NX_CRYPTO_HUGE_NUMBER_STRUCT::nx_crypto_huge_number_is_negative field

modulus.nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_dh.c:147

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_is_negative = NX_CRYPTO_FALSE;

nx_crypto_dh.c:167

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_is_negative = NX_CRYPTO_FALSE;

nx_crypto_dh.c:295

private_key.nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_dh.c:303

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

value -> nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_ec.c:1249

else if (value -> nx_crypto_huge_number_is_negative)

nx_crypto_ec.c:1251

value -> nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_ec.c:1254

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

value -> nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_ec.c:1392

else if (value -> nx_crypto_huge_number_is_negative)

nx_crypto_ec.c:1394

value -> nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_ec.c:1397

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

value -> nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_ec.c:1560

else if (value -> nx_crypto_huge_number_is_negative)

nx_crypto_ec.c:1562

value -> nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_ec.c:1565

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

value -> nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_ec.c:1734

else if (value -> nx_crypto_huge_number_is_negative)

nx_crypto_ec.c:1736

value -> nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_ec.c:1739

nx_crypto_ec.c:1818

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp, scratch, 66);

nx_crypto_ec.c:1822

value -> nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_ec.c:1855

else if (value -> nx_crypto_huge_number_is_negative)

nx_crypto_ec.c:1857

value -> nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_ec.c:1860

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

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_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_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_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

if (public_key -> nx_crypto_ec_point_x.nx_crypto_huge_number_is_negative ||

nx_crypto_ec.c:4321

public_key -> nx_crypto_ec_point_y.nx_crypto_huge_number_is_negative)

nx_crypto_ec.c:4322

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

nx_crypto_ec.c:4332

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

nx_crypto_ec.c:4333

_nx_crypto_ecdh_private_key_export()

private_key.nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_ecdh.c:192

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_is_negative = NX_CRYPTO_FALSE;

nx_crypto_ecdh.c:285

_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_is_negative = NX_CRYPTO_FALSE;

nx_crypto_ecdh.c:428

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

if (left -> nx_crypto_huge_number_is_negative == right -> nx_crypto_huge_number_is_negative)

nx_crypto_huge_number.c:187

NX_CRYPTO_HUGE_NUMBER_SET_DIGIT(left, 0);

nx_crypto_huge_number.c:192

left -> nx_crypto_huge_number_is_negative = right -> nx_crypto_huge_number_is_negative;

nx_crypto_huge_number.c:276

if (left -> nx_crypto_huge_number_is_negative != right -> nx_crypto_huge_number_is_negative)

nx_crypto_huge_number.c:285

NX_CRYPTO_HUGE_NUMBER_SET_DIGIT(left, 0);

nx_crypto_huge_number.c:290

left -> nx_crypto_huge_number_is_negative = !(right -> nx_crypto_huge_number_is_negative);

nx_crypto_huge_number.c:829

val -> nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

_nx_crypto_huge_number_adjust_size()

if (left -> nx_crypto_huge_number_is_negative != right -> nx_crypto_huge_number_is_negative)

nx_crypto_huge_number.c:898

nx_crypto_huge_number.c:900

if (left -> nx_crypto_huge_number_is_negative)

nx_crypto_huge_number.c:910

if (left -> nx_crypto_huge_number_is_negative)

nx_crypto_huge_number.c:1140

if (left -> nx_crypto_huge_number_is_negative == right -> nx_crypto_huge_number_is_negative)

nx_crypto_huge_number.c:1142

result -> nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_huge_number.c:1146

result -> nx_crypto_huge_number_is_negative = NX_CRYPTO_TRUE;

nx_crypto_huge_number.c:1212

result -> nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_huge_number.c:1237

result -> nx_crypto_huge_number_is_negative = value -> nx_crypto_huge_number_is_negative;

nx_crypto_huge_number.c:1336

result -> nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

_nx_crypto_huge_number_square()

if (result -> nx_crypto_huge_number_is_negative)

nx_crypto_huge_number.c:1464

_nx_crypto_huge_number_modulus()

if (result -> nx_crypto_huge_number_is_negative)

nx_crypto_huge_number.c:1582

_nx_crypto_huge_number_modulus()

number -> nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_huge_number.c:1683

_nx_crypto_huge_number_setup()

number -> nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_huge_number.c:1740

_nx_crypto_huge_number_setup()

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

NX_CRYPTO_HUGE_NUMBER_COPY(r, &C);

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

NX_CRYPTO_HUGE_NUMBER_COPY(r, &D);

nx_crypto_huge_number.c:2638

radix.nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_huge_number.c:2643

m0.nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

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

NX_CRYPTO_HUGE_NUMBER_COPY(result, &temp);

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

if (value -> nx_crypto_huge_number_is_negative)

nx_crypto_huge_number_extended.c:100

value -> nx_crypto_huge_number_is_negative = NX_CRYPTO_FALSE;

nx_crypto_huge_number_extended.c:160

if (value -> nx_crypto_huge_number_is_negative)

nx_crypto_huge_number_extended.c:182

value -> nx_crypto_huge_number_is_negative = NX_CRYPTO_TRUE;

nx_crypto_huge_number_extended.c:261

NX_CRYPTO_HUGE_NUMBER_INITIALIZE(&temp, scratch,

nx_crypto_huge_number_extended.c:265

NX_CRYPTO_HUGE_NUMBER_SET_DIGIT(result, 1);

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);

Call Tree

All items filtered out

Data Use

NX_CRYPTO_HUGE_NUMBER_STRUCT::nx_crypto_huge_number_is_negative is written by 48 functions and is read by 33 functions:

_nx_crypto_ec_point_fp_affine_to_projective()

_nx_crypto_ec_key_pair_stream_generate()

_nx_crypto_ecdh_private_key_export()

_nx_crypto_ecdh_setup()

_nx_crypto_ecjpake_hello_process()

_nx_crypto_huge_number_adjust_size()

_nx_crypto_huge_number_square()

_nx_crypto_huge_number_setup()

NX_CRYPTO_HUGE_NUMBER_STRUCT::nx_crypto_huge_number_is_negative

_nx_crypto_huge_number_modulus()