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
"""
Hash Cracking Interface - credential.crack
MITRE: T1110.002 - Brute Force: Password Cracking
Thin wrapper around ares/credential/cracker.py (720 lines, fully implemented).
Runs hashcat (GPU) or john (CPU fallback) against uncracked hashes in the vault.
Cracked plaintext is encrypted and stored back to vault via vault.mark_cracked().
OPSEC: LOCAL - cracking happens entirely on the operator machine.
Zero network traffic to target. Not included in campaign noise budget.
Hash types supported (hashcat modes):
krb5tgs → 13100 / 19700 / 19600 (from ad.kerberoast)
krb5asrep → 18200 (from ad.asreproast)
ntlm → 1000 (from ad.dcsync, windows.lsa_secrets)
netntlmv2 → 5600 (from lateral.smb_relay)
sha512 → 1800 (from linux /etc/shadow)
"""
from __future__ import annotations
from typing import Any
from ares.core.campaign import Severity
from ares.core.logger import audit, get_logger
from ares.core.tracing import trace_module
from ares.modules.params import CredentialCrackParams
from ares.sdk import (
BaseModule,
CircuitBreaker,
EvidenceRecord,
ModuleResult,
NetworkPermission,
OpsecLevel,
ProcessPermission,
module_contract,
)
logger = get_logger("ares.modules.credential.crack")
# Hashcat mode mapping per credential type
_HASHCAT_MODES: dict[str, int] = {
"krb5tgs": 13100, # Kerberoast RC4
"krb5tgs17": 19700, # Kerberoast AES128
"krb5tgs18": 19600, # Kerberoast AES256
"krb5asrep": 18200, # ASREPRoast
"ntlm": 1000, # NTLM
"lm": 3000, # LM
"netntlmv2": 5600, # NetNTLMv2
"sha512": 1800, # sha512crypt (Linux)
"md5": 500, # md5crypt
}
# Priority per hash type (lower = cracked first; NTLM is fastest)
_CRACK_PRIORITY: dict[str, int] = {
"ntlm": 1,
"lm": 2,
"netntlmv2": 3,
"krb5asrep": 4,
"krb5tgs": 5,
"sha512": 6,
"md5": 7,
}
@module_contract(
permissions=[
NetworkPermission(ports=[]),
ProcessPermission(allow_subprocesses=True, allowed_binaries=["hashcat", "john", "hashcat.exe", "john.exe"]),
],
circuit_breaker=CircuitBreaker(name="credential_crack", failure_threshold=5, recovery_timeout_s=60.0),
params_model=CredentialCrackParams,
)
class CrackModule(BaseModule[CredentialCrackParams, ModuleResult]):
"""
credential.crack - "Crack hashes in CredentialVault using hashcat (GPU
OPSEC: LOCAL
MITRE: "T1110.002"
REQUIRES: "vault"
OUTPUTS: "cracked_credentials"
"""
MODULE_ID = "credential.crack"
MODULE_NAME = "Hash Cracking"
MODULE_CATEGORY = "credential"
MODULE_DESCRIPTION = (
"Crack hashes in CredentialVault using hashcat (GPU) or john (CPU fallback). "
"Cracked plaintext is stored back to vault, immediately available for reuse."
)
OPSEC_LEVEL = OpsecLevel.LOCAL # local only - zero network traffic
REQUIRES = ["vault"]
OUTPUTS = ["cracked_credentials"]
MITRE_TECHNIQUES = ["T1110.002"]
MODULE_AUTHOR = "ARES Team <[email protected]>"
MODULE_TIMEOUT_SECONDS: int | None = 3600 # seconds
PARAMS_MODEL = CredentialCrackParams
async def validate(self, ctx: "Any") -> None:
"""Enforce vault has hash credentials to crack."""
from ares.core.context import ExecutionContext
from ares.core.errors import ModuleValidationError
if not isinstance(ctx, ExecutionContext):
return
vault = getattr(ctx, "vault", None)
if not vault:
raise ModuleValidationError(
"credential.crack requires a CredentialVault - "
"run ad.kerberoast, ad.asreproast, or ad.dcsync first.",
module_id=self.MODULE_ID, field="vault",
)
# Check there are actually hashes to crack
hashes = [
c for c in vault._store.values()
if c.is_hash and not c.cracked and c.active
]
if not hashes:
raise ModuleValidationError(
"No uncracked hashes found in vault. "
"Run ad.kerberoast / ad.asreproast / ad.dcsync first, "
"or all hashes have already been cracked.",
module_id=self.MODULE_ID, field="vault",
)
await super().validate(ctx)
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})
vault = getattr(ctx, "vault", None)
timeout_s = int(ctx.params.get("timeout_seconds", 3600))
use_gpu = bool(ctx.params.get("use_gpu", True))
wordlist = ctx.params.get("wordlist", "")
findings, raw = await self.run(
vault=vault, timeout_s=timeout_s, use_gpu=use_gpu, wordlist=wordlist,
)
# Cryptographic Evidence Records with SHA-256 Merkle Provenance
evidence_chain: list[EvidenceRecord] = []
for cred in raw.get("cracked_credentials", []):
ev = EvidenceRecord(
artifact_id=f"crack-{cred.get('username', 'unknown').lower()}",
source_target="localhost",
collected_by=self.MODULE_ID,
data={
"username": cred.get("username"),
"domain": cred.get("domain"),
"hash_type": cred.get("hash_type"),
},
tags=["credential", "crack", "hashcat"],
)
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 Synthesis (Sentinel KQL + Sigma YAML)
kql_rule = (
"// Microsoft Sentinel - Password Cracking Tool Execution\n"
"SecurityEvent\n"
"| where TimeGenerated > ago(24h)\n"
"| where EventID == 4688\n"
"| extend ProcessName = tolower(Process)\n"
"| where ProcessName endswith \"hashcat.exe\" or ProcessName endswith \"john.exe\" "
"or CommandLine has_any (\"--potfile\", \"rockyou.txt\", \"-m 1000\", \"-m 13100\", \"-m 18200\")\n"
"| project TimeGenerated, Computer, Account, Process, CommandLine, ParentProcessName"
)
sigma_rule = (
"title: Hashcat or John The Ripper Execution\n"
"id: d2e3f4a5-b6c7-48d9-a0b1-c2d3e4f5a6b7\n"
"status: experimental\n"
"description: Detects command-line execution of hash cracking tools like Hashcat or John the Ripper\n"
"references:\n"
" - https://attack.mitre.org/techniques/T1110/002/\n"
"author: ARES Purple Team Modernization\n"
"date: 2026-03-30\n"
"logsource:\n"
" category: process_creation\n"
" product: windows\n"
"detection:\n"
" selection:\n"
" Image|endswith:\n"
" - '\\hashcat.exe'\n"
" - '\\john.exe'\n"
" CommandLine|contains:\n"
" - 'rockyou'\n"
" - '-m 1000'\n"
" - '-m 13100'\n"
" - '-m 18200'\n"
" condition: selection\n"
"level: high\n"
"tags:\n"
" - attack.credential_access\n"
" - attack.t1110.002"
)
raw.setdefault("loot", {})
raw["loot"]["detection_kql"] = kql_rule
raw["loot"]["detection_sigma"] = sigma_rule
raw["weak_passwords_identified"] = bool(raw.get("cracked_credentials"))
raw["offline_cracking_vulnerability"] = bool(raw.get("cracked_credentials"))
raw["kerberos_ticket_cracked"] = any(
c.get("hash_type") in ["krb5tgs", "krb5asrep"] for c in raw.get("cracked_credentials", [])
)
raw["credential_cracking_audited"] = True
return ModuleResult(
status="success" if findings else "partial",
findings=findings, raw=raw, module_id=self.MODULE_ID,
execution_id=getattr(ctx, "execution_id", ""),
)
@trace_module("credential.crack")
async def run(self, vault: "Any" = None, timeout_s: int = 3600,
use_gpu: bool = True, wordlist: str = "", **kwargs: Any):
# Note: before_request() intentionally not called - credential.crack is
# OpsecLevel.LOCAL (offline hash cracking, no network calls).
# Scope, jitter, and rate-limit checks apply only to network-facing operations.
from ares.credential.cracker import CrackingQueue, CrackingWorker, CrackJob, CrackStatus
from ares.credential.vault import CredentialType
if vault is None:
return [], {"error": "no_vault_provided"}
# Collect all uncracked hash credentials from vault
hash_creds = [
c for c in vault._store.values()
if c.is_hash and not c.cracked and c.active
]
if not hash_creds:
return [], {"cracked": 0, "total": 0, "skipped": "no_hashes_in_vault"}
logger.info("crack_start", total_hashes=len(hash_creds))
audit("credential_crack", actor="operator", technique="T1110.002",
detail=f"hashes={len(hash_creds)}")
# Build CrackingWorker
worker = CrackingWorker(
vault=vault,
timeout_s=timeout_s,
use_gpu=use_gpu,
)
# Override wordlist if provided
if wordlist:
from pathlib import Path
if Path(wordlist).exists():
worker._wordlist = Path(wordlist)
# Report tool availability before starting
tools = worker.tool_status()
if not tools["hashcat"]["available"] and not tools["john"]["available"]:
logger.warning("crack_no_tool",
msg="Install hashcat or john-the-ripper for cracking")
return [], {
"error": "no_cracking_tool_available",
"hint": "Install hashcat (GPU) or john (CPU): apt install hashcat john",
"tools": tools,
}
queue = CrackingQueue(worker)
# Map CredentialType → hash type string + hashcat mode
def _hash_type(cred_type: CredentialType) -> tuple[str, int]:
mapping = {
CredentialType.KRB5_TGS: ("krb5tgs", 13100),
CredentialType.KRB5_ASREP: ("krb5asrep", 18200),
CredentialType.NTLM: ("ntlm", 1000),
CredentialType.HASH: ("sha512crypt", 1800),
}
return mapping.get(cred_type, ("ntlm", 1000))
# Submit jobs ordered by crack priority (fastest first)
for cred in hash_creds:
hash_str = vault.reveal(cred.id)
if not hash_str:
continue
ht, mode = _hash_type(cred.cred_type)
priority = _CRACK_PRIORITY.get(ht, 9)
job = CrackJob(
cred_id = cred.id,
hash_value = hash_str,
hash_type = ht,
hashcat_mode = mode,
username = cred.username,
domain = cred.domain or "",
)
queue.submit(job, priority=priority)
# Run until all jobs complete
results = await queue.run_until_empty()
cracked = [r for r in results if r.status == CrackStatus.CRACKED]
failed = [r for r in results if r.status == CrackStatus.FAILED]
skipped = [r for r in results if r.status == CrackStatus.SKIPPED]
logger.info("crack_complete",
cracked=len(cracked), failed=len(failed), skipped=len(skipped))
# Generate findings - one per cracked credential (no plaintext in finding)
if cracked:
usernames = [r.username for r in cracked if r.username]
self.finding(
title = f"Hash Cracking: {len(cracked)}/{len(results)} Hashes Cracked",
description = (
f"Successfully cracked {len(cracked)} of {len(results)} hashes "
f"using {cracked[0].tool_used if cracked else 'hashcat/john'}. "
"Plaintext credentials stored in vault - "
"immediately available for credential.reuse and lateral movement."
),
severity = Severity.CRITICAL,
mitre_technique = "T1110.002",
mitre_tactic = "Credential Access",
evidence = {
"cracked_count": len(cracked),
"total_hashes": len(results),
"usernames": usernames[:20],
"tools_used": list({r.tool_used for r in cracked}),
"avg_time_s": round(
sum(r.elapsed_s for r in cracked) / len(cracked), 1
) if cracked else 0,
},
remediation = (
"Enforce strong password policy (min 15 chars, complexity). "
"Migrate Kerberos service accounts to gMSA (auto-rotating, "
"240-char random passwords - uncrackable). "
"Enable AES-256 Kerberos encryption, disable RC4."
),
)
raw = {
"cracked": len(cracked),
"cracked_credentials": [{"username": r.username, "domain": r.domain,
"hash_type": r.hash_type}
for r in cracked], # OUTPUTS key
"failed": len(failed),
"skipped": len(skipped),
"total": len(results),
"cracked_users": [{"username": r.username, "domain": r.domain,
"hash_type": r.hash_type, "tool": r.tool_used,
"elapsed_s": r.elapsed_s}
for r in cracked], # no plaintext here
"tools": tools,
"wordlist": str(worker._wordlist) if worker._wordlist else None,
}
return self._findings[:], raw