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.

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.py
index 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:password
NTLM = "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 alias
SSH_KEY = "ssh_key" # private key
API_KEY = "api_key" # cloud / service API key
JWT = "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 cracked
CredentialType.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.py
index 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.py
index 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_ADMIN
if 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.py
index 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.title
assert 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
# ─────────────────────────────────────────────────────────────────────────────