mbedtls_mpi::n field

mbedtls_mpi_core_cond_assign(X->p, Y->p, Y->n, do_assign);

bignum.c:131

for (size_t i = Y->n; i < X->n; i++) {

bignum.c:134

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(X, Y->n));

bignum.c:162

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(Y, X->n));

bignum.c:163

mbedtls_mpi_core_cond_swap(X->p, Y->p, X->n, do_swap);

bignum.c:169

X->n = 0;

bignum.c:184

mbedtls_mpi_init()

mbedtls_mpi_zeroize_and_free(X->p, X->n);

X->n = 0;

if (X->n < nblimbs) {

bignum.c:217

memcpy(p, X->p, X->n * ciL);

bignum.c:223

mbedtls_mpi_zeroize_and_free(X->p, X->n);

bignum.c:224

X->n = (unsigned short) nblimbs;

bignum.c:229

if (X->n <= nblimbs) {

bignum.c:250

for (i = X->n - 1; i > 0; i--) {

bignum.c:255

mbedtls_mpi_zeroize_and_free(X->p, X->n);

bignum.c:272

X->n = (unsigned short) i;

bignum.c:277

mbedtls_mpi_resize_clear()

} else if (X->n == limbs) {

bignum.c:289

if (Y->n == 0) {

if (X->n != 0) {

memset(X->p, 0, X->n * ciL);

bignum.c:319

mbedtls_mpi_copy()

for (i = Y->n - 1; i > 0; i--) {

if (X->n < i) {

memset(X->p + i, 0, (X->n - i) * ciL);

bignum.c:336

mbedtls_mpi_copy()

memset(X->p, 0, X->n * ciL);

bignum.c:382

mbedtls_mpi_lset()

if (X->n * biL <= pos) {

bignum.c:397

mbedtls_mpi_get_bit()

if (X->n * biL <= pos) {

bignum.c:417

mbedtls_mpi_set_bit()

for (i = 0; i < X->n; i++) {

bignum.c:451

mbedtls_mpi_lsb()

return mbedtls_mpi_core_bitlen(X->p, X->n);

bignum.c:475

mbedtls_mpi_bitlen()

for (i = X->n, k = 0; i > 0; i--) {

bignum.c:663

mbedtls_mpi_write_string()

MBEDTLS_MPI_CHK(mbedtls_mpi_core_read_le(X->p, X->n, buf, buflen));

bignum.c:802

mbedtls_mpi_read_binary_le()

MBEDTLS_MPI_CHK(mbedtls_mpi_core_read_be(X->p, X->n, buf, buflen));

bignum.c:828

mbedtls_mpi_read_binary()

return mbedtls_mpi_core_write_le(X->p, X->n, buf, buflen);

bignum.c:846

mbedtls_mpi_write_binary_le()

return mbedtls_mpi_core_write_be(X->p, X->n, buf, buflen);

bignum.c:855

mbedtls_mpi_write_binary()

if (X->n * biL < i) {

bignum.c:868

mbedtls_mpi_shift_l()

mbedtls_mpi_core_shift_l(X->p, X->n, count);

bignum.c:874

mbedtls_mpi_shift_l()

if (X->n != 0) {

bignum.c:885

mbedtls_mpi_shift_r()

mbedtls_mpi_core_shift_r(X->p, X->n, count);

bignum.c:886

mbedtls_mpi_shift_r()

for (i = X->n; i > 0; i--) {

bignum.c:898

mbedtls_mpi_cmp_abs()

for (j = Y->n; j > 0; j--) {

bignum.c:904

mbedtls_mpi_cmp_abs()

for (i = X->n; i > 0; i--) {

bignum.c:939

mbedtls_mpi_cmp_mpi()

for (j = Y->n; j > 0; j--) {

bignum.c:945

mbedtls_mpi_cmp_mpi()

Y.n = 1;

bignum.c:991

mbedtls_mpi_cmp_int()

for (j = B->n; j > 0; j--) {

bignum.c:1020

mbedtls_mpi_add_abs()

if (j >= X->n) {

bignum.c:1045

mbedtls_mpi_add_abs()

for (n = B->n; n > 0; n--) {

bignum.c:1067

if (n > A->n) {

bignum.c:1072

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(X, A->n));

bignum.c:1078

if (A->n > n && A != X) {

bignum.c:1083

memcpy(X->p + n, A->p + n, (A->n - n) * ciL);

bignum.c:1084

if (X->n > A->n) {

bignum.c:1086

memset(X->p + A->n, 0, (X->n - A->n) * ciL);

bignum.c:1087

carry = mbedtls_mpi_core_sub_int(X->p + n, X->p + n, carry, X->n - n);

bignum.c:1093

B.n = 1;

bignum.c:1168

mbedtls_mpi_add_int()

B.n = 1;

bignum.c:1184

mbedtls_mpi_sub_int()

for (i = A->n; i > 0; i--) {

bignum.c:1211

mbedtls_mpi_mul_mpi()

for (j = B->n; j > 0; j--) {

bignum.c:1220

mbedtls_mpi_mul_mpi()

size_t n = A->n;

bignum.c:1256

mbedtls_mpi_mul_int()

mbedtls_mpi_core_mla(X->p, X->n, A->p, n, b - 1);

bignum.c:1281

mbedtls_mpi_mul_int()

T2.n = sizeof(TP2) / sizeof(*TP2);

bignum.c:1417

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(&Z, A->n + 2));

bignum.c:1434

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(&T1, A->n + 2));

bignum.c:1436

n = X.n - 1;

bignum.c:1447

t = Y.n - 1;

bignum.c:1448

B.n = 1;

bignum.c:1527

mbedtls_mpi_div_int()

if (b == 1 || A->n == 0) {

bignum.c:1578

mbedtls_mpi_mod_int()

for (i = A->n, y = 0; i > 0; i--) {

bignum.c:1591

mbedtls_mpi_mod_int()

if (E->n == 0) {

bignum.c:1650

size_t T_limbs = mbedtls_mpi_core_exp_mod_working_limbs(N->n, E->n);

bignum.c:1658

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(prec_RR, N->n));

bignum.c:1677

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(X, N->n));

bignum.c:1705

mbedtls_mpi_core_to_mont_rep(X->p, X->p, N->p, N->n, mm, RR.p, T);

bignum.c:1712

mbedtls_mpi_core_exp_mod_unsafe(X->p, X->p, N->p, N->n, E->p, E->n, RR.p, T);

bignum.c:1714

mbedtls_mpi_core_exp_mod(X->p, X->p, N->p, N->n, E->p, E->n, RR.p, T);

bignum.c:1716

mbedtls_mpi_core_from_mont_rep(X->p, X->p, N->p, N->n, mm, T);

bignum.c:1718

mbedtls_ct_condition_t is_x_non_zero = mbedtls_mpi_core_check_zero_ct(X->p, X->n);

bignum.c:1725

mbedtls_mpi_fill_random()

ret = mbedtls_mpi_core_fill_random(X->p, X->n, size, f_rng, p_rng);

bignum.c:1901

int ret = mbedtls_mpi_resize_clear(X, N->n);

bignum.c:1923

mbedtls_mpi_random()

return mbedtls_mpi_core_random(X->p, min, N->p, X->n, f_rng, p_rng);

bignum.c:1928

mbedtls_mpi_random()

MBEDTLS_MPI_CHK(mbedtls_mpi_fill_random(&A, X->n * ciL, f_rng, p_rng));

bignum.c:2112

mpi_miller_rabin()

A.p[A.n - 1] &= ((mbedtls_mpi_uint) 1 << (k - (A.n - 1) * biL - 1)) - 1;

bignum.c:2117

mpi_miller_rabin()

XX.n = X->n;

bignum.c:2182

mbedtls_mpi_is_prime_ext()

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_l(X, N->n * 2 * biL));

bignum_core.c:588

mbedtls_mpi_core_get_mont_r2_unsafe()

MBEDTLS_MPI_CHK(mbedtls_mpi_shrink(X, N->n));

bignum_core.c:590

mbedtls_mpi_core_get_mont_r2_unsafe()

MBEDTLS_MPI_CHK(mbedtls_mpi_shrink(&T[i]->X, grp->P.n));

ecp.c:1434

ecp_normalize_jac_many()

MBEDTLS_MPI_CHK(mbedtls_mpi_shrink(&T[i]->Y, grp->P.n));

ecp.c:1435

ecp_normalize_jac_many()

static const mbedtls_mpi ecp_x25519_bad_point_1 = ECP_MPI_INIT_ARRAY(

ecp.c:2957

static const mbedtls_mpi ecp_x25519_bad_point_2 = ECP_MPI_INIT_ARRAY(

ecp.c:2959

if (key->d.n == 0) {

ecp.c:3381

mbedtls_ecp_write_key_ext()

X->n = (unsigned short) (len / sizeof(mbedtls_mpi_uint));

X->n = 1;

end = p + N->n;

SUB(13); ADD(10); LAST; // A6 += -A13 + A10

ecp_curves.c:5025

ecp_mod_p224()

SUB(10); SUB(11); SUB(12); SUB(13); LAST; // A7

ecp_curves.c:5062

ecp_mod_p256()

SUB(22); LAST; // A11

ecp_curves.c:5111

ecp_mod_p384()

if (N->n < P521_WIDTH) {

ecp_curves.c:5156

M.n = N->n - (P521_WIDTH - 1);

ecp_curves.c:5162

if (M.n > P521_WIDTH + 1) {

ecp_curves.c:5163

M.n = P521_WIDTH + 1;

ecp_curves.c:5164

memcpy(Mp, N->p + P521_WIDTH - 1, M.n * sizeof(mbedtls_mpi_uint));

ecp_curves.c:5167

for (i = P521_WIDTH; i < N->n; i++) {

ecp_curves.c:5172

const size_t NT_n = N->n - P255_WIDTH;

ecp_curves.c:5204

ecp_mod_p255()

if (N->n <= P255_WIDTH) {

ecp_curves.c:5205

ecp_mod_p255()

if (N->n < p_limbs) {

R.n = P_KOBLITZ_R;

M.n = (unsigned short) (N->n - (p_limbs - adjust));

ecp_curves.c:5336

if (M.n > p_limbs + adjust) {

ecp_curves.c:5337

M.n = (unsigned short) (p_limbs + adjust);

ecp_curves.c:5338

memcpy(Mp, N->p + p_limbs - adjust, M.n * sizeof(mbedtls_mpi_uint));

ecp_curves.c:5341

M.n += R.n; /* Make room for multiplication by R */

ecp_curves.c:5345

for (i = p_limbs; i < N->n; i++) {

ecp_curves.c:5351

M.n = (unsigned short) (N->n - (p_limbs - adjust));

ecp_curves.c:5362

if (M.n > p_limbs + adjust) {

ecp_curves.c:5363

M.n = (unsigned short) (p_limbs + adjust);

ecp_curves.c:5364

memcpy(Mp, N->p + p_limbs - adjust, M.n * sizeof(mbedtls_mpi_uint));

ecp_curves.c:5367

M.n += R.n; /* Make room for multiplication by R */

ecp_curves.c:5371

for (i = p_limbs; i < N->n; i++) {

ecp_curves.c:5377

mbedtls_pk_get_psa_attributes()

int has_private = (ec->d.n != 0);

pk.c:476

if (ec->d.n == 0) {

pk.c:704

import_pair_into_psa()

const size_t nlimbs = N->n;

rsa.c:1354

rsa_unblind()

Call Tree

All items filtered out

Data Use

mbedtls_mpi::n is written by 14 functions and is read by 46 functions:

mbedtls_mpi_cmp_int()

mbedtls_mpi_add_int()

mbedtls_mpi_sub_int()

mbedtls_mpi_is_prime_ext()

mbedtls_mpi_div_int()

mbedtls_mpi::n

mbedtls_mpi_lt_mpi_ct()

mbedtls_mpi_free()

mbedtls_mpi_resize_clear()

mbedtls_mpi_copy()

mbedtls_mpi_lset()

mbedtls_mpi_get_bit()

mbedtls_mpi_set_bit()

mbedtls_mpi_lsb()

mbedtls_mpi_bitlen()

mbedtls_mpi_write_string()

mbedtls_mpi_read_binary_le()

mbedtls_mpi_read_binary()

mbedtls_mpi_write_binary_le()

mbedtls_mpi_write_binary()

mbedtls_mpi_shift_l()

mbedtls_mpi_shift_r()

mbedtls_mpi_cmp_abs()

mbedtls_mpi_cmp_mpi()

mbedtls_mpi_add_abs()

mbedtls_mpi_mul_mpi()

mbedtls_mpi_mul_int()

mbedtls_mpi_mod_int()