@camerontaylor/paseo-relay 0.8.0-fork.1

package/dist/crypto.js

@@ -0,0 +1,145 @@
+/// <reference lib="dom" />
+/**
+ * E2EE crypto primitives using NaCl (tweetnacl).
+ *
+ * - Key exchange: Curve25519 (nacl.box.before)
+ * - Encryption: XSalsa20-Poly1305 (nacl.box.after / open.after)
+ *
+ * Bundle format (binary):
+ *   [nonce (24 bytes)] [ciphertext...]
+ *
+ * The encrypted channel chooses the WebSocket representation. Crypto remains
+ * byte-oriented so frame kind is never inferred from plaintext contents.
+ */
+import nacl from "tweetnacl";
+import { fromByteArray, toByteArray } from "base64-js";
+const NONCE_LENGTH = nacl.box.nonceLength; // 24
+const ZERO_X25519_SHARED_RESULT = new Uint8Array(nacl.box.sharedKeyLength);
+let prngReady = false;
+function getGlobalCrypto() {
+    const g = globalThis;
+    return g.crypto;
+}
+function ensurePrng() {
+    if (prngReady)
+        return;
+    try {
+        nacl.randomBytes(1);
+        prngReady = true;
+        return;
+    }
+    catch {
+        // fallthrough
+    }
+    const cryptoObj = getGlobalCrypto();
+    if (cryptoObj?.getRandomValues) {
+        nacl.setPRNG((x, n) => {
+            const buf = new Uint8Array(n);
+            cryptoObj.getRandomValues(buf);
+            x.set(buf, 0);
+        });
+        prngReady = true;
+        return;
+    }
+    throw new Error("No secure PRNG available for tweetnacl (missing crypto.getRandomValues)");
+}
+function encodeBase64(bytes) {
+    return fromByteArray(bytes);
+}
+function decodeBase64(base64) {
+    return toByteArray(base64);
+}
+function decodePublicKeyBase64(base64) {
+    if (typeof base64 !== "string" ||
+        base64.length % 4 !== 0 ||
+        !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(base64)) {
+        throw new Error("Invalid public key encoding");
+    }
+    const bytes = decodeBase64(base64);
+    if (encodeBase64(bytes) !== base64) {
+        throw new Error("Invalid public key encoding");
+    }
+    return bytes;
+}
+function toUint8(data) {
+    return typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
+}
+function toArrayBuffer(bytes) {
+    const out = new Uint8Array(bytes.byteLength);
+    out.set(bytes);
+    return out.buffer;
+}
+export function generateKeyPair() {
+    ensurePrng();
+    const { publicKey, secretKey } = nacl.box.keyPair();
+    return { publicKey, secretKey };
+}
+export function exportPublicKey(publicKey) {
+    if (!(publicKey instanceof Uint8Array) || publicKey.byteLength !== nacl.box.publicKeyLength) {
+        throw new Error(`Invalid public key length (expected ${nacl.box.publicKeyLength})`);
+    }
+    return encodeBase64(publicKey);
+}
+export function importPublicKey(base64) {
+    const bytes = decodePublicKeyBase64(base64);
+    if (bytes.byteLength !== nacl.box.publicKeyLength) {
+        throw new Error(`Invalid public key length (expected ${nacl.box.publicKeyLength})`);
+    }
+    return bytes;
+}
+export function exportSecretKey(secretKey) {
+    if (!(secretKey instanceof Uint8Array) || secretKey.byteLength !== nacl.box.secretKeyLength) {
+        throw new Error(`Invalid secret key length (expected ${nacl.box.secretKeyLength})`);
+    }
+    return encodeBase64(secretKey);
+}
+export function importSecretKey(base64) {
+    const bytes = decodeBase64(base64);
+    if (bytes.byteLength !== nacl.box.secretKeyLength) {
+        throw new Error(`Invalid secret key length (expected ${nacl.box.secretKeyLength})`);
+    }
+    return bytes;
+}
+export function deriveSharedKey(ourSecretKey, peerPublicKey) {
+    if (ourSecretKey.byteLength !== nacl.box.secretKeyLength) {
+        throw new Error(`Invalid secret key length (expected ${nacl.box.secretKeyLength})`);
+    }
+    if (peerPublicKey.byteLength !== nacl.box.publicKeyLength) {
+        throw new Error(`Invalid peer public key length (expected ${nacl.box.publicKeyLength})`);
+    }
+    const rawSharedResult = nacl.scalarMult(ourSecretKey, peerPublicKey);
+    const isAllZero = nacl.verify(rawSharedResult, ZERO_X25519_SHARED_RESULT);
+    rawSharedResult.fill(0);
+    if (isAllZero) {
+        throw new Error("Invalid peer public key");
+    }
+    return nacl.box.before(peerPublicKey, ourSecretKey);
+}
+/**
+ * Encrypts data and returns the binary bundle:
+ *   [nonce (24)] [ciphertext...]
+ */
+export function encrypt(sharedKey, data) {
+    ensurePrng();
+    const nonce = nacl.randomBytes(NONCE_LENGTH);
+    const plaintext = toUint8(data);
+    const ciphertext = nacl.box.after(plaintext, nonce, sharedKey);
+    const out = new Uint8Array(nonce.byteLength + ciphertext.byteLength);
+    out.set(nonce, 0);
+    out.set(ciphertext, nonce.byteLength);
+    return toArrayBuffer(out);
+}
+export function decrypt(sharedKey, data) {
+    const bytes = new Uint8Array(data);
+    if (bytes.byteLength < NONCE_LENGTH) {
+        throw new Error("Ciphertext bundle too short");
+    }
+    const nonce = bytes.slice(0, NONCE_LENGTH);
+    const ciphertext = bytes.slice(NONCE_LENGTH);
+    const opened = nacl.box.open.after(ciphertext, nonce, sharedKey);
+    if (!opened) {
+        throw new Error("Decryption failed");
+    }
+    return toArrayBuffer(opened);
+}
+//# sourceMappingURL=crypto.js.map

package/dist/cutover-proxy.d.ts

@@ -0,0 +1,6 @@
+interface CutoverProxy {
+    fetch(request: Request): Promise<Response>;
+}
+export declare function createCutoverProxy(origin: string): CutoverProxy;
+export {};
+//# sourceMappingURL=cutover-proxy.d.ts.map

package/dist/cutover-proxy.js

@@ -0,0 +1,12 @@
+export function createCutoverProxy(origin) {
+    const originUrl = new URL(origin);
+    return {
+        async fetch(request) {
+            const upstreamUrl = new URL(request.url);
+            upstreamUrl.protocol = originUrl.protocol;
+            upstreamUrl.host = originUrl.host;
+            return fetch(new Request(upstreamUrl, request));
+        },
+    };
+}
+//# sourceMappingURL=cutover-proxy.js.map

package/dist/e2ee.d.ts

@@ -0,0 +1,5 @@
+export { createClientChannel, createDaemonChannel, EncryptedChannel } from "./encrypted-channel.js";
+export type { Transport, TransportMessage, EncryptedChannelEvents } from "./encrypted-channel.js";
+export { generateKeyPair, exportPublicKey, importPublicKey, exportSecretKey, importSecretKey, } from "./crypto.js";
+export type { KeyPair, SharedKey } from "./crypto.js";
+//# sourceMappingURL=e2ee.d.ts.map

package/dist/e2ee.js

@@ -0,0 +1,3 @@
+export { createClientChannel, createDaemonChannel, EncryptedChannel } from "./encrypted-channel.js";
+export { generateKeyPair, exportPublicKey, importPublicKey, exportSecretKey, importSecretKey, } from "./crypto.js";
+//# sourceMappingURL=e2ee.js.map

package/dist/encrypted-channel.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Encrypted channel that wraps a WebSocket-like transport.
+ *
+ * Handles ECDH handshake and encrypts/decrypts all messages.
+ * Works identically for daemon and client sides.
+ */
+import { type KeyPair, type SharedKey } from "./crypto.js";
+export interface Transport {
+    send(data: string | ArrayBuffer): void | Promise<void>;
+    close(code?: number, reason?: string): void;
+    onmessage: ((message: TransportMessage) => void) | null;
+    onclose: ((code: number, reason: string) => void) | null;
+    onerror: ((error: Error) => void) | null;
+}
+export interface TransportMessage {
+    data: string | ArrayBuffer;
+    isBinary: boolean;
+}
+export interface EncryptedChannelEvents {
+    onopen?: () => void;
+    onmessage?: (data: string | ArrayBuffer) => void;
+    onclose?: (code: number, reason: string) => void;
+    onerror?: (error: Error) => void;
+}
+type ChannelState = "connecting" | "handshaking" | "open" | "closed";
+interface EncryptedChannelOptions {
+    /**
+     * If set, the channel can validate repeated plaintext `{type:"e2ee_hello"}`
+     * messages even after it is open.
+     *
+     * This is useful for robustness when the client retries the handshake
+     * (e.g., it didn't observe the daemon's `{type:"e2ee_ready"}` yet). In that case,
+     * the daemon should re-send `{type:"e2ee_ready"}` without changing keys.
+     */
+    daemonKeyPair?: KeyPair;
+    binaryCiphertext?: boolean;
+}
+export declare function base64EncryptedWireByteLength(plaintextBytes: number): number;
+export declare function maxBase64EncryptedPlaintextByteLength(wireBytes: number): number;
+/**
+ * Creates an encrypted channel as the initiator (client).
+ *
+ * The client:
+ * 1. Receives daemon's public key via QR code
+ * 2. Generates own keypair
+ * 3. Sends e2ee_hello with own public key
+ * 4. Derives shared key and starts encrypted communication
+ */
+export declare function createClientChannel(transport: Transport, daemonPublicKeyB64: string, events?: EncryptedChannelEvents): Promise<EncryptedChannel>;
+/**
+ * Creates an encrypted channel as the responder (daemon).
+ *
+ * The daemon:
+ * 1. Has pre-generated keypair (public key was in QR)
+ * 2. Waits for client's e2ee_hello with their public key
+ * 3. Derives shared key and starts encrypted communication
+ */
+export declare function createDaemonChannel(transport: Transport, daemonKeyPair: KeyPair, events?: EncryptedChannelEvents): Promise<EncryptedChannel>;
+/**
+ * Encrypted channel that wraps a transport with E2EE.
+ */
+export declare class EncryptedChannel {
+    private transport;
+    private sharedKey;
+    private state;
+    private events;
+    private options;
+    private pendingSends;
+    private onOpenCallbacks;
+    private onCloseCallbacks;
+    constructor(transport: Transport, sharedKey: SharedKey, events?: EncryptedChannelEvents, options?: EncryptedChannelOptions);
+    setState(state: ChannelState): void;
+    private handleMessage;
+    send(data: string | ArrayBuffer): Promise<void>;
+    outboundWireByteLength(data: string | ArrayBuffer): number;
+    private flushPendingSends;
+    private handleDaemonRehello;
+    private sendReadyForRetry;
+    private rejectKeyRotation;
+    close(code?: number, reason?: string): void;
+    isOpen(): boolean;
+    onTransitionToOpen(cb: () => void): void;
+    onClose(cb: () => void): void;
+}
+export {};
+//# sourceMappingURL=encrypted-channel.d.ts.map