void ep2_curve_clean(void) { ctx_t *ctx = core_get(); #ifdef EP_PRECO for (int i = 0; i < EP_TABLE; i++) { fp2_free(ctx->ep2_pre[i].x); fp2_free(ctx->ep2_pre[i].y); fp2_free(ctx->ep2_pre[i].z); } #endif bn_clean(&(ctx->ep2_r)); bn_clean(&(ctx->ep2_h)); }
void bench_compute(int benches) { ctx_t *ctx = core_get(); #if TIMER != NONE ctx->total = ctx->total / benches; #ifdef OVERH ctx->total = ctx->total - ctx->over; #endif /* OVERH */ #else (void)benches; (void)ctx; #endif /* TIMER != NONE */ }
/** * Find non-zero bits for fast trace computation. * * @throw ERR_NO_MEMORY if there is no available memory. * @throw ERR_NO_VALID if the polynomial is invalid. */ static void find_trace() { fb_t t0, t1; int counter; ctx_t *ctx = core_get(); fb_null(t0); fb_null(t1); ctx->fb_ta = ctx->fb_tb = ctx->fb_tc = -1; TRY { fb_new(t0); fb_new(t1); counter = 0; for (int i = 0; i < FB_BITS; i++) { fb_zero(t0); fb_set_bit(t0, i, 1); fb_copy(t1, t0); for (int j = 1; j < FB_BITS; j++) { fb_sqr(t1, t1); fb_add(t0, t0, t1); } if (!fb_is_zero(t0)) { switch (counter) { case 0: ctx->fb_ta = i; ctx->fb_tb = ctx->fb_tc = -1; break; case 1: ctx->fb_tb = i; ctx->fb_tc = -1; break; case 2: ctx->fb_tc = i; break; default: THROW(ERR_NO_VALID); break; } counter++; } } } CATCH_ANY { THROW(ERR_CAUGHT); } FINALLY { fb_free(t0); fb_free(t1); } }
void fp_prime_clean() { ctx_t *ctx = core_get(); ctx->fp_id = 0; #if FP_RDC == QUICK || !defined(STRIP) ctx->sps_len = 0; memset(ctx->sps, 0, sizeof(ctx->sps)); #endif #if FP_RDC == MONTY || !defined(STRIP) bn_clean(&(ctx->one)); bn_clean(&(ctx->conv)); #endif bn_clean(&(ctx->prime)); }
const dig_t *fb_poly_tab_srz(int i) { #if FB_SRT == QUICK || !defined(STRIP) #ifdef FB_PRECO return core_get()->fb_tab_srz[i]; #else return NULL; #endif #else return NULL; #endif }
int ed_affine_is_valid(const fp_t x, const fp_t y) { fp_t tmpFP0; fp_t tmpFP1; fp_t tmpFP2; fp_null(tmpFP0); fp_null(tmpFP1); fp_null(tmpFP2); int r = 0; TRY { fp_new(tmpFP0); fp_new(tmpFP1); fp_new(tmpFP2); // a * X^2 + Y^2 - 1 - d * X^2 * Y^2 =?= 0 fp_sqr(tmpFP0, x); fp_mul(tmpFP0, core_get()->ed_a, tmpFP0); fp_sqr(tmpFP1, y); fp_add(tmpFP1, tmpFP0, tmpFP1); fp_sub_dig(tmpFP1, tmpFP1, 1); fp_sqr(tmpFP0, x); fp_mul(tmpFP0, core_get()->ed_d, tmpFP0); fp_sqr(tmpFP2, y); fp_mul(tmpFP2, tmpFP0, tmpFP2); fp_sub(tmpFP0, tmpFP1, tmpFP2); r = fp_is_zero(tmpFP0); } CATCH_ANY { THROW(ERR_CAUGHT); } FINALLY { fp_free(tmpFP0); fp_free(tmpFP1); fp_free(tmpFP2); } return r; }
void rand_seed(uint8_t *buf, int size) { int i; ctx_t *ctx = core_get(); if (size < MD_LEN_SHONE) { THROW(ERR_NO_VALID); } /* XKEY = SEED, throws away additional bytes. */ for (i = 0; i < MD_LEN_SHONE; i++) { ctx->rand[i] = buf[i]; } ctx->seeded = 1; }
const int *fp_prime_get_sps(int *len) { ctx_t *ctx = core_get(); if (ctx->sps_len > 0 && ctx->sps_len < MAX_TERMS) { if (len != NULL) { *len = ctx->sps_len; } return ctx->sps; } else { if (len != NULL) { *len = 0; } return NULL; } }
void fp_prime_set_pmers(const int *f, int len) { bn_t p, t; bn_null(p); bn_null(t); TRY { bn_new(p); bn_new(t); if (len >= MAX_TERMS) { THROW(ERR_NO_VALID); } bn_set_2b(p, f[len - 1]); for (int i = len - 2; i > 0; i--) { if (f[i] > 0) { bn_set_2b(t, f[i]); bn_add(p, p, t); } else { bn_set_2b(t, -f[i]); bn_sub(p, p, t); } } if (f[0] > 0) { bn_add_dig(p, p, f[0]); } else { bn_sub_dig(p, p, -f[0]); } #if FP_RDC == QUICK || !defined(STRIP) ctx_t *ctx = core_get(); for (int i = 0; i < len; i++) { ctx->sps[i] = f[i]; } ctx->sps[len] = 0; ctx->sps_len = len; #endif /* FP_RDC == QUICK */ fp_prime_set(p); } CATCH_ANY { THROW(ERR_CAUGHT); } FINALLY { bn_free(p); bn_free(t); } }
/** * Precomputes the square root of z. */ static void find_srz() { ctx_t *ctx = core_get(); fb_set_dig(ctx->fb_srz, 2); for (int i = 1; i < FB_BITS; i++) { fb_sqr(ctx->fb_srz, ctx->fb_srz); } #ifdef FB_PRECO for (int i = 0; i <= 255; i++) { fb_mul_dig(ctx->fb_tab_srz[i], ctx->fb_srz, i); } #endif }
void ep2_curve_set(fp2_t a, fp2_t b, ep2_t g, bn_t r, bn_t h) { ctx_t *ctx = core_get(); ctx->ep2_is_twist = 0; fp2_copy(ctx->ep2_a, a); fp2_copy(ctx->ep2_b, b); ep2_norm(&(ctx->ep2_g), g); bn_copy(&(ctx->ep2_r), r); bn_copy(&(ctx->ep2_h), h); #if defined(EP_PRECO) ep2_mul_pre((ep2_t *)ep2_curve_get_tab(), &(ctx->ep2_g)); #endif }
/** * Configures the irreducible polynomial of the binary field. * * @param[in] f - the new irreducible polynomial. */ static void fb_poly_set(const fb_t f) { fb_copy(core_get()->fb_poly, f); #if FB_TRC == QUICK || !defined(STRIP) find_trace(); #endif #if FB_SLV == QUICK || !defined(STRIP) find_solve(); #endif #if FB_SRT == QUICK || !defined(STRIP) find_srz(); #endif #if FB_INV == ITOHT || !defined(STRIP) find_chain(); #endif }
void bench_print(void) { ctx_t *ctx = core_get(); #if TIMER == POSIX || TIMER == ANSI || (OPSYS == DUINO && TIMER == HREAL) util_print("%lld microsec", ctx->total); #elif TIMER == CYCLE util_print("%lld cycles", ctx->total); #else util_print("%lld nanosec", ctx->total); #endif if (ctx->total < 0) { util_print(" (overflow or bad overhead estimation)\n"); } else { util_print("\n"); } }
void bench_overhead(void) { ctx_t *ctx = core_get(); int a[BENCH + 1]; int *tmpa; do { ctx->over = 0; for (int l = 0; l < BENCH; l++) { ctx->total = 0; /* Measure the cost of (n^2 + over). */ bench_before(); for (int i = 0; i < BENCH; i++) { tmpa = a; for (int j = 0; j < BENCH; j++) { empty(tmpa++); } } bench_after(); /* Add the cost of (n^2 + over). */ ctx->over += ctx->total; } /* Overhead stores the cost of n*(n^2 + over) = n^3 + n*over. */ ctx->total = 0; /* Measure the cost of (n^3 + over). */ bench_before(); for (int i = 0; i < BENCH; i++) { for (int k = 0; k < BENCH; k++) { tmpa = a; for (int j = 0; j < BENCH; j++) { empty(tmpa++); } } } bench_after(); /* Subtract the cost of (n^3 + over). */ ctx->over -= ctx->total; /* Now overhead stores (n - 1)*over, so take the average to obtain the * overhead to execute BENCH operations inside a benchmark. */ ctx->over /= (BENCH - 1); /* Divide to obtain the overhead of one operation pair. */ ctx->over /= BENCH; } while (ctx->over < 0); ctx->total = ctx->over; bench_print(); }
const int *fp_prime_get_sps(int *len) { #if FP_RDC == QUICK || !defined(STRIP) ctx_t *ctx = core_get(); if (ctx->sps_len > 0 && ctx->sps_len < MAX_TERMS) { if (len != NULL) { *len = ctx->sps_len; } return ctx->sps; } else { if (len != NULL) { *len = 0; } return NULL; } #else return NULL; #endif }
/** * Generates pseudo-random bytes by iterating the hash function. * * @param[out] out - the buffer to write. * @param[in] out_len - the number of bytes to write. */ static void rand_gen(uint8_t *out, int out_len) { int m = CEIL(out_len, MD_LEN); uint8_t hash[MD_LEN], data[(RAND_SIZE - 1)/2]; ctx_t *ctx = core_get(); /* data = V */ memcpy(data, ctx->rand + 1, (RAND_SIZE - 1)/2); for (int i = 0; i < m; i++) { /* w_i = Hash(data) */ md_map(hash, data, sizeof(data)); /* W = W || w_i */ memcpy(out, hash, MIN(MD_LEN, out_len)); out += MD_LEN; out_len -= MD_LEN; /* data = data + 1 mod 2^b. */ rand_inc(data, (RAND_SIZE - 1)/2, 1); } }
const int *fb_poly_get_chain(int *len) { #if FB_INV == ITOHT || !defined(STRIP) ctx_t *ctx = core_get(); if (ctx->chain_len > 0 && ctx->chain_len < MAX_TERMS) { if (len != NULL) { *len = ctx->chain_len; } return ctx->chain; } else { if (len != NULL) { *len = 0; } return NULL; } #else return NULL; #endif }
void eb_param_print() { switch (core_get()->eb_id) { case NIST_B163: util_banner("Curve NIST-B163:", 0); break; case NIST_K163: util_banner("Curve NIST-K163:", 0); break; case NIST_B233: util_banner("Curve NIST-B233:", 0); break; case NIST_K233: util_banner("Curve NIST-K233:", 0); break; case SECG_K239: util_banner("Curve SECG-K239:", 0); break; case EBACS_B251: util_banner("Curve EBACS-B251:", 0); break; case HALVE_B257: util_banner("Curve HALVE-B257:", 0); break; case NIST_B283: util_banner("Curve NIST-B283:", 0); break; case NIST_K283: util_banner("Curve NIST-K283:", 0); break; case NIST_B409: util_banner("Curve NIST-B409:", 0); break; case NIST_K409: util_banner("Curve NIST-K409:", 0); break; case NIST_B571: util_banner("Curve NIST-B571:", 0); break; case NIST_K571: util_banner("Curve NIST-K571:", 0); break; } }
void eb_curve_clean(void) { ctx_t *ctx = core_get(); #if ALLOC == STATIC fb_free(ctx->eb_g.x); fb_free(ctx->eb_g.y); fb_free(ctx->eb_g.z); for (int i = 0; i < EB_TABLE; i++) { fb_free(ctx->eb_pre[i].x); fb_free(ctx->eb_pre[i].y); fb_free(ctx->eb_pre[i].z); } #endif bn_clean(&(ctx->eb_r)); bn_clean(&(ctx->eb_h)); #if defined(EB_KBLTZ) && (EB_MUL == LWNAF || !defined(STRIP)) bn_clean(&(ctx->eb_vm)); bn_clean(&(ctx->eb_s0)); bn_clean(&(ctx->eb_s1)); #endif }
void ep_curve_set_super(const fp_t a, const fp_t b, const ep_t g, const bn_t r, const bn_t h) { ctx_t *ctx = core_get(); ctx->ep_is_endom = 0; ctx->ep_is_super = 1; fp_copy(ctx->ep_a, a); fp_copy(ctx->ep_b, b); detect_opt(&(ctx->ep_opt_a), ctx->ep_a); detect_opt(&(ctx->ep_opt_b), ctx->ep_b); ep_norm(&(ctx->ep_g), g); bn_copy(&(ctx->ep_r), r); bn_copy(&(ctx->ep_h), h); #if defined(EP_PRECO) ep_mul_pre((ep_t *)ep_curve_get_tab(), &(ctx->ep_g)); #endif }
void rand_clean() { #if RAND == UDEV int *fd = (int *)&(core_get()->rand); close(*fd); #endif #if RAND != CALL memset(core_get()->rand, 0, sizeof(core_get()->rand)); #else core_get()->rand_call = NULL; core_get()->rand_args = NULL; #endif core_get()->seeded = 0; }
void rand_bytes(uint8_t *buf, int size) { uint8_t hash[MD_LEN]; int carry, len = (RAND_SIZE - 1)/2; ctx_t *ctx = core_get(); if (sizeof(int) > 2 && size > (1 << 16)) { THROW(ERR_NO_VALID); } /* buf = hash_gen(size) */ rand_gen(buf, size); /* H = hash(03 || V) */ ctx->rand[0] = 0x3; md_map(hash, ctx->rand, 1 + len); /* V = V + H + C + reseed_counter. */ rand_add(ctx->rand + 1, ctx->rand + 1 + len, len); carry = rand_add(ctx->rand + 1 + (len - MD_LEN), hash, MD_LEN); rand_inc(ctx->rand, len - MD_LEN + 1, carry); rand_inc(ctx->rand, len + 1, ctx->counter); ctx->counter = ctx->counter + 1; }
void ep2_curve_init(void) { ctx_t *ctx = core_get(); #ifdef EP_PRECO for (int i = 0; i < EP_TABLE; i++) { ctx->ep2_ptr[i] = &(ctx->ep2_pre[i]); } #endif #if ALLOC == STATIC || ALLOC == DYNAMIC || ALLOC == STACK ctx->ep2_g.x[0] = ctx->ep2_gx[0]; ctx->ep2_g.x[1] = ctx->ep2_gx[1]; ctx->ep2_g.y[0] = ctx->ep2_gy[0]; ctx->ep2_g.y[1] = ctx->ep2_gy[1]; ctx->ep2_g.z[0] = ctx->ep2_gz[0]; ctx->ep2_g.z[1] = ctx->ep2_gz[1]; #endif #ifdef EP_PRECO #if ALLOC == STATIC || ALLOC == DYNAMIC for (int i = 0; i < EP_TABLE; i++) { fp2_new(ctx->ep2_pre[i].x); fp2_new(ctx->ep2_pre[i].y); fp2_new(ctx->ep2_pre[i].z); } #elif ALLOC == STACK for (int i = 0; i < EP_TABLE; i++) { ctx->ep2_pre[i].x[0] = ctx->_ep2_pre[3 * i][0]; ctx->ep2_pre[i].x[1] = ctx->_ep2_pre[3 * i][1]; ctx->ep2_pre[i].y[0] = ctx->_ep2_pre[3 * i + 1][0]; ctx->ep2_pre[i].y[1] = ctx->_ep2_pre[3 * i + 1][1]; ctx->ep2_pre[i].z[0] = ctx->_ep2_pre[3 * i + 2][0]; ctx->ep2_pre[i].z[1] = ctx->_ep2_pre[3 * i + 2][1]; } #endif #endif ep2_set_infty(&(ctx->ep2_g)); bn_init(&(ctx->ep2_r), FP_DIGS); bn_init(&(ctx->ep2_h), FP_DIGS); }
void eb_curve_set_kbltz(const fb_t a, const eb_t g, const bn_t r, const bn_t h) { ctx_t *ctx = core_get(); ctx->eb_is_kbltz = 1; ctx->eb_is_super = 0; fb_copy(ctx->eb_a, a); fb_set_dig(ctx->eb_b, 1); detect_opt(&(ctx->eb_opt_a), ctx->eb_a); detect_opt(&(ctx->eb_opt_b), ctx->eb_b); #if EB_MUL == LWNAF || EB_FIX == LWNAF || EB_SIM == INTER || !defined(STRIP) compute_kbltz(); #endif eb_norm(&(ctx->eb_g), g); bn_copy(&(ctx->eb_r), r); bn_copy(&(ctx->eb_h), h); #if defined(EB_PRECO) eb_mul_pre((eb_t *)eb_curve_get_tab(), &(ctx->eb_g)); #endif }
void eb_curve_set_super(const fb_t a, const fb_t b, const fb_t c, const eb_t g, const bn_t r, const bn_t h) { ctx_t *ctx = core_get(); ctx->eb_is_kbltz = 0; ctx->eb_is_super = 1; fb_copy(ctx->eb_a, a); fb_copy(ctx->eb_b, b); fb_copy(ctx->eb_c, c); detect_opt(&(ctx->eb_opt_a), ctx->eb_a); detect_opt(&(ctx->eb_opt_b), ctx->eb_b); detect_opt(&(ctx->eb_opt_c), ctx->eb_c); eb_norm(&(ctx->eb_g), g); bn_copy(&(ctx->eb_r), r); bn_copy(&(ctx->eb_h), h); #if defined(EB_PRECO) eb_mul_pre((eb_t *)eb_curve_get_tab(), &(ctx->eb_g)); #endif }
void fp2_mul_frb(fp2_t c, fp2_t a, int i, int j) { ctx_t *ctx = core_get(); if (i == 2) { fp_mul(c[0], a[0], ctx->fp2_p2[j - 1]); fp_mul(c[1], a[1], ctx->fp2_p2[j - 1]); } else { #if ALLOC == AUTO if (i == 1) { fp2_mul(c, a, ctx->fp2_p[j - 1]); } else { fp2_mul(c, a, ctx->fp2_p3[j - 1]); } #else fp2_t t; fp2_null(t); TRY { fp2_new(t); if (i == 1) { fp_copy(t[0], ctx->fp2_p[j - 1][0]); fp_copy(t[1], ctx->fp2_p[j - 1][1]); } else { fp_copy(t[0], ctx->fp2_p3[j - 1][0]); fp_copy(t[1], ctx->fp2_p3[j - 1][1]); } fp2_mul(c, a, t); } CATCH_ANY { THROW(ERR_CAUGHT); } FINALLY { fp2_free(t); } #endif } }
int eb_param_level() { switch (core_get()->eb_id) { case NIST_B163: case NIST_K163: return 80; case NIST_B233: case NIST_K233: case SECG_K239: return 112; case EBACS_B251: case HALVE_B257: case NIST_B283: case NIST_K283: return 128; case NIST_B409: case NIST_K409: return 192; case NIST_B571: case NIST_K571: return 256; } return 0; }
void ep_curve_clean(void) { ctx_t *ctx = core_get(); #if ALLOC == STATIC fp_free(ctx->ep_g.x); fp_free(ctx->ep_g.y); fp_free(ctx->ep_g.z); #ifdef EP_PRECO for (int i = 0; i < RELIC_EP_TABLE; i++) { fp_free(ctx->ep_pre[i].x); fp_free(ctx->ep_pre[i].y); fp_free(ctx->ep_pre[i].z); } #endif #endif bn_clean(&ctx->ep_r); bn_clean(&ctx->ep_h); #if defined(EP_ENDOM) && (EP_MUL == LWNAF || EP_FIX == LWNAF || !defined(STRIP)) for (int i = 0; i < 3; i++) { bn_clean(&(ctx->ep_v1[i])); bn_clean(&(ctx->ep_v2[i])); } #endif }
/** * Precomputes half-traces for z^i with odd i. * * @throw ERR_NO_MEMORY if there is no available memory. */ static void find_solve() { int i, j, k, l; fb_t t0; ctx_t *ctx = core_get(); fb_null(t0); TRY { fb_new(t0); l = 0; for (i = 0; i < FB_BITS; i += 8, l++) { for (j = 0; j < 16; j++) { fb_zero(t0); for (k = 0; k < 4; k++) { if (j & (1 << k)) { fb_set_bit(t0, i + 2 * k + 1, 1); } } fb_copy(ctx->fb_half[l][j], t0); for (k = 0; k < (FB_BITS - 1) / 2; k++) { fb_sqr(ctx->fb_half[l][j], ctx->fb_half[l][j]); fb_sqr(ctx->fb_half[l][j], ctx->fb_half[l][j]); fb_add(ctx->fb_half[l][j], ctx->fb_half[l][j], t0); } } fb_rsh(ctx->fb_half[l][j], ctx->fb_half[l][j], 1); } } CATCH_ANY { THROW(ERR_CAUGHT); } FINALLY { fb_free(t0); } }
void ep_param_set(int param) { int plain = 0, endom = 0, super = 0; char str[2 * FP_BYTES + 2]; fp_t a, b, beta; ep_t g; bn_t r, h, lamb; fp_null(a); fp_null(b); fp_null(beta); bn_null(lamb); ep_null(g); bn_null(r); bn_null(h); TRY { fp_new(a); fp_new(b); fp_new(beta); bn_new(lamb); ep_new(g); bn_new(r); bn_new(h); core_get()->ep_id = 0; switch (param) { #if defined(EP_ENDOM) && FP_PRIME == 158 case BN_P158: ASSIGNK(BN_P158, BN_158); endom = 1; break; #endif #if defined(EP_PLAIN) && FP_PRIME == 160 case SECG_P160: ASSIGN(SECG_P160, SECG_160); plain = 1; break; #endif #if defined(EP_ENDOM) && FP_PRIME == 160 case SECG_K160: ASSIGNK(SECG_K160, SECG_160D); endom = 1; break; #endif #if defined(EP_PLAIN) && FP_PRIME == 192 case NIST_P192: ASSIGN(NIST_P192, NIST_192); plain = 1; break; #endif #if defined(EP_ENDOM) && FP_PRIME == 192 case SECG_K192: ASSIGNK(SECG_K192, SECG_192); endom = 1; break; #endif #if defined(EP_PLAIN) && FP_PRIME == 221 case CURVE_22103: ASSIGN(CURVE_22103, PRIME_22103); plain = 1; break; #endif #if defined(EP_PLAIN) && FP_PRIME == 224 case NIST_P224: ASSIGN(NIST_P224, NIST_224); plain = 1; break; #endif #if defined(EP_ENDOM) && FP_PRIME == 224 case SECG_K224: ASSIGNK(SECG_K224, SECG_224); endom = 1; break; #endif #if defined(EP_PLAIN) && FP_PRIME == 226 case CURVE_4417: ASSIGN(CURVE_4417, PRIME_22605); plain = 1; break; #endif #if defined(EP_ENDOM) && FP_PRIME == 254 case BN_P254: ASSIGNK(BN_P254, BN_254); endom = 1; break; #endif #if defined(EP_PLAIN) && FP_PRIME == 251 case CURVE_1174: ASSIGN(CURVE_1174, PRIME_25109); plain = 1; break; #endif #if defined(EP_PLAIN) && FP_PRIME == 255 case CURVE_25519: ASSIGN(CURVE_25519, PRIME_25519); plain = 1; break; #endif #if defined(EP_PLAIN) && FP_PRIME == 256 case NIST_P256: ASSIGN(NIST_P256, NIST_256); plain = 1; break; #endif #if defined(EP_ENDOM) && FP_PRIME == 256 case SECG_K256: ASSIGNK(SECG_K256, SECG_256); endom = 1; break; case BN_P256: ASSIGNK(BN_P256, BN_256); endom = 1; break; #endif #if defined(EP_PLAIN) & FP_PRIME == 382 case CURVE_67254: ASSIGN(CURVE_67254, PRIME_382105); plain = 1; break; #endif #if defined(EP_PLAIN) && FP_PRIME == 383 case CURVE_383187: ASSIGN(CURVE_383187, PRIME_383187); plain = 1; break; #endif #if defined(EP_PLAIN) && FP_PRIME == 384 case NIST_P384: ASSIGN(NIST_P384, NIST_384); plain = 1; break; #endif #if defined(EP_PLAIN) && FP_PRIME == 477 case B24_P477: ASSIGN(B24_P477, B24_477); plain = 1; break; #endif #if defined(EP_ENDOM) && FP_PRIME == 508 case KSS_P508: ASSIGNK(KSS_P508, KSS_508); endom = 1; break; #endif #if defined(EP_PLAIN) && FP_PRIME == 511 case CURVE_511187: ASSIGN(CURVE_511187, PRIME_511187); plain = 1; break; #endif #if defined(EP_PLAIN) && FP_PRIME == 521 case NIST_P521: ASSIGN(NIST_P521, NIST_521); plain = 1; break; #endif #if defined(EP_ENDOM) && FP_PRIME == 638 case BN_P638: ASSIGNK(BN_P638, BN_638); endom = 1; break; case B12_P638: ASSIGNK(B12_P638, B12_638); endom = 1; break; #endif #if defined(EP_SUPER) && FP_PRIME == 1536 case SS_P1536: ASSIGN(SS_P1536, SS_1536); super = 1; break; #endif default: (void)str; THROW(ERR_NO_VALID); break; } /* Do not generate warnings. */ (void)endom; (void)plain; (void)beta; fp_zero(g->z); fp_set_dig(g->z, 1); g->norm = 1; #if defined(EP_PLAIN) if (plain) { ep_curve_set_plain(a, b, g, r, h); core_get()->ep_id = param; } #endif #if defined(EP_ENDOM) if (endom) { ep_curve_set_endom(b, g, r, h, beta, lamb); core_get()->ep_id = param; } #endif #if defined(EP_SUPER) if (super) { ep_curve_set_super(a, b, g, r, h); core_get()->ep_id = param; } #endif } CATCH_ANY { THROW(ERR_CAUGHT); } FINALLY { fp_free(a); fp_free(b); fp_free(beta); bn_free(lamb); ep_free(g); bn_free(r); bn_free(h); } }