Ejemplos de eb_copy en C++ (Cpp)

Ejemplo n.º 1

Archivo: relic_eb_add.c Proyecto: Gesine/relic

void eb_add_projc(eb_t r, const eb_t p, const eb_t q) {
	if (eb_is_infty(p)) {
		eb_copy(r, q);
		return;
	}

	if (eb_is_infty(q)) {
		eb_copy(r, p);
		return;
	}

	eb_add_projc_imp(r, p, q);
}

Ejemplo n.º 2

Archivo: relic_eb_add.c Proyecto: 0x64616E69656C/supercop

void eb_add_projc(eb_t r, eb_t p, eb_t q) {
	if (eb_is_infty(p)) {
		eb_copy(r, q);
		return;
	}

	if (eb_is_infty(q)) {
		eb_copy(r, p);
		return;
	}

#if defined(EB_ORDIN) || defined(EB_KBLTZ)
	eb_add_projc_ordin(r, p, q);
#endif
}

Ejemplo n.º 3

Archivo: relic_eb_curve.c Proyecto: 0x64616E69656C/supercop

void eb_curve_set_ordin(fb_t a, fb_t b, eb_t g, bn_t r, bn_t h) {
	fb_copy(curve_a, a);
	fb_copy(curve_b, b);

	detect_opt(&curve_opt_a, curve_a);
	detect_opt(&curve_opt_b, curve_b);

	curve_is_super = 0;
	if (fb_cmp_dig(curve_b, 1) == CMP_EQ) {
		curve_is_kbltz = 1;
	} else {
		curve_is_kbltz = 0;
	}
#if defined(EB_KBLTZ) && (EB_MUL == LWNAF || EB_FIX == LWNAF || EB_SIM == INTER || !defined(STRIP))
	if (curve_is_kbltz) {
		compute_kbltz();
	}
#endif

	eb_norm(g, g);
	eb_copy(&curve_g, g);
	bn_copy(&curve_r, r);
	bn_copy(&curve_h, h);
#if defined(EB_PRECO)
	eb_mul_pre(eb_curve_get_tab(), &curve_g);
#endif
}

Ejemplo n.º 4

Archivo: relic_eb_mul_fix.c Proyecto: 0x64616E69656C/supercop

void eb_mul_pre_combs(eb_t *t, eb_t p) {
	int i, j, l;
	bn_t ord;

	bn_null(ord);

	TRY {
		bn_new(ord);

		eb_curve_get_ord(ord);
		l = bn_bits(ord);
		l = ((l % EB_DEPTH) == 0 ? (l / EB_DEPTH) : (l / EB_DEPTH) + 1);

		eb_set_infty(t[0]);

		eb_copy(t[1], p);
		for (j = 1; j < EB_DEPTH; j++) {
			eb_dbl(t[1 << j], t[1 << (j - 1)]);
			for (i = 1; i < l; i++) {
				eb_dbl(t[1 << j], t[1 << j]);
			}
			for (i = 1; i < (1 << j); i++) {
				eb_add(t[(1 << j) + i], t[1 << j], t[i]);
			}
		}

		eb_norm_sim(t + 2, t + 2, EB_TABLE_COMBS - 2);
	}
	CATCH_ANY {
		THROW(ERR_CAUGHT);
	}
	FINALLY {
		bn_free(ord);
	}
}

Ejemplo n.º 5

Archivo: relic_eb_norm.c Proyecto: ekr/hacrypto

void eb_norm(eb_t r, const eb_t p) {
	if (eb_is_infty(p)) {
		eb_set_infty(r);
		return;
	}

	if (p->norm == 1) {
		/* If the point is represented in affine coordinates, we just copy it. */
		eb_copy(r, p);
		return;
	}

	if (p->norm == 2) {
		eb_norm_halve(r, p);
		return;
	}

#if EB_ADD == PROJC || !defined(STRIP)

#if defined(EB_SUPER)
	if (eb_curve_is_super()) {
		eb_norm_super(r, p, 0);
		return;
	}
#endif /* EB_SUPER */

#if defined(EB_ORDIN) || defined(EB_KBLTZ)
	eb_norm_ordin(r, p, 0);
#endif /* EB_ORDIN || EB_KBLTZ */

#endif /* EB_ADD == PROJC */
}

Ejemplo n.º 6

Archivo: relic_eb_mul_fix.c Proyecto: 0x64616E69656C/supercop

void eb_mul_fix_combs(eb_t r, eb_t *t, bn_t k) {
	int i, j, l, w, n, p0, p1;
	bn_t ord;

	bn_null(ord);

	TRY {
		bn_new(ord);

		eb_curve_get_ord(ord);
		l = bn_bits(ord);
		l = ((l % EB_DEPTH) == 0 ? (l / EB_DEPTH) : (l / EB_DEPTH) + 1);

		n = bn_bits(k);

		p0 = (EB_DEPTH) * l - 1;

		w = 0;
		p1 = p0--;
		for (j = EB_DEPTH - 1; j >= 0; j--, p1 -= l) {
			w = w << 1;
			if (p1 < n && bn_test_bit(k, p1)) {
				w = w | 1;
			}
		}
		eb_copy(r, t[w]);

		for (i = l - 2; i >= 0; i--) {
			eb_dbl(r, r);

			w = 0;
			p1 = p0--;
			for (j = EB_DEPTH - 1; j >= 0; j--, p1 -= l) {
				w = w << 1;
				if (p1 < n && bn_test_bit(k, p1)) {
					w = w | 1;
				}
			}
			if (w > 0) {
				eb_add(r, r, t[w]);
			}
		}
		eb_norm(r, r);
	}
	CATCH_ANY {
		THROW(ERR_CAUGHT);
	}
	FINALLY {
		bn_free(ord);
	}
}

Ejemplo n.º 7

Archivo: relic_eb_mul_fix.c Proyecto: 0x64616E69656C/supercop

void eb_mul_pre_combd(eb_t *t, eb_t p) {
	bn_t n;

	bn_null(n);

	TRY {
		int i, j, d, e;
		bn_new(n);

		eb_curve_get_ord(n);
		d = bn_bits(n);
		d = ((d % EB_DEPTH) == 0 ? (d / EB_DEPTH) : (d / EB_DEPTH) + 1);
		e = (d % 2 == 0 ? (d / 2) : (d / 2) + 1);

		eb_set_infty(t[0]);
		eb_copy(t[1], p);
		for (j = 1; j < EB_DEPTH; j++) {
			eb_dbl(t[1 << j], t[1 << (j - 1)]);
			for (i = 1; i < d; i++) {
				eb_dbl(t[1 << j], t[1 << j]);
			}
			for (i = 1; i < (1 << j); i++) {
				eb_add(t[(1 << j) + i], t[1 << j], t[i]);
			}
		}
		eb_set_infty(t[1 << EB_DEPTH]);
		for (j = 1; j < (1 << EB_DEPTH); j++) {
			eb_dbl(t[(1 << EB_DEPTH) + j], t[j]);
			for (i = 1; i < e; i++) {
				eb_dbl(t[(1 << EB_DEPTH) + j], t[(1 << EB_DEPTH) + j]);
			}
		}

		eb_norm_sim(t + 2, t + 2, (1 << EB_DEPTH) - 2);
		eb_norm_sim(t + (1 << EB_DEPTH) + 1, t + (1 << EB_DEPTH) + 1, (1 << EB_DEPTH) - 1);
	}
	CATCH_ANY {
		THROW(ERR_CAUGHT);
	}
	FINALLY {
		bn_free(n);
	}
}

Ejemplo n.º 8

Archivo: relic_eb_curve.c Proyecto: 0x64616E69656C/supercop

void eb_curve_set_super(fb_t a, fb_t b, fb_t c, eb_t g, bn_t r, bn_t h) {
	curve_is_kbltz = 0;
	curve_is_super = 1;

	fb_copy(curve_a, a);
	fb_copy(curve_b, b);
	fb_copy(curve_c, c);

	detect_opt(&curve_opt_a, curve_a);
	detect_opt(&curve_opt_b, curve_b);
	detect_opt(&curve_opt_c, curve_c);

	eb_norm(g, g);
	eb_copy(&curve_g, g);
	bn_copy(&curve_r, r);
	bn_copy(&curve_h, h);
#if defined(EB_PRECO)
	eb_mul_pre(eb_curve_get_tab(), &curve_g);
#endif
}

Ejemplo n.º 9

Archivo: relic_eb_curve.c Proyecto: 0x64616E69656C/supercop

void eb_curve_set_kbltz(fb_t a, eb_t g, bn_t r, bn_t h) {
	curve_is_kbltz = 1;
	curve_is_super = 0;

	fb_copy(curve_a, a);
	fb_set_dig(curve_b, 1);

	detect_opt(&curve_opt_a, curve_a);
	detect_opt(&curve_opt_b, curve_b);

#if EB_MUL == LWNAF || EB_FIX == LWNAF || EB_SIM == INTER || !defined(STRIP)
	compute_kbltz();
#endif
	eb_norm(g, g);
	eb_copy(&curve_g, g);
	bn_copy(&curve_r, r);
	bn_copy(&curve_h, h);
#if defined(EB_PRECO)
	eb_mul_pre(eb_curve_get_tab(), &curve_g);
#endif
}

Ejemplo n.º 10

Archivo: relic_eb_mul_sim.c Proyecto: enascimento/relic-git-avr

void eb_mul_sim_joint(eb_t r, const eb_t p, const bn_t k, const eb_t q,
		const bn_t m) {
	eb_t t[5];
	int u_i, len, offset;
	int8_t jsf[2 * (FB_BITS + 1)];
	int i;

	eb_null(t[0]);
	eb_null(t[1]);
	eb_null(t[2]);
	eb_null(t[3]);
	eb_null(t[4]);

	TRY {
		for (i = 0; i < 5; i++) {
			eb_new(t[i]);
		}

		eb_set_infty(t[0]);
		eb_copy(t[1], q);
		eb_copy(t[2], p);
		eb_add(t[3], p, q);
		eb_sub(t[4], p, q);
#if defined(EB_MIXED)
		eb_norm_sim(t + 3, (const eb_t*)(t + 3), 2);
#endif

		len = 2 * (FB_BITS + 1);
		bn_rec_jsf(jsf, &len, k, m);

		eb_set_infty(r);

		offset = MAX(bn_bits(k), bn_bits(m)) + 1;
		for (i = len - 1; i >= 0; i--) {
			eb_dbl(r, r);
			if (jsf[i] != 0 && jsf[i] == -jsf[i + offset]) {
				u_i = jsf[i] * 2 + jsf[i + offset];
				if (u_i < 0) {
					eb_sub(r, r, t[4]);
				} else {
					eb_add(r, r, t[4]);
				}
			} else {
				u_i = jsf[i] * 2 + jsf[i + offset];
				if (u_i < 0) {
					eb_sub(r, r, t[-u_i]);
				} else {
					eb_add(r, r, t[u_i]);
				}
			}
		}
		eb_norm(r, r);
	}
	CATCH_ANY {
		THROW(ERR_CAUGHT);
	}
	FINALLY {
		for (i = 0; i < 5; i++) {
			eb_free(t[i]);
		}
	}
}

Ejemplo n.º 11

Archivo: relic_eb_mul_sim.c Proyecto: relic-toolkit/relic

void eb_mul_sim_trick(eb_t r, const eb_t p, const bn_t k, const eb_t q,
		const bn_t m) {
	eb_t t0[1 << (EB_WIDTH / 2)], t1[1 << (EB_WIDTH / 2)], t[1 << EB_WIDTH];
	int l0, l1, w = EB_WIDTH / 2;
	uint8_t *w0 = RLC_ALLOCA(uint8_t, RLC_CEIL(RLC_FB_BITS, w));
	uint8_t *w1 = RLC_ALLOCA(uint8_t, RLC_CEIL(RLC_FB_BITS, w));
	bn_t n;

	bn_null(n);

	if (bn_is_zero(k) || eb_is_infty(p)) {
		eb_mul(r, q, m);
		return;
	}
	if (bn_is_zero(m) || eb_is_infty(q)) {
		eb_mul(r, p, k);
		return;
	}

	TRY {
		bn_new(n);

		eb_curve_get_ord(n);

		for (int i = 0; i < (1 << w); i++) {
			eb_null(t0[i]);
			eb_null(t1[i]);
			eb_new(t0[i]);
			eb_new(t1[i]);
		}
		for (int i = 0; i < (1 << EB_WIDTH); i++) {
			eb_null(t[i]);
			eb_new(t[i]);
		}

		eb_set_infty(t0[0]);
		eb_copy(t0[1], p);
		if (bn_sign(k) == RLC_NEG) {
			eb_neg(t0[1], t0[1]);
		}
		for (int i = 2; i < (1 << w); i++) {
			eb_add(t0[i], t0[i - 1], t0[1]);
		}

		eb_set_infty(t1[0]);
		eb_copy(t1[1], q);
		if (bn_sign(m) == RLC_NEG) {
			eb_neg(t1[1], t1[1]);
		}
		for (int i = 2; i < (1 << w); i++) {
			eb_add(t1[i], t1[i - 1], t1[1]);
		}

		for (int i = 0; i < (1 << w); i++) {
			for (int j = 0; j < (1 << w); j++) {
				eb_add(t[(i << w) + j], t0[i], t1[j]);
			}
		}

#if EB_WIDTH > 2 && defined(EB_MIXED)
		eb_norm_sim(t + 1, (const eb_t *)(t + 1), (1 << EB_WIDTH) - 1);
#endif

		l0 = l1 = RLC_CEIL(RLC_FB_BITS + 1, w);
		bn_rec_win(w0, &l0, k, w);
		bn_rec_win(w1, &l1, m, w);
		for (int i = l0; i < l1; i++) {
			w0[i] = 0;
		}
		for (int i = l1; i < l0; i++) {
			w1[i] = 0;
		}

		eb_set_infty(r);
		for (int i = RLC_MAX(l0, l1) - 1; i >= 0; i--) {
			for (int j = 0; j < w; j++) {
				eb_dbl(r, r);
			}
			eb_add(r, r, t[(w0[i] << w) + w1[i]]);
		}
		eb_norm(r, r);
	} CATCH_ANY {
		THROW(ERR_CAUGHT);
	}
	FINALLY {
		bn_free(n);
		for (int i = 0; i < (1 << w); i++) {
			eb_free(t0[i]);
			eb_free(t1[i]);
		}
		for (int i = 0; i < (1 << EB_WIDTH); i++) {
			eb_free(t[i]);
		}
	}
}

Ejemplo n.º 12

Archivo: relic_eb_util.c Proyecto: Gesine/relic

void eb_tab(eb_t *t, const eb_t p, int w) {
	int u;

#if defined(EB_PLAIN)
	if (!eb_curve_is_kbltz()) {
		if (w > 2) {
			eb_dbl(t[0], p);
#if defined(EB_MIXED)
			eb_norm(t[0], t[0]);
#endif
			eb_add(t[1], t[0], p);
			for (int i = 2; i < (1 << (w - 2)); i++) {
				eb_add(t[i], t[i - 1], t[0]);
			}
#if defined(EB_MIXED)
			eb_norm_sim(t + 1, (const eb_t *)t + 1, (1 << (w - 2)) - 1);
#endif
		}
		eb_copy(t[0], p);
	}
#endif /* EB_PLAIN */

#if defined(EB_KBLTZ)
	if (eb_curve_is_kbltz()) {
		u = (eb_curve_opt_a() == OPT_ZERO ? -1 : 1);

		/* Prepare the precomputation table. */
		for (int i = 0; i < 1 << (w - 2); i++) {
			eb_set_infty(t[i]);
			fb_set_dig(t[i]->z, 1);
			t[i]->norm = 1;
		}

#if defined(EB_MIXED)
		eb_norm(t[0], p);
#else
		eb_copy(t[0], p);
#endif

		switch (w) {
#if EB_DEPTH == 3 || EB_WIDTH ==  3
			case 3:
				eb_frb(t[1], t[0]);
				if (u == 1) {
					eb_sub(t[1], t[0], t[1]);
				} else {
					eb_add(t[1], t[0], t[1]);
				}
				break;
#endif
#if EB_DEPTH == 4 || EB_WIDTH ==  4
			case 4:
				eb_frb(t[3], t[0]);
				eb_frb(t[3], t[3]);

				eb_sub(t[1], t[3], p);
				eb_add(t[2], t[3], p);
				eb_frb(t[3], t[3]);

				if (u == 1) {
					eb_neg(t[3], t[3]);
				}
				eb_sub(t[3], t[3], p);
				break;
#endif
#if EB_DEPTH == 5 || EB_WIDTH ==  5
			case 5:
				eb_frb(t[3], t[0]);
				eb_frb(t[3], t[3]);

				eb_sub(t[1], t[3], p);
				eb_add(t[2], t[3], p);
				eb_frb(t[3], t[3]);

				eb_frb(t[7], t[3]);
				eb_sub(t[7], t[7], p);

				if (u == 1) {
					eb_neg(t[3], t[3]);
				}
				eb_sub(t[3], t[3], p);

				eb_frb(t[4], t[2]);
				eb_frb(t[4], t[4]);

				eb_neg(t[4], t[4]);
				eb_sub(t[5], t[4], p);
				eb_add(t[6], t[4], p);

				eb_frb(t[4], t[4]);
				if (u == -1) {
					eb_neg(t[4], t[4]);
				}
				eb_add(t[4], t[4], p);
				break;
#endif
#if EB_DEPTH == 6 || EB_WIDTH ==  6
			case 6:
				eb_frb(t[0], t[0]);
				eb_frb(t[0], t[0]);
				eb_neg(t[14], t[0]);

				eb_sub(t[13], t[14], p);
				eb_add(t[14], t[14], p);

				eb_frb(t[0], t[0]);
				eb_frb(t[8], t[0]);
				if (u == -1) {
					eb_neg(t[0], t[0]);
				}
				eb_sub(t[11], t[0], p);
				eb_add(t[12], t[0], p);

				eb_frb(t[0], t[12]);
				eb_frb(t[0], t[0]);
				eb_sub(t[1], t[0], p);
				eb_add(t[2], t[0], p);

				eb_frb(t[15], t[8]);
				if (u == -1) {
					eb_neg(t[15], t[15]);
				}
				eb_sub(t[15], t[15], p);

				eb_frb(t[0], t[13]);
				eb_frb(t[0], t[0]);
				eb_sub(t[5], t[0], p);
				eb_add(t[6], t[0], p);

				eb_sub(t[7], t[8], p);
				eb_add(t[8], t[8], p);

				eb_frb(t[0], t[0]);
				if (u == -1) {
					eb_neg(t[0], t[0]);
				}
				eb_sub(t[3], t[0], p);
				eb_add(t[4], t[0], p);

				eb_frb(t[0], t[1]);
				eb_frb(t[0], t[0]);

				eb_neg(t[9], t[0]);
				eb_sub(t[9], t[9], p);

				eb_frb(t[0], t[14]);
				eb_frb(t[0], t[0]);
				eb_add(t[10], t[0], p);

				eb_copy(t[0], p);
				break;
#endif
#if EB_DEPTH == 7 || EB_WIDTH ==  7
			/**
			 * Formulas from http://eprint.iacr.org/2012/519
			 */
			case 7:
				eb_frb(t[0], t[0]);
				eb_frb(t[0], t[0]);
				eb_sub(t[17], t[0], p);
				eb_add(t[18], t[0], p);
				eb_frb(t[0], t[0]);
				if (u == 1) {
					eb_neg(t[0], t[0]);
				}
				eb_sub(t[19], t[0], p);
				eb_add(t[20], t[0], p);

				eb_frb(t[0], t[19]);
				eb_frb(t[0], t[0]);
				eb_frb(t[11], t[0]);
				if (u == 1) {
					eb_neg(t[11], t[11]);
				}
				eb_add(t[12], t[11], p);
				eb_sub(t[11], t[11], p);
				eb_neg(t[0], t[0]);
				eb_sub(t[1], t[0], p);
				eb_add(t[2], t[0], p);

				eb_frb(t[0], t[17]);
				eb_frb(t[0], t[0]);
				eb_frb(t[0], t[0]);
				if (u == -1) {
					eb_neg(t[0], t[0]);
				}
				eb_sub(t[3], t[0], p);

				eb_frb(t[0], t[1]);
				eb_frb(t[0], t[0]);
				eb_add(t[9], t[0], p);
				eb_neg(t[9], t[9]);
				eb_frb(t[0], t[0]);
				if (u == -1) {
					eb_neg(t[0], t[0]);
				}
				eb_add(t[4], t[0], p);

				eb_frb(t[0], t[18]);
				eb_frb(t[0], t[0]);
				eb_sub(t[7], t[0], t[18]);
				eb_sub(t[25], t[0], p);
				eb_add(t[26], t[0], p);
				eb_frb(t[0], t[0]);
				if (u == -1) {
					eb_neg(t[0], t[0]);
				}
				eb_sub(t[27], t[0], p);
				eb_add(t[28], t[0], p);

				eb_frb(t[0], t[17]);
				eb_frb(t[0], t[0]);
				eb_add(t[8], t[0], t[18]);
				eb_neg(t[0], t[0]);
				eb_add(t[10], t[0], p);

				eb_frb(t[0], t[7]);
				eb_frb(t[0], t[0]);
				eb_sub(t[13], t[0], p);
				eb_frb(t[0], t[8]);
				eb_frb(t[0], t[0]);
				eb_neg(t[0], t[0]);
				eb_add(t[14], t[0], p);

				eb_frb(t[0], t[19]);
				eb_frb(t[0], t[0]);
				eb_add(t[15], t[0], t[17]);
				eb_add(t[16], t[0], t[18]);

				eb_frb(t[0], t[26]);
				eb_frb(t[0], t[0]);
				eb_neg(t[0], t[0]);
				eb_sub(t[5], t[0], p);
				eb_add(t[6], t[0], p);
				eb_add(t[23], t[0], t[17]);
				eb_add(t[24], t[0], t[18]);

				eb_frb(t[0], t[25]);
				eb_frb(t[0], t[0]);
				eb_sub(t[21], t[0], p);
				eb_add(t[22], t[0], p);

				eb_frb(t[0], t[20]);
				eb_frb(t[0], t[0]);
				eb_add(t[29], t[0], p);
				eb_neg(t[29], t[29]);

				eb_frb(t[0], t[27]);
				eb_frb(t[0], t[0]);
				eb_add(t[30], t[0], p);

				eb_frb(t[0], t[7]);
				eb_frb(t[0], t[0]);
				eb_add(t[31], t[0], t[17])

						eb_copy(t[0], p);
				break;
#endif
#if EB_DEPTH == 8 || EB_WIDTH ==  8
			/**
			 * Formulas from http://eprint.iacr.org/2012/519
			 */
			case 8:
				eb_frb(t[0], t[0]);
				eb_frb(t[0], t[0]);
				eb_neg(t[0], t[0]);
				eb_sub(t[45], t[0], p);
				eb_add(t[46], t[0], p);
				eb_frb(t[0], t[0]);
				if (u == 1) {
					eb_neg(t[0], t[0]);
				}
				eb_sub(t[43], t[0], p);
				eb_add(t[44], t[0], p);

				eb_frb(t[0], t[44]);
				eb_frb(t[0], t[0]);
				eb_sub(t[1], t[0], p);
				eb_add(t[2], t[0], p);
				eb_add(t[47], t[0], t[45]);
				eb_add(t[48], t[0], t[46]);

				eb_frb(t[0], t[46]);
				eb_frb(t[0], t[0]);
				eb_neg(t[0], t[0]);
				eb_sub(t[7], t[0], t[46]);
				eb_sub(t[8], t[0], t[45]);
				eb_frb(t[0], t[0]);
				if (u == -1) {
					eb_neg(t[0], t[0]);
				}
				eb_sub(t[3], t[0], p);

				eb_frb(t[0], t[1]);
				eb_frb(t[0], t[0]);
				eb_neg(t[0], t[0]);
				eb_add(t[55], t[0], t[45]);
				eb_add(t[56], t[0], t[46]);
				eb_sub(t[9], t[0], p);
				eb_add(t[10], t[0], p);
				eb_frb(t[0], t[0]);
				if (u == 1) {
					eb_neg(t[0], t[0]);
				}
				eb_add(t[4], t[0], p);

				eb_frb(t[0], t[47]);
				eb_frb(t[0], t[0]);
				eb_neg(t[0], t[0]);
				eb_sub(t[17], t[0], p);
				eb_add(t[18], t[0], p);

				eb_frb(t[0], t[8]);
				eb_frb(t[0], t[0]);
				eb_add(t[31], t[0], t[45]);
				eb_add(t[32], t[0], t[46]);
				eb_neg(t[0], t[0]);
				eb_sub(t[13], t[0], p);
				eb_add(t[14], t[0], p);
				eb_frb(t[0], t[0]);
				if (u == -1) {
					eb_neg(t[0], t[0]);
				}
				eb_sub(t[19], t[0], p);

				eb_frb(t[0], t[7]);
				eb_frb(t[0], t[0]);
				eb_frb(t[0], t[0]);
				if (u == -1) {
					eb_neg(t[0], t[0]);
				}
				eb_add(t[20], t[0], p);

				eb_frb(t[0], t[9]);
				eb_frb(t[0], t[0]);
				eb_sub(t[21], t[0], p);
				eb_add(t[22], t[0], p);

				eb_frb(t[0], t[2]);
				eb_frb(t[0], t[0]);
				eb_sub(t[25], t[0], p);
				eb_add(t[26], t[0], p);

				eb_frb(t[0], t[43]);
				eb_frb(t[0], t[0]);
				eb_neg(t[0], t[0]);
				eb_sub(t[33], t[0], p);
				eb_add(t[34], t[0], p);
				eb_frb(t[0], t[0]);
				if (u == -1) {
					eb_neg(t[0], t[0]);
				}
				eb_add(t[12], t[0], p);

				eb_frb(t[0], t[45]);
				eb_frb(t[0], t[0]);
				eb_sub(t[37], t[0], p);
				eb_add(t[38], t[0], p);
				eb_frb(t[0], t[0]);
				if (u == -1) {
					eb_neg(t[0], t[0]);
				}
				eb_sub(t[35], t[0], p);
				eb_add(t[36], t[0], p);

				eb_frb(t[0], t[38]);
				eb_frb(t[0], t[0]);
				eb_sub(t[41], t[0], p);
				eb_add(t[42], t[0], p);
				eb_neg(t[0], t[0]);
				eb_sub(t[39], t[0], t[46]);
				eb_sub(t[40], t[0], t[45]);

				eb_frb(t[0], t[37]);
				eb_frb(t[0], t[0]);
				eb_sub(t[5], t[0], p);
				eb_add(t[6], t[0], p);
				eb_frb(t[0], t[0]);
				if (u == -1) {
					eb_neg(t[0], t[0]);
				}
				eb_add(t[15], t[0], t[43]);
				eb_add(t[16], t[0], t[44]);
				eb_neg(t[0], t[0]);
				eb_sub(t[27], t[0], p);
				eb_add(t[28], t[0], p);

				eb_frb(t[0], t[36]);
				eb_frb(t[0], t[0]);
				eb_frb(t[0], t[0]);
				if (u == -1) {
					eb_neg(t[0], t[0]);
				}
				eb_sub(t[11], t[0], p);

				eb_frb(t[0], t[39]);
				eb_frb(t[0], t[0]);
				eb_add(t[0], t[0], p);
				eb_neg(t[49], t[0]);

				eb_frb(t[0], t[7]);
				eb_frb(t[0], t[0]);
				eb_neg(t[0], t[0]);
				eb_add(t[50], t[0], p);

				eb_frb(t[0], t[44]);
				eb_frb(t[0], t[0]);
				eb_frb(t[0], t[0]);
				if (u == 1) {
					eb_neg(t[0], t[0]);
				}
				eb_sub(t[51], t[0], p);
				eb_add(t[52], t[0], p);

				eb_frb(t[0], t[46]);
				eb_frb(t[0], t[0]);
				eb_neg(t[0], t[0]);
				eb_sub(t[53], t[0], p);
				eb_add(t[54], t[0], p);

				eb_frb(t[0], t[54]);
				eb_frb(t[0], t[0]);
				eb_add(t[23], t[0], t[45]);
				eb_add(t[24], t[0], t[46]);

				eb_frb(t[0], t[42]);
				eb_frb(t[0], t[0]);
				eb_sub(t[57], t[0], p);

				eb_frb(t[0], t[53]);
				eb_frb(t[0], t[0]);
				eb_neg(t[0], t[0]);
				eb_add(t[58], t[0], p);

				eb_frb(t[0], t[38]);
				eb_frb(t[0], t[0]);
				eb_frb(t[0], t[0]);
				if (u == -1) {
					eb_neg(t[0], t[0]);
				}
				eb_sub(t[59], t[0], p);
				eb_add(t[60], t[0], p);

				eb_frb(t[0], t[35]);
				eb_frb(t[0], t[0]);
				eb_sub(t[61], t[0], p);
				eb_add(t[62], t[0], p);

				eb_frb(t[0], t[47]);
				eb_frb(t[0], t[0]);
				eb_neg(t[0], t[0]);
				eb_add(t[63], t[0], t[45]);

				eb_frb(t[0], t[36]);
				eb_frb(t[0], t[0]);
				eb_neg(t[0], t[0]);
				eb_sub(t[29], t[0], p);
				eb_add(t[30], t[0], p);

				eb_copy(t[0], p);
				break;
#endif
		}
#if defined(EB_MIXED)
		if (w > 2) {
			eb_norm_sim(t + 1, (const eb_t *)t + 1, (1 << (w - 2)) - 1);
		}
#endif
	}
#endif /* EB_KBLTZ */
}

Ejemplo n.º 13

Archivo: relic_eb_curve.c Proyecto: 0x64616E69656C/supercop

void eb_curve_get_gen(eb_t g) {
	eb_copy(g, &curve_g);
}

Ejemplo n.º 14

Archivo: relic_eb_curve.c Proyecto: ekr/hacrypto

void eb_curve_get_gen(eb_t g) {
	eb_copy(g, &(core_get()->eb_g));
}