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

最新推荐文章于 2022-09-25 21:46:39 发布
最新推荐文章于 2022-09-25 21:46:39 发布
阅读量2.1k 收藏 1
点赞数 4
分类专栏： 密码学 文章标签： 密码学 c++ lfsr 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yamplusone/article/details/122178355
版权

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

非线性组合模型 G e f f e Geffe Geffe分割攻击

一、非线性组合模型 G e f f e Geffe Geffe​​​发生器的基本介绍

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

在这里插入图片描述

如图所示， G e f f e Geffe Geffe发生器使用了3个 L F S R LFSR LFSR​​移位寄存器他们以非线性方式组合，其中， L F S R 1 LFSR1 LFSR1和 L F S R 3 LFSR3 LFSR3作为复合器的输入， L F S R 2 LFSR2 LFSR2​作为控制复合器。

其中，三个 L F S R LFSR LFSR​的反馈多项式分别为：

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

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

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

非线性组合函数 F F F为:
g ( x 1 , x 2 , x 3 ) = x 1 x 2 ⊕ ( x 2 ⊕ 1 ) x 3 = { x 1 , x 2 = 1 x 3 , x 2 = 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​

二、非线性组合模型 G e f f e Geffe Geffe的初始化过程

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

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

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

将 K ’ K’ K’由低位到高位按照从右到左的顺序依次填入 L F S R 1 LFSR1 LFSR1、 L F S R 2 LFSR2 LFSR2和 L F S R 3 LFSR3 LFSR3。

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

将此时 L F S R LFSR LFSR​的内部状态做为密钥流生成的初态。

三、非线性组合模型 G e f f e Geffe Geffe​分割攻击流程

1.穷举 L F S R 2 LFSR2 LFSR2的初态
2.获得关于 L F S R 1 LFSR1 LFSR1和 L F S R 3 LFSR3 LFSR3初态的线性方程；
3.解方程得到初态
4.根据前100个时刻的乱数，验证初态是否正确

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

1.定义密钥流 K K K​的值并将 K K K​填充到三个 L F S R LFSR LFSR​​的初态中
	string K="1010010010000101010100101010110101101100100111001011010001110011";//K为初始密钥
	string s1,s2,s3;//s1,s2,s3中分别为LFSR1 2 3的初始填充
	s1="11001011010001110011";
	s2="100100001010101001010101101011011001001";
	s3="01000111001110100";
2.将 L F S R LFSR LFSR​空转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.根据 L F S R 2 LFSR2 LFSR2​的值来决定最后输出密钥流的每一位取 L F S R 1 LFSR1 LFSR1还是取 L F S R 3 LFSR3 LFSR3​​的值
	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.枚举 L F S R 2 LFSR2 LFSR2的初态
	int cnt =0;
	int x_len = 1<<39; 
	for(int i=0;i<x_len;i++){
        //中间流程由后面具体解释
    }
5.根据 L F S R 2 LFSR2 LFSR2​的初态，推算出 L F S R 1 LFSR1 LFSR1​和 L F S R 3 LFSR3 LFSR3​的初态
	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.判断是否存在解不出来 L F S R 1 LFSR1 LFSR1或 L F S R 3 LFSR3 LFSR3​​的情况
		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.如果 L F S R 1 LFSR1 LFSR1​和 L F S R 3 LFSR3 LFSR3​的初态均已解出，判断由此时 L F S R 1 LFSR1 LFSR1​​， L F S R 3 LFSR3 LFSR3​和 L F S R 2 LFSR2 LFSR2​所生成的​​密钥与真实值是否相等
	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;
}

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

甘薯Yam
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
非线性序列简述
weixin_44127339的博客
04-28 1459
非线性序列 密钥流生成器可分解为驱动子系统和非线性组合子系统，驱动子系统常用一个或多个线性反馈移位寄存器来实现，非线性组合子系统用非线性组合函数F来实现。为了使密钥流生成器输出的二元序列尽可能复杂，也应保证其周期尽可能大、线性复杂度和不可预测性尽可能高。 采用多个LFSR来构造驱动部分的非线性序列生成器，那么我们也把每个LFSR的输出序列称为驱动序列，显然密钥流生成器的周期不大于各驱动序列的乘积。...
http响应截断攻击（响应拆分攻击）
weixin_44387972的博客
07-28 2477
利用CR，LF字符，匹配http报文的格式，实现服务端响应伪造报文，达到攻击目的。如，污染缓存代理服务器的响应缓存。 回车CR-将光标移动到当前行的开头。 换行LF-将光标“垂直”移动到下一行。（而并不移动到下一行的开头，即不改变光标水平位置） http一条请求对应一条响应的原则，在发起一次正常请求时，在请求数据中加入预定义好的响应信息用作伪造服务器的相应内容。 服务器会产生两个响应报文（一个正常响应，一个攻击者伪造的响应），这次正常的请求会返回正常的响应报文。伪造的响应由于没有能够映射的对应请求，
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 之间的数字的公钥。
区块链攻击方式总结二
Leon~博客
03-13 4690
一、总述 当我们强调区块链上的数据难以篡改、去中心化特性时，区块链的攻击也是无时不在的。在区块链的Token经济下，智能合约漏洞、黑客攻击等攻击方式层出不穷。这些攻击来自很多地方，不仅仅是区块链本身的不完善，还包括一些钓鱼网站、对交易所的DDoS攻击、欺骗等手段。 转存失败重新上传取消 目前对区块链的攻击分为三个维度： （1）双花问题，就是一笔钱花了两次。传统的互联网是无法避免双花的。...
Geffe序列生成器及安全性
kali_Chenye的博客
03-11 2631
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​ 其密钥流周期为 ...
第十四讲 & 第十五讲 非线性序列(Geffe序列生成器、J-K触发器、Pless生成器、钟控序列生成器)
coderge's CSDN Blog.
07-29 3286
目录 1 Geffe序列生成器 2J-K触发器 利用J-K触发器的非线性序列生成器 利用J-K触发器的非线性序列生成器的实例 弱点 3Pless生成器 4钟控序列生成器 钟控序列的周期 钟控序列的线性复杂度 钟控序列的例子 钥流生成器可分解为驱动子系统和非线性组合子系统， 如图所示 驱动子系统常用一个或多个线性反馈移位寄存器来实现 非线性组合子系统用非线性组合函数F来实现 为了使密钥流生成器输出的二元序列尽可能复杂，也应保证其周期尽可能大、线性复杂度和不可预测性尽可能...
hammerstein非线性模型matlab代码
10-26
本资源提供了在MATLAB环境下实现Hammerstein非线性模型的代码，对于理解和应用此类模型非常有帮助。 MATLAB是一款强大的数值计算和数据可视化软件，其丰富的函数库和灵活的编程环境使得非线性模型的构建和分析变得...
非线性模型预测控制的matlab参考代码
11-30
本人在硕士期间做的一些有关于非线性模型预测控制的代码，现在已经不再做相关的行业，拿出来与大家分享。 很具有参考价值，相关方向的不容错过，可惜只是matlab仿真，但是并没有去做实现。不过应付应付论文是足够了...
非线性规划问题的Matlab实现求解.doc
11-13
非线性规划问题的 Matlab 实现求解 非线性规划问题是指在数学优化中，目标函数或约束条件中至少有一个是非线性的优化问题。这种问题的解决通常需要建立数学模型，然后使用 Matlab 软件进行求解。本文将对非线性规划...
非线性回归,非线性回归模型,matlab
09-10
文件"03 非线性回归.m"很可能包含了实现上述模型的MATLAB代码，每个模型都配有中文注释，这将帮助用户更好地理解和应用这些模型。通过阅读和理解这些代码，可以学习如何在MATLAB中进行非线性回归分析，从而解决实际...
标准的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
本人安装后感觉使用方便，说明很详细，推荐给大家共享，
unlinemodel_直升机非线性模型_
10-02
"unlinemodel_直升机非线性模型_"这一标题暗示我们将探讨的是一个关于微型直升机的全量非线性动力学模型，这个模型将包括直升机各个关键组件的运动方程，如旋翼、机身、尾桨等，并考虑了空气动力学、陀螺效应、重力...
FPGA组成、工作原理和开发流程
wusuowei1010的博客
03-24 3649
1. FPGA概述 FPGA是英文Field Programmable Gate Array的缩写，即现场可编程门阵列，它是在PAL、GAL、EPLD等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点 2. FPGA芯片结构 FPGA芯片主要由三部分组成，分别是IOE（input o...
密码学系列之四：一文搞懂序列密码
热门推荐
聚集机器学习、信息安全
09-25 1万+
序列密码，又称为流密码，属于对称密码体制，它一次只对明文消息的单个字符（通常是二进制位）进行加解密变换，具有实现简单、速度快、错误传播少等特点，是世界各国的军事和外交等领域中使用的主要密码体制之一。 本文介绍了序列密码的基本概念与原理，以及常用的序列密码：RC4、A5。
信息安全第四章 密码学
qq_44165890的博客
11-12 2684
第四章 密码学 * （重点、计算题 了解密码学发展历史，掌握密码体制模型及概念、密码体制原则、密码体制的分类、密码体制的安全性分类及典型攻击； 掌握分组密码设计的一般原理，了解DES算法；（重点） 掌握序列密码的基本原理，掌握线性反馈寄存器，掌握非线性序列的生成方法； （重点） 掌握哈希函数的概念、结构及应用，了解典型的哈希算法，掌握消息验证码概念，了解基于DES和Hash的消息认证码； （重点） 掌握公开密钥密码系统的特点及原理，掌握RSA的公钥密码算法，了解数字签名的特点和原理； （重点） 理解并掌握密
5.30【加密和安全】- Geffe Hash 流量劫持
网安进阶ing
05-30 778
加密和安全 牛客网每日刷题
浅谈HTTP响应拆分攻击(一)
weixin_33898233的博客
11-12 2187
在本文中，我们将探讨何谓HTTP响应拆分以及攻击行为是怎样进行的。一旦彻底理解了其发生原理（该原理往往被人所误解），我们就可以探究如何利用响应拆分执行跨站点脚本（简称XSS）。接下来自然就是讨论如果目标网站存在响应拆分漏洞，我们要如何利用这一机会组织CSRF（即跨站点伪造请求）攻击。最后，我们一起来看看哪些预防措施能够抵御这些攻击行为。如果大家对这个话题...
http应答分割攻击
mgxcool的专栏
06-11 2633
phpbb上的一个比较经典的漏洞，估计这个攻击也是因为这个漏洞而来的，没见到在其它地方出现过这个漏洞。 产生原因大概是这样： phpbb会将用户请求中的参数放到response的refresh头中。 如： GET /a.php?url=test.php 那么response中就会多出如下一个refresh头： REFRESH:0;URL=http://SERVE
线性+非线性组合预测模型
最新发布
01-13
线性+非线性组合预测模型是一种将线性模型和非线性模型相结合的方法，用于进行预测和控制。这种组合模型的目的是充分利用线性模型和非线性模型各自的优势，提高预测和控制的准确性和稳定性。 一种常见的线性+非线性...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值