Tecnología

async function deriveKeyPair(seed: Uint8Array): Promise<{
  publicKeyJwk: JsonWebKey;
  privateKeyJwk: JsonWebKey;
}> {
  // Step 1: Import seed as HKDF base key material
  const baseKey = await crypto.subtle.importKey(
    "raw", seed.buffer as ArrayBuffer,
    "HKDF", false, ["deriveBits"],
  );

  // Step 2: Derive 32 bytes via HKDF-SHA256
  const derivedBits = await crypto.subtle.deriveBits(
    {
      name: "HKDF",
      hash: "SHA-256",
      salt: new Uint8Array(32),
      info: new TextEncoder().encode("zerokvault-ecdh-p256-v1"),
    },
    baseKey, 256,
  );

  // Step 3: Import as P-256 private key
  const dBytes = new Uint8Array(derivedBits);
  const privateKey = await crypto.subtle.importKey(
    "jwk",
    { kty: "EC", crv: "P-256", d: uint8ArrayToBase64url(dBytes) },
    { name: "ECDH", namedCurve: "P-256" },
    true, ["deriveBits"],
  );

  // Step 4: Export both JWK forms
  const privateKeyJwk = await crypto.subtle.exportKey("jwk", privateKey);
  const publicKeyJwk = exportPublicKey(privateKeyJwk);
  return { publicKeyJwk, privateKeyJwk };
}

async function encryptContent(
  plaintext: string,
  dek: CryptoKey,
): Promise<string> {
  const iv = crypto.getRandomValues(new Uint8Array(12));
  const encoded = new TextEncoder().encode(plaintext);
  const ciphertext = await crypto.subtle.encrypt(
    { name: "AES-GCM", iv },
    dek, encoded,
  );
  // Concatenate IV (12 bytes) + ciphertext
  const combined = new Uint8Array(iv.byteLength + ciphertext.byteLength);
  combined.set(iv, 0);
  combined.set(new Uint8Array(ciphertext), iv.byteLength);
  return uint8ArrayToBase64(combined);
}

async function wrapDEK(
  dek: CryptoKey,
  recipientPublicKeyJwk: JsonWebKey,
): Promise<string> {
  // Generate ephemeral ECDH key pair (forward secrecy)
  const ephemeral = await crypto.subtle.generateKey(
    { name: "ECDH", namedCurve: "P-256" },
    true, ["deriveBits"],
  );

  // Import recipient public key
  const recipientPublicKey = await crypto.subtle.importKey(
    "jwk", recipientPublicKeyJwk,
    { name: "ECDH", namedCurve: "P-256" },
    false, [],
  );

  // ECDH key agreement -> shared secret
  const sharedBits = await crypto.subtle.deriveBits(
    { name: "ECDH", public: recipientPublicKey },
    ephemeral.privateKey, 256,
  );

  // HKDF -> AES-KW wrapping key, then wrap
  const wrappingKey = await deriveWrappingKey(sharedBits);
  const wrappedKeyBuffer = await crypto.subtle.wrapKey(
    "raw", dek, wrappingKey, "AES-KW",
  );

  return JSON.stringify({
    wrappedKey: uint8ArrayToBase64(new Uint8Array(wrappedKeyBuffer)),
    ephemeralPublicKey: await crypto.subtle.exportKey("jwk", ephemeral.publicKey),
  });
}