在Windows平台下使用openssl调用CSP

本文介绍一种方法使得通过RSA_private_decrypt函数可以使用CSP中的私钥来进行解密和通过RSA_sign函数可以使用CSP中的私钥来进行签名。
     在openssl中RSA结构既可以表示公钥也可以表示私钥，它有一个类型为RSA_METHOD的域meth，该域包含一组实现RSA运算的函数指针。为了可以调用CSP，我们只需要实现一个特殊的RSA私钥，它包含有自己的RSA_METHOD结构。由于很多CSP中通常不都能获取明文的私钥，所以，我们实现的RSA私钥结构中只能包含有公钥信息，即n和e，然后根据公钥寻找到匹配的私钥句柄来进行相关的操作。具体来说，我们实现了一个函数：RSA *RSAToCAPIPrivKey(RSA *rsa)。该函数的参数是个RSA公钥，返回的是一个能够调用CSP私钥的RSA私钥。
     具体的实现如下：
1、从个人证书库中寻找存在私钥且和给定公钥相匹配的证书，如果不存在，则返回NULL
2、用RSA_new()创建一个新的RSA结构，把公钥的n和e复制过去
3、设置新的RSA结构的flags为RSA_FLAG_SIGN_VER,并为之设置一个可以调用CSP的RSA_METHOD结构
4、返回该RSA结构。
     实现的关键是RSA_METHOD结构。
     RSA_METHOD结构的定义如下：
struct rsa_meth_st
     {
     const char *name;
     int (*rsa_pub_enc)(int flen,const unsigned char *from,
                    unsigned char *to,
                    RSA *rsa,int padding);
     int (*rsa_pub_dec)(int flen,const unsigned char *from,
                    unsigned char *to,
                    RSA *rsa,int padding);
     int (*rsa_priv_enc)(int flen,const unsigned char *from,
                    unsigned char *to,
                    RSA *rsa,int padding);
     int (*rsa_priv_dec)(int flen,const unsigned char *from,
                    unsigned char *to,
                    RSA *rsa,int padding);
     int (*rsa_mod_exp)(BIGNUM *r0,const BIGNUM *I,RSA *rsa,BN_CTX *ctx);
     int (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
                  const BIGNUM *m, BN_CTX *ctx,BN_MONT_CTX *m_ctx);
     int (*init)(RSA *rsa);            
     int (*finish)(RSA *rsa);      
     int flags;                  
     char *app_data;            
     int (*rsa_sign)(int type,
           const unsigned char *m, unsigned int m_length,
           unsigned char *sigret, unsigned int *siglen, const RSA *rsa);
     int (*rsa_verify)(int dtype,
           const unsigned char *m, unsigned int m_length,
           unsigned char *sigbuf, unsigned int siglen, const RSA *rsa);
     int (*rsa_keygen)(RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb);
};
typedef struct rsa_meth_st RSA_METHOD;
     name--是RSA_METHOD的名称
     rsa_pub_enc--是RSA公钥加密的实现，RSA_public_encrypt就是由它实现的。我们不需要实现它。
     rsa_pub_dec--是RSA公钥解密的实现，RSA_public_decrypt就是由它实现的。我们也不需要实现它。如果RSA结构的flags域没有设置了RSA_FLAG_SIGN_VER或者没有实现rsa_verify，则RSA_verify也会使用它来验证签名。
     rsa_priv_enc--是RSA私钥加密的实现，RSA_private_encrypt就是由它实现的。我不知道怎么实现它。如果RSA结构的flags域没有设置了RSA_FLAG_SIGN_VER或者没有实现rsa_sign，则RSA_sign也会使用它来进行签名。
     rsa_priv_dec--是RSA私钥解密的实现，RSA_private_decrypt就是由它实现的。这是我们要实现的。
     rsa_mod_exp和bn_mod_exp是用来辅佐实现RSA算法的某些大整数运算的实现，具体我不清楚。我们也不需要实现它。
     init--初始化函数，RSA_new会调用它。我们也不需要实现它。
     finish--清理函数，RSA_free会调用它。我们也不需要实现它。
     flags--某些标志
     app_data--某些相关数据。我们也不需要它。
     rsa_sign--如果RSA结构的flags域设置了RSA_FLAG_SIGN_VER(也就是rsa->flags & RSA_FLAG_SIGN_VER为真)且rsa_sign不为NULL的时候，RSA_sign会使用它来进行签名。这是我们要实现的。
     rsa_verify--如果RSA结构的flags域设置了RSA_FLAG_SIGN_VER(也就是rsa->flags & RSA_FLAG_SIGN_VER为真)且rsa_verify不为NULL的时候，RSA_verify会使用它来验证签名。我们也不需要实现它。
     rsa_keygen--产生RSA密钥对的实现。如果不为NULL，RSA_generate_key_ex会使用它，否则使用内置的RSA密钥对的实现。我们也不需要实现它。
     
     rsa_priv_dec的实现如下：
1、从个人证书库中寻找存在私钥且和给定公钥相匹配的证书，并获取其CERT_KEY_PROV_INFO_PROP_ID属性的值
2、根据获取到的CSP信息，获得私钥句柄
3、把要解密的数据的格式从big-endian转换为little-endian。openssl使用big-endian格式，而CryptoAPI通常要求little-endian格式。
4、调用CryptDecrypt解密即可。

     rsa_sign的实现如下：
1、从个人证书库中寻找存在私钥且和给定公钥相匹配的证书，并获取其CERT_KEY_PROV_INFO_PROP_ID属性的值
2、根据获取到的CSP信息，获得容器句柄
3、使用容器句柄创建一个对应的hash对象，并设定hash值。
4、使用CryptSignHash签名
5、把签名得到的数据从little-endian转换为big-endian。
     
     该程序使用openssl-0.9.8在windows2000和XP下测试通过。
     存在的问题：
1、只能在windows2000、XP下使用，不能在98、Me中使用，原因是使用了CryptAcquireContextW函数。其实很容易把得到的CERT_KEY_PROV_INFO_PROP_ID属性的值的各宽字符串转换为多字节字符串，使用CryptAcquireContextA函数就可以在在98和Me使用了。
2、获取私钥句柄只是搜索个人证书库，可能会有些CSP的私钥无法使用。
3、没有使用openssl的错误报告函数给出详细的错误信息
4、解密的时候存在很多限制，这些限制和CryptDecrypt的一样。有些CSP根本不支持CryptDecrypt使用RSA解密，有的只有Algid为AT_KEYEXCHANGE才能进行解密。

 

OpenVPN已经实现了可以看它的这个函数SSL_CTX_use_CryptoAPI_certificate

1. #include "openssl/rsa.h"
2. #include "openssl/obj_mac.h"
3. #include <windows.h>
4. #include <string.h>
6. static int capi_rsa_priv_dec(int flen,const unsigned char *from,unsigned char *to,RSA *rsa,int padding);
7. static int capi_rsa_sign(int type,const unsigned char *m, unsigned int m_length,unsigned char *sigret, unsigned int *siglen, const RSA *rsa);
8. static RSA *CAPI_RSA_new();
9. static PCRYPT_KEY_PROV_INFO GetProvInfo(const RSA *rsa);
11. static RSA_METHOD capirsameth=
12. {
13.     "Windows Crypto API RSA Method", /* name */
14.     0,  /* rsa_pub_enc */
15.     0,  /* rsa_pub_dec */
16.     0, /* rsa_priv_enc */
17.     capi_rsa_priv_dec, /* rsa_priv_dec */
18.     0, /* rsa_mod_exp */
19.     0, /* bn_mod_exp */
20.     0, /* init */
21.     0, /* finish */
22.     RSA_FLAG_SIGN_VER, /* flags */
23.     0, /* app_data */
24.     capi_rsa_sign, /* rsa_sign */
25.     0, /* rsa_verify */
26.     0, /* rsa_keygen */
27. };
30. int capi_rsa_priv_dec(int flen,const unsigned char *from,unsigned char *to,RSA *rsa,int padding)
31. {
32.     int number;
33.     PCRYPT_KEY_PROV_INFO keyinfo;
34.     HCRYPTPROV hProv;
35.     BOOL b;
36.     DWORD dwKeySpec;
37.     HCRYPTKEY hUserKey;
38.     BYTE *data;
39.     DWORD datalen;
40.     int i;
41.     if(flen<0||from==0||to==0||rsa==0||rsa->n==0||rsa->e==0)
42.     {
43.         return -1;
44.     }
45.     
46.     number=RSA_size(rsa);
47.     if(flen!=number)
48.     {
49.         return -1;
50.     }
51.     
52.     switch(padding)
53.     {
54.     case RSA_PKCS1_PADDING:
55.         break;
56.     default:
57.         return -1;
58.     }
59.     keyinfo=GetProvInfo(rsa);
60.     if(keyinfo==0)
61.     {
62.         return -1;
63.     }
64.     
65.     b=CryptAcquireContextW(&hProv,keyinfo->pwszContainerName,keyinfo->pwszProvName,keyinfo->dwProvType,keyinfo->dwFlags);
66.     dwKeySpec=keyinfo->dwKeySpec;
67.     free(keyinfo);
68.     if(b==0)
69.     {
70.         return -1;
71.     }
72.     b=CryptGetUserKey(hProv,dwKeySpec,&hUserKey);
73.     if(b==0)
74.     {
75.         CryptReleaseContext(hProv,0);
76.         return -1;
77.     }
79.     datalen=flen;
80.     data=(BYTE *)malloc(datalen);
81.     if(data==0)
82.     {
83.         CryptDestroyKey(hUserKey);
84.         CryptReleaseContext(hProv,0);
85.         return -1;
86.     }
87.     for(i=0;i<flen;i++)
88.     {
89.         data[i]=from[flen-i-1];
90.     }
91.     b=CryptDecrypt(hUserKey,0,TRUE,0,data,&datalen);
92.     CryptDestroyKey(hUserKey);
93.     CryptReleaseContext(hProv,0);
94.     if(b==0)
95.     {
96.         free(data);
97.         return -1;
98.     }
99.     memcpy(to,data,datalen);
100.     memset(data,0,datalen);
101.     free(data);
102.     return (int)datalen;
103. }
105. int capi_rsa_sign(int type,const unsigned char *m, unsigned int m_length,unsigned char *sigret, unsigned int *siglen, const RSA *rsa)
106. {
107.     int number;
108.     PCRYPT_KEY_PROV_INFO keyinfo;
109.     HCRYPTPROV hProv;
110.     BOOL b;
111.     DWORD dwKeySpec;
112.     ALG_ID hashid;
113.     HCRYPTHASH hHash;
114.     unsigned int i;
115.     unsigned char temp;
117.     if(m_length<0||m==0||sigret==0||siglen==0||rsa==0||rsa->n==0||rsa->e==0)
118.     {
119.         return 0;
120.     }
121.     
122.     number=RSA_size(rsa);
123.     if((int)m_length>number)
124.     {
125.         return 0;
126.     }
127.     *siglen=number;
129.     switch(type)
130.     {
131.     case NID_md5_sha1:
132.         hashid=CALG_SSL3_SHAMD5;
133.         if(m_length!=36)
134.         {
135.             return 0;
136.         }
137.         break;
138.     case NID_md5:
139.         hashid=CALG_MD5;
140.         if(m_length!=16)
141.         {
142.             return 0;
143.         }
144.         break;
145.     case NID_md2:
146.         hashid=CALG_MD2;
147.         if(m_length!=16)
148.         {
149.             return 0;
150.         }
151.         break;
152.     case NID_sha1:
153.         hashid=CALG_SHA1;
154.         if(m_length!=20)
155.         {
156.             return 0;
157.         }
158.         break;
159.     default :
160.         return 0;
161.     }
163.     keyinfo=GetProvInfo(rsa);
164.     if(keyinfo==0)
165.     {
166.         return 0;
167.     }
168.     
169.     b=CryptAcquireContextW(&hProv,keyinfo->pwszContainerName,keyinfo->pwszProvName,keyinfo->dwProvType,keyinfo->dwFlags);
170.     dwKeySpec=keyinfo->dwKeySpec;
171.     free(keyinfo);
172.     if(b==0)
173.     {
174.         return 0;
175.     }
176.     b=CryptCreateHash(hProv,hashid,0,0,&hHash);
177.     if(b==0)
178.     {
179.         CryptReleaseContext(hProv,0);
180.         return 0;
181.     }
182.     b=CryptSetHashParam(hHash,HP_HASHVAL,m,0);
183.     if(b==0)
184.     {
185.         CryptDestroyHash(hHash);
186.         CryptReleaseContext(hProv,0);
187.         return 0;
188.     }
190.     b=CryptSignHash(hHash,dwKeySpec,0,0,sigret,(DWORD *)siglen);
191.     CryptDestroyHash(hHash);
192.     CryptReleaseContext(hProv,0);
193.     if(b==0)
194.     {
195.         return 0;
196.     }
197.     for(i=0;i<(*siglen)/2;i++)
198.     {
199.         temp=sigret[i];
200.         sigret[i]=sigret[*siglen-i-1];
201.         sigret[*siglen-i-1]=temp;
202.     }
203.     return 1;
204. }
206. RSA *CAPI_RSA_new()
207. {
208.     RSA *rsa;
210.     rsa=RSA_new();
211.     if(rsa==0)
212.     {
213.         return 0;
214.     }
215.     RSA_set_method(rsa,&capirsameth);
216.     rsa->flags=RSA_FLAG_SIGN_VER;
217.     return rsa;
218. }
220. RSA *RSAToCAPIPrivKey(RSA *rsa)
221. {
222.     RSA *ret;
223.     PCRYPT_KEY_PROV_INFO keyinfo;
224.     HCRYPTPROV hProv;
225.     BOOL b;
227.     if(rsa==0||rsa->e==0||rsa->n==0)
228.     {
229.         return 0;
230.     }
231.     keyinfo=GetProvInfo(rsa);
232.     if(keyinfo==0)
233.     {
234.         return 0;
235.     }
236.     b=CryptAcquireContextW(&hProv,keyinfo->pwszContainerName,keyinfo->pwszProvName,keyinfo->dwProvType,keyinfo->dwFlags);
237.     free(keyinfo);
238.     if(b==0)
239.     {
240.         return 0;
241.     }
242.     CryptReleaseContext(hProv,0);
244.     ret=CAPI_RSA_new();
245.     if(ret==0)
246.     {
247.         return 0;
248.     }
250.     ret->e=BN_dup(rsa->e);
251.     if(ret->e==0)
252.     {
253.         RSA_free(ret);
254.         return 0;
255.     }
256.     
257.     ret->n=BN_dup(rsa->n);
258.     if(ret->n==0)
259.     {
260.         RSA_free(ret);
261.         return 0;
262.     }
264.     return ret;
265.     
266. }
269. PCRYPT_KEY_PROV_INFO GetProvInfo(const RSA *rsa)
270. {
271.     unsigned char *rsapubkeybuf=0;
272.     int rsapubkeybuflen;
273.     BOOL b;
274.     PCCERT_CONTEXT ctx1;
275.     PCCERT_CONTEXT ctx2;
276.     HCERTSTORE hStore;
277.     PCRYPT_KEY_PROV_INFO data;
278.     DWORD datalen;
279.     
280.     rsapubkeybuflen=i2d_RSAPublicKey(rsa,&rsapubkeybuf);
281.     if(rsapubkeybuflen<=0)
282.     {
283.         return 0;
284.     }
285.     
286.     hStore=CertOpenSystemStore(0,"MY");
287.     if(hStore==0)
288.     {
289.         OPENSSL_free(rsapubkeybuf);
290.         return 0;
291.     }
292.     
293.     ctx2=0;
294.     while((ctx1=CertEnumCertificatesInStore(hStore,ctx2)))
295.     {
296.         b=CertGetCertificateContextProperty(ctx1,CERT_KEY_PROV_INFO_PROP_ID, 0, &datalen);
297.         if(b)
298.         {
299.             data=(PCRYPT_KEY_PROV_INFO)malloc(datalen);
300.             if(data==0)
301.             {
302.                 OPENSSL_free(rsapubkeybuf);
303.                 CertFreeCertificateContext(ctx1);
304.                 CertCloseStore(hStore,0);
305.                 return 0;
306.             }
307.             b=CertGetCertificateContextProperty(ctx1,CERT_KEY_PROV_INFO_PROP_ID, data, &datalen);
308.             if(b)
309.             {
310.                 if(ctx1->pCertInfo->SubjectPublicKeyInfo.PublicKey.cUnusedBits==0&
311.                     (int)ctx1->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData==rsapubkeybuflen &
312.                     memcmp(ctx1->pCertInfo->SubjectPublicKeyInfo.PublicKey.pbData,rsapubkeybuf,rsapubkeybuflen)==0)
313.                 {
314.                     OPENSSL_free(rsapubkeybuf);
315.                     CertFreeCertificateContext(ctx1);
316.                     CertCloseStore(hStore,0);
317.                     return data;
318.                 }
319.                 else
320.                 {
321.                     free(data); 
322.                 }
323.             }
324.             else
325.             {
326.                 free(data);
327.             }
328.         }
329.         ctx2=ctx1;
330.     }
333.     OPENSSL_free(rsapubkeybuf);
334.     CertCloseStore(hStore,0);
335.     return 0;
336. }