jerkjs 2.1.1 → 2.1.2

package/examples/v2/README.md

@@ -1,72 +0,0 @@
-# Ejemplo API con Autenticación SQLite
-
-Este ejemplo demuestra cómo crear una API con autenticación basada en tokens almacenados en SQLite utilizando el Framework JERK.
-
-## Características
-
-- Autenticación JWT con tokens almacenados en SQLite
-- Rutas protegidas y públicas
-- Sistema de login para obtener tokens
-- Controladores organizados por funcionalidad
-
-## Configuración
-
-1. Asegúrate de tener instaladas las dependencias del framework JERK
-2. Instala sqlite3 si aún no está instalado: `npm install sqlite3`
-
-## Uso
-
-1. Inicia el servidor:
-   ```bash
-   node app.js
-   ```
-
-2. El servidor escuchará en `http://localhost:8088`
-
-## Endpoints
-
-- `GET /` - Página de inicio (público)
-- `POST /login` - Iniciar sesión y obtener token (público)
-- `GET /protected` - Contenido protegido (requiere token)
-- `GET /profile` - Perfil de usuario (requiere token)
-
-## Ejemplo de uso
-
-1. Iniciar sesión:
-   ```bash
-   curl -X POST http://localhost:8088/login \
-     -H "Content-Type: application/json" \
-     -d '{"username": "admin", "password": "password"}'
-   ```
-
-2. Acceder a contenido protegido:
-   ```bash
-   curl -X GET http://localhost:8088/protected \
-     -H "Authorization: Bearer TU_TOKEN_AQUI"
-   ```
-
-3. Ver perfil de usuario:
-   ```bash
-   curl -X GET http://localhost:8088/profile \
-     -H "Authorization: Bearer TU_TOKEN_AQUI"
-   ```
-
-## Estructura del proyecto
-
-```
-examples/v2/
-├── app.js              # Punto de entrada de la aplicación
-├── routes.json         # Definición de rutas
-├── controllers/        # Controladores de las rutas
-│   ├── mainController.js
-│   ├── authController.js
-│   ├── protectedController.js
-│   └── userController.js
-└── tokens_example.sqlite  # Base de datos SQLite para tokens (generada automáticamente)
-```
-
-## Seguridad
-
-- Los tokens se almacenan en una base de datos SQLite
-- Los tokens expiran después de 1 hora
-- Las rutas protegidas requieren un token válido en el header Authorization

package/examples/v2/app.js

@@ -1,74 +0,0 @@
-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/app_fixed.js

@@ -1,74 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,27 +0,0 @@
-{
-  "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

@@ -1,30 +0,0 @@
-[
-  {
-    "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

@@ -1,47 +0,0 @@
-#!/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

@@ -1,113 +0,0 @@
-# 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