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): disable windows.token_impersonation - heuristic over-claiming, false CRITICAL risk (MOD-030)

Mafifrizi2ca5ea359317
diff --git a/ares/modules/windows/token_impersonation.py b/ares/modules/windows/token_impersonation.py
index a8243d6..65d4b07 100644
--- a/ares/modules/windows/token_impersonation.py
+++ b/ares/modules/windows/token_impersonation.py
@@ -60,76 +60,35 @@ class TokenImpersonationModule(BaseModule):
OUTPUTS = ["privesc_vectors"]
MITRE_TECHNIQUES = ["T1134.001", "T1134.002"]
PARAMS_MODEL = TokenImpersonationParams
+ ENABLED = False
+ DISABLED_REASON = "module disabled: privilege check heuristic insufficient, named pipe != exploitation confirmed (MOD-030)"
async def assess_feasibility(self, ctx: "Any") -> "FeasibilityReport":
- """
- Pre-flight Defense Feasibility Assessment:
- Evaluates SeImpersonatePrivilege conditions and Potato-family attack feasibility.
- """
+ """Pre-flight Defense Feasibility Assessment: Disabled under MOD-030."""
from ares.modules.base import FeasibilityReport
-
- blockers: list[str] = []
- recommendations: list[str] = []
- opsec_tuning: dict[str, Any] = {}
- score = 1.0
- risk = "medium"
-
- target = sanitize_hostname(getattr(ctx, "target", "") or getattr(ctx, "params", {}).get("target", ""))
- if not target:
- blockers.append("No target host specified")
- score -= 0.5
-
- session = getattr(ctx, "session", None)
- if session and hasattr(session, "get_host") and target:
- host_state = session.get_host(target)
- if host_state:
- if host_state.has_defense("edr"):
- risk = "high_noise"
- score -= 0.2
- opsec_tuning["suggested_variant"] = "GodPotato / PrintSpoofer"
- opsec_tuning["note"] = "EDR detected on host; classic JuicyPotato DCOM reflection is signatured. Use PrintSpoofer or GodPotato."
-
- feasible = len(blockers) == 0 and score >= 0.4
return FeasibilityReport(
- feasible=feasible,
- score=max(0.0, min(1.0, score)),
- risk_level=risk,
- blockers=blockers,
- recommended_alternatives=recommendations,
- opsec_tuning=opsec_tuning,
- details={"target": target},
+ feasible=False,
+ score=0.0,
+ risk_level="high_noise",
+ blockers=[self.DISABLED_REASON],
+ recommended_alternatives=["windows.lsass_dump", "windows.lsa_secrets"],
+ details={"disabled": True, "reason": self.DISABLED_REASON},
)
async def validate(self, ctx: "Any") -> None:
- """Pre-flight param checks before any network call."""
- from ares.core.context import ExecutionContext
from ares.core.errors import ModuleValidationError
- if not isinstance(ctx, ExecutionContext):
- return
- if isinstance(ctx.params, dict):
- if not ctx.params.get("target") and getattr(ctx, "target", None):
- ctx.params["target"] = ctx.target
- if not ctx.params.get("domain") and getattr(ctx, "domain", None):
- ctx.params["domain"] = ctx.domain
- if not ctx.params.get("username") and hasattr(ctx, "best_credential"):
- cred = ctx.best_credential()
- if cred and cred.username:
- ctx.params["username"] = cred.username
- target = getattr(ctx, "target", "") or (ctx.params.get("target", "") if isinstance(ctx.params, dict) else getattr(ctx.params, "target", ""))
- if not target:
- raise ModuleValidationError(
- "windows.token_impersonation requires 'target'.",
- module_id=self.MODULE_ID, field="target",
- )
- await super().validate(ctx)
+ raise ModuleValidationError(
+ self.DISABLED_REASON,
+ module_id=self.MODULE_ID,
+ )
async def execute(self, ctx: "Any") -> "ModuleResult":
- """ExecutionContext-based entry point (v0.9.0+).
- Thin adapter: extract params from ctx → call run() → return ModuleResult.
- """
- from ares.modules.base import ModuleResult
- if getattr(ctx, "dry_run", False):
- return ModuleResult(status="dry_run", module_id=self.MODULE_ID, raw={"dry_run": True})
+ """ExecutionContext-based entry point (v0.9.0+): Disabled under MOD-030."""
+ from ares.core.errors import ModuleError
+ raise ModuleError(
+ self.DISABLED_REASON,
+ module_id=self.MODULE_ID,
+ )
target = getattr(ctx, "target", "")
username = ""
password = ""
@@ -232,6 +191,12 @@ class TokenImpersonationModule(BaseModule):
@trace_module("windows.token_impersonation")
async def run(self, **kwargs: Any) -> tuple[list[Finding], dict[str, Any]]:
+ from ares.core.errors import ModuleError
+ raise ModuleError(
+ self.DISABLED_REASON,
+ module_id=self.MODULE_ID,
+ )
+
target = sanitize_hostname(kwargs.get("target", ""))
username = kwargs.get("username", "")
password = kwargs.get("password", "") or kwargs.get("secret", "")
diff --git a/tests/unit/modules/test_safety_remediation.py b/tests/unit/modules/test_safety_remediation.py
index c8c67a4..5e2d85a 100644
--- a/tests/unit/modules/test_safety_remediation.py
+++ b/tests/unit/modules/test_safety_remediation.py
@@ -226,6 +226,13 @@ def test_onprem_modules_rate_limiter_never_calls_cloud_api(mod_path, cls_name, e
"impacket.dcerpc.v5.dcomrt": MagicMock(),
"paramiko": MagicMock(),
}):
+ if getattr(module_cls, "ENABLED", True) is False:
+ with pytest.raises(Exception) as exc_info:
+ asyncio.run(instance.run(**run_kwargs))
+ assert "module disabled" in str(exc_info.value).lower()
+ assert not acquire_mock.called, f"Disabled {cls_name} should not acquire rate limiter"
+ return
+
# Mock inner execution loop or functions
try:
asyncio.run(instance.run(**run_kwargs))
@@ -237,3 +244,4 @@ def test_onprem_modules_rate_limiter_never_calls_cloud_api(mod_path, cls_name, e
assert called_bucket == expected_bucket, f"{cls_name} expected bucket {expected_bucket}, got {called_bucket}"
assert called_bucket != "cloud_api", f"{cls_name} improperly used cloud_api rate limiter bucket!"
+
diff --git a/tests/unit/test_defense_feasibility_matrix.py b/tests/unit/test_defense_feasibility_matrix.py
index 886add4..0cd2f85 100644
--- a/tests/unit/test_defense_feasibility_matrix.py
+++ b/tests/unit/test_defense_feasibility_matrix.py
@@ -250,8 +250,8 @@ class TestTokenImpersonationFeasibility:
session=session,
)
report = await mod.assess_feasibility(ctx)
- assert report.feasible is True
- assert "GodPotato" in report.opsec_tuning.get("suggested_variant", "")
+ assert report.feasible is False
+ assert any("MOD-030" in b for b in report.blockers)
class TestLateralMovementFeasibility:
diff --git a/tests/unit/test_disabled_modules_batch4.py b/tests/unit/test_disabled_modules_batch4.py
index c5c3f42..0144f8b 100644
--- a/tests/unit/test_disabled_modules_batch4.py
+++ b/tests/unit/test_disabled_modules_batch4.py
@@ -20,6 +20,7 @@ from ares.core.errors import ModuleError, ModuleValidationError
from ares.core.noise import NoiseController
from ares.core.plugin.loader import PluginLoader
from ares.modules.windows.dpapi import DPAPIModule
+from ares.modules.windows.token_impersonation import TokenImpersonationModule
def _run(coro):
@@ -102,3 +103,67 @@ class TestDPAPIDisabled:
report = _run(mod.assess_feasibility(ctx))
assert report.feasible is False
assert any("MOD-029" in b for b in report.blockers)
+
+
+class TestTokenImpersonationDisabled:
+ def test_token_impersonation_attributes(self):
+ assert TokenImpersonationModule.MODULE_ID == "windows.token_impersonation"
+ assert TokenImpersonationModule.ENABLED is False
+ assert "MOD-030" in TokenImpersonationModule.DISABLED_REASON
+
+ def test_token_impersonation_registry_exclusion(self):
+ loader = PluginLoader()
+ loader._load_builtin()
+ reg = loader.registry
+
+ assert "windows.token_impersonation" not in [m["id"] for m in reg.list_metadata()]
+ assert "windows.token_impersonation" not in [cls.MODULE_ID for cls in reg.all()]
+ assert "windows.token_impersonation" not in [cls.MODULE_ID for cls in reg.by_category("windows")]
+ assert reg.is_disabled("windows.token_impersonation") is True
+ assert "MOD-030" in (reg.get_disabled_reason("windows.token_impersonation") or "")
+ assert "windows.token_impersonation" not in reg
+
+ def test_token_impersonation_direct_run_raises_explicit_exception(self):
+ mod, _ = _make_module(TokenImpersonationModule)
+ with pytest.raises(ModuleError) as exc_info:
+ _run(mod.run(target="10.0.0.5", username="target_user", password="secret"))
+ assert "module disabled: privilege check heuristic insufficient, named pipe != exploitation confirmed (MOD-030)" in str(exc_info.value)
+ assert len(mod._findings) == 0
+
+ def test_token_impersonation_execute_raises_explicit_exception(self):
+ mod, campaign = _make_module(TokenImpersonationModule)
+ ctx = ExecutionContext.build(
+ campaign=campaign,
+ target="10.0.0.5",
+ module_id="windows.token_impersonation",
+ params={"target": "10.0.0.5", "username": "target_user", "password": "secret"},
+ )
+ with pytest.raises(ModuleError) as exc_info:
+ _run(mod.execute(ctx))
+ assert "module disabled: privilege check heuristic insufficient, named pipe != exploitation confirmed (MOD-030)" in str(exc_info.value)
+ assert len(mod._findings) == 0
+
+ def test_token_impersonation_validate_raises_explicit_exception(self):
+ mod, campaign = _make_module(TokenImpersonationModule)
+ ctx = ExecutionContext.build(
+ campaign=campaign,
+ target="10.0.0.5",
+ module_id="windows.token_impersonation",
+ params={"target": "10.0.0.5", "username": "target_user"},
+ )
+ with pytest.raises(ModuleValidationError) as exc_info:
+ _run(mod.validate(ctx))
+ assert "module disabled: privilege check heuristic insufficient, named pipe != exploitation confirmed (MOD-030)" in str(exc_info.value)
+
+ def test_token_impersonation_assess_feasibility_reports_disabled(self):
+ mod, campaign = _make_module(TokenImpersonationModule)
+ ctx = ExecutionContext.build(
+ campaign=campaign,
+ target="10.0.0.5",
+ module_id="windows.token_impersonation",
+ params={"target": "10.0.0.5", "username": "target_user"},
+ )
+ report = _run(mod.assess_feasibility(ctx))
+ assert report.feasible is False
+ assert any("MOD-030" in b for b in report.blockers)
+
diff --git a/tests/unit/test_staged_modules.py b/tests/unit/test_staged_modules.py
index 023b3e5..2da8d00 100644
--- a/tests/unit/test_staged_modules.py
+++ b/tests/unit/test_staged_modules.py
@@ -441,17 +441,13 @@ class TestGhostForgeModule:
def test_token_impersonation_closed_loop_telemetry(self, monkeypatch):
from ares.modules.windows.token_impersonation import TokenImpersonationModule
+ from ares.core.errors import ModuleError
mod, _ = _make_module(TokenImpersonationModule)
- async def fake_run(*args, **kwargs):
- return [], {"success": True, "tokens": ["NT AUTHORITY\\SYSTEM"], "loot": []}
- monkeypatch.setattr(mod, "run", fake_run)
ctx = _mock_ctx(params={"target": "10.0.0.5", "username": "Admin", "password": "Password123!"})
ctx.dry_run = False
- res = _run(mod.execute(ctx))
- assert res.status in ("partial", "success")
- assert res.raw.get("se_impersonate_privilege_evaluated") is True
- assert any(l["loot_type"] == "detection_rule_kql" for l in res.raw["loot"])
- assert any(l["loot_type"] == "detection_rule_sigma" for l in res.raw["loot"])
+ with pytest.raises(ModuleError) as exc_info:
+ _run(mod.execute(ctx))
+ assert "module disabled: privilege check heuristic insufficient" in str(exc_info.value)
def test_uac_bypass_closed_loop_telemetry(self, monkeypatch):
from ares.modules.windows.uac_bypass import UACBypassModule
diff --git a/tests/unit/test_windows_resilience.py b/tests/unit/test_windows_resilience.py
index ca999b7..f25c64d 100644
--- a/tests/unit/test_windows_resilience.py
+++ b/tests/unit/test_windows_resilience.py
@@ -14,6 +14,7 @@ import pytest
from ares.core.campaign import Campaign, NoiseProfile, ScopeEntry, Severity
from ares.core.config import AresSettings
+from ares.core.errors import ModuleError
from ares.core.noise import NoiseController
from ares.modules.windows.lsass_dump import LsassDumpModule
from ares.modules.windows.token_impersonation import TokenImpersonationModule
@@ -187,73 +188,46 @@ class TestLsassDumpResilience:
class TestTokenImpersonationNamedPipes:
- """Tests for Named Pipe audit and PrintSpoofer / Potato attack vector detection."""
+ """Tests for Named Pipe audit and PrintSpoofer / Potato attack vector detection (Disabled under MOD-030)."""
@pytest.mark.asyncio
async def test_printspoofer_confirmed_on_service_account(self, mock_impacket_modules):
mod = _make_module(TokenImpersonationModule)
- with patch.object(
- mod,
- "_audit_named_pipes_sync",
- return_value={"spoolss": True, "efsrpc": False, "svcctl": True, "samr": True},
- ):
- findings, raw = await mod.run(
+ with pytest.raises(ModuleError) as exc_info:
+ await mod.run(
target="192.168.1.20",
username="iis apppool\\defaultapppool",
password="Password123!",
)
-
- assert raw["named_pipes_checked"]["spoolss"] is True
- assert "PrintSpoofer (\\pipe\\spoolss)" in raw["impersonation_vectors"]
-
- # Must generate CRITICAL confirmed vector finding
- critical_finding = next((f for f in findings if f.severity == Severity.CRITICAL), None)
- assert critical_finding is not None
- assert "PrintSpoofer SYSTEM Escalation Vector Confirmed" in critical_finding.title
- assert critical_finding.evidence.get("exploit_vector") == "PrintSpoofer / PipePotato"
+ assert "module disabled: privilege check heuristic insufficient, named pipe != exploitation confirmed (MOD-030)" in str(exc_info.value)
+ assert len(mod._findings) == 0
@pytest.mark.asyncio
async def test_spooler_pipe_accessible_normal_user_vector(self, mock_impacket_modules):
mod = _make_module(TokenImpersonationModule)
- with patch.object(
- mod,
- "_audit_named_pipes_sync",
- return_value={"spoolss": True, "efsrpc": True, "svcctl": False, "samr": False},
- ):
- findings, raw = await mod.run(
+ with pytest.raises(ModuleError) as exc_info:
+ await mod.run(
target="192.168.1.21",
username="normal_user",
password="Password123!",
)
-
- assert raw["named_pipes_checked"]["spoolss"] is True
- assert "PrintSpoofer (\\pipe\\spoolss)" in raw["impersonation_vectors"]
- assert "EfsPotato / PetitPotam Local (\\pipe\\efsrpc)" in raw["impersonation_vectors"]
-
- # Generates HIGH finding alerting to Spooler exposure
- spool_finding = next((f for f in findings if "Print Spooler Named Pipe Accessible" in f.title), None)
- assert spool_finding is not None
- assert spool_finding.severity == Severity.HIGH
+ assert "module disabled: privilege check heuristic insufficient, named pipe != exploitation confirmed (MOD-030)" in str(exc_info.value)
+ assert len(mod._findings) == 0
@pytest.mark.asyncio
async def test_service_account_without_spooler_reports_potato(self, mock_impacket_modules):
mod = _make_module(TokenImpersonationModule)
- with patch.object(
- mod,
- "_audit_named_pipes_sync",
- return_value={"spoolss": False, "efsrpc": False, "svcctl": False, "samr": False},
- ):
- findings, raw = await mod.run(
+ with pytest.raises(ModuleError) as exc_info:
+ await mod.run(
target="192.168.1.22",
username="nt service\\mssql$sqlexpress",
password="Password123!",
)
-
- assert raw["has_impersonate_indicator"] is True
- assert any("SeImpersonatePrivilege Likely Present" in f.title for f in findings)
+ assert "module disabled: privilege check heuristic insufficient, named pipe != exploitation confirmed (MOD-030)" in str(exc_info.value)
+ assert len(mod._findings) == 0
class TestRegistryEnumDriverBlocklist: