@yume-chan/adb 0.0.19 → 0.0.21

package/src/{crypto.ts → daemon/crypto.ts}

@@ -3,11 +3,6 @@ import {
     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);
-
 /**
  * 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.
@@ -18,15 +13,15 @@ const BigInt64 = BigInt(64);
 export function getBigUint(
     dataView: DataView,
     byteOffset: number,
-    length: number
+    length: number,
 ): bigint {
-    let result = BigInt0;
+    let result = 0n;
 
     // Currently `length` must be a multiplication of 8
     // Support for arbitrary length can be easily added
 
     for (let i = byteOffset; i < byteOffset + length; i += 8) {
-        result <<= BigInt64;
+        result <<= 64n;
         const value = getBigUint64(dataView, i, false);
         result += value;
     }
@@ -45,23 +40,23 @@ export function setBigUint(
     dataView: DataView,
     byteOffset: number,
     value: bigint,
-    littleEndian?: boolean
+    littleEndian?: boolean,
 ) {
     const start = byteOffset;
 
     if (littleEndian) {
-        while (value > BigInt0) {
+        while (value > 0n) {
             setBigUint64(dataView, byteOffset, value, true);
             byteOffset += 8;
-            value >>= BigInt64;
+            value >>= 64n;
         }
     } 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) {
+        while (value > 0n) {
             uint64Array.push(BigInt.asUintN(64, value));
-            value >>= BigInt64;
+            value >>= 64n;
         }
 
         for (let i = uint64Array.length - 1; i >= 0; i -= 1) {
@@ -99,7 +94,7 @@ const RsaPrivateKeyNLength = 2048 / 8;
 const RsaPrivateKeyDOffset = 303;
 const RsaPrivateKeyDLength = 2048 / 8;
 
-export function parsePrivateKey(key: Uint8Array): [n: bigint, d: bigint] {
+export function rsaParsePrivateKey(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);
@@ -133,18 +128,18 @@ export function modInverse(a: number, m: number) {
     return ((y % m) + m) % m;
 }
 
-export function calculatePublicKeyLength() {
+export function adbGetPublicKeySize() {
     return 4 + 4 + 2048 / 8 + 2048 / 8 + 4;
 }
 
-export function calculatePublicKey(privateKey: Uint8Array): Uint8Array;
-export function calculatePublicKey(
+export function adbGeneratePublicKey(privateKey: Uint8Array): Uint8Array;
+export function adbGeneratePublicKey(
     privateKey: Uint8Array,
-    output: Uint8Array
+    output: Uint8Array,
 ): number;
-export function calculatePublicKey(
+export function adbGeneratePublicKey(
     privateKey: Uint8Array,
-    output?: 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
@@ -163,11 +158,8 @@ export function calculatePublicKey(
     // (All in little endian)
     // See https://android.googlesource.com/platform/system/core.git/+/91784040db2b9273687f88d8b95f729d4a61ecc2/libcrypto_utils/android_pubkey.cpp#38
 
-    // extract `n` from private key
-    const [n] = parsePrivateKey(privateKey);
-
     let outputType: "Uint8Array" | "number";
-    const outputLength = calculatePublicKeyLength();
+    const outputLength = adbGetPublicKeySize();
     if (!output) {
         output = new Uint8Array(outputLength);
         outputType = "Uint8Array";
@@ -182,7 +174,7 @@ export function calculatePublicKey(
     const outputView = new DataView(
         output.buffer,
         output.byteOffset,
-        output.byteLength
+        output.byteLength,
     );
     let outputOffset = 0;
 
@@ -190,13 +182,13 @@ export function calculatePublicKey(
     outputView.setUint32(outputOffset, 2048 / 8 / 4, true);
     outputOffset += 4;
 
+    // extract `n` from private key
+    const [n] = rsaParsePrivateKey(privateKey);
+
     // Calculate `n0inv`
-    // Don't know why need to multiple -1
+    // Don't know why need to multiply by -1
     // Didn't exist in Android codebase
-    const n0inv = modInverse(
-        Number(BigInt.asUintN(32, n) * BigInt(-1)),
-        2 ** 32
-    );
+    const n0inv = modInverse(-Number(BigInt.asUintN(32, n)), 2 ** 32);
     outputView.setUint32(outputOffset, n0inv, true);
     outputOffset += 4;
 
@@ -205,7 +197,7 @@ export function calculatePublicKey(
     outputOffset += 256;
 
     // Calculate rr = (2^(rsa_size)) ^ 2 mod n
-    const rr = BigInt(2) ** BigInt(4096) % n;
+    const rr = 2n ** 4096n % n;
     outputOffset += setBigUint(outputView, outputOffset, rr, true);
 
     // exponent
@@ -229,22 +221,22 @@ export function calculatePublicKey(
 export function powMod(
     base: bigint,
     exponent: bigint,
-    modulus: bigint
+    modulus: bigint,
 ): bigint {
-    if (modulus === BigInt1) {
-        return BigInt0;
+    if (modulus === 1n) {
+        return 0n;
     }
 
-    let r = BigInt1;
+    let r = 1n;
     base = base % modulus;
 
-    while (exponent > BigInt0) {
-        if (BigInt.asUintN(1, exponent) === BigInt1) {
+    while (exponent > 0n) {
+        if (BigInt.asUintN(1, exponent) === 1n) {
             r = (r * base) % modulus;
         }
 
-        exponent >>= BigInt1;
-        base = base ** BigInt2 % modulus;
+        base = (base * base) % modulus;
+        exponent >>= 1n;
     }
 
     return r;
@@ -283,8 +275,8 @@ export const SHA1_DIGEST_INFO = new Uint8Array([
 // 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: Uint8Array, data: Uint8Array): Uint8Array {
-    const [n, d] = parsePrivateKey(privateKey);
+export function rsaSign(privateKey: Uint8Array, data: Uint8Array): Uint8Array {
+    const [n, d] = rsaParsePrivateKey(privateKey);
 
     // PKCS#1 padding
     const padded = new Uint8Array(256);

package/src/{backend.ts → daemon/device.ts}

@@ -3,7 +3,7 @@ import type { ValueOrPromise } from "@yume-chan/struct";
 
 import type { AdbPacketData, AdbPacketInit } from "./packet.js";
 
-export interface AdbBackend {
+export interface AdbDaemonDevice {
     readonly serial: string;
 
     readonly name: string | undefined;

package/src/{socket → daemon}/dispatcher.ts

@@ -1,5 +1,4 @@
 import { AsyncOperationManager, PromiseResolver } from "@yume-chan/async";
-import type { RemoveEventListener } from "@yume-chan/event";
 import type {
     Consumable,
     ReadableWritablePair,
@@ -10,15 +9,14 @@ import {
     ConsumableWritableStream,
     WritableStream,
 } from "@yume-chan/stream-extra";
-import type { ValueOrPromise } from "@yume-chan/struct";
 import { EMPTY_UINT8_ARRAY } from "@yume-chan/struct";
 
-import type { AdbPacketData, AdbPacketInit } from "../packet.js";
-import { AdbCommand, calculateChecksum } from "../packet.js";
-import { decodeUtf8, encodeUtf8 } from "../utils/index.js";
+import type { AdbIncomingSocketHandler, AdbSocket, Closeable } from "../adb.js";
+import { decodeUtf8, encodeUtf8, unreachable } from "../utils/index.js";
 
-import type { AdbSocket } from "./socket.js";
-import { AdbSocketController } from "./socket.js";
+import type { AdbPacketData, AdbPacketInit } from "./packet.js";
+import { AdbCommand, calculateChecksum } from "./packet.js";
+import { AdbDaemonSocketController } from "./socket.js";
 
 export interface AdbPacketDispatcherOptions {
     calculateChecksum: boolean;
@@ -30,14 +28,10 @@ export interface AdbPacketDispatcherOptions {
      */
     appendNullToServiceString: boolean;
     maxPayloadSize: number;
-}
-
-export type AdbIncomingSocketHandler = (
-    socket: AdbSocket
-) => ValueOrPromise<boolean>;
-
-export interface Closeable {
-    close(): ValueOrPromise<void>;
+    /**
+     * Whether to preserve the connection open after the `AdbPacketDispatcher` is closed.
+     */
+    preserveConnection?: boolean | undefined;
 }
 
 /**
@@ -53,32 +47,31 @@ export interface Closeable {
 export class AdbPacketDispatcher implements Closeable {
     // ADB socket id starts from 1
     // (0 means open failed)
-    private readonly initializers = new AsyncOperationManager(1);
+    readonly #initializers = new AsyncOperationManager(1);
     /**
      * Socket local ID to the socket controller.
      */
-    private readonly sockets = new Map<number, AdbSocketController>();
+    readonly #sockets = new Map<number, AdbDaemonSocketController>();
 
-    private _writer: WritableStreamDefaultWriter<Consumable<AdbPacketInit>>;
+    #writer: WritableStreamDefaultWriter<Consumable<AdbPacketInit>>;
 
-    public readonly options: AdbPacketDispatcherOptions;
+    readonly options: AdbPacketDispatcherOptions;
 
-    private _closed = false;
-    private _disconnected = new PromiseResolver<void>();
-    public get disconnected() {
-        return this._disconnected.promise;
+    #closed = false;
+    #disconnected = new PromiseResolver<void>();
+    get disconnected() {
+        return this.#disconnected.promise;
     }
 
-    private _incomingSocketHandlers: Set<AdbIncomingSocketHandler> = new Set();
-
-    private _abortController = new AbortController();
+    #incomingSocketHandlers = new Map<string, AdbIncomingSocketHandler>();
+    #readAbortController = new AbortController();
 
-    public constructor(
+    constructor(
         connection: ReadableWritablePair<
             AdbPacketData,
             Consumable<AdbPacketInit>
         >,
-        options: AdbPacketDispatcherOptions
+        options: AdbPacketDispatcherOptions,
     ) {
         this.options = options;
 
@@ -88,28 +81,28 @@ export class AdbPacketDispatcher implements Closeable {
                     write: async (packet) => {
                         switch (packet.command) {
                             case AdbCommand.OK:
-                                this.handleOk(packet);
+                                this.#handleOk(packet);
                                 break;
                             case AdbCommand.Close:
-                                await this.handleClose(packet);
+                                await this.#handleClose(packet);
                                 break;
                             case AdbCommand.Write:
-                                if (this.sockets.has(packet.arg1)) {
-                                    await this.sockets
+                                if (this.#sockets.has(packet.arg1)) {
+                                    await this.#sockets
                                         .get(packet.arg1)!
                                         .enqueue(packet.payload);
                                     await this.sendPacket(
                                         AdbCommand.OK,
                                         packet.arg1,
-                                        packet.arg0
+                                        packet.arg0,
                                     );
                                     break;
                                 }
                                 throw new Error(
-                                    `Unknown local socket id: ${packet.arg1}`
+                                    `Unknown local socket id: ${packet.arg1}`,
                                 );
                             case AdbCommand.Open:
-                                await this.handleOpen(packet);
+                                await this.#handleOpen(packet);
                                 break;
                             default:
                                 // Junk data may only appear in the authentication phase,
@@ -118,44 +111,39 @@ export class AdbPacketDispatcher implements Closeable {
                                 // (although it's possible that Adb added new commands in the future)
                                 throw new Error(
                                     `Unknown command: ${packet.command.toString(
-                                        16
-                                    )}`
+                                        16,
+                                    )}`,
                                 );
                         }
                     },
                 }),
                 {
-                    // There are multiple reasons for the pipe to stop,
-                    // (device disconnection, protocol error, or user abortion)
-                    // if the underlying streams are still open,
-                    // it's still possible to create another ADB connection.
-                    // So don't close `readable` here.
-                    preventCancel: true,
-                    signal: this._abortController.signal,
-                }
+                    preventCancel: options.preserveConnection ?? false,
+                    signal: this.#readAbortController.signal,
+                },
             )
             .then(
                 () => {
-                    this.dispose();
+                    this.#dispose();
                 },
                 (e) => {
-                    if (!this._closed) {
-                        this._disconnected.reject(e);
+                    if (!this.#closed) {
+                        this.#disconnected.reject(e);
                     }
-                    this.dispose();
-                }
+                    this.#dispose();
+                },
             );
 
-        this._writer = connection.writable.getWriter();
+        this.#writer = connection.writable.getWriter();
     }
 
-    private handleOk(packet: AdbPacketData) {
-        if (this.initializers.resolve(packet.arg1, packet.arg0)) {
+    #handleOk(packet: AdbPacketData) {
+        if (this.#initializers.resolve(packet.arg1, packet.arg0)) {
             // Device successfully created the socket
             return;
         }
 
-        const socket = this.sockets.get(packet.arg1);
+        const socket = this.#sockets.get(packet.arg1);
         if (socket) {
             // Device has received last `WRTE` to the socket
             socket.ack();
@@ -167,13 +155,13 @@ export class AdbPacketDispatcher implements Closeable {
         void this.sendPacket(AdbCommand.Close, packet.arg1, packet.arg0);
     }
 
-    private async handleClose(packet: AdbPacketData) {
+    async #handleClose(packet: AdbPacketData) {
         // If the socket is still pending
         if (
             packet.arg0 === 0 &&
-            this.initializers.reject(
+            this.#initializers.reject(
                 packet.arg1,
-                new Error("Socket open failed")
+                new Error("Socket open failed"),
             )
         ) {
             // Device failed to create the socket
@@ -192,18 +180,18 @@ export class AdbPacketDispatcher implements Closeable {
          */
 
         // Ignore `arg0` and search for the socket
-        const socket = this.sockets.get(packet.arg1);
+        const socket = this.#sockets.get(packet.arg1);
         if (socket) {
             // The device want to close the socket
             if (!socket.closed) {
                 await this.sendPacket(
                     AdbCommand.Close,
                     packet.arg1,
-                    packet.arg0
+                    packet.arg0,
                 );
             }
             await socket.dispose();
-            this.sockets.delete(packet.arg1);
+            this.#sockets.delete(packet.arg1);
             return;
         }
 
@@ -212,77 +200,80 @@ export class AdbPacketDispatcher implements Closeable {
         // the device may also respond with two `CLSE` packets.
     }
 
-    /**
-     * Add a handler for incoming socket.
-     * @param handler A function to call with new incoming sockets. It must return `true` if it accepts the socket.
-     * @returns A function to remove the handler.
-     */
-    public onIncomingSocket(
-        handler: AdbIncomingSocketHandler
-    ): RemoveEventListener {
-        this._incomingSocketHandlers.add(handler);
-        const remove = () => {
-            this._incomingSocketHandlers.delete(handler);
-        };
-        remove.dispose = remove;
-        return remove;
+    addReverseTunnel(service: string, handler: AdbIncomingSocketHandler) {
+        this.#incomingSocketHandlers.set(service, handler);
+    }
+
+    removeReverseTunnel(address: string) {
+        this.#incomingSocketHandlers.delete(address);
+    }
+
+    clearReverseTunnels() {
+        this.#incomingSocketHandlers.clear();
     }
 
-    private async handleOpen(packet: AdbPacketData) {
+    async #handleOpen(packet: AdbPacketData) {
         // `AsyncOperationManager` doesn't support skipping IDs
         // Use `add` + `resolve` to simulate this behavior
-        const [localId] = this.initializers.add<number>();
-        this.initializers.resolve(localId, undefined);
+        const [localId] = this.#initializers.add<number>();
+        this.#initializers.resolve(localId, undefined);
 
         const remoteId = packet.arg0;
-        const serviceString = decodeUtf8(packet.payload);
+        let service = decodeUtf8(packet.payload);
+        if (service.endsWith("\0")) {
+            service = service.substring(0, service.length - 1);
+        }
 
-        const controller = new AdbSocketController({
+        const handler = this.#incomingSocketHandlers.get(service);
+        if (!handler) {
+            await this.sendPacket(AdbCommand.Close, 0, remoteId);
+            return;
+        }
+
+        const controller = new AdbDaemonSocketController({
             dispatcher: this,
             localId,
             remoteId,
             localCreated: false,
-            serviceString,
+            service,
         });
 
-        for (const handler of this._incomingSocketHandlers) {
-            if (await handler(controller.socket)) {
-                this.sockets.set(localId, controller);
-                await this.sendPacket(AdbCommand.OK, localId, remoteId);
-                return;
-            }
+        try {
+            await handler(controller.socket);
+            this.#sockets.set(localId, controller);
+            await this.sendPacket(AdbCommand.OK, localId, remoteId);
+        } catch (e) {
+            await this.sendPacket(AdbCommand.Close, 0, remoteId);
         }
-
-        await this.sendPacket(AdbCommand.Close, 0, remoteId);
     }
 
-    public async createSocket(serviceString: string): Promise<AdbSocket> {
+    async createSocket(service: string): Promise<AdbSocket> {
         if (this.options.appendNullToServiceString) {
-            serviceString += "\0";
+            service += "\0";
         }
 
-        const [localId, initializer] = this.initializers.add<number>();
-        await this.sendPacket(AdbCommand.Open, localId, 0, serviceString);
+        const [localId, initializer] = this.#initializers.add<number>();
+        await this.sendPacket(AdbCommand.Open, localId, 0, service);
 
         // Fulfilled by `handleOk`
         const remoteId = await initializer;
-        const controller = new AdbSocketController({
+        const controller = new AdbDaemonSocketController({
             dispatcher: this,
             localId,
             remoteId,
             localCreated: true,
-            serviceString,
+            service,
         });
-        this.sockets.set(localId, controller);
+        this.#sockets.set(localId, controller);
 
         return controller.socket;
     }
 
-    public async sendPacket(
+    async sendPacket(
         command: AdbCommand,
         arg0: number,
         arg1: number,
-        payload: string | Uint8Array = EMPTY_UINT8_ARRAY
+        payload: string | Uint8Array = EMPTY_UINT8_ARRAY,
     ): Promise<void> {
         if (typeof payload === "string") {
             payload = encodeUtf8(payload);
@@ -292,7 +283,7 @@ export class AdbPacketDispatcher implements Closeable {
             throw new Error("payload too large");
         }
 
-        await ConsumableWritableStream.write(this._writer, {
+        await ConsumableWritableStream.write(this.#writer, {
             command,
             arg0,
             arg1,
@@ -304,29 +295,32 @@ export class AdbPacketDispatcher implements Closeable {
         });
     }
 
-    public async close() {
+    async close() {
         // Send `CLSE` packets for all sockets
         await Promise.all(
-            Array.from(this.sockets.values(), (socket) => socket.close())
+            Array.from(this.#sockets.values(), (socket) => socket.close()),
         );
 
         // Stop receiving
         // It's possible that we haven't received all `CLSE` confirm packets,
         // but it doesn't matter, the next connection can cope with them.
-        this._closed = true;
-        this._abortController.abort();
-        this._writer.releaseLock();
+        this.#closed = true;
+
+        this.#readAbortController.abort();
+        if (this.options.preserveConnection ?? false) {
+            this.#writer.releaseLock();
+        } else {
+            await this.#writer.close();
+        }
 
         // `pipe().then()` will call `dispose`
     }
 
-    private dispose() {
-        for (const socket of this.sockets.values()) {
-            socket.dispose().catch((e) => {
-                void e;
-            });
+    #dispose() {
+        for (const socket of this.#sockets.values()) {
+            socket.dispose().catch(unreachable);
         }
 
-        this._disconnected.resolve();
+        this.#disconnected.resolve();
     }
 }

package/src/daemon/index.ts

@@ -0,0 +1,7 @@
+export * from "./auth.js";
+export * from "./crypto.js";
+export * from "./device.js";
+export * from "./dispatcher.js";
+export * from "./packet.js";
+export * from "./socket.js";
+export * from "./transport.js";

package/src/{packet.ts → daemon/packet.ts}

@@ -23,7 +23,7 @@ export type AdbPacketHeader = (typeof AdbPacketHeader)["TDeserializeResult"];
 type AdbPacketHeaderInit = (typeof AdbPacketHeader)["TInit"];
 
 export const AdbPacket = new Struct({ littleEndian: true })
-    .fields(AdbPacketHeader)
+    .concat(AdbPacketHeader)
     .uint8Array("payload", { lengthField: "payloadLength" });
 
 export type AdbPacket = (typeof AdbPacket)["TDeserializeResult"];
@@ -31,11 +31,11 @@ export type AdbPacket = (typeof AdbPacket)["TDeserializeResult"];
 /**
  * `AdbPacketData` contains all the useful fields of `AdbPacket`.
  *
- * `AdbBackend#connect` will return a `ReadableStream<AdbPacketData>`,
- * so each backend can encode `AdbPacket` in different ways.
+ * `AdvDaemonConnection#connect` will return a `ReadableStream<AdbPacketData>`,
+ * allow each connection to encode `AdbPacket` in different methods.
  *
- * `AdbBackend#connect` will return a `WritableStream<AdbPacketInit>`,
- * however, `AdbPacketDispatcher` will transform `AdbPacketData` to `AdbPacketInit` for you,
+ * `AdbDaemonConnection#connect` will return a `WritableStream<AdbPacketInit>`,
+ * however, `AdbDaemonTransport` will transform `AdbPacketData` to `AdbPacketInit` for you,
  * so `AdbSocket#writable#write` only needs `AdbPacketData`.
  */
 export type AdbPacketData = Omit<
@@ -53,7 +53,7 @@ export class AdbPacketSerializeStream extends ConsumableTransformStream<
     AdbPacketInit,
     Uint8Array
 > {
-    public constructor() {
+    constructor() {
         const headerBuffer = new Uint8Array(AdbPacketHeader.size);
         super({
             transform: async (chunk, controller) => {