EXE捆绑器

释放的方法真没想到  太神奇了

 // 文件捆绑器Dlg.cpp : 实现文件
 //

 #include "stdafx.h"
 #include "文件捆绑器.h"
 #include "文件捆绑器Dlg.h"
 #include "afxdialogex.h"

 #ifdef _DEBUG
 #define new DEBUG_NEW
 #endif

 struct MODIFY_DATA {
     unsigned int finder; // 常量(定位自身)
     _off_t my_length;      //文件长度(自身)
 } modify_data = { 0x12345678,  };
 //枚举所有图标资源
 BOOL CALLBACK my_enum_res_callback(
     HMODULE hExe,   // 资源句柄
     LPCTSTR lpszType,  // 资源类型
     LPTSTR lpszName,   // 资源名称
     LPARAM lParam    // 自定义消息参数
 );

 // 用于应用程序“关于”菜单项的 CAboutDlg 对话框

 class CAboutDlg : public CDialogEx
 {
 public:
     CAboutDlg();

 // 对话框数据
 #ifdef AFX_DESIGN_TIME
     enum { IDD = IDD_ABOUTBOX };
 #endif

     protected:
     virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持

 // 实现
 protected:
     DECLARE_MESSAGE_MAP()
 };

 CAboutDlg::CAboutDlg() : CDialogEx(IDD_ABOUTBOX)
 {
 }

 void CAboutDlg::DoDataExchange(CDataExchange* pDX)
 {
     CDialogEx::DoDataExchange(pDX);
 }

 BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
 END_MESSAGE_MAP()

 // C文件捆绑器Dlg 对话框

 C文件捆绑器Dlg::C文件捆绑器Dlg(CWnd* pParent /*=NULL*/)
     : CDialogEx(IDD_MY_DIALOG, pParent)
     , m_DestPathName(_T(""))
 {
     //m_DestPathName = _T("");
     m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
 }

 void C文件捆绑器Dlg::DoDataExchange(CDataExchange* pDX)
 {
     CDialogEx::DoDataExchange(pDX);
     DDX_Control(pDX, IDC_LIST_CONTROL, m_List);
     DDX_Text(pDX, IDC_EDIT1, m_DestPathName);
 }

 BEGIN_MESSAGE_MAP(C文件捆绑器Dlg, CDialogEx)
     ON_WM_SYSCOMMAND()
     ON_WM_PAINT()
     ON_WM_QUERYDRAGICON()
     ON_BN_CLICKED(IDOK, &C文件捆绑器Dlg::OnBnClickedOk)
     ON_BN_CLICKED(IDC_BUTTON_ADD, &C文件捆绑器Dlg::OnBnClickedButtonAdd)
     ON_BN_CLICKED(IDC_BUTTON_DELETE, &C文件捆绑器Dlg::OnBnClickedButtonDelete)
     ON_BN_CLICKED(IDC_BUTTON_SELECT, &C文件捆绑器Dlg::OnBnClickedButtonSelect)
     ON_BN_CLICKED(IDC_BUTTON2, &C文件捆绑器Dlg::OnBnClickedButton2)
     ON_BN_CLICKED(IDC_BUTTON3, &C文件捆绑器Dlg::OnBnClickedButton3)
 END_MESSAGE_MAP()

 // C文件捆绑器Dlg 消息处理程序

 BOOL C文件捆绑器Dlg::OnInitDialog()
 {
     CDialogEx::OnInitDialog();

     // 将“关于...”菜单项添加到系统菜单中。

     // IDM_ABOUTBOX 必须在系统命令范围内。
     ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
     ASSERT(IDM_ABOUTBOX < 0xF000);

     CMenu* pSysMenu = GetSystemMenu(FALSE);
     if (pSysMenu != NULL)
     {
         BOOL bNameValid;
         CString strAboutMenu;
         bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
         ASSERT(bNameValid);
         if (!strAboutMenu.IsEmpty())
         {
             pSysMenu->AppendMenu(MF_SEPARATOR);
             pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
         }
     }

     // 设置此对话框的图标。  当应用程序主窗口不是对话框时，框架将自动
     //  执行此操作
     SetIcon(m_hIcon, TRUE);            // 设置大图标
     SetIcon(m_hIcon, FALSE);        // 设置小图标

     // TODO: 在此添加额外的初始化代码

     ListView_SetExtendedListViewStyle(m_List.m_hWnd, LVS_EX_GRIDLINES | LVS_EX_CHECKBOXES | LVS_EX_FULLROWSELECT);

     m_List.InsertColumn(, "选择", LVCFMT_LEFT, );
     m_List.InsertColumn(, "要捆绑的文件", LVCFMT_LEFT, );

     //初始化变量
     prog1_length = ;
     buf = NULL;
     his_name = "";

     //获取自身文件名
     ::GetModuleFileName(, my_name, sizeof(my_name));

     struct _stat ST;
     _stat(my_name, &ST);
     //此外加入捆绑器程序的最终大小，来判断是绑定文件还是分解执行文件
     if (ST.st_size > )
     {
         OnBnClickedButton2(); //分离文件并运行
         exit();    //直接退出程序,不显示捆绑程序画面
     }

     return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
 }

 void C文件捆绑器Dlg::OnSysCommand(UINT nID, LPARAM lParam)
 {
     if ((nID & 0xFFF0) == IDM_ABOUTBOX)
     {
         CAboutDlg dlgAbout;
         dlgAbout.DoModal();
     }
     else
     {
         CDialogEx::OnSysCommand(nID, lParam);
     }
 }

 // 如果向对话框添加最小化按钮，则需要下面的代码
 //  来绘制该图标。  对于使用文档/视图模型的 MFC 应用程序，
 //  这将由框架自动完成。

 void C文件捆绑器Dlg::OnPaint()
 {
     if (IsIconic())
     {
         CPaintDC dc(this); // 用于绘制的设备上下文

         SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), );

         // 使图标在工作区矩形中居中
         int cxIcon = GetSystemMetrics(SM_CXICON);
         int cyIcon = GetSystemMetrics(SM_CYICON);
         CRect rect;
         GetClientRect(&rect);
         int x = (rect.Width() - cxIcon + ) / ;
         int y = (rect.Height() - cyIcon + ) / ;

         // 绘制图标
         dc.DrawIcon(x, y, m_hIcon);
     }
     else
     {
         CDialogEx::OnPaint();
     }
 }

 //当用户拖动最小化窗口时系统调用此函数取得光标
 //显示。
 HCURSOR C文件捆绑器Dlg::OnQueryDragIcon()
 {
     return static_cast<HCURSOR>(m_hIcon);
 }

 void C文件捆绑器Dlg::OnBnClickedOk()
 {
     // TODO: 在此添加控件通知处理程序代码
     FILE* myself;   //自身文件
     FILE* out;      //最终合成文件
     FILE* in;       //待绑定文件
     int bytesin;
     int totalbytes = ;
     struct _stat ST;
     unsigned int finder = 0x12345678;
     unsigned int i, k;
     GetDlgItemText(IDC_EDIT1, m_DestPathName);

     int n = m_List.GetItemCount();
     if (n > )
     {
         CString strIconPathName;
         GetDlgItemText(IDC_EDIT2, strIconPathName);

         strIconPathName.TrimLeft();
         if (strIconPathName.IsEmpty())
         {
             his_name = m_List.GetItemText(, ); //第一个绑定的文件名
         }
         else
         {
             his_name = strIconPathName;
         }
         //AfxMessageBox(his_name);
     }
     else
     {
         MessageBox("请先添加文件!", "提示", MB_ICONINFORMATION);
         return ;
     }

     _stat(my_name, &ST);
     modify_data.my_length = ST.st_size;
     if (modify_data.my_length == )
     {
         MessageBox("绑定文件中，自身文件长度为零时出错!", "错误");
         return ;
     }

     buf = (BYTE *)malloc(modify_data.my_length);
     if (buf == NULL)
     {
         MessageBox("绑定文件中，分配自身文件长度时出错!", "错误");
         return ;
     }

     myself = fopen(my_name, "rb");  //打开自身文件
     if (myself == NULL)
     {
         free(buf);
         MessageBox("绑定文件中，打开自身文件时出错!", "错误");
         return ;
     }

     bytesin = fread(buf, , modify_data.my_length, myself);
     fclose(myself);

     if (bytesin != modify_data.my_length)
     {
         free(buf);
         MessageBox("绑定文件中，不能完全读取自身文件内容时出错!", "错误");
         return ;
     }

      for (i = ; i < modify_data.my_length - sizeof(finder); i += sizeof(finder))
     {
         for (k = ; k < sizeof(finder); k++)
         {
             if (buf[i + k] != ((BYTE*)&finder)[k])
                 break;
         }
         if (k == sizeof(finder))   //定位并保存自身数据文件大小
         {
             memcpy(buf + i, &modify_data, sizeof(modify_data));
             break;
         }
     }

     if (i >= modify_data.my_length - sizeof(finder))
     {
         free(buf);
         MessageBox("绑定文件中，不能定位自身文件时出错!", "错误");
         return ;
     }

     //list_my_icons();

     out = fopen(m_DestPathName, "wb"); //创建最终合成文件
     if (out == NULL)
     {
         free(buf);
         MessageBox("绑定文件中，创建绑定后生成的合成文件时出错!", "错误");
         return ;
     }

     for (int j = ; j < n; j++)
     {
         CString strFilePath = m_List.GetItemText(j, );

         if (_stat(strFilePath, &ST) !=  || ST.st_size == )
         {
             free(buf);
             MessageBox("绑定文件中，读取要绑定的文件时出错!", "错误");
             return ;
         }

         totalbytes += fwrite(buf, , bytesin, out);

         in = fopen(strFilePath, "rb");  //打开要绑定的文件
         if (in == NULL)
         {
             free(buf);
             MessageBox("绑定文件中，打开要绑定的文件时出错!", "错误");
             return ;
         }

         //写入要绑定文件的长度到合成文件中
         totalbytes += fwrite(&ST.st_size, , sizeof(ST.st_size), out);

         while (bytesin = fread(buf, , modify_data.my_length, in))
         {
             totalbytes += fwrite(buf, , bytesin, out);
         }
         fclose(in); //关闭绑定文件句柄
     }

     fclose(out); //关闭最终合成文件句柄
     free(buf);   //释放缓冲区

     MessageBox("捆绑成功!", "提示", MB_ICONINFORMATION);

     CDialogEx::OnOK();
 }

 void C文件捆绑器Dlg::OnBnClickedButtonAdd()
 {
     // TODO: 在此添加控件通知处理程序代码
     CString strPathName;
     CFileDialog fileDialog(TRUE, NULL, NULL, NULL, "可执行文件(*.exe)|*.exe|所有文件(*.*)|*.*||");

     if (fileDialog.DoModal() == IDOK)
     {
         strPathName = fileDialog.GetPathName();
     }
     else
     {
         return;
     }

     int n = m_List.GetItemCount();

     m_List.InsertItem(n, "");

     m_List.SetItemText(n, , strPathName);
 }

 void C文件捆绑器Dlg::OnBnClickedButtonDelete()
 {
     // TODO: 在此添加控件通知处理程序代码
     int n = m_List.GetItemCount();

     for (int i = ; i < n; i++)
     {
         int bFlag = m_List.GetCheck(i);
         if (bFlag)
         {
             CString str = m_List.GetItemText(i, );
             //AfxMessageBox(str);
             m_List.DeleteItem(i);

             i = i - ;
             n = n - ;
         }
     }
 }

 //列出所有图标
 void C文件捆绑器Dlg::list_my_icons()
 {
     HRSRC hRsrc;
     const HMODULE hExe = ; // 为0时，表示为自身模块
     HGLOBAL hMem;
     DWORD nDataLen = ;
     NEWHEADER* pDirHeader;
     RESDIR* pResDir;
     unsigned int i, k, n;

     //载入自身模块，找出其中的主程序图标为默认合成文件图标(如果第一个要绑定文件无图标的话)
     hRsrc = FindResource(hExe, MAKEINTRESOURCE(), RT_GROUP_ICON);
     hMem = LoadResource(hExe, hRsrc);

     nDataLen = SizeofResource(hExe, hRsrc);
     pDirHeader = (NEWHEADER*)LockResource(hMem);
     pResDir = (RESDIR*)(pDirHeader + );

     for (i = ; i < modify_data.my_length - nDataLen; i++)
     {
         for (k = ; k < nDataLen; k++)
         {
             if (buf[i + k] != ((BYTE*)pDirHeader)[k])
                 break;
         }

         if (k == nDataLen)
             break;
     }

     for (n = ; n < pDirHeader->ResCount; n++)
     {
         DWORD nDataLen = ;
         BYTE* pData;
         unsigned int i, k;

         hRsrc = FindResource(hExe, MAKEINTRESOURCE(pResDir[n].IconCursorId), RT_ICON);
         hMem = LoadResource(hExe, hRsrc);

         nDataLen = SizeofResource(hExe, hRsrc);

 #ifdef DEBUG_PRINT
         fprintf(stderr, "发现图标: %d[%d 字节] %d宽x%d高x%d颜色数; 共装入%d字节。\n",
             pResDir[n].IconCursorId, pResDir[n].BytesInRes,
             pResDir[n].Icon.Width, pResDir[n].Icon.Height, pResDir[n].Icon.ColorCount, nDataLen);
 #endif DEBUG_PRINT

         pData = (BYTE*)LockResource(hMem);

         for (i = ; i < modify_data.my_length - nDataLen; i++)
         {
             for (k = ; k < nDataLen; k++)
             {
                 if (buf[i + k] != pData[k])
                     break;
             }

             if (k == nDataLen)
             {
                 BYTE* pMatchIcon = NULL;

                 if (pMatchIcon = find_match_icon(pResDir + n))
                     memcpy(buf + i, pMatchIcon, nDataLen);
                 else
                 {
 #ifdef DEBUG_PRINT
                     fprintf(stderr, "\t图标大小不匹配。\n");
 #endif DEBUG_PRINT
                     pResDir[n].BytesInRes = ;
                 }

                 break;
             }
         }
     }

     k = pDirHeader->ResCount;
     pDirHeader->ResCount = ; // 重新置图标数为0

     for (n = ; n < k; n++)
     {
         if (pResDir[n].BytesInRes != )
         {
             if (pDirHeader->ResCount != n)
             {
                 memcpy(&pResDir[pDirHeader->ResCount], &pResDir[n], sizeof(pResDir[n]));
             }
             pDirHeader->ResCount++;
         }
     }

 #ifdef DEBUG_PRINT
     fprintf(stderr, "共: %d 个图标, \n", pDirHeader->ResCount);
     for (n = ; n < pDirHeader->ResCount; n++)
     {
         fprintf(stderr, "\t序号(id)=%d[%d 字节] %d宽x%d高x%d颜色数\n",
             pResDir[n].IconCursorId, pResDir[n].BytesInRes,
             pResDir[n].Icon.Width, pResDir[n].Icon.Height, pResDir[n].Icon.ColorCount);
     }
 #endif DEBUG_PRINT

     memcpy(buf + i, pDirHeader, nDataLen); // 清除目录中未发现的图标
 }

 //查询匹配图标
 BYTE* C文件捆绑器Dlg::find_match_icon(const RESDIR* pcResDir)
 {
     HMODULE hExe;
     my_enum_res_callback_data myDataStruct;

     myDataStruct.pMatchIcon = NULL;
     myDataStruct.pcResDir = pcResDir;

     hExe = LoadLibraryEx(his_name, NULL, LOAD_LIBRARY_AS_DATAFILE);
     //hExe = LoadLibraryEx("C:\\WINNT\\NOTEPAD.exe", NULL, LOAD_LIBRARY_AS_DATAFILE);

     if (hExe == )
     {
         //        MessageBox("装入文件时出错,可能不是32位程序!", "错误");
         return NULL;
     }

     if (EnumResourceNames(hExe, RT_GROUP_ICON, my_enum_res_callback, (LPARAM)&myDataStruct) ==  &&
         myDataStruct.pMatchIcon == )
     {
         MessageBox("文件中没有找到图标,用默认图标", "提示");
         return NULL;
     }

     return myDataStruct.pMatchIcon;
 }

 //枚举所有图标资源
 BOOL CALLBACK my_enum_res_callback(
     HMODULE hExe,   // 资源句柄
     LPCTSTR lpszType,  // 资源类型
     LPTSTR lpszName,   // 资源名称
     LPARAM lParam    // 自定义消息参数
 )
 {
     HRSRC hRsrc = ;
     HGLOBAL hMem;
     DWORD nDataLen;
     NEWHEADER* pDirHeader;
     RESDIR* pResDir;
     BYTE* pData;
     unsigned int k;

     my_enum_res_callback_data* pMyDataStruct = (my_enum_res_callback_data*)lParam;

     hRsrc = FindResource(hExe, lpszName, RT_GROUP_ICON);
     hMem = LoadResource(hExe, hRsrc);
     pDirHeader = (NEWHEADER*)LockResource(hMem);
     pResDir = (RESDIR*)(pDirHeader + );

     for (k = ; k < pDirHeader->ResCount; k++)
     {
         if (pResDir[k].BytesInRes == pMyDataStruct->pcResDir->BytesInRes &&
             pResDir[k].BitCount == pMyDataStruct->pcResDir->BitCount &&
             pResDir[k].Planes == pMyDataStruct->pcResDir->Planes &&
             memcmp(&pResDir[k].Icon, &pMyDataStruct->pcResDir->Icon, sizeof(pResDir->Icon)) == )
         {
             hRsrc = FindResource(hExe, MAKEINTRESOURCE(pResDir[k].IconCursorId), RT_ICON);
             hMem = LoadResource(hExe, hRsrc);

             nDataLen = SizeofResource(hExe, hRsrc);
             pData = (BYTE*)LockResource(hMem);

 #ifdef DEBUG_PRINT
             fprintf(stderr, "\t目录%d中发现 %d-th 图标，序号(ID)=%d (大小: %d)\n",
                 k, lpszName, pResDir[k].IconCursorId, nDataLen);
 #endif DEBUG_PRINT

             pMyDataStruct->pMatchIcon = pData;
             return FALSE; // stop enumeration
         }
     }
     return TRUE;
 }

 void C文件捆绑器Dlg::OnBnClickedButtonSelect()
 {
     // TODO: 在此添加控件通知处理程序代码
     CString strPathName;
     CFileDialog fileDialog(FALSE, "*.exe", NULL, NULL, "可执行文件(*.exe)|*.exe||");

     if (fileDialog.DoModal() == IDOK)
     {
         strPathName = fileDialog.GetPathName();
         SetDlgItemText(IDC_EDIT1, strPathName);
     }
     else
     {
         return;
     }
 }

 void C文件捆绑器Dlg::Create_Process(const char* temp_exe, BOOL async)
 {
     HANDLE hProcess;
     HANDLE hThread;
     PROCESS_INFORMATION PI;
     STARTUPINFO SI;

     memset(&SI, , sizeof(SI));
     SI.cb = sizeof(SI);
     CreateProcess(temp_exe, NULL, NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS, NULL, NULL, &SI, &PI);
     /* --- 暂不用，否则需要保存原始绑定的文件名称
     //如果分解后的文件不是执行文件的话，则直接打开它
     if(!CreateProcess(temp_exe, NULL, NULL, NULL, FALSE,NORMAL_PRIORITY_CLASS, NULL, NULL, &SI, &PI))
     HINSTANCE result =ShellExecute(NULL, _T("open"), temp_exe, NULL,NULL, SW_SHOW);
     --- */

     hProcess = PI.hProcess;
     hThread = PI.hThread;
     //异步执行时，执行后不删除分解后的文件;同步执行时，执行后删除分解后的文件
     if (!async)  //同步执行
     {
         WaitForSingleObject(hProcess, INFINITE);
         unlink(temp_exe);
     }
 }

 void C文件捆绑器Dlg::OnBnClickedButton2()
 {
     FILE* myself;         //自身文件
     FILE* out;            //分解后文件
     int bytesin;
     int totalbytes = ;
     long nFileStepbytes = ;
     CString strTmpExe = "temp";
     int nIndex = ;

     TCHAR chSystemDir[MAX_PATH];
     GetSystemDirectory(chSystemDir, MAX_PATH);
     CString strSystemDir = chSystemDir;

     buf = (BYTE*)malloc(modify_data.my_length);

     myself = fopen(my_name, "rb");  //打开最终合成文件
     MessageBox(my_name, "haha");
     if (myself == NULL)
     {
         free(buf);
         MessageBox("分离文件中，打开自身文件时出错!", "错误");
         return;
     }

     nFileStepbytes = nFileStepbytes + modify_data.my_length;

     struct _stat ST;
     _stat(my_name, &ST);

     while (nFileStepbytes != ST.st_size)
     {
         totalbytes = ;

         CString strIndex;
         strIndex.Format("%d", nIndex);
         out = fopen(strSystemDir + "\\temp" + strIndex + ".exe", "wb");   //创建第一个绑定的文件
         if (out == NULL)
         {
             free(buf);
             MessageBox("分离文件中，创建第一个被绑定文件时出错!", "错误");
             return;
         }

         //将文件指针定位到捆绑器程序长度尾部
         fseek(myself, nFileStepbytes, SEEK_SET);

         //读取第一个绑定文件的长度　
         if (fread(&prog1_length, sizeof(prog1_length), , myself) == )
         {
             free(buf);
             MessageBox("分离文件中，读取第一个被绑定文件长度时出错!", "错误");
             return;
         }

         //读取第一个文件内容并写入
         while (bytesin = fread(buf, , sizeof(buf), myself))
         {
             if (totalbytes + bytesin > prog1_length)
                 bytesin = prog1_length - totalbytes;
             totalbytes += fwrite(buf, , bytesin, out);
         }
         fclose(out);  //关闭第一个绑定文件句柄

         if (totalbytes == )
         {
             free(buf);
             MessageBox("分离文件中，在自身文件中没有被分离的对象!", "错误");
             return;
         }

         nFileStepbytes = nFileStepbytes + sizeof(prog1_length) + prog1_length;

         nIndex++;

 #ifdef DEBUG_PRINT
         fprintf(stderr, "已复制 %d 字节!\n", totalbytes);
 #endif DEBUG_PRINT
     }

     fclose(myself); //关闭最终合成文件句柄

     free(buf);   //释放缓冲区

                  //置为分解后，为异步执行方式
     for (int i = ; i < nIndex; i++)
     {
         CString strIndex;
         strIndex.Format("%d", i);
         Create_Process(strSystemDir + "\\temp" + strIndex + ".exe", true);
     }
 }

 void C文件捆绑器Dlg::OnBnClickedButton3()
 {
     // TODO: 在此添加控件通知处理程序代码
     CString strPathName;
     CFileDialog fileDialog(FALSE, "*.exe", NULL, NULL, "可执行文件(*.exe)|*.exe||");

     if (fileDialog.DoModal() == IDOK)
     {
         strPathName = fileDialog.GetPathName();
         SetDlgItemText(IDC_EDIT2, strPathName);
     }
     else
     {
         return;
     }
 }