古典暗码算法实验

一、实验名称

  

古典暗码算法

  

二、实验目的及要求

  

1.实验目的：

  

通过编程实现替换暗码算法和置换暗码算法，加深对古典暗码体制的了解。

  

2.实验要求：

  

根据实验内容完成任务，暗码算法的加密和解密过程，要求加密过程的明文和密钥、解密过程的密文和密钥由用户手动任意输入，并且以包含本人姓名的字符串作为明文输入，凯撒暗码的密钥数字为本人学号的后两位，矩阵换位暗码的密钥为下一学号学生的姓名去重复全凭，分别演示加密算法和解密算法的执行结果。 

  

三、实验环境

  

Windows10,Pycharm

  四、实验设计
  内容要求：
  

• 实验原理与内容
  

  

古典暗码算法曾被广泛应用， 大都比较简单， 利用手工和机械操作来实现加密和解密。

  

（1）替换暗码

  

替换暗码算法的原理是利用替换法进行加密，就是对明文中的字符用其他字符替换后形 成密文。比方， 明文字母 a, b, c, d,  用 d, e, f , g 做对应替换后形成密文。

  

替换暗码包括多种类型， 如单表替换暗码，多表替换暗码，多字母替换暗码等。 试编程 实现一种典型的单表替换暗码—凯撒(Caesar) 暗码。它的加密方法是将明文中的每个字母 用此字符在字母表中背面的第 k 个字母替换。它的加密过程可以表示为下面的函数：

  

E(k)=(m+k)modn

  

其中， m 为明文字母在字母表中的位置数，n 为字母表中的字母个数， k 为密钥， E(k) 为密文字母在字母表中对应的位置数。

  

解密过程类推。

  

（2）置换暗码

  

置换暗码算法的原理是不改变明文字符， 只将字符在明文中的排列顺序改变，从而实现明文信息的加密。置换暗码也叫换位暗码。

  

试编程实现矩阵换位暗码。它的加密方法是将明文中的字母按照给定的顺序安排在一个 矩阵中，然后用根据密钥提供的顺序重新组合矩阵中的字母，形成密文。比方，明文为 attack begins at five，密钥为 cipher，将明文按照每行 6 个字母的形式排在矩阵中， 如下形式：

  

a      t     t      a     c      k

  

b      e     g      i     n      s

  

a      t     f      i     v      e

  

根据密钥 cipher 中各字母在字母表中出现的先后顺序，给定一个置换：

  

  

根据上面的置换，将原有矩阵中的字母按照第 1 、4、5 、3、2、6 的顺序排列，则有下

列形式：

a      a      c      t     t      k

b      i      n      g      e      s

a      i      v      f     t      e

从而得到密文： aacttkbingesaivfte

解密过程类推。

• 实验步调
  

（1）根据实验原理部分对替换暗码算法的先容,自己创建明文信息,并选择一个密钥k,编写替换暗码算法的实现步调,实现加密和解密操作。 

（2）根据实验原理部分对置换暗码算法的先容,自己创建明文信息,并选择一个密钥,编写置换暗码算法的实现步调,实现加密和解密操作。

3、实验结果

  （1）替换暗码

加密：

 

解密：

 

置换暗码：

加密：

 

解密：

 

4、实验总结

通过本次实验，把握了古典暗码算法的根本原理，在本次实验中，我们学习了替换暗码和置换暗码两种古典暗码算法，并进行了加密和解密的实验。
通过本次实验，我了解到古典暗码算法的根本原理和加密过程。凯撒暗码是一种简单的替换暗码，通过将明文中的每个字母按照肯定的偏移量进行替换，得到密文。而置换暗码则是将明文中的每个字母先辈行一次线性变更，再进行一次替换，得到密文。这两种算法都有肯定的安全性，但是随着计算机技术的发展，它们的安全性已经被攻击者所破解。
在实验中，我还学习了Python语言的根本语法和编程技巧，把握了Python实现替换暗码和置换暗码的方法。通过编写代码，我深入理解了算法的实现过程和原理，同时也提高了自己的编程能力。
总的来说，本次实验让我对古典暗码算法有了更深入的了解，同时也提高了我的编程能力。在今后的学习和工作中，我将继续学习和把握更多的暗码算法和编程技巧，为保障信息安全做出自己的贡献。

替换暗码：

1. # 加密
2. def encrypt():
3.     print("-------------加密过程-------------")
4.     text = input("请输入明文:")
5.     s = int(input("请输入秘钥:"))
6.     result = ""
7.     # transverse the plain text
8.     for i in range(len(text)):
9.         char = text[i]
10.         # Encrypt uppercase characters in plain text
11.         if (char.isupper()):
12.             result += chr((ord(char) + s-65) % 26 + 65)
13.         # Encrypt lowercase characters in plain text
14.         else:
15.             result += chr((ord(char) + s - 97) % 26 + 97)
16.     print("加密后的结果为：",result)
17.     print("--------------------------------")
18.     return result
20. # 解密
21. def decrypt():
22.     print("-------------解密过程-------------")
23.     text = input("请输入密文:")
24.     s = int(input("请输入秘钥:"))
25.     result = ""
26.     # transverse the plain text
27.     for i in range(len(text)):
28.         char = text[i]
29.         # Encrypt uppercase characters in plain text
30.         if (char.isupper()):
31.             result += chr((ord(char) - s - 65) % 26 + 65)
32.         # Encrypt lowercase characters in plain text
33.         else:
34.             result += chr((ord(char) - s - 97) % 26 + 97)
35.     print("解密后的结果为：", result)
36.     print("--------------------------------")
37.     return result
39. # 主函数
40. def main():
41.     x = input("请选择模式（1.加密 2.解密 3.退出）:")
42.     while True:
43.         if x == "1":
44.             encrypt()
45.             x = input("请选择模式（1.加密 2.解密 3.退出）:")
46.         elif x == "2":
47.             decrypt()
48.             x = input("请选择模式（1.加密 2.解密 3.退出）:")
49.         elif x == "3":
50.             break
51.         else:
52.             break
54. if __name__ == '__main__':
55.     main()

复制代码

置换暗码：

1. #调用的包
2. from copy import deepcopy
4. # 处理密钥获取密钥的长度及顺序
5. def processSecretKey(s):
6.     sLength = len(s)
7.     tempList = []
8.     for i in range(len(s)):
9.         char = s[i]
10.         # tempList存入密钥单词中字母的ascii码值
11.         tempList.append(ord(char))
12.     # tempList2用于存储密钥单词每个字母在列表的顺序
13.     sKey = []
14.     # sort_tempList用于存储排序后的tempList
15.     sort_tempList = sorted(tempList)
16.     for index_,value in enumerate(tempList):
17.         sKey.append(sort_tempList.index(value)+1)
19.     return sKey,sLength
21. # 加密
22. def encrypt():
23.     print("-------------加密过程-------------")
24.     text = input("请输入明文:")
25.     s = str(input("请输入秘钥:"))
26.     # 除去明文中的空格
27.     tempList = text.split(" ")
28.     newText = "".join(tempList)
29.     # 获取处理后明文的长度
30.     textLength = len(newText)
31.     # print("text:",newText)
32.     # 获取密钥及密钥长度
33.     sKey,sLength = processSecretKey(s)
34.     # print(f"sLength:{sLength}")
35.     # print(f"sKey:{sKey}")
37.     # 对于长度不够处理后的明文进行补A处理
38.     while textLength % sLength != 0:
39.         newText+="X"
40.         textLength = textLength + 1
42.     # 更新处理后明文的长度
43.     textLength = len(newText)
44.     # print(f"textLength:{textLength}")
46.     # 根据密钥的长度对明文进行分割
47.     counter = 1
48.     temp = []
49.     tmp = []
50.     for item_ in newText:
51.         if  (counter % (sLength) != 0):
52.             tmp.append(item_)
53.             counter+=1
55.         elif  (counter % (sLength) == 0):
56.             tmp.append(item_)
57.             temp.append(tmp)
58.             tmp=[]
59.             counter+=1
61.     print("明文矩阵为：")
63.     # 根据密钥对明文进行移位
64.     for item_ in temp:
65.         print(item_)
66.         item_copy = deepcopy(item_)
67.         # print("加密前：",item_)
68.         for i in range(len(item_)):
69.             item_[i] = item_copy[sKey[i]-1]
70.         # print("加密后：",item_)
72.     # 对移位后的明文进行拼接形成密文
73.     print("加密后的密文矩阵为:")
74.     string = ''
75.     for item_ in temp:
76.         print(item_)
77.         string+="".join(item_)
78.     print("加密后的结果为：", string)
79.     print("--------------------------------")
82. # 解密
83. def decrypt():
84.     print("-------------解密过程-------------")
85.     text = input("请输入密文:")
86.     s = str(input("请输入秘钥:"))
87.     # 获取密钥及密钥长度
88.     sKey, sLength = processSecretKey(s)
89.     # print(f"sLength:{sLength}")
90.     # print(f"sKey:{sKey}")
92.     # 根据密钥的长度对密文进行分割
93.     newText = text
94.     counter = 1
95.     temp = []
96.     tmp = []
97.     for item_ in newText:
98.         if (counter % (sLength) != 0):
99.             tmp.append(item_)
100.             counter += 1
102.         elif (counter % (sLength) == 0):
103.             tmp.append(item_)
104.             temp.append(tmp)
105.             tmp = []
106.             counter += 1
107.     # print(temp)
109.     print("密文矩阵为：")
110.     # 根据密钥对密文进行移位复原
111.     for item_ in temp:
112.         print(item_)
113.         item_copy = deepcopy(item_)
114.         # print("解密前：",item_)
115.         for i in range(len(item_)):
116.             item_[sKey[i] - 1] = item_copy[i]
117.         # print("解密后：",item_)
119.     # 对移位复原后的密文进行拼接形成明文
120.     print("解密后的明文矩阵为:")
121.     string = ''
122.     for item_ in temp:
123.         print(item_)
124.         string += "".join(item_)
125.     #  除去尾部可能出现的X
126.     string.strip("X")
127.     print("解密后的结果为：", string)
128.     print("--------------------------------")
131. def main():
132.     x = input("请选择模式（1.加密 2.解密 3.退出）:")
133.     while True:
134.         if x == "1":
135.             encrypt()
136.             x = input("请选择模式（1.加密 2.解密 3.退出）:")
137.         elif x == "2":
138.             decrypt()
139.             x = input("请选择模式（1.加密 2.解密 3.退出）:")
140.         elif x == "3":
141.             break
142.         else:
143.             break
145. if __name__ == '__main__':
146.     main()

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。