NX_CRYPTO_HUGE_NUMBER_STRUCT::nx_crypto_huge_number_data field

modulus.nx_crypto_huge_number_data = dh_ptr -> nx_crypto_dh_modulus;

nx_crypto_dh.c:144

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&public_key, scratch_buf_ptr, dh_ptr -> nx_crypto_dh_key_size << 1);

nx_crypto_dh.c:161

private_key.nx_crypto_huge_number_data = dh_ptr -> nx_crypto_dh_private_key_buffer;

nx_crypto_dh.c:164

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&public_key, scratch_buf_ptr, key_size);

nx_crypto_dh.c:283

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&shared_secret, scratch_buf_ptr, key_size << 1);

nx_crypto_dh.c:284

modulus.nx_crypto_huge_number_data = (HN_UBASE *)dh_ptr -> nx_crypto_dh_modulus;

nx_crypto_dh.c:292

private_key.nx_crypto_huge_number_data = (HN_UBASE *)dh_ptr -> nx_crypto_dh_private_key_buffer;

nx_crypto_dh.c:300

NX_CRYPTO_HUGE_NUMBER_SET_DIGIT(&point -> nx_crypto_ec_point_x, 0);

nx_crypto_ec.c:812

NX_CRYPTO_HUGE_NUMBER_SET_DIGIT(&point -> nx_crypto_ec_point_y, 0);

nx_crypto_ec.c:813

NX_CRYPTO_HUGE_NUMBER_SET_DIGIT(&point -> nx_crypto_ec_point_z, 0);

nx_crypto_ec.c:817

_nx_crypto_ec_point_fp_affine_to_projective()

NX_CRYPTO_HUGE_NUMBER_SET_DIGIT(&point -> nx_crypto_ec_point_z, 1);

nx_crypto_ec.c:1028

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp1, scratch, buffer_size << 1);

nx_crypto_ec.c:1103

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp2, scratch, buffer_size << 1);

nx_crypto_ec.c:1104

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&zi, scratch, buffer_size);

nx_crypto_ec.c:1105

NX_CRYPTO_HUGE_NUMBER_COPY(&point -> nx_crypto_ec_point_x, &temp2);

nx_crypto_ec.c:1115

NX_CRYPTO_HUGE_NUMBER_COPY(&point -> nx_crypto_ec_point_y, &temp1);

nx_crypto_ec.c:1121

nx_crypto_ec.c:1201

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp, scratch, 36);

nx_crypto_ec.c:1205

NX_CRYPTO_EC_SECP192R1_DATA_SETUP(&temp, rev1,

nx_crypto_ec.c:1223

NX_CRYPTO_EC_SECP192R1_DATA_SETUP(&temp, rev1,

nx_crypto_ec.c:1229

NX_CRYPTO_EC_SECP192R1_DATA_SETUP(&temp, rev1,

nx_crypto_ec.c:1235

nx_crypto_ec.c:1338

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp, scratch, 36);

nx_crypto_ec.c:1342

nx_crypto_ec.c:1360

nx_crypto_ec.c:1366

nx_crypto_ec.c:1372

nx_crypto_ec.c:1378

nx_crypto_ec.c:1482

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp, scratch, 36);

nx_crypto_ec.c:1486

NX_CRYPTO_EC_SECP256R1_DATA_SETUP_LS1(&temp, rev1, rev2,

nx_crypto_ec.c:1504

NX_CRYPTO_EC_SECP256R1_DATA_SETUP_LS1(&temp, rev1, rev2,

nx_crypto_ec.c:1510

nx_crypto_ec.c:1516

nx_crypto_ec.c:1522

nx_crypto_ec.c:1528

nx_crypto_ec.c:1534

nx_crypto_ec.c:1540

nx_crypto_ec.c:1546

nx_crypto_ec.c:1647

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp, scratch, 52);

nx_crypto_ec.c:1651

NX_CRYPTO_EC_SECP384R1_DATA_SETUP_LS1(&temp, rev1, rev2,

nx_crypto_ec.c:1669

nx_crypto_ec.c:1679

nx_crypto_ec.c:1686

nx_crypto_ec.c:1693

nx_crypto_ec.c:1700

nx_crypto_ec.c:1707

nx_crypto_ec.c:1714

nx_crypto_ec.c:1720

nx_crypto_ec.c:1818

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp, scratch, 66);

nx_crypto_ec.c:1822

_nx_crypto_ec_subtract_digit_reduce()

(value -> nx_crypto_huge_number_data[0] < digit)))

nx_crypto_ec.c:1992

NX_CRYPTO_HUGE_NUMBER_COPY(&projective_point -> nx_crypto_ec_point_x,

nx_crypto_ec.c:2275

NX_CRYPTO_HUGE_NUMBER_COPY(&projective_point -> nx_crypto_ec_point_y,

nx_crypto_ec.c:2277

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp1, scratch, buffer_size << 1);

nx_crypto_ec.c:2289

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp2, scratch, buffer_size << 1);

nx_crypto_ec.c:2290

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp3, scratch, buffer_size << 1);

nx_crypto_ec.c:2291

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp4, scratch, buffer_size << 1);

nx_crypto_ec.c:2292

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp5, scratch, buffer_size << 1);

nx_crypto_ec.c:2293

NX_CRYPTO_HUGE_NUMBER_COPY(&projective_point -> nx_crypto_ec_point_z, &temp3);

nx_crypto_ec.c:2318

NX_CRYPTO_HUGE_NUMBER_COPY(&temp3, &temp2);

nx_crypto_ec.c:2327

NX_CRYPTO_HUGE_NUMBER_COPY(&projective_point -> nx_crypto_ec_point_x, &temp5);

nx_crypto_ec.c:2332

NX_CRYPTO_HUGE_NUMBER_COPY(&projective_point -> nx_crypto_ec_point_y, &temp3);

nx_crypto_ec.c:2344

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp1, scratch, buffer_size << 1);

nx_crypto_ec.c:2428

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp2, scratch, buffer_size << 1);

nx_crypto_ec.c:2429

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp3, scratch, buffer_size << 1);

nx_crypto_ec.c:2430

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp4, scratch, buffer_size << 1);

nx_crypto_ec.c:2431

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp5, scratch, buffer_size << 1);

nx_crypto_ec.c:2432

NX_CRYPTO_HUGE_NUMBER_COPY(&temp4, &projective_point -> nx_crypto_ec_point_x);

nx_crypto_ec.c:2449

NX_CRYPTO_HUGE_NUMBER_COPY(&temp5, &projective_point -> nx_crypto_ec_point_x);

nx_crypto_ec.c:2450

NX_CRYPTO_HUGE_NUMBER_COPY(&projective_point -> nx_crypto_ec_point_z, &temp5);

nx_crypto_ec.c:2460

NX_CRYPTO_HUGE_NUMBER_COPY(&temp5, &temp1);

nx_crypto_ec.c:2466

NX_CRYPTO_HUGE_NUMBER_COPY(&projective_point -> nx_crypto_ec_point_x, &temp3);

nx_crypto_ec.c:2469

NX_CRYPTO_HUGE_NUMBER_COPY(&projective_point -> nx_crypto_ec_point_y, &temp3);

nx_crypto_ec.c:2479

NX_CRYPTO_HUGE_NUMBER_COPY(&left -> nx_crypto_ec_point_x,

nx_crypto_ec.c:2552

NX_CRYPTO_HUGE_NUMBER_COPY(&left -> nx_crypto_ec_point_y,

nx_crypto_ec.c:2554

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp1, scratch, buffer_size << 1);

nx_crypto_ec.c:2567

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp2, scratch, buffer_size << 1);

nx_crypto_ec.c:2568

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp3, scratch, buffer_size << 1);

nx_crypto_ec.c:2569

NX_CRYPTO_HUGE_NUMBER_COPY(&temp3, &left -> nx_crypto_ec_point_y);

nx_crypto_ec.c:2579

NX_CRYPTO_HUGE_NUMBER_COPY(&temp1, &right -> nx_crypto_ec_point_x);

nx_crypto_ec.c:2593

NX_CRYPTO_HUGE_NUMBER_COPY(&temp1, &right -> nx_crypto_ec_point_y);

nx_crypto_ec.c:2596

NX_CRYPTO_HUGE_NUMBER_COPY(&temp2, &left -> nx_crypto_ec_point_x);

nx_crypto_ec.c:2605

NX_CRYPTO_HUGE_NUMBER_COPY(&left -> nx_crypto_ec_point_x, &temp1);

nx_crypto_ec.c:2606

NX_CRYPTO_HUGE_NUMBER_COPY(&left -> nx_crypto_ec_point_y, &temp1);

nx_crypto_ec.c:2612

NX_CRYPTO_EC_POINT_INITIALIZE(&point, NX_CRYPTO_EC_POINT_AFFINE, scratch,

nx_crypto_ec.c:2670

NX_CRYPTO_HUGE_NUMBER_COPY(&point.nx_crypto_ec_point_x, &right -> nx_crypto_ec_point_x);

nx_crypto_ec.c:2672

NX_CRYPTO_HUGE_NUMBER_COPY(&point.nx_crypto_ec_point_y, &curve -> nx_crypto_ec_field.fp);

nx_crypto_ec.c:2673

digit = digit + d -> nx_crypto_huge_number_data[i];

nx_crypto_ec.c:2737

value = (((d -> nx_crypto_huge_number_data[i + 1] & 1) << 1) + digit) & 3;

nx_crypto_ec.c:2759

digit = digit + d -> nx_crypto_huge_number_data[i];

nx_crypto_ec.c:2778

NX_CRYPTO_EC_POINT_INITIALIZE(&projective_point, NX_CRYPTO_EC_POINT_PROJECTIVE, scratch,

nx_crypto_ec.c:2888

NX_CRYPTO_EC_POINT_INITIALIZE(&negative_g, NX_CRYPTO_EC_POINT_AFFINE, scratch,

nx_crypto_ec.c:2890

NX_CRYPTO_HUGE_NUMBER_COPY(&negative_g.nx_crypto_ec_point_x, &g -> nx_crypto_ec_point_x);

nx_crypto_ec.c:2894

NX_CRYPTO_HUGE_NUMBER_COPY(&negative_g.nx_crypto_ec_point_y, &curve -> nx_crypto_ec_field.fp);

nx_crypto_ec.c:2895

NX_CRYPTO_HUGE_NUMBER_COPY(&r -> nx_crypto_ec_point_x,

nx_crypto_ec.c:2938

NX_CRYPTO_HUGE_NUMBER_COPY(&r -> nx_crypto_ec_point_y,

nx_crypto_ec.c:2940

NX_CRYPTO_EC_POINT_INITIALIZE(&projective_point, NX_CRYPTO_EC_POINT_PROJECTIVE, scratch,

nx_crypto_ec.c:3024

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&expanded_d, scratch, expanded_size);

nx_crypto_ec.c:3026

NX_CRYPTO_HUGE_NUMBER_COPY(&expanded_d, d);

nx_crypto_ec.c:3029

NX_CRYPTO_MEMSET(&expanded_d.nx_crypto_huge_number_data[expanded_d.nx_crypto_huge_number_size], 0,

nx_crypto_ec.c:3030

value = expanded_d.nx_crypto_huge_number_data[bit_index >> (HN_SIZE_SHIFT + 3)];

nx_crypto_ec.c:3043

value = expanded_d.nx_crypto_huge_number_data[bit_index >> (HN_SIZE_SHIFT + 3)];

nx_crypto_ec.c:3068

NX_CRYPTO_HUGE_NUMBER_COPY(&r -> nx_crypto_ec_point_x,

nx_crypto_ec.c:3082

NX_CRYPTO_HUGE_NUMBER_COPY(&r -> nx_crypto_ec_point_y,

nx_crypto_ec.c:3084

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&random_number, scratch, buffer_size);

nx_crypto_ec.c:3159

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&modulus, scratch, buffer_size);

nx_crypto_ec.c:3160

NX_CRYPTO_HUGE_NUMBER_COPY(&modulus, &curve -> nx_crypto_ec_n);

nx_crypto_ec.c:3178

NX_CRYPTO_HUGE_NUMBER_COPY(private_key, &random_number);

nx_crypto_ec.c:3184

_nx_crypto_ec_key_pair_stream_generate()

NX_CRYPTO_EC_POINT_INITIALIZE(&public_key, NX_CRYPTO_EC_POINT_AFFINE, scratch,

nx_crypto_ec.c:3264

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&private_key, scratch, private_key_len);

nx_crypto_ec.c:3268

_nx_crypto_ec_key_pair_stream_generate()

NX_CRYPTO_EC_POINT_INITIALIZE(&fixed_points -> nx_crypto_ec_fixed_points_array[i],

nx_crypto_ec.c:3396

NX_CRYPTO_EC_POINT_INITIALIZE(&fixed_points -> nx_crypto_ec_fixed_points_array_2e[i],

nx_crypto_ec.c:3402

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&d, scratch_ptr,

nx_crypto_ec.c:3407

NX_CRYPTO_MEMSET(d.nx_crypto_huge_number_data, 0, d.nx_crypto_huge_number_size << HN_SIZE_SHIFT);

nx_crypto_ec.c:3415

d.nx_crypto_huge_number_data[d.nx_crypto_huge_number_size - 1] =

nx_crypto_ec.c:3416

NX_CRYPTO_HUGE_NUMBER_COPY(&array[offset - 1].nx_crypto_ec_point_x,

nx_crypto_ec.c:3429

NX_CRYPTO_HUGE_NUMBER_COPY(&array[offset - 1].nx_crypto_ec_point_y,

nx_crypto_ec.c:3431

NX_CRYPTO_HUGE_NUMBER_COPY(&array[offset + j - 1].nx_crypto_ec_point_x,

nx_crypto_ec.c:3437

NX_CRYPTO_HUGE_NUMBER_COPY(&array[offset + j - 1].nx_crypto_ec_point_y,

nx_crypto_ec.c:3439

NX_CRYPTO_MEMSET(d.nx_crypto_huge_number_data, 0, d.nx_crypto_huge_number_size << HN_SIZE_SHIFT);

nx_crypto_ec.c:3450

d.nx_crypto_huge_number_data[d.nx_crypto_huge_number_size - 1] =

nx_crypto_ec.c:3451

NX_CRYPTO_MEMSET(d.nx_crypto_huge_number_data, 0, d.nx_crypto_huge_number_size << HN_SIZE_SHIFT);

nx_crypto_ec.c:3456

d.nx_crypto_huge_number_data[d.nx_crypto_huge_number_size - 1] =

nx_crypto_ec.c:3457

NX_CRYPTO_HUGE_NUMBER_COPY(&array[offset + j].nx_crypto_ec_point_x,

nx_crypto_ec.c:3473

NX_CRYPTO_HUGE_NUMBER_COPY(&array[offset + j].nx_crypto_ec_point_y,

nx_crypto_ec.c:3475

_nx_crypto_ec_fixed_output()

buffer = (HN_UBASE *)value -> nx_crypto_huge_number_data;

nx_crypto_ec.c:3607

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp, scratch2, buffer_size * 2);

nx_crypto_ec.c:4332

_nx_crypto_ec_validate_public_key()

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&right, scratch2, buffer_size * 2);

nx_crypto_ec.c:4333

_nx_crypto_ec_validate_public_key()

private_key.nx_crypto_huge_number_data = ecdh_ptr -> nx_crypto_ecdh_private_key_buffer;

nx_crypto_ecdh.c:107

_nx_crypto_ecdh_key_pair_import()

private_key.nx_crypto_huge_number_data = (HN_UBASE *)ecdh_ptr -> nx_crypto_ecdh_private_key_buffer;

nx_crypto_ecdh.c:189

_nx_crypto_ecdh_private_key_export()

NX_CRYPTO_EC_POINT_INITIALIZE(&public_key, NX_CRYPTO_EC_POINT_AFFINE, scratch_buf_ptr,

nx_crypto_ecdh.c:278

_nx_crypto_ecdh_setup()

private_key.nx_crypto_huge_number_data = ecdh_ptr -> nx_crypto_ecdh_private_key_buffer;

nx_crypto_ecdh.c:282

_nx_crypto_ecdh_setup()

NX_CRYPTO_EC_POINT_INITIALIZE(&public_key, NX_CRYPTO_EC_POINT_AFFINE, scratch_buf_ptr, key_size);

nx_crypto_ecdh.c:404

NX_CRYPTO_EC_POINT_INITIALIZE(&shared_secret, NX_CRYPTO_EC_POINT_AFFINE, scratch_buf_ptr, key_size);

nx_crypto_ecdh.c:405

private_key.nx_crypto_huge_number_data = (HN_UBASE *)ecdh_ptr -> nx_crypto_ecdh_private_key_buffer;

nx_crypto_ecdh.c:425

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&privkey, scratch, buffer_size);

nx_crypto_ecdsa.c:121

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&z, scratch, buffer_size);

nx_crypto_ecdsa.c:122

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&k, scratch, buffer_size + 8);

nx_crypto_ecdsa.c:124

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&ik, scratch, buffer_size);

nx_crypto_ecdsa.c:125

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp, scratch, buffer_size * 2);

nx_crypto_ecdsa.c:126

NX_CRYPTO_EC_POINT_INITIALIZE(&pt, NX_CRYPTO_EC_POINT_AFFINE, scratch, buffer_size);

nx_crypto_ecdsa.c:127

NX_CRYPTO_HUGE_NUMBER_COPY(&k, &temp);

nx_crypto_ecdsa.c:172

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&r, scratch, buffer_size);

nx_crypto_ecdsa.c:368

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&s, scratch, buffer_size);

nx_crypto_ecdsa.c:369

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&z, scratch, buffer_size);

nx_crypto_ecdsa.c:370

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&w, scratch, buffer_size);

nx_crypto_ecdsa.c:371

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&u1, scratch, buffer_size << 1);

nx_crypto_ecdsa.c:372

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&u2, scratch, buffer_size << 1);

nx_crypto_ecdsa.c:373

NX_CRYPTO_EC_POINT_INITIALIZE(&pubkey, NX_CRYPTO_EC_POINT_AFFINE, scratch, buffer_size);

nx_crypto_ecdsa.c:374

NX_CRYPTO_EC_POINT_INITIALIZE(&pt, NX_CRYPTO_EC_POINT_AFFINE, scratch, buffer_size);

nx_crypto_ecdsa.c:375

NX_CRYPTO_EC_POINT_INITIALIZE(&pt2, NX_CRYPTO_EC_POINT_AFFINE, scratch, buffer_size);

nx_crypto_ecdsa.c:376

NX_CRYPTO_EC_POINT_INITIALIZE(&ecjpake -> nx_crypto_ecjpake_public_x1,

nx_crypto_ecjpake.c:95

NX_CRYPTO_EC_POINT_INITIALIZE(&ecjpake -> nx_crypto_ecjpake_public_x2,

nx_crypto_ecjpake.c:97

NX_CRYPTO_EC_POINT_INITIALIZE(&ecjpake -> nx_crypto_ecjpake_public_x3,

nx_crypto_ecjpake.c:99

NX_CRYPTO_EC_POINT_INITIALIZE(&ecjpake -> nx_crypto_ecjpake_public_x4,

nx_crypto_ecjpake.c:101

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&ecjpake -> nx_crypto_ecjpake_private_x2, scratch_ptr, buffer_size);

nx_crypto_ecjpake.c:104

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&private_key, scratch, buffer_size);

nx_crypto_ecjpake.c:180

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&r, scratch, buffer_size);

nx_crypto_ecjpake.c:181

NX_CRYPTO_EC_POINT_INITIALIZE(&v, NX_CRYPTO_EC_POINT_AFFINE, scratch, buffer_size);

nx_crypto_ecjpake.c:182

_nx_crypto_ecjpake_hello_process()

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&r, scratch, buffer_size);

nx_crypto_ecjpake.c:349

NX_CRYPTO_EC_POINT_INITIALIZE(&v, NX_CRYPTO_EC_POINT_AFFINE, scratch, buffer_size);

nx_crypto_ecjpake.c:350

_nx_crypto_ecjpake_hello_process()

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&private_key, scratch, buffer_size);

nx_crypto_ecjpake.c:509

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&r, scratch, buffer_size);

nx_crypto_ecjpake.c:510

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&s, scratch,

nx_crypto_ecjpake.c:511

NX_CRYPTO_EC_POINT_INITIALIZE(&ga, NX_CRYPTO_EC_POINT_AFFINE, scratch, buffer_size);

nx_crypto_ecjpake.c:513

NX_CRYPTO_EC_POINT_INITIALIZE(&public_key, NX_CRYPTO_EC_POINT_AFFINE, scratch, buffer_size);

nx_crypto_ecjpake.c:514

NX_CRYPTO_EC_POINT_INITIALIZE(&v, NX_CRYPTO_EC_POINT_AFFINE, scratch, buffer_size);

nx_crypto_ecjpake.c:515

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&r, scratch, buffer_size);

nx_crypto_ecjpake.c:647

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&s, scratch,

nx_crypto_ecjpake.c:648

NX_CRYPTO_EC_POINT_INITIALIZE(&ga, NX_CRYPTO_EC_POINT_AFFINE, scratch, buffer_size);

nx_crypto_ecjpake.c:650

NX_CRYPTO_EC_POINT_INITIALIZE(&public_key, NX_CRYPTO_EC_POINT_AFFINE, scratch, buffer_size);

nx_crypto_ecjpake.c:651

NX_CRYPTO_EC_POINT_INITIALIZE(&v, NX_CRYPTO_EC_POINT_AFFINE, scratch, buffer_size);

nx_crypto_ecjpake.c:652

NX_CRYPTO_HUGE_NUMBER_COPY(&ga.nx_crypto_ec_point_x,

nx_crypto_ecjpake.c:664

NX_CRYPTO_HUGE_NUMBER_COPY(&ga.nx_crypto_ec_point_y,

nx_crypto_ecjpake.c:666

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&h, scratch, buffer_size);

nx_crypto_ecjpake.c:1122

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp1, scratch, buffer_size << 1);

nx_crypto_ecjpake.c:1123

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp2, scratch, buffer_size << 1);

nx_crypto_ecjpake.c:1124

NX_CRYPTO_HUGE_NUMBER_COPY(r, &temp1);

nx_crypto_ecjpake.c:1147

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&h, scratch,

nx_crypto_ecjpake.c:1223

NX_CRYPTO_EC_POINT_INITIALIZE(&temp1,

nx_crypto_ecjpake.c:1225

NX_CRYPTO_EC_POINT_INITIALIZE(&temp2,

nx_crypto_ecjpake.c:1228

NX_CRYPTO_HUGE_NUMBER_COPY(&g -> nx_crypto_ec_point_x, &x1 -> nx_crypto_ec_point_x);

nx_crypto_ecjpake.c:1329

NX_CRYPTO_HUGE_NUMBER_COPY(&g -> nx_crypto_ec_point_y, &x1 -> nx_crypto_ec_point_y);

nx_crypto_ecjpake.c:1330

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp1, scratch,

nx_crypto_ecjpake.c:1335

NX_CRYPTO_HUGE_NUMBER_COPY(private_key, &temp1);

nx_crypto_ecjpake.c:1339

NX_CRYPTO_EC_POINT_INITIALIZE(&temp1,

nx_crypto_ecjpake.c:1415

NX_CRYPTO_EC_POINT_INITIALIZE(&temp2,

nx_crypto_ecjpake.c:1418

NX_CRYPTO_HUGE_NUMBER_COPY(&temp1.nx_crypto_ec_point_x, &x4 -> nx_crypto_ec_point_x);

nx_crypto_ecjpake.c:1425

NX_CRYPTO_HUGE_NUMBER_COPY(&temp1.nx_crypto_ec_point_y, &x4 -> nx_crypto_ec_point_y);

nx_crypto_ecjpake.c:1426

NX_CRYPTO_HUGE_NUMBER_COPY(&temp2.nx_crypto_ec_point_x, &public_key -> nx_crypto_ec_point_x);

nx_crypto_ecjpake.c:1429

NX_CRYPTO_HUGE_NUMBER_COPY(&temp2.nx_crypto_ec_point_y, &public_key -> nx_crypto_ec_point_y);

nx_crypto_ecjpake.c:1430

nx_crypto_huge_number.c:93

if (x -> nx_crypto_huge_number_data[i])

_nx_crypto_huge_number_is_zero()

NX_CRYPTO_HUGE_NUMBER_SET_DIGIT(left, 0);

nx_crypto_huge_number.c:187

_nx_crypto_huge_number_add()

NX_CRYPTO_HUGE_NUMBER_SET_DIGIT(left, 0);

nx_crypto_huge_number.c:285

_nx_crypto_huge_number_subtract()

HN_UBASE *result_buffer = left -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:356

nx_crypto_huge_number.c:365

left_buffer = right -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:366

right_buffer = left -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:372

left_buffer = left -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:373

right_buffer = right -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:461

HN_UBASE *left_buffer = left -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:462

HN_UBASE *right_buffer = right -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:463

HN_UBASE *result_buffer = result -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:537

HN_UBASE *buffer = value -> nx_crypto_huge_number_data;

_nx_crypto_huge_number_add_digit_unsigned()

HN_UBASE *buffer = value -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:612

_nx_crypto_huge_number_subtract_digit_unsigned()

HN_UBASE *x_buffer = x -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:674

_nx_crypto_huge_number_shift_left()

HN_UBASE *x_buffer = x -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:744

_nx_crypto_huge_number_shift_right()

if (val -> nx_crypto_huge_number_data[size] != 0)

nx_crypto_huge_number.c:818

_nx_crypto_huge_number_adjust_size()

while (left_size && (left -> nx_crypto_huge_number_data[left_size - 1] == 0))

nx_crypto_huge_number.c:999

nx_crypto_huge_number.c:1003

while (right_size && (right -> nx_crypto_huge_number_data[right_size - 1] == 0))

nx_crypto_huge_number.c:1020

if (left -> nx_crypto_huge_number_data[i] > right -> nx_crypto_huge_number_data[i])

nx_crypto_huge_number.c:1024

else if (right -> nx_crypto_huge_number_data[i] > left -> nx_crypto_huge_number_data[i])

nx_crypto_huge_number.c:1100

left_buffer = left -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:1101

right_buffer = right -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:1107

result_buffer = result -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:1210

result -> nx_crypto_huge_number_data[0] = 0;

nx_crypto_huge_number.c:1217

value_buffer = value -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:1218

result_buffer = result -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:1302

value_buffer = value -> nx_crypto_huge_number_data;

_nx_crypto_huge_number_square()

result_buffer = result -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:1303

_nx_crypto_huge_number_square()

result_buffer = result -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:1476

_nx_crypto_huge_number_modulus()

divisor_buffer = divisor -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:1477

_nx_crypto_huge_number_modulus()

number -> nx_crypto_huge_number_data[0] = 0;

nx_crypto_huge_number.c:1681

_nx_crypto_huge_number_setup()

destination = number -> nx_crypto_huge_number_data + num_words - 1;

nx_crypto_huge_number.c:1696

_nx_crypto_huge_number_setup()

word = number -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:1931

_nx_crypto_huge_number_extract()

word = number -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:2002

_nx_crypto_huge_number_extract_fixed_size()

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&u, scratch, buffer_size);

nx_crypto_huge_number.c:2175

nx_crypto_huge_number.c:2176

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&v, scratch, buffer_size);

nx_crypto_huge_number.c:2177

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&A, scratch, buffer_size);

nx_crypto_huge_number.c:2178

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&C, scratch, buffer_size);

nx_crypto_huge_number.c:2180

NX_CRYPTO_HUGE_NUMBER_COPY(&u, a);

nx_crypto_huge_number.c:2181

NX_CRYPTO_HUGE_NUMBER_COPY(&v, p);

nx_crypto_huge_number.c:2182

NX_CRYPTO_HUGE_NUMBER_SET_DIGIT(&A, 1);

nx_crypto_huge_number.c:2183

NX_CRYPTO_HUGE_NUMBER_SET_DIGIT(&C, 0);

nx_crypto_huge_number.c:2187

while (NX_CRYPTO_HUGE_NUMBER_IS_EVEN(&u))

nx_crypto_huge_number.c:2190

if (NX_CRYPTO_HUGE_NUMBER_IS_EVEN(&A))

nx_crypto_huge_number.c:2201

while (NX_CRYPTO_HUGE_NUMBER_IS_EVEN(&v))

nx_crypto_huge_number.c:2204

if (NX_CRYPTO_HUGE_NUMBER_IS_EVEN(&C))

nx_crypto_huge_number.c:2228

NX_CRYPTO_HUGE_NUMBER_COPY(r, &C);

nx_crypto_huge_number.c:2302

if (NX_CRYPTO_HUGE_NUMBER_IS_EVEN(m) && NX_CRYPTO_HUGE_NUMBER_IS_EVEN(a))

nx_crypto_huge_number.c:2327

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&u, scratch, buffer_size);

nx_crypto_huge_number.c:2328

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&v, scratch, buffer_size);

nx_crypto_huge_number.c:2329

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&A, scratch, buffer_size);

nx_crypto_huge_number.c:2330

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&B, scratch, buffer_size);

nx_crypto_huge_number.c:2331

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&C, scratch, buffer_size);

nx_crypto_huge_number.c:2332

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&D, scratch, buffer_size);

nx_crypto_huge_number.c:2334

NX_CRYPTO_HUGE_NUMBER_COPY(&u, m);

nx_crypto_huge_number.c:2335

NX_CRYPTO_HUGE_NUMBER_COPY(&v, a);

nx_crypto_huge_number.c:2336

NX_CRYPTO_HUGE_NUMBER_SET_DIGIT(&A, 1);

nx_crypto_huge_number.c:2337

NX_CRYPTO_HUGE_NUMBER_SET_DIGIT(&B, 0);

nx_crypto_huge_number.c:2338

NX_CRYPTO_HUGE_NUMBER_SET_DIGIT(&C, 0);

nx_crypto_huge_number.c:2339

NX_CRYPTO_HUGE_NUMBER_SET_DIGIT(&D, 1);

nx_crypto_huge_number.c:2343

while (NX_CRYPTO_HUGE_NUMBER_IS_EVEN(&u))

nx_crypto_huge_number.c:2347

if (NX_CRYPTO_HUGE_NUMBER_IS_EVEN(&A) && NX_CRYPTO_HUGE_NUMBER_IS_EVEN(&B))

nx_crypto_huge_number.c:2361

while (NX_CRYPTO_HUGE_NUMBER_IS_EVEN(&v))

nx_crypto_huge_number.c:2364

if (NX_CRYPTO_HUGE_NUMBER_IS_EVEN(&C) && NX_CRYPTO_HUGE_NUMBER_IS_EVEN(&D))

nx_crypto_huge_number.c:2394

NX_CRYPTO_HUGE_NUMBER_COPY(r, &D);

nx_crypto_huge_number.c:2465

HN_UBASE *m_buffer = m -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:2466

HN_UBASE *x_buffer = x -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:2467

HN_UBASE *y_buffer = y -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:2468

HN_UBASE *result_buffer = result -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:2470

NX_CRYPTO_MEMSET(result -> nx_crypto_huge_number_data, 0, (m_len + 1) * sizeof(HN_UBASE));

nx_crypto_huge_number.c:2636

radix.nx_crypto_huge_number_data = radix_buffer;

nx_crypto_huge_number.c:2640

m0.nx_crypto_huge_number_data = m -> nx_crypto_huge_number_data;

nx_crypto_huge_number.c:2644

mi.nx_crypto_huge_number_data = mm_buffer;

nx_crypto_huge_number.c:2653

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&xx, scratch, m -> nx_crypto_huge_buffer_size + sizeof(HN_UBASE));

nx_crypto_huge_number.c:2654

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp, scratch, m -> nx_crypto_huge_buffer_size + sizeof(HN_UBASE));

nx_crypto_huge_number.c:2655

NX_CRYPTO_HUGE_NUMBER_INITIALIZE_DIGIT(&digit, &digit_value, 1);

nx_crypto_huge_number.c:2660

val = temp.nx_crypto_huge_number_data;

nx_crypto_huge_number.c:2672

NX_CRYPTO_HUGE_NUMBER_COPY(result, &temp);

nx_crypto_huge_number.c:2680

val = e -> nx_crypto_huge_number_data + (exp_size - 1);

nx_crypto_huge_number.c:2683

for (; (ULONG)val >= (ULONG)(e -> nx_crypto_huge_number_data); val--)

nx_crypto_huge_number.c:2718

NX_CRYPTO_HUGE_NUMBER_COPY(result, &temp);

nx_crypto_huge_number.c:2824

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&pi, scratch, p -> nx_crypto_huge_buffer_size);

nx_crypto_huge_number.c:2825

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&qi, scratch, q -> nx_crypto_huge_buffer_size);

nx_crypto_huge_number.c:2834

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp1, scratch, m -> nx_crypto_huge_buffer_size);

nx_crypto_huge_number.c:2835

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp2, scratch, p -> nx_crypto_huge_buffer_size);

nx_crypto_huge_number.c:2836

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp3, scratch, p -> nx_crypto_huge_buffer_size);

nx_crypto_huge_number.c:2837

NX_CRYPTO_HUGE_NUMBER_INITIALIZE_DIGIT(&digit, &digit_value, 1);

nx_crypto_huge_number.c:2842

NX_CRYPTO_HUGE_NUMBER_COPY(ep, e);

nx_crypto_huge_number.c:2843

NX_CRYPTO_HUGE_NUMBER_COPY(&temp1, p);

nx_crypto_huge_number.c:2849

NX_CRYPTO_HUGE_NUMBER_COPY(xp, x);

nx_crypto_huge_number.c:2866

NX_CRYPTO_HUGE_NUMBER_COPY(eq, e);

nx_crypto_huge_number.c:2867

NX_CRYPTO_HUGE_NUMBER_COPY(&temp1, q);

nx_crypto_huge_number.c:2873

NX_CRYPTO_HUGE_NUMBER_COPY(xq, x);

nx_crypto_huge_number_extended.c:87

(value -> nx_crypto_huge_number_data[0] >= digit))

_nx_crypto_huge_number_add_digit()

value -> nx_crypto_huge_number_data[0] = digit - value -> nx_crypto_huge_number_data[0];

nx_crypto_huge_number_extended.c:99

_nx_crypto_huge_number_add_digit()

(value -> nx_crypto_huge_number_data[0] >= digit))

nx_crypto_huge_number_extended.c:169

_nx_crypto_huge_number_subtract_digit()

value -> nx_crypto_huge_number_data[0] = digit - value -> nx_crypto_huge_number_data[0];

nx_crypto_huge_number_extended.c:181

_nx_crypto_huge_number_subtract_digit()

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp, scratch,

nx_crypto_huge_number_extended.c:261

nx_crypto_huge_number_extended.c:265

NX_CRYPTO_HUGE_NUMBER_SET_DIGIT(result, 1);

nx_crypto_huge_number_extended.c:268

val = exponent -> nx_crypto_huge_number_data;

nx_crypto_huge_number_extended.c:283

NX_CRYPTO_HUGE_NUMBER_COPY(result, &temp);

nx_crypto_huge_number_extended.c:295

NX_CRYPTO_HUGE_NUMBER_COPY(number, &temp);

modulus_hn.nx_crypto_huge_number_data = (HN_UBASE *)scratch;

nx_crypto_rsa.c:106

input_hn.nx_crypto_huge_number_data = (HN_UBASE *)scratch;

nx_crypto_rsa.c:111

exponent_hn.nx_crypto_huge_number_data = (HN_UBASE *)scratch;

nx_crypto_rsa.c:116

output_hn.nx_crypto_huge_number_data = (HN_UBASE *)scratch;

nx_crypto_rsa.c:121

p_hn.nx_crypto_huge_number_data = (HN_UBASE *)scratch;

nx_crypto_rsa.c:137

q_hn.nx_crypto_huge_number_data = (HN_UBASE *)scratch;

nx_crypto_rsa.c:141

Call Tree

All items filtered out

Data Use

NX_CRYPTO_HUGE_NUMBER_STRUCT::nx_crypto_huge_number_data is written by 39 functions and is read by 51 functions:

_nx_crypto_ec_key_pair_stream_generate()

_nx_crypto_ec_validate_public_key()

_nx_crypto_ecdh_key_pair_import()

_nx_crypto_ecdh_private_key_export()

_nx_crypto_ecdh_setup()

_nx_crypto_ecjpake_hello_process()

NX_CRYPTO_HUGE_NUMBER_STRUCT::nx_crypto_huge_number_data

_nx_crypto_ec_point_fp_affine_to_projective()

_nx_crypto_ec_subtract_digit_reduce()

_nx_crypto_ec_fixed_output()

_nx_crypto_huge_number_is_zero()

_nx_crypto_huge_number_add()

_nx_crypto_huge_number_subtract()

_nx_crypto_huge_number_add_digit_unsigned()

_nx_crypto_huge_number_subtract_digit_unsigned()

_nx_crypto_huge_number_shift_left()

_nx_crypto_huge_number_shift_right()

_nx_crypto_huge_number_adjust_size()

_nx_crypto_huge_number_square()

_nx_crypto_huge_number_modulus()

_nx_crypto_huge_number_setup()

_nx_crypto_huge_number_extract()

_nx_crypto_huge_number_extract_fixed_size()

_nx_crypto_huge_number_add_digit()

_nx_crypto_huge_number_subtract_digit()