@isopodlabs/binary_libs 0.0.1

package/src/pe.ts

@@ -0,0 +1,510 @@
+import * as binary from '@isopodlabs/binary';
+
+class MyDate extends Date {
+	constructor(x: number) { super(x * 1000); }
+	valueOf()	{ return this.getTime() / 1000; }
+	toString()	{ return super.toString(); }
+}
+
+const TIMEDATE = binary.as(binary.UINT32_LE, MyDate);
+
+
+//-----------------------------------------------------------------------------
+//	COFF
+//-----------------------------------------------------------------------------
+
+const DOS_HEADER = {
+	magic:		binary.UINT16_LE,
+	cblp:		binary.UINT16_LE,
+	cp:			binary.UINT16_LE,
+	crlc:		binary.UINT16_LE,
+	cparhdr:	binary.UINT16_LE,
+	minalloc:	binary.UINT16_LE,
+	maxalloc:	binary.XINT16_LE,
+	ss:			binary.UINT16_LE,
+	sp:			binary.UINT16_LE,
+	csum:		binary.UINT16_LE,
+	ip:			binary.UINT16_LE,
+	cs:			binary.UINT16_LE,
+	lfarlc:		binary.UINT16_LE,
+	ovno:		binary.UINT16_LE,
+};
+
+const EXE_HEADER = {
+	res:		binary.ArrayType(4, binary.UINT16_LE),
+	oemid:		binary.UINT16_LE,
+	oeminfo:	binary.UINT16_LE,
+	res2:		binary.ArrayType(10, binary.UINT16_LE),
+	lfanew:		binary.INT32_LE,
+};
+
+//-----------------------------------------------------------------------------
+//	PE
+//-----------------------------------------------------------------------------
+
+export class pe_stream extends binary.stream {
+	constructor(public pe: PE, data: Uint8Array) {
+		super(data);
+	}
+	get_rva()	{ return this.pe.GetDataRVA(binary.UINT32_LE.get(this))?.data; }
+}
+
+const RVA_STRING = {
+	get(s: pe_stream)	{ return binary.utils.decodeTextTo0(s.get_rva(), 'utf8'); },
+	put(s: pe_stream)	{}
+};
+const RVA_ARRAY16 = {
+	get(s: pe_stream)	{ return binary.utils.to16(s.get_rva()); },
+	put(s: pe_stream)	{}
+};
+const RVA_ARRAY32 = {
+	get(s: pe_stream)	{ return binary.utils.to32(s.get_rva()); },
+	put(s: pe_stream)	{}
+};
+const RVA_ARRAY64 = {
+	get(s: pe_stream)	{ return binary.utils.to64(s.get_rva()); },
+	put(s: pe_stream)	{}
+};
+
+const FILE_HEADER = {
+	Machine:				binary.UINT16_LE,
+	NumberOfSections:		binary.UINT16_LE,
+	TimeDateStamp:			binary.UINT32_LE,
+	PointerToSymbolTable:	binary.UINT32_LE,
+	NumberOfSymbols:		binary.UINT32_LE,
+	SizeOfOptionalHeader:	binary.UINT16_LE,
+	Characteristics:		binary.UINT16_LE,
+};
+
+enum SECTION_CHARACTERISTICS {
+//							= 0x00000000,
+//							= 0x00000001,
+//							= 0x00000002,
+//							= 0x00000004,
+	TYPE_NO_PAD				= 0x00000008,
+//							= 0x00000010,
+	CNT_CODE				= 0x00000020,
+	CNT_INITIALIZED_DATA	= 0x00000040,
+	CNT_UNINITIALIZED_DATA	= 0x00000080,
+	LNK_OTHER				= 0x00000100,
+	LNK_INFO				= 0x00000200,
+//							= 0x00000400,
+	LNK_REMOVE				= 0x00000800,
+	LNK_COMDAT				= 0x00001000,
+	GPREL					= 0x00008000,
+//	MEM_PURGEABLE			= 0x00020000,
+	MEM_16BIT				= 0x00020000,
+	MEM_LOCKED				= 0x00040000,
+	MEM_PRELOAD				= 0x00080000,
+	ALIGN					= 0x00f00000,
+	//ALIGN_1BYTES			= 0x00100000,
+	//ALIGN_2BYTES			= 0x00200000,
+	//ALIGN_4BYTES			= 0x00300000,
+	//ALIGN_8BYTES			= 0x00400000,
+	//ALIGN_16BYTES			= 0x00500000,
+	//ALIGN_32BYTES			= 0x00600000,
+	//ALIGN_64BYTES			= 0x00700000,
+	//ALIGN_128BYTES			= 0x00800000,
+	//ALIGN_256BYTES			= 0x00900000,
+	//ALIGN_512BYTES			= 0x00A00000,
+	//ALIGN_1024BYTES			= 0x00B00000,
+	//ALIGN_2048BYTES			= 0x00C00000,
+	//ALIGN_4096BYTES			= 0x00D00000,
+	//ALIGN_8192BYTES			= 0x00E00000,
+	LNK_NRELOC_OVFL			= 0x01000000,
+	MEM_DISCARDABLE			= 0x02000000,
+	MEM_NOT_CACHED			= 0x04000000,
+	MEM_NOT_PAGED			= 0x08000000,
+	MEM_SHARED				= 0x10000000,
+	MEM_EXECUTE				= 0x20000000,
+	MEM_READ				= 0x40000000,
+	MEM_WRITE				= 0x80000000,
+}
+
+class Section extends binary.ReadStruct({
+	Name:					binary.StringType(8),
+	VirtualSize:			binary.UINT32_LE,
+	VirtualAddress:			binary.XINT32_LE,
+	SizeOfRawData:			binary.UINT32_LE,
+	PointerToRawData:		binary.XINT32_LE,
+	PointerToRelocations:	binary.XINT32_LE,
+	PointerToLinenumbers:	binary.XINT32_LE,
+	NumberOfRelocations:	binary.INT16_LE,
+	NumberOfLinenumbers:	binary.INT16_LE,
+	Characteristics:		binary.asFlags(binary.UINT32_LE, SECTION_CHARACTERISTICS)
+}) {
+	data?: binary.utils.MappedMemory;
+	constructor(r: binary.stream) {
+		super(r);
+		try {
+			this.data = new binary.utils.MappedMemory(r.buffer_at(+this.PointerToRawData, this.SizeOfRawData), +this.VirtualAddress, this.flags);
+		} catch (e) {
+			console.log(e);
+		}
+	}
+	get flags() {
+		return binary.utils.MEM.RELATIVE
+			| (this.Characteristics.MEM_READ	? binary.utils.MEM.READ 	: 0)
+			| (this.Characteristics.MEM_WRITE	? binary.utils.MEM.WRITE 	: 0)
+			| (this.Characteristics.MEM_EXECUTE	? binary.utils.MEM.EXECUTE	: 0);
+	}
+}
+
+interface DirectoryInfo {
+	read?: (pe: PE, data: binary.utils.MappedMemory) => any;
+}
+
+export const DIRECTORIES : Record<string, DirectoryInfo> = {
+	EXPORT:			{read: (pe, data) => ReadExports(new pe_stream(pe, data.data)) },
+	IMPORT:			{read: (pe, data) => ReadImports(new pe_stream(pe, data.data)) },
+	RESOURCE:		{read: (pe, data) => ReadResourceDirectory(new binary.stream(data.data), data)},
+	EXCEPTION:		{},	// Exception Directory
+	SECURITY:		{},	// Security Directory
+	BASERELOC:		{},	// Base Relocation Table
+	DEBUG_DIR:		{},	// Debug Directory
+	ARCHITECTURE:	{},	// Architecture Specific Data
+	GLOBALPTR:		{},	// RVA of GP
+	TLS:			{},
+	LOAD_CONFIG:	{},	// Load Configuration Directory
+	BOUND_IMPORT:	{},	// Bound Import Directory in headers
+	IAT:			{},	// Import Address Table
+	DELAY_IMPORT:	{},
+	CLR_DESCRIPTOR:	{},
+};
+
+export const DATA_DIRECTORY = {
+	VirtualAddress: 			binary.UINT32_LE,
+	Size: 						binary.UINT32_LE,
+};
+
+type Directory = binary.ReadType<typeof DATA_DIRECTORY>;
+
+const MAGIC = {
+	NT32:		0x10b,
+	NT64:		0x20b,
+	ROM:		0x107,
+	OBJ:		0x104,	// object files, eg as output
+//	DEMAND:		0x10b,	// demand load format, eg normal ld output
+	TARGET:		0x101,	// target shlib
+	HOST:		0x123,	// host   shlib
+};
+
+const DLLCHARACTERISTICS = {
+	DYNAMIC_BASE:		  	0x0040,	// DLL can be relocated at load time (ASLR)
+	FORCE_INTEGRITY:	   	0x0080,	// Code integrity checks are enforced
+	NX_COMPAT:			 	0x0100,	// Image is NX compatible (DEP)
+	NO_ISOLATION:		  	0x0200,	// Isolation aware, but do not isolate the image
+	NO_SEH:					0x0400,	// Does not use structured exception handling
+	NO_BIND:			   	0x0800,	// Do not bind the image
+	WDM_DRIVER:				0x2000,	// Driver uses WDM model
+	TERMINAL_SERVER_AWARE: 	0x8000,	// Terminal Server aware
+};
+
+const OPTIONAL_HEADER = {
+	Magic:						binary.asEnum(binary.UINT16_LE, MAGIC),
+	MajorLinkerVersion:			binary.UINT8,
+	MinorLinkerVersion:			binary.UINT8,
+	SizeOfCode:					binary.UINT32_LE,
+	SizeOfInitializedData:		binary.UINT32_LE,
+	SizeOfUninitializedData:	binary.UINT32_LE,
+	AddressOfEntryPoint:		binary.XINT32_LE,
+	BaseOfCode:					binary.XINT32_LE,
+};
+
+const OPTIONAL_HEADER32 = {
+	BaseOfData: 				binary.XINT32_LE,
+	ImageBase:  				binary.XINT32_LE,
+	SectionAlignment:   		binary.UINT32_LE,
+	FileAlignment:  			binary.UINT32_LE,
+	MajorOperatingSystemVersion:binary.UINT16_LE,
+	MinorOperatingSystemVersion:binary.UINT16_LE,
+	MajorImageVersion:  		binary.UINT16_LE,
+	MinorImageVersion:  		binary.UINT16_LE,
+	MajorSubsystemVersion:  	binary.UINT16_LE,
+	MinorSubsystemVersion:  	binary.UINT16_LE,
+	Win32VersionValue:  		binary.UINT32_LE,
+	SizeOfImage:				binary.UINT32_LE,
+	SizeOfHeaders:  			binary.UINT32_LE,
+	CheckSum:   				binary.UINT32_LE,
+	Subsystem:  				binary.UINT16_LE,
+	DllCharacteristics: 		binary.asFlags(binary.UINT16_LE, DLLCHARACTERISTICS),
+	SizeOfStackReserve: 		binary.UINT32_LE,
+	SizeOfStackCommit:  		binary.UINT32_LE,
+	SizeOfHeapReserve:  		binary.UINT32_LE,
+	SizeOfHeapCommit:   		binary.UINT32_LE,
+	LoaderFlags:				binary.UINT32_LE,
+	DataDirectory:  			binary.objectWithNames(binary.ArrayType(binary.UINT32_LE, DATA_DIRECTORY), binary.names(Object.keys(DIRECTORIES))),
+};
+
+const OPTIONAL_HEADER64 = {
+	ImageBase:  				binary.XINT64_LE,
+	SectionAlignment:   		binary.UINT32_LE,
+	FileAlignment:  			binary.UINT32_LE,
+	MajorOperatingSystemVersion:binary.UINT16_LE,
+	MinorOperatingSystemVersion:binary.UINT16_LE,
+	MajorImageVersion:  		binary.UINT16_LE,
+	MinorImageVersion:  		binary.UINT16_LE,
+	MajorSubsystemVersion:  	binary.UINT16_LE,
+	MinorSubsystemVersion:  	binary.UINT16_LE,
+	Win32VersionValue:  		binary.UINT32_LE,
+	SizeOfImage:				binary.UINT32_LE,
+	SizeOfHeaders:  			binary.UINT32_LE,
+	CheckSum:   				binary.UINT32_LE,
+	Subsystem:  				binary.UINT16_LE,
+	DllCharacteristics: 		binary.asFlags(binary.UINT16_LE, DLLCHARACTERISTICS),
+	SizeOfStackReserve: 		binary.UINT64_LE,
+	SizeOfStackCommit:  		binary.UINT64_LE,
+	SizeOfHeapReserve:  		binary.UINT64_LE,
+	SizeOfHeapCommit:   		binary.UINT64_LE,
+	LoaderFlags:				binary.UINT32_LE,
+	DataDirectory:  			binary.objectWithNames(binary.ArrayType(binary.UINT32_LE, DATA_DIRECTORY), binary.names(Object.keys(DIRECTORIES))),
+};
+
+export class PE {
+	header:		binary.ReadType<typeof DOS_HEADER> & binary.ReadType<typeof EXE_HEADER>;
+	sections:	Section[];
+	opt?:		binary.ReadType<typeof OPTIONAL_HEADER> & (binary.ReadType<typeof OPTIONAL_HEADER32> | binary.ReadType<typeof OPTIONAL_HEADER64>);
+
+	static check(data: Uint8Array): boolean {
+		return binary.UINT16_LE.get(new binary.stream(data)) === binary.utils.stringCode("MZ");
+	}
+
+	constructor(private data: Uint8Array) {
+		const file	= new binary.stream(data);
+		this.header	= binary.read(file, {...DOS_HEADER, ...EXE_HEADER});
+
+		file.seek(this.header.lfanew);
+		if (binary.UINT32_LE.get(file) == binary.utils.stringCode("PE\0\0")) {
+			const h = binary.read(file, FILE_HEADER);
+
+			if (h.SizeOfOptionalHeader) {
+				const opt	= new binary.stream(file.read_buffer(h.SizeOfOptionalHeader));
+				const opt1	= binary.read(opt, OPTIONAL_HEADER);
+				if (opt1.Magic == 'NT32')
+					this.opt = binary.read_more(opt, OPTIONAL_HEADER32, opt1);
+				else if (opt1.Magic == 'NT64')
+					this.opt = binary.read_more(opt, OPTIONAL_HEADER64, opt1);
+			}
+
+			this.sections = Array.from({length: h.NumberOfSections}, () => new Section(file));
+		} else {
+			this.sections = [];
+		}
+	}
+
+	get directories() {
+		return this.opt?.DataDirectory;
+	}
+
+	FindSectionRVA(rva: number) {
+		for (const i of this.sections) {
+			if (rva >= +i.VirtualAddress && rva < +i.VirtualAddress + i.SizeOfRawData)
+				return i;
+		}
+	}
+
+	FindSectionRaw(addr: number) {
+		for (const i of this.sections) {
+			if (addr >= +i.PointerToRawData && addr < +i.PointerToRawData + i.SizeOfRawData)
+				return i;
+		}
+	}
+
+	GetDataRVA(rva: number, size?: number) {
+		const sect = this.FindSectionRVA(rva);
+		if (sect && sect.data)
+			return sect.data.at(rva, size);
+	}
+	GetDataRaw(addr: number, size: number) {
+		const sect = this.FindSectionRaw(addr);
+		if (sect && sect.data) {
+			const offset = addr - +sect.PointerToRawData;
+			return sect.data.data.subarray(offset, offset + size);
+		}
+	}
+	GetDataDir(dir: Directory) {
+		if (dir.Size)
+			return this.GetDataRVA(dir.VirtualAddress, dir.Size);
+	}
+
+	ReadDirectory(name: string) {
+		const dir	= this.opt?.DataDirectory[name];
+		if (dir?.Size) {
+			const data 	= this.GetDataDir(dir);
+			const info	= DIRECTORIES[name];
+			if (data && info?.read)
+				return info.read(this, data);
+			return data;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//	exports
+//-----------------------------------------------------------------------------
+
+const EXPORT_DIRECTORY = {
+	ExportFlags:	binary.UINT32_LE,	// Reserved, must be 0.
+	TimeDateStamp:	TIMEDATE,			// The time and date that the export data was created.
+	MajorVersion:	binary.XINT16_LE,	// The major version number. The major and minor version numbers can be set by the user.
+	MinorVersion:	binary.XINT16_LE,	// The minor version number.
+	DLLName:		RVA_STRING,			// The address of the ASCII string that contains the name of the DLL. This address is relative to the image base.
+	OrdinalBase:	binary.UINT32_LE,	// The starting ordinal number for exports in this image. This field specifies the starting ordinal number for the export address table. It is usually set to 1.
+	NumberEntries:	binary.UINT32_LE,	// The number of entries in the export address table.
+	NumberNames:	binary.UINT32_LE,	// The number of entries in the name pointer table. This is also the number of entries in the ordinal table.
+	FunctionTable:	RVA_ARRAY32,		// RVA of functions
+	NameTable:		RVA_ARRAY32,		// RVA of names
+	OrdinalTable:	RVA_ARRAY16,		// RVA from base of image
+};
+
+interface ExportEntry {
+	ordinal: number;
+	name: string;
+	address: number;
+}
+
+export function ReadExports(file: pe_stream) {
+	const dir 		= binary.read(file, EXPORT_DIRECTORY);
+	const addresses	= dir.FunctionTable!;
+	const names		= dir.NameTable;
+	const ordinals	= dir.OrdinalTable;
+
+	const result: ExportEntry[] = [];
+	for (let i = 0; i < dir.NumberEntries; i++) {
+		const sect = file.pe.FindSectionRVA(addresses[i]);
+		if (sect) {
+			const ordinal	= (ordinals && i < dir.NumberNames ? ordinals[i] : i) + dir.OrdinalBase;
+			const name		= names && i < dir.NumberNames ? binary.utils.decodeTextTo0(file.pe.GetDataRVA(names[i])?.data, 'utf8') : '';
+			result.push({ordinal, name, address: addresses[i]});
+		}
+	}
+	const sorted = result.sort((a, b)=> a.address - b.address);
+	return sorted.map((v, i) => {
+		let j = i;
+		while (++j < sorted.length && sorted[j].address == v.address);
+		return [v.ordinal, v.name, file.pe.GetDataRVA(v.address, j < sorted.length ? sorted[j].address - v.address : undefined)];
+	});
+}
+
+//-----------------------------------------------------------------------------
+//	imports
+//-----------------------------------------------------------------------------
+
+export class DLLImports extends Array {}
+
+const RVA_ITA64 = {
+	get(s: pe_stream)	{ 
+		const r = binary.utils.to64(s.get_rva());
+		if (r) {
+			const result = Array.from(r.subarray(0, r.indexOf(0n)), i =>
+				i >> 63n
+					? `ordinal_${i - (1n << 63n)}`
+					: binary.utils.decodeTextTo0(s.pe.GetDataRVA(Number(i))?.data.subarray(2), 'utf8')
+			);
+			Object.setPrototypeOf(result, DLLImports.prototype);
+			return result;
+		}
+	},
+	put(s: pe_stream)	{}
+};
+
+const IMPORT_DESCRIPTOR = {
+	Characteristics:	binary.UINT32_LE,	// 0 for terminating null import descriptor
+	TimeDateStamp:  	TIMEDATE,			// 0 if not bound, -1 if bound, and real date\time stamp in IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT (new BIND)	// O.W. date/time stamp of DLL bound to (Old BIND)
+	ForwarderChain: 	binary.UINT32_LE,	// -1 if no forwarders
+	DllName:			RVA_STRING,//binary.UINT32_LE,
+	FirstThunk:			RVA_ITA64,//binary.UINT32_LE,	// RVA to IAT (if bound this IAT has actual addresses)
+};
+
+export function ReadImports(file: pe_stream) {
+	const result: [string, any][] = [];
+	while (file.remaining()) {
+		const r = binary.read(file, IMPORT_DESCRIPTOR);
+		if (!r.Characteristics)
+			break;
+		result.push([r.DllName, r.FirstThunk]);
+	}
+	return result;
+}
+
+//-----------------------------------------------------------------------------
+//	resources
+//-----------------------------------------------------------------------------
+
+const RESOURCE_DIRECTORY_ENTRY = {
+	get(s: binary.stream) {
+		const u0 = binary.UINT32_LE.get(s);
+		const u1 = binary.UINT32_LE.get(s);
+		return [u0, u1];
+	},
+	put(s: binary.stream) {}
+
+};
+
+class RESOURCE_DATA_ENTRY extends binary.ReadStruct({
+	OffsetToData:	binary.UINT32_LE,
+	Size:			binary.UINT32_LE,
+	CodePage:		binary.UINT32_LE,
+	Reserved:		binary.UINT32_LE,
+}) {
+	data:			Uint8Array;
+	constructor(file: binary.stream, data: binary.utils.MappedMemory) {
+		super(file);
+		this.data	= data.slice(this.OffsetToData, this.OffsetToData + this.Size).data;
+	}
+}
+
+const RESOURCE_DIRECTORY = {
+	Characteristics:		binary.UINT32_LE,
+	TimeDateStamp:			binary.UINT32_LE,
+	MajorVersion:			binary.UINT16_LE,
+	MinorVersion:			binary.UINT16_LE,
+	NumberOfNamedEntries:	binary.UINT16_LE,
+	NumberOfIdEntries:		binary.UINT16_LE,
+};
+
+enum IRT {
+	NONE			= 0,
+	CURSOR			= 1,
+	BITMAP			= 2,
+	ICON			= 3,
+	MENU			= 4,
+	DIALOG			= 5,
+	STRING			= 6,
+	FONTDIR			= 7,
+	FONT			= 8,
+	ACCELERATOR		= 9,
+	RCDATA			= 10,
+	MESSAGETABLE	= 11,
+	GROUP_CURSOR	= 12,
+	GROUP_ICON		= 14,
+	VERSION			= 16,
+	DLGINCLUDE		= 17,
+	PLUGPLAY		= 19,
+	VXD				= 20,
+	ANICURSOR		= 21,
+	ANIICON			= 22,
+	HTML			= 23,
+	MANIFEST		= 24,
+	TOOLBAR			= 241,
+}
+
+export function ReadResourceDirectory(file: binary.stream, data: binary.utils.MappedMemory, type = IRT.NONE) {
+	const dir 		= binary.read(file, RESOURCE_DIRECTORY);
+	const n			= dir.NumberOfNamedEntries + dir.NumberOfIdEntries;
+	const entries	= binary.readn(file, RESOURCE_DIRECTORY_ENTRY, n);
+	const id_type	= binary.StringType(binary.UINT16_LE, 'utf16le');
+	const topbit	= 0x80000000;
+	const result : Record<string, any> = {};
+
+	for (const i of entries) {
+		const id = i[0] & topbit ? id_type.get(file.seek(i[0] & ~topbit)) : !type ? IRT[i[0]] : i[0];
+		
+		file.seek(i[1] & ~topbit);
+		result[id]	= i[1] & topbit
+			? ReadResourceDirectory(file, data, type || i[0])
+			: new RESOURCE_DATA_ENTRY(file, data);
+	}
+	return result;
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "strict": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "**/*.spec.ts"
+  ]
+}