Skip to content

armgit / ARES

Public Imported from GitHub
0

ARES - authorized red-team engagement automation with dashboard, campaign scope, module orchestration, OPSEC controls, encrypted vault, and reporting.

55.6 KB
Raw Blame
"""
ARES v1.0.0 Unit Tests
Covers all new systems:
  - Capability system (CAP_NET/EXEC/FS/DB/PROCESS)
  - API RBAC (role enforcement, rate limiting)
  - Attack AI Planner (scoring, suggestions)
  - Dependency audit (pip-audit wrapper)
  - Campaign graph (node/edge builder)
  - Subprocess worker (capability limits)
  - Plugin loader security (signing + capability enforcement)

Run: pytest tests/unit/test_capabilities_rbac_planner.py -v
"""
from __future__ import annotations

import concurrent.futures
import time
from unittest.mock import MagicMock, patch

import pytest

from ares.api.rbac import (
    RATE_LIMITS,
    AuthenticatedUser,
    RateLimiter,
)
from ares.core.capabilities import (
    CAP_COMMUNITY_MAX,
    CAP_LATERAL_MODULE,
    CAP_NETWORK_MODULE,
    Capability,
    CapabilityPolicy,
    CapabilityViolation,
    default_capabilities_for_category,
)

# ═══════════════════════════════════════════════════════════════════════════════
# 1. Capability System
# ═══════════════════════════════════════════════════════════════════════════════

class TestCapabilitySystem:

    def test_all_capabilities_defined(self):
        caps = list(Capability)
        assert Capability.CAP_NET     in caps
        assert Capability.CAP_EXEC    in caps
        assert Capability.CAP_FS      in caps
        assert Capability.CAP_DB      in caps
        assert Capability.CAP_PROCESS in caps
        assert Capability.CAP_UNSAFE  in caps

    def test_builtin_trust_allows_all(self):
        allowed = CapabilityPolicy.allowed_for_trust("builtin")
        assert frozenset(Capability) == allowed

    def test_community_trust_excludes_exec(self):
        allowed = CapabilityPolicy.allowed_for_trust("community")
        assert Capability.CAP_NET    in allowed
        assert Capability.CAP_DB     in allowed
        assert Capability.CAP_FS     in allowed
        assert Capability.CAP_EXEC   not in allowed
        assert Capability.CAP_UNSAFE not in allowed

    def test_external_trust_minimal_caps(self):
        allowed = CapabilityPolicy.allowed_for_trust("external")
        assert Capability.CAP_NET in allowed
        assert Capability.CAP_DB  in allowed
        assert Capability.CAP_FS     not in allowed
        assert Capability.CAP_EXEC   not in allowed

    def test_unsigned_trust_net_only(self):
        allowed = CapabilityPolicy.allowed_for_trust("unsigned")
        assert Capability.CAP_NET in allowed
        assert len(allowed) == 1

    def test_validate_valid_community_module(self):
        errors = CapabilityPolicy.validate(
            "corp.my_module",
            {Capability.CAP_NET, Capability.CAP_DB},
            "community",
        )
        assert errors == []

    def test_validate_community_tries_exec_fails(self):
        errors = CapabilityPolicy.validate(
            "corp.bad_module",
            {Capability.CAP_NET, Capability.CAP_EXEC},  # EXEC not allowed
            "community",
        )
        assert len(errors) == 1
        assert "cap_exec" in errors[0].lower()

    def test_enforce_raises_capability_violation(self):
        with pytest.raises(CapabilityViolation) as exc_info:
            CapabilityPolicy.enforce(
                "corp.bad_module",
                {Capability.CAP_NET, Capability.CAP_EXEC},
                "community",
            )
        assert exc_info.value.module_id == "corp.bad_module"
        assert Capability.CAP_EXEC in exc_info.value.forbidden

    def test_builtin_can_declare_unsafe(self):
        errors = CapabilityPolicy.validate(
            "ares.core.module",
            {Capability.CAP_UNSAFE},
            "builtin",
        )
        assert errors == []

    def test_community_cannot_declare_unsafe(self):
        errors = CapabilityPolicy.validate(
            "corp.unsafe",
            {Capability.CAP_UNSAFE},
            "community",
        )
        assert len(errors) > 0

    def test_seccomp_syscalls_for_net_cap(self):
        syscalls = CapabilityPolicy.seccomp_syscalls_for(
            frozenset({Capability.CAP_NET})
        )
        assert "socket"  in syscalls
        assert "connect" in syscalls
        assert "read"    in syscalls   # base syscalls always present
        assert "execve"  not in syscalls  # no CAP_EXEC

    def test_seccomp_syscalls_unsafe_returns_empty(self):
        # Empty set = no seccomp filter
        syscalls = CapabilityPolicy.seccomp_syscalls_for(
            frozenset({Capability.CAP_UNSAFE})
        )
        assert syscalls == set()

    def test_seccomp_includes_exec_when_cap_exec(self):
        syscalls = CapabilityPolicy.seccomp_syscalls_for(
            frozenset({Capability.CAP_NET, Capability.CAP_EXEC})
        )
        assert "execve" in syscalls
        assert "fork"   in syscalls
        assert "clone"  in syscalls

    def test_resource_limits_for_net_only(self):
        limits = CapabilityPolicy.resource_limits_for(
            frozenset({Capability.CAP_NET})
        )
        assert limits["cpu_time_s"] == 30
        assert limits["memory_mb"]  == 256
        assert limits["max_procs"]  == 1   # no CAP_EXEC → 1 process

    def test_resource_limits_for_exec_cap(self):
        limits = CapabilityPolicy.resource_limits_for(
            frozenset({Capability.CAP_NET, Capability.CAP_EXEC})
        )
        assert limits["cpu_time_s"] == 120
        assert limits["memory_mb"]  == 512
        assert limits["max_procs"]  == 8

    def test_resource_limits_unsafe_empty(self):
        limits = CapabilityPolicy.resource_limits_for(
            frozenset({Capability.CAP_UNSAFE})
        )
        assert limits == {}

    def test_default_caps_for_category(self):
        assert Capability.CAP_NET    in default_capabilities_for_category("ad")
        assert Capability.CAP_EXEC   in default_capabilities_for_category("lateral")
        assert Capability.CAP_PROCESS in default_capabilities_for_category("linux")
        assert Capability.CAP_FS     in default_capabilities_for_category("reporting")

    def test_cap_profiles_are_correct_types(self):
        assert isinstance(CAP_NETWORK_MODULE, frozenset)
        assert isinstance(CAP_LATERAL_MODULE, frozenset)
        assert isinstance(CAP_COMMUNITY_MAX,  frozenset)
        assert Capability.CAP_EXEC in CAP_LATERAL_MODULE
        assert Capability.CAP_EXEC not in CAP_NETWORK_MODULE


# ═══════════════════════════════════════════════════════════════════════════════
# 2. API RBAC
# ═══════════════════════════════════════════════════════════════════════════════

class TestAPIRBAC:

    def test_rate_limiter_allows_within_limit(self):
        limiter = RateLimiter()
        allowed, remaining = limiter.is_allowed("test:127.0.0.1", max_per_minute=5)
        assert allowed
        assert remaining == 4

    def test_rate_limiter_blocks_at_limit(self):
        limiter = RateLimiter()
        key = "test:10.0.0.1"
        for _ in range(5):
            limiter.is_allowed(key, max_per_minute=5)
        allowed, remaining = limiter.is_allowed(key, max_per_minute=5)
        assert not allowed
        assert remaining == 0

    def test_rate_limiter_separate_keys_independent(self):
        limiter = RateLimiter()
        # Fill up key A
        for _ in range(3):
            limiter.is_allowed("test:ip_a", max_per_minute=3)
        allowed_a, _ = limiter.is_allowed("test:ip_a", max_per_minute=3)
        # Key B unaffected
        allowed_b, _ = limiter.is_allowed("test:ip_b", max_per_minute=3)
        assert not allowed_a
        assert allowed_b

    def test_rate_limiter_window_expires(self):
        limiter = RateLimiter()
        key = "test:expire"
        # Manually inject old timestamps
        old_time = time.time() - 70  # 70s ago (outside 60s window)
        for _ in range(5):
            limiter._windows[key].append(old_time)
        # Now the window should be empty and request allowed
        allowed, _ = limiter.is_allowed(key, max_per_minute=3)
        assert allowed

    def test_rate_limits_config_all_defined(self):
        required = {"global", "auth", "module_run", "report", "register"}
        assert required <= set(RATE_LIMITS.keys())

    def test_authenticated_user_dataclass(self):
        user = AuthenticatedUser(username="alice", role="operator")
        assert user.username == "alice"
        assert user.role     == "operator"

    def test_role_can_access_team_lead_all(self):
        from ares.api.rbac import _role_can_access
        assert _role_can_access("team_lead", "POST", "/modules/run")
        assert _role_can_access("team_lead", "POST", "/auth/register")
        assert _role_can_access("team_lead", "DELETE", "/anything")

    def test_role_can_access_recon_limited(self):
        from ares.api.rbac import _role_can_access
        # Recon can list modules
        assert _role_can_access("recon", "GET", "/modules")
        # Recon cannot run modules
        assert not _role_can_access("recon", "POST", "/modules/lateral.psexec/run")
        # Recon cannot register users
        assert not _role_can_access("recon", "POST", "/auth/register")

    def test_role_can_access_reporter_read_only(self):
        from ares.api.rbac import _role_can_access
        # Reporter can read
        assert _role_can_access("reporter", "GET", "/campaigns")
        assert _role_can_access("reporter", "GET", "/reports")
        # Reporter cannot POST campaigns
        # (POST not in reporter allowed list)
        assert not _role_can_access("reporter", "POST", "/campaigns")

    def test_rate_limit_check_or_raise(self):
        from fastapi import HTTPException

        from ares.api.rbac import _limiter
        key = f"test_raise:{time.time()}"  # unique key
        for _ in range(60):
            _limiter.is_allowed(key, max_per_minute=60)
        # 61st should raise
        with pytest.raises(HTTPException) as exc_info:
            _limiter.check_or_raise(key, max_per_minute=60)
        assert exc_info.value.status_code == 429


# ═══════════════════════════════════════════════════════════════════════════════
# 3. Attack AI Planner
# ═══════════════════════════════════════════════════════════════════════════════

class TestAttackPlanner:

    @pytest.fixture
    def mock_registry(self):
        """Registry with stub modules."""
        from ares.core.capabilities import Capability
        from ares.core.plugin.loader import ModuleRegistry
        from ares.modules.base import BaseModule, OpsecLevel

        class StubKerberoast(BaseModule):
            MODULE_ID          = "ad.kerberoast"
            MODULE_NAME        = "Kerberoast"
            MODULE_CATEGORY    = "ad"
            MODULE_DESCRIPTION = "Kerberoast"
            OPSEC_LEVEL        = OpsecLevel.MEDIUM
            REQUIRES           = ["domain_creds"]
            OUTPUTS            = ["credential"]
            MITRE_TECHNIQUES   = ["T1558.003"]
            CAPABILITIES       = {Capability.CAP_NET, Capability.CAP_DB}
            async def run(self, **k): return [], {}

        class StubASREP(BaseModule):
            MODULE_ID          = "ad.asreproast"
            MODULE_NAME        = "ASREPRoast"
            MODULE_CATEGORY    = "ad"
            MODULE_DESCRIPTION = "ASREPRoast"
            OPSEC_LEVEL        = OpsecLevel.MEDIUM
            REQUIRES           = []
            OUTPUTS            = ["credential"]
            MITRE_TECHNIQUES   = ["T1558.004"]
            CAPABILITIES       = {Capability.CAP_NET}
            async def run(self, **k): return [], {}

        class StubDCSync(BaseModule):
            MODULE_ID          = "ad.dcsync"
            MODULE_NAME        = "DCSync"
            MODULE_CATEGORY    = "ad"
            MODULE_DESCRIPTION = "DCSync"
            OPSEC_LEVEL        = OpsecLevel.HIGH_NOISE
            REQUIRES           = ["domain_admin_creds"]
            OUTPUTS            = ["all_ntlm_hashes"]
            MITRE_TECHNIQUES   = ["T1003.006"]
            CAPABILITIES       = {Capability.CAP_NET, Capability.CAP_DB}
            async def run(self, **k): return [], {}

        class StubReport(BaseModule):
            MODULE_ID          = "reporting.html"
            MODULE_NAME        = "HTML Report"
            MODULE_CATEGORY    = "reporting"
            MODULE_DESCRIPTION = "Generate HTML report"
            OPSEC_LEVEL        = OpsecLevel.SILENT
            REQUIRES           = []
            OUTPUTS            = ["report"]
            MITRE_TECHNIQUES   = []
            CAPABILITIES       = {Capability.CAP_DB, Capability.CAP_FS}
            async def run(self, **k): return [], {}

        registry = ModuleRegistry()
        registry.register(StubKerberoast, "builtin")
        registry.register(StubASREP,     "builtin")
        registry.register(StubDCSync,    "builtin")
        registry.register(StubReport,    "builtin")
        return registry

    @pytest.fixture
    def planner(self, mock_registry):
        from ares.goal.planner import AttackPlanner
        return AttackPlanner(registry=mock_registry)

    def test_suggest_returns_suggestions(self, planner):
        from ares.goal.engine import Goal
        from ares.goal.planner import PlannerContext
        ctx = PlannerContext(
            goal=Goal.DOMAIN_ADMIN,
            targets=["10.0.0.1"],
            opsec_profile="normal",
        )
        suggestions = planner.suggest(ctx, limit=5)
        assert len(suggestions) > 0

    def test_suggest_excludes_reporting_modules(self, planner):
        from ares.goal.engine import Goal
        from ares.goal.planner import PlannerContext
        ctx = PlannerContext(
            goal=Goal.DOMAIN_ADMIN,
            targets=["10.0.0.1"],
        )
        suggestions = planner.suggest(ctx)
        module_ids = {s.module_id for s in suggestions}
        assert "reporting.html" not in module_ids

    def test_suggest_excludes_high_noise_in_stealth(self, planner):
        from ares.goal.engine import Goal
        from ares.goal.planner import PlannerContext
        ctx = PlannerContext(
            goal=Goal.DOMAIN_ADMIN,
            targets=["10.0.0.1"],
            opsec_profile="stealth",  # max noise 0.2
        )
        suggestions = planner.suggest(ctx)
        module_ids = {s.module_id for s in suggestions}
        assert "ad.dcsync" not in module_ids   # HIGH_NOISE filtered

    def test_suggest_prefers_asrep_when_no_creds(self, planner):
        from ares.goal.engine import Goal
        from ares.goal.planner import PlannerContext
        # No creds available → ASREPRoast (no prereqs) should score higher
        # than Kerberoast (requires domain_creds)
        ctx = PlannerContext(
            goal=Goal.DOMAIN_ADMIN,
            targets=["10.0.0.1"],
            opsec_profile="normal",
        )
        suggestions = planner.suggest(ctx)
        # ASREPRoast has no prereqs → higher prereq_met score
        asrep = next((s for s in suggestions if s.module_id == "ad.asreproast"), None)
        kerberoast = next((s for s in suggestions if s.module_id == "ad.kerberoast"), None)
        if asrep and kerberoast:
            # ASREPRoast should score higher when no creds (no prereqs)
            assert asrep.score >= kerberoast.score

    def test_suggest_excludes_already_tried(self, planner):
        from ares.goal.engine import Goal
        from ares.goal.planner import PlannerContext
        ctx = PlannerContext(
            goal=Goal.DOMAIN_ADMIN,
            targets=["10.0.0.1"],
            already_tried={"ad.asreproast:10.0.0.1"},
        )
        suggestions = planner.suggest(ctx)
        module_ids = {s.module_id for s in suggestions}
        assert "ad.asreproast" not in module_ids

    def test_suggestions_have_required_fields(self, planner):
        from ares.goal.engine import Goal
        from ares.goal.planner import PlannerContext
        ctx = PlannerContext(goal=Goal.DOMAIN_ADMIN, targets=["10.0.0.1"])
        suggestions = planner.suggest(ctx, limit=3)
        for s in suggestions:
            assert s.module_id       != ""
            assert s.module_name     != ""
            assert 0.0 <= s.score <= 1.0
            assert s.suggested_target == "10.0.0.1"
            assert s.opsec_level     != ""
            assert isinstance(s.score_breakdown, dict)
            assert len(s.score_breakdown) > 0

    def test_suggestion_to_dict(self, planner):
        from ares.goal.engine import Goal
        from ares.goal.planner import PlannerContext
        ctx = PlannerContext(goal=Goal.DOMAIN_ADMIN, targets=["10.0.0.1"])
        suggestions = planner.suggest(ctx, limit=1)
        if suggestions:
            d = suggestions[0].to_dict()
            assert "module_id"       in d
            assert "score"           in d
            assert "rationale"       in d
            assert "score_breakdown" in d

    def test_suggestions_sorted_highest_first(self, planner):
        from ares.goal.engine import Goal
        from ares.goal.planner import PlannerContext
        ctx = PlannerContext(goal=Goal.DOMAIN_ADMIN, targets=["10.0.0.1"])
        suggestions = planner.suggest(ctx)
        scores = [s.score for s in suggestions]
        assert scores == sorted(scores, reverse=True)

    def test_auto_suggest_function(self, mock_registry):
        from ares.goal.engine import Goal
        from ares.goal.planner import auto_suggest
        suggestions = auto_suggest(
            goal=Goal.DOMAIN_ADMIN,
            targets=["10.0.0.1"],
            registry=mock_registry,
            opsec_profile="normal",
            limit=3,
        )
        assert isinstance(suggestions, list)


# ═══════════════════════════════════════════════════════════════════════════════
# 4. Dependency Audit
# ═══════════════════════════════════════════════════════════════════════════════

class TestDependencyAudit:

    def test_audit_result_clean_flag(self):
        from ares.security.audit import AuditResult
        clean = AuditResult(scanned_packages=10, vulnerabilities=[])
        assert clean.clean
        assert clean.total_count == 0

    def test_audit_result_counts(self):
        from ares.security.audit import AuditResult, CVSSScore, Vulnerability
        result = AuditResult(
            scanned_packages=20,
            vulnerabilities=[
                Vulnerability("pkg1", "1.0", "CVE-2024-1001", "desc",
                               CVSSScore.CRITICAL, "1.1"),
                Vulnerability("pkg2", "2.0", "CVE-2024-1002", "desc",
                               CVSSScore.HIGH, "2.1"),
                Vulnerability("pkg3", "3.0", "CVE-2024-1003", "desc",
                               CVSSScore.MEDIUM, ""),
            ]
        )
        assert result.critical_count == 1
        assert result.high_count     == 1
        assert result.total_count    == 3
        assert not result.clean

    def test_audit_result_to_dict(self):
        from ares.security.audit import AuditResult
        result = AuditResult(scanned_packages=5)
        d = result.to_dict()
        assert "scanned_packages" in d
        assert "total_count"      in d
        assert "critical_count"   in d
        assert "clean"            in d
        assert "vulnerabilities"  in d

    def test_audit_result_summary_clean(self):
        from ares.security.audit import AuditResult
        result = AuditResult(scanned_packages=50, vulnerabilities=[])
        summary = result.summary()
        assert "Clean" in summary or "clean" in summary.lower()
        assert "50" in summary

    def test_audit_result_summary_with_vulns(self):
        from ares.security.audit import AuditResult, CVSSScore, Vulnerability
        result = AuditResult(
            scanned_packages=10,
            vulnerabilities=[
                Vulnerability("cryptography", "1.0", "CVE-2024-0001",
                               "Padding oracle", CVSSScore.CRITICAL, "3.0"),
            ]
        )
        summary = result.summary()
        assert "critical" in summary.lower() or "1" in summary

    @pytest.mark.asyncio
    async def test_run_audit_when_tool_missing(self):
        from ares.security.audit import run_dependency_audit
        with patch("shutil.which", return_value=None):
            result = await run_dependency_audit()
        assert not result["tool_available"]
        assert "pip-audit" in result["error"].lower()

    def test_parse_pip_audit_output(self):
        from ares.security.audit import _parse_pip_audit_output
        raw = {
            "dependencies": [
                {
                    "name": "cryptography",
                    "version": "3.4.8",
                    "vulns": [
                        {
                            "id": "GHSA-xxxx-yyyy-zzzz",
                            "description": "Padding oracle attack",
                            "fix_versions": ["41.0.0"],
                            "aliases": ["CVE-2023-49083"],
                        }
                    ]
                },
                {
                    "name": "requests",
                    "version": "2.28.0",
                    "vulns": []
                }
            ]
        }
        result = _parse_pip_audit_output(raw)
        assert result.scanned_packages == 2
        assert len(result.vulnerabilities) == 1
        assert result.vulnerabilities[0].package == "cryptography"
        assert "CVE-2023-49083" in result.vulnerabilities[0].aliases

    def test_audit_policy_enum(self):
        from ares.security.audit import AuditPolicy
        assert AuditPolicy.WARN.value           == "warn"
        assert AuditPolicy.BLOCK_CRITICAL.value == "block_critical"
        assert AuditPolicy.BLOCK_ANY.value      == "block_any"

    @pytest.mark.asyncio
    async def test_startup_audit_warn_continues(self):
        from ares.security.audit import (
            AuditPolicy,
            AuditResult,
            CVSSScore,
            Vulnerability,
            startup_audit,
        )
        mock_result = AuditResult(
            scanned_packages=10,
            vulnerabilities=[
                Vulnerability("pkg", "1.0", "CVE-x", "desc", CVSSScore.HIGH, "2.0")
            ]
        )
        with patch("ares.security.audit._run_pip_audit", return_value=mock_result):
            # WARN policy should not raise even with vulnerabilities
            await startup_audit(policy=AuditPolicy.WARN)

    @pytest.mark.asyncio
    async def test_startup_audit_block_critical_raises(self):
        from ares.security.audit import (
            AuditPolicy,
            AuditResult,
            CVSSScore,
            Vulnerability,
            startup_audit,
        )
        mock_result = AuditResult(
            scanned_packages=5,
            vulnerabilities=[
                Vulnerability("pkg", "1.0", "CVE-x", "desc", CVSSScore.CRITICAL, "2.0")
            ]
        )
        with patch("ares.security.audit._run_pip_audit", return_value=mock_result):
            with pytest.raises(RuntimeError) as exc_info:
                await startup_audit(policy=AuditPolicy.BLOCK_CRITICAL)
            assert "CRITICAL" in str(exc_info.value)


# ═══════════════════════════════════════════════════════════════════════════════
# 5. Campaign Graph
# ═══════════════════════════════════════════════════════════════════════════════

class TestCampaignGraph:

    def _make_mock_campaign(self):
        """Build a mock campaign with hosts, findings, credentials."""
        campaign = MagicMock()
        campaign.id   = "graph-test-001"
        campaign.name = "Graph Test"

        # Mock session with hosts
        host1 = MagicMock()
        host1.compromise_level = MagicMock(value="domain_admin")
        host1.is_dc     = True
        host1.hostname  = "dc01"
        host1.is_owned  = True
        host1.open_ports = [389, 445, 88]
        host1.os_info   = "Windows Server 2019"
        host1.attack_history = []
        host1.discovered_from = None

        host2 = MagicMock()
        host2.compromise_level = MagicMock(value="local_admin")
        host2.is_dc     = False
        host2.hostname  = "srv01"
        host2.is_owned  = True
        host2.open_ports = [445, 5985]
        host2.os_info   = "Windows Server 2022"
        host2.attack_history = []
        host2.discovered_from = "10.0.0.1"

        session = MagicMock()
        session.hosts = {
            "10.0.0.1": host1,
            "10.0.0.2": host2,
        }
        session.get_host = lambda ip: session.hosts.get(ip)
        campaign.session = session

        # Mock findings
        finding1 = MagicMock()
        finding1.id              = "abc123"
        finding1.title           = "Kerberoastable SPN"
        finding1.severity        = MagicMock(value="high")
        finding1.host            = "10.0.0.1"
        finding1.mitre_technique = "T1558.003"
        finding1.mitre_tactic    = "Credential Access"
        finding1.module_id       = "ad.kerberoast"
        finding1.description     = "svc_sql is kerberoastable"

        finding2 = MagicMock()
        finding2.id              = "def456"
        finding2.title           = "DCSync Successful"
        finding2.severity        = MagicMock(value="critical")
        finding2.host            = "10.0.0.1"
        finding2.mitre_technique = "T1003.006"
        finding2.mitre_tactic    = "Credential Access"
        finding2.module_id       = "ad.dcsync"
        finding2.description     = "DCSync all hashes"

        campaign.findings = [finding1, finding2]
        campaign.vault    = None  # no vault for simplicity
        return campaign

    def test_graph_builds_without_error(self):
        from ares.api.graph import build_campaign_graph
        campaign = self._make_mock_campaign()
        graph = build_campaign_graph(campaign)
        assert "nodes" in graph
        assert "edges" in graph
        assert "stats" in graph

    def test_graph_has_host_nodes(self):
        from ares.api.graph import build_campaign_graph
        campaign = self._make_mock_campaign()
        graph    = build_campaign_graph(campaign)
        host_nodes = [n for n in graph["nodes"] if n["type"] in ("host", "dc")]
        assert len(host_nodes) == 2

    def test_graph_dc_node_has_diamond_shape(self):
        from ares.api.graph import build_campaign_graph
        campaign = self._make_mock_campaign()
        graph    = build_campaign_graph(campaign)
        dc_nodes = [n for n in graph["nodes"] if n["type"] == "dc"]
        assert len(dc_nodes) == 1
        assert dc_nodes[0]["style"]["shape"] == "diamond"

    def test_graph_has_finding_nodes(self):
        from ares.api.graph import build_campaign_graph
        campaign = self._make_mock_campaign()
        graph    = build_campaign_graph(campaign)
        finding_nodes = [n for n in graph["nodes"] if n["type"] == "finding"]
        assert len(finding_nodes) == 2

    def test_graph_critical_finding_uses_red(self):
        from ares.api.graph import build_campaign_graph
        campaign = self._make_mock_campaign()
        graph    = build_campaign_graph(campaign)
        crit = [n for n in graph["nodes"]
                if n["type"] == "finding" and n["data"]["severity"] == "critical"]
        assert len(crit) == 1
        assert crit[0]["style"]["color"] == "#dc3545"   # red

    def test_graph_stats_correct(self):
        from ares.api.graph import build_campaign_graph
        campaign = self._make_mock_campaign()
        graph    = build_campaign_graph(campaign)
        stats    = graph["stats"]
        assert stats["hosts"]    == 2
        assert stats["findings"] == 2
        assert stats["owned_hosts"] == 2
        assert stats["crit_findings"] == 1

    def test_graph_has_legend(self):
        from ares.api.graph import build_campaign_graph
        campaign = self._make_mock_campaign()
        graph    = build_campaign_graph(campaign)
        assert "legend" in graph
        assert "node_types" in graph["legend"]
        assert "edge_types" in graph["legend"]
        assert "colors"     in graph["legend"]

    def test_graph_layout_hint_small(self):
        from ares.api.graph import build_campaign_graph
        campaign = self._make_mock_campaign()
        graph    = build_campaign_graph(campaign)
        # Small graph (< 20 nodes) → hierarchical
        assert graph["layout_hint"] == "hierarchical"

    def test_graph_node_ids_unique(self):
        from ares.api.graph import build_campaign_graph
        campaign = self._make_mock_campaign()
        graph    = build_campaign_graph(campaign)
        node_ids = [n["id"] for n in graph["nodes"]]
        assert len(node_ids) == len(set(node_ids))

    def test_graph_empty_campaign(self):
        """Graph builder should not crash on empty campaign."""
        from ares.api.graph import build_campaign_graph
        campaign = MagicMock()
        campaign.id       = "empty"
        campaign.name     = "Empty"
        campaign.session  = None
        campaign.findings = []
        campaign.vault    = None
        graph = build_campaign_graph(campaign)
        assert graph["stats"]["total_nodes"] == 0
        assert graph["stats"]["total_edges"] == 0


# ═══════════════════════════════════════════════════════════════════════════════
# 6. Subprocess Worker - Capability Limits
# ═══════════════════════════════════════════════════════════════════════════════

class TestSubprocessWorkerCapabilities:

    def test_apply_capability_limits_no_crash(self):
        """apply_capability_limits should not raise on valid inputs."""
        from contextlib import nullcontext

        from ares.worker import _subprocess_worker as worker

        limiter = (
            patch.object(worker._resource, "setrlimit")
            if worker._HAS_RESOURCE
            else nullcontext()
        )

        # Should silently succeed (or silently fail on unsupported platforms)
        with limiter as setrlimit:
            worker.apply_capability_limits(
                {"cap_net", "cap_db"},
                {"cpu_time_s": 30, "memory_mb": 256, "max_procs": 1, "max_files": 32}
            )
        if worker._HAS_RESOURCE:
            assert setrlimit.called

    def test_apply_capability_limits_empty_caps(self):
        """Empty caps should apply conservative defaults."""
        from contextlib import nullcontext

        from ares.worker import _subprocess_worker as worker

        limiter = (
            patch.object(worker._resource, "setrlimit")
            if worker._HAS_RESOURCE
            else nullcontext()
        )

        with limiter as setrlimit:
            worker.apply_capability_limits(set(), {})
        if worker._HAS_RESOURCE:
            assert setrlimit.called

    def test_capability_boundary_no_violation(self):
        """Boundary check should pass when caps are respected."""
        from ares.worker._subprocess_worker import check_capability_boundary
        # No violation expected for normal caps
        # (sys.modules won't have subprocess before module loads in test)
        check_capability_boundary("ad.kerberoast", {"cap_net", "cap_db"})

    def test_capability_boundary_unsafe_bypasses(self):
        """CAP_UNSAFE modules bypass boundary check."""
        from ares.worker._subprocess_worker import check_capability_boundary
        # Should not raise even with forbidden modules loaded
        check_capability_boundary("ares.core.dcsync", {"cap_unsafe"})


# ═══════════════════════════════════════════════════════════════════════════════
# 7. Plugin Loader Security
# ═══════════════════════════════════════════════════════════════════════════════

class TestPluginLoaderSecurity:

    def test_capability_enforcement_called_on_external_load(self, tmp_path):
        """Loader should reject external modules with forbidden caps."""
        from ares.core.capabilities import Capability, CapabilityPolicy

        # Module that tries to declare CAP_EXEC (forbidden for external)
        violations = CapabilityPolicy.validate(
            "external.bad_module",
            {Capability.CAP_NET, Capability.CAP_EXEC},
            "external",
        )
        assert len(violations) > 0
        assert "cap_exec" in violations[0].lower()

    def test_default_caps_assigned_when_missing(self):
        """Loader assigns sensible default caps when CAPABILITIES not declared."""
        from ares.core.capabilities import Capability, default_capabilities_for_category
        ad_caps = default_capabilities_for_category("ad")
        assert Capability.CAP_NET in ad_caps
        assert Capability.CAP_DB  in ad_caps

    def test_signing_policy_env_var_read(self):
        """Signing policy is configurable via environment variable."""
        import os
        from unittest.mock import patch
        with patch.dict(os.environ, {"ARES_PLUGIN_SIGNING_POLICY": "require_signed"}):
            # Re-import to test env var reading
            import ares.core.plugin.loader as loader_module
            policy = loader_module._SIGNING_POLICY  # noqa: F841
            # Note: module-level var is set at import time,
            # but we can test the env var is read
            assert "ARES_PLUGIN_SIGNING_POLICY" in os.environ


# ── CapabilityGraph circular dependency tests (Fix #9) ────────────────────────

class TestCapabilityGraphCircularDeps:
    """
    Verify CapabilityGraph.resolve_chain() handles circular dependencies safely.

    Edge cases:
      - A outputs X, B requires X and outputs Y, A requires Y → mutual dependency
      - Self-dependency: A outputs X and requires X
      - Long chain: A→B→C→D→back to A
    """

    @staticmethod
    def _run_with_timeout(fn, timeout_s: float, message: str):
        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
            future = pool.submit(fn)
            try:
                return future.result(timeout=timeout_s)
            except concurrent.futures.TimeoutError as exc:
                raise AssertionError(message) from exc

    def _make_registry_stub(self, modules: list[dict]):
        """Build a minimal registry stub from a list of {id, requires, outputs} dicts."""

        class ModuleStub:
            pass

        stubs = []
        for m in modules:
            stub = type(m["id"].replace(".", "_"), (), {
                "MODULE_ID": m["id"],
                "REQUIRES":  m.get("requires", []),
                "OUTPUTS":   m.get("outputs", []),
            })
            stubs.append(stub)

        class FakeRegistry:
            def all(self):
                return stubs

        return FakeRegistry()

    def test_resolve_chain_basic_linear(self):
        """A→B→C linear chain resolves in dependency order."""
        from ares.goal.engine import CapabilityGraph
        reg = self._make_registry_stub([
            {"id": "mod.a", "requires": [],          "outputs": ["cap_x"]},
            {"id": "mod.b", "requires": ["cap_x"],   "outputs": ["cap_y"]},
            {"id": "mod.c", "requires": ["cap_y"],   "outputs": ["cap_z"]},
        ])
        cg = CapabilityGraph.from_registry(reg)
        chain = cg.resolve_chain(["cap_z"])

        # mod.a must appear before mod.b, mod.b before mod.c
        assert "mod.a" in chain
        assert "mod.b" in chain
        assert "mod.c" in chain
        assert chain.index("mod.a") < chain.index("mod.b")
        assert chain.index("mod.b") < chain.index("mod.c")

    def test_resolve_chain_no_cycle_detection_visited_set(self):
        """
        Mutual dependency (A outputs X, B requires X and outputs Y, A requires Y).
        visited set prevents infinite recursion — chain terminates within max_depth.
        """
        from ares.goal.engine import CapabilityGraph
        reg = self._make_registry_stub([
            {"id": "mod.a", "requires": ["cap_y"], "outputs": ["cap_x"]},
            {"id": "mod.b", "requires": ["cap_x"], "outputs": ["cap_y"]},
        ])
        cg = CapabilityGraph.from_registry(reg)

        chain = self._run_with_timeout(
            lambda: cg.resolve_chain(["cap_x", "cap_y"]),
            3,
            "resolve_chain() timed out",
        )

        # Result is a finite list — no duplicates
        assert isinstance(chain, list)
        assert len(chain) == len(set(chain)), "Duplicates in resolved chain"

    def test_resolve_chain_self_dependency(self):
        """Module that outputs what it requires; visited set prevents a loop."""
        from ares.goal.engine import CapabilityGraph
        reg = self._make_registry_stub([
            {"id": "mod.self", "requires": ["cap_x"], "outputs": ["cap_x"]},
        ])
        cg = CapabilityGraph.from_registry(reg)

        chain = self._run_with_timeout(
            lambda: cg.resolve_chain(["cap_x"]),
            3,
            "Self-dep resolve timed out",
        )

        assert isinstance(chain, list)
        assert len(chain) == len(set(chain))

    def test_resolve_chain_long_cycle_terminates(self):
        """4-module cycle terminates due to max_depth + visited."""
        from ares.goal.engine import CapabilityGraph
        reg = self._make_registry_stub([
            {"id": "mod.a", "requires": ["cap_d"], "outputs": ["cap_a"]},
            {"id": "mod.b", "requires": ["cap_a"], "outputs": ["cap_b"]},
            {"id": "mod.c", "requires": ["cap_b"], "outputs": ["cap_c"]},
            {"id": "mod.d", "requires": ["cap_c"], "outputs": ["cap_d"]},
        ])
        cg = CapabilityGraph.from_registry(reg)

        chain = self._run_with_timeout(
            lambda: cg.resolve_chain(["cap_d"]),
            3,
            "Long-cycle resolve timed out",
        )

        assert isinstance(chain, list)
        assert len(chain) == len(set(chain)), "No duplicates allowed"


    def test_resolve_chain_available_modules_filter(self):
        """available_modules filter restricts resolution to a subset."""
        from ares.goal.engine import CapabilityGraph
        reg = self._make_registry_stub([
            {"id": "mod.a", "requires": [],          "outputs": ["cap_x"]},
            {"id": "mod.b", "requires": ["cap_x"],   "outputs": ["cap_y"]},
            {"id": "mod.c", "requires": ["cap_x"],   "outputs": ["cap_z"]},
        ])
        cg = CapabilityGraph.from_registry(reg)

        # Only allow mod.a and mod.c — mod.b filtered out
        chain = cg.resolve_chain(["cap_y", "cap_z"],
                                   available_modules=["mod.a", "mod.c"])
        assert "mod.b" not in chain
        assert "mod.c" in chain or "mod.a" in chain

    def test_resolve_chain_empty_goal(self):
        """Empty goal_required_outputs returns empty chain gracefully."""
        from ares.goal.engine import CapabilityGraph
        reg = self._make_registry_stub([
            {"id": "mod.a", "requires": [], "outputs": ["cap_x"]},
        ])
        cg = CapabilityGraph.from_registry(reg)
        chain = cg.resolve_chain([])
        assert chain == []

    def test_resolve_chain_unknown_capability(self):
        """Requesting a capability no module produces returns empty chain."""
        from ares.goal.engine import CapabilityGraph
        reg = self._make_registry_stub([
            {"id": "mod.a", "requires": [], "outputs": ["cap_x"]},
        ])
        cg = CapabilityGraph.from_registry(reg)
        chain = cg.resolve_chain(["cap_does_not_exist"])
        assert chain == []

    def test_capability_summary_structure(self):
        """capability_summary() returns correct structure and counts."""
        from ares.goal.engine import CapabilityGraph
        reg = self._make_registry_stub([
            {"id": "mod.a", "requires": [],        "outputs": ["cap_x", "cap_y"]},
            {"id": "mod.b", "requires": ["cap_x"], "outputs": ["cap_z"]},
        ])
        cg = CapabilityGraph.from_registry(reg)
        summary = cg.capability_summary()

        assert summary["total_capabilities"] == 3   # cap_x, cap_y, cap_z
        assert summary["total_modules"] == 2
        assert "cap_x" in summary["capabilities"]
        assert "mod.a" in summary["capabilities"]["cap_x"]

    def test_producers_for_returns_correct_modules(self):
        """producers_for() returns all modules that output a given capability."""
        from ares.goal.engine import CapabilityGraph
        reg = self._make_registry_stub([
            {"id": "mod.a", "requires": [], "outputs": ["cap_x"]},
            {"id": "mod.b", "requires": [], "outputs": ["cap_x", "cap_y"]},
            {"id": "mod.c", "requires": [], "outputs": ["cap_y"]},
        ])
        cg = CapabilityGraph.from_registry(reg)

        producers_x = cg.producers_for("cap_x")
        assert set(producers_x) == {"mod.a", "mod.b"}

        producers_y = cg.producers_for("cap_y")
        assert set(producers_y) == {"mod.b", "mod.c"}

        producers_z = cg.producers_for("cap_nonexistent")
        assert producers_z == []