openclaw-app 1.0.2 → 1.0.3

package/index.ts

@@ -61,8 +61,7 @@ async function e2eInit(state: E2EState): Promise<string> {
         ["deriveKey"]
     );
     const pubKeyRaw = await crypto.subtle.exportKey("raw", state.localKeyPair.publicKey);
-    const pubKeyB64 = bufToBase64Url(pubKeyRaw);
-    return JSON.stringify({ type: "handshake", pubkey: pubKeyB64 });
+    return bufToBase64Url(pubKeyRaw);
 }
 
 async function e2eHandleHandshake(state: E2EState, peerPubKeyB64: string): Promise<void> {
@@ -150,6 +149,84 @@ function base64UrlToBuf(b64: string): Uint8Array {
     return bytes;
 }
 
+const HANDSHAKE_AUTH_VERSION = "v1";
+const HANDSHAKE_AUTH_CONTEXT = "openclaw-hs-auth-v1";
+const HANDSHAKE_MAX_SKEW_MS = 2 * 60 * 1000;
+
+function canonicalHandshakePayload(
+    version: string,
+    role: "plugin" | "app",
+    sessionKey: string,
+    pubkey: string,
+    ts: number
+): string {
+    return [HANDSHAKE_AUTH_CONTEXT, version, role, sessionKey, String(ts), pubkey].join("|");
+}
+
+async function buildHandshakeMac(
+    token: string,
+    role: "plugin" | "app",
+    sessionKey: string,
+    pubkey: string,
+    ts: number,
+    version = HANDSHAKE_AUTH_VERSION,
+): Promise<string> {
+    const key = await crypto.subtle.importKey(
+        "raw",
+        new TextEncoder().encode(token),
+        { name: "HMAC", hash: "SHA-256" },
+        false,
+        ["sign"]
+    );
+    const payload = new TextEncoder().encode(
+        canonicalHandshakePayload(version, role, sessionKey, pubkey, ts)
+    );
+    const mac = await crypto.subtle.sign("HMAC", key, payload);
+    return bufToBase64Url(mac);
+}
+
+function constantTimeEquals(a: string, b: string): boolean {
+    const aa = new TextEncoder().encode(a);
+    const bb = new TextEncoder().encode(b);
+    if (aa.length !== bb.length) return false;
+    let diff = 0;
+    for (let i = 0; i < aa.length; i++) diff |= aa[i] ^ bb[i];
+    return diff === 0;
+}
+
+function parseHandshakeTs(raw: unknown): number | null {
+    if (typeof raw === "number" && Number.isFinite(raw)) return Math.trunc(raw);
+    if (typeof raw === "string") {
+        const n = Number(raw);
+        if (Number.isFinite(n)) return Math.trunc(n);
+    }
+    return null;
+}
+
+function isHandshakeTsFresh(ts: number): boolean {
+    return Math.abs(Date.now() - ts) <= HANDSHAKE_MAX_SKEW_MS;
+}
+
+async function verifyHandshakeMac(
+    token: string,
+    role: "plugin" | "app",
+    sessionKey: string,
+    pubkey: string,
+    ts: number,
+    mac: string,
+    version: string,
+): Promise<boolean> {
+    const expected = await buildHandshakeMac(
+        token,
+        role,
+        sessionKey,
+        pubkey,
+        ts,
+        version
+    );
+    return constantTimeEquals(mac, expected);
+}
+
 // ── Relay state (per account) ────────────────────────────────────────────────
 
 interface RelayState {
@@ -164,6 +241,7 @@ interface RelayState {
      * so multiple users can be active simultaneously without key collisions.
      */
     e2eSessions: Map<string, E2EState>;
+    relayToken: string;
 }
 
 const relayStates = new Map<string, RelayState>();
@@ -176,7 +254,15 @@ const CHANNEL_ID = "openclaw-app";
 function getRelayState(accountId: string): RelayState {
     let state = relayStates.get(accountId);
     if (!state) {
-        state = { ws: null, reconnectTimer: null, pingTimer: null, statusSink: null, gatewayCtx: null, e2eSessions: new Map() };
+        state = {
+            ws: null,
+            reconnectTimer: null,
+            pingTimer: null,
+            statusSink: null,
+            gatewayCtx: null,
+            e2eSessions: new Map(),
+            relayToken: "",
+        };
         relayStates.set(accountId, state);
     }
     return state;
@@ -346,21 +432,22 @@ const channel = {
             }
 
             const replySessionKey = session?.key ?? null;
-            const sessionE2E = replySessionKey ? state.e2eSessions.get(replySessionKey) : undefined;
+            if (!replySessionKey) {
+                return { ok: false, error: "missing session key" };
+            }
+            const sessionE2E = state.e2eSessions.get(replySessionKey);
+            if (!sessionE2E?.ready) {
+                return { ok: false, error: `e2e not ready for session ${replySessionKey}` };
+            }
             const plainMsg = JSON.stringify({
                 type: "message",
                 role: "assistant",
                 content: outText,
                 sessionKey: replySessionKey,
             });
-            let outMsg: string;
-            if (sessionE2E?.ready) {
-                const encrypted = JSON.parse(await e2eEncrypt(sessionE2E, plainMsg));
-                encrypted.sessionKey = replySessionKey;
-                outMsg = JSON.stringify(encrypted);
-            } else {
-                outMsg = plainMsg;
-            }
+            const encrypted = JSON.parse(await e2eEncrypt(sessionE2E, plainMsg));
+            encrypted.sessionKey = replySessionKey;
+            const outMsg = JSON.stringify(encrypted);
             state.ws.send(outMsg);
 
             return {
@@ -475,6 +562,7 @@ function cleanupRelay(state: RelayState) {
 function connectRelay(ctx: any, account: ResolvedAccount) {
     const accountId = account.accountId;
     const state = getRelayState(accountId);
+    state.relayToken = account.relayToken ?? "";
 
     const base = account.relayUrl.replace(/\/$/, "");
     const params = new URLSearchParams({
@@ -575,6 +663,10 @@ async function handleRelayMessage(ctx: any, accountId: string, state: RelayState
             ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] peer_joined missing sessionKey, ignoring`);
             return;
         }
+        if (!state.relayToken) {
+            ctx.log?.error?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Relay token missing, cannot authenticate handshake`);
+            return;
+        }
         // Always restart E2E when peer_joined arrives — the app may have
         // reconnected with a fresh _e2eReadyCompleter and is waiting for a
         // new handshake even if we still hold an old session state.
@@ -585,9 +677,24 @@ async function handleRelayMessage(ctx: any, accountId: string, state: RelayState
         ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] [E2E] App session joined (${sessionKey}), sending handshake`);
         const sessionE2E = makeE2EState();
         state.e2eSessions.set(sessionKey, sessionE2E);
-        const handshakeMsg = await e2eInit(sessionE2E);
-        // sessionKey를 포함시켜 relay가 올바른 app으로 라우팅하도록 함
-        const handshakeWithSession = JSON.stringify({ ...JSON.parse(handshakeMsg), sessionKey });
+        const pubkey = await e2eInit(sessionE2E);
+        const ts = Date.now();
+        const mac = await buildHandshakeMac(
+            state.relayToken,
+            "plugin",
+            sessionKey,
+            pubkey,
+            ts,
+            HANDSHAKE_AUTH_VERSION
+        );
+        const handshakeWithSession = JSON.stringify({
+            type: "handshake",
+            v: HANDSHAKE_AUTH_VERSION,
+            sessionKey,
+            pubkey,
+            ts,
+            mac,
+        });
         if (state.ws?.readyState === WebSocket.OPEN) {
             state.ws.send(handshakeWithSession);
         }
@@ -598,8 +705,36 @@ async function handleRelayMessage(ctx: any, accountId: string, state: RelayState
     if (msg.type === "handshake") {
         const sessionKey = msg.sessionKey as string | undefined;
         const peerPubKey = msg.pubkey as string | undefined;
-        if (!sessionKey || !peerPubKey) {
-            ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Handshake missing sessionKey or pubkey`);
+        const peerMac = msg.mac as string | undefined;
+        const version = (msg.v as string | undefined) ?? HANDSHAKE_AUTH_VERSION;
+        const peerTs = parseHandshakeTs(msg.ts);
+        if (!sessionKey || !peerPubKey || !peerMac || peerTs == null) {
+            ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Handshake missing auth fields`);
+            return;
+        }
+        if (version !== HANDSHAKE_AUTH_VERSION) {
+            ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Unsupported handshake version: ${version}`);
+            return;
+        }
+        if (!isHandshakeTsFresh(peerTs)) {
+            ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Handshake timestamp out of window, dropping`);
+            return;
+        }
+        if (!state.relayToken) {
+            ctx.log?.error?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Relay token missing, cannot verify handshake`);
+            return;
+        }
+        const verified = await verifyHandshakeMac(
+            state.relayToken,
+            "app",
+            sessionKey,
+            peerPubKey,
+            peerTs,
+            peerMac,
+            version
+        );
+        if (!verified) {
+            ctx.log?.warn?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Handshake MAC verification failed, dropping`);
             return;
         }
         let sessionE2E = state.e2eSessions.get(sessionKey);
@@ -608,8 +743,24 @@ async function handleRelayMessage(ctx: any, accountId: string, state: RelayState
             // 새 세션을 만들고 plugin의 pubkey를 먼저 전송한 후 ECDH 완성
             sessionE2E = makeE2EState();
             state.e2eSessions.set(sessionKey, sessionE2E);
-            const handshakeMsg = await e2eInit(sessionE2E);
-            const handshakeWithSession = JSON.stringify({ ...JSON.parse(handshakeMsg), sessionKey });
+            const pubkey = await e2eInit(sessionE2E);
+            const ts = Date.now();
+            const mac = await buildHandshakeMac(
+                state.relayToken,
+                "plugin",
+                sessionKey,
+                pubkey,
+                ts,
+                HANDSHAKE_AUTH_VERSION
+            );
+            const handshakeWithSession = JSON.stringify({
+                type: "handshake",
+                v: HANDSHAKE_AUTH_VERSION,
+                sessionKey,
+                pubkey,
+                ts,
+                mac,
+            });
             if (state.ws?.readyState === WebSocket.OPEN) {
                 state.ws.send(handshakeWithSession);
                 ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] [E2E] Session ${sessionKey} — sent handshake (reactive, no prior peer_joined)`);
@@ -650,6 +801,16 @@ async function handleRelayMessage(ctx: any, accountId: string, state: RelayState
     }
 
     // Plaintext message (no E2E or during handshake)
+    if (msg.type === "message" || msg.type === "delta" || msg.type === "final" || msg.type === "abort") {
+        const sessionKey = msg.sessionKey as string | undefined;
+        const sessionE2E = sessionKey ? state.e2eSessions.get(sessionKey) : undefined;
+        if (!sessionE2E?.ready) {
+            ctx.log?.warn?.(
+                `[${CHANNEL_ID}] [${accountId}] [E2E] Dropping plaintext ${msg.type} (session not encrypted yet)`
+            );
+            return;
+        }
+    }
     await handleInbound(ctx, accountId, msg);
 }
 
@@ -764,6 +925,12 @@ async function handleInbound(ctx: any, accountId: string, msg: any) {
                     // The relay routes plugin→app by sessionKey in the JSON payload
                     const replySessionKey = appSessionKey ?? sessionKey;
                     const sessionE2E = relayState.e2eSessions.get(replySessionKey);
+                    if (!sessionE2E?.ready) {
+                        ctx.log?.warn?.(
+                            `[${CHANNEL_ID}] [${accountId}] [E2E] Reply blocked: session ${replySessionKey} not ready`
+                        );
+                        return;
+                    }
                     for (const chunk of chunks.length > 0 ? chunks : [replyText]) {
                         if (!chunk) continue;
                         const plainMsg = JSON.stringify({
@@ -772,17 +939,9 @@ async function handleInbound(ctx: any, accountId: string, msg: any) {
                             content: chunk,
                             sessionKey: replySessionKey,
                         });
-                        // Encrypt with the per-session key if handshake is complete.
-                        // The outer envelope must carry sessionKey so the relay can route
-                        // the message to the correct app connection.
-                        let outMsg: string;
-                        if (sessionE2E?.ready) {
-                            const encrypted = JSON.parse(await e2eEncrypt(sessionE2E, plainMsg));
-                            encrypted.sessionKey = replySessionKey;
-                            outMsg = JSON.stringify(encrypted);
-                        } else {
-                            outMsg = plainMsg;
-                        }
+                        const encrypted = JSON.parse(await e2eEncrypt(sessionE2E, plainMsg));
+                        encrypted.sessionKey = replySessionKey;
+                        const outMsg = JSON.stringify(encrypted);
                         relayState.ws.send(outMsg);
                     }
                     ctx.log?.info?.(`[${CHANNEL_ID}] [${accountId}] Reply delivered (${replyText.length} chars) to sessionKey=${replySessionKey}`);

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
     "id": "openclaw-app",
     "name": "OpenClaw App",
-    "version": "1.0.2",
+    "version": "1.0.3",
     "description": "Mobile app channel for OpenClaw — chat via the OpenClaw Mobile app through a Cloudflare Worker relay.",
     "channels": [
         "openclaw-app"

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "openclaw-app",
-    "version": "1.0.2",
+    "version": "1.0.3",
     "description": "OpenClaw Mobile channel plugin — relay bridge for the OpenClaw Mobile app",
     "main": "index.ts",
     "type": "module",