c语言如何实现DES加密解密

c语言DES c语言加密解密 DES加密解密 2023-05-18 05:05:24 387人浏览八月长安

摘要

目录C语言实现DES加密解密C语言DES加密解密的认识以及解密出现乱码的分析Des加密Des加密模式填充方式保证加密解密的一致性　python中的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
};

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_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_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;
}

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;
}

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;
}

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;
}

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;
}



#ifndef DES_H
#define DES_H
#ifdef __cplusplus
extern "C"
{
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

//将某个位清零
#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;
//  结构体别名    结构体指针别名

p_desRetStruct desEncryption(data_size data, data_lenght_size data_lenght, subkey_size key, data_lenght_size key_lenght, enumFillingMode fillingMode);

p_desRetStruct desDecrypt(data_size data, data_lenght_size data_lenght, subkey_size key, data_lenght_size key_lenght, enumFillingMode fillingMode);

p_desRetStruct _3desEncryption(data_size data, data_lenght_size data_lenght, subkey_size key, data_lenght_size key_lenght, enumFillingMode 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

OK！

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程网。

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: c语言如何实现DES加密解密

本文链接: https://www.lsjlt.com/news/211738.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

c语言如何实现DES加密解密

目录c语言实现DES加密解密C语言DES加密解密的认识以及解密出现乱码的分析Des加密Des加密模式填充方式保证加密解密的一致性　python中的des加密总结c语言实现DES加密解...

99+

2023-05-18

c语言DES c语言加密解密 DES加密解密
如何理解C#DES加密解密的实现

这篇文章将为大家详细讲解有关如何理解C#DES加密解密的实现，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。C# DES加密解密的实现，DES算法为密码体制中的对称密码体制，由IBM公司研制的...

99+

2023-06-17
C语言如何利用DES模块实现加密功能

这篇文章主要讲解了“C语言如何利用DES模块实现加密功能”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“C语言如何利用DES模块实现加密功能”吧！DES(Data Encryption Sta...

99+

2023-06-17
C#加解密之DES算法的实现

目录前言实现功能开发环境实现代码实现效果前言说完了对称加密中的AES，这一篇再来介绍下DES。加解密原理什么的就不介绍了，大家可以自行百度（主要我也不太明白，也不需要太明白），大...

99+

2022-11-13
VB.NET如何实现DES加密

这篇文章主要介绍了VB.NET如何实现DES加密，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。VB.NET DES加密代码：Imports System ...

99+

2023-06-17
Go语言如何实现RSA加密解密

RSA是一种非对称加密算法，它的名字是由它的三位开发者，即RonRivest、AdiShamir和LeonardAdleman 的姓氏的首字母组成的（Rivest-Shamir-Ad...

99+

2022-11-12
C语言实现SM4加解密方式

目录C语言实现SM4加解密C语言文件加解密总结C语言实现SM4加解密简介： sm4也是一种对称加密算法，使用16字节秘钥加解密16字节数据。先生成32个32位子秘钥，数据再配合秘...

99+

2023-05-18

C语言SM4加解密 SM4加解密 C实现SM4加解密
C语言怎么实现MD5加密

这篇文章主要介绍“C语言怎么实现MD5加密”，在日常操作中，相信很多人在C语言怎么实现MD5加密问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”C语言怎么实现MD5加密”的疑惑有所帮助！接下来，请跟着小编一起来...

99+

2023-06-15
java实现的DES加密算法详解

本文实例讲述了java实现的DES加密算法。分享给大家供大家参考，具体如下：一、DES加密算法介绍要求密钥必须是8个字节，即64bit长度因为密钥是byte[8] , 代表字符串也可以是非可见的字节,可以与Base64编码算法一起使用加密、...

99+

2023-05-31

java des 加密算法
c语言中的文件加密与解密

目录c语言文件加密与解密具体加密过程如下解密过程与加密过程类似，采用的是模26减运算功能要求系统应提供以下功能总结c语言文件加密与解密本程序是一个c语言的大作业的一部分是简单的基...

99+

2023-05-18

c语言文件加密 c语言文件解密 c文件加密与解密
Go语言如何实现Sm2加解密

这篇文章主要讲解了“Go语言如何实现Sm2加解密”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“Go语言如何实现Sm2加解密”吧！在 Go 语言中，可以使用 github.com/tjfoc/...

99+

2023-07-05
C#如何实现加密与解密

这篇文章主要讲解了“C#如何实现加密与解密”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“C#如何实现加密与解密”吧！一、Hash加密，使用HashAlgorithm哈希算法类的派生类（MD5...

99+

2023-06-30
Go语言怎么实现RSA加密解密

这篇文章将为大家详细讲解有关Go语言怎么实现RSA加密解密，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。go是什么golang是一种编译语言，可以将代码编译为机器代码，编译后的二进制文件可以直接部署到目标...

99+

2023-06-14
C#实现加密与解密详解

目录一、Hash加密，使用HashAlgorithm哈希算法类的派生类（MD5、SHA1等）1、使用抽象类HashAlgorithm2、使用抽象类MD53、使用MD5CryptoSe...

99+

2022-11-13
详解DES加密算法的原理与Java实现

目录DES加密算法DES加密原理DES 加密算法Java实现前面阿粉说了关于 MD5 加密算法，还有 RSA 加密算法的实现，以及他们的前世今生，今天阿粉在来说一下这个关于 DES ...

99+

2022-11-13

Java DES加密算法 Java DES加密 Java DES
Java项目中AES与DES的加密解密怎么利用Hutool实现

Java项目中AES与DES的加密解密怎么利用Hutool实现？相信很多没有经验的人对此束手无策，为此本文总结了问题出现的原因和解决方法，通过这篇文章希望你能解决这个问题。介绍AES和DES同属对称加密算法，数据发信方将明文（原始数据）和加...

99+

2023-05-31

java aes des
如何用c语言进行数据加密

使用c语言对数据进行加密，具体方法如下：#include void main(){int a[5];int num, temp, encripy; int i;do{printf("Please input the number:");sc...

99+

2022-10-15
PHP如何实现加密解密

这篇文章主要为大家展示了“PHP如何实现加密解密”，内容简而易懂，条理清晰，希望能够帮助大家解决疑惑，下面让小编带领大家一起研究并学习一下“PHP如何实现加密解密”这篇文章吧。加密解密function encrypt($data,...

99+

2023-06-03
VBS如何实现加密解密

这篇文章主要为大家展示了“VBS如何实现加密解密”，内容简而易懂，条理清晰，希望能够帮助大家解决疑惑，下面让小编带领大家一起研究并学习一下“VBS如何实现加密解密”这篇文章吧。用法： 1.copy下面代码至文本文档 2.将文件后缀名改为.v...

99+

2023-06-08
RSA如何实现C# 加密

RSA如何实现C# 加密，很多新手对此不是很清楚，为了帮助大家解决这个难题，下面小编将为大家详细讲解，有这方面需求的人可以来学习下，希望你能有所收获。RSA实现C# 加密首先我们来了解下什么是RSA ，它属于不对称加密，其原理就是使用一个公...

99+

2023-06-17