前言
网络安全中数据加密标准（DES）的C++语言描述实现。
代码仓库
代码特点
纯C++语言：
- 相对规范和整洁
- 一定程度地面向对象
- 使用一部分高级特性
- 考虑优化性能
详细注释：
- 提示规范和整洁
- 提示面向对象
- 提示高级特性
- 提示优化性能
- 解析数据加密标准（DES）步骤
- 注意易错点
代码
des.h
//预处理指令——————————
//预定义宏
#ifndef DES_DES_H_
#define DES_DES_H_
//提示：防止头文件被重复包含
//标准库头文件
#include <iostream> //string，cout，endl
#include <vector> //vector
//命名空间
//提示：
//使用using声明而不是using指示，以体现命名空间的作用
//本项目并未体现命名空间的作用，因为只使用一个命名空间std
using std::cout;
using std::endl;
using std::string;
using std::vector;
//自定义数据类型——————————
//类
//数据加密标准类
class DES
{
public:
void encrypt(const string &plainText, const string &key, string &cipherTextASCII); //加密
void decrypt(const string &cipherTextASCII, const string &key, string &plainTextASCII); //解密
//提示：
//加密和解密过程相似，存在大量代码复用
//但仍依据语义拆分成两函数，解耦合以能够单独调用
//提示：返回值的数据类型为void而不是string，和其他函数形式统一，反正结果都会输出
private:
//提示：属性初始化，避免未显式定义的默认构造函数调用造成未知错误
//提示：因为会修改属性，所以不使用const修饰
//提示：记录二进制而不是字符是数据加密标准的原貌，更有实际意义
string plainTextASCII{""}; //明文的ASCII码 64位
string keyASCII{""}; //密钥的ASCII码 64位
string cipherTextASCII{""}; //密文的ASCII码 64位
vector<string> wheelKeys{
"", "", "", "",
"", "", "", "",
"", "", "", "",
"", "", "", ""}; //轮密钥 16个，每个56位
//注意：
// vector<string> wheelKeys(16,"");报错
// string默认为空字符串，可不初始化
//可初始化，和其他属性初始化方式统一
//提示：记录轮密钥，可将轮密钥生成过程和轮函数过程解耦合，可提前准备轮密钥
//提示：将固有属性放在类中，而不是初始化为静态全局变量
//提示：C++11新特性，可用大括号初始化任何类型
//初始置换IP表
const string ipTable{
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};
//密钥的选择置换表
const string keySeRepTable{
57, 49, 41, 33, 25, 17, 9,
1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27,
9, 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};
//密钥的左移位表
const vector<int> keyLeftMoveTable{1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};
//密钥的压缩置换表
const string keyComRepTable{
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};
//扩展置换E表
const string eRepTable{
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盒选择代替表
const vector<string> sBoxSeRepTable{
// 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}};
// 置换P表
const string pRepTable{
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};
//逆初始置换IP-1表
const string iIpTable{
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};
//提示：使用const表示只读；使用引用传地址而不是值，避免拷贝开销->搭配使用
//提示：非常量引用实参可传递给常量引用形参
void byteStrToBitStr(const string &str, string &bitStr); // 8字节字符串转64位字符串 依据ASCII码
void wheelKeyGener(const string &preKey, const int &wheelCount, string &nextKey, string &wheelKey); //轮密钥生成
void wheelFunc(const string &textIp, const string &keySeRep, string &textWheelF); //轮函数F
};
#endif // DES_DES_H_
des.cpp
//预处理指令——————————
//标准库头文件
#include <bitset> //<bitset>
#include <algorithm> //reverse()
#include <string> //stoi()
//自定义头文件
#include "des.h"
//命名空间
//提示：
//使用using声明而不是using指示，以体现命名空间的作用
//本项目并未体现命名空间的作用，因为只使用一个命名空间std
using std::bitset;
//加密
void DES::encrypt(const string &plainText, const string &key, string &cipherTextASCII) //参数：明文，密钥，密文的ASCII码
{
cout << "加密过程：————————————————————" << endl;
//对明文和密钥：
cout << "明文：\t" << plainText << endl;
cout << "密钥：\t" << key << endl;
// 0.初始化为二进制 8字节->64位
string plainTextASCII(""); //明文的ASCII码 64位
this->byteStrToBitStr(plainText, plainTextASCII); // 8字节字符串转64位字符串 依据ASCII码
this->plainTextASCII = plainTextASCII; //记录明文的ASCII码
cout << "明文的ASCII码：\t" << this->plainTextASCII << endl;
string keyASCII(""); //密钥的ASCII码 64位
this->byteStrToBitStr(key, keyASCII); // 8字节字符串转64位字符串 依据ASCII码
this->keyASCII = keyASCII; //记录密钥的ASCII码
cout << "密钥的ASCII码：\t" << this->keyASCII << endl;
cout << endl;
//对密钥：
// 1.密钥的选择置换 64->56位
string keySeRep(56, '-'); //密钥的选择置换 56位
//注意：因为需要使用下标赋值，所以需要初始化大小以预分配空间
//注意：初始化为不是0或1的字符，以验证是否成功
for (int i = 0; i < this->keySeRepTable.size(); ++i)
{
//置换规则：依据置换表，输入的第57位是输出的第1位->输入的第56位是输出的第0位
//注意：下标从0开始
keySeRep[i] = this->keyASCII[this->keySeRepTable[i] - 1];
}
cout << "密钥的选择置换：\t" << keySeRep << endl;
// 2.轮密钥生成
//提示：预先生成
string preKey(keySeRep); //上一轮密钥 56位
string nextKey(""); //下一轮密钥 56位
string wheelKey(48, '-'); //轮密钥 48位
//注意：因为需要使用下标赋值，所以需要初始化大小以预分配空间
//注意：初始化为不是0或1的字符，以验证是否成功
//提示：
//在循环外而不是循环中声明并初始化/定义对象，避免重复进行对象的构造和析构，减少开销
//但可读性差
// 16轮轮函数
//注意：轮数从1开始
for (int wheelCount = 1; wheelCount <= 16; ++wheelCount) //轮数计数
{
//轮密钥生成
//参数：上一轮密钥（56位），轮数（从1开始），下一轮密钥（56位），轮密钥（48位）
this->wheelKeyGener(preKey, wheelCount, nextKey, wheelKey);
this->wheelKeys[wheelCount - 1] = wheelKey; //记录轮密钥
//注意：轮数从1开始，轮密钥下标从0开始
//注意：记录轮密钥（48位）而不是下一轮密钥（56位）
//注意：
//循环外定义的变量可能需要更新
//循环内定义的变量为局部变量，不需要更新，方便
preKey = nextKey; //更新上一轮密钥 56位
nextKey = ""; //更新下一轮密钥 56位
//轮密钥每轮都通过下标填充，不需要更新
}
//对明文：
// 1.初始置换IP 64->64位
string plainTextIp(64, '-'); //明文的初始置换IP 64位
//注意：因为需要使用下标赋值，所以需要初始化大小以预分配空间
//注意：初始化为不是0或1的字符，以验证是否成功
for (int i = 0; i < this->ipTable.size(); ++i)
{
//置换规则：依据置换表，输入的第58位是输出的第1位->输入的第57位是输出的第0位
//注意：下标从0开始
plainTextIp[i] = this->plainTextASCII[this->ipTable[i] - 1];
}
cout << "明文的初始置换IP：\t" << plainTextIp << endl;
cout << endl;
// 2.轮函数F
string plainTextWheelF(""); //明文的轮函数 64位
wheelFunc(plainTextIp, keySeRep, plainTextWheelF);
//参数：明文的初始置换IP，密钥的选择置换，明文的轮函数
cout << "明文的轮函数F：\t" << plainTextWheelF << endl;
// 3.左右置换/轮函数F的第16轮不进行左右置换 64->64位
string left(plainTextWheelF.substr(0, 32)); //左 范围：0~31
string right(plainTextWheelF.substr(32, 32)); //右 范围：32~63
string plainTextLeRiRep = right + left; //明文的左右置换
cout << "明文的左右置换：\t" << plainTextLeRiRep << endl;
// 4.逆初始置换IP-1 64->64位
string plainTextIIp(64, '-'); //明文的逆初始置换IP-1
//注意：因为需要使用下标赋值，所以需要初始化大小以预分配空间
//注意：初始化为不是0或1的字符，以验证是否成功
for (int i = 0; i < this->iIpTable.size(); ++i)
{
//置换规则：依据置换表，输入的第40位是输出的第1位->输入的第39位是输出的第0位
//注意：下标从0开始
plainTextIIp[i] = plainTextLeRiRep[this->iIpTable[i] - 1];
}
cout << "明文的逆初始置换IP-1：\t" << plainTextIIp << endl;
cout << endl;
this->cipherTextASCII = plainTextIIp; //记录密文的ASCII码 密文的ASCII码为明文的逆初始置换IP-1
cout << "密文的ASCII码：\t" << this->cipherTextASCII << endl;
cout << endl;
cipherTextASCII = plainTextIIp; //记录结果 密文的ASCII码为明文的逆初始置换IP-1
return;
}
// 8字节字符串转64位字符串 依据ASCII码
void DES::byteStrToBitStr(const string &str, string &bitStr) //参数：8字节字符串，64位字符串
{
for (const char &ch : str)
{
bitStr += bitset<8>(ch).to_string(); // 1字节字符转8位字符串 字符->bitset对象->字符串
}
return;
}
//轮密钥生成
//参数：上一轮密钥（56位），轮数（从1开始），下一轮密钥（56位），轮密钥（48位）
void DES::wheelKeyGener(const string &preKey, const int &wheelCount, string &nextKey, string &wheelKey)
{
// 2.1等分上一轮密钥为上一轮左右 56->28+28位
//注意：substr()的参数：开始下标，子串大小
string preLeft(preKey.substr(0, 28)); //上一轮左 范围：0~27
string preRight(preKey.substr(28, 28)); //上一轮右 范围：28~55
// 2.2上一轮左右各循环左移/旋转
//上一轮左的左移
//局部翻转
//注意：轮数从1开始，下标从0开始
//注意：reverse()是左闭右开区间[)
reverse(preLeft.begin(), preLeft.begin() + this->keyLeftMoveTable[wheelCount - 1]); //翻转[0,1)或[0,2)
reverse(preLeft.begin() + this->keyLeftMoveTable[wheelCount - 1], preLeft.end()); //翻转[1,n)或[2,n)
//整体翻转
reverse(preLeft.begin(), preLeft.end()); //翻转[0,n)
//上一轮右的左移位
//局部翻转
//注意：轮数从1开始，下标从0开始
//注意：reverse()是左闭右开区间[)
reverse(preRight.begin(), preRight.begin() + this->keyLeftMoveTable[wheelCount - 1]); //翻转[0,1)或[0,2)
reverse(preRight.begin() + this->keyLeftMoveTable[wheelCount - 1], preRight.end()); //翻转[1,n)或[2,n)
//整体翻转
reverse(preRight.begin(), preRight.end()); //翻转[0,n)
// 2.3拼接上一轮左右得下一轮密钥 28+28->56位
nextKey = preLeft + preRight;
// 2.4下一轮密钥的压缩置换得轮密钥 56->48位
for (int i = 0; i < this->keyComRepTable.size(); ++i)
{
//置换规则：依据置换表，输入的第14位是输出的第1位->输入的第13位是输出的第0位
//注意：下标从0开始
wheelKey[i] = nextKey[this->keyComRepTable[i] - 1];
}
return;
}
//轮函数F
//注意：忘记加类作用域...
//参数：文本的初始置换IP，密钥的选择置换，文本的轮函数F
void DES::wheelFunc(const string &textIp, const string &keySeRep, string &textWheelF)
{
string preText(textIp); //上一轮文本 64位
//提示：
//在循环外而不是循环中声明并初始化/定义对象，避免重复进行对象的构造和析构，减少开销
//但可读性差
// 16轮轮函数
//注意：轮数从1开始
for (int wheelCount = 1; wheelCount <= 16; ++wheelCount) //轮数计数
{
// 2.1等分上一轮文本为上一轮左右 64->32+32位
//注意：substr()的参数：开始下标，子串大小
string preLeft(preText.substr(0, 32)); //上一轮左 范围：0~31
string preRight(preText.substr(32, 32)); //上一轮右 范围：32~63
// 2.2下一轮左为上一轮右 32->32位
string nextLeft(preRight);
// 2.3.1下一轮右：上一轮右扩展置换E 32->48位
string preRightERep(48, '-'); //上一轮右的扩展置换E
//注意：因为需要使用下标赋值，所以需要初始化大小以预分配空间
//注意：初始化为不是0或1的字符，以验证上一轮右的扩展置换E是否成功
for (int i = 0; i < this->eRepTable.size(); ++i)
{
//置换规则：依据置换表，输入的第32位是输出的第1位->输入的第31位是输出的第0位
//注意：下标从0开始
preRightERep[i] = preRight[this->eRepTable[i] - 1];
}
// 2.3.2下一轮右：上一轮右的扩展置换E（48位）与轮密钥（48位）异或 48w->48位
string preRightXor(""); //上一轮右的异或
for (int i = 0; i < preRightERep.size(); ++i)
{
//注意：轮数计数从1开始，轮密钥的下标从0开始
if (preRightERep[i] == this->wheelKeys[wheelCount - 1][i]) //相同为0
{
preRightXor += '0';
}
else //不同为'1'
{
preRightXor += '1';
}
}
// 2.3.4下一轮右：上一轮右的异或经S盒选择代替 48->32位
string preRightSBoxSeRep(""); //上一轮右的S盒选择代替
int sBoxCount = 0; // S盒计数
//注意：S盒计数从0开始
for (int i = 0; i < preRightXor.size();) // i循环范围：0~47
{
string sBoxGroup(preRightXor.substr(i, 6)); // S盒组 一组从i开始取6位数
//注意：substr()参数：开始下标，子串长度
string rowStr{sBoxGroup[0], sBoxGroup[5]}; //行字符串：首尾2位
//注意：初始化方式
int rowNumber = stoi(rowStr, 0, 2); //行号
//注意：stoi()参数：字符串，开始下标，字符串的基数
string colStr(sBoxGroup.substr(1, 4)); //列字符串：中间4位
//注意：初始化方式
int colNumber = stoi(colStr, 0, 2); //列号
//注意：stoi()参数：字符串，开始下标，字符串的基数
int pos = rowNumber * 16 + colNumber; //位置：第rowNumber行第colNumber列
//注意：行数从0开始，列数从0开始
char sBoxNumber = this->sBoxSeRepTable[sBoxCount][pos]; // S盒数
//注意：
// S盒计数从0开始 第0盒->S1
// S盒数是char数据类型
preRightSBoxSeRep += bitset<4>(sBoxNumber).to_string(); // 1字节字符转4位字符串 字符->bitset对象->字符串
sBoxCount += 1; // S盒计数+1
i += 6; //循环i+6
// 注意：i变化范围：0~5，6~11，12~17，18...
}
// 2.3.5下一轮右：上一轮右置换P 32->32位
string preRightPRep(32, '-'); //上一轮右的置换P
//注意：因为需要使用下标赋值，所以需要初始化大小以预分配空间
//注意：初始化为不是0或1的字符，以验证是否成功
for (int i = 0; i < this->pRepTable.size(); ++i)
{
//置换规则：依据置换表，输入的第16位是输出的第1位->输入的第15位是输出的第0位
//注意：下标从0开始
preRightPRep[i] = preRightSBoxSeRep[this->pRepTable[i] - 1];
}
// 2.3.6下一轮右：上一轮右与上一轮左异或 32->32位
string preRightXor2(""); //下一轮右的异或2
for (int i = 0; i < preLeft.size(); ++i)
{
if (preRightPRep[i] == preLeft[i]) //相同为0
{
preRightXor2 += '0';
}
else //不同为'1'
{
preRightXor2 += '1';
}
}
string nextRight(preRightXor2); //下一轮右
//注意：
//循环外定义的变量可能需要更新
//循环内定义的变量为局部变量，不需要更新，方便
preText = nextLeft + nextRight; //更新上一轮文本
cout << "明/密文的第" << wheelCount << "轮输出：\t" << preText << endl;
}
cout << endl;
textWheelF = preText; //文本的轮函数F为上一轮文本
return;
}
//解密
//注意过程：
// 1.初始置换IP
// 2.轮函数F
// 3.左右置换
// 4.逆初始置换IP-1
//提示：因为通过重构解耦合，直接复用加密函数代码，修改变量名称和注释即可
//注意：
//加密的轮函数F中，使用轮密钥K1，K2...K16，轮函数下标0，1...15
//解密的轮函数F中，使用轮密钥K16，K15...K1，轮函数下标15，14...1
//所以，解密的轮密钥生成中，反向记录轮密钥，即可复用相同的轮函数函数
void DES::decrypt(const string &cipherTextASCII, const string &key, string &plainTextASCII) //参数：密文的ASCII码，密钥，明文的ASCII码
{
cout << "解密过程：————————————————————" << endl;
//对密文和密钥：
cout << "密钥：\t" << key << endl;
this->cipherTextASCII = cipherTextASCII; //记录密文的ASCII码
cout << "密文的ASCII码：\t" << this->cipherTextASCII << endl;
// 0.初始化为二进制 8字节->64位
string keyASCII(""); //密钥的ASCII码 64位
this->byteStrToBitStr(key, keyASCII); // 8字节字符串转64位字符串 依据ASCII码
this->keyASCII = keyASCII; //记录密钥的ASCII码
cout << "密钥的ASCII码：\t" << this->keyASCII << endl;
cout << endl;
//对密钥：
// 1.密钥的选择置换 64->56位
string keySeRep(56, '-'); //密钥的选择置换 56位
//注意：因为需要使用下标赋值，所以需要初始化大小以预分配空间
//注意：初始化为不是0或1的字符，以验证是否成功
for (int i = 0; i < this->keySeRepTable.size(); ++i)
{
//置换规则：依据置换表，输入的第57位是输出的第1位->输入的第56位是输出的第0位
//注意：下标从0开始
keySeRep[i] = this->keyASCII[this->keySeRepTable[i] - 1];
}
cout << "密钥的选择置换：\t" << keySeRep << endl;
// 2.轮密钥生成
//注意：预先生成
string preKey(keySeRep); //上一轮密钥 56位
string nextKey(""); //下一轮密钥 56位
string wheelKey(48, '-'); //轮密钥 48位
//注意：因为需要使用下标赋值，所以需要初始化大小以预分配空间
//注意：初始化为不是0或1的字符，以验证是否成功
//提示：
//在循环外而不是循环中声明并初始化/定义对象，避免重复进行对象的构造和析构，减少开销
//但可读性差
// 16轮轮函数
//注意：轮数从1开始
for (int wheelCount = 1; wheelCount <= 16; ++wheelCount) //轮数计数
{
//轮密钥生成
//参数：上一轮密钥（56位），轮数（从1开始），下一轮密钥（56位），轮密钥（48位）
this->wheelKeyGener(preKey, wheelCount, nextKey, wheelKey);
//记录轮密钥
this->wheelKeys[16 - wheelCount] = wheelKey;
//注意：轮数从1开始，轮密钥下标从15开始
//注意：记录轮密钥（48位）而不是下一轮密钥（56位）
//注意：
//循环外定义的变量可能需要更新
//循环内定义的变量为局部变量，不需要更新，方便
preKey = nextKey; //更新上一轮密钥 56位
nextKey = ""; //更新下一轮密钥 56位
//轮密钥每轮都通过下标填充，不需要更新
}
//对密文：
// 1.初始置换IP 64->64位
string cipherTextIp(64, '-'); //密文的初始置换IP 64位
//注意：因为需要使用下标赋值，所以需要初始化大小以预分配空间
//注意：初始化为不是0或1的字符，以验证是否成功
for (int i = 0; i < this->ipTable.size(); ++i)
{
//置换规则：依据置换表，输入的第58位是输出的第1位->输入的第57位是输出的第0位
//注意：下标从0开始
cipherTextIp[i] = this->cipherTextASCII[this->ipTable[i] - 1];
//注意：忘记修改this->plain为cipher了...
}
cout << "密文的初始置换IP：\t" << cipherTextIp << endl;
cout << endl;
// 2.轮函数F
string cipherTextWheelF(""); //密文的轮函数 64位
wheelFunc(cipherTextIp, keySeRep, cipherTextWheelF);
//参数：密文的初始置换IP，密钥的选择置换，密文的轮函数
cout << "密文的轮函数F：\t" << cipherTextWheelF << endl;
// 3.左右置换/轮函数F的第16轮不进行左右置换 64->64位
string left(cipherTextWheelF.substr(0, 32)); //左 范围：0~31
string right(cipherTextWheelF.substr(32, 32)); //右 范围：32~63
string cipherTextLeRiRep = right + left; //密文的左右置换
cout << "密文的左右置换：\t" << cipherTextLeRiRep << endl;
// 4.逆初始置换IP-1 64->64位
string cipherTextIIp(64, '-'); //密文的逆初始置换IP-1
//注意：因为需要使用下标赋值，所以需要初始化大小以预分配空间
//注意：初始化为不是0或1的字符，以验证是否成功
for (int i = 0; i < this->iIpTable.size(); ++i)
{
//置换规则：依据置换表，输入的第40位是输出的第1位->输入的第39位是输出的第0位
//注意：下标从0开始
cipherTextIIp[i] = cipherTextLeRiRep[this->iIpTable[i] - 1];
}
cout << "密文的逆初始置换IP-1：\t" << cipherTextIIp << endl;
cout << endl;
this->plainTextASCII = cipherTextIIp; //记录明文的ASCII码 明文的ASCII码为密文的逆初始置换IP-1
cout << "明文的ASCII码：\t" << this->plainTextASCII << endl;
cout << endl;
plainTextASCII = cipherTextIIp; //记录结果 明文的ASCII码为密文的逆初始置换IP-1
return;
}
main.cpp
//预处理指令——————————
//自定义头文件
#include "des.h"
//函数声明——————————
void compareStrBit(string str1, string str2); //比较两字符串不同的位数
//主函数——————————
int main()
{
DES *des = new DES(); //数据加密标准对象
//提示：
//复杂类型/自定义类型可能占用空间大，堆区比栈区大，需要在堆区手动管理
//手动管理：使用new创建对象，使用delete释放对象->搭配使用
const string plainText("yezhenin"); //明文
const string key("91002705"); //密钥
string cipherTextASCII(""); //密文的ASCII码
//提示：
//密文的ASCII码没有必要转换为字符，因为：
// 1.转换的字符无意义
// 2.转换的字符可能为非打印字符
string plainTextASCII(""); //明文的ASCII码
des->encrypt(plainText, key, cipherTextASCII); //加密
//参数：明文（已知），密钥（已知），密文的ASCII码（未知）
des->decrypt(cipherTextASCII, key, plainTextASCII); //解密
//参数：密文的ASCII码（已知），密钥（已知），明文的ASCII码（未知）
//字符转ASCII码转换器网址：https://www.qqxiuzi.cn/bianma/ascii.htm
// ASCII码转字符转换器网址：https://www.asciim.cn/m/tools/convert_ascii_to_string.html
//雪崩效应测试
//提示：
//由设计接口：测试明文变化需要考虑到字节层面，传递明文参数；测试密文变化需要考虑到位层面，传递密文的ASCII码参数
//因为加密和解密过程相似，所以变化密文进行测试
string cipherTextCo = "0000110101111001101000001011100001101001111000010100000001011011"; //密文正确码
string plainTextCo = "0111100101100101011110100110100001100101011011100110100101101110"; //明文正确码
//第一组
string cipherTextEr = cipherTextCo; //密文错误码为密文正确码
cipherTextEr[0] = 1; //修改1位：0->1
string plainTextEr(""); //明文错误码
des->decrypt(cipherTextEr, key, plainTextEr); //解密
//参数：密文错误码（已知），密钥（已知），明文错误码（未知）
compareStrBit(plainTextCo, plainTextEr); //比较两字符串不同的位数
//第二组
cipherTextEr = cipherTextCo; //密文错误码为密文正确码
cipherTextEr[0] = 1; //修改1位：0->1
cipherTextEr[63] = 0; //修改1位：1->0
plainTextEr = ""; //明文错误码
des->decrypt(cipherTextEr, key, plainTextEr); //解密
//参数：密文错误码（已知），密钥（已知），明文错误码（未知）
compareStrBit(plainTextCo, plainTextEr); //较两字符串不同的位数
//第三组
cipherTextEr = cipherTextCo; //密文错误码为密文正确码
cipherTextEr[0] = 1; //修改1位：0->1
cipherTextEr[1] = 1; //修改1位：0->1
cipherTextEr[63] = 0; //修改1位：1->0
plainTextEr = ""; //明文错误码
des->decrypt(cipherTextEr, key, plainTextEr); //解密
//参数：密文错误码（已知），密钥（已知），明文错误码（未知）
compareStrBit(plainTextCo, plainTextEr); //较两字符串不同的位数
delete des;
return 0;
}
//比较两字符串不同的位数
void compareStrBit(string str1, string str2)
{
int diffBitCount = 0; //不同位计数
for (int i = 0; i < str1.size(); ++i)
{
if (str1[i] != str2[i])
{
++diffBitCount;
}
}
cout << "不同位数：\t" << diffBitCount << endl;
cout << endl;
return;
}
结果
加密过程
解密过程
雪崩效应
- 修改密文的1位，解密的错误明文与正确明文的不同位数为35：
- 修改密文的2位，解密的错误明文与正确明文的不同位数为31：
- 修改密文的3位，解密的错误明文与正确明文的不同位数为30：
分析：
-
明文和密钥/密文的一位发生变化会导致密文/明文的多位发生变化
-
明文/密文发生变化的位数近似为明文/密文的二分之一（64÷2=32位）
-
数据加密标准（DES）满足雪崩效应，强度高
总结
网络安全中数据加密标准（DES）的C++语言描述实现。
参考资料
- 《密码编码学与网络安全——原理与实践(第五版)》作者：William Stallings
作者的话
- 感谢参考资料的作者/博主
- 作者：夜悊
- 版权所有，转载请注明出处，谢谢~
- 如果文章对你有帮助，请点个赞或加个粉丝吧，你的支持就是作者的动力~
- 文章在描述时有疑惑的地方，请留言，定会一一耐心讨论、解答
- 文章在认识上有错误的地方, 敬请批评指正
- 望读者们都能有所收获
1393
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
