[OpenSSL] Erreur lors du décryptage AES 256 cbc.

Salut, j'utilise openssl pour chiffrer mes messages sur le réseau.

Cependant, parfois (pas tout le temps) j'ai cette erreur :

Code:

1
2
 
Error encrypting message: error:06065064:digital envelope routines:EVP_DecryptFinal_ex:bad decrypt

Pourtant je n'ai rien fait d'autre que de suivre un tutoriel, ce qui me donne le code suivant.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
unsigned char* AES_ENC::ossl_encrypt(const unsigned char* data, int dataSize, int& newSize) {
            int blockLen = 0;
            int encMsgLen = 0;
            unsigned char *encData = new unsigned char[dataSize + AES_BLOCK_SIZE];
            if (!EVP_EncryptInit_ex(e_ctx, EVP_aes_256_cbc(), nullptr, ossl_key, iv))
                return nullptr;
            if (!EVP_EncryptUpdate(e_ctx, encData, &blockLen, data, dataSize))
                return nullptr;
            encMsgLen += blockLen;
            if(!EVP_EncryptFinal_ex(e_ctx, encData+encMsgLen, &blockLen)) {
                return nullptr;
            }
            newSize = encMsgLen + blockLen;
 
            return encData;
        }
        unsigned char* AES_ENC::ossl_decrypt(const unsigned char* encData, int dataSize, int& newSize) {
            int blockLen = 0;
            int decMsgLen = 0;
            unsigned char *data = new unsigned char[dataSize];
            if (!EVP_DecryptInit_ex(d_ctx, EVP_aes_256_cbc(), nullptr, ossl_key, iv))
                return nullptr;
            if (!EVP_DecryptUpdate(d_ctx, data, &blockLen, encData, dataSize))
                return nullptr;
            decMsgLen += blockLen;
            if (!EVP_DecryptFinal_ex(d_ctx, data+decMsgLen, &blockLen)) {
                char* err = (char*) malloc(130);
                ERR_load_crypto_strings();
                ERR_error_string(ERR_get_error(), err);
                fprintf(stderr, "Error encrypting message: %s\n", err);
                free(err);
            }
            newSize = decMsgLen + blockLen;
            return data;
        }

Sachant que je chiffre la clé et l'iv avec du rsa.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
unsigned char* Rsa::ossl_encryptWithPrKey (const unsigned char *data, int dataSize, int& newSize) {
            unsigned char* encData = new unsigned char[RSA_size(keypair)];
            newSize = RSA_private_encrypt(dataSize, data, encData, keypair, RSA_PKCS1_PADDING);
            if (newSize == -1) {
                char* err = (char*) malloc(130);
                ERR_load_crypto_strings();
                ERR_error_string(ERR_get_error(), err);
                fprintf(stderr, "Error encrypting message: %s\n", err);
                free(err);
                return nullptr;
            }
            return encData;
        }
        unsigned char* Rsa::ossl_decryptWithPrKey (const unsigned char *encData, int dataSize, int& newSize) {
            unsigned char *data = new unsigned char[RSA_size(keypair)];
            newSize = RSA_private_decrypt(RSA_size(keypair), encData, data, keypair, RSA_PKCS1_OAEP_PADDING);
            if (newSize == -1) {
                char* err = (char*) malloc(130);
                ERR_load_crypto_strings();
                ERR_error_string(ERR_get_error(), err);
                fprintf(stderr, "Error encrypting message: %s\n", err);
                free(err);
                return nullptr;
            }
            return data;
        }
        unsigned char* Rsa::ossl_encryptWithPbKey (const unsigned char *data,int dataSize, int& newSize) {
            unsigned char *encData = new unsigned char[RSA_size(keypair)];
            newSize = RSA_public_encrypt(dataSize, data, encData, keypair, RSA_PKCS1_OAEP_PADDING);
            if (newSize == -1) {
                char* err = (char*) malloc(130);
                ERR_load_crypto_strings();
                ERR_error_string(ERR_get_error(), err);
                fprintf(stderr, "Error encrypting message: %s\n", err);
                free(err);
                return nullptr;
            }
            return encData;
        }
        unsigned char* Rsa::ossl_decryptWithPbKey (const unsigned char *encData, int dataSize, int &newSize) {
            unsigned char *data = new unsigned char[RSA_size(keypair)];
            newSize = RSA_public_decrypt(RSA_size(keypair), encData, data, keypair, RSA_PKCS1_PADDING);
            if (newSize == -1) {
                char* err = (char*) malloc(130);
 
                ERR_load_crypto_strings();
                ERR_error_string(ERR_get_error(), err);
                fprintf(stderr, "Error encrypting message: %s\n", err);
                free(err);
                return nullptr;
            }
            return data;
        }

On dirait que dans certains cas la clé pour l'aes n'est pas bonne.