@interncom/diplomatic 0.12.10 → 0.13.1

package/dist/web/shared/codec.d.ts

@@ -40,6 +40,7 @@ export declare class Encoder {
     writeStructs<T>(codec: ICodecStruct<T>, structs: Iterable<T>): Status;
     writeBytesSeq(bytesSeq: Iterable<Uint8Array>): void;
     result(): Uint8Array;
+    wipe(): void;
     scan(): Generator<Uint8Array>;
 }
 export interface ICodecStruct<T> {

package/dist/web/shared/codecs/pairPackage.d.ts

@@ -6,8 +6,7 @@ export type PairPackagePlain = {
     hosts: BundleHost[];
 };
 /**
- * Inner plaintext body (not sealed here — AEAD is applied by the pairing
- * ceremony, then carried as `body` in {@link pairPackageEnvelopeCodec}):
+ * Inner plaintext (AEAD is applied by QR pairing: X25519 + blake3 + XSalsa20):
  *   masterSeed: 32 fixed bytes
  *   hostsLen: varint
  *   hosts: hostsLen × BundleHost

package/dist/web/shared/consts.d.ts

@@ -39,7 +39,8 @@ export declare enum Status {
     CommunicationError = 25,
     VarLimitExceeded = 26,
     InvalidResponse = 27,
-    ConnectionClosed = 28
+    ConnectionClosed = 28,
+    CryptoError = 29
 }
 export declare enum APICallName {
     User = 0,

package/dist/web/shared/crypto/enclave.d.ts

@@ -3,17 +3,16 @@ import { Status } from "../consts.ts";
 import { MASTER_SEED_LEN, type SealedMasterKey } from "../seed.ts";
 import type { ICrypto, PublicKey } from "../types.ts";
 import { type ValStat } from "../valstat.ts";
+import { type DHKEReq, type DHKEResp, PairRequest } from "./pairing.ts";
 import { type LargeBlobCreateOpts, type LargeBlobRp } from "../webauthn/largeBlob.ts";
 import { type PrfCreateOpts, type PrfEvalOpts, type PrfRp } from "../webauthn/prf.ts";
 export type { LargeBlobCreateOpts, LargeBlobRp };
 export type { PrfCreateOpts, PrfEvalOpts, PrfRp };
 /** Options for PRF seal/unseal ceremonies (no raw PRF bytes). */
-export type PasskeyPrfOpts = PrfRp & {
-    salt?: Uint8Array;
+export type PasskeyPrfOpts = PrfCreateOpts & {
     credId?: Uint8Array;
     /** Seal only: create a PRF credential first when no credId is known. */
     createCredIfNeeded?: boolean;
-    userName?: string;
 };
 /** Durable PRF-sealed master + public meta (never includes PRF output). */
 export type PrfSealedMaster = {
@@ -48,7 +47,6 @@ export type Identity = {
     kdmFor: (msgHeadEnc: Uint8Array) => Promise<Uint8Array>;
 };
 declare const SEAL_WRAP_DOMAIN: Uint8Array<ArrayBufferLike>;
-declare const SEAL_PAIR_DOMAIN: Uint8Array<ArrayBufferLike>;
 declare const SEAL_KEY_LEN = 32;
 declare const SEAL_PRF_MIN_LEN = 16;
 export declare class Enclave {
@@ -109,27 +107,8 @@ export declare class Enclave {
     }>>;
     /** UV + overwrite largeBlob with zeros (destroys stored seed material). */
     static clearLargeBlob(credId: Uint8Array, opts?: LargeBlobRp): Promise<Status>;
-    /**
-     * UV + PRF, then AEAD-seal pair-package plaintext (seed + hosts).
-     * Returns ciphertext body + public ceremony meta (no PRF).
-     */
-    sealPairPackageBody(hosts: BundleHost[], opts?: PasskeyPrfOpts): Promise<ValStat<{
-        body: Uint8Array;
-        salt: Uint8Array;
-        credId: Uint8Array;
-    }>>;
-    /**
-     * UV + PRF (using envelope salt/credId), decrypt pair body, build Enclave.
-     * Also seals master under the same PRF for durable IDB (single ceremony).
-     */
-    static openPairPackageBody(body: Uint8Array, opts: PasskeyPrfOpts & {
-        salt: Uint8Array;
-    }): Promise<ValStat<{
-        enclave: Enclave;
-        hosts: BundleHost[];
-        sealedMaster: SealedMasterKey;
-        credId: Uint8Array;
-    }>>;
+    static pairRequest(): Promise<ValStat<PairRequest>>;
+    pairAccept(dhkeReq: DHKEReq, hosts: BundleHost[]): Promise<ValStat<DHKEResp>>;
     /**
      * Spawn a new sync Worker from the embedded bundle and inject this enclave's
      * master seed into it (transfer). Seed never goes to a caller-supplied port —
@@ -156,4 +135,4 @@ export declare class Enclave {
 }
 /** Derive seal key from PRF output (domain-separated). Used by enclave seal/unseal. */
 export declare function sealKeyFromPrf(crypto: ICrypto, prf: Uint8Array, domain?: Uint8Array): Promise<ValStat<Uint8Array>>;
-export { MASTER_SEED_LEN, SEAL_KEY_LEN, SEAL_PAIR_DOMAIN, SEAL_PRF_MIN_LEN, SEAL_WRAP_DOMAIN, };
+export { MASTER_SEED_LEN, SEAL_KEY_LEN, SEAL_PRF_MIN_LEN, SEAL_WRAP_DOMAIN };

package/dist/web/shared/crypto/noble.d.ts

@@ -1,6 +1,8 @@
+import { type X25519Sk } from "./x25519.ts";
 import type { DerivationSeed, Hash, ICrypto, KeyPair } from "../types.ts";
 /**
- * ICrypto: noble for XSalsa20 + blake3; native WebCrypto for all Ed25519.
+ * ICrypto: noble for XSalsa20 + blake3; WebCrypto Ed25519 + X25519
+ * (our scalar; RFC 7748 check before trusting pub/DH).
  */
 export declare class NobleCrypto implements ICrypto {
     private verifyKeys;
@@ -14,4 +16,9 @@ export declare class NobleCrypto implements ICrypto {
     signEd25519(message: Uint8Array | string, secKey: Uint8Array): Promise<Uint8Array>;
     checkSigEd25519(sig: Uint8Array, message: Uint8Array | string, pubKey: Uint8Array): Promise<boolean>;
     blake3(data: Uint8Array): Promise<Hash>;
+    genX25519(): Promise<{
+        priv: X25519Sk;
+        pub: Uint8Array;
+    }>;
+    x25519Shared(priv: X25519Sk, peerPub: Uint8Array): Promise<Uint8Array>;
 }

package/dist/web/shared/crypto/pairing.d.ts

@@ -0,0 +1,34 @@
+import type { BundleHost } from "../codecs/bundleHost.ts";
+import { type ValStat } from "../valstat.ts";
+import { Enclave } from "./enclave.ts";
+import type { X25519Sk } from "./x25519.ts";
+export declare const SEAL_PAIR_DOMAIN: Uint8Array<ArrayBufferLike>;
+export declare const X25519_PUB_LEN = 32;
+/** respPub (32) ‖ XSalsa nonce (24) ‖ tag (16); plaintext follows in the ct. */
+export declare const DHKE_RESP_MIN: number;
+declare const dhkeReqSymbol: unique symbol;
+declare const dhkeRespSymbol: unique symbol;
+export type DHKEReq = Uint8Array & {
+    readonly [dhkeReqSymbol]: true;
+};
+export type DHKEResp = Uint8Array & {
+    readonly [dhkeRespSymbol]: true;
+};
+export declare function asDHKEReq(bytes: Uint8Array): ValStat<DHKEReq>;
+export declare function asDHKEResp(bytes: Uint8Array): ValStat<DHKEResp>;
+export declare function pairKey(sk: X25519Sk, // local X25519 priv
+peer: Uint8Array, // ECDH peer pub (enroller: dhkeReq; enrollee: respPub)
+reqPub: Uint8Array, // enrollee pub, bound into KDF
+respPub: Uint8Array): Promise<ValStat<Uint8Array>>;
+export declare class PairRequest {
+    #private;
+    private constructor();
+    static create(): Promise<ValStat<PairRequest>>;
+    wipe(): void;
+    get dhkeReq(): DHKEReq;
+    finish(dhkeResp: DHKEResp): Promise<ValStat<{
+        enclave: Enclave;
+        hosts: BundleHost[];
+    }>>;
+}
+export {};

package/dist/web/shared/crypto/x25519.d.ts

@@ -0,0 +1,10 @@
+import { type ValStat } from "../valstat.ts";
+export declare const X25519_SK_LEN = 32;
+declare const x25519SkSymbol: unique symbol;
+export type X25519Sk = Uint8Array & {
+    readonly [x25519SkSymbol]: true;
+};
+export declare function asX25519Sk(bytes: Uint8Array): ValStat<X25519Sk>;
+export declare function x25519(sk: X25519Sk, u: Uint8Array): Uint8Array;
+export declare function x25519Pub(sk: X25519Sk): Uint8Array;
+export {};

package/dist/web/shared/webauthn/prf.d.ts

@@ -3,7 +3,10 @@ import { type WebAuthnRp } from "./common.ts";
 export type PrfRp = WebAuthnRp;
 export type PrfCreateOpts = PrfRp & {
     userName?: string;
-    authenticatorAttachment?: string;
+    /** Omit so the UA can offer roaming keys (YubiKey) and third-party providers. */
+    authenticatorAttachment?: "platform" | "cross-platform";
+    /** If set, request PRF eval at create so hmac-secret is actually enabled. */
+    salt?: Uint8Array;
 };
 /** Default salt for DIPLOMATIC PRF eval (UTF-8). */
 export declare const DEFAULT_PRF_SALT: Uint8Array<ArrayBufferLike>;