fix(ghidra): budget Swift literal decoding and tighten use sites

Large literals now draw on one heap budget per dossier, measured once
before decoding, instead of a separate check per literal. A literal that
does not fit is listed in a new swift_string_literal_omissions field
with its address, byte length and reason, so consumers read omissions
from structured data rather than from limitation text.

strings_names comparison checks referenced strings and names first and
reports a change there even when Swift literal coverage differs; it
returns unknown only when those facts match and literal coverage is
absent on one side or partial.

A computed jump counts as a tail call only when it has no resolved
target inside the function, so jump tables no longer qualify, and a
return requires a RETURN p-code operation, so traps no longer qualify.

Decoded literals keep control characters, which Swift strings may
contain and JSON escapes. The Swift verifier builds the literal fixture
for arm64 on any Mac host and now also covers the empty string and a
literal containing a tab.
This commit is contained in:
Omisakin Joshua
2026-10-12 10:42:03 +01:00
parent 702dc9f932
commit facd58973a
11 changed files with 256 additions and 93 deletions
+1
View File
@@ -97,6 +97,7 @@ const nativeViewSchema = z.strictObject({
"referenced_strings",
"referenced_names",
"swift_string_literals",
"swift_string_literal_omissions",
"native_api",
"value_flow_summary",
"value_flow_operations",
@@ -121,6 +121,7 @@ const nativeRows = (
referenced_strings: dossier.referenced_strings,
referenced_names: dossier.referenced_names,
swift_string_literals: dossier.swift_string_literals,
swift_string_literal_omissions: dossier.swift_string_literal_omissions,
value_flow_operations: flow?.operations,
value_flow_def_use: flow?.def_use,
value_flow_effects: flow?.effects,
+38 -3
View File
@@ -628,13 +628,48 @@ describe("function comparison Swift string literals", () => {
),
).toMatchObject({
status: "unknown",
left_count: 0,
right_count: null,
limitations: [
"Swift String literal coverage differs; one dossier did not record decoded literals.",
"Swift String literal coverage differs or is partial; referenced strings and names match, but decoded literals were not compared.",
],
});
});
it("reports a referenced name change even when Swift literal coverage differs", () => {
const named = functionDossierSchema.parse({
...dossier("return 0;", "0x2000"),
referenced_names: [
{ address: "0x3000", value: "helper", source_address: "0x2000" },
],
});
expect(
stringsDimension("7", withLiterals("0x1000", []), "8", named),
).toMatchObject({ status: "changed" });
});
it("does not equate a partial literal record with a complete one", () => {
const partial = functionDossierSchema.parse({
...withLiterals("0x2000", ["SleepDisabled"]),
swift_string_literal_omissions: [
{
source_address: "0x2000",
representation: "large",
address: "0x3000",
byte_length: 64,
reason: "capacity",
registers: ["x0", "x1"],
words: ["0xd000000000000040", "0x8000000000002fe0"],
},
],
});
expect(
stringsDimension(
"9",
withLiterals("0x1000", ["SleepDisabled"]),
"a",
partial,
),
).toMatchObject({ status: "unknown" });
});
});
const expectInlineComparisonEvidence = (
+29 -20
View File
@@ -139,20 +139,12 @@ const compareStringsAndNames = (
right: FunctionSnapshot,
context: ComparisonContext,
): FunctionDimension => {
const leftRecorded = left.dossier.swift_string_literals !== undefined;
const rightRecorded = right.dossier.swift_string_literals !== undefined;
if (leftRecorded !== rightRecorded)
return unresolvedDimension({
dimension: "strings_names",
links: context.links,
leftCount: recordedStringFactCount(left),
rightCount: recordedStringFactCount(right),
limitations: [
"Swift String literal coverage differs; one dossier did not record decoded literals.",
],
});
const leftValues = stringAndNameProjection(left);
const rightValues = stringAndNameProjection(right);
const complete =
swiftLiteralCoverage(left) === swiftLiteralCoverage(right) &&
swiftLiteralCoverage(left) !== "partial";
// Facts both dossiers record decide a change before Swift literal coverage can.
const leftValues = stringAndNameProjection(left, complete);
const rightValues = stringAndNameProjection(right, complete);
if (leftValues === null || rightValues === null)
return unresolvedDimension({
dimension: "strings_names",
@@ -163,15 +155,32 @@ const compareStringsAndNames = (
"Reference source locations could not be normalized to function offsets.",
],
});
return compareValues("strings_names", leftValues, rightValues, context);
const compared = compareValues(
"strings_names",
leftValues,
rightValues,
context,
);
if (complete || compared.status === "changed") return compared;
return unresolvedDimension({
dimension: "strings_names",
links: context.links,
leftCount: null,
rightCount: null,
limitations: [
"Swift String literal coverage differs or is partial; referenced strings and names match, but decoded literals were not compared.",
],
});
};
const recordedStringFactCount = (snapshot: FunctionSnapshot): number | null =>
const swiftLiteralCoverage = (
snapshot: FunctionSnapshot,
): "absent" | "complete" | "partial" =>
snapshot.dossier.swift_string_literals === undefined
? null
: snapshot.dossier.referenced_strings.length +
snapshot.dossier.referenced_names.length +
snapshot.dossier.swift_string_literals.length;
? "absent"
: (snapshot.dossier.swift_string_literal_omissions ?? []).length > 0
? "partial"
: "complete";
const compareReferences = (
left: FunctionSnapshot,
@@ -145,6 +145,7 @@ export const commentProjection = (
export const stringAndNameProjection = (
snapshot: FunctionSnapshot,
includeSwiftLiterals = true,
): readonly unknown[] | null => {
const values = [
...snapshot.dossier.referenced_strings.map(
@@ -167,7 +168,10 @@ export const stringAndNameProjection = (
value,
}),
),
...(snapshot.dossier.swift_string_literals ?? []).map(
...(includeSwiftLiterals
? (snapshot.dossier.swift_string_literals ?? [])
: []
).map(
({
source_address: sourceAddress,
value,
+21
View File
@@ -321,6 +321,21 @@ export const swiftStringLiteralSchema = z.discriminatedUnion("representation", [
}),
]);
/** A large Swift literal whose layout matched but whose text was not decoded. */
export const swiftStringLiteralOmissionSchema = z.strictObject({
source_address: swiftStringLiteralFields.source_address,
representation: z.literal("large"),
address: z.string().describe("Address of the literal's bytes."),
byte_length: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
reason: z
.literal("capacity")
.describe(
"The text did not fit the provider's memory budget for this dossier.",
),
registers: swiftStringLiteralFields.registers,
words: swiftStringLiteralFields.words,
});
/** Observed endpoints with complete or partial reference classification evidence. */
export const referenceEdgeSchema = z
.object({
@@ -378,6 +393,12 @@ export const functionDossierSchema = z
.describe(
"Swift String literals decoded from constant register values. Absent when the provider does not decode them for this target.",
),
swift_string_literal_omissions: z
.array(swiftStringLiteralOmissionSchema)
.exactOptional()
.describe(
"Literals that matched the Swift layout but were not decoded. Empty when swift_string_literals is complete for the examined use sites.",
),
basic_blocks: z.array(
z
.object({
+19
View File
@@ -515,6 +515,25 @@ const malformedOutputs = (): Array<
),
],
...malformedSwiftStringLiterals(dossier),
[
"non-canonical Swift literal omission address",
"analyze_function",
{
...dossier,
swift_string_literals: [],
swift_string_literal_omissions: [
{
source_address: "0x401004",
representation: "large",
address: "402240",
byte_length: 39,
reason: "capacity",
registers: ["x0", "x1"],
words: ["0xd000000000000027", "0x8000000000402220"],
},
],
},
],
[
"non-canonical native API target",
"analyze_function",
+3
View File
@@ -311,6 +311,9 @@ const ghidraFunctionDossier = functionDossierSchema
({ address, source_address }) =>
address === null ? [source_address] : [address, source_address],
),
...(value.swift_string_literal_omissions ?? []).flatMap(
({ address, source_address }) => [address, source_address],
),
...value.basic_blocks.flatMap(({ start, end, successors }) => [
start,
end,