MBEDTLS_MPI_CHK - syntax, references, description

References

Code

Location

#define MBEDTLS_MPI_CHK(f) \

bignum.h:49

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

asn1write.c:145

MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, i ) );

bignum.c:216

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

bignum.c:259

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

bignum.c:293

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

bignum.c:294

MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, 1 ) );

bignum.c:320

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

bignum.c:366

MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, n ) );

bignum.c:481

MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );

bignum.c:482

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

bignum.c:492

MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );

bignum.c:498

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

bignum.c:508

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

bignum.c:509

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

bignum.c:513

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

bignum.c:517

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

bignum.c:547

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

bignum.c:548

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &T, X ) );

bignum.c:637

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

bignum.c:642

MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, limbs ) );

bignum.c:842

MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );

bignum.c:844

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

bignum.c:923

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, A ) );

bignum.c:1104

MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, j ) );

bignum.c:1115

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

bignum.c:1133

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TB, B ) );

bignum.c:1185

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, A ) );

bignum.c:1190

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

bignum.c:1227

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

bignum.c:1232

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

bignum.c:1238

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

bignum.c:1262

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

bignum.c:1267

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

bignum.c:1273

if( X == A ) { MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TA, A ) ); A = &TA; }

bignum.c:1404

if( X == B ) { MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TB, B ) ); B = &TB; }

bignum.c:1405

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

bignum.c:1415

MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );

bignum.c:1416

if( Q != NULL ) MBEDTLS_MPI_CHK( mbedtls_mpi_lset( Q, 0 ) );

bignum.c:1564

if( R != NULL ) MBEDTLS_MPI_CHK( mbedtls_mpi_copy( R, A ) );

bignum.c:1565

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &X, A ) );

bignum.c:1569

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &Y, B ) );

bignum.c:1570

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

bignum.c:1573

MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &Z, 0 ) );

bignum.c:1574

MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &T1, 2 ) );

bignum.c:1575

MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &T2, 3 ) );

bignum.c:1576

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &X, k ) );

bignum.c:1582

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &Y, k ) );

bignum.c:1583

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

bignum.c:1589

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

bignum.c:1594

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

bignum.c:1596

MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &T1, 0 ) );

bignum.c:1613

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

bignum.c:1616

MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &T2, 0 ) );

bignum.c:1618

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

bignum.c:1625

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

bignum.c:1626

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

bignum.c:1627

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

bignum.c:1631

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

bignum.c:1632

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

bignum.c:1633

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( Q, &Z ) );

bignum.c:1640

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &X, k ) );

bignum.c:1646

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( R, &X ) );

bignum.c:1648

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

bignum.c:1694

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

bignum.c:1697

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

bignum.c:1700

MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, j ) );

bignum.c:1886

MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &W[1], j ) );

bignum.c:1887

MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &T, j * 2 ) );

bignum.c:1888

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &Apos, A ) );

bignum.c:1896

MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &RR, 1 ) );

bignum.c:1906

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

bignum.c:1907

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

bignum.c:1908

MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &W[1], A, N ) );

bignum.c:1920

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &W[1], A ) );

bignum.c:1922

MBEDTLS_MPI_CHK( mpi_montmul( &W[1], &RR, N, mm, &T ) );

bignum.c:1924

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, &RR ) );

bignum.c:1929

MBEDTLS_MPI_CHK( mpi_montred( X, N, mm, &T ) );

bignum.c:1930

MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &W[j], N->n + 1 ) );

bignum.c:1939

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &W[j], &W[1] ) );

bignum.c:1940

MBEDTLS_MPI_CHK( mpi_montmul( &W[j], &W[j], N, mm, &T ) );

bignum.c:1943

MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &W[i], N->n + 1 ) );

bignum.c:1950

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &W[i], &W[i - 1] ) );

bignum.c:1951

MBEDTLS_MPI_CHK( mpi_montmul( &W[i], &W[1], N, mm, &T ) );

bignum.c:1953

MBEDTLS_MPI_CHK( mpi_montmul( X, X, N, mm, &T ) );

bignum.c:1990

MBEDTLS_MPI_CHK( mpi_montmul( X, X, N, mm, &T ) );

bignum.c:2008

MBEDTLS_MPI_CHK( mpi_montmul( X, &W[wbits], N, mm, &T ) );

bignum.c:2013

MBEDTLS_MPI_CHK( mpi_montmul( X, X, N, mm, &T ) );

bignum.c:2026

MBEDTLS_MPI_CHK( mpi_montmul( X, &W[1], N, mm, &T ) );

bignum.c:2031

MBEDTLS_MPI_CHK( mpi_montred( X, N, mm, &T ) );

bignum.c:2037

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

bignum.c:2042

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TA, A ) );

bignum.c:2073

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TB, B ) );

bignum.c:2074

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TA, lz ) );

bignum.c:2082

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TB, lz ) );

bignum.c:2083

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

bignum.c:2089

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

bignum.c:2090

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

bignum.c:2094

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TA, 1 ) );

bignum.c:2095

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

bignum.c:2099

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TB, 1 ) );

bignum.c:2100

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &TB, lz ) );

bignum.c:2104

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( G, &TB ) );

bignum.c:2105

MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, limbs ) );

bignum.c:2138

MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );

bignum.c:2140

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

bignum.c:2169

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

bignum.c:2177

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

bignum.c:2178

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TB, N ) );

bignum.c:2179

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TV, N ) );

bignum.c:2180

MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &U1, 1 ) );

bignum.c:2182

MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &U2, 0 ) );

bignum.c:2183

MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &V1, 0 ) );

bignum.c:2184

MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &V2, 1 ) );

bignum.c:2185

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TU, 1 ) );

bignum.c:2191

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

bignum.c:2195

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

bignum.c:2196

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &U1, 1 ) );

bignum.c:2199

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &U2, 1 ) );

bignum.c:2200

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TV, 1 ) );

bignum.c:2205

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

bignum.c:2209

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

bignum.c:2210

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &V1, 1 ) );

bignum.c:2213

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &V2, 1 ) );

bignum.c:2214

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

bignum.c:2219

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

bignum.c:2220

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

bignum.c:2221

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

bignum.c:2225

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

bignum.c:2226

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

bignum.c:2227

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

bignum.c:2233

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

bignum.c:2236

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, &V1 ) );

bignum.c:2238

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

ecdh.c:82

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

ecdh.c:84

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

ecdh.c:122

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

ecdh.c:131

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

ecdsa.c:236

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

ecdsa.c:238

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

ecdsa.c:242

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

ecdsa.c:317

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

ecdsa.c:325

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

ecdsa.c:327

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

ecdsa.c:346

MBEDTLS_MPI_CHK( mbedtls_ecp_gen_privkey( grp, &t, f_rng, p_rng ) );

ecdsa.c:352

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

ecdsa.c:357

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

ecdsa.c:358

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

ecdsa.c:359

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

ecdsa.c:360

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

ecdsa.c:361

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

ecdsa.c:362

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

ecdsa.c:363

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:560

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

ecdsa.c:573

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

ecdsa.c:671

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

ecdsa.c:676

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

ecp.c:648

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

ecp.c:649

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

ecp.c:650

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

ecp.c:675

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

ecp.c:676

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

ecp.c:677

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

ecp.c:723

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

ecp.c:724

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

ecp.c:725

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

ecp.c:772

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

ecp.c:773

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

ecp.c:783

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

ecp.c:822

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

ecp.c:823

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

ecp.c:824

MBEDTLS_MPI_CHK( grp->modp( N ) );

ecp.c:1016

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

ecp.c:1020

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

ecp.c:1024

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

ecp.c:1052

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

ecp.c:1062

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

ecp.c:1071

MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( &Zi, &pt->Z, &grp->P ) );

ecp.c:1104

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ZZi, &Zi, &Zi ) ); MOD_MUL( ZZi );

ecp.c:1105

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &pt->X, &pt->X, &ZZi ) ); MOD_MUL( pt->X );

ecp.c:1106

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &pt->Y, &pt->Y, &ZZi ) ); MOD_MUL( pt->Y );

ecp.c:1111

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &pt->Y, &pt->Y, &Zi ) ); MOD_MUL( pt->Y );

ecp.c:1112

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

ecp.c:1117

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &c[0], &T[0]->Z ) );

ecp.c:1163

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &c[i], &c[i-1], &T[i]->Z ) );

ecp.c:1166

MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( &u, &c[T_size-1], &grp->P ) );

ecp.c:1173

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &Zi, &u ) );

ecp.c:1182

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &Zi, &u, &c[i-1] ) ); MOD_MUL( Zi );

ecp.c:1186

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &u, &u, &T[i]->Z ) ); MOD_MUL( u );

ecp.c:1187

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ZZi, &Zi, &Zi ) ); MOD_MUL( ZZi );

ecp.c:1193

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T[i]->X, &T[i]->X, &ZZi ) ); MOD_MUL( T[i]->X );

ecp.c:1194

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T[i]->Y, &T[i]->Y, &ZZi ) ); MOD_MUL( T[i]->Y );

ecp.c:1195

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T[i]->Y, &T[i]->Y, &Zi ) ); MOD_MUL( T[i]->Y );

ecp.c:1196

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

ecp.c:1204

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

ecp.c:1205

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

ecp.c:1237

MBEDTLS_MPI_CHK( mbedtls_mpi_safe_cond_assign( &Q->Y, &mQY, inv & nonzero ) );

ecp.c:1239

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &S, &P->Z, &P->Z ) ); MOD_MUL( S );

ecp.c:1282

MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &T, &P->X, &S ) ); MOD_ADD( T );

ecp.c:1283

MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &U, &P->X, &S ) ); MOD_SUB( U );

ecp.c:1284

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &S, &T, &U ) ); MOD_MUL( S );

ecp.c:1285

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &M, &S, 3 ) ); MOD_ADD( M );

ecp.c:1286

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &S, &P->X, &P->X ) ); MOD_MUL( S );

ecp.c:1291

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &M, &S, 3 ) ); MOD_ADD( M );

ecp.c:1292

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &S, &P->Z, &P->Z ) ); MOD_MUL( S );

ecp.c:1298

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T, &S, &S ) ); MOD_MUL( T );

ecp.c:1299

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &S, &T, &grp->A ) ); MOD_MUL( S );

ecp.c:1300

MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &M, &M, &S ) ); MOD_ADD( M );

ecp.c:1301

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T, &P->Y, &P->Y ) ); MOD_MUL( T );

ecp.c:1306

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &T, 1 ) ); MOD_ADD( T );

ecp.c:1307

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &S, &P->X, &T ) ); MOD_MUL( S );

ecp.c:1308

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &S, 1 ) ); MOD_ADD( S );

ecp.c:1309

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &U, &T, &T ) ); MOD_MUL( U );

ecp.c:1312

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &U, 1 ) ); MOD_ADD( U );

ecp.c:1313

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T, &M, &M ) ); MOD_MUL( T );

ecp.c:1316

MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &T, &T, &S ) ); MOD_SUB( T );

ecp.c:1317

MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &T, &T, &S ) ); MOD_SUB( T );

ecp.c:1318

MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &S, &S, &T ) ); MOD_SUB( S );

ecp.c:1321

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &S, &S, &M ) ); MOD_MUL( S );

ecp.c:1322

MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &S, &S, &U ) ); MOD_SUB( S );

ecp.c:1323

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &U, &P->Y, &P->Z ) ); MOD_MUL( U );

ecp.c:1326

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &U, 1 ) ); MOD_ADD( U );

ecp.c:1327

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &R->X, &T ) );

ecp.c:1329

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &R->Y, &S ) );

ecp.c:1330

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &R->Z, &U ) );

ecp.c:1331

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T1, &P->Z, &P->Z ) ); MOD_MUL( T1 );

ecp.c:1390

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T2, &T1, &P->Z ) ); MOD_MUL( T2 );

ecp.c:1391

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T1, &T1, &Q->X ) ); MOD_MUL( T1 );

ecp.c:1392

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T2, &T2, &Q->Y ) ); MOD_MUL( T2 );

ecp.c:1393

MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &T1, &T1, &P->X ) ); MOD_SUB( T1 );

ecp.c:1394

MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &T2, &T2, &P->Y ) ); MOD_SUB( T2 );

ecp.c:1395

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &Z, &P->Z, &T1 ) ); MOD_MUL( Z );

ecp.c:1412

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T3, &T1, &T1 ) ); MOD_MUL( T3 );

ecp.c:1413

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T4, &T3, &T1 ) ); MOD_MUL( T4 );

ecp.c:1414

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T3, &T3, &P->X ) ); MOD_MUL( T3 );

ecp.c:1415

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &T1, &T3, 2 ) ); MOD_ADD( T1 );

ecp.c:1416

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &X, &T2, &T2 ) ); MOD_MUL( X );

ecp.c:1417

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

ecp.c:1418

MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &X, &X, &T4 ) ); MOD_SUB( X );

ecp.c:1419

MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &T3, &T3, &X ) ); MOD_SUB( T3 );

ecp.c:1420

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T3, &T3, &T2 ) ); MOD_MUL( T3 );

ecp.c:1421

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T4, &T4, &P->Y ) ); MOD_MUL( T4 );

ecp.c:1422

MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &Y, &T3, &T4 ) ); MOD_SUB( Y );

ecp.c:1423

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &R->X, &X ) );

ecp.c:1425

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &R->Y, &Y ) );

ecp.c:1426

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &R->Z, &Z ) );

ecp.c:1427

MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( &l, p_size, f_rng, p_rng ) );

ecp.c:1463

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &l, 1 ) );

ecp.c:1466

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &pt->Z, &pt->Z, &l ) ); MOD_MUL( pt->Z );

ecp.c:1474

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ll, &l, &l ) ); MOD_MUL( ll );

ecp.c:1477

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &pt->X, &pt->X, &ll ) ); MOD_MUL( pt->X );

ecp.c:1478

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &ll, &ll, &l ) ); MOD_MUL( ll );

ecp.c:1481

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &pt->Y, &pt->Y, &ll ) ); MOD_MUL( pt->Y );

ecp.c:1482

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

ecp.c:1656

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

ecp.c:1673

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

ecp.c:1675

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

ecp.c:1694

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

ecp.c:1712

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

ecp.c:1731

MBEDTLS_MPI_CHK( mbedtls_mpi_safe_cond_assign( &R->X, &T[j].X, j == ii ) );

ecp.c:1764

MBEDTLS_MPI_CHK( mbedtls_mpi_safe_cond_assign( &R->Y, &T[j].Y, j == ii ) );

ecp.c:1765

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

ecp.c:1769

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

ecp.c:1817

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

ecp.c:1818

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

ecp.c:1820

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

ecp.c:1828

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

ecp.c:1829

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

ecp.c:1830

MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &M, m ) );

ecp.c:1882

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

ecp.c:1883

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

ecp.c:1884

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

ecp.c:1929

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

ecp.c:1931

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

ecp.c:1933

MBEDTLS_MPI_CHK( ecp_normalize_jac( grp, RR ) );

ecp.c:1942

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

ecp.c:2068

MBEDTLS_MPI_CHK( ecp_mul_comb_after_precomp( grp, R, m,

ecp.c:2080

MBEDTLS_MPI_CHK( mbedtls_ecp_check_privkey( grp, m ) );

ecp.c:2358

MBEDTLS_MPI_CHK( mbedtls_ecp_check_pubkey( grp, P ) );

ecp.c:2359

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

ecp.c:2369

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &YY, &pt->Y, &pt->Y ) ); MOD_MUL( YY );

ecp.c:2424

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &RHS, &pt->X, &pt->X ) ); MOD_MUL( RHS );

ecp.c:2425

MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &RHS, &RHS, 3 ) ); MOD_SUB( RHS );

ecp.c:2430

MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &RHS, &RHS, &grp->A ) ); MOD_ADD( RHS );

ecp.c:2434

MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &RHS, &RHS, &pt->X ) ); MOD_MUL( RHS );

ecp.c:2437

MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &RHS, &RHS, &grp->B ) ); MOD_ADD( RHS );

ecp.c:2438

MBEDTLS_MPI_CHK( mbedtls_ecp_copy( R, P ) );

ecp.c:2465

MBEDTLS_MPI_CHK( mbedtls_ecp_copy( R, P ) );

ecp.c:2469

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

ecp.c:2471

MBEDTLS_MPI_CHK( mbedtls_ecp_mul_restartable( grp, R, m, P,

ecp.c:2475

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

ecp.c:2531

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

ecp.c:2538

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

ecp.c:2552

MBEDTLS_MPI_CHK( ecp_normalize_jac( grp, pR ) );

ecp.c:2560

MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( d, n_size, f_rng, p_rng ) );

ecp.c:2737

MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( d, 8 * n_size - grp->nbits ) );

ecp.c:2738

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

ecp.c:2777

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

ecp.c:2778

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

ecp.c:2843

MBEDTLS_MPI_CHK( mbedtls_mpi_grow( N, (b) * 2 / 8 / \

ecp_curves.c:1006

MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( N, C, N ) );

ecp_curves.c:1043

MBEDTLS_MPI_CHK macro

Syntax

Arguments

Examples

References

Call Tree

Data Use

Class Tree

Override Tree

Implementations

Instances

Lifecycle