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。

巴特西

Enigma模拟-Python

设计思想

Enigma机的机械结构：

实现的关键：

python实现

测试

最新文章

热门文章