@futpib/parser 1.0.1 → 1.0.2

package/src/androidPackageParser.ts

@@ -0,0 +1,440 @@
+import invariant from 'invariant';
+import { createArrayParser } from './arrayParser.js';
+import { createOptionalParser } from './optionalParser.js';
+import { type Parser, setParserName } from './parser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+import {
+	zip64EndOfCentralDirectoryLocatorParser,
+	zip64EndOfCentralDirectoryRecordParser,
+	zipArchiveDecryptionHeaderParser,
+	zipArchiveExtraDataRecordParser,
+	ZipCentralDirectoryHeader,
+	zipCentralDirectoryHeaderParser,
+	ZipEndOfCentralDirectoryRecord,
+	zipEndOfCentralDirectoryRecordParser,
+	zipFromZipSegments,
+	ZipLocalFile,
+	zipLocalFileParser,
+} from './zipParser.js';
+import { AndroidPackageSignatureV2AdditionalAttribute, AndroidPackageSignatureV2Digest, AndroidPackageSignatureV2Signature, AndroidPackageSignatureV2SignedData, AndroidPackageSignatureV2Signer, type AndroidPackage, type AndroidPackageSigningBlock, type AndroidPackageSigningBlockPair } from './androidPackage.js';
+import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+import { parserCreatorCompose } from './parserCreatorCompose.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createSliceBoundedParser } from './sliceBoundedParser.js';
+import { createDisjunctionParser } from './disjunctionParser.js';
+import { createExactElementParser } from './exactElementParser.js';
+import { createParserConsumedSequenceParser } from './parserConsumedSequenceParser.js';
+import { createDebugLogInputParser } from './debugLogInputParser.js';
+import { createDebugLogParser } from './debugLogParser.js';
+import { createElementParser } from './elementParser.js';
+
+// https://source.android.com/docs/security/features/androidPackagesigning/v2#androidPackage-signing-block
+
+const uint32LEParser: Parser<number, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser(4),
+	array => Buffer.from(array).readUInt32LE(),
+);
+
+setParserName(uint32LEParser, 'uint32LEParser');
+
+const uint64LEParser: Parser<bigint, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser(8),
+	array => Buffer.from(array).readBigUInt64LE(),
+);
+
+setParserName(uint64LEParser, 'uint64LEParser');
+
+const createUint32LengthPrefixedParser = <T>(createInnerParser: (length: number) => Parser<T, Uint8Array>): Parser<T, Uint8Array> => parserCreatorCompose(
+	() => uint32LEParser,
+	length => createInnerParser(length),
+)();
+
+const createUint64LengthPrefixedParser = <T>(createInnerParser: (length: bigint) => Parser<T, Uint8Array>): Parser<T, Uint8Array> => parserCreatorCompose(
+	() => uint64LEParser,
+	length => createInnerParser(length),
+)();
+
+const createUint32LengthPrefixedSliceBoundedParser = <T>(innerParser: Parser<T, Uint8Array>): Parser<T, Uint8Array> => createUint32LengthPrefixedParser(
+	length => createSliceBoundedParser(innerParser, length),
+);
+
+const createUint32LengthPrefixedSliceBoundedArrayParser = <T>(innerParser: Parser<T, Uint8Array>): Parser<T[], Uint8Array> => createUint32LengthPrefixedSliceBoundedParser(createArrayParser(innerParser));
+
+type AndroidPackageSigningBlockZeroPaddingPair = {
+	type: 'zeroPadding';
+	length: number;
+};
+
+const createAndroidPackageSigningBlockZeroPaddingPairInnerParser = (length: number): Parser<AndroidPackageSigningBlockZeroPaddingPair, Uint8Array> => {
+	const androidPackageSigningBlockZeroPaddingPairInnerParser: Parser<AndroidPackageSigningBlockZeroPaddingPair, Uint8Array> = promiseCompose(
+		createTupleParser([
+			createExactSequenceParser<Uint8Array>(Buffer.from('77657242', 'hex')),
+			createFixedLengthSequenceParser(length - 4),
+		]),
+		([ _magic, zeroPadding ]) => ({ type: 'zeroPadding', length: zeroPadding.length }),
+	);
+
+	setParserName(androidPackageSigningBlockZeroPaddingPairInnerParser, 'androidPackageSigningBlockZeroPaddingPairInnerParser');
+
+	return androidPackageSigningBlockZeroPaddingPairInnerParser;
+};
+
+type AndroidPackageSigningBlockSignatureV2Pair = {
+	type: 'signatureV2';
+	signers: AndroidPackageSignatureV2Signer[];
+};
+
+const createAndroidPackageSigningBlockSignatureV2PairInnerParser = (length: number): Parser<AndroidPackageSigningBlockSignatureV2Pair, Uint8Array> => {
+	const androidPackageSigningBlockSignatureV2PairInnerParser = promiseCompose(
+		createTupleParser([
+			createExactSequenceParser<Uint8Array>(Buffer.from('1a870971', 'hex')),
+			androidPackageSignatureV2SignersParser,
+		]),
+		([ _magic, signers = [] ]) => ({ type: 'signatureV2' as const, signers }),
+	);
+
+	return setParserName(androidPackageSigningBlockSignatureV2PairInnerParser, 'androidPackageSigningBlockSignatureV2PairInnerParser');
+};
+
+type AndroidPackageSigningBlockGenericPair = {
+	type: 'generic';
+	pair: AndroidPackageSigningBlockPair;
+};
+
+const createAndroidPackageSigningBlockGenericPairInnerParser = (length: number): Parser<AndroidPackageSigningBlockGenericPair, Uint8Array> => promiseCompose(
+	createTupleParser([
+		uint32LEParser,
+		createFixedLengthSequenceParser(length - 4),
+	]),
+	([ id, value ]) => ({ type: 'generic', pair: { id, value } }),
+);
+
+type AndroidPackageSigningBlockPairType =
+	| AndroidPackageSigningBlockZeroPaddingPair
+	| AndroidPackageSigningBlockSignatureV2Pair
+	| AndroidPackageSigningBlockGenericPair
+;
+
+const createAndroidPackageSigningBlockPairInnerParser = (length: number): Parser<AndroidPackageSigningBlockPairType, Uint8Array> => {
+	const androidPackageSigningBlockPairInnerParser: Parser<AndroidPackageSigningBlockPairType, Uint8Array> = promiseCompose(
+		createTupleParser([
+			parserContext => {
+				parserContext.invariant(
+					Number.isSafeInteger(length),
+					'Signing block length is unreasonable: %s.',
+					length,
+				);
+			},
+			createDisjunctionParser<AndroidPackageSigningBlockPairType, Uint8Array>([
+				createAndroidPackageSigningBlockZeroPaddingPairInnerParser(length),
+				createAndroidPackageSigningBlockSignatureV2PairInnerParser(length),
+				createAndroidPackageSigningBlockGenericPairInnerParser(length),
+			]),
+		]),
+		([
+			_lengthInvariant,
+			pair,
+		]) => pair,
+	);
+
+	setParserName(androidPackageSigningBlockPairInnerParser, 'androidPackageSigningBlockPairInnerParser');
+
+	return androidPackageSigningBlockPairInnerParser;
+};
+
+const androidPackageSigningBlockPairParser: Parser<AndroidPackageSigningBlockPairType, Uint8Array> = createUint64LengthPrefixedParser(
+	length => createAndroidPackageSigningBlockPairInnerParser(Number(length)),
+);
+
+setParserName(androidPackageSigningBlockPairParser, 'androidPackageSigningBlockPairParser');
+
+const androidPackageSigningBlockPairsParser: Parser<AndroidPackageSigningBlockPairType[], Uint8Array> = createArrayParser(androidPackageSigningBlockPairParser);
+
+export const androidPackageSigningBlockParser: Parser<AndroidPackageSigningBlock, Uint8Array> = createUint64LengthPrefixedParser(
+	sizeOfBlock => promiseCompose(
+		createTupleParser([
+			androidPackageSigningBlockPairsParser,
+			uint64LEParser,
+			createExactSequenceParser<Uint8Array>(Buffer.from('APK Sig Block 42', 'utf8')),
+		]),
+		async ([
+			pairs,
+			sizeOfBlockRepeated,
+			_magic,
+		]): Promise<AndroidPackageSigningBlock> => {
+			invariant(sizeOfBlock === sizeOfBlockRepeated, 'Size of block mismatch: %s !== %s.', sizeOfBlock, sizeOfBlockRepeated);
+
+			const zeroPaddingPair = pairs.find(pair => pair.type === 'zeroPadding');
+			const signatureV2Pair = pairs.find(pair => pair.type === 'signatureV2');
+
+			const genericPairs = (
+				pairs
+					.filter(pair => (
+						pair !== zeroPaddingPair
+							&& pair !== signatureV2Pair
+					))
+					.map(pair => {
+						invariant(pair.type === 'generic', 'Expected generic pair, got %s.', pair.type);
+						return pair.pair;
+					})
+			);
+
+			return {
+				zeroPaddingLength: zeroPaddingPair?.length,
+				signatureV2: signatureV2Pair ? {
+					signers: signatureV2Pair?.signers,
+				} : undefined,
+				pairs: genericPairs,
+			};
+		},
+	),
+);
+
+const androidPackageSignatureV2DigestParser = createUint32LengthPrefixedParser<AndroidPackageSignatureV2Digest>(
+	pairLength => promiseCompose(
+		createTupleParser([
+			uint32LEParser,
+			createUint32LengthPrefixedParser(
+				digestLength => createFixedLengthSequenceParser(digestLength),
+			),
+		]),
+		([ signatureAlgorithmId, digest ]) => ({ signatureAlgorithmId, digest }),
+	),
+);
+
+const androidPackageSignatureV2DigestsParser = createUint32LengthPrefixedSliceBoundedArrayParser(
+	androidPackageSignatureV2DigestParser,
+);
+
+setParserName(androidPackageSignatureV2DigestsParser, 'androidPackageSignatureV2DigestsParser');
+
+const androidPackageSignatureV2CertificateParser = createUint32LengthPrefixedParser(
+	certificateLength => createFixedLengthSequenceParser(certificateLength),
+);
+
+setParserName(androidPackageSignatureV2CertificateParser, 'androidPackageSignatureV2CertificateParser');
+
+const androidPackageSignatureV2CertificatesParser = createUint32LengthPrefixedSliceBoundedArrayParser(
+	androidPackageSignatureV2CertificateParser,
+);
+
+setParserName(androidPackageSignatureV2CertificatesParser, 'androidPackageSignatureV2CertificatesParser');
+
+const androidPackageSignatureV2AdditionalAttributeParser = createUint32LengthPrefixedParser<AndroidPackageSignatureV2AdditionalAttribute>(
+	pairLength => promiseCompose(
+		createTupleParser([
+			uint32LEParser,
+			createFixedLengthSequenceParser(pairLength - 4),
+		]),
+		([ id, value ]) => ({ id, value }),
+	),
+);
+
+setParserName(androidPackageSignatureV2AdditionalAttributeParser, 'androidPackageSignatureV2AdditionalAttributeParser');
+
+const androidPackageSignatureV2AdditionalAttributesParser = createUint32LengthPrefixedSliceBoundedArrayParser(
+	androidPackageSignatureV2AdditionalAttributeParser,
+);
+
+setParserName(androidPackageSignatureV2AdditionalAttributesParser, 'androidPackageSignatureV2AdditionalAttributesParser');
+
+const androidPackageSignatureV2SignedDataParser = createUint32LengthPrefixedSliceBoundedParser(
+	promiseCompose(
+		createTupleParser([
+			androidPackageSignatureV2DigestsParser,
+			androidPackageSignatureV2CertificatesParser,
+			androidPackageSignatureV2AdditionalAttributesParser,
+			createArrayParser(createExactElementParser(0)),
+		]),
+		([
+			digests,
+			certificates,
+			additionalAttributes,
+			zeroPadding,
+		]): AndroidPackageSignatureV2SignedData => ({
+			digests,
+			certificates,
+			additionalAttributes,
+			zeroPaddingLength: zeroPadding.length,
+		}),
+	),
+);
+
+setParserName(androidPackageSignatureV2SignedDataParser, 'androidPackageSignatureV2SignedDataParser');
+
+const androidPackageSignatureV2SignatureParser = createUint32LengthPrefixedParser(
+	signatureLength => promiseCompose(
+		createTupleParser([
+			uint32LEParser,
+			createUint32LengthPrefixedParser(
+				signatureLength => createFixedLengthSequenceParser(signatureLength),
+			),
+		]),
+		([
+			signatureAlgorithmId,
+			signature,
+		]): AndroidPackageSignatureV2Signature => ({
+			signatureAlgorithmId,
+			signature,
+		}),
+	),
+);
+
+const androidPackageSignatureV2SignaturesParser = createUint32LengthPrefixedSliceBoundedArrayParser(
+	androidPackageSignatureV2SignatureParser,
+);
+
+setParserName(androidPackageSignatureV2SignaturesParser, 'androidPackageSignatureV2SignaturesParser');
+
+const androidPackageSignatureV2PublicKeyParser = createUint32LengthPrefixedParser(
+	publicKeyLength => createFixedLengthSequenceParser(publicKeyLength),
+);
+
+setParserName(androidPackageSignatureV2PublicKeyParser, 'androidPackageSignatureV2PublicKeyParser');
+
+const androidPackageSignatureV2SignerParser = createUint32LengthPrefixedSliceBoundedParser(
+	promiseCompose(
+		createTupleParser([
+			androidPackageSignatureV2SignedDataParser,
+			androidPackageSignatureV2SignaturesParser,
+			androidPackageSignatureV2PublicKeyParser,
+		]),
+		([
+			signedData,
+			signatures = [],
+			publicKey,
+		]): AndroidPackageSignatureV2Signer => ({
+			signedData,
+			signatures,
+			publicKey,
+		}),
+	),
+);
+
+setParserName(androidPackageSignatureV2SignerParser, 'androidPackageSignatureV2SignerParser');
+
+const androidPackageSignatureV2SignersParser = createUint32LengthPrefixedSliceBoundedArrayParser(
+	androidPackageSignatureV2SignerParser,
+);
+
+setParserName(androidPackageSignatureV2SignersParser, 'androidPackageSignatureV2SignersParser');
+
+const androidPackageParser_ = createTupleParser([
+	createArrayParser(zipLocalFileParser),
+	createOptionalParser(zipArchiveDecryptionHeaderParser),
+	createOptionalParser(zipArchiveExtraDataRecordParser),
+	createOptionalParser(androidPackageSigningBlockParser),
+	createArrayParser(zipCentralDirectoryHeaderParser),
+	createOptionalParser(zip64EndOfCentralDirectoryRecordParser),
+	createOptionalParser(zip64EndOfCentralDirectoryLocatorParser),
+	zipEndOfCentralDirectoryRecordParser,
+]);
+
+setParserName(androidPackageParser_, 'androidPackageParser_');
+
+export const androidPackageParser: Parser<AndroidPackage, Uint8Array> = promiseCompose(
+	androidPackageParser_,
+	async ([
+		zipLocalFiles,
+		zipArchiveDecryptionHeader,
+		zipArchiveExtraDataRecord,
+		androidPackageSigningBlock,
+		zipCentralDirectoryHeaders,
+		zip64EndOfCentralDirectoryRecord,
+		zip64EndOfCentralDirectoryLocator,
+		zipEndOfCentralDirectoryRecord,
+	]) => {
+		const zip = await zipFromZipSegments({
+			zipLocalFiles,
+			zipCentralDirectoryHeaders,
+			zipEndOfCentralDirectoryRecord,
+		});
+
+		return {
+			...zip,
+			signingBlock: androidPackageSigningBlock,
+		};
+	},
+);
+
+setParserName(androidPackageParser, 'androidPackageParser');
+
+export type AndroidPackageSignableSections = {
+	zipLocalFiles: ZipLocalFile[];
+	zipLocalFilesZeroPaddingLength: number;
+	androidPackageSigningBlock?: AndroidPackageSigningBlock;
+	zipCentralDirectory: ZipCentralDirectoryHeader[];
+	zipEndOfCentralDirectory: ZipEndOfCentralDirectoryRecord;
+
+	zipLocalFilesUint8Array: Uint8Array;
+	androidPackageSigningBlockUint8Array?: Uint8Array;
+	zipCentralDirectoryUint8Array: Uint8Array;
+	zipEndOfCentralDirectoryUint8Array: Uint8Array;
+}
+
+export const androidPackageSignableSectionsParser: Parser<AndroidPackageSignableSections, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createParserConsumedSequenceParser(
+			createTupleParser([
+				createArrayParser(zipLocalFileParser),
+				createOptionalParser(zipArchiveDecryptionHeaderParser),
+				createOptionalParser(zipArchiveExtraDataRecordParser),
+			]),
+		),
+		createArrayParser(
+			createExactElementParser(0),
+		),
+		createOptionalParser(
+			createParserConsumedSequenceParser(
+				androidPackageSigningBlockParser
+			),
+		),
+		createParserConsumedSequenceParser(
+			createTupleParser([
+				createArrayParser(zipCentralDirectoryHeaderParser),
+				createOptionalParser(zip64EndOfCentralDirectoryRecordParser),
+				createOptionalParser(zip64EndOfCentralDirectoryLocatorParser),
+			]),
+		),
+		createParserConsumedSequenceParser(
+			zipEndOfCentralDirectoryRecordParser,
+		),
+	]),
+	async ([
+		[
+			[
+				zipLocalFiles,
+			],
+			zipLocalFilesUint8Array,
+		],
+		zipLocalFilesZeroPadding,
+		[
+			androidPackageSigningBlock = undefined,
+			androidPackageSigningBlockUint8Array = undefined,
+		] = [],
+		[
+			[
+				zipCentralDirectory,
+			],
+			zipCentralDirectoryUint8Array,
+		],
+		[
+			zipEndOfCentralDirectory,
+			zipEndOfCentralDirectoryUint8Array,
+		],
+	]) => ({
+		zipLocalFiles,
+		zipLocalFilesZeroPaddingLength: zipLocalFilesZeroPadding.length,
+		androidPackageSigningBlock,
+		zipCentralDirectory,
+		zipEndOfCentralDirectory,
+
+		zipLocalFilesUint8Array,
+		androidPackageSigningBlockUint8Array,
+		zipCentralDirectoryUint8Array,
+		zipEndOfCentralDirectoryUint8Array,
+	}),
+);
+
+setParserName(androidPackageSignableSectionsParser, 'androidPackageSignableSectionsParser');

package/src/androidPackageUnparser.test.ts

@@ -0,0 +1,36 @@
+import test from 'ava';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { runParser } from './parser.js';
+import { androidPackageParser, androidPackageSigningBlockParser } from './androidPackageParser.js';
+import { runUnparser } from './unparser.js';
+import { androidPackageSigningBlockUnparser } from './androidPackageUnparser.js';
+import { uint8ArrayUnparserOutputCompanion } from './unparserOutputCompanion.js';
+import invariant from 'invariant';
+import { fetchCid } from './fetchCid.js';
+
+for (const androidPackageCid of [
+	'bafkreicckcmzrdxwoc3w2in3tivpyxrdtcfpct4zwauq3igew3nkpvfapu',
+]) {
+	test(
+		'androidPackage ' + androidPackageCid,
+		async t => {
+			const androidPackageStream = await fetchCid(androidPackageCid);
+
+			const androidPackage = await runParser(androidPackageParser, androidPackageStream, uint8ArrayParserInputCompanion, {
+				errorJoinMode: 'all',
+			});
+
+			const androidPackageSigningBlock = androidPackage.signingBlock;
+
+			invariant(androidPackageSigningBlock, 'APK has no signing block');
+
+			const androidPackageSigningBlockStream = runUnparser(androidPackageSigningBlockUnparser, androidPackageSigningBlock, uint8ArrayUnparserOutputCompanion);
+
+			const actual = await runParser(androidPackageSigningBlockParser, androidPackageSigningBlockStream, uint8ArrayParserInputCompanion, {
+				errorJoinMode: 'all',
+			});
+
+			t.deepEqual(actual, androidPackageSigningBlock);
+		},
+	);
+}

package/src/androidPackageUnparser.ts

@@ -0,0 +1,120 @@
+import { AndroidPackageSignatureV2AdditionalAttribute, AndroidPackageSignatureV2Digest, AndroidPackageSignatureV2Signature, AndroidPackageSignatureV2SignedData, AndroidPackageSignatureV2Signer, AndroidPackageSigningBlock } from "./androidPackage.js";
+import { createArrayUnparser } from "./arrayUnparser.js";
+import { createSequenceUnparser } from "./sequenceUnparser.js";
+import { Unparser } from "./unparser.js";
+
+const uint8ArrayUnparser = createSequenceUnparser<Uint8Array>();
+
+const uint32LEUnparser: Unparser<number, Uint8Array> = async function * (input) {
+	const buffer = Buffer.alloc(4);
+	buffer.writeUInt32LE(input);
+	yield buffer;
+}
+
+const uint64LEUnparser: Unparser<number | bigint, Uint8Array> = async function * (input) {
+	const buffer = Buffer.alloc(8);
+	buffer.writeBigUInt64LE(BigInt(input));
+	yield buffer;
+};
+
+const createUint32LengthPrefixedUnparser = <T>(innerUnparser: Unparser<T, Uint8Array>): Unparser<T, Uint8Array> => async function * (input, unparserContext) {
+	const length = yield * unparserContext.writeLater(4);
+	yield * innerUnparser(input, unparserContext);
+	yield * unparserContext.writeEarlier(length, uint32LEUnparser, unparserContext.position - length.positionEnd);
+};
+
+const createUint64LengthPrefixedUnparser = <T>(innerUnparser: Unparser<T, Uint8Array>): Unparser<T, Uint8Array> => async function * (input, unparserContext) {
+	const length = yield * unparserContext.writeLater(8);
+	yield * innerUnparser(input, unparserContext);
+	yield * unparserContext.writeEarlier(length, uint64LEUnparser, unparserContext.position - length.positionEnd);
+};
+
+const androidPackageSignatureV2DigestUnparser: Unparser<AndroidPackageSignatureV2Digest, Uint8Array> = createUint32LengthPrefixedUnparser(async function * (input, unparserContext) {
+	yield * uint32LEUnparser(input.signatureAlgorithmId, unparserContext);
+	yield * uint32LEUnparser(input.digest.length, unparserContext);
+	yield input.digest;
+});
+
+const androidPackageSignatureV2DigestsUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(androidPackageSignatureV2DigestUnparser));
+
+const androidPackageSignatureV2CertificateUnparser = createUint32LengthPrefixedUnparser(uint8ArrayUnparser);
+
+const androidPackageSignatureV2CertificatesUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(androidPackageSignatureV2CertificateUnparser));
+
+const androidPackageSignatureV2AdditionalAttributeUnparser: Unparser<AndroidPackageSignatureV2AdditionalAttribute, Uint8Array> = createUint32LengthPrefixedUnparser(async function * (input, unparserContext) {
+	yield * uint32LEUnparser(input.id, unparserContext);
+	yield input.value;
+});
+
+const androidPackageSignatureV2AdditionalAttributesUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(androidPackageSignatureV2AdditionalAttributeUnparser));
+
+export const androidPackageSignatureV2SignedDataUnparser: Unparser<AndroidPackageSignatureV2SignedData, Uint8Array> = createUint32LengthPrefixedUnparser(async function * (input, unparserContext) {
+	yield * androidPackageSignatureV2DigestsUnparser(input.digests, unparserContext);
+	yield * androidPackageSignatureV2CertificatesUnparser(input.certificates, unparserContext);
+	yield * androidPackageSignatureV2AdditionalAttributesUnparser(input.additionalAttributes, unparserContext);
+	if (input.zeroPaddingLength) {
+		yield Buffer.alloc(input.zeroPaddingLength);
+	}
+});
+
+const androidPackageSignatureV2SignatureUnparser: Unparser<AndroidPackageSignatureV2Signature, Uint8Array> = createUint32LengthPrefixedUnparser(async function * (input, unparserContext) {
+	yield * uint32LEUnparser(input.signatureAlgorithmId, unparserContext);
+	yield * uint32LEUnparser(input.signature.length, unparserContext);
+	yield input.signature;
+});
+
+const androidPackageSignatureV2SignaturesUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(androidPackageSignatureV2SignatureUnparser));
+
+const androidPackageSignatureV2PublicKeyUnparser = createUint32LengthPrefixedUnparser(uint8ArrayUnparser);
+
+const androidPackageSignatureV2SignerUnparser: Unparser<AndroidPackageSignatureV2Signer, Uint8Array> = createUint32LengthPrefixedUnparser(async function * (input, unparserContext) {
+	yield * androidPackageSignatureV2SignedDataUnparser(input.signedData, unparserContext);
+	yield * androidPackageSignatureV2SignaturesUnparser(input.signatures, unparserContext);
+	yield * androidPackageSignatureV2PublicKeyUnparser(input.publicKey, unparserContext);
+});
+
+const androidPackageSignatureV2SignersUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(androidPackageSignatureV2SignerUnparser));
+
+type AndroidPackageSigningBlockPair = {
+	id: number;
+	value: Uint8Array | AndroidPackageSignatureV2Signer[];
+};
+
+const androidPackageSigningBlockPairUnparser: Unparser<AndroidPackageSigningBlockPair, Uint8Array> = createUint64LengthPrefixedUnparser(async function * (input, unparserContext) {
+	yield * uint32LEUnparser(input.id, unparserContext);
+	if (input.value instanceof Uint8Array) {
+		yield input.value;
+	} else {
+		yield * androidPackageSignatureV2SignersUnparser(input.value, unparserContext);
+	}
+});
+
+const androidPackageSigningBlockPairsUnparser = createArrayUnparser(androidPackageSigningBlockPairUnparser);
+
+export const androidPackageSigningBlockUnparser: Unparser<AndroidPackageSigningBlock, Uint8Array> = async function * (
+	input,
+	unparserContext,
+) {
+	const pairs = [
+		...input.pairs,
+		...(input.signatureV2 ? [
+			{
+				id: 0x7109871a,
+				value: input.signatureV2!.signers,
+			},
+		] : []),
+		...(input.zeroPaddingLength ? [
+			{
+				id: 0x42726577,
+				value: Buffer.alloc(input.zeroPaddingLength),
+			},
+		] : []),
+	];
+
+	const sizeOfBlockWriteLater = yield * unparserContext.writeLater(8);
+	yield * androidPackageSigningBlockPairsUnparser(pairs, unparserContext);
+	const sizeOfBlock = unparserContext.position - sizeOfBlockWriteLater.position + 16;
+	yield * uint64LEUnparser(sizeOfBlock, unparserContext);
+	yield * unparserContext.writeEarlier(sizeOfBlockWriteLater, uint64LEUnparser, sizeOfBlock);
+	yield Buffer.from('APK Sig Block 42', 'utf8');
+};

package/src/arbitrarilySlicedAsyncInterable.ts

@@ -1,7 +1,7 @@
-import { inspect } from 'node:util';
 import * as fc from 'fast-check';
 import { type Arbitrary } from 'fast-check';
 import invariant from 'invariant';
+import { inspect } from './inspect.js';
 
 function concat<Sliceable extends string | Uint8Array>(slices: Sliceable[]): Sliceable {
 	const firstSlice = slices.at(0);
@@ -23,9 +23,14 @@ function equals<Sliceable extends string | Uint8Array>(a: Sliceable, b: Sliceabl
 
 export function arbitrarilySlicedAsyncIterable<Sliceable extends string | Uint8Array>(
 	arbitrarySliceable: Arbitrary<Sliceable>,
+	{
+		minSlices = 1,
+	}: {
+		minSlices?: number,
+	} = {},
 ): Arbitrary<[ Sliceable, AsyncIterable<Sliceable> ]> {
 	return (
-		fc.tuple(arbitrarySliceable, fc.array(fc.nat(), { minLength: 1 }))
+		fc.tuple(arbitrarySliceable, fc.array(fc.nat(), { minLength: Math.max(1, minSlices) }))
 			.map(([ sliceable, sliceSizes ]) => {
 				let start = 0;
 

package/src/arrayParser.test.ts

@@ -1,11 +1,11 @@
 import test from 'ava';
 import { createArrayParser } from './arrayParser.js';
-import { type Parser, runParser } from './parser.js';
+import { type Parser, runParserWithRemainingInput } from './parser.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
 
 test('does not loop forever with a child parser that does not consume anything', async t => {
 	const parser: Parser<undefined[], string> = createArrayParser(async () => undefined);
-	const result = await runParser(parser, 'foo', stringParserInputCompanion);
+	const { output } = await runParserWithRemainingInput(parser, 'foo', stringParserInputCompanion);
 
-	t.deepEqual(result, []);
+	t.deepEqual(output, []);
 });

package/src/backsmali.ts

@@ -0,0 +1,30 @@
+import fs from 'node:fs/promises';
+import { execa } from 'execa';
+import { temporaryDirectory, temporaryFile } from 'tempy';
+import path from 'node:path';
+
+export async function baksmaliClass(dexStream: AsyncIterable<Uint8Array>, smaliFilePath: string) {
+	const inputFilePath = temporaryFile();
+	const outputDirectoryPath = temporaryDirectory();
+
+	await fs.writeFile(inputFilePath, dexStream);
+
+	await execa('baksmali', [
+		'disassemble',
+		'--classes', 'L' + smaliFilePath + ';',
+		'--output', outputDirectoryPath,
+		inputFilePath,
+	]);
+
+	await fs.unlink(inputFilePath);
+
+	const smaliFilePath_ = path.join(outputDirectoryPath, smaliFilePath + '.smali');
+
+	const smali = await fs.readFile(smaliFilePath_, 'utf8');
+
+	await fs.rm(outputDirectoryPath, {
+		recursive: true,
+	});
+
+	return smali;
+}