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
fix(integrity): correct credential type classification in sssd_harvest - hash != cleartext (MOD-045)
Mafifrizibd24fb55c0de
diff --git a/ares/credential/vault.py b/ares/credential/vault.pyindex 17200b2..cad19f5 100644--- a/ares/credential/vault.py+++ b/ares/credential/vault.py@@ -53,9 +53,11 @@ def _env_bytes(name: str, default: bytes) -> bytes:class CredentialType(str, Enum):CLEARTEXT = "cleartext" # username:passwordNTLM = "ntlm" # NT:LM hash pair+ HASH = "hash" # Generic/Linux/crypt hash ($6$, $y$, $5$, etc.)KRB5_TGS = "krb5_tgs" # Kerberoast hash (hashcat 13100/19700)KRB5_ASREP = "krb5_asrep" # ASREPRoast hash (hashcat 18200)KRB5_TGT = "krb5_tgt" # full TGT (pass-the-ticket)+ KERBEROS = "krb5_tgs" # Kerberos aliasSSH_KEY = "ssh_key" # private keyAPI_KEY = "api_key" # cloud / service API keyJWT = "jwt" # JSON Web Token@@ -120,6 +122,7 @@ class Credential:def is_hash(self) -> bool:return self.cred_type in (CredentialType.NTLM,+ CredentialType.HASH,CredentialType.KRB5_TGS,CredentialType.KRB5_ASREP,)@@ -166,6 +169,7 @@ class CredentialScorer:TYPE_SCORES: dict[CredentialType, float] = {CredentialType.CLEARTEXT: 2.0,CredentialType.NTLM: 1.5,+ CredentialType.HASH: 1.0,CredentialType.KRB5_TGT: 2.5,CredentialType.KRB5_TGS: 0.5, # uncracked; +1.5 if crackedCredentialType.KRB5_ASREP: 0.5, # uncracked; +1.5 if cracked@@ -449,7 +453,7 @@ class CredentialVault:"cleartext": CredentialType.CLEARTEXT,"password": CredentialType.CLEARTEXT,"ntlm": CredentialType.NTLM,- "hash": CredentialType.NTLM,+ "hash": CredentialType.HASH,"token": CredentialType.JWT,"jwt": CredentialType.JWT,"api_key": CredentialType.API_KEY,diff --git a/ares/modules/credential/crack.py b/ares/modules/credential/crack.pyindex 65ddadb..b5301b3 100644--- a/ares/modules/credential/crack.py+++ b/ares/modules/credential/crack.py@@ -271,6 +271,7 @@ class CrackModule(BaseModule[CredentialCrackParams, ModuleResult]):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))diff --git a/ares/modules/linux/sssd_harvest.py b/ares/modules/linux/sssd_harvest.pyindex 6d33954..d3d7c65 100644--- a/ares/modules/linux/sssd_harvest.py+++ b/ares/modules/linux/sssd_harvest.py@@ -34,6 +34,22 @@ from ares.sdk import (logger = get_logger("ares.modules.linux.sssd_harvest")+def _infer_credential_type(secret: str) -> Any:+ from ares.credential.vault import CredentialType++ if secret.startswith(("$6$", "$y$", "$5$", "$2b$", "$1$")):+ return CredentialType.HASH+ if secret.startswith(("aes256-cts", "rc4-hmac", "des-")):+ return getattr(CredentialType, "KERBEROS", CredentialType.KRB5_TGS)+ # Default to NTLM for 32-char hex string+ if len(secret) == 32 and all(c in "0123456789abcdefABCDEF" for c in secret):+ return CredentialType.NTLM+ # Default to HASH for hex/encoded string longer than 32 chars+ if len(secret) > 32 and all(c in "0123456789abcdefABCDEF" for c in secret):+ return CredentialType.HASH+ return CredentialType.CLEARTEXT++@module_contract(permissions=[FilesystemPermission(read_only=True),@@ -170,7 +186,7 @@ class SssdHarvestModule(BaseModule[SssdHarvestParams, ModuleResult]):campaign_id=campaign_id,username=acc.get("username", "unknown"),domain=acc.get("domain", target),- cred_type=CredentialType.NTLM if not h.startswith("$6$") else CredentialType.CLEARTEXT,+ cred_type=_infer_credential_type(h),privilege=(PrivilegeLevel.DOMAIN_ADMINif acc.get("is_domain_admin")@@ -258,11 +274,40 @@ class SssdHarvestModule(BaseModule[SssdHarvestParams, ModuleResult]):" - attack.t1003.008\n")+ users_list = [+ {+ "username": acc.get("username", ""),+ "domain": acc.get("domain", target),+ "is_admin": acc.get("is_domain_admin", False),+ }+ for acc in extracted_accounts+ ]+ all_hashes = [h for acc in extracted_accounts for h in acc.get("hashes", [])]+ hash_entries = [+ {+ "username": acc.get("username", ""),+ "domain": acc.get("domain", target),+ "hash": h,+ "secret": h,+ "host": target,+ "privilege": "domain_admin" if acc.get("is_domain_admin") else "domain_user",+ }+ for acc in extracted_accounts+ for h in acc.get("hashes", [])+ ]+await self.noise.jitter.sleep()return self._findings[:], {"target": target,"accounts_count": len(extracted_accounts),"stored_in_vault": stored_vault_count,+ # Dual-write: standard keys per KEY_CONVENTION_STANDARD.md+ "users": users_list,+ "domain_users": users_list,+ "hashes": all_hashes,+ "cached_hashes": hash_entries,+ "credentials": hash_entries,+ # Backward compatibility alias"accounts": extracted_accounts,"kql": kql_query,"sigma": sigma_rule,diff --git a/tests/unit/modules/test_linux_ad_tradecraft.py b/tests/unit/modules/test_linux_ad_tradecraft.pyindex 71dbd7e..3809ea1 100644--- a/tests/unit/modules/test_linux_ad_tradecraft.py+++ b/tests/unit/modules/test_linux_ad_tradecraft.py@@ -290,6 +290,86 @@ class TestSssdHarvestModule:assert f0.severity.value == "critical"assert "domain_admin" in f0.titleassert mock_vault.store.called+ call_args = mock_vault.store.call_args_list[0]+ cred_arg, hash_arg = call_args[0]+ from ares.credential.vault import CredentialType+ assert cred_arg.cred_type == CredentialType.HASH++ @pytest.mark.asyncio+ async def test_sssd_harvest_mod045_semantic_type_integrity(self):+ """MOD-045: Verify hashes ($6$) are stored as CredentialType.HASH, not CLEARTEXT,+ and standard output keys are dual-written for ArtifactNormalizer pipeline."""+ from ares.credential.vault import CredentialVault, CredentialType+ from ares.normalize.artifacts import ArtifactNormalizer, ArtifactStore++ vault = CredentialVault(encryption_key=None)+ module, _ = _make_module(SssdHarvestModule)++ with tempfile.TemporaryDirectory() as tmpdir:+ ldb_path = os.path.join(tmpdir, "cache_corp.local.ldb")+ records = [+ (+ b"name=da_user,cn=users,dc=corp,dc=local",+ (+ b"name: da_user\n"+ b"cachedPassword: $6$rounds=5000$salt$hash512\n"+ b"memberOf: cn=Domain Admins,cn=users,dc=corp,dc=local\n"+ ),+ ),+ (+ b"name=regular_user,cn=users,dc=corp,dc=local",+ (+ b"name: regular_user\n"+ b"cachedPassword: $y$j9T$salt$yescryptHash\n"+ ),+ ),+ ]+ with open(ldb_path, "wb") as f:+ f.write(_synthesize_tdb(records))++ ctx = _make_test_ctx(params={"db_path": tmpdir}, vault=vault)+ res = await module.execute(ctx)++ assert res.status == "success"+ assert res.raw["stored_in_vault"] == 2++ # 1. Verify credentials stored with CredentialType.HASH, not CLEARTEXT+ stored_creds = list(vault._store.values())+ assert len(stored_creds) == 2+ for c in stored_creds:+ assert c.cred_type == CredentialType.HASH, f"Expected HASH, got {c.cred_type}"+ assert c.is_hash is True++ # 2. Downstream safety: uncracked hashes are NOT returned for reuse/spray+ reuse_creds = vault.credentials_for_reuse(min_score=0.5)+ assert len(reuse_creds) == 0++ # When cracked, it becomes CLEARTEXT and available for reuse+ da_cred = next(c for c in stored_creds if c.username == "da_user")+ vault.mark_cracked(da_cred.id, "CrackedPassword123!")+ assert da_cred.cred_type == CredentialType.CLEARTEXT+ reuse_after_crack = vault.credentials_for_reuse(min_score=0.5)+ assert len(reuse_after_crack) == 1+ assert reuse_after_crack[0].username == "da_user"++ # 3. Output key dual-write: standard keys present alongside backward-compat alias+ assert "users" in res.raw+ assert "hashes" in res.raw+ assert "domain_users" in res.raw+ assert "cached_hashes" in res.raw+ assert "credentials" in res.raw+ assert "accounts" in res.raw++ # 4. End-to-end normalizer pipeline+ store = ArtifactStore()+ normalizer = ArtifactNormalizer()+ count = normalizer.normalize(+ module_id=module.MODULE_ID,+ outputs=module.OUTPUTS,+ raw=res.raw,+ store=store,+ )+ assert count >= 1# ─────────────────────────────────────────────────────────────────────────────