1
2
|
#define IMAGE_ARCHIVE_START_SIZE 8
#define IMAGE_ARCHIVE_START "!
|
1
2
3
4
5
6
7
8
9
10
|
typedef struct _IMAGE_ARCHIVE_MEMBER_HEADER {
BYTE Name[16];
//
File member name - `/' terminated.
BYTE Date[12];
//
File member
date
- decimal.
BYTE UserID[6];
//
File member user
id
- decimal.
BYTE GroupID[6];
//
File member group
id
- decimal.
BYTE Mode[8];
//
File member mode - octal.
BYTE Size[10];
//
File member size – 头部大小不计算在内.
BYTE EndHeader[2];
//
String to end header.
} IMAGE_ARCHIVE_MEMBER_HEADER, *PIMAGE_ARCHIVE_MEMBER_HEADER;
#define IMAGE_SIZEOF_ARCHIVE_MEMBER_HDR 60
|
1
|
#define IMAGE_ARCHIVE_LINKER_MEMBER "/ "
|
1
|
#define IMAGE_ARCHIVE_LONGNAMES_MEMBER "// "
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
PBYTE CLibParser::GetFirstObjSection()
{
int iCtrl=0;
//
第一个链接器成员
PBYTE pSect = m_pLibImage+IMAGE_ARCHIVE_START_SIZE;
if
(!pSect)
return
NULL;
while
(pSect)
{
//
第二个链接器成员
if
(memcmp(((PIMAGE_ARCHIVE_MEMBER_HEADER)pSect)->Name,IMAGE_ARCHIVE_LINKER_MEMBER,16)==0)
{
//Nothing
}
//
第三个长名称成员
else
if
(memcmp(((PIMAGE_ARCHIVE_MEMBER_HEADER)pSect)->Name,IMAGE_ARCHIVE_LONGNAMES_MEMBER,16)==0)
//LONG
Name
{
//Nothing
//
尽管长名称成员的头部必须存在,但它本身却可以为空。
}
else
//
第一个目标文件成员
{
return
pSect;
}
//
注意BYTE Size[10];要用atol((LPSTR)..)这种方法才能得到正确size
PIMAGE_ARCHIVE_MEMBER_HEADER pAME=(PIMAGE_ARCHIVE_MEMBER_HEADER)pSect;
pSect += atol((LPSTR)pAME->Size) + sizeof(IMAGE_ARCHIVE_MEMBER_HEADER);
//
两个成员之间有可能是由\n隔开
if
(*pSect==
'\n'
) pSect++;
iCtrl++;
//
防止遇到错误的Lib文件,而死在这里面
if
(iCtrl>3)
{
break
;
}
}
return
NULL;
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
BOOL CLibParser::ParseObjs(PBYTE pObjSect)
{
do
{
PIMAGE_ARCHIVE_MEMBER_HEADER pAME=(PIMAGE_ARCHIVE_MEMBER_HEADER)pObjSect;
pObjSect+=sizeof(IMAGE_ARCHIVE_MEMBER_HEADER);
//
去掉头部,剩下的就是Obj(COFF格式)
//
判断是否是导入库格式,以防止错误的把导入库lib当做静态库lib,而程序直接挂掉
if
(bImportlibraryFormat(pObjSect))
{
MessageBox(NULL,
"This is not a Archive Format File,it's a Import Format File!"
,
"WARNING"
,MB_ICONWARNING);
return
FALSE;
}
//
解析目标成员(OBJ)
CObjParser objParser;
objParser.Parse(pObjSect,m_pNameFile,m_pDataFile,&m_FuncTable);
//
注意:BYTE Size[10];要用atol((LPSTR)..)这种方法才能得到正确size
pObjSect += atol((LPSTR)pAME->Size) ;
//
注意:两个成员之间有可能是由\n隔开,《PE COFF 文件格式》中并没有提到
if
(*pObjSect==
'\n'
)
pObjSect++;
}
while
(pObjSect
return
TRUE;
}
|
1
2
3
4
5
6
7
8
9
|
typedef struct _IMAGE_FILE_HEADER {
WORD Machine;
WORD NumberOfSections;
DWORD TimeDateStamp;
DWORD PointerToSymbolTable;
//
指向符号表
DWORD NumberOfSymbols;
//
符号表的大小
WORD SizeOfOptionalHeader;
WORD Characteristics;
} IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
typedef struct _IMAGE_SECTION_HEADER {
BYTE Name[IMAGE_SIZEOF_SHORT_NAME];
union {
DWORD PhysicalAddress;
DWORD VirtualSize;
} Misc;
DWORD VirtualAddress;
DWORD SizeOfRawData;
//
指定节大小
DWORD PointerToRawData;
//
指向节数据
DWORD PointerToRelocations;
//
指向此节重定位信息表
DWORD PointerToLinenumbers;
WORD NumberOfRelocations;
//
此节重定位信息表的大小
WORD NumberOfLinenumbers;
DWORD Characteristics;
} IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;
|
1
2
3
4
5
6
7
8
|
typedef struct _IMAGE_RELOCATION {
union {
DWORD VirtualAddress;
//
在相应节中的偏移
DWORD RelocCount; };
DWORD SymbolTableIndex;
//
此重定位信息的符号表索引
WORD Type;
} IMAGE_RELOCATION;
typedef IMAGE_RELOCATION UNALIGNED *PIMAGE_RELOCATION;
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
typedef struct _IMAGE_SYMBOL {
union {
BYTE ShortName[8];
struct {
DWORD Short;
//
如果是长名称,这四个字节为0
DWORD Long;
//
指定长名称位于字符串表中的偏移
} Name;
DWORD LongName[2];
//
PBYTE [2]
} N;
DWORD Value;
//
如果此符号是函数符号,给出函数数据在相应节中的偏移
SHORT SectionNumber;
//
此符号相应节位于节表的索引,从1开始
WORD Type;
//
如果是函数符号,此值为0x20
BYTE StorageClass;
//
如果是函数符号,此值为
//IMAGE_SYM_CLASS_EXTERNAL
(2)
BYTE NumberOfAuxSymbols;
//
辅助符号表的个数,如果有辅助符号表,
//
紧跟着每个符号表后面,一般是0-1张辅助符号表
} IMAGE_SYMBOL;
typedef IMAGE_SYMBOL UNALIGNED *PIMAGE_SYMBOL;
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
//
遍历符号表,过滤出其中的函数符号
for
(DWORD i=0;i
{
pSymbol=m_pSymbol+i;
//
存储类别为EXTERNAL()、Type 域的值表明它是一个函数(x20)
//
以及SectionNumber 域的值大于,它就标志着函数的开头
if
(ISFCN(pSymbol->Type)&&pSymbol->SectionNumber>0
&&pSymbol->StorageClass==IMAGE_SYM_CLASS_EXTERNAL)
{
memset(&funcHeader,0,sizeof(funcHeader));
GetNameofSymb(pSymbol,funcHeader);
GetDataofSymb(pSymbol,funcHeader);
m_pFuncTable->push_back(funcHeader);
}
//
直接跳过辅助符号表
i+=pSymbol->NumberOfAuxSymbols;
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
void CObjParser::GetNameofSymb(PIMAGE_SYMBOL pSymbol,FuncHeader& funcHeader)
{
PCHAR pName=NULL;
CHAR shortNam[9]={0};
//
如果符号名称长度不超过个字节,那么符号表的ShortName 域
//
就是包含符号名本身的一个字节长的数组;
if
(pSymbol->N.Name.Short)
{
//pName
= (PCHAR)pSymbol->N.ShortName;
//
注意:符号名可能正好占满个字节,那就没有NULL结束符了,
//
所以不能简单的用上面的方法
memcpy_s(shortNam,9,pSymbol->N.ShortName,8);
pName=shortNam;
}
//
否则的话,它给出了字符串表中的一个偏移地址
else
{
pName= m_pStrings+pSymbol->N.Name.Long;
}
//
记录偏移
if
(m_pFuncTable->size()==0)
{
funcHeader.NameOff=0;
}
else
{
FuncHeader& funcHeadPrev=m_pFuncTable->at(m_pFuncTable->size()-1);
funcHeader.NameOff=funcHeadPrev.NameOff+funcHeadPrev.NameSize;
}
//
记录大小
funcHeader.NameSize=strlen(pName)+1;
//
写入nam文件
fwrite(pName,funcHeader.NameSize,1,m_pNamFile);
fflush(m_pNamFile);
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
//
获得函数数据
void CObjParser::GetDataofSymb(PIMAGE_SYMBOL pSymbol,FuncHeader& funcHeader)
{
PIMAGE_SECTION_HEADER pISH = m_pSectionHeader+(pSymbol->SectionNumber-1);
//SectionNumber
从开始的索引
if
(!pISH)
{
MessageBox(NULL,
"Get SectionHeader Error!"
,
"Error"
,MB_ICONWARNING);
return
;
}
//
记录偏移
if
(m_pFuncTable->size()==0)
{
funcHeader.DataOff=0;
}
else
{
FuncHeader& funcHeadPrev=m_pFuncTable->at(m_pFuncTable->size()-1);
funcHeader.DataOff=funcHeadPrev.DataOff+funcHeadPrev.DataSize;
}
//
记录大小
//
这种记算函数大小的方法并准确,这样做是默认这个pSymbol所在节从pSymbol->Value偏移处开始到
//
节结束都是pSymbol所对应的函数数据,但有可能此节还包括其他函数数据
//
拿节大小SizeOfRawData-函数在此节的偏移Value
funcHeader.DataSize=pISH->SizeOfRawData-pSymbol->Value;
//
标志重定位位置
MarkRelocatePos(pISH);
//
获取函数数据
PBYTE funData=m_pObjImage+pISH->PointerToRawData+pSymbol->Value;
//
写入dat文件
fwrite(funData,funcHeader.DataSize,1,m_pDatFile);
fflush(m_pDatFile);
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
//
标志重定位信息
void CObjParser::MarkRelocatePos(PIMAGE_SECTION_HEADER pISH)
{
//
用四个字节0标志重定位信息位置
DWORD pReloMark=0;
DWORD modifyOff=0;
//
获得重定位表
PIMAGE_RELOCATION pIR = (PIMAGE_RELOCATION)(m_pObjImage + pISH->PointerToRelocations);
//
重定位表大小
DWORD RefCount = pISH->NumberOfRelocations;
//
遍历重定位表
for
(DWORD i =0;i
{
//
待重定位偏移
modifyOff=pISH->PointerToRawData+pIR[i].VirtualAddress;
//
修订
memcpy_s(m_pObjImage+modifyOff,4,&pReloMark,4);
}
}
|
1
2
|
#define IMAGE_FLIB_START_SIZE 8
#define IMAGE_FLIB_START "!
|
1
2
3
4
5
6
|
typedef struct _FlibFuncHeader
//flib
文件中的函数头结构
{
DWORD NameOff;
//
函数名称的文件偏移
DWORD DataOff;
//
函数数据的文件偏移
DWORD DataSize;
//
函数数据的大小
}FlibFuncHeader,*PFlibFuncHeader;
|