ARES - authorized red-team engagement automation with dashboard, campaign scope, module orchestration, OPSEC controls, encrypted vault, and reporting.
Python active-directorycloud-securitydefensive-validationfastapigood-first-issuemitre-attackopsecreactred-teamreportingsecurity
fix(security): harden scope firewall against IPv6/proxy escapes, enforce dynamic module destination admission, and add admission invariants
Mafifrizi6b4de8545ecb
diff --git a/ares/core/scope_firewall.py b/ares/core/scope_firewall.pyindex 4d18bd2..76c37f1 100644--- a/ares/core/scope_firewall.py+++ b/ares/core/scope_firewall.py@@ -140,7 +140,32 @@ class ScopeFirewall:if isinstance(host, bytes):host = host.decode("utf-8", errors="ignore")- return str(host).strip(), port+ host_str = str(host).strip()+ port_val = port++ # Handle string forms such as "[::1]:8080" or "10.0.0.1:445"+ if port_val is None and ":" in host_str:+ if host_str.startswith("[") and "]" in host_str:+ parts = host_str.split("]")+ host_str = parts[0][1:]+ after = parts[1]+ if after.startswith(":") and after[1:].isdigit():+ port_val = int(after[1:])+ elif host_str.count(":") == 1:+ h, p = host_str.split(":")+ if p.isdigit():+ host_str = h+ port_val = int(p)++ # Strip remaining bracketed IPv6 syntax: "[::1]" -> "::1"+ if host_str.startswith("[") and host_str.endswith("]"):+ host_str = host_str[1:-1]++ # Strip zone identifier: "fe80::1%eth0" -> "fe80::1"+ if "%" in host_str:+ host_str = host_str.split("%")[0]++ return host_str.strip(), port_valdef _is_cloud_allowed(self, host: str) -> bool:"""Verify if host matches trusted cloud endpoints for cloud modules."""@@ -169,14 +194,19 @@ class ScopeFirewall:if self._is_cloud_allowed(lowered_host):return True, address- # 3. Check if host is an IP literal+ # 3. Check if host is an IP literal (including IPv4, IPv6, and IPv4-mapped IPv6)try:addr = ipaddress.ip_address(lowered_host)- if self.allow_loopback_ipc and addr.is_loopback:+ effective_addr = getattr(addr, "ipv4_mapped", None) or addr+ if self.allow_loopback_ipc and (addr.is_loopback or effective_addr.is_loopback):self._ip_cache[lowered_host] = Truereturn True, address- in_scope = any(addr in net for net in self._networks)+ in_scope = any(+ (effective_addr in net if effective_addr.version == net.version else False)+ or (addr in net if addr.version == net.version else False)+ for net in self._networks+ )if len(self._ip_cache) < 1024:self._ip_cache[lowered_host] = in_scopereturn in_scope, address@@ -217,7 +247,13 @@ class ScopeFirewall:raw_ip = res[4][0]try:ip_obj = ipaddress.ip_address(raw_ip)- if any(ip_obj in net for net in self._networks):+ effective_ip = getattr(ip_obj, "ipv4_mapped", None) or ip_obj+ in_scope = any(+ (effective_ip in net if effective_ip.version == net.version else False)+ or (ip_obj in net if ip_obj.version == net.version else False)+ for net in self._networks+ )+ if in_scope:if pinned_ip is None:pinned_ip = raw_ipelse:@@ -604,6 +640,16 @@ def get_os_firewall_status() -> dict[str, Any]:# ── Context Managers ─────────────────────────────────────────────────────────+_PROXY_KEYS: tuple[str, ...] = (+ "HTTP_PROXY",+ "HTTPS_PROXY",+ "ALL_PROXY",+ "http_proxy",+ "https_proxy",+ "all_proxy",+)++@contextlib.asynccontextmanagerasync def scope_firewall_guard(campaign: Campaign | None,@@ -642,12 +688,16 @@ async def scope_firewall_guard(if enable_os_firewall:os_rules = OSFirewallController.apply_rules(campaign, fw.scope_cidrs)+ # Neutralize proxy environment variables that could route traffic out-of-scope+ saved_proxies = {k: os.environ.pop(k) for k in _PROXY_KEYS if k in os.environ}+try:yield fwfinally:_current_firewall.reset(token)if os_rules:OSFirewallController.remove_rules(os_rules)+ os.environ.update(saved_proxies)@contextlib.contextmanager@@ -688,9 +738,13 @@ def scope_firewall_sync_guard(if enable_os_firewall:os_rules = OSFirewallController.apply_rules(campaign, fw.scope_cidrs)+ # Neutralize proxy environment variables that could route traffic out-of-scope+ saved_proxies = {k: os.environ.pop(k) for k in _PROXY_KEYS if k in os.environ}+try:yield fwfinally:_current_firewall.reset(token)if os_rules:OSFirewallController.remove_rules(os_rules)+ os.environ.update(saved_proxies)diff --git a/ares/db/execution_lifecycle.py b/ares/db/execution_lifecycle.pyindex 32a069c..6fb30e0 100644--- a/ares/db/execution_lifecycle.py+++ b/ares/db/execution_lifecycle.py@@ -3610,7 +3610,22 @@ class ExecutionLifecycleStore:else:# Dynamic / plugin modules without formal Phase 5C descriptor (e.g. RFC-001 modules)values = {key: intent.raw_parameters[key] for key in sorted(intent.raw_parameters)}- destination_refs = ()+ extracted_dest_list: list[tuple[str, str]] = []+ for d_key in ("target", "targets", "host", "hosts", "rhost", "rhosts", "dc", "server"):+ if d_key in intent.raw_parameters:+ v = intent.raw_parameters[d_key]+ if isinstance(v, (list, tuple)):+ for item in v:+ if isinstance(item, str) and item.strip():+ extracted_dest_list.append(("host", item.strip().lower()))+ elif isinstance(v, str) and v.strip():+ extracted_dest_list.append(("host", v.strip().lower()))+ for d_key in ("domain", "realm"):+ if d_key in intent.raw_parameters:+ v = intent.raw_parameters[d_key]+ if isinstance(v, str) and v.strip():+ extracted_dest_list.append(("domain", v.strip().lower()))+ destination_refs = tuple(sorted(set(extracted_dest_list)))canonical_json = json.dumps(values,sort_keys=True,diff --git a/ares/marketplace/installer.py b/ares/marketplace/installer.pyindex 9ef33b8..f0fffc8 100644--- a/ares/marketplace/installer.py+++ b/ares/marketplace/installer.py@@ -627,9 +627,24 @@ class ModuleInstaller:def _install_single_file(self, file_path: Path, source_url: str, force: bool) -> ModuleManifest:manifest = self._infer_manifest_from_file(file_path, source_url)- dest_dir = PLUGINS_DIR / manifest.id.replace(".", "_")+ # Prevent path traversal in manifest.id and file_path.name+ if any(sep in manifest.id for sep in ("/", "\\", "..")):+ raise ValueError(f"Invalid or unsafe module ID: {manifest.id!r}")+ safe_id = manifest.id.replace(".", "_").strip()+ if not safe_id:+ raise ValueError(f"Invalid or empty module ID: {manifest.id!r}")+ dest_dir = (PLUGINS_DIR / safe_id).resolve()+ plugins_base = PLUGINS_DIR.resolve()+ if not (dest_dir == plugins_base or dest_dir.is_relative_to(plugins_base)):+ raise ValueError(f"Path traversal detected in module destination: {manifest.id!r}")+dest_dir.mkdir(parents=True, exist_ok=True)- shutil.copy2(file_path, dest_dir / file_path.name)+ safe_filename = Path(file_path.name).name+ dest_file = (dest_dir / safe_filename).resolve()+ if not (dest_file == dest_dir or dest_file.is_relative_to(dest_dir)):+ raise ValueError(f"Path traversal detected in module filename: {file_path.name!r}")++ shutil.copy2(file_path, dest_file)return self._finalize_install(dest_dir, manifest, force)def _finalize_install(self, plugin_dir: Path, manifest: ModuleManifest, force: bool) -> ModuleManifest:diff --git a/tests/unit/test_execution_admission_invariants.py b/tests/unit/test_execution_admission_invariants.pynew file mode 100644index 0000000..4b1480b--- /dev/null+++ b/tests/unit/test_execution_admission_invariants.py@@ -0,0 +1,179 @@+"""Adversarial tests for ARES C-LIVE Execution Admission Invariants.++Verifies:+1. Single-consumer binding (cannot be consumed by wrong engine/consumer).+2. Replay prevention (cannot be consumed more than once).+3. Non-serializability (cannot be pickled or transplanted across processes).+4. Campaign binding (cannot be executed under an unauthorized campaign).+5. Module binding (cannot execute a module different from admitted).+6. Sealed capability integrity (tampered context or forged signature rejected).+7. Issuer authenticity (cannot instantiate context without coordinator issuer seal).+"""+from __future__ import annotations++import pickle++import pytest++from ares.core.engine import AresEngine+from ares.core.execution_admission import (+ AdmittedDispatchContextV1,+ _mint_test_dispatch_context,+ consume_dispatch_context,+ mark_effect_started,+)+++class TestExecutionAdmissionInvariants:+ """Rigorous invariant verification for AdmittedDispatchContextV1."""++ def test_admission_context_belongs_to_intended_consumer(self):+ engine_a = AresEngine()+ engine_b = AresEngine()+ campaign_id = "11111111-1111-4111-8111-111111111111"+ module_id = "test.dummy"++ ctx = _mint_test_dispatch_context(+ consumer=engine_a,+ campaign_id=campaign_id,+ module_id=module_id,+ )++ # Consuming with wrong consumer must fail-closed+ with pytest.raises(+ PermissionError, match="stale, transferred, fabricated, or already used"+ ):+ consume_dispatch_context(+ ctx,+ consumer=engine_b,+ campaign_id=campaign_id,+ module_id=module_id,+ )++ def test_admission_context_replay_prevention(self):+ engine = AresEngine()+ campaign_id = "22222222-2222-4222-8222-222222222222"+ module_id = "test.replay"++ ctx = _mint_test_dispatch_context(+ consumer=engine,+ campaign_id=campaign_id,+ module_id=module_id,+ )++ # First consumption must succeed+ consumed = consume_dispatch_context(+ ctx,+ consumer=engine,+ campaign_id=campaign_id,+ module_id=module_id,+ )+ assert consumed._consumed is True++ # Second consumption (replay attack) must fail-closed+ with pytest.raises(+ PermissionError, match="stale, transferred, fabricated, or already used"+ ):+ consume_dispatch_context(+ ctx,+ consumer=engine,+ campaign_id=campaign_id,+ module_id=module_id,+ )++ def test_admission_context_serialization_forbidden(self):+ engine = AresEngine()+ campaign_id = "33333333-3333-4333-8333-333333333333"+ module_id = "test.transplant"++ ctx = _mint_test_dispatch_context(+ consumer=engine,+ campaign_id=campaign_id,+ module_id=module_id,+ )++ with pytest.raises(TypeError, match="dispatch contexts are not serializable"):+ pickle.dumps(ctx)++ def test_admission_context_campaign_mismatch(self):+ engine = AresEngine()+ campaign_id = "44444444-4444-4444-8444-444444444444"+ module_id = "test.campaign_isolation"++ ctx = _mint_test_dispatch_context(+ consumer=engine,+ campaign_id=campaign_id,+ module_id=module_id,+ )++ with pytest.raises(+ PermissionError, match="stale, transferred, fabricated, or already used"+ ):+ consume_dispatch_context(+ ctx,+ consumer=engine,+ campaign_id="99999999-9999-4999-8999-999999999999",+ module_id=module_id,+ )++ def test_admission_context_module_mismatch(self):+ engine = AresEngine()+ campaign_id = "55555555-5555-4555-8555-555555555555"+ module_id = "test.legitimate_module"++ ctx = _mint_test_dispatch_context(+ consumer=engine,+ campaign_id=campaign_id,+ module_id=module_id,+ )++ with pytest.raises(+ PermissionError, match="stale, transferred, fabricated, or already used"+ ):+ consume_dispatch_context(+ ctx,+ consumer=engine,+ campaign_id=campaign_id,+ module_id="test.unauthorized_module",+ )++ def test_admission_context_unauthorized_direct_instantiation_rejected(self):+ with pytest.raises(TypeError, match="dispatch contexts are coordinator-created only"):+ AdmittedDispatchContextV1(+ campaign_id="66666666-6666-4666-8666-666666666666",+ submission_id="77777777-7777-4777-8777-777777777777",+ logical_execution_id="88888888-8888-4888-8888-888888888888",+ attempt_id="99999999-9999-4999-8999-999999999999",+ module_id="test.fake",+ attempt_revision=3,+ consumer=object(),+ store=object(),+ _issuer=object(), # Fake issuer+ )++ def test_mark_effect_started_requires_consumed_context(self):+ engine = AresEngine()+ campaign_id = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa"+ module_id = "test.effect"++ ctx = _mint_test_dispatch_context(+ consumer=engine,+ campaign_id=campaign_id,+ module_id=module_id,+ )++ # Before consume: cannot mark effect started+ with pytest.raises(+ PermissionError, match="effect boundary requires a consumed dispatch context"+ ):+ mark_effect_started(ctx)++ # After consume: effect started succeeds+ consumed = consume_dispatch_context(+ ctx,+ consumer=engine,+ campaign_id=campaign_id,+ module_id=module_id,+ )+ mark_effect_started(consumed)+ assert consumed._effect_started is Truediff --git a/tests/unit/test_hardening.py b/tests/unit/test_hardening.pyindex a9aa8cc..43b1797 100644--- a/tests/unit/test_hardening.py+++ b/tests/unit/test_hardening.py@@ -737,3 +737,47 @@ class TestMarketplaceAndCrackerHardening:assert worker_custom.tmpdir == custom_dirassert worker_custom.tmpdir.exists()+ def test_marketplace_path_traversal_rejected(self, tmp_path, monkeypatch):+ """Path traversal in manifest module_id or file path must be rejected."""+ from ares.marketplace.installer import ModuleInstaller, ModuleManifest+ installer = ModuleInstaller()+ fake_file = tmp_path / "test.py"+ fake_file.write_text("print('test')")++ monkeypatch.setattr(+ installer,+ "_infer_manifest_from_file",+ lambda f, url: ModuleManifest(id="../../evil_module"),+ )+ with pytest.raises(ValueError, match="Path traversal detected|Invalid or unsafe module ID"):+ installer._install_single_file(fake_file, source_url="https://example.com/test.py", force=True)++ def test_dynamic_module_destination_extracted_in_lifecycle_admission(self):+ """Lifecycle admission must extract target/host for dynamic modules without static descriptors."""+ import uuid++ from ares.db.execution_lifecycle import AdmissionIntentV3, ExecutionLifecycleStore++ intent = AdmissionIntentV3(+ logical_execution_id=str(uuid.uuid4()),+ submission_id=str(uuid.uuid4()),+ attempt_id=str(uuid.uuid4()),+ outbox_id=None,+ publication_key=None,+ campaign_id=str(uuid.uuid4()),+ module_id="custom.dynamic_scanner",+ ingress_code="direct_engine",+ operation_id=str(uuid.uuid4()),+ evaluation_mode="live",+ raw_parameters={"target": "192.168.1.50", "port": 80, "domain": "corp.local"},+ credential_ids=(),+ approval_ref=None,+ noise_units=1,+ exfiltration_units=0,+ )+ prepared = ExecutionLifecycleStore._prepared_admission(intent)+ assert prepared is not None+ assert ("host", "192.168.1.50") in prepared.destination_refs+ assert ("domain", "corp.local") in prepared.destination_refs++diff --git a/tests/unit/test_scope_firewall.py b/tests/unit/test_scope_firewall.pyindex c28ca72..e7e9a8d 100644--- a/tests/unit/test_scope_firewall.py+++ b/tests/unit/test_scope_firewall.py@@ -368,3 +368,45 @@ class TestOSFirewallController:assert fw is not Nonemock_apply.assert_called_once()mock_remove.assert_called_once_with(["ARES_SCOPE_WALL_test"])++ def test_bracketed_ipv6_and_zone_id_parsing(self, sample_campaign: Campaign):+ fw = ScopeFirewall(campaign=sample_campaign, module_id="test.ipv6", allow_loopback_ipc=True)+ # Bracketed loopback+ assert fw.is_allowed_address("[::1]") is True+ assert fw.is_allowed_address(("[::1]", 8080)) is True+ assert fw.is_allowed_address("[::1]:8080") is True++ # Zone index stripping+ assert fw.is_allowed_address("[::1%eth0]:9000") is True++ # Bracketed out-of-scope IPv6+ assert fw.is_allowed_address("[2001:db8::1]") is False+ assert fw.is_allowed_address(("[2001:db8::1]", 443)) is False++ def test_ipv4_mapped_ipv6_scope_enforcement(self, sample_campaign: Campaign):+ fw = ScopeFirewall(campaign=sample_campaign, module_id="test.ipv4_mapped")+ # In-scope: 10.0.0.5 is in 10.0.0.0/24+ assert fw.is_allowed_address("::ffff:10.0.0.5") is True+ assert fw.is_allowed_address(("::ffff:10.0.0.5", 445)) is True++ # Out-of-scope: 8.8.8.8 is outside 10.0.0.0/24 and 192.168.1.0/24+ assert fw.is_allowed_address("::ffff:8.8.8.8") is False+ assert fw.is_allowed_address(("::ffff:8.8.8.8", 53)) is False++ def test_proxy_environment_variables_neutralized_during_guard(self, sample_campaign: Campaign):+ import os+ os.environ["HTTP_PROXY"] = "http://127.0.0.1:8080"+ os.environ["HTTPS_PROXY"] = "http://127.0.0.1:8443"+ try:+ with scope_firewall_sync_guard(sample_campaign) as fw:+ assert fw is not None+ # Proxies must be stripped while guard is active+ assert "HTTP_PROXY" not in os.environ+ assert "HTTPS_PROXY" not in os.environ+ # Proxies must be safely restored upon exit+ assert os.environ.get("HTTP_PROXY") == "http://127.0.0.1:8080"+ assert os.environ.get("HTTPS_PROXY") == "http://127.0.0.1:8443"+ finally:+ os.environ.pop("HTTP_PROXY", None)+ os.environ.pop("HTTPS_PROXY", None)+