making serialization possible for hashing (and also network stuff)

bgn2/inc/Bipoint.hpp

@@ -31,6 +31,7 @@ class CurveBipoint
 
 		friend class CurveBipointHash;
 		friend std::ostream& operator<<(std::ostream& os, const CurveBipoint& output);
+		friend std::istream& operator>>(std::istream& is, CurveBipoint& input);
 	
 	private:
 		curvepoint_fp_t point[2];
@@ -63,6 +64,7 @@ class TwistBipoint
 
 		friend class TwistBipointHash;
 		friend std::ostream& operator<<(std::ostream& os, const TwistBipoint& output);
+		friend std::istream& operator>>(std::istream& is, TwistBipoint& input);
 	
 	private:
 		twistpoint_fp2_t point[2];	

bgn2/inc/Curvepoint.hpp

@@ -30,7 +30,8 @@ class Curvepoint
         void make_affine();
 
         friend class CurvepointHash;
-        friend std::ostream& operator<<(std::ostream& os, const Curvepoint& output);   
+        friend std::ostream& operator<<(std::ostream& os, const Curvepoint& output);
+        friend std::istream& operator>>(std::istream& is, Curvepoint& input);
         
     private:
         curvepoint_fp_t point;

bgn2/inc/Quadripoint.hpp

@@ -27,6 +27,7 @@ class Quadripoint
 
 		friend class QuadripointHash;
 		friend std::ostream& operator<<(std::ostream& os, const Quadripoint& output);
+		friend std::istream& operator>>(std::istream& is, Quadripoint& input);
 	
 	private:
 		fp12e_t point[4];

bgn2/inc/print_helpers.hpp

@@ -2,7 +2,9 @@
 #define __PRINT_HELPERS_HPP
 
 #include <iomanip>
+#include <istream>
 #include <ostream>
+#include <cstring>
 
 extern "C" {
 #include "fp12e.h"
@@ -13,38 +15,41 @@ extern "C" {
 
 class Fp12e {
     public:
+        Fp12e();
         Fp12e(const fp12e_t& input);
         friend std::ostream& operator<<(std::ostream& os, const Fp12e& output);
-
-    private:
+        friend std::istream& operator>>(std::istream& is, Fp12e& input);
         fp12e_t data;
 };
 
 class Fp6e {
     public:
+        Fp6e();
         Fp6e(const fp6e_t& input);
         friend std::ostream& operator<<(std::ostream& os, const Fp6e& output);
-
-    private:
+        friend std::istream& operator>>(std::istream& is, Fp6e& input);
         fp6e_t data;
 };
 
 class Fp2e {
     public:
+        Fp2e();
         Fp2e(const fp2e_t& input);
         friend std::ostream& operator<<(std::ostream& os, const Fp2e& output);
-
-    private:
+        friend std::istream& operator>>(std::istream& is, Fp2e& input);
         fp2e_t data;
 };
 
 class Fpe {
     public:
+        Fpe();
         Fpe(const fpe_t& input);
         friend std::ostream& operator<<(std::ostream& os, const Fpe& output);
-
-    private:
+        friend std::istream& operator>>(std::istream& is, Fpe& input);
         fpe_t data;
 };
 
+std::ostream& hex_double(std::ostream& os, double d);
+std::istream& hex_double(std::istream& is, double& d);
+
 #endif

bgn2/src/Bipoint.cpp

@@ -176,30 +176,52 @@ void TwistBipoint::make_affine()
 
 std::ostream& operator<<(std::ostream& os, const CurveBipoint& output)
 {
-	os << "{[";
+	CurveBipoint affine_out = output;
+	affine_out.make_affine();
+
+	for (int i = 0; i < 2; i++)
+		os << Fpe(affine_out[i]->m_x) << Fpe(affine_out[i]->m_y) << Fpe(affine_out[i]->m_z);
+
+	return os;
+}
+
+std::istream& operator>>(std::istream& is, CurveBipoint& input)
+{
+	Fpe x, y, z;
 	for (int i = 0; i < 2; i++)
 	{
-		os << Fpe(output[i]->m_x) << ", " << Fpe(output[i]->m_y) << ", " << Fpe(output[i]->m_z);
-		if (i < 1)
-			os << "], [";
+		is >> x >> y >> z;
+		fpe_set(input[i]->m_x, x.data);
+		fpe_set(input[i]->m_y, y.data);
+		fpe_set(input[i]->m_z, z.data);
 	}
-	os << "]}";
 
-	return os;
+	return is;
 }
 
 std::ostream& operator<<(std::ostream& os, const TwistBipoint& output)
 {
-	os << "{[";
+	TwistBipoint affine_out = output;
+	affine_out.make_affine();
+
+	for (int i = 0; i < 2; i++)
+		os << Fp2e(output[i]->m_x) << Fp2e(output[i]->m_y) << Fp2e(output[i]->m_z);
+
+	return os;
+}
+
+std::istream& operator>>(std::istream& is, TwistBipoint& input)
+{
+	Fp2e x, y, z;
 	for (int i = 0; i < 2; i++)
 	{
-		os << Fp2e(output[i]->m_x) << ", " << Fp2e(output[i]->m_y) << ", " << Fp2e(output[i]->m_z);
-		if (i < 1)
-			os << "], [";
+		is >> x >> y >> z;
+		fp2e_set(input[i]->m_x, x.data);
+		fp2e_set(input[i]->m_y, y.data);
+		fp2e_set(input[i]->m_z, z.data);
 	}
-	os << "]}";
 
-	return os;
+	return is;
 }
 
 size_t CurveBipointHash::operator()(const CurveBipoint& x) const

bgn2/src/Curvepoint.cpp

@@ -146,13 +146,26 @@ void Curvepoint::make_affine()
 
 std::ostream& operator<<(std::ostream& os, const Curvepoint& output)
 {
-    os << "[";
-    os << Fpe(output.point->m_x) << ", " << Fpe(output.point->m_y) << ", " << Fpe(output.point->m_z);
-    os << "]";
+    Curvepoint affine_out = output;
+    affine_out.make_affine();
+    
+    os << Fpe(affine_out.point->m_x) << Fpe(affine_out.point->m_y) << Fpe(affine_out.point->m_z);
 
     return os;
 }
 
+std::istream& operator>>(std::istream& is, Curvepoint& input)
+{
+    Fpe x, y, z;
+    is >> x >> y >> z;
+
+    fpe_set(input.point->m_x, x.data);
+    fpe_set(input.point->m_y, y.data);
+    fpe_set(input.point->m_z, z.data);
+
+    return is;
+}
+
 size_t CurvepointHash::operator()(const Curvepoint& x) const
 {
     if (fpe_iszero(x.point->m_z))

bgn2/src/Quadripoint.cpp

@@ -92,18 +92,25 @@ bool Quadripoint::operator!=(const Quadripoint& b) const
 
 std::ostream& operator<<(std::ostream& os, const Quadripoint& output)
 {
-	os << "{[";
 	for (int i = 0; i < 4; i++)
-	{
 		os << Fp12e(output[i]);
-		if (i < 3)
-			os << "], [";
-	}
-	os << "]}";
 
 	return os;
 }
 
+std::istream& operator>>(std::istream& is, Quadripoint& input)
+{
+	Fp12e realIn[4];
+	
+	for (int i = 0; i < 4; i++)
+	{
+		is >> realIn[i];
+		fp12e_set(input[i], realIn[i].data);
+	}
+
+	return is;
+}
+
 size_t QuadripointHash::operator()(const Quadripoint& x) const
 {
 	size_t retval = 0;

bgn2/src/print_helpers.cpp

@@ -5,55 +5,127 @@ Fp12e::Fp12e(const fp12e_t& input)
     fp12e_set(data, input);
 }
 
+Fp12e::Fp12e()
+{
+    fp12e_setzero(data);
+}
+
 Fp6e::Fp6e(const fp6e_t& input)
 {
     fp6e_set(data, input);
 }
 
+Fp6e::Fp6e()
+{
+    fp6e_setzero(data);
+}
+
 Fp2e::Fp2e(const fp2e_t& input)
 {
     fp2e_set(data, input);
 }
 
+Fp2e::Fp2e()
+{
+    fp2e_setzero(data);
+}
+
 Fpe::Fpe(const fpe_t& input)
 {
     fpe_set(data, input);
 }
 
+Fpe::Fpe()
+{
+    fpe_setzero(data);
+}
+
 std::ostream& operator<<(std::ostream& os, const Fp12e& output)
 {
-    os << "(" << Fp6e(output.data->m_a) << " * Z + " << Fp6e(output.data->m_b) << ")";
+    os << Fp6e(output.data->m_a) << Fp6e(output.data->m_b);
 
     return os;
 }
 
+std::istream& operator>>(std::istream& is, Fp12e& input)
+{
+    Fp6e a, b;
+    is >> a >> b;
+
+    fp6e_set(input.data->m_a, a.data);
+    fp6e_set(input.data->m_b, b.data);
+
+    return is;
+}
+
 std::ostream& operator<<(std::ostream& os, const Fp6e& output)
 {
-    os << "(" << Fp2e(output.data->m_a) << " * Y^2 + " << Fp2e(output.data->m_b) << " * Y + " << Fp2e(output.data->m_c) << ")";
+    os << Fp2e(output.data->m_a) << Fp2e(output.data->m_b) << Fp2e(output.data->m_c);
 
     return os;
 }
 
+std::istream& operator>>(std::istream& is, Fp6e& input)
+{
+    Fp2e a, b, c;
+    is >> a >> b >> c;
+
+    fp2e_set(input.data->m_a, a.data);
+    fp2e_set(input.data->m_b, b.data);
+    fp2e_set(input.data->m_c, c.data);
+
+    return is;
+}
+
 std::ostream& operator<<(std::ostream& os, const Fp2e& output)
 {
     fpe_t a, b;
     fp2e_to_2fpe(a, b, output.data);
 
-    os << "(" << Fpe(a) << " * X + " << Fpe(b) << ")";
+    os << Fpe(a) << Fpe(b);
 
     return os;
 }
 
+std::istream& operator>>(std::istream& is, Fp2e& input)
+{
+    Fpe a, b;
+    is >> a >> b;
+    _2fpe_to_fp2e(input.data, a.data, b.data);
+
+    return is;
+}
+
 std::ostream& operator<<(std::ostream& os, const Fpe& output)
 {
-    os << "(";
     for (int i = 0; i < 12; i++)
-    {
-        os << std::setw(10) << output.data->v[i] << std::setw(0);
-        if (i < 11)
-            os << ", ";
-    }
-    os << ")";
+        hex_double(os, output.data->v[i]);
 
     return os;
 }
+
+std::istream& operator>>(std::istream& is, Fpe& input)
+{ 
+    for (int i = 0; i < 12; i++)
+        hex_double(is, input.data->v[i]);
+
+    return is;       
+}
+
+std::ostream& hex_double(std::ostream& os, double d)
+{
+    uint64_t u;
+    memcpy(&u, &d, sizeof(d));
+    os << std::hex << std::setw(16) << u << std::setw(0) << std::dec;
+
+    return os;
+}
+
+std::istream& hex_double(std::istream& is, double& d)
+{
+    uint64_t u;
+    is >> std::hex >> u >> std::dec;
+    memcpy(&d, &u, sizeof(u));
+
+    return is;
+}