@matter/react-native 0.16.0-alpha.0-20250809-ee8375bcb → 0.16.0-alpha.0-20250812-285b75d83

package/src/ble/ReactNativeBleClient.ts

@@ -22,7 +22,7 @@ export class ReactNativeBleClient {
     private deviceDiscoveredCallback: ((peripheral: Device, manufacturerData: Uint8Array) => void) | undefined;
 
     constructor() {
-        // this.bleMnager.setLogLevel(LogLevel.Verbose)
+        // this.bleManager.setLogLevel(LogLevel.Verbose)
         const subscription = this.bleManager.onStateChange(state => {
             this.bleState = state;
             logger.debug(`BLE state changed to ${state}`);
@@ -53,7 +53,7 @@ export class ReactNativeBleClient {
                     subscription.remove();
                     void this.stopScanning();
             }
-        });
+        }, true);
     }
 
     public setDiscoveryCallback(callback: (peripheral: Device, manufacturerData: Uint8Array) => void) {
@@ -70,23 +70,31 @@ export class ReactNativeBleClient {
         if (this.bleState === BluetoothState.PoweredOn) {
             logger.debug("Start BLE scanning for Matter Services ...");
             this.isScanning = true;
-            await this.bleManager.startDeviceScan([BLE_MATTER_SERVICE_UUID], {}, (error, peripheral) => {
-                if (error !== null || peripheral === null) {
-                    this.isScanning = false;
-                    logger.error("Error while scanning for BLE devices", error);
-                    if (this.shouldScan) {
-                        this.startScanning().catch(error =>
-                            logger.error("Error while restarting scanning after error", error),
-                        );
-                    } else {
-                        this.stopScanning().catch(error =>
-                            logger.error("Error while stopping scanning after error", error),
-                        );
+            await this.bleManager.startDeviceScan(
+                null,
+                {
+                    allowDuplicates: false,
+                    scanMode: 2, // Low Latency
+                    callbackType: 1, // All matches
+                },
+                (error, peripheral) => {
+                    if (error !== null || peripheral === null) {
+                        this.isScanning = false;
+                        logger.error("Error while scanning for BLE devices", error);
+                        if (this.shouldScan) {
+                            this.startScanning().catch(error =>
+                                logger.error("Error while restarting scanning after error", error),
+                            );
+                        } else {
+                            this.stopScanning().catch(error =>
+                                logger.error("Error while stopping scanning after error", error),
+                            );
+                        }
+                        return;
                     }
-                    return;
-                }
-                this.handleDiscoveredDevice(peripheral);
-            });
+                    this.handleDiscoveredDevice(peripheral);
+                },
+            );
         } else {
             logger.debug("ble state is not poweredOn ... delay scanning till poweredOn");
         }
@@ -111,7 +119,7 @@ export class ReactNativeBleClient {
             logger.info(`Peripheral ${peripheral.id} is not connectable ... ignoring`);
             return;
         }
-        const matterServiceDataBase64 = peripheral.serviceData?.[BLE_MATTER_SERVICE_UUID];
+        const matterServiceDataBase64 = peripheral.serviceData?.[BLE_MATTER_SERVICE_UUID.toLowerCase()];
         if (matterServiceDataBase64 === undefined) {
             logger.info(`Peripheral ${peripheral.id} does not advertise Matter Service ... ignoring`);
             return;

package/src/crypto/ReactNativeCrypto.ts

@@ -4,125 +4,127 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { install } from "react-native-quick-crypto";
-
-install(); // Install the react-native crypto module
-
 import {
+    Bytes,
     Crypto,
-    CRYPTO_HASH_ALGORITHM,
-    CryptoDsaEncoding,
-    CryptoVerifyError,
+    CRYPTO_HASH_LEN_BYTES,
+    CRYPTO_SYMMETRIC_KEY_LENGTH,
     Environment,
+    PrivateKey,
+    PublicKey,
     StandardCrypto,
+    WebCrypto,
 } from "#general";
-import { NodeJsCrypto } from "#nodejs";
-
-import jwk2pem from "jwk-to-pem";
-
-// @ts-expect-error No types but all fine
-crypto.hkdf = (
-    digest: "sha1" | "sha256" | "sha384" | "sha512",
-    ikm: Uint8Array,
-    salt: Uint8Array,
-    info: Uint8Array,
-    keylen: number,
-) => {
-    const hashlen = parseInt(digest.substr(3), 10) >> 3 || 20;
-    const prk = crypto
-        // @ts-expect-error No types but all fine
-        .createHmac(digest, salt.byteLength ? salt : new Uint8Array(hashlen))
-        .update(ikm)
-        .digest();
-
-    // T(0) = empty
-    // T(1) = HMAC(PRK, T(0) | info | 0x01)
-    // T(2) = HMAC(PRK, T(1) | info | 0x02)
-    // T(3) = HMAC(PRK, T(2) | info | 0x03)
-    // ...
-    // T(N) = HMAC(PRK, T(N-1) | info | N)
-
-    const N = Math.ceil(keylen / hashlen);
-
-    // Single T buffer to accomodate T = T(1) | T(2) | T(3) | ... | T(N)
-    // with a little extra for info | N during T(N)
-    const T = new Uint8Array(hashlen * N + info.byteLength + 1);
-    let prev = 0;
-    let start = 0;
-    for (let c = 1; c <= N; c++) {
-        T.set(info, start);
-        T[start + info.byteLength] = c;
-
-        T.set(
-            crypto
-                // @ts-expect-error No types but all fine
-                .createHmac(digest, prk)
-                .update(T.subarray(prev, start + info.byteLength + 1))
-                .digest(),
-            start,
-        );
-
-        prev = start;
-        start += hashlen;
-    }
+import { Buffer } from "@craftzdog/react-native-buffer";
+import QuickCrypto from "react-native-quick-crypto";
 
-    // OKM, releasing T
-    return T.slice(0, keylen);
-};
+// The default export from QuickCrypto should be compatible with the standard `crypto` object but the type system
+// seems confused by CJS exports.  Use a forced cast to correct types.
+const crypto = QuickCrypto as unknown as typeof QuickCrypto.default;
+
+// QuickCrypto's `install()` function is documented as optional but QuickCrypto references it as a global in its subtle
+// implementation, so we can't avoid mucking with global scope (as of QuickCrypto 0.7.6)
+if (!("Buffer" in globalThis)) {
+    (globalThis as unknown as { Buffer: typeof Buffer }).Buffer = Buffer;
+}
 
 /**
- * Crypto implementation for React Native
+ * Crypto implementation for React Native.
  */
-export class ReactNativeCrypto extends NodeJsCrypto {
-    override implementationName = "React Native";
-
-    override signEcdsa(
-        privateKey: JsonWebKey,
-        data: Uint8Array | Uint8Array[],
-        dsaEncoding: CryptoDsaEncoding = "ieee-p1363",
-    ): Uint8Array {
-        // @ts-expect-error No types but all fine
-        const signer = crypto.createSign(CRYPTO_HASH_ALGORITHM);
-        if (Array.isArray(data)) {
-            data.forEach(chunk => signer.update(chunk));
-        } else {
-            signer.update(data);
-        }
-        return new Uint8Array(
-            signer.sign({
-                key: jwk2pem(privateKey as jwk2pem.JWK, { private: true }),
-                format: "pem",
-                type: "pkcs8",
-                dsaEncoding,
-            }),
-        );
+export class ReactNativeCrypto extends StandardCrypto {
+    override implementationName = "ReactNativeCrypto";
+
+    static override provider() {
+        return new ReactNativeCrypto();
     }
 
-    override verifyEcdsa(
-        publicKey: JsonWebKey,
-        data: Uint8Array,
-        signature: Uint8Array,
-        dsaEncoding: CryptoDsaEncoding = "ieee-p1363",
+    /**
+     * Quick Crypto doesn't currently support {@link SubtleCrypto#deriveBits}.
+     */
+    override async createHkdfKey(
+        secret: Uint8Array,
+        salt: Uint8Array,
+        info: Uint8Array,
+        length: number = CRYPTO_SYMMETRIC_KEY_LENGTH,
     ) {
-        // @ts-expect-error No types but all fine
-        const verifier = crypto.createVerify(CRYPTO_HASH_ALGORITHM);
-        verifier.update(data);
-        const success = verifier.verify(
-            {
-                key: jwk2pem(publicKey as jwk2pem.JWK),
-                format: "pem",
-                type: "spki",
-                dsaEncoding,
-            },
-            signature,
-        );
-        if (!success) throw new CryptoVerifyError("Signature verification failed");
+        const prk = crypto
+            .createHmac("SHA-256", salt.byteLength ? salt : new Uint8Array(CRYPTO_HASH_LEN_BYTES))
+            .update(secret)
+            .digest();
+
+        // T(0) = empty
+        // T(1) = HMAC(PRK, T(0) | info | 0x01)
+        // T(2) = HMAC(PRK, T(1) | info | 0x02)
+        // T(3) = HMAC(PRK, T(2) | info | 0x03)
+        // ...
+        // T(N) = HMAC(PRK, T(N-1) | info | N)
+
+        const N = Math.ceil(length / CRYPTO_HASH_LEN_BYTES);
+
+        // Single T buffer to accomodate T = T(1) | T(2) | T(3) | ... | T(N)
+        // with a little extra for info | N during T(N)
+        const T = new Uint8Array(CRYPTO_HASH_LEN_BYTES * N + info.byteLength + 1);
+        let prev = 0;
+        let start = 0;
+        for (let c = 1; c <= N; c++) {
+            T.set(info, start);
+            T[start + info.byteLength] = c;
+
+            T.set(
+                crypto
+                    .createHmac("SHA-256", prk)
+                    .update(T.subarray(prev, start + info.byteLength + 1))
+                    .digest(),
+                start,
+            );
+
+            prev = start;
+            start += CRYPTO_HASH_LEN_BYTES;
+        }
+
+        // OKM, releasing T
+        return T.slice(0, length);
     }
 
-    // Quick crypto does not support AES-CCM.  Install the JS version to compensate
-    // TODO - remove this once we have proper feature detection to configure crypto
-    override encrypt = StandardCrypto.prototype.encrypt;
-    override decrypt = StandardCrypto.prototype.decrypt;
+    /**
+     * Quick Crypto apparently appends a "." to the base64 encoded properties.  I'm not aware of a legitimate reason for
+     * this, seems likely just a bug.  Regardless it trips us off so strip off.
+     */
+    override async generateJwk() {
+        const key = await super.generateJwk();
+
+        for (const prop of ["d", "x", "y"] as const) {
+            if (key[prop]?.endsWith(".")) {
+                key[prop] = key[prop].slice(0, key[prop].length - 1);
+            }
+        }
+
+        return key;
+    }
+
+    /**
+     * See comment on {@link createHkdfKey}.
+     */
+    override async generateDhSecret(key: PrivateKey, peerKey: PublicKey) {
+        return key.sharedSecretFor(peerKey);
+    }
+
+    /**
+     * Quick Crypto doesn't support import of raw keys so convert to JWK prior to import.
+     */
+    protected override importKey(
+        format: KeyFormat,
+        keyData: JsonWebKey | BufferSource,
+        algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm,
+        extractable: boolean,
+        keyUsages: ReadonlyArray<KeyUsage>,
+    ) {
+        if (format === "raw") {
+            format = "jwk";
+            keyData = PrivateKey(Bytes.of(keyData as BufferSource));
+        }
+        return super.importKey(format, keyData, algorithm, extractable, keyUsages);
+    }
 }
 
-Environment.default.set(Crypto, new ReactNativeCrypto());
+Environment.default.set(Crypto, new ReactNativeCrypto(crypto as unknown as WebCrypto));

package/src/net/NetworkReactNative.ts

@@ -8,21 +8,14 @@ import dgram from "react-native-udp";
 // @ts-expect-error globalThis is no index structure
 global.dgram = dgram;
 
-// @ts-expect-error globalThis is no index structure
+// @ts-expect-error globalThis is no index structure, no bind needed because static method
 const rnDGramCreateSocket = dgram.createSocket;
 // @ts-expect-error globalThis is no index structure
 // Work around because React-Native UDP lib is not providing the setMulticastInterface method
 dgram.createSocket = (...args: any[]) => {
     const socket = rnDGramCreateSocket(...args);
-    socket.setMulticastInterface = () => {}; // Stub for now
-
-    const originalSend = socket.send;
-    socket.send = (
-        buffer: Uint8Array,
-        port: number,
-        address: string,
-        callback: (error: Error | null, bytes: number) => void,
-    ) => originalSend(buffer, 0, buffer.length, port, address, callback);
+    socket.setMulticastInterface = () => {}; // Stub for now, suppress warning logs
+
     return socket;
 };
 

package/src/net/UdpChannelReactNative.ts

@@ -19,6 +19,7 @@ import {
     UdpChannelOptions,
     UdpSocketType,
 } from "#general";
+import { Platform } from "react-native";
 import { NetworkReactNative } from "./NetworkReactNative.js";
 
 const logger = Logger.get("UdpChannelNode");
@@ -52,14 +53,21 @@ interface SocketOptions {
 
 interface Socket {
     setBroadcast(flag: boolean): void;
-    setMulticastInterface(interfaceAddress: string): void;
+    setMulticastInterface(interfaceAddress: string): void; // Not implemented
     addMembership(multicastAddress: string, multicastInterface?: string): void;
     dropMembership(multicastAddress: string, multicastInterface?: string): void;
     on(event: "message", listener: (msg: Uint8Array, rinfo: RemoteInfo) => void): void;
     on(event: "error", listener: (error: Error) => void): void;
     removeListener(event: "message", listener: (msg: Uint8Array, rinfo: RemoteInfo) => void): void;
     removeListener(event: "error", listener: (error: Error) => void): void;
-    send(msg: Uint8Array, port: number, address: string, callback: (error: Error | null) => void): void;
+    send(
+        msg: Uint8Array,
+        offset: number,
+        length: number,
+        port: number,
+        address: string,
+        callback: (error: Error | null) => void,
+    ): void;
     close(): void;
     address(): { address: string; port: number };
 }
@@ -108,7 +116,10 @@ export class UdpChannelReactNative implements UdpChannel {
             socketOptions.ipv6Only = true;
         }
         const socket = await createDgramSocket(listeningAddress, listeningPort, socketOptions);
-        socket.setBroadcast(true);
+        if (Platform.OS !== "android") {
+            socket.setBroadcast(true);
+        }
+
         let netInterfaceZone: string | undefined;
         if (netInterface !== undefined) {
             netInterfaceZone = netInterface;
@@ -198,8 +209,8 @@ export class UdpChannelReactNative implements UdpChannel {
 
     async send(host: string, port: number, data: Uint8Array) {
         return new Promise<void>((resolve, reject) => {
-            this.#socket.send(data, port, host, error => {
-                if (error !== null) {
+            this.#socket.send(data, 0, data.length, port, host, error => {
+                if (error) {
                     reject(repackErrorAs(error, NetworkError) as Error);
                     return;
                 }