@structured-id/ui-core 2.0.0 → 3.0.0

package/dist/storage-4CB2JTLW.cjs

@@ -1,22 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-
-
-
-
-
-
-var _chunkC3Q766CYcjs = require('./chunk-C3Q766CY.cjs');
-
-
-
-
-
-
-
-
-
-
-exports.clearAll = _chunkC3Q766CYcjs.clearAll; exports.deleteBinding = _chunkC3Q766CYcjs.deleteBinding; exports.deleteProfileState = _chunkC3Q766CYcjs.deleteProfileState; exports.isIndexedDbAvailable = _chunkC3Q766CYcjs.isIndexedDbAvailable; exports.listBindings = _chunkC3Q766CYcjs.listBindings; exports.loadBinding = _chunkC3Q766CYcjs.loadBinding; exports.loadProfileState = _chunkC3Q766CYcjs.loadProfileState; exports.saveBinding = _chunkC3Q766CYcjs.saveBinding; exports.saveProfileState = _chunkC3Q766CYcjs.saveProfileState;

package/dist/storage-THRWREZP.js

@@ -1,22 +0,0 @@
-import {
-  clearAll,
-  deleteBinding,
-  deleteProfileState,
-  isIndexedDbAvailable,
-  listBindings,
-  loadBinding,
-  loadProfileState,
-  saveBinding,
-  saveProfileState
-} from "./chunk-J5YXRXB5.js";
-export {
-  clearAll,
-  deleteBinding,
-  deleteProfileState,
-  isIndexedDbAvailable,
-  listBindings,
-  loadBinding,
-  loadProfileState,
-  saveBinding,
-  saveProfileState
-};

package/src/browser-vp/crypto.ts

@@ -1,253 +0,0 @@
-/**
- * Cryptographic primitives for Browser VP.
- *
- * All operations use Web Crypto API. Keys are non-extractable.
- */
-
-import type { DerivedKeys } from "./types";
-
-const PRF_SALT = "sid-ppk-v1";
-const SIGNING_INFO = "signing-key";
-const DATA_KEY_INFO = "data-encryption-key";
-
-const encoder = new TextEncoder();
-
-/**
- * Derive signing key (ECDSA P-256) and data key (AES-256-GCM)
- * from a PRF output using HKDF-SHA256.
- *
- * Both keys are deterministic from the same PRF seed.
- * Same passkey on any device → same keys.
- */
-export async function deriveKeysFromPrf(
-  prfOutput: ArrayBuffer,
-): Promise<DerivedKeys> {
-  // Import PRF output as HKDF key material
-  const baseKey = await crypto.subtle.importKey(
-    "raw",
-    prfOutput,
-    "HKDF",
-    false,
-    ["deriveBits"],
-  );
-
-  const salt = encoder.encode(PRF_SALT);
-
-  // Derive 32 bytes for ECDSA signing key seed
-  const signingBits = await crypto.subtle.deriveBits(
-    { name: "HKDF", hash: "SHA-256", salt, info: encoder.encode(SIGNING_INFO) },
-    baseKey,
-    256,
-  );
-
-  // Derive 32 bytes for AES-256-GCM data key
-  const dataKeyBits = await crypto.subtle.deriveBits(
-    {
-      name: "HKDF",
-      hash: "SHA-256",
-      salt,
-      info: encoder.encode(DATA_KEY_INFO),
-    },
-    baseKey,
-    256,
-  );
-
-  // Import signing seed as ECDSA P-256 private key
-  // WebCrypto doesn't support importing raw seed → we use PKCS8
-  // Instead, derive via HKDF into a JWK-compatible format
-  const signingKey = await importEcdsaFromSeed(signingBits);
-
-  // Import data key as AES-256-GCM
-  const dataKey = await crypto.subtle.importKey(
-    "raw",
-    dataKeyBits,
-    { name: "AES-GCM", length: 256 },
-    false,
-    ["encrypt", "decrypt"],
-  );
-
-  return { signingKey, dataKey };
-}
-
-/**
- * Generate a random ECDSA P-256 key pair (Strategy B).
- * The private key is non-extractable.
- */
-export async function generateDeviceKey(): Promise<CryptoKeyPair> {
-  return crypto.subtle.generateKey(
-    { name: "ECDSA", namedCurve: "P-256" },
-    false, // non-extractable
-    ["sign", "verify"],
-  );
-}
-
-/**
- * Generate a random AES-256-GCM data key (Strategy B).
- */
-export async function generateDataKey(): Promise<CryptoKey> {
-  return crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, false, [
-    "encrypt",
-    "decrypt",
-  ]);
-}
-
-/**
- * Wrap a CryptoKey with AES-KW for upload to SID (Strategy B).
- * Returns the wrapped key bytes.
- */
-export async function wrapKey(
-  keyToWrap: CryptoKey,
-  wrappingKey: CryptoKey,
-): Promise<ArrayBuffer> {
-  return crypto.subtle.wrapKey("jwk", keyToWrap, wrappingKey, "AES-KW");
-}
-
-/**
- * Unwrap a CryptoKey from SID (Strategy B, new browser).
- * Returns non-extractable ECDSA P-256 key pair.
- */
-export async function unwrapSigningKey(
-  wrappedKey: ArrayBuffer,
-  wrappingKey: CryptoKey,
-): Promise<CryptoKey> {
-  return crypto.subtle.unwrapKey(
-    "jwk",
-    wrappedKey,
-    wrappingKey,
-    "AES-KW",
-    { name: "ECDSA", namedCurve: "P-256" },
-    false, // non-extractable
-    ["sign"],
-  );
-}
-
-/**
- * Derive AES-256-KW wrapping key from OPAQUE session export key (Strategy B).
- */
-export async function deriveWrappingKey(
-  sessionExportKey: ArrayBuffer,
-): Promise<CryptoKey> {
-  const baseKey = await crypto.subtle.importKey(
-    "raw",
-    sessionExportKey,
-    "HKDF",
-    false,
-    ["deriveKey"],
-  );
-
-  return crypto.subtle.deriveKey(
-    {
-      name: "HKDF",
-      hash: "SHA-256",
-      salt: encoder.encode("sid-device-key-wrap"),
-      info: encoder.encode("wrapping-key"),
-    },
-    baseKey,
-    { name: "AES-KW", length: 256 },
-    false,
-    ["wrapKey", "unwrapKey"],
-  );
-}
-
-/**
- * Encrypt data with AES-256-GCM.
- * Returns IV (12 bytes) prepended to ciphertext.
- */
-export async function encrypt(
-  data: ArrayBuffer,
-  key: CryptoKey,
-): Promise<ArrayBuffer> {
-  const iv = crypto.getRandomValues(new Uint8Array(12));
-  const ciphertext = await crypto.subtle.encrypt(
-    { name: "AES-GCM", iv },
-    key,
-    data,
-  );
-
-  // Prepend IV to ciphertext
-  const result = new Uint8Array(iv.length + ciphertext.byteLength);
-  result.set(iv, 0);
-  result.set(new Uint8Array(ciphertext), iv.length);
-  return result.buffer;
-}
-
-/**
- * Decrypt data encrypted with `encrypt()`.
- * Expects IV (12 bytes) prepended to ciphertext.
- */
-export async function decrypt(
-  data: ArrayBuffer,
-  key: CryptoKey,
-): Promise<ArrayBuffer> {
-  const bytes = new Uint8Array(data);
-  const iv = bytes.slice(0, 12);
-  const ciphertext = bytes.slice(12);
-
-  return crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext);
-}
-
-/**
- * Sign data with ECDSA P-256 (SHA-256).
- */
-export async function sign(
-  data: ArrayBuffer,
-  privateKey: CryptoKey,
-): Promise<ArrayBuffer> {
-  return crypto.subtle.sign(
-    { name: "ECDSA", hash: "SHA-256" },
-    privateKey,
-    data,
-  );
-}
-
-/**
- * Export public key as raw bytes (for CSR / certificate request).
- */
-export async function exportPublicKey(
-  keyPair: CryptoKeyPair,
-): Promise<ArrayBuffer> {
-  return crypto.subtle.exportKey("raw", keyPair.publicKey);
-}
-
-/**
- * Compute SHA-256 hash (for authenticator change detection).
- */
-export async function sha256(data: ArrayBuffer): Promise<string> {
-  const hash = await crypto.subtle.digest("SHA-256", data);
-  return Array.from(new Uint8Array(hash))
-    .map((b) => b.toString(16).padStart(2, "0"))
-    .join("");
-}
-
-// ── Internal helpers ──
-
-/**
- * Import a 32-byte seed as ECDSA P-256 key pair.
- *
- * WebCrypto doesn't support direct seed import for ECDSA.
- * We use the seed as HKDF input to derive a proper PKCS8 key.
- * This is deterministic: same seed → same key pair.
- */
-async function importEcdsaFromSeed(_seed: ArrayBuffer): Promise<CryptoKeyPair> {
-  // Use seed to deterministically generate key via HKDF → generateKey
-  // Since WebCrypto generateKey is non-deterministic, we instead:
-  // 1. Import seed as HMAC key (deterministic)
-  // 2. Sign a fixed message to get deterministic bytes
-  // 3. Use those bytes as JWK `d` parameter
-  //
-  // Note: This is a simplification. Production implementation
-  // should use a proper deterministic ECDSA keygen (RFC 6979-style).
-  // For now, we generate a random key pair — deterministic derivation
-  // requires either a WASM implementation or a JS bigint EC library.
-  //
-  // TODO: Replace with deterministic keygen from sid-wasm when available.
-  // The PRF output is still the entropy source, ensuring same passkey
-  // produces same seed. Full deterministic EC keygen will be added
-  // when sid-wasm exposes the derivation function.
-
-  return crypto.subtle.generateKey(
-    { name: "ECDSA", namedCurve: "P-256" },
-    false,
-    ["sign", "verify"],
-  );
-}

package/src/browser-vp/index.test.ts

@@ -1,10 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { detectStrategy } from "./index";
-
-describe("detectStrategy", () => {
-  it("returns null when window is undefined (Node.js)", async () => {
-    // Node.js has no window global
-    const result = await detectStrategy();
-    expect(result).toBeNull();
-  });
-});

package/src/browser-vp/index.ts

@@ -1,116 +0,0 @@
-/**
- * Browser VP — Zero-Load Auth in Browser.
- *
- * Public API for browser-based Verifiable Presentation creation.
- * Automatically selects the best strategy based on browser capabilities:
- *
- * - **Strategy A (PRF):** Passkey PRF extension → deterministic keys.
- *   Cross-device via passkey sync. ~90% browser coverage (2026).
- *
- * - **Strategy B (device-key):** Random WebCrypto key, wrapped for sync.
- *   Each browser = separate device. Fallback for non-PRF browsers.
- *
- * Reference: Prudnikov, D. (2026). "Client-Side Verifiable Presentation System
- * with Passkey-Derived Persistent Keys and Pairwise Service Bindings."
- * doi:10.5281/zenodo.19387768 — https://doi.org/10.5281/zenodo.19387768
- */
-
-// Types
-export type {
-  VpStrategy,
-  ProfileState,
-  BindingEntry,
-  DerivedKeys,
-  VerifiablePresentation,
-  VpRequest,
-  BrowserVpContext,
-} from "./types";
-
-// PRF extension
-export { hasPrfSupport, evaluatePrf, createPasskeyWithPrf } from "./prf";
-
-// Cryptographic primitives
-export {
-  deriveKeysFromPrf,
-  generateDeviceKey,
-  generateDataKey,
-  wrapKey,
-  unwrapSigningKey,
-  deriveWrappingKey,
-  encrypt,
-  decrypt,
-  sign,
-  exportPublicKey,
-  sha256,
-} from "./crypto";
-
-// IndexedDB storage
-export {
-  saveProfileState,
-  loadProfileState,
-  deleteProfileState,
-  saveBinding,
-  loadBinding,
-  listBindings,
-  deleteBinding,
-  clearAll,
-  isIndexedDbAvailable,
-} from "./storage";
-
-// VP creation
-export { createVp, needsRenewal, getExpiringSoon } from "./vp";
-
-// ── Strategy selection ──
-
-import { hasPrfSupport } from "./prf";
-import { isIndexedDbAvailable } from "./storage";
-import type { VpStrategy, BrowserVpContext } from "./types";
-
-/**
- * Detect the best VP strategy for this browser.
- *
- * Returns "prf" if WebAuthn PRF extension is supported,
- * "device-key" otherwise. Returns null if Browser VP is
- * not possible (no IndexedDB, no WebCrypto).
- */
-export async function detectStrategy(): Promise<VpStrategy | null> {
-  // Prerequisites
-  if (typeof window === "undefined") return null;
-  if (!isIndexedDbAvailable()) return null;
-  if (!window.crypto?.subtle) return null;
-
-  // Try PRF first (primary strategy)
-  if (await hasPrfSupport()) {
-    return "prf";
-  }
-
-  // Fallback to device key
-  return "device-key";
-}
-
-/**
- * Initialize Browser VP for a profile.
- *
- * This is the main entry point. It:
- * 1. Detects the best strategy
- * 2. Checks for existing state in IndexedDB
- * 3. Returns a context object indicating readiness
- *
- * If not ready, the caller should trigger setup flow
- * (passkey creation for PRF, or key generation for device-key).
- */
-export async function initBrowserVp(
-  profileId: string,
-): Promise<BrowserVpContext | null> {
-  const strategy = await detectStrategy();
-  if (!strategy) return null;
-
-  const { loadProfileState } = await import("./storage");
-  const state = await loadProfileState(profileId);
-
-  return {
-    strategy,
-    profileId,
-    ready: state != null && state.strategy === strategy,
-  };
-}

package/src/browser-vp/prf.ts

@@ -1,179 +0,0 @@
-/**
- * WebAuthn PRF extension support (Strategy A).
- *
- * PRF (Pseudo-Random Function) extension allows deriving
- * deterministic secrets from a passkey. Same passkey on any
- * synced device produces the same PRF output → same keys.
- */
-
-const PRF_EVAL_LABEL = "sid-ppk-v1";
-const PRF_PROBE_LABEL = "sid-probe";
-const encoder = new TextEncoder();
-
-/**
- * Detect whether the browser supports WebAuthn PRF extension.
- *
- * Attempts a PRF evaluation on an existing passkey. Returns false
- * if PRF is unsupported — no error thrown.
- *
- * Browser support (2026): Chrome 116+, Edge 116+, Safari 17.4+,
- * Chrome Android, Safari iOS 17.4+. ~90% coverage.
- */
-export async function hasPrfSupport(): Promise<boolean> {
-  try {
-    // Check if PublicKeyCredential and extensions are available
-    if (typeof window === "undefined" || !window.PublicKeyCredential) {
-      return false;
-    }
-
-    // Check if PRF extension is supported via static method (if available)
-    if (typeof PublicKeyCredential.getClientCapabilities === "function") {
-      try {
-        const caps = await PublicKeyCredential.getClientCapabilities();
-        if (caps && "prf" in caps) {
-          return Boolean(caps.prf);
-        }
-      } catch {
-        // Fall through to probe-based detection
-      }
-    }
-
-    // Probe-based detection: try to use PRF in a get() call
-    // This requires an existing passkey for this origin
-    const result = await navigator.credentials.get({
-      publicKey: {
-        challenge: crypto.getRandomValues(new Uint8Array(32)),
-        rpId: window.location.hostname,
-        userVerification: "discouraged",
-        extensions: {
-          prf: {
-            eval: {
-              first: encoder.encode(PRF_PROBE_LABEL),
-            },
-          },
-        } as AuthenticationExtensionsClientInputs,
-      },
-    });
-
-    if (!result) return false;
-
-    const ext = (
-      result as PublicKeyCredential
-    ).getClientExtensionResults() as Record<string, unknown>;
-    const prfResults = ext?.prf as
-      | { results?: { first?: ArrayBuffer } }
-      | undefined;
-
-    return prfResults?.results?.first != null;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Evaluate PRF extension during passkey authentication.
- *
- * Returns the raw PRF output (32 bytes) which serves as the
- * entropy source for key derivation.
- *
- * @param credentialId - Optional: specific credential to use.
- * @returns PRF output bytes, or null if PRF evaluation failed.
- */
-export async function evaluatePrf(
-  credentialId?: ArrayBuffer,
-): Promise<ArrayBuffer | null> {
-  try {
-    const allowCredentials: PublicKeyCredentialDescriptor[] | undefined =
-      credentialId ? [{ type: "public-key", id: credentialId }] : undefined;
-
-    const result = await navigator.credentials.get({
-      publicKey: {
-        challenge: crypto.getRandomValues(new Uint8Array(32)),
-        rpId: window.location.hostname,
-        userVerification: "required",
-        allowCredentials,
-        extensions: {
-          prf: {
-            eval: {
-              first: encoder.encode(PRF_EVAL_LABEL),
-            },
-          },
-        } as AuthenticationExtensionsClientInputs,
-      },
-    });
-
-    if (!result) return null;
-
-    const ext = (
-      result as PublicKeyCredential
-    ).getClientExtensionResults() as Record<string, unknown>;
-    const prfResults = ext?.prf as
-      | { results?: { first?: ArrayBuffer } }
-      | undefined;
-
-    return prfResults?.results?.first ?? null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Create a passkey with PRF extension (first-time setup).
- *
- * Returns both the credential and the initial PRF output.
- */
-export async function createPasskeyWithPrf(
-  userId: ArrayBuffer,
-  userName: string,
-  rpName: string,
-): Promise<{ credential: PublicKeyCredential; prfOutput: ArrayBuffer } | null> {
-  try {
-    const result = await navigator.credentials.create({
-      publicKey: {
-        challenge: crypto.getRandomValues(new Uint8Array(32)),
-        rp: {
-          name: rpName,
-          id: window.location.hostname,
-        },
-        user: {
-          id: userId,
-          name: userName,
-          displayName: userName,
-        },
-        pubKeyCredParams: [
-          { alg: -7, type: "public-key" }, // ES256
-          { alg: -257, type: "public-key" }, // RS256 fallback
-        ],
-        authenticatorSelection: {
-          residentKey: "required",
-          userVerification: "required",
-        },
-        extensions: {
-          prf: {
-            eval: {
-              first: encoder.encode(PRF_EVAL_LABEL),
-            },
-          },
-        } as AuthenticationExtensionsClientInputs,
-      },
-    });
-
-    if (!result) return null;
-
-    const credential = result as PublicKeyCredential;
-    const ext = credential.getClientExtensionResults() as Record<
-      string,
-      unknown
-    >;
-    const prfResults = ext?.prf as
-      | { results?: { first?: ArrayBuffer } }
-      | undefined;
-    const prfOutput = prfResults?.results?.first;
-
-    if (!prfOutput) return null;
-
-    return { credential, prfOutput };
-  } catch {
-    return null;
-  }
-}

package/src/browser-vp/storage.test.ts

@@ -1,9 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { isIndexedDbAvailable } from "./storage";
-
-describe("isIndexedDbAvailable", () => {
-  it("returns false in Node.js environment (no indexedDB global)", () => {
-    // Node.js doesn't have indexedDB
-    expect(isIndexedDbAvailable()).toBe(false);
-  });
-});