MBEDTLS_MPI_CHK - syntax, references, description

References

from 0/1 examples

Code

Location

#define MBEDTLS_MPI_CHK(f) \

bignum.h:40

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(X, *p, len));

asn1write.c:119

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

bignum.c:124

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_CHK(mbedtls_mpi_grow(X, i));

bignum.c:334

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(X, 1));

bignum.c:381

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(X, off + 1));

bignum.c:422

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(X, n));

bignum.c:546

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(X, 0));

bignum.c:547

MBEDTLS_MPI_CHK(mpi_get_digit(&d, radix, s[i - 1]));

bignum.c:550

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(X, 0));

bignum.c:554

MBEDTLS_MPI_CHK(mpi_get_digit(&d, radix, s[i]));

bignum.c:557

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_int(&T, X, radix));

bignum.c:558

MBEDTLS_MPI_CHK(mbedtls_mpi_add_int(X, &T, d));

bignum.c:559

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_int(&r, X, radix));

bignum.c:590

MBEDTLS_MPI_CHK(mbedtls_mpi_div_int(X, NULL, X, radix));

bignum.c:591

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&T, X));

bignum.c:677

MBEDTLS_MPI_CHK(mpi_write_hlp(&T, radix, &p, buflen));

bignum.c:683

MBEDTLS_MPI_CHK(mbedtls_mpi_write_string(X, radix, s, sizeof(s) - 2, &n));

bignum.c:761

MBEDTLS_MPI_CHK(mbedtls_mpi_resize_clear(X, limbs));

bignum.c:800

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

bignum.c:802

MBEDTLS_MPI_CHK(mbedtls_mpi_resize_clear(X, limbs));

bignum.c:826

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

bignum.c:828

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(X, BITS_TO_LIMBS(i)));

bignum.c:869

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(X, A));

bignum.c:1012

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(X, j));

bignum.c:1032

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(X, j + 1));

bignum.c:1046

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

bignum.c:1078

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_abs(X, A, B));

bignum.c:1122

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_abs(X, B, A));

bignum.c:1128

MBEDTLS_MPI_CHK(mbedtls_mpi_add_abs(X, A, B));

bignum.c:1133

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&TA, A)); A = &TA;

bignum.c:1205

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&TB, B)); B = &TB;

bignum.c:1208

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(X, i + j));

bignum.c:1229

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(X, 0));

bignum.c:1230

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(X, n + 1));

bignum.c:1279

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(X, A));

bignum.c:1280

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(Q, 0));

bignum.c:1422

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(R, A));

bignum.c:1425

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&X, A));

bignum.c:1430

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&Y, B));

bignum.c:1431

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

bignum.c:1434

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&Z, 0));

bignum.c:1435

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

bignum.c:1436

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_l(&X, k));

bignum.c:1441

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_l(&Y, k));

bignum.c:1442

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_l(&Y, biL * (n - t)));

bignum.c:1449

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&X, &X, &Y));

bignum.c:1453

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&Y, biL * (n - t)));

bignum.c:1455

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&T1, 0));

bignum.c:1473

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_int(&T1, &T1, Z.p[i - t - 1]));

bignum.c:1476

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_int(&T1, &Y, Z.p[i - t - 1]));

bignum.c:1479

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_l(&T1, biL * (i - t - 1)));

bignum.c:1480

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&X, &X, &T1));

bignum.c:1481

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&T1, &Y));

bignum.c:1484

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_l(&T1, biL * (i - t - 1)));

bignum.c:1485

MBEDTLS_MPI_CHK(mbedtls_mpi_add_mpi(&X, &X, &T1));

bignum.c:1486

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(Q, &Z));

bignum.c:1492

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&X, k));

bignum.c:1497

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(R, &X));

bignum.c:1499

MBEDTLS_MPI_CHK(mbedtls_mpi_div_mpi(NULL, R, A, B));

bignum.c:1544

MBEDTLS_MPI_CHK(mbedtls_mpi_add_mpi(R, R, B));

bignum.c:1547

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(R, R, B));

bignum.c:1551

MBEDTLS_MPI_CHK(mbedtls_mpi_core_get_mont_r2_unsafe(&RR, N));

bignum.c:1671

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

bignum.c:1677

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(X, A));

bignum.c:1685

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(X, X, N));

bignum.c:1703

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

bignum.c:1705

MBEDTLS_MPI_CHK(mbedtls_mpi_add_mpi(X, N, X));

bignum.c:1728

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&TA, A));

bignum.c:1787

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&TB, B));

bignum.c:1788

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&TA, mbedtls_mpi_lsb(&TA)));

bignum.c:1843

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&TB, mbedtls_mpi_lsb(&TB)));

bignum.c:1844

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_abs(&TA, &TA, &TB));

bignum.c:1854

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&TA, 1));

bignum.c:1855

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_abs(&TB, &TB, &TA));

bignum.c:1857

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&TB, 1));

bignum.c:1858

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_l(&TB, lz));

bignum.c:1872

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(G, &TB));

bignum.c:1873

MBEDTLS_MPI_CHK(mbedtls_mpi_resize_clear(X, limbs));

bignum.c:1896

MBEDTLS_MPI_CHK(mbedtls_mpi_gcd(&G, A, N));

bignum.c:1947

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&TA, A, N));

bignum.c:1954

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&TU, &TA));

bignum.c:1955

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&TB, N));

bignum.c:1956

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&TV, N));

bignum.c:1957

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&U1, 1));

bignum.c:1959

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&U2, 0));

bignum.c:1960

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&V1, 0));

bignum.c:1961

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&V2, 1));

bignum.c:1962

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&TU, 1));

bignum.c:1966

MBEDTLS_MPI_CHK(mbedtls_mpi_add_mpi(&U1, &U1, &TB));

bignum.c:1969

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&U2, &U2, &TA));

bignum.c:1970

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&U1, 1));

bignum.c:1973

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&U2, 1));

bignum.c:1974

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&TV, 1));

bignum.c:1978

MBEDTLS_MPI_CHK(mbedtls_mpi_add_mpi(&V1, &V1, &TB));

bignum.c:1981

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&V2, &V2, &TA));

bignum.c:1982

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&V1, 1));

bignum.c:1985

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&V2, 1));

bignum.c:1986

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&TU, &TU, &TV));

bignum.c:1990

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&U1, &U1, &V1));

bignum.c:1991

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&U2, &U2, &V2));

bignum.c:1992

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&TV, &TV, &TU));

bignum.c:1994

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&V1, &V1, &U1));

bignum.c:1995

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&V2, &V2, &U2));

bignum.c:1996

MBEDTLS_MPI_CHK(mbedtls_mpi_add_mpi(&V1, &V1, N));

bignum.c:2001

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&V1, &V1, N));

bignum.c:2005

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(X, &V1));

bignum.c:2008

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_int(&r, X, p));

bignum.c:2068

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&W, X, 1));

bignum.c:2101

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&R, &W));

bignum.c:2103

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&R, s));

bignum.c:2104

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

bignum.c:2112

MBEDTLS_MPI_CHK(mbedtls_mpi_exp_mod(&A, &A, &R, X, &RR));

bignum.c:2131

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&T, &A, &A));

bignum.c:2143

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&A, &T, X));

bignum.c:2144

MBEDTLS_MPI_CHK(mbedtls_mpi_fill_random(X, n * ciL, f_rng, p_rng));

bignum.c:2256

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(X, k - nbits));

bignum.c:2264

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_int(&r, X, 3));

bignum.c:2283

MBEDTLS_MPI_CHK(mbedtls_mpi_add_int(X, X, 8));

bignum.c:2285

MBEDTLS_MPI_CHK(mbedtls_mpi_add_int(X, X, 4));

bignum.c:2287

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&Y, X));

bignum.c:2291

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&Y, 1));

bignum.c:2292

MBEDTLS_MPI_CHK(mbedtls_mpi_add_int(X, X, 12));

bignum.c:2317

MBEDTLS_MPI_CHK(mbedtls_mpi_add_int(&Y, &Y, 6));

bignum.c:2318

MBEDTLS_MPI_CHK(mbedtls_mpi_read_string(&A, 16,

bignum.c:2355

MBEDTLS_MPI_CHK(mbedtls_mpi_read_string(&E, 16,

bignum.c:2361

MBEDTLS_MPI_CHK(mbedtls_mpi_read_string(&N, 16,

bignum.c:2367

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&X, &A, &N));

bignum.c:2372

MBEDTLS_MPI_CHK(mbedtls_mpi_read_string(&U, 16,

bignum.c:2374

MBEDTLS_MPI_CHK(mbedtls_mpi_div_mpi(&X, &Y, &A, &N));

bignum.c:2400

MBEDTLS_MPI_CHK(mbedtls_mpi_read_string(&U, 16,

bignum.c:2402

MBEDTLS_MPI_CHK(mbedtls_mpi_read_string(&V, 16,

bignum.c:2405

MBEDTLS_MPI_CHK(mbedtls_mpi_exp_mod(&X, &A, &E, &N, NULL));

bignum.c:2428

MBEDTLS_MPI_CHK(mbedtls_mpi_read_string(&U, 16,

bignum.c:2430

MBEDTLS_MPI_CHK(mbedtls_mpi_inv_mod(&X, &A, &N));

bignum.c:2452

MBEDTLS_MPI_CHK(mbedtls_mpi_read_string(&U, 16,

bignum.c:2454

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&X, gcd_pairs[i][0]));

bignum.c:2481

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&Y, gcd_pairs[i][1]));

bignum.c:2482

MBEDTLS_MPI_CHK(mbedtls_mpi_gcd(&A, &X, &Y));

bignum.c:2484

MBEDTLS_MPI_CHK( mbedtls_mpi_grow(Z, hw_words) );

bignum_alt.c:193

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(Z, Z, M));

bignum_alt.c:200

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(X, 1));

bignum_core.c:587

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

bignum_core.c:588

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(X, X, N));

bignum_core.c:589

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

bignum_core.c:590

MBEDTLS_MPI_CHK(f_rng(p_rng, (unsigned char *) X + overhead, n_bytes));

bignum_core.c:630

MBEDTLS_MPI_CHK(mbedtls_mpi_core_fill_random(X, limbs,

bignum_core.c:677

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&U, P, 2));

dhm.c:86

MBEDTLS_MPI_CHK(mbedtls_mpi_random(R, 3, M, f_rng, p_rng));

dhm.c:173

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(R, R, 1));

dhm.c:174

MBEDTLS_MPI_CHK(mbedtls_mpi_fill_random(&ctx->X, x_size, f_rng, p_rng));

dhm.c:194

MBEDTLS_MPI_CHK(mbedtls_mpi_exp_mod(&ctx->GX, &ctx->G, &ctx->X,

dhm.c:209

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary((X), \

dhm.c:243

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&ctx->GX, output, olen));

dhm.c:327

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&ctx->pX, &ctx->X));

dhm.c:356

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&ctx->Vi, 1));

dhm.c:357

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&ctx->Vf, 1));

dhm.c:358

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&ctx->Vi, &ctx->Vi, &ctx->Vi));

dhm.c:368

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&ctx->Vi, &ctx->Vi, &ctx->P));

dhm.c:369

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&ctx->Vf, &ctx->Vf, &ctx->Vf));

dhm.c:371

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&ctx->Vf, &ctx->Vf, &ctx->P));

dhm.c:372

MBEDTLS_MPI_CHK(dhm_random_below(&ctx->Vi, &ctx->P, f_rng, p_rng));

dhm.c:382

MBEDTLS_MPI_CHK(dhm_random_below(&R, &ctx->P, f_rng, p_rng));

dhm.c:387

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&ctx->Vf, &ctx->Vi, &R));

dhm.c:388

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&ctx->Vf, &ctx->Vf, &ctx->P));

dhm.c:389

MBEDTLS_MPI_CHK(mbedtls_mpi_inv_mod(&ctx->Vf, &ctx->Vf, &ctx->P));

dhm.c:390

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&ctx->Vf, &ctx->Vf, &R));

dhm.c:391

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&ctx->Vf, &ctx->Vf, &ctx->P));

dhm.c:392

MBEDTLS_MPI_CHK(mbedtls_mpi_exp_mod(&ctx->Vf, &ctx->Vf, &ctx->X, &ctx->P, &ctx->RP));

dhm.c:394

MBEDTLS_MPI_CHK(dhm_update_blinding(ctx, f_rng, p_rng));

dhm.c:428

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&GYb, &ctx->GY, &ctx->Vi));

dhm.c:429

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&GYb, &GYb, &ctx->P));

dhm.c:430

MBEDTLS_MPI_CHK(mbedtls_mpi_exp_mod(&ctx->K, &GYb, &ctx->X,

dhm.c:433

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&ctx->K, &ctx->K, &ctx->Vf));

dhm.c:437

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&ctx->K, &ctx->K, &ctx->P));

dhm.c:438

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&ctx->K, output, *olen));

dhm.c:443

MBEDTLS_MPI_CHK(mbedtls_ecp_gen_privkey(grp, d, f_rng, p_rng));

ecdh.c:68

MBEDTLS_MPI_CHK(mbedtls_ecp_mul_restartable(grp, Q, d, &grp->G,

ecdh.c:71

MBEDTLS_MPI_CHK(mbedtls_ecp_mul_restartable(grp, &P, d, Q,

ecdh.c:105

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(z, &P.X));

ecdh.c:113

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(x, buf, use_size));

ecdsa.c:210

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(x, use_size * 8 - grp->nbits));

ecdsa.c:212

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(x, x, &grp->N));

ecdsa.c:217

MBEDTLS_MPI_CHK(mbedtls_ecp_gen_privkey(grp, pk, f_rng, p_rng));

ecdsa.c:308

MBEDTLS_MPI_CHK(mbedtls_ecp_mul_restartable(grp, &R, pk, &grp->G,

ecdsa.c:317

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(pr, &R.X, &grp->N));

ecdsa.c:321

MBEDTLS_MPI_CHK(derive_mpi(grp, &e, buf, blen));

ecdsa.c:340

MBEDTLS_MPI_CHK(mbedtls_ecp_gen_privkey(grp, &t, f_rng_blind,

ecdsa.c:346

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(s, pr, d));

ecdsa.c:352

MBEDTLS_MPI_CHK(mbedtls_mpi_add_mpi(&e, &e, s));

ecdsa.c:353

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&e, &e, &t));

ecdsa.c:354

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(pk, pk, &t));

ecdsa.c:355

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(pk, pk, &grp->N));

ecdsa.c:356

MBEDTLS_MPI_CHK(mbedtls_mpi_inv_mod(s, pk, &grp->N));

ecdsa.c:357

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(s, s, &e));

ecdsa.c:358

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(s, s, &grp->N));

ecdsa.c:359

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(d, data, grp_len));

ecdsa.c:435

MBEDTLS_MPI_CHK(derive_mpi(grp, &h, buf, blen));

ecdsa.c:436

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&h, data + grp_len, grp_len));

ecdsa.c:437

MBEDTLS_MPI_CHK(mbedtls_hmac_drbg_seed_buf(p_rng, md_info, data, 2 * grp_len));

ecdsa.c:438

MBEDTLS_MPI_CHK(derive_mpi(grp, &e, buf, blen));

ecdsa.c:536

MBEDTLS_MPI_CHK(mbedtls_mpi_inv_mod(&s_inv, s, &grp->N));

ecdsa.c:543

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(pu1, &e, &s_inv));

ecdsa.c:545

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(pu1, pu1, &grp->N));

ecdsa.c:546

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(pu2, r, &s_inv));

ecdsa.c:548

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(pu2, pu2, &grp->N));

ecdsa.c:549

MBEDTLS_MPI_CHK(mbedtls_ecp_muladd_restartable(grp,

ecdsa.c:561

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&R.X, &R.X, &grp->N));

ecdsa.c:573

MBEDTLS_MPI_CHK(mbedtls_ecdsa_sign_det_restartable(&ctx->grp, &r, &s, &ctx->d,

ecdsa.c:657

MBEDTLS_MPI_CHK(ecdsa_signature_to_asn1(&r, &s, sig, sig_size, slen));

ecdsa.c:676

MBEDTLS_MPI_CHK(mbedtls_ecp_group_load(&ctx->grp, curve));

ecjpake.c:114

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&ctx->s, secret, len));

ecjpake.c:116

MBEDTLS_MPI_CHK(ecjpake_write_len_point(&p, end, grp, pf, G));

ecjpake.c:209

MBEDTLS_MPI_CHK(ecjpake_write_len_point(&p, end, grp, pf, V));

ecjpake.c:210

MBEDTLS_MPI_CHK(ecjpake_write_len_point(&p, end, grp, pf, X));

ecjpake.c:211

MBEDTLS_MPI_CHK(mbedtls_ecjpake_compute_hash(md_type,

ecjpake.c:228

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(h, hash,

ecjpake.c:232

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(h, h, &grp->N));

ecjpake.c:234

MBEDTLS_MPI_CHK(mbedtls_ecp_tls_read_point(grp, &V, p, (size_t) (end - *p)));

ecjpake.c:272

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&r, *p, r_len));

ecjpake.c:286

MBEDTLS_MPI_CHK(ecjpake_hash(md_type, grp, pf, G, &V, X, id, &h));

ecjpake.c:292

MBEDTLS_MPI_CHK(mbedtls_ecp_muladd((mbedtls_ecp_group *) grp,

ecjpake.c:293

MBEDTLS_MPI_CHK(mbedtls_ecp_gen_keypair_base((mbedtls_ecp_group *) grp,

ecjpake.c:340

MBEDTLS_MPI_CHK(ecjpake_hash(md_type, grp, pf, G, &V, X, id, &h));

ecjpake.c:342

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&h, &h, x)); /* x*h */

ecjpake.c:343

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&h, &v, &h)); /* v - x*h */

ecjpake.c:344

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&h, &h, &grp->N)); /* r */

ecjpake.c:345

MBEDTLS_MPI_CHK(mbedtls_ecp_tls_write_point(grp, &V,

ecjpake.c:348

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&h, *p, len)); /* r */

ecjpake.c:359

MBEDTLS_MPI_CHK(mbedtls_ecp_tls_read_point(grp, X, p, (size_t) (end - *p)));

ecjpake.c:395

MBEDTLS_MPI_CHK(ecjpake_zkp_read(md_type, grp, pf, G, X, id, p, end));

ecjpake.c:401

MBEDTLS_MPI_CHK(mbedtls_ecp_gen_keypair_base((mbedtls_ecp_group *) grp, G, x, X,

ecjpake.c:431

MBEDTLS_MPI_CHK(mbedtls_ecp_tls_write_point(grp, X,

ecjpake.c:433

MBEDTLS_MPI_CHK(ecjpake_zkp_write(md_type, grp, pf, G, x, X, id,

ecjpake.c:438

MBEDTLS_MPI_CHK(ecjpake_kkp_read(md_type, grp, pf, G, Xa, id, &p, end));

ecjpake.c:468

MBEDTLS_MPI_CHK(ecjpake_kkp_read(md_type, grp, pf, G, Xb, id, &p, end));

ecjpake.c:469

MBEDTLS_MPI_CHK(ecjpake_kkp_write(md_type, grp, pf, G, xm1, Xa, id,

ecjpake.c:502

MBEDTLS_MPI_CHK(ecjpake_kkp_write(md_type, grp, pf, G, xm2, Xb, id,

ecjpake.c:504

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&one, 1));

ecjpake.c:553

MBEDTLS_MPI_CHK(mbedtls_ecp_muladd(grp, R, &one, A, &one, B));

ecjpake.c:554

MBEDTLS_MPI_CHK(mbedtls_ecp_muladd(grp, R, &one, R, &one, C));

ecjpake.c:555

MBEDTLS_MPI_CHK(ecjpake_ecp_add3(&ctx->grp, &G,

ecjpake.c:585

MBEDTLS_MPI_CHK(mbedtls_ecp_tls_read_group(&grp, &p, len));

ecjpake.c:595

MBEDTLS_MPI_CHK(ecjpake_kkp_read(ctx->md_type, &ctx->grp,

ecjpake.c:602

MBEDTLS_MPI_CHK(mbedtls_mpi_fill_random(&b, 16, f_rng, p_rng));

ecjpake.c:634

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&b, &b, N));

ecjpake.c:635

MBEDTLS_MPI_CHK(mbedtls_mpi_add_mpi(&b, &b, S));

ecjpake.c:636

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(R, X, &b));

ecjpake.c:639

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(R, R, N));

ecjpake.c:641

MBEDTLS_MPI_CHK(ecjpake_ecp_add3(&ctx->grp, &G,

ecjpake.c:676

MBEDTLS_MPI_CHK(ecjpake_mul_secret(&xm, 1, &ctx->xm2, &ctx->s,

ecjpake.c:678

MBEDTLS_MPI_CHK(mbedtls_ecp_mul(&ctx->grp, &Xm, &xm, &G, f_rng, p_rng));

ecjpake.c:680

MBEDTLS_MPI_CHK(mbedtls_ecp_tls_write_group(&ctx->grp, &ec_len,

ecjpake.c:695

MBEDTLS_MPI_CHK(mbedtls_ecp_tls_write_point(&ctx->grp, &Xm,

ecjpake.c:704

MBEDTLS_MPI_CHK(ecjpake_zkp_write(ctx->md_type, &ctx->grp,

ecjpake.c:708

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&one, 1));

ecjpake.c:737

MBEDTLS_MPI_CHK(ecjpake_mul_secret(&m_xm2_s, -1, &ctx->xm2, &ctx->s,

ecjpake.c:744

MBEDTLS_MPI_CHK(mbedtls_ecp_muladd(&ctx->grp, K,

ecjpake.c:746

MBEDTLS_MPI_CHK(mbedtls_ecp_mul(&ctx->grp, K, &ctx->xm2, K,

ecjpake.c:749

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&K.X, kx, x_bytes));

ecjpake.c:783

MBEDTLS_MPI_CHK(mbedtls_ecjpake_compute_hash(ctx->md_type,

ecjpake.c:784

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&ctx->xm1, xm1, len1));

ecjpake.c:1008

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&ctx->xm2, xm2, len2));

ecjpake.c:1009

MBEDTLS_MPI_CHK(mbedtls_ecp_mul(&ctx->grp, &ctx->Xm1, &ctx->xm1,

ecjpake.c:1010

MBEDTLS_MPI_CHK(mbedtls_ecp_mul(&ctx->grp, &ctx->Xm2, &ctx->xm2,

ecjpake.c:1012

MBEDTLS_MPI_CHK(ecjpake_test_load(&cli,

ecjpake.c:1130

MBEDTLS_MPI_CHK(ecjpake_test_load(&srv,

ecjpake.c:1134

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&P->X, &Q->X));

ecp.c:620

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&P->Y, &Q->Y));

ecp.c:621

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&P->Z, &Q->Z));

ecp.c:622

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&pt->X, 1));

ecp.c:642

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&pt->Y, 1));

ecp.c:643

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&pt->Z, 0));

ecp.c:644

MBEDTLS_MPI_CHK(mbedtls_mpi_read_string(&P->X, radix, x));

ecp.c:680

MBEDTLS_MPI_CHK(mbedtls_mpi_read_string(&P->Y, radix, y));

ecp.c:681

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&P->Z, 1));

ecp.c:682

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary_le(&P->X, buf, plen));

ecp.c:713

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&P->X, buf + 1, plen));

ecp.c:740

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&P->Y, buf + 1 + plen, plen));

ecp.c:741

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&P->X, buf + 1, plen));

ecp.c:750

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary_le(&pt->X, buf, plen));

ecp.c:787

MBEDTLS_MPI_CHK(mbedtls_mpi_set_bit(&pt->X, plen * 8 - 1, 0));

ecp.c:792

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&pt->Z, 1));

ecp.c:795

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&pt->X, buf + 1, plen));

ecp.c:812

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&pt->Z, 1));

ecp.c:813

MBEDTLS_MPI_CHK(grp->modp(N));

ecp.c:1013

MBEDTLS_MPI_CHK(mbedtls_mpi_add_mpi(N, N, &grp->P));

ecp.c:1017

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_abs(N, N, &grp->P));

ecp.c:1022

MBEDTLS_MPI_CHK(ecp_modp(&(N), grp)); \

ecp.c:1051

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(X, A, B));

ecp.c:1061

MBEDTLS_MPI_CHK(mbedtls_mpi_add_mpi((N), (N), &grp->P)); \

ecp.c:1074

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(X, A, B));

ecp.c:1084

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_abs((N), (N), &grp->P))

ecp.c:1097

MBEDTLS_MPI_CHK(mbedtls_mpi_add_mpi(X, A, B));

ecp.c:1105

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_int(X, A, c));

ecp.c:1119

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(X, A, c));

ecp.c:1133

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int_mod(grp, X, A, c))

ecp.c:1140

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_l(X, count));

ecp.c:1148

MBEDTLS_MPI_CHK(mbedtls_mpi_add_mod(grp, X, A, B))

ecp.c:1161

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mod(grp, X, A, B))

ecp.c:1164

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mod(grp, X, A, B))

ecp.c:1167

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mod(grp, X, A, A))

ecp.c:1170

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_int_mod(grp, X, A, c))

ecp.c:1173

MBEDTLS_MPI_CHK(mbedtls_mpi_inv_mod((dst), (src), &grp->P))

ecp.c:1176

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(X, A))

ecp.c:1179

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_l_mod(grp, X, count))

ecp.c:1182

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(X, c))

ecp.c:1185

MBEDTLS_MPI_CHK(mbedtls_mpi_random((X), 2, &grp->P, f_rng, p_rng))

ecp.c:1195

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&tmp, &grp->P, (X))); \

ecp.c:1203

MBEDTLS_MPI_CHK(mbedtls_mpi_safe_cond_assign((X), &tmp, \

ecp.c:1204

MBEDTLS_MPI_CHK(mbedtls_mpi_safe_cond_assign((X), (Y), (cond)))

ecp.c:1214

MBEDTLS_MPI_CHK(mbedtls_mpi_safe_cond_swap((X), (Y), (cond)))

ecp.c:1217

MBEDTLS_MPI_CHK(ecp_sw_rhs(grp, Y, X));

ecp.c:1275

MBEDTLS_MPI_CHK(mbedtls_mpi_add_int(&exp, &grp->P, 1));

ecp.c:1279

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&exp, 2));

ecp.c:1280

MBEDTLS_MPI_CHK(mbedtls_mpi_exp_mod(Y, Y /*y^2*/, &exp, &grp->P, NULL));

ecp.c:1282

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(Y, &grp->P, Y));

ecp.c:1290

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

ecp.c:1434

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

ecp.c:1435

MBEDTLS_MPI_CHK(mbedtls_ecp_copy(&T[0], P));

ecp.c:1900

MBEDTLS_MPI_CHK(mbedtls_ecp_copy(cur, T + (i >> 1)));

ecp.c:1916

MBEDTLS_MPI_CHK(ecp_double_jac(grp, cur, cur, tmp));

ecp.c:1919

MBEDTLS_MPI_CHK(ecp_normalize_jac_many(grp, TT, j));

ecp.c:1943

MBEDTLS_MPI_CHK(ecp_add_mixed(grp, &T[i + j], &T[j], &T[i], tmp));

ecp.c:1961

MBEDTLS_MPI_CHK(ecp_normalize_jac_many(grp, TT, j));

ecp.c:1983

MBEDTLS_MPI_CHK(ecp_safe_invert_jac(grp, R, i >> 7));

ecp.c:2032

MBEDTLS_MPI_CHK(ecp_select_comb(grp, R, T, T_size, x[i]));

ecp.c:2081

MBEDTLS_MPI_CHK(ecp_randomize_jac(grp, R, f_rng, p_rng));

ecp.c:2083

MBEDTLS_MPI_CHK(ecp_double_jac(grp, R, R, tmp));

ecp.c:2091

MBEDTLS_MPI_CHK(ecp_select_comb(grp, &Txi, T, T_size, x[i]));

ecp.c:2092

MBEDTLS_MPI_CHK(ecp_add_mixed(grp, R, R, &Txi, tmp));

ecp.c:2093

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&M, m));

ecp.c:2146

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&mm, &grp->N, m));

ecp.c:2147

MBEDTLS_MPI_CHK(mbedtls_mpi_safe_cond_assign(&M, &mm, *parity_trick));

ecp.c:2148

MBEDTLS_MPI_CHK(ecp_comb_recode_scalar(grp, m, k, d, w,

ecp.c:2193

MBEDTLS_MPI_CHK(ecp_mul_comb_core(grp, RR, T, T_size, k, d,

ecp.c:2195

MBEDTLS_MPI_CHK(ecp_safe_invert_jac(grp, RR, parity_trick));

ecp.c:2197

MBEDTLS_MPI_CHK(ecp_randomize_jac(grp, RR, f_rng, p_rng));

ecp.c:2219

MBEDTLS_MPI_CHK(ecp_normalize_jac(grp, RR));

ecp.c:2222

MBEDTLS_MPI_CHK(ecp_precompute_comb(grp, T, P, w, d, rs_ctx));

ecp.c:2354

MBEDTLS_MPI_CHK(ecp_mul_comb_after_precomp(grp, R, m,

ecp.c:2365

MBEDTLS_MPI_CHK(mbedtls_ecp_copy(&RP, P));

ecp.c:2572

MBEDTLS_MPI_CHK(ecp_randomize_mxz(grp, &RP, f_rng, p_rng));

ecp.c:2583

MBEDTLS_MPI_CHK(ecp_double_add_mxz(grp, R, &RP, R, &RP, &PX, tmp));

ecp.c:2598

MBEDTLS_MPI_CHK(ecp_randomize_mxz(grp, R, f_rng, p_rng));

ecp.c:2614

MBEDTLS_MPI_CHK(ecp_normalize_mxz(grp, R));

ecp.c:2615

MBEDTLS_MPI_CHK(mbedtls_ecp_check_privkey(grp, m));

ecp.c:2676

MBEDTLS_MPI_CHK(mbedtls_ecp_check_pubkey(grp, P));

ecp.c:2677

MBEDTLS_MPI_CHK(ecp_mul_mxz(grp, R, m, P, f_rng, p_rng));

ecp.c:2683

MBEDTLS_MPI_CHK(ecp_mul_comb(grp, R, m, P, f_rng, p_rng, rs_ctx));

ecp.c:2688

MBEDTLS_MPI_CHK(ecp_sw_rhs(grp, &RHS, &pt->X));

ecp.c:2764

MBEDTLS_MPI_CHK(mbedtls_ecp_check_pubkey(grp, P));

ecp.c:2796

MBEDTLS_MPI_CHK(mbedtls_ecp_set_zero(R));

ecp.c:2797

MBEDTLS_MPI_CHK(mbedtls_ecp_check_pubkey(grp, P));

ecp.c:2799

MBEDTLS_MPI_CHK(mbedtls_ecp_copy(R, P));

ecp.c:2800

MBEDTLS_MPI_CHK(mbedtls_ecp_check_pubkey(grp, P));

ecp.c:2802

MBEDTLS_MPI_CHK(mbedtls_ecp_copy(R, P));

ecp.c:2803

MBEDTLS_MPI_CHK(ecp_mul_restartable_internal(grp, R, m, P,

ecp.c:2806

MBEDTLS_MPI_CHK(mbedtls_ecp_mul_shortcuts(grp, pmP, m, P, rs_ctx));

ecp.c:2862

MBEDTLS_MPI_CHK(mbedtls_ecp_mul_shortcuts(grp, pR, n, Q, rs_ctx));

ecp.c:2870

MBEDTLS_MPI_CHK(ecp_add_mixed(grp, pR, pmP, pR, tmp));

ecp.c:2886

MBEDTLS_MPI_CHK(ecp_normalize_jac(grp, pR));

ecp.c:2895

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&XmP, X));

ecp.c:2979

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&XmP, &XmP, P));

ecp.c:2981

MBEDTLS_MPI_CHK(mbedtls_mpi_add_int(&XmP, &XmP, 1));

ecp.c:3009

MBEDTLS_MPI_CHK(mbedtls_mpi_fill_random(d, n_random_bytes,

ecp.c:3131

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(d, 8 * n_random_bytes - high_bit - 1));

ecp.c:3133

MBEDTLS_MPI_CHK(mbedtls_mpi_set_bit(d, high_bit, 1));

ecp.c:3135

MBEDTLS_MPI_CHK(mbedtls_mpi_set_bit(d, 0, 0));

ecp.c:3139

MBEDTLS_MPI_CHK(mbedtls_mpi_set_bit(d, 1, 0));

ecp.c:3140

MBEDTLS_MPI_CHK(mbedtls_mpi_set_bit(d, 2, 0));

ecp.c:3142

MBEDTLS_MPI_CHK(mbedtls_ecp_gen_privkey(grp, d, f_rng, p_rng));

ecp.c:3199

MBEDTLS_MPI_CHK(mbedtls_ecp_mul(grp, Q, d, G, f_rng, p_rng));

ecp.c:3200

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary_le(&key->d, buf, buflen));

ecp.c:3277

MBEDTLS_MPI_CHK(mbedtls_mpi_set_bit(&key->d, 0, 0));

ecp.c:3280

MBEDTLS_MPI_CHK(mbedtls_mpi_set_bit(&key->d, 1, 0));

ecp.c:3281

MBEDTLS_MPI_CHK(mbedtls_mpi_set_bit(&key->d, 2, 0));

ecp.c:3282

MBEDTLS_MPI_CHK(

ecp.c:3285

MBEDTLS_MPI_CHK(

ecp.c:3291

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary_le(&key->d, buf, buflen));

ecp.c:3300

MBEDTLS_MPI_CHK(mbedtls_mpi_set_bit(&key->d, 0, 0));

ecp.c:3303

MBEDTLS_MPI_CHK(mbedtls_mpi_set_bit(&key->d, 1, 0));

ecp.c:3304

MBEDTLS_MPI_CHK(

ecp.c:3307

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&key->d, buf, buflen));

ecp.c:3316

MBEDTLS_MPI_CHK(mbedtls_ecp_check_privkey(&key->grp, &key->d));

ecp.c:3321

MBEDTLS_MPI_CHK(mbedtls_ecp_mul(&grp, &Q, &prv->d, &prv->grp.G, f_rng, p_rng));

ecp.c:3439

MBEDTLS_MPI_CHK(mbedtls_mpi_read_string(m, 16, exponents[0]));

ecp.c:3569

MBEDTLS_MPI_CHK(self_test_adjust_exponent(grp, m));

ecp.c:3570

MBEDTLS_MPI_CHK(mbedtls_ecp_mul(grp, R, m, P, self_test_rng, NULL));

ecp.c:3571

MBEDTLS_MPI_CHK(mbedtls_mpi_read_string(m, 16, exponents[i]));

ecp.c:3581

MBEDTLS_MPI_CHK(self_test_adjust_exponent(grp, m));

ecp.c:3582

MBEDTLS_MPI_CHK(mbedtls_ecp_mul(grp, R, m, P, self_test_rng, NULL));

ecp.c:3583

MBEDTLS_MPI_CHK(mbedtls_ecp_group_load(&grp, MBEDTLS_ECP_DP_SECP192R1));

ecp.c:3653

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&m, 2));

ecp.c:3662

MBEDTLS_MPI_CHK(mbedtls_ecp_mul(&grp, &P, &m, &grp.G, self_test_rng, NULL));

ecp.c:3663

MBEDTLS_MPI_CHK(mbedtls_ecp_group_load(&grp, MBEDTLS_ECP_DP_CURVE25519));

ecp.c:3693

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&grp->A, curve25519_a24));

ecp_curves.c:4627

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&grp->P, 1));

ecp_curves.c:4630

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_l(&grp->P, 255));

ecp_curves.c:4631

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&grp->P, &grp->P, 19));

ecp_curves.c:4632

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&grp->N,

ecp_curves.c:4636

MBEDTLS_MPI_CHK(mbedtls_mpi_set_bit(&grp->N, 252, 1));

ecp_curves.c:4638

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&grp->G.X, 9));

ecp_curves.c:4642

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&grp->G.Z, 1));

ecp_curves.c:4643

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(N, 6 * WIDTH));

ecp_curves.c:4869

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(N, (b) * 2 / biL + 1)); \

ecp_curves.c:4960

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&M, 521 % (8 * sizeof(mbedtls_mpi_uint))));

ecp_curves.c:5168

MBEDTLS_MPI_CHK(mbedtls_mpi_add_abs(N, N, &M));

ecp_curves.c:5177

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&M, shift));

ecp_curves.c:5343

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&M, &M, &R));

ecp_curves.c:5356

MBEDTLS_MPI_CHK(mbedtls_mpi_add_abs(N, N, &M));

ecp_curves.c:5357

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&M, shift));

ecp_curves.c:5369

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&M, &M, &R));

ecp_curves.c:5382

MBEDTLS_MPI_CHK(mbedtls_mpi_add_abs(N, N, &M));

ecp_curves.c:5383

MBEDTLS_MPI_CHK(mbedtls_mpi_set_bit(&RR, num_bits * 2, 1));

esp_bignum.c:209

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(Rinv, &RR, M));

esp_bignum.c:210

MBEDTLS_MPI_CHK(calculate_rinv(&Rinv, M, hw_words));

esp_bignum.c:243

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(Z, z_words));

esp_bignum.c:250

MBEDTLS_MPI_CHK( esp_mont_hw_op(&X_, X, Rinv, M, Mprime, hw_words, false) );

esp_bignum.c:314

MBEDTLS_MPI_CHK( esp_mont_hw_op(Z, Rinv, &one, M, Mprime, hw_words, true) );

esp_bignum.c:318

MBEDTLS_MPI_CHK( esp_mont_hw_op(Z, Z, Z, M, Mprime, hw_words, true) );

esp_bignum.c:324

MBEDTLS_MPI_CHK( esp_mont_hw_op(Z, Z, &X_, M, Mprime, hw_words, true) );

esp_bignum.c:329

MBEDTLS_MPI_CHK( esp_mont_hw_op(Z, Z, &one, M, Mprime, hw_words, true) );

esp_bignum.c:334

MBEDTLS_MPI_CHK(calculate_rinv(Rinv, M, num_words));

esp_bignum.c:399

MBEDTLS_MPI_CHK(ret);

esp_bignum.c:407

MBEDTLS_MPI_CHK(mbedtls_mpi_add_mpi(Z, M, Z));

esp_bignum.c:443

MBEDTLS_MPI_CHK( mbedtls_mpi_grow(Z, z_words) );

esp_bignum.c:520

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi(&Ztemp, X, &Yp) );

esp_bignum.c:613

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi(Z, X, &Ypp) );

esp_bignum.c:616

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l(Z, words_slice * 32) );

esp_bignum.c:619

MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi(Z, Z, &Ztemp) );

esp_bignum.c:622

MBEDTLS_MPI_CHK( mbedtls_mpi_grow(Z, hw_words) );

esp_bignum.c:639

MBEDTLS_MPI_CHK(mbedtls_ecp_group_load(&ref, *id));

pkparse.c:271

MBEDTLS_MPI_CHK(mbedtls_ecp_group_load(&ecp_group, grp_id));

psa_crypto.c:6208

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&diff_N_2, &ecp_group.N, 2));

psa_crypto.c:6217

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&k, *data, m_bytes));

psa_crypto.c:6246

MBEDTLS_MPI_CHK(mbedtls_mpi_lt_mpi_ct(&diff_N_2, &k, &key_out_of_range));

psa_crypto.c:6252

MBEDTLS_MPI_CHK(mbedtls_mpi_add_int(&k, &k, 1));

psa_crypto.c:6256

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&k, *data, m_bytes));

psa_crypto.c:6257

MBEDTLS_MPI_CHK(mbedtls_ecdsa_sign_det_ext(

psa_crypto_ecp.c:399

MBEDTLS_MPI_CHK(mbedtls_ecdsa_sign(&ecp->grp, &r, &s, &ecp->d,

psa_crypto_ecp.c:411

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&r,

psa_crypto_ecp.c:417

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&s,

psa_crypto_ecp.c:420

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(P, dhm_P,

psa_crypto_ffdh.c:121

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(G, dhm_G,

psa_crypto_ffdh.c:125

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&X, key_buffer,

psa_crypto_ffdh.c:178

MBEDTLS_MPI_CHK(mbedtls_mpi_exp_mod(&GX, &G, &X, &P, NULL));

psa_crypto_ffdh.c:181

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&GX, data, key_len));

psa_crypto_ffdh.c:182

MBEDTLS_MPI_CHK(mbedtls_mpi_random(&X, 3, &P, mbedtls_psa_get_random,

psa_crypto_ffdh.c:220

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&X, &X, 1));

psa_crypto_ffdh.c:222

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&X, key_buffer, key_buffer_size));

psa_crypto_ffdh.c:223

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&X, key_buffer,

psa_crypto_ffdh.c:292

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&GY, peer_key,

psa_crypto_ffdh.c:295

MBEDTLS_MPI_CHK(mbedtls_mpi_exp_mod(&K, &GY, &X, &P, NULL));

psa_crypto_ffdh.c:299

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&K, shared_secret,

psa_crypto_ffdh.c:301

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&ctx->N, N, N_len));

rsa.c:604

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&ctx->P, P, P_len));

rsa.c:609

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&ctx->Q, Q, Q_len));

rsa.c:613

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&ctx->D, D, D_len));

rsa.c:617

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&ctx->E, E, E_len));

rsa.c:621

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&ctx->N, N, N_len));

rsa.c:848

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&ctx->P, P, P_len));

rsa.c:852

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&ctx->Q, Q, Q_len));

rsa.c:856

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&ctx->D, D, D_len));

rsa.c:860

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&ctx->E, E, E_len));

rsa.c:864

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&ctx->E, exponent));

rsa.c:1082

MBEDTLS_MPI_CHK(mbedtls_mpi_gen_prime(&ctx->P, nbits >> 1,

rsa.c:1085

MBEDTLS_MPI_CHK(mbedtls_mpi_gen_prime(&ctx->Q, nbits >> 1,

rsa.c:1088

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&H, &ctx->P, &ctx->Q));

rsa.c:1092

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&ctx->P, &ctx->P, 1));

rsa.c:1103

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&ctx->Q, &ctx->Q, 1));

rsa.c:1104

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&H, &ctx->P, &ctx->Q));

rsa.c:1105

MBEDTLS_MPI_CHK(mbedtls_mpi_gcd(&G, &ctx->E, &H));

rsa.c:1108

MBEDTLS_MPI_CHK(mbedtls_mpi_gcd(&G, &ctx->P, &ctx->Q));

rsa.c:1114

MBEDTLS_MPI_CHK(mbedtls_mpi_div_mpi(&L, NULL, &H, &G));

rsa.c:1115

MBEDTLS_MPI_CHK(mbedtls_mpi_inv_mod(&ctx->D, &ctx->E, &L));

rsa.c:1116

MBEDTLS_MPI_CHK(mbedtls_mpi_add_int(&ctx->P, &ctx->P, 1));

rsa.c:1126

MBEDTLS_MPI_CHK(mbedtls_mpi_add_int(&ctx->Q, &ctx->Q, 1));

rsa.c:1127

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&ctx->N, &ctx->P, &ctx->Q));

rsa.c:1129

MBEDTLS_MPI_CHK(mbedtls_rsa_deduce_crt(&ctx->P, &ctx->Q, &ctx->D,

rsa.c:1139

MBEDTLS_MPI_CHK(mbedtls_rsa_check_privkey(ctx));

rsa.c:1144

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&T, input, ctx->len));

rsa.c:1255

MBEDTLS_MPI_CHK(mbedtls_mpi_exp_mod_unsafe(&T, &T, &ctx->E, &ctx->N, &ctx->RN));

rsa.c:1263

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&T, output, olen));

rsa.c:1264

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&ctx->Vi, &ctx->Vi, &ctx->Vi));

rsa.c:1298

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&ctx->Vi, &ctx->Vi, &ctx->N));

rsa.c:1299

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&ctx->Vf, &ctx->Vf, &ctx->Vf));

rsa.c:1300

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&ctx->Vf, &ctx->Vf, &ctx->N));

rsa.c:1301

MBEDTLS_MPI_CHK(mbedtls_mpi_fill_random(&ctx->Vf, ctx->len - 1, f_rng, p_rng));

rsa.c:1313

MBEDTLS_MPI_CHK(mbedtls_mpi_fill_random(&R, ctx->len - 1, f_rng, p_rng));

rsa.c:1316

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&ctx->Vi, &ctx->Vf, &R));

rsa.c:1317

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&ctx->Vi, &ctx->Vi, &ctx->N));

rsa.c:1318

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&ctx->Vi, &ctx->Vi, &R));

rsa.c:1332

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&ctx->Vi, &ctx->Vi, &ctx->N));

rsa.c:1333

MBEDTLS_MPI_CHK(mbedtls_mpi_exp_mod(&ctx->Vi, &ctx->Vi, &ctx->E, &ctx->N, &ctx->RN));

rsa.c:1337

MBEDTLS_MPI_CHK(mbedtls_mpi_core_get_mont_r2_unsafe(&RR, N));

rsa.c:1361

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(&M_T, tlimbs));

rsa.c:1362

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(T, nlimbs));

rsa.c:1364

MBEDTLS_MPI_CHK(mbedtls_mpi_grow(Vf, nlimbs));

rsa.c:1365

MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&T, input, ctx->len));

rsa.c:1479

MBEDTLS_MPI_CHK(rsa_prepare_blinding(ctx, f_rng, p_rng));

rsa.c:1489

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&T, &T, &ctx->Vi));

rsa.c:1490

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&T, &T, &ctx->N));

rsa.c:1491

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&input_blinded, &T));

rsa.c:1493

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&P1, &ctx->P, 1));

rsa.c:1498

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&Q1, &ctx->Q, 1));

rsa.c:1499

MBEDTLS_MPI_CHK(mbedtls_mpi_fill_random(&R, RSA_EXPONENT_BLINDING,

rsa.c:1514

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&DP_blind, &P1, &R));

rsa.c:1516

MBEDTLS_MPI_CHK(mbedtls_mpi_add_mpi(&DP_blind, &DP_blind,

rsa.c:1517

MBEDTLS_MPI_CHK(mbedtls_mpi_fill_random(&R, RSA_EXPONENT_BLINDING,

rsa.c:1523

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&DQ_blind, &Q1, &R));

rsa.c:1525

MBEDTLS_MPI_CHK(mbedtls_mpi_add_mpi(&DQ_blind, &DQ_blind,

rsa.c:1526

MBEDTLS_MPI_CHK(mbedtls_mpi_exp_mod(&TP, &T, &DP_blind, &ctx->P, &ctx->RP));

rsa.c:1540

MBEDTLS_MPI_CHK(mbedtls_mpi_exp_mod(&TQ, &T, &DQ_blind, &ctx->Q, &ctx->RQ));

rsa.c:1541

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&T, &TP, &TQ));

rsa.c:1546

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&TP, &T, &ctx->QP));

rsa.c:1547

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&T, &TP, &ctx->P));

rsa.c:1548

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&TP, &T, &ctx->Q));

rsa.c:1553

MBEDTLS_MPI_CHK(mbedtls_mpi_add_mpi(&T, &TQ, &TP));

rsa.c:1554

MBEDTLS_MPI_CHK(mbedtls_mpi_exp_mod(&check_result_blinded, &T, &ctx->E,

rsa.c:1558

MBEDTLS_MPI_CHK(rsa_unblind(&T, &ctx->Vf, &ctx->N));

rsa.c:1569

MBEDTLS_MPI_CHK(mbedtls_mpi_write_binary(&T, output, olen));

rsa.c:1572

MBEDTLS_MPI_CHK(mbedtls_rsa_private(ctx, f_rng, p_rng, sig, sig_try));

rsa.c:2472

MBEDTLS_MPI_CHK(mbedtls_rsa_public(ctx, sig_try, verif));

rsa.c:2473

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&dst->N, &src->N));

rsa.c:2779

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&dst->E, &src->E));

rsa.c:2780

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&dst->D, &src->D));

rsa.c:2782

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&dst->P, &src->P));

rsa.c:2783

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&dst->Q, &src->Q));

rsa.c:2784

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&dst->DP, &src->DP));

rsa.c:2787

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&dst->DQ, &src->DQ));

rsa.c:2788

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&dst->QP, &src->QP));

rsa.c:2789

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&dst->RP, &src->RP));

rsa.c:2790

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&dst->RQ, &src->RQ));

rsa.c:2791

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&dst->RN, &src->RN));

rsa.c:2794

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&dst->Vi, &src->Vi));

rsa.c:2796

MBEDTLS_MPI_CHK(mbedtls_mpi_copy(&dst->Vf, &src->Vf));

rsa.c:2797

MBEDTLS_MPI_CHK(mbedtls_mpi_read_string(&K, 16, RSA_N));

rsa.c:2935

MBEDTLS_MPI_CHK(mbedtls_rsa_import(&rsa, &K, NULL, NULL, NULL, NULL));

rsa.c:2936

MBEDTLS_MPI_CHK(mbedtls_mpi_read_string(&K, 16, RSA_P));

rsa.c:2937

MBEDTLS_MPI_CHK(mbedtls_rsa_import(&rsa, NULL, &K, NULL, NULL, NULL));

rsa.c:2938

MBEDTLS_MPI_CHK(mbedtls_mpi_read_string(&K, 16, RSA_Q));

rsa.c:2939

MBEDTLS_MPI_CHK(mbedtls_rsa_import(&rsa, NULL, NULL, &K, NULL, NULL));

rsa.c:2940

MBEDTLS_MPI_CHK(mbedtls_mpi_read_string(&K, 16, RSA_D));

rsa.c:2941

MBEDTLS_MPI_CHK(mbedtls_rsa_import(&rsa, NULL, NULL, NULL, &K, NULL));

rsa.c:2942

MBEDTLS_MPI_CHK(mbedtls_mpi_read_string(&K, 16, RSA_E));

rsa.c:2943

MBEDTLS_MPI_CHK(mbedtls_rsa_import(&rsa, NULL, NULL, NULL, NULL, &K));

rsa.c:2944

MBEDTLS_MPI_CHK(mbedtls_rsa_complete(&rsa));

rsa.c:2946

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&T, D, E));

rsa_alt_helpers.c:95

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&T, &T, 1));

rsa_alt_helpers.c:96

MBEDTLS_MPI_CHK(mbedtls_mpi_shift_r(&T, order));

rsa_alt_helpers.c:104

MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&K, primes[attempt]));

rsa_alt_helpers.c:117

MBEDTLS_MPI_CHK(mbedtls_mpi_gcd(P, &K, N));

rsa_alt_helpers.c:120

MBEDTLS_MPI_CHK(mbedtls_mpi_exp_mod(&K, &K, &T, N,

rsa_alt_helpers.c:127

MBEDTLS_MPI_CHK(mbedtls_mpi_add_int(&K, &K, 1));

rsa_alt_helpers.c:138

MBEDTLS_MPI_CHK(mbedtls_mpi_gcd(P, &K, N));

rsa_alt_helpers.c:139

MBEDTLS_MPI_CHK(mbedtls_mpi_div_mpi(Q, NULL, N, P));

rsa_alt_helpers.c:148

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&K, &K, 1));

rsa_alt_helpers.c:152

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&K, &K, &K));

rsa_alt_helpers.c:153

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&K, &K, N));

rsa_alt_helpers.c:154

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&K, P, 1));

rsa_alt_helpers.c:204

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&L, Q, 1));

rsa_alt_helpers.c:205

MBEDTLS_MPI_CHK(mbedtls_mpi_gcd(D, &K, &L));

rsa_alt_helpers.c:208

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&K, &K, &L));

rsa_alt_helpers.c:211

MBEDTLS_MPI_CHK(mbedtls_mpi_div_mpi(&K, NULL, &K, D));

rsa_alt_helpers.c:212

MBEDTLS_MPI_CHK(mbedtls_mpi_inv_mod(D, E, &K));

rsa_alt_helpers.c:215

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&K, P, 1));

rsa_alt_helpers.c:235

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(DP, D, &K));

rsa_alt_helpers.c:236

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&K, Q, 1));

rsa_alt_helpers.c:241

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(DQ, D, &K));

rsa_alt_helpers.c:242

MBEDTLS_MPI_CHK(mbedtls_mpi_inv_mod(QP, Q, P));

rsa_alt_helpers.c:247

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&K, P, Q));

rsa_alt_helpers.c:302

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&K, D, E));

rsa_alt_helpers.c:336

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&K, &K, 1));

rsa_alt_helpers.c:337

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&L, P, 1));

rsa_alt_helpers.c:338

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&K, &K, &L));

rsa_alt_helpers.c:339

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&K, D, E));

rsa_alt_helpers.c:346

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&K, &K, 1));

rsa_alt_helpers.c:347

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&L, Q, 1));

rsa_alt_helpers.c:348

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&K, &K, &L));

rsa_alt_helpers.c:349

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&K, P, 1));

rsa_alt_helpers.c:389

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&L, DP, D));

rsa_alt_helpers.c:390

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&L, &L, &K));

rsa_alt_helpers.c:391

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&K, Q, 1));

rsa_alt_helpers.c:406

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(&L, DQ, D));

rsa_alt_helpers.c:407

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&L, &L, &K));

rsa_alt_helpers.c:408

MBEDTLS_MPI_CHK(mbedtls_mpi_mul_mpi(&K, QP, Q));

rsa_alt_helpers.c:423

MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&K, &K, 1));

rsa_alt_helpers.c:424

MBEDTLS_MPI_CHK(mbedtls_mpi_mod_mpi(&K, &K, P));

rsa_alt_helpers.c:425

MBEDTLS_MPI_CHK macro

Syntax

Arguments

Examples

References

Call Tree

Data Use

Class Tree

Override Tree

Implementations

Instances

Lifecycle