@1auth/crypto 0.0.0-alpha.57 → 0.0.0-alpha.59

package/index.js

@@ -1,7 +1,7 @@
 import { promisify } from 'node:util'
 import {
   randomBytes,
-  createHash as checksum,
+  createHash,
   createCipheriv,
   createDecipheriv,
   createHmac,
@@ -18,39 +18,63 @@ const sign = promisify(signCallback)
 const verify = promisify(verifyCallback)
 
 const defaults = {
-  // symmetricEncryptionKey: randomBytes(32).toString('base64') // 256 bits
-  symmetricEncryptionKey: undefined,
-  symmetricEncryptionMethod: 'chacha20-poly1305', // 2024-05: AES-256 GCM (aes-256-gcm) or ChaCha20-Poly1305 (chacha20-poly1305)
-  symmetricEncryptionEncoding: 'base64', // https://nodejs.org/api/buffer.html#buffers-and-character-encodings
-  symmetricSignatureAlgorithm: 'sha3-384',
-  // symmetricSignatureSecret: randomBytes(32).toString('base64') // 256 bits
-  symmetricSignatureSecret: undefined,
+  symmetricEncryptionKey: undefined, // symmetricRandomEncryptionKey()
+  symmetricEncryptionAlgorithm: 'chacha20-poly1305', // 2024-05: 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
-  asymmetricSignatureAlgorithm: 'sha3-384',
-  digestAlgorithm: 'sha3-384',
-  digestEncoding: 'hex',
-  signatureEncoding: 'base64'
+  asymmetricSignatureHashAlgorithm: undefined, // fallback to defaultHashAlgorithm
+  asymmetricSignatureEncoding: undefined, // fallback to defaultEncoding
+  digestChecksumHashAlgorithm: undefined, // fallback to defaultHashAlgorithm
+  digestChecksumEncoding: undefined,
+  digestChecksumSalt: undefined, // randomChecksumSalt()
+  digestChecksumPepper: undefined, // randomChecksumPepper()
+  defaultEncoding: 'base64',
+  defaultHashAlgorithm: 'sha3-384'
 }
 const symmetricEncryptionEncodingLengths = {}
 const options = {}
 export default (opt = {}) => {
   Object.assign(options, defaults, opt)
-  symmetricEncryptionEncodingLengths.iv = randomBytes(12).toString(
-    options.symmetricEncryptionEncoding
-  ).length
-  symmetricEncryptionEncodingLengths.ivAndAuthTag =
-    symmetricEncryptionEncodingLengths.iv +
-    randomBytes(16).toString(options.symmetricEncryptionEncoding).length
+
+  // Check options, set defaults
   if (!options.symmetricEncryptionKey) {
     console.warn(
-      "@1auth/crypto symmetricEncryptionKey is empty, use a stored secret made from randomBytes(32).toString('base64'). Encryption disabled."
+      '@1auth/crypto symmetricEncryptionKey is empty, use a stored secret made from randomBytes(32) Encryption disabled.'
     )
   }
+  options.symmetricEncryptionEncoding ??= options.defaultEncoding
+  options.symmetricSignatureHashAlgorithm ??= options.defaultHashAlgorithm
   if (!options.symmetricSignatureSecret) {
     console.warn(
-      "@1auth/crypto symmetricSignatureSecret is empty, use a stored secret made from randomBytes(32).toString('base64'). Signature disabled."
+      '@1auth/crypto symmetricSignatureSecret is empty, use a stored secret made from randomBytes(32). Signature disabled.'
     )
   }
+  options.symmetricSignatureEncoding ??= options.defaultEncoding
+  options.asymmetricSignatureHashAlgorithm ??= options.defaultHashAlgorithm
+  options.asymmetricSignatureEncoding ??= options.defaultEncoding
+  if (!options.digestChecksumSalt) {
+    console.warn(
+      '@1auth/crypto digestChecksumSalt is empty, use a stored secret made from randomBytes(32). Checksum salting disabled.'
+    )
+  }
+  if (!options.digestChecksumPepper) {
+    console.warn(
+      '@1auth/crypto digestChecksumPepper is empty, use a stored secret made from randomBytes(12). Checksum peppering disabled.'
+    )
+  }
+  options.digestChecksumHashAlgorithm ??= options.defaultHashAlgorithm
+  options.digestChecksumEncoding ??= options.defaultEncoding
+
+  // Lengths
+  symmetricEncryptionEncodingLengths.iv = randomIV().toString(
+    options.symmetricEncryptionEncoding
+  ).length
+  symmetricEncryptionEncodingLengths.ivAndAuthTag =
+    symmetricEncryptionEncodingLengths.iv +
+    randomBytes(16).toString(options.symmetricEncryptionEncoding).length
 }
 
 export const getOptions = () => options
@@ -86,13 +110,13 @@ export const entropyToCharacterLength = (bits, characterPoolSize) => {
 }; */
 
 // *** Random generators *** //
-// Ref: https://github.com/sindresorhus/crypto-random-string/blob/main/core.js
-export const charactersAlphaNumeric = [
-  ...'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
+export const charactersAlpha = [
+  ...'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
 ]
-export const charactersDistinguishable = [...'CDEHKMPRTUWXY012458']
 export const charactersNumeric = [...'0123456789']
+export const charactersAlphaNumeric = charactersAlpha.concat(charactersNumeric)
 
+// Ref: https://github.com/sindresorhus/crypto-random-string/blob/main/core.js
 export const randomCharacters = (
   length,
   characters = charactersAlphaNumeric
@@ -145,58 +169,101 @@ export const randomId = {
 }
 
 // *** Digests *** //
-export const createChecksum = (value, { algorithm, encoding } = {}) => {
-  algorithm ??= options.digestAlgorithm
-  encoding ??= options.digestEncoding
-  return checksum(algorithm).update(value).digest(encoding)
-}
-export const createDigest = (value, { algorithm } = {}) => {
-  algorithm ??= options.digestAlgorithm
-  const checksum = createChecksum(value, { algorithm })
-  return `${algorithm}:${checksum}`
-}
-
-// TODO evaluate non-iv encryption approach?
-// Use encryption as pepper to allow easier rotation of pepper
-export const createEncryptedDigest = (value, { algorithm } = {}) => {
-  algorithm ??= options.digestAlgorithm
-  const digest = createDigest(value, { algorithm })
-  // encrypting using the symmetricEncryptionKey instead of
-  // the row encryptionKey to allow lookup, must have fixed iv
-  return symmetricEncrypt(digest, {
-    encryptionKey: options.symmetricEncryptionKey,
-    sub: '',
-    encoding: options.symmetricEncryptionEncoding,
-    iv: Buffer.from(
-      options.symmetricEncryptionKey.substring(
-        0,
-        symmetricEncryptionEncodingLengths.iv
-      ),
-      options.symmetricEncryptionEncoding
-    )
-  })
+export const randomChecksumSalt = () => {
+  return randomBytes(32) // 256 bits
+}
+export const randomChecksumPepper = () => {
+  return randomIV() // 96
 }
 
-export const rotateDigestEncryption = (
-  encryptedValue,
-  encryptionKey,
-  newEncryptionKey
+export const createSaltedValue = (value, { checksumSalt } = {}) => {
+  checksumSalt ??= options.digestChecksumSalt
+  if (!checksumSalt) {
+    return value
+  }
+  const newValue = value + checksumSalt
+  return newValue
+}
+export const createPepperedValue = (
+  value,
+  { checksumPepper, encryptionKey } = {}
 ) => {
-  const digest = symmetricDecrypt(encryptedValue, {
+  checksumPepper ??= options.digestChecksumPepper
+  encryptionKey ??= options.symmetricEncryptionKey
+  if (!checksumPepper || !encryptionKey) {
+    return value
+  }
+  const newValue = symmetricEncrypt(value, {
     encryptionKey,
     sub: '',
-    encoding: options.symmetricEncryptionEncoding
+    iv: checksumPepper
   })
+  return newValue
+}
 
-  return symmetricEncrypt(digest, {
-    encryptionKey: newEncryptionKey,
-    sub: '',
-    encoding: options.symmetricEncryptionEncoding,
-    iv: Buffer.from(
-      newEncryptionKey.substring(0, symmetricEncryptionEncodingLengths.iv),
-      options.symmetricEncryptionEncoding
-    )
+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 *** //
@@ -222,31 +289,41 @@ export const verifySecretHash = async (hash, value) => {
 const authTagLength = 16
 
 export const symmetricRandomEncryptionKey = () => {
-  return randomBytes(32).toString('base64') // 256 bits
+  return randomBytes(32) // 256 bits
 }
 
-export const symmetricGenerateEncryptionKey = (sub) => {
-  if (!options.symmetricEncryptionKey) {
+export const randomIV = () => {
+  return randomBytes(12) // 96 bits
+}
+
+export const symmetricGenerateEncryptionKey = (
+  sub,
+  { encryptionKey, signatureSecret } = {}
+) => {
+  encryptionKey ??= options.symmetricEncryptionKey
+  signatureSecret ??= options.symemeticSignatureSecret
+
+  if (!encryptionKey) {
     return { encryptionKey: '', encryptedKey: '' }
   }
-  const encryptionKey = symmetricRandomEncryptionKey()
-  const encryptedKey = symmetricEncrypt(encryptionKey, {
-    encryptionKey: options.symmetricEncryptionKey,
-    sub,
-    decoding: 'base64',
-    encoding: options.symmetricEncryptionEncoding
+  const rowEncryptionKey = symmetricRandomEncryptionKey()
+  const rowEncryptedKey = symmetricEncrypt(rowEncryptionKey, {
+    encryptionKey,
+    signatureSecret,
+    sub
   })
-  return { encryptionKey, encryptedKey }
+  return { encryptionKey: rowEncryptionKey, encryptedKey: rowEncryptedKey }
 }
 
 // sub add context to encryption
 export const symmetricEncryptFields = (
   values,
-  { encryptedKey, encryptionKey, sub },
+  { encryptedKey, encryptionKey, signatureSecret, sub },
   fields = []
 ) => {
   if (encryptedKey) {
     encryptionKey ??= symmetricDecryptKey(encryptedKey, {
+      signatureSecret,
       sub
     })
   }
@@ -255,6 +332,7 @@ export const symmetricEncryptFields = (
   for (const key of fields) {
     encryptedValues[key] &&= symmetricEncrypt(encryptedValues[key], {
       encryptionKey,
+      signatureSecret,
       sub
     })
   }
@@ -267,23 +345,23 @@ export const symmetricEncrypt = (
 ) => {
   if (encryptedKey) {
     encryptionKey ??= symmetricDecryptKey(encryptedKey, {
+      signatureSecret,
       sub
     })
   }
   if (!encryptionKey || !data) return data
   decoding ??= 'utf8'
   encoding ??= options.symmetricEncryptionEncoding
-  iv ??= randomBytes(12) // 96 bits
-
+  iv ??= randomIV()
   const cipher = createCipheriv(
-    options.symmetricEncryptionMethod,
-    Buffer.from(encryptionKey, 'base64'),
+    options.symmetricEncryptionAlgorithm,
+    encryptionKey,
     iv,
     {
       authTagLength
     }
   )
-  cipher.setAAD(Buffer.from(sub ?? '', 'utf8'))
+  cipher.setAAD(sub)
   const encryptedData =
     cipher.update(data, decoding, encoding) + cipher.final(encoding)
   const authTag = cipher.getAuthTag()
@@ -292,7 +370,7 @@ export const symmetricEncrypt = (
     iv.toString(encoding) + authTag.toString(encoding) + encryptedData
 
   // add signature to end
-  return symmetricSignatureSign(encryptedDataPacket, signatureSecret)
+  return symmetricSignatureSign(encryptedDataPacket, { signatureSecret })
 }
 
 export const symmetricDecryptFields = (
@@ -302,6 +380,7 @@ export const symmetricDecryptFields = (
 ) => {
   if (encryptedKey) {
     encryptionKey ??= symmetricDecryptKey(encryptedKey, {
+      signatureSecret,
       sub
     })
   }
@@ -310,19 +389,28 @@ export const symmetricDecryptFields = (
   for (const key of fields) {
     values[key] &&= symmetricDecrypt(values[key], {
       encryptionKey,
+      signatureSecret,
       sub
     })
   }
   return values
 }
 
-export const symmetricDecryptKey = (encryptedKey, { sub } = {}) => {
-  return symmetricDecrypt(encryptedKey, {
-    encryptionKey: options.symmetricEncryptionKey,
-    sub,
-    decoding: options.symmetricEncryptionEncoding,
-    encoding: 'base64'
-  })
+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 = (
@@ -331,6 +419,7 @@ export const symmetricDecrypt = (
 ) => {
   if (encryptedKey) {
     encryptionKey ??= symmetricDecryptKey(encryptedKey, {
+      signatureSecret,
       sub
     })
   }
@@ -339,15 +428,13 @@ export const symmetricDecrypt = (
   encoding ??= 'utf8'
 
   // remove signature when successful
-  encryptedDataPacket = symmetricSignatureVerify(
-    encryptedDataPacket,
+  encryptedDataPacket = symmetricSignatureVerify(encryptedDataPacket, {
     signatureSecret
-  )
+  })
 
   if (encryptedDataPacket === false) {
     throw new Error('Signature incorrect')
   }
-
   const iv = Buffer.from(
     encryptedDataPacket.substring(0, symmetricEncryptionEncodingLengths.iv),
     decoding
@@ -367,14 +454,14 @@ export const symmetricDecrypt = (
   )
 
   const decipher = createDecipheriv(
-    options.symmetricEncryptionMethod,
-    Buffer.from(encryptionKey, 'base64'),
+    options.symmetricEncryptionAlgorithm,
+    encryptionKey,
     iv,
     {
       authTagLength
     }
   )
-  decipher.setAAD(Buffer.from(sub ?? '', 'utf8'))
+  decipher.setAAD(sub)
 
   decipher.setAuthTag(authTag)
   const data =
@@ -385,10 +472,10 @@ export const symmetricDecrypt = (
 
 // *** Symmetric Signatures *** //
 export const symmetricRandomSignatureSecret = () => {
-  return randomBytes(32).toString('base64') // 256 bits
+  return randomBytes(32) // 256 bits
 }
 
-export const symmetricGenerateSignatureSecret = (sub) => {
+export const symmetricGenerateSignatureSecret = () => {
   if (!options.symmetricSignatureSecret) {
     return { signatureSecret: '' }
   }
@@ -398,15 +485,13 @@ export const symmetricGenerateSignatureSecret = (sub) => {
 
 export const symmetricSignatureSign = (
   data,
-  signatureSecret,
-  { algorithm } = {}
+  { hashAlgorithm, signatureSecret } = {}
 ) => {
-  // if (typeof data !== 'string') throw new TypeError('data must me a string')
   signatureSecret ??= options.symmetricSignatureSecret
-  algorithm ??= options.symmetricSignatureAlgorithm
-  const signature = createHmac(algorithm, signatureSecret)
+  hashAlgorithm ??= options.symmetricSignatureHashAlgorithm
+  const signature = createHmac(hashAlgorithm, signatureSecret)
     .update(data)
-    .digest(options.signatureEncoding)
+    .digest(options.symmetricSignatureEncoding)
     .replace(/=+$/, '')
 
   const signedData = data + '.' + signature
@@ -415,27 +500,73 @@ export const symmetricSignatureSign = (
 
 export const symmetricSignatureVerify = (
   signedData,
-  signatureSecret,
-  { algorithm } = {}
+  { hashAlgorithm, signatureSecret } = {}
 ) => {
   if (typeof signedData !== 'string') return false
-  const data = signedData.slice(0, signedData.lastIndexOf('.'))
-  const signedDataExpected = symmetricSignatureSign(data, signatureSecret, {
-    algorithm
+  let lastIndexOf = signedData.lastIndexOf('.')
+  // Test for unsigned
+  if (lastIndexOf < 0) {
+    lastIndexOf = signedData.length
+  }
+  const data = signedData.slice(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 = (
-  encryptedValues,
-  oldOptions, // { encryptedKey, encryptionKey, signatureSecret, sub }, // old
-  newOptions, // { encryptedKey, encryptionKey, signatureSecret, sub, decoding, encoding, iv }, // new
-  fields = []
+  oldEncryptedValues,
+  oldOptions, // { encryptionKey, signatureSecret, sub, decoding, encoding }, // old
+  oldFields = [],
+  newOptions, // { encryptionKey, signatureSecret, sub, decoding, encoding }, // new
+  newFields,
+  transform = (data) => {
+    return data
+  }
 ) => {
-  const data = symmetricDecryptFields(encryptedValues, oldOptions, fields)
-  const newEncryptedData = symmetricEncryptFields(data, newOptions, fields)
-  return newEncryptedData
+  newOptions ??= oldOptions
+  newFields ??= oldFields
+
+  if (oldOptions.sub !== newOptions.sub) throw new Error('Mismatching `sub`')
+
+  oldEncryptedValues = structuredClone(oldEncryptedValues)
+  // Don't use structuredClone, converts Buffer to Uint8Array ...
+  oldOptions = { ...oldOptions }
+  newOptions = { ...newOptions }
+
+  // decrypt old encryption key
+  const { encryptionKey: oldEncryptedKey } = oldEncryptedValues
+  delete oldEncryptedValues.encryptionKey
+
+  const oldEncryptionKey = symmetricDecryptKey(oldEncryptedKey, oldOptions)
+  oldOptions.encryptionKey = oldEncryptionKey
+
+  // decrypt
+  const data = transform(
+    symmetricDecryptFields(
+      oldEncryptedValues,
+      { ...oldOptions, encryptionKey: oldEncryptionKey },
+      oldFields
+    )
+  )
+
+  // rotate encryptionKey
+  const { encryptionKey: newEncryptionKey, encryptedKey: newEncryptedKey } =
+    symmetricGenerateEncryptionKey(newOptions.sub, newOptions)
+  newOptions.encryptionKey = newEncryptionKey
+
+  // encrypt
+  const newEncryptedValues = symmetricEncryptFields(
+    data,
+    newOptions,
+    newFields
+  )
+  newEncryptedValues.encryptionKey = newEncryptedKey
+
+  return newEncryptedValues
 }
 
 // *** Asymmetric Signatures *** //
@@ -452,7 +583,7 @@ export const makeAsymmetricKeys = async () => {
       type: 'sec1',
       format: 'pem'
       // Encryption done at another level for consistency
-      // cipher: options.asymmetricEncryptionMethod,
+      // cipher: options.asymmetricEncryptionAlgorithm,
       // passphrase: encryptionKey,
     }
   })
@@ -462,25 +593,25 @@ export const makeAsymmetricKeys = async () => {
 export const makeAsymmetricSignature = async (
   data,
   privateKey,
-  { algorithm } = {}
+  { hashAlgorithm } = {}
 ) => {
-  algorithm ??= options.asymmetricSignatureAlgorithm
-  return (await sign(algorithm, Buffer.from(data), privateKey)).toString(
-    options.signatureEncoding
+  hashAlgorithm ??= options.asymmetricSignatureHashAlgorithm
+  return (await sign(hashAlgorithm, Buffer.from(data), privateKey)).toString(
+    options.asymmetricSignatureEncoding
   )
 }
 export const verifyAsymmetricSignature = async (
   data,
   publicKey,
   signature,
-  { algorithm } = {}
+  { hashAlgorithm } = {}
 ) => {
-  algorithm ??= options.asymmetricSignatureAlgorithm
+  hashAlgorithm ??= options.asymmetricSignatureHashAlgorithm
   return await verify(
-    algorithm,
+    hashAlgorithm,
     Buffer.from(data),
     publicKey,
-    Buffer.from(signature, options.signatureEncoding)
+    Buffer.from(signature, options.asymmetricSignatureEncoding)
   )
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1auth/crypto",
-  "version": "0.0.0-alpha.57",
+  "version": "0.0.0-alpha.59",
   "description": "",
   "type": "module",
   "engines": {