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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
RSA.C
资源名称：inet_stock.zip　[点击查看]
上传用户：bjghjy
上传日期：2007-01-07
资源大小：379k
文件大小：9k
源码类别：

金融证券系统

开发平台：

Visual C++

RSA.C：源码内容
  1. #include <windows.h>
  2. #include <malloc.h>
  3. #include <dos.h>
  4. #include <conio.h>
  5. #include <stdlib.h>
  6. #include <stdio.h>
  7. #include <string.h>
  8. #include <math.h>
  9. #include <time.h>
  11. #define DATALENGTH 350
  12. #define MLENGTH 26
  13. #define TESTNUM 20
  14. #define SKLENGTH 4
  15. #define TEXTLENGTH 20
  17. typedef signed char byteint[DATALENGTH]; //-128 ->127
  18. typedef signed char mtype[MLENGTH];
  20. mtype *Model;
  22. byteint ONEVALUE,ZEROVALUE,TWOVALUE,EIGHTVALUE;
  24. //byteint *plaintext;
  25. //byteint *cipertext;
  27. void InitInt(void);
  28. void SetZero(byteint A);
  29. void IntCpy(byteint A,byteint B);
  30. int IntValid(byteint validtemp);
  32. int IntCmp(byteint A,byteint B);
  33. void Plus(byteint A,byteint B,byteint C);
  34. void Substract(byteint SA,byteint SB,byteint SC);
  35. void Multiply(byteint A,byteint B,byteint C);
  36. void SetMode(byteint A,byteint B,byteint C,byteint D);
  38. void IntRandom(byteint RandomA,int num);
  40. void LoadInt(byteint A,mtype B);
  41. void Mdata(void);
  42. void TransBi(byteint B,signed char flag[400]);
  44. int PowerMode(byteint A,byteint C,byteint D,signed char flag[400]);
  46. int Prime(byteint Prm);
  47. int ComputingPK(byteint Rvalue,byteint SK,byteint PK);
  48. int StrToByt(char *str,byteint byt);
  49. void BytToStr(byteint byt,char *str);
  51. void PackInt(byteint A,int B);
  53. byteint R,SK,PK,RsaKey; 
  54. int RsaOk =0;
  56. extern int UDPBlockingHook(void);
  57. extern char szDataPath[128];
  59. int RsaPrepare(byteint sk,byteint pk,byteint r)
  60. {
  61.   byteint p,q,Rvalue,buf1,buf2;
  63. Model =(mtype *)_fmalloc(TESTNUM*DATALENGTH);
  64. Mdata();
  65. InitInt();
  67. Prime(p);
  68. Prime(q);
  69. Multiply(p,q,r);
  70. Substract(p,ONEVALUE,buf1);
  71. Substract(q,ONEVALUE,buf2);
  72. Multiply(buf1,buf2,Rvalue);
  73. ComputingPK(Rvalue,sk,pk); 
  74. _ffree(Model);
  75. return TRUE;
  76. }
  78. int ReadRsaPk(int no,byteint r,byteint pk)
  79. {
  80. char file[80],item[10],temp[100+1];
  82. sprintf(file,"%s\sysinfo.dat",szDataPath);
  83. sprintf(item,"QS%d",no);
  85. if(GetPrivateProfileString("ZQS_RSA_R", item, "", temp,100, file)!=0)
  86. StrToByt(temp,r);
  87. else
  88. return FALSE;
  89. if(GetPrivateProfileString("ZQS_RSA_PK", item, "", temp, 100, file)!=0)
  90. StrToByt(temp,pk);
  91. else
  92. return FALSE;
  93. return TRUE;
  95. }
  98. int WriteRsaPk(int no,byteint r,byteint pk)
  99. {
  100. char file[80],item[10],temp[100+1];
  102. sprintf(file,"%s\sysinfo.dat",szDataPath);
  103. sprintf(item,"QS%d",no);
  105. memset(temp,0,100+1);
  106. BytToStr(r,temp);
  107. if(WritePrivateProfileString("ZQS_RSA_R", item, temp, file)==0)
  108. return FALSE;
  109. memset(temp,0,100+1);
  110. BytToStr(pk,temp);
  111. if(WritePrivateProfileString("ZQS_RSA_PK", item, temp,file)==0)
  112. return FALSE;
  113. return TRUE;
  114. }
  116. int ReadRsaCiper(int no,byteint ciper,char *deskey)
  117. {  
  118. char file[80],item[10],temp[100+1];
  119.  
  120.     sprintf(file,"%s\sysinfo.dat",szDataPath);
  121.     sprintf(item,"QS%d",no);
  123. if(GetPrivateProfileString("ZQS_DES_KEY", item, "", deskey, 100, file)==0)
  124. return FALSE;
  125. if(GetPrivateProfileString("ZQS_DES_RSA", item, "", temp, 100, file)==0)
  126. return FALSE;
  127. StrToByt(temp,ciper);
  128.     return TRUE;
  129. }
  131. int WriteRsaCiper(int no,byteint ciper,char *deskey)
  132. {  
  133. char file[80],item[10],temp[100+1];
  134.  
  135.     sprintf(file,"%s\sysinfo.dat",szDataPath);
  136.     sprintf(item,"QS%d",no);
  138. if(WritePrivateProfileString("ZQS_DES_KEY", item, deskey, file)==0)
  139. return FALSE;
  140. memset(temp,0,100+1);
  141. BytToStr(ciper,temp);
  142. if(WritePrivateProfileString("ZQS_DES_RSA", item, temp, file)==0)
  143. return FALSE;
  144.     return TRUE;
  145. }
  147. int EncipherDesKey(char *deskey,byteint r,byteint pk,byteint rsakey)
  148. {
  149. signed char flag[400];
  150.     byteint buf1;
  152. Model =(mtype *)_fmalloc(TESTNUM*DATALENGTH);
  154. Mdata();
  155. InitInt();
  157. //if(deskey[0] ==0)
  158. IntRandom(buf1,8);
  159.     //else
  160.     //    StrToByt(deskey,buf1);
  161. TransBi(pk,flag);
  162. PowerMode(buf1,r,rsakey,flag);
  163. memset(deskey,0,9);
  164.     BytToStr(buf1,deskey);    
  166. _ffree(Model);
  167. return 0;
  168. }
  171. int DecipherDesKey(byteint rsakey,byteint r,byteint sk,char *deskey)
  172. {
  173. byteint buf1;
  174. signed char flag[400];
  176. Model =(mtype *)_fmalloc(TESTNUM*DATALENGTH);
  178. Mdata();
  179. InitInt();
  181. TransBi(PK,flag);
  182. PowerMode(rsakey,r,buf1,flag);
  183. memset(deskey,0,9);
  184.     BytToStr(buf1,deskey);
  185.     
  186. _ffree(Model);
  188. return 0;
  189. }
  191. void InitInt(void)
  192. {
  193. SetZero(ONEVALUE);
  194. ONEVALUE[DATALENGTH-1]=1;
  195. SetZero(ZEROVALUE);
  196. SetZero(TWOVALUE);
  197. TWOVALUE[DATALENGTH-1]=2;
  198. SetZero(EIGHTVALUE);
  199. EIGHTVALUE[DATALENGTH-1]=8;
  200. //randomize();
  201. srand((unsigned)time(NULL));
  202. }
  205. void Multiply(byteint A,byteint B,byteint C)
  206. {
  207. register i,j,w;
  208. int X,Y,Z;
  209. int Avalid=0;
  210. int Bvalid=0;
  212. while(A[Avalid]==0 &&Avalid <DATALENGTH)
  213. Avalid++;
  214. while(B[Bvalid]==0 &&Bvalid <DATALENGTH)
  215. Bvalid++;
  216. SetZero(C);
  217. for(i=DATALENGTH -1;i>=Avalid;i--)
  218. {
  219. for(j=DATALENGTH-1;j>=Bvalid;j--)
  220. {
  221. X=A[i]*B[j];
  222. Y=X/10;
  223. Z=X-10*Y;
  224. w=i+j-(DATALENGTH-1);
  225. C[w]=C[w]+Z;
  226. C[w-1]=C[w-1]+(C[w]/10)+Y;
  227. C[w]=C[w]-(C[w]/10)*10;
  228. }
  229. }
  230. }
  232. void SetZero(byteint A)
  233. {
  234. memset(A,0,DATALENGTH);
  235. }
  237. void IntCpy(byteint A,byteint B)
  238. {
  239. memcpy(A,B,DATALENGTH);
  240. }
  242. void Plus(byteint A,byteint B,byteint C)
  243. {
  244. register i;
  245. int X,Y,Z,m,n,valid;
  247. m=IntValid(A);
  248. n=IntValid(B);
  249. valid=(m>n) ? m+1:n+1;
  250. SetZero(C);
  251. for(i=DATALENGTH -1;i>=DATALENGTH -valid;i--)
  252. {
  253. X=A[i] +B[i];
  254. Y=X/10;
  255. Z=X-10*Y;
  257. C[i]=C[i]+Z;
  258. C[i-1]=C[i-1]+Y;
  259. }
  260. }
  262. void Substract(byteint SA,byteint SB,byteint SC)
  263. {
  264. byteint buf;
  265. register i,j;
  266. int X;
  268. IntCpy(buf,SA);
  269. SetZero(SC);
  271. for(i=DATALENGTH-1;i>=0;i--)
  272. {
  273. if(buf[i]<SB[i]){
  274. buf[i]+=10;
  275. if(buf[i-1]>0)
  276. (buf[i-1])--;
  277. else {
  278. j=i-1;
  279. while (buf[j]==0)
  280. buf[j--]=9;
  281. buf[j]--;
  282. }
  283. }
  284. X=buf[i]-SB[i];
  285. SC[i]=X;
  286. }
  287. }
  289. int IntCmp(byteint A,byteint B)
  290. {
  291. int stat;
  293. stat =memcmp(A,B,DATALENGTH);
  294. if(stat ==0)
  295. return 0;
  296. if(stat>0)
  297. return 1;
  298. return -1;
  299. }
  301. int IntValid(byteint validtemp)
  302. {
  303. register i=0;
  304. while (validtemp[i]==0 && i<DATALENGTH)
  305. i++;
  306. return DATALENGTH-i;
  307. }
  309. void SetMode(byteint A,byteint B,byteint C,byteint D)
  310. {
  311. register i,j,k;
  313. int valid_1,valid_2,valid,sbits,cmpval;
  314. byteint buf1,buf2;
  316. SetZero(D);
  317. IntCpy(C,A);
  318. valid_2=IntValid(B);
  319. while((cmpval =IntCmp(C,B))>0){
  320. valid_1 =IntValid(C);
  321. valid =valid_1-valid_2;
  322. if(valid>0){
  323. i=DATALENGTH -valid_1;
  324. j=DATALENGTH -valid_2;
  325. sbits=0;
  326. for(k=j;k<DATALENGTH;k++){
  327. if(C[i]>B[j])
  328. break;
  329. if(C[i]<B[j]){
  330. sbits=1;
  331. break;
  332. }
  333. i++;j++;
  334. }
  335. valid=valid -sbits;
  336. SetZero(buf1);
  337. for(i=valid;i<DATALENGTH;i++){
  338. j=i-valid;
  339. buf1[j]=B[i];
  340. }
  341. }
  342. else
  343. IntCpy(buf1,B);
  345. D[DATALENGTH-1-valid]++;
  346. Substract(C,buf1,buf2);
  347. IntCpy(C,buf2);
  348. }
  350. if(cmpval==0){
  351. SetZero(C);
  352. D[DATALENGTH-1]++;
  353. }
  354. }
  356. void IntRandom(byteint RandomA,int num)
  357. {
  358. int i;
  359. SetZero(RandomA);
  360. while(!(RandomA[DATALENGTH-1] % 2))
  361. RandomA[DATALENGTH-1]=rand() % 10;
  363. while(!RandomA[DATALENGTH-num])
  364. RandomA[DATALENGTH-num] =rand() % 10;
  366. i=DATALENGTH -2;
  367. while(i>=DATALENGTH -num +1)
  368. RandomA[i--]=rand() % 10;
  369. }
  371. void LoadInt(byteint A,mtype B)
  372. {
  373. register i,j;
  375. SetZero(A);
  376. i=DATALENGTH -1;
  377. j=MLENGTH -1;
  378. while(j>=0)
  379. A[i--]=B[j--];
  380. }
  382. void Mdata(void)
  383. {
  384. register i,j;
  386. int k=MLENGTH -2;
  387. memset(Model,0,TESTNUM*MLENGTH);
  388. for(i=0;i<TESTNUM;i++){
  389. for(j=MLENGTH-1;j>=k;j--)
  390. Model[i][j]=rand()%10;
  391. k-=1;
  392. }
  393. }
  395. void TransBi(byteint B,signed char flag[400])
  396. {
  397. byteint buf;
  398. byteint result;
  399. byteint temp;
  400. register i;
  402. memset(flag,0,400);
  403. i=399;
  404. IntCpy(buf,B);
  405. while(IntCmp(buf,ZEROVALUE)==1){
  406. UDPBlockingHook();
  407. SetMode(buf,TWOVALUE,temp,result);
  408. flag[i]=temp[DATALENGTH -1];
  409. IntCpy(buf,result);
  410. i--;
  411. }
  412. flag[i] =-1;
  413. }
  415. int PowerMode(byteint A,byteint C,byteint D,signed char flag[400])
  416. {
  417. byteint buf;
  418. byteint result;
  419. byteint temp,P;
  420. register i;
  422. IntCpy(temp,A);
  423. if(flag[399]==1)
  424. IntCpy(result,A);
  425. else
  426. IntCpy(result,ONEVALUE);
  427. i=398;
  428. while(flag[i]!=-1){
  429. UDPBlockingHook();
  430. Multiply(temp,temp,buf);
  431. SetMode(buf,C,temp,P);
  432. if(flag[i]!=0){
  433. Multiply(temp,result,buf);
  434. SetMode(buf,C,result,P);
  435. }
  436. i--;
  437. }
  438. IntCpy(buf,C);
  439. IntCpy(D,result);
  440. Substract(buf,ONEVALUE,temp);
  441. if(IntCmp(result,ONEVALUE)==0)
  442. return 1;
  443. if(IntCmp(result,temp)==0)
  444. return 2;
  445. return 0;
  446. }
  448. int Prime(byteint Prm)
  449. {
  450. int i,k,ok,cnt=0;
  451. signed char flag[400];
  452. byteint A,B,D,buf1,buf2;
  454. while(1){
  455. int pass=0,pass_2=0;
  456. cnt++;
  457. IntRandom(B,MLENGTH);
  459. IntCpy(Prm,B);
  460. Substract(B,ONEVALUE,buf1);
  461. SetMode(buf1,TWOVALUE,buf2,B);
  462. TransBi(B,flag);
  463. ok=1;
  464. for(i=0;i<TESTNUM;i++){
  465. LoadInt(A,Model[i]);
  466. k=PowerMode(A,Prm,D,flag);
  467. if(k!=1&&k!=2)
  468. break;
  469. if(k==2){
  470. pass_2=1;
  471. }
  472. }
  473. if(ok && pass_2 ){
  474. return 0;
  475. }
  476. }
  477. }
  479. int ComputingPK(byteint Rvalue,byteint SK,byteint PK)
  480. {
  481. register i;
  482. byteint PA,PB,PC,buf,temp,buf2;
  483. SetZero(PK);
  484. while(1)
  485. {
  486. IntRandom(SK,SKLENGTH);
  488. IntCpy(PB,SK);
  489. IntCpy(PA,Rvalue);
  490. while(1) {
  491. SetMode(PA,PB,PC,PK);
  492. i=IntCmp(PC,ONEVALUE);
  493. if(i==0)
  494. break;
  495. i=IntCmp(PC,ZEROVALUE);
  496. if(i==0){
  497. i=-1;
  498. break;
  499. }
  500. IntCpy(PA,PB);
  501. IntCpy(PB,PC);
  502. }
  503. if(i==0)
  504. break;
  505. }
  506. IntCpy(temp,ONEVALUE);
  507. IntCpy(PA,Rvalue);
  508. IntCpy(PB,SK);
  510. while (1){
  511. Multiply(PA,temp,buf);
  512. Plus(buf,ONEVALUE,buf2);
  513. SetMode(buf2,PB,buf,PK);
  514. if(IntCmp(buf,ZEROVALUE)==0)
  515. break;
  516. Plus(temp,ONEVALUE,buf);
  517. IntCpy(temp,buf);
  518. }
  519. return 1;
  520. }
  522. void PackInt(byteint A,int B)
  523. {
  524. register i=DATALENGTH-1;
  526. SetZero(A);
  527. while(B>0){
  528. A[i--]=B % 10;
  529. B=B/10;
  530. }
  531. }
  533. int StrToByt(char *str,byteint byt)
  534. {
  535. unsigned int m;
  537. SetZero(byt);
  538. for(m=0;m<strlen(str);m++)
  539. byt[DATALENGTH-1-m]=str[strlen(str)-m-1]-'0';
  540. return 1;
  541. }
  543. void BytToStr(byteint byt,char *str)
  544. {
  545.   unsigned  int i=0,j=0;
  546.   while(i<DATALENGTH&&byt[i]==0) i++;
  547.   for(;i<DATALENGTH;i++,j++)
  548.   {
  549.   str[j] =byt[i]+'0';
  550.   }
  551. }