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.

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.py
index 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_val
def _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] = True
return 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_scope
return 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_ip
else:
@@ -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.asynccontextmanager
async 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 fw
finally:
_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 fw
finally:
_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.py
index 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.py
index 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.py
new file mode 100644
index 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 True
diff --git a/tests/unit/test_hardening.py b/tests/unit/test_hardening.py
index 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_dir
assert 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.py
index 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 None
mock_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)
+