secure-comms-hybrid 1.0.4 → 1.0.5

package/lib/backend/middleware.js

@@ -9,14 +9,16 @@ function createEncryptionMiddleware(hybridCrypto, options = {}) {
     logLevel = 'info'
   } = options;
 
-  // Decryption middleware
-  const decryptRequest = (req, res, next) => {
+  // Decryption middleware - FIXED to handle raw body
+  const decryptRequest = async (req, res, next) => {
     // Check if path is excluded
     if (excludedPaths.includes(req.path)) {
+      console.log(`Path ${req.path} excluded from encryption`);
       return next();
     }
     const isEncrypted = req.headers[CRYPTO_CONFIG.HEADERS.ENCRYPTED] === 'true';
     const clientId = req.headers[CRYPTO_CONFIG.HEADERS.CLIENT_ID];
+    console.log(`🔍 Middleware check: Encrypted=${isEncrypted}, ClientID=${clientId}, Path=${req.path}`);
     if (!isEncrypted) {
       if (requireEncryption) {
         return res.status(400).json({
@@ -25,92 +27,153 @@ function createEncryptionMiddleware(hybridCrypto, options = {}) {
           timestamp: new Date().toISOString()
         });
       }
+      console.log('ℹ️ No encryption requested, proceeding with plain request');
       return next();
     }
     if (!clientId) {
+      console.error('❌ Missing client ID for encrypted request');
       return res.status(400).json({
         success: false,
         error: ERRORS.MISSING_CLIENT_ID,
         timestamp: new Date().toISOString()
       });
     }
-    let rawBody = '';
-    req.on('data', chunk => {
-      rawBody += chunk.toString();
-    });
-    req.on('end', async () => {
+    console.log(`🔐 Processing encrypted request for client: ${clientId}`);
+    try {
+      // IMPORTANT: Read raw body BEFORE express.json() consumes it
+      // We need to handle this differently
+
+      // Create a buffer to collect the raw body
+      const chunks = [];
+
+      // Listen for data chunks
+      req.on('data', chunk => {
+        chunks.push(chunk);
+      });
+
+      // Wait for the entire body
+      await new Promise((resolve, reject) => {
+        req.on('end', resolve);
+        req.on('error', reject);
+      });
+
+      // Combine chunks
+      const rawBody = Buffer.concat(chunks).toString();
+      console.log(`📥 Raw body received (${rawBody.length} chars)`);
+      if (!rawBody) {
+        console.error('❌ Empty request body for encrypted request');
+        return res.status(400).json({
+          success: false,
+          error: 'Empty request body',
+          timestamp: new Date().toISOString()
+        });
+      }
+      let parsedBody;
       try {
-        if (!rawBody) {
-          return res.status(400).json({
-            success: false,
-            error: 'Empty request body',
-            timestamp: new Date().toISOString()
-          });
-        }
-        let parsedBody;
-        try {
-          parsedBody = JSON.parse(rawBody);
-        } catch (error) {
-          return res.status(400).json({
-            success: false,
-            error: 'Invalid JSON',
-            timestamp: new Date().toISOString()
-          });
-        }
-        if (!parsedBody.ciphertext || !parsedBody.iv || !parsedBody.authTag) {
-          return res.status(400).json({
-            success: false,
-            error: ERRORS.INVALID_REQUEST,
-            required: ['ciphertext', 'iv', 'authTag'],
-            timestamp: new Date().toISOString()
-          });
-        }
-        const decrypted = await hybridCrypto.decryptData(parsedBody.ciphertext, parsedBody.iv, parsedBody.authTag, clientId);
-        if (!decrypted.success) {
-          return res.status(400).json({
-            success: false,
-            error: ERRORS.DECRYPTION_FAILED,
-            details: decrypted.error,
-            timestamp: new Date().toISOString()
-          });
-        }
-        req.originalEncryptedBody = parsedBody;
-        req.body = decrypted.data;
-        req.encryptionMetadata = {
-          type: 'hybrid',
-          clientId,
-          decryptedAt: decrypted.timestamp,
-          algorithm: 'RSA-AES-GCM'
-        };
-        next();
+        parsedBody = JSON.parse(rawBody);
+        console.log(`✅ Body parsed successfully, keys: ${Object.keys(parsedBody).join(', ')}`);
       } catch (error) {
-        console.error('❌ Decryption middleware error:', error);
-        return res.status(500).json({
+        console.error('❌ Invalid JSON in request body:', error.message);
+        return res.status(400).json({
+          success: false,
+          error: 'Invalid JSON',
+          timestamp: new Date().toISOString()
+        });
+      }
+
+      // Check for required encryption fields
+      if (!parsedBody.ciphertext || !parsedBody.iv || !parsedBody.authTag) {
+        console.error('❌ Missing encryption fields in request');
+        console.log('Received:', {
+          hasCiphertext: !!parsedBody.ciphertext,
+          hasIV: !!parsedBody.iv,
+          hasAuthTag: !!parsedBody.authTag,
+          allKeys: Object.keys(parsedBody)
+        });
+        return res.status(400).json({
+          success: false,
+          error: ERRORS.INVALID_REQUEST,
+          required: ['ciphertext', 'iv', 'authTag'],
+          received: Object.keys(parsedBody),
+          timestamp: new Date().toISOString()
+        });
+      }
+      console.log(`🔓 Attempting to decrypt data for client ${clientId}`);
+      console.log(`   Ciphertext length: ${parsedBody.ciphertext.length}`);
+      console.log(`   IV: ${parsedBody.iv}`);
+      console.log(`   Auth Tag: ${parsedBody.authTag.substring(0, 20)}...`);
+      const decrypted = await hybridCrypto.decryptData(parsedBody.ciphertext, parsedBody.iv, parsedBody.authTag, clientId);
+      console.log(`📊 Decryption result:`, {
+        success: decrypted.success,
+        hasData: !!decrypted.data,
+        error: decrypted.error
+      });
+      if (!decrypted.success) {
+        console.error(`❌ Decryption failed: ${decrypted.error}`);
+        return res.status(400).json({
           success: false,
-          error: 'Internal server error',
+          error: ERRORS.DECRYPTION_FAILED,
+          details: decrypted.error,
           timestamp: new Date().toISOString()
         });
       }
-    });
+      console.log(`✅ Successfully decrypted data for client ${clientId}`);
+
+      // Store original encrypted body for debugging
+      req.originalEncryptedBody = parsedBody;
+      req.body = decrypted.data;
+      req.encryptionMetadata = {
+        type: 'hybrid',
+        clientId,
+        decryptedAt: decrypted.timestamp,
+        algorithm: 'RSA-AES-GCM',
+        originalBodySize: rawBody.length,
+        decryptedBodySize: JSON.stringify(decrypted.data).length
+      };
+      console.log(`📤 Decrypted body:`, {
+        type: typeof decrypted.data,
+        keys: Object.keys(decrypted.data || {}),
+        sample: JSON.stringify(decrypted.data).substring(0, 100)
+      });
+      next();
+    } catch (error) {
+      console.error('❌ Error in decryption middleware:', error);
+      return res.status(500).json({
+        success: false,
+        error: 'Internal server error',
+        message: error.message,
+        timestamp: new Date().toISOString()
+      });
+    }
   };
 
-  // Encryption middleware
+  // Encryption middleware - FIXED
   const encryptResponse = (req, res, next) => {
     const wantsEncryption = req.headers[CRYPTO_CONFIG.HEADERS.ENCRYPTED] === 'true';
     const clientId = req.headers[CRYPTO_CONFIG.HEADERS.CLIENT_ID];
+    console.log(`🔒 Response encryption check: Encrypt=${wantsEncryption}, ClientID=${clientId}`);
     if (!wantsEncryption || !clientId || excludedPaths.includes(req.path)) {
+      console.log('ℹ️ Response encryption not requested');
       return next();
     }
     const originalJson = res.json;
     res.json = async function (data) {
       try {
+        console.log(`🔐 Attempting to encrypt response for client ${clientId}`);
+
+        // Don't encrypt error responses
         if (res.statusCode >= 400) {
+          console.log('ℹ️ Not encrypting error response');
           return originalJson.call(this, data);
         }
         const encrypted = await hybridCrypto.encryptData(data, clientId);
         if (!encrypted.success) {
+          console.error(`❌ Response encryption failed: ${encrypted.error}`);
           throw new Error(`${ERRORS.ENCRYPTION_FAILED}: ${encrypted.error}`);
         }
+        console.log(`✅ Response encrypted successfully`);
+        console.log(`   Ciphertext length: ${encrypted.ciphertext.length}`);
+        console.log(`   IV: ${encrypted.iv.substring(0, 20)}...`);
         const encryptedResponse = {
           success: true,
           encrypted: true,
@@ -121,17 +184,24 @@ function createEncryptionMiddleware(hybridCrypto, options = {}) {
           timestamp: encrypted.timestamp,
           metadata: {
             clientId,
-            originalDataType: typeof data
+            originalDataType: typeof data,
+            encryptedAt: encrypted.timestamp
           }
         };
+
+        // Set encryption headers
         res.setHeader(CRYPTO_CONFIG.HEADERS.ENCRYPTED, 'true');
         res.setHeader(CRYPTO_CONFIG.HEADERS.ENCRYPTION_ALGORITHM, 'RSA-AES-GCM');
         res.setHeader(CRYPTO_CONFIG.HEADERS.CLIENT_ID, clientId);
+        console.log(`📤 Sending encrypted response`);
         return originalJson.call(this, encryptedResponse);
       } catch (error) {
         console.error('❌ Response encryption failed:', error);
+
+        // Remove encryption headers
         res.removeHeader(CRYPTO_CONFIG.HEADERS.ENCRYPTED);
         res.removeHeader(CRYPTO_CONFIG.HEADERS.ENCRYPTION_ALGORITHM);
+        console.log('⚠️ Falling back to plain response');
         return originalJson.call(this, {
           success: false,
           error: ERRORS.ENCRYPTION_FAILED,
@@ -151,64 +221,25 @@ function createEncryptionMiddleware(hybridCrypto, options = {}) {
   };
 }
 
-// Express.js specific middleware factory
+// Express.js specific middleware factory - FIXED
 function createExpressMiddleware(hybridCrypto, options = {}) {
   const {
     decryptRequest,
     encryptResponse
   } = createEncryptionMiddleware(hybridCrypto, options);
-  return function (req, res, next) {
-    // Apply decryption
-    decryptRequest(req, res, err => {
-      if (err) return next(err);
-      // Apply encryption
+  return async function (req, res, next) {
+    console.log(`🚀 Express middleware triggered for: ${req.method} ${req.path}`);
+    try {
+      await decryptRequest(req, res, next);
       encryptResponse(req, res, next);
-    });
-  };
-}
-
-// Koa.js middleware
-function createKoaMiddleware(hybridCrypto, options = {}) {
-  const {
-    decryptRequest,
-    encryptResponse
-  } = createEncryptionMiddleware(hybridCrypto, options);
-  return async (ctx, next) => {
-    // Convert Koa context to Express-like req/res
-    const req = ctx.request;
-    const res = {
-      json: data => {
-        ctx.body = data;
-        ctx.type = 'application/json';
-      },
-      status: code => {
-        ctx.status = code;
-        return res;
-      },
-      setHeader: (name, value) => {
-        ctx.set(name, value);
-      },
-      removeHeader: name => {
-        ctx.remove(name);
-      }
-    };
-    await new Promise(resolve => {
-      decryptRequest(req, res, err => {
-        if (err) throw err;
-        resolve();
-      });
-    });
-    await next();
-    if (ctx.headers[CRYPTO_CONFIG.HEADERS.ENCRYPTED] === 'true') {
-      await new Promise(resolve => {
-        encryptResponse(req, res, () => resolve());
-      });
+    } catch (error) {
+      console.error('Middleware error:', error);
+      next(error);
     }
   };
 }
 module.exports = {
   createEncryptionMiddleware,
   createExpressMiddleware,
-  createKoaMiddleware,
   HybridCrypto: require('./HybridCrypto')
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "secure-comms-hybrid",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Hybrid encryption (RSA + AES) for secure client-server communications",
   "main": "lib/backend/index.js",
   "browser": "dist/frontend/index.js",