crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1028

ret = nn_set_wlen(tmp, (u8)(nn_len / WORD_BYTES)); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1029

ret = nn_import_from_hexbuf(tmp, rec, 2 * nn_len); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1032

ret = fp_ctx_init_from_p(&fp_ctx_param, &fp_ctx_modulus); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1037

ret = nn_set_wlen(tmp, (u8)(nn_len / WORD_BYTES)); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1039

2 * nn_len); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1051

ret = nn_set_wlen(tmp, (u8)(nn_len / WORD_BYTES)); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1053

2 * nn_len); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1065

ret = nn_set_wlen(tmp, 1); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1067

WORD_BYTES * 2); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1078

ret = nn_set_wlen(tmp, 1); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1080

WORD_BYTES * 2); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1091

ret = nn_set_wlen(tmp, (u8)(nn_len / WORD_BYTES)); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1093

nn_len * 2); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1104

ret = nn_set_wlen(tmp, 1); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1106

WORD_BYTES * 2); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1138

ret = nn_set_wlen(tmp, (u8)(nn_len / WORD_BYTES)); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1139

ret = nn_import_from_hexbuf(tmp, rec, 2 * nn_len); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1140

ret = nn_set_wlen(tmp, fp_ctx_param.p.wlen); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1168

ret = nn_set_wlen(tmp, (u8)(nn_len / WORD_BYTES)); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

1169

ret = nn_import_from_hexbuf(tmp, rec, 2 * nn_len); EG(ret, err);

crypto/libecc/src/arithmetic_tests/arithmetic_tests.c

80

ret = nn_check_initialized(out_nn); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

107

ret = ec_shortw_crv_check_initialized(curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

108

ret = fp_check_initialized(x); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

114

ret = fp_copy(y1, x); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

115

ret = fp_copy(y2, x); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

118

ret = fp_sqr(y1, y1); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

119

ret = fp_mul(y1, y1, x); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

120

ret = fp_mul(y2, y2, &(curve->a)); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

121

ret = fp_add(y1, y1, y2); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

122

ret = fp_add(y1, y1, &(curve->b)); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

145

ret = ec_shortw_crv_check_initialized(curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

146

ret = fp_check_initialized(x); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

147

ret = fp_check_initialized(y); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

158

ret = fp_init(&tmp1, x->ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

159

ret = fp_sqr(&tmp1, y); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

160

ret = fp_sub(&tmp1, &tmp1, &(curve->b)); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

163

ret = fp_init(&tmp2, x->ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

164

ret = fp_sqr(&tmp2, x); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

165

ret = fp_add(&tmp2, &tmp2, &(curve->a)); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

166

ret = fp_mul(&tmp2, &tmp2, x); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

169

ret = fp_cmp(&tmp1, &tmp2, &cmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

189

ret = aff_pt_check_initialized(pt); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

204

ret = aff_pt_check_initialized(in); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

205

ret = aff_pt_init(out, in->crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

206

ret = fp_copy(&(out->x), &(in->x)); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

224

ret = aff_pt_check_initialized(in1); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

225

ret = aff_pt_check_initialized(in2); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

229

ret = fp_cmp(&(in1->x), &(in2->x), &cmp_x); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

230

ret = fp_cmp(&(in1->y), &(in2->y), &cmp_y); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

251

ret = aff_pt_check_initialized(in1); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

252

ret = aff_pt_check_initialized(in2); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

256

ret = fp_cmp(&(in1->x), &(in2->x), &cmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

257

ret = fp_eq_or_opp(&(in1->y), &(in2->y), &eq_or_opp); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

282

ret = ec_shortw_crv_check_initialized(crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

289

ret = fp_init_from_buf(&(pt->x), ctx, pt_buf, coord_len); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

290

ret = fp_init_from_buf(&(pt->y), ctx, pt_buf + coord_len, coord_len); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

302

ret = aff_pt_is_on_curve(pt, &on_curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

333

ret = aff_pt_is_on_curve(pt, &on_curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

341

ret = fp_export_to_buf(pt_buf, coord_len, &(pt->x)); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

46

ret = ec_shortw_crv_check_initialized(curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

47

ret = fp_init(&(in->x), curve->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

48

ret = fp_init(&(in->y), curve->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

67

ret = aff_pt_init(in, curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt.c

68

ret = fp_copy(&(in->x), xcoord); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

113

ret = ec_edwards_crv_check_initialized(curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

115

ret = fp_check_initialized(x); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

116

ret = fp_check_initialized(y); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

121

ret = fp_init(&x2, x->ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

122

ret = fp_sqr(&x2, x); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

123

ret = fp_init(&y2, x->ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

124

ret = fp_sqr(&y2, y); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

126

ret = fp_init(&tmp1, x->ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

127

ret = fp_init(&tmp2, x->ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

129

ret = fp_mul(&tmp1, &x2, &y2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

130

ret = fp_mul(&tmp1, &tmp1, &(curve->d)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

131

ret = fp_inc(&tmp1, &tmp1); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

133

ret = fp_mul(&tmp2, &x2, &(curve->a)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

134

ret = fp_add(&tmp2, &tmp2, &y2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

161

ret = aff_pt_edwards_check_initialized(pt); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

178

ret = aff_pt_edwards_check_initialized(in); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

179

ret = aff_pt_edwards_init(out, in->crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

181

ret = fp_copy(&(out->x), &(in->x)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

200

ret = aff_pt_edwards_check_initialized(in1); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

201

ret = aff_pt_edwards_check_initialized(in2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

205

ret = fp_cmp(&(in1->x), &(in2->x), &cmp1); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

233

ret = ec_edwards_crv_check_initialized(crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

241

ret = fp_init_from_buf(&(pt->x), ctx, pt_buf, coord_len); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

242

ret = fp_init_from_buf(&(pt->y), ctx, pt_buf + coord_len, coord_len); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

253

ret = aff_pt_edwards_is_on_curve(pt, &on_curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

279

ret = aff_pt_edwards_check_initialized(pt); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

283

ret = aff_pt_edwards_is_on_curve(pt, &on_curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

292

ret = fp_export_to_buf(pt_buf, coord_len, &(pt->x)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

316

ret = ec_edwards_crv_check_initialized(edwards_crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

317

ret = fp_check_initialized(alpha_edwards); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

320

ret = fp_init(&tmp1, edwards_crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

321

ret = fp_init(&tmp2, edwards_crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

322

ret = fp_init(&A, edwards_crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

323

ret = fp_init(&B, edwards_crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

331

ret = fp_sqr(&tmp1, alpha_edwards); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

332

ret = fp_sub(&tmp2, &(edwards_crv->a), &(edwards_crv->d)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

333

ret = fp_mul(&tmp2, &tmp2, &tmp1); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

334

ret = fp_inv(&tmp2, &tmp2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

335

ret = fp_set_word_value(&B, WORD(2)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

336

ret = fp_mul(&tmp2, &tmp2, &B); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

338

ret = fp_add(&A, &(edwards_crv->a), &(edwards_crv->d)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

339

ret = fp_mul(&A, &A, &tmp1); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

340

ret = fp_mul(&A, &A, &tmp2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

341

ret = fp_mul(&B, &B, &tmp2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

368

ret = ec_montgomery_crv_check_initialized(m_crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

369

ret = curve_edwards_to_montgomery(e_crv, &check, alpha_edwards); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

401

ret = ec_montgomery_crv_check_initialized(m_crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

402

ret = fp_check_initialized(alpha_edwards); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

405

ret = fp_init(&tmp, m_crv->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

406

ret = fp_init(&tmp2, m_crv->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

407

ret = fp_init(&a, m_crv->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

408

ret = fp_init(&d, m_crv->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

410

ret = fp_set_word_value(&tmp, WORD(2)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

411

ret = fp_mul(&tmp2, &(m_crv->B), alpha_edwards); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

412

ret = fp_mul(&tmp2, &tmp2, alpha_edwards); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

413

ret = fp_inv(&tmp2, &tmp2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

416

ret = fp_add(&a, &(m_crv->A), &tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

417

ret = fp_mul(&a, &a, &tmp2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

420

ret = fp_sub(&d, &(m_crv->A), &tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

421

ret = fp_mul(&d, &d, &tmp2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

425

ret = fp_one(&tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

426

ret = fp_cmp(&d, &tmp, &cmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

45

ret = ec_edwards_crv_check_initialized(curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

455

ret = curve_edwards_to_montgomery(edwards_crv, &montgomery_crv, alpha_edwards); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

47

ret = fp_init(&(in->x), curve->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

476

ret = curve_edwards_to_montgomery(edwards_crv, &montgomery_crv, alpha_edwards); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

48

ret = fp_init(&(in->y), curve->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

501

ret = curve_shortw_to_montgomery(shortw_crv, &montgomery_crv, alpha_montgomery, gamma_montgomery); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

539

ret = ec_montgomery_crv_check_initialized(montgomery_crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

542

ret = aff_pt_edwards_is_on_curve(in_edwards, &on_curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

545

ret = curve_edwards_montgomery_check(in_edwards->crv, montgomery_crv, alpha_edwards); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

547

ret = fp_init(&tmp, in_edwards->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

548

ret = fp_init(&tmp2, in_edwards->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

549

ret = fp_init(&x, in_edwards->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

550

ret = fp_init(&y, in_edwards->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

551

ret = fp_init(&tab_x[0], in_edwards->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

552

ret = fp_init(&tab_x[1], in_edwards->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

553

ret = fp_init(&tab_y[0], in_edwards->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

554

ret = fp_init(&tab_y[1], in_edwards->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

556

ret = fp_one(&tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

558

ret = fp_iszero(&(in_edwards->x), &iszero); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

559

ret = fp_cmp(&(in_edwards->y), &tmp, &cmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

562

ret = fp_zero(&tmp2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

563

ret = fp_sub(&tmp2, &tmp2, &tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

565

ret = fp_one(&tab_x[0]); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

566

ret = fp_copy(&tab_x[1], &(in_edwards->x)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

568

ret = fp_copy(&tab_y[0], &tmp2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

569

ret = fp_copy(&tab_y[1], &(in_edwards->y)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

571

ret = fp_iszero(&(in_edwards->x), &iszero); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

572

ret = fp_cmp(&(in_edwards->y), &tmp2, &cmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

574

ret = fp_tabselect(&x, idx, tab_x_t, 2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

575

ret = fp_tabselect(&y, idx, tab_y_t, 2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

577

ret = aff_pt_montgomery_init(out_montgomery, montgomery_crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

579

ret = fp_copy(&tmp2, &tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

581

ret = fp_sub(&tmp, &tmp, &y); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

582

ret = fp_inv(&tmp, &tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

584

ret = fp_add(&tmp2, &tmp2, &y); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

586

ret = fp_mul(&(out_montgomery->u), &tmp, &tmp2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

588

ret = fp_inv(&(out_montgomery->v), &x); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

589

ret = fp_mul(&(out_montgomery->v), &(out_montgomery->v), alpha_edwards); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

590

ret = fp_mul(&(out_montgomery->v), &(out_montgomery->u), &(out_montgomery->v)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

593

ret = aff_pt_montgomery_is_on_curve(out_montgomery, &on_curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

639

ret = ec_edwards_crv_check_initialized(edwards_crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

642

ret = aff_pt_montgomery_is_on_curve(in_montgomery, &on_curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

645

ret = curve_edwards_montgomery_check(edwards_crv, in_montgomery->crv, alpha); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

647

ret = fp_init(&tmp, in_montgomery->crv->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

648

ret = fp_init(&u, in_montgomery->crv->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

649

ret = fp_init(&v, in_montgomery->crv->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

650

ret = fp_init(&tab_u[0], in_montgomery->crv->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

651

ret = fp_init(&tab_u[1], in_montgomery->crv->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

652

ret = fp_init(&tab_v[0], in_montgomery->crv->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

653

ret = fp_init(&tab_v[1], in_montgomery->crv->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

655

ret = fp_one(&tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

658

ret = fp_zero(&tab_u[0]); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

659

ret = fp_copy(&tab_u[1], &(in_montgomery->u)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

661

ret = fp_copy(&tab_v[0], &tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

662

ret = fp_copy(&tab_v[1], &(in_montgomery->v)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

664

ret = fp_iszero(&(in_montgomery->u), &iszero1); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

665

ret = fp_iszero(&(in_montgomery->v), &iszero2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

667

ret = fp_tabselect(&u, idx, tab_u_t, 2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

668

ret = fp_tabselect(&v, idx, tab_v_t, 2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

670

ret = aff_pt_edwards_init(out_edwards, edwards_crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

672

ret = fp_inv(&(out_edwards->x), &v); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

673

ret = fp_mul(&(out_edwards->x), &(out_edwards->x), alpha); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

674

ret = fp_mul(&(out_edwards->x), &(out_edwards->x), &u); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

676

ret = fp_add(&(out_edwards->y), &u, &tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

677

ret = fp_inv(&(out_edwards->y), &(out_edwards->y)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

678

ret = fp_sub(&tmp, &u, &tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

679

ret = fp_mul(&(out_edwards->y), &(out_edwards->y), &tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

682

ret = aff_pt_edwards_is_on_curve(out_edwards, &on_curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

69

ret = aff_pt_edwards_init(in, curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

70

ret = fp_copy(&(in->x), xcoord); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

715

ret = aff_pt_edwards_check_initialized(in_edwards); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

716

ret = curve_edwards_to_montgomery(in_edwards->crv, &inter_montgomery_crv, alpha_edwards); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

717

ret = aff_pt_edwards_to_montgomery(in_edwards, &inter_montgomery_crv, &inter_montgomery, alpha_edwards); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

745

ret = curve_edwards_to_montgomery(edwards_crv, &inter_montgomery_crv, alpha_edwards); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

746

ret = aff_pt_shortw_to_montgomery(in_shortw, &inter_montgomery_crv, &inter_montgomery); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

773

ret = fp_check_initialized(x); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

774

ret = ec_edwards_crv_check_initialized(crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

780

ret = fp_init(y1, x->ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

781

ret = fp_init(y2, x->ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

782

ret = fp_init(&tmp, x->ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

787

ret = fp_one(&tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

789

ret = fp_mul(y1, x, &(crv->a)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

790

ret = fp_mul(y1, y1, x); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

791

ret = fp_sub(y1, &tmp, y1); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

793

ret = fp_mul(y2, x, &(crv->d)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

794

ret = fp_mul(y2, y2, x); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

795

ret = fp_sub(y2, &tmp, y2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

796

ret = fp_inv(y2, y2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

798

ret = fp_mul(&tmp, y1, y2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

823

ret = fp_check_initialized(y); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

824

ret = ec_edwards_crv_check_initialized(crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

830

ret = fp_init(x1, y->ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

831

ret = fp_init(x2, y->ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

832

ret = fp_init(&tmp, y->ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

837

ret = fp_one(&tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

839

ret = fp_mul(x1, y, y); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

840

ret = fp_sub(x1, &tmp, x1); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

842

ret = fp_mul(x2, y, &(crv->d)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

843

ret = fp_mul(x2, x2, y); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

844

ret = fp_sub(x2, &(crv->a), x2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

845

ret = fp_inv(x2, x2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_edwards.c

847

ret = fp_mul(&tmp, x1, x2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

107

ret = ec_montgomery_crv_check_initialized(curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

109

ret = fp_check_initialized(u); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

110

ret = fp_check_initialized(v); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

115

ret = fp_init(&Bv2, v->ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

116

ret = fp_sqr(&Bv2, v); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

117

ret = fp_mul(&Bv2, &(curve->B), &Bv2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

119

ret = fp_init(&Au2, u->ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

120

ret = fp_sqr(&Au2, u); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

121

ret = fp_copy(&u3, &Au2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

122

ret = fp_mul(&Au2, &(curve->A), &Au2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

124

ret = fp_mul(&u3, &u3, u); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

126

ret = fp_init(&tmp, u->ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

127

ret = fp_add(&tmp, &u3, &Au2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

128

ret = fp_add(&tmp, &tmp, u); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

130

ret = fp_cmp(&tmp, &Bv2, &cmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

152

ret = aff_pt_montgomery_check_initialized(pt); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

168

ret = aff_pt_montgomery_check_initialized(in); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

170

ret = aff_pt_montgomery_init(out, in->crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

171

ret = fp_copy(&(out->u), &(in->u)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

189

ret = aff_pt_montgomery_check_initialized(in1); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

190

ret = aff_pt_montgomery_check_initialized(in2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

193

ret = fp_cmp(&(in1->u), &(in2->u), &cmp1); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

194

ret = fp_cmp(&(in1->v), &(in2->v), &cmp2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

219

ret = ec_montgomery_crv_check_initialized(crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

227

ret = fp_init_from_buf(&(pt->u), ctx, pt_buf, coord_len); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

228

ret = fp_init_from_buf(&(pt->v), ctx, pt_buf + coord_len, coord_len); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

239

ret = aff_pt_montgomery_is_on_curve(pt, &on_curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

264

ret = aff_pt_montgomery_check_initialized(pt); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

268

ret = aff_pt_montgomery_is_on_curve(pt, &on_curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

277

ret = fp_export_to_buf(pt_buf, coord_len, &(pt->u)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

300

ret = ec_montgomery_crv_check_initialized(montgomery_crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

302

ret = fp_init(&tmp, montgomery_crv->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

303

ret = fp_init(&tmp2, montgomery_crv->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

304

ret = fp_init(&a, montgomery_crv->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

305

ret = fp_init(&b, montgomery_crv->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

308

ret = fp_sqr(&tmp, &(montgomery_crv->B)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

309

ret = fp_set_word_value(&tmp2, WORD(3)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

311

ret = fp_mul(&tmp, &tmp, &tmp2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

313

ret = fp_inv(&tmp, &tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

316

ret = fp_sqr(&tmp2, &(montgomery_crv->A)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

317

ret = fp_set_word_value(&a, WORD(3)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

318

ret = fp_sub(&tmp2, &a, &tmp2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

320

ret = fp_mul(&a, &tmp2, &tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

323

ret = fp_sqr(&tmp, &(montgomery_crv->B)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

324

ret = fp_mul(&tmp, &tmp, &(montgomery_crv->B)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

325

ret = fp_set_word_value(&tmp2, WORD(27)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

327

ret = fp_mul(&tmp, &tmp, &tmp2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

329

ret = fp_inv(&tmp, &tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

332

ret = fp_set_word_value(&tmp2, WORD(2)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

333

ret = fp_mul(&tmp2, &tmp2, &(montgomery_crv->A)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

334

ret = fp_mul(&tmp2, &tmp2, &(montgomery_crv->A)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

335

ret = fp_mul(&tmp2, &tmp2, &(montgomery_crv->A)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

337

ret = fp_set_word_value(&b, WORD(9)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

338

ret = fp_mul(&b, &b, &(montgomery_crv->A)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

339

ret = fp_sub(&b, &tmp2, &b); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

341

ret = fp_mul(&b, &b, &tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

367

ret = ec_shortw_crv_check_initialized(shortw_crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

368

ret = curve_montgomery_to_shortw(montgomery_crv, &check); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

399

ret = ec_shortw_crv_check_initialized(shortw_crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

400

ret = fp_check_initialized(alpha); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

401

ret = fp_check_initialized(gamma); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

404

ret = fp_init(&A, shortw_crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

405

ret = fp_init(&gamma_inv, shortw_crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

406

ret = fp_init(&c, shortw_crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

407

ret = fp_init(&tmp, shortw_crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

41

ret = ec_montgomery_crv_check_initialized(curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

410

ret = fp_inv(&gamma_inv, gamma); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

413

ret = fp_set_word_value(&A, WORD(3)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

414

ret = fp_mul(&A, &A, alpha); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

415

ret = fp_mul(&A, &A, &gamma_inv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

418

ret = fp_set_word_value(&c, WORD(3)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

419

ret = fp_mul(&c, &c, alpha); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

420

ret = fp_mul(&c, &c, alpha); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

421

ret = fp_add(&c, &c, &(shortw_crv->a)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

422

ret = fp_sqr(&tmp, gamma); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

43

ret = fp_init(&(in->u), curve->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

44

ret = fp_init(&(in->v), curve->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

452

ret = ec_shortw_crv_check_initialized(shortw_crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

457

ret = fp_init(&tmp, in_montgomery->crv->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

458

ret = fp_init(&tmp2, in_montgomery->crv->A.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

460

ret = aff_pt_montgomery_check_initialized(in_montgomery); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

461

ret = curve_montgomery_shortw_check(in_montgomery->crv, shortw_crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

463

ret = aff_pt_init(out_shortw, shortw_crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

465

ret = fp_inv(&tmp, &(in_montgomery->crv->B)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

466

ret = fp_mul(&tmp, &tmp, &(in_montgomery->u)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

468

ret = fp_set_word_value(&tmp2, WORD(3)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

469

ret = fp_mul(&tmp2, &tmp2, &(in_montgomery->crv->B)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

470

ret = fp_inv(&tmp2, &tmp2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

471

ret = fp_mul(&tmp2, &tmp2, &(in_montgomery->crv->A)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

473

ret = fp_add(&(out_shortw->x), &tmp, &tmp2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

475

ret = fp_inv(&tmp, &(in_montgomery->crv->B)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

476

ret = fp_mul(&(out_shortw->y), &tmp, &(in_montgomery->v)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

503

ret = ec_montgomery_crv_check_initialized(montgomery_crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

508

ret = fp_init(&tmp, in_shortw->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

509

ret = fp_init(&tmp2, in_shortw->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

511

ret = curve_montgomery_shortw_check(montgomery_crv, in_shortw->crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

513

ret = aff_pt_montgomery_init(out_montgomery, montgomery_crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

516

ret = fp_inv_word(&tmp, WORD(3)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

517

ret = fp_mul(&tmp, &tmp, &(montgomery_crv->A)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

520

ret = fp_mul(&tmp2, &(montgomery_crv->B), &(in_shortw->x)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

523

ret = fp_sub(&(out_montgomery->u), &tmp2, &tmp); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

526

ret = fp_mul(&(out_montgomery->v), &(montgomery_crv->B), &(in_shortw->y)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

552

ret = fp_check_initialized(u); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

553

ret = ec_montgomery_crv_check_initialized(crv); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

560

ret = fp_init(v1, u->ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

561

ret = fp_init(v2, u->ctx); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

566

ret = fp_sqr(v2, u); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

567

ret = fp_mul(v1, v2, u); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

568

ret = fp_mul(v2, v2, &(crv->A)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

569

ret = fp_add(v1, v1, v2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

570

ret = fp_add(v1, v1, u); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

571

ret = fp_inv(v2, &(crv->B)); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

572

ret = fp_mul(v1, v1, v2); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

65

ret = aff_pt_montgomery_init(in, curve); EG(ret, err);

crypto/libecc/src/curves/aff_pt_montgomery.c

66

ret = fp_copy(&(in->u), ucoord); EG(ret, err);

crypto/libecc/src/curves/curves.c

108

ret = local_strlen((const char *)name, &len); EG(ret, err);

crypto/libecc/src/curves/curves.c

151

ret = local_strnlen((const char *)ec_name, ec_name_len, &len); EG(ret, err);

crypto/libecc/src/curves/curves.c

199

ret = ec_get_curve_params_by_type(ec_type, &by_type); EG(ret, err);

crypto/libecc/src/curves/curves.c

238

ret = ec_get_curve_params_by_type(ec_type, &by_type); EG(ret, err);

crypto/libecc/src/curves/curves.c

44

ret = local_strnlen((const char *)ec_name, ec_name_len, &len); EG(ret, err);

crypto/libecc/src/curves/ec_edwards.c

47

ret = nn_check_initialized(order); EG(ret, err);

crypto/libecc/src/curves/ec_edwards.c

48

ret = fp_check_initialized(a); EG(ret, err);

crypto/libecc/src/curves/ec_edwards.c

49

ret = fp_check_initialized(d); EG(ret, err);

crypto/libecc/src/curves/ec_edwards.c

58

ret = fp_init(&(crv->a), a->ctx); EG(ret, err);

crypto/libecc/src/curves/ec_edwards.c

59

ret = fp_init(&(crv->d), d->ctx); EG(ret, err);

crypto/libecc/src/curves/ec_edwards.c

60

ret = fp_copy(&(crv->a), a); EG(ret, err);

crypto/libecc/src/curves/ec_edwards.c

61

ret = fp_copy(&(crv->d), d); EG(ret, err);

crypto/libecc/src/curves/ec_edwards.c

62

ret = nn_copy(&(crv->order), order); EG(ret, err);

crypto/libecc/src/curves/ec_montgomery.c

43

ret = nn_check_initialized(order); EG(ret, err);

crypto/libecc/src/curves/ec_montgomery.c

44

ret = fp_check_initialized(A); EG(ret, err);

crypto/libecc/src/curves/ec_montgomery.c

45

ret = fp_check_initialized(B); EG(ret, err);

crypto/libecc/src/curves/ec_montgomery.c

48

ret = fp_init(&tmp, A->ctx); EG(ret, err);

crypto/libecc/src/curves/ec_montgomery.c

51

ret = fp_set_word_value(&tmp, 2); EG(ret, err);

crypto/libecc/src/curves/ec_montgomery.c

52

ret = fp_add(&tmp, A, &tmp); EG(ret, err);

crypto/libecc/src/curves/ec_montgomery.c

55

ret = fp_set_word_value(&tmp, 2); EG(ret, err);

crypto/libecc/src/curves/ec_montgomery.c

56

ret = fp_sub(&tmp, A, &tmp); EG(ret, err);

crypto/libecc/src/curves/ec_montgomery.c

60

ret = fp_init(&(crv->A), A->ctx); EG(ret, err);

crypto/libecc/src/curves/ec_montgomery.c

61

ret = fp_init(&(crv->B), B->ctx); EG(ret, err);

crypto/libecc/src/curves/ec_montgomery.c

63

ret = fp_copy(&(crv->A), A); EG(ret, err);

crypto/libecc/src/curves/ec_montgomery.c

64

ret = fp_copy(&(crv->B), B); EG(ret, err);

crypto/libecc/src/curves/ec_montgomery.c

66

ret = nn_copy(&(crv->order), order); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

100

PARAM_BUF_LEN(in_str_params->gen_order)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

101

ret = nn_init(&(out_params->ec_gen_order), (u16)(tmp_order.wlen * WORD_BYTES)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

102

ret = nn_copy(&(out_params->ec_gen_order), &tmp_order); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

106

PARAM_BUF_LEN(in_str_params->gen_order_bitlen)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

111

PARAM_BUF_LEN(in_str_params->cofactor)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

113

(u16)(tmp_cofactor.wlen * WORD_BYTES)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

114

ret = nn_copy(&(out_params->ec_gen_cofactor), &tmp_cofactor); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

119

PARAM_BUF_LEN(in_str_params->curve_order)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

122

ret = ec_shortw_crv_init(&(out_params->ec_curve), &tmp_a, &tmp_b, &tmp_curve_order); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

127

PARAM_BUF_LEN(in_str_params->gx)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

130

PARAM_BUF_LEN(in_str_params->gy)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

133

PARAM_BUF_LEN(in_str_params->gz)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

136

&tmp_gx, &tmp_gy, &tmp_gz); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

142

PARAM_BUF_LEN(in_str_params->alpha_montgomery)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

145

PARAM_BUF_LEN(in_str_params->gamma_montgomery)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

149

PARAM_BUF_LEN(in_str_params->alpha_edwards)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

154

ret = local_memset(out_params->curve_oid, 0, MAX_CURVE_OID_LEN); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

157

in_str_params->oid->buflen); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

161

ret = local_memset(out_params->curve_name, 0, MAX_CURVE_NAME_LEN); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

164

in_str_params->name->buflen); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

169

&curve_type); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

40

ret = local_memset(out_params, 0, sizeof(ec_params)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

47

PARAM_BUF_LEN(in_str_params->p)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

51

PARAM_BUF_LEN(in_str_params->p_bitlen)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

54

PARAM_BUF_LEN(in_str_params->r)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

58

PARAM_BUF_LEN(in_str_params->r_square)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

62

PARAM_BUF_LEN(in_str_params->mpinv)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

66

PARAM_BUF_LEN(in_str_params->p_shift)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

70

PARAM_BUF_LEN(in_str_params->p_normalized)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

74

PARAM_BUF_LEN(in_str_params->p_reciprocal)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

81

&tmp_p_normalized, tmp_p_reciprocal.val[0]); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

89

PARAM_BUF_LEN(in_str_params->a)); EG(ret, err);

crypto/libecc/src/curves/ec_params.c

92

PARAM_BUF_LEN(in_str_params->b)); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

47

ret = nn_check_initialized(order); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

48

ret = fp_check_initialized(a); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

49

ret = fp_check_initialized(b); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

54

ret = fp_init(&tmp, a->ctx); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

55

ret = fp_init(&tmp2, a->ctx); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

56

ret = fp_sqr(&tmp, a); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

57

ret = fp_mul(&tmp, &tmp, a); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

58

ret = fp_set_word_value(&tmp2, WORD(4)); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

59

ret = fp_mul(&tmp, &tmp, &tmp2); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

61

ret = fp_set_word_value(&tmp2, WORD(27)); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

62

ret = fp_mul(&tmp2, &tmp2, b); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

63

ret = fp_mul(&tmp2, &tmp2, b); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

65

ret = fp_add(&tmp, &tmp, &tmp2); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

66

ret = fp_iszero(&tmp, &iszero); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

69

ret = fp_init(&(crv->a), a->ctx); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

70

ret = fp_init(&(crv->b), b->ctx); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

71

ret = fp_init(&(crv->a_monty), a->ctx); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

73

ret = fp_copy(&(crv->a), a); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

74

ret = fp_copy(&(crv->b), b); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

75

ret = fp_redcify(&(crv->a_monty), a); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

77

ret = nn_copy(&(crv->order), order); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

80

ret = fp_init(&(crv->b3), b->ctx); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

81

ret = fp_init(&(crv->b_monty), b->ctx); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

82

ret = fp_init(&(crv->b3_monty), b->ctx); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

84

ret = fp_add(&(crv->b3), b, b); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

85

ret = fp_add(&(crv->b3), &(crv->b3), b); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

86

ret = fp_redcify(&(crv->b_monty), b); EG(ret, err);

crypto/libecc/src/curves/ec_shortw.c

87

ret = fp_redcify(&(crv->b3_monty), &(crv->b3)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1000

ret = fp_add_monty(&t5, &in2->X, &in2->Z); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1002

ret = fp_mul_monty(&t4, &t4, &t5); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1003

ret = fp_add_monty(&t5, &t0, &t2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1004

ret = fp_sub_monty(&t4, &t4, &t5); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1005

ret = fp_add_monty(&t5, &in1->Y, &in1->Z); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1006

ret = fp_add_monty(&out->X, &in2->Y, &in2->Z); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1008

ret = fp_mul_monty(&t5, &t5, &out->X); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1009

ret = fp_add_monty(&out->X, &t1, &t2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1010

ret = fp_sub_monty(&t5, &t5, &out->X); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1011

ret = fp_mul_monty(&out->Z, &in1->crv->a_monty, &t4); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1012

ret = fp_mul_monty(&out->X, &in1->crv->b3_monty, &t2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1014

ret = fp_add_monty(&out->Z, &out->X, &out->Z); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1015

ret = fp_sub_monty(&out->X, &t1, &out->Z); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1016

ret = fp_add_monty(&out->Z, &t1, &out->Z); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1017

ret = fp_mul_monty(&out->Y, &out->X, &out->Z); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1018

ret = fp_add_monty(&t1, &t0, &t0); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1020

ret = fp_add_monty(&t1, &t1, &t0); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1021

ret = fp_mul_monty(&t2, &in1->crv->a_monty, &t2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1022

ret = fp_mul_monty(&t4, &in1->crv->b3_monty, &t4); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1023

ret = fp_add_monty(&t1, &t1, &t2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1024

ret = fp_sub_monty(&t2, &t0, &t2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1026

ret = fp_mul_monty(&t2, &in1->crv->a_monty, &t2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1027

ret = fp_add_monty(&t4, &t4, &t2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1028

ret = fp_mul_monty(&t0, &t1, &t4); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1029

ret = fp_add_monty(&out->Y, &out->Y, &t0); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1030

ret = fp_mul_monty(&t0, &t5, &t4); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1032

ret = fp_mul_monty(&out->X, &t3, &out->X); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1033

ret = fp_sub_monty(&out->X, &out->X, &t0); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1034

ret = fp_mul_monty(&t0, &t3, &t1); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1035

ret = fp_mul_monty(&out->Z, &t5, &out->Z); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1058

ret = fp_iszero(&(out->Z), &cmp1); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1059

ret = fp_iszero(&(out->Y), &cmp2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1089

ret = prj_pt_iszero(in, &iszero); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1091

ret = prj_pt_init(out, in->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1097

ret = __prj_pt_dbl_monty_cf(out, in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1115

ret = _prj_pt_dbl_monty(&out_cpy, val); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

113

ret = prj_pt_check_initialized(in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1136

ret = prj_pt_check_initialized(in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1186

ret = _prj_pt_add_monty(&out_cpy, in1, in2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1187

ret = prj_pt_copy(out, &out_cpy); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1208

ret = prj_pt_check_initialized(in1); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1209

ret = prj_pt_check_initialized(in2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1276

ret = prj_pt_init(out, in->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1279

ret = fp_get_random(&(out->Z), in->X.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

128

ret = prj_pt_check_initialized(out); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1285

ret = fp_mul_monty(&(out->X), &(in->X), &(out->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1286

ret = fp_mul_monty(&(out->Y), &(in->Y), &(out->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

130

ret = fp_zero(&(out->X)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

131

ret = fp_one(&(out->Y)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1338

ret = nn_sqr(&curve_order_square, curve_order); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1340

ret = nn_cmp(m, curve_order, &cmp); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1345

ret = nn_add(&m_msb_fixed, m, curve_order); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1346

ret = nn_bitlen(&m_msb_fixed, &msb_bit_len); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1347

ret = nn_bitlen(curve_order, &order_bitlen); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1349

&m_msb_fixed, curve_order); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1351

ret = nn_cmp(m, &curve_order_square, &cmp); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1356

ret = nn_add(&m_msb_fixed, m, &curve_order_square); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1357

ret = nn_bitlen(&m_msb_fixed, &msb_bit_len); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1358

ret = nn_bitlen(&curve_order_square, &curve_order_square_bitlen); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1360

&m_msb_fixed, &m_msb_fixed, &curve_order_square); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1363

ret = nn_copy(&m_msb_fixed, m); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1366

ret = nn_bitlen(&m_msb_fixed, &mlen); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1376

ret = nn_get_random_len(&r, m_msb_fixed.wlen * WORD_BYTES); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1378

ret = nn_getbit(&r, mlen, &rbit); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1381

ret = prj_pt_init(&T[0], in->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1382

ret = prj_pt_init(&T[1], in->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1389

ret = _blind_projective_point(&T[2], in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1392

ret = prj_pt_copy(&T[rbit], &T[2]); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1399

ret = nn_getbit(&r, mlen, &rbit_next); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1402

ret = nn_getbit(&m_msb_fixed, mlen, &mbit); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1423

ret = nn_copy(&(T[rbit_next].X.fp_val), &(T[mbit ^ rbit].X.fp_val)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1424

ret = nn_copy(&(T[rbit_next].Y.fp_val), &(T[mbit ^ rbit].Y.fp_val)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1425

ret = nn_copy(&(T[rbit_next].Z.fp_val), &(T[mbit ^ rbit].Z.fp_val)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1431

ret = prj_pt_copy(out, &T[rbit]); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1464

ret = _blind_projective_point(out, in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1485

ret = nn_sqr(&curve_order_square, curve_order); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

1487

ret = nn_cmp(m, curve_order, &cmp); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

1492

ret = nn_add(&m_msb_fixed, m, curve_order); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

1493

ret = nn_bitlen(&m_msb_fixed, &msb_bit_len); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

1494

ret = nn_bitlen(curve_order, &order_bitlen); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

1496

&m_msb_fixed, curve_order); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

1498

ret = nn_cmp(m, &curve_order_square, &cmp); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

1503

ret = nn_add(&m_msb_fixed, m, &curve_order_square); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

1504

ret = nn_bitlen(&m_msb_fixed, &msb_bit_len); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

1505

ret = nn_bitlen(&curve_order_square, &curve_order_square_bitlen); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

1507

&m_msb_fixed, &m_msb_fixed, &curve_order_square); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

1510

ret = nn_copy(&m_msb_fixed, m); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

1514

nn_uninit(&curve_order_square); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1517

ret = nn_bitlen(&m_msb_fixed, &mlen); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1526

ret = prj_pt_init(&dbl, in->crv); EG(ret, err2);

crypto/libecc/src/curves/prj_pt.c

1532

ret = nn_getbit(&m_msb_fixed, mlen, &mbit); EG(ret, err2);

crypto/libecc/src/curves/prj_pt.c

1546

ret = nn_cnd_swap(!mbit, &(out->X.fp_val), &(dbl.X.fp_val)); EG(ret, err2);

crypto/libecc/src/curves/prj_pt.c

1547

ret = nn_cnd_swap(!mbit, &(out->Y.fp_val), &(dbl.Y.fp_val)); EG(ret, err2);

crypto/libecc/src/curves/prj_pt.c

1548

ret = nn_cnd_swap(!mbit, &(out->Z.fp_val), &(dbl.Z.fp_val)); EG(ret, err2);

crypto/libecc/src/curves/prj_pt.c

1551

prj_pt_uninit(&dbl); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

157

ret = prj_pt_check_initialized(in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

158

ret = ec_shortw_crv_check_initialized(in->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1591

ret = nn_sqr(&curve_order_square, curve_order); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1594

ret = nn_cmp(m, curve_order, &cmp); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1599

ret = nn_add(&m_msb_fixed, m, curve_order); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1600

ret = nn_bitlen(&m_msb_fixed, &msb_bit_len); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1601

ret = nn_bitlen(curve_order, &order_bitlen); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1603

&m_msb_fixed, curve_order); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1605

ret = nn_cmp(m, &curve_order_square, &cmp); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

161

ret = fp_init(&X, in->X.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1610

ret = nn_add(&m_msb_fixed, m, &curve_order_square); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1611

ret = nn_bitlen(&m_msb_fixed, &msb_bit_len); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1612

ret = nn_bitlen(&curve_order_square, &curve_order_square_bitlen); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1614

&m_msb_fixed, &m_msb_fixed, &curve_order_square); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1617

ret = nn_copy(&m_msb_fixed, m); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

162

ret = fp_init(&Y, in->X.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1621

ret = nn_bitlen(&m_msb_fixed, &mlen); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

163

ret = fp_init(&Z, in->X.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1631

ret = nn_get_random_len(&r, (u16)(m_msb_fixed.wlen * WORD_BYTES)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1633

ret = nn_getbit(&r, mlen, &rbit); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1636

ret = prj_pt_init(&T[0], in->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1637

ret = prj_pt_init(&T[1], in->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1638

ret = prj_pt_init(&T[2], in->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1645

ret = _blind_projective_point(&T[rbit], in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

166

ret = fp_sqr(&X, &(in->X)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1664

ret = nn_getbit(&r, mlen, &rbit_next); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1667

ret = nn_getbit(&m_msb_fixed, mlen, &mbit); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

167

ret = fp_mul(&X, &X, &(in->X)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

168

ret = fp_mul(&Z, &(in->X), &(in->crv->a)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1688

ret = nn_copy(&(T[0].X.fp_val), &(T[2-(mbit ^ rbit_next)].X.fp_val)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1689

ret = nn_copy(&(T[0].Y.fp_val), &(T[2-(mbit ^ rbit_next)].Y.fp_val)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

169

ret = fp_mul(&Y, &(in->crv->b), &(in->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1690

ret = nn_copy(&(T[0].Z.fp_val), &(T[2-(mbit ^ rbit_next)].Z.fp_val)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1696

ret = nn_copy(&(T[1].X.fp_val), &(T[1+(mbit ^ rbit_next)].X.fp_val)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1697

ret = nn_copy(&(T[1].Y.fp_val), &(T[1+(mbit ^ rbit_next)].Y.fp_val)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1698

ret = nn_copy(&(T[1].Z.fp_val), &(T[1+(mbit ^ rbit_next)].Z.fp_val)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

170

ret = fp_add(&Z, &Z, &Y); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1704

ret = prj_pt_copy(out, &T[rbit]); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

171

ret = fp_mul(&Z, &Z, &(in->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

172

ret = fp_mul(&Z, &Z, &(in->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

173

ret = fp_add(&X, &X, &Z); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1744

ret = prj_pt_init(&out_cpy, in->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1745

ret = _prj_pt_mul_ltr_monty(&out_cpy, m, in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

176

ret = fp_sqr(&Y, &(in->Y)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1763

ret = prj_pt_check_initialized(in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1764

ret = nn_check_initialized(m); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

177

ret = fp_mul(&Y, &Y, &(in->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1770

ret = _prj_pt_mul_ltr_monty_aliased(out, m, in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1772

ret = _prj_pt_mul_ltr_monty(out, m, in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1797

ret = prj_pt_check_initialized(in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

180

ret = fp_cmp(&X, &Y, &cmp); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1801

ret = nn_init(&b, 0); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1803

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1805

ret = nn_mul(&b, &b, q); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1806

ret = nn_add(&b, &b, m); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1841

ret = prj_pt_check_initialized(public_in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1842

ret = nn_check_initialized(scalar); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1850

ret = nn_iszero(scalar, &iszero); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1853

ret = prj_pt_zero(out); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1857

ret = nn_bitlen(scalar, &explen); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1861

ret = prj_pt_copy(out, public_in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1865

ret = nn_getbit(scalar, explen, &expbit); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1866

ret = prj_pt_dbl(out, out); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1868

ret = prj_pt_add(out, out, public_in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1891

ret = prj_pt_copy(&A, public_in); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

1916

ret = prj_pt_check_initialized(in_shortw); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1917

ret = nn_check_initialized(in_isorder); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1923

ret = _prj_pt_unprotected_mult(&res, in_isorder, in_shortw); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1929

ret = prj_pt_mul_blind(&res, in_isorder, in_shortw); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1933

ret = prj_pt_iszero(&res, &iszero); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1963

ret = aff_pt_edwards_check_initialized(in_edwards); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1964

ret = curve_edwards_shortw_check(in_edwards->crv, shortw_crv, alpha_edwards); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1967

ret = prj_pt_init(out_shortw, shortw_crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1969

ret = fp_init(&one, in_edwards->x.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1970

ret = fp_one(&one); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1976

ret = fp_iszero(&(in_edwards->x), &iszero); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1977

ret = fp_cmp(&(in_edwards->y), &one, &cmp); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1979

ret = prj_pt_zero(out_shortw); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

1985

ret = aff_pt_edwards_to_shortw(in_edwards, shortw_crv, &out_shortw_aff, alpha_edwards); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

200

ret = prj_pt_check_initialized(in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

2014

ret = prj_pt_check_initialized(in_shortw); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

2015

ret = curve_edwards_shortw_check(edwards_crv, in_shortw->crv, alpha_edwards); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

2018

ret = aff_pt_init(&in_shortw_aff, in_shortw->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

202

ret = prj_pt_init(out, in->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

2024

ret = prj_pt_iszero(in_shortw, &iszero); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

2029

ret = fp_init(&zero, in_shortw->X.ctx); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

2030

ret = fp_init(&one, in_shortw->X.ctx); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

2032

ret = fp_zero(&zero); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

2033

ret = fp_one(&one); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

204

ret = fp_copy(&(out->X), &(in->X)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

2045

ret = prj_pt_to_aff(&in_shortw_aff, in_shortw); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

205

ret = fp_copy(&(out->Y), &(in->Y)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

2069

ret = aff_pt_montgomery_check_initialized(in_montgomery); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

2070

ret = curve_montgomery_shortw_check(in_montgomery->crv, shortw_crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

2073

ret = prj_pt_init(out_shortw, shortw_crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

2076

ret = aff_pt_montgomery_to_shortw(in_montgomery, shortw_crv, &out_shortw_aff); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

2098

ret = prj_pt_check_initialized(in_shortw); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

2099

ret = curve_montgomery_shortw_check(montgomery_crv, in_shortw->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

2102

ret = aff_pt_init(&in_shortw_aff, in_shortw->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

2105

ret = prj_pt_to_aff(&in_shortw_aff, in_shortw); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

222

ret = prj_pt_check_initialized(in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

224

ret = prj_pt_iszero(in, &iszero); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

227

ret = aff_pt_init(out, in->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

229

ret = fp_inv(&(out->x), &(in->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

230

ret = fp_mul(&(out->y), &(in->Y), &(out->x)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

245

ret = prj_pt_check_initialized(in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

246

ret = prj_pt_iszero(in, &iszero); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

254

ret = fp_init(&tmp, (in->Z).ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

255

ret = fp_inv(&tmp, &(in->Z)); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

256

ret = fp_mul(&(out->Y), &(in->Y), &tmp); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

257

ret = fp_mul(&(out->X), &(in->X), &tmp); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

258

ret = fp_one(&(out->Z)); EG(ret, err1);

crypto/libecc/src/curves/prj_pt.c

260

fp_uninit(&tmp); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

263

ret = prj_pt_init(out, in->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

264

ret = fp_inv(&(out->X), &(in->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

265

ret = fp_mul(&(out->Y), &(in->Y), &(out->X)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

266

ret = fp_mul(&(out->X), &(in->X), &(out->X)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

267

ret = fp_one(&(out->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

283

ret = aff_pt_check_initialized(in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

286

ret = aff_pt_is_on_curve(in, &on_curve); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

289

ret = prj_pt_init(out, in->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

290

ret = fp_copy(&(out->X), &(in->x)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

291

ret = fp_copy(&(out->Y), &(in->y)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

310

ret = prj_pt_check_initialized(in1); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

311

ret = prj_pt_check_initialized(in2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

315

ret = fp_init(&X1, (in1->X).ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

316

ret = fp_init(&X2, (in2->X).ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

317

ret = fp_init(&Y1, (in1->Y).ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

318

ret = fp_init(&Y2, (in2->Y).ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

325

ret = fp_mul_monty(&X1, &(in1->X), &(in2->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

326

ret = fp_mul_monty(&X2, &(in2->X), &(in1->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

327

ret = fp_mul_monty(&Y1, &(in1->Y), &(in2->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

328

ret = fp_mul_monty(&Y2, &(in2->Y), &(in1->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

330

ret = fp_mul_monty(&X1, &(in1->X), &(in2->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

331

ret = fp_mul_monty(&X2, &(in2->X), &(in1->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

332

ret = fp_mul_monty(&Y1, &(in1->Y), &(in2->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

333

ret = fp_mul_monty(&Y2, &(in2->Y), &(in1->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

334

ret = fp_cmp(&X1, &X2, &x_cmp); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

365

ret = fp_init(&X1, (in1->X).ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

366

ret = fp_init(&X2, (in2->X).ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

367

ret = fp_mul_monty(&X1, &(in1->X), &(in2->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

368

ret = fp_mul_monty(&X2, &(in2->X), &(in1->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

393

ret = fp_init(&Y1, (in1->Y).ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

394

ret = fp_init(&Y2, (in2->Y).ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

395

ret = fp_mul_monty(&Y1, &(in1->Y), &(in2->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

396

ret = fp_mul_monty(&Y2, &(in2->Y), &(in1->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

416

ret = prj_pt_check_initialized(in1); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

417

ret = prj_pt_check_initialized(in2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

421

ret = _prj_pt_eq_or_opp_X(in1, in2, &cmp); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

439

ret = prj_pt_check_initialized(in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

442

ret = prj_pt_init(out, in->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

443

ret = prj_pt_copy(out, in); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

470

ret = ec_shortw_crv_check_initialized(crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

477

ret = fp_init_from_buf(&(pt->X), ctx, pt_buf, coord_len); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

478

ret = fp_init_from_buf(&(pt->Y), ctx, pt_buf + coord_len, coord_len); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

479

ret = fp_init_from_buf(&(pt->Z), ctx, pt_buf + (2 * coord_len), coord_len); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

490

ret = prj_pt_is_on_curve(pt, &on_curve); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

51

ret = ec_shortw_crv_check_initialized(curve); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

519

ret = ec_shortw_crv_check_initialized(crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

526

ret = fp_init_from_buf(&(pt->X), ctx, pt_buf, coord_len); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

527

ret = fp_init_from_buf(&(pt->Y), ctx, pt_buf + coord_len, coord_len); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

529

ret = fp_init(&(pt->Z), ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

530

ret = fp_one(&(pt->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

541

ret = prj_pt_is_on_curve(pt, &on_curve); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

55

ret = fp_init(&(in->X), curve->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

56

ret = fp_init(&(in->Y), curve->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

568

ret = prj_pt_check_initialized(pt); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

57

ret = fp_init(&(in->Z), curve->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

573

ret = prj_pt_is_on_curve(pt, &on_curve); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

581

ret = fp_export_to_buf(pt_buf, coord_len, &(pt->X)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

582

ret = fp_export_to_buf(pt_buf + coord_len, coord_len, &(pt->Y)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

606

ret = prj_pt_check_initialized(pt); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

611

ret = prj_pt_is_on_curve(pt, &on_curve); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

615

ret = prj_pt_to_aff(&tmp_aff, pt); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

647

ret = prj_pt_init(out, in->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

649

ret = fp_init(&XX, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

650

ret = fp_init(&ZZ, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

651

ret = fp_init(&w, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

652

ret = fp_init(&s, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

653

ret = fp_init(&ss, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

654

ret = fp_init(&sss, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

655

ret = fp_init(&R, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

656

ret = fp_init(&RR, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

657

ret = fp_init(&B, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

658

ret = fp_init(&h, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

661

ret = fp_sqr_monty(&XX, &(in->X)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

664

ret = fp_sqr_monty(&ZZ, &(in->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

667

ret = fp_mul_monty(&w, &(in->crv->a_monty), &ZZ); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

668

ret = fp_add_monty(&w, &w, &XX); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

669

ret = fp_add_monty(&w, &w, &XX); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

670

ret = fp_add_monty(&w, &w, &XX); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

673

ret = fp_mul_monty(&s, &(in->Y), &(in->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

674

ret = fp_add_monty(&s, &s, &s); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

677

ret = fp_sqr_monty(&ss, &s); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

680

ret = fp_mul_monty(&sss, &s, &ss); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

683

ret = fp_mul_monty(&R, &(in->Y), &s); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

686

ret = fp_sqr_monty(&RR, &R); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

689

ret = fp_add_monty(&R, &R, &(in->X)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

690

ret = fp_sqr_monty(&B, &R); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

691

ret = fp_sub_monty(&B, &B, &XX); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

692

ret = fp_sub_monty(&B, &B, &RR); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

695

ret = fp_sqr_monty(&h, &w); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

696

ret = fp_sub_monty(&h, &h, &B); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

697

ret = fp_sub_monty(&h, &h, &B); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

700

ret = fp_mul_monty(&(out->X), &h, &s); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

703

ret = fp_sub_monty(&B, &B, &h); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

704

ret = fp_mul_monty(&(out->Y), &w, &B); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

705

ret = fp_sub_monty(&(out->Y), &(out->Y), &RR); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

706

ret = fp_sub_monty(&(out->Y), &(out->Y), &RR); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

747

ret = prj_pt_init(out, in1->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

749

ret = fp_init(&Y1Z2, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

75

ret = prj_pt_init(in, curve); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

750

ret = fp_init(&X1Z2, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

751

ret = fp_init(&Z1Z2, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

752

ret = fp_init(&u, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

753

ret = fp_init(&uu, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

754

ret = fp_init(&v, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

755

ret = fp_init(&vv, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

756

ret = fp_init(&vvv, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

757

ret = fp_init(&R, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

758

ret = fp_init(&A, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

76

ret = fp_copy(&(in->X), xcoord); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

761

ret = fp_mul_monty(&Y1Z2, &(in1->Y), &(in2->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

764

ret = fp_mul_monty(&X1Z2, &(in1->X), &(in2->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

767

ret = fp_mul_monty(&Z1Z2, &(in1->Z), &(in2->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

77

ret = fp_copy(&(in->Y), ycoord); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

770

ret = fp_mul_monty(&u, &(in2->Y), &(in1->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

771

ret = fp_sub_monty(&u, &u, &Y1Z2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

774

ret = fp_sqr_monty(&uu, &u); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

777

ret = fp_mul_monty(&v, &(in2->X), &(in1->Z)); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

778

ret = fp_sub_monty(&v, &v, &X1Z2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

781

ret = fp_sqr_monty(&vv, &v); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

784

ret = fp_mul_monty(&vvv, &v, &vv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

787

ret = fp_mul_monty(&R, &vv, &X1Z2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

790

ret = fp_mul_monty(&A, &uu, &Z1Z2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

791

ret = fp_sub_monty(&A, &A, &vvv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

792

ret = fp_sub_monty(&A, &A, &R); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

793

ret = fp_sub_monty(&A, &A, &R); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

796

ret = fp_mul_monty(&(out->X), &v, &A); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

799

ret = fp_sub_monty(&R, &R, &A); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

800

ret = fp_mul_monty(&(out->Y), &u, &R); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

801

ret = fp_mul_monty(&R, &vvv, &Y1Z2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

802

ret = fp_sub_monty(&(out->Y), &(out->Y), &R); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

830

ret = prj_pt_check_initialized(in1); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

831

ret = prj_pt_check_initialized(in2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

834

ret = prj_pt_iszero(in1, &iszero); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

837

ret = prj_pt_init(out, in2->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

838

ret = prj_pt_copy(out, in2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

841

ret = prj_pt_iszero(in2, &iszero); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

844

ret = prj_pt_init(out, in1->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

845

ret = prj_pt_copy(out, in1); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

856

ret = prj_pt_eq_or_opp(in1, in2, &eq_or_opp); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

859

ret = prj_pt_cmp(in1, in2, &cmp); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

862

ret = __prj_pt_dbl_monty_no_cf(out, in1); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

865

ret = prj_pt_init(out, in1->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

866

ret = prj_pt_zero(out); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

874

ret = ___prj_pt_add_monty_no_cf(out, in1, in2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

898

ret = prj_pt_init(out, in->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

900

ret = fp_init(&t0, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

901

ret = fp_init(&t1, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

902

ret = fp_init(&t2, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

903

ret = fp_init(&t3, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

905

ret = fp_mul_monty(&t0, &in->X, &in->X); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

906

ret = fp_mul_monty(&t1, &in->Y, &in->Y); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

907

ret = fp_mul_monty(&t2, &in->Z, &in->Z); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

908

ret = fp_mul_monty(&t3, &in->X, &in->Y); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

909

ret = fp_add_monty(&t3, &t3, &t3); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

911

ret = fp_mul_monty(&out->Z, &in->X, &in->Z); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

912

ret = fp_add_monty(&out->Z, &out->Z, &out->Z); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

913

ret = fp_mul_monty(&out->X, &in->crv->a_monty, &out->Z); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

914

ret = fp_mul_monty(&out->Y, &in->crv->b3_monty, &t2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

915

ret = fp_add_monty(&out->Y, &out->X, &out->Y); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

917

ret = fp_sub_monty(&out->X, &t1, &out->Y); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

918

ret = fp_add_monty(&out->Y, &t1, &out->Y); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

919

ret = fp_mul_monty(&out->Y, &out->X, &out->Y); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

920

ret = fp_mul_monty(&out->X, &t3, &out->X); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

921

ret = fp_mul_monty(&out->Z, &in->crv->b3_monty, &out->Z); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

923

ret = fp_mul_monty(&t2, &in->crv->a_monty, &t2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

924

ret = fp_sub_monty(&t3, &t0, &t2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

925

ret = fp_mul_monty(&t3, &in->crv->a_monty, &t3); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

926

ret = fp_add_monty(&t3, &t3, &out->Z); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

927

ret = fp_add_monty(&out->Z, &t0, &t0); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

929

ret = fp_add_monty(&t0, &out->Z, &t0); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

930

ret = fp_add_monty(&t0, &t0, &t2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

931

ret = fp_mul_monty(&t0, &t0, &t3); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

932

ret = fp_add_monty(&out->Y, &out->Y, &t0); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

933

ret = fp_mul_monty(&t2, &in->Y, &in->Z); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

935

ret = fp_add_monty(&t2, &t2, &t2); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

936

ret = fp_mul_monty(&t0, &t2, &t3); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

937

ret = fp_sub_monty(&out->X, &out->X, &t0); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

938

ret = fp_mul_monty(&out->Z, &t2, &t1); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

939

ret = fp_add_monty(&out->Z, &out->Z, &out->Z); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

981

ret = prj_pt_init(out, in1->crv); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

983

ret = fp_init(&t0, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

984

ret = fp_init(&t1, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

985

ret = fp_init(&t2, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

986

ret = fp_init(&t3, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

987

ret = fp_init(&t4, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

988

ret = fp_init(&t5, out->crv->a.ctx); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

990

ret = fp_mul_monty(&t0, &in1->X, &in2->X); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

991

ret = fp_mul_monty(&t1, &in1->Y, &in2->Y); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

992

ret = fp_mul_monty(&t2, &in1->Z, &in2->Z); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

993

ret = fp_add_monty(&t3, &in1->X, &in1->Y); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

994

ret = fp_add_monty(&t4, &in2->X, &in2->Y); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

996

ret = fp_mul_monty(&t3, &t3, &t4); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

997

ret = fp_add_monty(&t4, &t0, &t1); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

998

ret = fp_sub_monty(&t3, &t3, &t4); EG(ret, err);

crypto/libecc/src/curves/prj_pt.c

999

ret = fp_add_monty(&t4, &in1->X, &in1->Z); EG(ret, err);

crypto/libecc/src/ecdh/ecccdh.c

103

ret = generic_gen_priv_key(&(kp->priv_key)); EG(ret, err);

crypto/libecc/src/ecdh/ecccdh.c

128

ret = ec_priv_key_import_from_buf(&(kp->priv_key), params, priv_key_buf, priv_key_buf_len, ECCCDH); EG(ret, err);

crypto/libecc/src/ecdh/ecccdh.c

145

ret = pub_key_check_initialized_and_type(our_pub_key, ECCCDH); EG(ret, err);

crypto/libecc/src/ecdh/ecccdh.c

148

ret = prj_pt_iszero(&(our_pub_key->y), &iszero); EG(ret, err);

crypto/libecc/src/ecdh/ecccdh.c

178

ret = priv_key_check_initialized_and_type(our_priv_key, ECCCDH); EG(ret, err);

crypto/libecc/src/ecdh/ecccdh.c

184

ret = ec_pub_key_import_from_aff_buf(&peer_pub_key, our_priv_key->params, peer_pub_key_buf, peer_pub_key_buf_len, ECCCDH); EG(ret, err);

crypto/libecc/src/ecdh/ecccdh.c

188

ret = nn_isone(cofactor, &isone); EG(ret, err);

crypto/libecc/src/ecdh/ecccdh.c

194

ret = _prj_pt_unprotected_mult(Q, cofactor, Q); EG(ret, err);

crypto/libecc/src/ecdh/ecccdh.c

202

ret = prj_pt_iszero(Q, &iszero); EG(ret, err);

crypto/libecc/src/ecdh/ecccdh.c

207

ret = prj_pt_mul_blind(Q, &(our_priv_key->x), Q); EG(ret, err);

crypto/libecc/src/ecdh/ecccdh.c

209

ret = prj_pt_mul(Q, &(our_priv_key->x), Q); EG(ret, err);

crypto/libecc/src/ecdh/ecccdh.c

216

ret = prj_pt_iszero(Q, &iszero); EG(ret, err);

crypto/libecc/src/ecdh/ecccdh.c

220

ret = prj_pt_unique(Q, Q); EG(ret, err);

crypto/libecc/src/ecdh/ecccdh.c

222

ret = ecccdh_shared_secret_size(our_priv_key->params, &expected_shared_secret_len); EG(ret, err);

crypto/libecc/src/ecdh/ecccdh.c

69

ret = local_memset(out_pub, 0, sizeof(ec_pub_key)); EG(ret, err);

crypto/libecc/src/ecdh/ecccdh.c

71

ret = priv_key_check_initialized_and_type(in_priv, ECCCDH); EG(ret, err);

crypto/libecc/src/ecdh/ecccdh.c

80

ret = prj_pt_mul_blind(&(out_pub->y), &(in_priv->x), G); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

178

ret = decode_scalar(k_, k, len); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

179

ret = decode_u_coordinate(u_, u, len); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

185

ret = import_params(&shortw_curve_params, &wei25519_str_params); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

191

ret = import_params(&shortw_curve_params, &wei448_str_params); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

212

gamma_montgomery); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

215

ret = nn_init_from_buf(v_coord_nn, u_, len); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

219

ret = nn_cmp(v_coord_nn, &(montgomery_curve.A.ctx->p), &cmp); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

222

ret = fp_init(u_coord, montgomery_curve.A.ctx); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

223

ret = fp_set_nn(u_coord, v_coord_nn); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

226

ret = compute_v_from_u(u_coord, v_coord, &montgomery_curve); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

251

ret = aff_pt_montgomery_init_from_coords(&_Tmp, &montgomery_curve, u_coord, v_coord); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

253

ret = aff_pt_montgomery_to_prj_pt_shortw(&_Tmp, shortw_curve, &Q); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

259

ret = check_prj_pt_order(&Q, cofactor, PUBLIC_PT, &cmp); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

263

ret = nn_init_from_buf(&scalar, k_, len); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

266

ret = prj_pt_mul_blind(&Q, &scalar, &Q); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

268

ret = prj_pt_mul(&Q, &scalar, &Q); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

272

ret = prj_pt_shortw_to_aff_pt_montgomery(&Q, &montgomery_curve, &_Tmp); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

275

ret = fp_iszero(&(_Tmp.u), &iszero); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

279

ret = fp_export_to_buf(u_, len, &(_Tmp.u)); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

339

ret = local_memset(u, 0, sizeof(u)); EG(ret, err);

crypto/libecc/src/ecdh/x25519_448.c

347

ret = local_memset(u, 0, sizeof(u)); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

135

ret = local_strnlen((const char *)curve_name, MAX_CURVE_NAME_LEN, &len); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

139

(u8)len, &the_curve_const_parameters); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

150

ret = import_params(&curve_params, the_curve_const_parameters); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

152

ret = get_random_point_on_curve(&curve_params, &A); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

153

ret = get_random_point_on_curve(&curve_params, &B); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

159

ret = prj_pt_add(&C, &A, &B); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

165

ret = prj_pt_to_aff(&T, &C); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

166

ret = prj_pt_is_on_curve(&C, &is_oncurve); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

173

ret = aff_pt_is_on_curve(&T, &is_oncurve); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

183

ret = prj_pt_dbl(&C, &A); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

188

ret = prj_pt_to_aff(&T, &C); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

189

ret = prj_pt_is_on_curve(&C, &is_oncurve); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

196

ret = aff_pt_is_on_curve(&T, &is_oncurve); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

210

ret = prj_pt_add(&C, &A, &B); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

211

ret = prj_pt_dbl(&D, &A); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

212

ret = nn_isone(&(curve_params.ec_gen_cofactor), &isone); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

214

ret = prj_pt_mul(&TMP, &(curve_params.ec_gen_order), &A); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

215

ret = prj_pt_iszero(&TMP, &iszero); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

222

ret = prj_pt_mul_blind(&TMP, &(curve_params.ec_gen_order), &A); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

223

ret = prj_pt_iszero(&TMP, &iszero); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

230

ret = prj_pt_mul(&TMP, &(curve_params.ec_gen_order), &B); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

231

ret = prj_pt_iszero(&TMP, &iszero); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

238

ret = prj_pt_mul_blind(&TMP, &(curve_params.ec_gen_order), &B); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

239

ret = prj_pt_iszero(&TMP, &iszero); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

246

ret = prj_pt_mul(&TMP, &(curve_params.ec_gen_order), &C); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

247

ret = prj_pt_iszero(&TMP, &iszero); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

254

ret = prj_pt_mul_blind(&TMP, &(curve_params.ec_gen_order), &C); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

255

ret = prj_pt_iszero(&TMP, &iszero); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

262

ret = prj_pt_mul(&TMP, &(curve_params.ec_gen_order), &D); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

263

ret = prj_pt_iszero(&TMP, &iszero); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

270

ret = prj_pt_mul_blind(&TMP, &(curve_params.ec_gen_order), &D); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

271

ret = prj_pt_iszero(&TMP, &iszero); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

283

ret = nn_init(&nn_k, 0); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

292

ret = nn_get_random_mod(&nn_k, &(curve_params.ec_gen_order)); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

294

ret = prj_pt_mul(&TMP, &nn_k, &A); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

295

ret = prj_pt_to_aff(&T, &TMP); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

296

ret = prj_pt_is_on_curve(&TMP, &is_oncurve); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

304

ret = aff_pt_is_on_curve(&T, &is_oncurve); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

329

ret = nn_get_random_mod(&nn_k, &(curve_params.ec_gen_order)); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

331

ret = prj_pt_mul_blind(&TMP, &nn_k, &A); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

332

ret = prj_pt_to_aff(&T, &TMP); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

333

ret = prj_pt_is_on_curve(&TMP, &is_oncurve); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

341

ret = aff_pt_is_on_curve(&T, &is_oncurve); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

57

ret = fp_init(&x, ctx); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

58

ret = fp_init(&y, ctx); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

59

ret = fp_init(&fp_tmp1, ctx); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

60

ret = fp_init(&fp_tmp2, ctx); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

62

ret = nn_init(&nn_tmp, 0); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

63

ret = nn_set_word_value(&nn_tmp, WORD(3)); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

66

ret = fp_get_random(&x, ctx); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

67

ret = fp_copy(&fp_tmp1, &x); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

68

ret = fp_copy(&fp_tmp2, &x); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

70

ret = fp_pow(&fp_tmp1, &fp_tmp1, &nn_tmp); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

71

ret = fp_mul(&fp_tmp2, &fp_tmp2, &(curve_params->ec_curve.a)); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

72

ret = fp_add(&fp_tmp1, &fp_tmp1, &fp_tmp2); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

73

ret = fp_add(&fp_tmp1, &fp_tmp1, &(curve_params->ec_curve.b)); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

81

ret = is_on_shortw_curve(&x, &y, &(curve_params->ec_curve), &is_oncurve); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

92

ret = fp_one(&fp_tmp1); EG(ret, err);

crypto/libecc/src/examples/basic/curve_basic_examples.c

94

&fp_tmp1); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

110

ret = are_equal(role, Alice, CHECK_SIZE, &check1); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

111

ret = are_equal(role, Bob, CHECK_SIZE, &check2); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

138

ret = local_strnlen((const char *)curve_name, MAX_CURVE_NAME_LEN, &len); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

142

(u8)len, &the_curve_const_parameters); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

151

ret = import_params(&curve_params, the_curve_const_parameters); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

154

ret = prj_pt_init(&Q, &(curve_params.ec_curve)); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

155

ret = are_equal(our_public_buffer, zero, sizeof(zero), &check1); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

168

ret = nn_init(d, 0); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

169

ret = nn_get_random_mod(d, &(curve_params.ec_gen_order)); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

172

ret = prj_pt_mul(&Q, d, &(curve_params.ec_gen)); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

180

(u32)(2 * BYTECEIL(curve_params.ec_fp.p_bitlen))); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

184

ret = are_equal(other_public_buffer, zero, sizeof(zero), &check1); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

201

&(curve_params.ec_curve)); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

203

ret = prj_pt_mul(&Q, d, &Q); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

208

ret = prj_pt_unique(&Q, &Q); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

211

ret = fp_init(x, &(curve_params.ec_fp)); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

212

ret = fp_copy(x, &(Q.X)); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

243

ret = local_memset(Alice_to_Bob, 0, sizeof(Alice_to_Bob)); EG(ret, err);

crypto/libecc/src/examples/basic/curve_ecdh.c

244

ret = local_memset(Bob_to_Alice, 0, sizeof(Bob_to_Alice)); EG(ret, err);

crypto/libecc/src/examples/basic/fp_square_residue.c

37

ret = nn_init(&p, 0); EG(ret, err);

crypto/libecc/src/examples/basic/fp_square_residue.c

44

(&p, (u16)((NN_MAX_BIT_LEN / 3) / 8)); EG(ret, err);

crypto/libecc/src/examples/basic/fp_square_residue.c

47

ret = nn_isone(&p, &isone); EG(ret, err);

crypto/libecc/src/examples/basic/fp_square_residue.c

53

ret = miller_rabin(&p, 100, &check); EG(ret, err);

crypto/libecc/src/examples/basic/fp_square_residue.c

60

ret = fp_ctx_init_from_p(&ctx, &p); EG(ret, err);

crypto/libecc/src/examples/basic/fp_square_residue.c

62

ret = fp_init(&x, &ctx); EG(ret, err);

crypto/libecc/src/examples/basic/fp_square_residue.c

63

ret = fp_init(&x_sqrt1, &ctx); EG(ret, err);

crypto/libecc/src/examples/basic/fp_square_residue.c

64

ret = fp_init(&x_sqrt2, &ctx); EG(ret, err);

crypto/libecc/src/examples/basic/fp_square_residue.c

67

ret = fp_get_random(&x, &ctx); EG(ret, err);

crypto/libecc/src/examples/basic/fp_square_residue.c

72

ret = fp_sqr(&x, &x); EG(ret, err);

crypto/libecc/src/examples/basic/fp_square_residue.c

80

ret = fp_sqr(&x_sqrt1, &x_sqrt1); EG(ret, err);

crypto/libecc/src/examples/basic/fp_square_residue.c

81

ret = fp_cmp(&x, &x_sqrt1, &cmp); EG(ret, err);

crypto/libecc/src/examples/basic/fp_square_residue.c

89

ret = fp_sqr(&x_sqrt2, &x_sqrt2); EG(ret, err);

crypto/libecc/src/examples/basic/fp_square_residue.c

90

ret = fp_cmp(&x, &x_sqrt2, &cmp); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

101

ret = nn_copy(&tmp, n); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

102

ret = nn_dec(&tmp, &tmp); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

103

ret = nn_cmp(&tmp, &two, &cmp); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

111

ret = nn_isodd(n, &isodd); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

120

ret = nn_zero(&s); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

121

ret = nn_copy(&r, n); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

122

ret = nn_dec(&r, &r); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

124

ret = nn_divrem(&q, &d, &r, &two); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

125

ret = nn_inc(&s, &s); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

126

ret = nn_copy(&r, &q); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

128

ret = nn_isodd(&r, &isodd); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

137

ret = nn_copy(&tmp, n); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

138

ret = nn_dec(&tmp, &tmp); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

139

ret = nn_zero(&a); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

140

ret = nn_cmp(&a, &two, &cmp); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

142

ret = nn_get_random_mod(&a, &tmp); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

143

ret = nn_cmp(&a, &two, &cmp); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

150

ret = nn_one(&y); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

151

ret = nn_bitlen(&r, &blen); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

154

ret = nn_getbit(&r, k, &bit); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

161

ret = nn_mul(&y, &y, &a); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

162

ret = nn_mod(&y, &y, n); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

165

ret = nn_sqr(&a, &a); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

166

ret = nn_mod(&a, &a, n); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

171

ret = nn_cmp(&y, &one, &cmp1); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

172

ret = nn_cmp(&y, &tmp, &cmp2); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

175

ret = nn_one(&j); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

177

ret = nn_cmp(&j, &s, &cmp1); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

178

ret = nn_cmp(&y, &tmp, &cmp2); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

183

ret = nn_sqr(&y, &y); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

184

ret = nn_mod(&y, &y, n); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

186

ret = nn_cmp(&y, &one, &cmp); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

193

ret = nn_inc(&j, &j); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

194

ret = nn_cmp(&j, &s, &cmp1); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

195

ret = nn_cmp(&y, &tmp, &cmp2); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

198

ret = nn_cmp(&y, &tmp, &cmp); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

55

ret = nn_check_initialized(n); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

60

ret = nn_init(&s, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

61

ret = nn_init(&q, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

62

ret = nn_init(&r, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

63

ret = nn_init(&d, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

64

ret = nn_init(&a, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

65

ret = nn_init(&y, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

66

ret = nn_init(&j, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

67

ret = nn_init(&one, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

68

ret = nn_init(&two, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

69

ret = nn_init(&tmp, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

75

ret = nn_one(&one); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

77

ret = nn_set_word_value(&two, WORD(2)); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

80

ret = nn_iszero(n, &iszero); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

87

ret = nn_cmp(n, &one, &cmp); EG(ret, err);

crypto/libecc/src/examples/basic/nn_miller_rabin.c

94

ret = nn_cmp(n, &two, &cmp); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

100

ret = nn_sub(&tmp, &a, &b); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

102

ret = nn_sub(&tmp, &b, &a); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

104

ret = nn_gcd(d, &tmp, n, &sign); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

105

ret = nn_cmp(d, n, &cmp1); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

106

ret = nn_cmp(d, &one, &cmp2); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

111

ret = nn_cmp(d, n, &cmp); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

144

ret = nn_check_initialized(in); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

150

ret = miller_rabin(in, 10, &check); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

158

ret = nn_init(&n, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

159

ret = nn_copy(&n, in); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

161

ret = nn_init(&(divisors[i]), 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

174

ret = nn_cmp(&(divisors[n_divisors_found]), &(divisors[i]), &cmp); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

181

ret = nn_init(&q, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

182

ret = nn_init(&r, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

189

ret = nn_divrem(&q, &r, &n, &(divisors[n_divisors_found])); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

194

ret = miller_rabin(&q, 10, &check); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

202

ret = nn_copy(&n, &q); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

241

ret = nn_init(&n, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

243

ret = nn_init_from_buf(&n, fermat_F5, sizeof(fermat_F5)); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

244

ret = find_divisors(&n); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

246

ret = nn_init_from_buf(&n, fermat_F6, sizeof(fermat_F6)); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

247

ret = find_divisors(&n); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

249

ret = nn_one(&n); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

251

ret = nn_lshift(&n, &n, 80); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

252

ret = nn_get_random_mod(&n, &n); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

253

ret = find_divisors(&n); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

66

ret = nn_init(&a, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

67

ret = nn_init(&b, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

68

ret = nn_init(&tmp, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

69

ret = nn_init(&one, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

70

ret = nn_init(&c_bignum, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

71

ret = nn_init(d, 0); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

76

ret = nn_zero(d); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

77

ret = nn_one(&one); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

79

ret = nn_set_word_value(&a, WORD(2)); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

80

ret = nn_set_word_value(&b, WORD(2)); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

81

ret = nn_set_word_value(&c_bignum, c); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

87

ret = nn_sqr(&a, &a); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

88

ret = nn_add(&a, &a, &c_bignum); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

89

ret = nn_mod(&a, &a, n); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

91

ret = nn_sqr(&b, &b); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

92

ret = nn_add(&b, &b, &c_bignum); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

93

ret = nn_mod(&b, &b, n); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

94

ret = nn_sqr(&b, &b); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

95

ret = nn_add(&b, &b, &c_bignum); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

96

ret = nn_mod(&b, &b, n); EG(ret, err);

crypto/libecc/src/examples/basic/nn_pollard_rho.c

98

ret = nn_cmp(&a, &b, &cmp); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

101

ret = local_memcpy(V, M, sizeof(V)); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

199

ret = gostr34_11_94_block_encryption(K[0], H[3], &S[0], sbox); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

201

ret = gostr34_11_94_block_encryption(K[1], H[2], &S[1], sbox); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

203

ret = gostr34_11_94_block_encryption(K[2], H[1], &S[2], sbox); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

205

ret = gostr34_11_94_block_encryption(K[3], H[0], &S[3], sbox); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

240

ret = local_memcpy(g, G, sizeof(gostr34_11_94_union)); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

262

ret = local_memcpy(H_, S, GOSTR34_11_94_STATE_SIZE * sizeof(u64)); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

264

ret = gostr34_11_94_state_psi(H_, H_); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

277

ret = gostr34_11_94_state_psi(H_, H_); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

291

ret = gostr34_11_94_state_psi(H_, H_); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

344

ret = gostr34_11_94_key_generation(H, M, K); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

348

ret = gostr34_11_94_state_encryption((const u64 (*)[4])K, H, S, gostr34_11_94_sbox_norm); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

352

ret = gostr34_11_94_state_encryption((const u64 (*)[4])K, H, S, gostr34_11_94_sbox_rfc4357); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

361

ret = gostr34_11_94_state_output_transform(H, S, M, ctx->gostr34_11_94_state); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

387

ret = local_memset(ctx->gostr34_11_94_sum, 0, sizeof(ctx->gostr34_11_94_sum)); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

472

ret = local_memcpy(ctx->gostr34_11_94_buffer + left, data_ptr, fill); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

473

ret = gostr34_11_94_process(ctx, ctx->gostr34_11_94_buffer); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

480

ret = gostr34_11_94_process(ctx, data_ptr); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

486

ret = local_memcpy(ctx->gostr34_11_94_buffer + left, data_ptr, remain_ilen); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

507

ret = local_memset(last_padded_block, 0, sizeof(last_padded_block)); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

512

block_present); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

519

ret = gostr34_11_94_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

536

ret = gostr34_11_94_process(ctx, last_padded_block + GOSTR34_11_94_BLOCK_SIZE); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

538

ret = gostr34_11_94_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

578

ret = gostr34_11_94_init(&ctx); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

579

ret = gostr34_11_94_set_type(&ctx, type); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

582

ret = gostr34_11_94_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

614

ret = gostr34_11_94_init(&ctx); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

615

ret = gostr34_11_94_set_type(&ctx, type); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

616

ret = gostr34_11_94_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/examples/hash/gostr34_11_94.c

99

ret = local_memcpy(U, H, sizeof(U)); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

150

ret = get_hash_by_type(htype, hm); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

151

ret = get_hash_sizes(htype, hlen, block_size); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

224

ret = get_libecc_hash(gen_hash_type, &hash_type, &hm, hlen, block_size); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

239

ret = md2_scattered(input, ilen, digest); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

243

ret = md4_scattered(input, ilen, digest); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

247

ret = md5_scattered(input, ilen, digest); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

251

ret = sha0_scattered(input, ilen, digest); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

255

ret = sha1_scattered(input, ilen, digest); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

259

ret = mdc2_scattered_padding1(input, ilen, digest); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

263

ret = mdc2_scattered_padding2(input, ilen, digest); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

267

ret = gostr34_11_94_scattered_norm(input, ilen, digest); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

271

ret = gostr34_11_94_scattered_rfc4357(input, ilen, digest); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

279

ret = get_libecc_hash(gen_hash_type, &hash_type, &hm, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

281

ret = hm->hfunc_scattered(input, ilen, digest); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

306

ret = md2_init(&(ctx->md2ctx)); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

310

ret = md4_init(&(ctx->md4ctx)); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

314

ret = md5_init(&(ctx->md5ctx)); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

318

ret = sha0_init(&(ctx->sha0ctx)); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

322

ret = sha1_init(&(ctx->sha1ctx)); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

326

ret = mdc2_init(&(ctx->mdc2ctx)); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

327

ret = mdc2_set_padding_type(&(ctx->mdc2ctx), ISOIEC10118_TYPE1); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

331

ret = mdc2_init(&(ctx->mdc2ctx)); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

332

ret = mdc2_set_padding_type(&(ctx->mdc2ctx), ISOIEC10118_TYPE2); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

336

ret = gostr34_11_94_init(&(ctx->gostr34_11_94ctx)); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

337

ret = gostr34_11_94_set_type(&(ctx->gostr34_11_94ctx), GOST34_11_94_NORM); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

341

ret = gostr34_11_94_init(&(ctx->gostr34_11_94ctx)); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

342

ret = gostr34_11_94_set_type(&(ctx->gostr34_11_94ctx), GOST34_11_94_RFC4357); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

350

ret = get_libecc_hash(gen_hash_type, &hash_type, &hm, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

352

ret = hm->hfunc_init(&(ctx->hctx)); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

369

ret = md2_update(&(ctx->md2ctx), chunk, chunklen); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

373

ret = md4_update(&(ctx->md4ctx), chunk, chunklen); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

377

ret = md5_update(&(ctx->md5ctx), chunk, chunklen); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

381

ret = sha0_update(&(ctx->sha0ctx), chunk, chunklen); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

385

ret = sha1_update(&(ctx->sha1ctx), chunk, chunklen); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

390

ret = mdc2_update(&(ctx->mdc2ctx), chunk, chunklen); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

395

ret = gostr34_11_94_update(&(ctx->gostr34_11_94ctx), chunk, chunklen); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

403

ret = get_libecc_hash(gen_hash_type, &hash_type, &hm, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

405

ret = hm->hfunc_update(&(ctx->hctx), chunk, chunklen); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

422

ret = md2_final(&(ctx->md2ctx), output); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

426

ret = md4_final(&(ctx->md4ctx), output); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

430

ret = md5_final(&(ctx->md5ctx), output); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

434

ret = sha0_final(&(ctx->sha0ctx), output); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

438

ret = sha1_final(&(ctx->sha1ctx), output); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

443

ret = mdc2_final(&(ctx->mdc2ctx), output); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

448

ret = gostr34_11_94_final(&(ctx->gostr34_11_94ctx), output); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

456

ret = get_libecc_hash(gen_hash_type, &hash_type, &hm, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

458

ret = hm->hfunc_finalize(&(ctx->hctx), output); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

484

ret = local_memset(input5, 0, sizeof(input5)); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

486

ret = gen_hash_hfunc(input, sizeof(input)-1, output, HASH_MDC2_PADDING1); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

489

ret = gen_hash_hfunc(input, sizeof(input)-1, output, HASH_MDC2_PADDING2); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

492

ret = gen_hash_hfunc(input2, sizeof(input2)-1, output, HASH_GOST34_11_94_NORM); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

495

ret = gen_hash_hfunc(input3, sizeof(input3)-1, output, HASH_GOST34_11_94_NORM); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

498

ret = gen_hash_hfunc(input4, sizeof(input4)-1, output, HASH_GOST34_11_94_NORM); EG(ret, err);

crypto/libecc/src/examples/hash/hash.c

504

ret = gen_hash_hfunc(input5, sizeof(input5), output, HASH_GOST34_11_94_NORM); EG(ret, err);

crypto/libecc/src/examples/hash/md2.c

129

ret = local_memcpy(ctx->md2_buffer + left, data_ptr, fill); EG(ret, err);

crypto/libecc/src/examples/hash/md2.c

130

ret = md2_process(ctx, ctx->md2_buffer); EG(ret, err);

crypto/libecc/src/examples/hash/md2.c

137

ret = md2_process(ctx, data_ptr); EG(ret, err);

crypto/libecc/src/examples/hash/md2.c

143

ret = local_memcpy(ctx->md2_buffer + left, data_ptr, remain_ilen); EG(ret, err);

crypto/libecc/src/examples/hash/md2.c

168

ret = md2_process(ctx, ctx->md2_buffer); EG(ret, err);

crypto/libecc/src/examples/hash/md2.c

171

ret = md2_process(ctx, ctx->md2_checksum); EG(ret, err);

crypto/libecc/src/examples/hash/md2.c

174

ret = local_memcpy(output, ctx->md2_state, MD2_DIGEST_SIZE); EG(ret, err);

crypto/libecc/src/examples/hash/md2.c

200

ret = md2_init(&ctx); EG(ret, err);

crypto/libecc/src/examples/hash/md2.c

203

ret = md2_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/examples/hash/md2.c

222

ret = md2_init(&ctx); EG(ret, err);

crypto/libecc/src/examples/hash/md2.c

223

ret = md2_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/examples/hash/md2.c

47

ret = local_memcpy(&x[0], ctx->md2_state, MD2_BLOCK_SIZE); EG(ret, err);

crypto/libecc/src/examples/hash/md2.c

48

ret = local_memcpy(&x[MD2_BLOCK_SIZE], data, MD2_BLOCK_SIZE); EG(ret, err);

crypto/libecc/src/examples/hash/md2.c

62

ret = local_memcpy(ctx->md2_state, &x[0], MD2_BLOCK_SIZE); EG(ret, err);

crypto/libecc/src/examples/hash/md2.c

71

ret = local_memset(x, 0, sizeof(x)); EG(ret, err);

crypto/libecc/src/examples/hash/md2.c

91

ret = local_memset(ctx->md2_state, 0, sizeof(ctx->md2_state)); EG(ret, err);

crypto/libecc/src/examples/hash/md2.c

93

ret = local_memset(ctx->md2_checksum, 0, sizeof(ctx->md2_checksum)); EG(ret, err);

crypto/libecc/src/examples/hash/md4.c

145

ret = local_memcpy(ctx->md4_buffer + left, data_ptr, fill); EG(ret, err);

crypto/libecc/src/examples/hash/md4.c

146

ret = md4_process(ctx, ctx->md4_buffer); EG(ret, err);

crypto/libecc/src/examples/hash/md4.c

153

ret = md4_process(ctx, data_ptr); EG(ret, err);

crypto/libecc/src/examples/hash/md4.c

159

ret = local_memcpy(ctx->md4_buffer + left, data_ptr, remain_ilen); EG(ret, err);

crypto/libecc/src/examples/hash/md4.c

179

ret = local_memset(last_padded_block, 0, sizeof(last_padded_block)); EG(ret, err);

crypto/libecc/src/examples/hash/md4.c

186

block_present); EG(ret, err);

crypto/libecc/src/examples/hash/md4.c

197

ret = md4_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/examples/hash/md4.c

198

ret = md4_process(ctx, last_padded_block + MD4_BLOCK_SIZE); EG(ret, err);

crypto/libecc/src/examples/hash/md4.c

203

ret = md4_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/examples/hash/md4.c

236

ret = md4_init(&ctx); EG(ret, err);

crypto/libecc/src/examples/hash/md4.c

239

ret = md4_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/examples/hash/md4.c

258

ret = md4_init(&ctx); EG(ret, err);

crypto/libecc/src/examples/hash/md4.c

259

ret = md4_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/examples/hash/md5.c

146

ret = local_memcpy(ctx->md5_buffer + left, data_ptr, fill); EG(ret, err);

crypto/libecc/src/examples/hash/md5.c

147

ret = md5_process(ctx, ctx->md5_buffer); EG(ret, err);

crypto/libecc/src/examples/hash/md5.c

154

ret = md5_process(ctx, data_ptr); EG(ret, err);

crypto/libecc/src/examples/hash/md5.c

160

ret = local_memcpy(ctx->md5_buffer + left, data_ptr, remain_ilen); EG(ret, err);

crypto/libecc/src/examples/hash/md5.c

180

ret = local_memset(last_padded_block, 0, sizeof(last_padded_block)); EG(ret, err);

crypto/libecc/src/examples/hash/md5.c

187

block_present); EG(ret, err);

crypto/libecc/src/examples/hash/md5.c

198

ret = md5_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/examples/hash/md5.c

199

ret = md5_process(ctx, last_padded_block + MD5_BLOCK_SIZE); EG(ret, err);

crypto/libecc/src/examples/hash/md5.c

204

ret = md5_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/examples/hash/md5.c

237

ret = md5_init(&ctx); EG(ret, err);

crypto/libecc/src/examples/hash/md5.c

240

ret = md5_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/examples/hash/md5.c

259

ret = md5_init(&ctx); EG(ret, err);

crypto/libecc/src/examples/hash/md5.c

260

ret = md5_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

100

ret = local_memset(&(ctx->mdc2_state[8]), 0x25, 8); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

138

ret = local_memcpy(ctx->mdc2_buffer + left, data_ptr, fill); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

139

ret = mdc2_process(ctx, ctx->mdc2_buffer); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

146

ret = mdc2_process(ctx, data_ptr); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

152

ret = local_memcpy(ctx->mdc2_buffer + left, data_ptr, remain_ilen); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

182

ret = mdc2_process(ctx, ctx->mdc2_buffer); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

196

ret = mdc2_process(ctx, ctx->mdc2_buffer); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

205

ret = local_memcpy(output, ctx->mdc2_state, MDC2_DIGEST_SIZE); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

231

ret = mdc2_init(&ctx); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

233

ret = mdc2_set_padding_type(&ctx, p); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

236

ret = mdc2_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

279

ret = mdc2_init(&ctx); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

280

ret = mdc2_set_padding_type(&ctx, p); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

281

ret = mdc2_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

61

ret = local_memset(&des_ctx, 0, sizeof(des_context)); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

62

ret = des_set_key(&des_ctx, A, DES_ENCRYPTION); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

63

ret = des(&des_ctx, &data[0], V); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

68

ret = local_memset(&des_ctx, 0, sizeof(des_context)); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

69

ret = des_set_key(&des_ctx, B, DES_ENCRYPTION); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

70

ret = des(&des_ctx, &data[0], W); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

76

ret = local_memcpy(&A[0], &V[0], 4); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

77

ret = local_memcpy(&A[4], &W[4], 4); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

79

ret = local_memcpy(&B[0], &W[0], 4); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

80

ret = local_memcpy(&B[4], &V[4], 4); EG(ret, err);

crypto/libecc/src/examples/hash/mdc2.c

98

ret = local_memset(&(ctx->mdc2_state[0]), 0x52, 8); EG(ret, err);

crypto/libecc/src/examples/hash/sha0.c

144

ret = local_memcpy(ctx->sha0_buffer + left, data_ptr, fill); EG(ret, err);

crypto/libecc/src/examples/hash/sha0.c

145

ret = sha0_process(ctx, ctx->sha0_buffer); EG(ret, err);

crypto/libecc/src/examples/hash/sha0.c

152

ret = sha0_process(ctx, data_ptr); EG(ret, err);

crypto/libecc/src/examples/hash/sha0.c

158

ret = local_memcpy(ctx->sha0_buffer + left, data_ptr, remain_ilen); EG(ret, err);

crypto/libecc/src/examples/hash/sha0.c

178

ret = local_memset(last_padded_block, 0, sizeof(last_padded_block)); EG(ret, err);

crypto/libecc/src/examples/hash/sha0.c

185

block_present); EG(ret, err);

crypto/libecc/src/examples/hash/sha0.c

196

ret = sha0_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/examples/hash/sha0.c

197

ret = sha0_process(ctx, last_padded_block + SHA0_BLOCK_SIZE); EG(ret, err);

crypto/libecc/src/examples/hash/sha0.c

202

ret = sha0_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/examples/hash/sha0.c

236

ret = sha0_init(&ctx); EG(ret, err);

crypto/libecc/src/examples/hash/sha0.c

239

ret = sha0_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/examples/hash/sha0.c

258

ret = sha0_init(&ctx); EG(ret, err);

crypto/libecc/src/examples/hash/sha0.c

259

ret = sha0_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/examples/hash/sha1.c

144

ret = local_memcpy(ctx->sha1_buffer + left, data_ptr, fill); EG(ret, err);

crypto/libecc/src/examples/hash/sha1.c

145

ret = sha1_process(ctx, ctx->sha1_buffer); EG(ret, err);

crypto/libecc/src/examples/hash/sha1.c

152

ret = sha1_process(ctx, data_ptr); EG(ret, err);

crypto/libecc/src/examples/hash/sha1.c

158

ret = local_memcpy(ctx->sha1_buffer + left, data_ptr, remain_ilen); EG(ret, err);

crypto/libecc/src/examples/hash/sha1.c

178

ret = local_memset(last_padded_block, 0, sizeof(last_padded_block)); EG(ret, err);

crypto/libecc/src/examples/hash/sha1.c

185

block_present); EG(ret, err);

crypto/libecc/src/examples/hash/sha1.c

196

ret = sha1_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/examples/hash/sha1.c

197

ret = sha1_process(ctx, last_padded_block + SHA1_BLOCK_SIZE); EG(ret, err);

crypto/libecc/src/examples/hash/sha1.c

202

ret = sha1_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/examples/hash/sha1.c

236

ret = sha1_init(&ctx); EG(ret, err);

crypto/libecc/src/examples/hash/sha1.c

239

ret = sha1_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/examples/hash/sha1.c

258

ret = sha1_init(&ctx); EG(ret, err);

crypto/libecc/src/examples/hash/sha1.c

259

ret = sha1_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

101

ret = nn_init(&q_square, 0); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

102

ret = nn_init(&_m_msb_fixed, 0); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

105

ret = nn_sqr(&q_square, q); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

107

ret = nn_cmp(m, q, &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

112

ret = nn_add(&_m_msb_fixed, m, q); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

113

ret = nn_bitlen(&_m_msb_fixed, &msb_bit_len); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

114

ret = nn_bitlen(q, &q_bitlen); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

116

&_m_msb_fixed, q); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

118

ret = nn_cmp(m, &q_square, &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

123

ret = nn_add(&_m_msb_fixed, m, &q_square); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

124

ret = nn_bitlen(&_m_msb_fixed, &msb_bit_len); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

125

ret = nn_bitlen(&q_square, &q_square_bitlen); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

127

m_msb_fixed, &_m_msb_fixed, &q_square); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

130

ret = nn_copy(m_msb_fixed, m); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

152

ret = nn_check_initialized(m); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

153

ret = nn_check_initialized(q); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

154

ret = nn_check_initialized(m_blind); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

156

ret = nn_get_random_mod(&tmp, q); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

158

ret = nn_mul(&tmp, &tmp, q); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

16

ret = nn_check_initialized(x); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

191

ret = nn_check_initialized(base); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

192

ret = nn_check_initialized(exp); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

193

ret = nn_check_initialized(mod); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

195

ret = nn_bitlen(exp, &explen); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

200

ret = nn_isodd(mod, &isodd); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

204

ret = nn_compute_redc1_coefs(&r, &r_square, mod, &mpinv); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

207

ret = nn_cmp(base, mod, &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

209

ret = nn_mod(&_base, base, mod); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

21

ret = nn_bitlen(x, &blen); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

212

ret = nn_copy(&_base, base); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

215

ret = nn_mul_redc1(&_base, &_base, &r_square, mod, mpinv); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

216

ret = nn_copy(out, &r); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

218

ret = nn_init(&one, 0); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

219

ret = nn_one(&one); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

225

ret = nn_getbit(exp, explen, &expbit); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

228

ret = nn_mul_redc1(out, out, out, mod, mpinv); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

232

ret = nn_mul_redc1(out, out, &_base, mod, mpinv); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

97

ret = nn_check_initialized(m); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

98

ret = nn_check_initialized(q); EG(ret, err);

crypto/libecc/src/examples/sig/common/common.h

99

ret = nn_check_initialized(m_msb_fixed); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

101

ret = _os2ip(&(pub->p), p, plen); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

102

ret = _os2ip(&(pub->q), q, qlen); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

103

ret = _os2ip(&(pub->g), g, glen); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

104

ret = _os2ip(&(pub->y), y, ylen); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

107

ret = nn_cmp(&(pub->q), &(pub->p), &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

110

ret = nn_cmp(&(pub->g), &(pub->p), &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

113

ret = nn_cmp(&(pub->y), &(pub->p), &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

146

ret = nn_check_initialized(p); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

147

ret = nn_check_initialized(q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

148

ret = nn_check_initialized(g); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

149

ret = nn_check_initialized(x); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

152

ret = nn_cmp(&(priv->q), &(priv->p), &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

155

ret = nn_cmp(&(priv->g), &(priv->p), &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

158

ret = nn_cmp(&(priv->x), &(priv->q), &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

161

ret = nn_init(&x_, 0); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

165

ret = _blind_scalar(x, q, &x_); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

166

ret = _fix_scalar_msb(&x_, q, &x_); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

169

ret = nn_mod_pow(&(pub->y), g, &x_, p); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

172

ret = nn_copy(&(pub->p), p); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

173

ret = nn_copy(&(pub->q), q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

220

ret = local_memset(hash, 0, sizeof(hash)); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

229

ret = nn_check_initialized(p); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

230

ret = nn_check_initialized(q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

231

ret = nn_check_initialized(g); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

232

ret = nn_check_initialized(x); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

238

ret = nn_bitlen(q, &N); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

239

ret = gen_hash_get_hash_sizes(dsa_hash, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

248

ret = _os2ip(&k, nonce, noncelen); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

251

ret = nn_get_random_mod(&k, q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

255

ret = nn_copy(&k_, &k); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

258

ret = _blind_scalar(&k_, q, &k_); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

260

ret = _fix_scalar_msb(&k_, q, &k_); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

262

ret = nn_init(&r, 0); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

264

ret = nn_mod_pow(&r, g, &k_, p); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

266

ret = nn_mod(&r, &r, q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

269

ret = nn_iszero(&r, &iszero); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

275

ret = _i2osp(&r, sig, (siglen / 2)); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

278

ret = gen_hash_hfunc(msg, msglen, hash, dsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

284

ret = _os2ip(&z, hash, hlen); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

286

ret = nn_rshift_fixedlen(&z, &z, rshift); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

288

ret = nn_mod(&z, &z, q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

293

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

295

ret = nn_mod_mul(&r, &r, &b, q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

297

ret = nn_mod_mul(&z, &z, &b, q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

302

ret = nn_mod_mul(&k, &k, &b, q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

310

ret = nn_modinv_fermat(&kinv, &k, q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

311

ret = nn_mod_mul(&s, &r, x, q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

312

ret = nn_mod_add(&s, &s, &z, q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

313

ret = nn_mod_mul(&s, &kinv, &s, q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

316

ret = nn_iszero(&s, &iszero); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

372

ret = local_memset(hash, 0, sizeof(hash)); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

381

ret = nn_check_initialized(p); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

382

ret = nn_check_initialized(q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

383

ret = nn_check_initialized(g); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

384

ret = nn_check_initialized(y); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

387

ret = nn_bitlen(q, &N); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

391

ret = _os2ip(&r, sig, (siglen / 2)); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

392

ret = _os2ip(&s, sig + (siglen / 2), (siglen / 2)); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

395

ret = nn_iszero(&r, &iszero); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

397

ret = nn_iszero(&s, &iszero); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

400

ret = nn_cmp(&r, q, &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

402

ret = nn_cmp(&s, q, &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

406

ret = gen_hash_get_hash_sizes(dsa_hash, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

408

ret = gen_hash_hfunc(msg, msglen, hash, dsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

414

ret = _os2ip(&z, hash, hlen); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

416

ret = nn_rshift_fixedlen(&z, &z, rshift); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

418

ret = nn_mod(&z, &z, q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

421

ret = nn_modinv(&s, &s, q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

424

ret = nn_mod_mul(&u1, &z, &s, q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

426

ret = nn_mod_mul(&u2, &r, &s, q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

431

ret = _nn_mod_pow_insecure(&v, g, &u1, p); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

432

ret = _nn_mod_pow_insecure(&s, y, &u2, p); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

433

ret = nn_mod_mul(&v, &v, &s, p); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

434

ret = nn_mod(&v, &v, q); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

437

ret = nn_cmp(&v, &r, &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

539

ret = dsa_import_priv_key(&priv, p, sizeof(p), q, sizeof(q), g, sizeof(g), x, sizeof(x)); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

540

ret = dsa_import_pub_key(&pub, p, sizeof(p), q, sizeof(q), g, sizeof(g), y, sizeof(y)); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

541

ret = dsa_compute_pub_from_priv(&pub2, &priv); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

545

ret = dsa_sign(&priv, msg, sizeof(msg)-1, nonce, sizeof(nonce), sig, sizeof(sig), HASH_SHA256); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

65

ret = _os2ip(&(priv->p), p, plen); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

66

ret = _os2ip(&(priv->q), q, qlen); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

67

ret = _os2ip(&(priv->g), g, glen); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

68

ret = _os2ip(&(priv->x), x, xlen); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

71

ret = nn_cmp(&(priv->q), &(priv->p), &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

74

ret = nn_cmp(&(priv->g), &(priv->p), &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/dsa/dsa.c

77

ret = nn_cmp(&(priv->x), &(priv->q), &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

112

ret = local_memset(hash, 0, sizeof(hash)); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

121

ret = nn_check_initialized(p); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

122

ret = nn_check_initialized(q); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

123

ret = nn_check_initialized(g); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

124

ret = nn_check_initialized(x); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

130

ret = nn_bitlen(q, &N); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

131

ret = gen_hash_get_hash_sizes(gostr34_10_94_hash, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

140

ret = _os2ip(&k, nonce, noncelen); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

143

ret = nn_get_random_mod(&k, q); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

147

ret = nn_copy(&k_, &k); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

150

ret = _blind_scalar(&k_, q, &k_); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

152

ret = _fix_scalar_msb(&k_, q, &k_); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

154

ret = nn_init(&r, 0); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

156

ret = nn_mod_pow(&r, g, &k_, p); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

158

ret = nn_mod(&r, &r, q); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

161

ret = nn_iszero(&r, &iszero); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

167

ret = _i2osp(&r, sig, (siglen / 2)); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

170

ret = gen_hash_hfunc(msg, msglen, hash, gostr34_10_94_hash); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

172

ret = _reverse_endianness(hash, hlen); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

179

ret = _os2ip(&z, hash, hlen); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

181

ret = nn_rshift_fixedlen(&z, &z, rshift); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

183

ret = nn_mod(&z, &z, q); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

185

ret = nn_iszero(&z, &iszero); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

187

ret = nn_one(&z); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

193

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

195

ret = nn_mod_mul(&r, &r, &b, q); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

197

ret = nn_mod_mul(&z, &z, &b, q); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

203

ret = nn_modinv_fermat(&b, &b, q); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

207

ret = nn_mod_mul(&s, &r, x, q); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

208

ret = nn_mod_mul(&r, &k, &z, q); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

209

ret = nn_mod_add(&s, &s, &r, q); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

213

ret = nn_mod_mul(&s, &s, &b, q); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

216

ret = nn_iszero(&s, &iszero); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

270

ret = local_memset(hash, 0, sizeof(hash)); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

279

ret = nn_check_initialized(p); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

280

ret = nn_check_initialized(q); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

281

ret = nn_check_initialized(g); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

282

ret = nn_check_initialized(y); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

285

ret = nn_bitlen(q, &N); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

289

ret = _os2ip(&r, sig, (siglen / 2)); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

290

ret = _os2ip(&s, sig + (siglen / 2), (siglen / 2)); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

293

ret = nn_iszero(&r, &iszero); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

295

ret = nn_iszero(&s, &iszero); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

298

ret = nn_cmp(&r, q, &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

300

ret = nn_cmp(&s, q, &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

304

ret = gen_hash_get_hash_sizes(gostr34_10_94_hash, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

306

ret = gen_hash_hfunc(msg, msglen, hash, gostr34_10_94_hash); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

308

ret = _reverse_endianness(hash, hlen); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

315

ret = _os2ip(&z, hash, hlen); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

317

ret = nn_rshift_fixedlen(&z, &z, rshift); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

319

ret = nn_mod(&z, &z, q); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

321

ret = nn_iszero(&z, &iszero); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

323

ret = nn_one(&z); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

327

ret = nn_init(&v, 0); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

328

ret = nn_init(&u1, 0); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

329

ret = nn_init(&u2, 0); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

332

ret = nn_dec(&u1, q); EG(ret, err); /* use u1 as temp here */

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

333

ret = nn_dec(&u1, &u1); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

334

ret = _nn_mod_pow_insecure(&v, &z, &u1, q); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

336

ret = nn_mod_mul(&u1, &s, &v, q); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

338

ret = nn_sub(&u2, q, &r); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

339

ret = nn_mod_mul(&u2, &u2, &v, q); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

344

ret = _nn_mod_pow_insecure(&v, g, &u1, p); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

345

ret = _nn_mod_pow_insecure(&s, y, &u2, p); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

346

ret = nn_mod_mul(&v, &v, &s, p); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

347

ret = nn_mod(&v, &v, q); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

350

ret = nn_cmp(&v, &r, &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

495

ret = _reverse_endianness(&y_self_signed[0], sizeof(y_self_signed)); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

497

ret = gostr34_10_94_import_pub_key(&pub, p, sizeof(p), q, sizeof(q), g, sizeof(g), y_self_signed, sizeof(y_self_signed)); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

505

ret = nn_get_random_mod(&x_, &(pub.q)); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

506

ret = _i2osp(&x_, &x[0], sizeof(x)); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

508

ret = gostr34_10_94_import_priv_key(&priv, p, sizeof(p), q, sizeof(q), g, sizeof(g), x, sizeof(x)); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

510

ret = gostr34_10_94_compute_pub_from_priv(&pub, &priv); EG(ret, err);

crypto/libecc/src/examples/sig/gostr34_10_94/gostr34_10_94.c

512

ret = gostr34_10_94_sign(&priv, msg, sizeof(msg), NULL, 0, check_sig, sizeof(check_sig), HASH_GOST34_11_94_RFC4357); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

165

ret = local_memset(&pub, 0, sizeof(kcdsa_pub_key)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

166

ret = local_memset(hash, 0, sizeof(hash)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

167

ret = local_memset(pi_buf, 0, sizeof(pi_buf)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

176

ret = nn_check_initialized(p); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

177

ret = nn_check_initialized(q); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

178

ret = nn_check_initialized(g); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

179

ret = nn_check_initialized(x); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

182

ret = nn_bitlen(p, &alpha); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

184

ret = nn_bitlen(q, &beta); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

186

ret = gen_hash_get_hash_sizes(kcdsa_hash, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

203

ret = kcdsa_compute_pub_from_priv(&pub, priv); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

209

ret = _os2ip(&k, nonce, noncelen); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

212

ret = nn_get_random_mod(&k, q); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

216

ret = nn_copy(&k_, &k); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

219

ret = _blind_scalar(&k_, q, &k_); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

221

ret = _fix_scalar_msb(&k_, q, &k_); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

225

ret = nn_init(pi, 0); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

227

ret = nn_mod_pow(pi, g, &k_, p); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

232

ret = _i2osp(pi, pi_buf, (u16)BYTECEIL(alpha)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

237

ret = gen_hash_init(&hash_ctx, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

238

ret = gen_hash_update(&hash_ctx, pi_buf, (u16)BYTECEIL(alpha), kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

240

ret = gen_hash_final(&hash_ctx, sig, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

243

ret = _i2osp(y, pi_buf, (u16)BYTECEIL(alpha)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

244

ret = buf_lshift(pi_buf, (u16)BYTECEIL(alpha), (u16)(BYTECEIL(alpha) - block_size)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

245

ret = gen_hash_init(&hash_ctx, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

246

ret = gen_hash_update(&hash_ctx, pi_buf, block_size, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

247

ret = gen_hash_update(&hash_ctx, msg, msglen, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

248

ret = gen_hash_final(&hash_ctx, hash, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

252

ret = _os2ip(&s, hash, hlen); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

257

ret = gen_hash_init(&hash_ctx, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

258

ret = gen_hash_update(&hash_ctx, pi_buf, (u16)BYTECEIL(alpha), kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

260

ret = gen_hash_final(&hash_ctx, hash, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

262

ret = buf_lshift(hash, hlen, (u16)(hlen - BYTECEIL(beta))); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

263

ret = local_memcpy(sig, hash, (u16)BYTECEIL(beta)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

266

ret = _i2osp(y, pi_buf, (u16)BYTECEIL(alpha)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

267

ret = buf_lshift(pi_buf, (u16)BYTECEIL(alpha), (u16)(BYTECEIL(alpha) - block_size)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

268

ret = gen_hash_init(&hash_ctx, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

269

ret = gen_hash_update(&hash_ctx, pi_buf, block_size, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

270

ret = gen_hash_update(&hash_ctx, msg, msglen, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

271

ret = gen_hash_final(&hash_ctx, hash, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

273

ret = buf_lshift(hash, hlen, (u16)(hlen - BYTECEIL(beta))); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

277

ret = _os2ip(&s, hash, (u16)BYTECEIL(beta)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

281

ret = nn_mod(&s, &s, q); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

286

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

288

ret = nn_mod_mul(&s, &s, &b, q); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

290

ret = nn_mod_mul(&k, &k, &b, q); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

296

ret = nn_modinv_fermat(&b, &b, q); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

300

ret = nn_mod_sub(&s, &k, &s, q); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

301

ret = nn_mod_mul(&s, &s, x, q); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

305

ret = nn_mod_mul(&s, &s, &b, q); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

308

ret = nn_iszero(&s, &iszero); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

372

ret = local_memset(pi_buf, 0, sizeof(pi_buf)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

373

ret = local_memset(hash, 0, sizeof(hash)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

382

ret = nn_check_initialized(p); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

383

ret = nn_check_initialized(q); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

384

ret = nn_check_initialized(g); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

385

ret = nn_check_initialized(y); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

388

ret = nn_bitlen(p, &alpha); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

390

ret = nn_bitlen(q, &beta); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

392

ret = gen_hash_get_hash_sizes(kcdsa_hash, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

409

ret = _os2ip(&s, sig + curr_rlen, (u16)(siglen - curr_rlen)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

412

ret = nn_iszero(&s, &iszero); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

415

ret = nn_cmp(&s, q, &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

419

ret = nn_init(&u, 0); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

420

ret = nn_init(&pi, 0); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

427

ret = _i2osp(y, pi_buf, (u16)BYTECEIL(alpha)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

428

ret = buf_lshift(pi_buf, (u16)BYTECEIL(alpha), (u16)(BYTECEIL(alpha) - block_size)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

429

ret = gen_hash_init(&hash_ctx, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

430

ret = gen_hash_update(&hash_ctx, pi_buf, block_size, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

431

ret = gen_hash_update(&hash_ctx, msg, msglen, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

432

ret = gen_hash_final(&hash_ctx, hash, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

436

ret = _os2ip(&v, hash, hlen); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

442

ret = _i2osp(y, pi_buf, (u16)BYTECEIL(alpha)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

443

ret = buf_lshift(pi_buf, (u16)BYTECEIL(alpha), (u16)(BYTECEIL(alpha) - block_size)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

444

ret = gen_hash_init(&hash_ctx, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

445

ret = gen_hash_update(&hash_ctx, pi_buf, block_size, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

446

ret = gen_hash_update(&hash_ctx, msg, msglen, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

447

ret = gen_hash_final(&hash_ctx, hash, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

449

ret = buf_lshift(hash, hlen, (u16)(hlen - BYTECEIL(beta))); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

453

ret = _os2ip(&v, hash, (u16)BYTECEIL(beta)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

457

ret = nn_mod(&v, &v, q); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

463

ret = _nn_mod_pow_insecure(&u, y, &s, p); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

465

ret = _nn_mod_pow_insecure(&pi, g, &v, p); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

467

ret = nn_mod_mul(&pi, &pi, &u, p); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

472

ret = _i2osp(&pi, pi_buf, (u16)BYTECEIL(alpha)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

476

ret = gen_hash_init(&hash_ctx, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

477

ret = gen_hash_update(&hash_ctx, pi_buf, (u16)BYTECEIL(alpha), kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

479

ret = gen_hash_final(&hash_ctx, hash, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

483

ret = gen_hash_init(&hash_ctx, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

484

ret = gen_hash_update(&hash_ctx, pi_buf, (u16)BYTECEIL(alpha), kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

486

ret = gen_hash_final(&hash_ctx, hash, kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

488

ret = buf_lshift(hash, hlen, (u16)(hlen - BYTECEIL(beta))); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

492

ret = are_equal(sig, hash, curr_rlen, &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

743

ret = kcdsa_import_priv_key(&priv, p, sizeof(p), q, sizeof(q), g, sizeof(g), x, sizeof(x)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

744

ret = kcdsa_import_pub_key(&pub, p, sizeof(p), q, sizeof(q), g, sizeof(g), y, sizeof(y)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

745

ret = kcdsa_compute_pub_from_priv(&pub2, &priv); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

749

ret = kcdsa_sign(&priv, msg, sizeof(msg)-1, nonce, sizeof(nonce), sig, sizeof(sig), kcdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

86

ret = local_memcpy(&priv_, priv, sizeof(kcdsa_priv_key)); EG(ret, err);

crypto/libecc/src/examples/sig/kcdsa/kcdsa.c

88

ret = nn_modinv_fermat(&(priv_.x), &(priv_.x), &(priv_.q)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1026

ret = _mgf1(h, hlen, dbmask, dblen, mgf_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1063

ret = gen_hash_hfunc_scattered(input_, ilens_, h_, gen_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1066

ret = are_equal(h, h_, hlen, &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1089

ret = local_memset(digest, 0, sizeof(digest)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1092

ret = gen_hash_get_hash_sizes(gen_hash_type, &digest_size, &block_size); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1094

ret = gen_hash_hfunc_scattered(input, ilens, digest, gen_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1107

ret = rsa_digestinfo_from_hash(gen_hash_type, em, &digestinfo_len); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1115

ret = rsa_digestinfo_from_hash(gen_hash_type, &em[emlen - tlen], &digestinfo_len); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1116

ret = local_memcpy(&em[emlen - tlen + digestinfo_len], digest, digest_size); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

113

ret = nn_init_from_buf(&(priv->key.s.n), n, nlen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

114

ret = nn_init_from_buf(&(priv->key.s.d), d, dlen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1162

ret = get_random(&rand_byte, 1); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1173

ret = local_memcpy(&em[2], forced_seed, seedlen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1176

ret = local_memcpy(&em[k - mlen], m, mlen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

118

ret = nn_init_from_buf(&(priv->key.s_pq.n), n, nlen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1181

ret = rsa_os2ip(&m_, em, (u16)k); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1183

ret = rsaep(pub, &m_, &c_); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1185

ret = rsa_i2osp(&c_, c, (u16)k); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

119

ret = nn_init_from_buf(&(priv->key.s_pq.d), d, dlen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

120

ret = nn_init_from_buf(&(priv->key.s_pq.p), p, plen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

121

ret = nn_init_from_buf(&(priv->key.s_pq.q), q, qlen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1223

ret = rsa_os2ip(&c_, c, clen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1226

ret = rsadp_hardened(priv, pub, &c_, &m_); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1229

ret = rsadp(priv, &c_, &m_); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1233

ret = rsa_i2osp(&m_, em, (u16)k); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1323

ret = local_memset(seed, 0, sizeof(seed)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1324

ret = local_memset(db, 0, sizeof(db)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1325

ret = local_memset(dbmask, 0, sizeof(dbmask)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1331

ret = gen_hash_get_hash_sizes(gen_hash_type, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1351

ret = gen_hash_hfunc_scattered(input, ilens, &db[0], gen_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1371

ret = local_memcpy(seed, forced_seed, seedlen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1374

ret = get_random(seed, hlen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1379

ret = _mgf1(seed, hlen, dbmask, khlen, mgf_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1386

ret = _mgf1(maskeddb, (u16)khlen, seedmask, hlen, mgf_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1397

ret = rsa_os2ip(&m_, em, (u16)k); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1399

ret = rsaep(pub, &m_, &c_); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1401

ret = rsa_i2osp(&c_, c, (u16)k); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1443

ret = local_memset(lhash, 0, sizeof(lhash)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1444

ret = local_memset(seedmask, 0, sizeof(seedmask)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1445

ret = local_memset(dbmask, 0, sizeof(dbmask)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1451

ret = gen_hash_get_hash_sizes(gen_hash_type, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

146

ret = nn_init_from_buf(&(priv->key.crt.p), p, plen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1460

ret = rsa_os2ip(&c_, c, clen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1463

ret = rsadp_hardened(priv, pub, &c_, &m_); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1466

ret = rsadp(priv, &c_, &m_); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

147

ret = nn_init_from_buf(&(priv->key.crt.q), q, qlen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1470

ret = rsa_i2osp(&m_, em, (u16)k); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

148

ret = nn_init_from_buf(&(priv->key.crt.dP), dP, dPlen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1481

ret = gen_hash_hfunc_scattered(input, ilens, lhash, gen_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1488

ret = _mgf1(maskeddb, (u16)khlen, seedmask, hlen, mgf_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

149

ret = nn_init_from_buf(&(priv->key.crt.dQ), dQ, dQlen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1495

ret = _mgf1(seed, hlen, dbmask, khlen, mgf_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

150

ret = nn_init_from_buf(&(priv->key.crt.qInv), qInv, qInvlen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1597

ret = emsa_pkcs1_v1_5_encode(m, mlen, em, (u16)k, gen_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1600

ret = rsa_os2ip(&m_, em, (u16)k); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1603

ret = rsasp1_hardened(priv, pub, &m_, &s_); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1606

ret = rsasp1(priv, &m_, &s_); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1659

ret = local_memset(em, 0, sizeof(em)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

166

ret = nn_init_from_buf(&(cur->r), coeffs[i], coeffslens[i]); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1660

ret = local_memset(em_, 0, sizeof(em_)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

167

ret = nn_init_from_buf(&(cur->d), coeffs[i + 1], coeffslens[i + 1]); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1672

ret = rsa_os2ip(&s_, s, slen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1674

ret = rsavp1(pub, &s_, &m_); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1677

ret = rsa_i2osp(&m_, em, slen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

168

ret = nn_init_from_buf(&(cur->t), coeffs[i + 2], coeffslens[i + 2]); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1680

ret = emsa_pkcs1_v1_5_encode(m, mlen, em_, (u16)k, gen_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1683

ret = are_equal(em, em_, (u16)k, &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1721

ret = emsa_pss_encode(m, mlen, em, (modbits - 1), &emsize, gen_hash_type, mgf_hash_type, saltlen, forced_salt); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1727

ret = rsa_os2ip(&m_, em, (u16)emsize); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1730

ret = rsasp1_hardened(priv, pub, &m_, &s_); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1733

ret = rsasp1(priv, &m_, &s_); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1794

ret = local_memset(em, 0, sizeof(em)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1801

ret = rsa_os2ip(&s_, s, slen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1803

ret = rsavp1(pub, &s_, &m_); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1813

ret = rsa_i2osp(&m_, em, (u16)emlen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1856

ret = gen_hash_get_hash_sizes(gen_hash_type, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1868

ret = gen_hash_init(&hctx, gen_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1869

ret = gen_hash_update(&hctx, m, mlen, gen_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1870

ret = gen_hash_final(&hctx, &s[k - 1 - hlen], gen_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1873

ret = local_memcpy(&s[1], m, m1len_); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1886

ret = rsa_os2ip(&m_, s, k); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1889

ret = rsasp1_hardened(priv, pub, &m_, &s_); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1892

ret = rsasp1(priv, &m_, &s_); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1963

ret = local_memset(X, 0, sizeof(X)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1964

ret = local_memset(H, 0, sizeof(H)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1970

ret = gen_hash_get_hash_sizes(gen_hash_type, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1981

ret = rsa_os2ip(&s_, s, slen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1983

ret = rsavp1(pub, &s_, &m_); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

1986

ret = rsa_i2osp(&m_, X, slen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

2000

ret = gen_hash_init(&hctx, gen_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

2001

ret = gen_hash_update(&hctx, &X[1], m1len_, gen_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

2002

ret = gen_hash_update(&hctx, m2, m2len, gen_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

2003

ret = gen_hash_final(&hctx, H, gen_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

2006

ret = are_equal(H, &X[1 + m1len_], (u16)hlen, &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

2013

ret = local_memcpy(m1, &X[1], (*m1len)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

227

ret = nn_check_initialized(n); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

228

ret = nn_check_initialized(e); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

259

ret = nn_init(&b, 0); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

260

ret = nn_init(out, 0); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

262

ret = nn_one(out); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

263

ret = nn_lshift(out, out, bits); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

264

ret = nn_iszero(out, &check); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

269

ret = nn_get_random_mod(&b, out); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

272

ret = nn_copy(out, mod); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

273

ret = nn_dec(out, out); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

274

ret = nn_mul(&b, &b, out); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

277

ret = nn_mul(&b, &b, mod); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

305

ret = nn_init(&m_i, 0); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

306

ret = nn_init(&h, 0); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

307

ret = nn_init(&R, 0); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

312

ret = nn_copy(&R, &(priv->key.crt.coeffs[0].r)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

321

ret = nn_check_initialized(r_i_1); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

322

ret = nn_check_initialized(r_i); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

323

ret = nn_check_initialized(d_i); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

324

ret = nn_check_initialized(t_i); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

328

ret = _rsa_blind_exponent(d_i, r_i, &h, (bitcnt_t)RSA_EXPONENT_BLINDING_SIZE, 1); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

329

ret = nn_mod_pow(&m_i, c, &h, r_i); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

331

ret = nn_mod_pow(&m_i, c, d_i, r_i); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

334

ret = nn_mul(&R, &R, r_i_1); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

336

ret = nn_mod(&h, m, r_i); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

337

ret = nn_mod_sub(&h, &m_i, &h, r_i); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

338

ret = nn_mod_mul(&h, &h, t_i, r_i); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

340

ret = nn_mul(&h, &R, &h); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

341

ret = nn_add(m, m, &h); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

365

ret = nn_init(&m_1, 0); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

366

ret = nn_init(&m_2, 0); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

367

ret = nn_init(&h, 0); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

368

ret = nn_init(&msb_fixed, 0); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

379

ret = nn_check_initialized(p); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

380

ret = nn_check_initialized(q); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

381

ret = nn_check_initialized(dP); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

382

ret = nn_check_initialized(dQ); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

383

ret = nn_check_initialized(qInv); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

387

ret = _rsa_blind_exponent(dP, p, &h, (bitcnt_t)RSA_EXPONENT_BLINDING_SIZE, 1); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

388

ret = nn_mod_pow(&m_1, c, &h, p); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

390

ret = nn_mod_pow(&m_1, c, dP, p); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

394

ret = _rsa_blind_exponent(dQ, q, &h, (bitcnt_t)RSA_EXPONENT_BLINDING_SIZE, 1); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

395

ret = nn_mod_pow(&m_2, c, &h, q); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

397

ret = nn_mod_pow(&m_2, c, dQ, q); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

400

ret = nn_mod(&h, &m_2, p); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

401

ret = nn_mod_sub(&h, &m_1, &h, p); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

402

ret = nn_mod_mul(&h, &h, qInv, p); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

404

ret = nn_mul(m, &h, q); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

405

ret = nn_add(m, &m_2, m); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

447

ret = nn_check_initialized(n); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

448

ret = nn_check_initialized(d); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

461

ret = nn_init(&b1, 0); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

462

ret = nn_init(&b2, 0); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

463

ret = nn_dec(&b1, p); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

464

ret = nn_dec(&b2, q); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

465

ret = nn_mul(&b1, &b1, &b2); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

466

ret = _rsa_blind_exponent(d, &b1, &b2, (bitcnt_t)RSA_EXPONENT_BLINDING_SIZE, 0); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

467

ret = nn_mod_pow(m, c, &b2, n); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

501

ret = rsadp_nocrt(priv, c, m); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

504

ret = rsadp_crt(priv, c, m); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

537

ret = nn_init(&b, 0); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

538

ret = nn_init(&binv, 0); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

541

ret = nn_get_random_mod(&b, n); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

545

ret = _nn_mod_pow_insecure(m, &b, e, n); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

547

ret = nn_mod_mul(&b, m, c, n); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

550

ret = rsadp(priv, &b, m); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

553

ret = nn_mod_mul(m, m, &binv, n); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

558

ret = rsaep(pub, m, &b); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

559

ret = nn_cmp(c, &b, &check); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

616

ret = local_memcpy(digestinfo, _digestinfo, sizeof(_digestinfo)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

625

ret = local_memcpy(digestinfo, _digestinfo, sizeof(_digestinfo)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

634

ret = local_memcpy(digestinfo, _digestinfo, sizeof(_digestinfo)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

643

ret = local_memcpy(digestinfo, _digestinfo, sizeof(_digestinfo)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

652

ret = local_memcpy(digestinfo, _digestinfo, sizeof(_digestinfo)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

661

ret = local_memcpy(digestinfo, _digestinfo, sizeof(_digestinfo)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

670

ret = local_memcpy(digestinfo, _digestinfo, sizeof(_digestinfo)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

679

ret = local_memcpy(digestinfo, _digestinfo, sizeof(_digestinfo)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

688

ret = local_memcpy(digestinfo, _digestinfo, sizeof(_digestinfo)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

697

ret = local_memcpy(digestinfo, _digestinfo, sizeof(_digestinfo)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

706

ret = local_memcpy(digestinfo, _digestinfo, sizeof(_digestinfo)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

715

ret = local_memcpy(digestinfo, _digestinfo, sizeof(_digestinfo)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

730

ret = local_memcpy(digestinfo, _digestinfo, sizeof(_digestinfo)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

739

ret = local_memcpy(digestinfo, _digestinfo, sizeof(_digestinfo)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

748

ret = local_memcpy(digestinfo, _digestinfo, sizeof(_digestinfo)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

757

ret = local_memcpy(digestinfo, _digestinfo, sizeof(_digestinfo)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

769

ret = local_memcpy(digestinfo, _digestinfo, sizeof(_digestinfo)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

799

ret = local_memset(C, 0, sizeof(C)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

800

ret = local_memset(digest, 0, sizeof(digest)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

805

ret = gen_hash_get_hash_sizes(mgf_hash_type, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

821

ret = gen_hash_hfunc_scattered(input, ilens, digest, mgf_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

822

ret = local_memcpy(&mask[c * hlen], digest, (u32)(masklen % hlen)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

824

ret = gen_hash_hfunc_scattered(input, ilens, &mask[c * hlen], mgf_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

859

ret = local_memset(mhash, 0, sizeof(mhash)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

860

ret = local_memset(h, 0, sizeof(h)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

861

ret = local_memset(salt, 0, sizeof(salt)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

862

ret = local_memset(zeroes, 0, sizeof(zeroes)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

863

ret = local_memset(ilens_, 0, sizeof(ilens_)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

877

ret = gen_hash_get_hash_sizes(gen_hash_type, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

887

ret = gen_hash_hfunc_scattered(input, ilens, mhash, gen_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

89

ret = nn_init_from_buf(&(pub->n), n, nlen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

896

ret = local_memcpy(salt, forced_salt, saltlen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

902

ret = get_random(salt, (u16)saltlen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

908

ret = gen_hash_hfunc_scattered(input_, ilens_, h, gen_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

915

ret = _mgf1(h, hlen, dbmask, dblen, mgf_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

944

ret = local_memcpy(&em[dblen], h, hlen); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

981

ret = local_memset(mhash, 0, sizeof(mhash)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

982

ret = local_memset(h_, 0, sizeof(h_)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

983

ret = local_memset(dbmask, 0, sizeof(dbmask)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

984

ret = local_memset(zeroes, 0, sizeof(zeroes)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

985

ret = local_memset(input_, 0, sizeof(input_)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

986

ret = local_memset(ilens_, 0, sizeof(ilens_)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

992

ret = gen_hash_get_hash_sizes(gen_hash_type, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa.c

996

ret = gen_hash_hfunc_scattered(input, ilens, mhash, gen_hash_type); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

102

ret = rsaes_pkcs1_v1_5_decrypt(&priv, t->res, t->reslen, cipher, &clen, modbits); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

105

ret = are_equal(t->m, cipher, t->mlen, &cmp); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

109

ret = rsaes_pkcs1_v1_5_decrypt_hardened(&priv, &pub, t->res, t->reslen, cipher, &clen, modbits); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

112

ret = are_equal(t->m, cipher, t->mlen, &cmp); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

121

ret = rsaes_oaep_encrypt(&pub, t->m, t->mlen, cipher, &clen, modbits, NULL, 0, t->hash, t->hash, t->salt, t->saltlen); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

124

ret = are_equal(t->res, cipher, t->reslen, &cmp); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

129

ret = rsaes_oaep_decrypt(&priv, t->res, t->reslen, cipher, &clen, modbits, NULL, 0, t->hash, t->hash); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

132

ret = are_equal(t->m, cipher, t->mlen, &cmp); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

136

ret = rsaes_oaep_decrypt_hardened(&priv, &pub, t->res, t->reslen, cipher, &clen, modbits, NULL, 0, t->hash, t->hash); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

139

ret = are_equal(t->m, cipher, t->mlen, &cmp); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

147

ret = rsassa_pkcs1_v1_5_verify(&pub, t->m, t->mlen, t->res, (u16)(t->reslen), modbits, t->hash); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

149

ret = rsassa_pkcs1_v1_5_sign(&priv, t->m, t->mlen, sig, &siglen, modbits, t->hash); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

152

ret = are_equal(t->res, sig, t->reslen, &cmp); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

155

ret = rsassa_pkcs1_v1_5_sign_hardened(&priv, &pub, t->m, t->mlen, sig, &siglen, modbits, t->hash); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

158

ret = are_equal(t->res, sig, t->reslen, &cmp); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

166

ret = gen_hash_get_hash_sizes(t->hash, &digestsize, &blocksize); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

168

ret = rsassa_pss_verify(&pub, t->m, t->mlen, t->res, (u16)(t->reslen), modbits, t->hash, t->hash, digestsize); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

172

ret = rsassa_pss_verify(&pub, t->m, t->mlen, t->res, (u16)(t->reslen), modbits, t->hash, t->hash, t->saltlen); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

178

ret = rsassa_pss_sign(&priv, t->m, t->mlen, sig, &siglen, modbits, t->hash, t->hash, t->saltlen, t->salt); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

182

ret = are_equal(t->res, sig, t->reslen, &cmp); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

185

ret = rsassa_pss_sign_hardened(&priv, &pub, t->m, t->mlen, sig, &siglen, modbits, t->hash, t->hash, t->saltlen, t->salt); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

188

ret = are_equal(t->res, sig, t->reslen, &cmp); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

67

ret = rsa_import_pub_key(&pub, t->n, (u16)t->nlen, t->e, (u16)t->elen); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

75

ret = rsa_import_simple_priv_key(&priv, t->n, (u16)t->nlen, t->d, (u16)t->dlen, NULL, 0, NULL, 0); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

77

ret = rsa_import_simple_priv_key(&priv_pq, t->n, (u16)t->nlen, t->d, (u16)t->dlen, t_->p, (u16)t_->plen, t_->q, (u16)t_->qlen); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

81

ret = rsa_import_crt_priv_key(&priv, t->p, (u16)t->plen, t->q, (u16)t->qlen, t->dP, (u16)t->dPlen, t->dQ, (u16)t->dQlen, t->qInv, (u16)t->qInvlen, NULL, NULL, 0); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

85

ret = local_memcpy(&priv, &priv_pq, sizeof(rsa_priv_key)); EG(ret, err);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

94

ret = rsaes_pkcs1_v1_5_encrypt(&pub, t->m, t->mlen, cipher, &clen, modbits, t->salt, t->saltlen); EG(ret, err1);

crypto/libecc/src/examples/sig/rsa/rsa_tests.h

97

ret = are_equal(t->res, cipher, t->reslen, &cmp); EG(ret, err1);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

119

ret = local_memset(pi_buf, 0, sizeof(pi_buf)); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

128

ret = nn_check_initialized(p); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

129

ret = nn_check_initialized(q); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

130

ret = nn_check_initialized(g); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

131

ret = nn_check_initialized(x); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

134

ret = nn_bitlen(p, &alpha); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

136

ret = nn_bitlen(q, &beta); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

138

ret = gen_hash_get_hash_sizes(sdsa_hash, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

150

ret = _os2ip(&k, nonce, noncelen); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

153

ret = nn_get_random_mod(&k, q); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

157

ret = nn_copy(&k_, &k); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

160

ret = _blind_scalar(&k_, q, &k_); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

162

ret = _fix_scalar_msb(&k_, q, &k_); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

166

ret = nn_init(pi, 0); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

168

ret = nn_mod_pow(pi, g, &k_, p); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

172

ret = _i2osp(pi, pi_buf, (u16)BYTECEIL(alpha)); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

175

ret = gen_hash_init(&hash_ctx, sdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

176

ret = gen_hash_update(&hash_ctx, pi_buf, (u16)BYTECEIL(alpha), sdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

177

ret = gen_hash_update(&hash_ctx, msg, msglen, sdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

179

ret = gen_hash_final(&hash_ctx, sig, sdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

182

ret = _os2ip(&r, sig, hlen); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

183

ret = nn_mod(&r, &r, q); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

186

ret = nn_iszero(&r, &iszero); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

195

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

197

ret = nn_mod_mul(&r, &r, &b, q); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

199

ret = nn_mod_mul(&k, &k, &b, q); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

205

ret = nn_modinv_fermat(&b, &b, q); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

209

ret = nn_mod_mul(&s, &r, x, q); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

210

ret = nn_mod_add(&s, &s, &k, q); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

214

ret = nn_mod_mul(&s, &s, &b, q); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

217

ret = nn_iszero(&s, &iszero); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

223

ret = _i2osp(&s, sig + hlen, (u16)(siglen - hlen)); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

278

ret = local_memset(pi_buf, 0, sizeof(pi_buf)); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

279

ret = local_memset(hash, 0, sizeof(hash)); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

288

ret = nn_check_initialized(p); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

289

ret = nn_check_initialized(q); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

290

ret = nn_check_initialized(g); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

291

ret = nn_check_initialized(y); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

294

ret = nn_bitlen(p, &alpha); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

296

ret = nn_bitlen(q, &beta); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

298

ret = gen_hash_get_hash_sizes(sdsa_hash, &hlen, &block_size); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

305

ret = _os2ip(&r, sig, hlen); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

306

ret = _os2ip(&s, sig + hlen, (u16)(siglen - hlen)); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

309

ret = nn_iszero(&r, &iszero); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

311

ret = nn_iszero(&s, &iszero); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

314

ret = nn_cmp(&s, q, &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

318

ret = nn_mod(&r, &r, q); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

321

ret = nn_init(&u, 0); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

322

ret = nn_init(&pi, 0); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

328

ret = nn_sub(&r, q, &r); EG(ret, err); /* compute -r = (q - r) mod q */

crypto/libecc/src/examples/sig/sdsa/sdsa.c

329

ret = _nn_mod_pow_insecure(&u, y, &r, p); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

331

ret = _nn_mod_pow_insecure(&pi, g, &s, p); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

333

ret = nn_mod_mul(&pi, &pi, &u, p); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

338

ret = _i2osp(&pi, pi_buf, (u16)BYTECEIL(alpha)); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

340

ret = gen_hash_init(&hash_ctx, sdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

341

ret = gen_hash_update(&hash_ctx, pi_buf, (u16)BYTECEIL(alpha), sdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

342

ret = gen_hash_update(&hash_ctx, msg, msglen, sdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

343

ret = gen_hash_final(&hash_ctx, hash, sdsa_hash); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

346

ret = are_equal(sig, hash, hlen, &cmp); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

451

ret = sdsa_import_priv_key(&priv, p, sizeof(p), q, sizeof(q), g, sizeof(g), x, sizeof(x)); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

452

ret = sdsa_import_pub_key(&pub, p, sizeof(p), q, sizeof(q), g, sizeof(g), y, sizeof(y)); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

453

ret = sdsa_compute_pub_from_priv(&pub2, &priv); EG(ret, err);

crypto/libecc/src/examples/sig/sdsa/sdsa.c

457

ret = sdsa_sign(&priv, msg, sizeof(msg)-1, nonce, sizeof(nonce), sig, sizeof(sig), HASH_SHA256); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

100

ret = local_memset(C, 0, sizeof(C)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

106

ret = hmac(seed, SSS_SECRET_SIZE, SHA512, C, sizeof(C), hmac_val, &len); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

108

ret = nn_init_from_buf(&nn_val, hmac_val, len); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

110

ret = nn_mod(&nn_val, &nn_val, &(out->ctx->p)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

140

ret = local_memset(secret_seed, 0, sizeof(secret_seed)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

150

ret = nn_init_from_buf(&p, prime, sizeof(prime)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

151

ret = fp_ctx_init_from_p(&ctx, &p); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

156

ret = get_random(secret_seed, sizeof(secret_seed)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

175

ret = fp_init(&a0, &ctx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

181

ret = fp_import_from_buf(&a0, secret->secret, SSS_SECRET_SIZE); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

185

ret = _sss_derive_seed(&a0, secret_seed, 0); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

192

ret = fp_init(&base, &ctx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

193

ret = fp_init(&exp, &ctx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

194

ret = fp_init(&tmp, &ctx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

195

ret = fp_init(&s, &ctx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

196

ret = fp_init(&a, &ctx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

198

ret = fp_get_random(&blind, &ctx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

199

ret = fp_init(&blind_inv, &ctx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

200

ret = fp_inv(&blind_inv, &blind); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

210

ret = get_random((u8*)&idx_shift, sizeof(idx_shift)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

223

ret = fp_mul(&s, &blind, &a0); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

225

ret = fp_set_word_value(&base, (word_t)curr_idx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

227

ret = fp_one(&exp); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

230

ret = fp_mul_monty(&exp, &exp, &base); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

232

ret = _sss_derive_seed(&a, secret_seed, (u16)j); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

234

ret = fp_mul_monty(&a, &a, &blind); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

248

ret = fp_mul_monty(&tmp, &exp, &a); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

249

ret = fp_add(&s, &s, &tmp); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

254

ret = fp_mul(&s, &s, &blind_inv); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

255

ret = fp_export_to_buf(cur_share_i->share, SSS_SECRET_SIZE, &s); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

308

ret = nn_init_from_buf(&p, prime, sizeof(prime)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

309

ret = fp_ctx_init_from_p(&ctx, &p); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

312

ret = fp_init(&s, &ctx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

313

ret = fp_init(&y, &ctx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

314

ret = fp_init(&x_i, &ctx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

315

ret = fp_init(&x_j, &ctx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

316

ret = fp_init(&tmp, &ctx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

317

ret = fp_init(&tmp2, &ctx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

325

ret = fp_init(&x, &ctx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

326

ret = fp_set_word_value(&x, (word_t)val); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

329

ret = fp_get_random(&blind, &ctx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

330

ret = fp_init(&blind_inv, &ctx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

331

ret = fp_inv(&blind_inv, &blind); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

335

ret = fp_init(&r_inv, &ctx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

336

ret = fp_set_nn(&r_inv, &(ctx.r)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

337

ret = fp_inv(&r_inv, &r_inv); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

343

ret = fp_import_from_buf(&s, cur_share_i->share, SSS_SECRET_SIZE); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

345

ret = fp_mul_monty(&s, &s, &blind); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

348

ret = fp_set_word_value(&x_i, (word_t)(curr_idx)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

350

ret = fp_copy(&tmp2, &r_inv); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

358

ret = fp_set_word_value(&x_j, (word_t)(curr_idx)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

361

ret = fp_sub(&tmp, &x_j, &x); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

362

ret = fp_mul_monty(&s, &s, &tmp); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

371

ret = fp_mul_monty(&s, &s, &x_j); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

373

ret = fp_sub(&tmp, &x_j, &x_i); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

374

ret = fp_mul_monty(&tmp2, &tmp2, &tmp); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

378

ret = fp_inv(&tmp, &tmp2); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

379

ret = fp_mul_monty(&s, &s, &tmp); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

381

ret = fp_add(&y, &y, &s); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

384

ret = fp_redcify(&y, &y); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

385

ret = fp_mul(&y, &y, &blind_inv); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

433

ret = local_memset(session_id, 0, sizeof(session_id)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

436

ret = _sss_raw_generate(shares, k, n, secret, input_secret); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

443

ret = get_random(session_id, sizeof(session_id)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

457

ret = local_memcpy(cur_id, session_id, SSS_SESSION_ID_SIZE); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

460

ret = hmac_scattered((const u8*)secret, SSS_SECRET_SIZE, SHA256, inputs, ilens, cur_share_hmac, &len); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

483

ret = local_memset(hmac_val, 0, sizeof(hmac_val)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

486

ret = _sss_raw_combine(shares, k, secret); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

501

ret = are_equal(cur_id, cur_id0, SSS_SESSION_ID_SIZE, &cmp); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

511

ret = hmac_scattered((const u8*)secret, SSS_SECRET_SIZE, SHA256, inputs, ilens, hmac_val, &len); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

514

ret = are_equal(hmac_val, cur_share_hmac, len, &cmp); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

552

ret = local_memset(hmac_val, 0, sizeof(hmac_val)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

555

ret = _sss_raw_lagrange(shares, k, secret, 0); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

569

ret = are_equal(cur_id, cur_id0, SSS_SESSION_ID_SIZE, &cmp); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

582

ret = hmac_scattered((const u8*)secret, SSS_SECRET_SIZE, SHA256, inputs, ilens, hmac_val, &len); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

583

ret = are_equal(hmac_val, cur_share_hmac, len, &cmp); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

628

ret = local_memcpy(cur_id, cur_id0, SSS_SESSION_ID_SIZE); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

630

ret = _sss_raw_lagrange(shares, k, (sss_secret*)(cur_share->share), curr_idx); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

635

ret = hmac_scattered((const u8*)secret, SSS_SECRET_SIZE, SHA256, inputs, ilens, cur_share_hmac, &len); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

668

ret = local_memset(&secret, 0x00, sizeof(secret)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

676

buf_print(" secret", (u8*)&secret, SSS_SECRET_SIZE); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

685

ret = local_memset(&secret, 0x00, sizeof(secret)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

697

ret = local_memset(&secret, 0x00, sizeof(secret)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

710

ret = local_memset(&secret, 0x00, sizeof(secret)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

721

ret = local_memset(&secret, 0x00, sizeof(secret)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

732

ret = local_memset(&secret, 0x00, sizeof(secret)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

733

ret = sss_regenerate(shares, K, MAX_N, &secret); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

747

ret = local_memset(&secret, 0x00, sizeof(secret)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

758

ret = local_memset(&secret, 0x00, sizeof(secret)); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

97

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/examples/sss/sss.c

99

ret = local_memset(hmac_val, 0, sizeof(hmac_val)); EG(ret, err);

crypto/libecc/src/fp/fp.c

100

ret = nn_init(&r, 0); EG(ret, err);

crypto/libecc/src/fp/fp.c

101

ret = nn_init(&r_square, 0); EG(ret, err);

crypto/libecc/src/fp/fp.c

102

ret = nn_init(&p_normalized, 0); EG(ret, err);

crypto/libecc/src/fp/fp.c

111

ret = nn_set_wlen(&p, 2); EG(ret, err);

crypto/libecc/src/fp/fp.c

114

ret = nn_compute_redc1_coefs(&r, &r_square, &p, &mpinv); EG(ret, err);

crypto/libecc/src/fp/fp.c

115

ret = nn_compute_div_coefs(&p_normalized, &p_shift, &p_reciprocal, &p); EG(ret, err);

crypto/libecc/src/fp/fp.c

116

ret = nn_bitlen(p_in, &p_bitlen); EG(ret, err);

crypto/libecc/src/fp/fp.c

156

ret = fp_ctx_check_initialized(fpctx); EG(ret, err);

crypto/libecc/src/fp/fp.c

157

ret = nn_init(&(in->fp_val), (u16)((fpctx->p.wlen) * WORD_BYTES)); EG(ret, err);

crypto/libecc/src/fp/fp.c

175

ret = fp_ctx_check_initialized(fpctx); EG(ret, err);

crypto/libecc/src/fp/fp.c

176

ret = fp_init(in, fpctx); EG(ret, err);

crypto/libecc/src/fp/fp.c

210

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp.c

211

ret = nn_check_initialized(in); EG(ret, err);

crypto/libecc/src/fp/fp.c

212

ret = nn_copy(&(out->fp_val), in); EG(ret, err);

crypto/libecc/src/fp/fp.c

213

ret = nn_cmp(&(out->fp_val), &(out->ctx->p), &cmp); EG(ret, err);

crypto/libecc/src/fp/fp.c

232

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp.c

233

ret = nn_set_word_value(&(out->fp_val), 0); EG(ret, err);

crypto/libecc/src/fp/fp.c

250

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp.c

252

ret = nn_isone(&(out->ctx->p), &isone); EG(ret, err);

crypto/libecc/src/fp/fp.c

256

ret = nn_set_word_value(&(out->fp_val), val); EG(ret, err);

crypto/libecc/src/fp/fp.c

270

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp.c

273

ret = nn_cmp_word(&(out->ctx->p), val, &cmp); EG(ret, err);

crypto/libecc/src/fp/fp.c

277

ret = nn_set_word_value(&(out->fp_val), val); EG(ret, err);

crypto/libecc/src/fp/fp.c

298

ret = fp_check_initialized(in1); EG(ret, err);

crypto/libecc/src/fp/fp.c

299

ret = fp_check_initialized(in2); EG(ret, err);

crypto/libecc/src/fp/fp.c

314

ret = fp_check_initialized(in); EG(ret, err);

crypto/libecc/src/fp/fp.c

334

ret = fp_check_initialized(in); EG(ret, err);

crypto/libecc/src/fp/fp.c

341

ret = fp_init(out, in->ctx); EG(ret, err);

crypto/libecc/src/fp/fp.c

376

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp.c

384

ret = nn_zero(&(out->fp_val)); EG(ret, err);

crypto/libecc/src/fp/fp.c

389

ret = fp_check_initialized(tab[k]); EG(ret, err);

crypto/libecc/src/fp/fp.c

420

ret = fp_check_initialized(in1); EG(ret, err);

crypto/libecc/src/fp/fp.c

421

ret = fp_check_initialized(in2); EG(ret, err);

crypto/libecc/src/fp/fp.c

424

ret = fp_init(&opp, in1->ctx); EG(ret, err);

crypto/libecc/src/fp/fp.c

425

ret = fp_neg(&opp, in2); EG(ret, err);

crypto/libecc/src/fp/fp.c

426

ret = nn_cmp(&(in1->fp_val), &(in2->fp_val), &cmp_eq); EG(ret, err);

crypto/libecc/src/fp/fp.c

427

ret = nn_cmp(&(in1->fp_val), &(opp.fp_val), &cmp_opp); EG(ret, err);

crypto/libecc/src/fp/fp.c

448

ret = fp_check_initialized(out_fp); EG(ret, err);

crypto/libecc/src/fp/fp.c

449

ret = nn_init_from_buf(&(out_fp->fp_val), buf, buflen); EG(ret, err);

crypto/libecc/src/fp/fp.c

450

ret = nn_cmp(&(out_fp->fp_val), &(out_fp->ctx->p), &cmp); EG(ret, err);

crypto/libecc/src/fp/fp.c

465

ret = fp_check_initialized(in_fp); EG(ret, err);

crypto/libecc/src/fp/fp.c

62

ret = nn_check_initialized(p); EG(ret, err);

crypto/libecc/src/fp/fp.c

63

ret = nn_check_initialized(r); EG(ret, err);

crypto/libecc/src/fp/fp.c

64

ret = nn_check_initialized(r_square); EG(ret, err);

crypto/libecc/src/fp/fp.c

65

ret = nn_check_initialized(p_normalized); EG(ret, err);

crypto/libecc/src/fp/fp.c

67

ret = nn_copy(&(ctx->p), p); EG(ret, err);

crypto/libecc/src/fp/fp.c

72

ret = nn_copy(&(ctx->p_normalized), p_normalized); EG(ret, err);

crypto/libecc/src/fp/fp.c

73

ret = nn_copy(&(ctx->r), r); EG(ret, err);

crypto/libecc/src/fp/fp.c

74

ret = nn_copy(&(ctx->r_square), r_square); EG(ret, err);

crypto/libecc/src/fp/fp.c

96

ret = nn_check_initialized(p_in); EG(ret, err);

crypto/libecc/src/fp/fp.c

98

ret = nn_init(&p, 0); EG(ret, err);

crypto/libecc/src/fp/fp.c

99

ret = nn_copy(&p, p_in); EG(ret, err);

crypto/libecc/src/fp/fp_add.c

106

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp_add.c

107

ret = fp_check_initialized(in); EG(ret, err);

crypto/libecc/src/fp/fp_add.c

129

ret = fp_check_initialized(in); EG(ret, err);

crypto/libecc/src/fp/fp_add.c

130

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp_add.c

29

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp_add.c

30

ret = fp_check_initialized(in1); EG(ret, err);

crypto/libecc/src/fp/fp_add.c

31

ret = fp_check_initialized(in2); EG(ret, err);

crypto/libecc/src/fp/fp_add.c

56

ret = fp_check_initialized(in); EG(ret, err);

crypto/libecc/src/fp/fp_add.c

57

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp_add.c

79

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp_add.c

80

ret = fp_check_initialized(in1); EG(ret, err);

crypto/libecc/src/fp/fp_add.c

81

ret = fp_check_initialized(in2); EG(ret, err);

crypto/libecc/src/fp/fp_montgomery.c

77

ret = fp_check_initialized(in1); EG(ret, err);

crypto/libecc/src/fp/fp_montgomery.c

78

ret = fp_check_initialized(in2); EG(ret, err);

crypto/libecc/src/fp/fp_montgomery.c

79

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp_montgomery.c

86

ret = fp_div(out, in1, in2); EG(ret, err);

crypto/libecc/src/fp/fp_mul.c

111

ret = fp_check_initialized(num); EG(ret, err);

crypto/libecc/src/fp/fp_mul.c

112

ret = fp_check_initialized(den); EG(ret, err);

crypto/libecc/src/fp/fp_mul.c

113

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp_mul.c

123

ret = fp_copy(&_num, num); EG(ret, err1);

crypto/libecc/src/fp/fp_mul.c

124

ret = fp_inv(out, den); EG(ret, err1);

crypto/libecc/src/fp/fp_mul.c

129

EG(ret, err);

crypto/libecc/src/fp/fp_mul.c

132

ret = fp_inv(out, den); EG(ret, err);

crypto/libecc/src/fp/fp_mul.c

34

ret = fp_check_initialized(in1); EG(ret, err);

crypto/libecc/src/fp/fp_mul.c

35

ret = fp_check_initialized(in2); EG(ret, err);

crypto/libecc/src/fp/fp_mul.c

36

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp_mul.c

41

ret = nn_mul(&(out->fp_val), &(in1->fp_val), &(in2->fp_val)); EG(ret, err);

crypto/libecc/src/fp/fp_mul.c

73

ret = fp_check_initialized(in); EG(ret, err);

crypto/libecc/src/fp/fp_mul.c

74

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp_mul.c

93

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp_mul_redc1.c

102

ret = fp_check_initialized(in); EG(ret, err);

crypto/libecc/src/fp/fp_mul_redc1.c

103

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp_mul_redc1.c

104

ret = nn_init(&one, 0); EG(ret, err);

crypto/libecc/src/fp/fp_mul_redc1.c

105

ret = nn_one(&one); EG(ret, err);

crypto/libecc/src/fp/fp_mul_redc1.c

43

ret = fp_check_initialized(in1); EG(ret, err);

crypto/libecc/src/fp/fp_mul_redc1.c

44

ret = fp_check_initialized(in2); EG(ret, err);

crypto/libecc/src/fp/fp_mul_redc1.c

45

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp_mul_redc1.c

78

ret = fp_check_initialized(in); EG(ret, err);

crypto/libecc/src/fp/fp_mul_redc1.c

79

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp_pow.c

45

ret = fp_init(&base, out->ctx); EG(ret, err);

crypto/libecc/src/fp/fp_pow.c

46

ret = fp_copy(&base, out); EG(ret, err);

crypto/libecc/src/fp/fp_pow.c

47

ret = _fp_pow(out, &base, exp); EG(ret, err);

crypto/libecc/src/fp/fp_pow.c

65

ret = fp_check_initialized(base); EG(ret, err);

crypto/libecc/src/fp/fp_pow.c

66

ret = nn_check_initialized(exp); EG(ret, err);

crypto/libecc/src/fp/fp_pow.c

67

ret = fp_check_initialized(out); EG(ret, err);

crypto/libecc/src/fp/fp_rand.c

29

ret = fp_init(out, ctx); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

122

ret = nn_init(&q, 0); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

123

ret = nn_init(&s, 0); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

124

ret = nn_init(&tmp_nn, 0); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

125

ret = nn_init(&one_nn, 0); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

126

ret = nn_init(&two_nn, 0); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

127

ret = nn_init(&m, 0); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

128

ret = nn_init(&i, 0); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

129

ret = fp_init(&z, n->ctx); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

130

ret = fp_init(&t, n->ctx); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

131

ret = fp_init(&b, n->ctx); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

132

ret = fp_init(&r, n->ctx); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

133

ret = fp_init(&c, n->ctx); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

134

ret = fp_init(&one_fp, n->ctx); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

135

ret = fp_init(&tmp_fp, n->ctx); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

138

ret = fp_copy(_n, n); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

141

ret = fp_init(sqrt1, _n->ctx); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

142

ret = fp_init(sqrt2, _n->ctx); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

145

ret = nn_one(&one_nn); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

147

ret = nn_set_word_value(&two_nn, WORD(2)); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

150

ret = nn_cmp(&(_n->ctx->p), &two_nn, &cmp); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

152

ret = fp_copy(sqrt1, _n); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

153

ret = fp_copy(sqrt2, _n); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

159

ret = fp_iszero(_n, &iszero); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

161

ret = fp_zero(sqrt1); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

162

ret = fp_zero(sqrt2); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

174

ret = nn_zero(&s); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

176

ret = nn_copy(&q, &(_n->ctx->p)); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

177

ret = nn_dec(&q, &q); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

180

ret = nn_divrem(&tmp_nn, &i, &q, &two_nn); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

181

ret = nn_inc(&s, &s); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

182

ret = nn_copy(&q, &tmp_nn); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

184

ret = nn_isodd(&q, &isodd); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

190

ret = nn_cmp(&s, &one_nn, &cmp); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

192

ret = nn_inc(&tmp_nn, &(_n->ctx->p)); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

193

ret = nn_rshift(&tmp_nn, &tmp_nn, 2); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

194

ret = fp_pow(sqrt1, _n, &tmp_nn); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

195

ret = fp_neg(sqrt2, sqrt1); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

200

ret = fp_zero(&z); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

202

ret = fp_inc(&z, &z); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

204

ret = fp_pow(&c, &z, &q); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

206

ret = nn_inc(&tmp_nn, &q); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

207

ret = nn_rshift(&tmp_nn, &tmp_nn, 1); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

208

ret = fp_pow(&r, _n, &tmp_nn); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

209

ret = fp_pow(&t, _n, &q); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

210

ret = nn_copy(&m, &s); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

211

ret = fp_one(&one_fp); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

216

ret = fp_cmp(&t, &one_fp, &cmp); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

218

ret = fp_copy(sqrt1, &r); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

219

ret = fp_neg(sqrt2, sqrt1); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

224

ret = nn_one(&i); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

225

ret = fp_copy(&tmp_fp, &t); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

227

ret = fp_sqr(&tmp_fp, &tmp_fp); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

228

ret = fp_cmp(&tmp_fp, &one_fp, &cmp); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

232

ret = nn_inc(&i, &i); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

233

ret = nn_cmp(&i, &m, &cmp); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

241

ret = nn_sub(&tmp_nn, &m, &i); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

242

ret = nn_dec(&tmp_nn, &tmp_nn); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

243

ret = fp_copy(&b, &c); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

244

ret = nn_iszero(&tmp_nn, &iszero); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

246

ret = fp_sqr(&b, &b); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

247

ret = nn_dec(&tmp_nn, &tmp_nn); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

248

ret = nn_iszero(&tmp_nn, &iszero); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

251

ret = fp_mul(&r, &r, &b); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

253

ret = fp_sqr(&c, &b); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

255

ret = fp_mul(&t, &t, &c); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

257

ret = nn_copy(&m, &i); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

36

ret = fp_check_initialized(a); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

37

ret = fp_init(&pow, a->ctx); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

38

ret = fp_init(&one, a->ctx); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

39

ret = nn_init(&exp, 0); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

44

ret = fp_init(&pow, a->ctx); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

45

ret = fp_init(&one, a->ctx); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

46

ret = nn_init(&exp, 0); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

49

ret = fp_one(&one); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

55

ret = nn_dec(&exp, &(a->ctx->p)); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

56

ret = nn_rshift(&exp, &exp, 1); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

61

ret = fp_pow(&pow, a, &exp); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

63

ret = fp_iszero(&pow, &iszero); EG(ret, err);

crypto/libecc/src/fp/fp_sqrt.c

64

ret = fp_cmp(&pow, &one, &cmp); EG(ret, err);

crypto/libecc/src/hash/bash.c

120

ret = local_memset(state + pos, 0, (u8)((ctx->bash_block_size) - pos)); EG(ret, err);

crypto/libecc/src/hash/bash.c

126

ret = local_memcpy(output, state, ctx->bash_digest_size); EG(ret, err);

crypto/libecc/src/hash/bash.c

39

ret = local_memset(state, 0, sizeof(ctx->bash_state)); EG(ret, err);

crypto/libecc/src/hash/bash.c

84

ret = local_memcpy(state + left, data_ptr, fill); EG(ret, err);

crypto/libecc/src/hash/bash.c

91

ret = local_memcpy(state, data_ptr, ctx->bash_block_size); EG(ret, err);

crypto/libecc/src/hash/bash.c

97

ret = local_memcpy(state + left, data_ptr, remain_ilen); EG(ret, err);

crypto/libecc/src/hash/bash224.c

21

ret = _bash_init(ctx, BASH224_DIGEST_SIZE); EG(ret, err);

crypto/libecc/src/hash/bash224.c

50

ret = _bash_finalize((bash_context *)ctx, output); EG(ret, err);

crypto/libecc/src/hash/bash224.c

74

ret = bash224_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/bash224.c

77

ret = bash224_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/hash/bash224.c

96

ret = bash224_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/bash224.c

97

ret = bash224_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/bash256.c

21

ret = _bash_init(ctx, BASH256_DIGEST_SIZE); EG(ret, err);

crypto/libecc/src/hash/bash256.c

50

ret = _bash_finalize((bash_context *)ctx, output); EG(ret, err);

crypto/libecc/src/hash/bash256.c

74

ret = bash256_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/bash256.c

77

ret = bash256_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/hash/bash256.c

96

ret = bash256_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/bash256.c

97

ret = bash256_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/bash256.c

98

ret = bash256_final(&ctx, output); EG(ret, err);

crypto/libecc/src/hash/bash384.c

100

ret = bash384_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/bash384.c

101

ret = bash384_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/bash384.c

21

ret = _bash_init(ctx, BASH384_DIGEST_SIZE); EG(ret, err);

crypto/libecc/src/hash/bash384.c

50

ret = _bash_finalize((bash_context *)ctx, output); EG(ret, err);

crypto/libecc/src/hash/bash384.c

74

ret = bash384_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/bash384.c

80

ret = bash384_update(&ctx, buf, buflen); EG(ret, err);

crypto/libecc/src/hash/bash512.c

21

ret = _bash_init(ctx, BASH512_DIGEST_SIZE); EG(ret, err);

crypto/libecc/src/hash/bash512.c

50

ret = _bash_finalize((bash_context *)ctx, output); EG(ret, err);

crypto/libecc/src/hash/bash512.c

74

ret = bash512_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/bash512.c

77

ret = bash512_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/hash/bash512.c

96

ret = bash512_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/bash512.c

97

ret = bash512_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/belt-hash.c

315

ret = local_memset(ctx->belt_hash_state, 0, sizeof(ctx->belt_hash_state)); EG(ret, err);

crypto/libecc/src/hash/belt-hash.c

357

ret = local_memcpy(ctx->belt_hash_buffer + left, data_ptr, fill); EG(ret, err);

crypto/libecc/src/hash/belt-hash.c

361

ret = belt_hash_process(ctx, ctx->belt_hash_buffer); EG(ret, err);

crypto/libecc/src/hash/belt-hash.c

371

ret = belt_hash_process(ctx, data_ptr); EG(ret, err);

crypto/libecc/src/hash/belt-hash.c

377

ret = local_memcpy(ctx->belt_hash_buffer + left, data_ptr, remain_ilen); EG(ret, err);

crypto/libecc/src/hash/belt-hash.c

405

ret = belt_hash_process(ctx, ctx->belt_hash_buffer); EG(ret, err);

crypto/libecc/src/hash/belt-hash.c

409

ret = belt_hash_finalize(ctx->belt_hash_state, ctx->belt_hash_h, output); EG(ret, err);

crypto/libecc/src/hash/belt-hash.c

434

ret = belt_hash_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/belt-hash.c

437

ret = belt_hash_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/hash/belt-hash.c

456

ret = belt_hash_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/belt-hash.c

457

ret = belt_hash_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/hmac.c

117

ret = hash_mapping_callbacks_sanity_check(h); EG(ret, err);

crypto/libecc/src/hash/hmac.c

118

ret = h->hfunc_finalize(&(ctx->in_ctx), in_hash); EG(ret, err);

crypto/libecc/src/hash/hmac.c

119

ret = h->hfunc_update(&(ctx->out_ctx), in_hash, h->digest_size); EG(ret, err);

crypto/libecc/src/hash/hmac.c

120

ret = h->hfunc_finalize(&(ctx->out_ctx), output); EG(ret, err);

crypto/libecc/src/hash/hmac.c

142

ret = hmac_init(&ctx, hmackey, hmackey_len, hash_type); EG(ret, err);

crypto/libecc/src/hash/hmac.c

143

ret = hmac_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/hmac.c

162

ret = hmac_init(&ctx, hmackey, hmackey_len, hash_type); EG(ret, err);

crypto/libecc/src/hash/hmac.c

165

ret = hmac_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/hash/hmac.c

28

ret = local_memset(local_hmac_key, 0, sizeof(local_hmac_key)); EG(ret, err);

crypto/libecc/src/hash/hmac.c

30

ret = local_memset(ipad, 0x36, sizeof(ipad)); EG(ret, err);

crypto/libecc/src/hash/hmac.c

31

ret = local_memset(opad, 0x5c, sizeof(opad)); EG(ret, err);

crypto/libecc/src/hash/hmac.c

34

ret = get_hash_by_type(hash_type, &(ctx->hash)); EG(ret, err);

crypto/libecc/src/hash/hmac.c

42

ret = local_memcpy(local_hmac_key, hmackey, hmackey_len); EG(ret, err);

crypto/libecc/src/hash/hmac.c

51

ret = hash_mapping_callbacks_sanity_check(h); EG(ret, err);

crypto/libecc/src/hash/hmac.c

52

ret = h->hfunc_init(&tmp_ctx); EG(ret, err);

crypto/libecc/src/hash/hmac.c

53

ret = h->hfunc_update(&tmp_ctx, hmackey, hmackey_len); EG(ret, err);

crypto/libecc/src/hash/hmac.c

54

ret = h->hfunc_finalize(&tmp_ctx, local_hmac_key); EG(ret, err);

crypto/libecc/src/hash/hmac.c

60

ret = hash_mapping_callbacks_sanity_check(h); EG(ret, err);

crypto/libecc/src/hash/hmac.c

61

ret = h->hfunc_init(&(ctx->in_ctx)); EG(ret, err);

crypto/libecc/src/hash/hmac.c

63

ret = hash_mapping_callbacks_sanity_check(h); EG(ret, err);

crypto/libecc/src/hash/hmac.c

64

ret = h->hfunc_init(&(ctx->out_ctx)); EG(ret, err);

crypto/libecc/src/hash/hmac.c

70

ret = h->hfunc_update(&(ctx->in_ctx), ipad, h->block_size); EG(ret, err);

crypto/libecc/src/hash/hmac.c

75

ret = h->hfunc_update(&(ctx->out_ctx), opad, h->block_size); EG(ret, err);

crypto/libecc/src/hash/hmac.c

95

ret = hash_mapping_callbacks_sanity_check(h); EG(ret, err);

crypto/libecc/src/hash/hmac.c

96

ret = h->hfunc_update(&(ctx->in_ctx), input, ilen); EG(ret, err);

crypto/libecc/src/hash/ripemd160.c

231

ret = local_memcpy(ctx->ripemd160_buffer + left, data_ptr, fill); EG(ret, err);

crypto/libecc/src/hash/ripemd160.c

232

ret = ripemd160_process(ctx, ctx->ripemd160_buffer); EG(ret, err);

crypto/libecc/src/hash/ripemd160.c

239

ret = ripemd160_process(ctx, data_ptr); EG(ret, err);

crypto/libecc/src/hash/ripemd160.c

245

ret = local_memcpy(ctx->ripemd160_buffer + left, data_ptr, remain_ilen); EG(ret, err);

crypto/libecc/src/hash/ripemd160.c

265

ret = local_memset(last_padded_block, 0, sizeof(last_padded_block)); EG(ret, err);

crypto/libecc/src/hash/ripemd160.c

272

block_present); EG(ret, err);

crypto/libecc/src/hash/ripemd160.c

283

ret = ripemd160_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/hash/ripemd160.c

284

ret = ripemd160_process(ctx, last_padded_block + RIPEMD160_BLOCK_SIZE); EG(ret, err);

crypto/libecc/src/hash/ripemd160.c

289

ret = ripemd160_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/hash/ripemd160.c

316

ret = ripemd160_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/ripemd160.c

319

ret = ripemd160_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/hash/ripemd160.c

334

ret = ripemd160_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/ripemd160.c

335

ret = ripemd160_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/sha224.c

121

ret = local_memcpy(ctx->sha224_buffer + left, data_ptr, fill); EG(ret, err);

crypto/libecc/src/hash/sha224.c

122

ret = sha224_process(ctx, ctx->sha224_buffer); EG(ret, err);

crypto/libecc/src/hash/sha224.c

129

ret = sha224_process(ctx, data_ptr); EG(ret, err);

crypto/libecc/src/hash/sha224.c

135

ret = local_memcpy(ctx->sha224_buffer + left, data_ptr, remain_ilen); EG(ret, err);

crypto/libecc/src/hash/sha224.c

155

ret = local_memset(last_padded_block, 0, sizeof(last_padded_block)); EG(ret, err);

crypto/libecc/src/hash/sha224.c

162

block_present); EG(ret, err);

crypto/libecc/src/hash/sha224.c

173

ret = sha224_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/hash/sha224.c

174

ret = sha224_process(ctx, last_padded_block + SHA224_BLOCK_SIZE); EG(ret, err);

crypto/libecc/src/hash/sha224.c

179

ret = sha224_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/hash/sha224.c

214

ret = sha224_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha224.c

217

ret = sha224_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/hash/sha224.c

236

ret = sha224_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha224.c

237

ret = sha224_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/sha256.c

121

ret = local_memcpy(ctx->sha256_buffer + left, data_ptr, fill); EG(ret, err);

crypto/libecc/src/hash/sha256.c

122

ret = sha256_process(ctx, ctx->sha256_buffer); EG(ret, err);

crypto/libecc/src/hash/sha256.c

129

ret = sha256_process(ctx, data_ptr); EG(ret, err);

crypto/libecc/src/hash/sha256.c

135

ret = local_memcpy(ctx->sha256_buffer + left, data_ptr, remain_ilen); EG(ret, err);

crypto/libecc/src/hash/sha256.c

155

ret = local_memset(last_padded_block, 0, sizeof(last_padded_block)); EG(ret, err);

crypto/libecc/src/hash/sha256.c

162

block_present); EG(ret, err);

crypto/libecc/src/hash/sha256.c

173

ret = sha256_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/hash/sha256.c

174

ret = sha256_process(ctx, last_padded_block + SHA256_BLOCK_SIZE); EG(ret, err);

crypto/libecc/src/hash/sha256.c

179

ret = sha256_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/hash/sha256.c

209

ret = sha256_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha256.c

212

ret = sha256_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/hash/sha256.c

227

ret = sha256_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha256.c

228

ret = sha256_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/sha3-224.c

101

ret = sha3_224_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha3-224.c

102

ret = sha3_224_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/sha3-224.c

26

ret = _sha3_init(ctx, SHA3_224_DIGEST_SIZE); EG(ret, err);

crypto/libecc/src/hash/sha3-224.c

55

ret = _sha3_finalize((sha3_context *)ctx, output); EG(ret, err);

crypto/libecc/src/hash/sha3-224.c

79

ret = sha3_224_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha3-224.c

82

ret = sha3_224_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/hash/sha3-256.c

101

ret = sha3_256_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha3-256.c

102

ret = sha3_256_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/sha3-256.c

103

ret = sha3_256_final(&ctx, output); EG(ret, err);

crypto/libecc/src/hash/sha3-256.c

26

ret = _sha3_init(ctx, SHA3_256_DIGEST_SIZE); EG(ret, err);

crypto/libecc/src/hash/sha3-256.c

55

ret = _sha3_finalize((sha3_context *)ctx, output); EG(ret, err);

crypto/libecc/src/hash/sha3-256.c

79

ret = sha3_256_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha3-256.c

82

ret = sha3_256_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/hash/sha3-384.c

105

ret = sha3_384_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha3-384.c

106

ret = sha3_384_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/sha3-384.c

26

ret = _sha3_init(ctx, SHA3_384_DIGEST_SIZE); EG(ret, err);

crypto/libecc/src/hash/sha3-384.c

55

ret = _sha3_finalize((sha3_context *)ctx, output); EG(ret, err);

crypto/libecc/src/hash/sha3-384.c

79

ret = sha3_384_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha3-384.c

85

ret = sha3_384_update(&ctx, buf, buflen); EG(ret, err);

crypto/libecc/src/hash/sha3-512.c

101

ret = sha3_512_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha3-512.c

102

ret = sha3_512_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/sha3-512.c

26

ret = _sha3_init(ctx, SHA3_512_DIGEST_SIZE); EG(ret, err);

crypto/libecc/src/hash/sha3-512.c

55

ret = _sha3_finalize((sha3_context *)ctx, output); EG(ret, err);

crypto/libecc/src/hash/sha3-512.c

79

ret = sha3_512_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha3-512.c

82

ret = sha3_512_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/hash/sha3.c

36

ret = local_memset(ctx->sha3_state, 0, sizeof(ctx->sha3_state)); EG(ret, err);

crypto/libecc/src/hash/sha384.c

120

ret = local_memcpy(ctx->sha384_buffer + left, data_ptr, fill); EG(ret, err);

crypto/libecc/src/hash/sha384.c

121

ret = sha384_process(ctx, ctx->sha384_buffer); EG(ret, err);

crypto/libecc/src/hash/sha384.c

128

ret = sha384_process(ctx, data_ptr); EG(ret, err);

crypto/libecc/src/hash/sha384.c

134

ret = local_memcpy(ctx->sha384_buffer + left, data_ptr, remain_ilen); EG(ret, err);

crypto/libecc/src/hash/sha384.c

158

ret = local_memset(last_padded_block, 0, sizeof(last_padded_block)); EG(ret, err);

crypto/libecc/src/hash/sha384.c

165

block_present); EG(ret, err);

crypto/libecc/src/hash/sha384.c

177

ret = sha384_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/hash/sha384.c

178

ret = sha384_process(ctx, last_padded_block + SHA384_BLOCK_SIZE); EG(ret, err);

crypto/libecc/src/hash/sha384.c

184

ret = sha384_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/hash/sha384.c

219

ret = sha384_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha384.c

225

ret = sha384_update(&ctx, buf, buflen); EG(ret, err);

crypto/libecc/src/hash/sha384.c

241

ret = sha384_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha384.c

242

ret = sha384_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/sha512-224.c

110

ret = sha512_224_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha512-224.c

111

ret = sha512_224_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/sha512-224.c

66

ret = sha512_core_final(ctx, output, SHA512_224_DIGEST_SIZE); EG(ret, err);

crypto/libecc/src/hash/sha512-224.c

91

ret = sha512_224_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha512-224.c

94

ret = sha512_224_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/hash/sha512-256.c

110

ret = sha512_256_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha512-256.c

111

ret = sha512_256_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/sha512-256.c

67

ret = sha512_core_final(ctx, output, SHA512_256_DIGEST_SIZE); EG(ret, err);

crypto/libecc/src/hash/sha512-256.c

91

ret = sha512_256_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha512-256.c

94

ret = sha512_256_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/hash/sha512.c

111

ret = sha512_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha512.c

112

ret = sha512_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/sha512.c

67

ret = sha512_core_final(ctx, output, SHA512_DIGEST_SIZE); EG(ret, err);

crypto/libecc/src/hash/sha512.c

92

ret = sha512_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sha512.c

95

ret = sha512_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/hash/sha512_core.c

100

ret = sha512_core_process(ctx, data_ptr); EG(ret, err);

crypto/libecc/src/hash/sha512_core.c

106

ret = local_memcpy(ctx->sha512_buffer + left, data_ptr, remain_ilen); EG(ret, err);

crypto/libecc/src/hash/sha512_core.c

125

ret = local_memset(last_padded_block, 0, sizeof(last_padded_block)); EG(ret, err);

crypto/libecc/src/hash/sha512_core.c

132

block_present); EG(ret, err);

crypto/libecc/src/hash/sha512_core.c

144

ret = sha512_core_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/hash/sha512_core.c

145

ret = sha512_core_process(ctx, last_padded_block + SHA512_CORE_BLOCK_SIZE); EG(ret, err);

crypto/libecc/src/hash/sha512_core.c

151

ret = sha512_core_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/hash/sha512_core.c

174

ret = local_memcpy(output, tmp_output, output_size); EG(ret, err);

crypto/libecc/src/hash/sha512_core.c

92

ret = local_memcpy(ctx->sha512_buffer + left, data_ptr, fill); EG(ret, err);

crypto/libecc/src/hash/sha512_core.c

93

ret = sha512_core_process(ctx, ctx->sha512_buffer); EG(ret, err);

crypto/libecc/src/hash/shake.c

22

ret = local_memset(ctx->shake_state, 0, sizeof(ctx->shake_state)); EG(ret, err);

crypto/libecc/src/hash/shake256.c

20

ret = _shake_init(ctx, SHAKE256_DIGEST_SIZE, SHAKE256_BLOCK_SIZE); EG(ret, err);

crypto/libecc/src/hash/shake256.c

64

ret = shake256_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/shake256.c

67

ret = shake256_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/hash/shake256.c

82

ret = shake256_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/shake256.c

83

ret = shake256_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/sm3.c

240

ret = local_memcpy(ctx->sm3_buffer + left, data_ptr, fill); EG(ret, err);

crypto/libecc/src/hash/sm3.c

241

ret = sm3_process(ctx, ctx->sm3_buffer); EG(ret, err);

crypto/libecc/src/hash/sm3.c

248

ret = sm3_process(ctx, data_ptr); EG(ret, err);

crypto/libecc/src/hash/sm3.c

254

ret = local_memcpy(ctx->sm3_buffer + left, data_ptr, remain_ilen); EG(ret, err);

crypto/libecc/src/hash/sm3.c

274

ret = local_memset(last_padded_block, 0, sizeof(last_padded_block)); EG(ret, err);

crypto/libecc/src/hash/sm3.c

281

block_present); EG(ret, err);

crypto/libecc/src/hash/sm3.c

292

ret = sm3_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/hash/sm3.c

293

ret = sm3_process(ctx, last_padded_block + SM3_BLOCK_SIZE); EG(ret, err);

crypto/libecc/src/hash/sm3.c

298

ret = sm3_process(ctx, last_padded_block); EG(ret, err);

crypto/libecc/src/hash/sm3.c

328

ret = sm3_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sm3.c

331

ret = sm3_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/hash/sm3.c

346

ret = sm3_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/sm3.c

347

ret = sm3_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/streebog.c

120

ret = local_memset(Z, 0, sizeof(Z)); EG(ret, err);

crypto/libecc/src/hash/streebog.c

123

ret = local_memset(last_padded_block, 0, sizeof(last_padded_block)); EG(ret, err);

crypto/libecc/src/hash/streebog.c

130

block_present); EG(ret, err);

crypto/libecc/src/hash/streebog.c

173

ret = streebog_init(ctx, STREEBOG256_DIGEST_SIZE, STREEBOG256_BLOCK_SIZE); EG(ret, err);

crypto/libecc/src/hash/streebog.c

202

ret = streebog_final(ctx, output); EG(ret, err);

crypto/libecc/src/hash/streebog.c

222

ret = streebog256_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/streebog.c

225

ret = streebog256_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/hash/streebog.c

240

ret = streebog256_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/streebog.c

241

ret = streebog256_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/streebog.c

258

ret = streebog_init(ctx, STREEBOG512_DIGEST_SIZE, STREEBOG512_BLOCK_SIZE); EG(ret, err);

crypto/libecc/src/hash/streebog.c

289

ret = streebog_final(ctx, output); EG(ret, err);

crypto/libecc/src/hash/streebog.c

309

ret = streebog512_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/streebog.c

312

ret = streebog512_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);

crypto/libecc/src/hash/streebog.c

327

ret = streebog512_init(&ctx); EG(ret, err);

crypto/libecc/src/hash/streebog.c

328

ret = streebog512_update(&ctx, input, ilen); EG(ret, err);

crypto/libecc/src/hash/streebog.c

40

ret = local_memset(ctx, 0, sizeof(streebog_context)); EG(ret, err);

crypto/libecc/src/hash/streebog.c

43

ret = local_memset(ctx->h, 1, sizeof(ctx->h)); EG(ret, err);

crypto/libecc/src/hash/streebog.c

80

ret = local_memcpy(ctx->streebog_buffer + left, data_ptr, fill); EG(ret, err);

crypto/libecc/src/hash/streebog.c

94

ret = local_memcpy(ctx->streebog_buffer + left, data_ptr, remain_ilen); EG(ret, err);

crypto/libecc/src/nn/nn.c

134

ret = nn_check_initialized(A); EG(ret, err);

crypto/libecc/src/nn/nn.c

149

ret = nn_zero(A); EG(ret, err);

crypto/libecc/src/nn/nn.c

182

ret = nn_check_initialized(in1); EG(ret, err);

crypto/libecc/src/nn/nn.c

183

ret = nn_check_initialized(in2); EG(ret, err);

crypto/libecc/src/nn/nn.c

195

ret = get_unsafe_random((u8*)&r, sizeof(r)); EG(ret, err);

crypto/libecc/src/nn/nn.c

226

ret = nn_check_initialized(A); EG(ret, err);

crypto/libecc/src/nn/nn.c

252

ret = nn_check_initialized(A); EG(ret, err);

crypto/libecc/src/nn/nn.c

279

ret = nn_check_initialized(A); EG(ret, err);

crypto/libecc/src/nn/nn.c

305

ret = nn_check_initialized(A); EG(ret, err);

crypto/libecc/src/nn/nn.c

327

ret = nn_check_initialized(in); EG(ret, err);

crypto/libecc/src/nn/nn.c

374

ret = nn_check_initialized(A); EG(ret, err);

crypto/libecc/src/nn/nn.c

375

ret = nn_check_initialized(B); EG(ret, err);

crypto/libecc/src/nn/nn.c

406

ret = nn_check_initialized(src_nn); EG(ret, err);

crypto/libecc/src/nn/nn.c

428

ret = nn_check_initialized(in1); EG(ret, err);

crypto/libecc/src/nn/nn.c

499

ret = local_memset(tmp, 0, (u32)(NN_MAX_BYTE_LEN - buflen)); EG(ret, err);

crypto/libecc/src/nn/nn.c

500

ret = local_memcpy(tmp + NN_MAX_BYTE_LEN - buflen, buf, buflen); EG(ret, err);

crypto/libecc/src/nn/nn.c

502

ret = nn_init(out_nn, buflen); EG(ret, err);

crypto/libecc/src/nn/nn.c

506

ret = _ntohw(tmp + buf_pos, &(out_nn->val[wpos])); EG(ret, err);

crypto/libecc/src/nn/nn.c

531

ret = nn_check_initialized(in_nn); EG(ret, err);

crypto/libecc/src/nn/nn.c

533

ret = local_memset(buf, 0, buflen); EG(ret, err);

crypto/libecc/src/nn/nn.c

548

ret = _htonw((const u8 *)&in_nn->val[i], &val); EG(ret, err);

crypto/libecc/src/nn/nn.c

553

ret = local_memcpy(dst_word_ptr, src_word_ptr, copylen); EG(ret, err);

crypto/libecc/src/nn/nn.c

586

ret = nn_check_initialized(out); EG(ret, err);

crypto/libecc/src/nn/nn.c

589

ret = nn_zero(out); EG(ret, err);

crypto/libecc/src/nn/nn.c

595

ret = nn_check_initialized(tab[k]); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

124

ret = _nn_cnd_add(cnd, out, in1, in2, &carry); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

185

ret = nn_check_initialized(in1); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

190

ret = nn_init(out, (u16)(n_wlen * WORD_BYTES)); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

192

ret = nn_set_wlen(out, n_wlen); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

257

ret = nn_check_initialized(in1); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

258

ret = nn_check_initialized(in2); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

263

ret = nn_init(out, (u16)(loop_wlen * WORD_BYTES)); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

265

ret = nn_set_wlen(out, in1->wlen); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

303

ret = nn_check_initialized(in1); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

305

ret = nn_set_wlen(out, n_wlen); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

343

ret = nn_check_initialized(in1); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

344

ret = nn_check_initialized(in2); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

345

ret = nn_check_initialized(p); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

350

ret = nn_add(out, in1, in2); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

363

ret = nn_set_wlen(out, (u8)(p->wlen + 1)); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

364

ret = nn_cmp(out, p, &cmp); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

366

ret = nn_cnd_sub(larger, out, out, p); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

387

ret = nn_copy(&p_cpy, p); EG(ret, err1);

crypto/libecc/src/nn/nn_add.c

392

EG(ret, err);

crypto/libecc/src/nn/nn_add.c

411

ret = nn_check_initialized(in1); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

412

ret = nn_check_initialized(p); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

416

ret = nn_inc(out, in1); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

417

ret = nn_set_wlen(out, (u8)(p->wlen + 1)); EG(ret, err); /* see comment in nn_mod_add() */

crypto/libecc/src/nn/nn_add.c

418

ret = nn_cmp(out, p, &cmp); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

420

ret = nn_cnd_sub(larger, out, out, p); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

440

ret = nn_copy(&p_cpy, p); EG(ret, err1);

crypto/libecc/src/nn/nn_add.c

445

EG(ret, err);

crypto/libecc/src/nn/nn_add.c

469

ret = nn_check_initialized(in1); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

470

ret = nn_check_initialized(in2); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

471

ret = nn_check_initialized(p); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

478

ret = nn_copy(&in2_cpy, in2); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

481

ret = nn_init(&in2_cpy, 0); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

486

ret = nn_cmp(in1, in2_, &cmp); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

488

ret = nn_cnd_add(smaller, out, in1, p); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

489

ret = nn_set_wlen(out, (u8)(p->wlen + 1)); EG(ret, err);/* See Comment in nn_mod_add() */

crypto/libecc/src/nn/nn_add.c

490

ret = nn_sub(out, out, in2_); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

513

ret = nn_copy(&p_cpy, p); EG(ret, err1);

crypto/libecc/src/nn/nn_add.c

518

EG(ret, err);

crypto/libecc/src/nn/nn_add.c

537

ret = nn_check_initialized(in1); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

538

ret = nn_check_initialized(p); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

544

ret = nn_iszero(in1, &iszero); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

545

ret = nn_cnd_add(iszero, out, in1, p); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

546

ret = nn_set_wlen(out, (u8)(p->wlen + 1)); EG(ret, err); /* See Comment in nn_mod_add() */

crypto/libecc/src/nn/nn_add.c

547

ret = nn_dec(out, out); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

567

ret = nn_copy(&p_cpy, p); EG(ret, err1);

crypto/libecc/src/nn/nn_add.c

572

EG(ret, err);

crypto/libecc/src/nn/nn_add.c

598

ret = nn_check_initialized(in); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

599

ret = nn_check_initialized(p); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

603

ret = nn_iszero(in, &iszero); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

605

ret = nn_init(out, 0); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

606

ret = nn_zero(out); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

608

ret = nn_sub(out, p, in); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

69

ret = nn_check_initialized(in1); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

70

ret = nn_check_initialized(in2); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

75

ret = nn_init(out, (u16)(loop_wlen * WORD_BYTES)); EG(ret, err);

crypto/libecc/src/nn/nn_add.c

77

ret = nn_set_wlen(out, loop_wlen); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1087

ret = nn_init(g, 0); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1088

ret = nn_init(u, 0); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1089

ret = nn_init(v, 0); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1090

ret = nn_iszero(b, &iszero); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1093

ret = nn_copy(g, a); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1094

ret = nn_one(u); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1095

ret = nn_zero(v); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1101

ret = nn_init(&scratch[i], 0); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1108

ret = nn_one(u1); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1109

ret = nn_zero(v1); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1110

ret = nn_zero(u2); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1111

ret = nn_one(v2); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1114

ret = nn_copy(c, a); EG(ret, err); /* Copy could be skipped. */

crypto/libecc/src/nn/nn_div.c

1115

ret = nn_copy(d, b); EG(ret, err); /* Copy could be skipped. */

crypto/libecc/src/nn/nn_div.c

1123

ret = nn_iszero(d, &iszero); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1125

ret = nn_divrem(q, r, c, d); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1126

ret = nn_normalize(q); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1127

ret = nn_normalize(r); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1128

ret = nn_copy(c, r); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1129

ret = nn_mul(r, q, u1); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1130

ret = nn_normalize(r); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1131

ret = nn_add(v1, v1, r); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1132

ret = nn_mul(r, q, u2); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1133

ret = nn_normalize(r); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1134

ret = nn_add(v2, v2, r); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1135

ret = nn_normalize(v1); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1136

ret = nn_normalize(v2); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1138

ret = nn_iszero(c, &iszero); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1142

ret = nn_divrem(q, r, d, c); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1143

ret = nn_normalize(q); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1144

ret = nn_normalize(r); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1145

ret = nn_copy(d, r); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1146

ret = nn_mul(r, q, v1); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1147

ret = nn_normalize(r); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1148

ret = nn_add(u1, u1, r); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1149

ret = nn_mul(r, q, v2); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1150

ret = nn_normalize(r); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1151

ret = nn_add(u2, u2, r); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1152

ret = nn_normalize(u1); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1153

ret = nn_normalize(u2); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1157

ret = nn_iszero(d, &iszero); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1162

ret = nn_copy(g, d); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1163

ret = nn_copy(u, u2); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1164

ret = nn_copy(v, u1); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1166

ret = nn_copy(g, c); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1167

ret = nn_copy(u, v2); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1168

ret = nn_copy(v, v1); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1211

ret = nn_check_initialized(a); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1212

ret = nn_check_initialized(b); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1215

ret = nn_init(&b_cpy, 0); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1219

ret = nn_copy(&a_cpy, a); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1226

ret = nn_copy(&b_cpy, b); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1232

ret = nn_cmp(a_, b_, &cmp); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1235

ret = _nn_xgcd(g, v, u, b_, a_, &_sign); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

1238

ret = _nn_xgcd(g, u, v, a_, b_, &_sign); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

208

ret = nn_set_wlen(r, a->wlen); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

209

ret = nn_copy(r, a); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

212

ret = nn_set_wlen(q, (u8)(r->wlen - b->wlen)); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

244

ret = _nn_submul_word_shift(r, b, qstar, shift, &borrow); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

254

ret = _nn_cmp_shift(r, b, shift, &cmp); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

257

ret = _nn_cnd_sub_shift(_small, r, b, shift, &borrow); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

272

ret = _nn_cmp_shift(r, b, shift, &cmp); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

275

ret = nn_set_wlen(r, (u8)(r->wlen - 1)); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

316

ret = nn_init(&r, 0); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

317

ret = _nn_divrem_normalized(q, &r, a, b, v); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

318

ret = nn_copy(b, &r); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

342

ret = nn_check_initialized(a); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

343

ret = nn_check_initialized(q); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

344

ret = nn_check_initialized(r); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

352

ret = nn_check_initialized(b); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

374

ret = nn_init(&q, 0); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

426

ret = nn_copy(r, a); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

432

ret = nn_init(&a_shift, (u16)(new_wlen * WORD_BYTES)); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

433

ret = nn_set_wlen(&a_shift, new_wlen); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

434

ret = nn_lshift_fixedlen(&a_shift, a, cnt); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

435

ret = nn_set_wlen(r, new_wlen); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

439

ret = nn_cmp(&a_shift, b_norm, &cmp); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

441

ret = nn_cnd_sub(larger, r, &a_shift, b_norm); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

445

ret = nn_set_wlen(q, (u8)(new_wlen - b_wlen + 1)); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

450

ret = _nn_cmp_shift(&a_shift, b_norm, (u8)(new_wlen - b_wlen), &cmp); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

452

ret = _nn_cnd_sub_shift(larger, &a_shift, b_norm, (u8)(new_wlen - b_wlen), &borrow); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

459

ret = nn_divrem_normalized(q, r, &a_shift, b_norm, v); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

462

ret = nn_set_wlen(q, (u8)(new_wlen - b_wlen + 1)); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

466

ret = nn_rshift_fixedlen(r, r, cnt); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

495

ret = nn_init(&r, 0); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

496

ret = _nn_divrem_unshifted(q, &r, a, b_norm, v, cnt); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

497

ret = nn_copy(b_norm, &r); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

517

ret = nn_check_initialized(a); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

518

ret = nn_check_initialized(q); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

519

ret = nn_check_initialized(r); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

527

ret = nn_check_initialized(b); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

549

ret = nn_init(&q, 0); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

744

(word_t)(dh + WORD(1))); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

801

ret = nn_check_initialized(p_in); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

809

ret = nn_init(&p, 0); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

810

ret = nn_copy(&p, p_in); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

818

ret = nn_set_wlen(&p, 2); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

821

ret = nn_init(p_normalized, 0); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

822

ret = nn_init(&tmp_nn, 0); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

828

ret = nn_bitlen(&p, &p_bitlen); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

832

ret = nn_lshift(p_normalized, &p, (bitcnt_t)(*p_shift)); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

842

ret = nn_rshift(&tmp_nn, p_normalized, (bitcnt_t)(p_rounded_bitlen - (2 * WORDSIZE))); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

881

ret = nn_init(r, 0); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

882

ret = nn_init(q, 0); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

883

ret = nn_init(&b_large, 0); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

888

ret = nn_copy(&b_large, b); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

891

ret = nn_set_wlen(&b_large, 2); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

904

ret = nn_init(&b_normalized, (u16)((ptr->wlen) * WORD_BYTES)); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

905

ret = nn_clz(ptr, &cnt); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

906

ret = nn_lshift_fixedlen(&b_normalized, ptr, cnt); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

909

&v); /* Not constant time. */ EG(ret, err);

crypto/libecc/src/nn/nn_div.c

930

ret = nn_init(&a_cpy, 0); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

931

ret = nn_init(&b_cpy, 0); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

932

ret = nn_copy(&a_cpy, a); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

933

ret = nn_copy(&b_cpy, b); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

957

ret = nn_check_initialized(a); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

958

ret = nn_check_initialized(b); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

986

ret = nn_divrem_notrim(q, r, a, b); EG(ret, err);

crypto/libecc/src/nn/nn_div.c

989

ret = nn_normalize(q); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

100

ret = nn_check_initialized(in); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

105

ret = nn_init(out, 0); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

109

ret = nn_bitlen(in, &blen); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

163

ret = nn_check_initialized(in); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

164

ret = nn_check_initialized(out); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

218

ret = nn_check_initialized(in); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

222

ret = nn_init(out, 0); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

230

ret = nn_bitlen(in, &blen); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

287

ret = nn_check_initialized(in); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

288

ret = nn_init(&tmp, 0); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

289

ret = nn_lshift(&tmp, in, (bitcnt_t)(bitlen - cnt)); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

290

ret = nn_set_wlen(&tmp, owlen); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

291

ret = nn_rshift(out, in, cnt); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

292

ret = nn_set_wlen(out, owlen); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

293

ret = nn_xor(out, out, &tmp); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

327

ret = nn_check_initialized(in); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

328

ret = nn_init(&tmp, 0); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

329

ret = nn_lshift(&tmp, in, cnt); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

330

ret = nn_set_wlen(&tmp, owlen); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

331

ret = nn_rshift(out, in, (bitcnt_t)(bitlen - cnt)); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

332

ret = nn_set_wlen(out, owlen); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

333

ret = nn_xor(out, out, &tmp); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

363

ret = nn_check_initialized(B); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

364

ret = nn_check_initialized(C); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

368

ret = nn_init(A, 0); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

398

ret = nn_check_initialized(B); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

399

ret = nn_check_initialized(C); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

403

ret = nn_init(A, 0); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

433

ret = nn_check_initialized(B); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

434

ret = nn_check_initialized(C); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

438

ret = nn_init(A, 0); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

45

ret = nn_check_initialized(in); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

46

ret = nn_check_initialized(out); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

466

ret = nn_check_initialized(B); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

470

ret = nn_init(A, 0); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

513

ret = nn_check_initialized(in); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

542

ret = nn_check_initialized(in); EG(ret, err);

crypto/libecc/src/nn/nn_logical.c

569

ret = nn_check_initialized(in); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

108

ret = nn_getbit(&mask, explen, &rbit_next); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

110

ret = nn_getbit(exp, explen, &expbit); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

114

ret = nn_mul_redc1(&T[2], &T[expbit ^ rbit], &T[expbit ^ rbit], mod, mpinv); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

117

ret = nn_mod_mul(&T[2], &T[expbit ^ rbit], &T[expbit ^ rbit], mod); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

121

ret = nn_mul_redc1(&T[1], &T[0], &T[1], mod, mpinv); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

124

ret = nn_mod_mul(&T[1], &T[0], &T[1], mod); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

127

ret = nn_copy(&T[0], &T[2 - (expbit ^ rbit_next)]); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

128

ret = nn_copy(&T[1], &T[1 + (expbit ^ rbit_next)]); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

135

ret = nn_mul_redc1(&T[rbit], &T[rbit], &T[1 - rbit], mod, mpinv); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

140

ret = nn_mod(&T[1 - rbit], &T[1 - rbit], mod); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

142

ret = nn_mod(&T[2], base, mod); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

205

ret = nn_init(&_out, 0); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

206

ret = _nn_exp_monty_ladder_ltr(&_out, base, exp, mod, NULL, NULL, WORD(0)); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

228

ret = nn_init(&_out, 0); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

229

ret = _nn_mod_pow_redc(&_out, base, exp, mod, r, r_square, mpinv); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

248

ret = nn_check_initialized(base); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

249

ret = nn_check_initialized(exp); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

250

ret = nn_check_initialized(mod); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

251

ret = nn_check_initialized(r); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

252

ret = nn_check_initialized(r_square); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

255

ret = nn_isodd(mod, &isodd); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

268

ret = nn_copy(&_mod, mod); EG(ret, err1);

crypto/libecc/src/nn/nn_mod_pow.c

269

ret = nn_set_wlen(&_mod, 2); EG(ret, err1);

crypto/libecc/src/nn/nn_mod_pow.c

272

ret = _nn_mod_pow_redc_aliased(out, base, exp, &_mod, r, r_square, mpinv); EG(ret, err1);

crypto/libecc/src/nn/nn_mod_pow.c

274

ret = _nn_mod_pow_redc(out, base, exp, &_mod, r, r_square, mpinv); EG(ret, err1);

crypto/libecc/src/nn/nn_mod_pow.c

278

EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

315

ret = nn_isodd(mod, &isodd); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

323

ret = nn_compute_redc1_coefs(&r, &r_square, mod, &mpinv); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

49

ret = nn_init(out, 0); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

51

ret = nn_init(&T[0], 0); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

52

ret = nn_init(&T[1], 0); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

53

ret = nn_init(&T[2], 0); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

56

ret = nn_get_random_len(&mask, NN_MAX_BYTE_LEN); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

58

ret = nn_bitlen(exp, &explen); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

68

ret = nn_getbit(&mask, (bitcnt_t)(explen - 1), &rbit); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

71

ret = nn_cmp(base, mod, &cmp); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

74

ret = nn_mod(&T[rbit], base, mod); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

77

ret = nn_mul_redc1(&T[rbit], &T[rbit], r_square, mod, mpinv); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

83

ret = nn_mul_redc1(&T[rbit], base, r_square, mod, mpinv); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

86

ret = nn_copy(&T[rbit], base); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

94

ret = nn_mul_redc1(&T[1-rbit], &T[rbit], &T[rbit], mod, mpinv); EG(ret, err);

crypto/libecc/src/nn/nn_mod_pow.c

97

ret = nn_mod_mul(&T[1-rbit], &T[rbit], &T[rbit], mod); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

101

ret = nn_rshift_fixedlen(&mp1d2, m, 1); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

103

ret = nn_inc(&mp1d2, &mp1d2); EG(ret, err); /* no carry can occur here

crypto/libecc/src/nn/nn_modinv.c

128

ret = nn_isodd(&a, &isodd); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

129

ret = nn_cmp(&a, &b, &cmp); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

132

ret = nn_cnd_swap(swap, &a, &b); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

133

ret = nn_cnd_sub(isodd, &a, &a, &b); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

137

ret = nn_rshift_fixedlen(&a, &a, 1); EG(ret, err);/* division by 2 */

crypto/libecc/src/nn/nn_modinv.c

154

ret = nn_cnd_swap(swap, &u, uu); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

157

ret = nn_cmp(&u, uu, &cmp); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

161

ret = nn_sub(&tmp, m, uu); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

164

ret = nn_cnd_add(isodd & smaller, &u, &u, &tmp); EG(ret, err); /* no carry can occur as 'u+(m-uu) = m-(uu-u) < m' */

crypto/libecc/src/nn/nn_modinv.c

165

ret = nn_cnd_sub(isodd & (!smaller), &u, &u, uu); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

168

ret = nn_isodd(&u, &isodd); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

169

ret = nn_rshift_fixedlen(&u, &u, 1); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

170

ret = nn_cnd_add(isodd, &u, &u, &mp1d2); EG(ret, err); /* no carry can occur as u=1+u' with u'<m-1 and u' even so u'/2+(m+1)/2<(m-1)/2+(m+1)/2=m */

crypto/libecc/src/nn/nn_modinv.c

188

ret = nn_cmp_word(&b, WORD(1), &cmp); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

191

ret = nn_cnd_sub(cmp != 0, uu, uu, uu); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

228

ret = nn_check_initialized(x); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

229

ret = nn_check_initialized(m); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

232

ret = nn_init(&out, 0); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

233

ret = nn_isodd(m, &isodd); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

235

ret = nn_cmp(x, m, &cmp); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

244

ret = nn_mod(x_mod_m, x, m); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

245

ret = _nn_modinv_odd(&out, x_mod_m, m); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

247

ret = _nn_modinv_odd(&out, x, m); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

254

ret = nn_isodd(x, &isodd); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

257

ret = nn_init(&u, 0); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

258

ret = nn_init(&v, 0); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

259

ret = nn_xgcd(&out, &u, &v, x, m, &sign); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

260

ret = nn_isone(&out, &isone); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

263

ret = nn_mod(&out, &u, m); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

265

ret = nn_sub(&out, m, &out); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

290

ret = nn_set_wlen(A, (u8)(Awlen + 1)); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

295

ret = nn_sub(A, A, B); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

327

ret = nn_check_initialized(x); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

328

ret = nn_check_initialized(_out); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

330

ret = nn_init(&out, 0); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

331

ret = nn_init(&tmp_sqr, 0); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

332

ret = nn_init(&tmp_mul, 0); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

333

ret = nn_isodd(x, &isodd); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

340

ret = nn_zero(_out); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

349

ret = nn_one(&out); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

356

ret = nn_sqr_low(&tmp_sqr, &out, out.wlen); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

357

ret = nn_mul_low(&tmp_mul, &tmp_sqr, x, out.wlen); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

358

ret = nn_lshift_fixedlen(&out, &out, 1); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

375

ret = _nn_sub_mod_2exp(&out, &tmp_mul); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

382

ret = nn_set_wlen(&out, (u8)(2 * out.wlen)); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

383

ret = nn_sqr_low(&tmp_sqr, &out, out.wlen); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

384

ret = nn_mul_low(&tmp_mul, &tmp_sqr, x, out.wlen); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

385

ret = nn_lshift_fixedlen(&out, &out, 1); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

386

ret = _nn_sub_mod_2exp(&out, &tmp_mul); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

393

ret = nn_set_wlen(&out, exp_wlen); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

394

ret = nn_sqr_low(&tmp_sqr, &out, out.wlen); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

395

ret = nn_mul_low(&tmp_mul, &tmp_sqr, x, out.wlen); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

396

ret = nn_lshift_fixedlen(&out, &out, 1); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

397

ret = _nn_sub_mod_2exp(&out, &tmp_mul); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

405

ret = nn_copy(_out, &out); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

428

ret = nn_init(&nn_tmp, 0); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

429

ret = nn_set_word_value(&nn_tmp, w); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

450

ret = nn_check_initialized(x); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

451

ret = nn_check_initialized(p); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

457

ret = nn_iszero(x, &cmp); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

460

ret = nn_init(out, 0); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

461

ret = nn_zero(out); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

470

ret = nn_cmp_word(p, WORD(2), &cmp); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

473

ret = nn_isodd(x, &isodd); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

476

ret = nn_init(out, 0); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

477

ret = nn_one(out); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

482

ret = nn_init(out, 0); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

483

ret = nn_zero(out); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

491

ret = nn_init(out, 0); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

492

ret = nn_zero(out); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

501

ret = nn_init(p_minus_two, 0); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

504

ret = nn_init(&two, 0); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

505

ret = nn_set_word_value(&two, WORD(2)); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

540

ret = _nn_modinv_fermat_common(out, x, p, &p_minus_two, &lesstwo); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

57

ret = nn_init(out, 0); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

576

ret = _nn_modinv_fermat_common(out, x, p, &p_minus_two, &lesstwo); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

58

ret = nn_init(&a, (u16)(m->wlen * WORD_BYTES)); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

59

ret = nn_init(&b, (u16)(m->wlen * WORD_BYTES)); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

60

ret = nn_init(&u, (u16)(m->wlen * WORD_BYTES)); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

61

ret = nn_init(&mp1d2, (u16)(m->wlen * WORD_BYTES)); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

65

ret = nn_init(&tmp, (u16)(m->wlen * WORD_BYTES)); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

82

ret = nn_copy(&a, x); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

83

ret = nn_set_wlen(&a, m->wlen); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

84

ret = nn_copy(&b, m); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

85

ret = nn_one(&u); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

86

ret = nn_zero(uu); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

93

ret = nn_set_wlen(&u, m->wlen); EG(ret, err);

crypto/libecc/src/nn/nn_modinv.c

94

ret = nn_set_wlen(uu, m->wlen); EG(ret, err);

crypto/libecc/src/nn/nn_mul.c

113

ret = _nn_mul_low(&out_cpy, in1, in2, wlimit); EG(ret, err);

crypto/libecc/src/nn/nn_mul.c

114

ret = nn_init(out, out_cpy.wlen); EG(ret, err);

crypto/libecc/src/nn/nn_mul.c

128

ret = nn_check_initialized(in1); EG(ret, err);

crypto/libecc/src/nn/nn_mul.c

129

ret = nn_check_initialized(in2); EG(ret, err);

crypto/libecc/src/nn/nn_mul.c

152

ret = nn_check_initialized(in1); EG(ret, err);

crypto/libecc/src/nn/nn_mul.c

153

ret = nn_check_initialized(in2); EG(ret, err);

crypto/libecc/src/nn/nn_mul.c

188

ret = nn_check_initialized(in); EG(ret, err);

crypto/libecc/src/nn/nn_mul.c

189

ret = nn_init(&w_nn, WORD_BYTES); EG(ret, err);

crypto/libecc/src/nn/nn_mul.c

54

ret = nn_init(out, (u16)(wlimit * WORD_BYTES)); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

143

ret = nn_init(out, 0); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

156

ret = nn_set_wlen(out, p->wlen); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

210

ret = nn_cmp(out, p, &cmp); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

211

ret = nn_cnd_sub(cmp >= 0, out, out, p); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

232

ret = _nn_mul_redc1(&out_cpy, in1, in2, p, mpinv); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

233

ret = nn_init(out, out_cpy.wlen); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

251

ret = nn_check_initialized(in1); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

252

ret = nn_check_initialized(in2); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

253

ret = nn_check_initialized(p); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

295

ret = nn_isodd(p_in, &isodd); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

298

ret = nn_mul(out, in1, in2); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

299

ret = nn_mod(out, out, p_in); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

303

ret = nn_copy(&p, p_in); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

312

ret = nn_set_wlen(&p, 2); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

318

ret = nn_compute_redc1_coefs(&in1_tmp, &r_square, &p, &mpinv); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

321

ret = nn_mul_redc1(&in1_tmp, in1, &r_square, &p, mpinv); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

322

ret = nn_mul_redc1(&in2_tmp, in2, &r_square, &p, mpinv); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

327

ret = nn_mul_redc1(&r_square, &in1_tmp, &in2_tmp, &p, mpinv); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

330

ret = nn_init(&in1_tmp, 0); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

331

ret = nn_one(&in1_tmp); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

332

ret = nn_mul_redc1(out, &r_square, &in1_tmp, &p, mpinv); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

48

ret = nn_check_initialized(p_in); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

49

ret = nn_init(&p, 0); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

50

ret = nn_copy(&p, p_in); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

60

ret = nn_set_wlen(&p, 2); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

63

ret = nn_init(r, 0); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

64

ret = nn_init(r_square, 0); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

65

ret = nn_init(&tmp_nn1, 0); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

66

ret = nn_init(&tmp_nn2, 0); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

72

ret = nn_set_wlen(&tmp_nn1, 2); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

74

ret = nn_copy(&tmp_nn2, &tmp_nn1); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

75

ret = nn_modinv_2exp(&tmp_nn1, &p, WORD_BITS, &isodd); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

76

ret = nn_sub(&tmp_nn1, &tmp_nn2, &tmp_nn1); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

80

ret = nn_one(r); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

81

ret = nn_lshift(r, r, p_rounded_bitlen); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

82

ret = nn_mod(r, r, &p); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

95

ret = nn_sqr(r_square, r); EG(ret, err);

crypto/libecc/src/nn/nn_mul_redc1.c

96

ret = nn_mod(r_square, r_square, &p); EG(ret, err);

crypto/libecc/src/nn/nn_rand.c

103

ret = nn_check_initialized(q); EG(ret, err);

crypto/libecc/src/nn/nn_rand.c

104

ret = nn_bitlen(q, &q_bit_len); EG(ret, err);

crypto/libecc/src/nn/nn_rand.c

112

ret = nn_copy(&qprime, q); EG(ret, err);

crypto/libecc/src/nn/nn_rand.c

113

ret = nn_dec(&qprime, &qprime); EG(ret, err);

crypto/libecc/src/nn/nn_rand.c

116

ret = nn_init(&tmp_rand, (u16)(2 * q_len)); EG(ret, err);

crypto/libecc/src/nn/nn_rand.c

117

ret = get_random((u8 *)tmp_rand.val, (u16)(2 * q_len)); EG(ret, err);

crypto/libecc/src/nn/nn_rand.c

120

ret = nn_init(out, (u16)q_len); EG(ret, err);

crypto/libecc/src/nn/nn_rand.c

123

ret = nn_mod_notrim(out, &tmp_rand, &qprime); EG(ret, err);

crypto/libecc/src/nn/nn_rand.c

37

ret = nn_init(out, len); EG(ret, err);

crypto/libecc/src/nn/nn_rand.c

63

ret = get_random((u8 *)&len, 2); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

165

ret = local_memcpy(&adata[4], oid, oid_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

173

ret = local_memcpy(&adata[4 + oid_len], t, t_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

220

ret = nn_check_initialized(q); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

221

ret = nn_check_initialized(x); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

223

ret = local_memset(theta, 0, sizeof(theta)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

224

ret = local_memset(FE2OS_D, 0, sizeof(FE2OS_D)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

225

ret = local_memset(r_bar, 0, sizeof(r_bar)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

233

ret = bign_get_oid_from_adata(adata, adata_len, &oid_ptr, &oid_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

234

ret = bign_get_t_from_adata(adata, adata_len, &t_ptr, &t_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

236

ret = belt_hash_init(&belt_hash_ctx); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

237

ret = belt_hash_update(&belt_hash_ctx, oid_ptr, oid_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

240

ret = local_memset(FE2OS_D, 0, sizeof(FE2OS_D)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

241

ret = nn_export_to_buf(&FE2OS_D[0], q_len, x); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

242

ret = _reverse_endianness(&FE2OS_D[0], q_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

244

ret = belt_hash_update(&belt_hash_ctx, &FE2OS_D[0], (u32)(2*l)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

246

ret = belt_hash_update(&belt_hash_ctx, t_ptr, t_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

248

ret = belt_hash_final(&belt_hash_ctx, theta); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

257

ret = local_memcpy(r, h, hlen); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

276

ret = local_memset(s, 0, sizeof(s)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

285

ret = local_memcpy(&r[0], &r[BELT_BLOCK_LEN], (n - 2) * BELT_BLOCK_LEN); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

288

ret = local_memset(i_block, 0, sizeof(i_block)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

296

ret = local_memcpy(&r[(n - 1) * BELT_BLOCK_LEN], s, BELT_BLOCK_LEN); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

303

ret = local_memcpy(&r_bar[0], &r[0], r_bar_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

317

ret = local_memcpy(&r_bar[0], &r[0], r_bar_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

319

ret = _reverse_endianness(&r_bar[0], r_bar_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

320

ret = nn_init_from_buf(k, &r_bar[0], r_bar_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

323

ret = nn_cmp(k, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

325

ret = nn_iszero(k, &iszero); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

355

ret = local_memset(out_pub, 0, sizeof(ec_pub_key)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

357

ret = priv_key_check_initialized_and_type(in_priv, key_type); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

366

ret = prj_pt_mul_blind(&(out_pub->y), &(in_priv->x), G); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

415

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

418

ret = key_pair_check_initialized_and_type(ctx->key_pair, key_type); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

433

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

434

ret = ctx->h->hfunc_init(&(ctx->sign_data.bign.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

453

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

457

ret = key_pair_check_initialized_and_type(ctx->key_pair, key_type); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

461

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

500

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

505

ret = key_pair_check_initialized_and_type(ctx->key_pair, key_type); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

508

ret = local_memset(&kG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

526

ret = nn_cmp(x, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

547

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

549

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

550

ret = ctx->h->hfunc_finalize(&(ctx->sign_data.bign.h_ctx), hash); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

605

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

609

ret = nn_modinv_fermat(&binv, &b, q); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

617

ret = prj_pt_mul_blind(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

619

ret = prj_pt_mul(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

621

ret = prj_pt_unique(&kG, &kG); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

627

ret = belt_hash_init(&belt_hash_ctx); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

628

ret = bign_get_oid_from_adata(ctx->adata, ctx->adata_len, &oid_ptr, &oid_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

629

ret = belt_hash_update(&belt_hash_ctx, oid_ptr, oid_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

631

ret = local_memset(FE2OS_W, 0, sizeof(FE2OS_W)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

632

ret = fp_export_to_buf(&FE2OS_W[0], p_len, &(kG.X)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

633

ret = _reverse_endianness(&FE2OS_W[0], p_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

634

ret = fp_export_to_buf(&FE2OS_W[p_len], p_len, &(kG.Y)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

635

ret = _reverse_endianness(&FE2OS_W[p_len], p_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

637

ret = belt_hash_update(&belt_hash_ctx, &FE2OS_W[0], (u32)(2*l)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

639

ret = belt_hash_update(&belt_hash_ctx, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

641

ret = local_memset(hash_belt, 0, sizeof(hash_belt)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

642

ret = belt_hash_final(&belt_hash_ctx, hash_belt); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

643

ret = local_memset(&sig[0], 0, l); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

644

ret = local_memcpy(&sig[0], &hash_belt[0], LOCAL_MIN(l, BELT_HASH_DIGEST_SIZE)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

650

ret = _reverse_endianness(hash, hsize); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

651

ret = nn_init_from_buf(&h, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

652

ret = nn_mod(&h, &h, q); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

654

ret = local_memcpy(FE2OS_W, &sig[0], l); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

655

ret = _reverse_endianness(FE2OS_W, l); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

656

ret = nn_init_from_buf(&s1, FE2OS_W, l); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

657

ret = nn_mod(&s1, &s1, q); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

659

ret = nn_init(&tmp, 0); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

660

ret = nn_one(&tmp); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

661

ret = nn_lshift(&tmp, &tmp, (bitcnt_t)(8*l)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

662

ret = nn_mod(&tmp, &tmp, q); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

663

ret = nn_mod_add(&s1, &s1, &tmp, q); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

666

ret = nn_mod_mul(&s1, &s1, &b, q); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

669

ret = nn_mod_mul(&h, &h, &b, q); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

672

ret = nn_mod_mul(&k, &k, &b, q); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

675

ret = nn_mod_mul(&s1, &s1, &(priv_key->x), q); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

676

ret = nn_mod_sub(&s1, &k, &s1, q); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

677

ret = nn_mod_sub(&s1, &s1, &h, q); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

681

ret = nn_mod_mul(&s1, &s1, &binv, q); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

686

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

689

ret = nn_export_to_buf(&sig[l], (u16)BIGN_S1_LEN(q_bit_len), &s1); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

754

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

756

ret = local_memset(TMP, 0, sizeof(TMP)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

759

ret = pub_key_check_initialized_and_type(ctx->pub_key, key_type); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

783

ret = local_memcpy(s0_sig, sig, l); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

786

ret = local_memcpy(&TMP[0], sig, l); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

787

ret = _reverse_endianness(&TMP[0], l); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

788

ret = nn_init_from_buf(s0, &TMP[0], l); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

790

ret = local_memcpy(&TMP[0], &sig[l], (u32)BIGN_S1_LEN(q_bit_len)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

791

ret = _reverse_endianness(&TMP[0], (u16)BIGN_S1_LEN(q_bit_len)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

792

ret = nn_init_from_buf(s1, &TMP[0], (u8)BIGN_S1_LEN(q_bit_len)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

797

ret = nn_cmp(s1, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

802

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

803

ret = ctx->h->hfunc_init(&(ctx->verify_data.bign.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

828

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

831

ret = pub_key_check_initialized_and_type(ctx->pub_key, key_type); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

835

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

874

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

877

ret = pub_key_check_initialized_and_type(ctx->pub_key, key_type); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

885

ret = local_memset(&uG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

886

ret = local_memset(&vY, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

908

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

909

ret = ctx->h->hfunc_finalize(&(ctx->verify_data.bign.h_ctx), hash); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

913

ret = _reverse_endianness(hash, hsize); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

914

ret = nn_init_from_buf(&h, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

915

ret = nn_mod(&h, &h, q); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

919

ret = _reverse_endianness(hash, hsize); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

922

ret = nn_mod_add(&h, &h, s1, q); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

924

ret = nn_init(&tmp, 0); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

925

ret = nn_one(&tmp); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

926

ret = nn_lshift(&tmp, &tmp, (bitcnt_t)(8*l)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

927

ret = nn_mod(&tmp, &tmp, q); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

928

ret = nn_mod_add(&tmp, &tmp, s0, q); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

931

ret = prj_pt_mul(&uG, &h, G); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

932

ret = prj_pt_mul(&vY, &tmp, Y); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

933

ret = prj_pt_add(W, &uG, &vY); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

935

ret = prj_pt_iszero(W, &iszero); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

937

ret = prj_pt_unique(W, W); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

940

ret = belt_hash_init(&belt_hash_ctx); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

941

ret = bign_get_oid_from_adata(ctx->adata, ctx->adata_len, &oid_ptr, &oid_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

942

ret = belt_hash_update(&belt_hash_ctx, oid_ptr, oid_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

944

ret = local_memset(FE2OS_W, 0, sizeof(FE2OS_W)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

945

ret = fp_export_to_buf(&FE2OS_W[0], p_len, &(W->X)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

946

ret = _reverse_endianness(&FE2OS_W[0], p_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

947

ret = fp_export_to_buf(&FE2OS_W[p_len], p_len, &(W->Y)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

948

ret = _reverse_endianness(&FE2OS_W[p_len], p_len); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

950

ret = belt_hash_update(&belt_hash_ctx, &FE2OS_W[0], (u32)(2*l)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

952

ret = belt_hash_update(&belt_hash_ctx, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

954

ret = local_memset(hash_belt, 0, sizeof(hash_belt)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

955

ret = belt_hash_final(&belt_hash_ctx, hash_belt); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

956

ret = local_memset(&t[0], 0, l); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

957

ret = local_memcpy(&t[0], &hash_belt[0], LOCAL_MIN(l, BELT_HASH_DIGEST_SIZE)); EG(ret, err);

crypto/libecc/src/sig/bign_common.c

960

ret = are_equal(t, s0_sig, l, &cmp); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1000

ret = prj_pt_add(&Tmp, &Tmp, &P_sum); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1002

ret = prj_pt_iszero(&Tmp, &iszero); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1072

ret = local_memset(hash, 0, sizeof(hash)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1073

ret = local_memset(Pubx, 0, sizeof(Pubx)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1074

ret = local_memset(chacha20_seed, 0,sizeof(chacha20_seed)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1075

ret = local_memset(chacha20_scalar, 0,sizeof(chacha20_scalar)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1090

hash_type, adata, adata_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1114

ret = get_hash_by_type(hash_type, &hm); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1122

ret = pub_key_check_initialized_and_type(pub_keys[i], BIP0340); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

115

ret = local_memset(out_pub, 0, sizeof(ec_pub_key)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1151

ret = nn_init(&a, 0); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1152

ret = nn_init(&elements[(2 * num)].number, 0); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1153

ret = prj_pt_copy(&elements[(2 * num)].point, G); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1157

sizeof(chacha20_seed)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1164

q_bit_len, q_len, &a); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1169

ret = fp_init(&rx, pub_key->params->ec_curve.a.ctx); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

117

ret = priv_key_check_initialized_and_type(in_priv, BIP0340); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1170

ret = fp_import_from_buf(&rx, &sig[0], p_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1171

ret = nn_init_from_buf(&S, &sig[p_len], q_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1172

ret = nn_cmp(&S, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1182

ret = nn_mod_mul(&S, &a, &S, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1185

&S, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1190

ret = prj_pt_init(R, shortw_curve); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1192

ret = fp_copy(&(R->X), &rx); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1193

ret = aff_pt_y_from_x(&(R->Y), &(R->Z), &rx, shortw_curve); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1195

ret = nn_isodd(&(R->Y.fp_val), &isodd); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1197

ret = fp_copy(&(R->Y), &(R->Z)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1199

ret = fp_one(&(R->Z)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1202

ret = nn_init(&elements[i].number, 0); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1203

ret = nn_copy(&elements[i].number, &a); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1206

ret = nn_init(&elements[i].number, 0); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1207

ret = nn_one(&elements[i].number); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1217

ret = prj_pt_copy(Y, pub_key_y); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1218

ret = prj_pt_unique(Y, Y); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

122

ret = prj_pt_mul_blind(&(out_pub->y), &(in_priv->x), G); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1220

ret = nn_isodd(&(Y->Y.fp_val), &isodd); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1223

ret = fp_neg(&(Y->Y), &(Y->Y)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1229

ret = nn_init(e, 0); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1232

&h_ctx); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1233

ret = fp_export_to_buf(&Pubx[0], p_len, &(Y->X)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1234

ret = hm->hfunc_update(&h_ctx, &Pubx[0], p_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1235

ret = hm->hfunc_update(&h_ctx, m[i], m_len[i]); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1236

ret = hm->hfunc_finalize(&h_ctx, hash); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1238

ret = nn_init_from_buf(e, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1239

ret = nn_mod(e, e, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1245

ret = nn_mod_mul(e, e, &a, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1261

hash_type, adata, adata_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1270

ret = prj_pt_iszero(&elements[elements[0].index].point, &iszero); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1307

scratch_pad_area, scratch_pad_area_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

1312

hash_type, adata, adata_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

196

ret = key_pair_check_initialized_and_type(key_pair, BIP0340); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

199

ret = get_hash_by_type(hash_type, &hm); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

201

ret = hash_mapping_callbacks_sanity_check(hm); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

216

ret = prj_pt_copy(&Y, &(pub_key->y)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

217

ret = prj_pt_unique(&Y, &Y); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

219

ret = nn_init(&d, 0); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

220

ret = nn_copy(&d, &(priv_key->x)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

230

ret = nn_iszero(&d, &iszero); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

231

ret = nn_cmp(&d, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

235

ret = _bip0340_set_scalar(&d, q, &Y); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

248

ret = nn_init(&e, 0); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

249

ret = nn_one(&e); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

250

ret = nn_lshift(&e, &e, (bitcnt_t)(8 * q_len)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

254

ret = rand(&k, &e); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

258

ret = nn_export_to_buf(&sig[0], q_len, &k); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

262

&sig[0], q_len, hm, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

263

ret = hm->hfunc_finalize(&h_ctx, buff); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

265

ret = nn_export_to_buf(&sig[0], q_len, &d); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

272

&sig[0], q_len, hm, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

279

&buff[0], hm->digest_size, hm, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

281

ret = fp_export_to_buf(&sig[0], p_len, &(Y.X)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

282

ret = hm->hfunc_update(&h_ctx, &sig[0], p_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

283

ret = hm->hfunc_update(&h_ctx, m, mlen); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

284

ret = hm->hfunc_finalize(&h_ctx, buff); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

287

ret = nn_init_from_buf(&k, buff, hm->digest_size); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

288

ret = nn_mod(&k, &k, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

293

ret = nn_iszero(&k, &iszero); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

299

ret = prj_pt_mul_blind(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

301

ret = prj_pt_mul(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

303

ret = prj_pt_unique(&kG, &kG); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

308

ret = _bip0340_set_scalar(&k, q, &kG); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

312

ret = fp_export_to_buf(&sig[0], p_len, &(kG.X)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

314

&sig[0], p_len, hm, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

316

ret = fp_export_to_buf(&sig[0], p_len, &(Y.X)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

317

ret = hm->hfunc_update(&h_ctx, &sig[0], p_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

319

ret = hm->hfunc_update(&h_ctx, m, mlen); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

320

ret = hm->hfunc_finalize(&h_ctx, buff); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

321

ret = nn_init_from_buf(&e, buff, hm->digest_size); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

322

ret = nn_mod(&e, &e, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

327

ret = fp_export_to_buf(&sig[0], p_len, &(kG.X)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

331

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

337

ret = nn_mod_mul(&e, &e, &b, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

339

ret = nn_mod_mul(&k, &k, &b, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

342

ret = nn_mod_mul(&e, &e, &d, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

343

ret = nn_mod_add(&e, &k, &e, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

350

ret = nn_modinv_fermat(&binv, &b, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

351

ret = nn_mod_mul(&e, &e, &binv, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

356

ret = nn_export_to_buf(&sig[p_len], q_len, &e); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

396

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

399

ret = pub_key_check_initialized_and_type(ctx->pub_key, BIP0340); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

405

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

423

ret = prj_pt_copy(&Y, &(ctx->pub_key->y)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

424

ret = prj_pt_unique(&Y, &Y); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

427

ret = fp_init(rx, ctx->pub_key->params->ec_curve.a.ctx); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

428

ret = fp_import_from_buf(rx, &sig[0], p_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

429

ret = nn_init_from_buf(s, &sig[p_len], q_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

430

ret = nn_cmp(s, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

439

&(ctx->verify_data.bip0340.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

440

ret = fp_export_to_buf(&Pubx[0], p_len, &(Y.X)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

441

ret = ctx->h->hfunc_update(&(ctx->verify_data.bip0340.h_ctx), &Pubx[0], p_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

442

ret = local_memset(Pubx, 0, sizeof(Pubx)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

481

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

485

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

508

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

512

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

515

ret = local_memset(&sG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

516

ret = local_memset(&eY, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

528

ret = prj_pt_copy(&Y, &(ctx->pub_key->y)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

529

ret = prj_pt_unique(&Y, &Y); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

533

&e_buf[0]); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

534

ret = nn_init_from_buf(&e, e_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

535

ret = nn_mod(&e, &e, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

54

ret = hash_mapping_callbacks_sanity_check(hm); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

540

ret = prj_pt_mul(&sG, s, G); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

541

ret = nn_mod_neg(&e, &e, q); EG(ret, err); /* compute -e = (q - e) mod q */

crypto/libecc/src/sig/bip0340.c

543

ret = nn_isodd(&(Y.Y.fp_val), &isodd); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

546

ret = fp_neg(&(Y.Y), &(Y.Y)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

548

ret = prj_pt_mul(&eY, &e, &Y); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

549

ret = prj_pt_add(&sG, &sG, &eY); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

550

ret = prj_pt_unique(&sG, &sG); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

555

ret = prj_pt_iszero(&sG, &iszero); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

559

ret = nn_isodd(&(sG.Y.fp_val), &isodd); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

56

ret = hm->hfunc_init(h_ctx); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

563

ret = nn_cmp(&(r->fp_val), &(sG.X.fp_val), &cmp); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

57

ret = hm->hfunc_update(h_ctx, tag, tag_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

58

ret = hm->hfunc_finalize(h_ctx, hash); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

61

ret = hm->hfunc_init(h_ctx); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

62

ret = hm->hfunc_update(h_ctx, hash, hm->digest_size); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

63

ret = hm->hfunc_update(h_ctx, hash, hm->digest_size); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

64

ret = hm->hfunc_update(h_ctx, m, m_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

682

ret = local_memcpy(initial_state, state, sizeof(state)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

708

ret = local_memset(nonce, 0, sizeof(nonce)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

736

(*num)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

745

ret = nn_init_from_buf(a, scalar, q_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

747

ret = nn_iszero(a, &iszero); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

748

ret = nn_cmp(a, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

771

ret = local_memset(Pubx, 0, sizeof(Pubx)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

776

ret = get_hash_by_type(SHA256, &hm); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

783

ret = hm->hfunc_init(&h_ctx); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

785

ret = fp_export_to_buf(&Pubx[0], p_len, &(pub_keys[i]->y.X)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

786

ret = hm->hfunc_update(&h_ctx, &Pubx[0], p_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

789

ret = hm->hfunc_update(&h_ctx, m[i], m_len[i]); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

792

ret = hm->hfunc_update(&h_ctx, s[i], s_len[i]); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

81

ret = prj_pt_check_initialized(P); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

848

ret = local_memset(hash, 0, sizeof(hash)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

849

ret = local_memset(Pubx, 0, sizeof(Pubx)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

850

ret = local_memset(chacha20_seed, 0,sizeof(chacha20_seed)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

851

ret = local_memset(chacha20_scalar, 0,sizeof(chacha20_scalar)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

857

ret = get_hash_by_type(hash_type, &hm); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

86

ret = nn_isone(&(P->Z.fp_val), &isone); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

865

ret = pub_key_check_initialized_and_type(pub_keys[i], BIP0340); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

894

ret = nn_init(&S_sum, 0); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

895

ret = prj_pt_init(&R_sum, shortw_curve); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

896

ret = prj_pt_zero(&R_sum); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

897

ret = prj_pt_init(&P_sum, shortw_curve); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

898

ret = prj_pt_zero(&P_sum); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

899

ret = prj_pt_init(&Tmp, shortw_curve); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

90

ret = nn_isodd(&(P->Y.fp_val), &isodd); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

900

ret = nn_init(&e, 0); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

901

ret = nn_init(&a, 0); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

905

sizeof(chacha20_seed)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

912

q_bit_len, q_len, &a); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

917

ret = fp_init(&rx, pub_key->params->ec_curve.a.ctx); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

918

ret = fp_import_from_buf(&rx, &sig[0], p_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

919

ret = nn_init_from_buf(&S, &sig[p_len], q_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

920

ret = nn_cmp(&S, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

930

ret = nn_mod_mul(&S, &a, &S, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

932

ret = nn_mod_add(&S_sum, &S_sum, &S, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

937

ret = fp_copy(&(R->X), &rx); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

938

ret = aff_pt_y_from_x(&(R->Y), &(R->Z), &rx, shortw_curve); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

940

ret = nn_isodd(&(R->Y.fp_val), &isodd); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

942

ret = fp_copy(&(R->Y), &(R->Z)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

944

ret = fp_one(&(R->Z)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

947

ret = _prj_pt_unprotected_mult(R, &a, R); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

950

ret = prj_pt_add(&R_sum, &R_sum, R); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

959

ret = prj_pt_copy(Y, pub_key_y); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

96

ret = nn_mod_neg(scalar, scalar, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

960

ret = prj_pt_unique(Y, Y); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

962

ret = nn_isodd(&(Y->Y.fp_val), &isodd); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

965

ret = fp_neg(&(Y->Y), &(Y->Y)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

971

&h_ctx); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

972

ret = fp_export_to_buf(&Pubx[0], p_len, &(Y->X)); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

973

ret = hm->hfunc_update(&h_ctx, &Pubx[0], p_len); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

974

ret = hm->hfunc_update(&h_ctx, m[i], m_len[i]); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

975

ret = hm->hfunc_finalize(&h_ctx, hash); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

977

ret = nn_init_from_buf(&e, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

978

ret = nn_mod(&e, &e, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

984

ret = nn_mod_mul(&e, &e, &a, q); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

986

ret = _prj_pt_unprotected_mult(Y, &e, Y); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

989

ret = prj_pt_add(&P_sum, &P_sum, Y); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

996

ret = nn_mod_neg(&S_sum, &S_sum, q); EG(ret, err); /* -S_sum = q - S_sum*/

crypto/libecc/src/sig/bip0340.c

997

ret = _prj_pt_unprotected_mult(&Tmp, &S_sum, G); EG(ret, err);

crypto/libecc/src/sig/bip0340.c

999

ret = prj_pt_add(&Tmp, &Tmp, &R_sum); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

150

(ec_shortw_crv_src_t)&(params->ec_curve)); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

159

ret = nn_isone(&(params->ec_gen_cofactor), &isone); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

161

ret = check_prj_pt_order(&(pub_key->y), &(params->ec_gen_order), PUBLIC_PT, &check); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

192

(ec_shortw_crv_src_t)&(params->ec_curve)); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

201

ret = nn_isone(&(params->ec_gen_cofactor), &isone); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

203

ret = check_prj_pt_order(&(pub_key->y), &(params->ec_gen_order), PUBLIC_PT, &check); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

225

ret = pub_key_check_initialized(pub_key); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

241

ret = pub_key_check_initialized(pub_key); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

259

ret = priv_key_check_initialized(&A->priv_key); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

277

ret = priv_key_check_initialized_and_type(&A->priv_key, alg_type); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

300

priv_key_len, ec_key_alg); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

338

ret = local_strlen((const char *)params->curve_name, &len); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

344

params->curve_name, crv_name_len); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

369

ret = priv_key_check_initialized(priv_key); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

389

ret = local_strlen((const char *)curve_name, &len); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

394

ret = ec_get_curve_type_by_name(curve_name, curve_name_len, &curve_type); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

437

ret = local_strlen((const char *)params->curve_name, &len); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

443

params->curve_name, crv_name_len); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

467

ret = pub_key_check_initialized(pub_key); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

488

ret = local_strlen((const char *)curve_name, &len); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

493

ret = ec_get_curve_type_by_name(curve_name, curve_name_len, &curve_type); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

535

ret = local_strlen((const char *)params->curve_name, &len); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

541

params->curve_name, crv_name_len); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

580

ec_key_alg); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

602

ret = nn_get_random_mod(&(kp->priv_key.x), &(params->ec_gen_order)); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

610

ret = gen_priv_key(&(kp->priv_key)); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

65

ret = nn_init_from_buf(&(priv_key->x), priv_key_buf, priv_key_buf_len); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

86

ret = priv_key_check_initialized(priv_key); EG(ret, err);

crypto/libecc/src/sig/ec_key.c

92

ret = nn_bitlen(&(priv_key->x), &blen); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

101

ret = hmac(K, hsize, hash_type, V, hsize, V, &hmac_size); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

103

ret = hmac_init(&hmac_ctx, K, hsize, hash_type); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

104

ret = hmac_update(&hmac_ctx, V, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

107

ret = hmac_update(&hmac_ctx, &tmp, 1); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

108

ret = hmac_update(&hmac_ctx, priv_key_buff, q_len); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

111

ret = hmac_update(&hmac_ctx, T, q_len); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

113

ret = hmac_finalize(&hmac_ctx, K, &hmac_size); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

116

ret = hmac(K, hsize, hash_type, V, hsize, V, &hmac_size); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

141

ret = hmac(K, hsize, hash_type, V, hsize, V, &hmac_size); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

142

ret = local_memcpy(&T[BYTECEIL(t_bit_len)], V, hmac_size); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

145

ret = nn_init_from_buf(k, T, q_len); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

147

ret = nn_rshift(k, k, (bitcnt_t)((8 * q_len) - q_bit_len)); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

149

ret = nn_cmp(k, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

152

ret = hmac_init(&hmac_ctx, K, hsize, hash_type); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

153

ret = hmac_update(&hmac_ctx, V, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

156

ret = hmac_update(&hmac_ctx, &tmp, 1); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

159

ret = hmac_finalize(&hmac_ctx, K, &hmac_size); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

162

ret = hmac(K, hsize, hash_type, V, hsize, V, &hmac_size); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

182

ret = local_memset(out_pub, 0, sizeof(ec_pub_key)); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

184

ret = priv_key_check_initialized_and_type(in_priv, key_type); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

193

ret = prj_pt_mul_blind(&(out_pub->y), &(in_priv->x), G); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

270

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

273

ret = key_pair_check_initialized_and_type(ctx->key_pair, key_type); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

283

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

284

ret = ctx->h->hfunc_init(&(ctx->sign_data.ecdsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

303

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

307

ret = key_pair_check_initialized_and_type(ctx->key_pair, key_type); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

311

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

345

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

350

ret = key_pair_check_initialized_and_type(ctx->key_pair, key_type); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

353

ret = local_memset(&kG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

367

ret = nn_cmp(x, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

383

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

385

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

386

ret = ctx->h->hfunc_finalize(&(ctx->sign_data.ecdsa.h_ctx), hash); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

407

ret = nn_init_from_buf(&e, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

410

ret = nn_rshift_fixedlen(&e, &e, rshift); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

413

ret = nn_mod(&e, &e, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

469

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

477

ret = prj_pt_mul_blind(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

479

ret = prj_pt_mul(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

481

ret = prj_pt_unique(&kG, &kG); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

487

ret = nn_mod(&r, &(kG.X.fp_val), q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

491

ret = nn_iszero(&r, &iszero); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

497

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

500

ret = nn_export_to_buf(sig, q_len, &r); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

504

ret = nn_mod_mul(&r, &r, &b, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

507

ret = nn_mod_mul(&e, &e, &b, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

511

ret = nn_mod_mul(&tmp, x, &r, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

515

ret = nn_cmp(&e, &tmp, &cmp); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

523

ret = nn_mod_add(&tmp, &tmp, &e, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

531

ret = nn_mod_mul(&k, &k, &b, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

537

ret = nn_modinv_fermat(&kinv, &k, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

542

ret = nn_mod_mul(&s, &tmp, &kinv, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

547

ret = nn_iszero(&s, &iszero); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

629

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

632

ret = pub_key_check_initialized_and_type(ctx->pub_key, key_type); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

648

ret = nn_init_from_buf(r, sig, q_len); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

649

ret = nn_init_from_buf(s, sig + q_len, q_len); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

654

ret = nn_iszero(r, &iszero1); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

655

ret = nn_iszero(s, &iszero2); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

656

ret = nn_cmp(r, q, &cmp1); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

657

ret = nn_cmp(s, q, &cmp2); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

66

ret = nn_check_initialized(q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

662

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

663

ret = ctx->h->hfunc_init(&(ctx->verify_data.ecdsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

67

ret = nn_check_initialized(x); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

688

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

691

ret = pub_key_check_initialized_and_type(ctx->pub_key, key_type); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

695

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

727

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

730

ret = pub_key_check_initialized_and_type(ctx->pub_key, key_type); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

733

ret = local_memset(&uG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

734

ret = local_memset(&vY, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

74

ret = local_memset(V, 0x01, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

747

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

748

ret = ctx->h->hfunc_finalize(&(ctx->verify_data.ecdsa.h_ctx), hash); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

75

ret = local_memset(K, 0x00, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

769

ret = nn_init_from_buf(&e, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

77

ret = nn_export_to_buf(priv_key_buff, q_len, x); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

770

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

773

ret = nn_rshift_fixedlen(&e, &e, rshift); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

777

ret = nn_mod(&e, &e, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

781

ret = nn_modinv(&sinv, s, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

786

ret = nn_mod_mul(&uv, &e, &sinv, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

788

ret = prj_pt_mul(&uG, &uv, G); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

791

ret = nn_mod_mul(&uv, r, &sinv, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

793

ret = prj_pt_mul(&vY, &uv, Y); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

796

ret = prj_pt_add(W_prime, &uG, &vY); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

799

ret = prj_pt_iszero(W_prime, &iszero); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

803

ret = prj_pt_unique(W_prime, W_prime); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

806

ret = nn_mod(&r_prime, &(W_prime->X.fp_val), q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

809

ret = nn_cmp(&r_prime, r, &cmp); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

81

ret = hmac_init(&hmac_ctx, K, hsize, hash_type); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

82

ret = hmac_update(&hmac_ctx, V, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

85

ret = hmac_update(&hmac_ctx, &tmp, 1); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

86

ret = hmac_update(&hmac_ctx, priv_key_buff, q_len); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

885

ret = local_memset(&uG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

89

ret = nn_init_from_buf(k, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

904

ret = nn_init_from_buf(&r, sig, q_len); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

905

ret = nn_init_from_buf(&s, sig + q_len, q_len); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

908

ret = nn_iszero(&r, &iszero1); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

909

ret = nn_iszero(&s, &iszero2); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

91

ret = nn_rshift(k, k, (bitcnt_t)((8 * hsize) - q_bit_len)); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

910

ret = nn_cmp(&r, q, &cmp1); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

911

ret = nn_cmp(&s, q, &cmp2); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

918

ret = nn_mul_word(&u, q, order_multiplier); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

919

ret = nn_add(&r, &r, &u); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

921

ret = nn_cmp(&r, p, &cmp); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

93

ret = nn_mod(k, k, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

94

ret = nn_export_to_buf(T, q_len, k); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

946

ret = nn_init_from_buf(&e, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

948

ret = nn_rshift_fixedlen(&e, &e, rshift); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

95

ret = hmac_update(&hmac_ctx, T, q_len); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

950

ret = nn_mod(&e, &e, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

955

ret = fp_init(&(uG.X), &(params->ec_fp)); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

956

ret = fp_init(&(uG.Y), &(params->ec_fp)); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

957

ret = fp_init(&(uG.Z), &(params->ec_fp)); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

958

ret = fp_set_nn(&(uG.Z), &r); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

97

ret = hmac_finalize(&hmac_ctx, K, &hmac_size); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

974

ret = fp_init(&(Y2->Z), &(params->ec_fp)); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

975

ret = fp_one(&(Y2->Z)); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

977

ret = prj_pt_init_from_coords(Y1, &(params->ec_curve), &(uG.Z), &(uG.X), &(Y2->Z)); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

979

ret = prj_pt_init_from_coords(Y2, &(params->ec_curve), &(uG.Z), &(uG.Y), &(Y1->Z)); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

982

ret = nn_init(&u, 0); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

983

ret = nn_init(&v, 0); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

984

ret = nn_modinv(&r, &r, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

986

ret = nn_mod_mul(&u, &e, &r, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

988

ret = nn_mod_neg(&u, &u, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

990

ret = nn_mod_mul(&v, &s, &r, q); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

993

ret = prj_pt_mul(&uG, &u, G); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

995

ret = prj_pt_mul(Y1, &v, Y1); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

996

ret = prj_pt_add(Y1, Y1, &uG); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

998

ret = prj_pt_mul(Y2, &v, Y2); EG(ret, err);

crypto/libecc/src/sig/ecdsa_common.c

999

ret = prj_pt_add(Y2, Y2, &uG); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

1002

ret = nn_mod_mul(e, e, &a, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

1007

ret = prj_pt_import_from_aff_buf(W, &sig[0], (u16)(2 * p_len), shortw_curve); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

1008

ret = nn_init(&elements[i].number, 0); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

1009

ret = nn_copy(&elements[i].number, &a); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

1010

ret = nn_mod_neg(&elements[i].number, &elements[i].number, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

1026

hash_type, adata, adata_len); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

1036

ret = prj_pt_iszero(&elements[elements[0].index].point, &iszero); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

1068

scratch_pad_area, scratch_pad_area_len); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

1073

hash_type, adata, adata_len); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

134

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

137

ret = local_memset(&kG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

140

ret = key_pair_check_initialized_and_type(ctx->key_pair, ECFSDSA); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

173

ret = ctx->rand(k, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

178

ret = prj_pt_mul_blind(&kG, k, G); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

180

ret = prj_pt_mul(&kG, k, G); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

182

ret = prj_pt_unique(&kG, &kG); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

188

ret = fp_export_to_buf(r, p_len, &(kG.X)); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

189

ret = fp_export_to_buf(r + p_len, p_len, &(kG.Y)); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

208

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

209

ret = ctx->h->hfunc_init(&(ctx->sign_data.ecfsdsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

211

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

212

ret = ctx->h->hfunc_update(&(ctx->sign_data.ecfsdsa.h_ctx), r, r_len); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

242

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

247

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

248

ret = ctx->h->hfunc_update(&(ctx->sign_data.ecfsdsa.h_ctx), chunk, chunklen); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

278

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

295

ret = nn_cmp(x, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

304

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

309

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

312

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

313

ret = ctx->h->hfunc_finalize(&(ctx->sign_data.ecfsdsa.h_ctx), e_buf); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

317

ret = nn_init_from_buf(&e, e_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

318

ret = local_memset(e_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

319

ret = nn_mod(&e, &e, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

323

ret = nn_mod_mul(&e, &e, &b, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

326

ret = nn_mod_mul(&ex, &e, x, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

329

ret = nn_mod_mul(&s, k, &b, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

330

ret = nn_mod_add(&s, &s, &ex, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

332

ret = nn_mod_add(&s, k, &ex, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

339

ret = nn_modinv_fermat(&binv, &b, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

340

ret = nn_mod_mul(&s, &s, &binv, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

353

ret = local_memcpy(sig, r, r_len); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

354

ret = local_memset(r, 0, r_len); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

40

ret = local_memset(out_pub, 0, sizeof(ec_pub_key)); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

42

ret = priv_key_check_initialized_and_type(in_priv, ECFSDSA); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

430

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

433

ret = pub_key_check_initialized_and_type(ctx->pub_key, ECFSDSA); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

453

ret = fp_init(&rx, ctx->pub_key->params->ec_curve.a.ctx); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

454

ret = fp_import_from_buf(&rx, r, p_len); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

455

ret = fp_init(&ry, ctx->pub_key->params->ec_curve.a.ctx); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

456

ret = fp_import_from_buf(&ry, r + p_len, p_len); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

459

ret = is_on_shortw_curve(&rx, &ry, &(ctx->pub_key->params->ec_curve), &on_curve); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

465

ret = nn_init_from_buf(s, sig + r_len, s_len); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

468

ret = nn_iszero(s, &iszero); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

469

ret = nn_cmp(s, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

475

ret = local_memcpy(&(ctx->verify_data.ecfsdsa.r), r, r_len); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

477

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

478

ret = ctx->h->hfunc_init(&(ctx->verify_data.ecfsdsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

481

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

482

ret = ctx->h->hfunc_update(&(ctx->verify_data.ecfsdsa.h_ctx), r, r_len); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

51

ret = prj_pt_mul_blind(&(out_pub->y), &(in_priv->x), G); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

523

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

528

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

561

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

565

ret = local_memset(&sG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

566

ret = local_memset(&eY, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

581

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

582

ret = ctx->h->hfunc_finalize(&(ctx->verify_data.ecfsdsa.h_ctx), e_buf); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

590

ret = nn_init_from_buf(&tmp, e_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

591

ret = local_memset(e_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

592

ret = nn_mod(&tmp, &tmp, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

594

ret = nn_mod_neg(&e, &tmp, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

597

ret = prj_pt_mul(&sG, s, G); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

598

ret = prj_pt_mul(&eY, &e, Y); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

599

ret = prj_pt_add(Wprime, &sG, &eY); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

600

ret = prj_pt_unique(Wprime, Wprime); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

603

ret = fp_export_to_buf(r_prime, p_len, &(Wprime->X)); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

604

ret = fp_export_to_buf(r_prime + p_len, p_len, &(Wprime->Y)); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

609

ret = are_equal(r, r_prime, r_len, &check); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

691

ret = local_memset(hash, 0, sizeof(hash)); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

697

ret = get_hash_by_type(hash_type, &hm); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

705

ret = pub_key_check_initialized_and_type(pub_keys[i], ECFSDSA); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

734

ret = nn_init(&S_sum, 0); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

735

ret = prj_pt_init(&W_sum, shortw_curve); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

736

ret = prj_pt_zero(&W_sum); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

737

ret = prj_pt_init(&Y_sum, shortw_curve); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

738

ret = prj_pt_zero(&Y_sum); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

739

ret = prj_pt_init(&Tmp, shortw_curve); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

740

ret = nn_init(&e, 0); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

741

ret = nn_init(&a, 0); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

745

ret = nn_get_random_mod(&a, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

749

ret = nn_init_from_buf(&S, &sig[2 * p_len], q_len); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

750

ret = nn_cmp(&S, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

758

ret = nn_mod_mul(&S, &a, &S, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

760

&S, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

768

ret = prj_pt_copy(Y, pub_key_y); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

769

ret = prj_pt_unique(Y, Y); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

773

ret = hm->hfunc_init(&h_ctx); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

774

ret = hm->hfunc_update(&h_ctx, &sig[0], (u32)(2 * p_len)); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

775

ret = hm->hfunc_update(&h_ctx, m[i], m_len[i]); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

776

ret = hm->hfunc_finalize(&h_ctx, hash); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

778

ret = nn_init_from_buf(&e, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

779

ret = nn_mod(&e, &e, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

780

ret = nn_mod_neg(&e, &e, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

785

ret = nn_mod_mul(&e, &e, &a, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

787

ret = _prj_pt_unprotected_mult(Y, &e, Y); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

790

ret = prj_pt_add(&Y_sum, &Y_sum, Y); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

795

ret = prj_pt_import_from_aff_buf(W, &sig[0], (u16)(2 * p_len), shortw_curve); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

798

ret = nn_mod_neg(&a, &a, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

799

ret = _prj_pt_unprotected_mult(W, &a, W); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

802

ret = prj_pt_add(&W_sum, &W_sum, W); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

809

ret = _prj_pt_unprotected_mult(&Tmp, &S_sum, G); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

811

ret = prj_pt_add(&Tmp, &Tmp, &W_sum); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

812

ret = prj_pt_add(&Tmp, &Tmp, &Y_sum); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

814

ret = prj_pt_iszero(&Tmp, &iszero); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

878

ret = local_memset(hash, 0, sizeof(hash)); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

917

ret = get_hash_by_type(hash_type, &hm); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

925

ret = pub_key_check_initialized_and_type(pub_keys[i], ECFSDSA); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

954

ret = nn_init(&a, 0); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

955

ret = nn_init(&elements[(2 * num)].number, 0); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

956

ret = prj_pt_copy(&elements[(2 * num)].point, G); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

960

ret = nn_get_random_mod(&a, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

964

ret = nn_init_from_buf(&S, &sig[2 * p_len], q_len); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

965

ret = nn_cmp(&S, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

973

ret = nn_mod_mul(&S, &a, &S, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

975

&S, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

983

ret = prj_pt_copy(Y, pub_key_y); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

984

ret = prj_pt_unique(Y, Y); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

989

ret = nn_init(e, 0); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

990

ret = hm->hfunc_init(&h_ctx); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

991

ret = hm->hfunc_update(&h_ctx, &sig[0], (u32)(2 * p_len)); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

992

ret = hm->hfunc_update(&h_ctx, m[i], m_len[i]); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

993

ret = hm->hfunc_finalize(&h_ctx, hash); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

995

ret = nn_init_from_buf(e, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

996

ret = nn_mod(e, e, q); EG(ret, err);

crypto/libecc/src/sig/ecfsdsa.c

997

ret = nn_mod_neg(e, e, q); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

137

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

140

ret = key_pair_check_initialized_and_type(ctx->key_pair, ECGDSA); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

149

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

150

ret = ctx->h->hfunc_init(&(ctx->sign_data.ecgdsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

169

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

174

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

207

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

212

ret = local_memset(&kG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

227

ret = nn_cmp(x, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

242

ret = local_memset(e_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

244

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

245

ret = ctx->h->hfunc_finalize(&(ctx->sign_data.ecgdsa.h_ctx), e_buf); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

257

ret = nn_init_from_buf(&tmp, e_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

258

ret = local_memset(e_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

260

ret = nn_rshift_fixedlen(&tmp, &tmp, rshift); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

271

ret = nn_mod(&tmp, &tmp, q); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

272

ret = nn_mod_neg(&e, &tmp, q); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

286

ret = ctx->rand(&k, q); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

291

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

298

ret = prj_pt_mul_blind(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

300

ret = prj_pt_mul(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

302

ret = prj_pt_unique(&kG, &kG); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

308

ret = nn_mod(&r, &(kG.X.fp_val), q); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

312

ret = nn_iszero(&r, &iszero); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

318

ret = nn_export_to_buf(sig, r_len, &r); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

322

ret = nn_mod_mul(&e, &e, &b, q); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

323

ret = nn_mod_mul(&r, &r, &b, q); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

326

ret = nn_mod_mul(&kr, &k, &r, q); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

327

ret = nn_mod_add(&tmp, &kr, &e, q); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

328

ret = nn_mod_mul(&s, x, &tmp, q); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

334

ret = nn_modinv_fermat(&binv, &b, q); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

335

ret = nn_mod_mul(&s, &s, &binv, q); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

340

ret = nn_iszero(&s, &iszero); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

42

ret = local_memset(out_pub, 0, sizeof(ec_pub_key)); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

423

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

426

ret = pub_key_check_initialized_and_type(ctx->pub_key, ECGDSA); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

44

ret = priv_key_check_initialized_and_type(in_priv, ECGDSA); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

445

ret = nn_init_from_buf(r, sig, r_len); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

448

ret = nn_init_from_buf(s, sig + r_len, s_len); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

451

ret = nn_iszero(s, &iszero1); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

452

ret = nn_iszero(r, &iszero2); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

453

ret = nn_cmp(s, q, &cmp1); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

454

ret = nn_cmp(r, q, &cmp2); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

460

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

461

ret = ctx->h->hfunc_init(&(ctx->verify_data.ecgdsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

487

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

492

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

524

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

528

ret = local_memset(&uG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

529

ret = local_memset(&vY, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

542

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

543

ret = ctx->h->hfunc_finalize(&(ctx->verify_data.ecgdsa.h_ctx), e_buf); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

55

ret = nn_modinv_fermat(&xinv, &(in_priv->x), &(in_priv->params->ec_gen_order)); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

555

ret = nn_init_from_buf(&e, e_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

556

ret = local_memset(e_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

558

ret = nn_rshift_fixedlen(&e, &e, rshift); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

563

ret = nn_mod(&e, &e, q); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

566

ret = nn_modinv(&rinv, r, q); EG(ret, err); /* r^-1 */

crypto/libecc/src/sig/ecgdsa.c

567

ret = nn_mod_mul(&uv, &rinv, &e, q); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

568

ret = prj_pt_mul(&uG, &uv, G); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

57

ret = prj_pt_mul_blind(&(out_pub->y), &xinv, G); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

571

ret = nn_mod_mul(&uv, &rinv, s, q); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

572

ret = prj_pt_mul(&vY, &uv, Y); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

575

ret = prj_pt_add(Wprime, &uG, &vY); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

578

ret = prj_pt_unique(Wprime, Wprime); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

581

ret = nn_mod(&r_prime, &(Wprime->X.fp_val), q); EG(ret, err);

crypto/libecc/src/sig/ecgdsa.c

584

ret = nn_cmp(r, &r_prime, &cmp); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

213

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

216

ret = key_pair_check_initialized_and_type(ctx->key_pair, ECKCDSA); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

241

ret = prj_pt_to_aff(&y_aff, &(pub_key->y)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

242

ret = local_memset(tmp_buf, 0, sizeof(tmp_buf)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

243

ret = fp_export_to_buf(tmp_buf, p_len, &(y_aff.x)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

244

ret = fp_export_to_buf(tmp_buf + p_len, p_len, &(y_aff.y)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

249

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

250

ret = ctx->h->hfunc_init(&(ctx->sign_data.eckcdsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

251

ret = ctx->h->hfunc_update(&(ctx->sign_data.eckcdsa.h_ctx), tmp_buf, z_len); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

252

ret = local_memset(tmp_buf, 0, sizeof(tmp_buf)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

279

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

284

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

324

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

329

ret = local_memset(&kG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

343

ret = nn_cmp(x, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

358

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

359

ret = ctx->h->hfunc_finalize(&(ctx->sign_data.eckcdsa.h_ctx), hzm); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

370

ret = buf_lshift(hzm, hsize, shift); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

384

ret = ctx->rand(&k, q); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

390

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

397

ret = prj_pt_mul_blind(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

399

ret = prj_pt_mul(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

401

ret = prj_pt_unique(&kG, &kG); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

406

ret = local_memset(tmp_buf, 0, sizeof(tmp_buf)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

407

ret = fp_export_to_buf(tmp_buf, p_len, &(kG.X)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

409

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

410

ret = ctx->h->hfunc_init(&r_ctx); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

411

ret = ctx->h->hfunc_update(&r_ctx, tmp_buf, p_len); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

412

ret = ctx->h->hfunc_finalize(&r_ctx, r); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

413

ret = local_memset(tmp_buf, 0, p_len); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

414

ret = local_memset(&r_ctx, 0, sizeof(hash_context)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

424

ret = buf_lshift(r, hsize, shift); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

431

ret = nn_init_from_buf(&tmp, hzm, r_len); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

432

ret = local_memset(hzm, 0, r_len); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

433

ret = nn_mod(&e, &tmp, q); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

438

ret = nn_mod_mul(&k, &k, &b, q); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

439

ret = nn_mod_mul(&e, &e, &b, q); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

44

ret = priv_key_check_initialized_and_type(in_priv, ECKCDSA); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

443

ret = nn_modinv_fermat(&binv, &b, q); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

452

ret = nn_mod_neg(&tmp, &e, q); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

453

ret = nn_mod_add(&tmp, &k, &tmp, q); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

454

ret = nn_mod_mul(&s, x, &tmp, q); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

457

ret = nn_mod_mul(&s, &s, &binv, q); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

461

ret = nn_iszero(&s, &iszero); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

469

ret = local_memcpy(sig, r, r_len); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

470

ret = local_memset(r, 0, r_len); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

50

ret = local_memset(out_pub, 0, sizeof(ec_pub_key)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

561

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

565

ret = pub_key_check_initialized_and_type(ctx->pub_key, ECKCDSA); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

592

ret = nn_init_from_buf(&s, sig + r_len, s_len); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

593

ret = nn_iszero(&s, &iszero); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

594

ret = nn_cmp(&s, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

60

ret = nn_modinv_fermat(&xinv, &(in_priv->x), q); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

614

ret = prj_pt_to_aff(&y_aff, &(pub_key->y)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

615

ret = local_memset(tmp_buf, 0, sizeof(tmp_buf)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

616

ret = fp_export_to_buf(tmp_buf, p_len, &(y_aff.x)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

617

ret = fp_export_to_buf(tmp_buf + p_len, p_len, &(y_aff.y)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

622

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

623

ret = ctx->h->hfunc_init(&(ctx->verify_data.eckcdsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

625

z_len); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

626

ret = local_memset(tmp_buf, 0, sizeof(tmp_buf)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

63

ret = prj_pt_mul_blind(&(out_pub->y), &xinv, G); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

632

ret = local_memcpy(ctx->verify_data.eckcdsa.r, sig, r_len); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

633

ret = nn_copy(&(ctx->verify_data.eckcdsa.s), &s); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

676

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

681

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

723

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

727

ret = local_memset(&sY, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

728

ret = local_memset(&eG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

745

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

746

ret = ctx->h->hfunc_finalize(&(ctx->verify_data.eckcdsa.h_ctx), hzm); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

756

ret = buf_lshift(hzm, hsize, shift); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

763

ret = nn_init_from_buf(&tmp, hzm, r_len); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

764

ret = local_memset(hzm, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

765

ret = nn_mod(&e, &tmp, q); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

770

ret = prj_pt_mul(&sY, s, Y); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

771

ret = prj_pt_mul(&eG, &e, G); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

772

ret = prj_pt_add(Wprime, &sY, &eG); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

773

ret = prj_pt_unique(Wprime, Wprime); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

778

ret = local_memset(tmp_buf, 0, sizeof(tmp_buf)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

779

ret = fp_export_to_buf(tmp_buf, p_len, &(Wprime->X)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

781

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

782

ret = ctx->h->hfunc_init(&r_prime_ctx); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

783

ret = ctx->h->hfunc_update(&r_prime_ctx, tmp_buf, p_len); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

784

ret = ctx->h->hfunc_finalize(&r_prime_ctx, r_prime); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

785

ret = local_memset(tmp_buf, 0, p_len); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

786

ret = local_memset(&r_prime_ctx, 0, sizeof(hash_context)); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

794

ret = buf_lshift(r_prime, hsize, shift); EG(ret, err);

crypto/libecc/src/sig/eckcdsa.c

799

ret = are_equal(r, r_prime, r_len, &check); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

154

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

157

ret = key_pair_check_initialized_and_type(ctx->key_pair, ECRDSA); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

166

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

167

ret = ctx->h->hfunc_init(&(ctx->sign_data.ecrdsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

185

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

189

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

222

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

226

ret = local_memset(&kG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

240

ret = nn_cmp(x, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

263

ret = ctx->rand(&k, q); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

269

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

276

ret = prj_pt_mul_blind(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

278

ret = prj_pt_mul(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

280

ret = prj_pt_unique(&kG, &kG); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

285

ret = nn_mod(&r, &(kG.X.fp_val), q); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

288

ret = nn_iszero(&r, &iszero); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

295

ret = nn_export_to_buf(sig, r_len, &r); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

298

ret = local_memset(h_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

300

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

301

ret = ctx->h->hfunc_finalize(&(ctx->sign_data.ecrdsa.h_ctx), h_buf); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

307

ret = _reverse_endianness(h_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

309

ret = nn_init_from_buf(&e, h_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

310

ret = local_memset(h_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

311

ret = nn_mod(&e, &e, q); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

312

ret = nn_iszero(&e, &iszero); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

314

ret = nn_inc(&e, &e); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

320

ret = nn_mod_mul(&r, &r, &b, q); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

321

ret = nn_mod_mul(&e, &e, &b, q); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

325

ret = nn_mod_mul(&rx, &r, x, q); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

326

ret = nn_mod_mul(&ke, &k, &e, q); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

327

ret = nn_mod_add(&s, &rx, &ke, q); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

333

ret = nn_modinv_fermat(&binv, &b, q); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

334

ret = nn_mod_mul(&s, &s, &binv, q); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

338

ret = nn_iszero(&s, &iszero); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

428

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

431

ret = pub_key_check_initialized_and_type(ctx->pub_key, ECRDSA); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

444

ret = nn_init_from_buf(&r, sig, r_len); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

445

ret = nn_init_from_buf(&s, sig + r_len, s_len); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

446

ret = nn_iszero(&s, &iszero1); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

447

ret = nn_iszero(&r, &iszero2); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

448

ret = nn_cmp(&s, q, &cmp1); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

449

ret = nn_cmp(&s, q, &cmp2); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

453

ret = nn_copy(&(ctx->verify_data.ecrdsa.r), &r); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

454

ret = nn_copy(&(ctx->verify_data.ecrdsa.s), &s); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

456

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

457

ret = ctx->h->hfunc_init(&(ctx->verify_data.ecrdsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

485

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

490

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

521

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

525

ret = local_memset(&uG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

526

ret = local_memset(&vY, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

537

ret = local_memset(h_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

539

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

540

ret = ctx->h->hfunc_finalize(&(ctx->verify_data.ecrdsa.h_ctx), h_buf); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

546

ret = _reverse_endianness(h_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

550

ret = nn_init_from_buf(&h, h_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

551

ret = local_memset(h_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

552

ret = nn_mod(&h, &h, q); EG(ret, err); /* h = OS2I(h) mod q */

crypto/libecc/src/sig/ecrdsa.c

553

ret = nn_iszero(&h, &iszero); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

555

ret = nn_inc(&h, &h); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

557

ret = nn_modinv(&e, &h, q); EG(ret, err); /* e = h^-1 mod q */

crypto/libecc/src/sig/ecrdsa.c

560

ret = nn_mod_mul(&u, &e, s, q); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

569

ret = nn_mod_mul(&e, &e, r, q); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

570

ret = nn_mod_neg(&v, &e, q); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

573

ret = prj_pt_mul(&uG, &u, G); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

574

ret = prj_pt_mul(&vY, &v, Y); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

575

ret = prj_pt_add(Wprime, &uG, &vY); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

576

ret = prj_pt_unique(Wprime, Wprime); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

581

ret = nn_mod(&r_prime, &(Wprime->X.fp_val), q); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

584

ret = nn_cmp(r, &r_prime, &cmp); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

80

ret = local_memset(out_pub, 0, sizeof(ec_pub_key)); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

82

ret = priv_key_check_initialized_and_type(in_priv, ECRDSA); EG(ret, err);

crypto/libecc/src/sig/ecrdsa.c

91

ret = prj_pt_mul_blind(&(out_pub->y), &(in_priv->x), G); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

157

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

160

ret = local_memset(&kG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

163

ret = key_pair_check_initialized_and_type(ctx->key_pair, key_type); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

190

ret = ctx->rand(&k, q); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

195

ret = prj_pt_mul_blind(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

197

ret = prj_pt_mul(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

199

ret = prj_pt_unique(&kG, &kG); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

210

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

211

ret = ctx->h->hfunc_init(&(ctx->sign_data.ecsdsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

212

ret = fp_export_to_buf(Wx, p_len, &(kG.X)); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

213

ret = ctx->h->hfunc_update(&(ctx->sign_data.ecsdsa.h_ctx), Wx, p_len); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

215

ret = fp_export_to_buf(Wy, p_len, &(kG.Y)); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

217

p_len); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

219

ret = local_memset(Wx, 0, p_len); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

220

ret = local_memset(Wy, 0, p_len); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

223

ret = nn_copy(&(ctx->sign_data.ecsdsa.k), &k); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

254

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

259

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

260

ret = ctx->h->hfunc_update(&(ctx->sign_data.ecsdsa.h_ctx), chunk, chunklen); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

294

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

310

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

315

ret = local_memset(r, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

317

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

318

ret = ctx->h->hfunc_finalize(&(ctx->sign_data.ecsdsa.h_ctx), r); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

323

ret = nn_init_from_buf(&e, r, r_len); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

324

ret = nn_mod(&e, &e, q); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

337

ret = nn_mod_mul(&e, &e, &b, q); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

341

ret = nn_mod_mul(&ex, x, &e, q); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

344

ret = nn_mod_mul(&s, &(ctx->sign_data.ecsdsa.k), &b, q); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

345

ret = nn_mod_add(&s, &s, &ex, q); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

347

ret = nn_mod_add(&s, &(ctx->sign_data.ecsdsa.k), &ex, q); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

355

ret = nn_modinv_fermat(&binv, &b, q); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

356

ret = nn_mod_mul(&s, &s, &binv, q); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

369

ret = local_memcpy(sig, r, r_len); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

370

ret = local_memset(r, 0, r_len); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

44

ret = local_memset(out_pub, 0, sizeof(ec_pub_key)); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

449

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

452

ret = local_memset(&sG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

453

ret = local_memset(&eY, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

456

ret = pub_key_check_initialized_and_type(ctx->pub_key, key_type); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

46

ret = priv_key_check_initialized_and_type(in_priv, key_type); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

475

ret = nn_init_from_buf(&s, sig + r_len, s_len); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

476

ret = nn_iszero(&s, &iszero); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

477

ret = nn_cmp(&s, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

486

ret = nn_init_from_buf(&r, sig, r_len); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

487

ret = nn_mod(&rmodq, &r, q); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

488

ret = nn_mod_neg(&e, &rmodq, q); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

491

ret = nn_iszero(&e, &iszero); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

495

ret = prj_pt_mul(&sG, &s, G); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

496

ret = prj_pt_mul(&eY, &e, Y); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

497

ret = prj_pt_add(Wprime, &sG, &eY); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

498

ret = prj_pt_unique(Wprime, Wprime); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

507

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

508

ret = ctx->h->hfunc_init(&(ctx->verify_data.ecsdsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

509

ret = fp_export_to_buf(Wprimex, p_len, &(Wprime->X)); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

51

ret = prj_pt_mul_blind(&(out_pub->y), &(in_priv->x), G); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

511

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

512

ret = ctx->h->hfunc_update(&(ctx->verify_data.ecsdsa.h_ctx), Wprimex, p_len); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

514

ret = fp_export_to_buf(Wprimey, p_len, &(Wprime->Y)); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

516

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

518

Wprimey, p_len); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

520

ret = local_memset(Wprimex, 0, p_len); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

521

ret = local_memset(Wprimey, 0, p_len); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

524

ret = local_memcpy(ctx->verify_data.ecsdsa.r, sig, r_len); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

525

ret = nn_copy(&(ctx->verify_data.ecsdsa.s), &s); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

567

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

572

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

595

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

602

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

603

ret = ctx->h->hfunc_finalize(&(ctx->verify_data.ecsdsa.h_ctx), r_prime); EG(ret, err);

crypto/libecc/src/sig/ecsdsa_common.c

606

ret = are_equal(ctx->verify_data.ecsdsa.r, r_prime, r_len, &check); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1011

gamma_montgomery, alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1013

alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1042

shortw_curve_params, sig_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1065

ret = get_hash_by_type(hash_type, &hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1073

ret = hash_mapping_callbacks_sanity_check(hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1074

ret = hash->hfunc_init(&hash_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1075

ret = hash->hfunc_update(&hash_ctx, message, message_size); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1076

ret = hash->hfunc_finalize(&hash_ctx, digest); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1123

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1144

ret = eddsa_key_pair_sanity_check(key_pair); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1154

ret = nn_bitlen(&(key_pair->priv_key.x), &blen); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1162

ret = hash_mapping_callbacks_sanity_check(h); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1163

ret = h->hfunc_init(&(ctx->sign_data.eddsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1189

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1213

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1263

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1268

ret = local_memset(&R, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1269

ret = local_memset(&Tmp_edwards, 0, sizeof(aff_pt_edwards)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1270

ret = local_memset(&crv_edwards, 0, sizeof(ec_edwards_crv)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1271

ret = local_memset(hash, 0, sizeof(hash)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1272

ret = local_memset(ph_hash, 0, sizeof(ph_hash)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1325

ret = hash_mapping_callbacks_sanity_check(h); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1327

ret = h->hfunc_finalize(&(ctx->sign_data.eddsa.h_ctx), ph_hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1332

ret = eddsa_get_digest_from_priv_key(hash, &hash_size, priv_key); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1338

ret = h->hfunc_init(&(ctx->sign_data.eddsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1344

&(ctx->sign_data.eddsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1350

&(ctx->sign_data.eddsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1353

ret = h->hfunc_update(&(ctx->sign_data.eddsa.h_ctx), &hash[hsize / 2], hsize / 2); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1359

use_message_pre_hash_hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1362

ret = h->hfunc_finalize(&(ctx->sign_data.eddsa.h_ctx), hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1366

ret = eddsa_decode_integer(&r, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1372

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1377

ret = nn_modinv_fermat(&binv, &b, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1380

ret = nn_mul(&r, &r, &b); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1386

ret = nn_mod_notrim(&r, &r, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1399

ret = nn_init(&r_tmp, 0); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

1400

ret = nn_modinv_word(&r_tmp, WORD(4), q); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

1401

ret = nn_mod_mul(&r_tmp, &r_tmp, &r, q); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

1405

ret = nn_mod_mul(&r_tmp, &r_tmp, &binv, q); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

1412

EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1421

ret = nn_init(&r_tmp, 0); EG(ret, err2);

crypto/libecc/src/sig/eddsa.c

1422

ret = nn_copy(&r_tmp, &r); EG(ret, err2);

crypto/libecc/src/sig/eddsa.c

1425

ret = nn_mod_mul(&r_tmp, &r_tmp, &binv, q); EG(ret, err2);

crypto/libecc/src/sig/eddsa.c

1426

ret = prj_pt_mul_blind(&R, &r_tmp, G); EG(ret, err2);

crypto/libecc/src/sig/eddsa.c

1429

EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1431

ret = prj_pt_mul(&R, &r, G); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1436

ret = h->hfunc_init(&(ctx->sign_data.eddsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1439

gamma_montgomery, alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1441

alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1447

r_len, key_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1452

&(ctx->sign_data.eddsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1458

&(ctx->sign_data.eddsa.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1462

ret = h->hfunc_update(&(ctx->sign_data.eddsa.h_ctx), &sig[0], r_len); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1466

&Tmp_edwards, alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1472

r_len, key_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1475

ret = h->hfunc_update(&(ctx->sign_data.eddsa.h_ctx), hash, r_len); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1478

use_message_pre_hash_hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1480

ret = h->hfunc_finalize(&(ctx->sign_data.eddsa.h_ctx), hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1483

ret = eddsa_decode_integer(&S, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1484

ret = nn_mod(&S, &S, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1487

ret = eddsa_get_digest_from_priv_key(hash, &hsize, priv_key); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1489

ret = eddsa_compute_s(&s, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1490

ret = nn_mod(&s, &s, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1494

ret = nn_mod_mul(&S, &S, &b, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1497

ret = nn_mod_mul(&S, &S, &s, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1501

ret = nn_mod_add(&S, &S, &r, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1504

ret = nn_mod_mul(&S, &S, &binv, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1603

ret = local_memset(&R, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1604

ret = local_memset(&Tmp_edwards, 0, sizeof(aff_pt_edwards)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1605

ret = local_memset(&crv_edwards, 0, sizeof(ec_edwards_crv)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1606

ret = local_memset(hash, 0, sizeof(hash)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1607

ret = local_memset(ph_hash, 0, sizeof(ph_hash)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1610

ret = eddsa_key_pair_sanity_check(key_pair); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1613

ret = get_hash_by_type(hash_type, &h); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1625

ret = nn_bitlen(&(key_pair->priv_key.x), &blen); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1671

ret = eddsa_compute_pre_hash(m, mlen, ph_hash, &hash_size, sig_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1677

ret = eddsa_get_digest_from_priv_key(hash, &hash_size, &(key_pair->priv_key)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1681

ret = hash_mapping_callbacks_sanity_check(h); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1682

ret = h->hfunc_init(&h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1687

ret = dom2(0, adata, adata_len, h, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1690

ret = dom2(1, adata, adata_len, h, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1695

ret = dom4(0, adata, adata_len, h, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1698

ret = dom4(1, adata, adata_len, h, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1701

ret = h->hfunc_update(&h_ctx, &hash[hsize / 2], hsize / 2); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1705

ret = h->hfunc_update(&h_ctx, ph_hash, use_message_pre_hash_hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1708

ret = h->hfunc_update(&h_ctx, m, mlen); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1710

ret = h->hfunc_finalize(&h_ctx, hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1714

ret = eddsa_decode_integer(&r, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1720

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1725

ret = nn_modinv_fermat(&binv, &b, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1728

ret = nn_mul(&r, &r, &b); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1734

ret = nn_mod_notrim(&r, &r, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1747

ret = nn_init(&r_tmp, 0); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

1748

ret = nn_modinv_word(&r_tmp, WORD(4), q); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

1749

ret = nn_mod_mul(&r_tmp, &r_tmp, &r, q); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

1753

ret = nn_mod_mul(&r_tmp, &r_tmp, &binv, q); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

1760

EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1769

ret = nn_init(&r_tmp, 0); EG(ret, err2);

crypto/libecc/src/sig/eddsa.c

1770

ret = nn_copy(&r_tmp, &r); EG(ret, err2);

crypto/libecc/src/sig/eddsa.c

1773

ret = nn_mod_mul(&r_tmp, &r_tmp, &binv, q); EG(ret, err2);

crypto/libecc/src/sig/eddsa.c

1774

ret = prj_pt_mul_blind(&R, &r_tmp, G); EG(ret, err2);

crypto/libecc/src/sig/eddsa.c

1777

EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1779

ret = prj_pt_mul(&R, &r, G); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1784

ret = hash_mapping_callbacks_sanity_check(h); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1785

ret = h->hfunc_init(&h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1788

gamma_montgomery, alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1790

alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1795

r_len, key_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1803

ret = dom2(0, adata, adata_len, h, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1806

ret = dom2(1, adata, adata_len, h, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1811

ret = dom4(0, adata, adata_len, h, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1814

ret = dom4(1, adata, adata_len, h, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1818

ret = h->hfunc_update(&h_ctx, &sig[0], r_len); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1821

alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1827

hash, r_len, key_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1829

ret = h->hfunc_update(&h_ctx, hash, r_len); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1832

ret = h->hfunc_update(&h_ctx, ph_hash, use_message_pre_hash_hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1835

ret = h->hfunc_update(&h_ctx, m, mlen); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1838

ret = h->hfunc_finalize(&h_ctx, hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1841

ret = eddsa_decode_integer(&S, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1842

ret = nn_mod(&S, &S, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1845

ret = eddsa_get_digest_from_priv_key(hash, &hsize, priv_key); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1846

ret = eddsa_compute_s(&s, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1847

ret = nn_mod(&s, &s, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1850

ret = nn_mod_mul(&S, &S, &b, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1853

ret = nn_mod_mul(&S, &S, &s, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1857

ret = nn_mod_add(&S, &S, &r, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1860

ret = nn_mod_mul(&S, &S, &binv, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1941

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1945

ret = local_memset(&A, 0, sizeof(aff_pt_edwards)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1946

ret = local_memset(&crv_edwards, 0, sizeof(ec_edwards_crv)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1947

ret = local_memset(buff, 0, sizeof(buff)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1948

ret = local_memset(&R, 0, sizeof(R)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1949

ret = local_memset(&_Tmp, 0, sizeof(_Tmp)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

195

ret = priv_key_check_initialized(in_priv); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1952

ret = eddsa_pub_key_sanity_check(ctx->pub_key); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1981

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1982

ret = ctx->h->hfunc_init(h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1983

ret = ctx->h->hfunc_init(h_ctx_pre_hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1988

ret = dom2(0, ctx->adata, ctx->adata_len, ctx->h, h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1991

ret = dom2(1, ctx->adata, ctx->adata_len, ctx->h, h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1996

ret = dom4(0, ctx->adata, ctx->adata_len, ctx->h, h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

1999

ret = dom4(1, ctx->adata, ctx->adata_len, ctx->h, h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2006

gamma_montgomery, alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2009

EDDSA_R_LEN(hsize), key_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2012

ret = aff_pt_edwards_to_prj_pt_shortw(&R, shortw_curve, _R, alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2014

ret = ctx->h->hfunc_update(h_ctx, &sig[0], EDDSA_R_LEN(hsize)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2018

ret = eddsa_decode_integer(S, &sig[EDDSA_R_LEN(hsize)], EDDSA_S_LEN(hsize)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2020

ret = nn_cmp(S, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2033

ret = _prj_pt_unprotected_mult(&_Tmp, gen_cofactor, pub_key_y); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2037

ret = prj_pt_iszero(&_Tmp, &iszero); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2041

ret = prj_pt_shortw_to_aff_pt_edwards(pub_key_y, &crv_edwards, &A, alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2045

ret = eddsa_encode_point(&A, alpha_edwards, buff, EDDSA_R_LEN(hsize), key_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2048

ret = ctx->h->hfunc_update(h_ctx, buff, EDDSA_R_LEN(hsize)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

208

ret = pub_key_check_initialized(in_pub); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2088

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2111

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2115

chunk, chunklen); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2119

ret = ctx->h->hfunc_update(h_ctx, chunk, chunklen); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2151

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2155

ret = local_memset(&_Tmp1, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2156

ret = local_memset(&_Tmp2, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2157

ret = local_memset(hash, 0, sizeof(hash)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2192

ret = nn_cmp(S, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2199

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2202

ret = ctx->h->hfunc_finalize(h_ctx_pre_hash, hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2204

ret = ctx->h->hfunc_update(h_ctx, hash, use_message_pre_hash_hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2206

ret = ctx->h->hfunc_finalize(h_ctx, hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

221

ret = eddsa_priv_key_sanity_check(&(key_pair->priv_key)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2210

ret = eddsa_decode_integer(&h, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2211

ret = nn_mod(&h, &h, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

222

ret = eddsa_pub_key_sanity_check(&(key_pair->pub_key)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2220

ret = nn_lshift(&h, &h, 2); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2221

ret = nn_mod(&h, &h, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2225

ret = prj_pt_mul(&_Tmp1, S, G); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2226

ret = prj_pt_neg(&_Tmp2, _R); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2227

ret = prj_pt_add(&_Tmp1, &_Tmp1, &_Tmp2); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2228

ret = prj_pt_mul(&_Tmp2, &h, A); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2229

ret = prj_pt_neg(&_Tmp2, &_Tmp2); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2230

ret = prj_pt_add(&_Tmp1, &_Tmp1, &_Tmp2); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2236

ret = _prj_pt_unprotected_mult(&_Tmp2, gen_cofactor, &_Tmp1); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2239

ret = prj_pt_iszero(&_Tmp2, &iszero); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2320

ret = local_memset(&crv_edwards, 0, sizeof(ec_edwards_crv)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2321

ret = local_memset(hash, 0, sizeof(hash)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2322

ret = local_memset(&A, 0, sizeof(aff_pt_edwards)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2323

ret = local_memset(&R, 0, sizeof(aff_pt_edwards)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2324

ret = local_memset(&_R_sum, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2325

ret = local_memset(&_A_sum, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2326

ret = local_memset(&_Tmp, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2332

ret = get_hash_by_type(hash_type, &hm); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2357

ret = eddsa_pub_key_sanity_check(pub_keys[i]); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2380

ret = nn_init(&S_sum, 0); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2381

ret = prj_pt_init(&_R_sum, shortw_curve); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2382

ret = prj_pt_zero(&_R_sum); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2383

ret = prj_pt_init(&_A_sum, shortw_curve); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2384

ret = prj_pt_zero(&_A_sum); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2385

ret = nn_init(&z, 0); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2386

ret = nn_init(&h, 0); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2391

ret = nn_get_random_len(&z, (hsize / 4)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2392

ret = nn_iszero(&z, &iszero); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2408

ret = hash_mapping_callbacks_sanity_check(hm); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2409

ret = hm->hfunc_init(&h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

241

ret = nn_init(nn_out, 0); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2410

ret = hm->hfunc_init(&h_ctx_pre_hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2415

ret = dom2(0, adata[i], adata_len[i], hm, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2418

ret = dom2(1, adata[i], adata_len[i], hm, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2423

ret = dom4(0, adata[i], adata_len[i], hm, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2426

ret = dom4(1, adata[i], adata_len[i], hm, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

243

ret = local_memset(buf_little_endian, 0, sizeof(buf_little_endian)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2433

gamma_montgomery, alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2436

EDDSA_R_LEN(hsize), key_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2439

ret = aff_pt_edwards_to_prj_pt_shortw(&R, shortw_curve, &_Tmp, alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2441

ret = hm->hfunc_update(&h_ctx, &sig[0], EDDSA_R_LEN(hsize)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2444

ret = _prj_pt_unprotected_mult(&_Tmp, &z, &_Tmp); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2446

ret = prj_pt_add(&_R_sum, &_R_sum, &_Tmp); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2450

ret = eddsa_decode_integer(&S, &sig[EDDSA_R_LEN(hsize)], EDDSA_S_LEN(hsize)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2452

ret = nn_cmp(&S, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2457

ret = nn_mul(&S, &S, &z); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2458

ret = nn_mod(&S, &S, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2459

ret = nn_mod_add(&S_sum, &S_sum, &S, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2470

ret = _prj_pt_unprotected_mult(&_Tmp, gen_cofactor, pub_key_y); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2474

ret = prj_pt_iszero(&_Tmp, &iszero); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2478

ret = prj_pt_shortw_to_aff_pt_edwards(pub_key_y, &crv_edwards, &A, alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2482

ret = eddsa_encode_point(&A, alpha_edwards, hash, EDDSA_R_LEN(hsize), key_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2485

ret = hm->hfunc_update(&h_ctx, hash, EDDSA_R_LEN(hsize)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2489

ret = hm->hfunc_update(&h_ctx_pre_hash, m[i], m_len[i]); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2490

ret = hm->hfunc_finalize(&h_ctx_pre_hash, hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2492

ret = hm->hfunc_update(&h_ctx, hash, use_message_pre_hash_hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2495

ret = hm->hfunc_update(&h_ctx, m[i], m_len[i]); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2497

ret = hm->hfunc_finalize(&h_ctx, hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2501

ret = eddsa_decode_integer(&h, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2502

ret = nn_mod(&h, &h, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2510

ret = nn_lshift(&h, &h, 2); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2511

ret = nn_mod(&h, &h, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2519

ret = nn_mul(&z, &z, &h); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2520

ret = nn_mod(&z, &z, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2521

ret = _prj_pt_unprotected_mult(&_Tmp, &z, &_Tmp); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2523

ret = prj_pt_add(&_A_sum, &_A_sum, &_Tmp); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2530

ret = nn_mul(&S_sum, &S_sum, gen_cofactor); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2531

ret = nn_mod(&S_sum, &S_sum, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2533

ret = nn_mod_neg(&S_sum, &S_sum, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2535

ret = _prj_pt_unprotected_mult(&_Tmp, &S_sum, G); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2538

ret = _prj_pt_unprotected_mult(&_R_sum, gen_cofactor, &_R_sum); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2545

ret = prj_pt_iszero(&_Tmp, &iszero); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2659

ret = local_memset(&crv_edwards, 0, sizeof(ec_edwards_crv)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2660

ret = local_memset(hash, 0, sizeof(hash)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2661

ret = local_memset(&A, 0, sizeof(aff_pt_edwards)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2662

ret = local_memset(&R, 0, sizeof(aff_pt_edwards)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2668

ret = get_hash_by_type(hash_type, &hm); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

269

ret = nn_check_initialized(nn_in); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2695

ret = eddsa_pub_key_sanity_check(pub_keys[i]); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2719

ret = nn_init(&z, 0); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

272

ret = nn_bitlen(nn_in, &blen); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2720

ret = nn_init(&S, 0); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2721

ret = nn_init(&elements[(2 * num)].number, 0); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2722

ret = _prj_pt_unprotected_mult(&elements[(2 * num)].point, gen_cofactor, G); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2727

ret = nn_get_random_len(&z, (hsize / 4)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2728

ret = nn_iszero(&z, &iszero); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2744

ret = hash_mapping_callbacks_sanity_check(hm); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2745

ret = hm->hfunc_init(&h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2746

ret = hm->hfunc_init(&h_ctx_pre_hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2751

ret = dom2(0, adata[i], adata_len[i], hm, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2754

ret = dom2(1, adata[i], adata_len[i], hm, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2759

ret = dom4(0, adata[i], adata_len[i], hm, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

276

ret = nn_export_to_buf(buf, buf_size, nn_in); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2762

ret = dom4(1, adata[i], adata_len[i], hm, &h_ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2769

gamma_montgomery, alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2772

EDDSA_R_LEN(hsize), key_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2775

ret = aff_pt_edwards_to_prj_pt_shortw(&R, shortw_curve, &elements[i].point, alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2777

ret = hm->hfunc_update(&h_ctx, &sig[0], EDDSA_R_LEN(hsize)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2779

ret = nn_init(&elements[i].number, 0); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2780

ret = nn_mul(&elements[i].number, gen_cofactor, &z); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2781

ret = nn_mod(&elements[i].number, &elements[i].number, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2785

ret = eddsa_decode_integer(&S, &sig[EDDSA_R_LEN(hsize)], EDDSA_S_LEN(hsize)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2787

ret = nn_cmp(&S, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2792

ret = nn_mul(&S, &S, &z); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2793

ret = nn_mod(&S, &S, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2794

ret = nn_mod_neg(&S, &S, q); EG(ret, err); /* Negate S */

crypto/libecc/src/sig/eddsa.c

2795

ret = nn_mod_add(&elements[(2 * num)].number, &elements[(2 * num)].number, &S, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2806

ret = _prj_pt_unprotected_mult(&elements[num + i].point, gen_cofactor, pub_key_y); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2810

ret = prj_pt_iszero(&elements[num + i].point, &iszero); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2814

ret = prj_pt_shortw_to_aff_pt_edwards(pub_key_y, &crv_edwards, &A, alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2818

ret = eddsa_encode_point(&A, alpha_edwards, hash, EDDSA_R_LEN(hsize), key_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2821

ret = hm->hfunc_update(&h_ctx, hash, EDDSA_R_LEN(hsize)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2825

ret = hm->hfunc_update(&h_ctx_pre_hash, m[i], m_len[i]); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2826

ret = hm->hfunc_finalize(&h_ctx_pre_hash, hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2828

ret = hm->hfunc_update(&h_ctx, hash, use_message_pre_hash_hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2831

ret = hm->hfunc_update(&h_ctx, m[i], m_len[i]); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2833

ret = hm->hfunc_finalize(&h_ctx, hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2837

ret = eddsa_decode_integer(&elements[num + i].number, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2838

ret = nn_mod(&elements[num + i].number, &elements[num + i].number, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2846

ret = nn_lshift(&elements[num + i].number, &elements[num + i].number, 2); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2847

ret = nn_mod(&elements[num + i].number, &elements[num + i].number, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2852

ret = nn_mul(&elements[num + i].number, &elements[num + i].number, &z); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2853

ret = nn_mod(&elements[num + i].number, &elements[num + i].number, q); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2868

hash_type, adata, adata_len); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2877

ret = prj_pt_iszero(&elements[elements[0].index].point, &iszero); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2918

scratch_pad_area, scratch_pad_area_len); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

2922

hash_type, adata, adata_len); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

302

ret = eddsa_decode_integer(s, digest, (digest_size / 2)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

316

ret = eddsa_priv_key_sanity_check(in_priv); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

319

ret = get_hash_by_type(hash_type, &hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

345

ret = aff_pt_edwards_check_initialized(in); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

346

ret = fp_check_initialized(alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

349

ret = local_memset(buf, 0, buflen); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

350

ret = nn_init(&out_reduced, 0); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

372

ret = fp_init(&y1, in->y.ctx); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

373

ret = fp_copy(&tmp_x, &(in->x)); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

374

ret = fp_sqr(&tmp_x, &tmp_x); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

375

ret = fp_copy(&tmp_y, &(in->y)); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

376

ret = fp_sqr(&tmp_y, &tmp_y); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

377

ret = fp_sub(&tmp_y, &tmp_y, &tmp_x); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

379

ret = fp_inv(&tmp_y, &tmp_y); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

380

ret = fp_set_word_value(&tmp_x, WORD(4)); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

381

ret = fp_mul(&tmp_x, &tmp_x, &(in->x)); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

382

ret = fp_mul(&tmp_x, &tmp_x, &(in->y)); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

383

ret = fp_mul(&tmp_x, &tmp_x, &tmp_y); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

384

ret = fp_inv(&tmp_y, alpha_edwards); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

385

ret = fp_mul(&tmp_x, &tmp_x, &tmp_y); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

386

ret = nn_getbit(&(tmp_x.fp_val), 0, &lsb); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

388

ret = fp_copy(&tmp_x, &(in->x)); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

389

ret = fp_sqr(&tmp_x, &tmp_x); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

390

ret = fp_copy(&tmp_y, &(in->y)); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

391

ret = fp_sqr(&tmp_y, &tmp_y); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

392

ret = fp_set_word_value(&y1, WORD(2)); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

393

ret = fp_sub(&y1, &y1, &tmp_x); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

394

ret = fp_sub(&y1, &y1, &tmp_y); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

395

ret = fp_add(&tmp_x, &tmp_x, &tmp_y); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

397

ret = fp_inv(&tmp_x, &tmp_x); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

398

ret = fp_mul(&y1, &y1, &tmp_x); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

404

EG(ret, err);

crypto/libecc/src/sig/eddsa.c

410

ret = nn_getbit(&(in->x.fp_val), 0, &lsb); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

411

ret = eddsa_encode_integer(&(in->y.fp_val), buf, buflen); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

446

ret = ec_edwards_crv_check_initialized(edwards_curve); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

448

ret = fp_check_initialized(alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

466

ret = fp_init_from_buf(&y, edwards_curve->a.ctx, buf_little_endian, buflen); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

472

ret = fp_init(&sqrt1, edwards_curve->a.ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

473

ret = fp_init(&sqrt2, edwards_curve->a.ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

474

ret = fp_init(&x, edwards_curve->a.ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

488

ret = fp_init(&tmp, edwards_curve->a.ctx); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

494

(const u8*)d_edwards448_buff, sizeof(d_edwards448_buff)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

495

ret = ec_edwards_crv_init(&edwards_curve_edwards448, &(edwards_curve->a), &tmp, &(edwards_curve->order)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

497

ret = aff_pt_edwards_x_from_y(&sqrt1, &sqrt2, &y, &edwards_curve_edwards448); EG(ret, err); /* Error or no square root found, this should not happen! */

crypto/libecc/src/sig/eddsa.c

504

ret = aff_pt_edwards_x_from_y(&sqrt1, &sqrt2, &y, edwards_curve); EG(ret, err); /* Error or no square root found, this should not happen! */

crypto/libecc/src/sig/eddsa.c

507

ret = nn_getbit(&(sqrt1.fp_val), 0, &lsb); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

509

ret = fp_copy(&x, &sqrt1); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

512

ret = fp_copy(&x, &sqrt2); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

515

ret = fp_iszero(&x, &iszero); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

530

ret = fp_copy(&sqrt1, &x); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

531

ret = fp_copy(&sqrt2, &y); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

533

ret = fp_set_word_value(&x, WORD(2)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

534

ret = fp_sqr(&tmp, &sqrt1); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

535

ret = fp_sub(&x, &x, &tmp); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

536

ret = fp_sqr(&tmp, &sqrt2); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

537

ret = fp_sub(&x, &x, &tmp); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

539

ret = fp_inv(&x, &x); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

540

ret = fp_mul(&x, &x, &sqrt1); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

541

ret = fp_mul(&x, &x, &sqrt2); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

542

ret = fp_mul(&x, &x, alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

544

ret = fp_sqr(&sqrt1, &sqrt1); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

545

ret = fp_sqr(&sqrt2, &sqrt2); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

546

ret = fp_sub(&y, &sqrt2, &sqrt1); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

548

ret = fp_inv(&y, &y); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

549

ret = fp_add(&sqrt1, &sqrt1, &sqrt2); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

550

ret = fp_mul(&y, &y, &sqrt1); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

584

ret = eddsa_priv_key_sanity_check(in_priv); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

587

ret = get_hash_by_type(hash_type, &hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

591

ret = local_memset(x_buf, 0, sizeof(x_buf)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

594

ret = ec_priv_key_export_to_buf(in_priv, x_buf, (hash->digest_size / 2)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

596

ret = hash_mapping_callbacks_sanity_check(hash); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

623

ret = eddsa_priv_key_sanity_check(priv_key); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

631

ret = get_hash_sizes(hash_type, &digest_size, NULL); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

642

ret = eddsa_derive_priv_key_hash(priv_key, digest, digest_size); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

646

ret = nn_cmp_word(&(priv_key->params->ec_gen_cofactor), cofactor, &cmp); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

70

ret = h->hfunc_update(h_ctx, (const u8*)"SigEd25519 no Ed25519 collisions", 32); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

704

ret = eddsa_priv_key_sanity_check(priv_key); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

712

ret = get_hash_sizes(hash_type, &digest_size, NULL); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

720

ret = nn_get_random_len(&(priv_key->x), (digest_size / 2)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

73

ret = h->hfunc_update(h_ctx, (const u8*)"SigEd448", 8); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

753

ret = nn_init_from_buf(&(priv_key->x), buf, buflen); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

759

ret = get_hash_sizes(hash_type, &digest_size, NULL); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

761

ret = nn_bitlen(&(priv_key->x), &blen); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

802

ret = eddsa_priv_key_sanity_check(in_priv); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

804

ret = nn_init(&s, 0); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

807

ret = local_memset(out_pub, 0, sizeof(ec_pub_key)); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

81

ret = h->hfunc_update(h_ctx, tmp, 2); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

816

ret = get_hash_sizes(hash_type, &digest_size_, NULL); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

820

ret = eddsa_get_digest_from_priv_key(digest, &digest_size, in_priv); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

826

ret = eddsa_compute_s(&s, digest, digest_size); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

83

ret = h->hfunc_update(h_ctx, y, olen_y); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

843

ret = nn_rshift(&s, &s, 2); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

846

ret = prj_pt_mul_blind(&(out_pub->y), &s, G); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

916

gamma_montgomery, alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

920

sig_type); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

923

alpha_edwards); EG(ret, err);

crypto/libecc/src/sig/eddsa.c

937

ret = nn_init(&tmp, 0); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

938

ret = nn_modinv_word(&tmp, WORD(4), gen_order); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

939

ret = prj_pt_mul(&(pub_key->y), &tmp, pub_key_y); EG(ret, err1);

crypto/libecc/src/sig/eddsa.c

943

EG(ret, err);

crypto/libecc/src/sig/eddsa.c

986

ret = pub_key_check_initialized(in_pub); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

101

ret = local_memset(hash, 0, sizeof(hash)); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

102

ret = local_memcpy(hash, input, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

124

ret = nn_init_from_buf(&e, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

125

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

128

ret = nn_rshift_fixedlen(&e, &e, rshift); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

131

ret = nn_mod(&e, &e, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

143

ret = nn_init_from_buf(&k, nonce, noncelen); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

146

ret = ctx->rand(&k, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

153

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

160

ret = prj_pt_mul_blind(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

162

ret = prj_pt_mul(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

164

ret = prj_pt_unique(&kG, &kG); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

170

ret = nn_mod(&r, &(kG.X.fp_val), q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

177

ret = nn_iszero(&r, &iszero); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

181

ret = nn_export_to_buf(sig, q_len, &r); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

185

ret = nn_mod_mul(&r, &r, &b, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

188

ret = nn_mod_mul(&e, &e, &b, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

192

ret = nn_mod_mul(&tmp, x, &r, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

199

ret = nn_cmp(&e, &tmp, &cmp); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

205

ret = nn_mod_add(&tmp, &tmp, &e, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

212

ret = nn_mod_mul(&k, &k, &b, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

218

ret = nn_modinv_fermat(&kinv, &k, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

223

ret = nn_mod_mul(&s, &tmp, &kinv, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

231

ret = nn_iszero(&s, &iszero); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

302

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

307

ret = local_memset(&uG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

308

ret = local_memset(&vY, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

330

ret = local_memset(hash, 0, sizeof(hash)); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

331

ret = local_memcpy(hash, input, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

353

ret = nn_init_from_buf(&e, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

354

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

357

ret = nn_rshift_fixedlen(&e, &e, rshift); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

361

ret = nn_mod(&e, &e, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

365

ret = nn_modinv(&sinv, s, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

371

ret = nn_mod_mul(&uv, &e, &sinv, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

373

ret = prj_pt_mul(&uG, &uv, G); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

376

ret = nn_mod_mul(&uv, r, &sinv, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

378

ret = prj_pt_mul(&vY, &uv, Y); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

381

ret = prj_pt_add(W_prime, &uG, &vY); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

384

ret = prj_pt_iszero(W_prime, &iszero); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

388

ret = prj_pt_unique(W_prime, W_prime); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

391

ret = nn_mod(&r_prime, &(W_prime->X.fp_val), q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

394

ret = nn_cmp(&r_prime, r, &cmp); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

67

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecdsa.c

72

ret = local_memset(&kG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

103

ret = local_memset(e_buf, 0, sizeof(e_buf)); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

104

ret = local_memcpy(e_buf, input, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

116

ret = nn_init_from_buf(&tmp, e_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

117

ret = local_memset(e_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

119

ret = nn_rshift_fixedlen(&tmp, &tmp, rshift); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

130

ret = nn_mod(&tmp2, &tmp, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

131

ret = nn_mod_neg(&e, &tmp2, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

142

ret = nn_init_from_buf(&k, nonce, noncelen); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

145

ret = ctx->rand(&k, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

151

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

159

ret = prj_pt_mul_blind(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

161

ret = prj_pt_mul(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

163

ret = prj_pt_unique(&kG, &kG); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

169

ret = nn_mod(&r, &(kG.X.fp_val), q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

176

ret = nn_iszero(&r, &iszero); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

180

ret = nn_export_to_buf(sig, r_len, &r); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

184

ret = nn_mod_mul(&e, &e, &b, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

185

ret = nn_mod_mul(&r, &r, &b, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

188

ret = nn_mod_mul(&kr, &k, &r, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

189

ret = nn_mod_add(&tmp2, &kr, &e, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

190

ret = nn_mod_mul(&s, x, &tmp2, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

196

ret = nn_modinv_fermat(&binv, &b, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

197

ret = nn_mod_mul(&s, &s, &binv, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

205

ret = nn_iszero(&s, &iszero); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

279

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

284

ret = local_memset(&uG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

285

ret = local_memset(&vY, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

307

ret = local_memset(e_buf, 0, sizeof(e_buf)); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

308

ret = local_memcpy(e_buf, input, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

320

ret = nn_init_from_buf(&tmp, e_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

321

ret = local_memset(e_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

323

ret = nn_rshift_fixedlen(&tmp, &tmp, rshift); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

328

ret = nn_mod(&e, &tmp, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

331

ret = nn_modinv(&rinv, r, q); EG(ret, err); /* r^-1 */

crypto/libecc/src/sig/fuzzing_ecgdsa.c

332

ret = nn_mul(&tmp, &rinv, &e); EG(ret, err); /* r^-1 * e */

crypto/libecc/src/sig/fuzzing_ecgdsa.c

333

ret = nn_mod(&uv, &tmp, q); EG(ret, err); /* (r^-1 * e) mod q */

crypto/libecc/src/sig/fuzzing_ecgdsa.c

334

ret = prj_pt_mul(&uG, &uv, G); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

337

ret = nn_mul(&tmp, &rinv, s); EG(ret, err); /* r^-1 * s */

crypto/libecc/src/sig/fuzzing_ecgdsa.c

338

ret = nn_mod(&uv, &tmp, q); EG(ret, err); /* (r^-1 * s) mod q */

crypto/libecc/src/sig/fuzzing_ecgdsa.c

339

ret = prj_pt_mul(&vY, &uv, Y); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

342

ret = prj_pt_add(Wprime, &uG, &vY); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

345

ret = prj_pt_unique(Wprime, Wprime); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

348

ret = nn_mod(&r_prime, &(Wprime->X.fp_val), q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

351

ret = nn_cmp(r, &r_prime, &cmp); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

67

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecgdsa.c

72

ret = local_memset(&kG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

109

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

113

ret = local_memset(&kG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

145

ret = nn_init_from_buf(&k, nonce, noncelen); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

148

ret = ctx->rand(&k, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

155

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

162

ret = prj_pt_mul_blind(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

164

ret = prj_pt_mul(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

166

ret = prj_pt_unique(&kG, &kG); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

171

ret = nn_mod(&r, &(kG.X.fp_val), q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

177

ret = nn_iszero(&r, &iszero); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

183

ret = nn_export_to_buf(sig, r_len, &r); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

195

ret = local_memset(h_buf, 0, sizeof(h_buf)); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

196

ret = local_memcpy(h_buf, input, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

202

ret = _reverse_endianness(h_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

205

ret = nn_init_from_buf(&tmp, h_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

206

ret = local_memset(h_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

207

ret = nn_mod(&e, &tmp, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

208

ret = nn_iszero(&e, &iszero); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

210

ret = nn_inc(&e, &e); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

216

ret = nn_mod_mul(&r, &r, &b, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

217

ret = nn_mod_mul(&e, &e, &b, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

221

ret = nn_mod_mul(&rx, &r, x, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

222

ret = nn_mod_mul(&ke, &k, &e, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

223

ret = nn_mod_add(&s, &rx, &ke, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

229

ret = nn_modinv_fermat(&binv, &b, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

230

ret = nn_mod_mul(&s, &s, &binv, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

238

ret = nn_iszero(&s, &iszero); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

244

ret = nn_export_to_buf(sig + r_len, s_len, &s); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

314

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

318

ret = local_memset(&uG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

319

ret = local_memset(&vY, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

340

ret = local_memset(h_buf, 0, sizeof(h_buf)); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

341

ret = local_memcpy(h_buf, input, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

347

ret = _reverse_endianness(h_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

351

ret = nn_init_from_buf(&tmp, h_buf, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

352

ret = local_memset(h_buf, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

353

ret = nn_mod(&h, &tmp, q); EG(ret, err); /* h = OS2I(h) mod q */

crypto/libecc/src/sig/fuzzing_ecrdsa.c

354

ret = nn_iszero(&h, &iszero); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

356

ret = nn_inc(&h, &h); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

358

ret = nn_modinv(&e, &h, q); EG(ret, err); /* e = h^-1 mod q */

crypto/libecc/src/sig/fuzzing_ecrdsa.c

361

ret = nn_mul(&tmp, &e, s); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

362

ret = nn_mod(&u, &tmp, q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

369

ret = nn_mul(&tmp, &e, r); EG(ret, err); /* tmp = er */

crypto/libecc/src/sig/fuzzing_ecrdsa.c

370

ret = nn_mod(&tmp, &tmp, q); EG(ret, err); /* tmp = er mod q */

crypto/libecc/src/sig/fuzzing_ecrdsa.c

371

ret = nn_mod_neg(&v, &tmp, q); EG(ret, err); /* negate tmp */

crypto/libecc/src/sig/fuzzing_ecrdsa.c

374

ret = prj_pt_mul(&uG, &u, G); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

375

ret = prj_pt_mul(&vY, &v, Y); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

376

ret = prj_pt_add(Wprime, &uG, &vY); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

377

ret = prj_pt_unique(Wprime, Wprime); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

382

ret = nn_mod(&r_prime, &(Wprime->X.fp_val), q); EG(ret, err);

crypto/libecc/src/sig/fuzzing_ecrdsa.c

385

ret = nn_cmp(r, &r_prime, &cmp); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

1025

ret = nn_cmp(&elements[indexj].number, &elements[indexj_next].number, &check); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

1086

ret = _bubble_sort(elements, num); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

1091

&elements[index1].point); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

1096

&elements[index1].number); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

218

ret = hash_mapping_callbacks_sanity_check(sig_ctx->h); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

235

ret = hash_mapping_callbacks_sanity_check(verify_ctx->h); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

260

ret = get_hash_sizes(hash_type, &digest_size, &block_size); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

27

ret = priv_key_check_initialized(priv_key); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

307

ret = key_pair_check_initialized_and_type(key_pair, sig_type); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

356

ret = hash_mapping_sanity_check(hm); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

357

ret = sig_mapping_sanity_check(sm); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

360

ret = local_memset(ctx, 0, sizeof(struct ec_sign_context)); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

405

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

406

ret = sig_mapping_sanity_check(ctx->sig); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

407

ret = hash_mapping_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

408

ret = ec_sig_ctx_callbacks_sanity_check(ctx); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

429

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

430

ret = sig_mapping_sanity_check(ctx->sig); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

431

ret = hash_mapping_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

432

ret = ec_sig_ctx_callbacks_sanity_check(ctx); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

45

ret = priv_key_check_initialized(priv_key); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

464

hash_type, adata, adata_len); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

465

ret = ec_sign_update(&ctx, m, mlen); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

482

ret = get_sig_by_type(sig_type, &sm); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

523

ret = pub_key_check_initialized_and_type(pub_key, sig_type); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

555

ret = hash_mapping_sanity_check(hm); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

556

ret = sig_mapping_sanity_check(sm); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

559

ret = local_memset(ctx, 0, sizeof(struct ec_verify_context)); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

593

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

594

ret = sig_mapping_sanity_check(ctx->sig); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

595

ret = hash_mapping_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

598

ret = ec_verify_ctx_callbacks_sanity_check(ctx); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

618

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

619

ret = sig_mapping_sanity_check(ctx->sig); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

620

ret = hash_mapping_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

623

ret = ec_verify_ctx_callbacks_sanity_check(ctx); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

647

hash_type, adata, adata_len); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

648

ret = ec_verify_update(&ctx, m, mlen); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

664

ret = get_sig_by_type(sig_type, &sm); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

684

ret = get_sig_by_type(sig_type, &sm); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

726

curve_name, MAX_CURVE_NAME_LEN); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

767

ret = local_strlen((const char *)curve_name, &len); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

771

ret = ec_get_curve_type_by_name(curve_name, curve_name_len, &curve_type); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

78

ret = priv_key_check_initialized(priv_key); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

886

ret = get_sig_by_type(sig_type, &sig); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

915

ret = get_sig_by_type(sig_type, &sig); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

944

ret = get_sig_by_type(sig_type, &sig); EG(ret, err);

crypto/libecc/src/sig/sig_algs.c

974

ret = get_sig_by_type(sig_type, &sig); EG(ret, err);

crypto/libecc/src/sig/sm2.c

152

ret = pub_key_check_initialized_and_type(pub_key, SM2); EG(ret, err);

crypto/libecc/src/sig/sm2.c

154

ret = get_hash_by_type(hash_type, &hm); EG(ret, err);

crypto/libecc/src/sig/sm2.c

171

ret = hash_mapping_callbacks_sanity_check(hm); EG(ret, err);

crypto/libecc/src/sig/sm2.c

172

ret = hm->hfunc_init(&hctx); EG(ret, err);

crypto/libecc/src/sig/sm2.c

177

ret = hm->hfunc_update(&hctx, buf, 2); EG(ret, err);

crypto/libecc/src/sig/sm2.c

180

ret = hm->hfunc_update(&hctx, id, id_len); EG(ret, err);

crypto/libecc/src/sig/sm2.c

183

ret = fp_export_to_buf(buf, p_len, a); EG(ret, err);

crypto/libecc/src/sig/sm2.c

184

ret = hm->hfunc_update(&hctx, buf, p_len); EG(ret, err);

crypto/libecc/src/sig/sm2.c

187

ret = fp_export_to_buf(buf, p_len, b); EG(ret, err);

crypto/libecc/src/sig/sm2.c

188

ret = hm->hfunc_update(&hctx, buf, p_len); EG(ret, err);

crypto/libecc/src/sig/sm2.c

191

ret = prj_pt_export_to_aff_buf(G, buf, (u32)(2 * p_len)); EG(ret, err);

crypto/libecc/src/sig/sm2.c

192

ret = hm->hfunc_update(&hctx, buf, (u32)(2 * p_len)); EG(ret, err);

crypto/libecc/src/sig/sm2.c

195

ret = prj_pt_export_to_aff_buf(Y, buf, (u32)(2 * p_len)); EG(ret, err);

crypto/libecc/src/sig/sm2.c

196

ret = hm->hfunc_update(&hctx, buf, (u32)(2 * p_len)); EG(ret, err);

crypto/libecc/src/sig/sm2.c

199

ret = hm->hfunc_finalize(&hctx, Z); EG(ret, err);

crypto/libecc/src/sig/sm2.c

202

ret = local_memset(buf, 0, sizeof(buf)); EG(ret, err);

crypto/libecc/src/sig/sm2.c

203

ret = local_memset(&hctx, 0, sizeof(hctx)); EG(ret, err);

crypto/libecc/src/sig/sm2.c

254

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/sm2.c

257

ret = key_pair_check_initialized_and_type(ctx->key_pair, SM2); EG(ret, err);

crypto/libecc/src/sig/sm2.c

266

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/sm2.c

267

ret = ctx->h->hfunc_init(&(ctx->sign_data.sm2.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/sm2.c

270

ret = local_memset(Z, 0, sizeof(Z)); EG(ret, err);

crypto/libecc/src/sig/sm2.c

273

&(ctx->key_pair->pub_key), ctx->h->type); EG(ret, err);

crypto/libecc/src/sig/sm2.c

277

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/sm2.c

278

ret = ctx->h->hfunc_update(&(ctx->sign_data.sm2.h_ctx), Z, Zlen); EG(ret, err);

crypto/libecc/src/sig/sm2.c

298

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/sm2.c

303

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/sm2.c

334

ret = sig_sign_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/sm2.c

339

ret = local_memset(&kG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/sm2.c

359

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/sm2.c

361

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/sm2.c

364

ret = ctx->h->hfunc_finalize(&(ctx->sign_data.sm2.h_ctx), hash); EG(ret, err);

crypto/libecc/src/sig/sm2.c

378

ret = ctx->rand(&k, q); EG(ret, err);

crypto/libecc/src/sig/sm2.c

383

ret = prj_pt_mul_blind(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/sm2.c

385

ret = prj_pt_mul(&kG, &k, G); EG(ret, err);

crypto/libecc/src/sig/sm2.c

387

ret = prj_pt_unique(&kG, &kG); EG(ret, err);

crypto/libecc/src/sig/sm2.c

393

ret = nn_init_from_buf(&tmp, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/sm2.c

394

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/sm2.c

396

ret = nn_add(&tmp2, &tmp, &(kG.X.fp_val)); EG(ret, err);

crypto/libecc/src/sig/sm2.c

397

ret = nn_mod(&r, &tmp2, q); EG(ret, err);

crypto/libecc/src/sig/sm2.c

401

ret = nn_iszero(&r, &iszero); EG(ret, err);

crypto/libecc/src/sig/sm2.c

407

ret = nn_add(&tmp, &r, q); EG(ret, err);

crypto/libecc/src/sig/sm2.c

408

ret = nn_cmp(&tmp, q, &cmp); EG(ret, err);

crypto/libecc/src/sig/sm2.c

419

ret = nn_get_random_mod(&b, q); EG(ret, err);

crypto/libecc/src/sig/sm2.c

421

ret = nn_inc(&tmp2, x); EG(ret, err);

crypto/libecc/src/sig/sm2.c

422

ret = nn_mod_mul(&tmp2, &tmp2, &b, q); EG(ret, err);

crypto/libecc/src/sig/sm2.c

426

ret = nn_modinv_fermat(&tmp, &tmp2, q); EG(ret, err); /* tmp = (b*(1 + x))^(-1) */

crypto/libecc/src/sig/sm2.c

428

ret = nn_mod_mul(&tmp3, &r, &b, q); EG(ret, err); /* rb */

crypto/libecc/src/sig/sm2.c

429

ret = nn_mod_mul(&k, &k, &b, q); EG(ret, err); /* kb */

crypto/libecc/src/sig/sm2.c

43

ret = priv_key_check_initialized_and_type(priv_key, SM2); EG(ret, err);

crypto/libecc/src/sig/sm2.c

430

ret = nn_mod_mul(&tmp3, &tmp3, x, q); EG(ret, err); /* (rb)x mod q */

crypto/libecc/src/sig/sm2.c

431

ret = nn_mod_sub(&tmp2, &k, &tmp3, q); EG(ret, err); /* tmp2 = (kb - (rb)x) mod q */

crypto/libecc/src/sig/sm2.c

432

ret = nn_mod_mul(&s, &tmp, &tmp2, q); EG(ret, err);

crypto/libecc/src/sig/sm2.c

435

ret = nn_inc(&tmp2, x); EG(ret, err);

crypto/libecc/src/sig/sm2.c

439

ret = nn_modinv_fermat(&tmp, &tmp2, q); EG(ret, err); /* tmp = (1 + x)^(-1) */

crypto/libecc/src/sig/sm2.c

441

ret = nn_mod_mul(&tmp3, &r, x, q); EG(ret, err); /* rx mod q */

crypto/libecc/src/sig/sm2.c

442

ret = nn_mod_sub(&tmp2, &k, &tmp3, q); EG(ret, err); /* tmp2 = (k - rx) mod q */

crypto/libecc/src/sig/sm2.c

443

ret = nn_mod_mul(&s, &tmp, &tmp2, q); EG(ret, err);

crypto/libecc/src/sig/sm2.c

448

ret = nn_iszero(&s, &iszero); EG(ret, err);

crypto/libecc/src/sig/sm2.c

454

ret = nn_export_to_buf(sig, q_len, &r); EG(ret, err);

crypto/libecc/src/sig/sm2.c

46

ret = nn_init(&tmp, 0); EG(ret, err);

crypto/libecc/src/sig/sm2.c

47

ret = nn_dec(&tmp, &(priv_key->params->ec_gen_order)); EG(ret, err);

crypto/libecc/src/sig/sm2.c

530

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/sm2.c

533

ret = pub_key_check_initialized_and_type(ctx->pub_key, SM2); EG(ret, err);

crypto/libecc/src/sig/sm2.c

549

ret = nn_init_from_buf(r, sig, q_len); EG(ret, err);

crypto/libecc/src/sig/sm2.c

550

ret = nn_init_from_buf(s, sig + q_len, q_len); EG(ret, err);

crypto/libecc/src/sig/sm2.c

555

ret = nn_iszero(r, &iszero1); EG(ret, err);

crypto/libecc/src/sig/sm2.c

556

ret = nn_iszero(s, &iszero2); EG(ret, err);

crypto/libecc/src/sig/sm2.c

557

ret = nn_cmp(r, q, &cmp1); EG(ret, err);

crypto/libecc/src/sig/sm2.c

558

ret = nn_cmp(s, q, &cmp2); EG(ret, err);

crypto/libecc/src/sig/sm2.c

563

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/sm2.c

564

ret = ctx->h->hfunc_init(&(ctx->verify_data.sm2.h_ctx)); EG(ret, err);

crypto/libecc/src/sig/sm2.c

567

ret = local_memset(Z, 0, sizeof(Z)); EG(ret, err);

crypto/libecc/src/sig/sm2.c

569

ret = sm2_compute_Z(Z, &Zlen, ctx->adata, ctx->adata_len, ctx->pub_key, ctx->h->type); EG(ret, err);

crypto/libecc/src/sig/sm2.c

572

ret = ctx->h->hfunc_update(&(ctx->verify_data.sm2.h_ctx), Z, Zlen); EG(ret, err);

crypto/libecc/src/sig/sm2.c

598

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/sm2.c

603

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/sm2.c

634

ret = sig_verify_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/sig/sm2.c

638

ret = local_memset(&sG, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/sm2.c

639

ret = local_memset(&tY, 0, sizeof(prj_pt)); EG(ret, err);

crypto/libecc/src/sig/sm2.c

65

ret = priv_key_check_initialized_and_type(in_priv, SM2); EG(ret, err);

crypto/libecc/src/sig/sm2.c

651

ret = hash_mapping_callbacks_sanity_check(ctx->h); EG(ret, err);

crypto/libecc/src/sig/sm2.c

652

ret = ctx->h->hfunc_finalize(&(ctx->verify_data.sm2.h_ctx), hash); EG(ret, err);

crypto/libecc/src/sig/sm2.c

656

ret = nn_mod_add(&t, r, s, q); EG(ret, err);

crypto/libecc/src/sig/sm2.c

659

ret = nn_iszero(&t, &iszero); EG(ret, err);

crypto/libecc/src/sig/sm2.c

663

ret = nn_init_from_buf(&tmp, hash, hsize); EG(ret, err);

crypto/libecc/src/sig/sm2.c

664

ret = local_memset(hash, 0, hsize); EG(ret, err);

crypto/libecc/src/sig/sm2.c

666

ret = nn_mod(&e, &tmp, q); EG(ret, err);

crypto/libecc/src/sig/sm2.c

670

ret = prj_pt_mul(&sG, s, G); EG(ret, err);

crypto/libecc/src/sig/sm2.c

671

ret = prj_pt_mul(&tY, &t, Y); EG(ret, err);

crypto/libecc/src/sig/sm2.c

672

ret = prj_pt_add(W_prime, &sG, &tY); EG(ret, err);

crypto/libecc/src/sig/sm2.c

675

ret = prj_pt_iszero(W_prime, &iszero); EG(ret, err);

crypto/libecc/src/sig/sm2.c

679

ret = prj_pt_unique(W_prime, W_prime); EG(ret, err);

crypto/libecc/src/sig/sm2.c

684

ret = nn_mod(&r_prime, &(W_prime->X.fp_val), q); EG(ret, err);

crypto/libecc/src/sig/sm2.c

686

ret = nn_mod_add(&r_prime, &e, &r_prime, q); EG(ret, err);

crypto/libecc/src/sig/sm2.c

689

ret = nn_cmp(&r_prime, r, &cmp); EG(ret, err);

crypto/libecc/src/sig/sm2.c

72

ret = nn_init(&tmp, 0); EG(ret, err);

crypto/libecc/src/sig/sm2.c

73

ret = nn_dec(&tmp, &in_priv->params->ec_gen_order); EG(ret, err);

crypto/libecc/src/sig/sm2.c

81

ret = local_memset(out_pub, 0, sizeof(ec_pub_key)); EG(ret, err);

crypto/libecc/src/sig/sm2.c

84

ret = prj_pt_mul_blind(&(out_pub->y), &(in_priv->x), G); EG(ret, err);

crypto/libecc/src/tests/bign_test_vectors.h

133

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/bign_test_vectors.h

134

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/bign_test_vectors.h

184

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/bign_test_vectors.h

185

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/bign_test_vectors.h

240

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/bign_test_vectors.h

241

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/bign_test_vectors.h

294

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/bign_test_vectors.h

295

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/bign_test_vectors.h

34

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/bign_test_vectors.h

35

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/bign_test_vectors.h

351

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/bign_test_vectors.h

352

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/bign_test_vectors.h

407

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/bign_test_vectors.h

408

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/bign_test_vectors.h

85

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/bign_test_vectors.h

86

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/bip0340_test_vectors.h

125

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/bip0340_test_vectors.h

126

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/bip0340_test_vectors.h

170

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/bip0340_test_vectors.h

171

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/bip0340_test_vectors.h

35

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/bip0340_test_vectors.h

36

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/bip0340_test_vectors.h

80

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/bip0340_test_vectors.h

81

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests.c

191

ret = local_strlen(test_types[j].type_name, &len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests.c

192

ret = are_equal(argv[i], test_types[j].type_name, len + 1, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests.c

198

ret = are_equal(argv[i], "sign=", sizeof("sign=")-1, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests.c

209

ret = are_equal(argv[i], "hash=", sizeof("hash=")-1, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests.c

220

ret = are_equal(argv[i], "curve=", sizeof("curve=")-1, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests.c

251

ret = local_strlen(test_types[j].type_name, &len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests.c

252

ret = are_equal(argv[i], test_types[j].type_name, len + 1, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1007

ret = encode_error_value(c, failed_test, &ret_); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1030

ret = local_memset(&kp, 0, sizeof(kp)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1031

ret = local_memset(&params, 0, sizeof(params)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1051

ret = local_memset(serialized_pub_key, 0, sizeof(serialized_pub_key)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1052

ret = local_memset(shared_secret, 0, sizeof(shared_secret)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1063

ret = ecccdh_serialized_pub_key_size(&params, &serialized_pub_key_len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1073

ret = are_equal(serialized_pub_key, c->exp_our_pub_key, serialized_pub_key_len, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1080

ret = ecccdh_shared_secret_size(&params, &shared_secret_len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1090

ret = are_equal(shared_secret, c->exp_shared_secret, shared_secret_len, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1105

ret = local_memset(pub_key, 0, sizeof(pub_key)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1106

ret = local_memset(shared_secret, 0, sizeof(shared_secret)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1118

ret = are_equal(pub_key, c->exp_our_pub_key, X25519_SIZE, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1134

ret = are_equal(shared_secret, c->exp_shared_secret, X25519_SIZE, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1149

ret = local_memset(pub_key, 0, sizeof(pub_key)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1150

ret = local_memset(shared_secret, 0, sizeof(shared_secret)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1162

ret = are_equal(pub_key, c->exp_our_pub_key, X448_SIZE, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1178

ret = are_equal(shared_secret, c->exp_shared_secret, X448_SIZE, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1198

ret = ecdh_encode_error_value(c, failed_test, &ret_); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

132

ret = local_memset(&ctx, 0, sizeof(ctx)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1356

ret = local_memset(rand_adata, 0, sizeof(rand_adata)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1365

ret = local_memset(test_name, 0, sizeof(test_name)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1374

ret = local_memset(test_name, 0, tn_size + 1); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1375

ret = local_strncpy(test_name, sig->name, tn_size); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1376

ret = local_strlen(test_name, &len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1377

ret = local_strncat(test_name, "-", tn_size - len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1378

ret = local_strlen(test_name, &len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1379

ret = local_strncat(test_name, hash->name, tn_size - len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1380

ret = local_strlen(test_name, &len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1381

ret = local_strncat(test_name, "/", tn_size - len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1382

ret = local_strlen(test_name, &len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1383

ret = local_strncat(test_name, crv_name, tn_size - len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1409

ret = get_random((u8 *)&rand_len, sizeof(rand_len)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1410

ret = get_random((u8 *)rand_adata, (u16)(rand_len % sizeof(rand_adata))); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1430

ret = get_random((u8 *)rand_adata, sizeof(rand_adata)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1432

ret = get_random((u8 *)&oid_len, sizeof(oid_len)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1433

ret = get_random((u8 *)&t_len, sizeof(oid_len)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1593

ret = local_memset(&kp, 0, sizeof(kp)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1620

ret = local_memset(sig, 0, sizeof(sig)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1621

ret = local_memset(msg, 0, sizeof(msg)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1702

ret = is_verify_batch_mode_supported(c->sig_type, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1788

ret = local_memset(rand_adata, 0, sizeof(rand_adata)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1801

ret = local_memset(test_name, 0, sizeof(test_name)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1806

ret = local_memset(test_name, 0, tn_size + 1); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1807

ret = local_strncpy(test_name, sig->name, tn_size); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1808

ret = local_strlen(test_name, &len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1809

ret = local_strncat(test_name, "-", tn_size - len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

181

ret = local_memset(&ctx, 0, sizeof(ctx)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1810

ret = local_strlen(test_name, &len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1811

ret = local_strncat(test_name, hash->name, tn_size - len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1812

ret = local_strlen(test_name, &len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1813

ret = local_strncat(test_name, "/", tn_size - len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1814

ret = local_strlen(test_name, &len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1815

ret = local_strncat(test_name, crv_name, tn_size - len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1841

ret = get_random((u8 *)&rand_len, sizeof(rand_len)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1842

ret = get_random((u8 *)rand_adata, (u16)(rand_len % sizeof(rand_adata))); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1862

ret = get_random((u8 *)rand_adata, sizeof(rand_adata)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1864

ret = get_random((u8 *)&oid_len, sizeof(oid_len)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

1865

ret = get_random((u8 *)&t_len, sizeof(oid_len)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

242

ret = local_memset(&kp, 0, sizeof(kp)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

243

ret = local_memset(&params, 0, sizeof(params)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

296

ret = local_memset(sig_tmp1, 0, sizeof(sig_tmp1)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

297

ret = local_memset(sig_tmp2, 0, sizeof(sig_tmp2)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

299

ret = is_sign_streaming_mode_supported(c->sig_type, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

317

ret = is_sign_deterministic(c->sig_type, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

319

ret = are_equal(sig, sig_tmp1, siglen, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

326

ret = are_equal(sig, sig_tmp2, siglen, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

343

ret = is_verify_streaming_mode_supported(c->sig_type, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

345

ret = is_sign_streaming_mode_supported(c->sig_type, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

358

ret = is_sign_streaming_mode_supported(c->sig_type, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

373

ret = is_verify_batch_mode_supported(c->sig_type, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

414

ret = ec_sign_init(&sig_ctx, &kp, c->sig_type, c->hash_type, c->adata, c->adata_len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

416

ret = hash_mapping_callbacks_sanity_check(sig_ctx.h); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

417

ret = sig_ctx.h->hfunc_scattered(input, ilens, digest); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

421

ret = nn_isone(cofactor, &cofactorisone); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

430

ret = prj_pt_cmp(&(pub_key1.y), &(kp.pub_key.y), &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

432

ret = prj_pt_cmp(&(pub_key2.y), &(kp.pub_key.y), &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

473

ret = ec_sign_init(&sig_ctx, &kp, c->sig_type, c->hash_type, c->adata, c->adata_len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

475

ret = hash_mapping_callbacks_sanity_check(sig_ctx.h); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

476

ret = sig_ctx.h->hfunc_scattered(input, ilens, digest); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

482

ret = ecdsa_sign_raw(&sig_ctx, digest, digestlen, sig, siglen, NULL, 0); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

487

ret = ecgdsa_sign_raw(&sig_ctx, digest, digestlen, sig, siglen, NULL, 0); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

492

ret = ecrdsa_sign_raw(&sig_ctx, digest, digestlen, sig, siglen, NULL, 0); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

496

ret = ec_verify_init(&verif_ctx, &(kp.pub_key), sig, siglen, c->sig_type, c->hash_type, c->adata, c->adata_len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

499

ret = ecdsa_verify_raw(&verif_ctx, digest, digestlen); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

504

ret = ecgdsa_verify_raw(&verif_ctx, digest, digestlen); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

509

ret = ecrdsa_verify_raw(&verif_ctx, digest, digestlen); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

517

ret = is_verify_batch_mode_supported(c->sig_type, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

52

EG(ret, err); \

crypto/libecc/src/tests/ec_self_tests_core.c

642

c->nn_random, c->sig_type, c->hash_type, c->adata, c->adata_len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

643

ret = is_sign_streaming_mode_supported(c->sig_type, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

648

c->nn_random, c->sig_type, c->hash_type, c->adata, c->adata_len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

649

ret = are_equal(sig, sig_tmp, siglen, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

656

c->nn_random, c->sig_type, c->hash_type, c->adata, c->adata_len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

657

ret = are_equal(sig, sig_tmp, siglen, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

67

ret = local_memset(pub_key_buf, 0, sizeof(pub_key_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

68

ret = local_memset(priv_key_buf, 0, sizeof(priv_key_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

686

ret = is_verify_streaming_mode_supported(c->sig_type, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

69

ret = local_memset(&imported_kp, 0, sizeof(imported_kp)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

703

ret = is_verify_batch_mode_supported(c->sig_type, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

743

ret = local_memset(&kp, 0, sizeof(kp)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

744

ret = local_memset(&params, 0, sizeof(params)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

745

ret = local_memset(sig, 0, sizeof(sig)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

792

ret = are_equal(sig, c->exp_sig, siglen, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

830

ret = ec_sign_init(&sig_ctx, &kp, c->sig_type, c->hash_type, c->adata, c->adata_len); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

832

ret = hash_mapping_callbacks_sanity_check(sig_ctx.h); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

833

ret = sig_ctx.h->hfunc_scattered(input, ilens, digest); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

837

ret = nn_isone(cofactor, &cofactorisone); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

846

ret = prj_pt_cmp(&(pub_key1.y), &(kp.pub_key.y), &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

848

ret = prj_pt_cmp(&(pub_key2.y), &(kp.pub_key.y), &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

905

ret = sig_ctx.h->hfunc_scattered(input, ilens, digest); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

915

ret = nn_export_to_buf(nonce, (u16)BYTECEIL(q_bit_len), &n_nonce); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.c

960

ret = are_equal(sig, c->exp_sig, siglen, &check); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1070

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1071

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1147

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1148

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1216

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1217

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1278

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1279

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1343

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1344

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1407

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1408

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

143

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

144

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1481

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1482

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1550

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1551

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1626

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1627

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1691

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1692

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1764

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1765

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1839

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1840

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1907

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1908

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1969

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

1970

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2033

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2034

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

210

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

211

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2110

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2111

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2189

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2190

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2257

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2258

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2334

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2335

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2412

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2413

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2481

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2482

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2543

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2544

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2608

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2609

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2685

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2686

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2765

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2766

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

278

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

279

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2834

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2835

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2911

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2912

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2989

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

2990

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3058

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3059

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3124

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3125

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3192

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3193

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3276

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3277

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3365

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3366

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3438

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3439

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

348

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

349

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3521

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3522

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3607

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3608

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3678

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3679

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3737

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3738

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3798

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3799

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3862

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3863

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3957

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

3958

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4033

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4034

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4112

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4113

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4221

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4222

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

427

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

428

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4286

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4287

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4337

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4338

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4452

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4453

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4528

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4529

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4593

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4594

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4705

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4706

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4767

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

4768

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

504

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

505

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

568

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

569

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

5719

c->ec_str_p->name->buflen, &ctype); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

5741

c->ec_str_p->name->buflen, &ctype); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

634

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

635

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

701

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

702

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

769

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

770

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

846

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

847

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

925

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

926

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

993

ret = nn_init_from_buf(out, k_buf, sizeof(k_buf)); EG(ret, err);

crypto/libecc/src/tests/ec_self_tests_core.h

994

ret = nn_cmp(out, q, &cmp); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1046

hash_algorithm, &hash_type); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1049

ret = check_ancillary_data(adata, sig_type, ec_sig_name, &check); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1052

ret = import_params(&params, ec_str_p); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1144

ret = dump_hdr_info(&hdr); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1194

ret = are_str_equal((char *)stored_curve_name, (char *)params.curve_name, &check); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1249

ret = is_verify_streaming_mode_supported(sig_type, &check); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1408

NULL, NULL); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1411

ret = import_params(&curve_params, ec_str_p); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1445

ret = nn_init_from_buf(&d, buf, (u16)buf_len); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1460

ret = fclose(in_file); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1486

ret = prj_pt_mul_blind(&Q, &d, &Q); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1488

ret = prj_pt_mul(&Q, &d, &Q); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1491

ret = prj_pt_unique(&Q, &Q); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1606

ret = are_str_equal(argv[1], "gen_keys", &check); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1638

ret = are_str_equal(argv[1], "sign", &check); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1676

ret = local_strlen(adata, &len); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1687

ret = are_str_equal(argv[1], "verify", &check); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1724

ret = local_strlen(adata, &len); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1736

ret = are_str_equal(argv[1], "struct_sign", &check); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1778

ret = local_strlen(adata, &len); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1789

ret = are_str_equal(argv[1], "struct_verify", &check); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1824

ret = local_strlen(adata, &len); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

1836

ret = are_str_equal(argv[1], "scalar_mult", &check); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

193

ret = local_strlen((const char *)ec_name, &curve_name_len); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

259

ret = import_params(&params, ec_str_p); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

262

ret = ec_key_pair_gen(&kp, &params, sig_type); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

268

ret = prj_pt_unique(&(kp.pub_key.y), &(kp.pub_key.y)); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

273

ret = local_strnlen(fname_prefix, fname_len, &len); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

276

ret = local_memset(fname, 0, fname_len); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

277

ret = local_memcpy(fname, fname_prefix, prefix_len); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

278

ret = local_strncat(fname, "_private_key.bin", (u32)(fname_len - prefix_len)); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

292

ret = fclose(file); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

296

ret = local_memset(fname, 0, fname_len); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

297

ret = local_memcpy(fname, fname_prefix, prefix_len); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

298

ret = local_strncat(fname, "_private_key.h", (u32)(fname_len - prefix_len)); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

313

ret = fclose(file); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

319

ret = local_memset(fname, 0, fname_len); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

320

ret = local_memcpy(fname, fname_prefix, prefix_len); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

321

ret = local_strncat(fname, "_public_key.bin", (u32)(fname_len - prefix_len)); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

334

ret = fclose(file); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

338

ret = local_memset(fname, 0, fname_len); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

339

ret = local_memcpy(fname, fname_prefix, prefix_len); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

340

ret = local_strncat(fname, "_public_key.h", (u32)(fname_len - prefix_len)); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

355

ret = fclose(file); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

562

ret = are_str_equal(hdr_type, "IMAGE_TYPE0", &check); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

566

ret = are_str_equal(hdr_type, "IMAGE_TYPE1", &check); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

570

ret = are_str_equal(hdr_type, "IMAGE_TYPE2", &check); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

574

ret = are_str_equal(hdr_type, "IMAGE_TYPE3", &check); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

689

ret = check_ancillary_data(adata, sig_type, ec_sig_name, &check); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

692

ret = import_params(&params, ec_str_p); EG(ret, err);

crypto/libecc/src/tests/ec_utils.c

750

ret = is_sign_streaming_mode_supported(sig_type, &check); EG(ret, err);

crypto/libecc/src/utils/print_curves.c

29

ret = prj_pt_iszero(pt, &iszero); EG(ret, err);

crypto/libecc/src/utils/print_curves.c

35

ret = prj_pt_to_aff(&y_aff, pt); EG(ret, err);

crypto/libecc/src/utils/print_curves.c

51

ret = aff_pt_montgomery_check_initialized(pt); EG(ret, err);

crypto/libecc/src/utils/print_curves.c

67

ret = aff_pt_edwards_check_initialized(pt); EG(ret, err);

crypto/libecc/src/utils/print_fp.c

24

ret = fp_ctx_check_initialized(ctx); EG(ret, err);

crypto/libecc/src/utils/print_fp.c

43

ret = fp_check_initialized(a); EG(ret, err);

crypto/libecc/src/utils/print_fp.c

57

ret = fp_check_initialized(a); EG(ret, err);

crypto/libecc/src/utils/print_keys.c

23

ret = priv_key_check_initialized(priv); EG(ret, err);

crypto/libecc/src/utils/print_keys.c

36

ret = pub_key_check_initialized(pub); EG(ret, err);

crypto/libecc/src/utils/print_nn.c

23

ret = nn_check_initialized(a); EG(ret, err);

crypto/libecc/src/utils/utils.c

224

ret = local_strlen(dst, &dst_len); EG(ret, err);

crypto/libecc/src/wycheproof_tests/libecc_wycheproof.c

514

ret = fp_init_from_buf(&x, &(params->ec_fp), peerpubkey, peerpubkeylen); EG(ret, err);

crypto/libecc/src/wycheproof_tests/libecc_wycheproof.c

515

ret = fp_init(&tmp, &(params->ec_fp)); EG(ret, err);

crypto/libecc/src/wycheproof_tests/libecc_wycheproof.c

517

ret = aff_pt_y_from_x(&tmp, &x, &x, &(params->ec_curve)); EG(ret, err);

crypto/libecc/src/wycheproof_tests/libecc_wycheproof.c

522

ret = fp_cmp(&x, &tmp, &check); EG(ret, err);

crypto/libecc/src/wycheproof_tests/libecc_wycheproof.c

527

ret = local_memcpy(&serialized_pub_key[0], &peerpubkey[0], (serialized_pub_key_size / 2)); EG(ret, err);

crypto/libecc/src/wycheproof_tests/libecc_wycheproof.c

61

EG(ret, err); \

sys/dev/aac/aac_debug.c

271

(int)sizeof(aif->data.EN.data.EG),

sys/dev/aac/aac_debug.c

272

aif->data.EN.data.EG.text);

sys/dev/aac/aacreg.h

972

struct aac_AifEnsGeneric EG;

sys/dev/aacraid/aacraid_debug.c

183

(int)sizeof(aif->data.EN.data.EG),

sys/dev/aacraid/aacraid_debug.c

184

aif->data.EN.data.EG.text);

sys/dev/aacraid/aacraid_reg.h

963

struct aac_AifEnsGeneric EG;