这篇文章主要介绍“c语言怎么实现DES加密解密”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“c语言怎么实现DES加密解密”文章能帮助大家解决问题。
c语言实现DES加密解密
#include "des.h"
//移位表
static Table_size const shiftTable[NumberOfKeys] = {1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};
//E扩展表
static Table_size const eTable[des_key_pc2_standard]={
32, 1, 2, 3, 4, 5,
4, 5, 6, 7, 8, 9,
8, 9, 10, 11, 12, 13,
12, 13, 14, 15, 16, 17,
16, 17, 18, 19, 20, 21,
20, 21, 22, 23, 24, 25,
24, 25, 26, 27, 28, 29,
28, 29, 30, 31, 32, 1
};
//P置换表
static Table_size const pTable[des_data_rl]={
16, 7,20,21,29,12,28,17,
1,15,23,26, 5,18,31,10,
2, 8,24,14,32,27, 3, 9,
19,13,30, 6,22,11, 4,25
};
//数据初始置换表
static Table_size const ip0Table[des_standard] = {
58, 50, 42, 34, 26, 18, 10, 2,
60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6,
64, 56, 48, 40, 32, 24, 16, 8,
57, 49, 41, 33, 25, 17, 9, 1,
59, 51, 43, 35, 27, 19, 11, 3,
61, 53, 45, 37, 29, 21, 13, 5,
63, 55, 47, 39, 31, 23, 15, 7
};
//ip1表
static Table_size const ip1Table[des_standard]={
40, 8,48,16,56,24,64,32,
39, 7,47,15,55,23,63,31,
38, 6,46,14,54,22,62,30,
37, 5,45,13,53,21,61,29,
36, 4,44,12,52,20,60,28,
35, 3,43,11,51,19,59,27,
34, 2,42,10,50,18,58,26,
33, 1,41, 9,49,17,57,25
};
//子密钥pc1置换表
static Table_size const desSubkeyPc1[des_key_pc1_standard] = {
57, 49, 41, 33, 25, 17, 9,
1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27,
19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 23, 15,
7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29,
21, 13, 5, 28, 20, 12, 4
};
//子密钥pc2置换表
static Table_size const desSubkeyPc2[des_key_pc2_standard]={
14, 17, 11, 24, 1, 5, 3, 28,
15, 6, 21, 10, 23, 19, 12, 4,
26, 8, 16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55, 30, 40,
51, 34, 33, 48, 44, 49, 39, 56,
34, 53, 46, 42, 50, 36, 29, 32
};
//S盒表
static Table_size const sBoxTable[8][4][16]={
//S1
14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13,
//S2
15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9,
//S3
10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12,
//S4
7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14,
//S5
2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3,
//S6
12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
10, 15, 4, 2, 7, 12, 0, 5, 6, 1, 13, 14, 0, 11, 3, 8,
9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13,
//S7
4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
13, 0, 11, 7, 4, 0, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12,
//S8
13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11
};
/*
* 函数功能:生成16个6字节子密钥
* 参数:<key>传入8字节密钥,<key_lenght>密钥长度必须是8字节
* 返回值:返回16*(48/8)字节大小的16个子密钥
* 注释:返回值要释放
*/
subkey_size __desSubKeyGeneration(subkey_size key, data_lenght_size key_lenght)
{
//如果传入空或长度不为8字节则返回空
if(key==NULL || key_lenght!=8)
return NULL;
//申请堆内存
subkey_size subkey16 = (subkey_size)malloc(NumberOfKeys * (des_key_pc2_standard / systemBit));
//清空初始化,按照申请内存大小来清空这块堆内存
memset(subkey16, 0, NumberOfKeys * (des_key_pc2_standard / systemBit));
//创建布尔型的数组,让移位代码实现更简单
int count = 0;
bool tmp = 0;
bool bit_table_pc1[des_key_pc1_standard]={0}; //pc1的56位数据
bool bit_table[des_standard]={0}; //64位数据
//将数据赋值到布尔型数组里面
for(int i=0; i<des_standard; i++)
bit_table[i] = BIT_JUDGE(*(key + i / systemBit), (i % systemBit));
//进行PC1转换
for(int i=0; i<des_key_pc1_standard; i++)
bit_table_pc1[i] = bit_table[desSubkeyPc1[i]-1];
//进行十六次密钥生成
for(int num=0; num<NumberOfKeys; num++)
{
//保存移位次数
count = shiftTable[num];
//进行移位
while(count--)
{
//前二十八位移位
tmp = bit_table_pc1[0];
for(int i=0; i<28; i++)
bit_table_pc1[i]=bit_table_pc1[i+1];
bit_table_pc1[27]=tmp;
//后二十八位移位
tmp = bit_table_pc1[28];
for(int i=28; i<56; i++)
bit_table_pc1[i]=bit_table_pc1[i+1];
bit_table_pc1[55]=tmp;
}
//进行判断写入新的数据
for(int i=0; i<des_key_pc2_standard; i++)
{
if(bit_table_pc1[desSubkeyPc2[i]-1])
SET_BIT_NUMBER(*(subkey16 + (num * (des_key_pc2_standard / systemBit)) + (i / systemBit)), (i % systemBit));
else RESET_BIT_NUMBER(*(subkey16 + (num * (des_key_pc2_standard / systemBit)) + (i / systemBit)), (i % systemBit));
}
}
//返回子密钥
return subkey16;
}
/*
* 函数功能:进行数据加密
* 参数:<data>传入8整数倍字节数据,<data_lenght>数据长度,<key>16*(48/8)字节大小的16个子密钥,<key_lenght>必须是6*16长度
* 返回值:返回加密后的数据
* 注释:返回值要释放
*/
data_size __desDataEncryption(data_size data, data_lenght_size data_lenght, subkey_size key, data_lenght_size key_lenght)
{
//如果传入空或长度不为8字节则返回空
if(key==NULL || key_lenght!=(NumberOfKeys*(des_key_pc2_standard/systemBit)) || data==NULL || data_lenght!=8)
return NULL;
//申请堆内存
data_size Data16 = (data_size)malloc(des_standard/8);
//清空初始化,按照申请内存大小来清空这块堆内存
memset(Data16, 0, (des_standard/8));
//创建一个布尔型的数组,将移位操作变得简单
bool bit_table[des_standard]={0}; //64位数据
bool data64_table[des_standard]={0}; //64位数据
bool extend48_table[des_key_pc2_standard]={0}; //pc2表的48位数据
bool dataL32_table[des_data_rl]={0}; //64位数据的左32
bool dataR32_table[des_data_rl]={0}; //64位数据的右32
bool tmpL32_table[des_data_rl]={0}; //临时64位数据的左32
bool tmpR32_table[des_data_rl]={0}; //临时64位数据的右32
//将数据赋值到布尔型数组里面
for(int i=0; i<des_standard; i++)
bit_table[i] = BIT_JUDGE(*(data + (i / systemBit)), (i % systemBit));
//进行初始置换
for(int i=0; i<des_standard; i++)
data64_table[i] = bit_table[ip0Table[i]-1];
//将64位一分为二
for(int i=0; i<des_data_rl; i++)
dataL32_table[i] = data64_table[i];
for(int i=0; i<des_data_rl; i++)
dataR32_table[i] = data64_table[i+32];
// 列 行
int row=0, col=0;
//进行十六次轮函数
for(int num=0; num<NumberOfKeys; num++)
{
//将R数组赋值给L的临时数组
for(int i=0; i<des_data_rl; i++)
tmpL32_table[i] = dataR32_table[i];
//将R数组进行E扩展
for(int i=0; i<des_key_pc2_standard; i++)
extend48_table[i] = dataR32_table[(eTable[i]-1)];
//将E扩展后48位和子密钥进行异或
for(int i=0; i<des_key_pc2_standard; i++)
extend48_table[i] = extend48_table[i] ^ (BIT_JUDGE(*(key + (num * (des_key_pc2_standard / systemBit)) + i / systemBit), (i % systemBit)));
//将48位转换成32位
for(int j=0; j<des_key_pc2_standard; j+=6)
{
//计算出行列
row = extend48_table[j+0]*2 + extend48_table[j+5]*1;
col = extend48_table[j+1]*8 + extend48_table[j+2]*4 + extend48_table[j+3]*2 + extend48_table[j+4]*1;
//进行查表,并将10进制转换为四位二进制
for(int i=0; i<4; i++)
dataR32_table[((j/6)*4)+i] = BIT_JUDGE(sBoxTable[j/6][row][col], i);
}
//将R进行转换并存入R临时数组
for(int i=0; i<des_data_rl; i++)
tmpR32_table[i] = dataR32_table[pTable[i]-1];
//在用临时数组进行异或
for(int i=0; i<des_data_rl; i++)
{
dataR32_table[i] = (dataL32_table[i] ^ tmpR32_table[i]);
}
//最后将刚才的L临时数组赋值
for(int i=0; i<des_data_rl; i++)
dataL32_table[i] = tmpL32_table[i];
}
//将两个32位进行拼接
for(int i=0; i<des_data_rl; i++)
data64_table[i] = dataL32_table[i];
for(int i=des_data_rl; i<des_standard; i++)
data64_table[i] = dataR32_table[i-32];
//进行判断写入新的数据
for(int i=0; i<des_standard; i++)
{
if(data64_table[ip1Table[i]-1])
SET_BIT_NUMBER(*(Data16 + (i / systemBit)), (i % systemBit));
else RESET_BIT_NUMBER(*(Data16 + (i / systemBit)), (i % systemBit));
}
//返回数据
return Data16;
}
/*
* 函数功能:进行数据解密
* 参数:<data>传入加密后数据,<data_lenght>加密后数据长度,<key>16*(48/8)字节大小的16个子密钥,<key_lenght>必须是6*16长度
* 返回值:返回解密后的数据
* 注释:返回值要释放
*/
data_size __desDataDecrypt(data_size data, data_lenght_size data_lenght, subkey_size key, data_lenght_size key_lenght)
{
//如果传入空或长度不为8字节则返回空
if(key==NULL || key_lenght!=(NumberOfKeys*(des_key_pc2_standard/systemBit)) || data==NULL || data_lenght!=8)
return NULL;
//申请堆内存
data_size Data16 = (data_size)malloc(des_standard/8);
//清空初始化,按照申请内存大小来清空这块堆内存
memset(Data16, 0, (des_standard/8));
//创建一堆布尔型的数组,将移位操作变得简单
bool bit_table[des_standard]={0}; //64位数据
bool data64_table[des_standard]={0}; //64位数据
bool extend48_table[des_key_pc2_standard]={0}; //pc2表48位数据
bool dataL32_table[des_data_rl]={0}; //64位数据的左32位
bool dataR32_table[des_data_rl]={0}; //64位数据的右32位
bool tmpL32_table[des_data_rl]={0}; //临时64位数据的左32位
bool tmpR32_table[des_data_rl]={0}; //临时64位数据的右32位
//将数据赋值到布尔型数组里面
for(int i=0; i<des_standard; i++)
bit_table[i] = BIT_JUDGE(*(data + (i / systemBit)), (i % systemBit));
//进行初始置换
for(int i=0; i<des_standard; i++)
data64_table[i] = bit_table[ip0Table[i]-1];
//将64位一分为二
for(int i=0; i<des_data_rl; i++)
dataR32_table[i] = data64_table[i];
for(int i=0; i<des_data_rl; i++)
dataL32_table[i] = data64_table[i+32];
// 列 行
int row=0, col=0;
//进行十六次轮函数(反着来)
for(int num=(NumberOfKeys-1); num>=0; num--)
{
//将R数组赋值给L的临时数组
for(int i=0; i<des_data_rl; i++)
tmpL32_table[i] = dataR32_table[i];
//将R数组进行E扩展
for(int i=0; i<des_key_pc2_standard; i++)
extend48_table[i] = dataR32_table[(eTable[i]-1)];
//将E扩展后48位和子密钥进行异或
for(int i=0; i<des_key_pc2_standard; i++)
extend48_table[i] = extend48_table[i] ^ (BIT_JUDGE(*(key + (num * (des_key_pc2_standard / systemBit)) + i / systemBit), (i % systemBit)));
//将48位转换成32位
for(int j=0; j<des_key_pc2_standard; j+=6)
{
//计算出行列
row = extend48_table[j+0]*2 + extend48_table[j+5]*1;
col = extend48_table[j+1]*8 + extend48_table[j+2]*4 + extend48_table[j+3]*2 + extend48_table[j+4]*1;
//进行查表,并将10进制转换为四位二进制
for(int i=0; i<4; i++)
dataR32_table[((j/6)*4)+i] = BIT_JUDGE(sBoxTable[j/6][row][col], i);
}
//将R进行转换并存入R临时数组
for(int i=0; i<des_data_rl; i++)
tmpR32_table[i] = dataR32_table[pTable[i]-1];
//在用临时数组进行异或
for(int i=0; i<des_data_rl; i++)
{
dataR32_table[i] = (dataL32_table[i] ^ tmpR32_table[i]);
}
//最后将刚才的L临时数组赋值
for(int i=0; i<des_data_rl; i++)
dataL32_table[i] = tmpL32_table[i];
}
//将两个32位进行拼接
for(int i=0; i<des_data_rl; i++)
data64_table[i] = dataR32_table[i];
for(int i=des_data_rl; i<des_standard; i++)
data64_table[i] = dataL32_table[i-32];
//进行判断写入新的数据
for(int i=0; i<des_standard; i++)
{
if(data64_table[ip1Table[i]-1])
SET_BIT_NUMBER(*(Data16 + (i / systemBit)), (i % systemBit));
else RESET_BIT_NUMBER(*(Data16 + (i / systemBit)), (i % systemBit));
}
//返回数据
return Data16;
}
/*
* 函数功能:将数据进行DES加密
* 参数:<data>要加密的数据,<data_lenght>要加密的数据长度,<key>进行加密的密钥,<key_lenght>密钥的长度(8字节),<fillingMode>数据补位的模式选择
* 返回值:返回一个结构体,结构体内有加密后数据和加密后数据长度
*/
p_desRetStruct desEncryption(data_size data, data_lenght_size data_lenght, subkey_size key, data_lenght_size key_lenght, enumFillingMode fillingMode)
{
if(key_lenght != 8 || (fillingMode != NOPADDING && fillingMode != PKCS5PADDING))
{
return NULL;
}
//申请堆内存
p_desRetStruct retData = (p_desRetStruct)malloc(sizeof(desRetStruct));
//清空这块内存
memset(retData, 0, sizeof(desRetStruct));
//计算出长度
data_lenght_size mallocLenght = ((data_lenght%8==0)?(data_lenght):(((data_lenght/8)*8)+8));
//申请堆内存
retData->data = (data_size)malloc(mallocLenght);
//长度进行赋值
retData->dataLenght = mallocLenght;
//清空这块内存
memset(retData->data, 0, mallocLenght);
//进行赋值
memcpy(retData->data, data, data_lenght);
//如果是长度是8的整数倍
if(fillingMode == PKCS5PADDING && data_lenght % 8 != 0)
{
for(int i=0;i<8-(data_lenght%8);i++)
{
unsigned char num = (8 - (data_lenght % 8));
//进行拷贝
memcpy(retData->data + data_lenght + i, &num, 1);
}
}
//获取16个子密钥
subkey_size subkey16 = __desSubKeyGeneration(key, key_lenght);
//进行循环每8字节进行加密
for(int i=0; i<mallocLenght; i+=8)
{
//将8字节进行加密
data_size mData = __desDataEncryption(retData->data + i, 8, subkey16, 96);
//将加密后字节拷贝到返回值上
memcpy(retData->data + i, mData, 8);
//释放
free(mData);
}
//释放16个子密钥
free(subkey16);
//返回加密后的数据
return retData;
}
/*
* 函数功能:将DES加密数据进行解密
* 参数:<data>要解密的数据,<data_lenght>要解密的数据长度(8的整数倍字节),<key>进行解密的密钥,<key_lenght>密钥的长度(8字节),<fillingMode>数据补位的模式选择
* 返回值:返回一个结构体,结构体内有解密后数据和解密后数据长度
*/
p_desRetStruct desDecrypt(data_size data, data_lenght_size data_lenght, data_size key, data_lenght_size key_lenght, enumFillingMode fillingMode)
{
if(key_lenght != 8 || (fillingMode != NOPADDING && fillingMode != PKCS5PADDING) || data_lenght%8 != 0 || data_lenght == 0)
{
return NULL;
}
//申请堆内存
p_desRetStruct retData = (p_desRetStruct)malloc(sizeof(desRetStruct));
//清空这块内存
memset(retData, 0, sizeof(desRetStruct));
//申请堆内存
retData->data = (data_size)malloc(data_lenght);
//长度进行赋值
retData->dataLenght = data_lenght;
//清空这块内存
memset(retData->data, 0, data_lenght);
//获取16个子密钥
subkey_size subkey16 = __desSubKeyGeneration(key, key_lenght);
//进行循环每8字节进行解密
for(int i=0; i<data_lenght; i+=8)
{
//将8字节进行解密
data_size mData = __desDataDecrypt(data + i, 8, subkey16, 96);
//将解密后字节拷贝到返回值上
memcpy(retData->data + i, mData, 8);
//释放
free(mData);
}
//按照8-(n%8)补位方式解密
if(fillingMode == PKCS5PADDING)
{
//如果最后一位是0x01~0x07
if(0x01 <= *(retData->data + (data_lenght - 1)) && *(retData->data + (data_lenght - 1)) <= 0x07)
{
//进行8-模次循环
for(int count=1; count<=*(retData->data + (data_lenght - 1)); count++)
{
//判断是否和最后一字节相等
if(*(retData->data + (data_lenght - 1)) == *(retData->data + (data_lenght - count)))
{
retData->dataLenght--;
}
else
{
//如果有一次不相等就说明该数据没有补位
retData->dataLenght = data_lenght;
//退出循环
break;
}
}
}
}
//按照\0补位方式解密
else if(fillingMode == NOPADDING)
{
//从尾部开始进行8次判断
for(int count=1; count<=8; count++)
{
//如果这一字节等于0就位去掉
if(0x00 == *(retData->data + (data_lenght - count)))
{
//将长度进行减1
retData->dataLenght--;
}
else
{
//遇到正常数据进行退出循环
break;
}
}
}
//释放16个子密钥
free(subkey16);
//返回加密后的数据
return retData;
}
/*
* 函数功能:将数据进行3DES加密
* 参数:<data>要加密的数据,<data_lenght>要加密的数据长度,<key>进行加密的密钥,<key_lenght>密钥的长度(24字节),<fillingMode>数据补位的模式选择
* 返回值:返回一个结构体,结构体内有加密后数据和加密后数据长度
*/
p_desRetStruct _3desEncryption(data_size data, data_lenght_size data_lenght, subkey_size key, data_lenght_size key_lenght, enumFillingMode fillingMode)
{
if(key_lenght != 24 || (fillingMode != NOPADDING && fillingMode != PKCS5PADDING))
{
return NULL;
}
//申请堆内存
p_desRetStruct retData = (p_desRetStruct)malloc(sizeof(desRetStruct));
//清空这块内存
memset(retData, 0, sizeof(desRetStruct));
//计算出长度
data_lenght_size mallocLenght = ((data_lenght%8==0)?(data_lenght):(((data_lenght/8)*8)+8));
//申请堆内存
retData->data = (data_size)malloc(mallocLenght);
//长度进行赋值
retData->dataLenght = mallocLenght;
//清空这块内存
memset(retData->data, 0, mallocLenght);
//进行赋值
memcpy(retData->data, data, data_lenght);
//如果是长度是8的整数倍
if(fillingMode == PKCS5PADDING && data_lenght % 8 != 0)
{
for(int i=0;i<8-(data_lenght%8);i++)
{
unsigned char num = (8 - (data_lenght % 8));
//进行拷贝
memcpy(retData->data + data_lenght + i, &num, 1);
}
}
//获取16个子密钥
subkey_size subkey1 = __desSubKeyGeneration(key, 8);
//获取16个子密钥
subkey_size subkey2 = __desSubKeyGeneration(key+(key_lenght/3), 8);
//获取16个子密钥
subkey_size subkey3 = __desSubKeyGeneration(key+((key_lenght/3)*2), 8);
//进行循环每8字节进行加密
for(int i=0; i<mallocLenght; i+=8)
{
//将8字节进行加密
data_size mData1 = __desDataEncryption(retData->data + i, 8, subkey1, 96);
data_size mData2 = __desDataDecrypt(mData1, 8, subkey2, 96);
data_size mData3 = __desDataEncryption(mData2, 8, subkey3, 96);
//将加密后字节拷贝到返回值上
memcpy(retData->data + i, mData3, 8);
//释放
free(mData1);
free(mData2);
free(mData3);
}
//释放子密钥
free(subkey1);
free(subkey2);
free(subkey3);
//返回加密后的数据
return retData;
}
/*
* 函数功能:将3DES加密数据进行解密
* 参数:<data>要解密的数据,<data_lenght>要解密的数据长度(8的整数倍字节),<key>进行解密的密钥,<key_lenght>密钥的长度(24字节),<fillingMode>数据补位的模式选择
* 返回值:返回一个结构体,结构体内有解密后数据和解密后数据长度
*/
p_desRetStruct _3desDecrypt(data_size data, data_lenght_size data_lenght, data_size key, data_lenght_size key_lenght, enumFillingMode fillingMode)
{
if(key_lenght != 24 || (fillingMode != NOPADDING && fillingMode != PKCS5PADDING) || data_lenght%8 != 0 || data_lenght == 0)
{
return NULL;
}
//申请堆内存
p_desRetStruct retData = (p_desRetStruct)malloc(sizeof(desRetStruct));
//清空这块内存
memset(retData, 0, sizeof(desRetStruct));
//申请堆内存
retData->data = (data_size)malloc(data_lenght);
//长度进行赋值
retData->dataLenght = data_lenght;
//清空这块内存
memset(retData->data, 0, data_lenght);
//获取16个子密钥
subkey_size subkey1 = __desSubKeyGeneration(key, 8);
//获取16个子密钥
subkey_size subkey2 = __desSubKeyGeneration(key+(key_lenght/3), 8);
//获取16个子密钥
subkey_size subkey3 = __desSubKeyGeneration(key+((key_lenght/3)*2), 8);
//进行循环每8字节进行解密
for(int i=0; i<data_lenght; i+=8)
{
//将8字节进行加密
data_size mData1 = __desDataDecrypt(data + i, 8, subkey3, 96);
data_size mData2 = __desDataEncryption(mData1, 8, subkey2, 96);
data_size mData3 = __desDataDecrypt(mData2, 8, subkey1, 96);
//将解密后字节拷贝到返回值上
memcpy(retData->data + i, mData3, 8);
//释放
free(mData1);
free(mData2);
free(mData3);
}
//按照8-(n%8)补位方式解密
if(fillingMode == PKCS5PADDING)
{
//如果最后一位是0x01~0x07
if(0x01 <= *(retData->data + (data_lenght - 1)) && *(retData->data + (data_lenght - 1)) <= 0x07)
{
//进行(8-模)次循环
for(int count=1; count<=*(retData->data + (data_lenght - 1)); count++)
{
//判断是否和最后一字节相等
if(*(retData->data + (data_lenght - 1)) == *(retData->data + (data_lenght - count)))
{
retData->dataLenght--;
}
else
{
//如果有一次不相等就说明该数据没有补位
retData->dataLenght = data_lenght;
//退出循环
break;
}
}
}
}
//按照\0补位方式解密
else if(fillingMode == NOPADDING)
{
//从尾部开始进行8次判断
for(int count=1; count<=8; count++)
{
//如果这一字节等于0就位去掉
if(0x00 == *(retData->data + (data_lenght - count)))
{
//将长度进行减1
retData->dataLenght--;
}
else
{
//遇到正常数据进行退出循环
break;
}
}
}
//释放16个子密钥
free(subkey1);
free(subkey2);
free(subkey3);
//返回加密后的数据
return retData;
}
/* DES全称->数据加密标准->它出自IBM的研究工作(本描述大致步骤细节需要看代码)
* 数据=由8的整数倍构成(单位字节)(不足8字节可以补位) 密钥=固定由64位(即8字节)组成(其中8位为校验位不影响结果)
* (每个字节(0~255)任意选取) (每个字节(0~255)任意选取)
* ↓ ↓
* 进行ip置换将64位数据每个位进行移位 进行PC1转换(转换前64)(转换后将8位校验位舍弃)(并且进行移位)
* ↓ →→→→→→→→→→→→→→→→→→→→→↓→→→→→→→→→→→→→→→→→→→→→↓
* 将64位数据一分为二变成左右两个部分(分别32位) ↓ 一分为二(分别28位)分别移位(每轮移位次数不同) ↓
* ↓ ↓ ↓ ↓ ↓
* 左32位 右32位 ↓ 进行PC2转换(转换前56)(转换后48)(并且进行移位)↓
* ↓ ↓ ↓←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←↓
* (左32位 异或 f(右32位, key))←←←←←←←←←←←进行16次循环(每一次产生48位key与右32位进行轮函数)
* (左32位和f(右32位, key))进行异或运算) (解密时将16个48位key反着进行轮函数)
* 运算结果成为新的右32位并将右32位赋值给左32位
* 产生新的左32位和右32位 f(右32位, key)f轮函数步骤
* ↓ ↓ 右32位进行E扩展为48位
*新左32位=旧左32位^f(旧右32位, key)) 新右32位=旧左32位 扩展后48位和48位key进行异或
* (进行16次循环结束后将两个32进行合并并且进行终止置换) 将异或后48位进入S盒压缩为32结束
* (终止置换完,成为des加密数据)
* 解密的两个条件 = (解密时将16个48位key反着进行轮函数) + (图上的左右32位反着运算)
* 不足8整数倍字节时可以全部补位0,也可以补位(8-(数据长度(单位字节)%8))
*/
/* 3DES
* E表示加密 D表示解密 K1表示密钥1 K2表示密钥2 K3表示密钥3 P表示明文 C表示密文 EK1表示使用K1密钥进行加密 DK1表示使用K1密钥进行解密
* 加密:C = EK3( DK2( EK1(P)) ),即对明文数据进行,加密 -> 解密 -> 加密的过程,最后得到密文数据;
* 解密:P = DK1( EK2( DK3(C)) ),即对密文数据进行,解密 -> 加密 -> 解密的过程,最后得到明文数据;
*/
#ifndef DES_H
#define DES_H
#ifdef __cplusplus
extern "C"
{
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
/*程序示例*//*
unsigned char key[24] = {'1','2','3','4','5','6','7','8', 0x34, 0x45, 0xA4, 0x34, 0x45, 0xA4, 0x45, 0xA4, 0x45, 0xA4, 0x34, 0x45, 0x45, 0xA4, 0x34, 0x45,};
unsigned char _data[33] = {'1','2','3','4','5','6', '7', '8', '1','2','3','4','5','6', '7', '8',
'1','2','3','4','5','6', '7', '8','1','2','3','4','5','6', '7', '8', '1'
};
p_desRetStruct retData = _3desEncryption(_data, 33, key, 24, NOPADDING);
p_desRetStruct mData = _3desDecrypt(retData->data, retData->dataLenght, key, 24, NOPADDING);
printf("加密后数据十六进制:");
for(int num=0; num<retData->dataLenght; num++)
printf("0x%02X ", *(retData->data+num));
printf("\n");
printf("解密后原数据:");
for(int num=0; num<mData->dataLenght; num++)
printf("%c ",*(mData->data+num));
printf("\n");
*//*程序示例*/
//将某个位清零
#define RESET_BIT_NUMBER(UA, BIT_NUMBER) ( (UA) &= ( ~ ( 1 << (BIT_NUMBER) ) ) )
//将某个位置一
#define SET_BIT_NUMBER(UA, BIT_NUMBER) ( (UA) |= ( 1 << (BIT_NUMBER) ) )
//判断某个位是1还是0
#define BIT_JUDGE(UA, BIT_NUMBER) ( ( (UA) >> (BIT_NUMBER) ) & 1 )
//des标准下各种位数
#define des_standard 64
#define des_key_pc1_standard 56
#define des_key_pc2_standard 48
#define des_data_rl 32
#define NumberOfKeys 16
#define systemBit 8
//数据类型
#define Table_size unsigned char
#define data_lenght_size unsigned int
#define data_size unsigned char *
#define subkey_size unsigned char *
//补位方式
typedef enum
{
NOPADDING = 0, //按照\0补位
PKCS5PADDING = 1 //按照余8取(模)补位
}enumFillingMode;
//枚举
typedef struct desNode
{
data_size data; //返回的数据指针
data_lenght_size dataLenght; //返回的数据长度
}desRetStruct, *p_desRetStruct;
// 结构体别名 结构体指针别名
/*
* 函数功能:将数据进行DES加密
* 参数:<data>要加密的数据,<data_lenght>要加密的数据长度,<key>进行加密的密钥,<key_lenght>密钥的长度(8字节),<fillingMode>数据补位的模式选择
* 返回值:返回一个结构体,结构体内有加密后数据和加密后数据长度
*/
p_desRetStruct desEncryption(data_size data, data_lenght_size data_lenght, subkey_size key, data_lenght_size key_lenght, enumFillingMode fillingMode);
/*
* 函数功能:将DES加密数据进行解密
* 参数:<data>要解密的数据,<data_lenght>要解密的数据长度(8的整数倍字节),<key>进行解密的密钥,<key_lenght>密钥的长度(8字节),<fillingMode>数据补位的模式选择
* 返回值:返回一个结构体,结构体内有解密后数据和解密后数据长度
*/
p_desRetStruct desDecrypt(data_size data, data_lenght_size data_lenght, subkey_size key, data_lenght_size key_lenght, enumFillingMode fillingMode);
/*
* 函数功能:将数据进行3DES加密
* 参数:<data>要加密的数据,<data_lenght>要加密的数据长度,<key>进行加密的密钥,<key_lenght>密钥的长度(24字节),<fillingMode>数据补位的模式选择
* 返回值:返回一个结构体,结构体内有加密后数据和加密后数据长度
*/
p_desRetStruct _3desEncryption(data_size data, data_lenght_size data_lenght, subkey_size key, data_lenght_size key_lenght, enumFillingMode fillingMode);
/*
* 函数功能:将3DES加密数据进行解密
* 参数:<data>要解密的数据,<data_lenght>要解密的数据长度(8的整数倍字节),<key>进行解密的密钥,<key_lenght>密钥的长度(24字节),<fillingMode>数据补位的模式选择
* 返回值:返回一个结构体,结构体内有解密后数据和解密后数据长度
*/
p_desRetStruct _3desDecrypt(data_size data, data_lenght_size data_lenght, subkey_size key, data_lenght_size key_lenght, enumFillingMode fillingMode);
#ifdef __cplusplus
}
#endif
#endif //DES_H
C语言DES加密解密的认识以及解密出现乱码的分析
在工作中遇到的Des解密问题，第三方发来的数据需要我们进行des解密，但是解密的结果前几位始终是乱码。废了半天劲，终于找到了问题所在。
下面先介绍一下des，了解des的同学可以直接看下面的解决办法。
Des加密
DES全称为Data EncryptionStandard，即数据加密标准。Des加密算法是一种对称加密算法，所谓对称加密算法就是指对明文的加密以及对密文的解密用的是同一个密钥。
Des使用一个56位的密钥以及附加的8位奇偶校验位，产生最大64位的分组大小。这是一个迭代的分组密码，使用称为 Feistel 的技术，其中将加密的文本块分成两半。使用子密钥对其中一半应用循环功能，然后将输出与另一半进行“异或”运算；接着交换这两半，这一过程会继续下去，但最后一个循环不交换。DES 使用 16 个循环，使用异或，置换，代换，移位操作四种基本运算。
特点：数据加密标准，速度较快，适用于加密大量数据的场合。
Des算法的入口参数有三个：Key、Data、Mode。
Key： 为8个字节共64位，Des算法规定，其中第8、16、24、......64位是奇偶校验位，不参与Des运算，所以常说Des的密钥为56位。 在Des加密和解密的过程当中，密钥的长度都必须是8字节的倍数。Data： 8个字节64位，是要被加密后解密的数据。Mode： Des的工作方式：加密、解密。
Des加密模式
Des的加密模式主要有CBC模式，ECB模式，它们分别使用不同的加密方式加密。
ECB模式指的是电子密码本模式，是一种最古老,最简单的模式，将加密的数据分成若干组，每组的大小跟加密密钥长度相同；然后每组都用相同的密钥加密, 如果最后一个分组长度不够64位,要补齐64位。
ECB模式的特点是：
每次Key、明文、密文的长度都必须是64位；
数据块重复排序不需要检测；
相同的明文块(使用相同的密钥)产生相同的密文块，容易遭受字典攻击；
一个错误仅仅会对一个密文块产生影响；
CBC模式指的是加密块链模式，与ECB模式最大的不同是加入了初始向量。
CBC模式的特点是：
每次加密的密文长度为64位(8个字节);
当相同的明文使用相同的密钥和初始向量的时候CBC模式总是产生相同的密文;
密文块要依赖以前的操作结果,所以，密文块不能进行重新排列;
可以使用不同的初始化向量来避免相同的明文产生相同的密文,一定程度上抵抗字典攻击;
一个错误发生以后,当前和以后的密文都会被影响;
填充方式
常见的填充方式PKCS5Padding，PKCS5Padding表示当数据位数不足的时候要采用的数据补齐方式，也可以叫做数据填充方式。PKCS5Padding这种填充方式，具体来说就是“填充的数字代表所填字节的总数”
比如说，差两个字节，就是######22，差5个字节就是###55555，这样根据最后一个自己就可以知道填充的数字和数量。
保证加密解密的一致性
在不同的平台上，只要能保证这几个参数的一致，就可以实现加密和解密的一致性。
加密和解密的密钥一致
采用CBC模式的时候，要保证初始向量一致
采用相同的填充模式
python中的des加密
在python中，我们使用pyDes对数据进行des加密：
# pyDes.des(key, [mode], [IV], [pad], [padmode])
key：des的加密解密密钥。mode： 加密模式：支持CBC，ECB两种模式IV： 初始化向量，这是CBC模式专有的，长度为8 bytes。使用不同的初始化向量加密避免产生相同的密文,一定程度上抵抗字典攻击。pad： 当padmode设置为PAD_NORMAL时，用pad参数来指定填充方式。padmode： 填充方式，默认为PAD_PKCS5填充模式。
Example
-------
from pyDes import *
data = "Please encrypt my data"
k = des("DESCRYPT", CBC, "\0\0\0\0\0\0\0\0", pad=None, padmode=PAD_PKCS5)
# For Python3, you'll need to use bytes, i.e.:
# data = b"Please encrypt my data"
# k = des(b"DESCRYPT", CBC, b"\0\0\0\0\0\0\0\0", pad=None, padmode=PAD_PKCS5)
d = k.encrypt(data)
print "Encrypted: %r" % d
print "Decrypted: %r" % k.decrypt(d)
assert k.decrypt(d, padmode=PAD_PKCS5) == data
des加密后（CBC模式）使用相同的密钥，初始向量，填充模式解密，解密后的字符前几位是乱码，其他位正常的解决办法
des_key = 'ucgtchdp'
IV = '12345678'
k = des(des_key, mode=CBC, IV='12345678', padmode=PAD_PKCS5)
传递过来的加密数据： xUjw0iO7uhymZ+h/VB9kvhubiAEv4Kzz
通过k解密出来的数据：@IDX_^\x10Ys powerful
这种情况通常发生在不同语言（java加密、python解密）对初始向量的处理方式不同造成的解密不完全。
解决办法：检查初始向量的表现形式。
k1 = des(des_key, mode=CBC, IV='\1\2\3\4\5\6\7\x08', padmode=PAD_PKCS5)
通过k1解密出来的数据：python is powerful
关于“c语言怎么实现DES加密解密”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识，可以关注编程之家行业资讯频道，小编每天都会为大家更新不同的知识点。
浅谈C/C++中的指针和数组（一）指针是C/C++...
从两个例子分析C语言的声明 在读《C专家编程》一书的第三章时...
C语言文件操作解析(三) 在前面已经讨论了文件打开操作，下面...