@futpib/parser 1.0.0 → 1.0.1

package/src/apkParser.ts

@@ -1,17 +1,30 @@
-import { createArrayParser } from "./arrayParser.js";
-import { createOptionalParser } from "./optionalParser.js";
-import { Parser, setParserName } from "./parser.js";
-import { promiseCompose } from "./promiseCompose.js";
-import { createTupleParser } from "./tupleParser.js";
-import { zip64EndOfCentralDirectoryLocatorParser, zip64EndOfCentralDirectoryRecordParser, zipArchiveDecryptionHeaderParser, zipArchiveExtraDataRecordParser, zipCentralDirectoryHeaderParser, zipEndOfCentralDirectoryRecordParser, zipFromZipSegments, zipLocalFileParser } from "./zipParser.js";
-import { Apk, ApkSigningBlock, ApkSigningBlockPair } from "./apk.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 invariant from "invariant";
-import { createExactElementParser } from "./exactElementParser.js";
+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 { ApkSignatureV2AdditionalAttribute, ApkSignatureV2Digest, ApkSignatureV2Signature, ApkSignatureV2SignedData, ApkSignatureV2Signer, type Apk, type ApkSigningBlock, type ApkSigningBlockPair } from './apk.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';
 
 // https://source.android.com/docs/security/features/apksigning/v2#apk-signing-block
 
@@ -46,8 +59,8 @@ const createUint32LengthPrefixedSliceBoundedParser = <T>(innerParser: Parser<T,
 const createUint32LengthPrefixedSliceBoundedArrayParser = <T>(innerParser: Parser<T, Uint8Array>): Parser<T[], Uint8Array> => createUint32LengthPrefixedSliceBoundedParser(createArrayParser(innerParser));
 
 type ApkSigningBlockZeroPaddingPair = {
-	type: 'zeroPadding',
-	length: number,
+	type: 'zeroPadding';
+	length: number;
 };
 
 const createApkSigningBlockZeroPaddingPairInnerParser = (length: number): Parser<ApkSigningBlockZeroPaddingPair, Uint8Array> => promiseCompose(
@@ -59,15 +72,15 @@ const createApkSigningBlockZeroPaddingPairInnerParser = (length: number): Parser
 );
 
 type ApkSigningBlockSignatureV2Pair = {
-	type: 'signatureV2',
-	signers: ApkSignatureSchemeV2Signer[],
+	type: 'signatureV2';
+	signers: ApkSignatureV2Signer[];
 };
 
 const createApkSigningBlockSignatureV2PairInnerParser = (length: number): Parser<ApkSigningBlockSignatureV2Pair, Uint8Array> => {
 	const apkSigningBlockSignatureV2PairInnerParser = promiseCompose(
 		createTupleParser([
 			createExactSequenceParser<Uint8Array>(Buffer.from('1a870971', 'hex')),
-			apkSignatureSchemeV2SignersParser,
+			apkSignatureV2SignersParser,
 		]),
 		([ _magic, signers = [] ]) => ({ type: 'signatureV2' as const, signers }),
 	);
@@ -76,8 +89,8 @@ const createApkSigningBlockSignatureV2PairInnerParser = (length: number): Parser
 };
 
 type ApkSigningBlockGenericPair = {
-	type: 'generic',
-	pair: ApkSigningBlockPair,
+	type: 'generic';
+	pair: ApkSigningBlockPair;
 };
 
 const createApkSigningBlockGenericPairInnerParser = (length: number): Parser<ApkSigningBlockGenericPair, Uint8Array> => promiseCompose(
@@ -108,14 +121,14 @@ setParserName(apkSigningBlockPairParser, 'apkSigningBlockPairParser');
 
 const apkSigningBlockPairsParser: Parser<ApkSigningBlockPairType[], Uint8Array> = createArrayParser(apkSigningBlockPairParser);
 
-const apkSigningBlockParser: Parser<ApkSigningBlock, Uint8Array> = createUint64LengthPrefixedParser(
+export const apkSigningBlockParser: Parser<ApkSigningBlock, Uint8Array> = createUint64LengthPrefixedParser(
 	sizeOfBlock => promiseCompose(
 		createTupleParser([
 			apkSigningBlockPairsParser,
 			uint64LEParser,
 			createExactSequenceParser<Uint8Array>(Buffer.from('APK Sig Block 42', 'utf8')),
 		]),
-		async ([ pairs, sizeOfBlockRepeated, _magic ]) => {
+		async ([ pairs, sizeOfBlockRepeated, _magic ]): Promise<ApkSigningBlock> => {
 			invariant(sizeOfBlock === sizeOfBlockRepeated, 'Size of block mismatch: %s !== %s.', sizeOfBlock, sizeOfBlockRepeated);
 
 			const zeroPaddingPair = pairs.find(pair => pair.type === 'zeroPadding');
@@ -135,19 +148,16 @@ const apkSigningBlockParser: Parser<ApkSigningBlock, Uint8Array> = createUint64L
 
 			return {
 				zeroPaddingLength: zeroPaddingPair?.length,
-				signatureV2: signatureV2Pair?.signers,
+				signatureV2: signatureV2Pair ? {
+					signers: signatureV2Pair?.signers,
+				} : undefined,
 				pairs: genericPairs,
 			};
 		},
 	),
 );
 
-type ApkSignatureSchemeV2Digest = {
-	signatureAlgorithmId: number,
-	digest: Uint8Array,
-};
-
-const apkSignatureSchemeV2DigestParser = createUint32LengthPrefixedParser<ApkSignatureSchemeV2Digest>(
+const apkSignatureV2DigestParser = createUint32LengthPrefixedParser<ApkSignatureV2Digest>(
 	pairLength => promiseCompose(
 		createTupleParser([
 			uint32LEParser,
@@ -159,24 +169,19 @@ const apkSignatureSchemeV2DigestParser = createUint32LengthPrefixedParser<ApkSig
 	),
 );
 
-const apkSignatureSchemeV2DigestsParser = createUint32LengthPrefixedSliceBoundedArrayParser(
-	apkSignatureSchemeV2DigestParser
+const apkSignatureV2DigestsParser = createUint32LengthPrefixedSliceBoundedArrayParser(
+	apkSignatureV2DigestParser,
 );
 
-const apkSignatureSchemeV2CertificateParser = createUint32LengthPrefixedParser(
+const apkSignatureV2CertificateParser = createUint32LengthPrefixedParser(
 	certificateLength => createFixedLengthSequenceParser(certificateLength),
 );
 
-const apkSignatureSchemeV2CertificatesParser = createUint32LengthPrefixedSliceBoundedArrayParser(
-	apkSignatureSchemeV2CertificateParser,
+const apkSignatureV2CertificatesParser = createUint32LengthPrefixedSliceBoundedArrayParser(
+	apkSignatureV2CertificateParser,
 );
 
-type ApkSignatureSchemeV2AdditionalAttribute = {
-	id: number,
-	value: Uint8Array,
-};
-
-const apkSignatureSchemeV2AdditionalAttributeParser = createUint32LengthPrefixedParser<ApkSignatureSchemeV2AdditionalAttribute>(
+const apkSignatureV2AdditionalAttributeParser = createUint32LengthPrefixedParser<ApkSignatureV2AdditionalAttribute>(
 	pairLength => promiseCompose(
 		createTupleParser([
 			uint32LEParser,
@@ -186,44 +191,39 @@ const apkSignatureSchemeV2AdditionalAttributeParser = createUint32LengthPrefixed
 	),
 );
 
-const apkSignatureSchemeV2AdditionalAttributesParser = createUint32LengthPrefixedSliceBoundedArrayParser(
-	apkSignatureSchemeV2AdditionalAttributeParser,
+setParserName(apkSignatureV2AdditionalAttributeParser, 'apkSignatureV2AdditionalAttributeParser');
+
+const apkSignatureV2AdditionalAttributesParser = createUint32LengthPrefixedSliceBoundedArrayParser(
+	apkSignatureV2AdditionalAttributeParser,
 );
 
-type ApkSignatureSchemeV2SignedData = {
-	digests: ApkSignatureSchemeV2Digest[],
-	certificates: Uint8Array[],
-	additionalAttributes: ApkSignatureSchemeV2AdditionalAttribute[],
-};
+setParserName(apkSignatureV2AdditionalAttributesParser, 'apkSignatureV2AdditionalAttributesParser');
 
-const apkSignatureSchemeV2SignedDataParser = createUint32LengthPrefixedSliceBoundedParser(
+const apkSignatureV2SignedDataParser = createUint32LengthPrefixedSliceBoundedParser(
 	promiseCompose(
 		createTupleParser([
-			apkSignatureSchemeV2DigestsParser,
-			apkSignatureSchemeV2CertificatesParser,
-			createOptionalParser(apkSignatureSchemeV2AdditionalAttributesParser),
+			apkSignatureV2DigestsParser,
+			apkSignatureV2CertificatesParser,
+			apkSignatureV2AdditionalAttributesParser,
 			createArrayParser(createExactElementParser(0)),
 		]),
 		([
-			digests = [],
-			certificates = [],
-			additionalAttributes = [],
-		]): ApkSignatureSchemeV2SignedData => ({
 			digests,
 			certificates,
 			additionalAttributes,
+			zeroPadding,
+		]): ApkSignatureV2SignedData => ({
+			digests,
+			certificates,
+			additionalAttributes,
+			zeroPaddingLength: zeroPadding.length,
 		}),
 	),
 );
 
-setParserName(apkSignatureSchemeV2SignedDataParser, 'apkSignatureSchemeV2SignedDataParser');
+setParserName(apkSignatureV2SignedDataParser, 'apkSignatureV2SignedDataParser');
 
-type ApkSignatureSchemeV2Signature = {
-	signatureAlgorithmId: number,
-	signature: Uint8Array,
-};
-
-const apkSignatureSchemeV2SignatureParser = createUint32LengthPrefixedParser(
+const apkSignatureV2SignatureParser = createUint32LengthPrefixedParser(
 	signatureLength => promiseCompose(
 		createTupleParser([
 			uint32LEParser,
@@ -234,43 +234,37 @@ const apkSignatureSchemeV2SignatureParser = createUint32LengthPrefixedParser(
 		([
 			signatureAlgorithmId,
 			signature,
-		]): ApkSignatureSchemeV2Signature => ({
+		]): ApkSignatureV2Signature => ({
 			signatureAlgorithmId,
 			signature,
 		}),
 	),
 );
 
-const apkSignatureSchemeV2SignaturesParser = createUint32LengthPrefixedSliceBoundedArrayParser(
-	apkSignatureSchemeV2SignatureParser,
+const apkSignatureV2SignaturesParser = createUint32LengthPrefixedSliceBoundedArrayParser(
+	apkSignatureV2SignatureParser,
 );
 
-setParserName(apkSignatureSchemeV2SignaturesParser, 'apkSignatureSchemeV2SignaturesParser');
+setParserName(apkSignatureV2SignaturesParser, 'apkSignatureV2SignaturesParser');
 
-const apkSignatureSchemeV2PublicKeyParser = createUint32LengthPrefixedParser(
+const apkSignatureV2PublicKeyParser = createUint32LengthPrefixedParser(
 	publicKeyLength => createFixedLengthSequenceParser(publicKeyLength),
 );
 
-setParserName(apkSignatureSchemeV2PublicKeyParser, 'apkSignatureSchemeV2PublicKeyParser');
+setParserName(apkSignatureV2PublicKeyParser, 'apkSignatureV2PublicKeyParser');
 
-type ApkSignatureSchemeV2Signer = {
-	signedData: ApkSignatureSchemeV2SignedData,
-	signatures: ApkSignatureSchemeV2Signature[],
-	publicKey?: Uint8Array,
-};
-
-const apkSignatureSchemeV2SignerParser = createUint32LengthPrefixedSliceBoundedParser(
+const apkSignatureV2SignerParser = createUint32LengthPrefixedSliceBoundedParser(
 	promiseCompose(
 		createTupleParser([
-			apkSignatureSchemeV2SignedDataParser,
-			apkSignatureSchemeV2SignaturesParser,
-			apkSignatureSchemeV2PublicKeyParser,
+			apkSignatureV2SignedDataParser,
+			apkSignatureV2SignaturesParser,
+			apkSignatureV2PublicKeyParser,
 		]),
 		([
 			signedData,
 			signatures = [],
-			publicKey
-		]): ApkSignatureSchemeV2Signer => ({
+			publicKey,
+		]): ApkSignatureV2Signer => ({
 			signedData,
 			signatures,
 			publicKey,
@@ -278,13 +272,13 @@ const apkSignatureSchemeV2SignerParser = createUint32LengthPrefixedSliceBoundedP
 	),
 );
 
-setParserName(apkSignatureSchemeV2SignerParser, 'apkSignatureSchemeV2SignerParser');
+setParserName(apkSignatureV2SignerParser, 'apkSignatureV2SignerParser');
 
-const apkSignatureSchemeV2SignersParser = createUint32LengthPrefixedSliceBoundedArrayParser(
-	apkSignatureSchemeV2SignerParser,
+const apkSignatureV2SignersParser = createUint32LengthPrefixedSliceBoundedArrayParser(
+	apkSignatureV2SignerParser,
 );
 
-setParserName(apkSignatureSchemeV2SignersParser, 'apkSignatureSchemeV2SignersParser');
+setParserName(apkSignatureV2SignersParser, 'apkSignatureV2SignersParser');
 
 const apkParser_ = createTupleParser([
 	createArrayParser(zipLocalFileParser),
@@ -325,3 +319,74 @@ export const apkParser: Parser<Apk, Uint8Array> = promiseCompose(
 );
 
 setParserName(apkParser, 'apkParser');
+
+export type ApkSignableSections = {
+	zipLocalFiles: ZipLocalFile[];
+	apkSigningBlock?: ApkSigningBlock;
+	zipCentralDirectory: ZipCentralDirectoryHeader[];
+	zipEndOfCentralDirectory: ZipEndOfCentralDirectoryRecord;
+
+	zipLocalFilesUint8Array: Uint8Array;
+	apkSigningBlockUint8Array?: Uint8Array;
+	zipCentralDirectoryUint8Array: Uint8Array;
+	zipEndOfCentralDirectoryUint8Array: Uint8Array;
+}
+
+export const apkSignableSectionsParser: Parser<ApkSignableSections, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createParserConsumedSequenceParser(
+			createTupleParser([
+				createArrayParser(zipLocalFileParser),
+				createOptionalParser(zipArchiveDecryptionHeaderParser),
+				createOptionalParser(zipArchiveExtraDataRecordParser),
+			]),
+		),
+		createOptionalParser(
+			createParserConsumedSequenceParser(
+				apkSigningBlockParser
+			),
+		),
+		createParserConsumedSequenceParser(
+			createTupleParser([
+				createArrayParser(zipCentralDirectoryHeaderParser),
+				createOptionalParser(zip64EndOfCentralDirectoryRecordParser),
+				createOptionalParser(zip64EndOfCentralDirectoryLocatorParser),
+			]),
+		),
+		createParserConsumedSequenceParser(
+			zipEndOfCentralDirectoryRecordParser,
+		),
+	]),
+	async ([
+		[
+			[
+				zipLocalFiles,
+			],
+			zipLocalFilesUint8Array,
+		],
+		[
+			apkSigningBlock = undefined,
+			apkSigningBlockUint8Array = undefined,
+		] = [],
+		[
+			[
+				zipCentralDirectory,
+			],
+			zipCentralDirectoryUint8Array,
+		],
+		[
+			zipEndOfCentralDirectory,
+			zipEndOfCentralDirectoryUint8Array,
+		],
+	]) => ({
+		zipLocalFiles,
+		apkSigningBlock,
+		zipCentralDirectory,
+		zipEndOfCentralDirectory,
+
+		zipLocalFilesUint8Array,
+		apkSigningBlockUint8Array,
+		zipCentralDirectoryUint8Array,
+		zipEndOfCentralDirectoryUint8Array,
+	}),
+);

package/src/apkUnparser.test.ts

@@ -0,0 +1,37 @@
+import test from 'ava';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { runParser } from './parser.js';
+import { apkParser, apkSigningBlockParser } from './apkParser.js';
+import { runUnparser } from './unparser.js';
+import { apkSigningBlockUnparser } from './apkUnparser.js';
+import { uint8ArrayUnparserOutputCompanion } from './unparserOutputCompanion.js';
+import invariant from 'invariant';
+
+for (const apkCid of [
+	'bafkreicckcmzrdxwoc3w2in3tivpyxrdtcfpct4zwauq3igew3nkpvfapu',
+]) {
+	test(
+		'apk ' + apkCid,
+		async t => {
+			const apkResponse = await fetch('https://ipfs.io/ipfs/' + apkCid);
+
+			const apkStream = apkResponse.body!;
+
+			const apk = await runParser(apkParser, apkStream, uint8ArrayParserInputCompanion, {
+				errorJoinMode: 'all',
+			});
+
+			const apkSigningBlock = apk.signingBlock;
+
+			invariant(apkSigningBlock, 'APK has no signing block');
+
+			const apkSigningBlockStream = runUnparser(apkSigningBlockUnparser, apkSigningBlock, uint8ArrayUnparserOutputCompanion);
+
+			const actual = await runParser(apkSigningBlockParser, apkSigningBlockStream, uint8ArrayParserInputCompanion, {
+				errorJoinMode: 'all',
+			});
+
+			t.deepEqual(actual, apkSigningBlock);
+		},
+	);
+}

package/src/apkUnparser.ts

@@ -0,0 +1,120 @@
+import { ApkSignatureV2AdditionalAttribute, ApkSignatureV2Digest, ApkSignatureV2Signature, ApkSignatureV2SignedData, ApkSignatureV2Signer, ApkSigningBlock } from "./apk.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 apkSignatureV2DigestUnparser: Unparser<ApkSignatureV2Digest, Uint8Array> = createUint32LengthPrefixedUnparser(async function * (input, unparserContext) {
+	yield * uint32LEUnparser(input.signatureAlgorithmId, unparserContext);
+	yield * uint32LEUnparser(input.digest.length, unparserContext);
+	yield input.digest;
+});
+
+const apkSignatureV2DigestsUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(apkSignatureV2DigestUnparser));
+
+const apkSignatureV2CertificateUnparser = createUint32LengthPrefixedUnparser(uint8ArrayUnparser);
+
+const apkSignatureV2CertificatesUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(apkSignatureV2CertificateUnparser));
+
+const apkSignatureV2AdditionalAttributeUnparser: Unparser<ApkSignatureV2AdditionalAttribute, Uint8Array> = createUint32LengthPrefixedUnparser(async function * (input, unparserContext) {
+	yield * uint32LEUnparser(input.id, unparserContext);
+	yield input.value;
+});
+
+const apkSignatureV2AdditionalAttributesUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(apkSignatureV2AdditionalAttributeUnparser));
+
+export const apkSignatureV2SignedDataUnparser: Unparser<ApkSignatureV2SignedData, Uint8Array> = createUint32LengthPrefixedUnparser(async function * (input, unparserContext) {
+	yield * apkSignatureV2DigestsUnparser(input.digests, unparserContext);
+	yield * apkSignatureV2CertificatesUnparser(input.certificates, unparserContext);
+	yield * apkSignatureV2AdditionalAttributesUnparser(input.additionalAttributes, unparserContext);
+	if (input.zeroPaddingLength) {
+		yield Buffer.alloc(input.zeroPaddingLength);
+	}
+});
+
+const apkSignatureV2SignatureUnparser: Unparser<ApkSignatureV2Signature, Uint8Array> = createUint32LengthPrefixedUnparser(async function * (input, unparserContext) {
+	yield * uint32LEUnparser(input.signatureAlgorithmId, unparserContext);
+	yield * uint32LEUnparser(input.signature.length, unparserContext);
+	yield input.signature;
+});
+
+const apkSignatureV2SignaturesUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(apkSignatureV2SignatureUnparser));
+
+const apkSignatureV2PublicKeyUnparser = createUint32LengthPrefixedUnparser(uint8ArrayUnparser);
+
+const apkSignatureV2SignerUnparser: Unparser<ApkSignatureV2Signer, Uint8Array> = createUint32LengthPrefixedUnparser(async function * (input, unparserContext) {
+	yield * apkSignatureV2SignedDataUnparser(input.signedData, unparserContext);
+	yield * apkSignatureV2SignaturesUnparser(input.signatures, unparserContext);
+	yield * apkSignatureV2PublicKeyUnparser(input.publicKey, unparserContext);
+});
+
+const apkSignatureV2SignersUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(apkSignatureV2SignerUnparser));
+
+type ApkSigningBlockPair = {
+	id: number;
+	value: Uint8Array | ApkSignatureV2Signer[];
+};
+
+const apkSigningBlockPairUnparser: Unparser<ApkSigningBlockPair, Uint8Array> = createUint64LengthPrefixedUnparser(async function * (input, unparserContext) {
+	yield * uint32LEUnparser(input.id, unparserContext);
+	if (input.value instanceof Uint8Array) {
+		yield input.value;
+	} else {
+		yield * apkSignatureV2SignersUnparser(input.value, unparserContext);
+	}
+});
+
+const apkSigningBlockPairsUnparser = createArrayUnparser(apkSigningBlockPairUnparser);
+
+export const apkSigningBlockUnparser: Unparser<ApkSigningBlock, 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 * apkSigningBlockPairsUnparser(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/arbitraryFileSystemEntry.ts

@@ -14,10 +14,8 @@ type FileSystemFile = {
 
 export type FileSystemEntry =
 	| FileSystemFile
-	| FileSystemDirectory
-;
-
-export const arbitraryFileSystemEntry = fc.letrec((tie) => ({
+	| FileSystemDirectory;
+export const arbitraryFileSystemEntry = fc.letrec(tie => ({
 	entry: fc.oneof<[
 		fc.Arbitrary<FileSystemFile>,
 		fc.Arbitrary<FileSystemDirectory>,

package/src/arbitraryZip.ts

@@ -1,10 +1,13 @@
 import * as fc from 'fast-check';
-import { Zip, ZipDirectoryEntry, ZipEntry, ZipFileEntry } from './zip.js';
-import { arbitraryDosDateTime } from './arbitraryDosDateTime.js';
-import { createArbitraryZipPermissions } from './arbitraryZipPermissions.js';
 import invariant from 'invariant';
-
-const DOS_DIRECTORY_FLAG = 0b00010000;
+import {
+	type Zip,
+	type ZipDirectoryEntry,
+	type ZipFileEntry,
+	type ZipEntry,
+	type ZipEntryAttributes,
+} from './zip.js';
+import { arbitraryDosDateTime } from './arbitraryDosDateTime.js';
 
 const arbitraryPath = fc.string({ minLength: 1 }).filter(path => {
 	const pathSegments = path.split('/');
@@ -26,7 +29,10 @@ const createArbitraryZipEntry = (platform: 'unix' | 'dos') => fc.oneof<[
 		path: arbitraryPath,
 		date: arbitraryDosDateTime,
 		comment: fc.string(),
-		permissions: createArbitraryZipPermissions(platform),
+		hostSystem: fc.constant(platform),
+		attributes: fc.record<ZipEntryAttributes>({
+			directory: fc.constant(false),
+		}),
 		compression: fc.oneof(
 			fc.constant('store' as const),
 			fc.constant('deflate' as const),
@@ -40,13 +46,6 @@ const createArbitraryZipEntry = (platform: 'unix' | 'dos') => fc.oneof<[
 			return false;
 		}
 
-		if (
-			zipFileEntry.permissions.type === 'dos'
-				&& zipFileEntry.permissions.dosPermissions & DOS_DIRECTORY_FLAG
-		) {
-			return false;
-		}
-
 		return true;
 	}),
 	fc.record<ZipDirectoryEntry>({
@@ -54,16 +53,10 @@ const createArbitraryZipEntry = (platform: 'unix' | 'dos') => fc.oneof<[
 		path: arbitraryPath,
 		date: arbitraryDosDateTime,
 		comment: fc.string(),
-		permissions: createArbitraryZipPermissions(platform),
-	}).filter(zipDirectoryEntry => {
-		if (
-			zipDirectoryEntry.permissions.type === 'dos'
-				&& !(zipDirectoryEntry.permissions.dosPermissions & DOS_DIRECTORY_FLAG)
-		) {
-			return false;
-		}
-
-		return true;
+		hostSystem: fc.constant(platform),
+		attributes: fc.record<ZipEntryAttributes>({
+			directory: fc.constant(false),
+		}),
 	}),
 );
 
@@ -106,10 +99,10 @@ const createArbitraryZipEntries = (platform: 'unix' | 'dos') => (
 							path: directoryPath,
 							date: entry.date,
 							comment: '',
-							permissions: entry.permissions.type === 'dos' ? {
-								type: 'dos',
-								dosPermissions: entry.permissions.dosPermissions | DOS_DIRECTORY_FLAG,
-							} : entry.permissions,
+							hostSystem: platform,
+							attributes: {
+								directory: true,
+							},
 						});
 
 						seenDirectoryPaths.add(directoryPath);

package/src/arbitraryZipPermissions.ts

@@ -1,25 +0,0 @@
-import * as fc from 'fast-check';
-import { ZipDosPermissions, ZipUnixPermissions } from './zip.js';
-
-const arbitraryZipUnixPermissions = fc.record<ZipUnixPermissions>({
-	type: fc.constant('unix'),
-	unixPermissions: (
-		fc.nat({ max: 0b0000000111111111 })
-			.filter((unixPermissions) => unixPermissions > 0)
-	),
-});
-
-const arbitraryZipDosPermissions = fc.record<ZipDosPermissions>({
-	type: fc.constant('dos'),
-	dosPermissions: (
-		fc.nat({ max: 0b00111111 })
-	),
-});
-
-export const createArbitraryZipPermissions = (type: 'unix' | 'dos') => {
-	if (type === 'unix') {
-		return arbitraryZipUnixPermissions;
-	}
-
-	return arbitraryZipDosPermissions;
-};

package/src/arbitraryZipStream.ts

@@ -1,13 +1,13 @@
 import JSZip from 'jszip';
-import { ZipEntry } from './zip.js';
+import { type ZipEntry } from './zip.js';
 import { arbitraryZip } from './arbitraryZip.js';
 
 function addZipEntryToZip(zip: JSZip, zipEntry: ZipEntry) {
 	const options = {
 		comment: zipEntry.comment,
 		date: zipEntry.date,
-		unixPermissions: zipEntry.permissions.type === 'unix' ? zipEntry.permissions.unixPermissions : undefined,
-		dosPermissions: zipEntry.permissions.type === 'dos' ? zipEntry.permissions.dosPermissions : undefined,
+		// unixPermissions: zipEntry.permissions.type === 'unix' ? zipEntry.permissions.unixPermissions : undefined,
+		// dosPermissions: zipEntry.permissions.type === 'dos' ? zipEntry.permissions.dosPermissions : undefined,
 	};
 
 	if (zipEntry.type === 'file') {
@@ -35,7 +35,7 @@ export const arbitraryZipStream = arbitraryZip.map(zip => {
 	const zipInternalStream = jsZip.generateInternalStream({
 		type: 'uint8array',
 		comment: zip.comment,
-		platform: zip.entries.at(0)?.permissions.type.toUpperCase() as any,
+		platform: zip.entries.at(0)?.hostSystem.toUpperCase() as any,
 	});
 
 	const zipStream = new ReadableStream<Uint8Array>({