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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
CA.cpp
资源名称：MiniCA2.rar　[点击查看]
上传用户：dengkfang
上传日期：2008-12-30
资源大小：5233k
文件大小：68k
源码类别：

CA认证

开发平台：

Visual C++

CA.cpp：源码内容
  1. // CA.cpp : Defines the entry point for the DLL application.
  2. //
  3. #include "stdafx.h"
  4. #include <locale.h>
  5. #include "ca.h"
  6. #include <openssl/pem.h>
  7. #include <openssl/err.h>
  8. #include <openssl/x509.h>
  9. #include <openssl/x509v3.h>
  10. #include <openssl/pkcs12.h>
  11. #include <openssl/rand.h>
  12. //#include <sys/stat.h>   stat() 可以得到文件状态
  14. #define EXT_COPY_NONE 0
  15. #define EXT_COPY_ADD 1
  16. #define EXT_COPY_ALL 2
  18. #define MAX_CERT_LEN 8192 //最大公钥长度
  19. #define MAX_KEY_LEN 4096 //最大私钥长度
  21. BOOL APIENTRY DllMain( HANDLE hModule, 
  22.                        DWORD  ul_reason_for_call, 
  23.                        LPVOID lpReserved
  24.  )
  25. {
  26. switch(ul_reason_for_call) 
  27. { 
  28. case DLL_PROCESS_ATTACH: 
  29. OpenSSL_add_all_algorithms(); //leak EVP_cleanup(void);
  30. ERR_load_crypto_strings(); // leak  ERR_free_strings()
  31. //ENGINE_load_builtin_engines();
  32. break;
  34. case DLL_PROCESS_DETACH: 
  35. CONF_modules_unload(1);
  36. EVP_cleanup();
  37. CRYPTO_cleanup_all_ex_data(); 
  38. ERR_remove_state(0);
  39. ERR_free_strings(); 
  40. CONF_modules_free();
  41. break; 
  42. }
  43. return TRUE;
  44. }
  46. void LastError(char * info)
  47. {
  48. /* BIO * mem = BIO_new(BIO_s_mem());
  49. BIO_set_close(mem, BIO_CLOSE); 
  50. ERR_print_errors(mem);
  51. BUF_MEM * bptr = NULL;
  52. BIO_get_mem_ptr(mem, &bptr);
  53. int len = bptr->length;
  54. char * pbuf = new char[len+1];
  55. memset(pbuf,0,len+1);
  56. memcpy(pbuf,bptr->data,len);
  57. delete [] pbuf;*/
  59. }
  60. /*此函数可以将DER、PEM、P12文件公钥读出来*/
  61. X509 *load_cert(BIO * pBioCert/*输入BIO*/, const int iFormat/*格式*/,
  62. const char * lpszPwd,/*P12密码*/
  63. char * outMsg) //从DER、PEM、P12格式中加载公钥证书
  64. {
  65. X509 * x = NULL;
  66. if(iFormat == DER)
  67. x = d2i_X509_bio(pBioCert,NULL);
  68. else if (iFormat == PEM)
  69. x = PEM_read_bio_X509(pBioCert,NULL,NULL,NULL);//PEM_read_bio_X509_AUX
  70. else if (iFormat == P12)
  71. {
  72. OpenSSL_add_all_algorithms();
  73. PKCS12 *p12 = d2i_PKCS12_bio(pBioCert, NULL);
  74. PKCS12_parse(p12, lpszPwd, NULL, &x, NULL);
  75. PKCS12_free(p12);
  76. p12 = NULL;
  77. // EVP_cleanup();
  78. }
  79. else
  80. {
  81. sprintf(outMsg,"bad input format specified for input certn");
  82. goto end;
  83. }
  84. end:
  85. if (x == NULL)
  86. {
  87. sprintf(outMsg,"unable to load certificaten");
  88. }
  89. else
  90. sprintf(outMsg,"");
  91. return(x);
  92. }
  94. X509 * LoadCert(const char * lpszCert,const int iCertlen,
  95. const char * lpszPass,char * outMsg)//枚举DER/PEM格式
  96. {
  97. BIO * in = NULL;
  98. X509 * x509 = NULL;
  100. if(iCertlen == 0)//输入为磁盘文件
  101. {
  102. if((in = BIO_new_file(lpszCert, "r")) == NULL)
  103. {
  104. sprintf(outMsg,"open CA certificate file error");
  105. return NULL;
  106. }
  107. }
  108. else//输入为内存中文件
  109. {
  110. if((in = BIO_new_mem_buf((void *)lpszCert,iCertlen)) == NULL)//只读类型
  111. {
  112. sprintf(outMsg,"Make Mem Bio Error");
  113. return NULL;
  114. }
  115. }
  116. if((x509 = load_cert(in,DER,NULL,outMsg)) == NULL)//尝试DER
  117. {
  118. BIO_reset(in);//恢复bio
  119. if((x509 = load_cert(in,PEM,NULL,outMsg)) == NULL)//尝试PEM
  120. {
  121. BIO_reset(in);//恢复bio
  122. x509 = load_cert(in,P12,lpszPass,outMsg);//尝试P12
  123. }
  124. }
  125. if (in != NULL) BIO_free(in);
  126. return x509;
  127. }
  129. EVP_PKEY * load_key(BIO * pBioKey, const int iFormat, const char * lpszPass,char * outMsg)//枚举DER/PEM格式
  130. {
  131. EVP_PKEY * pkey = NULL;
  132. OpenSSL_add_all_algorithms();
  134. if (iFormat == DER)
  135. {
  136. if(NULL == lpszPass || strlen(lpszPass) == 0)
  137. {
  138. pkey = d2i_PrivateKey_bio(pBioKey, NULL);
  139. }
  140. else
  141. {
  142. //添加解密链
  143. unsigned char key[EVP_MAX_KEY_LENGTH] = "";//算法最长的KEY长度
  144. unsigned char iv[EVP_MAX_IV_LENGTH] = "";//算法最长的IV长度
  145. BIO * bDec = NULL;
  146. bDec = BIO_new(BIO_f_cipher());
  147. const EVP_CIPHER * cipher = NULL;
  148. cipher = EVP_des_ede3_cbc(); // 3DES-EDE-CBC 
  149. if(EVP_BytesToKey(cipher,EVP_sha1(),NULL,(unsigned char *)lpszPass,
  150. strlen(lpszPass),1,key,iv))
  151. {
  152. BIO_set_cipher(bDec,cipher,key,iv, 0);//1-加密、0-解密
  153. pBioKey = BIO_push(bDec, pBioKey); 
  154. BIO_flush(pBioKey);
  156. pkey = d2i_PrivateKey_bio(pBioKey, NULL);//私钥解密
  158. pBioKey = BIO_pop(pBioKey);
  159. BIO_free(bDec);
  160. }
  161. else
  162. {
  163. strcpy(outMsg,"初始化key or iv 失败");
  164. goto end;
  165. }
  166. }
  167. }
  168. else if (iFormat == PEM)
  169. {
  170. pkey = PEM_read_bio_PrivateKey(pBioKey,NULL,NULL,(void * )lpszPass);
  171. }
  172. else if (iFormat == P12)
  173. {
  174. PKCS12 *p12 = d2i_PKCS12_bio(pBioKey, NULL);
  175. PKCS12_parse(p12, lpszPass, &pkey, NULL, NULL);
  176. PKCS12_free(p12);
  177. p12 = NULL;
  178. }
  179. else
  180. {
  181. sprintf(outMsg,"bad input format specified for keyn");
  182. goto end;
  183. }
  184. end:
  185. // EVP_cleanup();
  186. if (pkey == NULL)
  187. sprintf(outMsg,"unable to load Private Keyn");
  188. else
  189. sprintf(outMsg,"");
  190. return(pkey);
  191. }
  193. EVP_PKEY * LoadKey(const char * lpszkey,const int iKeylen,const char * lpszPass,char * outMsg) //leak 4772
  194. {
  195. EVP_PKEY *pkey = NULL;
  196. BIO * in = NULL;
  198. if(iKeylen ==0 )//输入为磁盘文件
  199. {
  200. if((in = BIO_new_file(lpszkey, "r")) == NULL)
  201. {
  202. sprintf(outMsg,"open CA certificate file error");
  203. goto end;
  204. }
  205. }
  206. else//输入为内存中文件
  207. {
  208. if((in = BIO_new_mem_buf((void *)lpszkey,iKeylen)) == NULL)//只读类型
  209. {
  210. sprintf(outMsg,"Make Mem Bio Error");
  211. goto end;
  212. }
  213. }
  215. if((pkey = load_key(in,DER,lpszPass,outMsg)) == NULL)//尝试DER
  216. {
  217. BIO_reset(in);//BIO是可读写的，那么该BIO所有数据都会被清空；
  218. //如果该BIO是只读的，那么该操作只会简单将指
  219. //针指向原始位置，里面的数据可以再读.
  220. if((pkey = load_key(in,PEM,lpszPass,outMsg)) == NULL)//尝试PEM
  221. {
  222. BIO_reset(in);
  223. pkey = load_key(in,P12,lpszPass,outMsg);
  224. }
  225. }
  226. end:
  227. if (in != NULL)
  228. {
  229. BIO_flush(in);
  230. BIO_free_all(in);
  231. }
  232. return pkey;
  233. }
  235. int Rand(const char * file,const int dont_warn,char * outMsg)//产生随机数,return 0 ---成功
  236. {
  237. int consider_randfile = (file == NULL);
  238. char buffer[200];
  240. RAND_screen();
  241. if (file == NULL)
  242. file = RAND_file_name(buffer, sizeof buffer);
  243. else if (RAND_egd(file) > 0)
  244. {
  245. /* we try if the given filename is an EGD socket.
  246. if it is, we don't write anything back to the file. */
  247. return 1;
  248. }
  249. if (file == NULL || !RAND_load_file(file, -1))
  250. {
  251. if (RAND_status() == 0 && !dont_warn)
  252. {
  253. sprintf(outMsg,"unable to load 'random state'n");
  254. sprintf(outMsg,"This means that the random number generator has not been seededn");
  255. if (consider_randfile) /* explanation does not apply when a file is explicitly named */
  256. {
  257. sprintf(outMsg,"Consider setting the RANDFILE environment variable to point at a file thatn");
  258. sprintf(outMsg,"'random' data can be kept in (the file will be overwritten).n");
  259. }
  260. }
  261. return 0;
  262. }
  263. return 1;
  264. }
  267. ///////////////////////// end ////////////////////////////////////////
  268. //////////////////////////////////////////////////////////////////////
  269. ///////////////////////// begin //////////////////////////////////////
  271. /* Add extension using V3 code: we can set the config file as NULL
  272. * because we wont reference any other sections.
  273. */
  274. int Add_ExtCert(X509 * pCert/*正被添加的证书*/,X509 * pRoot/*根证书（从中得到信息)*/,
  275. const int iNid, const char * lpszValue)
  276. {
  277. X509_EXTENSION * ex = NULL;
  278. X509V3_CTX ctx;
  279. /* This sets the 'context' of the extensions. */
  280. /* No configuration database */
  281. X509V3_set_ctx_nodb(&ctx);
  282. /* Issuer and subject certs: both the target since it is self signed,
  283. * no request and no CRL
  284. */
  285. X509V3_set_ctx(&ctx,pRoot, pCert, NULL, NULL, 0);
  286. ex = X509V3_EXT_nconf_nid(NULL, &ctx, iNid, (char *)lpszValue);//X509V3_EXT_nconf
  287. if (!ex)
  288. {
  289. return 0;
  290. }
  291. X509_add_ext(pCert,ex,-1);
  292. X509_EXTENSION_free(ex);
  293. return 1;
  294. }
  296. int Add_ExtCert(X509 *pCert/*正被添加的证书*/,X509 * pRoot/*根证书（从中得到信息)*/, 
  297. const char * lpszName, const char *lpszValue)
  298. {
  299. X509_EXTENSION * ex = NULL;
  300. X509V3_CTX ctx;
  301. /* This sets the 'context' of the extensions. */
  302. /* No configuration database */
  303. X509V3_set_ctx_nodb(&ctx);
  304. /* Issuer and subject certs: both the target since it is self signed,
  305. * no request and no CRL
  306. */
  307. X509V3_set_ctx(&ctx, pRoot, pCert, NULL, NULL, 0);
  308. ex = X509V3_EXT_conf(NULL, &ctx, (char *)lpszName, (char *)lpszValue);//X509V3_EXT_nconf
  309. if (!ex)
  310. {
  311. return 0;
  312. }
  313. X509_add_ext(pCert,ex,-1);
  314. X509_EXTENSION_free(ex);
  315. return 1;
  316. }
  318. int AddExtCert(X509 *pCert/*正被添加的证书*/,X509 * pRoot/*根证书（从中得到信息)*/, 
  319.    const stuCERTEXT * pCertExt)
  320. {
  321. /* This sets the 'context' of the extensions. */
  322. /* No configuration database */
  323. /* Issuer and subject certs: both the target since it is self signed,
  324. * no request and no CRL
  325. */
  326. //基本限制Note if the CA option is FALSE the pathlen option should be omitted. 
  327. // Add_ExtCert(pCert,pCert,NID_friendlyName, "130203197703060618");
  329. //主题密钥标示符--------区分拥有者多对密钥
  330. // Add_ExtCert(pCert,pCert,NID_subject_key_identifier, "hash");
  332. //Authority密钥标示符----区分发行者有多个签名密钥时
  333. // Add_ExtCert(pCert,pRoot, NID_authority_key_identifier, "keyid,issuer:always");
  336. //密钥用法 ----数字签名、不可否认性、密钥加密、数据加密、密钥协商、证书签名、
  338. //颁发者备用名称,URL:http://my.url.here/、不支持email  copy
  339. // Add_ExtCert(pCert,pCert, NID_issuer_alt_name, 
  340. // "DNS:hpxs,email:hpxs@hotmail.com,RID:1.2.3.4,URI:https://hpxs,IP:192.168.0.22");
  341. //
  342. //证书策略
  343. // Add_ExtCert(pCert,pCert,NID_certificate_policies,"requireExplicitPolicy:3");
  344. //颁发机构信息访问
  345. // Add_ExtCert(pCert,pCert,NID_info_access,"OCSP;URI:https://hpxs");//或者caIssuers;URI:http://my.ca/ca.html
  346. //CRL分发点
  347. // Add_ExtCert(pCert,pCert, NID_crl_distribution_points, "URI:https://hpxs/hpxs.crl");
  349. /* Some Netscape specific extensions */
  350. // Add_ExtCert(ret,ret, NID_crl_number, "sslCA");
  352. // Add_ExtCert(ret,px509, NID_netscape_comment, "See http://cert.umd.edu/root for details.");
  353. /* In each case the 'value' of the extension is placed directly in the
  354. extension. Currently supported extensions in this category are: nsBaseUrl,
  355. nsRevocationUrl, nsCaRevocationUrl, nsRenewalUrl, nsCaPolicyUrl,
  356. nsSslServerName and nsComment */
  358. // Add_ExtCert(ret,px509, NID_netscape_cert_type, "client, server, email,objsign, reserved, sslCA,emailCA, objCA");
  359. /*nsCertType (netscape certificate type) takes the flags: client, server, email,
  360. objsign, reserved, sslCA, emailCA, objCA.*/
  361. /* Maybe even add our own extension based on existing */
  363. // nid = OBJ_create("1.3.6.1.4.1.5315.100.2.5", "Hpxs", "OC61108551");0.9.2342.19200300.100.1.1
  364. // X509V3_EXT_add_alias(nid, NID_netscape_comment);
  365. // Add_ExtCert(ret,ret, nid, "OC61108551");
  368. while(pCertExt!=NULL)//遍历链表
  369. {
  370. if(OBJ_sn2nid(pCertExt->cName) == NID_authority_key_identifier)
  371. {
  372. Add_ExtCert(pCert, pRoot, OBJ_sn2nid(pCertExt->cName), (char *)pCertExt->cInfo);
  373. }
  374. else if(strstr(pCertExt->cName, ".") == NULL) //没有发现.
  375. {
  376. Add_ExtCert(pCert, pCert, OBJ_sn2nid(pCertExt->cName), (char *)pCertExt->cInfo);
  377. }
  378. else
  379. { //加入自定义信息begin
  380. int nid;
  381. nid = OBJ_create(pCertExt->cName, pCertExt->cName, pCertExt->cName);
  382. if(nid != NID_undef)
  383. {
  384. X509V3_EXT_add_alias(nid, NID_netscape_comment);
  385. Add_ExtCert(pCert,pCert, nid, pCertExt->cInfo);
  386. }
  387. OBJ_cleanup();
  388. }
  389. pCertExt = pCertExt->Link;
  390. }
  391. return 1;
  392. }
  394. void Ansi2Utf8(const LPSTR lpsrc, const int srclen, LPSTR lpdst, int& dstlen)
  395. {
  396. WCHAR * pwUnicode;      
  397.     int len = MultiByteToWideChar(CP_ACP,0,(char*)lpsrc,srclen,NULL,0);      
  398.     pwUnicode = new WCHAR[len];  
  399.     memset(pwUnicode,0,len);
  400.     MultiByteToWideChar(CP_ACP,0 ,(char*)lpsrc,srclen,pwUnicode,len);      
  401.     dstlen = WideCharToMultiByte(CP_UTF8,0,pwUnicode,len,NULL,0,NULL,NULL);      
  402.     WideCharToMultiByte(CP_UTF8,0,pwUnicode,len,lpdst,dstlen,NULL,NULL);      
  403.     delete []pwUnicode;      
  404. }
  406. BOOL Add_Name(X509_NAME * px509Name,const int iNid/*ccn*/,
  407.   const int iType/*V_ASN1_UTF8STRING*/,
  408.   const char * lpszInput/*中国*/,
  409.   const int iLen/*输入长度*/)//支持中文名称
  410. {
  411. if(NULL == lpszInput || strlen(lpszInput) == 0)
  412. return FALSE;
  413. if(iType == V_ASN1_UTF8STRING)
  414. {
  415. char lpdst[1024] = {0};
  416. int dstlen = 0;
  417. char input[256]={0};
  418. strncpy(input, lpszInput, iLen);
  419. Ansi2Utf8(input, iLen, lpdst, dstlen);
  420. X509_NAME_add_entry_by_NID(px509Name,iNid,V_ASN1_UTF8STRING,(UCHAR *)lpdst,dstlen, -1, 0);
  421. }
  422. else
  423. X509_NAME_add_entry_by_NID(px509Name,iNid,iType,(UCHAR *)lpszInput,iLen, -1, 0);
  424. return TRUE;
  425. }
  427. BOOL Add_Name(X509_NAME * px509Name,const char * field/*ccn*/,
  428.   const char * lpszInput/*中国*/,
  429.   const int iLen/*输入长度*/)//支持中文名称
  430. {
  431. if(NULL == lpszInput || strlen(lpszInput) == 0)
  432. return FALSE;
  434. BOOL bRet = FALSE;
  436. int nid = NID_undef;
  438. int iType = V_ASN1_UTF8STRING;
  440. if(strstr(field, ".") == NULL) //没有发现.
  441. {
  442. nid = OBJ_txt2nid(field);
  443. }
  444. else
  445. {
  446. nid = OBJ_create(field, field, field);
  447. }
  448. if(nid != NID_undef)
  449. {
  450. if(NID_pkcs9_emailAddress == nid)
  451. {
  452. iType = V_ASN1_IA5STRING;
  453. }
  454. else
  455. {
  456. iType = V_ASN1_UTF8STRING;
  457. }
  459. bRet = Add_Name(px509Name, nid, iType, lpszInput, iLen);
  460. }
  461. OBJ_cleanup();
  463. return bRet;
  464. }
  466. void AddName(X509_NAME * px509Name,const stuSUBJECT * pSubJect)
  467. {
  468. setlocale(LC_CTYPE, "");
  470. while(pSubJect != NULL)//遍历链表
  471. {
  472. Add_Name(px509Name, (char *)pSubJect->cName, (char *)pSubJect->cInfo,strlen((char *)pSubJect->cInfo));
  473. pSubJect = pSubJect->Link;
  474. }
  476. /*
  481. Add_Name(px509Name,NID_stateOrProvinceName,V_ASN1_UTF8STRING,(char *)pSubJect->ST,strlen((char *)pSubJect->ST));
  482. Add_Name(px509Name,NID_localityName,V_ASN1_UTF8STRING,(char *)pSubJect->L,strlen((char *)pSubJect->L));
  483. Add_Name(px509Name,NID_organizationName,V_ASN1_UTF8STRING,(char *)pSubJect->O,strlen((char *)pSubJect->O));
  484. Add_Name(px509Name,NID_organizationalUnitName,V_ASN1_UTF8STRING,(char *)pSubJect->OU,strlen((char *)pSubJect->OU));
  485. Add_Name(px509Name,NID_commonName,V_ASN1_UTF8STRING,(char *)pSubJect->CN,strlen((char *)pSubJect->CN));
  486. Add_Name(px509Name,NID_pkcs9_emailAddress,V_ASN1_IA5STRING,(char *)pSubJect->MAIL,strlen((char *)pSubJect->MAIL));
  488. Add_Name(px509Name,NID_title,V_ASN1_UTF8STRING,(char *)pSubJect->T,strlen((char *)pSubJect->T));
  489. // Add_Name(px509Name,NID_description,(char *)pSubJect->D,strlen((char *)pSubJect->D));
  490. Add_Name(px509Name,NID_givenName,V_ASN1_UTF8STRING,(char *)pSubJect->G,strlen((char *)pSubJect->G));
  491. // Add_Name(px509Name,NID_initials,(char *)pSubJect->I,strlen((char *)pSubJect->I));
  492. // Add_Name(px509Name,NID_name,(char *)pSubJect->NAME,strlen((char *)pSubJect->NAME));
  493. Add_Name(px509Name,NID_surname,V_ASN1_UTF8STRING,(char *)pSubJect->S,strlen((char *)pSubJect->S));
  494. // Add_Name(px509Name,NID_dnQualifier,(char *)pSubJect->QUAL,strlen((char *)pSubJect->QUAL));
  495. // Add_Name(px509Name,NID_pkcs9_unstructuredName,(char *)pSubJect->STN,strlen((char *)pSubJect->STN));
  496. // Add_Name(px509Name,NID_pkcs9_challengePassword,(char *)pSubJect->PW,strlen((char *)pSubJect->PW));
  497. // Add_Name(px509Name,NID_pkcs9_unstructuredAddress,(char *)pSubJect->ADD,strlen((char *)pSubJect->ADD));
  498. Add_Name(px509Name,NID_streetAddress,V_ASN1_UTF8STRING,(char *)pSubJect->CN,strlen((char *)pSubJect->CN));
  499. Add_Name(px509Name,NID_postalCode,V_ASN1_UTF8STRING,(char *)pSubJect->CN,strlen((char *)pSubJect->CN));
  500. Add_Name(px509Name,NID_homePostalAddress,V_ASN1_UTF8STRING,(char *)pSubJect->CN,strlen((char *)pSubJect->CN));
  501. Add_Name(px509Name,"2.5.4.20",V_ASN1_UTF8STRING,(char *)pSubJect->CN,strlen((char *)pSubJect->CN));
  502. */
  503. }
  506. //BOOL MakeRootPub(stuSUBJECT * rootInfo,/*信息*/ char * certMem/*证书文件*/,int * certLen,char * outMsg/*操作结果*/)
  507. /*{
  508. //所以证书预览序号0,位数384,有限期1,格式DER
  509. BIO * memcert = NULL;//输出证书公私钥
  510. BUF_MEM *bptrcert = NULL;
  511. X509 *x509=NULL;
  512. EVP_PKEY *pkey=NULL;
  513. memcert= BIO_new(BIO_s_mem());
  514. BOOL bRet = FALSE;
  515. if(mkRoot(rootInfo,&x509,&pkey,384,1,1,outMsg))
  516. {
  517. if(i2d_X509_bio(memcert,x509))//returns 1 for success  写入公钥
  518. {
  519. BIO_get_mem_ptr(memcert, &bptrcert);
  520. *certLen=bptrcert->length;
  521. memcpy(certMem,bptrcert->data,*certLen);
  522. bRet = TRUE;
  523. goto end;
  524. }
  525. else
  526. {
  527. strcpy(outMsg,"存储证书发生异常");
  528. }
  529. }
  530. end:
  531. BIO_free_all(memcert);
  532. memcert = NULL;
  533. EVP_PKEY_free(pkey);
  534. pkey = NULL;
  535. X509_free(x509);
  536. x509 = NULL;
  537. EVP_cleanup();//frees all three stacks and sets their pointers to NULL ---- EVP_CIPHER
  538. CRYPTO_cleanup_all_ex_data();
  539. return bRet;
  540. }*/
  542. /*将BIO转换未内存,和长度*/
  543. BOOL Bio2Mem(BIO * memBio/*[IN]*/,char * lpszMem/*[OUT]*/,
  544.  UINT * memLen/*[IN,OUT],输入为mem长度,输出为实际长度*/)
  545. {
  546. if(memBio == NULL || memLen == NULL || (*memLen !=0 && lpszMem == NULL))
  547. return FALSE;
  548. //if(BIO_method_type(memBio))//判断是否内存类型BIO
  549. UINT uCopy = 0;//拷贝实际长度
  550. BUF_MEM * bptrBio = NULL;
  551. BIO_get_mem_ptr(memBio, &bptrBio);
  552. (*memLen >(UINT)bptrBio->length)?(uCopy = bptrBio->length):(uCopy = *memLen);
  553. memcpy(lpszMem,bptrBio->data,uCopy);//拷贝输入长度,输入为0时候,测定长度
  554. *memLen = bptrBio->length;//返回实际长度
  555. return TRUE;
  556. }
  558. /*X509转换为Mem*/
  559. BOOL X5092Mem(X509 * px509/*[IN]*/,const int iType/*[in]类型pem-der*/,
  560.   char * x509Mem/*[OUT]*/,UINT * x509Len/*[OUT]*/)
  561. {
  562. if(px509 == NULL || x509Len == NULL)
  563. return FALSE;
  564. BIO * memcert = NULL;
  565. memcert = BIO_new(BIO_s_mem());
  566. BIO_set_close(memcert, BIO_CLOSE); /*  BIO_free() free BUF_MEM  */
  567. BOOL ret = FALSE;
  568. if (iType == DER)
  569. {
  570. ret = i2d_X509_bio(memcert,px509);//returns 1 for success
  571. }
  572. else if(iType == PEM)
  573. {
  574. ret = PEM_write_bio_X509(memcert,px509);
  575. }
  576. else
  577. {
  578. // strcpy(outMsg,"指定证书格式错误");
  579. // ret = 0;
  580. goto err;
  581. }
  582. if(ret)
  583. {
  584.  ret = Bio2Mem(memcert,x509Mem,x509Len);
  585. }
  586. err:
  587. BIO_free_all(memcert);
  588. return ret;
  589. }
  591. /*EVP_PKEY转换为BIO*/
  592. BOOL Key2Mem(EVP_PKEY * pkey/*[IN]*/,const int iType/*[in]类型pem-der*/,
  593.  const char * priPwd/*[in]私钥密码*/,
  594.  char * keyMem/*[OUT]*/,UINT * keyLen/*[OUT]*/)
  595. {
  596. if(pkey == NULL || keyLen == NULL)
  597. return FALSE;
  598. BIO * memkey = NULL;
  599. BIO * bEnc = NULL;
  600. memkey = BIO_new(BIO_s_mem());
  601. BIO_set_close(memkey, BIO_CLOSE); /*  BIO_free() free BUF_MEM  */
  602. BOOL ret = FALSE;
  603. if (iType==DER)
  604. {
  605. if(NULL == priPwd || strlen(priPwd) == 0) //写入私钥
  606. ret=i2d_PrivateKey_bio(memkey,pkey);//私钥未加密
  607. else
  608. {
  609. //添加加密链
  610. unsigned char key[EVP_MAX_KEY_LENGTH]="";//算法最长的KEY长度
  611. unsigned char iv[EVP_MAX_IV_LENGTH]="";//算法最长的IV长度
  612. bEnc = BIO_new(BIO_f_cipher());
  613. const EVP_CIPHER * cipher = NULL;
  614. cipher = EVP_des_ede3_cbc(); // 3DES-EDE-CBC 
  615. if(EVP_BytesToKey(cipher,EVP_sha1(),NULL,(unsigned char *)priPwd,
  616. strlen(priPwd),1,key,iv))
  617. {
  618. BIO_set_cipher(bEnc,cipher,key,iv, 1);//1-加密、0-解密
  619. memkey = BIO_push(bEnc, memkey); 
  620. ret = i2d_PrivateKey_bio(memkey,pkey);//私钥加密
  621. BIO_flush(memkey);
  622. memkey = BIO_pop(memkey);
  623. BIO_free(bEnc);
  626. }
  627. else
  628. {
  629. ret = FALSE;
  630. }
  631. }
  632. }
  633. else if(iType == PEM)
  634. {
  635. if(NULL == priPwd || strlen(priPwd) == 0)
  636. ret = PEM_write_bio_PrivateKey(memkey,pkey,NULL,NULL,0,NULL, NULL); //私钥不加密
  637. else
  638. ret = PEM_write_bio_PrivateKey(memkey,pkey,EVP_des_ede3_cbc(),NULL,0,NULL, (void *)priPwd); //私钥加密
  639. }
  640. else
  641. {
  642. ret = 0;
  643. goto err;
  644. }
  645. if(ret)
  646. {
  647.  ret = Bio2Mem(memkey,keyMem,keyLen);
  648. }
  649. err:
  650. BIO_free_all(memkey);
  651. return ret;
  653. }
  655. /*将stuCertPair结构转换为X509,EVP_PKEY,并验证密钥对*/
  656. BOOL CertPair2XE(const stuCertPair & RootPair/*[IN]*/,X509 *& pCert, EVP_PKEY *& pKey ,char * outMsg)
  657. {
  658. pCert = NULL;
  659. pKey = NULL;
  660. //检测stuCertPair结构合法性
  661. //检测公钥
  662. if(RootPair.memCert == NULL || strlen(RootPair.memCert) == 0 )//没有公钥信息
  663. {
  664. sprintf(outMsg,"结构中缺少公钥信息");
  665. return FALSE;
  666. }
  667. else if(RootPair.lenCert > MAX_CERT_LEN)//检测公钥长度,限定为8192
  668. {
  669. sprintf(outMsg,"公钥长度超过系统限制");
  670. return FALSE;
  671. }
  672. //检测私钥
  673. else if(RootPair.memKey == NULL || strlen(RootPair.memKey)==0 )//没有私钥信息
  674. {
  675. sprintf(outMsg,"结构中缺少私钥信息");
  676. return FALSE;
  677. }
  678. else if(RootPair.lenKey > MAX_KEY_LEN)//检测私钥长度,限定为4096
  679. {
  680. sprintf(outMsg,"私钥长度超过系统限制");
  681. return FALSE;
  682. }
  684. if(RootPair.pwdKey != NULL && strlen(RootPair.pwdKey))//私钥代密码
  685. {
  686. // OpenSSL_add_all_algorithms();
  687. }
  689. pKey = LoadKey(RootPair.memKey,RootPair.lenKey,RootPair.pwdKey,outMsg);
  690. if (pKey == NULL)
  691. {
  692. // EVP_cleanup();
  693. // CRYPTO_cleanup_all_ex_data();
  694. return FALSE;
  695. }
  697. pCert = LoadCert(RootPair.memCert,RootPair.lenCert,RootPair.pwdKey,outMsg);
  698. if (pCert == NULL)
  699. {
  700. // EVP_cleanup();
  701. // CRYPTO_cleanup_all_ex_data();
  702. return FALSE;
  703. }
  704. if (!X509_check_private_key(pCert,pKey))
  705. {
  706. sprintf(outMsg,"公私钥对不匹配");
  707. // EVP_cleanup();
  708. // CRYPTO_cleanup_all_ex_data();
  709. return FALSE;
  710. }
  711. return TRUE;
  712. }
  714. //在内存中创建PFX
  715. BOOL CreateMemPfx(X509 * pCert, EVP_PKEY * key, const  char * p12Pwd, const char * friendlyName,
  716.   char * memP12/*OUT*/, UINT * p12Len/*OUT*/) //
  717. {
  718.   BIO * memBio = NULL;
  719. BUF_MEM * bptrP12 = NULL;
  720.   memBio = BIO_new(BIO_s_mem());
  721. OpenSSL_add_all_algorithms();
  722. PKCS12 * p12 = PKCS12_create((char *)p12Pwd,(char *)friendlyName, key, pCert, NULL, 0,0,0,0,0);
  723. if(!p12)
  724. {
  725. BIO_free_all(memBio);
  726. return FALSE;
  727. }
  728. i2d_PKCS12_bio(memBio, p12);
  729. BIO_get_mem_ptr(memBio, &bptrP12);
  730. *p12Len = bptrP12->length;
  731. memcpy(memP12,bptrP12->data,*p12Len);
  732. PKCS12_free(p12);
  733. BIO_free_all(memBio);
  734. // EVP_cleanup();//frees all three stacks and sets their pointers to NULL ---- EVP_CIPHER
  735. // CRYPTO_cleanup_all_ex_data();
  736. return TRUE;
  738. }
  740. BOOL mkRoot(const stuSUBJECT * rootInfo,
  741. X509 ** x509p/*out公钥*/, 
  742. EVP_PKEY ** pkeyp/*out私钥*/, 
  743.     int bits/*位数*/, 
  744. const long serial/*序列号*/, 
  745. const int days/*有效期*/,
  746. const char * kusage,
  747. const char * ekusage,
  748. const stuCERTEXT * pCertExt,/*扩展*/
  749. char * outMsg/*操作结果*/)
  750. {
  751. if(bits < 384)
  752. bits = 384;
  754. X509 * x = NULL;
  755. EVP_PKEY * pk = NULL;
  756. RSA * rsa = NULL;
  757. X509_NAME * name = NULL;
  758. int i = 0,
  759. len = 0;
  760. char altname[255] = {0};
  761. if ((pkeyp == NULL) || (*pkeyp == NULL))
  762. {
  763. if ((pk = EVP_PKEY_new()) == NULL)
  764. {
  765. abort(); 
  766. return FALSE;
  767. }
  768. }
  769. else
  770. pk= *pkeyp;
  772. if ((x509p == NULL) || (*x509p == NULL))
  773. {
  774. if ((x=X509_new()) == NULL)
  775. goto err;
  776. }
  777. else
  778. x= *x509p;
  780. Rand(NULL,1,outMsg);//产生随机数种子
  781. rsa = RSA_generate_key(bits,RSA_F4,0/*回调函数callback*/,NULL);//产生密钥对,//RSA存储了公钥私钥
  782. if (!EVP_PKEY_assign_RSA(pk,rsa))//完成RSA密钥的pkey结构初始工作,当pk不为NULL的时候，返回1，否则返回0
  783. {
  784. abort();
  785. goto err;
  786. }
  787. rsa = NULL;
  789. X509_set_version(x,2);//版本号，显示+1
  790. ASN1_INTEGER_set(X509_get_serialNumber(x),serial);//序列号
  791. X509_gmtime_adj(X509_get_notBefore(x),0);//起始时间
  792. X509_gmtime_adj(X509_get_notAfter(x),(long)60*60*24*days);//结束时间
  793. X509_set_pubkey(x,pk);//公钥
  795. name = X509_get_subject_name(x);
  797. /* This function creates and adds the entry, working out the
  798. * correct string type and performing checks on its length.
  799. * Normally we'd check the return value for errors...
  800. */
  802. //C-国家,ST-省,L-城市,O-组织,OU-部门,CN-个体,T-title,D-description,G-givenName,I-initials,
  803. //Email-emailAddress,S-surname,SN-serialNumber,dnQualifier-dnQualifier,unstructuredName,challengePassword,unstructuredAddress,
  805. AddName(name,rootInfo);
  806. /* Its self signed so set the issuer name to be the same as the
  807. * subject.
  808. */
  810. X509_set_issuer_name(x,name);//设置发行者名称等同于上面的
  813. if(kusage && strlen(kusage))
  814. Add_ExtCert(x,x, NID_key_usage, kusage);
  816. AddExtCert(x,x,pCertExt);//扩展
  818. if(ekusage && strlen(ekusage))
  819. Add_ExtCert(x,x,NID_ext_key_usage,ekusage);
  821. X509V3_EXT_cleanup();//cleanup the extension code if any custom extensions have been added
  822. OBJ_cleanup();
  823. if (!X509_sign(x,pk,EVP_sha1()))//签名算法EVP_sha1,EVP_md5,用私钥签名公钥
  824. {
  825. strcpy(outMsg,"证书签名失败");
  826. goto err;
  827. }
  828. *x509p = x;
  829. *pkeyp = pk;
  830. return TRUE;
  831. err:
  832. return FALSE;
  833. }
  835. /*输出标志,如果输出某项(certMem,或certLen == NULL),则不输出本项*/
  836. BOOL MakeRoot(const stuSUBJECT * rootInfo,/*[in]信息*/
  837.   const char * friendlyName/*好记的名称*/,
  838.   const int bits/*[in]位数*/, 
  839.   const long serial/*[in]序列号*/, 
  840.   const int days/*[in]有效期*/,
  841.   const char * priPwd/*[in]私钥密码*/,
  842.   const char * cKusage,/*密钥用法*/
  843.   const char * cEkusage,/*扩展密钥用法*/
  844.   const stuCERTEXT * pCertExt,/*证书扩展*/
  845.   char * certMem/*[OUT]证书*/,
  846.   UINT * certLen/*[OUT]*/,
  847.   char * keyMem/*[OUT]私钥*/,
  848.   UINT * keyLen/*[OUT]*/,
  849.   char * p12Mem/*[OUT]pkcs#12*/,
  850.   UINT * p12Len/*[OUT]*/,
  851.   char * outMsg,/*操作结果*/
  852.   const int iType/*[in]类型pem-der*/)
  853. {
  854. X509 * px509 = NULL;
  855. EVP_PKEY * pkey = NULL;
  857. BIO * memcert = NULL,
  858. * memkey = NULL;
  860. memcert = BIO_new(BIO_s_mem());
  861. memkey = BIO_new(BIO_s_mem());
  862. BIO_set_close(memcert, BIO_CLOSE); /*  BIO_free() free BUF_MEM  */
  863. BIO_set_close(memkey, BIO_CLOSE); /*  BIO_free() free BUF_MEM  */
  865. BOOL ret = TRUE;
  866. int i = 0,
  867. j = 0;
  869. if(mkRoot(rootInfo,&px509,&pkey,bits,serial,days,cKusage,
  870.   cEkusage,pCertExt,outMsg))
  871. {
  872. X5092Mem(px509,iType,certMem,certLen);
  873. Key2Mem(pkey,iType,priPwd,keyMem,keyLen);
  874. CreateMemPfx(px509, pkey, priPwd, friendlyName, p12Mem, p12Len);
  875. } 
  876. else
  877. ret = FALSE;
  879. BIO_free_all(memcert);
  880. BIO_free_all(memkey);
  881. X509_free(px509);
  882. EVP_PKEY_free(pkey);
  883. return ret;
  885. }
  887. ///////////////////////// end ////////////////////////////////////////
  888. //////////////////////////////////////////////////////////////////////
  889. ///////////////////////// begin //////////////////////////////////////
  891. /* Add extension using V3 code: we can set the config file as NULL
  892.  * because we wont reference any other sections.
  893.  */
  894. int Add_ExtReq(STACK_OF(X509_REQUEST) *sk,const int iNid,const char *lpszValue)
  895. {
  896. X509_EXTENSION *ex;
  897. ex = X509V3_EXT_conf_nid(NULL, NULL, iNid, (char *)lpszValue);
  898. if (!ex)
  899. return 0;
  900. sk_X509_EXTENSION_push(sk, ex);
  902. return 1;
  903. }
  905. int mkReq(const stuSUBJECT * reqInfo,X509_REQ **req,
  906.   EVP_PKEY **pkeyp, int bits,char * outMsg)
  907. {
  908. if(bits < 384)
  909. bits = 384;
  910. X509_REQ *x = NULL;
  911. EVP_PKEY *pk = NULL;
  912. RSA *rsa = NULL;
  913. X509_NAME * name=NULL;
  914. ASN1_STRING stmp, 
  915. *str = &stmp;
  916. char altname[255] = {0};
  918. STACK_OF(X509_EXTENSION) *exts = NULL;
  920. if ((pk=EVP_PKEY_new()) == NULL)
  921. goto err;
  923. if ((x=X509_REQ_new()) == NULL)
  924. goto err;
  925. Rand(NULL,1,outMsg);//产生随机数种子
  926. rsa=RSA_generate_key(bits,RSA_F4,0/*回调函数callback*/,NULL);//产生密钥对
  927. //PEM_write_bio_RSAPrivateKey
  928. if (!EVP_PKEY_assign_RSA(pk,rsa))
  929. goto err;
  931. rsa=NULL;
  933. X509_REQ_set_pubkey(x,pk);
  935. name=X509_REQ_get_subject_name(x);
  937. /* This function creates and adds the entry, working out the
  938. * correct string type and performing checks on its length.
  939. * Normally we'd check the return value for errors...
  940. */
  942. AddName(name,reqInfo);
  944. /* Certificate requests can contain extensions, which can be used
  945. * to indicate the extensions the requestor would like added to 
  946. * their certificate. CAs might ignore them however or even choke
  947. * if they are present.
  948. */
  950. /* For request extensions they are all packed in a single attribute.
  951. * We save them in a STACK and add them all at once later...
  952. */
  954. exts = sk_X509_EXTENSION_new_null();
  955. /* Standard extenions */
  956. //主题备用名称,URL:http://my.url.here/、支持email  copy
  957. // sprintf(altname,"email:%s",(char *)reqInfo->MAIL);
  958. // Add_ExtReq(exts, NID_subject_alt_name, altname);
  960. //加入自定义扩展
  961. // int nid;
  962. // nid = OBJ_create("1.3.6.1.4.1.5315.100.2.5", "UserID", "User ID Number");
  963. // X509V3_EXT_add_alias(nid, NID_netscape_comment);
  964. // Add_ExtReq(exts, nid, "ID130203197703060618");
  965. /* Now we've created the extensions we add them to the request */
  967. X509_REQ_add_extensions(x, exts);
  968. sk_X509_EXTENSION_pop_free(exts, X509_EXTENSION_free);
  969. X509V3_EXT_cleanup();//cleanup the extension code if any custom extensions have been added
  970. OBJ_cleanup();
  971. if (!X509_REQ_sign(x,pk,EVP_sha1()))//用自己的公钥签名私钥
  972. goto err;
  974. *req=x;
  975. *pkeyp=pk;
  976. return(1);
  977. err:
  978. return(0);
  979. }
  981. BOOL MakeReq(const stuSUBJECT * reqInfo,/*请求信息IN*/
  982.  const int bits/*位数IN*/,
  983.  const char * priPwd/*私钥密码,IN*/,
  984.  char * reqMem/*证书请求文件OUT*/,
  985.  UINT * reqLen/*证书请求文件长度OUT*/,
  986.  char * priMem/*私钥文件OUT*/,
  987.  UINT * priLen/*私钥文件文件长度OUT*/,
  988.  char * outMsg/*操作结果OUT*/,
  989.  const int iType/*类型pem-der*/)
  990. {
  991. X509_REQ * req=NULL;
  992. EVP_PKEY * pkey=NULL;
  994. BIO * breq = NULL,
  995. * bkey = NULL;
  997. int i = 0,
  998. j = 0;
  1000. breq = BIO_new(BIO_s_mem());
  1001. bkey = BIO_new(BIO_s_mem());
  1002. BIO_set_close(breq, BIO_CLOSE); /*  BIO_free() free BUF_MEM  */
  1003. BIO_set_close(bkey, BIO_CLOSE); /*  BIO_free() free BUF_MEM  */
  1005. /* if(((breq = BIO_new_file(reqFile, "w"))== NULL)||((bkey = BIO_new_file(priFile, "w")) == NULL))
  1006. {
  1007. strcpy(outMsg,"Create File Error");
  1008. return FALSE;
  1009. }
  1010. */
  1011. if(!mkReq(reqInfo,&req,&pkey,bits,outMsg))
  1012. {
  1013. strcpy(outMsg,"Make CertReq Error");
  1014. return FALSE;
  1015. }
  1017. if(iType == PEM)
  1018. {
  1019. i = PEM_write_bio_X509_REQ(breq,req); //写入公钥
  1020. if(NULL == priPwd || strlen(priPwd) == 0)
  1021. j = PEM_write_bio_PrivateKey(bkey,pkey,NULL,NULL,0,NULL, NULL); //私钥不加密
  1022. else
  1023. j = PEM_write_bio_PrivateKey(bkey,pkey,EVP_des_ede3_cbc(),NULL,0,NULL, (void *)priPwd); //私钥加密
  1024. }
  1025. else if(iType == DER)
  1026. {
  1027. i = i2d_X509_REQ_bio(breq,req); //写入公钥
  1029. if(NULL == priPwd || strlen(priPwd) == 0) //写入私钥
  1030. j = i2d_PrivateKey_bio(bkey,pkey);//私钥未加密
  1031. else
  1032. {
  1033. //添加加密链
  1034. unsigned char key[EVP_MAX_KEY_LENGTH] = "";//算法最长的KEY长度
  1035. unsigned char iv[EVP_MAX_IV_LENGTH] = "";//算法最长的IV长度
  1036. BIO * bEnc = NULL;
  1037. bEnc = BIO_new(BIO_f_cipher());
  1038. const EVP_CIPHER * cipher = NULL;
  1039. cipher = EVP_des_ede3_cbc(); // 3DES-EDE-CBC 
  1040. if(EVP_BytesToKey(cipher,EVP_sha1(),NULL,(unsigned char *)priPwd,
  1041. strlen(priPwd),1,key,iv))
  1042. {
  1043. BIO_set_cipher(bEnc,cipher,key,iv, 1);//1-加密、0-解密
  1044. bkey = BIO_push(bEnc, bkey); 
  1045. j = i2d_PrivateKey_bio(bkey,pkey);//私钥加密
  1046. BIO_flush(bkey);
  1047. bkey = BIO_pop(bkey);
  1048. BIO_free(bEnc);
  1049. }
  1050. else
  1051. strcpy(outMsg,"初始化key or iv 失败,");
  1052. }
  1053. }
  1054. //转换BIO->MEM
  1055. if(i&&j)
  1056. {
  1057. i = Bio2Mem(breq, reqMem, reqLen);
  1058. j = Bio2Mem(bkey, priMem, priLen);
  1059. }
  1061. BIO_free(breq);
  1062. BIO_free_all(bkey);
  1063. X509_REQ_free(req);
  1064. EVP_PKEY_free(pkey);
  1065. if(!i||!j)
  1066. {
  1067. strcat(outMsg,"Save Cert or Key File Error");
  1068. return FALSE;
  1069. }
  1070. return TRUE;
  1071. }
  1072. ////////////////////////// end //////////////////////////////////////
  1073. ////////////////////////////////////////////////////////////////////
  1074. /////////////////////////// begin ////////////////////////////////////////
  1075. int copy_extensions(X509 *x, X509_REQ *req, const int copy_type)//在证书中加入req自带扩展信息
  1076. {
  1077. STACK_OF(X509_EXTENSION) * exts = NULL;
  1078. X509_EXTENSION * ext = NULL,
  1079.            * tmpext = NULL;
  1080. ASN1_OBJECT * obj = NULL;
  1081. int i = 0,
  1082. idx = 0,
  1083. ret = 0;
  1084. if (!x || !req || (copy_type == EXT_COPY_NONE))
  1085. return 1;
  1087. exts = X509_REQ_get_extensions(req);
  1089. for(i = 0; i < sk_X509_EXTENSION_num(exts); i++)
  1090. {
  1091. ext = sk_X509_EXTENSION_value(exts, i);
  1092. obj = X509_EXTENSION_get_object(ext);
  1093. idx = X509_get_ext_by_OBJ(x, obj, -1);
  1094. /* Does extension exist? */
  1095. if (idx != -1) 
  1096. {
  1097. /* If normal copy don't override existing extension */
  1098. if (copy_type == EXT_COPY_ADD)
  1099. continue;
  1100. /* Delete all extensions of same type */
  1101. do
  1102. {
  1103. tmpext = X509_get_ext(x, idx);
  1104. X509_delete_ext(x, idx);
  1105. X509_EXTENSION_free(tmpext);
  1106. idx = X509_get_ext_by_OBJ(x, obj, -1);
  1107. } while (idx != -1);
  1108. }
  1109. if (!X509_add_ext(x, ext, -1))
  1110. goto end;
  1111. }
  1113. ret = 1;
  1115. end:
  1117. sk_X509_EXTENSION_pop_free(exts, X509_EXTENSION_free);
  1119. return ret;
  1120. }
  1123. int do_body(X509 **xret, EVP_PKEY *pkey, X509 *px509, 
  1124. const EVP_MD *dgst,const long serial,
  1125. const char *startdate, const char *enddate,
  1126. const int days,X509_REQ * req,const char * kusage,
  1127. const char * ekusage,const stuCERTEXT * pCertExt,char * outMsg)
  1128. {
  1129. X509_NAME * name = NULL, * CAname = NULL;
  1130. X509 * ret = NULL;
  1131. X509_CINF * ci = NULL;
  1132. EVP_PKEY * pktmp = NULL;
  1133. int ok= -1,
  1134. i=0;
  1135. // STACK_OF (X509_EXTENSION) * req_exts;//如何释放??
  1136. name = X509_REQ_get_subject_name(req);
  1137. if ((ret = X509_new()) == NULL) 
  1138. {
  1139. ok=0;
  1140. goto err;
  1141. }
  1142. ci = ret->cert_info;
  1144. /* Make it an X509 v3 certificate. 版本1扩展*/
  1145. if (!X509_set_version(ret,2L)) //版本
  1146. {
  1147. ok=0;
  1148. goto err;
  1149. }
  1151. ASN1_INTEGER_set(X509_get_serialNumber(ret),serial);//序列号
  1153. if (!X509_set_issuer_name(ret,X509_get_subject_name(px509)))//发行者
  1154. {
  1155. ok=0;
  1156. goto err;
  1157. }
  1159. //X509_gmtime_adj(X509_get_notBefore(x),0);//起始时间
  1160. //X509_gmtime_adj(X509_get_notAfter(x),(long)60*60*24*days);//结束时间
  1162. if (strcmp(startdate,"today") == 0)
  1163. X509_gmtime_adj(X509_get_notBefore(ret),0);//开始日期
  1164. else ASN1_UTCTIME_set_string(X509_get_notBefore(ret),(char *)startdate);
  1166. if (enddate == NULL)
  1167. X509_gmtime_adj(X509_get_notAfter(ret),(long)60*60*24*days);//结束日期
  1168. else ASN1_UTCTIME_set_string(X509_get_notAfter(ret),(char *)enddate);
  1170. // X509_gmtime_adj(X509_get_notBefore(ret),0);//起始时间
  1171. // X509_gmtime_adj(X509_get_notAfter(ret),(long)60*60*24*days);//结束时间
  1173. if (!X509_set_subject_name(ret,name)) //主体 ---所有者
  1174. {
  1175. ok=0;
  1176. goto err;
  1177. }
  1179. pktmp = X509_REQ_get_pubkey(req);
  1180. i = X509_set_pubkey(ret,pktmp);//公钥
  1181. EVP_PKEY_free(pktmp);
  1182. if (!i) 
  1183. {
  1184. ok = 0;
  1185. goto err;
  1186. }
  1188. //加入req自带扩展信息，生成REQ文件时候加入的
  1189. if (!copy_extensions(ret, req, EXT_COPY_ALL))
  1190. {
  1191. strcpy("加入自带扩展信息失败",outMsg);
  1192. goto err;
  1193. }
  1195. //CRL签名、仅仅加密、仅仅解密
  1197. if(kusage && strlen(kusage))
  1198. Add_ExtCert(ret,ret, NID_key_usage, kusage);
  1200. AddExtCert(ret,px509,pCertExt);
  1202. if(ekusage && strlen(ekusage))
  1203. Add_ExtCert(ret,ret,NID_ext_key_usage,ekusage);
  1205. /*
  1206. Application keyUsage  Values 
  1207. SSL Client digitalSignature 
  1208. SSL Server keyEncipherment 
  1209. S/MIME Signing digitalSignature 
  1210. S/MIME Encryption keyEncipherment 
  1211. Certificate Signing keyCertSign 
  1212. Object Signing digitalSignature */
  1215. //加入自定义信息end
  1216. X509V3_EXT_cleanup();//cleanup the extension code if any custom extensions have been added
  1217. OBJ_cleanup();
  1218. if (!X509_sign(ret,pkey,dgst))//加入签名，签名算法
  1219. {
  1220. ok=0;
  1221. goto err;
  1222. }
  1223. ok=1;
  1224. err:
  1225. if (CAname != NULL)
  1226. X509_NAME_free(CAname);
  1227. if (ok <= 0)
  1228. {
  1229. if (ret != NULL) X509_free(ret);
  1230. ret=NULL;
  1231. }
  1232. else
  1233. * xret = ret;
  1234. return(ok);
  1235. }
  1237. int certify(X509 **xret, X509_REQ *req, EVP_PKEY *pkey, 
  1238. X509 *px509,const EVP_MD *dgst,
  1239. const long serial, const char *startdate, const char *enddate, 
  1240. const int days,const char * KUSAGE,
  1241. const char * EKUSAGE,const stuCERTEXT * pCertExt,char * outMsg)
  1242. {//返回公钥证书，请求文件，根私钥，根公钥，
  1243. EVP_PKEY *pktmp=NULL;
  1244. int ok= -1,i=0;
  1245. if ((pktmp=X509_REQ_get_pubkey(req)) == NULL)//得到公钥
  1246. {
  1247. sprintf(outMsg,"error unpacking public keyn");
  1248. ok=0;
  1249. goto err;
  1250. }
  1251. i=X509_REQ_verify(req,pktmp);//证书请求里面有私要签名，这里验证一下，看此公钥主人是否持有私钥
  1252. EVP_PKEY_free(pktmp);
  1253. if (i < 0)
  1254. {
  1255. ok=0;
  1256. sprintf(outMsg,"Signature verification problems....n");
  1257. goto err;
  1258. }
  1259. if (i == 0)
  1260. {
  1261. ok=0;
  1262. sprintf(outMsg,"Signature did not match the certificate requestn");
  1263. goto err;
  1264. }
  1266. ok=do_body(xret,pkey,px509,dgst,serial,startdate, enddate,
  1267. days,req,KUSAGE,EKUSAGE,pCertExt,outMsg);
  1269. err:
  1270. return(ok);
  1271. }
  1274. BOOL MakeCert(const stuCertPair & RootPair/*根证书对*/,
  1275.   const long serial/*序列号*/,
  1276.   const char *enddate/*作废日期*/,
  1277.   const int days/*有效期*/, 
  1278.   const char * reqMem/*请求文件或内存*/,
  1279.   const int reqLen/*请求的长度,0-标示文件*/,
  1280.   const char * KUSAGE/*密钥用法*/,
  1281.   const char * EKUSAGE/*增强密钥用法*/,
  1282.   const stuCERTEXT * pCertExt,/*证书扩展*/
  1283.   char * outMem/*结果公钥文件*/,
  1284.   UINT * MemLen/*结果长度*/,
  1285.   char * outMsg/*操作结果*/,
  1286.   const int type/*结果类型DER,PEM*/)//通过证书请求，得到证书
  1287. {
  1288. int ret=1;
  1289. char * md=NULL;
  1290. EVP_PKEY *pkey=NULL;
  1291. X509 * px509=NULL;
  1292. X509_REQ *req=NULL;
  1293. X509 * x=NULL;
  1294. BIO * bcert=NULL,* reqbio=NULL;
  1295. int j;
  1296. const EVP_MD *dgst=NULL;
  1298. OpenSSL_add_all_algorithms();//加入签名算法
  1299. X509 * x509 = NULL;
  1301. if(reqLen == 0)//输入为磁盘文件
  1302. {
  1303. if((reqbio=BIO_new_file(reqMem, "r")) == NULL)
  1304. {
  1305. strcpy(outMsg,"找不到证书请求文件");
  1306. ret=0;
  1307. goto err;
  1308. }
  1309. }
  1310. else//输入为内存中文件
  1311. {
  1312. if((reqbio = BIO_new_mem_buf((void *)reqMem, reqLen)) == NULL)//只读类型
  1313. {
  1314. sprintf(outMsg,"Make Mem Bio Error");
  1315. ret=0;
  1316. goto err;
  1317. }
  1318. }
  1321. if ((req=PEM_read_bio_X509_REQ(reqbio,NULL,NULL,NULL)) == NULL)//PEM_read_X509_REQ 
  1322. {
  1323. BIO_reset(reqbio);
  1324. if ((req=d2i_X509_REQ_bio(reqbio,NULL)) == NULL)
  1325. {
  1326. sprintf(outMsg,"Error get certificate request");
  1327. ret=0;
  1328. goto err;
  1329. }
  1330. }
  1332. if(!CertPair2XE(RootPair,px509,pkey,outMsg))
  1333. {
  1334. ret = 0;
  1335. goto err;
  1336. }
  1338. md="sha1";//////////!!!!!!!!!!!!!!!!!////////////////////////////
  1339. if ((dgst=EVP_get_digestbyname(md)) == NULL)//return an EVP_MD structure when passed a digest name
  1340. {
  1341. sprintf(outMsg,"%s is an unsupported message digest typen",md);
  1342. ret = 0;
  1343. goto err;
  1344. }
  1345. j=certify(&x,req,pkey,px509,dgst,//公钥证书out，请求文件，根私钥，根公钥，
  1346. serial,"today",enddate,days,KUSAGE,EKUSAGE,pCertExt,outMsg);
  1347. if (j <= 0) 
  1348. {
  1349. ret=0;
  1350. goto err;
  1351. }
  1353. bcert = BIO_new(BIO_s_mem());
  1354. BIO_set_close(bcert, BIO_CLOSE); /*  BIO_free() free BUF_MEM  */
  1356. if (type==DER)
  1357. {
  1358. ret = i2d_X509_bio(bcert,x); 
  1359. }
  1360. else if(type==PEM)
  1361. {
  1362. ret = PEM_write_bio_X509(bcert,x);
  1363. }
  1365. //转换BIO->内存
  1366. if(ret)
  1367. {
  1368. ret = Bio2Mem(bcert, outMem, MemLen);
  1369. }
  1370. err:
  1371. if (reqbio != NULL) BIO_free(reqbio);
  1372. BIO_free_all(bcert);
  1373. EVP_PKEY_free(pkey);
  1374. X509_free(px509);
  1375. X509_free(x);
  1376. if (req != NULL) X509_REQ_free(req);
  1377. // EVP_cleanup();//frees all three stacks and sets their pointers to NULL ---- EVP_CIPHER
  1378. // CRYPTO_cleanup_all_ex_data();
  1379. return ret;
  1381. }
  1383. ///////////////////////// end ////////////////////////////////////////
  1384. BOOL DirectCert(const stuCertPair & RootPair/*根证书对*/,
  1385. const int bits/*[IN]*/,
  1386. const long serial/*[IN]序列号*/,
  1387. const char * enddate/*[IN]作废日期*/,
  1388. const int days/*[IN]有效期*/,
  1389. const char * priPwd /*私钥加密密码,IN*/,
  1390. const stuSUBJECT * sSUBJECT/*[IN]用户信息*/,
  1391. const char * friendlyName/*好记的名称*/,
  1392. const char * keyUsage/*密钥用法*/,
  1393. const char * ekeyUsage/*扩展密钥用法*/,
  1394. const stuCERTEXT * pCertExt,/*证书扩展结构*/
  1395. char * pCert/*[OUT]输出证书公钥*/,
  1396. UINT * certl/*[OUT]长度*/,
  1397. char * key/*[OUT]输出证书私钥*/,
  1398. UINT * keyl/*[OUT]长度*/,
  1399. char * p12/*[OUT]输出证书私钥*/,
  1400. UINT * p12l/*[OUT]长度*/,
  1401. char * outMsg/*[OUT]返回错误信息*/,
  1402. const int iType/*结果类型DER,PEM*/)
  1403. {
  1404. X509_REQ * req=NULL;
  1405. EVP_PKEY * pkey=NULL, * prkey=NULL;//证书私钥,//根私钥
  1406. X509 * px509=NULL,* x=NULL;//根公钥，证书公钥
  1407. int ret=1;
  1408. char * md=NULL;
  1409. int i=0,j=0,ok=0;
  1410. const EVP_MD *dgst=NULL;
  1412. OpenSSL_add_all_algorithms();//加入签名算法
  1414. if(!CertPair2XE(RootPair,px509,prkey,outMsg))
  1415. {
  1416. ret = 0;
  1417. goto err;
  1418. }
  1420. if(!mkReq(sSUBJECT,&req,&pkey, bits,outMsg))
  1421. {
  1422. sprintf(outMsg,"Make CertReq error");
  1423. ret = 0;
  1424. goto err;
  1425. }
  1427. md = "sha1";//////////!!!!!!!!!!!!!!!!!////////////////////////////
  1428. if ((dgst = EVP_get_digestbyname(md)) == NULL)//return an EVP_MD structure when passed a digest name
  1429. {
  1430. sprintf(outMsg,"%s is an unsupported message digest typen",md);
  1431. ret = 0;
  1432. goto err;
  1433. }
  1434. ok = certify(&x,req,prkey,px509,dgst,//公钥证书out，请求，根私钥，根公钥，
  1435. serial,"today",enddate,days,keyUsage,ekeyUsage,pCertExt,outMsg);
  1436. if (ok > 0) 
  1437. {
  1438. X5092Mem(x,iType,pCert,certl);
  1439. Key2Mem(pkey,iType,priPwd,key,keyl);
  1440. CreateMemPfx(x, pkey, priPwd, friendlyName, p12, p12l);
  1441. }
  1443. err:
  1444. EVP_PKEY_free(pkey);
  1445. EVP_PKEY_free(prkey);
  1446. X509_free(px509);
  1447. X509_free(x);
  1448. if (req != NULL) X509_REQ_free(req);
  1449. // EVP_cleanup();//frees all three stacks and sets their pointers to NULL ---- EVP_CIPHER
  1450. // CRYPTO_cleanup_all_ex_data();
  1451. return ret;
  1452. }
  1453. //////////////////////////////////////////////////////////////////////
  1454. ///////////////////////// begin //////////////////////////////////////
  1455. int Add_ExtCrl(X509_CRL *crl/*正被添加的证书*/,X509 * pRoot/*根证书（从中得到信息)*/, 
  1456.    const int iNid, const char *lpszValue)
  1457. {
  1458. X509V3_CTX ctx;
  1459. X509_EXTENSION *ex;
  1461. /* This sets the 'context' of the extensions. */
  1462. /* No configuration database */
  1463. // X509V3_set_ctx_nodb(&ctx);
  1464.     X509V3_set_ctx(&ctx, pRoot, NULL, NULL, crl, 0);
  1465. // issuerAltName  authorityKeyIdentifier
  1466. ex = X509V3_EXT_conf_nid(NULL, &ctx, iNid, (char *)lpszValue);
  1467. if (!ex)
  1468. return 0;
  1469. X509_CRL_add_ext(crl,ex,-1);
  1470. X509_EXTENSION_free(ex);
  1471. return 1;
  1472. }
  1475. BOOL MakeCrl(const stuCertPair & RootPair/*根证书对*/,
  1476.  const stuREVOKE * Head/*作废链表*/,
  1477.  const PNewCrlMem NewCrlMem/*回调函数*/,
  1478.  char *& outCrl,
  1479.  int * crll,
  1480.  char * outfile/*crl文件*/,
  1481.  char * outMsg/*操作结果*/)
  1482. {
  1483. X509_CRL_INFO *ci = NULL;
  1484. X509_CRL *crl = NULL;
  1485. int ret = 1,
  1486. i = 0;
  1487. char *key = NULL;
  1488. char *md = NULL;
  1489. EVP_PKEY *pkey = NULL;
  1490. X509 *px509 = NULL;
  1491. BIO *in = NULL,
  1492. *out = NULL;
  1493. const EVP_MD *dgst = NULL;
  1494. X509_REVOKED *r = NULL;
  1495. long crldays = 30;
  1496. long crlhours = 0;
  1497. // stuREVOKE * temp =NULL;
  1498. BIO * memcrl = NULL;
  1499. BUF_MEM *bptrcrl = NULL;
  1501. OpenSSL_add_all_algorithms();
  1503. if(!CertPair2XE(RootPair,px509,pkey,outMsg))
  1504. {
  1505. ret = 0;
  1506. goto err;
  1507. }
  1509. md="md5";//////////!!!!!!!!!!!!!!!!!////////////////////////////
  1510. if ((dgst=EVP_get_digestbyname(md)) == NULL)//return an EVP_MD structure when passed a digest name
  1511. {
  1512. sprintf(outMsg,"%s is an unsupported message digest typen",md);
  1513. ret = 0;
  1514. goto err;
  1515. }
  1517. if ((crl = X509_CRL_new()) == NULL)
  1518. {
  1519. ret = 0;
  1520. goto err;
  1521. }
  1522. ci = crl->crl;
  1523. X509_NAME_free(ci->issuer);
  1524. ci->issuer = X509_NAME_dup(px509->cert_info->subject);
  1525. if (ci->issuer == NULL)
  1526. {
  1527. ret = 0;
  1528. goto err;
  1529. }
  1530. X509_gmtime_adj(ci->lastUpdate,0);
  1531. if (ci->nextUpdate == NULL)
  1532. ci->nextUpdate=ASN1_UTCTIME_new();
  1533. X509_gmtime_adj(ci->nextUpdate,(crldays*24+crlhours)*60*60);
  1535. if(!ci->revoked)
  1536. ci->revoked = sk_X509_REVOKED_new_null();
  1539. while(Head!=NULL)//遍历链表
  1540. {
  1541. X509_REVOKED *r = NULL;
  1542.         BIGNUM *serial_bn = NULL;
  1543.         r = X509_REVOKED_new();
  1544. ASN1_TIME_set(r->revocationDate,Head->time);//时间
  1545. char index[100];
  1546.         BN_hex2bn(&serial_bn,itoa(Head->Index,index,10));//序号  -  leak BN_free
  1547.         ASN1_INTEGER *tmpser = BN_to_ASN1_INTEGER(serial_bn, r->serialNumber);
  1548. BN_free(serial_bn);
  1549.         sk_X509_REVOKED_push(ci->revoked,r);
  1550. Head=Head->Link;
  1551. }
  1553. // sk_X509_REVOKED_sort(ci->revoked);
  1554. for (i=0; i<sk_X509_REVOKED_num(ci->revoked); i++)
  1555. {
  1556. r=sk_X509_REVOKED_value(ci->revoked,i);
  1557. r->sequence=i;
  1558. }
  1560.     if (ci->version == NULL)
  1561.     if ((ci->version=ASN1_INTEGER_new()) == NULL)
  1562. {
  1563. ret = 0;
  1564. goto err;
  1565. }
  1566.     ASN1_INTEGER_set(ci->version,1);
  1567. // issuerAltName  authorityKeyIdentifier
  1568. Add_ExtCrl(crl,px509,NID_subject_alt_name,"DNS:hpxs,email:hpxs@hotmail.com,RID:1.2.3.4,URI:https://hpxs,IP:192.168.0.22");
  1569. Add_ExtCrl(crl,px509,NID_issuer_alt_name, "DNS:hpxs,email:hpxs@hotmail.com,RID:1.2.3.4,URI:https://hpxs,IP:192.168.0.22");
  1570. Add_ExtCrl(crl,px509,NID_authority_key_identifier, "keyid,issuer:always");
  1571. if (!X509_CRL_sign(crl,pkey,dgst))
  1572. {
  1573. ret = 0;
  1574. goto err;
  1575. }
  1576. if(NewCrlMem)//输出内存
  1577. {
  1578. memcrl= BIO_new(BIO_s_mem());
  1579. BIO_set_close(memcrl, BIO_CLOSE); /*  BIO_free() free BUF_MEM  */
  1580. PEM_write_bio_X509_CRL(memcrl,crl);
  1581. BIO_get_mem_ptr(memcrl, &bptrcrl);
  1582. *crll=bptrcrl->length;
  1583. outCrl=NewCrlMem(*crll);
  1584. memcpy(outCrl,bptrcrl->data,*crll);
  1585. }
  1586. if(outfile)//输出文件
  1587. {
  1588. out=BIO_new_file(outfile, "w");
  1589. if(out==NULL)
  1590. {
  1591. sprintf(outMsg,"%s is error",outfile);
  1592. ret = 0;
  1593. goto err;
  1594. }
  1595. PEM_write_bio_X509_CRL(out,crl);
  1596. }
  1598. X509V3_EXT_cleanup();//cleanup the extension code if any custom extensions have been added
  1599. OBJ_cleanup();
  1600. err:
  1601. if(out)
  1602. BIO_free_all(out);
  1603. if(memcrl)
  1604. BIO_free_all(memcrl);
  1605. if(in)
  1606. BIO_free(in);
  1607. if(pkey)
  1608. EVP_PKEY_free(pkey);
  1609. if(px509)
  1610. X509_free(px509);
  1611. if(crl)
  1612. X509_CRL_free(crl);
  1613. // EVP_cleanup();//frees all three stacks and sets their pointers to NULL ---- EVP_CIPHER
  1614. // CRYPTO_cleanup_all_ex_data();
  1615. if(ret==1)
  1616. strcpy(outMsg,"CRL制作成功");
  1617. return ret;
  1619. }
  1621. BOOL CertFormatConver(const char * buf/*文件内容或文件名称*/,
  1622.   const int len/*内存长度为0则buf为文件名*/,
  1623.   const char * pwd/*p12文件密码,或者解密私钥密码*/,
  1624.   char * pem/*输出内存*/,
  1625.   UINT * pOutLen,/*输入内存长度,输出实际输出的长度*/
  1626.   char * keyPwd,/*加密私钥密码,只在私钥时候起作用*/
  1627.   const int outformat,char * outMsg/*操作结果*/)
  1628. {
  1629. BOOL bRet = TRUE;
  1630. EVP_PKEY *key=NULL;
  1631. X509 *pCert=NULL;
  1632. BIO * biout=NULL;
  1633. int i=0;
  1634. //输出文件
  1635. if(pOutLen == 0) //表示输出为文件
  1636. {
  1637. if ((biout=BIO_new_file(pem, "w")) == NULL)
  1638. {
  1639. return FALSE;
  1640. }
  1641. }
  1642. //输出
  1643. else
  1644. {
  1645. biout = BIO_new(BIO_s_mem());
  1646. BIO_set_close(biout, BIO_CLOSE); 
  1647. }
  1649. pCert = LoadCert(buf,len,pwd,outMsg);//首先尝试公钥,pBioKey被改写
  1651. if(pCert)//输入文件为公钥文件
  1652. {
  1654. if  (outformat == DER)
  1655. i=i2d_X509_bio(biout,pCert);
  1656. else if (outformat == PEM)
  1657. {
  1658. // if (trustout) i=PEM_write_bio_X509_AUX(biout,x);
  1659. i=PEM_write_bio_X509(biout,pCert);
  1660. }
  1661. if(!i)//失败
  1662. strcpy(outMsg,"保存公钥失败");
  1663. else
  1664. strcpy(outMsg,"公钥证书格式转换成功");
  1665. }
  1666. else//输入文件为私钥文件
  1667. {
  1668. key=LoadKey(buf,len,pwd,outMsg);
  1669. if(!key) 
  1670. {
  1671. strcpy(outMsg,"不能识别的文件格式");
  1672. return FALSE;
  1673. }
  1674. if(outformat==PEM)
  1675. {
  1676. if(keyPwd == NULL || strlen(keyPwd) == 0)
  1677. PEM_write_bio_PrivateKey(biout, key, NULL, NULL, 0, 0, NULL); //私钥不加密
  1678. else
  1679. PEM_write_bio_PrivateKey(biout,key,EVP_des_ede3_cbc(),NULL,0,NULL, (void *)keyPwd); //私钥加密
  1680. }
  1681. if(outformat==DER)
  1682. {
  1683. if(NULL == keyPwd || strlen(keyPwd) == 0) //写入私钥
  1684. i2d_PrivateKey_bio(biout,key);//私钥未加密
  1685. else
  1686. {
  1687. //添加加密链
  1688. unsigned char keyl[EVP_MAX_KEY_LENGTH]="";//算法最长的KEY长度
  1689. unsigned char iv[EVP_MAX_IV_LENGTH]="";//算法最长的IV长度
  1690. BIO * bEnc = NULL;
  1691. if((bEnc = BIO_new(BIO_f_cipher())) != NULL)
  1692. {
  1693. const EVP_CIPHER * cipher = NULL;
  1694. cipher = EVP_des_ede3_cbc(); // 3DES-EDE-CBC 
  1695. if(EVP_BytesToKey(cipher,EVP_sha1(),NULL,(unsigned char *)keyPwd,
  1696. strlen(keyPwd),1,keyl,iv))
  1697. {
  1698. BIO_set_cipher(bEnc,cipher,keyl,iv, 1);//1-加密、0-解密
  1699. biout = BIO_push(bEnc, biout); 
  1700. i2d_PrivateKey_bio(biout,key);//私钥加密
  1701. BIO_flush(biout);
  1702. biout = BIO_pop(biout);
  1703. BIO_free(bEnc);
  1704. }
  1705. else
  1706. strcpy(outMsg,"初始化key or iv 失败,");
  1707. }
  1708. }
  1709. }
  1711. strcpy(outMsg,"私钥证书格式转换成功");
  1712. }
  1714. if(*pOutLen != 0) //表示输出为文件
  1715. {
  1716. Bio2Mem(biout, pem, pOutLen);
  1717. }
  1719. if (biout != NULL)
  1720. BIO_free_all(biout);
  1721. if(pCert)
  1722. X509_free(pCert);
  1723. if(key)
  1724. EVP_PKEY_free(key);
  1726. return TRUE;
  1727. }
  1729. //分解p12包
  1730. BOOL ParsePfx(const char * strP12/*包文件或内存*/,
  1731.   const UINT iP12Len/* 如果包为文件,则为0,否则为内存长度*/,
  1732.   const char * strPwdP12/*P12密码*/,
  1733.   const char * strCert/*公钥存放*/,
  1734.   const char * strkey/*私钥存放*/,
  1735.   const char * keyPwd/*私钥密码*/,
  1736.   const int outformat/*输出格式*/,
  1737.   char * outMsg/*返回结果*/)
  1738. {
  1739. BOOL bRet = TRUE;
  1740. EVP_PKEY * key = NULL;
  1741. X509 * pCert = NULL;
  1742. // STACK_OF(X509) *ca = NULL;
  1743. BIO * bio = NULL, 
  1744. * bioCert = NULL,
  1745. * bioKey = NULL;
  1746. PKCS12 * p12 = NULL;
  1747. int i = 0,
  1748. j = 0;
  1750. if(iP12Len == 0)//输入为磁盘文件
  1751. {
  1752. if((bio = BIO_new_file(strP12, "r")) == NULL)
  1753. {
  1754. strcpy(outMsg,"加载PFX文件错误");
  1755. bRet = FALSE;
  1756. goto err;
  1757. }
  1758. }
  1759. else//输入为内存中文件
  1760. {
  1761. if((bio = BIO_new_mem_buf((void *)strP12,iP12Len)) == NULL)//只读类型
  1762. {
  1763. sprintf(outMsg,"Make Mem Bio Error");
  1764. bRet = FALSE;
  1765. goto err;
  1766. }
  1767. }
  1769. OpenSSL_add_all_algorithms(); //不能去掉
  1770. p12 = d2i_PKCS12_bio(bio, NULL);
  1771. if (!PKCS12_parse(p12, strPwdP12, &key, &pCert/*PEM*/, /*&ca*/NULL)) 
  1772. {
  1773. strcpy(outMsg,"解析文件失败");
  1774. bRet = FALSE;
  1775. goto err;
  1776. }
  1778. //输出文件 - 可能不输出公钥
  1779. if (strCert != NULL && strlen(strCert) >0)
  1780. {
  1781. if((bioCert = BIO_new_file(strCert, "w")) == NULL)
  1782. {
  1783. bRet = FALSE;
  1784. goto err;
  1785. }
  1787. }
  1788. if (strkey!= NULL && strlen(strkey) >0 )
  1789. {
  1790. if((bioKey = BIO_new_file(strkey, "w")) == NULL)
  1791. {
  1792. bRet = FALSE;
  1793. goto err;
  1794. }
  1795. }
  1797. if(outformat == DER)
  1798. {
  1799. if(bioCert)
  1800. i = i2d_X509_bio(bioCert,pCert); //写入公钥
  1801. if(bioKey)
  1802. {
  1803. if(NULL == keyPwd || strlen(keyPwd) == 0) //写入私钥
  1804. i2d_PrivateKey_bio(bioKey,key);//私钥未加密
  1805. else
  1806. {
  1807. //添加加密链
  1808. unsigned char keyl[EVP_MAX_KEY_LENGTH]="";//算法最长的KEY长度
  1809. unsigned char iv[EVP_MAX_IV_LENGTH]="";//算法最长的IV长度
  1810. BIO * bEnc = NULL;
  1811. bEnc = BIO_new(BIO_f_cipher());
  1812. const EVP_CIPHER * cipher = NULL;
  1813. cipher = EVP_des_ede3_cbc(); // 3DES-EDE-CBC 
  1814. if(EVP_BytesToKey(cipher,EVP_sha1(),NULL,(unsigned char *)keyPwd,
  1815. strlen(keyPwd),1,keyl,iv))
  1816. {
  1817. BIO_set_cipher(bEnc,cipher,keyl,iv, 1);//1-加密、0-解密
  1818. bioKey = BIO_push(bEnc, bioKey); 
  1819. i2d_PrivateKey_bio(bioKey,key);//私钥加密
  1820. BIO_flush(bioKey);
  1821. bioKey = BIO_pop(bioKey);
  1822. BIO_free(bEnc);
  1823. }
  1824. else
  1825. {
  1826. strcpy(outMsg,"初始化key or iv 失败,");
  1827. bRet = FALSE;
  1828. goto err;
  1829. }
  1830. }
  1831. }
  1832. }
  1833. else if (outformat == PEM)
  1834. {
  1835. if(bioCert)
  1836. i=PEM_write_bio_X509(bioCert,pCert);
  1837. if(bioKey)
  1838. {
  1839. if(NULL == keyPwd || strlen(keyPwd) == 0)
  1840. j=PEM_write_bio_PrivateKey(bioKey, key, NULL, NULL, 0, 0, NULL);//私钥不加密
  1841. else
  1842. j=PEM_write_bio_PrivateKey(bioKey,key,EVP_des_ede3_cbc(),NULL,0,NULL, (void *)keyPwd); //私钥加密
  1843. }
  1844. }
  1846. err:
  1847. if (bio != NULL)
  1848. BIO_free(bio);
  1849. if (bioCert != NULL) 
  1850. BIO_free(bioCert);
  1851. if (bioKey != NULL) 
  1852. BIO_free_all(bioKey);
  1853. if(pCert)
  1854. X509_free(pCert);
  1855. if(key)
  1856. EVP_PKEY_free(key);
  1857. if(p12)
  1858. PKCS12_free(p12);
  1859. // EVP_cleanup();//frees all three stacks and sets their pointers to NULL ---- EVP_CIPHER
  1860. // CRYPTO_cleanup_all_ex_data();
  1861. if(bRet && i !=0 || j != 0)
  1862. {
  1863. return TRUE;
  1864. }
  1865. return FALSE;
  1866. }
  1869. //组合p12包
  1870. BOOL CreatePfx(char * StreamP12/*OUT包文件路径或内存区域*/,
  1871.    UINT & uP12Len,/*输入时候为用于保存结果的内存区域长度, 输出为实际P12内存的长度*/
  1872.    const char * P12EncPwd/*IN 用于加密P12的密码*/,
  1873.    const char * FriendName,/*IN 好记名称*/
  1874.    const char * StreamCert/*IN公钥*/,
  1875.    const UINT uCertLen,/*IN,公钥内存区域长度, 0 - 标示输入为磁盘文件*/
  1876.    const char * Streamkey/*IN私钥*/,
  1877.    const UINT uKeyLen,/*IN,私钥内存区域长度, 0 - 标示输入为磁盘文件*/
  1878.    const char * KeyDecPwd/*解密私钥密码*/,
  1879.    char * outMsg/*返回结果*/)
  1880. {
  1881. BOOL bRet = TRUE;
  1882. EVP_PKEY *key = NULL;
  1883. X509 *pCert = NULL;
  1884. PKCS12 * p12 = NULL;
  1885. int i=0;
  1887. //输出文件
  1888. BIO * biout = BIO_new(BIO_s_mem());
  1889. BIO_set_close(biout, BIO_CLOSE); 
  1891. pCert = LoadCert(StreamCert, uCertLen, "", outMsg);
  1892. if(!pCert) 
  1893. {
  1894. strcpy(outMsg,"加载公钥文件失败");
  1895. bRet = FALSE;
  1896. goto err;
  1897. }
  1899. key = LoadKey(Streamkey, uKeyLen, KeyDecPwd, outMsg);//私钥
  1900. if(!key) 
  1901. {
  1902. strcpy(outMsg,"加载私钥文件失败");
  1903. bRet = FALSE;
  1904. goto err;
  1905. }
  1907. OpenSSL_add_all_algorithms();
  1909. p12 = PKCS12_create(const_cast<char *>(P12EncPwd), const_cast<char *>(FriendName), key, pCert, NULL, 0,0,0,0,0);
  1910. if(!p12)
  1911. {
  1912. strcpy(outMsg,"创建p12结构失败");
  1913. bRet = FALSE;
  1914. goto err;
  1915. }
  1917. i2d_PKCS12_bio(biout, p12);
  1919. bRet = Bio2Mem(biout, StreamP12, &uP12Len);
  1921. err:
  1922. if(pCert)
  1923. X509_free(pCert);
  1924. if(key)
  1925. EVP_PKEY_free(key);
  1926. if (biout != NULL)
  1927. BIO_free(biout);
  1928. if(p12)
  1929. PKCS12_free(p12);
  1930. // EVP_cleanup();
  1931. return bRet;
  1932. }
  1934. //修改p12包密码
  1935. BOOL ChangePfxPwd(const char * strP12/*in老包文件*/,
  1936.    const char * strPwd/*IN原密码*/,
  1937.    const char * strPwd2/*IN新密码*/,
  1938.    const char * strOutP12/*in新包文件*/,
  1939.    char * outMsg/*返回结果*/)
  1940. {
  1941. BIO *bin = NULL;
  1942. BIO *biout = NULL;
  1943. EVP_PKEY *key = NULL;
  1944. X509 *pCert = NULL;
  1945. PKCS12 *p12 = NULL;
  1946. int len = 0,
  1947. wlen = 0;
  1949. BOOL bRet = TRUE;
  1952. OpenSSL_add_all_algorithms();
  1953. //输入文件 
  1954. if ((bin=BIO_new_file(strP12, "rw")) == NULL)
  1955. {
  1956. strcpy(outMsg,"加载PFX文件错误");
  1957. bRet = FALSE;
  1958. goto err;
  1959. }
  1960. p12 = d2i_PKCS12_bio(bin, NULL);
  1961. if (!p12) 
  1962. {
  1963. strcpy(outMsg,"加载包文件失败");
  1964. bRet = FALSE;
  1965. goto err;
  1966. }
  1967. if (!PKCS12_parse(p12, strPwd, &key, &pCert, NULL)) 
  1968. {
  1969. strcpy(outMsg,"解包失败");
  1970. bRet = FALSE;
  1971. goto err;
  1972. }
  1973. ///////////////////////////////////////
  1974. if(p12)
  1975. PKCS12_free(p12);
  1977. p12 = NULL;
  1979. p12 = PKCS12_create((char *)strPwd2,"MiniCA", key, pCert, NULL, 0,0,0,0,0);
  1980. if(!p12)
  1981. {
  1982. strcpy(outMsg,"创建p12结构失败");
  1983. bRet = FALSE;
  1984. goto err;
  1985. }
  1986. //输出文件
  1987. if ((biout = BIO_new_file(strP12, "w")) == NULL)
  1988. {
  1989. strcpy(outMsg,"创建输出文件失败");
  1990. bRet = FALSE;
  1991. goto err;
  1992. }
  1993. i2d_PKCS12_bio(biout, p12);
  1995. err:
  1996. if(p12)
  1997. PKCS12_free(p12);
  1998. if(pCert)
  1999. X509_free(pCert);
  2000. if(key)
  2001. EVP_PKEY_free(key);
  2002. if (bin)
  2003. BIO_free(bin);
  2004. if (biout)
  2005. BIO_free(biout);
  2006. // EVP_cleanup();//frees all three stacks and sets their pointers to NULL ---- EVP_CIPHER
  2007. return bRet;
  2008. }
  2010. //检验公钥、私钥是否配对
  2011. BOOL CertPairCheck(const char * pCert,
  2012.    const char * key,
  2013.    char * outMsg,
  2014.    const char * priPwd )//检验公钥、私钥是否配对
  2015. {
  2016. EVP_PKEY *pkey=NULL;
  2017. X509 *px509=NULL;
  2018. px509=LoadCert(pCert,0,"",outMsg);
  2019. if(px509==NULL)
  2020. {
  2021. strcpy(outMsg,"不能加载公钥文件");
  2022. return FALSE;
  2023. }
  2024. pkey=LoadKey(key,0,priPwd,outMsg);
  2025. if(pkey==NULL)
  2026. {
  2027. strcpy(outMsg,"不能加载私钥文件");
  2028. X509_free(px509);
  2029. return FALSE;
  2030. }
  2031. if(X509_check_private_key(px509,pkey))//匹配
  2032. {
  2033. X509_free(px509);
  2034. EVP_PKEY_free(pkey);
  2035. return TRUE;
  2036. }
  2037. else
  2038. {
  2039. strcpy(outMsg,"公私钥对不匹配");
  2040. X509_free(px509);
  2041. EVP_PKEY_free(pkey);
  2042. return FALSE;
  2043. }
  2045. }
  2047. int HexToTen(const char * pHex)
  2048. {
  2049.     DWORD dwHexNum=0;
  2050.     for (; *pHex!=0 ; pHex++)
  2051.     {
  2052.         dwHexNum *= 16;
  2053.         if ((*pHex>='0') && (*pHex<='9'))
  2054.             dwHexNum += *pHex-'0';
  2055.         else if ((*pHex>='a') && (*pHex<='f'))
  2056.             dwHexNum += *pHex-'a'+10;
  2057.         else if ((*pHex>='A') && (*pHex<='F'))
  2058.             dwHexNum += *pHex-'A'+10;
  2059.         else
  2060.             -1;
  2061.     }
  2062. return dwHexNum;
  2063. }
  2065. void Utf8ToAnsi(const UCHAR * lpsrc,const int srclen, LPSTR lpdst, int& dstlen)
  2066. {
  2067. WCHAR * Unicode;
  2068.     int len = MultiByteToWideChar ( CP_UTF8 , 0 ,(char*) lpsrc ,-1 ,NULL,0);
  2069.     Unicode = new WCHAR[len * sizeof(WCHAR)];
  2070.     MultiByteToWideChar ( CP_UTF8 , 0 ,( char * ) lpsrc, -1, Unicode , len );
  2071.     len = WideCharToMultiByte(CP_ACP,0,Unicode,-1,NULL,0,NULL,NULL);
  2072.     dstlen = WideCharToMultiByte (CP_ACP,0,Unicode,-1,lpdst,len,NULL,NULL);
  2073.     delete []Unicode;
  2074. }
  2078. /////////////////////////////////////////////////////////////////////////////
  2079. // 通过黑名单验证证书，验证通过返回真，否则返回假
  2080. BOOL CheckCertWithCrl(const char *pubCert,const int pubCertLen,
  2081.   const char *crlData,const int crlLen,char * outMsg)
  2082. {
  2083. BOOL bRet = TRUE;
  2084. int i = 0;
  2085. BOOL bf = TRUE;
  2086. int num;
  2087. ASN1_INTEGER *serial = NULL;
  2088. STACK_OF(X509_REVOKED) *revoked = NULL;
  2089. X509_REVOKED *rc;
  2090. X509_CRL * crl = NULL;
  2091. BIO * in=NULL;
  2093. X509 *x509 = LoadCert(pubCert,pubCertLen,NULL,outMsg);
  2094. if (x509 == NULL)
  2095. {
  2096. strcpy(outMsg,"加载证书失败");
  2097. bRet = FALSE;
  2098. goto end;
  2099. }
  2100. if(crlLen==0)
  2101. {
  2102. if((in=BIO_new_file(crlData, "r"))==NULL)
  2103. {
  2104. strcpy(outMsg,"Create File Error");
  2105. bRet = FALSE;
  2106. goto end;
  2107. }
  2108. }
  2109. else
  2110. {
  2111. if((in=BIO_new_mem_buf((void *)crlData,crlLen))== NULL)
  2112. {
  2113. strcpy(outMsg,"GlobalLock mem Error");
  2114. bRet = FALSE;
  2115. goto end;
  2116. }
  2117. }
  2118. crl = d2i_X509_CRL_bio(in,NULL); //DER 格式?
  2119. if(crl == NULL)
  2120. {
  2121. BIO_reset(in);//恢复bio
  2122. crl = PEM_read_bio_X509_CRL(in,NULL,NULL,NULL); //PEM格式?
  2123. }
  2124. if(crl == NULL)
  2125. {
  2126. strcpy(outMsg,"加载 crl 失败");
  2127. bRet = FALSE;
  2128. goto end;
  2129. }
  2130. revoked = crl->crl->revoked;
  2132.     
  2133. serial = X509_get_serialNumber(x509);
  2134. num = sk_X509_REVOKED_num(revoked);
  2135. for(i=0;i<num;i++)
  2136. {
  2137. rc=sk_X509_REVOKED_pop(revoked); //leak
  2138. if(ASN1_INTEGER_cmp(serial,rc->serialNumber)==0)
  2139. {
  2140. strcpy(outMsg,"证书已作废");
  2141. bf = FALSE;
  2142. }
  2143. X509_REVOKED_free(rc); //leak
  2144. }
  2145.     
  2146. end:
  2147. if(crl)
  2148. X509_CRL_free(crl);
  2149. if(x509)
  2150. X509_free(x509);
  2151. if(in)
  2152. BIO_free(in);
  2153. if(bRet)
  2154. {
  2155. if(bf)
  2156. strcpy(outMsg,"证书有效");
  2157. }
  2158. return bf;
  2159. }
  2160.     
  2161. /////////////////////////////////////////////////////////////////////////////
  2162. // 通过根证书验证证书ENGINE_load_private_key
  2163. BOOL CheckCertWithRoot(const char *pubCert,const int pubCertLen,
  2164.    const char *rootCert,const int rootCertLen,char * outMsg)
  2165. {
  2166. OpenSSL_add_all_algorithms();
  2167. BOOL bRet = TRUE;
  2168. EVP_PKEY * pcert = NULL;
  2169. X509 *pRoot = NULL;
  2170. int ret =0;
  2172. X509 *x509 = LoadCert(pubCert,pubCertLen,NULL,outMsg);
  2173. if (x509 == NULL)
  2174. {
  2175. strcpy(outMsg,"加载证书失败");
  2176. bRet =  FALSE;
  2177. goto end;
  2178. }
  2180. pRoot = LoadCert(rootCert,rootCertLen,NULL,outMsg);
  2181. if (pRoot == NULL)
  2182. {
  2183. strcpy(outMsg,"加载根证书失败");
  2184. bRet =  FALSE;
  2185. goto end;
  2186. }
  2187.     
  2188. pcert = X509_get_pubkey(pRoot);
  2189. if (pcert == NULL)
  2190. {
  2191. strcpy(outMsg,"读取根证书公钥信息失败");
  2192. bRet =  FALSE;
  2193. goto end;
  2194. }
  2196. ret = X509_verify(x509,pcert);
  2198. end:
  2199. if(pcert)
  2200. EVP_PKEY_free (pcert); 
  2201.     if(x509)
  2202. X509_free(x509);
  2203. if(pRoot)
  2204. X509_free(pRoot);
  2205. // EVP_cleanup();
  2206. if(bRet)
  2207. {
  2208. if(ret==1)
  2209. {
  2210. strcpy(outMsg,"证书与根证书匹配");
  2211. return TRUE;
  2212. }
  2213. else
  2214. {
  2215. strcpy(outMsg,"证书与根证书不匹配");
  2216. return FALSE;
  2217. }
  2218. }
  2219. else
  2220. return FALSE;
  2221. }
  2222.     
  2223. /////////////////////////////////////////////////////////////////////////////
  2224. // 检查证书有效期,在有效期内返回真，否则返回假
  2225. BOOL CheckCertLife(const char *pubCert,const int pubCertLen,char * outMsg)
  2226. {
  2227. X509 *x509 = LoadCert(pubCert,pubCertLen,NULL,outMsg);
  2228. if (x509 == NULL)
  2229. {
  2230. strcpy(outMsg,"加载证书失败");
  2231. return FALSE;
  2232. }
  2233. time_t ct;
  2234. time( &ct );
  2235. asn1_string_st *before=X509_get_notBefore(x509),
  2236. *after=X509_get_notAfter(x509);
  2237. ASN1_UTCTIME *be=ASN1_STRING_dup(before),
  2238. *af=ASN1_STRING_dup(after);
  2239. BOOL bf;
  2240. if(ASN1_UTCTIME_cmp_time_t(be,ct)>=0||ASN1_UTCTIME_cmp_time_t(af,ct)<=0)
  2241. {
  2242. strcpy(outMsg,"证书超出有效期");
  2243. bf = FALSE;
  2244. }
  2245. else
  2246. {
  2247. strcpy(outMsg,"证书有效");
  2248. bf = TRUE;
  2249. }
  2250. M_ASN1_UTCTIME_free(be);
  2251. M_ASN1_UTCTIME_free(af);
  2252. X509_free(x509);
  2253. return bf;
  2254. }
  2255.  
  2257. /*组合P7包*/
  2258. BOOL CreateP7b(std::list<std::string> * pCertList,
  2259.    const char * lpszCrl,
  2260.    const char * outP7b,
  2261.    const int outformat,
  2262.    char * outMsg/*返回结果*/)
  2263. {
  2264. int i = 0;
  2265. BIO *in = NULL,
  2266. *out = NULL;
  2267. PKCS7 *p7 = NULL;
  2268. PKCS7_SIGNED *p7s = NULL;
  2269. X509_CRL *crl = NULL;
  2270. STACK *certflst = NULL;
  2271. STACK_OF(X509_CRL) *crl_stack = NULL;
  2272. STACK_OF(X509) *cert_stack = NULL;
  2273. in = BIO_new(BIO_s_file());
  2274. if(lpszCrl && strlen(lpszCrl) != 0) //有黑名单文件
  2275. {
  2276. //加载CRL结构
  2277. if (BIO_read_filename(in,lpszCrl) <= 0)
  2278. {
  2279. sprintf(outMsg, "加载CRL%s失败", lpszCrl);
  2280. goto end;
  2281. }
  2282. crl = d2i_X509_CRL_bio(in,NULL); //DER 格式?
  2283. if(crl == NULL)
  2284. {
  2285. BIO_reset(in);//恢复bio
  2286. crl = PEM_read_bio_X509_CRL(in,NULL,NULL,NULL); //PEM格式?
  2287. }
  2288. }
  2289. if ((p7 = PKCS7_new()) == NULL) goto end;
  2290. if ((p7s = PKCS7_SIGNED_new()) == NULL) goto end;
  2291. p7->type = OBJ_nid2obj(NID_pkcs7_signed);
  2292. p7->d.sign = p7s;
  2293. p7s->contents->type = OBJ_nid2obj(NID_pkcs7_data);
  2295. if (!ASN1_INTEGER_set(p7s->version,1))
  2296. goto end;
  2297. if ((crl_stack=sk_X509_CRL_new_null()) == NULL)
  2298. goto end;
  2299. p7s->crl = crl_stack;
  2300. if (crl != NULL)
  2301. {
  2302. sk_X509_CRL_push(crl_stack,crl);
  2303. crl = NULL; /* now part of p7 for OPENSSL_freeing */
  2304. }
  2306. if ((cert_stack = sk_X509_new_null()) == NULL) goto end;
  2307. p7s->cert = cert_stack;
  2308. if(pCertList)
  2309. {
  2310. std::list<std::string>::const_iterator pos;
  2311. for(pos = pCertList->begin(); pos != pCertList->end(); ++pos)
  2312. {
  2313. std::string strCert = *pos;
  2314. X509 * pX509 = LoadCert(strCert.c_str(), 0, 0, outMsg);
  2315. if(pX509)
  2316. {
  2317. sk_X509_push(cert_stack, pX509);
  2318. }
  2319. }
  2320. }
  2321. out = BIO_new(BIO_s_file());
  2322. if (BIO_write_filename(out, const_cast<char *>(outP7b)) <= 0)
  2323. {
  2324. goto end;
  2325. }
  2327. if(outformat == DER)
  2328. i=i2d_PKCS7_bio(out,p7);
  2329. else if(outformat == PEM)
  2330. i=PEM_write_bio_PKCS7(out,p7);
  2332. end:
  2333. if (in != NULL) BIO_free(in);
  2334. if (out != NULL) BIO_free_all(out);
  2335. if (p7 != NULL) PKCS7_free(p7); //free cert_stack
  2336. if (crl != NULL) X509_CRL_free(crl);
  2337. return i;
  2338. }
  2341. /*分解P7包*/
  2342. BOOL ParseP7b(const char * lpszInP7b/*包文件或内存*/,
  2343.   const UINT iP12Len/* 如果包为文件,则为0,否则为内存长度*/,
  2344.   const int outformat/*输出格式*/,
  2345.   const char * lpszCert/*公钥存放*/,
  2346.   const char * lpszCrl/*CRL存放*/,
  2347.   const char * lpszOutP7b/*用于转换P7格式的输出文件名*/,
  2348.   char * outMsg/*返回结果*/)
  2349. {
  2350. PKCS7 *p7 = NULL;
  2351. int i,badops=0;
  2352. BIO *in = NULL,
  2353. *out = NULL;
  2354. int ret = 1;
  2355. STACK_OF(X509) *certs=NULL;
  2356. STACK_OF(X509_CRL) *crls=NULL;
  2358. in=BIO_new(BIO_s_file());
  2359. out=BIO_new(BIO_s_file());
  2360. if ((in == NULL) || (out == NULL))
  2361. {
  2362. ret = 0;
  2363.         goto end;
  2364.     }
  2366. if (BIO_read_filename(in, lpszInP7b) <= 0)
  2367. if (in == NULL)
  2368. {
  2369. sprintf(outMsg, "读取P7B%s失败", lpszInP7b);
  2370. ret = 0;
  2371. goto end;
  2372. }
  2374. p7 = d2i_PKCS7_bio(in,NULL);
  2375. if(!p7)
  2376. {
  2377. BIO_reset(in);//恢复bio
  2378. p7=PEM_read_bio_PKCS7(in,NULL,NULL,NULL);
  2379. }
  2380. if (p7 == NULL)
  2381. {
  2382. sprintf(outMsg, "加载P7B%s失败", lpszInP7b);
  2383. ret = 0;
  2384. goto end;
  2385. }
  2387. i=OBJ_obj2nid(p7->type);
  2388. switch (i)
  2389. {
  2390. case NID_pkcs7_signed:
  2391. certs=p7->d.sign->cert;
  2392. crls=p7->d.sign->crl;
  2393. break;
  2394. case NID_pkcs7_signedAndEnveloped:
  2395. certs=p7->d.signed_and_enveloped->cert;
  2396. crls=p7->d.signed_and_enveloped->crl;
  2397. break;
  2398. default:
  2399. break;
  2400. }
  2402. if (certs != NULL && lpszCert && strlen(lpszCert) !=0 )
  2403. {
  2404. X509 *x;
  2405. for (i=0; i<sk_X509_num(certs); i++)
  2406. {
  2407. BIO * bioCert = NULL;
  2408. char buf[256] = {0};
  2409. sprintf(buf, "%s-%d.Cer", lpszCert, i);
  2410. if((bioCert = BIO_new_file(buf, "w")) == NULL)
  2411. {
  2412. goto end;
  2413. ret = 0;
  2414. }
  2415. x = sk_X509_value(certs,i); //保存证书公钥
  2416. if (outformat == DER)
  2417. {
  2418. i2d_X509_bio(bioCert,x);
  2419. }
  2420. else
  2421. {
  2422. PEM_write_bio_X509(bioCert,x);
  2423. }
  2424. BIO_free(bioCert);
  2425. }
  2426. }
  2427. if (crls != NULL  && lpszCrl && strlen(lpszCrl) !=0 )
  2428. {
  2429. X509_CRL *crl;
  2431. for (i=0; i<sk_X509_CRL_num(crls); i++)
  2432. {
  2433. BIO * bioCrl = NULL;
  2434. char buf[256] = {0};
  2435. sprintf(buf, "%s-%d.Crl", lpszCrl, i);
  2436. if((bioCrl = BIO_new_file(buf, "w")) == NULL)
  2437. {
  2438. ret = 0;
  2439. goto end;
  2440. }
  2441. crl = sk_X509_CRL_value(crls,i);
  2442. PEM_write_bio_X509_CRL(bioCrl, crl);
  2443. BIO_free(bioCrl);
  2444. }
  2445. }
  2447. //转换P7格式
  2448. if(lpszOutP7b && strlen(lpszOutP7b) != 0)
  2449. {
  2450. if (BIO_write_filename(out, const_cast<char *>(lpszOutP7b)) <= 0)
  2451. {
  2452. ret = 0;
  2453. goto end;
  2454. }
  2456. if(outformat == DER)
  2457. i=i2d_PKCS7_bio(out,p7);
  2458. else
  2459. i=PEM_write_bio_PKCS7(out,p7);
  2460. if (!i)
  2461. {
  2462. sprintf(outMsg, "保存P7B%s失败", lpszOutP7b);
  2463. ret = 0;
  2464. goto end;
  2465. }
  2466. }
  2467. end:
  2468. if (p7 != NULL) PKCS7_free(p7);
  2469. if (in != NULL) BIO_free(in);
  2470. if (out != NULL) BIO_free_all(out);
  2471. return ret;
  2472. }
  2475. //转换证书到REQ
  2476. BOOL X5092Req(char * Cert/*公钥*/,int Certlen,char * Key/*私钥,用于签名公钥*/,int Keylen,char * Keypwd/*密码*/,
  2477.   char * outFile/*输出文件,req或者公钥证书*/,char * outMsg,/*操作结果*/
  2478.   char * Rootcert,/*根证书公钥*/int Rootlen,/*为0则certfile为磁盘文件，否则为内存区域*/
  2479.   char * Rootkey/*根证书私钥*/,int RKeylen,char * Pwd/*私钥密码*/)
  2480. {
  2481. X509_REQ * req = NULL;
  2482. EVP_PKEY * pkey = NULL,
  2483.      * prkey = NULL;//证书私钥,//根私钥
  2485. X509 * x509 = NULL,
  2486.  * x = NULL,
  2487.  * newx = NULL;//根公钥，证书公钥,新公钥证书
  2489. BIO * memcert = NULL, 
  2490. * memkey = NULL;//输出证书公私钥
  2492. BUF_MEM * bptrcert = NULL,
  2493.     * bptrkey = NULL;
  2495. char * md=NULL;
  2497. BOOL bReq = TRUE;//制作REQ还是CERT ,TRUE 为REQ
  2499. int i = 0,
  2500. j = 0,
  2501. ok = 0,
  2502. ret = 1;
  2504. const EVP_MD * dgst = NULL;
  2506. BIO * out = BIO_new_file(outFile, "w");
  2508. OpenSSL_add_all_algorithms();//加入签名算法
  2510. memcert= BIO_new(BIO_s_mem());
  2511. memkey= BIO_new(BIO_s_mem());
  2512. BIO_set_close(memcert, BIO_CLOSE); /*  BIO_free() free BUF_MEM  */
  2513. BIO_set_close(memkey, BIO_CLOSE); /*  BIO_free() free BUF_MEM  */
  2515. pkey = LoadKey(Key, Keylen, Keypwd, outMsg);//加载私钥
  2516. if (pkey == NULL)
  2517. {
  2518. ret = 0;
  2519. goto err;
  2520. }
  2522. x = LoadCert(Cert,Certlen,"",outMsg);//加载公钥
  2523. if (x == NULL)
  2524. {
  2525. ret = 0;
  2526. goto err;
  2527. }
  2529. if (!X509_check_private_key(x,pkey))
  2530. {
  2531. sprintf(outMsg,"CA certificate and CA private key do not matchn");
  2532. ret = 0;
  2533. goto err;
  2534. }
  2536. //得到公钥REQ
  2537. req = X509_to_X509_REQ(x,pkey,EVP_sha1());//EVP_md5
  2538. if (req == NULL)
  2539. {
  2540. strcpy(outMsg,"证书转换为REQ失败");
  2541. ret = 0;
  2542. goto err;
  2543. }
  2546. /* prkey = LoadKey(Rootkey,Keylen,Pwd,outMsg);//加载根私钥
  2547. if (prkey != NULL)
  2548. {
  2549. x509 = LoadCert(Rootcert,Rootlen,"",outMsg);
  2550. if (x509 != NULL)
  2551. {
  2552. if(X509_check_private_key(x509,prkey))//匹配
  2553. {
  2554. bReq = FALSE;//制作证书
  2555. }
  2556. else
  2557. sprintf(outMsg,"根证书公私钥对不匹配");
  2558. }
  2559. else
  2560. sprintf(outMsg,"不能加载根证书公钥");
  2561. }
  2562. else
  2563. sprintf(outMsg,"不能加载根证书私钥");
  2565. if(bReq)//REQ
  2566. {
  2567. PEM_write_bio_X509_REQ(out,rq);
  2568. }
  2569. else //证书
  2570. {
  2571. md="sha1";//////////!!!!!!!!!!!!!!!!!////////////////////////////
  2572. if ((dgst=EVP_get_digestbyname(md)) == NULL)//return an EVP_MD structure when passed a digest name
  2573. {
  2574. sprintf(outMsg,"%s is an unsupported message digest typen",md);
  2575. ret = 0;
  2576. goto err;
  2577. }
  2578. j=certify(&newx,req,prkey,x509,dgst,//公钥证书out，请求文件，根私钥，根公钥，
  2579. serial,"today",enddate,days,KUSAGE,EKUSAGE,outMsg);
  2580. if (j <= 0) 
  2581. {
  2582. ret=0;
  2583. goto err;
  2584. }
  2586. if(((bcert=BIO_new_file(outfile, "w"))== NULL))
  2587. {
  2588. strcpy(outMsg,"Create File Error");
  2589. goto err;
  2590. }
  2591. if (iType==DER)
  2592. {
  2593. i2d_X509_bio(bcert,x);
  2594. }
  2595. else if(iType==PEM)
  2596. {
  2597. PEM_write_bio_X509(bcert,x);
  2598. }
  2599. }
  2601. */
  2602. err:
  2603. return TRUE;
  2604. }
  2606. /*
  2608. 这是转换函数：  
  2609.            int            CodePageConvert(UINT  SrcCodePage,  LPCTSTR  pBuff,  int  iBuffLen,  UINT  DestCodePage,  char*  &lpCodePage)  
  2610.            {  
  2611.                        int  iWideCharCnt  =  ::MultiByteToWideChar(SrcCodePage,  0,  pBuff,  iBuffLen,  NULL,  0);  
  2612.                        LPWSTR  lpszWideChar  =  new  wchar_t[iWideCharCnt  +  1];  
  2613.                        memset(lpszWideChar,  0,  (iWideCharCnt  +  1)  *  sizeof(WCHAR));  
  2614.                        iWideCharCnt  =  MultiByteToWideChar(SrcCodePage,  0,  pBuff,  iBuffLen,  lpszWideChar,  iWideCharCnt);  
  2615.  
  2616.                        if(DestCodePage  ==  54936    
  2617.                                                &&  !IsValidCodePage(54936))  
  2618.                                    DestCodePage  =  936;  
  2619.  
  2620.                        int  iDestCnt  =  WideCharToMultiByte(DestCodePage,  0,  lpszWideChar,  iWideCharCnt,  NULL,  0,  NULL,  NULL);  
  2621.                        lpCodePage  =  new  char[iDestCnt  +  1];  
  2622.                        memset(lpCodePage,  0,  iDestCnt  +  1);  
  2623.                        iDestCnt  =  WideCharToMultiByte(DestCodePage,  0,  lpszWideChar,  iWideCharCnt,  lpCodePage,  iDestCnt,  NULL,  NULL);  
  2624.  
  2625.                        delete  []lpszWideChar;              
  2626.                        return  iDestCnt;  
  2627.            }  
  2628. 下面是调用方法：  
  2629.      utf-8  到  gbk  
  2630.            int  nLen  =  CodePageConvertUnix("UTF-8",_T("标准"),2,"GBK",lpOut);  
  2631.      gbk  到utf-8  
  2632. int  nLen  =  CodePageConvertUnix("UTF-8",_T("标准"),2,"GBK",lpOut); 
  2636.   //加入扩展信息
  2637. // Add_ExtCert(ret,ret,NID_basic_constraints, "critical,CA:FALSE,pathlen:1");
  2639. // Add_ExtCert(x,x,NID_basic_constraints, "critical,CA:TRUE,pathlen:1");
  2641. //主题密钥标示符---当发行者有多个签名密钥时
  2642. // Add_ExtCert(x,x,NID_subject_key_identifier, "hash");
  2643. //颁发机构密钥标示符
  2644. // Add_ExtCert(x,x,NID_authority_key_identifier, "keyid:always");
  2646. //
  2647. // Add_ExtCert(x,x,NID_certificate_policies, "serverAuth");
  2649. //主题备用名称,URL:http://my.url.here/、支持email  copy
  2650. // Add_ExtCert(x ,x, NID_subject_alt_name, "email:camgr@rog.majki.net,URI:altname:/mirabile/,URI:otherName://tygScaowlOmi,email:nc-glaserth@netcologne.de");
  2652. //加入自定义信息begin
  2653. /* int nid;
  2654. nid = OBJ_create("1.2.3.4.9", "Hpxs", "I love you!");
  2655. X509V3_EXT_add_alias(nid, NID_netscape_comment);
  2656. Add_ExtCert(x, nid, "I love you");
  2657. //加入自定义信息end
  2658. */
  2660.   
  2662. /* Lets add the extensions, if there are any 加入标准扩展*/