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.

feat(modules): implement pre-flight defense feasibility matrix for Active Directory modules

Mafifrizi95175b3144e2
diff --git a/ares/modules/ad/adcs.py b/ares/modules/ad/adcs.py
index a5efed8..7c0bb3d 100644
--- a/ares/modules/ad/adcs.py
+++ b/ares/modules/ad/adcs.py
@@ -73,6 +73,54 @@ class ADCSModule(BaseModule):
MITRE_TECHNIQUES = ["T1649"]
MODULE_TIMEOUT_SECONDS: int | None = 180 # seconds
+ async def assess_feasibility(self, ctx: "Any") -> Any:
+ """
+ Assess pre-flight feasibility for ADCS enumeration and ESC exploitation.
+ Evaluates DC/CA target, credential availability, LDAP signing, and EDR on target.
+ """
+ from ares.modules.base import FeasibilityReport
+ ad = self._extract_ad_params(ctx)
+ blockers: list[str] = []
+ recommendations: list[str] = []
+ score = 1.0
+ risk = "low"
+
+ target_host = ad.get("dc") or getattr(ctx, "target", "")
+ if not target_host:
+ blockers.append("No Domain Controller (dc) or target IP specified")
+ score -= 0.5
+
+ if not ad.get("username"):
+ blockers.append("No domain credentials available for LDAP certificate query")
+ score -= 0.3
+ recommendations.append("ad.asreproast")
+
+ session = getattr(ctx, "session", None)
+ if session and hasattr(session, "get_host") and target_host:
+ host_state = session.get_host(target_host)
+ if host_state:
+ if host_state.has_defense("ldap_signing_enforced") and not (getattr(ctx, "params", {}).get("use_ldaps")):
+ score -= 0.25
+ recommendations.append("ad.enum_spn")
+ if host_state.has_defense("edr_active") or host_state.has_defense("crowdstrike"):
+ risk = "medium"
+ recommendations.append("ad.shadow_credentials")
+
+ exploit_esc1 = getattr(ctx, "params", {}).get("exploit_esc1", False)
+ if exploit_esc1:
+ risk = "medium"
+
+ 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={"use_ldaps": True if "ad.enum_spn" in recommendations else False},
+ details={"exploit_esc1_requested": exploit_esc1},
+ )
+
async def validate(self, ctx: "Any") -> None:
await super().validate(ctx)
from ares.core.context import ExecutionContext
diff --git a/ares/modules/ad/asreproast.py b/ares/modules/ad/asreproast.py
index d22d78a..d223bad 100644
--- a/ares/modules/ad/asreproast.py
+++ b/ares/modules/ad/asreproast.py
@@ -214,6 +214,52 @@ class ASREPRoastModule(BaseModule):
OUTPUTS = ["asrep_hashes"]
MITRE_TECHNIQUES = ["T1558.004"]
+ async def assess_feasibility(self, ctx: "Any") -> Any:
+ """
+ Assess pre-flight feasibility for AS-REP Roasting.
+ Evaluates DC accessibility, domain targeting, and pre-auth bypass viability.
+ Works without credentials if a user list or userfile is supplied.
+ """
+ from ares.modules.base import FeasibilityReport
+ ad = self._extract_ad_params(ctx)
+ blockers: list[str] = []
+ recommendations: list[str] = []
+ score = 1.0
+ risk = "low"
+
+ target_host = ad.get("dc") or getattr(ctx, "target", "")
+ if not target_host:
+ blockers.append("No Domain Controller (dc) or target IP specified")
+ score -= 0.5
+
+ has_creds = bool(ad.get("username")) and bool(ad.get("password"))
+ has_file = bool(getattr(ctx, "params", {}).get("userfile"))
+ has_list = bool(getattr(ctx, "params", {}).get("usernames"))
+
+ if not has_creds and not has_file and not has_list:
+ blockers.append("No user list or credentials available for AS-REP enumeration")
+ score -= 0.4
+ recommendations.append("ad.enum_users")
+
+ session = getattr(ctx, "session", None)
+ if session and hasattr(session, "get_host") and target_host:
+ host_state = session.get_host(target_host)
+ if host_state:
+ if host_state.has_defense("mde_identity") or host_state.has_defense("kerberos_anomaly_detection"):
+ risk = "medium"
+ score -= 0.2
+
+ 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={"batch_size": 10 if risk == "medium" else 50},
+ details={"auth_mode": "authenticated" if has_creds else "unauthenticated_list"},
+ )
+
async def validate(self, ctx: "Any") -> None:
"""Validate: dc + domain + at least one input mode present."""
from ares.core.context import ExecutionContext
diff --git a/ares/modules/ad/dcsync.py b/ares/modules/ad/dcsync.py
index 892f24d..3c25e76 100644
--- a/ares/modules/ad/dcsync.py
+++ b/ares/modules/ad/dcsync.py
@@ -34,6 +34,60 @@ class DCSyncModule(BaseModule):
MITRE_TECHNIQUES = ["T1003.006"]
MODULE_TIMEOUT_SECONDS: int | None = 600 # seconds
+ async def assess_feasibility(self, ctx: "Any") -> Any:
+ """
+ Assess pre-flight feasibility for DCSync.
+ Evaluates DC replication rights, noise profile restrictions,
+ and MDI / DRSUAPI monitoring alarms, recommending stealthier alternatives (ad.adcs, ad.shadow_credentials).
+ """
+ from ares.modules.base import FeasibilityReport
+ from ares.core.campaign import NoiseProfile
+ ad = self._extract_ad_params(ctx)
+ blockers: list[str] = []
+ recommendations: list[str] = []
+ score = 1.0
+ risk = "high_noise"
+
+ target_host = ad.get("dc") or getattr(ctx, "target", "")
+ if not target_host:
+ blockers.append("No Domain Controller (dc) or target IP specified")
+ score -= 0.5
+
+ if not ad.get("username"):
+ blockers.append("No Domain Admin or replication credentials available")
+ score -= 0.4
+ recommendations.append("ad.adcs")
+ recommendations.append("ad.kerberoast")
+
+ noise = getattr(getattr(ctx, "campaign", None), "noise_profile", None)
+ if noise == NoiseProfile.STEALTH:
+ blockers.append("Blocked in STEALTH profile: MS-DRSR replication generates critical SIEM/MDI alarms")
+ score = 0.05
+ risk = "critical_alarm"
+ recommendations.append("ad.adcs")
+ recommendations.append("ad.shadow_credentials")
+
+ session = getattr(ctx, "session", None)
+ if session and hasattr(session, "get_host") and target_host:
+ host_state = session.get_host(target_host)
+ if host_state:
+ if host_state.has_defense("mde_identity") or host_state.has_defense("drsuapi_monitoring"):
+ risk = "critical_alarm"
+ score -= 0.4
+ recommendations.append("ad.adcs")
+ recommendations.append("ad.shadow_credentials")
+
+ 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={"suggested_alternatives": ["ad.adcs", "ad.shadow_credentials"] if risk == "critical_alarm" else []},
+ details={"target_user": getattr(ctx, "params", {}).get("target_user", "krbtgt")},
+ )
+
async def validate(self, ctx: "Any") -> None:
"""
Enforce dc, domain, domain-admin credentials, and noise profile.
diff --git a/ares/modules/ad/kerberoast.py b/ares/modules/ad/kerberoast.py
index 93005a4..649e7a3 100644
--- a/ares/modules/ad/kerberoast.py
+++ b/ares/modules/ad/kerberoast.py
@@ -248,6 +248,61 @@ class KerberoastModule(BaseModule):
OUTPUTS = ["kerberos_hashes"]
MITRE_TECHNIQUES = ["T1558.003"]
+ async def assess_feasibility(self, ctx: "Any") -> Any:
+ """
+ Assess pre-flight feasibility for Kerberoasting.
+ Evaluates DC accessibility, domain credentials, noise profile (Event ID 4769 risk),
+ and recommends cipher tuning or targeted SPN requests.
+ """
+ from ares.modules.base import FeasibilityReport
+ from ares.core.campaign import NoiseProfile
+ ad = self._extract_ad_params(ctx)
+ blockers: list[str] = []
+ recommendations: list[str] = []
+ score = 1.0
+ risk = "medium"
+
+ target_host = ad.get("dc") or getattr(ctx, "target", "")
+ if not target_host:
+ blockers.append("No Domain Controller (dc) or target IP specified")
+ score -= 0.5
+
+ if not ad.get("username"):
+ blockers.append("No domain credentials available to request TGS tickets")
+ score -= 0.4
+ recommendations.append("ad.asreproast")
+
+ noise = getattr(getattr(ctx, "campaign", None), "noise_profile", None)
+ if noise == NoiseProfile.STEALTH:
+ blockers.append("Blocked in STEALTH profile: TGS requests generate Event ID 4769")
+ score = 0.1
+ risk = "high_noise"
+ recommendations.append("ad.enum_spn")
+ recommendations.append("ad.adcs")
+
+ session = getattr(ctx, "session", None)
+ if session and hasattr(session, "get_host") and target_host:
+ host_state = session.get_host(target_host)
+ if host_state:
+ if host_state.has_defense("mde_identity") or host_state.has_defense("kerberos_anomaly_detection"):
+ risk = "high_noise"
+ score -= 0.3
+ recommendations.append("ad.adcs")
+
+ 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={
+ "preferred_cipher": "aes256-cts-hmac-sha1-96",
+ "rate_limit_seconds": 5.0 if noise != NoiseProfile.AGGRESSIVE else 0.5,
+ },
+ details={"target_dc": target_host, "spn_source": "enum_spn" if "spn_list" in getattr(ctx, "params", {}) else "dynamic"},
+ )
+
async def validate(self, ctx: "Any") -> None:
"""
Enforce dc, domain, and domain credentials.
diff --git a/ares/modules/base.py b/ares/modules/base.py
index 7b66f0d..1502b0e 100644
--- a/ares/modules/base.py
+++ b/ares/modules/base.py
@@ -138,6 +138,35 @@ class OpsecLevel(str, Enum):
HIGH_NOISE = "high_noise" # DCSync, brute force — blocked in stealth
+# ── Feasibility Report ────────────────────────────────────────────────────────
+
+@dataclass
+class FeasibilityReport:
+ """
+ Structured pre-flight feasibility evaluation report.
+ Assesses target defense posture, likelihood of success, OPSEC risk,
+ and recommends alternative modules if unfeasible.
+ """
+ feasible: bool = True
+ score: float = 1.0 # 0.0 (impossible/blocked) to 1.0 (optimal)
+ risk_level: str = "low" # silent, low, medium, high_noise, critical_alarm
+ blockers: list[str] = field(default_factory=list)
+ recommended_alternatives: list[str] = field(default_factory=list)
+ opsec_tuning: dict[str, Any] = field(default_factory=dict)
+ details: dict[str, Any] = field(default_factory=dict)
+
+ def to_dict(self) -> dict[str, Any]:
+ return {
+ "feasible": self.feasible,
+ "score": round(self.score, 3),
+ "risk_level": self.risk_level,
+ "blockers": list(self.blockers),
+ "recommended_alternatives": list(self.recommended_alternatives),
+ "opsec_tuning": dict(self.opsec_tuning),
+ "details": dict(self.details),
+ }
+
+
# ── BaseModule ────────────────────────────────────────────────────────────────
class BaseModule(abc.ABC):
@@ -151,6 +180,39 @@ class BaseModule(abc.ABC):
Formal SDK contract (v0.9.0+) — see validate(), before_request(), finding().
"""
+ async def assess_feasibility(self, ctx: "Any") -> FeasibilityReport:
+ """
+ Evaluate whether this module is feasible against target defenses
+ prior to execution. Does not make aggressive network calls.
+
+ Default implementation:
+ - Inspects target host defense profile in ctx.session if available
+ - Evaluates OPSEC level against campaign noise profile
+ - Subclasses override to provide defense-specific logic (e.g. EDR, Credential Guard)
+ """
+ risk = getattr(self.OPSEC_LEVEL, "value", str(self.OPSEC_LEVEL or "low"))
+ noise_profile = getattr(ctx, "opsec_profile", "normal")
+
+ if noise_profile == "stealth" and risk == "high_noise":
+ return FeasibilityReport(
+ feasible=False,
+ score=0.2,
+ risk_level="high_noise",
+ blockers=["Module OPSEC level is high_noise under a stealth campaign profile"],
+ recommended_alternatives=[],
+ opsec_tuning={"suggested_profile": "normal"},
+ )
+
+ return FeasibilityReport(
+ feasible=True,
+ score=1.0,
+ risk_level=risk,
+ blockers=[],
+ recommended_alternatives=[],
+ opsec_tuning={},
+ details={},
+ )
+
async def validate(self, ctx: "Any") -> None:
"""
Validate the execution context BEFORE running the module.
diff --git a/ares/modules/edr/bypass_adaptive.py b/ares/modules/edr/bypass_adaptive.py
index b4bad5a..0ee6a93 100644
--- a/ares/modules/edr/bypass_adaptive.py
+++ b/ares/modules/edr/bypass_adaptive.py
@@ -259,6 +259,20 @@ class EDRAdaptiveBypassModule(BaseModule):
os_version=ctx.params.get("os_version", ""),
**passthrough_params,
)
+
+ session = getattr(ctx, "session", None)
+ if session and hasattr(session, "get_or_create_host") and target:
+ host_state = session.get_or_create_host(target)
+ controls = {
+ "edr_vendor": edr_vendor,
+ "edr_active": bool(edr_vendor and edr_vendor != "unknown"),
+ "blind_spots": raw.get("blind_spots", []),
+ }
+ if edr_vendor and edr_vendor != "unknown":
+ controls[edr_vendor.lower().replace("-", "_").replace(" ", "_")] = True
+ if hasattr(host_state, "update_defense_profile"):
+ host_state.update_defense_profile(controls)
+
return ModuleResult(
status="success" if findings else "partial",
findings=findings, raw=raw, module_id=self.MODULE_ID,
diff --git a/ares/state/target_state.py b/ares/state/target_state.py
index d90fdaa..c6bf5d7 100644
--- a/ares/state/target_state.py
+++ b/ares/state/target_state.py
@@ -102,6 +102,8 @@ class HostState:
os_type: str = "" # e.g. "Windows Server", "Linux"
domain_role: str = "" # e.g. "domain_controller", "member"
attack_history: list[dict] = field(default_factory=list)
+ security_controls: dict[str, Any] = field(default_factory=dict)
+ defense_profile: dict[str, Any] = field(default_factory=dict)
def __post_init__(self) -> None:
if self.ip and not self.ip_address:
@@ -109,6 +111,23 @@ class HostState:
elif self.ip_address and not self.ip:
self.ip = self.ip_address
+ def update_defense_profile(self, controls: dict[str, Any]) -> None:
+ """Update or merge detected defense controls and security posture."""
+ self.defense_profile.update(controls)
+ self.security_controls.update(controls)
+ self.last_updated = time.time()
+
+ def has_defense(self, control_name: str) -> bool:
+ """Check if a specific security control or defense is active on this host."""
+ norm = control_name.strip().lower()
+ for k, v in self.defense_profile.items():
+ if k.strip().lower() == norm and bool(v):
+ return True
+ for k, v in self.security_controls.items():
+ if k.strip().lower() == norm and bool(v):
+ return True
+ return False
+
@property
def owned_by(self) -> str:
"""Username of the operator/user who owns this host."""
@@ -170,6 +189,8 @@ class HostState:
"reachable_from": self.reachable_from,
"can_reach": self.can_reach,
"tags": self.tags,
+ "security_controls": dict(self.security_controls),
+ "defense_profile": dict(self.defense_profile),
}
@@ -451,6 +472,8 @@ class OperatorSession:
owned_via = h.get("owned_via", ""),
owned_at = h.get("owned_at"),
attack_history = h.get("attack_history", []),
+ security_controls = h.get("security_controls", {}),
+ defense_profile = h.get("defense_profile", {}),
)
sess._hosts[ip] = hs
sess._pivot_proxies = data.get("pivot_proxies", [])
diff --git a/tests/unit/test_ad_feasibility_matrix.py b/tests/unit/test_ad_feasibility_matrix.py
new file mode 100644
index 0000000..67ff0f3
--- /dev/null
+++ b/tests/unit/test_ad_feasibility_matrix.py
@@ -0,0 +1,310 @@
+"""
+Unit tests for the ARES Pre-Flight Defense Feasibility Matrix.
+Tests feasibility evaluation across Active Directory modules:
+- ad.adcs
+- ad.kerberoast
+- ad.asreproast
+- ad.dcsync
+And HostState defense profiling integration.
+"""
+from __future__ import annotations
+
+import pytest
+
+from ares.core.campaign import Campaign, NoiseProfile
+from ares.core.config import AresSettings
+from ares.core.context import ExecutionContext
+from ares.core.noise import NoiseController
+from ares.modules.base import BaseModule, FeasibilityReport, OpsecLevel
+from ares.state.target_state import HostState, OperatorSession
+from ares.modules.ad.adcs import ADCSModule
+from ares.modules.ad.kerberoast import KerberoastModule
+from ares.modules.ad.asreproast import ASREPRoastModule
+from ares.modules.ad.dcsync import DCSyncModule
+from ares.modules.edr.bypass_adaptive import EDRAdaptiveBypassModule
+
+
+def dummy_settings():
+ return AresSettings(jwt_secret_key="test-secret-that-is-at-least-32-bytes-long!")
+
+
+def dummy_campaign():
+ return Campaign(name="test-feasibility-campaign", operator="test_operator", noise_profile=NoiseProfile.NORMAL)
+
+
+def dummy_noise(dummy_campaign):
+ return NoiseController(dummy_campaign)
+
+
+class TestHostStateDefenseProfile:
+ def test_host_state_defense_profile_defaults(self):
+ host = HostState(ip_address="10.0.0.10", hostname="dc01.corp.local")
+ assert host.defense_profile == {}
+ assert host.security_controls == {}
+ assert host.has_defense("crowdstrike") is False
+
+ def test_host_state_update_and_has_defense(self):
+ host = HostState(ip_address="10.0.0.10", hostname="dc01.corp.local")
+ host.update_defense_profile({
+ "edr_vendor": "CrowdStrike",
+ "crowdstrike": True,
+ "credential_guard": True,
+ "ldap_signing_enforced": True,
+ })
+ assert host.has_defense("crowdstrike") is True
+ assert host.has_defense("CrowdStrike") is True
+ assert host.has_defense("credential_guard") is True
+ assert host.has_defense("sentinelone") is False
+
+ def test_host_state_serialization_round_trip(self):
+ sess = OperatorSession(campaign_id="test-camp")
+ host = sess.add_host("10.0.0.20", hostname="srv01.corp.local")
+ host.update_defense_profile({"mde_identity": True, "edr_vendor": "defender_atp"})
+ snapshot = sess.snapshot()
+
+ restored = OperatorSession.from_snapshot(snapshot)
+ restored_host = restored.get_host("10.0.0.20")
+ assert restored_host is not None
+ assert restored_host.has_defense("mde_identity") is True
+ assert restored_host.defense_profile.get("edr_vendor") == "defender_atp"
+
+
+class TestBaseModuleFeasibility:
+ @pytest.mark.asyncio
+ async def test_default_base_module_feasibility_normal(self, dummy_settings, dummy_campaign, dummy_noise):
+ class DummyMod(BaseModule):
+ MODULE_ID = "test.dummy"
+ OPSEC_LEVEL = OpsecLevel.LOW
+
+ mod = DummyMod(dummy_settings, dummy_campaign, dummy_noise)
+ ctx = ExecutionContext.build(campaign=dummy_campaign, target="10.0.0.1", module_id=mod.MODULE_ID)
+ report = await mod.assess_feasibility(ctx)
+ assert isinstance(report, FeasibilityReport)
+ assert report.feasible is True
+ assert report.score == 1.0
+ assert report.risk_level == "low"
+ assert report.blockers == []
+
+ @pytest.mark.asyncio
+ async def test_default_base_module_stealth_blocks_high_noise(self, dummy_settings, dummy_campaign, dummy_noise):
+ class NoisyMod(BaseModule):
+ MODULE_ID = "test.noisy"
+ OPSEC_LEVEL = OpsecLevel.HIGH_NOISE
+
+ mod = NoisyMod(dummy_settings, dummy_campaign, dummy_noise)
+ ctx = ExecutionContext.build(
+ campaign=dummy_campaign, target="10.0.0.1", module_id=mod.MODULE_ID, opsec_profile="stealth"
+ )
+ report = await mod.assess_feasibility(ctx)
+ assert report.feasible is False
+ assert report.score < 0.5
+ assert report.risk_level == "high_noise"
+ assert len(report.blockers) > 0
+
+
+class TestADCSFeasibility:
+ @pytest.mark.asyncio
+ async def test_adcs_feasibility_ready(self, dummy_settings, dummy_campaign, dummy_noise):
+ mod = ADCSModule(dummy_settings, dummy_campaign, dummy_noise)
+ ctx = ExecutionContext.build(
+ campaign=dummy_campaign,
+ target="10.0.0.10",
+ module_id=mod.MODULE_ID,
+ params={"dc": "10.0.0.10", "domain": "corp.local", "username": "alice", "password": "Secret123!"},
+ )
+ report = await mod.assess_feasibility(ctx)
+ assert report.feasible is True
+ assert report.score >= 0.9
+ assert report.risk_level == "low"
+ assert report.blockers == []
+
+ @pytest.mark.asyncio
+ async def test_adcs_feasibility_missing_dc(self, dummy_settings, dummy_campaign, dummy_noise):
+ mod = ADCSModule(dummy_settings, dummy_campaign, dummy_noise)
+ ctx = ExecutionContext.build(
+ campaign=dummy_campaign,
+ target="",
+ module_id=mod.MODULE_ID,
+ params={"username": "alice", "password": "Secret123!"},
+ )
+ report = await mod.assess_feasibility(ctx)
+ assert report.feasible is False
+ assert "No Domain Controller (dc) or target IP specified" in report.blockers
+
+ @pytest.mark.asyncio
+ async def test_adcs_feasibility_recommends_asreproast_when_unauthenticated(self, dummy_settings, dummy_campaign, dummy_noise):
+ mod = ADCSModule(dummy_settings, dummy_campaign, dummy_noise)
+ ctx = ExecutionContext.build(
+ campaign=dummy_campaign,
+ target="10.0.0.10",
+ module_id=mod.MODULE_ID,
+ params={"dc": "10.0.0.10", "domain": "corp.local"},
+ )
+ report = await mod.assess_feasibility(ctx)
+ assert report.feasible is False
+ assert "ad.asreproast" in report.recommended_alternatives
+
+ @pytest.mark.asyncio
+ async def test_adcs_feasibility_detects_target_edr(self, dummy_settings, dummy_campaign, dummy_noise):
+ mod = ADCSModule(dummy_settings, dummy_campaign, dummy_noise)
+ session = OperatorSession(campaign_id="test-camp")
+ dc_host = session.add_host("10.0.0.10")
+ dc_host.update_defense_profile({"crowdstrike": True, "edr_active": True})
+
+ ctx = ExecutionContext.build(
+ campaign=dummy_campaign,
+ target="10.0.0.10",
+ module_id=mod.MODULE_ID,
+ session=session,
+ params={"dc": "10.0.0.10", "domain": "corp.local", "username": "alice", "password": "Secret123!"},
+ )
+ report = await mod.assess_feasibility(ctx)
+ assert report.risk_level == "medium"
+ assert "ad.shadow_credentials" in report.recommended_alternatives
+
+
+class TestKerberoastFeasibility:
+ @pytest.mark.asyncio
+ async def test_kerberoast_feasibility_normal_profile(self, dummy_settings, dummy_campaign, dummy_noise):
+ mod = KerberoastModule(dummy_settings, dummy_campaign, dummy_noise)
+ ctx = ExecutionContext.build(
+ campaign=dummy_campaign,
+ target="10.0.0.10",
+ module_id=mod.MODULE_ID,
+ params={"dc": "10.0.0.10", "domain": "corp.local", "username": "alice", "password": "Secret123!"},
+ )
+ report = await mod.assess_feasibility(ctx)
+ assert report.feasible is True
+ assert report.risk_level == "medium"
+ assert "preferred_cipher" in report.opsec_tuning
+
+ @pytest.mark.asyncio
+ async def test_kerberoast_feasibility_stealth_profile_recommends_adcs(self, dummy_settings):
+ stealth_camp = Campaign(name="stealth-camp", noise_profile=NoiseProfile.STEALTH)
+ mod = KerberoastModule(dummy_settings, stealth_camp, NoiseController(stealth_camp))
+ ctx = ExecutionContext.build(
+ campaign=stealth_camp,
+ target="10.0.0.10",
+ module_id=mod.MODULE_ID,
+ params={"dc": "10.0.0.10", "domain": "corp.local", "username": "alice", "password": "Secret123!"},
+ )
+ report = await mod.assess_feasibility(ctx)
+ assert report.feasible is False
+ assert report.risk_level == "high_noise"
+ assert any("STEALTH" in b for b in report.blockers)
+ assert "ad.adcs" in report.recommended_alternatives
+ assert "ad.enum_spn" in report.recommended_alternatives
+
+
+class TestASREPRoastFeasibility:
+ @pytest.mark.asyncio
+ async def test_asreproast_feasibility_with_creds(self, dummy_settings, dummy_campaign, dummy_noise):
+ mod = ASREPRoastModule(dummy_settings, dummy_campaign, dummy_noise)
+ ctx = ExecutionContext.build(
+ campaign=dummy_campaign,
+ target="10.0.0.10",
+ module_id=mod.MODULE_ID,
+ params={"dc": "10.0.0.10", "domain": "corp.local", "username": "alice", "password": "Secret123!"},
+ )
+ report = await mod.assess_feasibility(ctx)
+ assert report.feasible is True
+ assert report.score >= 0.9
+
+ @pytest.mark.asyncio
+ async def test_asreproast_feasibility_with_user_list(self, dummy_settings, dummy_campaign, dummy_noise):
+ mod = ASREPRoastModule(dummy_settings, dummy_campaign, dummy_noise)
+ ctx = ExecutionContext.build(
+ campaign=dummy_campaign,
+ target="10.0.0.10",
+ module_id=mod.MODULE_ID,
+ params={"dc": "10.0.0.10", "domain": "corp.local", "usernames": ["svc_backup", "svc_sql"]},
+ )
+ report = await mod.assess_feasibility(ctx)
+ assert report.feasible is True
+ assert report.details.get("auth_mode") == "unauthenticated_list"
+
+ @pytest.mark.asyncio
+ async def test_asreproast_feasibility_without_any_users(self, dummy_settings, dummy_campaign, dummy_noise):
+ mod = ASREPRoastModule(dummy_settings, dummy_campaign, dummy_noise)
+ ctx = ExecutionContext.build(
+ campaign=dummy_campaign,
+ target="10.0.0.10",
+ module_id=mod.MODULE_ID,
+ params={"dc": "10.0.0.10", "domain": "corp.local"},
+ )
+ report = await mod.assess_feasibility(ctx)
+ assert report.feasible is False
+ assert "ad.enum_users" in report.recommended_alternatives
+
+
+class TestDCSyncFeasibility:
+ @pytest.mark.asyncio
+ async def test_dcsync_feasibility_normal_profile(self, dummy_settings, dummy_campaign, dummy_noise):
+ mod = DCSyncModule(dummy_settings, dummy_campaign, dummy_noise)
+ ctx = ExecutionContext.build(
+ campaign=dummy_campaign,
+ target="10.0.0.10",
+ module_id=mod.MODULE_ID,
+ params={"dc": "10.0.0.10", "domain": "corp.local", "username": "Administrator", "password": "Secret123!"},
+ )
+ report = await mod.assess_feasibility(ctx)
+ assert report.feasible is True
+ assert report.risk_level == "high_noise"
+
+ @pytest.mark.asyncio
+ async def test_dcsync_feasibility_stealth_blocks_and_recommends_adcs(self, dummy_settings):
+ stealth_camp = Campaign(name="stealth-camp", noise_profile=NoiseProfile.STEALTH)
+ mod = DCSyncModule(dummy_settings, stealth_camp, NoiseController(stealth_camp))
+ ctx = ExecutionContext.build(
+ campaign=stealth_camp,
+ target="10.0.0.10",
+ module_id=mod.MODULE_ID,
+ params={"dc": "10.0.0.10", "domain": "corp.local", "username": "Administrator", "password": "Secret123!"},
+ )
+ report = await mod.assess_feasibility(ctx)
+ assert report.feasible is False
+ assert report.risk_level == "critical_alarm"
+ assert "ad.adcs" in report.recommended_alternatives
+ assert "ad.shadow_credentials" in report.recommended_alternatives
+
+ @pytest.mark.asyncio
+ async def test_dcsync_feasibility_target_with_drsuapi_monitoring(self, dummy_settings, dummy_campaign, dummy_noise):
+ mod = DCSyncModule(dummy_settings, dummy_campaign, dummy_noise)
+ session = OperatorSession(campaign_id="test-camp")
+ dc_host = session.add_host("10.0.0.10")
+ dc_host.update_defense_profile({"mde_identity": True, "drsuapi_monitoring": True})
+
+ ctx = ExecutionContext.build(
+ campaign=dummy_campaign,
+ target="10.0.0.10",
+ module_id=mod.MODULE_ID,
+ session=session,
+ params={"dc": "10.0.0.10", "domain": "corp.local", "username": "Administrator", "password": "Secret123!"},
+ )
+ report = await mod.assess_feasibility(ctx)
+ assert report.risk_level == "critical_alarm"
+ assert "ad.adcs" in report.recommended_alternatives
+
+
+class TestEDRBridgeIntegration:
+ @pytest.mark.asyncio
+ async def test_edr_execution_populates_host_defense_profile(self, dummy_settings, dummy_campaign, dummy_noise):
+ mod = EDRAdaptiveBypassModule(dummy_settings, dummy_campaign, dummy_noise)
+ session = OperatorSession(campaign_id="test-camp")
+ ctx = ExecutionContext.build(
+ campaign=dummy_campaign,
+ target="10.0.0.10",
+ module_id=mod.MODULE_ID,
+ session=session,
+ params={"edr_vendor": "crowdstrike", "target": "10.0.0.10"},
+ )
+ res = await mod.execute(ctx)
+ assert res.status in ("success", "partial")
+
+ host = session.get_host("10.0.0.10")
+ assert host is not None
+ assert host.has_defense("crowdstrike") is True
+ assert host.has_defense("edr_active") is True