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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > 查看源码
RSA.C
资源名称：rsa1.zip　[点击查看]
上传用户：kelungde
上传日期：2007-01-06
资源大小：3k
文件大小：9k
源码类别：

加密解密

开发平台：

C/C++

RSA.C：源码内容
  1. #include <windows.h>
  2. #include <dos.h>
  3. #include <conio.h>
  4. #include <stdlib.h>
  5. #include <stdio.h>
  6. #include <string.h>
  7. #include <math.h>
  8. #include <time.h>
  10. #define DATALENGTH 350
  11. #define MLENGTH 10
  12. #define TESTNUM 20
  13. #define SKLENGTH 5
  14. #define TEXTLENGTH 20
  16. typedef signed char byteint[DATALENGTH]; //-128 ->127
  17. typedef signed char mtype[MLENGTH];
  19. mtype Model[TESTNUM];
  21. byteint ONEVALUE,ZEROVALUE,TWOVALUE,EIGHTVALUE;
  24. void InitInt(void);
  25. void SetZero(byteint A);
  26. void IntCpy(byteint A,byteint B);
  27. int IntValid(byteint validtemp);
  29. int IntCmp(byteint A,byteint B);
  30. void Plus(byteint A,byteint B,byteint C);
  31. void Substract(byteint SA,byteint SB,byteint SC);
  32. void Multiply(byteint A,byteint B,byteint C);
  33. void SetMode(byteint A,byteint B,byteint C,byteint D);
  35. void IntRandom(byteint RandomA,int num);
  37. void LoadInt(byteint A,mtype B);
  38. void Mdata(void);
  39. void TransBi(byteint B,signed char flag[400]);
  41. int PowerMode(byteint A,byteint C,byteint D,signed char flag[400]);
  43. int Prime(byteint Prm);
  44. int ComputingPK(byteint Rvalue,byteint SK,byteint PK);
  45. int StrToByt(char *str,byteint byt);
  46. void BytToStr(byteint byt,char *str);
  48. void PackInt(byteint A,int B);
  50. byteint R,SK,PK,RsaKey; 
  52. extern int ShoutBlockingHook (void);
  53. extern char szDataPath[128];
  55. int RsaPrepare(byteint sk,byteint pk,byteint r)
  56. {
  57.   byteint p,q,Rvalue,buf1,buf2;
  59. Mdata();
  60. InitInt();
  62. Prime(p);
  63. Prime(q);
  64. Multiply(p,q,r);
  65. Substract(p,ONEVALUE,buf1);
  66. Substract(q,ONEVALUE,buf2);
  67. Multiply(buf1,buf2,Rvalue);
  68. ComputingPK(Rvalue,sk,pk); 
  69. return TRUE;
  70. }
  72. int ReadRsaFile(byteint r,byteint pk,byteint sk)
  73. {
  74. char file[80],temp[100+1];
  76. sprintf(file,"%s\sys\rsa.dat",szDataPath);
  78. if(GetPrivateProfileString("RSA", "R", "", temp,100, file)!=0)
  79. StrToByt(temp,r);
  80. else
  81. return FALSE;
  82. if(GetPrivateProfileString("RSA", "PK", "", temp, 100, file)!=0)
  83. StrToByt(temp,pk);
  84. else
  85. return FALSE;
  86. if(GetPrivateProfileString("RSA", "SK", "", temp, 100, file)!=0)
  87. StrToByt(temp,sk);
  88. else
  89. return FALSE;
  91. return TRUE;
  93. }
  95. int WriteRsaFile(byteint r,byteint pk,byteint sk)
  96. {
  97. char file[80],temp[100+1];
  99. sprintf(file,"%s\sys\rsa.dat",szDataPath);
  101. memset(temp,0,100+1);
  102. BytToStr(r,temp);
  103. if(WritePrivateProfileString("RSA", "R", temp, file)==0)
  104. return FALSE;
  105. memset(temp,0,100+1);
  106. BytToStr(pk,temp);
  107. if(WritePrivateProfileString("RSA", "PK", temp, file)==0)
  108. return FALSE;
  109. memset(temp,0,100+1);
  110. BytToStr(sk,temp);
  111. if(WritePrivateProfileString("RSA", "SK", temp, file)==0)
  112. return FALSE;
  114. return TRUE;
  115. }
  118. int DecipherDesKey(byteint rsakey,byteint r,byteint sk,char *deskey)
  119. {
  120. byteint buf1;
  121. signed char flag[400];
  123. Mdata();
  124. InitInt();
  126. TransBi(sk,flag);
  127. PowerMode(rsakey,r,buf1,flag);
  128.     BytToStr(buf1,deskey);
  129.     
  130. return 0;
  131. }
  133. void InitInt(void)
  134. {
  135. SetZero(ONEVALUE);
  136. ONEVALUE[DATALENGTH-1]=1;
  137. SetZero(ZEROVALUE);
  138. SetZero(TWOVALUE);
  139. TWOVALUE[DATALENGTH-1]=2;
  140. SetZero(EIGHTVALUE);
  141. EIGHTVALUE[DATALENGTH-1]=8;
  142. //randomize();
  143. srand((unsigned)time(NULL));
  144. }
  147. void Multiply(byteint A,byteint B,byteint C)
  148. {
  149. register i,j,w;
  150. int X,Y,Z;
  151. int Avalid=0;
  152. int Bvalid=0;
  154. while(A[Avalid]==0 &&Avalid <DATALENGTH)
  155. Avalid++;
  156. while(B[Bvalid]==0 &&Bvalid <DATALENGTH)
  157. Bvalid++;
  158. SetZero(C);
  159. for(i=DATALENGTH -1;i>=Avalid;i--)
  160. {
  161. for(j=DATALENGTH-1;j>=Bvalid;j--)
  162. {
  163. X=A[i]*B[j];
  164. Y=X/10;
  165. Z=X-10*Y;
  166. w=i+j-(DATALENGTH-1);
  167. C[w]=C[w]+Z;
  168. C[w-1]=C[w-1]+(C[w]/10)+Y;
  169. C[w]=C[w]-(C[w]/10)*10;
  170. }
  171. }
  172. }
  174. void SetZero(byteint A)
  175. {
  176. memset(A,0,DATALENGTH);
  177. }
  179. void IntCpy(byteint A,byteint B)
  180. {
  181. memcpy(A,B,DATALENGTH);
  182. }
  184. void Plus(byteint A,byteint B,byteint C)
  185. {
  186. register i;
  187. int X,Y,Z,m,n,valid;
  189. m=IntValid(A);
  190. n=IntValid(B);
  191. valid=(m>n) ? m+1:n+1;
  192. SetZero(C);
  193. for(i=DATALENGTH -1;i>=DATALENGTH -valid;i--)
  194. {
  195. X=A[i] +B[i];
  196. Y=X/10;
  197. Z=X-10*Y;
  199. C[i]=C[i]+Z;
  200. C[i-1]=C[i-1]+Y;
  201. }
  202. }
  204. void Substract(byteint SA,byteint SB,byteint SC)
  205. {
  206. byteint buf;
  207. register i,j;
  208. int X;
  210. IntCpy(buf,SA);
  211. SetZero(SC);
  213. for(i=DATALENGTH-1;i>=0;i--)
  214. {
  215. if(buf[i]<SB[i]){
  216. buf[i]+=10;
  217. if(buf[i-1]>0)
  218. (buf[i-1])--;
  219. else {
  220. j=i-1;
  221. while (buf[j]==0)
  222. buf[j--]=9;
  223. buf[j]--;
  224. }
  225. }
  226. X=buf[i]-SB[i];
  227. SC[i]=X;
  228. }
  229. }
  231. int IntCmp(byteint A,byteint B)
  232. {
  233. int stat;
  235. stat =memcmp(A,B,DATALENGTH);
  236. if(stat ==0)
  237. return 0;
  238. if(stat>0)
  239. return 1;
  240. return -1;
  241. }
  243. int IntValid(byteint validtemp)
  244. {
  245. register i=0;
  246. while (validtemp[i]==0 && i<DATALENGTH)
  247. i++;
  248. return DATALENGTH-i;
  249. }
  251. void SetMode(byteint A,byteint B,byteint C,byteint D)
  252. {
  253. register i,j,k;
  255. int valid_1,valid_2,valid,sbits,cmpval;
  256. byteint buf1,buf2;
  258. SetZero(D);
  259. IntCpy(C,A);
  260. valid_2=IntValid(B);
  261. while((cmpval =IntCmp(C,B))>0){
  262. valid_1 =IntValid(C);
  263. valid =valid_1-valid_2;
  264. if(valid>0){
  265. i=DATALENGTH -valid_1;
  266. j=DATALENGTH -valid_2;
  267. sbits=0;
  268. for(k=j;k<DATALENGTH;k++){
  269. if(C[i]>B[j])
  270. break;
  271. if(C[i]<B[j]){
  272. sbits=1;
  273. break;
  274. }
  275. i++;j++;
  276. }
  277. valid=valid -sbits;
  278. SetZero(buf1);
  279. for(i=valid;i<DATALENGTH;i++){
  280. j=i-valid;
  281. buf1[j]=B[i];
  282. }
  283. }
  284. else
  285. IntCpy(buf1,B);
  287. D[DATALENGTH-1-valid]++;
  288. Substract(C,buf1,buf2);
  289. IntCpy(C,buf2);
  290. }
  292. if(cmpval==0){
  293. SetZero(C);
  294. D[DATALENGTH-1]++;
  295. }
  296. }
  298. void IntRandom(byteint RandomA,int num)
  299. {
  300. int i;
  301. SetZero(RandomA);
  302. while(!(RandomA[DATALENGTH-1] % 2))
  303. RandomA[DATALENGTH-1]=rand() % 10;
  305. while(!RandomA[DATALENGTH-num])
  306. RandomA[DATALENGTH-num] =rand() % 10;
  308. i=DATALENGTH -2;
  309. while(i>=DATALENGTH -num +1)
  310. RandomA[i--]=rand() % 10;
  311. }
  313. void LoadInt(byteint A,mtype B)
  314. {
  315. register i,j;
  317. SetZero(A);
  318. i=DATALENGTH -1;
  319. j=MLENGTH -1;
  320. while(j>=0)
  321. A[i--]=B[j--];
  322. }
  324. void Mdata(void)
  325. {
  326. register i,j;
  328. int k=MLENGTH -2;
  329. memset(Model,0,TESTNUM*MLENGTH);
  330. for(i=0;i<TESTNUM;i++){
  331. for(j=MLENGTH-1;j>=k;j--)
  332. Model[i][j]=rand()%10;
  333. k-=1;
  334. }
  335. }
  337. void TransBi(byteint B,signed char flag[400])
  338. {
  339. byteint buf;
  340. byteint result;
  341. byteint temp;
  342. register i;
  344. memset(flag,0,400);
  345. i=399;
  346. IntCpy(buf,B);
  347. while(IntCmp(buf,ZEROVALUE)==1){
  348. ShoutBlockingHook();
  349. SetMode(buf,TWOVALUE,temp,result);
  350. flag[i]=temp[DATALENGTH -1];
  351. IntCpy(buf,result);
  352. i--;
  353. }
  354. flag[i] =-1;
  355. }
  357. int PowerMode(byteint A,byteint C,byteint D,signed char flag[400])
  358. {
  359. byteint buf;
  360. byteint result;
  361. byteint temp,P;
  362. register i;
  364. IntCpy(temp,A);
  365. if(flag[399]==1)
  366. IntCpy(result,A);
  367. else
  368. IntCpy(result,ONEVALUE);
  369. i=398;
  370. while(flag[i]!=-1){
  371. ShoutBlockingHook();
  372. Multiply(temp,temp,buf);
  373. SetMode(buf,C,temp,P);
  374. if(flag[i]!=0){
  375. Multiply(temp,result,buf);
  376. SetMode(buf,C,result,P);
  377. }
  378. i--;
  379. }
  380. IntCpy(buf,C);
  381. IntCpy(D,result);
  382. Substract(buf,ONEVALUE,temp);
  383. if(IntCmp(result,ONEVALUE)==0)
  384. return 1;
  385. if(IntCmp(result,temp)==0)
  386. return 2;
  387. return 0;
  388. }
  390. int Prime(byteint Prm)
  391. {
  392. int i,k,ok,cnt=0;
  393. signed char flag[400];
  394. byteint A,B,D,buf1,buf2;
  395. int pass=0,pass_2=0;
  397. while(1){
  398. ShoutBlockingHook();
  399. cnt++;
  400. IntRandom(B,MLENGTH);
  402. IntCpy(Prm,B);
  403. Substract(B,ONEVALUE,buf1);
  404. SetMode(buf1,TWOVALUE,buf2,B);
  405. TransBi(B,flag);
  406. ok=1;
  407. for(i=0;i<TESTNUM;i++){
  408. LoadInt(A,Model[i]);
  409. k=PowerMode(A,Prm,D,flag);
  410. if(k!=1&&k!=2)
  411. break;
  412. if(k==2){
  413. pass_2=1;
  414. }
  415. }
  416. if(ok && pass_2 ){
  417. return 0;
  418. }
  419. }
  420. }
  422. int ComputingPK(byteint Rvalue,byteint SK,byteint PK)
  423. {
  424. register i;
  425. byteint PA,PB,PC,buf,temp,buf2;
  426. SetZero(PK);
  427. while(1)
  428. {
  429. IntRandom(SK,SKLENGTH);
  431. IntCpy(PB,SK);
  432. IntCpy(PA,Rvalue);
  433. while(1) {
  434. ShoutBlockingHook();
  435. SetMode(PA,PB,PC,PK);
  436. i=IntCmp(PC,ONEVALUE);
  437. if(i==0)
  438. break;
  439. i=IntCmp(PC,ZEROVALUE);
  440. if(i==0){
  441. i=-1;
  442. break;
  443. }
  444. IntCpy(PA,PB);
  445. IntCpy(PB,PC);
  446. }
  447. if(i==0)
  448. break;
  449. }
  450. IntCpy(temp,ONEVALUE);
  451. IntCpy(PA,Rvalue);
  452. IntCpy(PB,SK);
  454. while (1){
  455. Multiply(PA,temp,buf);
  456. Plus(buf,ONEVALUE,buf2);
  457. SetMode(buf2,PB,buf,PK);
  458. if(IntCmp(buf,ZEROVALUE)==0)
  459. break;
  460. Plus(temp,ONEVALUE,buf);
  461. IntCpy(temp,buf);
  462. }
  463. return 1;
  464. }
  466. void PackInt(byteint A,int B)
  467. {
  468. register i=DATALENGTH-1;
  470. SetZero(A);
  471. while(B>0){
  472. A[i--]=B % 10;
  473. B=B/10;
  474. }
  475. }
  477. int StrToByt(char *str,byteint byt)
  478. {
  479. unsigned int m;
  481. SetZero(byt);
  482. for(m=0;m<strlen(str);m++)
  483. byt[DATALENGTH-1-m]=str[strlen(str)-m-1]-'0';
  484. return 1;
  485. }
  487. void BytToStr(byteint byt,char *str)
  488. {
  489.   unsigned  int i=0,j=0;
  490.   while(i<DATALENGTH&&byt[i]==0) i++;
  491.   for(;i<DATALENGTH;i++,j++)
  492.   {
  493.   str[j] =byt[i]+'0';
  494.   }
  495. }