secure-scan 1.2.2

package/docs/ARCHITECTURE.md

@@ -0,0 +1,320 @@
+# 🏗️ Arquitectura Técnica - Secure-Scan
+
+## Visión General
+
+Secure-Scan es una herramienta profesional de **Análisis Estático de Seguridad de Aplicaciones (SAST)** diseñada con una arquitectura modular, extensible y de nivel empresarial.
+
+## Diagrama de Arquitectura
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                           CLI Core                               │
+│  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────┐   │
+│  │   Commands   │  │   Options    │  │   Config Loader      │   │
+│  └──────────────┘  └──────────────┘  └──────────────────────┘   │
+└─────────────────────────────┬───────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                      Security Scanner                            │
+│  ┌──────────────────────────────────────────────────────────┐   │
+│  │                    Orchestrator                           │   │
+│  │  - Coordina todos los módulos                            │   │
+│  │  - Gestiona el flujo de análisis                         │   │
+│  │  - Combina resultados                                     │   │
+│  └──────────────────────────────────────────────────────────┘   │
+└──────────┬────────────────┬────────────────┬────────────────────┘
+           │                │                │
+           ▼                ▼                ▼
+┌──────────────────┐ ┌──────────────┐ ┌──────────────────┐
+│   File Scanner   │ │ Rule Engine  │ │  AI Analyzer     │
+│                  │ │              │ │                  │
+│ - Escanea dirs   │ │ - Patterns   │ │ - OpenAI/Claude  │
+│ - Detecta langs  │ │ - Regex      │ │ - Modelos locales│
+│ - Lee archivos   │ │ - AST        │ │ - Mejora reglas  │
+└──────────────────┘ └──────────────┘ └──────────────────┘
+           │                │                │
+           └────────────────┴────────────────┘
+                            │
+                            ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                    Language Analyzers (Plugins)                  │
+│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐   │
+│  │   JS    │ │ Python  │ │   PHP   │ │  Java   │ │  C/C++  │   │
+│  └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘   │
+│  ┌─────────┐ ┌─────────────────────────────────────────────┐   │
+│  │   C#    │ │               IaC Analyzer                   │   │
+│  └─────────┘ │ (Dockerfile, YAML, Terraform, CI/CD)        │   │
+│              └─────────────────────────────────────────────┘   │
+└─────────────────────────────┬───────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                      Risk Scoring Engine                         │
+│  - Calcula puntuación de riesgo (0-100)                         │
+│  - Pondera por severidad y categoría                            │
+│  - Genera métricas de seguridad                                 │
+└─────────────────────────────┬───────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                      Report Generator                            │
+│  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────┐   │
+│  │   HTML       │  │    JSON      │  │     SARIF (futuro)   │   │
+│  └──────────────┘  └──────────────┘  └──────────────────────┘   │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Componentes Principales
+
+### 1. CLI Core (`src/cli/`)
+
+Punto de entrada de la aplicación. Maneja:
+- Parsing de argumentos
+- Configuración de opciones
+- Invocación del scanner
+- Formato de salida
+
+**Comandos:**
+- `scan <path>` - Escanea un proyecto
+- `init` - Crea archivo de configuración
+- `rules` - Lista reglas disponibles
+
+### 2. File Scanner (`src/analyzers/core/scanner/`)
+
+Responsable de:
+- Escanear directorios recursivamente
+- Detectar lenguajes por extensión
+- Leer y procesar archivos
+- Filtrar por patrones de exclusión
+- Calcular hashes de archivos
+
+### 3. Rule Engine (`src/analyzers/core/engine/`)
+
+Motor de reglas que:
+- Carga reglas de detección
+- Ejecuta patrones regex contra código
+- Genera findings con contexto
+- Soporta AST (futuro)
+
+### 4. Language Analyzers (`src/analyzers/`)
+
+Plugins especializados por lenguaje:
+
+| Analizador | Lenguajes | Capacidades Especiales |
+|------------|-----------|------------------------|
+| JavaScript | JS, TS | npm audit, prototype pollution, DOM XSS |
+| Python | Python | pickle, YAML, Django/Flask |
+| PHP | PHP | Web shells, file inclusion, SQL |
+| Java | Java | Deserialization, XXE, SpEL |
+| C/C++ | C, C++ | Buffer overflow, format string |
+| C# | C# | .NET vulnerabilities, LDAP |
+| IaC | Docker, YAML, TF | Container security, CI/CD |
+
+### 5. AI Analyzer (`src/ai/`)
+
+Análisis potenciado por IA:
+- Integración con OpenAI GPT-4
+- Soporte para Anthropic Claude
+- Modelos locales (Ollama, llama.cpp)
+- Mejora de explicaciones
+- Detección de patrones complejos
+
+### 6. Risk Scoring (`src/analyzers/core/scoring/`)
+
+Sistema de puntuación:
+- Calcula score 0-100
+- Pondera por severidad (Critical=100, Info=5)
+- Multiplica por categoría (Malware=1.5x)
+- Normaliza por tamaño del proyecto
+
+### 7. Report Generator (`src/reports/`)
+
+Genera reportes profesionales:
+- HTML con diseño moderno
+- JSON para integración
+- SARIF para IDEs (futuro)
+
+## Flujo de Datos
+
+```
+Entrada: Ruta del proyecto
+           │
+           ▼
+    ┌──────────────┐
+    │ File Scanner │ ──▶ Lista de archivos con contenido
+    └──────────────┘
+           │
+           ▼
+    ┌──────────────┐
+    │ Detección de │ ──▶ Asigna lenguaje a cada archivo
+    │   Lenguaje   │
+    └──────────────┘
+           │
+           ▼
+    ┌──────────────────────────────────────┐
+    │    Análisis Paralelo                  │
+    │  ┌────────────┐  ┌────────────────┐  │
+    │  │   Rules    │  │   Analyzers    │  │
+    │  │  (Regex)   │  │  (Por lenguaje)│  │
+    │  └────────────┘  └────────────────┘  │
+    │         │               │            │
+    │         └───────┬───────┘            │
+    │                 ▼                    │
+    │  ┌────────────────────────────────┐  │
+    │  │         AI Analyzer            │  │
+    │  │   (si está habilitado)         │  │
+    │  └────────────────────────────────┘  │
+    └──────────────────┬───────────────────┘
+                       │
+                       ▼
+              ┌──────────────┐
+              │ Deduplicación│ ──▶ Elimina findings duplicados
+              └──────────────┘
+                       │
+                       ▼
+              ┌──────────────┐
+              │ Scoring      │ ──▶ Calcula riesgo
+              └──────────────┘
+                       │
+                       ▼
+              ┌──────────────┐
+              │   Report     │ ──▶ Genera HTML/JSON
+              │  Generator   │
+              └──────────────┘
+                       │
+                       ▼
+              Salida: Reporte + Exit Code
+```
+
+## Estructura de un Finding
+
+```typescript
+interface Finding {
+  id: string;           // Identificador único
+  title: string;        // Título del hallazgo
+  description: string;  // Descripción detallada
+  severity: Severity;   // critical | high | medium | low | info
+  threatType: ThreatType;  // sql_injection, xss, backdoor, etc.
+  category: FindingCategory;  // vulnerability | malware
+  location: {
+    file: string;       // Ruta del archivo
+    startLine: number;  // Línea inicial
+    endLine: number;    // Línea final
+  };
+  snippet: {
+    code: string;       // Código vulnerable
+    contextBefore: string;  // Contexto anterior
+    contextAfter: string;   // Contexto posterior
+  };
+  standards: SecurityStandard[];  // OWASP, CWE, MITRE
+  remediation: string;  // Cómo corregir
+  confidence: number;   // 0-100
+  analyzer: string;     // Qué analizador lo detectó
+  tags: string[];       // Etiquetas
+}
+```
+
+## Estándares de Seguridad
+
+Cada finding se mapea a:
+
+| Estándar | Descripción | Ejemplo |
+|----------|-------------|---------|
+| OWASP Top 10 | Top vulnerabilidades web | A03:2021 - Injection |
+| CWE | Common Weakness Enumeration | CWE-79 (XSS) |
+| MITRE ATT&CK | Tácticas y técnicas de atacantes | T1059 - Command Interpreter |
+| SANS Top 25 | Errores de software más peligrosos | SANS-3 - SQL Injection |
+
+## Reglas de Detección
+
+### Estructura de una Regla
+
+```typescript
+interface Rule {
+  id: string;           // VULN-SQL-001
+  name: string;         // SQL Injection
+  description: string;  // Descripción
+  languages: SupportedLanguage[];  // Lenguajes
+  threatType: ThreatType;
+  severity: Severity;
+  patterns: RulePattern[];  // Patrones de detección
+  remediation: string;
+  enabled: boolean;
+  tags: string[];
+}
+```
+
+### Tipos de Patrones
+
+1. **Regex** - Expresiones regulares
+2. **AST** - Análisis de árbol sintáctico (futuro)
+3. **Semantic** - Análisis semántico con IA
+
+## Extensibilidad
+
+### Añadir nuevo analizador
+
+1. Crear clase que extienda `BaseAnalyzer`
+2. Implementar método `analyze()`
+3. Registrar en `src/analyzers/index.ts`
+
+```typescript
+export class NewLanguageAnalyzer extends BaseAnalyzer {
+  name = 'New Language Analyzer';
+  languages = ['newlang'];
+  version = '1.0.0';
+
+  async analyze(file: ScannedFile, rules: Rule[]): Promise<Finding[]> {
+    // Implementación
+  }
+}
+```
+
+### Añadir nuevas reglas
+
+1. Crear archivo en `src/rules/vulnerabilities/` o `src/rules/malware/`
+2. Definir reglas con patrones
+3. Exportar en `index.ts`
+
+## Seguridad del Propio Scanner
+
+⚠️ **Restricciones de seguridad:**
+
+1. **Solo lectura** - El scanner nunca modifica archivos
+2. **Sin ejecución** - No ejecuta código del proyecto
+3. **Sin compilación** - No compila ni interpreta
+4. **Sandbox** - Puede ejecutarse en Docker
+
+## Roadmap de Desarrollo
+
+### Fase 1 ✅
+- Análisis estático básico
+- Reglas regex
+- Reportes HTML
+
+### Fase 2 ✅
+- Integración IA
+- Multi-lenguaje
+- CLI avanzado
+
+### Fase 3 ✅
+- Análisis AST
+- Análisis de IaC (Dockerfile, YAML, Terraform)
+- Detección de malware
+
+### Fase 4 ✅
+- Análisis de dependencias (SCA)
+- Software Composition Analysis
+- Detección de CVEs, typosquatting, paquetes maliciosos
+- Soporte para npm, pip, composer, maven, nuget, vcpkg
+
+### Fase 5 (Futuro)
+- Dashboard web
+- API REST
+- Multi-tenant SaaS
+
+### Fase 6 (Futuro)
+- DAST (análisis dinámico)
+- IAST (instrumentación)
+- RASP (protección runtime)

package/docs/V1.2.1-IA_Performances.md

@@ -0,0 +1,116 @@
+# Actualización V1.2.1-IA_Performances
+
+## Resumen
+
+La versión **V1.2.1-IA_Performances** introduce mejoras significativas en el rendimiento, nuevas capacidades de detección de malware, y una arquitectura optimizada para análisis estático de seguridad (SAST). Esta actualización refuerza la escalabilidad, extensibilidad y precisión de la herramienta Secure-Scan.
+
+---
+
+## Nota Importante
+
+Windows puede detectar como malware el módulo de `categories` y puede eliminar algunos archivos relacionados. Esto es un falso positivo debido a las reglas de detección avanzadas incluidas en esta actualización.
+
+![Alerta de Windows](images/alerta-windows.png)
+
+---
+
+## Cambios Principales
+
+### 1. **Arquitectura Modular Mejorada**
+- Refactorización completa del módulo de detección de malware.
+- Separación de responsabilidades en módulos especializados:
+  - `types/`: Definiciones de tipos e interfaces.
+  - `constants/`: Configuración y constantes globales.
+  - `utils/`: Funciones utilitarias para análisis avanzado.
+  - `scoring/`: Sistema de puntuación dinámico.
+  - `engine/`: Motor de detección principal.
+  - `categories/`: Reglas organizadas por categorías.
+
+### 2. **Nuevas Categorías de Reglas de Malware**
+Se añadieron 81 reglas distribuidas en 7 categorías:
+- **Backdoors**: Detección de reverse shells, web shells y RATs.
+- **Cryptominers**: Identificación de mineros de criptomonedas y abuso de CPU.
+- **Keyloggers**: Captura de eventos de teclado y robo de credenciales.
+- **Exfiltración de Datos**: Robo de cookies, tokens y datos sensibles.
+- **Ofuscación**: Patrones de codificación y anti-depuración.
+- **Loaders/Droppers**: Carga de código remoto y malware sin archivos.
+- **Red/C2**: Comunicación con servidores de comando y control (C2).
+
+### 3. **Integración con MITRE ATT&CK**
+- Mapeo completo de tácticas y técnicas de MITRE ATT&CK.
+- Ejemplo: T1059 (Command and Scripting Interpreter), T1496 (Resource Hijacking).
+
+### 4. **Mejoras en el Motor de Reglas**
+- Soporte para patrones Regex, AST y heurísticos.
+- Protección contra ReDoS con límites de tiempo en Regex.
+- Análisis concurrente de archivos con límites configurables.
+
+### 5. **Sistema de Puntuación Dinámico**
+- Puntuación de riesgo (0-100) basada en múltiples factores:
+  - Severidad de los hallazgos.
+  - Correlación entre patrones detectados.
+  - Nivel de ofuscación y actividad de red.
+- Conversión de puntuación a niveles de severidad: Crítico, Alto, Medio, Bajo.
+
+### 6. **Análisis Potenciado por IA**
+- Integración con OpenAI GPT-4 y Anthropic Claude.
+- Modelos locales para detección avanzada.
+- Mejora de explicaciones y reducción de falsos positivos.
+
+### 7. **Generación de Reportes**
+- Reportes en formato HTML y JSON.
+- Diseño moderno y profesional.
+- Soporte futuro para SARIF.
+
+### 8. **Compatibilidad con Versiones Anteriores**
+- Exportaciones y tipos heredados siguen disponibles.
+- Integración sin interrupciones con proyectos existentes.
+
+---
+
+## Cambios Técnicos
+
+### Refactorización de Archivos
+- **Nuevos Archivos:**
+  - `src/rules/malware/categories/backdoors.ts`
+  - `src/rules/malware/categories/cryptominers.ts`
+  - `src/rules/malware/categories/keyloggers.ts`
+  - `src/rules/malware/categories/exfiltration.ts`
+  - `src/rules/malware/categories/obfuscation.ts`
+  - `src/rules/malware/categories/loaders.ts`
+  - `src/rules/malware/categories/network.ts`
+- **Renombrados:**
+  - `src/core/engine/` → `src/analyzers/core/engine/`
+  - `src/core/scanner/` → `src/analyzers/core/scanner/`
+  - `src/core/scoring/` → `src/analyzers/core/scoring/`
+
+### Dependencias Actualizadas
+- **Producción:**
+  - `@anthropic-ai/sdk`: ^0.71.2
+  - `openai`: ^4.20.0
+- **Desarrollo:**
+  - `@typescript-eslint/eslint-plugin`: ^6.13.0
+  - `@typescript-eslint/parser`: ^6.13.0
+  - `typescript`: ^5.3.2
+
+### Scripts de NPM
+- `build`: Compila el proyecto con TypeScript.
+- `test:coverage`: Genera cobertura de pruebas con Jest.
+- `lint`: Ejecuta ESLint para análisis estático.
+- `prepare`: Limpia y construye el proyecto.
+
+---
+
+## Próximos Pasos
+
+1. **Integración AST**: Añadir soporte para análisis de árbol sintáctico.
+2. **Análisis Semántico**: Implementar flujo de datos y control.
+3. **Detección de Dependencias Maliciosas**: Integrar análisis SCA.
+4. **Optimización de Rendimiento**: Mejorar patrones Regex y concurrencia.
+5. **Pruebas de Integración**: Validar con muestras reales de malware.
+
+---
+
+## Conclusión
+
+La versión **V1.2.1-IA_Performances** establece un nuevo estándar para herramientas SAST con capacidades avanzadas de detección, arquitectura modular y soporte para IA. Esta actualización asegura que Secure-Scan sea una solución confiable, escalable y lista para producción.

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "secure-scan",
+  "version": "1.2.2",
+  "description": "Herramienta SAST (Análisis Estático de Seguridad) para detectar vulnerabilidades y código malicioso.",
+  "main": "dist/index.js",
+  "bin": {
+    "secure-scan": "./dist/cli/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Luis000923/secure-scan.git"
+  },
+  "homepage": "https://github.com/Luis000923/secure-scan#readme",
+  "bugs": {
+    "url": "https://github.com/Luis000923/secure-scan/issues"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/cli/index.js",
+    "dev": "ts-node src/cli/index.ts",
+    "test": "jest",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src/**/*.ts",
+    "clean": "rimraf dist",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "security",
+    "sast",
+    "static-analysis",
+    "vulnerability-scanner",
+    "malware-detection",
+    "code-analysis",
+    "owasp",
+    "cwe",
+    "profesional"
+  ],
+  "author": "Luis000923",
+  "license": "MIT",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.71.2",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "glob": "^10.3.10",
+    "handlebars": "^4.7.8",
+    "js-yaml": "^4.1.0",
+    "openai": "^4.20.0",
+    "ora": "^5.4.1",
+    "strip-comments": "^2.0.1",
+    "winston": "^3.11.0"
+  },
+  "devDependencies": {
+    "@types/glob": "^8.1.0",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.10.0",
+    "@typescript-eslint/eslint-plugin": "^6.13.0",
+    "@typescript-eslint/parser": "^6.13.0",
+    "eslint": "^8.54.0",
+    "jest": "^29.7.0",
+    "rimraf": "^5.0.5",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/secure-scan.config.json

@@ -0,0 +1,134 @@
+{
+  "$schema": "https://raw.githubusercontent.com/secure-scan/secure-scan/main/schema.json",
+  "version": "1.0.0",
+  
+  "scan": {
+    "languages": [
+      "javascript",
+      "typescript",
+      "python",
+      "php",
+      "java",
+      "c",
+      "cpp",
+      "csharp",
+      "dockerfile",
+      "yaml",
+      "terraform"
+    ],
+    "exclude": [
+      "**/node_modules/**",
+      "**/vendor/**",
+      "**/venv/**",
+      "**/.venv/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/target/**",
+      "**/.git/**",
+      "**/coverage/**",
+      "**/__pycache__/**",
+      "**/*.min.js",
+      "**/*.min.css",
+      "**/package-lock.json",
+      "**/yarn.lock",
+      "**/composer.lock"
+    ],
+    "include": [],
+    "maxFileSize": 1048576,
+    "maxFiles": 10000,
+    "followSymlinks": false
+  },
+  
+  "rules": {
+    "enabled": true,
+    "categories": {
+      "vulnerability": true,
+      "malware": true
+    },
+    "severity": {
+      "critical": true,
+      "high": true,
+      "medium": true,
+      "low": true,
+      "info": false
+    },
+    "customRulesPath": null,
+    "disabledRules": []
+  },
+  
+  "ai": {
+    "enabled": true,
+    "provider": "local",
+    "model": "codellama:7b-instruct",
+    "apiKey": null,
+    "endpoint": "http://localhost:11434/api/generate",
+    "enhanceFindings": true,
+    "generateSummary": true,
+    "maxTokens": 4096,
+    "temperature": 0.1,
+    "performance": {
+      "parallelRequests": 2,
+      "numGpuLayers": -1,
+      "numThreads": 8,
+      "contextSize": 4096,
+      "batchSize": 512,
+      "enableCache": true,
+      "useMmap": true,
+      "useMlock": false,
+      "timeout": 120000
+    }
+  },
+  
+  "output": {
+    "format": "html",
+    "path": "./secure-scan-report",
+    "filename": "security-report",
+    "includeSource": true,
+    "groupBy": "severity",
+    "sortBy": "severity"
+  },
+  
+  "scoring": {
+    "enabled": true,
+    "weights": {
+      "critical": 100,
+      "high": 50,
+      "medium": 20,
+      "low": 5,
+      "info": 1
+    },
+    "categoryMultipliers": {
+      "vulnerability": 1.0,
+      "malware": 1.5
+    },
+    "thresholds": {
+      "fail": 70,
+      "warn": 40
+    }
+  },
+  
+  "performance": {
+    "parallelism": 4,
+    "timeout": 300000,
+    "cacheEnabled": true,
+    "cachePath": ".secure-scan-cache"
+  },
+  
+  "integrations": {
+    "git": {
+      "enabled": true,
+      "scanOnlyChanged": false,
+      "baseBranch": "main"
+    },
+    "sarif": {
+      "enabled": false,
+      "path": "./results.sarif"
+    }
+  },
+  
+  "logging": {
+    "level": "info",
+    "file": null,
+    "colors": true
+  }
+}

package/secure-scan.sln

@@ -0,0 +1,29 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.5.2.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test-samples", "test-samples", "{5E849C8E-AA1E-7CD4-5143-C6E7A8E2EC2D}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VulnerableProject", "test-samples\VulnerableProject.csproj", "{970E6386-2235-55A4-270C-676D2128FFFC}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{970E6386-2235-55A4-270C-676D2128FFFC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{970E6386-2235-55A4-270C-676D2128FFFC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{970E6386-2235-55A4-270C-676D2128FFFC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{970E6386-2235-55A4-270C-676D2128FFFC}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{970E6386-2235-55A4-270C-676D2128FFFC} = {5E849C8E-AA1E-7CD4-5143-C6E7A8E2EC2D}
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {C65C7978-61E0-4C31-98B7-BA2317A793D2}
+	EndGlobalSection
+EndGlobal