crypto/libecc/include/libecc/sig/bign.h

22

ATTRIBUTE_WARN_UNUSED_RET int bign_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen);

crypto/libecc/include/libecc/sig/bign_common.h

73

ATTRIBUTE_WARN_UNUSED_RET int __bign_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen);

crypto/libecc/include/libecc/sig/bip0340.h

44

ATTRIBUTE_WARN_UNUSED_RET int bip0340_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize,

crypto/libecc/include/libecc/sig/dbign.h

22

ATTRIBUTE_WARN_UNUSED_RET int dbign_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen);

crypto/libecc/include/libecc/sig/decdsa.h

27

ATTRIBUTE_WARN_UNUSED_RET int decdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen);

crypto/libecc/include/libecc/sig/decdsa.h

45

const u8 *sig, u8 siglen, const u8 *hash, u8 hsize);

crypto/libecc/include/libecc/sig/ecdsa.h

27

ATTRIBUTE_WARN_UNUSED_RET int ecdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen);

crypto/libecc/include/libecc/sig/ecdsa.h

45

const u8 *sig, u8 siglen, const u8 *hash, u8 hsize);

crypto/libecc/include/libecc/sig/ecdsa_common.h

57

ATTRIBUTE_WARN_UNUSED_RET int __ecdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen);

crypto/libecc/include/libecc/sig/ecdsa_common.h

84

const u8 *sig, u8 siglen, const u8 *hash, u8 hsize,

crypto/libecc/include/libecc/sig/ecfsdsa.h

59

ATTRIBUTE_WARN_UNUSED_RET int ecfsdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize,

crypto/libecc/include/libecc/sig/ecgdsa.h

50

ATTRIBUTE_WARN_UNUSED_RET int ecgdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize,

crypto/libecc/include/libecc/sig/eckcdsa.h

28

#define ECKCDSA_R_LEN(hsize, q_bit_len) LOCAL_MIN(hsize, BYTECEIL(q_bit_len))

crypto/libecc/include/libecc/sig/eckcdsa.h

30

#define ECKCDSA_SIGLEN(hsize, q_bit_len) (ECKCDSA_R_LEN(hsize, q_bit_len) + \

crypto/libecc/include/libecc/sig/eckcdsa.h

49

ATTRIBUTE_WARN_UNUSED_RET int eckcdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize,

crypto/libecc/include/libecc/sig/ecosdsa.h

29

#define ECOSDSA_R_LEN(hsize) (hsize)

crypto/libecc/include/libecc/sig/ecosdsa.h

31

#define ECOSDSA_SIGLEN(hsize, q_bit_len) (ECOSDSA_R_LEN(hsize) + \

crypto/libecc/include/libecc/sig/ecosdsa.h

50

ATTRIBUTE_WARN_UNUSED_RET int ecosdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize,

crypto/libecc/include/libecc/sig/ecrdsa.h

50

ATTRIBUTE_WARN_UNUSED_RET int ecrdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize,

crypto/libecc/include/libecc/sig/ecsdsa.h

28

#define ECSDSA_R_LEN(hsize) (hsize)

crypto/libecc/include/libecc/sig/ecsdsa.h

30

#define ECSDSA_SIGLEN(hsize, q_bit_len) (ECSDSA_R_LEN(hsize) + \

crypto/libecc/include/libecc/sig/ecsdsa.h

49

ATTRIBUTE_WARN_UNUSED_RET int ecsdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize,

crypto/libecc/include/libecc/sig/ecsdsa_common.h

34

ATTRIBUTE_WARN_UNUSED_RET int __ecsdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize,

crypto/libecc/include/libecc/sig/eddsa.h

53

#define EDDSA_R_LEN(hsize) (hsize / 2)

crypto/libecc/include/libecc/sig/eddsa.h

54

#define EDDSA_S_LEN(hsize) (hsize / 2)

crypto/libecc/include/libecc/sig/eddsa.h

55

#define EDDSA_SIGLEN(hsize) (EDDSA_R_LEN(hsize) + EDDSA_S_LEN(hsize))

crypto/libecc/include/libecc/sig/eddsa.h

81

ATTRIBUTE_WARN_UNUSED_RET int eddsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen);

crypto/libecc/include/libecc/sig/sig_algs_internal.h

55

ATTRIBUTE_WARN_UNUSED_RET int (*siglen) (u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen);

crypto/libecc/include/libecc/sig/sm2.h

56

ATTRIBUTE_WARN_UNUSED_RET int sm2_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen);

crypto/libecc/src/sig/bign.c

36

int bign_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen)

crypto/libecc/src/sig/bign.c

38

return __bign_siglen(p_bit_len, q_bit_len, hsize, blocksize, siglen);

crypto/libecc/src/sig/bign_common.c

376

int __bign_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen)

crypto/libecc/src/sig/bign_common.c

383

(hsize <= MAX_DIGEST_SIZE) && (blocksize <= MAX_BLOCK_SIZE), ret, err);

crypto/libecc/src/sig/bign_common.c

480

u8 hsize, p_len, l;

crypto/libecc/src/sig/bign_common.c

518

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/bign_common.c

547

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

551

dbg_buf_print("h", hash, hsize);

crypto/libecc/src/sig/bign_common.c

587

ret = __bign_determinitic_nonce(&k, q, q_bit_len, &(priv_key->x), ctx->adata, ctx->adata_len, hash, hsize);

crypto/libecc/src/sig/bign_common.c

639

ret = belt_hash_update(&belt_hash_ctx, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

650

ret = _reverse_endianness(hash, hsize); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

651

ret = nn_init_from_buf(&h, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

686

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

718

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/bign_common.c

857

u8 hsize, p_len, l;

crypto/libecc/src/sig/bign_common.c

895

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/bign_common.c

910

dbg_buf_print("h = H(m)", hash, hsize);

crypto/libecc/src/sig/bign_common.c

913

ret = _reverse_endianness(hash, hsize); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

914

ret = nn_init_from_buf(&h, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

919

ret = _reverse_endianness(hash, hsize); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

952

ret = belt_hash_update(&belt_hash_ctx, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

989

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/bip0340.c

1049

u16 hsize;

crypto/libecc/src/sig/bip0340.c

1115

hsize = hm->digest_size;

crypto/libecc/src/sig/bip0340.c

1238

ret = nn_init_from_buf(e, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

135

int bip0340_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize,

crypto/libecc/src/sig/bip0340.c

143

(hsize <= MAX_DIGEST_SIZE) && (blocksize <= MAX_BLOCK_SIZE)),

crypto/libecc/src/sig/bip0340.c

505

u8 hsize;

crypto/libecc/src/sig/bip0340.c

520

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/bip0340.c

534

ret = nn_init_from_buf(&e, e_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

829

u16 hsize;

crypto/libecc/src/sig/bip0340.c

858

hsize = hm->digest_size;

crypto/libecc/src/sig/bip0340.c

977

ret = nn_init_from_buf(&e, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/dbign.c

41

int dbign_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen)

crypto/libecc/src/sig/dbign.c

43

return __bign_siglen(p_bit_len, q_bit_len, hsize, blocksize, siglen);

crypto/libecc/src/sig/decdsa.c

110

const u8 *sig, u8 siglen, const u8 *hash, u8 hsize)

crypto/libecc/src/sig/decdsa.c

112

return __ecdsa_public_key_from_sig(out_pub1, out_pub2, params, sig, siglen, hash, hsize, DECDSA);

crypto/libecc/src/sig/decdsa.c

41

int decdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen)

crypto/libecc/src/sig/decdsa.c

43

return __ecdsa_siglen(p_bit_len, q_bit_len, hsize, blocksize, siglen);

crypto/libecc/src/sig/ecdsa.c

36

int ecdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen)

crypto/libecc/src/sig/ecdsa.c

38

return __ecdsa_siglen(p_bit_len, q_bit_len, hsize, blocksize, siglen);

crypto/libecc/src/sig/ecdsa.c

74

const u8 *sig, u8 siglen, const u8 *hash, u8 hsize)

crypto/libecc/src/sig/ecdsa.c

76

return __ecdsa_public_key_from_sig(out_pub1, out_pub2, params, sig, siglen, hash, hsize, ECDSA);

crypto/libecc/src/sig/ecdsa_common.c

101

ret = hmac(K, hsize, hash_type, V, hsize, V, &hmac_size); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

103

ret = hmac_init(&hmac_ctx, K, hsize, hash_type); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

104

ret = hmac_update(&hmac_ctx, V, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

116

ret = hmac(K, hsize, hash_type, V, hsize, V, &hmac_size); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

141

ret = hmac(K, hsize, hash_type, V, hsize, V, &hmac_size); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

152

ret = hmac_init(&hmac_ctx, K, hsize, hash_type); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

153

ret = hmac_update(&hmac_ctx, V, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

162

ret = hmac(K, hsize, hash_type, V, hsize, V, &hmac_size); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

203

int __ecdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen)

crypto/libecc/src/sig/ecdsa_common.c

210

(hsize <= MAX_DIGEST_SIZE) && (blocksize <= MAX_BLOCK_SIZE), ret, err);

crypto/libecc/src/sig/ecdsa_common.c

328

u8 hsize, q_len;

crypto/libecc/src/sig/ecdsa_common.c

362

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/ecdsa_common.c

383

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

387

dbg_buf_print("h", hash, hsize);

crypto/libecc/src/sig/ecdsa_common.c

399

if ((hsize * 8) > q_bit_len) {

crypto/libecc/src/sig/ecdsa_common.c

400

rshift = (bitcnt_t)((hsize * 8) - q_bit_len);

crypto/libecc/src/sig/ecdsa_common.c

407

ret = nn_init_from_buf(&e, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

451

hash, hsize, ctx->h->type);

crypto/libecc/src/sig/ecdsa_common.c

49

nn_src_t x, const u8 *hash, u8 hsize,

crypto/libecc/src/sig/ecdsa_common.c

497

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

583

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/ecdsa_common.c

71

MUST_HAVE((q_len <= EC_PRIV_KEY_MAX_SIZE) && (hsize <= MAX_BLOCK_SIZE), ret, err);

crypto/libecc/src/sig/ecdsa_common.c

713

u8 hsize;

crypto/libecc/src/sig/ecdsa_common.c

74

ret = local_memset(V, 0x01, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

741

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/ecdsa_common.c

749

dbg_buf_print("h = H(m)", hash, hsize);

crypto/libecc/src/sig/ecdsa_common.c

75

ret = local_memset(K, 0x00, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

761

if ((hsize * 8) > q_bit_len) {

crypto/libecc/src/sig/ecdsa_common.c

762

rshift = (bitcnt_t)((hsize * 8) - q_bit_len);

crypto/libecc/src/sig/ecdsa_common.c

769

ret = nn_init_from_buf(&e, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

770

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

81

ret = hmac_init(&hmac_ctx, K, hsize, hash_type); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

82

ret = hmac_update(&hmac_ctx, V, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

837

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/ecdsa_common.c

868

const u8 *sig, u8 siglen, const u8 *hash, u8 hsize,

crypto/libecc/src/sig/ecdsa_common.c

89

ret = nn_init_from_buf(k, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

90

if((8 * hsize) > q_bit_len){

crypto/libecc/src/sig/ecdsa_common.c

91

ret = nn_rshift(k, k, (bitcnt_t)((8 * hsize) - q_bit_len)); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

943

if ((hsize * 8) > q_bit_len) {

crypto/libecc/src/sig/ecdsa_common.c

944

rshift = (bitcnt_t)((hsize * 8) - q_bit_len);

crypto/libecc/src/sig/ecdsa_common.c

946

ret = nn_init_from_buf(&e, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

261

u8 hsize, s_len, r_len;

crypto/libecc/src/sig/ecfsdsa.c

291

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/ecfsdsa.c

314

dbg_buf_print("h(R||m)", e_buf, hsize);

crypto/libecc/src/sig/ecfsdsa.c

317

ret = nn_init_from_buf(&e, e_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

318

ret = local_memset(e_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

379

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/ecfsdsa.c

546

u8 hsize, p_len;

crypto/libecc/src/sig/ecfsdsa.c

572

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/ecfsdsa.c

590

ret = nn_init_from_buf(&tmp, e_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

591

ret = local_memset(e_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

61

int ecfsdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen)

crypto/libecc/src/sig/ecfsdsa.c

638

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/ecfsdsa.c

676

u16 hsize;

crypto/libecc/src/sig/ecfsdsa.c

68

(hsize <= MAX_DIGEST_SIZE) && (blocksize <= MAX_BLOCK_SIZE), ret, err);

crypto/libecc/src/sig/ecfsdsa.c

698

hsize = hm->digest_size;

crypto/libecc/src/sig/ecfsdsa.c

778

ret = nn_init_from_buf(&e, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

859

u16 hsize;

crypto/libecc/src/sig/ecfsdsa.c

918

hsize = hm->digest_size;

crypto/libecc/src/sig/ecfsdsa.c

995

ret = nn_init_from_buf(e, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

187

u8 hsize, r_len, s_len;

crypto/libecc/src/sig/ecgdsa.c

224

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/ecgdsa.c

242

ret = local_memset(e_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

246

dbg_buf_print("H(m)", e_buf, hsize);

crypto/libecc/src/sig/ecgdsa.c

254

if ((hsize * 8) > q_bit_len) {

crypto/libecc/src/sig/ecgdsa.c

255

rshift = (bitcnt_t)((hsize * 8) - q_bit_len);

crypto/libecc/src/sig/ecgdsa.c

257

ret = nn_init_from_buf(&tmp, e_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

258

ret = local_memset(e_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

374

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/ecgdsa.c

508

u8 hsize;

crypto/libecc/src/sig/ecgdsa.c

538

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/ecgdsa.c

544

dbg_buf_print("H(m)", e_buf, hsize);

crypto/libecc/src/sig/ecgdsa.c

552

if ((hsize * 8) > q_bit_len) {

crypto/libecc/src/sig/ecgdsa.c

553

rshift = (bitcnt_t)((hsize * 8) - q_bit_len);

crypto/libecc/src/sig/ecgdsa.c

555

ret = nn_init_from_buf(&e, e_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

556

ret = local_memset(e_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

610

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/ecgdsa.c

69

int ecgdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen)

crypto/libecc/src/sig/ecgdsa.c

76

(hsize <= MAX_DIGEST_SIZE) && (blocksize <= MAX_BLOCK_SIZE), ret, err);

crypto/libecc/src/sig/eckcdsa.c

307

u8 p_len, r_len, s_len, hsize, shift;

crypto/libecc/src/sig/eckcdsa.c

335

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/eckcdsa.c

338

r_len = (u8)ECKCDSA_R_LEN(hsize, q_bit_len);

crypto/libecc/src/sig/eckcdsa.c

349

MUST_HAVE((siglen == ECKCDSA_SIGLEN(hsize, q_bit_len)), ret, err);

crypto/libecc/src/sig/eckcdsa.c

360

dbg_buf_print("h = H(z||m) pre-mask", hzm, hsize);

crypto/libecc/src/sig/eckcdsa.c

367

shift = (u8)((hsize > r_len) ? (hsize - r_len) : 0);

crypto/libecc/src/sig/eckcdsa.c

368

MUST_HAVE((hsize <= sizeof(hzm)), ret, err);

crypto/libecc/src/sig/eckcdsa.c

370

ret = buf_lshift(hzm, hsize, shift); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

421

dbg_buf_print("r pre-mask", r, hsize);

crypto/libecc/src/sig/eckcdsa.c

422

MUST_HAVE((hsize <= sizeof(r)), ret, err);

crypto/libecc/src/sig/eckcdsa.c

424

ret = buf_lshift(r, hsize, shift); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

501

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/eckcdsa.c

555

u8 hsize;

crypto/libecc/src/sig/eckcdsa.c

575

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/eckcdsa.c

576

r_len = (u8)ECKCDSA_R_LEN(hsize, q_bit_len);

crypto/libecc/src/sig/eckcdsa.c

589

MUST_HAVE((siglen == ECKCDSA_SIGLEN(hsize, q_bit_len)), ret, err);

crypto/libecc/src/sig/eckcdsa.c

659

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/eckcdsa.c

707

u8 hsize, shift;

crypto/libecc/src/sig/eckcdsa.c

738

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/eckcdsa.c

739

r_len = (u8)ECKCDSA_R_LEN(hsize, q_bit_len);

crypto/libecc/src/sig/eckcdsa.c

747

dbg_buf_print("h = H(z||m) pre-mask", hzm, hsize);

crypto/libecc/src/sig/eckcdsa.c

754

shift = (u8)((hsize > r_len) ? (hsize - r_len) : 0);

crypto/libecc/src/sig/eckcdsa.c

755

MUST_HAVE(hsize <= sizeof(hzm), ret, err);

crypto/libecc/src/sig/eckcdsa.c

756

ret = buf_lshift(hzm, hsize, shift); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

764

ret = local_memset(hzm, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

793

dbg_buf_print("r' pre-mask", r_prime, hsize);

crypto/libecc/src/sig/eckcdsa.c

794

ret = buf_lshift(r_prime, hsize, shift); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

82

int eckcdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize,

crypto/libecc/src/sig/eckcdsa.c

828

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/eckcdsa.c

90

(hsize <= MAX_DIGEST_SIZE) &&

crypto/libecc/src/sig/eckcdsa.c

93

(*siglen) = (u8)ECKCDSA_SIGLEN(hsize, q_bit_len);

crypto/libecc/src/sig/ecosdsa.c

43

int ecosdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize,

crypto/libecc/src/sig/ecosdsa.c

46

return __ecsdsa_siglen(p_bit_len, q_bit_len, hsize, blocksize, siglen);

crypto/libecc/src/sig/ecrdsa.c

101

int ecrdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen)

crypto/libecc/src/sig/ecrdsa.c

108

(hsize <= MAX_DIGEST_SIZE) && (blocksize <= MAX_BLOCK_SIZE), ret, err);

crypto/libecc/src/sig/ecrdsa.c

204

u8 hsize, r_len, s_len;

crypto/libecc/src/sig/ecrdsa.c

237

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/ecrdsa.c

298

ret = local_memset(h_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

302

dbg_buf_print("H(m)", h_buf, hsize);

crypto/libecc/src/sig/ecrdsa.c

307

ret = _reverse_endianness(h_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

309

ret = nn_init_from_buf(&e, h_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

310

ret = local_memset(h_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

376

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/ecrdsa.c

507

u8 hsize;

crypto/libecc/src/sig/ecrdsa.c

534

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/ecrdsa.c

537

ret = local_memset(h_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

541

dbg_buf_print("H(m)", h_buf, hsize);

crypto/libecc/src/sig/ecrdsa.c

546

ret = _reverse_endianness(h_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

550

ret = nn_init_from_buf(&h, h_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

551

ret = local_memset(h_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

612

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/ecsdsa.c

43

int ecsdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize,

crypto/libecc/src/sig/ecsdsa.c

46

return __ecsdsa_siglen(p_bit_len, q_bit_len, hsize, blocksize, siglen);

crypto/libecc/src/sig/ecsdsa_common.c

278

u8 hsize;

crypto/libecc/src/sig/ecsdsa_common.c

303

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/ecsdsa_common.c

304

r_len = (u8)ECSDSA_R_LEN(hsize);

crypto/libecc/src/sig/ecsdsa_common.c

307

MUST_HAVE((siglen == ECSDSA_SIGLEN(hsize, q_bit_len)), ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

315

ret = local_memset(r, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

397

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/ecsdsa_common.c

439

u8 hsize;

crypto/libecc/src/sig/ecsdsa_common.c

468

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/ecsdsa_common.c

469

r_len = (u8)ECSDSA_R_LEN(hsize);

crypto/libecc/src/sig/ecsdsa_common.c

472

MUST_HAVE((siglen == ECSDSA_SIGLEN(hsize, q_bit_len)), ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

547

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/ecsdsa_common.c

71

int __ecsdsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize,

crypto/libecc/src/sig/ecsdsa_common.c

79

(hsize <= MAX_DIGEST_SIZE) && (blocksize <= MAX_BLOCK_SIZE)),

crypto/libecc/src/sig/ecsdsa_common.c

82

(*siglen) = (u8)ECSDSA_SIGLEN(hsize, q_bit_len);

crypto/libecc/src/sig/eddsa.c

1085

int eddsa_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen)

crypto/libecc/src/sig/eddsa.c

1092

(hsize <= MAX_DIGEST_SIZE) && (blocksize <= MAX_BLOCK_SIZE), ret, err);

crypto/libecc/src/sig/eddsa.c

1094

(*siglen) = (u8)EDDSA_SIGLEN(hsize);

crypto/libecc/src/sig/eddsa.c

1235

u8 hsize, hash_size;

crypto/libecc/src/sig/eddsa.c

1285

hsize = h->digest_size;

crypto/libecc/src/sig/eddsa.c

1286

r_len = EDDSA_R_LEN(hsize);

crypto/libecc/src/sig/eddsa.c

1287

s_len = EDDSA_S_LEN(hsize);

crypto/libecc/src/sig/eddsa.c

1302

MUST_HAVE((siglen == EDDSA_SIGLEN(hsize)) && (siglen == (r_len + s_len)), ret, err);

crypto/libecc/src/sig/eddsa.c

1308

use_message_pre_hash_hsize = hsize;

crypto/libecc/src/sig/eddsa.c

1335

MUST_HAVE((hash_size == hsize), ret, err);

crypto/libecc/src/sig/eddsa.c

1353

ret = h->hfunc_update(&(ctx->sign_data.eddsa.h_ctx), &hash[hsize / 2], hsize / 2); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1356

MUST_HAVE((use_message_pre_hash_hsize <= hsize), ret, err);

crypto/libecc/src/sig/eddsa.c

1363

dbg_buf_print("h(h || m)", hash, hsize);

crypto/libecc/src/sig/eddsa.c

1366

ret = eddsa_decode_integer(&r, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1481

dbg_buf_print("h(R || PubKey || PH(m))", hash, hsize);

crypto/libecc/src/sig/eddsa.c

1483

ret = eddsa_decode_integer(&S, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1486

hsize = sizeof(hash);

crypto/libecc/src/sig/eddsa.c

1487

ret = eddsa_get_digest_from_priv_key(hash, &hsize, priv_key); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1489

ret = eddsa_compute_s(&s, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1522

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/eddsa.c

1580

u8 hsize, hash_size;

crypto/libecc/src/sig/eddsa.c

1633

hsize = h->digest_size;

crypto/libecc/src/sig/eddsa.c

1634

r_len = EDDSA_R_LEN(hsize);

crypto/libecc/src/sig/eddsa.c

1635

s_len = EDDSA_S_LEN(hsize);

crypto/libecc/src/sig/eddsa.c

1650

MUST_HAVE((siglen == EDDSA_SIGLEN(hsize)) && (siglen == (r_len + s_len)), ret, err);

crypto/libecc/src/sig/eddsa.c

1656

use_message_pre_hash_hsize = hsize;

crypto/libecc/src/sig/eddsa.c

1679

MUST_HAVE((hash_size == hsize), ret, err);

crypto/libecc/src/sig/eddsa.c

1701

ret = h->hfunc_update(&h_ctx, &hash[hsize / 2], hsize / 2); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1711

dbg_buf_print("h(h || PH(m))", hash, hsize);

crypto/libecc/src/sig/eddsa.c

1714

ret = eddsa_decode_integer(&r, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1839

dbg_buf_print("h(R || PubKey || PH(m))", hash, hsize);

crypto/libecc/src/sig/eddsa.c

1841

ret = eddsa_decode_integer(&S, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1844

hsize = sizeof(hash);

crypto/libecc/src/sig/eddsa.c

1845

ret = eddsa_get_digest_from_priv_key(hash, &hsize, priv_key); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1846

ret = eddsa_compute_s(&s, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1879

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/eddsa.c

1926

u16 hsize;

crypto/libecc/src/sig/eddsa.c

1959

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/eddsa.c

1976

MUST_HAVE((siglen == EDDSA_SIGLEN(hsize)), ret, err);

crypto/libecc/src/sig/eddsa.c

1977

MUST_HAVE((siglen == (EDDSA_R_LEN(hsize) + EDDSA_S_LEN(hsize))), ret, err);

crypto/libecc/src/sig/eddsa.c

2009

EDDSA_R_LEN(hsize), key_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2014

ret = ctx->h->hfunc_update(h_ctx, &sig[0], EDDSA_R_LEN(hsize)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2018

ret = eddsa_decode_integer(S, &sig[EDDSA_R_LEN(hsize)], EDDSA_S_LEN(hsize)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2043

MUST_HAVE((EDDSA_R_LEN(hsize) <= sizeof(buff)), ret, err);

crypto/libecc/src/sig/eddsa.c

2045

ret = eddsa_encode_point(&A, alpha_edwards, buff, EDDSA_R_LEN(hsize), key_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2048

ret = ctx->h->hfunc_update(h_ctx, buff, EDDSA_R_LEN(hsize)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2134

u16 hsize;

crypto/libecc/src/sig/eddsa.c

2163

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/eddsa.c

2178

use_message_pre_hash_hsize = hsize;

crypto/libecc/src/sig/eddsa.c

2195

MUST_HAVE((hsize <= sizeof(hash)), ret, err);

crypto/libecc/src/sig/eddsa.c

2203

MUST_HAVE((use_message_pre_hash_hsize <= hsize), ret, err);

crypto/libecc/src/sig/eddsa.c

2207

dbg_buf_print("hash = H(R || A || PH(M))", hash, hsize);

crypto/libecc/src/sig/eddsa.c

2210

ret = eddsa_decode_integer(&h, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2258

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/eddsa.c

2293

u16 hsize;

crypto/libecc/src/sig/eddsa.c

2333

hsize = hm->digest_size;

crypto/libecc/src/sig/eddsa.c

2340

use_message_pre_hash_hsize = hsize;

crypto/libecc/src/sig/eddsa.c

2391

ret = nn_get_random_len(&z, (hsize / 4)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2403

MUST_HAVE((siglen == EDDSA_SIGLEN(hsize)), ret, err);

crypto/libecc/src/sig/eddsa.c

2404

MUST_HAVE((siglen == (EDDSA_R_LEN(hsize) + EDDSA_S_LEN(hsize))), ret, err);

crypto/libecc/src/sig/eddsa.c

2436

EDDSA_R_LEN(hsize), key_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2441

ret = hm->hfunc_update(&h_ctx, &sig[0], EDDSA_R_LEN(hsize)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2450

ret = eddsa_decode_integer(&S, &sig[EDDSA_R_LEN(hsize)], EDDSA_S_LEN(hsize)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2480

MUST_HAVE((EDDSA_R_LEN(hsize) <= sizeof(hash)), ret, err);

crypto/libecc/src/sig/eddsa.c

2482

ret = eddsa_encode_point(&A, alpha_edwards, hash, EDDSA_R_LEN(hsize), key_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2485

ret = hm->hfunc_update(&h_ctx, hash, EDDSA_R_LEN(hsize)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2491

MUST_HAVE((use_message_pre_hash_hsize <= hsize), ret, err);

crypto/libecc/src/sig/eddsa.c

2498

dbg_buf_print("hash = H(R || A || PH(M))", hash, hsize);

crypto/libecc/src/sig/eddsa.c

2501

ret = eddsa_decode_integer(&h, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2595

u16 hsize;

crypto/libecc/src/sig/eddsa.c

2669

hsize = hm->digest_size;

crypto/libecc/src/sig/eddsa.c

2676

use_message_pre_hash_hsize = hsize;

crypto/libecc/src/sig/eddsa.c

2727

ret = nn_get_random_len(&z, (hsize / 4)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2739

MUST_HAVE((siglen == EDDSA_SIGLEN(hsize)), ret, err);

crypto/libecc/src/sig/eddsa.c

2740

MUST_HAVE((siglen == (EDDSA_R_LEN(hsize) + EDDSA_S_LEN(hsize))), ret, err);

crypto/libecc/src/sig/eddsa.c

2772

EDDSA_R_LEN(hsize), key_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2777

ret = hm->hfunc_update(&h_ctx, &sig[0], EDDSA_R_LEN(hsize)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2785

ret = eddsa_decode_integer(&S, &sig[EDDSA_R_LEN(hsize)], EDDSA_S_LEN(hsize)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2816

MUST_HAVE((EDDSA_R_LEN(hsize) <= sizeof(hash)), ret, err);

crypto/libecc/src/sig/eddsa.c

2818

ret = eddsa_encode_point(&A, alpha_edwards, hash, EDDSA_R_LEN(hsize), key_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2821

ret = hm->hfunc_update(&h_ctx, hash, EDDSA_R_LEN(hsize)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2827

MUST_HAVE((use_message_pre_hash_hsize <= hsize), ret, err);

crypto/libecc/src/sig/eddsa.c

2834

dbg_buf_print("hash = H(R || A || PH(M))", hash, hsize);

crypto/libecc/src/sig/eddsa.c

2837

ret = eddsa_decode_integer(&elements[num + i].number, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

102

ret = local_memcpy(hash, input, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

104

dbg_buf_print("h", hash, hsize);

crypto/libecc/src/sig/fuzzing_ecdsa.c

116

if ((hsize * 8) > q_bit_len) {

crypto/libecc/src/sig/fuzzing_ecdsa.c

117

rshift = (bitcnt_t)((hsize * 8) - q_bit_len);

crypto/libecc/src/sig/fuzzing_ecdsa.c

124

ret = nn_init_from_buf(&e, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

125

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

263

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/fuzzing_ecdsa.c

288

u8 hsize;

crypto/libecc/src/sig/fuzzing_ecdsa.c

315

hsize = inputlen;

crypto/libecc/src/sig/fuzzing_ecdsa.c

331

ret = local_memcpy(hash, input, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

333

dbg_buf_print("h = H(m)", hash, hsize);

crypto/libecc/src/sig/fuzzing_ecdsa.c

345

if ((hsize * 8) > q_bit_len) {

crypto/libecc/src/sig/fuzzing_ecdsa.c

346

rshift = (bitcnt_t)((hsize * 8) - q_bit_len);

crypto/libecc/src/sig/fuzzing_ecdsa.c

353

ret = nn_init_from_buf(&e, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

354

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

422

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/fuzzing_ecdsa.c

50

u8 hsize, q_len;

crypto/libecc/src/sig/fuzzing_ecdsa.c

81

hsize = inputlen;

crypto/libecc/src/sig/fuzzing_ecgdsa.c

104

ret = local_memcpy(e_buf, input, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

105

dbg_buf_print("H(m)", e_buf, hsize);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

113

if ((hsize * 8) > q_bit_len) {

crypto/libecc/src/sig/fuzzing_ecgdsa.c

114

rshift = (bitcnt_t)((hsize * 8) - q_bit_len);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

116

ret = nn_init_from_buf(&tmp, e_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

117

ret = local_memset(e_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

235

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

264

u8 hsize;

crypto/libecc/src/sig/fuzzing_ecgdsa.c

294

hsize = inputlen;

crypto/libecc/src/sig/fuzzing_ecgdsa.c

308

ret = local_memcpy(e_buf, input, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

309

dbg_buf_print("H(m)", e_buf, hsize);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

317

if ((hsize * 8) > q_bit_len) {

crypto/libecc/src/sig/fuzzing_ecgdsa.c

318

rshift = (bitcnt_t)((hsize * 8) - q_bit_len);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

320

ret = nn_init_from_buf(&tmp, e_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

321

ret = local_memset(e_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

379

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

48

u8 hsize, r_len, s_len;

crypto/libecc/src/sig/fuzzing_ecgdsa.c

84

hsize = inputlen;

crypto/libecc/src/sig/fuzzing_ecrdsa.c

124

hsize = inputlen;

crypto/libecc/src/sig/fuzzing_ecrdsa.c

196

ret = local_memcpy(h_buf, input, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

197

dbg_buf_print("H(m)", h_buf, hsize);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

202

ret = _reverse_endianness(h_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

205

ret = nn_init_from_buf(&tmp, h_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

206

ret = local_memset(h_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

269

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

299

u8 hsize;

crypto/libecc/src/sig/fuzzing_ecrdsa.c

327

hsize = inputlen;

crypto/libecc/src/sig/fuzzing_ecrdsa.c

341

ret = local_memcpy(h_buf, input, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

342

dbg_buf_print("H(m)", h_buf, hsize);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

347

ret = _reverse_endianness(h_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

351

ret = nn_init_from_buf(&tmp, h_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

352

ret = local_memset(h_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

414

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

91

u8 hsize, r_len, s_len;

crypto/libecc/src/sig/sm2.c

103

(hsize <= MAX_DIGEST_SIZE) && (blocksize <= MAX_BLOCK_SIZE), ret, err);

crypto/libecc/src/sig/sm2.c

139

u16 hsize, entlen, p_len;

crypto/libecc/src/sig/sm2.c

158

hsize = hm->digest_size;

crypto/libecc/src/sig/sm2.c

159

MUST_HAVE((*Zlen) >= hsize, ret, err);

crypto/libecc/src/sig/sm2.c

200

dbg_buf_print("Z", Z, hsize);

crypto/libecc/src/sig/sm2.c

205

(*Zlen) = hsize;

crypto/libecc/src/sig/sm2.c

315

u8 hsize, q_len;

crypto/libecc/src/sig/sm2.c

348

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/sm2.c

359

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/sm2.c

365

dbg_buf_print("h", hash, hsize);

crypto/libecc/src/sig/sm2.c

393

ret = nn_init_from_buf(&tmp, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/sm2.c

394

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/sm2.c

481

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/sm2.c

620

u8 hsize;

crypto/libecc/src/sig/sm2.c

645

hsize = ctx->h->digest_size;

crypto/libecc/src/sig/sm2.c

653

dbg_buf_print("h = H(m)", hash, hsize);

crypto/libecc/src/sig/sm2.c

663

ret = nn_init_from_buf(&tmp, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/sm2.c

664

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/sm2.c

713

VAR_ZEROIFY(hsize);

crypto/libecc/src/sig/sm2.c

96

int sm2_siglen(u16 p_bit_len, u16 q_bit_len, u8 hsize, u8 blocksize, u8 *siglen)

lib/libusbhid/data.c

100

hsize = h->report_size; /* bit length of data */

lib/libusbhid/data.c

102

if (hsize != 32) {

lib/libusbhid/data.c

103

mask = (1 << hsize) - 1;

lib/libusbhid/data.c

113

end = (hpos + hsize) / 8 - offs;

lib/libusbhid/data.c

44

uint32_t hsize;

lib/libusbhid/data.c

55

hsize = h->report_size; /* bit length of data */

lib/libusbhid/data.c

58

if (hsize == 0)

lib/libusbhid/data.c

60

if (hsize > 32)

lib/libusbhid/data.c

61

hsize = 32;

lib/libusbhid/data.c

64

end = (hpos + hsize) / 8 - offs;

lib/libusbhid/data.c

71

hsize = 32 - hsize;

lib/libusbhid/data.c

75

data = (int32_t)((int32_t)data << hsize) >> hsize;

lib/libusbhid/data.c

77

data = (uint32_t)((uint32_t)data << hsize) >> hsize;

lib/libusbhid/data.c

87

uint32_t hsize;

lib/libutil/realhostname.c

177

trimdomain(buf, hsize);

lib/libutil/realhostname.c

178

if (strlen(buf) > hsize &&

lib/libutil/realhostname.c

183

strncpy(host, buf, hsize);

lib/libutil/realhostname.c

193

strncpy(host, buf, hsize);

lib/libutil/realhostname.c

48

realhostname(char *host, size_t hsize, const struct in_addr *ip)

lib/libutil/realhostname.c

60

if (strlen(trimmed) <= hsize) {

lib/libutil/realhostname.c

73

strncpy(host, trimmed, hsize);

lib/libutil/realhostname.c

80

strncpy(host, inet_ntoa(*ip), hsize);

lib/libutil/realhostname.c

98

realhostname_sa(char *host, size_t hsize, struct sockaddr *addr, int addrlen)

sbin/hastd/hast_checksum.c

105

nv_add_uint8_array(nv, hash, hsize, "hash");

sbin/hastd/hast_checksum.c

90

size_t hsize;

sbin/hastd/hast_checksum.c

96

hast_crc32_checksum(*datap, *sizep, hash, &hsize);

sbin/hastd/hast_checksum.c

99

hast_sha256_checksum(*datap, *sizep, hash, &hsize);

sbin/hastd/hast_proto.c

116

hptr = ebuf_data(eb, &hsize);

sbin/hastd/hast_proto.c

117

if (proto_send(conn, hptr, hsize) == -1)

sbin/hastd/hast_proto.c

85

size_t hsize;

stand/efi/boot1/boot1.c

180

UINTN i, hsize, nhandles;

stand/efi/boot1/boot1.c

229

hsize = 0;

stand/efi/boot1/boot1.c

231

&hsize, NULL);

stand/efi/boot1/boot1.c

232

handles = malloc(hsize);

stand/efi/boot1/boot1.c

235

hsize);

stand/efi/boot1/boot1.c

237

NULL, &hsize, handles);

stand/efi/boot1/boot1.c

240

nhandles = hsize / sizeof(*handles);

stand/efi/libefi/efi_driver_utils.c

38

UINTN nhandles, i, hsize;

stand/efi/libefi/efi_driver_utils.c

41

hsize = 0;

stand/efi/libefi/efi_driver_utils.c

43

&hsize, NULL);

stand/efi/libefi/efi_driver_utils.c

49

handles = malloc(hsize);

stand/efi/libefi/efi_driver_utils.c

52

nhandles = hsize / sizeof(EFI_HANDLE);

stand/efi/libefi/efi_driver_utils.c

55

&hsize, handles);

stand/efi/loader/framebuffer.c

576

UINTN hsize;

stand/efi/loader/framebuffer.c

578

hsize = 0;

stand/efi/loader/framebuffer.c

580

status = BS->LocateHandle(ByProtocol, &gop_guid, NULL, &hsize, hlist);

stand/efi/loader/framebuffer.c

591

UINTN nhandles, i, hsize;

stand/efi/loader/framebuffer.c

598

hsize = 0;

stand/efi/loader/framebuffer.c

600

status = BS->LocateHandle(ByProtocol, &gop_guid, NULL, &hsize, hlist);

stand/efi/loader/framebuffer.c

602

hlist = malloc(hsize);

stand/efi/loader/framebuffer.c

605

status = BS->LocateHandle(ByProtocol, &gop_guid, NULL, &hsize,

stand/efi/loader/framebuffer.c

620

nhandles = hsize / sizeof(*hlist);

sys/arm64/broadcom/genet/if_genet.c

1278

int hsize = size; \

sys/arm64/broadcom/genet/if_genet.c

1289

bcopy(p, copy_p, hsize); \

sys/arm64/broadcom/genet/if_genet.c

1290

m0->m_len += hsize; \

sys/arm64/broadcom/genet/if_genet.c

1291

m->m_len -= hsize; \

sys/arm64/broadcom/genet/if_genet.c

1292

m->m_data += hsize; \

sys/arm64/broadcom/genet/if_genet.c

1294

copy_p += hsize; \

sys/dev/drm2/drm_crtc.h

1060

int hsize, int vsize, int fresh,

sys/dev/drm2/drm_edid.c

555

int hsize, int vsize, int fresh,

sys/dev/drm2/drm_edid.c

562

if (hsize != ptr->hdisplay)

sys/dev/drm2/drm_edid.c

745

int hsize, vsize;

sys/dev/drm2/drm_edid.c

753

if (bad_std_timing(t->hsize, t->vfreq_aspect))

sys/dev/drm2/drm_edid.c

757

hsize = t->hsize * 8 + 248;

sys/dev/drm2/drm_edid.c

763

vsize = hsize;

sys/dev/drm2/drm_edid.c

765

vsize = (hsize * 10) / 16;

sys/dev/drm2/drm_edid.c

767

vsize = (hsize * 3) / 4;

sys/dev/drm2/drm_edid.c

769

vsize = (hsize * 4) / 5;

sys/dev/drm2/drm_edid.c

771

vsize = (hsize * 9) / 16;

sys/dev/drm2/drm_edid.c

775

((hsize == 1360 && vsize == 765) ||

sys/dev/drm2/drm_edid.c

776

(hsize == 1368 && vsize == 769))) {

sys/dev/drm2/drm_edid.c

777

hsize = 1366;

sys/dev/drm2/drm_edid.c

788

if (m->hdisplay == hsize && m->vdisplay == vsize &&

sys/dev/drm2/drm_edid.c

793

if (hsize == 1366 && vsize == 768 && vrefresh_rate == 60) {

sys/dev/drm2/drm_edid.c

804

mode = drm_mode_find_dmt(dev, hsize, vsize, vrefresh_rate,

sys/dev/drm2/drm_edid.c

809

mode = drm_mode_find_dmt(dev, hsize, vsize, vrefresh_rate, false);

sys/dev/drm2/drm_edid.c

818

mode = drm_gtf_mode(dev, hsize, vsize, vrefresh_rate, 0, 0);

sys/dev/drm2/drm_edid.c

826

mode = drm_gtf_mode(dev, hsize, vsize, vrefresh_rate, 0, 0);

sys/dev/drm2/drm_edid.c

831

mode = drm_gtf_mode_complex(dev, hsize, vsize,

sys/dev/drm2/drm_edid.c

840

mode = drm_cvt_mode(dev, hsize, vsize, vrefresh_rate, 0, 0,

sys/dev/drm2/drm_edid.h

50

u8 hsize; /* need to multiply by 8 then add 248 */

sys/dev/fb/splash_pcx.c

166

uint16_t hsize;

sys/dev/hid/hid.c

708

uint32_t hsize = loc->size;

sys/dev/hid/hid.c

713

DPRINTFN(11, "hid_get_data: loc %d/%d\n", hpos, hsize);

sys/dev/hid/hid.c

716

if (hsize == 0)

sys/dev/hid/hid.c

718

if (hsize > 32)

sys/dev/hid/hid.c

719

hsize = 32;

sys/dev/hid/hid.c

724

n = (hsize + 7) / 8;

sys/dev/hid/hid.c

734

n = 32 - hsize;

sys/dev/hid/hid.c

767

uint32_t hsize = loc->size;

sys/dev/hid/hid.c

773

DPRINTFN(11, "hid_put_data: loc %d/%d = %u\n", hpos, hsize, value);

sys/dev/hid/hid.c

776

if (hsize == 0)

sys/dev/hid/hid.c

778

if (hsize > 32)

sys/dev/hid/hid.c

779

hsize = 32;

sys/dev/hid/hid.c

783

n = (hsize + 7) / 8;

sys/dev/hid/hid.c

785

mask = ((1ULL << hsize) - 1ULL) << (hpos % 8);

sys/net/if_llatbl.c

808

lltable_allocate_htbl(uint32_t hsize)

sys/net/if_llatbl.c

814

llt->llt_hsize = hsize;

sys/net/if_llatbl.c

815

llt->lle_head = malloc(sizeof(struct llentries) * hsize,

sys/net/if_llatbl.h

233

struct lltable *lltable_allocate_htbl(uint32_t hsize);

sys/netinet/in.c

1654

in_lltable_hash_dst(const struct in_addr dst, uint32_t hsize)

sys/netinet/in.c

1657

return (IN_LLTBL_HASH(dst.s_addr, hsize));

sys/netinet/in.c

1661

in_lltable_hash(const struct llentry *lle, uint32_t hsize)

sys/netinet/in.c

1664

return (in_lltable_hash_dst(lle->r_l3addr.addr4, hsize));

sys/netinet6/in6.c

2327

in6_lltable_hash_dst(const struct in6_addr *dst, uint32_t hsize)

sys/netinet6/in6.c

2330

return (IN6_LLTBL_HASH(dst->s6_addr32[3], hsize));

sys/netinet6/in6.c

2334

in6_lltable_hash(const struct llentry *lle, uint32_t hsize)

sys/netinet6/in6.c

2337

return (in6_lltable_hash_dst(&lle->r_l3addr.addr6, hsize));

sys/netpfil/ipfw/ip_fw_table_algo.c

1007

hash_ip(uint32_t addr, int hsize)

sys/netpfil/ipfw/ip_fw_table_algo.c

1010

return (addr % (hsize - 1));

sys/netpfil/ipfw/ip_fw_table_algo.c

1016

hash_ip6(struct in6_addr *addr6, int hsize)

sys/netpfil/ipfw/ip_fw_table_algo.c

1023

return (i % (hsize - 1));

sys/netpfil/ipfw/ip_fw_table_algo.c

1027

hash_ip64(struct in6_addr *addr6, int hsize)

sys/netpfil/ipfw/ip_fw_table_algo.c

1033

return (i % (hsize - 1));

sys/netpfil/ipfw/ip_fw_table_algo.c

1037

hash_ip6_slow(struct in6_addr *addr6, void *key, int mask, int hsize)

sys/netpfil/ipfw/ip_fw_table_algo.c

1044

return (hash_ip6(addr6, hsize));

sys/netpfil/ipfw/ip_fw_table_algo.c

1048

hash_ip6_al(struct in6_addr *addr6, void *key, int mask, int hsize)

sys/netpfil/ipfw/ip_fw_table_algo.c

1056

return (hash_ip6(addr6, hsize));

sys/netpfil/ipfw/ip_fw_table_algo.c

1066

uint16_t hash, hsize;

sys/netpfil/ipfw/ip_fw_table_algo.c

1073

hsize = 1 << ((ti->data & 0xFFFF) >> 8);

sys/netpfil/ipfw/ip_fw_table_algo.c

1077

hash = hash_ip(a, hsize);

sys/netpfil/ipfw/ip_fw_table_algo.c

1091

hsize = 1 << (ti->data & 0xFF);

sys/netpfil/ipfw/ip_fw_table_algo.c

1092

hash = hash_ip6_slow(&addr6, key, imask, hsize);

sys/netpfil/ipfw/ip_fw_table_algo.c

1111

uint16_t hash, hsize;

sys/netpfil/ipfw/ip_fw_table_algo.c

1118

hsize = 1 << ((ti->data & 0xFFFF) >> 8);

sys/netpfil/ipfw/ip_fw_table_algo.c

1122

hash = hash_ip(a, hsize);

sys/netpfil/ipfw/ip_fw_table_algo.c

1137

hsize = 1 << (ti->data & 0xFF);

sys/netpfil/ipfw/ip_fw_table_algo.c

1139

hash = hash_ip6_al(&addr6, key, imask, hsize);

sys/netpfil/ipfw/ip_fw_table_algo.c

1160

uint16_t hash, hsize;

sys/netpfil/ipfw/ip_fw_table_algo.c

1167

hsize = 1 << ((ti->data & 0xFFFF) >> 8);

sys/netpfil/ipfw/ip_fw_table_algo.c

1171

hash = hash_ip(a, hsize);

sys/netpfil/ipfw/ip_fw_table_algo.c

1185

hsize = 1 << (ti->data & 0xFF);

sys/netpfil/ipfw/ip_fw_table_algo.c

1187

hash = hash_ip64((struct in6_addr *)key, hsize);

sys/netpfil/ipfw/ip_fw_table_algo.c

1283

uint32_t hsize;

sys/netpfil/ipfw/ip_fw_table_algo.c

1313

hsize = ta_log2(cfg->size4) << 8 | ta_log2(cfg->size6);

sys/netpfil/ipfw/ip_fw_table_algo.c

1316

hsize;

sys/netpfil/ipfw/ip_fw_table_algo.c

1320

cfg->mask6 << 13 | hsize;

sys/netpfil/ipfw/ip_fw_table_algo.c

1325

cfg->mask6 << 16 | hsize;

sys/netpfil/ipfw/ip_fw_table_algo.c

3104

static __inline uint32_t hash_flow4(struct fhashentry4 *f, int hsize);

sys/netpfil/ipfw/ip_fw_table_algo.c

3105

static __inline uint32_t hash_flow6(struct fhashentry6 *f, int hsize);

sys/netpfil/ipfw/ip_fw_table_algo.c

3155

hash_flow4(struct fhashentry4 *f, int hsize)

sys/netpfil/ipfw/ip_fw_table_algo.c

3161

return (i % (hsize - 1));

sys/netpfil/ipfw/ip_fw_table_algo.c

3165

hash_flow6(struct fhashentry6 *f, int hsize)

sys/netpfil/ipfw/ip_fw_table_algo.c

3175

return (i % (hsize - 1));

sys/netpfil/ipfw/ip_fw_table_algo.c

3200

uint32_t hash, hsize;

sys/netpfil/ipfw/ip_fw_table_algo.c

3204

hsize = ti->data;

sys/netpfil/ipfw/ip_fw_table_algo.c

3218

hash = hash_flow4(&f, hsize);

sys/netpfil/ipfw/ip_fw_table_algo.c

3243

hash = hash_flow6(&f, hsize);

sys/netpfil/ipfw/ip_fw_table_algo.c

952

static __inline uint32_t hash_ip(uint32_t addr, int hsize);

sys/netpfil/ipfw/ip_fw_table_algo.c

955

static __inline uint32_t hash_ip6(struct in6_addr *addr6, int hsize);

sys/netpfil/ipfw/ip_fw_table_algo.c

956

static __inline uint16_t hash_ip64(struct in6_addr *addr6, int hsize);

sys/netpfil/ipfw/ip_fw_table_algo.c

958

int mask, int hsize);

sys/netpfil/ipfw/ip_fw_table_algo.c

960

int hsize);

sys/netpfil/ipfw/nat64/nat64lsn.c

972

int i, j, hsize;

sys/netpfil/ipfw/nat64/nat64lsn.c

979

hsize = h->states_hashsize * 2;

sys/netpfil/ipfw/nat64/nat64lsn.c

980

hash = malloc(sizeof(*hash)* hsize, M_NOWAIT);

sys/netpfil/ipfw/nat64/nat64lsn.c

983

for (j = 0; j < hsize; j++)

usr.bin/compress/zopen.c

273

for (fcode = (long)hsize; fcode < 65536L; fcode *= 2L)

usr.bin/compress/zopen.c

277

hsize_reg = hsize;

usr.bin/compress/zopen.c

649

cl_hash(zs, (count_int) hsize);

usr.bin/compress/zopen.c

706

hsize = HSIZE; /* For dynamic table sizing. */

usr.bin/posixshmcontrol/posixshmcontrol.c

228

bool hsize, jailed, uname;

usr.bin/posixshmcontrol/posixshmcontrol.c

230

hsize = false;

usr.bin/posixshmcontrol/posixshmcontrol.c

237

hsize = true;

usr.bin/posixshmcontrol/posixshmcontrol.c

329

if (hsize) {

usr.bin/posixshmcontrol/posixshmcontrol.c

401

stat_one_shm(const char *path, bool hsize, bool uname)

usr.bin/posixshmcontrol/posixshmcontrol.c

431

if (hsize) {

usr.bin/posixshmcontrol/posixshmcontrol.c

462

bool hsize, uname;

usr.bin/posixshmcontrol/posixshmcontrol.c

464

hsize = false;

usr.bin/posixshmcontrol/posixshmcontrol.c

470

hsize = true;

usr.bin/posixshmcontrol/posixshmcontrol.c

490

ret1 = stat_one_shm(argv[i], hsize, uname);