前言

在南邮的第二年里，终于接触到了密码学这部分内容。而第一次实验课，我们在老师的指导下完成了对恩尼格玛（Enigma）机的算法模拟就充满了挑战与乐趣。

基本原理

在我们的密码学课程中，首先接触的就是古典密码学，具体包括置换密码和代换密码。虽然没有融入复杂的数学算法，但是置换和代换的思想却是密码学的核心，一直伴随着密码学的发展。

而恩尼格玛机是古典代换密码的集大成者，通过迭代和多表代换的方式，将古典密码的内涵发扬的淋漓精致。该机器确切地说，是对二战时期纳粹德国使用的一系列相似的转子机械加解密机器的统称，它包括了许多不同的型号，为密码学对称加密算法的流加密的的典型。而且实际加密转轮机的精密和反射器的加密解密一体的设计更是将这一机器推向更高的高度。关于具体的加密算法步骤，本文就不过多介绍，很多相关文章都已经将转轮机的原理介绍的很详细了。

实现思路

在这次实验中，要求我们实现以下转轮机的加密解密过程：

在本次实验中，我运用的是python语言，因为我认为python里的字典数据类型可以很好的刻画转轮机中三个轮子间的一一对应关系。程序的主要部分包括：映射表、密钥设置函数、位移函数、反向位移函数、加密函数、解密函数、控制流程页面。

首先，映射表可以表达出三个轮子的对应关系，由于是三个轮子（慢，中，快三个轮子）和最后的输入输出组成的，所以一共有四种不同的对应关系，我用l_table,m_table,s_able,f_table表示它们，具体过程并不复杂，只需要写出四个字典就完成了。

然后，位移函数和反向位移函数是指转轮机在每次输出一个密文字符之后，都会改变原本的对应关系。所以位移函数的作用就是模拟轮子转动，改变映射表，使其向下位移一格，而反向位移函数，就是使得映射表向上位移一格，这在解密过程中会用到。

接着，密钥设置是模拟实际情况，说白了就是在输入密码之前，可以任意设置三个轮子的初始映射关系，我用k1,k2,k3分别表示快，中，慢三个轮子的初始位移量，这样可以使得加密系统更加多元复杂。

再接着，加密解密函数就是程序的核心部分，每一次明文字符依次通过前三个轮子的映射关系，从而得到密文字符。并且转动一次快轮子（中轮子和慢轮子也会依次变化），保证下一个明文字符会通过一个不同的加密映射表继续加密。而解密就是其逆过程，运用了字典键值对互换，列表倒序等算法。

最后，就是控制流程页面，这个就是使得上述过程流程化输入输出，并不需要过多介绍。

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
# 转轮机映射表
l_table = {'a': 24, 'b': 25, 'c': 26, 'd': 1, 'e': 2, 'f': 3, 'g': 4, 'h': 5, 'i': 6, 'j': 7, 'k': 8, 'l': 9, 'm': 10,
           'n': 11, 'o': 12, 'p': 13, 'q': 14, 'r': 15, 's': 16, 't': 17, 'u': 18, 'v': 19, 'w': 20, 'x': 21, 'y': 22,
           'z': 23}
m_table = {21: 26, 3: 1, 15: 2, 1: 3, 19: 4, 10: 5, 14: 6, 26: 7, 20: 8, 8: 9, 16: 10, 7: 11, 22: 12, 4: 13, 11: 14,
           5: 15, 17: 16, 9: 17, 12: 18, 23: 19, 18: 20,
           2: 21, 25: 22, 6: 23, 24: 24, 13: 25}
s_table = {20: 26, 1: 1, 6: 2, 4: 3, 15: 4, 3: 5, 14: 6, 12: 7, 23: 8, 5: 9, 16: 10, 2: 11, 22: 12, 19: 13, 11: 14,
           18: 15, 25: 16, 24: 17, 13: 18, 7: 19, 10: 20,
           8: 21, 21: 22, 9: 23, 26: 24, 17: 25}
f_table = {14: 'a', 8: 'b', 18: 'c', 26: 'd', 17: 'e', 20: 'f', 22: 'g', 10: 'h', 3: 'i', 13: 'j', 11: 'k', 4: 'l',
           23: 'm', 5: 'n', 24: 'o', 9: 'p',
           12: 'q', 25: 'r', 16: 's', 19: 't', 6: 'u', 15: 'v', 21: 'w', 2: 'x', 7: 'y', 1: 'z'}


# 密钥设置函数
def key(k1, k2, k3):
    global s_table, m_table, l_table, f_table
    while k1 != 0:
        k1 = k1 - 1
        l_table, m_table = move(l_table, m_table)
    while k2 != 0:
        k2 = k2 - 1
        m_table, s_table = move(m_table, s_table)
    while k3 != 0:
        k3 = k3 - 1
        s_table, f_table = move(s_table, f_table)


# 移位算法函数
def move(dict1, dict2):
    values = list(dict1.values())
    last_value1 = values.pop()  # 移除最后一个值
    values.insert(0, last_value1)  # 将它插入到列表的开始位置
    for key, value in zip(dict1.keys(), values):
        dict1[key] = value

    dict2 = {value: key for key, value in dict2.items()}
    values = list(dict2.values())
    last_value2 = values.pop()  # 移除最后一个值
    values.insert(0, last_value2)  # 将它插入到列表的开始位置
    for key, value in zip(dict2.keys(), values):
        dict2[key] = value
    dict2 = {value: key for key, value in dict2.items()}
    return dict1, dict2


def s_move(dict1, dict2):
    values = list(dict1.values())
    first_value1 = values.pop(0)
    values.append(first_value1)
    for key, value in zip(dict1.keys(), values):
        dict1[key] = value

    dict3 = {value: key for key, value in dict2.items()}
    values = list(dict3.values())
    first_value3 = values.pop(0)
    values.append(first_value3)
    for key, value in zip(dict3.keys(), values):
        dict3[key] = value
    dict4 = {value: key for key, value in dict3.items()}
    return dict1, dict4


# 加密算法
def encrypt(charlist_p):
    global s_table, m_table, l_table, f_table
    s_num = 0
    m_num = 0
    l_num = 0
    charlist_c = []

    for n in charlist_p:
        if ord(n) < 97 or ord(n) > 122:
            charlist_c.append(n)
            continue
        n = l_table[n]
        n = m_table[n]
        n = s_table[n]
        n = f_table[n]
        charlist_c.append(n)
        s_num = s_num + 1

        s_table, f_table = move(s_table, f_table)
        if s_num == 26:
            s_num = 0
            m_num = m_num + 1
            m_table, s_table = move(m_table, s_table)
        if m_num == 26:
            m_num = 0
            l_num = l_num + 1
            l_table, m_table = move(l_table, m_table)
        if l_num == 26:
            l_num = 0
    c = ''.join(charlist_c)
    print(l_num, m_num, s_num)
    return c


# 解密算法
def decrypt(charlist_c, k1, k2, k3):
    global s_table, m_table, l_table, f_table
    i = 1
    charlist_p = []
    key(k1, k2, k3)

    for n in charlist_c:
        if ord(n) < 97 or ord(n) > 122:
            charlist_p.append(n)
            continue
        s_f_table = {value: key for key, value in f_table.items()}
        s_s_table = {value: key for key, value in s_table.items()}
        s_m_table = {value: key for key, value in m_table.items()}
        s_l_table = {value: key for key, value in l_table.items()}
        n = s_f_table[n]

        n = s_s_table[n]

        n = s_m_table[n]

        n = s_l_table[n]

        charlist_p.append(n)
        if k3 != 0:
            k3 = k3 - 1
            s_table, f_table = s_move(s_table, f_table)
        elif k3 == 0:
            if k2 != 0:
                k2 = k2 - 1
                k3 = 26
                k3 = k3 - 1
                s_table, f_table = s_move(s_table, f_table)
                m_table, s_table = s_move(m_table, s_table)
            elif k2 == 0:
                if k1 != 0:
                    k1 = k1 - 1
                    k2 = 25
                    k3 = 26
                    k3 = k3 - 1
                    l_table, m_table = s_move(l_table, m_table)
                    m_table, s_table = s_move(m_table, s_table)
                    s_table, f_table = s_move(s_table, f_table)
    charlist_p.reverse()
    p = ''.join(charlist_p)

    return p


# 用户选择界面
print("欢迎使用Weiky-Enigma转轮机！！\n请输入密钥：\n")
k1 = int(input())
k2 = int(input())
k3 = int(input())

print(m_table, s_table)
choice = input("1. 加密\n2. 解密\n"
               "请输入1或2：")
if choice == '1':
    key(k1, k2, k3)
    p = input("请输入要加密的数据：")
    p = p.lower()
    charlist_p = list(p)
    c = encrypt(charlist_p)
    print(f'加密结果为：\n{c}')
elif choice == '2':
    c = input("请输入要解密的内容：")
    length = len([char for char in c if char.isalpha()])
    length = (k1 * 26 * 26 + k2 * 26 + k3) + length - 1
    print(length)
    k1 = length // (26 * 26)
    k2 = (length % (26 * 26)) // 26
    k3 = (length % (26 * 26)) % 26
    c = c.lower()
    charlist_c = list(c)
    charlist_c.reverse()
    p = decrypt(charlist_c, k1, k2, k3)
    print(f'解密结果为：\n{p}')
else:
    print("无效的选择，请输入1或2。")

测试

实验要求我们加密以下文本内容：

明文：

cryptology, science concerned with data communication and storage in secure and usually secret form. It encompasses both cryptography and cryptanalysis.

Cryptography was originally the study of the principles and techniques by which information could be concealed in ciphers and later revealed by legitimate users employing the secret key.

It now encompasses the whole area of key-controlled transformations of information into forms that are either impossible or computationally infeasible for unauthorized persons to duplicate or undo.

Cryptanalysis (from the Greek kryptós and analýein, “to loosen” or “to untie”) is the science (and art) of recovering or forging cryptographically secured information without knowledge of the key. Cryptology is often—and mistakenly—considered a synonym for cryptography and occasionally for cryptanalysis, but specialists in the field have for years adopted the convention that cryptology is the more inclusive term, encompassing both cryptography and cryptanalysis.

Cryptography was initially only concerned with providing secrecy for written messages, especially in times of war. Its principles apply equally well, however, to securing data flowing between computers or data stored in them, to encrypting facsimile and television signals, to verifying the identity of participants in electronic commerce (e-commerce) and providing legally acceptable records of those transactions. Because of this broadened interpretation of cryptography, the field of cryptanalysis has also been enlarged.

This article discusses the basic elements of cryptology, delineating the principal systems and techniques of cryptography as well as the general types and procedures of cryptanalysis. It also provides a concise historical survey of the development of cryptosystems and cryptodevices. A brief introduction is also given to the revolution in cryptology brought on by the information age, e-commerce, and the Internet. For additional information on the encoding and encryption of facsimile and television signals and of computer data, see telecommunications system and information processing.

带入上述模拟恩尼格玛转轮机的代码，可以得出以下密文：

Tipmymzipx, rmscqak oeclurmmt frko fqxe enpejhfpjrorl vis btqssmo yo zggigu mkp pljpkfz acptfv hmfh. nr yihimnwkevb alng zersrbqxuapb pun tmwxwigbuemrx.

Sriazhlbppfu aar qcztsvhosb eiq apfud bn ndc kasfurrsmv niq yjmfpnhzbt ge xeysy pgnqjddvrfh nftdw ha acnumaszq nu gwljffe jfa ctrnc ihgylrlu ad ifwaqzkzqn zqjkd lwwdqbifs wom ofhewy ynl.

Uh uwp vjjpozfxfly ppe jyvtt iqav lp gef-avbucrjdtl zrjvraugptymjhh iq wtkcwyaqnbz lytm egtmp amdj ltw rddnrb woigihxiey tp cwkoljrecnpczxl ujrboxoodt zrx ffsswqdwtmws xqeapgq qw bdjtzlrky yg vvxz.

Flxxtmgwztmtj (raeh fgy ogang qbnwwót xkd jsvbýhtc, “rp dwjxte” xe “ku bfhbb”) uc iwm cphcoku (dgu myh) tr sdnlptaejn pv rrtmkgk tdbnrbhgxpacvigee ctarnzp jgdovwmyqim hfbpeao qpbyusoxa gu sbk jeq. miykxlsieg fv dqblj—icm yuwaxgtswi—qfelbnxzop w dwdllfi ncn mkplmmekpaib vyf swavbjrdwjmw fhw rvdrwczbrveqw, dlp yhamsyydrrm yl cgi xzzij orec jkc xdyiv gznuoqw mjc pqcmtrniuh arts bezhcnldsh rm fhf sozo sowmmvqrz vzcb, afvwyvmuoxzq frsp mulmbuzcqbnf hqo azomgysoalctv.

Qiivszqnmfpq oyu djqtkdoen opki yoqpfbeqe tvoy amfkhnuze qxkclcj eym ffwapec xuzcongt, yfaquidlvp zh xtdyi pz gyp. sao nkcippstlo antuv wjlmbza lynd, bsvnqcu, kg xpvycmgg uopz orlzgkf kkpvnxb xuyjttjhh bb npum zmollk jm rrbk, am moladcmcsx bbckriyuu xfr nrgmthhezl srubmko, yi zeoysclgu ybw atibgdzx mq eyumjieskwci eg dfrvozzyac alqlyihs (a-msazuaow) btr qifvywpfd wovifpw qnxwyrcvdg zugygan pi iuawb glnbfckvhjyx. nemvhrp aj nvmv zfygwrfeg suloogyutfglul nv mrskforymnke, eec orsrr vw brkuugbiepnnh woz ntpn gbew xmsgrlxo.

Dvad smzkaza nwuknrpcj vjn gubst mpeexogt ca yllvshkiqt, wauulxbgvxq mco hmttaqrgm uyrjgtc cpb mjiibughwl vy otemnhzpavvf tp rqer dx qlf qmoxiki fapju cip ddlvdqmlyj mq whszpxanhwnlo. uu ecxl cmuktzxi j khzbfqw qhbelzdyrt bewavz cd pqx vfgsewgfcqr vr iopwnnrbzekng cnb wpqszbibawsqe. n rtosb fsryyxhdmlno nz lpho pqxee mt wfc tvrfsqsudd ff kcopdaohot ltiwohr tj mx epy oiddwqqbblh cul, y-cpuokpoi, kom tsc pcalneuv. gjc vgwqijvgwd uikvbojkcej yt prt wnsadeoy nfx axcxxpospn jc klhxcuvyt ofy mmelyjwavz oqjrkyv mvg oq pzgmnttu vytv, zer emrfnpcreiprmgkvnp yashhi eeb gpuxxjbwsrs yhgrxrzvgw.

接着的内容是对于第一段内容加解密的图片详细演示：

结尾

恩尼格玛机在密码发展的历史长卷中只是普通的一页，但却使得我也受阻重重，纸上得来终觉浅，绝知此事要躬行，课本上的密码看上去易，但唯有实践才能理解它们的威力。