@yume-chan/adb 0.0.22 → 0.0.24

package/src/commands/sync/socket.ts

@@ -1,11 +1,11 @@
 import type {
-    Consumable,
+    MaybeConsumable,
     WritableStreamDefaultWriter,
 } from "@yume-chan/stream-extra";
 import {
     BufferCombiner,
     BufferedReadableStream,
-    ConsumableWritableStream,
+    Consumable,
 } from "@yume-chan/stream-extra";
 import type { AsyncExactReadable } from "@yume-chan/struct";
 
@@ -13,7 +13,7 @@ import type { AdbSocket } from "../../adb.js";
 import { AutoResetEvent } from "../../utils/index.js";
 
 export class AdbSyncSocketLocked implements AsyncExactReadable {
-    readonly #writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>;
+    readonly #writer: WritableStreamDefaultWriter<MaybeConsumable<Uint8Array>>;
     readonly #readable: BufferedReadableStream;
     readonly #socketLock: AutoResetEvent;
     readonly #writeLock = new AutoResetEvent();
@@ -24,7 +24,7 @@ export class AdbSyncSocketLocked implements AsyncExactReadable {
     }
 
     constructor(
-        writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>,
+        writer: WritableStreamDefaultWriter<MaybeConsumable<Uint8Array>>,
         readable: BufferedReadableStream,
         bufferSize: number,
         lock: AutoResetEvent,
@@ -35,8 +35,9 @@ export class AdbSyncSocketLocked implements AsyncExactReadable {
         this.#combiner = new BufferCombiner(bufferSize);
     }
 
-    async #writeInnerStream(buffer: Uint8Array) {
-        await ConsumableWritableStream.write(this.#writer, buffer);
+    async #write(buffer: Uint8Array) {
+        // `#combiner` will reuse the buffer, so we need to use the Consumable pattern
+        await Consumable.WritableStream.write(this.#writer, buffer);
     }
 
     async flush() {
@@ -44,7 +45,7 @@ export class AdbSyncSocketLocked implements AsyncExactReadable {
             await this.#writeLock.wait();
             const buffer = this.#combiner.flush();
             if (buffer) {
-                await this.#writeInnerStream(buffer);
+                await this.#write(buffer);
             }
         } finally {
             this.#writeLock.notifyOne();
@@ -55,7 +56,7 @@ export class AdbSyncSocketLocked implements AsyncExactReadable {
         try {
             await this.#writeLock.wait();
             for (const buffer of this.#combiner.push(data)) {
-                await this.#writeInnerStream(buffer);
+                await this.#write(buffer);
             }
         } finally {
             this.#writeLock.notifyOne();
@@ -63,11 +64,15 @@ export class AdbSyncSocketLocked implements AsyncExactReadable {
     }
 
     async readExactly(length: number) {
+        // The request may still be in the internal buffer.
+        // Call `flush` to send it before starting reading
         await this.flush();
         return await this.#readable.readExactly(length);
     }
 
     release(): void {
+        // In theory, the writer shouldn't leave anything in the buffer,
+        // but to be safe, call `flush` to throw away any remaining data.
         this.#combiner.flush();
         this.#socketLock.notifyOne();
     }

package/src/commands/sync/stat.ts

@@ -29,7 +29,6 @@ export const AdbSyncLstatResponse = new Struct({ littleEndian: true })
     .int32("size")
     .int32("mtime")
     .extra({
-        id: AdbSyncResponseId.Lstat as const,
         get type() {
             return (this.mode >> 12) as LinuxFileType;
         },
@@ -83,7 +82,6 @@ export const AdbSyncStatResponse = new Struct({ littleEndian: true })
     .uint64("mtime")
     .uint64("ctime")
     .extra({
-        id: AdbSyncResponseId.Stat as const,
         get type() {
             return (this.mode >> 12) as LinuxFileType;
         },

package/src/commands/sync/sync.ts

@@ -1,5 +1,5 @@
 import { AutoDisposable } from "@yume-chan/event";
-import type { Consumable, ReadableStream } from "@yume-chan/stream-extra";
+import type { MaybeConsumable, ReadableStream } from "@yume-chan/stream-extra";
 
 import type { Adb, AdbSocket } from "../../adb.js";
 import { AdbFeature } from "../../features.js";
@@ -9,6 +9,7 @@ import type { AdbSyncEntry } from "./list.js";
 import { adbSyncOpenDir } from "./list.js";
 import { adbSyncPull } from "./pull.js";
 import { adbSyncPush } from "./push.js";
+import type { AdbSyncSocketLocked } from "./socket.js";
 import { AdbSyncSocket } from "./socket.js";
 import type { AdbSyncStat, LinuxFileType } from "./stat.js";
 import { adbSyncLstat, adbSyncStat } from "./stat.js";
@@ -31,7 +32,7 @@ export function dirname(path: string): string {
 
 export interface AdbSyncWriteOptions {
     filename: string;
-    file: ReadableStream<Consumable<Uint8Array>>;
+    file: ReadableStream<MaybeConsumable<Uint8Array>>;
     type?: LinuxFileType;
     permission?: number;
     mtime?: number;
@@ -74,16 +75,15 @@ export class AdbSync extends AutoDisposable {
         this._adb = adb;
         this._socket = new AdbSyncSocket(socket, adb.maxPayloadSize);
 
-        this.#supportsStat = adb.supportsFeature(AdbFeature.StatV2);
-        this.#supportsListV2 = adb.supportsFeature(AdbFeature.ListV2);
-        this.#fixedPushMkdir = adb.supportsFeature(AdbFeature.FixedPushMkdir);
-        this.#supportsSendReceiveV2 = adb.supportsFeature(
+        this.#supportsStat = adb.canUseFeature(AdbFeature.StatV2);
+        this.#supportsListV2 = adb.canUseFeature(AdbFeature.ListV2);
+        this.#fixedPushMkdir = adb.canUseFeature(AdbFeature.FixedPushMkdir);
+        this.#supportsSendReceiveV2 = adb.canUseFeature(
             AdbFeature.SendReceiveV2,
         );
         // https://android.googlesource.com/platform/packages/modules/adb/+/91768a57b7138166e0a3d11f79cd55909dda7014/client/file_sync_client.cpp#1361
         this.#needPushMkdirWorkaround =
-            this._adb.supportsFeature(AdbFeature.ShellV2) &&
-            !this.fixedPushMkdir;
+            this._adb.canUseFeature(AdbFeature.ShellV2) && !this.fixedPushMkdir;
     }
 
     /**
@@ -151,7 +151,7 @@ export class AdbSync extends AutoDisposable {
      */
     async write(options: AdbSyncWriteOptions): Promise<void> {
         if (this.needPushMkdirWorkaround) {
-            // It may fail if the path is already existed.
+            // It may fail if `filename` already exists.
             // Ignore the result.
             // TODO: sync: test push mkdir workaround (need an Android 8 device)
             await this._adb.subprocess.spawnAndWait([
@@ -168,6 +168,10 @@ export class AdbSync extends AutoDisposable {
         });
     }
 
+    lockSocket(): Promise<AdbSyncSocketLocked> {
+        return this._socket.lock();
+    }
+
     override async dispose() {
         super.dispose();
         await this._socket.close();

package/src/commands/tcpip.ts

@@ -47,7 +47,7 @@ export class AdbTcpIpCommand extends AdbCommandBase {
 
     async setPort(port: number): Promise<string> {
         if (port <= 0) {
-            throw new Error(`Invalid port ${port}`);
+            throw new TypeError(`Invalid port ${port}`);
         }
 
         const output = await this.adb.createSocketAndWait(`tcpip:${port}`);

package/src/daemon/auth.ts

@@ -83,7 +83,7 @@ export const AdbSignatureAuthenticator: AdbAuthenticator = async function* (
             command: AdbCommand.Auth,
             arg0: AdbAuthType.Signature,
             arg1: 0,
-            payload: new Uint8Array(signature),
+            payload: signature,
         };
     }
 };

package/src/daemon/crypto.ts

@@ -1,7 +1,8 @@
 import {
-    getBigUint64,
-    setBigUint64,
-} from "@yume-chan/dataview-bigint-polyfill/esm/fallback.js";
+    getUint64BigEndian,
+    setInt64BigEndian,
+    setInt64LittleEndian,
+} from "@yume-chan/no-data-view";
 
 /**
  * Gets the `BigInt` value at the specified byte offset and length from the start of the view. There is
@@ -11,7 +12,7 @@ import {
  * @param byteOffset The place in the buffer at which the value should be retrieved.
  */
 export function getBigUint(
-    dataView: DataView,
+    array: Uint8Array,
     byteOffset: number,
     length: number,
 ): bigint {
@@ -22,8 +23,8 @@ export function getBigUint(
 
     for (let i = byteOffset; i < byteOffset + length; i += 8) {
         result <<= 64n;
-        const value = getBigUint64(dataView, i, false);
-        result += value;
+        const value = getUint64BigEndian(array, i);
+        result |= value;
     }
 
     return result;
@@ -32,40 +33,32 @@ export function getBigUint(
 /**
  * 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 length The number of bytes to 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,
+    array: Uint8Array,
     byteOffset: number,
+    length: number,
     value: bigint,
     littleEndian?: boolean,
 ) {
-    const start = byteOffset;
-
     if (littleEndian) {
         while (value > 0n) {
-            setBigUint64(dataView, byteOffset, value, true);
+            setInt64LittleEndian(array, byteOffset, value);
             byteOffset += 8;
             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[] = [];
+        let position = byteOffset + length - 8;
         while (value > 0n) {
-            uint64Array.push(BigInt.asUintN(64, value));
+            setInt64BigEndian(array, position, value);
+            position -= 8;
             value >>= 64n;
         }
-
-        for (let i = uint64Array.length - 1; i >= 0; i -= 1) {
-            setBigUint64(dataView, byteOffset, uint64Array[i]!, false);
-            byteOffset += 8;
-        }
     }
-
-    return byteOffset - start;
 }
 
 // These values are correct only if
@@ -95,17 +88,26 @@ const RsaPrivateKeyDOffset = 303;
 const RsaPrivateKeyDLength = 2048 / 8;
 
 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);
+    const n = getBigUint(key, RsaPrivateKeyNOffset, RsaPrivateKeyNLength);
+    const d = getBigUint(key, RsaPrivateKeyDOffset, RsaPrivateKeyDLength);
     return [n, d];
 }
 
+function nonNegativeMod(m: number, d: number) {
+    const r = m % d;
+    if (r > 0) {
+        return r;
+    }
+    return r + (d > 0 ? d : -d);
+}
+
+// https://en.wikipedia.org/wiki/Modular_multiplicative_inverse
+// Solve for the smallest positive `x` in the equation `a * x ≡ 1 (mod m)`,
+// or in other words, `a * x % m = 1`
 // Taken from https://stackoverflow.com/a/51562038
-// I can't understand, but it does work
 // Only used with numbers smaller than 2^32 so doesn't need BigInt
 export function modInverse(a: number, m: number) {
-    a = ((a % m) + m) % m;
+    a = nonNegativeMod(a, m);
     if (!a || m < 2) {
         return NaN; // invalid input
     }
@@ -116,6 +118,7 @@ export function modInverse(a: number, m: number) {
         [a, b] = [b, a % b];
         s.push({ a, b });
     }
+    /* istanbul ignore next */
     if (a !== 1) {
         return NaN; // inverse does not exists
     }
@@ -125,11 +128,14 @@ export function modInverse(a: number, m: number) {
     for (let i = s.length - 2; i >= 0; i -= 1) {
         [x, y] = [y, x - y * Math.floor(s[i]!.a / s[i]!.b)];
     }
-    return ((y % m) + m) % m;
+    return nonNegativeMod(y, m);
 }
 
+const ModulusLengthInBytes = 2048 / 8;
+const ModulusLengthInWords = ModulusLengthInBytes / 4;
+
 export function adbGetPublicKeySize() {
-    return 4 + 4 + 2048 / 8 + 2048 / 8 + 4;
+    return 4 + 4 + ModulusLengthInBytes + ModulusLengthInBytes + 4;
 }
 
 export function adbGeneratePublicKey(privateKey: Uint8Array): Uint8Array;
@@ -141,22 +147,27 @@ export function adbGeneratePublicKey(
     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
-
-    // The public key is an array of
+    // cspell: ignore: mincrypt
+    // Android 6 and earlier has its own encryption library called mincrypt
+    // This is the RSA public key format used by mincrypt:
+    // https://android.googlesource.com/platform/system/core/+/bb0c180e62703c2068a1b2c9f8ba6d634bf1553c/include/mincrypt/rsa.h#46
+    // `n0inv` and `rr` are pre-calculated to speed up RSA operations
+
+    // Android 7 switched its encryption library to BoringSSL, but still keeps the key format:
+    // https://android.googlesource.com/platform/system/core.git/+/91784040db2b9273687f88d8b95f729d4a61ecc2/libcrypto_utils/android_pubkey.cpp#38
+    // Except when reading a key, `n0inv` and `rr` are ignored (they are still populated when generating a key):
+    // https://android.googlesource.com/platform/system/core.git/+/91784040db2b9273687f88d8b95f729d4a61ecc2/libcrypto_utils/android_pubkey.cpp#55
+
+    // The public key is a struct (in little endian) of:
     //
     // [
     //   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 (low 32 bits of n)
-    //   modulus,              // n
+    //                         // (the comment in Android source code is incorrect saying "This must be ANDROID_PUBKEY_MODULUS_SIZE")
+    //   n0inv,                // 32-bit integer, the modular inverse of (lower 32 bits of `n`)
+    //   modulus,              // `n`
     //   rr,                   // Montgomery parameter R^2
-    //   exponent,             // 32-bit integer, must be 65537
+    //   exponent,             // 32-bit integer, must be 3 or 65537
     // ]
-    //
-    // (All in little endian)
-    // See https://android.googlesource.com/platform/system/core.git/+/91784040db2b9273687f88d8b95f729d4a61ecc2/libcrypto_utils/android_pubkey.cpp#38
 
     let outputType: "Uint8Array" | "number";
     const outputLength = adbGetPublicKeySize();
@@ -164,8 +175,8 @@ export function adbGeneratePublicKey(
         output = new Uint8Array(outputLength);
         outputType = "Uint8Array";
     } else {
-        if (output.byteLength < outputLength) {
-            throw new Error("output buffer is too small");
+        if (output.length < outputLength) {
+            throw new TypeError("output buffer is too small");
         }
 
         outputType = "number";
@@ -174,31 +185,30 @@ export function adbGeneratePublicKey(
     const outputView = new DataView(
         output.buffer,
         output.byteOffset,
-        output.byteLength,
+        output.length,
     );
     let outputOffset = 0;
 
     // modulusLengthInWords
-    outputView.setUint32(outputOffset, 2048 / 8 / 4, true);
+    outputView.setUint32(outputOffset, ModulusLengthInWords, 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
-    const n0inv = modInverse(-Number(BigInt.asUintN(32, n)), 2 ** 32);
-    outputView.setUint32(outputOffset, n0inv, true);
+    const n0inv = -modInverse(Number(n % 2n ** 32n), 2 ** 32);
+    outputView.setInt32(outputOffset, n0inv, true);
     outputOffset += 4;
 
-    // Write n
-    setBigUint(outputView, outputOffset, n, true);
-    outputOffset += 256;
+    // Write `n` (a.k.a. `modulus`)
+    setBigUint(output, outputOffset, ModulusLengthInBytes, n, true);
+    outputOffset += ModulusLengthInBytes;
 
-    // Calculate rr = (2^(rsa_size)) ^ 2 mod n
+    // Calculate rr = (2 ** (rsa_size)) ** 2 % n
     const rr = 2n ** 4096n % n;
-    outputOffset += setBigUint(outputView, outputOffset, rr, true);
+    setBigUint(output, outputOffset, ModulusLengthInBytes, rr, true);
+    outputOffset += ModulusLengthInBytes;
 
     // exponent
     outputView.setUint32(outputOffset, 65537, true);
@@ -305,12 +315,11 @@ export function rsaSign(privateKey: Uint8Array, data: Uint8Array): Uint8Array {
 
     // Encryption
     // signature = padded ** d % n
-    const view = new DataView(padded.buffer);
-    const signature = powMod(getBigUint(view, 0, view.byteLength), d, n);
+    const signature = powMod(getBigUint(padded, 0, padded.length), d, n);
 
     // `padded` is not used anymore,
     // re-use the buffer to store the result
-    setBigUint(view, 0, signature, false);
+    setBigUint(padded, 0, padded.length, signature, false);
 
     return padded;
 }