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

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

CA认证

开发平台：

Visual C++

Evp.cpp：源码内容
  1. // Evp.cpp: implementation of the CEvp class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "minica.h"
  7. #include "Evp.h"
  8. #include <io.h>
  9. #include "CertKey.h"
  10. #include "rc.h"
  11. #ifdef _DEBUG
  12. #undef THIS_FILE
  13. static char THIS_FILE[]=__FILE__;
  14. #define new DEBUG_NEW
  15. #endif
  17. //////////////////////////////////////////////////////////////////////
  18. // Construction/Destruction
  19. //////////////////////////////////////////////////////////////////////
  20. CProgressCtrlST *  CEvp::m_pProgress = NULL;
  21. const UINT BUFLEN = 1024;
  22. const float HUNDRED = 100.0;
  23. CEvp::CEvp()
  24. {
  26. }
  28. CEvp::~CEvp()
  29. {
  31. }
  33. //函数功能:对称加解密
  34. //参数: [in] cpName - 算法名称
  35. // [in] inStream - 输入文件或内存区域
  36. // [in] inLen - 输入长度,0->标示输入为文件
  37. // [in] outStream - 输出为文件名或内存区域
  38. // [in,out] outLen - 输入为结果内存长度,输出为实际加密结果长度
  39. // [in] char * pwd - 用于初始iv的密码
  40. // [in] type - 1-加密、0-解密
  41. // [out] outMsg - 输出信息
  42. BOOL CEvp::Crypt(const char * cpName, const char * inStream, UINT inLen, 
  43.    char * outStream, UINT & outLen, char * pwd, const int type,
  44.    char * outMsg)
  45. {
  46. unsigned char inbuf[BUFLEN]="";
  47. unsigned char outbuf[BUFLEN + EVP_MAX_BLOCK_LENGTH]="";//所有算法最长的块长度。
  48. unsigned char key[EVP_MAX_KEY_LENGTH]="";//算法最长的KEY长度
  49.     unsigned char iv[EVP_MAX_IV_LENGTH]="";//算法最长的IV长度
  50. int infilelen=0, outlen=0;
  51. BOOL ret=true;
  52. const EVP_CIPHER *cipher=NULL;
  53. EVP_CIPHER_CTX ctx;
  54. memset(&ctx,0,sizeof(ctx));
  55. long fileLen=0;//文件长度
  56. long finishLen=0;//完成长度
  57. int uMaxMem = outLen; //可能为负数,不能用UINT
  58. outLen = 0;
  59. UINT len = 0;
  61. FILE * outfd=NULL,* infd=NULL;
  63. if(inLen==0&&(strlen(inStream)==0||strlen(outStream)==0))
  64. {
  65. strcpy(outMsg,"NO specify input or output file");
  66. return FALSE;
  67. }
  69. if(inLen==0)//文件
  70. {
  71. if ((infd = fopen (inStream, "rb")) == NULL)//原文
  72. {
  73. strcpy(outMsg,"open input file error");
  74. return FALSE;
  75. }
  76. fileLen = filelength(fileno(infd));//得到文件长度
  77. if ((outfd = fopen (outStream, "wb")) == NULL)//密文
  78. {
  79. strcpy(outMsg,"open output file error");
  80. fclose(infd);
  81. return FALSE;
  82. }
  83. }
  85. OpenSSL_add_all_algorithms();//add digests   and ciphers
  86. cipher=EVP_get_cipherbyname(cpName);
  87. if(cipher==NULL)
  88. {
  89. sprintf(outMsg,"Unknown cipher name %sn",cpName);
  90. ret=FALSE;
  91. goto err;
  92. }
  94. //表示產生的 key 是給哪一種 cipher 用的
  95. //過程中所使用的 hash 演算法,
  96. //用來加密的 salt，至少為八個 bytes，否則必須NULL,
  97. //重覆幾次 hashing 的動作，愈多次愈花時間，但相對地也愈安全
  98. if(!EVP_BytesToKey(cipher,EVP_md5(),NULL,(unsigned char *)pwd,
  99. strlen(pwd),1,key,iv))
  100. {
  101. strcpy(outMsg,"Crypt初始化key or iv 失败");
  102. ret=FALSE;
  103. goto err;
  104. }
  106. EVP_CIPHER_CTX_init(&ctx);//初始化一个EVP_CIPHER_CTX结构体
  108. //type为1，则加密；如果type为0，则解密；如果type是－1，则不改变数据
  109. if(!EVP_CipherInit_ex(&ctx, cipher, NULL/*NULL使用缺省的实现算法*/,key,iv,type))//初始化
  110. {
  111. strcpy(outMsg,"Crypt初始化加解密结构体失败");
  112. ret=FALSE;
  113. goto err;
  114. }
  116. //该函数进行加密算法结构EVP_CIPHER_CTX密钥长度的设置。
  117. //如果算法是一个密钥长度固定的算法，
  118. //那么如果设置的密钥长度跟它固定的长度不一致，就会产生错误。
  119. // EVP_CIPHER_CTX_set_key_length(&ctx, 10); 
  120. // EVP_CipherInit_ex(&ctx, NULL, NULL, key, iv, type);
  121. if(inLen==0)//文件
  122. {
  123. for(;;)
  124. {                       
  125. infilelen = fread(inbuf, sizeof(char), BUFLEN, infd);
  126. if(infilelen <= 0) break;
  127. if(!EVP_CipherUpdate(&ctx, outbuf, &outlen, inbuf, infilelen))//中間過程 
  128. {
  129. strcpy(outMsg,"Crypt中间过程错误");
  130. ret=FALSE;
  131. goto err;
  132. }
  133. fwrite(outbuf, sizeof(char), outlen, outfd);
  134. finishLen+=infilelen;
  135. DrawProg(finishLen*HUNDRED/fileLen);
  136. }               
  137. if(!EVP_CipherFinal_ex(&ctx, outbuf, &outlen))    //最終步驟-处理最后（Final）的一段数据
  138. {                       
  139. strcpy(outMsg,"Crypt最终过程错误"); 
  140. ret=FALSE;
  141. goto err;
  142. }               
  143. fwrite(outbuf, sizeof(char), outlen, outfd);
  144. }
  145. else//内存
  146. {
  147. fileLen = inLen;
  149. for(UINT i=0;;i++)
  150. {
  151. //每次1024
  152. len=(inLen>BUFLEN)?BUFLEN:inLen;
  153. inLen-=len;
  154. if(!EVP_CipherUpdate(&ctx, outbuf, &outlen,(UCHAR *)(inStream+i*BUFLEN), len))//中間過程
  155. {
  156. strcpy(outMsg,"Crypt中间过程错误");
  157. ret=FALSE;
  158. goto err;
  159. }
  160. //计算缓冲区长度是否能容纳结果数据集
  161. uMaxMem -= outlen;
  162. if(uMaxMem < 0)
  163. {
  164. strcpy(outMsg,"输出缓冲过小,不能容纳操作结果"); 
  165. ret = FALSE;
  166. goto err;
  167. }
  169. memcpy(outStream + outLen, outbuf, outlen);//拷贝到调用函数
  170. outLen+=outlen;
  171. if(inLen <= 0) break;          
  172. }
  174. if(!EVP_CipherFinal_ex(&ctx, outbuf, &outlen)) //最終步驟-处理最后（Final）的一段数据
  175. {   
  176. strcpy(outMsg,"Crypt最终过程错误"); 
  177. ret=FALSE;
  178. goto err;
  179. }               
  181. uMaxMem -= outlen;
  182. if(uMaxMem < 0)
  183. {
  184. strcpy(outMsg,"输出缓冲过小,不能容纳操作结果"); 
  185. ret = FALSE;
  186. goto err;
  187. }
  188. memcpy(outStream + outLen,outbuf,outlen);//拷贝到调用函数
  189. outLen += outlen;
  191. }
  192. err:
  193. if(infd!=NULL)
  194. fclose(infd);
  195. if(outfd!=NULL)
  196. fclose(outfd);
  197. if(ctx.cipher) EVP_CIPHER_CTX_cleanup(&ctx); //清除所有信息释放内存
  198. EVP_cleanup();//frees all three stacks and sets their pointers to NULL ---- EVP_CIPHER
  199. return ret;
  200. }
  202. /*消息摘要*/ 
  203. BOOL CEvp::Digest(const char * mdname/*摘要算法*/,const char * infoin/*输入,文件或内存*/,
  204. UINT inlen/*文件时候为0,内存为长度*/,unsigned char * md_value/*返回摘要*/,
  205. unsigned int * md_len/*摘要长度*/, char * outMsg)
  206. {
  208. const EVP_MD *md=NULL;
  209. char inbuf[BUFLEN]="";
  210. UINT len=0;
  211. BOOL ret=true;
  212. EVP_MD_CTX md_ctx;
  213. memset(&md_ctx,0,sizeof(md_ctx));
  214. FILE * infd=NULL;
  215. long fileLen=0;//文件长度
  216. long finishLen=0;//完成长度
  218. if(strlen(infoin)==0)
  219. {
  220. strcpy(outMsg,"NO specify input");
  221. return FALSE;
  222. }
  224. if(inlen==0)//输入为文件
  225. {
  226. if ((infd = fopen (infoin, "rb")) == NULL)//原文
  227. {
  228. strcpy(outMsg,"open input file error");
  229. return FALSE;
  230. }
  231. fileLen=filelength(fileno(infd));//得到文件长度
  232. }
  235. //使EVP_Digest系列函数支持所有有效的信息摘要算法
  236. OpenSSL_add_all_digests();
  237.     
  238. //根据输入的信息摘要函数的名字得到相应的EVP_MD算法结构
  239. md = EVP_get_digestbyname(mdname);  
  240. if(!md) 
  241. {
  242. sprintf(outMsg,"Unknown message digest %s",mdname);
  243. ret=FALSE;
  244. goto err;
  245. }
  246. //初始化信息摘要结构md_ctx。
  247. EVP_MD_CTX_init(&md_ctx);
  249. //使用md的算法结构设置mdctx结构，impl为NULL，即使用缺省实现的算法（openssl本身提供的信息摘要算法）
  250. if(!EVP_DigestInit_ex(&md_ctx, md, NULL/*impl*/))
  251. {
  252. strcpy(outMsg,"Digest初始化算法结构错误");
  253. ret=FALSE;
  254. goto err;
  255. }
  257. //信息摘要运算
  258. if(inlen==0)//输入为文件
  259. {
  260. for(;;)
  261. {
  262. len = fread(inbuf, 1, BUFLEN, infd);
  263. if(len <= 0) break;          
  264. if(!EVP_DigestUpdate(&md_ctx, inbuf, len))
  265. {
  266. strcpy(outMsg,"Digest中间过程错误");
  267. ret=FALSE;
  268. goto err;
  269. }
  270. finishLen+=len;
  271. DrawProg(finishLen * HUNDRED / fileLen);
  272. }
  273. }
  274. else//内存区域
  275. {
  276. for(UINT i=0;;i++)
  277. {
  278. //每次BUFLEN
  279. len=(inlen>BUFLEN)?BUFLEN:inlen;
  280. inlen-=len;
  281. if(!EVP_DigestUpdate(&md_ctx, (infoin+i*BUFLEN), len))
  282. {
  283. strcpy(outMsg,"Digest中间过程错误");
  284. ret=FALSE;
  285. goto err;
  286. }
  287. if(inlen <= 0) break;          
  288. }
  289. }
  290. //完成信息摘要计算过程，将完成的摘要信息存储在md_value里面,长度信息存储在md_len里面
  291. if(!EVP_DigestFinal_ex(&md_ctx, md_value, md_len))
  292. {
  293. strcpy(outMsg,"Digest最终过程错误");
  294. ret=FALSE;
  295. }
  297. err:
  298. //使用该函数释放mdctx占用的资源，如果使用_ex系列函数，这是必须调用的。
  299. if(infd!=NULL)
  300. fclose(infd);
  301. if(md_ctx.digest) EVP_MD_CTX_cleanup(&md_ctx);
  302. EVP_cleanup();
  303. return ret;
  304. }
  306. /*数字签名*/
  307. BOOL CEvp::Sign(const char * key/*私钥*/,const int keylen/*0-内存私钥*/,const char * pwd,
  308. const char * mdname/*签名算法*/,const char * infoin/*输入文件*/,
  309. int inlen,/*输入长度,0->内存*/char * infout/*输出*/,
  310. UINT & outlen/*输出长度,输入文件时=0*/,char * outMsg)
  311. {
  312. BOOL ret=true;
  313. unsigned char * sig_buf=NULL;
  314. unsigned int sig_len,len=0;
  315. unsigned char inbuf[BUFLEN]="";
  316. EVP_PKEY * pkey=NULL;
  317. const EVP_MD *md=NULL;
  318. EVP_MD_CTX md_ctx;
  319. memset(&md_ctx,0,sizeof(md_ctx));
  320. BIO *in=NULL;
  321. FILE * outfd=NULL,* infd=NULL;
  322. long fileLen=0;//文件长度
  323. long finishLen=0;//完成长度
  325. BOOL bType=inlen;
  327. if(bType==0&&(strlen(infoin)==0||strlen(infout)==0))//输入文件时候
  328. {
  329. strcpy(outMsg,"NO specify input or output file");
  330. return FALSE;
  331. }
  332. if(bType==0)//文件
  333. {
  334. if ((infd = fopen (infoin, "rb")) == NULL)//原文
  335. {
  336. strcpy(outMsg,"open input file error");
  337. return FALSE;
  338. }
  339. if ((outfd = fopen (infout, "wb")) == NULL)//密文
  340. {
  341. strcpy(outMsg,"open output file error");
  342. fclose(infd);
  343. return FALSE;
  344. }
  345. fileLen=filelength(fileno(infd));//得到文件长度
  346. }
  348. OpenSSL_add_all_digests();
  350. pkey = CCertKey::LoadKey((char *)key,keylen,(char *)pwd,outMsg);
  351. if (pkey == NULL)
  352. { 
  353. ret=FALSE;
  354. goto err;
  355. }
  357. /* Do the signature */
  358. md = EVP_get_digestbyname(mdname);
  359. if(!md)
  360. {
  361. sprintf(outMsg,"Unknown message digest %s",mdname);
  362. ret=FALSE;
  363. goto err;
  364. }
  365. EVP_MD_CTX_init(&md_ctx);
  366. if(!EVP_SignInit_ex(&md_ctx,md,NULL))
  367. {
  368. strcpy(outMsg,"初始化算法结构出错");
  369. ret=FALSE;
  370. goto err;
  371. }
  373. if(bType==0)//文件
  374. {
  375. for(;;)
  376. {
  377. len = fread(inbuf, sizeof(char), BUFLEN, infd);
  378. if(len <= 0) break;
  379. if(!EVP_SignUpdate(&md_ctx, inbuf, len))
  380. {
  381. sprintf(outMsg,"中间过程出错");
  382. ret=FALSE;
  383. goto err;
  384. }
  385. finishLen+=len;
  386. DrawProg(finishLen*HUNDRED/fileLen);
  387. }
  388. }
  390. else//内存区域
  391. {
  392. for(UINT i=0;;i++)
  393. {
  394. //每次BUFLEN
  395. len=(inlen>BUFLEN)?BUFLEN:inlen;
  396. inlen-=len;
  397. if(!EVP_SignUpdate(&md_ctx, (infoin+i*BUFLEN), len))
  398. {
  399. strcpy(outMsg,"中间过程错误");
  400. ret=FALSE;
  401. goto err;
  402. }
  403. if(inlen <= 0) break;          
  404. }
  405. }
  407. sig_len =EVP_PKEY_size(pkey);
  408. sig_buf=new unsigned char[sig_len];
  410. // 簽名後的結果，必須是個夠大視 private key 長度不同而不同，可以 EVP_PKEY_size() 取得
  411. if(!EVP_SignFinal (&md_ctx, sig_buf, &sig_len, pkey))
  412. {
  413. sprintf(outMsg,"最终过程出错");
  414. ret=FALSE;
  415. }
  416. else if(bType!=0)//内存
  417. {
  418. memcpy(infout,sig_buf,sig_len);
  419. outlen=sig_len;
  420. }
  422. if(outfd!=NULL)
  423. {
  424. fwrite(sig_buf,sizeof(char),sig_len,outfd);
  425. outlen=0;
  426. }
  428. err:
  429. if(infd!=NULL)
  430. fclose(infd);
  431. if(outfd!=NULL)
  432. fclose(outfd);
  433. BIO_free(in);
  435. if(pkey) EVP_PKEY_free (pkey);
  436. if(md_ctx.digest) EVP_MD_CTX_cleanup(&md_ctx);
  437. delete [] sig_buf;
  438. EVP_cleanup();
  439. return ret;
  440. }
  442. /*数字签名验证*/
  443. BOOL CEvp::VerifySign(const char * cert/*公钥*/,const int certlen,
  444.   const char * pwd,const char * mdname/*签名算法*/,
  445.   const char * infoin,/*原始信息*/ 
  446.   int inlen/*输入长度0->文件*/,char * sign/*签名结果*/,
  447.   char * outMsg)
  448. {
  449. const EVP_MD *md=NULL;
  450. unsigned char inbuf[BUFLEN]="";
  451. BOOL ret=true;
  452. unsigned char * sig_buf=NULL;
  453. unsigned int sig_len,len=0;
  454. FILE * outfd=NULL,* infd=NULL;
  455. long fileLen=0;//文件长度
  456. long finishLen=0;//完成长度
  457. X509 * x509=NULL;
  458. EVP_PKEY * pcert=NULL;
  459. EVP_MD_CTX md_ctx;
  460. memset(&md_ctx,0,sizeof(md_ctx));
  462. BOOL bType=inlen;
  464. if(bType==0&&(strlen(infoin)==0||strlen(sign)==0))//输入文件时候
  465. {
  466. strcpy(outMsg,"NO specify input file");
  467. return FALSE;
  468. }
  469. if(bType==0)//内存
  470. {
  471. if ((infd = fopen (infoin, "rb")) == NULL)//原文
  472. {
  473. strcpy(outMsg,"open input file error");
  474. return FALSE;
  475. }
  476. if ((outfd = fopen (sign, "rb")) == NULL)//密文
  477. {
  478. strcpy(outMsg,"open output file error");
  479. fclose(infd);
  480. return FALSE;
  481. }
  482. fileLen=filelength(fileno(infd));//得到文件长度
  483. }
  485. OpenSSL_add_all_digests();
  486. x509 = CCertKey::LoadCert((char *)cert,certlen,(char *)pwd,outMsg);
  487. if (x509 == NULL)
  488. {
  489. ret=FALSE;
  490. goto err;
  491. }
  492. pcert=X509_get_pubkey(x509);
  493. if (pcert == NULL)
  494. {
  495. sprintf(outMsg,"Read Public Key Failed!");
  496. ret=FALSE;
  497. goto err;
  498. }
  500. md = EVP_get_digestbyname(mdname);  
  501. if(!md) 
  502. {
  503. sprintf(outMsg,"Unknown message digest %s",mdname);
  504. ret=FALSE;
  505. goto err;
  506. }
  508. EVP_MD_CTX_init(&md_ctx);
  509. if(!EVP_VerifyInit_ex(&md_ctx,md,NULL))
  510. {
  511. strcpy(outMsg,"初始化算法结构出错");
  512. ret=FALSE;
  513. goto err;
  514. }
  516. if(bType==0)//文件
  517. {
  518. for(;;)
  519. {
  520. len = fread(inbuf, sizeof(char), BUFLEN, infd);                  
  521. if(len <= 0) break;
  522. if(!EVP_VerifyUpdate (&md_ctx, inbuf, len))
  523. {
  524. strcpy(outMsg,"中间过程出错");
  525. ret=FALSE;
  526. goto err;
  527. }
  528. finishLen+=len;
  529. DrawProg(finishLen*HUNDRED/fileLen);
  530. }
  531. }
  533. else//内存区域
  534. {
  535. for(UINT i=0;;i++)
  536. {
  537. //每次BUFLEN
  538. len=(inlen>BUFLEN)?BUFLEN:inlen;
  539. inlen-=len;
  540. if(!EVP_VerifyUpdate(&md_ctx, (infoin+i*BUFLEN), len))
  541. {
  542. strcpy(outMsg,"中间过程错误");
  543. ret=FALSE;
  544. goto err;
  545. }
  546. if(inlen <= 0) break;          
  547. }
  548. }
  550. sig_len =EVP_PKEY_size(pcert);//这里应该改动
  551. sig_buf=new unsigned char[sig_len];
  552. if(bType==0)//文件
  553. {
  554. fread(sig_buf,sizeof(char),sig_len,outfd);
  555. }
  556. else
  557. {
  558. memcpy(sig_buf,sign,sig_len);
  559. }
  560. if(!EVP_VerifyFinal (&md_ctx, sig_buf, sig_len, pcert))
  561. {
  562. strcpy(outMsg,"最终过程出错");
  563. ret=FALSE;
  564. }
  565. err:
  566. if(infd!=NULL)
  567. fclose(infd);
  568. if(outfd!=NULL)
  569. fclose(outfd);
  570. if(pcert) EVP_PKEY_free (pcert);
  571. if(x509) X509_free(x509);
  572. if(md_ctx.digest) EVP_MD_CTX_cleanup(&md_ctx);
  573. delete [] sig_buf;
  574. EVP_cleanup();
  575. return ret;
  576. }
  579. /*数字信封 - 多证书 */
  580. //文件结构
  581. // 加密后重要信息长度 DWORD
  582. // 加密后重要信息长度 CRC校验码 UINT
  583. // 加密后重要信息
  584. // -------------------------------重要信息开始--------------------------------
  585. // 公钥个数n
  586. // n个
  587. // 公钥加密的对称密钥长度
  588. // 公钥加密的对称密钥内容
  589. // 向量IV
  590. // -------------------------------重要信息结束--------------------------------
  591. // 加密文件内容
  593. BOOL CEvp::Seal(stuCertLink * pCERT/*[in]合法用户公钥链*/,
  594.   char * cpname/*算法名称*/,
  595.   char * filein/*输入文件*/, 
  596.   char * fileout/*输出文件*/,
  597.   char * outMsg)//写信
  598. {
  599. //对随机数播种（seeded）。
  600. UCHAR iv[EVP_MAX_IV_LENGTH]="";
  601. UCHAR * ekey [128]; 
  602. EVP_PKEY * pubKey[128];
  603. int ekeylen[128];
  604. UCHAR buf[BUFLEN]="";
  605. UCHAR ebuf[BUFLEN + EVP_MAX_BLOCK_LENGTH]="";
  606. int readlen=0;
  607. int ebuflen = 0;
  608. EVP_CIPHER_CTX eCtx;
  609. memset(&eCtx,0,sizeof(eCtx));
  610. int index = 0;
  612. const EVP_CIPHER *cipher=NULL;
  613. BOOL ret=true;
  614. FILE *outfd,*infd;
  615.   DWORD fileLen=0;//文件长度
  616. DWORD finishLen=0;//完成长度
  617. UINT uCrc16 = 0; //加密后重要信息CRC码
  618. DWORD dOutLen = 0;//内存文件长度
  619. BYTE * pOut = NULL; //内存文件缓冲区
  620. DWORD dFileInfoLen = 0;
  622. if(strlen(filein)==0||strlen(fileout)==0)
  623. {
  624. strcpy(outMsg,"NO specify input or output file");
  625. return false;
  626. }
  628. if ((infd = fopen (filein, "rb")) == NULL)//原文
  629. {
  630. strcpy(outMsg,"open input file error");
  631. return false;
  632. }
  633. if ((outfd = fopen (fileout, "wb")) == NULL)//密文
  634. {
  635. strcpy(outMsg,"open output file error");
  636. fclose(infd);
  637. return false;
  638. }
  640. //加载加密公钥
  641. HRSRC hRsrc = FindResource(NULL,MAKEINTRESOURCE(IDR_FILE_CERT),"CERT");
  642. DWORD lenCert = SizeofResource(NULL, hRsrc); 
  643. HGLOBAL hgCert = LoadResource(NULL,hRsrc);
  644. LPSTR lpCert = (LPSTR)LockResource(hgCert);
  647. CMemFile MemFile; //用于存放重要信息的内存文件
  649. DWORD dInLen = 0;
  650. BYTE * pIn = NULL; //用于MemFile.Dectch();
  653. fileLen = filelength(fileno(infd));//得到文件长度
  655. OpenSSL_add_all_algorithms();
  657. int nCountCert = 0; //证书个数
  659. for(stuCertLink * temp = pCERT; temp != NULL; temp=temp->Link, nCountCert++)
  660. {
  661. X509 * pX509 = NULL;
  662. pX509 = CCertKey::LoadCert(temp->pCert, temp->CertLen, NULL, outMsg);
  663.     if(pX509)
  664. {
  665. pubKey[nCountCert] = X509_get_pubkey(pX509);
  666. if (pubKey[nCountCert] == NULL)
  667. {
  668. sprintf(outMsg,"Read Public Key Failed!");
  669. ret=false;
  670. goto err;
  671. }
  672. ekey[nCountCert] = new unsigned char[EVP_PKEY_size(pubKey[nCountCert])];
  673. X509_free(pX509);
  674. }
  675. else
  676. {
  677. sprintf(outMsg,"加载第%d个证书失败",nCountCert);
  678. ret = false;
  679. goto err;
  680. }
  681. }
  683. cipher = EVP_get_cipherbyname(cpname);
  684. if(cipher==NULL)
  685. {
  686. sprintf(outMsg,"Unknown cipher name %sn",cpname);
  687. ret=false;
  688. goto err;
  689. }
  691. if(!EVP_SealInit(&eCtx,cipher,
  692. ekey,
  693. ekeylen,//存放所有 ek 長度
  694. iv,//自动生成
  695. pubKey,//加密 ek 用的 public key(s)
  696. nCountCert))
  697. {
  698. ret=false;
  699. goto err;
  700. }
  702. MemFile.Write(&nCountCert, sizeof(int)); //1 - 写入公钥个数
  704. //fwrite((char*)&nCountCert,sizeof(char), sizeof(int),outfd);//写入公钥个数
  705. for(index = 0; index < nCountCert; index++)
  706. {
  707. MemFile.Write(&ekeylen[index], sizeof(int));
  708. // fwrite(&ekeylen[index],sizeof(char), sizeof(int),outfd);//写入n个经公钥加密的对称密钥长度
  709. MemFile.Write(ekey[index], ekeylen[index]);
  710. // fwrite(ekey[index],sizeof(char) ,ekeylen[index],outfd);//写入n个经公钥加密的对称密钥
  711. }
  713. MemFile.Write(iv, sizeof(iv));
  714. // fwrite(iv,sizeof(char),sizeof(iv),outfd);//写入向量
  717. //构造加密结果 长度+1 内存
  718. dFileInfoLen = CEvp::GetEncLen(lpCert, lenCert, MemFile.GetLength());
  720. dOutLen = dFileInfoLen + 1;
  721. pOut = new BYTE[dOutLen];
  723. dInLen = MemFile.GetLength();
  724. pIn = MemFile.Detach();
  726. //加密重要信息
  727. if(!CEvp::RSAPubEnc((BYTE *)lpCert, lenCert, "", pIn, 
  728. dInLen, pOut, dOutLen, outMsg))
  729. {
  730. //加密失败
  731. ret=false;
  732. goto err;
  733. }
  735. //得到加密后长度的CRC校验
  736. if(!CRC::GetCrc16((char*)&dOutLen, sizeof(DWORD), uCrc16))
  737. {
  738. //加密失败
  739. ret=false;
  740. goto err;
  741. }
  743. //写入加密后重要信息长度和CRC校验和加密后重要信息内容
  744. fwrite(&dOutLen,sizeof(char),sizeof(DWORD),outfd);
  746. fwrite(&uCrc16,sizeof(char),sizeof(UINT),outfd);
  748. fwrite(pOut,sizeof(char),dOutLen,outfd);
  752. for(;;)
  753. {
  754. readlen = fread(buf, sizeof(char),sizeof(buf),infd);
  756. if (readlen <= 0)
  757. {
  758. break;
  759. }
  761. if(!EVP_SealUpdate(&eCtx, ebuf, &ebuflen, buf, readlen))
  762. {
  763. strcpy(outMsg,"中间过程出错");
  764. ret=false;
  765. goto err;
  766. }
  767. fwrite(ebuf,sizeof(char),ebuflen,outfd);
  768. finishLen += readlen;
  769. DrawProg(finishLen*HUNDRED/fileLen);//前半程
  771. }
  773. if(!EVP_SealFinal(&eCtx, ebuf, &ebuflen))
  774. {
  775. strcpy(outMsg,"最终过程出错");
  776. ret=false;
  777. goto err;
  778. }
  780. fwrite(ebuf, sizeof(char), ebuflen,outfd);
  782. err:
  783. fclose(infd);
  784. fclose(outfd);
  786. free(pIn);
  788. delete [] pOut;
  790. for(int i = 0;i< nCountCert;i++)
  791. {
  792. if(pubKey[i]) EVP_PKEY_free(pubKey[i]);
  793. if(ekey[i]) delete [] ekey[i];
  794. }
  795. if(eCtx.cipher) EVP_CIPHER_CTX_cleanup(&eCtx);
  796. EVP_cleanup();
  797. return ret;
  798. }
  800. /*拆封数字信封*/
  801. BOOL CEvp::OpenSeal(char * key/*私钥*/, int keylen, char * pwd/*私钥密码*/, 
  802.    char * cpname/*算法名称*/, char * filein/*输入文件*/, 
  803.    char * fileout/*输出文件*/,char * outMsg)
  804. {
  805. unsigned char buf[BUFLEN]="";
  806. unsigned char ebuf[BUFLEN + EVP_MAX_BLOCK_LENGTH]="";
  807. unsigned char iv[EVP_MAX_IV_LENGTH]="";
  808. const EVP_CIPHER *cipher=NULL;
  809. int ebuflen=0,readlen=0;
  810. bool ret=true;
  811. FILE *outfd,*infd;
  812. DWORD fileLen=0;//文件长度
  813. DWORD finishLen=0;//完成长度
  814. int nCountCert = 0; //公钥个数
  815. int index = 0;
  816. UCHAR * ekey [128] = {0}; 
  817. int ekeylen[128];
  818. BOOL bInit = FALSE;//是否初始化成功
  819. DWORD dFileInfoLen = 0;//加密后重要信息长度
  820. UINT uCrc16 = 0; //加密后重要信息CRC码
  823. EVP_CIPHER_CTX eCtx;
  824. memset(&eCtx,0,sizeof(eCtx));
  825. EVP_PKEY * pkey=NULL;
  827. if(strlen(filein)==0||strlen(fileout)==0)
  828. {
  829. strcpy(outMsg,"NO specify input or output file");
  830. return false;
  831. }
  833.     if ((infd = fopen (filein, "rb")) == NULL)//原文
  834. {
  835. strcpy(outMsg,"open input file error");
  836. return false;
  837. }
  838. if ((outfd = fopen (fileout, "wb")) == NULL)//密文
  839. {
  840. strcpy(outMsg,"open output file error");
  841. fclose(infd);
  842. return false;
  843. }
  844. fileLen = filelength(fileno(infd));//得到文件长度
  846. OpenSSL_add_all_algorithms();//digests   and ciphers
  847. /* Read private key */
  848. pkey = CCertKey::LoadKey(key,keylen,pwd,outMsg);
  849. if (pkey == NULL)
  850. { 
  851. fclose(infd);
  852. fclose(outfd);
  853. return FALSE;
  854. }
  856. //得到重要信息长度和CRC校验码
  857. readlen = fread(&dFileInfoLen, sizeof(char),sizeof(DWORD),infd);
  858. finishLen += readlen;
  860. readlen = fread(&uCrc16, sizeof(char),sizeof(UINT),infd);
  861. finishLen += readlen;
  863. if(!CRC::CheckCrc((char *)&dFileInfoLen, sizeof(DWORD), uCrc16))
  864. {
  865. strcpy(outMsg ,"文件头CRC校验错误");
  866. return FALSE;
  867. }
  869. //开辟缓冲区,容纳加密后的重要文件信息
  870. BYTE * pIn = NULL;
  871. pIn = new BYTE[dFileInfoLen + 1];
  872. readlen = fread(pIn, sizeof(char), dFileInfoLen, infd);
  873. finishLen += readlen;
  875. HRSRC hRsrc = FindResource(NULL,MAKEINTRESOURCE(IDR_FILE_KEY),"CERT");
  876. DWORD lenKey = SizeofResource(NULL, hRsrc); 
  877. HGLOBAL hgKey = LoadResource(NULL,hRsrc);
  878. LPSTR lpKey = (LPSTR)LockResource(hgKey);
  880. DWORD dOutLen = dFileInfoLen;
  882. //开辟缓冲区,容纳加密后的信息体
  883. BYTE * pOut = NULL;
  884. pOut = new BYTE[dOutLen];
  885. if(!CEvp::RSAPrivDec((BYTE *)lpKey, lenKey, pwd, pIn, 
  886. dFileInfoLen, pOut, dOutLen, outMsg))
  887. {
  888. //解密失败
  889. strcpy(outMsg ,"重要信息解密失败");
  890. fclose(infd);
  891. fclose(outfd);
  892. delete [] pIn;
  893. delete [] pOut;
  894. return FALSE;
  895. }
  897. CMemFile MemFile;
  898. MemFile.Attach(pOut, dOutLen);
  900. //首先是公钥个数
  901. MemFile.Read(&nCountCert, sizeof(int));
  903. for(index = 0; index < nCountCert; index++)
  904. {
  905. MemFile.Read(&ekeylen[index], sizeof(int));
  906. ekey[index] = new unsigned char[ekeylen[index]];
  907. MemFile.Read(ekey[index], ekeylen[index]);
  908. }
  910. MemFile.Read(iv, sizeof(iv));
  912. MemFile.Close();
  914. //输入文件已经偏移到加密后的文件
  916. cipher = EVP_get_cipherbyname(cpname);
  918. if(cipher == NULL)
  919. {
  920. sprintf(outMsg,"Unknown cipher name %sn",cpname);
  921. ret = false;
  922. goto err;
  923. }
  925. for(index = 0; index<nCountCert; index++)
  926. {
  927. if (ekeylen[index] != EVP_PKEY_size(pkey))
  928. {
  929. continue;
  930. }
  932. if(EVP_OpenInit(&eCtx,cipher, ekey[index],ekeylen[index],iv,pkey))
  933. {
  934. bInit = TRUE;
  935. break;
  936. }
  937. }
  938. if(!bInit)
  939. {
  940. sprintf(outMsg,"指定证书不能解密此文件");
  941. ret=false;
  942. goto err;
  943. }
  944. for(;;)
  945. {
  946. readlen = fread(buf, sizeof(char),sizeof(buf),infd);
  947. if (readlen <= 0)
  948. {
  949. break;
  950. }
  952. if(!EVP_OpenUpdate(&eCtx, ebuf, &ebuflen, buf, readlen))
  953. {
  954. sprintf(outMsg,"中间过程错误");
  955. ret=false;
  956. goto err;
  957. }
  958. fwrite(ebuf,sizeof(char),ebuflen,outfd);
  959. finishLen += readlen;
  960. DrawProg(finishLen*HUNDRED/fileLen);
  961. }
  963. if(!EVP_OpenFinal(&eCtx, ebuf, &ebuflen))
  964. {
  965. sprintf(outMsg,"最终过程错误");
  966. ret=false;
  967. goto err;
  968. }
  970. fwrite(ebuf, sizeof(char), ebuflen,outfd);
  971. err:
  972. fclose(infd);
  973. fclose(outfd);
  975. delete [] pIn;
  976. delete [] pOut;
  978. for(int i = 0;i< index;i++)
  979. {
  980. if(ekey[i]) delete ekey[i];
  981. }
  982. if(pkey) EVP_PKEY_free(pkey);
  983. if((&eCtx)->cipher) EVP_CIPHER_CTX_cleanup(&eCtx);
  985. EVP_cleanup();
  987. return ret;
  988. }
  990. //公钥加密
  991. BOOL CEvp::RSAPubEnc(const BYTE * pCertBuf/*[in]公钥*/,const UINT nCertLen/*[in]公钥长度*/,
  992. const char * pPwd/*[in]公钥密码,只针对PFX包文件*/,const BYTE * pInStream/*[in]输入文件或内存*/,
  993. DWORD nInlen/*[in]数据长度,为0表示pInStream为文件名*/,BYTE * pOutStream/*[out]加密后的数据*/,
  994. DWORD & nOutlen/*[in,out]in为0时候表示pOutStream为文件名,out加密后数据长度*/,
  995. char * OperMsg/*[out]返回操作错误信息*/)
  996. {
  997. UINT iblock_size = 0, //输入块长度
  998. oblock_size = 0; //输出块长度
  999. unsigned char * bufin=NULL,
  1000.   * bufout=NULL;
  1001. int inlen = 0,
  1002. outlen = 0;
  1003. BOOL ret = TRUE;
  1004. long fileLen = 0;//文件长度
  1005. long finishLen = 0;//完成长度
  1006. X509 * x509 = NULL;
  1007. EVP_PKEY * pcert = NULL;
  1008. RSA * rsa = NULL;
  1009. int memtemplen = 0; //输出内存偏移
  1010. UINT len = 0; //输入内存剩余长度
  1012. int uMaxMem = nOutlen; //可能为负数,不能用UINT
  1015. BOOL bOutType = FALSE;//输出文件类型,内存-FALSE,文件-TRUE;
  1017. if(nOutlen == 0) 
  1018. {
  1019. //检测文件名是否能够打开,以防pOutStream为文件
  1020. bOutType = TRUE;
  1021. }
  1023. FILE * outfd = NULL,
  1024. * infd = NULL;
  1026. if(nInlen == 0)//输入为文件
  1027. {
  1028. if(pInStream == NULL || strlen((char*)pInStream)==0)
  1029. {
  1030. strcpy(OperMsg,"未指定输入文件");
  1031. return FALSE;
  1032. }
  1034. if ((infd = fopen ((char *)pInStream, "rb")) == NULL)//原文
  1035. {
  1036. sprintf(OperMsg,"打开文件%s失败",pInStream);
  1037. return FALSE;
  1038. }
  1039. fileLen = filelength(fileno(infd));//得到文件长度
  1040. }
  1041. else
  1042. fileLen = nInlen;
  1044. if(nOutlen == 0)//输出为文件
  1045. {
  1046. if(pOutStream == NULL || strlen((char*)pOutStream)==0)
  1047. {
  1048. strcpy(OperMsg,"未指定输出文件");
  1049. return FALSE;
  1050. }
  1052. if ((outfd = fopen ((char *)pOutStream, "wb")) == NULL)//原文
  1053. {
  1054. sprintf(OperMsg,"打开文件%s失败",pOutStream);
  1055. return FALSE;
  1056. }
  1057. }
  1059. x509 = CCertKey::LoadCert((char *)pCertBuf,nCertLen,(char *)pPwd,OperMsg);
  1060. if (x509 == NULL)
  1061. {
  1062. ret = FALSE;
  1063. goto err;
  1064. }
  1066. pcert = X509_get_pubkey(x509);
  1067. if(pcert==NULL)
  1068. {
  1069. sprintf(OperMsg,"取得公钥密钥失败");
  1070. ret = FALSE;
  1071. goto err;
  1072. }
  1074.     if (!(rsa = EVP_PKEY_get1_RSA(pcert)))
  1075. {
  1076. sprintf(OperMsg,"取得RSA密钥失败");
  1077. ret=FALSE;
  1078. goto err;
  1079.     }
  1081. iblock_size = BN_num_bytes(rsa->n) - 11;//预加密长度,117
  1082. oblock_size = BN_num_bytes(rsa->n);//加密后长度,128
  1083. bufin = new unsigned char[iblock_size];
  1084. memset(bufin,0,iblock_size);
  1085. bufout = new unsigned char[oblock_size];
  1086. memset(bufout,0,oblock_size);
  1087. if(nInlen==0)//文件
  1088. {
  1089. for(;;)
  1090. {
  1091. inlen = fread(bufin,sizeof(char),iblock_size,infd);
  1092. if(!inlen)
  1093. break;
  1094. outlen = RSA_public_encrypt(inlen,bufin,bufout,rsa,RSA_PKCS1_PADDING);
  1095. if (outlen == -1)//加密后资料长度
  1096. {
  1097. sprintf(OperMsg,"RSA加密失败");
  1098. ret=FALSE;
  1099. goto err;
  1100. }
  1101. if(bOutType)
  1102. {
  1103. fwrite(bufout,sizeof(char),outlen,outfd);
  1104. memset(bufout,0,oblock_size);
  1105. }
  1106. else
  1107. {
  1108. uMaxMem -= outlen; //剩余缓冲大小
  1109. if(uMaxMem < 0)
  1110. {
  1111. strcpy(OperMsg, "输出缓冲过小,不能容纳操作结果"); 
  1112. ret = FALSE;
  1113. goto err;
  1114. }
  1115. memcpy(pOutStream + memtemplen, bufout, outlen);//拷贝到调用函数
  1116. memtemplen += outlen;
  1117. }
  1118. finishLen += inlen;
  1119. DrawProg(finishLen*HUNDRED/fileLen);
  1120. }
  1121. nOutlen = memtemplen;
  1122. }
  1124. else//内存区域
  1125. {
  1126. for(UINT i=0;;i++)
  1127. {
  1128. //每次 iblock_size 或实际长度
  1129. len = (nInlen>iblock_size)?iblock_size:nInlen;//内存区域长度
  1130. nInlen -= len;
  1131. outlen=RSA_public_encrypt(len,(UCHAR *)(pInStream+i*iblock_size),bufout,rsa,RSA_PKCS1_PADDING);
  1132. if (outlen == -1)//加密后资料长度
  1133. {
  1134. sprintf(OperMsg,"RSA加密失败");
  1135. ret = FALSE;
  1136. goto err;
  1137. }
  1138. if(bOutType)
  1139. {
  1140. fwrite(bufout,sizeof(char),outlen,outfd);
  1141. memset(bufout,0,outlen);
  1142. }
  1143. else
  1144. {
  1145. uMaxMem -= outlen; //剩余缓冲大小
  1146. if(uMaxMem < 0)
  1147. {
  1148. strcpy(OperMsg, "输出缓冲过小,不能容纳操作结果"); 
  1149. ret = FALSE;
  1150. goto err;
  1151. }
  1153. memcpy(pOutStream + memtemplen,bufout,outlen);//拷贝到调用函数
  1154. memtemplen += outlen;
  1155. }
  1156. finishLen += len;
  1157. DrawProg(finishLen*HUNDRED/fileLen);
  1158. if(nInlen <= 0) break;     
  1160. }
  1161. nOutlen = memtemplen;
  1162. }
  1163. err:
  1164. if(infd!=NULL)
  1165. fclose(infd);
  1166. if(outfd!=NULL)
  1167. fclose(outfd);
  1168. if(pcert) EVP_PKEY_free(pcert);
  1169.     if(x509) X509_free(x509);
  1170. if(rsa) RSA_free(rsa);
  1171. delete [] bufin;
  1172. delete [] bufout;
  1173. return ret;
  1174. }
  1177. //私钥解密
  1178. BOOL CEvp::RSAPrivDec(const BYTE * pKeyBuf/*[in]私钥*/,const UINT nKeyLen/*[in]私钥长度*/,
  1179. const char * pPwd/*[in]私钥密码*/,const BYTE * pInStream/*[in]输入文件或内存*/,
  1180. DWORD nInlen/*[in]数据长度,为0表示pInStream为文件名*/,BYTE * pOutStream/*[out]解密后的数据*/,
  1181. DWORD & nOutlen/*[in,out]in为0时候表示pOutStream为文件名,out解密后数据长度*/,
  1182.     char * OperMsg/*[out]返回操作错误信息*/)
  1183. {
  1184. unsigned char * bufin = NULL,
  1185.   * bufout = NULL;
  1186. UINT iblock_size = 0,
  1187. oblock_size = 0,
  1188. outlen = 0,
  1189. inlen = 0;
  1190. BOOL ret = true;
  1191. long fileLen = 0;//文件长度
  1192. long finishLen = 0;//完成长度
  1193. RSA * rsa = NULL;
  1194. EVP_PKEY * pkey = NULL;
  1195. FILE * outfd = NULL,
  1196.  * infd = NULL;
  1197. int memtemplen = 0; //输出内存偏移
  1198. UINT len = 0; //输入内存剩余长度
  1200. int uMaxMem = nOutlen; //可能为负数,不能用UINT
  1203. BOOL bOutType = FALSE;//输出文件类型,内存-FALSE,文件-TRUE;
  1204. if(nOutlen == 0) bOutType = TRUE;
  1206. if(nInlen == 0)//输入为文件
  1207. {
  1208. if(pInStream == NULL || strlen((char*)pInStream)==0)
  1209. {
  1210. strcpy(OperMsg,"未指定输入文件");
  1211. return FALSE;
  1212. }
  1214. if ((infd = fopen ((char *)pInStream, "rb")) == NULL)//原文
  1215. {
  1216. sprintf(OperMsg,"打开文件%s失败",pInStream);
  1217. return FALSE;
  1218. }
  1219. fileLen = filelength(fileno(infd));//得到文件长度
  1220. }
  1221. else
  1222. fileLen = nInlen;
  1224. if(nOutlen == 0)//输出为文件
  1225. {
  1226. if(pOutStream == NULL || strlen((char*)pOutStream)==0)
  1227. {
  1228. strcpy(OperMsg,"未指定输出文件");
  1229. return FALSE;
  1230. }
  1232. if ((outfd = fopen ((char *)pOutStream, "wb")) == NULL)//原文
  1233. {
  1234. sprintf(OperMsg,"打开文件%s失败",pOutStream);
  1235. return FALSE;
  1236. }
  1237. }
  1239. pkey=CCertKey::LoadKey((char *)pKeyBuf,nKeyLen,(char *)pPwd,OperMsg);
  1240. if (pkey == NULL)
  1241. { 
  1242. // sprintf(OperMsg,"取得私钥密钥失败");
  1243. ret=FALSE;
  1244. goto err;
  1245. }
  1247.     if (!(rsa = EVP_PKEY_get1_RSA(pkey)))
  1248. {
  1249. sprintf(OperMsg,"取得RSA密钥失败");
  1250. ret=FALSE;
  1251. goto err;
  1252.     }
  1255. iblock_size = BN_num_bytes(rsa->n);//预接密长度 128
  1256. oblock_size = BN_num_bytes(rsa->n) - 11;//杰密后长度 117
  1257. bufin=new unsigned char[iblock_size];
  1258. bufout=new unsigned char[oblock_size];
  1259. if(nInlen == 0)//文件
  1260. {
  1261. for(;;)
  1262. {
  1263. inlen=fread(bufin,sizeof(char),iblock_size,infd);
  1264. if(!inlen)
  1265. break;//117,128
  1266. outlen = RSA_private_decrypt(inlen,bufin,bufout,rsa,RSA_PKCS1_PADDING);
  1267. if (outlen == -1)//加密后资料长度
  1268. {
  1269. sprintf(OperMsg,"RSA解密失败");
  1270. ret=FALSE;
  1271. goto err;
  1272. }
  1273. if(bOutType)
  1274. {
  1275. fwrite(bufout,sizeof(char),outlen,outfd);
  1276. memset(bufout,0,oblock_size);
  1277. }
  1278. else
  1279. {
  1280. uMaxMem -= outlen; //剩余缓冲大小
  1281. if(uMaxMem < 0)
  1282. {
  1283. strcpy(OperMsg, "输出缓冲过小,不能容纳操作结果"); 
  1284. ret = FALSE;
  1285. goto err;
  1286. }
  1288. memcpy(pOutStream + memtemplen,bufout,outlen);//拷贝到调用函数
  1289. memtemplen += outlen;
  1290. }
  1291. finishLen+=inlen;
  1292. DrawProg(finishLen*HUNDRED/fileLen);
  1293. }
  1294. nOutlen = memtemplen;
  1295. }
  1296. else//内存
  1297. {
  1298. for(UINT i=0;;i++)
  1299. {
  1300. //每次 iblock_size 或实际长度
  1301. len = (nInlen>iblock_size)?iblock_size:nInlen;//内存区域长度
  1302. nInlen -= len;
  1303. outlen = RSA_private_decrypt(len,(UCHAR *)(pInStream+i*iblock_size),bufout,
  1304. rsa,RSA_PKCS1_PADDING);
  1305. if (outlen == -1)//加密后资料长度
  1306. {
  1307. sprintf(OperMsg,"RSA解密失败");
  1308. ret = FALSE;
  1309. goto err;
  1310. }
  1311. if(bOutType)
  1312. {
  1313. fwrite(bufout,sizeof(char),outlen,outfd);
  1314. memset(bufout,0,outlen);
  1315. }
  1316. else
  1317. {
  1318. uMaxMem -= outlen; //剩余缓冲大小
  1319. if(uMaxMem < 0)
  1320. {
  1321. strcpy(OperMsg, "输出缓冲过小,不能容纳操作结果"); 
  1322. ret = FALSE;
  1323. goto err;
  1324. }
  1326. memcpy(pOutStream + memtemplen,bufout,outlen);//拷贝到调用函数
  1327. memtemplen += outlen;
  1328. }
  1329. finishLen += len;
  1330. DrawProg(finishLen*HUNDRED/fileLen);
  1331. if(nInlen <= 0) break;          
  1332. }
  1333. nOutlen = memtemplen;
  1334. }
  1335. err:
  1336. if(pkey) EVP_PKEY_free(pkey);
  1337. if(infd!=NULL)
  1338. fclose(infd);
  1339. if(outfd!=NULL)
  1340. fclose(outfd);
  1341. if(rsa) RSA_free(rsa);
  1342. delete [] bufin;
  1343. delete [] bufout;
  1344. return ret;
  1345. }
  1347. /*私钥加密(签名)*/
  1348. BOOL CEvp::RSAPrivEnc(const BYTE * pKeyBuf/*[in]私钥*/,const UINT nKeyLen/*[in]私钥长度*/,
  1349. const char * pPwd/*[in]私钥密码*/,const BYTE * pInStream/*[in]输入文件或内存*/,
  1350. DWORD nInlen/*[in]数据长度,为0表示pInStream为文件名*/,BYTE * pOutStream/*[out]加密后的数据*/,
  1351. DWORD & nOutlen/*[in,out]in为0时候表示pOutStream为文件名,out加密后数据长度*/,
  1352. char * OperMsg/*[out]返回操作错误信息*/)
  1353. {
  1354. RSA * rsa = NULL;
  1355. EVP_PKEY * pkey = NULL;
  1356. UINT iblock_size = 0,
  1357. oblock_size = 0,
  1358. outlen = 0,
  1359. inlen = 0;
  1360. BOOL ret = TRUE;
  1361. UCHAR * bufin = NULL,
  1362.   * bufout = NULL;
  1363. long fileLen = 0;//文件长度
  1364. long finishLen = 0;//完成长度
  1366. int memtemplen = 0; //输出内存偏移
  1367. UINT len = 0; //输入内存剩余长度
  1368. int uMaxMem = nOutlen; //可能为负数,不能用UINT
  1370. FILE * outfd = NULL,
  1371.  * infd = NULL;
  1373. BOOL bOutType = FALSE;//输出文件类型,内存-FALSE,文件-TRUE;
  1374. if(nOutlen == 0) bOutType = TRUE;
  1377. if(nInlen == 0)//输入为文件
  1378. {
  1379. if(pInStream == NULL || strlen((char*)pInStream)==0)
  1380. {
  1381. strcpy(OperMsg,"未指定输入文件");
  1382. return FALSE;
  1383. }
  1385. if ((infd = fopen ((char *)pInStream, "rb")) == NULL)//原文
  1386. {
  1387. sprintf(OperMsg,"打开文件%s失败",pInStream);
  1388. return FALSE;
  1389. }
  1390. fileLen = filelength(fileno(infd));//得到文件长度
  1391. }
  1392. else
  1393. fileLen = nInlen;
  1395. if(nOutlen == 0)//输出为文件
  1396. {
  1397. if(pOutStream == NULL || strlen((char*)pOutStream)==0)
  1398. {
  1399. strcpy(OperMsg,"未指定输出文件");
  1400. return FALSE;
  1401. }
  1403. if ((outfd = fopen ((char *)pOutStream, "wb")) == NULL)//原文
  1404. {
  1405. sprintf(OperMsg,"打开文件%s失败",pOutStream);
  1406. return FALSE;
  1407. }
  1408. }
  1410. pkey=CCertKey::LoadKey((char *)pKeyBuf,nKeyLen,(char *)pPwd,OperMsg);
  1411. if (pkey == NULL)
  1412. { 
  1413. // sprintf(OperMsg,"取得私钥密钥失败");
  1414. ret=FALSE;
  1415. goto err;
  1416. }
  1418.     if (!(rsa = EVP_PKEY_get1_RSA(pkey)))
  1419. {
  1420. sprintf(OperMsg,"取得RSA密钥失败");
  1421. ret=FALSE;
  1422. goto err;
  1423.     }
  1426. iblock_size = BN_num_bytes(rsa->n) - 11;//输入长度 117
  1427.   oblock_size = BN_num_bytes(rsa->n);//加密后长度 128
  1428. bufin=new unsigned char[iblock_size];
  1429. bufout=new unsigned char[oblock_size];
  1430. if(nInlen == 0)//文件
  1431. {
  1432. for(;;)
  1433. {
  1434. inlen=fread(bufin,sizeof(char),iblock_size,infd);
  1435. if(!inlen)
  1436. break;//117,128
  1437. outlen = RSA_private_encrypt(inlen,bufin,bufout,rsa,RSA_PKCS1_PADDING);
  1438. if (outlen == -1)//加密后资料长度
  1439. {
  1440. sprintf(OperMsg,"RSA加密失败");
  1441. ret=FALSE;
  1442. goto err;
  1443. }
  1444. if(bOutType)
  1445. {
  1446. fwrite(bufout,sizeof(char),outlen,outfd);
  1447. memset(bufout,0,oblock_size);
  1448. }
  1449. else
  1450. {
  1451. uMaxMem -= outlen; //剩余缓冲大小
  1452. if(uMaxMem < 0)
  1453. {
  1454. strcpy(OperMsg, "输出缓冲过小,不能容纳操作结果"); 
  1455. ret = FALSE;
  1456. goto err;
  1457. }
  1458. memcpy(pOutStream + memtemplen,bufout,outlen);//拷贝到调用函数
  1459. memtemplen += outlen;
  1460. }
  1461. finishLen+=inlen;
  1462. DrawProg(finishLen*HUNDRED/fileLen);
  1463. }
  1464. nOutlen = memtemplen;
  1465. }
  1466. else//内存
  1467. {
  1468. for(UINT i=0;;i++)
  1469. {
  1470. //每次 iblock_size 或实际长度
  1471. len = (nInlen>iblock_size)?iblock_size:nInlen;//内存区域长度
  1472. nInlen -= len;
  1473. outlen = RSA_private_encrypt(len,(UCHAR *)(pInStream+i*iblock_size),
  1474. bufout,rsa,RSA_PKCS1_PADDING);
  1475. if (outlen == -1)//加密后资料长度
  1476. {
  1477. sprintf(OperMsg,"RSA加密失败");
  1478. ret = FALSE;
  1479. goto err;
  1480. }
  1481. if(bOutType)
  1482. {
  1483. fwrite(bufout,sizeof(char),outlen,outfd);
  1484. memset(bufout,0,outlen);
  1485. }
  1486. else
  1487. {
  1488. uMaxMem -= outlen; //剩余缓冲大小
  1489. if(uMaxMem < 0)
  1490. {
  1491. strcpy(OperMsg, "输出缓冲过小,不能容纳操作结果"); 
  1492. ret = FALSE;
  1493. goto err;
  1494. }
  1495. memcpy(pOutStream + memtemplen,bufout,outlen);//拷贝到调用函数
  1496. memtemplen += outlen;
  1497. }
  1498. finishLen += len;
  1499. DrawProg(finishLen*HUNDRED/fileLen);
  1500. if(nInlen <= 0) break;          
  1501. }
  1502. nOutlen = memtemplen;
  1503. }
  1505. err:
  1506. if(pkey) EVP_PKEY_free(pkey);
  1507. if(infd!=NULL)
  1508. fclose(infd);
  1509. if(outfd!=NULL)
  1510. fclose(outfd);
  1511. if(rsa) RSA_free(rsa);
  1512. delete [] bufin;
  1513. delete [] bufout;
  1514. return ret;
  1515. }
  1517. //公钥解密
  1518. BOOL CEvp::RSAPubDec(const BYTE * pCertBuf/*[in]公钥*/,const UINT nCertLen/*[in]公钥长度*/,
  1519. const char * pPwd/*[in]公钥密码,只针对PFX包文件*/,const BYTE * pInStream/*[in]输入文件或内存*/,
  1520. DWORD nInlen/*[in]数据长度,为0表示pInStream为文件名*/,BYTE * pOutStream/*[out]加密后的数据*/,
  1521. DWORD & nOutlen/*[in,out]in为0时候表示pOutStream为文件名,out加密后数据长度*/,
  1522. char * OperMsg/*[out]返回操作错误信息*/)
  1523. {
  1524. UINT iblock_size = 0, //输入块长度
  1525. oblock_size = 0; //输出块长度
  1526. unsigned char * bufin=NULL,
  1527.   * bufout=NULL;
  1528. int inlen = 0,
  1529. outlen = 0;
  1530. BOOL ret = TRUE;
  1531. long fileLen = 0;//文件长度
  1532. long finishLen = 0;//完成长度
  1533. X509 * x509 = NULL;
  1534. EVP_PKEY * pcert = NULL;
  1535. RSA * rsa = NULL;
  1536. int memtemplen = 0; //输出内存偏移
  1537. UINT len = 0; //输入内存剩余长度
  1538. int uMaxMem = nOutlen; //可能为负数,不能用UINT
  1540. BOOL bOutType = FALSE;//输出文件类型,内存-FALSE,文件-TRUE;
  1542. if(nOutlen == 0) bOutType = TRUE;
  1544. FILE * outfd = NULL,
  1545. * infd = NULL;
  1547. if(nInlen == 0)//输入为文件
  1548. {
  1549. if(pInStream == NULL || strlen((char*)pInStream)==0)
  1550. {
  1551. strcpy(OperMsg,"未指定输入文件");
  1552. return FALSE;
  1553. }
  1555. if ((infd = fopen ((char *)pInStream, "rb")) == NULL)//原文
  1556. {
  1557. sprintf(OperMsg,"打开文件%s失败",pInStream);
  1558. return FALSE;
  1559. }
  1560. fileLen = filelength(fileno(infd));//得到文件长度
  1561. }
  1562. else
  1563. fileLen = nInlen;
  1565. if(nOutlen == 0)//输出为文件
  1566. {
  1567. if(pOutStream == NULL || strlen((char*)pOutStream)==0)
  1568. {
  1569. strcpy(OperMsg,"未指定输出文件");
  1570. return FALSE;
  1571. }
  1573. if ((outfd = fopen ((char *)pOutStream, "wb")) == NULL)//原文
  1574. {
  1575. sprintf(OperMsg,"打开文件%s失败",pOutStream);
  1576. return FALSE;
  1577. }
  1578. }
  1580. x509 = CCertKey::LoadCert((char *)pCertBuf,nCertLen,(char *)pPwd,OperMsg);
  1581. if (x509 == NULL)
  1582. {
  1583. ret = FALSE;
  1584. goto err;
  1585. }
  1587. pcert = X509_get_pubkey(x509);
  1588. if(pcert==NULL)
  1589. {
  1590. sprintf(OperMsg,"取得公钥密钥失败");
  1591. ret = FALSE;
  1592. goto err;
  1593. }
  1595.     if (!(rsa = EVP_PKEY_get1_RSA(pcert)))
  1596. {
  1597. sprintf(OperMsg,"取得RSA密钥失败");
  1598. ret=FALSE;
  1599. goto err;
  1600.     }
  1601. iblock_size = BN_num_bytes(rsa->n);//预解密长度128
  1602. oblock_size = BN_num_bytes(rsa->n) - 11;//解密后长度117
  1603. bufin=new unsigned char[iblock_size];
  1604. bufout=new unsigned char[oblock_size];
  1605. if(nInlen==0)//文件
  1606. {
  1607. for(;;)
  1608. {
  1609. inlen = fread(bufin,sizeof(char),iblock_size,infd);
  1610. if(!inlen)
  1611. break;
  1612. outlen = RSA_public_decrypt(inlen,bufin,bufout,rsa,RSA_PKCS1_PADDING);
  1613. if (outlen == -1)//加密后资料长度
  1614. {
  1615. sprintf(OperMsg,"RSA解密失败");
  1616. ret=FALSE;
  1617. goto err;
  1618. }
  1619. if(bOutType)
  1620. {
  1621. fwrite(bufout,sizeof(char),outlen,outfd);
  1622. memset(bufout,0,oblock_size);
  1623. }
  1624. else
  1625. {
  1626. uMaxMem -= outlen; //剩余缓冲大小
  1627. if(uMaxMem < 0)
  1628. {
  1629. strcpy(OperMsg, "输出缓冲过小,不能容纳操作结果"); 
  1630. ret = FALSE;
  1631. goto err;
  1632. }
  1633. memcpy(pOutStream + memtemplen,bufout,outlen);//拷贝到调用函数
  1634. memtemplen += outlen;
  1635. }
  1636. finishLen += inlen;
  1637. DrawProg(finishLen*HUNDRED/fileLen);
  1638. }
  1639. nOutlen = memtemplen;
  1640. }
  1642. else//内存区域
  1643. {
  1644. for(UINT i=0;;i++)
  1645. {
  1646. //每次 iblock_size 或实际长度
  1647. len = (nInlen>iblock_size)?iblock_size:nInlen;//内存区域长度
  1648. nInlen -= len;
  1649. outlen = RSA_public_decrypt(len,(UCHAR *)(pInStream+i*iblock_size),bufout,rsa,RSA_PKCS1_PADDING);
  1650. if (outlen == -1)//加密后资料长度
  1651. {
  1652. sprintf(OperMsg,"RSA解密失败");
  1653. ret = FALSE;
  1654. goto err;
  1655. }
  1656. if(bOutType)
  1657. {
  1658. fwrite(bufout,sizeof(char),outlen,outfd);
  1659. memset(bufout,0,outlen);
  1660. }
  1661. else
  1662. {
  1663. uMaxMem -= outlen; //剩余缓冲大小
  1664. if(uMaxMem < 0)
  1665. {
  1666. strcpy(OperMsg, "输出缓冲过小,不能容纳操作结果"); 
  1667. ret = FALSE;
  1668. goto err;
  1669. }
  1670. memcpy(pOutStream + memtemplen,bufout,outlen);//拷贝到调用函数
  1671. memtemplen += outlen;
  1672. }
  1673. finishLen += len;
  1674. DrawProg(finishLen*HUNDRED/fileLen);
  1675. if(nInlen <= 0) break;     
  1677. }
  1678. nOutlen = memtemplen;
  1679. }
  1680. err:
  1681. if(infd!=NULL)
  1682. fclose(infd);
  1683. if(outfd!=NULL)
  1684. fclose(outfd);
  1685. if(pcert) EVP_PKEY_free(pcert);
  1686.     if(x509) X509_free(x509);
  1687. if(rsa) RSA_free(rsa);
  1688. delete [] bufin;
  1689. delete [] bufout;
  1690. return ret;
  1692. }
  1694. void CEvp::DrawProg(float fPot)
  1695. {
  1696. if(m_pProgress)
  1697. m_pProgress->SetPos((int)fPot);
  1698. }
  1700. void CEvp::SetProgRess(CProgressCtrlST *pProgress)
  1701. {
  1702. m_pProgress = pProgress;
  1703. }
  1705. //功能:得到加密后缓冲区大小
  1706. //参数:
  1707. // pCertBuf [in] - 公钥
  1708. // nCertLen [in] - 公钥长度
  1709. // nInlen   [in] - 数据长度
  1710. //返回值:输出缓冲区大小 -1 标示函数操作失败
  1711. DWORD CEvp::GetEncLen(const char * pCertBuf, const UINT nCertLen, const DWORD nInlen)
  1712. {
  1713. X509 * x509 = NULL;
  1714. EVP_PKEY * pcert = NULL;
  1715. RSA * rsa = NULL;
  1716. DWORD len = 0;
  1717. UINT iblock_size = 0, //输入块长度
  1718. oblock_size = 0; //输出块长度
  1719. UINT uMultiple = 0;//输入是块长度的倍数,用于计算输出
  1720. char OperMsg[100] = {0};
  1721. x509 = CCertKey::LoadCert((char *)pCertBuf,nCertLen,"",OperMsg);
  1722. if (x509 == NULL)
  1723. {
  1724. len = -1;
  1725. goto err;
  1726. }
  1727. pcert = X509_get_pubkey(x509);
  1728. if(pcert==NULL)
  1729. {
  1730. sprintf(OperMsg,"取得公钥密钥失败");
  1731. len = -1;
  1732. goto err;
  1733. }
  1735.     if (!(rsa = EVP_PKEY_get1_RSA(pcert)))
  1736. {
  1737. sprintf(OperMsg,"取得RSA密钥失败");
  1738. len = 0;
  1739. goto err;
  1740.     }
  1742. iblock_size = BN_num_bytes(rsa->n) - 11;//预加密长度,117
  1743. oblock_size = BN_num_bytes(rsa->n);//加密后长度,128
  1745. if(nInlen%iblock_size == 0)//正好整除
  1746. uMultiple = nInlen/iblock_size;
  1747. else
  1748. uMultiple = nInlen/iblock_size + 1;
  1750. len = (nInlen > iblock_size) ? (uMultiple * oblock_size) : oblock_size;//内存区域长度
  1752. err:
  1753. if(pcert) EVP_PKEY_free(pcert);
  1754.     if(x509) X509_free(x509);
  1755. if(rsa) RSA_free(rsa);
  1756. return len;
  1757. }
  1759. //目录部分
  1762. //功能:初始化对称加密结构
  1763. //支持目录加密
  1764. //返回值 : 成功TRUE
  1765. //    失败FALSE
  1766. //参数 : 
  1767. // strCpName - 算法名称
  1768. // strPwd - 密钥
  1769. // type - 类型 1 - 加密; 0 - 解密
  1770. // Ctx - 返回加密信息体
  1771. //调用时机: 加密前
  1772. BOOL CEvp::InitCrypt2(const CString strCpName, CString strPwd, const int type, EVP_CIPHER_CTX & Ctx)
  1773. {
  1774. const EVP_CIPHER * cipher=NULL;
  1775. unsigned char key[EVP_MAX_KEY_LENGTH]="";//算法最长的KEY长度
  1776.     unsigned char iv[EVP_MAX_IV_LENGTH]="";//算法最长的IV长度
  1777. OpenSSL_add_all_algorithms();//add digests   and ciphers
  1779. cipher = EVP_get_cipherbyname(strCpName);
  1780. if(cipher==NULL)
  1781. {
  1782. // sprintf(outMsg,"Unknown cipher name %sn",cpname);
  1783. return FALSE;
  1784. }
  1786. //表示產生的 key 是給哪一種 cipher 用的
  1787. //過程中所使用的 hash 演算法,
  1788. //用來加密的 salt，至少為八個 bytes，否則必須NULL,
  1789. //重覆幾次 hashing 的動作，愈多次愈花時間，但相對地也愈安全
  1791. if(!EVP_BytesToKey(cipher,EVP_md5(),NULL,(unsigned char *)strPwd.GetBuffer(0),
  1792. strPwd.GetLength(),1,key,iv))
  1793. {
  1794. // strcpy(outMsg,"Crypt初始化key or iv 失败");
  1795. return FALSE;
  1796. }
  1798. //EVP_CIPHER_CTX Ctx;
  1799. EVP_CIPHER_CTX_init(&Ctx);//初始化一个EVP_CIPHER_CTX结构体
  1801. //type为1，则加密；如果type为0，则解密；如果type是－1，则不改变数据
  1802. if(!EVP_CipherInit_ex(&Ctx, cipher, NULL/*NULL使用缺省的实现算法*/,key,iv,type))//初始化
  1803. {
  1804. // strcpy(outMsg,"Crypt初始化加解密结构体失败");
  1805. return FALSE;
  1806. }
  1807. EVP_cleanup();//frees all three stacks and sets their pointers to NULL ---- EVP_CIPHER
  1808. return TRUE;
  1810. }
  1812. //功能:清除对称加密结构
  1813. //调用:加密完毕后
  1814. void CEvp::CleanCrypt2(EVP_CIPHER_CTX & Ctx)
  1815. {
  1816. if(Ctx.cipher) 
  1817. EVP_CIPHER_CTX_cleanup(&Ctx); //清除所有信息释放内存
  1818. CRYPTO_cleanup_all_ex_data();
  1819. }
  1821. //返回值 : 加密时候返回加密后文件大小
  1822. //    解密时候返回解密后文件大小
  1823. //参数 : 
  1824. // pCtx - 已经初始化的加密信息体
  1825. // strFileName - 加密为要加密的文件名,解密为解密后保存的文件名
  1826. // File - 文件指针 ,具体位置的偏移有调用者负责
  1827. // dBolckLen - 块长度,块标示某个文件加密后的内容,只在解密时候有效,可以解密某个文件
  1828. //  加密时候无效,为0
  1829. // outStr - 返回错误信息
  1830. DWORD CEvp::Crypt2(EVP_CIPHER_CTX * pCtx, const CString & strFileName,
  1831. CFile & File, DWORD dBolckLen, CString & outStr)    
  1832. {
  1833. if(File.m_hFile == CFile::hFileNull)
  1834. return -1;
  1836. unsigned char inbuf[BUFLEN] = "";
  1837. unsigned char outbuf[BUFLEN + EVP_MAX_BLOCK_LENGTH] = "";//所有算法最长的块长度。
  1838. int infilelen = 0,
  1839. outlen=0;
  1840. BOOL ret = true;
  1841. DWORD dFileLen = 0;//文件长度
  1842. DWORD dFinishLen = 0;//完成长度
  1843. long lReadLen = 0; //每次读取的块长度
  1844. DWORD dReturnLen = 0;//返回加解密结果长度
  1846. CFile inSideFile;//内部文件
  1847. if(0 == dBolckLen)//块长度为0标示要加密
  1848. {
  1849. if(!inSideFile.Open(strFileName, CFile::modeRead | CFile::typeBinary))
  1850. {
  1851. outStr.Format("打开文件%s失败", strFileName);
  1852. return -1;
  1853. }
  1855. dFileLen = inSideFile.GetLength();
  1857. for(;;)
  1858. {                       
  1859. infilelen = inSideFile.Read(inbuf, BUFLEN);
  1860. if(infilelen <= 0) break;
  1861. if(!EVP_CipherUpdate(pCtx, outbuf, &outlen, inbuf, infilelen))//中間過程 
  1862. {
  1863. /* Error */              
  1864. outStr = "Crypt中间过程错误";
  1865. ret = FALSE;
  1866. goto err;
  1867. }
  1868. File.Write(outbuf, outlen);
  1869. dFinishLen += infilelen;
  1870. dReturnLen += outlen;
  1871. DrawProg(dFinishLen*HUNDRED/dFileLen);
  1872. } 
  1874. if(!EVP_CipherFinal_ex(pCtx, outbuf, &outlen))    //最終步驟-处理最后（Final）的一段数据
  1875. {   /* Error */                       
  1876. outStr = "Crypt最终过程错误"; 
  1877. ret = FALSE;
  1878. goto err;
  1879. }               
  1880. File.Write(outbuf, outlen);
  1882. }
  1883. else //解密
  1884. {
  1885. if(!inSideFile.Open(strFileName, CFile::modeCreate | CFile::modeWrite | CFile::typeBinary))
  1886. {
  1887. outStr.Format("创建文件%s失败", strFileName);
  1888. return -1;
  1889. }
  1891. dFileLen = dBolckLen;
  1893. for(;;)
  1894. {
  1895. //每次 iblock_size 或实际长度
  1896. lReadLen = (dBolckLen > BUFLEN) ? BUFLEN:dBolckLen;//内存区域长度
  1897. infilelen = File.Read(inbuf, lReadLen);
  1898. if(0 == infilelen)
  1899. break;
  1902. if(!EVP_CipherUpdate(pCtx, outbuf, &outlen, inbuf, infilelen))//中間過程 
  1903. {
  1904. /* Error */              
  1905. outStr = "Crypt中间过程错误";
  1906. ret = FALSE;
  1907. goto err;
  1908. }
  1910. inSideFile.Write(outbuf, outlen);
  1911. dReturnLen += outlen;
  1912. dFinishLen += infilelen;
  1913. DrawProg(dFinishLen*HUNDRED/dFileLen);
  1914. dBolckLen -= infilelen;
  1915. if(dBolckLen <= 0) break;
  1916. }
  1918. if(!EVP_CipherFinal_ex(pCtx, outbuf, &outlen))    //最終步驟-处理最后（Final）的一段数据
  1919. {   /* Error */                       
  1920. outStr = "Crypt最终过程错误"; 
  1921. ret = FALSE;
  1922. goto err;
  1923. }                
  1924. inSideFile.Write(outbuf, outlen);
  1925. }
  1927. dReturnLen += outlen;
  1929. err:
  1930. if(inSideFile.m_hFile != CFile::hFileNull )
  1931. inSideFile.Close();
  1932. if(ret)
  1933. return dReturnLen;
  1934. else return -1;
  1935. }
  1937. BOOL CEvp::InitDigest2(CString strMdName, EVP_MD_CTX & Ctx)
  1938. {
  1939. const EVP_MD *md = NULL;
  1940. if(strMdName.IsEmpty())
  1941. {
  1942. // outStr = "未指定摘要算法";
  1943. return FALSE;
  1944. }
  1945. //使EVP_Digest系列函数支持所有有效的信息摘要算法
  1946. OpenSSL_add_all_digests();
  1947.     
  1948. //根据输入的信息摘要函数的名字得到相应的EVP_MD算法结构
  1949. md = EVP_get_digestbyname(strMdName.GetBuffer(0));  
  1950. strMdName.ReleaseBuffer();
  1951. if(!md) 
  1952. {
  1953. // outStr.Format("未知摘要算法名称 %s",strMdName);
  1954. EVP_cleanup();
  1955. return FALSE;
  1956. }
  1958. //初始化信息摘要结构md_ctx。
  1959. EVP_MD_CTX_init(&Ctx);
  1961. //使用md的算法结构设置mdctx结构，impl为NULL，即使用缺省实现的算法（openssl本身提供的信息摘要算法）
  1962. if(!EVP_DigestInit_ex(&Ctx, md, NULL/*impl*/))
  1963. {
  1964. // outStr.Format("Digest初始化算法结构错误");
  1965. EVP_cleanup();
  1966. return FALSE;
  1967. }
  1968. EVP_cleanup();
  1969. return TRUE;
  1970. }
  1973. void CEvp::CleanDigest2(EVP_MD_CTX & mdCtx)
  1974. {
  1975. if(mdCtx.digest) EVP_MD_CTX_cleanup(&mdCtx);
  1976. CRYPTO_cleanup_all_ex_data();
  1977. }
  1980. /*消息摘要*/ 
  1981. //返回值:摘要后长度,-1标示失败
  1982. //参数 : strMdName - 摘要算法名称
  1983. // strFileName  - 输入文件名称
  1984. // File - 已经打开的结果文件
  1985. // outStr - 返回错误信息
  1986. DWORD CEvp::Digest2(EVP_MD_CTX * pCtx, const CString strFileName,
  1987. CFile & File, CString & outStr)
  1988. {
  1989. if(File.m_hFile == CFile::hFileNull)
  1990. return -1;
  1991. char inbuf[BUFLEN] = "";
  1992. UINT len = 0;
  1993. BOOL ret = true;
  1994. EVP_MD_CTX md_ctx;
  1995. memset(&md_ctx,0,sizeof(md_ctx));
  1996. FILE * infd = NULL;
  1997. long fileLen = 0;//文件长度
  1998. long finishLen = 0;//完成长度
  2000. unsigned char md_value[MAX_MD_SIZE]="";
  2001. UINT md_len = 0;/*摘要长度*/
  2004. if(strFileName.IsEmpty())
  2005. {
  2006. outStr = "未指定输入文件";
  2007. return -1;
  2008. }
  2010. CFile inSideFile;//内部文件
  2011. if(!inSideFile.Open(strFileName, CFile::modeRead | CFile::typeBinary))
  2012. {
  2013. outStr = "不能打开指定文件";
  2014. return -1;
  2015. }
  2018. for(;;)
  2019. {
  2020. len = fread(inbuf, 1, BUFLEN, infd);
  2021. if(len <= 0) break;          
  2022. if(!EVP_DigestUpdate(&md_ctx, inbuf, len))
  2023. {
  2024. outStr.Format("Digest中间过程错误");
  2025. ret=FALSE;
  2026. goto err;
  2027. }
  2028. finishLen+=len;
  2029. DrawProg(finishLen * HUNDRED / fileLen);
  2030. }
  2031. //完成信息摘要计算过程，将完成的摘要信息存储在md_value里面,长度信息存储在md_len里面
  2032. if(!EVP_DigestFinal_ex(&md_ctx, md_value, &md_len))
  2033. {
  2034. outStr.Format("Digest最终过程错误");
  2035. ret=FALSE;
  2036. }
  2039. err:
  2040. //使用该函数释放mdctx占用的资源，如果使用_ex系列函数，这是必须调用的。
  2041. if(ret)
  2042. {
  2043. //记录文件
  2044. File.Write(md_value, md_len);
  2045. return md_len;
  2046. }
  2047. else
  2048. return -1;
  2049. }
  2051. BOOL CEvp::VerifyDigest2(EVP_MD_CTX * mdCtx, const CString strFileName,
  2052. CFile & File, DWORD dBolckLen, CString & outStr)
  2053. {
  2054. if(File.m_hFile == CFile::hFileNull)
  2055. return -1;
  2056. char inbuf[BUFLEN] = "";
  2057. UINT len = 0;
  2058. BOOL ret = true;
  2059. EVP_MD_CTX md_ctx;
  2060. memset(&md_ctx,0,sizeof(md_ctx));
  2061. FILE * infd = NULL;
  2062. long fileLen = 0;//文件长度
  2063. long finishLen = 0;//完成长度
  2065. unsigned char md_value[MAX_MD_SIZE]="";
  2066. UINT md_len = 0;/*摘要长度*/
  2069. if(strFileName.IsEmpty())
  2070. {
  2071. outStr = "未指定输入文件";
  2072. return FALSE;
  2073. }
  2075. CFile inSideFile;//内部文件
  2076. if(!inSideFile.Open(strFileName, CFile::modeRead | CFile::typeBinary))
  2077. {
  2078. outStr.Format("文件%s丢失", strFileName);
  2079. return FALSE;
  2080. }
  2083. for(;;)
  2084. {
  2085. len = fread(inbuf, 1, BUFLEN, infd);
  2086. if(len <= 0) break;          
  2087. if(!EVP_DigestUpdate(&md_ctx, inbuf, len))
  2088. {
  2089. outStr.Format("Digest中间过程错误");
  2090. ret=FALSE;
  2091. goto err;
  2092. }
  2093. finishLen+=len;
  2094. DrawProg(finishLen * HUNDRED / fileLen);
  2095. }
  2096. //完成信息摘要计算过程，将完成的摘要信息存储在md_value里面,长度信息存储在md_len里面
  2097. if(!EVP_DigestFinal_ex(&md_ctx, md_value, &md_len))
  2098. {
  2099. outStr.Format("Digest最终过程错误");
  2100. ret=FALSE;
  2101. }
  2104. err:
  2105. //使用该函数释放mdctx占用的资源，如果使用_ex系列函数，这是必须调用的。
  2106. if(ret)
  2107. {
  2108. //比较文件摘要与结果是否相同
  2109. if(md_len != dBolckLen)
  2110. {
  2111. outStr.Format("摘要校验错误");
  2112. ret=FALSE;
  2113. }
  2114. else
  2115. {
  2116. char * pmdbuf = new char[dBolckLen + 1];
  2117. File.Read(pmdbuf, dBolckLen);
  2118. if(memcmp(pmdbuf, md_value, dBolckLen) == 0)
  2119. {
  2120. outStr.Format("摘要校验正确");
  2121. ret=TRUE;
  2122. }
  2123. else
  2124. {
  2125. outStr.Format("摘要校验错误");
  2126. ret=FALSE;
  2127. }
  2128. delete [] pmdbuf;
  2129. }
  2130. }
  2132. return ret;
  2133. }
  2135. BOOL CEvp::InitSeal2(stuCertLink * pCERT, const CString strCpName,
  2136.   CFile & File, EVP_CIPHER_CTX & eCtx, CString & outStr)
  2137. {
  2138. //对随机数播种（seeded）。
  2139. UCHAR iv[EVP_MAX_IV_LENGTH]="";
  2140. UCHAR * ekey [128]; 
  2141. EVP_PKEY * pubKey[128];
  2142. int ekeylen[128];
  2143. int index = 0;
  2145. const EVP_CIPHER *cipher=NULL;
  2146. BOOL ret=true;
  2147.  // DWORD fileLen=0;//文件长度
  2148. // DWORD finishLen=0;//完成长度
  2149. UINT uCrc16 = 0; //加密后重要信息CRC码
  2150. DWORD dOutLen = 0;//内存文件长度
  2151. BYTE * pOut = NULL; //内存文件缓冲区
  2152. DWORD dFileInfoLen = 0;
  2154. //加载加密公钥
  2155. HRSRC hRsrc = FindResource(NULL,MAKEINTRESOURCE(IDR_FILE_CERT),"CERT");
  2156. DWORD lenCert = SizeofResource(NULL, hRsrc); 
  2157. HGLOBAL hgCert = LoadResource(NULL,hRsrc);
  2158. LPSTR lpCert = (LPSTR)LockResource(hgCert);
  2161. CMemFile MemFile; //用于存放重要信息的内存文件
  2163. DWORD dInLen = 0;
  2164. BYTE * pIn = NULL; //用于MemFile.Dectch();
  2167. // fileLen = filelength(fileno(infd));//得到文件长度
  2169. OpenSSL_add_all_algorithms();
  2171. int nCountCert = 0; //证书个数
  2173. for(stuCertLink * temp = pCERT; temp != NULL; temp=temp->Link, nCountCert++)
  2174. {
  2175. X509 * pX509 = NULL;
  2176. pX509 = CCertKey::LoadCert(temp->pCert, temp->CertLen, NULL, outStr.GetBuffer(255));
  2177. outStr.ReleaseBuffer();
  2178.     if(pX509)
  2179. {
  2180. pubKey[nCountCert] = X509_get_pubkey(pX509);
  2181. if (pubKey[nCountCert] == NULL)
  2182. {
  2183. outStr = "Read Public Key Failed!";
  2184. ret=false;
  2185. goto err;
  2186. }
  2187. ekey[nCountCert] = new unsigned char[EVP_PKEY_size(pubKey[nCountCert])];
  2188. X509_free(pX509);
  2189. }
  2190. else
  2191. {
  2192. outStr.Format("加载第 %d 个证书 %s 失败", nCountCert+1, temp->pCert);
  2193. ret = false;
  2194. goto err;
  2195. }
  2196. }
  2198. cipher = EVP_get_cipherbyname(strCpName);
  2199. if(cipher==NULL)
  2200. {
  2201. outStr.Format("Unknown cipher name %sn",strCpName);
  2202. ret=false;
  2203. goto err;
  2204. }
  2206. if(!EVP_SealInit(&eCtx,cipher,
  2207. ekey,
  2208. ekeylen,//存放所有 ek 長度
  2209. iv,//自动生成
  2210. pubKey,//加密 ek 用的 public key(s)
  2211. nCountCert))
  2212. {
  2213. ret=false;
  2214. goto err;
  2215. }
  2217. MemFile.Write(&nCountCert, sizeof(int)); //1 - 写入公钥个数
  2219. for(index = 0; index < nCountCert; index++)
  2220. {
  2221. MemFile.Write(&ekeylen[index], sizeof(int));
  2222. MemFile.Write(ekey[index], ekeylen[index]);
  2223. }
  2225. MemFile.Write(iv, sizeof(iv));
  2227. //构造加密结果 长度+1 内存
  2228. dFileInfoLen = CEvp::GetEncLen(lpCert, lenCert, MemFile.GetLength());
  2230. dOutLen = dFileInfoLen + 1;
  2231. pOut = new BYTE[dOutLen];
  2233. dInLen = MemFile.GetLength();
  2234. pIn = MemFile.Detach();
  2236. //加密重要信息
  2237. if(!CEvp::RSAPubEnc((BYTE *)lpCert, lenCert, "", pIn, 
  2238. dInLen, pOut, dOutLen, outStr.GetBuffer(255)))
  2239. {
  2240. //加密失败
  2241. ret=false;
  2242. goto err;
  2243. }
  2245. //得到加密后长度的CRC校验
  2246. if(!CRC::GetCrc16((char*)&dOutLen, sizeof(DWORD), uCrc16))
  2247. {
  2248. //加密失败
  2249. ret=false;
  2250. goto err;
  2251. }
  2253. //写入加密后重要信息长度和CRC校验和加密后重要信息内容
  2254. File.Write(&dOutLen, sizeof(DWORD));
  2255. File.Write(&uCrc16, sizeof(UINT));
  2256. File.Write(pOut, dOutLen);
  2258. err:
  2259. outStr.ReleaseBuffer();
  2261. free(pIn);
  2262. delete [] pOut;
  2264. for(int i = 0;i< nCountCert;i++)
  2265. {
  2266. if(pubKey[i]) EVP_PKEY_free(pubKey[i]);
  2267. if(ekey[i]) delete [] ekey[i];
  2268. }
  2270. //if(eCtx.cipher) EVP_CIPHER_CTX_cleanup(&eCtx);
  2271. EVP_cleanup();
  2272. return ret;
  2273. }
  2275. void CEvp::CleanSeal2(EVP_CIPHER_CTX & sealCtx)
  2276. {
  2277. if(sealCtx.cipher) 
  2278. EVP_CIPHER_CTX_cleanup(&sealCtx); //清除所有信息释放内存
  2279. EVP_cleanup();
  2280. CRYPTO_cleanup_all_ex_data();
  2281. }
  2284. DWORD CEvp::Seal2(EVP_CIPHER_CTX * pCtx,const CString strFileName, CFile & File, CString & outStr)
  2285. {
  2286. int readlen = 0;
  2287. int ebuflen = 0;
  2288. UCHAR buf[BUFLEN]="";
  2289. UCHAR ebuf[BUFLEN + EVP_MAX_BLOCK_LENGTH]="";
  2290. BOOL ret = TRUE;
  2291. DWORD finishLen = 0;
  2292. CFile inSideFile;//内部文件
  2293. DWORD dProgLen = 0; //总共需要加密的长度
  2294. DWORD dProgFinshLen = 0;//已经加密的长度
  2296. if(!inSideFile.Open(strFileName, CFile::modeRead | CFile::typeBinary))
  2297. {
  2298. outStr = "不能打开指定文件";
  2299. return -1;
  2300. }
  2302. dProgLen = inSideFile.GetLength();
  2304. for(;;)
  2305. {
  2306. readlen = inSideFile.Read(buf, sizeof(buf));
  2308. if (readlen <= 0)
  2309. {
  2310. break;
  2311. }
  2313. if(!EVP_SealUpdate(pCtx, ebuf, &ebuflen, buf, readlen))
  2314. {
  2315. outStr = "中间过程出错";
  2316. ret=false;
  2317. goto err;
  2318. }
  2319. File.Write(ebuf, ebuflen);
  2320. finishLen += ebuflen;
  2322. dProgFinshLen += readlen;
  2323. DrawProg(dProgFinshLen*HUNDRED/dProgLen);
  2324. }
  2326. if(!EVP_SealFinal(pCtx, ebuf, &ebuflen))
  2327. {
  2328. outStr = "最终过程出错";
  2329. ret = false;
  2330. goto err;
  2331. }
  2332. File.Write(ebuf, ebuflen);
  2333. finishLen += ebuflen;
  2335. err:
  2336. inSideFile.Close();
  2337. if(ret)
  2338. return finishLen;
  2339. else
  2340. return ret;
  2341. }
  2343. BOOL CEvp::InitOpenSeal2(char * key, int keylen, char * pwd, const CString strCpName,
  2344.   CFile & File, EVP_CIPHER_CTX & eCtx, CString & outStr)
  2345. {
  2346. if(File.m_hFile == CFile::hFileNull)
  2347. return FALSE;
  2349. unsigned char iv[EVP_MAX_IV_LENGTH]="";
  2350. const EVP_CIPHER *cipher=NULL;
  2351. int ebuflen=0,readlen=0;
  2352. bool ret=true;
  2353. int nCountCert = 0; //公钥个数
  2354. int index = 0;
  2355. UCHAR * ekey [128] = {0}; 
  2356. int ekeylen[128];
  2357. BOOL bInit = FALSE;//是否初始化成功
  2358. DWORD dFileInfoLen = 0;//加密后重要信息长度
  2359. UINT uCrc16 = 0; //加密后重要信息CRC码
  2361. EVP_PKEY * pkey=NULL;
  2362. CMemFile MemFile;
  2363. HRSRC hRsrc = FindResource(NULL,MAKEINTRESOURCE(IDR_FILE_KEY),"CERT");
  2364. DWORD lenKey = SizeofResource(NULL, hRsrc); 
  2365. HGLOBAL hgKey = LoadResource(NULL,hRsrc);
  2366. LPSTR lpKey = (LPSTR)LockResource(hgKey);
  2367. BYTE * pIn = NULL;
  2368. BYTE * pOut = NULL;
  2369. DWORD dOutLen = 0;
  2371. OpenSSL_add_all_algorithms();//digests   and ciphers
  2372. /* Read private key */
  2373. pkey = CCertKey::LoadKey(key,keylen,pwd,outStr.GetBuffer(255));
  2374. outStr.ReleaseBuffer();
  2375. if (pkey == NULL)
  2376. { 
  2377. ret = false;
  2378. goto err;
  2379. }
  2381. //得到重要信息长度和CRC校验码
  2382. readlen = File.Read(&dFileInfoLen, sizeof(DWORD));
  2383. // finishLen += readlen;
  2385. readlen = File.Read(&uCrc16, sizeof(UINT));
  2386. // finishLen += readlen;
  2388. if(!CRC::CheckCrc((char *)&dFileInfoLen, sizeof(DWORD), uCrc16))
  2389. {
  2390. outStr = "文件头CRC校验错误";
  2391. ret = false;
  2392. goto err;
  2393. }
  2395. //开辟缓冲区,容纳加密后的重要文件信息
  2396. pIn = new BYTE[dFileInfoLen + 1];
  2397. dOutLen = dFileInfoLen;
  2399. readlen = File.Read(pIn, dFileInfoLen);
  2400. // finishLen += readlen;
  2404. //开辟缓冲区,容纳加密后的信息体
  2405. pOut = new BYTE[dOutLen];
  2406. if(!CEvp::RSAPrivDec((BYTE *)lpKey, lenKey, "", pIn, 
  2407. dFileInfoLen, pOut, dOutLen, outStr.GetBuffer(255)))
  2408. {
  2409. //解密失败
  2410. outStr.ReleaseBuffer();
  2411. outStr = "重要信息解密失败";
  2412. ret = false;
  2413. goto err;
  2414. }
  2416. outStr.ReleaseBuffer();
  2417. MemFile.Attach(pOut, dOutLen);
  2419. //首先是公钥个数
  2420. MemFile.Read(&nCountCert, sizeof(int));
  2422. for(index = 0; index < nCountCert; index++)
  2423. {
  2424. MemFile.Read(&ekeylen[index], sizeof(int));
  2425. ekey[index] = new unsigned char[ekeylen[index]];
  2426. MemFile.Read(ekey[index], ekeylen[index]);
  2427. }
  2429. MemFile.Read(iv, sizeof(iv));
  2431. MemFile.Close();
  2433. //输入文件已经偏移到加密后的文件
  2435. cipher = EVP_get_cipherbyname(strCpName);
  2437. if(cipher == NULL)
  2438. {
  2439. outStr.Format("Unknown cipher name %sn",strCpName);
  2440. ret = false;
  2441. goto err;
  2442. }
  2444. for(index = 0; index<nCountCert; index++)
  2445. {
  2446. if (ekeylen[index] != EVP_PKEY_size(pkey))
  2447. {
  2448. continue;
  2449. }
  2451. if(EVP_OpenInit(&eCtx,cipher, ekey[index],ekeylen[index],iv,pkey))
  2452. {
  2453. bInit = TRUE;
  2454. break;
  2455. }
  2456. }
  2457. if(!bInit)
  2458. {
  2459. outStr = "指定证书不能解密文件,请确认证书合法性";
  2460. ret=false;
  2461. goto err;
  2462. }
  2463. err:
  2464. delete [] pIn;
  2465. delete [] pOut;
  2467. for(int i = 0;i< nCountCert;i++)
  2468. {
  2469. if(ekey[i]) delete ekey[i];
  2470. }
  2471. if(pkey) EVP_PKEY_free(pkey);
  2473. EVP_cleanup();
  2475. return ret;
  2477. }
  2480. DWORD CEvp::OpenSeal2(EVP_CIPHER_CTX & eCtx, CFile & File, DWORD dBolckLen, const CString strFileName, CString & outStr)
  2481. {
  2482. unsigned char buf[BUFLEN]="";
  2483. unsigned char ebuf[BUFLEN + EVP_MAX_BLOCK_LENGTH]="";
  2484. int ebuflen = 0,
  2485. readlen = 0,
  2486. fileLen = 0,
  2487. finishLen = 0;
  2488. bool ret=true;
  2490. DWORD dProgLen = dBolckLen; //总共需要处理的长度
  2491. DWORD dProgFinshLen = 0;//已经处理的长度
  2494. CFile inSideFile;//内部文件
  2496. if(!inSideFile.Open(strFileName, CFile::modeCreate | CFile::modeWrite | CFile::typeBinary))
  2497. {
  2498. outStr.Format("创建文件%s错误", strFileName);
  2499. return -1;
  2500. }
  2501. for(;;)
  2502. {
  2503. //每次 iblock_size 或实际长度
  2504. fileLen = (dBolckLen > BUFLEN) ? BUFLEN:dBolckLen;//内存区域长度
  2505. readlen = File.Read(buf, fileLen);
  2506. if(readlen == 0)//可能加密时文件长度为0
  2507. break;
  2509. if(!EVP_OpenUpdate(&eCtx, ebuf, &ebuflen, buf, readlen))
  2510. {
  2511. outStr = "中间过程错误";
  2512. ret=false;
  2513. goto err;
  2514. }
  2516. inSideFile.Write(ebuf, ebuflen);
  2519. finishLen += ebuflen;
  2520. dBolckLen -= fileLen;
  2522. dProgFinshLen += readlen;
  2523. DrawProg(dProgFinshLen*HUNDRED/dProgLen);
  2525. if(dBolckLen <= 0) break;
  2526. }
  2528. //DrawProg(finishLen*HUNDRED/fileLen);
  2529. if(!EVP_OpenFinal(&eCtx, ebuf, &ebuflen))
  2530. {
  2531. outStr = "最终过程错误";
  2532. ret=false;
  2533. goto err;
  2534. }
  2536. inSideFile.Write(ebuf, ebuflen);
  2537. finishLen += ebuflen;
  2539. err:
  2540. inSideFile.Close();
  2541. if(ret)
  2542. return finishLen;
  2543. else
  2544. return -1;
  2545. }
  2547. void CEvp::CleanOpenSeal2(EVP_CIPHER_CTX & eCtx)
  2548. {
  2549. if(eCtx.cipher) 
  2550. EVP_CIPHER_CTX_cleanup(&eCtx); //清除所有信息释放内存
  2551. EVP_cleanup();
  2552. CRYPTO_cleanup_all_ex_data();
  2553. }
  2556. BOOL CEvp::GetPubRsa(const BYTE * pCertBuf/*[in]公钥*/, const UINT nCertLen/*[in]公钥长度*/, RSA *& pRsa)
  2557. {
  2558. X509 * x509 = NULL;
  2559. EVP_PKEY * pcert = NULL;
  2560. CString outStr;
  2561. BOOL ret = TRUE;
  2563. x509 = CCertKey::LoadCert((char *)pCertBuf, nCertLen, "", outStr.GetBuffer(255));
  2564. outStr.ReleaseBuffer();
  2565. if (x509 == NULL)
  2566. {
  2567. ret = FALSE;
  2568. goto err;
  2569. }
  2571. pcert = X509_get_pubkey(x509);
  2572. if(pcert==NULL)
  2573. {
  2574. outStr = "取得公钥密钥失败";
  2575. ret = FALSE;
  2576. goto err;
  2577. }
  2579.     if (!(pRsa = EVP_PKEY_get1_RSA(pcert)))
  2580. {
  2581. outStr = "取得RSA密钥失败";
  2582. ret=FALSE;
  2583. goto err;
  2584.     }
  2586. err:
  2587. if(pcert) EVP_PKEY_free(pcert);
  2588.     if(x509) X509_free(x509);
  2589. return ret;
  2590. }
  2592. BOOL CEvp::GetPrivRsa(const BYTE * pKeyBuf/*[in]私钥*/,const UINT nKeyLen/*[in]私钥长度*/,
  2593. const char * pPwd/*[in]私钥密码*/, RSA *& pRsa)
  2594. {
  2595. EVP_PKEY * pkey = NULL;
  2596. CString outStr;
  2597. pkey = CCertKey::LoadKey((char *)pKeyBuf,nKeyLen,(char *)pPwd,outStr.GetBuffer(255));
  2598. outStr.ReleaseBuffer();
  2599. BOOL ret = TRUE;
  2601. if (pkey == NULL)
  2602. { 
  2603. outStr = "取得私钥密钥失败";
  2604. ret=FALSE;
  2605. goto err;
  2606. }
  2608.     if (!(pRsa = EVP_PKEY_get1_RSA(pkey)))
  2609. {
  2610. outStr = "取得RSA密钥失败";
  2611. ret=FALSE;
  2612. goto err;
  2613.     }
  2614. err:
  2615. if(pkey) EVP_PKEY_free(pkey);
  2616. return ret;
  2617. }
  2619. void CEvp::FreeRsa(RSA *& pRsa)
  2620. {
  2621. if(pRsa) RSA_free(pRsa);
  2622. CRYPTO_cleanup_all_ex_data();
  2623. }
  2626. //公钥加密
  2627. DWORD CEvp::RSAPubEnc2(RSA * pRsa, const CString strFileName, CFile & File, CString & outStr)
  2628. {
  2629. if(pRsa == NULL)
  2630. {
  2631. outStr = "RSA非法";
  2632. return -1;
  2633. }
  2634. UINT iblock_size = 0, //输入块长度
  2635.  oblock_size = 0; //输出块长度
  2637. unsigned char * bufin=NULL,
  2638.   * bufout=NULL;
  2640. int inlen = 0,
  2641. outlen = 0;
  2643. DWORD dProgLen = 0; //总共需要处理的长度
  2644. DWORD dProgFinshLen = 0;//已经处理的长度
  2646. BOOL ret = TRUE;
  2647. long fileLen = 0;//文件长度
  2648. long finishLen = 0;//完成长度
  2649. DWORD returnLen = 0;//最后返回文件加密后长度
  2651. CFile inSideFile;//内部文件
  2652. if(!inSideFile.Open(strFileName, CFile::modeRead | CFile::typeBinary))
  2653. {
  2654. outStr = "不能打开指定文件";
  2655. return -1;
  2656. }
  2658. dProgLen = inSideFile.GetLength();
  2660. iblock_size = BN_num_bytes(pRsa->n) - 11;//预加密长度,117
  2661. oblock_size = BN_num_bytes(pRsa->n);//加密后长度,128
  2662. bufin = new unsigned char[iblock_size];
  2663. memset(bufin,0,iblock_size);
  2664. bufout = new unsigned char[oblock_size];
  2665. memset(bufout,0,oblock_size);
  2666. for(;;)
  2667. {
  2668. inlen = inSideFile.Read(bufin, iblock_size);
  2669. if(!inlen)
  2670. break;
  2671. outlen = RSA_public_encrypt(inlen,bufin,bufout,pRsa,RSA_PKCS1_PADDING);
  2672. if (outlen == -1)//加密后资料长度
  2673. {
  2674. outStr = "RSA加密失败";
  2675. ret=FALSE;
  2676. goto err;
  2677. }
  2678. File.Write(bufout, outlen);
  2679. returnLen += outlen;
  2680. memset(bufout,0,oblock_size);
  2682. dProgFinshLen += inlen;
  2683. DrawProg(dProgFinshLen*HUNDRED/dProgLen);
  2685. }
  2687. err:
  2688. inSideFile.Close();
  2689. // if(pRsa) RSA_free(pRsa);
  2690. delete [] bufin;
  2691. delete [] bufout;
  2692. if(!ret)
  2693. return -1;
  2694. else
  2695. return returnLen;
  2696. }
  2698. //私钥解密
  2699. DWORD CEvp::RSAPrivDec2(RSA * pRsa, CFile & File, DWORD dBolckLen, const CString strFileName, CString & outStr)
  2700. {
  2701. if(pRsa == NULL)
  2702. {
  2703. outStr = "RSA非法";
  2704. return -1;
  2705. }
  2706. unsigned char * bufin = NULL,
  2707.   * bufout = NULL;
  2708. DWORD dReturnLen = 0;
  2709. UINT iblock_size = 0,
  2710. oblock_size = 0,
  2711. outlen = 0,
  2712. inlen = 0,
  2713. readlen = 0;
  2714. BOOL ret = true;
  2716. long fileLen = 0;//文件长度
  2717. long finishLen = 0;//完成长度
  2719. DWORD dProgLen = dBolckLen; //总共需要处理的长度
  2720. DWORD dProgFinshLen = 0;//已经处理的长度
  2723. CFile inSideFile;//内部文件
  2725. if(!inSideFile.Open(strFileName, CFile::modeCreate | CFile::modeWrite | CFile::typeBinary))
  2726. return -1;
  2728. iblock_size = BN_num_bytes(pRsa->n);//预接密长度 128
  2729. oblock_size = BN_num_bytes(pRsa->n) - 11;//杰密后长度 117
  2730. bufin=new unsigned char[iblock_size];
  2731. bufout=new unsigned char[oblock_size];
  2733. for(;;)
  2734. {
  2735. //每次 iblock_size 或实际长度
  2736. readlen = (dBolckLen > iblock_size) ? iblock_size:dBolckLen;//内存区域长度
  2737. inlen = File.Read(bufin, readlen);
  2739. if(inlen == 0)//可能加密时文件长度为0
  2740. break;
  2742. outlen = RSA_private_decrypt(inlen,bufin,bufout,pRsa,RSA_PKCS1_PADDING);
  2743. if (outlen == -1)//加密后资料长度
  2744. {
  2745. outStr = "RSA解密失败";
  2746. ret=FALSE;
  2747. goto err;
  2748. }
  2749. inSideFile.Write(bufout, outlen);
  2751. dReturnLen += outlen;
  2752. memset(bufout,0,oblock_size);
  2754. dBolckLen -= inlen;
  2755. if(dBolckLen <= 0) break;
  2757. dProgFinshLen += inlen;
  2758. DrawProg(dProgFinshLen*HUNDRED/dProgLen);
  2759. }
  2761. err:
  2762. inSideFile.Close();
  2763. // if(pRsa) RSA_free(pRsa);
  2764. delete [] bufin;
  2765. delete [] bufout;
  2766. if(!ret)
  2767. return -1;
  2768. else return dReturnLen;
  2769. }
  2771. DWORD CEvp::RSAPrivEnc2(RSA * pRsa, const CString strFileName, CFile & File, CString & outStr)
  2772. {
  2773. if(pRsa == NULL)
  2774. {
  2775. outStr = "RSA非法";
  2776. return -1;
  2777. }
  2778. UINT iblock_size = 0, //输入块长度
  2779.  oblock_size = 0; //输出块长度
  2781. unsigned char * bufin=NULL,
  2782.   * bufout=NULL;
  2784. int inlen = 0,
  2785. outlen = 0;
  2787. BOOL ret = TRUE;
  2788. long fileLen = 0;//文件长度
  2789. long finishLen = 0;//完成长度
  2790. DWORD returnLen = 0;//最后返回文件加密后长度
  2792. DWORD dProgLen = 0; //总共需要处理的长度
  2793. DWORD dProgFinshLen = 0;//已经处理的长度
  2796. CFile inSideFile;//内部文件
  2797. if(!inSideFile.Open(strFileName, CFile::modeRead | CFile::typeBinary))
  2798. {
  2799. outStr = "不能打开指定文件";
  2800. return -1;
  2801. }
  2803. dProgLen = inSideFile.GetLength();
  2805. iblock_size = BN_num_bytes(pRsa->n) - 11;//预加密长度,117
  2806. oblock_size = BN_num_bytes(pRsa->n);//加密后长度,128
  2807. bufin = new unsigned char[iblock_size];
  2808. memset(bufin,0,iblock_size);
  2809. bufout = new unsigned char[oblock_size];
  2810. memset(bufout,0,oblock_size);
  2811. for(;;)
  2812. {
  2813. inlen = inSideFile.Read(bufin, iblock_size);
  2814. if(!inlen)
  2815. break;
  2816. outlen = RSA_private_encrypt(inlen,bufin,bufout,pRsa,RSA_PKCS1_PADDING);
  2817. if (outlen == -1)//加密后资料长度
  2818. {
  2819. outStr = "RSA加密失败";
  2820. ret=FALSE;
  2821. goto err;
  2822. }
  2823. File.Write(bufout, outlen);
  2824. returnLen += outlen;
  2825. memset(bufout,0,oblock_size);
  2827. dProgFinshLen += inlen;
  2828. DrawProg(dProgFinshLen*HUNDRED/dProgLen);
  2829. }
  2831. err:
  2832. inSideFile.Close();
  2833. // if(pRsa) RSA_free(pRsa);
  2834. delete [] bufin;
  2835. delete [] bufout;
  2836. if(!ret)
  2837. return -1;
  2838. else
  2839. return returnLen;
  2840. }
  2842. DWORD CEvp::RSAPubDec2(RSA * pRsa, CFile & File, DWORD dBolckLen, const CString strFileName, CString & outStr)
  2843. {
  2844. if(pRsa == NULL)
  2845. {
  2846. outStr = "RSA非法";
  2847. return -1;
  2848. }
  2849. unsigned char * bufin = NULL,
  2850.   * bufout = NULL;
  2851. DWORD dReturnLen = 0;
  2852. UINT iblock_size = 0,
  2853. oblock_size = 0,
  2854. outlen = 0,
  2855. inlen = 0,
  2856. readlen = 0;
  2857. BOOL ret = true;
  2858. long fileLen = 0;//文件长度
  2859. long finishLen = 0;//完成长度
  2861. DWORD dProgLen = dBolckLen; //总共需要处理的长度
  2862. DWORD dProgFinshLen = 0;//已经处理的长度
  2865. CFile inSideFile;//内部文件
  2867. if(!inSideFile.Open(strFileName, CFile::modeCreate | CFile::modeWrite | CFile::typeBinary))
  2868. return -1;
  2870. iblock_size = BN_num_bytes(pRsa->n);//预接密长度 128
  2871. oblock_size = BN_num_bytes(pRsa->n) - 11;//杰密后长度 117
  2872. bufin=new unsigned char[iblock_size];
  2873. bufout=new unsigned char[oblock_size];
  2875. for(;;)
  2876. {
  2877. //每次 iblock_size 或实际长度
  2878. readlen = (dBolckLen > iblock_size) ? iblock_size:dBolckLen;//内存区域长度
  2879. inlen = File.Read(bufin, readlen);
  2880. if(inlen == 0)//可能加密时文件长度为0
  2881. break;
  2882. outlen = RSA_public_decrypt(inlen,bufin,bufout,pRsa,RSA_PKCS1_PADDING);
  2883. if (outlen == -1)//加密后资料长度
  2884. {
  2885. outStr = "RSA解密失败";
  2886. ret=FALSE;
  2887. goto err;
  2888. }
  2889. inSideFile.Write(bufout, outlen);
  2891. dReturnLen += outlen;
  2892. memset(bufout,0,oblock_size);
  2894. dBolckLen -= inlen;
  2895. if(dBolckLen <= 0) break;
  2897. dProgFinshLen += inlen;
  2898. DrawProg(dProgFinshLen*HUNDRED/dProgLen);
  2899. }
  2901. err:
  2902. inSideFile.Close();
  2903. // if(pRsa) RSA_free(pRsa);
  2904. delete [] bufin;
  2905. delete [] bufout;
  2906. if(!ret)
  2907. return -1;
  2908. else return dReturnLen;
  2909. }
  2911. /*数字签名*/
  2913. //功能:初始化对称加密结构
  2914. //支持目录加密
  2915. //返回值 : 成功TRUE
  2916. //    失败FALSE
  2917. //参数 : 
  2918. // strCpName - 算法名称
  2919. // strPwd - 密钥
  2920. // type - 类型 1 - 加密; 0 - 解密
  2921. // Ctx - 返回加密信息体
  2922. //调用时机: 加密前
  2923. BOOL CEvp::InitSign2(CString strMdName, EVP_MD_CTX & md_Ctx, const char * key/*签名时候用私钥,验证时候用公钥*/,
  2924.   const int keylen, const char * pwd/*私钥密码,为空时候标示输入为公钥*/, X509 *& x509, EVP_PKEY *& pkey)
  2925. {
  2926. const EVP_MD *md = NULL;
  2927. if(strMdName.IsEmpty())
  2928. {
  2929. // outStr = "未指定摘要算法";
  2930. return FALSE;
  2931. }
  2933. char outMsg[100] = {0};
  2935. if(pwd != NULL && strlen(pwd) != 0)
  2936. {
  2937. pkey = CCertKey::LoadKey((char *)key,keylen,(char *)pwd,outMsg);
  2938. if (pkey == NULL)
  2939. { 
  2940. return FALSE;
  2941. }
  2942. }
  2943. else
  2944. {
  2945. x509 = CCertKey::LoadCert((char *)key,keylen,(char *)pwd,outMsg);
  2946. if (x509 == NULL)
  2947. {
  2948. return FALSE;
  2949. }
  2950. pkey = X509_get_pubkey(x509);
  2951. if (pkey == NULL)
  2952. {
  2953. return FALSE;
  2954. }
  2955. }
  2957. //使EVP_Digest系列函数支持所有有效的信息摘要算法
  2958. OpenSSL_add_all_digests();
  2959.    
  2960. //根据输入的信息摘要函数的名字得到相应的EVP_MD算法结构
  2961. md = EVP_get_digestbyname(strMdName.GetBuffer(0));  
  2962. strMdName.ReleaseBuffer();
  2963. if(!md) 
  2964. {
  2965. // outStr.Format("未知摘要算法名称 %s",strMdName);
  2966. EVP_cleanup();
  2967. return FALSE;
  2968. }
  2970. //初始化信息摘要结构md_ctx。
  2971. EVP_MD_CTX_init(&md_Ctx);
  2973. if(!EVP_SignInit_ex(&md_Ctx,md,NULL))
  2974. {
  2975. EVP_cleanup();
  2976. return FALSE;
  2977. }
  2979. EVP_cleanup();
  2980. return TRUE;
  2981. }
  2983. //功能:清除对称加密结构
  2984. //调用:加密完毕后
  2985. void CEvp::CleanSign2(EVP_MD_CTX & md_Ctx, X509 *& px509, EVP_PKEY *& pkey)
  2986. {
  2987. if(md_Ctx.digest) 
  2988. EVP_MD_CTX_cleanup(&md_Ctx);
  2990. if(px509) X509_free(px509);
  2992. if(pkey) EVP_PKEY_free (pkey);
  2994. EVP_cleanup();
  2996. CRYPTO_cleanup_all_ex_data();
  2997. // CRYPTO_mem_leaks(bio_err);
  2998. }
  3000. DWORD CEvp::Sign2(EVP_MD_CTX * pCtx,
  3001.   EVP_PKEY *& pkey,
  3002.   const CString strFileName,
  3003.   CFile & File, CString & outStr)
  3004. {
  3005. BOOL ret=true;
  3006. unsigned char * sig_buf=NULL;
  3007. unsigned int sig_len,len=0;
  3008. unsigned char inbuf[BUFLEN]="";
  3010. CFile inSideFile;//内部文件
  3012. long fileLen=0;//文件长度
  3013. long finishLen=0;//完成长度
  3016. if(pCtx == NULL)
  3017. {
  3018. outStr = "未初始化加密结构";
  3019. return -1;
  3020. }
  3021. if(pkey == NULL)
  3022. {
  3023. outStr = "私钥非法";
  3024. return -1;
  3025. }
  3026. /* Do the signature */
  3027. if(!inSideFile.Open(strFileName, CFile::modeRead | CFile::typeBinary))
  3028. {
  3029. outStr = "不能打开指定文件";
  3030. return -1;
  3031. }
  3034. for(;;)
  3035. {
  3036. len = inSideFile.Read(inbuf, BUFLEN);
  3037. if(len <= 0) break;
  3038. if(!EVP_SignUpdate(pCtx, inbuf, len))
  3039. {
  3040. outStr = "中间过程出错";
  3041. ret=FALSE;
  3042. goto err;
  3043. }
  3044. finishLen+=len;
  3045. DrawProg(finishLen*HUNDRED/fileLen);
  3046. }
  3048. sig_len = EVP_PKEY_size(pkey);
  3049. sig_buf = new unsigned char[sig_len];
  3051. // 簽名後的結果，必須是個夠大視 private key 長度不同而不同，可以 EVP_PKEY_size() 取得
  3052. if(!EVP_SignFinal (pCtx, sig_buf, &sig_len, pkey))
  3053. {
  3054. outStr = "最终过程出错";
  3055. ret = FALSE;
  3056. }
  3057. File.Write(sig_buf, sig_len);
  3059. err:
  3060. inSideFile.Close();
  3062. delete [] sig_buf;
  3063. if(ret)
  3064. return sig_len;
  3065. else
  3066. return -1;
  3067. }
  3069. BOOL CEvp::VerifySign2(EVP_MD_CTX * pCtx, EVP_PKEY *& pkey, const CString strFileName,
  3070.   CFile & File, DWORD dBolckLen, CString & outStr)
  3071. {
  3072. unsigned char * sig_buf=NULL;
  3073. unsigned int sig_len,len=0;
  3074. unsigned char inbuf[BUFLEN]="";
  3075. BOOL ret = FALSE;
  3076. long fileLen=0;//文件长度
  3077. long finishLen=0;//完成长度
  3079. if(pCtx == NULL)
  3080. {
  3081. outStr = "未初始化加密结构";
  3082. return FALSE;
  3083. }
  3084. if(pkey == NULL)
  3085. {
  3086. outStr = "公钥非法";
  3087. return FALSE;
  3088. }
  3090. CFile inSideFile;
  3091. if(!inSideFile.Open(strFileName, CFile::modeRead | CFile::typeBinary))
  3092. {
  3093. outStr = "不能打开指定文件";
  3094. return FALSE;
  3095. }
  3096. for(;;)
  3097. {
  3098. len = File.Read(inbuf, BUFLEN);                  
  3099. if(len <= 0) break;
  3100. if(!EVP_VerifyUpdate (pCtx, inbuf, len))
  3101. {
  3102. outStr = "中间过程出错";
  3103. ret=FALSE;
  3104. goto err;
  3105. }
  3106. finishLen+=len;
  3107. DrawProg(finishLen*HUNDRED/fileLen);
  3108. }
  3110. sig_len = EVP_PKEY_size(pkey);//这里应该改动
  3111. sig_buf = new unsigned char[sig_len + 1];
  3113. File.Read(sig_buf, sig_len);
  3115. if(!EVP_VerifyFinal (pCtx, sig_buf, sig_len, pkey))
  3116. {
  3117. outStr = "最终过程出错";
  3118. ret=FALSE;
  3119. }
  3120. err:
  3121. delete [] sig_buf;
  3122. return ret;
  3123. }