/* restable.c - Decoding PE and NE resource tables
*
* Copyright (C) 1998 Oskar Liljeblad
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <config.h>
#include <inttypes.h> /* ? */
#include "gettext.h" /* Gnulib */
#define _(s) gettext(s)
#define N_(s) gettext_noop(s)
#include "common/intutil.h"
#include "xalloc.h" /* Gnulib */
#include "xvasprintf.h" /* Gnulib */
#include "minmax.h" /* Gnulib */
#include "common/error.h"
#include "wrestool.h"
#include "win32.h"
#include "fileread.h"
static bool decode_pe_resource_id (WinLibrary *, WinResource *, uint32_t);
static bool decode_ne_resource_id (WinLibrary *, WinResource *, uint16_t);
static WinResource *list_ne_type_resources (WinLibrary *, int *);
static WinResource *list_ne_name_resources (WinLibrary *, WinResource *, int *);
static WinResource *list_pe_resources (WinLibrary *, Win32ImageResourceDirectory *, int, int *);
static int calc_vma_size (WinLibrary *);
static void do_resources_recurs (WinLibrary *, WinResource *, WinResource *, WinResource *, WinResource *, const char *, const char *, const char *, DoResourceCallback);
static char *get_resource_id_quoted (WinResource *);
static WinResource *find_with_resource_array(WinLibrary *, WinResource *, const char *);
static WinResource *list_resources (WinLibrary *fi, WinResource *res, int *count);
static bool compare_resource_id (WinResource *wr, const char *id);
/* Check whether access to a PE_SECTIONS is allowed */
#define RETURN_IF_BAD_PE_SECTIONS(ret, module) \
do { \
void* pe_sec_; \
RETURN_IF_BAD_POINTER(ret, PE_HEADER(module)->optional_header); \
RETURN_IF_BAD_POINTER(ret, PE_HEADER(module)->file_header.number_of_sections); \
pe_sec_ = PE_SECTIONS(module); \
RETURN_IF_BAD_OFFSET(ret, pe_sec_, sizeof(Win32ImageSectionHeader) \
* PE_HEADER(module)->file_header.number_of_sections); \
} while(0)
/* do_resources:
* Do something for each resource matching type, name and lang.
*/
void
do_resources (WinLibrary *fi, const char *type, const char *name, const char *lang, DoResourceCallback cb)
{
WinResource *type_wr;
WinResource *name_wr;
WinResource *lang_wr;
type_wr = malloc(sizeof(WinResource)*3);
name_wr = type_wr + 1;
lang_wr = type_wr + 2;
memset(type_wr, 0, sizeof(WinResource)*3);
do_resources_recurs(fi, NULL, type_wr, name_wr, lang_wr, type, name, lang, cb);
free(type_wr);
}
/* what is each entry in this directory level for? type, name or language? */
#define WINRESOURCE_BY_LEVEL(x) ((x)==0 ? type_wr : ((x)==1 ? name_wr : lang_wr))
/* does the id of this entry match the specified id? */
#define LEVEL_MATCHES(x) (x == NULL || x ## _wr->id[0] == '\0' || compare_resource_id(x ## _wr, x))
static void
do_resources_recurs (WinLibrary *fi, WinResource *base, WinResource *type_wr,
WinResource *name_wr, WinResource *lang_wr,
const char *type, const char *name, const char *lang, DoResourceCallback cb)
{
int c, rescnt;
WinResource *wr;
/* get a list of all resources at this level */
wr = list_resources (fi, base, &rescnt);
if (wr == NULL)
return;
/* process each resource listed */
for (c = 0 ; c < rescnt ; c++) {
/* (over)write the corresponding WinResource holder with the current */
memcpy(WINRESOURCE_BY_LEVEL(wr[c].level), wr+c, sizeof(WinResource));
if ((base && (wr[c].level <= base->level))
|| (wr[c].level >= 3))
{
warn(_("%s: resource structure malformed"), fi->name);
return;
}
/* go deeper unless there is something that does NOT match */
if (LEVEL_MATCHES(type) && LEVEL_MATCHES(name) && LEVEL_MATCHES(lang)) {
if (wr->is_directory)
do_resources_recurs (fi, wr+c, type_wr, name_wr, lang_wr, type, name, lang, cb);
else
cb(fi, wr+c, type_wr, name_wr, lang_wr);
}
}
/* since we're moving back one level after this, unset the
* WinResource holder used on this level */
memset(WINRESOURCE_BY_LEVEL(wr[0].level), 0, sizeof(WinResource));
}
void
print_resources_callback (WinLibrary *fi, WinResource *wr,
WinResource *type_wr, WinResource *name_wr,
WinResource *lang_wr)
{
const char *type, *offset;
int32_t id;
size_t size;
char *type_quoted, *name_quoted, *lang_quoted;
/* get named resource type if possible */
type = NULL;
if (parse_int32(type_wr->id, &id))
type = res_type_id_to_string(id);
/* get offset and size info on resource */
offset = get_resource_entry(fi, wr, &size);
if (offset == NULL)
return;
type_quoted = get_resource_id_quoted(type_wr);
name_quoted = get_resource_id_quoted(name_wr);
lang_quoted = get_resource_id_quoted(lang_wr);
printf(_("--type=%s --name=%s%s%s [%s%s%soffset=0x%x size=%zu]\n"),
type_quoted,
name_quoted,
(lang_wr->id[0] != '\0' ? _(" --language=") : ""),
lang_quoted,
(type != NULL ? "type=" : ""),
(type != NULL ? type : ""),
(type != NULL ? " " : ""),
(uint32_t) (offset - fi->memory), size);
free(type_quoted);
free(name_quoted);
free(lang_quoted);
}
/* return the resource id quoted if it's a string, otherwise just return it */
static char *
get_resource_id_quoted (WinResource *wr)
{
if (wr->numeric_id || wr->id[0] == '\0')
return xstrdup(wr->id);
return xasprintf("'%s'", wr->id);
}
static bool
compare_resource_id (WinResource *wr, const char *id)
{
if (wr->numeric_id) {
int32_t cmp1, cmp2;
if (id[0] == '+')
return false;
if (id[0] == '-')
id++;
if (!parse_int32(wr->id, &cmp1) || !parse_int32(id, &cmp2) || cmp1 != cmp2)
return false;
} else {
if (id[0] == '-')
return false;
if (id[0] == '+')
id++;
if (strcmp(wr->id, id))
return false;
}
return true;
}
static bool
decode_pe_resource_id (WinLibrary *fi, WinResource *wr, uint32_t value)
{
if (value & IMAGE_RESOURCE_NAME_IS_STRING) { /* numeric id */
int c, len;
uint16_t *mem = (uint16_t *)
(fi->first_resource + (value & ~IMAGE_RESOURCE_NAME_IS_STRING));
/* copy each char of the string, and terminate it */
RETURN_IF_BAD_POINTER(false, *mem);
len = mem[0];
RETURN_IF_BAD_OFFSET(false, &mem[1], sizeof(uint16_t) * len);
len = MIN(mem[0], WINRES_ID_MAXLEN);
for (c = 0 ; c < len ; c++)
wr->id[c] = mem[c+1] & 0x00FF;
wr->id[len] = '\0';
} else { /* Unicode string id */
/* translate id into a string */
snprintf(wr->id, WINRES_ID_MAXLEN, "%" PRIu32, value);
}
wr->numeric_id = (value & IMAGE_RESOURCE_NAME_IS_STRING ? false:true);
return true;
}
void *
get_resource_entry (WinLibrary *fi, WinResource *wr, size_t *size)
{
if (fi->is_PE_binary) {
Win32ImageResourceDataEntry *dataent;
dataent = (Win32ImageResourceDataEntry *) wr->children;
RETURN_IF_BAD_POINTER(NULL, *dataent);
*size = dataent->size;
RETURN_IF_BAD_OFFSET(NULL, fi->memory + dataent->offset_to_data, *size);
return fi->memory + dataent->offset_to_data;
} else {
Win16NENameInfo *nameinfo;
int sizeshift;
nameinfo = (Win16NENameInfo *) wr->children;
sizeshift = *((uint16_t *) fi->first_resource - 1);
*size = nameinfo->length << sizeshift;
RETURN_IF_BAD_OFFSET(NULL, fi->memory + (nameinfo->offset << sizeshift), *size);
return fi->memory + (nameinfo->offset << sizeshift);
}
}
static bool
decode_ne_resource_id (WinLibrary *fi, WinResource *wr, uint16_t value)
{
if (value & NE_RESOURCE_NAME_IS_NUMERIC) { /* numeric id */
/* translate id into a string */
snprintf(wr->id, WINRES_ID_MAXLEN, "%d", value & ~NE_RESOURCE_NAME_IS_NUMERIC);
} else { /* ASCII string id */
unsigned char len;
char *mem = (char *) NE_HEADER(fi->memory)
+ NE_HEADER(fi->memory)->rsrctab
+ value;
/* copy each char of the string, and terminate it */
RETURN_IF_BAD_POINTER(false, *mem);
len = mem[0];
RETURN_IF_BAD_OFFSET(false, &mem[1], sizeof(char) * len);
memcpy(wr->id, &mem[1], len);
wr->id[len] = '\0';
}
wr->numeric_id = (value & NE_RESOURCE_NAME_IS_NUMERIC ? true:false);
return true;
}
static WinResource *
list_pe_resources (WinLibrary *fi, Win32ImageResourceDirectory *pe_res, int level, int *count)
{
WinResource *wr;
unsigned int out_c;
int dirent_c, rescnt;
Win32ImageResourceDirectoryEntry *dirent
= (Win32ImageResourceDirectoryEntry *) (pe_res + 1);
/* count number of `type' resources */
RETURN_IF_BAD_POINTER(NULL, *dirent);
rescnt = pe_res->number_of_named_entries + pe_res->number_of_id_entries;
*count = 0;
if (rescnt == 0) return NULL;
/* allocate WinResource's */
wr = xmalloc(sizeof(WinResource) * rescnt);
/* fill in the WinResource's */
out_c = 0;
for (dirent_c = 0 ; dirent_c < rescnt ; dirent_c++) {
RETURN_IF_BAD_POINTER(NULL, dirent[dirent_c]);
wr[out_c].this = pe_res;
wr[out_c].level = level;
wr[out_c].is_directory = (dirent[dirent_c].u2.s.data_is_directory);
/* Require data to point somewhere after the directory */
if (dirent[dirent_c].u2.s.offset_to_directory < sizeof(Win32ImageResourceDirectory))
continue;
wr[out_c].children = fi->first_resource + dirent[dirent_c].u2.s.offset_to_directory;
/* fill in wr->id, wr->numeric_id */
if (!decode_pe_resource_id (fi, wr + out_c, dirent[dirent_c].u1.name))
continue;
++out_c;
++(*count);
}
if (out_c == 0) {
free(wr);
return NULL;
}
return wr;
}
static WinResource *
list_ne_name_resources (WinLibrary *fi, WinResource *typeres, int *count)
{
int c, rescnt;
WinResource *wr;
Win16NETypeInfo *typeinfo = (Win16NETypeInfo *) typeres->this;
Win16NENameInfo *nameinfo = (Win16NENameInfo *) typeres->children;
/* count number of `type' resources */
RETURN_IF_BAD_POINTER(NULL, typeinfo->count);
*count = rescnt = typeinfo->count;
if (rescnt == 0) return NULL;
/* allocate WinResource's */
wr = xmalloc(sizeof(WinResource) * rescnt);
/* fill in the WinResource's */
for (c = 0 ; c < rescnt ; c++) {
RETURN_IF_BAD_POINTER(NULL, nameinfo[c]);
wr[c].this = nameinfo+c;
wr[c].is_directory = false;
wr[c].children = nameinfo+c;
wr[c].level = 1;
/* fill in wr->id, wr->numeric_id */
if (!decode_ne_resource_id (fi, wr + c, (nameinfo+c)->id)) {
free(wr);
return NULL;
}
}
return wr;
}
static WinResource *
list_ne_type_resources (WinLibrary *fi, int *count)
{
size_t c, rescnt;
WinResource *wr;
Win16NETypeInfo *typeinfo;
/* count number of `type' resources */
typeinfo = (Win16NETypeInfo *) fi->first_resource;
RETURN_IF_BAD_POINTER(NULL, *typeinfo);
for (rescnt = 0 ; typeinfo->type_id != 0 ; rescnt++) {
if (((char *) NE_TYPEINFO_NEXT(typeinfo))+sizeof(uint16_t) > fi->memory + fi->total_size) {
warn(_("%s: resource table invalid, ignoring remaining entries"), fi->name);
break;
}
typeinfo = NE_TYPEINFO_NEXT(typeinfo);
RETURN_IF_BAD_POINTER(NULL, *typeinfo);
}
*count = rescnt;
if (rescnt == 0) return NULL;
/* allocate WinResource's */
wr = xmalloc(sizeof(WinResource) * rescnt);
/* fill in the WinResource's */
typeinfo = (Win16NETypeInfo *) fi->first_resource;
for (c = 0 ; c < rescnt ; c++) {
wr[c].this = typeinfo;
wr[c].is_directory = (typeinfo->count != 0);
wr[c].children = typeinfo+1;
wr[c].level = 0;
/* fill in wr->id, wr->numeric_id */
if (!decode_ne_resource_id (fi, wr + c, typeinfo->type_id)) {
free(wr);
return NULL;
}
typeinfo = NE_TYPEINFO_NEXT(typeinfo);
}
return wr;
}
/* list_resources:
* Return an array of WinResource's in the current
* resource level specified by res.
*/
static WinResource *
list_resources (WinLibrary *fi, WinResource *res, int *count)
{
if (res != NULL && !res->is_directory)
return NULL;
if (fi->is_PE_binary) {
return list_pe_resources(fi, (Win32ImageResourceDirectory *)
(res == NULL ? fi->first_resource : res->children),
(res == NULL ? 0 : res->level+1),
count);
} else {
return (res == NULL
? list_ne_type_resources(fi, count)
: list_ne_name_resources(fi, res, count));
}
}
static Win32ImageDataDirectory *
get_data_directory_entry (WinLibrary *fi, unsigned int entry)
{
Win32ImageNTHeaders *pe_header;
pe_header = PE_HEADER(fi->memory);
RETURN_IF_BAD_POINTER(NULL, pe_header->optional_header.magic);
if (pe_header->optional_header.magic == OPTIONAL_MAGIC_PE32) {
Win32ImageOptionalHeader *optional_header = &(pe_header->optional_header);
RETURN_IF_BAD_POINTER(false, optional_header->data_directory[entry]);
return optional_header->data_directory + entry;
} else if (pe_header->optional_header.magic == OPTIONAL_MAGIC_PE32_64) {
Win32ImageOptionalHeader64 *optional_header =
(Win32ImageOptionalHeader64*)&(pe_header->optional_header);
RETURN_IF_BAD_POINTER(false, optional_header->data_directory[entry]);
return optional_header->data_directory + entry;
} else {
return NULL;
}
}
/* read_library:
*
* Read header and get resource directory offset in a Windows library
* (AKA module).
*/
bool
read_library (WinLibrary *fi)
{
/* check for DOS header signature `MZ' */
RETURN_IF_BAD_POINTER(false, MZ_HEADER(fi->memory)->magic);
if (MZ_HEADER(fi->memory)->magic == IMAGE_DOS_SIGNATURE) {
DOSImageHeader *mz_header = MZ_HEADER(fi->memory);
RETURN_IF_BAD_POINTER(false, mz_header->lfanew);
if (mz_header->lfanew < sizeof (DOSImageHeader)) {
warn(_("%s: not a PE or NE library"), fi->name);
return false;
}
/* falls through */
}
RETURN_IF_BAD_OFFSET(false, MZ_HEADER(fi->memory), sizeof(Win32ImageNTHeaders));
/* check for OS2 (Win16) header signature `NE' */
RETURN_IF_BAD_POINTER(false, NE_HEADER(fi->memory)->magic);
if (NE_HEADER(fi->memory)->magic == IMAGE_OS2_SIGNATURE) {
OS2ImageHeader *header = NE_HEADER(fi->memory);
uint16_t *alignshift;
RETURN_IF_BAD_POINTER(false, header->rsrctab);
RETURN_IF_BAD_POINTER(false, header->restab);
if (header->rsrctab >= header->restab) {
warn(_("%s: no resource directory found"), fi->name);
return false;
}
fi->is_PE_binary = false;
alignshift = (uint16_t *) ((uint8_t *) NE_HEADER(fi->memory) + header->rsrctab);
fi->first_resource = ((uint8_t *) alignshift) + sizeof(uint16_t);
RETURN_IF_BAD_POINTER(false, *(Win16NETypeInfo *) fi->first_resource);
return true;
}
/* check for NT header signature `PE' */
RETURN_IF_BAD_POINTER(false, PE_HEADER(fi->memory)->signature);
if (PE_HEADER(fi->memory)->signature == IMAGE_NT_SIGNATURE) {
Win32ImageSectionHeader *pe_sections;
Win32ImageDataDirectory *dir;
Win32ImageNTHeaders *pe_header;
int d;
/* allocate new memory */
fi->total_size = calc_vma_size(fi);
if (fi->total_size <= 0) {
/* calc_vma_size has reported error */
return false;
}
fi->memory = xrealloc(fi->memory, fi->total_size);
/* relocate memory, start from last section */
pe_header = PE_HEADER(fi->memory);
RETURN_IF_BAD_PE_SECTIONS(false, fi->memory);
pe_sections = PE_SECTIONS(fi->memory);
/* we don't need to do OFFSET checking for the sections.
* calc_vma_size has already done that */
for (d = pe_header->file_header.number_of_sections - 1; d >= 0 ; d--) {
Win32ImageSectionHeader *pe_sec = pe_sections + d;
if (pe_sec->characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
continue;
//if (pe_sec->virtual_address + pe_sec->size_of_raw_data > fi->total_size)
/* Protect against memory moves overwriting the section table */
if ((uint8_t*)(fi->memory + pe_sec->virtual_address)
< (uint8_t*)(pe_sections + pe_header->file_header.number_of_sections)) {
warn(_("%s: invalid sections layout"), fi->name);
return false;
}
RETURN_IF_BAD_OFFSET(0, fi->memory + pe_sec->virtual_address, pe_sec->size_of_raw_data);
RETURN_IF_BAD_OFFSET(0, fi->memory + pe_sec->pointer_to_raw_data, pe_sec->size_of_raw_data);
if (pe_sec->virtual_address != pe_sec->pointer_to_raw_data) {
memmove(fi->memory + pe_sec->virtual_address,
fi->memory + pe_sec->pointer_to_raw_data,
pe_sec->size_of_raw_data);
}
}
/* find resource directory */
dir = get_data_directory_entry (fi, IMAGE_DIRECTORY_ENTRY_RESOURCE);
if (dir == NULL) return false;
if (dir->size == 0) {
warn(_("%s: file contains no resources"), fi->name);
return false;
}
fi->first_resource = ((uint8_t *) fi->memory) + dir->virtual_address;
fi->is_PE_binary = true;
return true;
}
/* other (unknown) header signature was found */
warn(_("%s: not a PE or NE library"), fi->name);
return false;
}
/* calc_vma_size:
* Calculate the total amount of memory needed for a 32-bit Windows
* module. Returns -1 if file was too small.
*/
static int
calc_vma_size (WinLibrary *fi)
{
Win32ImageSectionHeader *seg;
size_t c, segcount, size;
size = 0;
RETURN_IF_BAD_POINTER(-1, PE_HEADER(fi->memory)->file_header.number_of_sections);
segcount = PE_HEADER(fi->memory)->file_header.number_of_sections;
/* If there are no segments, just process file like it is.
* This is (probably) not the right thing to do, but problems
* will be delt with later anyway.
*/
if (segcount == 0)
return fi->total_size;
RETURN_IF_BAD_PE_SECTIONS(-1, fi->memory);
seg = PE_SECTIONS(fi->memory);
RETURN_IF_BAD_POINTER(-1, *seg);
for (c = 0 ; c < segcount ; c++) {
RETURN_IF_BAD_POINTER(0, *seg);
size = MAX(size, seg->virtual_address + seg->size_of_raw_data);
/* I have no idea what misc.virtual_size is for... */
size = MAX(size, seg->virtual_address + seg->misc.virtual_size);
seg++;
}
return size;
}
static WinResource *
find_with_resource_array(WinLibrary *fi, WinResource *wr, const char *id)
{
int c, rescnt;
WinResource *return_wr;
wr = list_resources(fi, wr, &rescnt);
if (wr == NULL)
return NULL;
for (c = 0 ; c < rescnt ; c++) {
if (compare_resource_id (&wr[c], id)) {
/* duplicate WinResource and return it */
return_wr = xmalloc(sizeof(WinResource));
memcpy(return_wr, &wr[c], sizeof(WinResource));
/* free old WinResource */
free(wr);
return return_wr;
}
}
return NULL;
}
WinResource *
find_resource (WinLibrary *fi, const char *type, const char *name, const char *language, int *level)
{
WinResource *wr;
*level = 0;
if (type == NULL)
return NULL;
wr = find_with_resource_array(fi, NULL, type);
if (wr == NULL || !wr->is_directory)
return wr;
*level = 1;
if (name == NULL)
return wr;
wr = find_with_resource_array(fi, wr, name);
if (wr == NULL || !wr->is_directory)
return wr;
*level = 2;
if (language == NULL)
return wr;
wr = find_with_resource_array(fi, wr, language);
return wr;
}