求C语言编写的DES加密解密源代码

从别的地方抄来的

创新互联公司主要从事网站制作、成都网站建设、网页设计、企业做网站、公司建网站等业务。立足成都服务沈河,10余年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:13518219792

#include "stdio.h"

#include "time.h"

#include "stdlib.h"

#define PLAIN_FILE_OPEN_ERROR -1

#define KEY_FILE_OPEN_ERROR -2

#define CIPHER_FILE_OPEN_ERROR -3

#define OK 1;

typedef char ElemType;

/* 初始置换表IP */

int IP_Table[64] = { 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,

56,48,40,32,24,16,8,0,

58,50,42,34,26,18,10,2,

60,52,44,36,28,20,12,4,

62,54,46,38,30,22,14,6};

/* 逆初始置换表IP^-1 */

int IP_1_Table[64] = {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,

32,0,40,8,48,16,56,24};

/* 扩充置换表E */

int E_Table[48] = {31, 0, 1, 2, 3, 4,

3, 4, 5, 6, 7, 8,

7, 8,9,10,11,12,

11,12,13,14,15,16,

15,16,17,18,19,20,

19,20,21,22,23,24,

23,24,25,26,27,28,

27,28,29,30,31, 0};

/* 置换函数P */

int P_Table[32] = {15,6,19,20,28,11,27,16,

0,14,22,25,4,17,30,9,

1,7,23,13,31,26,2,8,

18,12,29,5,21,10,3,24};

/* S盒 */

int S[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,9,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,9,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}}};

/* 置换选择1 */

int PC_1[56] = {56,48,40,32,24,16,8,

0,57,49,41,33,25,17,

9,1,58,50,42,34,26,

18,10,2,59,51,43,35,

62,54,46,38,30,22,14,

6,61,53,45,37,29,21,

13,5,60,52,44,36,28,

20,12,4,27,19,11,3};

/* 置换选择2 */

int PC_2[48] = {13,16,10,23,0,4,2,27,

14,5,20,9,22,18,11,3,

25,7,15,6,26,19,12,1,

40,51,30,36,46,54,29,39,

50,44,32,46,43,48,38,55,

33,52,45,41,49,35,28,31};

/* 对左移次数的规定 */

int MOVE_TIMES[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};

int ByteToBit(ElemType ch,ElemType bit[8]);

int BitToByte(ElemType bit[8],ElemType *ch);

int Char8ToBit64(ElemType ch[8],ElemType bit[64]);

int Bit64ToChar8(ElemType bit[64],ElemType ch[8]);

int DES_MakeSubKeys(ElemType key[64],ElemType subKeys[16][48]);

int DES_PC1_Transform(ElemType key[64], ElemType tempbts[56]);

int DES_PC2_Transform(ElemType key[56], ElemType tempbts[48]);

int DES_ROL(ElemType data[56], int time);

int DES_IP_Transform(ElemType data[64]);

int DES_IP_1_Transform(ElemType data[64]);

int DES_E_Transform(ElemType data[48]);

int DES_P_Transform(ElemType data[32]);

int DES_SBOX(ElemType data[48]);

int DES_XOR(ElemType R[48], ElemType L[48],int count);

int DES_Swap(ElemType left[32],ElemType right[32]);

int DES_EncryptBlock(ElemType plainBlock[8], ElemType subKeys[16][48], ElemType cipherBlock[8]);

int DES_DecryptBlock(ElemType cipherBlock[8], ElemType subKeys[16][48], ElemType plainBlock[8]);

int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile);

int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile);

/* 字节转换成二进制 */

int ByteToBit(ElemType ch, ElemType bit[8]){

int cnt;

for(cnt = 0;cnt 8; cnt++){

*(bit+cnt) = (chcnt)1;

}

return 0;

}

/* 二进制转换成字节 */

int BitToByte(ElemType bit[8],ElemType *ch){

int cnt;

for(cnt = 0;cnt 8; cnt++){

*ch |= *(bit + cnt)cnt;

}

return 0;

}

/* 将长度为8的字符串转为二进制位串 */

int Char8ToBit64(ElemType ch[8],ElemType bit[64]){

int cnt;

for(cnt = 0; cnt 8; cnt++){

ByteToBit(*(ch+cnt),bit+(cnt3));

}

return 0;

}

/* 将二进制位串转为长度为8的字符串 */

int Bit64ToChar8(ElemType bit[64],ElemType ch[8]){

int cnt;

memset(ch,0,8);

for(cnt = 0; cnt 8; cnt++){

BitToByte(bit+(cnt3),ch+cnt);

}

return 0;

}

/* 生成子密钥 */

int DES_MakeSubKeys(ElemType key[64],ElemType subKeys[16][48]){

ElemType temp[56];

int cnt;

DES_PC1_Transform(key,temp);/* PC1置换 */

for(cnt = 0; cnt 16; cnt++){/* 16轮跌代，产生16个子密钥 */

DES_ROL(temp,MOVE_TIMES[cnt]);/* 循环左移 */

DES_PC2_Transform(temp,subKeys[cnt]);/* PC2置换，产生子密钥 */

}

return 0;

}

/* 密钥置换1 */

int DES_PC1_Transform(ElemType key[64], ElemType tempbts[56]){

int cnt;

for(cnt = 0; cnt 56; cnt++){

tempbts[cnt] = key[PC_1[cnt]];

}

return 0;

}

/* 密钥置换2 */

int DES_PC2_Transform(ElemType key[56], ElemType tempbts[48]){

int cnt;

for(cnt = 0; cnt 48; cnt++){

tempbts[cnt] = key[PC_2[cnt]];

}

return 0;

}

/* 循环左移 */

int DES_ROL(ElemType data[56], int time){

ElemType temp[56];

/* 保存将要循环移动到右边的位 */

memcpy(temp,data,time);

memcpy(temp+time,data+28,time);

/* 前28位移动 */

memcpy(data,data+time,28-time);

memcpy(data+28-time,temp,time);

/* 后28位移动 */

memcpy(data+28,data+28+time,28-time);

memcpy(data+56-time,temp+time,time);

return 0;

}

/* IP置换 */

int DES_IP_Transform(ElemType data[64]){

int cnt;

ElemType temp[64];

for(cnt = 0; cnt 64; cnt++){

temp[cnt] = data[IP_Table[cnt]];

}

memcpy(data,temp,64);

return 0;

}

/* IP逆置换 */

int DES_IP_1_Transform(ElemType data[64]){

int cnt;

ElemType temp[64];

for(cnt = 0; cnt 64; cnt++){

temp[cnt] = data[IP_1_Table[cnt]];

}

memcpy(data,temp,64);

return 0;

}

/* 扩展置换 */

int DES_E_Transform(ElemType data[48]){

int cnt;

ElemType temp[48];

for(cnt = 0; cnt 48; cnt++){

temp[cnt] = data[E_Table[cnt]];

}

memcpy(data,temp,48);

return 0;

}

/* P置换 */

int DES_P_Transform(ElemType data[32]){

int cnt;

ElemType temp[32];

for(cnt = 0; cnt 32; cnt++){

temp[cnt] = data[P_Table[cnt]];

}

memcpy(data,temp,32);

return 0;

}

/* 异或 */

int DES_XOR(ElemType R[48], ElemType L[48] ,int count){

int cnt;

for(cnt = 0; cnt count; cnt++){

R[cnt] ^= L[cnt];

}

return 0;

}

/* S盒置换 */

int DES_SBOX(ElemType data[48]){

int cnt;

int line,row,output;

int cur1,cur2;

for(cnt = 0; cnt 8; cnt++){

cur1 = cnt*6;

cur2 = cnt2;

/* 计算在S盒中的行与列 */

line = (data[cur1]1) + data[cur1+5];

row = (data[cur1+1]3) + (data[cur1+2]2)

+ (data[cur1+3]1) + data[cur1+4];

output = S[cnt][line][row];

/* 化为2进制 */

data[cur2] = (output0X08)3;

data[cur2+1] = (output0X04)2;

data[cur2+2] = (output0X02)1;

data[cur2+3] = output0x01;

}

return 0;

}

/* 交换 */

int DES_Swap(ElemType left[32], ElemType right[32]){

ElemType temp[32];

memcpy(temp,left,32);

memcpy(left,right,32);

memcpy(right,temp,32);

return 0;

}

/* 加密单个分组 */

int DES_EncryptBlock(ElemType plainBlock[8], ElemType subKeys[16][48], ElemType cipherBlock[8]){

ElemType plainBits[64];

ElemType copyRight[48];

int cnt;

Char8ToBit64(plainBlock,plainBits);

/* 初始置换（IP置换） */

DES_IP_Transform(plainBits);

/* 16轮迭代 */

for(cnt = 0; cnt 16; cnt++){

memcpy(copyRight,plainBits+32,32);

/* 将右半部分进行扩展置换，从32位扩展到48位 */

DES_E_Transform(copyRight);

/* 将右半部分与子密钥进行异或操作 */

DES_XOR(copyRight,subKeys[cnt],48);

/* 异或结果进入S盒，输出32位结果 */

DES_SBOX(copyRight);

/* P置换 */

DES_P_Transform(copyRight);

/* 将明文左半部分与右半部分进行异或 */

DES_XOR(plainBits,copyRight,32);

if(cnt != 15){

/* 最终完成左右部的交换 */

DES_Swap(plainBits,plainBits+32);

}

}

/* 逆初始置换（IP^1置换） */

DES_IP_1_Transform(plainBits);

Bit64ToChar8(plainBits,cipherBlock);

return 0;

}

/* 解密单个分组 */

int DES_DecryptBlock(ElemType cipherBlock[8], ElemType subKeys[16][48],ElemType plainBlock[8]){

ElemType cipherBits[64];

ElemType copyRight[48];

int cnt;

Char8ToBit64(cipherBlock,cipherBits);

/* 初始置换（IP置换） */

DES_IP_Transform(cipherBits);

/* 16轮迭代 */

for(cnt = 15; cnt = 0; cnt--){

memcpy(copyRight,cipherBits+32,32);

/* 将右半部分进行扩展置换，从32位扩展到48位 */

DES_E_Transform(copyRight);

/* 将右半部分与子密钥进行异或操作 */

DES_XOR(copyRight,subKeys[cnt],48);

/* 异或结果进入S盒，输出32位结果 */

DES_SBOX(copyRight);

/* P置换 */

DES_P_Transform(copyRight);

/* 将明文左半部分与右半部分进行异或 */

DES_XOR(cipherBits,copyRight,32);

if(cnt != 0){

/* 最终完成左右部的交换 */

DES_Swap(cipherBits,cipherBits+32);

}

}

/* 逆初始置换（IP^1置换） */

DES_IP_1_Transform(cipherBits);

Bit64ToChar8(cipherBits,plainBlock);

return 0;

}

/* 加密文件 */

int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile){

FILE *plain,*cipher;

int count;

ElemType plainBlock[8],cipherBlock[8],keyBlock[8];

ElemType bKey[64];

ElemType subKeys[16][48];

if((plain = fopen(plainFile,"rb")) == NULL){

return PLAIN_FILE_OPEN_ERROR;

}

if((cipher = fopen(cipherFile,"wb")) == NULL){

return CIPHER_FILE_OPEN_ERROR;

}

/* 设置密钥 */

memcpy(keyBlock,keyStr,8);

/* 将密钥转换为二进制流 */

Char8ToBit64(keyBlock,bKey);

/* 生成子密钥 */

DES_MakeSubKeys(bKey,subKeys);

while(!feof(plain)){

/* 每次读8个字节，并返回成功读取的字节数 */

if((count = fread(plainBlock,sizeof(char),8,plain)) == 8){

DES_EncryptBlock(plainBlock,subKeys,cipherBlock);

fwrite(cipherBlock,sizeof(char),8,cipher);

}

}

if(count){

/* 填充 */

memset(plainBlock + count,'\0',7 - count);

/* 最后一个字符保存包括最后一个字符在内的所填充的字符数量 */

plainBlock[7] = 8 - count;

DES_EncryptBlock(plainBlock,subKeys,cipherBlock);

fwrite(cipherBlock,sizeof(char),8,cipher);

}

fclose(plain);

fclose(cipher);

return OK;

}

/* 解密文件 */

int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile){

FILE *plain, *cipher;

int count,times = 0;

long fileLen;

ElemType plainBlock[8],cipherBlock[8],keyBlock[8];

ElemType bKey[64];

ElemType subKeys[16][48];

if((cipher = fopen(cipherFile,"rb")) == NULL){

return CIPHER_FILE_OPEN_ERROR;

}

if((plain = fopen(plainFile,"wb")) == NULL){

return PLAIN_FILE_OPEN_ERROR;

}

/* 设置密钥 */

memcpy(keyBlock,keyStr,8);

/* 将密钥转换为二进制流 */

Char8ToBit64(keyBlock,bKey);

/* 生成子密钥 */

DES_MakeSubKeys(bKey,subKeys);

/* 取文件长度 */

fseek(cipher,0,SEEK_END); /* 将文件指针置尾 */

fileLen = ftell(cipher); /* 取文件指针当前位置 */

rewind(cipher); /* 将文件指针重指向文件头 */

while(1){

/* 密文的字节数一定是8的整数倍 */

fread(cipherBlock,sizeof(char),8,cipher);

DES_DecryptBlock(cipherBlock,subKeys,plainBlock);

times += 8;

if(times fileLen){

fwrite(plainBlock,sizeof(char),8,plain);

}

else{

break;

}

}

/* 判断末尾是否被填充 */

if(plainBlock[7] 8){

for(count = 8 - plainBlock[7]; count 7; count++){

if(plainBlock[count] != '\0'){

break;

}

}

}

if(count == 7){/* 有填充 */

fwrite(plainBlock,sizeof(char),8 - plainBlock[7],plain);

}

else{/* 无填充 */

fwrite(plainBlock,sizeof(char),8,plain);

}

fclose(plain);

fclose(cipher);

return OK;

}

int main()

{ DES_Encrypt("1.txt","key.txt","2.txt");

system("pause");

DES_Decrypt("2.txt","key.txt","3.txt");

getchar();

return 0;

}

DES算法实现

完成一个DES 算法的 详细设计 ,内容包括：

DES（Data Encryption Standard）是一种用于电子数据加密的对称密钥块加密算法 .它以64位为分组长度，64位一组的明文作为算法的输入，通过一系列复杂的操作，输出同样64位长度的密文。DES 同样采用64位密钥，但由于每8位中的最后1位用于奇偶校验，实际有效密钥长度为56位。密钥可以是任意的56位的数，且可随时改变。

DES 使用加密密钥定义变换过程，因此算法认为只有持有加密所用的密钥的用户才能解密密文。DES的两个重要的安全特性是混淆和扩散。其中 混淆 是指通过密码算法使明文和密文以及密钥的关系非常复杂，无法从数学上描述或者统计。 扩散 是指明文和密钥中的每一位信息的变动，都会影响到密文中许多位信息的变动，从而隐藏统计上的特性，增加密码的安全。

DES算法的基本过程是换位和置换。如图，有16个相同的处理阶段，称为轮。还有一个初始和最终的排列，称为 IP 和 FP，它们是反向的 (IP 取消 FP 的作用，反之亦然)。

在主轮之前，块被分成两个32位的一半和交替处理；这种纵横交错的方案被称为Feistel 方法。Feistel 结构确保了解密和加密是非常相似的过程——唯一的区别是在解密时子键的应用顺序是相反的。其余的算法是相同的。这大大简化了实现，特别是在硬件中，因为不需要单独的加密和解密算法。

符号表示异或（XOR）操作。Feistel 函数将半块和一些键合在一起。然后，将Feistel 函数的输出与块的另一半组合在一起，在下一轮之前交换这一半。在最后一轮之后，两队交换了位置；这是 Feistel 结构的一个特性，使加密和解密过程类似。

IP 置换表指定64位块上的输入排列。其含义如下：输出的第一个比特来自输入的第58位;第二个位来自第50位，以此类推，最后一个位来自第7位输入。

最后的排列是初始排列的倒数。

展开函数被解释为初始排列和最终排列。注意，输入的一些位在输出时是重复的;输入的第5位在输出的第6位和第8位中都是重复的。因此，32位半块被扩展到48位。

P排列打乱了32位半块的位元。

表的“左”和“右”部分显示了来自输入键的哪些位构成了键调度状态的左和右部分。输入的64位中只有56位被选中；剩下的8（8、16、24、32、40、48、56、64）被指定作为奇偶校验位使用。

这个排列从56位键调度状态为每轮选择48位的子键。

这个表列出了DES中使用的8个S-box，每个S-box用4位的输出替换6位的输入。给定一个6位输入，通过使用外部的两个位选择行，以及使用内部的四个位选择列，就可以找到4位输出。例如，一个输入“011011”有外部位“01”和内部位“1101”。第一行为“00”，第一列为“0000”，S-box S5对应的输出为“1001”(=9)，即第二行第14列的值。

DES算法的基本流程图如下：

DES算法是典型的对称加密算法，在输入64比特明文数据后，通过输入64比特密钥和算法的一系列加密步骤后，可以得到同样为64比特的密文数据。反之，我们通过已知的密钥，可以将密文数据转换回明文。 我们将算法分为了三大块：IP置换、16次T迭代和IP逆置换 ，加密和解密过程分别如下：

实验的设计模式是自顶向下的结构，用C语言去分别是先各个函数的功能，最后通过主函数将所有函数进行整合，让算法更加清晰客观。

通过IP置换表，根据表中所示下标，找到相应位置进行置换。

对于16次 迭代，我们先将传入的经过 IP 混淆过的64位明文的左右两部分，分别为32位的 和32位的 。之后我们将 和 进行交换，得到作为IP逆置换的输入：

，

子密钥的生成，经历下面一系列步骤：首先对于64位密钥，进行置换选择，因为将用户输入的64 位经历压缩变成了56位，所以我们将左面和右面的各28位进行循环位移。左右两部分分别按下列规则做循环移位：当 ，循环左移1位；其余情况循环左移2位。最后将得到的新的左右两部分进行连接得到56位密钥。

对半块的 Feistel 操作分为以下五步：

如上二图表明，在给出正确的密码后，可以得到对应的明文。

若密码错误，将解码出错误答案。

【1】 Data Encryption Standard

【2】 DES算法的详细设计（简单实现）

【3】 深入理解并实现DES算法

【4】 DES算法原理完整版

【5】 安全体系（一）—— DES算法详解

DES加密算法C语言实现

#includeiostream.h

class SubKey{ //定义子密钥为一个类

public:

int key[8][6];

}subkey[16]; //定义子密钥对象数组

class DES{

int encipher_decipher; //判断加密还是解密

int key_in[8][8]; //用户原始输入的64位二进制数

int key_out[8][7]; //除去每行的最后一位校验位

int c0_d0[8][7]; //存储经PC-1转换后的56位数据

int c0[4][7],d0[4][7]; //分别存储c0,d0

int text[8][8]; //64位明文

int text_ip[8][8]; //经IP转换过后的明文

int A[4][8],B[4][8]; //A,B分别存储经IP转换过后明文的两部分,便于交换

int temp[8][6]; //存储经扩展置换后的48位二进制值

int temp1[8][6]; //存储和子密钥异或后的结果

int s_result[8][4]; //存储经S变换后的32位值

int text_p[8][4]; //经P置换后的32位结果

int secret_ip[8][8]; //经逆IP转换后的密文

public:

void Key_Putting();

void PC_1();

int function(int,int); //异或

void SubKey_Production();

void IP_Convert();

void f();

void _IP_Convert();

void Out_secret();

};

void DES::Key_Putting() //得到密钥中对算法有用的56位

{

cout"请输入64位的密钥(8行8列且每行都得有奇数个1):\n";

for(int i=0;i8;i++)

for(int j=0;j8;j++){

cinkey_in[i][j];

if(j!=7) key_out[i][j]=key_in[i][j];

}

}

void DES::PC_1() //PC-1置换函数

{

int pc_1[8][7]={ //PC-1

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

};

int i,j;

for(i=0;i8;i++)

for(j=0;j7;j++)

c0_d0[i][j]=key_out[ (pc_1[i][j]-1)/8 ][ (pc_1[i][j]-1)%8 ];

}

int DES::function(int a,int b) //模拟二进制数的异或运算,a和b为整型的0和1,返回值为整型的0或1

{

if(a!=b)return 1;

else return 0;

}

void DES::SubKey_Production() //生成子密钥

{

int move[16][2]={ //循环左移的位数

1 , 1 , 2 , 1 ,

3 , 2 , 4 , 2 ,

5 , 2 , 6 , 2 ,

7 , 2 , 8 , 2 ,

9 , 1, 10 , 2,

11 , 2, 12 , 2,

13 , 2, 14 , 2,

15 , 2, 16 , 1

};

int pc_2[8][6]={ //PC-2

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, 45, 33, 48,

44, 49, 39, 56, 34, 53,

46, 42, 50, 36, 29, 32

};

for(int i=0;i16;i++) //生成子密钥

{

int j,k;

int a[2],b[2];

int bb[28],cc[28];

for(j=0;j4;j++)

for(k=0;k7;k++)

c0[j][k]=c0_d0[j][k];

for(j=4;j8;j++)

for(k=0;k7;k++)

d0[j-4][k]=c0_d0[j][k];

for(j=0;j4;j++)

for(k=0;k7;k++){

bb[7*j+k]=c0[j][k];

cc[7*j+k]=d0[j][k];

}

for(j=0;jmove[i][1];j++){

a[j]=bb[j];

b[j]=cc[j];

}

for(j=0;j28-move[i][1];j++){

bb[j]=bb[j+1];

cc[j]=cc[j+1];

}

for(j=0;jmove[i][1];j++){

bb[27-j]=a[j];

cc[27-j]=b[j];

}

for(j=0;j28;j++){

c0[j/7][j%7]=bb[j];

d0[j/7][j%7]=cc[j];

}

for(j=0;j4;j++) //L123--L128是把c0,d0合并成c0_d0

for(k=0;k7;k++)

c0_d0[j][k]=c0[j][k];

for(j=4;j8;j++)

for(k=0;k7;k++)

c0_d0[j][k]=d0[j-4][k];

for(j=0;j8;j++) //对Ci,Di进行PC-2置换

for(k=0;k6;k++)

subkey[i].key[j][k]=c0_d0[ (pc_2[j][k]-1)/7 ][ (pc_2[j][k]-1)%7 ];

}

}

void DES::IP_Convert()

{

int IP[8][8]={ //初始置换IP矩阵

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

};

cout"你好,你要加密还是解密?加密请按1号键(输入1),解密请按2号键,并确定."'\n';

cinencipher_decipher;

char * s;

if(encipher_decipher==1) s="明文";

else s="密文";

cout"请输入64位"s"(二进制):\n";

int i,j;

for(i=0;i8;i++)

for(j=0;j8;j++)

cintext[i][j];

for(i=0;i8;i++) //进行IP变换

for(j=0;j8;j++)

text_ip[i][j]=text[ (IP[i][j]-1)/8 ][ (IP[i][j]-1)%8 ];

}

用c语言写des加密算法

#include stdio.h #include string.h #include windows.h #include conio.h #include "Schedle.h" class CShift{ public: DWORDLONG mask[16]; int step[16]; CShift(){ for(int i=0;i16;i++){ step[i]=2; mask[i]=0xc000000; } step[0]=step[1]=step[8]=step[15]=1; mask[0]=mask[1]=mask[8]=mask[15]=0x8000000; } }; class CDES{ public: CDES(){ m_dwlKey=0; m_dwlData=0; ConvertTableToMask(dwlKey_PC_1,64); //PrintTable(dwlKey_PC_1,7,8); ConvertTableToMask(dwlKey_PC_2,56); ConvertTableToMask(dwlData_IP,64); ConvertTableToMask(dwlData_Expansion,32); ConvertTableToMask(dwlData_FP,64); ConvertTableToMask(dwlData_P,32); Generate_S(); } void PrintBit(DWORDLONG); void EncryptKey(char *); unsigned char* EncryptData(unsigned char *); unsigned char* DescryptData(unsigned char*); private: void ConvertTableToMask(DWORDLONG *,int); void Generate_S(void); void PrintTable(DWORDLONG*,int,int); DWORDLONG ProcessByte(unsigned char*,BOOL); DWORDLONG PermuteTable(DWORDLONG,DWORDLONG*,int); void Generate_K(void); void EncryptKernel(void); DWORDLONG Generate_B(DWORDLONG,DWORDLONG*); /*For verify schedule permutation only*/ DWORDLONG UnPermuteTable(DWORDLONG,DWORDLONG*,int); /**************************************/ DWORDLONG dwlData_S[9][4][16]; CShift m_shift; DWORDLONG m_dwlKey; DWORDLONG m_dwlData; DWORDLONG m_dwl_K[17]; }; void CDES::EncryptKey(char *key){ printf("\nOriginal Key: %s",key); m_dwlKey=ProcessByte((unsigned char*)key,TRUE); // PrintBit(m_dwlKey); m_dwlKey=PermuteTable(m_dwlKey,dwlKey_PC_1,56); // PrintBit(m_dwlKey); Generate_K(); // printf("\n******************************************\n"); } void CDES::Generate_K(void){ DWORDLONG C[17],D[17],tmp; C[0]=m_dwlKey28; D[0]=m_dwlKey0xfffffff; for(int i=1;i=16;i++){ tmp=(C[i-1]m_shift.mask[i-1])(28-m_shift.step[i-1]); C[i]=((C[i-1]m_shift.step[i-1])|tmp)0x0fffffff; tmp=(D[i-1]m_shift.mask[i-1])(28-m_shift.step[i-1]); D[i]=((D[i-1]m_shift.step[i-1])|tmp)0x0fffffff; m_dwl_K[i]=(C[i]28)|D[i]; m_dwl_K[i]=PermuteTable(m_dwl_K[i],dwlKey_PC_2,48); } } DWORDLONG CDES::ProcessByte(unsigned char *key,BOOL shift){ unsigned char tmp; DWORDLONG byte=0; int i=0; while(i8){ while(*key){ if(byte!=0) byte=8; tmp=*key; if(shift) tmp=1; byte|=tmp; i++; key++; } if(i8) byte=8; i++; } return byte; } DWORDLONG CDES::PermuteTable(DWORDLONG dwlPara,DWOR 基于des算法的rfid安全系统

DLONG* dwlTable,int nDestLen){ int i=0; DWORDLONG tmp=0,moveBit; while(inDestLen){ moveBit=1; if(dwlTable[i]dwlPara){ moveBit=nDestLen-i-1; tmp|=moveBit; } i++; } return tmp; } DWORDLONG CDES::UnPermuteTable(DWORDLONG dwlPara,DWORDLONG* dwlTable,int nDestLen){ DWORDLONG tmp=0; int i=nDestLen-1; while(dwlPara!=0){ if(dwlPara0x01) tmp|=dwlTable[i]; dwlPara=1; i--; } return tmp; } void CDES::PrintTable(DWORDLONG *dwlPara,int col,int row){ int i,j; for(i=0;irow;i++){ printf("\n"); getch(); for(j=0;jcol;j++) PrintBit(dwlPara[i*col+j]); } } void CDES::PrintBit(DWORDLONG bitstream){ char out[76]; int i=0,j=0,space=0; while(bitstream!=0){ if(bitstream0x01) out[i++]='1'; else out[i++]='0'; j++; if(j%8==0){ out[i++]=' '; space++; } bitstream=bitstream1; } out[i]='\0'; strcpy(out,strrev(out)); printf("%s **:%d\n",out,i-space); } void CDES::ConvertTableToMask(DWORDLONG *mask,int max){ int i=0; DWORDLONG nBit=1; while(mask[i]!=0){ nBit=1; nBit=max-mask[i]; mask[i++]=nBit; } } void CDES::Generate_S(void){ int i; int j,m,n; m=n=0; j=1; for(i=0;i512;i++){ dwlData_S[j][m][n]=OS[i]; n=(n+1)%16; if(!n){ m=(m+1)%4; if(!m) j++; } } } unsigned char * CDES::EncryptData(unsigned char *block){ unsigned char *EncrytedData=new unsigned char(15); printf("\nOriginal Data: %s\n",block); m_dwlData=ProcessByte(block,0); // PrintBit(m_dwlData); m_dwlData=PermuteTable(m_dwlData,dwlData_IP,64); EncryptKernel(); // PrintBit(m_dwlData); DWORDLONG bit6=m_dwlData; for(int i=0;i11;i++){ EncrytedData[7-i]=(unsigned char)(bit60x3f)+46; bit6=6; } EncrytedData[11]='\0'; printf("\nAfter Encrypted: %s",EncrytedData); for(i=0;i8;i++){ EncrytedData[7-i]=(unsigned char)(m_dwlData0xff); m_dwlData=8; } EncrytedData[8]='\0'; return EncrytedData; } void CDES::EncryptKernel(void){ int i=1; DWORDLONG L[17],R[17],B[9],EK,PSB; L[0]=m_dwlData32; R[0]=m_dwlData0xffffffff; for(i=1;i=16;i++){ L[i]=R[i-1]; R[i-1]=PermuteTable(R[i-1],dwlData_Expansion,48); //Expansion R EK=R[i-1]^m_dwl_K[i]; //E Permutation PSB=Generate_B(EK,B); //P Permutation R[i]=L[i-1]^PSB; } R[16]=32; m_dwlData=R[16]|L[16]; m_dwlData=PermuteTable(m_dwlData,dwlData_FP,64); } unsigned char* CDES::DescryptData(unsigned char *desData){ int i=1; unsigned char *DescryptedData=new unsigned char(15); DWORDLONG L[17],R[17],B[9],EK,PSB; DWORDLONG dataPara; dataPara=ProcessByte(desData,0); dataPara=PermuteTable(dataPara,dwlData_IP,64); R[16]=dataPara32; L[16]=dataPara0xffffffff; for(i=16;i=1;i--){ R[i-1]=L[i]; L[i]=PermuteTable(L[i],dwlData_Expansion,48); //Expansion L EK=L[i]^m_dwl_K[i]; //E Permutation PSB=Generate_B(EK,B); //P Permutation L[i-1]=R[i]^PSB; } L[0]=32; dataPara=L[0]|R[0]; dataPara=PermuteTable(dataPara,dwlData_FP,64); // PrintBit(dataPara); for(i=0;i8;i++){ DescryptedData[7-i]=(unsigned char)(dataPara0xff); dataPara=8; } DescryptedData[8]='\0'; printf("\nAfter Decrypted: %s\n",DescryptedData); return DescryptedData; } DWORDLONG CDES::Generate_B(DWORDLONG EKPara,DWORDLONG *block){ int i,m,n; DWORDLONG tmp=0; for(i=8;i0;i--){ block[i]=EKPara0x3f; m=(int)(block[i]0x20)4; m|=block[i]0x01; n=(int)(block[i]1)2; block[i]=dwlData_S[i][m][n]; EKPara=6; } for(i=1;i=8;i++){ tmp|=block[i]; tmp=4; } tmp=4; tmp=PermuteTable(tmp,dwlData_P,32); return tmp; } void main(void){ CDES des; des.EncryptKey("12345678"); unsigned char *result=des.EncryptData((unsigned char*)"DemoData"); des.DescryptData(result); }[1]

网站栏目：des异或函数c语言 异或运算 c语言
本文路径：http://abwzjs.com/article/ddjddjh.html