@floegence/flowersec-core 2.5.3 → 3.0.0

package/dist/v3/contract.d.ts

@@ -0,0 +1,65 @@
+import type { RpcError } from "../rpc/wire.js";
+import type { ByteStream, CarrierKind as PublicCarrierKind, IncomingStream, JsonObject, JsonPrimitive, JsonValue, OperationOptions, PathKind as PublicPathKind, RpcPeer, RpcResult, Session, SessionTermination, StreamOpenOptions, UnreliableMessageChannel, UnreliableMessageSendOptions, UnreliableMessageSendResult } from "../public/contract.js";
+export { SessionError } from "../public/contract.js";
+export type { SessionErrorCode } from "../public/contract.js";
+export type CarrierKind = PublicCarrierKind;
+export type PathKind = PublicPathKind;
+export type JsonPrimitiveV3 = JsonPrimitive;
+export type JsonValueV3 = JsonValue;
+export type JsonObjectV3 = JsonObject;
+export type OperationOptionsV3 = OperationOptions;
+export type UnreliableMessageSendOptionsV3 = UnreliableMessageSendOptions;
+export type UnreliableMessageSendResultV3 = UnreliableMessageSendResult;
+export type UnreliableMessageChannelV3 = UnreliableMessageChannel;
+export type StreamOpenOptionsV3 = StreamOpenOptions;
+export type RpcResultV3<Response = unknown> = RpcResult<Response>;
+export type RpcPeerV3 = RpcPeer;
+export type ByteStreamV3 = ByteStream;
+export type IncomingStreamV3 = IncomingStream;
+export type SessionTerminationV3 = SessionTermination;
+export type SessionV3 = Session;
+export interface InternalByteStreamV3 {
+    readonly id: bigint;
+    readonly kind: string;
+    readonly terminalError: Error | undefined;
+    read(options?: OperationOptionsV3): Promise<Uint8Array | null>;
+    write(data: Uint8Array, options?: OperationOptionsV3): Promise<number>;
+    closeWrite(): Promise<void>;
+    reset(): Promise<void>;
+    close(): Promise<void>;
+}
+export interface InternalIncomingStreamV3 {
+    readonly id: bigint;
+    readonly kind: string;
+    readonly metadata: JsonObjectV3;
+    readonly stream: InternalByteStreamV3;
+}
+export interface InternalSessionV3 {
+    readonly path: PathKind;
+    readonly endpointInstanceId: string | undefined;
+    readonly rpc: InternalRpcPeerV3;
+    readonly termination: Promise<Readonly<{
+        error: Error;
+    }>>;
+    readonly unreliableMessages?: UnreliableMessageChannelV3 | undefined;
+    openStream(kind: string, options?: InternalStreamOpenOptionsV3): Promise<InternalByteStreamV3>;
+    acceptStream(options?: OperationOptionsV3): Promise<InternalIncomingStreamV3>;
+    rekey(options?: OperationOptionsV3): Promise<void>;
+    probeLiveness(options?: OperationOptionsV3): Promise<number>;
+    waitTermination(): Promise<Readonly<{
+        error: Error;
+    }>>;
+    close(): Promise<void>;
+}
+export interface InternalRpcPeerV3 {
+    call(typeId: number, payload: unknown, signal?: AbortSignal): Promise<{
+        payload: unknown;
+        error?: RpcError;
+    }>;
+    notify(typeId: number, payload: unknown): Promise<void>;
+    onNotify(typeId: number, handler: (payload: unknown) => void): () => void;
+    close(): void;
+}
+export type InternalStreamOpenOptionsV3 = OperationOptionsV3 & Readonly<{
+    metadata?: JsonObjectV3;
+}>;

package/dist/v3/contract.js

@@ -0,0 +1,3 @@
+// Package exports keep this module private, but its declarations must remain in
+// the emitted closure because other internal declaration files import them.
+export { SessionError } from "../public/contract.js";

package/dist/v3/controller.d.ts

@@ -0,0 +1,43 @@
+import type { ArtifactPathKindV3, CanonicalArtifactCandidateV3 } from "./artifact.js";
+import { ConnectErrorV3, type RetryDispositionV3, type TransportFailureV3 } from "./security.js";
+export type CandidateFailureV3 = Readonly<{
+    candidate: CanonicalArtifactCandidateV3;
+    failure: TransportFailureV3;
+    disposition?: RetryDispositionV3;
+}>;
+export declare class ControllerCycleStateV3 {
+    #private;
+    constructor(maximumAttempts?: number);
+    beginAcquisition(): boolean;
+    recordFailedAcquisitionOrLease(): number;
+    claimReplacementQuota(): boolean;
+    blockPinPolicy(endpointKey: string, digest: string): void;
+    isBlocked(endpointKey: string, digest: string): boolean;
+    isSecurityLockedEndpoint(endpointKey: string): boolean;
+    recordPolicyTrigger(opaque: boolean): void;
+    blockedPolicyTerminal(): ConnectErrorV3;
+    established(): void;
+    snapshot(): Readonly<{
+        attempts: number;
+        consecutiveFailures: number;
+        replacementUsed: boolean;
+    }>;
+}
+export declare function saturatingControllerIncrementV3(value: number): number;
+export declare function endpointKeyV3(path: ArtifactPathKindV3, candidate: CanonicalArtifactCandidateV3): string;
+export declare function selectReplacementCandidatesV3(path: ArtifactPathKindV3, primary: readonly CanonicalArtifactCandidateV3[], replacement: readonly CanonicalArtifactCandidateV3[], triggerEndpointKeys: ReadonlySet<string>, failedEndpointKeys: ReadonlySet<string>, cycle: ControllerCycleStateV3): readonly CanonicalArtifactCandidateV3[];
+export declare function filterBlockedCandidatesV3(path: ArtifactPathKindV3, candidates: readonly CanonicalArtifactCandidateV3[], cycle: ControllerCycleStateV3): readonly CanonicalArtifactCandidateV3[];
+export declare function aggregateCandidateFailuresV3(failures: readonly CandidateFailureV3[], policyRefreshExecutable: boolean): ConnectErrorV3 | "policy_refresh";
+/** Records policy-refresh provenance at the A-result linearization point. */
+export declare function blockPolicyRefreshTriggersV3(path: ArtifactPathKindV3, failures: readonly CandidateFailureV3[], cycle: ControllerCycleStateV3): ReadonlySet<string>;
+export type ControllerClockV3 = Readonly<{
+    wallNowMilliseconds(): number;
+    monotonicNowMilliseconds(): number;
+    sleep(milliseconds: number, signal: AbortSignal): Promise<void>;
+}>;
+export declare class ControllerRetryWaitV3 {
+    #private;
+    constructor(clock?: ControllerClockV3);
+    retryNow(): boolean;
+    wait(disposition: RetryDispositionV3, consecutiveFailure: number, signal: AbortSignal): Promise<boolean>;
+}

package/dist/v3/controller.js

@@ -0,0 +1,303 @@
+import { tlsPolicyDigestV3 } from "./artifact.js";
+import { ConnectErrorV3, aggregateRetryDispositionsV3, } from "./security.js";
+const WALL_CLOCK_RECHECK_MILLISECONDS = 1_000;
+export class ControllerCycleStateV3 {
+    #maximumAttempts;
+    #attempts = 0;
+    #consecutiveFailures = 0;
+    #replacementUsed = false;
+    #blockedPinPolicies = new Map();
+    #securityLockedEndpoints = new Set();
+    #securityPolicyTrigger = false;
+    #opaquePolicyTrigger = false;
+    constructor(maximumAttempts = 0) {
+        if (!Number.isSafeInteger(maximumAttempts) || maximumAttempts < 0) {
+            throw new RangeError("maximumAttempts must be a non-negative safe integer");
+        }
+        this.#maximumAttempts = maximumAttempts;
+    }
+    beginAcquisition() {
+        if (this.#maximumAttempts !== 0 && this.#attempts >= this.#maximumAttempts)
+            return false;
+        this.#attempts = saturatingControllerIncrementV3(this.#attempts);
+        return true;
+    }
+    recordFailedAcquisitionOrLease() {
+        this.#consecutiveFailures = Math.min(Number.MAX_SAFE_INTEGER, this.#consecutiveFailures + 1);
+        return this.#consecutiveFailures;
+    }
+    claimReplacementQuota() {
+        if (this.#replacementUsed)
+            return false;
+        this.#replacementUsed = true;
+        return true;
+    }
+    blockPinPolicy(endpointKey, digest) {
+        const values = this.#blockedPinPolicies.get(endpointKey) ?? new Set();
+        values.add(digest);
+        this.#blockedPinPolicies.set(endpointKey, values);
+        this.#securityLockedEndpoints.add(endpointKey);
+    }
+    isBlocked(endpointKey, digest) {
+        return this.#blockedPinPolicies.get(endpointKey)?.has(digest) === true;
+    }
+    isSecurityLockedEndpoint(endpointKey) {
+        return this.#securityLockedEndpoints.has(endpointKey);
+    }
+    recordPolicyTrigger(opaque) {
+        if (opaque)
+            this.#opaquePolicyTrigger = true;
+        else
+            this.#securityPolicyTrigger = true;
+    }
+    blockedPolicyTerminal() {
+        if (!this.#securityPolicyTrigger && !this.#opaquePolicyTrigger) {
+            return new ConnectErrorV3("artifact_invalid", { kind: "terminal" });
+        }
+        return new ConnectErrorV3(this.#securityPolicyTrigger ? "transport_security_failed" : "connection_failed", { kind: "terminal" });
+    }
+    established() {
+        this.#attempts = 0;
+        this.#consecutiveFailures = 0;
+        this.#replacementUsed = false;
+        this.#blockedPinPolicies.clear();
+        this.#securityLockedEndpoints.clear();
+        this.#securityPolicyTrigger = false;
+        this.#opaquePolicyTrigger = false;
+    }
+    snapshot() {
+        return Object.freeze({
+            attempts: this.#attempts,
+            consecutiveFailures: this.#consecutiveFailures,
+            replacementUsed: this.#replacementUsed,
+        });
+    }
+}
+export function saturatingControllerIncrementV3(value) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new RangeError("controller counter must be a non-negative safe integer");
+    }
+    return value === Number.MAX_SAFE_INTEGER ? value : value + 1;
+}
+export function endpointKeyV3(path, candidate) {
+    return `${candidate.carrier}\0${path}\0${candidate.normalized_url}`;
+}
+export function selectReplacementCandidatesV3(path, primary, replacement, triggerEndpointKeys, failedEndpointKeys, cycle) {
+    const primaryByKey = new Map(primary.map((candidate) => [endpointKeyV3(path, candidate), candidate]));
+    for (const key of triggerEndpointKeys) {
+        const candidate = primaryByKey.get(key);
+        if (candidate?.tls.mode === "pin") {
+            cycle.blockPinPolicy(key, tlsPolicyDigestV3(candidate.tls).hashBase64URL);
+        }
+    }
+    const eligible = [];
+    let changedPin = false;
+    for (const candidate of replacement) {
+        const key = endpointKeyV3(path, candidate);
+        const previous = primaryByKey.get(key);
+        if (previous === undefined) {
+            if (!blockedOrDowngraded(candidate, key, cycle))
+                eligible.push(candidate);
+            continue;
+        }
+        if (triggerEndpointKeys.has(key)) {
+            if (candidate.tls.mode !== "pin" || previous.tls.mode !== "pin")
+                continue;
+            const oldDigest = tlsPolicyDigestV3(previous.tls).hashBase64URL;
+            const newDigest = tlsPolicyDigestV3(candidate.tls).hashBase64URL;
+            if (oldDigest !== newDigest && !cycle.isBlocked(key, newDigest)) {
+                changedPin = true;
+                eligible.push(candidate);
+            }
+            continue;
+        }
+        if (!failedEndpointKeys.has(key) && !blockedOrDowngraded(candidate, key, cycle))
+            eligible.push(candidate);
+    }
+    return Object.freeze(changedPin ? eligible : []);
+}
+export function filterBlockedCandidatesV3(path, candidates, cycle) {
+    return Object.freeze(candidates.filter((candidate) => !blockedOrDowngraded(candidate, endpointKeyV3(path, candidate), cycle)));
+}
+export function aggregateCandidateFailuresV3(failures, policyRefreshExecutable) {
+    if (failures.some(({ failure }) => failure.code === "invalid_artifact")) {
+        return new ConnectErrorV3("artifact_invalid", { kind: "terminal" });
+    }
+    if (failures.some(({ failure }) => failure.code === "expired_artifact")) {
+        return new ConnectErrorV3("expired_artifact", { kind: "retryable" });
+    }
+    const securityTriggers = failures.filter(({ failure, candidate }) => isNativePolicyTriggerV3(candidate, failure));
+    const opaqueTriggers = failures.filter(({ failure, candidate }) => candidate.tls.mode === "pin" && failure.code === "connection_failed" &&
+        failure.detail === "browser_pin_opaque");
+    if (policyRefreshExecutable && (securityTriggers.length > 0 || opaqueTriggers.length > 0))
+        return "policy_refresh";
+    if (securityTriggers.length > 0 || failures.some(({ failure }) => failure.code === "tls_failed")) {
+        return new ConnectErrorV3("transport_security_failed", { kind: "terminal" });
+    }
+    if (opaqueTriggers.length > 0)
+        return new ConnectErrorV3("connection_failed", { kind: "terminal" });
+    if (failures.length > 0 && failures.every(({ failure }) => failure.code === "tls_unsupported")) {
+        return new ConnectErrorV3("transport_security_unsupported", { kind: "terminal" });
+    }
+    const ordinary = failures.filter(({ failure }) => failure.code === "connection_failed");
+    if (ordinary.length > 0) {
+        return new ConnectErrorV3("connection_failed", aggregateRetryDispositionsV3(ordinary.map(({ disposition }) => disposition ?? { kind: "retryable" })));
+    }
+    return new ConnectErrorV3("connection_failed", { kind: "terminal" });
+}
+/** Records policy-refresh provenance at the A-result linearization point. */
+export function blockPolicyRefreshTriggersV3(path, failures, cycle) {
+    const triggerKeys = new Set();
+    for (const { candidate, failure } of failures) {
+        if (!isPolicyTriggerV3(candidate, failure))
+            continue;
+        cycle.recordPolicyTrigger(failure.code === "connection_failed" && failure.detail === "browser_pin_opaque");
+        const key = endpointKeyV3(path, candidate);
+        triggerKeys.add(key);
+        if (candidate.tls.mode === "pin") {
+            cycle.blockPinPolicy(key, tlsPolicyDigestV3(candidate.tls).hashBase64URL);
+        }
+    }
+    return triggerKeys;
+}
+function blockedOrDowngraded(candidate, endpointKey, cycle) {
+    if (cycle.isSecurityLockedEndpoint(endpointKey) && candidate.tls.mode === "ca")
+        return true;
+    if (candidate.tls.mode === "ca")
+        return false;
+    return cycle.isBlocked(endpointKey, tlsPolicyDigestV3(candidate.tls).hashBase64URL);
+}
+function isPolicyTriggerV3(candidate, failure) {
+    return isNativePolicyTriggerV3(candidate, failure) ||
+        (candidate.tls.mode === "pin" && failure.code === "connection_failed" &&
+            failure.detail === "browser_pin_opaque");
+}
+function isNativePolicyTriggerV3(candidate, failure) {
+    return candidate.tls.mode === "pin" && (failure.code === "tls_policy_expired" ||
+        (failure.code === "tls_failed" &&
+            (failure.detail === "pin_mismatch" || failure.detail === "unknown")));
+}
+export class ControllerRetryWaitV3 {
+    #clock;
+    #waiting = false;
+    #manual = false;
+    #absoluteDeadline;
+    #wake;
+    constructor(clock = defaultControllerClockV3()) {
+        this.#clock = clock;
+    }
+    retryNow() {
+        if (!this.#waiting)
+            return false;
+        if (this.#absoluteDeadline !== undefined &&
+            this.#clock.wallNowMilliseconds() < this.#absoluteDeadline)
+            return false;
+        this.#manual = true;
+        this.#wake?.();
+        return true;
+    }
+    async wait(disposition, consecutiveFailure, signal) {
+        const validated = validateControllerWaitDisposition(disposition);
+        if (validated.kind === "terminal" || signal.aborted)
+            return false;
+        if (this.#waiting)
+            throw new Error("Flowersec v3 retry wait is already active");
+        const backoffDeadline = saturatingAddMilliseconds(this.#clock.monotonicNowMilliseconds(), controllerBackoffForWait(consecutiveFailure));
+        this.#waiting = true;
+        this.#manual = false;
+        this.#absoluteDeadline = validated.kind === "retry_after"
+            ? validated.absoluteUnixMilliseconds
+            : undefined;
+        try {
+            while (!signal.aborted) {
+                const wallNow = this.#clock.wallNowMilliseconds();
+                const monoNow = this.#clock.monotonicNowMilliseconds();
+                const wallRemaining = this.#absoluteDeadline === undefined
+                    ? 0
+                    : saturatingDifferenceMilliseconds(this.#absoluteDeadline, wallNow);
+                const monoRemaining = this.#manual ? 0 : saturatingDifferenceMilliseconds(backoffDeadline, monoNow);
+                if (wallRemaining === 0 && monoRemaining === 0)
+                    return true;
+                const delay = Math.max(1, Math.min(WALL_CLOCK_RECHECK_MILLISECONDS, ...(wallRemaining === 0 ? [] : [wallRemaining]), ...(monoRemaining === 0 ? [] : [monoRemaining])));
+                await this.#sleepOrWake(delay, signal);
+            }
+            return false;
+        }
+        catch (error) {
+            if (signal.aborted)
+                return false;
+            throw error;
+        }
+        finally {
+            this.#waiting = false;
+            this.#manual = false;
+            this.#absoluteDeadline = undefined;
+            this.#wake = undefined;
+        }
+    }
+    async #sleepOrWake(milliseconds, signal) {
+        let wake;
+        const manual = new Promise((resolve) => { wake = resolve; });
+        this.#wake = wake;
+        try {
+            await Promise.race([this.#clock.sleep(milliseconds, signal), manual]);
+        }
+        finally {
+            if (this.#wake === wake)
+                this.#wake = undefined;
+        }
+    }
+}
+function saturatingAddMilliseconds(value, increment) {
+    if (!Number.isFinite(value) || !Number.isFinite(increment) || increment < 0)
+        return Number.MAX_SAFE_INTEGER;
+    if (value >= Number.MAX_SAFE_INTEGER - increment)
+        return Number.MAX_SAFE_INTEGER;
+    return value + increment;
+}
+function saturatingDifferenceMilliseconds(deadline, now) {
+    if (!Number.isFinite(deadline) || !Number.isFinite(now) || deadline <= now)
+        return 0;
+    const difference = deadline - now;
+    return Number.isSafeInteger(difference) ? difference : Number.MAX_SAFE_INTEGER;
+}
+function validateControllerWaitDisposition(value) {
+    if (value.kind === "terminal" || value.kind === "retryable")
+        return value;
+    if (value.kind !== "retry_after" || !Number.isSafeInteger(value.absoluteUnixMilliseconds) ||
+        value.absoluteUnixMilliseconds < 0 || value.absoluteUnixMilliseconds > 253_402_300_799_999) {
+        throw new ConnectErrorV3("artifact_invalid", { kind: "terminal" });
+    }
+    return value;
+}
+function controllerBackoffForWait(consecutiveFailure) {
+    if (!Number.isSafeInteger(consecutiveFailure) || consecutiveFailure < 1) {
+        throw new RangeError("consecutive failure ordinal must be positive");
+    }
+    if (consecutiveFailure >= 8)
+        return 30_000;
+    return 250 * 2 ** (consecutiveFailure - 1);
+}
+function defaultControllerClockV3() {
+    return Object.freeze({
+        wallNowMilliseconds: Date.now,
+        monotonicNowMilliseconds: () => Math.floor(performance.now()),
+        sleep: async (milliseconds, signal) => await new Promise((resolve, reject) => {
+            if (signal.aborted) {
+                reject(signal.reason);
+                return;
+            }
+            const timer = setTimeout(finish, milliseconds);
+            const abort = () => {
+                clearTimeout(timer);
+                signal.removeEventListener("abort", abort);
+                reject(signal.reason);
+            };
+            function finish() {
+                signal.removeEventListener("abort", abort);
+                resolve();
+            }
+            signal.addEventListener("abort", abort, { once: true });
+        }),
+    });
+}

package/dist/v3/handshake.d.ts

@@ -0,0 +1,81 @@
+import { CipherSuiteV3 } from "./protocol.js";
+import { FLOWERSEC_V3_PROFILE } from "./transportConstants.js";
+export declare enum HandshakeMessageTypeV3 {
+    ClientInit = 1,
+    ServerFinished = 2,
+    ClientFinished = 3
+}
+export type HandshakeFrameV3 = Readonly<{
+    type: HandshakeMessageTypeV3;
+    payload: Uint8Array;
+    raw: Uint8Array;
+}>;
+export type ClientInitV3 = Readonly<{
+    profile: typeof FLOWERSEC_V3_PROFILE;
+    channelID: string;
+    sessionContractHash: Uint8Array;
+    clientRole: 1;
+    suite: CipherSuiteV3;
+    clientEphemeralPublic: Uint8Array;
+    nonceC: Uint8Array;
+    selectedFeatures: number;
+    maxInboundStreams: number;
+    clientAdmissionBinding: Uint8Array;
+    clientEndpointInstanceID: string;
+}>;
+export type ServerFinishedCoreV3 = Readonly<{
+    suite: CipherSuiteV3;
+    handshakeID: Uint8Array;
+    serverEphemeralPublic: Uint8Array;
+    nonceS: Uint8Array;
+    sessionContractHash: Uint8Array;
+    selectedFeatures: number;
+    maxInboundStreams: number;
+    serverAdmissionBinding: Uint8Array;
+    serverEndpointInstanceID: string;
+}>;
+export type ServerFinishedV3 = Readonly<{
+    core: ServerFinishedCoreV3;
+    serverConfirm: Uint8Array;
+}>;
+export type ClientFinishedV3 = Readonly<{
+    handshakeID: Uint8Array;
+    clientConfirm: Uint8Array;
+}>;
+export type HandshakeExpectationsV3 = Readonly<{
+    path: "direct" | "tunnel";
+    channelID: string;
+    sessionContractHash: Uint8Array;
+    suite: CipherSuiteV3;
+    maxInboundStreams: number;
+    admissionBinding: Uint8Array;
+    expectedEndpointInstanceID: string;
+}>;
+export declare function encodeControlPrefaceV3(): Uint8Array;
+export declare function parseControlPrefaceV3(raw: Uint8Array): void;
+export declare function encodeHandshakeFrameV3(type: HandshakeMessageTypeV3, payload: Uint8Array): Uint8Array;
+export declare function decodeHandshakeFrameV3(raw: Uint8Array): HandshakeFrameV3;
+export declare function encodeClientInitV3(message: ClientInitV3): Uint8Array;
+export declare function decodeClientInitV3(raw: Uint8Array): ClientInitV3;
+export declare function encodeServerFinishedCoreV3(core: ServerFinishedCoreV3, suite: CipherSuiteV3): Uint8Array;
+export declare function encodeServerFinishedV3(message: ServerFinishedV3, suite: CipherSuiteV3): Uint8Array;
+export declare function decodeServerFinishedV3(raw: Uint8Array, suite: CipherSuiteV3): ServerFinishedV3;
+export declare function encodeClientFinishedCoreV3(handshakeID: Uint8Array): Uint8Array;
+export declare function encodeClientFinishedV3(message: ClientFinishedV3): Uint8Array;
+export declare function decodeClientFinishedV3(raw: Uint8Array): ClientFinishedV3;
+export declare function generateEphemeralKeyV3(suite: CipherSuiteV3, entropy: (length: number) => Uint8Array): Readonly<{
+    privateKey: Uint8Array;
+    publicKey: Uint8Array;
+}>;
+export declare function ephemeralPublicKeyV3(suite: CipherSuiteV3, privateKey: Uint8Array): Uint8Array;
+export declare function computeSharedSecretV3(suite: CipherSuiteV3, privateKey: Uint8Array, peerPublicKey: Uint8Array): Uint8Array;
+export declare function deriveHandshakePRKV3(psk: Uint8Array, sharedSecret: Uint8Array): Uint8Array;
+export declare function computeHandshakeH0V3(controlPrefaceRaw: Uint8Array, clientInitRaw: Uint8Array): Uint8Array;
+export declare function computeHandshakeH1V3(h0: Uint8Array, serverCoreRaw: Uint8Array): Uint8Array;
+export declare function computeServerConfirmV3(handshakePRK: Uint8Array, h1: Uint8Array): Uint8Array;
+export declare function computeHandshakeH2V3(h1: Uint8Array, serverFinishedRaw: Uint8Array, clientCoreRaw: Uint8Array): Uint8Array;
+export declare function computeClientConfirmV3(handshakePRK: Uint8Array, h2: Uint8Array): Uint8Array;
+export declare function computeHandshakeH3V3(h2: Uint8Array, clientFinishedRaw: Uint8Array): Uint8Array;
+export declare function deriveSessionPRKV3(h3: Uint8Array, handshakePRK: Uint8Array): Uint8Array;
+export declare function validateClientInitV3(message: ClientInitV3, expected: HandshakeExpectationsV3): void;
+export declare function validateServerFinishedV3(message: ServerFinishedV3, expected: HandshakeExpectationsV3): void;