@yume-chan/adb 0.0.20 → 0.0.22

package/src/commands/sync/sync.ts

@@ -48,27 +48,27 @@ export class AdbSync extends AutoDisposable {
     readonly #supportsSendReceiveV2: boolean;
     readonly #needPushMkdirWorkaround: boolean;
 
-    public get supportsStat(): boolean {
+    get supportsStat(): boolean {
         return this.#supportsStat;
     }
 
-    public get supportsListV2(): boolean {
+    get supportsListV2(): boolean {
         return this.#supportsListV2;
     }
 
-    public get fixedPushMkdir(): boolean {
+    get fixedPushMkdir(): boolean {
         return this.#fixedPushMkdir;
     }
 
-    public get supportsSendReceiveV2(): boolean {
+    get supportsSendReceiveV2(): boolean {
         return this.#supportsSendReceiveV2;
     }
 
-    public get needPushMkdirWorkaround(): boolean {
+    get needPushMkdirWorkaround(): boolean {
         return this.#needPushMkdirWorkaround;
     }
 
-    public constructor(adb: Adb, socket: AdbSocket) {
+    constructor(adb: Adb, socket: AdbSocket) {
         super();
 
         this._adb = adb;
@@ -78,7 +78,7 @@ export class AdbSync extends AutoDisposable {
         this.#supportsListV2 = adb.supportsFeature(AdbFeature.ListV2);
         this.#fixedPushMkdir = adb.supportsFeature(AdbFeature.FixedPushMkdir);
         this.#supportsSendReceiveV2 = adb.supportsFeature(
-            AdbFeature.SendReceiveV2
+            AdbFeature.SendReceiveV2,
         );
         // https://android.googlesource.com/platform/packages/modules/adb/+/91768a57b7138166e0a3d11f79cd55909dda7014/client/file_sync_client.cpp#1361
         this.#needPushMkdirWorkaround =
@@ -86,19 +86,34 @@ export class AdbSync extends AutoDisposable {
             !this.fixedPushMkdir;
     }
 
-    public async lstat(path: string): Promise<AdbSyncStat> {
-        return await adbSyncLstat(this._socket, path, this.supportsStat);
+    /**
+     * Gets information of a file or folder.
+     *
+     * If `path` points to a symbolic link, the returned information is about the link itself (with `type` being `LinuxFileType.Link`).
+     */
+    async lstat(path: string): Promise<AdbSyncStat> {
+        return await adbSyncLstat(this._socket, path, this.#supportsStat);
     }
 
-    public async stat(path: string) {
-        if (!this.supportsStat) {
+    /**
+     * Gets the information of a file or folder.
+     *
+     * If `path` points to a symbolic link, it will be resolved and the returned information is about the target (with `type` being `LinuxFileType.File` or `LinuxFileType.Directory`).
+     */
+    async stat(path: string) {
+        if (!this.#supportsStat) {
             throw new Error("Not supported");
         }
 
         return await adbSyncStat(this._socket, path);
     }
 
-    public async isDirectory(path: string): Promise<boolean> {
+    /**
+     * Checks if `path` is a directory, or a symbolic link to a directory.
+     *
+     * This uses `lstat` internally, thus works on all Android versions.
+     */
+    async isDirectory(path: string): Promise<boolean> {
         try {
             await this.lstat(path + "/");
             return true;
@@ -107,11 +122,11 @@ export class AdbSync extends AutoDisposable {
         }
     }
 
-    public opendir(path: string): AsyncGenerator<AdbSyncEntry, void, void> {
+    opendir(path: string): AsyncGenerator<AdbSyncEntry, void, void> {
         return adbSyncOpenDir(this._socket, path, this.supportsListV2);
     }
 
-    public async readdir(path: string) {
+    async readdir(path: string) {
         const results: AdbSyncEntry[] = [];
         for await (const entry of this.opendir(path)) {
             results.push(entry);
@@ -125,7 +140,7 @@ export class AdbSync extends AutoDisposable {
      * @param filename The full path of the file on device to read.
      * @returns A `ReadableStream` that contains the file content.
      */
-    public read(filename: string): ReadableStream<Uint8Array> {
+    read(filename: string): ReadableStream<Uint8Array> {
         return adbSyncPull(this._socket, filename);
     }
 
@@ -134,7 +149,7 @@ export class AdbSync extends AutoDisposable {
      *
      * @param options The content and options of the file to write.
      */
-    public async write(options: AdbSyncWriteOptions): Promise<void> {
+    async write(options: AdbSyncWriteOptions): Promise<void> {
         if (this.needPushMkdirWorkaround) {
             // It may fail if the path is already existed.
             // Ignore the result.
@@ -153,7 +168,7 @@ export class AdbSync extends AutoDisposable {
         });
     }
 
-    public override async dispose() {
+    override async dispose() {
         super.dispose();
         await this._socket.close();
     }

package/src/commands/tcpip.ts

@@ -1,7 +1,51 @@
 import { AdbCommandBase } from "./base.js";
 
+/**
+ * ADB daemon checks for the following properties in the order of
+ *
+ * * `serviceListenAddresses` (`service.adb.listen_addrs`)
+ * * `servicePort` (`service.adb.tcp.port`)
+ * * `persistPort` (`persist.adb.tcp.port`)
+ *
+ * Once it finds a non-empty value, it will use it and ignore the rest.
+ *
+ * `serviceListenAddresses` and `persistPort` are fixed at build time,
+ * only `servicePort` can be changed using `setPort` and `disable`.
+ * This means if either `serviceListenAddresses` or `persistPort` is non-empty,
+ * ADB over WiFi is always enabled.
+ */
+export interface AdbTcpIpListenAddresses {
+    serviceListenAddresses: string[];
+    servicePort: number | undefined;
+    persistPort: number | undefined;
+}
+
 export class AdbTcpIpCommand extends AdbCommandBase {
-    public async setPort(port: number): Promise<string> {
+    #parsePort(value: string): number | undefined {
+        if (!value || value === "0") {
+            return undefined;
+        }
+        return Number.parseInt(value, 10);
+    }
+
+    async getListenAddresses(): Promise<AdbTcpIpListenAddresses> {
+        const serviceListenAddresses = await this.adb.getProp(
+            "service.adb.listen_addrs",
+        );
+        const servicePort = await this.adb.getProp("service.adb.tcp.port");
+        const persistPort = await this.adb.getProp("persist.adb.tcp.port");
+
+        return {
+            serviceListenAddresses:
+                serviceListenAddresses != ""
+                    ? serviceListenAddresses.split(",")
+                    : [],
+            servicePort: this.#parsePort(servicePort),
+            persistPort: this.#parsePort(persistPort),
+        };
+    }
+
+    async setPort(port: number): Promise<string> {
         if (port <= 0) {
             throw new Error(`Invalid port ${port}`);
         }
@@ -13,7 +57,7 @@ export class AdbTcpIpCommand extends AdbCommandBase {
         return output;
     }
 
-    public async disable(): Promise<string> {
+    async disable(): Promise<string> {
         const output = await this.adb.createSocketAndWait("usb:");
         if (output !== "restarting in USB mode\n") {
             throw new Error(output);

package/src/daemon/auth.ts

@@ -1,8 +1,13 @@
 import { PromiseResolver } from "@yume-chan/async";
 import type { Disposable } from "@yume-chan/event";
 import type { ValueOrPromise } from "@yume-chan/struct";
+import { EMPTY_UINT8_ARRAY } from "@yume-chan/struct";
 
-import { calculateBase64EncodedLength, encodeBase64 } from "../utils/index.js";
+import {
+    calculateBase64EncodedLength,
+    encodeBase64,
+    encodeUtf8,
+} from "../utils/index.js";
 
 import {
     adbGeneratePublicKey,
@@ -12,18 +17,26 @@ import {
 import type { AdbPacketData } from "./packet.js";
 import { AdbCommand } from "./packet.js";
 
-export type AdbKeyIterable = Iterable<Uint8Array> | AsyncIterable<Uint8Array>;
+export interface AdbPrivateKey {
+    /**
+     * The private key in PKCS #8 format.
+     */
+    buffer: Uint8Array;
+    name?: string | undefined;
+}
+
+export type AdbKeyIterable =
+    | Iterable<AdbPrivateKey>
+    | AsyncIterable<AdbPrivateKey>;
 
 export interface AdbCredentialStore {
     /**
-     * Generate and store a RSA private key with modulus length `2048` and public exponent `65537`.
-     *
-     * The returned `Uint8Array` is the private key in PKCS #8 format.
+     * Generates and stores a RSA private key with modulus length `2048` and public exponent `65537`.
      */
-    generateKey(): ValueOrPromise<Uint8Array>;
+    generateKey(): ValueOrPromise<AdbPrivateKey>;
 
     /**
-     * Synchronously or asynchronously iterate through all stored RSA private keys.
+     * Synchronously or asynchronously iterates through all stored RSA private keys.
      *
      * Each call to `iterateKeys` must return a different iterator that iterate through all stored keys.
      */
@@ -50,13 +63,13 @@ export interface AdbAuthenticator {
      */
     (
         credentialStore: AdbCredentialStore,
-        getNextRequest: () => Promise<AdbPacketData>
+        getNextRequest: () => Promise<AdbPacketData>,
     ): AsyncIterable<AdbPacketData>;
 }
 
 export const AdbSignatureAuthenticator: AdbAuthenticator = async function* (
     credentialStore: AdbCredentialStore,
-    getNextRequest: () => Promise<AdbPacketData>
+    getNextRequest: () => Promise<AdbPacketData>,
 ): AsyncIterable<AdbPacketData> {
     for await (const key of credentialStore.iterateKeys()) {
         const packet = await getNextRequest();
@@ -65,7 +78,7 @@ export const AdbSignatureAuthenticator: AdbAuthenticator = async function* (
             return;
         }
 
-        const signature = rsaSign(key, packet.payload);
+        const signature = rsaSign(key.buffer, packet.payload);
         yield {
             command: AdbCommand.Auth,
             arg0: AdbAuthType.Signature,
@@ -77,7 +90,7 @@ export const AdbSignatureAuthenticator: AdbAuthenticator = async function* (
 
 export const AdbPublicKeyAuthenticator: AdbAuthenticator = async function* (
     credentialStore: AdbCredentialStore,
-    getNextRequest: () => Promise<AdbPacketData>
+    getNextRequest: () => Promise<AdbPacketData>,
 ): AsyncIterable<AdbPacketData> {
     const packet = await getNextRequest();
 
@@ -85,7 +98,7 @@ export const AdbPublicKeyAuthenticator: AdbAuthenticator = async function* (
         return;
     }
 
-    let privateKey: Uint8Array | undefined;
+    let privateKey: AdbPrivateKey | undefined;
     for await (const key of credentialStore.iterateKeys()) {
         privateKey = key;
         break;
@@ -99,13 +112,23 @@ export const AdbPublicKeyAuthenticator: AdbAuthenticator = async function* (
     const [publicKeyBase64Length] =
         calculateBase64EncodedLength(publicKeyLength);
 
+    const nameBuffer = privateKey.name?.length
+        ? encodeUtf8(privateKey.name)
+        : EMPTY_UINT8_ARRAY;
     const publicKeyBuffer = new Uint8Array(
-        publicKeyBase64Length + 1 // Null character
+        publicKeyBase64Length +
+            (nameBuffer.length ? nameBuffer.length + 1 : 0) + // Space character + name
+            1, // Null character
     );
 
-    adbGeneratePublicKey(privateKey, publicKeyBuffer);
+    adbGeneratePublicKey(privateKey.buffer, publicKeyBuffer);
     encodeBase64(publicKeyBuffer.subarray(0, publicKeyLength), publicKeyBuffer);
 
+    if (nameBuffer.length) {
+        publicKeyBuffer[publicKeyBase64Length] = 0x20;
+        publicKeyBuffer.set(nameBuffer, publicKeyBase64Length + 1);
+    }
+
     yield {
         command: AdbCommand.Auth,
         arg0: AdbAuthType.PublicKey,
@@ -120,34 +143,30 @@ export const ADB_DEFAULT_AUTHENTICATORS: AdbAuthenticator[] = [
 ];
 
 export class AdbAuthenticationProcessor implements Disposable {
-    public readonly authenticators: readonly AdbAuthenticator[];
+    readonly authenticators: readonly AdbAuthenticator[];
 
-    private readonly credentialStore: AdbCredentialStore;
+    readonly #credentialStore: AdbCredentialStore;
 
     #pendingRequest = new PromiseResolver<AdbPacketData>();
     #iterator: AsyncIterator<AdbPacketData, void, void> | undefined;
 
-    public constructor(
+    constructor(
         authenticators: readonly AdbAuthenticator[],
-        credentialStore: AdbCredentialStore
+        credentialStore: AdbCredentialStore,
     ) {
         this.authenticators = authenticators;
-        this.credentialStore = credentialStore;
+        this.#credentialStore = credentialStore;
     }
 
-    private getNextRequest = (): Promise<AdbPacketData> => {
+    #getNextRequest = (): Promise<AdbPacketData> => {
         return this.#pendingRequest.promise;
     };
 
-    private async *invokeAuthenticator(): AsyncGenerator<
-        AdbPacketData,
-        void,
-        void
-    > {
+    async *#invokeAuthenticator(): AsyncGenerator<AdbPacketData, void, void> {
         for (const authenticator of this.authenticators) {
             for await (const packet of authenticator(
-                this.credentialStore,
-                this.getNextRequest
+                this.#credentialStore,
+                this.#getNextRequest,
             )) {
                 // If the authenticator yielded a response
                 // Prepare `nextRequest` for next authentication request
@@ -162,9 +181,9 @@ export class AdbAuthenticationProcessor implements Disposable {
         }
     }
 
-    public async process(packet: AdbPacketData): Promise<AdbPacketData> {
+    async process(packet: AdbPacketData): Promise<AdbPacketData> {
         if (!this.#iterator) {
-            this.#iterator = this.invokeAuthenticator();
+            this.#iterator = this.#invokeAuthenticator();
         }
 
         this.#pendingRequest.resolve(packet);
@@ -177,7 +196,7 @@ export class AdbAuthenticationProcessor implements Disposable {
         return result.value;
     }
 
-    public dispose() {
+    dispose() {
         void this.#iterator?.return?.();
     }
 }

package/src/daemon/crypto.ts

@@ -13,7 +13,7 @@ import {
 export function getBigUint(
     dataView: DataView,
     byteOffset: number,
-    length: number
+    length: number,
 ): bigint {
     let result = 0n;
 
@@ -40,7 +40,7 @@ export function setBigUint(
     dataView: DataView,
     byteOffset: number,
     value: bigint,
-    littleEndian?: boolean
+    littleEndian?: boolean,
 ) {
     const start = byteOffset;
 
@@ -135,11 +135,11 @@ export function adbGetPublicKeySize() {
 export function adbGeneratePublicKey(privateKey: Uint8Array): Uint8Array;
 export function adbGeneratePublicKey(
     privateKey: Uint8Array,
-    output: Uint8Array
+    output: Uint8Array,
 ): number;
 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
@@ -158,9 +158,6 @@ export function adbGeneratePublicKey(
     // (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] = rsaParsePrivateKey(privateKey);
-
     let outputType: "Uint8Array" | "number";
     const outputLength = adbGetPublicKeySize();
     if (!output) {
@@ -177,7 +174,7 @@ export function adbGeneratePublicKey(
     const outputView = new DataView(
         output.buffer,
         output.byteOffset,
-        output.byteLength
+        output.byteLength,
     );
     let outputOffset = 0;
 
@@ -185,6 +182,9 @@ export function adbGeneratePublicKey(
     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 multiply by -1
     // Didn't exist in Android codebase
@@ -221,7 +221,7 @@ export function adbGeneratePublicKey(
 export function powMod(
     base: bigint,
     exponent: bigint,
-    modulus: bigint
+    modulus: bigint,
 ): bigint {
     if (modulus === 1n) {
         return 0n;