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, 0 };
//枚举所有图标资源
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(0, "选择", LVCFMT_LEFT, 50);
    m_List.InsertColumn(1, "要捆绑的文件", LVCFMT_LEFT, 280);


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


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

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

    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()), 0);

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

        // 绘制图标
        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 = 0;
    struct _stat ST;
    unsigned int finder = 0x12345678;
    unsigned int i, k;
    GetDlgItemText(IDC_EDIT1, m_DestPathName);
     
    int n = m_List.GetItemCount();
    if (n > 0)
    {
        CString strIconPathName;
        GetDlgItemText(IDC_EDIT2, strIconPathName);

        strIconPathName.TrimLeft();
        if (strIconPathName.IsEmpty())
        {
            his_name = m_List.GetItemText(0, 1); //第一个绑定的文件名
        }
        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 == 0)
    {
        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, 1, modify_data.my_length, myself);
    fclose(myself);

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

     for (i = 0; i < modify_data.my_length - sizeof(finder); i += sizeof(finder))
    {
        for (k = 0; 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 = 0; j < n; j++)
    {
        CString strFilePath = m_List.GetItemText(j, 1);

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

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


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


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


        while (bytesin = fread(buf, 1, modify_data.my_length, in))
        {
            totalbytes += fwrite(buf, 1, 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, 1, strPathName);
}


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

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

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


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

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

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

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

        if (k == nDataLen)
            break;
    }

    for (n = 0; n < pDirHeader->ResCount; n++)
    {
        DWORD nDataLen = 0;
        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字节。
",
            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 = 0; i < modify_data.my_length - nDataLen; i++)
        {
            for (k = 0; 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, "	图标大小不匹配。
");
#endif DEBUG_PRINT
                    pResDir[n].BytesInRes = 0;
                }

                break;
            }
        }
    }

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

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

#ifdef DEBUG_PRINT
    fprintf(stderr, "共: %d 个图标, 
", pDirHeader->ResCount);
    for (n = 0; n < pDirHeader->ResCount; n++)
    {
        fprintf(stderr, "	序号(id)=%d[%d 字节] %d宽x%d高x%d颜色数
",
            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 == 0)
    {
        //        MessageBox("装入文件时出错,可能不是32位程序!", "错误");
        return NULL;
    }

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

    return myDataStruct.pMatchIcon;
}


//枚举所有图标资源
BOOL CALLBACK my_enum_res_callback(
    HMODULE hExe,   // 资源句柄
    LPCTSTR lpszType,  // 资源类型
    LPTSTR lpszName,   // 资源名称
    LPARAM lParam    // 自定义消息参数
)
{
    HRSRC hRsrc = 0;
    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 + 1);

    for (k = 0; 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)) == 0)
        {
            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, "	目录%d中发现 %d-th 图标，序号(ID)=%d (大小: %d)
",
                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, 0, 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 = 0;
    long nFileStepbytes = 0;
    CString strTmpExe = "temp";
    int nIndex = 1;

    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 = 0;

        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), 1, myself) == 0)
        {
            free(buf);
            MessageBox("分离文件中，读取第一个被绑定文件长度时出错!", "错误");
            return;
        }



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

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

        nFileStepbytes = nFileStepbytes + sizeof(prog1_length) + prog1_length;

        nIndex++;

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

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



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


                 //置为分解后，为异步执行方式
    for (int i = 1; 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;
    }
}