紧接着上一篇的千里追踪输入表，现在终于可以开始看输入表里面的神奇东东了。。。
还是copy小甲鱼的课件。。。。
输入表结构
回顾一下，在 PE文件头的 IMAGE_OPTIONAL_HEADER 结构中的 DataDirectory(数据目录表) 的第二个成员就是指向输入表的。而输入表是以一个 IMAGE_IMPORT_DESCRIPTOR(简称IID) 的数组开始。每个被 PE文件链接进来的 DLL文件都分别对应一个 IID数组结构。在这个 IID数组中，并没有指出有多少个项(就是没有明确指明有多少个链接文件)，但它最后是以一个全为NULL(0) 的 IID 作为结束的标志。
IMAGE_IMPORT_DESCRIPTOR 结构定义如下：
IMAGE_IMPORT_DESCRIPTOR STRUCT
union
Characteristics DWORD ?
OriginalFirstThunk DWORD ?
ends
TimeDateStamp DWORD ?
ForwarderChain DWORD ?
Name DWORD ?
FirstThunk DWORD ?
IMAGE_IMPORT_DESCRIPTOR ENDS
成员介绍:
OriginalFirstThunk
它指向first thunk，IMAGE_THUNK_DATA，该 thunk 拥有 Hint 和 Function name 的地址。
TimeDateStamp
该字段可以忽略。如果那里有绑定的话它包含时间/数据戳（time/data stamp）。如果它是0，就没有绑定在被导入的DLL中发生。在最近，它被设置为0xFFFFFFFF以表示绑定发生。
ForwarderChain
一般情况下我们也可以忽略该字段。在老版的绑定中，它引用API的第一个forwarder chain（传递器链表）。它可被设置为0xFFFFFFFF以代表没有forwarder。
Name
它表示DLL 名称的相对虚地址（译注：相对一个用null作为结束符的ASCII字符串的一个RVA，该字符串是该导入DLL文件的名称，如：KERNEL32.DLL）。
FirstThunk
它包含由IMAGE_THUNK_DATA定义的 first thunk数组的虚地址，通过loader用函数虚地址初始化thunk。在Orignal First Thunk缺席下，它指向first thunk：Hints和The Function names的thunks。
这个OriginalFirstThunk 和 FirstThunk明显是亲家，两家伙首先名字就差不多哈。那他们有什么不可告人的秘密呢？来，我们看下面一张图（画的很辛苦，大家仔细看哈）：
我们看到：OriginalFirstThunk 和 FirstThunk 他们都是两个类型为IMAGE_THUNK_DATA 的数组，它是一个指针大小的联合（union）类型。每一个IMAGE_THUNK_DATA 结构定义一个导入函数信息（即指向结构为IMAGE_IMPORT_BY_NAME 的家伙，这家伙稍后再议），然后数组最后以一个内容为0 的 IMAGE_THUNK_DATA 结构作为结束标志。
我们得到 IMAGE_THUNK_DATA 结构的定义如下：
IMAGE_THUNK_DATA STRUC
union u1
ForwarderString DWORD ? ; 指向一个转向者字符串的RVA
Function DWORD ? ; 被输入的函数的内存地址
Ordinal DWORD ? ; 被输入的API 的序数值
AddressOfData DWORD ? ; 指向 IMAGE_IMPORT_BY_NAME
ends
IMAGE_THUNK_DATA ENDS
我们可以看出由于是union结构，所以IMAGE_THUNK_DATA 事实上是一个双字大小。该结构在不同时候赋予不同的意义（伟大神奇不得鸟……）。其实union这种数据结构很容易理解：说白了就是当时穷，能省就省，再说白了，就是几兄弟姐妹轮流穿一条裤子去相亲！理解了吧？哈哈~
那我们怎么来区分何时是何意义呢？
规定如下：
当 IMAGE_THUNK_DATA 值的最高位为 1时，表示函数以序号方式输入，这时候低 31位被看作一个函数序号。
当 IMAGE_THUNK_DATA 值的最高位为 0时，表示函数以字符串类型的函数名方式输入，这时双字的值是一个 RVA，指向一个 IMAGE_IMPORT_BY_NAME 结构。（演示请看小甲鱼解密系列视频讲座）
好，那接着我们讨论下指向的这个 IMAGE_IMPORT_BY_NAME 结构。IMAGE_IMPORT_BY_NAME 结构仅仅只有一个字型数据的大小，存有一个输入函数的相关信息结构。其结构如下：
IMAGE_IMPORT_BY_NAME STRUCT
Hint WORD ?
Name BYTE ?
IMAGE_IMPORT_BY_NAME ENDS
结构中的 Hint 字段也表示函数的序号，不过这个字段是可选的，有些编译器总是将它设置为 0，Name 字段定义了导入函数的名称字符串，这是一个以 0 为结尾的字符串。
整个过程看起来有点绕有点烦，别急，后边我们有演示哈。
输入地址表（IAT）
为什么由两个并行的指针数组同时指向 IMAGE_IMPORT_BY_NAME 结构呢？第一个数组（由 OriginalFirstThunk 所指向）是单独的一项，而且不能被改写，我们前边称为 INT。第二个数组（由 FirstThunk 所指向）事实上是由 PE 装载器重写的。
好了，那么 PE 装载器的核心操作时如何的呢？这里就给大家揭秘啦~
PE 装载器首先搜索 OriginalFirstThunk ，找到之后加载程序迭代搜索数组中的每个指针，找到每个 IMAGE_IMPORT_BY_NAME 结构所指向的输入函数的地址，然后加载器用函数真正入口地址来替代由 FirstThunk 数组中的一个入口，因此我们称为输入地址表（IAT）。所以，当我们的 PE 文件装载内存后准备执行时，刚刚的图就会转化为下图：
此时，输入表中其他部分就不重要了，程序依靠 IAT 提供的函数地址就可正常运行。
自己在写的时候遇到了很多问题：
1.输入表一定在.idata区块里面吗？
答：当然不是了。在VC编译器下面是这样的，但是不同的编译器下面是不一样的。而且区块的名称只是名称而已，没有什么大用处。
2.注意一下
IMAGE_THUNK_DATA这个数据结构，可以回上去看看小甲鱼的课件，它是一个联合体类型。
当 IMAGE_THUNK_DATA 值的最高位为 0时，表示函数以字符串类型的函数名方式输入，这时双字的值是一个 RVA，指向一个
这个时候很好办，我们可以找到这个RVA换算成offset 最终获得它的函数名称
当 IMAGE_THUNK_DATA 值的最高位为 1时，表示函数以序号方式输入，这时候低 31位被看作一个函数序号。
这个时候就讨厌了，如果没有考虑到这个情况的话，程序很可能会因为错误的指针而出错。
这个时候我们就应该用一个if语句来进行一下判断：
PIMAGE_THUNK_DATA SrcImageThunkData = (PIMAGE_THUNK_DATA) PINT;
if ( ! (SrcImageThunkData[i].u1.Ordinal & 0x80000000))
这里用到了 & 按位与运算
注意一下这里的 0x80000000是十六进制的，0x8转换成二进制就是1000 这样最高位就是1了
通过这个if条件的判断，就可以知道联合体的成员是ForwarderString 还是Ordinal
好吧，下面把我自己写的代码贴上来，虽然说有点乱，只是当做自己的笔记。大家可以不看的。因为代码写的很不工整。。。。
注意一下这里的 0x80000000是十六进制的，0x8转换成二进制就是1000 这样最高位就是1了
通过这个if条件的判断，就可以知道联合体的成员是ForwarderString 还是Ordinal
好吧，下面把我自己写的代码贴上来，虽然说有点乱，只是当做自己的笔记。大家可以不看的。因为代码写的很不工整。。。。
#include <stdio.h>
#include <windows.h>
#include <tchar.h>
#include <winnt.h>
const TCHAR* FileName = L"d:\\PING.exe";
//文件目录
const TCHAR* NewFileName = L"d:\\PING2.exe";
//复制的文件目录
HANDLE hFile;
//文件句柄
BYTE* pBase = NULL;
//基地址
int NumberOfSections;
//区块表的个数
DWORD IMPORT_RVA = NULL;
//输入表的RVA
DWORD IMPORT_OFFSET = NULL;
//输入表的offset
DWORD IN_IMPORT_RVA = NULL;
//输入表所在的区块的起始RVA
DWORD IN_IMPORT_OFFSET = NULL;
//输入表所在区块的物理起始地址
BYTE* fnReadFile();
//读取文件
int fnReadPE (BYTE *pBuffer);
//读取PE文件信息
BYTE* fnReadDosHeader(BYTE* pBuffer);
//读取dos文件头信息
int fnReadNTHeader(BYTE* pBuffer);
//读取 PE文件头信息
int fnReadFileHeader(BYTE* ImageFileHeader);
//读取PE文件头中的FileHeader结构的信息
int fnReadOptionalHeader(BYTE* ImageOptionalHeader);
//读取PE文件头中的OptionalHeader结构的信息
int fnReadSectionHeader(BYTE* ImageSectionHeader);
//读取区块表
int fnReadImportTable(BYTE* ImportTable);
//读取输入表
int fnReadDllName(BYTE* PDllName);
//读取DLL名称
int fnReadINT(BYTE* PINT);
//读取INT
int fnReadFunctionName(BYTE* PFunctionName);
//读取函数名称
//int fnAddSectionTable(LONG offset);
//添加PE区块表
int Copy();
//复制文件，防止文件被破坏
IMAGE_SECTION_HEADER Own_Section_Header;
/*
Own_Section_Header.Name[Own_Section_Header] = ".carl";
Own_Section_Header.VirtualAddress = 9A010000 ; // 节区的 RVA 地址
Own_Section_Header.SizeOfRawData =00100000 ; // 在文件中对齐后的尺寸
Own_Section_Header.PointerToRawData = 00020000; // 在文件中的偏移量
Own_Section_Header.PointerToRelocations = 00040000; // 在OBJ文件中使用，重定位的偏移
Own_Section_Header.PointerToLinenumbers = 00000000; // 行号表的偏移（供调试使用地）
Own_Section_Header.NumberOfRelocations =0000; // 在OBJ文件中使用，重定位项数目
Own_Section_Header.NumberOfLinenumbers = 0000; // 行号表中行号的数目
Own_Section_Header.Characteristics = 20000060; // 节属性如可读，可写，可执行等
*/
int main()
{
Copy();
BYTE* pBuffer = fnReadFile();
fnReadPE (pBuffer);
return 0;
}
BYTE* fnReadFile()
{
printf("映射文件...\n");
hFile = CreateFile(NewFileName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
//读取文件
if (hFile == INVALID_HANDLE_VALUE)
{
printf("打开文件出错\n");
return 0;
}
DWORD dwFileSize = GetFileSize(hFile, NULL);
//获得文件大小
BYTE* pBuffer = new BYTE[dwFileSize];
//new相当于malloc
DWORD dwSizeOfRead;
if(!ReadFile(hFile, pBuffer, dwFileSize, &dwSizeOfRead, NULL))
{
printf("读取文件出错\n");
pBase = NULL;
return 0;
}
pBase = pBuffer;
return pBase;
//基地址
}
int fnReadPE(BYTE *pBuffer)
{
printf("读取PE信息...\n");
BYTE* pBaseNTHeader = fnReadDosHeader(pBuffer);
//调用fnReadDosHeader函数获取Dos头信息,并且获得PE文件头的基地址
if (!pBaseNTHeader)
{
return 1;
}
if (!fnReadNTHeader(pBaseNTHeader))
//读取PE文件头信息
{
return 1;
}
return 0;
}
BYTE* fnReadDosHeader(BYTE* pBuffer)
//读取dos文件头信息
{
printf("读取DOS文件头...\n");
PIMAGE_DOS_HEADER SrcImageDosHeader = (PIMAGE_DOS_HEADER)pBuffer;
if (SrcImageDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
{
return 0;
}
else
{
printf("IMAGE_DOS_HEADER结构\n");
printf("e_magic :%04x DOS可执行文件标记\n",SrcImageDosHeader->e_magic);
printf("e_cblp :%04x Bytes on last page of file\n",SrcImageDosHeader->e_cblp);
printf("e_cp :%04x Page in file\n", SrcImageDosHeader->e_cp);
printf("e_crlc :%04x Relocations\n", SrcImageDosHeader->e_crlc);
printf("e_cparhdr :%04x Size of header in paragraphs\n", SrcImageDosHeader->e_cparhdr);
printf("e_minalloc:%04x Minimum extra paragraphs needed\n", SrcImageDosHeader->e_minalloc);
printf("e_maxalloc:%04x Maximum extra paragraphs needed\n", SrcImageDosHeader->e_maxalloc);
printf("e_ss :%04x Initial (relative) SS value DOS代码的初始化堆栈SS\n", SrcImageDosHeader->e_ss);
printf("e_sp :%04x Initial SP value DOS代码的初始化堆栈指针SP\n", SrcImageDosHeader->e_sp);
printf("e_csum :%04x Checksum\n", SrcImageDosHeader->e_csum);
printf("e_ip :%04x Initial IP value DOS代码的初始化指针入口\n", SrcImageDosHeader->e_ip);
printf("e_cs :%04x Initial (relative) CS value DOS代码的初始堆栈入口\n", SrcImageDosHeader->e_cs);
printf("e_lfarlc :%04x File address of elocation table\n", SrcImageDosHeader->e_lfarlc);
printf("e_ovno :%04x Overlay number\n", SrcImageDosHeader->e_ovno);
printf("e_res[4] :%04x, %04x, %04x, %04x Reserved words\n", SrcImageDosHeader->e_res[0],SrcImageDosHeader->e_res[1],SrcImageDosHeader->e_res[2],SrcImageDosHeader->e_res[3]);
printf("e_oemid :%04x OEM identifier (for e_oeminfo)\n", SrcImageDosHeader->e_oemid);
printf("e_oeminfo :%04x OEM information; e_oemid specific\n", SrcImageDosHeader->e_oeminfo);
printf("e_res2[10]:%04x,%04x,%04x,%04x,%04x,%04x,%04x,%04x,%04x,%04x, Reserved words\n", SrcImageDosHeader->e_res2[0],SrcImageDosHeader->e_res2[1],SrcImageDosHeader->e_res2[2],SrcImageDosHeader->e_res2[3],SrcImageDosHeader->e_res2[4],SrcImageDosHeader->e_res2[5],SrcImageDosHeader->e_res2[6],SrcImageDosHeader->e_res2[7],SrcImageDosHeader->e_res2[8],SrcImageDosHeader->e_res2[9]);
printf("e_lfanew :%04x File address of new exe header 指向PE文件头\n", SrcImageDosHeader->e_lfanew);
}
LONG test = (LONG) (SrcImageDosHeader->e_lfanew);
//fnAddSectionTable(test);//PE文件头的开始位置
return (BYTE*) (pBuffer + SrcImageDosHeader->e_lfanew);
}
int fnReadNTHeader(BYTE* pBaseNTBuffer)
{
printf("读取PE文件头...\n");
PIMAGE_NT_HEADERS SrcImageNTHeader = (PIMAGE_NT_HEADERS)(pBaseNTBuffer);
if (SrcImageNTHeader->Signature != IMAGE_NT_SIGNATURE)
{
return 1;
}
else
{
printf("IMAGE_NT_HEADERS结构\n");
printf("Signature :%08x\n", SrcImageNTHeader->Signature);
fnReadFileHeader((BYTE*)&SrcImageNTHeader->FileHeader);
//读取FileHeader结构的信息
fnReadOptionalHeader((BYTE*) &SrcImageNTHeader->OptionalHeader);
//读取OptionalHeader结构的信息
fnReadSectionHeader((BYTE*)IMAGE_FIRST_SECTION(pBaseNTBuffer));
//读取区块表
fnReadImportTable((BYTE*) (pBase+IMPORT_OFFSET));
}
return 0;
}
int fnReadFileHeader(BYTE* ImageFileHeader)
{
PIMAGE_FILE_HEADER SrcImageFileHeader = (PIMAGE_FILE_HEADER)ImageFileHeader;
printf("IMAGE_FILE_HEADERS结构\n");
printf("Machine: %04x\n", SrcImageFileHeader->Machine);
printf("NumberOfSections: %04x\n", SrcImageFileHeader->NumberOfSections);
printf("TimeDateStamp: %08x\n", SrcImageFileHeader->TimeDateStamp);
printf("PointerToSymbolTable: %08x\n", SrcImageFileHeader->PointerToSymbolTable);
printf("NumberOfSymbols: %08x\n", SrcImageFileHeader->NumberOfSymbols);
printf("SizeOfOptionalHeader: %04x\n", SrcImageFileHeader->SizeOfOptionalHeader);
printf("Characteristics: %04x\n", SrcImageFileHeader->Characteristics);
NumberOfSections = SrcImageFileHeader->NumberOfSections;
return 0;
}
int fnReadOptionalHeader(BYTE* ImageOptionalHeader)
{
PIMAGE_OPTIONAL_HEADER SrcImageOptional_Header = (PIMAGE_OPTIONAL_HEADER)ImageOptionalHeader;
printf("IMAGE_OPTIONAL_HEADER结构\n");
// Standard fields.
printf("Magic: %04x\n", SrcImageOptional_Header->Magic);
printf("MajorLinkerVersion: %02x\n", SrcImageOptional_Header->MajorLinkerVersion);
printf("MinorLinkerVersion: %02x\n", SrcImageOptional_Header->MinorLinkerVersion);
printf("SizeOfCode: %08x\n", SrcImageOptional_Header->SizeOfCode);
printf("SizeOfInitializedData: %08x\n", SrcImageOptional_Header->SizeOfInitializedData);
printf("SizeOfUninitializedData: %08x\n", SrcImageOptional_Header->SizeOfUninitializedData);
printf("AddressOfEntryPoint: %08x\n", SrcImageOptional_Header->AddressOfEntryPoint);
printf("BaseOfCode: %08x\n", SrcImageOptional_Header->BaseOfCode);
printf("BaseOfData: %08x\n", SrcImageOptional_Header->BaseOfData);
// NT additional fields.
printf("ImageBase: %08x\n", SrcImageOptional_Header->ImageBase);
printf("SectionAlignment: %08x\n", SrcImageOptional_Header->SectionAlignment);
printf("FileAlignmen: %08x\n", SrcImageOptional_Header->FileAlignment);
printf("MajorOperatingSystemVersion:%04x\n", SrcImageOptional_Header->MajorOperatingSystemVersion);
printf("MinorOperatingSystemVersion:%04x\n", SrcImageOptional_Header->MinorOperatingSystemVersion);
printf("MajorImageVersion; %04x\n", SrcImageOptional_Header->MajorImageVersion);
printf("MinorImageVersion: %04x\n", SrcImageOptional_Header->MinorImageVersion);
printf("MajorSubsystemVersion: %04x\n", SrcImageOptional_Header->MajorSubsystemVersion);
printf("MinorSubsystemVersion: %04x\n", SrcImageOptional_Header->MinorSubsystemVersion);
printf("Win32VersionValue: %08x\n", SrcImageOptional_Header->Win32VersionValue);
printf("SizeOfImage: %08x\n", SrcImageOptional_Header->SizeOfImage);
printf("SizeOfHeaders: %08x\n", SrcImageOptional_Header->SizeOfHeaders);
printf("CheckSum: %08x\n", SrcImageOptional_Header->CheckSum);
printf("Subsystem: %04x\n", SrcImageOptional_Header->Subsystem);
printf("DllCharacteristics: %04x\n", SrcImageOptional_Header->DllCharacteristics);
printf("SizeOfStackReserve: %08x\n", SrcImageOptional_Header->SizeOfStackReserve);
printf("SizeOfStackCommit: %08x\n", SrcImageOptional_Header->SizeOfStackCommit);
printf("SizeOfHeapReserve: %08x\n", SrcImageOptional_Header->SizeOfHeapCommit);
printf("SizeOfHeapCommit: %08x\n", SrcImageOptional_Header->SizeOfHeapCommit);
printf("LoaderFlags: %08x\n", SrcImageOptional_Header->LoaderFlags);
printf("NumberOfRvaAndSizes: %08x\n", SrcImageOptional_Header->NumberOfRvaAndSizes);
//获得数据目录表中输入表的大小和RVA地址
printf("IMAGE_DIRECTORY_ENTRY_EXPOET Size: %08x\n", SrcImageOptional_Header->DataDirectory[1].Size);
printf("IMAGE_DIRECTORY_ENTRY_EXPOET VirtualAddress(RVA): %08x\n", SrcImageOptional_Header->DataDirectory[1].VirtualAddress);
IMPORT_RVA = SrcImageOptional_Header->DataDirectory[1].VirtualAddress;
return 0;
}
int fnReadSectionHeader(BYTE* ImageSectionHeader){
int i = 0;
int NUMBER_OF_RVA = NULL;
//获得输入表所在的区块位置
PIMAGE_SECTION_HEADER SrcImageSectionHeader = (PIMAGE_SECTION_HEADER) ImageSectionHeader;
//数组名可以看成是指针，所以下面可以用数组的方式来表示相当于 （i+1） *sizeof(PIMAGE_SECTION_HEADER)
printf("IMAGE_SECTION_HEADER结构\n");
for (i = 0; i < NumberOfSections; i++)
{
char SectionName[9];
memset(SectionName, 0, sizeof(SectionName));
memcpy(SectionName, SrcImageSectionHeader[i].Name, 8);
printf("name:%s\n", SectionName);
printf("Misc: %08x\n", SrcImageSectionHeader[i].Misc);
printf("VirtualAddres: %08x\n", SrcImageSectionHeader[i].VirtualAddress);
printf("SizeOfRawData: %08x\n", SrcImageSectionHeader[i].SizeOfRawData);
printf("PointerToRawData: %08x\n", SrcImageSectionHeader[i].PointerToRawData);
printf("PointerToRelocations:%08x\n", SrcImageSectionHeader[i].PointerToRelocations);
printf("PointerToLinenumbers:%08x\n", SrcImageSectionHeader[i].PointerToLinenumbers);
printf("NumberOfRelocations: %04x\n", SrcImageSectionHeader[i].NumberOfRelocations);
printf("NumberOfLinenumbers: %04x\n", SrcImageSectionHeader[i].NumberOfLinenumbers);
printf("Characteristics: %08x\n", SrcImageSectionHeader[i].Characteristics);
if (i < NumberOfSections - 1)
if (IMPORT_RVA >= SrcImageSectionHeader[i].VirtualAddress && IMPORT_RVA < SrcImageSectionHeader[i+1].VirtualAddress)
NUMBER_OF_RVA = i;
}
printf("输入表所在的区块是在第%d个区块\n", NUMBER_OF_RVA+1);
IMPORT_OFFSET = IMPORT_RVA - (SrcImageSectionHeader[NUMBER_OF_RVA].VirtualAddress - SrcImageSectionHeader[NUMBER_OF_RVA].PointerToRawData);
//printf("%08x\n", SrcImageSectionHeader[NUMBER_OF_RVA].VirtualAddress);
//printf("%08x\n", SrcImageSectionHeader[NUMBER_OF_RVA].PointerToRawData);
IN_IMPORT_RVA = SrcImageSectionHeader[NUMBER_OF_RVA].VirtualAddress;
//输入表所在的区块的起始RVA
IN_IMPORT_OFFSET = SrcImageSectionHeader[NUMBER_OF_RVA].PointerToRawData;
//输入表所在区块的物理起始地址
//printf("输入表的RVA是%08x\n", IMPORT_RVA);
//printf("输入表的offset是%08x\n", IMPORT_OFFSET);
return 0;
}
int fnReadImportTable(BYTE* ImportTable)
{
PIMAGE_IMPORT_DESCRIPTOR SrcImageImportDescriptor = (PIMAGE_IMPORT_DESCRIPTOR)ImportTable;
printf("输入表内容.....\n");
for (int i = 0; SrcImageImportDescriptor[i].OriginalFirstThunk != 0; i++)
//IID最后一个结构如果全部为0标志着结束
{
printf("OriginalFirstThunk is %08x\n",SrcImageImportDescriptor[i].OriginalFirstThunk);
printf("TimeDataStamp is %08x\n", SrcImageImportDescriptor[i].TimeDateStamp);
printf("ForwarderChain is %08x\n",SrcImageImportDescriptor[i].ForwarderChain);
printf("Name is %08x\n", SrcImageImportDescriptor[i].Name);
printf("FirstChunk is %08x\n ",SrcImageImportDescriptor[i].FirstThunk);
printf("\n");
fnReadDllName((BYTE*)(SrcImageImportDescriptor[i].Name - IN_IMPORT_RVA + IN_IMPORT_OFFSET + pBase));
fnReadINT((BYTE*) (SrcImageImportDescriptor[i].OriginalFirstThunk - IN_IMPORT_RVA + IN_IMPORT_OFFSET + pBase) );
//BYTE * SrcImageThunkData = SrcImageImportDescriptor[i].OriginalFirstThunk;
//PIMAGE_THUNK_DATA SrcImageThunkData =
}
return 0;
}
int fnReadDllName(BYTE* PDllName)
{
char* Dll;
Dll = (char*)PDllName;
printf("Dll name is %s\n", Dll);
printf("\n");
return 0;
}
int fnReadINT(BYTE* PINT)
{
PIMAGE_THUNK_DATA SrcImageThunkData = (PIMAGE_THUNK_DATA) PINT;
for (int i = 0; SrcImageThunkData[i].u1.AddressOfData != 0; i++)
{
//printf("IMAGE_THUNK_DATA INT is %08x\n", SrcImageThunkData[i].u1);
PIMAGE_IMPORT_BY_NAME SrcImageImportByName = (PIMAGE_IMPORT_BY_NAME)(SrcImageThunkData[i].u1.AddressOfData - IN_IMPORT_RVA + IN_IMPORT_OFFSET + pBase);
if ( ! (SrcImageThunkData[i].u1.Ordinal & 0x80000000))
//这里的8是16进制的，转换为2进制就是1000
{
char* FunctionName;
FunctionName = (char*)(SrcImageImportByName) + sizeof(char) * 2;
printf("Function name is %s\n", FunctionName);
printf("\n");
}
/*
else
{
printf("%08x\n",SrcImageThunkData[i].u1.Ordinal & 0x80000000);
}
*/
}
//fnReadFunctionName((BYTE*) (SrcImageThunkData->u1.AddressOfData - IN_IMPORT_RVA + IN_IMPORT_OFFSET + pBase) );
return 0;
}
int fnReadFunctionName(BYTE* PFunctionName)
{
char* FunctionName;
FunctionName = (char*)PFunctionName;
printf("Function name is %s\n", FunctionName);
printf("\n");
return 0;
}
/*
int fnAddSectionTable(LONG offset)
{
DWORD dwSizeOfWrite;
DWORD add = 0x6C726163;
LPDWORD lpNumberOfBytesWritten = NULL;
PIMAGE_SECTION_HEADER p = &Own_Section_Header;
//BYTE* ChangeAddress = ImageSectionTable - 2 *sizeof(BYTE);
//BYTE* lpWriteBuffer = ImageSectionTable - 8 * sizeof(BYTE);
//Own_Section_Header.Name[Own_Section_Header] = ".carl";
//Own_Section_Header.VirtualAddress = 9A010000 ; // 节区的 RVA 地址
Own_Section_Header.SizeOfRawData =00100000 ; // 在文件中对齐后的尺寸
Own_Section_Header.PointerToRawData = 00020000; // 在文件中的偏移量
Own_Section_Header.PointerToRelocations = 00040000; // 在OBJ文件中使用，重定位的偏移
Own_Section_Header.PointerToLinenumbers = 00000000; // 行号表的偏移（供调试使用地）
Own_Section_Header.NumberOfRelocations =0000; // 在OBJ文件中使用，重定位项数目
Own_Section_Header.NumberOfLinenumbers = 0000; // 行号表中行号的数目
Own_Section_Header.Characteristics = 20000060; // 节属性如可读，可写，可执行等
SetFilePointer( hFile, offset, NULL, FILE_BEGIN );
if (WriteFile(hFile, p, 1 * sizeof(Own_Section_Header), &dwSizeOfWrite, NULL ))
printf("正确写入文件\n");
else
printf("写入文件错误\n");
return 0;
}
*/
int Copy()
{
BOOL Flag = TRUE;
if(CopyFile(FileName, NewFileName, Flag))
printf("成功复制文件\n");
else
printf("复制文件失败\n");
return 0;
}
扫一扫
2553
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
