精华内容
下载资源
问答
  • 多表代换密码跟单表代换密码的区别,主要是,多表代换的代换表有多个。对于加密,交替使用不同的代换表。注意,加密和解密要同步,也就是,加密和解密所用的代换表顺序要一致,不然,解密会出错。 多表代换跟单表...

    一、多表代换

    多表代换密码跟单表代换密码的区别,主要是,多表代换的代换表有多个。对于加密,交替使用不同的代换表。注意,加密和解密要同步,也就是,加密和解密所用的代换表顺序要一致,不然,解密会出错。
    多表代换跟单表代换相比,其主要优点是,多表代换增大了密钥空间,打乱了整体上的统计特性。
    举一个简单的例子:
    假设明文字符集为{1,2,3,4};
    代换表1为{1:2,2:4,3:3,4:1};
    代换表2为{1:4,2:1,3:2,4:3}。
    代换表1和代换表2交替使用。
    现在加密123112。

    123112
    表1232
    表2141

    密文为213421。
    同一明文字符最多出现了3次,而密文中则为2次。其统计特性发生了变化。
    多表代换的密钥不仅仅是代换表,还有代换表的使用顺序和代换表的个数(也叫做周期)。
    如果上述加密先使用代换表2,则结果为:

    123112
    表1424
    表2424

    这样,明文字符出现了4个,而密文中只有两种字符。

    二、维吉尼亚密码

    维吉尼亚密码是最简单的多表代换密码,由多个凯撒移位密码组成。其明文字符集为a~z,26个英文字母。将字母按顺序循环移位k个,形成一个代换表。
    下面是一个简单的实现:

    #include<iostream>
    #include<vector>
    using namespace std;
    //encrypt
    string encrypt(string message,vector<int> &key){
    	for(int i=0;i<message.size();i++){
    		message[i]=(message[i]-'a'+key[i%key.size()])%26+'a';
    	}
    	return message;
    }
    //decipher
    string decipher(string cipher,vector<int> &key){
    	vector<int> k1=key;
    	for(int i=0;i<key.size();i++){
    		k1[i]=26-key[i];
    	}
    	return encrypt(cipher,k1);
    }
    int main(){
    	vector<int> key={3,7,2};
    	string message,cipher;
    	cout<<"Please enter the message:";
    	cin>>message;
    	cipher=encrypt(message,key);
    	cout<<"The ciphertext is:"<<cipher<<endl;
    	cout<<"After decipher:"<<decipher(cipher,key)<<endl;
    }
    

    测试样例:

    Please enter the message:iloveyou
    The ciphertext is:lsqylarb
    After decipher:iloveyou

    展开全文
  • 密码学】多表代换

    2021-09-07 18:15:48
    解析都在代码里 /* 本版本支持 ASCII码 */ #include <iostream> #include <string> #define N 4 // 定义分组数 using namespace std;...string multiplication(char* str,int a[N][N]);...

    解析都在代码里

    /*
         _/_/_/                                                    
       _/          _/_/_/    _/_/      _/_/_/    _/_/_/  _/  _/_/   
      _/        _/    _/  _/_/_/_/  _/_/      _/    _/  _/_/        
     _/        _/    _/  _/            _/_/  _/    _/  _/           
      _/_/_/    _/_/_/    _/_/_/  _/_/_/      _/_/_/  _/         
                                                                          */
    #include <iostream>
    #include <string>
    #define N 4   // 定义分组数 
    using namespace std;
    
    string multiplication(char* str,int a[N][N]); // 适用于 N*N 与 N*N 的矩阵相乘 
    class cryption{
    	string plaintext;// 明文
    	string encrypt;// 加密文 
    	string decrypt;// 解密文 
    public: 
    	cryption(string a)
    	: plaintext(a){}
    	string out_en(){return this->encrypt;}  
    	string out_de(){return this->decrypt;} // 对密文的赋值,用于解密 
    	void input_en(string en){this->encrypt=en;}
    	void encryption(int a[N][N],int b[N]);  // 加密函数 
    	void decryption(int aa[N][N],int b[N]);  // 解密函数 
    friend string multiplication(char* str,int a[N][N]);
    }; 
    void cryption::encryption(int a[N][N],int b[N])
    {
    	string ssr;
    	string str=this->plaintext;
    	int len=str.size();
    	
    	for(int i=0;i<len/N;i++){
    		ssr+=multiplication(&(str[N*i]),a); // 矩阵乘法 a*str[N*i:N*i+N]=ssr[N*i:N*i+N]
    	}
    	for(int j=0;j<len;j++)ssr[j]=(ssr[j]+b[j%N])%128; // (ssr[j]+b[j%N])mod 128 ->ASCII码 
    	this->encrypt=ssr; 
    }
    void cryption::decryption(int aa[N][N],int b[N])
    {
    	string ssr;
    	string str=this->encrypt;
    	int len=str.size();
    
    	for(int i=0;i<len;i++)str[i]=(str[i]-b[i%N])%128; // (str[i]-b[i%N])mod 128 
    	for(int j=0;j<len/N;j++){
    		ssr+=multiplication(&(str[N*j]),aa);  // 矩阵乘法 a*str[N*j:N*j+N]=ssr[N*i:N*i+N]
    	}
    	this->decrypt=ssr;
    } 
    void is_right(int a[N][N],int aa[N][N]); // 判断密钥正确性 
    void is_right(int a[N][N],int aa[N][N])
    {
    	int b[N][N]={0};
    	for(int i=0;i<N;i++){
    		for(int j=0;j<N;j++)
    		{
    			for(int k=0;k<N;k++) 
    				b[i][j]+=a[i][k]*aa[k][j]; // 矩阵乘法 
    		}
    	}
    	int flag=1; 
    	for(int i=0;i<N;i++){
    		for(int j=0;j<N;j++){
    			cout<<b[i][j]%128<<" ";
    			if(b[i][j]!=1&&i==j)flag=0;
    			if(b[i][j]!=0&&i!=j)flag=0;
    		}	
    		cout<<endl;
    	}
    	if(flag)cout<<"密钥正确"<<endl;
    	else{
    		cout<<"密钥错误"<<endl;
    		exit(1);
    	}
    }
    string multiplication(char* str,int a[N][N])
    {
    	string s="";
    	char c=0;
    	for(int i=0;i<N;i++){
    		for(int j=0;j<N;j++)
    			c=(c+a[i][j]*str[j]+12800)%128; // 矩阵乘法 
    		s+=c;
    		c=0;
    	}
    	return s;
    }
    
    int main()
    {
    //  输入部分	
    	cout<<"请输入加密密钥 a:"<<endl; 
    	int a[N][N],b[N],aa[N][N];
    	for(int i=0;i<N;i++){
    		for(int j=0;j<N;j++)
    			cin>>a[i][j];
    	}
    	cout<<"请输入加密密钥 b:"<<endl; 
    	for(int i=0;i<N;i++)
    		cin>>b[i];
    	cout<<"请输入解密密钥 a:"<<endl; 
    	for(int i=0;i<N;i++){
    		for(int j=0;j<N;j++)
    			cin>>aa[i][j];
    	}
    
    //0 0 1 2 0 0 3 5 2 -1 0 0 -5 3 0 0
    //1 21 8 17
    //0 0 3 1 0 0 5 2 -5 2 0 0 3 -1 0 0
    //	int a[N][N]={0,0,1,2,0,0,3,5,2,-1,0,0,-5,3,0,0};
    //	int b[N]={1,21,8,17};
    //	int aa[N][N]={0,0,3,1,0,0,5,2,-5,2,0,0,3,-1,0,0}; // 题目所给密钥不适用于所有编码,且有错误 
    	
    	string str;
    	is_right(a,aa);
    	getchar();
    	getline(cin,str);
    	int len=str.size();
    	if(len%N){
    		for(int k=0;k<N-len%N;k++)
    			str+=" "; // 长度不是N的倍数补空格 
    	}
    	cryption test(str);
    	test.encryption(a,b);
    	test.decryption(aa,b);
    	cout<<test.out_en()<<endl;
    	cout<<test.out_de()<<endl;
    	return 0;
    }	
    
    
    
    
    

    贴个原始版本来丢人

    #include <iostream>
    #include <string>
    // 标点符号支持 " " "," "." 
    using namespace std;
    void is_right(int a[4][4],int aa[4][4]);
    string encryption(string str,int a[4][4],int b[4]);
    string decryption(string str,int aa[4][4],int b[4]);
    string multiplication(char* str,int a[4][4]);
    
    string multiplication(char* str,int a[4][4])
    {
    	string s="abcd";
    	for(int i=0;i<4;i++){
    		s[i]='A'+(a[i][0]*(str[0]-'A')+a[i][1]*(str[1]-'A')+a[i][2]*(str[2]-'A')+a[i][3]*(str[3]-'A')+2900)%29;
    	}
    	return s;
    }
    void is_right(int a[4][4],int aa[4][4])
    {
    	int b[4][4];
    	int sum=0,flag=1;
    	for(int i=0;i<4;i++){
    		for(int j=0;j<4;j++)
    		{
    			b[i][j]=a[i][1]*aa[1][j]+a[i][2]*aa[2][j]+a[i][3]*aa[3][j]+a[i][0]*aa[0][j];
    		}
    	}
    	int i,j;
    	for(i=0;i<4;i++){
    		for(j=0;j<4;j++)
    		{
    			cout<<b[i][j]%29<<" ";
    		}
    		cout<<endl;
    	}
    }
    
    string encryption(string str,int a[4][4],int b[4])
    {
    	string ss="";
    	int len=str.size();
    	int sum=0; 
    	
    	for(int i=0;i<len/4;i++){
    		ss+=multiplication(&(str[4*i]),a);  
    	}
    	for(int i=0;i<len;i++)ss[i]=(ss[i]+b[i%4]-'A')%29 +'A';
    	return ss; 
    }
    
    string decryption(string str,int aa[4][4],int b[4])
    {
    	string ss="";
    	int len=str.size();
    	int sum=0; 
    	for(int i=0;i<len;i++)str[i]=(str[i]-b[i%4]-'A'+29)%29+'A';
    	for(int i=0;i<len/4;i++){
    		ss+=multiplication(&(str[4*i]),aa);  
    	}
    	for(int k=0;k<len;k++){
    		if(ss[k]=='[') ss[k]=' ';
    		else if(ss[k]=='/') ss[k]=',';
    		else if(ss[k]==']') ss[k]='.';
    	}
    	return ss; 
    }
    
    int main()
    {
    	int n=4,i,j;
    	int a[4][4]={0,0,1,2,0,0,3,5,2,-1,0,0,-5,3,0,0};
    
    	int b[4]={1,21,8,17};
    	int aa[4][4]={0,0,3,1,0,0,5,2,-5,2,0,0,3,-1,0,0};
    	
    //	for(i=0;i<n;i++){
    //		for(j=0;j<n;j++)
    //			cin>>a[i][j];
    //	}
    //	for(i=0;i<n;i++)
    //		cin>>b[i];
    //	for(i=0;i<n;i++){
    //		for(j=0;j<n;j++)
    //			cin>>aa[i][j];
    //	}
    	is_right(a,aa);
    	
    	string str,encrypt,decrypt;
    	getline(cin,str);
    	int len=str.size();
    	if(len%4){
    		for(int k=0;k<4-len%4;k++)
    			str+=" ";
    	}
    	for(int k=0;k<len;k++){
    		if(str[k]==' ') str[k]='[';
    		else if(str[k]==',') str[k]='/';
    		else if(str[k]=='.') str[k]=']';
    	}
    	encrypt=encryption(str,a,b);
    	cout<<encrypt<<endl;
    	decrypt=decryption(encrypt,aa,b);
    	cout<<decrypt<<endl;
    	return 0;
    }	
    
    
    
    
    展开全文
  • 表代换密码体制

    2021-07-27 20:33:04
    表代换密码体制 所谓代换,是指将明文的字符,用字符集的其他字符代替,从而变成密文。单代换,顾名思义,有一张代换中描述了代换关系。值得注意的是,代换关系可以是一对,但是必须要保证的可逆性,即...

    一、单表代换密码体制

    所谓代换,是指将明文的字符,用字符集的其他字符代替,从而变成密文。单表代换,顾名思义,有一张代换表,表中描述了代换关系。值得注意的是,代换关系可以是一对多,但是必须要保证的可逆性,即一个密文字符唯一对应于一个明文的字符,也就是密文解密的唯一性,一个密文解密出一个明文。不过,一个明文可以加密成多个密文。下面举一个例子。
    假设字符集为{a,b,c},,代换所用的字符集为{1,2,3,4,5,6}。
    代换表如下:

    明文字符abc
    密文字符1,23,45,6

    则明文ab可以加密成13,14,23,或24这四种密文中的一种。反之,密文13只能解密成ab。
    这是代换的一般形式。
    当然,我们通常采用的更加特殊的代换,也就是明文字符集和密文字符集一样,这样加解密的过程就是一一对应。每一张代换表就是一个密钥,不一定满足某种规律,他只是对应于字符集的一种排列。所以,一个有n个字符的字符集,最多有n!种不同的代换表,也就是密钥空间为n!。

    二、英文字母单表代换

    现在给出一个26个小写英文字母的单表代换例子。

    #include<iostream>
    #include<map>
    using namespace std;
    //encrypt, message is clear text and table is the substitution table.
    string encrypt(string message,map<char,char>& table){
    	for(int i=0;i<message.size();i++){
    		message[i]=table[message[i]];
    	}
    	return message;
    }
    //decipher, rtable is the inverse of substitution table
    string decipher(string ciphertext,map<char,char>& rtable){
    	for(int i=0;i<ciphertext.size();i++){
    		ciphertext[i]=rtable[ciphertext[i]];
    	}
    	return ciphertext;
    }
    int main(){
    	map<char,char> table,rtable;
    	table['a']='n',table['b']='d',table['c']='q',table['d']='g',table['e']='i';
    	table['f']='a',table['g']='m',table['h']='z',table['i']='s',table['j']='w';
    	table['k']='y',table['l']='t',table['m']='c',table['n']='l',table['o']='f';
    	table['p']='r',table['q']='e',table['r']='p',table['s']='k',table['t']='u';
    	table['u']='o',table['v']='x',table['w']='v',table['x']='j',table['y']='h',table['z']='b';
    	for(auto it:table){
    		rtable[it.second]=it.first;
    	}
    	cout<<"Please input message:";
    	string message;
    	cin>>message;
    	cout<<"The ciphertext is:";
    	string ciphertext;
    	ciphertext=encrypt(message,table);
    	cout<<ciphertext<<endl;;
    	cout<<"After deciphering:"<<decipher(ciphertext,rtable)<<endl;
    }
    
    展开全文
  • 目录应用密码学:古典密码技术单表代替密码多表代替密码 单表代替密码 1.一般单表代替密码 一般单代替密码的原理是以26个英文字母集合上的一个置换Π(派)为密钥,对明文中的每一个字母依次进行变换,变换的方式是...

    应用密码学:单表代替密码简单介绍

    代替密码(Substitution Cipher)



    原理

    一般单代替密码的原理是以26个英文字母集合上的一个置换Π(派)为密钥,对明文中的每一个字母依次进行变换,变换的方式是把明文中的每个字母用它在置换出来的对应项去代替。

    用自己的话来说:
    先按一定顺序写出26个英文字母,这里我们按字母表的顺序,
    例如: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 | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z |
    |代替| Q | W | E | R | T | Y | U | I | O | P | A | S | D | F | G | H | J | K | L | Z | X | C | V | B | N | M |
    这个对应表就是所谓的密钥
    

    密钥

    同上表
    |原表| 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 |
    |代替| Q | W | E | R | T | Y | U | I | O | P | A | S | D | F | G | H | J | K | L | Z | X | C | V | B | N | M |
    

    加密

    我们用上面这个表来加密一段话看看效果
    例如:
    M明文:my name is yg
    ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓
    C密文:dn fqdt ol nu

    对应密钥写出密文为:dn fqdt ol nu


    解密

    将加密的密钥 逆置换 后可以得到解密的密钥(将’代替’这一行重新排序,以这行为主)

    |代替| 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 |
    |原表| K | X | V | M | C | N | O | P | H | Q | R | S | Z | Y | I | J | A | D | L | E | G | W | B | U | F | T |
    

    将密文用原表的字母代替就可以完成解密得到明文
    C密文:dn fqdt ol nu
    ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓
    M明文:my name is yg


    展开全文
  • 字符代换密码

    2021-07-28 19:33:48
    所谓字符代换密码,其实是单代换的一个简单改进,也就是把原来的代换,由单个字符到单个字符的映射,变成了个字符到个字符的映射。比如,原来在单代换中,明文字符a用b代换,字符b用d代换,故ab,加密成...
  • 数据格式、报头信息对于密码体制的安全有重要意义,在密码分析中也起着重要的作用。 在分析或攻击一份密报时利用英文的下述统计特性很有帮助。 ⑴冠词the对英文的统计特性影响很大,它使t,h,th,he和the在单字母、...
  • polyalphabetic-substitution-cipherPolyalphabetic Substitution Cipher:基于仿射变换的多表代换密码的C语言实现多表代换编程实现原理编程语言C编程环境Ubuntu 18.04编译器gcc源代码文件说明polyalphabetic_...
  • 多表替代的实现 原理 package MiMaXue; import java.util.Scanner; public class DuoBiaoTiHuan1{ public static void main(String[] args){ Scanner sc=new Scanner(System.in); System.out.print("请输入...
  • 本文附有丰富的代码,故文章冗长,请对照目录查阅,各大...代换:将明文中的字符替代成其他字符(仿射变换、多表代换)。 在线性空间的变化中,古典加密就是移动并拉伸物体,让物体变得与原来不一样;解密解释将物...
  • 替换密码

    2021-03-16 02:05:58
    要求:实现单替换密码,用键盘接收明文和密钥,屏幕答应替换和密文,大小写敏感,输入健壮性。实际问题:密钥处理应该是这个程序的重点,加密和解密都没有什么要注意的地方。用key[]数组接收keytext[],并分三...
  • 多表代换:编程实现Hill加密算法,输入一段无空格的五个小写字母明文,对其加密并输出密文 撰写实验报告 实验内容 单表代换: 凯撒密码密钥为3,从文本文件中读取明文,用密钥加密,密文保存于对应密文数组 多表...
  • 1古典密码 (1)置换密码 明文字母重新排列,字母本身不变,但是位置发生变化(倒序或者按照按照数组排列后以行或列重新组合) (2)代替密码 分为单表代替密码多表代替密码 单表代替密码中代表性的 ...
  • 置换密码/huanweim 置换密码(Permutation Cipher)又叫换位密码(Transposi-tionCipher),它根据一定的规则重新排列明文,以便打破明文的结构特性。置换密码的特点是保持明文的所有字符不变,只是利用置换打乱了...
  • 置换密码的C代码实现//单置换密码的编程实现(C++)//作者信息:////本程序使用方法:需要在本程序所在的文件夹创建一个"密码学.txt"文档,//该程序所需要的数据全部由该文档提供,然后运行即可得到结果,如需要...
  • 表密码在凯撒密码之上做了改进(对密钥进行置换),原理较为简单。 plaintext = input('明文:') key = input('密钥:') plaintext = plaintext.replace(" ", "") plaintexts = [] keys = [] for p in plain...
  • 古典密码密码学中的其中一个类型,其大部分加密方式都是利用【替换式密码】或【移项式密码】,有时则是两者的混合。 其于历史中经常使用,但现代已经很少使用,大部分的已经不再使用了。 一般而言,经典密码是基于...
  • 满意答案#include "stdio.h"#include "conio.h"main(){ int i,j,k;char a[]="abcdefghigklmnopqrstuvwxyz" ;char str[100];char c[126];char b[126];printf("shurukey:\n");gets(str);strcat(str,(const char *)a);...
  • exint丿ace豪灬回答数:125|被采纳数:1052017-02-21 02:42:47恢复的密钥AlBnCeDdEgFfGcHbIhJiMoNaOzPrQmRsStTvVwXpYyZu-------------------------------------------------------------------恢复的明文the central...
  • 加密算法、截获的部分密文、一个或个明文密文对 选择明文攻击 加密算法、截获的部分密文、自己选择的明文消息,及由密钥产生的相应密文 选择密文攻击 加密算法 、截获的部分密文、自己选择的密文消息,及相应...
  • 一、实验目的 实现对1-1字母代换密码的密码分析 二、实验内容 密文信息: ...
  • 移位密码体制 通俗的来讲,移位密码体制就是通过一个线性变换,即一次方程,是使得在该变换下,明文和密文是一一对应的。下面给出具体的移位的密码体制。 令P=C=K=Z26​(这里的P表示明文空间,C代表密文空间,K代表...
  • 密码学——维吉尼亚密码

    千次阅读 2021-01-22 20:35:16
    维吉尼亚密码是一种使用多表代换的代换密码,是在凯撒密码的基础上扩展出来的多表密码。 维吉尼亚密码引入了“密钥”的概念,根据密钥来决定用哪一行的密表来进行替换,以此来对抗字频统计。 例子如下(密钥为...
  • 仿射密码是一种表单代换密码,字母的每个字母相应的值使用一个简单的数学函数对应一个数值,再把对应数值转换成字母。 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 0 1 2 3 4 5 6 7 8 9 10 11 ...
  • 1,移位密码 先读取输入 K,表示移位密码的参数。然后读取输入的一个只含小写字母的字符串。要求你输出该字符串经过 K 位加密之后的加密串,其中串的长度在 100 以内,0<=K<=25 #include<bits/stdc++.h>...
  • 密码体制等密码学基本概念

    千次阅读 2021-12-11 17:53:55
    密码体制等密码学基本概念 保密通信系统 保密通信系统模型: 包括明文空间(M,信源)、密文空间©、加密秘钥(K1)、解密秘钥(K2)、加密算法(E)、解密算法(D)构成。 保密系统需满足的要求: 保密系统虽然达不到理论...
  • C++实现单置换密码

    2021-03-16 02:06:28
    置换密码的C++代码实现,供大家参考,具体内容如下本程序使用方法:需要在本程序所在的文件夹创建一个"密码学.txt"文档。该程序所需要的数据全部由该文档提供,然后运行即可得到结果,如需要修改数据,必须从...
  • 仿射密码

    2021-04-21 22:43:39
    通过编程实现代换密码算法——仿射密码和简单置换密码算法,加深对古典密码体制的了解,为深入学习密码学奠定基础。 实验内容: 根据仿射密码的实现原理,实现利用仿射密码进行加密和解密的程序。 (1)设计加密程序:...
  • 2.2 代换密码:FSHFPMGHTFVMAZPPZYUBMMGZSOVINFUM KCZMZSOMGZVNFFWKIVAHYZAZSOGFKTUY GTIMGHTIMZYIBNIYWOCFUSAMFZSYBUAHYCDLMFOCILGDZVINCFIAVUNQHYMISAZM CHRUZCHVWSFKBHAOHFPVHEHCIBICHIVF ...
  • 1 密码学 1.1 什么是密码密码学是保障信息安全的核心技术,信息安全是密码学研究与发展的主要动力和目的。 密码学能做什么? 机密性: 如何使得某个数据自己能看懂,别人看不懂 认证: 如何确保数据的正确来源...
  • 密码学替代密码

    2021-12-06 20:29:09
    2、单表替代密码多表替代密码的主要特点是什么? 单表替代密码:加密算法加密时使用一个固定的替换表 多表替代密码:加密算法加密时使用多个替换表 3、简述替代密码和置换密码的主要特点。 替换密码就是将明文中的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 145,806
精华内容 58,322
关键字:

多表代替密码