DES从入门到cpp实现#

1
uint64_t data = 0;
2
for (int i = 0; i < 8; ++i) data = (data << 8) | block[i];

1
IP表
2
58 50 42 34 26 18 10  2
3
60 52 44 36 28 20 12  4
4
62 54 46 38 30 22 14  6
5
64 56 48 40 32 24 16  8
6
57 49 41 33 25 17  9  1
7
59 51 43 35 27 19 11  3
8
61 53 45 37 29 21 13  5
9
63 55 47 39 31 23 15  7

1
公式
2
L_i = R_{i-1}
3
R_i = L_{i-1} ⊕ F(R_{i-1}, K_i)
4
关键性质：加密和解密结构完全相同，只需子密钥逆序。这是 Feistel 网络的对称美。

1
FP表
2
40  8 48 16 56 24 64 32   39  7 47 15 55 23 63 31
3
38  6 46 14 54 22 62 30   37  5 45 13 53 21 61 29
4
36  4 44 12 52 20 60 28   35  3 43 11 51 19 59 27
5
34  2 42 10 50 18 58 26   33  1 41  9 49 17 57 25

1
#include <iostream>
2
#include <cstdint>
3
#include <cstring>
4
#include <string>
5
#include <vector>
6
#include <array>
7
#include <stdexcept>
8
#include <iomanip>
9
#include <sstream>
10

11
// ============================================================
12
// DES 常量表
13
// ============================================================
14
namespace tables {
15

16
// IP 初始置换
17
constexpr std::array<uint8_t, 64> IP = {
18
    58,50,42,34,26,18,10, 2, 60,52,44,36,28,20,12, 4,
19
    62,54,46,38,30,22,14, 6, 64,56,48,40,32,24,16, 8,
20
    57,49,41,33,25,17, 9, 1, 59,51,43,35,27,19,11, 3,
21
    61,53,45,37,29,21,13, 5, 63,55,47,39,31,23,15, 7
22
};
23

24
// FP 逆初始置换
25
constexpr std::array<uint8_t, 64> FP = {
26
    40, 8,48,16,56,24,64,32, 39, 7,47,15,55,23,63,31,
27
    38, 6,46,14,54,22,62,30, 37, 5,45,13,53,21,61,29,
28
    36, 4,44,12,52,20,60,28, 35, 3,43,11,51,19,59,27,
29
    34, 2,42,10,50,18,58,26, 33, 1,41, 9,49,17,57,25
30
};
31

32
// E 扩展
33
constexpr std::array<uint8_t, 48> E = {
34
    32, 1, 2, 3, 4, 5,  4, 5, 6, 7, 8, 9,
35
     8, 9,10,11,12,13, 12,13,14,15,16,17,
36
    16,17,18,19,20,21, 20,21,22,23,24,25,
37
    24,25,26,27,28,29, 28,29,30,31,32, 1
38
};
39

40
// P 置换
41
constexpr std::array<uint8_t, 32> P = {
42
    16, 7,20,21,29,12,28,17, 1,15,23,26, 5,18,31,10,
43
     2, 8,24,14,32,27, 3, 9,19,13,30, 6,22,11, 4,25
44
};
45

46
// PC-1 密钥置换
47
constexpr std::array<uint8_t, 56> PC1 = {
48
    57,49,41,33,25,17, 9,  1,58,50,42,34,26,18,
49
    10, 2,59,51,43,35,27, 19,11, 3,60,52,44,36,
50
    63,55,47,39,31,23,15,  7,62,54,46,38,30,22,
51
    14, 6,61,53,45,37,29, 21,13, 5,28,20,12, 4
52
};
53

54
// PC-2 压缩置换
55
constexpr std::array<uint8_t, 48> PC2 = {
56
    14,17,11,24, 1, 5,  3,28,15, 6,21,10,
57
    23,19,12, 4,26, 8, 16, 7,27,20,13, 2,
58
    41,52,31,37,47,55, 30,40,51,45,33,48,
59
    44,49,39,56,34,53, 46,42,50,36,29,32
60
};
61

62
// 循环左移位数表
63
constexpr std::array<uint8_t, 16> SHIFT = {
64
    1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
65
};
66

67
// S 盒
68
constexpr uint8_t SBOX[8][4][16] = {
69
    {{14, 4,13, 1, 2,15,11, 8, 3,10, 6,12, 5, 9, 0, 7},
70
     { 0,15, 7, 4,14, 2,13, 1,10, 6,12,11, 9, 5, 3, 8},
71
     { 4, 1,14, 8,13, 6, 2,11,15,12, 9, 7, 3,10, 5, 0},
72
     {15,12, 8, 2, 4, 9, 1, 7, 5,11, 3,14,10, 0, 6,13}},
73
    {{15, 1, 8,14, 6,11, 3, 4, 9, 7, 2,13,12, 0, 5,10},
74
     { 3,13, 4, 7,15, 2, 8,14,12, 0, 1,10, 6, 9,11, 5},
75
     { 0,14, 7,11,10, 4,13, 1, 5, 8,12, 6, 9, 3, 2,15},
76
     {13, 8,10, 1, 3,15, 4, 2,11, 6, 7,12, 0, 5,14, 9}},
77
    {{10, 0, 9,14, 6, 3,15, 5, 1,13,12, 7,11, 4, 2, 8},
78
     {13, 7, 0, 9, 3, 4, 6,10, 2, 8, 5,14,12,11,15, 1},
79
     {13, 6, 4, 9, 8,15, 3, 0,11, 1, 2,12, 5,10,14, 7},
80
     { 1,10,13, 0, 6, 9, 8, 7, 4,15,14, 3,11, 5, 2,12}},
81
    {{ 7,13,14, 3, 0, 6, 9,10, 1, 2, 8, 5,11,12, 4,15},
82
     {13, 8,11, 5, 6,15, 0, 3, 4, 7, 2,12, 1,10,14, 9},
83
     {10, 6, 9, 0,12,11, 7,13,15, 1, 3,14, 5, 2, 8, 4},
84
     { 3,15, 0, 6,10, 1,13, 8, 9, 4, 5,11,12, 7, 2,14}},
85
    {{ 2,12, 4, 1, 7,10,11, 6, 8, 5, 3,15,13, 0,14, 9},
86
     {14,11, 2,12, 4, 7,13, 1, 5, 0,15,10, 3, 9, 8, 6},
87
     { 4, 2, 1,11,10,13, 7, 8,15, 9,12, 5, 6, 3, 0,14},
88
     {11, 8,12, 7, 1,14, 2,13, 6,15, 0, 9,10, 4, 5, 3}},
89
    {{12, 1,10,15, 9, 2, 6, 8, 0,13, 3, 4,14, 7, 5,11},
90
     {10,15, 4, 2, 7,12, 9, 5, 6, 1,13,14, 0,11, 3, 8},
91
     { 9,14,15, 5, 2, 8,12, 3, 7, 0, 4,10, 1,13,11, 6},
92
     { 4, 3, 2,12, 9, 5,15,10,11,14, 1, 7, 6, 0, 8,13}},
93
    {{ 4,11, 2,14,15, 0, 8,13, 3,12, 9, 7, 5,10, 6, 1},
94
     {13, 0,11, 7, 4, 9, 1,10,14, 3, 5,12, 2,15, 8, 6},
95
     { 1, 4,11,13,12, 3, 7,14,10,15, 6, 8, 0, 5, 9, 2},
96
     { 6,11,13, 8, 1, 4,10, 7, 9, 5, 0,15,14, 2, 3,12}},
97
    {{13, 2, 8, 4, 6,15,11, 1,10, 9, 3,14, 5, 0,12, 7},
98
     { 1,15,13, 8,10, 3, 7, 4,12, 5, 6,11, 0,14, 9, 2},
99
     { 7,11, 4, 1, 9,12,14, 2, 0, 6,10,13,15, 3, 5, 8},
100
     { 2, 1,14, 7, 4,10, 8,13,15,12, 9, 0, 3, 5, 6,11}}
101
};
102

103
} // namespace tables

1
// ============================================================
2
// PKCS#7 填充
3
// ============================================================
4
namespace pkcs7 {
5

6
std::vector<uint8_t> pad(const std::vector<uint8_t>& data, size_t blockSize) {
7
    size_t padLen = blockSize - (data.size() % blockSize);//计算出要填充的长度，用分组大小减去数据取模块大小
8
    std::vector<uint8_t> out = data; //拷贝一份避免修改原数据。
9
    out.insert(out.end(), padLen, static_cast<uint8_t>(padLen));//在out的末尾插入padLen个值为padLen的字节。
10
    //static_cast<uint8_t>(padLen)：把 padLen（size_t 类型）转成 uint8_t，因为 padLen 最大是 16，能放进一个字节。
11
    return out;
12
}
13

14
std::vector<uint8_t> unpad(const std::vector<uint8_t>& data) {
15
    if (data.empty()) throw std::runtime_error("empty data");
16

17
    uint8_t padLen = data.back();  //取最后一个字节，因为填充就是按照长度的数值填充的。
18

19
    if (padLen == 0 || padLen > 8 || padLen > data.size()) {
20
        throw std::runtime_error("invalid PKCS#7 padding");
21
    }
22
    for (size_t i = data.size() - padLen; i < data.size(); ++i) {
23
        if (data[i] != padLen) {
24
            throw std::runtime_error("invalid PKCS#7 padding");
25
        }
26
    }
27
    return std::vector<uint8_t>(data.begin(), data.end() - padLen);//直接返回一个新的数组，减去了填充的长度即为原始数据长度。
28
}
29

30
} // namespace pkcs7

1
// ============================================================
2
// DES 核心类
3
// ============================================================
4
class DES {
5
public:
6
    static constexpr size_t BLOCK_SIZE = 8;
7
    static constexpr size_t KEY_SIZE   = 8;
8

9
    //explicit  关键字，禁止隐式类型转换
10
    explicit DES(const std::vector<uint8_t>& key) {
11
        if (key.size() != KEY_SIZE) {
12
            throw std::invalid_argument("DES key must be 8 bytes");
13
        }
14
        generateSubkeys(key.data()); //这个函数是私有函数，在下面，可能把他放到上面会更好阅读点，这里我的。。。
15
    }
16

17
    void encryptBlock(uint8_t block[BLOCK_SIZE]) const {
18
        processBlock(block, true);
19
    }
20

21
    void decryptBlock(uint8_t block[BLOCK_SIZE]) const {
22
        processBlock(block, false);
23
    }
24

25
private:
26
    uint64_t subkeys_[16]; //
27

28
    // --------------------------------------------------------
29
    // 通用位痣，置换函数（注意断句）
30
    //   table  : 置换表，1-based，第 1 位是 MSB
31
    //   n      : 输出位数
32
    //   in     : 输入值（右对齐，低 inBits 位有效）
33
    //   inBits : 输入的有效位宽
34
    // --------------------------------------------------------
35
    static uint64_t permute(const uint8_t* table, int n,
36
                            uint64_t in, int inBits) {
37
        //该函数的作用就是查找对应的置换表然后将输入数据指定位置的数置换成表里面的数
38
        uint64_t out = 0;
39
        for (int i = 0; i < n; ++i) {
40
            int pos = table[i];
41
            uint64_t bit = (in >> (inBits - pos)) & 1ULL; //获取输入数据pos位的比特数
42
            /*
43
            注意1ULL 就是一个无符号长长整型（unsigned long long）的常量 1。
44
         举个例子
45
         in = 0b1101
46
    pos = 2, inBits = 4
47
    inBits - pos = 2
48
    in >> 2 = 0b11
49
    0b11 & 1 = 1
50
        */
51
            out = (out << 1) | bit;  //把刚取出的 1 个 bit 拼到输出末尾。
52
        }
53
        return out;
54
    }
55

56
    // 28bit 循环左移
57
    static uint32_t rotl28(uint32_t x, int n) {
58
        return ((x << n) | (x >> (28 - n))) & 0x0FFFFFFFU;
59
    }
60

61
    // 密钥扩展
62
    void generateSubkeys(const uint8_t key[KEY_SIZE]) {
63
        using namespace tables;
64

65
        // 1. 大端加载 64bit 密钥
66
        uint64_t key64 = 0;
67
        for (int i = 0; i < 8; ++i) {
68
            key64 = (key64 << 8) | key[i];
69
        }
70

71
        // 2. PC-1: 64 → 56（输入 64bit）
72
        // PC1.data()返回PC1数组第一个元素
73
        uint64_t pc1 = permute(PC1.data(), 56, key64, 64);
74

75
        // 3. 拆 C / D（各 28bit）
76
        uint32_t C = static_cast<uint32_t>((pc1 >> 28) & 0x0FFFFFFFU);
77
        uint32_t D = static_cast<uint32_t>(pc1 & 0x0FFFFFFFU);
78

79
        // 4. 16 轮：左移 + PC-2 压缩
80
        for (int i = 0; i < 16; ++i) {
81
            C = rotl28(C, SHIFT[i]); //循环左移位数也是要查表的记得吗？懂我意思？👌
82
            D = rotl28(D, SHIFT[i]);
83

84
            uint64_t CD = (static_cast<uint64_t>(C) << 28) | D;  // 56bit
85
            // PC-2 的输入是 56bit，不是 64bit，输出是48bit
86
            subkeys_[i] = permute(PC2.data(), 48, CD, 56)
87
                        & 0xFFFFFFFFFFFFULL;
88
        }
89
    }
90

91
    // 轮函数 F
92
    static uint32_t feistel(uint32_t R, uint64_t subkey) {
93
        using namespace tables;
94

95
        // E 扩展：输入 32bit
96
        uint64_t expanded = permute(E.data(), 48, R, 32);
97

98
        // 异或子密钥
99
        expanded ^= subkey;
100

101
        // S 盒：48 → 32，最关键一步
102
        uint32_t sOut = 0;
103
        for (int i = 0; i < 8; ++i) {
104
            int shift = (7 - i) * 6;  //记住咱们s盒是从索引0开始的，每个盒子接受6个bit
105
            uint8_t six = static_cast<uint8_t>((expanded >> shift) & 0x3F);
106
            int row = ((six & 0x20) >> 4) | (six & 0x01); //行号就是首末两bit
107
            int col = (six >> 1) & 0x0F;
108
            uint8_t val = SBOX[i][row][col];
109
            sOut = (sOut << 4) | val;
110
        }
111

112
        // P 置换：输入 32bit
113
        return static_cast<uint32_t>(permute(P.data(), 32, sOut, 32));
114
    }
115

116
    // 单块处理
117
    void processBlock(uint8_t block[BLOCK_SIZE], bool encrypt) const {
118
        using namespace tables;
119

120
        // 1. 大端加载
121
        uint64_t data = 0;
122
        for (int i = 0; i < 8; ++i) {
123
            data = (data << 8) | block[i];
124
        }
125

126
        // 2. IP 置换：输入 64bit
127
        uint64_t ip = permute(IP.data(), 64, data, 64);
128

129
        // 3. 拆 L / R
130
        uint32_t L = static_cast<uint32_t>(ip >> 32);
131
        uint32_t R = static_cast<uint32_t>(ip & 0xFFFFFFFFULL);
132

133
        // 4. 16 轮 Feistel
134
        for (int i = 0; i < 16; ++i) {
135
            int ki = encrypt ? i : (15 - i);
136
            uint32_t F = feistel(R, subkeys_[ki]);
137
            uint32_t newR = L ^ F;
138
            L = R;
139
            R = newR;
140
        }
141

142
        // 5. 左右交换
143
        uint64_t preoutput = (static_cast<uint64_t>(R) << 32) | L;
144

145
        // 6. FP 置换：输入 64bit
146
        uint64_t out = permute(FP.data(), 64, preoutput, 64);
147

148
        // 7. 大端拆回字节
149
        for (int i = 0; i < 8; ++i) {
150
            block[i] = static_cast<uint8_t>((out >> (56 - i * 8)) & 0xFF);
151
        }
152
    }
153
};

1
// ============================================================
2
// ECB 模式
3
// ============================================================
4
class DESECB {
5
public:
6
    explicit DESECB(const std::vector<uint8_t>& key) : des_(key) {}
7

8
    std::vector<uint8_t> encrypt(const std::vector<uint8_t>& plaintext) const {
9
        std::vector<uint8_t> data = pkcs7::pad(plaintext, DES::BLOCK_SIZE);//先对数据进行填充
10
        std::vector<uint8_t> out(data.size()); //声明输出
11

12
        for (size_t i = 0; i < data.size(); i += DES::BLOCK_SIZE) {
13
            uint8_t block[DES::BLOCK_SIZE];
14
            std::memcpy(block, data.data() + i, DES::BLOCK_SIZE);
15
            des_.encryptBlock(block); //ECB就这样，对每个块分别加密
16
            std::memcpy(out.data() + i, block, DES::BLOCK_SIZE);
17
        }
18
        return out;
19
    }
20

21
    std::vector<uint8_t> decrypt(const std::vector<uint8_t>& ciphertext) const {
22
        if (ciphertext.size() % DES::BLOCK_SIZE != 0) {
23
            throw std::invalid_argument("ciphertext size must be multiple of 8");
24
        }
25

26
        std::vector<uint8_t> out(ciphertext.size());
27
        for (size_t i = 0; i < ciphertext.size(); i += DES::BLOCK_SIZE) {
28
            uint8_t block[DES::BLOCK_SIZE];
29
            std::memcpy(block, ciphertext.data() + i, DES::BLOCK_SIZE);
30
            des_.decryptBlock(block);
31
            std::memcpy(out.data() + i, block, DES::BLOCK_SIZE);
32
        }
33
        return pkcs7::unpad(out);
34
    }
35

36
private:
37
    DES des_;
38
};

1
// ============================================================
2
// CBC 模式
3
// ============================================================
4
class DESCBC {
5
public:
6
    DESCBC(const std::vector<uint8_t>& key,
7
           const std::vector<uint8_t>& iv)
8
        : des_(key)
9
    {
10
        if (iv.size() != DES::BLOCK_SIZE) {
11
            throw std::invalid_argument("IV must be 8 bytes");
12
        }
13
        std::memcpy(iv_, iv.data(), DES::BLOCK_SIZE);
14
    }
15

16
    std::vector<uint8_t> encrypt(const std::vector<uint8_t>& plaintext) const {
17
        std::vector<uint8_t> data = pkcs7::pad(plaintext, DES::BLOCK_SIZE);
18
        std::vector<uint8_t> out(data.size());
19

20
        uint8_t prev[DES::BLOCK_SIZE];
21
        std::memcpy(prev, iv_, DES::BLOCK_SIZE); //记录向量
22

23
        for (size_t i = 0; i < data.size(); i += DES::BLOCK_SIZE) {
24
            uint8_t block[DES::BLOCK_SIZE];
25
            for (size_t j = 0; j < DES::BLOCK_SIZE; ++j) {
26
                block[j] = data[i + j] ^ prev[j];
27
            }
28
            des_.encryptBlock(block);
29
            std::memcpy(out.data() + i, block, DES::BLOCK_SIZE);
30
            std::memcpy(prev, block, DES::BLOCK_SIZE); //更新向量用作下一轮的输入向量
31
        }
32
        return out;
33
    }
34

35
    std::vector<uint8_t> decrypt(const std::vector<uint8_t>& ciphertext) const {
36
        if (ciphertext.size() % DES::BLOCK_SIZE != 0) {
37
            throw std::invalid_argument("ciphertext size must be multiple of 8");
38
        }
39

40
        std::vector<uint8_t> out(ciphertext.size());
41

42
        uint8_t prev[DES::BLOCK_SIZE];
43
        std::memcpy(prev, iv_, DES::BLOCK_SIZE);
44

45
        for (size_t i = 0; i < ciphertext.size(); i += DES::BLOCK_SIZE) {
46
            uint8_t block[DES::BLOCK_SIZE];
47
            std::memcpy(block, ciphertext.data() + i, DES::BLOCK_SIZE);
48

49
            uint8_t cipherBlock[DES::BLOCK_SIZE];
50
            std::memcpy(cipherBlock, block, DES::BLOCK_SIZE);
51

52
            des_.decryptBlock(block);
53
            for (size_t j = 0; j < DES::BLOCK_SIZE; ++j) {
54
                out[i + j] = block[j] ^ prev[j];  //异或反运算就是异或
55
            }
56
            std::memcpy(prev, cipherBlock, DES::BLOCK_SIZE);
57
        }
58
        return pkcs7::unpad(out);
59
    }
60

61
private:
62
    DES des_;
63
    uint8_t iv_[DES::BLOCK_SIZE];
64
};