jerkjs 2.0.1 → 2.0.2

package/examples/v2/app_fixed.js

@@ -0,0 +1,74 @@
+const {
+  APIServer,
+  Authenticator,
+  RouteLoader,
+  Logger,
+  SQLiteTokenAdapter
+} = require('../../index.js');
+
+async function startServer() {
+  // Crear instancia del servidor
+  const server = new APIServer({
+    port: 8088,
+    host: 'localhost'
+  });
+
+  // Crear instancia del logger
+  const logger = new Logger({ level: 'info' });
+
+  try {
+    // Crear instancia del adaptador de tokens SQLite
+    const tokenAdapter = new SQLiteTokenAdapter({
+      dbPath: './tokens_example.sqlite',
+      tableName: 'example_tokens'
+    });
+
+    // Inicializar el adaptador de tokens
+    await tokenAdapter.initialize();
+    logger.info('SQLite Token Adapter inicializado correctamente');
+
+    // Crear instancia del autenticador
+    const authenticator = new Authenticator({ logger });
+
+    // Registrar estrategia de autenticación JWT que utiliza el adaptador SQLite
+    authenticator.use('jwt-sqlite', async (req, options = {}) => {
+      const authHeader = req.headers.authorization;
+      const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN
+
+      if (!token) {
+        return false;
+      }
+
+      // Validar el token contra la base de datos SQLite
+      const tokenRecord = await tokenAdapter.validateToken(token);
+
+      if (tokenRecord) {
+        // Agregar información del usuario a la solicitud
+        req.user = { userId: tokenRecord.user_id, tokenType: tokenRecord.token_type };
+        return true;
+      }
+
+      return false;
+    });
+
+    // Agregar el autenticador al servidor para que pueda ser usado por el RouteLoader
+    server.authenticator = authenticator;
+
+    // Cargar rutas desde archivo JSON
+    const routeLoader = new RouteLoader();
+    await routeLoader.loadRoutes(server, './routes.json');
+
+    // Iniciar el servidor
+    server.start();
+
+    logger.info('Servidor iniciado en http://localhost:8088');
+  } catch (error) {
+    logger.error('Error iniciando el servidor:', error.message);
+    process.exit(1);
+  }
+}
+
+// Iniciar el servidor
+startServer();
+
+module.exports = { startServer };

package/examples/v2/controllers/authController.js

@@ -0,0 +1,64 @@
+const jwt = require('jsonwebtoken');
+const { SQLiteTokenAdapter } = require('../../../index.js');
+
+// Adaptador de tokens para este controlador
+const tokenAdapter = new SQLiteTokenAdapter({
+  dbPath: './tokens_example.sqlite',
+  tableName: 'example_tokens'
+});
+
+// Asegurarse de que el adaptador esté inicializado
+tokenAdapter.initialize().catch(console.error);
+
+const authController = {
+  login: async (req, res) => {
+    try {
+      const { username, password } = req.body;
+
+      // Validación simple de credenciales (esto debería ser más robusto en producción)
+      if (!username || !password) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Nombre de usuario y contraseña requeridos' }));
+        return;
+      }
+
+      // Simulación de autenticación (en una aplicación real, esto verificaría contra una base de datos)
+      if (username === 'admin' && password === 'password') {
+        // Generar un token JWT
+        const payload = { 
+          userId: 1, 
+          username: username,
+          role: 'admin'
+        };
+        
+        // Secret para firmar el token (en producción, debería estar en variables de entorno)
+        const secret = 'super-secret-key-for-example';
+        const token = jwt.sign(payload, secret, { expiresIn: '1h' });
+
+        // Guardar el token en la base de datos SQLite
+        await tokenAdapter.saveToken(
+          token,
+          { userId: 1 },
+          'access',
+          new Date(Date.now() + 60 * 60 * 1000) // 1 hora
+        );
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ 
+          message: 'Inicio de sesión exitoso',
+          token: token,
+          user: payload
+        }));
+      } else {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Credenciales inválidas' }));
+      }
+    } catch (error) {
+      console.error('Error en login:', error);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Error interno del servidor' }));
+    }
+  }
+};
+
+module.exports = authController;

package/examples/v2/controllers/mainController.js

@@ -0,0 +1,24 @@
+const jwt = require('jsonwebtoken');
+const { SQLiteTokenAdapter } = require('../../../index.js');
+
+// Adaptador de tokens para este controlador
+const tokenAdapter = new SQLiteTokenAdapter({
+  dbPath: './tokens_example.sqlite',
+  tableName: 'example_tokens'
+});
+
+const mainController = {
+  home: (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ 
+      message: 'Bienvenido a la API de ejemplo con autenticación SQLite',
+      endpoints: {
+        'POST /login': 'Iniciar sesión y obtener token',
+        'GET /protected': 'Contenido protegido (requiere token)',
+        'GET /profile': 'Perfil de usuario (requiere token)'
+      }
+    }));
+  }
+};
+
+module.exports = mainController;

package/examples/v2/controllers/protectedController.js

@@ -0,0 +1,12 @@
+const protectedController = {
+  getProtectedData: (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ 
+      message: 'Datos protegidos accesados exitosamente',
+      user: req.user,
+      timestamp: new Date().toISOString()
+    }));
+  }
+};
+
+module.exports = protectedController;

package/examples/v2/controllers/userController.js

@@ -0,0 +1,16 @@
+const userController = {
+  getProfile: (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ 
+      profile: {
+        id: req.user.userId,
+        username: req.user.username || 'Usuario',
+        role: req.user.role || 'guest',
+        tokenType: req.user.tokenType
+      },
+      message: 'Perfil de usuario obtenido exitosamente'
+    }));
+  }
+};
+
+module.exports = userController;

package/examples/v2/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "jerk-example-v2",
+  "version": "1.0.0",
+  "description": "Ejemplo de API con autenticación SQLite usando el Framework JERK",
+  "main": "app.js",
+  "scripts": {
+    "start": "node app.js",
+    "dev": "nodemon app.js"
+  },
+  "keywords": [
+    "api",
+    "sdk",
+    "authentication",
+    "sqlite",
+    "jwt",
+    "framework"
+  ],
+  "author": "JERK Framework",
+  "license": "MIT",
+  "dependencies": {
+    "jsonwebtoken": "^9.0.0",
+    "sqlite3": "^5.1.6"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.0"
+  }
+}

package/examples/v2/routes.json

@@ -0,0 +1,30 @@
+[
+  {
+    "path": "/",
+    "method": "GET",
+    "controller": "./controllers/mainController.js",
+    "handler": "home",
+    "auth": "none"
+  },
+  {
+    "path": "/login",
+    "method": "POST",
+    "controller": "./controllers/authController.js",
+    "handler": "login",
+    "auth": "none"
+  },
+  {
+    "path": "/protected",
+    "method": "GET",
+    "controller": "./controllers/protectedController.js",
+    "handler": "getProtectedData",
+    "auth": "jwt-sqlite"
+  },
+  {
+    "path": "/profile",
+    "method": "GET",
+    "controller": "./controllers/userController.js",
+    "handler": "getProfile",
+    "auth": "jwt-sqlite"
+  }
+]

package/examples/v2/test_api.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+
+echo "Iniciando prueba de la API con autenticación SQLite..."
+
+# Iniciar el servidor en segundo plano
+node app.js &
+SERVER_PID=$!
+
+# Esperar a que el servidor inicie
+sleep 3
+
+echo "Probando endpoints..."
+
+# Probar endpoint público
+echo "1. Probando endpoint público (/)"
+curl -s -w "\n%{http_code}\n" -X GET http://localhost:8088/
+
+# Probar login
+echo -e "\n2. Probando login..."
+TOKEN=$(curl -s -X POST http://localhost:8088/login \
+  -H "Content-Type: application/json" \
+  -d '{"username": "admin", "password": "password"}' | jq -r '.token')
+
+if [ "$TOKEN" != "null" ] && [ -n "$TOKEN" ]; then
+  echo "Login exitoso, token obtenido: ${TOKEN:0:20}..."
+  
+  # Probar endpoint protegido con token
+  echo -e "\n3. Probando endpoint protegido (/protected) con token..."
+  curl -s -w "\n%{http_code}\n" -X GET http://localhost:8088/protected \
+    -H "Authorization: Bearer $TOKEN"
+  
+  # Probar endpoint de perfil con token
+  echo -e "\n4. Probando endpoint de perfil (/profile) con token..."
+  curl -s -w "\n%{http_code}\n" -X GET http://localhost:8088/profile \
+    -H "Authorization: Bearer $TOKEN"
+else
+  echo "Error: No se pudo obtener el token de login"
+fi
+
+# Probar endpoint protegido sin token (debería fallar)
+echo -e "\n5. Probando endpoint protegido (/protected) sin token (debería fallar)..."
+curl -s -w "\n%{http_code}\n" -X GET http://localhost:8088/protected
+
+echo -e "\nPrueba completada."
+
+# Detener el servidor
+kill $SERVER_PID

package/examples/v2.1_firewall_demo/README.md

@@ -0,0 +1,113 @@
+# Ejemplo de API con Funcionalidades de Firewall Avanzado (v2.1.0)
+
+Este ejemplo demuestra las funcionalidades de firewall avanzado implementadas en la versión 2.1.0 del Framework JERK, incluyendo el sistema de hooks para eventos de seguridad.
+
+## Características del Firewall
+
+- **Detección de Patrones de Ataque**: Identificación de SQL Injection, XSS, Path Traversal
+- **Bloqueo de IPs**: Sistema de bloqueo tras múltiples intentos fallidos
+- **Listas Blancas y Negras**: IPs permitidas o prohibidas permanentemente
+- **Reglas Personalizadas**: Posibilidad de definir reglas personalizadas de firewall
+- **Sistema de Hooks**: Integración con el sistema de hooks para eventos de seguridad
+- **Monitoreo de Solicitudes Sospechosas**: Registro y seguimiento de actividades sospechosas
+
+## Configuración
+
+No se requieren dependencias adicionales más allá del Framework JERK.
+
+## Uso
+
+1. Inicia el servidor:
+   ```bash
+   node app.js
+   ```
+
+2. El servidor escuchará en `http://localhost:8097`
+
+## Endpoints de Prueba
+
+- `GET /` - Página de inicio con información del firewall
+- `GET /test-attacks` - Prueba de detección de ataques
+- `GET /test-sql-injection` - Prueba de detección de SQL injection (será bloqueada)
+- `GET /test-xss` - Prueba de detección de XSS (será bloqueada)
+- `GET /test-path-traversal` - Prueba de detección de path traversal (será bloqueada)
+- `GET /firewall-status` - Estado actual del firewall
+
+## Pruebas de Seguridad
+
+### Prueba de SQL Injection
+```bash
+curl -X GET "http://localhost:8097/test-sql-injection?id=1'%20OR%20'1'='1"
+```
+
+### Prueba de XSS
+```bash
+curl -X GET "http://localhost:8097/test-xss?input=<script>alert('xss')</script>"
+```
+
+### Prueba de Path Traversal
+```bash
+curl -X GET "http://localhost:8097/test-path-traversal?file=../../../etc/passwd"
+```
+
+### Prueba de User Agent Sospechoso
+```bash
+curl -X GET http://localhost:8097/test-attacks -H "User-Agent: sqlmap/1.0"
+```
+
+## Sistema de Hooks de Seguridad
+
+El ejemplo demuestra cómo usar el sistema de hooks para eventos de seguridad:
+
+- `firewall_rule_triggered` - Se dispara cuando se activa una regla de firewall
+- `firewall_ip_blocked` - Se dispara cuando se bloquea una IP
+- `firewall_security_event` - Se dispara para eventos generales de seguridad
+
+## Configuración del Firewall
+
+El firewall se puede configurar con las siguientes opciones:
+
+```javascript
+const firewall = new Firewall({
+  maxAttempts: 5,           // Número máximo de intentos antes de bloquear
+  blockDuration: 900000,    // Duración del bloqueo en ms (15 minutos)
+  whitelist: ['127.0.0.1'], // IPs que no deben ser bloqueadas
+  blacklist: [],            // IPs que siempre deben ser bloqueadas
+  rules: [                  // Reglas personalizadas de firewall
+    {
+      name: 'large_payload',
+      condition: (req) => {
+        // Condición para activar la regla
+      },
+      action: 'block',      // 'block' o 'monitor'
+      reason: 'Motivo del bloqueo'
+    }
+  ],
+  logger: logger            // Instancia de logger para eventos
+});
+```
+
+## Estructura del proyecto
+
+```
+examples/v2.1_firewall_demo/
+├── app.js              # Punto de entrada de la aplicación con firewall
+├── controllers/        # Controladores de las rutas
+│   └── (controladores según sea necesario)
+└── README.md
+```
+
+## Reglas de Firewall Integradas
+
+1. **SQL Injection Detection**: Detecta patrones comunes de inyección SQL
+2. **XSS Detection**: Detecta patrones comunes de Cross-Site Scripting
+3. **Path Traversal**: Detecta intentos de navegación fuera del directorio permitido
+4. **Large Payload**: Bloquea solicitudes con cuerpos excesivamente grandes
+5. **Suspicious User Agents**: Detecta user agents asociados con herramientas de ataque
+
+## Seguridad
+
+- El firewall bloquea automáticamente solicitudes que contienen patrones de ataque conocidos
+- Las IPs que generan múltiples violaciones son bloqueadas temporalmente
+- Las reglas personalizadas permiten una protección adaptada a necesidades específicas
+- El sistema de hooks permite una respuesta personalizada a eventos de seguridad

package/examples/v2.1_firewall_demo/app.js

@@ -0,0 +1,182 @@
+/**
+ * Ejemplo de API con funcionalidades de firewall avanzado (v2.1.0)
+ * Demostrando el uso del sistema de firewall con el sistema de hooks
+ */
+
+const {
+  APIServer,
+  Authenticator,
+  RateLimiter,
+  Logger,
+  HookSystem,
+  Firewall
+} = require('../../index.js');
+
+async function startServer() {
+  // Crear instancia del servidor
+  const server = new APIServer({
+    port: 8097,
+    host: 'localhost'
+  });
+
+  // Crear instancia del logger
+  const logger = new Logger({ level: 'info' });
+
+  // Crear instancia del sistema de hooks
+  const hooks = new HookSystem();
+
+  // Crear instancia del firewall
+  const firewall = new Firewall({
+    maxAttempts: 3,
+    blockDuration: 300000, // 5 minutos para pruebas
+    whitelist: ['127.0.0.1', '::1'], // IPs locales
+    blacklist: [], // Ninguna IP bloqueada por defecto
+    rules: [
+      {
+        name: 'large_payload',
+        condition: (req) => {
+          // Bloquear solicitudes con cuerpo muy grande
+          const contentLength = req.headers['content-length'];
+          return contentLength && parseInt(contentLength) > 1024 * 100; // 100KB
+        },
+        action: 'block',
+        reason: 'Solicitud con payload excesivamente grande'
+      },
+      {
+        name: 'suspicious_user_agent',
+        condition: (req) => {
+          const userAgent = req.headers['user-agent'] || '';
+          // Detectar user agents sospechosos
+          const suspiciousAgents = [
+            /sqlmap/i,
+            /nikto/i,
+            /nessus/i,
+            /nmap/i,
+            /dirbuster/i
+          ];
+
+          return suspiciousAgents.some(agent => agent.test(userAgent));
+        },
+        action: 'block',
+        reason: 'User agent sospechoso detectado'
+      }
+    ],
+    logger
+  });
+
+  try {
+    // Registrar hooks para eventos de firewall
+    hooks.addAction('firewall_rule_triggered', (rule, clientIP, req) => {
+      logger.info(`[[FIREWALL-HOOK]] Regla activada: ${rule.name} para IP: ${clientIP}`);
+    });
+
+    hooks.addAction('firewall_ip_blocked', (ip, reason) => {
+      logger.warn(`[[FIREWALL-HOOK]] IP bloqueada: ${ip} por razón: ${reason}`);
+    });
+
+    hooks.addAction('firewall_security_event', (event, details) => {
+      logger.info(`[[FIREWALL-HOOK]] Evento de seguridad: ${event}`, details);
+    });
+
+    // Aplicar middleware de firewall al servidor
+    server.use(firewall.middleware());
+
+    // Ruta pública
+    server.addRoute('GET', '/', (req, res) => {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        message: 'API con funcionalidades de firewall avanzado (v2.1.0)',
+        features: [
+          'Detección de patrones de ataque (SQL Injection, XSS, Path Traversal)',
+          'Bloqueo de IPs tras intentos fallidos',
+          'Listas blancas y negras de IPs',
+          'Reglas personalizadas de firewall',
+          'Sistema de hooks para eventos de seguridad',
+          'Monitoreo de solicitudes sospechosas'
+        ],
+        firewallStatus: firewall.getStatus(),
+        timestamp: new Date().toISOString()
+      }));
+    });
+
+    // Ruta para probar diferentes tipos de ataques
+    server.addRoute('GET', '/test-attacks', (req, res) => {
+      // Disparar un hook personalizado para demostrar el sistema
+      hooks.doAction('firewall_security_event', 'attack_test_requested', {
+        clientIP: firewall.getClientIP(req),
+        userAgent: req.headers['user-agent'],
+        timestamp: new Date().toISOString()
+      });
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        message: 'Prueba de ataques completada',
+        clientIP: firewall.getClientIP(req),
+        securityLevel: 'monitored',
+        timestamp: new Date().toISOString()
+      }));
+    });
+
+    // Ruta para probar SQL injection (esta debería ser bloqueada)
+    server.addRoute('GET', '/test-sql-injection', (req, res) => {
+      // Esta ruta no debería ser accesible si se detecta SQL injection en la URL
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        message: '¡Esto no debería verse si se detectó SQL injection!',
+        status: 'compromised',
+        timestamp: new Date().toISOString()
+      }));
+    });
+
+    // Ruta para probar XSS (esta debería ser bloqueada)
+    server.addRoute('GET', '/test-xss', (req, res) => {
+      // Esta ruta no debería ser accesible si se detecta XSS en la URL
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        message: '¡Esto no debería verse si se detectó XSS!',
+        status: 'compromised',
+        timestamp: new Date().toISOString()
+      }));
+    });
+
+    // Ruta para probar path traversal (esta debería ser bloqueada)
+    server.addRoute('GET', '/test-path-traversal', (req, res) => {
+      // Esta ruta no debería ser accesible si se detecta path traversal
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        message: '¡Esto no debería verse si se detectó path traversal!',
+        status: 'compromised',
+        timestamp: new Date().toISOString()
+      }));
+    });
+
+    // Ruta para verificar estado del firewall
+    server.addRoute('GET', '/firewall-status', (req, res) => {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        firewall: firewall.getStatus(),
+        timestamp: new Date().toISOString()
+      }));
+    });
+
+    // Iniciar el servidor
+    server.start();
+
+    logger.info('Servidor con firewall avanzado iniciado en http://localhost:8097');
+    logger.info('Endpoints disponibles:');
+    logger.info('- GET / - Página de inicio con información de firewall');
+    logger.info('- GET /test-attacks - Prueba de detección de ataques');
+    logger.info('- GET /test-sql-injection - Prueba de detección de SQL injection (será bloqueada)');
+    logger.info('- GET /test-xss - Prueba de detección de XSS (será bloqueada)');
+    logger.info('- GET /test-path-traversal - Prueba de detección de path traversal (será bloqueada)');
+    logger.info('- GET /firewall-status - Estado actual del firewall');
+  } catch (error) {
+    logger.error('Error iniciando el servidor:', error.message);
+    process.exit(1);
+  }
+}
+
+// Iniciar el servidor
+startServer();
+
+module.exports = { startServer };

package/examples/v2.1_firewall_demo/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "jerk-firewall-demo",
+  "version": "1.0.0",
+  "description": "Ejemplo de API con funcionalidades de firewall avanzado usando el Framework JERK",
+  "main": "app.js",
+  "scripts": {
+    "start": "node app.js",
+    "dev": "nodemon app.js"
+  },
+  "keywords": [
+    "api",
+    "sdk",
+    "firewall",
+    "security",
+    "advanced",
+    "protection",
+    "framework"
+  ],
+  "author": "JERK Framework",
+  "license": "MIT",
+  "dependencies": {
+    "jsonwebtoken": "^9.0.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.0"
+  }
+}