From b7e8a1d439eb68bb24c98f8f08bccd473555311a Mon Sep 17 00:00:00 2001 From: GabrielTofvesson Date: Mon, 5 Mar 2018 07:59:53 +0100 Subject: [PATCH] Updated readme Added some convenient stuff to BigInteger Did a tiny rename (looks like not all of the SHA project was renamed but meh who cares for now) --- README.md | 59 +++++++++++++++++++++++++++++++- RSA/RSA.cpp | 6 ++++ RSA/RSA.h | 76 +++++++++++++++++++++++++++++++++-------- RSA/RSA.vcxproj | 9 +++++ RSA/RSA.vcxproj.filters | 5 +++ SHA1/SHA1.vcxproj | 1 + XMath/BigInteger.cpp | 44 ++++++++++++++++++++++++ XMath/BigInteger.h | 4 +++ 8 files changed, 189 insertions(+), 15 deletions(-) create mode 100644 RSA/RSA.cpp diff --git a/README.md b/README.md index 4885892..5390046 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,59 @@ # CryptoCPP -My attempt at a small crypto library \ No newline at end of file +My attempt at a small crypto library + +## Current projects +* AES +* RSA +* SHA +* XMath +* CryptoTests + + + +### AES +An implementation of AES designed to show how AES encrypts. It uses mathematical functions rather than lookup tables in order to clarify how the encryption actally works and why the operations are as they are. +Status: +* Implemented + +Dependencies: +* XMath + + +### RSA +Small RSA implementation with key generation delegated partially to XMath. The implementation supports message signing, seralization and deserialization. +Status: +* Headers: Implemented +* Code: Not implemented + +Dependencies: +* XMath + + +### SHA +Secure hashing algorithms. Implementations: SHA1. +Status: +* Not implemented + +Dependencies: +None + + +### XMath +A library with a lot of helper functions and classes for keeping other code clean. +Status: +* BigInteger: Implemented +* Galois Implemented +* Matrix Implemented +* Primes: Not implemented + +Dependencies: +None + + +### CryptoTests +A project for testing all the other projects and their implementations. +Status: +N/A + +Dependencies: +All \ No newline at end of file diff --git a/RSA/RSA.cpp b/RSA/RSA.cpp new file mode 100644 index 0000000..1ae58c7 --- /dev/null +++ b/RSA/RSA.cpp @@ -0,0 +1,6 @@ +#define RSA_API +#include "RSA.h" + +namespace CryptoCPP { namespace RSA { + +}} \ No newline at end of file diff --git a/RSA/RSA.h b/RSA/RSA.h index 55dd9fc..5e719a9 100644 --- a/RSA/RSA.h +++ b/RSA/RSA.h @@ -1,17 +1,65 @@ #pragma once +#include "Primes.h" +#include "BigInteger.h" -namespace CryptoCPP { - namespace RSA { - struct PublicKey - { - // Big integer modulus - // Big integer exponent - }; - class RSA - { - public: - //RSA(PublicKey* key, Math::BigInteger* privateKey); - }; - } -} \ No newline at end of file +#if defined(__MINGW32__) || defined(_WIN32) + +#if defined(RSA_API) +#undef RSA_API +#define RSA_API __declspec(dllexport) +#else +#define RSA_API __declspec(dllimport) +#endif + +#endif + +#ifndef RSA_API +#if __GNUC__ >= 4 +#define RSA_API __attribute__ ((visibility ("default"))) +#else +#define RSA_API +#endif +#endif + + +namespace CryptoCPP { namespace RSA { + struct PublicKey + { + Math::BigInteger * mod; + Math::BigInteger * exp; + }; + typedef Math::BigInteger PrivateKey; + struct KeyPair { + PublicKey * pub; + PrivateKey * priv; + }; + + class RSA + { + public: + RSA_API RSA(KeyPair* pair); + + RSA_API char* encrypt(char* message); // Encrypt with public key + RSA_API char* sign(char* message); // Encrypt with private key + + RSA_API char* decrypt(char* cipher); // Decrypt with private key + RSA_API char* check_sign(char* cipher); // Decrypt with public key + + RSA_API bool can_decrypt(); // Checks whether or not we have a private key + + RSA_API char* serialize_net(); // Serializes public key + RSA_API char* serialize_all(); // Complete serialization (public + private key). NOTE: Should NEVER be transmitted over an insecure channel. This should preferably be kept to the local file system + + RSA_API static RSA * deserialize(char* ser);// Deserializes a serialized RSA object. Autodetects whether or not a private key is available + + protected: + KeyPair * keypair; + + RSA_API static char* encrypt(char* message, Math::BigInteger * exp, Math::BigInteger * mod); // Internal encryption function. exp can be either public or private exponent + RSA_API static char* decrypt(char* message, Math::BigInteger * exp, Math::BigInteger * mod); // Internal decryption function. -||- + }; + + typedef char(*RandomProvider)(); + KeyPair* generate_key_pair(RandomProvider provider, size_t approximate_byte_count, size_t byte_margin); +}} \ No newline at end of file diff --git a/RSA/RSA.vcxproj b/RSA/RSA.vcxproj index 625a0fd..018665e 100644 --- a/RSA/RSA.vcxproj +++ b/RSA/RSA.vcxproj @@ -76,6 +76,7 @@ Disabled true true + $(SolutionDir)XMath;%(AdditionalIncludeDirectories) @@ -117,6 +118,14 @@ + + + {5f9ad03f-b1f0-4db3-b39a-49b66895774c} + + + + + diff --git a/RSA/RSA.vcxproj.filters b/RSA/RSA.vcxproj.filters index 401028b..168bc9a 100644 --- a/RSA/RSA.vcxproj.filters +++ b/RSA/RSA.vcxproj.filters @@ -19,4 +19,9 @@ Header Files + + + Source Files + + \ No newline at end of file diff --git a/SHA1/SHA1.vcxproj b/SHA1/SHA1.vcxproj index 71239a8..e7e53dc 100644 --- a/SHA1/SHA1.vcxproj +++ b/SHA1/SHA1.vcxproj @@ -23,6 +23,7 @@ {2CB4EC0F-FE3F-413F-A27D-0BB3C8CF84EB} SHA1 10.0.16299.0 + SHA diff --git a/XMath/BigInteger.cpp b/XMath/BigInteger.cpp index 854bd62..acf67e5 100644 --- a/XMath/BigInteger.cpp +++ b/XMath/BigInteger.cpp @@ -31,6 +31,15 @@ namespace CryptoCPP { sign = initialvalue.sign; } + BIGINT_API BigInteger::BigInteger(const char * value, size_t size) + { + sign = value[size - 1] & 128; + data = new std::vector(size); + for (size_t t = 0; t < size; ++t) (*data)[t] = value[t]; + clip_zeroes(); + } + + BIGINT_API BigInteger * BigInteger::operator+(const BigInteger & val) const { BigInteger* create = new BigInteger(*this); @@ -218,6 +227,41 @@ namespace CryptoCPP { return string; } + BIGINT_API BigInteger* BigInteger::mod_pow(BigInteger* base, BigInteger* exp, BigInteger* mod) + { + // Declare new versions that we can manipulate to our heart's content + BigInteger * b = new BigInteger(base); + BigInteger * e = new BigInteger(exp); + BigInteger * m = new BigInteger(mod); + + // Allocate a result + BigInteger * res = new BigInteger(1); + b->imod(*m, false); + + bool r, hb; + while (*exp > 0) // As long as e has bits + { + r = !exp->lowest_set_bit(&hb); // Check if the lowest bit is set + e->ishr(1); // Shift all the bits to the right by one step, effectively deleting the lowest bit + if (r) // Do some magic here + { + res->imul(*b, false); + res->imod(*m, false); + } + + // Magic here too + b->imul(*b, false); + b->imod(*m, false); + } + + // Remember to clean up after ourselves + delete m; + delete e; + delete b; + + return res; + } + BIGINT_API void BigInteger::iadd(const BigInteger & other, bool swaptarget) { diff --git a/XMath/BigInteger.h b/XMath/BigInteger.h index 36f2739..b41332f 100644 --- a/XMath/BigInteger.h +++ b/XMath/BigInteger.h @@ -30,6 +30,7 @@ namespace CryptoCPP { public: BIGINT_API BigInteger(long long initialValue); BIGINT_API BigInteger(const BigInteger& initialvalue); + BIGINT_API BigInteger(const char * value, size_t size); // These should just create a new bigint and call the internal functions on it BIGINT_API BigInteger* operator+(const BigInteger& val) const; @@ -64,6 +65,9 @@ namespace CryptoCPP { BIGINT_API char* toString(); + + BIGINT_API static BigInteger* mod_pow(BigInteger* base, BigInteger* exp, BigInteger* mod); + protected: std::vector* data; bool sign;