blackcoffee2 2.1.0

package/manuales/WAF_MODULE_MANUAL.md

@@ -0,0 +1,229 @@
+# Manual del Módulo WAF (Web Application Firewall) para Insitu Framework
+
+## Tabla de Contenidos
+1. [Introducción](#introducción)
+2. [Características del WAF](#características-del-waf)
+3. [Comandos Disponibles](#comandos-disponibles)
+4. [Estadísticas del Servidor](#estadísticas-del-servidor)
+5. [Gestión de Reglas X-Headers](#gestión-de-reglas-x-headers)
+6. [Listas de IPs](#listas-de-ips)
+7. [Persistencia de Reglas](#persistencia-de-reglas)
+8. [Ejemplos de Uso](#ejemplos-de-uso)
+
+## Introducción
+
+El módulo WAF (Web Application Firewall) es una extensión de la extensión de administración de Insitu Framework que permite monitorear, gestionar y proteger tu aplicación web. Proporciona estadísticas en tiempo real, gestión de reglas de seguridad y control de acceso basado en headers X-.
+
+## Características del WAF
+
+- **Estadísticas en tiempo real**: Conteo de solicitudes procesadas y respuestas enviadas con medición en kilobytes
+- **Monitoreo de tráfico**: Registro de accesos a rutas y endpoints
+- **Sistema de reglas X-Headers**: Bloqueo basado en headers como X-Forwarded-For, X-Real-IP, etc.
+- **Listas de IPs**: Sistema de whitelist (nunca bloqueadas) y blacklist (siempre bloqueadas)
+- **Persistencia**: Guardado y carga de reglas de seguridad
+- **Interfaz interactiva**: Sistema de comandos para gestión en tiempo real
+
+## Comandos Disponibles
+
+### Comandos Generales de Estadísticas
+- `waf-status` o `waf-stats`: Muestra estadísticas generales del servidor
+- `waf-blocked` o `waf-security`: Muestra estadísticas de seguridad
+- `waf-x-headers`: Muestra reglas de headers X- configuradas
+
+### Comandos de Gestión de Reglas
+- `create-x-rule`: Crea una nueva regla de seguridad basada en headers X-
+- `remove-x-rule`: Remueve una regla de seguridad existente
+- `save-rules`: Guarda todas las reglas a un archivo
+- `load-rules`: Carga reglas desde un archivo
+
+### Comandos de Gestión de IPs
+- `waf-block-ip`: Bloquea temporalmente una IP
+- `waf-unblock-ip`: Desbloquea una IP temporalmente bloqueada
+- `waf-whitelist`: Agrega una IP a la lista blanca
+- `waf-blacklist`: Agrega una IP a la lista negra
+
+## Estadísticas del Servidor
+
+### waf-status / waf-stats
+Muestra las estadísticas generales del servidor:
+
+```
+=== Estadísticas del WAF ===
+Solicitudes procesadas: 15
+Solicitudes procesadas (KB): 2.45 KB
+Respuestas enviadas: 15
+Respuestas enviadas (KB): 15.67 KB
+IPs en lista blanca: 2
+IPs en lista negra: 1
+Reglas de seguridad activas: 3
+```
+
+### Campos de Estadísticas
+- **Solicitudes procesadas**: Número total de solicitudes HTTP procesadas
+- **Solicitudes procesadas (KB)**: Cantidad total de datos recibidos en kilobytes
+- **Respuestas enviadas**: Número total de respuestas HTTP enviadas
+- **Respuestas enviadas (KB)**: Cantidad total de datos enviados en kilobytes
+- **IPs en lista blanca**: Número de IPs que nunca serán bloqueadas
+- **IPs en lista negra**: Número de IPs que siempre serán bloqueadas
+- **Reglas de seguridad activas**: Número de reglas de seguridad activas
+
+## Gestión de Reglas X-Headers
+
+### Crear Regla (`create-x-rule`)
+Proceso interactivo para crear reglas de seguridad basadas en headers X-:
+
+1. **Nombre del header**: Introduce el nombre del header X- (ej: X-Forwarded-For, X-Real-IP)
+2. **Patrón**: Introduce el patrón para coincidir (cadena o expresión regular)
+3. **Acción**: Selecciona la acción a tomar:
+   - `1` o `block`: Bloquear solicitudes que coincidan
+   - `2` o `log`: Registrar solicitudes que coincidan
+   - `3` o `monitor`: Monitorear solicitudes que coincidan
+4. **Razón**: Introduce la razón para la regla (opcional)
+
+### Remover Regla (`remove-x-rule`)
+Proceso interactivo para remover reglas existentes:
+1. Se muestra una lista numerada de reglas disponibles
+2. Introduce el número de la regla que deseas remover
+3. La regla se elimina inmediatamente del sistema
+
+## Listas de IPs
+
+### Whitelist (`waf-whitelist`)
+Agrega una IP a la lista blanca (nunca será bloqueada):
+
+```
+> waf-whitelist
+Introduce la IP a agregar a la lista blanca (ej: 192.168.1.100):
+> 192.168.1.100
+IP 192.168.1.100 agregada a la lista blanca.
+```
+
+### Blacklist (`waf-blacklist`)
+Agrega una IP a la lista negra (siempre será bloqueada):
+
+```
+> waf-blacklist
+Introduce la IP a agregar a la lista negra (ej: 10.0.0.100):
+> 10.0.0.100
+IP 10.0.0.100 agregada a la lista negra.
+```
+
+### Bloqueo Temporal (`waf-block-ip`)
+Bloquea temporalmente una IP:
+
+```
+> waf-block-ip
+Introduce la IP a bloquear temporalmente (ej: 192.168.1.100):
+> 192.168.1.200
+IP 192.168.1.200 bloqueada temporalmente.
+```
+
+## Persistencia de Reglas
+
+### Guardar Reglas (`save-rules`)
+Guarda todas las reglas de seguridad actuales a un archivo JSON:
+
+```
+> save-rules
+✅ Reglas guardadas exitosamente en: /path/to/waf-rules/waf-rules-timestamp.json
+Total de reglas guardadas: 3
+```
+
+### Cargar Reglas (`load-rules`)
+Carga reglas de seguridad desde un archivo JSON:
+
+```
+> load-rules
+=== Archivos de Reglas Disponibles ===
+1. waf-rules-1770795262452.json
+
+Introduce el número del archivo a cargar (o "cancel" para cancelar):
+> 1
+
+¿Deseas reemplazar las reglas actuales? (sí/no):
+> sí
+
+✅ Reglas cargadas exitosamente desde: /path/to/waf-rules/waf-rules-1770795262452.json
+Total de reglas cargadas: 3
+```
+
+## Ejemplos de Uso
+
+### Ejemplo 1: Crear Regla para Bloquear IPs Internas
+```
+> create-x-rule
+=== Crear Regla de Header X- ===
+Introduce el nombre del header X- (ej: X-Forwarded-For, X-Real-IP):
+> X-Forwarded-For
+Header seleccionado: X-Forwarded-For
+Introduce el patrón para coincidir (cadena o expresión regular):
+> 192.168.
+Selecciona la acción a tomar:
+1. block - Bloquear solicitudes que coincidan
+2. log - Registrar solicitudes que coincidan
+3. monitor - Monitorear solicitudes que coincidan
+Escribe el número o el nombre de la acción:
+> 1
+Acción seleccionada: block
+Introduce la razón para la regla (opcional):
+> Bloquear IPs internas
+✅ Regla de header X- creada exitosamente:
+  ID: xheader_x_forwarded_for_1770792842636
+  Header: x-forwarded-for
+  Patrón: 192.168.
+  Acción: block
+  Razón: Bloquear IPs internas
+```
+
+### Ejemplo 2: Ver Estadísticas de Seguridad
+```
+> waf-security
+=== Estadísticas de Seguridad del WAF ===
+IPs bloqueadas temporalmente: 2
+Intentos de ataque detectados: 5
+Tipos de ataques detectados: 3
+Registros de seguridad: 10
+
+Accesos a rutas (Input/Output):
+  GET /: 8 accesos
+  POST /api/users: 3 accesos
+  GET /api/users: 4 accesos
+
+Endpoints más accedidos:
+  GET /: 8 hits
+  GET /api/users: 4 hits
+  POST /api/users: 3 hits
+```
+
+### Ejemplo 3: Agregar IP a Lista Negra
+```
+> waf-blacklist
+Introduce la IP a agregar a la lista negra (ej: 10.0.0.100):
+> 10.0.0.100
+IP 10.0.0.100 agregada a la lista negra.
+```
+
+## Consideraciones de Seguridad
+
+- El servidor de administración solo escucha en localhost (127.0.0.1) por defecto
+- Todas las operaciones de bloqueo son inmediatas y afectan al sistema en tiempo real
+- Las reglas de seguridad se aplican antes de que la solicitud llegue a los controladores
+- El sistema de persistencia permite mantener reglas entre reinicios del servidor
+
+## Solución de Problemas
+
+### Las estadísticas no se actualizan
+- Verifica que el middleware de firewall esté activo en tu servidor
+- Asegúrate de que las solicitudes estén pasando por el sistema de firewall
+
+### Las reglas no se aplican
+- Verifica que el firewall esté correctamente integrado en tu pipeline de middlewares
+- Confirma que las reglas se hayan creado correctamente usando `waf-x-headers`
+
+## Autor
+
+Insitu Framework Team
+
+## Versión
+
+v1.0.0

package/manuales/after_route_handler_filter_example.md

@@ -0,0 +1,116 @@
+# Cómo usar `addFilter` para `after_route_handler`
+
+El hook `after_route_handler` está implementado como filtro y acción, lo que significa que puedes usar `addFilter` para modificar los objetos `req`, `res` o `matchedRoute` después de que se ejecuta el handler de la ruta.
+
+## Ejemplo básico de uso:
+
+```javascript
+// Suponiendo que tienes acceso al objeto hooks del framework
+hooks.addFilter('after_route_handler', (data, req, res, matchedRoute) => {
+  // Puedes modificar req, res o matchedRoute aquí después de que se ejecutó el handler
+  // El objeto data contiene { req, res, matchedRoute }
+  
+  // Por ejemplo, registrar información sobre la respuesta
+  console.log(`Handler completado para: ${req.method} ${req.url}`);
+  
+  // O agregar encabezados personalizados después de la ejecución
+  if (!res.headersSent) {
+    res.setHeader('X-Response-Time', Date.now() - req.startTime);
+  }
+  
+  // Devolver el objeto modificado
+  return {
+    ...data,
+    req: req,
+    res: res
+  };
+}, 10, 3);
+```
+
+## Ejemplo más complejo:
+
+```javascript
+// Registro de métricas de rendimiento después de la ejecución del handler
+hooks.addFilter('after_route_handler', (data, req, res, matchedRoute) => {
+  // Calcular el tiempo de ejecución del handler
+  const executionTime = Date.now() - (req.handlerStartTime || Date.now());
+  
+  // Registrar métricas
+  console.log(`Handler completado en ${executionTime}ms para: ${req.method} ${req.url}`);
+  
+  // Agregar información de auditoría
+  req.responseAudit = {
+    timestamp: new Date().toISOString(),
+    executionTime: executionTime,
+    statusCode: res.statusCode || 200
+  };
+  
+  // Devolver el objeto actualizado
+  return {
+    ...data,
+    req: req
+  };
+}, 10, 3);
+```
+
+## Parámetros de `addFilter`:
+
+- **Primer parámetro**: `'after_route_handler'` - El nombre del hook
+- **Segundo parámetro**: La función callback que se ejecutará
+- **Tercer parámetro**: `10` - La prioridad (números más bajos se ejecutan primero)
+- **Cuarto parámetro**: `3` - Número de argumentos aceptados por el callback
+- **Quinto parámetro** (opcional): Un identificador para el callback
+
+## Estructura del callback:
+
+El callback para `after_route_handler` recibe 4 parámetros:
+1. `data` - El objeto que contiene `{ req, res, matchedRoute }`
+2. `req` - El objeto de solicitud (ya modificado por el handler)
+3. `res` - El objeto de respuesta (posiblemente ya enviado por el handler)
+4. `matchedRoute` - Información sobre la ruta coincidente
+
+El callback debe devolver el objeto modificado que será usado por el sistema.
+
+## Ejemplo de uso en un módulo de auditoría:
+
+```javascript
+// En algún módulo de tu aplicación
+const afterRouteHandlerFilter = (data, req, res, matchedRoute) => {
+  // Registrar información de auditoría después de la ejecución del handler
+  const auditLog = {
+    timestamp: new Date().toISOString(),
+    method: req.method,
+    url: req.url,
+    userId: req.userId || 'anonymous',
+    statusCode: res.statusCode,
+    executionTime: Date.now() - (req.handlerStartTime || Date.now()),
+    route: matchedRoute.path
+  };
+  
+  // Guardar registro de auditoría (podría ser en base de datos, archivo, etc.)
+  console.log('AUDIT:', JSON.stringify(auditLog));
+  
+  // Agregar información de respuesta personalizada si es necesario
+  if (!res.headersSent && req.needsCustomResponse) {
+    res.setHeader('X-Audited', 'true');
+  }
+  
+  return {
+    ...data,
+    req: req
+  };
+};
+
+// Registrar el filtro
+hooks.addFilter('after_route_handler', afterRouteHandlerFilter, 10, 3, 'auditing-filter');
+```
+
+## Consideraciones importantes:
+
+1. **Estado de la respuesta**: En el hook `after_route_handler`, la respuesta puede ya haber sido enviada al cliente (`res.headersSent` puede ser `true`), por lo que debes verificar este estado antes de intentar modificar encabezados o enviar contenido adicional.
+
+2. **Tiempo de ejecución**: Este hook se ejecuta después del handler original, por lo que cualquier modificación a la respuesta debe tener en cuenta que el cuerpo de la respuesta ya puede haber sido enviado.
+
+3. **Uso común**: Este hook es ideal para tareas de auditoría, métricas de rendimiento, registro de actividad y limpieza post-ejecución.
+
+Esta implementación permite interceptar y modificar la solicitud y respuesta después de que se ejecuta el handler de la ruta, proporcionando una potente capacidad de procesamiento post-ejecución.

package/manuales/after_route_handler_usage.md

@@ -0,0 +1,130 @@
+# Cómo usar el hook `after_route_handler`
+
+El hook `after_route_handler` se ejecuta justo después de que se ejecuta el handler de la ruta, y está disponible tanto como acción (`addAction`) como como filtro (`addFilter`).
+
+## Ejemplo 1: Uso como acción para registrar actividad post-ejecución
+
+```javascript
+// Registrar cada vez que se completa la ejecución de un handler
+hooks.addAction('after_route_handler', (req, res, matchedRoute) => {
+  const executionTime = Date.now() - req.startTime;
+  console.log(`Handler completado para: ${req.method} ${req.url} en ${executionTime}ms`);
+  console.log(`Código de estado: ${res.statusCode}`);
+}, 10, 3);
+```
+
+## Ejemplo 2: Uso como filtro para añadir headers después de la ejecución
+
+```javascript
+// Añadir headers personalizados después de ejecutar el handler
+hooks.addFilter('after_route_handler', (data, req, res, matchedRoute) => {
+  // Calcular tiempo de ejecución
+  const executionTime = Date.now() - (req.startTime || Date.now());
+  
+  // Añadir header de tiempo de ejecución si la respuesta no se ha enviado
+  if (!res.headersSent) {
+    res.setHeader('X-Response-Time', `${executionTime}ms`);
+  }
+  
+  // Registrar métricas de rendimiento
+  console.log(`Ruta ${req.url} procesada en ${executionTime}ms`);
+  
+  // Devolver el objeto modificado
+  return {
+    ...data,
+    req: req
+  };
+}, 10, 3);
+```
+
+## Ejemplo 3: Uso como filtro para auditoría post-ejecución
+
+```javascript
+// Registrar información de auditoría después de la ejecución del handler
+hooks.addFilter('after_route_handler', (data, req, res, matchedRoute) => {
+  const auditLog = {
+    timestamp: new Date().toISOString(),
+    method: req.method,
+    url: req.url,
+    userId: req.userId || 'anonymous',
+    statusCode: res.statusCode,
+    executionTime: Date.now() - (req.handlerStartTime || Date.now()),
+    route: matchedRoute.path
+  };
+  
+  // Guardar registro de auditoría
+  console.log('AUDIT:', JSON.stringify(auditLog));
+  
+  return data;
+}, 5, 3);
+```
+
+## Ejemplo 4: Uso como filtro para limpieza de recursos
+
+```javascript
+// Realizar tareas de limpieza después de la ejecución del handler
+hooks.addFilter('after_route_handler', (data, req, res, matchedRoute) => {
+  // Limpiar recursos temporales si es necesario
+  if (req.tempFiles) {
+    req.tempFiles.forEach(file => {
+      // Eliminar archivo temporal
+      fs.unlink(file.path, (err) => {
+        if (err) console.error('Error eliminando archivo temporal:', err);
+      });
+    });
+  }
+  
+  // Registrar fin de ejecución
+  console.log(`Finalizada ejecución para: ${req.method} ${req.url}`);
+  
+  return data;
+}, 15, 3);
+```
+
+## Ejemplo 5: Uso combinado de acción y filtro
+
+```javascript
+// Filtro para calcular métricas
+hooks.addFilter('after_route_handler', (data, req, res, matchedRoute) => {
+  const responseTime = Date.now() - (req.startTime || Date.now());
+  
+  // Añadir información de rendimiento al objeto de solicitud
+  req.performanceMetrics = {
+    responseTime: responseTime,
+    timestamp: new Date()
+  };
+  
+  return {
+    ...data,
+    req: req
+  };
+}, 5, 3);
+
+// Acción para registrar evento
+hooks.addAction('after_route_handler', (req, res, matchedRoute) => {
+  console.log(`[AFTER_ROUTE] Handler completado para ${req.method} ${req.url}`);
+  
+  // Enviar métricas a un servicio de monitoreo
+  if (req.performanceMetrics) {
+    sendMetricsToMonitoringService(req.performanceMetrics);
+  }
+}, 10, 3);
+```
+
+## Parámetros importantes:
+
+- El hook solo se ejecuta para solicitudes que **no sean** del tipo OPTIONS
+- El filtro recibe `(data, req, res, matchedRoute)` y debe devolver el objeto `data` modificado
+- La acción recibe `(req, res, matchedRoute)` y no necesita devolver nada
+- El parámetro `acceptedArgs` define cuántos argumentos acepta tu callback (normalmente 3 para este hook)
+- El parámetro `priority` define el orden de ejecución (valores más bajos se ejecutan primero)
+
+## Consideraciones importantes:
+
+1. **Estado de la respuesta**: En `after_route_handler`, la respuesta puede ya haber sido enviada al cliente (`res.headersSent` puede ser `true`), por lo que debes verificar este estado antes de intentar modificar encabezados o enviar contenido adicional.
+
+2. **Tiempo de ejecución**: Este hook se ejecuta después del handler original, por lo que cualquier modificación a la respuesta debe tener en cuenta que el cuerpo de la respuesta ya puede haber sido enviado.
+
+3. **Uso común**: Este hook es ideal para tareas de auditoría, métricas de rendimiento, registro de actividad post-ejecución y limpieza de recursos.
+
+Este hook es especialmente útil para implementar lógica que debe ejecutarse después de cualquier handler de ruta, permitiendo registrar métricas, auditar la actividad o realizar tareas de limpieza.

package/manuales/an/303/241lisis-completo-insitu-framework.md

@@ -0,0 +1,213 @@
+# Análisis Completo del Framework Insitu
+
+## Descripción General
+
+Insitu es un framework de desarrollo web completo para Node.js que implementa una arquitectura MVC (Modelo-Vista-Controlador) con soporte para APIs REST, seguridad avanzada, y sistemas de plantillas. La versión actual es 2.5.4.
+
+## Arquitectura General
+
+El framework está estructurado en componentes modulares que se comunican entre sí a través de un sistema de hooks y filtros, permitiendo una alta extensibilidad y personalización.
+
+## Componentes Principales
+
+### 1. Servidor Principal (APIServer)
+
+- Implementa un servidor HTTP/HTTPS básico con soporte para rutas parametrizadas
+- Incluye manejo de archivos estáticos con soporte para índices y control de caché
+- Tiene integración con sistema de hooks para extensibilidad
+- Soporta middlewares y manejo de cuerpos de solicitud con límites de tamaño
+
+### 2. Sistema de Enrutamiento
+
+- **Router**: Sistema de enrutamiento avanzado con soporte para rutas anidadas
+- **RouteMatcher**: Componente especializado para coincidencia de rutas parametrizadas con cacheo de expresiones regulares
+- Soporta rutas estáticas y dinámicas con prioridad adecuada
+
+### 3. Middleware
+
+- **CORS**: Middleware para configuración de políticas de recursos cruzados
+- **Authenticator**: Sistema de autenticación con múltiples estrategias (JWT, API Keys, Basic Auth, OAuth2, OpenID Connect)
+- **Session**: Sistema de sesiones con almacenamiento en memoria y cookies seguras
+- **Validator**: Validador de esquemas para solicitudes HTTP
+- **RateLimiter**: Limitador de tasa con almacenamiento en memoria o Redis
+- **Compressor**: Middleware de compresión (gzip/deflate) con sistema de hooks
+- **Firewall**: Web Application Firewall (WAF) con detección de patrones de ataque
+- **AuditLogger**: Sistema de auditoría para eventos de seguridad
+
+### 4. Componentes MVC
+
+- **ControllerBase**: Controlador base con soporte para vistas, layouts y variables
+- **ModelBase**: Clase base para modelos con operaciones CRUD
+- **ViewEngine**: Motor de plantillas profesional con soporte para filtros, helpers, condiciones, bucles e inclusiones
+- **ModelManager**: Gestor de modelos con soporte para múltiples adaptadores
+- **Adaptadores**: Soporte para diferentes motores de base de datos (Memory, MariaDB/MySQL, SQLite)
+
+### 5. Sistema de Seguridad
+
+- **SecurityEnhancedServer**: Servidor con funcionalidades de seguridad avanzada (WAF)
+- **Firewall**: Sistema de firewall con listas blancas/negras y reglas personalizadas
+- **TokenManager**: Gestión de tokens JWT con diferentes tipos de almacenamiento
+- **AttackDetector**: Detector de patrones de ataque (SQL Injection, XSS, etc.)
+
+### 6. Sistema de Hooks
+
+- Implementación completa del sistema de hooks y filtros similar al de WordPress
+- Permite extensibilidad en todos los componentes del framework
+- Soporta namespaces y prioridades para los hooks
+
+### 7. Sistemas de Carga
+
+- **RouteLoader**: Carga de rutas desde archivos JSON
+- **RouteDirectoryLoader**: Carga de rutas desde múltiples archivos JSON en un directorio
+- **ControllerLoader**: Carga dinámica de controladores desde archivos
+
+### 8. Utilidades
+
+- **Logger**: Sistema de logging estructurado con diferentes niveles y formatos
+- **ErrorHandler**: Manejo centralizado de errores con soporte para diferentes tipos de excepciones
+- **ConfigParser**: Parser de configuración desde archivos JSON y variables de entorno
+- **MimeType**: Sistema de detección de tipos MIME
+
+## Características Destacadas
+
+1. **Arquitectura Modular**: Componentes independientes para mayor flexibilidad
+2. **Seguridad Avanzada**: Múltiples capas de seguridad incluyendo WAF
+3. **Sistema de Hooks**: Extensibilidad similar al sistema de WordPress
+4. **Autenticación Flexible**: Soporte para múltiples métodos de autenticación
+5. **Almacenamiento de Tokens**: Soporte para memoria, JSON, SQLite y MariaDB
+6. **Enrutamiento Avanzado**: Soporte para rutas parametrizadas, anidadas y estáticas
+7. **Soporte para Frontend**: Capacidad de servir contenido HTML y otros tipos de contenido
+8. **Sistema de Sesiones**: Gestión completa de sesiones con soporte para autenticación
+9. **Motor de Plantillas MVC**: Sistema profesional de vistas con soporte para filtros, helpers y hooks
+10. **Arquitectura de Modelos Completa (MVC)**: Capa de modelos para la lógica de negocio y acceso a datos
+11. **Sistema de Adaptadores de Base de Datos**: Soporte para múltiples motores de base de datos
+12. **Compatible con qbuilderjs**: Integración con QueryBuilder externo para construir consultas SQL
+
+## Estructura de Directorios
+
+- `lib/`: Código fuente principal del framework
+  - `core/`: Componentes fundamentales (servidor, router, hooks)
+  - `loader/`: Componentes de carga (rutas, controladores)
+  - `middleware/`: Middlewares de seguridad y funcionalidad
+  - `mvc/`: Componentes MVC (controladores, modelos, vistas)
+  - `router/`: Componentes de enrutamiento
+  - `utils/`: Utilidades (logging, manejo de errores, etc.)
+
+## Dependencias
+
+- `bcrypt`: Para hashing de contraseñas
+- `jsonwebtoken`: Para tokens JWT
+- `mariadb`: Para conexión con bases de datos MariaDB/MySQL
+- `sqlite3`: Para conexión con bases de datos SQLite
+- `qbuilderjs`: Para construcción de consultas SQL seguras
+
+## Patrones de Diseño
+
+- **Singleton**: Para componentes centrales como el sistema de hooks
+- **Factory**: Para creación de instancias de modelos y adaptadores
+- **Strategy**: Para diferentes estrategias de autenticación
+- **Observer**: A través del sistema de hooks para extensibilidad
+- **MVC**: Arquitectura modelo-vista-controlador para la separación de responsabilidades
+
+## Funcionalidades Avanzadas
+
+### Sistema de Hooks y Filtros
+
+El framework incluye un sistema completo de hooks y filtros similar al de WordPress, que permite extender la funcionalidad en diferentes puntos del ciclo de vida de la aplicación:
+
+```javascript
+const { hooks } = require('insitu');
+
+// Registrar una acción
+hooks.addAction('firewall_request_blocked', (rule, clientIP, req, res) => {
+  console.log(`Solicitud bloqueada: ${rule.name} para IP: ${clientIP}`);
+});
+
+// Registrar un filtro
+hooks.addFilter('session_create_data', (userData, req) => {
+  return {
+    ...userData,
+    ipAddress: req.headers['x-forwarded-for'] || req.connection.remoteAddress,
+    createdAt: new Date().toISOString()
+  };
+});
+```
+
+### Motor de Plantillas
+
+El motor de plantillas profesional incluye soporte para:
+
+- Variables: `{{variable}}`
+- Condiciones: `{{if variable}}contenido{{endif}}`
+- Bucles: `{{foreach:array}}contenido{{endforeach}}`
+- Inclusiones: `{{include:header}}`
+- Filtros: `{{variable|upper}}`
+- Helpers personalizados
+
+### Sistema de Modelos
+
+La arquitectura de modelos completa permite:
+
+- Encapsular la lógica de negocio y el acceso a datos
+- Utilizar diferentes adaptadores de base de datos
+- Implementar operaciones CRUD estándar
+- Extender con métodos personalizados
+
+## Conclusión
+
+Este framework está diseñado para proporcionar una solución completa para el desarrollo de aplicaciones web seguras y escalables, con una arquitectura modular que permite extender su funcionalidad a través del sistema de hooks y una sólida capa de seguridad que incluye WAF, autenticación multifactor y protección contra ataques comunes.
+
+La arquitectura modular y el sistema de hooks hacen que Insitu sea altamente personalizable y adaptable a diferentes necesidades de desarrollo, mientras que su enfoque en la seguridad y el patrón MVC proporcionan una base sólida para construir aplicaciones robustas y mantenibles.
+
+## Consideraciones de Seguridad Adicionales
+
+### Seguridad de Cookies en el Sistema de Sesiones
+
+Tras un análisis detallado del código de Insitu Framework, se ha identificado que el sistema de sesiones implementado en `lib/middleware/session.js` presenta algunas deficiencias en cuanto a la seguridad de las cookies:
+
+#### Flags de Seguridad Implementadas:
+
+1. **HttpOnly**: 
+   - Esta flag está presente en ambas configuraciones de cookie (creación y destrucción)
+   - **Propósito**: Previene ataques de secuestro de sesión mediante XSS (Cross-Site Scripting)
+   - **Funcionamiento**: Impide que el código JavaScript del lado del cliente acceda al valor de la cookie a través de document.cookie
+   - **Implementación en Insitu**: Se aplica sistemáticamente en todas las operaciones de cookie de sesión
+
+#### Flags de Seguridad Ausentes:
+
+2. **Secure**:
+   - **NO ESTÁ IMPLEMENTADA** en la configuración actual de cookies en Insitu
+   - **Propósito**: Asegura que la cookie solo se transmita a través de conexiones HTTPS cifradas
+   - **Importancia**: Crítica para prevenir el robo de cookies en redes inseguras
+   - **Falta en Insitu**: El framework no incluye esta flag, lo que representa un riesgo de seguridad en entornos HTTPS
+
+3. **SameSite**:
+   - **NO ESTÁ IMPLEMENTADA** en la configuración actual de cookies en Insitu
+   - **Propósito**: Previene ataques de falsificación de solicitudes entre sitios (CSRF)
+   - **Valores posibles**:
+     - `Strict`: La cookie solo se envía en contextos de primer nivel (mismo sitio)
+     - `Lax`: La cookie se envía en solicitudes de navegación de alto nivel (links, etc.)
+     - `None`: La cookie se envía en todos los contextos (requiere Secure)
+   - **Importancia**: Fundamental para la protección contra CSRF
+   - **Falta en Insitu**: El framework no incluye esta protección
+
+#### Recomendaciones de Mejora:
+
+Para mejorar la seguridad del sistema de sesiones, se deberían considerar las siguientes modificaciones:
+
+1. **Agregar detección automática de HTTPS**:
+   ```javascript
+   let cookieFlags = 'HttpOnly; Path=/';
+   if (req.connection.encrypted || req.headers['x-forwarded-proto'] === 'https') {
+     cookieFlags += '; Secure';
+   }
+   cookieFlags += '; SameSite=Lax';
+   res.setHeader('Set-Cookie', `${this.cookieName}=${newSessionId}; ${cookieFlags}; Max-Age=${this.timeout / 1000}`);
+   ```
+
+2. **Permitir configuración personalizada**:
+   - Opciones para SameSite (Lax, Strict, None)
+   - Configuración de Path personalizable
+   - Soporte para dominios cruzados si es necesario
+
+La implementación actual en Insitu Framework proporciona la protección básica con HttpOnly, pero carece de las flags Secure y SameSite que son esenciales para una seguridad completa en aplicaciones web modernas. Estas deficiencias deben abordarse para cumplir con los estándares de seguridad actuales.