精华内容
下载资源
问答
  • 用C写的仿射变换加密解密程序,程序过程很简单,不足之处,欢迎提出
  • 仿射加密解密算法

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

    概述:基本上和数学上的仿射变换类似
    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;
    }
    只恨数学学的不够多啊。
    展开全文
  • 密码学之仿射加密解密算法

    万次阅读 多人点赞 2017-03-09 15:38:04
    仿射变换加密解密分别是: 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)=...

    仿射变换的加密解密分别是:

    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;
    }
    


    展开全文
  • =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...

    个人自建博客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;
    }

    展开全文
  • 【现代密码学】仿射密码加密

    千次阅读 2014-11-17 20:37:57
    //仿射变换主要是乘法与加法变换的结合 //C=a*m+k mod 26 加密 //M=a^-1(c-k)mod 26 解密 #include &lt;iostream&gt; #include&lt;fstream&gt; #include&lt;string.h&gt; #include&lt;...
    //仿射变换主要是乘法与加法变换的结合
    //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;
    }
    
    

     

     

    展开全文
  • 仿射密码解密

    万次阅读 2016-06-17 00:07:56
    描述已知仿射加密变换公式为 c = (11 * m) mod 26,试着对密文解密。解析这里我们要强调的是加密过程不是对字符对应的ascii值进行加密,而是用0~25表示a~z26个英文字母。通过乘法加密和加法加密再取模。于是我们...
  • 仿射加密是一种相对简单的加密,可以帮助...仿射变换加密解密分别是: 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.
  • 仿射加密(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互素...
  • DES加密解密算法

    2015-05-22 21:22:51
    DES加密解密算法// 仿射变换加解密.cpp : 定义控制台应用程序的入口点。 //#include #include <conio.h>static char key[10], key_a[5], code[8], key_b[5], temp[10], key_aa[8], key_bb[8], l[4], r[4], l_a[4], ...
  • 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
  • 实验地点:E楼III区503 实验...仿射变换加密解密: 其中a, b为密钥,,且gcd(a, 26)=1 五、实验目的: 1、熟悉仿射密码算法; 2、理解明文(plaintext)、密文(ciphertext)、加密密钥(encryption ke...
  • 仿射密码

    2019-04-27 18:30:34
    仿射变换加密解密: 其中a, b为密钥,,且gcd(a, 26)=1 五、实验目的: 1、熟悉仿射密码算法; 2、理解明文(plaintext)、密文(ciphertext)、加密密钥(encryption key)、解密密钥(decryption key)、加密...
  • 安恒11月赛Crypto 仿射

    2018-11-30 12:45:53
    仿射变换加密解密分别是: 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...
  • 仿射变换加密解密: 其中a, b为密钥, ,且gcd(a, 26)=1 1.参数选取与密钥生成 首先让用户自行输入a,b的值。 判断a与N是否互素。(欧几里得算法) 利用a与N求得a的模逆aa。(扩展欧几里得算法) 由...
  • 用c语言实现用移位变换和仿射变换对信息加密解密。简单实用,是锻炼和学习c语言及从事信息安全领域和密码学的最好学习例子。
  • 仿射变换的加解密分别是: 加密公式:c = Ea,b(m)≡am+b(mod 26) 解密公式:m = Da,b©≡a^(-1)(c-b)(mod 26) 其中a,b是密钥,为满足0&lt;=a,b&lt;=25和gcd(a,26)=1的整数。其中gcd(a,26)表示a和26的最大公...
  • 仿射密码分析和破解

    2020-03-08 17:48:53
    0x01 加密解密表达式 放射加密的数学表达式是 ek(x)=(ax+b)mod 26, 相应的解密变换为dk(y)=a-1(y-b) mod 26 注意这里a,a和26必须公因数必须只能有1。 x,y,ek(x),dk(y)是ABCDEFGHIJKLMNOPQRSTUVWXYZ的序号,从0...
  • 古典密码算法曾经被广泛应用,大都比较简单,使用手工和机械操作来实现加密解密。它的主要对象是文字信息,利用密码算法实现文字信息的加密解密。古典密码学可以分为代替密码(也叫做移位密码)和置换密码(也...
  • 古典密码算法的实现

    2019-09-21 06:56:19
    2、仿射变换加密过程:e(x) = ax + b (mod m) 解密过程:d(e(x)) = a^(-1)*(e(x) - b) mod m 参数要求:a,m互质;a,b互质;m是集合中元素的个数。(例如当前取1~9和a~z中的所有元素作为集合,m为36) 加密...
  • 这种形式的加密手法是仿射变换,其加解密分别如上 所以可以得到a=11,b=6,需要做的工作是根据密文c,密钥a/b求得明文m。这里a−1计算可以利用Python的gmpy2库中invert函数完成 注意仿射变换26个字母按数字0~25记,...
  • 现代密码学第一章复习题

    千次阅读 2017-03-12 21:00:51
    1.设仿射变换加密是E11,23(m)=11m+23(mod 26),对明文“THE NATIONAL SECURITY AGENCY”加密,并使用解密变换D11,23(c)=11-1(c-23) (mod 26)验证你的加密结果。 解:T=19,11·19+23(mod 26)=24,TY
  • 现代密码学期末总结

    千次阅读 2020-06-14 23:32:32
    文章目录写在前面1....2.仿射变换加密解密中a,b为秘钥 (属于单表变换) c=Ea,b(m)=am+b(mod 26) m=Da,b(m)=a-1(c-b)(mod 26) 注意a-1*a≡1 mod 26 3.多表代换密码:其中A为n*n的矩阵,n等于几代表明文
  • iscc2016-basic-find-to-me

    2016-05-30 20:10:00
    已知仿射加密变换为c=(11m+8)mod26,试对密文sjoyuxzr解密 #include <stdio.h> int main(void) { int m,c; while(scanf("%c",&m)) { c = (11 * (m -97)+ 8)%26; ...
  • 【简答题】Java程序设计上机实验手册(完稿)_吴... (1.0分)【简答题】编程实现仿射解密,加密变换为c=7m+3mod23,明文为Strengthening basic education is the only way for a strong country。【简答题】分别鉴赏这...
  • OpenCV学习笔记

    2020-11-22 14:22:07
    文章目录OpenCV基本操作读取图像显示图像保存图像waitKey()创建窗口销毁窗口图像处理基础item()itemset()通道拆分通道合并获取图像属性图像运算加法运算图像加权和按位逻辑运算位平面分解图像加密解密数字水印色彩...
  • 操作系统实验

    2013-12-30 11:30:48
    建议加密过程使用按字符进行异或的方式处理,也可以是仿射加密方式,比如把所有的字符做一个平移变换:A-A+C(A为任意字母表中的字母,C为常数,为了防止越界或溢出,可以改造其为A-(A+C)MOD 256),这里要...
  • 加密变换: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 15 16 17 ...

空空如也

空空如也

1 2
收藏数 28
精华内容 11
关键字:

仿射变换加密解密