aip-master-node-sumit 1.0.0 → 1.0.3

package/index.js

@@ -1,27 +1,39 @@
 const axios = require('axios');
 
-// 🛡️ THE FIX: Allow clients to define the URL, or default to your live production API
-const AIP_MASTER_API = process.env.AIP_MASTER_URL || 'http://localhost:8080/api/v1'; 
+// 🛡️ THE FIX: Smart URL Cleaner ensures the base API URL is exactly right
+const getSafeMasterUrl = (url) => {
+    if (!url) return 'http://localhost:8080/api/v1';
+    let clean = url.replace(/\/+$/, '');
+    if (clean.endsWith('/iam')) {
+        clean = clean.substring(0, clean.length - 4);
+    }
+    return clean;
+};
+
+const AIP_MASTER_API = getSafeMasterUrl(process.env.AIP_MASTER_URL); 
 const API_KEY = process.env.AIP_MASTER_API_KEY; 
 
-// Startup Ping Verification (Only runs if they provided an API key)
 if (API_KEY) {
-    axios.post(`${AIP_MASTER_API}/iam/ping`, { module: 'middleware' }, {
-        headers: { 'Authorization': `Bearer ${API_KEY}` }
-    }).catch(() => {});
+    const sendHeartbeat = async () => {
+        try {
+            await axios.post(`${AIP_MASTER_API}/iam/ping`, { module: 'middleware' }, {
+                headers: { 'Authorization': `Bearer ${API_KEY}` },
+                timeout: 5000 
+            });
+        } catch (err) {
+            // Silently fail so the client's app doesn't crash if Master API is updating
+        }
+    };
+    sendHeartbeat(); 
+    setInterval(sendHeartbeat, 5 * 60 * 1000);
 }
 
-/**
- * Universal Security Guard (God-Mode)
- * @param {Object} options - { requireLogin: boolean }
- */
 const aipGuard = (options = { requireLogin: true }) => {
     return async (req, res, next) => {
         
-        // 🛡️ LAYER 1: INFRASTRUCTURE SHIELD (Anti-DDoS & Header Hacks)
-        const MAX_PAYLOAD_BYTES = 2 * 1024 * 1024; // 2MB Upload Limit
-        
-        // Block advanced Chunked Encoding bypass attacks
+        // LAYER 1: INFRASTRUCTURE SHIELD 
+        const MAX_PAYLOAD_BYTES = 2 * 1024 * 1024;
+
         if (req.headers['transfer-encoding'] && req.headers['transfer-encoding'].includes('chunked')) {
             return res.status(411).send("AIP Infrastructure Shield: Chunked encoding rejected.");
         }
@@ -30,53 +42,56 @@ const aipGuard = (options = { requireLogin: true }) => {
             return res.status(413).send("AIP Infrastructure Shield: Payload Too Large.");
         }
         
-        // Inject Secure Anti-Hacker Headers into the browser
         res.setHeader('X-Frame-Options', 'DENY');
         res.setHeader('X-Content-Type-Options', 'nosniff');
         res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
         res.setHeader('Access-Control-Allow-Origin', process.env.AIP_ALLOWED_ORIGIN || '*');
 
-        // 🛡️ LAYER 2: IDENTITY CHECK & RBAC AUTO-DISCOVERY
+        let token = req.query.token || (req.cookies && req.cookies.aip_session);
+        if (!token && req.headers.authorization && req.headers.authorization.startsWith('Bearer ')) {
+            token = req.headers.authorization.split(' ')[1];
+        } else if (!token && req.headers['x-aip-token']) {
+            token = req.headers['x-aip-token'];
+        }
+
+        // LAYER 2: IDENTITY CHECK & RBAC
         if (options.requireLogin) {
-            const token = req.query.token || (req.cookies && req.cookies.aip_session);
-            if (!token) return res.redirect('/login');
+            if (!token) return res.status(401).send("Unauthorized: Missing AIP Session Token");
 
             try {
-                // The Scout: Automatically grabs the route and sends it to AIP Master for RBAC Scanning
                 const currentAction = req.method + " " + (req.baseUrl + req.path);
                 const authRes = await axios.post(`${AIP_MASTER_API}/iam/verify-session`, 
-                    { 
-                        session_token: token, 
-                        action: currentAction 
-                    }, 
-                    { 
-                        headers: { 'Authorization': `Bearer ${API_KEY}` } 
-                    }
+                    { session_token: token, action: currentAction }, 
+                    { headers: { 'Authorization': `Bearer ${API_KEY}` } }
                 );
-
+                
                 req.user = authRes.data.user; 
-                res.cookie('aip_session', token, { httpOnly: true, secure: true });
+
+                const isProd = process.env.NODE_ENV === 'production';
+                res.cookie('aip_session', token, { httpOnly: true, secure: isProd });
 
             } catch (error) {
-                if (res.clearCookie) res.clearCookie('aip_session');
+                const status = error.response?.status || 500;
                 const errMsg = error.response?.data?.error || "AIP Identity Blocked: Invalid Token.";
-                return res.status(403).send(errMsg);
+                
+                if (status === 401 && res.clearCookie) {
+                    res.clearCookie('aip_session');
+                }
+                
+                return res.status(status === 401 ? 401 : 403).send(errMsg);
             }
         }
 
-        // 🛡️ LAYER 3: WAF THREAT SCAN & SMART IP EXTRACTION
+        // LAYER 3: WAF THREAT SCAN
         try {
             const payloadData = JSON.stringify({ 
-                body: req.body, 
-                query: req.query 
+                body: req.body || {}, 
+                query: req.query || {}
             });
-
-            // Smart IP Resolver: Protects clients hosted on Vercel, Heroku, or AWS
             const forwardedFor = req.headers['x-forwarded-for'];
             let clientIp = req.ip || (req.connection && req.connection.remoteAddress) || "0.0.0.0";
-
+            
             if (forwardedFor) {
-                // Handle both string and array formats safely
                 clientIp = Array.isArray(forwardedFor) 
                     ? forwardedFor[0].trim() 
                     : forwardedFor.split(',')[0].trim();
@@ -89,7 +104,8 @@ const aipGuard = (options = { requireLogin: true }) => {
                 url: req.originalUrl,
                 payload: payloadData,
                 origin: req.headers.origin || "",
-                user_agent: req.headers['user-agent'] || ""
+                user_agent: req.headers['user-agent'] || "",
+                session_token: token || "" 
             });
 
             if (wafRes.data.action === "block") {
@@ -101,7 +117,6 @@ const aipGuard = (options = { requireLogin: true }) => {
             return res.status(500).send("Security verification failed.");
         }
 
-        // Passed all 3 Layers perfectly!
         next(); 
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aip-master-node-sumit",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "Enterprise-grade WAF and IAM security middleware for Node.js.",
   "main": "index.js",
   "scripts": {