mbedtls_mpi_uint

size_t idx = pos % biL;

bignum.c:355

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

bignum.c:361

X->p[off] &= ~( (mbedtls_mpi_uint) 0x01 << idx );

bignum.c:369

X->p[off] |= (mbedtls_mpi_uint) val << idx;

bignum.c:370

mbedtls_mpi_read_string()

for( j = 0; j < biL; j++, count++ )

bignum.c:386

mbedtls_mpi_lsb()

static size_t mbedtls_clz( const mbedtls_mpi_uint x )

bignum.c:396

mbedtls_clz()

mbedtls_clz()::x

mbedtls_mpi_uint mask = (mbedtls_mpi_uint) 1 << (biL - 1);

bignum.c:399

mbedtls_clz()

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

bignum.c:401

mbedtls_clz()

j = biL - mbedtls_clz( X->p[i] );

bignum.c:425

mbedtls_mpi_bitlen()

return( ( i * biL ) + j );

bignum.c:427

mbedtls_mpi_bitlen()

static int mpi_get_digit( mbedtls_mpi_uint *d, int radix, char c )

bignum.c:441

mpi_get_digit()

mpi_get_digit()::d

if( *d >= (mbedtls_mpi_uint) radix )

bignum.c:449

mpi_get_digit()

mbedtls_mpi_uint d;

bignum.c:462

n = BITS_TO_LIMBS( slen << 2 );

bignum.c:479

mbedtls_mpi_read_string()

X->p[j / ( 2 * ciL )] |= d << ( ( j % ( 2 * ciL ) ) << 2 );

bignum.c:493

mbedtls_mpi_read_string()

mbedtls_mpi_uint r;

bignum.c:536

mpi_write_hlp()

for( j = ciL; j > 0; j-- )

bignum.c:622

mbedtls_mpi_write_string()

static mbedtls_mpi_uint mpi_uint_bigendian_to_host_c( mbedtls_mpi_uint x )

bignum.c:742

mbedtls_mpi_uint tmp = 0;

bignum.c:745

for( i = 0; i < ciL; i++, x >>= 8 )

bignum.c:747

tmp |= ( x & 0xFF ) << ( ( ciL - 1 - i ) << 3 );

bignum.c:748

static mbedtls_mpi_uint mpi_uint_bigendian_to_host( mbedtls_mpi_uint x )

bignum.c:752

switch( sizeof(mbedtls_mpi_uint) )

bignum.c:779

static void mpi_bigendian_to_host( mbedtls_mpi_uint * const p, size_t limbs )

bignum.c:795

mpi_bigendian_to_host()::p

mbedtls_mpi_uint *cur_limb_left;

bignum.c:797

mbedtls_mpi_uint *cur_limb_right;

bignum.c:798

mbedtls_mpi_uint tmp;

bignum.c:815

mbedtls_mpi_read_binary()

size_t const limbs = CHARS_TO_LIMBS( buflen );

bignum.c:830

size_t const overhead = ( limbs * ciL ) - buflen;

bignum.c:831

mbedtls_mpi_read_binary()

stored_bytes = X->n * ciL;

bignum.c:875

mbedtls_mpi_write_binary()

if( GET_BYTE( X, i ) != 0 )

bignum.c:896

mbedtls_mpi_write_binary()

p[bytes_to_copy - i - 1] = GET_BYTE( X, i );

bignum.c:902

mbedtls_mpi_write_binary()

mbedtls_mpi_uint r0 = 0, r1;

bignum.c:914

v0 = count / (biL );

bignum.c:917

t1 = count & (biL - 1);

bignum.c:918

if( X->n * biL < i )

bignum.c:922

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

bignum.c:923

r1 = X->p[i] >> (biL - t1);

bignum.c:946

mbedtls_mpi_uint r0 = 0, r1;

bignum.c:964

v0 = count / biL;

bignum.c:967

v1 = count & (biL - 1);

bignum.c:968

r1 = X->p[i - 1] << (biL - v1);

bignum.c:992

mbedtls_mpi_uint p[1];

bignum.c:1075

mbedtls_mpi_cmp_int()

mbedtls_mpi_uint *o, *p, c, tmp;

bignum.c:1093

mbedtls_mpi_add_abs()

static void mpi_sub_hlp( size_t n, mbedtls_mpi_uint *s, mbedtls_mpi_uint *d )

bignum.c:1148

mpi_sub_hlp()

mpi_sub_hlp()::s

mbedtls_mpi_uint c, z;

bignum.c:1151

mpi_sub_hlp()

mbedtls_mpi_uint p[1];

bignum.c:1288

mbedtls_mpi_add_int()

mbedtls_mpi_uint p[1];

bignum.c:1306

mbedtls_mpi_sub_int()

void mpi_mul_hlp( size_t i, mbedtls_mpi_uint *s, mbedtls_mpi_uint *d, mbedtls_mpi_uint b )

bignum.c:1329

mpi_mul_hlp()

mpi_mul_hlp()::s

mbedtls_mpi_uint c = 0, t = 0;

bignum.c:1331

mpi_mul_hlp()

int mbedtls_mpi_mul_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_uint b )

bignum.c:1433

mbedtls_mpi_uint p[1];

bignum.c:1436

static mbedtls_mpi_uint mbedtls_int_div_int( mbedtls_mpi_uint u1,

bignum.c:1452

mbedtls_mpi_uint u0, mbedtls_mpi_uint d, mbedtls_mpi_uint *r )

mbedtls_int_div_int()::u0

const mbedtls_mpi_uint radix = (mbedtls_mpi_uint) 1 << biH;

bignum.c:1458

const mbedtls_mpi_uint uint_halfword_mask = ( (mbedtls_mpi_uint) 1 << biH ) - 1;

bignum.c:1459

mbedtls_mpi_uint d0, d1, q0, q1, rAX, r0, quotient;

bignum.c:1460

mbedtls_mpi_uint u0_msw, u0_lsw;

bignum.c:1461

u1 |= ( u0 >> ( biL - s ) ) & ( -(mbedtls_mpi_sint)s >> ( biL - 1 ) );

bignum.c:1500

d1 = d >> biH;

bignum.c:1503

u0_msw = u0 >> biH;

bignum.c:1506

k = mbedtls_mpi_bitlen( &Y ) % biL;

bignum.c:1578

if( k < biL - 1 )

bignum.c:1579

k = biL - 1 - k;

bignum.c:1581

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

bignum.c:1589

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

bignum.c:1596

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

bignum.c:1626

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

bignum.c:1632

mbedtls_mpi_uint p[1];

bignum.c:1670

mbedtls_mpi_div_int()

int mbedtls_mpi_mod_int( mbedtls_mpi_uint *r, const mbedtls_mpi *A, mbedtls_mpi_sint b )

bignum.c:1710

mbedtls_mpi_uint x, y, z;

bignum.c:1713

y = ( y << biH ) | ( x >> biH );

bignum.c:1744

x <<= biH;

bignum.c:1748

y = ( y << biH ) | ( x >> biH );

bignum.c:1749

static void mpi_montg_init( mbedtls_mpi_uint *mm, const mbedtls_mpi *N )

bignum.c:1769

mpi_montg_init()

mpi_montg_init()::mm

mbedtls_mpi_uint x, m0 = N->p[0];

bignum.c:1771

mpi_montg_init()

for( i = biL; i >= 8; i /= 2 )

bignum.c:1777

mpi_montg_init()

static int mpi_montmul( mbedtls_mpi *A, const mbedtls_mpi *B, const mbedtls_mpi *N, mbedtls_mpi_uint mm,

bignum.c:1786

mpi_montmul()::mm

mbedtls_mpi_uint u0, u1, *d;

bignum.c:1790

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

bignum.c:1795

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

bignum.c:1815

mbedtls_mpi_fill_random()

mbedtls_mpi_uint mm, const mbedtls_mpi *T )

bignum.c:1830

mpi_montred()

mpi_montred()::mm

mbedtls_mpi_uint z = 1;

bignum.c:1832

mpi_montred()

mbedtls_mpi_uint ei, mm, state;

bignum.c:1852

mbedtls_mpi_exp_mod()

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

bignum.c:1907

mbedtls_mpi_exp_mod()

bufsize = sizeof( mbedtls_mpi_uint ) << 3;

bignum.c:1972

mbedtls_mpi_exp_mod()

size_t const limbs = CHARS_TO_LIMBS( size );

bignum.c:2126

size_t const overhead = ( limbs * ciL ) - size;

bignum.c:2127

mbedtls_mpi_fill_random()

mbedtls_mpi_uint *p; /*!< pointer to limbs */

bignum.h:189

mbedtls_mpi

mbedtls_mpi::p

mbedtls_mpi_uint b );

bignum.h:689

int mbedtls_mpi_mod_int( mbedtls_mpi_uint *r, const mbedtls_mpi *A,

bignum.h:769

static const mbedtls_mpi_uint secp256r1_p[] = {

ecp_curves.c:163

secp256r1_p

BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),

ecp_curves.c:164

BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00 ),

ecp_curves.c:165

BYTES_TO_T_UINT_8( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ),

ecp_curves.c:166

BYTES_TO_T_UINT_8( 0x01, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF ),

ecp_curves.c:167

static const mbedtls_mpi_uint secp256r1_b[] = {

ecp_curves.c:169

secp256r1_b

BYTES_TO_T_UINT_8( 0x4B, 0x60, 0xD2, 0x27, 0x3E, 0x3C, 0xCE, 0x3B ),

ecp_curves.c:170

BYTES_TO_T_UINT_8( 0xF6, 0xB0, 0x53, 0xCC, 0xB0, 0x06, 0x1D, 0x65 ),

ecp_curves.c:171

BYTES_TO_T_UINT_8( 0xBC, 0x86, 0x98, 0x76, 0x55, 0xBD, 0xEB, 0xB3 ),

ecp_curves.c:172

BYTES_TO_T_UINT_8( 0xE7, 0x93, 0x3A, 0xAA, 0xD8, 0x35, 0xC6, 0x5A ),

ecp_curves.c:173

static const mbedtls_mpi_uint secp256r1_gx[] = {

ecp_curves.c:175

secp256r1_gx

BYTES_TO_T_UINT_8( 0x96, 0xC2, 0x98, 0xD8, 0x45, 0x39, 0xA1, 0xF4 ),

ecp_curves.c:176

BYTES_TO_T_UINT_8( 0xA0, 0x33, 0xEB, 0x2D, 0x81, 0x7D, 0x03, 0x77 ),

ecp_curves.c:177

BYTES_TO_T_UINT_8( 0xF2, 0x40, 0xA4, 0x63, 0xE5, 0xE6, 0xBC, 0xF8 ),

ecp_curves.c:178

BYTES_TO_T_UINT_8( 0x47, 0x42, 0x2C, 0xE1, 0xF2, 0xD1, 0x17, 0x6B ),

ecp_curves.c:179

static const mbedtls_mpi_uint secp256r1_gy[] = {

ecp_curves.c:181

secp256r1_gy

BYTES_TO_T_UINT_8( 0xF5, 0x51, 0xBF, 0x37, 0x68, 0x40, 0xB6, 0xCB ),

ecp_curves.c:182

BYTES_TO_T_UINT_8( 0xCE, 0x5E, 0x31, 0x6B, 0x57, 0x33, 0xCE, 0x2B ),

ecp_curves.c:183

BYTES_TO_T_UINT_8( 0x16, 0x9E, 0x0F, 0x7C, 0x4A, 0xEB, 0xE7, 0x8E ),

ecp_curves.c:184

BYTES_TO_T_UINT_8( 0x9B, 0x7F, 0x1A, 0xFE, 0xE2, 0x42, 0xE3, 0x4F ),

ecp_curves.c:185

static const mbedtls_mpi_uint secp256r1_n[] = {

ecp_curves.c:187

secp256r1_n

BYTES_TO_T_UINT_8( 0x51, 0x25, 0x63, 0xFC, 0xC2, 0xCA, 0xB9, 0xF3 ),

ecp_curves.c:188

BYTES_TO_T_UINT_8( 0x84, 0x9E, 0x17, 0xA7, 0xAD, 0xFA, 0xE6, 0xBC ),

ecp_curves.c:189

BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),

ecp_curves.c:190

BYTES_TO_T_UINT_8( 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF ),

ecp_curves.c:191

static const mbedtls_mpi_uint secp384r1_p[] = {

ecp_curves.c:199

secp384r1_p

BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00 ),

ecp_curves.c:200

BYTES_TO_T_UINT_8( 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF ),

ecp_curves.c:201

BYTES_TO_T_UINT_8( 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),

ecp_curves.c:202

BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),

ecp_curves.c:203

BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),

ecp_curves.c:204

BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),

ecp_curves.c:205

static const mbedtls_mpi_uint secp384r1_b[] = {

ecp_curves.c:207

secp384r1_b

BYTES_TO_T_UINT_8( 0xEF, 0x2A, 0xEC, 0xD3, 0xED, 0xC8, 0x85, 0x2A ),

ecp_curves.c:208

BYTES_TO_T_UINT_8( 0x9D, 0xD1, 0x2E, 0x8A, 0x8D, 0x39, 0x56, 0xC6 ),

ecp_curves.c:209

BYTES_TO_T_UINT_8( 0x5A, 0x87, 0x13, 0x50, 0x8F, 0x08, 0x14, 0x03 ),

ecp_curves.c:210

BYTES_TO_T_UINT_8( 0x12, 0x41, 0x81, 0xFE, 0x6E, 0x9C, 0x1D, 0x18 ),

ecp_curves.c:211

BYTES_TO_T_UINT_8( 0x19, 0x2D, 0xF8, 0xE3, 0x6B, 0x05, 0x8E, 0x98 ),

ecp_curves.c:212

BYTES_TO_T_UINT_8( 0xE4, 0xE7, 0x3E, 0xE2, 0xA7, 0x2F, 0x31, 0xB3 ),

ecp_curves.c:213

static const mbedtls_mpi_uint secp384r1_gx[] = {

ecp_curves.c:215

secp384r1_gx

BYTES_TO_T_UINT_8( 0xB7, 0x0A, 0x76, 0x72, 0x38, 0x5E, 0x54, 0x3A ),

ecp_curves.c:216

BYTES_TO_T_UINT_8( 0x6C, 0x29, 0x55, 0xBF, 0x5D, 0xF2, 0x02, 0x55 ),

ecp_curves.c:217

BYTES_TO_T_UINT_8( 0x38, 0x2A, 0x54, 0x82, 0xE0, 0x41, 0xF7, 0x59 ),

ecp_curves.c:218

BYTES_TO_T_UINT_8( 0x98, 0x9B, 0xA7, 0x8B, 0x62, 0x3B, 0x1D, 0x6E ),

ecp_curves.c:219

BYTES_TO_T_UINT_8( 0x74, 0xAD, 0x20, 0xF3, 0x1E, 0xC7, 0xB1, 0x8E ),

ecp_curves.c:220

BYTES_TO_T_UINT_8( 0x37, 0x05, 0x8B, 0xBE, 0x22, 0xCA, 0x87, 0xAA ),

ecp_curves.c:221

static const mbedtls_mpi_uint secp384r1_gy[] = {

ecp_curves.c:223

secp384r1_gy

BYTES_TO_T_UINT_8( 0x5F, 0x0E, 0xEA, 0x90, 0x7C, 0x1D, 0x43, 0x7A ),

ecp_curves.c:224

BYTES_TO_T_UINT_8( 0x9D, 0x81, 0x7E, 0x1D, 0xCE, 0xB1, 0x60, 0x0A ),

ecp_curves.c:225

BYTES_TO_T_UINT_8( 0xC0, 0xB8, 0xF0, 0xB5, 0x13, 0x31, 0xDA, 0xE9 ),

ecp_curves.c:226

BYTES_TO_T_UINT_8( 0x7C, 0x14, 0x9A, 0x28, 0xBD, 0x1D, 0xF4, 0xF8 ),

ecp_curves.c:227

BYTES_TO_T_UINT_8( 0x29, 0xDC, 0x92, 0x92, 0xBF, 0x98, 0x9E, 0x5D ),

ecp_curves.c:228

BYTES_TO_T_UINT_8( 0x6F, 0x2C, 0x26, 0x96, 0x4A, 0xDE, 0x17, 0x36 ),

ecp_curves.c:229

static const mbedtls_mpi_uint secp384r1_n[] = {

ecp_curves.c:231

secp384r1_n

BYTES_TO_T_UINT_8( 0x73, 0x29, 0xC5, 0xCC, 0x6A, 0x19, 0xEC, 0xEC ),

ecp_curves.c:232

BYTES_TO_T_UINT_8( 0x7A, 0xA7, 0xB0, 0x48, 0xB2, 0x0D, 0x1A, 0x58 ),

ecp_curves.c:233

BYTES_TO_T_UINT_8( 0xDF, 0x2D, 0x37, 0xF4, 0x81, 0x4D, 0x63, 0xC7 ),

ecp_curves.c:234

BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),

ecp_curves.c:235

BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),

ecp_curves.c:236

BYTES_TO_T_UINT_8( 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ),

ecp_curves.c:237

static inline void ecp_mpi_load( mbedtls_mpi *X, const mbedtls_mpi_uint *p, size_t len )

ecp_curves.c:563

ecp_mpi_load()

ecp_mpi_load()::p

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

ecp_curves.c:566

ecp_mpi_load()

X->p = (mbedtls_mpi_uint *) p;

ecp_curves.c:567

ecp_mpi_load()

static mbedtls_mpi_uint one[] = { 1 };

ecp_curves.c:575

ecp_mpi_set1()

const mbedtls_mpi_uint *p, size_t plen,

ecp_curves.c:585

ecp_group_load()::p

const mbedtls_mpi_uint *a, size_t alen,

ecp_curves.c:586

ecp_group_load()::a

const mbedtls_mpi_uint *b, size_t blen,

ecp_curves.c:587

ecp_group_load()::b

const mbedtls_mpi_uint *gx, size_t gxlen,

ecp_curves.c:588

ecp_group_load()::gx

const mbedtls_mpi_uint *gy, size_t gylen,

ecp_curves.c:589

ecp_group_load()::gy

const mbedtls_mpi_uint *n, size_t nlen)

ecp_curves.c:590

ecp_group_load()::n

C->p[ C->n - 1 ] = (mbedtls_mpi_uint) -c;

INIT( 256 );

INIT( 384 );

Call Tree

All items filtered out

Data Use

All items filtered out

Class Tree

All items filtered out

Override Tree

All items filtered out

Implementations

All items filtered out

Instances

Instance

Scope

Location

Project

mbedtls_mpi::p

mbedtls_mpi

bignum.h:189

bignum.h:689

bignum.h:769

mbedtls_mpi_zeroize()::v

mbedtls_mpi_zeroize()

return

mpi_uint_bigendian_to_host_c()::x

bignum.c:742

bignum.c:742

return

mpi_uint_bigendian_to_host()::x

bignum.c:752

mpi_bigendian_to_host()::p

bignum.c:752

bignum.c:1433

return

mbedtls_int_div_int()::u1

bignum.c:1452

mbedtls_int_div_int()::u0

bignum.c:1452

mbedtls_int_div_int()::d

mbedtls_int_div_int()::r