@yume-chan/adb 0.0.20 → 0.0.21

package/src/commands/sync/push.ts

@@ -26,14 +26,14 @@ export interface AdbSyncPushV1Options {
 }
 
 export const AdbSyncOkResponse = new Struct({ littleEndian: true }).uint32(
-    "unused"
+    "unused",
 );
 
 async function pipeFileData(
     locked: AdbSyncSocketLocked,
     file: ReadableStream<Consumable<Uint8Array>>,
     packetSize: number,
-    mtime: number
+    mtime: number,
 ) {
     // Read and write in parallel,
     // allow error response to abort the write.
@@ -45,11 +45,11 @@ async function pipeFileData(
                     await adbSyncWriteRequest(
                         locked,
                         AdbSyncRequestId.Data,
-                        chunk
+                        chunk,
                     );
                 },
             }),
-            { signal: abortController.signal }
+            { signal: abortController.signal },
         )
         .then(async () => {
             await adbSyncWriteRequest(locked, AdbSyncRequestId.Done, mtime);
@@ -59,7 +59,7 @@ async function pipeFileData(
     await adbSyncReadResponse(
         locked,
         AdbSyncResponseId.Ok,
-        AdbSyncOkResponse
+        AdbSyncOkResponse,
     ).catch((e) => {
         abortController.abort();
         throw e;
@@ -142,7 +142,7 @@ export async function adbSyncPushV2({
                 id: AdbSyncRequestId.SendV2,
                 mode,
                 flags,
-            })
+            }),
         );
 
         await pipeFileData(locked, file, packetSize, mtime);

package/src/commands/sync/request.ts

@@ -30,7 +30,7 @@ export interface AdbSyncWritable {
 export async function adbSyncWriteRequest(
     writable: AdbSyncWritable,
     id: AdbSyncRequestId | string,
-    value: number | string | Uint8Array
+    value: number | string | Uint8Array,
 ): Promise<void> {
     if (typeof value === "number") {
         const buffer = AdbSyncNumberRequest.serialize({
@@ -42,12 +42,12 @@ export async function adbSyncWriteRequest(
         // Let `writable` buffer writes
         const buffer = encodeUtf8(value);
         await writable.write(
-            AdbSyncNumberRequest.serialize({ id, arg: buffer.byteLength })
+            AdbSyncNumberRequest.serialize({ id, arg: buffer.byteLength }),
         );
         await writable.write(buffer);
     } else {
         await writable.write(
-            AdbSyncNumberRequest.serialize({ id, arg: value.byteLength })
+            AdbSyncNumberRequest.serialize({ id, arg: value.byteLength }),
         );
         await writable.write(value);
     }

package/src/commands/sync/response.ts

@@ -19,17 +19,19 @@ export enum AdbSyncResponseId {
     Fail = "FAIL",
 }
 
+export class AdbSyncError extends Error {}
+
 export const AdbSyncFailResponse = new Struct({ littleEndian: true })
     .uint32("messageLength")
     .string("message", { lengthField: "messageLength" })
     .postDeserialize((object) => {
-        throw new Error(object.message);
+        throw new AdbSyncError(object.message);
     });
 
 export async function adbSyncReadResponse<T>(
     stream: AsyncExactReadable,
     id: AdbSyncResponseId,
-    type: StructLike<T>
+    type: StructLike<T>,
 ): Promise<T> {
     const actualId = decodeUtf8(await stream.readExactly(4));
     switch (actualId) {
@@ -44,11 +46,11 @@ export async function adbSyncReadResponse<T>(
 }
 
 export async function* adbSyncReadResponses<
-    T extends Struct<object, PropertyKey, object, any>
+    T extends Struct<object, PropertyKey, object, any>,
 >(
     stream: AsyncExactReadable,
     id: AdbSyncResponseId,
-    type: T
+    type: T,
 ): AsyncGenerator<StructValueType<T>, void, void> {
     while (true) {
         const actualId = decodeUtf8(await stream.readExactly(4));
@@ -68,7 +70,7 @@ export async function* adbSyncReadResponses<
                 break;
             default:
                 throw new Error(
-                    `Expected '${id}' or '${AdbSyncResponseId.Done}', but got '${actualId}'`
+                    `Expected '${id}' or '${AdbSyncResponseId.Done}', but got '${actualId}'`,
                 );
         }
     }

package/src/commands/sync/socket.ts

@@ -19,15 +19,15 @@ export class AdbSyncSocketLocked implements AsyncExactReadable {
     readonly #writeLock = new AutoResetEvent();
     readonly #combiner: BufferCombiner;
 
-    public get position() {
+    get position() {
         return this.#readable.position;
     }
 
-    public constructor(
+    constructor(
         writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>,
         readable: BufferedReadableStream,
         bufferSize: number,
-        lock: AutoResetEvent
+        lock: AutoResetEvent,
     ) {
         this.#writer = writer;
         this.#readable = readable;
@@ -35,39 +35,39 @@ export class AdbSyncSocketLocked implements AsyncExactReadable {
         this.#combiner = new BufferCombiner(bufferSize);
     }
 
-    private async writeInnerStream(buffer: Uint8Array) {
+    async #writeInnerStream(buffer: Uint8Array) {
         await ConsumableWritableStream.write(this.#writer, buffer);
     }
 
-    public async flush() {
+    async flush() {
         try {
             await this.#writeLock.wait();
             const buffer = this.#combiner.flush();
             if (buffer) {
-                await this.writeInnerStream(buffer);
+                await this.#writeInnerStream(buffer);
             }
         } finally {
             this.#writeLock.notifyOne();
         }
     }
 
-    public async write(data: Uint8Array) {
+    async write(data: Uint8Array) {
         try {
             await this.#writeLock.wait();
             for (const buffer of this.#combiner.push(data)) {
-                await this.writeInnerStream(buffer);
+                await this.#writeInnerStream(buffer);
             }
         } finally {
             this.#writeLock.notifyOne();
         }
     }
 
-    public async readExactly(length: number) {
+    async readExactly(length: number) {
         await this.flush();
         return await this.#readable.readExactly(length);
     }
 
-    public release(): void {
+    release(): void {
         this.#combiner.flush();
         this.#socketLock.notifyOne();
     }
@@ -78,22 +78,22 @@ export class AdbSyncSocket {
     readonly #socket: AdbSocket;
     readonly #locked: AdbSyncSocketLocked;
 
-    public constructor(socket: AdbSocket, bufferSize: number) {
+    constructor(socket: AdbSocket, bufferSize: number) {
         this.#socket = socket;
         this.#locked = new AdbSyncSocketLocked(
             socket.writable.getWriter(),
             new BufferedReadableStream(socket.readable),
             bufferSize,
-            this.#lock
+            this.#lock,
         );
     }
 
-    public async lock() {
+    async lock() {
         await this.#lock.wait();
         return this.#locked;
     }
 
-    public async close() {
+    async close() {
         await this.#socket.close();
     }
 }

package/src/commands/sync/stat.ts

@@ -103,7 +103,7 @@ export type AdbSyncStatResponse =
 export async function adbSyncLstat(
     socket: AdbSyncSocket,
     path: string,
-    v2: boolean
+    v2: boolean,
 ): Promise<AdbSyncStat> {
     const locked = await socket.lock();
     try {
@@ -112,14 +112,14 @@ export async function adbSyncLstat(
             return await adbSyncReadResponse(
                 locked,
                 AdbSyncResponseId.Lstat2,
-                AdbSyncStatResponse
+                AdbSyncStatResponse,
             );
         } else {
             await adbSyncWriteRequest(locked, AdbSyncRequestId.Lstat, path);
             const response = await adbSyncReadResponse(
                 locked,
                 AdbSyncResponseId.Lstat,
-                AdbSyncLstatResponse
+                AdbSyncLstatResponse,
             );
             return {
                 mode: response.mode,
@@ -141,7 +141,7 @@ export async function adbSyncLstat(
 
 export async function adbSyncStat(
     socket: AdbSyncSocket,
-    path: string
+    path: string,
 ): Promise<AdbSyncStatResponse> {
     const locked = await socket.lock();
     try {
@@ -149,7 +149,7 @@ export async function adbSyncStat(
         return await adbSyncReadResponse(
             locked,
             AdbSyncResponseId.Stat,
-            AdbSyncStatResponse
+            AdbSyncStatResponse,
         );
     } finally {
         locked.release();

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,7 @@
 import { AdbCommandBase } from "./base.js";
 
 export class AdbTcpIpCommand extends AdbCommandBase {
-    public async setPort(port: number): Promise<string> {
+    async setPort(port: number): Promise<string> {
         if (port <= 0) {
             throw new Error(`Invalid port ${port}`);
         }
@@ -13,7 +13,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;