Beispiel #1
0
/* FP12 full multiplication w=w*y */
void FP12_mul(FP12 *w,FP12 *y)
{
	FP4 z0,z1,z2,z3,t0,t1;

	FP4_mul(&z0,&(w->a),&(y->a));
	FP4_mul(&z2,&(w->b),&(y->b));  //

	FP4_add(&t0,&(w->a),&(w->b));
	FP4_add(&t1,&(y->a),&(y->b));  //
	FP4_mul(&z1,&t0,&t1);  
	FP4_add(&t0,&(w->b),&(w->c));
	
	FP4_add(&t1,&(y->b),&(y->c));  //
	FP4_mul(&z3,&t0,&t1);

	FP4_neg(&t0,&z0);
	FP4_neg(&t1,&z2);

	FP4_add(&z1,&z1,&t0);   // z1=z1-z0
#if CHUNK<64	
	FP4_norm(&z1);
#endif
	FP4_add(&(w->b),&z1,&t1);    
// z1=z1-z2
	FP4_add(&z3,&z3,&t1);        // z3=z3-z2
	FP4_add(&z2,&z2,&t0);        // z2=z2-z0

	FP4_add(&t0,&(w->a),&(w->c));
	
	FP4_add(&t1,&(y->a),&(y->c));
	FP4_mul(&t0,&t1,&t0);
	FP4_add(&z2,&z2,&t0);

	FP4_mul(&t0,&(w->c),&(y->c));
	FP4_neg(&t1,&t0);
#if CHUNK<64
	FP4_norm(&z2);
	FP4_norm(&z3);
	FP4_norm(&(w->b));
#endif
	FP4_add(&(w->c),&z2,&t1);
	FP4_add(&z3,&z3,&t1); 
	FP4_times_i(&t0); 
	FP4_add(&(w->b),&(w->b),&t0);
	
	FP4_times_i(&z3);
	FP4_add(&(w->a),&z0,&z3);

	FP12_norm(w);
}
Beispiel #2
0
/* SU= 600 */
void FP12_usqr(FP12 *w,FP12 *x)
{
	FP4 A,B,C,D;

	FP4_copy(&A,&(x->a));

	FP4_sqr(&(w->a),&(x->a));
	FP4_add(&D,&(w->a),&(w->a)); 
	FP4_add(&(w->a),&D,&(w->a)); 

#if CHUNK<64
	FP4_norm(&(w->a));
#endif

	FP4_nconj(&A,&A);

	FP4_add(&A,&A,&A); 
	FP4_add(&(w->a),&(w->a),&A); 
	FP4_sqr(&B,&(x->c));
	FP4_times_i(&B);

	FP4_add(&D,&B,&B); 
	FP4_add(&B,&B,&D); 
#if CHUNK<64
	FP4_norm(&B); 
#endif
	FP4_sqr(&C,&(x->b));

	FP4_add(&D,&C,&C);
	FP4_add(&C,&C,&D);

#if CHUNK<64
	FP4_norm(&C); 
#endif
	FP4_conj(&(w->b),&(x->b));
	FP4_add(&(w->b),&(w->b),&(w->b)); 
	FP4_nconj(&(w->c),&(x->c));

	FP4_add(&(w->c),&(w->c),&(w->c)); 
	FP4_add(&(w->b),&B,&(w->b));
	FP4_add(&(w->c),&C,&(w->c));
	FP12_reduce(w);	    /* reduce here as in pow function repeated squarings would trigger multiple reductions */

}
Beispiel #3
0
/* SU= 600 */
void FP12_sqr(FP12 *w,FP12 *x)
{
/* Use Chung-Hasan SQR2 method from http://cacr.uwaterloo.ca/techreports/2006/cacr2006-24.pdf */

	FP4 A,B,C,D;

	FP4_sqr(&A,&(x->a));
	FP4_mul(&B,&(x->b),&(x->c));
	FP4_add(&B,&B,&B);  
	FP4_sqr(&C,&(x->c));
	FP4_mul(&D,&(x->a),&(x->b));
	FP4_add(&D,&D,&D); 
	FP4_add(&(w->c),&(x->a),&(x->c));
	FP4_add(&(w->c),&(x->b),&(w->c));

	FP4_sqr(&(w->c),&(w->c));

	FP4_copy(&(w->a),&A);

	FP4_add(&A,&A,&B);
#if CHUNK<64
	FP4_norm(&A);
#endif
	FP4_add(&A,&A,&C);
	FP4_add(&A,&A,&D);
#if CHUNK<64
	FP4_norm(&A);
#endif
	FP4_neg(&A,&A);
	FP4_times_i(&B);
	FP4_times_i(&C);

	FP4_add(&(w->a),&(w->a),&B);
	FP4_add(&(w->b),&C,&D);
	FP4_add(&(w->c),&(w->c),&A);

	FP12_norm(w);   
}
/* XTR xtr_a function */
void FP4_xtr_A(FP4 *r,FP4 *w,FP4 *x,FP4 *y,FP4 *z)
{
	FP4 t1,t2;

	FP4_copy(r,x);

	FP4_sub(&t1,w,y);

	FP4_pmul(&t1,&t1,&(r->a));
	FP4_add(&t2,w,y);
	FP4_pmul(&t2,&t2,&(r->b));
	FP4_times_i(&t2);

	FP4_add(r,&t1,&t2);
	FP4_add(r,r,z);

	FP4_norm(r);
}
/* SU= 312 */
void FP4_mul(FP4 *w,FP4 *x,FP4 *y)
{

	FP2 t1,t2,t3,t4;
	FP2_mul(&t1,&(x->a),&(y->a)); /* norms x */
	FP2_mul(&t2,&(x->b),&(y->b)); /* and y */
	FP2_add(&t3,&(y->b),&(y->a)); 
	FP2_add(&t4,&(x->b),&(x->a)); 


	FP2_mul(&t4,&t4,&t3); /* (xa+xb)(ya+yb) */
	FP2_sub(&t4,&t4,&t1);    
#if CHUNK<64
	FP2_norm(&t4);
#endif
	FP2_sub(&(w->b),&t4,&t2); 
	FP2_mul_ip(&t2);
	FP2_add(&(w->a),&t2,&t1);

	FP4_norm(w);
}
/* SU= 200 */
void FP4_times_i(FP4 *w)
{
	BIG z;
	FP2 s,t;
#if CHUNK<64
	FP4_norm(w);
#endif
	FP2_copy(&t,&(w->b));

	FP2_copy(&s,&t);

	BIG_copy(z,s.a);
	FP_neg(s.a,s.b);
	BIG_copy(s.b,z);

	FP2_add(&t,&t,&s);
#if CHUNK<64
	FP2_norm(&t);
#endif
	FP2_copy(&(w->b),&(w->a));
	FP2_copy(&(w->a),&t);
}
/* SU= 232 */
void FP4_sqr(FP4 *w,FP4 *x)
{
	FP2 t1,t2,t3;
 
	FP2_mul(&t3,&(x->a),&(x->b)); /* norms x */
	FP2_copy(&t2,&(x->b));
	FP2_add(&t1,&(x->a),&(x->b)); 
	FP2_mul_ip(&t2); 

	FP2_add(&t2,&(x->a),&t2); 

	FP2_mul(&(w->a),&t1,&t2);

	FP2_copy(&t2,&t3);   
	FP2_mul_ip(&t2);         

	FP2_add(&t2,&t2,&t3); 

	FP2_neg(&t2,&t2);         
	FP2_add(&(w->a),&(w->a),&t2);  /* a=(a+b)(a+i^2.b)-i^2.ab-ab = a*a+ib*ib */
	FP2_add(&(w->b),&t3,&t3);  /* b=2ab */

	FP4_norm(w);
}
Beispiel #8
0
/* normalise all components of w */
void FP12_norm(FP12 *w)
{
	 FP4_norm(&(w->a));
	 FP4_norm(&(w->b));
	 FP4_norm(&(w->c));
}