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

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

CA认证

开发平台：

Visual C++

SafeDataSetPage.cpp：源码内容
  1. // SafeDataSetPage.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "minica.h"
  6. #include "SafeDataSetPage.h"
  7. #include "MiniMainDlg.h"
  8. #include "Evp.h"
  9. #include "rc.h"
  10. #include ".GenericClassLanguage.h"
  11. #include "minict.h"
  13. const UINT BUFLEN = 4096;
  14. #ifdef _DEBUG
  15. #define new DEBUG_NEW
  16. #undef THIS_FILE
  17. static char THIS_FILE[] = __FILE__;
  18. #endif
  20. //加密后文件格式如下
  21. /*
  22. ------------------------------------信息头开始-------------------------------------------------
  23. 文件版本标记 - Evp20
  24. 信息颈长度 - DWORD
  25. 信息颈长度CRC码 - UINT
  26. ------------------------------------信息颈开始-------------------------------------------------
  27. 信息颈内容  处理方式 公钥加密
  28.              包括:
  29.       加密方式 ENUM
  30.   信息体个数n INT
  31.       n个信息体CDataSafe
  33. ---------------------------------对于数字信封:这里还要附加-------------------------------------
  34. ------------------------EVP信息头开始----------------------------------
  35. // 加密后EVP信息颈长度 DWORD
  36. // 加密后EVP信息颈长度 CRC校验码 UINT
  37. // 加密后EVP信息颈
  38. // -------------------------------EVP信息颈开始---------------------------
  39. // 公钥个数n
  40. // n个
  41. // 公钥加密的对称密钥长度
  42. // 公钥加密的对称密钥内容
  43. // 向量IV
  44. // -------------------------------EVP信息颈结束---------------------------
  45. ------------------------------------------------------------------------------------------------
  46. ------------------------------------n个加密文件内容开始------------------------------------------------
  47. ************************************************************************************************
  48. ************************************************************************************************
  49. ************************************************************************************************
  50. ************************************************************************************************
  51. ************************************************************************************************
  52. ------------------------------------n个加密文件内容结束------------------------------------------------
  55. */
  57. /////////////////////////////////////////////////////////////////////////////
  58. // CSafeDataSetPage property page
  59. const char m_sHeadMark[6] = "Evp20";
  60. CProgressCtrlST * CSafeDataSetPage::m_pProgOne = NULL;
  62. IMPLEMENT_DYNCREATE(CSafeDataSetPage, CPropertyPage)
  64. CSafeDataSetPage::CSafeDataSetPage() : CPropertyPage(CSafeDataSetPage::IDD)
  65. {
  66. //{{AFX_DATA_INIT(CSafeDataSetPage)
  67. // NOTE: the ClassWizard will add member initialization here
  68. //}}AFX_DATA_INIT
  69. m_uIndex = 0;
  70. m_EncType = NONE;
  71. m_bIsEnc = TRUE;
  72. m_pParent = NULL;
  73. m_pPageCdb = NULL;
  74. }
  76. CSafeDataSetPage::~CSafeDataSetPage()
  77. {
  78. m_Image.Detach();
  79. }
  81. void CSafeDataSetPage::DoDataExchange(CDataExchange* pDX)
  82. {
  83. CPropertyPage::DoDataExchange(pDX);
  84. //{{AFX_DATA_MAP(CSafeDataSetPage)
  85. // DDX_Control(pDX, IDC_EDIT_PWD, m_XpEditPwd);
  86. DDX_Control(pDX, IDC_B_ENC, m_BEnc);
  87. DDX_Control(pDX, IDC_PROGRESS_ALL, m_ProgAll);
  88. DDX_Control(pDX, IDC_PROGRESS_ONE, m_ProgOne);
  89. DDX_Control(pDX, IDC_LIST_DATASET, m_DataSetList);
  90. //}}AFX_DATA_MAP
  91. }
  94. BEGIN_MESSAGE_MAP(CSafeDataSetPage, CPropertyPage)
  95. //{{AFX_MSG_MAP(CSafeDataSetPage)
  96. ON_NOTIFY(NM_RCLICK, IDC_LIST_DATASET, OnRclickListDataset)
  97. ON_NOTIFY(NM_DBLCLK, IDC_LIST_DATASET, OnDblclkListDataset)
  98. ON_BN_CLICKED(IDC_B_ENC, OnBEnc)
  99. ON_BN_CLICKED(IDC_RADIO1, OnRadio1)
  100. ON_BN_CLICKED(IDC_RADIO2, OnRadio2)
  101. ON_BN_CLICKED(IDC_RADIO5, OnRadio5)
  102. ON_BN_CLICKED(IDC_RADIO6, OnRadio6)
  103. ON_NOTIFY(LVN_KEYDOWN, IDC_LIST_DATASET, OnKeydownListDataset)
  104. ON_BN_CLICKED(IDC_RADIO3, OnRadio3)
  105. ON_BN_CLICKED(IDC_RADIO4, OnRadio4)
  106. ON_NOTIFY(HDN_BEGINDRAG, IDC_LIST_DATASET, OnBegindragListDataset)
  107. ON_NOTIFY(LVN_BEGINDRAG, IDC_LIST_DATASET, OnBegindragListDataset)
  108. //}}AFX_MSG_MAP
  109. ON_MESSAGE(DROPM_DROPOK, OnDropOk)
  110. END_MESSAGE_MAP()
  112. /////////////////////////////////////////////////////////////////////////////
  113. // CSafeDataSetPage message handlers
  114. CWinThread * pThreadEvpSet = NULL;
  115. UINT _EvpSetThread(LPVOID lparam)
  116. {
  117. CSafeDataSetPage * p=(CSafeDataSetPage *)lparam;
  118. ((CMiniMainDlg *)p->GetParentWnd())->SetItemIcon(MiniCT_0002,16);
  121. //解决XP进度条不刷新问题
  122. //解决方法,刷新父窗口
  123. p->m_ProgOne.SetPos(0);
  124. //得到进度条控件区域
  125. CRect rectProg;
  126. p->m_ProgOne.GetWindowRect(&rectProg);
  127. p->ScreenToClient(rectProg);//
  129.   //指定父窗口刷新区域
  130. p->InvalidateRect(rectProg, TRUE);
  132. if(p->GetIsEnc())//加密
  133. {
  134. switch(p->m_EncType)
  135. {
  136. case CSafeDataSetPage::NONE:
  137. break;
  138. case CSafeDataSetPage::CRYPT:
  139. p->DoCrypt();
  140. break;
  141. case CSafeDataSetPage::DIGEST:
  142. break;
  143. case CSafeDataSetPage::SIGN:
  144. p->DoSign();
  145. break;
  146. case CSafeDataSetPage::SEAL:
  147. p->DoSeal();
  148. break;
  149. case CSafeDataSetPage::PubEnc:
  150. p->DoRSAPubEnc();
  151. break;
  152. case CSafeDataSetPage::PrivEnc:
  153. p->DoRSAPrivEnc();
  154. break;
  155. default:
  156. break;
  157. }
  158. }
  159. else //解密
  160. {
  161. switch(p->m_EncType)
  162. {
  163. case CSafeDataSetPage::NONE:
  164. break;
  165. case CSafeDataSetPage::CRYPT:
  166. p->DoDecCrypt();
  167. break;
  168. case CSafeDataSetPage::DIGEST:
  169. break;
  170. case CSafeDataSetPage::SIGN:
  171. break;
  172. case CSafeDataSetPage::SEAL:
  173. p->DoOpenSeal();
  174. break;
  175. case CSafeDataSetPage::PubEnc:
  176. p->DoRSAPriDec();
  177. break;
  178. case CSafeDataSetPage::PrivEnc:
  179. p->DoRSAPubDec();
  180. break;
  181. default:
  182. break;
  183. }
  184. }
  186. ((CMiniMainDlg *)p->GetParentWnd())->SetItemIcon(MiniCT_0002, 4);
  187. return 0;
  188. }
  190. BOOL CSafeDataSetPage::OnInitDialog() 
  191. {
  192. CPropertyPage::OnInitDialog();
  194. // TODO: Add extra initialization here
  195. CXPStyleButtonST::SetAllThemeHelper(this, ((CMiniCaApp *)AfxGetApp())->GetThemeHelperST());
  196. m_BEnc.SetIcon(IDI_ICON_DENC);
  197. m_BEnc.OffsetColor(CButtonST::BTNST_COLOR_BK_IN, 30);
  199. if(!((CMiniCaApp *)AfxGetApp())->IsXpStyle())
  200. {
  201. // m_Progress.SetBitmap(IDB_BITMAP_PROG);
  202. ClassXP(GetDlgItem(IDC_COMBO_CRYPT)->m_hWnd,TRUE);
  203. ClassXP(GetDlgItem(IDC_RADIO1)->m_hWnd,TRUE);
  204. ClassXP(GetDlgItem(IDC_RADIO2)->m_hWnd,TRUE);
  205. ClassXP(GetDlgItem(IDC_RADIO3)->m_hWnd,TRUE);
  206. ClassXP(GetDlgItem(IDC_RADIO4)->m_hWnd,TRUE);
  207. ClassXP(GetDlgItem(IDC_RADIO5)->m_hWnd,TRUE);
  208. ClassXP(GetDlgItem(IDC_RADIO6)->m_hWnd,TRUE);
  209. }
  212. //初始化图像列表
  213. SHFILEINFO shfi = {0};
  215. HIMAGELIST m_hImlIcons = (HIMAGELIST)SHGetFileInfo(NULL, 0, 
  216. &shfi, sizeof(SHFILEINFO), SHGFI_SYSICONINDEX | SHGFI_SMALLICON);
  217. //得到系统ImageList
  218. //以后通过得到文件的图标索引添加图标
  220. m_Image.Attach(m_hImlIcons);
  222. m_DataSetList.SetImageList(&m_Image, LVSIL_SMALL);
  224. m_DataSetList.SetExtendedStyle(LVS_EX_GRIDLINES);
  226. m_DataSetList.InsertColumn(0, MiniCT_1300, LVCFMT_LEFT, 150);
  227. m_DataSetList.InsertColumn(1, MiniCT_1301, LVCFMT_LEFT, 75);
  228. m_DataSetList.InsertColumn(2, MiniCT_1302, LVCFMT_LEFT, 70);
  229. m_DataSetList.InsertColumn(3, MiniCT_1303, LVCFMT_LEFT, 70);
  230. m_DataSetList.InsertColumn(4, MiniCT_1304, LVCFMT_LEFT, 100);
  231. // m_DataSetList.InsertColumn(3, "进度", LVCFMT_LEFT, 100);
  233. SetDlgItemText(IDC_COMBO_CRYPT,"idea-cbc");
  234. SetDlgItemText(IDC_EDIT_PWD,"MiniCA");
  235. ((CComboBox *)GetDlgItem(IDC_COMBO_CRYPT))->SetCurSel(16);
  236. ((CButton *)GetDlgItem(IDC_RADIO2))->SetCheck(1);
  238. m_pParent = AfxGetMainWnd();
  240. CSafeDataSetPage::m_pProgOne = &m_ProgOne;
  242. m_Target.Reg(this, "SafeData");
  244. CMiniMainDlg * pMain = (CMiniMainDlg *)AfxGetMainWnd();
  245. if(pMain)
  246. {
  247. CWinEvpSheet * pSheet = (CWinEvpSheet *)(pMain->GetPage("CWinEvpSheet"));
  248. if(pSheet)
  249. m_pPageCdb = (CSafeDataCdbPage*)pSheet->GetPage("CSafeDataCdbPage");
  250. }
  252. return TRUE;  // return TRUE unless you set the focus to a control
  253.               // EXCEPTION: OCX Property Pages should return FALSE
  254. }
  256. /*
  257. 函数功能:向列表中添加记录
  258. strDataSet - 记录名称
  259. strFileLen - 记录大小
  260. strDate - 修改时间
  261. uImage - 显示的图像索引
  262. pParent - 父节点句柄,NULL表示添加为根节点
  263. */
  264. CSuperGridCtrl::CTreeItem * CSafeDataSetPage::AddDataSet(const CDataSafe * pDataSafe,
  265.  const CString strDataSet, 
  266.  const UINT uImage,
  267.  const DWORD & dOldLen, 
  268.  const DWORD dNewLen, 
  269.  CString strType,
  270.  CString strTime,
  271.  CSuperGridCtrl::CTreeItem * pParent)
  272. {
  273. CString strOldLen(""), strNewLen("");
  274. strOldLen.Format("%d", dOldLen);
  275. if(dNewLen != 0 )
  276. strNewLen.Format("%d", dNewLen);
  278. CItemInfo* lpItemInfo = new CItemInfo();
  279. lpItemInfo->SetDataSafe(pDataSafe);
  280. lpItemInfo->SetImage(uImage);
  281. lpItemInfo->SetItemText(strDataSet);
  282. lpItemInfo->AddSubItemText(strOldLen); //原始大小
  283. lpItemInfo->AddSubItemText(strNewLen); //加密后大小
  284. lpItemInfo->AddSubItemText(strType); //类型说明
  285. lpItemInfo->AddSubItemText(strTime); //修改时间
  287. if(!pParent)
  288. {
  289. // lpRoot->m_uIndex = m_uIndex + 1;
  290. return m_DataSetList.InsertRootItem(lpItemInfo);//previous on N.Y.P.D we call it CreateTreeCtrl(lp)
  291. }
  292. else
  293. {
  294. // lpItemInfo->m_uIndex = m_uIndex + 1;
  295. return m_DataSetList.InsertItem(pParent, lpItemInfo, FALSE);
  296. }
  297. }
  299. //添加文件到结构MAP
  300. //枚举到文件时候的操作
  301. void CSafeDataSetPage::AddFileList(const WIN32_FIND_DATA & FileData, 
  302.    CSuperGridCtrl::CTreeItem * hPitem,
  303.    const UINT uTempParent,
  304.    CString sFile,
  305.    DWORD & dFileLen)
  306. {
  308. SHFILEINFO sfi = {0};
  309. SHGetFileInfo(FileData.cFileName, FILE_ATTRIBUTE_NORMAL, &sfi,
  310. sizeof(SHFILEINFO), SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX | SHGFI_TYPENAME);
  312. //ftLastWriteTime
  314. SYSTEMTIME stime;
  315. FILETIME ftime; 
  316. FileTimeToLocalFileTime(&FileData.ftLastWriteTime, &ftime); // 转换成本地时间 
  317. FileTimeToSystemTime(&ftime, &stime); // 转换成系统时间格式
  319. //文件大小
  320.   //  StrFormatByteSize(rFind.nFileSizeLow, szFileLen, 64 );
  322. dFileLen = (FileData.nFileSizeHigh * (MAXDWORD+1)) + FileData.nFileSizeLow;
  324. //时间
  325. CString strTime;
  326. strTime.Format("%d-%d-%d %d:%d", stime.wYear, stime.wMonth, stime.wDay, stime.wHour, stime.wMinute);
  328. CDataSafe DataSafe(FileData.cFileName, dFileLen, 
  329. FileData.ftLastWriteTime, TRUE, uTempParent, sFile.GetBuffer(0));
  331. AddDataSet(&DataSafe, FileData.cFileName, sfi.iIcon, dFileLen, 0, sfi.szTypeName, strTime, hPitem);
  333. // ++m_uIndex; 
  335. }
  337. BOOL CSafeDataSetPage::AddList(CString sLocalDir, UINT uPid, 
  338.    CSuperGridCtrl::CTreeItem * hPitem)
  339. {
  340.     POSITION pos = m_DirName.GetHeadPosition();
  341.     while ( NULL != pos )
  342.     {
  343. if(m_DirName.GetNext(pos).Compare(sLocalDir) == 0)//重复
  344. return TRUE;
  345.     }
  346. m_DirName.AddHead(sLocalDir);
  347. //判断是否为磁盘,如果为磁盘,则后面添加*.*
  348. if(sLocalDir.GetLength() == 3 && sLocalDir.Find(":") != -1)
  349. sLocalDir += "*.*";
  350. return EnumDir(sLocalDir, uPid, hPitem);
  351. }
  353. /*BOOL CSafeDataSetPage::GetDirTime(CString DirName, FILETIME &ftime, CString & strTime)
  354. {
  355. FILETIME lpCreationTime; // 文件夹的创建时间 
  356. FILETIME lpLastAccessTime; // 对文件夹的最近访问时间 
  357. FILETIME lpLastWriteTime; // 文件夹的最近修改时间 
  358. // 打开文件夹
  359. HANDLE hDir = CreateFile (DirName, GENERIC_READ, 
  360. FILE_SHARE_READ|FILE_SHARE_DELETE, 
  361. NULL, OPEN_EXISTING, 
  362. FILE_FLAG_BACKUP_SEMANTICS, NULL); 
  364. if(INVALID_HANDLE_VALUE == hDir)
  365. return FALSE;
  366. // 获取文件夹时间属性信息
  367. SYSTEMTIME stime;
  369. if (GetFileTime(hDir, &lpCreationTime, &lpLastAccessTime, &lpLastWriteTime))
  370. { 
  371. FileTimeToLocalFileTime(&lpLastWriteTime, &ftime); // 转换成本地时间 
  372. FileTimeToSystemTime(&ftime, &stime); // 转换成系统时间格式
  373. } 
  374. CloseHandle(hDir); // 关闭打开过的文件夹
  376. strTime.Format("%d-%d-%d %d:%d", stime.wYear, stime.wMonth, stime.wDay, stime.wHour, stime.wMinute);
  378. return TRUE;
  379. }*/
  382. //枚举目录,如果是文件,直接添加到列表中
  383. BOOL CSafeDataSetPage::EnumDir(CString strPath, UINT uPid, 
  384.    CSuperGridCtrl::CTreeItem * hPitem)
  385. {
  386. DWORD dDirLen = 0;
  387. WIN32_FIND_DATA wfd = {0};
  389. HANDLE hFind = FindFirstFile (strPath, &wfd);
  390. BOOL bResult = (hFind == INVALID_HANDLE_VALUE) ? FALSE : TRUE;
  392. CSuperGridCtrl::CTreeItem *  pItem = NULL;
  393. UINT uTempParent = 0;
  395. CString strTime;
  396. SYSTEMTIME stime;
  397. FILETIME ftime; 
  399. while (bResult)
  400. {
  401. if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY && wfd.cFileName[0] != '.' && wfd.cFileName[0] != '..') // folder
  402. {
  403. SHFILEINFO sfi = {0};
  404. SHGetFileInfo (NULL, FILE_ATTRIBUTE_DIRECTORY, &sfi, sizeof(SHFILEINFO),
  405. SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX | SHGFI_TYPENAME);
  407. FileTimeToLocalFileTime(&wfd.ftLastWriteTime, &ftime); // 转换成本地时间 
  408. FileTimeToSystemTime(&ftime, &stime); // 转换成系统时间格式
  410. strTime.Format("%d-%d-%d %d:%d", stime.wYear, stime.wMonth, stime.wDay, stime.wHour, stime.wMinute);
  412. CString strFileName = strPath;
  413. strFileName.Replace("*.*", wfd.cFileName);
  415. CDataSafe DataSafe(wfd.cFileName, 0, wfd.ftLastWriteTime, FALSE, uPid, strFileName);
  417. pItem = AddDataSet(&DataSafe, wfd.cFileName, sfi.iIcon, 0, 0, sfi.szTypeName, strTime, hPitem);
  419. uTempParent = ++m_uIndex;
  421. //进入目录
  422. CString strPathName = strPath; //枚举此文件夹下面的所有内容
  423. strPathName.Replace("*.*", wfd.cFileName);
  424. strPathName += "\*.*";
  425. EnumDir(strPathName, uTempParent, pItem);
  426. }
  427. bResult = FindNextFile (hFind, &wfd);
  428. }
  429. FindClose (hFind);
  431. // read files
  432. hFind = FindFirstFile (strPath, &wfd);
  433. bResult = (hFind == INVALID_HANDLE_VALUE) ? FALSE : TRUE;
  435. while (bResult)
  436. {
  437. if (!(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && wfd.cFileName[0] != '.' && wfd.cFileName[0] != '') // no folder or parent folder
  438. {
  439. CString strFileName = strPath;
  440. strFileName.Replace("*.*", wfd.cFileName);
  441. DWORD dFileLen = 0;
  442. AddFileList(wfd, hPitem, uPid, strFileName, dFileLen);
  443. dDirLen += dFileLen;
  444. //累加所有文件长度,然后显示在列表中,并修改父结构长度
  445. }
  446. bResult = FindNextFile (hFind, &wfd);
  447. }
  448. FindClose (hFind);
  449. CString str;
  450. str.Format("%d", dDirLen);
  451. if(hPitem)
  452. {
  453. int index = m_DataSetList.GetCurIndex(hPitem);
  454. if(index != -1)
  455. m_DataSetList.SetItemText(index, 1, str);
  456. }
  459. return bResult;
  460. }
  463. void CSafeDataSetPage::OnRclickListDataset(NMHDR* pNMHDR, LRESULT* pResult) 
  464. {
  465. // TODO: Add your control notification handler code here
  466. int i = m_DataSetList.GetSelectedItem();
  467. if(i == -1)
  468. return;
  469. CSuperGridCtrl::CTreeItem * pItem = m_DataSetList.GetTreeItem(i);
  470. CItemInfo * pInfo = m_DataSetList.GetData(pItem ); 
  472. const CDataSafe * pDataSafe = pInfo->GetDataSafe();
  475. CString str;
  476. str.Format("文件名%s 偏移%d 长度%d", pDataSafe->cName, pDataSafe->dBeginSeek, pDataSafe->dNewLen);
  477. AfxMessageBox(str);
  478. *pResult = 0;
  479. }
  482. //加载硬盘里面的.evp文件,读取文件信息,并写入MAP,然后显示在列表中
  483. BOOL CSafeDataSetPage::ParseEvp(CString strEvpFile, EncType & encType)
  484. {
  485. m_uIndex = 0; //添加目录时候不清0,因为可能多次添加
  487. CFile File;
  488. if(!File.Open(strEvpFile, CFile::modeRead | CFile::typeBinary))
  489. {
  490. AfxMessageBox(MiniCT_1320);
  491. return FALSE;
  492. }
  493. //读取文件前5个字母,判断是否为Evp20
  494. char sHeadMark[6] = {0};
  495. File.Read(sHeadMark, strlen(m_sHeadMark));
  496. if(strcmp(sHeadMark, m_sHeadMark)!=0)
  497. {
  498. //非EVP文件,返回
  499. File.Close();
  500. AfxMessageBox(MiniCT_1305);
  501. return FALSE;
  502. }
  503. DWORD dFileInfoLen = 0; 
  504. File.Read(&dFileInfoLen, sizeof(DWORD));
  505. //校验CRC,类型UINT
  506. UINT uCrcCheck = 0;
  507. File.Read(&uCrcCheck, sizeof(UINT));
  508. if(!CRC::CheckCrc((char *)&dFileInfoLen, sizeof(DWORD), uCrcCheck))
  509. {
  510. AfxMessageBox(MiniCT_1306);
  511. File.Close();
  512. return FALSE;
  513. }
  515. //开辟缓冲区,容纳加密后的信息体
  516. BYTE * pIn = new BYTE[dFileInfoLen + 1];
  517. File.Read(pIn, dFileInfoLen);
  519. HRSRC hRsrc = FindResource(NULL,MAKEINTRESOURCE(IDR_FILE_KEY),"CERT");
  520. DWORD lenKey = SizeofResource(NULL, hRsrc); 
  521. HGLOBAL hgKey = LoadResource(NULL,hRsrc);
  522. LPSTR lpKey = (LPSTR)LockResource(hgKey);
  524. DWORD dOutLen = dFileInfoLen;
  526. //开辟缓冲区,容纳解密后的信息体
  527. BYTE * pOut = new BYTE[dOutLen];
  529. CString outMsg;
  532. if(!CEvp::RSAPrivDec((BYTE *)lpKey, lenKey, "MiniCA", pIn, 
  533. dFileInfoLen, pOut, dOutLen, outMsg.GetBuffer(256)))
  534. {
  535. //解密失败
  536. AfxMessageBox(MiniCT_1307);
  537. File.Close();
  538. delete [] pIn;
  539. delete [] pOut;
  540. return FALSE;
  541. }
  543. CMemFile MemFile;
  544. MemFile.Attach(pOut, dOutLen);
  546. //首先是加密方式
  547. MemFile.Read(&encType, sizeof(EncType));
  548. m_EncType = encType;
  550. //然后是结构体个数
  551. UINT uIndex = 0;
  552. MemFile.Read(&uIndex, sizeof(uIndex));
  554. CSuperGridCtrl::CTreeItem * pItem[1024]; //只记录文件夹
  555. memset(pItem, 0, sizeof(CSuperGridCtrl::CTreeItem * ) * 1024);
  557. CMap<UINT, UINT, CSuperGridCtrl::CTreeItem *, CSuperGridCtrl::CTreeItem * > ItemMap;//记录目录ITEM的MAP
  558. ItemMap.SetAt(0, NULL);
  560. SHFILEINFO sfi = {0};
  563. //最后是n个结构体
  564. for(UINT index = 1, j = 1; index <= uIndex; index++, m_uIndex++) //读取文件信息到结构MAP
  565. {
  566. CDataSafe DataSafe;
  567. DataSafe.Read(MemFile);
  569. CSuperGridCtrl::CTreeItem * pParentItem = NULL;
  570. if(ItemMap.Lookup(DataSafe.uParentID, pParentItem))
  571. {
  573. SYSTEMTIME stime;
  574. FILETIME ftime; 
  575. FileTimeToLocalFileTime(&DataSafe.ftLastWriteTime, &ftime); // 转换成本地时间 
  576. FileTimeToSystemTime(&ftime, &stime); // 转换成系统时间格式
  578. //时间
  579. CString strTime;
  580. strTime.Format("%d-%d-%d %d:%d", stime.wYear, stime.wMonth, stime.wDay, stime.wHour, stime.wMinute);
  582. if(!DataSafe.bIsFile)//目录,记录下来
  583. {
  585. SHGetFileInfo (NULL, FILE_ATTRIBUTE_DIRECTORY, &sfi, sizeof(SHFILEINFO),
  586. SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX | SHGFI_TYPENAME);
  588. pItem[j] = AddDataSet(&DataSafe, DataSafe.cName, sfi.iIcon, 
  589. DataSafe.dOldLen, 0, sfi.szTypeName, strTime, pParentItem);
  590. ItemMap.SetAt(j, pItem[j]);
  591. j++;
  592. }
  593. else
  594. {
  595. SHGetFileInfo(DataSafe.cName, FILE_ATTRIBUTE_NORMAL, &sfi,
  596. sizeof(SHFILEINFO), SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX| SHGFI_TYPENAME );
  598. AddDataSet(&DataSafe, DataSafe.cName, sfi.iIcon, DataSafe.dOldLen, DataSafe.dNewLen,
  599. sfi.szTypeName, strTime, pParentItem);
  600. }
  601. }
  603. }
  605. delete [] pIn;
  606. delete [] pOut;
  608. MemFile.Close();
  609. File.Close();
  612. /* for(int index = 1, j = 0; index <= m_DataMap.GetCount(); index++, m_uIndex++)
  613. {
  614. }*/
  615. //如果分析成功,则转换为解密方式,需要完成,按钮等的变化
  616. // SetDlgItemText(IDC_B_ENC, "解密");
  617. m_BEnc.SetIcon(IDI_ICON_DDEC);
  619. ((CButton *)GetDlgItem(IDC_RADIO1))->SetCheck(0);
  620. ((CButton *)GetDlgItem(IDC_RADIO2))->SetCheck(0);
  621. ((CButton *)GetDlgItem(IDC_RADIO3))->SetCheck(0);
  622. ((CButton *)GetDlgItem(IDC_RADIO4))->SetCheck(0);
  623. ((CButton *)GetDlgItem(IDC_RADIO5))->SetCheck(0);
  624. ((CButton *)GetDlgItem(IDC_RADIO6))->SetCheck(0);
  626. GetDlgItem(IDC_RADIO1)->EnableWindow(0);
  627. GetDlgItem(IDC_RADIO2)->EnableWindow(0);
  628. GetDlgItem(IDC_RADIO3)->EnableWindow(0);
  629. GetDlgItem(IDC_RADIO4)->EnableWindow(0);
  630. GetDlgItem(IDC_RADIO5)->EnableWindow(0);
  631. GetDlgItem(IDC_RADIO6)->EnableWindow(0);
  633. switch(m_EncType)
  634. {
  635. case NONE:
  636. break;
  637. case CRYPT: //对称 1
  638. OnRadio1();
  639. GetDlgItem(IDC_RADIO1)->EnableWindow(1);
  640. ((CButton *)GetDlgItem(IDC_RADIO1))->SetCheck(1);
  641. break;
  642. case DIGEST: //摘要 3
  643. OnRadio3();
  644. GetDlgItem(IDC_RADIO3)->EnableWindow(1);
  645. ((CButton *)GetDlgItem(IDC_RADIO3))->SetCheck(1);
  646. break;
  647. case SIGN: //签名 4
  648. OnRadio3();
  649. GetDlgItem(IDC_RADIO4)->EnableWindow(1);
  650. ((CButton *)GetDlgItem(IDC_RADIO4))->SetCheck(1);
  651. break;
  652. case SEAL: //信封 2
  653. OnRadio4();
  654. GetDlgItem(IDC_RADIO2)->EnableWindow(1);
  655. ((CButton *)GetDlgItem(IDC_RADIO2))->SetCheck(1);
  656. break;
  657. case PubEnc:
  658. OnRadio5();
  659. GetDlgItem(IDC_RADIO5)->EnableWindow(1);
  660. ((CButton *)GetDlgItem(IDC_RADIO5))->SetCheck(1);
  661. break;
  662. case PrivEnc:
  663. OnRadio6();
  664. GetDlgItem(IDC_RADIO6)->EnableWindow(1);
  665. ((CButton *)GetDlgItem(IDC_RADIO6))->SetCheck(1);
  666. break;
  667. default:
  668. break;
  669. }
  670. m_bIsEnc = FALSE;
  671. m_strEvpPath = strEvpFile; //設置解密文件
  672. return TRUE;
  673. }
  675. CProgressCtrlST * CSafeDataSetPage::ShowProg(int nItem, int nCol)
  676. {
  677. // CString strFind = GetItemText(nItem, nCol);
  679. //basic code start
  680. CRect rect;
  681. int offset = 0;
  682. // Make sure that the item is visible
  683. if( !m_DataSetList.EnsureVisible(nItem, TRUE)) return NULL;
  684. m_DataSetList.GetSubItemRect(nItem, nCol, LVIR_BOUNDS, rect);
  685. // Now scroll if we need to expose the column
  686. CRect rcClient;
  687. m_DataSetList.GetClientRect(rcClient);
  688. if( offset + rect.left < 0 || offset + rect.left > rcClient.right )
  689. {
  690. CSize size;
  691. size.cx = offset + rect.left;
  692. size.cy = 0;
  693. m_DataSetList.Scroll(size);
  694. rect.left -= size.cx;
  695. }
  697. rect.left += offset;
  698. rect.right = rect.left + m_DataSetList.GetColumnWidth(nCol);
  699. if(rect.right > rcClient.right) 
  700.    rect.right = rcClient.right;
  701. //basic code end
  703. rect.bottom += rect.Height();//dropdown area
  705. DWORD dwStyle =  WS_CHILD | WS_VISIBLE;
  706. CProgressCtrlST *pProg = new CProgressCtrlST;
  707. pProg->Create(dwStyle, rect, this, 100050);
  708. pProg->SetBitmap(IDB_BITMAP_PROG);
  709. pProg->SetPos(40);
  710. // pList->ModifyStyleEx(0,WS_EX_CLIENTEDGE);//can we tell at all
  711. // pList->SetHorizontalExtent(CalcHorzExtent(pList, lstItems));
  712. // pList->ShowDropDown();
  713. // pList->SelectString(-1, strFind.GetBuffer(1));
  714. // The returned pointer should not be saved
  715. return pProg;
  716. }
  719. //功能:
  720. //写入 版本Evp20, 加密结构长度, 加密结构校验
  721. //移动文件到加密位置(掠过信息颈)
  722. //参数:
  723. //File - 用来加密文件的
  724. //nCount - 文件信息体个数
  725. //dFileInfoLen - 返回加密后长度
  726. //strMsg - 返回操作错误信息
  727. BOOL CSafeDataSetPage::MadeFileHead(CFile & File, const int nCount, DWORD & dFileInfoLen, CString & strMsg)
  728. {
  729. if(0 == nCount)
  730. {
  731. strMsg = MiniCT_1308;
  732. return FALSE;
  733. }
  735. HRSRC hRsrc = FindResource(NULL,MAKEINTRESOURCE(IDR_FILE_CERT),"CERT");
  736. DWORD lenCert = SizeofResource(NULL, hRsrc); 
  737. HGLOBAL hgCert = LoadResource(NULL,hRsrc);
  738. LPSTR lpCert = (LPSTR)LockResource(hgCert);
  741. //取得加密后文件信息体大小
  742. //文件信息体为: 加密方式sizeof(EncType) +  sizeof(int)(信息体个数 int 类型) + n个CDataSafe结构大小nCount * (sizeof(CDataSafe) - sizeof(char)*256
  743. //其中CDataSafe结构不写入文件全路径,所以 - sizeof(char)*256
  744. //
  745. dFileInfoLen = CEvp::GetEncLen(lpCert, lenCert, 
  746. sizeof(EncType) + sizeof(nCount) + nCount * (sizeof(CDataSafe) - sizeof(char)*256) );
  747. if(dFileInfoLen == -1)
  748. {
  749. strMsg = MiniCT_1309;
  750. return FALSE;
  751. }
  753. //写入版本标志Evp20
  754. File.Write(m_sHeadMark, strlen(m_sHeadMark));
  755. //写入加密后文件信息体大小,类型为DWORD
  756. File.Write(&dFileInfoLen, sizeof(DWORD));
  757. //写入CRC校验值,类型UINT
  758. UINT uCrcCheck = 0;
  759. if(CRC::GetCrc16((char *)&dFileInfoLen, sizeof(DWORD), uCrcCheck))
  760. {
  761. File.Write(&uCrcCheck, sizeof(UINT));
  762. }
  763. else
  764. {
  765. strMsg = MiniCT_1310; //"生成信息颈长度CRC校验失败";
  766. AddMsg(strMsg, M_ERROR);
  767. return FALSE;
  768. }
  770. //预留信息头 
  771. File.Seek(dFileInfoLen, CFile::current);
  772. return TRUE;
  773. }
  775. //功能: - 加密文件完毕后调用
  776. //写入 加密(加密方式+文件个数+文件信息体加密后长度)后内容
  777. //移动文件到加密位置
  778. //参数:
  779. //File - 用来加密文件的
  780. //encType - 加密方式
  781. //nCount - 文件信息体个数
  782. //dFileInfoLen - 加密后长度,用于分配内存
  783. //strMsg - 返回操作错误信息
  785. BOOL CSafeDataSetPage::MadeFileNeck(CList<CDataSafe *, CDataSafe *> * pDataList, CFile &File, 
  786. const EncType encType, const int nCount, 
  787. const DWORD dFileInfoLen, CString &strMsg)
  788. {
  789. //开始屏蔽进度显示 , 完毕后打开
  790. CSafeDataSetPage::m_pProgOne = NULL;
  792. //构造内存文件,写入 加密方式 + 信息体个数n + n个信息体
  793. CMemFile MemFile;
  795. MemFile.Write(&encType, sizeof(EncType));
  797. MemFile.Write(&nCount, sizeof(int));
  799. //枚举目录列表
  800. POSITION pos = pDataList->GetHeadPosition();
  801. while(pos != NULL)
  802. {
  803. CDataSafe* pDataSafe = pDataList->GetNext(pos);
  804. if(pDataSafe)
  805. pDataSafe->Write(MemFile);
  806. }
  807. //加密内存文件
  808. //构造加密结果 长度+1 内存
  809. DWORD dOutLen = -1;
  810. BYTE * pOut = new BYTE[dFileInfoLen + 1];
  811. dOutLen = dFileInfoLen;
  813. HRSRC hRsrc = FindResource(NULL,MAKEINTRESOURCE(IDR_FILE_CERT),"CERT");
  814. DWORD lenCert = SizeofResource(NULL, hRsrc); 
  815. HGLOBAL hgCert = LoadResource(NULL,hRsrc);
  816. LPSTR lpCert = (LPSTR)LockResource(hgCert);
  818. //构造加密输入
  819. DWORD dInLen = MemFile.GetLength();
  820. BYTE * pIn = MemFile.Detach(); //同时关闭MemFile.Close(); 此时不要重新开辟内存,而且Detach用malloc,所以释放用free
  823. if(!CEvp::RSAPubEnc((BYTE *)lpCert, lenCert, "", pIn, dInLen, 
  824. pOut, dOutLen, strMsg.GetBuffer(256)))
  825. {
  826. //加密失败
  827. strMsg.ReleaseBuffer();
  828. free(pIn);
  829. delete [] pOut;
  830. CSafeDataSetPage::m_pProgOne = &m_ProgOne;
  831. return FALSE;
  832. }
  833. else if(dOutLen != dFileInfoLen)
  834. {
  835. //加密失败
  836. strMsg.ReleaseBuffer();
  837. strMsg = MiniCT_1311;//"信息颈长度与预期不符";
  838. free(pIn);
  839. delete [] pOut;
  840. CSafeDataSetPage::m_pProgOne = &m_ProgOne;
  841. return FALSE;
  842. }
  844. CSafeDataSetPage::m_pProgOne = &m_ProgOne;
  846. //移动文件指针到开头 + "Evp20" + 加密后信息体大小DWORD + CRC校验UINT
  847. File.Seek(strlen(m_sHeadMark) + sizeof(DWORD) + sizeof(UINT), CFile::begin);
  848. File.Write(pOut, dFileInfoLen);
  849. free(pIn);
  851. delete [] pOut;
  852. return TRUE;
  853. }
  855. /////////////////////////////////////////////////////加密文件部分////////////////////////////////////////////////
  856. //功能:对称加密文件、目录
  857. //参数:
  858. // strCpName - 算法名称
  859. // strPwd- 对称密钥
  860. // strFileName - 加密后文件
  861. // outMsg - 返回操作信息
  862. BOOL CSafeDataSetPage::Crypt(CString strCpName, CString strPwd, CString strFileName, CString & outMsg)
  863. {
  864. //输入检查
  865. if(strCpName.IsEmpty() || strPwd.IsEmpty() || strFileName.IsEmpty())
  866. {
  867. outMsg = MiniCT_1312; //"算法名称或对称密钥或输出文件非法";
  868. return FALSE;
  869. }
  871. CFile File;//文件头加版本信息
  872. if(!File.Open(strFileName, CFile::modeCreate | CFile::modeWrite | CFile::typeBinary ))
  873. {
  874. outMsg.Format("%s : %s", MiniCT_1313,strFileName); //创建文件失败
  875. return FALSE;
  876. }
  878. int nCount = m_DataSetList.GetCount();
  880. DWORD dFileInfoLen = 0;
  882. //创建信息头
  883. if(!MadeFileHead(File, nCount, dFileInfoLen, outMsg))
  884. {
  885. File.Close();
  886. return FALSE;
  887. }
  889. DWORD dOutLen = -1;
  891. EVP_CIPHER_CTX Ctx, CtxTemp;
  892. if(!CEvp::InitCrypt2(strCpName, strPwd, 1, Ctx))
  893. {
  894. outMsg = MiniCT_1314; //"初始化加密结构失败";
  895. File.Close();
  896. return FALSE;
  897. }
  899. //枚举目录列表加密信息
  900. CList<CDataSafe *, CDataSafe *> DataList; //包含目录和文件得全部信息列表
  902. EnumList(&DataList);
  903. POSITION pos = DataList.GetHeadPosition();
  904. int iCount = DataList.GetCount();
  905. m_ProgAll.SetRange(0, iCount);
  906. int iFinish = 0;
  908. CString strInfo;
  910. while(pos != NULL)
  911. {
  912. CDataSafe* pDataSafe = DataList.GetNext(pos);
  913. if(pDataSafe)
  914. {
  915. if(pDataSafe->bIsFile) //文件则加密
  916. {
  917. strInfo.Format("%s %s ,%s %d %s", MiniCT_1315, pDataSafe->cName, MiniCT_1316, pDataSafe->dOldLen, MiniCT_1317);
  918. AddOnceMsg(strInfo);
  919. CtxTemp = Ctx;
  920. //结构中加密起始位置赋值
  921. pDataSafe->dBeginSeek = File.GetPosition();
  922. dOutLen = CEvp::Crypt2(&CtxTemp, pDataSafe->cPathName, File, 0, outMsg);
  923. if(dOutLen == -1)
  924. {
  925. CString str;
  926. str.Format("%s%s, %s%s", pDataSafe->cName, MiniCT_1318, MiniCT_1319, outMsg);//对称加密失败 失败原因:
  927. outMsg = str;
  928. File.Close();
  929. CleanList(&DataList);
  930. return FALSE;
  931. }
  932. else//结构赋值
  933. {
  934. pDataSafe->dNewLen = dOutLen;
  935. }
  936. }
  937. }
  939. m_ProgAll.SetPos(++iFinish);
  940. }
  942. //创建信息颈
  943. if(!MadeFileNeck(&DataList, File, CRYPT, nCount, dFileInfoLen, outMsg))
  944. {
  945. File.Close();
  946. CEvp::CleanCrypt2(Ctx);
  947. CleanList(&DataList);
  948. return FALSE;
  949. }
  951. CEvp::CleanCrypt2(Ctx);
  952. CleanList(&DataList);
  954. File.Close();
  955. return TRUE;
  956. }
  958. //对称解密
  959. BOOL CSafeDataSetPage::DecCrypt(CString strCpName, CString strPwd, CString strEvpFile, CString & outMsg)
  960. {
  961. //解密信息
  962. DWORD dOutLen = -1;
  964. BOOL bRet = TRUE;
  966. CFile File;
  967. if(!File.Open(strEvpFile, CFile::modeRead | CFile::typeBinary))
  968. {
  969. outMsg.Format("%s%s", MiniCT_1320, strEvpFile);//打开文件失败
  970. return FALSE;
  971. }
  973. EVP_CIPHER_CTX Ctx, CtxTemp;
  974. if(!CEvp::InitCrypt2(strCpName, strPwd, 0, Ctx))
  975. {
  976. outMsg = MiniCT_1314;//"初始化加密结构失败";
  977. File.Close();
  978. return FALSE;
  979. }
  981. CString strPathName;
  983. //枚举目录列表加密信息
  984. CList<CDataSafe *, CDataSafe *> DataList; //文件和目录信息列表
  985. CList<CDataSafe *, CDataSafe *> DirList; //目录信息列表
  987. EnumList(&DataList, &DirList);
  988. POSITION pos = DataList.GetHeadPosition();
  989. int iCount = DataList.GetCount();
  990. m_ProgAll.SetRange(0, iCount);
  991. int iFinish = 0;
  992. while(pos != NULL)
  993. {
  994. CDataSafe* pDataSafe = DataList.GetNext(pos);
  995. if(pDataSafe)
  996. {
  997. strPathName = GetPathName(pDataSafe, &DirList);
  998. if(pDataSafe->bIsFile) //文件
  999. {
  1000. //结构中加密起始位置赋值
  1001. CtxTemp = Ctx;
  1002. File.Seek(pDataSafe->dBeginSeek, CFile::begin);
  1003. dOutLen = CEvp::Crypt2(&CtxTemp, strPathName, 
  1004. File, pDataSafe->dNewLen, outMsg);
  1005. if(-1 == dOutLen)
  1006. {
  1007. bRet =  FALSE;
  1008. break;
  1009. }
  1010. else if(dOutLen != pDataSafe->dOldLen)
  1011. {
  1012. outMsg.Format("%s%s", strPathName, MiniCT_1321); //文件大小校验失败
  1013. bRet =  FALSE;
  1014. break;
  1015. }
  1016. }
  1017. else//目录 ->建立目录
  1018. {
  1019. if(!Mdir(strPathName, outMsg))
  1020. {
  1021. bRet =  FALSE;
  1022. break;
  1023. }
  1024. }
  1026. m_ProgAll.SetPos(++iFinish);
  1028. }
  1029. }
  1031. File.Close();
  1032. CleanList(&DataList);
  1033. CEvp::CleanCrypt2(Ctx);
  1034. return bRet;
  1035. }
  1037. //数集摘要
  1038. //参数: strMdName - 摘要算法名称
  1039. // strOutName - 保存结果的EVP文件名称
  1040. // outMsg - 返回操作信息
  1041. BOOL CSafeDataSetPage::Digest(CString strMdName, CString strOutName, CString & outMsg)
  1042. {
  1044. //输入检查
  1045. if(strMdName.IsEmpty() || strOutName.IsEmpty())
  1046. {
  1047. outMsg = MiniCT_1322;//"算法名称或输出文件非法";
  1048. return FALSE;
  1049. }
  1051. CFile File;//文件头加版本信息
  1052. if(!File.Open(strOutName, CFile::modeCreate | CFile::modeWrite | CFile::typeBinary ))
  1053. {
  1054. outMsg = MiniCT_1313;//"创建文件失败";
  1055. return FALSE;
  1056. }
  1058. int nCount = m_DataSetList.GetCount();
  1060. DWORD dFileInfoLen = 0;
  1062. //创建信息头
  1063. if(!MadeFileHead(File, nCount, dFileInfoLen, outMsg))
  1064. return FALSE;
  1066. DWORD dOutLen = -1;
  1068. EVP_MD_CTX mdCtx, mdCtxTemp;
  1070. //初始化CTX
  1071. CEvp::InitDigest2(strMdName, mdCtx);
  1073. //枚举目录列表加密信息
  1074. CList<CDataSafe *, CDataSafe *> DataList;
  1075. EnumList(&DataList);
  1076. POSITION pos = DataList.GetHeadPosition();
  1077. int iCount = DataList.GetCount();
  1078. m_ProgAll.SetRange(0, iCount);
  1079. int iFinish = 0;
  1080. while(pos != NULL)
  1081. {
  1082. CDataSafe* pDataSafe = DataList.GetNext(pos);
  1083. if(pDataSafe)
  1084. {
  1085. if(pDataSafe->bIsFile) //文件则加密
  1086. {
  1087. mdCtxTemp = mdCtx;
  1088. //结构中加密起始位置赋值
  1089. pDataSafe->dBeginSeek = File.GetPosition();
  1090. dOutLen = CEvp::Digest2(&mdCtxTemp, pDataSafe->cPathName, File, outMsg);
  1091. if(dOutLen == -1)
  1092. {
  1093. CString str;
  1094. str.Format("%s%s", MiniCT_1323, pDataSafe->cName); //摘要文件失败
  1095. outMsg = str;
  1096. File.Close();
  1097. CleanList(&DataList);
  1098. return FALSE;
  1099. }
  1100. else//结构赋值
  1101. {
  1102. pDataSafe->dNewLen = dOutLen;
  1103. }
  1105. }
  1107. m_ProgAll.SetPos(++iFinish);
  1109. }
  1110. }
  1112. //创建信息颈
  1113. if(!MadeFileNeck(&DataList, File, DIGEST, nCount, dFileInfoLen, outMsg))
  1114. {
  1115. File.Close();
  1116. CEvp::CleanDigest2(mdCtx);
  1117. CleanList(&DataList);
  1118. return FALSE;
  1119. }
  1120. File.Close();
  1121. CEvp::CleanDigest2(mdCtx);
  1122. CleanList(&DataList);
  1123. return TRUE;
  1124. }
  1126. //摘要验证
  1127. BOOL CSafeDataSetPage::VerifyDigest(CString strMdName, CString strEvpFile, CString & outStr)
  1128. {
  1129. EVP_MD_CTX mdCtx, mdCtxTemp;
  1131. //解密信息
  1133. BOOL bRet = TRUE;
  1135. CFile File;
  1136. if(!File.Open(strEvpFile, CFile::modeRead | CFile::typeBinary))
  1137. {
  1138. outStr.Format("%s%s", MiniCT_1320, strEvpFile); //打开文件失败
  1139. return FALSE;
  1140. }
  1142. // 文件版本标记 - Evp20
  1143. // 信息颈长度 - DWORD
  1144. // 信息颈长度CRC码 - UINT
  1145. File.Seek(strlen(m_sHeadMark), CFile::begin);
  1147. DWORD dFileInfoLen = 0; 
  1148. File.Read(&dFileInfoLen, sizeof(DWORD));
  1150. File.Seek(sizeof(UINT), CFile::current);
  1152. File.Seek(dFileInfoLen, CFile::current);
  1155. //初始化CTX
  1156. CEvp::InitDigest2(strMdName, mdCtx);
  1157. {
  1158. File.Close();
  1159. return FALSE;
  1160. }
  1162. CString strPathName;
  1164. //枚举目录列表加密信息
  1165. CList<CDataSafe *, CDataSafe *> DataList; //文件和目录信息列表
  1166. CList<CDataSafe *, CDataSafe *> DirList; //目录信息列表
  1168. EnumList(&DataList, &DirList);
  1169. POSITION pos = DataList.GetHeadPosition();
  1170. int iCount = DataList.GetCount();
  1171. m_ProgAll.SetRange(0, iCount);
  1172. int iFinish = 0;
  1173. while(pos != NULL)
  1174. {
  1175. CDataSafe* pDataSafe = DataList.GetNext(pos);
  1176. if(pDataSafe)
  1177. {
  1178. strPathName = GetPathName(pDataSafe, &DirList);
  1179. if(pDataSafe->bIsFile) //文件
  1180. {
  1181. //结构中加密起始位置赋值
  1182. mdCtxTemp = mdCtx;
  1183. File.Seek(pDataSafe->dBeginSeek, CFile::begin);
  1185. bRet = CEvp::VerifyDigest2(&mdCtxTemp, strPathName, File, pDataSafe->dNewLen, outStr);
  1187. }
  1188. m_ProgAll.SetPos(++iFinish);
  1190. }
  1191. }
  1193. CleanList(&DataList);
  1194. File.Close();
  1195. CEvp::CleanDigest2(mdCtx);
  1196. return bRet;
  1197. }
  1199. //数字签名
  1200. BOOL CSafeDataSetPage::Sign(CString strMdName, const BYTE * pCertBuf, const UINT nCertLen, CString strPwd,
  1201.   CString strOutName, CString & outStr)
  1202. {
  1204. EVP_MD_CTX md_Ctx = {0};
  1205. EVP_PKEY * pkey = NULL;
  1206. X509 * px509 = NULL;
  1207. CEvp::InitSign2(strMdName, md_Ctx, (char *)pCertBuf, nCertLen, strPwd, px509, pkey);
  1209. CFile File;//文件头加版本信息
  1210. if(!File.Open(strOutName, CFile::modeCreate | CFile::modeWrite | CFile::typeBinary ))
  1211. {
  1212. outStr.Format("%s%s", MiniCT_1313, strOutName);//创建文件失败
  1213. return FALSE;
  1214. }
  1216. int nCount = m_DataSetList.GetCount();
  1218. DWORD dFileInfoLen = 0;
  1220. //创建信息头
  1221. if(!MadeFileHead(File, nCount, dFileInfoLen, outStr))
  1222. {
  1223. File.Close();
  1224. return FALSE;
  1225. }
  1227. DWORD dOutLen = -1;
  1229. //枚举目录列表加密信息
  1230. CList<CDataSafe *, CDataSafe *> DataList;
  1231. EnumList(&DataList);
  1232. POSITION pos = DataList.GetHeadPosition();
  1233. int iCount = DataList.GetCount();
  1234. m_ProgAll.SetRange(0, iCount);
  1235. int iFinish = 0;
  1236. CString strInfo;
  1237. while(pos != NULL)
  1238. {
  1239. CDataSafe* pDataSafe = DataList.GetNext(pos);
  1240. if(pDataSafe)
  1241. {
  1242. if(pDataSafe->bIsFile) //文件则加密
  1243. {
  1244. //结构中加密起始位置赋值
  1245. // strInfo.Format("文件 %s ,大小 %d 加密中...", pDataSafe->cName, pDataSafe->dOldLen);
  1246. strInfo.Format("%s %s ,%s %d %s", MiniCT_1315, pDataSafe->cName, MiniCT_1316, pDataSafe->dOldLen, MiniCT_1317);
  1247. AddOnceMsg(strInfo);
  1249. pDataSafe->dBeginSeek = File.GetPosition();
  1251. dOutLen = CEvp::Sign2(&md_Ctx, pkey, pDataSafe->cPathName, File, outStr);
  1253. if(dOutLen == -1)
  1254. {
  1255. CString str;
  1256. str.Format("%s%s, %s%s", MiniCT_1324, pDataSafe->cName, MiniCT_1319, outStr); //签名失败%s, 失败原因:%s
  1257. outStr = str;
  1258. File.Close();
  1259. CleanList(&DataList);
  1260. return FALSE;
  1261. }
  1262. else//结构赋值
  1263. {
  1264. pDataSafe->dNewLen = dOutLen;
  1265. }
  1266. }
  1268. m_ProgAll.SetPos(++iFinish);
  1270. }
  1272. }
  1274. //创建信息颈
  1275. if(!MadeFileNeck(&DataList, File, SIGN, nCount, dFileInfoLen, outStr))
  1276. {
  1277. File.Close();
  1278. CleanList(&DataList);
  1279. CEvp::CleanSign2(md_Ctx, px509, pkey);
  1280. return FALSE;
  1281. }
  1282. CEvp::CleanSign2(md_Ctx, px509, pkey);
  1283. File.Close();
  1284. CleanList(&DataList);
  1285. return TRUE;
  1286. }
  1288. //验证数字签名
  1289. BOOL CSafeDataSetPage::VerifySign(CString strMdName, const BYTE * pCertBuf, const UINT nCertLen,
  1290.   CString strEvpFile, CString & outStr)
  1291. {
  1293. EVP_MD_CTX mdCtx = {0},
  1294. mdCtxTemp = {0};
  1295. EVP_PKEY * pkey = NULL;
  1296. X509 * px509 = NULL;
  1298. BOOL bRet = TRUE;
  1300. CFile File;
  1301. if(!File.Open(strEvpFile, CFile::modeRead | CFile::typeBinary))
  1302. {
  1303. outStr.Format("%s%s", MiniCT_1320, strEvpFile);//"打开文件失败%s"
  1304. return FALSE;
  1305. }
  1307. CEvp::InitSign2(strMdName, mdCtx, (char *)pCertBuf, nCertLen, NULL, px509, pkey);
  1309. // 文件版本标记 - Evp20
  1310. // 信息颈长度 - DWORD
  1311. // 信息颈长度CRC码 - UINT
  1312. File.Seek(strlen(m_sHeadMark), CFile::begin);
  1314. DWORD dFileInfoLen = 0; 
  1315. File.Read(&dFileInfoLen, sizeof(DWORD));
  1317. File.Seek(sizeof(UINT), CFile::current);
  1319. File.Seek(dFileInfoLen, CFile::current);
  1320. CString strPathName;
  1322. //枚举目录列表加密信息
  1323. CList<CDataSafe *, CDataSafe *> DataList; //文件和目录信息列表
  1324. CList<CDataSafe *, CDataSafe *> DirList; //目录信息列表
  1326. EnumList(&DataList, &DirList);
  1327. POSITION pos = DataList.GetHeadPosition();
  1328. int iCount = DataList.GetCount();
  1329. m_ProgAll.SetRange(0, iCount);
  1330. int iFinish = 0;
  1331. while(pos != NULL)
  1332. {
  1333. CDataSafe* pDataSafe = DataList.GetNext(pos);
  1334. if(pDataSafe)
  1335. {
  1336. strPathName = GetPathName(pDataSafe, &DirList);
  1337. if(pDataSafe->bIsFile) //文件
  1338. {
  1339. //结构中加密起始位置赋值
  1340. mdCtxTemp = mdCtx;
  1341. File.Seek(pDataSafe->dBeginSeek, CFile::begin);
  1342. bRet = CEvp::VerifySign2(&mdCtxTemp, pkey, strPathName, File, pDataSafe->dNewLen, outStr);
  1343. }
  1344. m_ProgAll.SetPos(++iFinish);
  1346. }
  1347. }
  1349. CleanList(&DataList);
  1350. File.Close();
  1351. CEvp::CleanDigest2(mdCtx);
  1352. return TRUE;
  1353. }
  1355. //功能:多证书数字信封
  1356. //参数:
  1357. // pCERT -- [in]合法用户公钥链
  1358. // strCpName -- 算法名称
  1359. // outMsg -- [OUT]返回错误信息
  1360. BOOL CSafeDataSetPage::Seal(CEvp::stuCertLink * pCERT, CString strCpName,
  1361. CString strOutName, CString & outMsg)
  1362. {
  1363. CFile File;//文件头加版本信息
  1364. if(!File.Open(strOutName, CFile::modeCreate | CFile::modeWrite | CFile::typeBinary ))
  1365. {
  1366. outMsg.Format("%s%s", MiniCT_1313, strOutName);//"创建文件失败%s"
  1367. return FALSE;
  1368. }
  1370. int nCount = m_DataSetList.GetCount();
  1372. DWORD dFileInfoLen = 0;
  1374. //创建信息头
  1375. if(!MadeFileHead(File, nCount, dFileInfoLen, outMsg))
  1376. {
  1377. File.Close();
  1378. return FALSE;
  1379. }
  1381. DWORD dOutLen = -1;
  1383. EVP_CIPHER_CTX eCtx, eCtxTemp;
  1385. //初始化CTX
  1386. if(!CEvp::InitSeal2(pCERT, strCpName, File, eCtx, outMsg))
  1387. {
  1388. File.Close();
  1389. return FALSE;
  1390. }
  1392. //枚举目录列表加密信息
  1393. CList<CDataSafe *, CDataSafe *> DataList;
  1394. EnumList(&DataList);
  1395. POSITION pos = DataList.GetHeadPosition();
  1396. int iCount = DataList.GetCount();
  1397. m_ProgAll.SetRange(0, iCount);
  1398. int iFinish = 0;
  1399. CString strInfo;
  1401. // CDC* pDC = m_DataSetList.GetDC();
  1402. while(pos != NULL)
  1403. {
  1404. // m_DataSetList.DrawProgressBar(pDC, 0, 2);
  1406. CDataSafe* pDataSafe = DataList.GetNext(pos);
  1407. if(pDataSafe)
  1408. {
  1409. if(pDataSafe->bIsFile) //文件则加密
  1410. {
  1411. //初始化CTX
  1412. // strInfo.Format("文件 %s ,大小 %d 加密中...", pDataSafe->cName, pDataSafe->dOldLen);
  1413. strInfo.Format("%s %s ,%s %d %s", MiniCT_1315, pDataSafe->cName, MiniCT_1316, pDataSafe->dOldLen, MiniCT_1317);
  1414. AddOnceMsg(strInfo);
  1415. eCtxTemp = eCtx;
  1416. //结构中加密起始位置赋值
  1417. pDataSafe->dBeginSeek = File.GetPosition();
  1418. dOutLen = CEvp::Seal2(&eCtxTemp, pDataSafe->cPathName, File, outMsg);
  1419. if(dOutLen == -1)
  1420. {
  1421. CString str;
  1422. str.Format("%s%s, %s%s", MiniCT_1325, pDataSafe->cName, MiniCT_1319, outMsg);//"封装文件失败%s, 失败原因:%s"
  1423. outMsg = str;
  1424. File.Close();
  1425. CleanList(&DataList);
  1426. return FALSE;
  1427. }
  1428. else//结构赋值
  1429. {
  1430. pDataSafe->dNewLen = dOutLen;
  1431. }
  1433. }
  1435. m_ProgAll.SetPos(++iFinish);
  1437. }
  1439. }
  1441. // m_DataSetList.ReleaseDC(pDC);
  1444. //创建信息颈
  1445. if(!MadeFileNeck(&DataList, File, SEAL, nCount, dFileInfoLen, outMsg))
  1446. {
  1447. File.Close();
  1448. CEvp::CleanSeal2(eCtx);
  1449. CleanList(&DataList);
  1450. return FALSE;
  1451. }
  1452. File.Close();
  1453. CEvp::CleanSeal2(eCtx);
  1454. CleanList(&DataList);
  1455. return TRUE;
  1456. }
  1458. //拆封数字信封
  1459. BOOL CSafeDataSetPage::OpenSeal(char * pKey, UINT ukeyLen, char * pwd, CString strCpName,
  1460. CString strEvpFile, CString & outStr)
  1461. {
  1462. //解密信息
  1463. DWORD dOutLen = -1;
  1465. BOOL bRet = TRUE;
  1467. CFile File;
  1468. if(!File.Open(strEvpFile, CFile::modeRead | CFile::typeBinary))
  1469. {
  1470. outStr.Format("%s%s", MiniCT_1320, strEvpFile);//"打开文件%s失败"
  1471. return FALSE;
  1472. }
  1474. // 文件版本标记 - Evp20
  1475. // 信息颈长度 - DWORD
  1476. // 信息颈长度CRC码 - UINT
  1478. File.Seek(strlen(m_sHeadMark), CFile::begin);
  1480. DWORD dFileInfoLen = 0; 
  1481. File.Read(&dFileInfoLen, sizeof(DWORD));
  1483. File.Seek(sizeof(UINT), CFile::current);
  1485. File.Seek(dFileInfoLen, CFile::current);
  1488. EVP_CIPHER_CTX Ctx, CtxTemp;
  1490. if(!CEvp::InitOpenSeal2(pKey, ukeyLen, pwd, strCpName, File, Ctx, outStr))
  1491. {
  1492. File.Close();
  1493. outStr.Format(MiniCT_1314);//"初始化加密结构失败"
  1494. return FALSE;
  1495. }
  1497. CString strPathName;
  1499. //枚举目录列表加密信息
  1500. CList<CDataSafe *, CDataSafe *> DataList; //文件和目录信息列表
  1501. CList<CDataSafe *, CDataSafe *> DirList; //目录信息列表
  1503. EnumList(&DataList, &DirList);
  1504. POSITION pos = DataList.GetHeadPosition();
  1505. int iCount = DataList.GetCount();
  1506. m_ProgAll.SetRange(0, iCount);
  1507. int iFinish = 0;
  1508. while(pos != NULL)
  1509. {
  1510. CDataSafe* pDataSafe = DataList.GetNext(pos);
  1511. if(pDataSafe)
  1512. {
  1513. strPathName = GetPathName(pDataSafe, &DirList);
  1514. if(pDataSafe->bIsFile) //文件
  1515. {
  1516. //结构中加密起始位置赋值
  1517. CtxTemp = Ctx;
  1518. File.Seek(pDataSafe->dBeginSeek, CFile::begin);
  1521. dOutLen = CEvp::OpenSeal2(CtxTemp, File, pDataSafe->dNewLen, strPathName, outStr);
  1522. if(-1 == dOutLen)
  1523. {
  1524. bRet =  FALSE;
  1525. break;
  1526. }
  1527. else if(dOutLen != pDataSafe->dOldLen)
  1528. {
  1529. outStr.Format("%s%s", MiniCT_1321, strPathName);//文件%s大小校验失败
  1530. bRet =  FALSE;
  1531. break;
  1532. }
  1533. }
  1534. else//目录 ->建立目录
  1535. {
  1536. if(!Mdir(strPathName, outStr))
  1537. {
  1538. bRet =  FALSE;
  1539. break;
  1540. }
  1541. }
  1543. m_ProgAll.SetPos(++iFinish);
  1545. }
  1546. }
  1548. CleanList(&DataList);
  1549. File.Close();
  1550. CEvp::CleanOpenSeal2(Ctx);
  1551. return bRet;
  1552. }
  1554. //公钥加密
  1555. BOOL CSafeDataSetPage::RSAPubEnc(const BYTE * pCertBuf, const UINT nCertLen,
  1556.   CString strOutName, CString & outStr)
  1557. {
  1559. RSA * pRsa = NULL;
  1560. if(!CEvp::GetPubRsa(pCertBuf, nCertLen,pRsa))
  1561. {
  1562. outStr.Format("%s", MiniCT_1326); //取得公钥RSA结构失败
  1563. return FALSE;
  1564. }
  1566. CFile File;//文件头加版本信息
  1567. if(!File.Open(strOutName, CFile::modeCreate | CFile::modeWrite | CFile::typeBinary ))
  1568. {
  1569. outStr.Format("%s%s", MiniCT_1313, strOutName);//创建文件失败%s
  1570. return FALSE;
  1571. }
  1573. int nCount = m_DataSetList.GetCount();
  1575. DWORD dFileInfoLen = 0;
  1577. //创建信息头
  1578. if(!MadeFileHead(File, nCount, dFileInfoLen, outStr))
  1579. {
  1580. File.Close();
  1581. return FALSE;
  1582. }
  1584. DWORD dOutLen = -1;
  1586. //枚举目录列表加密信息
  1587. CList<CDataSafe *, CDataSafe *> DataList;
  1588. EnumList(&DataList);
  1589. POSITION pos = DataList.GetHeadPosition();
  1590. int iCount = DataList.GetCount();
  1591. m_ProgAll.SetRange(0, iCount);
  1592. int iFinish = 0;
  1593. CString strInfo;
  1594. while(pos != NULL)
  1595. {
  1596. CDataSafe* pDataSafe = DataList.GetNext(pos);
  1597. if(pDataSafe)
  1598. {
  1599. if(pDataSafe->bIsFile) //文件则加密
  1600. {
  1601. //结构中加密起始位置赋值
  1602. strInfo.Format("%s %s ,%s %d %s", MiniCT_1315, pDataSafe->cName, MiniCT_1316, pDataSafe->dOldLen, MiniCT_1317);
  1603. // strInfo.Format("文件 %s ,大小 %d 加密中...", pDataSafe->cName, pDataSafe->dOldLen);
  1604. AddOnceMsg(strInfo);
  1605. pDataSafe->dBeginSeek = File.GetPosition();
  1607. dOutLen = CEvp::RSAPubEnc2(pRsa, pDataSafe->cPathName, File, outStr);
  1608. if(dOutLen == -1)
  1609. {
  1610. CString str;
  1611. str.Format("%s%s%s%s", MiniCT_1327, pDataSafe->cName, MiniCT_1319, outStr); //公钥加密文件失败%s,失败原因:%s
  1612. outStr = str;
  1613. File.Close();
  1614. CleanList(&DataList);
  1615. return FALSE;
  1616. }
  1617. else//结构赋值
  1618. {
  1619. pDataSafe->dNewLen = dOutLen;
  1620. }
  1621. }
  1623. m_ProgAll.SetPos(++iFinish);
  1626. }
  1628. }
  1630. //创建信息颈
  1631. if(!MadeFileNeck(&DataList, File, PubEnc, nCount, dFileInfoLen, outStr))
  1632. {
  1633. CleanList(&DataList);
  1634. File.Close();
  1635. CEvp::FreeRsa(pRsa);
  1636. return FALSE;
  1637. }
  1638. CEvp::FreeRsa(pRsa);
  1639. CleanList(&DataList);
  1640. File.Close();
  1641. return TRUE;
  1643. }
  1645. //私钥解密
  1646. BOOL CSafeDataSetPage::RSAPriDec(const BYTE * pCertBuf, const UINT nCertLen, CString strPwd, CString strEvpFile,
  1647.   CString & outStr)
  1648. {
  1649. RSA * pRsa = NULL;
  1650. if(!CEvp::GetPrivRsa(pCertBuf, nCertLen, strPwd, pRsa))
  1651. {
  1652. outStr.Format("%s", MiniCT_1326);//"取得私钥RSA结构失败"
  1653. return FALSE;
  1654. }
  1656. DWORD dOutLen = -1;
  1658. BOOL bRet = TRUE;
  1660. CFile File;
  1661. if(!File.Open(strEvpFile, CFile::modeRead | CFile::typeBinary))
  1662. {
  1663. outStr.Format("%s%s", MiniCT_1320, strEvpFile);//打开文件失败%s
  1664. return FALSE;
  1665. }
  1667. CString strPathName;
  1669. //枚举目录列表加密信息
  1670. CList<CDataSafe *, CDataSafe *> DataList; //文件和目录信息列表
  1671. CList<CDataSafe *, CDataSafe *> DirList; //目录信息列表
  1673. EnumList(&DataList, &DirList);
  1674. POSITION pos = DataList.GetHeadPosition();
  1675. int iCount = DataList.GetCount();
  1676. m_ProgAll.SetRange(0, iCount);
  1677. int iFinish = 0;
  1678. while(pos != NULL)
  1679. {
  1680. CDataSafe* pDataSafe = DataList.GetNext(pos);
  1681. if(pDataSafe)
  1682. {
  1683. strPathName = GetPathName(pDataSafe, &DirList);
  1684. if(pDataSafe->bIsFile) //文件
  1685. {
  1686. File.Seek(pDataSafe->dBeginSeek, CFile::begin);
  1687. dOutLen = CEvp::RSAPrivDec2(pRsa, File, pDataSafe->dNewLen, strPathName, outStr);
  1688. if(-1 == dOutLen)
  1689. {
  1690. bRet =  FALSE;
  1691. break;
  1692. }
  1693. else if(dOutLen != pDataSafe->dOldLen)
  1694. {
  1695. outStr.Format("%s%s", MiniCT_1321, strPathName);
  1696. bRet =  FALSE;
  1697. break;
  1698. }
  1699. }
  1700. else//目录 ->建立目录
  1701. {
  1702. if(!Mdir(strPathName, outStr))
  1703. {
  1704. bRet =  FALSE;
  1705. break;
  1706. }
  1707. }
  1709. m_ProgAll.SetPos(++iFinish);
  1711. }
  1712. }
  1714. CleanList(&DataList);
  1715. CEvp::FreeRsa(pRsa);
  1716. File.Close();
  1717. return bRet;
  1718. }
  1720. //私钥加密
  1721. BOOL CSafeDataSetPage::RSAPrivEnc(const BYTE * pCertBuf, const UINT nCertLen, CString strPwd,
  1722.   CString strOutName, CString & outStr)//私钥加密
  1723. {
  1725. RSA * pRsa = NULL;
  1726. if(!CEvp::GetPrivRsa(pCertBuf, nCertLen, strPwd, pRsa))
  1727. {
  1728. outStr.Format("%s", MiniCT_1326);//"取得私钥RSA结构失败"
  1729. return FALSE;
  1730. }
  1732. CFile File;//文件头加版本信息
  1733. if(!File.Open(strOutName, CFile::modeCreate | CFile::modeWrite | CFile::typeBinary ))
  1734. {
  1735. outStr.Format("%s%s", MiniCT_1313, strOutName);
  1736. return FALSE;
  1737. }
  1739. int nCount = m_DataSetList.GetCount();
  1741. DWORD dFileInfoLen = 0;
  1743. //创建信息头
  1744. if(!MadeFileHead(File, nCount, dFileInfoLen, outStr))
  1745. {
  1746. File.Close();
  1747. return FALSE;
  1748. }
  1750. DWORD dOutLen = -1;
  1752. //枚举目录列表加密信息
  1753. CList<CDataSafe *, CDataSafe *> DataList;
  1754. EnumList(&DataList);
  1755. POSITION pos = DataList.GetHeadPosition();
  1756. int iCount = DataList.GetCount();
  1757. m_ProgAll.SetRange(0, iCount);
  1758. int iFinish = 0;
  1759. CString strInfo;
  1760. while(pos != NULL)
  1761. {
  1762. CDataSafe* pDataSafe = DataList.GetNext(pos);
  1763. if(pDataSafe)
  1764. {
  1765. if(pDataSafe->bIsFile) //文件则加密
  1766. {
  1767. //结构中加密起始位置赋值
  1768. strInfo.Format("%s %s ,%s %d %s", MiniCT_1315, pDataSafe->cName, MiniCT_1316, pDataSafe->dOldLen, MiniCT_1317);
  1769. // strInfo.Format("文件 %s ,大小 %d 加密中...", pDataSafe->cName, pDataSafe->dOldLen);
  1770. AddOnceMsg(strInfo);
  1772. pDataSafe->dBeginSeek = File.GetPosition();
  1774. dOutLen = CEvp::RSAPrivEnc2(pRsa, pDataSafe->cPathName, File, outStr);
  1775. if(dOutLen == -1)
  1776. {
  1777. CString str;
  1778. str.Format("%s%s%s%s", MiniCT_1328, pDataSafe->cName, MiniCT_1319, outStr);//私钥加密文件失败%s, 失败原因:%s
  1779. outStr = str;
  1780. File.Close();
  1781. CleanList(&DataList);
  1782. return FALSE;
  1783. }
  1784. else//结构赋值
  1785. {
  1786. pDataSafe->dNewLen = dOutLen;
  1787. }
  1788. }
  1790. m_ProgAll.SetPos(++iFinish);
  1792. }
  1794. }
  1796. //创建信息颈
  1797. if(!MadeFileNeck(&DataList, File, PrivEnc, nCount, dFileInfoLen, outStr))
  1798. {
  1799. File.Close();
  1800. CleanList(&DataList);
  1801. CEvp::FreeRsa(pRsa);
  1802. return FALSE;
  1803. }
  1804. CEvp::FreeRsa(pRsa);
  1805. File.Close();
  1806. CleanList(&DataList);
  1807. return TRUE;
  1809. }
  1811. //公钥解密
  1812. BOOL CSafeDataSetPage::RSAPubDec(const BYTE * pCertBuf, const UINT nCertLen, CString strEvpFile,
  1813.  CString & outStr)
  1814. {
  1815. RSA * pRsa = NULL;
  1816. if(!CEvp::GetPubRsa(pCertBuf, nCertLen, pRsa))
  1817. {
  1818. outStr.Format("%s", MiniCT_1326);
  1819. return FALSE;
  1820. }
  1822. DWORD dOutLen = -1;
  1824. BOOL bRet = TRUE;
  1826. CFile File;
  1827. if(!File.Open(strEvpFile, CFile::modeRead | CFile::typeBinary))
  1828. {
  1829. outStr.Format("%s%s", MiniCT_1320, strEvpFile);//打开文件失败%s
  1830. return FALSE;
  1831. }
  1833. CString strPathName;
  1835. //枚举目录列表加密信息
  1836. CList<CDataSafe *, CDataSafe *> DataList; //文件和目录信息列表
  1837. CList<CDataSafe *, CDataSafe *> DirList; //目录信息列表
  1839. EnumList(&DataList, &DirList);
  1840. POSITION pos = DataList.GetHeadPosition();
  1841. int iCount = DataList.GetCount();
  1842. m_ProgAll.SetRange(0, iCount);
  1843. int iFinish = 0;
  1844. while(pos != NULL)
  1845. {
  1846. CDataSafe* pDataSafe = DataList.GetNext(pos);
  1847. if(pDataSafe)
  1848. {
  1849. strPathName = GetPathName(pDataSafe, &DirList);
  1850. if(pDataSafe->bIsFile) //文件
  1851. {
  1852. File.Seek(pDataSafe->dBeginSeek, CFile::begin);
  1853. dOutLen = CEvp::RSAPubDec2(pRsa, File, pDataSafe->dNewLen, strPathName, outStr);
  1854. if(-1 == dOutLen)
  1855. {
  1856. CString str;
  1857. str.Format("%s%s%s%s", MiniCT_1329, pDataSafe->cPathName, MiniCT_1319, outStr);//公钥解密文件失败%s, 失败原因:%s
  1858. outStr = str;
  1859. bRet =  FALSE;
  1860. break;
  1861. }
  1862. else if(dOutLen != pDataSafe->dOldLen)
  1863. {
  1864. outStr.Format("%s%s", MiniCT_1321, strPathName);
  1865. bRet =  FALSE;
  1866. break;
  1867. }
  1868. }
  1869. else//目录 ->建立目录
  1870. {
  1871. if(!Mdir(strPathName, outStr))
  1872. {
  1873. bRet =  FALSE;
  1874. break;
  1875. }
  1876. }
  1878. m_ProgAll.SetPos(++iFinish);
  1879. }
  1880. }
  1881. CleanList(&DataList);
  1882. CEvp::FreeRsa(pRsa);
  1883. File.Close();
  1884. return bRet;
  1885. }
  1886. ////////////////////////////////////////////////加密部分结束///////////////////////////////////////////////////
  1889. void CSafeDataSetPage::OnDblclkListDataset(NMHDR* pNMHDR, LRESULT* pResult)
  1890. {
  1891. // TODO: Add your control notification handler code here
  1892. //双击,如果是未加密的,则打开LIST中目录,文件则打开文件
  1893. //如果是加密的,就解密到临时目录,并打开
  1894. int nIndex = m_DataSetList.GetSelectedItem();
  1895. if(nIndex == -1)
  1896. return;
  1897. CSuperGridCtrl::CTreeItem * pItem = m_DataSetList.GetTreeItem(nIndex);
  1898. if(!pItem)
  1899. return;
  1900. CItemInfo * pInfo = m_DataSetList.GetData(pItem ); 
  1902. const CDataSafe * pDataSafe = pInfo->GetDataSafe();
  1903. if(pDataSafe == NULL)
  1904. return;
  1906. if(pDataSafe->bIsFile) //执行
  1907. {
  1908. CString strOut;
  1909. CString strPathName;
  1910. BOOL bSucceed = TRUE;
  1911. if(m_bIsEnc) //未加密文件
  1912. {
  1913. strPathName.Format("%s", pDataSafe->cPathName);
  1914. }
  1915. else //解密到临时目录
  1916. {
  1917. //取得临时路径
  1918. TCHAR szTempPath[MAX_PATH];
  1919. DWORD dwResult=:: GetTempPath (MAX_PATH, szTempPath);
  1920. ASSERT (dwResult);
  1922. //创建临时文件
  1923. // TCHAR szTempFile[MAX_PATH];
  1924. // UINT nResult = GetTempFileName (szTempPath, _T ("~mc"), 0, szTempFile);
  1926. strPathName.Format("%s\%s",szTempPath, pDataSafe->cName);
  1927. bSucceed = DecOneFile(m_strEvpPath, strPathName, pDataSafe->dBeginSeek, 
  1928. pDataSafe->dNewLen, pDataSafe->dOldLen, strOut);
  1929. }
  1931. if(bSucceed)
  1932. ShellExecute(this->m_hWnd, "open", strPathName, "", "", SW_SHOWNORMAL);
  1933. else
  1934. AddMsg(strOut, M_ERROR);
  1935. }
  1936. else//展开
  1937. {
  1938. BOOL bRedraw=0;
  1939. if(m_DataSetList.ItemHasChildren(pItem))
  1940. {
  1941. m_DataSetList.SetRedraw(0);
  1942. int nScrollIndex=0;
  1943. if(m_DataSetList.IsCollapsed(pItem))
  1944. {
  1945. if(m_DataSetList.OnItemExpanding(pItem, nIndex))
  1946. {
  1947. nScrollIndex = m_DataSetList.Expand(pItem, nIndex);
  1948. m_DataSetList.OnItemExpanded(pItem, nIndex);
  1949. bRedraw=1;
  1950. }
  1951. }
  1953. else 
  1954. {
  1955. if(m_DataSetList.OnCollapsing(pItem))
  1956. {
  1957. m_DataSetList.Collapse(pItem);
  1958. m_DataSetList.OnItemCollapsed(pItem);
  1959. bRedraw=1;
  1960. }
  1961. }
  1962. m_DataSetList.SetRedraw(1);
  1964. if(bRedraw)
  1965. {
  1966. CRect rc;
  1967. m_DataSetList.GetItemRect(nIndex,rc,LVIR_BOUNDS);
  1968. m_DataSetList.InvalidateRect(rc);
  1969. m_DataSetList.UpdateWindow();
  1970. m_DataSetList.EnsureVisible(nScrollIndex,1);
  1971. }
  1972. }//ItemHasChildren
  1973. }
  1975. *pResult = 0;
  1976. }
  1978. //只是解密时候用,加密时候结构中保存了路径信息
  1979. //给定某个结构信息,附加父信息在其上面
  1980. //例如,结构为文件结构,文件名为minica.rar
  1981. //父结构肯定为目录结构,目录名为minica
  1982. //minica的父结构也存在,目录名为vc
  1983. //vc没有分目录
  1984. //最后的附加信息为:vc\minica\minica.rar
  1985. //参数: pDataSafe - 当前的结构信息
  1986. // uMinPid - 最小父结构ID
  1987. //解密时候可能不从根开始解密,这时候需要传递父lpParentItem
  1988. CString CSafeDataSetPage::GetPathName(CDataSafe* pDataSafe, 
  1989.   CList<CDataSafe *, CDataSafe *> * pDataList)
  1990. {
  1991. CString strAllPath, strPathName;//全部路径
  1993. if(!pDataSafe && !pDataList)
  1994. return strAllPath;
  1996. if(pDataSafe->uParentID == 0)//标示没有父
  1997. strPathName = pDataSafe->cName;
  1998. else
  1999. {
  2001. for(CDataSafe* pDataTemp = pDataSafe; ;)
  2002. {
  2003. strPathName = pDataTemp->cName + strPathName;
  2004. strPathName = "\" + strPathName;
  2005. if(pDataTemp->uParentID == 0)
  2006. break;
  2007. POSITION pos = pDataList->FindIndex( pDataTemp->uParentID - 1);
  2008. if(pos)
  2009. {
  2010. pDataTemp = pDataList->GetAt(pos);
  2011. }
  2012. else
  2013. break;
  2014. }
  2015. }
  2018. strAllPath.Format("%s\%s", m_strSavePath, strPathName); //解压到
  2019. if(strAllPath.GetAt(strAllPath.GetLength() - 1) == '\')
  2020. strAllPath = strAllPath.Left(strAllPath.GetLength() - 1);
  2021. return strAllPath;
  2022. }
  2024. BOOL CSafeDataSetPage::Mdir(CString strPathName, CString & strInfo)
  2025. {
  2026. strPathName += "\";
  2027. return CMiniCaApp::MakeSureDirectoryPathExists(strPathName);
  2028. /*if(_mkdir(strPathName) == -1)
  2029. {
  2030. if(errno==ENOENT)//目录没有发现
  2031. {
  2032. strInfo.Format("建立目录%s失败!",strPathName);
  2033. return FALSE;
  2034. }
  2035. }*/
  2037. }
  2039. void CSafeDataSetPage::OnRadio1() //对称加密按钮
  2040. {
  2041. // TODO: Add your control notification handler code here
  2042. GetDlgItem(IDC_STATIC_CHIPNAME)->EnableWindow(TRUE);
  2043. GetDlgItem(IDC_STATIC_PWD)->EnableWindow(TRUE);
  2044. GetDlgItem(IDC_COMBO_CRYPT)->EnableWindow(TRUE);
  2045. GetDlgItem(IDC_EDIT_PWD)->EnableWindow(TRUE);
  2046. }
  2048. void CSafeDataSetPage::OnRadio2() //信封加密按钮
  2049. {
  2050. // TODO: Add your control notification handler code here
  2051. GetDlgItem(IDC_STATIC_CHIPNAME)->EnableWindow(TRUE);
  2052. GetDlgItem(IDC_STATIC_PWD)->EnableWindow(FALSE);
  2053. GetDlgItem(IDC_COMBO_CRYPT)->EnableWindow(TRUE);
  2054. GetDlgItem(IDC_EDIT_PWD)->EnableWindow(FALSE);
  2055. }
  2057. void CSafeDataSetPage::OnRadio3() //摘要
  2058. {
  2059. // TODO: Add your control notification handler code here
  2061. }
  2063. void CSafeDataSetPage::OnRadio4() //签名
  2064. {
  2065. // TODO: Add your control notification handler code here
  2067. }
  2069. void CSafeDataSetPage::OnRadio5() //公钥加密按钮
  2070. {
  2071. // TODO: Add your control notification handler code here
  2072. GetDlgItem(IDC_STATIC_CHIPNAME)->EnableWindow(FALSE);
  2073. GetDlgItem(IDC_STATIC_PWD)->EnableWindow(FALSE);
  2074. GetDlgItem(IDC_COMBO_CRYPT)->EnableWindow(FALSE);
  2075. GetDlgItem(IDC_EDIT_PWD)->EnableWindow(FALSE);
  2076. }
  2078. void CSafeDataSetPage::OnRadio6() //私钥加密按钮
  2079. {
  2080. // TODO: Add your control notification handler code here
  2081. GetDlgItem(IDC_STATIC_CHIPNAME)->EnableWindow(FALSE);
  2082. GetDlgItem(IDC_STATIC_PWD)->EnableWindow(FALSE);
  2083. GetDlgItem(IDC_COMBO_CRYPT)->EnableWindow(FALSE);
  2084. GetDlgItem(IDC_EDIT_PWD)->EnableWindow(FALSE);
  2085. }
  2087. void CSafeDataSetPage::OnBEnc() 
  2088. {
  2089. // TODO: Add your control notification handler code here
  2090. if(pThreadEvpSet != NULL )
  2091. return;
  2093. //检测列表中是否有记录
  2094. // int nCount = ;
  2096. if(m_DataSetList.GetCount() == 0)
  2097. {
  2098. AddMsg(MiniCT_1308, M_ERROR);
  2099. return;
  2100. }
  2102. CEvp::SetProgRess(CSafeDataSetPage::m_pProgOne);
  2104. if(m_bIsEnc)//加密
  2105. {
  2106. if(((CButton *)GetDlgItem(IDC_RADIO1))->GetCheck())//对称加密
  2107. {
  2108. m_EncType = CRYPT;
  2109. }
  2110. else if(((CButton *)GetDlgItem(IDC_RADIO2))->GetCheck())//信封加密
  2111. {
  2112. m_EncType = SEAL;
  2113. }
  2114. else if(((CButton *)GetDlgItem(IDC_RADIO3))->GetCheck())//摘要
  2115. {
  2116. m_EncType = DIGEST;
  2117. }
  2118. else if(((CButton *)GetDlgItem(IDC_RADIO4))->GetCheck())//签名
  2119. {
  2120. m_EncType = SIGN;
  2121. }
  2122. else if(((CButton *)GetDlgItem(IDC_RADIO5))->GetCheck())//公钥加密
  2123. {
  2124. m_EncType = PubEnc;
  2125. }
  2126. else if(((CButton *)GetDlgItem(IDC_RADIO6))->GetCheck())//私钥加密
  2127. {
  2128. m_EncType = PrivEnc;
  2129. }
  2130. //出现令存对话框
  2131. CFileDialog dlgOpen(true,NULL,NULL,OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT /*| OFN_NOCHANGEDIR */,
  2132. MiniCT_1345, NULL);
  2133. dlgOpen.m_ofn.lStructSize = sizeof(OPENFILENAME);
  2134. CString str = MiniCT_1343;
  2135. dlgOpen.m_ofn.lpstrTitle = str;//标题条 LPCTSTR
  2136. if(dlgOpen.DoModal()!=IDOK) return;
  2137. m_strEvpPath = dlgOpen.GetPathName();
  2138. CString strExt = m_strEvpPath.Right(4);
  2139. if(strExt.CollateNoCase(".Evp") != 0)
  2140. m_strEvpPath += ".Evp";
  2142. }
  2143. else
  2144. {
  2145. //出现解密到对话框
  2146. if(!SelectPath())
  2147. return;
  2148. }
  2150. pThreadEvpSet = ::AfxBeginThread(_EvpSetThread,this,THREAD_PRIORITY_IDLE);
  2152. }
  2154. void CSafeDataSetPage::OnKeydownListDataset(NMHDR* pNMHDR, LRESULT* pResult) 
  2155. {
  2156. LV_KEYDOWN* pLVKeyDow = (LV_KEYDOWN*)pNMHDR;
  2157. // TODO: Add your control notification handler code here
  2158. if(!m_bIsEnc) //解密,不能删除
  2159. return;
  2160. switch(pLVKeyDow->wVKey)
  2161. {
  2162. case VK_DELETE: //只能删除父目录
  2163. {
  2164. int nItem = m_DataSetList.GetSelectedItem();
  2165. if(nItem!=-1)
  2166. {
  2167. CSuperGridCtrl::CTreeItem * pSelItem = m_DataSetList.GetTreeItem(nItem);
  2169. CItemInfo * pInfo = m_DataSetList.GetData(pSelItem ); 
  2170. if(pInfo->GetDataSafe()->uParentID != 0) //0为根的父
  2171. {
  2172. return;
  2173. }
  2175. //删除拖动链表
  2176. POSITION pos = m_DirName.GetHeadPosition();
  2177. while ( NULL != pos )
  2178. {
  2179. if(m_DirName.GetAt(pos).Compare(pInfo->GetDataSafe()->cPathName) == 0)//删除
  2180. {
  2181. m_DirName.RemoveAt(pos);
  2182. break;
  2183. }
  2184. m_DirName.GetNext(pos);
  2185. }
  2187. m_DataSetList.DeleteItemEx(pSelItem, nItem);
  2188. }
  2189. }
  2190. break;
  2191. }
  2194. *pResult = 0;
  2195. }
  2197. //记录结构信息的MAP,在加密解密之前先要枚举列表到MAP中
  2198. void CSafeDataSetPage::EnumList(CList<CDataSafe *, CDataSafe *> * pDataList, CList<CDataSafe *, CDataSafe *> * pDirList)
  2199. {
  2200. //枚举目录列表加密信息
  2201. POSITION pos = m_DataSetList.GetRootHeadPosition();
  2202. while(pos != NULL)
  2203. {
  2204. CSuperGridCtrl::CTreeItem *pParent = m_DataSetList.GetNextRoot(pos); 
  2205. CSuperGridCtrl::CTreeItem *pItem = pParent;
  2206. CItemInfo* lp = m_DataSetList.GetData(pParent);
  2207. CDataSafe * pDataSafe = new CDataSafe();
  2208. lp->CopyDataSafe(pDataSafe);
  2209. pDataList->AddTail(pDataSafe);
  2210. if(pDirList) //解密时候需要建立目录,此时需要添加目录列表
  2211. {
  2212. if(!pDataSafe->bIsFile)//目录
  2213. pDirList->AddTail(pDataSafe);
  2214. }
  2216. //GetNext ....loop through all children 
  2217. for(;;)
  2218. {
  2219. CSuperGridCtrl::CTreeItem *pCur = m_DataSetList.GetNext(pParent, pItem, TRUE, FALSE/*regardless of the item are hidden or not, set to TRUE if only visible items must be included in the search*/);   
  2220. if(!m_DataSetList.IsChildOf(pParent, pCur))
  2221. break;
  2222. else if(pCur==pItem)
  2223. break;
  2224. CItemInfo* lp = m_DataSetList.GetData(pCur);
  2225. pItem = pCur;//next;
  2226. CDataSafe * pDataSafe = new CDataSafe();
  2227. lp->CopyDataSafe(pDataSafe);
  2228. pDataList->AddTail(pDataSafe);
  2229. if(pDirList) //解密时候需要建立目录,此时需要添加目录列表
  2230. {
  2231. if(!pDataSafe->bIsFile)//目录
  2232. pDirList->AddTail(pDataSafe);
  2233. }
  2235. }
  2236. }
  2237. }
  2239. void CSafeDataSetPage::CleanList(CList<CDataSafe *, CDataSafe *> * pDataList)
  2240. {
  2241. POSITION pos = pDataList->GetHeadPosition();
  2242. while(pos != NULL)
  2243. {
  2244. CDataSafe* pDataSafe = pDataList->GetNext(pos);
  2245. if(pDataSafe)
  2246. delete pDataSafe;
  2247. }
  2249. }
  2251. void CSafeDataSetPage::DoCrypt()
  2252. {
  2253. CString strCpName, strPwd;
  2254. GetDlgItemText(IDC_COMBO_CRYPT,strCpName);
  2255. GetDlgItemText(IDC_EDIT_PWD,strPwd);
  2256. if(strCpName.IsEmpty() || strPwd.IsEmpty())
  2257. {
  2258. AddMsg(MiniCT_1330, M_ERROR);//请输入加密密钥和算法名称
  2259. pThreadEvpSet = NULL;
  2260. return;
  2261. }
  2262. CString outMsg;
  2263. if(!Crypt(strCpName, strPwd, m_strEvpPath, outMsg))
  2264. {
  2265. AddMsg(outMsg, M_ERROR);
  2266. }
  2267. else
  2268. AddMsg(MiniCT_1331);//对称加密成功
  2269. pThreadEvpSet = NULL;
  2271. }
  2273. void CSafeDataSetPage::DoSeal()
  2274. {
  2275. //创建合法用户公钥链
  2276. CEvp::stuCertLink * pCertLink = NULL;
  2277. int nCount = 0;
  2278. if(m_pPageCdb->GetCertPair(CSafeDataCdbPage::SEAL, TRUE, m_strKey, 
  2279. m_lenKey,m_p12Pwd,&((CMiniMainDlg *)m_pParent)->m_ListBox))//得到公钥
  2280. {
  2281. //可能为多证书,这时查找;,然后添加每一个
  2282. if(m_lenKey == 0) //外部证书
  2283. {
  2284. CString strSub,
  2285.     strPath;
  2286. while(AfxExtractSubString(strSub, m_strKey, nCount++, ';')) //未公开 分解字符串
  2287. {
  2288. if(nCount == 1) //第一个文件,取得路径
  2289. {
  2290. int nPos = strSub.ReverseFind('\');
  2291. strPath = strSub.Left(nPos + 1);//附带
  2292. strSub.TrimLeft();
  2293. pCertLink->AddCert(pCertLink, strSub, m_lenKey);
  2294. }
  2295. else
  2296. {
  2297. strSub.TrimLeft();
  2298. pCertLink->AddCert(pCertLink, strPath + strSub, m_lenKey);
  2299. }
  2301. }
  2302. }
  2303. else
  2304. pCertLink->AddCert(pCertLink, m_strKey, m_lenKey);
  2305. }
  2307. CString strCpName;
  2308. GetDlgItemText(IDC_COMBO_CRYPT,strCpName);
  2309. if(strCpName.IsEmpty())
  2310. {
  2311. AddMsg(MiniCT_1332, M_ERROR); //请输入加密算法名称
  2312. pThreadEvpSet = NULL;
  2313. return;
  2314. }
  2315. CString outMsg;
  2316. if(!Seal(pCertLink, strCpName, m_strEvpPath, outMsg))
  2317. {
  2318. AddMsg(outMsg, M_ERROR);
  2319. }
  2320. else
  2321. AddMsg(MiniCT_1333);//封装信封成功
  2322. pCertLink->RemoveAll(pCertLink);
  2323. pThreadEvpSet = NULL;
  2324. }
  2326. void CSafeDataSetPage::DoRSAPubEnc()
  2327. {
  2328. CString outStr;
  2329. if(m_pPageCdb->GetCertPair(CSafeDataCdbPage::PubEnc, TRUE, m_strKey,
  2330. m_lenKey,m_p12Pwd, &((CMiniMainDlg *)m_pParent)->m_ListBox))//得到公钥
  2331. {
  2332. if(!RSAPubEnc((UCHAR *)m_strKey, m_lenKey, m_strEvpPath, outStr))
  2333. {
  2334. AddMsg(outStr, M_ERROR);
  2335. }
  2336. else
  2337. AddMsg(MiniCT_1334);//公钥加密成功
  2338. }
  2339. pThreadEvpSet = NULL;
  2340. }
  2342. void CSafeDataSetPage::DoRSAPrivEnc()
  2343. {
  2344. CString outStr;
  2345. if(m_pPageCdb->GetCertPair(CSafeDataCdbPage::PubEnc, FALSE, m_strKey, 
  2346. m_lenKey, m_p12Pwd, &((CMiniMainDlg *)m_pParent)->m_ListBox))//得到私钥
  2347. { 
  2348.   if(!RSAPrivEnc((UCHAR *)m_strKey, m_lenKey, m_p12Pwd, m_strEvpPath, outStr))
  2349. {
  2350. AddMsg(outStr, M_ERROR);
  2351. }
  2352. else
  2353. AddMsg(MiniCT_1335);//私钥加密成功
  2354. }
  2355. pThreadEvpSet = NULL;
  2356. }
  2358. void CSafeDataSetPage::DoDecCrypt()
  2359. {
  2360. CString strCpName, strPwd, outStr;
  2361. GetDlgItemText(IDC_COMBO_CRYPT, strCpName);
  2362. GetDlgItemText(IDC_EDIT_PWD, strPwd);
  2363. CString strEvpFile(m_strEvpPath);
  2364. if(strPwd.IsEmpty() || strCpName.IsEmpty())
  2365. {
  2366. AddMsg(MiniCT_1336, M_ERROR);  //请选择算法并输入加密密码
  2367. pThreadEvpSet = NULL;
  2368. return;
  2369. }
  2370. if(!DecCrypt(strCpName, strPwd, strEvpFile, outStr))
  2371. {
  2372. AddMsg(outStr, M_ERROR);
  2373. }
  2374. else
  2375. AddMsg(MiniCT_1337); //对称解密成功
  2376. pThreadEvpSet = NULL;
  2378. }
  2380. void CSafeDataSetPage::DoOpenSeal()
  2381. {
  2382. CString strCpName, outStr;
  2383. GetDlgItemText(IDC_COMBO_CRYPT, strCpName);
  2384. CString strEvpFile(m_strEvpPath);
  2385. if(strCpName.IsEmpty())
  2386. {
  2387. AddMsg(MiniCT_1338, M_ERROR);  //"请选择算法"
  2388. pThreadEvpSet = NULL;
  2389. return;
  2390. }
  2391. if(m_pPageCdb->GetCertPair(CSafeDataCdbPage::SEAL, FALSE, m_strKey, m_lenKey, m_p12Pwd,
  2392. &((CMiniMainDlg *)m_pParent)->m_ListBox))//得到私钥
  2393. {
  2394. if(!OpenSeal(m_strKey, m_lenKey, m_p12Pwd.GetBuffer(0), strCpName, strEvpFile, outStr))
  2395. {
  2396. AddMsg(outStr, M_ERROR);
  2397. }
  2398. else
  2399. AddMsg(MiniCT_1339); //拆封信封成功
  2400. m_p12Pwd.ReleaseBuffer();
  2401. }
  2402. pThreadEvpSet = NULL;
  2403. }
  2405. void CSafeDataSetPage::DoRSAPriDec()
  2406. {
  2407. CString outStr;
  2408. CString strEvpFile(m_strEvpPath);
  2409. if(m_pPageCdb->GetCertPair(CSafeDataCdbPage::PubEnc, FALSE, m_strKey, m_lenKey, m_p12Pwd,
  2410. &((CMiniMainDlg *)m_pParent)->m_ListBox))//得到私钥
  2411. {
  2412. if(!RSAPriDec((UCHAR *)m_strKey, m_lenKey, m_p12Pwd, strEvpFile, outStr))
  2413. {
  2414. AddMsg(outStr, M_ERROR);
  2415. }
  2416. else
  2417. AddMsg(MiniCT_1340); //私钥解密成功
  2418. }
  2419. pThreadEvpSet = NULL;
  2420. }
  2422. void CSafeDataSetPage::DoRSAPubDec()
  2423. {
  2424. CString outStr;
  2425. if(m_pPageCdb->GetCertPair(CSafeDataCdbPage::PrivEnc, TRUE, m_strKey, m_lenKey, m_p12Pwd,
  2426. &((CMiniMainDlg *)m_pParent)->m_ListBox))
  2427. {
  2428. if(!RSAPubDec((UCHAR *)m_strKey, m_lenKey, m_strEvpPath, outStr))
  2429. {
  2430. AddMsg(outStr, M_ERROR);
  2431. }
  2432. else
  2433. AddMsg(MiniCT_1341);
  2434. }
  2435. pThreadEvpSet = NULL;
  2436. }
  2438. void CSafeDataSetPage::AddMsg(CString info, DWORD type)
  2439. {
  2440. ((CMiniMainDlg *)m_pParent)->AddMsg(MiniCT_0002,info, type);
  2441. }
  2443. void CSafeDataSetPage::AddOnceMsg(CString info, DWORD type)
  2444. {
  2445. // ((CMiniMainDlg *)m_pParent)->AddMsg("WinEvp",info, type);
  2446. }
  2448. void CSafeDataSetPage::DoSign()
  2449. {
  2450. CString strCpName;
  2451. GetDlgItemText(IDC_COMBO_CRYPT,strCpName);
  2452. if(strCpName.IsEmpty())
  2453. {
  2454. AddMsg(MiniCT_1332, M_ERROR);
  2455. pThreadEvpSet = NULL;
  2456. return;
  2457. }
  2458. CString outStr;
  2459. if(m_pPageCdb->GetCertPair(CSafeDataCdbPage::SIGN, FALSE, m_strKey, m_lenKey, 
  2460. m_p12Pwd, &((CMiniMainDlg *)m_pParent)->m_ListBox))//得到私钥
  2461. {
  2462. if(!Sign("md5", (UCHAR *)m_strKey, m_lenKey, m_p12Pwd,
  2463. m_strEvpPath, outStr))
  2464. {
  2465. AddMsg(outStr, M_ERROR);
  2466. }
  2467. else
  2468. AddMsg(MiniCT_1342); //"数字签名成功"
  2469. }
  2470. pThreadEvpSet = NULL;
  2471. }
  2473. LRESULT CSafeDataSetPage::OnDropOk(WPARAM wParam, LPARAM lParam)
  2474. {
  2475. CStringArray * pStringArray = (CStringArray*) wParam;
  2477. for(int i = 0 ;i < pStringArray->GetSize(); i++)
  2478. {
  2479. AddList(pStringArray->GetAt(i)); //如果扩展名不为.evp
  2480. }
  2481. return 0;
  2482. }
  2484. //解密文件
  2485. //参数:
  2486. //EVP文件名
  2487. //输出文件名
  2488. //文件在EVP文件中的偏移
  2489. //加密后文件长度(也就是解密时候要读取的长度)
  2490. //原始文件长度,用于校验
  2491. //返回错误信息
  2492. BOOL CSafeDataSetPage::DecOneFile(CString strEvpFile, CString strOutFile, DWORD dSeek, 
  2493.   DWORD dFileLen, DWORD dOldLen, CString & outStr)
  2494. {
  2495. CFile FileEvp;
  2496. CString strCpName;
  2497. DWORD dOutLen = -1;
  2498. DWORD dFileInfoLen = 0; 
  2500. BOOL bSucceed = TRUE;
  2502. if(!FileEvp.Open(strEvpFile, CFile::modeRead | CFile::typeBinary))
  2503. {
  2504. outStr.Format("%s%s", MiniCT_1320, strEvpFile);//打开文件失败%s
  2505. return FALSE;
  2506. }
  2508. switch(m_EncType)
  2509. {
  2510. case NONE:
  2511. break;
  2512. case CRYPT: //对称 1
  2513. break;
  2514. case DIGEST://摘要 3
  2515. break;
  2516. case SIGN: //签名 4
  2517. break;
  2518. case SEAL: //信封 2
  2519. FileEvp.Seek(strlen(m_sHeadMark), CFile::begin);
  2520. FileEvp.Read(&dFileInfoLen, sizeof(DWORD));
  2521. FileEvp.Seek(sizeof(UINT), CFile::current);
  2522. FileEvp.Seek(dFileInfoLen, CFile::current);
  2523. GetDlgItemText(IDC_COMBO_CRYPT, strCpName);
  2524. if(strCpName.IsEmpty())
  2525. {
  2526. AddMsg(MiniCT_1338,M_ERROR);// "请选择算法"
  2527. break;
  2528. }
  2530. EVP_CIPHER_CTX Ctx;
  2532. if(m_pPageCdb->GetCertPair(CSafeDataCdbPage::SEAL, FALSE, m_strKey, m_lenKey, m_p12Pwd,
  2533. &((CMiniMainDlg *)m_pParent)->m_ListBox))//得到私钥
  2535. if(!CEvp::InitOpenSeal2(m_strKey, m_lenKey, m_p12Pwd.GetBuffer(0), strCpName, FileEvp, Ctx, outStr))
  2536. {
  2537. m_p12Pwd.ReleaseBuffer();
  2538. FileEvp.Close();
  2539. return FALSE;
  2540. }
  2541. m_p12Pwd.ReleaseBuffer();
  2542. FileEvp.Seek(dSeek, CFile::begin);
  2543. dOutLen = CEvp::OpenSeal2(Ctx, FileEvp, dFileLen, strOutFile, outStr);
  2544. if(dOutLen != dOldLen)
  2545. {
  2546. bSucceed = FALSE;
  2547. outStr = MiniCT_1321;
  2548. }
  2549. CEvp::CleanOpenSeal2(Ctx);
  2550. break;
  2551. case PubEnc:
  2552. break;
  2553. case PrivEnc:
  2554. break;
  2555. default:
  2556. break;
  2557. }
  2558. FileEvp.Close();
  2559. return bSucceed;
  2561. }
  2563. void CSafeDataSetPage::OnBegindragListDataset(NMHDR* pNMHDR, LRESULT* pResult) 
  2564. {
  2565. NMLISTVIEW*    pNMLV = (NMLISTVIEW*) pNMHDR;
  2566. COleDataSource datasrc;
  2567. HGLOBAL        hgDrop;
  2568. DROPFILES*     pDrop;
  2569. CStringList    lsDraggedFiles;
  2570. POSITION       pos;
  2571. int            nSelItem;
  2572. CString        sFile;
  2573. UINT           uBuffSize = 0;
  2574. TCHAR*         pszBuff;
  2575. FORMATETC      etc = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
  2576. CString    outStr;
  2578.     *pResult = 0;   // return value ignored
  2580.     // For every selected item in the list, put the filename into lsDraggedFiles.
  2582. pos = m_DataSetList.GetFirstSelectedItemPosition();
  2584. while ( NULL != pos )
  2585. {
  2586. nSelItem = m_DataSetList.GetNextSelectedItem ( pos );
  2588. //如果是加密的,就解密到临时目录,并打开
  2589. CSuperGridCtrl::CTreeItem * pItem = m_DataSetList.GetTreeItem(nSelItem);
  2590. if(!pItem)
  2591. return;
  2592. CItemInfo * pInfo = m_DataSetList.GetData(pItem); 
  2594. const CDataSafe * pDataSafe = pInfo->GetDataSafe();
  2595. if(pDataSafe == NULL)
  2596. return;
  2598. //取得临时路径
  2599. TCHAR szTempPath[MAX_PATH];
  2600. DWORD dwResult=:: GetTempPath (MAX_PATH, szTempPath);
  2601. ASSERT (dwResult);
  2603. sFile.Format("%s\%s",szTempPath, pDataSafe->cName);
  2605. CString strOut;
  2607. if(pDataSafe->bIsFile) //文件
  2608. {
  2609. if(!DecOneFile(m_strEvpPath, sFile, pDataSafe->dBeginSeek, pDataSafe->dNewLen,
  2610. pDataSafe->dNewLen, strOut))
  2611. AddMsg(strOut, M_ERROR);
  2612. }
  2613. else//目录 ->建立目录
  2614. {
  2615. if(!Mdir(sFile, outStr))
  2616. {
  2617. return;
  2618. }
  2619. }
  2621. lsDraggedFiles.AddTail ( sFile );
  2623. // Calculate the # of chars required to hold this string.
  2625. uBuffSize += lstrlen ( sFile ) + 1;
  2626. }
  2628.     // Add 1 extra for the final null char, and the size of the DROPFILES struct.
  2630.     uBuffSize = sizeof(DROPFILES) + sizeof(TCHAR) * (uBuffSize + 1);
  2632.     // Allocate memory from the heap for the DROPFILES struct.
  2634.     hgDrop = GlobalAlloc ( GHND | GMEM_SHARE, uBuffSize );
  2636.     if ( NULL == hgDrop )
  2637.         return;
  2639.     pDrop = (DROPFILES*) GlobalLock ( hgDrop );
  2641.     if ( NULL == pDrop )
  2642. {
  2643.         GlobalFree ( hgDrop );
  2644.         return;
  2645. }
  2647.     // Fill in the DROPFILES struct.
  2649.     pDrop->pFiles = sizeof(DROPFILES);
  2651. #ifdef _UNICODE
  2652.     // If we're compiling for Unicode, set the Unicode flag in the struct to
  2653.     // indicate it contains Unicode strings.
  2655.     pDrop->fWide = TRUE;
  2656. #endif
  2658.     // Copy all the filenames into memory after the end of the DROPFILES struct.
  2660.     pos = lsDraggedFiles.GetHeadPosition();
  2661.     pszBuff = (TCHAR*) (LPBYTE(pDrop) + sizeof(DROPFILES));
  2663.     while ( NULL != pos )
  2664. {
  2665.         lstrcpy ( pszBuff, (LPCTSTR) lsDraggedFiles.GetNext ( pos ) );
  2666.         pszBuff = 1 + _tcschr ( pszBuff, '' );
  2667. }
  2669.     GlobalUnlock ( hgDrop );
  2671.     // Put the data in the data source.
  2673.     datasrc.CacheGlobalData ( CF_HDROP, hgDrop, &etc );
  2675.     // Add in our own custom data, so we know that the drag originated from our 
  2676.     // window.  CMyDropTarget::DragEnter() checks for this custom format, and
  2677.     // doesn't allow the drop if it's present.  This is how we prevent the user
  2678.     // from dragging and then dropping in our own window.
  2679.     // The data will just be a dummy bool.
  2680. HGLOBAL hgBool;
  2682.     hgBool = GlobalAlloc ( GHND | GMEM_SHARE, sizeof(bool) );
  2684.     if ( NULL == hgBool )
  2685. {
  2686.         GlobalFree ( hgDrop );
  2687.         return;
  2688. }
  2690.     // Put the data in the data source.
  2692.     etc.cfFormat = m_Target.GetClipbrdFormat();
  2693.     
  2694.     datasrc.CacheGlobalData (etc.cfFormat, hgBool, &etc );
  2697.     // Start the drag 'n' drop!
  2699. DROPEFFECT dwEffect = datasrc.DoDragDrop (DROPEFFECT_MOVE);
  2701.     // If the DnD completed OK, we remove all of the dragged items from our
  2702.     // list.
  2704.     GlobalFree(hgDrop);
  2705.     GlobalFree(hgBool);
  2706. }
  2708. void CSafeDataSetPage::TranslateCT()
  2709. {
  2710. CHeaderCtrl * pHeader = m_DataSetList.GetHeaderCtrl();
  2711. if (pHeader)
  2712. {
  2713. UINT uCount = pHeader->GetItemCount();
  2715. CString str = MiniCT_1300;
  2716. HDITEM hdi;
  2717. hdi.mask = HDI_TEXT;
  2718. hdi.pszText = (LPTSTR)((LPCTSTR)str);
  2719. pHeader->SetItem(0, &hdi);
  2721. str = MiniCT_1301;
  2722. hdi.pszText = (LPTSTR)((LPCTSTR)str);
  2723. pHeader->SetItem(1, &hdi);
  2725. str = MiniCT_1302;
  2726. hdi.pszText = (LPTSTR)((LPCTSTR)str);
  2727. pHeader->SetItem(2, &hdi);
  2729. str = MiniCT_1303;
  2730. hdi.pszText = (LPTSTR)((LPCTSTR)str);
  2731. pHeader->SetItem(3, &hdi);
  2733. str = MiniCT_1304;
  2734. hdi.pszText = (LPTSTR)((LPCTSTR)str);
  2735. pHeader->SetItem(4, &hdi);
  2736. }
  2737. SetDlgItemText(IDC_STATICINFO, MiniCT_11401);
  2738. SetDlgItemText(IDC_RADIO1, MiniCT_11402);
  2739. SetDlgItemText(IDC_RADIO2, MiniCT_11403);
  2740. SetDlgItemText(IDC_RADIO3, MiniCT_11404);
  2741. SetDlgItemText(IDC_RADIO4, MiniCT_11405);
  2742. SetDlgItemText(IDC_RADIO5, MiniCT_11406);
  2743. SetDlgItemText(IDC_RADIO6, MiniCT_11407);
  2744. SetDlgItemText(IDC_STATICFUN, MiniCT_11408);
  2745. SetDlgItemText(IDC_STATIC_PWD, MiniCT_11409);
  2746. SetDlgItemText(IDC_STATIC_CHIPNAME, MiniCT_11410);
  2747. }
  2749. BOOL CSafeDataSetPage::SelectPath() 
  2750. {
  2751. // TODO: Add your control notification handler code here
  2752. LPITEMIDLIST pidlRoot = NULL; 
  2753. LPMALLOC pMalloc;   
  2754. if(NOERROR == SHGetSpecialFolderLocation(m_pParent->m_hWnd, CSIDL_DRIVES, &pidlRoot)) //leak
  2755. {
  2756. BROWSEINFO bi;   //必须传入的参数,下面就是这个结构的参数的初始化 
  2757. CString strDisplayName;// = CMiniCaApp::NormalCode("选择文件夹");;   //用来得到,你选择的活页夹路径,相当于提供一个缓冲区 
  2758. bi.hwndOwner = GetSafeHwnd();   //得到父窗口Handle值 
  2759. bi.pidlRoot=0;   //这个变量就是我们在上面得到的. 
  2760. bi.pszDisplayName = strDisplayName.GetBuffer(MAX_PATH+1);   //得到缓冲区指针, 
  2761. CString strTitle = MiniCT_1344; //解密到
  2762. bi.lpszTitle = strTitle;  //设置标题 
  2763. bi.ulFlags = BIF_RETURNONLYFSDIRS  | BIF_DONTGOBELOWDOMAIN  ;   //设置标志 
  2764. bi.lpfn=NULL; 
  2765. bi.lParam=0; 
  2766. bi.iImage=0;   //上面这个是一些无关的参数的设置,最好设置起来, 
  2767. ITEMIDLIST * pidl;  
  2768. pidl = SHBrowseForFolder(&bi);   //打开对话框 
  2769. if(!pidl)
  2770. return FALSE;
  2771. SHGetPathFromIDList(pidl,bi.pszDisplayName);
  2772. strDisplayName.ReleaseBuffer();   //和上面的GetBuffer()相对应 
  2774. if(SUCCEEDED( SHGetMalloc ( &pMalloc ))) // leak
  2775. { 
  2776. pMalloc->Free(pidlRoot); 
  2777. pMalloc->Release(); 
  2778. }
  2779. m_strSavePath = strDisplayName;
  2780. }
  2781. return TRUE;
  2782. }