@interncom/diplomatic 0.12.9 → 0.13.0

package/dist/web/passkey/prf-store.d.ts

@@ -1,6 +1,5 @@
 import { Enclave } from "../shared/crypto/enclave";
 import { type SealedMasterKey } from "../shared/seed";
-import type { ICrypto } from "../shared/types";
 import { type ValStat } from "../shared/valstat";
 import type { ISeedStore, SetSeedOpts } from "../types";
 import type { PrfRp } from "../shared/webauthn/prf";
@@ -21,7 +20,6 @@ export type PrfSeedMeta = {
  */
 export type PersistPrfSeedMeta = (meta: PrfSeedMeta | undefined) => void | Promise<void>;
 export type PrfSeedStoreOpts = PrfRp & {
-    crypto: ICrypto;
     /**
      * Required durable write path for sealed master + salt + credId.
      * Protocol IDB implements this via {@link IDBSeedStore.persistPrfMeta}.

package/dist/web/passkey/seed.d.ts

@@ -1,12 +1,10 @@
 import { Enclave } from "../shared/crypto/enclave";
-import type { ICrypto } from "../shared/types";
 import { type ValStat } from "../shared/valstat";
 import type { ISeedStore, SetSeedOpts } from "../types";
 import { type LargeBlobRp } from "./largeBlob";
 export { defaultWebAuthnRpId } from "./webauthn";
 export { LargeBlob, type LargeBlobCreateOpts, type LargeBlobRp, } from "./largeBlob";
 export type PasskeySeedStoreOpts = LargeBlobRp & {
-    crypto: ICrypto;
     credId?: Uint8Array;
 };
 /**

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,6 +3,7 @@ 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 };
@@ -48,20 +49,19 @@ 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 {
     #private;
     private constructor();
     /** New enclave with a fresh 32-byte master seed. */
-    static fromRandom(crypto: ICrypto): Promise<Enclave>;
+    static fromRandom(): Promise<Enclave>;
     /**
      * Construct from raw master seed bytes (import / bootstrap only).
      * Copies the seed so callers may zero their buffer after success.
      * Prefer {@link fromRandom} or {@link unsealWithPasskey} for normal flows.
      */
-    static fromBytes(crypto: ICrypto, bytes: Uint8Array): ValStat<Enclave>;
+    static fromBytes(bytes: Uint8Array): ValStat<Enclave>;
     /**
      * UV + PRF ceremony, then AEAD-seal master. Returns sealed ciphertext + public
      * meta only — never PRF output. Sealed blob on disk is useless without a
@@ -75,7 +75,7 @@ export declare class Enclave {
      * Callers never supply PRF bytes — only sealed meta + RP/salt/credId.
      * Returns the credential id used so stores can persist it (skip picker next time).
      */
-    static unsealWithPasskey(crypto: ICrypto, sealedMaster: SealedMasterKey, opts: PasskeyPrfOpts & {
+    static unsealWithPasskey(sealedMaster: SealedMasterKey, opts: PasskeyPrfOpts & {
         salt: Uint8Array;
     }): Promise<ValStat<{
         enclave: Enclave;
@@ -100,7 +100,7 @@ export declare class Enclave {
      * Pass `opts.credId` for a known credential; omit for discoverable assertion.
      * Returns the credential id used (useful after discover).
      */
-    static fromLargeBlob(crypto: ICrypto, opts?: LargeBlobRp & {
+    static fromLargeBlob(opts?: LargeBlobRp & {
         credId?: Uint8Array;
     }): Promise<ValStat<{
         enclave: Enclave;
@@ -109,27 +109,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(crypto: ICrypto, 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 +137,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/stores/idb/seed.d.ts

@@ -30,7 +30,5 @@ export declare class IDBSeedStore implements ISeedStore {
     hasPrfMeta(): Promise<boolean>;
     /** Last PRF passkey id, if this device has a sealed PRF identity. */
     lastPrfCredId(): Promise<Uint8Array | undefined>;
-    openPrfStore(opts: Omit<PrfSeedStoreOpts, "crypto" | "persistMeta" | "meta"> & {
-        crypto?: ICrypto;
-    }): Promise<PrfSeedStore>;
+    openPrfStore(opts: Omit<PrfSeedStoreOpts, "persistMeta" | "meta">): Promise<PrfSeedStore>;
 }