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

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

钩子与API截获

开发平台：

Visual C++

cryptapi.cpp：源码内容
  1. #include <stdio.h>
  2. #include <memory.h>
  3. #include <string.h>
  6. #define FUNC_OK             0
  7. #define FUNC_ERR            1
  9. #define CPTR            *               
  10. #define CCPTR           **
  11. #define PUB_FUNC_RTN    uint32                  
  13. #include "ca_common.h"
  14. #include "csp_api.h"
  15. #include "md2.h"/*../soft_crypt/*/
  16. #include "md5.h"/*../soft_crypt/*/
  17. #include "sha.h"/*../soft_crypt/*/
  19. #include "common.h"
  20. #include "g_val.h"
  21. #include "asn1.h"
  23. #include "cryptapi.h"
  24. #include "rsaref.h"
  26. static uint8  MD2_DIGEST_INFO[] = {
  27.            0x30, 0x20, 
  28.      0x30, 0x0c, 
  29.        0x06, 0x08, 
  30.          0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x02, 0x02,
  31.                        0x05, 0x00,
  32.                  0x04, 0x10 
  33. };
  34.  
  35. static uint8  MD5_DIGEST_INFO[] = {
  36.            0x30, 0x20, 
  37.      0x30, 0x0c, 
  38.        0x06, 0x08, 
  39.          0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x02, 0x05,
  40.                        0x05, 0x00,
  41.                  0x04, 0x10 
  42. };
  44.  
  45. static uint8  SHA1_DIGEST_INFO[] = {
  46.            0x30, 0x21, 
  47.      0x30, 0x09, 
  48.        0x06, 0x05, 
  49.          0x2b, 0x0e, 0x03, 0x02, 0x1a,
  50.                        0x05, 0x00,
  51.                  0x04, 0x14 
  52. };
  55. char *del_rn(char *pbuf);
  57. CRET Crypt_Get_Version(char* version)
  58. {
  59. // int rtn_code;
  61. strcpy(version, "2.0");
  63. return 0;
  64. }
  68. CRET Crypt_InitEnvironment(void)
  69. {
  70. int rtn_code;
  72.     rtn_code = CSP_InitEnvironment();
  73.     if(rtn_code != RTN_OK){
  74. return FUNC_ERR;
  75. }
  77. return FUNC_OK;
  78. }
  80. CRET Crypt_ClearEnvironment(void)
  81. {
  82. int rtn_code;
  84.     rtn_code = CSP_ClearEnvironment();
  85.     if(rtn_code != RTN_OK){
  86. return FUNC_ERR;
  87. }
  89. return FUNC_OK;
  90. }
  93. CRET CA_Crypt_Gen_Hash(
  94.         int    uid_algorithm,
  95.         unsigned char    *msg,
  96.         int              msgSize,
  97.         unsigned char    *hash,
  98. int              *hashSize)
  99. {
  100. return Crypt_Gen_Hash(
  101.         uid_algorithm,
  102.         msg,
  103.         msgSize,
  104.         hash,
  105. hashSize);
  106. }
  108. int Crypt_Gen_Hash(
  109.         int    uid_algorithm,
  110.         unsigned char    *msg,
  111.         int              msgSize,
  112.         unsigned char    *hash,
  113. int              *hashSize)
  114. {
  116. switch(uid_algorithm){
  117.         case UID_md2WithRSAEncryption:
  118. MD2(msg,msgSize,hash);
  119. *hashSize = 16;
  120. break;
  121.         case UID_md5WithRSAEncryption:
  122. MD5(msg,msgSize,hash);
  123. *hashSize = 16;
  124. break;
  125.         case UID_md5:
  126. MD5(msg,msgSize,hash);
  127. *hashSize = 16;
  128. break;
  129.         case UID_sha1WithRSASignature:
  130. SHA1(msg,msgSize,hash);
  131. *hashSize = 20;
  132. break;
  133.         case UID_sha1:
  134. SHA1(msg,msgSize,hash);
  135. *hashSize = 20;
  136. break;
  137. default:
  138. return FUNC_ERR;
  139.   }
  141. return FUNC_OK;
  142. }
  145. CRET Crypt_Gen_Encoded_Hash(
  146.         int    uid_algorithm,
  147.         unsigned char    *msg,
  148.         int              msgSize,
  149.         unsigned char    *hash,
  150. int              *hashSize)
  151. {
  152. unsigned char digestValue[32];
  153. int i;
  155. switch(uid_algorithm){
  156.         case UID_md2WithRSAEncryption:
  157. MD2(msg,msgSize,digestValue);
  159. i = sizeof(MD2_DIGEST_INFO);
  160.             memcpy(hash,MD2_DIGEST_INFO,i);
  161.             memcpy(&hash[i],digestValue,16);
  163. *hashSize = i + 16;
  164. break;
  165.         case UID_md5WithRSAEncryption:
  166. MD5(msg,msgSize,digestValue);
  168. i = sizeof(MD5_DIGEST_INFO);
  169.             memcpy(hash,MD5_DIGEST_INFO,i);
  170.             memcpy(&hash[i],digestValue,16);
  172. *hashSize = i + 16;
  173. break;
  174.         case UID_md5:
  175. MD5(msg,msgSize,digestValue);
  177. i = sizeof(MD5_DIGEST_INFO);
  178.             memcpy(hash,MD5_DIGEST_INFO,i);
  179.             memcpy(&hash[i],digestValue,16);
  181. *hashSize = i + 16;
  182.   break;
  183.         case UID_sha1WithRSASignature:
  184. SHA1(msg,msgSize,digestValue);
  186. i = sizeof(SHA1_DIGEST_INFO);
  187.             memcpy(hash,SHA1_DIGEST_INFO,i);
  188.             memcpy(&hash[i],digestValue,20);
  190. *hashSize = i + 20;
  191. break;
  192.         case UID_sha1:
  193. SHA1(msg,msgSize,digestValue);
  195. i = sizeof(SHA1_DIGEST_INFO);
  196.             memcpy(hash,SHA1_DIGEST_INFO,i);
  197.             memcpy(&hash[i],digestValue,20);
  199. *hashSize = i + 20;
  200.   break;
  201. default:
  202. return FUNC_ERR;
  203.   }
  205. return FUNC_OK;
  206. }
  209. int c2d_RSA_PUBLIC_KEY(
  210.         RSA_PUBLIC_KEY  *rsaPublicKey,
  211.         uint8   *rsaPublicKeyDERString,
  212.         uint32  *rsaPublicKeyDERStringLen)
  213. {
  214. /*
  215. RSAPublicKey ::= SEQUENCE {
  216.     modulus            INTEGER, -- n
  217.     publicExponent     INTEGER  -- e -- }
  218.  
  219. typedef struct {
  220.     uint16    bits;    
  221.     UCHAR     modulus[MAX_RSA_MODULUS_LEN]; 
  222.     UCHAR     publicExponent [MAX_RSA_MODULUS_LEN];  
  223. }RSA_PUBLIC_KEY;
  224. */
  225.   DATA_BUFFER t_buf;
  226.   ASN1_SEQUENCE *p_head,*p_cur,*p_tail;
  227. uint8 buf[8]; 
  228. uint32 rtn_code;
  229. uint32 i,j,flag;
  231. p_head = 0;
  232. p_cur = 0;
  234. flag = 0;
  235. /* encode the n */
  236. if(flag == 0){
  237. flag = 1;
  238.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  239.         if(rtn_code != FUNC_OK){
  240.         return FUNC_ERR;
  241. }
  243.         p_head = p_tail;
  244.         p_cur = p_tail;
  245. }
  246. else{
  247.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  248.         if(rtn_code != FUNC_OK){
  249. if(p_head != 0)
  250. free_ASN1_SEQUENCE(p_head);
  251.         return FUNC_ERR;
  252. }
  254.         p_cur->next = p_tail;
  255.         p_cur = p_tail;
  256. }
  258. j = 0;
  259. for(i=0;i<MAX_RSA_MODULUS_LEN;i++){
  260. if(rsaPublicKey->modulus[i] == 0){
  261. j++;
  262. }
  263. else{
  264. break;
  265. }
  266. }
  268. t_buf.length = MAX_RSA_MODULUS_LEN - j;
  269. t_buf.data = &rsaPublicKey->modulus[j];
  271. if(t_buf.length == 0){
  272.         buf[0] = 0;
  273.     t_buf.length = 1;
  274.     t_buf.data = buf;
  275.     }
  277.     rtn_code = ASN1_Encode_Integer(
  278.                    t_buf,
  279.        &p_cur->data);
  280.     if(rtn_code != FUNC_OK){
  281. if(p_head!=0)
  282. free_ASN1_SEQUENCE(p_head);
  283. return FUNC_ERR;
  284. }
  286. /* encode the e */
  287. if(flag == 0){
  288. flag = 1;
  289.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  290.         if(rtn_code != FUNC_OK){
  291.         return FUNC_ERR;
  292. }
  294.         p_head = p_tail;
  295.         p_cur = p_tail;
  296. }
  297. else{
  298.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  299.         if(rtn_code != FUNC_OK){
  300. if(p_head!=0)
  301. free_ASN1_SEQUENCE(p_head);
  302.         return FUNC_ERR;
  303. }
  305.         p_cur->next = p_tail;
  306.         p_cur = p_tail;
  307. }
  309. j = 0;
  310. for(i=0;i<MAX_RSA_MODULUS_LEN;i++){
  311. if(rsaPublicKey->publicExponent[i] == 0){
  312. j++;
  313. }
  314. else{
  315. break;
  316. }
  317. }
  319. t_buf.length = MAX_RSA_MODULUS_LEN - j;
  320. t_buf.data = &rsaPublicKey->publicExponent[j];
  322. if(t_buf.length == 0){
  323.         buf[0] = 0;
  324.     t_buf.length = 1;
  325.     t_buf.data = buf;
  326.     }
  328.     rtn_code = ASN1_Encode_Integer(
  329.                    t_buf,
  330.        &p_cur->data);
  331.     if(rtn_code != FUNC_OK){
  332. if(p_head!=0)
  333.         free_ASN1_SEQUENCE(p_head);
  334. return FUNC_ERR;
  335. }
  336.  
  337.     /* encode the whole sequence */
  338.     rtn_code = ASN1_Encode_Sequence(
  339.                    p_head,
  340.    &t_buf);
  341.     if(rtn_code != FUNC_OK){
  342. if(p_head!=0)
  343.         free_ASN1_SEQUENCE(p_head);
  344. return FUNC_ERR;
  345. }
  347.     *rsaPublicKeyDERStringLen = t_buf.length;
  348. memcpy(rsaPublicKeyDERString,t_buf.data,*rsaPublicKeyDERStringLen);
  350. rtn_code = free_ASN1_SEQUENCE(p_head);
  351.     if(rtn_code != FUNC_OK){
  352. if(p_head!=0)
  353.         free_DATA_BUFFER(&t_buf);
  354. return FUNC_ERR;
  355. }
  357.     rtn_code = free_DATA_BUFFER(&t_buf);
  358.     if(rtn_code != FUNC_OK){
  359. return FUNC_ERR;
  360. }
  362. return FUNC_OK;
  363. }
  365. int d2c_RSA_PUBLIC_KEY(
  366.         uint8  *rsaPublicKeyDERString,
  367.         uint32 rsaPublicKeyDERStringLen,
  368.         RSA_PUBLIC_KEY  *rsaPublicKey)
  369. {
  370.   DATA_BUFFER t_buf;
  371.   ASN1_SEQUENCE *p_head,*p_cur;
  372. uint32 rtn_code;
  373. uint32 i;
  375. memset(rsaPublicKey,0,sizeof(RSA_PUBLIC_KEY));
  377. /* decode the sequence */
  378.     t_buf.length = rsaPublicKeyDERStringLen;
  379. t_buf.data = rsaPublicKeyDERString;
  380.     rtn_code = ASN1_Decode_Sequence(
  381.          t_buf,
  382.        &p_head);
  383. p_cur = p_head;
  385.     /* decode the n */
  386. if(p_cur == NULL){
  387. return FUNC_ERR;
  388. }
  390.     rtn_code = ASN1_Decode_Integer(
  391.            p_cur->data,
  392.                    &t_buf);
  393.     if(rtn_code != FUNC_OK){
  394. free_ASN1_SEQUENCE(p_head);
  395. return FUNC_ERR;
  396. }
  398.     if(t_buf.length <= 64){
  399. rsaPublicKey->bits = 512;
  400. }
  401. else{
  402.         if(t_buf.length <= 128){
  403.     rsaPublicKey->bits = 1024;
  404. }
  405. else{
  406. if(t_buf.length <= 256){
  407.         rsaPublicKey->bits = 2048;
  408. }
  409. else{
  410.         return FUNC_ERR;
  411. }
  412. }
  413. }
  415.     i = MAX_RSA_MODULUS_LEN - t_buf.length;
  416.     memcpy(&rsaPublicKey->modulus[i],t_buf.data,t_buf.length);
  418. rtn_code = free_DATA_BUFFER(&t_buf);
  419.     if(rtn_code != FUNC_OK){
  420. free_ASN1_SEQUENCE(p_head);
  421. return FUNC_ERR;
  422. }
  424.     /* decode the e */
  425. p_cur = p_cur->next;
  426. if(p_cur == NULL){
  427. free_ASN1_SEQUENCE(p_head);
  428. return FUNC_ERR;
  429. }
  431.     rtn_code = ASN1_Decode_Integer(
  432.            p_cur->data,
  433.                    &t_buf);
  434.     if(rtn_code != FUNC_OK){
  435. free_ASN1_SEQUENCE(p_head);
  436. return FUNC_ERR;
  437. }
  439.     i = MAX_RSA_MODULUS_LEN - t_buf.length;
  440.     memcpy(&rsaPublicKey->publicExponent[i],t_buf.data,t_buf.length);
  442. rtn_code = free_DATA_BUFFER(&t_buf);
  443.     if(rtn_code != FUNC_OK){
  444. free_ASN1_SEQUENCE(p_head);
  445. return FUNC_ERR;
  446. }
  448. rtn_code = free_ASN1_SEQUENCE(p_head);
  449.     if(rtn_code != FUNC_OK){
  450. return FUNC_ERR;
  451. }
  453. return FUNC_OK;
  454. }
  456. int c2d_RSA_PRIVATE_KEY(
  457.         RSA_PRIVATE_KEY  *rsaPrivateKey,
  458.         uint8  *rsaPrivateKeyDERString,
  459.         uint32 *rsaPrivateKeyDERStringLen)
  460. {    
  461. /*
  462. RSAPrivateKey ::= SEQUENCE {
  463.   version Version,
  464.   modulus INTEGER, -- n
  465.   publicExponent INTEGER, -- e
  466.   privateExponent INTEGER, -- d
  467.   prime1 INTEGER, -- p
  468.   prime2 INTEGER, -- q
  469.   exponent1 INTEGER, -- d mod (p-1)
  470.   exponent2 INTEGER, -- d mod (q-1)
  471.   coefficient INTEGER -- (inverse of q) mod p }
  473. typedef struct rsa_pri_key{
  474. uint16    bits;     
  475. UCHAR     modulus[MAX_RSA_MODULUS_LEN]; 
  476. UCHAR     publicExponent[MAX_RSA_MODULUS_LEN]; 
  477. UCHAR     privateExponent[MAX_RSA_MODULUS_LEN];          
  478. UCHAR     prime[2][MAX_RSA_PRIME_LEN];               
  479. UCHAR     exponent[2][MAX_RSA_PRIME_LEN];               
  480. UCHAR     coefficient [MAX_RSA_PRIME_LEN];               
  481. UCHAR   N[MAX_RSA_MODULUS_LEN];
  482. UCHAR   P[MAX_RSA_MODULUS_LEN];
  483. UCHAR   Q[MAX_RSA_MODULUS_LEN];
  484. UCHAR   d1[MAX_RSA_MODULUS_LEN];
  485. UCHAR   d2[MAX_RSA_MODULUS_LEN];
  486. UCHAR   P_[MAX_RSA_MODULUS_LEN];
  487. UCHAR   Q_[MAX_RSA_MODULUS_LEN];
  488. UCHAR   S[MAX_RSA_MODULUS_LEN];
  489. UCHAR   T[MAX_RSA_MODULUS_LEN];
  490. } RSA_PRIVATE_KEY;
  491. */
  492. DATA_BUFFER t_buf;
  493.   ASN1_SEQUENCE *p_head,*p_cur,*p_tail;
  494. uint8 buf[8]; 
  495. uint32 rtn_code;
  496. uint32 i,j,flag;
  498.     flag = 0;
  499. p_head = 0;
  500. p_cur = 0;
  502. /* encode the version */
  503. if(flag == 0){
  504. flag = 1;
  505.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  506.         if(rtn_code != FUNC_OK){
  507.         return FUNC_ERR;
  508. }
  510.         p_head = p_tail;
  511.         p_cur = p_tail;
  512. }
  513. else{
  514.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  515.         if(rtn_code != FUNC_OK){
  516.             free_ASN1_SEQUENCE(p_head);
  517.         return FUNC_ERR;
  518. }
  520.         p_cur->next = p_tail;
  521.         p_cur = p_tail;
  522. }
  524.     buf[0] = 0;
  525.  
  526. t_buf.length = 1;
  527. t_buf.data = buf;
  529.     rtn_code = ASN1_Encode_Integer(
  530.                    t_buf,
  531.        &p_cur->data);
  532.     if(rtn_code != FUNC_OK){
  533.         free_ASN1_SEQUENCE(p_head);
  534. return FUNC_ERR;
  535. }
  537. /* encode the modulus */
  538. if(flag == 0){
  539. flag = 1;
  540.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  541.         if(rtn_code != FUNC_OK){
  542.         return FUNC_ERR;
  543. }
  545.         p_head = p_tail;
  546.         p_cur = p_tail;
  547. }
  548. else{
  549.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  550.         if(rtn_code != FUNC_OK){
  551.             free_ASN1_SEQUENCE(p_head);
  552.         return FUNC_ERR;
  553. }
  555.         p_cur->next = p_tail;
  556.         p_cur = p_tail;
  557. }
  559. j = 0;
  560. for(i=0;i<MAX_RSA_MODULUS_LEN;i++){
  561. if(rsaPrivateKey->modulus[i] == 0){
  562. j++;
  563. }
  564. else{
  565. break;
  566. }
  567. }
  569. t_buf.length = MAX_RSA_MODULUS_LEN - j;
  570. t_buf.data = &rsaPrivateKey->modulus[j];
  572. if(t_buf.length == 0){
  573.         buf[0] = 0;
  574.     t_buf.length = 1;
  575.     t_buf.data = buf;
  576.     }
  578.     rtn_code = ASN1_Encode_Integer(
  579.                    t_buf,
  580.        &p_cur->data);
  581.     if(rtn_code != FUNC_OK){
  582.         free_ASN1_SEQUENCE(p_head);
  583. return FUNC_ERR;
  584. }
  586. /* encode the publicExponent */
  587. if(flag == 0){
  588. flag = 1;
  589.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  590.         if(rtn_code != FUNC_OK){
  591.         return FUNC_ERR;
  592. }
  594.         p_head = p_tail;
  595.         p_cur = p_tail;
  596. }
  597. else{
  598.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  599.         if(rtn_code != FUNC_OK){
  600.             free_ASN1_SEQUENCE(p_head);
  601.         return FUNC_ERR;
  602. }
  604.         p_cur->next = p_tail;
  605.         p_cur = p_tail;
  606. }
  608. j = 0;
  609. for(i=0;i<MAX_RSA_MODULUS_LEN;i++){
  610. if(rsaPrivateKey->publicExponent[i] == 0){
  611. j++;
  612. }
  613. else{
  614. break;
  615. }
  616. }
  618. t_buf.length = MAX_RSA_MODULUS_LEN - j;
  619. t_buf.data = &rsaPrivateKey->publicExponent[j];
  621. if(t_buf.length == 0){
  622.         buf[0] = 0;
  623.     t_buf.length = 1;
  624.     t_buf.data = buf;
  625.     }
  627.     rtn_code = ASN1_Encode_Integer(
  628.                    t_buf,
  629.        &p_cur->data);
  630.     if(rtn_code != FUNC_OK){
  631.         free_ASN1_SEQUENCE(p_head);
  632. return FUNC_ERR;
  633. }
  635. /* encode the privateExponent */
  636. if(flag == 0){
  637. flag = 1;
  638.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  639.         if(rtn_code != FUNC_OK){
  640.         return FUNC_ERR;
  641. }
  643.         p_head = p_tail;
  644.         p_cur = p_tail;
  645. }
  646. else{
  647.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  648.         if(rtn_code != FUNC_OK){
  649.             free_ASN1_SEQUENCE(p_head);
  650.         return FUNC_ERR;
  651. }
  653.         p_cur->next = p_tail;
  654.         p_cur = p_tail;
  655. }
  657. j = 0;
  658. for(i=0;i<MAX_RSA_MODULUS_LEN;i++){
  659. if(rsaPrivateKey->privateExponent[i] == 0){
  660. j++;
  661. }
  662. else{
  663. break;
  664. }
  665. }
  667. t_buf.length = MAX_RSA_MODULUS_LEN - j;
  668. t_buf.data = &rsaPrivateKey->privateExponent[j];
  670. if(t_buf.length == 0){
  671.         buf[0] = 0;
  672.     t_buf.length = 1;
  673.     t_buf.data = buf;
  674.     }
  676.     rtn_code = ASN1_Encode_Integer(
  677.                    t_buf,
  678.        &p_cur->data);
  679.     if(rtn_code != FUNC_OK){
  680.         free_ASN1_SEQUENCE(p_head);
  681. return FUNC_ERR;
  682. }
  684. /* encode the prime[0] */
  685. if(flag == 0){
  686. flag = 1;
  687.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  688.         if(rtn_code != FUNC_OK){
  689.         return FUNC_ERR;
  690. }
  692.         p_head = p_tail;
  693.         p_cur = p_tail;
  694. }
  695. else{
  696.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  697.         if(rtn_code != FUNC_OK){
  698.             free_ASN1_SEQUENCE(p_head);
  699.         return FUNC_ERR;
  700. }
  702.         p_cur->next = p_tail;
  703.         p_cur = p_tail;
  704. }
  706. j = 0;
  707. for(i=0;i<MAX_RSA_PRIME_LEN;i++){
  708. if(rsaPrivateKey->prime[0][i] == 0){
  709. j++;
  710. }
  711. else{
  712. break;
  713. }
  714. }
  716. t_buf.length = MAX_RSA_PRIME_LEN - j;
  717. t_buf.data = &rsaPrivateKey->prime[0][j];
  719. if(t_buf.length == 0){
  720.         buf[0] = 0;
  721.     t_buf.length = 1;
  722.     t_buf.data = buf;
  723.     }
  725.     rtn_code = ASN1_Encode_Integer(
  726.                    t_buf,
  727.        &p_cur->data);
  728.     if(rtn_code != FUNC_OK){
  729.         free_ASN1_SEQUENCE(p_head);
  730. return FUNC_ERR;
  731. }
  733. /* encode the prime[1] */
  734. if(flag == 0){
  735. flag = 1;
  736.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  737.         if(rtn_code != FUNC_OK){
  738.         return FUNC_ERR;
  739. }
  741.         p_head = p_tail;
  742.         p_cur = p_tail;
  743. }
  744. else{
  745.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  746.         if(rtn_code != FUNC_OK){
  747.             free_ASN1_SEQUENCE(p_head);
  748.         return FUNC_ERR;
  749. }
  751.         p_cur->next = p_tail;
  752.         p_cur = p_tail;
  753. }
  755. j = 0;
  756. for(i=0;i<MAX_RSA_PRIME_LEN;i++){
  757. if(rsaPrivateKey->prime[1][i] == 0){
  758. j++;
  759. }
  760. else{
  761. break;
  762. }
  763. }
  765. t_buf.length = MAX_RSA_PRIME_LEN - j;
  766. t_buf.data = &rsaPrivateKey->prime[1][j];
  768. if(t_buf.length == 0){
  769.         buf[0] = 0;
  770.     t_buf.length = 1;
  771.     t_buf.data = buf;
  772.     }
  774.     rtn_code = ASN1_Encode_Integer(
  775.                    t_buf,
  776.        &p_cur->data);
  777.     if(rtn_code != FUNC_OK){
  778.         free_ASN1_SEQUENCE(p_head);
  779. return FUNC_ERR;
  780. }
  782. /* encode the exponent[0] */
  783. if(flag == 0){
  784. flag = 1;
  785.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  786.         if(rtn_code != FUNC_OK){
  787.         return FUNC_ERR;
  788. }
  790.         p_head = p_tail;
  791.         p_cur = p_tail;
  792. }
  793. else{
  794.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  795.         if(rtn_code != FUNC_OK){
  796.             free_ASN1_SEQUENCE(p_head);
  797.         return FUNC_ERR;
  798. }
  800.         p_cur->next = p_tail;
  801.         p_cur = p_tail;
  802. }
  804. j = 0;
  805. for(i=0;i<MAX_RSA_PRIME_LEN;i++){
  806. if(rsaPrivateKey->exponent[0][i] == 0){
  807. j++;
  808. }
  809. else{
  810. break;
  811. }
  812. }
  814. t_buf.length = MAX_RSA_PRIME_LEN - j;
  815. t_buf.data = &rsaPrivateKey->exponent[0][j];
  817. if(t_buf.length == 0){
  818.         buf[0] = 0;
  819.     t_buf.length = 1;
  820.     t_buf.data = buf;
  821.     }
  823.     rtn_code = ASN1_Encode_Integer(
  824.                    t_buf,
  825.        &p_cur->data);
  826.     if(rtn_code != FUNC_OK){
  827.         free_ASN1_SEQUENCE(p_head);
  828. return FUNC_ERR;
  829. }
  831. /* encode the exponent[1] */
  832. if(flag == 0){
  833. flag = 1;
  834.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  835.         if(rtn_code != FUNC_OK){
  836.         return FUNC_ERR;
  837. }
  839.         p_head = p_tail;
  840.         p_cur = p_tail;
  841. }
  842. else{
  843.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  844.         if(rtn_code != FUNC_OK){
  845.             free_ASN1_SEQUENCE(p_head);
  846.         return FUNC_ERR;
  847. }
  849.         p_cur->next = p_tail;
  850.         p_cur = p_tail;
  851. }
  853. j = 0;
  854. for(i=0;i<MAX_RSA_PRIME_LEN;i++){
  855. if(rsaPrivateKey->exponent[1][i] == 0){
  856. j++;
  857. }
  858. else{
  859. break;
  860. }
  861. }
  863. t_buf.length = MAX_RSA_PRIME_LEN - j;
  864. t_buf.data = &rsaPrivateKey->exponent[1][j];
  866. if(t_buf.length == 0){
  867.         buf[0] = 0;
  868.     t_buf.length = 1;
  869.     t_buf.data = buf;
  870.     }
  872.     rtn_code = ASN1_Encode_Integer(
  873.                    t_buf,
  874.        &p_cur->data);
  875.     if(rtn_code != FUNC_OK){
  876.         free_ASN1_SEQUENCE(p_head);
  877. return FUNC_ERR;
  878. }
  880. /* encode the coefficient */
  881. if(flag == 0){
  882. flag = 1;
  883.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  884.         if(rtn_code != FUNC_OK){
  885.         return FUNC_ERR;
  886. }
  888.         p_head = p_tail;
  889.         p_cur = p_tail;
  890. }
  891. else{
  892.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  893.         if(rtn_code != FUNC_OK){
  894.             free_ASN1_SEQUENCE(p_head);
  895.         return FUNC_ERR;
  896. }
  898.         p_cur->next = p_tail;
  899.         p_cur = p_tail;
  900. }
  902. j = 0;
  903. for(i=0;i<MAX_RSA_PRIME_LEN;i++){
  904. if(rsaPrivateKey->coefficient[i] == 0){
  905. j++;
  906. }
  907. else{
  908. break;
  909. }
  910. }
  912. t_buf.length = MAX_RSA_PRIME_LEN - j;
  913. t_buf.data = &rsaPrivateKey->coefficient[j];
  915. if(t_buf.length == 0){
  916.         buf[0] = 0;
  917.     t_buf.length = 1;
  918.     t_buf.data = buf;
  919.     }
  921.     rtn_code = ASN1_Encode_Integer(
  922.                    t_buf,
  923.        &p_cur->data);
  924.     if(rtn_code != FUNC_OK){
  925.         free_ASN1_SEQUENCE(p_head);
  926. return FUNC_ERR;
  927. }
  928. /***************************************/
  929. /*  
  930. if(flag == 0){
  931. flag = 1;
  932.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  933.         if(rtn_code != FUNC_OK){
  934.         return FUNC_ERR;
  935. }
  937.         p_head = p_tail;
  938.         p_cur = p_tail;
  939. }
  940. else{
  941.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  942.         if(rtn_code != FUNC_OK){
  943.             free_ASN1_SEQUENCE(p_head);
  944.         return FUNC_ERR;
  945. }
  947.         p_cur->next = p_tail;
  948.         p_cur = p_tail;
  949. }
  951. j = 0;
  952. for(i=0;i<MAX_RSA_MODULUS_LEN;i++){
  953. if(rsaPrivateKey->N[i] == 0){
  954. j++;
  955. }
  956. else{
  957. break;
  958. }
  959. }
  961. t_buf.length = MAX_RSA_MODULUS_LEN - j;
  962. t_buf.data = &rsaPrivateKey->N[j];
  964. if(t_buf.length == 0){
  965.         buf[0] = 0;
  966.     t_buf.length = 1;
  967.     t_buf.data = buf;
  968.     }
  970.     rtn_code = ASN1_Encode_Integer(
  971.                    t_buf,
  972.        &p_cur->data);
  973.     if(rtn_code != FUNC_OK){
  974.         free_ASN1_SEQUENCE(p_head);
  975. return FUNC_ERR;
  976. }
  977.  
  978.  
  979. if(flag == 0){
  980. flag = 1;
  981.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  982.         if(rtn_code != FUNC_OK){
  983.         return FUNC_ERR;
  984. }
  986.         p_head = p_tail;
  987.         p_cur = p_tail;
  988. }
  989. else{
  990.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  991.         if(rtn_code != FUNC_OK){
  992.             free_ASN1_SEQUENCE(p_head);
  993.         return FUNC_ERR;
  994. }
  996.         p_cur->next = p_tail;
  997.         p_cur = p_tail;
  998. }
  1000. j = 0;
  1001. for(i=0;i<MAX_RSA_MODULUS_LEN;i++){
  1002. if(rsaPrivateKey->P[i] == 0){
  1003. j++;
  1004. }
  1005. else{
  1006. break;
  1007. }
  1008. }
  1010. t_buf.length = MAX_RSA_MODULUS_LEN - j;
  1011. t_buf.data = &rsaPrivateKey->P[j];
  1013. if(t_buf.length == 0){
  1014.         buf[0] = 0;
  1015.     t_buf.length = 1;
  1016.     t_buf.data = buf;
  1017.     }
  1019.     rtn_code = ASN1_Encode_Integer(
  1020.                    t_buf,
  1021.        &p_cur->data);
  1022.     if(rtn_code != FUNC_OK){
  1023.         free_ASN1_SEQUENCE(p_head);
  1024. return FUNC_ERR;
  1025. }
  1027.  
  1028. if(flag == 0){
  1029. flag = 1;
  1030.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  1031.         if(rtn_code != FUNC_OK){
  1032.         return FUNC_ERR;
  1033. }
  1035.         p_head = p_tail;
  1036.         p_cur = p_tail;
  1037. }
  1038. else{
  1039.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  1040.         if(rtn_code != FUNC_OK){
  1041.             free_ASN1_SEQUENCE(p_head);
  1042.         return FUNC_ERR;
  1043. }
  1045.         p_cur->next = p_tail;
  1046.         p_cur = p_tail;
  1047. }
  1049. j = 0;
  1050. for(i=0;i<MAX_RSA_MODULUS_LEN;i++){
  1051. if(rsaPrivateKey->Q[i] == 0){
  1052. j++;
  1053. }
  1054. else{
  1055. break;
  1056. }
  1057. }
  1059. t_buf.length = MAX_RSA_MODULUS_LEN - j;
  1060. t_buf.data = &rsaPrivateKey->Q[j];
  1062. if(t_buf.length == 0){
  1063.         buf[0] = 0;
  1064.     t_buf.length = 1;
  1065.     t_buf.data = buf;
  1066.     }
  1068.     rtn_code = ASN1_Encode_Integer(
  1069.                    t_buf,
  1070.        &p_cur->data);
  1071.     if(rtn_code != FUNC_OK){
  1072.         free_ASN1_SEQUENCE(p_head);
  1073. return FUNC_ERR;
  1074. }
  1076.  
  1077. if(flag == 0){
  1078. flag = 1;
  1079.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  1080.         if(rtn_code != FUNC_OK){
  1081.         return FUNC_ERR;
  1082. }
  1084.         p_head = p_tail;
  1085.         p_cur = p_tail;
  1086. }
  1087. else{
  1088.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  1089.         if(rtn_code != FUNC_OK){
  1090.             free_ASN1_SEQUENCE(p_head);
  1091.         return FUNC_ERR;
  1092. }
  1094.         p_cur->next = p_tail;
  1095.         p_cur = p_tail;
  1096. }
  1098. j = 0;
  1099. for(i=0;i<MAX_RSA_MODULUS_LEN;i++){
  1100. if(rsaPrivateKey->d1[i] == 0){
  1101. j++;
  1102. }
  1103. else{
  1104. break;
  1105. }
  1106. }
  1108. t_buf.length = MAX_RSA_MODULUS_LEN - j;
  1109. t_buf.data = &rsaPrivateKey->d1[j];
  1111. if(t_buf.length == 0){
  1112.         buf[0] = 0;
  1113.     t_buf.length = 1;
  1114.     t_buf.data = buf;
  1115.     }
  1117.     rtn_code = ASN1_Encode_Integer(
  1118.                    t_buf,
  1119.        &p_cur->data);
  1120.     if(rtn_code != FUNC_OK){
  1121.         free_ASN1_SEQUENCE(p_head);
  1122. return FUNC_ERR;
  1123. }
  1125.  
  1126. if(flag == 0){
  1127. flag = 1;
  1128.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  1129.         if(rtn_code != FUNC_OK){
  1130.         return FUNC_ERR;
  1131. }
  1133.         p_head = p_tail;
  1134.         p_cur = p_tail;
  1135. }
  1136. else{
  1137.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  1138.         if(rtn_code != FUNC_OK){
  1139.             free_ASN1_SEQUENCE(p_head);
  1140.         return FUNC_ERR;
  1141. }
  1143.         p_cur->next = p_tail;
  1144.         p_cur = p_tail;
  1145. }
  1147. j = 0;
  1148. for(i=0;i<MAX_RSA_MODULUS_LEN;i++){
  1149. if(rsaPrivateKey->d2[i] == 0){
  1150. j++;
  1151. }
  1152. else{
  1153. break;
  1154. }
  1155. }
  1157. t_buf.length = MAX_RSA_MODULUS_LEN - j;
  1158. t_buf.data = &rsaPrivateKey->d2[j];
  1160. if(t_buf.length == 0){
  1161.         buf[0] = 0;
  1162.     t_buf.length = 1;
  1163.     t_buf.data = buf;
  1164.     }
  1166.     rtn_code = ASN1_Encode_Integer(
  1167.                    t_buf,
  1168.        &p_cur->data);
  1169.     if(rtn_code != FUNC_OK){
  1170.         free_ASN1_SEQUENCE(p_head);
  1171. return FUNC_ERR;
  1172. }
  1174.  
  1175. if(flag == 0){
  1176. flag = 1;
  1177.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  1178.         if(rtn_code != FUNC_OK){
  1179.         return FUNC_ERR;
  1180. }
  1182.         p_head = p_tail;
  1183.         p_cur = p_tail;
  1184. }
  1185. else{
  1186.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  1187.         if(rtn_code != FUNC_OK){
  1188.             free_ASN1_SEQUENCE(p_head);
  1189.         return FUNC_ERR;
  1190. }
  1192.         p_cur->next = p_tail;
  1193.         p_cur = p_tail;
  1194. }
  1196. j = 0;
  1197. for(i=0;i<MAX_RSA_MODULUS_LEN;i++){
  1198. if(rsaPrivateKey->P_[i] == 0){
  1199. j++;
  1200. }
  1201. else{
  1202. break;
  1203. }
  1204. }
  1206. t_buf.length = MAX_RSA_MODULUS_LEN - j;
  1207. t_buf.data = &rsaPrivateKey->P_[j];
  1209. if(t_buf.length == 0){
  1210.         buf[0] = 0;
  1211.     t_buf.length = 1;
  1212.     t_buf.data = buf;
  1213.     }
  1215.     rtn_code = ASN1_Encode_Integer(
  1216.                    t_buf,
  1217.        &p_cur->data);
  1218.     if(rtn_code != FUNC_OK){
  1219.         free_ASN1_SEQUENCE(p_head);
  1220. return FUNC_ERR;
  1221. }
  1223.  
  1224. if(flag == 0){
  1225. flag = 1;
  1226.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  1227.         if(rtn_code != FUNC_OK){
  1228.         return FUNC_ERR;
  1229. }
  1231.         p_head = p_tail;
  1232.         p_cur = p_tail;
  1233. }
  1234. else{
  1235.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  1236.         if(rtn_code != FUNC_OK){
  1237.             free_ASN1_SEQUENCE(p_head);
  1238.         return FUNC_ERR;
  1239. }
  1241.         p_cur->next = p_tail;
  1242.         p_cur = p_tail;
  1243. }
  1245. j = 0;
  1246. for(i=0;i<MAX_RSA_MODULUS_LEN;i++){
  1247. if(rsaPrivateKey->Q_[i] == 0){
  1248. j++;
  1249. }
  1250. else{
  1251. break;
  1252. }
  1253. }
  1255. t_buf.length = MAX_RSA_MODULUS_LEN - j;
  1256. t_buf.data = &rsaPrivateKey->Q_[j];
  1258. if(t_buf.length == 0){
  1259.         buf[0] = 0;
  1260.     t_buf.length = 1;
  1261.     t_buf.data = buf;
  1262.     }
  1264.     rtn_code = ASN1_Encode_Integer(
  1265.                    t_buf,
  1266.        &p_cur->data);
  1267.     if(rtn_code != FUNC_OK){
  1268.         free_ASN1_SEQUENCE(p_head);
  1269. return FUNC_ERR;
  1270. }
  1273.  
  1274. if(flag == 0){
  1275. flag = 1;
  1276.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  1277.         if(rtn_code != FUNC_OK){
  1278.         return FUNC_ERR;
  1279. }
  1281.         p_head = p_tail;
  1282.         p_cur = p_tail;
  1283. }
  1284. else{
  1285.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  1286.         if(rtn_code != FUNC_OK){
  1287.             free_ASN1_SEQUENCE(p_head);
  1288.         return FUNC_ERR;
  1289. }
  1291.         p_cur->next = p_tail;
  1292.         p_cur = p_tail;
  1293. }
  1295. j = 0;
  1296. for(i=0;i<MAX_RSA_MODULUS_LEN;i++){
  1297. if(rsaPrivateKey->S[i] == 0){
  1298. j++;
  1299. }
  1300. else{
  1301. break;
  1302. }
  1303. }
  1305. t_buf.length = MAX_RSA_MODULUS_LEN - j;
  1306. t_buf.data = &rsaPrivateKey->S[j];
  1308. if(t_buf.length == 0){
  1309.         buf[0] = 0;
  1310.     t_buf.length = 1;
  1311.     t_buf.data = buf;
  1312.     }
  1314.     rtn_code = ASN1_Encode_Integer(
  1315.                    t_buf,
  1316.        &p_cur->data);
  1317.     if(rtn_code != FUNC_OK){
  1318.         free_ASN1_SEQUENCE(p_head);
  1319. return FUNC_ERR;
  1320. }
  1322.  
  1323. if(flag == 0){
  1324. flag = 1;
  1325.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  1326.         if(rtn_code != FUNC_OK){
  1327.         return FUNC_ERR;
  1328. }
  1330.         p_head = p_tail;
  1331.         p_cur = p_tail;
  1332. }
  1333. else{
  1334.         rtn_code = new_ASN1_SEQUENCE(&p_tail);
  1335.         if(rtn_code != FUNC_OK){
  1336.             free_ASN1_SEQUENCE(p_head);
  1337.         return FUNC_ERR;
  1338. }
  1340.         p_cur->next = p_tail;
  1341.         p_cur = p_tail;
  1342. }
  1344. j = 0;
  1345. for(i=0;i<MAX_RSA_MODULUS_LEN;i++){
  1346. if(rsaPrivateKey->T[i] == 0){
  1347. j++;
  1348. }
  1349. else{
  1350. break;
  1351. }
  1352. }
  1354. t_buf.length = MAX_RSA_MODULUS_LEN - j;
  1355. t_buf.data = &rsaPrivateKey->T[j];
  1357. if(t_buf.length == 0){
  1358.         buf[0] = 0;
  1359.     t_buf.length = 1;
  1360.     t_buf.data = buf;
  1361.     }
  1363.     rtn_code = ASN1_Encode_Integer(
  1364.                    t_buf,
  1365.        &p_cur->data);
  1366.     if(rtn_code != FUNC_OK){
  1367.         free_ASN1_SEQUENCE(p_head);
  1368. return FUNC_ERR;
  1369. }
  1370. */
  1371. /****************************************/
  1372.     /* encode the whole sequence */
  1373.     rtn_code = ASN1_Encode_Sequence(
  1374.                    p_head,
  1375.    &t_buf);
  1376.     if(rtn_code != FUNC_OK){
  1377.         free_ASN1_SEQUENCE(p_head);
  1378. return FUNC_ERR;
  1379. }
  1381.     *rsaPrivateKeyDERStringLen = t_buf.length;
  1382. memcpy(rsaPrivateKeyDERString,t_buf.data,*rsaPrivateKeyDERStringLen);
  1384. rtn_code = free_ASN1_SEQUENCE(p_head);
  1385.     if(rtn_code != FUNC_OK){
  1386.         free_DATA_BUFFER(&t_buf);
  1387. return FUNC_ERR;
  1388. }
  1390.     rtn_code = free_DATA_BUFFER(&t_buf);
  1391.     if(rtn_code != FUNC_OK){
  1392. return FUNC_ERR;
  1393. }
  1395. return FUNC_OK;
  1396. }
  1398. int d2c_RSA_PRIVATE_KEY(
  1399.         uint8  *rsaPrivateKeyDERString,
  1400.         uint32 rsaPrivateKeyDERStringLen,
  1401.         RSA_PRIVATE_KEY  *rsaPrivateKey)
  1402. {
  1403. /*
  1404. typedef struct rsa_pri_key{
  1405. uint16    bits;     
  1406. UCHAR     modulus[MAX_RSA_MODULUS_LEN]; 
  1407. UCHAR     publicExponent[MAX_RSA_MODULUS_LEN]; 
  1408. UCHAR     privateExponent[MAX_RSA_MODULUS_LEN];          
  1409. UCHAR     prime[2][MAX_RSA_PRIME_LEN];               
  1410. UCHAR     exponent[2][MAX_RSA_PRIME_LEN];               
  1411. UCHAR     coefficient [MAX_RSA_PRIME_LEN];               
  1412. UCHAR   N[MAX_RSA_MODULUS_LEN];
  1413. UCHAR   P[MAX_RSA_MODULUS_LEN];
  1414. UCHAR   Q[MAX_RSA_MODULUS_LEN];
  1415. UCHAR   d1[MAX_RSA_MODULUS_LEN];
  1416. UCHAR   d2[MAX_RSA_MODULUS_LEN];
  1417. UCHAR   P_[MAX_RSA_MODULUS_LEN];
  1418. UCHAR   Q_[MAX_RSA_MODULUS_LEN];
  1419. UCHAR   S[MAX_RSA_MODULUS_LEN];
  1420. UCHAR   T[MAX_RSA_MODULUS_LEN];
  1421. } RSA_PRIVATE_KEY;
  1422. */
  1423.   DATA_BUFFER t_buf;
  1424.   ASN1_SEQUENCE *p_head,*p_cur;
  1425. uint32 rtn_code;
  1426. uint32 i;
  1428. memset(rsaPrivateKey,0,sizeof(RSA_PRIVATE_KEY));
  1430. /* decode the sequence */
  1431.     t_buf.length = rsaPrivateKeyDERStringLen;
  1432. t_buf.data = rsaPrivateKeyDERString;
  1433.     rtn_code = ASN1_Decode_Sequence(
  1434.          t_buf,
  1435.        &p_head);
  1436. p_cur = p_head;
  1438.     /* decode the modulus */
  1439. p_cur = p_cur->next; /* igore the version */
  1440. if(p_cur == NULL){
  1441. return FUNC_ERR;
  1442. }
  1444.     rtn_code = ASN1_Decode_Integer(
  1445.            p_cur->data,
  1446.                    &t_buf);
  1447.     if(rtn_code != FUNC_OK){
  1448. free_ASN1_SEQUENCE(p_head);
  1449. return FUNC_ERR;
  1450. }
  1452.     i = MAX_RSA_MODULUS_LEN - t_buf.length;
  1453.     memcpy(&rsaPrivateKey->modulus[i],t_buf.data,t_buf.length);
  1455. ////////////////////////////  decode the bits  //////////////////
  1456. if(t_buf.length <= 64){
  1457. rsaPrivateKey->bits = 512;
  1458. }
  1459. else{
  1460.         if(t_buf.length <= 128){
  1461.     rsaPrivateKey->bits = 1024;
  1462. }
  1463. else{
  1464. if(t_buf.length <= 256){
  1465.         rsaPrivateKey->bits = 2048;
  1466. }
  1467. else{
  1468.         return FUNC_ERR;
  1469. }
  1470. }
  1471. }
  1472. ///////////////////////////////////////////////////////////////
  1474. rtn_code = free_DATA_BUFFER(&t_buf);
  1475.     if(rtn_code != FUNC_OK){
  1476. free_ASN1_SEQUENCE(p_head);
  1477. return FUNC_ERR;
  1478. }
  1480.     /* decode the publicExponent */
  1481. p_cur = p_cur->next;
  1482. if(p_cur == NULL){
  1483. free_ASN1_SEQUENCE(p_head);
  1484. return FUNC_ERR;
  1485. }
  1487.     rtn_code = ASN1_Decode_Integer(
  1488.            p_cur->data,
  1489.                    &t_buf);
  1490.     if(rtn_code != FUNC_OK){
  1491. free_ASN1_SEQUENCE(p_head);
  1492. return FUNC_ERR;
  1493. }
  1495.     i = MAX_RSA_MODULUS_LEN - t_buf.length;
  1496.     memcpy(&rsaPrivateKey->publicExponent[i],t_buf.data,t_buf.length);
  1498. rtn_code = free_DATA_BUFFER(&t_buf);
  1499.     if(rtn_code != FUNC_OK){
  1500. free_ASN1_SEQUENCE(p_head);
  1501. return FUNC_ERR;
  1502. }
  1504.     /* decode the privateExponent */
  1505. p_cur = p_cur->next;
  1506. if(p_cur == NULL){
  1507. free_ASN1_SEQUENCE(p_head);
  1508. return FUNC_ERR;
  1509. }
  1511.     rtn_code = ASN1_Decode_Integer(
  1512.            p_cur->data,
  1513.                    &t_buf);
  1514.     if(rtn_code != FUNC_OK){
  1515. free_ASN1_SEQUENCE(p_head);
  1516. return FUNC_ERR;
  1517. }
  1519.     i = MAX_RSA_MODULUS_LEN - t_buf.length;
  1520.     memcpy(&rsaPrivateKey->privateExponent[i],t_buf.data,t_buf.length);
  1522. rtn_code = free_DATA_BUFFER(&t_buf);
  1523.     if(rtn_code != FUNC_OK){
  1524. free_ASN1_SEQUENCE(p_head);
  1525. return FUNC_ERR;
  1526. }
  1528.     /* decode the prime[0] */
  1529. p_cur = p_cur->next;
  1530. if(p_cur == NULL){
  1531. free_ASN1_SEQUENCE(p_head);
  1532. return FUNC_ERR;
  1533. }
  1535.     rtn_code = ASN1_Decode_Integer(
  1536.            p_cur->data,
  1537.                    &t_buf);
  1538.     if(rtn_code != FUNC_OK){
  1539. free_ASN1_SEQUENCE(p_head);
  1540. return FUNC_ERR;
  1541. }
  1543.     i = MAX_RSA_PRIME_LEN - t_buf.length;
  1544.     memcpy(&rsaPrivateKey->prime[0][i],t_buf.data,t_buf.length);
  1546. rtn_code = free_DATA_BUFFER(&t_buf);
  1547.     if(rtn_code != FUNC_OK){
  1548. free_ASN1_SEQUENCE(p_head);
  1549. return FUNC_ERR;
  1550. }
  1552.     /* decode the prime[1] */
  1553. p_cur = p_cur->next;
  1554. if(p_cur == NULL){
  1555. free_ASN1_SEQUENCE(p_head);
  1556. return FUNC_ERR;
  1557. }
  1559.     rtn_code = ASN1_Decode_Integer(
  1560.            p_cur->data,
  1561.                    &t_buf);
  1562.     if(rtn_code != FUNC_OK){
  1563. free_ASN1_SEQUENCE(p_head);
  1564. return FUNC_ERR;
  1565. }
  1567.     i = MAX_RSA_PRIME_LEN - t_buf.length;
  1568.     memcpy(&rsaPrivateKey->prime[1][i],t_buf.data,t_buf.length);
  1570. rtn_code = free_DATA_BUFFER(&t_buf);
  1571.     if(rtn_code != FUNC_OK){
  1572. free_ASN1_SEQUENCE(p_head);
  1573. return FUNC_ERR;
  1574. }
  1576.     /* decode the exponent[0] */
  1577. p_cur = p_cur->next;
  1578. if(p_cur == NULL){
  1579. free_ASN1_SEQUENCE(p_head);
  1580. return FUNC_ERR;
  1581. }
  1583.     rtn_code = ASN1_Decode_Integer(
  1584.            p_cur->data,
  1585.                    &t_buf);
  1586.     if(rtn_code != FUNC_OK){
  1587. free_ASN1_SEQUENCE(p_head);
  1588. return FUNC_ERR;
  1589. }
  1591.     i = MAX_RSA_PRIME_LEN - t_buf.length;
  1592.     memcpy(&rsaPrivateKey->exponent[0][i],t_buf.data,t_buf.length);
  1594. rtn_code = free_DATA_BUFFER(&t_buf);
  1595.     if(rtn_code != FUNC_OK){
  1596. free_ASN1_SEQUENCE(p_head);
  1597. return FUNC_ERR;
  1598. }
  1600.     /* decode the exponent[1] */
  1601. p_cur = p_cur->next;
  1602. if(p_cur == NULL){
  1603. free_ASN1_SEQUENCE(p_head);
  1604. return FUNC_ERR;
  1605. }
  1607.     rtn_code = ASN1_Decode_Integer(
  1608.            p_cur->data,
  1609.                    &t_buf);
  1610.     if(rtn_code != FUNC_OK){
  1611. free_ASN1_SEQUENCE(p_head);
  1612. return FUNC_ERR;
  1613. }
  1615.     i = MAX_RSA_PRIME_LEN - t_buf.length;
  1616.     memcpy(&rsaPrivateKey->exponent[1][i],t_buf.data,t_buf.length);
  1618. rtn_code = free_DATA_BUFFER(&t_buf);
  1619.     if(rtn_code != FUNC_OK){
  1620. free_ASN1_SEQUENCE(p_head);
  1621. return FUNC_ERR;
  1622. }
  1624.     /* decode the coefficient */
  1625. p_cur = p_cur->next;
  1626. if(p_cur == NULL){
  1627. free_ASN1_SEQUENCE(p_head);
  1628. return FUNC_ERR;
  1629. }
  1631.     rtn_code = ASN1_Decode_Integer(
  1632.            p_cur->data,
  1633.                    &t_buf);
  1634.     if(rtn_code != FUNC_OK){
  1635. free_ASN1_SEQUENCE(p_head);
  1636. return FUNC_ERR;
  1637. }
  1639.     i = MAX_RSA_PRIME_LEN - t_buf.length;
  1640.     memcpy(&rsaPrivateKey->coefficient[i],t_buf.data,t_buf.length);
  1642. rtn_code = free_DATA_BUFFER(&t_buf);
  1643.     if(rtn_code != FUNC_OK){
  1644. free_ASN1_SEQUENCE(p_head);
  1645. return FUNC_ERR;
  1646. }
  1647. /***************************************/
  1648. /*     
  1649. p_cur = p_cur->next;
  1650. if(p_cur == NULL){
  1651. free_ASN1_SEQUENCE(p_head);
  1652. return FUNC_ERR;
  1653. }
  1655.     rtn_code = ASN1_Decode_Integer(
  1656.            p_cur->data,
  1657.                    &t_buf);
  1658.     if(rtn_code != FUNC_OK){
  1659. free_ASN1_SEQUENCE(p_head);
  1660. return FUNC_ERR;
  1661. }
  1663.     if(t_buf.length <= 64){
  1664. rsaPrivateKey->bits = 512;
  1665. }
  1666. else{
  1667.         if(t_buf.length <= 128){
  1668.     rsaPrivateKey->bits = 1024;
  1669. }
  1670. else{
  1671. if(t_buf.length <= 256){
  1672.         rsaPrivateKey->bits = 2048;
  1673. }
  1674. else{
  1675.         return FUNC_ERR;
  1676. }
  1677. }
  1678. }
  1680.     i = MAX_RSA_MODULUS_LEN - t_buf.length;
  1681.     memcpy(&rsaPrivateKey->N[i],t_buf.data,t_buf.length);
  1683. rtn_code = free_DATA_BUFFER(&t_buf);
  1684.     if(rtn_code != FUNC_OK){
  1685. free_ASN1_SEQUENCE(p_head);
  1686. return FUNC_ERR;
  1687. }
  1688.  
  1689.     
  1690. p_cur = p_cur->next;
  1691. if(p_cur == NULL){
  1692. free_ASN1_SEQUENCE(p_head);
  1693. return FUNC_ERR;
  1694. }
  1696.     rtn_code = ASN1_Decode_Integer(
  1697.            p_cur->data,
  1698.                    &t_buf);
  1699.     if(rtn_code != FUNC_OK){
  1700. free_ASN1_SEQUENCE(p_head);
  1701. return FUNC_ERR;
  1702. }
  1704.     i = MAX_RSA_MODULUS_LEN - t_buf.length;
  1705.     memcpy(&rsaPrivateKey->P[i],t_buf.data,t_buf.length);
  1707. rtn_code = free_DATA_BUFFER(&t_buf);
  1708.     if(rtn_code != FUNC_OK){
  1709. free_ASN1_SEQUENCE(p_head);
  1710. return FUNC_ERR;
  1711. }
  1713.    
  1714. p_cur = p_cur->next;
  1715. if(p_cur == NULL){
  1716. free_ASN1_SEQUENCE(p_head);
  1717. return FUNC_ERR;
  1718. }
  1720.     rtn_code = ASN1_Decode_Integer(
  1721.            p_cur->data,
  1722.                    &t_buf);
  1723.     if(rtn_code != FUNC_OK){
  1724. free_ASN1_SEQUENCE(p_head);
  1725. return FUNC_ERR;
  1726. }
  1728.     i = MAX_RSA_MODULUS_LEN - t_buf.length;
  1729.     memcpy(&rsaPrivateKey->Q[i],t_buf.data,t_buf.length);
  1731. rtn_code = free_DATA_BUFFER(&t_buf);
  1732.     if(rtn_code != FUNC_OK){
  1733. free_ASN1_SEQUENCE(p_head);
  1734. return FUNC_ERR;
  1735. }
  1737.     
  1738. p_cur = p_cur->next;
  1739. if(p_cur == NULL){
  1740. free_ASN1_SEQUENCE(p_head);
  1741. return FUNC_ERR;
  1742. }
  1744.     rtn_code = ASN1_Decode_Integer(
  1745.            p_cur->data,
  1746.                    &t_buf);
  1747.     if(rtn_code != FUNC_OK){
  1748. free_ASN1_SEQUENCE(p_head);
  1749. return FUNC_ERR;
  1750. }
  1752.     i = MAX_RSA_MODULUS_LEN - t_buf.length;
  1753.     memcpy(&rsaPrivateKey->d1[i],t_buf.data,t_buf.length);
  1755. rtn_code = free_DATA_BUFFER(&t_buf);
  1756.     if(rtn_code != FUNC_OK){
  1757. free_ASN1_SEQUENCE(p_head);
  1758. return FUNC_ERR;
  1759. }
  1761.   
  1762. p_cur = p_cur->next;
  1763. if(p_cur == NULL){
  1764. free_ASN1_SEQUENCE(p_head);
  1765. return FUNC_ERR;
  1766. }
  1768.     rtn_code = ASN1_Decode_Integer(
  1769.            p_cur->data,
  1770.                    &t_buf);
  1771.     if(rtn_code != FUNC_OK){
  1772. free_ASN1_SEQUENCE(p_head);
  1773. return FUNC_ERR;
  1774. }
  1776.     i = MAX_RSA_MODULUS_LEN - t_buf.length;
  1777.     memcpy(&rsaPrivateKey->d2[i],t_buf.data,t_buf.length);
  1779. rtn_code = free_DATA_BUFFER(&t_buf);
  1780.     if(rtn_code != FUNC_OK){
  1781. free_ASN1_SEQUENCE(p_head);
  1782. return FUNC_ERR;
  1783. }
  1785.   
  1786. p_cur = p_cur->next;
  1787. if(p_cur == NULL){
  1788. free_ASN1_SEQUENCE(p_head);
  1789. return FUNC_ERR;
  1790. }
  1792.     rtn_code = ASN1_Decode_Integer(
  1793.            p_cur->data,
  1794.                    &t_buf);
  1795.     if(rtn_code != FUNC_OK){
  1796. free_ASN1_SEQUENCE(p_head);
  1797. return FUNC_ERR;
  1798. }
  1800.     i = MAX_RSA_MODULUS_LEN - t_buf.length;
  1801.     memcpy(&rsaPrivateKey->P_[i],t_buf.data,t_buf.length);
  1803. rtn_code = free_DATA_BUFFER(&t_buf);
  1804.     if(rtn_code != FUNC_OK){
  1805. free_ASN1_SEQUENCE(p_head);
  1806. return FUNC_ERR;
  1807. }
  1809.    
  1810. p_cur = p_cur->next;
  1811. if(p_cur == NULL){
  1812. free_ASN1_SEQUENCE(p_head);
  1813. return FUNC_ERR;
  1814. }
  1816.     rtn_code = ASN1_Decode_Integer(
  1817.            p_cur->data,
  1818.                    &t_buf);
  1819.     if(rtn_code != FUNC_OK){
  1820. free_ASN1_SEQUENCE(p_head);
  1821. return FUNC_ERR;
  1822. }
  1824.     i = MAX_RSA_MODULUS_LEN - t_buf.length;
  1825.     memcpy(&rsaPrivateKey->Q_[i],t_buf.data,t_buf.length);
  1827. rtn_code = free_DATA_BUFFER(&t_buf);
  1828.     if(rtn_code != FUNC_OK){
  1829. free_ASN1_SEQUENCE(p_head);
  1830. return FUNC_ERR;
  1831. }
  1833.    
  1834. p_cur = p_cur->next;
  1835. if(p_cur == NULL){
  1836. free_ASN1_SEQUENCE(p_head);
  1837. return FUNC_ERR;
  1838. }
  1840.     rtn_code = ASN1_Decode_Integer(
  1841.            p_cur->data,
  1842.                    &t_buf);
  1843.     if(rtn_code != FUNC_OK){
  1844. free_ASN1_SEQUENCE(p_head);
  1845. return FUNC_ERR;
  1846. }
  1848.     i = MAX_RSA_MODULUS_LEN - t_buf.length;
  1849.     memcpy(&rsaPrivateKey->S[i],t_buf.data,t_buf.length);
  1851. rtn_code = free_DATA_BUFFER(&t_buf);
  1852.     if(rtn_code != FUNC_OK){
  1853. free_ASN1_SEQUENCE(p_head);
  1854. return FUNC_ERR;
  1855. }
  1857.    
  1858. p_cur = p_cur->next;
  1859. if(p_cur == NULL){
  1860. free_ASN1_SEQUENCE(p_head);
  1861. return FUNC_ERR;
  1862. }
  1864.     rtn_code = ASN1_Decode_Integer(
  1865.            p_cur->data,
  1866.                    &t_buf);
  1867.     if(rtn_code != FUNC_OK){
  1868. free_ASN1_SEQUENCE(p_head);
  1869. return FUNC_ERR;
  1870. }
  1872.     i = MAX_RSA_MODULUS_LEN - t_buf.length;
  1873.     memcpy(&rsaPrivateKey->T[i],t_buf.data,t_buf.length);
  1875. rtn_code = free_DATA_BUFFER(&t_buf);
  1876.     if(rtn_code != FUNC_OK){
  1877. free_ASN1_SEQUENCE(p_head);
  1878. return FUNC_ERR;
  1879. }
  1880. */
  1881. /******************************************/
  1882. rtn_code = free_ASN1_SEQUENCE(p_head);
  1883.     if(rtn_code != FUNC_OK){
  1884. return FUNC_ERR;
  1885. }
  1887. return FUNC_OK;
  1888. }
  1890.   
  1891. CRET Crypt_GenRSAKeyPair(
  1892.         char          *keyName,
  1893.         char          *password,
  1894. unsigned char *DerPubkey,
  1895. int   *DerPubkeyLen,
  1896. unsigned char *DerPrikey,
  1897. int   *DerPrikeyLen)
  1898. {
  1899.     int rtn_code;
  1900.     int keyNumber;
  1901.     RSA_PUBLIC_KEY  cardRsaPublicKey;
  1902.     RSA_PRIVATE_KEY cardRsaPrivateKey;
  1903.  
  1904.     keyNumber = 0;
  1906. if(strcmp(keyName,"keypair.db1") == 0){
  1907.         keyNumber = 1;
  1908. }
  1910. if(strcmp(keyName,"keypair.db2") == 0){
  1911.         keyNumber = 2;
  1912. }
  1914. if(strcmp(keyName,"keypair.db3") == 0){
  1915.         keyNumber = 3;
  1916. }
  1918. if(strcmp(keyName,"keypair.db4") == 0){
  1919.         keyNumber = 4;
  1920. }
  1922. if(strcmp(keyName,"keypair.db5") == 0){
  1923.         keyNumber = 5;
  1924. }
  1925.      
  1926. //printf("key filename %snn", keyname);
  1927.     rtn_code = CSP_GenRSAKeyPair(
  1928.                    (USHORT)keyNumber,
  1929.                    &cardRsaPublicKey,
  1930.                    &cardRsaPrivateKey);
  1931.     if(rtn_code != 0){
  1932.         return FUNC_ERR;
  1933.     }
  1937.     rtn_code = c2d_RSA_PUBLIC_KEY(&cardRsaPublicKey,
  1938.                        DerPubkey,
  1939.            DerPubkeyLen);
  1940.     if(rtn_code != FUNC_OK){
  1941.         return FUNC_ERR;
  1942.     }
  1944. rtn_code = c2d_RSA_PRIVATE_KEY(
  1945.         &cardRsaPrivateKey,
  1946.         DerPrikey,
  1947.         DerPrikeyLen);
  1948.     if(rtn_code != FUNC_OK){
  1949.         return FUNC_ERR;
  1950.     }
  1952.     if(keyNumber == 0){
  1954. rtn_code = Crypt_SavePemKey2File(
  1955.         keyName,
  1956. password,
  1957. /*&cardRsaPublicKey,*/ DerPubkey,
  1958. /*sizeof(RSA_PUBLIC_KEY),*/ *DerPubkeyLen,
  1959. /*&cardRsaPrivateKey,*/ DerPrikey,
  1960. /*sizeof(RSA_PRIVATE_KEY));*/ *DerPrikeyLen);
  1961. if(rtn_code != 0)
  1962. return -1;
  1963. }
  1965. return FUNC_OK;
  1966. }
  1968. int Crypt_SavePemKey2File(
  1969.         char          *keyName,
  1970.         char          *password,
  1971. unsigned char *DerPubkey,
  1972. int   DerPubkeyLen,
  1973. unsigned char *DerPrikey,
  1974. int   DerPrikeyLen)
  1975. {
  1977. FILE    *f;
  1978. unsigned char pem_key[2048], hashPasswd[20], Enc_DerPubkey[2048];
  1979. int rtn_code, pem_keySize, hashPasswdSize, Enc_DerPubkeySize;
  1981.     f = fopen(keyName,"wb");
  1982.     if(f == NULL){
  1983.     return FUNC_ERR;
  1984.         }
  1986. rtn_code = Crypt_Gen_Hash(
  1987. UID_md5,
  1988. password,
  1989. strlen(password),
  1990. hashPasswd,
  1991. &hashPasswdSize);
  1992. if(rtn_code != 0)
  1993. return -1;
  1994. /*
  1995. rtn_code = iCrypt_Enc_Data_S(
  1996. DerPubkey,
  1997. DerPubkeyLen,
  1998. Enc_DerPubkey,
  1999. &Enc_DerPubkeySize,
  2000. hashPasswd);
  2001. if(rtn_code != 0)
  2002. return -1;
  2003. */     
  2004. rtn_code = DER2PEM_data_format(
  2005.                    DerPubkey,//Enc_DerPubkey, 
  2006.                    DerPubkeyLen,//Enc_DerPubkeySize,
  2007.                    pem_key,
  2008.                    &pem_keySize,
  2009.                    PublicKey_Begin_String, 
  2010.                    PublicKey_End_String);
  2011.     if(rtn_code != FUNC_OK){
  2012.         printf("DER2PEM_data_format error...n");
  2013.         return -1;
  2014.     }
  2015. fwrite(pem_key,1,pem_keySize,f);
  2017. rtn_code = iCrypt_Enc_Data_S(
  2018. DerPrikey,
  2019. DerPrikeyLen,
  2020. Enc_DerPubkey,
  2021. &Enc_DerPubkeySize,
  2022. hashPasswd);
  2023. if(rtn_code != 0)
  2024. return -1;
  2027. rtn_code = DER2PEM_data_format(
  2028.                    Enc_DerPubkey, 
  2029.                    Enc_DerPubkeySize,
  2030.                    pem_key,
  2031.                    &pem_keySize,
  2032.                    PrivateKey_Begin_String, 
  2033.                    PrivateKey_End_String);
  2034.     if(rtn_code != FUNC_OK){
  2035.         printf("DER2PEM_data_format error...n");
  2036.         return -1;
  2037.     }
  2038. fwrite(pem_key,1,pem_keySize,f);
  2040. fclose(f);
  2042. return 0;
  2043. }
  2046. CRET Crypt_ChgKeyPasswd(
  2047.         char          *keyName,
  2048. char          *OldPasswd,
  2049. char          *NewPasswd)
  2050. {
  2051. unsigned char DerPubKey[1024], DerPrikey[1024];
  2052. int rtn_code, DerPubKeyLen, DerPrikeyLen, keyNumber;
  2053. //    RSA_PUBLIC_KEY  cardRsaPublicKey;
  2054. //    RSA_PRIVATE_KEY cardRsaPrivateKey;
  2056.     keyNumber = 0;
  2058. if(strcmp(keyName,"keypair.db1") == 0){
  2059.         keyNumber = 1;
  2060. }
  2062. if(strcmp(keyName,"keypair.db2") == 0){
  2063.         keyNumber = 2;
  2064. }
  2066. if(strcmp(keyName,"keypair.db3") == 0){
  2067.         keyNumber = 3;
  2068. }
  2070. if(strcmp(keyName,"keypair.db4") == 0){
  2071.         keyNumber = 4;
  2072. }
  2074. if(strcmp(keyName,"keypair.db5") == 0){
  2075.         keyNumber = 5;
  2076. }
  2077.      
  2078.     if(keyNumber == 0){
  2080. rtn_code =  RestoreKeyFromFile(
  2081. keyName,
  2082. OldPasswd,
  2083. DerPubKey,//&cardRsaPublicKey,
  2084. &DerPubKeyLen,
  2085. DerPrikey,//&cardRsaPrivateKey,
  2086. &DerPrikeyLen);
  2087. if(rtn_code != 0)
  2088. return -1;
  2090. rtn_code = Crypt_SavePemKey2File(
  2091.         keyName,
  2092. NewPasswd,
  2093. DerPubKey,//&cardRsaPublicKey,
  2094. DerPubKeyLen,//sizeof(RSA_PUBLIC_KEY),
  2095. DerPrikey,//&cardRsaPrivateKey,
  2096. DerPrikeyLen);//sizeof(RSA_PRIVATE_KEY));
  2097. if(rtn_code != 0)
  2098. return -1;
  2099. }
  2101. return 0;
  2102. }
  2104. CRET Crypt_Decode_Pubkey_Info(
  2105. unsigned char *DerPublicKeyInfo,
  2106. int DerPublicKeyInfoSize,
  2107. int *bits,
  2108. unsigned char *modulus,
  2109. unsigned char   *publicExponent)
  2110. {
  2111. //    unsigned char subjectPublicKeyInfo[512];
  2112. //    int  subjectPublicKeyInfoSize;
  2113.     RSA_PUBLIC_KEY  rsaPublicKey;
  2115. int rtn_code;
  2117. /*
  2118. typedef struct rsa_pub_key{
  2119.     uint16       bits;    // length in bits of modulus 
  2120. UCHAR     modulus[MAX_RSA_MODULUS_LEN]; 
  2121.                    // modulus  ----- n 
  2122. UCHAR     publicExponent[MAX_RSA_MODULUS_LEN];  
  2123.                    // public exponent  -----  e  
  2124. } RSA_PUBLIC_KEY;
  2125. */
  2126.     
  2127. rtn_code = d2c_RSA_PUBLIC_KEY(
  2128.                    DerPublicKeyInfo,
  2129.                    DerPublicKeyInfoSize,
  2130.                    &rsaPublicKey);
  2131.     if(rtn_code != FUNC_OK){
  2132.         return FUNC_ERR;
  2133.     }
  2135. *bits = rsaPublicKey.bits;
  2136. memcpy(modulus, rsaPublicKey.modulus, sizeof(rsaPublicKey.modulus));
  2137. memcpy(publicExponent, rsaPublicKey.publicExponent, sizeof(rsaPublicKey.publicExponent));
  2139. return 0;
  2140. }
  2142. CRET Crypt_Decode_Prikey_Info(
  2143. unsigned char *DerPrivateKeyInfo,
  2144. int DerPrivateKeyInfoSize,
  2145. int *bits,
  2146. unsigned char *modulus,
  2147. unsigned char   *publicExponent,
  2148. unsigned char   *privateExponent,
  2149. unsigned char   *prime,
  2150. unsigned char   *exponent,
  2151. unsigned char   *coefficient)
  2152. {
  2153. // unsigned char DerPrikey[1024];
  2154. // int DerPrikeyLen;
  2155.     RSA_PRIVATE_KEY  cardRsaPrivateKey;
  2156. int rtn_code;
  2158. rtn_code = d2c_RSA_PRIVATE_KEY(
  2159. DerPrivateKeyInfo,
  2160. DerPrivateKeyInfoSize,
  2161. &cardRsaPrivateKey);
  2162. if(rtn_code != 0)
  2163. return -1;
  2165. *bits = cardRsaPrivateKey.bits;
  2166. memcpy(modulus, cardRsaPrivateKey.modulus, sizeof(cardRsaPrivateKey.modulus));
  2167. memcpy(publicExponent, cardRsaPrivateKey.publicExponent, sizeof(cardRsaPrivateKey.publicExponent));
  2168. memcpy(privateExponent, cardRsaPrivateKey.privateExponent, sizeof(cardRsaPrivateKey.privateExponent));
  2169. memcpy(prime, cardRsaPrivateKey.prime[2], sizeof(cardRsaPrivateKey.prime[2]));
  2170. memcpy(exponent, cardRsaPrivateKey.exponent[2], sizeof(cardRsaPrivateKey.exponent[2]));
  2171. memcpy(coefficient, cardRsaPrivateKey.coefficient, sizeof(cardRsaPrivateKey.coefficient));
  2173. return 0;
  2174. }
  2177. CRET Crypt_RestorePublicKey(
  2178.         char          *keyName,
  2179. char          *password,
  2180. unsigned char *DerPubkey,
  2181. int   *DerPubkeyLen)
  2182. {
  2183. //int rtn_code;
  2184. unsigned char DerPriKey[1024];
  2185. int DerPriKeyLen;
  2187. return RestoreKeyFromFile(
  2188. keyName,
  2189. password,
  2190. DerPubkey,
  2191. DerPubkeyLen,
  2192. DerPriKey,
  2193. &DerPriKeyLen);
  2194. }
  2196. CRET Crypt_RestorePriKey(
  2197.         char          *keyName,
  2198. char          *password,
  2199. unsigned char *DerPrikey,
  2200. int   *DerPrikeyLen)
  2201. {
  2202. //int rtn_code;
  2203. unsigned char DerPubKey[1024];
  2204. int DerPubKeyLen;
  2206. return RestoreKeyFromFile(
  2207. keyName,
  2208. password,
  2209. DerPubKey,
  2210. &DerPubKeyLen,
  2211. DerPrikey,
  2212. DerPrikeyLen);
  2213. }
  2216. int RestoreKeyFromFile(
  2217.         char          *keyName,
  2218.         char          *password,
  2219. unsigned char *DerPubkey,
  2220. int   *DerPubkeyLen,
  2221. unsigned char *DerPrikey,
  2222. int   *DerPrikeyLen)
  2223. {
  2225. FILE    *f;
  2226. unsigned char pem_key[2048], hashPasswd[20], Dec_Derkey[1024], buffer[128];
  2227. int rtn_code,  hashPasswdSize, Dec_DerkeySize, ptr_offset;
  2229.     ptr_offset=0;
  2231. f = fopen(keyName,"r");
  2232.     if(f == NULL){
  2233. printf("open failed! keyname=%sn", keyName);
  2234.     return FUNC_ERR;
  2235.         }
  2237. do{
  2238. fgets(buffer, sizeof(buffer), f);
  2239. //printf("len=%d, buffer:%sn", strlen(buffer), buffer);
  2240.                 del_rn(buffer);
  2241. //printf("after del_rn, len=%d, buffer:%sn", strlen(buffer), buffer);
  2242. memcpy(pem_key+ptr_offset, buffer,strlen(buffer));
  2243. ptr_offset += strlen(buffer);
  2244. }
  2245. while(strcmp(buffer,PublicKey_End_String2));
  2247.     rtn_code = PEM2DER_data_format(
  2248.                        pem_key,
  2249.                        strlen(pem_key),
  2250.                        DerPubkey,//Dec_Derkey, 
  2251.                        DerPubkeyLen);//&Dec_DerkeySize);
  2252.     if(rtn_code != FUNC_OK){
  2253.         printf("PEM2DER_data_format error...n");
  2254. fclose(f);
  2255.         return -1;
  2256.     }
  2257. rtn_code = Crypt_Gen_Hash(
  2258. UID_md5,
  2259. password,
  2260. strlen(password),
  2261. hashPasswd,
  2262. &hashPasswdSize);
  2263. if(rtn_code != 0){
  2264. fclose(f);
  2265. return -1;
  2266. }
  2267. /*
  2268. rtn_code = iCrypt_Dec_Data_S(
  2269. Dec_Derkey,
  2270. Dec_DerkeySize,
  2271. DerPubkey,
  2272. DerPubkeyLen,
  2273. hashPasswd);
  2274. if(rtn_code != 0){
  2275. fclose(f);
  2276. return -1;
  2277. }
  2278. */
  2279. ptr_offset = 0;
  2280. do{
  2281. fgets(buffer, sizeof(buffer), f);
  2282. //printf("len=%d, buffer=%sn", strlen(buffer), buffer);
  2283.                 del_rn(buffer);
  2284. //printf("after del_rn:len=%d, buffer=%sn", strlen(buffer), buffer);
  2285. memcpy(pem_key+ptr_offset, buffer,strlen(buffer));
  2286. ptr_offset += strlen(buffer);
  2287. }
  2288. while(strcmp(buffer,PrivateKey_End_String2));
  2289. fclose(f);
  2291.     rtn_code = PEM2DER_data_format(
  2292.                        pem_key,
  2293.                        strlen(pem_key),
  2294.                        Dec_Derkey,
  2295.             &Dec_DerkeySize);
  2296.     if(rtn_code != FUNC_OK){
  2297.         printf("PEM2DER_data_format error...n");
  2298.         return -1;
  2299.     }
  2301. rtn_code = iCrypt_Dec_Data_S(
  2302. Dec_Derkey,
  2303. Dec_DerkeySize,
  2304. DerPrikey,
  2305. DerPrikeyLen,
  2306. hashPasswd);
  2307. if(rtn_code != 0)
  2308. return -1;
  2310. return 0;
  2311. }
  2313. CRET Crypt_GetRSAPublicKey(
  2314.         char           *keyName,
  2315. char *passwd,
  2316.         unsigned char  *rsaPublicKey,
  2317.         int            *rsaPublicKeySize)
  2318. {
  2319.     int rtn_code;
  2320.     int keyNumber;
  2321. //    RSA_PUBLIC_KEY  cardRsaPublicKey;
  2323.     keyNumber = 0;
  2325. if(strcmp(keyName,"keypair.db1") == 0){
  2326.         keyNumber = 1;
  2327. }
  2329. if(strcmp(keyName,"keypair.db2") == 0){
  2330.         keyNumber = 2;
  2331. }
  2333. if(strcmp(keyName,"keypair.db3") == 0){
  2334.         keyNumber = 3;
  2335. }
  2337. if(strcmp(keyName,"keypair.db4") == 0){
  2338.         keyNumber = 4;
  2339. }
  2341. if(strcmp(keyName,"keypair.db5") == 0){
  2342.         keyNumber = 5;
  2343. }
  2345.     if(keyNumber == 0){
  2346. rtn_code = Crypt_RestorePublicKey(
  2347. keyName,
  2348. passwd,
  2349. rsaPublicKey,//&cardRsaPublicKey,
  2350. rsaPublicKeySize);
  2351.       if(rtn_code != 0)
  2352.             return FUNC_ERR;
  2353.         
  2354.     }
  2355. /*
  2356.     d2c_RSA_PUBLIC_KEY(rsaPublicKey,*rsaPublicKeySize,
  2357.                        &cardRsaPublicKey);
  2359.     c2d_RSA_PUBLIC_KEY(&cardRsaPublicKey,
  2360.                        rsaPublicKey,
  2361.            rsaPublicKeySize);
  2363. */
  2364.     return FUNC_OK;
  2365. }
  2367. CRET CA_Crypt_Gen_Signature( 
  2368.         int    uid_algorithm,
  2369. char   *keyName,
  2370. char   *password,
  2371.         unsigned char  *msg,
  2372.         int            msgSize,
  2373.         unsigned char  *sig,
  2374. int            *sigSize)
  2375. {
  2376. return     Crypt_Gen_Signature( 
  2377.     uid_algorithm,
  2378.     keyName,
  2379. password,
  2380. msg,
  2381.                 msgSize,
  2382. sig,
  2383. sigSize);
  2384. }
  2386. int Crypt_Gen_Signature( 
  2387.         int    uid_algorithm,
  2388. char   *keyName,
  2389. char   *password,
  2390.         unsigned char  *msg,
  2391.         int            msgSize,
  2392.         unsigned char  *sig,
  2393. int            *sigSize)
  2394. {
  2395.     int rtn_code;
  2396.     int keyNumber;
  2397. uint32 hashSize;
  2398.     UCHAR hash[64],output[128]; 
  2399.     ULONG outputLen;
  2400. unsigned char DerPrikey[1024];
  2401. int DerPrikeyLen;
  2402. //    RSA_PUBLIC_KEY  cardRsaPublicKey;
  2403.     RSA_PRIVATE_KEY  cardRsaPrivateKey;
  2406.     keyNumber = 0;
  2408. if(strcmp(keyName,"keypair.db1") == 0){
  2409.         keyNumber = 1;
  2410. }
  2412. if(strcmp(keyName,"keypair.db2") == 0){
  2413.         keyNumber = 2;
  2414. }
  2416. if(strcmp(keyName,"keypair.db3") == 0){
  2417.         keyNumber = 3;
  2418. }
  2420. if(strcmp(keyName,"keypair.db4") == 0){
  2421.         keyNumber = 4;
  2422. }
  2424. if(strcmp(keyName,"keypair.db5") == 0){
  2425.         keyNumber = 5;
  2426. }
  2428.     if(keyNumber == 0){
  2429. rtn_code = Crypt_RestorePriKey(
  2430. keyName,
  2431. password,
  2432. DerPrikey,//&cardRsaPrivateKey,
  2433. &DerPrikeyLen);
  2434. if(rtn_code != 0)
  2435. return -1;
  2436. //*
  2437. rtn_code = d2c_RSA_PRIVATE_KEY(
  2438. DerPrikey,
  2439. DerPrikeyLen,
  2440. &cardRsaPrivateKey);
  2441. if(rtn_code != 0)
  2442. return -1;
  2443. //*/
  2444.   }
  2446. /////////////  it is tmp codes, maybe modify ....... ///////////////////////////
  2447. // cardRsaPrivateKey.bits = 1024;
  2448. ////////////////////////////////////////////////////////////////////////////////
  2450. rtn_code = Crypt_Gen_Encoded_Hash(
  2451.            uid_algorithm,
  2452.                    msg,
  2453.                    msgSize,
  2454.    hash,
  2455.    &hashSize);
  2456.     if(rtn_code != FUNC_OK){
  2457.         return FUNC_ERR;
  2458.     }
  2460.     rtn_code = CSP_RSAPrivateEncrypt(
  2461.                (USHORT)keyNumber,
  2462.                    output, 
  2463.                    &outputLen,
  2464.                    hash,
  2465.                    (ULONG)hashSize, 
  2466.                    &cardRsaPrivateKey);
  2467.     if(rtn_code != RTN_OK){
  2468.         return FUNC_ERR;
  2469.     }
  2470.  
  2471.     memcpy(sig,output,outputLen);
  2472. *sigSize = (uint32)outputLen;
  2474.     return FUNC_OK;
  2475. }
  2478. CRET Crypt_Ver_Signature(
  2479.         int            uid_algorithm,
  2480.         unsigned char  *rsaPublicKey,
  2481.         int            rsaPublicKeySize,
  2482.         unsigned char  *msg,
  2483.         int            msgSize,
  2484.         unsigned char  *sig,
  2485. int            sigSize)
  2486. {
  2487.     int rtn_code;
  2488. uint32 hashSize;
  2489.     UCHAR hash[64],output[128]; 
  2490.     ULONG  outputLen;
  2491.     USHORT keyNumber;
  2492.     RSA_PUBLIC_KEY cardRsaPublicKey;
  2495.     d2c_RSA_PUBLIC_KEY(rsaPublicKey,rsaPublicKeySize,
  2496.                        &cardRsaPublicKey);
  2498. rtn_code = Crypt_Gen_Encoded_Hash(
  2499.            uid_algorithm,
  2500.                    msg,
  2501.                    msgSize,
  2502.    hash,
  2503.    &hashSize);
  2504.     if(rtn_code != FUNC_OK){
  2505.         return FUNC_ERR;
  2506.     }
  2508.     keyNumber = 0;
  2509.     rtn_code = CSP_RSAPublicDecrypt(
  2510.            (USHORT)keyNumber,
  2511.                     output,
  2512.                     &outputLen,
  2513.                     sig,
  2514.                     (ULONG)sigSize,
  2515.                     &cardRsaPublicKey); 
  2516.      if(rtn_code != RTN_OK){
  2517.         return FUNC_ERR;
  2518.     }
  2521.     if(memcmp(hash,output,hashSize) != 0){
  2522.         return FUNC_ERR;
  2523.     }
  2525.     return FUNC_OK;
  2526. }
  2529. CRET 
  2530. Crypt_Get_PubKey_FromCert(
  2531.     unsigned char   *der_cert,
  2532.     int             der_certSize,
  2533.     unsigned char   *subjectPublicKeyInfo,
  2534.     int             *subjectPublicKeyInfoSize)
  2535. {                          
  2536. /*
  2537.     int version,serialNumberSize,signatureAlgorithm,parametersSize;
  2538.     unsigned char  serialNumber[256],parameters[64];
  2539.     char issuer_countryName[64],issuer_organizationName[64];
  2540.     char issuer_organizationalUnitname1[64],issuer_organizationalUnitname2[64];
  2541.     char issuer_organizationalUnitname3[64],issuer_stateOrProvinceName[64];
  2542.     char issuer_commonName[64],issuer_localityName[64];
  2543.     char issuer_title[64],issuer_surname[64];
  2544.     char issuer_givenName[64],issuer_initials[64];
  2545.     char issuer_email[64],issuer_postalAddress[64];
  2546.     char issuer_postalCode[64],issuer_postalOfficeBox[64];
  2547.     char issuer_telephoneNumber[64],issuer_telexNumber[64];
  2548.     char notBefore[64],notAfter[64];
  2549.     char subject_countryName[64],subject_organizationName[64];
  2550.     char subject_organizationalUnitname1[64],subject_organizationalUnitname2[64];
  2551.     char subject_organizationalUnitname3[64],subject_stateOrProvinceName[64];
  2552.     char subject_commonName[64],subject_localityName[64];
  2553.     char subject_title[64],subject_surname[64];
  2554.     char subject_givenName[64],subject_initials[64];
  2555.     char subject_email[64],subject_postalAddress[64];
  2556.     char subject_postalCode[64],subject_postalOfficeBox[64];
  2557.     char subject_telephoneNumber[64],subject_telexNumber[64];
  2558.  
  2559.     unsigned char issuerUniqueID[64];
  2560.     unsigned char subjectUniqueID[64];
  2561.     int  issuerUniqueIDSize,subjectUniqueIDSize;
  2562.     unsigned int   extensionsFlag,criticalFlag;
  2563.  
  2564.     char authKeyId_countryName[64],authKeyId_organizationName[64];
  2565.     char authKeyId_organizationalUnitname1[64],authKeyId_organizationalUnitname2[64];
  2566.     char authKeyId_organizationalUnitname3[64],authKeyId_stateOrProvinceName[64];
  2567.     char authKeyId_commonName[64],authKeyId_localityName[64],authKeyId_title[64];
  2568.     char authKeyId_surname[64],authKeyId_givenName[64];
  2569.     char authKeyId_initials[64],authKeyId_email[64];
  2570.     char authKeyId_postalAddress[64],authKeyId_postalCode[64];
  2571.     char authKeyId_postalOfficeBox[64],authKeyId_telephoneNumber[64];
  2572.     char authKeyId_telexNumber[64];
  2574.     unsigned char authKeyId_serialNumber[64];
  2575.     int authKeyId_serialNumberSize;
  2577.     unsigned char policyId1[64],policyId2[64],policyId3[64],policyId4[64];
  2578.     int policyIdSize1,policyIdSize2,policyIdSize3,policyIdSize4;
  2579.     char policyUrl1[64],policyUrl2[64],policyUrl3[64],policyUrl4[64];
  2580.     char PrivateKeyUsagePeriod_notBefore[64];
  2581.     char PrivateKeyUsagePeriod_notAfter[64];
  2582.     int  BasicConstraints_cA,BasicConstraints_pathLenConstraint;
  2583.    
  2584.     unsigned int   KeyUsage,neCertType,setCertType;
  2585.     int  self_certClass;
  2586.     char revocationURL[64];
  2588.     unsigned char  hashedRootKey[64];
  2589.     int            hashedRootKeySize;
  2590. */
  2592.     int version,serialNumberSize,signatureAlgorithm,parametersSize;
  2593.     unsigned char  serialNumber[256],parameters[64];
  2594.     char issuer_countryName[64],issuer_organizationName[64];
  2595.     char issuer_organizationalUnitname1[64];
  2596.     char issuer_stateOrProvinceName[64];
  2597.     char issuer_commonName[64],issuer_localityName[64];
  2598.     char issuer_title[64],issuer_surname[64];
  2599.     char issuer_givenName[64],issuer_initials[64];
  2600.     char issuer_email[64],issuer_postalAddress[64];
  2601.     char issuer_postalCode[64],issuer_postalOfficeBox[64];
  2602.     char issuer_telephoneNumber[64],issuer_telexNumber[64];
  2603.     char notBefore[64],notAfter[64];
  2604.     char subject_countryName[64],subject_organizationName[64];
  2605.     char subject_organizationalUnitname1[64];
  2606.     char subject_stateOrProvinceName[64];
  2607.     char subject_commonName[64],subject_localityName[64];
  2608.     char subject_title[64],subject_surname[64];
  2609.     char subject_givenName[64],subject_initials[64];
  2610.     char subject_email[64],subject_postalAddress[64];
  2611.     char subject_postalCode[64],subject_postalOfficeBox[64];
  2612.     char subject_telephoneNumber[64],subject_telexNumber[64];
  2613.  
  2614.     unsigned char issuerUniqueID[64];
  2615.     unsigned char subjectUniqueID[64];
  2616.     int  issuerUniqueIDSize,subjectUniqueIDSize;
  2617.     unsigned int   extensionsFlag,criticalFlag;
  2618.  
  2619.     char authKeyId_countryName[64],authKeyId_organizationName[64];
  2620.     char authKeyId_organizationalUnitname1[64];
  2621.     char authKeyId_stateOrProvinceName[64];
  2622.     char authKeyId_commonName[64],authKeyId_localityName[64],authKeyId_title[64];
  2623.     char authKeyId_surname[64],authKeyId_givenName[64];
  2624.     char authKeyId_initials[64],authKeyId_email[64];
  2625.     char authKeyId_postalAddress[64],authKeyId_postalCode[64];
  2626.     char authKeyId_postalOfficeBox[64],authKeyId_telephoneNumber[64];
  2627.     char authKeyId_telexNumber[64];
  2629.     unsigned char authKeyId_serialNumber[64];
  2630.     int authKeyId_serialNumberSize;
  2632.     unsigned char policyId1[64],policyId2[64],policyId3[64],policyId4[64];
  2633.     int policyIdSize1,policyIdSize2,policyIdSize3,policyIdSize4;
  2634.     char policyUrl1[64],policyUrl2[64],policyUrl3[64],policyUrl4[64];
  2635.     char PrivateKeyUsagePeriod_notBefore[64];
  2636.     char PrivateKeyUsagePeriod_notAfter[64];
  2637.     int  BasicConstraints_cA,BasicConstraints_pathLenConstraint;
  2638.    
  2639.     unsigned int   KeyUsage,neCertType,setCertType;
  2640.     int  self_certClass;
  2641.     char revocationURL[64];
  2643.     unsigned char  hashedRootKey[64];
  2644.     int            hashedRootKeySize;
  2646.     int  rtn_code;
  2648.  
  2649.     rtn_code = Crypt_Decode_Cert(
  2650.                    der_cert,
  2651.                    der_certSize,
  2653.                    &version,
  2654.                    serialNumber,
  2655.                    &serialNumberSize,
  2656.                    &signatureAlgorithm,
  2657.                    parameters,
  2658.                    &parametersSize,
  2659.                    issuer_countryName,
  2660.                    issuer_organizationName,
  2661.                    issuer_organizationalUnitname1,
  2662. //                   issuer_organizationalUnitname2,
  2663. //                   issuer_organizationalUnitname3,
  2664.                    issuer_stateOrProvinceName,
  2665.                    issuer_commonName,
  2666.                    issuer_localityName,
  2667.                    issuer_title,
  2668.                    issuer_surname,
  2669.                    issuer_givenName,
  2670.                    issuer_initials,
  2671.                    issuer_email,
  2672.                    issuer_postalAddress,
  2673.                    issuer_postalCode,
  2674.                    issuer_postalOfficeBox,
  2675.                    issuer_telephoneNumber,
  2676.                    issuer_telexNumber,
  2677.                    notBefore,   
  2678.                    notAfter,     
  2679.                    subject_countryName,
  2680.                    subject_organizationName,
  2681.                    subject_organizationalUnitname1,
  2682. //                   subject_organizationalUnitname2,
  2683. //                   subject_organizationalUnitname3,
  2684.                    subject_stateOrProvinceName,
  2685.                    subject_commonName,
  2686.                    subject_localityName,
  2687.                    subject_title,
  2688.                    subject_surname,
  2689.                    subject_givenName,
  2690.                    subject_initials,
  2691.                    subject_email,
  2692.                    subject_postalAddress,
  2693.                    subject_postalCode,
  2694.                    subject_postalOfficeBox,
  2695.                    subject_telephoneNumber,
  2696.                    subject_telexNumber,
  2697.                    subjectPublicKeyInfo,
  2698.                    subjectPublicKeyInfoSize,
  2699.                    issuerUniqueID, 
  2700.                    &issuerUniqueIDSize,
  2701.                    subjectUniqueID,
  2702.                    &subjectUniqueIDSize,
  2703.                    &extensionsFlag,
  2704.                    &criticalFlag,
  2705.                    authKeyId_countryName,
  2706.                    authKeyId_organizationName,
  2707.                    authKeyId_organizationalUnitname1,
  2708. //                   authKeyId_organizationalUnitname2,
  2709. //                   authKeyId_organizationalUnitname3,
  2710.                    authKeyId_stateOrProvinceName,
  2711.                    authKeyId_commonName,
  2712.                    authKeyId_localityName,
  2713.                    authKeyId_title,
  2714.                    authKeyId_surname,
  2715.                    authKeyId_givenName,
  2716.                    authKeyId_initials,
  2717.                    authKeyId_email,
  2718.                    authKeyId_postalAddress,
  2719.                    authKeyId_postalCode,
  2720.                    authKeyId_postalOfficeBox,
  2721.                    authKeyId_telephoneNumber,
  2722.                    authKeyId_telexNumber,
  2723.                    authKeyId_serialNumber,
  2724.                    &authKeyId_serialNumberSize,
  2725.                    policyId1,
  2726.                    &policyIdSize1,
  2727.                    policyUrl1,
  2728.                    policyId2,
  2729.                    &policyIdSize2,
  2730.                    policyUrl2,
  2731.                    policyId3,
  2732.                    &policyIdSize3,
  2733.                    policyUrl3,
  2734.                    policyId4,
  2735.                    &policyIdSize4,
  2736.                    policyUrl4,
  2737.                    PrivateKeyUsagePeriod_notBefore,   
  2738.                    PrivateKeyUsagePeriod_notAfter,     
  2739.                    &BasicConstraints_cA,
  2740.                    &BasicConstraints_pathLenConstraint,
  2741.                    &KeyUsage,
  2742.                    &neCertType,
  2743.                    &setCertType,
  2744.                    hashedRootKey,
  2745.                    &hashedRootKeySize,
  2747.                    &self_certClass,
  2748.                    revocationURL);
  2749.     if(rtn_code != FUNC_OK){
  2750.         return FUNC_ERR;
  2751.     }
  2753.     return FUNC_OK; 
  2754. }
  2756.  
  2757. CRET 
  2758. Crypt_Ver_Signature_ByCert(
  2759.     int             uid_algorithm,
  2760.     unsigned char   *der_cert,
  2761.     int             der_certSize,
  2762.     unsigned char   *msg,
  2763.     int             msgSize,
  2764.     unsigned char   *sig,
  2765.     int             sigSize)
  2766. {
  2767.     unsigned char subjectPublicKeyInfo[512];
  2768.     int  subjectPublicKeyInfoSize;
  2769.     int  rtn_code;
  2772.     rtn_code = Crypt_Get_PubKey_FromCert(
  2773.                     der_cert,
  2774.                     der_certSize,
  2775.                     subjectPublicKeyInfo,
  2776.                     &subjectPublicKeyInfoSize);
  2777.     if(rtn_code != FUNC_OK){
  2778.         return FUNC_ERR;
  2779.     }
  2781.     rtn_code = Crypt_Ver_Signature(
  2782.                    uid_algorithm,
  2783.                    subjectPublicKeyInfo,
  2784.                    subjectPublicKeyInfoSize,
  2785.                    msg,
  2786.                    msgSize,
  2787.                    sig,
  2788.            sigSize);
  2789.     if(rtn_code != FUNC_OK){
  2790.         return FUNC_ERR;
  2791.     }
  2793.     return FUNC_OK;
  2794. }
  2796. int iCrypt_Enc_Data_S(
  2797. unsigned char  *indata,
  2798.     int            indataSize,
  2799.     unsigned char  *outdata,
  2800.     int            *outdataSize,
  2801. unsigned char  *sdbiKey)
  2802. {
  2803.     int rtn_code = CSP_SDBIEncrypt(
  2804.                    outdata,
  2805.                    outdataSize,
  2806.                    indata,
  2807.                    (ULONG)indataSize,
  2808.                    sdbiKey,
  2809.                    16);
  2810.     if(rtn_code != RTN_OK){
  2811.         return FUNC_ERR;
  2812.     }
  2813. return FUNC_OK;
  2814. }
  2816. CRET Crypt_Enc_Data_S(
  2817. unsigned char  *indata,
  2818.     int            indataSize,
  2819.     unsigned char  *outdata,
  2820.     int            *outdataSize,
  2821. unsigned char  *sdbiKey)
  2822. {
  2824.     int rtn_code = CSP_SDBIEncrypt(
  2825.                    outdata,
  2826.                    outdataSize,
  2827.                    indata,
  2828.                    (ULONG)indataSize,
  2829.                    sdbiKey,
  2830.                    16);
  2831.     if(rtn_code != RTN_OK){
  2832.         return FUNC_ERR;
  2833.     }
  2834. return FUNC_OK;
  2835. }
  2837. CRET
  2838. Crypt_Enc_Data(
  2839.     unsigned char  *indata,
  2840.     int            indataSize,
  2841.     unsigned char  *outdata,
  2842.     int            *outdataSize,
  2843.     unsigned char  *der_cert,
  2844.     int            der_certSize)
  2845. {
  2846.     unsigned char subjectPublicKeyInfo[512];
  2847.     int  subjectPublicKeyInfoSize;
  2848.     RSA_PUBLIC_KEY  rsaPublicKey;
  2849.     UCHAR  SDBIKey[32],seedValue[32];
  2850.     UCHAR  enc_SDBIKey[256];
  2851.     ULONG  SDBIKeyLen,seedLen;
  2853.     int rtn_code;
  2856.     rtn_code = Crypt_Get_PubKey_FromCert(
  2857.                     der_cert,
  2858.                     der_certSize,
  2859.                     subjectPublicKeyInfo,
  2860.                     &subjectPublicKeyInfoSize);
  2861.     if(rtn_code != FUNC_OK){
  2862.         return FUNC_ERR;
  2863.     }
  2865.     seedLen = 16;
  2866.     rtn_code = CSP_GenRandomBytes(
  2867.                    SDBIKey,
  2868.                    16,
  2869.                    seedValue,
  2870.                    seedLen);
  2871.     if(rtn_code != RTN_OK){
  2872.         return FUNC_ERR;
  2873.     }
  2874.                
  2875.     rtn_code = d2c_RSA_PUBLIC_KEY(
  2876.                    subjectPublicKeyInfo,
  2877.                    subjectPublicKeyInfoSize,
  2878.                    &rsaPublicKey);
  2879.     if(rtn_code != FUNC_OK){
  2880.         return FUNC_ERR;
  2881.     }
  2883.     rtn_code = CSP_RSAPublicEncrypt(
  2884.            0, 
  2885.                    enc_SDBIKey,
  2886.                    &SDBIKeyLen,
  2887.                    SDBIKey,
  2888.                    16,
  2889.                    &rsaPublicKey);
  2890.     if(rtn_code != RTN_OK){
  2891.         return FUNC_ERR;
  2892.     }
  2894.     memcpy(outdata,enc_SDBIKey,SDBIKeyLen);
  2896.     rtn_code = CSP_SDBIEncrypt(
  2897.                    &outdata[SDBIKeyLen],
  2898.                    &seedLen,
  2899.                    indata,
  2900.                    (ULONG)indataSize,
  2901.                    SDBIKey,
  2902.                    16);
  2903.     if(rtn_code != RTN_OK){
  2904.         return FUNC_ERR;
  2905.     }
  2907.     *outdataSize = SDBIKeyLen + seedLen;
  2908.    
  2909.     return FUNC_OK;
  2910. }
  2912. int iCrypt_Dec_Data_S(
  2913.       unsigned char  *indata,
  2914.       int           indataSize,
  2915.       unsigned char  *outdata,
  2916.       int           *outdataSize,
  2917.       unsigned char  *sdbiKey)
  2918. {
  2919.     int rtn_code = CSP_SDBIDecrypt(
  2920.                    outdata,
  2921.                    outdataSize,
  2922.                    indata,
  2923.                    indataSize,
  2924.                    sdbiKey,
  2925.                    16);
  2926.     if(rtn_code != RTN_OK){
  2927.         return FUNC_ERR;
  2928.     }
  2930.     return FUNC_OK;
  2931. }
  2934. CRET  Crypt_Dec_Data_S(
  2935.       unsigned char  *indata,
  2936.       int           indataSize,
  2937.       unsigned char  *outdata,
  2938.       int           *outdataSize,
  2939.       unsigned char  *sdbiKey)
  2940. {
  2941.     int rtn_code = CSP_SDBIDecrypt(
  2942.                    outdata,
  2943.                    outdataSize,
  2944.                    indata,
  2945.                    indataSize,
  2946.                    sdbiKey,
  2947.                    16);
  2948.     if(rtn_code != RTN_OK){
  2949.         return FUNC_ERR;
  2950.     }
  2952.     return FUNC_OK;
  2953. }
  2955. CRET  Crypt_Dec_Data(
  2956.       unsigned char  *indata,
  2957.       int           indataSize,
  2958.       unsigned char  *outdata,
  2959.       int           *outdataSize,
  2960.       char          *keyName,
  2961.       char          *password)
  2962. {
  2963.     int rtn_code;
  2964.     int keyNumber;
  2965.     UCHAR SDBIKey[128]; 
  2966.     ULONG outputLen;
  2968. unsigned char DerPrikey[1024];
  2969. int DerPrikeyLen;
  2971. //    RSA_PUBLIC_KEY  cardRsaPublicKey;
  2972.     RSA_PRIVATE_KEY  cardRsaPrivateKey;
  2975.     keyNumber = 0;
  2977. if(strcmp(keyName,"keypair.db1") == 0){
  2978.         keyNumber = 1;
  2979. }
  2981. if(strcmp(keyName,"keypair.db2") == 0){
  2982.         keyNumber = 2;
  2983. }
  2985. if(strcmp(keyName,"keypair.db3") == 0){
  2986.         keyNumber = 3;
  2987. }
  2989. if(strcmp(keyName,"keypair.db4") == 0){
  2990.         keyNumber = 4;
  2991. }
  2993. if(strcmp(keyName,"keypair.db5") == 0){
  2994.         keyNumber = 5;
  2995. }
  2998.     if(keyNumber == 0){
  2999. rtn_code = Crypt_RestorePriKey(
  3000. keyName,
  3001. password,
  3002. DerPrikey,//&cardRsaPrivateKey,
  3003. &DerPrikeyLen);
  3004. if(rtn_code != 0)
  3005. return -1;
  3006. //*
  3007. rtn_code = d2c_RSA_PRIVATE_KEY(
  3008. DerPrikey,
  3009. DerPrikeyLen,
  3010. &cardRsaPrivateKey);
  3011. if(rtn_code != 0)
  3012. return -1;
  3013. //*/  
  3014. }
  3015. ///////////////////////// tmp codes, maybe modify....................
  3016. // cardRsaPrivateKey.bits = 1024;
  3017. /////////////////////////////////////////////////////////////////////
  3019.     rtn_code = CSP_RSAPrivateDecrypt(
  3020.            keyNumber,
  3021.                    SDBIKey,
  3022.                    &outputLen,
  3023.                    indata,
  3024.                    128,
  3025.                    &cardRsaPrivateKey);
  3026.     if(rtn_code != RTN_OK){
  3027.         return FUNC_ERR;
  3028.     }
  3029.     
  3030.     rtn_code = CSP_SDBIDecrypt(
  3031.                    outdata,
  3032.                    &outputLen,
  3033.                    &indata[128],
  3034.                    indataSize-128,
  3035.                    SDBIKey,
  3036.                    16);
  3037.     if(rtn_code != RTN_OK){
  3038.         return FUNC_ERR;
  3039.     }
  3041.     *outdataSize = outputLen;
  3043.     return FUNC_OK;
  3044. }
  3046. CRET Crypt_Rsa_PrivateKeyDec(
  3047. char *keyName,
  3048. char *password,
  3049. unsigned char *cipher,
  3050. int cipherLen,
  3051. unsigned char *msg,
  3052. int *msgLen)
  3053. {
  3054.     int rtn_code;
  3055.     int keyNumber;
  3056.  
  3057. unsigned char DerPrikey[1024];
  3058. int DerPrikeyLen;
  3060. //    RSA_PUBLIC_KEY  cardRsaPublicKey;
  3061.     RSA_PRIVATE_KEY  cardRsaPrivateKey;
  3063. rtn_code = Crypt_RestorePriKey(
  3064. keyName,
  3065. password,
  3066. DerPrikey,//&cardRsaPrivateKey,
  3067. &DerPrikeyLen);
  3068. if(rtn_code != 0)
  3069. return -1;
  3070. rtn_code = d2c_RSA_PRIVATE_KEY(
  3071. DerPrikey,
  3072. DerPrikeyLen,
  3073. &cardRsaPrivateKey);
  3074. if(rtn_code != 0)
  3075. return -1;
  3077.     /*
  3078. rtn_code = CSP_RSAPrivateDecrypt(
  3079.            0,
  3080.                    msg,
  3081.                    &msgLen,
  3082.                    cipher,
  3083.                    cipherLen,
  3084.                    &cardRsaPrivateKey);
  3085. */
  3086. rtn_code = RSAPrivateBlock (msg, msgLen, cipher, cipherLen, &cardRsaPrivateKey);
  3087.     if(rtn_code != 0){
  3088.         return FUNC_ERR;
  3089.     }
  3090.     
  3091.     return FUNC_OK;
  3093. }
  3095. CRET Crypt_Cert_PubKeyEnc (
  3096. char *der_cert,
  3097. int der_certSize,
  3098. unsigned char *msg,
  3099. int msgLen,
  3100. unsigned char *cipher,
  3101. int *cipherLen)
  3102. {
  3103.     unsigned char subjectPublicKeyInfo[512];
  3104.     int  subjectPublicKeyInfoSize;
  3105.     RSA_PUBLIC_KEY  rsaPublicKey;
  3107.     int rtn_code;
  3110.     rtn_code = Crypt_Get_PubKey_FromCert(
  3111.                     der_cert,
  3112.                     der_certSize,
  3113.                     subjectPublicKeyInfo,
  3114.                     &subjectPublicKeyInfoSize);
  3115.     if(rtn_code != FUNC_OK){
  3116.         return FUNC_ERR;
  3117.     }
  3119.     rtn_code = d2c_RSA_PUBLIC_KEY(
  3120.                    subjectPublicKeyInfo,
  3121.                    subjectPublicKeyInfoSize,
  3122.                    &rsaPublicKey);
  3123.     if(rtn_code != FUNC_OK){
  3124.         return FUNC_ERR;
  3125.     }
  3127. /*
  3128.     rtn_code = CSP_RSAPublicEncrypt(
  3129.            0, 
  3130.                    cipher,
  3131.                    &cipherLen,
  3132.                    msg,
  3133.                    msgLen,
  3134.                    &rsaPublicKey);
  3135. */
  3136.  rtn_code =  RSAPublicBlock (cipher, cipherLen, msg, msgLen, &rsaPublicKey);
  3137.     if(rtn_code != 0){
  3138.         return FUNC_ERR;
  3139.     }
  3141. return 0;
  3142. }
  3144. char *del_rn(char *pbuf)
  3145. {
  3146.   char *p;
  3148.   if((p =strchr(pbuf, 'r')) !=NULL) *p =0;
  3149.   if((p =strchr(pbuf, 'n')) !=NULL) *p =0;
  3151.   return pbuf;
  3152. }