/** * ECC session handshake helpers — OPC 10000-6 §6.8.2. * * When a SecureChannel uses an ECC (or RSA-DH) SecurityPolicy, CreateSession * and ActivateSession carry an extra ECDH handshake in the AdditionalHeader: * the Client advertises the ECDHPolicyUri it plans to use for UserIdentityToken * secrets, and the Server answers with a fresh EphemeralKey (EphemeralKeyType) * that the Client must use for its EccEncryptedSecret (§6.8.3). * * AdditionalHeader key names come from Part 6 Table 70: * ECDHPolicyUri (request direction), ECDHKey (response direction). */ import { AdditionalParametersType } from '../generated/AdditionalParametersType'; import { ExtensionObject } from '../basic-types/extension_object'; import { getCryptoFactory } from '../secure-channel/security_policy'; import { EccNistP256_Params } from '../crypto'; import type { ClientSession } from './client_session'; export declare const ECDH_POLICY_URI_KEY = "ECDHPolicyUri"; export declare const ECDH_KEY_KEY = "ECDHKey"; export interface SessionEphemeralKey { /** The ECDHPolicyUri this key was issued for. */ policyUri: string; /** Server ephemeral x||y public key (zero-padded big-endian). */ publicKey: Uint8Array; /** Set once consumed by an EccEncryptedSecret (servers reject reuse). */ used: boolean; } /** Request direction: advertise the ECDHPolicyUri for upcoming user tokens. */ export declare function buildEcdhPolicyUriHeader(policyUri: string): AdditionalParametersType; /** * Set (or refresh) the ECDHPolicyUri entry on a request header, preserving * any unrelated AdditionalHeader entries instead of overwriting the header. */ export declare function setEcdhPolicyUriHeader(requestHeader: { additionalHeader?: ExtensionObject | undefined; }, policyUri: string): void; /** * Response direction: extract the server EphemeralKey from an AdditionalHeader. * Accepts a decoded AdditionalParametersType (as produced by * decodeExtensionObject) and tolerates unknown entries. */ export declare function parseEccSessionEphemeralKey(additionalHeader: ExtensionObject | undefined | null, fallbackPolicyUri?: string): SessionEphemeralKey | undefined; /** Latest server ephemeral key for a policy URI, once stored on the session. */ export declare function sessionEphemeralKeyFor(session: ClientSession, policyUri: string): SessionEphemeralKey | undefined; /** * Record a freshly received server EphemeralKey on the session, replacing any * previous (possibly consumed) key for the same policy URI. */ export declare function storeSessionEphemeralKey(session: ClientSession, key: SessionEphemeralKey): void; export interface EccTokenContext { factory: Exclude, null>; params: typeof EccNistP256_Params; /** ECDHPolicyUri: token policy URI, falling back to the channel policy. */ policyUri: string; } /** Resolve ECC token context when the *token* policy is ECC, else undefined. */ export declare function eccTokenContextFor(session: ClientSession, tokenPolicyUri: string | undefined): EccTokenContext | undefined; export interface ClientIdentityForSigning { getPrivateKey(): { getSignKey(h: string, a?: string): Promise; } | undefined; getCertificateChain(): Uint8Array | undefined; getCertificate(): Uint8Array | undefined; } /** * Build an EccEncryptedSecret-protected secret for a UserIdentityToken * (Part 6 §6.8.3): fresh sender ephemeral key + the latest server session * ephemeral key, signed with the client application key. */ export declare function protectEccUserTokenSecret(session: ClientSession, client: ClientIdentityForSigning | null | undefined, ctx: EccTokenContext, secret: Uint8Array): Promise<{ envelope: Uint8Array; policyUri: string; encryptionAlgorithm: string; }>; //# sourceMappingURL=ecc_session_handshake.d.ts.map