Rsa 算法分析.docx

Rsa 算法分析.docx

《Rsa 算法分析.docx》由会员分享，可在线阅读，更多相关《Rsa 算法分析.docx（26页珍藏版）》请在冰豆网上搜索。

Rsa算法分析

RSA算法分析

姓名：

学号：

班级：

1、算法简介：

RSA公钥加密算法是1977年由罗纳德·李维斯特（RonRivest）、阿迪·萨莫尔（AdiShamir）和伦纳德·阿德曼（LeonardAdleman）一起提出的。

当时他们三人都在麻省理工学院工作。

RSA就是他们三人姓氏开头字母拼在一起组成的。

RSA公开密钥密码体制。

所谓的公开密钥密码体制就是使用不同的加密密钥与解密密钥，是一种“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。

在公开密钥密码体制中，加密密钥（即公开密钥）PK是公开信息，而解密密钥（即秘密密钥）SK是需要保密的。

加密算法E和解密算法D也都是公开的。

虽然解密密钥SK是由公开密钥PK决定的，但却不能根据PK计算出SK。

RSA算法是第一个能同时用于加密和数字签名的算法，也易于理解和操作。

RSA是被研究得最广泛的公钥算法，从提出到现今的三十多年里，经历了各种攻击的考验，逐渐为人们接受，普遍认为是目前最优秀的公钥方案之一。

二、源码分析：

/*-----------------------------------------------RSA.cpp-----------------------------------------------*/

#include"rsa.h"//引入"rsa.h"

/*---------------------以下为prime_factory类定义与实现-------------------*/

//prime_factory：

用于产生质数

classprime_factory//类

{

unsignednp;//无符号

unsigned*pl;//无符号

public:

//公共

prime_factory（）;//构造函数

~prime_factory（）;//构造函数

vlongfind_prime（vlong&start）;//寻找质数

};

//判定是否有很大概率为质数

staticintis_probable_prime（constvlong&p）//静态

{

//基于费马小定理：

若p是任一质数,a是任一整数,则a^p=1modp。

换句话说,

//如果a和p互质,则a^（p-1）==1modp。

{2,3,5,7}值分别代入a,若上式均成立

//则p为质数的概率极大

constrep=4;//测试底数a的个数

constunsignedany[rep]={2,3,5,7};//测试底数a数组为{2,3,5,7}

for（unsignedi=0;i

if（modexp（any[i],p-（vlong）1,p）!

=（vlong）1）//判断是否a^（p-1）==1modp

return0;//返回0

return1;//返回1

}

//构造小质数表

prime_factory:

:

prime_factory（）

{

np=0;//初始化为0

unsignedNP=200;//小质数表个数上限

pl=newunsigned[NP];//pl指向小质数表

//初始化质数表

unsignedSS=8*NP;//质数表上限

char*b=newchar[SS+1];//指针指向字符数组

for（unsignedi=0;i<=SS;i+=1）//for循环对b数组赋值

b[i]=1;//数组初始化为1

unsignedp=2;//从2开始构造质数

while

（1）

{

//skipcomposites

while（b[p]==0）p+=1;//如果p为0，p递增1

if（p==SS）break;//若p等于SS，退出循环

pl[np]=p;//将找到的质数写入小质数表中

np+=1;//质数个数递增1

if（np==NP）break;//如果质数个数达到小质数表的上限个数，退出循环

//crossoffmultiples

unsignedc=p*2;//记录2*p

while（c

{

b[c]=0;//c处数为0

c+=p;//c递增p

}

p+=1;//p递增1

}

delete[]b;//删除数组b

}

//析构函数

prime_factory:

:

~prime_factory（）

{

delete[]pl;//删除数组pl

}

//寻找第一个>=start的质数

vlongprime_factory:

:

find_prime（vlong&start）

{

unsignedSS=1000;//1000为上限

char*b=newchar[SS];//后备，如果SS[i]=0，就不需要用

//费马小定理（is_probable_prime）检验start+i,因为它必非质数

unsignedtested=0;//使用is_probable_prime函数检验过的后备质数次数

while

（1）

{

unsignedi;//循环变量i

for（i=0;i

b[i]=1;//赋初值为1

for（i=0;i

{

unsignedp=pl[i];//p记录循环所指向的质数

unsignedr=start%（vlong）p;//

if（r）//

r=p-r;//将p-r赋值给r

//去除所有能被p除尽的后备质数

while（r

{

b[r]=0;//将后备质数检验位置为0

r+=p;//r递增p

}

}

//检验后备质数

for（i=0;i

{

if（b[i]）//若后备质数检验位为1

{

tested+=1;//?

?

?

if（is_probable_prime（start））//判断start是否为质数

returnstart;//若是质数，则返回找到的质数

}

start+=1;//start每次递增1，寻找下一个

}

}

delete[]b;//删除数组b

}

//由字符串r1和r2创建p、q和公钥

voidprivate_key:

:

create（constchar*r1,constchar*r2）

{

//由r1和r2产生质数p、q

{

prime_factorypf;//构造小质数表pf

p=pf.find_prime（from_str（r1））;//寻找质数p

q=pf.find_prime（from_str（r2））;//寻找质数q

if（p>q）//若p>q，则交换两数

{

vlongtmp=p;

p=q;

q=tmp;

}

}

//计算公钥

//从[0，（p-1）（q-1）-1]中随机选取加密密钥e，使得e和（p-1）（q-1）互质。

此处

//为使e较大，直接从一较大数开始选取（50001）

{

m=p*q;//模m=p*q

e=50001;//必须为奇数

while（gcd（p-（vlong）1,e）!

=（vlong）1||gcd（q-（vlong）1,e）!

=（vlong）1）//？

？

e+=2;//e只能每次递增2

}

}

//加密明文

vlongpublic_key:

:

encrypt（constvlong&plain）

{

returnmodexp（plain,e,m）;//返回

}

//解密秘文

vlongprivate_key:

:

decrypt（constvlong&cipher）

{

//Calculatevaluesforperformingdecryption

//Thesecouldbecached,butthecalculationisquitefast

vlongd=modinv（e,（p-（vlong）1）*（q-（vlong）1））;

vlongu=modinv（p,q）;

vlongdp=d%（p-（vlong）1）;//计算dmod（p-1）

vlongdq=d%（q-（vlong）1）;//计算dmod（q-1）

//应用同余定理

vlonga=modexp（cipher%p,dp,p）;//计算

vlongb=modexp（cipher%q,dq,q）;//计算

if（b

returna+p*（（（b-a）*u）%q）;//根据同余定理，计算

}

/*----------------------------------------------vlong.h----------------------------------------------------*/

//长整数类，可随意定义其长度

classvlong

{//公有成员函数

public:

//重载常用算术运算符

friendvlongoperator+（constvlong&x,constvlong&y）;

//友元函数operator+实现对算术运算符'+'的重载

friendvlongoperator-（constvlong&x,constvlong&y）;

//友元函数operator-实现对算术运算符'-'的重载

friendvlongoperator*（constvlong&x,constvlong&y）;

//友元函数operator*实现对算术运算符'*'的重载

friendvlongoperator/（constvlong&x,constvlong&y）;

//友元函数operator/实现对算术运算符'/'的重载

friendvlongoperator%（constvlong&x,constvlong&y）;

//友元函数operator%实现对算术运算符'%'的重载

vlong&operator+=（constvlong&x）;//'+='

vlong&operator-=（constvlong&x）;//'-='

//重载常用比较运算符

friendinlineintoperator!

=（constvlong&x,constvlong&y）{returnx.cf（y）!

=0;}

//友元内联函数实现对常用比较运算符operator!

=的重载

friendinlineintoperator==（constvlong&x,constvlong&y）{returnx.cf（y）==0;}

//友元内联函数实现对常用比较运算符operator==的重载

friendinlineintoperator>=（constvlong&x,constvlong&y）{returnx.cf（y）>=0;}

//友元内联函数实现对常用比较运算符operator>=的重载

friendinlineintoperator<=（constvlong&x,constvlong&y）{returnx.cf（y）<=0;}

//友元内联函数实现对常用比较运算符operator<=的重载

friendinlineintoperator>（constvlong&x,constvlong&y）{returnx.cf（y）>0;}

//友元内联函数实现对常用比较运算符operator>的重载

friendinlineintoperator<（constvlong&x,constvlong&y）{returnx.cf（y）<0;}

//友元内联函数实现对常用比较运算符operator<的重载

//构造函数

vlong（unsignedx=0）;//构造函数声明

vlong（constvlong&x）//构造函数声明

~vlong（）;//析构函数

operatorunsigned（）;//操作，无符号

vlong&operator=（constvlong&x）;//赋值函数

//私有数据成员及成员函数

private:

classvlong_value*value;//类

intnegative;//整型变量

intcf（constvlongx）const;//常数

voiddocopy（）;//拷贝

friendclassmonty;//友元类

};

vlongmodexp（constvlong&x,constvlong&e,constvlong&m）;//？

？

？

vlonggcd（constvlong&X,constvlong&Y）;//求最大因子

vlongmodinv（constvlong&a,constvlong&m）;//Euclid算法

/*---------------------------------------vlong.cpp*-------------------------------------------------------*/

#include"vlong.h"//引入vlong.h

classvlong_value;//类的声明

/*-------------------------------以下为flex_unit类定义与实现----------------------------*/

classflex_unit//类的声明

{

unsigned*a;//内存unsignedint单元数组

unsignedz;//分配单元数

public:

//公有成员函数

unsignedn;//已使用的单元数（只读属性）

flex_unit（）;//构造函数

~flex_unit（）;//析构函数

voidclear（）;//已使用单元数n清0

unsignedget（unsignedi）const;//获取第i个单元值

voidset（unsignedi,unsignedx）;//设置第i个单元值

voidreserve（unsignedx）;//扩展存储区

//有时间要求的乘法

voidfast_mul（flex_unit&x,flex_unit&y,unsignedn）;

};

//按索引获取单元值

unsignedflex_unit:

:

get（unsignedi）const

{

if（i>=n）return0;//如果i超过n，则返回0

returna[i];//否则，返回第i个单元数

}

voidflex_unit:

:

clear（）//清空

{

n=0;//n为0

}

flex_unit:

:

flex_unit（）//构造函数

{

z=0;//z初始化为0

a=0;//a初始化为0

n=0;//n初始化为0

}

flex_unit:

:

~flex_unit（）//析构函数

{

unsignedi=z;//获取分配单元数

while（i）//

{

i-=1;//i递减1

a[i]=0;

}

delete[]a;//删除

}

voidflex_unit:

:

reserve（unsignedx）//扩展存储区

{

if（x>z）//如果x大于z

{

unsigned*na=newunsigned[x];//生成新的na

for（unsignedi=0;i

delete[]a;//删除a

a=na;//na赋值给a

z=x;//x赋值给z

}

}

//根据索引设置元素值

voidflex_unit:

:

set（unsignedi,unsignedx）

{

if（i

{

a[i]=x;//第i个单元值置为x

if（x==0）//如果x等于0

while（n&&a[n-1]==0）//去除高位0

n-=1;//n每次递减1

}

elseif（x）//否则？

{

reserve（i+1）;//扩展，i+1

for（unsignedj=n;j

a[i]=x;//第i个单元值置为x

n=i+1;//n置为i+1

}

}

#defineBPU（8*sizeof（unsigned））//unsignedint类型bit数

#definelo（x）（（x）&（（1<<（BPU/2））-1））//unsignedint低半部分

#definehi（x）（（x）>>（BPU/2））//unsignedint高半部分

#definelh（x）（（x）<<（BPU/2））//使低半部分左移至高半部分

voidflex_unit:

:

fast_mul（flex_unit&x,flex_unit&y,unsignedkeep）//快速乘法

{

//*this=（x*y）%（2**keep）

unsignedi,limit=（keep+BPU-1）/BPU;//运算结果单元数

reserve（limit）;//扩展为limit

for（i=0;i

a[i]=0;//初始化为0

unsignedmin=x.n;//n?

if（min>limit）//取较小者

min=limit;

for（i=0;i

//对取得的已使用的单元数n与运算结果单元数之间的较小者内存单元进行处理

{

unsignedm=x.a[i];//获取每个内存单元值

unsignedc=0;//初始化为0

unsignedmin=i+y.n;//获取当前位置后第n个位置

if（min>limit）min=limit;//取min与limit之间的较小者

for（unsignedj=i;j

{

//此处代码为运算关键，可使用机器或汇编代码以加快速度，c:

a[j]=a[j]+c+m*y.a[j-i];

unsignedw,v=a[j],p=y.a[j-i];//?

v+=c;c=（v

w=lo（p）*lo（m）;v+=w;c+=（v

?

?

w=lo（p）*hi（m）;c+=hi（w）;w=lh（w）;v+=w;c+=（v

?

?

w=hi（p）*lo（m）;c+=hi（w）;w=lh（w）;v+=w;c+=（v

?

?

c+=hi（p）*hi（m）;//?

?

?

a[j]=v;//?

?

?

}

while（c&&j

{

a[j]+=c;

c=a[j]

j+=1;

}

}

keep%=BPU;//去除不必要的bit

if（keep）

a[limit-1]&=（1<

while（limit&&a[limit-1]==0）//计算使用单元数

limit-=1;

n=limit;//limit赋值给n

};

/*---------------------------------以上为flex_unit类定义与实现----------------------------*/

/*-------------------------------以下为vlong_value类定义与实现----------------------------*/

classvlong_value:

publicflex_unit//继承自flex_unit，负责vlong类内存管理

{//共有数据成员及成员函数

public:

unsignedshare;//共有

intis_zero（）const;//测试大数是否为0

inttest（unsignedi）const;//测试第i位（bit）值是否为0

unsignedbits（）const;//获取大数位（bit）数

intcf（vlong_value&x）const;//比较大小

voidshl（）;//左移

voidshr（）;//右移

voidshr（unsignedn）;//左移n位

voidadd（vlong_value&x）;//加法

voidsubtract（vlong_value&x）;//减法

voidinit（unsignedx）;//初始化函数

voidcopy（vlong_value&x）;//拷贝

operatorunsigned（）;//转换至unsignedint类型，不安全

vlong_value（）;//构造函数

voidmul（vlong_value&x,vlong_value&y）;//乘法

voiddi