inslash 1.1.0 → 1.1.1

package/index.js

@@ -20,7 +20,7 @@ const generateApiKey = (options = {}) => {
         length = 32,
         encoding = "hex"
     } = options;
-    
+
     const random = crypto.randomBytes(length).toString(encoding);
     return prefix ? `${prefix}_${random}` : random;
 };
@@ -38,7 +38,7 @@ const hashWithSalt = async (value, salt, secret, options) => {
     console.timeEnd(`Hash operation (${iterations} iterations)`);
 
     const result = digest.toString(encoding).slice(0, hashLength);
-    
+
     return {
         hash: result,
         timing: iterations, // For informational purposes
@@ -60,10 +60,10 @@ const encodePassport = (meta) => {
         meta.hash,
         history
     ];
-    
+
     // Add optional metadata if present
     if (meta.encoding) parts.push(meta.encoding);
-    
+
     return parts.join("$");
 };
 
@@ -71,13 +71,15 @@ const encodePassport = (meta) => {
 const decodePassport = (passport) => {
     const parts = passport.split("$");
     if (parts[1] !== "inslash") throw new Error("Invalid passport format");
-    
-    // Check version (new format includes version at index 2)
-    const version = parts[2] || "1";
-    
-    if (version === "1") {
-        // Legacy format
-        const [ , , algorithm, iterations, saltLength, hashLength, salt, hash, history ] = parts;
+
+    // Detect format: check if parts[2] is a numeric version or an algorithm name
+    // Legacy format: $inslash$algorithm$iterations$...
+    // New format: $inslash$version$algorithm$iterations$...
+    const isLegacyFormat = SUPPORTED_ALGORITHMS.includes(parts[2]);
+
+    if (isLegacyFormat) {
+        // Legacy format without explicit version
+        const [, , algorithm, iterations, saltLength, hashLength, salt, hash, history] = parts;
         return {
             version: "1",
             algorithm,
@@ -86,11 +88,12 @@ const decodePassport = (passport) => {
             hashLength: Number(hashLength),
             salt,
             hash,
-            history: JSON.parse(Buffer.from(history, "base64").toString())
+            history: history ? JSON.parse(Buffer.from(history, "base64").toString()) : []
         };
     } else {
-        // New format with encoding
-        const [ , , , algorithm, iterations, saltLength, hashLength, salt, hash, history, encoding ] = parts;
+        // New format with explicit version
+        const version = parts[2];
+        const [, , , algorithm, iterations, saltLength, hashLength, salt, hash, history, encoding] = parts;
         return {
             version,
             algorithm,
@@ -99,7 +102,7 @@ const decodePassport = (passport) => {
             hashLength: Number(hashLength),
             salt,
             hash,
-            history: JSON.parse(Buffer.from(history, "base64").toString()),
+            history: history ? JSON.parse(Buffer.from(history, "base64").toString()) : [],
             encoding: encoding || "hex"
         };
     }
@@ -109,22 +112,22 @@ const decodePassport = (passport) => {
 const hash = async (value, secret, opts = {}) => {
     if (!secret) throw new Error("Secret key is required");
     if (typeof value !== "string" || !value) throw new Error("Value to hash must be a non-empty string");
-    
+
     // Validate algorithm
     if (opts.algorithm && !SUPPORTED_ALGORITHMS.includes(opts.algorithm)) {
         throw new Error(`Unsupported algorithm: ${opts.algorithm}. Supported: ${SUPPORTED_ALGORITHMS.join(", ")}`);
     }
-    
+
     // Validate encoding
     if (opts.encoding && !SUPPORTED_ENCODINGS.includes(opts.encoding)) {
         throw new Error(`Unsupported encoding: ${opts.encoding}. Supported: ${SUPPORTED_ENCODINGS.join(", ")}`);
     }
-    
+
     const options = { ...DEFAULTS, ...opts };
     const salt = createSalt(options.saltLength);
     const pepper = process.env.HASH_PEPPER || "";
     const valueWithPepper = value + pepper;
-    
+
     const { hash: hashed } = await hashWithSalt(valueWithPepper, salt, secret, options);
 
     const meta = {
@@ -163,21 +166,21 @@ const verify = async (value, passport, secret, opts = {}) => {
         encoding: meta.encoding || "hex",
         ...opts
     };
-    
+
     const pepper = process.env.HASH_PEPPER || "";
     const valueWithPepper = value + pepper;
-    
+
     const { hash: computed } = await hashWithSalt(valueWithPepper, meta.salt, secret, options);
-    
+
     // Use timing-safe comparison
     const valid = crypto.timingSafeEqual(
         Buffer.from(computed, options.encoding),
         Buffer.from(meta.hash, meta.encoding || "hex")
     );
-    
+
     let needsUpgrade = false;
     let upgradeReasons = [];
-    
+
     if (opts.iterations && opts.iterations > meta.iterations) {
         needsUpgrade = true;
         upgradeReasons.push(`iterations (${meta.iterations} -> ${opts.iterations})`);
@@ -190,10 +193,10 @@ const verify = async (value, passport, secret, opts = {}) => {
         needsUpgrade = true;
         upgradeReasons.push(`encoding (${meta.encoding} -> ${opts.encoding})`);
     }
-    
+
     let upgradedPassport = null;
     let upgradedMetadata = null;
-    
+
     if (valid && needsUpgrade) {
         const newMeta = { ...meta, ...opts };
         newMeta.history = (meta.history || []).concat([
@@ -205,14 +208,14 @@ const verify = async (value, passport, secret, opts = {}) => {
                 reason: "security upgrade"
             }
         ]);
-        
+
         const newSalt = createSalt(newMeta.saltLength);
         const { hash: newHash } = await hashWithSalt(valueWithPepper, newSalt, secret, newMeta);
-        
+
         newMeta.salt = newSalt;
         newMeta.hash = newHash;
         newMeta.version = "2";
-        
+
         upgradedPassport = encodePassport(newMeta);
         upgradedMetadata = {
             algorithm: newMeta.algorithm,
@@ -220,7 +223,7 @@ const verify = async (value, passport, secret, opts = {}) => {
             encoding: newMeta.encoding
         };
     }
-    
+
     return {
         valid,
         needsUpgrade,
@@ -281,14 +284,14 @@ const comparePassports = (passport1, passport2) => {
     try {
         const meta1 = decodePassport(passport1);
         const meta2 = decodePassport(passport2);
-        
+
         return {
             sameAlgorithm: meta1.algorithm === meta2.algorithm,
             sameIterations: meta1.iterations === meta2.iterations,
             sameSalt: meta1.salt === meta2.salt,
             sameHash: meta1.hash === meta2.hash,
             sameEncoding: (meta1.encoding || "hex") === (meta2.encoding || "hex"),
-           完全相同: meta1.hash === meta2.hash && meta1.salt === meta2.salt
+            完全相同: meta1.hash === meta2.hash && meta1.salt === meta2.salt
         };
     } catch (error) {
         return {
@@ -304,16 +307,16 @@ const estimateSecurity = (passport) => {
         const meta = decodePassport(passport);
         const now = new Date();
         const year = now.getFullYear();
-        
+
         // Rough estimate of security level
         let score = 0;
         let recommendations = [];
-        
+
         // Algorithm score
         if (meta.algorithm === "sha512") score += 40;
         else if (meta.algorithm === "sha384") score += 35;
         else if (meta.algorithm === "sha256") score += 30;
-        
+
         // Iterations score (based on year)
         if (meta.iterations >= 300000) score += 40;
         else if (meta.iterations >= 200000) score += 35;
@@ -323,7 +326,7 @@ const estimateSecurity = (passport) => {
             score += 15;
             recommendations.push("Increase iterations (current: " + meta.iterations + ")");
         }
-        
+
         // Salt length
         if (meta.saltLength >= 32) score += 20;
         else if (meta.saltLength >= 16) score += 15;
@@ -331,16 +334,16 @@ const estimateSecurity = (passport) => {
             score += 5;
             recommendations.push("Increase salt length (current: " + meta.saltLength + ")");
         }
-        
+
         // Hash length
         if (meta.hashLength >= 32) score += 10;
-        
+
         let level = "Weak";
         if (score >= 90) level = "Excellent";
         else if (score >= 75) level = "Strong";
         else if (score >= 60) level = "Good";
         else if (score >= 40) level = "Fair";
-        
+
         return {
             score,
             level,
@@ -368,19 +371,19 @@ module.exports = {
     verify,
     encodePassport,
     decodePassport,
-    
+
     // New enhanced functions
     batchVerify,
     inspectPassport,
     comparePassports,
     estimateSecurity,
     generateApiKey,
-    
+
     // Utilities
     DEFAULTS,
     SUPPORTED_ALGORITHMS,
     SUPPORTED_ENCODINGS,
-    
+
     // Version info
     VERSION: "1.1.0"
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inslash",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "A modern, upgradeable, and secure password hashing utility with passport encoding, hash ancestry, and comprehensive security features.",
   "main": "index.js",
   "types": "index.d.ts",