crypto/openssh/auth2-hostbased.c

152

sshbuf_ptr(b), sshbuf_len(b), pkalg, ssh->compat, NULL) == 0)

crypto/openssh/auth2-pubkey.c

230

sshbuf_ptr(b), sshbuf_len(b),

crypto/openssh/auth2.c

418

userauth_send_banner(ssh, sshbuf_ptr(loginmsg));

crypto/openssh/channels.c

1466

p = sshbuf_ptr(input);

crypto/openssh/channels.c

1499

p = sshbuf_ptr(input);

crypto/openssh/channels.c

1517

p = sshbuf_ptr(input);

crypto/openssh/channels.c

1581

p = sshbuf_ptr(input);

crypto/openssh/channels.c

1735

p = sshbuf_ptr(c->input);

crypto/openssh/channels.c

1793

p = sshbuf_ptr(c->output);

crypto/openssh/channels.c

2293

len = write(c->efd, sshbuf_ptr(c->extended),

crypto/openssh/channels.c

2438

need = PEEK_U32(sshbuf_ptr(c->input));

crypto/openssh/channels.c

2466

len = write(c->wfd, sshbuf_ptr(c->output), sshbuf_len(c->output));

crypto/openssh/channels.c

3010

(r = sshpkt_put_string(ssh, sshbuf_ptr(c->input), len)) != 0 ||

crypto/openssh/channels.c

3045

(r = sshpkt_put_string(ssh, sshbuf_ptr(c->extended), len)) != 0 ||

crypto/openssh/clientloop.c

2402

sshbuf_ptr(signdata), sshbuf_len(signdata),

crypto/openssh/clientloop.c

2768

(int)len, (const u_char*)sshbuf_ptr(cmd));

crypto/openssh/clientloop.c

2774

(int)len, (const u_char*)sshbuf_ptr(cmd));

crypto/openssh/digest-libc.c

215

return ssh_digest_update(ctx, sshbuf_ptr(b), sshbuf_len(b));

crypto/openssh/digest-libc.c

265

return ssh_digest_memory(alg, sshbuf_ptr(b), sshbuf_len(b), d, dlen);

crypto/openssh/digest-openssl.c

155

return ssh_digest_update(ctx, sshbuf_ptr(b), sshbuf_len(b));

crypto/openssh/digest-openssl.c

205

return ssh_digest_memory(alg, sshbuf_ptr(b), sshbuf_len(b), d, dlen);

crypto/openssh/gss-genr.c

150

ret = xstrdup((const char *)sshbuf_ptr(b));

crypto/openssh/kex.c

1349

memcmp(sshbuf_ptr(peer_version), "SSH-", 4) == 0)

crypto/openssh/kexc25519.c

131

client_pub = sshbuf_ptr(client_blob);

crypto/openssh/kexc25519.c

152

dump_digest("encoded shared secret:", sshbuf_ptr(buf), sshbuf_len(buf));

crypto/openssh/kexc25519.c

179

server_pub = sshbuf_ptr(server_blob);

crypto/openssh/kexc25519.c

192

dump_digest("encoded shared secret:", sshbuf_ptr(buf), sshbuf_len(buf));

crypto/openssh/kexgexc.c

201

sshbuf_ptr(shared_secret), sshbuf_len(shared_secret),

crypto/openssh/kexgexs.c

179

sshbuf_ptr(shared_secret), sshbuf_len(shared_secret),

crypto/openssh/kexmlkem768x25519.c

117

client_pub = sshbuf_ptr(client_blob);

crypto/openssh/kexmlkem768x25519.c

164

sshbuf_ptr(buf), sshbuf_len(buf));

crypto/openssh/kexmlkem768x25519.c

172

dump_digest("encoded shared secret:", sshbuf_ptr(buf), sshbuf_len(buf));

crypto/openssh/kexmlkem768x25519.c

212

ciphertext = sshbuf_ptr(server_blob);

crypto/openssh/kexmlkem768x25519.c

241

sshbuf_ptr(buf), sshbuf_len(buf));

crypto/openssh/kexmlkem768x25519.c

248

dump_digest("encoded shared secret:", sshbuf_ptr(buf), sshbuf_len(buf));

crypto/openssh/kexsntrup761x25519.c

141

sshbuf_ptr(buf), sshbuf_len(buf));

crypto/openssh/kexsntrup761x25519.c

149

dump_digest("encoded shared secret:", sshbuf_ptr(buf), sshbuf_len(buf));

crypto/openssh/kexsntrup761x25519.c

181

ciphertext = sshbuf_ptr(server_blob);

crypto/openssh/kexsntrup761x25519.c

206

sshbuf_ptr(buf), sshbuf_len(buf));

crypto/openssh/kexsntrup761x25519.c

213

dump_digest("encoded shared secret:", sshbuf_ptr(buf), sshbuf_len(buf));

crypto/openssh/kexsntrup761x25519.c

99

client_pub = sshbuf_ptr(client_blob);

crypto/openssh/misc.c

2180

memcpy(ret, sshbuf_ptr(buf), sshbuf_len(buf));

crypto/openssh/monitor.c

1380

p = sshbuf_ptr(b);

crypto/openssh/monitor.c

1855

if (memcmp(sshbuf_ptr(ssh->kex->session_id), session_id2,

crypto/openssh/monitor.c

760

memcmp(p, sshbuf_ptr(sigbuf), sshbuf_len(sigbuf)) != 0)

crypto/openssh/mux.c

1519

ptr = sshbuf_ptr(queue);

crypto/openssh/mux.c

1574

need = PEEK_U32(sshbuf_ptr(queue));

crypto/openssh/packet.c

1186

type = (sshbuf_ptr(state->outgoing_packet))[5];

crypto/openssh/packet.c

1270

sshbuf_ptr(state->outgoing_packet), len,

crypto/openssh/packet.c

1280

sshbuf_ptr(state->outgoing_packet),

crypto/openssh/packet.c

1352

type = sshbuf_ptr(state->outgoing_packet)[5];

crypto/openssh/packet.c

1530

cp = sshbuf_ptr(state->input);

crypto/openssh/packet.c

1592

sshbuf_ptr(state->input), sshbuf_len(state->input)) != 0)

crypto/openssh/packet.c

1617

state->p_send.seqnr, cp, sshbuf_ptr(state->input),

crypto/openssh/packet.c

1620

state->packlen = PEEK_U32(sshbuf_ptr(state->incoming_packet));

crypto/openssh/packet.c

1673

sshbuf_ptr(state->input), aadlen + need,

crypto/openssh/packet.c

1674

sshbuf_ptr(state->input) + aadlen + need + authlen,

crypto/openssh/packet.c

1685

sshbuf_ptr(state->input), need, aadlen, authlen)) != 0)

crypto/openssh/packet.c

1692

sshbuf_ptr(state->incoming_packet),

crypto/openssh/packet.c

1694

sshbuf_ptr(state->input), maclen)) != 0) {

crypto/openssh/packet.c

1726

padlen = sshbuf_ptr(state->incoming_packet)[4];

crypto/openssh/packet.c

2114

sshbuf_ptr(state->output), len);

crypto/openssh/packet.c

2754

return sshbuf_ptr(ssh->state->incoming_packet);

crypto/openssh/packet.c

397

sshbuf_ptr(state->incoming_packet), dlen,

crypto/openssh/regress/misc/fuzz-harness/kex_fuzz.cc

354

if (fwrite(sshbuf_ptr(ts->smsgs), 1,

crypto/openssh/regress/misc/fuzz-harness/kex_fuzz.cc

365

if (fwrite(sshbuf_ptr(ts->cmsgs), 1,

crypto/openssh/regress/misc/fuzz-harness/kex_fuzz.cc

83

if ((r = ssh_input_append(server, sshbuf_ptr(ts->sin),

crypto/openssh/regress/misc/fuzz-harness/kex_fuzz.cc

91

if ((r = ssh_input_append(client, sshbuf_ptr(ts->cin),

crypto/openssh/regress/misc/ssh-verify-attestation/ssh-verify-attestation.c

114

fido_cred_set_clientdata(cred, sshbuf_ptr(challenge),

crypto/openssh/regress/misc/ssh-verify-attestation/ssh-verify-attestation.c

117

fido_cred_set_authdata(cred, sshbuf_ptr(authdata),

crypto/openssh/regress/misc/ssh-verify-attestation/ssh-verify-attestation.c

120

fido_cred_set_x509(cred, sshbuf_ptr(attestation_cert),

crypto/openssh/regress/misc/ssh-verify-attestation/ssh-verify-attestation.c

122

fido_cred_set_sig(cred, sshbuf_ptr(sig), sshbuf_len(sig));

crypto/openssh/regress/misc/ssh-verify-attestation/ssh-verify-attestation.c

426

sshbuf_ptr(attestation_cert), sshbuf_len(attestation_cert));

crypto/openssh/regress/unittests/sshbuf/test_sshbuf.c

105

cdp = sshbuf_ptr(p1);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf.c

122

cdp = sshbuf_ptr(p1);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf.c

127

cdp = sshbuf_ptr(p1);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf.c

156

cdp = sshbuf_ptr(p1);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf.c

196

cdp = sshbuf_ptr(p1);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf.c

218

cdp = sshbuf_ptr(p1);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_fixed.c

115

ASSERT_PTR_NE(sshbuf_ptr(p3), NULL);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_fixed.c

117

ASSERT_MEM_EQ(sshbuf_ptr(p3), test_buf, sizeof(test_buf) - 1);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_fixed.c

46

ASSERT_PTR_EQ(sshbuf_ptr(p1), test_buf);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_fixed.c

53

ASSERT_PTR_EQ(sshbuf_ptr(p1), test_buf);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_fixed.c

55

ASSERT_PTR_EQ(sshbuf_ptr(p1), test_buf + 1);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_fixed.c

58

ASSERT_PTR_EQ(sshbuf_ptr(p1), test_buf + 5);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_fixed.c

79

ASSERT_PTR_EQ(sshbuf_ptr(p2), sshbuf_ptr(p1));

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_fixed.c

80

ASSERT_PTR_NE(sshbuf_ptr(p1), NULL);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_fixed.c

81

ASSERT_PTR_NE(sshbuf_ptr(p2), NULL);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_fixed.c

86

ASSERT_PTR_EQ(sshbuf_ptr(p2), sshbuf_ptr(p1) + 1);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_fixed.c

89

ASSERT_PTR_EQ(sshbuf_ptr(p2), sshbuf_ptr(p1) + 5);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_fuzz.c

106

ASSERT_PTR_NE(sshbuf_ptr(p1), NULL);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_fuzz.c

107

ASSERT_MEM_ZERO_NE(sshbuf_ptr(p1), sshbuf_len(p1));

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_fuzz.c

124

ASSERT_PTR_NE(sshbuf_ptr(p1), NULL);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_fuzz.c

127

ASSERT_PTR_NE(sshbuf_ptr(p1), NULL);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_fuzz.c

128

ASSERT_MEM_ZERO_NE(sshbuf_ptr(p1), sshbuf_len(p1));

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_fuzz.c

46

ASSERT_PTR_NE(sshbuf_ptr(p1), NULL);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_fuzz.c

47

ASSERT_MEM_ZERO_NE(sshbuf_ptr(p1), sshbuf_len(p1));

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

101

ASSERT_U8_EQ(*(sshbuf_ptr(p1)), 0x55);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

204

ASSERT_MEM_EQ(sshbuf_ptr(p1), x, 8);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

214

ASSERT_MEM_EQ(sshbuf_ptr(p1), x, 8);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

233

ASSERT_MEM_EQ(sshbuf_ptr(p1), x, 4);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

243

ASSERT_MEM_EQ(sshbuf_ptr(p1), x, 4);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

262

ASSERT_MEM_EQ(sshbuf_ptr(p1), x, 2);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

272

ASSERT_MEM_EQ(sshbuf_ptr(p1), x, 2);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

383

ASSERT_U32_EQ(PEEK_U32(sshbuf_ptr(p1)), sizeof(x));

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

384

ASSERT_MEM_EQ(sshbuf_ptr(p1) + 4, x, sizeof(x));

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

413

ASSERT_MEM_EQ(sshbuf_ptr(p1), "hello 23 5f", 11);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

426

ASSERT_MEM_EQ(sshbuf_ptr(p2), "blahblahblah", 12);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

435

ASSERT_MEM_EQ(sshbuf_ptr(p1), bn_exp1, sizeof(bn_exp1));

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

444

ASSERT_MEM_EQ(sshbuf_ptr(p1), bn_exp1, sizeof(bn_exp1));

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

453

ASSERT_MEM_EQ(sshbuf_ptr(p1), bn_exp2, sizeof(bn_exp2));

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

462

ASSERT_MEM_EQ(sshbuf_ptr(p1), bn_exp2, sizeof(bn_exp2));

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

471

ASSERT_MEM_EQ(sshbuf_ptr(p1), bn_exp3, sizeof(bn_exp3));

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

480

ASSERT_MEM_EQ(sshbuf_ptr(p1), bn_exp3, sizeof(bn_exp3));

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

81

cd = sshbuf_ptr(p1);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_basic.c

94

ASSERT_U8_EQ(*(sshbuf_ptr(p1)), 0x55);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_crypto.c

110

ASSERT_U32_EQ(PEEK_U32(sshbuf_ptr(p1)), (u_int32_t)BN_num_bytes(bn) + 1);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_crypto.c

111

ASSERT_U8_EQ(*(sshbuf_ptr(p1) + 4), 0x00);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_crypto.c

112

ASSERT_MEM_EQ(sshbuf_ptr(p1) + 5, expbn2, sizeof(expbn2));

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_crypto.c

86

ASSERT_U32_EQ(PEEK_U32(sshbuf_ptr(p1)), (u_int32_t)BN_num_bytes(bn));

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_getput_crypto.c

87

ASSERT_MEM_EQ(sshbuf_ptr(p1) + 4, expbn1, sizeof(expbn1));

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_misc.c

116

ASSERT_U8_EQ(*sshbuf_ptr(p1), 0xd0);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_misc.c

125

ASSERT_U16_EQ(PEEK_U16(sshbuf_ptr(p1)), 0xd00f);

crypto/openssh/regress/unittests/sshbuf/test_sshbuf_misc.c

134

ASSERT_U32_EQ(PEEK_U32(sshbuf_ptr(p1)), 0xd00fd00f);

crypto/openssh/regress/unittests/sshkey/common.c

59

for (p = sshbuf_ptr(ret); sshbuf_len(ret) > 0;) {

crypto/openssh/regress/unittests/sshkey/common.c

81

ASSERT_INT_NE(BN_hex2bn(&ret, (const char *)sshbuf_ptr(buf)), 0);

crypto/openssh/regress/unittests/sshkey/test_file.c

142

ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));

crypto/openssh/regress/unittests/sshkey/test_file.c

151

ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));

crypto/openssh/regress/unittests/sshkey/test_file.c

161

ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));

crypto/openssh/regress/unittests/sshkey/test_file.c

188

(const char *)sshbuf_ptr(pw), &k2, NULL), 0);

crypto/openssh/regress/unittests/sshkey/test_file.c

207

(const char *)sshbuf_ptr(pw), &k2, NULL), 0);

crypto/openssh/regress/unittests/sshkey/test_file.c

234

ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));

crypto/openssh/regress/unittests/sshkey/test_file.c

243

ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));

crypto/openssh/regress/unittests/sshkey/test_file.c

253

ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));

crypto/openssh/regress/unittests/sshkey/test_file.c

268

ASSERT_STRING_EQ((const char *)sshbuf_ptr(buf),

crypto/openssh/regress/unittests/sshkey/test_file.c

290

(const char *)sshbuf_ptr(pw), &k2, NULL), 0);

crypto/openssh/regress/unittests/sshkey/test_file.c

309

(const char *)sshbuf_ptr(pw), &k2, NULL), 0);

crypto/openssh/regress/unittests/sshkey/test_file.c

336

ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));

crypto/openssh/regress/unittests/sshkey/test_file.c

345

ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));

crypto/openssh/regress/unittests/sshkey/test_file.c

355

ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));

crypto/openssh/regress/unittests/sshkey/test_file.c

376

(const char *)sshbuf_ptr(pw), &k2, NULL), 0);

crypto/openssh/regress/unittests/sshkey/test_file.c

403

ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));

crypto/openssh/regress/unittests/sshkey/test_file.c

412

ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));

crypto/openssh/regress/unittests/sshkey/test_file.c

422

ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));

crypto/openssh/regress/unittests/sshkey/test_file.c

442

(const char *)sshbuf_ptr(pw), &k2, NULL), 0);

crypto/openssh/regress/unittests/sshkey/test_file.c

469

ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));

crypto/openssh/regress/unittests/sshkey/test_file.c

478

ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));

crypto/openssh/regress/unittests/sshkey/test_file.c

488

ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));

crypto/openssh/regress/unittests/sshkey/test_file.c

508

(const char *)sshbuf_ptr(pw), &k2, NULL), 0);

crypto/openssh/regress/unittests/sshkey/test_file.c

535

ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));

crypto/openssh/regress/unittests/sshkey/test_file.c

544

ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));

crypto/openssh/regress/unittests/sshkey/test_file.c

554

ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));

crypto/openssh/regress/unittests/sshkey/test_file.c

78

(const char *)sshbuf_ptr(pw), &k2, NULL), 0);

crypto/openssh/regress/unittests/sshkey/test_file.c

97

(const char *)sshbuf_ptr(pw), &k2, NULL), 0);

crypto/openssh/regress/unittests/sshkey/test_fuzz.c

65

ASSERT_INT_EQ(sshkey_from_blob(sshbuf_ptr(buf), sshbuf_len(buf),

crypto/openssh/regress/unittests/sshkey/test_sshkey.c

106

sshbuf_ptr(b), sshbuf_len(b), sig_alg, NULL, NULL, 0), 0);

crypto/openssh/regress/unittests/sshkey/test_sshkey.c

456

ASSERT_INT_EQ(sshkey_from_blob(sshbuf_ptr(b), sshbuf_len(b), &k3), 0);

crypto/openssh/regress/unittests/sshkey/test_sshkey.c

531

ASSERT_INT_EQ(sshkey_from_blob(sshbuf_ptr(b), sshbuf_len(b), &k4),

crypto/openssh/serverloop.c

711

sshbuf_ptr(sigbuf), sshbuf_len(sigbuf), sigalg)) != 0 ||

crypto/openssh/session.c

266

printf("%s", (char *)sshbuf_ptr(loginmsg));

crypto/openssh/sftp-client.c

176

iov[1].iov_base = (u_char *)sshbuf_ptr(m);

crypto/openssh/sftp-server.c

1816

cp = sshbuf_ptr(iqueue);

crypto/openssh/sftp-server.c

2085

len = write(out, sshbuf_ptr(oqueue), olen);

crypto/openssh/ssh-agent.c

1748

if ((r = sshkey_verify(key, sshbuf_ptr(sig), sshbuf_len(sig),

crypto/openssh/ssh-agent.c

1749

sshbuf_ptr(sid), sshbuf_len(sid), NULL, 0, NULL)) != 0) {

crypto/openssh/ssh-agent.c

1846

cp = sshbuf_ptr(e->input);

crypto/openssh/ssh-agent.c

2040

sshbuf_ptr(sockets[socknum].output),

crypto/openssh/ssh-agent.c

849

if (sshbuf_ptr(a) == NULL || sshbuf_ptr(b) == NULL)

crypto/openssh/ssh-agent.c

853

if (timingsafe_bcmp(sshbuf_ptr(a), sshbuf_ptr(b), sshbuf_len(a)) != 0)

crypto/openssh/ssh-agent.c

966

sshbuf_ptr(data), sshbuf_len(data), agent_decode_alg(key, flags),

crypto/openssh/ssh-dss.c

316

memcpy(*sigp, sshbuf_ptr(b), len);

crypto/openssh/ssh-ecdsa-sk.c

217

if ((r = sshbuf_cmp(wrapper, 0, sshbuf_ptr(m), sshbuf_len(m))) != 0)

crypto/openssh/ssh-ecdsa-sk.c

404

sshbuf_ptr(original_signed), sshbuf_len(original_signed))) {

crypto/openssh/ssh-ecdsa.c

372

memcpy(*sigp, sshbuf_ptr(b), len);

crypto/openssh/ssh-ed25519-sk.c

219

sm = sshbuf_ptr(encoded);

crypto/openssh/ssh-ed25519.c

190

memcpy(*sigp, sshbuf_ptr(b), len);

crypto/openssh/ssh-keygen.c

2304

memcpy(*blobp, sshbuf_ptr(b), *lenp);

crypto/openssh/ssh-keygen.c

477

if (BN_bin2bn(sshbuf_ptr(b), bytes, value) == NULL)

crypto/openssh/ssh-pkcs11-helper.c

287

cp = sshbuf_ptr(iqueue);

crypto/openssh/ssh-pkcs11-helper.c

422

len = write(out, sshbuf_ptr(oqueue),

crypto/openssh/ssh-rsa.c

460

memcpy(*sigp, sshbuf_ptr(b), len);

crypto/openssh/ssh-sk.c

540

challenge = sshbuf_ptr(challenge_buf);

crypto/openssh/ssh-sk.c

701

sshbuf_ptr(key->sk_key_handle), sshbuf_len(key->sk_key_handle),

crypto/openssh/ssh-sk.c

741

memcpy(*sigp, sshbuf_ptr(sig), sshbuf_len(sig));

crypto/openssh/ssh-xmss.c

250

memcpy(*sigp, sshbuf_ptr(b), len);

crypto/openssh/ssh_api.c

319

return sshbuf_ptr(output);

crypto/openssh/ssh_api.c

346

const u_char *s = sshbuf_ptr(input);

crypto/openssh/ssh_api.c

373

memcmp(sshbuf_ptr(banner), "SSH-", 4) == 0)

crypto/openssh/ssh_api.c

376

sshbuf_ptr(banner));

crypto/openssh/sshbuf-getput-basic.c

102

if (sshbuf_ptr(buf) == NULL) /* calls sshbuf_check_sanity() */

crypto/openssh/sshbuf-getput-basic.c

122

*p = sshbuf_ptr(buf) + offset;

crypto/openssh/sshbuf-getput-basic.c

244

const u_char *p = sshbuf_ptr(buf);

crypto/openssh/sshbuf-getput-basic.c

343

return sshbuf_put(buf, sshbuf_ptr(v), sshbuf_len(v));

crypto/openssh/sshbuf-getput-basic.c

37

const u_char *p = sshbuf_ptr(buf);

crypto/openssh/sshbuf-getput-basic.c

50

const u_char *p = sshbuf_ptr(buf);

crypto/openssh/sshbuf-getput-basic.c

543

return sshbuf_put_string(buf, sshbuf_ptr(v), sshbuf_len(v));

crypto/openssh/sshbuf-getput-basic.c

63

const u_char *p = sshbuf_ptr(buf);

crypto/openssh/sshbuf-getput-basic.c

76

const u_char *p = sshbuf_ptr(buf);

crypto/openssh/sshbuf-getput-basic.c

89

const u_char *p = sshbuf_ptr(buf);

crypto/openssh/sshbuf-misc.c

107

if (b64_ntop(sshbuf_ptr(d), sshbuf_len(d), s, slen) == -1) {

crypto/openssh/sshbuf-misc.c

187

if (l <= 1 || sshbuf_ptr(b) == NULL) {

crypto/openssh/sshbuf-misc.c

191

if (sshbuf_ptr(b)[l - 1] != '=')

crypto/openssh/sshbuf-misc.c

217

const u_char *p = NULL, *s = sshbuf_ptr(buf);

crypto/openssh/sshbuf-misc.c

241

if (sshbuf_ptr(b) == NULL)

crypto/openssh/sshbuf-misc.c

247

if (timingsafe_bcmp(sshbuf_ptr(b) + offset, s, len) != 0)

crypto/openssh/sshbuf-misc.c

260

if (sshbuf_ptr(b) == NULL)

crypto/openssh/sshbuf-misc.c

266

if ((p = memmem(sshbuf_ptr(b) + start_offset,

crypto/openssh/sshbuf-misc.c

270

*offsetp = (const u_char *)p - sshbuf_ptr(b);

crypto/openssh/sshbuf-misc.c

70

sshbuf_dump_data(sshbuf_ptr(buf), sshbuf_len(buf), f);

crypto/openssh/sshbuf-misc.c

77

const u_char *p = sshbuf_ptr(buf);

crypto/openssh/sshbuf.c

151

if ((ret = sshbuf_from(sshbuf_ptr(buf), sshbuf_len(buf))) == NULL)

crypto/openssh/sshbuf.h

102

const u_char *sshbuf_ptr(const struct sshbuf *buf);

crypto/openssh/sshconnect2.c

1430

sshbuf_ptr(b), sshbuf_len(b), ssh->compat, alg);

crypto/openssh/sshconnect2.c

2229

sshbuf_ptr(b), sshbuf_len(b))) != 0) {

crypto/openssh/sshd.c

1061

ptr = sshbuf_ptr(buf);

crypto/openssh/sshd.c

1310

if (ssh_digest_update(ctx, sshbuf_ptr(server_cfg),

crypto/openssh/sshd.c

1327

if (ssh_digest_update(ctx, sshbuf_ptr(buf), sshbuf_len(buf)) != 0)

crypto/openssh/sshkey-xmss.c

1021

memcmp(sshbuf_ptr(encoded), XMSS_MAGIC, sizeof(XMSS_MAGIC))) {

crypto/openssh/sshkey-xmss.c

1053

(r = cipher_crypt(ciphercontext, 0, dp, sshbuf_ptr(copy),

crypto/openssh/sshkey-xmss.c

960

(r = cipher_crypt(ciphercontext, 0, cp, sshbuf_ptr(encoded),

crypto/openssh/sshkey.c

1440

if (fwrite(sshbuf_ptr(b), sshbuf_len(b), 1, f) != 1) {

crypto/openssh/sshkey.c

1710

sshbuf_ptr(prvbuf), sshbuf_len(prvbuf), 0, 0)) != 0)

crypto/openssh/sshkey.c

1975

sshbuf_ptr(key->cert->certblob), signed_len, NULL, 0, NULL)) != 0)

crypto/openssh/sshkey.c

2360

if ((ret = signer(ca, &sig_blob, &sig_len, sshbuf_ptr(cert),

crypto/openssh/sshkey.c

2938

sshbuf_ptr(encrypted), sshbuf_len(encrypted), 0, authlen)) != 0)

crypto/openssh/sshkey.c

2986

cp = sshbuf_ptr(blob);

crypto/openssh/sshkey.c

3021

if ((r = sshbuf_b64tod(decoded, (char *)sshbuf_ptr(encoded))) != 0)

crypto/openssh/sshkey.c

3026

memcmp(sshbuf_ptr(decoded), AUTH_MAGIC, sizeof(AUTH_MAGIC))) {

crypto/openssh/sshkey.c

3140

if ((r = cipher_crypt(ciphercontext, 0, dp, sshbuf_ptr(decoded),

crypto/openssh/sshkey.c

3537

if (BIO_write(bio, sshbuf_ptr(blob), sshbuf_len(blob)) !=

crypto/openssh/sshkey.c

818

if (timingsafe_bcmp(sshbuf_ptr(a->certblob), sshbuf_ptr(b->certblob),

crypto/openssh/sshkey.c

967

memcpy(*blobp, sshbuf_ptr(b), len);

crypto/openssh/sshsig.c

203

sshbuf_ptr(tosign), sshbuf_len(tosign),

crypto/openssh/sshsig.c

210

sshbuf_ptr(tosign), sshbuf_len(tosign),

crypto/openssh/sshsig.c

383

if ((r = sshkey_verify(key, sig, siglen, sshbuf_ptr(toverify),