Repository navigation
Expand file tree
/
Copy pathpe_parser.cpp
More file actions
250 lines (230 loc) · 8.67 KB
/
Copy pathpe_parser.cpp
File metadata and controls
250 lines (230 loc) · 8.67 KB
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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
#include <Windows.h>
#include <stdio.h>
#define NON_EXECUTABLE_IMAGE "Non-executable or corrupted image"
#define NT_SIGNATURE_NOT_FOUND "NT_SIGNATURE not found"
#define DOS_SIGNATURE_NOT_FOUND "DOS_SIGNATURE not found"
#define BUFFER_OVERFLOW "Buffer overflow"
#define INVALID_ENTRY_POINT "Invalid entry point"
#define INVALID_DOS_HEADER "Invalid DOS header"
#define UNUSUAL_ENTRY_POINT_LOCATION "Unusual entry point location"
struct OPT_HEADER_INFO {
IMAGE_SECTION_HEADER* sec_header;
DWORD imageBase;
DWORD entryPoint;
};
#define BUFFER_SIZE 0x1000
#define CYRILLIC_CODE_PAGE 1251
HANDLE GetFileFromArguments( int argc, char** argv );
unsigned int ReadFileToBuffer( HANDLE fileHandle, char buffer[ BUFFER_SIZE ] );
void PrintHelp( char* programName );
void PrintError( char* functionFrom );
void PrintErrorAdv(const char* functionFrom, const char* error);
void PrintInfo(IMAGE_SECTION_HEADER* sec_header,
int sectionIndex,
DWORD imageBase,
DWORD entryPoint);
int GetInfoFromNTHeader(IMAGE_NT_HEADERS* pe_header, OPT_HEADER_INFO* opt_header_info);
void FindSectionWithEP(char* buffer, int bufferSize);
void ParseFile( char* buffer, int bufferSize );
int main( int argc, char** argv )
{
UINT codePage = GetConsoleOutputCP( );
SetConsoleOutputCP( CYRILLIC_CODE_PAGE ); // set code page to display russian symbols
HANDLE fileHandle = GetFileFromArguments( argc, argv );
if( NULL != fileHandle )
{
char buffer[ BUFFER_SIZE ];
int readSize = ReadFileToBuffer( fileHandle, buffer );
CloseHandle( fileHandle );
if( 0x00 != readSize )
{
ParseFile( buffer, readSize );
}
}
SetConsoleOutputCP( codePage ); // restore code page
return 0x00;
}
HANDLE GetFileFromArguments( int argc, char** argv )
{
HANDLE fileHandle = NULL;
if( 0x02 == argc )
{
fileHandle = CreateFileA( argv[ 0x01 ], GENERIC_READ, NULL, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
if( INVALID_HANDLE_VALUE == fileHandle )
{
PrintError( "CreateFileA" );
}
}
else
{
PrintHelp( argv[ 0x00 ] );
}
return fileHandle;
}
unsigned int ReadFileToBuffer( HANDLE fileHandle, char buffer[ BUFFER_SIZE ] )
{
unsigned int returnValue = 0x00;
if( NULL != fileHandle )
{
unsigned int fileSize = GetFileSize( fileHandle, NULL );
if( INVALID_FILE_SIZE == fileSize )
{
PrintError( "GetFileSize" );
}
else
{
unsigned long bytesRead;
fileSize = min( fileSize, BUFFER_SIZE );
if( true == ReadFile( fileHandle, buffer, fileSize, &bytesRead, NULL ) )
{
returnValue = bytesRead;
}
else
{
PrintError( "ReadFile" );
}
}
}
return returnValue;
}
int GetInfoFromNTHeader(
IMAGE_NT_HEADERS* pe_header,
OPT_HEADER_INFO* opt_header_info) {
if (IMAGE_NT_OPTIONAL_HDR32_MAGIC == pe_header->OptionalHeader.Magic) {
IMAGE_OPTIONAL_HEADER32* opt_header
= (IMAGE_OPTIONAL_HEADER32*)&pe_header->OptionalHeader;
opt_header_info->sec_header = IMAGE_FIRST_SECTION(pe_header);
opt_header_info->imageBase = opt_header->ImageBase;
opt_header_info->entryPoint = opt_header->AddressOfEntryPoint;
} else if (IMAGE_NT_OPTIONAL_HDR64_MAGIC == pe_header->OptionalHeader.Magic) {
IMAGE_OPTIONAL_HEADER64* opt_header
= (IMAGE_OPTIONAL_HEADER64*)&pe_header->OptionalHeader;
opt_header_info->sec_header = IMAGE_FIRST_SECTION(pe_header);
opt_header_info->imageBase = opt_header->ImageBase;
opt_header_info->entryPoint = opt_header->AddressOfEntryPoint;
} else {
PrintErrorAdv(__func__, NON_EXECUTABLE_IMAGE);
return -1;
}
return 0;
}
void FindSectionWithEP(char* buffer, int bufferSize) {
IMAGE_DOS_HEADER* dos_header = (IMAGE_DOS_HEADER*)buffer;
IMAGE_NT_HEADERS* pe_header
= (IMAGE_NT_HEADERS*)(buffer + dos_header->e_lfanew);
IMAGE_FILE_HEADER* file_header = &pe_header->FileHeader;
WORD numberOfSections = file_header->NumberOfSections;
OPT_HEADER_INFO opt_header_info;
if (NO_ERROR == GetInfoFromNTHeader(pe_header, &opt_header_info)) {
DWORD sectionsOffset = dos_header->e_lfanew
+ FIELD_OFFSET(IMAGE_NT_HEADERS, OptionalHeader)
+ file_header->SizeOfOptionalHeader;
IMAGE_SECTION_HEADER* sec_header = opt_header_info.sec_header;
DWORD imageBase = opt_header_info.imageBase;
DWORD entryPoint = opt_header_info.entryPoint;
if (sectionsOffset + sizeof(*sec_header) * numberOfSections <= bufferSize) {
WORD i;
int success = 0;
for (i = 0; i < numberOfSections; ++i, ++sec_header) {
if (sec_header->VirtualAddress <= entryPoint
&& entryPoint < sec_header->VirtualAddress
+ sec_header->Misc.VirtualSize) {
if (sec_header->SizeOfRawData > 0) {
PrintInfo(sec_header, i, imageBase, entryPoint);
success = 1;
} else {
PrintErrorAdv(__func__, UNUSUAL_ENTRY_POINT_LOCATION);
}
break;
}
}
if (!success) {
PrintErrorAdv(__func__, INVALID_ENTRY_POINT);
}
} else {
PrintErrorAdv(__func__, BUFFER_OVERFLOW);
}
}
return;
}
void ParseFile( char* buffer, int bufferSize )
{
// TODO: Íåîáõîäèìî âûïîëíèòü ðàçáîð ôàéëà è íàïèñàòü â êàêîé ñåêöèè ðàñïîëàãàåòñÿ òî÷êà âõîäà.
// Âûâîä äîëæåí áûòü â ñëåäóþùåì ôîðìàòå
// ## Entry point (<çíà÷åíèå òî÷êè âõîäà>)
// ## In section <èíäåêñ ñåêöèè>, <íàçâàíèå ñåêöèè>
// ## Offset in section <ñìåùåíèå îòíîñèòåëüíî íà÷àëà ñåêöèè>, <ñìåùåíèå â ïðîöåíòàõ> %
//
// Ãäå ñìåùåíèå â ïðîöåíòàõ âû÷èñëÿåòñÿ îòíîñèòåëüíî ðàçìåðà ñåêöèè. Íàïðèìåð, åñëè ñåêöèÿ èìååò
// ðàçìåð 1000, à òî÷êà âõîäà ðàñïîëàãàåòñÿ ïî ñìåùåíèþ 400 â íåé, òî íåîáõîäèìî âûâåñòè 40 %.
//
// Âñå èñïîëüçóåìûå ñòðóêòóðû ìîæíî ïîñìîòðåòü â çàãîëîâî÷íîì ôàéëå WinNT.h (îí óæå ïîäêëþ÷åí, òàê
// êàê óêàçàí â Windows.h). Íàïðèìåð âàì ìîãóò ïîòðåáîâàòüñÿ ñëåäóþùèå ñòðóêòóðû:
//IMAGE_DOS_HEADER çàãîëîâîê, êîòîðûé èñïîëüçóåòñÿ â ñèñòåìå DOS (ñåé÷àñ âàì â íåì ïîòðåáóåòñÿ òîëüêî ïîëå e_lfanew (÷òî îíî îçíà÷àåò?)
//IMAGE_NT_HEADERS çàãîëîâîê íîâîãî ôîðìàòà èñïîëíÿåìîãî ôàéëà (PE), èñïîëüçóåìîãî â Windows NT
//IMAGE_FILE_HEADER îäèí èç äâóõ çàãîëîâêîâ, èç êîòîðûõ ñîñòîèò IMAGE_NT_HEADER, ñîäåðæèò NumberOfSections
//IMAGE_OPTIONAL_HEADER âòîðîé çàãîëîâîê IMAGE_NT_HEADER, ñîäåðæèò âàæíûå äëÿ íàñ ïîëÿ ImageBase è AddressOfEntryPoint
//IMAGE_SECTION_HEADER çàãîëîâîê ñåêöèè, â íåì ñîäåðæèòñÿ íàçâàíèå, ðàçìåð è ðàñïîëîæåíèå ñåêöèè
//
// Íå çàáûâàéòå ïðîâåðÿòü òàêèå ïîëÿ êàê ñèãíàòóðû ôàéëîâ (âåäü íàäî óáåäèòüñÿ, ÷òî ðàçáèðàåì ñîáñòâåííî èñïîëíÿåìûé ôàéë)
//printf( "Buffer length: %d\nImplement parsing of file\n", bufferSize );
IMAGE_DOS_HEADER* dos_header = NULL;
if (sizeof(*dos_header) <= bufferSize) {
dos_header = (IMAGE_DOS_HEADER*)buffer;
if (IMAGE_DOS_SIGNATURE == dos_header->e_magic) {
IMAGE_NT_HEADERS* pe_header = NULL;
if ((DWORD)dos_header->e_lfanew + sizeof(*pe_header) <= bufferSize) {
pe_header = (IMAGE_NT_HEADERS*)(buffer + dos_header->e_lfanew);
if (IMAGE_NT_SIGNATURE == pe_header->Signature) {
FindSectionWithEP(buffer, bufferSize);
} else {
PrintErrorAdv(__func__, NT_SIGNATURE_NOT_FOUND);
}
} else {
PrintErrorAdv(__func__, INVALID_DOS_HEADER);
}
} else {
PrintErrorAdv(__func__, DOS_SIGNATURE_NOT_FOUND);
}
} else {
PrintErrorAdv(__func__, INVALID_DOS_HEADER);
}
return;
}
#pragma region __ Print functions __
void PrintHelp( char* programName )
{
printf( "Usage:\n%s <filename>", programName );
}
void PrintError( char* functionFrom )
{
char* errorMessage;
DWORD errorCode = GetLastError( );
// Retrieve the system error message for the last-error code
FormatMessageA( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
errorCode,
MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),
( LPTSTR ) &errorMessage,
0, NULL );
printf( "In function %s, error %d:\n%s", functionFrom, errorCode, errorMessage );
LocalFree( errorMessage );
}
void PrintErrorAdv(const char* functionFrom, const char* error) {
printf("%s: %s\n", functionFrom, error);
return;
}
void PrintInfo(IMAGE_SECTION_HEADER* sec_header,
int sectionIndex,
DWORD imageBase,
DWORD entryPoint) {
char sectionName[IMAGE_SIZEOF_SHORT_NAME + 1];
sectionName[IMAGE_SIZEOF_SHORT_NAME] = '\0';
memcpy(sectionName, sec_header->Name, IMAGE_SIZEOF_SHORT_NAME);
printf("Entry point (0x%X)\nIn section %d, %s\n\
Offset in section 0x%X, %d %%\n", imageBase + entryPoint, sectionIndex,
sectionName, entryPoint - sec_header->VirtualAddress,
((entryPoint - sec_header->VirtualAddress) * 100)
/ sec_header->Misc.VirtualSize);
}
#pragma endregion