agent-master-devsecops 3.9.0 → 5.1.0

package/scripts/auditors/sast_scanner.js

@@ -0,0 +1,442 @@
+/**
+ * scripts/auditors/sast_scanner.js
+ * SAST & Secret Detection Engine — Shift-Left DevSecOps (v5.1 Enterprise)
+ * Scanner estático nativo de vulnerabilidades OWASP Top 10, CWEs e segredos em texto plano.
+ * Em estrita conformidade com a Regra 5, Regra 12 e NIST SSDF SP 800-218.
+ * Suporta modo híbrido industrial (Semgrep CLI) com motor heurístico determinístico embutido.
+ */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { createSarifReport, parseSarifReport } = require('../core/sarif_engine.js');
+
+const SECURITY_RULES = Object.freeze([
+  Object.freeze({
+    id: 'DEVSEC-CWE-78',
+    cwe: 'CWE-78',
+    name: 'Command Injection',
+    severity: 'CRITICAL',
+    pattern: /(?:child_process\s*\.\s*exec\s*\(|\bexecSync\s*\(|\bpopen\s*\(|(?<![\w$.])exec\s*\(|`[^`]*\$\{.*?\}[^`]*`\s*(?:\|\||&&)?\s*exec)/i,
+    message: 'Execução de comando via shell detectada. Utilize execFile ou spawn com argumentos em array sanitizados.',
+    remediation: 'Substitua child_process.exec por child_process.execFile ou spawn sem invocação de shell intermediário.'
+  }),
+  Object.freeze({
+    id: 'DEVSEC-CWE-89',
+    cwe: 'CWE-89',
+    name: 'SQL Injection',
+    severity: 'CRITICAL',
+    pattern: /(?<!\.)\b(?:SELECT|INSERT\s+INTO|UPDATE\s+[a-zA-Z0-9_.]+\s+SET|DELETE\s+FROM|DROP\s+TABLE)\b\s+[\s\S]*?['"`]\s*\+\s*[a-zA-Z0-9_$]|\b(?:SELECT\b[\s\S]*?\bFROM\b|INSERT\s+INTO\b|DELETE\s+FROM\b)[\s\S]*?\$\{.*?\}|\$\{.*?\}[\s\S]*?\b(?:WHERE|VALUES)\b|(?<!\.)\b(?:SELECT\s+[\s\S]*?\bFROM|INSERT\s+INTO|UPDATE\s+[a-zA-Z0-9_.]+\s+SET|DELETE\s+FROM)\b[^;]*?\+\s*[a-zA-Z0-9_$]/i,
+    message: 'Interpolação dinâmica de parâmetros em instrução SQL detectada.',
+    remediation: 'Utilize consultas parametrizadas (Prepared Statements) ou query builders com bind de parâmetros.'
+  }),
+  Object.freeze({
+    id: 'DEVSEC-CWE-1333',
+    cwe: 'CWE-1333',
+    name: 'ReDoS (Regular Expression Denial of Service)',
+    severity: 'HIGH',
+    pattern: /\/([^\/\\]*(\([^\(\)]*[\+\*][^\(\)]*\)[\+\*])[^\/\\]*)\/[gimsuy]*/,
+    message: 'Expressão regular com quantificadores aninhados propensa a catastrophic backtracking exponencial.',
+    remediation: 'Refatore a regex para eliminar quantificadores aninhados ou substitua por autômato linear / busca determinística.'
+  }),
+  Object.freeze({
+    id: 'DEVSEC-CWE-79',
+    cwe: 'CWE-79',
+    name: 'Cross-Site Scripting (XSS)',
+    severity: 'HIGH',
+    pattern: /(?:innerHTML\s*=|dangerouslySetInnerHTML\s*=|document\s*\.\s*write\s*\()/i,
+    message: 'Atribuição insegura de HTML direto no DOM sem sanitização contextual.',
+    remediation: 'Utilize textContent ou bibliotecas canônicas de sanitização estrita (DOMPurify).'
+  }),
+  Object.freeze({
+    id: 'DEVSEC-CWE-798-SECRET',
+    cwe: 'CWE-798',
+    name: 'Hardcoded Credentials & API Keys',
+    severity: 'CRITICAL',
+    pattern: /(?:(?:AKIA[0-9A-Z]{16})|(?:gh[pousr]_[A-Za-z0-9_]{30,255})|(?:xox[baprs]-[0-9a-zA-Z]{10,48})|(?:-----BEGIN\s+PRIVATE\s+KEY-----)|(?:(?:api[_-]?key|secret|password|auth[_-]?token)\s*[:=]\s*['"][A-Za-z0-9_\-\.+=]{16,}['"]))/i,
+    message: 'Credencial, token de acesso ou chave privada em texto plano embutida no código-fonte.',
+    remediation: 'Remova imediatamente o segredo, revogue a credencial e carregue via variáveis de ambiente seguras (process.env).'
+  }),
+  Object.freeze({
+    id: 'DEVSEC-CWE-798-EMAIL',
+    cwe: 'CWE-798',
+    name: 'Hardcoded Email Address',
+    severity: 'CRITICAL',
+    pattern: /(?:(?:email|user|account)\s*(?:[:=]|\|\|)\s*['"][a-zA-Z0-9._%+-]+@(gmail|hotmail|outlook|yahoo|[a-zA-Z0-9.-]+)\.[a-zA-Z]{2,}['"])/i,
+    message: 'Endereço de email hardcoded ou utilizado como fallback no código-fonte.',
+    remediation: 'Remova o email estático e obtenha o valor exclusivamente de process.env (ex: process.env.ATLASSIAN_EMAIL).'
+  }),
+  Object.freeze({
+    id: 'DEVSEC-CWE-798-TENANT-DOMAIN',
+    cwe: 'CWE-798',
+    name: 'Hardcoded Atlassian Tenant Domain',
+    severity: 'CRITICAL',
+    pattern: /https?:\/\/[a-zA-Z0-9-]+\.atlassian\.net/i,
+    message: 'Domínio privado de tenant Atlassian hardcoded no código.',
+    remediation: 'Substitua por variável de ambiente dinâmica (ex: process.env.ATLASSIAN_DOMAIN).'
+  }),
+  Object.freeze({
+    id: 'DEVSEC-CWE-798-EXTERNAL-FILE',
+    cwe: 'CWE-798',
+    name: 'External Credential File Reference',
+    severity: 'CRITICAL',
+    pattern: /['"][^'"]*(?:id_rsa|id_ed25519|\.pgpass|\.netrc|credentials\.json|service-account.*\.json|Atlassian Account|Token\.txt|Account\.txt)['"]/i,
+    message: 'Referência a arquivo de credenciais, chave privada ou segredo em texto plano.',
+    remediation: 'Elimine referências a arquivos estáticos de credenciais. Utilize variáveis de ambiente ou .env protegido por .gitignore.'
+  }),
+  Object.freeze({
+    id: 'DEVSEC-CWE-95',
+    cwe: 'CWE-95',
+    name: 'Dynamic Code Evaluation',
+    severity: 'CRITICAL',
+    pattern: /\beval\s*\(|\bnew\s+Function\s*\(/,
+    message: 'Uso de eval() ou new Function() que permite execução arbitrária de código.',
+    remediation: 'Substitua por parsers seguros de JSON ou mapeamentos estáticos de funções.'
+  }),
+  Object.freeze({
+    id: 'DEVSEC-CWE-22',
+    cwe: 'CWE-22',
+    name: 'Path Traversal / Arbitrary File Access',
+    severity: 'HIGH',
+    pattern: /(?:fs\.(?:readFile|readFileSync|writeFile|writeFileSync|unlink|unlinkSync)\s*\([^,)]*(?:\+|`[^`]*\$\{)[^,)]*(?:\.\.\/|\.\.\\))/i,
+    message: 'Concatenação insegura de caminho de arquivo propensa a Path Traversal (CWE-22).',
+    remediation: 'Utilize path.resolve com validação de caminho relativo dentro de um diretório raiz seguro.'
+  })
+]);
+
+/**
+ * Executa comandos CLI de ferramentas industriais de forma blindada contra injection e timeouts.
+ */
+function runCliSafely(bin, args = [], options = {}) {
+  try {
+    const timeout = options.timeout || 30000;
+    const maxBuffer = options.maxBuffer || 15 * 1024 * 1024;
+    const cwd = options.cwd || process.cwd();
+
+    if (process.platform === 'win32') {
+      return spawnSync(process.env.ComSpec || 'cmd.exe', ['/d', '/s', '/c', bin, ...args], {
+        encoding: 'utf8',
+        timeout,
+        maxBuffer,
+        windowsHide: true,
+        cwd
+      });
+    }
+    return spawnSync(bin, args, {
+      encoding: 'utf8',
+      timeout,
+      maxBuffer,
+      windowsHide: true,
+      cwd
+    });
+  } catch (err) {
+    return { status: -1, error: err };
+  }
+}
+
+/**
+ * Motor Canônico de Análise Estática de Segurança e Detecção de Segredos.
+ */
+class SastScanner {
+  constructor(rules = SECURITY_RULES) {
+    this.rules = Array.isArray(rules) ? rules : SECURITY_RULES;
+  }
+
+  /**
+   * Verifica se o Semgrep CLI está instalado e disponível no PATH do host.
+   * @returns {boolean}
+   */
+  isSemgrepAvailable() {
+    try {
+      const res = runCliSafely('semgrep', ['--version'], { timeout: 10000 });
+      return res.status === 0;
+    } catch (_) {
+      return false;
+    }
+  }
+
+  /**
+   * Executa varredura industrial via Semgrep CLI caso instalado.
+   * @param {string} targetPath 
+   * @returns {object|null}
+   */
+  scanWithSemgrep(targetPath) {
+    try {
+      const res = runCliSafely('semgrep', ['scan', '--config', 'auto', '--json', '--quiet', targetPath], {
+        timeout: 60000
+      });
+      if (res.status === 0 && res.stdout) {
+        const data = JSON.parse(res.stdout);
+        const results = data.results || [];
+        const findings = results.map(r => ({
+          ruleId: r.check_id,
+          name: r.extra?.metadata?.cwe ? `CWE Violation: ${r.extra.metadata.cwe}` : r.check_id,
+          cwe: Array.isArray(r.extra?.metadata?.cwe) ? r.extra.metadata.cwe[0] : (r.extra?.metadata?.cwe || 'CWE-Unknown'),
+          severity: (r.extra?.severity || 'MEDIUM').toUpperCase(),
+          filename: r.path,
+          line: r.start?.line || 1,
+          snippet: (r.extra?.lines || '').trim().substring(0, 100),
+          message: r.extra?.message || 'Semgrep finding',
+          remediation: r.extra?.metadata?.shortlink || 'Consulte a documentação da regra Semgrep para correção.'
+        }));
+
+        return {
+          engine: 'semgrep_cli_industrial',
+          status: findings.some(f => f.severity === 'CRITICAL' || f.severity === 'HIGH' || f.severity === 'ERROR') ? 'FAILED' : 'PASSED',
+          totalFindings: findings.length,
+          criticalCount: findings.filter(f => f.severity === 'CRITICAL' || f.severity === 'ERROR').length,
+          highCount: findings.filter(f => f.severity === 'HIGH' || f.severity === 'WARNING').length,
+          mediumCount: findings.filter(f => f.severity === 'MEDIUM' || f.severity === 'INFO').length,
+          findings
+        };
+      }
+    } catch (_) {
+      // Fallback gracioso para o motor heurístico embutido
+    }
+    return null;
+  }
+
+  /**
+   * Varre um arquivo físico no disco.
+   * @param {string} filePath 
+   * @param {object} [options={}]
+   * @returns {object}
+   */
+  scanFile(filePath, options = {}) {
+    if (!filePath || typeof filePath !== 'string' || !fs.existsSync(filePath)) {
+      throw new Error(`Arquivo não encontrado para varredura SAST: ${filePath}`);
+    }
+    const preferSemgrep = options.preferSemgrep === true;
+    if (preferSemgrep && this.isSemgrepAvailable()) {
+      const semgrepRes = this.scanWithSemgrep(filePath);
+      if (semgrepRes) return semgrepRes;
+    }
+    const content = fs.readFileSync(filePath, 'utf8');
+    return this.scanCode(content, path.basename(filePath));
+  }
+
+  /**
+   * Varre uma string de código-fonte em memória de forma pura e defensiva.
+   * @param {string} code 
+   * @param {string} [filename='snippet.js'] 
+   * @returns {object}
+   */
+  scanCode(code, filename = 'snippet.js') {
+    const safeCode = typeof code === 'string' ? code : '';
+    const safeFilename = typeof filename === 'string' ? filename : 'snippet.js';
+    const findings = [];
+    const lines = safeCode.split('\n');
+
+    const isDocOrConfig = /\.(md|json|ya?ml)$/i.test(safeFilename);
+    const activeRules = isDocOrConfig
+      ? this.rules.filter(r => r.cwe === 'CWE-798')
+      : this.rules;
+
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+      const lineText = lines[lineIdx];
+      const isComment = /^\s*(?:\/\/|\/\*|\*)/.test(lineText);
+
+      for (const rule of activeRules) {
+        // Pula regras de injeção, XSS e domínios de tenant se for comentário explicativo
+        if (isComment && (rule.cwe !== 'CWE-798' || rule.id === 'DEVSEC-CWE-798-TENANT-DOMAIN')) {
+          continue;
+        }
+
+        if (rule.pattern.test(lineText)) {
+          findings.push({
+            ruleId: rule.id,
+            name: rule.name,
+            cwe: rule.cwe,
+            severity: rule.severity,
+            filename: safeFilename,
+            line: lineIdx + 1,
+            snippet: lineText.trim().substring(0, 100),
+            message: rule.message,
+            remediation: rule.remediation
+          });
+        }
+      }
+    }
+
+    const hasCritical = findings.some(f => f.severity === 'CRITICAL');
+    const hasHigh = findings.some(f => f.severity === 'HIGH');
+    const status = (hasCritical || hasHigh) ? 'FAILED' : (findings.length > 0 ? 'WARNING' : 'PASSED');
+
+    return {
+      engine: 'embedded_heuristic',
+      status,
+      filename: safeFilename,
+      totalFindings: findings.length,
+      criticalCount: findings.filter(f => f.severity === 'CRITICAL').length,
+      highCount: findings.filter(f => f.severity === 'HIGH').length,
+      mediumCount: findings.filter(f => f.severity === 'MEDIUM').length,
+      findings
+    };
+  }
+
+  /**
+   * Varre um diretório recursivamente.
+   * @param {string} dirPath 
+   * @param {object|Array} [options={}]
+   * @returns {object}
+   */
+  scanDirectory(dirPath, options = {}) {
+    if (!dirPath || typeof dirPath !== 'string' || !fs.existsSync(dirPath)) {
+      return {
+        engine: 'embedded_heuristic_fallback',
+        filesScanned: 0,
+        totalFindings: 0,
+        criticalCount: 0,
+        highCount: 0,
+        findings: [],
+        status: 'PASSED'
+      };
+    }
+
+    const extensions = Array.isArray(options) ? options : (options && options.extensions ? options.extensions : ['.js', '.ts', '.jsx', '.tsx', '.json', '.md']);
+    const preferSemgrep = typeof options === 'object' && options.preferSemgrep !== false;
+
+    if (preferSemgrep && this.isSemgrepAvailable()) {
+      const semgrepRes = this.scanWithSemgrep(dirPath);
+      if (semgrepRes) {
+        return semgrepRes;
+      }
+    }
+
+    const allFindings = [];
+    let filesScanned = 0;
+
+    const walk = (dir) => {
+      try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = path.join(dir, entry.name);
+          if (entry.isDirectory()) {
+            if (!['node_modules', '.git', 'dist', 'build', '.gemini', 'test', 'saida', 'coverage'].includes(entry.name)) {
+              walk(fullPath);
+            }
+          } else if (entry.isFile()) {
+            if (entry.name === 'sast_scanner.js') continue;
+            const ext = path.extname(entry.name);
+            if (extensions.includes(ext)) {
+              filesScanned++;
+              const content = fs.readFileSync(fullPath, 'utf8');
+              const result = this.scanCode(content, path.relative(dirPath, fullPath));
+              if (result.findings.length > 0) {
+                allFindings.push(...result.findings);
+              }
+            }
+          }
+        }
+      } catch (_) {
+        // Ignora diretórios inacessíveis
+      }
+    };
+
+    walk(dirPath);
+
+    return {
+      engine: 'embedded_heuristic_fallback',
+      advisoryNotice: 'Semgrep CLI não detectado no host. A auditoria utilizou regras heurísticas estáticas embutidas. Para auditoria SAST industrial completa (NIST SSDF SP 800-218), instale Semgrep CLI.',
+      filesScanned,
+      totalFindings: allFindings.length,
+      criticalCount: allFindings.filter(f => f.severity === 'CRITICAL').length,
+      highCount: allFindings.filter(f => f.severity === 'HIGH').length,
+      findings: allFindings,
+      status: allFindings.some(f => f.severity === 'CRITICAL' || f.severity === 'HIGH') ? 'FAILED' : 'PASSED'
+    };
+  }
+
+  /**
+   * Formata os resultados da auditoria SAST em relatório executivo Markdown/texto.
+   * @param {object} scanResult 
+   * @returns {string}
+   */
+  formatReport(scanResult) {
+    if (!scanResult || typeof scanResult !== 'object') {
+      return 'Relatório SAST inválido ou vazio.';
+    }
+
+    const findings = Array.isArray(scanResult.findings) ? scanResult.findings : [];
+    let output = '================================================================================\n';
+    output += `RELATÓRIO DE AUDITORIA SAST & VULNERABILIDADES [ ${scanResult.status || 'UNKNOWN'} ]\n`;
+    output += '================================================================================\n\n';
+
+    output += `Mecanismo de Análise: ${scanResult.engine || 'heurística embutida'}\n`;
+    output += `Total de Ocorrências: ${scanResult.totalFindings || findings.length}\n`;
+    output += `- Críticas: ${scanResult.criticalCount || findings.filter(f => f.severity === 'CRITICAL').length}\n`;
+    output += `- Altas: ${scanResult.highCount || findings.filter(f => f.severity === 'HIGH').length}\n`;
+    output += `- Médias: ${scanResult.mediumCount || findings.filter(f => f.severity === 'MEDIUM').length}\n\n`;
+
+    if (scanResult.advisoryNotice) {
+      output += `Nota Consultiva: ${scanResult.advisoryNotice}\n\n`;
+    }
+
+    output += 'VULNERABILIDADES E SEGREDOS IDENTIFICADOS:\n';
+    if (findings.length === 0) {
+      output += 'Nenhuma vulnerabilidade ou credencial exposta detectada no escopo auditado.\n';
+    } else {
+      findings.forEach((f, idx) => {
+        output += `${idx + 1}. <${f.filename}:${f.line}> · [${f.severity}] ${f.name} (${f.ruleId} · ${f.cwe})\n`;
+        output += `   Trecho: "${f.snippet}"\n`;
+        output += `   Descrição: ${f.message}\n`;
+        output += `   Remediação: ${f.remediation}\n\n`;
+      });
+    }
+
+    output += '================================================================================\n';
+    return output;
+  }
+
+  /**
+   * Emite relatório oficial OASIS SARIF v2.1.0 para snippet de código em memória.
+   * @param {string} code 
+   * @param {string} [filename='snippet.js'] 
+   * @returns {object}
+   */
+  scanCodeToSarif(code, filename = 'snippet.js') {
+    const scanResult = this.scanCode(code, filename);
+    return createSarifReport({
+      toolName: 'agent-master-sast-scanner',
+      toolVersion: '5.1.0',
+      rules: this.rules,
+      findings: scanResult.findings,
+      properties: {
+        engine: scanResult.engine,
+        status: scanResult.status,
+        filename
+      }
+    });
+  }
+
+  /**
+   * Emite relatório oficial OASIS SARIF v2.1.0 para arquivo ou diretório físico.
+   * @param {string} targetPath 
+   * @param {object} [options={}] 
+   * @returns {object}
+   */
+  scanToSarif(targetPath, options = {}) {
+    const isFile = fs.existsSync(targetPath) && fs.statSync(targetPath).isFile();
+    const scanResult = isFile ? this.scanFile(targetPath, options) : this.scanDirectory(targetPath, options);
+
+    return createSarifReport({
+      toolName: scanResult.engine === 'semgrep_cli_industrial' ? 'semgrep-sast' : 'agent-master-sast-scanner',
+      toolVersion: '5.1.0',
+      rules: this.rules,
+      findings: scanResult.findings,
+      properties: {
+        engine: scanResult.engine,
+        status: scanResult.status,
+        targetPath,
+        advisoryNotice: scanResult.advisoryNotice || null
+      }
+    });
+  }
+}
+
+module.exports = {
+  SastScanner,
+  SECURITY_RULES,
+  runCliSafely
+};