免杀专题基础(2)

// 逆向学习9.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。//
#include <iostream>void Function(int x) {  switch (x) {  case 1:    printf("1");    break;  case 2:    printf("2");    break;  case 3:    printf("3");    break;  default:    printf("default");  }}int main(){  Function(1);}

// 逆向学习9.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。//
#include <iostream>void Function(int x) {  switch (x) {  case 1:    printf("1");    break;  case 2:    printf("2");    break;  case 3:    printf("3");    break;  case 4:    printf("3");    break;  default:    printf("5");  }}int main(){  Function(1);}

#include <iostream>void Function(int x) {  switch (x) {  case 101:    printf("101");    break;  case 102:    printf("102");    break;  case 103:    printf("103");    break;  case 104:    printf("104");    break;  default:    printf("5");  }}int main(){  Function(101);}

// 逆向学习9.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。//
#include <iostream>
void Function(int x) {  switch (x) {  case 101:    printf("101");    break;  //case 102:  //  printf("102");  //  break;  //case 103:  //  printf("103");  //  break;  case 104:    printf("104");    break;  case 105:    printf("105");    break;  case 106:    printf("106");    break;  case 107:    printf("107");    break;  case 108:    printf("108");    break;  case 109:    printf("109");    break;
  default:    printf("5");  }}int main(){  Function(101);}

#include <iostream>
void Function(int x) {  switch (x) {  case 101:    printf("101");    break;  //case 102:  //  printf("102");  //  break;  //case 103:  //  printf("103");  //  break;  case 107:    printf("107");    break;  case 108:    printf("108");    break;  case 109:    printf("109");    break;
  default:    printf("5");  }}int main(){  Function(108);}

char* a;short* b;int* c;

void Test(){    short* b;    int* c;     a = (char*)10;    b = (short*)20;    c = (short*)30;}int main(){    Test();}

void Test(){       char a;    short b;    int c;      a = 10;    b = 20;    c = 30;}int main(){    Test();}

#include <iostream>
void Test() {    char* a;    short* b;    int* c;    a = (char*)10;    b = (short*)20;    c = (int*)30;}int main() {    Test();}

#include <iostream>
void Test() {    char* a;    short* b;    int* c;    a = (char*)100;    b = (short*)100;    c = (int*)100;    a++;    b++;    c++;}int main() {    Test();}

#include <iostream>
void Test() {    char** a;    short** b;    int** c;    a = (char**)100;    b = (short**)100;    c = (int**)100;    a++;    b++;    c++;    printf("%d %d %d", a, b, c);}int main() {    Test();}

mov al,0x81SAL al,1

mov al,0x81SAR al,1

mov al,0x81SHL al,1

SHR al,1

rol al,1

ror al,1

RCL al,1

#include <iostream>int main(){  char x = 2;  char y = 3;  printf("%xn", x & y);与 // 0010 0011 0010 //2  printf("%dn", x | y);或 // 0010 0011 0011 //3  printf("%xn", ~x); 非// 0010  1101 // D  printf("%dn", x^y);异或 //0010 0011 //0000 0001 //1  return 0;}

#include <iostream>#include "Test.h"#define TRUE 1;#define FALSE 0;#define PI 3.1415926;#define MAX(A,B)((A) > (B) ?(A):(B))
void Function1() {  int* ptr;  ptr = (int*)malloc(sizeof(int)*128); //申请一块4 * 128字节的内存 申请的内存在堆中。  if (ptr == NULL) {    printf("申请内存失败");  }  //初始化分配的内存空间  memset(ptr,0,sizeof(int)*128);
  //使用  *(ptr) = 1;  //使用完毕 释放申请的堆空间  free(ptr);
  //将指针设置为Null  ptr = NULL;
}int Function() {  int x = MAX(2, 3);  return TRUE;}int main(){
  Function1();}//申请内存
//判断是否申请内存成功
//初始化内存空间
//使用内存
//释放申请的内存空间
//将指针所指向的内存设置为null

// stack.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。//#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <malloc.h>
void fun();int Size(FILE*);int main(int argc, char* argv[]){  fun();  return 0;}
//此函数返回文件的大小int Size(FILE* p) {
  int num = 0;  fseek(p, 0, SEEK_END);  num = ftell(p);  //再把指针移到开头  fseek(p, 0, SEEK_SET);  return num;}void fun() {  //定义一个File类型的指针  FILE* fp;  //读取文件  fp = fopen("C:\Windows\System32\notepad.exe", "rb");  //判断文件是否读取成功  if (fp == NULL) {    printf("文件读取失败");  }  //通过Size函数拿到文件的大小  printf("文件大小为:%dn", Size(fp));    //申请一块缓冲区  char* ch;  ch = (char*)malloc(Size(fp));  if (ch == NULL) {
    printf("分配空间失败");
  }  //申请完成缓冲区之后,将文件读取出来的内存写入到缓冲区中。  fread(ch, Size(fp), 1, fp);    int address = (int)ch;  printf("内存空间地址为:%d", address);  free(ch);  fclose(fp);
}

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <malloc.h>
int Size(FILE* p) {
  int num = 0;  fseek(p, 0, SEEK_END);  num = ftell(p);  //再把指针移到开头  fseek(p, 0, SEEK_SET);  return num;
}void fun() {  FILE* fp1;  FILE* fp2;  int FileSize = 0;  //打开文件  fp1 = fopen("C:\Windows\System32\notepad.exe", "rb");  if (fp1 == NULL) {    printf("文件读取失败");  }  //创建写入的文件  fp2 = fopen("C:\Users\Admin\Desktop\test.exe", "wb");  //获取第一个第一个文件的大小  FileSize = Size(fp1);  //创建一个缓冲区空间  char* ch;  ch = (char*)malloc(FileSize);  if (ch == NULL) {    printf("创建失败");  }  fread(ch, FileSize, 1, fp1);  fwrite(ch, FileSize, 1, fp2);
  free(ch);  fclose(fp1);  fclose(fp2);
}int main(int argc, char* argv[]){  fun();
  return 0;
}

struct _IMAGE_DOS_HEADER {0x00 WORD e_magic;  //5A4D * 需要背0x02 WORD e_cblp; //00900x04 WORD e_cp; //00300x06 WORD e_crlc;//00000x08 WORD e_cparhdr;//00040x0a WORD e_minalloc; //00000x0c WORD e_maxalloc;//FFFF0x0e WORD e_ss; //00000x10 WORD e_sp;//00B80x12 WORD e_csum;//00000x14 WORD e_ip; //00000x16 WORD e_cs;//00000x18 WORD e_lfarlc; //00400x1a WORD e_ovno; //00000x1c WORD e_res[4]; //00 00 00 00 00 00 00 00 这是两个字节的数组 有4个 所以占用8个字节0x24 WORD e_oemid; //00000x26 WORD e_oeminfo;//00000x28 WORD e_res2[10]; //00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 //这也是两个字节的数组有10个，所以占用20个字节。0x3c DWORD e_lfanew; //000000E0 //DWORD占用4个字节 *  需要背};

struct _IMAGE_FILE_HEADER {0x00 WORD Machine; //014C 需要背0x02 WORD NumberOfSections; //0009 需要背0x04 DWORD TimeDateStamp; //65 22 15 5D 需要背0x08 DWORD PointerToSymbolTable; //00 00 00 000x0c DWORD NumberOfSymbols; //00 00 00 00 0x10 WORD SizeOfOptionalHeader; //00 E0 需要背0x12 WORD Characteristics; // 01 02 需要背};

struct _IMAGE_OPTIONAL_HEADER {0x00 WORD Magic;  //01 0B //需要背0x02 BYTE MajorLinkerVersion; //0E0x03 BYTE MinorLinkerVersion; //250x04 DWORD SizeOfCode; //00 00 58 00 //需要背0x08 DWORD SizeOfInitializedData; //00 00 46 00 //需要背0x0c DWORD SizeOfUninitializedData; //00 00 00 00 //需要背0x10 DWORD AddressOfEntryPoint; //00 01 10 23//需要背0x14 DWORD BaseOfCode; //00 00 10 00//需要背0x18 DWORD BaseOfData; //00 10 00 00//需要背0x1c DWORD ImageBase; //00 40 00 00//需要背0x20 DWORD SectionAlignment; //00 00 10 00//需要背0x24 DWORD FileAlignment; //00 00 02 00//需要背0x28 WORD MajorOperatingSystemVersion; //00 060x2a WORD MinorOperatingSystemVersion; //00 000x2c WORD MajorImageVersion; //00 00 0x2e WORD MinorImageVersion; //00 000x30 WORD MajorSubsystemVersion;//00 060x32 WORD MinorSubsystemVersion;//00 000x34 DWORD Win32VersionValue; //00 00 00 00 0x38 DWORD SizeOfImage; //00 02 00 00 //需要背0x3c DWORD SizeOfHeaders; //00 00 04 00//需要背0x40 DWORD CheckSum; //00 00 00 00//需要背0x44 WORD Subsystem; //00 030x46 WORD DllCharacteristics; // 81  400x48 DWORD SizeOfStackReserve; //00 10 00 00//需要背0x4c DWORD SizeOfStackCommit; //00 00 10 00//需要背0x50 DWORD SizeOfHeapReserve; //00 10 00 00 //需要背0x54 DWORD SizeOfHeapCommit;// 00 00 10 00//需要背0x58 DWORD LoaderFlags; //00 00 00 00 0x5c DWORD NumberOfRvaAndSizes; //00 00 00 100x60 _IMAGE_DATA_DIRECTORY DataDirectory[16]; //暂时先不找};

WORD e_magic "MZ标记" 用于判断是否为可执行文件DWORD e_lfanew PE头相对于文件的偏移，用于定位PE文件 通俗一点就是说通过这个字段来找PE是从哪里开始的。就比如说我们前面找到的是E0，那么也就是说PE离我们最开始的位置有E0个字节。

WORD Machine * 程序运行的CPU型号：0x0任何处理器/0x14c 386及后续处理器 (这个值主要是约束这个EXE程序在什么样的CPU上运行)WORD NumberOfSections 文件中存在节的的总数，如果要新增节或者合并节，就要修改这个值。（我们前面说过PE是分节的，每一个数据段都是一节。）

DWORD TimeDateStamp 时间戳，文件的创建时间(和操作系统的创建时间无关)，编辑器填写的。DWORD SizeOfOptionaHeader 可选PE头的大小，32位PE文件默认是E0H，而在64位PE文件默认为F0H，大小可以自定义。WORD Characteristics 每个位有不同的意义，可执行的文件值为10F 即0 1 2 3 8位置1.

WORD Magic 说明文件类型，如果是32位下的PE文件它的值是10B，如果是64位下的PE文件他的值是20B（重点）SectionAlignment 内存对齐 1000HFileAlignment 文件对齐 200HDWORD SizeOfCode  所有代码节的和，必须是FileAlignment的整数倍，编辑器填的(这里指的是PE结构分很多节，比如说我其中有一个节中有10字节的代码，那么就是10 * FileAlignment 也就是文件对齐，一般文件对齐的话都是200H，而内存对齐的是话是1000H，所以它存储的值就是1000)DWORD SizeOfInitializedData 已初始化数据大小的和，必须是FileAlignment的整数倍 编辑器填的。DWORD SizeOfUninitializedData 未初始化数据大小的和，必须是FileAlignment的整数倍 编辑器填的。
    AddressOfEntryPoint 程序入口点(重点)  程序入口点 + 内存镜像基址 (我们可以发现在使用OD或者xdebg的时候它断点断的那个位置就是程序入口点这个值 + 内存镜像基址)//注意:一个exe文件由多个PE文件组成，比如说dll文件，每一个dll都是一个模块。DWORD BaseOfCode 代码开始的基址 编辑器填的 没用DWORD BaseOfData 数据开始的基址 编译器填的 没用ImageBase 内存镜像DWORD SizeOfImage 内存中整个PE文件的映射的尺寸，可以比实际的值大，但必须是SectionAlignment的整数倍。DWORD SizeOfHeaders 所有头+节表按照文件对齐后的大小，否则加载会出错。DWORD CheckSum 校验和，一些系统文件有要求，用来判断文件是否被修改。DWORD SizeOfStackReserve; 初始化时保留的堆栈大小DWORD SizeOfStackCommit; 初始化时实际提交的大小DWORD SizeOfHeapReserve; 初始化时保留堆的大小DWORD SizeOfHeapCommit;  初始化时实际提交堆的大小DWORD NumberOfRvaAndSizes; 目录项数(比如说存储了一个0x10，那么就表示在他后面还有10个结构。)

#define _CRT_SECURE_NO_WARNINGS#include <iostream>#include <malloc.h>#include <malloc.h>#include <windows.h>int Size(FILE* p) {  int num = 0;  fseek(p, 0, SEEK_END);  num = ftell(p);  //再把指针移到开头  fseek(p, 0, SEEK_SET);  return num;}//这里需要传递进去一个文件void  readPeFile() {  //首先定义一个文件指针  FILE* fp = NULL;  //定义文件的大小  DWORD FileSize = 0;  LPVOID pfileBuffer = NULL;  //打开文件  fp = fopen("C:\Windows\system32\notepad.exe", "rb");  if (fp == NULL) {    printf("打开文件失败");  }  //读取文件的大小  FileSize  = Size(fp);  //printf("文件大小为:%d", FileSize);  //创建缓冲区  pfileBuffer  = malloc(FileSize);  if (pfileBuffer == NULL) {    printf("内存分配失败");    free(pfileBuffer);    fclose(fp);  }  //将exe写入到内存中，动态分配内存  size_t n  = fread(pfileBuffer, FileSize, 1, fp);  if (n ==NULL) {    printf("数据读取失败");    free(pfileBuffer);    fclose(fp);  }  //定义相关的DOS头 NT头 节表相关的信息  PIMAGE_DOS_HEADER pDosHeader = NULL;  PIMAGE_NT_HEADERS pNTHeader = NULL;  PIMAGE_FILE_HEADER pPEHeader = NULL;  PIMAGE_OPTIONAL_HEADER32 pOptionHeader = NULL;  PIMAGE_SECTION_HEADER pSectionHeader = NULL;    //判断DOS头的mz标志    //这里的PWORD,WORD是2个字节，也就是说取前两个字节也就是MZ。  if ((*(PWORD)pfileBuffer) != IMAGE_DOS_SIGNATURE) { //这里的IMAGE_DOS_SIGNATURE对应的就是0x5a4d    printf("不是有效的PE文件");    free(fp);  }  pDosHeader = (PIMAGE_DOS_HEADER)pfileBuffer;//获取DOS头开始的地址  //打印Dos头信息  printf("******************DOS头*********************n");  printf("MZ标志: %xn", pDosHeader->e_magic);  printf("PE偏移: %xn", pDosHeader->e_lfanew);  //判断pe有效位    if (*(PWORD)((DWORD)pfileBuffer + pDosHeader->e_lfanew) != IMAGE_NT_SIGNATURE) {    printf("不是有效得pe标识n");    free(pfileBuffer);  }  pNTHeader = (PIMAGE_NT_HEADERS)((DWORD)pfileBuffer + pDosHeader->e_lfanew); //定位到NT Header  //打印NT  printf("**************NT头*************n");  printf("NT : %xn", pNTHeader->Signature);  pPEHeader = pPEHeader = (PIMAGE_FILE_HEADER)(((DWORD)pNTHeader) + 4);  //打印标准PE头  printf("**************标准PE头**********n");  printf("Machine : %xn", pPEHeader->Machine);  printf("NumberOfSections : %xn", pPEHeader->NumberOfSections);  printf(" SizeOfOptionalHeader : %xn", pPEHeader->SizeOfOptionalHeader);  //打印可选pe头  /*printf("********************OPTIOIN_PE头********************n");
  printf("OPTION_PE：%xn", pOptionHeader->Magic);  printf("sizeofcode=%xn", pOptionHeader->SizeOfCode);
  printf("baseofcode=%xn", pOptionHeader->BaseOfCode);
  printf("baseofdata=%xn", pOptionHeader->BaseOfData);
  printf("imagebase=%xn", pOptionHeader->ImageBase);
  printf("sectionalignment=%xn", pOptionHeader->SectionAlignment);
  printf("filealignment=%xn", pOptionHeader->FileAlignment);
  printf("sizeofimage=%xn", pOptionHeader->SizeOfImage);
  printf("sizeofheader=%xn", pOptionHeader->SizeOfHeaders);
  printf("checksum=%xn", pOptionHeader->CheckSum);*/
  pSectionHeader = (PIMAGE_SECTION_HEADER)((DWORD)pOptionHeader + pPEHeader->SizeOfOptionalHeader); //获取节表的地址  printf("%dn", pSectionHeader);
  printf("***********************节表信息如下*************************n");  DWORD NumberOfSection = pPEHeader->NumberOfSections;  for (DWORD i = 0; i < NumberOfSection; i++, pSectionHeader++)  {    printf("********************第%d个节信息:***********************n", i + 1);    printf("section_name:");    for (DWORD j = 0; j < IMAGE_SIZEOF_SHORT_NAME; j++)    {      printf("%c", pSectionHeader->Name[j]);    }    printf("n");    printf("misc:%xn", pSectionHeader->Misc);    printf("VirtualAddress:%08Xn", pSectionHeader->VirtualAddress);    printf("SizeOfRawData:%08Xn", pSectionHeader->SizeOfRawData);    printf("PointerToRawData:%08Xn", pSectionHeader->PointerToRawData);    printf("Characteristics%08Xn", pSectionHeader->Characteristics);    }  //printf("%xn", pDosHeader);   //printf("%x", *(PWORD)pfileBuffer); //这里打印出来的就是5a4d   //printf("%dn", *(PWORD)((DWORD)pfileBuffer + pDosHeader->e_lfanew));  //这里是将5a4d加上DOS头的偏移地址 //打印出来的地址就是4550 转换16进制即可  //printf("%dn", (PIMAGE_FILE_HEADER)(((DWORD)pNTHeader) + 4)); //打印NT头的第一个属性也就是DWORD Signature 也就是标准PE头的地址。  //printf("%dn", (PIMAGE_OPTIONAL_HEADER32)((DWORD)pPEHeader + IMAGE_SIZEOF_FILE_HEADER));//获取到可选PE头的地址  fclose(fp);}  int main(){  readPeFile();}

#include <iostream>union TestUnion{  char x;  int y;};int main(){  TestUnion t;  t.y = 0x12345678;
  printf("%xn", t.x);
  return 0;}

DOS头 + 垃圾数据 + 标准PE头 + 可选PE头的大小(SizeOfOptionaHeader E0字节)

#define IMAGE_SIZEOF_SHORT_NAME 8typedef struct _IMAGE_SECTION_HEADER {    BYTE    Name[IMAGE_SIZEOF_SHORT_NAME];    union {            DWORD   PhysicalAddress;            DWORD   VirtualSize;           // 节区尺寸    } Misc;    DWORD   VirtualAddress;                // 节区RVA    DWORD   SizeOfRawData;                 // 在文件中对齐后的尺寸    DWORD   PointerToRawData;              // 在文件中的偏移    DWORD   PointerToRelocations;          // 在OBJ文件中使用    DWORD   PointerToLinenumbers;    WORD    NumberOfRelocations;    WORD    NumberOfLinenumbers;    DWORD   Characteristics;               // 节区属性字段} IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;

1.首先考虑的是我们应该分多少内存呢？意思就是说我们应该开辟多大的内存来复制文件中的数据。这里可以通过SizeOfImage (内存中整个PE文件的映射的尺寸，可以比实际的值大，但必须是SectionAlignment的整数倍。)2.那么开辟完新的空间之后，然后将文件中的数据一个一个复制到内存中，首先将头部和节表全部copy过来，copy的大小可以根据SizeOfHeaders来决定，比如说在文件中头部和节表加起来是1000，那么copy到内存中也是1000，copy之前需要将内存中间全部初始化为0。3.紧接着就是节的数据了，首先通过PointerToRawData找到节开始的地方，然后开始复制数据，复制到内存的什么地方是由VirtualAddress来决定的，那么到底要copy多少数据是由SizeOfRawData来决定的。

#include <iostream>
void fun() {  printf("1");}int main(){  fun();}

44F7FFFF = 8F10FA - 8F19B6

jmp E9后面的硬编码 = 真实跳转的地址 - E9的下一条地址

jmp E9 = 真实跳转的地址 - E9的下一条地址

#include <iostream>#include <Windows.h>void fun() {  printf("1");}int main(){  MessageBox(0, 0, 0, 0);  fun();}

604363 - 651192 = FFFB31D1

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <malloc.h>
#include <malloc.h>#include <windows.h>int Size(FILE* p) {
  int num = 0;  fseek(p, 0, SEEK_END);  num = ftell(p);  //再把指针移到开头  fseek(p, 0, SEEK_SET);  return num;
}//读取文件的函数，返回的是文件的大小void readFile() {  //首先定义一个文件指针  FILE* fp = NULL;  //定义文件的大小  DWORD FileSize = 0;  LPVOID pfileBuffer = NULL;
  //打开文件  fp = fopen("C:\Windows\system32\notepad.exe", "rb");  if (fp == NULL) {    printf("打开文件失败");  }  //读取文件的大小  FileSize = Size(fp);  //printf("文件大小为:%d", FileSize);  //创建缓冲区  pfileBuffer = malloc(FileSize);  if (pfileBuffer == NULL) {    printf("内存分配失败");    free(pfileBuffer);    fclose(fp);  }  //将exe写入到内存中，动态分配内存  size_t n = fread(pfileBuffer, FileSize, 1, fp);  if (n == NULL) {    printf("数据读取失败");    free(pfileBuffer);    fclose(fp);  }  
  //FileBuffer --> imageBuffer  //首先初始化PE头部的一些信息  PIMAGE_DOS_HEADER pDosHeader = NULL; //DOS头  PIMAGE_NT_HEADERS pNTHeader = NULL; //NT头   PIMAGE_FILE_HEADER pPEHeader = NULL; //标准PE头  PIMAGE_OPTIONAL_HEADER32 pOptionHeader = NULL; //可选PE头  PIMAGE_SECTION_HEADER pSectionHeader = NULL; //节表    //初始化IMAGEBUFFER指针  LPVOID pTempImagebuffer = NULL;    if (pfileBuffer == NULL) {    printf("读取到内存的pfilebuffer无效!!!");  }
  //判断PE独有的标记 MZ标记  if (*((PWORD)pfileBuffer) != IMAGE_DOS_SIGNATURE) { //这里的IMAGE_DOS_SIGNATURE其实就是5a4d    printf("这不是一个PE文件");  }  pDosHeader = PIMAGE_DOS_HEADER(pfileBuffer);//获取到DOS头  //判断是否有PE的标志  if (*((PDWORD)((DWORD)pfileBuffer + pDosHeader->e_lfanew)) != IMAGE_NT_SIGNATURE) { // 注意指针的加法是：去掉一个*后的类型相加。必须转换为DWORD类型再加减。    //相加后的和 强制类型转换为4字节指针类型（PWORD） IMAGE_NT_SIGNATURE 4BYTES    printf("不是有效的PE标志！n");  }  // 强制结构体类型转换  pNTHeader = (PIMAGE_NT_HEADERS)((DWORD)pfileBuffer + pDosHeader->e_lfanew); //获取到NT头  pPEHeader = (PIMAGE_FILE_HEADER)((DWORD)pNTHeader + 4); //获取标准PE头  pOptionHeader = (PIMAGE_OPTIONAL_HEADER32)((DWORD)pPEHeader + IMAGE_SIZEOF_FILE_HEADER); //获取到可选PE头 //这里的IMAGE_SIZEOF_FILE_HEADER其实就是标准PE头的大小 值为20  pSectionHeader = (PIMAGE_SECTION_HEADER)((DWORD)pOptionHeader + pPEHeader->SizeOfOptionalHeader); //获取到节表 这是是通过标准PE头的SizeOfOptionalHeader属性来定位节表    //分配动态内存  pTempImagebuffer =  malloc(pOptionHeader->SizeOfImage); //这里的SizeOfImage表示的是内存中整个PE文件的映射的尺寸  if (!pTempImagebuffer) {    printf("分配内存失败");  }  //初始化动态内存  memset(pTempImagebuffer,0, pOptionHeader->SizeOfImage);
  // 拷贝头部    //第一个参数是你要将内容copy到哪里    //第二个参数是你要复制的数据源的指针    //最后一个参数就是你要copy多少字节  memcpy(pTempImagebuffer, pDosHeader, pOptionHeader->SizeOfHeaders);
  // 循环拷贝节表  PIMAGE_SECTION_HEADER pTempSectionHeader = pSectionHeader;  for (DWORD i = 0; i < pPEHeader->NumberOfSections; i++, pTempSectionHeader++)  {    memcpy((void*)((DWORD)pTempImagebuffer + pTempSectionHeader->VirtualAddress), (void*)((DWORD)pfileBuffer + pTempSectionHeader->PointerToRawData), pTempSectionHeader->SizeOfRawData);  }  // 返回数据  pTempImagebuffer = NULL;}int main(){    readFile();}