BearParser
Portable Executable parsing library (from PE-bear)
Loading...
Searching...
No Matches
ResourceDirWrapper.cpp
Go to the documentation of this file.
2#include "pe/PEFile.h"
3
4#define MAX_ENTRIES (-1)
5#define MAX_DEPTH 5
6
7/*
8typedef struct _IMAGE_RESOURCE_DIRECTORY {
9 DWORD Characteristics;
10 DWORD TimeDateStamp;
11 WORD MajorVersion;
12 WORD MinorVersion;
13 WORD NumberOfNamedEntries;
14 WORD NumberOfIdEntries;
15 // IMAGE_RESOURCE_DIRECTORY_ENTRY DirectoryEntries[];
16} IMAGE_RESOURCE_DIRECTORY, *PIMAGE_RESOURCE_DIRECTORY;
17
18
19 // Each directory contains the 32-bit Name of the entry and an offset,
20 // relative to the beginning of the resource directory of the data associated
21 // with this directory entry. If the name of the entry is an actual text
22 // string instead of an integer Id, then the high order bit of the name field
23 // is set to one and the low order 31-bits are an offset, relative to the
24 // beginning of the resource directory of the string, which is of type
25 // IMAGE_RESOURCE_DIRECTORY_STRING. Otherwise the high bit is clear and the
26 // low-order 16-bits are the integer Id that identify this resource directory
27 // entry. If the directory entry is yet another resource directory (i.e. a
28 // subdirectory), then the high order bit of the offset field will be
29 // set to indicate this. Otherwise the high bit is clear and the offset
30 // field points to a resource data entry.
31
32#define RESOURCE_NAME_IS_STRING 0x80000000
33#define RESOURCE_DATA_IS_DIRECTORY 0x80000000
34
35
36typedef struct _IMAGE_RESOURCE_DIRECTORY_ENTRY {
37 union {
38 struct {
39 DWORD NameOffset:31;
40 DWORD NameIsString:1;
41 } name;
42 DWORD Name;
43 WORD Id;
44 };
45 union {
46 DWORD OffsetToData;
47 struct {
48 DWORD OffsetToDirectory:31;
49 DWORD DataIsDirectory:1;
50 } dir;
51 };
52} IMAGE_RESOURCE_DIRECTORY_ENTRY, *PIMAGE_RESOURCE_DIRECTORY_ENTRY;
53
54*/
55//-------------
56
57IMAGE_RESOURCE_DIRECTORY* ResourceDirWrapper::mainResourceDir()
58{
60
61 BYTE *ptr = m_Exe->getContentAt(rva, Executable::RVA, sizeof(IMAGE_RESOURCE_DIRECTORY));
62 return (IMAGE_RESOURCE_DIRECTORY*) ptr;
63}
64
65IMAGE_RESOURCE_DIRECTORY* ResourceDirWrapper::resourceDir()
66{
67 if (this->rawOff == 0) return mainResourceDir();
68
69 BYTE *ptr = m_Exe->getContentAt(this->rawOff, Executable::RAW, sizeof(IMAGE_RESOURCE_DIRECTORY));
70 return (IMAGE_RESOURCE_DIRECTORY*) ptr;
71}
72
74{
75 clear();
76 if (this->topEntryID == TOP_ENTRY_ROOT && this->album != NULL) {
77 this->album->clear();
78 }
79 IMAGE_RESOURCE_DIRECTORY* dir = resourceDir();
80 if (dir == NULL) return false;
81 if (this->root == this) {
82 // the top directory is the first one to be expanded (it is addressed by rawOff == 0)
83 this->expandedDirs.clear();
84 this->entriesLeft = static_cast<size_t>(m_Exe->getRawSize()) / sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
86 }
87 size_t namesNum = dir->NumberOfNamedEntries;
88 size_t idsNum = dir->NumberOfIdEntries;
89
90 size_t totalEntries = namesNum + idsNum;
91 for (size_t i = 0; i < totalEntries && i < MAX_ENTRIES; i++ ) {
92 if (!takeEntry()) break;
93
94 long topDirId = (this->topEntryID != TOP_ENTRY_ROOT) ? this->topEntryID : long(i) ;
95
96 //ResourceEntryWrapper(PEFile *pe, ResourceDirWrapper *parentDir, size_t entryNumber, long topEntryId, ResourcesAlbum *resAlbum)
97 ResourceEntryWrapper* entry = new ResourceEntryWrapper(this->m_PE, this, i, topDirId, this->album);
98
99 if (entry->getPtr() == NULL) {
100 delete entry;
101 break;
102 }
103 if (this->topEntryID == TOP_ENTRY_ROOT && this->album != NULL) {
104 pe::resource_type typeId = static_cast<pe::resource_type>(entry->getID());
105 this->album->mapIdToLeafType(i, typeId);
106 }
107 //this->parsedSize += val;
108 this->entries.push_back(entry);
109 }
110 //printf("Entries: %d\n", getEntriesCount());
111 return true;
112}
113
114
116{
117 if (getPtr() == NULL) return 0;
118 bufsize_t size = sizeof(IMAGE_RESOURCE_DIRECTORY);
119 size += getEntriesAreaSize();
120 return size;
121}
122
123void* ResourceDirWrapper::getFieldPtr(size_t fId, size_t subField)
124{
125 IMAGE_RESOURCE_DIRECTORY* d = resourceDir();
126 if (d == NULL) return NULL;
127
128 switch (fId) {
129 case CHARACTERISTIC: return &d->Characteristics;
130 case TIMESTAMP: return &d->TimeDateStamp;
131 case MAJOR_VER: return &d->MajorVersion;
132 case MINOR_VER: return &d->MinorVersion;
133 case NAMED_ENTRIES_NUM : return &d->NumberOfNamedEntries;
134 case ID_ENTRIES_NUM : return &d->NumberOfIdEntries;
135 }
136 return this->getPtr();
137}
138
139bufsize_t ResourceDirWrapper::getFieldSize(size_t fId, size_t subField)
140{
141 IMAGE_RESOURCE_DIRECTORY* d = resourceDir();
142 if (d == NULL) return 0;
143
144 // calculate size of the last field separately:
145 if (fId == ID_ENTRIES_NUM) {
146 void *nextPtr = (&d->NumberOfIdEntries) + 1;
147 void *argPtr = &d->NumberOfIdEntries;
148 return (BYTE*) nextPtr - (BYTE*)argPtr;
149 }
150 return DataDirEntryWrapper::getFieldSize(fId, subField);
151}
152
153QString ResourceDirWrapper::getFieldName(size_t fieldId)
154{
155 switch (fieldId) {
156 case CHARACTERISTIC: return "Characteristics";
157 case TIMESTAMP: {
158 PEFile* myPe = dynamic_cast<PEFile*>(this->m_Exe);
159 if (myPe && myPe->isReproBuild()) {
160 return "ReproChecksum";
161 }
162 return "TimeDateStamp";
163 }
164 case MAJOR_VER: return "MajorVersion";
165 case MINOR_VER: return "MinorVersion";
166 case NAMED_ENTRIES_NUM : return "NumberOfNamedEntries";
167 case ID_ENTRIES_NUM : return "NumberOfIdEntries";
168 }
169 return getName();
170}
171
172//-----------------------------------------------------------------
173
175{
176 delete childDir;
177 this->childDir = NULL;
178 //---
179 delete childLeaf;
180 this->childLeaf = NULL;
181}
182
184{
185 clear();
186 //---
187 offset_t childRaw = getChildAddress();
188 if (childRaw == 0 || childRaw == INVALID_ADDR) return false;
189
190 if (this->isDir()) {
191 long depth = this->parentDir->getDepth() + 1;
192 if (depth >= MAX_DEPTH) return false;
193 // A malformed file may make directories point back at themselves (or at the top directory),
194 // or make many entries point at the same child. Expand every directory only once;
195 // otherwise the tree grows exponentially with the depth.
196 if (!this->parentDir->markExpanded(childRaw)) return false;
197 this->childDir = new ResourceDirWrapper(this->m_PE, this->album, childRaw, depth, topEntryID, this->parentDir->getRoot());
198 } else {
199 this->childLeaf = new ResourceLeafWrapper(m_Exe, childRaw, topEntryID);
200 if (this->album != NULL) {
201 album->putLeaf(childLeaf, topEntryID);
202 }
203 }
204 return true;
205}
206
207
208IMAGE_RESOURCE_DIRECTORY_ENTRY* ResourceEntryWrapper::getEntryPtr()
209{
210 if (this->parentDir == NULL) return NULL;
211 uint64_t offset = parentDir->getFieldOffset(ResourceDirWrapper::ID_ENTRIES_NUM);
212 if (offset == INVALID_ADDR) return NULL;
213
214 size_t lastSize = parentDir->getFieldSize(ResourceDirWrapper::ID_ENTRIES_NUM, FIELD_NONE);
215 offset += lastSize;
216 offset += (this->entryNum * sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
217
218 void *ptr = m_Exe->getContentAt(offset, Executable::RAW, sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
219 return (IMAGE_RESOURCE_DIRECTORY_ENTRY*) ptr;
220}
221
222//IMAGE_RESOURCE_DIRECTORY_ENTRY
223void* ResourceEntryWrapper::getFieldPtr(size_t fieldId, size_t subField)
224{
225 IMAGE_RESOURCE_DIRECTORY_ENTRY* entry = getEntryPtr();
226 if (entry == NULL) return NULL;
227
228 switch (fieldId) {
229 case NAME_ID_ADDR:
230 return &entry->Name;
231 case OFFSET_TO_DATA:
232 return &entry->OffsetToData;
233 }
234 return getPtr();
235}
236
238{
239 switch (fieldId) {
240 case NAME_ID_ADDR:
241 return(isByName()) ? "Name": "ID";
242 case OFFSET_TO_DATA:
243 return "Offset To Data";
244 }
245 return getName();
246}
247
249{
250 IMAGE_RESOURCE_DIRECTORY_ENTRY* entry = getEntryPtr();
251 if (entry == NULL) return false;
252 if (entry->NameIsString == 1) return true;
253 return false;
254}
255
257{
258 IMAGE_RESOURCE_DIRECTORY_ENTRY* entry = getEntryPtr();
259 if (entry == NULL) return false;
260 if (entry->DataIsDirectory == 1) return true;
261 return false;
262}
263
265{
266 IMAGE_RESOURCE_DIRECTORY_ENTRY* entry = getEntryPtr();
267 if (entry == NULL) return INVALID_ADDR;
268
269 if (this->parentDir == NULL) return INVALID_ADDR;
270 offset_t fOff = this->parentDir->getOffset(this->parentDir->getPtr());
271 if (fOff == INVALID_ADDR) return INVALID_ADDR;
272
273 if (entry->NameIsString != 1) return INVALID_ADDR;
274 return fOff + entry->NameOffset;
275}
276
277IMAGE_RESOURCE_DIRECTORY_STRING* ResourceEntryWrapper::getNameStr()
278{
279 offset_t nameOff = getNameOffset();
280 if (nameOff == INVALID_ADDR) return NULL;
281
282 const size_t BASIC_SIZE = sizeof(IMAGE_RESOURCE_DIRECTORY_STRING);
283 IMAGE_RESOURCE_DIRECTORY_STRING *ptr = (IMAGE_RESOURCE_DIRECTORY_STRING*) this->m_Exe->getContentAt(nameOff, Executable::RAW, BASIC_SIZE);
284 return ptr;
285}
286
288{
289 switch (id) {
290 case pe::RESTYPE_CURSOR : return "Cursor";
291 case pe::RESTYPE_FONT :return "Font";
292 case pe::RESTYPE_BITMAP : return "Bitmap";
293 case pe::RESTYPE_ICON : return "Icon";
294 case pe::RESTYPE_MENU : return "Menu";
295 case pe::RESTYPE_DIALOG : return "Dialog";
296 case pe::RESTYPE_STRING : return "String";
297 case pe::RESTYPE_FONTDIR : return "Font Dir";
298 case pe::RESTYPE_ACCELERATOR : return "Accelerator";
299 case pe::RESTYPE_RCDATA : return "RC Data";
300 case pe::RESTYPE_MESSAGETABLE : return "Message Table";
301
302 case pe::RESTYPE_GROUP_CURSOR : return "Cursors Group";
303 case pe::RESTYPE_GROUP_ICON : return "Icons Group";
304 case pe::RESTYPE_VERSION : return "Version";
305 case pe::RESTYPE_DLGINCLUDE : return "Dlg Include";
306 case pe::RESTYPE_PLUGPLAY : return "Plug & Play";
307 case pe::RESTYPE_VXD : return "VXD";
308 case pe::RESTYPE_ANICURSOR : return "Animated Cursor";
309 case pe::RESTYPE_ANIICON : return "Animated Icon";
310 case pe::RESTYPE_HTML : return "HTML";
311 case pe::RESTYPE_MANIFEST : return "Manifest";
312 }
313 return "";
314}
315
317{
318 IMAGE_RESOURCE_DIRECTORY_ENTRY* entry = getEntryPtr();
319 if (entry == NULL) return 0;
320 if (this->isByName()) return 0;
321
322 return entry->Id;
323}
324
326{
327 const IMAGE_RESOURCE_DIRECTORY_ENTRY* entry = getEntryPtr();
328 if (!entry) {
329 return INVALID_ADDR;
330 }
331 if (entry->DataIsDirectory) {
332 return entry->OffsetToDirectory;
333 }
334 return entry->OffsetToData;
335}
336
338{
339 if (!this->parentDir) return INVALID_ADDR;
340
341 const offset_t fOff = this->parentDir->getOffset(this->parentDir->mainResourceDir());
342 if (fOff == INVALID_ADDR) return INVALID_ADDR;
343
344 const offset_t childOff = getChildOffsetToDirectory();
345 if (childOff == INVALID_ADDR) return INVALID_ADDR;
346
347 return fOff + childOff;
348}
349
350//-------------------------------------------------------------------------
351
352IMAGE_RESOURCE_DATA_ENTRY* ResourceLeafWrapper::leafEntryPtr()
353{
354 if (this->offset == 0 || this->offset == INVALID_ADDR) return NULL;
355
356 IMAGE_RESOURCE_DATA_ENTRY* leaf = (IMAGE_RESOURCE_DATA_ENTRY*) this->m_Exe->getContentAt(this->offset, Executable::RAW, sizeof(IMAGE_RESOURCE_DATA_ENTRY));
357 return leaf;
358}
359
360void* ResourceLeafWrapper::getFieldPtr(size_t fieldId, size_t subField)
361{
362 IMAGE_RESOURCE_DATA_ENTRY* leaf = leafEntryPtr();
363 if (!leaf) return NULL;
364
365 switch (fieldId) {
366 case OFFSET_TO_DATA: return &leaf->OffsetToData;
367 case DATA_SIZE: return &leaf->Size;
368 case CODE_PAGE: return &leaf->CodePage;
369 case RESERVED: return &leaf->Reserved;
370 }
371 return NULL;
372}
373
375{
376 switch (fieldId) {
377 case OFFSET_TO_DATA: return "OffsetToData";
378 case DATA_SIZE: return "DataSize";
379 case CODE_PAGE: return "CodePage";
380 case RESERVED: return "Reserved";
381 }
382 return "";
383}
384
385
const offset_t INVALID_ADDR
uint64_t offset_t
size_t bufsize_t
#define FIELD_NONE
#define MAX_DEPTH
#define MAX_ENTRIES
#define TOP_ENTRY_ROOT
friend class PEFile
offset_t getDirEntryAddress()
virtual bufsize_t getFieldSize(size_t fieldId, size_t subField=FIELD_NONE)
virtual offset_t getOffset()
std::vector< ExeNodeWrapper * > entries
virtual void clear()
BYTE * getContentAt(offset_t offset, bufsize_t size, bool allowExceptions=false)
Definition Executable.h:67
virtual offset_t getRawSize() const
Definition Executable.h:64
bool isReproBuild()
Definition PEFile.h:360
virtual bufsize_t getSize()
virtual QString getFieldName(size_t fieldId)
virtual void * getFieldPtr(size_t fieldId, size_t subField)
bool markExpanded(offset_t dirRawOffset)
virtual void * getPtr()
IMAGE_RESOURCE_DIRECTORY * mainResourceDir()
virtual bufsize_t getFieldSize(size_t fieldId, size_t subField)
virtual QString getName()
bufsize_t getEntriesAreaSize()
ResourceDirWrapper(PEFile *pe, ResourcesAlbum *resAlbum=NULL, offset_t rawOffset=0, long depth=0, long topEntryId=TOP_ENTRY_ROOT, ResourceDirWrapper *rootDir=NULL)
WORD getID()
virtual QString getFieldName(size_t fieldId)
offset_t getChildAddress()
IMAGE_RESOURCE_DIRECTORY_ENTRY * getEntryPtr()
offset_t getNameOffset()
virtual void clear()
bool isDir()
static QString translateType(WORD id)
bool isByName()
virtual QString getName()
bool wrap()
IMAGE_RESOURCE_DIRECTORY_STRING * getNameStr()
ResourceEntryWrapper(PEFile *pe, ResourceDirWrapper *parentDir, size_t entryNumber, long topEntryId, ResourcesAlbum *resAlbum)
offset_t getChildOffsetToDirectory()
@ NAME_ID_ADDR
@ OFFSET_TO_DATA
virtual void * getPtr()
virtual void * getFieldPtr(size_t fieldId, size_t subField=FIELD_NONE)
IMAGE_RESOURCE_DATA_ENTRY * leafEntryPtr()
virtual void * getFieldPtr(size_t fieldId, size_t subField)
virtual QString getFieldName(size_t fieldId)
ResourceLeafWrapper(Executable *pe, offset_t rawOffset, long topEntryId)