lib/libc/gen/getgrent.c

292

int keylen, datalen;

lib/libc/gen/getgrent.c

311

&key, &keylen, &data, &datalen);

lib/libc/gen/getgrent.c

314

__ypcurrentlen = keylen;

lib/libc/gen/getpwent.c

332

int keylen, datalen, r, s;

lib/libc/gen/getpwent.c

342

&key, &keylen, &data, &datalen);

lib/libc/gen/getpwent.c

351

__ypcurrentlen = keylen;

lib/libc/gen/getpwent.c

517

int keylen, resultlen;

lib/libc/gen/getpwent.c

541

&key, &keylen, &result, &resultlen)) {

lib/libc/yp/ypmatch_cache.c

101

ep->keylen = keylen;

lib/libc/yp/ypmatch_cache.c

108

ypmatch_find(const char *map, const char *key, u_int keylen, char **val,

lib/libc/yp/ypmatch_cache.c

120

if (ep->keylen != keylen)

lib/libc/yp/ypmatch_cache.c

124

if (memcmp(ep->key, key, keylen))

lib/libc/yp/ypmatch_cache.c

46

int keylen, vallen;

lib/libc/yp/ypmatch_cache.c

53

ypmatch_add(const char *map, const char *key, u_int keylen, char *val,

lib/libc/yp/ypmatch_cache.c

60

if (keylen == 0 || vallen == 0)

lib/libc/yp/ypmatch_cache.c

67

(newkey = malloc(keylen)) == NULL ||

lib/libc/yp/ypmatch_cache.c

96

(void)memcpy(newkey, key, keylen);

lib/libcrypto/asn1/p5_pbev2.c

197

int alg_nid, keylen;

lib/libcrypto/asn1/p5_pbev2.c

239

keylen = EVP_CIPHER_key_length(cipher);

lib/libcrypto/asn1/p5_pbev2.c

241

keylen = -1;

lib/libcrypto/asn1/p5_pbev2.c

247

pbe2->keyfunc = PKCS5_pbkdf2_set(iter, salt, saltlen, prf_nid, keylen);

lib/libcrypto/asn1/p5_pbev2.c

286

int keylen)

lib/libcrypto/asn1/p5_pbev2.c

320

if (keylen > 0) {

lib/libcrypto/asn1/p5_pbev2.c

323

if (!ASN1_INTEGER_set(kdf->keylength, keylen))

lib/libcrypto/cmac/cm_pmeth.c

189

long keylen;

lib/libcrypto/cmac/cm_pmeth.c

191

key = string_to_hex(value, &keylen);

lib/libcrypto/cmac/cm_pmeth.c

194

r = pkey_cmac_ctrl(ctx, EVP_PKEY_CTRL_SET_MAC_KEY, keylen, key);

lib/libcrypto/cmac/cmac.c

182

CMAC_Init(CMAC_CTX *ctx, const void *key, size_t keylen,

lib/libcrypto/cmac/cmac.c

189

if (key == NULL && cipher == NULL && keylen == 0) {

lib/libcrypto/cmac/cmac.c

227

if (!EVP_CIPHER_CTX_set_key_length(ctx->cipher_ctx, keylen))

lib/libcrypto/cmac/cmac.h

73

int CMAC_Init(CMAC_CTX *ctx, const void *key, size_t keylen,

lib/libcrypto/cms/cms.h

178

size_t keylen, BIO *dcont, BIO *out, unsigned int flags);

lib/libcrypto/cms/cms.h

181

const unsigned char *key, size_t keylen, unsigned int flags);

lib/libcrypto/cms/cms.h

184

const unsigned char *key, size_t keylen);

lib/libcrypto/cms/cms.h

202

size_t keylen, const unsigned char *id, size_t idlen);

lib/libcrypto/cms/cms.h

220

unsigned char *key, size_t keylen, unsigned char *id, size_t idlen,

lib/libcrypto/cms/cms.h

228

size_t keylen);

lib/libcrypto/cms/cms.h

349

ASN1_OCTET_STRING *ukm, int keylen);

lib/libcrypto/cms/cms_asn1.c

1600

ASN1_OCTET_STRING *ukm, int keylen)

lib/libcrypto/cms/cms_asn1.c

1613

keylen <<= 3;

lib/libcrypto/cms/cms_asn1.c

1614

kl[0] = (keylen >> 24) & 0xff;

lib/libcrypto/cms/cms_asn1.c

1615

kl[1] = (keylen >> 16) & 0xff;

lib/libcrypto/cms/cms_asn1.c

1616

kl[2] = (keylen >> 8) & 0xff;

lib/libcrypto/cms/cms_asn1.c

1617

kl[3] = keylen & 0xff;

lib/libcrypto/cms/cms_asn1.c

940

freezero(kekri->key, kekri->keylen);

lib/libcrypto/cms/cms_enc.c

146

ec->keylen = tkeylen;

lib/libcrypto/cms/cms_enc.c

155

if (ec->keylen != tkeylen) {

lib/libcrypto/cms/cms_enc.c

157

if (!EVP_CIPHER_CTX_set_key_length(ctx, ec->keylen)) {

lib/libcrypto/cms/cms_enc.c

167

freezero(ec->key, ec->keylen);

lib/libcrypto/cms/cms_enc.c

169

ec->keylen = tkeylen;

lib/libcrypto/cms/cms_enc.c

200

freezero(ec->key, ec->keylen);

lib/libcrypto/cms/cms_enc.c

212

const EVP_CIPHER *cipher, const unsigned char *key, size_t keylen)

lib/libcrypto/cms/cms_enc.c

216

if ((ec->key = malloc(keylen)) == NULL) {

lib/libcrypto/cms/cms_enc.c

220

memcpy(ec->key, key, keylen);

lib/libcrypto/cms/cms_enc.c

222

ec->keylen = keylen;

lib/libcrypto/cms/cms_enc.c

231

const unsigned char *key, size_t keylen)

lib/libcrypto/cms/cms_enc.c

235

if (!key || !keylen) {

lib/libcrypto/cms/cms_enc.c

253

return cms_EncryptedContent_init(ec, ciph, key, keylen);

lib/libcrypto/cms/cms_env.c

405

if (EVP_PKEY_encrypt(pctx, NULL, &eklen, ec->key, ec->keylen) <= 0)

lib/libcrypto/cms/cms_env.c

415

if (EVP_PKEY_encrypt(pctx, ek, &eklen, ec->key, ec->keylen) <= 0)

lib/libcrypto/cms/cms_env.c

502

freezero(ec->key, ec->keylen);

lib/libcrypto/cms/cms_env.c

504

ec->keylen = eklen;

lib/libcrypto/cms/cms_env.c

560

size_t keylen, unsigned char *id, size_t idlen, ASN1_GENERALIZEDTIME *date,

lib/libcrypto/cms/cms_env.c

572

switch (keylen) {

lib/libcrypto/cms/cms_env.c

599

if (keylen != exp_keylen) {

lib/libcrypto/cms/cms_env.c

632

kekri->keylen = keylen;

lib/libcrypto/cms/cms_env.c

693

size_t keylen)

lib/libcrypto/cms/cms_env.c

704

kekri->keylen = keylen;

lib/libcrypto/cms/cms_env.c

729

if (AES_set_encrypt_key(kekri->key, kekri->keylen << 3, &actx)) {

lib/libcrypto/cms/cms_env.c

734

wkey = malloc(ec->keylen + 8);

lib/libcrypto/cms/cms_env.c

740

wkeylen = AES_wrap_key(&actx, NULL, wkey, ec->key, ec->keylen);

lib/libcrypto/cms/cms_env.c

779

if (aes_wrap_keylen(wrap_nid) != kekri->keylen) {

lib/libcrypto/cms/cms_env.c

791

if (AES_set_decrypt_key(kekri->key, kekri->keylen << 3, &actx)) {

lib/libcrypto/cms/cms_env.c

810

freezero(ec->key, ec->keylen);

lib/libcrypto/cms/cms_env.c

812

ec->keylen = ukeylen;

lib/libcrypto/cms/cms_env.c

972

freezero(ec->key, ec->keylen);

lib/libcrypto/cms/cms_env.c

974

ec->keylen = 0;

lib/libcrypto/cms/cms_kari.c

307

freezero(ec->key, ec->keylen);

lib/libcrypto/cms/cms_kari.c

309

ec->keylen = ceklen;

lib/libcrypto/cms/cms_kari.c

406

int keylen = EVP_CIPHER_key_length(cipher);

lib/libcrypto/cms/cms_kari.c

431

if (keylen <= 16)

lib/libcrypto/cms/cms_kari.c

433

else if (keylen <= 24)

lib/libcrypto/cms/cms_kari.c

483

if (!cms_kek_cipher(&enckey, &enckeylen, ec->key, ec->keylen,

lib/libcrypto/cms/cms_local.h

172

size_t keylen;

lib/libcrypto/cms/cms_local.h

258

size_t keylen;

lib/libcrypto/cms/cms_local.h

435

const EVP_CIPHER *cipher, const unsigned char *key, size_t keylen);

lib/libcrypto/cms/cms_pwri.c

340

size_t keylen;

lib/libcrypto/cms/cms_pwri.c

401

if (!kek_wrap_key(NULL, &keylen, ec->key, ec->keylen, kekctx))

lib/libcrypto/cms/cms_pwri.c

404

key = malloc(keylen);

lib/libcrypto/cms/cms_pwri.c

408

if (!kek_wrap_key(key, &keylen, ec->key, ec->keylen, kekctx))

lib/libcrypto/cms/cms_pwri.c

411

pwri->encryptedKey->length = keylen;

lib/libcrypto/cms/cms_pwri.c

418

if (!kek_unwrap_key(key, &keylen, pwri->encryptedKey->data,

lib/libcrypto/cms/cms_pwri.c

424

freezero(ec->key, ec->keylen);

lib/libcrypto/cms/cms_pwri.c

426

ec->keylen = keylen;

lib/libcrypto/cms/cms_smime.c

251

size_t keylen, BIO *dcont, BIO *out, unsigned int flags)

lib/libcrypto/cms/cms_smime.c

264

if (CMS_EncryptedData_set1_key(cms, NULL, key, keylen) <= 0)

lib/libcrypto/cms/cms_smime.c

278

const unsigned char *key, size_t keylen, unsigned int flags)

lib/libcrypto/cms/cms_smime.c

290

if (!CMS_EncryptedData_set1_key(cms, cipher, key, keylen))

lib/libcrypto/cms/cms_smime.c

774

CMS_decrypt_set1_key(CMS_ContentInfo *cms, unsigned char *key, size_t keylen,

lib/libcrypto/cms/cms_smime.c

792

CMS_RecipientInfo_set0_key(ri, key, keylen);

lib/libcrypto/dh/dh_pmeth.c

233

pkey_dh_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen)

lib/libcrypto/dh/dh_pmeth.c

245

*keylen = ret;

lib/libcrypto/ec/ec_ameth.c

802

int plen, keylen;

lib/libcrypto/ec/ec_ameth.c

844

keylen = EVP_CIPHER_CTX_key_length(kekctx);

lib/libcrypto/ec/ec_ameth.c

845

if (EVP_PKEY_CTX_set_ecdh_kdf_outlen(pctx, keylen) <= 0)

lib/libcrypto/ec/ec_ameth.c

848

if ((plen = CMS_SharedInfo_encode(&der, kekalg, ukm, keylen)) <= 0)

lib/libcrypto/ec/ec_ameth.c

903

int keylen;

lib/libcrypto/ec/ec_ameth.c

974

keylen = EVP_CIPHER_CTX_key_length(ctx);

lib/libcrypto/ec/ec_ameth.c

996

if ((penclen = CMS_SharedInfo_encode(&penc, wrap_alg, ukm, keylen)) <= 0)

lib/libcrypto/ec/ec_ameth.c

999

if (EVP_PKEY_CTX_set_ecdh_kdf_outlen(pctx, keylen) <= 0)

lib/libcrypto/ec/ec_pmeth.c

210

pkey_ec_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen)

lib/libcrypto/ec/ec_pmeth.c

225

*keylen = BN_num_bytes(eckey->group->p);

lib/libcrypto/ec/ec_pmeth.c

235

outlen = *keylen;

lib/libcrypto/ec/ec_pmeth.c

241

*keylen = ret;

lib/libcrypto/ec/ec_pmeth.c

247

pkey_ec_kdf_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen)

lib/libcrypto/ec/ec_pmeth.c

255

return pkey_ec_derive(ctx, key, keylen);

lib/libcrypto/ec/ec_pmeth.c

258

*keylen = dctx->kdf_outlen;

lib/libcrypto/ec/ec_pmeth.c

261

if (*keylen != dctx->kdf_outlen)

lib/libcrypto/ec/ec_pmeth.c

272

if (!ecdh_KDF_X9_63(key, *keylen, ktmp, ktmplen, dctx->kdf_ukm,

lib/libcrypto/evp/evp.h

552

int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *x, int keylen);

lib/libcrypto/evp/evp.h

835

const unsigned char *salt, int saltlen, int iter, int keylen,

lib/libcrypto/evp/evp.h

838

int saltlen, int iter, const EVP_MD *digest, int keylen,

lib/libcrypto/evp/evp.h

942

int keylen);

lib/libcrypto/evp/evp.h

973

int EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);

lib/libcrypto/evp/evp_local.h

312

int (*derive)(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);

lib/libcrypto/evp/evp_pbe.c

331

int saltlen, int iter, const EVP_MD *digest, int keylen, unsigned char *out)

lib/libcrypto/evp/evp_pbe.c

344

tkeylen = keylen;

lib/libcrypto/evp/evp_pbe.c

405

int saltlen, int iter, int keylen, unsigned char *out)

lib/libcrypto/evp/evp_pbe.c

408

EVP_sha1(), keylen, out);

lib/libcrypto/evp/evp_pbe.c

512

unsigned int keylen = 0;

lib/libcrypto/evp/evp_pbe.c

522

keylen = EVP_CIPHER_CTX_key_length(ctx);

lib/libcrypto/evp/evp_pbe.c

523

if (keylen > sizeof key) {

lib/libcrypto/evp/evp_pbe.c

546

(ASN1_INTEGER_get(kdf->keylength) != (int)keylen)){

lib/libcrypto/evp/evp_pbe.c

580

keylen, key))

lib/libcrypto/evp/evp_pbe.c

586

explicit_bzero(key, keylen);

lib/libcrypto/evp/pmeth_gn.c

207

EVP_PKEY_new_mac_key(int type, ENGINE *e, const unsigned char *key, int keylen)

lib/libcrypto/evp/pmeth_gn.c

218

EVP_PKEY_CTRL_SET_MAC_KEY, keylen, (void *)key) <= 0)

lib/libcrypto/hmac/hm_pmeth.c

236

long keylen;

lib/libcrypto/hmac/hm_pmeth.c

237

key = string_to_hex(value, &keylen);

lib/libcrypto/hmac/hm_pmeth.c

240

r = pkey_hmac_ctrl(ctx, EVP_PKEY_CTRL_SET_MAC_KEY, keylen, key);

lib/libcrypto/kdf/hkdf_evp.c

231

size_t *keylen)

lib/libcrypto/kdf/hkdf_evp.c

246

return HKDF(key, *keylen, kctx->md, kctx->key, kctx->key_len,

lib/libcrypto/kdf/hkdf_evp.c

251

*keylen = EVP_MD_size(kctx->md);

lib/libcrypto/kdf/hkdf_evp.c

254

return HKDF_extract(key, keylen, kctx->md, kctx->key,

lib/libcrypto/kdf/hkdf_evp.c

258

return HKDF_expand(key, *keylen, kctx->md, kctx->key,

lib/libcrypto/kdf/kdf.h

100

EVP_PKEY_CTRL_HKDF_KEY, keylen, (void *)(key))

lib/libcrypto/kdf/kdf.h

98

# define EVP_PKEY_CTX_set1_hkdf_key(pctx, key, keylen) \

lib/libcrypto/pem/pvkfmt.c

729

unsigned int keylen, pem_password_cb *cb, void *u)

lib/libcrypto/pem/pvkfmt.c

754

enctmp = malloc(keylen + 8);

lib/libcrypto/pem/pvkfmt.c

767

if (keylen < 8) {

lib/libcrypto/pem/pvkfmt.c

771

inlen = keylen - 8;

lib/libcrypto/pem/pvkfmt.c

802

ret = b2i_PrivateKey(&p, keylen);

lib/libcrypto/pem/pvkfmt.c

819

unsigned int saltlen, keylen;

lib/libcrypto/pem/pvkfmt.c

827

if (!do_PVK_header(&p, 24, 0, &saltlen, &keylen))

lib/libcrypto/pem/pvkfmt.c

829

buflen = keylen + saltlen;

lib/libcrypto/pem/pvkfmt.c

840

ret = do_PVK_body(&p, saltlen, keylen, cb, u);

lib/libcrypto/pkcs7/pk7_doit.c

145

pkcs7_encode_rinfo(PKCS7_RECIP_INFO *ri, unsigned char *key, int keylen)

lib/libcrypto/pkcs7/pk7_doit.c

170

if (EVP_PKEY_encrypt(pctx, NULL, &eklen, key, keylen) <= 0)

lib/libcrypto/pkcs7/pk7_doit.c

180

if (EVP_PKEY_encrypt(pctx, ek, &eklen, key, keylen) <= 0)

lib/libcrypto/pkcs7/pk7_doit.c

335

int keylen, ivlen;

lib/libcrypto/pkcs7/pk7_doit.c

343

keylen = EVP_CIPHER_key_length(evp_cipher);

lib/libcrypto/pkcs7/pk7_doit.c

369

if (pkcs7_encode_rinfo(ri, key, keylen) <= 0)

lib/libcrypto/pkcs7/pk7_doit.c

372

explicit_bzero(key, keylen);

lib/libcrypto/x509/x509_addr.c

1066

size_t keylen;

lib/libcrypto/x509/x509_addr.c

1084

if (!CBB_finish(&cbb, &key, &keylen))

lib/libcrypto/x509/x509_addr.c

1092

if (CBS_mem_equal(&cbs, key, keylen))

lib/libcrypto/x509/x509_addr.c

1098

if (!ASN1_OCTET_STRING_set(af->addressFamily, key, keylen))

lib/libcrypto/x509/x509_local.h

421

int prf_nid, int keylen);

lib/libexpat/lib/xmlparse.c

237

static size_t keylen(KEY s);

lib/libexpat/lib/xmlparse.c

4155

sip24_update(&sip_state, s, keylen(s) * sizeof(XML_Char));

lib/libexpat/lib/xmlparse.c

7856

sip24_update(&state, s, keylen(s) * sizeof(XML_Char));

lib/libfido2/src/ecdh.c

40

size_t keylen = SHA256_DIGEST_LENGTH;

lib/libfido2/src/ecdh.c

63

if (EVP_PKEY_derive(ctx, key, &keylen) < 1) {

lib/libfido2/src/eddsa.c

16

size_t keylen)

lib/libfido2/src/eddsa.c

21

(void)keylen;

lib/libssl/tls1.h

366

#define SSL_CTX_get_tlsext_ticket_keys(ctx, keys, keylen) \

lib/libssl/tls1.h

367

SSL_CTX_ctrl((ctx),SSL_CTRL_GET_TLSEXT_TICKET_KEYS,(keylen),(keys))

lib/libssl/tls1.h

368

#define SSL_CTX_set_tlsext_ticket_keys(ctx, keys, keylen) \

lib/libssl/tls1.h

369

SSL_CTX_ctrl((ctx),SSL_CTRL_SET_TLSEXT_TICKET_KEYS,(keylen),(keys))

lib/libtls/tls_config.c

535

int keylen;

lib/libtls/tls_config.c

538

keylen = 0;

lib/libtls/tls_config.c

540

keylen = -1;

lib/libtls/tls_config.c

542

keylen = 1024;

lib/libtls/tls_config.c

549

config->dheparams = keylen;

lib/libtls/tls_config.c

898

unsigned char *key, size_t keylen)

lib/libtls/tls_config.c

903

if (TLS_TICKET_KEY_SIZE != keylen ||

lib/libtls/tls_config.c

904

sizeof(newkey.aes_key) + sizeof(newkey.hmac_key) > keylen) {

lib/libutil/bcrypt_pbkdf.c

109

size_t origkeylen = keylen;

lib/libutil/bcrypt_pbkdf.c

114

if (passlen == 0 || saltlen == 0 || keylen == 0 ||

lib/libutil/bcrypt_pbkdf.c

115

keylen > sizeof(out) * sizeof(out))

lib/libutil/bcrypt_pbkdf.c

117

stride = (keylen + sizeof(out) - 1) / sizeof(out);

lib/libutil/bcrypt_pbkdf.c

118

amt = (keylen + stride - 1) / stride;

lib/libutil/bcrypt_pbkdf.c

127

for (count = 1; keylen > 0; count++) {

lib/libutil/bcrypt_pbkdf.c

154

amt = MINIMUM(amt, keylen);

lib/libutil/bcrypt_pbkdf.c

161

keylen -= i;

lib/libutil/bcrypt_pbkdf.c

173

arc4random_buf(key, keylen);

lib/libutil/bcrypt_pbkdf.c

99

uint8_t *key, size_t keylen, unsigned int rounds)

regress/lib/libcrypto/aeswrap/aes_wrap.c

66

const unsigned char *key, int keylen)

regress/lib/libcrypto/aeswrap/aes_wrap.c

72

otmp = malloc(keylen + 8);

regress/lib/libcrypto/aeswrap/aes_wrap.c

73

ptmp = malloc(keylen);

regress/lib/libcrypto/aeswrap/aes_wrap.c

78

r = AES_wrap_key(&wctx, iv, otmp, key, keylen);

regress/lib/libcrypto/aeswrap/aes_wrap.c

82

if (eout && memcmp(eout, otmp, keylen))

regress/lib/libcrypto/aeswrap/aes_wrap.c

91

if (memcmp(key, ptmp, keylen))

regress/lib/libcrypto/pbkdf2/pbkdf2.c

138

size_t keylen;

regress/lib/libcrypto/pbkdf2/pbkdf2.c

147

keylen = strlen(hex);

regress/lib/libcrypto/pbkdf2/pbkdf2.c

148

if ((keylen % 2) != 0) {

regress/lib/libcrypto/pbkdf2/pbkdf2.c

152

keylen /= 2;

regress/lib/libcrypto/pbkdf2/pbkdf2.c

153

expected = malloc(keylen);

regress/lib/libcrypto/pbkdf2/pbkdf2.c

154

out = malloc(keylen);

regress/lib/libcrypto/pbkdf2/pbkdf2.c

159

if (convert(expected, (const unsigned char *)hex, keylen) != 0) {

regress/lib/libcrypto/pbkdf2/pbkdf2.c

166

test->iter, digest, keylen, out);

regress/lib/libcrypto/pbkdf2/pbkdf2.c

173

if (memcmp(expected, out, keylen) != 0) {

regress/lib/libcrypto/pbkdf2/pbkdf2.c

177

hexdump(stderr, "expected: ", expected, keylen);

regress/lib/libcrypto/pbkdf2/pbkdf2.c

178

hexdump(stderr, "result: ", out, keylen);

regress/lib/libutil/bcrypt_pbkdf/bcrypt_pbkdf_test.c

111

printkey(const uint8_t *key, size_t keylen)

regress/lib/libutil/bcrypt_pbkdf/bcrypt_pbkdf_test.c

115

for (k = 0; k < keylen; k++) {

regress/lib/libutil/bcrypt_pbkdf/bcrypt_pbkdf_test.c

144

key, t->keylen, t->rounds);

regress/lib/libutil/bcrypt_pbkdf/bcrypt_pbkdf_test.c

145

if (memcmp(key, t->key, t->keylen) != 0) {

regress/lib/libutil/bcrypt_pbkdf/bcrypt_pbkdf_test.c

148

printkey(t->key, t->keylen);

regress/lib/libutil/bcrypt_pbkdf/bcrypt_pbkdf_test.c

150

printkey(key, t->keylen);

regress/lib/libutil/bcrypt_pbkdf/bcrypt_pbkdf_test.c

30

size_t keylen;

regress/sys/crypto/aes/aestest.c

141

do_tests(const char *filename, int test_num, u_char *key, u_int keylen,

regress/sys/crypto/aes/aestest.c

148

if (docrypt(key, keylen, plaintext, result, textlen, 1) < 0) {

regress/sys/crypto/aes/aestest.c

157

if (docrypt(key, keylen, ciphertext, result, textlen, 0) < 0) {

regress/sys/crypto/aes/aestest.c

176

u_int keylen, textlen, tmp;

regress/sys/crypto/aes/aestest.c

182

keylen = textlen = tmp = 0;

regress/sys/crypto/aes/aestest.c

242

parsehex(cp, &key, &keylen);

regress/sys/crypto/aes/aestest.c

243

if (keylen * 8 != (u_int)keysize)

regress/sys/crypto/aes/aestest.c

255

fail += do_tests(filename, test, key, keylen,

sbin/iked/crypto.c

307

hash_setkey(struct iked_hash *hash, void *key, size_t keylen)

sbin/iked/crypto.c

310

if ((hash->hash_key = ibuf_new(key, keylen)) == NULL) {

sbin/iked/crypto.c

488

cipher_setkey(struct iked_cipher *encr, const void *key, size_t keylen)

sbin/iked/crypto.c

491

if ((encr->encr_key = ibuf_new(key, keylen)) == NULL) {

sbin/iked/crypto.c

775

dsa_setkey(struct iked_dsa *dsa, void *key, size_t keylen, uint8_t type)

sbin/iked/crypto.c

784

if ((dsa->dsa_keydata = ibuf_new(key, keylen)) == NULL) {

sbin/iked/crypto.c

789

if ((rawcert = BIO_new_mem_buf(key, keylen)) == NULL)

sbin/iked/ikev2_msg.c

1007

ssize_t keylen;

sbin/iked/ikev2_msg.c

1029

if ((keylen = ikev2_psk(sa, auth->auth_data,

sbin/iked/ikev2_msg.c

1043

keylen = ibuf_size(id->id_buf);

sbin/iked/ikev2_msg.c

1049

print_map(auth->auth_method, ikev2_auth_map), keylen,

sbin/iked/ikev2_msg.c

1052

if (dsa_setkey(dsa, key, keylen, keytype) == NULL ||

sbin/iked/ikev2_msg.c

1080

ssize_t keylen, siglen;

sbin/iked/ikev2_msg.c

1104

if ((keylen = ikev2_psk(sa, auth->auth_data,

sbin/iked/ikev2_msg.c

1118

keylen = ibuf_size(id->id_buf);

sbin/iked/ikev2_msg.c

1123

if (dsa_setkey(dsa, key, keylen, keytype) == NULL ||

sbin/isakmpd/dnssec.c

226

*keylen = key_rr.datalen;

sbin/isakmpd/dnssec.c

237

dns_RSA_dns_to_x509(u_int8_t *key, int keylen, RSA **rsa_key)

sbin/isakmpd/dnssec.c

243

if (!key || keylen <= 0) {

sbin/isakmpd/dnssec.c

257

if (keylen < 3) {

sbin/isakmpd/dnssec.c

265

if (e_len > (keylen - key_offset)) {

sbin/isakmpd/dnssec.c

275

rsa->n = BN_bin2bn(key + key_offset, keylen - key_offset, NULL);

sbin/isakmpd/dnssec.c

286

dns_RSA_x509_to_dns(RSA *rsa_key, u_int8_t *key, int *keylen)

sbin/isakmpd/dnssec.c

64

dns_get_key(int type, struct message *msg, int *keylen)

sbin/isakmpd/ike_auth.c

134

ike_auth_get_key(int type, char *id, char *local_id, size_t *keylen)

sbin/isakmpd/ike_auth.c

158

*keylen = (strlen(key) - 1) / 2;

sbin/isakmpd/ike_auth.c

159

buf = malloc(*keylen);

sbin/isakmpd/ike_auth.c

162

"failed", (unsigned long)*keylen);

sbin/isakmpd/ike_auth.c

165

if (hex2raw(key + 2, (unsigned char *)buf, *keylen)) {

sbin/isakmpd/ike_auth.c

179

*keylen = strlen(key);

sbin/isakmpd/ike_auth.c

344

size_t keylen;

sbin/isakmpd/ike_auth.c

392

(char *)buf, &keylen);

sbin/isakmpd/ike_auth.c

400

exchange->recv_key = calloc(keylen + 1, sizeof(char));

sbin/isakmpd/ike_auth.c

404

(unsigned long)keylen);

sbin/isakmpd/ike_auth.c

408

memcpy(exchange->recv_key, key, keylen);

sbin/isakmpd/ike_auth.c

413

keylen);

sbin/isakmpd/ike_phase_1.c

703

u_int16_t len, keylen;

sbin/isakmpd/ike_phase_1.c

713

keylen = exchange->key_length;

sbin/isakmpd/ike_phase_1.c

714

if (keylen % prf->blocksize)

sbin/isakmpd/ike_phase_1.c

715

keylen += prf->blocksize - (keylen % prf->blocksize);

sbin/isakmpd/ike_phase_1.c

717

key = malloc(keylen);

sbin/isakmpd/ike_phase_1.c

722

"malloc (%d) failed", keylen);

sbin/isakmpd/ipsec.c

1549

iproto->keylen = decode_16(value);

sbin/isakmpd/ipsec.c

1875

if (!iproto->keylen)

sbin/isakmpd/ipsec.c

1877

return iproto->keylen / 8;

sbin/isakmpd/ipsec.c

1881

if (!iproto->keylen)

sbin/isakmpd/ipsec.c

1883

return iproto->keylen / 8 + 4;

sbin/isakmpd/ipsec.c

1885

if (!iproto->keylen)

sbin/isakmpd/ipsec.c

1889

return iproto->keylen / 8;

sbin/isakmpd/ipsec.h

134

u_int16_t keylen;

sbin/isakmpd/pf_key_v2.c

1020

keylen = 0;

sbin/isakmpd/pf_key_v2.c

1202

IPSEC_PROTO_IPSEC_ESP ? keylen : 0),

sbin/isakmpd/pf_key_v2.c

1209

if (keylen) {

sbin/isakmpd/pf_key_v2.c

1210

len = sizeof *key + PF_KEY_V2_ROUND(keylen);

sbin/isakmpd/pf_key_v2.c

1216

key->sadb_key_bits = keylen * 8;

sbin/isakmpd/pf_key_v2.c

1218

memcpy(key + 1, iproto->keymat[incoming], keylen);

sbin/isakmpd/pf_key_v2.c

886

int keylen, hashlen, err;

sbin/isakmpd/pf_key_v2.c

899

keylen = ipsec_esp_enckeylength(proto);

sbin/isakmpd/pf_key_v2.c

982

keylen = 0;

sbin/isakmpd/sa.c

541

int keylen, hashlen;

sbin/isakmpd/sa.c

545

keylen = ipsec_esp_enckeylength(proto);

sbin/isakmpd/sa.c

548

fprintf(fd, "Encryption key length: %d\n", keylen);

sbin/mount_vnd/mount_vnd.c

108

if (key == NULL || (keylen = strlen(key)) == 0)

sbin/mount_vnd/mount_vnd.c

112

keylen = BLF_MAXUTILIZED;

sbin/mount_vnd/mount_vnd.c

114

rv = config(argv[1], argv[0], dp, key, keylen);

sbin/mount_vnd/mount_vnd.c

187

config(char *dev, char *file, struct disklabel *dp, char *key, size_t keylen)

sbin/mount_vnd/mount_vnd.c

203

vndio.vnd_keylen = keylen;

sbin/mount_vnd/mount_vnd.c

216

explicit_bzero(key, keylen);

sbin/mount_vnd/mount_vnd.c

65

size_t keylen = 0;

sbin/unwind/libunbound/sldns/keyraw.c

537

sldns_gost2pkey_raw(unsigned char* key, size_t keylen)

sbin/unwind/libunbound/sldns/keyraw.c

546

if(keylen != 64) {

sbin/unwind/libunbound/sldns/keyraw.c

562

sldns_ecdsa2pkey_raw(unsigned char* key, size_t keylen, uint8_t algo)

sbin/unwind/libunbound/sldns/keyraw.c

574

if(keylen != 2*256/8) return NULL;

sbin/unwind/libunbound/sldns/keyraw.c

577

if(keylen != 2*384/8) return NULL;

sbin/unwind/libunbound/sldns/keyraw.c

582

if(keylen+1 > sizeof(buf)) { /* sanity check */

sbin/unwind/libunbound/sldns/keyraw.c

587

memmove(buf+1, key, keylen);

sbin/unwind/libunbound/sldns/keyraw.c

594

!OSSL_PARAM_BLD_push_octet_string(param_bld, "pub", buf, keylen+1)) {

sbin/unwind/libunbound/sldns/keyraw.c

626

if(keylen != 2*256/8) return NULL;

sbin/unwind/libunbound/sldns/keyraw.c

629

if(keylen != 2*384/8) return NULL;

sbin/unwind/libunbound/sldns/keyraw.c

633

if(keylen+1 > sizeof(buf)) { /* sanity check */

sbin/unwind/libunbound/sldns/keyraw.c

640

memmove(buf+1, key, keylen);

sbin/unwind/libunbound/sldns/keyraw.c

641

if(!o2i_ECPublicKey(&ec, &pp, (int)keylen+1)) {

sbin/unwind/libunbound/sldns/keyraw.c

662

sldns_ed255192pkey_raw(const unsigned char* key, size_t keylen)

sbin/unwind/libunbound/sldns/keyraw.c

672

if(keylen != 32 || keylen + pre_len > sizeof(buf))

sbin/unwind/libunbound/sldns/keyraw.c

675

memmove(buf+pre_len, key, keylen);

sbin/unwind/libunbound/sldns/keyraw.c

676

evp_key = d2i_PUBKEY(NULL, &pp, (int)(pre_len+keylen));

sbin/unwind/libunbound/sldns/keyraw.c

683

sldns_ed4482pkey_raw(const unsigned char* key, size_t keylen)

sbin/unwind/libunbound/sldns/keyraw.c

693

if(keylen != 57 || keylen + pre_len > sizeof(buf))

sbin/unwind/libunbound/sldns/keyraw.c

696

memmove(buf+pre_len, key, keylen);

sbin/unwind/libunbound/sldns/keyraw.c

697

evp_key = d2i_PUBKEY(NULL, &pp, (int)(pre_len+keylen));

sbin/unwind/libunbound/sldns/keyraw.h

85

EVP_PKEY* sldns_gost2pkey_raw(unsigned char* key, size_t keylen);

sbin/unwind/libunbound/sldns/keyraw.h

95

EVP_PKEY* sldns_ecdsa2pkey_raw(unsigned char* key, size_t keylen, uint8_t algo);

sbin/unwind/libunbound/sldns/str2wire.c

2619

size_t gwlen = 0, keylen = 0;

sbin/unwind/libunbound/sldns/str2wire.c

2681

keylen = *len - 3 - gwlen;

sbin/unwind/libunbound/sldns/str2wire.c

2683

rd+3+gwlen, &keylen);

sbin/unwind/libunbound/sldns/str2wire.c

2686

*len = 3 + gwlen + keylen;

sbin/unwind/libunbound/validator/val_secalgo.c

1239

unsigned char* key, size_t keylen, unsigned char** prefix,

sbin/unwind/libunbound/validator/val_secalgo.c

1267

*pubkey = nss_buf2dsa(key, keylen);

sbin/unwind/libunbound/validator/val_secalgo.c

1286

*pubkey = nss_buf2rsa(key, keylen);

sbin/unwind/libunbound/validator/val_secalgo.c

1323

*pubkey = nss_buf2rsa(key, keylen);

sbin/unwind/libunbound/validator/val_secalgo.c

1335

*pubkey = nss_buf2ecdsa(key, keylen,

sbin/unwind/libunbound/validator/val_secalgo.c

1345

*pubkey = nss_buf2ecdsa(key, keylen,

sbin/unwind/libunbound/validator/val_secalgo.c

1379

unsigned int sigblock_len, unsigned char* key, unsigned int keylen,

sbin/unwind/libunbound/validator/val_secalgo.c

1395

if(!nss_setup_key_digest(algo, &pubkey, &htype, key, keylen,

sbin/unwind/libunbound/validator/val_secalgo.c

1756

unsigned int sigblock_len, unsigned char* key, unsigned int keylen)

sbin/unwind/libunbound/validator/val_secalgo.c

1804

if (keylen < 21) {

sbin/unwind/libunbound/validator/val_secalgo.c

1813

if (keylen != expected_len ) {

sbin/unwind/libunbound/validator/val_secalgo.c

1845

unsigned int sigblock_len, uint8_t* key, unsigned int keylen)

sbin/unwind/libunbound/validator/val_secalgo.c

1854

if( keylen <= 1) {

sbin/unwind/libunbound/validator/val_secalgo.c

1863

if (keylen < 3) {

sbin/unwind/libunbound/validator/val_secalgo.c

1872

if (keylen < exp_offset + exp_len + 1) {

sbin/unwind/libunbound/validator/val_secalgo.c

1877

pubkey.size = keylen - mod_offset;

sbin/unwind/libunbound/validator/val_secalgo.c

1925

unsigned int sigblock_len, unsigned char* key, unsigned int keylen)

sbin/unwind/libunbound/validator/val_secalgo.c

1932

if (sigblock_len != 2*digest_size || keylen != 2*digest_size) {

sbin/unwind/libunbound/validator/val_secalgo.c

1991

unsigned int sigblock_len, unsigned char* key, unsigned int keylen)

sbin/unwind/libunbound/validator/val_secalgo.c

1998

if(keylen != ED25519_KEY_SIZE) {

sbin/unwind/libunbound/validator/val_secalgo.c

2027

unsigned int sigblock_len, unsigned char* key, unsigned int keylen,

sbin/unwind/libunbound/validator/val_secalgo.c

2032

if (sigblock_len == 0 || keylen == 0) {

sbin/unwind/libunbound/validator/val_secalgo.c

2050

*reason = _verify_nettle_dsa(buf, sigblock, sigblock_len, key, keylen);

sbin/unwind/libunbound/validator/val_secalgo.c

2076

sigblock_len, key, keylen);

sbin/unwind/libunbound/validator/val_secalgo.c

2090

sigblock_len, key, keylen);

sbin/unwind/libunbound/validator/val_secalgo.c

2099

key, keylen);

sbin/unwind/libunbound/validator/val_secalgo.c

549

unsigned char* key, size_t keylen)

sbin/unwind/libunbound/validator/val_secalgo.c

555

*evp_key = sldns_key_dsa2pkey_raw(key, keylen);

sbin/unwind/libunbound/validator/val_secalgo.c

580

*evp_key = sldns_key_rsa2pkey_raw(key, keylen);

sbin/unwind/libunbound/validator/val_secalgo.c

606

*evp_key = sldns_key_rsa2pkey_raw(key, keylen);

sbin/unwind/libunbound/validator/val_secalgo.c

616

*evp_key = sldns_gost2pkey_raw(key, keylen);

sbin/unwind/libunbound/validator/val_secalgo.c

632

*evp_key = sldns_ecdsa2pkey_raw(key, keylen,

sbin/unwind/libunbound/validator/val_secalgo.c

646

*evp_key = sldns_ecdsa2pkey_raw(key, keylen,

sbin/unwind/libunbound/validator/val_secalgo.c

662

*evp_key = sldns_ed255192pkey_raw(key, keylen);

sbin/unwind/libunbound/validator/val_secalgo.c

673

*evp_key = sldns_ed4482pkey_raw(key, keylen);

sbin/unwind/libunbound/validator/val_secalgo.c

736

unsigned int sigblock_len, unsigned char* key, unsigned int keylen,

sbin/unwind/libunbound/validator/val_secalgo.c

753

if(!setup_key_digest(algo, &evp_key, &digest_type, key, keylen)) {

sbin/unwind/libunbound/validator/val_secalgo.h

148

unsigned char* key, unsigned int keylen, char** reason);

sbin/unwind/libunbound/validator/val_sigcrypt.c

1555

unsigned int keylen;

sbin/unwind/libunbound/validator/val_sigcrypt.c

1672

dnskey_get_pubkey(dnskey, dnskey_idx, &key, &keylen);

sbin/unwind/libunbound/validator/val_sigcrypt.c

1680

sigblock, sigblock_len, key, keylen, reason);

sbin/vnconfig/vnconfig.c

141

if (key == NULL || (keylen = strlen(key)) == 0)

sbin/vnconfig/vnconfig.c

145

keylen = BLF_MAXUTILIZED;

sbin/vnconfig/vnconfig.c

147

rv = config(file, vnd, dp, key, keylen);

sbin/vnconfig/vnconfig.c

281

config(char *file, char *dev, struct disklabel *dp, char *key, size_t keylen)

sbin/vnconfig/vnconfig.c

307

vndio.vnd_keylen = keylen;

sbin/vnconfig/vnconfig.c

327

explicit_bzero(key, keylen);

sbin/vnconfig/vnconfig.c

75

size_t keylen = 0;

sys/crypto/blake2s.c

203

const size_t inlen, const size_t keylen)

sys/crypto/blake2s.c

210

if (keylen > BLAKE2S_BLOCK_SIZE) {

sys/crypto/blake2s.c

212

blake2s_update(&state, key, keylen);

sys/crypto/blake2s.c

215

memcpy(x_key, key, keylen);

sys/crypto/blake2s.c

82

const void *key, const size_t keylen)

sys/crypto/blake2s.c

87

!key || !keylen || keylen > BLAKE2S_KEY_SIZE));

sys/crypto/blake2s.c

89

blake2s_init_param(state, 0x01010000 | keylen << 8 | outlen);

sys/crypto/blake2s.c

91

memcpy(block, key, keylen);

sys/crypto/blake2s.h

41

const void *key, const size_t keylen);

sys/crypto/blake2s.h

47

const size_t outlen, const size_t inlen, const size_t keylen)

sys/crypto/blake2s.h

53

(key != NULL || keylen == 0) && keylen <= BLAKE2S_KEY_SIZE);

sys/crypto/blake2s.h

55

if (keylen)

sys/crypto/blake2s.h

56

blake2s_init_key(&state, outlen, key, keylen);

sys/crypto/blake2s.h

65

const size_t outlen, const size_t inlen, const size_t keylen);

sys/dev/ic/if_wi.c

1211

int keylen;

sys/dev/ic/if_wi.c

1215

keylen = wk->wi_keys[sc->wi_tx_key].wi_keylen;

sys/dev/ic/if_wi.c

1216

keylen = letoh16(keylen);

sys/dev/ic/if_wi.c

1220

ws.wi_len = (keylen > 5) ? 8 : 4;

sys/dev/ic/if_wi.c

1223

ws.wi_str, keylen);

sys/dev/pv/hypervic.c

1134

size_t keylen;

sys/dev/pv/hypervic.c

1145

if (kvp_pool_keys(kvpl, next, vp, &keylen))

sys/dev/pv/hypervic.c

1149

vp += keylen;

sys/dev/pv/hypervic.c

547

int keylen = strlen(key);

sys/dev/pv/hypervic.c

549

if (keylen > HV_KVP_MAX_KEY_SIZE / 2)

sys/dev/pv/hypervic.c

588

int keylen = strlen(key);

sys/dev/pv/hypervic.c

590

if (keylen > HV_KVP_MAX_KEY_SIZE / 2)

sys/dev/pv/hypervic.c

615

kvp_pool_import(struct kvp_pool *kvpl, const char *key, uint32_t keylen,

sys/dev/pv/hypervic.c

620

if (keylen > HV_KVP_MAX_KEY_SIZE ||

sys/dev/pv/hypervic.c

627

if (keycmp_utf16le(kpe->kpe_key, key, keylen) == 0)

sys/dev/pv/hypervic.c

638

keylen);

sys/dev/pv/hypervic.c

655

uint32_t *keylen, char *val, uint32_t *vallen, uint32_t *valtype)

sys/dev/pv/hypervic.c

670

*keylen = copyout_utf16le(key, kpe->kpe_key, HV_KVP_MAX_KEY_SIZE,

sys/dev/pv/hypervic.c

682

kvp_pool_remove(struct kvp_pool *kvpl, const char *key, uint32_t keylen)

sys/dev/pv/hypervic.c

689

if (keycmp_utf16le(kpe->kpe_key, key, keylen) == 0)

sys/dev/pv/hypervic.c

746

kvp_pool_keys(struct kvp_pool *kvpl, int next, char *key, size_t *keylen)

sys/dev/pv/hypervic.c

756

*keylen = strlen(kpe->kpe_key) + 1;

sys/dev/pv/hypervic.c

757

strlcpy(key, kpe->kpe_key, *keylen);

sys/dev/pv/pvbus.c

400

size_t valuelen = 0, keylen = 0, sz;

sys/dev/pv/pvbus.c

439

keylen = pvr->pvr_keylen;

sys/dev/pv/pvbus.c

440

if ((error = pvbusgetstr(keylen, pvr->pvr_key, &key)) != 0)

sys/dev/pv/pvbus.c

461

free(key, M_TEMP, keylen + 1);

sys/dev/usb/if_wi_usb.c

817

int keylen;

sys/dev/usb/if_wi_usb.c

822

keylen = wk->wi_keys[wsc->wi_tx_key].wi_keylen;

sys/dev/usb/if_wi_usb.c

823

keylen = letoh16(keylen);

sys/dev/usb/if_wi_usb.c

827

ws.wi_len = (keylen > 5) ? 8 : 4;

sys/dev/usb/if_wi_usb.c

830

ws.wi_str, keylen);

sys/lib/libsa/bcrypt_pbkdf.c

107

size_t origkeylen = keylen;

sys/lib/libsa/bcrypt_pbkdf.c

112

if (passlen == 0 || saltlen == 0 || keylen == 0 ||

sys/lib/libsa/bcrypt_pbkdf.c

113

keylen > sizeof(out) * sizeof(out))

sys/lib/libsa/bcrypt_pbkdf.c

115

stride = (keylen + sizeof(out) - 1) / sizeof(out);

sys/lib/libsa/bcrypt_pbkdf.c

116

amt = (keylen + stride - 1) / stride;

sys/lib/libsa/bcrypt_pbkdf.c

125

for (count = 1; keylen > 0; count++) {

sys/lib/libsa/bcrypt_pbkdf.c

152

amt = MINIMUM(amt, keylen);

sys/lib/libsa/bcrypt_pbkdf.c

159

keylen -= i;

sys/lib/libsa/bcrypt_pbkdf.c

97

uint8_t *key, size_t keylen, unsigned int rounds)

sys/net/pipex.c

2331

rc4_keysetup(&mppe->rc4ctx, mppe->session_key, mppe->keylen);

sys/net/pipex.c

2343

mppe->keylen);

sys/net/pipex.c

2374

mppe->keylen = 8;

sys/net/pipex.c

2377

mppe->keylen = 16;

sys/net/pipex.c

2381

GetNewKeyFromSHA(mppe->master_key, mppe->master_key, mppe->keylen,

sys/net/pipex.c

2461

GetNewKeyFromSHA(mppe->master_key, mppe->session_key, mppe->keylen,

sys/net/pipex.c

2464

rc4_keysetup(&keychg, interim, mppe->keylen);

sys/net/pipex.c

2465

rc4_crypt(&keychg, interim, mppe->session_key, mppe->keylen);

sys/net/pipex_local.h

404

#define pipex_mppe_rc4_keybits(r) ((r)->keylen << 3)

sys/net/pipex_local.h

75

int16_t keylen; /* [I] */

sys/net/radix.c

1152

rn_init(unsigned int keylen)

sys/net/radix.c

1156

KASSERT(keylen <= KEYLEN_LIMIT);

sys/net/radix.c

1163

if (keylen <= max_keylen)

sys/net/radix.c

1169

rn_zeros = mallocarray(2, keylen, M_RTABLE, M_NOWAIT | M_ZERO);

sys/net/radix.c

1172

max_keylen = keylen;

sys/net80211/ieee80211.h

1145

u_int8_t keylen[2];

sys/net80211/ieee80211_pae_input.c

1025

keylen = ieee80211_cipher_keylen(ni->ni_rsngroupcipher);

sys/net80211/ieee80211_pae_input.c

1026

if (BE_READ_2(key->keylen) != keylen)

sys/net80211/ieee80211_pae_input.c

1030

if (BE_READ_2(key->paylen) < keylen)

sys/net80211/ieee80211_pae_input.c

1039

if (ieee80211_must_update_group_key(k, gtk, keylen)) {

sys/net80211/ieee80211_pae_input.c

1047

k->k_len = keylen;

sys/net80211/ieee80211_pae_input.c

369

int keylen, deferlink = 0;

sys/net80211/ieee80211_pae_input.c

553

keylen = ieee80211_cipher_keylen(ni->ni_rsncipher);

sys/net80211/ieee80211_pae_input.c

554

if (BE_READ_2(key->keylen) != keylen) {

sys/net80211/ieee80211_pae_input.c

565

k->k_len = keylen;

sys/net80211/ieee80211_pae_input.c

589

keylen = ieee80211_cipher_keylen(ni->ni_rsngroupcipher);

sys/net80211/ieee80211_pae_input.c

590

if (gtk[1] != 6 + keylen) {

sys/net80211/ieee80211_pae_input.c

597

if (ieee80211_must_update_group_key(k, &gtk[8], keylen)) {

sys/net80211/ieee80211_pae_input.c

605

k->k_len = keylen;

sys/net80211/ieee80211_pae_input.c

821

int keylen;

sys/net80211/ieee80211_pae_input.c

887

keylen = ieee80211_cipher_keylen(ni->ni_rsngroupcipher);

sys/net80211/ieee80211_pae_input.c

888

if (gtk[1] != 6 + keylen)

sys/net80211/ieee80211_pae_input.c

894

if (ieee80211_must_update_group_key(k, &gtk[8], keylen)) {

sys/net80211/ieee80211_pae_input.c

902

k->k_len = keylen;

sys/net80211/ieee80211_pae_input.c

991

int keylen;

sys/net80211/ieee80211_pae_output.c

260

u_int16_t info, keylen;

sys/net80211/ieee80211_pae_output.c

283

keylen = ieee80211_cipher_keylen(ni->ni_rsncipher);

sys/net80211/ieee80211_pae_output.c

284

BE_WRITE_2(key->keylen, keylen);

sys/net80211/ieee80211_pae_output.c

340

int keylen;

sys/net80211/ieee80211_pae_output.c

343

keylen = ieee80211_cipher_keylen(ni->ni_rsncipher);

sys/net80211/ieee80211_pae_output.c

344

BE_WRITE_2(key->keylen, keylen);

sys/net80211/ieee80211_pae_output.c

368

u_int16_t info, keylen;

sys/net80211/ieee80211_pae_output.c

403

keylen = ieee80211_cipher_keylen(ni->ni_rsncipher);

sys/net80211/ieee80211_pae_output.c

404

BE_WRITE_2(key->keylen, keylen);

sys/net80211/ieee80211_pae_output.c

460

int keylen;

sys/net80211/ieee80211_pae_output.c

462

keylen = ieee80211_cipher_keylen(ni->ni_rsncipher);

sys/net80211/ieee80211_pae_output.c

463

BE_WRITE_2(key->keylen, keylen);

sys/net80211/ieee80211_pae_output.c

527

BE_WRITE_2(key->keylen, k->k_len);

sys/net80211/ieee80211_pae_output.c

585

BE_WRITE_2(key->keylen, k->k_len);

usr.bin/dig/lib/dns/hmac_link.c

143

int keylen;

usr.bin/dig/lib/dns/hmac_link.c

161

keylen = ISC_SHA1_DIGESTLENGTH;

usr.bin/dig/lib/dns/hmac_link.c

164

keylen = r.length;

usr.bin/dig/lib/dns/hmac_link.c

167

key->key_size = keylen * 8;

usr.bin/dig/lib/dns/hmac_link.c

287

int keylen;

usr.bin/dig/lib/dns/hmac_link.c

305

keylen = ISC_SHA224_DIGESTLENGTH;

usr.bin/dig/lib/dns/hmac_link.c

308

keylen = r.length;

usr.bin/dig/lib/dns/hmac_link.c

311

key->key_size = keylen * 8;

usr.bin/dig/lib/dns/hmac_link.c

431

int keylen;

usr.bin/dig/lib/dns/hmac_link.c

449

keylen = ISC_SHA256_DIGESTLENGTH;

usr.bin/dig/lib/dns/hmac_link.c

452

keylen = r.length;

usr.bin/dig/lib/dns/hmac_link.c

455

key->key_size = keylen * 8;

usr.bin/dig/lib/dns/hmac_link.c

575

int keylen;

usr.bin/dig/lib/dns/hmac_link.c

593

keylen = ISC_SHA384_DIGESTLENGTH;

usr.bin/dig/lib/dns/hmac_link.c

596

keylen = r.length;

usr.bin/dig/lib/dns/hmac_link.c

599

key->key_size = keylen * 8;

usr.bin/dig/lib/dns/hmac_link.c

719

int keylen;

usr.bin/dig/lib/dns/hmac_link.c

737

keylen = ISC_SHA512_DIGESTLENGTH;

usr.bin/dig/lib/dns/hmac_link.c

740

keylen = r.length;

usr.bin/dig/lib/dns/hmac_link.c

743

key->key_size = keylen * 8;

usr.bin/openssl/req.c

1590

long keylen = -1;

usr.bin/openssl/req.c

1597

keylen = *pkeylen;

usr.bin/openssl/req.c

1600

keylen = strtonum(gstr, 0, LONG_MAX, &errstr);

usr.bin/openssl/req.c

1605

*pkeylen = keylen;

usr.bin/openssl/req.c

1628

keylen = strtonum(p + 1, 0, LONG_MAX, &errstr);

usr.bin/openssl/req.c

1634

*pkeylen = keylen;

usr.bin/openssl/req.c

1636

keylen = *pkeylen;

usr.bin/openssl/req.c

1703

if ((*pkey_type == EVP_PKEY_RSA) && (keylen != -1)) {

usr.bin/openssl/req.c

1704

if (EVP_PKEY_CTX_set_rsa_keygen_bits(gctx, keylen) <= 0) {

usr.bin/signify/signify.c

255

uint8_t *key, size_t keylen)

usr.bin/signify/signify.c

262

memset(key, 0, keylen);

usr.bin/signify/signify.c

282

keylen, rounds) == -1)

usr.bin/snmp/usm.c

501

size_t keylen, enum usm_key_level level)

usr.bin/snmp/usm.c

516

keylen = EVP_MD_size(digest);

usr.bin/snmp/usm.c

518

if (keylen != (size_t)EVP_MD_size(digest)) {

usr.bin/snmp/usm.c

522

if ((lkey = malloc(keylen)) == NULL)

usr.bin/snmp/usm.c

524

memcpy(lkey, key, keylen);

usr.bin/snmp/usm.c

534

size_t keylen, enum usm_key_level level)

usr.bin/snmp/usm.c

553

keylen = EVP_MD_size(usm->digest);

usr.bin/snmp/usm.c

555

if (keylen != (size_t)EVP_MD_size(usm->digest)) {

usr.bin/snmp/usm.c

559

if ((lkey = malloc(keylen)) == NULL)

usr.bin/snmp/usm.c

561

memcpy(lkey, key, keylen);

usr.bin/ssh/cipher-chachapoly-libcrypto.c

33

chachapoly_new(const u_char *key, u_int keylen)

usr.bin/ssh/cipher-chachapoly-libcrypto.c

37

if (keylen != (32 + 32)) /* 2 x 256 bit keys */

usr.bin/ssh/cipher-chachapoly.c

33

chachapoly_new(const u_char *key, u_int keylen)

usr.bin/ssh/cipher-chachapoly.c

37

if (keylen != (32 + 32)) /* 2 x 256 bit keys */

usr.bin/ssh/cipher-chachapoly.h

29

struct chachapoly_ctx *chachapoly_new(const u_char *key, u_int keylen)

usr.bin/ssh/cipher.c

231

const u_char *key, u_int keylen, const u_char *iv, u_int ivlen,

usr.bin/ssh/cipher.c

248

if (keylen < cipher->key_len ||

usr.bin/ssh/cipher.c

256

cc->cp_ctx = chachapoly_new(key, keylen);

usr.bin/ssh/cipher.c

266

aesctr_keysetup(&cc->ac_ctx, key, 8 * keylen, 8 * ivlen);

usr.bin/ssh/cipher.c

291

if (klen > 0 && keylen != (u_int)klen) {

usr.bin/ssh/cipher.c

292

if (EVP_CIPHER_CTX_set_key_length(cc->evp, keylen) == 0) {

usr.bin/ssh/packet.c

2489

size_t keylen, ivlen, maclen;

usr.bin/ssh/packet.c

2508

(r = sshbuf_get_string(b, &enc->key, &keylen)) != 0 ||

usr.bin/ssh/packet.c

2536

enc->key_len = keylen;

usr.bin/ssh/sshconnect2.c

2140

size_t siglen = 0, keylen = 0;

usr.bin/ssh/sshconnect2.c

2213

if ((r = sshkey_to_blob(private, &keyblob, &keylen)) != 0) {

usr.bin/ssh/sshconnect2.c

2223

(r = sshbuf_put_string(b, keyblob, keylen)) != 0 ||

usr.bin/ssh/sshconnect2.c

2244

(r = sshpkt_put_string(ssh, keyblob, keylen)) != 0 ||

usr.bin/ssh/sshkey.c

2778

size_t i, pubkeylen, keylen, ivlen, blocksize, authlen;

usr.bin/ssh/sshkey.c

2805

keylen = cipher_keylen(cipher);

usr.bin/ssh/sshkey.c

2808

if ((key = calloc(1, keylen + ivlen)) == NULL) {

usr.bin/ssh/sshkey.c

2815

salt, SALT_LEN, key, keylen + ivlen, rounds) < 0) {

usr.bin/ssh/sshkey.c

2827

if ((r = cipher_init(&ciphercontext, cipher, key, keylen,

usr.bin/ssh/sshkey.c

2828

key + keylen, ivlen, 1)) != 0)

usr.bin/ssh/sshkey.c

2890

freezero(key, keylen + ivlen);

usr.bin/ssh/sshkey.c

2978

size_t keylen = 0, ivlen = 0, authlen = 0, slen = 0;

usr.bin/ssh/sshkey.c

3041

keylen = cipher_keylen(cipher);

usr.bin/ssh/sshkey.c

3044

if ((key = calloc(1, keylen + ivlen)) == NULL) {

usr.bin/ssh/sshkey.c

3053

key, keylen + ivlen, rounds) < 0) {

usr.bin/ssh/sshkey.c

3068

(r = cipher_init(&ciphercontext, cipher, key, keylen,

usr.bin/ssh/sshkey.c

3069

key + keylen, ivlen, 0)) != 0)

usr.bin/ssh/sshkey.c

3110

explicit_bzero(key, keylen + ivlen);

usr.bin/tmux/format.c

4938

format_replace(struct format_expand_state *es, const char *key, size_t keylen,

usr.bin/tmux/format.c

4963

copy = copy0 = xstrndup(key, keylen);

usr.bin/tmux/menu.c

102

keylen = strlen(key) + 3; /* 3 = space and two brackets */

usr.bin/tmux/menu.c

109

if (keylen <= max_width / 4)

usr.bin/tmux/menu.c

110

max_width -= keylen;

usr.bin/tmux/menu.c

111

else if (keylen >= max_width || slen >= max_width - keylen)

usr.bin/tmux/menu.c

72

size_t keylen, slen;

usr.bin/tmux/mode-tree.c

275

mti->keylen = strlen(mti->keystr);

usr.bin/tmux/mode-tree.c

278

mti->keylen = 0;

usr.bin/tmux/mode-tree.c

743

int keylen, pad, alignlen[mtd->maxdepth + 1];

usr.bin/tmux/mode-tree.c

758

keylen = 0;

usr.bin/tmux/mode-tree.c

763

if ((int)mti->keylen + 3 > keylen)

usr.bin/tmux/mode-tree.c

764

keylen = mti->keylen + 3;

usr.bin/tmux/mode-tree.c

787

pad = keylen - 2 - mti->keylen;

usr.bin/tmux/mode-tree.c

826

xasprintf(&text, "%-*s%s%*s%s%s", keylen, key, start,

usr.bin/tmux/mode-tree.c

95

size_t keylen;

usr.sbin/bgpd/parse.y

2313

uint8_t keylen;

usr.sbin/bgpd/parse.y

2318

keylen = 20;

usr.sbin/bgpd/parse.y

2321

keylen = 16;

usr.sbin/bgpd/parse.y

2330

if (strlen($7) / 2 != keylen) {

usr.sbin/bgpd/parse.y

2332

"is %zu bytes", keylen, strlen($7) / 2);

usr.sbin/bgpd/parse.y

2367

$$.auth_keylen_in = keylen;

usr.sbin/bgpd/parse.y

2380

$$.auth_keylen_out = keylen;

usr.sbin/bgpd/pfkey.c

505

uint8_t keylen, char *key, uint32_t *spi)

usr.sbin/bgpd/pfkey.c

513

src, dst, *spi, 0, keylen, key, 0, 0, NULL, 0, 0) == -1)

usr.sbin/ldpd/pfkey.c

340

pfkey_sa_add(int af, union ldpd_addr *src, union ldpd_addr *dst, uint8_t keylen,

usr.sbin/ldpd/pfkey.c

349

af, src, dst, *spi, 0, keylen, key, 0, 0, NULL, 0, 0) < 0)

usr.sbin/npppd/npppd/mppe.c

171

_this->keylen, interim);

usr.sbin/npppd/npppd/mppe.c

173

rc4_key(keychg, _this->keylen, interim);

usr.sbin/npppd/npppd/mppe.c

174

rc4(keychg, _this->keylen, interim, _this->session_key);

usr.sbin/npppd/npppd/mppe.c

206

_this->send.keylen = 8;

usr.sbin/npppd/npppd/mppe.c

209

_this->send.keylen = 8;

usr.sbin/npppd/npppd/mppe.c

212

_this->send.keylen = 16;

usr.sbin/npppd/npppd/mppe.c

219

_this->recv.keylen = 8;

usr.sbin/npppd/npppd/mppe.c

222

_this->recv.keylen = 8;

usr.sbin/npppd/npppd/mppe.c

225

_this->recv.keylen = 16;

usr.sbin/npppd/npppd/mppe.c

232

_this->send.keylen, _this->send.session_key);

usr.sbin/npppd/npppd/mppe.c

239

_this->recv.keylen, _this->recv.session_key);

usr.sbin/npppd/npppd/mppe.c

645

return rc4_key(_this->rc4ctx, _this->keylen, _this->session_key);

usr.sbin/npppd/npppd/mppe.c

651

return rc4_key(_this->rc4ctx, _this->keylen,

usr.sbin/npppd/npppd/ppp.h

395

uint8_t keylen;

usr.sbin/nsd/rdata.c

2703

uint16_t keylen;

usr.sbin/nsd/rdata.c

2745

keylen = rdlength - (buffer_position(packet)-mark);

usr.sbin/nsd/rdata.c

2748

sizeof(**rr) + 3 + gateway_length + keylen)))

usr.sbin/nsd/rdata.c

2754

if(keylen != 0)

usr.sbin/nsd/rdata.c

2755

buffer_read(packet, (*rr)->rdata + 3 + gateway_length, keylen);

usr.sbin/nsd/rdata.c

2756

(*rr)->rdlength = 3 + gateway_length + keylen;

usr.sbin/unbound/sldns/keyraw.c

537

sldns_gost2pkey_raw(unsigned char* key, size_t keylen)

usr.sbin/unbound/sldns/keyraw.c

546

if(keylen != 64) {

usr.sbin/unbound/sldns/keyraw.c

562

sldns_ecdsa2pkey_raw(unsigned char* key, size_t keylen, uint8_t algo)

usr.sbin/unbound/sldns/keyraw.c

574

if(keylen != 2*256/8) return NULL;

usr.sbin/unbound/sldns/keyraw.c

577

if(keylen != 2*384/8) return NULL;

usr.sbin/unbound/sldns/keyraw.c

582

if(keylen+1 > sizeof(buf)) { /* sanity check */

usr.sbin/unbound/sldns/keyraw.c

587

memmove(buf+1, key, keylen);

usr.sbin/unbound/sldns/keyraw.c

594

!OSSL_PARAM_BLD_push_octet_string(param_bld, "pub", buf, keylen+1)) {

usr.sbin/unbound/sldns/keyraw.c

626

if(keylen != 2*256/8) return NULL;

usr.sbin/unbound/sldns/keyraw.c

629

if(keylen != 2*384/8) return NULL;

usr.sbin/unbound/sldns/keyraw.c

633

if(keylen+1 > sizeof(buf)) { /* sanity check */

usr.sbin/unbound/sldns/keyraw.c

640

memmove(buf+1, key, keylen);

usr.sbin/unbound/sldns/keyraw.c

641

if(!o2i_ECPublicKey(&ec, &pp, (int)keylen+1)) {

usr.sbin/unbound/sldns/keyraw.c

662

sldns_ed255192pkey_raw(const unsigned char* key, size_t keylen)

usr.sbin/unbound/sldns/keyraw.c

672

if(keylen != 32 || keylen + pre_len > sizeof(buf))

usr.sbin/unbound/sldns/keyraw.c

675

memmove(buf+pre_len, key, keylen);

usr.sbin/unbound/sldns/keyraw.c

676

evp_key = d2i_PUBKEY(NULL, &pp, (int)(pre_len+keylen));

usr.sbin/unbound/sldns/keyraw.c

683

sldns_ed4482pkey_raw(const unsigned char* key, size_t keylen)

usr.sbin/unbound/sldns/keyraw.c

693

if(keylen != 57 || keylen + pre_len > sizeof(buf))

usr.sbin/unbound/sldns/keyraw.c

696

memmove(buf+pre_len, key, keylen);

usr.sbin/unbound/sldns/keyraw.c

697

evp_key = d2i_PUBKEY(NULL, &pp, (int)(pre_len+keylen));

usr.sbin/unbound/sldns/keyraw.h

85

EVP_PKEY* sldns_gost2pkey_raw(unsigned char* key, size_t keylen);

usr.sbin/unbound/sldns/keyraw.h

95

EVP_PKEY* sldns_ecdsa2pkey_raw(unsigned char* key, size_t keylen, uint8_t algo);

usr.sbin/unbound/sldns/str2wire.c

2619

size_t gwlen = 0, keylen = 0;

usr.sbin/unbound/sldns/str2wire.c

2681

keylen = *len - 3 - gwlen;

usr.sbin/unbound/sldns/str2wire.c

2683

rd+3+gwlen, &keylen);

usr.sbin/unbound/sldns/str2wire.c

2686

*len = 3 + gwlen + keylen;

usr.sbin/unbound/testcode/unitverify.c

564

size_t keylen = 260;

usr.sbin/unbound/testcode/unitverify.c

574

evp_key = sldns_key_rsa2pkey_raw(key, keylen);

usr.sbin/unbound/validator/val_secalgo.c

1239

unsigned char* key, size_t keylen, unsigned char** prefix,

usr.sbin/unbound/validator/val_secalgo.c

1267

*pubkey = nss_buf2dsa(key, keylen);

usr.sbin/unbound/validator/val_secalgo.c

1286

*pubkey = nss_buf2rsa(key, keylen);

usr.sbin/unbound/validator/val_secalgo.c

1323

*pubkey = nss_buf2rsa(key, keylen);

usr.sbin/unbound/validator/val_secalgo.c

1335

*pubkey = nss_buf2ecdsa(key, keylen,

usr.sbin/unbound/validator/val_secalgo.c

1345

*pubkey = nss_buf2ecdsa(key, keylen,

usr.sbin/unbound/validator/val_secalgo.c

1379

unsigned int sigblock_len, unsigned char* key, unsigned int keylen,

usr.sbin/unbound/validator/val_secalgo.c

1395

if(!nss_setup_key_digest(algo, &pubkey, &htype, key, keylen,

usr.sbin/unbound/validator/val_secalgo.c

1756

unsigned int sigblock_len, unsigned char* key, unsigned int keylen)

usr.sbin/unbound/validator/val_secalgo.c

1804

if (keylen < 21) {

usr.sbin/unbound/validator/val_secalgo.c

1813

if (keylen != expected_len ) {

usr.sbin/unbound/validator/val_secalgo.c

1845

unsigned int sigblock_len, uint8_t* key, unsigned int keylen)

usr.sbin/unbound/validator/val_secalgo.c

1854

if( keylen <= 1) {

usr.sbin/unbound/validator/val_secalgo.c

1863

if (keylen < 3) {

usr.sbin/unbound/validator/val_secalgo.c

1872

if (keylen < exp_offset + exp_len + 1) {

usr.sbin/unbound/validator/val_secalgo.c

1877

pubkey.size = keylen - mod_offset;

usr.sbin/unbound/validator/val_secalgo.c

1925

unsigned int sigblock_len, unsigned char* key, unsigned int keylen)

usr.sbin/unbound/validator/val_secalgo.c

1932

if (sigblock_len != 2*digest_size || keylen != 2*digest_size) {

usr.sbin/unbound/validator/val_secalgo.c

1991

unsigned int sigblock_len, unsigned char* key, unsigned int keylen)

usr.sbin/unbound/validator/val_secalgo.c

1998

if(keylen != ED25519_KEY_SIZE) {

usr.sbin/unbound/validator/val_secalgo.c

2027

unsigned int sigblock_len, unsigned char* key, unsigned int keylen,

usr.sbin/unbound/validator/val_secalgo.c

2032

if (sigblock_len == 0 || keylen == 0) {

usr.sbin/unbound/validator/val_secalgo.c

2050

*reason = _verify_nettle_dsa(buf, sigblock, sigblock_len, key, keylen);

usr.sbin/unbound/validator/val_secalgo.c

2076

sigblock_len, key, keylen);

usr.sbin/unbound/validator/val_secalgo.c

2090

sigblock_len, key, keylen);

usr.sbin/unbound/validator/val_secalgo.c

2099

key, keylen);

usr.sbin/unbound/validator/val_secalgo.c

549

unsigned char* key, size_t keylen)

usr.sbin/unbound/validator/val_secalgo.c

555

*evp_key = sldns_key_dsa2pkey_raw(key, keylen);

usr.sbin/unbound/validator/val_secalgo.c

580

*evp_key = sldns_key_rsa2pkey_raw(key, keylen);

usr.sbin/unbound/validator/val_secalgo.c

606

*evp_key = sldns_key_rsa2pkey_raw(key, keylen);

usr.sbin/unbound/validator/val_secalgo.c

616

*evp_key = sldns_gost2pkey_raw(key, keylen);

usr.sbin/unbound/validator/val_secalgo.c

632

*evp_key = sldns_ecdsa2pkey_raw(key, keylen,

usr.sbin/unbound/validator/val_secalgo.c

646

*evp_key = sldns_ecdsa2pkey_raw(key, keylen,

usr.sbin/unbound/validator/val_secalgo.c

662

*evp_key = sldns_ed255192pkey_raw(key, keylen);

usr.sbin/unbound/validator/val_secalgo.c

673

*evp_key = sldns_ed4482pkey_raw(key, keylen);

usr.sbin/unbound/validator/val_secalgo.c

736

unsigned int sigblock_len, unsigned char* key, unsigned int keylen,

usr.sbin/unbound/validator/val_secalgo.c

753

if(!setup_key_digest(algo, &evp_key, &digest_type, key, keylen)) {

usr.sbin/unbound/validator/val_secalgo.h

148

unsigned char* key, unsigned int keylen, char** reason);

usr.sbin/unbound/validator/val_sigcrypt.c

1555

unsigned int keylen;

usr.sbin/unbound/validator/val_sigcrypt.c

1672

dnskey_get_pubkey(dnskey, dnskey_idx, &key, &keylen);

usr.sbin/unbound/validator/val_sigcrypt.c

1680

sigblock, sigblock_len, key, keylen, reason);

usr.sbin/ypserv/ypxfr/ypxfr.c

56

ypxfr_foreach(u_long status, char *keystr, int keylen, char *valstr, int vallen,

usr.sbin/ypserv/ypxfr/ypxfr.c

64

keystr[keylen] = '\0';