概述：基本上和数学上的仿射变换类似
y=ax+b，通过如此达到一一对应加密。

仿射变换加密加密过程：
加密算法：c=a*m+ b(mod n)
加密过程:
1.获取a，b（密钥），n（字符个数）
2.获取明文。
3.加密成密文，明文转换成各个字符所对应的数字，将所得数字带入上面的算法公式，得到数字再转换成对应的字符
解密过程：
算法：m=a^-1（m-b）（mod n）这里a^-1不是指倒数，而是a关于字符数量模的乘法可逆元，下面介绍一下乘法可逆元
乘法可逆元定义；
群G中任意一个元素a,都在G中有唯一的逆元a‘,具有性质aa'=a'a=e,其中e为群的单位元
这个官方的定义不学数论什么肯定看不太懂。。没事我们只研究数学应用，不学理论，
举个例子好了：
4关于模7的乘法逆元为多少?
可令4X≡1mod7，即可等价于4X=7K+1，其中X,K为整数，求X和K。
由此看出可逆元的通俗定义
如果ax≡1modf，那么a为关于模f的乘法逆元。
另外也有条件，当a与f互素时，a关于模f的乘法逆元有解。如果不互素，则无解。如果f为素数，则从1到f-1的任意数都与f互素，即在1到f-1之间都恰好有一个关于模f的乘法逆元。
再来一个更具体的例子，
求5关于14的乘法逆元
用辗转相除法
14=5*2+4
5=4*1+1
反过来写
1=5-4=5-（14-5*2）=5*3-14
因此5关于模14的乘法逆元为3.
如此即可求出逆元，然后再带入公式即可实现解密。
下面给出仿射加密算法的算法实现。（直观起见采用C++）

#include<iostream>
using namespace std;
#define N 26  //这里只采用26个字母的加解密

//加密
char *encry(char *Plain, int a, int b, int n);
char *decry(char *Cipher, int a, int b, int n);
//获取可行仿射加密的a值数组
void setArr(int Canuse[], int n);
//求GCD（最大公约数）
int Gcd(int a, int b);
//求a关于模n的乘法可逆元
int Multiplicative_inverse_modulo(int Canuse[], int a, int n);
int main() {
	int a, b;
	char str[200] = "";
	cout << ("输入密钥a，b的值") << endl;
	cin >> a >> b;
	cout << "输入明文内容" << endl;
	cin >> str;
	cout << "明文为" << endl;
	cout << str << endl;
	//加密
	encry(str, a, b, N);
	//输出密文
	cout << str << endl;
	//解密
	decry(str, a, b, N);
	//输出解密内容
	cout << str << endl;
	return 0;
}
//加密函数实现
char *encry(char *Plain, int a, int b, int n)
{
	char *tmp = Plain;
	if (Plain == NULL)return NULL;
	while (*Plain) {
		if (' ' == *Plain)
		{
			++Plain;
			continue;
		}
		if ((*Plain < 'A') || (*Plain > 'Z'))
			return NULL;
		*Plain -= 'A';
		*Plain = (a*(*Plain) + b) % n;
		*Plain += 'A';
		++Plain;
	}
	return tmp;
}
//解密所需基础算法实现
void setArr(int Canuse[], int n) {
	for (int i = 1; i < n; i++) {
		if (1 == Gcd(n, i))
			*(Canuse++) = i;
	}
}
int Gcd(int a, int b) {
	int gcd = 0;
	int div = 0;
	//辗转相除法
	do {
		div = a%b;
		gcd = b;
		a = b;
		b = div;
	} while (div);
	return gcd;
}
//求乘法可逆元
int Multiplicative_inverse_modulo(int Canuse[], int a, int n) {
	for (int i = 0; Canuse[i] != 0; i++) {
		if (1 == (a*Canuse[i]) % n)
			return Canuse[i];
	}
	return 0;
}
//解密实现
char *decry(char *Cipher, int a, int b, int n) {
	char *tmp = Cipher;
	int Canuse[32] = { 0 };//符合条件的a值
	int moda = 0;//a的乘法可逆元
	int i = 0;
	if (Cipher == NULL)return NULL;
	for (; i < 32; i++)Canuse[i] = 0;
	setArr(Canuse, n);//存放符合条件的a.
	moda = Multiplicative_inverse_modulo(Canuse, a, n);
	while (*Cipher) {
		if (' ' == *Cipher) {
			++Cipher;
			continue;
		}
		if ((*Cipher < 'A') || (*Cipher > 'Z'))
			return NULL;
		*Cipher -= 'A';
		*Cipher = (moda*(*Cipher - b + n)) % n;
		*Cipher += 'A';
		++Cipher;
	}
	return tmp;
}
只恨数学学的不够多啊。

仿射变换的加密解密分别是：
c = Ea,b(m)  ≡ a, + b(mod 26)
m = Da,b(c) ≡ a^-1(c - b)(mod 26)
其中，a,b是密钥，为满足0≤a,b≤25和gcd(a,26)等于1的整数。
其中gcd(a,26)表示a和26的最大公因子，gcd(a,26)=1表示a和26是
互素的，a^-1表示a的逆元，即a^-1*a ≡ 1mod26。


解析：
加密过程较为容易
加密算法：c = a*m + b(mod n)
加密过程：
1，获取a,b,n；（若未知）
2，获取明文字符串；
3，
1，将每一个明文字符转换成对应的数字；
2，将明文数字带入公式c = a*m + b(mod n)，获取密文对应数字；
3，将密文数字转换成对应的密文字符。
解密过程是是其中难点。
解密算法：m = a^-1(m - b) (mod n)（注：a^用_a表示）
解密过程：
1, 获取a, b,n；（若未知）
2，获取密文字符串；（若未知）
3
1，设置数组coprime为存放与n互素的元素
2，获取value1,value2的最大公约数
3，在coprime中寻找a的模n可逆元_a
4， 1，将每一个
密文字符转换成对应的数字；
2，将密文数字带入公式m = a^-1(m - b) (mod n)，获取明文对应数字；
3，将明文数字转换成对应的明文字符。

下面附上源码
main函数
#include <stdio.h>
#include <assert.h>

#define N 26 //仿射变换默认模数为26
 
//加密算法
char *encode(char *c_str, int a, int b, int n);
//解密算法
char *decode(char *m_str, int a, int b, int n);

//设置数组coprime为存放与n互素的元素
void setCoprime(int coprime[], int n);
//获取value1,value2的最大公约数
int getGcd(int value1, int value2);
//在coprime中寻找a的模n可逆元_a
int get_a(int coprime[], int a, int n);

int main()
{	
	int a = 0;
	int b = 0;

	//str存储明文
	char str[128] = "";

	printf("输入a, b的值\n");
	scanf("%d %d", &a, &b);

	getchar(); //抵消换行符的干扰

	printf("输入str的内容\n");
	gets(str); //注意输入大写字母字符串

	//输出明文
	printf("明文：%s\n", str);

	//加密
	encode(str, a, b, N);

	//检验是否加密成功
	printf("密文：%s\n", str);

	//解密
	decode(str, a, b, N);

	//检验是否解密成功
	printf("明文：%s\n", str);

	return 0;
}


加密函数encode()
//加密算法
char *encode(char *c_str, int a, int b, int n)
{
	char *p_str = c_str; //减小副作用
	assert (c_str);  //判断明文字符串c_str是否为NULL
	
	while (*c_str)
	{
	if (' ' == *c_str)	//遇到空格就跳过
		{
			++c_str;
			continue;
		}

		if ((*c_str < 'A') || (*c_str > 'Z')) //不是‘A’到‘Z’之间的就中断
			assert(0);
		
		*c_str -= 'A';	//将字符转化为对应数字
		*c_str = (a*(*c_str) + b)%n;//加密核心算法
		*c_str += 'A';	//将数字转化为字符

		++c_str;
	}

	return p_str;
}


解密函数decode()
//解密算法
char *decode(char *m_str, int a, int b, int n)
{
	char *p_str = m_str; //减小副作用
	int coprime[32] = {0}; //存放小于n并且与n互素的元素
	int _a = 0; //存放a的模n可逆元
	int i = 0; //迭代因子

	assert (m_str);  //判断密文字符串m_str是否为NULL

	for (; i < 32; i++)  //将数组元素赋为0
		coprime[i] = 0;

	setCoprime(coprime, n);//设置数组coprime存放与n互素的元素

	_a = get_a(coprime, a, n);//在coprime中寻找a的逆元_a

	
	while (*m_str)
	{
		if (' ' == *m_str)  //遇到空格就跳过
		{
			++m_str;
			continue;
		}

		if ((*m_str < 'A') || (*m_str > 'Z')) //不是‘A’到‘Z’之间的就中断
			assert(0);
		*m_str -= 'A';	//将字符转化为对应数字
		*m_str = (_a*(*m_str - b + n))%n;//解密核心算法
		*m_str += 'A';	//将数字转化为字符

		++m_str;
	}

	return p_str;
}


设置数组coprime内容
//设置数组coprime存放与n互素的元素
void setCoprime(int coprime[], int n)
{
	int i = 1;

	for (; i < n; i++)
		if (1 == getGcd(n, i))//判断是否n,i是否互素
			*(coprime++) = i; //将i存入coprime中
}


获取两数最大公约数getGcd()
//获取value1和value2的最大公约数
int getGcd(int value1, int value2)
{
	int gcd = 0; //最大公约数
	int divisor = 0; //余数
	
	do	//辗转相除法
	{	
		divisor = value1 % value2;

		gcd = value2;

		value1 = value2;
		value2 = divisor;

	}while(divisor);

	return gcd;}
获取可逆元_a
//在数组coprime中寻找a的模n可逆元
int get_a(int coprime[], int a, int n)
{
	int i = 0;

	for (; coprime[i] != 0; i++)
		if (1 == (a*coprime[i])%n)
			return coprime[i];

	return 0;
}

个人自建博客http://34.96.139.59/

移位变换（凯撒密码）：单纯的移位


加密：c=m+k(mod26),0<=m<=25
解密：m=c-k（mod26）,0<=c<=25
以英文(26个)为主，c为密文，m为明文。k为密钥


1，确立变量。


密文 mi
明文 ming
密钥参数 k


2，确立函数。


void kaisajiami(char* ming,char* mi,int k)//加密


void kaisajiemi(char* ming,char* mi,int k)//解密


int main()主函数


3，粗略结果实现。


4，完善代码，补充异常情况处理代码。


void kaisajiami(char* ming,char* mi,int k){
int i;
for(i=0;ming[i];i++){
if(ming[i]>64){
if(ming[i]>96){
mi[i]=((ming[i])%97+k)%26+97;
if(mi[i]>122)
mi[i]=mi[i]%122+64;
continue;
}
if(ming[i]<91){ mi[i]=((ming[i])%65+k)%26+65; if(mi[i]>90)
mi[i]=mi[i]+6;
continue;
}
}
mi[i]=ming[i];
}
mi[i]=ming[i];
}


void kaisajiemi(char* ming,char* mi,int k){
int i;
for(i=0;ming[i];i++){
if(ming[i]>64){
if((int)ming[i]>96){
mi[i]=((ming[i])%97-k)%26+97;
if(mi[i]-97<0) mi[i]=97+97-mi[i]; if((int)mi[i]>122)
mi[i]=mi[i]%122+64;
continue;
}
if(ming[i]<91){
mi[i]=((ming[i])%65-k)%26+65;
if(mi[i]-65<0)
mi[i]=mi[i]+26;
continue;
}
}
mi[i]=ming[i];
}
mi[i]=ming[i];
}


int main(){
char str[256]="BEEAKFYDJXUQYHYJIQRYHTYJIQFBQDUYJIIKFUHCQD";
char ming[256];
char mi[256];
int k=3;
cout<<"输入加密/解密文(只对字母处理，并且不会变更大小写)"<>str;
cout<<"输入加密/解密参数k"<>k;
kaisajiami(str,mi,k);
cout<<"加密运算得出密文："<<mi<<endl;
kaisajiemi(str,ming,k);
cout<<"解密得出明文明文："<<ming<<endl;
}


思维导图


另附仿射加密





void jiami(char* ming,char* mi,int a,int b){
int i;
for(i=0;ming[i];i++){
if((int)ming[i]>64){
if((int)ming[i]>96){
mi[i]=((ming[i])%97a+b)%26+97; if((int)mi[i]>122) mi[i]=mi[i]%122+64; continue; } if((int)ming[i]<91){ mi[i]=((ming[i])%65a+b)%26+65;
if((int)mi[i]>90)
mi[i]=mi[i]+6;
continue;
}
}
mi[i]=ming[i];
}
mi[i]=ming[i];
}


void jiemi(char* ming,char* mi,int a,int b){
int c,j,i;
for(j = 1; 1 ; j++){
if(((a*j-1)%26)==0)
break;
}
cout<<"逆元="<<j<<endl;


for(i=0;ming[i];i++){
    if((int)ming[i]>64){
        if((int)ming[i]>96){
            mi[i]=((ming[i])%97-b)*j%26+97;
            if(mi[i]-97<0)
                mi[i]=97+97-mi[i];
            if((int)mi[i]>122)
                mi[i]=mi[i]%122+64;
            continue;
        }
        if((int)ming[i]<91){
            mi[i]=((ming[i])%65-b)*j%26+65;
            if(mi[i]-65<0)
                mi[i]=mi[i]+26;
            continue;
        }
    }
    mi[i]=ming[i];
}
mi[i]=ming[i];


}


int main(){
char str[256]="BEEAKFYDJXUQYHYJIQRYHTYJIQFBQDUYJIIKFUHCQD";
char ming[256];
char mi[256];
int a=7,b=21;
cout<<"输入加密/解密文"<>str;
cout<<"输入加密/解密参数a,b"<>a;
cin>>b;
jiami(str,mi,a,b);
cout<<"加密运算得出密文："<<mi<<endl;
jiemi(str,ming,a,b);
cout<<"解密得出明文明文："<<ming<<endl;
}

文

//仿射变换主要是乘法与加法变换的结合
//C=a*m+k mod 26 加密
//M=a^-1(c-k)mod 26 解密
#include <iostream>
#include<fstream>
#include<string.h>
#include<stdlib.h>
#define MAX 10000
using namespace std;

int gcd(int a, int b) /*辗转相除法求a,b的最大公因数*/
{
    int k = 0;
    do
    {
        k = a%b;
        a = b;
        b = k;
    }
    while(k!=0);
    return a;
}

int Ni(int a, int b) /*求a相对于b的逆元*/
{
    int i = 0;
    while(a*(++i)%b!=1);  //a*i=1 mod b
    return i;
}

void Fshe(char c[MAX],char m) /*仿射密码*/
{
    int length, i=0, ka=0, kb=0, tmp;

    do
    {
        cout<<"ka 和 kb : ";
        cin>>ka>>kb;
        getchar();
        if(gcd(ka,94)!=1)
        {
            cout<<"密钥输入有误，请重新输入!\n";
            //如果输入的秘钥与模数94不互素则需要重新输入
        }
    }
    while(gcd(ka,94)!=1&&m=='d');  //用于验证秘钥的合法性
    length = strlen(c);
    if(m=='e')
    {
        for(i=0; i<length; i++) //加密算法c[i]=ka*m[i]+kb mod 94
        {
            c[i] = (ka*(c[i]-32)+kb)%94+32;  //字符ASCII从32----126

        }
    }
    if(m=='d')
    {
        for(i=0; i<length; i++)  //解密算法 m[i]=Ni*(c[i]-kb)mod 94        {
        {
            c[i] =Ni(ka,94)*((c[i]-32)-kb);  //解密需要使用乘法逆元
        }
    }
    }

int main()
{

    ifstream fin("d:/mingwen.txt",ios::in);  //明文存储的文件
    ofstream fout("d:/miwen.txt",ios::out);    //新建文件存储密文
    ifstream fin1("d:/miwen.txt",ios::in);     //需要打开密文文件
    ofstream fout1("d:/jiemi.txt",ios::out);    // 存储解密后的数据
    char str[MAX],str1[MAX];
    if(!fin)  //依次打开文件
    {
        cout<<"can't open ! please creat the file (d:/mingwen.txt) ! \n";
        exit(1);
    }
    if(!fin1)
    {
        cout<<"can't open fin1!\n";
        exit(1);
    }
    if(!fout)
    {
        cout<<"can't open fout!\n";
        exit(1);
    }
    if(!fout1)
    {
        cout<<"can't open fout1!\n";
        exit(1);
    }
    char m;
    cout<<"请选择加密（e）解密（d）操作：";   //增加操作性选择加密或解密操作
    cin>>m;
    switch(m)
    {
    case 'e':
        fin.getline(str,MAX);
        Fshe(str,m);  //加密操作
        //cout<<str<<endl;  //输出加密后的字符
        fout<<str;
        cout<<"明文已加密！\n";
        break;
    case 'd':
        fin1.getline(str1,MAX);
        Fshe(str1,m); //解密操作
       // cout<<str<<endl;  //输出解密后的字符
        fout1<<str1;
        cout<<"密文已解密！\n";
        break;
    default:
        break;
    }
    fin.close();  //文件操作完后关闭文件
    fout.close();
    fin1.close();
    fout1.close();

    return 0;
}