Enigma模拟-Python

设计思想

Enigma机的机械结构：

• 键盘：加密人员通过键盘进行输入

• 转子：Enigma机上一般装有至少3个转轮。每个转轮有代表26个字母的触头和触点，触点和触头在转轮内部有导线相连（一个转轮相当于一组单表代替密码），同时外部有棘轮控制转动的幅度。当按动键盘上的单键时，最右边的转轮就会转动一次，每转动26次就会发生进位，带动下一个轮转动。每当转轮转动暂停下来，转轮的触头就会和下一个转轮的触点重新接触，构成通路，按动单键产生的电信号就会经过三个转轮（转轮的触头和下一个转轮的触点有26种接触可能，就是26种通路可能，也就是26张单表）。

• 反射板：从最后一个转轮出来的电信号会经过反射板，反射板会对信号再次进行置换，接着反射回去，让其再次通过三个转轮，随后输出。

• 显示板：输出的字母会在显示板上展现，随后会另有机器打印记录。

• 连接板：设置在机器底部，可以将一对字母短接，相当于是单表加密。

实现的关键：

• 转子作为单表代替密码，可采用随机代替的方式实现。
• 反射器是设计关键，需要保证\(D(a) = b, \quad D(b) = a\)，即\(D(D(x))=x\)。
• 转子转动规则为26进1.

python实现

import random      
from copy import copy       
reflector=[18, 16, 12, 15, 19, 13, 23, 20, 9, 8, 21, 14, 2, 5, 11, 3, 1, 22, 0, 4, 7, 10, 17, 6, 25, 24]  
raw_cog=[[6, 10, 23, 9, 19, 2, 21, 1, 7, 24, 0, 17, 15, 3, 8, 4, 14, 12, 16, 25, 11, 18, 22, 20, 13, 5]  
,[0, 7, 1, 10, 19, 5, 9, 18, 4, 23, 2, 20, 15, 24, 22, 8, 12, 25, 6, 13, 3, 11, 21, 17, 16, 14]  
,[23, 2, 4, 13, 14, 21, 12, 0, 9, 16, 5, 17, 20, 22, 10, 24, 7, 3, 25, 8, 15, 6, 19, 18, 11, 1]]  
  
def shift(List,n):    
    return List[n:]+List[:n]    
  
class Cog:#模拟转子   
    def __init__(self,temp):    
        self.cog=copy(temp)      
    def rotate(self):     
        #self.cog=self.cog[1:]+self.cog[:1]      
        self.cog=shift(self.cog,1)      
    def printStatus(self):#输出转子当前的状态  
        for i in self.cog:  
            print i,  
    def nextNum(self,x):  
        return self.cog[x]  
    def lastNum(self,x):  
        return self.cog.index(x)  
  
class Enigma:  
    def __init__(self,cogSum):#cogSum是要使用的转子数  
        global reflector  
        self.lenCipher=0 #记录密文长度，计算转子转动  
        self.cogSum=cogSum  
        self.cogList=[] #所有使用的转子list  
        self.reflector=copy(reflector) #反射器  
        for i in range(0,cogSum):  
            self.cogList.append(Cog(raw_cog[i]))  
    def printStatus(self):#输出Enigma密码机当前的状态  
        for i in range(0,self.cogSum):  
            print 'cog'+str(self.cogSum)+': '  
            self.cogList[i].printStatus()  
            print  
        print 'reflector:',  
        for i in self.reflector:  
            print i,  
    def dealChar(self,c):#加密一个字符，并且转动转子  
        #加密字符  
        num=ord(c)-ord('a')  
        for i in range(0,self.cogSum):  
            num=self.cogList[i].nextNum(num)  
        num=self.reflector[num]  
        for i in range(self.cogSum-1,-1,-1):  
            num=self.cogList[i].lastNum(num)  
        #转动转子  
        for i in range(0,self.cogSum):  
            if 26**i<=self.lenCipher and self.lenCipher%26**i==0:  
                self.cogList[i].rotate()  
        return chr(ord('a')+num)  
    def encode(self,oriStr):#字符串的加密，只处理小写英文字母，忽略其他字符  
        ciphertext=''  
        oriStr=oriStr.lower()  
        for eachChar in oriStr:  
            if eachChar.isalpha():  
                self.lenCipher+=1  
                ciphertext+=self.dealChar(eachChar)  
        return ciphertext  
  
def main():  
    sumcog=input('请输入要使用的转子数目（最多3个）：')  
    for i in range(0,sumcog):  
        print '请输入一个0-25的数字以确定第'+str(i+1)+'一个转子起始位置：'  
        c1=input()  
        raw_cog[i]=shift(raw_cog[i],c1) #调整转子的初始位子  
  
    rawString=raw_input('请输入要加密的字符串')  
    test=Enigma(sumcog)  
    temp=test.encode(rawString)  
    print temp  
  
if __name__ == '__main__':  
    main()

测试



输入相同字符串：aaaaa，加密后得到zjfns；
再次使用相同设置加密zjfns，得到原字符串aaaaa。