@floegence/flowersec-core 3.2.1 → 5.0.0

package/dist/v2/streamLifetimeLedger.d.ts

@@ -1,31 +0,0 @@
-export declare const MAX_STREAM_LIFETIME_SLOTS_V2 = 1048576;
-export declare function maxLogicalStreamIDV2(openerRole: 1 | 2): bigint;
-export declare enum StreamLifetimeStateV2 {
-    Empty = 0,
-    AbandonedNoFSS2 = 1,
-    PrefaceSeen = 2,
-    ActiveOrResolved = 3
-}
-export type LateFSS2ActionV2 = "accepted" | "reset";
-export declare class StreamLifetimeLedgerV2Error extends Error {
-    readonly code: "capacity" | "duplicate" | "invalid_state";
-    constructor(code: "capacity" | "duplicate" | "invalid_state", message: string);
-}
-export declare class StreamLifetimeLedgerV2 {
-    private readonly openerRole;
-    private readonly states;
-    private resolvedFrontier;
-    constructor(openerRole: 1 | 2);
-    get frontier(): bigint;
-    get backingBytes(): number;
-    state(id: bigint): StreamLifetimeStateV2;
-    validFSS2(id: bigint): LateFSS2ActionV2;
-    validOpen(id: bigint): void;
-    peerReset(id: bigint): void;
-    localResetCommitted(id: bigint): void;
-    private requireSlot;
-    private slotIndex;
-    private stateAt;
-    private setStateAt;
-    private advanceFrontier;
-}

package/dist/v2/streamLifetimeLedger.js

@@ -1,131 +0,0 @@
-export const MAX_STREAM_LIFETIME_SLOTS_V2 = 1_048_576;
-export function maxLogicalStreamIDV2(openerRole) {
-    return BigInt(MAX_STREAM_LIFETIME_SLOTS_V2) * 2n - (openerRole === 1 ? 1n : 0n);
-}
-export var StreamLifetimeStateV2;
-(function (StreamLifetimeStateV2) {
-    StreamLifetimeStateV2[StreamLifetimeStateV2["Empty"] = 0] = "Empty";
-    StreamLifetimeStateV2[StreamLifetimeStateV2["AbandonedNoFSS2"] = 1] = "AbandonedNoFSS2";
-    StreamLifetimeStateV2[StreamLifetimeStateV2["PrefaceSeen"] = 2] = "PrefaceSeen";
-    StreamLifetimeStateV2[StreamLifetimeStateV2["ActiveOrResolved"] = 3] = "ActiveOrResolved";
-})(StreamLifetimeStateV2 || (StreamLifetimeStateV2 = {}));
-export class StreamLifetimeLedgerV2Error extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-        this.name = "StreamLifetimeLedgerV2Error";
-    }
-}
-export class StreamLifetimeLedgerV2 {
-    openerRole;
-    states = new Uint8Array(MAX_STREAM_LIFETIME_SLOTS_V2 / 4);
-    resolvedFrontier = 0n;
-    constructor(openerRole) {
-        this.openerRole = openerRole;
-    }
-    get frontier() {
-        return this.resolvedFrontier;
-    }
-    get backingBytes() {
-        return this.states.byteLength;
-    }
-    state(id) {
-        const index = this.slotIndex(id, false);
-        return index === undefined ? StreamLifetimeStateV2.Empty : this.stateAt(index);
-    }
-    validFSS2(id) {
-        const index = this.requireSlot(id);
-        switch (this.stateAt(index)) {
-            case StreamLifetimeStateV2.Empty:
-                this.setStateAt(index, StreamLifetimeStateV2.PrefaceSeen);
-                return "accepted";
-            case StreamLifetimeStateV2.AbandonedNoFSS2:
-                this.setStateAt(index, StreamLifetimeStateV2.ActiveOrResolved);
-                this.advanceFrontier();
-                return "reset";
-            case StreamLifetimeStateV2.PrefaceSeen:
-            case StreamLifetimeStateV2.ActiveOrResolved:
-                throw new StreamLifetimeLedgerV2Error("duplicate", "duplicate logical stream identity");
-        }
-    }
-    validOpen(id) {
-        const index = this.requireSlot(id);
-        if (this.stateAt(index) !== StreamLifetimeStateV2.PrefaceSeen) {
-            throw new StreamLifetimeLedgerV2Error("invalid_state", "OPEN without a pending FSS2 identity");
-        }
-        this.setStateAt(index, StreamLifetimeStateV2.ActiveOrResolved);
-        this.advanceFrontier();
-    }
-    peerReset(id) {
-        const index = this.requireSlot(id);
-        switch (this.stateAt(index)) {
-            case StreamLifetimeStateV2.Empty:
-                this.setStateAt(index, StreamLifetimeStateV2.AbandonedNoFSS2);
-                break;
-            case StreamLifetimeStateV2.PrefaceSeen:
-                this.setStateAt(index, StreamLifetimeStateV2.ActiveOrResolved);
-                break;
-            case StreamLifetimeStateV2.AbandonedNoFSS2:
-            case StreamLifetimeStateV2.ActiveOrResolved:
-                break;
-        }
-        this.advanceFrontier();
-    }
-    localResetCommitted(id) {
-        const index = this.requireSlot(id);
-        const state = this.stateAt(index);
-        if (state === StreamLifetimeStateV2.ActiveOrResolved)
-            return;
-        if (state !== StreamLifetimeStateV2.PrefaceSeen) {
-            throw new StreamLifetimeLedgerV2Error("invalid_state", "ordered reset without a pending FSS2 identity");
-        }
-        this.setStateAt(index, StreamLifetimeStateV2.ActiveOrResolved);
-        this.advanceFrontier();
-    }
-    requireSlot(id) {
-        const index = this.slotIndex(id, true);
-        if (index === undefined) {
-            throw new StreamLifetimeLedgerV2Error("capacity", "logical stream lifetime ledger capacity exceeded");
-        }
-        return index;
-    }
-    slotIndex(id, validate) {
-        const validParity = id > 0n && (this.openerRole === 1 ? (id & 1n) === 1n : (id & 1n) === 0n);
-        if (!validParity) {
-            if (validate)
-                throw new StreamLifetimeLedgerV2Error("capacity", "logical stream identity is outside the opener role");
-            return undefined;
-        }
-        const ordinal = this.openerRole === 1 ? (id + 1n) / 2n : id / 2n;
-        if (ordinal < 1n || ordinal > BigInt(MAX_STREAM_LIFETIME_SLOTS_V2))
-            return undefined;
-        return Number(ordinal - 1n);
-    }
-    stateAt(index) {
-        const shift = (index % 4) * 2;
-        return ((this.states[Math.floor(index / 4)] >>> shift) & 0x03);
-    }
-    setStateAt(index, state) {
-        const byteIndex = Math.floor(index / 4);
-        const shift = (index % 4) * 2;
-        const mask = 0x03 << shift;
-        this.states[byteIndex] = (this.states[byteIndex] & ~mask) | (state << shift);
-    }
-    advanceFrontier() {
-        let next = this.resolvedFrontier === 0n
-            ? (this.openerRole === 1 ? 1n : 2n)
-            : this.resolvedFrontier + 2n;
-        while (true) {
-            const index = this.slotIndex(next, false);
-            if (index === undefined)
-                return;
-            const state = this.stateAt(index);
-            if (state !== StreamLifetimeStateV2.AbandonedNoFSS2 && state !== StreamLifetimeStateV2.ActiveOrResolved) {
-                return;
-            }
-            this.resolvedFrontier = next;
-            next += 2n;
-        }
-    }
-}

package/dist/v2/streamMetadata.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/v2/streamMetadata.js

@@ -1,7 +0,0 @@
-import { createStreamMetadata, streamMetadataValues, } from "../public/streamMetadata.js";
-/** @internal */
-export { createStreamMetadata, StreamMetadataError } from "../public/streamMetadata.js";
-/** @internal */
-export const createStreamMetadataV2 = createStreamMetadata;
-/** @internal */
-export const streamMetadataValuesV2 = streamMetadataValues;

package/dist/v2/unreliableMessage.d.ts

@@ -1,43 +0,0 @@
-import type { CarrierUnreliableDatagramsV2 } from "./carrier.js";
-import { CipherSuiteV2 } from "./protocol.js";
-import type { DirectionV2 } from "./protocol.js";
-export declare const UNRELIABLE_MESSAGES_FEATURE_V2 = 1;
-export declare const UNRELIABLE_MESSAGE_MAX_PLAINTEXT_BYTES_V2: 976;
-export declare const UNRELIABLE_MESSAGE_WIRE_BYTES_V2: 1024;
-export type InternalUnreliableMessageChannelV2Options = Readonly<{
-    transport: CarrierUnreliableDatagramsV2;
-    suite: CipherSuiteV2;
-    h3: Uint8Array;
-    sendDirection: DirectionV2;
-    receiveDirection: DirectionV2;
-    currentSendEpoch(): Readonly<{
-        epoch: number;
-        epochSecret: Uint8Array;
-    }>;
-    receiveEpochSecret(epoch: number): Uint8Array | undefined;
-    now?: () => number;
-}>;
-export type UnreliableMessageMaterialV2 = Readonly<{
-    unreliableRoot: Uint8Array;
-    materialSecret: Uint8Array;
-    recordKey: Uint8Array;
-    noncePrefix: Uint8Array;
-}>;
-export type SealUnreliableMessageDatagramV2Options = Readonly<{
-    suite: CipherSuiteV2;
-    epochSecret: Uint8Array;
-    h3: Uint8Array;
-    direction: DirectionV2;
-    epoch: number;
-    sequence: bigint;
-    expiresAtUnixMs: bigint;
-    plaintext: Uint8Array;
-}>;
-export type SealedUnreliableMessageDatagramV2 = Readonly<{
-    material: UnreliableMessageMaterialV2;
-    nonce: Uint8Array;
-    header: Uint8Array;
-    aad: Uint8Array;
-    ciphertext: Uint8Array;
-    wire: Uint8Array;
-}>;

package/dist/v2/unreliableMessage.js

@@ -1,254 +0,0 @@
-import { gcm } from "@noble/ciphers/aes.js";
-import { chacha20poly1305 } from "@noble/ciphers/chacha.js";
-import { expand } from "@noble/hashes/hkdf.js";
-import { sha256 } from "@noble/hashes/sha2.js";
-import { CipherSuiteV2 } from "./protocol.js";
-import { UnreliableMessageError } from "../public/contract.js";
-export const UNRELIABLE_MESSAGES_FEATURE_V2 = 0x00000001;
-export const UNRELIABLE_MESSAGE_MAX_PLAINTEXT_BYTES_V2 = 976;
-export const UNRELIABLE_MESSAGE_WIRE_BYTES_V2 = 1_024;
-const HEADER_BYTES = 32;
-const TAG_BYTES = 16;
-const MAX_PENDING_SENDS = 64;
-const MAX_UINT64 = (1n << 64n) - 1n;
-const encoder = new TextEncoder();
-/** @internal */ export { UnreliableMessageError } from "../public/contract.js";
-/** @internal */
-export function createInternalUnreliableMessageChannelV2(options) {
-    return new InternalUnreliableMessageChannelV2(options);
-}
-class InternalUnreliableMessageChannelV2 {
-    options;
-    maxMessageSize = UNRELIABLE_MESSAGE_MAX_PLAINTEXT_BYTES_V2;
-    replay = new Map();
-    now;
-    nextSequence = 0n;
-    sendEpoch = -1;
-    pendingSends = 0;
-    constructor(options) {
-        this.options = options;
-        if (options.transport.maxDatagramSize < UNRELIABLE_MESSAGE_WIRE_BYTES_V2 || options.h3.byteLength !== 32) {
-            throw new UnreliableMessageError("operation_failed");
-        }
-        this.now = options.now ?? Date.now;
-    }
-    async send(message, options) {
-        throwIfAborted(options.signal);
-        if (!(message instanceof Uint8Array) || message.byteLength < 1) {
-            throw new UnreliableMessageError("invalid_message");
-        }
-        if (message.byteLength > UNRELIABLE_MESSAGE_MAX_PLAINTEXT_BYTES_V2) {
-            throw new UnreliableMessageError("too_large");
-        }
-        const payload = message.slice();
-        const expiresAt = requireFutureExpiry(options.expiresAtUnixMs, this.now());
-        if (expiresAt === undefined)
-            return "dropped_expired";
-        if (this.pendingSends >= MAX_PENDING_SENDS)
-            return "dropped_budget";
-        const roots = this.options.currentSendEpoch();
-        if (roots.epoch !== this.sendEpoch) {
-            this.sendEpoch = roots.epoch;
-            this.nextSequence = 0n;
-        }
-        if (this.nextSequence > MAX_UINT64)
-            throw new UnreliableMessageError("closed");
-        const sequence = this.nextSequence++;
-        const sealed = sealUnreliableMessageDatagramV2({
-            suite: this.options.suite,
-            epochSecret: roots.epochSecret,
-            h3: this.options.h3,
-            direction: this.options.sendDirection,
-            epoch: roots.epoch,
-            sequence,
-            expiresAtUnixMs: BigInt(expiresAt),
-            plaintext: payload,
-        });
-        this.pendingSends++;
-        try {
-            return await this.options.transport.send(sealed.wire, {
-                ...(options.signal === undefined ? {} : { signal: options.signal }),
-                expiresAt,
-            });
-        }
-        catch (error) {
-            if (isAbortError(error))
-                throw new UnreliableMessageError("canceled");
-            throw new UnreliableMessageError("operation_failed");
-        }
-        finally {
-            this.pendingSends--;
-        }
-    }
-    async receive(options = {}) {
-        for (;;) {
-            throwIfAborted(options.signal);
-            let wire;
-            try {
-                wire = await this.options.transport.receive(options);
-            }
-            catch (error) {
-                if (isAbortError(error))
-                    throw new UnreliableMessageError("canceled");
-                throw new UnreliableMessageError("closed");
-            }
-            const decoded = decodeHeader(wire);
-            if (decoded === undefined || decoded.expiresAtUnixMs <= BigInt(Math.floor(this.now())))
-                continue;
-            const epochSecret = this.options.receiveEpochSecret(decoded.epoch);
-            if (epochSecret === undefined)
-                continue;
-            const window = this.replay.get(decoded.epoch) ?? new ReplayWindow();
-            if (window.seen(decoded.sequence))
-                continue;
-            const material = deriveUnreliableMessageMaterialV2(epochSecret, this.options.h3, this.options.receiveDirection, decoded.epoch);
-            const nonce = concat(material.noncePrefix, u64be(decoded.sequence));
-            const aad = labelWith("flowersec-v2-unreliable", this.options.h3, byte(this.options.receiveDirection), wire.subarray(0, HEADER_BYTES));
-            let plaintext;
-            try {
-                plaintext = cipher(this.options.suite, material.recordKey, nonce, aad).decrypt(wire.subarray(HEADER_BYTES));
-            }
-            catch {
-                continue;
-            }
-            if (plaintext.byteLength < 1 || plaintext.byteLength > UNRELIABLE_MESSAGE_MAX_PLAINTEXT_BYTES_V2)
-                continue;
-            window.mark(decoded.sequence);
-            this.replay.set(decoded.epoch, window);
-            pruneReplayEpochs(this.replay, decoded.epoch);
-            return plaintext.slice();
-        }
-    }
-}
-/** @internal */
-export function encodeUnreliableMessageHeaderV2(epoch, sequence, expiresAtUnixMs, ciphertextLength) {
-    const header = new Uint8Array(HEADER_BYTES);
-    header.set(encoder.encode("FSD2"));
-    header[4] = 2;
-    header[5] = 0;
-    const view = new DataView(header.buffer);
-    view.setUint16(6, HEADER_BYTES, false);
-    view.setUint32(8, epoch, false);
-    view.setBigUint64(12, sequence, false);
-    view.setBigUint64(20, expiresAtUnixMs, false);
-    view.setUint32(28, ciphertextLength, false);
-    return header;
-}
-function decodeHeader(wire) {
-    if (!(wire instanceof Uint8Array) || wire.byteLength < HEADER_BYTES + TAG_BYTES ||
-        wire.byteLength > UNRELIABLE_MESSAGE_WIRE_BYTES_V2 ||
-        wire[0] !== 0x46 || wire[1] !== 0x53 || wire[2] !== 0x44 || wire[3] !== 0x32 ||
-        wire[4] !== 2 || wire[5] !== 0)
-        return undefined;
-    const view = new DataView(wire.buffer, wire.byteOffset, HEADER_BYTES);
-    if (view.getUint16(6, false) !== HEADER_BYTES || view.getUint32(28, false) !== wire.byteLength - HEADER_BYTES) {
-        return undefined;
-    }
-    return {
-        epoch: view.getUint32(8, false),
-        sequence: view.getBigUint64(12, false),
-        expiresAtUnixMs: view.getBigUint64(20, false),
-    };
-}
-/** @internal */
-export function deriveUnreliableMessageMaterialV2(epochSecret, h3, direction, epoch) {
-    const unreliableRoot = expand(sha256, epochSecret, labelWith("flowersec v2 unreliable root"), 32);
-    const materialSecret = expand(sha256, unreliableRoot, labelWith("flowersec v2 unreliable", h3, byte(direction), u32be(epoch)), 32);
-    return {
-        unreliableRoot,
-        materialSecret,
-        recordKey: expand(sha256, materialSecret, labelWith("flowersec v2 unreliable key"), 32),
-        noncePrefix: expand(sha256, materialSecret, labelWith("flowersec v2 unreliable nonce"), 4),
-    };
-}
-/** @internal */
-export function sealUnreliableMessageDatagramV2(options) {
-    const header = encodeUnreliableMessageHeaderV2(options.epoch, options.sequence, options.expiresAtUnixMs, options.plaintext.byteLength + TAG_BYTES);
-    const material = deriveUnreliableMessageMaterialV2(options.epochSecret, options.h3, options.direction, options.epoch);
-    const nonce = concat(material.noncePrefix, u64be(options.sequence));
-    const aad = labelWith("flowersec-v2-unreliable", options.h3, byte(options.direction), header);
-    const ciphertext = cipher(options.suite, material.recordKey, nonce, aad).encrypt(options.plaintext);
-    return {
-        material,
-        nonce,
-        header,
-        aad,
-        ciphertext,
-        wire: concat(header, ciphertext),
-    };
-}
-function cipher(suite, key, nonce, aad) {
-    if (suite === CipherSuiteV2.ChaCha20Poly1305)
-        return chacha20poly1305(key, nonce, aad);
-    if (suite === CipherSuiteV2.AES256GCM)
-        return gcm(key, nonce, aad);
-    throw new UnreliableMessageError("operation_failed");
-}
-class ReplayWindow {
-    highest = -1n;
-    bitmap = 0n;
-    seen(sequence) {
-        if (this.highest < 0n || sequence > this.highest)
-            return false;
-        const distance = this.highest - sequence;
-        return distance >= 64n || (this.bitmap & (1n << distance)) !== 0n;
-    }
-    mark(sequence) {
-        if (this.highest < 0n) {
-            this.highest = sequence;
-            this.bitmap = 1n;
-            return;
-        }
-        if (sequence > this.highest) {
-            const shift = sequence - this.highest;
-            this.bitmap = shift >= 64n ? 1n : ((this.bitmap << shift) | 1n) & ((1n << 64n) - 1n);
-            this.highest = sequence;
-            return;
-        }
-        this.bitmap |= 1n << (this.highest - sequence);
-    }
-}
-function pruneReplayEpochs(windows, current) {
-    for (const epoch of windows.keys()) {
-        if (epoch + 1 < current || epoch > current + 1)
-            windows.delete(epoch);
-    }
-}
-function requireFutureExpiry(value, now) {
-    if (!Number.isSafeInteger(value) || value < 0)
-        throw new UnreliableMessageError("invalid_message");
-    return value <= now ? undefined : value;
-}
-function throwIfAborted(signal) {
-    if (signal?.aborted === true)
-        throw new UnreliableMessageError("canceled");
-}
-function isAbortError(error) {
-    return error instanceof DOMException && error.name === "AbortError" ||
-        error instanceof Error && error.name === "AbortError";
-}
-function labelWith(label, ...parts) {
-    return concat(encoder.encode(label), byte(0), ...parts);
-}
-function concat(...parts) {
-    const out = new Uint8Array(parts.reduce((size, part) => size + part.byteLength, 0));
-    let offset = 0;
-    for (const part of parts) {
-        out.set(part, offset);
-        offset += part.byteLength;
-    }
-    return out;
-}
-function byte(value) {
-    return Uint8Array.of(value);
-}
-function u32be(value) {
-    const out = new Uint8Array(4);
-    new DataView(out.buffer).setUint32(0, value, false);
-    return out;
-}
-function u64be(value) {
-    const out = new Uint8Array(8);
-    new DataView(out.buffer).setBigUint64(0, value, false);
-    return out;
-}