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

#　pyDes.des(key, [mode], [IV], [pad], [padmode])

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" % dprint "Decrypted: %r" % k.decrypt(d)assert k.decrypt(d, padmode=PAD_PKCS5) == datades加密后（CBC模式）使用相同的密钥，初始向量，填充模式解密，解密后的字符前几位是乱码，其他位正常的解决办法des_key = 'ucgtchdp'IV = '12345678'k = des(des_key, mode=CBC, IV='12345678', padmode=PAD_PKCS5)

k1 = des(des_key, mode=CBC, IV='\1\2\3\4\5\6\7\x08', padmode=PAD_PKCS5)