@carecard/auth-util 3.19.0 → 3.21.0

package/lib/jwtUtilAuth.js

@@ -1,22 +1,25 @@
 const crypto = require('crypto');
 
+const supportedVerificationHashes = new Set(crypto.getHashes().map(hash => hash.toLowerCase()));
+
+// Pattern: Normalizer - preserves explicit registered times while supplying omitted defaults.
 const _normalizePayload = payloadObject => {
   const payload = { ...payloadObject };
   const now = Math.floor(Date.now() / 1000);
   const fieldsToNormalize = ['iat', 'exp', 'nbf', 'auth_time'];
   const msThreshold = 1000000000000;
 
-  if (!payload.iat) {
+  if (!Number.isFinite(payload.iat)) {
     payload.iat = now;
   }
 
   fieldsToNormalize.forEach(field => {
-    if (payload[field] && payload[field] > msThreshold) {
+    if (Number.isFinite(payload[field]) && payload[field] > msThreshold) {
       payload[field] = Math.floor(payload[field] / 1000);
     }
   });
 
-  if (!payload.exp) {
+  if (!Number.isFinite(payload.exp)) {
     payload.exp = payload.iat + 3600;
   }
   return payload;
@@ -52,6 +55,19 @@ const _verify = (token, signature, alg, publicKey) => {
   return verify.verify(publicKey, signature, 'base64url');
 };
 
+// Pattern: Allow List - rejects algorithms that the runtime cannot safely verify.
+const isSupportedVerificationAlgorithm = algorithm => {
+  if (algorithm === 'EdDSA' || algorithm === 'Ed25519') {
+    return true;
+  }
+  return typeof algorithm === 'string' && supportedVerificationHashes.has(algorithm.toLowerCase());
+};
+
+// Pattern: Type Guard - decoded JWT parts must honor their documented object contract.
+const isDecodedJwtObject = value => {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+
 const isNonEmptyString = value => {
   return typeof value === 'string' && value.trim().length > 0;
 };
@@ -155,6 +171,7 @@ function createServiceAuthorizationHeader(options = {}) {
  * @param publicKey
  * @return {boolean}
  */
+// Pattern: Fail-Closed Verification - malformed token metadata returns false before crypto use.
 const verifyJwtSignature = (jwt, publicKey) => {
   try {
     if (!jwt || !publicKey) {
@@ -168,6 +185,9 @@ const verifyJwtSignature = (jwt, publicKey) => {
     const [header, payload, signature] = splitJWT;
     const token = header + '.' + payload;
     const headerObject = _decode(header);
+    if (!isDecodedJwtObject(headerObject) || !isSupportedVerificationAlgorithm(headerObject.alg)) {
+      return false;
+    }
 
     return _verify(token, signature, headerObject.alg, publicKey);
   } catch (error) {
@@ -183,6 +203,7 @@ const verifyJwtSignature = (jwt, publicKey) => {
  * @param jwt
  * @return {{payload: *, header: *}|null}
  */
+// Pattern: Boundary Validation - returns only decoded header and payload objects.
 const getHeaderPayloadFromJwt = jwt => {
   try {
     if (typeof jwt !== 'string') {
@@ -195,6 +216,9 @@ const getHeaderPayloadFromJwt = jwt => {
 
     const headerObject = _decode(splitJWT[0]);
     const payloadObject = _decode(splitJWT[1]);
+    if (!isDecodedJwtObject(headerObject) || !isDecodedJwtObject(payloadObject)) {
+      return null;
+    }
 
     return { header: headerObject, payload: payloadObject };
   } catch (error) {

package/lib/pwdUtilAuth.js

@@ -1,26 +1,45 @@
 const crypto = require('crypto');
 
-/**
- * Automatically adds random salt.
- * @param password
- * @param secret
- * @param algorithm
- * @return {string}
- */
+const PASSWORD_HASH_VERSION = '1';
+
+// Pattern: Pure Function - creates a digest in which both the pepper and random salt participate.
+function createSaltedPasswordDigest(password, secret, algorithm, salt) {
+  return crypto
+    .createHmac(algorithm, secret)
+    .update(Buffer.from(salt, 'base64'))
+    .update(password)
+    .digest('base64');
+}
+
+// Pattern: Pure Function - recreates the historical digest for existing stored credentials.
+function createLegacyPasswordDigest(password, secret, algorithm) {
+  return crypto.createHmac(algorithm, secret).update(password).digest('base64');
+}
+
+// Pattern: Serializer - preserves the published password-hash storage contract.
+function serializePasswordHash(algorithmBase64, hashBase64, salt) {
+  return `$${PASSWORD_HASH_VERSION}$${algorithmBase64}$${hashBase64}$${salt}$`;
+}
+
+// Pattern: Constant-Time Comparison - avoids credential-dependent string comparison timing.
+function passwordHashesMatch(candidateHash, savedPasswordHash) {
+  const candidateBuffer = Buffer.from(candidateHash);
+  const savedBuffer = Buffer.from(savedPasswordHash);
+  return (
+    candidateBuffer.length === savedBuffer.length &&
+    crypto.timingSafeEqual(candidateBuffer, savedBuffer)
+  );
+}
+
+// Pattern: Factory - creates a password hash whose random salt changes the credential digest.
 const createPasswordHashWithRandomSalt = (password, secret, algorithm) => {
   const salt = crypto.randomBytes(32).toString('base64');
   const algorithmBase64 = Buffer.from(algorithm).toString('base64');
-  const hashBase64 = crypto.createHmac(algorithm, secret).update(password).digest('base64');
-  return '$1$' + algorithmBase64 + '$' + hashBase64 + '$' + salt + '$';
+  const hashBase64 = createSaltedPasswordDigest(password, secret, algorithm, salt);
+  return serializePasswordHash(algorithmBase64, hashBase64, salt);
 };
 
-/**
- * Creates hash based on saved hash in database.
- * @param password
- * @param savedPasswordHash
- * @param secret
- * @return {string}
- */
+// Pattern: Compatibility Verification - verifies salted hashes while retaining existing credentials.
 const createPasswordHashBasedOnSavedAlgorithmSalt = (password, savedPasswordHash, secret) => {
   if (typeof savedPasswordHash !== 'string') {
     return null;
@@ -31,12 +50,18 @@ const createPasswordHashBasedOnSavedAlgorithmSalt = (password, savedPasswordHash
     return null;
   }
 
+  const version = splitStringArray[1];
   const algBase64 = splitStringArray[2];
   const salt = splitStringArray[4];
+  if (version !== PASSWORD_HASH_VERSION || !algBase64 || !salt) {
+    return null;
+  }
   const algorithm = Buffer.from(algBase64, 'base64').toString('utf8');
-
-  const hashBase64 = crypto.createHmac(algorithm, secret).update(password).digest('base64');
-  return '$1$' + algBase64 + '$' + hashBase64 + '$' + salt + '$';
+  const saltedDigest = createSaltedPasswordDigest(password, secret, algorithm, salt);
+  const saltedHash = serializePasswordHash(algBase64, saltedDigest, salt);
+  const legacyDigest = createLegacyPasswordDigest(password, secret, algorithm);
+  const legacyHash = serializePasswordHash(algBase64, legacyDigest, salt);
+  return passwordHashesMatch(legacyHash, savedPasswordHash) ? legacyHash : saltedHash;
 };
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carecard/auth-util",
-  "version": "3.19.0",
+  "version": "3.21.0",
   "repository": "https://github.com/CareCard-ca/pkg-auth-util.git",
   "description": "Auth utility functions",
   "main": "index.js",
@@ -47,8 +47,8 @@
     "typescript": "6.0.3"
   },
   "dependencies": {
-    "@carecard/common-util": "3.18.0",
-    "@carecard/validate": "3.18.0",
+    "@carecard/common-util": "3.21.0",
+    "@carecard/validate": "3.21.0",
     "@types/express": "5.0.6"
   },
   "overrides": {