精华内容
下载资源
问答
  • 主要介绍了Python实现仿射密码的思路详解,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • 主要介绍了基于Python解密仿射密码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 仿射密码Python实现

    2018-12-29 23:55:00
    仿射密码结合了移位密码和乘数密码的特点,是移位密码和乘数密码的组合。 仿射密码的加密算法就是一个线性变化,即对明文字符x,对应的密文字符为y=ax+b(mod26)其中,a, b属于Z26且gcd(a,b)=1 实现过程: 选取a,b...

    算法分析

    1. 仿射密码结合了移位密码和乘数密码的特点,是移位密码和乘数密码的组合。
    2. 仿射密码的加密算法就是一个线性变化,即对明文字符x,对应的密文字符为y=ax+b(mod26)其中,a, b属于Z26且gcd(a,b)=1
    3. 实现过程:
    • 选取a,b两个参数,其中gcd(a, 26)=1
    • 加密变换: c= a∗?+b ??? 26
      a=1时,移位密码
      b=1时,乘数密码
    • 解密变换:  ?= (c−b)∗a^(−1) ??? 26

    算法实现

    # 暴力破解
    la = [1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 23, 25]
    lb = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
          14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]
    
    # 最大公约数
    def gcd(a, b):
        while b != 0:
            tem = a % b
            a = b
            b = tem
        return a
    
    # 加密
    def encrypt(m, c, a, b):
        for i in range(len(m)):
            # 加密成相应的大写字母
            c.append(chr(((ord(m[i]) - 97) * a + b) % 26 + 65))
        d = ''.join(c)
        print(d)
    
    # 求逆元
    def niyuan(a, b):
        ny = 1
        while (a * ny) % b != 1:
            ny += 1
        return ny
    
    # 解密
    def decrypt(c, k, b):
        mw = []
        for i in range(len(c)):
            tem = ord(c[i]) - 65 - b
            if tem < 0:
                tem += 26
            mw.append(chr((k * tem) % 26 + 97))
        print("k=" + str(k) + ", b=" + str(b) + "时,解密后的明文为:")
        res = ''.join(mw)
        print(res)
    
    #实现
    if __name__ == "__main__":
        # 明文
        m = 'ifnottothesunforsmilingwarmisstillinthesuntherebutwewilllaughmoreconfidentcalmifturnedtofoundhisownshadowappropriateescapethesunwillbethroughtheheartwarmeachplacebehindthecornerifanoutstretchedpalmcannotfallbutterflythenclenchedwavingarmsgivenpowerificanthavebrightsmileitwillfacetothesunshineandsunshinesmiletogetherinfullbloom'
        # 密文
        c = []
        x, y = input("请输入a和b: ").split()
        a = int(x)
        b = int(y)
        while gcd(a, b) != 1:
            x, y = input("a和b不互素,请重新输入a和b: ").split()
            a = int(x)
            b = int(y)
        print("明文内容为:")
        print(m)
        print("加密后的密文为:")
        encrypt(m, c, a, b)
        print("知道密钥破解:")
        k = niyuan(a, 26)
        decrypt(c, k, b)
        print("不知道秘钥破解,暴力破解如下: ")
        for i in range(0, 12):
            for j in range(0, 26):
                decrypt(c, la[i], lb[j])
    

    加密与解密

    • 加密:输入a = 3, b = 4时,加密结果如图所示:
      1240
    • 解密:知道秘钥k = 9, b = 4 (k为a的逆元)时,解出相应明文。
      1240

    正确性

    由于算法的前提要求gcd(a,26)==1, 从而使加密函数c= a∗?+b ??? 26是一个单射函数,故其解必然是唯一的。即,gcd(a,26)==1保证了仿射加密函数是一个双射函数,故算法正确。

    安全性分析

    • 此密码算法安全性较弱。由算法的实现可知,此算法的秘钥空间大小为12*26 – 1 ==311(去除a = 1, b = 0时的情况)且a = 1,3,5,7,9,11,15,17,19,21,23,25 故很容易便能够通过暴力破解获得明文。
      1240
    • 还可以通过统计分析破解:代码如下
    #统计破解仿射密码
    
    # 最大公约数
    def gcd(a, b)
        while b != 0:
            tem = a % b
            a = b
            b = tem
        return a
    
    if __name__ == "__main__":
        # a = 3, b = 4时的密文
        m = "CTRUJJUJZQGMRTUDGOCLCRWSEDOCGGJCLLCRJZQGMRJZQDQHMJSQSCLLLEMWZOUDQKURTCNQRJKELOCTJMDRQNJUTUMRNZCGUSRGZENUSEXXDUXDCEJQQGKEXQJZQGMRSCLLHQJZDUMWZJZQZQEDJSEDOQEKZXLEKQHQZCRNJZQKUDRQDCTERUMJGJDQJKZQNXELOKERRUJTELLHMJJQDTLYJZQRKLQRKZQNSEPCRWEDOGWCPQRXUSQDCTCKERJZEPQHDCWZJGOCLQCJSCLLTEKQJUJZQGMRGZCRQERNGMRGZCRQGOCLQJUWQJZQDCRTMLLHLUUO"
        # 根据统计而得出的实际各字母出现的概率
        reality = dict(a=0.082, b=0.015, c=0.028, d=0.043, e=0.127, f=0.022, g=0.02, h=0.061, i=0.07,
                       j=0.002, k=0.008, l=0.04, m=0.024, n=0.067, o=0.075, p=0.019, q=0.001, r=0.06,
                       s=0.063, t=0.091, u=0.028, v=0.01, w=0.023, x=0.001, y=0.02, z=0.001)
        # 对字典中各字母出现的概率进行降序排序
        order = dict(sorted(reality.items(), key = lambda x:x[1], reverse = True))
        print("统计中各字母出现的概率从小到大如下: ")
        print(order)
        # 统计密文中各字母出现的次数
        example = {}
        for i in m:
          example[i] = m.count(i)
        # 对字典中各字母出现的次数进行降序排序
        result = dict(sorted(example.items(), key = lambda x:x[1], reverse = True))
        print("计算得的密文中个字母的出现的次数从大到小如下: ")
        print(result)
    
        # #从结果可推测:Q由e加密而得,J由t加密而得,进行验算。
        # (a*4+b)%26==16
        # (a*19+b)%26==9
        # 从而计算出a=3,b=4
        # (a*K)%26==1,求得k=9
        # 用k=9,b=4进行解密可得出明文
        print("根据统计分析,加密所用的a, b可能为:")
        for i in range(1,26):
            for j in range(1,26):
                if (i*4+j)%26==16 and (i*19+j)%26==9:
                    if gcd(i, j)==1:
                        print("a="+str(i), "b="+str(j))
    

    运行结果为(此处以破解a=3, b=4时得出的密文):
    1240
    如图所示,正确解出a, b 再用(a*k)%26==1,求得k=9 用k=9,b=4进行解密可得出明文。

    • 还可以通过差分分析进行破解。对于仿射密码来说,“差分”是模26减法,那么,在不知道两对明密文对(M1,C1)(M2, C2)的情况下,只需要知道M1-M2C1-C2便可以确定a。因为

      C1 = aM1 + b(mod26)
      C2 = a
      M2 + b(mod26)
      易得,a = (C1 – C2)/(M1 – M2) (mod26)

    得到a 后,进一步找到b就很容易了。

    转载于:https://www.cnblogs.com/clwsec/p/10198428.html

    展开全文
  • 仿射密码 python

    千次阅读 2018-12-25 16:08:58
    def Euclid(a,b=26): x1 = 1 x2 = 0 x3 = a y1 = 0 y2 = 1 y3 = b while y3 != 0 : q = int(x3/y3) t1 = x1-q*y1 t2 = x2-q*y2 t3 = x3-q*y3 ...
    def Euclid(a,b=26):
        x1 = 1
        x2 = 0
        x3 = a
        y1 = 0
        y2 = 1
        y3 = b
    
        while y3 != 0 :
            q = int(x3/y3)
            t1 = x1-q*y1
            t2 = x2-q*y2
            t3 = x3-q*y3
    
            x1 = y1
            x2 = y2
            x3 = y3
    
            y1 = t1
            y2 = t2
            y3 = t3
    
            if x1<0:
                x1 = x1+b
        return x1
    
    print("请输入密钥a,b,定义域[0,25],且gcd(a,26)=1")
    a = int(input('a='))
    b = int(input('b='))
    m = input('要加密的明文m:')
    c = input('要解密的密文c:')
    
    m1=[]
    m2=[]
    
    for i in range(len(m)):
        m1.append(  chr( (a*(ord(m[i])-97)+b)%26+97)  )
    
    for i in range(len(c)):
        m2.append(  chr((  Euclid(a)*((ord(c[i])-97)-b)  )%26+97) )
    
    m3=''.join(m1)
    m4=''.join(m2)
    
    print(m3)
    print(m4)
    

     

    展开全文
  • Python实现仿射密码

    2020-12-21 07:40:55
    仿射密码思路: 1、加解密公式: 2、构造对应字典: 3、代码实现 构造字典,建立映射关系: # 构造字典,'A' --> 0 ... def char_2_num(x): list_s = [] list_num = [] for i in range(26): c = chr(i + 65)...
  • 仿射密码加解密(python实现)

    千次阅读 2020-05-24 16:19:24
    仿射密码是一种替换密码。它是利用加密函数一个字母对一个字母的加密。 加密函数是E(x)= (ax + b) (mod m),其中,a和m互质,m是字符集的大小。 (例如,26即是以26个字母作为编码,当m是26时,a必须是1,3,5,7,9...

    1. 简介

    仿射密码是一种替换密码。它是利用加密函数一个字母对一个字母的加密。

    加密函数是E(x)= (ax + b) (mod m),其中,a和m互质,m是字符集的大小。
    (例如,26即是以26个字母作为编码,当m是26时,a必须是1,3,5,7,9,11,15,17,19,21,23,25其中之一)

    解密函数为D(x) = a-1(x - b) (mod m),其中a-1是a在Zm群的乘法逆元。

    2. 乘法逆元

    所谓乘法逆元,定义如下:

    群G中任意一个元素a,都在G中有唯一的逆元a`,具有性质aa` = a`a = e,其中e为群的单位元。

    例如:4 * 2 ≡ 1 (mod 7)中,2即是4的乘法逆元。

    要求乘法逆元,在字符集大小不大的情况下,完全可以通过遍历实现。

    另外也可以通过gmpy2库中的invert函数实现。

    在密码学中,乘法逆元一般是通过拓展欧几里得算法求得的。

    3. 代码

    m = 26,字符集为小写字母时

    '''
    仿射密码
    (a,b)
    m = 26,字符集为小写字母
    加密函数是E(x)= (ax + b) (mod m)
    解密函数为D(x) = (a^-1)(x - b) (mod m),其中a^-1是a的乘法逆元
    '''
    
    #通过一个简单的遍历得到a的乘法逆元,也可以通过gmpy2库中的invert函数实现
    def get_inverse(a):
        for i in range(1,27):
            if a*i%26==1:
                return i
    
    #加密
    def encipher(a, b, p):
        c=[]
        for i in p:
            temp=((ord(i)-97)*a+b)%26+97
            c.append(chr(temp))
        print(''.join(c))
    
    #解密
    def decipher(a, b, c):
        a_inv = get_inverse(a)
        p=[]
        for i in c:
            temp=(((ord(i)-97)-b)*a_inv)%26+97
            p.append(chr(temp))
        print(''.join(p))
    
    if __name__ == "__main__":
        a = 11
        b = 6
        message = 'sorcery'
        encipher(a,b,message)
        #decipher(a,b,message)
    

    m = 52,字符集为小写和大写字母时

    '''
    仿射密码
    m = 52
    字符集为小写和大写字母
    '''
    import string
    def encrypt(k1,k2,message):
        dic = string.ascii_letters
        c = []
        for i in message:
            if i.islower():
                num = ord(i)-ord('a')
                c.append(dic[(num*k1+k2)%52])
            elif i.isupper():
                num = ord(i)-ord('A')+26
                c.append(dic[(num*k1+k2)%52])
            else:
                c.append(i)
        print(''.join(c))
    
    def decrypt(k1,k2,message):
        for i in range(52):
            if k1*i%52==1:
                inv = i
                break
        dic = string.ascii_letters
        m = []
        for i in message:
            if i.islower():
                num = ord(i)-ord('a')
                m.append(dic[inv*(num-k2)%52])
            elif i.isupper():
                num = ord(i)-ord('A')+26
                m.append(dic[inv*(num-k2)%52])
            else:
                m.append(i)
        print(''.join(m))
    
    message = 'gVEXGT iDIT' #待加密或解密的消息
    a = 5 # key的范围0~51之间
    b = 29 # key的范围0~51之间
    # encrypt(a,b,message)
    decrypt(a,b,message)
    
    展开全文
  • python代码实现仿射密码的解密

    仿射密码简介

    仿射密码的加密算法是一个线性变换,即对任意的明文字符x,先找到x对应的数字(a-z分别对应0-25),然后进行加密变换: y = e ( x ) = a ∗ x + b ( m o d 26 ) y = e(x) = a*x+b(mod 26) y=e(x)=ax+b(mod26),找出数字y对应的字母x*,x*就是x的密文。
    知道a和b的前提下解密过程就是: x = d ( e ( x ) ) = a ′ ( e ( x ) − b ) ( m o d 26 ) x=d(e(x))=a'(e(x)-b)(mod 26) x=d(e(x))=a(e(x)b)(mod26),其中 a ′ a' a为a的逆元( a ∗ a ′ = 1 ( m o d 26 a*a'=1(mod 26 aa=1(mod26)。

    实例

    下面我们以 e ( x ) = ( 5 x + 8 ) m o d 26 e(x)=(5x+8)mod26 e(x)=(5x+8)mod26函数为例子进行介绍,要加密的字符串为 AFFINE CIPHER。
    1
    其对应的加密结果是 IHHWVCSWFRCP。
    对于解密过程,正常解密者具有a与b,可以计算得到 a ′ a' a为 21,所以其解密函数是d(x)=21(x−8)(mod26),解密如下:
    2

    加密算法

    '''
    加密算法
    '''
    def Reflect():
        d = {}
        j = 0
        for i in range(ord('a'), ord('z') + 1):
            d[chr(i)] = j
            j += 1
        return d
    def Encode(a, b, s, d):
        c = ''
        for i in s:
            if i == ' ':
                c += i
                continue
            f = (a * d[i] + b) % 26
            for key, value in d.items():
                if value == f:
                    c += key
                    break
        return c
    
    s = input('请输入要加密的字符串:')
    s = s.lower()
    print('-----------加密方程为a*x + b(mod 26)--------------')
    a = eval(input('请输入参数a:'))
    b = eval(input('请输入参数b:'))
    d = Reflect()
    c = Encode(a, b, s, d)
    print('密文为:',c)
    

    唯密文攻击破解实战

    采用频率分析法,根据大量英文文献的统计得出,出现最多次数的两个英文字母为E和T,我们可以先统计出密文中个字母出现的次数,然后将出现最多的字母p1看做是由’E’加密而来的,将出现第二多p2的字母看做是由’T’加密而来的,令 e ( x ) = a ∗ x + b ( m o d 26 ) e(x)=a*x+b(mod 26) e(x)=ax+b(mod26),因为E对应4,T对应19,有 { 4 a + b = p 1 ( m o d 26 ) 19 a + b = p 2 ( m o d 26 ) \begin{cases} 4a+b=p1(mod 26) \\ 19a+b=p2(mod 26)\end{cases} {4a+b=p1(mod26)19a+b=p2(mod26)
    可以解出a与b的值,从而计算出明文值。若破译出的明文语义有误,则将’T’对应出现第三多的字母,重新计算a和b,依此类推,直到语义无误。
    解密代码:

    '''
    唯密文攻击
    '''
    #频率分布列表
    index = ['e', 't', 'a', 'o', 'i', 'n', 's', 'h', 'r', 'd', 'l', 'c', 'u', 'm', 'w', 'f', 'g', 'y', 'p', 'b', 'v', 'k', 'j', 'q', 'x', 'z']
    
    def frequency_Sort(s):
        d = dict()
        for i in range(ord('a'),ord('z')+1):
            sum = 0
            for j in s:
                if ord(j)==i :
                    sum += 1
            d[chr(i)] = sum
        d = sorted(d.items(), key = lambda x: x[1], reverse = True) #d的类型变为list,不再是dict
        c = []
        for k in d:
            c.append(k[0])
        return c
    
    def coefficient(a, b, m, n):     #求系数
        x1 = d[a]
        x2 = d[b]
        y1 = d[m]
        y2 = d[n]
        k = 0
        f = (x2 - x1)%26
        point = (y2 - y1) % 26
        while f % point != 0:
            f += 26
            k += 1
            if k == 1000:
                break
        if k == 1000:
            return 2,0
        _a = ( f / point ) % 26
        _b = ( x1 - y1 * _a) % 26
        return _a , _b
    
    def decodeFunction(a, b):
        q = []
        t = [0,1]
        numChu = 26 // a
        numYu = 26 % a
        while numYu != 0:
            q.append(numChu)
            j = a
            a = numYu
            numChu = j // a
            numYu = j % a
        q.append(numChu)
        for i in range(0,len(q) - 1):
            f = -q[i] * t[i + 1] + t[i]
            t.append(f)
        a = t[-1] % 26
        b = (-b * t[-1]) % 26
        return a, b
    s = input('请输入密文:')
    s = s.lower()
    j = 0
    d = dict()
    for i in range(ord('a'), ord('z') + 1):
        d[chr(i)] = j
        j += 1
    w = frequency_Sort(s)
    bug = ''
    for two in range(0, 25):
        for p1 in range(0, len(w) - 1):
            for p2 in range(p1 + 1, len(w)):
                a, b = coefficient(w[p1], w[p2], index[two], index[two + 1])
                if a % 2 == 0 or a % 13 == 0:
                    continue
                a, b = decodeFunction(a, b)
                c = ''
                for i in s:
                    if i == ' ':
                        c += i
                        continue
                    f = (d[i]*a + b)%26
                    for q,v in d.items():
                        if v == f:
                            c += q
                            break
                print('明文为:{}'.format(c))
                bug = input("若语义有误则输入'c'继续尝试(输入's'退出):")
                if bug == 's':
                    break
                else:
                    continue
            if bug == 's':
                break
        if bug == 's':
            break
    
    

    运行情况:
    测试一
    3
    测试二(上面实例里的密文解密
    4

    展开全文
  • 仿射密码 python实现

    2021-11-07 21:54:55
    主要为两个函数的实现: 加密函数 : y = ax+b (mod m), (一般m设置为26) 解密函数:x = a^-1 (y - b) (mod m) , a^-1 为a 的逆元,在用其他语言实现求逆元时需要注意mod 取整问题; 参考代码如下, ...
  • python3 仿射密码破解脚本 禁止转载 说明:在一次直播课上看到的[时匣](https://www.cnblogs.com/casket/p/)师傅写的脚本,顺便截屏抄下来了 在做CTF的时候会用到,收藏备用 # -*- coding: utf-8 -*- #使用前注意...
  • python实现仿射密码加解密过程

    千次阅读 2017-05-12 22:10:55
    对于仿射密码算法过程这里不做过多讲解,请自行参照教材或者网络资料。这里需要注意的是,默认为加密后的密文要转化为大写字母的形式。下面是用python实现的加解密过程: 密钥为k=(11,4) (1)加密过程 (2)...
  • 仿射变换: 加密: 解密: 其中a, b为密钥, ,且gcd(a, 26)=1 1.参数选取与密钥生成 首先让用户自行输入a,b的值。 判断a与N是否互素。(欧几里得算法) 利用a与N求得a的模逆aa。(扩展欧几里得算法) 由...
  • 仿射密码 仿射密码是一种替换密码。它是一个字母对一个字母的。 它的加密函数是 Ek(x)=(k1x+k2) mod n(其中k1和n互质,n是字母的数目) 解码函数是 Dk(x)=ny(x- k2) mod n (其中ny代表逆元,满足(k1*ny) mod n = 1) ...
  • 图像仿射变换python实现

    千次阅读 2020-03-18 21:54:21
    写文章不易,如果您觉得此... 仿射变换介绍: 请参考:图解图像仿射变换:https://www.cnblogs.com/wojianxin/p/12518393.html 图像仿射变换之图像平移:https://www.cnblogs.com/wojianxin/p/12519498.html 二...
  • 仿射密码维吉尼亚密码的python3实现
  •  解密由仿射密码加密的密文“DBUHU SPANO SMPUS STMIU SBAKN OSMPU SS”  想解密这个密文,首先必须要知道仿射密码是什么:  仿射密码是一种代换密码,加解密公式如下  加密:$C=E([a,b],p)=(ap+b)\ mod\ 26$ ...
  • 实现仿射密码

    2008-03-13 18:58:21
    MFC下实现仿射密码的加密和解密。
  • 假设X,Y,a,b是Z52整数环中的元素,a和b为密钥,X是原文,Y是密文 ...#仿射密码 z=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','A','B','C',
  • python仿射密码

    2019-09-18 17:54:21
    密码学实验 算法 加密:E(x)=ax+b(mod 26) # x表示明文 解密:D(x)=(a)’(E(x)-b)(mod 26) D(x)=a’E(x)-a’b(mod 26) # (a)'表示a的逆元 代码 import random import os a=int(input("输入a:")) b=int(input("输入b:...
  • 仿射密码 仿射密码的映射函数为f(ai)=bi=aj,j=ik1+k0 mod n ,(k1,n)=0,0<k0<n,且不容许同时有k1=1和k0=0。 #仿射密码------------------------------------------------------------------------------...
  • Keys1=9 Keys2=2 first = 97 temp=0 dir={} for i in range(26): dir[chr(first)]=i first=first+1 PlainText ='In several distributed systems a user should only be able to access data if a user posses a ...
  • [(X[0] - Q * Y[0]),(X[1] - Q * Y[1]),(X[2] - Q * Y[2])] X[0],X[1],X[2] = Y[0],Y[1],Y[2] Y[0],Y[1],Y[2] = T1,T2,T3 exgcd(X,Y) exgcd(X,Y) return int(Y[1]) #fangshe_reverse(3,17) 仿射密码实现加解密 算法...
  • 仿射密码

    2021-04-21 22:43:39
    根据仿射密码的实现原理,实现利用仿射密码进行加密和解密的程序。 (1)设计加密程序:能够根据用户输入明文的内容产生加密的密文并输出 (2)设计解密程序:能够对输入的密文内容破解并输出得到其对应的明文。 # -*- ...
  • 维吉尼亚密码加密解密、Hill密码加密解密、仿射密码加密解密及字母出现的频率统计 import string print('------------------------------------Vigenere加解密---------------------------------------------------...
  • 仿射密码 加密变换:E(x)=ax + b (mod m) 解密变换:D(x)=a-1(x-b) (mod m) m=36 (其中包括26个字母(a到z)和10个数字(0到9)) ascii码: a~z 97~122 0~9 48~57 替换表: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 ...
  • 密码学—仿射密码实验报告

    千次阅读 2020-04-05 19:22:10
    古典密码算法实验报告 姓名:空の城 学号:你猜 ...仿射密码的基本思想:加法密码和乘法密码结合就构成仿射密码仿射密码的加密和解密算法是: C=Ek(m)=(k1m+k2)mod nC=Ek(m)=(k1m+k2)mod n M=Dk(c)=k1(...
  • 密码学原理与实践(第三版) 冯登国 1.21(b) 及1.24 维吉尼亚密码.py # -*- coding: utf-8 -*- ''' 代码中各个函数的说明如下 gcd(a, b) #获取两个数的最大公因数 multi_gcd(num) #获取数组中所有数的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 404
精华内容 161
关键字:

仿射密码python

python 订阅