@matter/protocol 0.16.0-alpha.0-20251016-b56cf5683 → 0.16.0-alpha.0-20251020-3f6e46245

package/src/session/NodeSession.ts

@@ -22,6 +22,7 @@ import type { Subscription } from "#interaction/Subscription.js";
 import { PeerAddress } from "#peer/PeerAddress.js";
 import { MessageCounter } from "#protocol/MessageCounter.js";
 import { MessageReceptionStateEncryptedWithoutRollover } from "#protocol/MessageReceptionState.js";
+import { SecureChannelMessenger } from "#securechannel/SecureChannelMessenger.js";
 import { CaseAuthenticatedTag, FabricIndex, NodeId, StatusCode, StatusResponseError } from "#types";
 import { SecureSession } from "./SecureSession.js";
 import { Session, SessionParameterOptions } from "./Session.js";
@@ -330,6 +331,11 @@ export class NodeSession extends SecureSession {
         await this.destroy(sendClose, closeAfterExchangeFinished);
     }
 
+    async closeByPeer() {
+        await this.destroy(false, false);
+        await this.closedByPeer.emit();
+    }
+
     /** Destroys a session. Outstanding subscription data will be discarded. */
     async destroy(sendClose = false, closeAfterExchangeFinished = true) {
         await this.clearSubscriptions(false);
@@ -392,4 +398,24 @@ export namespace NodeSession {
     export function is(session?: Session): session is NodeSession {
         return session?.type === SessionType.Unicast;
     }
+
+    export function logNew(
+        logger: Logger,
+        operation: "New" | "Resumed",
+        session: NodeSession,
+        messenger: SecureChannelMessenger,
+        fabric: Fabric,
+        peerNodeId: NodeId,
+    ) {
+        logger.info(
+            `${operation} session with`,
+            Diagnostic.strong(PeerAddress({ fabricIndex: fabric.fabricIndex, nodeId: peerNodeId }).toString()),
+            Diagnostic.dict({
+                id: session.id,
+                address: messenger.channelName,
+                fabric: `${NodeId.toHexString(fabric.nodeId)} (#${fabric.fabricIndex})`,
+                ...session.parameterDiagnostics,
+            }),
+        );
+    }
 }

package/src/session/SecureSession.ts

@@ -7,11 +7,13 @@ import { Subject } from "#action/server/Subject.js";
 import { Message } from "#codec/MessageCodec.js";
 import { Fabric } from "#fabric/Fabric.js";
 import { MatterFlowError } from "#general";
+import { PeerAddress } from "#peer/PeerAddress.js";
 import { Session } from "./Session.js";
 
 export abstract class SecureSession extends Session {
     readonly isSecure = true;
     abstract fabric: Fabric | undefined;
+    abstract peerAddress: PeerAddress;
     abstract subjectFor(message?: Message): Subject;
 }
 

package/src/session/Session.ts

@@ -97,6 +97,7 @@ export abstract class Session {
      */
     closer?: Promise<void>;
     #destroyed = AsyncObservable<[]>();
+    #closedByPeer = AsyncObservable<[]>();
 
     constructor(args: {
         manager?: SessionManager;
@@ -143,6 +144,10 @@ export abstract class Session {
         return this.#destroyed;
     }
 
+    get closedByPeer() {
+        return this.#closedByPeer;
+    }
+
     notifyActivity(messageReceived: boolean) {
         this.timestamp = Time.nowMs;
         if (messageReceived) {

package/src/session/case/CaseClient.ts

@@ -7,8 +7,7 @@
 import { Icac } from "#certificate/kinds/Icac.js";
 import { Noc } from "#certificate/kinds/Noc.js";
 import { Fabric } from "#fabric/Fabric.js";
-import { Bytes, Diagnostic, Duration, Logger, PublicKey, UnexpectedDataError } from "#general";
-import { PeerAddress } from "#peer/PeerAddress.js";
+import { Bytes, Duration, Logger, PublicKey, UnexpectedDataError } from "#general";
 import { MessageExchange, RetransmissionLimitReachedError } from "#protocol/MessageExchange.js";
 import { ChannelStatusResponseError } from "#securechannel/SecureChannelMessenger.js";
 import { NodeSession } from "#session/NodeSession.js";
@@ -135,7 +134,7 @@ export class CaseClient {
                 caseAuthenticatedTags,
             });
             await messenger.sendSuccess();
-            this.#logNewSession("Resumed", secureSession, messenger, fabric, peerNodeId);
+            NodeSession.logNew(logger, "Resumed", secureSession, messenger, fabric, peerNodeId);
 
             resumptionRecord.resumptionId = resumptionId; /* update resumptionId */
             resumptionRecord.sessionParameters = secureSession.parameters; /* update mrpParams */
@@ -246,7 +245,7 @@ export class CaseClient {
                 peerSessionParameters,
                 caseAuthenticatedTags: sessionCaseAuthenticatedTags,
             });
-            this.#logNewSession("New", secureSession, messenger, fabric, peerNodeId);
+            NodeSession.logNew(logger, "New", secureSession, messenger, fabric, peerNodeId);
             resumptionRecord = {
                 fabric,
                 peerNodeId,
@@ -262,25 +261,6 @@ export class CaseClient {
 
         return { session: secureSession, resumed };
     }
-
-    #logNewSession(
-        operation: "New" | "Resumed",
-        session: NodeSession,
-        messenger: CaseClientMessenger,
-        fabric: Fabric,
-        peerNodeId: NodeId,
-    ) {
-        logger.info(
-            `${operation} session with`,
-            Diagnostic.strong(PeerAddress({ fabricIndex: fabric.fabricIndex, nodeId: peerNodeId }).toString()),
-            Diagnostic.dict({
-                id: session.id,
-                address: messenger.channelName,
-                fabric: `${NodeId.toHexString(fabric.nodeId)} (#${fabric.fabricIndex})`,
-                ...session.parameterDiagnostics,
-            }),
-        );
-    }
 }
 
 export namespace CaseClient {

package/src/session/case/CaseMessenger.ts

@@ -47,6 +47,8 @@ export class CaseClientMessenger extends SecureChannelMessenger {
             payload,
             payloadHeader: { messageType },
         } = await this.anyNextMessage("Sigma2(Resume)");
+
+        // TODO Add support for BUSY response and resend the message after waiting time
         switch (messageType) {
             case SecureMessageType.Sigma2:
                 return { sigma2Bytes: payload, sigma2: TlvCaseSigma2.decode(payload) as CaseSigma2 };

package/src/session/case/CaseServer.ts

@@ -5,10 +5,11 @@
  */
 
 import { Noc } from "#certificate/kinds/Noc.js";
-import { Bytes, Crypto, CryptoDecryptError, Logger, PublicKey, UnexpectedDataError } from "#general";
+import { Bytes, Crypto, CryptoDecryptError, Diagnostic, Logger, PublicKey, UnexpectedDataError } from "#general";
+import { NodeSession } from "#session/NodeSession.js";
 import { SessionParametersWithDurations } from "#session/pase/PaseMessages.js";
 import { ResumptionRecord, SessionManager } from "#session/SessionManager.js";
-import { NodeId, SECURE_CHANNEL_PROTOCOL_ID, SecureChannelStatusCode } from "#types";
+import { SECURE_CHANNEL_PROTOCOL_ID, SecureChannelStatusCode } from "#types";
 import { FabricManager, FabricNotFoundError } from "../../fabric/FabricManager.js";
 import { MessageExchange } from "../../protocol/MessageExchange.js";
 import { ProtocolHandler } from "../../protocol/ProtocolHandler.js";
@@ -64,7 +65,7 @@ export class CaseServer implements ProtocolHandler {
     }
 
     async #handleSigma1(messenger: CaseServerMessenger) {
-        logger.info(`Received pairing request from ${messenger.channelName}`);
+        logger.info("Received pairing request «", Diagnostic.via(messenger.channelName));
 
         // Initialize context with information from peer
         const { sigma1Bytes, sigma1 } = await messenger.readSigma1();
@@ -86,9 +87,12 @@ export class CaseServer implements ProtocolHandler {
         }
 
         logger.info(
-            `Invalid resumption ID or resume MIC received from ${messenger.channelName}`,
-            context.peerResumptionId,
-            context.peerResumeMic,
+            "Invalid resumption ID or resume MIC received from",
+            messenger.channelName,
+            Diagnostic.dict({
+                resumptionId: context.peerResumptionId,
+                resumeMic: context.peerResumeMic,
+            }),
         );
 
         throw new UnexpectedDataError("Invalid resumption ID or resume MIC.");
@@ -152,13 +156,8 @@ export class CaseServer implements ProtocolHandler {
             throw error;
         }
 
-        logger.info(
-            `Session ${secureSession.id} resumed with ${cx.messenger.channelName} for Fabric ${NodeId.toHexString(
-                fabric.nodeId,
-            )} (index ${fabric.fabricIndex}) and PeerNode ${NodeId.toHexString(peerNodeId)}`,
-            "with CATs",
-            caseAuthenticatedTags,
-        );
+        NodeSession.logNew(logger, "Resumed", secureSession, cx.messenger, fabric, peerNodeId);
+
         cx.resumptionRecord.resumptionId = cx.localResumptionId; /* Update the ID */
 
         // Wait for success on the peer side
@@ -274,13 +273,9 @@ export class CaseServer implements ProtocolHandler {
             peerSessionParameters: cx.peerSessionParams,
             caseAuthenticatedTags,
         });
-        logger.info(
-            `Session ${secureSession.id} created with ${cx.messenger.channelName} for Fabric ${NodeId.toHexString(
-                fabric.nodeId,
-            )} (index ${fabric.fabricIndex}) and PeerNode ${NodeId.toHexString(peerNodeId)}`,
-            "with CATs",
-            caseAuthenticatedTags,
-        );
+
+        NodeSession.logNew(logger, "New", secureSession, cx.messenger, fabric, peerNodeId);
+
         await cx.messenger.sendSuccess();
 
         const resumptionRecord = {

package/src/session/index.ts

@@ -17,4 +17,5 @@ export * from "./pase/PaseMessenger.js";
 export * from "./pase/PaseServer.js";
 export * from "./SecureSession.js";
 export * from "./Session.js";
+export * from "./SessionIntervals.js";
 export * from "./SessionManager.js";

package/src/session/pase/PaseClient.ts

@@ -106,7 +106,7 @@ export class PaseClient {
             peerSessionParameters,
         });
         await messenger.close();
-        logger.info(`Pase client: Paired successfully with ${messenger.channelName}.`);
+        logger.info("Paired successfully »", messenger.channelName);
 
         return secureSession;
     }

package/src/session/pase/PaseMessenger.ts

@@ -60,6 +60,8 @@ export class PaseClientMessenger extends SecureChannelMessenger {
             SecureMessageType.PbkdfParamResponse,
             DEFAULT_NORMAL_PROCESSING_TIME,
         );
+
+        // TODO Add support for BUSY response and resend the message after waiting time
         return { responsePayload: payload, response: TlvPbkdfParamResponse.decode(payload) as PbkdfParamResponse };
     }
 

package/src/session/pase/PaseServer.ts

@@ -7,6 +7,7 @@
 import {
     Bytes,
     Crypto,
+    Diagnostic,
     ec,
     Logger,
     MatterFlowError,
@@ -104,7 +105,7 @@ export class PaseServer implements ProtocolHandler {
     }
 
     private async handlePairingRequest(crypto: Crypto, messenger: PaseServerMessenger) {
-        logger.info(`Received pairing request from ${messenger.channelName}.`);
+        logger.info("Received pairing request «", Diagnostic.via(messenger.channelName));
 
         this.#pairingTimer = Time.getTimer("PASE pairing timeout", PASE_PAIRING_TIMEOUT_MS, () =>
             this.cancelPairing(messenger),
@@ -167,7 +168,7 @@ export class PaseServer implements ProtocolHandler {
             isResumption: false,
             peerSessionParameters: initiatorSessionParams,
         });
-        logger.info(`Session ${responderSessionId} created with ${messenger.channelName}.`);
+        logger.info(Diagnostic.strong(`Session ${responderSessionId} created`), "with", messenger.channelName);
 
         await messenger.sendSuccess();
         await messenger.close();