summaryrefslogtreecommitdiff
path: root/src/CryptClass
diff options
context:
space:
mode:
Diffstat (limited to 'src/CryptClass')
-rw-r--r--src/CryptClass/AESCrypt.cpp126
-rw-r--r--src/CryptClass/AESCrypt.hpp101
-rw-r--r--src/CryptClass/AbstractSKA.hpp57
-rw-r--r--src/CryptClass/HASHCrypt.cpp116
-rw-r--r--src/CryptClass/HASHCrypt.hpp135
5 files changed, 535 insertions, 0 deletions
diff --git a/src/CryptClass/AESCrypt.cpp b/src/CryptClass/AESCrypt.cpp
new file mode 100644
index 0000000..d3ea949
--- /dev/null
+++ b/src/CryptClass/AESCrypt.cpp
@@ -0,0 +1,126 @@
+/**
+ * @file AESCrypt.cpp
+ * @brief AESCrypt class definitions
+ * @author manzerbredes
+ * @date 8 Mars 2015
+ *
+ * Contain all definitions of AESCrypt class.
+ *
+ */
+
+
+//----- class -----
+#include "AESCrypt.hpp"
+
+
+
+//Constructor
+AESCrypt::AESCrypt(){
+ this->hash=HASHCrypt(); //Init hash attribute
+}
+
+//Destructor
+AESCrypt::~AESCrypt(){
+
+}
+
+
+
+//Encrypt string with string key
+std::string AESCrypt::encrypt(std::string key, std::string data){
+
+ //Generate SHA-256
+ byte digest[32];
+ hash.getSHA_256(key, digest, (int)sizeof(digest));
+
+ return encryptRoutine(data, digest, sizeof(digest));
+
+}
+
+
+
+//Encrypt string with byte* key
+std::string AESCrypt::encrypt(byte* key, std::string data){
+ return encryptRoutine(data, key, 32);
+}
+
+
+
+//The encryptRoutine
+std::string AESCrypt::encryptRoutine(std::string data, byte* digest, int size){
+ //Contain data encrypted
+ std::string cipher;
+
+
+ //Use try, catch to be ensure no problems happening
+ try{
+ //Create encoder to encrypt data
+ CryptoPP::ECB_Mode<CryptoPP::AES>::Encryption encoder;
+ encoder.SetKey( digest, size );
+
+ //Encrypt data with StreamTransformationFilter with NO PADDING
+ CryptoPP::StringSource ss1(data, true,
+ new CryptoPP::StreamTransformationFilter( encoder,
+ new CryptoPP::StringSink( cipher ),
+ CryptoPP::StreamTransformationFilter::ZEROS_PADDING
+
+ )
+ );
+ }
+ catch( CryptoPP::Exception& e )
+ {
+ std::cerr << e.what() << std::endl;
+ exit(EXIT_FAILURE);
+ }
+
+ //return encrypted data
+ return cipher;
+
+
+}
+
+
+
+//Decrypt string
+std::string AESCrypt::decrypt(std::string key, std::string data){
+
+ //Get SHA-256
+ byte digest[32];
+ hash.getSHA_256(key, digest, (int)sizeof(digest));
+
+
+ //Contain data decrypted
+ std::string cipher;
+
+ //Use try, catch to be ensure no problems happening
+ try {
+
+ //Create decoder to encrypt data
+ CryptoPP::ECB_Mode< CryptoPP::AES >::Decryption decoder;
+ decoder.SetKey( digest, sizeof(digest) );
+
+ //Decrypt data with StreamTransformationFilter with NO PADDING
+ CryptoPP::StringSource ss3( data, true,
+ new CryptoPP::StreamTransformationFilter( decoder,
+ new CryptoPP::StringSink( cipher ),
+ CryptoPP::StreamTransformationFilter::NO_PADDING
+ )
+ );
+ }
+ catch( CryptoPP::Exception& e )
+ {
+ std::cerr << e.what() << std::endl;
+ exit(1);
+ }
+
+ //Remove ZEROS padding
+ int i=0;
+ for(i=0;i<cipher.length();i++){
+ if(cipher[i]=='\0')
+ break;
+ }
+ cipher.erase(i,cipher.length()-1); //Erase ZEROS
+
+ //return decrypted data
+ return cipher;
+}
diff --git a/src/CryptClass/AESCrypt.hpp b/src/CryptClass/AESCrypt.hpp
new file mode 100644
index 0000000..c4d75aa
--- /dev/null
+++ b/src/CryptClass/AESCrypt.hpp
@@ -0,0 +1,101 @@
+/**
+ * @file AESCrypt.hpp
+ * @brief AESCrypt class header
+ * @author manzerbredes
+ * @date 8 Mars 2015
+ *
+ * Contain all prototypes of AESCrypt class.
+ *
+ */
+
+#ifndef __AESCrypt__
+#define __AESCrypt__
+
+//----- std -----
+#include "AbstractSKA.hpp"
+#include "HASHCrypt.hpp"
+#include <iostream>
+
+//----- crypto++ -----
+#include <crypto++/aes.h>
+#include <crypto++/modes.h>
+#include <crypto++/filters.h>
+
+
+/**
+ * @class AESCrypt AESCrypt.hpp "/CryptClass/AESCrypt.hpp"
+ * @brief Class for Advanced Encryption Standard (AES) algorithm
+ * @author manzerbredes
+ *
+ * This class provide AES encrypt and decrypt.
+ * Key used is 32 bytes key (256 bits).
+ *
+ * \bug Find another solution for managing padding.
+ */
+class AESCrypt : public AbstractSKA {
+
+
+ public:
+ //Constructor
+ AESCrypt();
+
+ //Destructor
+ ~AESCrypt();
+
+
+ /**
+ * @brief Run encryptRoutine.
+ *
+ * @param key : key used to encrypt data
+ * @param data : contain data to encrypt.
+ *
+ * @return string : correspond to crypted data
+ *
+ * Run encryptRoutine with byte* key or string key.
+ * Allow you to choose between string key or byte key.
+ *
+ */
+ std::string encrypt(std::string key, std::string data);
+ std::string encrypt(byte* key, std::string data);
+
+
+ /**
+ * @brief Decrypt data from AES algorithm.
+ *
+ * @param key : key used to encrypt data
+ * @param data : contain data to decrypt from AES encrypt.
+ *
+ * @return string : correspond to decrypted data
+ *
+ * Decrypt data, and return them into a string.
+ *
+ */
+ std::string decrypt(std::string key, std::string data);
+
+
+
+ private:
+
+ /**
+ * @brief Encrypt data with AES algorithm.
+ *
+ * @param key : key used to encrypt data
+ * @param data : contain data to encrypt.
+ *
+ * @return string : correspond to crypted data
+ *
+ * Encrypt data, and return them into a string.
+ * Padding are blank space.
+ *
+ */
+ std::string encryptRoutine(std::string data, byte* digest, int size);
+
+
+ //Attributes:
+
+ HASHCrypt hash; ///< hash instance to generate SHA-256 hash code.
+
+
+};
+
+#endif
diff --git a/src/CryptClass/AbstractSKA.hpp b/src/CryptClass/AbstractSKA.hpp
new file mode 100644
index 0000000..7622ab4
--- /dev/null
+++ b/src/CryptClass/AbstractSKA.hpp
@@ -0,0 +1,57 @@
+/**
+ * @file AbstractSKA.hpp
+ * @brief Class for Symmetric-Key Algorithm (SKA)
+ * @author manzerbredes
+ * @date 8 Mars 2015
+ *
+ * Specify which method the algorithm must be implement.
+ *
+ */
+
+#ifndef __AbstractSKA__
+#define __AbstractSKA__
+
+
+//----- std -----
+#include <string>
+
+
+
+/**
+ * @class AbstractSKA AbstractSKA.hpp "/CryptClass/AbstractSKA.hpp"
+ * @brief Class for Symmetric-Key Algorithm (SKA)
+ * @author manzerbredes
+ *
+ * This class should not be instantiate directly.
+ *
+ */
+class AbstractSKA {
+
+ public:
+ /**
+ * @brief Encrypt data.
+ *
+ * @param key : key used to encrypt data
+ * @param data : contain data to encrypt.
+ *
+ * This method must be overwritten.
+ * **Warning** data will be modified.
+ *
+ */
+ virtual std::string encrypt(std::string key, std::string data) = 0;
+
+
+ /**
+ * @brief Decrypt data.
+ *
+ * @param key : key used to decrypt data
+ * @param data : contain data to decrypt.
+ *
+ * This method must be overwritten.
+ * **Warning** data will be modified.
+ *
+ */
+ virtual std::string decrypt(std::string key, std::string data) = 0;
+};
+
+#endif
diff --git a/src/CryptClass/HASHCrypt.cpp b/src/CryptClass/HASHCrypt.cpp
new file mode 100644
index 0000000..eed9cb5
--- /dev/null
+++ b/src/CryptClass/HASHCrypt.cpp
@@ -0,0 +1,116 @@
+/**
+ * @file HASHCrypt.cpp
+ * @brief HASHCrypt class definitions
+ * @author manzerbredes
+ * @date 8 Mars 2015
+ *
+ * Contain all definitions of HASHCrypt class.
+ *
+ */
+
+
+//----- class -----
+#include "HASHCrypt.hpp"
+
+
+
+//Constructor
+HASHCrypt::HASHCrypt(){
+}
+
+//Destructor
+HASHCrypt::~HASHCrypt(){
+}
+
+
+
+//Contruct MD5 over 128 bits and put it into digest
+void HASHCrypt::getMD5_128(std::string chain, byte* digest, int size){
+
+ //Digest size controller
+ this->checkDigestSize(CryptoPP::Weak1::MD5::DIGESTSIZE,size);
+
+ //Create the MD5 on digest parameter
+ CryptoPP::Weak1::MD5 hash;
+ hash.CalculateDigest( digest, (byte*) chain.c_str(), chain.length() );
+
+}
+
+
+
+//Contruct SHA-256 and put it into digest
+void HASHCrypt::getSHA_256(std::string chain, byte* digest, int size){
+
+ //Digest size controller
+ this->checkDigestSize(CryptoPP::SHA256::DIGESTSIZE,size);
+
+ //Create the SHA-256 on digest parameter
+ CryptoPP::SHA256 hash;
+ hash.CalculateDigest( digest, (byte*) chain.c_str(), chain.length() );
+
+
+}
+
+
+
+//Compare 2 digest (same size)
+bool HASHCrypt::compareDigest(byte* digest1, byte* digest2, int size){
+
+ //Try is more safe
+ try
+ {
+ //Compare the two digest
+ for(int i=0; i<size; i++){
+ //Return false if digest are different
+ if(digest1[i] != digest2[i]){
+ return false;
+ }
+ }
+ }
+ catch (std::exception& e)
+ {
+ std::cerr << "Exception catched : " << e.what() << std::endl;
+ }
+
+ //Return true if digest are equals
+ return true;
+}
+
+
+
+//Convert digest to string
+std::string HASHCrypt::digestToString(byte* digest, int size){
+
+ CryptoPP::HexEncoder encoder;
+ std::string output;
+ encoder.Attach( new CryptoPP::StringSink( output ) );
+ encoder.Put( digest, size );
+ encoder.MessageEnd();
+
+ return output;
+}
+
+
+
+//Check the size of the digest
+void HASHCrypt::checkDigestSize(int sizeRequired, int size){
+ try{
+ if(size !=sizeRequired){
+ throw this->getInvalidDigestSizeError(sizeRequired, size);
+ }
+
+ }
+ catch(std::string erreur){
+ std::cerr << erreur <<std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+}
+
+
+
+//Make the error
+std::string HASHCrypt::getInvalidDigestSizeError(int sizeRequired, int size){
+ std::ostringstream erreurStream;
+ erreurStream << "Invalid digest size ! ("<< sizeRequired <<" bytes required and "<< size <<" given)";
+ return erreurStream.str();
+}
diff --git a/src/CryptClass/HASHCrypt.hpp b/src/CryptClass/HASHCrypt.hpp
new file mode 100644
index 0000000..3eafb2f
--- /dev/null
+++ b/src/CryptClass/HASHCrypt.hpp
@@ -0,0 +1,135 @@
+/**
+ * @file HASHCrypt.hpp
+ * @brief HASHCrypt class header
+ * @author manzerbredes
+ * @date 8 Mars 2015
+ *
+ * Contain all prototypes of HASHCrypt class.
+ *
+ */
+
+#ifndef __HASHCrypt__
+#define __HASHCrypt__
+
+//----- std -----
+#include <iostream>
+#include <string>
+#include <sstream>
+
+//----- crypto++ -----
+#define CRYPTOPP_ENABLE_NAMESPACE_WEAK 1
+#include <crypto++/md5.h> //For MD5
+#include <crypto++/hex.h> //For Hex convertion
+#include <crypto++/sha.h> //For SHA
+
+
+/**
+ * @class HASHCrypt HASHCrypt.hpp "/CryptClass/HASHCrypt.hpp"
+ * @brief Hashing class
+ * @author manzerbredes
+ *
+ * Class who handle hashing functions on a byte* parameter.
+ * HASHCrypt try to detect errors and throw exceptions.
+ * HASHCrypt use crypto++ library.
+ */
+class HASHCrypt{
+
+ public:
+ /**
+ * @brief Contructor
+ */
+ HASHCrypt();
+
+ /**
+ * @brief Destructor
+ */
+ ~HASHCrypt();
+
+
+ /**
+ * @brief Create an MD5 over 128 bits on a digest array of bytes.
+ *
+ * @param chain : Chain to hash
+ * @param digest : An array of bytes (8 bits)
+ * @param size : Length of digest
+ *
+ * **Warning** digest will be modified.
+ * Digest must be an array of byte with 16 entries
+ * Invalid size can cause "Segmentation Fault"
+ */
+ void getMD5_128(std::string chain, byte* digest, int size);
+
+
+ /**
+ * @brief Create an SHA over 256 bits on a digest array of bytes.
+ *
+ * @param chain : Chain to hash
+ * @param digest : An array of bytes (8 bits)
+ * @param size : Length of digest
+ *
+ * **Warning** digest will be modified.
+ * Digest must be an array of byte with 32 entries
+ * Invalid size can cause "Segmentation Fault"
+ */
+ void getSHA_256(std::string chain, byte* digest, int size); //Return SHA_256
+
+
+ /**
+ * @brief Convert digest to a string of HEX characters
+ *
+ * @param digest : an array of bytes (8 bits)
+ * @param size : length of digest
+ *
+ * @return return a string of hex digest equivalent
+ *
+ * Digest must be an array of byte.
+ */
+ std::string digestToString(byte* digest, int size); //Return a string
+
+
+ /**
+ * @brief Compare 2 digest
+ *
+ * @param digest1 : An array of bytes (8 bits)
+ * @param digest2 : An array of bytes (8 bits)
+ * @param size : Length of the array digest1 or digest2
+ *
+ * @return return a boolean (true if digest1 equals to digest2 and false else)
+ *
+ * **Warning** if sizeof(digest1) != sizeof(digest 2) : segmentation fault !
+ * Compare the two digest.
+ *
+ */
+ bool compareDigest(byte* digest1, byte* digest2, int size);
+
+
+ private:
+
+ /**
+ * @brief Check the digest size
+ *
+ * @param sizeRequired : Digest size expected
+ * @param size : Given digest size
+ *
+ * Throw an exception, and stop the program if
+ * sizeRequired != size
+ * Use getInvalidDigestSizeError method.
+ */
+ void checkDigestSize(int sizeRequired, int size);
+
+
+ /**
+ * @brief Make "invalid digest size" error message.
+ *
+ * @param sizeRequired : Digest size expected
+ * @param size : Given digest size
+ *
+ * @return a string correspond to the error message
+ *
+ * Construct an error message with sizeRequired and size.
+ */
+ std::string getInvalidDigestSizeError(int sizeRequired, int size);
+
+};
+
+#endif
generated by cgit v1.2.3 (git 2.46.0) at 2026-04-16 00:12:09 +0000