Web Crypto API

const { subtle } = globalThis.crypto;

(async function() {
  const key = await subtle.generateKey({
    name: 'HMAC',
    hash: 'SHA-256',
    length: 256,
  }, true, ['sign', 'verify']);

  const enc = new TextEncoder();
  const message = enc.encode('I love cupcakes');

  const digest = await subtle.sign({
    name: 'HMAC',
  }, key, message);
})();

const { subtle } = globalThis.crypto;

const array = new Uint8Array(32);
globalThis.crypto.getRandomValues(array);
console.log(array);

const uuid = globalThis.crypto.randomUUID();
console.log(uuid);
// '36b8f84d-df4e-4d49-b662-bcde71a8764f'

const { SubtleCrypto } = globalThis;

if (SubtleCrypto.supports?.('importKey', 'Argon2id')) {
  console.log('Argon2id is supported');
}

if (SubtleCrypto.supports?.('encrypt', 'AES-OCB')) {
  console.log('AES-OCB is supported');
}

const key = await subtle.generateKey({
  name: 'AES-GCM',
  length: 256,
}, true, ['encrypt', 'decrypt']);

const { publicKey, privateKey } = await subtle.generateKey({
  name: 'ECDSA',
  namedCurve: 'P-521',
}, true, ['sign', 'verify']);

const keyPair = await subtle.generateKey({
  name: 'Ed25519',
}, true, ['sign', 'verify']);

const { publicKey, privateKey } = await subtle.generateKey({
  name: 'RSA-PSS',
  modulusLength: 2048,
  publicExponent: new Uint8Array([1, 0, 1]),
  hash: 'SHA-256',
}, true, ['sign', 'verify']);

const key = await subtle.generateKey({
  name: 'HMAC',
  hash: 'SHA-512',
}, true, ['sign', 'verify']);

const crypto = globalThis.crypto;

const key = await crypto.subtle.generateKey({
  name: 'AES-GCM',
  length: 256,
}, true, ['encrypt', 'decrypt']);

const iv = crypto.getRandomValues(new Uint8Array(12));
const data = new TextEncoder().encode('secret message');

const encrypted = await crypto.subtle.encrypt({
  name: 'AES-GCM',
  iv,
}, key, data);

const decrypted = await crypto.subtle.decrypt({
  name: 'AES-GCM',
  iv,
}, key, encrypted);

const message = new TextDecoder().decode(decrypted);

const { publicKey, privateKey } = await subtle.generateKey({
  name: 'ECDSA',
  namedCurve: 'P-384',
}, true, ['sign', 'verify']);

const data = new TextEncoder().encode('message to sign');
const signature = await subtle.sign({
  name: 'ECDSA',
  hash: 'SHA-384',
}, privateKey, data);

const isValid = await subtle.verify({
  name: 'ECDSA',
  hash: 'SHA-384',
}, publicKey, signature, data);

console.log('Signature valid:', isValid);

const data = new TextEncoder().encode('hello world');
const hashBuffer = await subtle.digest('SHA-256', data);
const hashArray = Array.from(new Uint8Array(hashBuffer));
const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
console.log(hashHex);

const password = new TextEncoder().encode('user-password');
const keyMaterial = await subtle.importKey(
  'raw',
  password,
  'PBKDF2',
  false,
  ['deriveBits']
);

const salt = crypto.getRandomValues(new Uint8Array(16));
const bits = await subtle.deriveBits({
  name: 'PBKDF2',
  hash: 'SHA-512',
  salt,
  iterations: 100000,
}, keyMaterial, 256);

const derivedKey = await subtle.deriveKey({
  name: 'PBKDF2',
  hash: 'SHA-512',
  salt,
  iterations: 100000,
}, keyMaterial, {
  name: 'AES-GCM',
  length: 256,
}, true, ['encrypt', 'decrypt']);

if (SubtleCrypto.supports?.('importKey', 'Argon2id')) {
  const passwordKey = await crypto.subtle.importKey(
    'raw-secret',
    new TextEncoder().encode('password'),
    'Argon2id',
    false,
    ['deriveKey']
  );

  const key = await crypto.subtle.deriveKey({
    name: 'Argon2id',
    nonce: crypto.getRandomValues(new Uint8Array(16)),
    parallelism: 4,
    memory: 2 ** 21,
    passes: 1,
  }, passwordKey, {
    name: 'AES-GCM',
    length: 256,
  }, false, ['encrypt', 'decrypt']);
}

const jwk = {
  kty: 'oct',
  k: 'Y0zt37HgOx-BY7SQjYVmrqhPkO44Ii2Jcb9yydUDPfE',
  alg: 'HS256',
  ext: true,
};

const key = await subtle.importKey(
  'jwk',
  jwk,
  { name: 'HMAC', hash: 'SHA-256' },
  true,
  ['sign', 'verify']
);

const exportedKey = await subtle.exportKey('jwk', key);
console.log(JSON.stringify(exportedKey, null, 2));

const keyToWrap = await subtle.generateKey({
  name: 'HMAC',
  hash: 'SHA-512',
}, true, ['sign', 'verify']);

const wrappingKey = await subtle.generateKey({
  name: 'AES-KW',
  length: 256,
}, true, ['wrapKey', 'unwrapKey']);

const wrappedKey = await subtle.wrapKey(
  'jwk',
  keyToWrap,
  wrappingKey,
  'AES-KW'
);

const unwrappedKey = await subtle.unwrapKey(
  'jwk',
  wrappedKey,
  wrappingKey,
  'AES-KW',
  { name: 'HMAC', hash: 'SHA-512' },
  true,
  ['sign', 'verify']
);

const { publicKey, privateKey } = await subtle.generateKey({
  name: 'ML-KEM-768',
}, true, ['encapsulateBits', 'decapsulateBits']);

const { sharedSecret, ciphertext } = await subtle.encapsulateBits(
  { name: 'ML-KEM-768' },
  publicKey,
  256
);

const decapsulatedSecret = await subtle.decapsulateBits(
  { name: 'ML-KEM-768' },
  privateKey,
  ciphertext,
  256
);

const publicKey = await subtle.getPublicKey(privateKey);