Browse Source

Add base64 encryption for aes key and aes IV

master
Antoine 11 months ago
parent
commit
91898250bc
7 changed files with 185 additions and 23 deletions
  1. +21
    -9
      Makefile
  2. +8
    -11
      aes.hpp
  3. +2
    -0
      data/cryptomain/file
  4. +137
    -0
      lib/base64/base64.cpp
  5. +14
    -0
      lib/base64/base64.hpp
  6. +2
    -2
      main.cpp
  7. +1
    -1
      mainDecrypt.cpp

+ 21
- 9
Makefile View File

@@ -1,23 +1,35 @@
.PHONY: cryptomain.ex crypt.ex decrypt.ex

GCXX_DEBUG=-ggdb
CFLAGS=-Wall -Wextra --std=c++14 $(GCXX_DEBUG)
LDFLAGS=-lcrypto
CXX=g++

BIN_PATH=./bin
LIB_PATH=./lib
OBJ_PATH=./obj

EXEC=$(BIN_PATH)/cryptomain.ex
SRC=main.cpp
JSON_CPP=$(OBJ_PATH)/jsoncpp.o
JSONCPP_O=$(OBJ_PATH)/jsoncpp.o
BASE64_O=$(OBJ_PATH)/base64.o

cryptomain.ex: $(EXEC)

# merge crypt and decrypt binary into cryptomain
$(EXEC): $(SRC) *.hpp $(JSON_CPP)
$(EXEC): $(SRC) *.hpp $(JSONCPP_O) $(BASE64_O)
@echo "compilation de aes"
@g++ -Wall -Wextra -ggdb -o $(EXEC) $(SRC) $(JSON_CPP) -lcrypto --std=c++14
@$(CXX) $(CFLAGS) $(LDFLAGS) -o $(EXEC) $(SRC) $(JSONCPP_O) $(BASE64_O)

SOURCES_BASE64=$(wildcard $(LIB_PATH)/base64/base64.*)
$(BASE64_O): $(SOURCES_BASE64)
@echo "compilation de base64"
@$(CXX) $(CFLAGS) -c $(LIB_PATH)/base64/base64.cpp -o $(BASE64_O)

$(JSON_CPP): $(LIB_PATH)/jsoncpp.cpp $(LIB_PATH)/json/json.h $(LIB_PATH)/json/json-forwards.h
SOURCES_JSON_CPP :=$(LIB_PATH)/jsoncpp.cpp $(wildcard $(LIB_PATH)/*.h)
$(JSONCPP_O): $(SOURCES_JSON_CPP)
@echo "compilation de jsoncpp"
@g++ -I ../lib/jsoncpp-master/include/ -Wall -Wextra -std=c++11 -c -ggdb $(LIB_PATH)/jsoncpp.cpp -o $(JSON_CPP)
@$(CXX) $(CFLAGS) -I ../lib/jsoncpp-master/include/ -c $(LIB_PATH)/jsoncpp.cpp -o $(JSONCPP_O)

run: $(EXEC)
@./$(EXEC) data/cryptomain/file
@@ -31,13 +43,13 @@ SRC_DECRYPT=mainDecrypt.cpp
crypt.ex: $(EXEC_CRYPT)
decrypt.ex: $(EXEC_DECRYPT)

$(EXEC_CRYPT): $(SRC_CRYPT) *.hpp $(JSON_CPP)
$(EXEC_CRYPT): $(SRC_CRYPT) *.hpp $(JSONCPP_O) $(BASE64_O)
@echo "compilation de crypt.ex"
@g++ -Wall -Wextra -ggdb -o $(EXEC_CRYPT) $(SRC_CRYPT) $(JSON_CPP) -lcrypto --std=c++14
@$(CXX) $(CFLAGS) $(LDFLAGS) -o $(EXEC_CRYPT) $(SRC_CRYPT) $(JSONCPP_O) $(BASE64_O)

$(EXEC_DECRYPT): $(SRC_DECRYPT) *.hpp $(JSON_CPP)
$(EXEC_DECRYPT): $(SRC_DECRYPT) *.hpp $(JSONCPP_O) $(BASE64_O)
@echo "compilation de decrypt.ex"
@g++ -Wall -Wextra -ggdb -o $(EXEC_DECRYPT) $(SRC_DECRYPT) $(JSON_CPP) -lcrypto --std=c++14
@$(CXX) $(CFLAGS) $(LDFLAGS) -o $(EXEC_DECRYPT) $(SRC_DECRYPT) $(JSONCPP_O) $(BASE64_O)

run2: $(EXEC_CRYPT) $(EXEC_DECRYPT)
@./$(EXEC_CRYPT) data/crypt_decrypt/file && ./$(EXEC_DECRYPT) data/crypt_decrypt/file.enc data/crypt_decrypt/file.key


+ 8
- 11
aes.hpp View File

@@ -18,6 +18,7 @@
#include <openssl/rand.h>

#include "lib/json/json.h"
#include "lib/base64/base64.hpp"

#define FAILURE -1
#define SUCCESS 0
@@ -84,9 +85,9 @@ void aes::init_all() {
exit(FAILURE);
}

// #define USE_PBKDF
#define USE_PBKDF
#ifdef USE_PBKDF
std::cerr << "utilisation de USE_PBKDF" << std::endl;
std::cerr << "Use of USE_PBKDF parameter" << std::endl;
// Get some random data to use as the AES pass and salt
if(RAND_bytes(aesPass, AES_KEYLEN/8) == 0) {
exit(FAILURE);
@@ -216,11 +217,7 @@ std::string aes::PrintAesKey() {
std::string res;

res = "aesKey : ";
for (int i = 0; i < 32; i++) {
ss << std::hex;
ss >> res;
res += std::string(1, (char)aesKey[i]+'\n');
}
res += base64_encode(aesKey, AES_KEYLEN/8);
return res;
}

@@ -230,8 +227,8 @@ void aes::importKey(const char* filename) {
std::ifstream keyfile(filename, std::ifstream::binary);
keyfile >> root;

setAesKey(reinterpret_cast<const unsigned char*>(root["key"].asString().c_str()));
setAesIV(reinterpret_cast<const unsigned char*>(root["IV"].asString().c_str()));
setAesKey(reinterpret_cast<const unsigned char*>(base64_decode(root["key"].asString()).c_str()));
setAesIV(reinterpret_cast<const unsigned char*>(base64_decode(root["IV"].asString()).c_str()));
}

std::string aes::exportKey() {
@@ -242,8 +239,8 @@ std::string aes::exportKey(const char* filename) {
// export the tuples aeskey and aesIV to json file
Json::Value root;

root["key"] = std::string(reinterpret_cast<char *>(aesKey));
root["IV"] = std::string(reinterpret_cast<char *>(aesIV));
root["key"] = base64_encode(aesKey, AES_KEYLEN/8);
root["IV"] = base64_encode(aesIV, AES_KEYLEN/8);

std::ofstream out(filename);
out << root;


+ 2
- 0
data/cryptomain/file View File

@@ -1 +1,3 @@
toto

ceic est &é à un test

+ 137
- 0
lib/base64/base64.cpp View File

@@ -0,0 +1,137 @@
/*
base64.cpp and base64.h

base64 encoding and decoding with C++.

Version: 1.02.00

Copyright (C) 2004-2017, 2020 René Nyffenegger

This source code is provided 'as-is', without any express or implied
warranty. In no event will the author be held liable for any damages
arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:

1. The origin of this source code must not be misrepresented; you must not
claim that you wrote the original source code. If you use this source code
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original source code.

3. This notice may not be removed or altered from any source distribution.

René Nyffenegger rene.nyffenegger@adp-gmbh.ch

*/

#include "base64.hpp"
#include <cctype>

static const std::string base64_chars =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";

static std::size_t pos_of_char(const unsigned char chr) {
//
// Return the position of chr within base64_chars.
//

if (chr >= 'A' && chr <= 'Z') return chr - 'A';
else if (chr >= 'a' && chr <= 'z') return chr - 'a' + ('Z' - 'A') + 1;
else if (chr >= '0' && chr <= '9') return chr - '0' + ('Z' - 'A') + ('z' - 'a') + 2;
else if (chr == '+' ) return 62;
else if (chr == '/' ) return 63;

throw "If input is correct, this line should never be reached.";
}

static inline bool is_base64(unsigned char c) {
return (isalnum(c) || (c == '+') || (c == '/'));
}

std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {
std::string ret;
int i = 0;
unsigned char char_array_3[3];
unsigned char char_array_4[4];

while (in_len--) {
char_array_3[i++] = *(bytes_to_encode++);
if (i == 3) {
char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
char_array_4[3] = char_array_3[2] & 0x3f;

for(i = 0; (i <4) ; i++)
ret.push_back(base64_chars[char_array_4[i]]);
i = 0;
}
}

if (i)
{
for(int j = i; j < 3; j++)
char_array_3[j] = '\0';

char_array_4[0] = ( char_array_3[0] & 0xfc) >> 2;
char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);

for (int j = 0; (j < i + 1); j++)
ret.push_back(base64_chars[char_array_4[j]]);

while((i++ < 3))
ret.push_back('=');
}

return ret;

}

std::string base64_decode(std::string const& encoded_string) {
size_t in_len = encoded_string.size();
int i = 0;
int in_ = 0;
unsigned char char_array_4[4], char_array_3[3];
std::string ret;

ret.reserve(encoded_string.size() / 4 * 3);

while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
char_array_4[i++] = encoded_string[in_]; in_++;
if (i ==4) {
for (i = 0; i <4; i++) {
char_array_4[i] = pos_of_char(char_array_4[i]);
}

char_array_3[0] = ( char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

for (i = 0; (i < 3); i++)
ret.push_back(char_array_3[i]);
i = 0;
}
}

if (i) {
for (int j = 0; j < i; j++) {
char_array_4[j] = pos_of_char(char_array_4[j]);
}

char_array_3[0] = ( char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);

for (int j = 0; (j < i - 1); j++)
ret.push_back(char_array_3[j]);
}

return ret;
}

+ 14
- 0
lib/base64/base64.hpp View File

@@ -0,0 +1,14 @@
//
// base64 encoding and decoding with C++.
// Version: 1.02.00
//

#ifndef BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A
#define BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A

#include <string>

std::string base64_encode(unsigned char const* , unsigned int len);
std::string base64_decode(std::string const& s);

#endif /* BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A */

+ 2
- 2
main.cpp View File

@@ -8,7 +8,7 @@ int main(int argc, char* argv[]) {
return 1;
}

//***************************************************
//***************************************************
char* filename = argv[1];

aes* O = new crypt(filename);
@@ -39,7 +39,7 @@ int main(int argc, char* argv[]) {

free(encryptedFile);
free(file);
//***************************************************
//***************************************************
std::cerr << "*******************************" << std::endl;
aes* O2 = new decrypt(encryptedFilename.c_str(), O->getAesKey(), O->getAesIV());



+ 1
- 1
mainDecrypt.cpp View File

@@ -24,7 +24,7 @@ int main(int argc, char* argv[]) {
}

printf("%d bytes decrypted\n", (int)decryptedFileLength);
std::cerr << O2->PrintAesKey() << std::endl;
std::cerr << "mainDeCrypt.ex : " << O2->PrintAesKey() << std::endl;

// Write the decrypted file to its own file
std::string decryptedFilename = O2->writeFile(decryptedFile, decryptedFileLength);


Loading…
Cancel
Save