AES 192、AES-256 的分段错误，不适用于 AES-128 位
Segmentation fault for AES 192, AES-256 , not for AES-128 bit
我正在尝试使用具有不同密钥大小的 openssl 的 AES_decrypt 函数来解密密文。我能够成功解密密钥大小 = 128 的消息。
这是我的代码
mydecrypt.c
#include <stdio.h>
#include "AES.h"
#include "string.h"
#include "stdlib.h"
#define NO_OF_DECRYPTION 50
static const unsigned char key[]={
0x8E,0xa1,0xeE,0xce,0x5F,0xEB,0x1E,0x8d,0xa5,0xdA,0x95,0x57,0xD0,0x77,0xee,0xd8,0x49,0xfc,0xBd,0x2d,0x0D,0xF0,0x40,0x35,0xd3,0xd8,0x07,0x8f,0xce,0xFD,0x24,0xaF
};
int main(int argc, char *argv[])
{
unsigned char *text = (unsigned char *)malloc(16*sizeof(char));;
unsigned char out[20];
unsigned char * input = (unsigned char *)malloc(NO_OF_DECRYPTION*16*sizeof(char));
FILE *myfile;
myfile = fopen("encrypted.bin", "r");
fread(input, sizeof(char), NO_OF_DECRYPTION*16, myfile);
AES_KEY wctx;
int aes_counter=0;
private_AES_set_decrypt_key(key, 128, &wctx); // keysize = 192, 256 causes segmentation fault
printf("AES Decryption started\n");
while(aes_counter<NO_OF_DECRYPTION)
{
text = &input[aes_counter*16];
AES_decrypt(text, out, &wctx);
aes_counter++;
}
printf("AES Decryption finished\n");
fclose(myfile);
return 0;
}
我复制了aes_core.c（重命名为AES.c）、aes.h（重命名为AES.h）openssl文件并创建了我自己的共享库到运行 上面的代码。
//AES.h
#include <stdint.h>
#ifndef AES_h__
#define AES_h__
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
struct aes_key_st {
unsigned int rd_key[4 *(10 + 1)];
int rounds;
};
typedef struct aes_key_st AES_KEY;
extern int private_AES_set_decrypt_key(const unsigned char *userKey, const int bits,AES_KEY *key);
extern void AES_decrypt(const unsigned char *in, unsigned char *out,const AES_KEY *key);
#endif // foo_h__
以下是我如何将我的代码成功编译为 运行 keysize=128 位。
gcc -c -Wall -Werror -fPIC -O0 AES.c
gcc -shared -o libAES.so AES.o
var=`pwd`
gcc -std=gnu89 -g -L$var -O0 -Wall -o dec mydecrypt.c -lAES -fPIC
LD_LIBRARY_PATH=$var:$LD_LIBRARY_PATH
export LD_LIBRARY_PATH=$var:$LD_LIBRARY_PATH
#run
./dec
尽管我能够使用 AES_key 和 key_size=128 加密明文和解密密文，但是我遇到了其他密钥大小 192 和 256 的分段错误。.
private_AES_set_decrypt_key(key, 192, &wctx); 未生成分段错误
但是，private_AES_set_decrypt_key(key, 256, &wctx); 正在生成分段错误
对于 key-size=192 和 key-size=256，
AES_decrypt() 正在生成分段错误
密钥大小为 192 和 256 的分段错误的原因是什么？
我哪里出错了？
任何 suggestion/clue 到 运行 使用 key-size=192/256 解密的代码都会有很大帮助。
我在 Debian 8 中使用 gcc-4.9.2。提前致谢。
注意：
用于加密，密钥大小=128
AES_set_encrypt_key((const unsigned char *)key, 128, &enc_key);
不会导致任何分段错误，但是
AES_set_encrypt_key((const unsigned char *)key, 192, &enc_key);
AES_set_encrypt_key((const unsigned char *)key, 256, &enc_key);
两者都会导致段错误。
AES.c 的一部分，其中定义了 private_AES_set_decrypt_key 和 private_AES_set_encrypt_key
/**
* Expand the cipher key into the encryption key schedule.
*/
int private_AES_set_encrypt_key(const unsigned char *userKey, const int bits,
AES_KEY *key)
{
u32 *rk;
int i = 0;
u32 temp;
if (!userKey || !key)
return -1;
if (bits != 128 && bits != 192 && bits != 256)
return -2;
rk = key->rd_key;
if (bits==128)
key->rounds = 10;
else if (bits==192)
key->rounds = 12;
else
key->rounds = 14;
rk[0] = GETU32(userKey );
rk[1] = GETU32(userKey + 4);
rk[2] = GETU32(userKey + 8);
rk[3] = GETU32(userKey + 12);
if (bits == 128) {
while (1) {
temp = rk[3];
rk[4] = rk[0] ^
((u32)Te4[(temp >> 16) & 0xff] << 24) ^
((u32)Te4[(temp >> 8) & 0xff] << 16) ^
((u32)Te4[(temp ) & 0xff] << 8) ^
((u32)Te4[(temp >> 24) ]) ^
rcon[i];
rk[5] = rk[1] ^ rk[4];
rk[6] = rk[2] ^ rk[5];
rk[7] = rk[3] ^ rk[6];
if (++i == 10) {
return 0;
}
rk += 4;
}
}
rk[4] = GETU32(userKey + 16);
rk[5] = GETU32(userKey + 20);
if (bits == 192) {
while (1) {
temp = rk[ 5];
rk[ 6] = rk[ 0] ^
((u32)Te4[(temp >> 16) & 0xff] << 24) ^
((u32)Te4[(temp >> 8) & 0xff] << 16) ^
((u32)Te4[(temp ) & 0xff] << 8) ^
((u32)Te4[(temp >> 24) ]) ^
rcon[i];
rk[ 7] = rk[ 1] ^ rk[ 6];
rk[ 8] = rk[ 2] ^ rk[ 7];
rk[ 9] = rk[ 3] ^ rk[ 8];
if (++i == 8) {
return 0;
}
rk[10] = rk[ 4] ^ rk[ 9];
rk[11] = rk[ 5] ^ rk[10];
rk += 6;
}
}
rk[6] = GETU32(userKey + 24);
rk[7] = GETU32(userKey + 28);
if (bits == 256) {
while (1) {
temp = rk[ 7];
rk[ 8] = rk[ 0] ^
((u32)Te4[(temp >> 16) & 0xff] << 24) ^
((u32)Te4[(temp >> 8) & 0xff] << 16) ^
((u32)Te4[(temp ) & 0xff] << 8) ^
((u32)Te4[(temp >> 24) ]) ^
rcon[i];
rk[ 9] = rk[ 1] ^ rk[ 8];
rk[10] = rk[ 2] ^ rk[ 9];
rk[11] = rk[ 3] ^ rk[10];
if (++i == 7) {
return 0;
}
temp = rk[11];
rk[12] = rk[ 4] ^
((u32)Te4[(temp >> 24) ] << 24) ^
((u32)Te4[(temp >> 16) & 0xff] << 16) ^
((u32)Te4[(temp >> 8) & 0xff] << 8) ^
((u32)Te4[(temp ) & 0xff]);
rk[13] = rk[ 5] ^ rk[12];
rk[14] = rk[ 6] ^ rk[13];
rk[15] = rk[ 7] ^ rk[14];
rk += 8;
}
}
return 0;
}
/**
* Expand the cipher key into the decryption key schedule.
*/
int private_AES_set_decrypt_key(const unsigned char *userKey, const int bits,
AES_KEY *key)
{
u32 *rk;
int i, j, status;
u32 temp;
/* first, start with an encryption schedule */
status = private_AES_set_encrypt_key(userKey, bits, key);
if (status < 0)
return status;
rk = key->rd_key;
/* invert the order of the round keys: */
for (i = 0, j = 4*(key->rounds); i < j; i += 4, j -= 4) {
temp = rk[i ]; rk[i ] = rk[j ]; rk[j ] = temp;
temp = rk[i + 1]; rk[i + 1] = rk[j + 1]; rk[j + 1] = temp;
temp = rk[i + 2]; rk[i + 2] = rk[j + 2]; rk[j + 2] = temp;
temp = rk[i + 3]; rk[i + 3] = rk[j + 3]; rk[j + 3] = temp;
}
/* apply the inverse MixColumn transform to all round keys but the first and the last: */
for (i = 1; i < (key->rounds); i++) {
rk += 4;
for (j = 0; j < 4; j++) {
u32 tp1, tp2, tp4, tp8, tp9, tpb, tpd, tpe, m;
tp1 = rk[j];
m = tp1 & 0x80808080;
tp2 = ((tp1 & 0x7f7f7f7f) << 1) ^
((m - (m >> 7)) & 0x1b1b1b1b);
m = tp2 & 0x80808080;
tp4 = ((tp2 & 0x7f7f7f7f) << 1) ^
((m - (m >> 7)) & 0x1b1b1b1b);
m = tp4 & 0x80808080;
tp8 = ((tp4 & 0x7f7f7f7f) << 1) ^
((m - (m >> 7)) & 0x1b1b1b1b);
tp9 = tp8 ^ tp1;
tpb = tp9 ^ tp2;
tpd = tp9 ^ tp4;
tpe = tp8 ^ tp4 ^ tp2;
#if defined(ROTATE)
rk[j] = tpe ^ ROTATE(tpd,16) ^
ROTATE(tp9,24) ^ ROTATE(tpb,8);
#else
rk[j] = tpe ^ (tpd >> 16) ^ (tpd << 16) ^
(tp9 >> 8) ^ (tp9 << 24) ^
(tpb >> 24) ^ (tpb << 8);
#endif
}
}
return 0;
}
#endif /* AES_ASM */
在使用键大小=192 和 256 调用这两个函数时发生分段。虽然在这两个函数中，它明确指定了关于键大小的轮数（键大小=128，total_round=10,key-size=192, total_round=12,key-size=256, total_round=14), 这两个函数仍然出现分段错误。
不要使用块级加密代码，您需要使用支持输入大于块的级别，因此不需要循环，CBC 等模式和 PKCS#7 等填充
忽略我之前的错误回答尝试。
AES_KEY 的 rd_key 字段是一个包含 44 个元素的 unsigned int 数组。
rounds 字段可以用值 12（对于 192 位密钥）或 14（对于 256 位密钥）进行初始化。
rounds 字段然后用作对进入 rd_key 数组的索引的限制（通过 rk 指针），索引可以超出 rd_key 数组的末尾大批。在 private_AES_set_decrypt_key() 中有这段代码：
/* invert the order of the round keys: */
for (i = 0, j = 4*(key->rounds); i < j; i += 4, j -= 4) {
temp = rk[i ]; rk[i ] = rk[j ]; rk[j ] = temp;
temp = rk[i + 1]; rk[i + 1] = rk[j + 1]; rk[j + 1] = temp;
temp = rk[i + 2]; rk[i + 2] = rk[j + 2]; rk[j + 2] = temp;
temp = rk[i + 3]; rk[i + 3] = rk[j + 3]; rk[j + 3] = temp;
}
当rounds为12时，j将从48开始，所以在上面的前两次循环迭代中使用j变量的所有访问都超出了结束大批。当 256 位密钥使用 14 轮时，情况会更糟。由于其中一些访问是写操作，rounds 字段也会被覆盖，到那时谁知道 rd-key 数组会发生什么，因为 rounds 被用作限制在下面的循环中？
其他循环将 rk 指针移到 rd_key 数组的开头之外，因此很难知道它们是否超出了数组的末尾，但应该能够验证是否使用调试器不会发生这种情况。
也许您需要做的就是将 struct aes_key_st 的定义更改为：
struct aes_key_st {
unsigned int rd_key[4 *(14 + 1)];
int rounds;
};
最多容纳 256 位密钥中的 14 rounds 个。
我正在尝试使用具有不同密钥大小的 openssl 的 AES_decrypt 函数来解密密文。我能够成功解密密钥大小 = 128 的消息。 这是我的代码
mydecrypt.c
#include <stdio.h>
#include "AES.h"
#include "string.h"
#include "stdlib.h"
#define NO_OF_DECRYPTION 50
static const unsigned char key[]={
0x8E,0xa1,0xeE,0xce,0x5F,0xEB,0x1E,0x8d,0xa5,0xdA,0x95,0x57,0xD0,0x77,0xee,0xd8,0x49,0xfc,0xBd,0x2d,0x0D,0xF0,0x40,0x35,0xd3,0xd8,0x07,0x8f,0xce,0xFD,0x24,0xaF
};
int main(int argc, char *argv[])
{
unsigned char *text = (unsigned char *)malloc(16*sizeof(char));;
unsigned char out[20];
unsigned char * input = (unsigned char *)malloc(NO_OF_DECRYPTION*16*sizeof(char));
FILE *myfile;
myfile = fopen("encrypted.bin", "r");
fread(input, sizeof(char), NO_OF_DECRYPTION*16, myfile);
AES_KEY wctx;
int aes_counter=0;
private_AES_set_decrypt_key(key, 128, &wctx); // keysize = 192, 256 causes segmentation fault
printf("AES Decryption started\n");
while(aes_counter<NO_OF_DECRYPTION)
{
text = &input[aes_counter*16];
AES_decrypt(text, out, &wctx);
aes_counter++;
}
printf("AES Decryption finished\n");
fclose(myfile);
return 0;
}
我复制了aes_core.c（重命名为AES.c）、aes.h（重命名为AES.h）openssl文件并创建了我自己的共享库到运行 上面的代码。
//AES.h
#include <stdint.h>
#ifndef AES_h__
#define AES_h__
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
struct aes_key_st {
unsigned int rd_key[4 *(10 + 1)];
int rounds;
};
typedef struct aes_key_st AES_KEY;
extern int private_AES_set_decrypt_key(const unsigned char *userKey, const int bits,AES_KEY *key);
extern void AES_decrypt(const unsigned char *in, unsigned char *out,const AES_KEY *key);
#endif // foo_h__
以下是我如何将我的代码成功编译为 运行 keysize=128 位。
gcc -c -Wall -Werror -fPIC -O0 AES.c
gcc -shared -o libAES.so AES.o
var=`pwd`
gcc -std=gnu89 -g -L$var -O0 -Wall -o dec mydecrypt.c -lAES -fPIC
LD_LIBRARY_PATH=$var:$LD_LIBRARY_PATH
export LD_LIBRARY_PATH=$var:$LD_LIBRARY_PATH
#run
./dec
尽管我能够使用 AES_key 和 key_size=128 加密明文和解密密文，但是我遇到了其他密钥大小 192 和 256 的分段错误。.
private_AES_set_decrypt_key(key, 192, &wctx); 未生成分段错误
但是，private_AES_set_decrypt_key(key, 256, &wctx); 正在生成分段错误
对于 key-size=192 和 key-size=256，
AES_decrypt() 正在生成分段错误
密钥大小为 192 和 256 的分段错误的原因是什么？
我哪里出错了？
任何 suggestion/clue 到 运行 使用 key-size=192/256 解密的代码都会有很大帮助。
我在 Debian 8 中使用 gcc-4.9.2。提前致谢。
注意： 用于加密，密钥大小=128
AES_set_encrypt_key((const unsigned char *)key, 128, &enc_key);
不会导致任何分段错误，但是
AES_set_encrypt_key((const unsigned char *)key, 192, &enc_key);
AES_set_encrypt_key((const unsigned char *)key, 256, &enc_key);
两者都会导致段错误。
AES.c 的一部分，其中定义了 private_AES_set_decrypt_key 和 private_AES_set_encrypt_key
/**
* Expand the cipher key into the encryption key schedule.
*/
int private_AES_set_encrypt_key(const unsigned char *userKey, const int bits,
AES_KEY *key)
{
u32 *rk;
int i = 0;
u32 temp;
if (!userKey || !key)
return -1;
if (bits != 128 && bits != 192 && bits != 256)
return -2;
rk = key->rd_key;
if (bits==128)
key->rounds = 10;
else if (bits==192)
key->rounds = 12;
else
key->rounds = 14;
rk[0] = GETU32(userKey );
rk[1] = GETU32(userKey + 4);
rk[2] = GETU32(userKey + 8);
rk[3] = GETU32(userKey + 12);
if (bits == 128) {
while (1) {
temp = rk[3];
rk[4] = rk[0] ^
((u32)Te4[(temp >> 16) & 0xff] << 24) ^
((u32)Te4[(temp >> 8) & 0xff] << 16) ^
((u32)Te4[(temp ) & 0xff] << 8) ^
((u32)Te4[(temp >> 24) ]) ^
rcon[i];
rk[5] = rk[1] ^ rk[4];
rk[6] = rk[2] ^ rk[5];
rk[7] = rk[3] ^ rk[6];
if (++i == 10) {
return 0;
}
rk += 4;
}
}
rk[4] = GETU32(userKey + 16);
rk[5] = GETU32(userKey + 20);
if (bits == 192) {
while (1) {
temp = rk[ 5];
rk[ 6] = rk[ 0] ^
((u32)Te4[(temp >> 16) & 0xff] << 24) ^
((u32)Te4[(temp >> 8) & 0xff] << 16) ^
((u32)Te4[(temp ) & 0xff] << 8) ^
((u32)Te4[(temp >> 24) ]) ^
rcon[i];
rk[ 7] = rk[ 1] ^ rk[ 6];
rk[ 8] = rk[ 2] ^ rk[ 7];
rk[ 9] = rk[ 3] ^ rk[ 8];
if (++i == 8) {
return 0;
}
rk[10] = rk[ 4] ^ rk[ 9];
rk[11] = rk[ 5] ^ rk[10];
rk += 6;
}
}
rk[6] = GETU32(userKey + 24);
rk[7] = GETU32(userKey + 28);
if (bits == 256) {
while (1) {
temp = rk[ 7];
rk[ 8] = rk[ 0] ^
((u32)Te4[(temp >> 16) & 0xff] << 24) ^
((u32)Te4[(temp >> 8) & 0xff] << 16) ^
((u32)Te4[(temp ) & 0xff] << 8) ^
((u32)Te4[(temp >> 24) ]) ^
rcon[i];
rk[ 9] = rk[ 1] ^ rk[ 8];
rk[10] = rk[ 2] ^ rk[ 9];
rk[11] = rk[ 3] ^ rk[10];
if (++i == 7) {
return 0;
}
temp = rk[11];
rk[12] = rk[ 4] ^
((u32)Te4[(temp >> 24) ] << 24) ^
((u32)Te4[(temp >> 16) & 0xff] << 16) ^
((u32)Te4[(temp >> 8) & 0xff] << 8) ^
((u32)Te4[(temp ) & 0xff]);
rk[13] = rk[ 5] ^ rk[12];
rk[14] = rk[ 6] ^ rk[13];
rk[15] = rk[ 7] ^ rk[14];
rk += 8;
}
}
return 0;
}
/**
* Expand the cipher key into the decryption key schedule.
*/
int private_AES_set_decrypt_key(const unsigned char *userKey, const int bits,
AES_KEY *key)
{
u32 *rk;
int i, j, status;
u32 temp;
/* first, start with an encryption schedule */
status = private_AES_set_encrypt_key(userKey, bits, key);
if (status < 0)
return status;
rk = key->rd_key;
/* invert the order of the round keys: */
for (i = 0, j = 4*(key->rounds); i < j; i += 4, j -= 4) {
temp = rk[i ]; rk[i ] = rk[j ]; rk[j ] = temp;
temp = rk[i + 1]; rk[i + 1] = rk[j + 1]; rk[j + 1] = temp;
temp = rk[i + 2]; rk[i + 2] = rk[j + 2]; rk[j + 2] = temp;
temp = rk[i + 3]; rk[i + 3] = rk[j + 3]; rk[j + 3] = temp;
}
/* apply the inverse MixColumn transform to all round keys but the first and the last: */
for (i = 1; i < (key->rounds); i++) {
rk += 4;
for (j = 0; j < 4; j++) {
u32 tp1, tp2, tp4, tp8, tp9, tpb, tpd, tpe, m;
tp1 = rk[j];
m = tp1 & 0x80808080;
tp2 = ((tp1 & 0x7f7f7f7f) << 1) ^
((m - (m >> 7)) & 0x1b1b1b1b);
m = tp2 & 0x80808080;
tp4 = ((tp2 & 0x7f7f7f7f) << 1) ^
((m - (m >> 7)) & 0x1b1b1b1b);
m = tp4 & 0x80808080;
tp8 = ((tp4 & 0x7f7f7f7f) << 1) ^
((m - (m >> 7)) & 0x1b1b1b1b);
tp9 = tp8 ^ tp1;
tpb = tp9 ^ tp2;
tpd = tp9 ^ tp4;
tpe = tp8 ^ tp4 ^ tp2;
#if defined(ROTATE)
rk[j] = tpe ^ ROTATE(tpd,16) ^
ROTATE(tp9,24) ^ ROTATE(tpb,8);
#else
rk[j] = tpe ^ (tpd >> 16) ^ (tpd << 16) ^
(tp9 >> 8) ^ (tp9 << 24) ^
(tpb >> 24) ^ (tpb << 8);
#endif
}
}
return 0;
}
#endif /* AES_ASM */
在使用键大小=192 和 256 调用这两个函数时发生分段。虽然在这两个函数中，它明确指定了关于键大小的轮数（键大小=128，total_round=10,key-size=192, total_round=12,key-size=256, total_round=14), 这两个函数仍然出现分段错误。
不要使用块级加密代码，您需要使用支持输入大于块的级别，因此不需要循环，CBC 等模式和 PKCS#7 等填充
忽略我之前的错误回答尝试。
AES_KEY 的 rd_key 字段是一个包含 44 个元素的 unsigned int 数组。
rounds 字段可以用值 12（对于 192 位密钥）或 14（对于 256 位密钥）进行初始化。
rounds 字段然后用作对进入 rd_key 数组的索引的限制（通过 rk 指针），索引可以超出 rd_key 数组的末尾大批。在 private_AES_set_decrypt_key() 中有这段代码：
/* invert the order of the round keys: */
for (i = 0, j = 4*(key->rounds); i < j; i += 4, j -= 4) {
temp = rk[i ]; rk[i ] = rk[j ]; rk[j ] = temp;
temp = rk[i + 1]; rk[i + 1] = rk[j + 1]; rk[j + 1] = temp;
temp = rk[i + 2]; rk[i + 2] = rk[j + 2]; rk[j + 2] = temp;
temp = rk[i + 3]; rk[i + 3] = rk[j + 3]; rk[j + 3] = temp;
}
当rounds为12时，j将从48开始，所以在上面的前两次循环迭代中使用j变量的所有访问都超出了结束大批。当 256 位密钥使用 14 轮时，情况会更糟。由于其中一些访问是写操作，rounds 字段也会被覆盖，到那时谁知道 rd-key 数组会发生什么，因为 rounds 被用作限制在下面的循环中？
其他循环将 rk 指针移到 rd_key 数组的开头之外，因此很难知道它们是否超出了数组的末尾，但应该能够验证是否使用调试器不会发生这种情况。
也许您需要做的就是将 struct aes_key_st 的定义更改为：
struct aes_key_st {
unsigned int rd_key[4 *(14 + 1)];
int rounds;
};
最多容纳 256 位密钥中的 14 rounds 个。