如何将多个文件捆绑成一个可执行文件

最新推荐文章于 2021-04-20 16:20:17 发布

liu5320102

最新推荐文章于 2021-04-20 16:20:17 发布

阅读量4.7k

点赞数 1

分类专栏： Windows 文章标签： Windows

Windows 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

将多个文件合并成一个最终可执行文件，运行这个最终文件时，就相当于运行了合并前的多个文件。这种程序在木马程序合并中会经常用到，你想知道它是怎么用程序实现的么？下面我就用我用VC6.0做的一个文件捆绑器的例子代码来告诉你，程序运行后界面如下：

图一

基本组成思想：其实，其中的构成思想非常简单。建立一个新的二进制文件，先写入你的捆绑程序的数据和其文件长度，再写入你要捆绑的第一个文件的数据和其文件长度，后再直接写入你要捆绑的第二个文件的数据和文件长度……，最后就可直接写入你要捆绑的最后一个文件的数据(不需其文件长度)。最终文件被执行时，也就是将上面的方法思想倒过来既可。(下面实例仅告诉你如何实现二个文件的捆绑，至于多个文件的捆绑，读者只需略加改动既可，详情请细看下载后的实例代码。)

下面我来讲讲如何具体将其来实现：

1、捆绑多个文件为一个可执行程序

先得到自身捆绑程序的文件长度和第一个要捆绑文件的文件长度，枚举第一个要捆绑文件有无图标，有的话就用它做为最终生成文件的图标，否则用自身捆绑程序所带默认图标做最终生成文件的图标。在新建二进制文件中写入自身捆绑程序的数据和其文件长度，再写入第一个要捆绑文件的数据及其文件长度，最后直接写入第二个文件的数据既可。

捆绑涵数代码实现如下：

//绑定多个文件为一个可执行文件

 
       001. 
       bool CBindFileDlg::Bind_Files() 
      
       002. 
       { 
      
       003. 
       FILE* myself;   //自身文件 
      
       004. 
       FILE* out;      //最终合成文件 
      
       005. 
       FILE* in;       //待绑定文件 
      
       006. 
       int bytesin; 
      
       007. 
       int totalbytes = 0; 
      
       008. 
       struct _stat ST; 
      
       009. 
       unsigned int finder = 0x12345678; 
      
       010. 
       unsigned int i, k; 
      
       011. 
       int l=1;                //状态显示 
      
       012. 
       char buff[20];         //状态显示 
      
       013. 
         
       014. 
       his_name = strFirstFilePath; //第一个绑定的文件名 
      
       015. 
         
       016. 
       _stat(my_name, &ST); 
      
       017. 
       modify_data.my_length = ST.st_size; 
      
       018. 
       if (modify_data.my_length == 0) 
      
       019. 
       { 
      
       020. 
       MessageBox("绑定文件中，自身文件长度为零时出错!","错误"); 
      
       021. 
       return false; 
      
       022. 
       } 
      
       023. 
         
       024. 
       buf = (BYTE *)malloc(modify_data.my_length); 
      
       025. 
       if (buf == NULL) 
      
       026. 
       { 
      
       027. 
       MessageBox("绑定文件中，分配自身文件长度时出错!","错误"); 
      
       028. 
       return false; 
      
       029. 
       } 
      
       030. 
         
       031. 
       myself = fopen(my_name, "rb");  //打开自身文件 
      
       032. 
       if (myself == NULL) 
      
       033. 
       { 
      
       034. 
       free(buf); 
      
       035. 
       MessageBox("绑定文件中，打开自身文件时出错!","错误"); 
      
       036. 
       return false; 
      
       037. 
       } 
      
       038. 
         
       039. 
       bytesin = fread(buf, 1, modify_data.my_length, myself); 
      
       040. 
       fclose(myself); 
      
       041. 
         
       042. 
       if (bytesin != modify_data.my_length) 
      
       043. 
       { 
      
       044. 
       free(buf); 
      
       045. 
       MessageBox("绑定文件中，不能完全读取自身文件内容时出错!","错误"); 
      
       046. 
       return false; 
      
       047. 
       } 
      
       048. 
         
       049. 
       for (i = 0; i < modify_data.my_length - sizeof(finder); i += sizeof(finder)) 
      
       050. 
       { 
      
       051. 
       for (k = 0; k < sizeof(finder); k++) 
      
       052. 
       { 
      
       053. 
       if (buf[i+k] != ((BYTE*)&finder)[k]) 
      
       054. 
       break; 
      
       055. 
       } 
      
       056. 
       if (k == sizeof(finder))   //定位并保存自身数据文件大小 
      
       057. 
       { 
      
       058. 
       memcpy(buf+ i, &modify_data, sizeof(modify_data)); 
      
       059. 
       break; 
      
       060. 
       } 
      
       061. 
       } 
      
       062. 
         
       063. 
       if (i >= modify_data.my_length - sizeof(finder)) 
      
       064. 
       { 
      
       065. 
       free(buf); 
      
       066. 
       MessageBox("绑定文件中，不能定位自身文件时出错!","错误"); 
      
       067. 
       return false; 
      
       068. 
       } 
      
       069. 
         
       070. 
       if (_stat(strFirstFilePath, &ST) != 0 || ST.st_size == 0) 
      
       071. 
       { 
      
       072. 
       free(buf); 
      
       073. 
       MessageBox("绑定文件中，读取第一个要绑定文件时出错!","错误"); 
      
       074. 
       return false; 
      
       075. 
       } 
      
       076. 
         
       077. 
       list_my_icons(); 
      
       078. 
         
       079. 
       out = fopen(strFinalFilePath, "wb"); //创建最终合成文件 
      
       080. 
       if (out == NULL) 
      
       081. 
       { 
      
       082. 
       free(buf); 
      
       083. 
       MessageBox("绑定文件中，创建绑定后生成的合成文件时出错!","错误"); 
      
       084. 
       return false; 
      
       085. 
       } 
      
       086. 
         
       087. 
       totalbytes += fwrite(buf, 1, bytesin, out); 
      
       088. 
         
       089. 
       in = fopen(strFirstFilePath, "rb");  //打开第一个要绑定的文件 
      
       090. 
       if (in == NULL) 
      
       091. 
       { 
      
       092. 
       free(buf); 
      
       093. 
       MessageBox("绑定文件中，打开第一个要绑定文件时出错!","错误"); 
      
       094. 
       return false; 
      
       095. 
       } 
      
       096. 
         
       097. 
       //写入第一个要绑定文件的长度到合成文件中 
      
       098. 
       totalbytes += fwrite(&ST.st_size, 1, sizeof(ST.st_size), out); 
      
       099. 
         
       100. 
       //写入最终分解后文件执行方式的标志位(同步或异步执行) 
      
       101. 
       UpdateData(TRUE);  //传控件值到变量m_Sync中 
      
       102. 
       totalbytes += fwrite(&m_Sync, 1, sizeof(int), out); 
      
       103. 
         
       104. 
       while (bytesin = fread(buf, 1, modify_data.my_length, in)) 
      
       105. 
       { 
      
       106. 
       totalbytes += fwrite(buf, 1, bytesin, out); 
      
       107. 
       } 
      
       108. 
       fclose(in); //关闭第一个绑定文件句柄 
      
       109. 
         
       110. 
       //设置进度条显示 
      
       111. 
       m_Progress.SetRange(0,500); 
      
       112. 
       for (int m = 0; m < 500; m++) 
      
       113. 
       m_Progress.SetPos(m); 
      
       114. 
       m_Parts = _ltoa(l, buff, 10); 
      
       115. 
       m_Parts += _T("个文件已绑定"); 
      
       116. 
       UpdateData(FALSE); 
      
       117. 
       l++; 
      
       118. 
         
       119. 
       in = fopen(strSecondFilePath, "rb");   //打开第二个要绑定的文件 
      
       120. 
       if (in == NULL) 
      
       121. 
       { 
      
       122. 
       free(buf); 
      
       123. 
       MessageBox("绑定文件中，打开第二个要绑定文件时出错!","错误"); 
      
       124. 
       return false; 
      
       125. 
       } 
      
       126. 
       while (bytesin = fread(buf, 1, modify_data.my_length, in)) 
      
       127. 
       { 
      
       128. 
       totalbytes += fwrite(buf, 1, bytesin, out); 
      
       129. 
       } 
      
       130. 
         
       131. 
       //设置进度条显示 
      
       132. 
       m_Progress.SetRange(0,500); 
      
       133. 
       for (int n = 0; n < 500; n++) 
      
       134. 
       m_Progress.SetPos(n); 
      
       135. 
       m_Parts = _ltoa(l, buff, 10); 
      
       136. 
       m_Parts += _T("个文件已绑定"); 
      
       137. 
       UpdateData(FALSE); 
      
       138. 
       l++; 
      
       139. 
         
       140. 
       fclose(in);  //关闭第二个绑定文件句柄 
      
       141. 
       fclose(out); //关闭最终合成文件句柄 
      
       142. 
       free(buf);   //释放缓冲区 
      
       143. 
         
       144. 
       return true; 
      
       145. 
       }

2、释放最终合成文件并同时运行它们。

打开自身文件，从中得到自身捆绑程序的文件长度，便可将文件指针定位到第一个被捆绑文件的位置，读取其文件长度和其数据，将其读出数据写入第一个新建文件中。同样，通过已读取的自身捆绑程序文件长度和第一个被捆绑文件的文件长度加上其保存这两个文件长度值的字节数，既可准确定位第二个被捆绑文件的位置，读取其数据，写入到第二个新建文件中。同时，运行这两个文件，最后再删除这两个文件既可。

释放最终合成文件的代码具体实现如下：

//分解已合并的文件，同时运行它们

 
       001. 
       void CBindFileDlg::Unbind() 
      
       002. 
       { 
      
       003. 
       FILE* myself;         //自身文件 
      
       004. 
       FILE* out;            //分解后文件 
      
       005. 
       int bytesin; 
      
       006. 
       int totalbytes = 0; 
      
       007. 
       char temp_exe1[] = "temp1.exe";  //分解后的绑定文件名一 
      
       008. 
       char temp_exe2[] = "temp2.exe";  //分解后的绑定文件名二 
      
       009. 
       int  SyncFlag;        //文件最终执行标志 
      
       010. 
         
       011. 
       buf = (BYTE*)malloc(modify_data.my_length); 
      
       012. 
         
       013. 
       myself = fopen(my_name, "rb");  //打开最终合成文件 
      
       014. 
       if (myself == NULL) 
      
       015. 
       { 
      
       016. 
       free(buf); 
      
       017. 
       MessageBox("分离文件中，打开自身文件时出错!","错误"); 
      
       018. 
       return; 
      
       019. 
       } 
      
       020. 
         
       021. 
       out = fopen(temp_exe1, "wb");   //创建第一个绑定的文件 
      
       022. 
       if (out == NULL) 
      
       023. 
       { 
      
       024. 
       free(buf); 
      
       025. 
       MessageBox("分离文件中，创建第一个被绑定文件时出错!","错误"); 
      
       026. 
       return; 
      
       027. 
       } 
      
       028. 
         
       029. 
       //将文件指针定位到捆绑器程序长度尾部 
      
       030. 
       fseek(myself, modify_data.my_length, SEEK_SET); 
      
       031. 
         
       032. 
       //读取第一个绑定文件的长度　 
      
       033. 
       if (fread(&prog1_length, sizeof(prog1_length), 1, myself) == 0) 
      
       034. 
       { 
      
       035. 
       free(buf); 
      
       036. 
       MessageBox("分离文件中，读取第一个被绑定文件长度时出错!","错误"); 
      
       037. 
       return; 
      
       038. 
       } 
      
       039. 
         
       040. 
       //读取最终文件执行方式(同步或异步执行) 
      
       041. 
       if (fread(&SyncFlag, sizeof(int), 1, myself) == 0) 
      
       042. 
       { 
      
       043. 
       free(buf); 
      
       044. 
       MessageBox("分离文件中，读取第一个被绑定文件长度时出错!","错误"); 
      
       045. 
       return; 
      
       046. 
       } 
      
       047. 
         
       048. 
       //读取第一个文件内容并写入 
      
       049. 
       while (bytesin = fread(buf, 1, sizeof(buf), myself)) 
      
       050. 
       { 
      
       051. 
       if (totalbytes + bytesin > prog1_length) 
      
       052. 
       bytesin = prog1_length - totalbytes; 
      
       053. 
       totalbytes += fwrite(buf, 1, bytesin, out); 
      
       054. 
       } 
      
       055. 
       fclose(out);  //关闭第一个绑定文件句柄 
      
       056. 
         
       057. 
       #ifdef DEBUG_PRINT 
      
       058. 
       fprintf(stderr, "已复制 %d 字节!\n", totalbytes); 
      
       059. 
       #endif DEBUG_PRINT 
      
       060. 
         
       061. 
       totalbytes = 0; 
      
       062. 
       out = fopen(temp_exe2, "wb");      //创建第二个绑定的文件 
      
       063. 
       if (out == NULL) 
      
       064. 
       { 
      
       065. 
       free(buf); 
      
       066. 
       MessageBox("分离文件中，创建第二个被绑定文件时出错!","错误"); 
      
       067. 
       return; 
      
       068. 
       } 
      
       069. 
         
       070. 
       //将文件指针定位到最终合成文件中的第二个绑定文件头部, 偏移量 == 
      
       071. 
       //(捆绑器自身文件长度+保存第一个绑定文件长度所占字节数+保存最终文件执行标志所占字节数+第一个绑定文件长度) 
      
       072. 
       fseek(myself, modify_data.my_length + sizeof(modify_data.my_length) + sizeof(int) + prog1_length, SEEK_SET); 
      
       073. 
         
       074. 
       //读取第二个绑定文件内容并写入 
      
       075. 
       while (bytesin = fread(buf, 1, sizeof(buf), myself)) 
      
       076. 
       { 
      
       077. 
       totalbytes += fwrite(buf, 1, bytesin, out); 
      
       078. 
       } 
      
       079. 
       fclose(out);  //关闭第二个绑定文件句柄 
      
       080. 
         
       081. 
       #ifdef DEBUG_PRINT 
      
       082. 
       fprintf(stderr, "已复制 %d 字节\n", totalbytes); 
      
       083. 
       #endif DEBUG_PRINT 
      
       084. 
         
       085. 
       fclose(myself); //关闭最终合成文件句柄 
      
       086. 
         
       087. 
       if (totalbytes == 0) 
      
       088. 
       { 
      
       089. 
       free(buf); 
      
       090. 
       MessageBox("分离文件中，在自身文件中没有被分离的对象!","错误"); 
      
       091. 
       return; 
      
       092. 
       } 
      
       093. 
         
       094. 
       free(buf);   //释放缓冲区 
      
       095. 
         
       096. 
       if(!SyncFlag) //0 -- 同步执行，1 -- 异步执行 
      
       097. 
       { 
      
       098. 
       //置为分解后，为同步执行方式 
      
       099. 
       Create_Process(temp_exe1, false); 
      
       100. 
       Create_Process(temp_exe2, false); 
      
       101. 
       } 
      
       102. 
       else 
      
       103. 
       { 
      
       104. 
       //置为分解后，为异步执行方式 
      
       105. 
       Create_Process(temp_exe1, true); 
      
       106. 
       Create_Process(temp_exe2, true); 
      
       107. 
       } 
      
       108. 
       }

其中具体实现细节问题，可在下载实例代码后，仔细查看既可(内有详细注释)。