0
0

古典密码算法实验

一、实验****名称

古典密码算法

二****、实验目的及要求

1.实验目的：

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

2.实验要求：

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

三****、实验环境

Windows10,Pycharm

四、实验****设计

内容要求：

  1. 实验****原理与内容

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

（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. 实验****步骤

（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("--------------------------------")
  81. # 解密
  82. def decrypt():
  83.     print("-------------解密过程-------------")
  84.     text = input("请输入密文:")
  85.     s = str(input("请输入秘钥:"))
  86.     # 获取密钥及密钥长度
  87.     sKey, sLength = processSecretKey(s)
  88.     # print(f"sLength:{sLength}")
  89.     # print(f"sKey:{sKey}")
  91.     # 根据密钥的长度对密文进行分割
  92.     newText = text
  93.     counter = 1
  94.     temp = []
  95.     tmp = []
  96.     for item_ in newText:
  97.         if (counter % (sLength) != 0):
  98.             tmp.append(item_)
  99.             counter += 1
  101.         elif (counter % (sLength) == 0):
  102.             tmp.append(item_)
  103.             temp.append(tmp)
  104.             tmp = []
  105.             counter += 1
  106.     # print(temp)
  108.     print("密文矩阵为：")
  109.     # 根据密钥对密文进行移位复原
  110.     for item_ in temp:
  111.         print(item_)
  112.         item_copy = deepcopy(item_)
  113.         # print("解密前：",item_)
  114.         for i in range(len(item_)):
  115.             item_[sKey[i] - 1] = item_copy[i]
  116.         # print("解密后：",item_)
  118.     # 对移位复原后的密文进行拼接形成明文
  119.     print("解密后的明文矩阵为:")
  120.     string = ''
  121.     for item_ in temp:
  122.         print(item_)
  123.         string += "".join(item_)
  124.     #  除去尾部可能出现的X
  125.     string.strip("X")
  126.     print("解密后的结果为：", string)
  127.     print("--------------------------------")
  129. def main():
  130.     x = input("请选择模式（1.加密 2.解密 3.退出）:")
  131.     while True:
  132.         if x == "1":
  133.             encrypt()
  134.             x = input("请选择模式（1.加密 2.解密 3.退出）:")
  135.         elif x == "2":
  136.             decrypt()
  137.             x = input("请选择模式（1.加密 2.解密 3.退出）:")
  138.         elif x == "3":
  139.             break
  140.         else:
  141.             break
  143. if __name__ == '__main__':
  144.     main()
标签： 算法 python 密码学
本文转载自: https://blog.csdn.net/qq_62760217/article/details/130457916
版权归原作者 qq_62760217 所有， 如有侵权，请联系我们删除。
登录后发布评论

“古典密码算法实验”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航
没有找到文章内容分段。。。