From a068c34862b8182ad214aa8b3ed8ccd969b42f38 Mon Sep 17 00:00:00 2001 From: Gabriel Tofvesson Date: Tue, 27 Feb 2018 21:40:39 +0100 Subject: [PATCH 1/7] Added makefile Changed defines to support linux Fixed types --- makefile | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 makefile diff --git a/makefile b/makefile new file mode 100644 index 0000000..a6e0a85 --- /dev/null +++ b/makefile @@ -0,0 +1,18 @@ +start: + $(info No recipe specified!) + +xmath: + mkdir -p build/include + mkdir -p build/lib + mkdir -p XMath/intermediate + g++ -c XMath/BigInteger.cpp -o XMath/intermediate/BigInteger.o + g++ -c XMath/Matrix.cpp -o XMath/intermediate/Matrix.o + ar rcs build/lib/libxmath.a XMath/intermediate/* + cp XMath/*.h* build/include/ + rm -r XMath/intermediate/ + +clean: + mkdir -p build + rm -r build + mkdir -p XMath/intermediate + rm -r XMath/intermediate From a9df66c179b6b61ca881e091fea510f69e1f9a06 Mon Sep 17 00:00:00 2001 From: Gabriel Tofvesson Date: Tue, 27 Feb 2018 21:59:19 +0100 Subject: [PATCH 2/7] Fixed files not being added --- .gitignore | 3 ++- XMath/BigInteger.cpp | 26 ++++++++++--------- XMath/BigInteger.h | 41 +++++++++++++++++++----------- XMath/Matrix.cpp | 59 ++++++++++++++++++++++---------------------- XMath/Matrix.h | 50 +++++++++++++++++++++++-------------- 5 files changed, 104 insertions(+), 75 deletions(-) diff --git a/.gitignore b/.gitignore index 3c4efe2..e941d87 100644 --- a/.gitignore +++ b/.gitignore @@ -21,6 +21,7 @@ bld/ [Bb]in/ [Oo]bj/ [Ll]og/ +build/ # Visual Studio 2015 cache/options directory .vs/ @@ -258,4 +259,4 @@ paket-files/ # Python Tools for Visual Studio (PTVS) __pycache__/ -*.pyc \ No newline at end of file +*.pyc diff --git a/XMath/BigInteger.cpp b/XMath/BigInteger.cpp index e733ca1..854bd62 100644 --- a/XMath/BigInteger.cpp +++ b/XMath/BigInteger.cpp @@ -2,14 +2,15 @@ #include "BigInteger.h" + namespace CryptoCPP { namespace Math { - BIGINT_API BigInteger::BigInteger(int64_t initialValue) + BIGINT_API BigInteger::BigInteger(long long initialValue) { data = new std::vector(); // We know how big this should be and we know the size won't change - static const size_t bytes = sizeof(int64_t); + static const size_t bytes = sizeof(initialValue); for (size_t t = 0; t < bytes; ++t) data->push_back((initialValue >> (t * 8)) & 255); sign = false; @@ -93,14 +94,14 @@ namespace CryptoCPP { return create; } - BIGINT_API BigInteger * BigInteger::operator<<(uint64_t shiftcount) const + BIGINT_API BigInteger * BigInteger::operator<<(size_t shiftcount) const { BigInteger* create = new BigInteger(*this); create->ishl(shiftcount); return create; } - BIGINT_API BigInteger * BigInteger::operator>>(uint64_t shiftcount) const + BIGINT_API BigInteger * BigInteger::operator>>(size_t shiftcount) const { BigInteger* create = new BigInteger(*this); create->ishr(shiftcount); @@ -157,13 +158,13 @@ namespace CryptoCPP { return this; } - BIGINT_API BigInteger* BigInteger::operator<<=(uint64_t shiftcount) + BIGINT_API BigInteger* BigInteger::operator<<=(size_t shiftcount) { ishl(shiftcount); return this; } - BIGINT_API BigInteger* BigInteger::operator>>=(uint64_t shiftcount) + BIGINT_API BigInteger* BigInteger::operator>>=(size_t shiftcount) { ishr(shiftcount); return this; @@ -338,7 +339,7 @@ namespace CryptoCPP { BIGINT_API BigInteger* BigInteger::idiv(const BigInteger & val, bool swaptarget) { - if (val.is_zero()) throw new std::exception("Divide by zero!"); + if (val.is_zero()) throw new std::exception(); // Divide by zero! BigInteger* rem = new BigInteger(0); BigInteger quot = BigInteger(0); @@ -403,7 +404,7 @@ namespace CryptoCPP { for (size_t t = 0; t < data->size(); ++t) (*data)[t] = ~(*data)[t]; } - BIGINT_API void BigInteger::ishl(uint64_t shift) + BIGINT_API void BigInteger::ishl(size_t shift) { size_t set = shift / 8; char sub = shift % 8; @@ -430,7 +431,7 @@ namespace CryptoCPP { clip_zeroes(); } - BIGINT_API void BigInteger::ishr(uint64_t shift) + BIGINT_API void BigInteger::ishr(size_t shift) { size_t offset = shift / 8; char sub = shift % 8; @@ -491,10 +492,10 @@ namespace CryptoCPP { return ((l1 > l2 && (!sign == grt)) || ((sign == grt) && l1 < l2)) ? 1 : 0; } - BIGINT_API char BigInteger::shift_mask(int64_t shift, bool left) + BIGINT_API char BigInteger::shift_mask(size_t shift, bool left) { BYTE res = 0; - for (uint64_t i = shift; i > 0; --i) res = left ? (res >> 1) | 128 : (res << 1) | 1; + for (size_t i = shift; i > 0; --i) res = left ? (res >> 1) | 128 : (res << 1) | 1; return res; } @@ -547,4 +548,5 @@ namespace CryptoCPP { } } -} \ No newline at end of file +} + diff --git a/XMath/BigInteger.h b/XMath/BigInteger.h index 97b495b..36f2739 100644 --- a/XMath/BigInteger.h +++ b/XMath/BigInteger.h @@ -2,11 +2,23 @@ #include -#ifdef BIGINT_API -#define BIGINT_API __declspec(dllexport) -#else -#define BIGINT_API __declspec(dllimport) -#endif +#if defined(__MINGW32__) || defined(_WIN32) + +#if defined(BIGINT_API) +#define BIGINT_API __declspec(dllexport) +#else +#define BIGINT_API __declspec(dllimport) +#endif + +#endif + +#ifndef BIGINT_API + #if __GNUC__ >= 4 + #define BIGINT_API __attribute__ ((visibility ("default"))) + #else + #define BIGINT_API + #endif +#endif #define BYTE unsigned char @@ -16,7 +28,7 @@ namespace CryptoCPP { class BigInteger { public: - BIGINT_API BigInteger(int64_t initialValue); + BIGINT_API BigInteger(long long initialValue); BIGINT_API BigInteger(const BigInteger& initialvalue); // These should just create a new bigint and call the internal functions on it @@ -29,8 +41,8 @@ namespace CryptoCPP { BIGINT_API BigInteger* operator&(const BigInteger& val) const; BIGINT_API BigInteger* operator|(const BigInteger& val) const; BIGINT_API BigInteger* operator~() const; - BIGINT_API BigInteger* operator<<(uint64_t shiftcount) const; - BIGINT_API BigInteger* operator>>(uint64_t shiftcount) const; + BIGINT_API BigInteger* operator<<(size_t shiftcount) const; + BIGINT_API BigInteger* operator>>(size_t shiftcount) const; BIGINT_API BigInteger* operator+=(const BigInteger& val); BIGINT_API BigInteger* operator-=(const BigInteger& val); @@ -40,8 +52,8 @@ namespace CryptoCPP { BIGINT_API BigInteger* operator^=(const BigInteger& val); BIGINT_API BigInteger* operator&=(const BigInteger& val); BIGINT_API BigInteger* operator|=(const BigInteger& val); - BIGINT_API BigInteger* operator<<=(uint64_t shiftcount); - BIGINT_API BigInteger* operator>>=(uint64_t shiftcount); + BIGINT_API BigInteger* operator<<=(size_t shiftcount); + BIGINT_API BigInteger* operator>>=(size_t shiftcount); BIGINT_API bool operator<(const BigInteger& val) const; BIGINT_API bool operator>(const BigInteger& val) const; @@ -66,8 +78,8 @@ namespace CryptoCPP { BIGINT_API void iand(const BigInteger& val, bool swaptarget); BIGINT_API void ior(const BigInteger& val, bool swaptarget); BIGINT_API void inot(); - BIGINT_API void ishl(uint64_t shift); - BIGINT_API void ishr(uint64_t shift); + BIGINT_API void ishl(size_t shift); + BIGINT_API void ishr(size_t shift); BIGINT_API void twos_complement(); BIGINT_API void set_bit(size_t index, bool value); BIGINT_API void cpy(const BigInteger& val, bool withsign); @@ -75,7 +87,7 @@ namespace CryptoCPP { BIGINT_API char cmp(const BigInteger& other, bool grt) const; // Math helper functions - BIGINT_API char shift_mask(int64_t shift, bool left); + BIGINT_API char shift_mask(size_t shift, bool left); // For sorting and whatnot BIGINT_API void clip_zeroes(); @@ -85,4 +97,5 @@ namespace CryptoCPP { BIGINT_API bool is_zero() const; }; } -} \ No newline at end of file +} + diff --git a/XMath/Matrix.cpp b/XMath/Matrix.cpp index cba4dbb..b8f7355 100644 --- a/XMath/Matrix.cpp +++ b/XMath/Matrix.cpp @@ -1,5 +1,6 @@ #define MATRIX_API #include "Matrix.h" +#include namespace CryptoCPP { namespace Math { @@ -20,13 +21,13 @@ namespace CryptoCPP { MATRIX_API long long Vector::at(size_t index) const { - if (index < 0 || index >= count) throw new std::exception("Index out of bounds"); + if (index < 0 || index >= count) throw new std::exception(); // Index out of bounds return valueSet[index]; } MATRIX_API long long Vector::at(size_t index, long long newval) { - if (index < 0 || index >= count) throw new std::exception("Index out of bounds"); + if (index < 0 || index >= count) throw new std::exception(); // Index out of bounds long long l = valueSet[index]; valueSet[index] = newval; return l; @@ -40,12 +41,12 @@ namespace CryptoCPP { this->context = context; } - MATRIX_API const DelegatingFPTR* DelegatingFPTR::operator()(const Vector & input, size_t index) const + MATRIX_API const DelegatingFPTR DelegatingFPTR::operator()(const Vector & input, size_t index) const { return (context->*impl)(input, index); } - MATRIX_API const DelegatingFPTR* DelegatingFPTR::operator()(Vector * input, size_t index) const + MATRIX_API const DelegatingFPTR DelegatingFPTR::operator()(Vector * input, size_t index) const { return (context->*point)(input, index); } @@ -72,59 +73,59 @@ namespace CryptoCPP { delete[] columns; } - MATRIX_API const DelegatingFPTR* Matrix::set_row(const Vector & row, size_t rowidx) + MATRIX_API const DelegatingFPTR Matrix::set_row(const Vector & row, size_t rowidx) { return set_row_r(row, rowidx); } - MATRIX_API const DelegatingFPTR* Matrix::set_col(const Vector & col, size_t colidx) + MATRIX_API const DelegatingFPTR Matrix::set_col(const Vector & col, size_t colidx) { return set_col_r(col, colidx); } - MATRIX_API const DelegatingFPTR* Matrix::set_row(Vector * row, size_t rowidx) + MATRIX_API const DelegatingFPTR Matrix::set_row(Vector * row, size_t rowidx) { return set_row_p(row, rowidx); } - MATRIX_API const DelegatingFPTR* Matrix::set_col(Vector * col, size_t colidx) + MATRIX_API const DelegatingFPTR Matrix::set_col(Vector * col, size_t colidx) { return set_col_p(col, colidx); } - MATRIX_API const DelegatingFPTR* Matrix::set_row_r(const Vector & row, size_t rowidx) + MATRIX_API const DelegatingFPTR Matrix::set_row_r(const Vector & row, size_t rowidx) { - if (rowidx >= height) throw new std::exception("Row index out of bounds"); + if (rowidx >= height) throw new std::exception(); // Index out of bounds size_t min = row.count < width ? row.count : width; for (size_t t = 0; t < min; ++t) columns[t]->at(rowidx, row.at(t)); - return ar; + return *ar; } - MATRIX_API const DelegatingFPTR* Matrix::set_col_r(const Vector & col, size_t colidx) + MATRIX_API const DelegatingFPTR Matrix::set_col_r(const Vector & col, size_t colidx) { - if (colidx >= width) throw new std::exception("Column index out of bounds"); + if (colidx >= width) throw new std::exception(); // Index out of bounds size_t min = col.count < height ? col.count : height; for (size_t t = 0; t < height; ++t) columns[colidx]->at(t, col.at(t)); - return ac; + return *ac; } - MATRIX_API const DelegatingFPTR* Matrix::set_row_p(Vector * row, size_t rowidx) + MATRIX_API const DelegatingFPTR Matrix::set_row_p(Vector * row, size_t rowidx) { - const DelegatingFPTR * chain = set_row((const Vector&) *row, rowidx); + const DelegatingFPTR chain = set_row((const Vector&) *row, rowidx); delete row; return chain; } - MATRIX_API const DelegatingFPTR* Matrix::set_col_p(Vector * col, size_t colidx) + MATRIX_API const DelegatingFPTR Matrix::set_col_p(Vector * col, size_t colidx) { - const DelegatingFPTR * chain = set_col((const Vector&) *col, colidx); + const DelegatingFPTR chain = set_col((const Vector&) *col, colidx); delete col; return chain; } MATRIX_API long long Matrix::set_at(size_t col, size_t row, long long value) { - if (col < 0 || col >= width || row < 0 || row >= height) throw new std::exception("Index out of bounds"); + if (col < 0 || col >= width || row < 0 || row >= height) throw new std::exception(); // Index out of bounds return columns[col]->at(row, value); } @@ -135,7 +136,7 @@ namespace CryptoCPP { MATRIX_API Vector * Matrix::at_row(size_t index) const { - if (index < 0 || index >= height) throw new std::exception("Index out of bounds"); + if (index < 0 || index >= height) throw new std::exception(); // Index out of bounds Vector * collect = new Vector(width); for (size_t t = 0; t < width; ++t) collect->at(t, columns[t]->at(index)); @@ -144,7 +145,7 @@ namespace CryptoCPP { MATRIX_API Vector * Matrix::at_col(size_t index) const { - if (index < 0 || index >= width) throw new std::exception("Index out of bounds"); + if (index < 0 || index >= width) throw new std::exception(); // Index out of bounds Vector * collect = new Vector(height); for (size_t t = 0; t < height; ++t) collect->at(t, columns[index]->at(t)); @@ -153,7 +154,7 @@ namespace CryptoCPP { MATRIX_API long long Matrix::at(size_t col, size_t row) const { - if (col < 0 || col >= width || row < 0 || row >= height) throw new std::exception("Index out of bounds"); + if (col < 0 || col >= width || row < 0 || row >= height) throw new std::exception(); // Index out of bounds return columns[col]->at(row); } @@ -164,7 +165,7 @@ namespace CryptoCPP { MATRIX_API Matrix * Matrix::mul(const Matrix & factor) const { - if (factor.height != width) throw new std::exception("Mismatched dimensions"); + if (factor.height != width) throw new std::exception(); // Index out of bounds Matrix* result = new Matrix(height, factor.width); for (size_t i = 0; i < factor.width; ++i) for (size_t j = 0; j < height; ++j) @@ -197,10 +198,10 @@ namespace CryptoCPP { return mul(scalar); } - MATRIX_API Matrix * Matrix::minor(size_t row, size_t col) const + MATRIX_API Matrix * Matrix::get_minor(size_t row, size_t col) const { if (height == 0 || width == 0) return new Matrix(0, 0); - if (row >= height || col >= width) throw new std::exception("Index out of bounds"); + if (row >= height || col >= width) throw new std::exception(); // Index out of bounds Matrix* result = new Matrix(height - 1, width - 1); for (size_t i = 0; i < width; ++i) { if (i == col) continue; @@ -215,8 +216,8 @@ namespace CryptoCPP { MATRIX_API long long Matrix::det() const { // Matrix safety checks - if (height != width) throw new std::exception("Matrix must be square to compute the determinant"); - if (!height) throw new std::exception("Zero-matrix does not have a determinant"); + if (height != width) throw new std::exception(); // Only square matrices have determinants + if (!height) throw new std::exception(); // Zero-matrix doesn't have a determinant // Compute determinant for 1x1 matrix if (height == 1) return columns[0]->at(0); @@ -224,7 +225,7 @@ namespace CryptoCPP { // Compute determinant for higher-order matrices long long result = 0; for (size_t t = 0; t < width; ++t) { - Matrix * smaller = minor(0, t); // Compute minor + Matrix * smaller = get_minor(0, t); // Compute minor result += smaller->det() * columns[t]->at(0) * (long long)((t % 2) ? -1 : 1); // Compute partial determinant for the given minor delete smaller; // Delete allocated minor } @@ -232,4 +233,4 @@ namespace CryptoCPP { } } -} \ No newline at end of file +} diff --git a/XMath/Matrix.h b/XMath/Matrix.h index 370e7cc..ddde0bd 100644 --- a/XMath/Matrix.h +++ b/XMath/Matrix.h @@ -2,12 +2,25 @@ #include -#ifdef MATRIX_API -#define MATRIX_API __declspec(dllexport) -#else -#define MATRIX_API __declspec(dllimport) +#if defined(__MINGW32__) || defined(_WIN32) + +#if defined(MATRIX_API) +#define MATRIX_API __declspec(dllexport) +#else +#define MATRIX_API __declspec(dllimport) #endif +#endif + +#ifndef MATRIX_API + #if __GNUC__ >= 4 + #define MATRIX_API __attribute__ ((visibility ("default"))) + #else + #define MATRIX_API + #endif +#endif + + #define WITH ->operator() namespace CryptoCPP { @@ -32,16 +45,15 @@ namespace CryptoCPP { class DelegatingFPTR; - typedef const DelegatingFPTR*(Matrix::*Delegate)(const Vector & input, size_t at); - typedef const DelegatingFPTR*(Matrix::*PDelegate)(const Vector * input, size_t at); + typedef const DelegatingFPTR(Matrix::*Delegate)(const Vector & input, size_t at); + typedef const DelegatingFPTR(Matrix::*PDelegate)(const Vector * input, size_t at); class DelegatingFPTR { public: - DelegatingFPTR(Delegate impl, PDelegate point, Matrix* context); - MATRIX_API const DelegatingFPTR* operator()(const Vector & input, size_t index) const; - MATRIX_API const DelegatingFPTR* operator()(Vector * input, size_t index) const; + MATRIX_API const DelegatingFPTR operator()(const Vector & input, size_t index) const; + MATRIX_API const DelegatingFPTR operator()(Vector * input, size_t index) const; protected: Delegate impl; PDelegate point; @@ -55,15 +67,15 @@ namespace CryptoCPP { MATRIX_API Matrix(const Matrix & copy); MATRIX_API ~Matrix(); - MATRIX_API const DelegatingFPTR* set_row(const Vector & row, size_t rowidx); - MATRIX_API const DelegatingFPTR* set_col(const Vector & col, size_t colidx); - MATRIX_API const DelegatingFPTR* set_row(Vector * row, size_t rowidx); - MATRIX_API const DelegatingFPTR* set_col(Vector * col, size_t colidx); + MATRIX_API const DelegatingFPTR set_row(const Vector & row, size_t rowidx); + MATRIX_API const DelegatingFPTR set_col(const Vector & col, size_t colidx); + MATRIX_API const DelegatingFPTR set_row(Vector * row, size_t rowidx); + MATRIX_API const DelegatingFPTR set_col(Vector * col, size_t colidx); - MATRIX_API const DelegatingFPTR* set_row_r(const Vector & row, size_t rowidx); - MATRIX_API const DelegatingFPTR* set_col_r(const Vector & col, size_t colidx); - MATRIX_API const DelegatingFPTR* set_row_p(Vector * row, size_t rowidx); - MATRIX_API const DelegatingFPTR* set_col_p(Vector * col, size_t colidx); + MATRIX_API const DelegatingFPTR set_row_r(const Vector & row, size_t rowidx); + MATRIX_API const DelegatingFPTR set_col_r(const Vector & col, size_t colidx); + MATRIX_API const DelegatingFPTR set_row_p(Vector * row, size_t rowidx); + MATRIX_API const DelegatingFPTR set_col_p(Vector * col, size_t colidx); MATRIX_API long long set_at(size_t col, size_t row, long long value); MATRIX_API long long set_at(size_t index, bool rowMajor, long long value); @@ -79,7 +91,7 @@ namespace CryptoCPP { MATRIX_API Matrix* operator*(const Matrix * factor) const; MATRIX_API Matrix* operator*(long long scalar) const; - MATRIX_API Matrix* minor(size_t row, size_t col) const; + MATRIX_API Matrix* get_minor(size_t row, size_t col) const; MATRIX_API long long det() const; protected: @@ -90,4 +102,4 @@ namespace CryptoCPP { const size_t width; }; } -} \ No newline at end of file +} From 9399030a9a95a232444a885b75f8466f679a340a Mon Sep 17 00:00:00 2001 From: Gabriel Tofvesson Date: Wed, 28 Feb 2018 02:38:29 +0100 Subject: [PATCH 3/7] Started implementing Galois class --- XMath/Galois.h | 70 ++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 57 insertions(+), 13 deletions(-) diff --git a/XMath/Galois.h b/XMath/Galois.h index d238355..8adfe2d 100644 --- a/XMath/Galois.h +++ b/XMath/Galois.h @@ -1,29 +1,73 @@ #pragma once +#if defined(__MINGW32__) || defined(_WIN32) + +#if defined(GALOIS_API) +#define GALOIS_API __declspec(dllexport) +#else +#define GALOIS_API __declspec(dllimport) +#endif + +#endif + +#ifndef GALOIS_API + #if __GNUC__ >= 4 + #define GALOIS_API __attribute__ ((visibility ("default"))) + #else + #define GALOIS_API + #endif +#endif + + namespace CryptoCPP { namespace Math { class Galois { public: - Galois(size_t characteristic, size_t exponent, size_t irreducible); + GALOIS_API Galois( + size_t characteristic, + size_t exponent, + size_t * irreducible, + size_t irreducible_size, + size_t * value + ); + GALOIS_API ~Galois(); - Galois * add(const Galois * value) const; // Add - Galois * sub(const Galois * value) const; // Subtract - Galois * mul(const Galois * value) const; // Multiply - Galois * inv(const Galois * value) const; // Inverse multiply + // Addition + GALOIS_API Galois * add(const Galois * value) const; + + // Subtraction + GALOIS_API Galois * sub(const Galois * value) const; + + // Multiplication + GALOIS_API Galois * mul(const Galois * value) const; + + // Inverse multiplication + GALOIS_API Galois * inv(const Galois * value) const; protected: - size_t characteristic, exponent, irreducible; + static const size_t high_bit = 1 << ((sizeof(size_t)*8)-1); + // GF parameters + const size_t characteristic, exponent, irreducible; + // Effective storage params + const size_t binary_block_size, data_size; + // Value of this GF object + const size_t * data; - // Reduce the value of this galois to one that fits the field parameters - void reduce(); + + // Reduce the value of this galois to fit characteristic + GALOIS_API void reduce(); // Self-mutable operations - void iadd(const Galois * value); - void isub(const Galois * value); - void imul(const Galois * value); - void iinv(const Galois * value); + GALOIS_API void iadd(const Galois * value); + GALOIS_API void isub(const Galois * value); + GALOIS_API void imul(const Galois * value); + GALOIS_API void iinv(const Galois * value); + + GALOIS_API size_t _mask(size_t bits, bool side) const; + GALOIS_API size_t get_value(size_t idx) const; + GALOIS_API void set_value(size_t idx, size_t value); }; } -} \ No newline at end of file +} From 3f7eddc3786e669f0d6e9d47a743f16ed4231e3a Mon Sep 17 00:00:00 2001 From: Gabriel Tofvesson Date: Wed, 28 Feb 2018 02:41:19 +0100 Subject: [PATCH 4/7] Added Galois implementation --- XMath/Galois.cpp | 170 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 170 insertions(+) create mode 100644 XMath/Galois.cpp diff --git a/XMath/Galois.cpp b/XMath/Galois.cpp new file mode 100644 index 0000000..a08d72f --- /dev/null +++ b/XMath/Galois.cpp @@ -0,0 +1,170 @@ +#include "Galois.h" + +namespace CryptoCPP{ + namespace Math{ + size_t _ceil(double d) + { + return (size_t)d + (d > (size_t)d ? 1 : 0); + } + + GALOIS_API Galois::Galois( + size_t characteristic, + size_t exponent, + size_t * irreducible, + size_t irreducible_size, + size_t * value + ) : + characteristic(characteristic), + exponent(exponent), + irreducible(irreducible), + irreducible_size(irreducible_size), + binary_block_size(_ceil(characteristic/2.0)), + data_size(binary_block_size * exponent) + { + data = value; + } + + GALOIS_API Galois::Galois(Galois & copy) : + characteristic(copy.characteristic), + exponent(copy.exponent), + irreducible(new size_t[copy.irreducible_size]), + irreducible_size(copy.irreducible_size), + binary_block_size(copy.binary_block_size), + data_size(copy.data_size) + { + data = new size_t[data_size]; + memcpy(irreducible, copy.irreducible, irreducible_size * sizeof(size_t)); + memcpy(data, copy.data, data_size * sizeof(size_t)); + } + + GALOIS_API Galois::~Galois() + { + delete[] irreducible; + delete[] data; + } + + GALOIS_API Galois * Galois::add(const Galois * value) const + { + Galois * result = new Galois(*this); + result->iadd(value); + return result; + } + + GALOIS_API Galois * Galois::sub(const Galois * value) const + { + Galois * result = new Galois(*this); + result->isub(value); + return result; + } + + GALOIS_API Galois * Galois::mul(const Galois * value) const + { + Galois * result = new Galois(*this); + result->imul(value); + return result; + } + + GALOIS_API Galois * Galois::inv(const Galois * value) const + { + Galois * result = new Galois(*this); + result->iinv(value); + return result; + } + + GALOIS_API void Galois::iadd(const Galois * value) + { + size_t min = data_size < value->data_size ? data_size : value->data_size; + for(size_t t = 0; tget_value(t)) % characteristic; + set_value(t, block); + } + } + + GALOIS_API void Galois::isub(const Galois * value) + { + + } + + GALOIS_API void Galois::imul(const Galois * value) + { + + } + + GALOIS_API void Galois::iinv(cosnt Galois * value) + { + + } + + GALOIS_API size_t Galois::_mask(size_t bits, bool side) const + { + size_t result = 0; + for(size_t t = 0; t>1)|high_bit; + return result; + } + + GALOIS_API size_t Galois::get_value(size_t index) const + { + // Compute block/sub-block indexing + size_t upper_bit_size = ((binary_block_size*index)%(8*sizeof(size_t)))%binary_block_size; + size_t upper_block_index = (index*binary_block_size)/8; + size_t lower_block_index = ((index - upper_bit_size)*binary_block_size)/8; + + // Boundary disparity check + if(upper_block_index!=lower_block_index) + { + // Get block values + size_t upper_block = data[upper_block_index] & _mask(upper_bit_size, true); + size_t lower_block = data[lower_block_index] & _mask(binary_block_size-upper_bit_size, false); + + // Do alignment + size_t block = (upper_block << (binary_block_size - upper_bit_size)) | (lower_block >> ((sizeof(size_t)*8)-upper_bit_size)); + + return block; + } + else + { + // Passed: no boundary disparity + size_t shift = (binary_block_size * index) % (8 * sizeof(size_t)); + size_t block_index = (binary_block_size * index) / (8 * sizeof(size_t)); + + // Get and mask + return data[block_index] >> shift & _mask(binary_block_size, true); + } + } + + GALOIS_API void Galois::set_value(size_t index, size_t value) + { + value = value % characteristic; + + // Compute block/sub-block indexing + size_t upper_bit_size = ((binary_block_size*index)%(8*sizeof(size_t)))%binary_block_size; + size_t upper_block_index = (index*binary_block_size)/8; + size_t lower_block_index = ((index - upper_bit_size)*binary_block_size)/8; + + // Boundary disparity check + if(upper_block_index!=lower_block_index) + { + // Mask bits + data[upper_block_index] &= ~_mask(upper_bit_size, false); + data[lower_block_index] &= ~_mask(binary_block_size-upper_bit_size, true); + + // Get block values + data[upper_block_index] = value >> (binary_block_size - upper_bit_size); + data[lower_block_index] = (value & _mask(binary_block_size-upper_bit_size, false)) << ((8 * sizeof(size_t)) - (binary_block_size - upper_bit_size)); + } + else + { + // Passed: no boundary disparity + size_t shift = (binary_block_size * index) % (8 * sizeof(size_t)); + size_t block_index = (binary_block_size * index) / (8 * sizeof(size_t)); + + // Mask bits + data[block_index] &= ~_mask(binary_block_size, false) << shift; + + // Apply shift + data[block_index] = value << shift; + } + } + } +} From 341fb538a8101fcf5affb637b129870984056378 Mon Sep 17 00:00:00 2001 From: GabrielTofvesson Date: Thu, 1 Mar 2018 01:14:51 +0100 Subject: [PATCH 5/7] Started properly implementing galois 'n stuff --- XMath/Galois.cpp | 203 +++++++++++++++++++++++++----------- XMath/Galois.h | 40 +++---- XMath/XMath.vcxproj | 1 + XMath/XMath.vcxproj.filters | 3 + 4 files changed, 171 insertions(+), 76 deletions(-) diff --git a/XMath/Galois.cpp b/XMath/Galois.cpp index a08d72f..5fb053c 100644 --- a/XMath/Galois.cpp +++ b/XMath/Galois.cpp @@ -1,4 +1,7 @@ +#define GALOIS_API + #include "Galois.h" +#include namespace CryptoCPP{ namespace Math{ @@ -7,6 +10,18 @@ namespace CryptoCPP{ return (size_t)d + (d > (size_t)d ? 1 : 0); } + size_t block_count(size_t bin_block_size, size_t bufs) + { + return (bufs * 8) / bin_block_size; + } + + void* do_copy(void* v, size_t size) + { + char * c = new char[size]; + memcpy(c, v, size); + return c; + } + GALOIS_API Galois::Galois( size_t characteristic, size_t exponent, @@ -24,7 +39,7 @@ namespace CryptoCPP{ data = value; } - GALOIS_API Galois::Galois(Galois & copy) : + GALOIS_API Galois::Galois(const Galois & copy) : characteristic(copy.characteristic), exponent(copy.exponent), irreducible(new size_t[copy.irreducible_size]), @@ -44,127 +59,199 @@ namespace CryptoCPP{ } GALOIS_API Galois * Galois::add(const Galois * value) const - { - Galois * result = new Galois(*this); - result->iadd(value); - return result; + { + bool imSmaller = value->data_size > data_size; + size_t state_size = imSmaller ? value->data_size : data_size; + size_t * state = new size_t[state_size]; + memset(state, 0, state_size * sizeof(size_t)); + memcpy(state, imSmaller ? value->data : data, state_size * sizeof(size_t)); + + iadd(imSmaller ? data : value->data, imSmaller ? data_size : value->data_size, binary_block_size, state, state_size, characteristic); + + return new Galois(characteristic, exponent, (size_t *)do_copy(irreducible, irreducible_size * sizeof(size_t)), irreducible_size, state); } GALOIS_API Galois * Galois::sub(const Galois * value) const - { - Galois * result = new Galois(*this); - result->isub(value); - return result; + { + bool imSmaller = value->data_size > data_size; + size_t state_size = imSmaller ? value->data_size : data_size; + size_t * state = new size_t[state_size]; + memset(state, 0, state_size * sizeof(size_t)); + memcpy(state, data, data_size * sizeof(size_t)); + + isub(value->data, value->data_size, binary_block_size, state, state_size, characteristic); + + return new Galois(characteristic, exponent, (size_t *)do_copy(irreducible, irreducible_size * sizeof(size_t)), irreducible_size, state); } GALOIS_API Galois * Galois::mul(const Galois * value) const - { - Galois * result = new Galois(*this); - result->imul(value); - return result; - } - - GALOIS_API Galois * Galois::inv(const Galois * value) const - { - Galois * result = new Galois(*this); - result->iinv(value); - return result; - } - - GALOIS_API void Galois::iadd(const Galois * value) { - size_t min = data_size < value->data_size ? data_size : value->data_size; - for(size_t t = 0; tdata, value->data_size, value->binary_block_size, &nb2); + + // If one of the values is 0, return a zero-Galois + if (nb1 || nb2) return new Galois(characteristic, exponent, (size_t *)do_copy(irreducible, irreducible_size * sizeof(size_t)), irreducible_size, (size_t*)memset(new size_t[1], 0, sizeof(size_t))); + + // The product of two values with the same base is represented as the sum of their exponents + size_t * state = new size_t[h1 + h2]; + memset(state, 0, (h1 + h2) * sizeof(size_t)); + + imul(value->data, value->data_size, binary_block_size, state, h1 + h2, characteristic, h1, h2); + + return new Galois(characteristic, exponent, (size_t *)do_copy(irreducible, irreducible_size * sizeof(size_t)), irreducible_size, state); + } + + GALOIS_API Galois * Galois::inv() const + { + + } + + // These internal functions assume that an adequate state size has been chose + GALOIS_API void Galois::iadd(size_t * data, size_t data_size, size_t bin_size, size_t * state, size_t state_size, size_t characteristic) + { + for (size_t t = block_count(bin_size, data_size); t > 0; --t) + set_value( + t - 1, + ( + get_value(t-1, bin_size, state) + + get_value(t - 1, bin_size, data) + ) % characteristic, + bin_size, + characteristic, + state + ); + } + + GALOIS_API void Galois::isub(size_t * data, size_t data_size, size_t bin_size, size_t * state, size_t state_size, size_t characteristic) + { + for (size_t t = block_count(bin_size, data_size); t > 0; --t) + set_value( + t - 1, + ( + characteristic + + get_value(t - 1, bin_size, state) - + get_value(t - 1, bin_size, data) + ) % characteristic, + bin_size, + characteristic, + state + ); + } + + GALOIS_API void Galois::imul(size_t * data, size_t data_size, size_t bin_size, size_t * state, size_t state_size, size_t characteristic, size_t high1, size_t high2) + { + size_t * temp = new size_t[high1 + high2]; + memset(temp, 0, (high1 + high2) * sizeof(size_t)); + + size_t data_blocks = block_count(bin_size, data_size); + + for (size_t t = block_count(bin_size, state_size); t > 0; --t) { - size_t block = (get_value(t) + value->get_value(t)) % characteristic; - set_value(t, block); + memcpy(temp, data, data_size * sizeof(size_t)); + ilsh(temp, data_size + (t*bin_size), t); + + for (size_t tblk = 0; tblk < data_blocks; ++tblk) // Multiply each element + set_value(tblk, get_value(tblk, bin_size, data) * get_value(t - 1, bin_size, state), bin_size, characteristic, temp); + + // Add shifted and multiplied value to state + iadd(state, data_size + (t*bin_size), bin_size, state, state_size, characteristic); } } - GALOIS_API void Galois::isub(const Galois * value) + GALOIS_API void Galois::iinv(size_t * state, size_t state_size) { } - GALOIS_API void Galois::imul(const Galois * value) + GALOIS_API void Galois::ilsh(size_t * state, size_t state_size, size_t bin_size, size_t characteristic, size_t shiftc) { - + for (size_t t = block_count(bin_size, state_size); t > shiftc; --t) + set_value(t - 1, get_value(t - 1 - shiftc, bin_size, state), bin_size, characteristic, state); + for (size_t t = shiftc; t > 0; --t) + set_value(t - 1, 0, bin_size, characteristic, state); } - GALOIS_API void Galois::iinv(cosnt Galois * value) - { - - } - - GALOIS_API size_t Galois::_mask(size_t bits, bool side) const + GALOIS_API size_t Galois::_mask(size_t bits, bool side) { size_t result = 0; for(size_t t = 0; t>1)|high_bit; return result; } - GALOIS_API size_t Galois::get_value(size_t index) const + GALOIS_API size_t Galois::get_value(size_t index, size_t block_size, size_t * from) { // Compute block/sub-block indexing - size_t upper_bit_size = ((binary_block_size*index)%(8*sizeof(size_t)))%binary_block_size; - size_t upper_block_index = (index*binary_block_size)/8; - size_t lower_block_index = ((index - upper_bit_size)*binary_block_size)/8; + size_t upper_bit_size = ((block_size*index)%(8*sizeof(size_t)))% block_size; + size_t upper_block_index = (index*block_size)/8; + size_t lower_block_index = ((index - upper_bit_size)*block_size)/8; // Boundary disparity check if(upper_block_index!=lower_block_index) { // Get block values - size_t upper_block = data[upper_block_index] & _mask(upper_bit_size, true); - size_t lower_block = data[lower_block_index] & _mask(binary_block_size-upper_bit_size, false); + size_t upper_block = from[upper_block_index] & _mask(upper_bit_size, true); + size_t lower_block = from[lower_block_index] & _mask(block_size -upper_bit_size, false); // Do alignment - size_t block = (upper_block << (binary_block_size - upper_bit_size)) | (lower_block >> ((sizeof(size_t)*8)-upper_bit_size)); + size_t block = (upper_block << (block_size - upper_bit_size)) | (lower_block >> ((sizeof(size_t)*8)-upper_bit_size)); return block; } else { // Passed: no boundary disparity - size_t shift = (binary_block_size * index) % (8 * sizeof(size_t)); - size_t block_index = (binary_block_size * index) / (8 * sizeof(size_t)); + size_t shift = (block_size * index) % (8 * sizeof(size_t)); + size_t block_index = (block_size * index) / (8 * sizeof(size_t)); // Get and mask - return data[block_index] >> shift & _mask(binary_block_size, true); + return from[block_index] >> shift & _mask(block_size, true); } } - GALOIS_API void Galois::set_value(size_t index, size_t value) + GALOIS_API void Galois::set_value(size_t index, size_t value, size_t block_size, size_t characteristic, size_t * to) { value = value % characteristic; // Compute block/sub-block indexing - size_t upper_bit_size = ((binary_block_size*index)%(8*sizeof(size_t)))%binary_block_size; - size_t upper_block_index = (index*binary_block_size)/8; - size_t lower_block_index = ((index - upper_bit_size)*binary_block_size)/8; + size_t upper_bit_size = ((block_size*index)%(8*sizeof(size_t)))%block_size; + size_t upper_block_index = (index*block_size)/8; + size_t lower_block_index = ((index - upper_bit_size)*block_size)/8; // Boundary disparity check if(upper_block_index!=lower_block_index) { // Mask bits - data[upper_block_index] &= ~_mask(upper_bit_size, false); - data[lower_block_index] &= ~_mask(binary_block_size-upper_bit_size, true); + to[upper_block_index] &= ~_mask(upper_bit_size, false); + to[lower_block_index] &= ~_mask(block_size -upper_bit_size, true); // Get block values - data[upper_block_index] = value >> (binary_block_size - upper_bit_size); - data[lower_block_index] = (value & _mask(binary_block_size-upper_bit_size, false)) << ((8 * sizeof(size_t)) - (binary_block_size - upper_bit_size)); + to[upper_block_index] = value >> (block_size - upper_bit_size); + to[lower_block_index] = (value & _mask(block_size -upper_bit_size, false)) << ((8 * sizeof(size_t)) - (block_size - upper_bit_size)); } else { // Passed: no boundary disparity - size_t shift = (binary_block_size * index) % (8 * sizeof(size_t)); - size_t block_index = (binary_block_size * index) / (8 * sizeof(size_t)); + size_t shift = (block_size * index) % (8 * sizeof(size_t)); + size_t block_index = (block_size * index) / (8 * sizeof(size_t)); // Mask bits - data[block_index] &= ~_mask(binary_block_size, false) << shift; + to[block_index] &= ~_mask(block_size, false) << shift; // Apply shift - data[block_index] = value << shift; + to[block_index] = value << shift; } } + + GALOIS_API size_t Galois::high_factor(size_t * state, size_t state_size, size_t bin_size, bool * noBits) + { + *noBits = false; + for (size_t t = block_count(bin_size, state_size); t > 0; --t) + if (get_value(t - 1, bin_size, state)) + return t - 1; + *noBits = true; + return 0; + } } } diff --git a/XMath/Galois.h b/XMath/Galois.h index 8adfe2d..a1bac41 100644 --- a/XMath/Galois.h +++ b/XMath/Galois.h @@ -25,12 +25,12 @@ namespace CryptoCPP { { public: GALOIS_API Galois( - size_t characteristic, - size_t exponent, - size_t * irreducible, - size_t irreducible_size, - size_t * value - ); + size_t characteristic, + size_t exponent, + size_t * irreducible, + size_t irreducible_size, + size_t * value + ); GALOIS_API ~Galois(); // Addition @@ -43,31 +43,35 @@ namespace CryptoCPP { GALOIS_API Galois * mul(const Galois * value) const; // Inverse multiplication - GALOIS_API Galois * inv(const Galois * value) const; + GALOIS_API Galois * inv() const; protected: static const size_t high_bit = 1 << ((sizeof(size_t)*8)-1); // GF parameters - const size_t characteristic, exponent, irreducible; + size_t characteristic, exponent, *irreducible, irreducible_size; // Effective storage params - const size_t binary_block_size, data_size; + size_t binary_block_size, data_size; // Value of this GF object - const size_t * data; + size_t * data; // Reduce the value of this galois to fit characteristic GALOIS_API void reduce(); - // Self-mutable operations - GALOIS_API void iadd(const Galois * value); - GALOIS_API void isub(const Galois * value); - GALOIS_API void imul(const Galois * value); - GALOIS_API void iinv(const Galois * value); - GALOIS_API size_t _mask(size_t bits, bool side) const; - GALOIS_API size_t get_value(size_t idx) const; - GALOIS_API void set_value(size_t idx, size_t value); + // Logic + GALOIS_API static void iadd(size_t * data, size_t data_size, size_t bin_size, size_t * state, size_t state_size, size_t characteristic); // Addition + GALOIS_API static void isub(size_t * data, size_t data_size, size_t bin_size, size_t * state, size_t state_size, size_t characteristic); // Subtraction + GALOIS_API static void imul(size_t * data, size_t data_size, size_t bin_size, size_t * state, size_t state_size, size_t characteristic, size_t high1, size_t high2); // Multiplication + GALOIS_API static void iinv(size_t * state, size_t state_size); // Multiplicative inverse + GALOIS_API static void ilsh(size_t * state, size_t state_size, size_t bin_size, size_t characteristic, size_t shiftc); // Left shift + + // Data management. Don't look at these unless you want a headache + GALOIS_API static size_t _mask(size_t bits, bool side); + GALOIS_API static size_t get_value(size_t idx, size_t block_size, size_t * from); + GALOIS_API static void set_value(size_t idx, size_t value, size_t block_size, size_t characteristic, size_t * to); + GALOIS_API static size_t high_factor(size_t * state, size_t state_size, size_t bin_size, bool * noBits); }; } } diff --git a/XMath/XMath.vcxproj b/XMath/XMath.vcxproj index 03c7612..bc65f77 100644 --- a/XMath/XMath.vcxproj +++ b/XMath/XMath.vcxproj @@ -122,6 +122,7 @@ + diff --git a/XMath/XMath.vcxproj.filters b/XMath/XMath.vcxproj.filters index f72a80e..c80218e 100644 --- a/XMath/XMath.vcxproj.filters +++ b/XMath/XMath.vcxproj.filters @@ -21,6 +21,9 @@ Source Files + + Source Files + From 90fddd72de2f65109fad0cb76766659eb9ac8962 Mon Sep 17 00:00:00 2001 From: Gabriel Tofvesson Date: Fri, 2 Mar 2018 08:05:04 +0100 Subject: [PATCH 6/7] Started adding multiplicative inverse --- XMath/Galois.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/XMath/Galois.cpp b/XMath/Galois.cpp index 5fb053c..5281218 100644 --- a/XMath/Galois.cpp +++ b/XMath/Galois.cpp @@ -2,6 +2,7 @@ #include "Galois.h" #include +#include namespace CryptoCPP{ namespace Math{ @@ -105,7 +106,12 @@ namespace CryptoCPP{ GALOIS_API Galois * Galois::inv() const { + size_t * compute = new size_t[exponent+1]; + memset(compute, 0, (exponent + 1) * sizeof(size_t)); + std::vector factors = new std::vector(); + + // TODO: Implement extended Euclidean algorithm } // These internal functions assume that an adequate state size has been chose From 6cbecfd2c6bef41fbf1bc5a448d7f5efceaabd4a Mon Sep 17 00:00:00 2001 From: GabrielTofvesson Date: Sun, 4 Mar 2018 09:59:25 +0100 Subject: [PATCH 7/7] Fully implemented Galois field arithmetic operations - Changed static "size_t"-type to a define to allow for compiling with different data types - Added modular arithmetic operation to protected section - Added a simplified constructor for supplying literals Probably some other things I didn't think were worth mentioning NOTE: Galois-field code may be unstable! --- Crypto/Start.cpp | 9 +- XMath/Galois.cpp | 305 +++++++++++++++++++++++++++++++++++++---------- XMath/Galois.h | 55 +++++---- 3 files changed, 283 insertions(+), 86 deletions(-) diff --git a/Crypto/Start.cpp b/Crypto/Start.cpp index ab5390c..c7a8376 100644 --- a/Crypto/Start.cpp +++ b/Crypto/Start.cpp @@ -1,6 +1,7 @@ #include #include "BigInteger.h" #include "Matrix.h" +#include "Galois.h" using namespace CryptoCPP::Math; @@ -11,7 +12,7 @@ int main() // |3 4| Matrix * m = new Matrix(2, 2); m->set_row - (new Vector(2, new long long[2]{ 1, 2 }), 0) WITH + (new Vector(2, new long long[2]{ 1, 2 }), 0) (new Vector(2, new long long[2]{ 3, 4 }), 1); // Create a 2x2 matrix @@ -19,7 +20,7 @@ int main() // |7 8| Matrix * m1 = new Matrix(2, 2); m1->set_row - (new Vector(2, new long long[2]{ 5, 6 }), 0) WITH + (new Vector(2, new long long[2]{ 5, 6 }), 0) (new Vector(2, new long long[2]{ 7, 8 }), 1); // Multiply matrices @@ -36,6 +37,10 @@ int main() std::cout << "\nMatrix 'res':" << std::endl; for (size_t t = 0; t < 4; ++t) std::cout << res->at(t, true) << ((t%2) ? '\n' : ' '); std::cout << "\ndet(m) = " << m->det() << "\ndet(m1) = " << m->det() << "\ndet(res) = " << res->det() << std::endl; + + Galois * g1 = new Galois(2, 0b100011011, 0b10); + Galois * g2 = new Galois(2, 0b100011011, 0b11); + Galois * g3 = g1->mul(g2); std::cin.ignore(); return 0; } \ No newline at end of file diff --git a/XMath/Galois.cpp b/XMath/Galois.cpp index 5281218..880290a 100644 --- a/XMath/Galois.cpp +++ b/XMath/Galois.cpp @@ -13,7 +13,7 @@ namespace CryptoCPP{ size_t block_count(size_t bin_block_size, size_t bufs) { - return (bufs * 8) / bin_block_size; + return (bufs * 8 * sizeof(BLOCK)) / bin_block_size; } void* do_copy(void* v, size_t size) @@ -24,33 +24,39 @@ namespace CryptoCPP{ } GALOIS_API Galois::Galois( - size_t characteristic, - size_t exponent, - size_t * irreducible, - size_t irreducible_size, - size_t * value + BLOCK characteristic, + BLOCK * irreducible, + size_t irreducible_size, + BLOCK * value, + size_t value_size ) : characteristic(characteristic), - exponent(exponent), irreducible(irreducible), irreducible_size(irreducible_size), binary_block_size(_ceil(characteristic/2.0)), - data_size(binary_block_size * exponent) + exponent(high_factor(irreducible, irreducible_size, _ceil(characteristic / 2.0), 0)), + data_size(value_size) { data = value; } + GALOIS_API Galois::Galois( + BLOCK characteristic, + BLOCK irreducible, + BLOCK value + ) : Galois(characteristic, new BLOCK[1]{ irreducible }, 1, new BLOCK[1]{value}, 1) + { } GALOIS_API Galois::Galois(const Galois & copy) : characteristic(copy.characteristic), exponent(copy.exponent), - irreducible(new size_t[copy.irreducible_size]), + irreducible(new BLOCK[copy.irreducible_size]), irreducible_size(copy.irreducible_size), binary_block_size(copy.binary_block_size), data_size(copy.data_size) { - data = new size_t[data_size]; - memcpy(irreducible, copy.irreducible, irreducible_size * sizeof(size_t)); - memcpy(data, copy.data, data_size * sizeof(size_t)); + data = new BLOCK[data_size]; + memcpy(irreducible, copy.irreducible, irreducible_size * sizeof(BLOCK)); + memcpy(data, copy.data, data_size * sizeof(BLOCK)); } GALOIS_API Galois::~Galois() @@ -63,26 +69,26 @@ namespace CryptoCPP{ { bool imSmaller = value->data_size > data_size; size_t state_size = imSmaller ? value->data_size : data_size; - size_t * state = new size_t[state_size]; - memset(state, 0, state_size * sizeof(size_t)); - memcpy(state, imSmaller ? value->data : data, state_size * sizeof(size_t)); + BLOCK * state = new BLOCK[state_size]; + memset(state, 0, state_size * sizeof(BLOCK)); + memcpy(state, imSmaller ? value->data : data, state_size * sizeof(BLOCK)); iadd(imSmaller ? data : value->data, imSmaller ? data_size : value->data_size, binary_block_size, state, state_size, characteristic); - return new Galois(characteristic, exponent, (size_t *)do_copy(irreducible, irreducible_size * sizeof(size_t)), irreducible_size, state); + return new Galois(characteristic, (BLOCK *)do_copy(irreducible, irreducible_size * sizeof(BLOCK)), irreducible_size, state, state_size); } GALOIS_API Galois * Galois::sub(const Galois * value) const { bool imSmaller = value->data_size > data_size; size_t state_size = imSmaller ? value->data_size : data_size; - size_t * state = new size_t[state_size]; - memset(state, 0, state_size * sizeof(size_t)); - memcpy(state, data, data_size * sizeof(size_t)); + BLOCK * state = new BLOCK[state_size]; + memset(state, 0, state_size * sizeof(BLOCK)); + memcpy(state, data, data_size * sizeof(BLOCK)); isub(value->data, value->data_size, binary_block_size, state, state_size, characteristic); - return new Galois(characteristic, exponent, (size_t *)do_copy(irreducible, irreducible_size * sizeof(size_t)), irreducible_size, state); + return new Galois(characteristic, (BLOCK *)do_copy(irreducible, irreducible_size * sizeof(BLOCK)), irreducible_size, state, state_size); } GALOIS_API Galois * Galois::mul(const Galois * value) const @@ -90,32 +96,160 @@ namespace CryptoCPP{ bool nb1, nb2; size_t h1 = high_factor(data, data_size, binary_block_size, &nb1), - h2 = high_factor(value->data, value->data_size, value->binary_block_size, &nb2); + h2 = high_factor(value->data, value->data_size, value->binary_block_size, &nb2), + h1_idx = h1 / (8 * sizeof(BLOCK)), + h2_idx = h2 / (8 * sizeof(BLOCK)); // If one of the values is 0, return a zero-Galois - if (nb1 || nb2) return new Galois(characteristic, exponent, (size_t *)do_copy(irreducible, irreducible_size * sizeof(size_t)), irreducible_size, (size_t*)memset(new size_t[1], 0, sizeof(size_t))); + if (nb1 || nb2) return new Galois(characteristic, (BLOCK *)do_copy(irreducible, irreducible_size * sizeof(BLOCK)), irreducible_size, (BLOCK*)memset(new BLOCK[1], 0, sizeof(BLOCK)), 1); // The product of two values with the same base is represented as the sum of their exponents - size_t * state = new size_t[h1 + h2]; - memset(state, 0, (h1 + h2) * sizeof(size_t)); + BLOCK * state = new BLOCK[h1_idx + h2_idx + 1]; + memset(state, 0, (h1_idx + h2_idx + 1) * sizeof(BLOCK)); + memcpy(state, this->data, this->data_size); - imul(value->data, value->data_size, binary_block_size, state, h1 + h2, characteristic, h1, h2); + BLOCK * cmp_exp = new BLOCK[(exponent/(8 * sizeof(BLOCK))) + 1]; + set_value(exponent, 1, binary_block_size, characteristic, cmp_exp); - return new Galois(characteristic, exponent, (size_t *)do_copy(irreducible, irreducible_size * sizeof(size_t)), irreducible_size, state); + imul(value->data, value->data_size, binary_block_size, &state, h1_idx + h2_idx + 1, characteristic, h1_idx, h2_idx); + ModResult * res = imod(state, h1_idx + h2_idx + 1, irreducible, irreducible_size, cmp_exp, (exponent / (8 * sizeof(BLOCK))) + 1, characteristic, binary_block_size); + delete[] state; + state = res->mod; + size_t state_size = res->mod_size; + delete[] res->div; + delete res; + + return new Galois(characteristic, (BLOCK *)do_copy(irreducible, irreducible_size * sizeof(BLOCK)), irreducible_size, state, state_size); } GALOIS_API Galois * Galois::inv() const { - size_t * compute = new size_t[exponent+1]; - memset(compute, 0, (exponent + 1) * sizeof(size_t)); + struct FactorItem { + FactorItem(BLOCK * factor, size_t factor_size) { this->factor = factor; this->factor_size = factor_size; } + BLOCK * factor; + size_t factor_size; + }; - std::vector factors = new std::vector(); + size_t exp = ((exponent + 1) / (8 * sizeof(BLOCK))) + 1; + BLOCK * compute = new BLOCK[exp]; + memset(compute, 0, exp * sizeof(size_t)); + memcpy(compute, irreducible, irreducible_size * sizeof(BLOCK)); + + size_t compute_size = exp; + + BLOCK * temp = new BLOCK[exp]; + memset(temp, 0, exp * sizeof(BLOCK)); + memcpy(temp, data, data_size * sizeof(BLOCK)); + + size_t temp_size = exp; + + std::vector factors = std::vector(); + struct ModResult * m; + size_t high; + size_t highest1 = 1, highest2 = 1; // TODO: Implement extended Euclidean algorithm + bool nb; + volatile bool x = false; + Loop: + high_factor(temp, temp_size, binary_block_size, &nb); + if (nb) goto Next; + + m = //new ModResult(); m->div = new size_t[m->div_size = 1]{(size_t)(change?0:1)}; m->mod = new size_t[m->mod_size = 1]{0}; + imod(compute, compute_size, temp, temp_size, temp, temp_size, characteristic, binary_block_size); + delete[] compute; + compute = temp; + temp = m->mod; + compute_size = temp_size; + temp_size = m->mod_size; + factors.push_back(FactorItem(m->div, m->div_size)); + + // Record highest values + high = high_factor(m->div, m->div_size, binary_block_size, &nb); + if (high > highest1) + { + highest2 = highest1; + highest1 = high; + } + else if (high > highest2) highest2 = high; + delete m; + goto Loop; + + Next: + // Free unneeded resources + delete[] temp; + delete[] compute; + + // Remove invalid computation result + delete[] factors.at(factors.size() - 1).factor; + factors.pop_back(); + + if (factors.size() == 0) factors.push_back(FactorItem(new BLOCK[1]{1}, 1)); + + // Initialize left result of the diophantine equation + compute_size = highest1 * highest2; + compute = new BLOCK[compute_size]; + memset(compute, 0, compute_size * sizeof(BLOCK)); + memcpy(compute, factors.at(factors.size() - 1).factor, factors.at(factors.size() - 1).factor_size * sizeof(BLOCK)); + delete[] factors.at(factors.size() - 1).factor; + factors.pop_back(); + + // Initialize the right result + temp_size = compute_size; + temp = new BLOCK[temp_size]; + memset(temp, 0, compute_size * sizeof(BLOCK)); + temp[0] |= 1; + + BLOCK * cmp = new BLOCK[exp]; + memset(cmp, 0, exp * sizeof(BLOCK)); + cmp[exponent] = 1; + + // Initialize a holder for performing intermediate computations on + size_t holder_size = compute_size; + BLOCK * holder = new BLOCK[holder_size]; + + BLOCK * transfer; + size_t transfer_size; + + // Continue computation of both sides + while (factors.size() > 0) + { + FactorItem item = factors.at(factors.size() - 1); + factors.pop_back(); + memcpy(memset(holder, 0, holder_size), item.factor, item.factor_size * sizeof(size_t)); + + size_t f1 = high_factor(temp, temp_size, binary_block_size, 0), f2 = high_factor(holder, holder_size, binary_block_size, 0); + + imul(holder, holder_size, binary_block_size, &temp, temp_size, characteristic, f1 / (8 * sizeof(BLOCK)), f2 / (8 * sizeof(BLOCK))); + temp_size = (f1 / (8 * sizeof(BLOCK))) + (f2 / (8 * sizeof(BLOCK))) + 1; + ModResult * result = imod(temp, temp_size, irreducible, irreducible_size, cmp, exp, characteristic, binary_block_size); + memcpy(memset(temp, 0, temp_size * sizeof(BLOCK)), result->mod, result->mod_size); + delete[] result->mod; + delete[] result->div; + delete result; + + // Do swap + transfer = compute; + transfer_size = compute_size; + + compute = temp; + compute_size = temp_size; + + temp = transfer; + temp_size = transfer_size; + } + + size_t result_size = ((high_factor(compute, compute_size, binary_block_size, &nb) + 1) / (8 * sizeof(BLOCK))) + 1; + BLOCK * result = new BLOCK[result_size]; + memcpy(result, compute, result_size * sizeof(BLOCK)); + delete[] compute; + delete[] temp; + delete[] cmp; + return new Galois(characteristic, (BLOCK*)do_copy(irreducible, irreducible_size * sizeof(BLOCK)), irreducible_size, result, result_size); } // These internal functions assume that an adequate state size has been chose - GALOIS_API void Galois::iadd(size_t * data, size_t data_size, size_t bin_size, size_t * state, size_t state_size, size_t characteristic) + GALOIS_API void Galois::iadd(BLOCK * data, size_t data_size, size_t bin_size, BLOCK * state, size_t state_size, BLOCK characteristic) { for (size_t t = block_count(bin_size, data_size); t > 0; --t) set_value( @@ -130,7 +264,7 @@ namespace CryptoCPP{ ); } - GALOIS_API void Galois::isub(size_t * data, size_t data_size, size_t bin_size, size_t * state, size_t state_size, size_t characteristic) + GALOIS_API void Galois::isub(BLOCK * data, size_t data_size, size_t bin_size, BLOCK * state, size_t state_size, BLOCK characteristic) { for (size_t t = block_count(bin_size, data_size); t > 0; --t) set_value( @@ -146,32 +280,81 @@ namespace CryptoCPP{ ); } - GALOIS_API void Galois::imul(size_t * data, size_t data_size, size_t bin_size, size_t * state, size_t state_size, size_t characteristic, size_t high1, size_t high2) + GALOIS_API void Galois::imul(BLOCK * data, size_t data_size, size_t bin_size, BLOCK ** state, size_t state_size, BLOCK characteristic, size_t high1, size_t high2) { - size_t * temp = new size_t[high1 + high2]; - memset(temp, 0, (high1 + high2) * sizeof(size_t)); + BLOCK * temp = new BLOCK[high1 + high2 + 1]; + //memset(temp, 0, (high1 + high2 + 1) * sizeof(size_t)); + + BLOCK * res = new BLOCK[high1 + high2 + 1]; + memset(res, 0, (high1 + high2 + 1) * sizeof(BLOCK)); size_t data_blocks = block_count(bin_size, data_size); for (size_t t = block_count(bin_size, state_size); t > 0; --t) { - memcpy(temp, data, data_size * sizeof(size_t)); - ilsh(temp, data_size + (t*bin_size), t); + memset(temp, 0, (high1 + high2 + 1) * sizeof(BLOCK)); + //memcpy(temp, data, data_size * sizeof(size_t)); + //ilsh(temp, data_size, bin_size, characteristic, t-1); for (size_t tblk = 0; tblk < data_blocks; ++tblk) // Multiply each element - set_value(tblk, get_value(tblk, bin_size, data) * get_value(t - 1, bin_size, state), bin_size, characteristic, temp); + set_value(tblk + t - 1, get_value(tblk, bin_size, data) * get_value(t - 1, bin_size, *state), bin_size, characteristic, temp); // Add shifted and multiplied value to state - iadd(state, data_size + (t*bin_size), bin_size, state, state_size, characteristic); + iadd(temp, high1 + high2 + 1, bin_size, res, high1 + high2 + 1, characteristic); } + delete[] *state; + *state = res; } - GALOIS_API void Galois::iinv(size_t * state, size_t state_size) + GALOIS_API Galois::ModResult* Galois::imod(BLOCK * value, size_t value_size, BLOCK * modulo, size_t modulo_size, BLOCK * cmp, size_t cmp_size, BLOCK characteristic, size_t bin_size) { - + bool nb; + size_t mod_max = high_factor(modulo, modulo_size, bin_size, &nb); + if (nb) return 0; + size_t cmp_max = high_factor(cmp, cmp_size, bin_size, &nb); + if (nb) return 0; + + BLOCK * aligned = 0; + ModResult * result = new ModResult(); + result->mod = new BLOCK[value_size]; + result->mod_size = value_size; + memcpy(result->mod, value, value_size * sizeof(BLOCK)); + + result->div = 0; + + LoopStart: // Loop start + // Loop evaluation + size_t idx = high_factor(result->mod, result->mod_size, bin_size, &nb); + if (nb || idx < cmp_max || (idx == cmp_max && result->mod[idx / (8 * sizeof(BLOCK))] < cmp[cmp_max / (8 * sizeof(BLOCK))])) goto LoopEnd; // Break + + // Loop body + if (aligned == 0) { + aligned = new BLOCK[value_size]; + result->div_size = (((idx - mod_max) * bin_size) / (8 * sizeof(BLOCK))) + 1; + result->div = new BLOCK[result->div_size]; + memset(result->div, 0, result->div_size * sizeof(BLOCK)); + } + memcpy(memset(aligned, 0, value_size * sizeof(BLOCK)), modulo, modulo_size * sizeof(BLOCK)); + ilsh(aligned, value_size, bin_size, characteristic, idx - mod_max); + isub(aligned, value_size, bin_size, result->mod, value_size, characteristic); + + set_value(idx - mod_max, (get_value(idx - mod_max, bin_size, result->div) + 1) % characteristic, bin_size, characteristic, result->div); + + // End of loop body + goto LoopStart; + LoopEnd: + + if (result->div == 0) { + result->div = new BLOCK[1]{0}; + result->div_size = 1; + } + delete[] aligned; + + // Stuff after loop + return result; } - GALOIS_API void Galois::ilsh(size_t * state, size_t state_size, size_t bin_size, size_t characteristic, size_t shiftc) + GALOIS_API void Galois::ilsh(BLOCK * state, size_t state_size, size_t bin_size, BLOCK characteristic, size_t shiftc) { for (size_t t = block_count(bin_size, state_size); t > shiftc; --t) set_value(t - 1, get_value(t - 1 - shiftc, bin_size, state), bin_size, characteristic, state); @@ -186,12 +369,12 @@ namespace CryptoCPP{ return result; } - GALOIS_API size_t Galois::get_value(size_t index, size_t block_size, size_t * from) + GALOIS_API BLOCK Galois::get_value(size_t index, size_t block_size, BLOCK * from) { // Compute block/sub-block indexing - size_t upper_bit_size = ((block_size*index)%(8*sizeof(size_t)))% block_size; - size_t upper_block_index = (index*block_size)/8; - size_t lower_block_index = ((index - upper_bit_size)*block_size)/8; + size_t upper_bit_size = ((block_size*index)%(8*sizeof(BLOCK)))% block_size; + size_t upper_block_index = (index*block_size)/(8 * sizeof(BLOCK)); + size_t lower_block_index = ((index - upper_bit_size)*block_size)/ (8 * sizeof(BLOCK)); // Boundary disparity check if(upper_block_index!=lower_block_index) @@ -201,27 +384,27 @@ namespace CryptoCPP{ size_t lower_block = from[lower_block_index] & _mask(block_size -upper_bit_size, false); // Do alignment - size_t block = (upper_block << (block_size - upper_bit_size)) | (lower_block >> ((sizeof(size_t)*8)-upper_bit_size)); + BLOCK block = (upper_block << (block_size - upper_bit_size)) | (lower_block >> ((sizeof(BLOCK)*8)-upper_bit_size)); return block; } else { // Passed: no boundary disparity - size_t shift = (block_size * index) % (8 * sizeof(size_t)); - size_t block_index = (block_size * index) / (8 * sizeof(size_t)); + size_t shift = (block_size * index) % (8 * sizeof(BLOCK)); + size_t block_index = (block_size * index) / (8 * sizeof(BLOCK)); // Get and mask return from[block_index] >> shift & _mask(block_size, true); } } - GALOIS_API void Galois::set_value(size_t index, size_t value, size_t block_size, size_t characteristic, size_t * to) + GALOIS_API void Galois::set_value(size_t index, BLOCK value, size_t block_size, BLOCK characteristic, BLOCK * to) { value = value % characteristic; // Compute block/sub-block indexing - size_t upper_bit_size = ((block_size*index)%(8*sizeof(size_t)))%block_size; + size_t upper_bit_size = ((block_size*index)%(8*sizeof(BLOCK)))%block_size; size_t upper_block_index = (index*block_size)/8; size_t lower_block_index = ((index - upper_bit_size)*block_size)/8; @@ -229,34 +412,34 @@ namespace CryptoCPP{ if(upper_block_index!=lower_block_index) { // Mask bits - to[upper_block_index] &= ~_mask(upper_bit_size, false); - to[lower_block_index] &= ~_mask(block_size -upper_bit_size, true); + to[upper_block_index] &= ~_mask(upper_bit_size, true); + to[lower_block_index] &= ~_mask(block_size - upper_bit_size, false); // Get block values - to[upper_block_index] = value >> (block_size - upper_bit_size); - to[lower_block_index] = (value & _mask(block_size -upper_bit_size, false)) << ((8 * sizeof(size_t)) - (block_size - upper_bit_size)); + to[upper_block_index] |= value >> (block_size - upper_bit_size); + to[lower_block_index] |= (value & _mask(block_size -upper_bit_size, false)) << ((8 * sizeof(BLOCK)) - (block_size - upper_bit_size)); } else { // Passed: no boundary disparity - size_t shift = (block_size * index) % (8 * sizeof(size_t)); - size_t block_index = (block_size * index) / (8 * sizeof(size_t)); + size_t shift = (block_size * index) % (8 * sizeof(BLOCK)); + size_t block_index = (block_size * index) / (8 * sizeof(BLOCK)); // Mask bits - to[block_index] &= ~_mask(block_size, false) << shift; + to[block_index] &= ~(_mask(block_size, true) << shift); // Apply shift - to[block_index] = value << shift; + to[block_index] |= value << shift; } } - GALOIS_API size_t Galois::high_factor(size_t * state, size_t state_size, size_t bin_size, bool * noBits) + GALOIS_API size_t Galois::high_factor(BLOCK * state, size_t state_size, size_t bin_size, bool * noBits) { - *noBits = false; + if(noBits!=0) *noBits = false; for (size_t t = block_count(bin_size, state_size); t > 0; --t) if (get_value(t - 1, bin_size, state)) return t - 1; - *noBits = true; + if (noBits != 0) *noBits = true; return 0; } } diff --git a/XMath/Galois.h b/XMath/Galois.h index a1bac41..6db5968 100644 --- a/XMath/Galois.h +++ b/XMath/Galois.h @@ -3,6 +3,7 @@ #if defined(__MINGW32__) || defined(_WIN32) #if defined(GALOIS_API) +#undef GALOIS_API #define GALOIS_API __declspec(dllexport) #else #define GALOIS_API __declspec(dllimport) @@ -18,6 +19,7 @@ #endif #endif +#define BLOCK size_t namespace CryptoCPP { namespace Math { @@ -25,12 +27,18 @@ namespace CryptoCPP { { public: GALOIS_API Galois( - size_t characteristic, - size_t exponent, - size_t * irreducible, + BLOCK characteristic, + BLOCK * irreducible, size_t irreducible_size, - size_t * value + BLOCK * value, + size_t value_size ); + GALOIS_API Galois( + BLOCK characteristic, + BLOCK irreducible, + BLOCK value + ); + GALOIS_API Galois(const Galois & copy); GALOIS_API ~Galois(); // Addition @@ -45,33 +53,34 @@ namespace CryptoCPP { // Inverse multiplication GALOIS_API Galois * inv() const; - protected: - static const size_t high_bit = 1 << ((sizeof(size_t)*8)-1); - // GF parameters - size_t characteristic, exponent, *irreducible, irreducible_size; - // Effective storage params - size_t binary_block_size, data_size; - // Value of this GF object - size_t * data; + static const BLOCK high_bit = 1 << ((sizeof(BLOCK) * 8) - 1); + // GF parameters & value + BLOCK characteristic, *irreducible, *data; + // Storage params + size_t binary_block_size, data_size, irreducible_size, exponent; - // Reduce the value of this galois to fit characteristic - GALOIS_API void reduce(); + struct ModResult { + BLOCK * div; + size_t div_size; + BLOCK * mod; + size_t mod_size; + }; // Logic - GALOIS_API static void iadd(size_t * data, size_t data_size, size_t bin_size, size_t * state, size_t state_size, size_t characteristic); // Addition - GALOIS_API static void isub(size_t * data, size_t data_size, size_t bin_size, size_t * state, size_t state_size, size_t characteristic); // Subtraction - GALOIS_API static void imul(size_t * data, size_t data_size, size_t bin_size, size_t * state, size_t state_size, size_t characteristic, size_t high1, size_t high2); // Multiplication - GALOIS_API static void iinv(size_t * state, size_t state_size); // Multiplicative inverse - GALOIS_API static void ilsh(size_t * state, size_t state_size, size_t bin_size, size_t characteristic, size_t shiftc); // Left shift + GALOIS_API static void iadd(BLOCK * data, size_t data_size, size_t bin_size, BLOCK * state, size_t state_size, BLOCK characteristic); // Addition + GALOIS_API static void isub(BLOCK * data, size_t data_size, size_t bin_size, BLOCK * state, size_t state_size, BLOCK characteristic); // Subtraction + GALOIS_API static void imul(BLOCK * data, size_t data_size, size_t bin_size, BLOCK ** state, size_t state_size, BLOCK characteristic, size_t high1, size_t high2); // Multiplication + GALOIS_API static ModResult* imod(BLOCK * value, size_t value_size, BLOCK * modulo, size_t modulo_size, BLOCK * cmp, size_t cmp_size, BLOCK characteristic, size_t bin_size); + GALOIS_API static void ilsh(BLOCK * state, size_t state_size, size_t bin_size, BLOCK characteristic, size_t shiftc); // Left shift // Data management. Don't look at these unless you want a headache - GALOIS_API static size_t _mask(size_t bits, bool side); - GALOIS_API static size_t get_value(size_t idx, size_t block_size, size_t * from); - GALOIS_API static void set_value(size_t idx, size_t value, size_t block_size, size_t characteristic, size_t * to); - GALOIS_API static size_t high_factor(size_t * state, size_t state_size, size_t bin_size, bool * noBits); + GALOIS_API static BLOCK _mask(size_t bits, bool side); + GALOIS_API static BLOCK get_value(size_t idx, size_t block_size, BLOCK * from); + GALOIS_API static void set_value(size_t idx, BLOCK value, size_t block_size, BLOCK characteristic, BLOCK * to); + GALOIS_API static size_t high_factor(BLOCK * state, size_t state_size, size_t bin_size, bool * noBits); }; } }