Add project files.

Author: weniseb

ChinRemainder.cpp

@@ -0,0 +1,30 @@
+#include "ChinRemainder.h"
+#include "Euclidean.h"
+
+ChinRemainder::ChinRemainder(int x1, int x2, int m1, int m2) : x1(x1), x2(x2), m1(m1), m2(m2)
+{};
+
+bool ChinRemainder::parametersSet()
+{
+  if (x1 == 0 || x2 == 0 || m1 == 0 || m2 == 0)
+  {
+    return false;
+  }
+
+  return true;
+}
+
+int256_t ChinRemainder::calculate()
+{
+  if (!parametersSet())
+  {
+    return 0;
+  }
+
+  int a = x1 * m2;
+  int b = x2 * m1;
+
+  int256_t x, s;
+
+  Euclidean::extendedEuclidean(a, m2, &x, &s);
+}

ChinRemainder.h

@@ -0,0 +1,46 @@
+//---------------------------------------------------------
+// Implementaton of the chinese remainder theorem.
+// Includes the basic and extended algorithm of the theorem.
+//
+// Author: Sebastian Weninger
+//
+
+#ifndef CHIN_REMAINDER
+#define CHIN_REMAINDER
+
+#include <boost/multiprecision/cpp_int.hpp>
+using namespace boost::multiprecision;
+
+class ChinRemainder
+{
+private:
+
+  int x1;
+  int x2;
+
+  int m1;
+  int m2;
+
+public:
+  
+  //-------------------------------------------------------
+  // Constructor
+  //
+  ChinRemainder(int x1, int x2, int m1, int m2);
+
+  //-------------------------------------------------------
+  // Query if all parameters are set.
+  //
+  // return: bool
+  //
+  bool parametersSet();
+
+  //-------------------------------------------------------
+  // Calculate result with initialized modules
+  // 
+  // return: int265_t result
+  //
+  int256_t calculate();
+};
+
+#endif

Decryptor.cpp

@@ -0,0 +1,34 @@
+#include <string>
+#include "Decryptor.h"
+#include "RSA.h"
+#include <boost/multiprecision/cpp_int.hpp>
+
+using namespace boost::multiprecision;
+using namespace Crypto;
+using std::string;
+
+Decryptor::Decryptor(const PrivateKey *key) : text(""), private_key(key)
+{
+};
+
+
+string Decryptor::decryptString(CryptoString input)
+{
+  string cypher;
+
+  int256_t tmp;
+  int it;
+  for (it = 0; it < input.size(); it++)
+  {
+    tmp = powm(input[it], private_key->s, private_key->q * private_key->p);
+    cypher.push_back(tmp.convert_to<char>());
+  }
+
+  return cypher;
+}
+
+int Decryptor::decryptChar(int c) const
+{
+  int256_t res = powm((int256_t)c, private_key->s, private_key->q * private_key->p);
+  return res.convert_to<int>();
+}

Decryptor.h

@@ -0,0 +1,44 @@
+//---------------------------------------------------------
+// Class to decrypt data.
+//
+// Author: Sebastian Weninger
+//
+
+#ifndef DECRYPTOR_
+#define DECRYPTOR_
+
+#include "RSA.h"
+#include <string>
+
+using std::string;
+
+namespace Crypto
+{
+  class Decryptor
+  {
+  private:
+    const PrivateKey* private_key;
+
+    string text;
+
+  public:
+    // ------------------------------------------------------
+    // Constructor
+    Decryptor(const PrivateKey* key);
+
+    // ------------------------------------------------------
+    // Decrypts a whole string.
+    //
+    // input: input string
+    // return: cypher string
+    string decryptString(CryptoString input);
+
+    //-------------------------------------------------------
+    // Decrypts a single char.
+    //
+    // c: input char
+    // return: decrypted char, represented as integer
+    int decryptChar(int c) const;
+  };
+}
+#endif

Encryptor.cpp

@@ -0,0 +1,32 @@
+#include <string>
+#include "Encryptor.h"
+#include "RSA.h"
+#include <boost/multiprecision/cpp_int.hpp>
+
+using namespace boost::multiprecision;
+using namespace Crypto;
+using std::string;
+
+Encryptor::Encryptor(const PublicKey* key) : text(""), public_key(key)
+{};
+
+CryptoString Encryptor::encryptString(string &input)
+{
+  CryptoString str;
+
+  int256_t tmp;
+  int it;
+  for (it = 0; it < input.length(); it++)
+  {
+    tmp = powm((int256_t)input.at(it), public_key->r, public_key->m);
+    str.push_back(tmp);
+  }
+
+  return str;
+}
+
+int256_t Encryptor::encryptChar(int c) const
+{
+  int256_t res = powm((int256_t)c, public_key->r, public_key->m);
+  return res.convert_to<int>();
+}

Encryptor.h

@@ -0,0 +1,37 @@
+//---------------------------------------------------------
+// Class to encrypt data.
+//
+// Author: Sebastian Weninger
+//
+
+#ifndef ENCRYPTOR_
+#define ENCRYPTOR_
+
+#include "RSA.h"
+#include <string>
+
+using std::string;
+
+namespace Crypto
+{
+  class Encryptor
+  {
+  private:
+    const PublicKey* public_key;
+
+    string text;
+
+  public:
+    // ---------------------
+    // Constructor
+    //
+    Encryptor(const PublicKey* key);
+
+    // ---------------------
+    // input: input string
+    // return: Crypto string
+    CryptoString encryptString(string& input);
+    int256_t encryptChar(int c) const;
+  };
+}
+#endif

Euclidean.cpp

@@ -0,0 +1,69 @@
+#include "Euclidean.h"
+
+#include <boost/multiprecision/cpp_int.hpp>
+using namespace boost::multiprecision;
+
+Euclidean::Euclidean()
+{};
+
+Euclidean::~Euclidean()
+{};
+
+int256_t Euclidean::extendedEuclidean(int256_t a, int256_t b, int256_t* x, int256_t* s)
+{
+  if ((a == 0) || (b == 0))
+  {
+    return 0;
+  }
+
+  int256_t q = 0;
+  int256_t r = 0;
+
+  q = a / b;
+
+  //remainder
+  r = a % b;
+
+  int256_t x_tmp = *x;
+  int256_t s_tmp = *s;
+  if (r != 0)
+  {
+    extendedEuclidean(b, r, &x_tmp, &s_tmp);
+  }
+
+  if (r == 0)
+  {
+    *x = 0;
+    *s = 1;
+
+    return b;
+  }
+
+  *x = s_tmp;
+  *s = x_tmp - (q * s_tmp);
+
+  return b;
+}
+
+int256_t Euclidean::euclidean(int256_t a, int256_t b)
+{
+
+  if ((a == 0) || (b == 0))
+  {
+    return 0;
+  }
+
+  int256_t q;
+  int256_t r;
+
+  do
+  {
+    q = a / b;
+    r = a % b;
+
+    a = b;
+    b = r;
+  } while (r != 0);
+
+  return a;
+}

Euclidean.h

@@ -0,0 +1,48 @@
+//---------------------------------------------------------
+// Implementation of the basic and extended euclidean algorithm.
+// Mainly used for secret key calculation.
+// 
+// Input and output of the algorithms are 256 bit integers from the
+// boost library.
+//
+// Author: Sebastian Weninger
+//
+
+#include <boost/multiprecision/cpp_int.hpp>
+using namespace boost::multiprecision;
+
+#ifndef EUCLIDEAN_
+#define EUCLIDEAN_
+
+class Euclidean
+{
+  private:
+    // Constructor
+    Euclidean();
+    // Desctructor
+    ~Euclidean();
+  public:
+
+    ///----------------------------------------------------
+    // Extended euclidean algorithm to calculate gcd of
+    // two integers and it's inverse representatives.
+    //
+    //
+    // *x: pointer to inverse of a
+    // *s: pointer to inverse of b (secret key in cryptography)
+    //
+    // return: gcd of a and b
+    //
+    static int256_t extendedEuclidean(int256_t a, int256_t b, int256_t* x, int256_t* s);
+
+    //-----------------------------------------------------
+    // Basic euclidean algorithm to calculate gcd of
+    // two integers.
+    //
+    // return: gcd of a and b
+    //
+    static int256_t euclidean(int256_t a, int256_t b);
+};
+
+#endif
+