From 2a6786168a3662493c47f5babfc9598e932a9ea2 Mon Sep 17 00:00:00 2001 From: morluto <76467478+morluto@users.noreply.github.com> Date: Thu, 19 Nov 2026 20:38:54 -0500 Subject: [PATCH] refactor(apk): project scheme limits from the parser (#12662) * refactor(apk): project scheme limits from the parser * fix(apk): establish scheme record framing before capacity --- .../resource-constraint-constructor.json | 2 +- src/apkSignature/ApkSignatureProvider.ts | 12 +- src/apkSignature/apkSignatureFailures.test.ts | 10 -- src/apkSignature/apkSignatureFailures.ts | 30 ++-- .../apkSignature/apkSignatureSchemes.test.ts | 152 +++++++++++------- .../apkSignature/apkSignatureSchemes.ts | 71 ++++---- .../apkSignatureLimitsCliMcp.test.ts | 66 ++++++++ 7 files changed, 222 insertions(+), 121 deletions(-) diff --git a/scripts/verify/baselines/resource-constraint-constructor.json b/scripts/verify/baselines/resource-constraint-constructor.json index 7c95c60f4e..9ae269390c 100644 --- a/scripts/verify/baselines/resource-constraint-constructor.json +++ b/scripts/verify/baselines/resource-constraint-constructor.json @@ -6,7 +6,7 @@ "src/android/JadxFailure.ts": 2, "src/android/JadxSession.ts": 2, "src/apkSignature/ApkSignatureAdmission.ts": 1, - "src/apkSignature/apkSignatureFailures.ts": 6, + "src/apkSignature/apkSignatureFailures.ts": 5, "src/apktool/ApktoolConfiguration.ts": 1, "src/application/JsonAuthenticationHeadroom.ts": 2, "src/application/JsonInputFile.ts": 3, diff --git a/src/apkSignature/ApkSignatureProvider.ts b/src/apkSignature/ApkSignatureProvider.ts index b9ebff7560..ffbea41808 100644 --- a/src/apkSignature/ApkSignatureProvider.ts +++ b/src/apkSignature/ApkSignatureProvider.ts @@ -165,12 +165,13 @@ interface DecodedScheme { const lineageOf = ( signer: ApkSigner, + version: Exclude, ): Result => { const attribute = signer.attributes.find( (a) => a.id === PROOF_OF_ROTATION_ATTR_ID, ); if (attribute === undefined) return ok({ present: false }); - const nodes = decodeRotationLineage(attribute.value); + const nodes = decodeRotationLineage(attribute.value, version); if (nodes.ok) return ok({ present: true, nodes: nodes.value }); // A malformed lineage is reported, not dropped; an over-cap lineage is refused. return nodes.error.kind === "malformed-signer" @@ -589,10 +590,7 @@ const sourceStampFacts = ( : { present: true, certificate: null, - decode_error: - certificate.error.kind === "malformed-signer" - ? certificate.error.detail - : `more ${certificate.error.resource} than ${String(certificate.error.limit)}`, + decode_error: certificate.error.detail, }; }; @@ -610,7 +608,9 @@ const decodeScheme = ( const decoded: DecodedSigner[] = []; for (const signer of signers.value.signers) { const rotation = - version === "v2" ? ok({ present: false } as const) : lineageOf(signer); + version === "v2" + ? ok({ present: false } as const) + : lineageOf(signer, version); if (!rotation.ok) return err(mapApkSchemeError(rotation.error, version)); decoded.push({ signer, rotation: rotation.value }); } diff --git a/src/apkSignature/apkSignatureFailures.test.ts b/src/apkSignature/apkSignatureFailures.test.ts index 147b67def1..963bfead7b 100644 --- a/src/apkSignature/apkSignatureFailures.test.ts +++ b/src/apkSignature/apkSignatureFailures.test.ts @@ -3,7 +3,6 @@ import { projectAnalysisError } from "../domain/analysisErrorProjection.js"; import { apkOutputBudgetError, mapApkBlockError, - mapApkSchemeError, mapCentralDirectoryError, v1SignerCapacityError, } from "./apkSignatureFailures.js"; @@ -19,15 +18,6 @@ it.each([ "max_signing_block_pairs", 4096, ], - [ - "scheme signers", - mapApkSchemeError( - { kind: "budget-exceeded", resource: "signers", limit: 32 }, - "v2", - ), - "max_signers", - 32, - ], [ "v1 entries", mapCentralDirectoryError({ diff --git a/src/apkSignature/apkSignatureFailures.ts b/src/apkSignature/apkSignatureFailures.ts index 1569520cf3..c29ac0cde2 100644 --- a/src/apkSignature/apkSignatureFailures.ts +++ b/src/apkSignature/apkSignatureFailures.ts @@ -20,6 +20,7 @@ import { cancelledBy, carriedReason, } from "../domain/analysisErrorCore.js"; +import { parseLimitConstraint } from "../domain/parseFailureAnalysisError.js"; import type { ApkSchemeError } from "../domain/apkSignature/apkSignatureSchemes.js"; import type { ApkSigningBlockError } from "../domain/apkSignature/apkSigningBlock.js"; import type { ApkCentralDirectoryError } from "../domain/apkSignature/apkV1Signature.js"; @@ -89,21 +90,20 @@ export const mapApkBlockError = ( export const mapApkSchemeError = ( error: ApkSchemeError, scheme: string, -): AnalysisError => - error.kind === "malformed-signer" - ? inputError( - `Malformed APK Signature Scheme ${scheme} block: ${error.detail}.`, - ) - : new AnalysisResourceConstraintError( - OPERATION, - "capacity", - `APK Signature Scheme ${scheme} holds more ${error.resource} than the ${String(error.limit)} limit.`, - { [`max_${error.resource.replace(/-/g, "_")}`]: error.limit }, - fixedAllowanceOptions( - `The APK Signature Scheme ${scheme} allowance of ${String(error.limit)} ${error.resource} (this release has no runtime override)`, - "count", - ), - ); +): AnalysisError => { + if (error.kind === "malformed-signer") + return inputError( + `Malformed APK Signature Scheme ${scheme} block: ${error.detail}.`, + ); + const { name, maximum } = error.failure.limit; + return parseLimitConstraint(OPERATION, "capacity", error, { + legacyMaximumKey: `max_${name.replace(/-/g, "_")}`, + ...fixedAllowanceOptions( + `The APK Signature Scheme ${scheme} allowance of ${String(maximum)} ${name} (this release has no runtime override)`, + "count", + ), + }); +}; /** A central directory that cannot be walked leaves v1 presence unknown: refuse. */ export const mapCentralDirectoryError = ( diff --git a/src/domain/apkSignature/apkSignatureSchemes.test.ts b/src/domain/apkSignature/apkSignatureSchemes.test.ts index 3c297c3c3e..7611fe9032 100644 --- a/src/domain/apkSignature/apkSignatureSchemes.test.ts +++ b/src/domain/apkSignature/apkSignatureSchemes.test.ts @@ -127,7 +127,7 @@ describe("APK scheme signer decoder", () => { "refuses lineage nodes missing required algorithm/signature framing", ({ node }) => { expect( - decodeRotationLineage(Uint8Array.from([...u32(1), ...lp(node)])), + decodeRotationLineage(Uint8Array.from([...u32(1), ...lp(node)]), "v3"), ).toMatchObject({ ok: false, error: { kind: "malformed-signer" } }); }, ); @@ -184,7 +184,7 @@ describe("APK scheme signer decoder", () => { expect(result.error.kind).toBe("malformed-signer"); }); - it("names the failing signer and keeps a cap overrun distinct from malformed input", () => { + it("names the failing signer", () => { const truncated = decodeSigners( Uint8Array.from(seq([lp([...seq([digestElement]), ...u32(99)])])), "v3", @@ -195,63 +195,6 @@ describe("APK scheme signer decoder", () => { kind: "malformed-signer", detail: expect.stringContaining("signer 0") as string, }); - const signedData = [ - ...seq([digestElement]), - ...seq([CERT_DER]), - ...seq([]), - ]; - const tooMany = decodeSigners( - Uint8Array.from( - seq(Array.from({ length: MAX_SIGNERS + 1 }, () => lp(signedData))), - ), - "v2", - ); - expect(tooMany.ok).toBe(false); - if (!tooMany.ok) - expect(tooMany.error).toEqual({ - kind: "budget-exceeded", - resource: "signers", - limit: MAX_SIGNERS, - }); - }); - - it("decodes lineage nodes with each node's own retained flags", () => { - const node = (cert: number[], flags: number): number[] => - lp([ - ...lp([...lp(cert), ...u32(0x0103)]), - ...u32(flags), - ...u32(0x0103), - ...lp([1]), - ]); - const lineage = decodeRotationLineage( - Uint8Array.from([...u32(1), ...node([1, 2], 22), ...node([3, 4], 21)]), - ); - expect(lineage.ok).toBe(true); - if (!lineage.ok) return; - expect(lineage.value.map((n) => [[...n.certificate], n.flags])).toEqual([ - [[1, 2], 22], - [[3, 4], 21], - ]); - }); - - it("refuses an unknown lineage version and an over-cap lineage", () => { - const badVersion = decodeRotationLineage(Uint8Array.from(u32(2))); - expect(badVersion.ok).toBe(false); - if (!badVersion.ok) expect(badVersion.error.kind).toBe("malformed-signer"); - const node = lp([ - ...lp([...lp([1]), ...u32(0x0103)]), - ...u32(0), - ...u32(0x0103), - ...lp([]), - ]); - const tooLong = decodeRotationLineage( - Uint8Array.from([ - ...u32(1), - ...Array.from({ length: MAX_LINEAGE_NODES + 1 }, () => node).flat(), - ]), - ); - expect(tooLong.ok).toBe(false); - if (!tooLong.ok) expect(tooLong.error.kind).toBe("budget-exceeded"); }); it("maps signature-algorithm ids to content-digest algorithms", () => { @@ -262,3 +205,94 @@ describe("APK scheme signer decoder", () => { expect(contentDigestAlgorithm(0x9999)).toBeNull(); }); }); + +it("distinguishes an extra framed signer from an incomplete frame at capacity", () => { + const signer = schemeValue([ + ...seq([digestElement]), + ...seq([CERT_DER]), + ...seq([]), + ]).subarray(4); + const prefix = Array.from({ length: MAX_SIGNERS }, () => [...signer]).flat(); + expect(decodeSigners(Uint8Array.from(lp(prefix)), "v2").ok).toBe(true); + expect( + decodeSigners(Uint8Array.from(lp([...prefix, ...signer])), "v2"), + ).toMatchObject({ + ok: false, + error: { + kind: "limit", + failure: { limit: { name: "signers", maximum: MAX_SIGNERS } }, + }, + }); + for (const incomplete of [[1], [...u32(3), 1]]) { + expect( + decodeSigners(Uint8Array.from(lp([...prefix, ...incomplete])), "v2"), + ).toMatchObject({ + ok: false, + error: { kind: "malformed-signer", detail: "signers element truncated" }, + }); + } +}); + +describe("APK proof-of-rotation lineage", () => { + it("decodes lineage nodes with each node's own retained flags", () => { + const node = (cert: number[], flags: number): number[] => + lp([ + ...lp([...lp(cert), ...u32(0x0103)]), + ...u32(flags), + ...u32(0x0103), + ...lp([1]), + ]); + const lineage = decodeRotationLineage( + Uint8Array.from([...u32(1), ...node([1, 2], 22), ...node([3, 4], 21)]), + "v3", + ); + expect(lineage.ok).toBe(true); + if (!lineage.ok) return; + expect(lineage.value.map((n) => [[...n.certificate], n.flags])).toEqual([ + [[1, 2], 22], + [[3, 4], 21], + ]); + }); + + it("distinguishes incomplete lineage frames from an extra framed node at capacity", () => { + const badVersion = decodeRotationLineage(Uint8Array.from(u32(2)), "v3"); + expect(badVersion.ok).toBe(false); + if (!badVersion.ok) expect(badVersion.error.kind).toBe("malformed-signer"); + const node = lp([ + ...lp([...lp([1]), ...u32(0x0103)]), + ...u32(0), + ...u32(0x0103), + ...lp([]), + ]); + const prefix = [ + ...u32(1), + ...Array.from({ length: MAX_LINEAGE_NODES }, () => node).flat(), + ]; + expect(decodeRotationLineage(Uint8Array.from(prefix), "v3.1").ok).toBe( + true, + ); + const tooLong = decodeRotationLineage( + Uint8Array.from([...prefix, ...node]), + "v3.1", + ); + expect(tooLong.ok).toBe(false); + if (!tooLong.ok) + expect(tooLong.error).toMatchObject({ + kind: "limit", + failure: { + limit: { name: "lineage-nodes", maximum: MAX_LINEAGE_NODES }, + }, + }); + for (const incomplete of [[1], [...u32(3), 1]]) { + expect( + decodeRotationLineage( + Uint8Array.from([...prefix, ...incomplete]), + "v3.1", + ), + ).toMatchObject({ + ok: false, + error: { kind: "malformed-signer", detail: "lineage node truncated" }, + }); + } + }); +}); diff --git a/src/domain/apkSignature/apkSignatureSchemes.ts b/src/domain/apkSignature/apkSignatureSchemes.ts index e4756de987..1c5128b833 100644 --- a/src/domain/apkSignature/apkSignatureSchemes.ts +++ b/src/domain/apkSignature/apkSignatureSchemes.ts @@ -9,23 +9,20 @@ * certificate DER, SDK bounds, and additional attributes. Certificate facts and * digest recomputation are layered on top. Dependency-free and bounded: a short * or inconsistent length is a `malformed-signer` error, and a count past a - * resource admission cap is a distinct `budget-exceeded` error, never conflated. + * resource admission cap is a distinct typed parse limit. */ import { BinaryReader } from "../binaryContainer.js"; +import { decodeLimit, type ParseFailureError } from "../parseFailure.js"; import { type Result, err, ok } from "../result.js"; export type ApkSchemeVersion = "v2" | "v3" | "v3.1"; -export type ApkSchemeError = - | { - readonly kind: "malformed-signer"; - readonly detail: string; - } - | { - readonly kind: "budget-exceeded"; - readonly resource: string; - readonly limit: number; - }; +interface ApkMalformedSigner { + readonly kind: "malformed-signer"; + readonly detail: string; +} + +export type ApkSchemeError = ApkMalformedSigner | ParseFailureError<"limit">; export interface ApkSignerDigest { /** APK signature-algorithm id (e.g. 0x0103 = RSA-PKCS1 SHA-256). */ @@ -106,23 +103,36 @@ class LeReader { } } -const malformed = (detail: string): Result => +const malformed = (detail: string): Result => err({ kind: "malformed-signer", detail }); +const schemeLimit = ( + version: ApkSchemeVersion, + name: string, + maximum: number, +): Result> => + err( + decodeLimit( + "apk-signature-scheme", + `APK Signature Scheme ${version} holds more ${name} than the ${String(maximum)} limit.`, + { name, maximum }, + ), + ); + /** Split a length-prefixed sequence into its length-prefixed elements. */ const elements = ( seq: Uint8Array | null, what: string, + version: ApkSchemeVersion, limit = MAX_ELEMENTS, ): Result => { if (seq === null) return malformed(`${what} sequence missing or truncated`); const reader = new LeReader(seq); const out: Uint8Array[] = []; while (reader.remaining > 0) { - if (out.length >= limit) - return err({ kind: "budget-exceeded", resource: what, limit }); const el = reader.lenChunk(); if (el === null) return malformed(`${what} element truncated`); + if (out.length >= limit) return schemeLimit(version, what, limit); out.push(el); } return ok(out); @@ -131,13 +141,14 @@ const elements = ( const decodeAlgorithmRecords = ( seq: Uint8Array | null, what: string, + version: ApkSchemeVersion, record: ( algorithmId: number, bytes: Uint8Array, uninterpretedBytes: number, ) => T, ): Result => { - const items = elements(seq, what); + const items = elements(seq, what, version); if (!items.ok) return items; const records: T[] = []; for (const item of items.value) { @@ -153,8 +164,9 @@ const decodeAlgorithmRecords = ( const decodeAttributes = ( seq: Uint8Array | null, + version: ApkSchemeVersion, ): Result => { - const items = elements(seq, "attributes"); + const items = elements(seq, "attributes", version); if (!items.ok) return items; const attributes: ApkSignerAttribute[] = []; for (const item of items.value) { @@ -177,6 +189,7 @@ const decodeSignedData = ( const digests = decodeAlgorithmRecords( reader.lenChunk(), "digests", + version, (algorithmId, digest, uninterpretedBytes) => ({ algorithmId, digest, @@ -184,7 +197,7 @@ const decodeSignedData = ( }), ); if (!digests.ok) return digests; - const certificates = elements(reader.lenChunk(), "certificates"); + const certificates = elements(reader.lenChunk(), "certificates", version); if (!certificates.ok) return certificates; let minSdk: number | null = null; let maxSdk: number | null = null; @@ -194,7 +207,7 @@ const decodeSignedData = ( if (minSdk === null || maxSdk === null) return malformed("min/max SDK truncated"); } - const attributes = decodeAttributes(reader.lenChunk()); + const attributes = decodeAttributes(reader.lenChunk(), version); if (!attributes.ok) return attributes; return ok({ certificates: certificates.value, @@ -227,6 +240,7 @@ const decodeSigner = ( const signatures = decodeAlgorithmRecords( reader.lenChunk(), "signatures", + version, (algorithmId, signature, uninterpretedBytes) => ({ algorithmId, signature, @@ -255,7 +269,7 @@ export const decodeSigners = ( version: ApkSchemeVersion, ): Result => { const reader = new LeReader(value); - const chunks = elements(reader.lenChunk(), "signers", MAX_SIGNERS); + const chunks = elements(reader.lenChunk(), "signers", version, MAX_SIGNERS); if (!chunks.ok) return chunks; const signers: ApkSigner[] = []; for (const [index, chunk] of chunks.value.entries()) { @@ -290,22 +304,19 @@ export interface ApkLineageNode { */ export const decodeRotationLineage = ( value: Uint8Array, + version: Exclude, ): Result => { const reader = new LeReader(value); - const version = reader.u32(); - if (version === null) return malformed("lineage version missing"); - if (version !== LINEAGE_VERSION) - return malformed(`unsupported lineage version ${String(version)}`); + const lineageVersion = reader.u32(); + if (lineageVersion === null) return malformed("lineage version missing"); + if (lineageVersion !== LINEAGE_VERSION) + return malformed(`unsupported lineage version ${String(lineageVersion)}`); const nodes: ApkLineageNode[] = []; while (reader.remaining > 0) { - if (nodes.length >= MAX_LINEAGE_NODES) - return err({ - kind: "budget-exceeded", - resource: "lineage-nodes", - limit: MAX_LINEAGE_NODES, - }); const node = reader.lenChunk(); if (node === null) return malformed("lineage node truncated"); + if (nodes.length >= MAX_LINEAGE_NODES) + return schemeLimit(version, "lineage-nodes", MAX_LINEAGE_NODES); const nodeReader = new LeReader(node); const signedData = nodeReader.lenChunk(); const flags = nodeReader.u32(); @@ -331,7 +342,7 @@ export const decodeRotationLineage = ( */ export const decodeSourceStampCertificate = ( value: Uint8Array, -): Result => { +): Result => { const stampData = new LeReader(value).lenChunk(); if (stampData === null) return malformed("source stamp data truncated"); const certificate = new LeReader(stampData).lenChunk(); diff --git a/tests/acceptance/apkSignatureLimitsCliMcp.test.ts b/tests/acceptance/apkSignatureLimitsCliMcp.test.ts index 70d3418f15..7725ba6c9b 100644 --- a/tests/acceptance/apkSignatureLimitsCliMcp.test.ts +++ b/tests/acceptance/apkSignatureLimitsCliMcp.test.ts @@ -10,6 +10,11 @@ import { parseMcpToolError } from "../fixtures/mcpToolError.js"; import { connectLocalToolsMcp } from "../fixtures/localToolsMcp.js"; import { createTestTempDirectory } from "../fixtures/temporaryDirectory.js"; import { + APK_SIGNATURE_V2_ID, + APK_SIGNATURE_V3_ID, + LEAF_CERTIFICATE, + v2SchemeValue, + v3SchemeValue, withSigningBlock, zipWith, } from "../fixtures/apkSignature/v1SignatureBlock.js"; @@ -80,3 +85,64 @@ cliTest( } }, ); + +cliTest( + "preserves the fixed signer and lineage refusals through CLI and MCP", + async ({ cli }) => { + const root = await createTestTempDirectory("rea-apk-scheme-limit-"); + const archive = await zipWith([ + { name: "AndroidManifest.xml", data: Uint8Array.of(3, 0, 8, 0) }, + ]); + const signer = v2SchemeValue(LEAF_CERTIFICATE).subarray(4); + const signerLength = Buffer.alloc(4); + signerLength.writeUInt32LE(signer.length * 33); + const { call } = await connectLocalToolsMcp({ + REA_MCP_OUTPUT_SCHEMA_PROFILE: "off", + }); + for (const { id, value, scheme, boundary, key } of [ + { + id: APK_SIGNATURE_V2_ID, + value: Buffer.concat([ + signerLength, + ...Array.from({ length: 33 }, () => signer), + ]), + scheme: "v2", + boundary: "signers", + key: "max_signers", + }, + { + id: APK_SIGNATURE_V3_ID, + value: v3SchemeValue( + null, + Array.from({ length: 33 }, () => LEAF_CERTIFICATE), + ), + scheme: "v3", + boundary: "lineage-nodes", + key: "max_lineage_nodes", + }, + ]) { + const path = join(root, `${scheme}.apk`); + await writeFile(path, withSigningBlock(archive, [{ id, value }])); + const reply = await cli.run({ + arguments: ["inspect-apk-signature", path, "--json"], + }); + expect(reply.exitCode, reply.stderr).toBe(1); + const error = analysisErrorProjectionSchema.parse(reply.json); + expect(error).toMatchObject({ + code: "resource_constraint", + retryable: false, + details: { + operation: "inspect_apk_signature", + resource: "capacity", + reason: `APK Signature Scheme ${scheme} holds more ${boundary} than the 32 limit.`, + }, + }); + expect(error.details?.reported_limits).toEqual({ [key]: 32 }); + expect(error.remediation.action).toBe( + `The APK Signature Scheme ${scheme} allowance of 32 ${boundary} (this release has no runtime override) is a fixed count. Waiting for an active analysis to finish does not raise it. Repeating the unchanged request fails the same way.`, + ); + const rejected = await call("inspect_apk_signature", { path }); + expect(parseMcpToolError(rejected).error).toEqual(error); + } + }, +);