@floegence/flowersec-core 0.22.1 → 0.24.0

package/dist/controlplane/issuer.js

@@ -2,13 +2,13 @@ import { ed25519 } from "@noble/curves/ed25519";
 import { base64urlEncode } from "../utils/base64url.js";
 import { signToken } from "./token.js";
 export class IssuerKeyset {
-    kid;
-    signingSeed;
+    active;
+    verificationKeys = new Map();
     constructor(kid, signingSeed) {
-        this.kid = normalizeKid(kid);
-        if (signingSeed.length !== 32)
-            throw new TypeError("Ed25519 signing seed must be 32 bytes");
-        this.signingSeed = signingSeed.slice();
+        const normalizedKID = normalizeKid(kid);
+        const retainedSeed = copySigningSeed(signingSeed);
+        this.active = { kid: normalizedKID, signingSeed: retainedSeed };
+        this.verificationKeys.set(normalizedKID, ed25519.getPublicKey(retainedSeed));
     }
     static random(kid) {
         const seed = crypto.getRandomValues(new Uint8Array(32));
@@ -20,30 +20,90 @@ export class IssuerKeyset {
         }
     }
     currentKID() {
-        return this.kid;
+        return this.requireActive().kid;
     }
     publicKeys() {
-        return new Map([[this.kid, ed25519.getPublicKey(this.signingSeed)]]);
+        this.requireActive();
+        return new Map([...this.verificationKeys.entries()]
+            .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+            .map(([kid, publicKey]) => [kid, publicKey.slice()]));
     }
     sign(payload) {
-        return signToken(this.signingSeed, { ...payload, kid: this.kid });
+        const active = this.requireActive();
+        return signToken(active.signingSeed, { ...payload, kid: active.kid });
+    }
+    addVerificationKey(kid, publicKey) {
+        this.requireActive();
+        const normalizedKID = normalizeKid(kid);
+        const retainedKey = copyPublicKey(publicKey);
+        const existing = this.verificationKeys.get(normalizedKID);
+        if (existing != null) {
+            if (!equalBytes(existing, retainedKey))
+                throw new Error(`key ID ${normalizedKID} is already bound to a different public key`);
+            return;
+        }
+        this.verificationKeys.set(normalizedKID, retainedKey);
     }
     rotate(kid, signingSeed) {
+        const active = this.requireActive();
         const nextKID = normalizeKid(kid);
-        if (signingSeed.length !== 32)
-            throw new TypeError("Ed25519 signing seed must be 32 bytes");
-        const nextSeed = signingSeed.slice();
-        this.signingSeed.fill(0);
-        this.kid = nextKID;
-        this.signingSeed = nextSeed;
+        const nextSeed = copySigningSeed(signingSeed);
+        const nextPublicKey = ed25519.getPublicKey(nextSeed);
+        const prepublishedKey = this.verificationKeys.get(nextKID);
+        if (prepublishedKey == null) {
+            nextSeed.fill(0);
+            throw new Error(`key ID ${nextKID} must be prepublished before rotation`);
+        }
+        if (!equalBytes(prepublishedKey, nextPublicKey)) {
+            nextSeed.fill(0);
+            throw new Error(`key ID ${nextKID} is bound to a different public key`);
+        }
+        this.active = { kid: nextKID, signingSeed: nextSeed };
+        active.signingSeed.fill(0);
+    }
+    retireVerificationKey(kid) {
+        const active = this.requireActive();
+        const normalizedKID = normalizeKid(kid);
+        if (normalizedKID === active.kid)
+            throw new Error("the active signing key cannot be retired");
+        if (!this.verificationKeys.delete(normalizedKID))
+            throw new Error(`key ID ${normalizedKID} is not published`);
     }
     exportTunnelKeyset() {
         const keys = [...this.publicKeys()].map(([kid, publicKey]) => ({ kid, pubkey_b64u: base64urlEncode(publicKey) }));
         return new TextEncoder().encode(JSON.stringify({ keys }, null, 2));
     }
     dispose() {
-        this.signingSeed.fill(0);
+        const active = this.active;
+        if (active == null)
+            return;
+        active.signingSeed.fill(0);
+        this.active = undefined;
+        this.verificationKeys.clear();
     }
+    requireActive() {
+        if (this.active == null)
+            throw new Error("issuer keyset is disposed");
+        return this.active;
+    }
+}
+function copySigningSeed(signingSeed) {
+    if (signingSeed.length !== 32)
+        throw new TypeError("Ed25519 signing seed must be 32 bytes");
+    return signingSeed.slice();
+}
+function copyPublicKey(publicKey) {
+    if (publicKey.length !== 32)
+        throw new TypeError("Ed25519 public key must be 32 bytes");
+    return publicKey.slice();
+}
+function equalBytes(left, right) {
+    if (left.length !== right.length)
+        return false;
+    let diff = 0;
+    for (let index = 0; index < left.length; index++)
+        diff |= left[index] ^ right[index];
+    return diff === 0;
 }
 function normalizeKid(kid) {
     const value = kid.trim();

package/dist/controlplane/request.js

@@ -77,7 +77,9 @@ async function readControlplaneText(response, maxBytes) {
             try {
                 await reader.cancel();
             }
-            catch { }
+            catch {
+                // The size violation is authoritative; cancellation is secondary cleanup.
+            }
             throw new ControlplaneResponseTooLargeError(maxBytes);
         }
         text += decoder.decode(chunk.value, { stream: true });

package/dist/defaults.d.ts

@@ -8,6 +8,7 @@ export declare const SDK_DEFAULTS: Readonly<{
         maxHandshakePayloadBytes: number;
         maxRecordBytes: number;
         outboundRecordChunkBytes: number;
+        maxInboundBufferedBytes: number;
         maxOutboundBufferedBytes: number;
     }>;
     yamux: Readonly<{
@@ -15,6 +16,7 @@ export declare const SDK_DEFAULTS: Readonly<{
         maxInboundStreams: 32;
         maxFrameBytes: number;
         preferredOutboundFrameBytes: number;
+        maxStreamWriteQueueBytes: number;
         maxStreamReceiveBytes: number;
         maxSessionReceiveBytes: number;
     }>;

package/dist/defaults.js

@@ -8,6 +8,7 @@ export const SDK_DEFAULTS = Object.freeze({
         maxHandshakePayloadBytes: 8 * 1024,
         maxRecordBytes: 1024 * 1024,
         outboundRecordChunkBytes: 64 * 1024,
+        maxInboundBufferedBytes: 4 * 1024 * 1024,
         maxOutboundBufferedBytes: 4 * 1024 * 1024,
     }),
     yamux: Object.freeze({
@@ -15,6 +16,7 @@ export const SDK_DEFAULTS = Object.freeze({
         maxInboundStreams: 32,
         maxFrameBytes: 256 * 1024,
         preferredOutboundFrameBytes: 64 * 1024,
+        maxStreamWriteQueueBytes: 4 * 1024 * 1024,
         maxStreamReceiveBytes: 256 * 1024,
         maxSessionReceiveBytes: 16 * 1024 * 1024,
     }),

package/dist/e2ee/handshake.d.ts

@@ -16,7 +16,7 @@ export type HandshakeClientOptions = Readonly<{
     maxRecordBytes: number;
     /** Preferred plaintext bytes per outbound record. */
     outboundRecordChunkBytes?: number;
-    /** Maximum buffered plaintext bytes for the secure channel. */
+    /** Maximum queued inbound plaintext bytes for the secure channel. */
     maxBufferedBytes?: number;
     /** Maximum queued outbound plaintext bytes for the secure channel. */
     maxOutboundBufferedBytes?: number;
@@ -44,7 +44,7 @@ export type HandshakeServerOptions = Readonly<{
     maxRecordBytes: number;
     /** Preferred plaintext bytes per outbound record. */
     outboundRecordChunkBytes?: number;
-    /** Maximum buffered plaintext bytes for the secure channel. */
+    /** Maximum queued inbound plaintext bytes for the secure channel. */
     maxBufferedBytes?: number;
     /** Maximum queued outbound plaintext bytes for the secure channel. */
     maxOutboundBufferedBytes?: number;

package/dist/e2ee/secureChannel.d.ts

@@ -31,7 +31,7 @@ export declare class SecureChannel {
     private readonly transport;
     private readonly maxRecordBytes;
     private readonly outboundRecordChunkBytes;
-    private readonly maxBufferedBytes;
+    private readonly maxInboundBufferedBytes;
     private readonly maxOutboundBufferedBytes;
     private sendKey;
     private recvKey;
@@ -50,7 +50,7 @@ export declare class SecureChannel {
     private sendQueueBytes;
     private sendClosed;
     private sendErr;
-    private readonly recvQueue;
+    private recvQueue;
     private recvQueueHead;
     private recvQueueBytes;
     private recvWaiters;

package/dist/e2ee/secureChannel.js

@@ -1,6 +1,7 @@
 import { RECORD_FLAG_APP, RECORD_FLAG_PING, RECORD_FLAG_REKEY } from "./constants.js";
 import { decryptRecord, encryptRecord, maxPlaintextBytes } from "./record.js";
 import { deriveRekeyKey } from "./kdf.js";
+import { SDK_DEFAULTS } from "../defaults.js";
 const maxRecordSeq = (1n << 64n) - 1n;
 class RecordSeqExhaustedError extends Error {
     constructor() {
@@ -15,8 +16,7 @@ export class SecureChannel {
     // Maximum allowed bytes per record frame.
     maxRecordBytes;
     outboundRecordChunkBytes;
-    // Upper bound for buffered plaintext in memory.
-    maxBufferedBytes;
+    maxInboundBufferedBytes;
     maxOutboundBufferedBytes;
     // Active encryption keys and nonce prefixes for the current epoch.
     sendKey;
@@ -52,16 +52,16 @@ export class SecureChannel {
         this.transport = args.transport;
         this.maxRecordBytes = args.maxRecordBytes;
         const maxPlain = Math.max(1, maxPlaintextBytes(this.maxRecordBytes));
-        this.outboundRecordChunkBytes = args.outboundRecordChunkBytes ?? Math.min(64 * 1024, maxPlain);
+        this.outboundRecordChunkBytes = args.outboundRecordChunkBytes ?? Math.min(SDK_DEFAULTS.e2ee.outboundRecordChunkBytes, maxPlain);
         if (!Number.isSafeInteger(this.outboundRecordChunkBytes) || this.outboundRecordChunkBytes <= 0 || this.outboundRecordChunkBytes > maxPlain) {
             throw new RangeError("outboundRecordChunkBytes must be a positive integer within the record plaintext limit");
         }
-        this.maxBufferedBytes = Math.max(0, args.maxBufferedBytes ?? 4 * (1 << 20));
-        const maxOutboundBufferedBytes = args.maxOutboundBufferedBytes ?? 4 * (1 << 20);
+        this.maxInboundBufferedBytes = Math.max(0, args.maxBufferedBytes ?? SDK_DEFAULTS.e2ee.maxInboundBufferedBytes);
+        const maxOutboundBufferedBytes = args.maxOutboundBufferedBytes ?? SDK_DEFAULTS.e2ee.maxOutboundBufferedBytes;
         if (!Number.isSafeInteger(maxOutboundBufferedBytes) || maxOutboundBufferedBytes < 0) {
             throw new RangeError("maxOutboundBufferedBytes must be a non-negative safe integer");
         }
-        this.maxOutboundBufferedBytes = maxOutboundBufferedBytes === 0 ? 4 * (1 << 20) : maxOutboundBufferedBytes;
+        this.maxOutboundBufferedBytes = maxOutboundBufferedBytes === 0 ? SDK_DEFAULTS.e2ee.maxOutboundBufferedBytes : maxOutboundBufferedBytes;
         this.sendKey = args.sendKey;
         this.recvKey = args.recvKey;
         this.sendNoncePrefix = args.sendNoncePrefix;
@@ -87,7 +87,11 @@ export class SecureChannel {
             if (this.recvQueueHead < this.recvQueue.length) {
                 const b = this.recvQueue[this.recvQueueHead];
                 this.recvQueueHead++;
-                if (this.recvQueueHead > 1024 && this.recvQueueHead * 2 > this.recvQueue.length) {
+                if (this.recvQueueHead === this.recvQueue.length) {
+                    this.recvQueue = [];
+                    this.recvQueueHead = 0;
+                }
+                else if (this.recvQueueHead > 1024 && this.recvQueueHead * 2 > this.recvQueue.length) {
                     this.recvQueue.splice(0, this.recvQueueHead);
                     this.recvQueueHead = 0;
                 }
@@ -171,7 +175,11 @@ export class SecureChannel {
             return null;
         const req = this.sendQueue[this.sendQueueHead];
         this.sendQueueHead++;
-        if (this.sendQueueHead > 1024 && this.sendQueueHead * 2 > this.sendQueue.length) {
+        if (this.sendQueueHead === this.sendQueue.length) {
+            this.sendQueue = [];
+            this.sendQueueHead = 0;
+        }
+        else if (this.sendQueueHead > 1024 && this.sendQueueHead * 2 > this.sendQueue.length) {
             this.sendQueue.splice(0, this.sendQueueHead);
             this.sendQueueHead = 0;
         }
@@ -182,7 +190,11 @@ export class SecureChannel {
             return undefined;
         const w = this.sendWaiters[this.sendWaitersHead];
         this.sendWaitersHead++;
-        if (this.sendWaitersHead > 1024 && this.sendWaitersHead * 2 > this.sendWaiters.length) {
+        if (this.sendWaitersHead === this.sendWaiters.length) {
+            this.sendWaiters = [];
+            this.sendWaitersHead = 0;
+        }
+        else if (this.sendWaitersHead > 1024 && this.sendWaitersHead * 2 > this.sendWaiters.length) {
             this.sendWaiters.splice(0, this.sendWaitersHead);
             this.sendWaitersHead = 0;
         }
@@ -284,7 +296,7 @@ export class SecureChannel {
                 }
                 this.recvSeq = seq + 1n;
                 if (flags === RECORD_FLAG_APP) {
-                    if (this.maxBufferedBytes > 0 && this.recvQueueBytes + plaintext.length > this.maxBufferedBytes) {
+                    if (this.maxInboundBufferedBytes > 0 && this.recvQueueBytes + plaintext.length > this.maxInboundBufferedBytes) {
                         throw new Error("recv buffer exceeded");
                     }
                     this.recvQueue.push(plaintext);

package/dist/endpoint/index.d.ts

@@ -70,6 +70,7 @@ export declare class Session {
         signal?: AbortSignal;
     }>): Promise<void>;
     probeLiveness(timeoutMs?: 10000): Promise<number>;
+    rekey(): Promise<void>;
     close(): void;
     private pushStream;
     private acceptRawStream;

package/dist/endpoint/index.js

@@ -8,6 +8,7 @@ import { decodeHandshakeFrame } from "../e2ee/framing.js";
 import { HANDSHAKE_TYPE_INIT, PROTOCOL_VERSION } from "../e2ee/constants.js";
 import { readStreamHello, writeStreamHello } from "../streamhello/streamHello.js";
 import { ByteReader } from "../yamux/byteReader.js";
+import { isYamuxPingTimeoutError } from "../yamux/errors.js";
 import { YamuxSession } from "../yamux/session.js";
 import { RpcServer } from "../rpc/server.js";
 import { base64urlDecode, base64urlEncode } from "../utils/base64url.js";
@@ -43,9 +44,10 @@ export class Session {
         return session;
     }
     async openStream(kind, options = {}) {
+        const streamKind = normalizeStreamKind(kind, this.path);
         const stream = await this.mux.openStream(options);
         try {
-            await writeStreamHello((bytes) => stream.write(bytes), normalizeStreamKind(kind, this.path));
+            await writeStreamHello((bytes) => stream.write(bytes), streamKind);
             return stream;
         }
         catch (error) {
@@ -82,8 +84,27 @@ export class Session {
             return;
         }
     }
-    probeLiveness(timeoutMs = SDK_DEFAULTS.transport.handshakeTimeoutMs) {
-        return this.mux.probeLiveness(timeoutMs);
+    async probeLiveness(timeoutMs = SDK_DEFAULTS.transport.handshakeTimeoutMs) {
+        try {
+            return await this.mux.probeLiveness(timeoutMs);
+        }
+        catch (error) {
+            throw new FlowersecError({
+                path: this.path,
+                stage: "yamux",
+                code: isYamuxPingTimeoutError(error) ? "timeout" : "ping_failed",
+                message: "endpoint liveness probe failed",
+                cause: error,
+            });
+        }
+    }
+    async rekey() {
+        try {
+            await this.secure.rekeyNow();
+        }
+        catch (error) {
+            throw new FlowersecError({ path: this.path, stage: "secure", code: "rekey_failed", message: "endpoint rekey failed", cause: error });
+        }
     }
     close() {
         this.fail(new Error("endpoint session closed"));
@@ -239,7 +260,7 @@ async function establishSession(path, transport, handshake, options, endpointIns
             maxHandshakePayload: options.maxHandshakePayload ?? SDK_DEFAULTS.e2ee.maxHandshakePayloadBytes,
             maxRecordBytes: options.maxRecordBytes ?? SDK_DEFAULTS.e2ee.maxRecordBytes,
             outboundRecordChunkBytes: options.outboundRecordChunkBytes ?? SDK_DEFAULTS.e2ee.outboundRecordChunkBytes,
-            maxBufferedBytes: options.maxBufferedBytes ?? SDK_DEFAULTS.e2ee.maxOutboundBufferedBytes,
+            maxBufferedBytes: options.maxBufferedBytes ?? SDK_DEFAULTS.e2ee.maxInboundBufferedBytes,
             maxOutboundBufferedBytes: options.maxOutboundBufferedBytes ?? SDK_DEFAULTS.e2ee.maxOutboundBufferedBytes,
             timeoutMs: options.handshakeTimeoutMs ?? SDK_DEFAULTS.transport.handshakeTimeoutMs,
             ...(options.signal === undefined ? {} : { signal: options.signal }),
@@ -319,7 +340,7 @@ function randomEndpointInstanceId() {
 function normalizeStreamKind(kind, path) {
     const value = kind.trim();
     if (value === "")
-        throw new FlowersecError({ path, stage: "validate", code: "missing_stream_kind", message: "missing stream kind" });
+        throw new FlowersecError({ path, stage: "rpc", code: "missing_stream_kind", message: "missing stream kind" });
     return value;
 }
 function unwrapServerGrant(input) {

package/dist/proxy/controllerWindow.js

@@ -78,11 +78,10 @@ function bridgeWebSocket(runtime, msg, port) {
         terminal = true;
         acceptingWrites = false;
         const err = error instanceof Error ? error : new Error(String(error));
-        try {
-            stream?.reset(err);
-        }
-        catch {
-            // Best-effort.
+        if (stream != null) {
+            void Promise.resolve(stream.reset(err)).catch(() => {
+                // The bridge error is already delivered through the terminal response.
+            });
         }
         try {
             ac.abort(err.message);

package/dist/proxy/runtime.js

@@ -416,13 +416,13 @@ export function createProxyRuntime(opts) {
                 }
                 if (!respMeta.ok) {
                     const msg = respMeta.error?.message ?? "upstream error";
-                    port.postMessage({ type: "flowersec-proxy:response_error", status: 502, message: msg });
-                    try {
-                        stream.reset(new Error(msg));
-                    }
-                    catch {
-                        // Best-effort.
-                    }
+                    port.postMessage({
+                        type: "flowersec-proxy:response_error",
+                        status: 502,
+                        ...(respMeta.error?.code === undefined ? {} : { code: respMeta.error.code }),
+                        message: msg,
+                    });
+                    await stream.reset(new Error(msg));
                     stream = null;
                     return;
                 }
@@ -455,14 +455,10 @@ export function createProxyRuntime(opts) {
                 port.postMessage({
                     type: "flowersec-proxy:response_error",
                     status,
+                    ...(code === undefined ? {} : { code }),
                     message: msg,
                 });
-                try {
-                    stream?.reset(new Error(msg));
-                }
-                catch {
-                    // Best-effort.
-                }
+                await stream?.reset(new Error(msg));
             }
             finally {
                 wakeResponseCreditWaiter();
@@ -494,12 +490,7 @@ export function createProxyRuntime(opts) {
         const resp = (await readJsonFrame(reader, maxJsonFrameBytes));
         if (resp.v !== PROXY_PROTOCOL_VERSION || resp.ok !== true) {
             const msg = resp.error?.message ?? "upstream ws open failed";
-            try {
-                stream.reset(new Error(msg));
-            }
-            catch {
-                // Best-effort.
-            }
+            await stream.reset(new Error(msg));
             throw new Error(msg);
         }
         return { stream, protocol: resp.protocol ?? "" };