python实现替代密码与置换密码
Posted booze-J
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python实现替代密码与置换密码相关的知识，希望对你有一定的参考价值。
文章目录
一、替代密码
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、代码实现换位密码
加密文本：
解密密文：
java实现列置换密码
package Demo_01;
public class Cipher_Main {
public static void main(String[] args) {
//明文
String p = "Beijing2008OlympicGames";
//秘钥
int[][] key = {{1,4,3},{5,6}};
String cip =permutationCipher.run(p, key);
System.out.println(cip);
// int[][] rekey = decryptKey.run(key);
//
// String cy =permutationCipher.run(cip, rekey);
//
// System.out.println(cy);
//
//
//
//
}
}
package Demo_01;
public class permutationCipher {
public static String run(String p,int[][] key) {
// //明文
// String p = "Beijing2008OlympicGames";
//
// //秘钥
// int[][] key = {{1,4,3},{5,6}};
//得到最大列
int column = key[key.length-1][(key[key.length-1].length)-1];
//得到最大行
int row = calcRow(p,column);
//通过key得到一维加密数组，方便后续加密
int[] keyArry = calcKeyArry(key);
//生成明文p矩阵
char[][]Mp = calcMp(p,column,row);
//生成密文矩阵
char[][]Mk = transposition(Mp,keyArry);
//密文
String cip = "";
for(char[] xd :Mk){
for(char xc :xd){
cip+=xc;
}
}
return cip;
}
//生成密文矩阵
private static char[][] transposition(char[][] mp, int[] keyArry) {
char[][] newmp = new char[mp.length][mp[0].length];
for (int i = 1; i < keyArry.length; i++) {
for (int j = 0; j < mp.length; j++) {
newmp[j][i-1]=mp[j][(keyArry[i])-1];
}
}
return newmp;
}
//生成明文矩阵
private static char[][] calcMp(String p, int column, int row) {
char[][] Mp = new char [row][column];
char[] c = p.toCharArray();
for(int i=0, j=0, k=0; i<c.length ;i++){
Mp[j][k] = c[i];
k++;
if(k==column){
j++;
k=0;
}
}
return Mp;
}
//为rekey赋值 ， rekey下标为被置换的列 ，值为要置换到的列,rekey[0]=0
private static int[] calcKeyArry(int[][] key) {
int[] rekey = new int[key[key.length-1][(key[key.length-1].length)-1]+1];
//两层循环遍历key
for(int a[]: key){
for(int i = 0 ; i<=a.length-1; i++){
//判断是否为最后一个，若是值为第一个，否为下一个
if(i==a.length-1){
rekey[a[i]] = a[0];
}else{
rekey[a[i]]=a[i+1];
}
}
}
//不用置换的
for(int i = 0 ; i<=rekey.length-1; i++){
if(rekey[i]==0){
rekey[i] = i;
}
}
return rekey;
}
//计算最大列
private static int calcRow(String p, int column) {
char[] a = p.toCharArray();
int b = a.length;
int c;
if(b%column==0){
c = b/column;
}else{
c = (b/column)+1;
}
return c;
}
}本文出自 “Try” 博客，转载请与作者联系！
以上是关于python实现替代密码与置换密码的主要内容，如果未能解决你的问题，请参考以下文章