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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 钩子与API截获 > 查看源码
softrsa.c
资源名称：HookAPI　[点击查看]
上传用户：nbcables
上传日期：2007-01-11
资源大小：1243k
文件大小：26k
源码类别：

钩子与API截获

开发平台：

Visual C++

softrsa.c：源码内容
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <memory.h>
  4. #include <time.h>
  6. //#include <winsock2.h>
  8. #include "setenv.h"
  9. #include "ca_common.h"
  10. #include "ca_error.h"
  12. #include "rsaref.h"
  13. #include "csp_api.h"
  14. #include "csp_self.h" 
  16. #define FIRST 1
  17. #define MID 2
  18. #define LAST 3
  19. #define ONLY 4
  20. #define SUCCESS 0
  22. static unsigned short static_inbuf[2560];  
  24. void gen_i_enkey(unsigned short *inkey, unsigned short *enkey_array);
  25. void gen_i_dekey(unsigned short *enkey_array, unsigned short *dekey_array);
  26. void cip(unsigned short *indata, unsigned short *outdata, unsigned short *key);
  27. int  ecb_encry_proc(unsigned short *indata,unsigned short indata_blk,
  28.                     unsigned short *outdata,unsigned short *key);
  29. int  ecb_decry_proc(unsigned short *indata,unsigned short indata_blk,
  30.                     unsigned short *outdata,unsigned short *key);
  31. int  ecb_mac_proc(unsigned short *indata1,unsigned short indata1_blk,
  32.                   unsigned short *outMAC,unsigned short *key);
  34. #define  maxim   65537
  35. unsigned short g_tempenkey[60],g_tempdekey[60];
  37. R_RANDOM_STRUCT  gRandomStruct;
  38. void gen_i_enkey(unsigned short *inkey, unsigned short *enkey_array)
  40. {
  41.     short i,k;
  42.     unsigned short *p;
  43.         k = 0;
  44.         for(i=0;i<8;i++){
  45.            enkey_array[k++] = inkey[i];
  46.         }
  48.         p = enkey_array;
  49.         for(i=0;i<6;i++){
  50.             enkey_array[k++] = (p[1] << 9) | (p[2] >> 7); /*  0 */
  51.             enkey_array[k++] = (p[2] << 9) | (p[3] >> 7); /*  1 */
  52.             enkey_array[k++] = (p[3] << 9) | (p[4] >> 7); /*  2 */
  53.             enkey_array[k++] = (p[4] << 9) | (p[5] >> 7); /*  3 */
  54.             enkey_array[k++] = (p[5] << 9) | (p[6] >> 7); /*  4 */
  55.             enkey_array[k++] = (p[6] << 9) | (p[7] >> 7); /*  5 */
  56.             enkey_array[k++] = (p[7] << 9) | (p[0] >> 7); /*  6 */
  57.             enkey_array[k++] = (p[0] << 9) | (p[1] >> 7); /*  7 */
  58.             p = p + 8;
  59.         }
  60.         return;
  61. }
  63. unsigned short inv(unsigned short xin)
  64. {
  65.     long n1,n2,q,r,b1,b2,t;
  66.         if(xin == 0){
  67.             b2 = 0;
  68.         }
  69.         else{
  70.             n1 = maxim;
  71.             n2 = xin;
  72.             b2 = 1;
  73.             b1 = 0;
  74.             do{
  75.                 r = (n1 % n2);
  76.                 q = n1/n2;
  77.                 if(r == 0){
  78.                     if(b2 < 0){
  79.                         b2 = maxim + b2;
  80.                     }
  81.                 }
  82.                 else{
  83.                     n1 = n2;
  84.                     n2 = r;
  85.                     t = b2;
  86.                     b2 = b1 - q*b2;
  87.                     b1 = t;
  88.                 }
  89.             }while(r != 0);
  90.         }
  91.         return (unsigned short)b2;
  93. }
  95. void gen_i_dekey(unsigned short *enkey_array, unsigned short *dekey_array)
  96. {
  97.     short i,k;
  98.     unsigned short *p;
  99.         p = enkey_array + 46;
  100.         k = 0;
  101.         dekey_array[k++] = inv(p[2]);
  102.         dekey_array[k++] = -p[3];
  103.         dekey_array[k++] = -p[4];
  104.         dekey_array[k++] = inv(p[5]);
  105.         dekey_array[k++] = p[0];
  106.         dekey_array[k++] = p[1];
  107.         p = p - 6;
  108.         for(i=0;i<7;i++){
  109.             dekey_array[k++] = inv(p[2]);
  110.             dekey_array[k++] = -p[4];
  111.             dekey_array[k++] = -p[3];
  112.             dekey_array[k++] = inv(p[5]);
  113.             dekey_array[k++] = p[0];
  114.             dekey_array[k++] = p[1];
  115.             if(i != 6){
  116.                 p = p - 6;
  117.             }
  118.         }
  120.         dekey_array[k++] = inv(enkey_array[0]);
  121.         dekey_array[k++] = -enkey_array[1];
  122.         dekey_array[k++] = -enkey_array[2];
  123.         dekey_array[k++] = inv(enkey_array[3]);
  124.         return;
  125. }
  128. unsigned short mul(unsigned short a, unsigned short b)
  129. {
  130.     unsigned long lx;
  131.     unsigned short low,high,x;
  132.         if(a){
  133.             if(b){
  134.                 lx = a;
  135.                 lx = lx*b;
  136. low = (unsigned short)lx;
  137. high = (unsigned short)(lx >>16);
  138.                 x = low - high;
  139.                 if(low < high){
  140.                     x++;
  141.                 }
  142.                 return (unsigned short)x;
  143.             }
  144.             else{
  145.                 return (unsigned short)(1-a);
  146.             }
  147.         }
  148.         else{
  149.             return (unsigned short)(1-b);
  150.         }
  151. }
  153. void cip(unsigned short *indata, unsigned short *outdata, unsigned short *key)
  154. {
  156. ideaCrypt( indata, outdata, key );
  157.  
  158. /*
  159. unsigned short x1,x2,x3,x4,t1,t2;
  160.     unsigned short *p,i;
  162.         p = key;
  163.         x1 = indata[0];
  164.         x2 = indata[1];
  165.         x3 = indata[2];
  166.         x4 = indata[3];
  167.         for(i=0;i<8;i++){
  168.             x1 = mul(x1,p[0]);
  169.             x2 = x2 + p[1];
  170.             x3 = x3 + p[2];
  171.             x4 = mul(x4,p[3]);
  172.             t2 = mul(x1 ^ x3,p[4]);
  173.             t1 = t2 + (x2^x4);
  174.             t1 = mul(t1,p[5]);
  175.             t2 = t1 + t2;
  176.             x1 = x1 ^ t1;
  177.             x4 = x4 ^ t2;
  179.             t2 = t2 ^ x2;
  180.             x2 = x3 ^ t1;
  181.             x3 = t2;
  183.             p = p + 6;
  184.         }
  186.         outdata[0] = mul(x1,p[0]);
  187.         outdata[1] = x3 + p[1];
  188.         outdata[2] = x2 + p[2];
  189.         outdata[3] = mul(x4,p[3]);
  190. */
  191.         return;
  192. }
  194. int  ecb_encry_proc(unsigned short *indata,unsigned short indata_blk,
  195.                     unsigned short *outdata,unsigned short *key)
  196. {
  197.     unsigned short i;
  198.     unsigned short *inp, *outp;
  199. WORD eKey[ 52 ], dKey[ 52 ];
  200.    ideaExpandKey( key, eKey, dKey );
  202. //       gen_i_enkey(key, g_tempenkey);
  203.         inp = indata;
  204.         outp = outdata;
  205.         for(i=0;i<indata_blk;i++){
  207.             cip(inp, outp, eKey);
  208. //outp[0]=htons(outp[0]);
  209. //outp[1]=htons(outp[1]);
  210. //outp[2]=htons(outp[2]);
  211. //outp[3]=htons(outp[3]);
  213.             inp = inp + 4;
  214.             outp = outp + 4;
  215.         }
  216.         return 0;
  218. }
  221. int  ecb_decry_proc(unsigned short *indata,unsigned short indata_blk,
  222.                     unsigned short *outdata,unsigned short *key)
  223. {
  224.     unsigned short i;
  225.     unsigned short *inp, *outp;
  226. WORD eKey[ 52 ], dKey[ 52 ];
  227.    ideaExpandKey( key, eKey, dKey );
  229. //        gen_i_enkey(key, g_tempenkey);
  230. //        gen_i_dekey(g_tempenkey, g_tempdekey);
  231.         inp = indata;
  232.         outp = outdata;
  233.         for(i=0;i<indata_blk;i++){
  234. //inp[0]=ntohs(inp[0]);
  235. //inp[1]=ntohs(inp[1]);
  236. //inp[2]=ntohs(inp[2]);
  237. //inp[3]=ntohs(inp[3]);
  238.             cip(inp, outp, dKey);
  239.             inp = inp + 4;
  240.             outp = outp + 4;
  241.         }
  242.         return 0;
  243. }
  245. int  ecb_mac_proc(unsigned short *indata1,unsigned short indata1_blk,
  246.                   unsigned short *outMAC,unsigned short *key)
  247. {
  248.     unsigned short i,j,k;
  249.     unsigned short tbuf[4];
  250.     unsigned short *inp;
  251.         gen_i_enkey(key, g_tempenkey);
  253.         inp = indata1;
  254.         tbuf[0] = outMAC[0];
  255.         tbuf[1] = outMAC[1];
  256.         tbuf[2] = outMAC[2];
  257.         tbuf[3] = outMAC[3];
  259.         j = indata1_blk;
  260.         for(i=0;i<j;i++){
  261.             for(k=0;k<4;k++){
  262.                 tbuf[k] ^= inp[k];
  263.             }
  264.             cip(tbuf, tbuf, g_tempenkey);
  265.             inp = inp + 4;
  266.         }
  268.         for(i=0;i<4;i++){
  269.             outMAC[i] = tbuf[i];
  270.         }
  272.         return 0;
  273. }
  275. BYTE generate_soft_mac_core(WORD c_status,BYTE *msg_text,WORD msg_size,
  276. BYTE *hash_text,WORD *hash_size,WORD *save_buf);
  277. BYTE enc_message_sdbi(WORD c_status,BYTE *plain_text,
  278. WORD plain_size, BYTE *cipher_text, WORD *cipher_size,WORD *save_buf);
  279. BYTE dec_message_sdbi(WORD c_status,BYTE *plain_text,WORD *plain_size,
  280. BYTE *cipher_text, WORD cipher_size,WORD *save_buf);
  282. /*------------------ API  functions prototype --------------*/
  283. WORD    Enc_Message_SDBI(WORD  status,BYTE *plain_text,
  284. WORD plain_size,BYTE *cipher_text,WORD *cipher_size,
  285. BYTE *save_buf);
  286. WORD    Dec_Message_SDBI(WORD  status,BYTE *plain_text,
  287. WORD *plain_size,BYTE *cipher_text,WORD cipher_size,
  288. BYTE *save_buf);
  289. WORD    Gen_MAC(WORD  status,BYTE *msg_text,WORD msg_size,
  290. BYTE *mac_text,BYTE *save_buf);
  291.  
  292.  
  293. WORD Enc_Message_SDBI(
  294. WORD  status,
  295. BYTE *plain_text,
  296. WORD plain_size,
  297. BYTE *cipher_text,
  298. WORD *cipher_size,
  299. BYTE *key)
  300. {
  301.  
  302. BYTE    func_serial, ret_val;
  303.   int     cipher_len = 0;
  304. WORD    kdormk = 1;
  305.  
  306. func_serial = E_M_S;
  307. if((status == MID) || (status == FIRST)) {
  308. if(plain_size != 2*MAX_TEXT_LEN) {
  309. return 0xc3;
  310. }
  311. }
  312. if((status == LAST) || (status == ONLY)) {
  313. if(plain_size > 2*MAX_TEXT_LEN) {
  314. return 0xc4;
  316. }
  317. }
  319.  
  320. if((ret_val = enc_message_sdbi(status,plain_text,
  321. plain_size,cipher_text,cipher_size,(WORD*)key)) !=0) {
  322. return(ret_val);
  323. }
  326. return(SUCCESS);
  327. }
  330. /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  331. *  Dec_Message_SDBI
  332. *  return : 0 --- success, else --- failure
  333. * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
  334. WORD Dec_Message_SDBI(
  335. WORD  status,
  336. BYTE *plain_text,
  337. WORD *plain_size,
  338. BYTE *cipher_text,
  339. WORD cipher_size,
  340. BYTE *key)
  341. {
  342.  
  343. BYTE    func_serial, ret_val;
  344.   int     plain_len = 0;
  345.  
  347. func_serial = Dec_M_S;
  349. if((cipher_size % 8) != 0) {
  350. return 0xc9;
  351. }
  353. if((status == MID) || (status == FIRST)) {
  354. if(cipher_size != 2*MAX_TEXT_LEN) {
  355. return 0xc9;
  356. }
  357. }
  358. if((status == LAST) || (status == ONLY)) {
  359. if(cipher_size > 2*MAX_TEXT_LEN) {
  360. return 0xc4;
  361. }
  362. }
  363. if((ret_val = dec_message_sdbi(status,plain_text,
  364. plain_size,cipher_text,cipher_size,(WORD *)key)) !=0) {
  365. return ret_val;
  366. }
  367. return(SUCCESS);
  368. }
  372. /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  373. *  Gen_MAC
  374. *  return : 0 --- success, else --- failure
  375. * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
  376. WORD Gen_MAC(
  377. WORD  status,
  378. BYTE *msg_text,
  379. WORD msg_size,
  380. BYTE *mac_text,
  381. BYTE *key)   /* 16 bytes */
  382. {
  383.  
  384. BYTE    func_serial, ret_val;
  385. WORD     o_len;
  386.  
  387.  
  388. WORD    hashormac = 2;
  389.  
  391. func_serial = Gen_M;
  393. if((status == MID) || (status == FIRST)) {
  394. if(msg_size != 2*MAX_TEXT_LEN) {
  395. return 0xc8;
  396. }
  397. }
  398. if((status == LAST) || (status == ONLY)) {
  399. if(msg_size > 2*MAX_TEXT_LEN) {
  400. return 0xc4;
  401. }
  402. }
  404. if((ret_val = generate_soft_mac_core(status,msg_text,
  405. msg_size,mac_text,&o_len,(WORD *)key)) !=0) {
  406. return ret_val;
  407. }
  408. return(SUCCESS);
  409. }
  410.  
  411. BYTE enc_message_sdbi(WORD c_status,
  412. BYTE *plain_text,
  413. WORD plain_size,
  414. BYTE *cipher_text,
  415. WORD *cipher_size,
  416. WORD *save_buf)
  417. {
  418. WORD    *inbuf;
  419. int     i;
  420. WORD    *word_point, cfb_block=8;
  421. int pad_bytes,pad_zero_no;
  422. int first_sndword,tail_bytes,indata_len;
  423. BYTE  last8bytes[10];
  424. WORD kd_buf[64];
  426. inbuf=static_inbuf;
  427.   memcpy(kd_buf,save_buf,64);
  428. switch(c_status) {
  429.     case 1:
  430. if(plain_size!=(MAX_TEXT_LEN+MAX_TEXT_LEN)){
  431. return(0xc3);
  432. }
  433. ecb_encry_proc((unsigned short *)plain_text,MAX_TEXT_LEN/4,
  434.                     (WORD *)cipher_text,kd_buf);
  436. *cipher_size=MAX_TEXT_LEN*2;
  437. break;
  439.     case 2:
  440. if(plain_size != (MAX_TEXT_LEN + MAX_TEXT_LEN)) {
  441. return(0xc3);
  442. }
  444. ecb_encry_proc((unsigned short *)plain_text,MAX_TEXT_LEN/4,
  445.                     (WORD*)cipher_text,kd_buf);
  446. *cipher_size=MAX_TEXT_LEN*2;
  447. break;
  448.     case 3:
  449. if(plain_size > (MAX_TEXT_LEN + MAX_TEXT_LEN)) {
  450. return(0xc4);
  451. }
  452. cfb_block = 8;
  454. pad_bytes = cfb_block - (plain_size % cfb_block);
  455. pad_zero_no = pad_bytes - 1;
  457. tail_bytes = plain_size;
  458. first_sndword = tail_bytes >> 1;
  460. inbuf[0]=1+((tail_bytes+pad_bytes) >>1);
  461. inbuf[1]=ENC_MSG_LAST_ECB;
  462. word_point = (WORD *)plain_text;
  463. for(i=0;i<first_sndword;i++)
  464. inbuf[i+2] = word_point[i];
  466. if((tail_bytes % 2) ==1) {
  467. last8bytes[0]=plain_text[plain_size - 1];
  468. last8bytes[1]=1;
  469. for(i=0;i<pad_zero_no;i++)
  470. last8bytes[i+2]=0;
  471. }
  472. else {
  473. last8bytes[0]=1;
  474. for(i=0;i<pad_zero_no;i++)
  475. last8bytes[i+1]=0;
  476. }
  478. indata_len=(pad_bytes+1) >> 1;
  479. word_point = (WORD *)last8bytes;
  480. for(i=0;i<indata_len;i++)
  481. inbuf[i+2+first_sndword] = word_point[i];
  482. ecb_encry_proc((unsigned short *)&inbuf[2],(WORD)((inbuf[0]-1)/4),
  483.                     (WORD*)cipher_text,(WORD*)kd_buf);
  484. *cipher_size=(inbuf[0]-1)*2;
  485. break;
  487.     case 4:
  488. if(plain_size > (MAX_TEXT_LEN + MAX_TEXT_LEN)) {
  489. return(0xc4);
  490. }
  492. cfb_block = 8;
  494. pad_bytes = cfb_block - (plain_size % cfb_block);
  495. pad_zero_no = pad_bytes - 1;
  497. tail_bytes = plain_size;
  498. first_sndword = tail_bytes >> 1;
  500. inbuf[0]=1+((tail_bytes+pad_bytes) >>1);
  501. word_point = (WORD *)plain_text;
  502. for(i=0;i<first_sndword;i++)
  503. inbuf[i+2] = word_point[i];
  505. if((tail_bytes % 2) ==1) {
  506. last8bytes[0]=plain_text[plain_size - 1];
  507. last8bytes[1]=1;
  508. for(i=0;i<pad_zero_no;i++)
  509. last8bytes[i+2]=0;
  510. }
  511. else {
  512. last8bytes[0]=1;
  513. for(i=0;i<pad_zero_no;i++)
  514. last8bytes[i+1]=0;
  515. }
  517. indata_len=(pad_bytes+1) >> 1;
  518. word_point = (WORD *)last8bytes;
  519. for(i=0;i<indata_len;i++)
  520. inbuf[i+2+first_sndword] = word_point[i];
  522. ecb_encry_proc((unsigned short *)&inbuf[2],(WORD)((inbuf[0]-1)/4),
  523.                     (WORD*)cipher_text,(WORD*)kd_buf);
  524. *cipher_size=(inbuf[0]-1)*2;
  525. break;
  526.     default:
  527. return(0xff);
  528. }
  529. return(SUCCESS);
  530. }
  533.  
  534. BYTE dec_message_sdbi(WORD c_status,BYTE *plain_text,WORD *plain_size,
  535. BYTE *cipher_text,WORD cipher_size,WORD *save_buf)
  536. {
  537. WORD    *inbuf;
  538.   int     i;
  539.   unsigned char *p;
  540. int tail_posi;
  541.   WORD kd_buf[64];
  543. inbuf=static_inbuf;
  544.   memcpy(kd_buf,save_buf,64);
  545.  
  546. switch(c_status) {
  547.     case 1:
  548. if(cipher_size != (MAX_TEXT_LEN + MAX_TEXT_LEN)) {
  549. return(0xc3);
  550. }
  552. ecb_decry_proc((unsigned short *)cipher_text,MAX_TEXT_LEN/4,
  553.                     (WORD*)plain_text,kd_buf);
  555. *plain_size=MAX_TEXT_LEN*2;
  557. break;
  559.     case 2:
  560. if(cipher_size != (MAX_TEXT_LEN + MAX_TEXT_LEN)) {
  561. return(0xc3);
  562. }
  563.     ecb_decry_proc((unsigned short *)cipher_text,MAX_TEXT_LEN/4,
  564.                     (WORD*)plain_text,kd_buf);
  565. *plain_size=MAX_TEXT_LEN*2;
  567. break;
  569.     case 3:
  570. if(cipher_size > (MAX_TEXT_LEN + MAX_TEXT_LEN)) {
  571. return(0xc4);
  572. }
  574. ecb_decry_proc((unsigned short *)cipher_text,(WORD)(cipher_size/8),
  575.                     inbuf,(WORD*)kd_buf);
  578. i=0;
  579. p=(unsigned char*)inbuf;
  580. tail_posi=cipher_size-1; //-2; debug by david , 20001.2.26
  581. while(p[tail_posi] != 1) {
  582. i++;
  583. if(i>=8)
  584.     return(0xc5);
  585. tail_posi=tail_posi -1;
  586. }
  587. *plain_size=tail_posi;
  588. memcpy(plain_text,(unsigned char*)inbuf,*plain_size);
  589. break;
  590.     case 4:
  591. if(cipher_size > (MAX_TEXT_LEN + MAX_TEXT_LEN)) {
  592. return(0xc4);
  593. }
  595. ecb_decry_proc((unsigned short *)cipher_text,(WORD)(cipher_size/8),
  596.                     inbuf,(WORD*)kd_buf);
  599. i=0;
  600. p=(unsigned char*)inbuf;
  601. tail_posi=cipher_size-1; //-2; debug by david , 20001.2.26
  602. while(p[tail_posi] != 1) {
  603. i++;
  604. if(i>=8)
  605.     return(0xc5);
  606. tail_posi=tail_posi -1;
  607. }
  608. *plain_size=tail_posi;
  609. memcpy(plain_text,(unsigned char*)inbuf,*plain_size);
  610. break;
  612.     default:
  613. return(0xff);
  614. }
  615. return 0;
  616. }
  618.  
  619. BYTE generate_soft_mac_core(WORD c_status,BYTE *msg_text,WORD msg_size,
  620. BYTE *hash_text, WORD *hash_size,WORD *save_buf)
  621. {
  622. WORD    *inbuf;
  623.   int     i;
  624. WORD    *word_point, cfb_block=8;
  626. int pad_bytes,pad_zero_no;
  627. int first_sndword,tail_bytes,indata_len;
  628. BYTE  last8bytes[100];
  629. WORD kd_buf[64];
  630.         inbuf = static_inbuf;
  631.  
  632.     memcpy(kd_buf,save_buf,64);
  634. switch(c_status) {
  635.     case 1:
  636. if(msg_size != (MAX_TEXT_LEN + MAX_TEXT_LEN)) {
  637. return(0xc3);
  638. }
  639. memset(save_buf+32,0,64);
  640. ecb_mac_proc((unsigned short *)msg_text,(WORD)(MAX_TEXT_LEN/4),
  641.                   save_buf+32,(WORD*)(kd_buf+8));
  642. break;
  644.     case 2:
  645. if(msg_size != (MAX_TEXT_LEN + MAX_TEXT_LEN)) {
  646. return(0xc3);
  647. }
  648. ecb_mac_proc((unsigned short *)msg_text,MAX_TEXT_LEN/4,
  649.             save_buf+32,kd_buf+8);
  651. break;
  653.     case 3:
  654. if(msg_size > (MAX_TEXT_LEN + MAX_TEXT_LEN)) {
  655. return(0xc4);
  656. }
  657. cfb_block = 8;
  658.                 memcpy(hash_text,save_buf+32,8);
  659. pad_bytes = cfb_block - (msg_size % cfb_block);
  660. pad_zero_no = pad_bytes - 1;
  662. tail_bytes = msg_size;
  663. first_sndword = tail_bytes >> 1;
  665. inbuf[0]=1+((tail_bytes+pad_bytes) >>1);
  666. word_point = (WORD *)msg_text;
  667. for(i=0;i<first_sndword;i++)
  668. inbuf[i+2] = word_point[i];
  670. if((tail_bytes % 2) ==1) {
  671. last8bytes[0]=msg_text[msg_size - 1];
  672. last8bytes[1]=1;
  673. for(i=0;i<pad_zero_no;i++)
  674. last8bytes[i+2]=0;
  675. }
  676. else {
  677. last8bytes[0]=1;
  678. for(i=0;i<pad_zero_no;i++)
  679. last8bytes[i+1]=0;
  680. }
  682. indata_len=(pad_bytes+1) >> 1;
  683. word_point = (WORD *)last8bytes;
  684. for(i=0;i<indata_len;i++)
  685. inbuf[i+2+first_sndword] = word_point[i];
  686. ecb_mac_proc((unsigned short *)&inbuf[2],(WORD)((inbuf[0]-1)/4),
  687.               (unsigned short*)hash_text,(WORD*)(kd_buf+8));
  689. break;
  691.     case 4:
  692. if(msg_size > (MAX_TEXT_LEN + MAX_TEXT_LEN)) {
  693. return(0xc4);
  694. }
  696. cfb_block = 8;
  697. memset(hash_text,0,8);
  698. pad_bytes = cfb_block - (msg_size % cfb_block);
  699. pad_zero_no = pad_bytes - 1;
  701. tail_bytes = msg_size;
  702. first_sndword=tail_bytes >> 1;
  704. inbuf[0]=1+((tail_bytes + pad_bytes) >>1);
  706. word_point = (WORD *)msg_text;
  707. for(i=0;i<first_sndword;i++)
  708. inbuf[i+2] = word_point[i];
  710. if((tail_bytes % 2) ==1) {
  711. last8bytes[0]=msg_text[msg_size - 1];
  712. last8bytes[1]=1;
  713. for(i=0;i<pad_zero_no;i++)
  714. last8bytes[i+2]=0;
  715. }
  716. else {
  717. last8bytes[0]=1;
  718. for(i=0;i<pad_zero_no;i++)
  719. last8bytes[i+1]=0;
  720. }
  722. indata_len=(pad_bytes+1) >> 1;
  723. word_point = (WORD *)last8bytes;
  724. for(i=0;i<indata_len;i++)
  725. inbuf[i+2+first_sndword] = word_point[i];
  727. ecb_mac_proc((unsigned short *)&inbuf[2],(WORD)((inbuf[0]-1)/4),
  728.               (unsigned short*)hash_text,(WORD*)(kd_buf+8));
  729. break;
  730.     default:
  731. return(0Xff);
  732. }
  733. return 0;
  734. }
  736. #define MAX_BLOCK_LEN 4096
  737. int  CSP_SDBIEncrypt(
  738.         UCHAR  *output,
  739.         ULONG  *outputLen,
  740.         UCHAR  *input,
  741.         ULONG  inputLen,
  742.         UCHAR  * SDBIKey,
  743.         ULONG  SDBIKeyLen
  744.     )
  745. {
  746. USHORT  retWord;
  747. USHORT  bytesLeft,bytesOver;
  748. USHORT inputLen_,outputLen_;
  750. if (SDBIKeyLen!=16)
  751. {
  752. ErrorLocation;
  753. SetError(ERR_CODE_KEYLENGTH);
  754. return RTN_ERR;
  755. }
  757. if (inputLen <= MAX_BLOCK_LEN)
  758. {
  759. inputLen_=(USHORT)inputLen;
  760. retWord = Enc_Message_SDBI(ONLY,input,inputLen_,output,&outputLen_,SDBIKey);
  761. if (retWord)
  762. {
  763. SetError(ERR_CODE_ENCSDBI);
  764. ErrorLocation;
  765. return RTN_ERR;
  766. }
  767.     else
  768. {
  769. *outputLen = (ULONG)outputLen_;
  770. return RTN_OK;
  771. }
  772. }
  774. else
  775. {
  776. bytesLeft = (USHORT)inputLen;
  777. bytesOver = 0;
  778. retWord = Enc_Message_SDBI(FIRST,input+bytesOver,MAX_BLOCK_LEN,output+bytesOver,&outputLen_,SDBIKey);
  779. if (retWord)
  780. {
  781. SetError(ERR_CODE_ENCSDBI);
  782. ErrorLocation;
  783. return RTN_ERR;
  784. }
  785. else
  786. {
  787. bytesLeft -= MAX_BLOCK_LEN;
  788. bytesOver += MAX_BLOCK_LEN;
  789. }
  790. while (bytesLeft > MAX_BLOCK_LEN)
  791. {
  792. retWord = Enc_Message_SDBI(MID,input+bytesOver,MAX_BLOCK_LEN,output+bytesOver,&outputLen_,SDBIKey);
  793. if (retWord)
  794. {
  795. SetError(ERR_CODE_ENCSDBI);
  796. ErrorLocation;
  797. return RTN_ERR;
  798. }
  799. else
  800. {
  801. bytesLeft -= MAX_BLOCK_LEN;
  802. bytesOver += MAX_BLOCK_LEN;
  803. }
  804. }
  805.     
  806. retWord = Enc_Message_SDBI(LAST,input+bytesOver,bytesLeft,output+bytesOver,&outputLen_,SDBIKey);
  807. if (retWord)
  808. {
  809. SetError(ERR_CODE_ENCSDBI);
  810. ErrorLocation;
  811. return RTN_ERR;
  812. }
  813. else
  814. {
  815. bytesLeft -= MAX_BLOCK_LEN;
  816. bytesOver += outputLen_;
  817. }
  818. *outputLen = (ULONG)bytesOver;
  819. return RTN_OK;
  820. }
  821. }
  823.  
  824. int  CSP_SDBIDecrypt(
  825.         UCHAR  *output,
  826.         ULONG  *outputLen,
  827.         UCHAR  *input,
  828.         ULONG  inputLen,
  829.         UCHAR  * SDBIKey,
  830.         ULONG  SDBIKeyLen
  831.     )
  832. {
  833. USHORT  retWord;
  834. USHORT  bytesLeft,bytesOver;
  835. USHORT inputLen_,outputLen_;
  837. if (SDBIKeyLen!=16)
  838. {
  839. ErrorLocation;
  840. SetError(ERR_CODE_KEYLENGTH);
  841. return RTN_ERR;
  842. }
  844. if (inputLen <= MAX_BLOCK_LEN)
  845. {
  846. inputLen_=(USHORT)inputLen;
  847. retWord = Dec_Message_SDBI(ONLY,output,&outputLen_,input,inputLen_,SDBIKey);
  848. if (retWord)
  849. {
  850. SetError(ERR_CODE_DECSDBI);
  851. ErrorLocation;
  852. return RTN_ERR;
  853. }
  854.     else
  855. {
  856. *outputLen = (ULONG)outputLen_;
  857. return RTN_OK;
  858. }
  859. }
  861. else
  862. {
  863. bytesLeft = (USHORT)inputLen;
  864. bytesOver = 0;
  865. retWord = Dec_Message_SDBI(FIRST,output+bytesOver,&outputLen_,input+bytesOver,MAX_BLOCK_LEN,SDBIKey);
  866. if (retWord)
  867. {
  868. SetError(ERR_CODE_DECSDBI);
  869. ErrorLocation;
  870. return RTN_ERR;
  871. }
  872. else
  873. {
  874. bytesLeft -= MAX_BLOCK_LEN;
  875. bytesOver += MAX_BLOCK_LEN;
  876. }
  877. while (bytesLeft > MAX_BLOCK_LEN)
  878. {
  879. retWord = Dec_Message_SDBI(MID,output+bytesOver,&outputLen_,input+bytesOver,MAX_BLOCK_LEN,SDBIKey);
  880. if (retWord)
  881. {
  882. SetError(ERR_CODE_DECSDBI);
  883. ErrorLocation;
  884. return RTN_ERR;
  885. }
  886. else
  887. {
  888. bytesLeft -= MAX_BLOCK_LEN;
  889. bytesOver += MAX_BLOCK_LEN;
  890. }
  891. }
  892.     
  893. retWord = Dec_Message_SDBI(LAST,output+bytesOver,&outputLen_,input+bytesOver,bytesLeft,SDBIKey);
  894. if (retWord)
  895. {
  896. SetError(ERR_CODE_DECSDBI);
  897. ErrorLocation;
  898. return RTN_ERR;
  899. }
  900. else
  901. {
  902. bytesLeft -= MAX_BLOCK_LEN;
  903. bytesOver += outputLen_;
  904. }
  905. *outputLen = (ULONG)bytesOver;
  906. return RTN_OK;
  907. }
  908. }
  911. /*
  913. int CSP_i2d_RSAPublicKey(
  914.         RSA_PUBLIC_KEY  *rsaPublicKey,
  915.         UCHAR  *rsaPublicKeyDERString,
  916.         ULONG  *rsaPublicKeyDERStringLen)
  917. {
  918. return(i2d_RSAPublicKey(rsaPublicKey,
  919. rsaPublicKeyDERString,
  920. rsaPublicKeyDERStringLen));
  921. }
  922. int CSP_d2i_RSAPublicKey(
  923.         UCHAR  *rsaPublicKeyDERString,
  924.         ULONG  rsaPublicKeyDERStringLen,
  925.         RSA_PUBLIC_KEY  *rsaPublicKey)
  926. {
  927. return(d2i_RSAPublicKey(rsaPublicKeyDERString,
  928. rsaPublicKeyDERStringLen,rsaPublicKey));
  930. }
  931. int CSP_i2d_RSAPrivateKey(
  932.         RSA_PRIVATE_KEY  *rsaPrivateKey,
  933.         UCHAR  *rsaPrivateKeyDERString,
  934.         ULONG  *rsaPrivateKeyDERStringLen)
  935. {
  936.      
  937. return(i2d_RSAPrivateKey(rsaPrivateKey,
  938. rsaPrivateKeyDERString,
  939. rsaPrivateKeyDERStringLen));
  940. }
  941. int CSP_d2i_RSAPrivateKey(
  942.         UCHAR  *rsaPrivateKeyDERString,
  943.         ULONG  rsaPrivateKeyDERStringLen,
  944.         RSA_PRIVATE_KEY  *rsaPrivateKey)
  945. {
  946.   return(d2i_RSAPrivateKey(rsaPrivateKeyDERString,
  947. rsaPrivateKeyDERStringLen,
  948. rsaPrivateKey));
  949. }
  950. */
  952. int  CSP_RSAPublicEncrypt(
  953. USHORT  keyNumber, 
  954.         UCHAR  *output,
  955.         ULONG  *outputLen,
  956.         UCHAR  *input,
  957.         ULONG  inputLen,
  958.         RSA_PUBLIC_KEY  *rsaPublicKey
  959.     )
  960. {
  962. int ret_code;
  964. ret_code = RSAPublicEncrypt
  965. (output, outputLen, input, inputLen, (R_RSA_PUBLIC_KEY*)rsaPublicKey, &gRandomStruct);
  967. if (ret_code)
  968. {
  969.     ErrorLocation;
  970. return RTN_ERR; 
  971. }
  974. return RTN_OK;
  975. }
  977. /*Decrypt data use RSA PublicKey;*/
  979. int  CSP_RSAPublicDecrypt(
  980. USHORT  keyNumber,
  981.         UCHAR  *output,
  982.         ULONG  *outputLen,
  983.         UCHAR  *input,
  984.         ULONG  inputLen,
  985.         RSA_PUBLIC_KEY  * rsaPublicKey
  986.     )
  987. {
  988. int ret_code;
  990. ret_code = RSAPublicDecrypt 
  991. (output, outputLen, input, inputLen, (R_RSA_PUBLIC_KEY*)rsaPublicKey);
  992. if (ret_code)
  993. {
  994. ErrorLocation;
  995. return RTN_ERR;
  996. }
  997. return RTN_OK;
  998. }
  1000. /* Encrypt data use RSA PrivateKey;*/
  1002. int  CSP_RSAPrivateEncrypt(
  1003. USHORT  keyNumber,
  1004.         UCHAR  *output, 
  1005.         ULONG  *outputLen,
  1006.         UCHAR  *input,
  1007.         ULONG  inputLen, 
  1008.         RSA_PRIVATE_KEY  *rsaPrivateKey  
  1009.     )
  1010. {
  1011. int ret_code;
  1012. ret_code = RSAPrivateEncrypt 
  1013. (output, outputLen, input, inputLen, (R_RSA_PRIVATE_KEY*)rsaPrivateKey);
  1014. if (ret_code)
  1015. {
  1016. ErrorLocation;
  1017. return RTN_ERR;
  1018. }
  1019. return RTN_OK;
  1020. }
  1022. /*Decrypt data use PrivateKey;*/
  1024. int  CSP_RSAPrivateDecrypt(
  1025. USHORT  keyNumber,
  1026.         UCHAR  *output,
  1027.         ULONG  *outputLen,
  1028.         UCHAR  *input,
  1029.         ULONG  inputLen,
  1030.         RSA_PRIVATE_KEY  *rsaPrivateKey 
  1031.     )
  1032. {
  1033. int ret_code;
  1034. ret_code =  RSAPrivateDecrypt 
  1035. (output, outputLen, input, inputLen,(R_RSA_PRIVATE_KEY*)rsaPrivateKey);
  1036. if (ret_code)
  1037. {
  1038. ErrorLocation;
  1039. return RTN_ERR;
  1040. }
  1041. return RTN_OK;
  1042. }
  1046. static void InitRandomStruct (R_RANDOM_STRUCT * randomStruct)
  1047. {
  1048. unsigned int bytesNeeded;
  1049. long t_time;
  1051. R_RandomInit (randomStruct);
  1052. /*
  1053.  *Initialize with time seed.
  1054.  */
  1055. while (1) {
  1056. R_GetRandomBytesNeeded (&bytesNeeded, randomStruct);
  1057. if (bytesNeeded == 0)
  1058. break;
  1060. time(&t_time);
  1061. R_RandomUpdate (randomStruct,(unsigned char*) &t_time, sizeof(t_time));
  1062. }
  1063. }
  1066. int  CSP_GenRandomBytes(
  1067.         UCHAR  *randomBytes,
  1068.         ULONG  randomBytesLen,
  1069.         UCHAR  *seedValue,
  1070.         ULONG  seedLen
  1071.      )
  1072. {
  1073. int rtn_code;
  1074. InitRandomStruct (&gRandomStruct);
  1075. if(randomBytesLen <1 || randomBytesLen>256)
  1076. return -1;
  1077. rtn_code = R_GenerateBytes(randomBytes,randomBytesLen,&gRandomStruct);
  1078.   if(rtn_code == 0) return RTN_OK;
  1079. else return RTN_ERR;
  1080. }
  1083. int  CSP_GenRSAKeyPair(
  1084.         USHORT  keyNumber,/* if 0 then out the key else must be 1`5;*/
  1085.         RSA_PUBLIC_KEY  *rsaPublicKey,
  1086.         RSA_PRIVATE_KEY  *rsaPrivateKey
  1087.     )
  1089. {
  1090.   R_RSA_PROTO_KEY protoKey;
  1092. if(keyNumber == 0){
  1093.   protoKey.bits = 1024;
  1094.   protoKey.useFermat4 = 1;
  1096.   InitRandomStruct(&gRandomStruct);
  1097.   return R_GeneratePEMKeys((R_RSA_PUBLIC_KEY*)rsaPublicKey, (R_RSA_PRIVATE_KEY*)rsaPrivateKey, &protoKey, &gRandomStruct);
  1098.     }
  1099. return RTN_ERR;
  1100. }
  1102. /*Get out RSA PublicKey by Key Number;*/
  1104. int  CSP_GetRSAPublicKey(
  1105.         USHORT  keyNumber,
  1106.         RSA_PUBLIC_KEY  *rsaPublicKey
  1107.     )
  1108. {
  1109.     
  1110. return RTN_ERR;
  1111. }
  1113. int  CSP_PutRSAKeyPair(
  1114.         USHORT  keyNumber,
  1115.         RSA_PUBLIC_KEY  *rsaPublicKey,
  1116.         RSA_PRIVATE_KEY  *rsaPrivateKey
  1117.     )
  1118. {
  1119. return RTN_ERR;
  1120. }
  1122. int  CSP_InitEnvironment(void)
  1123. {
  1124. return RTN_OK;
  1125. }
  1127. /*Clear Environment; Close Device...*/
  1128. int  CSP_ClearEnvironment(void)
  1129. {
  1130. return RTN_OK;
  1131. }