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
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.pyindex 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 ExecutionContextdiff --git a/ares/modules/ad/asreproast.py b/ares/modules/ad/asreproast.pyindex 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 ExecutionContextdiff --git a/ares/modules/ad/dcsync.py b/ares/modules/ad/dcsync.pyindex 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.pyindex 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.pyindex 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.pyindex 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.pyindex 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+@propertydef 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] = hssess._pivot_proxies = data.get("pivot_proxies", [])diff --git a/tests/unit/test_ad_feasibility_matrix.py b/tests/unit/test_ad_feasibility_matrix.pynew file mode 100644index 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