文章目录

• • 一、替代密码
  • • 1、要求
    • 2、代码实现
    • 3、演示效果
  • 二、置换密码
  • • 1、要求
    • 2、代码实现
    • 3、演示效果

一、替代密码

1、要求

替代密码算法的原理是使用替代法进行加密，就是对明文中的字符用其他字符替代后形成密文。例如，明文字母a, b, c, d, 用d, e, f , g做对应替换后形成密文。
替代密码包括多种类型，如单表替代密码，多表替代密码，多字母替代密码等。试编程实现一种典型的单表替代密码—凯撒（Caesar）密码。它的加密方法是将明文中的每个字母用此字符在字母表中后面的第k个字母替代。它的加密过程可以表示为下面的函数：
E(k)=(m+k)mod n
其中，m为明文字母在字母表中的位置数，n为字母表中的字母个数，k为密钥，E(k)为密文字母在字母表中对应的位置数。
解密过程类推。

2、代码实现

# 加密
def encrypt():
   print("-------------加密过程-------------")
   text = input("请输入明文:")
   s = int(input("请输入秘钥:"))
   result = ""
   # transverse the plain text
   for i in range(len(text)):
      char = text[i]
      # Encrypt uppercase characters in plain text
      if (char.isupper()):
         result += chr((ord(char) + s-65) % 26 + 65)
      # Encrypt lowercase characters in plain text
      else:
         result += chr((ord(char) + s - 97) % 26 + 97)
   print("加密后的结果为：",result)
   print("--------------------------------")
   return result

# 解密
def decrypt():
    print("-------------解密过程-------------")
    text = input("请输入密文:")
    s = int(input("请输入秘钥:"))
    result = ""
    # transverse the plain text
    for i in range(len(text)):
        char = text[i]
        # Encrypt uppercase characters in plain text
        if (char.isupper()):
            result += chr((ord(char) - s - 65) % 26 + 65)
        # Encrypt lowercase characters in plain text
        else:
            result += chr((ord(char) - s - 97) % 26 + 97)
    print("解密后的结果为：", result)
    print("--------------------------------")
    return result


# 主函数
def main():
    x = input("请选择模式（1.加密 2.解密 3.退出）:")
    while True:
        if x == "1":
            encrypt()
            x = input("请选择模式（1.加密 2.解密 3.退出）:")
        elif x == "2":
            decrypt()
            x = input("请选择模式（1.加密 2.解密 3.退出）:")
        elif x == "3":
            break
        else:
            break

if __name__ == '__main__':
    main()

3、演示效果

代码实现替代密码中单表替代密码—凯撒（Caesar）密码的加密与解密
加密文本：

解密密文：

二、置换密码

1、要求

置换密码算法的原理是不改变明文字符，只将字符在明文中的排列顺序改变，从而实现明文信息的加密。置换密码也叫换位密码。
试编程实现矩阵换位密码。它的加密方法是将明文中的字母按照给定的顺序安排在一个矩阵中，然后用根据密钥提供的顺序重新组合矩阵中的字母，形成密文。例如，明文为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
解密过程类推。

2、代码实现

#调用的包
from copy import deepcopy

# 处理密钥获取密钥的长度及顺序
def processSecretKey(s):
    sLength = len(s)
    tempList = []
    for i in range(len(s)):
        char = s[i]
        # tempList存入密钥单词中字母的ascii码值
        tempList.append(ord(char))
    # tempList2用于存储密钥单词每个字母在列表的顺序
    sKey = []
    # sort_tempList用于存储排序后的tempList
    sort_tempList = sorted(tempList)
    for index_,value in enumerate(tempList):
        sKey.append(sort_tempList.index(value)+1)

    return sKey,sLength

# 加密
def encrypt():
    print("-------------加密过程-------------")
    text = input("请输入明文:")
    s = str(input("请输入秘钥:"))
    # 除去明文中的空格
    tempList = text.split(" ")
    newText = "".join(tempList)
    # 获取处理后明文的长度
    textLength = len(newText)
    # print("text:",newText)
    # 获取密钥及密钥长度
    sKey,sLength = processSecretKey(s)
    # print(f"sLength:{sLength}")
    # print(f"sKey:{sKey}")

    # 对于长度不够处理后的明文进行补A处理
    while textLength % sLength != 0:
        newText+="A"
        textLength = textLength + 1

    # 更新处理后明文的长度
    textLength = len(newText)
    # print(f"textLength:{textLength}")

    # 根据密钥的长度对明文进行分割
    counter = 1
    temp = []
    tmp = []
    for item_ in newText:
        if  (counter % (sLength) != 0):
            tmp.append(item_)
            counter+=1

        elif  (counter % (sLength) == 0):
            tmp.append(item_)
            temp.append(tmp)
            tmp=[]
            counter+=1

    print("明文矩阵为：")

    # 根据密钥对明文进行移位
    for item_ in temp:
        print(item_)
        # [Python中的深复制浅复制（等号赋值、copy和deepcopy的区别）](https://blog.csdn.net/weixin_39750084/article/details/81435454)
        item_copy = deepcopy(item_)
        # print("加密前：",item_)
        for i in range(len(item_)):
            item_[i] = item_copy[sKey[i]-1]
        # print("加密后：",item_)

    # 对移位后的明文进行拼接形成密文
    print("加密后的密文矩阵为:")
    string = ''
    for item_ in temp:
        print(item_)
        string+="".join(item_)
    print("加密后的结果为：", string)
    print("--------------------------------")


# 解密
def decrypt():
    print("-------------解密过程-------------")
    text = input("请输入密文:")
    s = str(input("请输入秘钥:"))
    # 获取密钥及密钥长度
    sKey, sLength = processSecretKey(s)
    # print(f"sLength:{sLength}")
    # print(f"sKey:{sKey}")

    # 根据密钥的长度对密文进行分割
    newText = text
    counter = 1
    temp = []
    tmp = []
    for item_ in newText:
        if (counter % (sLength) != 0):
            tmp.append(item_)
            counter += 1

        elif (counter % (sLength) == 0):
            tmp.append(item_)
            temp.append(tmp)
            tmp = []
            counter += 1
    # print(temp)

    print("密文矩阵为：")
    # 根据密钥对密文进行移位复原
    for item_ in temp:
        print(item_)
        # [Python中的深复制浅复制（等号赋值、copy和deepcopy的区别）](https://blog.csdn.net/weixin_39750084/article/details/81435454)
        item_copy = deepcopy(item_)
        # print("解密前：",item_)
        for i in range(len(item_)):
            item_[sKey[i] - 1] = item_copy[i]
        # print("解密后：",item_)

    # 对移位复原后的密文进行拼接形成明文
    print("解密后的明文矩阵为:")
    string = ''
    for item_ in temp:
        print(item_)
        string += "".join(item_)
    #  除去尾部可能出现的A
    string.strip("A")
    print("解密后的结果为：", string)
    print("--------------------------------")


def main():
    x = input("请选择模式（1.加密 2.解密 3.退出）:")
    while True:
        if x == "1":
            encrypt()
            x = input("请选择模式（1.加密 2.解密 3.退出）:")
        elif x == "2":
            decrypt()
            x = input("请选择模式（1.加密 2.解密 3.退出）:")
        elif x == "3":
            break
        else:
            break

if __name__ == '__main__':
    # 明文:attack begins at five   秘钥:cipher
    main()

3、演示效果

2、代码实现换位密码
加密文本：

解密密文：