@yume-chan/adb 0.0.10 → 0.0.13

package/src/crypto.ts

@@ -1,51 +1,64 @@
+import { getBigUint64, setBigUint64 } from '@yume-chan/dataview-bigint-polyfill/esm/fallback.js';
+
 const BigInt0 = BigInt(0);
 const BigInt1 = BigInt(1);
 const BigInt2 = BigInt(2);
+const BigInt64 = BigInt(64);
 
-const BigInt2To64 = BigInt2 ** BigInt(64);
-
-export function getBig(
-    buffer: ArrayBuffer,
-    offset = 0,
-    length = buffer.byteLength - offset
-): bigint {
-    const view = new DataView(buffer);
-
+/**
+ * Gets the `BigInt` value at the specified byte offset and length from the start of the view. There is
+ * no alignment constraint; multi-byte values may be fetched from any offset.
+ *
+ * Only supports Big-Endian, because that's what ADB uses.
+ * @param byteOffset The place in the buffer at which the value should be retrieved.
+ */
+export function getBigUint(dataView: DataView, byteOffset: number, length: number): bigint {
     let result = BigInt0;
 
-    // Now `length` must be a multiplication of 8
+    // Currently `length` must be a multiplication of 8
     // Support for arbitrary length can be easily added
 
-    for (let i = offset; i < offset + length; i += 8) {
-        result *= BigInt2To64;
-        const value = view.getBigUint64(i, false);
+    for (let i = byteOffset; i < byteOffset + length; i += 8) {
+        result <<= BigInt64;
+        const value = getBigUint64(dataView, i, false);
         result += value;
     }
 
     return result;
 }
 
-export function setBig(buffer: ArrayBuffer, value: bigint, offset: number = 0) {
-    const uint64Array: bigint[] = [];
-    while (value > BigInt0) {
-        uint64Array.push(BigInt.asUintN(64, value));
-        value /= BigInt2To64;
-    }
+/**
+ * Stores an arbitrary-precision positive `BigInt` value at the specified byte offset from the start of the view.
+ * @param byteOffset The place in the buffer at which the value should be set.
+ * @param value The value to set.
+ * @param littleEndian If `false` or `undefined`, a big-endian value should be written,
+ * otherwise a little-endian value should be written.
+ */
+export function setBigUint(dataView: DataView, byteOffset: number, value: bigint, littleEndian?: boolean) {
+    const start = byteOffset;
+
+    if (littleEndian) {
+        while (value > BigInt0) {
+            setBigUint64(dataView, byteOffset, value, true);
+            byteOffset += 8;
+            value >>= BigInt64;
+        }
+    } else {
+        // Because we don't know how long (in bits) the `value` is,
+        // Convert it to an array of `uint64` first.
+        const uint64Array: bigint[] = [];
+        while (value > BigInt0) {
+            uint64Array.push(BigInt.asUintN(64, value));
+            value >>= BigInt64;
+        }
 
-    const view = new DataView(buffer);
-    for (let i = uint64Array.length - 1; i >= 0; i -= 1) {
-        view.setBigUint64(offset, uint64Array[i], false);
-        offset += 8;
+        for (let i = uint64Array.length - 1; i >= 0; i -= 1) {
+            setBigUint64(dataView, byteOffset, uint64Array[i]!, false);
+            byteOffset += 8;
+        }
     }
-}
 
-export function setBigLE(buffer: ArrayBuffer, value: bigint, offset = 0) {
-    const view = new DataView(buffer);
-    while (value > BigInt0) {
-        view.setBigUint64(offset, value, true);
-        offset += 8;
-        value /= BigInt2To64;
-    }
+    return byteOffset - start;
 }
 
 // These values are correct only if
@@ -74,10 +87,10 @@ const RsaPrivateKeyNLength = 2048 / 8;
 const RsaPrivateKeyDOffset = 303;
 const RsaPrivateKeyDLength = 2048 / 8;
 
-export function parsePrivateKey(key: ArrayBuffer): [n: bigint, d: bigint] {
-    let n = getBig(key, RsaPrivateKeyNOffset, RsaPrivateKeyNLength);
-    let d = getBig(key, RsaPrivateKeyDOffset, RsaPrivateKeyDLength);
-
+export function parsePrivateKey(key: Uint8Array): [n: bigint, d: bigint] {
+    const view = new DataView(key.buffer, key.byteOffset, key.byteLength);
+    const n = getBigUint(view, RsaPrivateKeyNOffset, RsaPrivateKeyNLength);
+    const d = getBigUint(view, RsaPrivateKeyDOffset, RsaPrivateKeyDLength);
     return [n, d];
 }
 
@@ -85,11 +98,6 @@ export function parsePrivateKey(key: ArrayBuffer): [n: bigint, d: bigint] {
 // I can't understand, but it does work
 // Only used with numbers less than 2^32 so doesn't need BigInt
 export function modInverse(a: number, m: number) {
-    // validate inputs
-    [a, m] = [Number(a), Number(m)];
-    if (Number.isNaN(a) || Number.isNaN(m)) {
-        return NaN; // invalid input
-    }
     a = (a % m + m) % m;
     if (!a || m < 2) {
         return NaN; // invalid input
@@ -108,7 +116,7 @@ export function modInverse(a: number, m: number) {
     let x = 1;
     let y = 0;
     for (let i = s.length - 2; i >= 0; --i) {
-        [x, y] = [y, x - y * Math.floor(s[i].a / s[i].b)];
+        [x, y] = [y, x - y * Math.floor(s[i]!.a / s[i]!.b)];
     }
     return (y % m + m) % m;
 }
@@ -118,18 +126,16 @@ export function calculatePublicKeyLength() {
 }
 
 export function calculatePublicKey(
-    privateKey: ArrayBuffer
-): ArrayBuffer;
+    privateKey: Uint8Array
+): Uint8Array;
 export function calculatePublicKey(
-    privateKey: ArrayBuffer,
-    output: ArrayBuffer,
-    outputOffset?: number
+    privateKey: Uint8Array,
+    output: Uint8Array,
 ): number;
 export function calculatePublicKey(
-    privateKey: ArrayBuffer,
-    output?: ArrayBuffer,
-    outputOffset: number = 0
-): ArrayBuffer | number {
+    privateKey: Uint8Array,
+    output?: Uint8Array,
+): Uint8Array | number {
     // Android has its own public key generation algorithm
     // See https://android.googlesource.com/platform/system/core.git/+/91784040db2b9273687f88d8b95f729d4a61ecc2/libcrypto_utils/android_pubkey.cpp#111
 
@@ -138,7 +144,7 @@ export function calculatePublicKey(
     // [
     //   modulusLengthInWords, // 32-bit integer, a "word" is 32-bit so it must be 2048 / 8 / 4
     //                         // Actually the comment in Android source code was wrong
-    //   n0inv,                // 32-bit integer, the modular inverse of (lower 32 bits of) n
+    //   n0inv,                // 32-bit integer, the modular inverse of (low 32 bits of n)
     //   modulus,              // n
     //   rr,                   // Montgomery parameter R^2
     //   exponent,             // 32-bit integer, must be 65537
@@ -150,20 +156,21 @@ export function calculatePublicKey(
     // extract `n` from private key
     const [n] = parsePrivateKey(privateKey);
 
-    let outputType: 'ArrayBuffer' | 'number';
+    let outputType: 'Uint8Array' | 'number';
     const outputLength = calculatePublicKeyLength();
     if (!output) {
-        output = new ArrayBuffer(outputLength);
-        outputType = 'ArrayBuffer';
+        output = new Uint8Array(outputLength);
+        outputType = 'Uint8Array';
     } else {
-        if (output.byteLength - outputOffset < outputLength) {
+        if (output.byteLength < outputLength) {
             throw new Error('output buffer is too small');
         }
 
         outputType = 'number';
     }
 
-    const outputView = new DataView(output);
+    const outputView = new DataView(output.buffer, output.byteOffset, output.byteLength);
+    let outputOffset = 0;
 
     // modulusLengthInWords
     outputView.setUint32(outputOffset, 2048 / 8 / 4, true);
@@ -177,19 +184,18 @@ export function calculatePublicKey(
     outputOffset += 4;
 
     // Write n
-    setBigLE(output, n, outputOffset);
+    setBigUint(outputView, outputOffset, n, true);
     outputOffset += 256;
 
     // Calculate rr = (2^(rsa_size)) ^ 2 mod n
     let rr = BigInt(2) ** BigInt(4096) % n;
-    setBigLE(output, rr, outputOffset);
-    outputOffset += 256;
+    outputOffset += setBigUint(outputView, outputOffset, rr, true);
 
     // exponent
     outputView.setUint32(outputOffset, 65537, true);
     outputOffset += 4;
 
-    if (outputType === 'ArrayBuffer') {
+    if (outputType === 'Uint8Array') {
         return output;
     } else {
         return outputLength;
@@ -223,22 +229,22 @@ export function powMod(base: bigint, exponent: bigint, modulus: bigint): bigint
     return r;
 }
 
-export const Sha1DigestLength = 20;
+export const SHA1_DIGEST_LENGTH = 20;
 
-export const Asn1Sequence = 0x30;
-export const Asn1OctetString = 0x04;
-export const Asn1Null = 0x05;
-export const Asn1Oid = 0x06;
+export const ASN1_SEQUENCE = 0x30;
+export const ASN1_OCTET_STRING = 0x04;
+export const ASN1_NULL = 0x05;
+export const ASN1_OID = 0x06;
 
 // PKCS#1 SHA-1 hash digest info
-export const Sha1DigestInfo = [
-    Asn1Sequence, 0x0d + Sha1DigestLength,
-    Asn1Sequence, 0x09,
+export const SHA1_DIGEST_INFO = new Uint8Array([
+    ASN1_SEQUENCE, 0x0d + SHA1_DIGEST_LENGTH,
+    ASN1_SEQUENCE, 0x09,
     // SHA-1 (1 3 14 3 2 26)
-    Asn1Oid, 0x05, 1 * 40 + 3, 14, 3, 2, 26,
-    Asn1Null, 0x00,
-    Asn1OctetString, Sha1DigestLength
-];
+    ASN1_OID, 0x05, 1 * 40 + 3, 14, 3, 2, 26,
+    ASN1_NULL, 0x00,
+    ASN1_OCTET_STRING, SHA1_DIGEST_LENGTH
+]);
 
 // SubtleCrypto.sign() will hash the given data and sign the hash
 // But we don't need the hashing step
@@ -246,7 +252,7 @@ export const Sha1DigestInfo = [
 // encrypt the given data with its private key)
 // However SubtileCrypto.encrypt() doesn't accept 'RSASSA-PKCS1-v1_5' algorithm
 // So we need to implement the encryption by ourself
-export function sign(privateKey: ArrayBuffer, data: ArrayBuffer): ArrayBuffer {
+export function sign(privateKey: Uint8Array, data: Uint8Array): Uint8Array {
     const [n, d] = parsePrivateKey(privateKey);
 
     // PKCS#1 padding
@@ -259,7 +265,7 @@ export function sign(privateKey: ArrayBuffer, data: ArrayBuffer): ArrayBuffer {
     padded[index] = 1;
     index += 1;
 
-    const fillLength = padded.length - Sha1DigestInfo.length - data.byteLength - 1;
+    const fillLength = padded.length - SHA1_DIGEST_INFO.length - data.length - 1;
     while (index < fillLength) {
         padded[index] = 0xff;
         index += 1;
@@ -268,18 +274,23 @@ export function sign(privateKey: ArrayBuffer, data: ArrayBuffer): ArrayBuffer {
     padded[index] = 0;
     index += 1;
 
-    padded.set(new Uint8Array(Sha1DigestInfo), index);
-    index += Sha1DigestInfo.length;
+    padded.set(SHA1_DIGEST_INFO, index);
+    index += SHA1_DIGEST_INFO.length;
 
-    padded.set(new Uint8Array(data), index);
+    padded.set(data, index);
 
     // Encryption
     // signature = padded ** d % n
-    let signature = powMod(getBig(padded.buffer), d, n);
-
-    // Put into an ArrayBuffer
-    const result = new ArrayBuffer(256);
-    setBig(result, signature);
-
-    return result;
+    const view = new DataView(padded.buffer);
+    const signature = powMod(
+        getBigUint(view, 0, view.byteLength),
+        d,
+        n
+    );
+
+    // `padded` is not used anymore,
+    // re-use the buffer to store the result
+    setBigUint(view, 0, signature, false);
+
+    return padded;
 }

package/src/features.ts

@@ -1,5 +1,9 @@
+// The order follows
+// https://android.googlesource.com/platform/packages/modules/adb/+/79010dc6d5ca7490c493df800d4421730f5466ca/transport.cpp#1252
 export enum AdbFeatures {
-    StatV2 = 'stat_v2',
+    ShellV2 = "shell_v2",
     Cmd = 'cmd',
-    ShellV2 = "shell_v2"
+    StatV2 = 'stat_v2',
+    ListV2 = 'ls_v2',
+    FixedPushMkdir = 'fixed_push_mkdir',
 }

package/src/index.ts

@@ -1,10 +1,11 @@
-export * from './adb';
-export * from './auth';
-export * from './backend';
-export * from './commands';
-export * from './crypto';
-export * from './features';
-export * from './packet';
-export * from './socket';
-export * from './stream';
-export * from './utils';
+
+export * from './adb.js';
+export * from './auth.js';
+export * from './backend.js';
+export * from './commands/index.js';
+export * from './crypto.js';
+export * from './features.js';
+export * from './packet.js';
+export * from './socket/index.js';
+export * from './stream/index.js';
+export * from './utils/index.js';

package/src/packet.ts

@@ -1,6 +1,5 @@
 import Struct from '@yume-chan/struct';
-import { AdbBackend } from './backend';
-import { BufferedStream } from './stream';
+import { TransformStream } from "./stream/index.js";
 
 export enum AdbCommand {
     Auth = 0x48545541,    // 'AUTH'
@@ -11,7 +10,7 @@ export enum AdbCommand {
     Write = 0x45545257,   // 'WRTE'
 }
 
-const AdbPacketHeader =
+export const AdbPacketHeader =
     new Struct({ littleEndian: true })
         .uint32('command')
         .uint32('arg0')
@@ -20,65 +19,62 @@ const AdbPacketHeader =
         .uint32('checksum')
         .int32('magic');
 
-const AdbPacketStruct =
+export type AdbPacketHeader = typeof AdbPacketHeader['TDeserializeResult'];
+
+type AdbPacketHeaderInit = typeof AdbPacketHeader['TInit'];
+
+export const AdbPacket =
     new Struct({ littleEndian: true })
         .fields(AdbPacketHeader)
-        .arrayBuffer('payload', { lengthField: 'payloadLength' });
+        .uint8Array('payload', { lengthField: 'payloadLength' });
 
-export type AdbPacket = typeof AdbPacketStruct['TDeserializeResult'];
+export type AdbPacket = typeof AdbPacket['TDeserializeResult'];
 
-export type AdbPacketInit = Omit<typeof AdbPacketStruct['TInit'], 'checksum' | 'magic'>;
+/**
+ * `AdbPacketData` contains all the useful fields of `AdbPacket`.
+ *
+ * `AdbBackend#connect` will return a `ReadableStream<AdbPacketData>`,
+ * so each backend can encode `AdbPacket` in different ways.
+ *
+ * `AdbBackend#connect` will return a `WritableStream<AdbPacketInit>`,
+ * however, `AdbPacketDispatcher` will transform `AdbPacketData` to `AdbPacketInit` for you,
+ * so `AdbSocket#writable#write` only needs `AdbPacketData`.
+ */
+export type AdbPacketData = Omit<typeof AdbPacket['TInit'], 'checksum' | 'magic'>;
 
-export namespace AdbPacket {
-    export async function read(backend: AdbBackend): Promise<AdbPacket> {
-        // Detect boundary
-        // Note that it relies on the backend to only return data from one write operation
-        let buffer: ArrayBuffer;
-        do {
-            // Maybe it's a payload from last connection.
-            // Ignore and try again
-            buffer = await backend.read(24);
-        } while (buffer.byteLength !== 24);
-
-        let bufferUsed = false;
-        const stream = new BufferedStream({
-            async read(length: number) {
-                if (!bufferUsed) {
-                    bufferUsed = true;
-                    return buffer;
-                }
-                return backend.read(length);
-            }
-        });
+// All fields except `magic`, which can be calculated in `AdbPacketSerializeStream`
+export type AdbPacketInit = Omit<typeof AdbPacket['TInit'], 'magic'>;
 
-        return AdbPacketStruct.deserialize(stream);
+export function calculateChecksum(payload: Uint8Array): number;
+export function calculateChecksum(init: AdbPacketData): AdbPacketInit;
+export function calculateChecksum(payload: Uint8Array | AdbPacketData): number | AdbPacketInit {
+    if (payload instanceof Uint8Array) {
+        return payload.reduce((result, item) => result + item, 0);
+    } else {
+        (payload as AdbPacketInit).checksum = calculateChecksum(payload.payload);
+        return payload as AdbPacketInit;
     }
+}
 
-    export async function write(
-        init: AdbPacketInit,
-        calculateChecksum: boolean,
-        backend: AdbBackend
-    ): Promise<void> {
-        let checksum: number;
-        if (calculateChecksum && init.payload) {
-            const array = new Uint8Array(init.payload);
-            checksum = array.reduce((result, item) => result + item, 0);
-        } else {
-            checksum = 0;
-        }
+export class AdbPacketSerializeStream extends TransformStream<AdbPacketInit, Uint8Array>{
+    public constructor() {
+        super({
+            transform: async (init, controller) => {
+                // This syntax is ugly, but I don't want to create a new object.
+                (init as unknown as AdbPacketHeaderInit).magic = init.command ^ 0xFFFFFFFF;
+                (init as unknown as AdbPacketHeaderInit).payloadLength = init.payload.byteLength;
 
-        const packet = {
-            ...init,
-            checksum,
-            magic: init.command ^ 0xFFFFFFFF,
-            payloadLength: init.payload.byteLength,
-        };
+                controller.enqueue(
+                    AdbPacketHeader.serialize(
+                        init as unknown as AdbPacketHeaderInit
+                    )
+                );
 
-        // Write payload separately to avoid an extra copy
-        const header = AdbPacketHeader.serialize(packet);
-        await backend.write(header);
-        if (packet.payload.byteLength) {
-            await backend.write(packet.payload);
-        }
+                if (init.payload.byteLength) {
+                    // Enqueue payload separately to avoid copying
+                    controller.enqueue(init.payload);
+                }
+            },
+        });
     }
 }