关于非线性组合模型Geffe的分割攻击实现

最新推荐文章于 2024-06-28 04:02:03 发布
原创 最新推荐文章于 2024-06-28 04:02:03 发布 · 2.3k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#密码学 #c++ #lfsr #安全

本文介绍了Geffe发生器，一个基于三个高阶线性反馈移位寄存器（LFSR）的密钥流生成器。详细阐述了其初始化过程，并详细讨论了针对该系统的分割攻击方法，包括穷举LFSR2的初态，建立线性方程，解方程以及验证解的正确性。同时，提供了C++代码实现攻击流程，但指出由于LFSR2的高阶，攻击在实际中可能面临计算复杂性问题。

密码学学完序列密码后要做关于Geffe的攻击。。。
看来看去就分割攻击比较好写但是这个LFSR2的级数太高了好像写的有点问题
不管了，快期未考试了

非线性组合模型GeffeGeffeGeffe分割攻击

一、非线性组合模型GeffeGeffeGeffe​​​发生器的基本介绍

GeffeGeffeGeffe发生器是1973年GeffeGeffeGeffe​设计的一个密钥流生成器，具体描述如下:

在这里插入图片描述

如图所示，GeffeGeffeGeffe发生器使用了3个LFSRLFSRLFSR​​移位寄存器他们以非线性方式组合，其中，LFSR1LFSR1LFSR1和LFSR3LFSR3LFSR3作为复合器的输入，LFSR2LFSR2LFSR2​作为控制复合器。

其中，三个LFSRLFSRLFSR​的反馈多项式分别为：

f1(x)=x20⊕x3⊕1f_1(x)=x^{20}\oplus x^3\oplus 1f1​(x)=x20⊕x3⊕1​

f2(x)=x39⊕x4⊕1f_2(x)=x^{39}\oplus x^4\oplus 1f2​(x)=x39⊕x4⊕1

f3(x)=x17⊕x3⊕1f_3(x)=x^{17}\oplus x^3\oplus 1f3​(x)=x17⊕x3⊕1

非线性组合函数FFF为:
g(x1,x2,x3)=x1x2⊕(x2⊕1)x3={x1,x2=1x3,x2=0 g(x_1,x_2,x_3)=x_1x_2\oplus(x_2\oplus1)x_3= \begin{cases} x_1,\quad x_2=1\\ x_3,\quad x_2=0 \end{cases} g(x1​,x2​,x3​)=x1​x2​⊕(x2​⊕1)x3​={x1​,x2​=1x3​,x2​=0​

二、非线性组合模型GeffeGeffeGeffe的初始化过程

(1)密钥K=(k63,…,k0)K=(k_{63},…,k_0)K=(k63​,…,k0​)按照如下方式填充：

先将密钥重复链接，得到76比特密钥K’K’K’

K’=(k11,…,k1,k0,k63,…,k0)K’=(k_{11},…, k_1,k_0,k_{63},…,k_{0})K’=(k11​,…,k1​,k0​,k63​,…,k0​)​​

将K’K’K’由低位到高位按照从右到左的顺序依次填入LFSR1LFSR1LFSR1、LFSR2LFSR2LFSR2和LFSR3LFSR3LFSR3。

2）按照密钥流生成方式空转100个时刻

将此时LFSRLFSRLFSR​的内部状态做为密钥流生成的初态。

三、非线性组合模型GeffeGeffeGeffe​分割攻击流程

1.穷举LFSR2LFSR2LFSR2的初态
2.获得关于LFSR1LFSR1LFSR1和LFSR3LFSR3LFSR3初态的线性方程；
3.解方程得到初态
4.根据前100个时刻的乱数，验证初态是否正确

四、分割攻击具体实现代码及注释

1.定义密钥流KKK​的值并将KKK​填充到三个LFSRLFSRLFSR​​的初态中
	string K="1010010010000101010100101010110101101100100111001011010001110011";//K为初始密钥
	string s1,s2,s3;//s1,s2,s3中分别为LFSR1 2 3的初始填充
	s1="11001011010001110011";
	s2="100100001010101001010101101011011001001";
	s3="01000111001110100";
2.将LFSRLFSRLFSR​空转100个时刻并记录下产生的密钥流
void LFSR_f1(int l_xunhuan,string chutai){//LFSR1的实现代码，其中l_xunhuan为循环轮数，chutai为LFSR的初态
	bitset<20>f1(chutai);//初态赋值 
	//cout<<f1.to_string();
	for(int i=1;i<=l_xunhuan;i++){//移位寄存
		int j=f1[0]^f1[17] ;
		len_f1++;
		//string s_out = f1.to_string();
		f1_out += '0'+j;
		f1.operator>>=(1);
		f1[19]=j;
	}
}

void LFSR_f2(int l_xunhuan,string chutai){//LFSR2的实现代码，其中l_xunhuan为循环轮数，chutai为LFSR的初态
	bitset<39>f2(chutai);//初态赋值 
	//cout<<f2.to_string();
	for(int i=1;i<=l_xunhuan;i++){//移位寄存
		int j=f2[0]^f2[35] ;
		len_f2++;
		//string s_out = f2.to_string();
		f2_out += '0'+j;
		f2.operator>>=(1);
		f2[38]=j;
	}
}

void LFSR_f3(int l_xunhuan,string chutai){//LFSR2的实现代码，其中l_xunhuan为循环轮数，chutai为LFSR的初态
	bitset<17>f3(chutai);//初态赋值 
	//cout<<f3.to_string();
	for(int i=1;i<=l_xunhuan;i++){//移位寄存
		int j=f3[0]^f3[14] ;
		len_f3++;
		//cout<<i<<endl;
		//cout<<"f3_out--->"<<f3_out<<endl;
		//string s_out = f3.to_string();
		f3_out += j+'0' ;
		f3.operator>>=(1);
		f3[16]=j;
	}
}

//此为主函数的调用语句
	LFSR_f1(100,s1);
	LFSR_f2(100,s2);
	LFSR_f3(100,s3);
3.根据LFSR2LFSR2LFSR2​的值来决定最后输出密钥流的每一位取LFSR1LFSR1LFSR1还是取LFSR3LFSR3LFSR3​​的值
	string f0_out;//为最终输出密钥流
	for(int i=0;i<100;i++){
		if(f2_out[i]=='1') f0_out+=f1_out[i];
		else f0_out+=f3_out[i];
	}
4.枚举LFSR2LFSR2LFSR2的初态
	int cnt =0;
	int x_len = 1<<39; 
	for(int i=0;i<x_len;i++){
        //中间流程由后面具体解释
    }
5.根据LFSR2LFSR2LFSR2​的初态，推算出LFSR1LFSR1LFSR1​和LFSR3LFSR3LFSR3​的初态
	int cnt =0;
	int x_len = 1<<39; 
	for(int i=0;i<x_len;i++){
		string  sheng_chu;       //生成枚举LFSR2的字符串
		for(int j=0;j<39;j++){
			int k=(i>>j) & 1;
			sheng_chu+=(k+'0');
		}
		f2_out="";
		f3_out="";
		f1_out="";
		LFSR_f2(100,sheng_chu);
		string sheng_f1(100,'2');//初始化LFSR1
		string sheng_f3(100,'2');//初始化LFSR2
		
		for(int j=0;j<100;j++){
			if(f2_out[j]=='0') sheng_f1[j]=f0_out[j];
			else sheng_f3[j]=f0_out[j];
		}
		string sheng(20,'2');
		sheng_f1=sheng+sheng_f1;
		bool flag =true;
		//不断的根据已有关系求解 f1
		while(flag){
			flag=false;
			for(int j=119;j>=20;j--){
				int x=sheng_f1[j-20]-'0',y=sheng_f1[j-3]-'0';
				if(sheng_f1[j]!='2' && (x==2) && (y!=2)){
					sheng_f1[j-20]= (y ^ (sheng_f1[j]-'0'))+'0';
					flag=true ;	
				} 
				else if(sheng_f1[j]!='2' && (x!=2) && (y==2)){
					sheng_f1[j-3]= (x ^ (sheng_f1[j]-'0'))+'0';
					flag=true ;
				}
				else if(sheng_f1[j]=='2' && (x!=2) && (y!=2)){
					sheng_f1[j]=(x^y)+'0';
					flag=true;
				}
			}
		}
		
//		for(int i=0;i<20;i++) cout<<sheng_f1[i];
//		cout<<endl;
		string sheng3(17,'2');
		sheng_f3=sheng3+sheng_f3;
		flag =true;
		//不断的根据已有关系求解 f3
		while(flag){
			flag=false;
			for(int j=116;j>=17;j--){
				int x=sheng_f3[j-17]-'0',y=sheng_f3[j-3]-'0';
				if(sheng_f3[j]!='2' && (x==2) && (y!=2)){
					sheng_f3[j-17]= (y ^ (sheng_f3[j]-'0'))+'0';
					flag=true ;	
				} 
				else if(sheng_f3[j]!='2' && (x!=2) && (y==2)){
					sheng_f3[j-3]= (x ^ (sheng_f3[j]-'0'))+'0';
					flag=true ;
				}
				else if(sheng_f3[j]=='2' && (x!=2) && (y!=2)){
					sheng_f3[j]=(x^y)+'0';
					flag=true;
				}
			}
		}
//		for(int i=0;i<17;i++) cout<<sheng_f3[i];
//		cout<<endl;
		}
	}
6.判断是否存在解不出来LFSR1LFSR1LFSR1或LFSR3LFSR3LFSR3​​的情况
		bool check_f1=true,check_f3=true;
		string temp_f1="",temp_f3="";
		for(int i=0;i<20;i++){
			if(sheng_f1[i]=='2') {
				check_f1=false;//判断是否存在有解不出来的情况
				break;
			}
			temp_f1+=sheng_f1[i];
		}
			
		for(int i=0;i<17;i++){
			if(sheng_f3[i]=='2') {
				check_f3=false;//判断是否存在有解不出来的情况
				break;
			}
			temp_f3+=sheng_f3[i];
		}
7.如果LFSR1LFSR1LFSR1​和LFSR3LFSR3LFSR3​的初态均已解出，判断由此时LFSR1LFSR1LFSR1​​，LFSR3LFSR3LFSR3​和LFSR2LFSR2LFSR2​所生成的​​密钥与真实值是否相等
	if(check_f1 && check_f3) {
			//cnt++;
			f1_out="";
			f3_out="";
			//cout<<"-1"<<endl;
			LFSR_f1(100,temp_f1);//根据f1初始值生成密钥流 
			//cout<<"-2"<<endl;
			//cout<<sheng_f3<<endl;
			LFSR_f3(100,temp_f3);//根据f3初始值生成密钥流 
			//cout<<sheng_f3<<endl;
			//cout<<"-3"<<endl;
			string f_sheng_out;
			//if() f_sheng_out=;
			for(int i=0;i<100;i++){ //根据枚举的f2,f1,f3的值, 生成密钥流 
				if(f2_out[i]=='1') f_sheng_out+=f1_out[i];
				else f_sheng_out+=f3_out[i];
			}
			if(f_sheng_out == f0_out) {//判断是否匹配成功 
				printf("YES\n");
				cout<<temp_f1<<"\n"<<temp_f3<<endl;
			}else{
				printf("NO\n");
				cout<<temp_f1<<"\n"<<temp_f3<<endl;//输出此时计算出的f1,f3 
			}
		}

五、完整代码及运行结果

#include <iostream>
#include <cstdlib>
#include <bitset>
using namespace std;

string f1_out,f2_out,f3_out;
int len_f1,len_f2,len_f3;

void LFSR_f1(int l_xunhuan,string chutai){
	
	bitset<20>f1(chutai);
	//cout<<f1.to_string();
	for(int i=1;i<=l_xunhuan;i++){
		int j=f1[0]^f1[17] ;
		len_f1++;
		//string s_out = f1.to_string();
		f1_out += '0'+j;
		f1.operator>>=(1);
		f1[19]=j;
	}
}

void LFSR_f2(int l_xunhuan,string chutai){
	
	bitset<39>f2(chutai);//初态赋值 
	//cout<<f2.to_string();
	for(int i=1;i<=l_xunhuan;i++){
		int j=f2[0]^f2[35] ;
		len_f2++;
		//string s_out = f2.to_string();
		f2_out += '0'+j;
		f2.operator>>=(1);
		f2[38]=j;
	}
	
}

void LFSR_f3(int l_xunhuan,string chutai){
	
	bitset<17>f3(chutai);//初态赋值 
	//cout<<f3.to_string();
	for(int i=1;i<=l_xunhuan;i++){
		
		int j=f3[0]^f3[14] ;
		len_f3++;
		//cout<<i<<endl;
		//cout<<"f3_out--->"<<f3_out<<endl;
		//string s_out = f3.to_string();
		f3_out += j+'0' ;
		f3.operator>>=(1);
		f3[16]=j;
	}
	
}

int main(){
//	string sy="01010101100010110111";
//			  // 01234567890123456789
//	LFSR_f1(100,sy);
//	cout<<f1_out;
	string K="1010010010000101010100101010110101101100100111001011010001110011";
	string s1,s2,s3;
	s1="11001011010001110011";
	s2="100100001010101001010101101011011001001";
	s3="01000111001110100";
{	
//	bitset<20> sy(s1);
//	for(int i=0;i<20;i++) cout<<sy[i]<<" ";
//	sy.operator<<=(1);
//	string ssyy=sy.to_string();
//	cout<<endl;
//	for(int i=0;i<20;i++) cout<<sy[i]<<" ";
//	cout<<endl;
}
	LFSR_f1(100,s1);
	LFSR_f2(100,s2);
	LFSR_f3(100,s3);
	
	string f0_out;
	for(int i=0;i<100;i++){
		if(f2_out[i]=='1') f0_out+=f1_out[i];
		else f0_out+=f3_out[i];
	}
	//
	cout<<"LFSR1--->"<<f1_out<<endl;
	cout<<"LFSR2--->"<<f2_out<<endl;
	cout<<"LFSR3--->"<<f3_out<<endl;
	cout<<"LFSR输出--->"<<f0_out<<endl;
	
	//long long ii=1<<39-1;
	
//	string 
//	for(int i=0;i<39;i++){
//		if((ii>>i & 1)==1) 
//	}

	int cnt =0;
	int x_len = 1<<30; 
	for(int i=0;i<x_len;i++){
		string  sheng_chu;
		for(int j=0;j<39;j++){
			int k=(i>>j) & 1;
			sheng_chu+=(k+'0');
		}
		//sheng_chu="100100001010101001010101101011011001001";
		f2_out="";
		f3_out="";
		f1_out="";
		LFSR_f2(100,sheng_chu);
		string sheng_f1(100,'2');
		string sheng_f3(100,'2');
		
		
		for(int j=0;j<100;j++){
			if(f2_out[j]=='0') sheng_f1[j]=f0_out[j];
			else sheng_f3[j]=f0_out[j];
		}
//		cout<<sheng_f1<<endl;
//		cout<<sheng_f3<<endl;
		string sheng(20,'2');
		sheng_f1=sheng+sheng_f1;
		bool flag =true;
		//不断的根据已有关系求解 f1
		while(flag){
			flag=false;
			for(int j=119;j>=20;j--){
				int x=sheng_f1[j-20]-'0',y=sheng_f1[j-3]-'0';
				if(sheng_f1[j]!='2' && (x==2) && (y!=2)){
					sheng_f1[j-20]= (y ^ (sheng_f1[j]-'0'))+'0';
					flag=true ;	
				} 
				else if(sheng_f1[j]!='2' && (x!=2) && (y==2)){
					sheng_f1[j-3]= (x ^ (sheng_f1[j]-'0'))+'0';
					flag=true ;
				}
				else if(sheng_f1[j]=='2' && (x!=2) && (y!=2)){
					sheng_f1[j]=(x^y)+'0';
					flag=true;
				}
			}
		}
		
//		for(int i=0;i<20;i++) cout<<sheng_f1[i];
//		cout<<endl;
		
		string sheng3(17,'2');
		sheng_f3=sheng3+sheng_f3;
		flag =true;
		//不断的根据已有关系求解 f3
		while(flag){
			flag=false;
			for(int j=116;j>=17;j--){
				int x=sheng_f3[j-17]-'0',y=sheng_f3[j-3]-'0';
				if(sheng_f3[j]!='2' && (x==2) && (y!=2)){
					sheng_f3[j-17]= (y ^ (sheng_f3[j]-'0'))+'0';
					flag=true ;	
				} 
				else if(sheng_f3[j]!='2' && (x!=2) && (y==2)){
					sheng_f3[j-3]= (x ^ (sheng_f3[j]-'0'))+'0';
					flag=true ;
				}
				else if(sheng_f3[j]=='2' && (x!=2) && (y!=2)){
					sheng_f3[j]=(x^y)+'0';
					flag=true;
				}
			}
		}
//		for(int i=0;i<17;i++) cout<<sheng_f3[i];
//		cout<<endl;
		bool check_f1=true,check_f3=true;
		string temp_f1="",temp_f3="";
		for(int i=0;i<20;i++){
			if(sheng_f1[i]=='2') {
				check_f1=false;//判断是否存在有解不出来的情况
				break;
			}
			temp_f1+=sheng_f1[i];
		}
			
		for(int i=0;i<17;i++){
			if(sheng_f3[i]=='2') {
				check_f3=false;//判断是否存在有解不出来的情况
				break;
			}
			temp_f3+=sheng_f3[i];
		}
			
		if(check_f1 && check_f3) {
			//cnt++;
			f1_out="";
			f3_out="";
			//cout<<"-1"<<endl;
			LFSR_f1(100,temp_f1);//根据f1初始值生成密钥流 
			//cout<<"-2"<<endl;
			//cout<<sheng_f3<<endl;
			LFSR_f3(100,temp_f3);//根据f3初始值生成密钥流 
			//cout<<sheng_f3<<endl;
			//cout<<"-3"<<endl;
			string f_sheng_out;
			//if() f_sheng_out=;
			for(int i=0;i<100;i++){ //根据枚举的f2,f1,f3的值, 生成密钥流 
				if(f2_out[i]=='1') f_sheng_out+=f1_out[i];
				else f_sheng_out+=f3_out[i];
			}
			if(f_sheng_out == f0_out) {//判断是否匹配成功 
				printf("YES\n");
				cout<<temp_f1<<"\n"<<temp_f3<<endl;
			}else{
				printf("NO\n");
				cout<<"LFSR1="<<temp_f1<<"\n"<<"LFSR3="<<temp_f3<<endl;//输出此时计算出的f1,f3 
			}
		}
	}
	//cout<<cnt;
}

程序运行展示:
在这里插入图片描述
因LFSR2LFSR2LFSR2级数太高，无法在短时间内结束

信息安全第四章 密码学
qq_44165890的博客
11-12 2928
第四章 密码学 * （重点、计算题 了解密码学发展历史，掌握密码体制模型及概念、密码体制原则、密码体制的分类、密码体制的安全性分类及典型攻击； 掌握分组密码设计的一般原理，了解DES算法；（重点） 掌握序列密码的基本原理，掌握线性反馈寄存器，掌握非线性序列的生成方法； （重点） 掌握哈希函数的概念、结构及应用，了解典型的哈希算法，掌握消息验证码概念，了解基于DES和Hash的消息认证码； （重点） 掌握公开密钥密码系统的特点及原理，掌握RSA的公钥密码算法，了解数字签名的特点和原理； （重点） 理解并掌握密
第十四讲 & 第十五讲 非线性序列(Geffe序列生成器、J-K触发器、Pless生成器、钟控序列生成器)
coderge's 优快云 Blog.
07-29 4323
目录 1 Geffe序列生成器 2J-K触发器 利用J-K触发器的非线性序列生成器 利用J-K触发器的非线性序列生成器的实例 弱点 3Pless生成器 4钟控序列生成器 钟控序列的周期 钟控序列的线性复杂度 钟控序列的例子 钥流生成器可分解为驱动子系统和非线性组合子系统， 如图所示 驱动子系统常用一个或多个线性反馈移位寄存器来实现 非线性组合子系统用非线性组合函数F来实现 为了使密钥流生成器输出的二元序列尽可能复杂，也应保证其周期尽可能大、线性复杂度和不可预测性尽可能...
序列密码知识整理（三 非线性序列）
qq_44827634的博客
05-12 919
序列密码密钥流优化
区块链攻击方式总结二
Leon~博客
03-13 5455
一、总述 当我们强调区块链上的数据难以篡改、去中心化特性时，区块链的攻击也是无时不在的。在区块链的Token经济下，智能合约漏洞、黑客攻击等攻击方式层出不穷。这些攻击来自很多地方，不仅仅是区块链本身的不完善，还包括一些钓鱼网站、对交易所的DDoS攻击、欺骗等手段。 转存失败重新上传取消 目前对区块链的攻击分为三个维度： （1）双花问题，就是一笔钱花了两次。传统的互联网是无法避免双花的。...
Stream-encryption:开发。 LSFR1、geffe 和 RC4 算法
07-04
流加密 开发。 LSFR1、geffe 和 RC4 算法 LSFR1 LSFR1 - 线性反馈移位寄存器。 如果您想加密任何公共信息或数据，您应该使用随机 init 初始化 LSFR1。 钥匙。 此密钥应由 1 或 0 组成，长度等于 23。 该寄存器返回您粘贴到消息输入中的加密消息。 LSFR1 函数还带回生成的密钥，该密钥已用于加密。 杰夫 Geffe - 加密算法的名称，它使用三个线性反馈移位寄存器对数据进行加密。 它有三个输入，用户应该在其中输入公钥。 所以第一个键应该等于32，第二个30，第三个28。 RC4 加密算法，即加密文件。 在开始加密时，用户应粘贴 1 到 255 之间的数字的公钥。
【总结一】现代密码学
FansMing的博客
04-30 1914
密码是指采用特定变换的方法对信息进行加密保护、安全认证的技术、产品和服务。--------《中华人民共和国密码法》密码学是研究编制密码和破译密码的技术科学。研究密码变化的客观规律，应用于编制密码以保护通信秘密的成为密码编码学，应用于破译密码以获取通信情报的，称为密码分析学。​如上图，在Alice向Bob发送信息的过程中存在着许多安全问题，是否有其他人看到信息内容（机密性），信息内容是否被改动（完整性），是否是Alice发送的信息（消息源认证），是否是发给Bob的信息（通信实体认证。
非线性序列简述
weixin_44127339的博客
04-28 1627
非线性序列 密钥流生成器可分解为驱动子系统和非线性组合子系统，驱动子系统常用一个或多个线性反馈移位寄存器来实现，非线性组合子系统用非线性组合函数F来实现。为了使密钥流生成器输出的二元序列尽可能复杂，也应保证其周期尽可能大、线性复杂度和不可预测性尽可能高。 采用多个LFSR来构造驱动部分的非线性序列生成器，那么我们也把每个LFSR的输出序列称为驱动序列，显然密钥流生成器的周期不大于各驱动序列的乘积。...
Geffe序列生成器及安全性
kali_Chenye的博客
03-11 3106
Geffe序列生成器 Geffe序列生成器由三个长度为L1，L2，L3的最长LFSR定义组成，其中L1，L2，L3两两互素其中LFSR2作为控制生成器使用。其非线性组合函数为： f（x1,x2,x3)=x1x2⊕x2x3⊕x3 f（x_1,x_2,x_3)=x_1x_2\oplus x_2x_3\oplus x_3 f（x1​,x2​,x3​)=x1​x2​⊕x2​x3​⊕x3​ 其密钥流周期为 ...
密码学系列之四：一文搞懂序列密码
热门推荐
聚集机器学习、信息安全
09-25 1万+
序列密码，又称为流密码，属于对称密码体制，它一次只对明文消息的单个字符（通常是二进制位）进行加解密变换，具有实现简单、速度快、错误传播少等特点，是世界各国的军事和外交等领域中使用的主要密码体制之一。 本文介绍了序列密码的基本概念与原理，以及常用的序列密码：RC4、A5。
FPGA组成、工作原理和开发流程
wusuowei1010的博客
03-24 4201
1. FPGA概述 FPGA是英文Field Programmable Gate Array的缩写，即现场可编程门阵列，它是在PAL、GAL、EPLD等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点 2. FPGA芯片结构 FPGA芯片主要由三部分组成，分别是IOE（input o...
标准的Geffe密钥流序列生成器
09-16
程序说明 标准的Geffe密钥流序列生成器 3个LFSR的级数分别为n1=18,n2=17,n3=7,两两互素 array1,array2,array3分别为3个LFSR的初始输入，数字为十进制数 lfsr1，lfsr2，lfsr3分别为3个LFSR的输出 Geffe_out为输出的密钥序列
matlab7.1序列号生成器
01-16
本人安装后感觉使用方便，说明很详细，推荐给大家共享，
5.30【加密和安全】- Geffe Hash 流量劫持
网安进阶ing
05-30 1051
加密和安全 牛客网每日刷题
机器学习笔记（六）机器学习（特征组合--解决非线性问题）
sazass的博客
02-14 4628
主要来源：视频学习网站Google机器学习教程 特征组合 (Feature Crosses) 在机器学习中也常常要解决许多非线性问题，如： 要解决图 2 所示的非线性问题，可以创建一个特征组合。 特征组合：是指通过将两个或多个输入特征相乘来对特征空间中的非线性规律进行编码的合成特征。 “cross”（组合）这一术语来自 cross product（向量积）。我们通过将 x1(横坐标)与 x2(纵...
密码分析之代数攻击简介
MinCong Luo的博客
07-30 2897
代数攻击简介 密码分析是为了还原加密的密文而对密码或系统进行分析的研究.顾名思义,代数密码分析是密码分析方法的一种,主要利用代数技术,如方程求解算法.对于具有简单代数结构的密码,例如具有低代数度的轮函数的密码协议(例如DES的轮函数是一个对合变换),代数密码分析被证明是强大的. 动机(Motivation) 具有简单代数结构的对称加密算法(意即抗代数攻击)正从许多要求具备轻量级实现、高效隐秘对策和低乘法复杂性等特定需求的应用场景中涌现出来. 实现轻量级方案的方法之一是最小化算法circle的logi
浅谈HTTP响应拆分攻击(一)
weixin_33898233的博客
11-12 2274
在本文中，我们将探讨何谓HTTP响应拆分以及攻击行为是怎样进行的。一旦彻底理解了其发生原理（该原理往往被人所误解），我们就可以探究如何利用响应拆分执行跨站点脚本（简称XSS）。接下来自然就是讨论如果目标网站存在响应拆分漏洞，我们要如何利用这一机会组织CSRF（即跨站点伪造请求）攻击。最后，我们一起来看看哪些预防措施能够抵御这些攻击行为。如果大家对这个话题...
http应答分割攻击
mgxcool的专栏
06-11 2738
phpbb上的一个比较经典的漏洞，估计这个攻击也是因为这个漏洞而来的，没见到在其它地方出现过这个漏洞。 产生原因大概是这样： phpbb会将用户请求中的参数放到response的refresh头中。 如： GET /a.php?url=test.php 那么response中就会多出如下一个refresh头： REFRESH:0;URL=http://SERVE
流密码（二）m序列、Geffe序列生成器、钟控生成器
kali_Chenye的博客
06-16 4101
流密码（二）m序列、Geffe序列、钟控生成器 文章目录流密码（二）m序列、Geffe序列、钟控生成器m序列Geffe生成器JK触发器please触发器钟控生成器交错生成器收缩生成器 m序列 定义：若 C(D)∈Z2[D] 是一个L次本原多项式，则 <L,C(D)> 称 为最大长度LFSR。最大长度LFSR在非零初始状态下的输出称为m序列。 （m序列的统计性质） 设s是由长为L的最大长度 LFSR所生成的m序列. s满足Golomb随机性假设。即每个m序列也是伪噪声序列 (pn序列）。
密码学及其应用 —— 对称加密技术
最新发布
weixin_65190179的博客
06-28 2015
a. 分割明文：明文消息 m 被分割成`n`位的块，表示为`m1, m2, ..., ml`。如果消息的长度不是`n`的倍数，则需要添加填充（padding），以使最后一个块的大小等于`n`位。b. 填充（Padding）：常见的填充技术包括PKCS#7、ANSI X.923、ISO/IEC 7816-4以及零填充（Zero padding）。RFC 2040提出了与使用RC5算法相关的填充方案。填充确保所有的数据块大小都是一致的，这对于块加密算法的正确执行是必需的。
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值