termdock 1.4.173 → 1.4.175

package/dist/server/federation/openAccess.js

@@ -0,0 +1,25 @@
+import express from 'express';
+import { isAuthEnabled } from '../utils/authProtection.js';
+import { bootstrapCors } from './bootstrapCors.js';
+/** Open mode is per connection and transient; it must never create persisted grants. */
+export function openAccessAllowed(direct, authEnabled, action) {
+    return direct && !authEnabled && (!action || !action.startsWith('authorization.') && !action.startsWith('route.'));
+}
+export function createOpenAccessRouter(serviceIdentity) {
+    const router = express.Router();
+    router.use(bootstrapCors);
+    router.get('/parameters', (_req, res) => {
+        res.setHeader('Cache-Control', 'no-store');
+        if (isAuthEnabled()) {
+            res.status(403).json({ error: 'Password authentication required' });
+            return;
+        }
+        const identity = serviceIdentity();
+        if (!identity) {
+            res.status(503).json({ error: 'Encrypted access is starting' });
+            return;
+        }
+        res.json({ serviceIdentity: identity });
+    });
+    return router;
+}

package/dist/server/federation/originPolicy.js

@@ -0,0 +1,19 @@
+/** Noise endpoints never use cookies as authority. A browser may legitimately
+ * connect to a pinned target from another HTTPS service's PWA; possession of
+ * the paired device key is still required before any business operation.
+ * Legacy cookie-authenticated endpoints must not use this relaxed policy. */
+export function secureChannelOriginAllowed(origin, sameOriginAllowed) {
+    if (origin === undefined)
+        return true; // Native CLI/Mac relay.
+    try {
+        const parsed = new URL(origin);
+        if (parsed.origin !== origin)
+            return false;
+        if (parsed.protocol === 'https:')
+            return true;
+        return parsed.protocol === 'http:' && sameOriginAllowed();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/server/federation/packets.js

@@ -0,0 +1,116 @@
+/** Bounded queues are also used at the untrusted, pre-handshake boundary. */
+export class AsyncQueue {
+    limit;
+    items = [];
+    wake;
+    ended = false;
+    error;
+    constructor(limit = 64) {
+        this.limit = limit;
+    }
+    push(value) {
+        if (this.ended)
+            throw new Error('Channel closed');
+        if (this.items.length >= this.limit) {
+            this.end(new Error('Channel queue exceeded'));
+            throw this.error;
+        }
+        this.items.push(value);
+        this.wake?.();
+    }
+    end(error) { this.ended = true; this.error ??= error; this.wake?.(); }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            if (this.error)
+                throw this.error;
+            const item = this.items.shift();
+            if (item !== undefined) {
+                yield item;
+                continue;
+            }
+            if (this.ended)
+                return;
+            await new Promise(resolve => { this.wake = resolve; });
+            this.wake = undefined;
+        }
+    }
+}
+const MAX_PACKET = 2 * 1024 * 1024;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder('utf-8', { fatal: true });
+/** Application records live entirely inside Noise; transport routing never sees them. */
+export class PacketChannel {
+    duplex;
+    outgoing = new AsyncQueue(256);
+    outgoingBytes = 0;
+    done;
+    constructor(duplex) {
+        this.duplex = duplex;
+        const self = this;
+        this.done = duplex.sink((async function* () {
+            for await (const bytes of self.outgoing) {
+                try {
+                    yield bytes;
+                }
+                finally {
+                    self.outgoingBytes -= bytes.byteLength;
+                }
+            }
+        })());
+        void this.done.catch(error => this.close(error instanceof Error ? error : new Error('Transport failed')));
+    }
+    send(packet) {
+        const body = encoder.encode(JSON.stringify(packet));
+        if (body.length > MAX_PACKET)
+            throw new Error('Record too large');
+        const bytes = new Uint8Array(body.length + 4);
+        new DataView(bytes.buffer).setUint32(0, body.length);
+        bytes.set(body, 4);
+        if (this.outgoingBytes + bytes.byteLength > 4 * 1024 * 1024)
+            throw new Error('Record queue byte budget exceeded');
+        this.outgoingBytes += bytes.byteLength;
+        try {
+            this.outgoing.push(bytes);
+        }
+        catch (error) {
+            this.outgoingBytes -= bytes.byteLength;
+            throw error;
+        }
+    }
+    close(error) { this.outgoing.end(error); this.duplex.close?.(error); }
+    async *read() {
+        let pending = new Uint8Array(0);
+        for await (const chunk of this.duplex.source) {
+            if (pending.length + chunk.length > MAX_PACKET * 2 + 8)
+                throw new Error('Record buffer exceeded');
+            const next = new Uint8Array(pending.length + chunk.length);
+            next.set(pending);
+            next.set(chunk, pending.length);
+            pending = next;
+            while (pending.length >= 4) {
+                const size = new DataView(pending.buffer, pending.byteOffset, 4).getUint32(0);
+                if (size > MAX_PACKET || size === 0)
+                    throw new Error('Invalid record size');
+                if (pending.length < size + 4)
+                    break;
+                const packet = JSON.parse(decoder.decode(pending.subarray(4, size + 4)));
+                if (!packet || typeof packet !== 'object' || typeof packet.id !== 'string' || typeof packet.type !== 'string')
+                    throw new Error('Invalid record');
+                yield packet;
+                pending = pending.slice(size + 4);
+            }
+        }
+        if (pending.length)
+            throw new Error('Truncated record');
+    }
+}
+export function toBase64(bytes) {
+    let value = '';
+    for (let offset = 0; offset < bytes.length; offset += 8192)
+        value += String.fromCharCode(...bytes.subarray(offset, offset + 8192));
+    return btoa(value);
+}
+export function fromBase64(value) {
+    const raw = atob(value);
+    return Uint8Array.from(raw, c => c.charCodeAt(0));
+}

package/dist/server/federation/passwordBootstrap.js

@@ -0,0 +1,86 @@
+import * as opaque from '@serenity-kit/opaque';
+import { scryptAsync } from '@noble/hashes/scrypt.js';
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';
+// Existing credentials are password-equivalent here. Never send the stored hash
+// over the wire. OPAQUE authenticates both Noise identities before any grant.
+const keyStretching = 'memory-constrained';
+const userIdentifier = 'termdock-password-bootstrap-v1';
+const TTL = 60_000;
+function identifiers(clientIdentity, serverIdentity, origin) {
+    if (!clientIdentity || clientIdentity.length > 256 || !serverIdentity || serverIdentity.length > 256 ||
+        origin.length > 2048 || new URL(origin).origin !== origin)
+        throw new Error('Invalid bootstrap identity');
+    return { client: JSON.stringify([userIdentifier, origin, clientIdentity]), server: serverIdentity };
+}
+function bounded(value) {
+    if (typeof value !== 'string' || value.length < 1 || value.length > 8192)
+        throw new Error('Invalid OPAQUE message');
+}
+export async function startPasswordBootstrap(password, saltHex) {
+    if (!/^[0-9a-f]{32}$/.test(saltHex) || !password || password.length > 1024 || new TextEncoder().encode(password).length > 4096)
+        throw new Error('Invalid password parameters');
+    await opaque.ready;
+    const passwordKey = bytesToHex(await scryptAsync(password, hexToBytes(saltHex), { N: 32768, r: 8, p: 1, dkLen: 64, maxmem: 67108864 }));
+    return { ...opaque.client.startLogin({ password: passwordKey }), passwordKey };
+}
+export async function finishPasswordBootstrap(state, response, binding) {
+    await opaque.ready;
+    bounded(response.loginResponse);
+    const result = opaque.client.finishLogin({ clientLoginState: state.clientLoginState, password: state.passwordKey,
+        loginResponse: response.loginResponse, keyStretching,
+        identifiers: identifiers(binding.clientIdentity, response.serverIdentity, binding.origin) });
+    if (!result)
+        throw new Error('Password authentication failed');
+    return { attemptId: response.attemptId, finishLoginRequest: result.finishLoginRequest, serverIdentity: response.serverIdentity };
+}
+export class PasswordBootstrapServer {
+    options;
+    setup;
+    pending = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    now() { return this.options.now?.() ?? Date.now(); }
+    credential() {
+        const hash = this.options.getPasswordHash();
+        if (!hash || !/^scrypt\$[0-9a-f]{32}\$[0-9a-f]{128}$/.test(hash))
+            throw new Error('Password authentication unavailable');
+        return hash;
+    }
+    parameters() { return { saltHex: this.credential().split('$')[1] }; }
+    async start(input) {
+        bounded(input.startLoginRequest);
+        const ids = identifiers(input.clientIdentity, this.options.serverIdentity, input.origin);
+        for (const [id, entry] of this.pending)
+            if (entry.expiresAt <= this.now())
+                this.pending.delete(id);
+        if (this.pending.size >= 32)
+            throw new Error('Too many password login attempts');
+        const credential = this.credential();
+        await opaque.ready;
+        if (this.pending.size >= 32)
+            throw new Error('Too many password login attempts');
+        this.setup ??= opaque.server.createSetup();
+        const password = credential.split('$')[2];
+        // Registration is local migration from the existing scrypt credential; no
+        // unauthenticated network registration endpoint or password reset is needed.
+        const registration = opaque.client.startRegistration({ password });
+        const { registrationResponse } = opaque.server.createRegistrationResponse({ ...registration, serverSetup: this.setup, userIdentifier });
+        const { registrationRecord } = opaque.client.finishRegistration({ ...registration, registrationResponse, password, identifiers: ids, keyStretching });
+        const result = opaque.server.startLogin({ serverSetup: this.setup, registrationRecord, userIdentifier,
+            startLoginRequest: input.startLoginRequest, identifiers: ids });
+        const attemptId = globalThis.crypto.randomUUID();
+        this.pending.set(attemptId, { serverLoginState: result.serverLoginState, clientIdentity: input.clientIdentity, credential, expiresAt: this.now() + TTL });
+        return { attemptId, loginResponse: result.loginResponse, serverIdentity: this.options.serverIdentity };
+    }
+    async finish(input) {
+        bounded(input.finishLoginRequest);
+        const entry = this.pending.get(input.attemptId);
+        this.pending.delete(input.attemptId);
+        if (!entry || entry.expiresAt <= this.now() || entry.credential !== this.credential())
+            throw new Error('Password login expired');
+        await opaque.ready;
+        opaque.server.finishLogin({ serverLoginState: entry.serverLoginState, finishLoginRequest: input.finishLoginRequest });
+        return { clientIdentity: entry.clientIdentity, serverIdentity: this.options.serverIdentity };
+    }
+}

package/dist/server/federation/passwordLoginRoutes.js

@@ -0,0 +1,98 @@
+import express from 'express';
+import { PasswordBootstrapServer } from './passwordBootstrap.js';
+import { getLoginBlockMs, getPasswordVerifier, recordLoginFailure, recordLoginSuccess } from '../utils/authProtection.js';
+import { getPublicOrigin } from '../utils/publicSecurity.js';
+import { bootstrapCors } from './bootstrapCors.js';
+export function createPasswordLoginRouter(getRuntime) {
+    const router = express.Router();
+    let bootstrap;
+    let runtime;
+    let computing = 0;
+    const starts = [];
+    const pending = new Map();
+    router.use(bootstrapCors);
+    router.use((_req, res, next) => {
+        const ready = getRuntime();
+        if (!ready) {
+            res.status(503).json({ error: 'Encrypted login is starting' });
+            return;
+        }
+        if (ready !== runtime) {
+            runtime = ready;
+            bootstrap = new PasswordBootstrapServer({ getPasswordHash: getPasswordVerifier, serverIdentity: ready.serviceId });
+            pending.clear();
+        }
+        res.setHeader('Cache-Control', 'no-store');
+        next();
+    });
+    router.get('/parameters', (_req, res) => {
+        try {
+            res.json(bootstrap.parameters());
+        }
+        catch {
+            res.status(503).json({ error: 'Password login unavailable' });
+        }
+    });
+    router.use(express.json({ limit: '8kb' }));
+    router.post('/start', async (req, res) => {
+        const ip = req.socket.remoteAddress ?? 'unknown';
+        const now = Date.now();
+        while (starts.length && starts[0] <= now - 60_000)
+            starts.shift();
+        for (const [id, entry] of pending)
+            if (entry.expiresAt <= now)
+                pending.delete(id);
+        if (getLoginBlockMs(ip) > 0 || starts.length >= 30 || computing >= 2) {
+            res.status(429).json({ error: 'Too many login attempts' });
+            return;
+        }
+        if (typeof req.body?.clientIdentity !== 'string' || typeof req.body?.startLoginRequest !== 'string' ||
+            Object.keys(req.body).some(key => !['clientIdentity', 'startLoginRequest'].includes(key))) {
+            res.status(400).json({ error: 'Invalid login request' });
+            return;
+        }
+        const origin = req.headers.origin ?? getPublicOrigin() ?? `${req.protocol}://${req.headers.host}`;
+        starts.push(now);
+        computing++;
+        recordLoginFailure(ip);
+        try {
+            const result = await bootstrap.start({ ...req.body, origin });
+            pending.set(result.attemptId, { ip, origin, expiresAt: Date.now() + 60_000 });
+            res.json(result);
+        }
+        catch {
+            res.status(401).json({ error: 'Password authentication failed' });
+        }
+        finally {
+            computing--;
+        }
+    });
+    router.post('/finish', async (req, res) => {
+        const ip = req.socket.remoteAddress ?? 'unknown';
+        const origin = req.headers.origin ?? getPublicOrigin() ?? `${req.protocol}://${req.headers.host}`;
+        if (typeof req.body?.attemptId !== 'string' || typeof req.body?.finishLoginRequest !== 'string' ||
+            Object.keys(req.body).some(key => !['attemptId', 'finishLoginRequest'].includes(key))) {
+            res.status(400).json({ error: 'Invalid login request' });
+            return;
+        }
+        const entry = pending.get(req.body.attemptId);
+        if (!entry || entry.ip !== ip || entry.origin !== origin || entry.expiresAt <= Date.now()) {
+            res.status(401).json({ error: 'Password authentication failed' });
+            return;
+        }
+        pending.delete(req.body.attemptId);
+        try {
+            const credential = getPasswordVerifier();
+            const result = await bootstrap.finish(req.body);
+            if (!credential || credential !== getPasswordVerifier())
+                throw new Error('Password changed');
+            runtime.store.grantPassword(result.clientIdentity);
+            recordLoginSuccess(ip);
+            res.json({ ok: true });
+        }
+        catch {
+            res.status(401).json({ error: 'Password authentication failed' });
+        }
+    });
+    return router;
+}