前言：
 
摘抄自wiki的关于仿射变换的定义：
 
仿射变换，又称仿射映射，是指在几何中，一个向量空间进行一次线性变换并接上一个平移，变换为另一个向量空间。
 
一个对向量
 
 平移
 
，与旋转放大缩小
 
 的仿射映射为
 
  
 
【1】
 
1、移位加密：
 
比方说：把字母表全部向右循环移1位，也就是A变成B，B变成C，... ，
 
Z变成A。
 
用数学一点的术语我觉得所谓“移位”就是映射吧。
 
那么我们可以写出通解公式，——现在是已知明文和加密步骤，进行加密，也就是求密文。
 
New = (Old + k) (mod table)
 
【2】
 
注释：
 
New：要求的密文
 
Old  ：明文
 
k ：移位的位数
 
table：这张表有多大，比方说字母表就是26个字母，table就是26.
 
2、仿射变换：
 
移位加密和仿射变换有啥关系呢？
 
额 ，因为移位加密就是一种放射变换。。。
 
首先我们在1里面的变量命名现在改一下，以便更好地认识，变成：
 
y
 
= (x + b)(mod m) 【3】
 
是不是和【1】很像啦，可惜我们的x没有系数。。
 
但是没关系，我们完全可以自己加上一个系数，把【3】变成：
 
y
 
= (ax + b)(mod m)   a,b为整数； 【4】
 
这样已经很像了，只不过【1】里面的自变量是向量。
 
但是，我们这里讨论的是一维的变换，所以不用用到2维及其以上的向量。(一维数字标记的向量就是普通的数嘛……)
 
3、知道了1、2这些，我们现在的目标就是——
 
"当知道一个一维的仿射变换的加密，
 
a. 怎么把明文加密
 
b.
 
怎么把密文解密 "
 
对于"a.
 
怎么把明文加密"，我们已经解决了，就是【4】那个公式。
 
对于"b.
 
怎么把密文解密"嘛，其实也不复杂。待我不快不慢地说来。
 
首先由【4】我们可以得到什么？
 
没错！就是 y
 
≡ (ax + b)(mod m) —— 这是明显的事实不用证明了。
 
然后正视一下题目是什么：我们现在已知a,b,y,m，要求x。
 
1). 左右移位一下 ,变为y-b
 
≡ (ax)(mod m) 【5】
 
{为啥【5】是对的？
 
首先同余式可以相加，
 
即 若 a ≡ b (mod m),c ≡ d (mod m)， 【*】
 
那么(a +
 
c) ≡ (b + d)(mod m) .
 
——同余式可以相加的证明用同余的定义就好……
 
然后  y ≡ (ax +
 
b)(mod m)
 
-b ≡ -b (mod
 
m)
 
所以……
 
}
 
2). 已知y-b
 
≡ (ax)(mod m)，x未知，求x.
 
现在已知ax ≡(y-b) (mod
 
m)；
 
{首先我们要知道 同余式可以相乘，若【*】，则 ac
 
≡ bd (mod m) .证明同样可以基于同余定义。}
 
这时候我们就脑补了，如果有一个c能使得
 
cax ≡ x ≡ c(y-b) (mod m)就好了！
 
也就是说这个c如果能使得ca = 1或者 更宽一点的：ca ≡ 1(mod
 
m).那么就解决了！
 
3). 于是问题变成了：找一个c使得，ca ≡ 1(mod
 
m)
 
于是很容易联系到费马小定理、欧拉定理一类的。
 
但是费马小定理要求m一定要是素数，这样和我们题目不符。
 
所以看看欧拉定理，对 gcd(a,m) =
 
1(m>1)，有aΦ(m)≡ 1 (mod m)
 
{Φ(m) 为欧拉函数，就是小于等于m的与m互素的正整数个数。如Φ(2) = 1
 
，Φ(6) = 2——6与{1,5}互素。}
 
所以如果ca
 
= aΦ(m)，那么就有ca ≡ 1(mod m)。
 
于是c
 
= aΦ(m)-1. 但是gcd(a,m) = 1，这一点不能漏。
 
4、综上，我们发现了，当c
 
= aΦ(m)-1时 ；
 
cax ≡c(y-b) (mod m)
 
化为 x ≡c(y-b) (mod m) {现在要附加gcd(a,m)=1这个条件了！}
 
5、那么对于仿射变换，
 
我们知道变化规则[即位移b]后，如何把密文[y]翻译成明文[x]呢？
 
结论是：
 
step
 
1.  求 c
 
= aΦ(m)-1
 
step 2.  x ≡c(y-b) (mod m)
 
番外小剧场：
 
窝：你在2里面为啥要改名字？该问题纯属好奇！
 
big窝：此中原因有2——
 
1. 如文中所说，为了更直观地比较。
 
2.
 
也是最根本的原因——变量命名如此之平凡，根本不是我的feel！OK？
 
窝：......
 
窝：第二个问题——你怎么知道同余式符合相加相乘原理？你怎么想到的？
 
big窝：
 
首先"同余式符合相加相乘原理"这个结论在数论里就像是实数有相加相乘的运算一样自然，如果想不到那么你需要找一本数论的书看看，不需要看完这就足以变成你的常识。至于怎么想到的，如果给你一堆数，你能想到的最基本的运算就是做加减乘除了吧？
 
窝：恩……好像是的……
 
big窝：那不就得了，说了同余式符合相加相乘原理是同余式的基本运算。
 
窝：……哦……
 
原文：http://www.cnblogs.com/PeanutPrince/p/3543723.html

加密和解密都是数学函数。对此并没有很多了解。只为一解答一道作业题目来了解这两个函数以及将函数转为代码。
 
先从百度基本了解一下这个加密函数
 
 
只靠通识的数学知识，理解
 
 
是有难度
 
首先是计算优先级的疑惑，通过查资料确认是先计算前面的加法运算，然后再模，所以从非专业人士来说以下的通式形式会更好理解。
 
 
这个式子对于代码来说应该是不难了，但是我要解的题目是类似这样的
 
 
 
 
那么怎么将字母作为可计算的值代入式子呢。参考这个文章
 
https://www.cnblogs.com/Mayfly-nymph/p/12394329 得知，以26个字母为编码系统为例，那么x代表的是字母在编码系统中的位序，
 
以 (3x+4)/mod 26为例，对 this字符进行加密的计算过程是这样
 
 
 
 
明文
 
 
t
 
 
h
 
 
i
 
 
s
 
 
x
 
 
19
 
 
7
 
 
8
 
 
18
 
 
3x+4
 
 
61
 
 
25
 
 
28
 
 
58
 
 
Mod 26
 
 
9
 
 
25
 
 
2
 
 
6
 
 
密文
 
 
j
 
 
z
 
 
c
 
 
g
 
 
了解这个之后，代码实现就很简单了，就是一个转换关系，如下
 
 
 
 
解密函数的形式是这样的：
 
 
𝑎−1表示是 a 关于m的乘法逆元，关于这个概念可以参考这里https://blog.csdn.net/mochounv/article/details/109254137
 
简单来说就是𝑎−1amod26=1,就是一个最小与本身相乘再对26求模结果为1的数，因为a=3，所以这里很容易推算出 𝑎−1=9
 
代码求是这样的：
 
 
所以得到这个系数之后 ，解密函数转成代码也就很简单了，如下：
 
 
所以文中提到的题目，
 
 
根据以上代码转换函数计算结果如下：
 
 
 
 
 
 
源码可以从这里下载：
 
https://download.csdn.net/download/mochounv/13033530

 
文章目录
 
前言
一、移位密码
二、仿射变换
三、全部代码

 
前言
 
 
 
这个代码是很久之前的，已经忘记具体的思路了，你可以结合此文章来了解两个加密方式的内容。
 前两个步骤是对应加密方式的函数，第三个步骤是整合。
 
 
一、移位密码
 
def yiwei(string,number):
    '''
    将字符串的每个字母，向右移动指定的位数，并返回移动后的字符串
    如：A 向右移动3位，返回值为D
    string为字符串，number为整型
    A的ASCII码为65
    '''
    new_string = ""
    string = string.upper()  #转换为大写
    for i in string:        #移位操作
        #转换为ascii码后，经过移位变为新的ascii，再转换回字母
        new_string += chr((ord(i)-65+number)%26+65) 
    return new_string
##print(yiwei('AAA',3)) #测试函数正确性

def yiwei_decode(c):
    '''移位密码解密，并打印解密的结果'''
    for i in range(1,27): #穷尽密钥搜索，遍历范围[1,26]
        print(yiwei(c,i))
    print("解密结束")
##yiwei_decode("A") #测试函数正确性
 
二、仿射变换
 
def fangshe_key(m,c):
    '''
    通过已知的两对明文密文，求解得到两个密钥
    m为明文,c为密文
    [A-Z]转换为数字为[0-25]
    '''
    #大写
    m = m.upper()
    c = c.upper()
    #切片
    m1 = m[:1:]     #明文的第一个字母
    m2 = m[-1::]    #明文的最后一个字母
    c1 = c[:1:]     #密文的第一个字母
    c2 = c[-1::]    #密文的最后一个字母
##    print(m1,m2)
##    print(c1,c2)
    #转换为整数
    m1 = ord(m1)-65
    m2 = ord(m2)-65
    c1 = ord(c1)-65
    c2 = ord(c2)-65
##    print(m1,m2)
##    print(c1,c2)
    #穷举法
    for i in range(0,26):
        for j in range(0,26):
            if (m1*i+j)%26==c1 and (m2*i+j)%26==c2: #同时满足加密算法时
                return i,j
    return False
##print(fangshe_key("IF","ED")) #测试函数正确性

def fangshe_reverse(x,y):
    '''
    计算乘法逆元,求解x^-1(%y)的乘法逆元,并返回对应值
    '''
    i = 0
    while True:
        if x*i%26==1: #符合乘法逆元条件时
            return i
        i += 1
##print(fangshe_reverse(9,26)) #测试函数正确性

def fangshe_decode(c,a,b):
    '''
    仿射变换解密，并打印解密的结果
    c为密文，a和b为密钥
    0<=a,b<=25，且满足gcd(a,26)=1，a^-1表示a的逆元
    加密公式：c = a*m + b%26
    解密公式：m = (a^-1)*(c-b)%26
    '''
    new_string = ''
    c = c.upper() #大写转换
    for i in c: #逐个字母解密
        new_i = ord(i)-65 #转换成数字
        new_i = (fangshe_reverse(a,26)*(new_i - b))%26 #解密
        new_string += chr(new_i + 65) #转换回大写字母
    print(new_string)
    print("解密结束")
##fangshe_decode("ED",9,10) #测试函数正确性
 
三、全部代码
 
 
 
移位密码
 
 
 
 
 
仿射变换
 
 

 
 
 
# coding=utf-8
# 作者：小狐狸FM
# 题目：古典密码
def menu():
    '''
    菜单界面
    '''
    print("-----------------------")
    print("|    0. 退出          |")
    print("|    1. 移位密码解密  |")
    print("|    2. 仿射变换解密  |")
    print("-----------------------")
##menu() #测试函数

def yiwei(string,number):
    '''
    将字符串的每个字母，向右移动指定的位数，并返回移动后的字符串
    如：A 向右移动3位，返回值为D
    string为字符串，number为整型
    A的ASCII码为65
    '''
    new_string = ""
    string = string.upper()  #转换为大写
    for i in string:        #移位操作
        #转换为ascii码后，经过移位变为新的ascii，再转换回字母
        new_string += chr((ord(i)-65+number)%26+65) 
    return new_string
##print(yiwei('AAA',3)) #测试函数正确性

def yiwei_decode(c):
    '''移位密码解密，并打印解密的结果'''
    for i in range(1,27): #穷尽密钥搜索，遍历范围[1,26]
        print(yiwei(c,i))
    print("解密结束")
##yiwei_decode("A") #测试函数正确性

def fangshe_key(m,c):
    '''
    通过已知的两对明文密文，求解得到两个密钥
    m为明文,c为密文
    [A-Z]转换为数字为[0-25]
    '''
    #大写
    m = m.upper()
    c = c.upper()
    #切片
    m1 = m[:1:]     #明文的第一个字母
    m2 = m[-1::]    #明文的最后一个字母
    c1 = c[:1:]     #密文的第一个字母
    c2 = c[-1::]    #密文的最后一个字母
##    print(m1,m2)
##    print(c1,c2)
    #转换为整数
    m1 = ord(m1)-65
    m2 = ord(m2)-65
    c1 = ord(c1)-65
    c2 = ord(c2)-65
##    print(m1,m2)
##    print(c1,c2)
    #穷举法
    for i in range(0,26):
        for j in range(0,26):
            if (m1*i+j)%26==c1 and (m2*i+j)%26==c2: #同时满足加密算法时
                return i,j
    return False
##print(fangshe_key("IF","ED")) #测试函数正确性

def fangshe_reverse(x,y):
    '''
    计算乘法逆元,求解x^-1(%y)的乘法逆元,并返回对应值
    '''
    i = 0
    while True:
        if x*i%26==1: #符合乘法逆元条件时
            return i
        i += 1
##print(fangshe_reverse(9,26)) #测试函数正确性

def fangshe_decode(c,a,b):
    '''
    仿射变换解密，并打印解密的结果
    c为密文，a和b为密钥
    0<=a,b<=25，且满足gcd(a,26)=1，a^-1表示a的逆元
    加密公式：c = a*m + b%26
    解密公式：m = (a^-1)*(c-b)%26
    '''
    new_string = ''
    c = c.upper() #大写转换
    for i in c: #逐个字母解密
        new_i = ord(i)-65 #转换成数字
        new_i = (fangshe_reverse(a,26)*(new_i - b))%26 #解密
        new_string += chr(new_i + 65) #转换回大写字母
    print(new_string)
    print("解密结束")
##fangshe_decode("ED",9,10) #测试函数正确性
    

if __name__=='__main__':
    while True:
        menu()
        choose = int(input("请选择: "))
        if choose==1:   
            string = input("请输入密文: ")
            yiwei_decode(string)
        elif choose==2:            
            string = input("请输入密文: ")
            m = input("已知明文：")
            c = input("对应密文:")
            a,b = fangshe_key(m,c)
            fangshe_decode(string,a,b)
        else:
            break

1、加密
 
加密函数：
 
E(m) = (k1 * m + k2)mod 26 ---->(以英文为载体，有26个字母）
 注意：其中k1与26互为质数
 
2、解密
 
解密函数：
 
D© = k1^-1(c - k2)(mod 26)
 —> k1^-1是k1的乘法逆元素
 重点：求k1的乘法逆元素
 
乘法逆元素：要求在0,1,2,3,4，…，25找一个数，这个数和k1相乘再取模26运算，结果为1。
 
3、破译
 
要求：已知密文，求明文
 未知：密钥 k1、k2
 k1与26互为质数，且k1<26
 故，k1可穷举，1,3,5,7,9,11,15,17,19,21,23,25
 k2为正整数，且k2<26.
 所以暴力破译后，有12*26 = 312 种情况
 
Java代码实现：
 
package com.qul.java1;

import java.util.Scanner;

/**
 * @author Dxkstart
 * @create 2021-05-25 15:21
 */
public class AffineTest {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        System.out.println("1.*****加密*****");
        System.out.println("2.*****解密*****");
        System.out.println("3.*****破译*****");
        System.out.println("4.*****退出*****");
        boolean b = true;
        while (b) {
            System.out.println("请选择功能：");
            int num = scanner.nextInt();

            switch (num) {
                case 1:
                    new Encryption().encryption();
                    break;
                case 2:
                    new Decryption().decryption();
                    break;
                case 3:
                    new Decode().decode();
                    break;
                case 4:
                    b = false;
            }
        }

    }

}


//加密算法
class Encryption {
    String cleartext;//明文
    int k1;//k1与26互为质数
    int k2;

    public void encryption() {
        Scanner scanner = new Scanner(System.in);
        scanner.useDelimiter("\n");

        System.out.println("请输入k1、k2：");
        k1 = scanner.nextInt();
        k2 = scanner.nextInt();

        System.out.println("请输入明文(小写字符)：");
        cleartext = scanner.next();
        System.out.println("密文为：");

        char[] chars = cleartext.toCharArray();//String转char数组
        for (int i = 0; i < chars.length; i++) {
            int q = (int) chars[i];//转ACSll码 97-122
            if (q != 32) {
                int m = (k1 * (q - 97) + k2 % 26) % 26;
                char c = (char) (m + 65);//转大写字符
                System.out.print(c);
            } else {
                System.out.print(" ");
            }
        }
        System.out.println();
    }
}


//解密算法
class Decryption {
    String ciphertext;//密文
    int k1;//k1与26互为质数
    int k2;

    public void decryption() {
        Scanner scanner = new Scanner(System.in);
        scanner.useDelimiter("\n");//可识别空格字符

        System.out.println("请输入k1、k2：");
        k1 = scanner.nextInt();
        k2 = scanner.nextInt();

        System.out.println("请输入密文(大写字符)：");
        ciphertext = scanner.next();
        System.out.println("明文为：");

        //求k1的乘法逆元素
        int M;
        for (M = 0; M < 26; M++) {
            if ((k1 * M) % 26 == 1) {
                break;
            }
        }

        char[] chars = ciphertext.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            int q = (int) chars[i];//转ACSll码 65-90
            if (q != 32) {
                int m = (M * ((q - 65 + 26) - k2)) % 26;
                char c = (char) (m + 97);//转小写字符
                System.out.print(c);
            } else {
                System.out.print(" ");
            }
        }
        System.out.println();
    }
}


//破译算法
class Decode {
    String ciphertext;//密文
    int k1;//k1与26互为质数
    int k2;

    public void decode() {
        Scanner scanner = new Scanner(System.in);
        scanner.useDelimiter("\n");

        System.out.println("请输入密文(大写字符)：");
        ciphertext = scanner.next();
        System.out.println("明文为：");

        //求k1、k2
        for (k1 = 1; k1 <= 26; k1 += 2) {
            if (k1 % 13 != 0) {
                for (k2 = 1; k2 < 26; k2++) {
                    //求k1的乘法逆元素
                    int M;
                    for (M = 0; M < 26; M++) {
                        if ((k1 * M) % 26 == 1) {
                            break;
                        }
                    }

                    char[] chars = ciphertext.toCharArray();
                    for (int i = 0; i < chars.length; i++) {
                        int q = (int) chars[i];//转ACSll码 65-90
                        if (q != 32) {
                            int m = (M * ((q - 65 + 26) - k2)) % 26;
                            char c = (char) (m + 97);//转小写字符
                            System.out.print(c);
                        } else {
                            System.out.print(" ");
                        }
                    }
                    System.out.print("     *****    k1 = " + k1 + "  k2= " + k2);
                    System.out.println();
                }
            }

        }

    }

}



 
举例：
 
加密：
 
 
解密：
 
 
破译：
 
找出有真正意义的句子
 破译结果：algorithms are quite general definitions of arithmetic processes
 K1 = 3 k2 = 5