开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
rsawang1.cpp
资源名称：rsa.rar　[点击查看]
上传用户：len888
上传日期：2015-03-06
资源大小：59k
文件大小：50k
源码类别：

CA认证

开发平台：

Visual C++

rsawang1.cpp：源码内容
  1. //
  3. #include "stdafx.h"
  4. //#include "RSATest1.h"
  5. #include "Rsawang1.h"
  7. #ifdef _DEBUG
  8. #define new DEBUG_NEW
  9. #undef THIS_FILE
  10. static char THIS_FILE[] = __FILE__;
  11. #endif
  13. /////////////////////////////////////////////////////////////////////////////
  14. // CRsaA
  16. IMPLEMENT_DYNCREATE(CRsaA, CCmdTarget)
  18. CRsaA::CRsaA()
  19. {
  20. InitInt();
  22. }
  24. CRsaA::~CRsaA()
  25. {
  26. }
  29. BEGIN_MESSAGE_MAP(CRsaA, CCmdTarget)
  30. //{{AFX_MSG_MAP(CRsaA)
  31. // NOTE - the ClassWizard will add and remove mapping macros here.
  32. //}}AFX_MSG_MAP
  33. //ON_MESSAGE(WM_COMPUTING,OnComputing)
  34. END_MESSAGE_MAP()
  36. /////////////////////////////////////////////////////////////////////////////
  37. // CRsaA message handlers
  39. /*----------------------------------------------------------------------------
  40. 功能：进行相关大数的初始化
  41. 入口参数：无
  42. 返回值：无
  43. ----------------------------------------------------------------------------*/
  44. void CRsaA::InitInt(void)
  45. {
  46. SetZero(ZEROVALUE); //对大数变量zerovalue清零
  47. memset(mZEROVALUE,0,MLENGTH);
  48. SetZero(ONEVALUE);                      //对大数变量ONEVALUE进行清零
  49. ONEVALUE[DATALENGTH-1]=1; //ONEVALUE的最后一位为1
  50. SetZero(TWOVALUE); //将TOWVALUE进行清零
  51.     TWOVALUE[DATALENGTH-1]=2; //TOWVALUE的最后一位为2
  52. SetZero(EIGHTVALUE); //对EIGHTVALUE进行清零
  53.     EIGHTVALUE[DATALENGTH-1]=8; //最后一位为8
  54. return ;
  55. }
  57. /*---------------------------------------------------------------------------
  58. 功能：将一个大数A转换为相应的字符串形式
  59. 入口参数：大数A
  60. 返回值：相对应的字符串
  61. ----------------------------------------------------------------------------*/
  62. CString CRsaA::PrtInt(byteint A)
  63. {
  64. register i=0;
  65. int m,n;
  66. while(i<DATALENGTH && A[i]==0)          //跳过大数开始的空白0
  67. i++;
  68. if(i<DATALENGTH)
  69. m=DATALENGTH-i;                     //求出有用的大数长度
  70. n=0;
  71. //注意到这里的i已经是数组中第一个非零元素的对应位置，
  72. CString str=""; //因此下面的循环就是从数组中
  73. //存放的数的最高位开始输出。
  74. while(i<DATALENGTH)
  75. {
  76. str += (A[i++]+'0');
  77. }
  78. return str;
  79. }
  81. /*---------------------------------------------------------------------------
  82. 功能：大数A与大数B相乘，结果放入C中 A×B->C
  83. 入口参数：被乘数A和乘数B，结果C
  84. 返回值：无
  85. ----------------------------------------------------------------------------*/
  86. void CRsaA::Multiply(byteint A,byteint B,byteint C)
  87. {
  88. register i,j,w;
  89. int X,Y,Z;
  90. int Avalid=0; //Avalid=validating bits of A
  91. int Bvalid=0; //Avalid=validating bits of B
  92. while (A[Avalid]==0 && Avalid<DATALENGTH)
  93. Avalid++; //计算Avalid
  94. while (B[Bvalid]==0 && Bvalid<DATALENGTH)
  95. Bvalid++; //计算Bvalid
  97. SetZero(C); //将C清零初始化
  99. for(i=DATALENGTH-1;i>=Avalid;i--)
  100. for(j=DATALENGTH-1;j>=Bvalid;j--)       //逐位进行相乘运算
  101. {
  102. X=A[i]*B[j];        
  103. Y=X/10;
  104. Z=X-10*Y;
  105. w=i+j-(DATALENGTH-1);
  106. C[w]=C[w]+Z;
  107. C[w-1]=C[w-1]+(C[w]/10)+Y;
  108. C[w]=C[w]-(C[w]/10)*10;
  109. }
  110. return;
  111. }
  113. /*---------------------------------------------------------------------------
  114. 功能：将指定的自定义的大数进行0初始化
  115. 入口参数：大数A名
  116. 返回值：无
  117. ----------------------------------------------------------------------------*/
  118. void CRsaA::SetZero(byteint A)  
  119. {
  120. memset(A,0,DATALENGTH);                    //调用系统函数进行初始化
  121. }
  123. /*---------------------------------------------------------------------------
  124. 功能：将大数B拷贝到大数A中
  125. 入口参数：大数A，大数B
  126. 返回值：无
  127. ----------------------------------------------------------------------------*/
  128. void CRsaA::IntCpy(byteint A,byteint B)
  129. {
  130. memcpy(A,B,DATALENGTH);                    //调用系统函数完成拷贝
  131. }
  133. /*---------------------------------------------------------------------------
  134. 功能：A＋B的结果送C
  135. 入口参数：大数A,B,C
  136. 返回值：无
  137. ----------------------------------------------------------------------------*/
  138. void CRsaA::Plus(byteint A,byteint B,byteint C)
  139. {
  140. register i;//,w;
  141. int X,Y,Z,m,n,valid;
  142. m=IntValid(A);                 //计算A的长度         
  143. n=IntValid(B);                 //计算B的长度
  144. valid=(m>n)?m+1:n+1;           //计算时要以最长的数为准
  145. SetZero(C);                    //将C清零
  146. for(i=DATALENGTH-1;i>=DATALENGTH-valid;i--)
  147. {
  148. X=A[i]+B[i];               //按位相加
  149. Y=X/10;
  150. Z=X-10*Y;
  152. C[i]=C[i]+Z;               //计算进位
  153. C[i-1]=C[i-1]+Y;
  154. }
  155. }
  157. /*---------------------------------------------------------------------------
  158. 功能：大数SA减去大数SB，结果放入SC
  159. 入口参数：被减数SA，减数SB，差SC
  160. 返回值：无
  161. ----------------------------------------------------------------------------*/
  162. void CRsaA::Substract(byteint SA,byteint SB,byteint SC)
  163. {
  164. byteint buf;
  165. register i,j;
  166. int X;
  167. IntCpy(buf,SA);                  //将SA的内容拷贝到buf中
  168. SetZero(SC);                 //SC清零初始化
  169. for(i=DATALENGTH-1;i>=0;i--)
  170. {
  171. if(buf[i]<SB[i])             //如果最低位不够减
  172. {
  173. buf[i]=buf[i]+10;        //向高位借1
  174. if(buf[i-1]>0)           //如果高位够减，直接减1
  175. (buf[i-1])--;    
  176. else                     //否则一直找到够减的位
  177. {
  178. j=i-1;
  179. while(buf[j]==0)     //j不会出现越界，是因为保证了最高位不为0
  180. buf[j--]=9;
  181. buf[j]=buf[j]-1;
  182. }
  183. }
  184. X=buf[i]-SB[i];              //将各位减的结果存入SC中
  185. SC[i]=X;
  186. }
  187. }
  189. /*---------------------------------------------------------------------------
  190. 功能：比较两个大数A和B的大小
  191. 入口参数：大数A和大数B
  192. 返回值：A>B:return 1 ; A=B:return 0 ; A<B:return -1
  193. ----------------------------------------------------------------------------*/
  194. int CRsaA::IntCmp(byteint A,byteint B)
  195. {
  196. int stat;
  197. stat=memcmp(A,B,DATALENGTH);    //系统函数
  198. if(stat==0)
  199. return 0;
  200. if(stat>0)
  201. return 1;
  202. return -1;
  203. }
  205. /*---------------------------------------------------------------------------
  206. 功能：得到一个大数的非零位数
  207. 入口参数：大数validtemp
  208. 返回值：大数中非零的位数
  209. ----------------------------------------------------------------------------*/
  210. int CRsaA::IntValid(byteint validtemp)
  211. {
  212. register i=0;
  213. while(validtemp[i]==0 && i<DATALENGTH)
  214. i++;
  215. return DATALENGTH-i;
  216. }
  218. /*---------------------------------------------------------------------------
  219. 功能：计算大数A÷B的结果，余数放在C中，商在D中
  220. 入口参数：被除数A，除数B，余数C，商D
  221. 返回值：无
  222. ----------------------------------------------------------------------------*/
  223. void CRsaA::SetMode(byteint A,byteint B,byteint C,byteint D)
  224. {
  225. register i,j,k;
  226. int valid_1,valid_2,valid,sbits,cmpval;
  227. byteint buf1,buf2;
  228.     
  229. SetZero(buf1);  SetZero(buf2);
  230. SetZero(D);                       //将大数D进行清零初始化
  231.     IntCpy(C,A);                      //将被除数A拷贝到C中
  232. valid_2=IntValid(B);              //计算B(除数)的位数,
  233. while((cmpval=IntCmp(C,B))>0)     //变除法为减法,每减一次就判断是否有C>B,如果满足就继续减。
  234. {
  235. valid_1=IntValid(C);          //计算C(被除数)的位数,因为它的位数在循环过程中是变化的
  236.                               //做减法后(C-B)仍然存放在C中
  237. valid=valid_1-valid_2;        //C的长度与B的长度的差（该值最小为0）
  238. if(valid>0)                   //如果被除数比除数的位数多
  239. {
  240. i=DATALENGTH-valid_1;     //被除数前导零的个数
  241. j=DATALENGTH-valid_2;     //除数前导零的个数，作下标指示器
  242. sbits=0;
  243. for(k=j;k<DATALENGTH;k++)
  244. {
  245. if(C[i]>B[j])         //从C和B的最高位开始依次比较对应位的大小，判断是否够减
  246. break;
  247. if(C[i]<B[j])
  248. {
  249. sbits=1;          //如果不够减，那么C就退一位，再做减法
  250. break;
  251. }
  252. i++;j++;              //当C和B的最高位相等时,就比较二者的次高位
  253. }
  254. valid=valid-sbits;
  255. SetZero(buf1);            //buf1清零
  256. for(i=valid;i<DATALENGTH;i++)
  257. {
  258. j=i-valid;
  259. buf1[j]=B[i];         //buf1中存放的是B左移若干位之后得到的值
  260.                       //如果够减,则B左移后最高位与C的最高位对齐,
  261.                       //否则与C的次高位对齐
  262. }
  263. }
  264. else
  265. IntCpy(buf1,B);           //当C和B的位数相同时,就直接把B放入缓冲区buf1中
  267. D[DATALENGTH-1-valid]++;      //这里保存的是在某一位上所做的减法的次数，每做一次就加1
  268. Substract(C,buf1,buf2);       //不论C的长度与B的长度的差是否大于0，都要做减法，直到C<=B
  269. IntCpy(C,buf2);
  270. }
  271. if(cmpval==0)                     //两个数相等
  272. {
  273. SetZero(C);                   //余数为0
  274. D[DATALENGTH-1]++;            //商为1
  275. }
  276. }
  278. /*---------------------------------------------------------------------------
  279. 功能：随机地产生一个大数奇数，长度为num，最高位不是0，存放在RandomA中
  280. 入口参数：大数A，长度num
  281. 返回值：无
  282. ----------------------------------------------------------------------------*/
  283. void CRsaA::IntRandom(byteint RandomA,int num)
  284. {
  285. int i;
  286. SetZero(RandomA);                     //将RandomA清零
  288. while(!(RandomA[DATALENGTH-1]%2))     //判断条件保证RandomA的最后一位数是奇数
  289. RandomA[DATALENGTH-1]=rand()%10;  //如果最后一位是偶数，则从新产生最后一位
  290.     while(!(RandomA[DATALENGTH-num]))     //判断条件保证RandomA最高位不是0
  291. RandomA[DATALENGTH-num]=rand()%10;//如果最高位是0,则从新产生最高位
  293. i=DATALENGTH-2;
  294. while(i>=DATALENGTH-num+1)            //循环产生从次低位开始到次高位的所有位上的数
  295. RandomA[i--]=rand()%10;
  296. }
  298. /*---------------------------------------------------------------------------
  299. 功能：将质数类型B拷贝到A中，实现类型转换
  300. 入口参数：大数A，质数类型B
  301. 返回值：无
  302. ----------------------------------------------------------------------------*/
  303. //功能：将数B拷贝到大数A，实现类型转换
  304. void CRsaA::LoadInt(byteint A,mtype B)
  305. {
  306. register i,j;
  307. SetZero(A);                  //A进行清零初始化
  308. i=DATALENGTH-1;
  309. j=MLENGTH-1;
  310. while(j>0)                   //循环拷贝各位数字
  311. {
  312. A[i--]=B[j--];
  313. }
  314. }
  316. /*---------------------------------------------------------------------------
  317. 功能：该函数用来从集合[1,b-1]中产生若干个用于检测的数，存放在Model[]中
  318. 入口参数：无
  319. 返回值：无
  320. ----------------------------------------------------------------------------*/
  321. void CRsaA::Mdata()
  322. {
  323. register i,j;                     //Randomly choose a set of 100 numbers in [1,b-1]
  324. int k=MLENGTH-2;
  326. memset(Model,0,TESTNUM*MLENGTH);  //这个函数在这里用来将整个数组清零，进行初始化
  327. srand( (unsigned)time( NULL ) );  //进行随机函数的初始化
  328. for(i=0;i<TESTNUM;i++)            //TESTNUM为需要产生的个数
  329. {
  330. for(j=MLENGTH-1;j>=k;j--)
  331. {
  332. Model[i][j]=rand()%10;    //注意这里与测试素数的程序中的区别，
  333. }
  334. if((memcmp(Model[i],mZEROVALUE,MLENGTH))==0)  
  335. i--;
  336. k--;                          //保证所产生的数不为0
  337. if (k<0) k=MLENGTH-2;
  338. }
  340. }
  342. /*---------------------------------------------------------------------------
  343. 功能：该函数用来将十进制的大整数转换成二进制的数
  344. 入口参数：需转换的大数B，二进制结果flag[400]
  345. 返回值：无
  346. ----------------------------------------------------------------------------*/
  347. void CRsaA::TransBi(byteint B,signed char flag[400])
  348. {
  349. byteint buf;
  350. byteint result;
  351. byteint temp;
  352. register i;
  353. SetZero(buf);  SetZero(result);  SetZero(temp);
  354. memset(flag,0,400);                     //将flag数组清零
  356. i=399;
  357. IntCpy(buf,B);                          //将B拷贝到buf中
  358. while(IntCmp(buf,ZEROVALUE)==1)         //如果buf内容为0
  359. {
  360. SetMode(buf,TWOVALUE,temp,result);  //将buf进行大数的模2运算，商在result中，余数temp
  361. flag[i]=temp[DATALENGTH-1];         
  362. IntCpy(buf,result);                 //对商继续进行模2运算
  363. i--;
  364. }
  365. flag[i]=-1;                             //设置一个标志位，表明二进制数的开始
  366. }
  368. /*---------------------------------------------------------------------------
  369. 功能：该函数用来进行模幂算法，A为底数，模为c，二进制的指数B存放在数组flag中
  370. 入口参数：底数A，模C，结果D，二进制质数flag[400]
  371. 返回值：A^B=1(mod C),返回1；A^B=p-1(mod C),返回2；否则返回0
  372. ----------------------------------------------------------------------------*/
  373. int CRsaA::PowerMode(byteint A,byteint C,byteint D,signed char flag[400])
  374. {
  375. byteint buf;
  376. byteint result;
  377. byteint temp,P;
  378. register i;
  379. SetZero(D);   SetZero(buf); SetZero(result); SetZero(temp); SetZero(P);  //将D清零
  381. IntCpy(temp,A);                       //将A的值拷贝到temp中
  382. if(flag[399]==1)                      //最低位为1，拷贝本身，flag[i]只有1或者0两种情况
  383. IntCpy(result,A);
  384. else   //最低位为0，则幂为1
  385. IntCpy(result,ONEVALUE);
  386. i=398;
  387. while(flag[i]!=-1)                    //判断是否已经到达指数尽头
  388. {
  389. Multiply(temp,temp,buf);          //temp*temp->buf 
  390. SetMode(buf,C,temp,P);            //buf%c余数->temp,商->p
  391. if(flag[i]!=0)                    //如果该位不是0，则将其和前一步低一位的结果进行乘法运算
  392. {                                 //否则，将其作为该位的模，在高一位的运算中，只要进行一次
  393. Multiply(temp,result,buf);    //平方运算，就可以得到高一位的模
  394. SetMode(buf,C,result,P);
  395. }
  396. i--;
  397. }                                     //result中存放的是最终结果
  398. IntCpy(buf,C);
  399. IntCpy(D,result);
  400. Substract(buf,ONEVALUE,temp);
  401. if(IntCmp(result,ONEVALUE)==0)        //p mod n=1，判断是否有A^B=1(mod C)
  402. return 1;
  403. if(IntCmp(result,temp)==0)            //p mod n=-1[p-1=-1(mod p)]，判断是否有A^B=p-1(mod C)
  404. return 2;
  405. return 0;
  406. }
  408. /*---------------------------------------------------------------------------
  409. 功能：产生一个质数
  410. 入口参数：大数Prm
  411. 返回值：产生成功，返回0
  412. ----------------------------------------------------------------------------*/
  413. int CRsaA::Prime(byteint Prm)
  414. {
  415. int i,k,ok;
  416. signed char flag[400];
  417. byteint A,B,D,buf1,buf2;
  418. SetZero(A); SetZero(B); SetZero(D); SetZero(buf1); SetZero(buf2);
  420. while(1)                                 //一直循环直到找到一个素数为止
  421. {
  422. int pass=0;
  423. srand( (unsigned)time( NULL ) );     //初始化srand
  424. IntRandom(B,MLENGTH);                //随机产生一个大数B  try b if prime,B是一个奇数
  426. IntCpy(Prm,B);                       //将B拷贝到prm中 C=N result prime
  427. Substract(B,ONEVALUE,buf1);          //将B-ONEVALUE的结果放到buf1中
  428. SetMode(buf1,TWOVALUE,buf2,B);       //B=(B-1)/2的商,buf2=(B-1)/2的余数=0
  429. TransBi(B,flag);                     //将B转换为二进制大数
  430. ok=1;
  431. for(i=0;i<TESTNUM;i++)
  432. {
  433. LoadInt(A,Model[i]);             //将数组Model中的第i+1个数读取到A中
  434. k=PowerMode(A,Prm,D,flag);       //(A^flag) mod Prm ->D
  435. if(k!=1 && k!=2)                 //不符合判定规则
  436. {
  437. ok=0;
  438. break;
  439. }
  440. if(k==1)                         //判定条件1，G=A^(n-1)/2=1
  441. {
  442. }
  443. if(k==2)                         //判定条件2，G=A^(n-1)/2=p-1
  444. {
  445. }
  447. }
  448. if (ok)//if(ok && pass_2)
  449. {
  450. return 0;
  451. }//for循环用来检测IntRandom(B,MLENGTH)产生的数B是否是一个素数
  452. }
  453. }
  455. /*---------------------------------------------------------------------------
  456. 功能：计算公钥PK
  457. 入口参数：$(r)的值在Rvalue中，私钥SK，公钥PK
  458. 返回值：成功找到，返回1
  459. ----------------------------------------------------------------------------*/
  460. int CRsaA::ComputingPK(byteint Rvalue,byteint SK,byteint PK)
  461. {
  462. register i;
  463. byteint PA,PB,PC,buf1,temp,buf2;
  464. SetZero(PK); SetZero(PA); SetZero(PB); SetZero(PC); SetZero(buf1);   //清零初始化
  465. SetZero(temp); SetZero(buf2);
  466. while(1)
  467. {
  468. IntRandom(SK,SKLENGTH);        //随机产生一个大数奇数作为Generated secret key
  470. IntCpy(PB,SK);
  471. IntCpy(PA,Rvalue);
  472. while(1)
  473. {
  474. SetMode(PA,PB,PC,PK);     //PA=PB*PK+PC
  475. i=IntCmp(PC,ONEVALUE);
  476. if(i==0)                  //PC=1, i=0
  477. break;                //满足条件，是互质的
  478. i=IntCmp(PC,ZEROVALUE);
  479. if(i==0)
  480. {
  481. i=-1;                 //PC=0,i=-1
  482. break;                //不满足互质条件，跳出循环，从新生成一个随机数
  483. }
  484. IntCpy(PA,PB);            //按照欧几里的定理继续判断
  486. IntCpy(PB,PC);
  487. }
  488. if(i==0)                      //满足，跳出查找循环
  489. break;
  490. }
  492. IntCpy(temp,ONEVALUE);
  493. IntCpy(PA,Rvalue);
  494. IntCpy(PB,SK);
  495. while(1)
  496. {
  497. Multiply(PA,temp,buf1);  //buf1=PA*temp
  498. Plus(buf1,ONEVALUE,buf2);//buf2=(PA*temp)+1
  499. SetMode(buf2,PB,buf1,PK);//buf=((PA*temp)+1)%PB
  500. if(IntCmp(buf1,ZEROVALUE)==0)
  501. break;
  502. Plus(temp,ONEVALUE,buf1);
  503. IntCpy(temp,buf1);
  504. }
  505. return 1;                   //SK and PK found
  506. }
  509. /*---------------------------------------------------------------------------
  510. 功能：计算模R
  511. 入口参数：产生的质数p，q，模R
  512. 返回值：无
  513. ----------------------------------------------------------------------------*/
  514. void CRsaA::ComputingR(byteint p,byteint q,byteint R)
  515. {
  516. Multiply(p,q,R);              // R=p*q, public mode number
  517. }
  519. /*---------------------------------------------------------------------------
  520. 功能：计算$(r)
  521. 入口参数：质数p，质数q，模$(r)放在Rvalue
  522. 返回值：无
  523. ----------------------------------------------------------------------------*/
  524. void CRsaA::ComputingRvalue(byteint p,byteint q,byteint Rvalue)
  525. {
  526. byteint buf1,buf2;
  527. SetZero(buf1); SetZero(buf2);
  529. Substract(p,ONEVALUE,buf1);   // buf1=p-1
  530. Substract(q,ONEVALUE,buf2);   // buf2=q-1
  531. Multiply(buf1,buf2,Rvalue);   // Rvalue=(p-1)*(q-1)
  532. }
  534. /*---------------------------------------------------------------------------
  535. 功能：将接受的字符串转换为大数类型
  536. 入口参数：大数result,字符串input
  537. 返回值：数的长度
  538. ----------------------------------------------------------------------------*/
  539. int CRsaA::Getinput(byteint result,CString input)
  540. {
  541. int i=DATALENGTH,m=0;
  542. long strlen;
  543. strlen=input.GetLength();
  545. if(strlen==0) return 0;
  546. else
  547. {
  548. for(int j=0;j<strlen;j++)
  549. {
  550. result[i-strlen+j] = (input.GetAt(j)-'0');
  551. }
  552. return j;
  553. }
  554. }
  556. /*---------------------------------------------------------------------------
  557. 功能：实现加密，解密运算功能
  558. 入口参数：明文(大数类型source)，模R，秘钥key，结果desti
  559. 返回值：无
  560. ----------------------------------------------------------------------------*/
  561. void CRsaA::RsaDo(byteint source,byteint R,byteint key,byteint desti)
  562. {
  563. TransBi(key,flag);
  564. PowerMode(source,R,desti,flag);
  565. }
  567. /*---------------------------------------------------------------------------
  568. 功能：将长整形的数转换为大数类型
  569. 入口参数：大数类型result,长整形input
  570. 返回值：成功，返回数的长度，否则返回0；
  571. ----------------------------------------------------------------------------*/
  572. int CRsaA::Getinput1(byteint result,unsigned long input)
  573. {
  574. int i=DATALENGTH-1,m=0;
  575. long j=0;
  576. int k=0;
  578. if(input)
  579. {
  580. do
  581. {
  582. j=input/10;
  583. k=input-j*10;
  584. result[i]=k;
  585. i--;
  586. m++;
  587. input=j;
  588. }while(j);
  589. return m;
  590. }
  591. else
  592. return 0;
  593. }
  595. /*---------------------------------------------------------------------------
  596. 功能：将十六进制的串转换为数值
  597. 入口参数：字符串指针
  598. 返回值：成功，返回数
  599. ----------------------------------------------------------------------------*/
  600. unsigned long CRsaA::Os2ip(unsigned char* pstr)
  601. {
  602. unsigned long ch=0;
  603. unsigned int j=0;
  604. unsigned long k=1;
  605. for(int i=0;i<4;i++)
  606. {
  607. j = (unsigned int) (*(pstr+3-i));
  608. /* if( (*(pstr+3-i))>='0'&&(*(pstr+3-i))<='9')
  609. j = (*(pstr+3-i)) - '0';
  610. if( (*(pstr+3-i))>='a'&&(*(pstr+3-i))<='f') 
  611. j = (*(pstr+3-i)) - 'a'+10;
  612. if( (*(pstr+3-i))>='A'&&(*(pstr+3-i))<='F')
  613. j = (*(pstr+3-i)) - 'A'+10;*/
  614. ch += j*k;
  615. k*=256;
  616. }
  617. return ch;
  618. } 
  620. /*---------------------------------------------------------------------------
  621. 功能：将数串转换为相应的字符串
  622. 入口参数：字符串str
  623. 返回值：返回转换的结果；
  624. ----------------------------------------------------------------------------*/
  625. CString CRsaA::Ip2os(CString str)
  626. {
  627. int strlen=str.GetLength(),quotient=0,remainder=0;
  628. unsigned long num=0,temp=0;
  629. unsigned int k=1;
  630. CString strResult="";
  632. for(int i=strlen;i>0;i--)  //得到相应的数字串,存放在num中
  633. {
  634. temp = (str.GetAt(i-1) - '0');
  635. num += temp*k;
  636. k *= 10;
  637. }
  638. //采用模除的方式,求得相应的十六进制数
  639. for(int j=0;j<4;j++)
  640. {
  641. quotient = num/256;
  642. remainder = num - quotient*256;
  643. /*if(remainder>=0&&remainder<=9)
  644. strResult.Insert(0,(remainder+'0'));
  645. if(remainder>=10&&remainder<=15)
  646. strResult.Insert(0,(remainder-10+'a'));*/
  647. strResult.Insert(0,(unsigned char)remainder);
  648. num = quotient;
  649. }
  651. return strResult; 
  652. }
  654. /*---------------------------------------------------------------------------
  655. 功能：产生RSA秘钥对
  656. 入口参数：存放结果的字符串地址 
  657. 返回值：无
  658. ----------------------------------------------------------------------------*/
  659. void CRsaA::GenKeys(CString& pk,CString& sk,CString& R)
  660. {
  661. byteint m_p,m_q,m_R,m_Rvalue,m_PK,m_SK;
  662. SetZero(m_p);      //对大数变量进行清零初始化
  663. SetZero(m_q);
  664.     SetZero(m_R);
  665.     SetZero(m_Rvalue);
  666.     SetZero(m_PK);
  667.     SetZero(m_SK);
  669. Mdata();         //生成比较数表
  670. AfxMessageBox("开始计算质数P...");
  671. Prime(m_p);        //生成素数p q
  672. AfxMessageBox("开始计算质数Q...");
  673. Prime(m_q);
  675. AfxMessageBox("开始计算模R...");
  676. ComputingR(m_p,m_q,m_R); //计算模R
  677. AfxMessageBox("开始计算模r");
  678. ComputingRvalue(m_p,m_q,m_Rvalue);  //计算r
  679. AfxMessageBox("开始计算秘钥SK,PK");
  680. ComputingPK(m_Rvalue,m_PK,m_SK);    // Generate PK and SK
  682. //CGenKeyBusyDlg dlg1;
  683. //g1.DoModal();
  684. R=PrtInt(m_R);
  685. pk=PrtInt(m_PK);
  686. sk=PrtInt(m_SK);
  687. return ;
  689. }
  691. /*---------------------------------------------------------------------------
  692. 功能：实现加密功能接口
  693. 入口参数：明文字符串source，模字符串R，秘钥字符串key，结果字符串数组result
  694. 返回值：无
  695. ----------------------------------------------------------------------------*/
  696. int CRsaA::RsaEncrypt(CString& source,const char *key,const char *R,CStringArray& result)
  697. {
  698. unsigned char* pstr;
  699. int j;//sourcelen,j;
  700. byteint m_key,m_R,desti,aa;
  701. SetZero(desti);              //将大数变量清零初始化
  702. SetZero(aa);
  703. //SetZero(bb);
  704. SetZero(m_key);
  705. SetZero(m_R);
  707. pstr = (unsigned char*)(LPCTSTR)source;               //得到字符串数据的指针
  708. j = source.GetLength()/4;    //得到数组的元素个数
  710. result.SetSize(j,1);
  711. Getinput(m_key,key);             //将字符串转换为大数类型
  712. Getinput(m_R,R);
  714. for(int i=0;i<j;i++)
  715. {
  716. Getinput1(desti,Os2ip(pstr));    //将四个字节的输入转换为大数类型数值
  717. RsaDo(desti,m_R,m_key,aa);  //进行加密运算
  718. result.SetAt(i,PrtInt(aa));          //将结果存放到数组中
  719. SetZero(desti);  SetZero(aa);
  720. pstr += 4;
  721. }
  722. return j;
  723. }
  725. /*---------------------------------------------------------------------------
  726. 功能：实现解密功能接口
  727. 入口参数：密文字符串数组source，秘钥字符串sk，模字符串R，
  728. 返回值：结果字符串数组result
  729. ----------------------------------------------------------------------------*/
  730. CString CRsaA::RsaDecrypt(CStringArray& source,const char* sk,const char* R)
  731. {
  732. int index=0;
  733. CString result;
  734. byteint m_sk,m_r,desti,aa;
  735. SetZero(m_sk);  SetZero(m_r); SetZero(desti); SetZero(aa);  //SetZero(bb);
  737. index=source.GetSize();   //得到数组的元素个数
  738. Getinput(m_sk,sk);        //将字符串转换为大数类型
  739. Getinput(m_r,R);
  741. for(int i=0;i<index;i++)
  742. {
  743. Getinput(desti,source.GetAt(i));   //将加密结果转换为大数类型
  744. RsaDo(desti,m_r,m_sk,aa);          //解密运算
  745. result += Ip2os(PrtInt(aa));       //组合初始明文
  746. SetZero(aa);  SetZero(desti);
  747. }
  749. return result;        //返回明文串
  750. }
  752. /*---------------------------------------------------------------------------
  753. 功能：生成一个秘钥存贮文件
  754. 入口参数：无
  755. 返回值：无
  756. ----------------------------------------------------------------------------*/
  757. void CRsaA::GenKeysTable()
  758. {
  759. CStringArray RArray,SKArray,PKArray;
  760. CString r,pk,sk;
  761. int j=1,i;      //参数j表示产生的秘钥对的个数
  762. unsigned char strlength;
  763. //设置数组的元素个数
  764. RArray.SetSize(j,1); SKArray.SetSize(j,1); PKArray.SetSize(j,1);
  766. /*-----------------------------------------------------------------------
  767. 文件格式为：
  768. 长度   秘钥   长度   秘钥......
  769. ----   ----   ----   ----
  770. 1byte  nbyte  1byte  nbyte       (中间无空格,R,SK,PK)
  771. */
  772. CFile file;
  774. for(i=0;i<j;i++)
  775. {
  776. GenKeys(pk,sk,r);  //循环产生秘钥
  777. RArray.SetAt(i,r); SKArray.SetAt(i,sk); PKArray.SetAt(i,pk);
  778. }
  780. if(file.Open("c:\key.txt",CFile::modeCreate|CFile::modeReadWrite)==0)
  781. {
  782. AfxMessageBox("open file error!");  //打开文件失败
  783. return;
  784. }
  787. for(i=0;i<j;i++)
  788. {                //循环写入结果
  789. strlength = (unsigned char)(RArray.GetAt(i)).GetLength();
  790. file.Write(&strlength,1);
  792. file.Write(RArray.GetAt(i),(RArray.GetAt(i)).GetLength());
  794. strlength = (unsigned char)(SKArray.GetAt(i)).GetLength();
  795. file.Write(&strlength,1);
  797. file.Write(SKArray.GetAt(i),(SKArray.GetAt(i)).GetLength());
  799. strlength = (unsigned char)(PKArray.GetAt(i)).GetLength();
  800. file.Write(&strlength,1);
  802. file.Write(PKArray.GetAt(i),(PKArray.GetAt(i)).GetLength());
  803. }
  805. file.Close();
  806. }
  808. void CRsaA::LoadKeysFromFile(CString& r,CString& sk,CString& pk)
  809. {
  810. int            j=10,len;
  811. char           *pbuffer;
  812. unsigned char  strlen1;
  814. CFile          file;
  815. CFileException e;
  816. CString        strFileName;
  817. if(file.Open("c:\key.txt",CFile::modeRead)==0)
  818. {
  819. AfxMessageBox("File(key.txt)could not be opened" );
  820. }
  821. file.Read(&strlen1,1);  //读出R长度
  822. len = (int)strlen1;
  824. pbuffer = new char[len+1];
  825. pbuffer[len]='';
  826. file.Read(pbuffer,len);  //读出R
  827. r=pbuffer;
  828. delete pbuffer;
  830. file.Read(&strlen1,1);  //读出SK长度
  831. len = (int)strlen1;
  833. pbuffer = new char[len+1];
  834. pbuffer[len]='';
  835. file.Read(pbuffer,len);  //读出SK
  836. sk=pbuffer;
  837. delete pbuffer;
  839. file.Read(&strlen1,1);  //读出PK长度
  840. len = (int)strlen1;
  842. pbuffer = new char[len+1];
  843. pbuffer[len]='';
  844. file.Read(pbuffer,len);  //读出PK
  845. pk=pbuffer;
  846. delete pbuffer;
  848. file.Close();
  849. }//
  851. #include "stdafx.h"
  852. //#include "RSATest1.h"
  853. #include "Rsawang1.h"
  855. #ifdef _DEBUG
  856. #define new DEBUG_NEW
  857. #undef THIS_FILE
  858. static char THIS_FILE[] = __FILE__;
  859. #endif
  861. /////////////////////////////////////////////////////////////////////////////
  862. // CRsaA
  864. IMPLEMENT_DYNCREATE(CRsaA, CCmdTarget)
  866. CRsaA::CRsaA()
  867. {
  868. InitInt();
  870. }
  872. CRsaA::~CRsaA()
  873. {
  874. }
  877. BEGIN_MESSAGE_MAP(CRsaA, CCmdTarget)
  878. //{{AFX_MSG_MAP(CRsaA)
  879. // NOTE - the ClassWizard will add and remove mapping macros here.
  880. //}}AFX_MSG_MAP
  881. //ON_MESSAGE(WM_COMPUTING,OnComputing)
  882. END_MESSAGE_MAP()
  884. /////////////////////////////////////////////////////////////////////////////
  885. // CRsaA message handlers
  887. /*----------------------------------------------------------------------------
  888. 功能：进行相关大数的初始化
  889. 入口参数：无
  890. 返回值：无
  891. ----------------------------------------------------------------------------*/
  892. void CRsaA::InitInt(void)
  893. {
  894. SetZero(ZEROVALUE); //对大数变量zerovalue清零
  895. memset(mZEROVALUE,0,MLENGTH);
  896. SetZero(ONEVALUE);                      //对大数变量ONEVALUE进行清零
  897. ONEVALUE[DATALENGTH-1]=1; //ONEVALUE的最后一位为1
  898. SetZero(TWOVALUE); //将TOWVALUE进行清零
  899.     TWOVALUE[DATALENGTH-1]=2; //TOWVALUE的最后一位为2
  900. SetZero(EIGHTVALUE); //对EIGHTVALUE进行清零
  901.     EIGHTVALUE[DATALENGTH-1]=8; //最后一位为8
  902. return ;
  903. }
  905. /*---------------------------------------------------------------------------
  906. 功能：将一个大数A转换为相应的字符串形式
  907. 入口参数：大数A
  908. 返回值：相对应的字符串
  909. ----------------------------------------------------------------------------*/
  910. CString CRsaA::PrtInt(byteint A)
  911. {
  912. register i=0;
  913. int m,n;
  914. while(i<DATALENGTH && A[i]==0)          //跳过大数开始的空白0
  915. i++;
  916. if(i<DATALENGTH)
  917. m=DATALENGTH-i;                     //求出有用的大数长度
  918. n=0;
  919. //注意到这里的i已经是数组中第一个非零元素的对应位置，
  920. CString str=""; //因此下面的循环就是从数组中
  921. //存放的数的最高位开始输出。
  922. while(i<DATALENGTH)
  923. {
  924. str += (A[i++]+'0');
  925. }
  926. return str;
  927. }
  929. /*---------------------------------------------------------------------------
  930. 功能：大数A与大数B相乘，结果放入C中 A×B->C
  931. 入口参数：被乘数A和乘数B，结果C
  932. 返回值：无
  933. ----------------------------------------------------------------------------*/
  934. void CRsaA::Multiply(byteint A,byteint B,byteint C)
  935. {
  936. register i,j,w;
  937. int X,Y,Z;
  938. int Avalid=0; //Avalid=validating bits of A
  939. int Bvalid=0; //Avalid=validating bits of B
  940. while (A[Avalid]==0 && Avalid<DATALENGTH)
  941. Avalid++; //计算Avalid
  942. while (B[Bvalid]==0 && Bvalid<DATALENGTH)
  943. Bvalid++; //计算Bvalid
  945. SetZero(C); //将C清零初始化
  947. for(i=DATALENGTH-1;i>=Avalid;i--)
  948. for(j=DATALENGTH-1;j>=Bvalid;j--)       //逐位进行相乘运算
  949. {
  950. X=A[i]*B[j];        
  951. Y=X/10;
  952. Z=X-10*Y;
  953. w=i+j-(DATALENGTH-1);
  954. C[w]=C[w]+Z;
  955. C[w-1]=C[w-1]+(C[w]/10)+Y;
  956. C[w]=C[w]-(C[w]/10)*10;
  957. }
  958. return;
  959. }
  961. /*---------------------------------------------------------------------------
  962. 功能：将指定的自定义的大数进行0初始化
  963. 入口参数：大数A名
  964. 返回值：无
  965. ----------------------------------------------------------------------------*/
  966. void CRsaA::SetZero(byteint A)  
  967. {
  968. memset(A,0,DATALENGTH);                    //调用系统函数进行初始化
  969. }
  971. /*---------------------------------------------------------------------------
  972. 功能：将大数B拷贝到大数A中
  973. 入口参数：大数A，大数B
  974. 返回值：无
  975. ----------------------------------------------------------------------------*/
  976. void CRsaA::IntCpy(byteint A,byteint B)
  977. {
  978. memcpy(A,B,DATALENGTH);                    //调用系统函数完成拷贝
  979. }
  981. /*---------------------------------------------------------------------------
  982. 功能：A＋B的结果送C
  983. 入口参数：大数A,B,C
  984. 返回值：无
  985. ----------------------------------------------------------------------------*/
  986. void CRsaA::Plus(byteint A,byteint B,byteint C)
  987. {
  988. register i;//,w;
  989. int X,Y,Z,m,n,valid;
  990. m=IntValid(A);                 //计算A的长度         
  991. n=IntValid(B);                 //计算B的长度
  992. valid=(m>n)?m+1:n+1;           //计算时要以最长的数为准
  993. SetZero(C);                    //将C清零
  994. for(i=DATALENGTH-1;i>=DATALENGTH-valid;i--)
  995. {
  996. X=A[i]+B[i];               //按位相加
  997. Y=X/10;
  998. Z=X-10*Y;
  1000. C[i]=C[i]+Z;               //计算进位
  1001. C[i-1]=C[i-1]+Y;
  1002. }
  1003. }
  1005. /*---------------------------------------------------------------------------
  1006. 功能：大数SA减去大数SB，结果放入SC
  1007. 入口参数：被减数SA，减数SB，差SC
  1008. 返回值：无
  1009. ----------------------------------------------------------------------------*/
  1010. void CRsaA::Substract(byteint SA,byteint SB,byteint SC)
  1011. {
  1012. byteint buf;
  1013. register i,j;
  1014. int X;
  1015. IntCpy(buf,SA);                  //将SA的内容拷贝到buf中
  1016. SetZero(SC);                 //SC清零初始化
  1017. for(i=DATALENGTH-1;i>=0;i--)
  1018. {
  1019. if(buf[i]<SB[i])             //如果最低位不够减
  1020. {
  1021. buf[i]=buf[i]+10;        //向高位借1
  1022. if(buf[i-1]>0)           //如果高位够减，直接减1
  1023. (buf[i-1])--;    
  1024. else                     //否则一直找到够减的位
  1025. {
  1026. j=i-1;
  1027. while(buf[j]==0)     //j不会出现越界，是因为保证了最高位不为0
  1028. buf[j--]=9;
  1029. buf[j]=buf[j]-1;
  1030. }
  1031. }
  1032. X=buf[i]-SB[i];              //将各位减的结果存入SC中
  1033. SC[i]=X;
  1034. }
  1035. }
  1037. /*---------------------------------------------------------------------------
  1038. 功能：比较两个大数A和B的大小
  1039. 入口参数：大数A和大数B
  1040. 返回值：A>B:return 1 ; A=B:return 0 ; A<B:return -1
  1041. ----------------------------------------------------------------------------*/
  1042. int CRsaA::IntCmp(byteint A,byteint B)
  1043. {
  1044. int stat;
  1045. stat=memcmp(A,B,DATALENGTH);    //系统函数
  1046. if(stat==0)
  1047. return 0;
  1048. if(stat>0)
  1049. return 1;
  1050. return -1;
  1051. }
  1053. /*---------------------------------------------------------------------------
  1054. 功能：得到一个大数的非零位数
  1055. 入口参数：大数validtemp
  1056. 返回值：大数中非零的位数
  1057. ----------------------------------------------------------------------------*/
  1058. int CRsaA::IntValid(byteint validtemp)
  1059. {
  1060. register i=0;
  1061. while(validtemp[i]==0 && i<DATALENGTH)
  1062. i++;
  1063. return DATALENGTH-i;
  1064. }
  1066. /*---------------------------------------------------------------------------
  1067. 功能：计算大数A÷B的结果，余数放在C中，商在D中
  1068. 入口参数：被除数A，除数B，余数C，商D
  1069. 返回值：无
  1070. ----------------------------------------------------------------------------*/
  1071. void CRsaA::SetMode(byteint A,byteint B,byteint C,byteint D)
  1072. {
  1073. register i,j,k;
  1074. int valid_1,valid_2,valid,sbits,cmpval;
  1075. byteint buf1,buf2;
  1076.     
  1077. SetZero(buf1);  SetZero(buf2);
  1078. SetZero(D);                       //将大数D进行清零初始化
  1079.     IntCpy(C,A);                      //将被除数A拷贝到C中
  1080. valid_2=IntValid(B);              //计算B(除数)的位数,
  1081. while((cmpval=IntCmp(C,B))>0)     //变除法为减法,每减一次就判断是否有C>B,如果满足就继续减。
  1082. {
  1083. valid_1=IntValid(C);          //计算C(被除数)的位数,因为它的位数在循环过程中是变化的
  1084.                               //做减法后(C-B)仍然存放在C中
  1085. valid=valid_1-valid_2;        //C的长度与B的长度的差（该值最小为0）
  1086. if(valid>0)                   //如果被除数比除数的位数多
  1087. {
  1088. i=DATALENGTH-valid_1;     //被除数前导零的个数
  1089. j=DATALENGTH-valid_2;     //除数前导零的个数，作下标指示器
  1090. sbits=0;
  1091. for(k=j;k<DATALENGTH;k++)
  1092. {
  1093. if(C[i]>B[j])         //从C和B的最高位开始依次比较对应位的大小，判断是否够减
  1094. break;
  1095. if(C[i]<B[j])
  1096. {
  1097. sbits=1;          //如果不够减，那么C就退一位，再做减法
  1098. break;
  1099. }
  1100. i++;j++;              //当C和B的最高位相等时,就比较二者的次高位
  1101. }
  1102. valid=valid-sbits;
  1103. SetZero(buf1);            //buf1清零
  1104. for(i=valid;i<DATALENGTH;i++)
  1105. {
  1106. j=i-valid;
  1107. buf1[j]=B[i];         //buf1中存放的是B左移若干位之后得到的值
  1108.                       //如果够减,则B左移后最高位与C的最高位对齐,
  1109.                       //否则与C的次高位对齐
  1110. }
  1111. }
  1112. else
  1113. IntCpy(buf1,B);           //当C和B的位数相同时,就直接把B放入缓冲区buf1中
  1115. D[DATALENGTH-1-valid]++;      //这里保存的是在某一位上所做的减法的次数，每做一次就加1
  1116. Substract(C,buf1,buf2);       //不论C的长度与B的长度的差是否大于0，都要做减法，直到C<=B
  1117. IntCpy(C,buf2);
  1118. }
  1119. if(cmpval==0)                     //两个数相等
  1120. {
  1121. SetZero(C);                   //余数为0
  1122. D[DATALENGTH-1]++;            //商为1
  1123. }
  1124. }
  1126. /*---------------------------------------------------------------------------
  1127. 功能：随机地产生一个大数奇数，长度为num，最高位不是0，存放在RandomA中
  1128. 入口参数：大数A，长度num
  1129. 返回值：无
  1130. ----------------------------------------------------------------------------*/
  1131. void CRsaA::IntRandom(byteint RandomA,int num)
  1132. {
  1133. int i;
  1134. SetZero(RandomA);                     //将RandomA清零
  1136. while(!(RandomA[DATALENGTH-1]%2))     //判断条件保证RandomA的最后一位数是奇数
  1137. RandomA[DATALENGTH-1]=rand()%10;  //如果最后一位是偶数，则从新产生最后一位
  1138.     while(!(RandomA[DATALENGTH-num]))     //判断条件保证RandomA最高位不是0
  1139. RandomA[DATALENGTH-num]=rand()%10;//如果最高位是0,则从新产生最高位
  1141. i=DATALENGTH-2;
  1142. while(i>=DATALENGTH-num+1)            //循环产生从次低位开始到次高位的所有位上的数
  1143. RandomA[i--]=rand()%10;
  1144. }
  1146. /*---------------------------------------------------------------------------
  1147. 功能：将质数类型B拷贝到A中，实现类型转换
  1148. 入口参数：大数A，质数类型B
  1149. 返回值：无
  1150. ----------------------------------------------------------------------------*/
  1151. //功能：将数B拷贝到大数A，实现类型转换
  1152. void CRsaA::LoadInt(byteint A,mtype B)
  1153. {
  1154. register i,j;
  1155. SetZero(A);                  //A进行清零初始化
  1156. i=DATALENGTH-1;
  1157. j=MLENGTH-1;
  1158. while(j>0)                   //循环拷贝各位数字
  1159. {
  1160. A[i--]=B[j--];
  1161. }
  1162. }
  1164. /*---------------------------------------------------------------------------
  1165. 功能：该函数用来从集合[1,b-1]中产生若干个用于检测的数，存放在Model[]中
  1166. 入口参数：无
  1167. 返回值：无
  1168. ----------------------------------------------------------------------------*/
  1169. void CRsaA::Mdata()
  1170. {
  1171. register i,j;                     //Randomly choose a set of 100 numbers in [1,b-1]
  1172. int k=MLENGTH-2;
  1174. memset(Model,0,TESTNUM*MLENGTH);  //这个函数在这里用来将整个数组清零，进行初始化
  1175. srand( (unsigned)time( NULL ) );  //进行随机函数的初始化
  1176. for(i=0;i<TESTNUM;i++)            //TESTNUM为需要产生的个数
  1177. {
  1178. for(j=MLENGTH-1;j>=k;j--)
  1179. {
  1180. Model[i][j]=rand()%10;    //注意这里与测试素数的程序中的区别，
  1181. }
  1182. if((memcmp(Model[i],mZEROVALUE,MLENGTH))==0)  
  1183. i--;
  1184. k--;                          //保证所产生的数不为0
  1185. if (k<0) k=MLENGTH-2;
  1186. }
  1188. }
  1190. /*---------------------------------------------------------------------------
  1191. 功能：该函数用来将十进制的大整数转换成二进制的数
  1192. 入口参数：需转换的大数B，二进制结果flag[400]
  1193. 返回值：无
  1194. ----------------------------------------------------------------------------*/
  1195. void CRsaA::TransBi(byteint B,signed char flag[400])
  1196. {
  1197. byteint buf;
  1198. byteint result;
  1199. byteint temp;
  1200. register i;
  1201. SetZero(buf);  SetZero(result);  SetZero(temp);
  1202. memset(flag,0,400);                     //将flag数组清零
  1204. i=399;
  1205. IntCpy(buf,B);                          //将B拷贝到buf中
  1206. while(IntCmp(buf,ZEROVALUE)==1)         //如果buf内容为0
  1207. {
  1208. SetMode(buf,TWOVALUE,temp,result);  //将buf进行大数的模2运算，商在result中，余数temp
  1209. flag[i]=temp[DATALENGTH-1];         
  1210. IntCpy(buf,result);                 //对商继续进行模2运算
  1211. i--;
  1212. }
  1213. flag[i]=-1;                             //设置一个标志位，表明二进制数的开始
  1214. }
  1216. /*---------------------------------------------------------------------------
  1217. 功能：该函数用来进行模幂算法，A为底数，模为c，二进制的指数B存放在数组flag中
  1218. 入口参数：底数A，模C，结果D，二进制质数flag[400]
  1219. 返回值：A^B=1(mod C),返回1；A^B=p-1(mod C),返回2；否则返回0
  1220. ----------------------------------------------------------------------------*/
  1221. int CRsaA::PowerMode(byteint A,byteint C,byteint D,signed char flag[400])
  1222. {
  1223. byteint buf;
  1224. byteint result;
  1225. byteint temp,P;
  1226. register i;
  1227. SetZero(D);   SetZero(buf); SetZero(result); SetZero(temp); SetZero(P);  //将D清零
  1229. IntCpy(temp,A);                       //将A的值拷贝到temp中
  1230. if(flag[399]==1)                      //最低位为1，拷贝本身，flag[i]只有1或者0两种情况
  1231. IntCpy(result,A);
  1232. else   //最低位为0，则幂为1
  1233. IntCpy(result,ONEVALUE);
  1234. i=398;
  1235. while(flag[i]!=-1)                    //判断是否已经到达指数尽头
  1236. {
  1237. Multiply(temp,temp,buf);          //temp*temp->buf 
  1238. SetMode(buf,C,temp,P);            //buf%c余数->temp,商->p
  1239. if(flag[i]!=0)                    //如果该位不是0，则将其和前一步低一位的结果进行乘法运算
  1240. {                                 //否则，将其作为该位的模，在高一位的运算中，只要进行一次
  1241. Multiply(temp,result,buf);    //平方运算，就可以得到高一位的模
  1242. SetMode(buf,C,result,P);
  1243. }
  1244. i--;
  1245. }                                     //result中存放的是最终结果
  1246. IntCpy(buf,C);
  1247. IntCpy(D,result);
  1248. Substract(buf,ONEVALUE,temp);
  1249. if(IntCmp(result,ONEVALUE)==0)        //p mod n=1，判断是否有A^B=1(mod C)
  1250. return 1;
  1251. if(IntCmp(result,temp)==0)            //p mod n=-1[p-1=-1(mod p)]，判断是否有A^B=p-1(mod C)
  1252. return 2;
  1253. return 0;
  1254. }
  1256. /*---------------------------------------------------------------------------
  1257. 功能：产生一个质数
  1258. 入口参数：大数Prm
  1259. 返回值：产生成功，返回0
  1260. ----------------------------------------------------------------------------*/
  1261. int CRsaA::Prime(byteint Prm)
  1262. {
  1263. int i,k,ok;
  1264. signed char flag[400];
  1265. byteint A,B,D,buf1,buf2;
  1266. SetZero(A); SetZero(B); SetZero(D); SetZero(buf1); SetZero(buf2);
  1268. while(1)                                 //一直循环直到找到一个素数为止
  1269. {
  1270. int pass=0;
  1271. srand( (unsigned)time( NULL ) );     //初始化srand
  1272. IntRandom(B,MLENGTH);                //随机产生一个大数B  try b if prime,B是一个奇数
  1274. IntCpy(Prm,B);                       //将B拷贝到prm中 C=N result prime
  1275. Substract(B,ONEVALUE,buf1);          //将B-ONEVALUE的结果放到buf1中
  1276. SetMode(buf1,TWOVALUE,buf2,B);       //B=(B-1)/2的商,buf2=(B-1)/2的余数=0
  1277. TransBi(B,flag);                     //将B转换为二进制大数
  1278. ok=1;
  1279. for(i=0;i<TESTNUM;i++)
  1280. {
  1281. LoadInt(A,Model[i]);             //将数组Model中的第i+1个数读取到A中
  1282. k=PowerMode(A,Prm,D,flag);       //(A^flag) mod Prm ->D
  1283. if(k!=1 && k!=2)                 //不符合判定规则
  1284. {
  1285. ok=0;
  1286. break;
  1287. }
  1288. if(k==1)                         //判定条件1，G=A^(n-1)/2=1
  1289. {
  1290. }
  1291. if(k==2)                         //判定条件2，G=A^(n-1)/2=p-1
  1292. {
  1293. }
  1295. }
  1296. if (ok)//if(ok && pass_2)
  1297. {
  1298. return 0;
  1299. }//for循环用来检测IntRandom(B,MLENGTH)产生的数B是否是一个素数
  1300. }
  1301. }
  1303. /*---------------------------------------------------------------------------
  1304. 功能：计算公钥PK
  1305. 入口参数：$(r)的值在Rvalue中，私钥SK，公钥PK
  1306. 返回值：成功找到，返回1
  1307. ----------------------------------------------------------------------------*/
  1308. int CRsaA::ComputingPK(byteint Rvalue,byteint SK,byteint PK)
  1309. {
  1310. register i;
  1311. byteint PA,PB,PC,buf1,temp,buf2;
  1312. SetZero(PK); SetZero(PA); SetZero(PB); SetZero(PC); SetZero(buf1);   //清零初始化
  1313. SetZero(temp); SetZero(buf2);
  1314. while(1)
  1315. {
  1316. IntRandom(SK,SKLENGTH);        //随机产生一个大数奇数作为Generated secret key
  1318. IntCpy(PB,SK);
  1319. IntCpy(PA,Rvalue);
  1320. while(1)
  1321. {
  1322. SetMode(PA,PB,PC,PK);     //PA=PB*PK+PC
  1323. i=IntCmp(PC,ONEVALUE);
  1324. if(i==0)                  //PC=1, i=0
  1325. break;                //满足条件，是互质的
  1326. i=IntCmp(PC,ZEROVALUE);
  1327. if(i==0)
  1328. {
  1329. i=-1;                 //PC=0,i=-1
  1330. break;                //不满足互质条件，跳出循环，从新生成一个随机数
  1331. }
  1332. IntCpy(PA,PB);            //按照欧几里的定理继续判断
  1334. IntCpy(PB,PC);
  1335. }
  1336. if(i==0)                      //满足，跳出查找循环
  1337. break;
  1338. }
  1340. IntCpy(temp,ONEVALUE);
  1341. IntCpy(PA,Rvalue);
  1342. IntCpy(PB,SK);
  1343. while(1)
  1344. {
  1345. Multiply(PA,temp,buf1);  //buf1=PA*temp
  1346. Plus(buf1,ONEVALUE,buf2);//buf2=(PA*temp)+1
  1347. SetMode(buf2,PB,buf1,PK);//buf=((PA*temp)+1)%PB
  1348. if(IntCmp(buf1,ZEROVALUE)==0)
  1349. break;
  1350. Plus(temp,ONEVALUE,buf1);
  1351. IntCpy(temp,buf1);
  1352. }
  1353. return 1;                   //SK and PK found
  1354. }
  1357. /*---------------------------------------------------------------------------
  1358. 功能：计算模R
  1359. 入口参数：产生的质数p，q，模R
  1360. 返回值：无
  1361. ----------------------------------------------------------------------------*/
  1362. void CRsaA::ComputingR(byteint p,byteint q,byteint R)
  1363. {
  1364. Multiply(p,q,R);              // R=p*q, public mode number
  1365. }
  1367. /*---------------------------------------------------------------------------
  1368. 功能：计算$(r)
  1369. 入口参数：质数p，质数q，模$(r)放在Rvalue
  1370. 返回值：无
  1371. ----------------------------------------------------------------------------*/
  1372. void CRsaA::ComputingRvalue(byteint p,byteint q,byteint Rvalue)
  1373. {
  1374. byteint buf1,buf2;
  1375. SetZero(buf1); SetZero(buf2);
  1377. Substract(p,ONEVALUE,buf1);   // buf1=p-1
  1378. Substract(q,ONEVALUE,buf2);   // buf2=q-1
  1379. Multiply(buf1,buf2,Rvalue);   // Rvalue=(p-1)*(q-1)
  1380. }
  1382. /*---------------------------------------------------------------------------
  1383. 功能：将接受的字符串转换为大数类型
  1384. 入口参数：大数result,字符串input
  1385. 返回值：数的长度
  1386. ----------------------------------------------------------------------------*/
  1387. int CRsaA::Getinput(byteint result,CString input)
  1388. {
  1389. int i=DATALENGTH,m=0;
  1390. long strlen;
  1391. strlen=input.GetLength();
  1393. if(strlen==0) return 0;
  1394. else
  1395. {
  1396. for(int j=0;j<strlen;j++)
  1397. {
  1398. result[i-strlen+j] = (input.GetAt(j)-'0');
  1399. }
  1400. return j;
  1401. }
  1402. }
  1404. /*---------------------------------------------------------------------------
  1405. 功能：实现加密，解密运算功能
  1406. 入口参数：明文(大数类型source)，模R，秘钥key，结果desti
  1407. 返回值：无
  1408. ----------------------------------------------------------------------------*/
  1409. void CRsaA::RsaDo(byteint source,byteint R,byteint key,byteint desti)
  1410. {
  1411. TransBi(key,flag);
  1412. PowerMode(source,R,desti,flag);
  1413. }
  1415. /*---------------------------------------------------------------------------
  1416. 功能：将长整形的数转换为大数类型
  1417. 入口参数：大数类型result,长整形input
  1418. 返回值：成功，返回数的长度，否则返回0；
  1419. ----------------------------------------------------------------------------*/
  1420. int CRsaA::Getinput1(byteint result,unsigned long input)
  1421. {
  1422. int i=DATALENGTH-1,m=0;
  1423. long j=0;
  1424. int k=0;
  1426. if(input)
  1427. {
  1428. do
  1429. {
  1430. j=input/10;
  1431. k=input-j*10;
  1432. result[i]=k;
  1433. i--;
  1434. m++;
  1435. input=j;
  1436. }while(j);
  1437. return m;
  1438. }
  1439. else
  1440. return 0;
  1441. }
  1443. /*---------------------------------------------------------------------------
  1444. 功能：将十六进制的串转换为数值
  1445. 入口参数：字符串指针
  1446. 返回值：成功，返回数
  1447. ----------------------------------------------------------------------------*/
  1448. unsigned long CRsaA::Os2ip(unsigned char* pstr)
  1449. {
  1450. unsigned long ch=0;
  1451. unsigned int j=0;
  1452. unsigned long k=1;
  1453. for(int i=0;i<4;i++)
  1454. {
  1455. j = (unsigned int) (*(pstr+3-i));
  1456. /* if( (*(pstr+3-i))>='0'&&(*(pstr+3-i))<='9')
  1457. j = (*(pstr+3-i)) - '0';
  1458. if( (*(pstr+3-i))>='a'&&(*(pstr+3-i))<='f') 
  1459. j = (*(pstr+3-i)) - 'a'+10;
  1460. if( (*(pstr+3-i))>='A'&&(*(pstr+3-i))<='F')
  1461. j = (*(pstr+3-i)) - 'A'+10;*/
  1462. ch += j*k;
  1463. k*=256;
  1464. }
  1465. return ch;
  1466. } 
  1468. /*---------------------------------------------------------------------------
  1469. 功能：将数串转换为相应的字符串
  1470. 入口参数：字符串str
  1471. 返回值：返回转换的结果；
  1472. ----------------------------------------------------------------------------*/
  1473. CString CRsaA::Ip2os(CString str)
  1474. {
  1475. int strlen=str.GetLength(),quotient=0,remainder=0;
  1476. unsigned long num=0,temp=0;
  1477. unsigned int k=1;
  1478. CString strResult="";
  1480. for(int i=strlen;i>0;i--)  //得到相应的数字串,存放在num中
  1481. {
  1482. temp = (str.GetAt(i-1) - '0');
  1483. num += temp*k;
  1484. k *= 10;
  1485. }
  1486. //采用模除的方式,求得相应的十六进制数
  1487. for(int j=0;j<4;j++)
  1488. {
  1489. quotient = num/256;
  1490. remainder = num - quotient*256;
  1491. /*if(remainder>=0&&remainder<=9)
  1492. strResult.Insert(0,(remainder+'0'));
  1493. if(remainder>=10&&remainder<=15)
  1494. strResult.Insert(0,(remainder-10+'a'));*/
  1495. strResult.Insert(0,(unsigned char)remainder);
  1496. num = quotient;
  1497. }
  1499. return strResult; 
  1500. }
  1502. /*---------------------------------------------------------------------------
  1503. 功能：产生RSA秘钥对
  1504. 入口参数：存放结果的字符串地址 
  1505. 返回值：无
  1506. ----------------------------------------------------------------------------*/
  1507. void CRsaA::GenKeys(CString& pk,CString& sk,CString& R)
  1508. {
  1509. byteint m_p,m_q,m_R,m_Rvalue,m_PK,m_SK;
  1510. SetZero(m_p);      //对大数变量进行清零初始化
  1511. SetZero(m_q);
  1512.     SetZero(m_R);
  1513.     SetZero(m_Rvalue);
  1514.     SetZero(m_PK);
  1515.     SetZero(m_SK);
  1517. Mdata();         //生成比较数表
  1518. AfxMessageBox("开始计算质数P...");
  1519. Prime(m_p);        //生成素数p q
  1520. AfxMessageBox("开始计算质数Q...");
  1521. Prime(m_q);
  1523. AfxMessageBox("开始计算模R...");
  1524. ComputingR(m_p,m_q,m_R); //计算模R
  1525. AfxMessageBox("开始计算模r");
  1526. ComputingRvalue(m_p,m_q,m_Rvalue);  //计算r
  1527. AfxMessageBox("开始计算秘钥SK,PK");
  1528. ComputingPK(m_Rvalue,m_PK,m_SK);    // Generate PK and SK
  1530. //CGenKeyBusyDlg dlg1;
  1531. //g1.DoModal();
  1532. R=PrtInt(m_R);
  1533. pk=PrtInt(m_PK);
  1534. sk=PrtInt(m_SK);
  1535. return ;
  1537. }
  1539. /*---------------------------------------------------------------------------
  1540. 功能：实现加密功能接口
  1541. 入口参数：明文字符串source，模字符串R，秘钥字符串key，结果字符串数组result
  1542. 返回值：无
  1543. ----------------------------------------------------------------------------*/
  1544. int CRsaA::RsaEncrypt(CString& source,const char *key,const char *R,CStringArray& result)
  1545. {
  1546. unsigned char* pstr;
  1547. int j;//sourcelen,j;
  1548. byteint m_key,m_R,desti,aa;
  1549. SetZero(desti);              //将大数变量清零初始化
  1550. SetZero(aa);
  1551. //SetZero(bb);
  1552. SetZero(m_key);
  1553. SetZero(m_R);
  1555. pstr = (unsigned char*)(LPCTSTR)source;               //得到字符串数据的指针
  1556. j = source.GetLength()/4;    //得到数组的元素个数
  1558. result.SetSize(j,1);
  1559. Getinput(m_key,key);             //将字符串转换为大数类型
  1560. Getinput(m_R,R);
  1562. for(int i=0;i<j;i++)
  1563. {
  1564. Getinput1(desti,Os2ip(pstr));    //将四个字节的输入转换为大数类型数值
  1565. RsaDo(desti,m_R,m_key,aa);  //进行加密运算
  1566. result.SetAt(i,PrtInt(aa));          //将结果存放到数组中
  1567. SetZero(desti);  SetZero(aa);
  1568. pstr += 4;
  1569. }
  1570. return j;
  1571. }
  1573. /*---------------------------------------------------------------------------
  1574. 功能：实现解密功能接口
  1575. 入口参数：密文字符串数组source，秘钥字符串sk，模字符串R，
  1576. 返回值：结果字符串数组result
  1577. ----------------------------------------------------------------------------*/
  1578. CString CRsaA::RsaDecrypt(CStringArray& source,const char* sk,const char* R)
  1579. {
  1580. int index=0;
  1581. CString result;
  1582. byteint m_sk,m_r,desti,aa;
  1583. SetZero(m_sk);  SetZero(m_r); SetZero(desti); SetZero(aa);  //SetZero(bb);
  1585. index=source.GetSize();   //得到数组的元素个数
  1586. Getinput(m_sk,sk);        //将字符串转换为大数类型
  1587. Getinput(m_r,R);
  1589. for(int i=0;i<index;i++)
  1590. {
  1591. Getinput(desti,source.GetAt(i));   //将加密结果转换为大数类型
  1592. RsaDo(desti,m_r,m_sk,aa);          //解密运算
  1593. result += Ip2os(PrtInt(aa));       //组合初始明文
  1594. SetZero(aa);  SetZero(desti);
  1595. }
  1597. return result;        //返回明文串
  1598. }
  1600. /*---------------------------------------------------------------------------
  1601. 功能：生成一个秘钥存贮文件
  1602. 入口参数：无
  1603. 返回值：无
  1604. ----------------------------------------------------------------------------*/
  1605. void CRsaA::GenKeysTable()
  1606. {
  1607. CStringArray RArray,SKArray,PKArray;
  1608. CString r,pk,sk;
  1609. int j=1,i;      //参数j表示产生的秘钥对的个数
  1610. unsigned char strlength;
  1611. //设置数组的元素个数
  1612. RArray.SetSize(j,1); SKArray.SetSize(j,1); PKArray.SetSize(j,1);
  1614. /*-----------------------------------------------------------------------
  1615. 文件格式为：
  1616. 长度   秘钥   长度   秘钥......
  1617. ----   ----   ----   ----
  1618. 1byte  nbyte  1byte  nbyte       (中间无空格,R,SK,PK)
  1619. */
  1620. CFile file;
  1622. for(i=0;i<j;i++)
  1623. {
  1624. GenKeys(pk,sk,r);  //循环产生秘钥
  1625. RArray.SetAt(i,r); SKArray.SetAt(i,sk); PKArray.SetAt(i,pk);
  1626. }
  1628. if(file.Open("c:\key.txt",CFile::modeCreate|CFile::modeReadWrite)==0)
  1629. {
  1630. AfxMessageBox("open file error!");  //打开文件失败
  1631. return;
  1632. }
  1635. for(i=0;i<j;i++)
  1636. {                //循环写入结果
  1637. strlength = (unsigned char)(RArray.GetAt(i)).GetLength();
  1638. file.Write(&strlength,1);
  1640. file.Write(RArray.GetAt(i),(RArray.GetAt(i)).GetLength());
  1642. strlength = (unsigned char)(SKArray.GetAt(i)).GetLength();
  1643. file.Write(&strlength,1);
  1645. file.Write(SKArray.GetAt(i),(SKArray.GetAt(i)).GetLength());
  1647. strlength = (unsigned char)(PKArray.GetAt(i)).GetLength();
  1648. file.Write(&strlength,1);
  1650. file.Write(PKArray.GetAt(i),(PKArray.GetAt(i)).GetLength());
  1651. }
  1653. file.Close();
  1654. }
  1656. void CRsaA::LoadKeysFromFile(CString& r,CString& sk,CString& pk)
  1657. {
  1658. int            j=10,len;
  1659. char           *pbuffer;
  1660. unsigned char  strlen1;
  1662. CFile          file;
  1663. CFileException e;
  1664. CString        strFileName;
  1665. if(file.Open("c:\key.txt",CFile::modeRead)==0)
  1666. {
  1667. AfxMessageBox("File(key.txt)could not be opened" );
  1668. }
  1669. file.Read(&strlen1,1);  //读出R长度
  1670. len = (int)strlen1;
  1672. pbuffer = new char[len+1];
  1673. pbuffer[len]='';
  1674. file.Read(pbuffer,len);  //读出R
  1675. r=pbuffer;
  1676. delete pbuffer;
  1678. file.Read(&strlen1,1);  //读出SK长度
  1679. len = (int)strlen1;
  1681. pbuffer = new char[len+1];
  1682. pbuffer[len]='';
  1683. file.Read(pbuffer,len);  //读出SK
  1684. sk=pbuffer;
  1685. delete pbuffer;
  1687. file.Read(&strlen1,1);  //读出PK长度
  1688. len = (int)strlen1;
  1690. pbuffer = new char[len+1];
  1691. pbuffer[len]='';
  1692. file.Read(pbuffer,len);  //读出PK
  1693. pk=pbuffer;
  1694. delete pbuffer;
  1696. file.Close();
  1697. }