Files
reverse-engineering-anything/src/domain/elfProgramHeader.ts
T
morluto 0b19b06bf6 fix(native): share ELF, PE, and Mach-O framing across artifact readers (#12156)
* fix(elf): share dynamic table singleton validation

* fix(elf): share note storage and framing across readers

Refs #12130

* fix(elf): retain zero-filled load mapping ambiguity

Refs #12136

* fix(pe): share header extent admission

Refs #12143

* fix(macho): share embedded section backing checks

Refs #12142

* fix(pe): share header facts and validate resource directory order

* fix(macho): require complete carrier load command framing

* fix(pe): probe declared resource headers by file offset

* fix(elf): preserve zero-fill observations across mapping gaps

* refactor(pe): share positional COFF header observation (#12173)

* fix(elf): check load-map agreement across section extents (#12175)

* fix(elf): check load-map agreement across section extents

* fix(elf): preserve agreed section links across unreadable tables
2026-11-19 03:49:13 +00:00

88 lines
2.5 KiB
TypeScript

import { err, ok } from "./result.js";
import type { FileMapping, ZeroFillMapping } from "./virtualFileMapping.js";
export const PT_INTERP = 3;
export type ElfProgramHeader = Extract<
ReturnType<typeof readElfProgramHeader>,
{ readonly ok: true }
>["value"];
/** Fixed ELF32/ELF64 program declarations; consumers own type, precision and mapping admission. */
export const readElfProgramHeader = (
bytes: Uint8Array,
bits: 32 | 64,
littleEndian: boolean,
) => {
const wide = bits === 64;
if (bytes.byteLength < (wide ? 56 : 32))
return err({
kind: "malformed" as const,
message: "ELF program header is truncated",
});
const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
const word = (at: number): bigint =>
wide
? view.getBigUint64(at, littleEndian)
: BigInt(view.getUint32(at, littleEndian));
return ok({
type: view.getUint32(0, littleEndian),
flags: view.getUint32(wide ? 4 : 24, littleEndian),
offset: word(wide ? 8 : 4),
virtualAddress: word(wide ? 16 : 8),
physicalAddress: word(wide ? 24 : 12),
fileSize: word(wide ? 32 : 16),
memorySize: word(wide ? 40 : 20),
alignment: word(wide ? 48 : 28),
});
};
/** Admit PT_LOAD sizes once for consumers that read through load mappings. */
export const admitElfLoadSegment = (
segment: {
readonly virtualAddress: bigint;
readonly memorySize: bigint;
readonly fileSize: bigint;
},
bits: 32 | 64,
) =>
segment.fileSize > segment.memorySize ||
segment.virtualAddress + segment.memorySize > 1n << BigInt(bits)
? err({
kind: "malformed" as const,
message: "ELF load segment sizes or addresses are invalid",
})
: ok(null);
export interface ElfLoadMappings {
readonly fileBacked: readonly FileMapping[];
readonly zeroFills: readonly ZeroFillMapping[];
}
/** Project an admitted PT_LOAD into its file-backed prefix and zero-filled tail. */
export const elfLoadSpans = ({
virtualAddress,
offset,
fileSize,
memorySize,
}: Pick<
ElfProgramHeader,
"virtualAddress" | "offset" | "fileSize" | "memorySize"
>): {
readonly fileBacked: FileMapping | undefined;
readonly zeroFill: ZeroFillMapping | undefined;
} => ({
fileBacked:
fileSize === 0n
? undefined
: {
address: virtualAddress,
offset: Number(offset),
size: Number(fileSize),
},
zeroFill:
memorySize > fileSize
? { address: virtualAddress + fileSize, size: memorySize - fileSize }
: undefined,
});