本文主要是对《信息安全技术》的DES算法实验作业的一些总结，不会着重地介绍算法原理，而会在算法实现过程中给出自己的理解（因为有些部分我也不知道正确与否，如有错误请指教）。文章中出现的原理介绍和配图，均参考自其它博客，相关链接将在文中给出。
另外，文中的代码都是根据内容截取的，若想查看完整代码，请参考 DES - github
一、DES算法简介(参考自DES算法实例详解)
DES（Data Encryption Standard）是一种用于电子数据加密的对称密钥块加密算法。它以64bit一组的明文(Input)作为算法的输入，通过一系列复杂的操作，输出同样64bit长度的密文(Output)。DES 同样采用64位密钥(Key)，但由于每8bit中的最后1位用于奇偶校验，实际有效密钥长度为56bit（Tips：输入的Key依然是64bit，只是在映射时不对每个字节最后1位进行处理，所以变为了56bit）。
DES 使用加密密钥定义变换过程，因此算法认为只有持有加密所用的密钥的用户才能解密密文。DES的两个重要的安全特性是混淆和扩散。其中混淆是指通过密码算法使明文和密文以及密钥的关系非常复杂，无法从数学上描述或者统计。扩散是指明文和密钥中的每一位信息的变动，都会影响到密文中许多位信息的变动，从而隐藏统计上的特性，增加密码的安全。
上图是DES算法的流程图。左侧是算法的工作流程，可以看到：
（1）用64bit的密钥Key产生16个48bit的子密钥；
（2）对输入的64bit明文先进行了Initial Permutation(IP初始置换)；
（3）将64bit分为左右两部分（各32bit），用16个子密钥辅助进行16轮的F变换；
（4）两部分合成为64bit，进行Final Permutation(FP最终置换/逆置换)形成密文输出
而我们可以看到，在（3）中的16轮变换中，都需要右侧图中由密钥(Key)产生的子密钥(Sub-Key #i)。因此，我们可以首先来处理初始置换部分和子密钥算法部分。
二、算法准备
2.1、数据结构
首先要确定的是数据结构，即如何保存算法过程中出现的二进制、八进制和字符串数据？显然的，在C++中，我们可以全都用string来进行存储，但是对于算法中经常进行的异或操作，就不是很方便了。
对于整数和单个字符，我们的数据范围不会很大，不论是字符还是数字使用unsigned char即可。因此先定义类型：
typedef unsigned char Byte;
对于其它数据，我们使用string类型来保存这些数据。但是需要进行位操作时，我们就将这些数据转换为C++中bitset类型来保存。关于bitset类型的介绍可以参考博客C++ bitset 用法，这里不再赘述。但是有一点需要特别特别注意，使用索引index来获取数据时，是从低位开始的。也就是说，若有bitset<4> bs("0001")，那么bs[0]==1，bs[3]==0。
2.2、置换操作
在算法过程中，我们经常可以看到对位数据进行置换操作。那么到底置换操作是怎么进行的呢？
// 要特别注意的是bitset的index由0->size-1是从 低位->高位，即右边->左边
// 置换操作模板函数
template <typename Input, typename Output>
void DES_Permutation(const Input& input, Output& output
, const Byte Table[], const Byte tableSize)
{
for(Byte i = 0; i < tableSize; ++i)
output[tableSize - i - 1] = input[input.size() - Table[i]];
}
举一个简单的例子，bitset<8> input("00101001")，input.size()为8。现在有置换数组Table {3, 1, 7, 5, 2, 8, 4, 6}，tableSize为8。那么现在再来一个bitset<8> output，经过循环置换操作后output的结果为 "10010100"。
置换过程简单来说，就是如下图所示：从左边开始数，input中第[3,1,7,5,2,8,4,6]个位依次映射到output第[1,2,3,4,5,6,7,8]中。由于我们使用的bitset中的索引0表示低位，即从右边开始数，因此需要进行一个如代码中所示的下标转换。
2.3、置换表和常量定义
了解了2.2中的置换操作，就知道这些置换数组的重要性了。在DES算法中，我们有很多的置换表，这里和一些常量、枚举类型统一给出，若在下文遇到没见过的数组、枚举，请回这里查找：
const Byte SIZE_INPUT = 64;
const Byte SIZE_OUTPUT = 64;
const Byte SIZE_DIVIDE = 28;
const Byte NUM_SONKEY = 16;
const Byte SIZE_SONKEY = 48;
enum plainTextMode {TEXT, BINARY, HEX}; // 明文模式：文本，二进制，十六进制
enum operateMode {ENCODE, DECODE}; // 工作模式：加密，解密
enum encodeMode {ECB, CBC, CFB, OFB};// 加密模式：ECB, CBC, CFB, OFB
// 初始置换表64bit
const Byte InitPerm_Table[] = {
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
};
// 选择置换表1，28*2 bit，其中未出现的 8,16,24,32,40,48,56,64做奇偶校验位
const Byte PC_Table1[] = {
// Ci
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,
// Di
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
};
// 选择置换表2，6*8 bit
const Byte PC_Table2[] = {
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
};
// 左移位数表
const Byte LeftMove_Table[] = {
1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
};
// 扩展表
const Byte Expansion_Table[] = {
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盒，8*64bit
const Byte SBox_Table[][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盒，4*8bit
const Byte PBox_Table[] = {
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
};
// 逆初始置换表64bit
const Byte FinalPerm_Table[] = {
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
};
三、算法实现
3.1、初始置换
非常的简单，有了上面2.2的置换操作DES_Permutation，我们只需要传入特定的数据即可。首先创建一个64bit的IP用作输出，其中plaintext为64bit明文输入（类型均为bitset<64>）。
bitset<SIZE_OUTPUT> IP; DES_Permutation(plaintext, IP, InitPerm_Table, SIZE_INPUT);
3.2、子密钥生成
首先需要64bit的Key映射为56bit，然后将其一分为二为Ci和Di(均为28bit)。有人可能会问64bit是怎么转成56bit的？其实很简单，回到2.3中的PC_Table1，它只有56个数，并且少了[8, 16, 24, 32, 40, 48, 56, 64]这8个下标，因此映射到K中的也只有56个bit。这正对应了本文开头时Tips所述。
接下来是对Ci和Di进行16轮的复杂操作（搞清楚一遍的原理就够了，剩下的都是for循环）。
1、首先对Ci和Di分别进行左移位操作（移几位参考LeftMove_Table表），注意这里的移位操作是循环的。也就是说，左移位溢出的位不会丢弃，而是移动到右边去。举个例子，有bitset<8> bs("10001011")，左移两位，则变为bs("00101110")。
// 旋转左移
template <typename Input>
void DES_LeftRotation(Input& bs, Byte count)
{
while( count-- )
{
Byte bit = bs[SIZE_DIVIDE - 1];
bs <<= 1;
bs[0] = bit;
}
}
2、接下来，Ci和Di合并为bitset<56>的临时变量bs_merge，再使用PC_Table2表对其置换，即得到了第i个密钥Ki[i]
依次对操作1和2循环16次，即完成了子密钥的生成，以下给出生成子密钥完整代码实现：
// 生成的子密钥保存在Ki[]中
void getKeyTable(const bitset<SIZE_INPUT>& key, bitset<SIZE_SONKEY> Ki[])
{
// 交换生成56bit的K
bitset<SIZE_DIVIDE*2> K;
DES_Permutation(key, K, PC_Table1, SIZE_DIVIDE*2);
// 一分为二生成初始C0, D0
string str_K = K.to_string();
bitset<SIZE_DIVIDE> Ci(str_K.substr(0, SIZE_DIVIDE));
bitset<SIZE_DIVIDE> Di(str_K.substr(SIZE_DIVIDE));
// 生成16个子密钥
for(Byte i = 0; i < NUM_SONKEY; ++i){
// 旋转左移
DES_LeftRotation(Ci, LeftMove_Table[i]);
DES_LeftRotation(Di, LeftMove_Table[i]);
// 合并置换
bitset<2*SIZE_DIVIDE> bs_merge(Ci.to_string() + Di.to_string());
DES_Permutation(bs_merge, Ki[i], PC_Table2, SIZE_SONKEY);
}
}
3.3、Feistel轮函数
同样的，对应上述生成的16个子密钥，轮函数同样需要进行16次。我们首先将经过初始置换生成的IP一分为二，变为28bit的Li和Ri。
// 生成初始L0, R0
string str_IP = IP.to_string();
bitset<SIZE_INPUT/2> Li(str_IP.substr(0, SIZE_INPUT/2)), tmpL;
bitset<SIZE_INPUT/2> Ri(str_IP.substr(SIZE_INPUT/2)) , tmpR;
其中的tmpL，tmpR用于暂存原来的Li和Ri值，因为在轮函数中它们的值会变化，而最后又会用到原来的值。
接下来正式进入16轮循环。对于每一轮循环，首先用扩展表将Ri扩展至48bit，存放于Ei中。
bitset<SIZE_SONKEY> Ei; // 保存中间结果
DES_Permutation(Ri, Ei, Expansion_Table, SIZE_SONKEY);
然后将扩展结果Ei与子密钥进行异或（加密过程对应第i个子密钥，解密过程对应第16-i个子密钥）。
// 与密钥Ki异或
if( opMode == ENCODE ) Ei ^= Ki[i];
else Ei ^= Ki[15 - i];
再来就是对上述的Ei进行复杂的S盒映射操作，S盒是一个8*4*16的三维数组。
我们将Ei分为8组，每组6bit，共操作8次。第i次（0~7）我们使用第i个子二维数组进行操作。其中这6bit的首尾位构成行号（0~3），中间四位构成列号（0~15）。然后到S盒中取数，生成4bit的结果，累加到结果res中。因为这个过程有8轮，因此最终会生成32bit的数据。
string res = "";
for(Byte j = 0; j < SIZE_SONKEY; j += 6){
string str_col = Ei.to_string().substr(j+1, 4);
// 转化行、列
Byte row = Ei[SIZE_SONKEY-j-1]*2 + Ei[SIZE_SONKEY-j-6];
Byte col = bitset<4>(str_col).to_ulong();
// 获取S-BOX的值
Byte value = SBox_Table[j/6][row][col];
res += bitset<4>(value).to_string();
}
// 再转换回32bit
bitset<32> bs_tmp(res);
最后将这32位数据最为输入，使用P盒进行置换，再将结果与上一轮的Li异或，便得到了下一轮的Ri；而下一轮的Li，则直接拷贝上一轮的Ri即可。
// P盒置换
DES_Permutation(bs_tmp, Ri, PBox_Table, SIZE_INPUT/2);
Ri ^= tmpL;
Li = tmpR;
注意到这16轮算法中的最后一轮我们是不需要交换Li和Ri位置的，而我们在循环中并未做特殊处理。因此最终我们得到的预输出密文应当是Ri在左，Li在右。
bitset<64> res(Ri.to_string() + Li.to_string());
DES_Permutation(res, ciphertext, FinalPerm_Table, SIZE_OUTPUT);
将预输出密文最后做一次IP逆置换，即得到了最终的密文ciphertext。至此，DES算法实现完成。
四、四种模式的实现
四种模式ECB, CBC, CFB, OFB的枚举常量encodeMode均已在前文定义，并同时定义了明文的输入类型plainTextMode以及算法的工作模式operateMode。以下四种模式我没有单独给定函数，而是集成在了2个函数中（CFB模式使用8位流密码，我单独为它写了一个函数），因此不会单独给出实现，而是给出完整代码，并加上注释。
4.1、电码本模式（ECB）
电码本模式即是对输入明文进行分组加密（通常为64bit）。由于电码本模式对任何分组都是使用同一密钥加密，因此若分组中若有相同的明文组，那么密文中也会出现几个相同的密文组。因此ECB模式特别适合于数据较少的情况，如加密一个密钥。
4.2、密文分组链接模式（CBC）
为了克服上述ECB的问题，我们将明文组先和上一个密文组异或，再进行相同的操作。显然，第一个分组加密时没有上一个密文组，因此我们需要设置一个64bit初始向量IV充当这个角色。
4.3、密文反馈模式（CFB）
上述两种模式都需要对明文进行64位的分组加密，若分组不够64bit的，还需要补0。在CFB模式中，我们的分组是1个字符（8个位），因此不存在这种困扰。我们同样需要一个64bit初始化向量IV充当输入，输出的IV_DES高8位与8bit明文异或得到密文；同时IV左移8位，用密文填充低8位后充当下一次的IV。特别提醒：CFB模式加/解密使用密钥Ki的顺序要一致！
4.4、输出反馈模式（OFB）
与CFB模式类似，只是它又变回64bit分组了。因此，IV输出的IV_DES不需要取高8位，而是直接与明文分组异或。下一个IV也不需要移位填充，而是直接由IV_DES充当即可。特别提醒：OFB模式加/解密使用密钥Ki的顺序要一致！
// ECB, CBC, OFB模式实现（均以64bit分组）
string str_binaryCpText = "";
for(int i = 0; i < str_binaryPlText.size(); i += SIZE_INPUT)
{
// 每次截取64bit明文进行加密
string sub_binary = str_binaryPlText.substr(i, SIZE_INPUT);
bitset<SIZE_INPUT> plaintext(sub_binary);
bitset<SIZE_OUTPUT> ciphertext;
// ECB 电子密本模式
if( enMode == ECB ){
myDES(plaintext, Ki, ciphertext, opMode);
}
// CBC 密文分组链接模式
else if( enMode == CBC )
{
if( opMode == ENCODE )
plaintext ^= IV;
myDES(plaintext, Ki, ciphertext, opMode);
if( opMode == ENCODE )
IV = ciphertext;
else{
ciphertext ^= IV;
IV = plaintext;
}
}
// OFB 输出反馈模式
else if( enMode == OFB ){
// OFB模式加/解密时使用密钥Ki的顺序一致
myDES(IV, Ki, ciphertext, ENCODE);
IV = ciphertext;
ciphertext ^= plaintext;
}
// OFB 输出反馈模式
else if( enMode == OFB ){
// OFB模式加/解密时使用密钥Ki的顺序一致
myDES(IV, Ki, ciphertext, ENCODE);
IV = ciphertext;
ciphertext ^= plaintext;
}
// 64bit明文加密后的密文累加
str_binaryCpText += ciphertext.to_string();
}
// OFB模式需要舍去填充的位
if( enMode == OFB ){
int size = str_binaryCpText.size();
str_binaryCpText = str_binaryCpText.substr(0, size - fillSize);
}
// CFB模式（8bit流分组）
string str_binaryCpText = "";
for(int i = 0; i < str_binaryPlText.size(); i += 8)
{
// 每次截取8bit明文进行加密
string sub_binary = str_binaryPlText.substr(i, 8);
bitset<8> plaintext(sub_binary);
bitset<SIZE_OUTPUT> IV_DES;
cout << "plaintext : " << plaintext << endl;
myDES(IV, Ki, IV_DES, ENCODE);
bitset<8> ciphertext(IV_DES.to_string().substr(0, 8));
ciphertext ^= plaintext;
cout << "ciphertext : " << ciphertext << endl << endl;
str_binaryCpText += ciphertext.to_string();
IV <<= 8;
if( opMode == ENCODE )
IV |= bitset<64>( ciphertext.to_string() );
else
IV |= bitset<64>( plaintext.to_string() );
}
四种模式中均为对二进制流操作，而输入明文可为“文本”、“十六进制”、“二进制”，因此在这两个函数的前后还有一些文本<->进制的转换，具体函数及模式完整代码请到Github仓库中查看。