@1auth/crypto 0.0.0-alpha.9 → 0.0.0-beta.1

package/index.js

@@ -1,30 +1,125 @@
-import { promisify } from 'node:util'
+// Copyright 2003 - 2026 will Farrell, and 1Auth contributors.
+// SPDX-License-Identifier: MIT
 import {
-  randomBytes,
-  createHash as checksum,
-  createCipheriv,
-  createDecipheriv,
-  generateKeyPair as generateKeyPairCallback,
-  sign,
-  verify
-} from 'node:crypto'
-// https://github.com/napi-rs/node-rs/tree/main/packages/argon2
-import { hash as secretHash, verify as secretVerify } from '@node-rs/argon2'
-
-const options = {
-  // randomBytes(32).toString('hex') // 256 bits
-  encryptionSharedKey: '',
-  encryptionMethod: 'chacha20-poly1305', // AES-256 GCM (aes-256-gcm) or ChaCha20-Poly1305 (chacha20-poly1305)
-
-  digestAlgorithm: 'sha3-256',
-  digestSalt: ''
-}
-
-export default (params) => {
-  Object.assign(options, params)
-}
-
-const generateKeyPair = promisify(generateKeyPairCallback)
+	argon2Sync,
+	createCipheriv,
+	createDecipheriv,
+	createHash,
+	createHmac,
+	generateKeyPair as generateKeyPairCallback,
+	randomBytes,
+	randomInt,
+	sign as signCallback,
+	timingSafeEqual,
+	verify as verifyCallback,
+} from "node:crypto";
+import { promisify } from "node:util";
+import { customAlphabet } from "nanoid";
+
+const generateKeyPair = promisify(generateKeyPairCallback);
+const sign = promisify(signCallback);
+const verify = promisify(verifyCallback);
+
+const defaults = {
+	symmetricEncryptionKey: undefined, // symmetricRandomEncryptionKey()
+	symmetricEncryptionAlgorithm: "chacha20-poly1305", // 2025-03: AES-256 GCM (aes-256-gcm) or ChaCha20-Poly1305 (chacha20-poly1305)
+	symmetricEncryptionEncoding: undefined, // https://nodejs.org/api/buffer.html#buffers-and-character-encodings
+	symmetricSignatureHashAlgorithm: undefined, // fallback to defaultHashAlgorithm
+	symmetricSignatureSecret: undefined, // symmetricRandomSignatureSecret()
+	symmetricSignatureEncoding: undefined, // fallback to defaultEncoding
+	asymmetricKeyNamedCurve: "P-384", // P-512
+	asymmetricSignatureHashAlgorithm: undefined, // fallback to defaultHashAlgorithm
+	asymmetricSignatureEncoding: undefined, // fallback to defaultEncoding
+	digestChecksumHashAlgorithm: undefined, // fallback to defaultHashAlgorithm
+	digestChecksumEncoding: undefined,
+	digestChecksumSalt: undefined, // randomChecksumSalt()
+	digestChecksumPepper: undefined, // randomChecksumPepper()
+	secretArgon2Algorithm: "argon2id",
+	secretArgon2Version: 19, // argon2id
+	secretArgon2Parallelism: 1, // argon2id
+	secretArgon2MemoryCost: 15, // argon2id
+	secretArgon2TimeCost: 3, // argon2id
+	secretArgon2NonceLength: 16, // argon2id
+	secretArgon2HashLength: 64, // argon2id
+
+	defaultEncoding: "base64",
+	defaultHashAlgorithm: "sha3-384",
+};
+const symmetricEncryptionEncodingLengths = {};
+const options = {};
+export default (opt = {}) => {
+	Object.assign(options, defaults, opt);
+
+	// Check options, set defaults
+	if (!options.symmetricEncryptionKey) {
+		throw new Error(
+			"@1auth/crypto symmetricEncryptionKey is empty, use a stored secret made from randomBytes(32) Encryption disabled.",
+		);
+	}
+	options.symmetricEncryptionKey = makeOptionsBuffer(
+		options.symmetricEncryptionKey,
+	);
+	options.symmetricEncryptionEncoding ??= options.defaultEncoding;
+	options.symmetricSignatureHashAlgorithm ??= options.defaultHashAlgorithm;
+	if (!options.symmetricSignatureSecret) {
+		throw new Error(
+			"@1auth/crypto symmetricSignatureSecret is empty, use a stored secret made from randomBytes(32) Signature disabled.",
+		);
+	}
+	options.symmetricSignatureSecret = makeOptionsBuffer(
+		options.symmetricSignatureSecret,
+	);
+	options.symmetricSignatureEncoding ??= options.defaultEncoding;
+	options.asymmetricSignatureHashAlgorithm ??= options.defaultHashAlgorithm;
+	options.asymmetricSignatureEncoding ??= options.defaultEncoding;
+	if (!options.digestChecksumSalt) {
+		throw new Error(
+			"@1auth/crypto digestChecksumSalt is empty, use a stored secret made from randomBytes(32) Checksum salting disabled.",
+		);
+	}
+	options.digestChecksumSalt = makeOptionsBuffer(options.digestChecksumSalt);
+	if (!options.digestChecksumPepper) {
+		throw new Error(
+			"@1auth/crypto digestChecksumPepper is empty, use a stored secret made from randomBytes(12) Checksum peppering disabled.",
+		);
+	}
+	options.digestChecksumPepper = makeOptionsBuffer(
+		options.digestChecksumPepper,
+	);
+	options.digestChecksumHashAlgorithm ??= options.defaultHashAlgorithm;
+	options.digestChecksumEncoding ??= options.defaultEncoding;
+
+	// Secrets
+	Object.assign(argon2Options, {
+		algorithm: options.secretArgon2Algorithm,
+		version: options.secretArgon2Version, // argon2id
+		parallelism: options.secretArgon2Parallelism, // argon2id
+		memoryCost: options.secretArgon2MemoryCost, // argon2id
+		timeCost: options.secretArgon2TimeCost, // argon2id
+		nonceLength: options.secretArgon2NonceLength, // argon2id
+		hashLength: options.secretArgon2HashLength, // argon2id
+	});
+
+	// Lengths
+	symmetricEncryptionEncodingLengths.iv = randomIV().toString(
+		options.symmetricEncryptionEncoding,
+	).length;
+	symmetricEncryptionEncodingLengths.ivAndAuthTag =
+		symmetricEncryptionEncodingLengths.iv +
+		randomBytes(16).toString(options.symmetricEncryptionEncoding).length;
+};
+
+export const makeOptionsBuffer = (
+	value,
+	encoding = options.defaultEncoding,
+) => {
+	if (typeof value === "string") {
+		return Buffer.from(value, encoding);
+	}
+	return value;
+};
+
+export const getOptions = () => options;
 
 // *** entropy *** //
 // export const characterPoolSize = (value) => {
@@ -42,359 +137,628 @@ const generateKeyPair = promisify(generateKeyPairCallback)
 //   return max - min
 // }
 
-// *** Random generators *** //
-export const characterPoolSize = {
-  keyboard: 94, // (26 + 10 + 11) * 2
-  alphaNumeric: 62, // (26 + 10) * 2
-  base64: 64, // (26 + 10) * 2 + 2
-  hex: 16,
-  numeric: 10
-}
-// Alt: https://github.com/sindresorhus/crypto-random-string/blob/main/core.js
-export const randomAlphaNumeric = (bits) => {
-  const characterLength = entropyToCharacterLength(
-    bits,
-    characterPoolSize.alphaNumeric
-  )
-  return randomBytes(characterLength * 2)
-    .toString('base64')
-    .replace(/[^a-zA-Z0-9]/g, '')
-    .substring(0, characterLength)
-}
-
-export const randomBase64 = (bits) => {
-  const characterLength = entropyToCharacterLength(
-    bits,
-    characterPoolSize.base64
-  )
-  return randomBytes(characterLength + 1)
-    .toString('base64')
-    .replace('=', '')
-}
-
-export const randomNumeric = (bits) => {
-  const characterLength = entropyToCharacterLength(
-    bits,
-    characterPoolSize.numeric
-  )
-  const max = 10 ** characterLength
-  let value = Math.floor(Math.random() * max).toString()
-  if (value === max.toString()) {
-    return randomNumeric(bits)
-  }
-  while (value.length < characterLength) value = '0' + value
-  return value
-}
-
-export const randomHex = (bits) => {
-  const characterLength = entropyToCharacterLength(bits, characterPoolSize.hex)
-  return randomBytes(characterLength).toString('hex')
-}
-
-// *** configs *** //
-export const randomId = {
-  type: 'id',
-  entropy: 64,
-  charPool: characterPoolSize.alphaNumeric,
-  create: async () => randomAlphaNumeric(randomId.entropy)
-}
-
-export const subject = {
-  type: 'id',
-  entropy: 64,
-  charPool: characterPoolSize.alphaNumeric,
-  create: async () => randomAlphaNumeric(subject.entropy)
-}
-
-export const session = {
-  type: 'id',
-  entropy: 128, // ASVS 3.2.2
-  charPool: characterPoolSize.alphaNumeric,
-  expire: 15 * 60,
-  create: async () => randomAlphaNumeric(session.entropy)
-}
-
-export const passwordSecret = {
-  type: 'secret',
-  entropy: 64,
-  charPool: characterPoolSize.keyboard,
-  otp: false,
-  encode: async (value, encryptedKey, sub) =>
-    createSecretHash(value).then((hash) => encrypt(hash, encryptedKey, sub)),
-  decode: async (value, encryptedKey, sub) => decrypt(value, encryptedKey, sub),
-  verify: async (value, hash) => verifySecretHash(hash, value)
-}
-
-// aka Password/Credential Recovery
-export const passwordToken = {
-  type: 'token',
-  entropy: 20,
-  charPool: characterPoolSize.numeric,
-  otp: true,
-  expire: 30,
-  create: async () => randomNumeric(passwordToken.entropy),
-  encode: async (value, encryptedKey, sub) =>
-    createSecretHash(value).then((hash) => encrypt(hash, encryptedKey, sub)),
-  decode: async (value, encryptedKey, sub) => decrypt(value, encryptedKey, sub),
-  verify: async (value, hash) => verifySecretHash(hash, value)
-}
-
-export const oneTimeSecret = {
-  type: 'secret',
-  entropy: 64, //
-  charPool: characterPoolSize.base64,
-  otp: false,
-  expire: null,
-  create: async () => randomBase64(oneTimeSecret.entropy),
-  encode: async (value, encryptedKey, sub) => encrypt(value, encryptedKey, sub),
-  decode: async (value, encryptedKey, sub) => decrypt(value, encryptedKey, sub)
-  // create, hash, verify to be handled within
-}
-export const oneTimeToken = {
-  type: 'token',
-  entropy: 20,
-  charPool: characterPoolSize.numeric,
-  otp: true,
-  expire: 30
-  // create, hash, verify to be handled within
-}
-
-// aka lookup secret
-export const recoveryCode = {
-  type: 'secret',
-  entropy: 112,
-  charPool: characterPoolSize.alphaNumeric,
-  otp: true,
-  create: async () => randomAlphaNumeric(recoveryCode.entropy),
-  encode: async (value, encryptedKey, sub) =>
-    createSecretHash(value).then((hash) => encrypt(hash, encryptedKey, sub)),
-  decode: async (value, encryptedKey, sub) => decrypt(value, encryptedKey, sub),
-  verify: async (value, hash) => verifySecretHash(hash, value)
-}
-
-export const outOfBandToken = {
-  type: 'token',
-  entropy: 20,
-  charPool: characterPoolSize.numeric,
-  otp: true,
-  expire: 10 * 60,
-  create: async () => randomNumeric(outOfBandToken.entropy),
-  encode: async (value, encryptedKey, sub) =>
-    createSecretHash(value).then((hash) => encrypt(hash, encryptedKey, sub)),
-  decode: async (value, encryptedKey, sub) => decrypt(value, encryptedKey, sub),
-  verify: async (value, hash) => verifySecretHash(hash, value)
-}
-
-export const accessToken = {
-  type: 'secret',
-  entropy: 112,
-  charPool: characterPoolSize.alphaNumeric,
-  otp: false,
-  expire: 30 * 24 * 60 * 60, // allow override from user
-  create: async () => randomAlphaNumeric(accessToken.entropy),
-  encode: async (value, encryptedKey, sub) =>
-    createSecretHash(value).then((hash) => encrypt(hash, encryptedKey, sub)),
-  decode: async (value, encryptedKey, sub) => decrypt(value, encryptedKey, sub),
-  verify: async (value, hash) => verifySecretHash(hash, value)
-}
-
 // *** Helpers *** //
-export const characterLengthToEntropy = (
+// Ref: https://therootcompany.com/blog/how-many-bits-of-entropy-per-character/
+export const entropyToCharacterLength = (bits, characterPoolSize) => {
+	// bits*ln(2)/ln(characterPoolSize)
+	return Math.ceil((bits * Math.LN2) / Math.log(characterPoolSize));
+};
+/* export const characterLengthToEntropy = (
   characterLength,
-  characterPoolSize
+  characterPoolSize,
 ) => {
   // log_2(characterPoolSize^characterLength)
-  return Math.round(Math.log2(characterPoolSize ** characterLength))
-}
+  return Math.floor(Math.log2(characterPoolSize ** characterLength));
+}; */
 
-export const entropyToCharacterLength = (bits, characterPoolSize) => {
-  // bits*ln(2)/ln(characterPoolSize)
-  return Math.round((bits * Math.LN2) / Math.log(characterPoolSize))
-}
+// *** Random generators *** //
+export { randomBytes, randomInt, randomUUID } from "node:crypto";
+
+export const charactersNumeric = "0123456789";
+export const charactersAlphaUpper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+export const charactersAlphaLower = "abcdefghijklmnopqrstuvwxyz";
+export const charactersAlpha = charactersAlphaUpper + charactersAlphaLower;
+export const charactersAlphaNumeric = charactersAlpha + charactersNumeric;
+export const charactersDistinguishable = "CDEHKMPRTUWXY012458";
+
+const randomCharactersCache = {
+	charactersAlphaNumeric: customAlphabet(charactersAlphaNumeric),
+};
+export const randomCharacters = (
+	length,
+	characters = charactersAlphaNumeric,
+) => {
+	randomCharactersCache[characters] ??= customAlphabet(characters);
+	return randomCharactersCache[characters](length);
+};
+
+export const randomAlphaNumeric = (characterLength) => {
+	return randomCharacters(characterLength, charactersAlphaNumeric);
+};
+
+export const randomNumeric = (characterLength) => {
+	let value = "";
+	for (let i = characterLength; i--; ) {
+		value += randomInt(9);
+	}
+	return value;
+};
+
+// *** configs *** //
+// Input: {id, prefix, entropy, characters, opt, expire}
+// Output: {id, type, opt, expire, create, ...}
+export const makeRandomConfigObject = ({
+	id,
+	prefix = "",
+	entropy = 64,
+	characters = charactersAlphaNumeric,
+	...params
+} = {}) => {
+	const minLength = entropyToCharacterLength(entropy, characters.length);
+	const config = {
+		id,
+		type: "id",
+		create: () => prefix + randomCharacters(minLength, characters),
+		...params,
+	};
+	return config;
+};
 
 // *** Digests *** //
-export const createDigest = async (value, { algorithm, salt } = {}) => {
-  algorithm ??= options.digestAlgorithm
-  salt ??= options.digestSalt
-  const hash = checksum(algorithm)
-    .update(value + salt)
-    .digest('hex')
-  return `${algorithm}:${hash}`
-}
+export const randomChecksumSalt = () => {
+	return randomBytes(32); // 256 bits
+};
+export const randomChecksumPepper = () => {
+	return randomIV(); // 96
+};
+
+export const createSaltedValue = (value, { checksumSalt } = {}) => {
+	checksumSalt ??= options.digestChecksumSalt;
+	if (!checksumSalt) {
+		return value;
+	}
+	const newValue = value + checksumSalt;
+	return newValue;
+};
+export const createPepperedValue = (
+	value,
+	{ checksumPepper, encryptionKey } = {},
+) => {
+	checksumPepper ??= options.digestChecksumPepper;
+	encryptionKey ??= options.symmetricEncryptionKey;
+	if (!checksumPepper || !encryptionKey) {
+		return value;
+	}
+	const newValue = symmetricEncrypt(value, {
+		encryptionKey,
+		sub: "",
+		iv: checksumPepper,
+	});
+	return newValue;
+};
+
+export const createChecksum = (value, { hashAlgorithm, encoding } = {}) => {
+	hashAlgorithm ??= options.digestChecksumHashAlgorithm;
+	encoding ??= options.digestChecksumEncoding;
+	return createHash(hashAlgorithm).update(value).digest(encoding);
+};
+export const createSeasonedChecksum = (
+	value,
+	{ hashAlgorithm, encoding, checksumSalt, checksumPepper } = {},
+) => {
+	return createChecksum(
+		createPepperedValue(createSaltedValue(value, { checksumSalt }), {
+			checksumPepper,
+		}),
+		{
+			hashAlgorithm,
+			encoding,
+		},
+	);
+};
+
+export const createDigest = (value, { hashAlgorithm, encoding } = {}) => {
+	hashAlgorithm ??= options.digestChecksumHashAlgorithm;
+	const checksum = createChecksum(value, { hashAlgorithm, encoding });
+	return `${hashAlgorithm}:${checksum}`;
+};
+export const createSaltedDigest = (
+	value,
+	{ hashAlgorithm, encoding, checksumSalt } = {},
+) => {
+	hashAlgorithm ??= options.digestChecksumHashAlgorithm;
+	const checksum = createChecksum(createSaltedValue(value, { checksumSalt }), {
+		hashAlgorithm,
+		encoding,
+	});
+	return `${hashAlgorithm}:${checksum}`;
+};
+export const createPepperedDigest = (
+	value,
+	{ hashAlgorithm, encoding, checksumPepper, encryptionKey } = {},
+) => {
+	hashAlgorithm ??= options.digestChecksumHashAlgorithm;
+	const checksum = createChecksum(
+		createPepperedValue(value, { checksumPepper, encryptionKey }),
+		{
+			hashAlgorithm,
+			encoding,
+		},
+	);
+	return `${hashAlgorithm}:${checksum}`;
+};
+export const createSeasonedDigest = (
+	value,
+	{ hashAlgorithm, encoding, checksumSalt, checksumPepper, encryptionKey } = {},
+) => {
+	hashAlgorithm ??= options.digestChecksumHashAlgorithm;
+	const checksum = createSeasonedChecksum(value, {
+		hashAlgorithm,
+		encoding,
+		checksumSalt,
+		checksumPepper,
+		encryptionKey,
+	});
+	return `${hashAlgorithm}:${checksum}`;
+};
 
 // *** Hashing *** //
-const hashOptions = {
-  timeCost: 3,
-  memoryCost: 2 ** 16,
-  saltLength: 16,
-  parallelism: 1,
-  outputLen: 64, // hashLength: 128
-  algorithm: 2,
-  version: 1
-}
-
-export const createSecretHash = async (value, options = hashOptions) => {
-  return secretHash(value, options)
-}
+const argon2Options = {
+	algorithm: "argon2id",
+	version: 19,
+	parallelism: 1, // Default 1
+	memoryCost: 15, // memory 2^memoryCost // Default 2 ** 12 = 4MB
+	timeCost: 3, // Default 3
+	nonceLength: 16,
+	hashLength: 64, // hashLength: 128 // Default 32
+
+	secret: undefined, // pepper
+	associatedData: undefined, // sub
+};
+export const encodeArgon2 = ({
+	algorithm,
+	version,
+	memoryCost,
+	timeCost,
+	parallelism,
+	nonce,
+	hash,
+} = {}) => {
+	return `$${algorithm}$v=${version}$m=${memoryCost},t=${timeCost},p=${parallelism}$${nonce.toString(options.defaultEncoding)}$${hash.toString(options.defaultEncoding)}`;
+};
+export const decodeArgon2 = (str) => {
+	const argon2Options = {};
+	const optionMap = {
+		m: "memoryCost",
+		t: "timeCost",
+		p: "parallelism",
+	};
+	let [, algorithm, version, variables, nonce, hash] = str.split("$");
+
+	if (version) {
+		version = Number.parseInt(version.replace("v=", ""), 10);
+	}
+	nonce = Buffer.from(nonce, options.defaultEncoding);
+	hash = Buffer.from(hash, options.defaultEncoding);
+	const nonceLength = Buffer.byteLength(nonce);
+	const hashLength = Buffer.byteLength(hash);
+	Object.assign(argon2Options, {
+		algorithm,
+		version,
+		nonce,
+		nonceLength,
+		hash,
+		hashLength,
+	});
+	for (const pair of variables.split(",")) {
+		const [key, value] = pair.split("=");
+		argon2Options[optionMap[key]] = Number.parseInt(value, 10);
+	}
+	return argon2Options;
+};
+
+export const createArgon2 = (
+	message,
+	{
+		algorithm,
+		version,
+		parallelism,
+		memoryCost,
+		timeCost,
+		nonceLength,
+		hashLength,
+	} = {},
+) => {
+	algorithm ??= options.secretArgon2Algorithm;
+	version ??= options.secretArgon2Version;
+	memoryCost ??= options.secretArgon2MemoryCost;
+	timeCost ??= options.secretArgon2TimeCost;
+	parallelism ??= options.secretArgon2Parallelism;
+	nonceLength ??= options.secretArgon2NonceLength;
+	hashLength ??= options.secretArgon2HashLength;
+
+	const nonce = randomBytes(nonceLength);
+	const hash = argon2Sync(algorithm, {
+		message,
+		nonce,
+		parallelism,
+		memory: 2 ** memoryCost,
+		passes: timeCost,
+		tagLength: hashLength,
+	});
+	return encodeArgon2({
+		algorithm,
+		version,
+		memoryCost,
+		timeCost,
+		parallelism,
+		nonce,
+		hash,
+	});
+};
+export const verifyArgon2 = (derivedKey, message) => {
+	const {
+		algorithm,
+		memoryCost,
+		timeCost,
+		parallelism,
+		nonce,
+		hash,
+		hashLength,
+	} = decodeArgon2(derivedKey);
+
+	const verifyHash = argon2Sync(algorithm, {
+		message,
+		nonce,
+		parallelism,
+		memory: 2 ** memoryCost,
+		passes: timeCost,
+		tagLength: hashLength,
+	});
+	return timingSafeEqual(hash, verifyHash);
+};
+
+export const createSecretHash = async (value, options) => {
+	return createArgon2(value, options);
+};
 
 export const verifySecretHash = async (hash, value) => {
-  return secretVerify(hash, value)
-}
-
-// *** Encryption *** //
-const authTagLength = 16
-
-export const makeSymetricKey = (assocData) => {
-  if (!options.encryptionSharedKey) {
-    return { encryptionKey: '', encryptedKey: '' }
-  }
-  const encryptionKey = randomBytes(32)
-  const encryptedKey = __encrypt(
-    encryptionKey,
-    Buffer.from(options.encryptionSharedKey, 'hex'),
-    assocData,
-    'hex',
-    'hex'
-  )
-  return { encryptionKey, encryptedKey }
-}
-
-export const encrypt = (data, encryptedKey, assocData) => {
-  if (!encryptedKey) return data
-
-  const encryptionKey = __decrypt(
-    encryptedKey,
-    Buffer.from(options.encryptionSharedKey, 'hex'),
-    assocData,
-    'hex',
-    'hex'
-  )
-  return __encrypt(
-    data,
-    Buffer.from(encryptionKey, 'hex'),
-    assocData,
-    'utf8',
-    'hex'
-  )
-}
-
-const __encrypt = (
-  data,
-  encryptionKey,
-  assocData,
-  decoding = 'utf8',
-  encoding = 'hex'
+	return verifyArgon2(hash, value);
+};
+
+// *** Symmetric Encryption *** //
+const authTagLength = 16;
+
+export const symmetricRandomEncryptionKey = () => {
+	return randomBytes(32); // 256 bits
+};
+
+export const randomIV = () => {
+	return randomBytes(12); // 96 bits
+};
+
+export const symmetricGenerateEncryptionKey = (
+	sub,
+	{ encryptionKey, signatureSecret } = {},
+) => {
+	encryptionKey ??= options.symmetricEncryptionKey;
+	signatureSecret ??= options.symemeticSignatureSecret;
+
+	const rowEncryptionKey = symmetricRandomEncryptionKey();
+	const rowEncryptedKey = symmetricEncrypt(rowEncryptionKey, {
+		encryptionKey,
+		signatureSecret,
+		sub,
+	});
+	return { encryptionKey: rowEncryptionKey, encryptedKey: rowEncryptedKey };
+};
+
+// sub add context to encryption
+export const symmetricEncryptFields = (
+	values,
+	{ encryptedKey, encryptionKey, signatureSecret, sub },
+	fields = [],
+) => {
+	if (encryptedKey) {
+		encryptionKey ??= symmetricDecryptKey(encryptedKey, {
+			signatureSecret,
+			sub,
+		});
+	}
+	if (!encryptionKey) return values;
+	const encryptedValues = structuredClone(values);
+	for (const key of fields) {
+		encryptedValues[key] &&= symmetricEncrypt(encryptedValues[key], {
+			encryptionKey,
+			signatureSecret,
+			sub,
+		});
+	}
+	return encryptedValues;
+};
+
+export const symmetricEncrypt = (
+	data,
+	{ encryptedKey, encryptionKey, signatureSecret, sub, decoding, encoding, iv },
+) => {
+	if (encryptedKey) {
+		encryptionKey ??= symmetricDecryptKey(encryptedKey, {
+			signatureSecret,
+			sub,
+		});
+	}
+	if (!encryptionKey || !data) return data;
+	decoding ??= "utf8";
+	encoding ??= options.symmetricEncryptionEncoding;
+	iv ??= randomIV();
+	const cipher = createCipheriv(
+		options.symmetricEncryptionAlgorithm,
+		encryptionKey,
+		iv,
+		{
+			authTagLength,
+		},
+	);
+	cipher.setAAD(sub);
+	const encryptedData =
+		cipher.update(data, decoding, encoding) + cipher.final(encoding);
+	const authTag = cipher.getAuthTag();
+
+	const encryptedDataPacket =
+		iv.toString(encoding) + authTag.toString(encoding) + encryptedData;
+
+	// add signature to end
+	return symmetricSignatureSign(encryptedDataPacket, { signatureSecret });
+};
+
+export const symmetricDecryptFields = (
+	encryptedValues,
+	{ encryptedKey, encryptionKey, signatureSecret, sub },
+	fields = [],
+) => {
+	if (encryptedKey) {
+		encryptionKey ??= symmetricDecryptKey(encryptedKey, {
+			signatureSecret,
+			sub,
+		});
+	}
+	if (!encryptionKey) return encryptedValues;
+	const values = structuredClone(encryptedValues);
+	for (const key of fields) {
+		values[key] &&= symmetricDecrypt(values[key], {
+			encryptionKey,
+			signatureSecret,
+			sub,
+		});
+	}
+	return values;
+};
+
+export const symmetricDecryptKey = (
+	encryptedKey,
+	{ sub, encryptionKey, signatureSecret } = {},
+) => {
+	encryptionKey ??= options.symmetricEncryptionKey;
+	signatureSecret ??= options.symemeticSignatureSecret;
+	return Buffer.from(
+		symmetricDecrypt(encryptedKey, {
+			encryptionKey,
+			signatureSecret,
+			sub,
+			encoding: options.symmetricEncryptionEncoding,
+		}),
+		options.symmetricEncryptionEncoding,
+	);
+};
+
+export const symmetricDecrypt = (
+	signedEncryptedDataPacket,
+	{ encryptedKey, encryptionKey, signatureSecret, sub, decoding, encoding },
+) => {
+	if (encryptedKey) {
+		encryptionKey ??= symmetricDecryptKey(encryptedKey, {
+			signatureSecret,
+			sub,
+		});
+	}
+	if (!encryptionKey || !signedEncryptedDataPacket)
+		return signedEncryptedDataPacket;
+	decoding ??= options.symmetricEncryptionEncoding;
+	encoding ??= "utf8";
+
+	// remove signature when successful
+	const encryptedDataPacket = symmetricSignatureVerify(
+		signedEncryptedDataPacket,
+		{
+			signatureSecret,
+		},
+	);
+
+	if (encryptedDataPacket === false) {
+		throw new Error("Signature incorrect");
+	}
+	const iv = Buffer.from(
+		encryptedDataPacket.substring(0, symmetricEncryptionEncodingLengths.iv),
+		decoding,
+	);
+	const authTag = Buffer.from(
+		encryptedDataPacket.substring(
+			symmetricEncryptionEncodingLengths.iv,
+			symmetricEncryptionEncodingLengths.ivAndAuthTag,
+		),
+		decoding,
+	);
+	const encryptedData = Buffer.from(
+		encryptedDataPacket.substring(
+			symmetricEncryptionEncodingLengths.ivAndAuthTag,
+		),
+		decoding,
+	);
+
+	const decipher = createDecipheriv(
+		options.symmetricEncryptionAlgorithm,
+		encryptionKey,
+		iv,
+		{
+			authTagLength,
+		},
+	);
+	decipher.setAAD(sub);
+
+	decipher.setAuthTag(authTag);
+	const data =
+		decipher.update(encryptedData, decoding, encoding) +
+		decipher.final(encoding);
+	return data;
+};
+
+// *** Symmetric Signatures *** //
+export const symmetricRandomSignatureSecret = () => {
+	return randomBytes(32); // 256 bits
+};
+
+export const symmetricGenerateSignatureSecret = () => {
+	const signatureSecret = symmetricRandomSignatureSecret();
+	return { signatureSecret };
+};
+
+export const symmetricSignatureSign = (
+	data,
+	{ hashAlgorithm, signatureSecret } = {},
+) => {
+	signatureSecret ??= options.symmetricSignatureSecret;
+	hashAlgorithm ??= options.symmetricSignatureHashAlgorithm;
+	const signature = createHmac(hashAlgorithm, signatureSecret)
+		.update(data)
+		.digest(options.symmetricSignatureEncoding)
+		.replace(/=+$/, "");
+
+	const signedData = `${data}.${signature}`;
+	return signedData;
+};
+
+export const symmetricSignatureVerify = (
+	signedData,
+	{ hashAlgorithm, signatureSecret } = {},
+) => {
+	if (typeof signedData !== "string") return false;
+	let lastIndexOf = signedData.lastIndexOf(".");
+	// Test for unsigned
+	if (lastIndexOf < 0) {
+		lastIndexOf = signedData.length;
+	}
+	const data = signedData.substring(0, lastIndexOf);
+	const signedDataExpected = symmetricSignatureSign(data, {
+		hashAlgorithm,
+		signatureSecret,
+	});
+	return safeEqual(signedData, signedDataExpected) && data;
+};
+
+// Allow rotation of global encryption key, global signature secret, and row encryption key
+export const symmetricRotation = (
+	oldEncryptedValues,
+	oldOptions, // { encryptionKey, signatureSecret, sub, decoding, encoding }, // old
+	oldFields,
+	newOptions, // { encryptionKey, signatureSecret, sub, decoding, encoding }, // new
+	newFields,
+	transform = (data) => {
+		return data;
+	},
 ) => {
-  const iv = randomBytes(12) // 96 bits
-  const cipher = createCipheriv(options.encryptionMethod, encryptionKey, iv, {
-    authTagLength
-  })
-  cipher.setAAD(Buffer.from(assocData, 'utf8'))
-  const encryptedData =
-    cipher.update(data, decoding, encoding) + cipher.final(encoding)
-  const authTag = cipher.getAuthTag()
-  return (
-    iv.toString(encoding) + // 24 char
-    authTag.toString(encoding) + // 32 char
-    encryptedData
-  )
-}
-
-export const decrypt = (encryptedData, encryptedKey, assocData) => {
-  if (!options.encryptionSharedKey || !encryptedKey) return encryptedData
-  const encryptionKey = __decrypt(
-    encryptedKey,
-    Buffer.from(options.encryptionSharedKey, 'hex'),
-    assocData,
-    'hex',
-    'hex'
-  )
-  const data = __decrypt(
-    encryptedData,
-    Buffer.from(encryptionKey, 'hex'),
-    assocData,
-    'hex',
-    'utf8'
-  )
-  return data
-}
-
-const __decrypt = (
-  data,
-  encryptionKey,
-  assocData,
-  decoding = 'hex',
-  encoding = 'utf8'
+	if (oldOptions.sub !== newOptions.sub) throw new Error("Mismatching `sub`");
+
+	const oldEncryptedValuesClone = structuredClone(oldEncryptedValues);
+	// Don't use structuredClone, converts Buffer to Uint8Array ...
+	const oldOptionsClone = { ...oldOptions };
+	const newOptionsClone = { ...(newOptions ?? oldOptions) };
+
+	// decrypt old encryption key
+	const { encryptionKey: oldEncryptedKey } = oldEncryptedValuesClone;
+	oldEncryptedValuesClone.encryptionKey = undefined;
+
+	const oldEncryptionKey = symmetricDecryptKey(
+		oldEncryptedKey,
+		oldOptionsClone,
+	);
+	oldOptionsClone.encryptionKey = oldEncryptionKey;
+
+	// decrypt
+	const data = transform(
+		symmetricDecryptFields(
+			oldEncryptedValuesClone,
+			{ ...oldOptionsClone, encryptionKey: oldEncryptionKey },
+			oldFields,
+		),
+	);
+
+	// rotate encryptionKey
+	const { encryptionKey: newEncryptionKey, encryptedKey: newEncryptedKey } =
+		symmetricGenerateEncryptionKey(newOptionsClone.sub, newOptionsClone);
+	newOptionsClone.encryptionKey = newEncryptionKey;
+
+	// encrypt
+	const newEncryptedValues = symmetricEncryptFields(
+		data,
+		newOptionsClone,
+		newFields ?? oldFields,
+	);
+	newEncryptedValues.encryptionKey = newEncryptedKey;
+
+	return newEncryptedValues;
+};
+
+// *** Asymmetric Signatures *** //
+// asymmetricKeyPairType
+export const makeAsymmetricKeys = async () => {
+	const { publicKey, privateKey } = await generateKeyPair("ec", {
+		namedCurve: options.asymmetricKeyNamedCurve,
+		paramEncoding: "named",
+		publicKeyEncoding: {
+			type: "spki",
+			format: "pem",
+		},
+		privateKeyEncoding: {
+			type: "sec1",
+			format: "pem",
+			// Encryption done at another level for consistency
+			// cipher: options.asymmetricEncryptionAlgorithm,
+			// passphrase: encryptionKey,
+		},
+	});
+	return { publicKey, privateKey };
+};
+
+export const makeAsymmetricSignature = async (
+	data,
+	privateKey,
+	{ hashAlgorithm } = {},
 ) => {
-  const iv = Buffer.from(data.substring(0, 24), decoding)
-  const authTag = Buffer.from(data.substring(24, 56), decoding)
-  const encryptedData = Buffer.from(data.substring(56), decoding)
-
-  const decipher = createDecipheriv(
-    options.encryptionMethod,
-    encryptionKey,
-    iv,
-    {
-      authTagLength
-    }
-  )
-  decipher.setAAD(Buffer.from(assocData, 'utf8'))
-  decipher.setAuthTag(authTag)
-  return (
-    decipher.update(encryptedData, decoding, encoding) +
-    decipher.final(encoding)
-  )
-}
-
-// *** Signatures *** //
-export const makeAsymmetricKeys = async (encryptionKey) => {
-  const { publicKey, privateKey } = await generateKeyPair('ec', {
-    namedCurve: 'P-384', // P-512
-    paramEncoding: 'named',
-    publicKeyEncoding: {
-      type: 'spki',
-      format: 'pem'
-    },
-    privateKeyEncoding: {
-      type: 'sec1',
-      format: 'pem',
-      // TODO remove encryption for other with sub check?
-      cipher: options.encryptionMethod,
-      passphrase: encryptionKey
-    }
-  })
-  return { publicKey, privateKey }
-}
-
-export const makeSignature = (data, privateKey, algorithm = 'SHA3-256') => {
-  return sign(algorithm, Buffer.from(data), privateKey).toString('base64')
-}
-export const verifySignature = (
-  data,
-  publicKey,
-  signature,
-  algorithm = 'SHA3-256'
+	hashAlgorithm ??= options.asymmetricSignatureHashAlgorithm;
+	return (await sign(hashAlgorithm, Buffer.from(data), privateKey)).toString(
+		options.asymmetricSignatureEncoding,
+	);
+};
+export const verifyAsymmetricSignature = async (
+	data,
+	publicKey,
+	signature,
+	{ hashAlgorithm } = {},
 ) => {
-  return verify(
-    algorithm,
-    Buffer.from(data),
-    publicKey,
-    Buffer.from(signature, 'base64')
-  )
-}
-// const assocData = 'sub'
-// const input = 'data'
-//
-// const {encryptedKey} = makeSymetricKey(assocData)
-// const encryptedData = encrypt(input, encryptedKey, assocData)
-// const output = decrypt(encryptedData, encryptedKey, assocData)
-// console.log(assocData, input, output, encryptedData)
-
-// const assocData = 'tlSIcVp1XEF'
-// const encryptionKey =
-//   'b9ebfdab6603dd8e151138ec8298aaf8b49bf6d38480f9864e9e72e65c4d8b59.b9f9bc89d7f3ce4aa1e1af469d10508b.aa1b6a682fcc186e867a9cfd'
-// const value =
-//   '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.a5237f2d798c9f98b26a676794d3c3f6.0f15d0f53657150aeb1462d5'
-// const output = decrypt(value, encryptionKey, assocData)
-// console.log(output)
-// *** TOTP *** //
+	hashAlgorithm ??= options.asymmetricSignatureHashAlgorithm;
+	return await verify(
+		hashAlgorithm,
+		Buffer.from(data),
+		publicKey,
+		Buffer.from(signature, options.asymmetricSignatureEncoding),
+	);
+};
+
+export const safeEqual = (input, expected) => {
+	const bufferInput = Buffer.from(input);
+	const bufferExpected = Buffer.from(expected);
+	return (
+		bufferInput.length === bufferExpected.length &&
+		timingSafeEqual(bufferInput, bufferExpected)
+	);
+};

package/package.json

@@ -1,55 +1,55 @@
 {
-  "name": "@1auth/crypto",
-  "version": "0.0.0-alpha.9",
-  "description": "",
-  "type": "module",
-  "engines": {
-    "node": ">=16"
-  },
-  "engineStrict": true,
-  "publishConfig": {
-    "access": "public"
-  },
-  "main": "./index.js",
-  "module": "./index.js",
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./index.d.ts",
-        "default": "./index.js"
-      }
-    }
-  },
-  "types": "index.d.ts",
-  "files": [
-    "index.js",
-    "index.d.ts"
-  ],
-  "scripts": {
-    "test": "npm run test:unit",
-    "test:unit": "ava"
-  },
-  "license": "MIT",
-  "funding": {
-    "type": "github",
-    "url": "https://github.com/sponsors/willfarrell"
-  },
-  "keywords": [],
-  "author": {
-    "name": "1auth contributors",
-    "url": "https://github.com/willfarrell/1auth/graphs/contributors"
-  },
-  "repository": {
-    "type": "git",
-    "url": "github:willfarrell/1auth",
-    "directory": "packages/crypto"
-  },
-  "bugs": {
-    "url": "https://github.com/willfarrell/1auth/issues"
-  },
-  "homepage": "https://github.com/willfarrell/1auth",
-  "gitHead": "d21e1013f55ed05af4daf980bc4dfdfd52538792",
-  "dependencies": {
-    "@node-rs/argon2": "1.5.0"
-  }
+	"name": "@1auth/crypto",
+	"version": "0.0.0-beta.1",
+	"description": "",
+	"type": "module",
+	"engines": {
+		"node": ">=24"
+	},
+	"engineStrict": true,
+	"publishConfig": {
+		"access": "public"
+	},
+	"main": "./index.js",
+	"module": "./index.js",
+	"exports": {
+		".": {
+			"import": {
+				"types": "./index.d.ts",
+				"default": "./index.js"
+			}
+		}
+	},
+	"types": "index.d.ts",
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"scripts": {
+		"test": "npm run test:unit",
+		"test:unit": "node --test"
+	},
+	"license": "MIT",
+	"funding": {
+		"type": "github",
+		"url": "https://github.com/sponsors/willfarrell"
+	},
+	"keywords": [],
+	"author": {
+		"name": "1auth contributors",
+		"url": "https://github.com/willfarrell/1auth/graphs/contributors"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/willfarrell/1auth.git",
+		"directory": "packages/crypto"
+	},
+	"bugs": {
+		"url": "https://github.com/willfarrell/1auth/issues"
+	},
+	"homepage": "https://github.com/willfarrell/1auth",
+	"gitHead": "7a6c0fbb8ab71d6a2171e678697de9f237568431",
+	"dependencies": {
+		"nanoid": "5.1.6"
+	}
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 will Farrell
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.