@openchamber/web 1.14.0 → 1.15.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (100) hide show
  1. package/bin/cli.test.js +8 -0
  2. package/bin/lib/DOCUMENTATION.md +3 -0
  3. package/bin/lib/cli-args.js +10 -0
  4. package/bin/lib/commands-connect-url.js +169 -22
  5. package/dist/assets/{DiagramView-CIaZCGUT.js → DiagramView-HR2xZxJ8.js} +1 -1
  6. package/dist/assets/MarkdownRendererImpl-sm01Q7R7.js +11 -0
  7. package/dist/assets/{MultiRunWindow-Bsbr3i8y.js → MultiRunWindow-DlFUaNQK.js} +1 -1
  8. package/dist/assets/OnboardingScreen-DVRz82mJ.js +1 -0
  9. package/dist/assets/{SessionSwitcherDropdown-CLm6tF5n.js → SessionSwitcherDropdown-DvoOalMY.js} +1 -1
  10. package/dist/assets/SettingsWindow-CkInZcj7.js +1 -0
  11. package/dist/assets/{TerminalView-DF7-jlam.js → TerminalView-D_9BAjtv.js} +3 -3
  12. package/dist/assets/es-cjUissX4.js +15 -0
  13. package/dist/assets/fr-DqbXnTdK.js +13 -0
  14. package/dist/assets/index-Dg0nmvQU.css +1 -0
  15. package/dist/assets/index-ltrmNGAf.js +2 -0
  16. package/dist/assets/ja-Cetyq6Eg.js +15 -0
  17. package/dist/assets/ko-DtunWisP.js +15 -0
  18. package/dist/assets/main-BC0m8s1v.js +236 -0
  19. package/dist/assets/main-DzNa8r0N.js +2 -0
  20. package/dist/assets/miniChat-BRYDE-Se.js +2 -0
  21. package/dist/assets/mobile-C3QJVA97.js +2 -0
  22. package/dist/assets/pl-DctGLgve.js +15 -0
  23. package/dist/assets/pt-BR-CXPhf78S.js +15 -0
  24. package/dist/assets/renderElectronMiniChatApp-CVFbDC5A.js +2 -0
  25. package/dist/assets/renderMobileApp-wkBjh5WR.js +16 -0
  26. package/dist/assets/runtimeEndpointReset-C42u8PvG.js +167 -0
  27. package/dist/assets/uk-Bdrc-kqF.js +15 -0
  28. package/dist/assets/{useAppFontEffects-DTO332li.js → useAppFontEffects-DzBg8hrC.js} +132 -116
  29. package/dist/assets/{vendor-.bun-C6iL44L9.js → vendor-.bun-BE757pvp.js} +1 -1
  30. package/dist/assets/zh-CN-CeCVKrHP.js +15 -0
  31. package/dist/assets/zh-TW-CoqiQING.js +15 -0
  32. package/dist/index.html +4 -4
  33. package/dist/mini-chat.html +4 -4
  34. package/dist/mobile.html +4 -4
  35. package/package.json +2 -2
  36. package/server/index.js +157 -6
  37. package/server/lib/client-auth/pairing.js +308 -0
  38. package/server/lib/client-auth/pairing.test.js +142 -0
  39. package/server/lib/client-auth/remote-clients.js +65 -3
  40. package/server/lib/notifications/apns-runtime.js +9 -16
  41. package/server/lib/opencode/bootstrap-runtime.js +10 -0
  42. package/server/lib/opencode/core-routes.js +247 -6
  43. package/server/lib/opencode/core-routes.test.js +248 -9
  44. package/server/lib/opencode/feature-routes-runtime.js +10 -0
  45. package/server/lib/opencode/models-metadata.js +61 -0
  46. package/server/lib/opencode/network-runtime.js +14 -1
  47. package/server/lib/opencode/network-runtime.test.js +29 -9
  48. package/server/lib/opencode/openchamber-routes.js +7 -40
  49. package/server/lib/opencode/proxy.js +47 -6
  50. package/server/lib/opencode/settings-helpers.js +16 -0
  51. package/server/lib/opencode/settings-helpers.test.js +11 -0
  52. package/server/lib/opencode/settings-normalization-runtime.js +2 -0
  53. package/server/lib/opencode/shutdown-runtime.js +2 -0
  54. package/server/lib/package-manager.js +18 -5
  55. package/server/lib/relay/DOCUMENTATION.md +78 -0
  56. package/server/lib/relay/cross-compat.test.js +135 -0
  57. package/server/lib/relay/e2ee.js +341 -0
  58. package/server/lib/relay/e2ee.test.js +124 -0
  59. package/server/lib/relay/host-client.js +389 -0
  60. package/server/lib/relay/host-client.test.js +280 -0
  61. package/server/lib/relay/identity.js +73 -0
  62. package/server/lib/relay/identity.test.js +78 -0
  63. package/server/lib/relay/service.js +247 -0
  64. package/server/lib/relay/signing-key.js +50 -0
  65. package/server/lib/relay/tunnel-codec.js +373 -0
  66. package/server/lib/relay/tunnel-codec.test.js +58 -0
  67. package/server/lib/relay/tunnel-host.js +462 -0
  68. package/server/lib/session-assist/DOCUMENTATION.md +66 -0
  69. package/server/lib/session-assist/runtime.js +394 -0
  70. package/server/lib/small-model/DOCUMENTATION.md +78 -0
  71. package/server/lib/small-model/call.js +380 -0
  72. package/server/lib/small-model/catalog.js +13 -0
  73. package/server/lib/small-model/index.js +167 -0
  74. package/server/lib/small-model/resolve.js +131 -0
  75. package/server/lib/small-model/resolve.test.js +197 -0
  76. package/server/lib/small-model/routes.js +44 -0
  77. package/server/lib/ui-auth/DOCUMENTATION.md +6 -0
  78. package/server/lib/ui-auth/ui-auth.js +10 -0
  79. package/server/opencode-proxy.test.js +38 -0
  80. package/dist/assets/MarkdownRendererImpl-DWgOeIpO.js +0 -7
  81. package/dist/assets/OnboardingScreen-3IAKkM5k.js +0 -1
  82. package/dist/assets/SettingsWindow-K-ErjehP.js +0 -1
  83. package/dist/assets/es-DQIFCjC2.js +0 -15
  84. package/dist/assets/fr-CJRav0LS.js +0 -13
  85. package/dist/assets/index-5eUDDB6w.js +0 -2
  86. package/dist/assets/index-CgpE7F8T.css +0 -1
  87. package/dist/assets/ja-CjAaqvHO.js +0 -15
  88. package/dist/assets/ko-BEbFxvrd.js +0 -15
  89. package/dist/assets/main-C2put7uQ.js +0 -2
  90. package/dist/assets/main-DuQEoz31.js +0 -214
  91. package/dist/assets/miniChat-o3AAQ-8r.js +0 -2
  92. package/dist/assets/mobile-X0421aWz.js +0 -2
  93. package/dist/assets/pl-D4kzai5T.js +0 -15
  94. package/dist/assets/pt-BR-9Sk3esQZ.js +0 -15
  95. package/dist/assets/renderElectronMiniChatApp-CdDj0ms1.js +0 -2
  96. package/dist/assets/renderMobileApp-cZ_HZKSe.js +0 -16
  97. package/dist/assets/runtimeEndpointReset-BYLVW9e7.js +0 -167
  98. package/dist/assets/uk-DW_dTfoO.js +0 -15
  99. package/dist/assets/zh-CN-r2_euV7U.js +0 -15
  100. package/dist/assets/zh-TW-BdPx3NWh.js +0 -15
@@ -0,0 +1,341 @@
1
+ // E2EE primitives + responder handshake for the private relay (Layer 2).
2
+ // JS mirror of the normative TS implementation in
3
+ // packages/ui/src/lib/relay/{protocol,crypto,handshake}.ts — the web server is
4
+ // plain JS and cannot import from packages/ui, so the logic is copied verbatim
5
+ // (converted to JSDoc'd JS) and MUST stay byte-compatible with those modules.
6
+ // WebCrypto only: `globalThis.crypto.subtle` (Node >= 22).
7
+ // Spec: .opencode/plans/private-relay/01-protocol-spec.md (Layer 2).
8
+
9
+ const subtle = globalThis.crypto.subtle;
10
+
11
+ export const RELAY_PROTOCOL_VERSION = 1;
12
+ export const RELAY_HKDF_INFO = 'openchamber-relay-v1';
13
+
14
+ // Encrypted frame layout: [1 byte version][12 byte IV][ciphertext + 16 byte GCM tag].
15
+ export const ENCRYPTED_FRAME_VERSION = 1;
16
+ export const ENCRYPTED_FRAME_IV_BYTES = 12;
17
+ export const ENCRYPTED_FRAME_HEADER_BYTES = 1 + ENCRYPTED_FRAME_IV_BYTES;
18
+ export const MAX_PLAINTEXT_FRAME_BYTES = 64 * 1024;
19
+
20
+ // Relay-assigned WebSocket close codes (subset the host needs).
21
+ export const RelayCloseCode = {
22
+ RekeyMismatch: 1008,
23
+ ChannelFailure: 1011,
24
+ };
25
+
26
+ const ECDH_PARAMS = { name: 'ECDH', namedCurve: 'P-256' };
27
+ const HANDSHAKE_NONCE_BYTES = 16;
28
+ const SESSION_KEY_BYTES = 32;
29
+ const GCM_TAG_BYTES = 16;
30
+ // IV = 4-byte random per-direction prefix || 8-byte big-endian frame counter.
31
+ const IV_PREFIX_BYTES = 4;
32
+ const IV_COUNTER_BYTES = 8;
33
+
34
+ export class RelayCryptoError extends Error {
35
+ constructor(message) {
36
+ super(message);
37
+ this.name = 'RelayCryptoError';
38
+ }
39
+ }
40
+
41
+ /** @returns {Promise<CryptoKeyPair>} */
42
+ export const generateEcdhKeyPair = () => subtle.generateKey(ECDH_PARAMS, true, ['deriveBits']);
43
+
44
+ /**
45
+ * @param {CryptoKey} key
46
+ * @returns {Promise<JsonWebKey>} public JWK reduced to the fields that define the point
47
+ */
48
+ export const exportPublicKeyJwk = async (key) => {
49
+ const jwk = await subtle.exportKey('jwk', key);
50
+ return { kty: jwk.kty, crv: jwk.crv, x: jwk.x, y: jwk.y };
51
+ };
52
+
53
+ /** @param {JsonWebKey} jwk */
54
+ export const importEcdhPublicKey = async (jwk) => {
55
+ if (jwk.kty !== 'EC' || jwk.crv !== 'P-256' || typeof jwk.x !== 'string' || typeof jwk.y !== 'string') {
56
+ throw new RelayCryptoError('invalid ECDH public key JWK');
57
+ }
58
+ try {
59
+ return await subtle.importKey(
60
+ 'jwk',
61
+ { kty: jwk.kty, crv: jwk.crv, x: jwk.x, y: jwk.y, ext: true },
62
+ ECDH_PARAMS,
63
+ true,
64
+ [],
65
+ );
66
+ } catch {
67
+ throw new RelayCryptoError('invalid ECDH public key JWK');
68
+ }
69
+ };
70
+
71
+ /** @param {JsonWebKey} jwk private ECDH JWK (d + point) */
72
+ export const importEcdhPrivateKey = async (jwk) => {
73
+ try {
74
+ return await subtle.importKey('jwk', jwk, ECDH_PARAMS, false, ['deriveBits']);
75
+ } catch {
76
+ throw new RelayCryptoError('invalid ECDH private key JWK');
77
+ }
78
+ };
79
+
80
+ // Stable fingerprint of a public key, used to detect rekey attempts on re-hello.
81
+ /** @param {JsonWebKey} jwk */
82
+ export const publicKeyJwkFingerprint = (jwk) =>
83
+ JSON.stringify({ crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y });
84
+
85
+ export const generateHandshakeNonce = () => {
86
+ const nonce = new Uint8Array(HANDSHAKE_NONCE_BYTES);
87
+ globalThis.crypto.getRandomValues(nonce);
88
+ return nonce;
89
+ };
90
+
91
+ /**
92
+ * Both sides call this with their own private key and the peer's public key;
93
+ * ECDH yields the same shared secret, so the derived key pair matches.
94
+ * @param {CryptoKey} ownPrivateKey
95
+ * @param {CryptoKey} peerPublicKey
96
+ * @param {Uint8Array} handshakeNonce
97
+ * @returns {Promise<{ clientToHost: CryptoKey, hostToClient: CryptoKey }>}
98
+ */
99
+ export const deriveSessionKeys = async (ownPrivateKey, peerPublicKey, handshakeNonce) => {
100
+ if (handshakeNonce.length !== HANDSHAKE_NONCE_BYTES) {
101
+ throw new RelayCryptoError('invalid handshake nonce length');
102
+ }
103
+ const sharedSecret = await subtle.deriveBits({ name: 'ECDH', public: peerPublicKey }, ownPrivateKey, 256);
104
+ const hkdfKey = await subtle.importKey('raw', sharedSecret, 'HKDF', false, ['deriveBits']);
105
+ const keyMaterial = new Uint8Array(
106
+ await subtle.deriveBits(
107
+ {
108
+ name: 'HKDF',
109
+ hash: 'SHA-256',
110
+ salt: handshakeNonce,
111
+ info: new TextEncoder().encode(RELAY_HKDF_INFO),
112
+ },
113
+ hkdfKey,
114
+ SESSION_KEY_BYTES * 2 * 8,
115
+ ),
116
+ );
117
+ const importAesKey = (bytes, usage) => subtle.importKey('raw', bytes, { name: 'AES-GCM' }, false, usage);
118
+ return {
119
+ clientToHost: await importAesKey(keyMaterial.slice(0, SESSION_KEY_BYTES), ['encrypt', 'decrypt']),
120
+ hostToClient: await importAesKey(keyMaterial.slice(SESSION_KEY_BYTES), ['encrypt', 'decrypt']),
121
+ };
122
+ };
123
+
124
+ const writeCounter = (target, offset, counter) => {
125
+ for (let i = IV_COUNTER_BYTES - 1; i >= 0; i -= 1) {
126
+ target[offset + i] = Number(counter & 0xffn);
127
+ counter >>= 8n;
128
+ }
129
+ };
130
+
131
+ const readCounter = (source, offset) => {
132
+ let value = 0n;
133
+ for (let i = 0; i < IV_COUNTER_BYTES; i += 1) {
134
+ value = (value << 8n) | BigInt(source[offset + i]);
135
+ }
136
+ return value;
137
+ };
138
+
139
+ /** @param {CryptoKey} key AES-256-GCM key for this direction */
140
+ export const createFrameEncryptor = (key) => {
141
+ const ivPrefix = new Uint8Array(IV_PREFIX_BYTES);
142
+ globalThis.crypto.getRandomValues(ivPrefix);
143
+ let counter = 0n;
144
+ return {
145
+ /** @param {Uint8Array} plaintext */
146
+ async encrypt(plaintext) {
147
+ if (plaintext.length > MAX_PLAINTEXT_FRAME_BYTES) {
148
+ throw new RelayCryptoError('plaintext frame exceeds maximum size');
149
+ }
150
+ counter += 1n;
151
+ const iv = new Uint8Array(ENCRYPTED_FRAME_IV_BYTES);
152
+ iv.set(ivPrefix, 0);
153
+ writeCounter(iv, IV_PREFIX_BYTES, counter);
154
+ const ciphertext = new Uint8Array(await subtle.encrypt({ name: 'AES-GCM', iv }, key, plaintext));
155
+ const frame = new Uint8Array(ENCRYPTED_FRAME_HEADER_BYTES + ciphertext.length);
156
+ frame[0] = ENCRYPTED_FRAME_VERSION;
157
+ frame.set(iv, 1);
158
+ frame.set(ciphertext, ENCRYPTED_FRAME_HEADER_BYTES);
159
+ return frame;
160
+ },
161
+ };
162
+ };
163
+
164
+ // Enforces strictly increasing per-direction counters: the relay WS preserves
165
+ // ordering, so any regression or replay means tampering and must fail closed.
166
+ /** @param {CryptoKey} key AES-256-GCM key for this direction */
167
+ export const createFrameDecryptor = (key) => {
168
+ let lastCounter = 0n;
169
+ return {
170
+ /** @param {Uint8Array} frame */
171
+ async decrypt(frame) {
172
+ if (frame.length < ENCRYPTED_FRAME_HEADER_BYTES + GCM_TAG_BYTES) {
173
+ throw new RelayCryptoError('encrypted frame too short');
174
+ }
175
+ if (frame[0] !== ENCRYPTED_FRAME_VERSION) {
176
+ throw new RelayCryptoError('unsupported encrypted frame version');
177
+ }
178
+ const iv = frame.slice(1, ENCRYPTED_FRAME_HEADER_BYTES);
179
+ const counter = readCounter(iv, IV_PREFIX_BYTES);
180
+ if (counter <= lastCounter) {
181
+ throw new RelayCryptoError('frame counter regression');
182
+ }
183
+ let plaintext;
184
+ try {
185
+ plaintext = await subtle.decrypt({ name: 'AES-GCM', iv }, key, frame.slice(ENCRYPTED_FRAME_HEADER_BYTES));
186
+ } catch {
187
+ throw new RelayCryptoError('frame decryption failed');
188
+ }
189
+ lastCounter = counter;
190
+ return new Uint8Array(plaintext);
191
+ },
192
+ };
193
+ };
194
+
195
+ const BASE64URL_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
196
+
197
+ /** @param {Uint8Array} bytes */
198
+ export const bytesToBase64Url = (bytes) => {
199
+ let out = '';
200
+ for (let i = 0; i < bytes.length; i += 3) {
201
+ const b0 = bytes[i];
202
+ const b1 = i + 1 < bytes.length ? bytes[i + 1] : undefined;
203
+ const b2 = i + 2 < bytes.length ? bytes[i + 2] : undefined;
204
+ out += BASE64URL_ALPHABET[b0 >> 2];
205
+ out += BASE64URL_ALPHABET[((b0 & 0x03) << 4) | ((b1 ?? 0) >> 4)];
206
+ if (b1 !== undefined) out += BASE64URL_ALPHABET[((b1 & 0x0f) << 2) | ((b2 ?? 0) >> 6)];
207
+ if (b2 !== undefined) out += BASE64URL_ALPHABET[b2 & 0x3f];
208
+ }
209
+ return out;
210
+ };
211
+
212
+ /** @param {string} value */
213
+ export const base64UrlToBytes = (value) => {
214
+ if (!/^[A-Za-z0-9_-]*$/.test(value) || value.length % 4 === 1) {
215
+ throw new RelayCryptoError('invalid base64url input');
216
+ }
217
+ const out = new Uint8Array(Math.floor((value.length * 3) / 4));
218
+ let outIndex = 0;
219
+ let buffer = 0;
220
+ let bits = 0;
221
+ for (const char of value) {
222
+ buffer = (buffer << 6) | BASE64URL_ALPHABET.indexOf(char);
223
+ bits += 6;
224
+ if (bits >= 8) {
225
+ bits -= 8;
226
+ out[outIndex] = (buffer >> bits) & 0xff;
227
+ outIndex += 1;
228
+ }
229
+ }
230
+ return out;
231
+ };
232
+
233
+ // ---------------------------------------------------------------------------
234
+ // Responder handshake state machine (host side). Mirror of createHostHandshake
235
+ // in packages/ui/src/lib/relay/handshake.ts.
236
+ //
237
+ // Fail-closed rules (from the spec):
238
+ // - a repeated identical `hello` re-sends `ready` (client retry race);
239
+ // - a `hello` with a DIFFERENT key on an established channel is a rekey
240
+ // attack -> close 1008, never rekey in place;
241
+ // - plaintext after `ready`, or any decrypt failure -> close 1011.
242
+ // ---------------------------------------------------------------------------
243
+
244
+ const parseHandshakeMessage = (raw) => {
245
+ let parsed;
246
+ try {
247
+ parsed = JSON.parse(raw);
248
+ } catch {
249
+ return null;
250
+ }
251
+ if (typeof parsed !== 'object' || parsed === null) return null;
252
+ if (parsed.v !== RELAY_PROTOCOL_VERSION) return null;
253
+ // Unknown/missing capability flag = false = legacy behavior.
254
+ const batch = parsed.batch === true;
255
+ if (parsed.t === 'ready') {
256
+ return { t: 'ready', v: RELAY_PROTOCOL_VERSION, batch };
257
+ }
258
+ if (parsed.t === 'hello' && typeof parsed.nonce === 'string' && typeof parsed.clientPubJwk === 'object' && parsed.clientPubJwk !== null) {
259
+ return { t: 'hello', v: RELAY_PROTOCOL_VERSION, clientPubJwk: parsed.clientPubJwk, nonce: parsed.nonce, batch };
260
+ }
261
+ return null;
262
+ };
263
+
264
+ const failClosed = (reason) => ({
265
+ type: 'fail',
266
+ closeCode: RelayCloseCode.ChannelFailure,
267
+ reason,
268
+ });
269
+
270
+ /**
271
+ * Host (responder) handshake. Feed every inbound text frame to `handleText`;
272
+ * it returns one of:
273
+ * { type: 'send-text', text } — send this plaintext frame
274
+ * { type: 'established', channel, replyText } — send replyText first, then switch to encrypted frames
275
+ * { type: 'ignore' } — drop the frame
276
+ * { type: 'fail', closeCode, reason } — close the socket with closeCode
277
+ * @param {CryptoKey} hostEncPrivateKey long-lived ECDH private key
278
+ * @param {{ batch?: boolean }} [options] `batch` defaults true; set false to force legacy behavior
279
+ */
280
+ export const createHostHandshake = (hostEncPrivateKey, options = {}) => {
281
+ const localBatch = options.batch !== false;
282
+ let established = false;
283
+ let acceptedClientKeyFingerprint = null;
284
+ let readyText = null;
285
+ let negotiatedBatch = false;
286
+ return {
287
+ get established() {
288
+ return established;
289
+ },
290
+ /** @param {string} raw */
291
+ async handleText(raw) {
292
+ const message = parseHandshakeMessage(raw);
293
+ if (message?.t !== 'hello') {
294
+ if (established) {
295
+ return failClosed('plaintext frame on established channel');
296
+ }
297
+ return { type: 'ignore' };
298
+ }
299
+ const fingerprint = publicKeyJwkFingerprint(message.clientPubJwk);
300
+ if (acceptedClientKeyFingerprint !== null) {
301
+ if (fingerprint === acceptedClientKeyFingerprint && readyText !== null) {
302
+ // Client retried `hello` before our `ready` arrived — answer again.
303
+ return { type: 'send-text', text: readyText };
304
+ }
305
+ return { type: 'fail', closeCode: RelayCloseCode.RekeyMismatch, reason: 'rekey mismatch' };
306
+ }
307
+ let clientPublicKey;
308
+ let nonce;
309
+ try {
310
+ clientPublicKey = await importEcdhPublicKey(message.clientPubJwk);
311
+ nonce = base64UrlToBytes(message.nonce);
312
+ } catch {
313
+ return failClosed('malformed hello');
314
+ }
315
+ let keys;
316
+ try {
317
+ keys = await deriveSessionKeys(hostEncPrivateKey, clientPublicKey, nonce);
318
+ } catch {
319
+ return failClosed('key derivation failed');
320
+ }
321
+ acceptedClientKeyFingerprint = fingerprint;
322
+ // Batching runs only if both peers advertised it.
323
+ negotiatedBatch = localBatch && message.batch === true;
324
+ readyText = JSON.stringify(
325
+ negotiatedBatch
326
+ ? { t: 'ready', v: RELAY_PROTOCOL_VERSION, batch: true }
327
+ : { t: 'ready', v: RELAY_PROTOCOL_VERSION },
328
+ );
329
+ established = true;
330
+ return {
331
+ type: 'established',
332
+ batch: negotiatedBatch,
333
+ replyText: readyText,
334
+ channel: {
335
+ encryptor: createFrameEncryptor(keys.hostToClient),
336
+ decryptor: createFrameDecryptor(keys.clientToHost),
337
+ },
338
+ };
339
+ },
340
+ };
341
+ };
@@ -0,0 +1,124 @@
1
+ import { describe, expect, it } from 'bun:test';
2
+
3
+ import {
4
+ base64UrlToBytes,
5
+ bytesToBase64Url,
6
+ createFrameDecryptor,
7
+ createFrameEncryptor,
8
+ createHostHandshake,
9
+ deriveSessionKeys,
10
+ exportPublicKeyJwk,
11
+ generateEcdhKeyPair,
12
+ generateHandshakeNonce,
13
+ RELAY_PROTOCOL_VERSION,
14
+ } from './e2ee.js';
15
+
16
+ const subtle = globalThis.crypto.subtle;
17
+
18
+ // A minimal client-side initiator so the host handshake can be exercised
19
+ // end-to-end without importing the browser TS modules.
20
+ const createClientHandshake = async (hostEncPubJwk) => {
21
+ const hostPublicKey = await subtle.importKey(
22
+ 'jwk',
23
+ { kty: hostEncPubJwk.kty, crv: hostEncPubJwk.crv, x: hostEncPubJwk.x, y: hostEncPubJwk.y, ext: true },
24
+ { name: 'ECDH', namedCurve: 'P-256' },
25
+ true,
26
+ [],
27
+ );
28
+ const ephemeral = await generateEcdhKeyPair();
29
+ const nonce = generateHandshakeNonce();
30
+ const helloText = JSON.stringify({
31
+ t: 'hello',
32
+ v: RELAY_PROTOCOL_VERSION,
33
+ clientPubJwk: await exportPublicKeyJwk(ephemeral.publicKey),
34
+ nonce: bytesToBase64Url(nonce),
35
+ });
36
+ const deriveChannel = async () => {
37
+ const keys = await deriveSessionKeys(ephemeral.privateKey, hostPublicKey, nonce);
38
+ return {
39
+ encryptor: createFrameEncryptor(keys.clientToHost),
40
+ decryptor: createFrameDecryptor(keys.hostToClient),
41
+ };
42
+ };
43
+ return { helloText, deriveChannel };
44
+ };
45
+
46
+ describe('relay e2ee', () => {
47
+ it('round-trips frames in both directions after handshake', async () => {
48
+ const hostKeys = await generateEcdhKeyPair();
49
+ const hostPubJwk = await exportPublicKeyJwk(hostKeys.publicKey);
50
+ const host = createHostHandshake(hostKeys.privateKey);
51
+ const client = await createClientHandshake(hostPubJwk);
52
+
53
+ const action = await host.handleText(client.helloText);
54
+ expect(action.type).toBe('established');
55
+ const hostChannel = action.channel;
56
+ const clientChannel = await client.deriveChannel();
57
+
58
+ const c2h = new TextEncoder().encode('client-to-host payload');
59
+ const decodedAtHost = await hostChannel.decryptor.decrypt(await clientChannel.encryptor.encrypt(c2h));
60
+ expect(new TextDecoder().decode(decodedAtHost)).toBe('client-to-host payload');
61
+
62
+ const h2c = new TextEncoder().encode('host-to-client payload');
63
+ const decodedAtClient = await clientChannel.decryptor.decrypt(await hostChannel.encryptor.encrypt(h2c));
64
+ expect(new TextDecoder().decode(decodedAtClient)).toBe('host-to-client payload');
65
+ });
66
+
67
+ it('rejects tampered ciphertext', async () => {
68
+ const keyBytes = new Uint8Array(32);
69
+ globalThis.crypto.getRandomValues(keyBytes);
70
+ const key = await subtle.importKey('raw', keyBytes, { name: 'AES-GCM' }, false, ['encrypt', 'decrypt']);
71
+ const enc = createFrameEncryptor(key);
72
+ const dec = createFrameDecryptor(key);
73
+ const frame = await enc.encrypt(new Uint8Array([1, 2, 3]));
74
+ frame[frame.length - 1] ^= 0xff;
75
+ await expect(dec.decrypt(frame)).rejects.toThrow();
76
+ });
77
+
78
+ it('rejects counter regression / replay', async () => {
79
+ const keyBytes = new Uint8Array(32);
80
+ globalThis.crypto.getRandomValues(keyBytes);
81
+ const key = await subtle.importKey('raw', keyBytes, { name: 'AES-GCM' }, false, ['encrypt', 'decrypt']);
82
+ const enc = createFrameEncryptor(key);
83
+ const dec = createFrameDecryptor(key);
84
+ const first = await enc.encrypt(new Uint8Array([9]));
85
+ await dec.decrypt(first);
86
+ // Replaying the same frame (counter no longer strictly increasing) fails.
87
+ await expect(dec.decrypt(first)).rejects.toThrow('frame counter regression');
88
+ });
89
+
90
+ it('re-sends ready on identical re-hello and fails on rekey', async () => {
91
+ const hostKeys = await generateEcdhKeyPair();
92
+ const hostPubJwk = await exportPublicKeyJwk(hostKeys.publicKey);
93
+ const host = createHostHandshake(hostKeys.privateKey);
94
+ const client = await createClientHandshake(hostPubJwk);
95
+
96
+ const first = await host.handleText(client.helloText);
97
+ expect(first.type).toBe('established');
98
+
99
+ const repeat = await host.handleText(client.helloText);
100
+ expect(repeat.type).toBe('send-text');
101
+ expect(repeat.text).toBe(first.replyText);
102
+
103
+ const other = await createClientHandshake(hostPubJwk);
104
+ const rekey = await host.handleText(other.helloText);
105
+ expect(rekey.type).toBe('fail');
106
+ expect(rekey.closeCode).toBe(1008);
107
+ });
108
+
109
+ it('fails closed on plaintext after ready', async () => {
110
+ const hostKeys = await generateEcdhKeyPair();
111
+ const hostPubJwk = await exportPublicKeyJwk(hostKeys.publicKey);
112
+ const host = createHostHandshake(hostKeys.privateKey);
113
+ const client = await createClientHandshake(hostPubJwk);
114
+ await host.handleText(client.helloText);
115
+ const action = await host.handleText(JSON.stringify({ hello: 'not a handshake' }));
116
+ expect(action.type).toBe('fail');
117
+ expect(action.closeCode).toBe(1011);
118
+ });
119
+
120
+ it('base64url helpers round-trip', () => {
121
+ const bytes = new Uint8Array([0, 1, 2, 250, 251, 252, 253, 254, 255]);
122
+ expect(Array.from(base64UrlToBytes(bytesToBase64Url(bytes)))).toEqual(Array.from(bytes));
123
+ });
124
+ });