Skip to content

alexgreensh/repo-forensics / skills/repo-forensics

repo-forensics

Flagged

Security forensics for git repos, AI skills, and MCP servers. Audits dependencies, detects prompt injection, credential theft, runtime dynamism, manifest drift, known CVEs, CISA KEV (actively exploited) vulns, and 2026 attack patterns. Not for fixing vulnerabilities or pentesting.

FileKindSize
.gitignoreother193 B
SKILL.mdskill md43.4 KB
checksums.jsonconfig10.8 KB
checksums.json.sigother64 B
data/README.mdmarkdown1.3 KB
data/compromised_versions.jsonconfig188.3 KB
data/rule_ids.csvother35.3 KB
data/rulepacks/.gitkeepother221 B
data/rulepacks/dead_anchors.jsonconfig9.0 KB
data/rulepacks/mcp_security.jsonconfig31.2 KB
data/rulepacks/runtime_dynamism.jsonconfig46.7 KB
data/rulepacks/sast.jsonconfig107.6 KB
data/rulepacks/secrets.jsonconfig30.4 KB
data/rulepacks/shared.jsonconfig4.4 KB
data/rulepacks/skill_threats.jsonconfig95.4 KB
data/runtime_floors.jsonconfig2.3 KB
data/yara/cryptominers.yarother1.8 KB
data/yara/hacktools.yarother2.2 KB
data/yara/malware.yarother2.2 KB
data/yara/manifest.jsonconfig8.0 KB
data/yara/webshells.yarother2.5 KB
references/cursor-hook-contract.mdmarkdown5.6 KB
references/kernel_privesc_sandbox_pack.mdmarkdown5.0 KB
references/mcp-attack-patterns.mdmarkdown8.7 KB
references/research_sources.mdmarkdown8.0 KB
references/threat_patterns.mdmarkdown20.3 KB
scripts/_context_gate.pyscript21.7 KB
scripts/_ed25519.pyscript5.1 KB
scripts/_pyc_unmarshal.pyscript17.1 KB
scripts/_shared_patterns.pyscript4.8 KB
scripts/adjudication.pyscript16.4 KB
scripts/adjudication_bridge.pyscript1.0 KB
scripts/aggregate_json.pyscript69.2 KB
scripts/auto_scan.pyexecutablescript152.1 KB
scripts/corpus_sync.pyscript10.0 KB
scripts/cursor_pre_scan.pyscript22.5 KB
scripts/dast_sandbox.sbother1.6 KB
scripts/dead_anchors_extract.pyscript14.8 KB
scripts/dead_anchors_probe.pyscript27.1 KB
scripts/forensics_core.pyscript176.5 KB
scripts/gen_rule_ids.pyscript8.6 KB
scripts/hook_adapter.pyscript19.4 KB
scripts/ioc_manager.pyscript49.6 KB
scripts/parse_pnpm_lock.pyscript7.9 KB
scripts/pre_scan.pyscript143.5 KB
scripts/pypi_pins.pyscript8.1 KB
scripts/refresh_controller.pyexecutablescript48.4 KB
scripts/refresh_threat_dbs.pyexecutablescript19.4 KB
scripts/rule_loader.pyscript44.8 KB
scripts/rulepack_feed.pyscript26.4 KB
scripts/run_forensics.shexecutablescript20.3 KB
scripts/sarif_export.pyscript18.6 KB
scripts/scan_agent_skills.pyscript33.2 KB
scripts/scan_archive.pyscript29.1 KB
scripts/scan_ast.pyscript44.9 KB
scripts/scan_binary.pyscript10.9 KB
scripts/scan_bytecode.pyscript28.2 KB
scripts/scan_dast.pyscript28.8 KB
scripts/scan_dataflow.pyscript15.4 KB
scripts/scan_dead_anchors.pyscript15.9 KB
scripts/scan_decode.pyscript37.5 KB
scripts/scan_dependencies.pyscript124.5 KB
scripts/scan_devcontainer.pyscript8.5 KB
scripts/scan_entropy.pyscript15.6 KB
scripts/scan_entrypoint.pyscript34.3 KB
scripts/scan_git_config.pyscript96.3 KB
scripts/scan_git_forensics.pyscript24.1 KB
scripts/scan_history.pyscript14.5 KB
scripts/scan_infra.pyscript54.3 KB
scripts/scan_integrity.pyscript41.0 KB
scripts/scan_lifecycle.pyscript65.1 KB
scripts/scan_manifest_drift.pyscript47.0 KB
scripts/scan_mcp_security.pyscript42.3 KB
scripts/scan_oversize.pyscript11.7 KB
scripts/scan_post_incident.pyscript36.9 KB
scripts/scan_provenance.pyscript19.4 KB
scripts/scan_runtime_dynamism.pyscript23.5 KB
scripts/scan_runtime_floors.pyscript33.5 KB
scripts/scan_sast.pyscript59.1 KB
scripts/scan_secrets.pyscript11.9 KB
scripts/scan_skill_threats.pyscript102.4 KB
scripts/scan_splitstream.pyscript29.5 KB
scripts/scan_yara.pyscript19.7 KB
scripts/session_scan.pyscript54.1 KB
scripts/suppressions.pyscript15.4 KB
scripts/validate_manifests.pyscript13.7 KB
scripts/verify_install.pyscript26.2 KB
scripts/vuln_feed.pyscript31.1 KB
tests/conftest.pyscript13.4 KB
tests/corpus/DEAD_ANCHORS_CORPUS.mdmarkdown2.3 KB
tests/corpus/budgets.jsonconfig5.6 KB
tests/cursor_helpers.pyscript12.6 KB
tests/fixtures/legacy_main_blocks.jsonconfig10.3 KB
tests/fixtures/powershell_verdict_corpus.jsonconfig114.9 KB
tests/golden/parity_mcp_security.jsonconfig17.5 KB
tests/golden/parity_runtime_dynamism.jsonconfig31.7 KB
tests/golden/parity_sast.jsonconfig59.8 KB
tests/golden/parity_secrets.jsonconfig18.8 KB
tests/golden/parity_skill_threats.jsonconfig48.8 KB
tests/parity_corpus.pyscript6.3 KB
tests/powershell_hook.pyscript8.2 KB
tests/report_builders.pyscript5.0 KB
tests/schemas/sarif-schema-2.1.0.jsonconfig109.1 KB
tests/shell_compat.pyscript2.2 KB
tests/test_adjudication_bridge.pyscript832 B
tests/test_adjudication_containment.pyscript1.4 KB
tests/test_adjudication_output.pyscript20.0 KB
tests/test_adjudication_suppressions.pyscript18.7 KB
tests/test_advisory_adjudication.pyscript1.3 KB
tests/test_agent_relay_rules.pyscript7.8 KB
tests/test_aggregate_json.pyscript10.0 KB
tests/test_auto_scan_patterns.pyscript10.5 KB
tests/test_benign_corpus.pyscript16.4 KB
tests/test_benign_new_scanners.pyscript6.1 KB
tests/test_build_output_skip.pyscript10.6 KB
tests/test_capability_ledger.pyscript18.8 KB
tests/test_codex_install.pyscript10.0 KB
tests/test_codex_marketplace.pyscript3.3 KB
tests/test_comment_false_positives.pyscript2.2 KB
tests/test_composer_dependencies.pyscript4.0 KB
tests/test_compromised_versions.pyscript51.2 KB
tests/test_context_gate.pyscript32.4 KB
tests/test_coverage_status.pyscript7.6 KB
tests/test_css_compounding_shrink.pyscript20.8 KB
tests/test_cursor_adapter.pyscript7.8 KB
tests/test_cursor_benign.pyscript3.4 KB
tests/test_cursor_degrade.pyscript12.7 KB
tests/test_cursor_install.pyscript17.1 KB
tests/test_cursor_latency.pyscript7.2 KB
tests/test_cursor_parity.pyscript5.8 KB
tests/test_cursor_redteam_fn.pyscript4.9 KB
tests/test_cursor_tamper_modify.pyscript14.2 KB
tests/test_cursor_wiring.pyscript32.3 KB
tests/test_d1_yara_correlation.pyscript9.2 KB
tests/test_dead_anchors_extract.pyscript7.6 KB
tests/test_dead_anchors_probe.pyscript19.7 KB
tests/test_evidence_engine_parity.pyscript8.1 KB
tests/test_evidence_model.pyscript11.4 KB
tests/test_forensics_core.pyscript79.2 KB
tests/test_fp_hardening_r3.pyscript9.7 KB
tests/test_fp_hardening_r4.pyscript18.8 KB
tests/test_fp_regression_pairs.pyscript62.5 KB
tests/test_fp_structural.pyscript21.2 KB
tests/test_freshness.pyscript6.2 KB
tests/test_frontmatter_validity.pyscript7.0 KB
tests/test_gpg_rce_hotfix.pyscript4.8 KB
tests/test_hook_inert_data.pyscript6.1 KB
tests/test_hook_scripts.pyscript14.0 KB
tests/test_inspection_cpu_budget.pyscript11.6 KB
tests/test_ioc_manager.pyscript55.4 KB
tests/test_kernel_privesc_rules.pyscript27.8 KB
tests/test_legit_precision_regressions.pyscript6.8 KB
tests/test_lethal_trifecta.pyscript20.7 KB
tests/test_manifest_signature.pyscript1.5 KB
tests/test_manifest_validity.pyscript2.9 KB
tests/test_monotonic_trust_e2e.pyscript4.4 KB
tests/test_non_breaking_contract.pyscript22.7 KB
tests/test_openclaw_install.pyscript6.6 KB
tests/test_pack_parity.pyscript24.8 KB
tests/test_parse_pnpm_lock.pyscript10.7 KB
tests/test_plugin_checkout_provenance.pyscript11.1 KB
tests/test_powershell_hook_wire.pyscript10.6 KB
tests/test_powershell_verdict_corpus.pyscript6.2 KB
tests/test_pr44_hardening.pyscript6.5 KB
tests/test_pre_scan.pyscript19.6 KB
tests/test_pre_scan_composer.pyscript7.4 KB
tests/test_precondition_fields.pyscript4.6 KB
tests/test_provenance_offline.pyscript2.5 KB
tests/test_published_rulepack_feed_current.pyscript1.4 KB
tests/test_py38_compat.pyscript3.3 KB
tests/test_pypi_pinned_versions.pyscript19.3 KB
tests/test_pyproject_string_forms.pyscript2.2 KB
tests/test_redteam_fn_regression.pyscript32.5 KB
tests/test_reflective_fetch_execute.pyscript23.5 KB
tests/test_reflective_review_fixes.pyscript17.8 KB
tests/test_refresh_controller.pyscript19.9 KB
tests/test_refresh_rulepacks.pyscript12.4 KB
tests/test_review_gate_regressions.pyscript9.3 KB
tests/test_rule_loader.pyscript23.2 KB
tests/test_rulepack_feed.pyscript38.1 KB
tests/test_run_forensics_json.pyscript1012 B
tests/test_run_scanner_fail_loud.pyscript6.5 KB
tests/test_runtime_floors.pyscript19.8 KB
tests/test_sandbox_probing_rules.pyscript9.6 KB
tests/test_sarif_export.pyscript19.9 KB
tests/test_scan_agent_skills.pyscript31.3 KB
tests/test_scan_archive.pyscript11.6 KB
tests/test_scan_ast.pyscript12.8 KB
tests/test_scan_binary.pyscript15.3 KB
tests/test_scan_bytecode.pyscript21.5 KB
tests/test_scan_dast.pyscript32.1 KB
tests/test_scan_dataflow.pyscript7.1 KB
tests/test_scan_dead_anchors.pyscript11.5 KB
tests/test_scan_decode.pyscript28.0 KB
tests/test_scan_dependencies.pyscript37.8 KB
tests/test_scan_devcontainer.pyscript8.5 KB
tests/test_scan_entropy.pyscript11.2 KB
tests/test_scan_entrypoint.pyscript19.5 KB
tests/test_scan_git_config.pyscript58.5 KB
tests/test_scan_git_config_review_fixes.pyscript33.3 KB

scripts/scan_dataflow.py

View on GitHub
#!/usr/bin/env python3
"""
scan_dataflow.py - Lightweight Source-to-Sink Taint Tracker
Tracks sensitive data from sources (env vars, credential files)
through assignments to sinks (network calls, code execution).

Single-pass forward analysis, regex-based (not AST).
Supports Python and JavaScript/TypeScript.

Created by Alex Greenshpun
"""

import ast
import os
import re
import sys
from collections import defaultdict

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import forensics_core as core

SCANNER_NAME = "dataflow"

# === Sources: where sensitive data enters ===
PYTHON_SOURCES = [
    (re.compile(r'(\w+)\s*=\s*os\.environ\b', re.IGNORECASE), "os.environ access"),
    (re.compile(r'(\w+)\s*=\s*os\.environ\.copy\(\)', re.IGNORECASE), "os.environ.copy()"),
    (re.compile(r'(\w+)\s*=\s*os\.environ\.get\(', re.IGNORECASE), "os.environ.get()"),
    (re.compile(r'(\w+)\s*=\s*os\.environ\[', re.IGNORECASE), "os.environ[] access"),
    (re.compile(r'(\w+)\s*=\s*os\.getenv\(', re.IGNORECASE), "os.getenv() access"),
    (re.compile(r'(\w+)\s*=\s*getattr\s*\(\s*os\s*,\s*["\']environ["\']\)', re.IGNORECASE), "getattr(os, 'environ') evasion"),
    (re.compile(r'(\w+)\s*=\s*open\s*\([^)]*(?:\.env|\.ssh|\.aws|credentials|\.gnupg|\.config|\.claude|\.kiro|\.kube|\.terraform|sitemanager\.xml|recentservers\.xml|\.atomic|msal_token_cache|\.remmina|\.ovpn|\.npmrc|\.git-credentials)'), "Sensitive file read"),
    (re.compile(r'(\w+)\s*=\s*pathlib\.Path\s*\([^)]*(?:\.env|\.ssh|\.aws|credentials|\.claude|\.kiro|\.kube|\.terraform|msal_token_cache|sitemanager\.xml|\.atomic)'), "Sensitive path access"),
    (re.compile(r'(\w+)\s*=\s*dotenv\.dotenv_values\(', re.IGNORECASE), "dotenv values load"),
]

JS_SOURCES = [
    (re.compile(r'(?:const|let|var)\s+(\w+)\s*=\s*process\.env\b', re.IGNORECASE), "process.env access"),
    (re.compile(r'(?:const|let|var)\s+(\w+)\s*=\s*Object\.keys\s*\(\s*process\.env', re.IGNORECASE), "process.env enumeration"),
    (re.compile(r'(?:const|let|var)\s+(\w+)\s*=\s*(?:fs\.)?readFileSync\s*\([^)]*(?:\.env|\.ssh|\.aws|credential|\.claude|\.kiro|\.kube|\.terraform|sitemanager\.xml|\.atomic|msal_token_cache|\.npmrc|\.git-credentials)'), "Sensitive file read"),
    (re.compile(r'(?:const|let|var)\s+(\w+)\s*=\s*require\s*\(["\']dotenv["\']\)', re.IGNORECASE), "dotenv require"),
    (re.compile(r'(?:const|let|var)\s+(\w+)\s*=\s*JSON\.parse\s*\(\s*(?:fs\.)?readFileSync', re.IGNORECASE), "JSON file parse"),
]

# === Sinks: where data leaves ===
PYTHON_SINKS = [
    re.compile(r'requests\.(post|put|patch|delete)\s*\(', re.IGNORECASE),
    re.compile(r'urllib\.request\.(urlopen|Request)\s*\(', re.IGNORECASE),
    re.compile(r'http\.client\.HTTPConnection', re.IGNORECASE),
    re.compile(r'httpx\.(post|put|patch|delete|AsyncClient)\s*\(', re.IGNORECASE),
    re.compile(r'aiohttp\.ClientSession', re.IGNORECASE),
    re.compile(r'subprocess\.(run|call|Popen|check_output)\s*\(', re.IGNORECASE),
    re.compile(r'os\.system\s*\(', re.IGNORECASE),
    re.compile(r'os\.popen\s*\(', re.IGNORECASE),
    re.compile(r'eval\s*\(', re.IGNORECASE),
    re.compile(r'exec\s*\(', re.IGNORECASE),
    re.compile(r'__import__\s*\(', re.IGNORECASE),
]

JS_SINKS = [
    re.compile(r'fetch\s*\(', re.IGNORECASE),
    re.compile(r'axios\.(post|put|patch|delete)\s*\(', re.IGNORECASE),
    re.compile(r'XMLHttpRequest', re.IGNORECASE),
    re.compile(r'require\s*\(["\']child_process["\']\)', re.IGNORECASE),
    re.compile(r'child_process\.(exec|spawn|execSync)\s*\(', re.IGNORECASE),
    re.compile(r'eval\s*\(', re.IGNORECASE),
    re.compile(r'Function\s*\(', re.IGNORECASE),
    re.compile(r'new\s+WebSocket\s*\(', re.IGNORECASE),
]
PYTHON_NETWORK_SINKS = frozenset(PYTHON_SINKS[:5])
JS_NETWORK_SINKS = frozenset(JS_SINKS[:3] + JS_SINKS[-1:])

# === Assignment tracking ===
ASSIGN_PATTERN = re.compile(r'(?:(?:const|let|var)\s+)?(\w+)\s*=(?!=)\s*(.*)')
TAINT_PROPAGATORS = [
    re.compile(r'base64\.(b64encode|encode|urlsafe_b64encode)\s*\(', re.IGNORECASE),
    re.compile(r'json\.dumps\s*\(', re.IGNORECASE),
    re.compile(r'str\s*\(', re.IGNORECASE),
    re.compile(r'\.encode\s*\(', re.IGNORECASE),
    re.compile(r'Buffer\.from\s*\(', re.IGNORECASE),
    re.compile(r'btoa\s*\(', re.IGNORECASE),
    re.compile(r'JSON\.stringify\s*\(', re.IGNORECASE),
    re.compile(r'encodeURIComponent\s*\(', re.IGNORECASE),
]


def detect_language(rel_path):
    ext = os.path.splitext(rel_path)[1].lower()
    if ext in ('.py',):
        return 'python'
    elif ext in ('.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'):
        return 'javascript'
    return None


class _ScopeBindings(ast.NodeVisitor):
    def __init__(self):
        self.globals = set()
        self.nonlocals = set()
        self.locals = set()

    def visit_Global(self, node):
        self.globals.update(node.names)

    def visit_Nonlocal(self, node):
        self.nonlocals.update(node.names)

    def visit_Name(self, node):
        if isinstance(node.ctx, ast.Store):
            self.locals.add(node.id)

    def visit_FunctionDef(self, node):
        self.locals.add(node.name)

    visit_AsyncFunctionDef = visit_FunctionDef
    visit_ClassDef = visit_FunctionDef


def analyze_file(file_path, rel_path):
    """Single-pass forward taint analysis on one file."""
    lang = detect_language(rel_path)
    if lang is None:
        return []

    try:
        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
            lines = f.readlines()
    except (OSError, UnicodeDecodeError):
        return []

    sources = PYTHON_SOURCES if lang == 'python' else JS_SOURCES
    sinks = PYTHON_SINKS if lang == 'python' else JS_SINKS
    network_sinks = PYTHON_NETWORK_SINKS if lang == 'python' else JS_NETWORK_SINKS

    tainted_vars = {}  # var_name -> (source_line, source_desc)
    scope_starts = defaultdict(list)
    if lang == 'python':
        try:
            tree = ast.parse(''.join(lines))
            for node in ast.walk(tree):
                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
                    bindings = _ScopeBindings()
                    for stmt in node.body:
                        bindings.visit(stmt)
                    params = set()
                    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
                        args = node.args
                        params.update(a.arg for a in args.posonlyargs + args.args + args.kwonlyargs)
                        params.update(a.arg for a in (args.vararg, args.kwarg) if a)
                    bindings.locals.update(params)
                    scope_starts[node.lineno].append((
                        node.end_lineno, bindings.globals, bindings.nonlocals,
                        bindings.locals, params, isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)),
                    ))
        except (SyntaxError, ValueError, RecursionError, MemoryError):
            pass
    scopes = [(float('inf'), tainted_vars, set(), set(), set(), False)]
    findings = []

    for i, line in enumerate(lines):
        line_stripped = line.strip()
        line_no = i + 1
        if lang == 'python':
            while len(scopes) > 1 and line_no > scopes[-1][0]:
                scopes.pop()
            for end_line, global_names, nonlocal_names, local_names, params, is_function in sorted(
                scope_starts.get(line_no, []), key=lambda item: item[0], reverse=True,
            ):
                scoped_taints = scopes[-1][1].copy()
                for param in params:
                    scoped_taints.pop(param, None)
                scopes.append((end_line, scoped_taints, global_names, nonlocal_names, local_names, is_function))
            tainted_vars = scopes[-1][1]

        # Bound regex backtracking by TRUNCATING, never skipping: dropping the
        # line entirely lets a payload hide behind 10k characters of padding.
        line_stripped = core.clip_line(line_stripped)

        # Reassignment ends the old value's taint unless the RHS carries it.
        assign_m = ASSIGN_PATTERN.match(line_stripped)
        if assign_m:
            lhs = assign_m.group(1)
            rhs = assign_m.group(2)
            inherited = None
            for tvar in tainted_vars:
                if re.search(r'\b' + re.escape(tvar) + r'\b', rhs):
                    inherited = tainted_vars[tvar]
                    break
            targets = [tainted_vars]
            if lang == 'python' and lhs in scopes[-1][2]:
                targets.append(scopes[0][1])
            elif lang == 'python' and lhs in scopes[-1][3]:
                for scope in reversed(scopes[:-1]):
                    if scope[5] and lhs in scope[4]:
                        targets.append(scope[1])
                        break
            for target in targets:
                if inherited is None:
                    target.pop(lhs, None)
                else:
                    target[lhs] = inherited

        # Check if line introduces a tainted source
        for source_pat, source_desc in sources:
            m = source_pat.search(line_stripped)
            if m:
                var_name = m.group(1)
                tainted_vars[var_name] = (line_no, source_desc)
                if lang == 'python' and var_name in scopes[-1][2]:
                    scopes[0][1][var_name] = tainted_vars[var_name]
                elif lang == 'python' and var_name in scopes[-1][3]:
                    for scope in reversed(scopes[:-1]):
                        if scope[5] and var_name in scope[4]:
                            scope[1][var_name] = tainted_vars[var_name]
                            break

        # Check if any tainted variable reaches a sink
        sink_text = assign_m.group(2) if assign_m else line_stripped
        for sink_pat in sinks:
            if sink_pat.search(sink_text):
                for tvar, (src_line, src_desc) in tainted_vars.items():
                    if re.search(r'\b' + re.escape(tvar) + r'\b', sink_text):
                        findings.append(core.Finding(
                            scanner=SCANNER_NAME,
                            severity="critical",
                            title="Tainted Data Reaches Sink",
                            description=f"Variable '{tvar}' (from {src_desc} at line {src_line}) flows to sink",
                            file=rel_path,
                            line=line_no,
                            snippet=line_stripped[:120],
                            category="dataflow",
                            rule_id="DF-NET-001" if sink_pat in network_sinks else "DF-EXEC-001",
                        ))

    return findings


def build_import_graph(repo_path, ignore_patterns):
    """Build a simple import graph to check cross-file taint."""
    imports = defaultdict(set)  # file -> set of imported file stems

    for file_path, rel_path in core.walk_repo(repo_path, ignore_patterns, skip_binary=True):
        lang = detect_language(rel_path)
        if lang is None:
            continue

        try:
            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                # Filter mega-lines to prevent O(n^2) regex backtracking
                content = ''.join(core.clip_line(line) for line in f)
        except (OSError, UnicodeDecodeError):
            continue

        if lang == 'python':
            for m in re.finditer(r'(?:from|import)\s+([\w.]+)', content):
                imports[rel_path].add(m.group(1).split('.')[0])
        elif lang == 'javascript':
            for m in re.finditer(r'(?:require|import)\s*\(?["\']\.?\.?/?([\w/.-]+)["\']', content):
                mod = m.group(1).split('/')[-1].replace('.js', '').replace('.ts', '')
                imports[rel_path].add(mod)

    return imports


def main():
    args = core.parse_common_args(sys.argv, "Dataflow Taint Tracker")
    repo_path = args.repo_path

    core.emit_status(args.format, f"[*] Running dataflow analysis on {repo_path}...")

    ignore_patterns = core.load_ignore_patterns(repo_path)
    all_findings = []

    # Per-file taint analysis
    file_findings = {}
    for file_path, rel_path in core.walk_repo(repo_path, ignore_patterns, skip_binary=True):
        findings = analyze_file(file_path, rel_path)
        if findings:
            file_findings[rel_path] = findings
            all_findings.extend(findings)

    # Cross-file: if file A has tainted sources and file B imports A and has sinks
    import_graph = build_import_graph(repo_path, ignore_patterns)
    # Only STRONG sources taint a whole module cross-file. Whole-env capture,
    # env enumeration, and credential-file reads are rare outside exfiltration;
    # bare process.env reads, dotenv, and JSON config parses are ubiquitous in
    # legitimate server code and mass-flagged clean packages.
    cross_file_sources = {
        'python': [p for p in PYTHON_SOURCES
                   if p[1] in ("os.environ.copy()", "Sensitive file read", "Sensitive path access")],
        'javascript': [p for p in JS_SOURCES
                       if p[1] in ("process.env enumeration", "Sensitive file read")],
    }
    tainted_modules = set()
    for file_path, rel_path in core.walk_repo(repo_path, ignore_patterns, skip_binary=True):
        lang = detect_language(rel_path)
        if lang is None:
            continue
        try:
            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                # Filter mega-lines to prevent O(n^2) regex backtracking
                content = ''.join(core.clip_line(line) for line in f)
        except (OSError, UnicodeDecodeError):
            continue

        for source_pat, _ in cross_file_sources[lang]:
            if source_pat.search(content):
                stem = os.path.splitext(os.path.basename(rel_path))[0]
                tainted_modules.add(stem)

    for rel_path, imported_modules in import_graph.items():
        for tmod in tainted_modules:
            if tmod in imported_modules:
                # Check if this file has sinks
                file_path_full = os.path.join(repo_path, rel_path)
                lang = detect_language(rel_path)
                if lang is None:
                    continue
                sinks = PYTHON_SINKS if lang == 'python' else JS_SINKS
                try:
                    with open(file_path_full, 'r', encoding='utf-8', errors='ignore') as f:
                        # Filter mega-lines to prevent O(n^2) regex backtracking
                        content = ''.join(core.clip_line(line) for line in f)
                except (OSError, UnicodeDecodeError):
                    continue

                content_lines = content.split('\n')
                for sink_pat in sinks:
                    m = sink_pat.search(content)
                    if m:
                        line_no = content[:m.start()].count('\n') + 1
                        snippet = content_lines[line_no - 1].strip()[:120] if line_no <= len(content_lines) else ""
                        all_findings.append(core.Finding(
                            scanner=SCANNER_NAME,
                            severity="high",
                            title="Cross-File Taint: Import from Tainted Module",
                            description=f"File imports from '{tmod}' (which accesses sensitive data) and contains sinks",
                            file=rel_path,
                            line=line_no,
                            snippet=snippet,
                            category="dataflow"
                        ))
                        break  # One finding per file per tainted module

    core.output_findings(all_findings, args.format, SCANNER_NAME)


if __name__ == "__main__":
    main()
rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first.Stars: 194kUpdated Claude CodeCodexVerifiedInstall