欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

python实现维吉尼亚算法

程序员文章站 2022-05-13 21:15:29
本文实例为大家分享了python实现维吉尼亚算法的具体代码,供大家参考,具体内容如下 1 virginia加密算法、解密算法 vigenenre密码是最著名的多表代换密...

本文实例为大家分享了python实现维吉尼亚算法的具体代码,供大家参考,具体内容如下

1 virginia加密算法、解密算法

vigenenre密码是最著名的多表代换密码,是法国著名密码学家vigenenre发明的。vigenenre密码使用一个词组作为密钥,密钥中每一个字母用来确定一个代换表,每一个密钥字母被用来加密一个明文字母,第一个密钥字母加密第一个明文字母,第二个密钥字母加密第二个明文字母,等所有密钥字母使用完后,密钥再次循环使用,于是加解密前需先将明密文按照密钥长度进行分组。

密码算法可表示如下:。

设明文串为:

m=m1m2…mn,mi∈charset, n是明文长度

秘钥为:

k=k1k2…kd,ki∈charset, d是秘钥长度

密文为:

c=c1c2…cn,ci∈charset, n是密文长度

加密算法:

cj+td=(mj+td+kj ) mod 26

j=1…d,  t=0…ceiling(n/d)-1

其中ceiling(x)函数表示不小于x最小整数

解密算法:

mj+td=(cj+td -kj ) mod 26

j=1…d, t=0…ceiling(n/d)-1

其中ceiling(x)函数表示不小于x最小整数

加解密代码如下

def vigenereencrypto(message, key):
 mslen = len(message)
 keylen = len(key)
 message = message.upper()
 key = key.upper()
 raw = "abcdefghijklmnopqrstuvwxyz"# 明文空间
 # 定义加密后的字符串
 ciphertext = ""
 # 开始加密
 for i in range(0, mslen):
  # 轮询key的字符
  j = i % keylen
  # 判断字符是否为英文字符,不是则直接向后面追加且继续
  if message[i] not in raw:
   ciphertext += message[i]
   continue
  encodechr = chr((ord(message[i]) - ord("a") + ord(key[j]) - ord("a")) % 26 + ord("a"))
  # 追加字符
  ciphertext += encodechr
 # 返回加密后的字符串
 return ciphertext
if __name__ == "__main__":
 message = "hello, world!"
 key = "key"
 text = vigenereencrypto(message, key)
 print(text)
def vigeneredecrypto(ciphertext, key):
 mslen = len(ciphertext)
 keylen = len(key)
 key = key.upper()
 raw = "abcdefghijklmnopqrstuvwxyz"# 密文空间
 plaintext = ""
 for i in range(0, mslen):# 开始解密
  # 轮询key的字符
  j = i % keylen
  # 判断字符是否为英文字符,不是则直接向后面追加且继续
  if ciphertext[i] not in raw:
   plaintext += ciphertext[i]
   continue
  decodechr = chr((ord(ciphertext[i]) - ord("a") - ord(key[j]) - ord("a")) % 26 + ord("a"))
  # 追加字符
  plaintext += decodechr
 # 返回加密后的字符串
 return plaintext
if __name__=="__main__":
 ciphertext = "rijvs, ambpb!"
 key = "key"
 text = vigeneredecrypto(ciphertext, key)
 print(text)
import vigeneredecrypto
import vigenereencrypto
def main():
 info = '''==========********=========='''# 开始加密
 print(info, "\n------维吉尼亚加密算法------")
 print(info)
 # 读取测试文本文档
 message = open("test.txt","r+").read()
 print("读取测试文本文档:test.txt")
 print("开始加密!")
 # 输入key
 key = input("请输入密钥:")
 # 进入加密算法
 ciphertext = vigenereencrypto.vigenereencrypto(message, key)
 # 写入密文文本文档
 c = open("ciphertext.txt", "w+")
 c.write(ciphertext)
 c.close()
 print("加密后得到的密文是: \n" + ciphertext)
 # 开始解密
 print(info, "\n------维吉尼亚解密算法------")
 print(info)
 # 读取加密文本文档
 print("读取密文文本文档:ciphertext.txt")
 ciphertext = open("ciphertext.txt", "r+").read()
 # 进入解密算法
 print("开始解密!")
 plaintext = vigeneredecrypto.vigeneredecrypto(ciphertext, key)
 p = open("plaintext.txt", "w+")
 # 写入解密文本文档
 p.write(plaintext)
 p.close()
 print("解密后得到的明文是 : \n" + plaintext)
if __name__=="__main__":
 main()

2重合指数法

2.1重合指数

设x=x1x2...xn是一个含有n个字符的字符串,x的重合指数记为ic(x),定义为x中两个随机元素相同的概率。

设y是一个长度为n密文,即y=y1y2...ym,其中y是密文字母,同样来求从中抽到两个相同字母的概率是多少。为此,设na为字母a在这份密文中的频数,设nb为字母b在这份密文中的频数,依此类推

从n个密文字母中抽取两个字母的方式有????_????^2=n(n-1)/2,而其中na个a组成一对a的方式有cna2= na(na-1)/2,于是从y中抽到两个字母都为a的概率为[na(na -1)]/[n(n-1)],..因此,从y中抽到两个相同字母的概率为  (∑▒〖????????(????????−1)〗)/(????(????−1))

这个数据称为这份密文的重合指数,记为ic(y)

2.2重合指数法原理

26个英文字母出现频率表                                                                 重合指数公式

python实现维吉尼亚算法

(1)根据频率表,我们可以计算出英语文本的重合指数为0.065。

(2)利用重合指数推测密钥长度的原理在于,对于一个由凯撒密码加密的序列,由于所有字母的位移程度相同,所以密文的重合指数应等于原文语言的重合指数。

(3)假设y=y1 y2...yn是由  vigenere 密码得到的长度为n的密文。将y按列排成一个m*(n/ m)的矩形阵列,各行分别记为y1,y2...ym.如果m确实是密钥字的长度,则yi中的各个密文字母都是由同一个密钥的移位加密方式得到的。矩阵的每一行对应于子串yi,1≤i≤m。

(4)另一方面,如果m不是密钥字的长度,则 yi中的各个密文字母将是由不同密钥以移位加密方式得到的, yi 中的各个密文字母看起来更随机一些。对于一个随机的英文字母串,其重合指数为0.038。

(5)因为0.065和0.038相差较远,所以我们一般能够确定密钥字的长度,或者说我们能够确定由 kasiski 测试法得到的密钥字的长度的正确性。

3拟重合指数测试法

拟重合指数测试法:首先子密文段重各个字母的频率进行统计(记为fi, i∈a – z),查看字母频率分布统计概率(记pi),计算子密文段长度为n,使用公式:

python实现维吉尼亚算法

计算出m0,然后对子密文段移位25次,同样按照上述方法求出m1 — m25的值

根据重合指数的定义知:一个有意义的英文文本,m ≈0.065,所以利用这个规律,就可以确定秘钥中的每一个字母

代码实现

def main():
 fo=open("cipher.txt","r")
 s=fo.read()
 s=str(s)
 fo.close()
 ic=0
 max_num=len(s)//26
 # while ic<0.06:
 #def fenzu():
 #分组
 aves=[0]*max_num
 for i in range(1,max_num):
  count = 0
  zicuan=[]
  for t in range (i):
   fz=s[t:len(s):i]
   zicuan+=[fz]
   count+=1
   #print(count,'韩庚韩庚韩庚',zicuan)
  for js in range (i):
   zicuan[js]=zicuan[js].upper()
  ics=[0]*count
  #统计每个分组的ic值
  for r in range(count):
   ics[r]=tongjicisu(zicuan[r])
  ave =sum(ics)/count
  print('第{}次分片的ic值是{}'.format(i,ave))
  aves[i-1]=ave
 #找到最可能的密钥分组
 key_index=1
 max = 1
 for i in range(max_num):
  max1=abs(aves[i]-0.065)
  if max1<max:
   max=max1
   key_index=i+1
 print('key_length',key_index)
 key = [none]*key_index
 #得到密钥长度后从新按密钥长度分片计算
 zicuan2 = []
 for t in range(key_index):
  fz = s[t:len(s):key_index]
  zicuan2 += [fz]
 for i in range(key_index):
  key[i]=decode(zicuan2[i])
 print(key)
 di = {}.fromkeys(key)
 key=di.keys()
 keys=""
 for i in key:
  keys+=i
 
 print(keys,"密钥")
 mc = vigeneredecrypto(s,keys)
 print(mc,'ecewew')
 
# 统计次数ic值
def tongjicisu(s):
 tongjicisu = [0] * 26
 zff = ""
 ic=-0
 for t in s:
  if 65 <= ord(t) <= 90:
   zff += t
 for cisu in zff:
  tongjicisu[ord(cisu) - 65] += 1
 for i in range (len(tongjicisu)):
  xic=tongjicisu[i]*(tongjicisu[i]-1)/len(zff)/(len(zff)-1)
  ic+=xic
 return ic
 
def decode(s):
 nicos=[0]*26
 for i in range(26):
  nicos[i]=tongjinichonghe(i,s)
 list1=sorted(nicos)
 num = nicos.index(list1[-1])
 ch = chr(num+65)
 #print(ch)
 return ch
#计算拟重合指数
def tongjinichonghe(key,s):
 sniic=0
 p = [0.08167, 0.01492, 0.02782, 0.04253, 0.12702, 0.02228, 0.02015, 0.06094, 0.06966, 0.00153, 0.00772, 0.04025,
   0.02406, 0.06749, 0.07507, 0.01929, 0.00095, 0.05987, 0.06327, 0.09056, 0.02758, 0.00978, 0.02360, 0.00150,
   0.01974, 0.00074]
 tongjinichonghe = [0] * 26
 zff = ""
 #ic=-0
 #转换为只有大写字母的字符串
 for t in s:
  if 65 <= ord(t) <= 90:
   zff += t
 #统计每个字母出现的次数
 for cisu in zff:
  tongjinichonghe[ord(cisu) - 65] += 1
 #求出每个凯撒加密的解密,根据拟重合指数找到正确的密钥
 list0=tongjinichonghe
 list1=[0]*26
 for i in range (26):
  list1[i]=list0[(i+key)%26]
 tongjinichonghe=list1
 for i in range (len(tongjinichonghe)):
  niic=tongjinichonghe[i]/len(tongjinichonghe)*p[i]
  sniic+=niic
 return sniic
 
def vigeneredecrypto(ciphertext, key):
 mslen = len(ciphertext)
 keylen = len(key)
 key = key.upper()
 raw = "abcdefghijklmnopqrstuvwxyz"# 密文空间
 plaintext = ""
 for i in range(0, mslen):# 开始解密
  # 轮询key的字符
  j = i % keylen
  # 判断字符是否为英文字符,不是则直接向后面追加且继续
  if ciphertext[i] not in raw:
   plaintext += ciphertext[i]
   continue
  decodechr = chr((ord(ciphertext[i]) - ord("a") - ord(key[j]) - ord("a")) % 26 + ord("a"))
  # 追加字符
  plaintext += decodechr
 # 返回加密后的字符串
 return plaintext
 
if __name__ == '__main__':
 main()

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。