feat(ghidra): admit verified MIPS16 shared ELF images
Admit the verified ELF32 o32 MIPS32r2 MIPS16 shared-image profile after complete source load and relocation inspection. Preserve caller-selected bytes, pin the endian-matched language, and report per-address decoder context. Refuse unverified relocation shapes with explicit reasons. Verified on Linux x64 with Ghidra 12.1.4: eight source-owned public CLI/MCP controls, original-artifact instruction/pseudocode/export replay, snapshot restore and owned cleanup. 152 integrated focused tests, static checks and documentation checks passed. Fixes #1851 Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com> Co-authored-by: Kaoru0822 <208281322+kaoru0822-kitauji@users.noreply.github.com>
This commit is contained in:
co-authored by
factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
Kaoru0822
parent
6395e8d300
commit
e9fe6437a7
@@ -17,7 +17,7 @@ import {
|
||||
import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
|
||||
import type { BinaryTarget } from "../domain/binaryTargetTypes.js";
|
||||
import { err, ok, type Result } from "../domain/result.js";
|
||||
import { readMipsElfAbiFlags } from "./MipsElfAbiFlags.js";
|
||||
import { readMipsElfMetadata } from "./MipsElfMetadata.js";
|
||||
import {
|
||||
resolveAppBundleExecutable,
|
||||
type ResolvedAppBundle,
|
||||
@@ -430,18 +430,23 @@ const readExecutableMetadata = async (
|
||||
parsed.value.mips.elfClass !== 32
|
||||
)
|
||||
return parsed;
|
||||
const abiFlags = await readMipsElfAbiFlags(handle, parsed.value.mips, () =>
|
||||
throwIfTargetResolutionCancelled(signal),
|
||||
const declarations = await readMipsElfMetadata(
|
||||
handle,
|
||||
parsed.value.mips,
|
||||
() => throwIfTargetResolutionCancelled(signal),
|
||||
);
|
||||
if (!abiFlags.ok) return abiFlags;
|
||||
if (!declarations.ok) return declarations;
|
||||
return ok({
|
||||
...parsed.value,
|
||||
mips: {
|
||||
...parsed.value.mips,
|
||||
abiFlags: abiFlags.value.abiFlags,
|
||||
...(abiFlags.value.limitations.length === 0
|
||||
abiFlags: declarations.value.abiFlags,
|
||||
...(declarations.value.sharedLoad === undefined
|
||||
? {}
|
||||
: { limitations: abiFlags.value.limitations }),
|
||||
: { sharedLoad: declarations.value.sharedLoad }),
|
||||
...(declarations.value.limitations.length === 0
|
||||
? {}
|
||||
: { limitations: declarations.value.limitations }),
|
||||
},
|
||||
});
|
||||
};
|
||||
|
||||
@@ -4,24 +4,29 @@ import type {
|
||||
MipsElfMetadata,
|
||||
} from "../domain/binaryTargetTypes.js";
|
||||
import { err, ok, type Result } from "../domain/result.js";
|
||||
import {
|
||||
readMipsElfSharedLoad,
|
||||
type MipsElfRelocationSection,
|
||||
} from "./MipsElfSharedLoad.js";
|
||||
|
||||
/** Observed ABI declarations and coverage of their source tables. */
|
||||
export interface MipsAbiFlagsInspection {
|
||||
/** Observed ABI and load declarations, retaining unavailable source coverage. */
|
||||
export interface MipsElfInspection {
|
||||
readonly abiFlags: MipsAbiFlags | null;
|
||||
readonly limitations: readonly string[];
|
||||
readonly sharedLoad?: MipsElfMetadata["sharedLoad"];
|
||||
}
|
||||
|
||||
/**
|
||||
* Read ELF32 MIPS ABI declarations from the caller's already-open file.
|
||||
* Read ELF32 MIPS ABI and shared-load declarations from the caller's already-open file.
|
||||
* Inspect both typed tables (not section names), including records beyond the
|
||||
* initial header probe. A missing record is unknown, not a default FP ABI.
|
||||
* The caller supplies its cancellation check so its tagged error is preserved.
|
||||
*/
|
||||
export const readMipsElfAbiFlags = async (
|
||||
export const readMipsElfMetadata = async (
|
||||
handle: FileHandle,
|
||||
metadata: MipsElfMetadata,
|
||||
checkCancelled: () => void,
|
||||
): Promise<Result<MipsAbiFlagsInspection, string>> => {
|
||||
): Promise<Result<MipsElfInspection, string>> => {
|
||||
checkCancelled();
|
||||
if (metadata.elfClass !== 32)
|
||||
return err("MIPS ABI record inspection currently supports ELF32 only");
|
||||
@@ -107,6 +112,9 @@ export const readMipsElfAbiFlags = async (
|
||||
if (u16(bytes, 44) === 0xffff || u16(bytes, 48) >= 0xff00)
|
||||
return err("extended or reserved MIPS ELF table numbering is unsupported");
|
||||
let record: Buffer | undefined;
|
||||
let sharedLoad: MipsElfMetadata["sharedLoad"];
|
||||
let programHeaders: Buffer | undefined;
|
||||
const relocationSections: MipsElfRelocationSection[] = [];
|
||||
const limitations: string[] = [];
|
||||
for (const table of tables) {
|
||||
if (table.count === 0) {
|
||||
@@ -135,12 +143,20 @@ export const readMipsElfAbiFlags = async (
|
||||
table.label,
|
||||
);
|
||||
if (!contents.ok) return contents;
|
||||
if (!table.optional && metadata.type === 3) programHeaders = contents.value;
|
||||
let found = false;
|
||||
for (let i = 0; i < count; i += 1) {
|
||||
checkCancelled();
|
||||
const position = i * table.entrySize;
|
||||
if (u32(contents.value, position + table.typeOffset) !== table.recordType)
|
||||
continue;
|
||||
const type = u32(contents.value, position + table.typeOffset);
|
||||
if (metadata.type === 3 && table.optional && (type === 4 || type === 9))
|
||||
relocationSections.push({
|
||||
type,
|
||||
offset: u32(contents.value, position + 16),
|
||||
size: u32(contents.value, position + 20),
|
||||
entrySize: u32(contents.value, position + 36),
|
||||
});
|
||||
if (type !== table.recordType) continue;
|
||||
if (found) return err(`duplicate MIPS ABI records in ${table.label}`);
|
||||
found = true;
|
||||
const offset = u32(contents.value, position + table.dataOffset);
|
||||
@@ -154,7 +170,37 @@ export const readMipsElfAbiFlags = async (
|
||||
record = candidate.value;
|
||||
}
|
||||
}
|
||||
if (record === undefined) return ok({ abiFlags: null, limitations });
|
||||
if (metadata.type === 3 && programHeaders !== undefined) {
|
||||
if (limitations.length > 0)
|
||||
sharedLoad = {
|
||||
status: "unavailable",
|
||||
reason: `MIPS shared-image relocation declaration sources are incomplete. ${limitations.join(" ")}`,
|
||||
};
|
||||
else {
|
||||
const shared = await readMipsElfSharedLoad(
|
||||
programHeaders,
|
||||
little,
|
||||
fileSize,
|
||||
read,
|
||||
checkCancelled,
|
||||
relocationSections,
|
||||
);
|
||||
sharedLoad = shared.ok
|
||||
? shared.value
|
||||
: { status: "unavailable", reason: shared.error };
|
||||
}
|
||||
}
|
||||
const shared =
|
||||
metadata.type === 3
|
||||
? {
|
||||
sharedLoad: sharedLoad ?? {
|
||||
status: "unavailable" as const,
|
||||
reason: "MIPS shared image has no inspected program header table",
|
||||
},
|
||||
}
|
||||
: {};
|
||||
if (record === undefined)
|
||||
return ok({ abiFlags: null, limitations, ...shared });
|
||||
// Preserve declarations verbatim, including unknown versions/values. Provider
|
||||
// admission, not parsing, decides which interpretations have been verified.
|
||||
const abiFlags: MipsAbiFlags = {
|
||||
@@ -170,5 +216,5 @@ export const readMipsElfAbiFlags = async (
|
||||
flags1: u32(record, 16),
|
||||
flags2: u32(record, 20),
|
||||
};
|
||||
return ok({ abiFlags, limitations });
|
||||
return ok({ abiFlags, limitations, ...shared });
|
||||
};
|
||||
@@ -0,0 +1,220 @@
|
||||
import type { MipsElfMetadata } from "../domain/binaryTargetTypes.js";
|
||||
import { err, ok, type Result } from "../domain/result.js";
|
||||
|
||||
type ReadRange = (
|
||||
offset: number,
|
||||
length: number,
|
||||
label: string,
|
||||
) => Promise<Result<Buffer, string>>;
|
||||
|
||||
export interface MipsElfRelocationSection {
|
||||
readonly type: number;
|
||||
readonly offset: number;
|
||||
readonly size: number;
|
||||
readonly entrySize: number;
|
||||
}
|
||||
type SharedLoadFacts = Extract<
|
||||
NonNullable<MipsElfMetadata["sharedLoad"]>,
|
||||
{ status: "complete" }
|
||||
>;
|
||||
|
||||
/** Source ELF facts only; the provider owns interpretation and admission. */
|
||||
export const readMipsElfSharedLoad = async (
|
||||
programHeaders: Buffer,
|
||||
little: boolean,
|
||||
fileSize: number,
|
||||
read: ReadRange,
|
||||
checkCancelled: () => void,
|
||||
sections: readonly MipsElfRelocationSection[],
|
||||
): Promise<Result<SharedLoadFacts, string>> => {
|
||||
const u32 = (bytes: Buffer, offset: number): number =>
|
||||
little ? bytes.readUInt32LE(offset) : bytes.readUInt32BE(offset);
|
||||
const loads: {
|
||||
offset: number;
|
||||
address: number;
|
||||
size: number;
|
||||
memorySize: number;
|
||||
}[] = [];
|
||||
let dynamic: { offset: number; address: number; size: number } | undefined;
|
||||
for (let position = 0; position < programHeaders.length; position += 32) {
|
||||
checkCancelled();
|
||||
const type = u32(programHeaders, position);
|
||||
const offset = u32(programHeaders, position + 4);
|
||||
const size = u32(programHeaders, position + 16);
|
||||
if (type === 1) {
|
||||
const address = u32(programHeaders, position + 8);
|
||||
const memorySize = u32(programHeaders, position + 20);
|
||||
if (
|
||||
offset > fileSize - size ||
|
||||
size > memorySize ||
|
||||
address + memorySize > 0x100000000
|
||||
)
|
||||
return err("invalid or incomplete MIPS PT_LOAD range");
|
||||
loads.push({ offset, address, size, memorySize });
|
||||
}
|
||||
if (type === 2) {
|
||||
if (dynamic !== undefined) return err("duplicate MIPS PT_DYNAMIC tables");
|
||||
dynamic = { offset, address: u32(programHeaders, position + 8), size };
|
||||
}
|
||||
}
|
||||
if (dynamic === undefined)
|
||||
return err("MIPS shared image has no PT_DYNAMIC table");
|
||||
if (dynamic.size === 0 || dynamic.size % 8 !== 0)
|
||||
return err("invalid MIPS ELF32 dynamic table size");
|
||||
if (dynamic.offset > fileSize - dynamic.size)
|
||||
return err("MIPS PT_DYNAMIC range extends beyond the file");
|
||||
const ranges = loads
|
||||
.filter((load) => load.memorySize > 0)
|
||||
.sort((left, right) => left.address - right.address);
|
||||
for (let i = 1; i < ranges.length; i += 1) {
|
||||
checkCancelled();
|
||||
const previous = ranges[i - 1]!;
|
||||
if (ranges[i]!.address < previous.address + previous.memorySize)
|
||||
return err(
|
||||
"overlapping MIPS PT_LOAD memory ranges require separate mapping verification",
|
||||
);
|
||||
}
|
||||
// One normalized index prevents relocation count * program-header count work.
|
||||
const mapped = (address: number, length: number, fileBacked: boolean) => {
|
||||
let low = 0;
|
||||
let high = ranges.length;
|
||||
while (low < high) {
|
||||
const middle = Math.floor((low + high) / 2);
|
||||
if (ranges[middle]!.address <= address) low = middle + 1;
|
||||
else high = middle;
|
||||
}
|
||||
const range = ranges[low - 1];
|
||||
return range !== undefined &&
|
||||
address - range.address <=
|
||||
(fileBacked ? range.size : range.memorySize) - length
|
||||
? range
|
||||
: undefined;
|
||||
};
|
||||
const dynamicMapping = mapped(dynamic.address, dynamic.size, true);
|
||||
if (
|
||||
dynamicMapping === undefined ||
|
||||
dynamicMapping.offset + dynamic.address - dynamicMapping.address !==
|
||||
dynamic.offset
|
||||
)
|
||||
return err(
|
||||
"MIPS PT_DYNAMIC has no unique matching file-backed PT_LOAD range",
|
||||
);
|
||||
|
||||
// Bound temporary storage, not admitted artifact size. ELF32 records are
|
||||
// exact eight-byte structures; every declared record is examined or refused.
|
||||
const chunkBytes = 64 * 1024;
|
||||
const relevant = new Set([2, 7, 8, 9, 17, 18, 19, 20, 23]);
|
||||
const tags = new Map<number, number>();
|
||||
let terminated = false;
|
||||
for (
|
||||
let offset = 0;
|
||||
offset < dynamic.size && !terminated;
|
||||
offset += chunkBytes
|
||||
) {
|
||||
const chunk = await read(
|
||||
dynamic.offset + offset,
|
||||
Math.min(chunkBytes, dynamic.size - offset),
|
||||
"dynamic table",
|
||||
);
|
||||
if (!chunk.ok) return chunk;
|
||||
for (let position = 0; position < chunk.value.length; position += 8) {
|
||||
checkCancelled();
|
||||
const tag = u32(chunk.value, position);
|
||||
if (tag === 0) {
|
||||
terminated = true;
|
||||
break;
|
||||
}
|
||||
if (!relevant.has(tag)) continue;
|
||||
if (tags.has(tag)) return err(`duplicate MIPS dynamic tag ${tag}`);
|
||||
tags.set(tag, u32(chunk.value, position + 4));
|
||||
}
|
||||
}
|
||||
if (!terminated) return err("MIPS dynamic table has no DT_NULL terminator");
|
||||
if ([2, 7, 8, 9, 23].some((tag) => (tags.get(tag) ?? 0) !== 0))
|
||||
return err(
|
||||
"MIPS shared RELA or PLT relocation declarations require separate verification",
|
||||
);
|
||||
const address = tags.get(17);
|
||||
const size = tags.get(18);
|
||||
const stride = tags.get(19);
|
||||
const checkSections = (
|
||||
offset: number,
|
||||
length: number,
|
||||
): string | undefined => {
|
||||
let observed = 0;
|
||||
for (const section of sections) {
|
||||
checkCancelled();
|
||||
if (section.size === 0) continue;
|
||||
if (
|
||||
section.type !== 9 ||
|
||||
section.entrySize !== 8 ||
|
||||
section.offset !== offset ||
|
||||
section.size !== length
|
||||
)
|
||||
return "MIPS section relocation declarations outside the dynamic REL table require separate verification";
|
||||
observed += 1;
|
||||
}
|
||||
return observed > 1
|
||||
? "duplicate MIPS section relocation declarations require separate verification"
|
||||
: undefined;
|
||||
};
|
||||
const emptyRelocations = (): Result<SharedLoadFacts, string> => {
|
||||
const reason = checkSections(0, 0);
|
||||
return reason === undefined
|
||||
? ok({
|
||||
status: "complete",
|
||||
relocationCount: 0,
|
||||
relocationTypes: [],
|
||||
symbolRelativeCount: 0,
|
||||
})
|
||||
: err(reason);
|
||||
};
|
||||
if (address === undefined && size === undefined && stride === undefined)
|
||||
return emptyRelocations();
|
||||
if (
|
||||
address === undefined ||
|
||||
size === undefined ||
|
||||
stride !== 8 ||
|
||||
size % 8 !== 0
|
||||
)
|
||||
return err(
|
||||
"incomplete or invalid MIPS DT_REL/DT_RELSZ/DT_RELENT declaration",
|
||||
);
|
||||
if (size === 0) return emptyRelocations();
|
||||
const mapping = mapped(address, size, true);
|
||||
if (mapping === undefined)
|
||||
return err(
|
||||
"MIPS DT_REL range has no unique complete file-backed PT_LOAD mapping",
|
||||
);
|
||||
const fileOffset = mapping.offset + address - mapping.address;
|
||||
const sectionReason = checkSections(fileOffset, size);
|
||||
if (sectionReason !== undefined) return err(sectionReason);
|
||||
let symbolRelativeCount = 0;
|
||||
const types = new Set<number>();
|
||||
for (let offset = 0; offset < size; offset += chunkBytes) {
|
||||
const chunk = await read(
|
||||
fileOffset + offset,
|
||||
Math.min(chunkBytes, size - offset),
|
||||
"dynamic REL records",
|
||||
);
|
||||
if (!chunk.ok) return chunk;
|
||||
for (let position = 0; position < chunk.value.length; position += 8) {
|
||||
checkCancelled();
|
||||
const info = u32(chunk.value, position + 4);
|
||||
const type = info & 0xff;
|
||||
const relocationAddress = u32(chunk.value, position);
|
||||
if (type === 3 && mapped(relocationAddress, 4, false) === undefined)
|
||||
return err(
|
||||
"MIPS REL32 destination has no unique complete PT_LOAD memory range",
|
||||
);
|
||||
types.add(type);
|
||||
if (type === 3 && info >>> 8 !== 0) symbolRelativeCount += 1;
|
||||
}
|
||||
}
|
||||
return ok({
|
||||
status: "complete",
|
||||
relocationCount: size / 8,
|
||||
relocationTypes: [...types].sort((left, right) => left - right),
|
||||
symbolRelativeCount,
|
||||
});
|
||||
};
|
||||
Reference in New Issue
Block a user