premier commit programme fonctionne mais code dégeu

aes.cpp

@@ -0,0 +1,256 @@
+#include <openssl/evp.h>
+#include <openssl/pem.h>
+#include <openssl/aes.h>
+#include <openssl/err.h>
+#include <openssl/rand.h>
+
+#include <iostream>
+#include <stdio.h>
+#include <string>
+#include <string.h>
+
+#define FAILURE -1
+#define SUCCESS 0
+
+#define AES_KEYLEN 256
+#define AES_ROUNDS 6
+
+
+int aesDecrypt(EVP_CIPHER_CTX* aesDecryptCtx, unsigned char* aesKey, unsigned char* aesIV, unsigned char *encMsg, size_t encMsgLen, unsigned char **decMsg) {
+    size_t decLen   = 0;
+    size_t blockLen = 0;
+
+    *decMsg = (unsigned char*)malloc(encMsgLen);
+    if(*decMsg == NULL) return FAILURE;
+
+    if(!EVP_DecryptInit_ex(aesDecryptCtx, EVP_aes_256_cbc(), NULL, aesKey, aesIV)) {
+        return FAILURE;
+    }
+
+    if(!EVP_DecryptUpdate(aesDecryptCtx, (unsigned char*)*decMsg, (int*)&blockLen, encMsg, (int)encMsgLen)) {
+        return FAILURE;
+    }
+    decLen += blockLen;
+
+    if(!EVP_DecryptFinal_ex(aesDecryptCtx, (unsigned char*)*decMsg + decLen, (int*)&blockLen)) {
+        return FAILURE;
+    }
+    decLen += blockLen;
+
+    EVP_CIPHER_CTX_cleanup(aesDecryptCtx);
+
+    return (int)decLen;
+}
+
+int aesEncrypt(EVP_CIPHER_CTX* aesEncryptCtx, unsigned char* aesKey, unsigned char* aesIV, const unsigned char *msg, size_t msgLen, unsigned char **encMsg) {
+    size_t blockLen  = 0;
+    size_t encMsgLen = 0;
+
+    *encMsg = (unsigned char*)malloc(msgLen + AES_BLOCK_SIZE);
+    if(encMsg == NULL) return FAILURE;
+
+    if(!EVP_EncryptInit_ex(aesEncryptCtx, EVP_aes_256_cbc(), NULL, aesKey, aesIV)) {
+        return FAILURE;
+    }
+
+    if(!EVP_EncryptUpdate(aesEncryptCtx, *encMsg, (int*)&blockLen, (unsigned char*)msg, msgLen)) {
+        return FAILURE;
+    }
+    encMsgLen += blockLen;
+
+    if(!EVP_EncryptFinal_ex(aesEncryptCtx, *encMsg + encMsgLen, (int*)&blockLen)) {
+        return FAILURE;
+    }
+
+    EVP_CIPHER_CTX_cleanup(aesEncryptCtx);
+
+    return encMsgLen + blockLen;
+}
+
+void clear_all(EVP_CIPHER_CTX* aesEncryptCtx, EVP_CIPHER_CTX* aesDecryptCtx, unsigned char* aesKey, unsigned char* aesIV) {
+	EVP_CIPHER_CTX_cleanup(aesEncryptCtx);
+	EVP_CIPHER_CTX_cleanup(aesDecryptCtx);
+ 
+	free(aesEncryptCtx);
+    free(aesDecryptCtx);
+
+    free(aesIV);
+    free(aesKey);
+}
+
+void init_all(EVP_CIPHER_CTX* aesEncryptCtx, EVP_CIPHER_CTX* aesDecryptCtx, unsigned char* aesKey, unsigned char* aesIV) {
+	EVP_CIPHER_CTX_init(aesEncryptCtx);
+    EVP_CIPHER_CTX_init(aesDecryptCtx);
+
+    unsigned char *aesPass = (unsigned char*)malloc(AES_KEYLEN/8);
+    unsigned char *aesSalt = (unsigned char*)malloc(8);
+
+    if(aesKey == NULL || aesIV == NULL || aesPass == NULL || aesSalt == NULL) {
+    	exit(FAILURE);
+    }
+
+    #define USE_PBKDF
+    #ifdef USE_PBKDF
+    	std::cerr << "utilisation de USE_PBKDF" << std::endl;
+        // Get some random data to use as the AES pass and salt
+        if(RAND_bytes(aesPass, AES_KEYLEN/8) == 0) {
+            exit(FAILURE);
+        }
+
+        if(RAND_bytes(aesSalt, 8) == 0) {
+            exit(FAILURE);
+        }
+
+        if(EVP_BytesToKey(EVP_aes_256_cbc(), EVP_sha256(), aesSalt, aesPass, AES_KEYLEN/8, AES_ROUNDS, aesKey, aesIV) == 0) {
+            exit(FAILURE);
+        }
+    #else
+        if(RAND_bytes(aesKey, AES_KEYLEN/8) == 0) {
+            exit(FAILURE);
+        }
+
+        if(RAND_bytes(aesIV, AES_KEYLEN/8) == 0) {
+            exit(FAILURE);
+        }
+    #endif
+
+    free(aesPass);
+    free(aesSalt);
+}
+
+void writeFile(char *filename, unsigned char *file, size_t fileLength) {
+    FILE *fd = fopen(filename, "wb");
+    if(fd == NULL) {
+        fprintf(stderr, "Failed to open file: %s\n", strerror(errno));
+        exit(1);
+    }
+
+    size_t bytesWritten = fwrite(file, 1, fileLength, fd);
+
+    if(bytesWritten != fileLength) {
+        fprintf(stderr, "Failed to write file\n");
+        exit(1);
+    }
+
+    fclose(fd);
+}
+
+int readFile(char *filename, unsigned char **file) {
+    FILE *fd = fopen(filename, "rb");
+    if(fd == NULL) {
+        fprintf(stderr, "Failed to open file: %s\n", strerror(errno));
+        exit(1);
+    }
+
+    // Determine size of the file
+    fseek(fd, 0, SEEK_END);
+    size_t fileLength = ftell(fd);
+    fseek(fd, 0, SEEK_SET);
+
+    // Allocate space for the file
+    *file = (unsigned char*)malloc(fileLength);
+    if(*file == NULL) {
+        fprintf(stderr, "Failed to allocate memory\n");
+        exit(1);
+    }
+
+    // Read the file into the buffer
+    size_t bytesRead = fread(*file, 1, fileLength, fd);
+
+    if(bytesRead != fileLength) {
+        fprintf(stderr, "Error reading file\n");
+        exit(1);
+    }
+
+    fclose(fd);
+
+    return fileLength;
+}
+
+int main(int argc, char* argv[]) {
+	if(argc != 2) {
+        fprintf(stderr, "No file argument supplied.\n");
+        return 1;
+    }
+
+	EVP_CIPHER_CTX* aesEncryptCtx = (EVP_CIPHER_CTX*)malloc(sizeof(EVP_CIPHER_CTX));
+	EVP_CIPHER_CTX* aesDecryptCtx = (EVP_CIPHER_CTX*)malloc(sizeof(EVP_CIPHER_CTX));
+	if(aesDecryptCtx == NULL || aesEncryptCtx == NULL) {
+		return FAILURE;
+	}
+
+	unsigned char* aesKey = (unsigned char*)malloc(AES_KEYLEN/8);
+	unsigned char* aesIV = (unsigned char*)malloc(AES_KEYLEN/8);
+
+	init_all(aesEncryptCtx, aesDecryptCtx, aesKey, aesIV);
+
+	//***************************************************
+	char* filename = argv[1];
+
+    // Read the file to encrypt
+    unsigned char *file;
+    size_t fileLength = readFile(filename, &file);
+    printf("%d bytes to be encrypted\n", (int)fileLength);
+
+    // Encrypt the file
+    unsigned char *encryptedFile;
+    int encryptedFileLength;
+    if((encryptedFileLength = aesEncrypt(aesEncryptCtx, aesKey, aesIV, (const unsigned char*)file, fileLength, &encryptedFile)) == -1) {
+        fprintf(stderr, "Encryption failed\n");
+        return 1;
+    }
+    printf("%d bytes encrypted\n", encryptedFileLength);
+
+    // Append .enc to the filename
+    char *encryptedFilename = (char*)malloc(strlen(filename) + 5);
+    if(encryptedFilename == NULL) {
+        fprintf(stderr, "Failed to allocate memory\n");
+        return 1;
+    }
+    sprintf(encryptedFilename, "%s.enc", filename);
+
+    // Write the encrypted file to its own file
+    writeFile(encryptedFilename, encryptedFile, encryptedFileLength);
+    
+    std::cerr << "aesKey : ";
+	for (int i = 0; i < 32; i++) {
+		std::cerr << std::hex << aesKey[i];
+	}
+    std::cerr << std::endl;
+
+    printf("Encrypted message written to \"%s\"\n", encryptedFilename);
+
+    free(file);
+	//***************************************************
+
+    fileLength = readFile(encryptedFilename, &file);
+
+    // Decrypt the encrypted file
+    unsigned char *decryptedFile;
+    int decryptedFileLength;
+    if((decryptedFileLength = aesDecrypt(aesDecryptCtx, aesKey, aesIV, file, fileLength, &decryptedFile)) == -1) {
+        fprintf(stderr, "Decryption failed\n");
+        return 1;
+    }
+    printf("%d bytes decrypted\n", (int)decryptedFileLength);
+
+    // Append .dec to the filename
+    char *decryptedFilename = (char*)malloc(strlen(filename) + 5);
+    if(decryptedFilename == NULL) {
+        fprintf(stderr, "Failed to allocate memory\n");
+        return 1;
+    }
+    sprintf(decryptedFilename, "%s.dec", filename);
+    
+    // Write the decrypted file to its own file
+    writeFile(decryptedFilename, decryptedFile, decryptedFileLength);
+    printf("Decrypted file written to \"%s\"\n", decryptedFilename);
+
+    free(decryptedFile);
+    free(file);
+
+
+    //***************************************************
+    clear_all(aesEncryptCtx, aesDecryptCtx, aesKey, aesIV);
+	return 0;
+}

file.txt

@@ -0,0 +1,7 @@
+toto
+
+
+rftyguhjio
+
+ftyguhiokpl
+ùvfdjibngflkg,kflhi,omqcgikfsngchjfdngbfopdpioijn,hgiuhnb,sd;

makefile

@@ -0,0 +1,6 @@
+main:
+	@g++ -Wall -Wextra -ggdb -o crypto.ex aes.cpp -lcrypto
+	@./crypto.ex file.txt
+
+clean:
+	@rm *.ex