/* *	HT Editor *	htpeil.cc * *	Copyright (C) 1999-2002 Stefan Weyergraf * *	This program is free software; you can redistribute it and/or modify *	it under the terms of the GNU General Public License version 2 as *	published by the Free Software Foundation. * *	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, write to the Free Software *	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */#include "formats.h"#include "htapp.h"#include "atom.h"#include "htcoff.h"#include "htctrl.h"#include "endianess.h"#include "hthex.h"#include "htiobox.h"#include "htnewexe.h"#include "htpe.h"#include "htpehead.h"#include "htpeil.h"#include "httag.h"#include "strtools.h"#include "snprintf.h"#include "pestruct.h"#include "ilopc.h"#include "ilstruct.h"#include <string.h>static ht_mask_ptable il_directory[] = {	{"size",           STATICTAG_EDIT_DWORD_LE("00000000")},	{"major version",  STATICTAG_EDIT_WORD_LE("00000004")},	{"minor version",  STATICTAG_EDIT_WORD_LE("00000006")},	{"metadata rva",   STATICTAG_EDIT_DWORD_LE("00000008")},	{"metadata size",  STATICTAG_EDIT_DWORD_LE("0000000c")},	{"attributes",     STATICTAG_EDIT_DWORD_LE("00000010")},	{"entrypoint token",STATICTAG_EDIT_DWORD_LE("00000014")},	{"resources rva",   STATICTAG_EDIT_DWORD_LE("00000018")},	{"resources size",  STATICTAG_EDIT_DWORD_LE("0000001c")},	{"strong name sig",  STATICTAG_EDIT_DWORD_LE("00000020")},	{"strong name sig",  STATICTAG_EDIT_DWORD_LE("00000024")},	{"code manager rva",   STATICTAG_EDIT_DWORD_LE("00000028")},	{"code manager size",  STATICTAG_EDIT_DWORD_LE("0000002c")},	{"vtable fixups rva",   STATICTAG_EDIT_DWORD_LE("00000030")},	{"vtable fixups size",   STATICTAG_EDIT_DWORD_LE("00000034")},	{"export address table",  STATICTAG_EDIT_DWORD_LE("00000038")},	{"export address table",  STATICTAG_EDIT_DWORD_LE("0000003c")},	{"managed native header", STATICTAG_EDIT_DWORD_LE("00000040")},	{0, 0}};static ht_mask_ptable metadata_section[] = {	{"magic",                 STATICTAG_EDIT_DWORD_LE("00000000")},	{"major_version",         STATICTAG_EDIT_WORD_LE("00000004")},	{"minor_version",         STATICTAG_EDIT_WORD_LE("00000006")},	{"unknown",               STATICTAG_EDIT_DWORD_LE("00000008")},	{"version_string_length", STATICTAG_EDIT_DWORD_LE("00000010")},	{0, 0}};static ht_view *htpeil_init(Bounds *b, File *file, ht_format_group *group){	ht_pe_shared_data *pe_shared=(ht_pe_shared_data *)group->get_shared_data();	if (pe_shared->opt_magic!=COFF_OPTMAGIC_PE32) return NULL;	uint32 sec_rva, sec_size;	FileOfs sec_ofs;	sec_rva = pe_shared->pe32.header_nt.directory[PE_DIRECTORY_ENTRY_IL].address;	sec_size = pe_shared->pe32.header_nt.directory[PE_DIRECTORY_ENTRY_IL].size;	if (!sec_rva || !sec_size) return NULL;	PE_IL_DIRECTORY dir;	bool pe_bigendian = false;	ht_pe_il_viewer *v;	if (!pe_rva_to_ofs(&pe_shared->sections, sec_rva, &sec_ofs)) goto read_error;			file->seek(sec_ofs);	if (file->read(&dir, sizeof dir) != sizeof dir) goto read_error;	createHostStruct(&dir, PE_IL_DIRECTORY_struct, little_endian);		if (sec_size != dir.size) goto read_error;		pe_shared->il = new ht_pe_il();	pe_shared->il->dir = dir;	v = new ht_pe_il_viewer();	v->init(b, DESC_PE_IL, VC_EDIT | VC_SEARCH, file, group);	pe_shared->v_il = v;	ht_mask_sub *s;//	ht_collapsable_sub *cs;		s = new ht_mask_sub();	s->init(file, 0);	char info[128];	ht_snprintf(info, sizeof info, "* COM+ directory at offset %08qx", sec_ofs);	s->add_mask(info);	v->insertsub(s);	/* FIXME: */		s=new ht_mask_sub();	s->init(file, 1);	s->add_staticmask_ptable(il_directory, sec_ofs, pe_bigendian);	v->insertsub(s);		FileOfs metadata_ofs;	if (pe_rva_to_ofs(&pe_shared->sections, dir.metadata_section_rva, &metadata_ofs)) {		/* read metadata section*/		IL_METADATA_SECTION metadata;		file->seek(metadata_ofs);		if (file->read(&metadata, sizeof metadata) == sizeof metadata) {			createHostStruct(&metadata, IL_METADATA_SECTION_struct, little_endian);			pe_shared->il->metadata = metadata;			uint32 add = 2;			if (metadata.minor_version == 1) {				// FIXME: align metadata.version_string_length				uint32 version_string_length;				file->read(&version_string_length, 4); // dummy				file->read(&version_string_length, 4);				version_string_length = createHostInt(&version_string_length, 4, little_endian);				add += version_string_length + 8;			}			FileOfs ofs = metadata_ofs + sizeof metadata + add;			file->seek(ofs);			uint16 count;			file->read(&count, 2);			count = createHostInt(&count, 2, little_endian);			pe_shared->il->entries = new Array(true);			for (uint i=0; i < count; i++) {				IL_METADATA_SECTION_ENTRY sec_entry;				ht_il_metadata_entry *entry;				// FIXME: error handling				file->read(&sec_entry, sizeof sec_entry);				createHostStruct(&sec_entry, IL_METADATA_SECTION_ENTRY_struct, little_endian);				String name("?");				file->readStringz(name);				int nlen = name.length() + 1;				uint32 dummy;				if (nlen % 4) {					// align properly					file->read(&dummy, 4 - nlen % 4);				}				entry = new ht_il_metadata_entry(name.contentChar(), metadata_ofs+sec_entry.offset, sec_entry.size);//				fprintf(stderr, "%s %x %x\n", name.contentChar(), metadata_ofs+sec_entry.offset, sec_entry.size);				pe_shared->il->entries->insert(entry);			}			for (uint i=0; i<count; i++) {				ht_il_metadata_entry *entry = (ht_il_metadata_entry *)(*pe_shared->il->entries)[i];				if (strcmp(entry->name, "#~") == 0) {					// token index					char dummy[8];					uint64 types;					file->seek(entry->offset);					file->read(&dummy, 8);					file->read(&types, 8);//					file->read();				} else if (strcmp(entry->name, "#US")==0) {					// stringpool					pe_shared->il->string_pool = ht_malloc(entry->size);					file->seek(entry->offset);					pe_shared->il->string_pool_size = file->read(pe_shared->il->string_pool, entry->size);				}			}		}			}		return v;read_error:	return NULL;}format_viewer_if htpeil_if = {	htpeil_init,	0};/* *	CLASS ht_pe_header_viewer */void ht_pe_il_viewer::init(Bounds *b, const char *desc, int caps, File *file, ht_format_group *group){	ht_uformat_viewer::init(b, desc, caps, file, group);	VIEW_DEBUG_NAME("ht_pe_il_viewer");}void ht_pe_il_viewer::done(){	ht_pe_shared_data *pe_shared=(ht_pe_shared_data *)format_group->get_shared_data();	if (pe_shared && pe_shared->il) {		free(pe_shared->il->string_pool);		delete pe_shared->il->entries;		delete pe_shared->il;	}	ht_uformat_viewer::done();}ht_il_metadata_entry::ht_il_metadata_entry(const char *n, uint32 o, uint32 s){	name = ht_strdup(n);	offset = o;	size = s;}ht_il_metadata_entry::~ht_il_metadata_entry(){	free(name);}/* *	NOTE: ILunpack returns result in host-endianess */int ILunpackDword(uint32 &result, const byte *buf, int len){	if (len) {		result = *(buf++);		len--;		if (result < 0x80) return 1; // one byte form		if (!len) return 0;		if ((result & 0xc0) == 0x80) {			// two byte form			result = ((result & 0x3f) << 8) | buf[0];			return 2;		} else if ((result & 0xe0) == 0xc0) {			// four byte form			if (len < 2) return 0;			result = ((result & 0x1F) << 24) |				    (((uint32)buf[0]) << 16) |				    (((uint32)buf[1]) << 8) |					 (uint32)buf[2];			return 4;		} else if ((result & 0xf0) == 0xe0) {			// five byte form			if (len < 3) return 0;			result = (((uint32)buf[0]) << 24) |				    (((uint32)buf[1]) << 16) |				    (((uint32)buf[2]) << 8) |					 (uint32)buf[3];			return 5;		}	}	return 0;}int ILunpackToken(uint32 &result, const byte *buf, int len){	int read = ILunpackDword(result, buf, len);	if (!read) return 0;	uint32 type;	switch (result & 0x03) {		case 0x00:			type = IL_META_TOKEN_TYPE_DEF;			break;		case 0x01:			type = IL_META_TOKEN_TYPE_REF;			break;		case 0x02:			type = IL_META_TOKEN_TYPE_SPEC;			break;		default:			type = IL_META_TOKEN_BASE_TYPE;	}	result = (result >> 2) | type;	return read;}