如何用C语言实现RSA算法

Posted 2023-03-17

高手请指点...

RSA算法它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作，也很流行。算法的名字以发明者的名字
命名：Ron Rivest, Adi Shamir 和Leonard
Adleman。但RSA的安全性一直未能得到理论上的证明。它经历了各种攻击，至今未被完全攻破。

一、RSA算法 :

首先, 找出三个数, p, q, r,
其中 p, q 是两个相异的质数, r 是与 (p-1)(q-1) 互质的数
p, q, r 这三个数便是 private key

接著, 找出 m, 使得 rm == 1 mod (p-1)(q-1)
这个 m 一定存在, 因为 r 与 (p-1)(q-1) 互质, 用辗转相除法就可以得到了
再来, 计算 n = pq
m, n 这两个数便是 public key

编码过程是, 若资料为 a, 将其看成是一个大整数, 假设 a < n
如果 a >= n 的话, 就将 a 表成 s 进位 (s <= n, 通常取 s = 2^t),
则每一位数均小於 n, 然後分段编码
接下来, 计算 b == a^m mod n, (0 <= b < n),
b 就是编码後的资料

解码的过程是, 计算 c == b^r mod pq (0 <= c < pq),
於是乎, 解码完毕 等会会证明 c 和 a 其实是相等的 :)

如果第三者进行窃听时, 他会得到几个数: m, n(=pq), b
他如果要解码的话, 必须想办法得到 r
所以, 他必须先对 n 作质因数分解
要防止他分解, 最有效的方法是找两个非常的大质数 p, q,
使第三者作因数分解时发生困难
<定理>
若 p, q 是相异质数, rm == 1 mod (p-1)(q-1),
a 是任意一个正整数, b == a^m mod pq, c == b^r mod pq,
则 c == a mod pq

证明的过程, 会用到费马小定理, 叙述如下:
m 是任一质数, n 是任一整数, 则 n^m == n mod m
(换另一句话说, 如果 n 和 m 互质, 则 n^(m-1) == 1 mod m)
运用一些基本的群论的知识, 就可以很容易地证出费马小定理的

<证明>
因为 rm == 1 mod (p-1)(q-1), 所以 rm = k(p-1)(q-1) + 1, 其中 k 是整数
因为在 modulo 中是 preserve 乘法的
(x == y mod z and u == v mod z => xu == yv mod z),
所以, c == b^r == (a^m)^r == a^(rm) == a^(k(p-1)(q-1)+1) mod pq

1. 如果 a 不是 p 的倍数, 也不是 q 的倍数时,
则 a^(p-1) == 1 mod p (费马小定理) => a^(k(p-1)(q-1)) == 1 mod p
a^(q-1) == 1 mod q (费马小定理) => a^(k(p-1)(q-1)) == 1 mod q
所以 p, q 均能整除 a^(k(p-1)(q-1)) - 1 => pq | a^(k(p-1)(q-1)) - 1
即 a^(k(p-1)(q-1)) == 1 mod pq
=> c == a^(k(p-1)(q-1)+1) == a mod pq

2. 如果 a 是 p 的倍数, 但不是 q 的倍数时,
则 a^(q-1) == 1 mod q (费马小定理)
=> a^(k(p-1)(q-1)) == 1 mod q
=> c == a^(k(p-1)(q-1)+1) == a mod q
=> q | c - a
因 p | a
=> c == a^(k(p-1)(q-1)+1) == 0 mod p
=> p | c - a
所以, pq | c - a => c == a mod pq

3. 如果 a 是 q 的倍数, 但不是 p 的倍数时, 证明同上

4. 如果 a 同时是 p 和 q 的倍数时,
则 pq | a
=> c == a^(k(p-1)(q-1)+1) == 0 mod pq
=> pq | c - a
=> c == a mod pq
Q.E.D.

这个定理说明 a 经过编码为 b 再经过解码为 c 时, a == c mod n (n = pq)
但我们在做编码解码时, 限制 0 <= a < n, 0 <= c < n,
所以这就是说 a 等於 c, 所以这个过程确实能做到编码解码的功能

二、RSA 的安全性

RSA的安全性依赖于大数分解，但是否等同于大数分解一直未能得到理论上的证明，因为没有证明破解
RSA就一定需要作大数分解。假设存在一种无须分解大数的算法，那它肯定可以修改成为大数分解算法。目前， RSA
的一些变种算法已被证明等价于大数分解。不管怎样，分解n是最显然的攻击方法。现在，人们已能分解多个十进制位的大素数。因此，模数n
必须选大一些，因具体适用情况而定。

三、RSA的速度

由于进行的都是大数计算，使得RSA最快的情况也比DES慢上倍，无论是软件还是硬件实现。速度一直是RSA的缺陷。一般来说只用于少量数据加密。

四、RSA的选择密文攻击

RSA在选择密文攻击面前很脆弱。一般攻击者是将某一信息作一下伪装( Blind)，让拥有私钥的实体签署。然后，经过计算就可得到它所想要的信息。实际上，攻击利用的都是同一个弱点，即存在这样一个事实：乘幂保留了输入的乘法结构：

( XM )^d = X^d *M^d mod n

前面已经提到，这个固有的问题来自于公钥密码系统的最有用的特征--每个人都能使用公钥。但从算法上无法解决这一问题，主要措施有两条：一条是采用好的公
钥协议，保证工作过程中实体不对其他实体任意产生的信息解密，不对自己一无所知的信息签名；另一条是决不对陌生人送来的随机文档签名，签名时首先使用
One-Way HashFunction 对文档作HASH处理，或同时使用不同的签名算法。在中提到了几种不同类型的攻击方法。

五、RSA的公共模数攻击

若系统中共有一个模数，只是不同的人拥有不同的e和d，系统将是危险的。最普遍的情况是同一信息用不同的公钥加密，这些公钥共模而且互质，那末该信息无需私钥就可得到恢复。设P为信息明文，两个加密密钥为e1和e2，公共模数是n，则：

C1 = P^e1 mod n

C2 = P^e2 mod n

密码分析者知道n、e1、e2、C1和C2，就能得到P。

因为e1和e2互质，故用Euclidean算法能找到r和s，满足：

r * e1 + s * e2 = 1

假设r为负数，需再用Euclidean算法计算C1^(-1)，则

( C1^(-1) )^(-r) * C2^s = P mod n

另外，还有其它几种利用公共模数攻击的方法。总之，如果知道给定模数的一对e和d，一是有利于攻击者分解模数，一是有利于攻击者计算出其它成对的e’和d’，而无需分解模数。解决办法只有一个，那就是不要共享模数n。

RSA的小指数攻击。 有一种提高 RSA速度的建议是使公钥e取较小的值，这样会使加密变得易于实现，速度有
所提高。但这样作是不安全的，对付办法就是e和d都取较大的值。

RSA算法是
第一个能同时用于加密和数字签名的算法，也易于理解和操作。RSA是被研究得最广泛的公钥算法，从提出到现在已近二十年，经历了各种攻击的考验，逐渐为人
们接受，普遍认为是目前最优秀的公钥方案之一。RSA的安全性依赖于大数的因子分解，但并没有从理论上证明破译RSA的难度与大数分解难度等价。即RSA
的重大缺陷是无法从理论上把握它的保密性能
如何，而且密码学界多数人士倾向于因子分解不是NPC问题。
RSA的缺点主要有：A)产生密钥很麻烦，受到素数产生技术的限制，因而难以做到一次一密。B)分组长度太大，为保证安全性，n 至少也要 600
bits
以上，使运算代价很高，尤其是速度较慢，较对称密码算法慢几个数量级；且随着大数分解技术的发展，这个长度还在增加，不利于数据格式的标准化。目
前，SET( Secure Electronic Transaction )协议中要求CA采用比特长的密钥，其他实体使用比特的密钥。

C语言实现

#include <stdio.h>
int candp(int a,int b,int c)
int r=1;
b=b+1;
while(b!=1)

r=r*a;
r=r%c;
b--;

printf("%d\n",r);
return r;

void main()

int p,q,e,d,m,n,t,c,r;
char s;
printf("please input the p,q: ");
scanf("%d%d",&p,&q);
n=p*q;
printf("the n is %3d\n",n);
t=(p-1)*(q-1);
printf("the t is %3d\n",t);
printf("please input the e: ");
scanf("%d",&e);
if(e<1||e>t)

printf("e is error,please input again: ");
scanf("%d",&e);

d=1;
while(((e*d)%t)!=1) d++;
printf("then caculate out that the d is %d\n",d);
printf("the cipher please input 1\n");
printf("the plain please input 2\n");
scanf("%d",&r);
switch(r)

case 1: printf("input the m: "); /*输入要加密的明文数字*/
scanf("%d",&m);
c=candp(m,e,n);
printf("the cipher is %d\n",c);break;
case 2: printf("input the c: "); /*输入要解密的密文数字*/
scanf("%d",&c);
m=candp(c,d,n);
printf("the cipher is %d\n",m);break;

getch();
参考技术A #include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <math.h>

int str2num(char *str) //字符转数字

int i=0,num=0;

for(i=0;i<(int)strlen(str);i++)
num=num*10+str[i]-'0';
return num;



float CarmSqrt(float x) //求平方根 系统的太慢，用了别人的

union

int intPart;
float floatPart;
convertor;

union

int intPart;
float floatPart;
convertor2;

convertor.floatPart = x;
convertor2.floatPart = x;
convertor.intPart = 0x1FBCF800 + (convertor.intPart >> 1);
convertor2.intPart = 0x5f3759df - (convertor2.intPart >> 1);
return 0.5f*(convertor.floatPart + (x * convertor2.floatPart));
//可以不用，用sqrt()也可以

int isPrime(int n) //判断是否为素数

int i=0,k=2;

k=(int)CarmSqrt(n);
for(i=2;i<=k;i++)

if(n%i==0)
break;


if(i>k)
return 1;
else
return 0;



int rnd(int max) //生成随机数 2~max 用来生成e，
//取系统时间做随机数种子
int range,n;
int min=2,flag=0;
time_t t;
double j;

range=max-min;
t=time(NULL);
srand((unsigned)t);

n=rand();

j=((double)n/(double)RAND_MAX);

n=(int)(j*(double)range);
n+=min;

return n;



int co_prime(int a ,int b) // 求互质

int c;
do

if(b==1)
return 1;
c=a%b;
a=b;
b=c;

while(c!=0);
return 0;


void get_d_e(int p,int q)

int r,t,e,d,i=2,k=0;

if(isPrime(p)!=1||isPrime(q)!=1)

printf("Invaild Parameters\nshould be PRIME!\n");
printf("Usage:RSA Prime1 Prime2\n");
exit(0);


r=p*q;

t=(p-1)*(q-1);
e=rnd(t)/10;
while(co_prime(t,e)!=1)

e=e+1;



for(d=2;d<t;d++)

if((e*d)%t==1)
break;


printf("d=%d e=%d r=%d\n",d,e,r);


void en(int n,int e,int r)

//加密


void de(int c,int d,int r)

//解密


void main(int argc,char* argv[])

int n1,n2;

if(argc!=3&&argc!=5)

printf("Invaild Parameters!\n");
printf("Usage: \nRSA -e Express e r\n");
printf("RSA -d Ciphertext d r\n");
printf("RSA Prime1 Prime2\n");//错误输出
exit(0);

else

if(argv[1][0]!='-')

n1=str2num(argv[1]);
n2=str2num(argv[2]);
get_d_e(n1,n2);
exit(0);


else
if(argv[1][1]=='e') //加密

n1=str2num(argv[3]);
n2=str2num(argv[4]);
en(str2num(argv[2]),n1,n2);
exit(0);



if(argv[1][1]=='d') //解密

n1=str2num(argv[3]);
n2=str2num(argv[4]);
en(str2num(argv[2]),n1,n2);
exit(0);



else
printf("Invaild Parameters!\n");
printf("Usage: \nRSA -e Express e r\n");
printf("RSA -d Ciphertext d r\n");
printf("RSA Prime1 Prime2\n");
exit(0);

本回答被提问者采纳 参考技术B 上学期交的作业，已通过老师在运行时间上的测试
#include <stdio.h>
#include <stdlib.h>

unsigned long prime1,prime2,ee;

unsigned long *kzojld(unsigned long p,unsigned long q) //扩展欧几里得算法求模逆

unsigned long i=0,a=1,b=0,c=0,d=1,temp,mid,ni[2];
mid=p;
while(mid!=1)

while(p>q)
p=p-q; mid=p;i++;
a=c*(-1)*i+a;b=d*(-1)*i+b;
temp=a;a=c;c=temp;
temp=b;b=d;d=temp;
temp=p;p=q;q=temp;
i=0;

ni[0]=c;ni[1]=d;
return(ni);


unsigned long momi(unsigned long a,unsigned long b,unsigned long p) //模幂算法

unsigned long c;
c=1;
if(a>p) a=a%p;
if(b>p) b=b%(p-1);
while(b!=0)

while(b%2==0)

b=b/2;
a=(a*a)%p;

b=b-1;
c=(a*c)%p;

return(c);


void RSAjiami() //RSA加密函数

unsigned long c1,c2;
unsigned long m,n,c;
n=prime1*prime2;
system("cls");
printf("Please input the message：\n");
scanf("%lu",&m);getchar();
c=momi(m,ee,n);
printf("The cipher is：%lu",c);
return;


void RSAjiemi() //RSA解密函数

unsigned long m1,m2,e,d,*ni;
unsigned long c,n,m,o;
o=(prime1-1)*(prime2-1);
n=prime1*prime2;
system("cls");
printf("Please input the cipher：\n");
scanf("%lu",&c);getchar();
ni=kzojld(ee,o);
d=ni[0];
m=momi(c,d,n);
printf("The original message is：%lu",m);
return;


void main()
unsigned long m;
char cho;
printf("Please input the two prime you want to use:\n");
printf("P=");scanf("%lu",&prime1);getchar();
printf("Q=");scanf("%lu",&prime2);getchar();
printf("E=");scanf("%lu",&ee);getchar();
if(prime1<prime2)
m=prime1;prime1=prime2;prime2=m;
while(1)

system("cls");
printf("\t*******RSA密码系统*******\n");
printf("Please select what do you want to do:\n");
printf("1.Encrpt.\n");
printf("2.Decrpt.\n");
printf("3.Exit.\n");
printf("Your choice:");
scanf("%c",&cho);getchar();
switch(cho)
case '1':RSAjiami();break;
case '2':RSAjiemi();break;
case '3':exit(0);
default:printf("Error input.\n");break;

getchar();

参考技术C 网上到处是……

如何用C语言实现动态分区分配算法的模拟

参考技术A

#define _CRT_SECURE_NO_WARNINGS 1   

#include<stdio.h>  

#include<string.h>  

#include<stdlib.h>  

#include<math.h>  

#define N 10000  

int n1;//空闲分区的个数  

int n2;//作业区的个数  

struct kongxian  

  

int start;  //起址  

int end;    //结束  

int length;  //长度  

kongxian[N];  

struct zuoye  

  

int start;  //起址  

int end;   //结束  

int length;  //长度  

zuoye[N];  

int cmp1(const void *a, const void *b)  

  

return (*(struct kongxian *)a).start - (*(struct kongxian *)b).start;  

  

int cmp2(const void *a, const void *b)  

  

return (*(struct zuoye *)a).start - (*(struct zuoye *)b).start;  

  

void init()  

  

n1 = 1;  //初始时只有一个空闲区  

n2 = 0;  //初始没有作业  

kongxian[0].start = 0;  

kongxian[0].end = 511;  

kongxian[0].length = 512;  

  

void print1() //打印空闲分区  

  

int i;  

for (i = 0; i<n1; i++)  

printf("空闲分区ID:%d 起止:%d 结束:%d 长度:%d\\n", i, kongxian[i].start, kongxian[i].end, kongxian[i].length);  

  

void print2() //打印作业分区  

  

int i;  

for (i = 0; i<n2; i++)  

printf("作业分区ID：%d 起止:%d 结束:%d 长度:%d\\n", i, zuoye[i].start, zuoye[i].end, zuoye[i].length);  

  

int main()  

  

int i, j, t, len, flag, id;  

int front, middle, behind;  

int t1, t2;  

init();  

print1();  

printf("输入1装入新作业，输入0回收作业，输入-1结束\\n");  

while (scanf("%d", &t) != EOF)  

  

if (t == 1)  //装入新作业  

  

printf("请输入作业的占用空间的长度 ");  

scanf("%d", &len);  

flag = 0;  

for (i = 0; i<n1; i++)  

  

if (kongxian[i].length >= len)  //首次适应算法  

  

flag = 1;  

break;  

  

  

if (!flag)  

  

printf("内存分配失败\\n");  

  

else  

  

//将该作业加入作业区里  

zuoye[n2].start = kongxian[i].start;  

zuoye[n2].end = zuoye[n2].start + len;  

zuoye[n2].length = len;  

n2++;  //作业数加1  

if (kongxian[i].length == len) //该分区全部用于分配，删除该空闲分区  

  

for (j = i; j<n1 - 1; j++)  

  

kongxian[j].start = kongxian[j + 1].start;  

kongxian[j].end = kongxian[j + 1].end;  

kongxian[j].length = kongxian[j + 1].length;  

  

n1--;  

  

else  //该空闲分区部分用于分配，剩余的留在空闲分区中  

  

kongxian[i].start += len;  

kongxian[i].length -= len;  

  

  

  

else if (t == 0)  

  

printf("输入要回收的作业ID ");  

scanf("%d", &id);  

front = middle = behind = 0;  

for (i = 0; i<n1; i++)  

  

if (kongxian[i].start>zuoye[id].end)  

break;  

if (kongxian[i].end == zuoye[id].start)  //待回收的作业上面有空闲分区  

  

front = 1;  

t1 = i;  

  

if (kongxian[i].start == zuoye[id].end)  //待回收的作业下面有空闲分区  

  

behind = 1;  

t2 = i;  

  

  

if (!front&&!behind)  //待回收的作业上下均没有空闲分区  

  

kongxian[n1].start = zuoye[id].start;  

kongxian[n1].end = zuoye[id].end;  

kongxian[n1].length = zuoye[id].length;  

n1++;  //空闲分区增加一个  

qsort(kongxian, n1, sizeof(struct kongxian), cmp1); //插入空闲分区后排序  

for (j = id; j<n2 - 1; j++)  //在作业分区中删除该作业  

  

zuoye[j].start = zuoye[j + 1].start;  

zuoye[j].end = zuoye[j + 1].end;  

zuoye[j].length = zuoye[j + 1].length;  

  

n2--;  

  

if (front &&behind)  //待回收的作业上下均有空闲分区  

middle = 1;  

if (front&&!middle)  //合并待回收的作业和上面的空闲分区  

  

kongxian[t1].end += zuoye[id].length;  

kongxian[t1].length += zuoye[id].length;  

for (j = id; j<n2 - 1; j++)  //在作业分区中删除该作业  

  

zuoye[j].start = zuoye[j + 1].start;  

zuoye[j].end = zuoye[j + 1].end;  

zuoye[j].length = zuoye[j + 1].length;  

  

n2--;  

  

if (middle)  //合并待回收的作业和上下的空闲分区  

  

kongxian[t1].end = kongxian[t2].end;  

kongxian[t1].length += (zuoye[id].length + kongxian[t2].length);  

//删除空闲分区t2  

for (j = t2; j<n1 - 1; j++)  

  

kongxian[j].start = kongxian[j + 1].start;  

kongxian[j].end = kongxian[j + 1].end;  

kongxian[j].length = kongxian[j + 1].length;  

  

n1--;  

for (j = id; j<n2 - 1; j++)  //在作业分区中删除该作业  

  

zuoye[j].start = zuoye[j + 1].start;  

zuoye[j].end = zuoye[j + 1].end;  

zuoye[j].length = zuoye[j + 1].length;  

  

n2--;  

  

if (behind &&!middle) //合并待回收的作业和下面的分区  

  

kongxian[t2].start -= zuoye[id].length;  

kongxian[t2].length += zuoye[id].length;  

for (j = id; j<n2 - 1; j++)  //在作业分区中删除该作业  

  

zuoye[j].start = zuoye[j + 1].start;  

zuoye[j].end = zuoye[j + 1].end;  

zuoye[j].length = zuoye[j + 1].length;  

  

n2--;  

  

  

else  

  

printf("操作结束\\n");  

break;  

  

print1();  

print2();  

  

return 0;