@onlineapps/service-validator-core 1.0.4 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/service-validator-core",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Core validation logic for microservices",
   "main": "src/index.js",
   "scripts": {

package/src/index.js

@@ -7,6 +7,7 @@ const CertificateManager = require('./security/certificateManager');
 const ValidationProofVerifier = require('./security/ValidationProofVerifier');
 const ValidationProofCodec = require('./security/ValidationProofCodec');
 const ValidationProofSchema = require('./types/ValidationProofSchema');
+const FingerprintUtils = require('./utils/FingerprintUtils');
 
 class ValidationCore {
   constructor(config = {}) {
@@ -213,4 +214,5 @@ class ValidationCore {
 module.exports = ValidationCore;
 module.exports.ValidationProofVerifier = ValidationProofVerifier;
 module.exports.ValidationProofCodec = ValidationProofCodec;
-module.exports.ValidationProofSchema = ValidationProofSchema;
+module.exports.ValidationProofSchema = ValidationProofSchema;
+module.exports.FingerprintUtils = FingerprintUtils;

package/src/security/certificateManager.js

@@ -1,4 +1,5 @@
 const crypto = require('crypto');
+const FingerprintUtils = require('../utils/FingerprintUtils');
 
 class CertificateManager {
   constructor(config = {}) {
@@ -147,8 +148,7 @@ class CertificateManager {
    * @returns {string} Fingerprint
    */
   generateFingerprint(data) {
-    const sortedData = JSON.stringify(data, Object.keys(data).sort());
-    return crypto.createHash('sha256').update(sortedData).digest('hex');
+    return FingerprintUtils.generateValidationFingerprint(data);
   }
 
   /**

package/src/security/tokenManager.js

@@ -1,5 +1,6 @@
 const jwt = require('jsonwebtoken');
 const crypto = require('crypto');
+const FingerprintUtils = require('../utils/FingerprintUtils');
 
 class TokenManager {
   constructor(config = {}) {
@@ -186,8 +187,7 @@ class TokenManager {
    * @returns {string} Fingerprint hash
    */
   generateFingerprint(validationData) {
-    const sortedData = JSON.stringify(validationData, Object.keys(validationData).sort());
-    return crypto.createHash('sha256').update(sortedData).digest('hex');
+    return FingerprintUtils.generateValidationFingerprint(validationData);
   }
 }
 

package/src/utils/FingerprintUtils.js

@@ -0,0 +1,126 @@
+const crypto = require('crypto');
+
+/**
+ * FingerprintUtils - Centralized fingerprint generation
+ *
+ * Single source of truth for SHA256 fingerprinting across the system.
+ * Used for configuration caching, certificate verification, and content integrity.
+ *
+ * NOT to be confused with ValidationProofCodec which is specifically for
+ * validation proof hashing (different purpose).
+ *
+ * Usage:
+ * - configFingerprint: Identify service configuration version
+ * - Certificate fingerprint: Verify certificate data integrity
+ * - Token fingerprint: Generate token identifiers
+ * - Content fingerprint: Verify file/storage content
+ */
+class FingerprintUtils {
+  /**
+   * Generate SHA256 fingerprint for any data
+   *
+   * @param {*} data - Data to fingerprint (will be JSON.stringify if object)
+   * @param {Object} options - Options
+   * @param {boolean} options.sortKeys - Sort object keys (default: true)
+   * @returns {string} SHA256 hash (64 hex characters)
+   *
+   * @example
+   * const hash = FingerprintUtils.generate({ version: '1.0', endpoints: [] });
+   * // Returns: consistent SHA256 hash for the object
+   */
+  static generate(data, options = {}) {
+    const sortKeys = options.sortKeys !== false; // default true
+
+    let input;
+
+    // Handle different data types
+    if (Buffer.isBuffer(data)) {
+      input = data;
+    } else if (typeof data === 'string') {
+      input = data;
+    } else if (typeof data === 'object' && data !== null) {
+      // Serialize object with optional key sorting
+      const keys = sortKeys ? Object.keys(data).sort() : Object.keys(data);
+      input = JSON.stringify(data, keys);
+    } else {
+      // Primitives (number, boolean, null, undefined)
+      input = String(data);
+    }
+
+    // Generate SHA256 hash
+    return crypto.createHash('sha256').update(input).digest('hex');
+  }
+
+  /**
+   * Generate fingerprint for service configuration
+   * Used for cache validation - skip re-validation if config unchanged
+   *
+   * @param {Object} config - Service configuration
+   * @param {string} config.version - Service version (REQUIRED)
+   * @param {Array} config.endpoints - API endpoints (REQUIRED)
+   * @param {Object} config.metadata - Service metadata (REQUIRED)
+   * @param {string} config.health - Health check endpoint (REQUIRED)
+   * @returns {string} Configuration fingerprint
+   * @throws {Error} If any required field is missing
+   */
+  static generateConfigFingerprint(config) {
+    if (!config) {
+      throw new Error('Config is required for generateConfigFingerprint');
+    }
+    if (!config.version) {
+      throw new Error('config.version is required');
+    }
+    if (!Array.isArray(config.endpoints)) {
+      throw new Error('config.endpoints must be an array');
+    }
+    if (typeof config.metadata !== 'object' || config.metadata === null) {
+      throw new Error('config.metadata must be an object');
+    }
+    if (!config.health) {
+      throw new Error('config.health is required');
+    }
+
+    return this.generate({
+      version: config.version,
+      endpoints: config.endpoints,
+      metadata: config.metadata,
+      health: config.health
+    });
+  }
+
+  /**
+   * Generate fingerprint for validation results
+   * Used in certificates and tokens
+   *
+   * @param {Object} validationResults - Validation results data
+   * @returns {string} Validation results fingerprint
+   */
+  static generateValidationFingerprint(validationResults) {
+    return this.generate(validationResults);
+  }
+
+  /**
+   * Generate fingerprint for content (files, storage)
+   *
+   * @param {string|Buffer} content - Content to fingerprint
+   * @returns {string} Content fingerprint
+   */
+  static generateContentFingerprint(content) {
+    return this.generate(content, { sortKeys: false });
+  }
+
+  /**
+   * Verify fingerprint matches data
+   *
+   * @param {*} data - Data to verify
+   * @param {string} expectedFingerprint - Expected fingerprint
+   * @param {Object} options - Options (passed to generate)
+   * @returns {boolean} True if fingerprint matches
+   */
+  static verify(data, expectedFingerprint, options = {}) {
+    const actualFingerprint = this.generate(data, options);
+    return actualFingerprint === expectedFingerprint;
+  }
+}
+
+module.exports = FingerprintUtils;