C语言实现RSA

最新推荐文章于 2024-07-25 21:31:04 发布
最新推荐文章于 2024-07-25 21:31:04 发布
阅读量3.4k 收藏 30
点赞数 6
分类专栏： 密码学 文章标签： 密码学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44310495/article/details/110571213
版权

参考 《密码学引论》武汉大学出版社

RSA简介

1978年美国麻省理工学院的三名密码学者R.L.Rivest, A.Shamir和L.M.Adleman提出了一种基于大合数因子分解困难性的公开密钥密码，简称RSA密码。

RSA密码被誉为是一种风格幽雅的公开密钥密码。由于RSA密码即可用于加密，又可用于数字签名，安全、易懂。因此，RSA密码已成为目前应用最广泛的公开密钥密码。许多国家标准化组织，如ISO，ITU和SWIFT等都已接受RSA作为标准。Internet网的E-Mail保密系统CPG以及国际的VISA和MASTER组织的电子商务协议（SET协议）中都将RSA密码作为传送会话密钥和数字签名的标准。

RSA加解密过程

  1. 随机地选择两个大素数p和q，而且保密；
  2. 计算n=pq，将n公开
  3. 计算fi=(p-1)*(q-1)，对fi保密
  4. 随机选择一个正整数e，1<e<fi 且e和fi 互素
  5. 根据 ed=1 mod fi，求出d，并对d保密
  6. 加密运算：C=M^e mod n
  7. 解密运算：M=C^d mod n

简单实现

#include<stdio.h> 

int main(){
	int p=3,q=5;
	int n=p*q,fi=(p-1)*(q-1);
	int e=3,d;
	
	int i;
	for(i=0;i<fi;i++){
		if((i*e)%fi==1){
			d=i;break;
		}
	}
	printf("p:%d q:%d n:%d fi:%d e:%d d:%d\n",p,q,n,fi,e,d);
	
	int m=7,c=1,tmp=1;
	for(i=0;i<e;i++){
		c=(c*m)%n;
	}
	for(i=0;i<d;i++){
		tmp=(tmp*c)%n;
	}
	printf("m:%d c:%d dec:%d\n",m,c,tmp);
	return 0;
}

代码效果：
在这里插入图片描述

RSA-1024实现

涉及大数运算参考：https://editor.csdn.net/md/?articleId=109395413

#include<stdio.h> 
#include<stdlib.h>
#include<string.h>
#define max(a,b) (a>b?a:b)
#define BUFLEN 514

int a[BUFLEN],b[BUFLEN],c[BUFLEN];

//将数组设置为0 
int setZero(int*num,int len){
	memset(num,0,sizeof(int)*len);
}

void hex_str2hex(char*str,int*num){
	setZero(num,BUFLEN);
	int i,j;
	int len=strlen(str);
	for(i=0;i<len;i++){
		if(str[len-1-i]<58&&str[len-1-i]>47) //0-9
			num[i]=str[len-1-i]-48;
		else if(str[len-1-i]<71&&str[len-1-i]>64) //A-F
			num[i]=10+str[len-1-i]-65;
		else if(str[len-1-i]<103&&str[len-1-i]>96) //a-f
			num[i]=10+str[len-1-i]-97;
	}
}

void hex2hex_str(int*num,char*str){
	int i,tmp;
	memset(str,0,BUFLEN);
	for(i=BUFLEN-1;num[i]==0;i--);//这里还能优化
	for(tmp=0;i>=0;i--,tmp++){
		if(num[i]>=0&&num[i]<=9)str[tmp]=num[i]+'0';
		else str[tmp]=num[i]-10+'A';
	}
}

void str2hex_str(char*str1,char*str2){
	setZero(a,BUFLEN); 
	int i,j,len=strlen(str1);
	for(i=0,j=2*len-1;i<len;i++){		
		a[j--]=(str1[i]>>4)&0xf;
		a[j--]=str1[i]&0xf;
	}
	hex2hex_str(a,str2);
}

void hex_str2str(char*str1,char*str2){
	int i,len=strlen(str1);
	hex_str2hex(str1,a);
	
	memset(str2,0,BUFLEN);
	for(i=0;i<strlen(str1)/2;i++){
		str2[i]=(a[len-1-2*i]<<4)+a[len-2-2*i];
	}
}

int compare(int*num1,int len1,int*num2,int len2){
	int i=len1-1,j=len2-1;
	if(i<j)return -1;
	else if(i>j)return 1;
	else{
		for(;i>=0;i--){
			if(num1[i]>num2[i])
				return 1;
			else if(num1[i]<num2[i])
				return -1;
		}
		return 0;
	}
}

int copy(int*num1,int*num2,int len){
	int j;
	setZero(num1,BUFLEN);
	for(j=0;j<len;j++)
		num1[j]=num2[j];
	return len;
}

//无符号大数加法 ,16进制 
void add(char*str1,char*str2,char*str3){		
	int i,carry=0;
	int len1=strlen(str1),len2=strlen(str2),len=max(len1,len2);
	hex_str2hex(str1,a);
	hex_str2hex(str2,b);
	
	setZero(c,BUFLEN);
	for(i=0;i<len;i++){
		c[i]=(a[i]+b[i]+carry)%16;
		carry=(a[i]+b[i]+carry)/16;
	}
	
	if(carry!=0)
		c[len++]=1;
	hex2hex_str(c,str3);
}

//无符号大数减法，仅当str1大于str2时得到正确结果
 void sub(char*str1,char*str2,char*str3){
	int i,borrow=0;
	int len=strlen(str1);
	hex_str2hex(str1,a);
	hex_str2hex(str2,b);
	
	setZero(c,BUFLEN);
	for(i=0;i<len;i++){
		c[i]=a[i]-b[i]-borrow;
		if(c[i]<0&&i+1<len){
			borrow=1;
			c[i]+=16;
		}
		else
			borrow=0;
	}
	hex2hex_str(c,str3);
}

//带符号大数加法，实际上没用到这个函数 
void signAdd(char*str1,char*str2,char*str3){
	int len1=strlen(str1)-1,len2=strlen(str2)-1;
	hex_str2hex(&str1[1],a);
	hex_str2hex(&str2[1],b);
	
	if(str1[0]==str2[0]){
		add(&str1[1],&str2[1],&str3[1]);
		str3[0]=str1[0];
	}
	
	if(str1[0]!=str2[0]){
		if(compare(a,len1,b,len2)>0){
			sub(&str1[1],&str2[1],&str3[1]);
			str3[0]=str1[0];
		}
		else if(compare(a,len1,b,len2)<0){
			sub(&str2[1],&str1[1],&str3[1]);
			str3[0]=str2[0];
		}
		else{
			strcpy(str3,"+0");
		}
	}
	
	
}

//带符号大数减法
void signSub(char*str1,char*str2,char*str3){
	int len1=strlen(str1)-1,len2=strlen(str2)-1;
	hex_str2hex(&str1[1],a);
	hex_str2hex(&str2[1],b);
	
	char tmp1=str1[0],tmp2=str2[0];
	memset(str3,0,BUFLEN);
	if(tmp1==tmp2){
		if(compare(a,len1,b,len2)>0){
			sub(&str1[1],&str2[1],&str3[1]);
			str3[0]=tmp1;
		}
		else if(compare(a,len1,b,len2)<0){
			sub(&str2[1],&str1[1],&str3[1]);
			if(tmp1=='+')str3[0]='-';
			else str3[0]='+';
		}
		else{
			strcpy(str3,"+0");
		}
	}
	
	if(tmp1!=tmp2){
		add(&str1[1],&str2[1],&str3[1]);
		str3[0]=tmp1;
	}
}

//大数乘法 ,16进制 
void mul(char*str1,char*str2,char*str3) {	
	int i,j,k=0,carry=0,tmp; 
	int len1=strlen(str1),len2=strlen(str2);
	
	hex_str2hex(str1,a);
	hex_str2hex(str2,b);
	
	setZero(c,BUFLEN);
	for(i=0;i<len1;i++){
		for(k=i,j=0;j<len2;j++,k++){
			c[k]+=a[i]*b[j];
		}
	}
	for(i=0;i<=k;i++) {
		c[i]+=carry;
		tmp=c[i];
		c[i]=tmp%16;
		carry=tmp/16;
	}
	
	hex2hex_str(c,str3);
}

//大数除法，16进制 
void div(char*str1,char*str2,char*str3){	
	int i,j,tmp,tmp2=0,borrow=0,temp[BUFLEN]={0},temp2[BUFLEN]={0};
	int len1=strlen(str1),len2=strlen(str2);
	hex_str2hex(str1,a);
	hex_str2hex(str2,b);
	
	
	if(compare(a,len1,b,len2)<0){
		memset(str3,0,BUFLEN);
		return;
	}
	
	setZero(c,BUFLEN);
	while(compare(a,len1,b,len2)>=0){			
		tmp=len1-len2;
		if(tmp==tmp2&&tmp>0)
			tmp--;
		tmp2=tmp;
		
		setZero(temp2,BUFLEN);
		for(i=len1-1;i>=tmp;i--)
			temp2[i]=b[i-tmp];
		copy(temp,a,len1);
		
		if(compare(temp,len1,temp2,len2+tmp)<0)
				continue;
		for(j=1;;j++){
			borrow=0;
			for(i=tmp;i<len1;i++){
				temp[i]=a[i]-temp2[i]-borrow;
				if(temp[i]<0){
					borrow=1;
					temp[i]+=16;
				}
				else
					borrow=0;
			}
			
			for(;temp[i]==0;i--);i++;
			len1=copy(a,temp,i);			
			c[tmp]=j;
			if(compare(temp,len1,temp2,len2+tmp)<0)
				break;
		}
	}
	
	hex2hex_str(c,str3);
}

//大数模运算,16进制 
void mod(char*str1,char*str2,char*str3){
	setZero(c,BUFLEN);
	int i,j,tmp,tmp2=0,borrow=0,temp[BUFLEN]={0},temp2[BUFLEN]={0};
	int len1=strlen(str1),len2=strlen(str2);
	hex_str2hex(str1,a);
	hex_str2hex(str2,b);
	
	
	if(compare(a,len1,b,len2)<0){
		memset(str3,0,BUFLEN);
		hex2hex_str(a,str3);
		return;
	}
	
	while(compare(a,len1,b,len2)>=0){			
		tmp=len1-len2;
		if(tmp==tmp2&&tmp>0)
			tmp--;
		tmp2=tmp;
		
		setZero(temp2,BUFLEN);
		for(i=len1-1;i>=tmp;i--)
			temp2[i]=b[i-tmp];
		copy(temp,a,len1);
		
		if(compare(temp,len1,temp2,len2+tmp)<0)continue;
		for(j=1;;j++){
			borrow=0;
			for(i=tmp;i<len1;i++){
				temp[i]=a[i]-temp2[i]-borrow;
				if(temp[i]<0){
					borrow=1;
					temp[i]+=16;
				}
				else
					borrow=0;
			}
			for(;temp[i]==0;i--);i++;
			len1=copy(a,temp,i);			
			c[tmp]=j;
			if(compare(temp,len1,temp2,len2+tmp)<0)
				break;
		}
	}
	
	hex2hex_str(temp,str3);
}


int exgcd(char*str1,char*str2,char*x, char*y){
	if(strlen(str2)==0){
		strcpy(x,"+1");strcpy(y,"+0");
		return 1;
	}
	
	char temp[BUFLEN];mod(str1,str2,temp);
	int ret=exgcd(str2,temp,y,x);
	
	
	char temp2[BUFLEN+1]={0},temp3[BUFLEN+1]={0};
	div(str1,str2,temp2);
	mul(temp2,&x[1],&temp2[1]);temp2[0]=x[0];
	signSub(y,temp2,temp3);
	strcpy(y,temp3);
	return ret;
}

//扩展欧几里得求e的逆元d 
void genPrivateKey(char*e,char*fi,char*d){
	char x[BUFLEN+1]={0},y[BUFLEN+1]={0};
	int ret=exgcd(e,fi,x,y);
	if(x[0]=='+')
		add(&x[1],"",d);
	else if(x[0]=='-'){
		sub(fi,&x[1],d);
		mod(d,fi,d);
	}
		
}

#define HEX_ENC 0
#define HEX_DEC 1
#define STR_ENC 2
#define STR_DEC 3

//利用反复平方乘加解密 
void enc_dec(char*str,char*key,char*n,char*out,int opt){
	char temp[BUFLEN]={0};
	int key_t[BUFLEN];
	
	if(opt==STR_ENC)
		str2hex_str(str,str);	
	strcpy(temp,"1");
	
	int i,tmp,flag;
	hex_str2hex(key,key_t);
	for(i=strlen(key)*4-1;((key_t[i/4]>>(i%4))&0x1)==0;i--);
	for(;i>=0;i--){
		mul(temp,temp,temp);
		mod(temp,n,temp);
		
		tmp=(key_t[i/4]>>(i%4))&0x1;
		if(tmp==1){
			mul(str,temp,temp);
			mod(temp,n,temp);
		}
	}
	
	if(opt==STR_DEC)
		hex_str2str(temp,out);
	else{
		strcpy(out,temp);
	}
}


int  main(){
	char p[BUFLEN]="e86c7f16fd24818ffc502409d33a83c2a2a07fdfe971eb52de97a3de092980279ea29e32f378f5e6b7ab1049bb9e8c5eae84dbf2847eb94ff14c1e84cf568415";
	char q[BUFLEN]="d7d9d94071fcc67ede82084bbedeae1aaf765917b6877f3193bbaeb5f9f36007127c9aa98d436a80b3cce3fcd56d57c4103fb18f1819d5c238a49b0985fe7b49";
	char p1[BUFLEN],q1[BUFLEN],n[BUFLEN],fi[BUFLEN];
	sub(p,"1",p1);sub(q,"1",q1);mul(p,q,n);mul(p1,q1,fi); //计算获得n和fi 

	char e[BUFLEN]="100001",d[BUFLEN]; //存储公私钥，取e=65537较为合理 
	genPrivateKey(e,fi,d);//获取解密钥 
	
	
	char temp[BUFLEN];
	char M[BUFLEN]="b503be7137293906649e0ae436e29819ea2d06abf31e10091a7383349de84c5b",C[BUFLEN];
	//char M[BUFLEN]="this is a test",C[BUFLEN];
	printf("p: %s\n\nq: %s\n\nn: %s\n\nfi: %s\n\ne: %s\n\nd: %s\n\nM: %s\n\n",p,q,n,fi,e,d,M);
	enc_dec(M,e,n,C,HEX_ENC);
	printf("enc: %s\n\n",C);
	enc_dec(C,d,n,temp,HEX_DEC);
	printf("dec: %s\n\n",temp);	
}

加解密16进制字符串：
在这里插入图片描述

上述代码在Dev C++, VS2010, gcc 中编译均通过，一次完整的加解密时间大概在8秒左右，但是用python写是真的快，1~2秒就完成了。

混z
关注
  • 6
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
完整word版-C语言实现RSA算法.doc
11-24
完整word版-C语言实现RSA算法.doc，表明这是一份关于使用C语言实现RSA算法的文档。 描述解释 该描述为空，未提供任何有用的信息。 标签解释 完整word版-C语言实现RSA，表明这篇文档与RSA算法和C语言的实现有关。 ...
C语言实现RSA加解密.zip
06-13
在这个“C语言实现RSA加解密”的压缩包中，可能包含了一系列用C语言编写的源代码文件，用于演示如何在实际项目中应用RSA算法。 RSA算法的核心原理基于两个大素数的乘积以及它们的欧拉函数的性质。首先，选择两个大...
RSA C语言实现
u012582383的博客
05-14 2343
RSA密钥生成和加解密，前面的C语言实现
RSA.rar_C语言实现RSA
07-15
总的来说，C语言实现RSA加密算法是一个涉及数学、编程和安全性的综合性任务，需要对数论、加密原理和C语言有深入理解。通过这个项目，你可以提升这些技能，并为其他加密算法的实现打下坚实的基础。
C语言rsa验签（源文件，模数，指数，签名文件\签名数据）
weixin_40700617的博客
06-25 237
C语言验签（源文件，模数，指数，签名文件\签名数据）C语言验签（源文件，公钥文件，签名文件）
RSA.rar_C语言实现RSA_rsa_rsa加密解密
09-21
- C语言实现RSA时，需要使用大数库来处理大整数运算，例如GMP（GNU Multiple Precision Arithmetic Library）。 - 程序可能包括素数检测、大数乘法、模幂运算和模逆元计算等模块。 - 在RSA.txt文件中，可能包含了...
rsa2048.rar RSA2048的C语言实现代码
05-18
在C语言中，实现RSA2048需要处理大整数运算。可以使用GMP（GNU Multiple Precision Arithmetic Library）库来支持大整数操作。以下是一些关键步骤： - 导入GMP库，声明大整数变量，并使用gmp_init初始化。 - 实现...
C语言实现大数运算（长整数的加、减、乘、除）
热门推荐
qq_44310495的博客
10-31 2万+
由于整型数的位数有限，因此整型数不能满足大整数（超长整数）的运算要求 。大整数计算是利用字符串来表示大整数，即用字符串的一位字符表示大整数的一位数值，然后根据四则运算规则实现大整数的四则运算。 ...
C语言实现AES加解密
qq_44310495的博客
10-28 8221
C语言实现AES加解密 #include<stdio.h> #include<string.h> #include<time.h> #include<windows.h> #define Nb 4 //数据块行数 #define Nk 4 //密码块行数 #define Nr 10 //轮加密次数 unsigned char RoundKey[4*Nb*(Nr+1)]; //轮密钥 unsigned char Key[17];
C语言实现DES,3DES以及基于3DES的文件加密系统
qq_44310495的博客
10-10 3684
C语言实现3DES文件加密系统DES算法 DES算法 DES（数据加密标准）是一种分组密码。明文，密文和密钥的分组长度都是64位。 DES算法是一种对称加密，通过同一组秘钥进行加密和解密。利用64位秘钥对64位数据进行加密生成一组新的64位数据，其中的转换都是利用统一的表格数组对秘钥和数据转换 ...
C语言实现RC4序列密码
qq_44310495的博客
10-30 3229
RC4序列密码 在密码学中，RC4（来自Rivest Cipher 4的缩写）是一种流加密算法，密钥长度可变。它加解密使用相同的密钥，因此也属于对称加密算法。 RC4密码与基于移位寄存器的序列密码不同，它是一种基于非线性数据表变换的序列密码。它以一个足够大的数据表为基础，对表进行非线性变换，产生非线性的密钥序列。非线性变换的依据即输入密钥。 由于RC4密码算法简单，软件实现容易，加密速度块，因此得到了广泛的应用。目前RC4可能是商用领域应用最广的序列密码。 代码实现 #include<stdio.h&
C语言实现SHA-1
qq_44310495的博客
12-09 3090
参考：《密码学引论》第二版 武汉大学出版社 SHA-1简介 SHA-1（英语：Secure Hash Algorithm 1，中文名：安全散列算法1）是一种密码散列函数，美国国家安全局设计，并由美国国家标准技术研究所（NIST）发布为联邦数据处理标准（FIPS）。SHA-1可以生成一个被称为消息摘要的160位（20字节）散列值，散列值通常的呈现形式为40个十六进制数。（源自百度百科） 具体实现 数据填充 填充数据的母的是使数据长度与448模512同余（这里是指位数）。若数据本身已经满足上述长度要求，让需要进
Miller方法产生、检验素数
qq_44310495的博客
12-16 450
有关Miller方法过程 设n为被检验的整数，n=m*2^t+1，期中m为n-1的最大奇因子，t>=1。记检测n是否为素数的算法为F(l,k)，其中l为正整数，是算法的输入，Pass为布尔型变量。 使用该算法来产生一个大素数还需要做改进，因为用它来产生一个200位的大素数就需要300多秒。但是用来检验素数还是不错的。 代码实现 2000以内的素数如下： char prime[303][4]={ "2","3","5","7","b","d","11","13","17","1d","1f","25
密码学原理精解【8】
基础数学与应用数学
07-17 981
信息学中的熵，特别是在信息论中，用于量化信息的不确定性或随机性。熵的计算是基于随机变量的概率分布来进行的。HX−∑i1nPxilog⁡2PxiHX−i1∑n​Pxi​log2​Pxi​))]其中，X 表示随机变量，n 是 X可能取值的总数，PxiP(x_i)Pxi​是 X取值为xix_ixi​的概率，log⁡2\log_2log2​表示以2为底的对数。
西电网络空间安全综合953考研分享||西安电子科技大学
qq_30953547的博客
07-24 935
线代看的是李永乐的强化视频，资料用的他的《线性代数辅导讲义》，说到他的这本书，真的特别推荐，而且老师真的讲得非常非常好，这本书强化复习我看了两遍，后期做真题的时候遇到忘记的知识点也经常翻，它每章节前都有一个知识框架，复习每一章节之前，可以先看框架，然后再看知识点和对应的题型总结，每章节过完可以做一下后面的练习题。做完上册之后，针对自己的不擅长的题型，去看武忠祥老师的17堂课，他这个是类似专项练习，不需要全看，只挑着自己不擅长的部分看看就可以。英语血的教训，不要拉下阅读，不要拉下阅读，不要拉下阅读！
密码学概述
零度°C的博客
07-25 981
现代密码学包含了从传统的对称加密和非对称加密，到先进的量子加密技术和混合加密方案等多种技术。这些技术在保护信息安全、确保数据完整性和验证身份方面发挥着关键作用。随着技术的不断发展，密码学也在不断演变和提升，以应对新兴的安全威胁和挑战。理解这些技术的工作原理和应用场景对于设计和实现安全系统至关重要。
守望先锋资讯小程序(源码).zip
07-28
守望先锋资讯小程序(源码).zip
无人智能化关键技术及其在火炮系统中的应用_常建龙.caj
最新发布
07-28
无人智能化关键技术及其在火炮系统中的应用_常建龙
C语言实现RSA算法代码
05-16
以下是C语言实现RSA算法的代码示例： ```c #include <stdio.h> #include <stdlib.h> #include <math.h> int main() { int p, q, n, phi, e, d, plain_text, cipher_text, decrypted_text; printf("Enter two prime numbers p and q: "); scanf("%d %d", &p, &q); n = p * q; phi = (p - 1) * (q - 1); // Select an integer e such that 1 < e < phi and gcd(e, phi) = 1. printf("Enter the value of e such that gcd(e, phi) = 1: "); scanf("%d", &e); // Calculate d such that d ≡ e^(-1) (mod phi). d = fmod(pow(e, -1), phi); printf("Enter the plain text: "); scanf("%d", &plain_text); // Encryption: c = (plain_text^e) % n. cipher_text = fmod(pow(plain_text, e), n); printf("Cipher text: %d\n", cipher_text); // Decryption: plain_text = (cipher_text^d) % n. decrypted_text = fmod(pow(cipher_text, d), n); printf("Decrypted text: %d\n", decrypted_text); return 0; } ``` 在该示例中，用户需要输入两个素数`p`和`q`、加密指数`e`以及明文`plain_text`。程序计算出了`n`和`phi`，然后计算出了私钥`d`。使用公钥`(n, e)`对明文进行加密，使用私钥`(n, d)`对密文进行解密。 请注意，此示例仅用于演示目的，实际使用中需要考虑更多的安全性和性能方面的问题。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值