Adding new functionality to enable proofs of valid votes in PRSONA

bgn2/inc/Bipoint.hpp

@@ -5,6 +5,7 @@
 #include <functional>
 
 #include "Scalar.hpp"
+#include "Curvepoint.hpp"
 #include "print_helpers.hpp"
 
 extern "C" {
@@ -17,11 +18,13 @@ class CurveBipoint
 	public:
 		CurveBipoint();
 		CurveBipoint(curvepoint_fp_t p1, curvepoint_fp_t p2);
+		CurveBipoint(const Curvepoint& p1, const Curvepoint& p2);
 
 		curvepoint_fp_t& operator[](int n);
 		const curvepoint_fp_t& operator[](int n) const;
 
 		CurveBipoint operator+(const CurveBipoint& b) const;
+		CurveBipoint operator-(const CurveBipoint& b) const;
 		CurveBipoint operator*(const Scalar& mult) const;
 
 		bool operator==(const CurveBipoint& b) const;
@@ -55,6 +58,7 @@ class TwistBipoint
 		const twistpoint_fp2_t& operator[](int n) const;
 
 		TwistBipoint operator+(const TwistBipoint& b) const;
+		TwistBipoint operator-(const TwistBipoint& b) const;
 		TwistBipoint operator*(const Scalar& mult) const;
 
 		bool operator==(const TwistBipoint& b) const;

bgn2/inc/Curvepoint.hpp

@@ -17,6 +17,9 @@ class Curvepoint
         Curvepoint();
         Curvepoint(const curvepoint_fp_t input);
 
+        curvepoint_fp_t& toCurvepointFpT();
+        const curvepoint_fp_t& toCurvepointFpT() const;
+
         Curvepoint operator+(const Curvepoint& b) const;
         Curvepoint operator-(const Curvepoint& b) const;
         Curvepoint operator*(const Scalar& mult) const;

bgn2/inc/PublicKey.hpp

@@ -10,9 +10,11 @@ class BGNPublicKey
 {
 	public:
 		BGNPublicKey(const BGNPublicKey& other);
+		
 		void encrypt(CurveBipoint& G_element, const Scalar& cleartext) const;
 		void encrypt(TwistBipoint& H_element, const Scalar& cleartext) const;
 		void encrypt(CurveBipoint& G_element, TwistBipoint& H_element, const Scalar& cleartext) const;
+		CurveBipoint encrypt(Scalar& lambda, const Scalar& cleartext) const;
 
 		CurveBipoint homomorphic_addition(const CurveBipoint& a, const CurveBipoint& b) const;
 		TwistBipoint homomorphic_addition(const TwistBipoint& a, const TwistBipoint& b) const;
@@ -27,6 +29,8 @@ class BGNPublicKey
 		CurveBipoint rerandomize(const CurveBipoint& a) const;
 		TwistBipoint rerandomize(const TwistBipoint& a) const;
 		Quadripoint rerandomize(const Quadripoint& a) const;
+		CurveBipoint rerandomize(Scalar& lambda, const CurveBipoint& a) const;
+		TwistBipoint rerandomize(Scalar& lambda, const TwistBipoint& a) const;
 
 		CurveBipoint get_bipoint_curvegen() const;
 		TwistBipoint get_bipoint_twistgen() const;	

bgn2/src/Bipoint.cpp

@@ -24,6 +24,12 @@ TwistBipoint::TwistBipoint(twistpoint_fp2_t p1, twistpoint_fp2_t p2)
 	twistpoint_fp2_set(point[1], p2);
 }
 
+CurveBipoint::CurveBipoint(const Curvepoint& p1, const Curvepoint& p2)
+{
+	curvepoint_fp_set(point[0], p1.toCurvepointFpT());
+	curvepoint_fp_set(point[1], p2.toCurvepointFpT());
+}
+
 curvepoint_fp_t& CurveBipoint::operator[](int n)
 {
 	return point[n];
@@ -76,6 +82,44 @@ TwistBipoint TwistBipoint::operator+(const TwistBipoint& b) const
 	return retval;
 }
 
+CurveBipoint CurveBipoint::operator-(const CurveBipoint& b) const
+{
+	CurveBipoint retval, inverseB;
+
+	if (!equal(point[0], b[0]))
+    {
+        curvepoint_fp_neg(inverseB[0], b[0]);
+        curvepoint_fp_add_vartime(retval[0], point[0], inverseB[0]);
+    }
+
+	if (!equal(point[1], b[1]))
+	{
+        curvepoint_fp_neg(inverseB[1], b[1]);
+        curvepoint_fp_add_vartime(retval[1], point[1], inverseB[1]);
+	}
+
+	return retval;
+}
+
+TwistBipoint TwistBipoint::operator-(const TwistBipoint& b) const
+{
+	TwistBipoint retval, inverseB;
+
+	if (!equal(point[0], b[0]))
+    {
+        twistpoint_fp2_neg(inverseB[0], b[0]);
+        twistpoint_fp2_add_vartime(retval[0], point[0], inverseB[0]);
+    }
+
+	if (!equal(point[1], b[1]))
+	{
+        twistpoint_fp2_neg(inverseB[1], b[1]);
+        twistpoint_fp2_add_vartime(retval[1], point[1], inverseB[1]);
+	}
+
+	return retval;
+}
+
 CurveBipoint CurveBipoint::operator*(const Scalar& exp) const
 {
 	CurveBipoint retval;

bgn2/src/Curvepoint.cpp

@@ -10,6 +10,16 @@ Curvepoint::Curvepoint(const curvepoint_fp_t input)
     curvepoint_fp_set(point, input);
 }
 
+curvepoint_fp_t& Curvepoint::toCurvepointFpT()
+{
+    return point;
+}
+
+const curvepoint_fp_t& Curvepoint::toCurvepointFpT() const
+{
+    return point;
+}
+
 Curvepoint Curvepoint::operator+(const Curvepoint& b) const
 {
     

bgn2/src/PublicKey.cpp

@@ -18,6 +18,17 @@ void BGNPublicKey::encrypt(CurveBipoint& G_element, const Scalar& cleartext) con
     G_element = cleartext_as_element + random_mask;
 }
 
+CurveBipoint BGNPublicKey::encrypt(Scalar& lambda, const Scalar& cleartext) const
+{
+    lambda.set_random();
+
+    CurveBipoint cleartext_as_element, random_mask;
+    cleartext_as_element = get_bipoint_curvegen() * cleartext;
+    random_mask = get_bipoint_curve_subgroup_gen() * lambda;
+
+    return cleartext_as_element + random_mask;
+}
+
 void BGNPublicKey::encrypt(TwistBipoint& H_element, const Scalar& cleartext) const
 {
     Scalar lambda;
@@ -110,6 +121,26 @@ Quadripoint BGNPublicKey::rerandomize(const Quadripoint& a) const
     return a + random_mask;
 }
 
+CurveBipoint BGNPublicKey::rerandomize(Scalar& lambda, const CurveBipoint& a) const
+{
+    lambda.set_random();
+
+    CurveBipoint random_mask;
+    random_mask = bipoint_curve_subgroup_gen * lambda;
+
+    return a + random_mask;
+}
+
+TwistBipoint BGNPublicKey::rerandomize(Scalar& lambda, const TwistBipoint& a) const
+{
+    lambda.set_random();
+
+    TwistBipoint random_mask;
+    random_mask = bipoint_twist_subgroup_gen * lambda;
+
+    return a + random_mask;
+}
+
 CurveBipoint BGNPublicKey::get_bipoint_curvegen() const
 {
     return bipoint_curvegen;