예제 #1
0
파일: poly.c 프로젝트: enascimento/supercop
poly_t * poly_syndrome_init(poly_t generator, gf_t *support, int n)
{
    int i,j,t;
    gf_t a;
    poly_t * F;

    F = malloc(n * sizeof (poly_t));
    t = poly_deg(generator);

    //g(z)=g_t+g_(t-1).z^(t-1)+......+g_1.z+g_0
    //f(z)=f_(t-1).z^(t-1)+......+f_1.z+f_0

    for(j=0; j<n; j++)
    {
        F[j] = poly_alloc(t-1);
        poly_set_coeff(F[j],t-1,gf_unit());
        for(i=t-2; i>=0; i--)
        {
            poly_set_coeff(F[j],i,gf_add(poly_coeff(generator,i+1),
                                         gf_mul(support[j],poly_coeff(F[j],i+1))));
        }
        a = gf_add(poly_coeff(generator,0),gf_mul(support[j],poly_coeff(F[j],0)));
        for(i=0; i<t; i++)
        {
            poly_set_coeff(F[j],i, gf_div(poly_coeff(F[j],i),a));
        }
    }

    return F;
}
예제 #2
0
static void pt_to_pniels(pniels_t b, const curve448_point_t a)
{
    gf_sub(b->n->a, a->y, a->x);
    gf_add(b->n->b, a->x, a->y);
    gf_mulw(b->n->c, a->t, 2 * TWISTED_D);
    gf_add(b->z, a->z, a->z);
}
예제 #3
0
static void niels_to_pt(curve448_point_t e, const niels_t n)
{
    gf_add(e->y, n->b, n->a);
    gf_sub(e->x, n->b, n->a);
    gf_mul(e->t, e->y, e->x);
    gf_copy(e->z, ONE);
}
예제 #4
0
파일: ec_curve.c 프로젝트: geocar/cexec
void ec_sub (ec_point *p, const ec_point *r)
	/* sets p := p - r */
{
	ec_point t;

	gf_copy (t.x, r->x);
	gf_add  (t.y, r->x, r->y);
	ec_add (p, &t);
} /* ec_sub */
예제 #5
0
파일: poly.c 프로젝트: enascimento/supercop
// p = p * x mod g
// p de degré <= deg(g)-1
void poly_shiftmod(poly_t p, poly_t g) {
    int i, t;
    gf_t a;

    t = poly_deg(g);
    a = gf_div(p->coeff[t-1], g->coeff[t]);
    for (i = t - 1; i > 0; --i)
        p->coeff[i] = gf_add(p->coeff[i - 1], gf_mul(a, g->coeff[i]));
    p->coeff[0] = gf_mul(a, g->coeff[0]);
}
예제 #6
0
파일: ec_curve.c 프로젝트: geocar/cexec
int ec_calcy (ec_point *p, int ybit)
	/* given the x coordinate of p, evaluate y such that y^2 + x*y = x^3 + EC_B */
{
	gf_point a, b, t;

	b[0] = 1; b[1] = EC_B;
	if (p->x[0] == 0) {
		/* elliptic equation reduces to y^2 = EC_B: */
		gf_squareroot (p->y, EC_B);
		return 1;
	}
	/* evaluate alpha = x^3 + b = (x^2)*x + EC_B: */
	gf_square (t, p->x); /* keep t = x^2 for beta evaluation */
	gf_multiply (a, t, p->x);
	gf_add (a, a, b); /* now a == alpha */
	if (a[0] == 0) {
		p->y[0] = 0;
		/* destroy potentially sensitive data: */
		gf_clear (a); gf_clear (t);
		return 1;
	}
	/* evaluate beta = alpha/x^2 = x + EC_B/x^2 */
	gf_smalldiv (t, EC_B);
	gf_invert (a, t);
	gf_add (a, p->x, a); /* now a == beta */
	/* check if a solution exists: */
	if (gf_trace (a) != 0) {
		/* destroy potentially sensitive data: */
		gf_clear (a); gf_clear (t);
		return 0; /* no solution */
	}
	/* solve equation t^2 + t + beta = 0 so that gf_ybit(t) == ybit: */
	gf_quadsolve (t, a);
	if (gf_ybit (t) != ybit) {
		t[1] ^= 1;
	}
	/* compute y = x*t: */
	gf_multiply (p->y, p->x, t);
	/* destroy potentially sensitive data: */
	gf_clear (a); gf_clear (t);
	return 1;
} /* ec_calcy */
예제 #7
0
파일: ec_curve.c 프로젝트: geocar/cexec
void ec_double (ec_point *p)
	/* sets p := 2*p */
{
	gf_point lambda, t1, t2;

	/* evaluate lambda = x + y/x: */
	gf_invert (t1, p->x);
	gf_multiply (lambda, p->y, t1);
	gf_add (lambda, lambda, p->x);
	/* evaluate x3 = lambda^2 + lambda: */
	gf_square (t1, lambda);
	gf_add (t1, t1, lambda); /* now t1 = x3 */
	/* evaluate y3 = x^2 + lambda*x3 + x3: */
	gf_square (p->y, p->x);
	gf_multiply (t2, lambda, t1);
	gf_add (p->y, p->y, t2);
	gf_add (p->y, p->y, t1);
	/* deposit the value of x3: */
	gf_copy (p->x, t1);
} /* ec_double */
예제 #8
0
static void pniels_to_pt(curve448_point_t e, const pniels_t d)
{
    gf eu;

    gf_add(eu, d->n->b, d->n->a);
    gf_sub(e->y, d->n->b, d->n->a);
    gf_mul(e->t, e->y, eu);
    gf_mul(e->x, d->z, e->y);
    gf_mul(e->y, d->z, eu);
    gf_sqr(e->z, d->z);
}
예제 #9
0
파일: poly.c 프로젝트: enascimento/supercop
gf_t poly_eval_aux(gf_t * coeff, gf_t a, int d) {
    gf_t b;

    b = coeff[d--];
    for (; d >= 0; --d)
        if (b != gf_zero())
            b = gf_add(gf_mul(b, a), coeff[d]);
        else
            b = coeff[d];
    return b;
}
예제 #10
0
파일: gf.c 프로젝트: nimrody/rs
gf gf_poly(gf p[], int n, gf a)
{
    int i = n-1;
    gf acc = 0;

    while(i>=0)  {
        acc = gf_mul(acc, a);
        acc = gf_add(acc, p[i]);
        i--;
    }

    return acc;
}
예제 #11
0
// C=AB
// A: nxp
// B: pxm
// C: nxm
void matrix_mul(unsigned char *A, unsigned char *B, unsigned char *C, int n, int p, int m)
{
	int i;
	int j;
	int k;
	for(i=0; i<n; i++)
	{
		for(j=0; j<m; j++)
		{
			for(k=0; k<p; k++)
			{
				C[i*m+j] = gf_add(C[i*m+j], gf_mul(A[i*p+k],B[k*m+j]));
			}
		}
	}
}
예제 #12
0
c448_bool_t curve448_point_valid(const curve448_point_t p)
{
    mask_t out;
    gf a, b, c;

    gf_mul(a, p->x, p->y);
    gf_mul(b, p->z, p->t);
    out = gf_eq(a, b);
    gf_sqr(a, p->x);
    gf_sqr(b, p->y);
    gf_sub(a, b, a);
    gf_sqr(b, p->t);
    gf_mulw(c, b, TWISTED_D);
    gf_sqr(b, p->z);
    gf_add(b, b, c);
    out &= gf_eq(a, b);
    out &= ~gf_eq(p->z, ZERO);
    return mask_to_bool(out);
}
예제 #13
0
파일: ec_curve.c 프로젝트: geocar/cexec
void ec_add (ec_point *p, const ec_point *q)
	/* sets p := p + q */
{
	gf_point lambda, t, tx, ty, x3;

	/* first check if there is indeed work to do (q != 0): */
	if (q->x[0] != 0 || q->y[0] != 0) {
		if (p->x[0] != 0 || p->y[0] != 0) {
			/* p != 0 and q != 0 */
			if (gf_equal (p->x, q->x)) {
				/* either p == q or p == -q: */
				if (gf_equal (p->y, q->y)) {
					/* points are equal; double p: */
					ec_double (p);
				} else {
					/* must be inverse: result is zero */
					/* (should assert that q->y = p->x + p->y) */
					p->x[0] = p->y[0] = 0;
				}
			} else {
				/* p != 0, q != 0, p != q, p != -q */
				/* evaluate lambda = (y1 + y2)/(x1 + x2): */
				gf_add (ty, p->y, q->y);
				gf_add (tx, p->x, q->x);
				gf_invert (t, tx);
				gf_multiply (lambda, ty, t);
				/* evaluate x3 = lambda^2 + lambda + x1 + x2: */
				gf_square (x3, lambda);
				gf_add (x3, x3, lambda);
				gf_add (x3, x3, tx);
				/* evaluate y3 = lambda*(x1 + x3) + x3 + y1: */
				gf_add (tx, p->x, x3);
				gf_multiply (t, lambda, tx);
				gf_add (t, t, x3);
				gf_add (p->y, t, p->y);
				/* deposit the value of x3: */
				gf_copy (p->x, x3);
			}
		} else {
			/* just copy q into p: */
			gf_copy (p->x, q->x);
			gf_copy (p->y, q->y);
		}
	}
} /* ec_add */
예제 #14
0
void test_distributive_law() {
    suite("distributive law");
    SOME3( test(gf_mult(gf_add(a,b), c) == gf_add(gf_mult(a,c), gf_mult(b,c))); )
}
예제 #15
0
uint8_t gf_sub(uint8_t a, uint8_t b)
{
    return gf_add(a, b);
}
예제 #16
0
GFn_el_t & GFn_el_t::operator += (unsigned int _a) {

    comp[0] = gf_add(prime, comp[0], _a%prime);

    return *this;
}
예제 #17
0
GFn_el_t & GFn_el_t::operator += (int _a) {

    comp[0] = gf_add(prime, comp[0], gf_int(prime, _a));

    return *this;
}
예제 #18
0
파일: ec_curve.c 프로젝트: geocar/cexec
void ec_negate (ec_point *p)
	/* sets p := -p */
{
	gf_add (p->y, p->x, p->y);
} /* ec_negate */
예제 #19
0
void test_add_associates() {
    suite("addition associates");
    SOME3( test(gf_add(gf_add(a,b), c) == gf_add(a, gf_add(b,c))); )
}
예제 #20
0
void test_add_commutes() {
    suite("addition commutes");
    ALL2( test(gf_add(a,b) == gf_add(b,a)); )
}