AES (aes-cbc-128, aes-cbc-192, aes-cbc-256) шифрование/дешифрование с помощью openssl C
Я просто хочу протестировать AES из openSSL с помощью этих трех режимов: с длиной 128 192 и 256, но мой расшифрованный текст отличается от моего ввода, и я не знаю почему. Кроме того, когда я пропускаю огромную длину ввода (скажем, 1024 байта), моя программа показывает core dumped... Мой вход всегда один и тот же, но он не имеет значения, по крайней мере на данный момент. Вот код:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <openssl/aes.h>
int main(int argc, char **argv)
{
int i;
int keylength;
printf("Give a key length [only 128 or 192 or 256!]:\n");
scanf("%d", &keylength);
/* generate a key with a given length */
unsigned char aes_key[keylength];
memset(aes_key, 0, sizeof(aes_key));
if (!RAND_bytes(aes_key, keylength))
{
exit(-1);
}
aes_key[keylength-1] = '\0';
int inputslength;
printf("Give an input length:\n");
scanf("%d", &inputslength);
/* generate input with a given length */
unsigned char aes_input[inputslength+1];
memset(aes_input, '0', sizeof(aes_input));
aes_input[inputslength] = '\0';
/*printf("original:\t");
for(i=0; i<inputslength; i++)
{
printf("%c ", aes_input[i]);
}
printf("\n");*/
/* init vector */
unsigned char iv[AES_BLOCK_SIZE];
if (!RAND_bytes(iv, AES_BLOCK_SIZE))
{
exit(-1);
}
//printf("AES_BLOCK_SIZE = %d\n", AES_BLOCK_SIZE); // aes block size is 16 bytes = 128 bits
AES_KEY enc_key, dec_key;
unsigned char enc_out[AES_BLOCK_SIZE];
unsigned char dec_out[AES_BLOCK_SIZE];
// so i can do with this aes-cbc-128 aes-cbc-192 aes-cbc-256
AES_set_encrypt_key(aes_key, keylength, &enc_key);
AES_cbc_encrypt(aes_input, enc_out, inputslength, &enc_key, iv, AES_ENCRYPT);
AES_set_decrypt_key(aes_key, keylength, &dec_key);
AES_decrypt(enc_out, dec_out, &dec_key);
printf("original:\t");
for(i=0;*(aes_input+i)!=0x00;i++)
printf("%X ",*(aes_input+i));
printf("\nencrypted:\t");
for(i=0;*(enc_out+i)!=0x00;i++)
printf("%X ",*(enc_out+i));
printf("\ndecrypted:\t");
for(i=0;*(dec_out+i)!=0x00;i++)
printf("%X ",*(dec_out+i));
printf("\n");
/*printf("\n\noriginal:\t");
for(i=0; i<inputslength; i++)
{
printf("%x ", dec_out[i]);
}
printf("\n");*/
return 0;
}
EDIT:
Когда я изменил размеры выходов на inputslength вместо AES_BLOCK_SIZE, я получил результаты:
Give a key length [only 128 or 192 or 256!]:
128
Give an input length:
5
original: 30 30 30 30 30
encrypted: 94 56 50 7E 19 B2 1C CE 20 23 4A E7 10 AF DB E3 30 30 30 30 30
decrypted: E1 5F F4 3D E8 8D 91 19 CD 3E 22 1E AF 1C 8F 5A 94 56 50 7E 19 B2 1C CE 20 23 4A E7 10 AF DB E3 30 30 30 30 30
Возможно ли, что проблема с размерами аванса и размером iv? Какие размеры они должны иметь (для AES-CBC-128, AES-CBC-192, AES-CBC-256)?
Ответы
Ответ 1
Взгляните на эту измененную версию вашего кода. Обратите внимание на следующее:
- Добавлен hex_print (minor)
- Добавлен правильный размер буфера (среды).
- Добавлен правильный размер выходного буфера шифрования (который должен быть кратным размером блока, и если исходный буфер источника является точным кратным размером блока, вам все равно нужен один полный блок заполнения (см. дополнение PKCS 5 для получения дополнительной информации).
- Тот же IV используется для шифрования и дешифрования.
- Наконец, нечетным, как может показаться,
AES_cbc_encrypt() используется как для шифрования, так и для дешифрования (см. последний параметр в вызове).
Исходный код
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <openssl/aes.h>
#include <openssl/rand.h>
// a simple hex-print routine. could be modified to print 16 bytes-per-line
static void hex_print(const void* pv, size_t len)
{
const unsigned char * p = (const unsigned char*)pv;
if (NULL == pv)
printf("NULL");
else
{
size_t i = 0;
for (; i<len;++i)
printf("%02X ", *p++);
}
printf("\n");
}
// main entrypoint
int main(int argc, char **argv)
{
int keylength;
printf("Give a key length [only 128 or 192 or 256!]:\n");
scanf("%d", &keylength);
/* generate a key with a given length */
unsigned char aes_key[keylength/8];
memset(aes_key, 0, keylength/8);
if (!RAND_bytes(aes_key, keylength/8))
exit(-1);
size_t inputslength = 0;
printf("Give an input length:\n");
scanf("%lu", &inputslength);
/* generate input with a given length */
unsigned char aes_input[inputslength];
memset(aes_input, 'X', inputslength);
/* init vector */
unsigned char iv_enc[AES_BLOCK_SIZE], iv_dec[AES_BLOCK_SIZE];
RAND_bytes(iv_enc, AES_BLOCK_SIZE);
memcpy(iv_dec, iv_enc, AES_BLOCK_SIZE);
// buffers for encryption and decryption
const size_t encslength = ((inputslength + AES_BLOCK_SIZE) / AES_BLOCK_SIZE) * AES_BLOCK_SIZE;
unsigned char enc_out[encslength];
unsigned char dec_out[inputslength];
memset(enc_out, 0, sizeof(enc_out));
memset(dec_out, 0, sizeof(dec_out));
// so i can do with this aes-cbc-128 aes-cbc-192 aes-cbc-256
AES_KEY enc_key, dec_key;
AES_set_encrypt_key(aes_key, keylength, &enc_key);
AES_cbc_encrypt(aes_input, enc_out, inputslength, &enc_key, iv_enc, AES_ENCRYPT);
AES_set_decrypt_key(aes_key, keylength, &dec_key);
AES_cbc_encrypt(enc_out, dec_out, encslength, &dec_key, iv_dec, AES_DECRYPT);
printf("original:\t");
hex_print(aes_input, sizeof(aes_input));
printf("encrypt:\t");
hex_print(enc_out, sizeof(enc_out));
printf("decrypt:\t");
hex_print(dec_out, sizeof(dec_out));
return 0;
}
Тестовый выход
Give a key length [only 128 or 192 or 256!]:
128
Give an input length:
10
original: 58 58 58 58 58 58 58 58 58 58
encrypt: A9 66 C5 24 A4 02 AB 96 08 65 F7 22 A5 FB BE 26
decrypt: 58 58 58 58 58 58 58 58 58 58
Второй тестовый выход
Give a key length [only 128 or 192 or 256!]:
128
Give an input length:
10
original: 58 58 58 58 58 58 58 58 58 58
encrypt: C2 47 6D B1 A1 68 29 53 55 74 C5 CC 3F 27 0A 3F
decrypt: 58 58 58 58 58 58 58 58 58 58
Я искренне надеюсь, что это поможет.
Ответ 2
@WhozCraig: Большое вам спасибо за помощь! Это много объясняло мне! Но это еще одна проблема. Я изменил статические массивы на динамические. Когда я это сделал, произошли некоторые эры. Но они возникают только тогда, когда я даю огромный размер входных данных, посмотрите на вывод valgrind: http://pastie.org/private/bzofrrtgrlzr0doyb3g. Ошибка возникает только при передаче огромного ввода, когда я пропускаю небольшой размер (например, в вашем примере, 10), это нормально. Все остальное работает отлично.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <openssl/aes.h>
#include <openssl/rand.h>
// a simple hex-print routine. could be modified to print 16 bytes-per-line
static void hex_print(const void* pv, size_t len)
{
const unsigned char * p = (const unsigned char*)pv;
if (NULL == pv)
printf("NULL");
else
{
size_t i = 0;
for (; i<len;++i)
printf("%02X ", *p++);
}
printf("\n");
}
// main entrypoint
int main(int argc, char **argv)
{
size_t inputslength = 0;
printf("Give an input length:\n");
scanf("%lu", &inputslength);
int keylength;
printf("Give a key length [only 128 or 192 or 256!]:\n");
scanf("%d", &keylength);
// generate a key with a given length
unsigned char *aes_key = (unsigned char*)malloc(sizeof(unsigned char) * (keylength/8));
memset(aes_key, 0, keylength/8);
RAND_bytes(aes_key, keylength/8);
// generate input with a given length
unsigned char *aes_input = (unsigned char*)malloc(sizeof(unsigned char) * (inputslength));
memset(aes_input, 'X', sizeof(aes_input));
// init vectors
unsigned char *iv_enc = (unsigned char*)malloc(sizeof(unsigned char) * (AES_BLOCK_SIZE));
unsigned char *iv_dec = (unsigned char*)malloc(sizeof(unsigned char) * (AES_BLOCK_SIZE));
// iv_dec == iv_enc
RAND_bytes(iv_enc, AES_BLOCK_SIZE);
memcpy(iv_dec, iv_enc, AES_BLOCK_SIZE);
// buffers for encryption and decryption
const size_t length = (((inputslength + AES_BLOCK_SIZE) / AES_BLOCK_SIZE) * AES_BLOCK_SIZE);
unsigned char *enc_out = (unsigned char*)malloc(sizeof(unsigned char) * (length));
unsigned char *dec_out = (unsigned char*)malloc(sizeof(unsigned char) * (inputslength));
// so i can do with this aes-cbc-128 aes-cbc-192 aes-cbc-256
AES_KEY encKey, decKey;
AES_set_encrypt_key(aes_key, keylength, &encKey);
AES_cbc_encrypt(aes_input, enc_out, inputslength, &encKey, iv_enc, AES_ENCRYPT);
AES_set_decrypt_key(aes_key, keylength, &decKey);
AES_cbc_encrypt(enc_out, dec_out, length, &decKey, iv_dec, AES_DECRYPT);
printf("original:\t");
hex_print(aes_input, sizeof(aes_input));
printf("encrypt:\t");
hex_print(enc_out, sizeof(enc_out));
printf("decrypt:\t");
hex_print(dec_out, sizeof(dec_out));
free(aes_key);
aes_key = NULL;
free(aes_input);
aes_input = NULL;
free(iv_enc);
iv_enc = NULL;
free(iv_dec);
iv_dec = NULL;
free(enc_out);
enc_out = NULL;
free(dec_out);
dec_out = NULL;
return 0;
}
EDIT:
Хорошо, что-то случилось с предыдущим кодом, который я опубликовал, это новый, прекрасно работающий, даже для огромных входов. Приветствую вас за помощь!:)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <openssl/aes.h>
#include <openssl/rand.h>
// a simple hex-print routine. could be modified to print 16 bytes-per-line
static void hex_print(const void* pv, size_t len)
{
const unsigned char * p = (const unsigned char*)pv;
if (NULL == pv)
printf("NULL");
else
{
size_t i = 0;
for (; i<len;++i)
printf("%02X ", *p++);
}
printf("\n");
}
// main entrypoint
int main(int argc, char **argv)
{
int keylength;
printf("Give a key length [only 128 or 192 or 256!]:\n");
scanf("%d", &keylength);
/* generate a key with a given length */
unsigned char *aes_key = (unsigned char*)malloc(sizeof(unsigned char) * (keylength/8));
memset(aes_key, 0, keylength/8);
if (!RAND_bytes(aes_key, keylength/8))
exit(-1);
size_t inputslength = 0;
printf("Give an input length:\n");
scanf("%lu", &inputslength);
/* generate input with a given length */
unsigned char *aes_input = (unsigned char*)malloc(sizeof(unsigned char) *inputslength);
memset(aes_input, 'X', inputslength);
/* init vector */
unsigned char *iv_enc = (unsigned char*)malloc(sizeof(unsigned char) *AES_BLOCK_SIZE), *iv_dec = (unsigned char*)malloc(sizeof(unsigned char) *AES_BLOCK_SIZE);
RAND_bytes(iv_enc, AES_BLOCK_SIZE);
memcpy(iv_dec, iv_enc, AES_BLOCK_SIZE);
// buffers for encryption and decryption
const size_t encslength = ((inputslength + AES_BLOCK_SIZE) / AES_BLOCK_SIZE) * AES_BLOCK_SIZE;
unsigned char *enc_out = (unsigned char*)malloc(sizeof(unsigned char) *encslength);
unsigned char *dec_out = (unsigned char*)malloc(sizeof(unsigned char) *inputslength);
memset(enc_out, 0, sizeof(enc_out));
memset(dec_out, 0, sizeof(dec_out));
// so i can do with this aes-cbc-128 aes-cbc-192 aes-cbc-256
AES_KEY enc_key, dec_key;
AES_set_encrypt_key(aes_key, keylength, &enc_key);
AES_cbc_encrypt(aes_input, enc_out, inputslength, &enc_key, iv_enc, AES_ENCRYPT);
AES_set_decrypt_key(aes_key, keylength, &dec_key);
AES_cbc_encrypt(enc_out, dec_out, encslength, &dec_key, iv_dec, AES_DECRYPT);
printf("original:\t");
hex_print(aes_input, inputslength);
printf("encrypt:\t");
hex_print(enc_out, encslength);
printf("decrypt:\t");
hex_print(dec_out, inputslength);
// free memory here
return 0;
}
