cleaning up some files by getting rid of them when they're unnecessary, others refactoring to be more appropriate (and use better code)

bgn2/src/Bipoint.cpp

@@ -1,204 +1,130 @@
 #include "Bipoint.hpp"
 
-
-void Bipoint<curvepoint_fp_t>::print() const
+Bipoint<curvepoint_fp_t>::Bipoint()
 {
-	curvepoint_fp_print(stdout,point[0]);
-	jump;
-	curvepoint_fp_print(stdout,point[1]);
-	JUMP;
+	curvepoint_fp_setneutral(point[0]);
+	curvepoint_fp_setneutral(point[1]);
 }
 
-void Bipoint<twistpoint_fp2_t>::print() const
+Bipoint<twistpoint_fp2_t>::Bipoint()
 {
-	twistpoint_fp2_print(stdout,point[0]);
-	jump;
-	twistpoint_fp2_print(stdout,point[1]);	
-	JUMP;
+	twistpoint_fp2_setneutral(point[0]);
+	twistpoint_fp2_setneutral(point[1]);
 }
 
-Bipoint<curvepoint_fp_t> Bipoint<curvepoint_fp_t>::operator+(Bipoint<curvepoint_fp_t> b)
+Bipoint<curvepoint_fp_t>::Bipoint(curvepoint_fp_t p1, curvepoint_fp_t p2)
 {
-	Bipoint  <curvepoint_fp_t> rop;
-	if (*this==b) //l'addition a+b dans la lib 666 est mal défini si a=b, il faut distinguer les cas
-	{
-		curvepoint_fp_double(rop[0],point[0]);
-		curvepoint_fp_double(rop[1],point[1]);		
-	}
-	else
-	{
-		curvepoint_fp_add_vartime(rop[0],point[0],b.point[0]);
-		curvepoint_fp_add_vartime(rop[1],point[1],b.point[1]);
-	}
-	return rop;
+	curvepoint_fp_set(point[0], p1);
+	curvepoint_fp_set(point[1], p2);
 }
 
-
-Bipoint<twistpoint_fp2_t> Bipoint<twistpoint_fp2_t>::operator+(Bipoint<twistpoint_fp2_t> b)
+Bipoint<twistpoint_fp2_t>::Bipoint(twistpoint_fp2_t p1, twistpoint_fp2_t p2)
 {
-	Bipoint  <twistpoint_fp2_t> rop;
-	if (*this==b)
-	{
-		twistpoint_fp2_double(rop[0],point[0]);
-		twistpoint_fp2_double(rop[1],point[1]);		
-	}
-	else
-	{
-		twistpoint_fp2_add_vartime(rop[0],point[0],b.point[0]);
-		twistpoint_fp2_add_vartime(rop[1],point[1],b.point[1]);
-	}
-	return rop;
+	twistpoint_fp2_set(point[0], p1);
+	twistpoint_fp2_set(point[1], p2);
 }
 
-bool Bipoint<curvepoint_fp_t>::operator==(Bipoint<curvepoint_fp_t> b)
+curvepoint_fp_t& Bipoint<curvepoint_fp_t>::operator[](int n)
 {
-	bool rop;
-
-	
-	if(fpe_iseq(point[0]->m_x,b[0]->m_x) && fpe_iseq(point[0]->m_y,b[0]->m_y) && fpe_iseq(point[0]->m_z,b[0]->m_z) && fpe_iseq(point[1]->m_x,b[1]->m_x) && fpe_iseq(point[1]->m_y,b[1]->m_y) && fpe_iseq(point[1]->m_z,b[1]->m_z)) 
-	{
-		rop=true;
-	}
-	else
-	{
-		rop=false;
-	}
-	return rop;
+	return point[n];
 }
 
-
-bool Bipoint<twistpoint_fp2_t>::operator==(Bipoint<twistpoint_fp2_t> b)
+twistpoint_fp2_t& Bipoint<twistpoint_fp2_t>::operator[](int n)
 {
-	bool rop;
-
-	
-	if(fp2e_iseq(point[0]->m_x,b[0]->m_x) && fp2e_iseq(point[0]->m_y,b[0]->m_y) && fp2e_iseq(point[0]->m_z,b[0]->m_z) && fp2e_iseq(point[1]->m_x,b[1]->m_x) && fp2e_iseq(point[1]->m_y,b[1]->m_y) && fp2e_iseq(point[1]->m_z,b[1]->m_z)) 
-	{
-		rop=true;
-	}
-	else
-	{
-		rop=false;
-	}
-	return rop;
+	return point[n];
 }
 
-void Bipoint<curvepoint_fp_t>::makeaffine()
+const curvepoint_fp_t& Bipoint<curvepoint_fp_t>::operator[](int n) const
 {
-	curvepoint_fp_makeaffine(point[0]);
-	curvepoint_fp_makeaffine(point[1]);
+	return point[n];
 }
 
-void Bipoint<twistpoint_fp2_t>::makeaffine()
+const twistpoint_fp2_t& Bipoint<twistpoint_fp2_t>::operator[](int n) const
 {
-	twistpoint_fp2_makeaffine(point[0]);
-	twistpoint_fp2_makeaffine(point[1]);
+	return point[n];
 }
 
-void Bipoint<twistpoint_fp2_t>::scalarmult_vartime(Bipoint<twistpoint_fp2_t> op, scalar_t s)
+Bipoint<curvepoint_fp_t> Bipoint<curvepoint_fp_t>::operator+(const Bipoint<curvepoint_fp_t>& b) const
 {
-	twistpoint_fp2_t a,b;
-	twistpoint_fp2_scalarmult_vartime(a, op[0],s);
-	twistpoint_fp2_scalarmult_vartime(b, op[1],s);
-	set_point(a,0);
-	set_point(b,1);	
-}
+	Bipoint<curvepoint_fp_t> retval;
 
-void Bipoint<curvepoint_fp_t>::scalarmult_vartime(Bipoint<curvepoint_fp_t> op, scalar_t s) 
-//pb cannot call member function blabla without object --> sol Bipoint<curvepoint_fp_t>::
-{
-	curvepoint_fp_t a,b;
-	//cout << RED << "affichage de op[0] " << RESET << endl;
-	//curvepoint_fp_print(stdout,op[0]);
-	//jump;
-	//cout << RED "affichage de op[1] " << RESET << endl;
-	//curvepoint_fp_print(stdout,op[1]);
-	//JUMP;
-	curvepoint_fp_scalarmult_vartime(a, op[0],s);
-	curvepoint_fp_scalarmult_vartime(b, op[1],s);
-	//cout << RED << "affichage du curvepoint u1[0] " << RESET << endl;
-	//curvepoint_fp_print(stdout,a);
-	//jump;
-	//cout << RED "affichage du curvepoint u1[1]" << RESET << endl;
-	//curvepoint_fp_print(stdout,b);
-	//JUMP;
-	set_point(a,0);
-	set_point(b,1);
-}
+	curvepoint_fp_add_vartime(retval[0], point[0], b.point[0]);
+	curvepoint_fp_add_vartime(retval[1], point[1], b.point[1]);
 
-curvepoint_fp_t& Bipoint<curvepoint_fp_t>::operator[](int n)
-{
-	return point[n];
+	return retval;
 }
 
-twistpoint_fp2_t& Bipoint<twistpoint_fp2_t>::operator[](int n)
+Bipoint<twistpoint_fp2_t> Bipoint<twistpoint_fp2_t>::operator+(const Bipoint<twistpoint_fp2_t>& b) const
 {
-	return point[n];
-}
+	Bipoint<twistpoint_fp2_t> retval;
 
+	twistpoint_fp2_add_vartime(retval[0], point[0], b.point[0]);
+	twistpoint_fp2_add_vartime(retval[1], point[1], b.point[1]);
 
-Bipoint<curvepoint_fp_t>::Bipoint()
-{
-	curvepoint_fp_setneutral(point[0]);
-	curvepoint_fp_setneutral(point[1]);
+	return retval;
 }
 
-Bipoint<twistpoint_fp2_t>::Bipoint()
+Bipoint<curvepoint_fp_t> Bipoint<curvepoint_fp_t>::operator*(const scalar_t& mult) const
 {
-	twistpoint_fp2_setneutral(point[0]);
-	twistpoint_fp2_setneutral(point[1]);
-}
+	Bipoint<curvepoint_fp_t> retval;
 
-Bipoint<curvepoint_fp_t>::Bipoint(curvepoint_fp_t p1,curvepoint_fp_t p2)
-{
-	curvepoint_fp_set(point[0],p1);
-	curvepoint_fp_set(point[1],p2);
-}
+	curvepoint_fp_scalarmult_vartime(retval[0], point[0], mult);
+	curvepoint_fp_scalarmult_vartime(retval[1], point[1], mult);
 
-Bipoint<twistpoint_fp2_t>::Bipoint(twistpoint_fp2_t p1,twistpoint_fp2_t p2)
-{
-	twistpoint_fp2_set(point[0],p1);
-	twistpoint_fp2_set(point[1],p2);
+	return retval;
 }
 
-void Bipoint<curvepoint_fp_t>::set_point(curvepoint_fp_t element,int numpoint)
+Bipoint<twistpoint_fp2_t> Bipoint<twistpoint_fp2_t>::operator*(const scalar_t& mult) const
 {
-	curvepoint_fp_set(point[numpoint],element);
-}
+	Bipoint<twistpoint_fp2_t> retval;
 
-void Bipoint<twistpoint_fp2_t>::set_point(twistpoint_fp2_t element,int numpoint)
-{
-	twistpoint_fp2_set(point[numpoint],element);
-}
+	twistpoint_fp2_scalarmult_vartime(retval[0], point[0], mult);
+	twistpoint_fp2_scalarmult_vartime(retval[1], point[1], mult);
 
-void Bipoint<fpe_t>::set_coordonnee(fpe_t element,int numcoord)
-{
-	fpe_set(coordonnee[numcoord],element);
+	return retval;
 }
 
-void Bipoint<fp2e_t>::set_coordonnee(fp2e_t element,int numcoord)
+bool Bipoint<curvepoint_fp_t>::operator==(const Bipoint<curvepoint_fp_t>& b) const
 {
-	fp2e_set(coordonnee[numcoord],element);
-}
+	bool retval = fpe_iseq(point[0]->m_x, b[0]->m_x);
+	retval &&= fpe_iseq(point[0]->m_y, b[0]->m_y); 
+	retval &&= fpe_iseq(point[0]->m_z, b[0]->m_z);
+	retval &&= fpe_iseq(point[1]->m_x, b[1]->m_x); 
+	retval &&= fpe_iseq(point[1]->m_y, b[1]->m_y);
+	retval &&= fpe_iseq(point[1]->m_z, b[1]->m_z); 
 
-void Bipoint<curvepoint_fp_t>::print(int numpoint) const
-{
-	curvepoint_fp_print(stdout,point[numpoint]);
-	JUMP;
+	return retval;
 }
 
-void Bipoint<twistpoint_fp2_t>::print(int numpoint) const
+
+bool Bipoint<twistpoint_fp2_t>::operator==(const Bipoint<twistpoint_fp2_t>& b) const
 {
-	twistpoint_fp2_print(stdout,point[numpoint]);
-	JUMP;
+	bool retval = fp2e_iseq(point[0]->m_x, b[0]->m_x);
+	retval &&= fp2e_iseq(point[0]->m_y, b[0]->m_y); 
+	retval &&= fp2e_iseq(point[0]->m_z, b[0]->m_z);
+	retval &&= fp2e_iseq(point[1]->m_x, b[1]->m_x); 
+	retval &&= fp2e_iseq(point[1]->m_y, b[1]->m_y);
+	retval &&= fp2e_iseq(point[1]->m_z, b[1]->m_z); 
+
+	return retval;
 }
 
-void Bipoint<fpe_t>::get_coordonnee(int numcoord) const
+Bipoint<curvepoint_fp_t> Bipoint<curvepoint_fp_t>::multBy2() const
 {
-	fpe_print(stdout,coordonnee[numcoord]);
+	Bipoint<curvepoint_fp_t> retval;
+
+	curvepoint_fp_double(retval[0], point[0]);
+	curvepoint_fp_double(retval[1], point[1]);
+
+	return retval;
 }
 
-void Bipoint<fp2e_t>::get_coordonnee(int numcoord) const
+Bipoint<twistpoint_fp2_t> Bipoint<twistpoint_fp2_t>::multBy2() const
 {
-	fp2e_print(stdout,coordonnee[numcoord]);
+	Bipoint<twistpoint_fp2_t> retval;
+
+	twistpoint_fp2_double(retval[0], point[0]);
+	twistpoint_fp2_double(retval[1], point[1]);
+
+	return retval;
 }

bgn2/src/Bipoint.hpp

@@ -1,10 +1,6 @@
 #ifndef __BIPOINT_HPP
-
 #define __BIPOINT_HPP
 
-
-
-//#include "bgn.hpp"
 #include "mydouble.h" 
 extern "C" {
 #include "fpe.h"
@@ -14,80 +10,54 @@ extern "C" {
 #include "fp2e.h"	
 }
 #include "twistpoint_fp2.h"
-#include "zout.hpp"
 
+/* It doesn't actually make sense to instantiate this generally;
+ * we'll specify for each real type directly.
+ * We still have to make something here, though, so it's empty. */
 template <typename T>
 class Bipoint
-{}; //il faut une définition de la classe pour un type quelconque, on choisit de rien mettre dedans, on veut traiter seulement des cas particuliers
+{};
 
 template <>
-class Bipoint  <curvepoint_fp_t> //spécialisation pour curvepoint_fp_t
+class Bipoint<curvepoint_fp_t>
 {
-	
 	public:
-	//Bipoint() = default; 
-	Bipoint();
-	Bipoint(curvepoint_fp_t p1,curvepoint_fp_t p2);
-	//void bipoint_curvepoint_fp_init_set(Bipoint<curvepoint_fp_t> rop, const Bipoint<curvepoint_fp_t> op);
-	void set_point(curvepoint_fp_t, int numpoint); 
-	void print(int numpoint) const;	
-	curvepoint_fp_t& operator[](int n); //la valeur de retour doit être une référence.
-	Bipoint  <curvepoint_fp_t> operator+(Bipoint  <curvepoint_fp_t> b); 
-	bool operator==(Bipoint<curvepoint_fp_t> b);
-	void makeaffine();
-	void scalarmult_vartime(Bipoint<curvepoint_fp_t> op, scalar_t s);
-	void print() const;
+		Bipoint();
+		Bipoint(curvepoint_fp_t p1, curvepoint_fp_t p2);
+
+		curvepoint_fp_t& operator[](int n);
+		const curvepoint_fp_t& operator[](int n) const;
+
+		Bipoint<curvepoint_fp_t> operator+(const Bipoint<curvepoint_fp_t>& b) const;
+		Bipoint<curvepoint_fp_t> operator*(const scalar_t& mult) const;
+
+		bool operator==(const Bipoint<curvepoint_fp_t>& b) const;
+
+		Bipoint<curvepoint_fp_t> multBy2() const;
 	
 	private:
-	curvepoint_fp_t point[2];	
+		curvepoint_fp_t point[2];	
 };
 
 template <>
-class Bipoint  <twistpoint_fp2_t> //spécialisation pour twistpoint_fp2_t
+class Bipoint<twistpoint_fp2_t>
 {
-	
 	public:
-	Bipoint(); 
-	Bipoint(twistpoint_fp2_t p1,twistpoint_fp2_t p2);	
-	void set_point(twistpoint_fp2_t, int numpoint); 
-	void print(int numpoint) const;
-	twistpoint_fp2_t& operator[](int n);
-	Bipoint<twistpoint_fp2_t> operator+(Bipoint<twistpoint_fp2_t> b);
-	bool operator==(Bipoint<twistpoint_fp2_t> b);
-	void makeaffine();	
-	void scalarmult_vartime(Bipoint<twistpoint_fp2_t> op, scalar_t s);
-	void print() const;
-	
-	private:
-	twistpoint_fp2_t point[2];	
-};
+		Bipoint(); 
+		Bipoint(twistpoint_fp2_t p1,twistpoint_fp2_t p2);	
 
+		twistpoint_fp2_t& operator[](int n);
+		const twistpoint_fp2_t& operator[](int n) const;
 
-template <>
-class Bipoint  <fpe_t> //spécialisation pour fpe_t
-{
-	
-	public:
-	
-	void set_coordonnee(fpe_t, int numcoord); 
-	void get_coordonnee(int numcoord) const;
-	
-	private:
-	fpe_t coordonnee[2];	
-};
+		Bipoint<twistpoint_fp2_t> operator+(const Bipoint<twistpoint_fp2_t>& b) const;
+		Bipoint<twistpoint_fp2_t> operator*(const scalar_t& mult) const;
 
+		bool operator==(const Bipoint<twistpoint_fp2_t>& b) const;
 
-template <>
-class Bipoint  <fp2e_t> //spécialisation pour fp2e_t
-{
-	
-	public:
-	
-	void set_coordonnee(fp2e_t, int numcoord); 
-	void get_coordonnee(int numcoord) const;
+		Bipoint<twistpoint_fp2_t> multBy2() const;
 	
 	private:
-	fp2e_t coordonnee[2];	
+		twistpoint_fp2_t point[2];	
 };
 
 #endif

bgn2/src/Fp.cpp

@@ -1,66 +1,217 @@
 #include "Fp.hpp"
-#include "fpe2scalar.hpp" //problem : Fp does not name a type --> solution :  include fpe2scalar.hpp only in the cpp files
-
-	Fp Fp::operator-()
-	{
-		Fp rop;
-		fpe_t temp;
-		fpe_neg(temp,fpe_rep);
-		rop.set(temp);
-		return rop;		
-	}
-	
-	Fp Fp::operator* (Fp b)
-	{
-		Fp rop;
-		fpe_t temp;
-		fpe_mul(temp,fpe_rep,b.fpe_rep); //b.fpe_rep on peut accéder au champ fpe_rep ici bien qu'il soit privé
-		fpe_print(stdout,temp);
-		zout(fpe2mpz(temp));
-		rop.set(temp);
-		zout(scalar2mpz(rop.scalar()));
-		return rop;
-	}
-
-	void Fp::set(fpe_t fpe)
-	{
-		//abc;
-		//zout(scalar_rep[0],scalar_rep[1],scalar_rep[2],scalar_rep[3]);
-		fpe_set(fpe_rep,fpe);
-		fpe2scalar(scalar_rep,fpe_rep);	
-		//zout(scalar_rep[0],scalar_rep[1],scalar_rep[2],scalar_rep[3]);
-		//xyz;
-	}
-	void Fp::set_random()
-	{
-		fpe_setrandom(fpe_rep);
-		fpe2scalar(scalar_rep,fpe_rep);	
-	}
-	void Fp::set_ad_minus_bc(Fp b,Fp c,Fp d) // i1*l1 - j1*k1=1  on calcule i1 = (j1*k1 + 1)*l1^(-1)
-	{
-		fpe_ad_minus_bc(fpe_rep,b.fpe_rep,c.fpe_rep,d.fpe_rep);
-		fpe2scalar(scalar_rep,fpe_rep);	
-		
-		/** bloc pour vérifier si ad-bc=1 en représentation mpz_class,   **/
-		//extern const double bn_v;
-		//mpz_class bn_u, bn_p;
-		//zout(bn_v);
-		//bn_u=1;//pow(bn_v,3); ne marche pas ni bn_v*bn_v*bn_v moral: d'abord initialiser pour travailler avec des mpz_class plutôt que des doubles
-		//for (int i =0;i<3;i++)
-		//{
-			//bn_u*=bn_v;
-		//}
-		//bn_p=36 * bn_u * bn_u * bn_u * bn_u+36 * bn_u * bn_u * bn_u+24 * bn_u * bn_u+6 * bn_u + 1;
-		//zout (fpe2mpz(fpe_rep),fpe2mpz(d.fpe_rep),fpe2mpz(b.fpe_rep),fpe2mpz(c.fpe_rep),fpe2mpz(fpe_rep)*fpe2mpz(d.fpe_rep)-fpe2mpz(b.fpe_rep)*fpe2mpz(c.fpe_rep));		
-		//mpz_class field_element=(fpe2mpz(fpe_rep)*fpe2mpz(d.fpe_rep)-fpe2mpz(b.fpe_rep)*fpe2mpz(c.fpe_rep)) % bn_p;
-		//field_element = (sgn(field_element)>=0)? field_element :field_element+bn_p; //il faut faire le modulo p et changer le reste de la division tronqué (obtenu avec %) est négatif, le modulo est du même signe que le dividende (celui qu'on divise) 
-		//zout(field_element);
-	}	
-	const scalar_t& Fp::scalar() const
-	{
-		return scalar_rep;
-	}
-	void Fp::print_fpe() const
-	{
-		cout << fpe_rep << endl;
-	}
+// #include "fpe2scalar.hpp" //problem : Fp does not name a type --> solution :  include fpe2scalar.hpp only in the cpp files
+
+extern const double bn_v;
+
+Fp::Fp()
+{
+    fpe_setzero(element);
+    no_change = false;
+}
+
+Fp::Fp(const fpe_t & input)
+{
+    set(input);
+    no_change = false;
+}
+
+Fp::Fp(int input)
+{
+    set(input);
+    no_change = false;
+}
+
+void Fp::set(const fpe_t & fpe)
+{
+    fpe_set(element, fpe);
+    no_change = false;
+}
+
+void Fp::set(int input)
+{
+    mydouble[12] coefficient_matrix;
+    for (int i = 0; i < 12; i++)
+    {
+        switch (i)
+        {
+            case 0:
+                coefficient_matrix[i] = ((mydouble) input);
+                break;
+
+            default:
+                coefficient_matrix[i] = 0.;             
+        }
+    }
+
+    fpe_set_doublearray(element, coefficient_matrix);
+    if (input > ((int) bn_v) * 3)
+    {
+        fpe_short_coeffred(element)
+    }
+
+    no_change = false;
+}
+
+void Fp::set_random()
+{
+    // c.f. https://www.cryptojedi.org/papers/dclxvi-20100714.pdf for these maxes
+    const int MAX_A = ((int) bn_v) * 3;
+    const int MAX_B = ((int) bn_v) / 2 + 1;
+    
+    std::random_device generator;
+    std::uniform_int_distribution<int> distribution_a(-MAX_A, MAX_A);
+    std::uniform_int_distribution<int> distribution_b(-MAX_B, MAX_B);
+
+    mydouble[12] coefficient_matrix;
+    for (int i = 0; i < 12; i++)
+    {
+        switch (i)
+        {
+            case 0:
+            case 6:
+                coefficient_matrix[i] = ((mydouble) distribution_a(generator));
+                break;
+
+            default:
+                coefficient_matrix[i] = ((mydouble) distribution_b(generator));             
+        }
+    }
+
+    fpe_set_doublearray(element, coefficient_matrix);
+
+    no_change = false;
+}
+
+Fp Fp::operator-() const
+{
+    fpe_t temp;
+
+    fpe_neg(temp, element);
+    return Fp(temp);
+}
+
+Fp Fp::operator+(const Fp & b) const
+{
+    fpe_t temp;
+    fpe_add(temp, element, b.element);
+
+    return Fp(temp);
+}
+
+Fp Fp::operator-(const Fp & b) const
+{
+    fpe_t temp;
+    fpe_sub(temp, element, b.element);
+
+    return Fp(temp);
+}
+
+Fp Fp::operator*(const Fp & b) const
+{
+    fpe_t temp;
+    fpe_mul(temp, element, b.element);
+
+    return Fp(temp);
+}
+
+Fp Fp::operator/(const Fp & b) const
+{
+    fpe_t temp;
+    fpe_invert(temp, b.element);
+    fpe_mul(temp, element, temp);
+
+    return Fp(temp);
+}
+
+bool Fp::operator==(const Fp & b) const
+{
+    return fpe_iseq(element, b.element) == 1;
+}
+
+bool Fp::operator!=(const Fp & b) const
+{
+    return fpe_iseq(element, b.element) == 0;
+}
+
+bool Fp::is_zero() const
+{
+    return fpe_iszero(element) == 1;
+}
+    
+scalar_t& Fp::to_scalar() const
+{
+    if (no_change)
+        return scalar;
+
+    mpz_class poly_at_one = 1.;
+    mpz_class increment_factor = bn_v * 6;
+    for (int i = 0; i < 12; i++)
+    {
+        switch (i)
+        {
+            case 0:
+                poly_at_one = todouble(element->v[0]);
+                break;
+
+            case 1:
+            case 2:
+            case 3:
+            case 4:
+            case 5:
+            case 6:
+                poly_at_one += increment_factor * todouble(element->v[i]);
+                increment_factor *= bn_v;
+                break;
+
+            case 7:
+                increment_factor *= 6.;
+                poly_at_one += increment_factor * todouble(element->v[i]);
+                increment_factor *= bn_v;
+                break;
+
+            default:
+                poly_at_one += increment_factor * todouble(element->v[i]);
+                increment_factor *= bn_v;
+                break;
+        }
+    }
+    
+    mpz_class bn_u = 1;
+    for (int i = 0; i < 3; i++)
+        bn_u *= bn_v;
+        
+    mpz_class bn_p;
+    bn_p = 36*bn_u*bn_u*bn_u*bn_u + 36*bn_u*bn_u*bn_u + 24*bn_u*bn_u + 6*bn_u + 1;
+
+    mpz_class field_element = poly_at_one % bn_p;
+
+    mpz_class mask = 0xffffffffffffffff; // 8 octets 64 bits
+    scalar[0] = mpz2ull( field_element         & mask);
+    scalar[1] = mpz2ull((field_element >> 64)  & mask);
+    scalar[2] = mpz2ull((field_element >> 128) & mask);
+    scalar[3] = mpz2ull((field_element >> 192) & mask);
+
+    no_change = true;
+
+    return scalar;
+}
+
+std::ostream& operator<<(std::ostream& os, const Fp& output)
+{
+    if (!output.no_change)
+        output.to_scalar();
+
+    os << output.scalar[3] << output.scalar[2] << output.scalar[1] << output.scalar[0];
+    return os;
+}
+
+unsigned long long Fp::mpz2ull(const mpz_class& n) const
+{
+    stringstream str;
+    unsigned long long retval;
+    
+    str << n;
+    str >> retval;
+
+    return retval;
+}

bgn2/src/Fp.hpp

@@ -1,43 +1,52 @@
 #ifndef __FP_HPP
-
 #define __FP_HPP
 
+#include <ostream>
+#include <sstream>
+#include <random>
 
-//#include "bgn.hpp" 
-
-#include "mydouble.h" 
+#include "mydouble.h"
 extern "C" {
 #include "fpe.h"
-#ifdef NEW_PARAMETERS
-#include "scalar_512.h"
-#else
 #include "scalar.h"
-#endif
 }
-//#include "fpe2scalar.hpp"
-
-
 
 class Fp
 {
-	friend class PrivateKey; //nécessaire pour fournir à PrivateKey l'accès aux membres privés de Fp.
-	friend class PublicKey;
-	
-	public:
-	
-	void set(fpe_t fpe); 
-	void set_random();
-	void set_ad_minus_bc(Fp b,Fp c,Fp d);
-	const scalar_t& scalar() const; //problem declared as function returning an array --> solution passage en réference de la valeur de retour
-	void print_fpe() const;	
-	Fp operator*(Fp b); // there is already one implicit parameter: the object for which the method is invoked! 
-	Fp operator-();
-	
-	private:
-	
-	scalar_t scalar_rep={};
-	fpe_t fpe_rep;
-	
+    // Necessary for private and public keys to have access to private members
+    friend class PrivateKey;
+    friend class PublicKey;
+
+    public:
+        Fp();
+        Fp(const fpe_t& input);
+        Fp(int input);
+
+        void set(const fpe_t& input);
+        void set(int input);
+        void set_random();
+
+        Fp operator-() const;
+        Fp operator+(const Fp& b) const;
+        Fp operator-(const Fp& b) const;
+        Fp operator*(const Fp& b) const;
+        Fp operator/(const Fp& b) const;
+
+        bool operator==(const Fp& b) const;
+        bool operator!=(const Fp & b) const;
+        bool Fp::is_zero() const;
+        
+        // Problem: thanks to the magic of weird typedefs, scalar_t is actually an array, which complicates returning it
+        // Solution: make the return value a reference
+        const scalar_t& to_scalar() const;
+        
+        friend std::ostream& operator<<(std::ostream& os, const Fp& output);
+    
+    private:
+        unsigned long long Fp::mpz2ull(const mpz_class& n) const;
+        fpe_t element;
+        scalar_t scalar;
+        bool no_change;
 };
 
 #endif

bgn2/src/PrivateKey.cpp

@@ -1,356 +1,323 @@
 #include "PrivateKey.hpp"
-#include "fpe2scalar.hpp"
-
-//to remove after debug
-//PrivateKey private_key;
-
-	Fp PrivateKey::get(string name)
-	{
-		 if (name == "i1") return i1; 
-		 if (name == "i2") return i2; 
-		 if (name == "j1") return j1; 
-		 if (name == "j2") return j2; 	
-		 if (name == "k1") return k1; 
-		 if (name == "k2") return k2; 
-		 if (name == "l1") return l1; 
-		 if (name == "l2") return l2; 	
-	}
-	
-	PrivateKey::PrivateKey(Fp a, Fp b, Fp c, Fp d, Fp e, Fp f, Fp g, Fp h)
-	{
-		i1 = a;
-		j1 = b;
-		k1 = c;
-		l1 = d;
-		i2 = e;
-		j2 = f;
-		k2 = g;
-		l2 = h;
-	}
-	
-	void PrivateKey::set(Fp a, Fp b, Fp c, Fp d, Fp e, Fp f, Fp g, Fp h)
-	{
-		i1 = a;
-		j1 = b;
-		k1 = c;
-		l1 = d;
-		i2 = e;
-		j2 = f;
-		k2 = g;
-		l2 = h;
-	}
-	
-	void PrivateKey::print() const
-	{
-		zout(*i1.scalar_rep, *j1.scalar_rep, *k1.scalar_rep, *l1.scalar_rep, *i2.scalar_rep, *j2.scalar_rep, *k2.scalar_rep, *l2.scalar_rep); 
-		
-	}
-	
-	
-	Bipoint<curvepoint_fp_t>  PrivateKey::pi_1(Bipoint<curvepoint_fp_t> op)
-	{
-		//what;
-		Bipoint<curvepoint_fp_t> rop;
-		curvepoint_fp_t rop0, rop1; // rop0=coeff1.op[0] + coeff2.op[1]=(-j1*k1)x +(i1*k1)y    rop1=coeff3.op[0] + coeff4.op[1]=(-j1*l1)x + (i1*l1)y
-		//cout << RED << "affichage du scalar_t i1" << RESET <<endl;
-		//scalar_print(stdout, i1.scalar()); 
-		//JUMP;
-		//cout << RED << "affichage du scalar_t j1" << RESET <<endl;
-		//scalar_print(stdout, j1.scalar()); 
-		//JUMP;
-		//cout << RED << "affichage du scalar_t k1" << RESET <<endl;
-		//scalar_print(stdout, k1.scalar()); 
-		//JUMP;		
-		
-		//cout << "à modifier après débug" << endl;
-		//Fp coeff1=-(j1*k1), coeff2=i1*k1,coeff3=-(j1*l1),coeff4=i1*l1; // en théorie, on peut faire les calculs dans Fp d'abord puis les multiplications scalaires, en pratique, on obtient des représentants différents à cause du modulo lors du produit
-		//cout << RED << "affichage du scalar_t coeff1.scalar()" << RESET <<endl;
-		//scalar_print(stdout, coeff1.scalar()); 
-		//JUMP;
-		//cout << RED << "affichage du scalar_t coeff2.scalar()" << RESET <<endl;
-		//scalar_print(stdout, coeff2.scalar()); 
-		//JUMP;
-		
-		
-		
-		
-		//Fp test1=j1*k1*i1, test2=i1*k1*j1;
-		//cout << RED << "affichage du scalar_t test1" << RESET <<endl;
-		//scalar_print(stdout, test1.scalar()); 
-		//JUMP;
-		//cout << RED << "affichage du scalar_t test2" << RESET <<endl;
-		//scalar_print(stdout, test2.scalar()); 
-		//JUMP;	
-		//curvepoint_fp_t test3,test4;
-		//curvepoint_fp_scalarmult_vartime(test3,bn_curvegen,test1.scalar());
-		//curvepoint_fp_scalarmult_vartime(test4,bn_curvegen,test2.scalar());
-		//curvepoint_fp_print(stdout,test3);
-		//JUMP;
-		//curvepoint_fp_print(stdout,test4);
-		//JUMP;
-			
-		curvepoint_fp_t temp1a,temp2a,temp3a,temp4a,temp1b,temp2b,temp3b,temp4b,temp1c,temp3c;
-		//scalar_print(stdout, coeff1.scalar());		JUMP;
-
-		//scalar_print(stdout, coeff2.scalar());		JUMP;
-
-		//curvepoint_fp_print(stdout,op[0]);		JUMP;
-
-		//curvepoint_fp_print(stdout,op[1]);		JUMP;
-
-		
-		//cout << "coeff1[0] = " << coeff1.scalar()[0] << endl;
-		//cout << "coeff1[1] = " << coeff1.scalar()[1] << endl;
-		//cout << "coeff1[2] = " << coeff1.scalar()[2] << endl;
-		//cout << "coeff1[3] = " << coeff1.scalar()[3] << endl;
-		
-		//scalar_t test5;
-		//test5[0]=1; test5[1]=0; test5[2]=0; test5[3]=0; 
-		//curvepoint_fp_scalarmult_vartime(temp1,op[0],test5);
-		//exit(0);
-		
-		//curvepoint_fp_scalarmult_vartime(temp1,op[0],coeff1.scalar());
-		curvepoint_fp_scalarmult_vartime(temp1a,op[0],j1.scalar());
-		curvepoint_fp_scalarmult_vartime(temp1b,temp1a,k1.scalar());
-		curvepoint_fp_neg(temp1c,temp1b);
-		curvepoint_fp_makeaffine(temp1c);
-		//cout << RED << "si bit_urandom=0 et op=u1 affichage du curvepoint coeff1*u1[0]=-(j1*k1)u1[0]=-(j1*k1) (lambda1*i1*g)=" << RESET << endl; curvepoint_fp_print(stdout,temp1c); JUMP; 
-		//curvepoint_fp_scalarmult_vartime(temp2,op[1],coeff2.scalar());
-		curvepoint_fp_scalarmult_vartime(temp2a,op[1],i1.scalar());
-		curvepoint_fp_scalarmult_vartime(temp2b,temp2a,k1.scalar());
-		curvepoint_fp_makeaffine(temp2b);
-		//cout << RED "si bit_urandom=0 et op=u1 affichage du curvepoint coeff2*u1[1]=(i1*k1)u1[1]=(i1*k1) (lambda1*j1*g)=" << RESET << endl; curvepoint_fp_print(stdout,temp2b);JUMP;
-		curvepoint_fp_add_vartime(rop0,temp1c,temp2b);
-		curvepoint_fp_makeaffine(rop0);
-		curvepoint_fp_set(rop[0],rop0);
-		//cout << RED << "si bit_urandom=0 et op=u1 affichage du curvepoint pi_1(u1)[0]=-(j1*k1)u1[0]+(i1*k1)u1[1]=-(j1*k1) (lambda1*i1*g)+(i1*k1) (lambda1*j1*g)" << RESET << endl; curvepoint_fp_print(stdout,rop[0]); JUMP; 
-
-		
-		//cout << RED << "affichage du scalar_t j1" << RESET <<endl;
-		//scalar_print(stdout, j1.scalar()); 
-		//JUMP;		
-		//cout << RED << "affichage du scalar_t -j1" << RESET <<endl;
-		//scalar_print(stdout, (-j1).scalar()); 
-		//JUMP;		
-		//cout << RED << "affichage du scalar_t l1" << RESET <<endl;
-		//scalar_print(stdout, l1.scalar()); 
-		//JUMP;		
-		//cout << RED << "affichage du scalar_t -l1" << RESET <<endl;
-		//scalar_print(stdout, (-l1).scalar()); 
-		//JUMP;
-		
-		//curvepoint_fp_scalarmult_vartime(temp3,op[0],coeff3.scalar());
-		curvepoint_fp_scalarmult_vartime(temp3a,op[0],j1.scalar());
-		curvepoint_fp_scalarmult_vartime(temp3b,temp3a,l1.scalar());
-		curvepoint_fp_neg(temp3c,temp3b);
-		curvepoint_fp_makeaffine(temp3c);
-		//cout << RED << "si bit_urandom=0 et op=u1 affichage du curvepoint -(j1*l1)u1[0]=-(j1*l1) (lambda1*i1*g)=" << RESET << endl; curvepoint_fp_print(stdout,temp3c); JUMP;
-		//curvepoint_fp_scalarmult_vartime(temp4,op[1],coeff4.scalar());
-		curvepoint_fp_scalarmult_vartime(temp4a,op[1],i1.scalar());
-		curvepoint_fp_scalarmult_vartime(temp4b,temp4a,l1.scalar());
-		curvepoint_fp_makeaffine(temp4b);
-		//cout << RED << "si bit_urandom=0 et op=u1 affichage du curvepoint (i1*l1)u1[1]=(i1*l1) (lambda1*j1*g)=" << RESET << endl; curvepoint_fp_print(stdout,temp4b); JUMP;
-		curvepoint_fp_add_vartime(rop1,temp3c,temp4b);
-		curvepoint_fp_makeaffine(rop1);
-		curvepoint_fp_set(rop[1],rop1);	
-		//cout << RED << "si bit_urandom=0 et op=u1 affichage du curvepoint pi_1(u1)[1]=-(j1*l1)u1[0]+(i1*l1)u1[1]=-(j1*l1) lambda1*i1*g+(i1*l1) lambda1*j1*g" << RESET << endl; curvepoint_fp_print(stdout,rop[1]); JUMP; 
-
-		return rop;
-	}
-
-	Bipoint<twistpoint_fp2_t>  PrivateKey::pi_2(Bipoint<twistpoint_fp2_t> op)
-	{
-		Bipoint<twistpoint_fp2_t> rop;
-		twistpoint_fp2_t rop0, rop1; // rop0=coeff1.op[0] + coeff2.op[1]=(-j2*k2)x +(i2*k2)y    rop1=coeff3.op[0] + coeff4.op[1]=(-j2*l2)x + (i2*l2)y
-		//Fp coeff1 = -j2*k2, coeff2 = i2*k2, coeff3 = -j2*l2, coeff4 = i2*l2;
-		twistpoint_fp2_t temp1a,temp2a,temp3a,temp4a,temp1b,temp2b,temp3b,temp4b,temp1c,temp3c;
-		//twistpoint_fp2_scalarmult_vartime(temp1,op[0],coeff1.scalar());
-		twistpoint_fp2_scalarmult_vartime(temp1a,op[0],j2.scalar());
-		twistpoint_fp2_scalarmult_vartime(temp1b,temp1a,k2.scalar());
-		twistpoint_fp2_neg(temp1c,temp1b);
-		twistpoint_fp2_makeaffine(temp1c);
-		//twistpoint_fp2_scalarmult_vartime(temp2,op[1],coeff2.scalar());
-		twistpoint_fp2_scalarmult_vartime(temp2a,op[1],i2.scalar());
-		twistpoint_fp2_scalarmult_vartime(temp2b,temp2a,k2.scalar());
-		twistpoint_fp2_makeaffine(temp2b);
-		twistpoint_fp2_add_vartime(rop0,temp1c,temp2b);
-		twistpoint_fp2_makeaffine(rop0);
-		twistpoint_fp2_set(rop[0],rop0);
-		
-		//twistpoint_fp2_scalarmult_vartime(temp3,op[0],coeff3.scalar());
-		twistpoint_fp2_scalarmult_vartime(temp3a,op[0],j2.scalar());
-		twistpoint_fp2_scalarmult_vartime(temp3b,temp3a,l2.scalar());
-		twistpoint_fp2_neg(temp3c,temp3b);		
-		twistpoint_fp2_makeaffine(temp3c);
-		//twistpoint_fp2_scalarmult_vartime(temp4,op[1],coeff4.scalar());
-		twistpoint_fp2_scalarmult_vartime(temp4a,op[1],i2.scalar());
-		twistpoint_fp2_scalarmult_vartime(temp4b,temp4a,l2.scalar());
-		twistpoint_fp2_makeaffine(temp4b);
-		twistpoint_fp2_add_vartime(rop1,temp3c,temp4b);
-		twistpoint_fp2_makeaffine(rop1);
-		twistpoint_fp2_set(rop[1],rop1);	
-		return rop;		
-	}
-	
-	Quadripoint PrivateKey::pi_T(Quadripoint op)
-	{
-		Quadripoint rop;
-		fp12e_t rop1, rop2, rop3, rop4;
-		fp12e_t temp1[20],temp2[20],temp3[20],temp4[20];
-		//void fp12e_pow_vartime(fp12e_t rop, const fp12e_t op, const scalar_t exp);
-		//void fp12e_mul(fp12e_t rop, const fp12e_t op1, const fp12e_t op2);
-		//void fp12e_invert(fp12e_t rop, const fp12e_t op);
-		
-		//fpe_t un={139089155.,0,0,0,0,0,0,0,0,0,0,0};
-		//fpe_t deux={13908915423.,0,0,0,0,0,0,0,0,0,0,0};
-		//Fp UN,DEUX;
-		//UN.set(un);
-		//DEUX.set(deux);
-		//zout(fpe2mpz(un),fpe2mpz(deux));
-		//fp12e_pow_vartime(temp1[0],op[0],UN.scalar());
-		//fp12e_pow_vartime(temp1[1],temp1[0],DEUX.scalar());
-		//fp12e_print(stdout,temp1[1]);
-		//JUMP;
-		//fp12e_pow_vartime(temp1[2],op[0],(UN*DEUX).scalar());
-		//fp12e_print(stdout,temp1[2]);
-		//JUMP;
-		//scalar_print(stdout,(UN*DEUX).scalar());		
-		//jump;
-		//zout(scalar2mpz((UN*DEUX).scalar()))
-		//exit(0);
-
-		
-		//composante 1
-		//scalar1024 exp1={}, exp2={}, exp3={}, exp4={};
-		//mpz2scalar1024(exp1,scalar2mpz(j1.scalar())*scalar2mpz(k1.scalar())*scalar2mpz(j2.scalar())*scalar2mpz(k2.scalar()));	
-		//mpz2scalar1024(exp2,scalar2mpz(j1.scalar())*scalar2mpz(k1.scalar())*scalar2mpz(i2.scalar())*scalar2mpz(k2.scalar()));	
-		//mpz2scalar1024(exp3,scalar2mpz(i1.scalar())*scalar2mpz(k1.scalar())*scalar2mpz(j2.scalar())*scalar2mpz(k2.scalar()));	
-		//mpz2scalar1024(exp4,scalar2mpz(i1.scalar())*scalar2mpz(k1.scalar())*scalar2mpz(i2.scalar())*scalar2mpz(k2.scalar()));	
-		
-		//fp12e_pow_vartime1024(temp1[3],op[0],exp1);
-		
-		//fp12e_invert(temp1[4],op[1]);
-		//fp12e_pow_vartime1024(temp1[8],temp1[4],exp2);
-
-		//fp12e_invert(temp1[9],op[2]);
-		//fp12e_pow_vartime1024(temp1[13],temp1[9],exp3);
-
-		//fp12e_pow_vartime1024(temp1[17],op[3],exp4);
-
-		fp12e_pow_vartime(temp1[0],op[0],j1.scalar()); // le produit d'entiers j1*k1 est trop grand pour aller dans un scalaire 
-		fp12e_pow_vartime(temp1[1],temp1[0],k1.scalar()); //le produit de fpe_t (j1*k1) est réduit modulo p 
-		fp12e_pow_vartime(temp1[2],temp1[1],j2.scalar()); 
-		fp12e_pow_vartime(temp1[3],temp1[2],k2.scalar());
-
-		
-		fp12e_invert(temp1[4],op[1]);
-		fp12e_pow_vartime(temp1[5],temp1[4],j1.scalar());
-		fp12e_pow_vartime(temp1[6],temp1[5],k1.scalar());
-		fp12e_pow_vartime(temp1[7],temp1[6],i2.scalar());
-		fp12e_pow_vartime(temp1[8],temp1[7],k2.scalar());
-
-		fp12e_invert(temp1[9],op[2]);
-		fp12e_pow_vartime(temp1[10],temp1[9],i1.scalar());
-		fp12e_pow_vartime(temp1[11],temp1[10],k1.scalar());
-		fp12e_pow_vartime(temp1[12],temp1[11],j2.scalar());
-		fp12e_pow_vartime(temp1[13],temp1[12],k2.scalar());
-
-		fp12e_pow_vartime(temp1[14],op[3],i1.scalar());
-		fp12e_pow_vartime(temp1[15],temp1[14],k1.scalar());
-		fp12e_pow_vartime(temp1[16],temp1[15],i2.scalar());
-		fp12e_pow_vartime(temp1[17],temp1[16],k2.scalar());
-
-		fp12e_mul(temp1[18],temp1[3],temp1[8]);
-		fp12e_mul(temp1[19],temp1[13],temp1[17]);
-		fp12e_mul(rop1,temp1[18],temp1[19]);
-
-		//composante 2
-		fp12e_pow_vartime(temp2[0],op[0],j1.scalar());
-		fp12e_pow_vartime(temp2[1],temp2[0],k1.scalar());
-		fp12e_pow_vartime(temp2[2],temp2[1],j2.scalar());
-		fp12e_pow_vartime(temp2[3],temp2[2],l2.scalar());
-
-		fp12e_pow_vartime(temp2[4],op[1],j1.scalar());
-		fp12e_invert(temp2[5],temp2[4]);
-		fp12e_pow_vartime(temp2[6],temp2[5],k1.scalar());
-		fp12e_pow_vartime(temp2[7],temp2[6],i2.scalar());
-		fp12e_pow_vartime(temp2[8],temp2[7],l2.scalar());
-
-		fp12e_pow_vartime(temp2[9],op[2],i1.scalar());
-		fp12e_pow_vartime(temp2[10],temp2[9],k1.scalar());
-		fp12e_pow_vartime(temp2[11],temp2[10],j2.scalar());
-		fp12e_invert(temp2[12],temp2[11]);
-		fp12e_pow_vartime(temp2[13],temp2[12],l2.scalar());
-//
-		fp12e_pow_vartime(temp2[14],op[3],i1.scalar());
-		fp12e_pow_vartime(temp2[15],temp2[14],k1.scalar());
-		fp12e_pow_vartime(temp2[16],temp2[15],i2.scalar());
-		fp12e_pow_vartime(temp2[17],temp2[16],l2.scalar());
-
-		fp12e_mul(temp2[18],temp2[3],temp2[8]);
-		fp12e_mul(temp2[19],temp2[13],temp2[17]);
-		fp12e_mul(rop2,temp2[18],temp2[19]);
-		
-		
-		//composante 3
-		fp12e_pow_vartime(temp3[0],op[0],j1.scalar());
-		fp12e_pow_vartime(temp3[1],temp3[0],l1.scalar());
-		fp12e_pow_vartime(temp3[2],temp3[1],j2.scalar());
-		fp12e_pow_vartime(temp3[3],temp3[2],k2.scalar());
-
-		fp12e_pow_vartime(temp3[4],op[1],j1.scalar());
-		fp12e_invert(temp3[5],temp3[4]);
-		fp12e_pow_vartime(temp3[6],temp3[5],l1.scalar());
-		fp12e_pow_vartime(temp3[7],temp3[6],i2.scalar());
-		fp12e_pow_vartime(temp3[8],temp3[7],k2.scalar());
-
-		fp12e_pow_vartime(temp3[9],op[2],i1.scalar());
-		fp12e_pow_vartime(temp3[10],temp3[9],l1.scalar());
-		fp12e_pow_vartime(temp3[11],temp3[10],j2.scalar());
-		fp12e_invert(temp3[12],temp3[11]);
-		fp12e_pow_vartime(temp3[13],temp3[12],k2.scalar());
-
-		fp12e_pow_vartime(temp3[14],op[3],i1.scalar());
-		fp12e_pow_vartime(temp3[15],temp3[14],l1.scalar());
-		fp12e_pow_vartime(temp3[16],temp3[15],i2.scalar());
-		fp12e_pow_vartime(temp3[17],temp3[16],k2.scalar());
-		
-		fp12e_mul(temp3[18],temp3[3],temp3[8]);
-		fp12e_mul(temp3[19],temp3[13],temp3[17]);
-		fp12e_mul(rop3,temp3[18],temp3[19]);
-		
-		//composante 4
-		
-		fp12e_pow_vartime(temp4[0],op[0],j1.scalar());
-		fp12e_pow_vartime(temp4[1],temp4[0],l1.scalar());
-		fp12e_pow_vartime(temp4[2],temp4[1],j2.scalar());
-		fp12e_pow_vartime(temp4[3],temp4[2],l2.scalar());
-
-		fp12e_pow_vartime(temp4[4],op[1],j1.scalar());
-		fp12e_invert(temp4[5],temp4[4]);
-		fp12e_pow_vartime(temp4[6],temp4[5],l1.scalar());
-		fp12e_pow_vartime(temp4[7],temp4[6],i2.scalar());
-		fp12e_pow_vartime(temp4[8],temp4[7],l2.scalar());
-
-		fp12e_pow_vartime(temp4[9],op[2],i1.scalar());
-		fp12e_pow_vartime(temp4[10],temp4[9],l1.scalar());
-		fp12e_pow_vartime(temp4[11],temp4[10],j2.scalar());
-		fp12e_invert(temp4[12],temp4[11]);
-		fp12e_pow_vartime(temp4[13],temp4[12],l2.scalar());
-
-		fp12e_pow_vartime(temp4[14],op[3],i1.scalar());
-		fp12e_pow_vartime(temp4[15],temp4[14],l1.scalar());
-		fp12e_pow_vartime(temp4[16],temp4[15],i2.scalar());
-		fp12e_pow_vartime(temp4[17],temp4[16],l2.scalar());
-
-		fp12e_mul(temp4[18],temp4[3],temp4[8]);
-		fp12e_mul(temp4[19],temp4[13],temp4[17]);
-		fp12e_mul(rop4,temp4[18],temp4[19]);		
-		
-		rop.set(rop1,0);
-		rop.set(rop2,1);
-		rop.set(rop3,2);
-		rop.set(rop4,3);
-		
-		return rop;
-	}
+
+extern const curvepoint_fp_t bn_curvegen;
+
+PrivateKey::PrivateKey(const Fp& a, const Fp& b, const Fp& c, const Fp& d, const Fp& e, const Fp& f, const Fp& g, const Fp& h)
+{
+    set(a, b, c, d, e, f, g, h);
+}
+
+void PrivateKey::set(const Fp& a, const Fp& b, const Fp& c, const Fp& d, const Fp& e, const Fp& f, const Fp& g, const Fp& h)
+{
+    i1 = a;
+    j1 = b;
+    k1 = c;
+    l1 = d;
+
+    i2 = e;
+    j2 = f;
+    k2 = g;
+    l2 = h;
+}
+
+void PrivateKey::set(string which, const Fp& input);
+{
+    if (which.length() != 2)
+        return;
+
+    bool var_is_1 = false;
+    switch (which[1])
+    {
+        case '1':
+            var_is_1 = true;
+            break;
+
+        case '2':
+            break;
+
+        default:
+            return;
+    }
+
+    switch (which[0])
+    {
+        case 'i':
+            if (var_is_1)
+                i1 = input;
+            else i2 = input;
+            break;
+
+        case 'j':
+            if (var_is_1)
+                j1 = input;
+            else j2 = input;
+            break;
+
+        case 'k':
+            if (var_is_1)
+                k1 = input;
+            else k2 = input;
+            break;
+
+        case 'l':
+            if (var_is_1)
+                l1 = input;
+            else l2 = input;
+            break;
+
+        default:
+            break;
+    } 
+}
+
+Fp PrivateKey::get(string which) const
+{
+    if (which.length() != 2)
+        return Fp();
+
+    bool var_is_1 = false;
+    switch (which[1])
+    {
+        case '1':
+            var_is_1 = true;
+            break;
+
+        case '2':
+            break;
+
+        default:
+            return Fp();
+    }
+
+    switch (which[0])
+    {
+        case 'i':
+            return var_is_1 ? i1 : i2;
+
+        case 'j':
+            return var_is_1 ? j1 : j2;
+
+        case 'k':
+            return var_is_1 ? k1 : k2;
+
+        case 'l':
+            return var_is_1 ? l1 : l2;
+
+        default:
+            return Fp();
+    } 
+}
+
+Bipoint<curvepoint_fp_t> PrivateKey::pi_1(const Bipoint<curvepoint_fp_t>& input) const
+{
+    Bipoint<curvepoint_fp_t> retval;
+    curvepoint_fp_t temp1, temp2;
+    
+    const scalar_t i1_s = i1.to_scalar();
+    const scalar_t j1_s = j1.to_scalar();
+    const scalar_t k1_s = k1.to_scalar();
+    const scalar_t l1_s = l1.to_scalar();
+
+
+    curvepoint_fp_scalarmult_vartime(temp1, input[0], j1_s);
+    curvepoint_fp_scalarmult_vartime(temp1, temp1, k1_s);
+    curvepoint_fp_neg(temp1, temp1);
+    curvepoint_fp_makeaffine(temp1);
+
+    curvepoint_fp_scalarmult_vartime(temp2, input[1], i1_s);
+    curvepoint_fp_scalarmult_vartime(temp2, temp2, k1_s);
+    curvepoint_fp_makeaffine(temp2);
+
+    curvepoint_fp_add_vartime(temp1, temp1, temp2);
+    curvepoint_fp_makeaffine(temp1);
+    curvepoint_fp_set(retval[0], temp1);
+    
+
+    curvepoint_fp_scalarmult_vartime(temp1, input[0], j1_s);
+    curvepoint_fp_scalarmult_vartime(temp1, temp1, l1_s);
+    curvepoint_fp_neg(temp1, temp1);
+    curvepoint_fp_makeaffine(temp1);
+    
+    curvepoint_fp_scalarmult_vartime(temp2, input[1], i1_s);
+    curvepoint_fp_scalarmult_vartime(temp2, temp2, l1_s);
+    curvepoint_fp_makeaffine(temp2);
+    
+    curvepoint_fp_add_vartime(temp1, temp1, temp2);
+    curvepoint_fp_makeaffine(temp1);
+    curvepoint_fp_set(retval[1], temp1); 
+
+
+    return retval;
+}
+
+Bipoint<twistpoint_fp2_t> PrivateKey::pi_2(const Bipoint<twistpoint_fp2_t>& input) const
+{
+    Bipoint<twistpoint_fp2_t> retval;
+    twistpoint_fp2_t temp1, temp2;
+
+    const scalar_t i2_s = i2.to_scalar();
+    const scalar_t j2_s = j2.to_scalar();
+    const scalar_t k2_s = k2.to_scalar();
+    const scalar_t l2_s = l2.to_scalar();
+    
+
+    twistpoint_fp2_scalarmult_vartime(temp1, input[0], j2_s);
+    twistpoint_fp2_scalarmult_vartime(temp1, temp1, k2_s);
+    twistpoint_fp2_neg(temp1,temp1);
+    twistpoint_fp2_makeaffine(temp1);
+    
+    twistpoint_fp2_scalarmult_vartime(temp2, input[1], i2_s);
+    twistpoint_fp2_scalarmult_vartime(temp2, temp2, k2_s);
+    twistpoint_fp2_makeaffine(temp2);
+
+    twistpoint_fp2_add_vartime(temp1, temp1, temp2);
+    twistpoint_fp2_makeaffine(temp1);
+    twistpoint_fp2_set(retval[0], temp1);
+    
+
+    twistpoint_fp2_scalarmult_vartime(temp1, input[0], j2_s);
+    twistpoint_fp2_scalarmult_vartime(temp1, temp1, l2_s);
+    twistpoint_fp2_neg(temp1, temp1);      
+    twistpoint_fp2_makeaffine(temp1);
+    
+    twistpoint_fp2_scalarmult_vartime(temp2, input[1], i2_s);
+    twistpoint_fp2_scalarmult_vartime(temp2, temp2, l2_s);
+    twistpoint_fp2_makeaffine(temp2);
+
+    twistpoint_fp2_add_vartime(temp1, temp1, temp2);
+    twistpoint_fp2_makeaffine(temp1);
+    twistpoint_fp2_set(retval[1], temp1);
+
+
+    return retval;     
+}
+
+Quadripoint PrivateKey::pi_T(const Quadripoint& input) const
+{
+    Quadripoint retval;
+    fp12e_t temp1, temp2, temp3, temp4;
+
+    const scalar_t i1_s = i1.to_scalar();
+    const scalar_t j1_s = j1.to_scalar();
+    const scalar_t k1_s = k1.to_scalar();
+    const scalar_t l1_s = l1.to_scalar();
+    const scalar_t i2_s = i2.to_scalar();
+    const scalar_t j2_s = j2.to_scalar();
+    const scalar_t k2_s = k2.to_scalar();
+    const scalar_t l2_s = l2.to_scalar();
+
+
+    fp12e_pow_vartime(temp1, input[0], j1_s);
+    fp12e_pow_vartime(temp1, temp1, k1_s);
+    fp12e_pow_vartime(temp1, temp1, j2_s); 
+    fp12e_pow_vartime(temp1, temp1, k2_s);
+    
+    fp12e_invert(temp2, input[1]);
+    fp12e_pow_vartime(temp2, temp2, j1_s);
+    fp12e_pow_vartime(temp2, temp2, k1_s);
+    fp12e_pow_vartime(temp2, temp2, i2_s);
+    fp12e_pow_vartime(temp2, temp2, k2_s);
+
+    fp12e_invert(temp3, input[2]);
+    fp12e_pow_vartime(temp3, temp3, i1_s);
+    fp12e_pow_vartime(temp3, temp3, k1_s);
+    fp12e_pow_vartime(temp3, temp3, j2_s);
+    fp12e_pow_vartime(temp3, temp3, k2_s);
+
+    fp12e_pow_vartime(temp4, input[3], i1_s);
+    fp12e_pow_vartime(temp4, temp4, k1_s);
+    fp12e_pow_vartime(temp4, temp4, i2_s);
+    fp12e_pow_vartime(temp4, temp4, k2_s);
+
+    fp12e_mul(temp1, temp1, temp2);
+    fp12e_mul(temp2, temp3, temp4);
+    fp12e_mul(temp1, temp1, temp2);
+    retval.set(temp1, 0);
+
+
+    fp12e_pow_vartime(temp1, input[0], j1_s);
+    fp12e_pow_vartime(temp1, temp1, k1_s);
+    fp12e_pow_vartime(temp1, temp1, j2_s);
+    fp12e_pow_vartime(temp1, temp1, l2_s);
+
+    fp12e_pow_vartime(temp2, input[1], j1_s);
+    fp12e_invert(temp2, temp2);
+    fp12e_pow_vartime(temp2, temp2, k1_s);
+    fp12e_pow_vartime(temp2, temp2, i2_s);
+    fp12e_pow_vartime(temp2, temp2, l2_s);
+
+    fp12e_pow_vartime(temp3, input[2], i1_s);
+    fp12e_pow_vartime(temp3, temp3, k1_s);
+    fp12e_pow_vartime(temp3, temp3, j2_s);
+    fp12e_invert(temp3, temp3);
+    fp12e_pow_vartime(temp3, temp3, l2_s);
+
+    fp12e_pow_vartime(temp4, input[3], i1_s);
+    fp12e_pow_vartime(temp4, temp4, k1_s);
+    fp12e_pow_vartime(temp4, temp4, i2_s);
+    fp12e_pow_vartime(temp4, temp4, l2_s);
+
+    fp12e_mul(temp1, temp1, temp2);
+    fp12e_mul(temp2, temp3, temp4);
+    fp12e_mul(temp1, temp1, temp2);
+    retval.set(temp1, 1);
+    
+
+    fp12e_pow_vartime(temp1, input[0], j1_s);
+    fp12e_pow_vartime(temp1, temp1, l1_s);
+    fp12e_pow_vartime(temp1, temp1, j2_s);
+    fp12e_pow_vartime(temp1, temp1, k2_s);
+
+    fp12e_pow_vartime(temp2, input[1], j1_s);
+    fp12e_invert(temp2, temp2);
+    fp12e_pow_vartime(temp2, temp2, l1_s);
+    fp12e_pow_vartime(temp2, temp2, i2_s);
+    fp12e_pow_vartime(temp2, temp2, k2_s);
+
+    fp12e_pow_vartime(temp3, input[2], i1_s);
+    fp12e_pow_vartime(temp3, temp3, l1_s);
+    fp12e_pow_vartime(temp3, temp3, j2_s);
+    fp12e_invert(temp3, temp3);
+    fp12e_pow_vartime(temp3, temp3, k2_s);
+
+    fp12e_pow_vartime(temp4, input[3], i1_s);
+    fp12e_pow_vartime(temp4, temp4, l1_s);
+    fp12e_pow_vartime(temp4, temp4, i2_s);
+    fp12e_pow_vartime(temp4, temp4, k2_s);
+    
+    fp12e_mul(temp1, temp1, temp2);
+    fp12e_mul(temp2, temp3, temp4);
+    fp12e_mul(temp1, temp1, temp2);
+    retval.set(temp1, 2);
+    
+
+    fp12e_pow_vartime(temp1, input[0], j1_s);
+    fp12e_pow_vartime(temp1, temp1, l1_s);
+    fp12e_pow_vartime(temp1, temp1, j2_s);
+    fp12e_pow_vartime(temp1, temp1, l2_s);
+
+    fp12e_pow_vartime(temp2, input[1], j1_s);
+    fp12e_invert(temp2, temp2);
+    fp12e_pow_vartime(temp2, temp2, l1_s);
+    fp12e_pow_vartime(temp2, temp2, i2_s);
+    fp12e_pow_vartime(temp2, temp2, l2_s);
+
+    fp12e_pow_vartime(temp3, input[2], i1_s);
+    fp12e_pow_vartime(temp3, temp3, l1_s);
+    fp12e_pow_vartime(temp3, temp3, j2_s);
+    fp12e_invert(temp3, temp3);
+    fp12e_pow_vartime(temp3, temp3, l2_s);
+
+    fp12e_pow_vartime(temp4, input[3], i1_s);
+    fp12e_pow_vartime(temp4, temp4, l1_s);
+    fp12e_pow_vartime(temp4, temp4, i2_s);
+    fp12e_pow_vartime(temp4, temp4, l2_s);
+
+    fp12e_mul(temp1, temp1, temp2);
+    fp12e_mul(temp2, temp3, temp4);
+    fp12e_mul(temp1, temp1, temp2);
+    retval.set(temp1, 3);
+    
+
+    return retval;
+}

bgn2/src/PrivateKey.hpp

@@ -1,34 +1,27 @@
 #ifndef __PRIVATEKEY_HPP
-
 #define __PRIVATEKEY_HPP
+
+#include "Fp.hpp"
 #include "Bipoint.hpp"
-#include "Fp.hpp" 
-#include "zout.hpp"
 #include "Quadripoint.hpp"
 #include "fp12e.h"
 
-extern const curvepoint_fp_t bn_curvegen;
-
-class  PrivateKey
+class PrivateKey
 {
-	
-	public:
-	PrivateKey() = default; 
-	PrivateKey(Fp a, Fp b, Fp c, Fp d, Fp e, Fp f, Fp g, Fp h);
-	void set(Fp a, Fp b, Fp c, Fp d, Fp e, Fp f, Fp g, Fp h);
-	Fp get(string name);
-	void print() const;
-	Bipoint<curvepoint_fp_t>  pi_1(Bipoint<curvepoint_fp_t>);
-	Bipoint<twistpoint_fp2_t> pi_2(Bipoint<twistpoint_fp2_t>);
-	Quadripoint pi_T(Quadripoint);
-	
-	private :
-	Fp i1, j1, k1, l1, i2, j2, k2, l2;
-	
-};
+    public:
+        PrivateKey() = default; 
+        PrivateKey(const Fp& a, const Fp& b, const Fp& c, const Fp& d, const Fp& e, const Fp& f, const Fp& g, const Fp& h);
 
-//to remove after debug REMOVE
-//extern PrivateKey private_key;
+        void set(const Fp& a, const Fp& b, const Fp& c, const Fp& d, const Fp& e, const Fp& f, const Fp& g, const Fp& h);
+        void set(string which, const Fp& input);
+        Fp get(string which) const;
+        
+        Bipoint<curvepoint_fp_t>  pi_1(const Bipoint<curvepoint_fp_t>& input) const;
+        Bipoint<twistpoint_fp2_t> pi_2(const Bipoint<twistpoint_fp2_t>& input) const;
+        Quadripoint pi_T(const Quadripoint& input) const;
+    
+    private:
+        Fp i1, j1, k1, l1, i2, j2, k2, l2;
+};
 
 #endif
-

bgn2/src/PublicKey.cpp

@@ -1,78 +1,40 @@
 #include "PublicKey.hpp"
 
-PublicKey public_key;
-	
-Bipoint<curvepoint_fp_t> PublicKey::get_bipoint_curvegen() const
+PublicKey(const Bipoint<curvepoint_fp_t>& a, const Bipoint<twistpoint_fp2_t>& b, const Bipoint<curvepoint_fp_t>& c, const Bipoint<twistpoint_fp2_t>& d)
 {
-	return bipoint_curvegen;
+    set(a, b, c, d);
 }
 
-Bipoint<twistpoint_fp2_t> PublicKey::get_bipoint_twistgen() const
+void set(const Bipoint<curvepoint_fp_t>& a, const Bipoint<twistpoint_fp2_t>& b, const Bipoint<curvepoint_fp_t>& c, const Bipoint<twistpoint_fp2_t>& d)
 {
-	return bipoint_twistgen;
-}
+    a.makeaffine();
+    b.makeaffine();
+    c.makeaffine();
+    d.makeaffine();
 
-Bipoint<curvepoint_fp_t> PublicKey::get_bipoint_curve_groupelt() const
-{
-	return bipoint_curve_groupelt;
+    bipoint_curvegen = a;
+    bipoint_twistgen = b;
+    
+    bipoint_curve_groupelt = c;
+    bipoint_twist_groupelt = d;
 }
 
-Bipoint<twistpoint_fp2_t> PublicKey::get_bipoint_twist_groupelt() const
+Bipoint<curvepoint_fp_t> PublicKey::get_bipoint_curvegen() const
 {
-	return bipoint_twist_groupelt;
+    return bipoint_curvegen;
 }
 
-void PublicKey::print() const
+Bipoint<twistpoint_fp2_t> PublicKey::get_bipoint_twistgen() const
 {
-	cout << RED << "affichage du point i1.g" << RESET << endl;
-	bipoint_curvegen.print(0);
-	JUMP;
-	cout << RED << "affichage du point j1.g" << RESET << endl;
-	bipoint_curvegen.print(1);
-	JUMP;
-	cout << RED << "affichage du point i2.h" << RESET << endl;
-	bipoint_twistgen.print(0);
-	JUMP;
-	cout << RED << "affichage du point j2.h" << RESET << endl;
-	bipoint_twistgen.print(1);
-	JUMP;
-	cout << RED << "affichage du point u[0]" << RESET << endl;
-	bipoint_curve_groupelt.print(0);
-	JUMP;
-	cout << RED << "affichage du point u[1]" << RESET << endl;
-	bipoint_curve_groupelt.print(1);
-	JUMP;
-	cout << RED << "affichage du point v[0]" << RESET << endl;
-	bipoint_twist_groupelt.print(0);
-	JUMP;
-	cout << RED << "affichage du point v[1]" << RESET << endl;
-	bipoint_twist_groupelt.print(1);
-	JUMP;	
-	
-	
-	
+    return bipoint_twistgen;
 }
-	
-PublicKey::PublicKey(Bipoint<curvepoint_fp_t> a ,Bipoint<twistpoint_fp2_t> b, Bipoint<curvepoint_fp_t> c ,Bipoint<twistpoint_fp2_t> d)
+
+Bipoint<curvepoint_fp_t> PublicKey::get_bipoint_curve_groupelt() const
 {
-	a.makeaffine();
-	b.makeaffine();
-	c.makeaffine();
-	d.makeaffine();
-	bipoint_curvegen = a;
-	bipoint_twistgen = b;
-	bipoint_curve_groupelt = c;
-	bipoint_twist_groupelt = d;
+    return bipoint_curve_groupelt;
 }
 
-void PublicKey::set(Bipoint<curvepoint_fp_t> a,Bipoint<twistpoint_fp2_t> b, Bipoint<curvepoint_fp_t> c ,Bipoint<twistpoint_fp2_t> d)
+Bipoint<twistpoint_fp2_t> PublicKey::get_bipoint_twist_groupelt() const
 {
-	a.makeaffine();
-	b.makeaffine();
-	c.makeaffine();
-	d.makeaffine();
-	bipoint_curvegen = a;
-	bipoint_twistgen = b;
-	bipoint_curve_groupelt = c;
-	bipoint_twist_groupelt = d;
+    return bipoint_twist_groupelt;
 }

bgn2/src/PublicKey.hpp

@@ -1,30 +1,26 @@
 #ifndef __PUBLICKEY_HPP
-
 #define __PUBLICKEY_HPP
 
 #include "Bipoint.hpp"
-#include "zout.hpp"
-#include <type_traits>
 
-class  PublicKey
+class PublicKey
 {
 	public:
-	PublicKey() = default;
-	PublicKey(Bipoint<curvepoint_fp_t> a,Bipoint<twistpoint_fp2_t> b, Bipoint<curvepoint_fp_t> c,Bipoint<twistpoint_fp2_t> d);
-	void set(Bipoint<curvepoint_fp_t> a,Bipoint<twistpoint_fp2_t> b, Bipoint<curvepoint_fp_t> c,Bipoint<twistpoint_fp2_t> d);
-	void print() const;
-	Bipoint<curvepoint_fp_t> get_bipoint_curvegen() const;
-	Bipoint<twistpoint_fp2_t> get_bipoint_twistgen() const;	
-	Bipoint<curvepoint_fp_t> get_bipoint_curve_groupelt() const;
-	Bipoint<twistpoint_fp2_t> get_bipoint_twist_groupelt() const;	
+		PublicKey() = default;
+		PublicKey(const Bipoint<curvepoint_fp_t>& a, const Bipoint<twistpoint_fp2_t>& b, const Bipoint<curvepoint_fp_t>& c, const Bipoint<twistpoint_fp2_t>& d);
+		
+		void set(const Bipoint<curvepoint_fp_t>& a, const Bipoint<twistpoint_fp2_t>& b, const Bipoint<curvepoint_fp_t>& c, const Bipoint<twistpoint_fp2_t>& d);
 		
-	private :
-	Bipoint<curvepoint_fp_t> bipoint_curvegen; //subgroup_gen (i1g,j1,g)
-	Bipoint<twistpoint_fp2_t> bipoint_twistgen; //subgroup_gen (i2h, j2h)
-	Bipoint<curvepoint_fp_t> bipoint_curve_groupelt; // u
-	Bipoint<twistpoint_fp2_t> bipoint_twist_groupelt; // v
+		Bipoint<curvepoint_fp_t> get_bipoint_curvegen() const;
+		Bipoint<twistpoint_fp2_t> get_bipoint_twistgen() const;	
+		Bipoint<curvepoint_fp_t> get_bipoint_curve_groupelt() const;
+		Bipoint<twistpoint_fp2_t> get_bipoint_twist_groupelt() const;	
+		
+	private:
+		Bipoint<curvepoint_fp_t> bipoint_curvegen; // subgroup_gen(i1g, j1g)
+		Bipoint<twistpoint_fp2_t> bipoint_twistgen; // subgroup_gen(i2h, j2h)
+		Bipoint<curvepoint_fp_t> bipoint_curve_groupelt; // u
+		Bipoint<twistpoint_fp2_t> bipoint_twist_groupelt; // v
 };
 
-extern PublicKey public_key;
-
 #endif

bgn2/src/Quadripoint.cpp

@@ -1,101 +1,73 @@
 #include "Quadripoint.hpp"
 
-
-void Quadripoint::print() const
-{
-	fp12e_print(stdout,point[0]);
-	jump;
-	fp12e_print(stdout,point[1]);
-	jump;
-	fp12e_print(stdout,point[2]);
-	jump;
-	fp12e_print(stdout,point[3]);	
-	JUMP;
-}
-
-bool Quadripoint::operator==(Quadripoint b)
+Quadripoint::Quadripoint()
 {
-	bool rop;
-
-	
-	if(fp12e_iseq(point[0],b[0]) && fp12e_iseq(point[1],b[1]) && fp12e_iseq(point[2],b[2]) && fp12e_iseq(point[3],b[3])) 
-	{
-		rop=true;
-	}
-	else
-	{
-		rop=false;
-	}
-	return rop;
+	fp12e_setone(point[0]);
+	fp12e_setone(point[1]);
+	fp12e_setone(point[2]);
+	fp12e_setone(point[3]);	
 }
 
-Quadripoint Quadripoint::square()
+Quadripoint::Quadripoint(const fp12e_t& p1, const fp12e_t& p2, const fp12e_t& p3, const fp12e_t& p4)
 {
-	Quadripoint   rop;
-	fp12e_square(rop[0],point[0]);
-	fp12e_square(rop[1],point[1]);
-	fp12e_square(rop[2],point[2]);
-	fp12e_square(rop[3],point[3]);
-	return rop;	
+	fp12e_set(point[0], p1);
+	fp12e_set(point[1], p2);
+	fp12e_set(point[2], p3);
+	fp12e_set(point[3], p4);
 }
 
-Quadripoint Quadripoint::pow_vartime(const scalar_t exp)
-{
-	Quadripoint   rop;
-	fp12e_pow_vartime(rop[0],point[0],exp);
-	fp12e_pow_vartime(rop[1],point[1],exp);
-	fp12e_pow_vartime(rop[2],point[2],exp);
-	fp12e_pow_vartime(rop[3],point[3],exp);
-	return rop;	
-}
-Quadripoint Quadripoint::operator*(Quadripoint b)
+fp12e_t& Quadripoint::operator[](int n)
 {
-	Quadripoint   rop;
-	fp12e_mul(rop[0],point[0],b.point[0]);
-	fp12e_mul(rop[1],point[1],b.point[1]);
-	fp12e_mul(rop[2],point[2],b.point[2]);
-	fp12e_mul(rop[3],point[3],b.point[3]);
-	return rop;
+	return point[n];
 }
 
-fp12e_t& Quadripoint::operator[](int n)
+const fp12e_t& Quadripoint::operator[](int n) const
 {
 	return point[n];
 }
 
+Quadripoint Quadripoint::operator*(const Quadripoint& b) const
+{
+	Quadripoint retval;
 
+	fp12e_mul(retval[0], point[0], b.point[0]);
+	fp12e_mul(retval[1], point[1], b.point[1]);
+	fp12e_mul(retval[2], point[2], b.point[2]);
+	fp12e_mul(retval[3], point[3], b.point[3]);
 
-
-Quadripoint::Quadripoint()
-{
-	fp12e_setone(point[0]);
-	fp12e_setone(point[1]);
-	fp12e_setone(point[2]);
-	fp12e_setone(point[3]);	
+	return retval;
 }
 
-
-Quadripoint::Quadripoint(fp12e_t p1,fp12e_t p2, fp12e_t p3,fp12e_t p4)
+Quadripoint Quadripoint::operator^(const scalar_t& exp) const
 {
-	fp12e_set(point[0],p1);
-	fp12e_set(point[1],p2);
-	fp12e_set(point[2],p3);
-	fp12e_set(point[3],p4);
-	}
-
+	Quadripoint retval;
+	
+	fp12e_pow_vartime(retval[0], point[0], exp);
+	fp12e_pow_vartime(retval[1], point[1], exp);
+	fp12e_pow_vartime(retval[2], point[2], exp);
+	fp12e_pow_vartime(retval[3], point[3], exp);
 
+	return retval;	
+}
 
-void Quadripoint::set(fp12e_t element,int numpoint)
+bool Quadripoint::operator==(const Quadripoint& b) const
 {
-	fp12e_set(point[numpoint],element);
+	bool retval = fp12e_iseq(point[0], b[0]);
+	retval &&= fp12e_iseq(point[1], b[1]);
+	retval &&= fp12e_iseq(point[2], b[2]);
+	retval &&= fp12e_iseq(point[3], b[3]);
+	
+	return retval;
 }
 
-
-
-
-void Quadripoint::print(int numpoint) const
+Quadripoint Quadripoint::square() const
 {
-	fp12e_print(stdout,point[numpoint]);
-	JUMP;
-}
+	Quadripoint retval;
+	
+	fp12e_square(retval[0], point[0]);
+	fp12e_square(retval[1], point[1]);
+	fp12e_square(retval[2], point[2]);
+	fp12e_square(retval[3], point[3]);
 
+	return retval;	
+}

bgn2/src/Quadripoint.hpp

@@ -1,42 +1,31 @@
 #ifndef __QUADRIPOINT_HPP
-
 #define __QUADRIPOINT_HPP
 
-
-
-//#include "bgn.hpp"
 #include "mydouble.h" 
 extern "C" {
 #include "fpe.h"
-}
-extern "C" {
 #include "fp2e.h"	
-}
-extern "C" {
 #include "fp6e.h"	
-}
-extern "C" {
 #include "fp12e.h"	
 }
-#include "zout.hpp"
 
 class Quadripoint
 {
 	public:
-	//Quadripoint() = default; 
-	Quadripoint();
-	Quadripoint(fp12e_t p1,fp12e_t p2, fp12e_t p3,fp12e_t p4);
-	void set(fp12e_t, int numpoint); 
-	void print(int numpoint) const;	
-	fp12e_t& operator[](int n); //la valeur de retour doit être une référence.
-	bool operator==(Quadripoint b);
-	Quadripoint operator*(Quadripoint b); 
-	Quadripoint square();
-	Quadripoint pow_vartime(const scalar_t exp);
+		Quadripoint();
+		Quadripoint(const fp12e_t& p1, const fp12e_t& p2, const fp12e_t& p3, const fp12e_t& p4);
+
+		fp12e_t& operator[](int n);
+		const fp12e_t& operator[](int n) const;
+
+		Quadripoint operator*(const Quadripoint& b) const;
+		Quadripoint operator^(const scalar_t& exp) const;
+		bool operator==(const Quadripoint& b) const;
 
-	void print() const;
+		Quadripoint square() const;
 	
 	private:
-	fp12e_t point[4];	}; 
+		fp12e_t point[4];
+}; 
 
 #endif

bgn2/src/circuit_additionL1.cpp

@@ -1,99 +0,0 @@
-#include "circuit_additionL1.hpp"
-void circuit_additionL1(PublicKey public_key, PrivateKey private_key)
-{
-	ecris(CURVE);
-	F2 un=0,zero=0, somme=0;
-	BitEvalL1<curvepoint_fp_t> bit_chiffre_curve_0, bit_chiffre_curve_1, chiffre_curve_somme;
-	
-	chiffrement(bit_chiffre_curve_0,0,public_key);
-	chiffrement(bit_chiffre_curve_1,1,public_key);
-	dechiffrement(zero,bit_chiffre_curve_0,private_key);
-	dechiffrement(un,bit_chiffre_curve_1,private_key);
-	zout(zero,un);
-	
-	cout << "cas #1 0+0" << endl;
-	
-	//ecris(affichage de bit_chiffre_curve_0);
-	//bit_chiffre_curve_0.print();
-	chiffre_curve_somme=additionL1(bit_chiffre_curve_0,bit_chiffre_curve_0,public_key);
-	//ecris(affichage de chiffre_curve_somme);
-	//chiffre_curve_somme.print();
-	dechiffrement(somme,chiffre_curve_somme,private_key);
-	zout(somme);
-			
-	cout << "cas #2 0+1" << endl;
-
-	chiffre_curve_somme=additionL1(bit_chiffre_curve_0,bit_chiffre_curve_1,public_key);
-	dechiffrement(somme,chiffre_curve_somme,private_key);
-	zout(somme);
-		
-	cout << "cas #3 1+0" << endl;
-
-	//bit_chiffre_curve_0.print();
-	//bit_chiffre_curve_1.print();
-
-	chiffre_curve_somme=additionL1(bit_chiffre_curve_1,bit_chiffre_curve_0,public_key);
-	dechiffrement(somme,chiffre_curve_somme,private_key);
-	zout(somme);
-		
-	cout << "cas #4 1+1" << endl;
-	
-	chiffre_curve_somme=additionL1(bit_chiffre_curve_1,bit_chiffre_curve_1,public_key);
-	dechiffrement(somme,chiffre_curve_somme,private_key);
-	zout(somme);
-	
-	JUMP;
-	
-	
-	
-	
-	ecris(TWIST);
-	un=0,zero=0, somme=0;
-	BitEvalL1<twistpoint_fp2_t> bit_chiffre_twist_0, bit_chiffre_twist_1, chiffre_twist_somme;
-	
-	chiffrement(bit_chiffre_twist_0,0,public_key);
-	chiffrement(bit_chiffre_twist_1,1,public_key);
-	dechiffrement(zero,bit_chiffre_twist_0,private_key);
-	dechiffrement(un,bit_chiffre_twist_1,private_key);
-	zout(zero,un);
-	
-	cout << "cas #1 0+0" << endl;
-	
-	//ecris(affichage de bit_chiffre_twist_0);
-	//bit_chiffre_twist_0.print();
-	chiffre_twist_somme=additionL1(bit_chiffre_twist_0,bit_chiffre_twist_0,public_key);
-	//ecris(affichage de chiffre_twist_somme);
-	//chiffre_twist_somme.print();
-	dechiffrement(somme,chiffre_twist_somme,private_key);
-	zout(somme);
-			
-	cout << "cas #2 0+1" << endl;
-
-	chiffre_twist_somme=additionL1(bit_chiffre_twist_0,bit_chiffre_twist_1,public_key);
-	dechiffrement(somme,chiffre_twist_somme,private_key);
-	zout(somme);
-		
-	cout << "cas #3 1+0" << endl;
-
-	//bit_chiffre_twist_0.print();
-	//bit_chiffre_twist_1.print();
-
-	chiffre_twist_somme=additionL1(bit_chiffre_twist_1,bit_chiffre_twist_0,public_key);
-	dechiffrement(somme,chiffre_twist_somme,private_key);
-	zout(somme);
-		
-	cout << "cas #4 1+1" << endl;
-	
-	chiffre_twist_somme=additionL1(bit_chiffre_twist_1,bit_chiffre_twist_1,public_key);
-	dechiffrement(somme,chiffre_twist_somme,private_key);
-	zout(somme);	
-	
-	JUMP;
-	cout << "taille d'un chiffré de niveau 1 de type curve = " << sizeof(bit_chiffre_curve_0) << " octets" << endl;
-	cout << "taille d'un chiffré de niveau 1 de type twist = " << sizeof(bit_chiffre_twist_0) << " octets" << endl;
-	//cout << "taille en octets de la somme de deux chiffrés de niveau 1 de type curve =" << sizeof(chiffre_curve_somme)<< endl;
-	//cout << "taille en octets de la somme de deux chiffrés de niveau 1 de type twist" << sizeof(chiffre_twist_somme)<< endl;
-	
-	
-
-}

bgn2/src/circuit_additionL1.hpp

@@ -1,22 +0,0 @@
-#ifndef __CIRCUIT_ADDITIONL1_HPP
-
-#define __CIRCUIT_ADDITIONL1_HPP
-
-#include <limits.h>		/* for CHAR_BIT */
-#include "typedef.h"
-#include "BitChiffre.hpp"
-#include "BitEvalL1.hpp"
-#include "chiffrement.hpp" 
-#include "keygen.hpp"
-#include "dechiffrement.hpp" 
-#include "additionL1.hpp"
-#include "multiplicationL1.hpp"
-#include "multiplicationL1L2.hpp"
-#include "additionL2.hpp"
-#include "additionL3.hpp"
-#include "precomputation.hpp"
-#include "postcomputation.hpp"
-
-void circuit_additionL1(PublicKey public_key, PrivateKey private_key);
-
-#endif /* __CIRCUIT_ADDITIONL1_HPP */

bgn2/src/circuit_additionL2.cpp

@@ -1,50 +0,0 @@
-#include "circuit_additionL2.hpp"
-void circuit_additionL2(PublicKey public_key, PrivateKey private_key)
-{
-	F2 un=0,zero=0, somme=0;
-	BitEvalL1<curvepoint_fp_t> bit_chiffre_0_curve, bit_chiffre_1_curve;
-	BitEvalL1<twistpoint_fp2_t> bit_chiffre_0_twist, bit_chiffre_1_twist;
-	BitEvalL2 chiffre_L2_0, chiffre_L2_1, chiffre_somme;
-	chiffrement(bit_chiffre_0_curve,0,public_key);
-	chiffrement(bit_chiffre_1_curve,1,public_key);
-	chiffrement(bit_chiffre_0_twist,0,public_key);
-	chiffrement(bit_chiffre_1_twist,1,public_key);	
-	chiffre_L2_0=multiplicationL1(bit_chiffre_0_curve,bit_chiffre_0_twist,public_key);
-	chiffre_L2_1=multiplicationL1(bit_chiffre_1_curve,bit_chiffre_1_twist,public_key);
-	//dechiffrementL2(zero,chiffre_L2_0,private_key);
-	//dechiffrementL2(un,chiffre_L2_1,private_key);
-	//zout(zero,un);
-		
-	cout << "cas #1 0+0" << endl;
-	
-	chiffre_somme=additionL2(chiffre_L2_0,chiffre_L2_0,public_key);
-	dechiffrementL2(somme,chiffre_somme,private_key);
-	zout(somme);
-		
-	cout << "cas #2 0+1" << endl;
-
-	chiffre_somme=additionL2(chiffre_L2_0,chiffre_L2_1,public_key);
-	dechiffrementL2(somme,chiffre_somme,private_key);
-	zout(somme);
-		
-	cout << "cas #3 1+0" << endl;
-
-	//chiffre_L2_0.print_bit_masque();
-	//chiffre_L2_1.print_bit_masque();
-
-	chiffre_somme=additionL2(chiffre_L2_1,chiffre_L2_0,public_key);
-	dechiffrementL2(somme,chiffre_somme,private_key);
-	zout(somme);
-	
-	//chiffre_somme.print_bit_masque();
-
-		
-	cout << "cas #4 1+1" << endl;
-	
-	chiffre_somme=additionL2(chiffre_L2_1,chiffre_L2_1,public_key);
-	dechiffrementL2(somme,chiffre_somme,private_key);
-	zout(somme);
-	
-	JUMP;
-	cout << "taille d'un chiffré de niveau 2 = " << sizeof(chiffre_L2_0) << " octets" << endl;
-}

bgn2/src/circuit_additionL2.hpp

@@ -1,24 +0,0 @@
-#ifndef __CIRCUIT_ADDITIONL2_HPP
-
-#define __CIRCUIT_ADDITIONL2_HPP
-
-#include <limits.h>		/* for CHAR_BIT */
-#include "typedef.h"
-#include "BitChiffre.hpp"
-#include "BitEvalL1.hpp"
-#include "BitEvalL2.hpp"
-#include "chiffrement.hpp" 
-#include "keygen.hpp"
-#include "dechiffrement.hpp" 
-#include "dechiffrementL2.hpp" 
-#include "additionL1.hpp"
-#include "multiplicationL1.hpp"
-#include "multiplicationL1L2.hpp"
-#include "additionL2.hpp"
-#include "additionL3.hpp"
-#include "precomputation.hpp"
-#include "postcomputation.hpp"
-
-void circuit_additionL2(PublicKey public_key, PrivateKey private_key);
-
-#endif /* __CIRCUIT_ADDITIONL2_HPP */

bgn2/src/circuit_chiffrement.cpp

@@ -1,45 +0,0 @@
-#include "circuit_chiffrement.hpp"
-
-void circuit_chiffrement(char lettre, PublicKey public_key, PrivateKey private_key)
-{
-	signature;
-	F2 bit_clair=0, bit_dechiffre=0; 
-	BitEvalL1<curvepoint_fp_t> bit_chiffre_curve;	
-	BitEvalL1<twistpoint_fp2_t> bit_chiffre_twist;	
-	for (unsigned int j=0; j<CHAR_BIT;j++) //pour chaque bit
-	{
-		bit_clair=bitset<CHAR_BIT>(lettre)[j] ;
-		//zout(bit_clair);
-		chiffrement(bit_chiffre_curve,bit_clair,public_key);
-		dechiffrement(bit_dechiffre,bit_chiffre_curve,private_key);
-		//zout(bit_dechiffre);
-		if (bit_clair != bit_dechiffre)
-		{
-			cout << BOLDRED << "KO" << endl;
-			exit(0);
-		}
-		cout << BOLDRED << "OK" << endl;
-		chiffrement(bit_chiffre_twist,bit_clair,public_key);
-		dechiffrement(bit_dechiffre,bit_chiffre_twist,private_key);
-		//zout(bit_dechiffre);
-		if (bit_clair != bit_dechiffre)
-		{
-			cout << BOLDRED << "KO" << endl;
-			exit(0);
-		}
-		cout << BOLDRED << "OK" << endl;		
-	}
-	//BitChiffre eval11, eval12;
-	//chiffrement(eval11,bit_clair,public_key,CURVE);
-	//chiffrement(eval12,bit_clair,public_key,TWIST);
-	//BitEvalL2 eval2= multiplicationL1 ( eval11, eval12, public_key);
-	//BitEvalL3 eval3= multiplicationL1L2 ( eval11, eval2, public_key);
-	//BitEvalL3 eval31 = multiplicationL1L2 ( eval11, eval2, public_key);
-	//BitEvalL3 eval32 = additionL3(eval31,eval31,public_key);
-	//BitEvalL3 eval33 = additionL3(eval32,eval32,public_key);
-	//BitEvalL3 eval34 = additionL3(eval33,eval33,public_key);
-	//BitEvalL3 eval35 = additionL3(eval31,eval33,public_key);
-	//BitEvalL3 eval36 = additionL3(eval33,eval31,public_key);
-
-	//zout(lettre, char(lettre+31), char(lettre+5));
-}

bgn2/src/circuit_chiffrement.hpp

@@ -1,21 +0,0 @@
-#ifndef __CIRCUIT_CHIFFREMENT_HPP
-
-#define __CIRCUIT_CHIFFREMENT_HPP
-
-#include <limits.h>		/* for CHAR_BIT */
-#include "typedef.h"
-#include "BitChiffre.hpp"
-#include "BitEvalL1.hpp"
-#include "chiffrement.hpp" 
-#include "keygen.hpp"
-#include "dechiffrement.hpp" 
-#include "additionL1.hpp"
-#include "multiplicationL1.hpp"
-#include "multiplicationL1L2.hpp"
-#include "additionL2.hpp"
-#include "additionL3.hpp"
-
-
-void circuit_chiffrement(char lettre, PublicKey public_key, PrivateKey private_key);
-
-#endif /* __CIRCUIT_CHIFFREMENT_HPP */

bgn2/src/circuit_demo.cpp

@@ -1,42 +0,0 @@
-#include "circuit_demo.hpp"
-
-
-void circuit_demo(char& evalue_dechiffre, char clair, PublicKey public_key, PrivateKey private_key)
-{
-	cout <<  "Tapez le caractère de votre choix" << endl;
-	zout(clair);	
-	F2 clair1=0, clair2=0, clair3=0; // resp de n8, n9, o8 (voir rapport.pdf, page 24)
-	precomputation(clair1, clair2, clair3, clair);
-	F2 curve, twist, quadripoint;
-	
-	BitEvalL1<curvepoint_fp_t> n8,n9;
-	BitEvalL1<twistpoint_fp2_t> o8;
-	chiffrement(n8,clair1,public_key);	
-	chiffrement(n9,clair2,public_key);	
-	chiffrement(o8,clair3,public_key);
-	grostitre(affichage des trois chiffrés correspondant aux trois bits utiles);
-	cout << "Un chiffré consiste en un bit et deux points de la courbe ou du twist" << endl;
-	n8.print();
-	n9.print();
-	o8.print();
-
-	BitEvalL1<curvepoint_fp_t> temp_curve, chiffre_1_curve;
-	BitEvalL1<twistpoint_fp2_t> temp_twist, chiffre_1_twist;
-	chiffrement(chiffre_1_curve,1, public_key);
-	chiffrement(chiffre_1_twist,1, public_key);
-	temp_curve = additionL1(chiffre_1_curve,n9,public_key);	//NB il faut rajouter CURVE pour passer de BitChiffre à BitEvalL1, la diff entre les deux, la taille mémoire
-	temp_twist = additionL1(chiffre_1_twist,o8,public_key);
-	
-	BitEvalL2 temp_quadripoint; // (1+n9)(1+o8)
-	temp_quadripoint = multiplicationL1(temp_curve,temp_twist,public_key);
-
-		
-	BitEvalL3 evalue; 	// n8(1+n9)(1+o8)	
-	evalue = multiplicationL1L2(n8,temp_quadripoint,public_key);	
-
-	cout << BOLDCYAN << "affichage de l'évalué" << RESET << endl;
-	cout << " Dans ce circuit, l'évalué consiste en 2*4 points du corps Fp^12 et deux points de la courbe" << endl;
-	evalue.print();
-	postcomputation(evalue_dechiffre, clair, evalue, private_key);	
-	zout(clair, evalue_dechiffre);
-}

bgn2/src/circuit_demo.hpp

@@ -1,24 +0,0 @@
-#ifndef __CIRCUIT_DEMO_HPP
-
-#define __CIRCUIT_DEMO_HPP
-
-#include <limits.h>		/* for CHAR_BIT */
-#include "typedef.h"
-#include "BitChiffre.hpp"
-#include "BitEvalL1.hpp"
-#include "chiffrement.hpp" 
-#include "keygen.hpp"
-#include "dechiffrement.hpp" 
-#include "additionL1.hpp"
-#include "multiplicationL1.hpp"
-#include "multiplicationL1L2.hpp"
-#include "additionL2.hpp"
-#include "additionL3.hpp"
-#include "precomputation.hpp"
-#include "postcomputation.hpp"
-
-
-
-void circuit_demo(char& rop, char symbol, PublicKey public_key, PrivateKey private_key);
-
-#endif /* __CIRCUIT_DEMO_HPP */

bgn2/src/circuit_ip.cpp

@@ -1,423 +0,0 @@
-#include "circuit_ip.hpp"
-
-void circuit_ip(PublicKey public_key, PrivateKey private_key)
-{
-	ecris(original server);
-	/** définition du plaintext clair **/
-	
-	
-	/** adresses ipv4s en clair **/
-	unsigned int adress_size=4;
-	vector<unsigned char> original_server = {10,0,1,10}; 
-	vector<unsigned char> cdn1 = {10,0,1,10};
-	vector<unsigned char> cdn2 = {10,1,1,10};
-	vector<unsigned char> cdn3 = {10,2,1,10};
-	vector<unsigned char> cdn4 = {10,3,1,10};
-	vector<unsigned char> receiver = {100,0,1,10};
-	vector<unsigned char> null={0,0,0,0};
-	
-	
-	vector<unsigned char> aes_key = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
-	vector<unsigned char> offset={0}; //obligé de mettre les {} avec vector contrairement à unsigned char
-	
-	vector<unsigned char> original_server_addr,original_server_dest,cdn1_addr,cdn1_source,cdn1_dest,cdn2_addr,cdn2_source,cdn2_dest,cdn3_addr,cdn3_source,cdn3_dest,cdn4_addr,cdn4_source,cdn4_dest;
-	
-	original_server_addr=original_server;
-	original_server_dest=cdn1; 
-	cdn1_addr=null; 
-	cdn1_source=null; 
-	cdn1_dest=null; 	
-	cdn2_addr=null; 
-	cdn2_source=null; 
-	cdn2_dest=null; 	
-	cdn3_addr=null; 
-	cdn3_source=null; 
-	cdn3_dest=null; 	
-	cdn4_addr=null; 
-	cdn4_source=null; 
-	cdn4_dest=null; 	
-	
-	vector<unsigned char> plaintext;
-	plaintext.reserve(aes_key.size()+offset.size()+original_server_addr.size()+original_server_dest.size()+cdn1_addr.size()+cdn1_source.size()+cdn1_dest.size()+cdn2_addr.size()+cdn2_source.size()+cdn2_dest.size()+cdn3_addr.size()+cdn3_source.size()+cdn3_dest.size()+cdn4_addr.size()+cdn4_source.size()+cdn4_dest.size());	
-	plaintext.insert(plaintext.end(), aes_key.begin(), aes_key.end());
-	plaintext.insert(plaintext.end(), offset.begin(), offset.end());
-	plaintext.insert(plaintext.end(), original_server_addr.begin(), original_server_addr.end());
-	plaintext.insert(plaintext.end(), original_server_dest.begin(), original_server_dest.end());
-	plaintext.insert(plaintext.end(), cdn1_addr.begin(), cdn1_addr.end());
-	plaintext.insert(plaintext.end(), cdn1_source.begin(), cdn1_source.end());
-	plaintext.insert(plaintext.end(), cdn1_dest.begin(), cdn1_dest.end());
-	plaintext.insert(plaintext.end(), cdn2_addr.begin(), cdn2_addr.end());
-	plaintext.insert(plaintext.end(), cdn2_source.begin(), cdn2_source.end());
-	plaintext.insert(plaintext.end(), cdn2_dest.begin(), cdn2_dest.end());	
-	plaintext.insert(plaintext.end(), cdn3_addr.begin(), cdn3_addr.end());
-	plaintext.insert(plaintext.end(), cdn3_source.begin(), cdn3_source.end());
-	plaintext.insert(plaintext.end(), cdn3_dest.begin(), cdn3_dest.end());	
-	plaintext.insert(plaintext.end(), cdn4_addr.begin(), cdn4_addr.end());
-	plaintext.insert(plaintext.end(), cdn4_source.begin(), cdn4_source.end());
-	plaintext.insert(plaintext.end(), cdn4_dest.begin(), cdn4_dest.end());
-	zout(plaintext.size());
-	
-	BitEvalL1<curvepoint_fp_t>  bit_chiffre_curve[plaintext.size()*CHAR_BIT], chiffre_poids_faible_offset_curve, chiffre_poids_fort_offset_curve;
-	BitEvalL1<twistpoint_fp2_t>  bit_chiffre_twist, chiffre_poids_faible_offset_twist, chiffre_poids_fort_offset_twist;
-	F2 bit_clair=0, poids_faible_offset=0, poids_fort_offset=0;
-	
-	//mode curve
-	for (unsigned int i=0; i<plaintext.size();i++)
-	{
-		printf("%u\t",plaintext[i]); //affichage des unsigned char avec printf, pas avec cout qui affiche les caractères
-		for (unsigned int j=0; j<CHAR_BIT;j++) //pour chaque bit
-		{
-			bit_clair=bitset<CHAR_BIT>(plaintext[i])[j] ;
-			chiffrement(bit_chiffre_curve[i*CHAR_BIT+j],bit_clair,public_key); //on chiffre le plaintext bit à bit en mode curve
-		}
-	}
-	jump;
-	chiffre_poids_faible_offset_curve=bit_chiffre_curve[128];//16*8+0=128
-	chiffre_poids_fort_offset_curve=bit_chiffre_curve[129];
-
-	//mode twist
-	bit_clair=bitset<CHAR_BIT>(plaintext[16])[0] ; //en plus, on chiffre les bit de l'offset (les 16 premiers unsigned char, c'est la clef AES) en mode twist
-	chiffrement(chiffre_poids_faible_offset_twist,bit_clair,public_key);	
-	bit_clair=bitset<CHAR_BIT>(plaintext[16])[1] ; 
-	chiffrement(chiffre_poids_fort_offset_twist,bit_clair,public_key);	
-
-	//dechiffrement(poids_faible_offset,chiffre_poids_faible_offset_curve,private_key);
-	//dechiffrement(poids_fort_offset,chiffre_poids_fort_offset_curve,private_key);
-	//zout(poids_faible_offset,poids_fort_offset);
-	//dechiffrement(poids_faible_offset,chiffre_poids_faible_offset_twist,private_key);
-	//dechiffrement(poids_fort_offset,chiffre_poids_fort_offset_twist,private_key);
-	//zout(poids_faible_offset,poids_fort_offset);
-	
-	
-	//serveur 1
-	ecris(CDN 1);
-	BitEvalL1<curvepoint_fp_t>  chiffre_IP1[12*adress_size*CHAR_BIT]; //12 IPs =  4 blocs de 3 IPs en bits 12*4*8=384 bits
-	BitEvalL2 is_zero, is_one, is_two, is_three;
-	BitEvalL1<curvepoint_fp_t> bit_chiffre_curve_0, bit_chiffre_curve_1;
-	BitEvalL1<twistpoint_fp2_t> bit_chiffre_twist_0, bit_chiffre_twist_1;
-	chiffrement(bit_chiffre_curve_0,0,public_key);
-	chiffrement(bit_chiffre_twist_0,0,public_key);
-	chiffrement(bit_chiffre_curve_1,1,public_key);
-	chiffrement(bit_chiffre_twist_1,1,public_key);
-	
-	for (unsigned int i=0; i<adress_size;i++)
-	{
-		for (unsigned int j=0; j<CHAR_BIT;j++) //pour chaque bit
-		{
-			bit_clair=bitset<CHAR_BIT>(cdn1[i])[j] ;
-			chiffrement(chiffre_IP1[i*CHAR_BIT+j],bit_clair,public_key); //on chiffre l'IP bit à bit en mode curve
-			//NB au lieu de cela, dans les faits, il faudra chiffrer 3 IPs concaténer 3*(nb CDN -1) IP à 0.0.0.0 puis permuter  ce chiffré par bloc de 3 IPs
-			//zout(i*CHAR_BIT+j);
-		}
-	}	
-	for (unsigned int i=0; i<adress_size;i++)
-	{
-		for (unsigned int j=0; j<CHAR_BIT;j++) //pour chaque bit
-		{
-			bit_clair=bitset<CHAR_BIT>(original_server[i])[j] ;
-			chiffrement(chiffre_IP1[32+i*CHAR_BIT+j],bit_clair,public_key); //on chiffre l'IP bit à bit en mode curve
-			//zout(32+i*CHAR_BIT+j);
-		}
-	}		
-	for (unsigned int i=0; i<adress_size;i++)
-	{
-		for (unsigned int j=0; j<CHAR_BIT;j++) //pour chaque bit
-		{
-			bit_clair=bitset<CHAR_BIT>(cdn2[i])[j] ;
-			chiffrement(chiffre_IP1[64+i*CHAR_BIT+j],bit_clair,public_key); //on chiffre l'IP bit à bit en mode curve
-			//zout(64+i*CHAR_BIT+j);
-			
-		}
-	}		
-	for (unsigned int i=0; i<9*CHAR_BIT*adress_size;i++) //on chiffre les 9 IP restantes
-	{
-		chiffrement(chiffre_IP1[96+i],0,public_key); //on chiffre l'IP bit à bit en mode curve
-		//zout(96+i);
-	}	
-		
-	//incrémentation du offset (2 bits) modulo 4
-	
-	chiffre_poids_fort_offset_curve=additionL1(chiffre_poids_fort_offset_curve,chiffre_poids_faible_offset_curve,public_key);
-	chiffre_poids_fort_offset_twist=additionL1(chiffre_poids_fort_offset_twist,chiffre_poids_faible_offset_twist,public_key);	//poids fort twist	
-	chiffre_poids_faible_offset_curve=additionL1(chiffre_poids_faible_offset_curve,bit_chiffre_curve_1,public_key); //poids faible curve
-	//chiffre_poids_faible_offset_twist=additionL1(chiffre_poids_faible_offset_twist,bit_chiffre_twist_1,public_key);
-
-
-	//dechiffrement(poids_faible_offset,chiffre_poids_faible_offset_curve,private_key);
-	//dechiffrement(poids_fort_offset,chiffre_poids_fort_offset_curve,private_key);
-	//zout(poids_faible_offset,poids_fort_offset);
-	//dechiffrement(poids_faible_offset,chiffre_poids_faible_offset_twist,private_key);
-	//dechiffrement(poids_fort_offset,chiffre_poids_fort_offset_twist,private_key);
-	//zout(poids_faible_offset,poids_fort_offset);
-		
-	//4 tests d'égalité --> x1,x2,x3,x4
-	
-	BitEvalL1<curvepoint_fp_t> faible_plus_zero_curve, faible_plus_one_curve, fort_plus_zero_curve, fort_plus_one_curve;
-	BitEvalL1<twistpoint_fp2_t> faible_plus_zero_twist, faible_plus_one_twist, fort_plus_zero_twist, fort_plus_one_twist;
-	faible_plus_zero_curve=additionL1(chiffre_poids_faible_offset_curve,bit_chiffre_curve_0, public_key);
-	faible_plus_one_curve=additionL1(chiffre_poids_faible_offset_curve,bit_chiffre_curve_1, public_key);
-	//fort_plus_zero_curve=additionL1(chiffre_poids_fort_offset_curve,bit_chiffre_curve_0, public_key);
-	//fort_plus_one_curve=additionL1(chiffre_poids_fort_offset_curve,bit_chiffre_curve_1, public_key);
-	//faible_plus_zero_twist=additionL1(chiffre_poids_faible_offset_twist,bit_chiffre_twist_0, public_key);
-	//faible_plus_one_twist=additionL1(chiffre_poids_faible_offset_twist,bit_chiffre_twist_1, public_key);
-	fort_plus_zero_twist=additionL1(chiffre_poids_fort_offset_twist,bit_chiffre_twist_0, public_key);
-	fort_plus_one_twist=additionL1(chiffre_poids_fort_offset_twist,bit_chiffre_twist_1, public_key);	
-	
-	is_zero=multiplicationL1(faible_plus_one_curve,fort_plus_one_twist,public_key); // 00 +1 +1
-	is_one=multiplicationL1(faible_plus_one_curve,fort_plus_zero_twist,public_key); //01 +1 +0
-	is_two=multiplicationL1(faible_plus_zero_curve,fort_plus_one_twist,public_key); //10  +0 +1
-	is_three=multiplicationL1(faible_plus_zero_curve,fort_plus_zero_twist,public_key); //11 +0 +0
-	
-	//porte conditionnelle/select sur tous les bits des IP à MAJ par le serveur 1
-	// select(x1,bit de IP1,bit de null) or select (x2,bit de IP1,bit de null) or select(x3,bit de IP1,bit de null) or select (x4,bit de IP1,bit de null)
-	
-	cout << "Incrémentation OK, test d'égalité OK, MAJ KO. On ne peut pas réaliser qu'une seule MAJ avec le circuit. Le circuit est de profondeur 1 + nb de MAJs." << endl;
-	//BitEvalL3 evalue[384];
-	////si compteur=0
-	//for (int i=0; i<384; i++)
-	//{
-		//multiplicationL1L2(,,public_key);
-		//multiplicationL1L2(,,public_key);
-		//evalue[i]=additionL3(,,public_key);
-	//}
-	////si compteur=1
-	//for (int i=0; i<384; i++)
-	//{
-		//multiplicationL1L2(,,public_key);
-		//multiplicationL1L2(,,public_key);
-		//evalue[i]=additionL3(,,public_key);
-	//}
-	////si compteur=2
-	//for (int i=0; i<384; i++)
-	//{
-		//multiplicationL1L2(,,public_key);
-		//multiplicationL1L2(,,public_key);
-		//evalue[i]=additionL3(,,public_key);
-	//}
-	////si compteur=3
-	//for (int i=0; i<384; i++)
-	//{
-		//multiplicationL1L2(,,public_key);
-		//multiplicationL1L2(,,public_key);
-		//evalue[i]=additionL3(,,public_key);
-	//}		
-	
-	//serveur 2
-	ecris(CDN 2);
-	
-	BitEvalL1<curvepoint_fp_t>  chiffre_IP2[12*adress_size*CHAR_BIT];
-	for (unsigned int i=0; i<adress_size;i++)
-	{
-		for (unsigned int j=0; j<CHAR_BIT;j++) //pour chaque bit
-		{
-			bit_clair=bitset<CHAR_BIT>(cdn2[i])[j] ;
-			chiffrement(chiffre_IP2[i*CHAR_BIT+j],bit_clair,public_key); //on chiffre l'IP bit à bit en mode curve
-			//NB au lieu de cela, dans les faits, il faudra chiffrer 3 IPs concaténer 3*(nb CDN -1) IP à 0.0.0.0 puis permuter  ce chiffré par bloc de 3 IPs
-		}
-	}	
-	for (unsigned int i=0; i<adress_size;i++)
-	{
-		for (unsigned int j=0; j<CHAR_BIT;j++) //pour chaque bit
-		{
-			bit_clair=bitset<CHAR_BIT>(cdn1[i])[j] ;
-			chiffrement(chiffre_IP2[32+i*CHAR_BIT+j],bit_clair,public_key); //on chiffre l'IP bit à bit en mode curve
-		}
-	}		
-	for (unsigned int i=0; i<adress_size;i++)
-	{
-		for (unsigned int j=0; j<CHAR_BIT;j++) //pour chaque bit
-		{
-			bit_clair=bitset<CHAR_BIT>(cdn3[i])[j] ;
-			chiffrement(chiffre_IP2[64+i*CHAR_BIT+j],bit_clair,public_key); //on chiffre l'IP bit à bit en mode curve
-			
-		}
-	}		
-	for (unsigned int i=0; i<9*CHAR_BIT*adress_size;i++) //on chiffre les 9 IP restantes
-	{
-		chiffrement(chiffre_IP2[96+i],0,public_key); //on chiffre l'IP bit à bit en mode curve
-	}		
-
-	chiffre_poids_fort_offset_curve=additionL1(chiffre_poids_fort_offset_curve,chiffre_poids_faible_offset_curve,public_key);
-	chiffre_poids_fort_offset_twist=additionL1(chiffre_poids_fort_offset_twist,chiffre_poids_faible_offset_twist,public_key);	
-	chiffre_poids_faible_offset_curve=additionL1(chiffre_poids_faible_offset_curve,bit_chiffre_curve_1,public_key);
-	//chiffre_poids_faible_offset_twist=additionL1(chiffre_poids_faible_offset_twist,bit_chiffre_twist_1,public_key);
-
-
-	//dechiffrement(poids_faible_offset,chiffre_poids_faible_offset_curve,private_key);
-	//dechiffrement(poids_fort_offset,chiffre_poids_fort_offset_curve,private_key);
-	//zout(poids_faible_offset,poids_fort_offset);
-	//dechiffrement(poids_faible_offset,chiffre_poids_faible_offset_twist,private_key);
-	//dechiffrement(poids_fort_offset,chiffre_poids_fort_offset_twist,private_key);
-	//zout(poids_faible_offset,poids_fort_offset);
-	
-	//4 tests d'égalité --> x1,x2,x3,x4
-	
-	faible_plus_zero_curve=additionL1(chiffre_poids_faible_offset_curve,bit_chiffre_curve_0, public_key);
-	faible_plus_one_curve=additionL1(chiffre_poids_faible_offset_curve,bit_chiffre_curve_1, public_key);
-	//fort_plus_zero_curve=additionL1(chiffre_poids_fort_offset_curve,bit_chiffre_curve_0, public_key);
-	//fort_plus_one_curve=additionL1(chiffre_poids_fort_offset_curve,bit_chiffre_curve_1, public_key);
-	//faible_plus_zero_twist=additionL1(chiffre_poids_faible_offset_twist,bit_chiffre_twist_0, public_key);
-	//faible_plus_one_twist=additionL1(chiffre_poids_faible_offset_twist,bit_chiffre_twist_1, public_key);
-	fort_plus_zero_twist=additionL1(chiffre_poids_fort_offset_twist,bit_chiffre_twist_0, public_key);
-	fort_plus_one_twist=additionL1(chiffre_poids_fort_offset_twist,bit_chiffre_twist_1, public_key);	
-	
-	is_zero=multiplicationL1(faible_plus_one_curve,fort_plus_one_twist,public_key); // 00 +1 +1
-	is_one=multiplicationL1(faible_plus_one_curve,fort_plus_zero_twist,public_key); //01 +1 +0
-	is_two=multiplicationL1(faible_plus_zero_curve,fort_plus_one_twist,public_key); //10  +0 +1
-	is_three=multiplicationL1(faible_plus_zero_curve,fort_plus_zero_twist,public_key); //11 +0 +0	
-	
-	
-	//exit(0);	
-		
-	//serveur 3
-	ecris(CDN 3);
-
-	BitEvalL1<curvepoint_fp_t>  chiffre_IP3[12*adress_size*CHAR_BIT];
-	for (unsigned int i=0; i<adress_size;i++)
-	{
-		for (unsigned int j=0; j<CHAR_BIT;j++) //pour chaque bit
-		{
-			bit_clair=bitset<CHAR_BIT>(cdn3[i])[j] ;
-			chiffrement(chiffre_IP3[i*CHAR_BIT+j],bit_clair,public_key); //on chiffre l'IP bit à bit en mode curve
-			//NB au lieu de cela, dans les faits, il faudra chiffrer 3 IPs concaténer 3*(nb CDN -1) IP à 0.0.0.0 puis permuter  ce chiffré par bloc de 3 IPs
-		}
-	}	
-	for (unsigned int i=0; i<adress_size;i++)
-	{
-		for (unsigned int j=0; j<CHAR_BIT;j++) //pour chaque bit
-		{
-			bit_clair=bitset<CHAR_BIT>(cdn2[i])[j] ;
-			chiffrement(chiffre_IP3[32+i*CHAR_BIT+j],bit_clair,public_key); //on chiffre l'IP bit à bit en mode curve
-		}
-	}		
-	for (unsigned int i=0; i<adress_size;i++)
-	{
-		for (unsigned int j=0; j<CHAR_BIT;j++) //pour chaque bit
-		{
-			bit_clair=bitset<CHAR_BIT>(cdn4[i])[j] ;
-			chiffrement(chiffre_IP3[64+i*CHAR_BIT+j],bit_clair,public_key); //on chiffre l'IP bit à bit en mode curve
-			
-		}
-	}		
-	for (unsigned int i=0; i<9*CHAR_BIT*adress_size;i++) //on chiffre les 9 IP restantes
-	{
-		chiffrement(chiffre_IP3[96+i],0,public_key); //on chiffre l'IP bit à bit en mode curve
-	}		
-
-	chiffre_poids_fort_offset_curve=additionL1(chiffre_poids_fort_offset_curve,chiffre_poids_faible_offset_curve,public_key);
-	chiffre_poids_fort_offset_twist=additionL1(chiffre_poids_fort_offset_twist,chiffre_poids_faible_offset_twist,public_key);	
-	chiffre_poids_faible_offset_curve=additionL1(chiffre_poids_faible_offset_curve,bit_chiffre_curve_1,public_key);
-	//chiffre_poids_faible_offset_twist=additionL1(chiffre_poids_faible_offset_twist,bit_chiffre_twist_1,public_key);
-	
-
-	//dechiffrement(poids_faible_offset,chiffre_poids_faible_offset_curve,private_key);
-	//dechiffrement(poids_fort_offset,chiffre_poids_fort_offset_curve,private_key);
-	//zout(poids_faible_offset,poids_fort_offset);
-	//dechiffrement(poids_faible_offset,chiffre_poids_faible_offset_twist,private_key);
-	//dechiffrement(poids_fort_offset,chiffre_poids_fort_offset_twist,private_key);
-	//zout(poids_faible_offset,poids_fort_offset);
-
-
-	//4 tests d'égalité --> x1,x2,x3,x4
-	
-	faible_plus_zero_curve=additionL1(chiffre_poids_faible_offset_curve,bit_chiffre_curve_0, public_key);
-	faible_plus_one_curve=additionL1(chiffre_poids_faible_offset_curve,bit_chiffre_curve_1, public_key);
-	//fort_plus_zero_curve=additionL1(chiffre_poids_fort_offset_curve,bit_chiffre_curve_0, public_key);
-	//fort_plus_one_curve=additionL1(chiffre_poids_fort_offset_curve,bit_chiffre_curve_1, public_key);
-	//faible_plus_zero_twist=additionL1(chiffre_poids_faible_offset_twist,bit_chiffre_twist_0, public_key);
-	//faible_plus_one_twist=additionL1(chiffre_poids_faible_offset_twist,bit_chiffre_twist_1, public_key);
-	fort_plus_zero_twist=additionL1(chiffre_poids_fort_offset_twist,bit_chiffre_twist_0, public_key);
-	fort_plus_one_twist=additionL1(chiffre_poids_fort_offset_twist,bit_chiffre_twist_1, public_key);	
-	
-	is_zero=multiplicationL1(faible_plus_one_curve,fort_plus_one_twist,public_key); // 00 +1 +1
-	is_one=multiplicationL1(faible_plus_one_curve,fort_plus_zero_twist,public_key); //01 +1 +0
-	is_two=multiplicationL1(faible_plus_zero_curve,fort_plus_one_twist,public_key); //10  +0 +1
-	is_three=multiplicationL1(faible_plus_zero_curve,fort_plus_zero_twist,public_key); //11 +0 +0	
-		
-	//serveur 4
-	ecris(CDN 4);
-
-	BitEvalL1<curvepoint_fp_t>  chiffre_IP4[12*adress_size*CHAR_BIT];
-	for (unsigned int i=0; i<adress_size;i++)
-	{
-		for (unsigned int j=0; j<CHAR_BIT;j++) //pour chaque bit
-		{
-			bit_clair=bitset<CHAR_BIT>(cdn4[i])[j] ;
-			chiffrement(chiffre_IP4[i*CHAR_BIT+j],bit_clair,public_key); //on chiffre l'IP bit à bit en mode curve
-			//NB au lieu de cela, dans les faits, il faudra chiffrer 3 IPs concaténer 3*(nb CDN -1) IP à 0.0.0.0 puis permuter  ce chiffré par bloc de 3 IPs
-		}
-	}	
-	for (unsigned int i=0; i<adress_size;i++)
-	{
-		for (unsigned int j=0; j<CHAR_BIT;j++) //pour chaque bit
-		{
-			bit_clair=bitset<CHAR_BIT>(cdn3[i])[j] ;
-			chiffrement(chiffre_IP4[32+i*CHAR_BIT+j],bit_clair,public_key); //on chiffre l'IP bit à bit en mode curve
-		}
-	}		
-	for (unsigned int i=0; i<adress_size;i++)
-	{
-		for (unsigned int j=0; j<CHAR_BIT;j++) //pour chaque bit
-		{
-			bit_clair=bitset<CHAR_BIT>(receiver[i])[j] ;
-			chiffrement(chiffre_IP4[64+i*CHAR_BIT+j],bit_clair,public_key); //on chiffre l'IP bit à bit en mode curve
-			
-		}
-	}		
-	for (unsigned int i=0; i<9*CHAR_BIT*adress_size;i++) //on chiffre les 9 IP restantes
-	{
-		chiffrement(chiffre_IP4[96+i],0,public_key); //on chiffre l'IP bit à bit en mode curve
-	}	
-
-	chiffre_poids_fort_offset_curve=additionL1(chiffre_poids_fort_offset_curve,chiffre_poids_faible_offset_curve,public_key);
-	chiffre_poids_fort_offset_twist=additionL1(chiffre_poids_fort_offset_twist,chiffre_poids_faible_offset_twist,public_key);	
-	chiffre_poids_faible_offset_curve=additionL1(chiffre_poids_faible_offset_curve,bit_chiffre_curve_1,public_key);
-	//chiffre_poids_faible_offset_twist=additionL1(chiffre_poids_faible_offset_twist,bit_chiffre_twist_1,public_key);
-
-	
-	//dechiffrement(poids_faible_offset,chiffre_poids_faible_offset_curve,private_key);
-	//dechiffrement(poids_fort_offset,chiffre_poids_fort_offset_curve,private_key);
-	//zout(poids_faible_offset,poids_fort_offset);
-	//dechiffrement(poids_faible_offset,chiffre_poids_faible_offset_twist,private_key);
-	//dechiffrement(poids_fort_offset,chiffre_poids_fort_offset_twist,private_key);
-	//zout(poids_faible_offset,poids_fort_offset);
-	
-	//4 tests d'égalité --> x1,x2,x3,x4
-	
-	faible_plus_zero_curve=additionL1(chiffre_poids_faible_offset_curve,bit_chiffre_curve_0, public_key);
-	faible_plus_one_curve=additionL1(chiffre_poids_faible_offset_curve,bit_chiffre_curve_1, public_key);
-	//fort_plus_zero_curve=additionL1(chiffre_poids_fort_offset_curve,bit_chiffre_curve_0, public_key);
-	//fort_plus_one_curve=additionL1(chiffre_poids_fort_offset_curve,bit_chiffre_curve_1, public_key);
-	//faible_plus_zero_twist=additionL1(chiffre_poids_faible_offset_twist,bit_chiffre_twist_0, public_key);
-	//faible_plus_one_twist=additionL1(chiffre_poids_faible_offset_twist,bit_chiffre_twist_1, public_key);
-	fort_plus_zero_twist=additionL1(chiffre_poids_fort_offset_twist,bit_chiffre_twist_0, public_key);
-	fort_plus_one_twist=additionL1(chiffre_poids_fort_offset_twist,bit_chiffre_twist_1, public_key);	
-	
-	is_zero=multiplicationL1(faible_plus_one_curve,fort_plus_one_twist,public_key); // 00 +1 +1 a égale b = a nxor b = a xor non b
-	is_one=multiplicationL1(faible_plus_one_curve,fort_plus_zero_twist,public_key); //01 +1 +0
-	is_two=multiplicationL1(faible_plus_zero_curve,fort_plus_one_twist,public_key); //10  +0 +1
-	is_three=multiplicationL1(faible_plus_zero_curve,fort_plus_zero_twist,public_key); //11 +0 +0	
-		
-	//contenu final
-	//unsigned char cdn1[4]= {0x0A,0x01,0x01,0x0A};
-	//unsigned char cdn1_source[4]= {0x0A,0x00,0x01,0x0A};
-	//unsigned char cdn1_dest[4]= {0x0A,0x02,0x01,0x0A};
-	//unsigned char cdn2[4]= {0x0A,0x02,0x01,0x0A};
-	//unsigned char cdn2_source[4]= {0x0A,0x01,0x01,0x0A};
-	//unsigned char cdn2_dest[4]= {0x0A,0x03,0x01,0x0A};	
-	//unsigned char cdn3[4]= {0x0A,0x03,0x01,0x0A};
-	//unsigned char cdn3_source[4]= {0x0A,0x02,0x01,0x0A};
-	//unsigned char cdn3_dest[4]= {0x0A,0x04,0x01,0x0A};	
-	//unsigned char cdn4[4]= {0x0A,0x01,0x04,0x0A};
-	//unsigned char cdn4_source[4]= {0x0A,0x03,0x01,0x0A};
-	//unsigned char cdn4_dest[4]= {0x64,0x01,0x01,0x0A};	//6*16+4
-	
-	/** compteur (2 bits) + 1 modulo 4, 2 circuits (1 entrée: bit de poids faible et 2 entrées:bit de l'offset) de profondeur 0, 4 serveurs **/
-	
-	/** 4 tests d'égalité, 1 circuit de profondeur 1 (2 entrées:bits de l'offset)**/
-	
-	/** si vrai alors bit de 192.0.0.1 sinon bit de 0.0.0.0 (3 entrées:2 bits de l'offset et 1 bit de l'IP)**/
-	
-	/** chaque cdn fait les tests d'égalité une seule fois **/
-	 
-}

bgn2/src/circuit_ip.hpp

@@ -1,11 +0,0 @@
-#ifndef __CIRCUIT_IP_HPP
-
-#define __CIRCUIT_IP_HPP
-
-#include "keygen.hpp"
-#include <string>
-#include <vector>
-
-void circuit_ip(PublicKey public_key, PrivateKey private_key);
-
-#endif /* __CIRCUIT_IP_HPP */

bgn2/src/circuit_minmaj.cpp

@@ -1,48 +0,0 @@
-#include "circuit_minmaj.hpp"
-
-
-void circuit_minmaj(char& rop, char symbole, PublicKey public_key, PrivateKey private_key)
-{
-	//signature;
-	
-	F2 clair1=0, clair2=0, clair3=0; // resp de n8, n9, o8 (voir rapport.pdf, page 24)
-	precomputation(clair1, clair2, clair3, symbole);
-	F2 curve, twist, quadripoint;
-	//F2 clair_n8, clair_n9, clair_o8;
-	
-	//BitChiffre n8,n9,o8;
-	BitEvalL1<curvepoint_fp_t> n8,n9;
-	BitEvalL1<twistpoint_fp2_t> o8;
-	chiffrement(n8,clair1,public_key);	
-	chiffrement(n9,clair2,public_key);	
-	chiffrement(o8,clair3,public_key);
-	//zout(sizeof(n8),sizeof(o8));
-	//dechiffrement(clair_n8,n8,private_key,CURVE);
-	//dechiffrement(clair_n9,n9,private_key,CURVE);
-	//dechiffrement(clair_o8,o8,private_key,TWIST);	
-	
-	//BitChiffre temp_curve, temp_twist; //resp 1+n9 et 1+o8
-	//BitChiffre chiffre_1_curve, chiffre_1_twist;
-	BitEvalL1<curvepoint_fp_t> temp_curve, chiffre_1_curve;
-	BitEvalL1<twistpoint_fp2_t> temp_twist, chiffre_1_twist;
-	chiffrement(chiffre_1_curve,1, public_key);
-	chiffrement(chiffre_1_twist,1, public_key);
-	temp_curve = additionL1(chiffre_1_curve,n9,public_key);	//NB il faut rajouter CURVE pour passer de BitChiffre à BitEvalL1, la diff entre les deux, la taille mémoire
-	temp_twist = additionL1(chiffre_1_twist,o8,public_key);
-	//dechiffrement(curve,temp_curve,private_key,CURVE);
-	//dechiffrement(twist,temp_twist,private_key,TWIST);
-	
-	BitEvalL2 temp_quadripoint; // (1+n9)(1+o8)
-	temp_quadripoint = multiplicationL1(temp_curve,temp_twist,public_key);
-	//dechiffrementL2(quadripoint,temp_quadripoint,private_key);
-
-	//zout(clair1,clair2,clair3);
-	//zout(curve,twist,quadripoint); 
-		
-	BitEvalL3 evalue; 	// n8(1+n9)(1+o8)	
-	evalue = multiplicationL1L2(n8,temp_quadripoint,public_key);
-	//jump;
-	//zout(sizeof(evalue),sizeof(evalue.get_vec_bipoints()),sizeof(evalue.get_vec_quadripoints()),sizeof(evalue.get_alpha()),sizeof(temp_quadripoint.get_bit_masque()),sizeof(temp_quadripoint.get_quadripoint()));
-	
-	postcomputation(rop, symbole, evalue, private_key);	
-}

bgn2/src/circuit_minmaj.hpp

@@ -1,24 +0,0 @@
-#ifndef __CIRCUIT_MINMAJ_HPP
-
-#define __CIRCUIT_MINMAJ_HPP
-
-#include <limits.h>		/* for CHAR_BIT */
-#include "typedef.h"
-#include "BitChiffre.hpp"
-#include "BitEvalL1.hpp"
-#include "chiffrement.hpp" 
-#include "keygen.hpp"
-#include "dechiffrement.hpp" 
-#include "additionL1.hpp"
-#include "multiplicationL1.hpp"
-#include "multiplicationL1L2.hpp"
-#include "additionL2.hpp"
-#include "additionL3.hpp"
-#include "precomputation.hpp"
-#include "postcomputation.hpp"
-
-
-
-void circuit_minmaj(char& rop, char symbol, PublicKey public_key, PrivateKey private_key);
-
-#endif /* __CIRCUIT_MINMAJ_HPP */

bgn2/src/circuit_minmaj2.cpp

@@ -1,51 +0,0 @@
-#include "circuit_minmaj2.hpp"
-
-
-void circuit_minmaj2(char& rop, char symbole, PublicKey public_key, PrivateKey private_key)
-{	
-	F2 clair1=0, clair2=0, clair3=0; 
-	clair1=bitset<sizeof(int)*CHAR_BIT>(symbole)[5] ; 
-	clair2=bitset<sizeof(int)*CHAR_BIT>(symbole)[6] ;
-	clair3=bitset<sizeof(int)*CHAR_BIT>(symbole)[7] ; 
-	
-	
-	BitEvalL1<twistpoint_fp2_t> m6;
-	BitEvalL1<curvepoint_fp_t> m7,m8;
-	
-	chiffrement(m6,clair1,public_key);	
-	chiffrement(m7,clair2,public_key);	
-	chiffrement(m8,clair3,public_key);
-
-	BitEvalL1<curvepoint_fp_t> temp_curve, chiffre_1_curve;
-	BitEvalL1<twistpoint_fp2_t> temp_twist, chiffre_1_twist;
-	chiffrement(chiffre_1_curve,1, public_key);
-	chiffrement(chiffre_1_twist, 1, public_key);
-
-	temp_curve = additionL1(chiffre_1_curve,m8,public_key);	//calcul 1+m8
-
-	
-	BitEvalL2 temp_quadripoint; // m6(1+m8)
-	temp_quadripoint = multiplicationL1(temp_curve,m6,public_key);
-		
-	BitEvalL2 chiffre_L2_1;	
-	BitEvalL3 temp_L3, evalue, chiffre_L3_1; 	// m6m7(1+m8)	
-	chiffre_L2_1 = multiplicationL1(chiffre_1_curve,chiffre_1_twist,public_key);
-	chiffre_L3_1=multiplicationL1L2(chiffre_1_curve,chiffre_L2_1,public_key);
-	temp_L3 = multiplicationL1L2(m7,temp_quadripoint,public_key);		
-	evalue=additionL3(temp_L3,chiffre_L3_1,public_key);
-	
-	F2 IS_LOWER_CASE=0;
-	dechiffrementL3(IS_LOWER_CASE,evalue,private_key);
-	char symbole_dechiffree=symbole;
-	if (IS_LOWER_CASE == 0)
-	{
-		//cout << symbole << " est sensé être une minuscule!" << endl;
-		symbole_dechiffree=char(symbole-32);
-	}
-	else
-	{
-		//cout << symbole << " est sensé ne pas être une minuscule!" << endl;
-	}
-	cout << symbole_dechiffree << flush;
-
-}

bgn2/src/circuit_minmaj2.hpp

@@ -1,24 +0,0 @@
-#ifndef __CIRCUIT_MINMAJ2_HPP
-
-#define __CIRCUIT_MINMAJ2_HPP
-
-#include <limits.h>		/* for CHAR_BIT */
-#include "typedef.h"
-#include "BitChiffre.hpp"
-#include "BitEvalL1.hpp"
-#include "chiffrement.hpp" 
-#include "keygen.hpp"
-#include "dechiffrement.hpp" 
-#include "additionL1.hpp"
-#include "multiplicationL1.hpp"
-#include "multiplicationL1L2.hpp"
-#include "additionL2.hpp"
-#include "additionL3.hpp"
-#include "precomputation.hpp"
-#include "postcomputation.hpp"
-
-
-
-void circuit_minmaj2(char& rop, char symbol, PublicKey public_key, PrivateKey private_key);
-
-#endif /* __CIRCUIT_MINMAJ2_HPP */

bgn2/src/circuit_minmaj3.cpp

@@ -1,33 +0,0 @@
-#include "circuit_minmaj3.hpp"
-
-
-void circuit_minmaj3(char& rop, char symbole, PublicKey public_key, PrivateKey private_key)
-{	
-	F2 clair1=0, clair2=0, clair3=0; 
-	clair1=bitset<sizeof(int)*CHAR_BIT>(symbole)[5] ; 
-	clair2=bitset<sizeof(int)*CHAR_BIT>(symbole)[6] ;
-	clair3=bitset<sizeof(int)*CHAR_BIT>(symbole)[7] ; 
-	
-	
-	BitEvalL1<twistpoint_fp2_t> m6;
-	BitEvalL1<curvepoint_fp_t> m7,m8;
-	
-	chiffrement(m6,clair1,public_key);	
-	chiffrement(m7,clair2,public_key);	
-	chiffrement(m8,clair3,public_key);
-
-	BitEvalL1<curvepoint_fp_t> temp_curve, chiffre_1_curve;
-	BitEvalL1<twistpoint_fp2_t> temp_twist;
-	chiffrement(chiffre_1_curve,1, public_key);
-
-	temp_curve = additionL1(chiffre_1_curve,m8,public_key);	//calcul 1+m8
-
-	
-	BitEvalL2 temp_quadripoint; // m6(1+m8)
-	temp_quadripoint = multiplicationL1(temp_curve,m6,public_key);
-		
-	BitEvalL3 evalue; 	// m6m7(1+m8)	
-	evalue = multiplicationL1L2(m7,temp_quadripoint,public_key);	
-
-	postcomputation(rop, symbole, evalue, private_key);	
-}

bgn2/src/circuit_minmaj3.hpp

@@ -1,24 +0,0 @@
-#ifndef __CIRCUIT_MINMAJ3_HPP
-
-#define __CIRCUIT_MINMAJ3_HPP
-
-#include <limits.h>		/* for CHAR_BIT */
-#include "typedef.h"
-#include "BitChiffre.hpp"
-#include "BitEvalL1.hpp"
-#include "chiffrement.hpp" 
-#include "keygen.hpp"
-#include "dechiffrement.hpp" 
-#include "additionL1.hpp"
-#include "multiplicationL1.hpp"
-#include "multiplicationL1L2.hpp"
-#include "additionL2.hpp"
-#include "additionL3.hpp"
-#include "precomputation.hpp"
-#include "postcomputation.hpp"
-
-
-
-void circuit_minmaj3(char& rop, char symbol, PublicKey public_key, PrivateKey private_key);
-
-#endif /* __CIRCUIT_MINMAJ3_HPP */

bgn2/src/circuit_multiplicationL1.cpp

@@ -1,71 +0,0 @@
-#include "circuit_multiplicationL1.hpp"
-void circuit_multiplicationL1(PublicKey public_key, PrivateKey private_key)
-{
-	F2 un_curve=0,zero_curve=0, produit=0, zero_twist=0, un_twist=0;
-	BitEvalL1<curvepoint_fp_t> bit_chiffre_0_curve, bit_chiffre_1_curve;
-	BitEvalL1<twistpoint_fp2_t> bit_chiffre_0_twist, bit_chiffre_1_twist;
-	BitEvalL2 chiffre_produit;
-	
-	chiffrement(bit_chiffre_0_curve,0,public_key);
-	chiffrement(bit_chiffre_1_curve,1,public_key);
-	chiffrement(bit_chiffre_0_twist,0,public_key);
-	chiffrement(bit_chiffre_1_twist,1,public_key);
-	//dechiffrement(zero_curve,bit_chiffre_0_curve,private_key);
-	//dechiffrement(un_curve,bit_chiffre_1_curve,private_key);
-	//dechiffrement(zero_twist,bit_chiffre_0_twist,private_key);
-	//dechiffrement(un_twist,bit_chiffre_1_twist,private_key);		
-	//zout(zero_curve,un_curve,zero_twist,un_twist);
-	
-	
-	cout << "cas #1 0*0" << endl;
-	
-	chiffre_produit=multiplicationL1(bit_chiffre_0_curve,bit_chiffre_0_twist,public_key);
-	dechiffrementL2(produit,chiffre_produit,private_key);
-	zout(produit);
-		
-	cout << "cas #2 0*1" << endl;
-
-	chiffre_produit=multiplicationL1(bit_chiffre_0_curve,bit_chiffre_1_twist,public_key);
-	dechiffrementL2(produit,chiffre_produit,private_key);
-	zout(produit);
-		
-	cout << "cas #3 1*0" << endl;
-
-	//bit_chiffre_0.print();
-	//bit_chiffre_1.print();
-
-	chiffre_produit=multiplicationL1(bit_chiffre_1_curve,bit_chiffre_0_twist,public_key);
-	dechiffrementL2(produit,chiffre_produit,private_key);
-	zout(produit);
-		
-	cout << "cas #4 1*1" << endl;
-	
-	chiffre_produit=multiplicationL1(bit_chiffre_1_curve,bit_chiffre_1_twist,public_key);
-	dechiffrementL2(produit,chiffre_produit,private_key);
-	zout(produit);
-	
-	//cout << "cas #5 (1+0)*1" << endl; 
-	//BitChiffre temp_curve = additionL1(bit_chiffre_1_curve,bit_chiffre_0_curve,public_key);	
-	//chiffre_produit=multiplicationL1(temp_curve,bit_chiffre_1_twist,public_key);
-	//dechiffrementL2(produit,chiffre_produit,private_key);
-	//zout(produit);	
-	
-	//cout << "cas #6 (1+0)*(1+0)" << endl; 
-	//BitChiffre temp_twist = additionL1(bit_chiffre_1_twist,bit_chiffre_0_twist,public_key);	
-	//chiffre_produit=multiplicationL1(temp_curve,temp_twist,public_key);
-	//dechiffrementL2(produit,chiffre_produit,private_key);
-	//zout(produit);	
-	
-	//cout << "cas #7 1*(1+0)" << endl; 
-	//chiffre_produit=multiplicationL1(bit_chiffre_1_curve,temp_twist,public_key);
-	//dechiffrementL2(produit,chiffre_produit,private_key);
-	//zout(produit);		
-	
-	//cout << "cas #8 (1+0) twist" << endl; 
-	//dechiffrement(produit,temp_twist,private_key);
-	//zout(produit);		
-	
-	
-	JUMP;
-	cout << "taille d'un chiffré de niveau 2 = " << sizeof(chiffre_produit) << " octets" << endl;	
-}

bgn2/src/circuit_multiplicationL1.hpp

@@ -1,24 +0,0 @@
-#ifndef __CIRCUIT_MULTIPLICATIONL1_HPP
-
-#define __CIRCUIT_MULTIPLICATIONL1_HPP
-
-#include <limits.h>		/* for CHAR_BIT */
-#include "typedef.h"
-#include "BitChiffre.hpp"
-#include "BitEvalL1.hpp"
-#include "BitEvalL2.hpp"
-#include "chiffrement.hpp" 
-#include "keygen.hpp"
-#include "dechiffrement.hpp" 
-#include "dechiffrementL2.hpp" 
-#include "additionL1.hpp"
-#include "multiplicationL1.hpp"
-#include "multiplicationL1L2.hpp"
-#include "additionL2.hpp"
-#include "additionL3.hpp"
-#include "precomputation.hpp"
-#include "postcomputation.hpp"
-
-void circuit_multiplicationL1(PublicKey public_key, PrivateKey private_key);
-
-#endif /* __CIRCUIT_MULTIPLICATIONL1_HPP */

bgn2/src/circuit_multiplicationL1L2.cpp

@@ -1,50 +0,0 @@
-#include "circuit_multiplicationL1L2.hpp"
-void circuit_multiplicationL1L2(PublicKey public_key, PrivateKey private_key)
-{
-	F2 zero=0, un=0, produit=0;
-	BitEvalL1<curvepoint_fp_t> bit_chiffre_0_curve, bit_chiffre_1_curve;
-	BitEvalL1<twistpoint_fp2_t> bit_chiffre_0_twist, bit_chiffre_1_twist;
-	BitEvalL2 chiffre_L2_0, chiffre_L2_1;
-	BitEvalL3 chiffre_produit;
-	
-	chiffrement(bit_chiffre_0_curve,0,public_key);
-	chiffrement(bit_chiffre_1_curve,1,public_key);
-	chiffrement(bit_chiffre_0_twist,0,public_key);
-	chiffrement(bit_chiffre_1_twist,1,public_key);
-	chiffre_L2_0 = multiplicationL1(bit_chiffre_0_curve,bit_chiffre_0_twist,public_key);
-	chiffre_L2_1 = multiplicationL1(bit_chiffre_1_curve,bit_chiffre_1_twist,public_key);	
-	dechiffrementL2(zero,chiffre_L2_0,private_key);	
-	dechiffrementL2(un,chiffre_L2_1,private_key);	
-	zout(zero,un);
-	
-	
-	cout << "cas #1 0*0" << endl;
-	
-	chiffre_produit=multiplicationL1L2(bit_chiffre_0_curve,chiffre_L2_0,public_key);
-	dechiffrementL3(produit,chiffre_produit,private_key);
-	zout(produit);
-	
-	//exit(0);
-		
-	cout << "cas #2 0*1" << endl;
-
-	chiffre_produit=multiplicationL1L2(bit_chiffre_0_curve,chiffre_L2_1,public_key);
-	dechiffrementL3(produit,chiffre_produit,private_key);
-	zout(produit);
-		
-	cout << "cas #3 1*0" << endl;
-
-	chiffre_produit=multiplicationL1L2(bit_chiffre_1_curve,chiffre_L2_0,public_key);
-	dechiffrementL3(produit,chiffre_produit,private_key);
-	zout(produit);
-		
-	cout << "cas #4 1*1" << endl;
-	
-	chiffre_produit=multiplicationL1L2(bit_chiffre_1_curve,chiffre_L2_1,public_key);
-	dechiffrementL3(produit,chiffre_produit,private_key);
-	zout(produit);
-	
-	JUMP;
-	cout << "taille d'un chiffré de niveau 3 = " << sizeof(chiffre_produit)+sizeof(Bipoint<curvepoint_fp_t>)*(chiffre_produit.get_vec_bipoints().capacity()) +sizeof(Quadripoint)*(chiffre_produit.get_vec_quadripoints().capacity()) << " octets" << endl;
-			
-}

bgn2/src/circuit_multiplicationL1L2.hpp

@@ -1,25 +0,0 @@
-#ifndef __CIRCUIT_MULTIPLICATIONL1L2_HPP
-
-#define __CIRCUIT_MULTIPLICATIONL1L2_HPP
-
-#include <limits.h>		/* for CHAR_BIT */
-#include "typedef.h"
-#include "BitChiffre.hpp"
-#include "BitEvalL1.hpp"
-#include "BitEvalL2.hpp"
-#include "chiffrement.hpp" 
-#include "keygen.hpp"
-#include "dechiffrement.hpp" 
-#include "dechiffrementL2.hpp" 
-#include "dechiffrementL3.hpp" 
-#include "additionL1.hpp"
-#include "multiplicationL1.hpp"
-#include "multiplicationL1L2.hpp"
-#include "additionL2.hpp"
-#include "additionL3.hpp"
-#include "precomputation.hpp"
-#include "postcomputation.hpp"
-
-void circuit_multiplicationL1L2(PublicKey public_key, PrivateKey private_key);
-
-#endif /* __CIRCUIT_MULTIPLICATIONL1L2_HPP */

bgn2/src/circuit_multiplicationL2.cpp

@@ -1,50 +0,0 @@
-#include "circuit_multiplicationL2.hpp"
-void circuit_multiplicationL2(PublicKey public_key, PrivateKey private_key)
-{
-	F2 zero=0, un=0, produit=0;
-	BitEvalL1<curvepoint_fp_t> bit_chiffre_0_curve, bit_chiffre_1_curve;
-	BitEvalL1<twistpoint_fp2_t> bit_chiffre_0_twist, bit_chiffre_1_twist;
-	BitEvalL2 chiffre_L2_0, chiffre_L2_1;
-	BitEvalL4 chiffre_produit;
-	
-	chiffrement(bit_chiffre_0_curve,0,public_key);
-	chiffrement(bit_chiffre_1_curve,1,public_key);
-	chiffrement(bit_chiffre_0_twist,0,public_key);
-	chiffrement(bit_chiffre_1_twist,1,public_key);
-	chiffre_L2_0 = multiplicationL1(bit_chiffre_0_curve,bit_chiffre_0_twist,public_key);
-	chiffre_L2_1 = multiplicationL1(bit_chiffre_1_curve,bit_chiffre_1_twist,public_key);	
-	dechiffrementL2(zero,chiffre_L2_0,private_key);	
-	dechiffrementL2(un,chiffre_L2_1,private_key);	
-	zout(zero,un);
-	
-	
-	cout << "cas #1 0*0" << endl;
-	
-	chiffre_produit=multiplicationL2(chiffre_L2_0,chiffre_L2_0,public_key);
-	dechiffrementL4(produit,chiffre_produit,private_key);
-	zout(produit);
-	
-	//exit(0);
-		
-	cout << "cas #2 0*1" << endl;
-
-	chiffre_produit=multiplicationL2(chiffre_L2_0,chiffre_L2_1,public_key);
-	dechiffrementL4(produit,chiffre_produit,private_key);
-	zout(produit);
-		
-	cout << "cas #3 1*0" << endl;
-
-	chiffre_produit=multiplicationL2(chiffre_L2_1,chiffre_L2_0,public_key);
-	dechiffrementL4(produit,chiffre_produit,private_key);
-	zout(produit);
-		
-	cout << "cas #4 1*1" << endl;
-	
-	chiffre_produit=multiplicationL2(chiffre_L2_1,chiffre_L2_1,public_key);
-	dechiffrementL4(produit,chiffre_produit,private_key);
-	zout(produit);
-	
-	JUMP;
-	cout << "taille d'un chiffré de niveau 4 = " << sizeof(chiffre_produit)+sizeof(Quadripoint)*(chiffre_produit.get_vec_quadripoints(0).capacity()+ chiffre_produit.get_vec_quadripoints(1).capacity()) << " octets" << endl;
-			
-}

bgn2/src/circuit_multiplicationL2.hpp

@@ -1,26 +0,0 @@
-#ifndef __CIRCUIT_MULTIPLICATIONL2_HPP
-
-#define __CIRCUIT_MULTIPLICATIONL2_HPP
-
-#include <limits.h>		/* for CHAR_BIT */
-#include "typedef.h"
-#include "BitChiffre.hpp"
-#include "BitEvalL1.hpp"
-#include "BitEvalL2.hpp"
-#include "chiffrement.hpp" 
-#include "keygen.hpp"
-#include "dechiffrement.hpp" 
-#include "dechiffrementL2.hpp" 
-#include "dechiffrementL4.hpp" 
-#include "additionL1.hpp"
-#include "multiplicationL1.hpp"
-#include "multiplicationL2.hpp"
-#include "multiplicationL1L2.hpp"
-#include "additionL2.hpp"
-#include "additionL3.hpp"
-#include "precomputation.hpp"
-#include "postcomputation.hpp"
-
-void circuit_multiplicationL2(PublicKey public_key, PrivateKey private_key);
-
-#endif /* __CIRCUIT_MULTIPLICATIONL2_HPP */

bgn2/src/circuit_scalar_product.cpp

@@ -1,59 +0,0 @@
-#include "circuit_scalar_product.hpp"
-void circuit_scalar_product(PublicKey public_key, PrivateKey private_key)
-{
-	unsigned long graine_faible_time;
-	graine_faible_time = time(NULL); 
-	srand((unsigned int)graine_faible_time); //cast explicite pour être propre
-		
-	// longueur des vecteurs n
-	
-	int n=5;
-	deque<bool> clair_1(n),clair_2(n);
-	for (unsigned int i=0; i<clair_1.size();i++)
-	{
-		clair_1[i]=rand()%2;
-		cout << "clair_1[" << i << "] = " << clair_1[i] << endl;
-		clair_2[i]=rand()%2;
-		cout << "clair_2[" << i << "] = " << clair_2[i] << endl;	
-		jump;	
-	}
-	
-	
-	// chiffrement vecteur binaire 1
-	
-	BitEvalL1<curvepoint_fp_t> A[n];	
-	for (unsigned int i=0; i<clair_1.size();i++) //pour chaque bit
-	{
-		chiffrement(A[i],clair_1[i],public_key);
-	}
-	
-	// chiffrement vecteur binaire 2
-
-	BitEvalL1<twistpoint_fp2_t> B[n];	
-	for (unsigned int i=0; i<clair_2.size();i++) //pour chaque bit
-	{
-		chiffrement(B[i],clair_2[i],public_key);
-	}
-		
-	// évaluation produit scalaire
-	
-	BitEvalL2 evalue, C[n];
-	int scalar_product=0;
-	for (unsigned int i=0; i<clair_1.size();i++) //pour chaque bit
-	{
-		C[i]=multiplicationL1(A[i],B[i],public_key);
-		evalue=additionL2(evalue,C[i],public_key);
-	}	
-	
-	// déchiffrement de l'évalué (somme de n chiffrés L1)
-	
-	F2 evalue_dechiffre=0;
-	dechiffrementL2(evalue_dechiffre,evalue,private_key);
-	zout (evalue_dechiffre); // produit scalaire modulo 2
-	for (unsigned int i=0; i<clair_1.size();i++) //pour chaque bit
-	{
-		dechiffrementL2(evalue_dechiffre,C[i],private_key);
-		scalar_product+=evalue_dechiffre;
-	}	
-	zout(scalar_product);
-}

bgn2/src/circuit_scalar_product.hpp

@@ -1,10 +0,0 @@
-#ifndef __CIRCUIT_SCALAR_PRODUCT_HPP
-
-#define __CIRCUIT_SCALAR_PRODUCT_HPP
-
-#include "keygen.hpp"
-#include <deque>
-
-void circuit_scalar_product(PublicKey public_key, PrivateKey private_key);
-
-#endif /* __CIRCUIT_SCALAR_PRODUCT_HPP */

bgn2/src/circuit_size.cpp

@@ -1,45 +0,0 @@
-#include "circuit_size.hpp"
-void circuit_size(PublicKey public_key, PrivateKey private_key)
-{
-	BitEvalL1<curvepoint_fp_t> bit_chiffre_0_curve;
-	BitEvalL1<twistpoint_fp2_t> bit_chiffre_0_twist;
-	BitEvalL2 chiffre_L2_0;
-	BitEvalL3 chiffre_L3_0, chiffre_somme_2_L3, chiffre_somme_3_L3, chiffre_somme_4_L3;
-	BitEvalL4 chiffre_L4_0, chiffre_somme_2_L4, chiffre_somme_3_L4, chiffre_somme_4_L4;
-	chiffrement(bit_chiffre_0_curve,0,public_key);
-	chiffrement(bit_chiffre_0_twist,0,public_key);
-	chiffre_L2_0 = multiplicationL1(bit_chiffre_0_curve,bit_chiffre_0_twist,public_key);
-	chiffre_L3_0 = multiplicationL1L2(bit_chiffre_0_curve,chiffre_L2_0,public_key);
-	chiffre_L4_0 = multiplicationL2(chiffre_L2_0,chiffre_L2_0,public_key);
-	chiffre_somme_2_L3=additionL3(chiffre_L3_0,chiffre_L3_0,public_key);	
-	chiffre_somme_3_L3=additionL3(chiffre_L3_0,chiffre_somme_2_L3,public_key);		
-	chiffre_somme_4_L3=additionL3(chiffre_somme_2_L3,chiffre_somme_2_L3,public_key);	
-	chiffre_somme_2_L4=additionL4(chiffre_L4_0,chiffre_L4_0,public_key);
-	chiffre_somme_3_L4=additionL4(chiffre_L4_0,chiffre_somme_2_L4,public_key);		
-	chiffre_somme_4_L4=additionL4(chiffre_somme_2_L4,chiffre_somme_2_L4,public_key);	
-	
-	cout  << "taille d'un chiffré de niveau 1 de type curve = " << sizeof(bit_chiffre_0_curve) << " octets " << GREEN <<"(taille de deux des trois chiffrés envoyés au serveur)" << RESET<<  endl;	
-	cout <<  "taille d'un chiffré de niveau 1 de type twist = " << sizeof(bit_chiffre_0_twist) << " octets " << GREEN <<"(taille d'un des trois chiffrés envoyé au serveur)" << RESET<<  endl;	
-	cout << "taille d'un chiffré de niveau 2 = " << sizeof(chiffre_L2_0) << " octets" << endl;
-	cout <<  "taille d'un chiffrais de niveau 3 = " << sizeof(chiffre_L3_0)+sizeof(Bipoint<curvepoint_fp_t>)*(chiffre_L3_0.get_vec_bipoints().capacity()) +sizeof(Quadripoint)*(chiffre_L3_0.get_vec_quadripoints().capacity())<< " octets " GREEN << "(taille de l'évalué calculé par le serveur dans les circuit minmaj et minmaj3)" << RESET << endl;
-	cout << "taille d'un chiffrais de niveau 4 = " << sizeof(chiffre_L4_0)+sizeof(Quadripoint)*(chiffre_L4_0.get_vec_quadripoints(0).capacity()+(chiffre_L4_0.get_vec_quadripoints(1).capacity())) << " octets" << endl;
-	cout << "taille de la somme de deux chiffrés de niveau 3 = " << sizeof(chiffre_somme_2_L3)+sizeof(Bipoint<curvepoint_fp_t>)*(chiffre_somme_2_L3.get_vec_bipoints().capacity()) +sizeof(Quadripoint)*(chiffre_somme_2_L3.get_vec_quadripoints().capacity())<< " octets " GREEN << "(taille de l'évalué calculé par le serveur dans le circuit minmaj2)" << RESET << endl;
-	cout << "taille de la somme de trois chiffrés de niveau 3 = " << sizeof(chiffre_somme_3_L3)+sizeof(Bipoint<curvepoint_fp_t>)*(chiffre_somme_3_L3.get_vec_bipoints().capacity()) +sizeof(Quadripoint)*(chiffre_somme_3_L3.get_vec_quadripoints().capacity())<< " octets " << endl;			
-	cout << "taille de la somme de quatre chiffrés de niveau 3 = " << sizeof(chiffre_somme_4_L3)+sizeof(Bipoint<curvepoint_fp_t>)*(chiffre_somme_4_L3.get_vec_bipoints().capacity()) +sizeof(Quadripoint)*(chiffre_somme_4_L3.get_vec_quadripoints().capacity())<< " octets " << endl;	
-	cout << "taille de la somme de deux chiffrés de niveau 4 = " << sizeof(chiffre_somme_2_L4)+sizeof(Quadripoint)*(chiffre_somme_2_L4.get_vec_quadripoints(0).capacity()+(chiffre_somme_2_L4.get_vec_quadripoints(1).capacity())) << " octets" << endl;
-	cout << "taille de la somme de trois chiffrés de niveau 4 = " << sizeof(chiffre_somme_3_L4)+sizeof(Quadripoint)*(chiffre_somme_3_L4.get_vec_quadripoints(0).capacity()+(chiffre_somme_3_L4.get_vec_quadripoints(1).capacity())) << " octets" << endl;
-	cout << "taille de la somme de quatre chiffrés de niveau 4 = " << sizeof(chiffre_somme_4_L4)+sizeof(Quadripoint)*(chiffre_somme_4_L4.get_vec_quadripoints(0).capacity()+(chiffre_somme_4_L4.get_vec_quadripoints(1).capacity())) << " octets" << endl;
-	cout << "taille de la clef publique = " << sizeof(public_key) << " octets " << endl; 
-	cout << "taille de la clef privée = " << sizeof(private_key) << " octets " << endl; 
-	cout << "taille d'un Fp = " << sizeof(Fp) << " octets " << endl;
-	cout << "taille d'un point de la courbe = " << sizeof(curvepoint_fp_t) << " octets "  << endl;
-	cout << "taille d'un point du twist = " << sizeof(twistpoint_fp2_t) << " octets "  << endl;
-	cout << "taille d'un fpe_t = " << sizeof(fpe_t) << " octets "  << endl;
-	cout << "taille d'un scalar_t = " << sizeof(scalar_t) << " octets "  << endl;	
-	cout << "taille d'un ull = " << sizeof(unsigned long long) << " octets "  << endl;
-	cout << "taille d'un double = " << sizeof(double) << " octets "  << endl;
-	cout << "taille d'un fp12e_t = " << sizeof(fp12e_t) << " octets "  << endl;
-	cout << "taille d'un quadripoint = " << sizeof(Quadripoint) << " octets "  << endl;	
-	
-	
-}

bgn2/src/circuit_size.hpp

@@ -1,29 +0,0 @@
-#ifndef __CIRCUIT_SIZE_HPP
-
-#define __CIRCUIT_SIZE_HPP
-
-#include <limits.h>		/* for CHAR_BIT */
-#include "typedef.h"
-#include "BitChiffre.hpp"
-#include "BitEvalL1.hpp"
-#include "BitEvalL2.hpp"
-#include "BitEvalL3.hpp"
-#include "BitEvalL4.hpp"
-#include "chiffrement.hpp" 
-#include "keygen.hpp"
-#include "dechiffrement.hpp" 
-#include "dechiffrementL2.hpp" 
-#include "dechiffrementL3.hpp"
-#include "additionL1.hpp"
-#include "multiplicationL1.hpp"
-#include "multiplicationL2.hpp"
-#include "multiplicationL1L2.hpp"
-#include "additionL2.hpp"
-#include "additionL3.hpp"
-#include "additionL4.hpp"
-#include "precomputation.hpp"
-#include "postcomputation.hpp"
-
-void circuit_size(PublicKey public_key, PrivateKey private_key);
-
-#endif /* __CIRCUIT_SIZE_HPP */

bgn2/src/circuit_time.cpp

@@ -1,257 +0,0 @@
-#include "circuit_time.hpp"
-
-
-void circuit_time(string message, PublicKey public_key, PrivateKey private_key)
-{
-	zout(omp_get_num_procs(),omp_get_max_threads());
-
-	int nombre_symboles = message.length();
-    using Clock = std::chrono::high_resolution_clock;
-    using std::chrono::nanoseconds;
-    using std::chrono::duration_cast;
-
-   	double temps_en_nanosecondes;    
-	double temps_en_secondes, temps_en_millisecondes_par_symbole;
-	
-	///circuit minmaj
-	grostitre(Circuit minmaj : Sans erreur et avec précalcul et postcalcul);
-	F2 clair1[nombre_symboles]={}, clair2[nombre_symboles]={},clair3[nombre_symboles]={}; // resp de n8, n9, o8 (voir rapport.pdf, page 24)
-	BitEvalL1<curvepoint_fp_t> n8[nombre_symboles],n9[nombre_symboles],temp_curve[nombre_symboles], chiffre_1_curve[nombre_symboles];
-	BitEvalL1<twistpoint_fp2_t> o8[nombre_symboles],temp_twist[nombre_symboles], chiffre_1_twist[nombre_symboles];
-	BitEvalL2 temp_quadripoint[nombre_symboles]; // (1+n9)(1+o8)
-	BitEvalL3 evalue[nombre_symboles]; 	// n8(1+n9)(1+o8)	
-	//char dechiffre[nombre_symboles]={}; //GREEN
-	string dechiffre;
-	dechiffre.resize(nombre_symboles); // on donne explicitement la taille de la string pour faciliter l'affichage
-	///précalcul, chiffrement
-	ecris(précalcul et chiffrement);
-    auto temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	//	omp_set_num_threads(1);	    //version séquentielle  
-	#pragma omp parallel 
-	{    
-		#pragma omp single	//sinon l'instruction est executée par chaque thread
-		{
-		zout(omp_get_num_threads()); //le nombre de thread n'est modifié que dans la section parallel
-		}
-		#pragma omp for
-			for (int i=0; i<nombre_symboles;i++)
-			{
-				precomputation(clair1[i], clair2[i], clair3[i], message[i]);
-				chiffrement(n8[i],clair1[i],public_key);	
-				chiffrement(n9[i],clair2[i],public_key);	
-				chiffrement(o8[i],clair3[i],public_key);
-			}
-		
-	}
-  
-	auto temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes_par_symbole=temps_en_nanosecondes*1e-6/nombre_symboles;
-	zout(temps_en_millisecondes_par_symbole);
-	
-	///évaluation homomorphique
-	ecris(évaluation homomorphique);
-    temps_initial = Clock::now();
-	#pragma omp parallel 
-	{    
-		#pragma omp for
-		for (int i=0; i<nombre_symboles;i++)
-		{
-			chiffrement(chiffre_1_curve[i],1, public_key);
-			chiffrement(chiffre_1_twist[i],1, public_key);
-			temp_curve[i] = additionL1(chiffre_1_curve[i],n9[i],public_key);	//NB il faut rajouter CURVE pour passer de BitChiffre à BitEvalL1, la diff entre les deux, la taille mémoire
-			temp_twist[i] = additionL1(chiffre_1_twist[i],o8[i],public_key);
-			temp_quadripoint[i] = multiplicationL1(temp_curve[i],temp_twist[i],public_key);	
-			evalue[i] = multiplicationL1L2(n8[i],temp_quadripoint[i],public_key);	
-		}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes_par_symbole=temps_en_nanosecondes*1e-6/nombre_symboles;
-	zout(temps_en_millisecondes_par_symbole);	
- 
-	/// déchiffrement et poscalcul
-	ecris(dechiffrement et postcalcul);
-	//int max=omp_get_max_threads();
-	//for (int nb_threads=1;nb_threads<=max;nb_threads++)
-	//{
-		//omp_set_num_threads(nb_threads);
-	temps_initial = Clock::now();
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_symboles;i++)
-			{
-				postcomputation(dechiffre[i], message[i], evalue[i], private_key);	
-			}
-	}
-
-	temps_final = Clock::now();
-
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_millisecondes_par_symbole=temps_en_nanosecondes*1e-6/nombre_symboles;
-	zout(dechiffre,temps_en_millisecondes_par_symbole);
-	//}
-	
-
-	
-	///circuit minmaj2
-	grostitre(Circuit minmaj2 : avec erreur sur les caractères ~{|`});	
-	BitEvalL1<twistpoint_fp2_t> m6[nombre_symboles];
-	BitEvalL1<curvepoint_fp_t> m7[nombre_symboles],m8[nombre_symboles];
-	BitEvalL2 chiffre_L2_1[nombre_symboles];	
-	BitEvalL3 temp_L3[nombre_symboles],  chiffre_L3_1[nombre_symboles]; 	// m6m7(1+m8)		
-	F2 IS_LOWER_CASE[nombre_symboles]={};
-	
-	///chiffrement
-	ecris(chiffrement);
-    temps_initial = Clock::now();
-
-	#pragma omp parallel 
-	{    
-		#pragma omp single	//sinon l'instruction est executée par chaque thread
-		{
-		zout(omp_get_num_threads()); //le nombre de thread n'est modifié que dans la section parallel
-		}
-		#pragma omp for
-		for (int i=0; i<nombre_symboles;i++)
-		{		
-			clair1[i]=bitset<sizeof(int)*CHAR_BIT>(message[i])[5] ; 
-			clair2[i]=bitset<sizeof(int)*CHAR_BIT>(message[i])[6] ;
-			clair3[i]=bitset<sizeof(int)*CHAR_BIT>(message[i])[7] ; 
-			chiffrement(m6[i],clair1[i],public_key);	
-			chiffrement(m7[i],clair2[i],public_key);	
-			chiffrement(m8[i],clair3[i],public_key);
-		}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes_par_symbole=temps_en_nanosecondes*1e-6/nombre_symboles;
-	zout(temps_en_millisecondes_par_symbole);	
-	
-	
-	///évaluation homomorphique
-	ecris(évaluation homomorphique);
-    temps_initial = Clock::now();
-	#pragma omp parallel 
-	{    
-		#pragma omp for
-		for (int i=0; i<nombre_symboles;i++)
-		{	
-			chiffrement(chiffre_1_curve[i],1, public_key);
-			chiffrement(chiffre_1_twist[i], 1, public_key);
-			temp_curve[i] = additionL1(chiffre_1_curve[i],m8[i],public_key);	//calcul 1+m8
-			temp_quadripoint[i] = multiplicationL1(temp_curve[i],m6[i],public_key);
-			chiffre_L2_1[i] = multiplicationL1(chiffre_1_curve[i],chiffre_1_twist[i],public_key);
-			chiffre_L3_1[i]=multiplicationL1L2(chiffre_1_curve[i],chiffre_L2_1[i],public_key);
-			temp_L3[i] = multiplicationL1L2(m7[i],temp_quadripoint[i],public_key);	
-			evalue[i]=additionL3(temp_L3[i],chiffre_L3_1[i],public_key);
-		}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes_par_symbole=temps_en_nanosecondes*1e-6/nombre_symboles;
-	zout(temps_en_millisecondes_par_symbole);	
- 
-	/// déchiffrement 
-	ecris(dechiffrement);
-	dechiffre.clear();
-	dechiffre.resize(nombre_symboles); 
-    temps_initial = Clock::now();
-	#pragma omp parallel 
-	{    
-		#pragma omp for	
-		for (int i=0; i<nombre_symboles;i++)
-		{		
-			dechiffrementL3(IS_LOWER_CASE[i],evalue[i],private_key);
-			if (IS_LOWER_CASE[i] == 0)
-			{
-				//cout << symbole << " est sensé être une minuscule!" << endl;
-				dechiffre[i]=char(message[i]-32);
-			}
-			else
-			{
-				dechiffre[i]=char(message[i]);	
-			}
-			//cout << dechiffre[i] << flush;
-		}
-	}
-	jump;
-	zout(dechiffre);
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-	//zout(temps_en_secondes);
-	temps_en_millisecondes_par_symbole=temps_en_nanosecondes*1e-6/nombre_symboles;
-	zout(temps_en_millisecondes_par_symbole);
-	
-	
-	
-	
-	
-	///circuit minmaj3
-	grostitre(Circuit minmaj3 : avec erreur sur les caractères ~{|`} et avec postcalcul);	
-	
-	
-	///chiffrement
-	ecris(chiffrement);
-
-	cout << "Circuit de chiffrement identique à circuit minmaj2" << endl;
-	
-	///évaluation homomorphique
-	ecris(évaluation homomorphique);
-    temps_initial = Clock::now();
-	#pragma omp parallel 
-	{    
-		#pragma omp for
-		for (int i=0; i<nombre_symboles;i++)
-		{		
-			chiffrement(chiffre_1_curve[i],1, public_key);
-			temp_curve[i] = additionL1(chiffre_1_curve[i],m8[i],public_key);	//calcul 1+m8	
-			temp_quadripoint[i] = multiplicationL1(temp_curve[i],m6[i],public_key);
-			evalue[i] = multiplicationL1L2(m7[i],temp_quadripoint[i],public_key);	
-		}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-	//zout(temps_en_secondes);
-	temps_en_millisecondes_par_symbole=temps_en_nanosecondes*1e-6/nombre_symboles;
-	zout(temps_en_millisecondes_par_symbole);
-	
-	
-	
-	/// déchiffrement 
-	ecris(dechiffrement);
-	dechiffre.clear();
-	dechiffre.resize(nombre_symboles); 
-	temps_initial = Clock::now();
-	#pragma omp parallel 
-	{    
-		#pragma omp for	
-		for (int i=0; i<nombre_symboles;i++)
-		{		
-			postcomputation(dechiffre[i], message[i], evalue[i], private_key);
-		}	
-	}
-	jump;
-	zout(dechiffre);
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-	//zout(temps_en_secondes);
-	temps_en_millisecondes_par_symbole=temps_en_nanosecondes*1e-6/nombre_symboles;
-	zout(temps_en_millisecondes_par_symbole);	
-	
-	
-		
-}

bgn2/src/circuit_time.hpp

@@ -1,24 +0,0 @@
-#ifndef __CIRCUIT_TIME_HPP
-
-#define __CIRCUIT_TIME_HPP
-
-#include <limits.h>		/* for CHAR_BIT */
-#include "typedef.h"
-#include "BitChiffre.hpp"
-#include "BitEvalL1.hpp"
-#include "chiffrement.hpp" 
-#include "keygen.hpp"
-#include "dechiffrement.hpp" 
-#include "additionL1.hpp"
-#include "multiplicationL1.hpp"
-#include "multiplicationL1L2.hpp"
-#include "additionL2.hpp"
-#include "additionL3.hpp"
-#include "precomputation.hpp"
-#include "postcomputation.hpp"
-#include <chrono>
-#include <omp.h>
-
-void circuit_time(string message, PublicKey public_key, PrivateKey private_key);
-
-#endif /* __CIRCUIT_TIME_HPP */

bgn2/src/circuit_time2.cpp

@@ -1,437 +0,0 @@
-#include "circuit_time2.hpp"
-
-
-void circuit_time2(PublicKey public_key, PrivateKey private_key)
-{
-	zout(omp_get_num_procs(),omp_get_max_threads());
-
-    using Clock = chrono::high_resolution_clock;
-    using chrono::nanoseconds;
-    using chrono::duration_cast;
-
-   	double temps_en_nanosecondes;    
-	double temps_en_secondes, temps_en_millisecondes;
-	
-	unsigned long graine_faible_time;
-	graine_faible_time = time(NULL); 
-	srand((unsigned int)graine_faible_time); //cast explicite pour être propre
-			
-	int nombre_instances=50;
-	F2 clair;
-	BitEvalL1<curvepoint_fp_t> chiffre_curve[nombre_instances], sum_curve[nombre_instances];
-	BitEvalL1<twistpoint_fp2_t> chiffre_twist[nombre_instances], sum_twist[nombre_instances];
-	BitEvalL2 chiffre_L2[nombre_instances], sum_L2[nombre_instances];
-	BitEvalL3 chiffre_L3[nombre_instances], sum_L3[nombre_instances];
-	BitEvalL4 chiffre_L4[nombre_instances], sum_L4[nombre_instances];
-	
-
-	
-	
-	/**encryption mode curve **/
-	green(encryption mode curve);
-	auto temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	clair=rand()%2;
-	
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_instances;i++)
-			{
-				//clair=rand()%2;
-				chiffrement(chiffre_curve[i],clair,public_key);
-			}
-	}
-	auto temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes=temps_en_nanosecondes*1e-6/nombre_instances;
-	cout << setprecision(3) << temps_en_millisecondes << " ms\n";	
-
-	/**encryption mode twist **/
-	
-	green(encryption mode twist);
-	temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_instances;i++)
-			{
-				chiffrement(chiffre_twist[i],clair,public_key);
-			}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes=temps_en_nanosecondes*1e-6/nombre_instances;
-	cout << setprecision(3) << temps_en_millisecondes << " ms\n";	
-	
-
-
-	/**multiplication L1 **/
-	
-	yellow(multiplication L1);
-	temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_instances;i++)
-			{
-				chiffre_L2[i]=multiplicationL1(chiffre_curve[i],chiffre_twist[i],public_key);
-			}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes=temps_en_nanosecondes*1e-6/nombre_instances;
-	cout << setprecision(3) << temps_en_millisecondes << " ms\n";	
-		
-	/**multiplication L1L2 curve **/
-	
-	yellow(multiplication L1L2);
-	temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_instances;i++)
-			{
-				chiffre_L3[i]=multiplicationL1L2(chiffre_curve[i],chiffre_L2[i],public_key);
-			}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes=temps_en_nanosecondes*1e-6/nombre_instances;
-	cout << setprecision(3) << temps_en_millisecondes << " ms\n";		
-	
-	/**multiplication L2 **/
-	
-	yellow(multiplication L2);
-	temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_instances;i++)
-			{
-				chiffre_L4[i]=multiplicationL2(chiffre_L2[i],chiffre_L2[i],public_key);
-			}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes=temps_en_nanosecondes*1e-6/nombre_instances;
-	cout << setprecision(3) << temps_en_millisecondes << " ms\n";	
-
-
-	
-	/**addition L1 mode curve **/
-	green(addition L1 mode curve);
-	temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	clair=rand()%2;
-	
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_instances-1;i++)
-			{
-				//clair=rand()%2;
-				sum_curve[i]=additionL1(chiffre_curve[i],chiffre_curve[i+1],public_key);
-			}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes=temps_en_nanosecondes*1e-6/(nombre_instances-1);
-	cout << setprecision(3) << temps_en_millisecondes << " ms\n";	
-	
-	/**addition L1 mode twist **/
-	green(addition L1 mode twist);
-	temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	clair=rand()%2;
-	
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_instances-1;i++)
-			{
-				//clair=rand()%2;
-				sum_twist[i]=additionL1(chiffre_twist[i],chiffre_twist[i+1],public_key);
-			}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes=temps_en_nanosecondes*1e-6/(nombre_instances-1);
-	cout << setprecision(3) << temps_en_millisecondes << " ms\n";		
-	
-	
-	/**addition L2 **/
-	green(addition L2);
-	temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	clair=rand()%2;
-	
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_instances-1;i++)
-			{
-				//clair=rand()%2;
-				sum_L2[i]=additionL2(chiffre_L2[i],chiffre_L2[i+1],public_key);
-			}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes=temps_en_nanosecondes*1e-6/(nombre_instances-1);
-	cout << setprecision(3) << temps_en_millisecondes << " ms\n";	
-	
-	/**addition L3 **/
-	green(addition of two L3);
-	temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	clair=rand()%2;
-	
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_instances-1;i++)
-			{
-				//clair=rand()%2;
-				sum_L3[i]=additionL3(chiffre_L3[i],chiffre_L3[i+1],public_key);
-			}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes=temps_en_nanosecondes*1e-6/(nombre_instances-1);
-	cout << setprecision(3) << temps_en_millisecondes << " ms\n";		
-	
-	/**addition L4 **/
-	green(addition of two L4);
-	temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	clair=rand()%2;
-	
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_instances-1;i++)
-			{
-				//clair=rand()%2;
-				sum_L4[i]=additionL4(chiffre_L4[i],chiffre_L4[i+1],public_key);
-			}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes=temps_en_nanosecondes*1e-6/(nombre_instances-1);
-	cout << setprecision(3) << temps_en_millisecondes << " ms\n";		
-	
-	
-		
-	/**decryption L1 mode curve **/
-	
-	green(decryption mode curve);
-	temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_instances;i++)
-			{
-				dechiffrement(clair,chiffre_curve[i],private_key);
-			}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes=temps_en_nanosecondes*1e-6/nombre_instances;
-	cout << setprecision(3) << temps_en_millisecondes << " ms\n";	
-	
-	/**decryption L1 mode twist **/
-	
-	green(decryption mode twist);
-	temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_instances;i++)
-			{
-				dechiffrement(clair,chiffre_twist[i],private_key);
-			}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes=temps_en_nanosecondes*1e-6/nombre_instances;
-	cout << setprecision(3) << temps_en_millisecondes << " ms\n";	
-	
-	/**decryption L2 **/
-	
-	red(decryption L2);
-	temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_instances;i++)
-			{
-				dechiffrementL2(clair,chiffre_L2[i],private_key);
-			}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes=temps_en_nanosecondes*1e-6/nombre_instances;
-	cout << setprecision(3) << temps_en_millisecondes << " ms\n";
-	
-	
-	/**decryption L3 **/
-	
-	red(decryption L3);
-	temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_instances;i++)
-			{
-				dechiffrementL3(clair,chiffre_L3[i],private_key);
-			}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes=temps_en_nanosecondes*1e-6/nombre_instances;
-	cout << setprecision(3) << temps_en_millisecondes << " ms\n";
-	
-	
-	/**decryption L4 **/
-	
-	red(decryption L4);
-	temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_instances;i++)
-			{
-				dechiffrementL4(clair,chiffre_L4[i],private_key);
-			}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes=temps_en_nanosecondes*1e-6/nombre_instances;
-	cout << setprecision(3) << temps_en_millisecondes << " ms\n";	
-	
-
-	
-	
-	/**decryption sum L3 **/
-	
-	red(decryption sum of two L3);
-	temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_instances-1;i++)
-			{
-				dechiffrementL3(clair,sum_L3[i],private_key);
-			}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes=temps_en_nanosecondes*1e-6/(nombre_instances-1);
-	cout << setprecision(3) << temps_en_millisecondes << " ms\n";
-	
-	
-	/**decryption sum L4 **/
-	
-	red(decryption sum of two L4);
-	temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_instances-1;i++)
-			{
-				dechiffrementL4(clair,sum_L4[i],private_key);
-			}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes=temps_en_nanosecondes*1e-6/(nombre_instances-1);
-	cout << setprecision(3) << temps_en_millisecondes << " ms\n";	
-	
-	
-	/**keygen **/
-	green(keygen);
-	temps_initial = Clock::now();
-	omp_set_num_threads(omp_get_max_threads());	
-	clair=rand()%2;
-	
-	#pragma omp parallel 
-	{
-		#pragma omp for
-			for (int i=0; i<nombre_instances;i++)
-			{
-				keygen(public_key, private_key);
-			}
-	}
-	temps_final = Clock::now();
-	temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-	temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-    //zout(temps_en_secondes);
-	temps_en_millisecondes=temps_en_nanosecondes*1e-6/nombre_instances;
-	cout << setprecision(3) << temps_en_millisecondes << " ms\n";			
-			
-
-	/**precomputation L2 **/
-        
-        red(precompute L2);
-        temps_initial = Clock::now();
-        omp_set_num_threads(omp_get_max_threads());        
-#pragma omp parallel 
-        {
-#pragma omp for
-	  for (int i=0; i<nombre_instances;i++)
-	    {
-	      Quadripoint base_log = private_key.pi_T(pairing(public_key.get_bipoint_curve_groupelt(),public_key.get_bipoint_twist_groupelt()));  //pi_T(e(u,v))
-	    }
-        }
-        temps_final = Clock::now();
-        temps_en_nanosecondes = duration_cast<nanoseconds>(temps_final-temps_initial).count(); /* total time in nanoseconds */ 
-        temps_en_secondes= temps_en_nanosecondes*1e-9; //on pourrait passer directement en secondes avec chrono mais on perdrait de la précision avec leurs arrondis
-	//zout(temps_en_secondes);
-        temps_en_millisecondes=temps_en_nanosecondes*1e-6/nombre_instances;
-        cout << setprecision(3) << temps_en_millisecondes << " ms\n";
-}

bgn2/src/circuit_time2.hpp

@@ -1,32 +0,0 @@
-#ifndef __CIRCUIT_TIME2_HPP
-
-#define __CIRCUIT_TIME2_HPP
-
-#include <limits.h>		/* for CHAR_BIT */
-#include "typedef.h"
-#include "BitChiffre.hpp"
-#include "BitEvalL1.hpp"
-#include "BitEvalL2.hpp"
-#include "BitEvalL3.hpp"
-#include "BitEvalL4.hpp"
-#include "chiffrement.hpp" 
-#include "keygen.hpp"
-#include "dechiffrement.hpp" 
-#include "dechiffrementL2.hpp" 
-#include "dechiffrementL3.hpp"
-#include "dechiffrementL4.hpp"
-#include "additionL1.hpp"
-#include "multiplicationL1.hpp"
-#include "multiplicationL1L2.hpp"
-#include "multiplicationL2.hpp"
-#include "additionL2.hpp"
-#include "additionL3.hpp"
-#include "precomputation.hpp"
-#include "postcomputation.hpp"
-#include <chrono>
-#include <omp.h>
-#include <iomanip> //setprecision
-
-void circuit_time2(PublicKey public_key, PrivateKey private_key);
-
-#endif /* __CIRCUIT2_TIME_HPP */

bgn2/src/keygen.cpp

@@ -1,205 +1,81 @@
 #include "keygen.hpp"
 
-const scalar_t &bn_r=bn_n;
+extern const scalar_t bn_n;
+extern const curvepoint_fp_t bn_curvegen;   
+extern const twistpoint_fp2_t bn_twistgen;
 
 void keygen(PublicKey& public_key, PrivateKey& private_key)
 {
-	//signature;
+    Fp i1, j1, k1, l1, i2, j2, k2, l2;
+    
+    while (true)
+    {
+        j1.set_random();
+        k1.set_random();
+        l1.set_random();
 
-	
+        if (!l1.is_zero())
+        {
+            i1 = (j1 * k1 + Fp(1)) / l1;
+            break;
+        }
+    }
 
-	/** générer des données privées avant la création d'une paire de clefs **/
+    while (true)
+    {
+        j2.set_random();
+        k2.set_random();
+        l2.set_random();
 
-	Fp i1,j1,k1,l1,i2,j2,k2,l2;
-	do
-	{
-		////cout << "j1 = " << endl;
-		j1.set_random();
-		//cout << "k1 = " << endl;
-		k1.set_random();
-		//cout << "l1 = " << endl;
-		l1.set_random();
-		//cout << "i1 = " << endl;
-		i1.set_ad_minus_bc(j1,k1,l1);
-	}
-	while (scalar2mpz(i1.scalar())<0); 
-	do
-	{
-	//cout << "j2 = " << endl;
-	j2.set_random();
-	//cout << "k2 = " << endl;
-	k2.set_random();
-	//cout << "l2 = " << endl;
-	l2.set_random();
-	//cout << "i2 = " << endl;
-	i2.set_ad_minus_bc(j2,k2,l2);	
-	}
-	while (scalar2mpz(i2.scalar())<0);
-	/** génération de la clef privée **/
+        if (!l2.is_zero())
+        {
+            i2 = (j2 * k2 + Fp(1)) / l2;
+            break;
+        }   
+    }
 
-	//cout << YELLOW << "Private Key Generation" << RESET << endl;
-	
-	//cout << "sk:=(pi_1,pi_2,pi_T)" << endl;
-	
-	// Pi_1(x,y)=((-j1*k1)x + (i1*k1)y ,(-j1*l1)x + (i1*l1)y)
-	
-	
-	//PrivateKey private_key(i1,j1,k1,l1,i2,j2,k2,l2);
-	
-	private_key.set(i1,j1,k1,l1,i2,j2,k2,l2);
-	
-	
-	//fpe_t test;
-	//int i;
-	//for(i=1;i<12;i++)
-	//{
-		//test->v[i] = 0.;
-	//}
-	//test->v[0] = 2;
-	//i1.set(test);
-	
-	//private_key.Pi_1(x,y);
-		
-	/** génération de la clef publique **/
+    private_key.set(i1, j1, k1, l1, i2, j2, k2, l2);
+    
+    curvepoint_fp_t c1, c2, c3, c4; 
+    
+    curvepoint_fp_scalarmult_vartime(c1, bn_curvegen, i1.to_scalar());  
+    curvepoint_fp_makeaffine(c1);
 
-	//cout << YELLOW << "Public Key Generation" << RESET << endl;
-	
-	//cout << "pk:=(p, G, H, G_T, e, g, h, (i_1*g,j_1*g), (i_2*h,j_2*h))" << endl;
-	
-	// 1) (i_1*g,j_1*g)  public_key.bipoint_curve (i_2*h,j_2*h) public_key:bipoint_twist
-	// 2) on utilise bn_curvegen comme générateur g, on pourrait (devrait?) utiliser un générateur aléatoire plutôt qu'un générateur fixé
-	
-	curvepoint_fp_t c1,c2,c3,c4;	
-	
-	//cout << RED << "affichage du curvepoint g = " << RESET << endl;
-	//curvepoint_fp_print(stdout,bn_curvegen);
-	//JUMP;
-	// calcul du générateur (i1g,j1g) du sous groupe  des bipoints de la courbe
-	//ecris(g);
-	//curvepoint_fp_print(stdout,bn_curvegen);
-	//jump;
-	//representation(bn_curvegen);
-	
-	curvepoint_fp_scalarmult_vartime(c1, bn_curvegen,i1.scalar());  
-	curvepoint_fp_scalarmult_vartime(c2, bn_curvegen,j1.scalar());
-	curvepoint_fp_makeaffine(c1); //il faut homogénéiser pour pouvoir faire des tests lors du déchiffrement
-	curvepoint_fp_makeaffine(c2);
+    curvepoint_fp_scalarmult_vartime(c2, bn_curvegen, j1.to_scalar());
+    curvepoint_fp_makeaffine(c2);
 
+    Bipoint<curvepoint_fp_t> b1(c1, c2);
 
+    twistpoint_fp2_t t1, t2, t3, t4;
 
-	
-	//cout << RED << "affichage du scalar_t i1" << RESET <<endl;
-	//scalar_print(stdout, i1.scalar()); 
-	//JUMP;
-	//cout << RED << "affichage du scalar_t j1" << RESET <<endl;
-	//scalar_print(stdout, j1.scalar()); 
-	//JUMP;
-	//cout << RED << "affichage du curvepoint i1 g = " << RESET << endl;
-	//curvepoint_fp_print(stdout,c1);
-	//JUMP;
-	//representation(c1);
-	//JUMP;
-	//cout << RED << "affichage du curvepoint j1 g = " << RESET << endl;
-	//curvepoint_fp_print(stdout,c2);
-	//representation(c2);
-	//JUMP;
-	
-	//ecris(2g);
-	//curvepoint_fp_t temp;
-	//curvepoint_fp_double(temp,bn_curvegen);
-	//curvepoint_fp_makeaffine(temp);
-	//curvepoint_fp_print(stdout,temp);
-	//jump;
-	//representation(temp);
-	//ecris(g+g);
-	//curvepoint_fp_add_vartime(temp,bn_curvegen,bn_curvegen);
-	//curvepoint_fp_makeaffine(temp);
-	//curvepoint_fp_print(stdout,temp);
-	//jump;
-	//representation(temp);			
-	//curvepoint_fp_t test1,test2;
-	//curvepoint_fp_scalarmult_vartime(test1, c1,j1.scalar());  
-	//curvepoint_fp_scalarmult_vartime(test2, c2,i1.scalar());
-	//cout << RED << "affichage du curvepoint j1 (i1 g) = " << RESET << endl;
-	//curvepoint_fp_makeaffine(test1);
-	//curvepoint_fp_print(stdout,test1);
-	//JUMP;
-	//cout << RED << "affichage du curvepoint i1 (j1 g) = " << RESET << endl;
-	//curvepoint_fp_makeaffine(test2);
-	//curvepoint_fp_print(stdout,test2);
-	//JUMP;	
-	
-	
-	//Fp test3=j1*i1, test4=i1*j1;
-	//cout << RED << "affichage du scalar_t (i1 j1) =" << RESET <<endl;
-	//scalar_print(stdout, test3.scalar()); 
-	//JUMP;
-	//cout << RED << "affichage du scalar_t (j1 i1) =" << RESET <<endl;
-	//scalar_print(stdout, test4.scalar()); 
-	//JUMP;
-	//curvepoint_fp_t test5,test6;
-	//curvepoint_fp_scalarmult_vartime(test5,bn_curvegen,test3.scalar());
-	//curvepoint_fp_scalarmult_vartime(test6,bn_curvegen,test4.scalar());
-	//cout << RED << "affichage du curvepoint (i1j1) g = " << RESET << endl;
-	//curvepoint_fp_makeaffine(test5);
-	//curvepoint_fp_print(stdout,test5);
-	//test5.get_fpe();
-	//JUMP;
-	//curvepoint_fp_makeaffine(test6);
-	//curvepoint_fp_print(stdout,test6);
-	//JUMP;
-	
-	
-	//curvepoint_fp_t temp1,temp2, temp3, temp4;
-	//curvepoint_fp_neg(temp1,test1);
-	//curvepoint_fp_add_vartime(temp2,temp1,test5);
-	//cout << RED << "affichage du curvepoint = test5 - test1 = (i1j1) g - j1 (i1 g)" << RESET << endl;
-	//curvepoint_fp_makeaffine(temp2);
-	//curvepoint_fp_print(stdout,temp2);
-	//JUMP;
-	//curvepoint_fp_neg(temp3,test5);
-	//curvepoint_fp_add_vartime(temp4,test1,temp3);
-	//cout << RED << "affichage du curvepoint = test1 - test5" << RESET << endl;
-	//curvepoint_fp_makeaffine(temp4);
-	//curvepoint_fp_print(stdout,temp4);
-	//exit(0);
-	
-	//curvepoint_fp_t test6,test7;
-	//curvepoint_fp_neg(test6,bn_curvegen);
-	//curvepoint_fp_add_vartime(test7,bn_curvegen,test6);
-	//cout << RED << "affichage du curvepoint = test7 =g-g" << RESET << endl;
-	//curvepoint_fp_print(stdout,test7);
-	//JUMP;
+    twistpoint_fp2_scalarmult_vartime(t1, bn_twistgen,i2.scalar());
+    twistpoint_fp2_makeaffine(t1);
 
-	Bipoint<curvepoint_fp_t> b1(c1,c2);	
-	// calcul du générateur (i2h,j2h) du sous groupe des bipoints du twist
-	twistpoint_fp2_t t1,t2,t3,t4;	
-	twistpoint_fp2_scalarmult_vartime(t1, bn_twistgen,i2.scalar());
-	twistpoint_fp2_scalarmult_vartime(t2, bn_twistgen,j2.scalar());
-	twistpoint_fp2_makeaffine(t1);
-	twistpoint_fp2_makeaffine(t2);
-	Bipoint<twistpoint_fp2_t> b2(t1,t2);
-	scalar_t s1, s2, s3, s4;
-	//scalar_print(stdout,bn_r);
-	scalar_setrandom(s1, bn_r);
-	scalar_setrandom(s2, bn_r);
-	scalar_setrandom(s3, bn_r);
-	scalar_setrandom(s4, bn_r);
-	// calcul de u, un bipoint de la courbe dans le groupe
-	curvepoint_fp_scalarmult_vartime(c3, bn_curvegen,s1);
-	curvepoint_fp_scalarmult_vartime(c4, bn_curvegen,s2);
-	Bipoint<curvepoint_fp_t> b3(c3,c4);	
-	b3.makeaffine();
-	// calcul de v, un bipoint du twist dans le groupe
-	
-	twistpoint_fp2_scalarmult_vartime(t3, bn_twistgen,s3);
-	twistpoint_fp2_scalarmult_vartime(t4, bn_twistgen,s4);
-	Bipoint<twistpoint_fp2_t> b4(t3,t4);
-	b4.makeaffine();
+    twistpoint_fp2_scalarmult_vartime(t2, bn_twistgen,j2.scalar());
+    twistpoint_fp2_makeaffine(t2);
 
-	//PublicKey public_key(b1,b2,b3,b4);		
-	public_key.set(b1,b2,b3,b4);		
-	//public_key.bipoint_curvegen.set_point(p1,0);
-	//public_key.bipoint_curvegen.set_point(p2,1);
-	
+    Bipoint<twistpoint_fp2_t> b2(t1, t2);
+    
+    scalar_t s1, s2, s3, s4;
+    scalar_setrandom(s1, bn_n);
+    scalar_setrandom(s2, bn_n);
+    scalar_setrandom(s3, bn_n);
+    scalar_setrandom(s4, bn_n);
+    
+    curvepoint_fp_scalarmult_vartime(c3, bn_curvegen, s1);
+    curvepoint_fp_makeaffine(c3);
+
+    curvepoint_fp_scalarmult_vartime(c4, bn_curvegen, s2);
+    curvepoint_fp_makeaffine(c4);
+
+    Bipoint<curvepoint_fp_t> b3(c3, c4);    
+    
+    twistpoint_fp2_scalarmult_vartime(t3, bn_twistgen, s3);
+    twistpoint_fp2_makeaffine(t3);
+    twistpoint_fp2_scalarmult_vartime(t4, bn_twistgen, s4);
+    twistpoint_fp2_makeaffine(t4);
+    
+    Bipoint<twistpoint_fp2_t> b4(t3, t4);
+        
+    public_key.set(b1, b2, b3, b4);
 }

bgn2/src/keygen.hpp

@@ -1,33 +1,12 @@
 #ifndef __KEYGEN_HPP
-
 #define __KEYGEN_HPP
 
-#include <iostream>
-#include "zout.hpp"
 #include "Fp.hpp"
 #include "PrivateKey.hpp"
 #include "PublicKey.hpp"
-#include "representation.hpp"
-#include "fpe2scalar.hpp"
-#include <array>
 
 using namespace std;
 
-
 void keygen(PublicKey& public_key, PrivateKey& private_key);
-extern const scalar_t bn_n;
-extern const curvepoint_fp_t bn_curvegen;	
-extern const twistpoint_fp2_t bn_twistgen;
-
-//#ifdef NEW_PARAMETERS
-//const scalar_t bn_r={bn_n[0],bn_n[1],bn_n[2],bn_n[3],bn_n[4],bn_n[5],bn_n[6],bn_n[7]}; //copie pour résoudre problème notation
-//#else
-//const scalar_t bn_r={bn_n[0],bn_n[1],bn_n[2],bn_n[3]};
-//#endif
-
-//static const scalar_t &bn_r=bn_n;
-
-extern const scalar_t &bn_r; 
 
 #endif
-

bgn2/src/postcomputation.cpp

@@ -1,23 +0,0 @@
-#include "postcomputation.hpp"
-
-void postcomputation(char& rop, char symbole, BitEvalL3 evalue, PrivateKey private_key)
-{
-	//void dechiffrementL3(F2& bit_dechiffre, BitEvalL3 bit_chiffre, PrivateKey private_key)
-	F2 IS_LOWER_CASE=0;
-	dechiffrementL3(IS_LOWER_CASE,evalue,private_key);
-	char symbole_dechiffree=symbole;
-	//zout(IS_LOWER_CASE); //multiplicationL1L2 dechiffrementL3
-	if (IS_LOWER_CASE == 1)
-	{
-		//cout << symbole << " est sensé être une minuscule!" << endl;
-		symbole_dechiffree=char(symbole-32);
-	}
-	else
-	{
-		//cout << symbole << " est sensé ne pas être une minuscule!" << endl;
-	}
-	//cout << symbole_dechiffree << flush;
-	//zout(sizeof(evalue));
-	rop=symbole_dechiffree;
-
-}

bgn2/src/postcomputation.hpp

@@ -1,18 +0,0 @@
-#ifndef __POSTCOMPUTATION_HPP
-
-#define __POSTCOMPUTATION_HPP
-
-#include <limits.h>		/* for CHAR_BIT */
-#include "typedef.h"
-#include <iostream>
-#include "zout.hpp"
-#include <typeinfo>
-#include <cxxabi.h>
-#include "BitEvalL3.hpp"
-#include "dechiffrementL3.hpp"
-#include "PrivateKey.hpp"
-
-
-void postcomputation(char& rop, char symbole, BitEvalL3 evalue, PrivateKey private_key);
-
-#endif /* __POSTCOMPUTATION_HPP */

bgn2/src/precomputation.cpp

@@ -1,27 +0,0 @@
-#include "precomputation.hpp"
-
-void precomputation(F2 &clair1, F2 &clair2, F2 &clair3, char symbole)
-{
-	//zout(symbole);
-	clair1=bitset<sizeof(int)*CHAR_BIT>(symbole+31)[7] ; //clair de n8 //après l'addition le char est un int, si on fait +0 les 8 premiers bits sont identiques au char, les 24 suivants sont nuls
-	clair2=bitset<sizeof(int)*CHAR_BIT>(symbole+31)[8] ; //clair de n9
-	clair3=bitset<sizeof(int)*CHAR_BIT>(symbole+5)[7] ; //clair de o8
-	//zout(clair1,clair2,clair3); // 100 pour une minuscule
-	
-	//for (unsigned int j=0; j<CHAR_BIT;j++) //pour chaque bit
-	//{
-		//bit_clair=bitset<CHAR_BIT>(symbole)[j] ;
-		//zout(bit_clair);
-	//}
-	
-	//JUMP;
-	//for (unsigned int j=0; j<sizeof(symbole+0)*CHAR_BIT;j++) //pour chaque bit
-	//{
-		//bit_clair=bitset<sizeof(symbole+0)*CHAR_BIT>(symbole+0)[j] ;
-		//zout(bit_clair);
-	//}
-	
-	//cout << abi::__cxa_demangle(typeid(symbole).name(), 0, 0, 0) <<  endl;
-	//cout << abi::__cxa_demangle(typeid(symbole+0).name(), 0, 0, 0) <<  endl;	
-	
-}

bgn2/src/precomputation.hpp

@@ -1,15 +0,0 @@
-#ifndef __PRECOMPUTATION_HPP
-
-#define __PRECOMPUTATION_HPP
-
-#include <limits.h>		/* for CHAR_BIT */
-#include "typedef.h"
-#include <iostream>
-#include "zout.hpp"
-#include <typeinfo>
-#include <cxxabi.h>
-
-
-void precomputation(F2 &clair1, F2 &clair2, F2 &clair3, char lettre);
-
-#endif /* __PRECOMPUTATION_HPP */

bgn2/src/quadruplet.cpp

@@ -1,109 +0,0 @@
-#include "quadruplet.hpp"
-
-
-
-
-
-
-
-
-void fpe_setrandom(fpe_t rop)
-{
-	//zout(sizeof(*rop));
-	//cout << abi::__cxa_demangle(typeid(rop->v[8]).name(), 0, 0, 0) <<  endl;
-	bool tableau_entier[12]={}; /** Les shorts sont stockés sur 2  octets ne provoquent pas d'overflow après 10000 tests. Les ints sur 4 octets provoquent des overflows lorsqu'on multiplie les fpe_t entre eux. La mantisse des doubles est limitée à 53 bits. Les fpe_t sont associées à 12 doubles. On peut aussi générer des ints, puis faire un modulo pour voir la taille maximale. Avec cette méthode, on a pas d'overflow avec un modulo 2<<22-1. Autrement dit, le résultat fait moins de 22 bits soit moins de 2,75 octets. Edit : On a remplacé les shorts par des bools (3 occurences dans le fichier) pour diminuer la taille des coefficients qui faisaient parfois 256 bits et empêchent un décodage L2 correct.  **/
-	FILE * urandom;
-    urandom = fopen ("/dev/urandom","r");
-	if (urandom == NULL)
-	{
-		fprintf(stderr, "Could not open device file /dev/urandom");
-		exit(1);
-	}
-	
-	#ifdef CHECK
-	for (int i=0; i<12;i++)
-	{
-		fread(&tableau_entier[i],sizeof(bool),1,urandom); 
-		(rop->v[i]).v=(double)tableau_entier[i]; 
-		(rop->v[i]).mmax = (unsigned long long)fabs((double)tableau_entier[i]);
-	}
-	#else
-	for (int i=0; i<12;i++)
-	{
-		fread(&tableau_entier[i],sizeof(bool),1,urandom); 
-		rop->v[i]=(double)tableau_entier[i]; // version sans DCHECK, équivalent (*rop).v[i]
-		//zout(log(abs(rop->v[i]))/log(2));
-	}
-	#endif
-	
-
-	//fpe_print(stdout,rop);
-	//cout << endl; 
-	//log2_fpe_print(stdout,rop);
-	//cout << endl; 
-	
-		
-	fclose (urandom);
-
-}
-
-void fpe_ad_minus_bc(fpe_t rop,fpe_t op1,fpe_t op2,fpe_t op3) //(i_1,j_1,k_1,l_1); // rop*op3- op1*op2 = i1*l1 - j1*k1=1  on calcule i1 = (j1*k1 + 1)*l1^(-1)
-{
-	if (fpe_iszero(op3)==1) //1=vrai
-	{
-		fpe_setrandom(rop); //rop quelconque
-		
-		fpe_t temp;
-		fpe_invert(temp,op1);
-		fpe_neg(op2,temp); //op2 = - (1/op1)
-		cout << "op2=k1 modifié car op3=l1 vaut 0" << endl;
-		//fpe_print(stdout,op2);
-		//cout << endl; 
-		//log2_fpe_print(stdout,op2);
-		//cout << endl; 
-	}	
-	else
-	{
-		fpe_t temp1, temp2, temp3, temp4;
-		fpe_mul(temp1,op1,op2);
-		fpe_setone(temp2);
-		fpe_add(temp3,temp1,temp2);
-		fpe_invert(temp4,op3);
-		fpe_mul(rop,temp3,temp4);
-	}
-	
-	
-
-	
-	/** affichage de rop=i1 **/
-	//fpe_print(stdout,rop);
-	//cout << endl; 
-	//log2_fpe_print(stdout,rop);
-	//cout << endl; 
-	
-	/** verifions que ad-bc = 1  **/
-	fpe_t temp5,temp6,temp7;
-	fpe_mul(temp5,rop,op3);
-	fpe_mul(temp6,op1,op2);
-	fpe_sub(temp7,temp5,temp6);
-	
-	
-	//cout << "i1*l1 - j1*k1" << endl;
-	//fpe_print(stdout,temp7);
-	//jump;
-	
-	
-
-}
-
-
-// Print the bitsize of the element to stdout:
-void log2_fpe_print(FILE * outfile, const fpe_t op)
-{
-  int i;
-  for(i=0;i<11;i++)
-  {
-	   fprintf(outfile, "%d, ", int(ceil(log2(fabs(todouble(op->v[i]))))));
-  }
-  fprintf(outfile, "%d\n", int(ceil(log2(fabs(todouble(op->v[11]))))));
-}

bgn2/src/quadruplet.hpp

@@ -1,10 +0,0 @@
-#ifndef __SETTINGS_HPP
-#define __SETTINGS_HPP
-
-#include "bgn.hpp"
-
-void fpe_setrandom(fpe_t rop); //choisit un élément de Fp "au hasard"
-void fpe_ad_minus_bc(fpe_t rop,fpe_t op1,fpe_t op2,fpe_t op3); // calcule a tel que ad-bc=1
-void log2_fpe_print(FILE * outfile, const fpe_t op); // affiche la taille en bits des douze coeffs représentant un élément de Fp
-
-#endif /* __SETTINGS_HPP */

bgn2/src/scalar1024.cpp

@@ -1,58 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <assert.h>
-#include "scalar1024.hpp"
-#include "zout.hpp"
-
-void fp12e_pow_vartime1024(fp12e_t rop, const fp12e_t op, const scalar1024 exp)
-{	
-  fp12e_t dummy;
-  unsigned int startbit;
-
-  startbit = scalar1024_scanb(exp);
-  //zout(startbit);
-  fp12e_set(dummy, op);
-  fp12e_set(rop,op);
-  int i;
-  for(i = startbit; i > 0; i--)
-  {
-    fp12e_square(rop, rop);
-    if(scalar1024_getbit(exp, i - 1)) 
-      fp12e_mul(rop, rop, dummy);
-  }
-}
-
-int scalar1024_getbit(const scalar1024 s, unsigned int pos)
-{
-  //zout(s[0]); 
-  //printf("s[0] en mode d = %d\n", s[0]);
-  //printf("s[0] en mode llx = %llx\n", s[0]);
-
-  assert(pos < 1024);
-  //zout(pos >> 28,s[pos >> 28],(pos & 0x3f),s[pos >> 28] >> (pos & 0x3f));
-  return (s[pos >> 6] >> (pos & 0x3f)) & 1;
-}
-
-// Returns the position of the most significant set bit
-int scalar1024_scanb(const scalar1024 s)
-{
-  int i;
-  unsigned int pos = 0;
-  //for(i=1023;i>0;i--)
-    //if(scalar1024_getbit(s,i) && pos == 0) pos = i;
-  i=1023;
-  while(scalar1024_getbit(s,i)!=1)
-  {i--;}  
-  pos=i;
-  return pos;
-}
-
-void scalar1024_print(FILE *fh, const scalar1024 t)
-{
-  int i;
-  for(i=15;i>=0;i--)
-    fprintf(fh, "%d\t", t[i]);
-    //fprintf(fh, "%llx\t", t[i]);
-
-}
-

bgn2/src/scalar1024.hpp

@@ -1,24 +0,0 @@
-#ifndef SCALAR1024_H
-#define SCALAR1024_H
-#include <stdio.h>
-#include "mul.h" 
-extern "C" {
-#include "fp12e.h"
-}
-
-
-
-
-typedef unsigned long long scalar1024[16] ;
-
-
-int scalar1024_getbit(const scalar1024 s, unsigned int pos);
-
-// Returns the position of the most significant set bit
-int scalar1024_scanb(const scalar1024 s);
-void scalar1024_print(FILE *fh, const scalar1024 t);
-void fp12e_pow_vartime1024(fp12e_t rop, const fp12e_t op, const scalar1024 exp); //NB rajout
-
-
-
-#endif

bgn2/src/test_quadruplet.cpp

@@ -1,42 +0,0 @@
-#include "bgn.hpp"
-
-int main()
-{	
-	//NBTESTS = 
-	//100000 (main @17) 10^5 tests
-	//temps_en_secondes = 
-	//126.74 (main @31) 2 minutes
-
-	
-	/** début chrono **/
-
-	clock_t temps_initial, temps_final;  
-	double temps_en_secondes;    
-	temps_initial = clock (); /* initial time in microseconds */
-	
-	
-	
-	fpe_t i_1,j_1,k_1,l_1;
-	
-	//fpe_t temp;
-	//fpe_setone(temp);
-	//fpe_print(stdout,temp); // 1.000000,   0.000000,   0.000000,   0.000000,   0.000000,   0.000000,   0.000000,   0.000000,   0.000000,   0.000000,   0.000000,   0.000000
-	
-	
-	zout(NBTESTS);
-	for (int num_test=0; num_test<NBTESTS;num_test++)	
-	{
-		//zout(num_test);
-		fpe_setrandom(j_1);
-		fpe_setrandom(k_1);
-		fpe_setrandom(l_1);
-		fpe_ad_minus_bc(i_1,j_1,k_1,l_1); // i1*l1 - j1*k1=1  on calcule i1 = (j1*k1 + 1)*l1^(-1)
-	}
-
-	/** fin chrono **/
-	temps_final = clock (); /* final time in microseconds */
-	temps_en_secondes = (temps_final - temps_initial) * 1e-6; /* total time in seconds */ 
-	//cout << BLUE << "running time = " << temps_en_secondes  << " sec" << RESET << endl;
-	zout(temps_en_secondes) ;
-	return EXIT_SUCCESS;
-}