Web Crypto

if (!globalThis.isSecureContext || !crypto.subtle) {
  throw new Error("Web Crypto needs HTTPS or localhost");
}

const key = crypto.getRandomValues(new Uint8Array(32));
const id = crypto.randomUUID(); // v4, 36 chars
 
// Uniform integer in [0, max): reject the biased tail
function randomInt(max: number): number {
  const limit = Math.floor(2 ** 32 / max) * max;
  const buf = new Uint32Array(1);
  do crypto.getRandomValues(buf);
  while (buf[0]! >= limit);
  return buf[0]! % max;
}

const aes = await crypto.subtle.generateKey(
  { name: "AES-GCM", length: 256 },
  false,                     // extractable
  ["encrypt", "decrypt"],    // usages
); // CryptoKey
 
const pair = await crypto.subtle.generateKey(
  { name: "ECDSA", namedCurve: "P-256" },
  false,
  ["sign", "verify"],
); // CryptoKeyPair; publicKey is always extractable
 
aes.type;         // "secret" | "public" | "private"
aes.extractable;  // false: exportKey/wrapKey throw
aes.algorithm;    // { name: "AES-GCM", length: 256 }
aes.usages;       // ["encrypt", "decrypt"]

// PEM is base64 DER between header lines
function pemToDer(pem: string): Uint8Array<ArrayBuffer> {
  const b64 = pem.replace(/-----[^-]+-----|\s/g, "");
  return Uint8Array.fromBase64(b64);
}
 
declare const pem: string;
const pub = await crypto.subtle.importKey(
  "spki",
  pemToDer(pem),
  { name: "RSA-PSS", hash: "SHA-256" },
  true,
  ["verify"],
);
const jwk = await crypto.subtle.exportKey("jwk", pub);
jwk.kty; // "RSA"

const data = new TextEncoder().encode("hello");
const buf = await crypto.subtle.digest("SHA-256", data);
new Uint8Array(buf).toHex(); // "2cf24dba5fb0a30e..."

declare const key: CryptoKey; // AES-GCM, 256-bit
declare const userIdBytes: Uint8Array<ArrayBuffer>;
const iv = crypto.getRandomValues(new Uint8Array(12));
const ct = await crypto.subtle.encrypt(
  { name: "AES-GCM", iv, additionalData: userIdBytes },
  key,
  new TextEncoder().encode("secret"),
); // ciphertext + 16-byte tag, appended
// store iv next to ct; AAD must match on decrypt

declare const privateKey: CryptoKey, publicKey: CryptoKey;
const msg = new TextEncoder().encode("payload");
const alg = { name: "ECDSA", hash: "SHA-256" };
const sig = await crypto.subtle.sign(alg, privateKey, msg);
await crypto.subtle.verify(alg, publicKey, sig, msg);

declare const secret: CryptoKey; // HKDF base key
const k = await crypto.subtle.deriveKey(
  {
    name: "HKDF",
    hash: "SHA-256",
    salt: new Uint8Array(32),
    info: new TextEncoder().encode("app:v1:enc"),
  },
  secret,
  { name: "AES-GCM", length: 256 },
  false,
  ["encrypt", "decrypt"],
);

const bytes = new TextEncoder().encode("hi");
bytes.toBase64();                // "aGk="
bytes.toBase64({ alphabet: "base64url", omitPadding: true });
bytes.toHex();                   // "6869"
Uint8Array.fromBase64("aGk=");   // Uint8Array [104, 105]
Uint8Array.fromHex("6869");
new TextDecoder().decode(bytes); // "hi"

const toHex = (b: Uint8Array): string =>
  Array.from(b, (x) => x.toString(16).padStart(2, "0"))
    .join("");
 
const toB64 = (b: Uint8Array): string => {
  let s = "";
  for (const x of b) s += String.fromCharCode(x);
  return btoa(s); // spread would overflow on big arrays
};
 
const fromB64 = (s: string): Uint8Array<ArrayBuffer> =>
  Uint8Array.from(atob(s), (c) => c.charCodeAt(0));

export async function sha256Hex(
  input: string | Uint8Array<ArrayBuffer>,
): Promise<string> {
  const data = typeof input === "string"
    ? new TextEncoder().encode(input)
    : input;
  const buf = await crypto.subtle.digest("SHA-256", data);
  return new Uint8Array(buf).toHex();
}
 
await sha256Hex("hello"); // "2cf24dba5fb0a30e26e8..."

export async function keyFromPassword(
  password: string,
  salt: Uint8Array<ArrayBuffer>, // 16 random bytes
  iterations = 600_000,
): Promise<CryptoKey> {
  const base = await crypto.subtle.importKey(
    "raw",
    new TextEncoder().encode(password),
    "PBKDF2",
    false,
    ["deriveKey"],
  );
  return crypto.subtle.deriveKey(
    { name: "PBKDF2", salt, iterations, hash: "SHA-256" },
    base,
    { name: "AES-GCM", length: 256 },
    false,
    ["encrypt", "decrypt"],
  );
}

const enc = new TextEncoder();
 
export async function seal(text: string, pw: string) {
  const salt = crypto.getRandomValues(new Uint8Array(16));
  const iv = crypto.getRandomValues(new Uint8Array(12));
  const key = await keyFromPassword(pw, salt);
  const ct = await crypto.subtle.encrypt(
    { name: "AES-GCM", iv }, key, enc.encode(text));
  const out = new Uint8Array(28 + ct.byteLength);
  out.set(salt); out.set(iv, 16);
  out.set(new Uint8Array(ct), 28);
  return out.toBase64();
}
 
export async function unseal(b64: string, pw: string) {
  const b = Uint8Array.fromBase64(b64);
  const key = await keyFromPassword(pw, b.slice(0, 16));
  const pt = await crypto.subtle.decrypt( // OperationError
    { name: "AES-GCM", iv: b.slice(16, 28) }, // if wrong pw
    key, b.slice(28));
  return new TextDecoder().decode(pt);
}

const hmacKey = (secret: string) =>
  crypto.subtle.importKey(
    "raw", new TextEncoder().encode(secret),
    { name: "HMAC", hash: "SHA-256" }, false,
    ["sign", "verify"]);
 
export async function sign(secret: string, body: string) {
  const sig = await crypto.subtle.sign("HMAC",
    await hmacKey(secret), new TextEncoder().encode(body));
  return `sha256=${new Uint8Array(sig).toHex()}`;
}
 
export async function verifyWebhook(
  req: Request, secret: string,
): Promise<boolean> {
  const header = req.headers.get("x-hub-signature-256");
  const hex = header?.match(/^sha256=([0-9a-f]{64})$/i)?.[1];
  if (!hex) return false;
  const body = await req.clone().text(); // raw bytes
  return crypto.subtle.verify("HMAC", await hmacKey(secret),
    Uint8Array.fromHex(hex), new TextEncoder().encode(body));
}

const { privateKey, publicKey } =
  await crypto.subtle.generateKey(
    "Ed25519", false, ["sign", "verify"]);
 
// Share the 32-byte public key as base64url
const raw = await crypto.subtle.exportKey("raw", publicKey);
const pubB64 = new Uint8Array(raw)
  .toBase64({ alphabet: "base64url", omitPadding: true });
 
const msg = new TextEncoder().encode("license:acme:2027");
const sig = await crypto.subtle.sign(
  "Ed25519", privateKey, msg); // 64 bytes
 
// Verifier side
const pub = await crypto.subtle.importKey("raw",
  Uint8Array.fromBase64(pubB64, { alphabet: "base64url" }),
  "Ed25519", true, ["verify"]);
await crypto.subtle.verify("Ed25519", pub, sig, msg); // true

export async function newToken(bytes = 32) {
  const raw = crypto.getRandomValues(new Uint8Array(bytes));
  const token = raw.toBase64({
    alphabet: "base64url",
    omitPadding: true,
  }); // 43 chars for 32 bytes, URL-safe
  const hash = await crypto.subtle.digest(
    "SHA-256", new TextEncoder().encode(token));
  return { token, hash: new Uint8Array(hash).toHex() };
}