精华内容
下载资源
问答
  • 仿射加密

    2021-03-11 22:40:55
    仿射加密 最简单的加密方式之一。 令P=C=K=Z26P=C=K=\textbf{Z}_{26}P=C=K=Z26​对0≤K≤250\le K\le 250≤K≤25任意x,y∈Z26x,y\in \textbf{Z}_{26}x,y∈Z26​定义e(x)=(ax+b)mod26e(x)=(ax+b)mod26e(x)=(ax+b)mod...

    仿射加密

    最简单的加密方式之一。
    P=C=K=Z26P=C=K=\textbf{Z}_{26}0K250\le K\le 25任意x,yZ26x,y\in \textbf{Z}_{26}定义e(x)=(ax+b)mod  26e(x)=(ax+b)\mod 26、定义d(y)=a1(yb)mod  26d(y)=a^{-1}(y-b)\mod 26,其中a1a^{-1}aaZ26\textbf{Z}_{26}上的乘法逆。对任意的xZ26x\in \textbf{Z}_{26}dK(e(x))=xd_K(e(x))=xaa必需和2626互质。

    代码

    python3
    输入b和a值之后输入待加密字符串敲回车即可看到加密和解密结果。待加密字符串不区分大小写。b如果不与26互质则需要重输。

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    START = ord('a')
    CHAR_COUNT = 26
    print('input \'b\':')
    OFFSET = int(input()) % CHAR_COUNT
    def gcd(m, n):
        return max(abs(n), abs(m)) if n*m == 0 else gcd(abs(n), abs(m) % abs(n))
    def set_factor(v):
        return set_factor(int(input()) % CHAR_COUNT) if gcd(v, CHAR_COUNT) != 1 else v
    print('input \'a\':')
    FACTOR = set_factor(int(input()) % CHAR_COUNT)
    print('input str:')
    MAP = {chr(v+START-1): chr(((FACTOR*v+OFFSET) % CHAR_COUNT)+START) for v in range(1, CHAR_COUNT+1)}
    def encrypt(str):  # 加密
        return ''.join([MAP[char] if char in MAP else char for char in str.lower()])
    def decrypt(str):  # 解密
        return ''.join([list(MAP.keys())[list(MAP.values()).index(char)] if char in MAP.values() else char for char in str.lower()])
    v = input()
    print('\033[31m', 'encrypt: ', encrypt(v), '\033[0m', '\033[35m', '\t decrypt: ', decrypt(encrypt(v)), '\033[0m')
    

    运行结果

    input 'b':
    3
    input 'a':
    14
    15
    input str:
    abcdefghijklmnopqrstuvwxyz
     encrypt:  shwlapetixmbqfujyncrgvkzod            decrypt:  abcdefghijklmnopqrstuvwxyz 
    
    展开全文
  • 仿射加密

    万次阅读 2020-02-19 21:42:03
    仿射加密法 乘数加密法 + 凯撒加密法 = 仿射加密法 凯撒加密法:[https://blog.csdn.net/youngdianfeng/article/details/104333494] 乘数加密法下面介绍。 乘数加密法

    仿射加密法

    乘数加密法 + 凯撒加密法 = 仿射加密法
    在乘数加密之后执行凯撒加密,便是仿射加密。
    这样确保字母A不总是加密到A,且密钥是乘数加密的26倍。
    凯撒加密法:https://blog.csdn.net/youngdianfeng/article/details/104333494
    乘数加密法:https://blog.csdn.net/youngdianfeng/article/details/104401000

    算法大意

    加密过程:明文 --> 乘以密钥A --> 加上密钥B --> 根据符号集的大小取模 --> 密文
    解密过程:明文 <-- 根据符号集的大小取模 <-- 乘以密钥A的模逆 <-- 减去密钥B <-- 密文

    弊端

    密钥A不能使用任何数字,如果是8,字母C和P都加密成Q。
    必须要满足的条件:密钥A数字和符号集的大小必须互质 及 gcd(密钥,符号集大小) ==1
    仿射加密法的加密密钥和解密密钥是两个不同的数字。

    什么是模逆

    两个数字a和m的模逆i满足 (a*i) % m == 1
    可以通过暴力运算出模逆,但是如果像8953851这种密钥就比较耗时,提供了欧几里得的扩展算法可以快速算出模逆。

    代码实例

    # 找出两个数字的最大公因数 如果是1则代表是互质
    def gcd(a,b):
        while a!=0:
            a,b = b % a,a
        return b
    
    # 欧几里得的扩展算法 找出模逆算法
    def findModInverse(a,m):
        if gcd(a,m)!=1:
            # 如果a和m不互质,则不存在模逆
            return None 
        u1,u2,u3 = 1,0,a
        v1,v2,v3 = 0,1,m
        while v3!=0:
            q = u3 // v3
            v1,v2,v3,u1,u2,u3 = (u1 - q*v1),(u2 - q*v3),(u3 - q*v3),v1,v2,v3
        return u1 % m
    
    
    import sys, random
    
    # 字典(符号集)
    SYMBOLS = """ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~""" # 第一个是空格字符
    
    
    # 将一个密钥分成两个密钥及密钥A和密钥B,key = (keyA * 字典大小) + keyB
    def getKeyParts(key):
        keyA = key // len(SYMBOLS)
        keyB = key % len(SYMBOLS)
        return (keyA, keyB)
    
    # 验证密钥是否可用
    def checkKeys(keyA, keyB, mode):
        # 如果keyA是1的话 或者 KeyB是0的话 那密钥是个弱密钥(如果KeyA是1,keyB是0,那么就没有加密)
        if keyA == 1 and mode == 'encrypt':
            sys.exit('The affine cipher becomes incredibly weak when key A is set to 1. Choose a different key.')
        if keyB == 0 and mode == 'encrypt':
            sys.exit('The affine cipher becomes incredibly weak when key B is set to 0. Choose a different key.')
        # keyA和keyB不能是负数
        if keyA < 0 or keyB < 0 or keyB > len(SYMBOLS) - 1:
            sys.exit('Key A must be greater than 0 and Key B must be between 0 and %s.' % (len(SYMBOLS) - 1))
        # keyA和字典总数互质
        if gcd(keyA, len(SYMBOLS)) != 1:
            sys.exit('Key A (%s) and the symbol set size (%s) are not relatively prime. Choose a different key.' % (keyA, len(SYMBOLS)))
    
    # 加密算法
    def encryptMessage(key, message):
        keyA, keyB = getKeyParts(key)
        checkKeys(keyA, keyB, 'encrypt')
        ciphertext = ''
        for symbol in message:
            if symbol in SYMBOLS:
                # 加密单个字符
                symIndex = SYMBOLS.find(symbol)
                ciphertext += SYMBOLS[(symIndex * keyA + keyB) % len(SYMBOLS)]
            else:
                ciphertext += symbol # 如果不在字符集里就在密文里直接加入这个字符
        return ciphertext
    
    # 解密算法
    def decryptMessage(key, message):
        keyA, keyB = getKeyParts(key)
        checkKeys(keyA, keyB, 'decrypt')
        plaintext = ''
        modInverseOfKeyA = findModInverse(keyA, len(SYMBOLS))
    
        for symbol in message:
            if symbol in SYMBOLS:
                # 解密单个字符
                symIndex = SYMBOLS.find(symbol)
                plaintext += SYMBOLS[(symIndex - keyB) * modInverseOfKeyA % len(SYMBOLS)]
            else:
                plaintext += symbol # 如果不在字符集里就在密文里直接加入这个字符
        return plaintext
    
    # 随机出一个可用密钥
    def getRandomKey():
        while True:
            keyA = random.randint(2, len(SYMBOLS))
            keyB = random.randint(2, len(SYMBOLS))
            if gcd(keyA, len(SYMBOLS)) == 1:
                return keyA * len(SYMBOLS) + keyB
    
    def main():
        myMessage = """"A computer would deserve to be called intelligent if it could deceive a human into believing that it was human." -Alan Turing"""
        myKey = getRandomKey() #  例如 2023
        # 加密
        translated = encryptMessage(myKey, myMessage)
        print('Key: %s' % (myKey))
        print('ciphertext : %s' %(translated))
        print()
        # 解密
        print('decrypt hte ciphertext....')
        translated = decryptMessage(myKey, translated)
        print('plaintext :  %s' %(translated))
    
    
    if __name__ == '__main__':
        main()
    

    运行结果

    Key: 3764
    ciphertext : J0[,%6LQz;[@%QnS[Szbz;xz[%[dz[,=nnzS[X]znnXiz][XB[X*[,%QnS[Sz,zXxz[=[1Q6=][X]%[dznXzxX]i[1=[X[@=b[1Q6=]CJ[{0n=][|Q;X]i

    decrypt hte ciphertext…
    plaintext : “A computer would deserve to be called intelligent if it could deceive a human into believing that it was human.” -Alan Turing

    展开全文
  • 破译仿射加密

    万次阅读 2020-02-20 21:51:34
    由于凯撒加密法有“回调”效果,仿射加密法也有。 凯撒加密法受符号集大小的因素,同理仿射加密法也是,可以写个小程序验证。 得出结论: 如果符号集大小是95 那么密钥可能有就是95*95=9025种(未减去不互质数), ...

    思路

    由于凯撒加密法有“回调”效果,仿射加密法也有。
    凯撒加密法受符号集大小的因素,同理仿射加密法也是,可以写个小程序验证。
    得出结论: 如果符号集大小是95 那么密钥可能有就是95*95=9025种(未减去不互质数),
    如果减去不能用的密钥,剩下数字是7125.

    已知可能密钥数,进行暴力破解

    代码实现

    # 验证仿射加密法“回调”效果程序
    def affineKeyTest():
        import affineCipher
    
        message = 'Make things as simple as possible, but not simpler.'
        # 由于0和1不是有效密钥A,所以在2~100尝试
        for keyA in range(2, 100):
            key = keyA * len(affineCipher.SYMBOLS) + 1
            # 如果不互质则跳过
            if affineCipher.gcd(keyA, len(affineCipher.SYMBOLS)) == 1:
                print(keyA, affineCipher.encryptMessage(key, message))
    
    # 调用仿射加密法的 gcd判断 和破译换位加密法的英语单词判断
    import affineCipher, transpositionHacker
    
    def hackAffine(message):
        print('Hacking...')
        # 直接尝试字典大小的平方数大小
        for key in range(len(affineCipher.SYMBOLS) ** 2):
            # 将密钥分成A、B 并取出KeyA进行互质判断
            keyA = affineCipher.getKeyParts(key)[0]
            # 进行密钥A判断是否互质 如果不互质直接下一个循环
            if affineCipher.gcd(keyA, len(affineCipher.SYMBOLS)) != 1:
                continue
            # 尝试解密
            decryptedText = affineCipher.decryptMessage(key, message)
            print('Tried Key %s... (%s)' % (key, decryptedText[:40]))
            # 如果解密判断有英文单词 则判断其可能是正确密钥
            if transpositionHacker.isEnglish(decryptedText):
                print()
                print('Possible encryption hack:')
                print('Key: %s' % (key))
                print('Decrypted message: ' + decryptedText[:200])
                print()
                return decryptedText
        return None
    
    def main():
        myMessage = """U&'<3dJ^Gjx'-3^MS'Sj0jxuj'G3'%j'<mMMjS'g{GjMMg9j{G'g"'gG'<3^MS'Sj<jguj'm'P^dm{'g{G3'%jMgjug{9'GPmG'gG'-m0'P^dm{LU'5&Mm{'_^xg{9"""
    
        hackedMessage = hackAffine(myMessage)
    
        if hackedMessage != None:
            print(hackedMessage)
        else:
            print('Failed to hack encryption.')
    
    if __name__ == "__main__":
       # affineKeyTest()
        main()
    

    结果

    截取一部分
    运行结果

    展开全文
  • 仿射加密体制算法

    2018-04-11 09:23:11
    利用仿射加密体制,对txt文件进行加密,同时进行解密的
  • affine仿射加密

    千次阅读 2018-11-08 14:03:54
    仿射加密法 单码加密法的另一种形式称为仿射加密法(affine cipher)。在仿射加密法中,字母表的字母被赋予一个数字,例如a=0,b=1,c=2…z=25。仿射加密法的密钥为0-25直接的数字对。 含义 仿射加密法与单码加密...

    仿射加密法

    单码加密法的另一种形式称为仿射加密法(affine cipher)。在仿射加密法中,字母表的字母被赋予一个数字,例如a=0,b=1,c=2…z=25。仿射加密法的密钥为0-25直接的数字对。

    含义

    仿射加密法与单码加密法没什么不同,因为明文的每个字母分别只映射到一个密文字母。仿射密码的加密算法就是一个线性变换,即对任意的明文字符x,对应的密文字符为,其中,a,b∈Z26,且要求gcd(a,26)=1,函数e(x)称为仿射加密函数。

    乘法逆元

    举例

    设仿射加密函数是 ,由上表知:11-1mod(26)=19,所以相应的仿射解密函数是

    若加密明文是"sorcery",首先把明文每个字母转换为数字18,14,17,2,4,17,24。然后对明文进行加密,得密文为"welcylk"。

    例题

    y = 17*x-8 flag{szzyfimhyzd}
    
    答案格式:flag{********}

    脚本

    import string  #affine
    
    s = 'szzyfimhyzd'
    s1 = ''
    len =len(s)
    for i in range(0,len):
        a=(23*(ord(s[i])-97+8))%26
        s1+=chr(a+97)
    print s1

     

    展开全文
  • 仿射加密,可以直接运行!仿射加密c代码 仿射加密c代码 仿射加密c代码
  • 仿射加密是一种相对简单的加密,可以帮助理解一些加密算法的原理; 单码加密法的另一种形式称为仿射加密法(affine cipher)。 在仿射加密法中,字母表的字母被赋予一个数字,例如a=0,b=1,c=2…z=25。 仿射加密法...
  • 转盘密码和仿射加密

    2018-11-17 13:50:00
    仿射加密法中,字母表的字母被赋予一个数字,例如a=0,b=1,c=2…z=25。仿射加密法的密钥为0-25直接的数字对。 加密过程较为容易 加密算法:c = a*m + b(mod n) 加密过程: 1,获取a,b,n...
  • 仿射加密(java)

    2020-12-18 13:30:52
    仿射加密的加密过程是一个线性变换: 在仿射加密中,可设0-25对应 'a '-‘z’ 这26个字母。 设y为密文,x为明文,则: y(x)=(k1x+k2) mod 26 并且要求gcd(k1,26)=1;(即k1与26的最大公约数为1) 要求k1和26互素...
  • 仿射加密-C语言

    2019-03-26 16:17:30
    1、[仿射加密概念](https://baike.baidu.com/item/%E4%BB%BF%E5%B0%84%E5%AF%86%E7%A0%81/2250198?fr=aladdin) 2、代码: #include<stdio.h> #include<string.h> void pritext(char text[128]); ...
  • 仿射加密算法的C实现

    2012-05-27 10:37:06
    仿射加密算法的C实现,本人写的代码。加密与解密可以重复进行。
  • 用脚本语言vbscript编写的一个小型加密程序,利用古典加密方式仿射加密,遗憾的是只能进行数字的加密,字母的还没写出来……另外没有解密函数……
  • 仿射加密算法.zip

    2020-03-25 14:54:55
    它的加密函数是,其中a和m互质,m是字母的数目。解码函数是,其中是a在群的乘法逆元. 此密码之首要弱处为,如果密码学家可发现(如频率分析, 暴力破解, 臆测或任何其他方法) 加密文件两字元之原文,则关键值可透过...
  • Affine cipher(仿射加密)

    2020-04-16 21:11:09
    加密函数:f(x) = ax + b (mod m) 解码函数:f(x) = a^(-1)(x - b)(mod m) 求乘法逆元的公式:a*a^(-1)(mod m)...解决仿射加密的首要前提就是理解好上面的三个重要公式,以及什么是互质,什么是乘法逆元,请认真阅读...
  • 这是一个基于VC++基础上的仿射加密\RSA加密\DES加密的文件加密系统,使用MFC使之界面化,操作易懂,对学习VC++绝对有很好的参考价值。除个别文件类型外,一般文件加密后,再解密后大体可以恢复原文件内容.......
  • 加密函数:E(x) = (k1*x + k2) (mod m)=(k1*x)mod 26 +k2,D(x) = k1^{-1} (x - k2) (mod m),这是乘法逆元的解法,本程序采用枚举算法解出,附有详细注释+文本文档,乘法加密是字母对应是a-z对应1-25-0.
  • 三种古典加密算法,对字符串和文件进行加密解密
  • 本程序可进行仿射加密和求解逆元的操作。 1-仿射加密,2-求逆元
  • 仿射加密 #include <iostream> #include <cstdio> using namespace std; char letter[30]; char _letter[30]; char ans_letter[30]; int num[30],s_num[100],k1,k2;const int mod=27; int ...
  • 仿射加密算法

    2021-03-09 15:44:04
    package security; import java.util.HashMap; import java.util.... System.out.println("请输入秘钥,k1,k2,以及加密的字母"); Scanner scanner = new Scanner(System.in); int k = scanner.nextInt();
  • 5.仿射加密

    2020-06-26 23:10:32
    5前面发漏了,现在补上 原理 仿射密码也是一般单表替代...定义加密变换为:c = Ek (m) = k1 m +k2 (mod 26) 相应解密变换为: m = Dk (c) = k1-1 (c-k2) (mod 26) 编程 python实现: # 字母表 LETTERS = 'ABCDEFGHI
  • 深入浅出密码学---仿射加密

    千次阅读 2016-12-27 19:41:18
    仿射加密在本质上还是一个置换密码:如果说移位密码是一个常数级别的置换,那么,仿射加密是一个一次级别的置换 定义: 不妨设我们讨论的范围是所有的小写字母,其中a为0,z为25,其本质是一个Z26的整数环 假设...
  • 仿射加密加解密算法

    千次阅读 2018-03-31 16:16:17
    仿射变换加密加密过程:加密算法:c=a*m+ b(mod n)加密过程:1.获取a,b(密钥),n(字符个数)2.获取明文。3.加密成密文,明文转换成各个字符所对应的数字,将所得数字带入上面的算法公式,得到数字再转换成对应的...
  • 仿射加密与解密 Z26

    2020-10-08 13:45:12
    仿射代码的加密与解密 Z26 int dx, y, q; void extend_Eulid(int aa, int bb) { if (bb == 0) { dx = 1; y = 0; q = aa; } else { extend_Eulid(bb, aa % bb); int temp = dx; dx = y; y = temp - aa /...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,402
精华内容 560
关键字:

仿射加密