@futpib/parser 1.0.0 → 1.0.2

package/src/dalvikExecutable.ts

@@ -0,0 +1,220 @@
+
+export type DalvikExecutableAccessFlags = {
+	public: boolean,
+	private: boolean,
+	protected: boolean,
+	static: boolean,
+	final: boolean,
+	synchronized: boolean,
+	volatile: boolean,
+	bridge: boolean,
+	transient: boolean,
+	varargs: boolean,
+	native: boolean,
+	interface: boolean,
+	abstract: boolean,
+	strict: boolean,
+	synthetic: boolean,
+	annotation: boolean,
+	enum: boolean,
+	constructor: boolean,
+	declaredSynchronized: boolean,
+};
+
+export type DalvikExecutableEncodedValue = number | DalvikExecutableEncodedValue[] | undefined;
+
+type DalvikExecutableTry = {
+	startAddress: number;
+	instructionCount: number;
+	handler: DalvikExecutableEncodedCatchHandler;
+};
+
+type DalvikExecutableEncodedTypeAddressPair = {
+	type: string;
+	address: number;
+};
+
+type DalvikExecutableEncodedCatchHandler = {
+	handlers: DalvikExecutableEncodedTypeAddressPair[],
+	catchAllAddress: undefined | number,
+};
+
+export type DalvikExecutableCode<Instructions> = {
+	registersSize: number;
+	insSize: number;
+	outsSize: number;
+	debugInfo: undefined | DalvikExecutableDebugInfo;
+	instructions: Instructions;
+	tries: DalvikExecutableTry[];
+};
+
+type DalvikExecutableDebugByteCodeValue =
+	| {
+		type: 'advancePc';
+		addressDiff: number;
+	}
+	| {
+		type: 'advanceLine';
+		lineDiff: number;
+	}
+	| {
+		type: 'startLocal';
+		registerNum: number;
+		name: undefined | string;
+		type_: undefined | string;
+	}
+	| {
+		type: 'startLocalExtended';
+		registerNum: number;
+		name: undefined | string;
+		type_: undefined | string;
+		signature: undefined | string;
+	}
+	| {
+		type: 'endLocal';
+		registerNum: number;
+	}
+	| {
+		type: 'restartLocal';
+		registerNum: number;
+	}
+	| {
+		type: 'setPrologueEnd';
+	}
+	| {
+		type: 'setEpilogueBegin';
+	}
+	| {
+		type: 'setFile';
+		name: undefined | string;
+	}
+	| {
+		type: 'special';
+		value: number;
+	}
+;
+
+type DalvikExecutableDebugByteCode = DalvikExecutableDebugByteCodeValue[];
+
+export type DalvikExecutableDebugInfo = {
+	lineStart: number;
+	parameterNames: (undefined | string)[];
+	bytecode: DalvikExecutableDebugByteCode;
+};
+
+type DalvikExecutableAnnotationItemVisibility =
+	| 'build'
+	| 'runtime'
+	| 'system'
+;
+
+type DalvikExecutableAnnotationElement = {
+	name: string;
+	value: DalvikExecutableEncodedValue;
+};
+
+export type DalvikExecutableAnnotation = {
+	visibility: DalvikExecutableAnnotationItemVisibility;
+	type: string;
+	elements: DalvikExecutableAnnotationElement[];
+}
+
+export type DalvikExecutablePrototype = {
+	shorty: string;
+	returnType: string;
+	parameters: string[];
+};
+
+export type DalvikExecutableField = {
+	class: string;
+	type: string;
+	name: string;
+};
+
+export function isDalvikExecutableField(x: unknown): x is DalvikExecutableField {
+	return (
+		x !== null
+			&& typeof x === 'object'
+			&& 'class' in x
+			&& 'type' in x
+			&& 'name' in x
+			&& typeof (x as DalvikExecutableField).class === 'string'
+			&& typeof (x as DalvikExecutableField).type === 'string'
+			&& typeof (x as DalvikExecutableField).name === 'string'
+	);
+}
+
+export type DalvikExecutableFieldWithAccess = {
+	field: DalvikExecutableField;
+	accessFlags: DalvikExecutableAccessFlags;
+};
+
+export type DalvikExecutableMethod = {
+	class: string;
+	prototype: DalvikExecutablePrototype;
+	name: string;
+};
+
+export function isDalvikExecutableMethod(x: unknown): x is DalvikExecutableMethod {
+	return (
+		x !== null
+			&& typeof x === 'object'
+			&& 'class' in x
+			&& 'prototype' in x
+			&& 'name' in x
+			&& typeof (x as DalvikExecutableMethod).class === 'string'
+			&& typeof (x as DalvikExecutableMethod).prototype === 'object'
+			&& typeof (x as DalvikExecutableMethod).name === 'string'
+	);
+}
+
+export type DalvikExecutableMethodWithAccess<Instructions> = {
+	method: DalvikExecutableMethod;
+	accessFlags: DalvikExecutableAccessFlags;
+	code: undefined | DalvikExecutableCode<Instructions>;
+};
+
+export type DalvikExecutableClassFieldAnnotation = {
+	field: DalvikExecutableField;
+	annotations: undefined | DalvikExecutableAnnotation[];
+};
+
+export type DalvikExecutableClassMethodAnnotation = {
+	method: DalvikExecutableMethod;
+	annotations: undefined | DalvikExecutableAnnotation[];
+};
+
+export type DalvikExecutableClassParameterAnnotation = {
+	method: DalvikExecutableMethod;
+	annotations: undefined | (undefined | DalvikExecutableAnnotation[])[];
+};
+
+export type DalvikExecutableClassAnnotations = {
+	classAnnotations: undefined | DalvikExecutableAnnotation[];
+	fieldAnnotations: DalvikExecutableClassFieldAnnotation[];
+	methodAnnotations: DalvikExecutableClassMethodAnnotation[];
+	parameterAnnotations: DalvikExecutableClassParameterAnnotation[];
+};
+
+export type DalvikExecutableClassData<Instructions> = {
+	staticFields: DalvikExecutableFieldWithAccess[];
+	instanceFields: DalvikExecutableFieldWithAccess[];
+	directMethods: DalvikExecutableMethodWithAccess<Instructions>[];
+	virtualMethods: DalvikExecutableMethodWithAccess<Instructions>[];
+};
+
+export type DalvikExecutableClassDefinition<Instructions> = {
+	class: string;
+	accessFlags: DalvikExecutableAccessFlags,
+	superclass: string;
+	interfaces: string[];
+	sourceFile: undefined | string;
+	annotations: undefined | DalvikExecutableClassAnnotations;
+	staticValues: DalvikExecutableEncodedValue[];
+	classData: undefined | DalvikExecutableClassData<Instructions>;
+};
+
+export type DalvikExecutable<Instructions> = {
+	classDefinitions: DalvikExecutableClassDefinition<Instructions>[];
+	link: undefined | Uint8Array,
+};

package/src/dalvikExecutableParser/stringSyntaxParser.ts

@@ -0,0 +1,145 @@
+import invariant from "invariant";
+import { Parser, setParserName } from "../parser.js";
+import { ParserContext } from "../parserContext.js";
+import { promiseCompose } from "../promiseCompose.js";
+import { createSeparatedArrayParser } from "../separatedArrayParser.js";
+import { createExactSequenceParser } from "../exactSequenceParser.js";
+import { createUnionParser } from "../unionParser.js";
+import { createTupleParser } from "../tupleParser.js";
+import { createArrayParser } from "../arrayParser.js";
+
+export const smaliSimpleNameParser: Parser<string, string> = async (parserContext: ParserContext<string, string>) => {
+	const characters: string[] = [];
+
+	while (true) {
+		const character = await parserContext.peek(0);
+
+		parserContext.invariant(character !== undefined, 'Unexpected end of input');
+
+		invariant(character !== undefined, 'Unexpected end of input');
+
+		if (
+			(
+				character >= 'a' && character <= 'z'
+			)
+				|| (
+					character >= 'A' && character <= 'Z'
+				)
+				|| (
+					character >= '0' && character <= '9'
+				)
+				|| (
+					character === ' '
+				)
+				|| (
+					character === '$'
+				)
+				|| (
+					character === '-'
+				)
+				|| (
+					character === '_'
+				)
+				|| (
+					character === '\u00a0'
+				)
+				|| (
+					character >= '\u00a1' && character <= '\u1fff'
+				)
+				|| (
+					character >= '\u2000' && character <= '\u200a'
+				)
+				|| (
+					character >= '\u2010' && character <= '\u2027'
+				)
+				|| (
+					character === '\u202f'
+				)
+				|| (
+					character >= '\u2030' && character <= '\ud7ff'
+				)
+				|| (
+					character >= '\ue000' && character <= '\uffef'
+				)
+				|| (
+					character >= '\ud800' && character <= '\udbff'
+				)
+		) {
+			parserContext.skip(1);
+
+			characters.push(character);
+
+			continue;
+		}
+
+		parserContext.invariant(characters.length > 0, 'Expected at least one character');
+
+		break;
+	}
+
+	return characters.join('');
+};
+
+setParserName(smaliSimpleNameParser, 'smaliSimpleNameParser');
+
+export const smaliMemberNameParser: Parser<string, string> = createUnionParser([
+	smaliSimpleNameParser,
+	promiseCompose(
+		createTupleParser([
+			createExactSequenceParser('<'),
+			smaliSimpleNameParser,
+			createExactSequenceParser('>'),
+		]),
+		(strings) => strings.join(''),
+	),
+]);
+
+setParserName(smaliMemberNameParser, 'smaliMemberNameParser');
+
+const smaliFullClassNameParser: Parser<string, string> = promiseCompose(
+	createSeparatedArrayParser(
+		smaliMemberNameParser,
+		createExactSequenceParser('/'),
+	),
+	(pathSegments) => pathSegments.join('/'),
+);
+
+setParserName(smaliFullClassNameParser, 'smaliFullClassNameParser');
+
+const smaliNonArrayFieldTypeDescriptorParser: Parser<string, string> = createUnionParser([
+	createExactSequenceParser('Z'),
+	createExactSequenceParser('B'),
+	createExactSequenceParser('S'),
+	createExactSequenceParser('C'),
+	createExactSequenceParser('I'),
+	createExactSequenceParser('J'),
+	createExactSequenceParser('F'),
+	createExactSequenceParser('D'),
+	promiseCompose(
+		createTupleParser([
+			createExactSequenceParser('L'),
+			smaliFullClassNameParser,
+			createExactSequenceParser(';'),
+		]),
+		strings => strings.join(''),
+	),
+]);
+
+setParserName(smaliNonArrayFieldTypeDescriptorParser, 'smaliNonArrayFieldTypeDescriptorParser');
+
+const smaliFieldTypeDescriptorParser: Parser<string, string> = promiseCompose(
+	createTupleParser([
+		createArrayParser(createExactSequenceParser('[')),
+		smaliNonArrayFieldTypeDescriptorParser,
+	]),
+	([ strings, string ]) => strings.join('') + string,
+);
+
+setParserName(smaliFieldTypeDescriptorParser, 'smaliFieldTypeDescriptorParser');
+
+export const smaliTypeDescriptorParser: Parser<string, string> = createUnionParser([
+	createExactSequenceParser('V'),
+	smaliFieldTypeDescriptorParser,
+]);
+
+setParserName(smaliTypeDescriptorParser, 'smaliTypeDescriptorParser');

package/src/dalvikExecutableParser/typeParsers.ts

@@ -0,0 +1,65 @@
+import { createElementParser } from "../elementParser.js";
+import { createFixedLengthSequenceParser } from "../fixedLengthSequenceParser.js";
+import { uleb128NumberParser } from "../leb128Parser.js";
+import { Parser } from "../parser.js";
+import { promiseCompose } from "../promiseCompose.js";
+
+export const uleb128p1NumberParser: Parser<number, Uint8Array> = async (parserContext) => {
+	const value = await uleb128NumberParser(parserContext);
+	return value - 1;
+}
+
+export const ubyteParser: Parser<number, Uint8Array> = createElementParser();
+
+export const byteParser: Parser<number, Uint8Array> = promiseCompose(
+	ubyteParser,
+	(ubyte) => ubyte > 127 ? ubyte - 256 : ubyte,
+);
+
+export const shortParser: Parser<number, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser<Uint8Array>(2),
+	(uint8Array) => {
+		const buffer = Buffer.from(uint8Array);
+		return buffer.readInt16LE(0);
+	},
+);
+
+export const ushortParser: Parser<number, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser<Uint8Array>(2),
+	(uint8Array) => {
+		const buffer = Buffer.from(uint8Array);
+		return buffer.readUInt16LE(0);
+	},
+);
+
+export const intParser: Parser<number, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser<Uint8Array>(4),
+	(uint8Array) => {
+		const buffer = Buffer.from(uint8Array);
+		return buffer.readInt32LE(0);
+	},
+);
+
+export const uintParser: Parser<number, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser<Uint8Array>(4),
+	(uint8Array) => {
+		const buffer = Buffer.from(uint8Array);
+		return buffer.readUInt32LE(0);
+	},
+);
+
+export const longParser: Parser<bigint, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser<Uint8Array>(8),
+	(uint8Array) => {
+		const buffer = Buffer.from(uint8Array);
+		return buffer.readBigInt64LE(0);
+	},
+);
+
+export const ulongParser: Parser<bigint, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser<Uint8Array>(8),
+	(uint8Array) => {
+		const buffer = Buffer.from(uint8Array);
+		return buffer.readBigUInt64LE(0);
+	},
+);

package/src/dalvikExecutableParser/typedNumbers.ts

@@ -0,0 +1,57 @@
+import { Newtype, iso } from 'newtype-ts';
+
+export interface IndexIntoStringIds extends Newtype<{ readonly IndexIntoStringIds: unique symbol }, number> {}
+export const isoIndexIntoStringIds = iso<IndexIntoStringIds>();
+
+export interface IndexIntoTypeIds extends Newtype<{ readonly IndexIntoTypeIds: unique symbol }, number> {}
+export const isoIndexIntoTypeIds = iso<IndexIntoTypeIds>();
+
+export interface IndexIntoPrototypeIds extends Newtype<{ readonly IndexIntoPrototypeIds: unique symbol }, number> {}
+export const isoIndexIntoPrototypeIds = iso<IndexIntoPrototypeIds>();
+
+export interface IndexIntoFieldIds extends Newtype<{ readonly IndexIntoFieldIds: unique symbol }, number> {}
+export const isoIndexIntoFieldIds = iso<IndexIntoFieldIds>();
+
+export interface IndexIntoMethodIds extends Newtype<{ readonly IndexIntoMethodIds: unique symbol }, number> {}
+export const isoIndexIntoMethodIds = iso<IndexIntoMethodIds>();
+
+export interface OffsetToStringDataItem extends Newtype<{ readonly OffsetToStringDataItem: unique symbol }, number> {}
+export const isoOffsetToStringDataItem = iso<OffsetToStringDataItem>();
+
+export interface OffsetToTypeList extends Newtype<{ readonly OffsetToTypeList: unique symbol }, number> {}
+export const isoOffsetToTypeList = iso<OffsetToTypeList>();
+
+export interface OffsetToAnnotationsDirectoryItem extends Newtype<{ readonly OffsetToAnnotationsDirectoryItem: unique symbol }, number> {}
+export const isoOffsetToAnnotationsDirectoryItem = iso<OffsetToAnnotationsDirectoryItem>();
+
+export interface OffsetToAnnotationSetItem extends Newtype<{ readonly OffsetToAnnotationSetItem: unique symbol }, number> {}
+export const isoOffsetToAnnotationSetItem = iso<OffsetToAnnotationSetItem>();
+
+export interface OffsetToAnnotationSetRefListItem extends Newtype<{ readonly OffsetToAnnotationSetRefListItem: unique symbol }, number> {}
+export const isoOffsetToAnnotationSetRefListItem = iso<OffsetToAnnotationSetRefListItem>();
+
+export interface OffsetToClassDataItem extends Newtype<{ readonly OffsetToClassDataItem: unique symbol }, number> {}
+export const isoOffsetToClassDataItem = iso<OffsetToClassDataItem>();
+
+export interface OffsetToEncodedArrayItem extends Newtype<{ readonly OffsetToEncodedArrayItem: unique symbol }, number> {}
+export const isoOffsetToEncodedArrayItem = iso<OffsetToEncodedArrayItem>();
+
+export interface OffsetToCodeItem extends Newtype<{ readonly OffsetToCodeItem: unique symbol }, number> {}
+export const isoOffsetToCodeItem = iso<OffsetToCodeItem>();
+
+export interface OffsetToDebugInfoItem extends Newtype<{ readonly OffsetToDebugInfoItem: unique symbol }, number> {}
+export const isoOffsetToDebugInfoItem = iso<OffsetToDebugInfoItem>();
+
+export interface OffsetToAnnotationItem extends Newtype<{ readonly OffsetToAnnotationItem: unique symbol }, number> {}
+export const isoOffsetToAnnotationItem = iso<OffsetToAnnotationItem>();
+
+export interface OffsetFromEncodedCatchHandlerListToEncodedCatchHandler extends Newtype<{ readonly OffsetFromEncodedCatchHandlerListToEncodedCatchHandler: unique symbol }, number> {}
+export const isoOffsetFromEncodedCatchHandlerListToEncodedCatchHandler = iso<OffsetFromEncodedCatchHandlerListToEncodedCatchHandler>();
+
+export interface TypedNumberArray<IndexType, ValueType> extends Newtype<{ readonly TypedNumberArray: unique symbol }, Array<ValueType>> {
+	get length(): number;
+	at(index: IndexType): undefined | ValueType;
+	map<NewValueType>(fn: (value: ValueType, index: IndexType) => NewValueType): TypedNumberArray<IndexType, NewValueType>;
+	[Symbol.iterator](): IterableIterator<ValueType>;
+};
+export const getIsoTypedNumberArray = <IndexType, ValueType>() => iso<TypedNumberArray<IndexType, ValueType>>();

package/src/dalvikExecutableParser.test.ts

@@ -0,0 +1,89 @@
+import test from 'ava';
+import { runParser } from './parser.js';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { dalvikExecutableParser, dalvikExecutableWithRawInstructionsParser } from './dalvikExecutableParser.js';
+import { fetchCid } from './fetchCid.js';
+
+for (const [ dexCid, shouldSnapshot ] of [
+	[ 'bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', true ],
+	[ 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', false ],
+	[ 'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', false ],
+	[ 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', false ],
+] as const) {
+	test.serial(
+		'dex (with instructions as bytes) ' + dexCid,
+		async t => {
+			const dexStream = await fetchCid(dexCid);
+
+			const actual = await runParser(dalvikExecutableWithRawInstructionsParser, dexStream, uint8ArrayParserInputCompanion, {
+				errorJoinMode: 'all',
+			});
+
+			if (shouldSnapshot) {
+				t.snapshot(actual);
+			} else {
+				//console.dir(actual, { depth: null });
+				t.pass();
+			}
+		},
+	);
+}
+
+type ObjectPath = (string | symbol | number)[];
+
+function objectWalk(object: unknown, f: (path: ObjectPath, value: unknown) => void, initialPath: ObjectPath = []) {
+	f(initialPath, object);
+
+	if (
+		!object
+			|| typeof object !== 'object'
+	) {
+		return;
+	}
+
+	if (Array.isArray(object)) {
+		for (const [ index, value ] of object.entries()) {
+			objectWalk(value, f, [ ...initialPath, index ]);
+		}
+	} else {
+		for (const [ key, value ] of Object.entries(object)) {
+			objectWalk(value, f, [ ...initialPath, key ]);
+		}
+	}
+}
+
+for (const [ dexCid, shouldSnapshot ] of [
+	[ 'bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', true ],
+	// [ 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', false ],
+	// [ 'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', false ],
+	// [ 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', false ],
+] as const) {
+	test.serial(
+		'dex (with parsed instructions) ' + dexCid,
+		async t => {
+			const dexStream = await fetchCid(dexCid);
+
+			const actual = await runParser(dalvikExecutableParser, dexStream, uint8ArrayParserInputCompanion, {
+				errorJoinMode: 'all',
+			});
+
+			objectWalk(actual, (path) => {
+				const key = path.at(-1);
+
+				if (typeof key !== 'string') {
+					return;
+				}
+
+				t.false(key.endsWith('Offset'), 'All offsets should be resolved: ' + path.join('.'));
+				t.false(key.endsWith('Index'), 'All indexes should be resolved: ' + path.join('.'));
+			});
+
+			if (shouldSnapshot) {
+				t.snapshot(actual);
+			} else {
+				//console.dir(actual, { depth: null });
+				t.pass();
+			}
+		},
+	);
+}