@matter/thread-br-client 0.0.1 → 0.17.5-alpha.0-20260706-fd4c49e2e

package/src/dtls/ecjpake/SchnorrZkp.ts

@@ -4,9 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { InternalError } from "@matter/general";
+import { Bytes, Crypto, InternalError } from "@matter/general";
 import { p256 } from "@noble/curves/nist.js";
-import { sha256 } from "@noble/hashes/sha2.js";
 import { DtlsError } from "../channel/DtlsChannel.js";
 
 /**
@@ -22,9 +21,9 @@ import { DtlsError } from "../channel/DtlsChannel.js";
  */
 export interface SchnorrZkp {
     /** SEC1-uncompressed encoding of `V = v*G`. */
-    V: Uint8Array;
+    V: Bytes;
     /** Minimal big-endian encoding of `r = v - h*x mod n`. */
-    r: Uint8Array;
+    r: Bytes;
 }
 
 const Point = p256.Point;
@@ -37,13 +36,19 @@ function be32(value: number): Uint8Array {
     return out;
 }
 
-function hashChallenge(args: {
-    gBytes: Uint8Array;
-    vBytes: Uint8Array;
-    xBytes: Uint8Array;
-    idBytes: Uint8Array;
-}): bigint {
-    const { gBytes, vBytes, xBytes, idBytes } = args;
+async function hashChallenge(
+    crypto: Crypto,
+    args: {
+        gBytes: Bytes;
+        vBytes: Bytes;
+        xBytes: Bytes;
+        idBytes: Bytes;
+    },
+): Promise<bigint> {
+    const gBytes = Bytes.of(args.gBytes);
+    const vBytes = Bytes.of(args.vBytes);
+    const xBytes = Bytes.of(args.xBytes);
+    const idBytes = Bytes.of(args.idBytes);
     const total = 4 + gBytes.length + 4 + vBytes.length + 4 + xBytes.length + 4 + idBytes.length;
     const buf = new Uint8Array(total);
     let p = 0;
@@ -63,7 +68,7 @@ function hashChallenge(args: {
     p += 4;
     buf.set(idBytes, p);
 
-    const digest = sha256(buf);
+    const digest = Bytes.of(await crypto.computeHash(buf));
     let h = 0n;
     for (const byte of digest) {
         h = (h << 8n) | BigInt(byte);
@@ -87,9 +92,9 @@ function bigintToMinimalBE(value: bigint): Uint8Array {
     return Uint8Array.from(tmp.reverse());
 }
 
-function bigintFromBE(bytes: Uint8Array): bigint {
+function bigintFromBE(bytes: Bytes): bigint {
     let v = 0n;
-    for (const byte of bytes) {
+    for (const byte of Bytes.of(bytes)) {
         v = (v << 8n) | BigInt(byte);
     }
     return v;
@@ -99,13 +104,14 @@ function getBaseGBytes(): Uint8Array {
     return Point.BASE.toBytes(false);
 }
 
-function pointFromBytes(bytes: Uint8Array): InstanceType<typeof Point> {
-    if (bytes.length !== POINT_LEN || bytes[0] !== 0x04) {
+function pointFromBytes(bytes: Bytes): InstanceType<typeof Point> {
+    const buf = Bytes.of(bytes);
+    if (buf.length !== POINT_LEN || buf[0] !== 0x04) {
         throw new DtlsError(
-            `expected SEC1-uncompressed P-256 point (65 bytes, 0x04 prefix), got len=${bytes.length} head=${bytes[0]}`,
+            `expected SEC1-uncompressed P-256 point (65 bytes, 0x04 prefix), got len=${buf.length} head=${buf[0]}`,
         );
     }
-    return Point.fromBytes(bytes);
+    return Point.fromBytes(buf);
 }
 
 /**
@@ -116,12 +122,13 @@ function pointFromBytes(bytes: Uint8Array): InstanceType<typeof Point> {
  */
 export interface SchnorrZkpGenerator {
     point: InstanceType<typeof Point>;
-    bytes: Uint8Array;
+    bytes: Bytes;
 }
 
 function generatorOrBase(g?: SchnorrZkpGenerator): SchnorrZkpGenerator {
     if (g) {
-        if (g.bytes.length !== POINT_LEN || g.bytes[0] !== 0x04) {
+        const bytes = Bytes.of(g.bytes);
+        if (bytes.length !== POINT_LEN || bytes[0] !== 0x04) {
             throw new InternalError("generator bytes must be SEC1-uncompressed P-256 (65 bytes, 0x04 prefix)");
         }
         return g;
@@ -140,13 +147,16 @@ export const SchnorrZkp = {
      * `ephemeral` is the per-proof scalar `v`; in production it must be sampled
      * uniformly from `[1, n-1]`. Tests pass a fixed value so the proof is deterministic.
      */
-    generate(args: {
-        privateKey: bigint;
-        publicKey: Uint8Array;
-        ephemeral: bigint;
-        id: string;
-        generator?: SchnorrZkpGenerator;
-    }): SchnorrZkp {
+    async generate(
+        crypto: Crypto,
+        args: {
+            privateKey: bigint;
+            publicKey: Bytes;
+            ephemeral: bigint;
+            id: string;
+            generator?: SchnorrZkpGenerator;
+        },
+    ): Promise<SchnorrZkp> {
         const { privateKey, publicKey, ephemeral, id } = args;
         if (ephemeral <= 0n || ephemeral >= N) {
             throw new InternalError("ephemeral scalar must be in [1, n-1]");
@@ -158,13 +168,16 @@ export const SchnorrZkp = {
         const V = g.point.multiply(ephemeral);
         const vBytes = V.toBytes(false);
         const idBytes = new TextEncoder().encode(id);
-        const h = hashChallenge({ gBytes: g.bytes, vBytes, xBytes: publicKey, idBytes });
+        const h = await hashChallenge(crypto, { gBytes: g.bytes, vBytes, xBytes: publicKey, idBytes });
         // r = v - h*x mod n, matching mbedTLS ecjpake_zkp_write.
         const rBig = (((ephemeral - ((h * privateKey) % N)) % N) + N) % N;
         return { V: vBytes, r: bigintToMinimalBE(rBig) };
     },
 
-    verify(args: { zkp: SchnorrZkp; publicKey: Uint8Array; id: string; generator?: SchnorrZkpGenerator }): boolean {
+    async verify(
+        crypto: Crypto,
+        args: { zkp: SchnorrZkp; publicKey: Bytes; id: string; generator?: SchnorrZkpGenerator },
+    ): Promise<boolean> {
         const { zkp, publicKey, id } = args;
         const idBytes = new TextEncoder().encode(id);
         let g: SchnorrZkpGenerator;
@@ -184,7 +197,7 @@ export const SchnorrZkp = {
         if (r >= N) {
             return false;
         }
-        const h = hashChallenge({ gBytes: g.bytes, vBytes: zkp.V, xBytes: publicKey, idBytes });
+        const h = await hashChallenge(crypto, { gBytes: g.bytes, vBytes: zkp.V, xBytes: publicKey, idBytes });
         // mbedTLS ecjpake_zkp_verify computes V' = r*G + h*X via ecp_muladd. multiplyUnsafe is
         // safe here: r is on the wire (peer-supplied) and h is a hash digest; neither is secret.
         const lhs = g.point.multiplyUnsafe(r).add(X.multiplyUnsafe(h));

package/src/dtls/handshake/ChangeCipherSpec.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { Bytes } from "@matter/general";
 import { DtlsError } from "../channel/DtlsChannel.js";
 
 /**
@@ -22,7 +23,8 @@ import { DtlsError } from "../channel/DtlsChannel.js";
 export const CHANGE_CIPHER_SPEC_BODY: Readonly<Uint8Array> = new Uint8Array([0x01]);
 
 export const ChangeCipherSpec = {
-    parse(body: Uint8Array): void {
+    parse(rawBody: Bytes): void {
+        const body = Bytes.of(rawBody);
         if (body.length !== 1 || body[0] !== 0x01) {
             throw new DtlsError(
                 `ChangeCipherSpec must be a single 0x01 byte, got len=${body.length} first=${body[0] ?? "undefined"}`,

package/src/dtls/handshake/ClientHelloMessage.ts

@@ -27,7 +27,7 @@
  *   omitted but real BRs may not be
  */
 
-import { InternalError } from "@matter/general";
+import { Bytes, InternalError } from "@matter/general";
 
 /** TLS extension type for `ecjpake_kkpp` (draft-cragie-tls-ecjpake-01 §3). */
 export const EXTENSION_TYPE_ECJPAKE_KKPP = 0x0100;
@@ -52,14 +52,14 @@ const MAX_COOKIE_LEN = 0xff;
 
 export interface ClientHelloFields {
     /** 32 random bytes that will become `ClientHello.random`. */
-    random: Uint8Array;
+    random: Bytes;
     /**
      * DTLS cookie returned by `HelloVerifyRequest`, or empty on the first ClientHello
      * (RFC 6347 §4.2.1).
      */
-    cookie: Uint8Array;
+    cookie: Bytes;
     /** `ecjpake_kkpp` extension payload — the round-1 ECJPAKEKeyKPPairList bytes. */
-    ecjpakeKkpp: Uint8Array;
+    ecjpakeKkpp: Bytes;
 }
 
 function writeUint16BE(buf: Uint8Array, offset: number, value: number): void {
@@ -72,8 +72,10 @@ export const ClientHelloMessage = {
      * Serialise a ClientHello body. Caller wraps the result in a
      * {@link HandshakeMessage} and a `DtlsRecord` of `ContentType.HANDSHAKE`.
      */
-    build(fields: ClientHelloFields): Uint8Array {
-        const { random, cookie, ecjpakeKkpp } = fields;
+    build(fields: ClientHelloFields): Bytes {
+        const random = Bytes.of(fields.random);
+        const cookie = Bytes.of(fields.cookie);
+        const ecjpakeKkpp = Bytes.of(fields.ecjpakeKkpp);
         if (random.length !== RANDOM_LEN) {
             throw new InternalError(`ClientHello random must be ${RANDOM_LEN} bytes, got ${random.length}`);
         }

package/src/dtls/handshake/ClientKeyExchangeMessage.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import type { Bytes } from "@matter/general";
 import { type EcJpakeKeyKP, EcJpakeRound } from "../ecjpake/EcJpakeRound.js";
 
 /**
@@ -19,7 +20,7 @@ import { type EcJpakeKeyKP, EcJpakeRound } from "../ecjpake/EcJpakeRound.js";
  * ```
  */
 export const ClientKeyExchangeMessage = {
-    build(kp: EcJpakeKeyKP): Uint8Array {
+    build(kp: EcJpakeKeyKP): Bytes {
         return EcJpakeRound.serializeRound2(kp, { prependEcParameters: false });
     },
 } as const;