fix(elf): centralize fixed header validation across consumers
Validate ELF identification/header versions and declared header bounds at the shared owner. Reuse parsed facts in target selection, Go, Dart and MIPS readers while preserving their stricter format policies and x32 support. Repair synthetic ELF fixtures and remove a superseded Go error-text assertion. Validation: 74 source tests, 202 filesystem/Go/MIPS boundary tests, typecheck and lint. No new real-provider claims.
This commit is contained in:
@@ -3,6 +3,7 @@ import type {
|
||||
MipsAbiFlags,
|
||||
MipsElfMetadata,
|
||||
} from "../domain/binaryTargetTypes.js";
|
||||
import { readElfFixedHeader } from "../domain/elfFixedHeader.js";
|
||||
import { err, ok, type Result } from "../domain/result.js";
|
||||
import {
|
||||
readMipsElfSharedLoad,
|
||||
@@ -64,21 +65,22 @@ export const readMipsElfMetadata = async (
|
||||
const header = await read(0, 52, "ELF32 header");
|
||||
if (!header.ok) return header;
|
||||
const bytes = header.value;
|
||||
const fixedHeader = readElfFixedHeader(bytes, fileSize);
|
||||
if (!fixedHeader.ok) return fixedHeader;
|
||||
const little = metadata.byteOrder === "little";
|
||||
const u16 = (data: Buffer, offset: number): number =>
|
||||
little ? data.readUInt16LE(offset) : data.readUInt16BE(offset);
|
||||
const u32 = (data: Buffer, offset: number): number =>
|
||||
little ? data.readUInt32LE(offset) : data.readUInt32BE(offset);
|
||||
if (
|
||||
bytes.toString("hex", 0, 4) !== "7f454c46" ||
|
||||
bytes[4] !== 1 ||
|
||||
bytes[5] !== (little ? 1 : 2) ||
|
||||
fixedHeader.value.elfClass !== 32 ||
|
||||
fixedHeader.value.byteOrder !== metadata.byteOrder ||
|
||||
u16(bytes, 18) !== 8 ||
|
||||
u16(bytes, 16) !== metadata.type ||
|
||||
u32(bytes, 36) !== metadata.flags
|
||||
)
|
||||
return err("MIPS ELF header no longer matches the resolved identity");
|
||||
if (bytes[6] !== 1 || u32(bytes, 20) !== 1 || u16(bytes, 40) !== 52)
|
||||
if (fixedHeader.value.headerSize !== 52)
|
||||
return err("invalid MIPS ELF32 version or header size");
|
||||
|
||||
const tables = [
|
||||
|
||||
@@ -5,9 +5,16 @@ export const elf = (
|
||||
machine: number,
|
||||
): Buffer => {
|
||||
const bytes = Buffer.alloc(class_ === 1 ? 52 : 64);
|
||||
bytes.set([0x7f, 0x45, 0x4c, 0x46, class_, endian]);
|
||||
if (endian === 1) bytes.writeUInt16LE(machine, 18);
|
||||
else bytes.writeUInt16BE(machine, 18);
|
||||
bytes.set([0x7f, 0x45, 0x4c, 0x46, class_, endian, 1]);
|
||||
if (endian === 1) {
|
||||
bytes.writeUInt16LE(machine, 18);
|
||||
bytes.writeUInt32LE(1, 20);
|
||||
bytes.writeUInt16LE(class_ === 1 ? 52 : 64, class_ === 1 ? 40 : 52);
|
||||
} else {
|
||||
bytes.writeUInt16BE(machine, 18);
|
||||
bytes.writeUInt32BE(1, 20);
|
||||
bytes.writeUInt16BE(class_ === 1 ? 52 : 64, class_ === 1 ? 40 : 52);
|
||||
}
|
||||
return bytes;
|
||||
};
|
||||
|
||||
|
||||
@@ -7,10 +7,14 @@ const header = (little: boolean, bits: 32 | 64 = 32): Buffer => {
|
||||
if (little) {
|
||||
bytes.writeUInt16LE(2, 16);
|
||||
bytes.writeUInt16LE(8, 18);
|
||||
bytes.writeUInt32LE(1, 20);
|
||||
bytes.writeUInt16LE(bits === 32 ? 52 : 64, bits === 32 ? 40 : 52);
|
||||
bytes.writeUInt32LE(0x70001001, bits === 32 ? 36 : 48);
|
||||
} else {
|
||||
bytes.writeUInt16BE(2, 16);
|
||||
bytes.writeUInt16BE(8, 18);
|
||||
bytes.writeUInt32BE(1, 20);
|
||||
bytes.writeUInt16BE(bits === 32 ? 52 : 64, bits === 32 ? 40 : 52);
|
||||
bytes.writeUInt32BE(0x70001001, bits === 32 ? 36 : 48);
|
||||
}
|
||||
return bytes;
|
||||
|
||||
@@ -13,10 +13,14 @@ const header = (
|
||||
if (little) {
|
||||
bytes.writeUInt16LE(type, 16);
|
||||
bytes.writeUInt16LE(machine, 18);
|
||||
bytes.writeUInt32LE(1, 20);
|
||||
bytes.writeUInt16LE(bits === 32 ? 52 : 64, bits === 32 ? 40 : 52);
|
||||
bytes.writeUInt32LE(flags, bits === 32 ? 36 : 48);
|
||||
} else {
|
||||
bytes.writeUInt16BE(type, 16);
|
||||
bytes.writeUInt16BE(machine, 18);
|
||||
bytes.writeUInt32BE(1, 20);
|
||||
bytes.writeUInt16BE(bits === 32 ? 52 : 64, bits === 32 ? 40 : 52);
|
||||
bytes.writeUInt32BE(flags, bits === 32 ? 36 : 48);
|
||||
}
|
||||
return bytes;
|
||||
|
||||
@@ -26,6 +26,13 @@ describe("executable header parsing", () => {
|
||||
expect(result.ok && result.value).toMatchObject({ format, architecture });
|
||||
});
|
||||
|
||||
it("retains ELF32 x86-64 identity for the x32 ABI", () => {
|
||||
expect(parseExecutableHeader(elf(1, 1, 62), "x64")).toMatchObject({
|
||||
ok: true,
|
||||
value: { format: "elf", architecture: "x86_64" },
|
||||
});
|
||||
});
|
||||
|
||||
it("distinguishes native PE applications, DLLs, and managed assemblies", () => {
|
||||
const application = parseExecutableHeader(pe(0x8664), "x64");
|
||||
const library = parseExecutableHeader(pe(0x8664, 64, 0x2002), "x64");
|
||||
|
||||
@@ -7,6 +7,7 @@ import type {
|
||||
UniversalMachOSlice,
|
||||
} from "./binaryTargetTypes.js";
|
||||
import { err, ok, type Result } from "./result.js";
|
||||
import { readElfFixedHeader } from "./elfFixedHeader.js";
|
||||
import { observeMzWindowsHeader, parseDosMzHeader } from "./dosMz.js";
|
||||
import { decodePeMachine } from "./peMachine.js";
|
||||
import {
|
||||
@@ -191,20 +192,14 @@ const parseElf = (
|
||||
bytes: Buffer,
|
||||
fileSize: number,
|
||||
): Result<ExecutableMetadata, string> => {
|
||||
if (bytes.length < 6) return err("truncated ELF header");
|
||||
if (bytes[4] !== 1 && bytes[4] !== 2) return err("unsupported ELF class");
|
||||
const little = bytes[5] === 1;
|
||||
if (!little && bytes[5] !== 2) return err("unsupported ELF endianness");
|
||||
const headerSize = bytes[4] === 1 ? 52 : 64;
|
||||
if (bytes.length < headerSize)
|
||||
return err(
|
||||
`truncated ELF header: an ELF${bytes[4] === 1 ? 32 : 64} header needs ${headerSize} bytes; the file has ${fileSize}`,
|
||||
);
|
||||
const fixedHeader = readElfFixedHeader(bytes, fileSize);
|
||||
if (!fixedHeader.ok) return fixedHeader;
|
||||
const { elfClass, byteOrder } = fixedHeader.value;
|
||||
const little = byteOrder === "little";
|
||||
const machine = little ? bytes.readUInt16LE(18) : bytes.readUInt16BE(18);
|
||||
const architecture = elfArchitecture(machine);
|
||||
if (architecture === undefined) return err("unsupported ELF architecture");
|
||||
if (architecture === "mips" || architecture === "riscv") {
|
||||
const elfClass = bytes[4] === 1 ? 32 : 64;
|
||||
const flagsOffset = elfClass === 32 ? 36 : 48;
|
||||
const metadata: ElfFamilyMetadata = {
|
||||
elfClass,
|
||||
|
||||
@@ -0,0 +1,61 @@
|
||||
import { expect, it } from "vitest";
|
||||
import { readElfFixedHeader } from "./elfFixedHeader.js";
|
||||
import { elf } from "./binaryTarget.fixture.js";
|
||||
|
||||
it.each([
|
||||
["ELF32 little endian", 1, 1],
|
||||
["ELF32 big endian", 1, 2],
|
||||
["ELF64 little endian", 2, 1],
|
||||
["ELF64 big endian", 2, 2],
|
||||
] as const)(
|
||||
"reads common fixed header commitments for %s",
|
||||
(_name, cls, data) => {
|
||||
const bytes = elf(cls, data, cls === 1 ? 3 : 62);
|
||||
expect(readElfFixedHeader(bytes)).toEqual({
|
||||
ok: true,
|
||||
value: {
|
||||
elfClass: cls === 1 ? 32 : 64,
|
||||
byteOrder: data === 1 ? "little" : "big",
|
||||
headerSize: cls === 1 ? 52 : 64,
|
||||
},
|
||||
});
|
||||
},
|
||||
);
|
||||
|
||||
it.each([
|
||||
[
|
||||
"identification version",
|
||||
(bytes: Buffer) => {
|
||||
bytes[6] = 0;
|
||||
},
|
||||
],
|
||||
[
|
||||
"header version",
|
||||
(bytes: Buffer) => {
|
||||
bytes.writeUInt32LE(0, 20);
|
||||
},
|
||||
],
|
||||
[
|
||||
"undersized declared header",
|
||||
(bytes: Buffer) => {
|
||||
bytes.writeUInt16LE(51, 40);
|
||||
},
|
||||
],
|
||||
[
|
||||
"declared header beyond file",
|
||||
(bytes: Buffer) => {
|
||||
bytes.writeUInt16LE(53, 40);
|
||||
},
|
||||
],
|
||||
])("rejects an invalid %s", (_name, corrupt) => {
|
||||
const bytes = elf(1, 1, 3);
|
||||
corrupt(bytes);
|
||||
expect(readElfFixedHeader(bytes)).toMatchObject({ ok: false });
|
||||
});
|
||||
|
||||
it("checks declared header size against the whole file, not the prefix", () => {
|
||||
const bytes = elf(2, 1, 62);
|
||||
bytes.writeUInt16LE(128, 52);
|
||||
expect(readElfFixedHeader(bytes, 128)).toMatchObject({ ok: true });
|
||||
expect(readElfFixedHeader(bytes, 127)).toMatchObject({ ok: false });
|
||||
});
|
||||
@@ -0,0 +1,55 @@
|
||||
import { err, ok, type Result } from "./result.js";
|
||||
|
||||
export interface ElfFixedHeader {
|
||||
readonly elfClass: 32 | 64;
|
||||
readonly byteOrder: "little" | "big";
|
||||
readonly headerSize: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate the common, fixed ELF header commitments.
|
||||
*
|
||||
* `bytes` may be a bounded prefix. `totalBytes` is the containing file size,
|
||||
* so the declared header extent is checked against the file without requiring
|
||||
* the whole declared extent to be present in this prefix.
|
||||
*/
|
||||
export const readElfFixedHeader = (
|
||||
bytes: Buffer,
|
||||
totalBytes = bytes.length,
|
||||
): Result<ElfFixedHeader, string> => {
|
||||
if (bytes.length >= 4 && bytes.toString("hex", 0, 4) !== "7f454c46")
|
||||
return err("not an ELF image");
|
||||
if (bytes.length < 16) return err("ELF identification is truncated");
|
||||
const classByte = bytes[4];
|
||||
if (classByte !== 1 && classByte !== 2) return err("unsupported ELF class");
|
||||
const dataByte = bytes[5];
|
||||
if (dataByte !== 1 && dataByte !== 2)
|
||||
return err("unsupported ELF endianness");
|
||||
if (bytes[6] !== 1) return err("unsupported ELF identification version");
|
||||
|
||||
const elfClass = classByte === 1 ? 32 : 64;
|
||||
const minimumSize = elfClass === 32 ? 52 : 64;
|
||||
if (
|
||||
!Number.isSafeInteger(totalBytes) ||
|
||||
totalBytes < bytes.length ||
|
||||
totalBytes < minimumSize ||
|
||||
bytes.length < minimumSize
|
||||
)
|
||||
return err(
|
||||
`truncated ELF header: an ELF${elfClass} header needs ${minimumSize} bytes; the file has ${totalBytes}`,
|
||||
);
|
||||
const littleEndian = dataByte === 1;
|
||||
const readU16 = (offset: number): number =>
|
||||
littleEndian ? bytes.readUInt16LE(offset) : bytes.readUInt16BE(offset);
|
||||
const readU32 = (offset: number): number =>
|
||||
littleEndian ? bytes.readUInt32LE(offset) : bytes.readUInt32BE(offset);
|
||||
if (readU32(20) !== 1) return err("unsupported ELF header version");
|
||||
const headerSize = readU16(elfClass === 32 ? 40 : 52);
|
||||
if (headerSize < minimumSize || headerSize > totalBytes)
|
||||
return err("invalid ELF header size");
|
||||
return ok({
|
||||
elfClass,
|
||||
byteOrder: littleEndian ? "little" : "big",
|
||||
headerSize,
|
||||
});
|
||||
};
|
||||
+6
-16
@@ -5,6 +5,7 @@ import {
|
||||
SNAPSHOT_HASH_OFFSET,
|
||||
SNAPSHOT_HASH_PATTERN,
|
||||
} from "./FlutterPayloadScan.js";
|
||||
import { readElfFixedHeader } from "../domain/elfFixedHeader.js";
|
||||
|
||||
/** Bounds-checked little-endian reader over one loaded buffer. */
|
||||
class BoundedReader {
|
||||
@@ -80,24 +81,13 @@ export const readElfHeader = (
|
||||
totalBytes: number = bytes.length,
|
||||
) => {
|
||||
const reader = new BoundedReader(bytes);
|
||||
const magic = reader.u32(0);
|
||||
if (magic !== 0x464c457f) return { failure: { reason: "not an ELF image" } };
|
||||
const elfClass = reader.u8(4);
|
||||
if (elfClass !== 1 && elfClass !== 2)
|
||||
return { failure: { reason: `unsupported ELF class ${String(elfClass)}` } };
|
||||
const is64 = elfClass === 2;
|
||||
const fixedHeader = readElfFixedHeader(bytes, totalBytes);
|
||||
if (!fixedHeader.ok) return { failure: { reason: fixedHeader.error } };
|
||||
const is64 = fixedHeader.value.elfClass === 64;
|
||||
const headerBytes = is64 ? ELF_HEADER_MAX_BYTES : 52;
|
||||
if (
|
||||
bytes.length < headerBytes ||
|
||||
!Number.isSafeInteger(totalBytes) ||
|
||||
totalBytes < headerBytes
|
||||
)
|
||||
return { failure: { reason: "ELF header is truncated" } };
|
||||
if (reader.u8(5) !== 1)
|
||||
if (fixedHeader.value.byteOrder !== "little")
|
||||
return { failure: { reason: "unsupported ELF byte order" } };
|
||||
if (reader.u8(6) !== 1 || reader.u32(0x14) !== 1)
|
||||
return { failure: { reason: "unsupported ELF version" } };
|
||||
if (reader.u16(is64 ? 0x34 : 0x28) !== headerBytes)
|
||||
if (fixedHeader.value.headerSize !== headerBytes)
|
||||
return { failure: { reason: "unsupported ELF header size" } };
|
||||
const e_type = reader.u16(0x10);
|
||||
if (e_type !== 1 && e_type !== 2 && e_type !== ET_DYN)
|
||||
|
||||
+9
-21
@@ -6,31 +6,19 @@ import {
|
||||
type GoFileMapping,
|
||||
type GoZeroFillMapping,
|
||||
} from "./GoBinaryContainer.js";
|
||||
import { readElfFixedHeader } from "../domain/elfFixedHeader.js";
|
||||
|
||||
/** Read ELF build-info sections and file-backed program mappings. */
|
||||
export const readGoElfImage = (bytes: Buffer): GoBinaryContainer => {
|
||||
if (bytes.length < 16)
|
||||
throw new GoBinaryFormatFailure(
|
||||
"malformed",
|
||||
"ELF identification is truncated",
|
||||
);
|
||||
const bits = bytes[4] === 1 ? 32 : bytes[4] === 2 ? 64 : null;
|
||||
if (bits === null || ![1, 2].includes(bytes[5] ?? 0) || bytes[6] !== 1)
|
||||
throw new GoBinaryFormatFailure(
|
||||
"malformed",
|
||||
"ELF class, byte order, or version is invalid",
|
||||
);
|
||||
const reader = new GoBinaryReader(bytes, bytes[5] === 1);
|
||||
const fixedHeader = readElfFixedHeader(bytes);
|
||||
if (!fixedHeader.ok)
|
||||
throw new GoBinaryFormatFailure("malformed", fixedHeader.error);
|
||||
const { elfClass: bits, headerSize } = fixedHeader.value;
|
||||
const reader = new GoBinaryReader(
|
||||
bytes,
|
||||
fixedHeader.value.byteOrder === "little",
|
||||
);
|
||||
const wide = bits === 64;
|
||||
const minimum = wide ? 64 : 52;
|
||||
reader.range(0, minimum, "ELF header");
|
||||
if (reader.u32(20) !== 1 || reader.u16(wide ? 52 : 40) < minimum)
|
||||
throw new GoBinaryFormatFailure(
|
||||
"malformed",
|
||||
"ELF header version or size is invalid",
|
||||
);
|
||||
const headerSize = reader.u16(wide ? 52 : 40);
|
||||
reader.range(0, headerSize, "ELF declared header");
|
||||
const phOffset = reader.word(wide ? 32 : 28, bits);
|
||||
const shOffset = reader.word(wide ? 40 : 32, bits);
|
||||
const phWidth = reader.u16(wide ? 54 : 42);
|
||||
|
||||
@@ -20,6 +20,7 @@ import {
|
||||
} from "../../../src/application/AppBundleExecutable.js";
|
||||
import {
|
||||
dosMz,
|
||||
elf,
|
||||
fat,
|
||||
pe,
|
||||
thinMach,
|
||||
@@ -846,3 +847,40 @@ describe("DOS binary target I/O", () => {
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it.each([
|
||||
[
|
||||
"EI_VERSION",
|
||||
(bytes: Buffer) => {
|
||||
bytes[6] = 0;
|
||||
},
|
||||
],
|
||||
[
|
||||
"e_version",
|
||||
(bytes: Buffer) => {
|
||||
bytes.writeUInt32LE(0, 20);
|
||||
},
|
||||
],
|
||||
[
|
||||
"e_ehsize",
|
||||
(bytes: Buffer) => {
|
||||
bytes.writeUInt16LE(51, 40);
|
||||
},
|
||||
],
|
||||
])(
|
||||
"rejects an ELF with malformed %s during public target opening",
|
||||
async (_name, corrupt) => {
|
||||
const directory = await createTestTempDirectory("rea-invalid-elf-header-");
|
||||
const path = join(directory, "invalid.elf");
|
||||
const bytes = elf(1, 1, 3);
|
||||
corrupt(bytes);
|
||||
await writeFile(path, bytes);
|
||||
expect(await parseBinaryTarget(path)).toMatchObject({
|
||||
ok: false,
|
||||
error: {
|
||||
_tag: "BinaryTargetError",
|
||||
constraint: "file_format_rejected",
|
||||
},
|
||||
});
|
||||
},
|
||||
);
|
||||
|
||||
@@ -227,11 +227,6 @@ it("rejects ELF header tables overlapping the native header", () => {
|
||||
expect(() => readGoBinaryImage(fixture.bytes)).toThrowError(
|
||||
/header|overlap/i,
|
||||
);
|
||||
const declaredSize = createGoBinaryFixture();
|
||||
declaredSize.bytes.writeUInt16LE(8192, 52);
|
||||
expect(() => readGoBinaryImage(declaredSize.bytes)).toThrowError(
|
||||
/truncated|range/i,
|
||||
);
|
||||
});
|
||||
|
||||
it("rejects contradictory aliases when a metadata address maps to different file bytes", () => {
|
||||
|
||||
Reference in New Issue
Block a user