express-cybershield 1.0.34

package/README.md

@@ -0,0 +1,104 @@
+# CyberShield WAF Plugin for Express.js
+
+CyberShield WAF Plugin is a real-time web application firewall (WAF) middleware for Express.js applications. Powered by the MERN Cloud AI engine, it provides robust protection against common web vulnerabilities 
+
+## Installation
+
+You can install the CyberShield Plugin via `npm` or `yarn`.
+
+### Using npm
+
+```bash
+npm install express-cybershield
+```
+
+### Using yarn
+
+```bash
+yarn add express-cybershield
+```
+
+> **Note**: This package requires Node.js `14.0.0` or higher and Express `4.0.0` or higher.
+
+---
+
+## Basic Usage
+
+To integrate the CyberShield WAF into your Express application, simply import the agent, initialize it with your configuration credentials, and add it as a middleware.
+
+```javascript
+const express = require('express');
+const cyberShield = require('express-cybershield');
+
+const app = express();
+
+// 1. Initialize CyberShield Agent
+cyberShield.init({
+  apiKey:       process.env.CYBERSHIELD_API_KEY,
+  siteUrl:      process.env.CYBERSHIELD_SITE_URL,
+  emailAddress: process.env.CYBERSHIELD_EMAIL,
+});
+// 2. Attach the WAF middleware globally
+// Ensure you place this BEFORE your route definitions so requests are scanned.
+app.use(cyberShield.waf);
+
+// Example route
+app.get('/', (req, res) => {
+  res.send('Your application is protected by CyberShield!');
+});
+
+const PORT = process.env.PORT || 3000;
+app.listen(PORT, () => {
+  console.log(`Server running on port ${PORT}`);
+});
+```
+
+## Environment Variables
+
+All credentials **must** be stored in a `.env` file at the root of your project — never hardcoded in source code.
+
+### 1. Install dotenv
+
+```bash
+npm install dotenv
+```
+
+### 2. Create a `.env` file
+
+```env
+# .env  (never commit this file — add it to .gitignore)
+CYBERSHIELD_API_KEY=your_cybershield_api_key
+CYBERSHIELD_SITE_URL=https://your-domain.com
+CYBERSHIELD_EMAIL=admin@your-domain.com
+CYBERSHIELD_API_URL=https://your-mern-engine-url.com
+```
+
+### 3. Load `.env` at the very top of your entry file
+
+```javascript
+require('dotenv').config(); // Must be the FIRST line
+
+const express    = require('express');
+const cyberShield = require('express-cybershield');
+```
+
+> **Important**: Add `.env` to your `.gitignore` to prevent secrets from being committed.
+
+```gitignore
+# .gitignore
+.env
+```
+
+## Configuration Options
+
+When calling `cyberShield.init(config)`, you can pass the following properties in the `config` object:
+
+| Option | Type | Required | Description |
+|--------|------|----------|-------------|
+| `apiKey` | `string` | **Yes** | Your unique CyberShield API Key. |
+| `siteUrl` | `string` | **Yes** | The base URL of the site being protected. |
+| `emailAddress` | `string` | **Yes** | Administrator email address for alert notifications. |
+
+
+## Support & Issues
+For issues and feature requests, please visit the [GitHub repository](https://github.com/securas/express-cybershield/issues) or contact [SECURAS](https://securas.cloud).

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "express-cybershield",
+  "version": "1.0.34",
+  "description": "CyberShield WAF Agent for Express.js — Real-time web application firewall powered by MERN Cloud AI engine. Protects against SQL injection, XSS, brute-force, and more.",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "cybershield",
+    "waf",
+    "security",
+    "firewall",
+    "express",
+    "middleware",
+    "xss",
+    "sql-injection",
+    "bot-protection",
+    "threat-detection",
+    "web-security",
+    "express-middleware"
+  ],
+  "author": "SECURAS <contact@securas.cloud> (https://securas.cloud)",
+  "license": "ISC",
+  "type": "commonjs",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "axios": "^1.13.6"
+  },
+  "peerDependencies": {
+    "express": ">=4.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/securas/express-cybershield"
+  },
+  "homepage": "https://securas.cloud",
+  "bugs": {
+    "url": "https://github.com/securas/express-cybershield/issues"
+  }
+}

package/src/api/cybershield-api.js

@@ -0,0 +1,197 @@
+const axios = require('axios');
+const context = require('../core/cybershield-context');
+
+/**
+ * Client API CyberShield
+ * 
+ * Fait l'interface entre l'agent Node.js local et le moteur centralisé MERN.
+ */
+class CyberShieldApiClient {
+    constructor() {
+        this.apiClient = axios.create({
+            timeout: 5000 // 5s max — au-delà, Fail-Open immédiat
+        });
+
+        // Cache interne pour checkStatus — évite un appel MERN à chaque requête
+        this._statusCache = { valid: null, expiresAt: 0 };
+        this._STATUS_TTL_MS = 30 * 1000; // Re-vérifie toutes les 30 secondes
+        // Intercepteur dynamique — résout l'URL MERN depuis le contexte (init() > env var)
+        this.apiClient.interceptors.request.use(config => {
+            config.baseURL = context.apiUrl || process.env.CYBERSHIELD_API_URL;
+            return config;
+        });
+    }
+    /**
+     * Authentification initiale du SDK.
+     * Correspond à la route "exports.getApiPlugin" sur votre code MERN.
+     * Appelé une seule fois au démarrage de l'application cliente.
+     */
+    async wafVerify() {
+        try {
+            if (!context.apiKey || !context.siteUrl || !context.emailAddress) {
+                console.error('[CyberShield] Clé API, URL ou email manquant. Bouclier inactif.');
+                context.isActive = false;
+                return false;
+            }
+            // Construction de la Query String conformément à getApiPlugin
+            const queryParams = new URLSearchParams({
+                api_key: context.apiKey,
+                site_url: context.siteUrl,
+                email_address: context.emailAddress
+            });
+            // GET vers la route d'activation/installation
+
+            const response = await this.apiClient.get(`/api/checkApiKeyPlugin?${queryParams.toString()}`);
+            // Validation de la réponse
+            if (response.data && response.data.valid) {
+                console.log('[CyberShield]  Connexion MERN réussie. Bouclier activé.');
+                console.log(`[CyberShield]  Message: ${response.data.message}`);
+
+                // On alimente le contexte (la RAM) avec les informations du MERN
+                // updateStateFromMERN gère seul l'état isActive pour éviter toute redondance
+                context.updateStateFromMERN(response.data);
+                return true;
+            } else {
+                const errorMsg = response.data ? response.data.message : 'WAF désactivé';
+                console.warn(`[CyberShield]  Authentification MERN refusée. ${errorMsg}`);
+                context.isActive = false;
+                return false;
+            }
+
+        } catch (error) {
+            if (error.response && error.response.data) {
+                console.error(`[CyberShield] Erreur de communication MERN (Initialisation) - ALERTE:`, error.response.data);
+                console.log(error.response.data);
+            } else {
+                console.error('[CyberShield] Erreur de communication MERN (Initialisation):', error.message);
+            }
+            // Politique "Fail-Open" : En cas d'erreur réseau, on ne bloque pas le site client.
+            // Bien qu'il vaille mieux laisser le site tourner, si la validation n'a jamais marché, le WAF reste inactif
+            context.isActive = false;
+            return false;
+        }
+    }
+    /**
+     * Vérification de l'abonnement par le Moteur MERN (Mode Synchrone).
+     * Correspond à la route "exports.getApiActive" sur votre code MERN.
+     * Appelé AVANT chaque requête du visiteur pour s'assurer que l'abonnement est actif.
+     */
+    async checkStatus() {
+        // --- Cache 30s : évite un appel MERN supplémentaire à chaque requête ---
+        if (this._statusCache.valid !== null && Date.now() < this._statusCache.expiresAt) {
+            return this._statusCache.valid;
+        }
+
+        try {
+            if (!context.apiKey) return false;
+
+            const queryParams = new URLSearchParams({
+                api_key: context.apiKey,
+                site_url: context.siteUrl
+            });
+            if (context.emailAddress) {
+                queryParams.append('email_address', context.emailAddress);
+            }
+
+            // GET vers la route de validation
+            const response = await this.apiClient.get(`/api/checkApiKeyValide?${queryParams.toString()}`);
+
+            if (response.data && response.data.valid) {
+                console.log(`[CyberShield]  Abonnement: ${response.data.message}`);
+                context.isActive = true;
+                this._statusCache = { valid: true, expiresAt: Date.now() + this._STATUS_TTL_MS };
+                return true;
+            } else {
+                console.warn(`[CyberShield]  Abonnement: ${response.data.message}`);
+                context.isActive = false;
+                this._statusCache = { valid: false, expiresAt: Date.now() + this._STATUS_TTL_MS };
+                return false;
+            }
+        } catch (error) {
+            // Si le MERN renvoie spécifiquement une erreur 4xx (ex: 403 Expired)
+            if (error.response && error.response.data) {
+                console.warn(`[CyberShield]  ALERTE: ${error.response.data.message || 'Abonnement expiré.'}`);
+                context.isActive = false;
+                this._statusCache = { valid: false, expiresAt: Date.now() + this._STATUS_TTL_MS };
+                return false;
+            }
+
+            // Fail-Open sur erreur réseau totale (MERN injoignable) —
+            // On n'invalide PAS le cache ici pour ne pas spammer le MERN en cas de panne
+            console.warn('[CyberShield]  checkStatus: MERN injoignable — Fail-Open temporaire.');
+            context.isActive = false;
+            return false;
+        }
+    }
+
+    /**
+     * Analyse de la requête par le Moteur MERN (Mode Synchrone).
+     * Correspond à la route "exports.addLogEntryTest" sur votre code MERN.
+     * Appelé à chaque requête du visiteur pour que le MERN prenne la décision.
+     * 
+     */
+    async analyzeRequest(requestData) {
+        try {
+            if (!context.apiKey || !context.siteUrl) return { threat_detected: false };
+
+            // Prepare safe headers
+            const safeHeaders = { ...(requestData.headers || {}) };
+            delete safeHeaders.cookie;
+            delete safeHeaders.Cookie;
+            const payload = {
+                ip: requestData.ip,
+                user_agent: requestData.headers?.['user-agent'] || 'Unknown',
+                query_string: requestData.query_string || '',
+                query: requestData.query || {},         // Structured query params (was dropped before)
+                request_method: requestData.method,
+                body: requestData.body || {},
+                headers: safeHeaders,
+
+                // send cookies separately as data, not as real headers
+                cookies: requestData.headers?.cookie || null,
+
+                site_url: context.siteUrl,
+                domain: (() => {
+                    try {
+                        return new URL(context.siteUrl).hostname;
+                    } catch (e) {
+                        return context.siteUrl;
+                    }
+                })(),
+                page: requestData.url
+            };
+
+            if (process.env.CYBERSHIELD_DEBUG === 'true') {
+                console.log("[CyberShield DEBUG] PAYLOAD WAF ENVOYÉ AU MERN :", JSON.stringify(payload, null, 2));
+            }
+
+
+            // Appel POST vers votre API MERN 
+            const response = await this.apiClient.post('/log/logEntryTest', payload, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': context.apiKey,
+                },
+            });
+
+
+            if (process.env.CYBERSHIELD_DEBUG === 'true') {
+                console.log("[CyberShield DEBUG] analyzeRequest response status:", response?.status);
+            }
+
+            if (response) {
+                return response.data; // { threat_detected: true/false, option: {...}, setting: '...' }
+            }
+            return null; // Réponse vide inattendue → Fail-Open dans le WAF
+
+        } catch (error) {
+            console.error('[CyberShield]  Impossible de joindre le MERN pour l\'analyse. Fail-Open.');
+            // Retourne null → le WAF détecte !result et déclenche next() proprement
+            // (évite le cas où toutes les flags sont undefined/false et rien ne bloque)
+            return null;
+        }
+    }
+}
+
+const client = new CyberShieldApiClient();
+module.exports = client;

package/src/core/cybershield-context.js

@@ -0,0 +1,60 @@
+/**
+ * Le "Cerveau" de l'Agent CyberShield.
+ */
+class CyberShieldContext {
+    constructor() {
+        if (CyberShieldContext.instance) {
+            return CyberShieldContext.instance;
+        }
+
+        // --- Paramètres d'Identité ---
+        this.apiKey = null;
+        this.emailAddress = null;
+        this.siteUrl = null;
+        this.apiUrl = null;  // URL du moteur MERN (peut venir de init() ou de process.env)
+
+        // --- Etat Global (Master Switch) ---
+        this.isActive = false;
+
+        // --- Configuration personnalisée du client JS ---
+        this.ignoreRoutes = [];
+
+        CyberShieldContext.instance = this;
+    }
+    /**
+     * Initialise le contexte lorsque le SDK est lancé par le client.
+     */
+    init(configData) {
+        if (configData.apiKey) {
+            this.apiKey = configData.apiKey;
+        }
+        if (configData.emailAddress) {
+            this.emailAddress = configData.emailAddress;
+        }
+        if (configData.siteUrl) {
+            this.siteUrl = configData.siteUrl;
+        }
+        // apiUrl : init() config takes priority, then falls back to env var
+        if (configData.apiUrl) {
+            this.apiUrl = configData.apiUrl;
+        } else if (process.env.CYBERSHIELD_API_URL) {
+            this.apiUrl = process.env.CYBERSHIELD_API_URL;
+        }
+
+        if (Array.isArray(configData.ignoreRoutes)) {
+            this.ignoreRoutes = configData.ignoreRoutes;
+        }
+    }
+    /**
+     * Met à jour l'état de sécurité après la réponse du moteur MERN
+     */
+    updateStateFromMERN(apiResponse) {
+        if (!apiResponse) return;
+        // Mise à jour de l'état global du bouclier selon la validité stricte renvoyée par le MERN
+        this.isActive = apiResponse.valid === true;
+    }
+}
+
+// Export de l'instance Singleton
+const context = new CyberShieldContext();
+module.exports = context;

package/src/index.js

@@ -0,0 +1,57 @@
+/**
+ * Plugin Name:     CyberShield Firewall
+ * Plugin URI:      https://docs.securas.cloud
+ * Description:     CyberShield Web Application Firewall for Express.js.
+ * Requires Node:   14.0.0
+ * Version:         1.0.0
+ * Author:          Securas
+ * Author URI:      https://docs.securas.cloud
+ * License:         ISC
+ * since 30/11/2024
+ * version 1.0.0
+ */
+
+const context = require('./core/cybershield-context');
+const apiClient = require('./api/cybershield-api');
+const waf = require('./middlewares/cybershield-waf');
+
+/**
+ * Fichier Principal du SDK Node.js Express-CyberShield
+ */
+
+class CyberShieldAgent {
+    constructor() {
+        this.waf = waf;
+        this.context = context;
+        this.isInitialized = false;
+    }
+
+    /**
+     * Initialise l'agent sur le serveur du client.
+     * @param {Object} config - { apiKey, siteUrl, emailAddress, ignoreRoutes, customBypassLogic }
+     */
+    init(config = {}) {
+        if (this.isInitialized) {
+            console.warn('[CyberShield] Attention: L\'agent a déjà été initialisé.');
+            return this;
+        }
+
+        console.log('[CyberShield]  Initialisation de l\'Agent Express-CyberShield...');
+
+        // 1. Initialisation de la mémoire RAM
+        context.init(config);
+
+        // 2. Premier contact avec votre API MERN (`getApiPlugin`) de façon non bloquante
+        apiClient.wafVerify().then(authSuccess => {
+            if (authSuccess) {
+                console.log('[CyberShield] ✓ Bouclier MERN activé en mode de vérification Synchrone.');
+            }
+        });
+
+        this.isInitialized = true;
+        return this; // Permet de faire du chaînage si besoin
+    }
+}
+// On exporte un singleton global
+const agent = new CyberShieldAgent();
+module.exports = agent;

package/src/middlewares/cybershield-waf.js

@@ -0,0 +1,197 @@
+const context = require('../core/cybershield-context');
+const apiClient = require('../api/cybershield-api');
+const { sanitizeInput, isSearchBot, cleanParameterPollution, checkJwtIntegrity } = require('../utils/cybershield-utils');
+const { getTelemetryInfo } = require('../telemetry/cybershield-telemetry');
+
+/**
+ * Cœur d'analyse WAF (MERN)
+ */
+const cybershieldWafCore = async (req, res, next) => {
+
+    // -------------------------------------------------------------
+    // ETAPE 1 : VÉRIFICATION MERN STRICTE (Temps-Réel par requête)
+    // -------------------------------------------------------------
+    // Demande client : On vérifie systématiquement auprès du MERN si la licence 
+    // est valide AVANT chaque visiteur, au détriment de la performance.
+    const isStillValid = await apiClient.checkStatus();
+    if (!isStillValid || !context.isActive) {
+        return next(); // L'abonnement n'est plus actif ou injoignable -> Fail-Open
+    }
+    // -------------------------------------------------------------
+    // ETAPE 3 : ENVOI AU MERN POUR ANALYSE (Mode Synchrone)
+    // -------------------------------------------------------------
+    try {
+        const rawIp = req.headers['x-forwarded-for'] || req.ip || req.socket.remoteAddress || '127.0.0.1';
+        const requestData = {
+            ip: (rawIp.includes(',') ? rawIp.split(',')[0] : rawIp).trim(),
+            method: req.method,
+            url: req.originalUrl,
+            headers: req.headers,
+            body: req.body,
+            query: req.query,
+            query_string: (() => {
+                try {
+                    return req.originalUrl.includes('?') ? decodeURIComponent(req.originalUrl.split('?')[1]) : '';
+                } catch (e) {
+                    return req.originalUrl.split('?')[1] || '';
+                }
+            })()
+        };
+
+        // Appel synchrone vers le moteur MERN (addLogEntryTest)
+        const result = await apiClient.analyzeRequest(requestData);
+        if (!result || typeof result !== 'object') {
+            return next();
+        }
+        // 4.1 En-tête XSS Protection
+        if (result.option && parseInt(result.option.xss_protection) === 1) {
+            res.setHeader('X-XSS-Protection', '1');
+        }
+        // 4.2 Masquer la version du serveur
+        if (result.option && parseInt(result.option.hide_node_ver) === 1) {
+            res.setHeader('X-Powered-By', 'SECURAS');
+        }
+        // 4.3 Protection Clickjacking
+        if (result.option && parseInt(result.option.clickjacking_protection) === 1) {
+            res.setHeader('X-Frame-Options', 'sameorigin');
+        }
+        // 4.4 Protection MIME Sniffing
+        if (result.option && parseInt(result.option.mimemis_protection) === 1) {
+            res.setHeader('X-Content-Type-Options', 'nosniff');
+        }
+        // 4.5 Forcer HTTPS (HSTS)
+        if (result.option && parseInt(result.option.force_secure_conn) === 1) {
+            res.setHeader('Strict-Transport-Security', 'max-age=15552000; preload');
+        }
+        // 4.6 Referrer-Policy — Empêche la fuite d'URL vers des sites tiers
+        if (result.option && parseInt(result.option.referrer_policy) === 1) {
+            res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');
+        }
+        // 4.7 Permissions-Policy — Désactive les fonctionnalités du navigateur
+        if (result.option && parseInt(result.option.permissions_policy) === 1) {
+            res.setHeader('Permissions-Policy', 'camera=(), microphone=(), geolocation=()');
+        }
+        // 4.8 DNS Prefetch Control — Empêche le navigateur de résoudre les domaines externes
+        if (result.option && parseInt(result.option.dns_prefetch_control) === 1) {
+            res.setHeader('X-DNS-Prefetch-Control', 'off');
+        }
+
+        // 4.9 Sanitisation des entrées (Nettoyage XSS dans req.body / req.query)
+        // Équivalent PHP : $_POST = cybershield_sanitize($_POST);
+        if (result.option && parseInt(result.option.sanitize_input) === 1) {
+            if (req.body && typeof req.body === 'object') {
+                req.body = sanitizeInput(req.body);
+            }
+            if (req.query && typeof req.query === 'object') {
+                req.query = sanitizeInput(req.query);
+            }
+            if (req.cookies && typeof req.cookies === 'object') {
+                req.cookies = sanitizeInput(req.cookies);
+            }
+        }
+
+        // 4.10 Blocage des bots de recherche (si option désactivée)
+        if (result.option && parseInt(result.option.allow_search_bots) === 0) {
+            const userAgent = req.headers['user-agent'] || '';
+            if (isSearchBot(userAgent)) {
+                res.setHeader('X-Robots-Tag', 'noindex, nofollow');
+            }
+        }
+
+        // 4.13 HTTP Parameter Pollution (HPP)
+        if (result.option && parseInt(result.option.hpp_protection) === 1) {
+            if (req.query && typeof req.query === 'object') {
+                req.query = cleanParameterPollution(req.query);
+            }
+        }
+
+        // 4.14 Protection JWT Integrity
+        if (result.option && parseInt(result.option.jwt_protection) === 1) {
+            const authHeader = req.headers['authorization'];
+            if (!checkJwtIntegrity(authHeader)) {
+                const targetUrl = (result.setting && typeof result.setting === 'string' && result.setting.length > 0)
+                    ? result.setting
+                    : 'https://block.cybershield.cloud/';
+
+                if (req.headers['sec-fetch-mode'] === 'navigate') {
+                    return res.redirect(302, targetUrl);
+                }
+                return res.status(403).json({
+                    blocked: true,
+                    redirect: targetUrl,
+                    error: "Forbidden",
+                    message: "CyberShield: Token JWT malformé ou dangereux détecté."
+                });
+            }
+        }
+
+        // -----------------------------------------------------------
+        // ETAPE 5 : DÉCISION FINALE (Bloquer ou Laisser Passer)
+        // -----------------------------------------------------------
+
+        const isBanned = result.banIP;
+        const isCountryBlocked = result.blockCountry;
+        const isWhiteIP = result.whiteIP;
+        const isWhiteCountry = result.whiteCountry;
+        const isThreat = result.threat_detected;
+
+        // Condition de blocage
+        if (
+            isBanned ||
+            isCountryBlocked ||
+            (isThreat && !isWhiteIP && !isWhiteCountry)
+        ) {
+            console.log(`[CyberShield WAF] Blocage sur ${req.originalUrl} | IP=${requestData.ip} | Ban=${isBanned} Country=${isCountryBlocked} Threat=${isThreat}`);
+            // URL configurée dans le Dashboard (ou Fallback si introuvable)
+            const targetUrl = (result.setting && typeof result.setting === 'string' && result.setting.length > 0)
+                ? result.setting
+                : 'https://block.cybershield.cloud/';
+            // 1. Navigation classique HTML -> Redirection 302 HTTP
+            if (req.headers['sec-fetch-mode'] === 'navigate') {
+                return res.redirect(302, targetUrl);
+            }
+            // 2. Requête API/Angular (AJAX) -> Renvoie un JSON 403 avec l'instruction de redirect
+            return res.status(403).json({
+                blocked: true,
+                redirect: targetUrl,
+                error: "Forbidden",
+                message: "CyberShield a bloqué cette requête suite à l'analyse de sécurité."
+            });
+        }
+        // Tout est sain → on laisse le backend du client traiter la requête
+        next();
+    } catch (error) {
+        console.error('[CyberShield] Erreur interne dans le WAF (Fail-Open utilisé):', error.message);
+        next();
+    }
+};
+
+/**
+ * Wrapper Principal
+ * 1. Intercepte la télémétrie sans restriction
+ * 2. Bypass les routes ignorées
+ * 3. Délègue au cœur du WAF (analyse MERN)
+ */
+const cybershieldWaf = (req, res, next) => {
+    // INTERCEPTION TÉLÉMÉTRIE
+    if (req.method === 'GET' && req.path.includes('/siteinfo.js')) {
+        const requestedKey = req.path.split('/').pop();
+        if (requestedKey === context.apiKey && context.apiKey) {
+            return res.json(getTelemetryInfo());
+        } else {
+            return res.status(401).json({ success: false, reason: "API key was incorrect" });
+        }
+    }
+
+    // ROUTES IGNORÉES
+    if (context.ignoreRoutes && Array.isArray(context.ignoreRoutes)) {
+        for (const route of context.ignoreRoutes) {
+            if (typeof route === 'string' && req.path.startsWith(route)) {
+                return next(); // Bypass
+            }
+        }
+    }
+    cybershieldWafCore(req, res, next);
+};
+
+module.exports = cybershieldWaf;

package/src/telemetry/cybershield-telemetry.js

@@ -0,0 +1,113 @@
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const context = require('../core/cybershield-context');
+
+/**
+ * Rassemble les informations techniques du serveur Node.js et de l'environnement
+ * de manière équivalente à class-cybershield.php (qui lit PHP_INFO, SERVER_INFO etc.)
+ */
+function getTelemetryInfo() {
+    let modulesList = [];
+
+    try {
+        // Tente de lire les dépendances dans le package.json du projet client
+        const pkgPath = path.resolve(process.cwd(), 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            modulesList = Object.keys(pkg.dependencies || {});
+        }
+    } catch (e) {
+        console.error('[CyberShield] Erreur lors de la lecture du package.json pour la télémétrie', e.message);
+    }
+
+    // POSIX infos (disponible sous Linux/Mac uniquement)
+    let uid = null, groups = [];
+    if (typeof process.getuid === 'function') {
+        uid = process.getuid();
+    }
+    if (typeof process.getgroups === 'function') {
+        groups = process.getgroups();
+    }
+
+    // Storage Info (Utilise fs.statfsSync si Node >= 19.6, sinon N/A)
+    let storageInfo = { free: "N/A", total: "N/A" };
+    try {
+        if (typeof fs.statfsSync === 'function') {
+            // Racine / sur Linux ou MacOS, ou le disque actuel pour Windows (par ex via '/')
+            const stats = fs.statfsSync('/');
+            const freeGb = (stats.bfree * stats.bsize) / (1024 * 1024 * 1024);
+            const totalGb = (stats.blocks * stats.bsize) / (1024 * 1024 * 1024);
+            storageInfo.free = `${freeGb.toFixed(2)} GB`;
+            storageInfo.total = `${totalGb.toFixed(2)} GB`;
+        }
+    } catch (e) {
+        // Fallback muet
+    }
+
+    // Audit Info (Vérification des droits d'écriture)
+    let audit = {
+        test_writable_document_root: { isWritable: false },
+        test_writable_temp_dir: { isWritable: false }
+    };
+    try {
+        fs.accessSync(process.cwd(), fs.constants.W_OK);
+        audit.test_writable_document_root.isWritable = true;
+    } catch (e) { }
+
+    try {
+        fs.accessSync(os.tmpdir(), fs.constants.W_OK);
+        audit.test_writable_temp_dir.isWritable = true;
+    } catch (e) { }
+
+    // Utilitaire pour récupérer l'IP locale (pour NODE_INFO et SERVER_INFO)
+    const ip = (() => {
+        const nets = os.networkInterfaces();
+        for (const name of Object.keys(nets)) {
+            for (const net of nets[name]) {
+                if (net.family === 'IPv4' && !net.internal) {
+                    return net.address;
+                }
+            }
+        }
+        return "127.0.0.1";
+    })();
+
+    // Structure NODE_INFO et SERVER_INFO demandée
+    const nodeInfo = {
+        url: context.siteUrl,
+        hostname: os.hostname(),
+        ip: ip,
+        os: os.type() + " " + os.release(),
+        arch: os.arch(),
+        platform: os.platform(),
+        ver: process.version,
+        soft: `Node.js/${process.version}`,
+        port: process.env.PORT || "Unknown",
+        protocol: context.siteUrl && context.siteUrl.includes('https') ? 'https://' : 'http://',
+        uptime: process.uptime(),
+        cpus: os.cpus().length,
+        env: process.env.NODE_ENV || "development",
+        pid: process.pid,
+        cwd: process.cwd(),
+        temp_dir: os.tmpdir(),
+        posix_getuid: uid,
+        posix_getgroups: groups
+    };
+
+    // Résultat JSON exact
+    return {
+        api_key: context.apiKey,
+        NODE_INFO: nodeInfo,
+        SERVER_INFO: nodeInfo,
+        MODULES: modulesList,
+        MEMORY_INFO: {
+            free: `${(os.freemem() / (1024 * 1024 * 1024)).toFixed(2)} GB`,
+            total: `${(os.totalmem() / (1024 * 1024 * 1024)).toFixed(2)} GB`
+        },
+        STORAGE_INFO: storageInfo,
+        audit: audit
+    };
+}
+
+module.exports = { getTelemetryInfo };

package/src/utils/cybershield-utils.js

@@ -0,0 +1,141 @@
+/**
+ * Fonctions Utilitaires CyberShield
+ * Équivalent Node.js de `global-functions.php` — Fonctions de protection uniquement.
+ */
+
+// NETTOYAGE HTML BRUT 
+
+function cleanInput(data) {
+    if (typeof data !== 'string') return data;
+    let output = data;
+    output = output.replace(/<script[^>]*?>.*?<\/script>/gis, '');  // Strip javascript
+    output = output.replace(/<[\/\!]*?[^<>]*?>/gis, '');            // Strip HTML tags
+    output = output.replace(/<style[^>]*?>.*?<\/style>/gis, '');    // Strip style tags
+    output = output.replace(/<!--[\s\S]*?--[ \t\n\r]*>/g, '');      // Strip comments
+    return output;
+}
+
+// SANITISATION COMPLÈTE 
+
+function sanitizeInput(data) {
+    if (Array.isArray(data)) {
+        return data.map(item => sanitizeInput(item));
+    }
+    if (typeof data === 'object' && data !== null) {
+        const sanitized = {};
+        for (const [key, value] of Object.entries(data)) {
+            sanitized[key] = sanitizeInput(value);
+        }
+        return sanitized;
+    }
+    if (typeof data === 'string') {
+        let output = data;
+        output = output.replace(/"/g, '').replace(/'/g, ''); // str_replace guillemets
+        output = cleanInput(output);                          // cybershield_clean_input
+        output = output                                       // htmlentities(ENT_QUOTES)
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#x27;');
+        return output;
+    }
+    return data; // nombres, booléens, null → inchangés
+}
+
+// DÉTECTION DES BOTS 
+
+const SEARCH_BOT_LIST = [
+    'Googlebot', 'Baiduspider', 'YandexBot', 'ia_archiver',
+    'R6_FeedFetcher', 'NetcraftSurveyAgent',
+    'Sogou web spider', 'bingbot', 'Yahoo! Slurp',
+    'facebookexternalhit', 'PrintfulBot', 'msnbot',
+    'Twitterbot', 'UnwindFetchor', 'urlresolver'
+];
+
+/**
+ * Vérifie si le User-Agent est un bot de moteur de recherche connu.
+ */
+function isSearchBot(userAgent) {
+    if (!userAgent) return false;
+    const ua = userAgent.toLowerCase();
+    return SEARCH_BOT_LIST.some(bot => ua.includes(bot.toLowerCase()));
+}
+
+
+
+
+// HTTP PARAMETER POLLUTION (HPP) BLOCKEUR
+
+/**
+ * Express transforme "?id=1&id=2" en tableau ["1", "2"].
+ * Cela fait cracher beaucoup de bases de données (MongoDB, SQL) qui attendent un String.
+ * Cette fonction nettoie `req.query` pour ne garder que la dernière valeur.
+ * 
+ */
+function cleanParameterPollution(queryObject) {
+    if (!queryObject || typeof queryObject !== 'object') return queryObject;
+    
+    const cleanedQuery = {};
+    for (const [key, value] of Object.entries(queryObject)) {
+        if (Array.isArray(value)) {
+            // Ne garder que la dernière occurrence (comportement PHP natif)
+            cleanedQuery[key] = value[value.length - 1];
+        } else {
+            cleanedQuery[key] = value;
+        }
+    }
+    return cleanedQuery;
+}
+
+// JWT INTEGRITY CHECKER (Vérification de sécurité des Tokens)
+
+/**
+ * Vérifie si le header "Authorization: Bearer <token>" contient un JWT malveillant.
+ * Ne vérifie pas la cryptographie (le SDK n'a pas la clé secrète du client),
+ * mais bloque les attaques structurelles communes (ex: faille "alg: none").
+ * 
+ * @returns {boolean} true si sain, false si attaque détectée
+ */
+function checkJwtIntegrity(authHeader) {
+    if (!authHeader || typeof authHeader !== 'string') return true;
+    
+    if (!authHeader.startsWith('Bearer ')) return true;
+    
+    const token = authHeader.split(' ')[1];
+    if (!token) return true;
+
+    const parts = token.split('.');
+    
+    // Un JWT classique doit OBLIGATOIREMENT avoir 3 parties (Header, Payload, Signature)
+    if (parts.length !== 3) {
+        return false; // Malformé (Tentative de crash du parseur JWT backend)
+    }
+
+    try {
+        // Prévention de la faille critique "alg: none" (Token Bypass)
+        // On décode la 1ère partie du JWT (Base64)
+        const headerBuffer = Buffer.from(parts[0], 'base64');
+        const headerStr = headerBuffer.toString('utf-8');
+        const headerJson = JSON.parse(headerStr);
+        
+        if (!headerJson.alg || headerJson.alg.toLowerCase() === 'none') {
+            return false; // Attaque d'usurpation d'identité interceptée
+        }
+
+    } catch (e) {
+        // Si le Base64 est invalide ou que ce n'est pas du JSON, c'est du Fuzzing
+        return false; 
+    }
+
+    return true; // JWT structurellement sain
+}
+
+module.exports = {
+    cleanInput,
+    sanitizeInput,
+    isSearchBot,
+    SEARCH_BOT_LIST,
+    cleanParameterPollution,
+    checkJwtIntegrity
+};