secure-scan 1.2.2

package/dist/ai/aiAnalyzer.js

@@ -0,0 +1,669 @@
+"use strict";
+/**
+ * AI Analyzer Module
+ * Uses AI/ML for advanced threat detection and analysis
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIAnalyzer = void 0;
+const types_1 = require("../types");
+const logger_1 = require("../utils/logger");
+const utils_1 = require("../utils");
+const standards_1 = require("../rules/standards");
+/**
+ * AI Analyzer Class
+ * Provides AI-powered security analysis
+ */
+class AIAnalyzer {
+    config;
+    initialized = false;
+    detectedProvider = 'openai';
+    constructor(config) {
+        this.config = config;
+        // Auto-detect provider from API key if set to 'auto' or not specified correctly
+        this.detectedProvider = this.detectProvider();
+    }
+    /**
+     * Auto-detect AI provider from API key format
+     */
+    detectProvider() {
+        const apiKey = this.config.apiKey || '';
+        const provider = this.config.provider;
+        // If explicitly set to local, use local
+        if (provider === 'local') {
+            return 'local';
+        }
+        // Auto-detect from API key format
+        if (apiKey.startsWith('sk-ant-') || apiKey.startsWith('sk-ant')) {
+            logger_1.logger.debug('🔍 Detected Anthropic API key');
+            return 'anthropic';
+        }
+        if (apiKey.startsWith('AIzaSy') || apiKey.startsWith('AIza')) {
+            logger_1.logger.debug('🔍 Detected Google AI API key');
+            return 'google';
+        }
+        if (apiKey.startsWith('sk-') || apiKey.startsWith('sk-proj-')) {
+            logger_1.logger.debug('🔍 Detected OpenAI API key');
+            return 'openai';
+        }
+        // Fallback to configured provider or openai
+        if (provider === 'google' || provider === 'gemini') {
+            return 'google';
+        }
+        if (provider === 'anthropic') {
+            return 'anthropic';
+        }
+        if (provider === 'openai') {
+            return 'openai';
+        }
+        // Default to openai if we can't detect
+        return 'openai';
+    }
+    /**
+     * Initialize AI analyzer
+     */
+    async initialize() {
+        if (!this.config.apiKey && this.detectedProvider !== 'local') {
+            logger_1.logger.warn('⚠️ AI API key not provided. AI analysis will be limited.');
+            return;
+        }
+        const providerName = this.detectedProvider === 'google' ? 'Google AI (Gemini)' :
+            this.detectedProvider === 'anthropic' ? 'Anthropic (Claude)' :
+                this.detectedProvider === 'openai' ? 'OpenAI (GPT)' : 'Local';
+        logger_1.logger.info(`🤖 Initializing AI analyzer with ${providerName}...`);
+        this.initialized = true;
+    }
+    /**
+     * Analyze code with AI
+     */
+    async analyze(file) {
+        if (!this.initialized) {
+            return { findings: [] };
+        }
+        try {
+            switch (this.detectedProvider) {
+                case 'openai':
+                    return await this.analyzeWithOpenAI(file);
+                case 'anthropic':
+                    return await this.analyzeWithAnthropic(file);
+                case 'google':
+                    return await this.analyzeWithGoogle(file);
+                case 'local':
+                    return await this.analyzeWithLocal(file);
+                default:
+                    return { findings: [] };
+            }
+        }
+        catch (error) {
+            logger_1.logger.debug(`AI analysis error: ${error}`);
+            return { findings: [] };
+        }
+    }
+    /**
+     * Get the best model for the provider
+     */
+    getModel() {
+        if (this.config.model) {
+            return this.config.model;
+        }
+        // Default models per provider
+        switch (this.detectedProvider) {
+            case 'openai':
+                return 'gpt-4o'; // Latest and most capable
+            case 'anthropic':
+                return 'claude-3-sonnet-20240229';
+            case 'google':
+                return 'gemini-pro'; // Stable model for v1beta API
+            default:
+                return 'gpt-4';
+        }
+    }
+    /**
+     * Analyze with OpenAI (supports all GPT models)
+     */
+    async analyzeWithOpenAI(file) {
+        // Dynamic import to avoid issues if package not installed
+        const OpenAI = (await Promise.resolve().then(() => __importStar(require('openai')))).default;
+        const client = new OpenAI({
+            apiKey: this.config.apiKey
+        });
+        const prompt = this.buildAnalysisPrompt(file);
+        const model = this.getModel();
+        logger_1.logger.debug(`Using OpenAI model: ${model}`);
+        try {
+            const response = await client.chat.completions.create({
+                model: model,
+                messages: [
+                    {
+                        role: 'system',
+                        content: this.getSystemPrompt()
+                    },
+                    {
+                        role: 'user',
+                        content: prompt
+                    }
+                ],
+                max_tokens: this.config.maxTokens || 2000,
+                temperature: this.config.temperature || 0.1
+            });
+            const content = response.choices[0]?.message?.content;
+            if (!content) {
+                return { findings: [] };
+            }
+            return this.parseAIResponse(content, file);
+        }
+        catch (error) {
+            if (error?.status === 429) {
+                logger_1.logger.warn('⚠️ OpenAI: Cuota excedida. Verifica tu plan en https://platform.openai.com/account/billing');
+            }
+            else if (error?.status === 401) {
+                logger_1.logger.warn('⚠️ OpenAI: API key inválida');
+            }
+            else {
+                logger_1.logger.debug(`OpenAI error: ${error.message || error}`);
+            }
+            return { findings: [] };
+        }
+    }
+    /**
+     * Analyze with Anthropic Claude
+     */
+    async analyzeWithAnthropic(file) {
+        try {
+            const Anthropic = (await Promise.resolve().then(() => __importStar(require('@anthropic-ai/sdk')))).default;
+            const client = new Anthropic({
+                apiKey: this.config.apiKey
+            });
+            const prompt = this.buildAnalysisPrompt(file);
+            const model = this.getModel();
+            logger_1.logger.debug(`Using Anthropic model: ${model}`);
+            const response = await client.messages.create({
+                model: model,
+                max_tokens: this.config.maxTokens || 2000,
+                system: this.getSystemPrompt(),
+                messages: [
+                    {
+                        role: 'user',
+                        content: prompt
+                    }
+                ]
+            });
+            const content = response.content[0];
+            if (!content || content.type !== 'text') {
+                return { findings: [] };
+            }
+            return this.parseAIResponse(content.text, file);
+        }
+        catch (error) {
+            logger_1.logger.debug(`Anthropic analysis error: ${error}`);
+            return { findings: [] };
+        }
+    }
+    /**
+     * Analyze with Google AI (Gemini)
+     */
+    async analyzeWithGoogle(file) {
+        try {
+            const prompt = this.buildAnalysisPrompt(file);
+            const model = this.getModel();
+            logger_1.logger.debug(`Using Google AI model: ${model}`);
+            // Use Google AI REST API directly
+            const apiKey = this.config.apiKey;
+            // Try v1 API first, fallback to v1beta
+            const apis = [
+                `https://generativelanguage.googleapis.com/v1/models/${model}:generateContent?key=${apiKey}`,
+                `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`
+            ];
+            let lastError = null;
+            for (const url of apis) {
+                try {
+                    const response = await fetch(url, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({
+                            contents: [
+                                {
+                                    parts: [
+                                        {
+                                            text: `${this.getSystemPrompt()}\n\n${prompt}`
+                                        }
+                                    ]
+                                }
+                            ],
+                            generationConfig: {
+                                temperature: this.config.temperature || 0.1,
+                                maxOutputTokens: this.config.maxTokens || 2000
+                            }
+                        })
+                    });
+                    const data = await response.json();
+                    if (!response.ok) {
+                        lastError = data.error;
+                        continue; // Try next API version
+                    }
+                    const content = data.candidates?.[0]?.content?.parts?.[0]?.text;
+                    if (!content) {
+                        return { findings: [] };
+                    }
+                    return this.parseAIResponse(content, file);
+                }
+                catch (e) {
+                    lastError = e;
+                    continue;
+                }
+            }
+            // If all APIs failed, show helpful message
+            if (lastError) {
+                if (lastError.code === 404) {
+                    logger_1.logger.warn(`⚠️ Google AI: Modelo "${model}" no disponible. Intenta con: gemini-pro`);
+                }
+                else if (lastError.code === 403) {
+                    logger_1.logger.warn('⚠️ Google AI: API key sin permisos. Habilita la API en Google Cloud Console.');
+                }
+                else if (lastError.code === 429) {
+                    logger_1.logger.warn('⚠️ Google AI: Cuota excedida. Espera un momento o verifica tu plan.');
+                }
+                else {
+                    logger_1.logger.debug(`Google AI error: ${JSON.stringify(lastError)}`);
+                }
+            }
+            return { findings: [] };
+        }
+        catch (error) {
+            logger_1.logger.debug(`Google AI analysis error: ${error}`);
+            return { findings: [] };
+        }
+    }
+    // Cache for local AI results
+    analysisCache = new Map();
+    /**
+     * Analyze with local model (Ollama compatible) - Optimized for performance
+     */
+    async analyzeWithLocal(file) {
+        if (!this.config.endpoint) {
+            logger_1.logger.warn('Local AI endpoint not configured');
+            return { findings: [] };
+        }
+        // Check cache first
+        const perf = this.config.performance || {};
+        if (perf.enableCache) {
+            const cacheKey = `${file.hash}-${this.config.model}`;
+            const cached = this.analysisCache.get(cacheKey);
+            if (cached) {
+                logger_1.logger.debug(`⚡ Cache hit for ${file.relativePath}`);
+                return cached;
+            }
+        }
+        const prompt = this.buildAnalysisPrompt(file);
+        const model = this.config.model || 'codellama:7b-instruct';
+        try {
+            logger_1.logger.debug(`🤖 Usando modelo local: ${model}`);
+            // Build Ollama options with performance tuning
+            const ollamaOptions = {
+                num_predict: this.config.maxTokens || 2000,
+                temperature: this.config.temperature || 0.1,
+            };
+            // Apply performance settings
+            if (perf.numGpuLayers !== undefined) {
+                ollamaOptions.num_gpu = perf.numGpuLayers;
+            }
+            if (perf.numThreads !== undefined) {
+                ollamaOptions.num_thread = perf.numThreads;
+            }
+            if (perf.contextSize !== undefined) {
+                ollamaOptions.num_ctx = perf.contextSize;
+            }
+            if (perf.batchSize !== undefined) {
+                ollamaOptions.num_batch = perf.batchSize;
+            }
+            if (perf.useMmap !== undefined) {
+                ollamaOptions.use_mmap = perf.useMmap;
+            }
+            if (perf.useMlock !== undefined) {
+                ollamaOptions.use_mlock = perf.useMlock;
+            }
+            // Use AbortController for timeout
+            const controller = new AbortController();
+            const timeout = perf.timeout || 120000; // 2 minutes default
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+            const response = await fetch(this.config.endpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    model: model,
+                    prompt: `${this.getSystemPrompt()}\n\n${prompt}`,
+                    stream: false,
+                    options: ollamaOptions
+                }),
+                signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorText = await response.text();
+                logger_1.logger.warn(`⚠️ Error del modelo local (${response.status}): ${errorText}`);
+                return { findings: [] };
+            }
+            const data = await response.json();
+            const content = data.response || data.content || data.message?.content || '';
+            if (!content) {
+                logger_1.logger.debug('El modelo local no devolvió respuesta');
+                return { findings: [] };
+            }
+            const result = this.parseAIResponse(content, file);
+            // Store in cache
+            if (perf.enableCache) {
+                const cacheKey = `${file.hash}-${this.config.model}`;
+                this.analysisCache.set(cacheKey, result);
+            }
+            return result;
+        }
+        catch (error) {
+            if (error.name === 'AbortError') {
+                logger_1.logger.warn(`⚠️ Timeout analizando ${file.relativePath}`);
+            }
+            else if (error.code === 'ECONNREFUSED') {
+                logger_1.logger.warn('⚠️ No se puede conectar al servidor local. ¿Está Ollama ejecutándose?');
+                logger_1.logger.info('💡 Inicia Ollama con: ollama serve');
+            }
+            else {
+                logger_1.logger.debug(`Local AI error: ${error.message || error}`);
+            }
+            return { findings: [] };
+        }
+    }
+    /**
+     * Analyze multiple files in parallel (for local models)
+     */
+    async analyzeParallel(files) {
+        const results = new Map();
+        const parallelRequests = this.config.performance?.parallelRequests || 1;
+        // Process in batches
+        for (let i = 0; i < files.length; i += parallelRequests) {
+            const batch = files.slice(i, i + parallelRequests);
+            const batchPromises = batch.map(async (file) => {
+                const result = await this.analyze(file);
+                return { path: file.relativePath, result };
+            });
+            const batchResults = await Promise.all(batchPromises);
+            for (const { path, result } of batchResults) {
+                results.set(path, result);
+            }
+        }
+        return results;
+    }
+    /**
+     * Clear the analysis cache
+     */
+    clearCache() {
+        this.analysisCache.clear();
+        logger_1.logger.debug('🗑️ AI analysis cache cleared');
+    }
+    /**
+     * Get system prompt for AI
+     */
+    getSystemPrompt() {
+        return `You are an expert security analyst specializing in static code analysis (SAST).
+Your task is to analyze code for:
+1. Security vulnerabilities (SQL injection, XSS, command injection, etc.)
+2. Malicious code patterns (backdoors, keyloggers, data exfiltration)
+3. Insecure configurations
+4. Hardcoded credentials
+
+For each finding, provide:
+- Title: Brief description
+- Severity: critical, high, medium, low, or info
+- Type: vulnerability type (sql_injection, xss, backdoor, etc.)
+- Line: approximate line number
+- Description: detailed explanation
+- Remediation: how to fix
+
+Respond in JSON format:
+{
+  "findings": [
+    {
+      "title": "...",
+      "severity": "...",
+      "type": "...",
+      "line": 123,
+      "description": "...",
+      "remediation": "..."
+    }
+  ],
+  "riskAssessment": "Overall risk assessment",
+  "explanation": "Summary of analysis"
+}
+
+Be precise and avoid false positives. Focus on real security issues.`;
+    }
+    /**
+     * Build analysis prompt
+     */
+    buildAnalysisPrompt(file) {
+        // Truncate large files
+        const maxLength = 8000;
+        const content = file.content.length > maxLength
+            ? file.content.substring(0, maxLength) + '\n... (truncated)'
+            : file.content;
+        return `Analyze this ${file.language || 'unknown'} code file for security issues:
+
+File: ${file.relativePath}
+Language: ${file.language || 'unknown'}
+
+\`\`\`
+${content}
+\`\`\`
+
+Identify all security vulnerabilities and malicious code patterns.`;
+    }
+    /**
+     * Parse AI response into findings
+     */
+    parseAIResponse(response, file) {
+        try {
+            // Extract JSON from response
+            const jsonMatch = response.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                return { findings: [] };
+            }
+            const parsed = JSON.parse(jsonMatch[0]);
+            const findings = [];
+            for (const item of parsed.findings || []) {
+                const finding = this.convertToFinding(item, file);
+                if (finding) {
+                    findings.push(finding);
+                }
+            }
+            return {
+                findings,
+                explanation: parsed.explanation,
+                riskAssessment: parsed.riskAssessment
+            };
+        }
+        catch (error) {
+            logger_1.logger.debug(`Failed to parse AI response: ${error}`);
+            return { findings: [] };
+        }
+    }
+    /**
+     * Convert AI finding to Finding type
+     */
+    convertToFinding(item, file) {
+        if (!item.title || !item.severity) {
+            return null;
+        }
+        const severity = this.parseSeverity(item.severity);
+        const threatType = this.parseThreatType(item.type);
+        const lineNum = parseInt(item.line) || 1;
+        // Extract code context
+        const lines = file.content.split('\n');
+        const code = lines[lineNum - 1] || '';
+        const contextBefore = lines.slice(Math.max(0, lineNum - 3), lineNum - 1).join('\n');
+        const contextAfter = lines.slice(lineNum, Math.min(lines.length, lineNum + 2)).join('\n');
+        return {
+            id: (0, utils_1.generateId)(),
+            title: item.title,
+            description: item.description || item.title,
+            severity,
+            threatType,
+            category: this.ismalwareType(threatType) ? types_1.FindingCategory.MALWARE : types_1.FindingCategory.VULNERABILITY,
+            location: {
+                file: file.relativePath,
+                startLine: lineNum,
+                endLine: lineNum
+            },
+            snippet: {
+                code,
+                contextBefore,
+                contextAfter
+            },
+            standards: (0, standards_1.getStandardsForThreat)(threatType),
+            remediation: item.remediation || 'Review and fix the identified issue.',
+            confidence: 70,
+            analyzer: 'AI Analyzer',
+            timestamp: new Date(),
+            tags: ['ai-detected'],
+            aiExplanation: item.description,
+            suggestedFix: item.remediation
+        };
+    }
+    /**
+     * Parse severity string
+     */
+    parseSeverity(severity) {
+        const lower = severity.toLowerCase();
+        if (lower.includes('critical'))
+            return types_1.Severity.CRITICAL;
+        if (lower.includes('high'))
+            return types_1.Severity.HIGH;
+        if (lower.includes('medium'))
+            return types_1.Severity.MEDIUM;
+        if (lower.includes('low'))
+            return types_1.Severity.LOW;
+        return types_1.Severity.INFO;
+    }
+    /**
+     * Parse threat type string
+     */
+    parseThreatType(type) {
+        const lower = (type || '').toLowerCase().replace(/[_-]/g, '');
+        const typeMap = {
+            'sqlinjection': types_1.ThreatType.SQL_INJECTION,
+            'sqli': types_1.ThreatType.SQL_INJECTION,
+            'commandinjection': types_1.ThreatType.COMMAND_INJECTION,
+            'cmdi': types_1.ThreatType.COMMAND_INJECTION,
+            'xss': types_1.ThreatType.XSS,
+            'crosssitescripting': types_1.ThreatType.XSS,
+            'csrf': types_1.ThreatType.CSRF,
+            'deserialization': types_1.ThreatType.INSECURE_DESERIALIZATION,
+            'hardcodedcredentials': types_1.ThreatType.HARDCODED_CREDENTIALS,
+            'credentials': types_1.ThreatType.HARDCODED_CREDENTIALS,
+            'pathtraversal': types_1.ThreatType.PATH_TRAVERSAL,
+            'lfi': types_1.ThreatType.PATH_TRAVERSAL,
+            'backdoor': types_1.ThreatType.BACKDOOR,
+            'keylogger': types_1.ThreatType.KEYLOGGER,
+            'cryptominer': types_1.ThreatType.CRYPTOMINER,
+            'obfuscation': types_1.ThreatType.OBFUSCATED_CODE,
+            'exfiltration': types_1.ThreatType.DATA_EXFILTRATION
+        };
+        return typeMap[lower] || types_1.ThreatType.DANGEROUS_FUNCTION;
+    }
+    /**
+     * Check if threat type is malware
+     */
+    ismalwareType(type) {
+        const malwareTypes = [
+            types_1.ThreatType.BACKDOOR,
+            types_1.ThreatType.KEYLOGGER,
+            types_1.ThreatType.CRYPTOMINER,
+            types_1.ThreatType.OBFUSCATED_CODE,
+            types_1.ThreatType.EMBEDDED_PAYLOAD,
+            types_1.ThreatType.REVERSE_SHELL,
+            types_1.ThreatType.DATA_EXFILTRATION,
+            types_1.ThreatType.MALICIOUS_LOADER
+        ];
+        return malwareTypes.includes(type);
+    }
+    /**
+     * Enhance finding with AI explanation
+     */
+    async enhanceFinding(finding) {
+        if (!this.initialized || !this.config.apiKey) {
+            return finding;
+        }
+        try {
+            const OpenAI = (await Promise.resolve().then(() => __importStar(require('openai')))).default;
+            const client = new OpenAI({ apiKey: this.config.apiKey });
+            const response = await client.chat.completions.create({
+                model: this.config.model || 'gpt-4',
+                messages: [
+                    {
+                        role: 'system',
+                        content: 'You are a security expert. Provide a clear, technical explanation of the security issue and a specific code fix.'
+                    },
+                    {
+                        role: 'user',
+                        content: `Explain this security finding and provide a fix:
+
+Title: ${finding.title}
+Type: ${finding.threatType}
+Code:
+\`\`\`
+${finding.snippet.code}
+\`\`\`
+
+Provide a 2-3 sentence explanation and a corrected code example.`
+                    }
+                ],
+                max_tokens: 500,
+                temperature: 0.2
+            });
+            const content = response.choices[0]?.message?.content;
+            if (content) {
+                finding.aiExplanation = content;
+            }
+        }
+        catch (error) {
+            logger_1.logger.debug(`Failed to enhance finding: ${error}`);
+        }
+        return finding;
+    }
+}
+exports.AIAnalyzer = AIAnalyzer;
+exports.default = AIAnalyzer;
+//# sourceMappingURL=aiAnalyzer.js.map