DES算法的C语言实现 （《信息网络安全》作业）

学习DES可参考下文：

DES加密算法的C++实现

这篇写的很详细，一气呵成看完很通透。

但是唯一的不足是没办法一次加密和解密长一点的，它默认明文就是64位的。

所以我对其做了一点小改进，使得可以对一长串文字编码。不过输入的明文字符数也必须是8的整数倍。

不是计算机专业，码代码有些费力，请多指教

改进后代码如下：     （注明：代码很大一部分是借鉴了DES加密算法的C++实现）

/*************************************************************************
> File Name: Des.cpp
> Author: SongLee
> E-mail: lisong.shine@qq.com
> Created Time: 2014年06月01日 星期日 19时46分32秒
> Personal Blog: http://songlee24.github.com
> Changed a little by Yandan Yang
> Personal Blog: http://blog.csdn.net/github_38140310
************************************************************************/
#include <iostream>  
#include <fstream>  
#include <bitset>  
#include <string>  
using namespace std;

bitset<64> key;                // 64位密钥  
bitset<48> subKey[16];         // 存放16轮子密钥  

// 初始置换表  
int 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 };

// 结尾置换表  
int IP_1[] = { 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 };

/*------------------下面是生成密钥所用表-----------------*/

// 密钥置换表，将64位密钥变成56位  
int 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 };

// 压缩置换，将56位密钥压缩成48位子密钥  
int 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 };

// 每轮左移的位数  
int shiftBits[] = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };

/*------------------下面是密码函数 f 所用表-----------------*/

// 扩展置换表，将 32位 扩展至 48位  
int E[] = { 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 };

// S盒，每个S盒是4x16的置换表，6位 -> 4位  
int S_BOX[8][4][16] = {
		{
			{ 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 }
		},
		{
			{ 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 }
		},
		{
			{ 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 }
		},
		{
			{ 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 }
		},
		{
			{ 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 }
		},
		{
			{ 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 }
		},
		{
			{ 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 }
		},
		{
			{ 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 }
		}
};

// P置换，32位 -> 32位  
int P[] = { 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 };

/**********************************************************************/
/*                                                                    */
/*                            下面是DES算法实现                         */
/*                                                                    */
/**********************************************************************/

/**
*  密码函数f，接收32位数据和48位子密钥，产生一个32位的输出
*/

bitset<32> f(bitset<32> R, bitset<48> k)
{
	bitset<48> expandR;
	// 第一步：扩展置换，32 -> 48  
	for (int i = 0; i<48; ++i)
		expandR[47 - i] = R[32 - E[i]];
	// 第二步：异或  
	expandR = expandR ^ k;             //符号^表示异或
	// 第三步：查找S_BOX置换表  
	bitset<32> output;
	int x = 0;
	for (int i = 0; i<48; i = i + 6)
	{
		int row = expandR[47 - i] * 2 + expandR[47 - i - 5];
		int col = expandR[47 - i - 1] * 8 + expandR[47 - i - 2] * 4 + expandR[47 - i - 3] * 2 + expandR[47 - i - 4];
		int num = S_BOX[i / 6][row][col];
		bitset<4> binary(num);
		output[31 - x] = binary[3];
		output[31 - x - 1] = binary[2];
		output[31 - x - 2] = binary[1];
		output[31 - x - 3] = binary[0];
		x += 4;
	}
	// 第四步：P-置换，32 -> 32  
	bitset<32> tmp = output;
	for (int i = 0; i<32; ++i)
		output[31 - i] = tmp[32 - P[i]];
	return output;
}

/**
*  对56位密钥的前后部分进行左移
*/
bitset<28> leftShift(bitset<28> k, int shift)          
{
	bitset<28> tmp = k;
	for (int i = 27; i >= 0; --i)
	{
		if (i - shift<0)
			k[i] = tmp[i - shift + 28];
		else
			k[i] = tmp[i - shift];
	}
	return k;
}

/**
*  生成16个48位的子密钥
*/
void generateKeys()
{
	bitset<56> realKey;
	bitset<28> left;
	bitset<28> right;
	bitset<48> compressKey;
	// 去掉奇偶标记位，将64位密钥变成56位  
	for (int i = 0; i<56; ++i)
		realKey[55 - i] = key[64 - PC_1[i]];
	// 生成子密钥，保存在 subKeys[16] 中  
	for (int round = 0; round<16; ++round)
	{
		// 前28位与后28位  
		for (int i = 28; i<56; ++i)                    //感觉写在外面可以少执行几次
			left[i - 28] = realKey[i];
		for (int i = 0; i<28; ++i)
			right[i] = realKey[i];
		// 左移  
		left = leftShift(left, shiftBits[round]);
		right = leftShift(right, shiftBits[round]);
		// 压缩置换，由56位得到48位子密钥  
		for (int i = 28; i<56; ++i)
			realKey[i] = left[i - 28];
		for (int i = 0; i<28; ++i)
			realKey[i] = right[i];
		for (int i = 0; i<48; ++i)
			compressKey[47 - i] = realKey[56 - PC_2[i]];
		subKey[round] = compressKey;
	}
}

/**
*  工具函数：将char字符数组转为二进制
*/
bitset<64> charToBitset(const char s[8])
{
	bitset<64> bits;
	for (int i = 0; i<8; ++i)
		for (int j = 0; j<8; ++j)
			bits[i * 8 + j] = ((s[i] >> j) & 1);                    //右移j次，并且和00000001与，很精妙
	return bits;
}

/**
*  DES加密
*/
bitset<64> encrypt(bitset<64>& plain)
{
	bitset<64> cipher;
	bitset<64> currentBits;
	bitset<32> left;
	bitset<32> right;
	bitset<32> newLeft;
	// 第一步：初始置换IP  
	for (int i = 0; i<64; ++i)
		currentBits[63 - i] = plain[64 - IP[i]];
	// 第二步：获取 Li 和 Ri  
	for (int i = 32; i<64; ++i)
		left[i - 32] = currentBits[i];            //left为什么在右边？？？？？？？？、
	for (int i = 0; i<32; ++i)
		right[i] = currentBits[i];
	// 第三步：共16轮迭代  
	for (int round = 0; round<16; ++round)
	{
		newLeft = right;
		right = left ^ f(right, subKey[round]);
		left = newLeft;
	}
	// 第四步：合并L16和R16，注意合并为 R16L16  
	for (int i = 0; i<32; ++i)
		cipher[i] = left[i];
	for (int i = 32; i<64; ++i)
		cipher[i] = right[i - 32];
	// 第五步：结尾置换IP-1  
	currentBits = cipher;
	for (int i = 0; i<64; ++i)
		cipher[63 - i] = currentBits[64 - IP_1[i]];
	// 返回密文  
	return cipher;
}

/**
*  DES解密
*/
bitset<64> decrypt(bitset<64>& cipher)
{
	bitset<64> plain;
	bitset<64> currentBits;
	bitset<32> left;
	bitset<32> right;
	bitset<32> newLeft;
	// 第一步：初始置换IP  
	for (int i = 0; i<64; ++i)
		currentBits[63 - i] = cipher[64 - IP[i]];
	// 第二步：获取 Li 和 Ri  
	for (int i = 32; i<64; ++i)
		left[i - 32] = currentBits[i];
	for (int i = 0; i<32; ++i)
		right[i] = currentBits[i];
	// 第三步：共16轮迭代（子密钥逆序应用）  
	for (int round = 0; round<16; ++round)
	{
		newLeft = right;
		right = left ^ f(right, subKey[15 - round]);
		left = newLeft;
	}
	// 第四步：合并L16和R16，注意合并为 R16L16  
	for (int i = 0; i<32; ++i)
		plain[i] = left[i];
	for (int i = 32; i<64; ++i)
		plain[i] = right[i - 32];
	// 第五步：结尾置换IP-1  
	currentBits = plain;
	for (int i = 0; i<64; ++i)
		plain[63 - i] = currentBits[64 - IP_1[i]];
	// 返回明文  
	return plain;
}


/**********************************************************************/
/* 测试：                                                             */
/*     1.将一个 64 位的字符串加密， 把密文写入文件 a.txt                  */
/*     2.读取文件 a.txt 获得 64 位密文，解密之后再写入 b.txt              */
/**********************************************************************/

int main() {
	string s = "Happy April Fool's Day! ";
	string k = "12345678";
	fstream file1;
	string m="aaaaaaaa";
	key = charToBitset(k.c_str());
	// 生成16个子密钥  
	generateKeys();             //输入参数key是全局变量，所以不用写
	file1.open("D://a.txt", ios::binary | ios::out | ios::end);
    //之前把open和close放在循环里，一直没有解决write的覆盖问题，放出来就可以了。不知道有没有其他办法让write不覆盖？
	for (int i = 0; i < s.size() / 8; i++)
	{
		for (int j = 0; j < 8; j++)
			m[j] = s[i * 8 + j];
		bitset<64> plain = charToBitset(m.c_str());
		// 密文写入 a.txt  
		bitset<64> cipher = encrypt(plain);
		//ios::out opens the file for writing.
		//ios::binary makes sure the data is read or written without translating new line characters to and from \r\n on the fly.
		//In other words, exactly what you give the stream is exactly what's written.
		//ios::end表示从尾部开始写
		file1.write((char*)&cipher, sizeof(cipher));
	}
	file1.close();
		// 读文件 a.txt 
	bitset<64000> n;                       //貌似长度只能是常数，所以我定义了一个比较大的长度
	bitset<64> temp;
	file1.open("D://a.txt", ios::binary | ios::in);
	file1.read((char*)&n, sizeof(n));
	file1.close();
	file1.open("D://b.txt", ios::binary | ios::out | ios::end);
	for ( int ii = 0; ii < s.size() / 8; ii++)
	{
		for (int jj = 0; jj < 64; jj++)
			temp[jj] = n[ii * 64 + jj];
		// 解密，并写入文件 b.txt  
		bitset<64> temp_plain = decrypt(temp);
		
		file1.write((char*)&temp_plain, sizeof(temp_plain));
	}
	file1.close();
	return 0;
}


/*


最后测试所得结果：

a中存的密文：                          ??>U@S籚繈D堅?木斍
b中存的解密后的明文：          Happy April Fool's Day! 
开心！！*/