more of the continuing C++ outbreak

include/codecrypt.h

@@ -4,70 +4,127 @@
 
 #include <vector>
 
-namespace ccr {
+namespace ccr
+{
 
-	typedef std::vector<bool> bvector;
+typedef unsigned int uint;
-	//for broken/old/weird STL uncomment this:
-	//typedef std::bit_vector bvector;
-	//TODO ifdef
-	
-	class matrix : public std::vector<bvector> {
 
-	};
+/*
+ * vector over GF(2). We rely on STL's vector<bool> == bit_vector
+ * specialization for efficiency.
+ */
+class bvector : public std::vector<bool>
+{
+public:
+	uint hamming_weight();
+};
 
-	class permutation : public std::vector<unsigned int> {
+/*
+ * pseudorandom number generator. Meant to be inherited and
+ * instantiated by the user
+ */
+class prng
+{
+public:
+	virtual int random (uint) = 0;
+	virtual void request_seed (uint) = 0;
+};
 
-	};
+/*
+ * matrix over GF(2) is a vector of columns
+ */
+class matrix : public std::vector<bvector>
+{
+public:
+	matrix operator* (const matrix&);
 
-	class polynomial : public bvector {
+	bool compute_inversion (matrix&);
+	void generate_random_invertible (uint, prng&);
+	void unit (uint);
+	void compute_transpose (matrix&);
+};
 
-	};
+/*
+ * permutation is stored as transposition table ordered from zero
+ * e.g. (13)(2) is [2,1,0]
+ */
+class permutation : public std::vector<uint>
+{
+	void compute_inversion (permutation&);
 
-	namespace mce {
+	void generate_random (uint n, prng&);
-		class privkey {
+	void permute_rows (const matrix&, matrix&);
-		public:
+	void permute_cols (const matrix&, matrix&);
-			matrix Sinv;
+};
-			permutation Pinv;
 
-			matrix h;
+/*
-			permutation hsys;
+ * polynomial over GF(2) is effectively a vector with a_n binary values
+ * with some added operations.
+ */
+class polynomial : public bvector
+{
+	bool is_irreducible();
 
-			polynomial g;
+	void generate_random_irreducible (uint n, prng&);
-			matrix sqInv; //"cache"
+};
 
-			int decrypt(const bvector&, bvector&);
+/*
-		};
+ * classical McEliece
+ */
+namespace mce
+{
+class privkey
+{
+public:
+	matrix Sinv;
+	permutation Pinv;
 
-		class pubkey {
+	matrix h;
-		public:
+	permutation hsys;
-			matrix G;
-			int t;
-			int encrypt(const bvector&, bvector&);
-		};
 
-		int generate(pubkey&,privkey&);
+	polynomial g;
-	}
+	matrix sqInv; //"cache"
 
-	namespace nd {
+	int decrypt (const bvector&, bvector&);
-		class privkey {
+};
 
-			int decrypt(const bvector&, bvector&);
+class pubkey
-		};
+{
+public:
+	matrix G;
+	uint t;
+	int encrypt (const bvector&, bvector&, prng&);
+};
 
-		class pubkey {
+int generate (pubkey&, privkey&, prng&);
-		public:
+}
-			matrix H;
-			int t;
 
-			int encrypt(const bvector&, bvector&);
+/*
-		};
+ * classical Niederreiter
+ */
+namespace nd
+{
+class privkey
+{
+public:
+	/*todo stuff*/
 
-		int generate(pubkey&,privkey&);
+	int decrypt (const bvector&, bvector&);
-	}
+};
 
-	//TODO entropy sources
+class pubkey
+{
+public:
+	matrix H;
+	uint t;
 
-} //namespace CCR
+	int encrypt (const bvector&, bvector&, prng&);
+};
+
+int generate (pubkey&, privkey&, prng&);
+}
+
+} //namespace ccr
 
 #endif // _CODECRYPT_H_
 

lib/bvector.cpp

@@ -0,0 +1,11 @@
+
+#include "codecrypt.h"
+using namespace ccr;
+
+uint bvector::hamming_weight()
+{
+	uint r = 0;
+	for (uint i = 0; i < size(); ++i) if ( (*this) [i]) ++r;
+	return r;
+}
+

lib/matrix.cpp

@@ -0,0 +1,25 @@
+
+#include "codecrypt.h"
+
+using namespace ccr;
+
+void matrix::unit (uint size)
+{
+
+}
+
+bool matrix::compute_inversion (matrix&r)
+{
+
+	return false;
+}
+
+void matrix::generate_random_invertible (uint size, prng&rng)
+{
+
+}
+
+void matrix::compute_transpose (matrix&r)
+{
+
+}

lib/permutation.cpp

@@ -0,0 +1,25 @@
+
+#include "codecrypt.h"
+
+using namespace ccr;
+
+void permutation::compute_inversion (permutation&r)
+{
+
+}
+
+void permutation::generate_random (uint size, prng&rng)
+{
+
+}
+
+void permutation::permute_cols (const matrix&a, matrix&r)
+{
+
+}
+
+void permutation::permute_rows (const matrix&a, matrix&r)
+{
+
+}
+

lib/polynomial.cpp

@@ -0,0 +1,15 @@
+
+#include "codecrypt.h"
+
+using namespace ccr;
+
+bool polynomial::is_irreducible()
+{
+
+}
+
+void polynomial::generate_random_irreducible (uint size, prng&rng)
+{
+
+}
+