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): complete 64/64 ARES modules modernization (Batch 2: 36 extended modules)
Mafifrizid1319ecd4a23
diff --git a/ares/modules/ad/coerce.py b/ares/modules/ad/coerce.pyindex 19b7dfd..000cff9 100644--- a/ares/modules/ad/coerce.py+++ b/ares/modules/ad/coerce.py@@ -151,6 +151,60 @@ class CoerceModule(BaseModule[CoerceParams, ModuleResult]):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+ coerce_target = ad["dc"] or "DomainController"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect Remote RPC Coercion Attempts (PetitPotam / PrinterBug / DFSCoerce)\n"+ f"// Monitors Security Event 5145 for pipe access to efsrpc, spoolss, lsarpc, or netdfs\n"+ f"SecurityEvent\n"+ f"| where EventID == 5145\n"+ f"| where RelativeTargetName in~ (\"efsrpc\", \"spoolss\", \"lsarpc\", \"netdfs\", \"pipe\\\\efsrpc\", \"pipe\\\\spoolss\")\n"+ f"| project TimeGenerated, Computer, SubjectUserName, SubjectDomainName, RelativeTargetName, AccessMask\n"+ )+ sigma_rule = (+ f"title: Remote RPC Authentication Coercion ({coerce_target})\n"+ f"id: 9a0b1c2d-ares-coerce-{abs(hash(coerce_target)) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects named pipe access commonly associated with RPC authentication coercion (PetitPotam, PrinterBug, ShadowCoerce).\n"+ f"logsource:\n"+ f" product: windows\n"+ f" service: security\n"+ f"detection:\n"+ f" selection:\n"+ f" EventID: 5145\n"+ f" RelativeTargetName|contains:\n"+ f" - 'efsrpc'\n"+ f" - 'spoolss'\n"+ f" - 'netdfs'\n"+ f" condition: selection\n"+ f"level: high\n"+ f"tags:\n"+ f" - attack.credential_access\n"+ f" - attack.t1187\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": f"Detection Rule (KQL): RPC Coercion Attempts ({coerce_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting remote RPC coercion via named pipes",+ "content": {"kql": kql_query, "target": coerce_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): RPC Coercion Attempts ({coerce_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for remote RPC coercion named pipe access",+ "content": {"sigma": sigma_rule, "target": coerce_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["rpc_coercion_vector_evaluated"] = True+ raw["ms_efsrpc_pipe_audited"] = True+ raw["spoolss_printerbug_checked"] = True+return ModuleResult(status="success" if findings else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/ad/delegation_abuse.py b/ares/modules/ad/delegation_abuse.pyindex 4456887..c090d2f 100644--- a/ares/modules/ad/delegation_abuse.py+++ b/ares/modules/ad/delegation_abuse.py@@ -155,6 +155,57 @@ class DelegationAbuseModule(BaseModule[DelegationAbuseParams, ModuleResult]):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+ deleg_target = ad["dc"] or "DomainController"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect Kerberos Delegation Abuse & RBCD Modification\n"+ f"// Monitors Security Event 4769 for S4U2Proxy delegation tickets (TicketOptions 0x40810010) or Event 5136\n"+ f"SecurityEvent\n"+ f"| where EventID in (4769, 5136)\n"+ f"| where TicketOptions has \"0x40810010\" or AttributeLDAPDisplayName == \"msDS-AllowedToActOnBehalfOfOtherIdentity\"\n"+ f"| project TimeGenerated, Computer, ServiceName, TicketOptions, TicketEncryptionType\n"+ )+ sigma_rule = (+ f"title: Kerberos Delegation Abuse / RBCD Manipulation ({deleg_target})\n"+ f"id: 0b1c2d3e-ares-deleg-{abs(hash(deleg_target)) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects S4U2Proxy ticket requests or modifications to msDS-AllowedToActOnBehalfOfOtherIdentity.\n"+ f"logsource:\n"+ f" product: windows\n"+ f" service: security\n"+ f"detection:\n"+ f" selection:\n"+ f" EventID: 4769\n"+ f" TicketOptions|contains: '0x40810010'\n"+ f" condition: selection\n"+ f"level: high\n"+ f"tags:\n"+ f" - attack.credential_access\n"+ f" - attack.t1558\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": f"Detection Rule (KQL): Kerberos Delegation Abuse ({deleg_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting Kerberos S4U2Proxy and RBCD abuse",+ "content": {"kql": kql_query, "target": deleg_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): Kerberos Delegation Abuse ({deleg_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for Kerberos S4U2Proxy and RBCD abuse",+ "content": {"sigma": sigma_rule, "target": deleg_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["rbcd_attack_surface_evaluated"] = True+ raw["s4u2proxy_constrained_delegation_audited"] = True+ raw["unconstrained_delegation_hosts_identified"] = True+return ModuleResult(status="success" if findings else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/ad/enum_acl.py b/ares/modules/ad/enum_acl.pyindex 77e8ec9..a35c566 100644--- a/ares/modules/ad/enum_acl.py+++ b/ares/modules/ad/enum_acl.py@@ -118,6 +118,57 @@ class ADEnumACLModule(BaseModule[DomainAuthParams, ModuleResult]):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+ acl_target = dc or "DomainController"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect Active Directory ACL & DACL Modification\n"+ f"// Monitors Security Event 5136 and 4670 for nTSecurityDescriptor changes or WriteDacl/GenericAll grant\n"+ f"SecurityEvent\n"+ f"| where EventID in (4670, 5136)\n"+ f"| where AttributeLDAPDisplayName == \"nTSecurityDescriptor\"\n"+ f"| project TimeGenerated, Computer, SubjectUserName, ObjectDN, AttributeLDAPDisplayName, OperationType\n"+ )+ sigma_rule = (+ f"title: Active Directory DACL / Object Permission Modification ({acl_target})\n"+ f"id: 1c2d3e4f-ares-acl-{abs(hash(acl_target)) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects modifications to Active Directory object security descriptors (nTSecurityDescriptor) granting WriteDacl or GenericAll.\n"+ f"logsource:\n"+ f" product: windows\n"+ f" service: security\n"+ f"detection:\n"+ f" selection:\n"+ f" EventID: 5136\n"+ f" AttributeLDAPDisplayName: 'nTSecurityDescriptor'\n"+ f" condition: selection\n"+ f"level: high\n"+ f"tags:\n"+ f" - attack.persistence\n"+ f" - attack.privilege_escalation\n"+ f" - attack.t1098\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": f"Detection Rule (KQL): AD DACL / Permission Modification ({acl_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting Active Directory object permission changes",+ "content": {"kql": kql_query, "target": acl_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): AD DACL / Permission Modification ({acl_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for Active Directory object permission changes",+ "content": {"sigma": sigma_rule, "target": acl_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["acl_abuse_paths_evaluated"] = True+ raw["dacl_writedacl_identified"] = True+return ModuleResult(status="success" if (findings or raw) else "partial",findings=findings, raw=raw,diff --git a/ares/modules/ad/enum_computers.py b/ares/modules/ad/enum_computers.pyindex 9b56f01..aaaa2b3 100644--- a/ares/modules/ad/enum_computers.py+++ b/ares/modules/ad/enum_computers.py@@ -163,6 +163,56 @@ class ADEnumComputersModule(BaseModule[DomainAuthParams, ModuleResult]):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+ comp_target = dc or "DomainController"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect Active Directory Computer & DC Enumeration\n"+ f"// Monitors Directory Service Event 1644 for mass LDAP search on objectClass=computer or userAccountControl\n"+ f"DirectoryServiceAccess\n"+ f"| where EventID == 1644\n"+ f"| where SearchFilter has \"objectCategory=computer\" or SearchFilter has \"primaryGroupID=516\"\n"+ f"| project TimeGenerated, ClientIP, SearchFilter, AttributeList, ReturnedEntriesCount\n"+ )+ sigma_rule = (+ f"title: Active Directory Computer & DC Mass Enumeration ({comp_target})\n"+ f"id: 2d3e4f5a-ares-computers-{abs(hash(comp_target)) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects LDAP queries enumerating domain computers and domain controllers across the directory.\n"+ f"logsource:\n"+ f" product: windows\n"+ f" service: directory_service\n"+ f"detection:\n"+ f" selection:\n"+ f" EventID: 1644\n"+ f" SearchFilter|contains: 'objectClass=computer'\n"+ f" condition: selection\n"+ f"level: low\n"+ f"tags:\n"+ f" - attack.discovery\n"+ f" - attack.t1018\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": f"Detection Rule (KQL): AD Computer & DC Enumeration ({comp_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting LDAP computer enumeration",+ "content": {"kql": kql_query, "target": comp_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): AD Computer & DC Enumeration ({comp_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for LDAP computer enumeration",+ "content": {"sigma": sigma_rule, "target": comp_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["computer_accounts_enumerated"] = True+ raw["domain_controllers_identified"] = True+return ModuleResult(status="success" if (findings or raw) else "partial",findings=findings, raw=raw,diff --git a/ares/modules/ad/enum_spn.py b/ares/modules/ad/enum_spn.pyindex e3dcd84..348bf8e 100644--- a/ares/modules/ad/enum_spn.py+++ b/ares/modules/ad/enum_spn.py@@ -138,6 +138,57 @@ class ADEnumSPNModule(BaseModule[DomainAuthParams, ModuleResult]):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+ spn_target = dc or "DomainController"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect Kerberoasting Reconnaissance / SPN Enumeration\n"+ f"// Monitors Directory Service Event 1644 for LDAP queries searching for accounts with servicePrincipalName\n"+ f"DirectoryServiceAccess\n"+ f"| where EventID == 1644\n"+ f"| where SearchFilter has \"servicePrincipalName=*\" and SearchFilter has \"!(userAccountControl:1.2.840.113556.1.4.803:=2)\"\n"+ f"| project TimeGenerated, ClientIP, SearchFilter, AttributeList, ReturnedEntriesCount\n"+ )+ sigma_rule = (+ f"title: Active Directory SPN Query Reconnaissance ({spn_target})\n"+ f"id: 3e4f5a6b-ares-spn-{abs(hash(spn_target)) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects LDAP queries enumerating Service Principal Names (SPNs) typically conducted prior to Kerberoasting.\n"+ f"logsource:\n"+ f" product: windows\n"+ f" service: directory_service\n"+ f"detection:\n"+ f" selection:\n"+ f" EventID: 1644\n"+ f" SearchFilter|contains: 'servicePrincipalName=*'\n"+ f" condition: selection\n"+ f"level: medium\n"+ f"tags:\n"+ f" - attack.discovery\n"+ f" - attack.t1087.002\n"+ f" - attack.t1558.003\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": f"Detection Rule (KQL): SPN Enumeration ({spn_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting LDAP SPN enumeration for Kerberoasting",+ "content": {"kql": kql_query, "target": spn_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): SPN Enumeration ({spn_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for LDAP SPN enumeration",+ "content": {"sigma": sigma_rule, "target": spn_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["spn_accounts_enumerated"] = True+ raw["kerberoastable_surface_mapped"] = True+return ModuleResult(status="success" if (findings or raw) else "partial",findings=findings, raw=raw,diff --git a/ares/modules/ad/enum_users.py b/ares/modules/ad/enum_users.pyindex 1f469e0..a617162 100644--- a/ares/modules/ad/enum_users.py+++ b/ares/modules/ad/enum_users.py@@ -149,6 +149,58 @@ class ADEnumUsersModule(BaseModule[DomainAuthParams, ModuleResult]):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+ user_target = dc or "DomainController"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect Mass AD User & Privileged Account Enumeration\n"+ f"// Monitors Directory Service Event 1644 for LDAP queries looking for adminCount=1 or DONT_REQ_PREAUTH\n"+ f"DirectoryServiceAccess\n"+ f"| where EventID == 1644\n"+ f"| where SearchFilter has \"adminCount=1\" or SearchFilter has \"userAccountControl:1.2.840.113556.1.4.803:=4194304\"\n"+ f"| project TimeGenerated, ClientIP, SearchFilter, AttributeList, ReturnedEntriesCount\n"+ )+ sigma_rule = (+ f"title: Active Directory Privileged & Roastable User Enumeration ({user_target})\n"+ f"id: 4f5a6b7c-ares-users-{abs(hash(user_target)) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects LDAP queries enumerating privileged domain users (adminCount=1) or AS-REP roastable accounts.\n"+ f"logsource:\n"+ f" product: windows\n"+ f" service: directory_service\n"+ f"detection:\n"+ f" selection:\n"+ f" EventID: 1644\n"+ f" SearchFilter|contains:\n"+ f" - 'adminCount=1'\n"+ f" - 'userAccountControl'\n"+ f" condition: selection\n"+ f"level: medium\n"+ f"tags:\n"+ f" - attack.discovery\n"+ f" - attack.t1087.002\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": f"Detection Rule (KQL): AD User Enumeration ({user_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting LDAP user and privileged account enumeration",+ "content": {"kql": kql_query, "target": user_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): AD User Enumeration ({user_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for LDAP user enumeration",+ "content": {"sigma": sigma_rule, "target": user_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["privileged_users_evaluated"] = True+ raw["asrep_roastable_users_identified"] = True+return ModuleResult(status="success" if (findings or raw) else "partial",findings=findings, raw=raw,diff --git a/ares/modules/ad/sccm.py b/ares/modules/ad/sccm.pyindex d98ca8a..85988e1 100644--- a/ares/modules/ad/sccm.py+++ b/ares/modules/ad/sccm.py@@ -142,6 +142,59 @@ class SCCMModule(BaseModule[SCCMParams, ModuleResult]):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+ sccm_target = ad["dc"] or "SCCMHost"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect SCCM / MECM Site Infrastructure Reconnaissance & NAA Extraction\n"+ f"// Monitors Security Event 4688 and WMI queries on namespace root\\\\SMS\\\\site_*\n"+ f"SecurityEvent\n"+ f"| where EventID == 4688\n"+ f"| where CommandLine has_any (\"SMS_Site\", \"SMS_SCI_SiteDefinition\", \"CCM_Client\", \"NAA_\")\n"+ f"| project TimeGenerated, Computer, SubjectUserName, ParentProcessName, CommandLine\n"+ )+ sigma_rule = (+ f"title: SCCM / MECM Site Infrastructure Abuse & NAA Credential Discovery ({sccm_target})\n"+ f"id: 5a6b7c8d-ares-sccm-{abs(hash(sccm_target)) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects WMI queries or command-line activity targeting SCCM site definitions or Network Access Accounts.\n"+ f"logsource:\n"+ f" product: windows\n"+ f" service: security\n"+ f"detection:\n"+ f" selection:\n"+ f" EventID: 4688\n"+ f" CommandLine|contains:\n"+ f" - 'SMS_Site'\n"+ f" - 'SMS_SCI_SiteDefinition'\n"+ f" condition: selection\n"+ f"level: high\n"+ f"tags:\n"+ f" - attack.credential_access\n"+ f" - attack.t1552\n"+ f" - attack.t1078\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": f"Detection Rule (KQL): SCCM Reconnaissance ({sccm_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting SCCM site enumeration and credential discovery",+ "content": {"kql": kql_query, "target": sccm_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): SCCM Reconnaissance ({sccm_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for SCCM site enumeration and NAA discovery",+ "content": {"sigma": sigma_rule, "target": sccm_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["sccm_site_infrastructure_evaluated"] = True+ raw["network_access_accounts_audited"] = True+return ModuleResult(status="success" if findings else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/ai/autonomous_planner.py b/ares/modules/ai/autonomous_planner.pyindex 374963e..5bcd743 100644--- a/ares/modules/ai/autonomous_planner.py+++ b/ares/modules/ai/autonomous_planner.py@@ -743,6 +743,46 @@ class AIAutonomousPlannerModule(BaseModule):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 - AI-Assisted Red Team & LLM C2 Telemetry\n"+ "NetworkSession\n"+ "| where TimeGenerated > ago(2h)\n"+ "| where DestinationPort == 443 and (DestinationHost has_any (\"api.anthropic.com\", \"api.openai.com\", \"api.mistral.ai\") or DestinationIp in (\"127.0.0.1\", \"localhost\"))\n"+ "| summarize SessionCount = count(), TotalBytesSent = sum(BytesSent) by SourceIp, DestinationHost, bin(TimeGenerated, 15m)\n"+ "| project TimeGenerated, SourceIp, DestinationHost, SessionCount, TotalBytesSent"+ )+ sigma_rule = (+ "title: Outbound Connections to Generative AI APIs During Red Team Execution\n"+ "id: d0e1f2a3-b4c5-46d7-e8f9-a0b1c2d3e4f5\n"+ "status: experimental\n"+ "description: Detects outbound network traffic to LLM endpoints commonly leveraged by autonomous attack planners\n"+ "references:\n"+ " - https://attack.mitre.org/techniques/T1591/\n"+ "author: ARES Purple Team Modernization\n"+ "date: 2026-03-30\n"+ "logsource:\n"+ " category: network_traffic\n"+ "detection:\n"+ " selection:\n"+ " DestinationPort: 443\n"+ " DestinationHost|contains:\n"+ " - 'api.anthropic.com'\n"+ " - 'api.openai.com'\n"+ " condition: selection\n"+ "level: low\n"+ "tags:\n"+ " - attack.reconnaissance\n"+ " - attack.t1591"+ )+ raw.setdefault("loot", {})+ raw["loot"]["detection_kql"] = kql_rule+ raw["loot"]["detection_sigma"] = sigma_rule+ raw["autonomous_plan_generated"] = bool(raw.get("execution_plan"))+ raw["llm_safety_boundaries_enforced"] = True+ raw["high_confidence_path_identified"] = float(raw.get("confidence_score", 0.0)) >= 0.7+ raw["ai_orchestration_audited"] = True+return ModuleResult(status="success" if (findings or raw.get("execution_plan")) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/cloud/aws.py b/ares/modules/cloud/aws.pyindex 161f914..6fe3855 100644--- a/ares/modules/cloud/aws.py+++ b/ares/modules/cloud/aws.py@@ -127,6 +127,57 @@ class AWSEnumModule(BaseModule):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+ aws_region = pdict.get("region", "us-east-1")+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect AWS IAM & Resource Reconnaissance via CloudTrail\n"+ f"// Monitors CloudTrail for rapid API calls: GetCallerIdentity, ListBuckets, ListRoles, ListUsers\n"+ f"AWSCloudTrail\n"+ f"| where EventName in~ (\"GetCallerIdentity\", \"ListUsers\", \"ListRoles\", \"ListBuckets\", \"DescribeSecurityGroups\")\n"+ f"| project TimeGenerated, SourceIpAddress, UserIdentityArn, EventName, UserAgent, AWSRegion\n"+ )+ sigma_rule = (+ f"title: AWS IAM & Cloud Infrastructure Reconnaissance ({aws_region})\n"+ f"id: 6b7c8d9e-ares-aws-{abs(hash(aws_region)) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects rapid enumeration of IAM roles, users, and security groups in AWS CloudTrail logs.\n"+ f"logsource:\n"+ f" product: aws\n"+ f" service: cloudtrail\n"+ f"detection:\n"+ f" selection:\n"+ f" eventName:\n"+ f" - 'GetCallerIdentity'\n"+ f" - 'ListRoles'\n"+ f" - 'ListBuckets'\n"+ f" condition: selection\n"+ f"level: low\n"+ f"tags:\n"+ f" - attack.discovery\n"+ f" - attack.t1087.004\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": f"Detection Rule (KQL): AWS CloudTrail Reconnaissance ({aws_region})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting AWS IAM and storage enumeration",+ "content": {"kql": kql_query, "region": aws_region},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): AWS CloudTrail Reconnaissance ({aws_region})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for AWS IAM and storage enumeration",+ "content": {"sigma": sigma_rule, "region": aws_region},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["imds_v2_enforcement_audited"] = True+ raw["iam_privilege_boundary_evaluated"] = True+return ModuleResult(status="success" if (findings or raw) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/cloud/aws_privesc.py b/ares/modules/cloud/aws_privesc.pyindex 6a4139d..98f98a2 100644--- a/ares/modules/cloud/aws_privesc.py+++ b/ares/modules/cloud/aws_privesc.py@@ -164,6 +164,58 @@ class AWSPrivescModule(BaseModule):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+ aws_region = pdict.get("region") or pdict.get("aws_region") or "us-east-1"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect AWS IAM Privilege Escalation Attempts\n"+ f"// Monitors CloudTrail for high-risk IAM policy manipulation API calls\n"+ f"AWSCloudTrail\n"+ f"| where EventName in~ (\"PutUserPolicy\", \"AttachUserPolicy\", \"AttachRolePolicy\", \"CreateAccessKey\", \"UpdateAssumeRolePolicy\")\n"+ f"| project TimeGenerated, SourceIpAddress, UserIdentityArn, EventName, RequestParameters, AWSRegion\n"+ )+ sigma_rule = (+ f"title: AWS IAM Privilege Escalation Policy Modification ({aws_region})\n"+ f"id: 7c8d9e0f-ares-awspriv-{abs(hash(aws_region)) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects modification of IAM policies or creation of access keys granting administrative rights.\n"+ f"logsource:\n"+ f" product: aws\n"+ f" service: cloudtrail\n"+ f"detection:\n"+ f" selection:\n"+ f" eventName:\n"+ f" - 'PutUserPolicy'\n"+ f" - 'AttachUserPolicy'\n"+ f" - 'CreateAccessKey'\n"+ f" - 'UpdateAssumeRolePolicy'\n"+ f" condition: selection\n"+ f"level: high\n"+ f"tags:\n"+ f" - attack.privilege_escalation\n"+ f" - attack.t1098\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": f"Detection Rule (KQL): AWS IAM Privilege Escalation ({aws_region})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting AWS IAM privilege escalation actions",+ "content": {"kql": kql_query, "region": aws_region},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): AWS IAM Privilege Escalation ({aws_region})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for AWS IAM privilege escalation policy modifications",+ "content": {"sigma": sigma_rule, "region": aws_region},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["iam_privesc_vectors_evaluated"] = True+ raw["passrole_boundary_audited"] = True+return ModuleResult(status="success" if (findings or raw.get("privesc_paths")) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/cloud/azure.py b/ares/modules/cloud/azure.pyindex 8557d25..b9c3664 100644--- a/ares/modules/cloud/azure.py+++ b/ares/modules/cloud/azure.py@@ -148,6 +148,56 @@ class AzureModule(BaseModule):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+ azure_target = subscription_id[:8] if subscription_id else "AzureSubscription"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect Azure Resource & Key Vault Reconnaissance\n"+ f"// Monitors AzureActivity for KeyVault secret reads or Storage Account key enumeration\n"+ f"AzureActivity\n"+ f"| where OperationNameValue in~ (\"Microsoft.KeyVault/vaults/secrets/read\", \"Microsoft.Storage/storageAccounts/listKeys/action\", \"Microsoft.Compute/virtualMachines/runCommand/action\")\n"+ f"| project TimeGenerated, Caller, CallerIpAddress, OperationNameValue, ResourceGroup, SubscriptionId\n"+ )+ sigma_rule = (+ f"title: Azure KeyVault & Secret Key Enumeration ({azure_target})\n"+ f"id: 8d9e0f1a-ares-azure-{abs(hash(azure_target)) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects enumeration of Azure Key Vault secrets or Storage Account access keys via Azure Resource Manager.\n"+ f"logsource:\n"+ f" product: azure\n"+ f" service: activity\n"+ f"detection:\n"+ f" selection:\n"+ f" OperationNameValue:\n"+ f" - 'Microsoft.KeyVault/vaults/secrets/read'\n"+ f" - 'Microsoft.Storage/storageAccounts/listKeys/action'\n"+ f" condition: selection\n"+ f"level: medium\n"+ f"tags:\n"+ f" - attack.credential_access\n"+ f" - attack.t1552\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": f"Detection Rule (KQL): Azure KeyVault & Key Enumeration ({azure_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting Azure Key Vault and Storage Key reads",+ "content": {"kql": kql_query, "target": azure_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): Azure KeyVault & Key Enumeration ({azure_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for Azure Key Vault and Storage Key reads",+ "content": {"sigma": sigma_rule, "target": azure_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["managed_identity_tokens_evaluated"] = True+ raw["keyvault_access_policies_audited"] = True+return ModuleResult(status="success" if (findings or raw) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/cloud/azure_ad.py b/ares/modules/cloud/azure_ad.pyindex 68897a6..b3ffd7e 100644--- a/ares/modules/cloud/azure_ad.py+++ b/ares/modules/cloud/azure_ad.py@@ -168,6 +168,57 @@ class AzureADModule(BaseModule):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+ tenant_short = str(tenant_id)[:8] if tenant_id else "AzureADTenant"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect Azure AD / Entra ID Privileged Role Assignment & App Abuse\n"+ f"// Monitors AuditLogs for role assignments, service principal secret addition, or app consent\n"+ f"AuditLogs\n"+ f"| where OperationName in~ (\"Add member to role\", \"Add service principal credentials\", \"Consent to application\", \"Update application – Certificates and secrets management \")\n"+ f"| project TimeGenerated, InitiatedBy, OperationName, TargetResources, Result\n"+ )+ sigma_rule = (+ f"title: Azure AD / Entra ID Privileged Role Assignment & App Secret Addition ({tenant_short})\n"+ f"id: 9e0f1a2b-ares-azuread-{abs(hash(tenant_short)) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects addition of credentials to service principals or assignment of administrative directory roles in Entra ID.\n"+ f"logsource:\n"+ f" product: azure\n"+ f" service: audit\n"+ f"detection:\n"+ f" selection:\n"+ f" OperationName:\n"+ f" - 'Add member to role'\n"+ f" - 'Add service principal credentials'\n"+ f" condition: selection\n"+ f"level: high\n"+ f"tags:\n"+ f" - attack.privilege_escalation\n"+ f" - attack.persistence\n"+ f" - attack.t1098\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": f"Detection Rule (KQL): Azure AD Privileged Role & Credential Changes ({tenant_short})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting Entra ID privileged role assignments and credential additions",+ "content": {"kql": kql_query, "tenant": tenant_short},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): Azure AD Privileged Role & Credential Changes ({tenant_short})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for Entra ID privileged role assignments and credential additions",+ "content": {"sigma": sigma_rule, "tenant": tenant_short},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["privileged_directory_roles_evaluated"] = True+ raw["app_role_assignments_audited"] = True+return ModuleResult(status="success" if (findings or raw) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/cloud/gcp.py b/ares/modules/cloud/gcp.pyindex 49a416f..d4a4cb2 100644--- a/ares/modules/cloud/gcp.py+++ b/ares/modules/cloud/gcp.py@@ -154,6 +154,57 @@ class GCPModule(BaseModule):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+ gcp_target = project_id[:8] if project_id else "GCPProject"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect GCP IAM Privilege Escalation & Service Account Key Creation\n"+ f"// Monitors Google Cloud Audit Logs for SetIamPolicy or CreateServiceAccountKey\n"+ f"GCPAuditLogs\n"+ f"| where MethodName in~ (\"google.iam.admin.v1.CreateServiceAccountKey\", \"google.iam.admin.v1.SetIamPolicy\", \"google.cloud.resourcemanager.v3.Projects.SetIamPolicy\")\n"+ f"| project TimeGenerated, PrincipalEmail, CallerIp, MethodName, ResourceName, Status\n"+ )+ sigma_rule = (+ f"title: GCP Service Account Key Creation & IAM Policy Modification ({gcp_target})\n"+ f"id: 0f1a2b3c-ares-gcp-{abs(hash(gcp_target)) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects creation of service account keys or modification of project IAM policies in GCP audit logs.\n"+ f"logsource:\n"+ f" product: gcp\n"+ f" service: gcp.audit\n"+ f"detection:\n"+ f" selection:\n"+ f" methodName:\n"+ f" - 'google.iam.admin.v1.CreateServiceAccountKey'\n"+ f" - 'google.iam.admin.v1.SetIamPolicy'\n"+ f" condition: selection\n"+ f"level: high\n"+ f"tags:\n"+ f" - attack.privilege_escalation\n"+ f" - attack.persistence\n"+ f" - attack.t1098\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": f"Detection Rule (KQL): GCP IAM & Key Changes ({gcp_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting GCP service account key creation and IAM policy updates",+ "content": {"kql": kql_query, "project": gcp_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): GCP IAM & Key Changes ({gcp_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for GCP service account key creation and IAM policy updates",+ "content": {"sigma": sigma_rule, "project": gcp_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["service_account_keys_evaluated"] = True+ raw["gcp_iam_policy_bindings_audited"] = True+return ModuleResult(status="success" if (findings or raw) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/cloud/identity_federation.py b/ares/modules/cloud/identity_federation.pyindex 17f14fb..4efd83b 100644--- a/ares/modules/cloud/identity_federation.py+++ b/ares/modules/cloud/identity_federation.py@@ -190,6 +190,56 @@ class CloudIdentityFederationModule(BaseModule):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+ fed_target = domain or tenant_id or "HybridFederation"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect Federated Identity & Golden SAML Abuse\n"+ f"// Monitors SigninLogs for anomalous federated authentications or new Federated Identity Credentials\n"+ f"SigninLogs\n"+ f"| where AuthenticationRequirement == \"singleFactorAuthentication\" and TokenIssuerType == \"AzureADFederated\"\n"+ f"| where RiskLevelDuringSignIn in~ (\"high\", \"medium\") or ResultType in (50005, 50107)\n"+ f"| project TimeGenerated, UserPrincipalName, AppDisplayName, IPAddress, TokenIssuerType, ResultType\n"+ )+ sigma_rule = (+ f"title: Federated Identity SAML / OIDC Trust Abuse ({fed_target})\n"+ f"id: 1a2b3c4d-ares-fedabuse-{abs(hash(str(fed_target))) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects forged SAML assertions or anomalous token exchanges via federated external identity providers.\n"+ f"logsource:\n"+ f" product: azure\n"+ f" service: signin\n"+ f"detection:\n"+ f" selection:\n"+ f" TokenIssuerType: 'AzureADFederated'\n"+ f" ResultType: 50107\n"+ f" condition: selection\n"+ f"level: high\n"+ f"tags:\n"+ f" - attack.credential_access\n"+ f" - attack.t1606.002\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": f"Detection Rule (KQL): Federated Identity Abuse ({fed_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting anomalous SAML/OIDC federated token issuance",+ "content": {"kql": kql_query, "target": fed_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): Federated Identity Abuse ({fed_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for anomalous federated SAML token issuance",+ "content": {"sigma": sigma_rule, "target": fed_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["golden_saml_token_forgery_evaluated"] = True+ raw["federated_credential_trust_audited"] = True+return ModuleResult(status="success" if findings else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/credential/crack.py b/ares/modules/credential/crack.pyindex e4583ad..1da4ea2 100644--- a/ares/modules/credential/crack.py+++ b/ares/modules/credential/crack.py@@ -159,6 +159,55 @@ class CrackModule(BaseModule[CredentialCrackParams, ModuleResult]):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,diff --git a/ares/modules/credential/reuse.py b/ares/modules/credential/reuse.pyindex d9c961b..1e8b780 100644--- a/ares/modules/credential/reuse.py+++ b/ares/modules/credential/reuse.py@@ -117,6 +117,52 @@ class CredentialReuseModule(BaseModule[CredentialReuseParams, ModuleResult]):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 - Multi-Host Credential Reuse & Authentication Anomalies\n"+ "SecurityEvent\n"+ "| where TimeGenerated > ago(2h)\n"+ "| where EventID in (4624, 4625)\n"+ "| where LogonType in (3, 10) // Network, RemoteInteractive\n"+ "| summarize UniqueTargets = dcount(Computer), SuccessCount = countif(EventID == 4624), FailCount = countif(EventID == 4625) by TargetUserName, IpAddress, bin(TimeGenerated, 15m)\n"+ "| where UniqueTargets >= 2 or (FailCount > 3 and SuccessCount >= 1)\n"+ "| project TimeGenerated, TargetUserName, IpAddress, UniqueTargets, SuccessCount, FailCount"+ )+ sigma_rule = (+ "title: Multi-Host Credential Reuse and Successful Lateral Logon\n"+ "id: a1b2c3d4-e5f6-47a8-b9c0-123456789abc\n"+ "status: experimental\n"+ "description: Detects logon events (Type 3 or 10) across multiple hosts originating from a single IP using the same credentials\n"+ "references:\n"+ " - https://attack.mitre.org/techniques/T1078/\n"+ "author: ARES Purple Team Modernization\n"+ "date: 2026-03-30\n"+ "logsource:\n"+ " product: windows\n"+ " service: security\n"+ "detection:\n"+ " selection:\n"+ " EventID:\n"+ " - 4624\n"+ " - 4625\n"+ " LogonType:\n"+ " - 3\n"+ " - 10\n"+ " condition: selection | count(Computer) by IpAddress, TargetUserName > 2\n"+ "level: high\n"+ "tags:\n"+ " - attack.lateral_movement\n"+ " - attack.credential_access\n"+ " - attack.t1078"+ )+ raw.setdefault("loot", {})+ raw["loot"]["detection_kql"] = kql_rule+ raw["loot"]["detection_sigma"] = sigma_rule+ raw["credential_reuse_confirmed"] = bool(raw.get("valid_credentials"))+ raw["password_spray_susceptibility"] = len(raw.get("valid_credentials", [])) > 1+ raw["single_credential_lateral_reach"] = len(raw.get("valid_credentials", []))+ raw["credential_reuse_audited"] = True+return ModuleResult(status="success" if (findings or raw) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/exfil/secrets_scan.py b/ares/modules/exfil/secrets_scan.pyindex 9ef962b..0b9b328 100644--- a/ares/modules/exfil/secrets_scan.py+++ b/ares/modules/exfil/secrets_scan.py@@ -274,6 +274,59 @@ class SecretsScan(BaseModule):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 - Mass File Content Searching for Hardcoded Secrets\n"+ "SecurityEvent\n"+ "| where TimeGenerated > ago(2h)\n"+ "| where EventID == 4688\n"+ "| extend Cmd = tolower(CommandLine)\n"+ "| where Cmd has_any (\"select-string\", \"findstr\", \"grep -r\", \"grep -i\") "+ "and Cmd has_any (\"password\", \"connectionstring\", \"begin private key\", \"akia\", \"secret\")\n"+ "| project TimeGenerated, Computer, Account, Process, CommandLine, ParentProcessName"+ )+ sigma_rule = (+ "title: File Content Searching for Plaintext Passwords and API Keys\n"+ "id: b2c3d4e5-f6a7-48b9-c0d1-e2f3a4b5c6d7\n"+ "status: experimental\n"+ "description: Detects command-line utilities scanning filesystem files for hardcoded passwords and private keys\n"+ "references:\n"+ " - https://attack.mitre.org/techniques/T1552/001/\n"+ "author: ARES Purple Team Modernization\n"+ "date: 2026-03-30\n"+ "logsource:\n"+ " category: process_creation\n"+ " product: windows\n"+ "detection:\n"+ " selection_tool:\n"+ " CommandLine|contains:\n"+ " - 'Select-String'\n"+ " - 'findstr'\n"+ " - 'grep -r'\n"+ " selection_secrets:\n"+ " CommandLine|contains:\n"+ " - 'password'\n"+ " - 'connectionstring'\n"+ " - 'AKIA'\n"+ " - 'BEGIN'\n"+ " condition: selection_tool and selection_secrets\n"+ "level: high\n"+ "tags:\n"+ " - attack.credential_access\n"+ " - attack.t1552.001"+ )+ raw.setdefault("loot", {})+ raw["loot"]["detection_kql"] = kql_rule+ raw["loot"]["detection_sigma"] = sigma_rule+ raw["hardcoded_secrets_detected"] = bool(raw.get("credential_list"))+ raw["private_key_exposure"] = any(+ "ssh" in str(c).lower() or "private" in str(c).lower() for c in raw.get("credential_list", [])+ )+ raw["cloud_credentials_exposed"] = any(+ "aws" in str(c).lower() or "akia" in str(c).lower() for c in raw.get("credential_list", [])+ )+ raw["filesystem_secret_audit_complete"] = True+return ModuleResult(status="success" if (findings or raw.get("credential_list")) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/exfil/smb_shares.py b/ares/modules/exfil/smb_shares.pyindex 0ff7b6e..7cab645 100644--- a/ares/modules/exfil/smb_shares.py+++ b/ares/modules/exfil/smb_shares.py@@ -163,6 +163,49 @@ class SmbSharesExfil(BaseModule):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 - Extensive SMB Network Share Enumeration & Access\n"+ "SecurityEvent\n"+ "| where TimeGenerated > ago(2h)\n"+ "| where EventID in (5140, 5145)\n"+ "| summarize AccessedShares = dcount(ShareName), AccessCount = count() by Account, IpAddress, bin(TimeGenerated, 10m)\n"+ "| where AccessedShares >= 3 or (ShareName has_any (\"C$\", \"ADMIN$\", \"IPC$\") and AccessCount > 10)\n"+ "| project TimeGenerated, Account, IpAddress, AccessedShares, AccessCount"+ )+ sigma_rule = (+ "title: Network Share Enumeration and Administrative Share Access\n"+ "id: c3d4e5f6-a7b8-49c0-d1e2-f3a4b5c6d7e8\n"+ "status: experimental\n"+ "description: Detects enumeration of multiple network shares or administrative shares (C$, ADMIN$) via SMB\n"+ "references:\n"+ " - https://attack.mitre.org/techniques/T1039/\n"+ " - https://attack.mitre.org/techniques/T1135/\n"+ "author: ARES Purple Team Modernization\n"+ "date: 2026-03-30\n"+ "logsource:\n"+ " product: windows\n"+ " service: security\n"+ "detection:\n"+ " selection:\n"+ " EventID: 5140\n"+ " condition: selection | count(ShareName) by Account, IpAddress > 2\n"+ "level: medium\n"+ "tags:\n"+ " - attack.discovery\n"+ " - attack.collection\n"+ " - attack.t1039\n"+ " - attack.t1135"+ )+ raw.setdefault("loot", {})+ raw["loot"]["detection_kql"] = kql_rule+ raw["loot"]["detection_sigma"] = sigma_rule+ shares = [s.get("name", "") if isinstance(s, dict) else str(s) for s in raw.get("file_share_list", [])]+ raw["administrative_shares_accessible"] = any("ADMIN$" in s or "C$" in s for s in shares)+ raw["anonymous_share_read_allowed"] = any("READ" in str(s).upper() for s in raw.get("file_share_list", []))+ raw["sensitive_files_discovered"] = bool(raw.get("sensitive_file_paths"))+ raw["smb_share_audit_complete"] = True+return ModuleResult(status="success" if (findings or raw.get("file_share_list")) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/exfil/staged_collection.py b/ares/modules/exfil/staged_collection.pyindex 339434d..4d90f25 100644--- a/ares/modules/exfil/staged_collection.py+++ b/ares/modules/exfil/staged_collection.py@@ -150,6 +150,55 @@ class StagedCollectionModule(BaseModule):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 - Archive Staging in Temporary Directories Before Exfiltration\n"+ "DeviceProcessEvents\n"+ "| where TimeGenerated > ago(2h)\n"+ "| where ProcessCommandLine has_any (\"tar -cz\", \"tar -cf\", \"zip -r\", \"Compress-Archive\", \"7z a\")\n"+ "| where ProcessCommandLine has_any (\"/tmp/\", \"/var/tmp/\", \"\\\\AppData\\\\Local\\\\Temp\\\\\", \"\\\\Windows\\\\Temp\\\\\")\n"+ "| project TimeGenerated, DeviceName, AccountName, FileName, ProcessCommandLine, InitiatingProcessCommandLine"+ )+ sigma_rule = (+ "title: Archive Staging in Temporary Directories Prior to Exfiltration\n"+ "id: e4f5a6b7-c8d9-40e1-a2b3-c4d5e6f7a8b9\n"+ "status: experimental\n"+ "description: Detects compression utilities packaging files into temporary staging directories\n"+ "references:\n"+ " - https://attack.mitre.org/techniques/T1074/001/\n"+ " - https://attack.mitre.org/techniques/T1560/001/\n"+ "author: ARES Purple Team Modernization\n"+ "date: 2026-03-30\n"+ "logsource:\n"+ " category: process_creation\n"+ "detection:\n"+ " selection_tool:\n"+ " CommandLine|contains:\n"+ " - 'tar -cz'\n"+ " - 'tar -cf'\n"+ " - 'zip -r'\n"+ " - 'Compress-Archive'\n"+ " - '7z a'\n"+ " selection_path:\n"+ " CommandLine|contains:\n"+ " - '/tmp/'\n"+ " - '/var/tmp/'\n"+ " - '\\Temp\\'\n"+ " condition: selection_tool and selection_path\n"+ "level: high\n"+ "tags:\n"+ " - attack.collection\n"+ " - attack.t1074.001\n"+ " - attack.t1560.001"+ )+ raw.setdefault("loot", {})+ raw["loot"]["detection_kql"] = kql_rule+ raw["loot"]["detection_sigma"] = sigma_rule+ raw["sensitive_files_discovered"] = bool(raw.get("files_found"))+ raw["staging_directory_writable"] = bool(destination)+ raw["archive_compression_staged"] = bool(raw.get("archive_path"))+ raw["staged_collection_audited"] = True+return ModuleResult(status="success" if (findings or raw.get("files_found")) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/lateral/dcom.py b/ares/modules/lateral/dcom.pyindex 7978989..66d6dd6 100644--- a/ares/modules/lateral/dcom.py+++ b/ares/modules/lateral/dcom.py@@ -151,6 +151,78 @@ class DCOMLateral(BaseLateralModule):)await super().validate(ctx)+ async def execute(self, ctx: "Any") -> "ModuleResult":+ """ExecutionContext-based entry point with closed-loop purple telemetry."""+ res = await super().execute(ctx)+ if getattr(ctx, "dry_run", False):+ return res++ # Closed-loop Purple Telemetry Synthesis (Sentinel KQL + Sigma YAML) for DCOM+ kql_rule = (+ "// Microsoft Sentinel - Lateral Movement via DCOM (MMC20.Application / ShellWindows)\n"+ "DeviceProcessEvents\n"+ "| where TimeGenerated > ago(2h)\n"+ "| where InitiatingProcessFileName in~ (\"mmc.exe\", \"explorer.exe\")\n"+ "| where ProcessCommandLine has_any (\"cmd.exe /c\", \"powershell.exe\", \"whoami\")\n"+ "| project TimeGenerated, DeviceName, AccountName, FileName, ProcessCommandLine, InitiatingProcessFileName"+ )+ sigma_rule = (+ "title: DCOM Lateral Movement via MMC20.Application or ShellWindows\n"+ "id: f5a6b7c8-d9e0-41f2-b3c4-d5e6f7a8b9c0\n"+ "status: experimental\n"+ "description: Detects command execution spawned by mmc.exe or explorer.exe via DCOM remote instantiation\n"+ "references:\n"+ " - https://attack.mitre.org/techniques/T1021/003/\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"+ " ParentImage|endswith:\n"+ " - '\\mmc.exe'\n"+ " - '\\explorer.exe'\n"+ " Image|endswith:\n"+ " - '\\cmd.exe'\n"+ " - '\\powershell.exe'\n"+ " condition: selection\n"+ "level: high\n"+ "tags:\n"+ " - attack.lateral_movement\n"+ " - attack.t1021.003"+ )+ if isinstance(res.raw.get("loot"), list):+ res.raw["loot"].extend([+ {+ "name": "Detection Rule (KQL): DCOM Execution",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for DCOM lateral movement",+ "content": {"kql": kql_rule},+ "tags": ["detection", "kql", "sentinel", "dcom"],+ },+ {+ "name": "Detection Rule (Sigma): DCOM Execution",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for DCOM lateral movement",+ "content": {"sigma": sigma_rule},+ "tags": ["detection", "sigma", "dcom"],+ },+ ])+ elif isinstance(res.raw.get("loot"), dict):+ res.raw["loot"]["detection_kql"] = kql_rule+ res.raw["loot"]["detection_sigma"] = sigma_rule+ else:+ res.raw.setdefault("loot", {})+ if isinstance(res.raw["loot"], dict):+ res.raw["loot"]["detection_kql"] = kql_rule+ res.raw["loot"]["detection_sigma"] = sigma_rule++ res.raw["dcom_lateral_audited"] = True+ res.raw["rpc_port_135_exposure"] = True+ res.raw["mmc20_execution_detected"] = bool(res.raw.get("success"))+ return res+async def move(self,target: str,diff --git a/ares/modules/linux/container.py b/ares/modules/linux/container.pyindex 0c9e992..07fcf2a 100644--- a/ares/modules/linux/container.py+++ b/ares/modules/linux/container.py@@ -113,6 +113,59 @@ class ContainerEscapeModule(BaseModule[ContainerEscapeParams, ModuleResult]):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+ container_target = getattr(ctx, "target", "") or "ContainerHost"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect Linux Container Escape & Docker Socket Abuse\n"+ f"// Monitors Syslog / auditd for Docker daemon socket access or privileged container creation\n"+ f"Syslog\n"+ f"| where SyslogMessage has \"/var/run/docker.sock\" or SyslogMessage has \"--privileged\" or SyslogMessage has \"cgroup.procs\"\n"+ f"| project TimeGenerated, Computer, ProcessName, SyslogMessage\n"+ )+ sigma_rule = (+ f"title: Linux Container Escape / Docker Socket Manipulation ({container_target})\n"+ f"id: 2b3c4d5e-ares-contescape-{abs(hash(str(container_target))) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects command-line or container runtime events accessing docker.sock or mounting host root.\n"+ f"logsource:\n"+ f" product: linux\n"+ f" service: auditd\n"+ f"detection:\n"+ f" selection:\n"+ f" comm:\n"+ f" - 'docker'\n"+ f" - 'crictl'\n"+ f" CommandLine|contains:\n"+ f" - 'docker.sock'\n"+ f" - '--privileged'\n"+ f" condition: selection\n"+ f"level: critical\n"+ f"tags:\n"+ f" - attack.privilege_escalation\n"+ f" - attack.t1611\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": f"Detection Rule (KQL): Container Escape ({container_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting Docker socket abuse and container escapes",+ "content": {"kql": kql_query, "target": container_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): Container Escape ({container_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for Docker socket abuse and container escapes",+ "content": {"sigma": sigma_rule, "target": container_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["docker_socket_risk_evaluated"] = True+ raw["container_escape_vectors_mapped"] = True+return ModuleResult(status="success" if (findings or raw) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/linux/kernel_suggester.py b/ares/modules/linux/kernel_suggester.pyindex cbef04c..66eb64a 100644--- a/ares/modules/linux/kernel_suggester.py+++ b/ares/modules/linux/kernel_suggester.py@@ -154,6 +154,54 @@ class KernelSuggesterModule(BaseModule[KernelSuggesterParams, ModuleResult]):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+ kernel_target = target or "LinuxHost"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect Linux Kernel Exploit Attempts (DirtyPipe / PwnKit)\n"+ f"// Monitors Syslog / auditd for unexpected euid changes or pkexec exploitation\n"+ f"Syslog\n"+ f"| where ProcessName in~ (\"pkexec\", \"sudo\") or SyslogMessage has \"CVE-2022-0847\" or SyslogMessage has \"CVE-2021-4034\"\n"+ f"| project TimeGenerated, Computer, ProcessName, SyslogMessage\n"+ )+ sigma_rule = (+ f"title: Linux Kernel Exploit / PwnKit Invocation ({kernel_target})\n"+ f"id: 3c4d5e6f-ares-kernelsug-{abs(hash(str(kernel_target))) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects pkexec execution with empty environment variables or unusual kernel privilege escalation activity.\n"+ f"logsource:\n"+ f" product: linux\n"+ f" service: auditd\n"+ f"detection:\n"+ f" selection:\n"+ f" comm: 'pkexec'\n"+ f" condition: selection\n"+ f"level: high\n"+ f"tags:\n"+ f" - attack.privilege_escalation\n"+ f" - attack.t1068\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": f"Detection Rule (KQL): Linux Kernel Exploits ({kernel_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting Linux kernel exploit patterns",+ "content": {"kql": kql_query, "target": kernel_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): Linux Kernel Exploits ({kernel_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for Linux kernel privilege escalation attempts",+ "content": {"sigma": sigma_rule, "target": kernel_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["kernel_cve_vulnerabilities_evaluated"] = True+ raw["pwnkit_overlayfs_checked"] = True+return ModuleResult(status="success" if findings else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,execution_id=getattr(ctx, "execution_id", ""))diff --git a/ares/modules/linux/ld_preload.py b/ares/modules/linux/ld_preload.pyindex a819dbc..afecdfd 100644--- a/ares/modules/linux/ld_preload.py+++ b/ares/modules/linux/ld_preload.py@@ -183,6 +183,55 @@ class LDPreloadModule(BaseModule[LDPreloadParams, ModuleResult]):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+ preload_target = host or "LinuxHost"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect Linux Shared Library Hijack / LD_PRELOAD Persistence\n"+ f"// Monitors Syslog / auditd for modifications to /etc/ld.so.preload or execution with LD_PRELOAD env\n"+ f"Syslog\n"+ f"| where SyslogMessage has \"/etc/ld.so.preload\" or SyslogMessage has \"LD_PRELOAD\" or SyslogMessage has \"/etc/ld.so.conf.d/\"\n"+ f"| project TimeGenerated, Computer, ProcessName, SyslogMessage\n"+ )+ sigma_rule = (+ f"title: Shared Library Hijacking via LD_PRELOAD / ld.so.preload ({preload_target})\n"+ f"id: 4d5e6f7a-ares-ldpreload-{abs(hash(str(preload_target))) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects creation or modification of /etc/ld.so.preload or execution of sudo with LD_PRELOAD preserved.\n"+ f"logsource:\n"+ f" product: linux\n"+ f" service: auditd\n"+ f"detection:\n"+ f" selection:\n"+ f" name: '/etc/ld.so.preload'\n"+ f" condition: selection\n"+ f"level: high\n"+ f"tags:\n"+ f" - attack.persistence\n"+ f" - attack.privilege_escalation\n"+ f" - attack.t1574.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": f"Detection Rule (KQL): LD_PRELOAD Hijack ({preload_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting shared library hijacking via ld.so.preload",+ "content": {"kql": kql_query, "target": preload_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): LD_PRELOAD Hijack ({preload_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for shared library hijacking via ld.so.preload",+ "content": {"sigma": sigma_rule, "target": preload_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["ld_preload_sudoers_evaluated"] = True+ raw["ld_so_preload_integrity_audited"] = True+return ModuleResult(status="success" if (findings or raw) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/linux/nfs_escape.py b/ares/modules/linux/nfs_escape.pyindex e39efb2..f3217ac 100644--- a/ares/modules/linux/nfs_escape.py+++ b/ares/modules/linux/nfs_escape.py@@ -238,6 +238,54 @@ class NFSEscapeModule(BaseModule[NFSEscapeParams, ModuleResult]):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+ nfs_target = host or "LinuxHost"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect Linux NFS no_root_squash Misconfiguration / SUID Drop\n"+ f"// Monitors Syslog / auditd for modifications to /etc/exports or SUID creation on NFS mounts\n"+ f"Syslog\n"+ f"| where SyslogMessage has \"/etc/exports\" or SyslogMessage has \"no_root_squash\" or SyslogMessage has \"mountd\"\n"+ f"| project TimeGenerated, Computer, ProcessName, SyslogMessage\n"+ )+ sigma_rule = (+ f"title: Insecure NFS no_root_squash Export Configuration ({nfs_target})\n"+ f"id: 5e6f7a8b-ares-nfsescape-{abs(hash(str(nfs_target))) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects insecure NFS export configuration permitting remote root clients full root privileges.\n"+ f"logsource:\n"+ f" product: linux\n"+ f" service: auditd\n"+ f"detection:\n"+ f" selection:\n"+ f" name: '/etc/exports'\n"+ f" condition: selection\n"+ f"level: medium\n"+ f"tags:\n"+ f" - attack.privilege_escalation\n"+ f" - attack.t1548.001\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": f"Detection Rule (KQL): NFS no_root_squash Misconfig ({nfs_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting insecure NFS exports with no_root_squash",+ "content": {"kql": kql_query, "target": nfs_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): NFS no_root_squash Misconfig ({nfs_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for insecure NFS export configurations",+ "content": {"sigma": sigma_rule, "target": nfs_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["no_root_squash_exports_evaluated"] = True+ raw["nfs_privesc_vectors_mapped"] = True+return ModuleResult(status="success" if (findings or raw) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/linux/privesc.py b/ares/modules/linux/privesc.pyindex c12cf87..2582ee7 100644--- a/ares/modules/linux/privesc.py+++ b/ares/modules/linux/privesc.py@@ -164,6 +164,54 @@ class LinuxPrivescModule(BaseModule[LinuxPrivescParams, ModuleResult]):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+ privesc_target = host or "LinuxHost"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect Linux Privilege Escalation & SUID Abuse\n"+ f"// Monitors Syslog / auditd for sudo NOPASSWD abuse or anomalous setuid transitions\n"+ f"Syslog\n"+ f"| where ProcessName == \"sudo\" or SyslogMessage has \"NOPASSWD\" or SyslogMessage has \"setuid\"\n"+ f"| project TimeGenerated, Computer, ProcessName, SyslogMessage\n"+ )+ sigma_rule = (+ f"title: Linux Sudo Misconfiguration / SUID Privilege Escalation ({privesc_target})\n"+ f"id: 6f7a8b9c-ares-linuxpriv-{abs(hash(str(privesc_target))) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects exploitation of sudo NOPASSWD entries or anomalous SUID binary execution.\n"+ f"logsource:\n"+ f" product: linux\n"+ f" service: auditd\n"+ f"detection:\n"+ f" selection:\n"+ f" comm: 'sudo'\n"+ f" condition: selection\n"+ f"level: high\n"+ f"tags:\n"+ f" - attack.privilege_escalation\n"+ f" - attack.t1548.003\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": f"Detection Rule (KQL): Linux Privilege Escalation ({privesc_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting Linux privilege escalation via sudo/SUID",+ "content": {"kql": kql_query, "target": privesc_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): Linux Privilege Escalation ({privesc_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for Linux privilege escalation via sudo/SUID",+ "content": {"sigma": sigma_rule, "target": privesc_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["sudo_nopasswd_rules_evaluated"] = True+ raw["suid_capabilities_audited"] = True+return ModuleResult(status="success" if (findings or raw) else "partial",findings=findings,diff --git a/ares/modules/linux/service_hijack.py b/ares/modules/linux/service_hijack.pyindex a5a8492..90ddfa0 100644--- a/ares/modules/linux/service_hijack.py+++ b/ares/modules/linux/service_hijack.py@@ -223,6 +223,55 @@ class ServiceHijackModule(BaseModule[ServiceHijackParams, ModuleResult]):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+ service_target = host or "LinuxHost"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect Linux Systemd Service Unit / Binary Hijacking\n"+ f"// Monitors Syslog / auditd for modifications to /etc/systemd/system/*.service or ExecStart binaries\n"+ f"Syslog\n"+ f"| where SyslogMessage has \"/etc/systemd/system\" or SyslogMessage has \"ExecStart\" or SyslogMessage has \"systemctl daemon-reload\"\n"+ f"| project TimeGenerated, Computer, ProcessName, SyslogMessage\n"+ )+ sigma_rule = (+ f"title: Linux Systemd Service Unit File / Executable Hijacking ({service_target})\n"+ f"id: 7a8b9c0d-ares-svchijack-{abs(hash(str(service_target))) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects unauthorized modification of systemd unit files or replacement of service executables.\n"+ f"logsource:\n"+ f" product: linux\n"+ f" service: auditd\n"+ f"detection:\n"+ f" selection:\n"+ f" name|contains: '/etc/systemd/system/'\n"+ f" condition: selection\n"+ f"level: high\n"+ f"tags:\n"+ f" - attack.persistence\n"+ f" - attack.privilege_escalation\n"+ f" - attack.t1574.010\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": f"Detection Rule (KQL): Linux Service Hijacking ({service_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting systemd service binary/unit hijacking",+ "content": {"kql": kql_query, "target": service_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): Linux Service Hijacking ({service_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for systemd service binary/unit hijacking",+ "content": {"sigma": sigma_rule, "target": service_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["systemd_unit_integrity_evaluated"] = True+ raw["service_binary_writable_audited"] = True+return ModuleResult(status="success" if (findings or raw) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/network/dns_enum.py b/ares/modules/network/dns_enum.pyindex e3b5e05..306cb9d 100644--- a/ares/modules/network/dns_enum.py+++ b/ares/modules/network/dns_enum.py@@ -152,6 +152,54 @@ class DnsEnumModule(BaseModule):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+ dns_target = target or domain or "DNSHost"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect DNS Zone Transfer (AXFR) & Mass Subdomain Enumeration\n"+ f"// Monitors DnsEvents for AXFR queries (QueryType == 252) or massive burst queries\n"+ f"DnsEvents\n"+ f"| where QueryType == 252 or (QueryType in (1, 28) and EventId == 257)\n"+ f"| project TimeGenerated, ClientIP, Name, QueryType, ResultCode\n"+ )+ sigma_rule = (+ f"title: DNS Zone Transfer AXFR Request ({dns_target})\n"+ f"id: 8b9c0d1e-ares-dnsaxfr-{abs(hash(str(dns_target))) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects DNS zone transfer requests (AXFR) attempting full domain zone extraction.\n"+ f"logsource:\n"+ f" product: windows\n"+ f" service: dns\n"+ f"detection:\n"+ f" selection:\n"+ f" QueryType: 252\n"+ f" condition: selection\n"+ f"level: high\n"+ f"tags:\n"+ f" - attack.reconnaissance\n"+ f" - attack.t1590.002\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": f"Detection Rule (KQL): DNS AXFR Zone Transfer ({dns_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting DNS zone transfer requests",+ "content": {"kql": kql_query, "target": dns_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): DNS AXFR Zone Transfer ({dns_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for DNS zone transfer requests",+ "content": {"sigma": sigma_rule, "target": dns_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["zone_transfer_axfr_audited"] = True+ raw["active_directory_srv_records_mapped"] = True+return ModuleResult(status="success" if (findings or raw.get("dns_records")) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/network/http_fingerprint.py b/ares/modules/network/http_fingerprint.pyindex d9b88b6..304786e 100644--- a/ares/modules/network/http_fingerprint.py+++ b/ares/modules/network/http_fingerprint.py@@ -163,6 +163,56 @@ class HttpFingerprintModule(BaseModule):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+ http_target = target or "WebTarget"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect Web Application Reconnaissance & Admin Surface Probing\n"+ f"// Monitors W3CIISLog / AppGW for scanning of administrative endpoints (/admin, /actuator, /swagger)\n"+ f"W3CIISLog\n"+ f"| where csUriStem in~ (\"/admin\", \"/actuator\", \"/swagger-ui.html\", \"/api-docs\", \"/.env\")\n"+ f"| project TimeGenerated, cIP, csMethod, csUriStem, scStatus, sSiteName\n"+ )+ sigma_rule = (+ f"title: Web Application Admin Interface & Actuator Probing ({http_target})\n"+ f"id: 9c0d1e2f-ares-httpprobe-{abs(hash(str(http_target))) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects HTTP requests targeting administrative interfaces, Spring Actuator, or API documentation.\n"+ f"logsource:\n"+ f" product: webserver\n"+ f"detection:\n"+ f" selection:\n"+ f" c-uri-stem:\n"+ f" - '/admin'\n"+ f" - '/actuator*'\n"+ f" - '/swagger*'\n"+ f" condition: selection\n"+ f"level: medium\n"+ f"tags:\n"+ f" - attack.reconnaissance\n"+ f" - attack.t1592.002\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": f"Detection Rule (KQL): HTTP Admin Probing ({http_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting HTTP admin interface scanning",+ "content": {"kql": kql_query, "target": http_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): HTTP Admin Probing ({http_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for HTTP admin interface scanning",+ "content": {"sigma": sigma_rule, "target": http_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["security_headers_compliance_evaluated"] = True+ raw["admin_interfaces_probed"] = True+return ModuleResult(status="success" if (findings or raw.get("web_fingerprint")) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/network/pivot.py b/ares/modules/network/pivot.pyindex f4d5be3..0b7aa7b 100644--- a/ares/modules/network/pivot.py+++ b/ares/modules/network/pivot.py@@ -196,6 +196,57 @@ class PivotModule(BaseModule):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+ pivot_host = target or "PivotHost"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect SSH Tunneling & SOCKS Proxy Pivoting\n"+ f"// Monitors Linux auditd / Syslog for sshd port forwarding or ssh client running with -D or -L\n"+ f"Syslog\n"+ f"| where ProcessName in~ (\"sshd\", \"ssh\") and (SyslogMessage has \"forwarding\" or SyslogMessage has \"port 1080\" or SyslogMessage has \"direct-tcpip\")\n"+ f"| project TimeGenerated, Computer, ProcessName, SyslogMessage\n"+ )+ sigma_rule = (+ f"title: SSH Dynamic Port Forwarding / SOCKS Pivot Established ({pivot_host})\n"+ f"id: 0d1e2f3a-ares-sshpivot-{abs(hash(str(pivot_host))) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects SSH client or daemon establishing dynamic port forwarding / internal network proxying.\n"+ f"logsource:\n"+ f" product: linux\n"+ f" service: sshd\n"+ f"detection:\n"+ f" selection:\n"+ f" CommandLine|contains:\n"+ f" - ' -D '\n"+ f" - ' -R '\n"+ f" - ' -L '\n"+ f" condition: selection\n"+ f"level: high\n"+ f"tags:\n"+ f" - attack.command_and_control\n"+ f" - attack.t1090.001\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": f"Detection Rule (KQL): SSH Tunneling Pivot ({pivot_host})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting SSH dynamic port forwarding and pivoting",+ "content": {"kql": kql_query, "target": pivot_host},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): SSH Tunneling Pivot ({pivot_host})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for SSH dynamic port forwarding and pivoting",+ "content": {"sigma": sigma_rule, "target": pivot_host},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["ssh_tunnel_integrity_evaluated"] = True+ raw["internal_routing_pivot_mapped"] = True+return ModuleResult(status="success" if findings else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/network/port_scan.py b/ares/modules/network/port_scan.pyindex 83eecee..b4c9a46 100644--- a/ares/modules/network/port_scan.py+++ b/ares/modules/network/port_scan.py@@ -376,6 +376,54 @@ class PortScanModule(BaseModule):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+ scan_target = target or "NetworkTarget"+ kql_query = (+ f"// ARES Closed-Loop Telemetry: Detect Rapid Network Port Scanning / Sweep\n"+ f"// Monitors AzureNetworkAnalytics_CL / NetworkSession for single source contacting >= 15 distinct ports within 5 minutes\n"+ f"NetworkSession\n"+ f"| where DestinationIp == \"{scan_target}\" or SourceIp == \"{scan_target}\"\n"+ f"| summarize DistinctPorts = dcount(DestinationPort), StartTime = min(TimeGenerated), EndTime = max(TimeGenerated) by SourceIp, DestinationIp\n"+ f"| where DistinctPorts >= 15\n"+ )+ sigma_rule = (+ f"title: Rapid Network Port Scan / Reconnaissance ({scan_target})\n"+ f"id: 1e2f3a4b-ares-portscan-{abs(hash(str(scan_target))) % 1000000:06d}\n"+ f"status: experimental\n"+ f"description: Detects rapid probing of multiple distinct TCP ports against target hosts.\n"+ f"logsource:\n"+ f" product: firewall\n"+ f"detection:\n"+ f" selection:\n"+ f" dst_ip: '{scan_target}'\n"+ f" condition: selection | count() by src_ip > 15\n"+ f"level: low\n"+ f"tags:\n"+ f" - attack.reconnaissance\n"+ f" - attack.t1046\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": f"Detection Rule (KQL): Network Port Scan ({scan_target})",+ "loot_type": "detection_rule_kql",+ "description": "Microsoft Sentinel KQL query for detecting rapid TCP port scanning",+ "content": {"kql": kql_query, "target": scan_target},+ "tags": ["detection", "kql", "sentinel", "blue_team"],+ },+ {+ "name": f"Detection Rule (Sigma): Network Port Scan ({scan_target})",+ "loot_type": "detection_rule_sigma",+ "description": "Sigma detection rule for rapid TCP port scanning",+ "content": {"sigma": sigma_rule, "target": scan_target},+ "tags": ["detection", "sigma", "blue_team"],+ },+ ])+ raw["loot"] = loot_items+ raw["port_scan_reconnaissance_evaluated"] = True+ raw["high_value_ports_mapped"] = True+return ModuleResult(status="success" if (findings or raw.get("open_ports")) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/network/service_detect.py b/ares/modules/network/service_detect.pyindex b42d319..749a051 100644--- a/ares/modules/network/service_detect.py+++ b/ares/modules/network/service_detect.py@@ -191,6 +191,55 @@ class ServiceDetectModule(BaseModule):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 - Multi-Port Service Banner Enumeration\n"+ "NetworkSession\n"+ "| where TimeGenerated > ago(1h)\n"+ "| where DestinationPort in (21, 22, 25, 80, 443, 6379, 8080, 8443, 27017)\n"+ "| summarize PortCount = dcount(DestinationPort), BytesReceived = sum(BytesReceived), SessionCount = count() by SourceIp, DestinationIp, bin(TimeGenerated, 5m)\n"+ "| where PortCount >= 3 or (SessionCount >= 5 and BytesReceived < 5000)\n"+ "| project TimeGenerated, SourceIp, DestinationIp, PortCount, SessionCount"+ )+ sigma_rule = (+ "title: Network Service Banner Grabbing and Version Enumeration\n"+ "id: e8a91b2c-3d4e-4f5a-b6c7-d8e9f0a1b2c3\n"+ "status: experimental\n"+ "description: Detects rapid connection handshakes and probe queries targeted at service banner ports\n"+ "references:\n"+ " - https://attack.mitre.org/techniques/T1046/\n"+ "author: ARES Purple Team Modernization\n"+ "date: 2026-03-30\n"+ "logsource:\n"+ " category: network_traffic\n"+ "detection:\n"+ " selection:\n"+ " DestinationPort:\n"+ " - 21\n"+ " - 22\n"+ " - 25\n"+ " - 80\n"+ " - 443\n"+ " - 6379\n"+ " - 8080\n"+ " - 8443\n"+ " - 27017\n"+ " condition: selection | count(DestinationPort) by SourceIp, DestinationIp > 3\n"+ "level: medium\n"+ "tags:\n"+ " - attack.discovery\n"+ " - attack.t1046"+ )+ raw.setdefault("loot", {})+ raw["loot"]["detection_kql"] = kql_rule+ raw["loot"]["detection_sigma"] = sigma_rule+ raw["banner_exposure_detected"] = bool(raw.get("service_versions"))+ raw["unauthenticated_service_risk"] = any(+ "no-auth" in vs.get("cve_hint", "") for vs in raw.get("vulnerable_services", [])+ )+ raw["legacy_version_detected"] = bool(raw.get("vulnerable_services"))+ raw["service_enumeration_audited"] = True+return ModuleResult(status="success" if (findings or raw.get("service_versions")) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/network/snmp_enum.py b/ares/modules/network/snmp_enum.pyindex 9a8834a..2493ac7 100644--- a/ares/modules/network/snmp_enum.py+++ b/ares/modules/network/snmp_enum.py@@ -233,6 +233,47 @@ class SnmpEnumModule(BaseModule):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 - SNMP Community String Brute-Force & Walk\n"+ "NetworkSession\n"+ "| where TimeGenerated > ago(1h)\n"+ "| where DestinationPort in (161, 162) and NetworkProtocol =~ \"UDP\"\n"+ "| summarize RequestCount = count(), UniqueDestinations = dcount(DestinationIp) by SourceIp, bin(TimeGenerated, 5m)\n"+ "| where RequestCount >= 10\n"+ "| project TimeGenerated, SourceIp, RequestCount, UniqueDestinations"+ )+ sigma_rule = (+ "title: SNMP Community String Enumeration and Polling\n"+ "id: f1a2b3c4-d5e6-47a8-b9c0-d1e2f3a4b5c6\n"+ "status: experimental\n"+ "description: Detects rapid UDP port 161 SNMP polling indicative of community string brute force or OID walking\n"+ "references:\n"+ " - https://attack.mitre.org/techniques/T1046/\n"+ "author: ARES Purple Team Modernization\n"+ "date: 2026-03-30\n"+ "logsource:\n"+ " category: network_traffic\n"+ "detection:\n"+ " selection:\n"+ " DestinationPort: 161\n"+ " Protocol: udp\n"+ " condition: selection | count() by SourceIp > 10\n"+ "level: medium\n"+ "tags:\n"+ " - attack.discovery\n"+ " - attack.t1046"+ )+ raw.setdefault("loot", {})+ raw["loot"]["detection_kql"] = kql_rule+ raw["loot"]["detection_sigma"] = sigma_rule+ raw["snmp_v1_v2c_exposed"] = bool(raw.get("valid_communities"))+ raw["default_community_detected"] = any(+ c in ["public", "private", "community"] for c in raw.get("valid_communities", [])+ )+ raw["snmp_write_access_detected"] = "private" in raw.get("valid_communities", [])+ raw["snmp_enumeration_audited"] = True+return ModuleResult(status="success" if (findings or raw.get("valid_communities")) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/opsec/coverage_predictor.py b/ares/modules/opsec/coverage_predictor.pyindex 7b151e8..ff9fdf6 100644--- a/ares/modules/opsec/coverage_predictor.py+++ b/ares/modules/opsec/coverage_predictor.py@@ -728,6 +728,47 @@ class CoveragePredictorModule(BaseModule):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 - Multi-Technique Attack Campaign Correlation & Detection Scoring\n"+ "SecurityAlert\n"+ "| where TimeGenerated > ago(24h)\n"+ "| extend Techniques = parse_json(Techniques)\n"+ "| mv-expand Techniques\n"+ "| summarize UniqueTechniques = dcount(to_string(Techniques)), AlertCount = count(), Severities = make_set(AlertSeverity) by CompromisedEntity, bin(TimeGenerated, 1h)\n"+ "| where UniqueTechniques >= 3 or AlertCount >= 5\n"+ "| project TimeGenerated, CompromisedEntity, UniqueTechniques, AlertCount, Severities"+ )+ sigma_rule = (+ "title: Correlated Multi-Stage Adversary Activity Detection\n"+ "id: e1f2a3b4-c5d6-47e8-f9a0-b1c2d3e4f5a6\n"+ "status: experimental\n"+ "description: Correlates multiple distinct MITRE ATT&CK tactical alerts against a single host or identity\n"+ "references:\n"+ " - https://attack.mitre.org/techniques/T1592/\n"+ "author: ARES Purple Team Modernization\n"+ "date: 2026-03-30\n"+ "logsource:\n"+ " category: alert\n"+ "detection:\n"+ " selection:\n"+ " AlertSeverity:\n"+ " - high\n"+ " - critical\n"+ " condition: selection | count() by CompromisedEntity > 3\n"+ "level: high\n"+ "tags:\n"+ " - attack.defense_evasion\n"+ " - attack.t1592"+ )+ raw.setdefault("loot", {})+ raw["loot"]["detection_kql"] = kql_rule+ raw["loot"]["detection_sigma"] = sigma_rule+ raw["overall_detection_probability"] = float(raw.get("detection_score", 0.0))+ raw["siem_correlations_identified"] = bool(raw.get("siem_correlations"))+ raw["recommended_wait_hours"] = int(raw.get("wait_hours", 0))+ raw["opsec_coverage_audited"] = True+return ModuleResult(status="success" if (findings or raw.get("detection_score", 0) >= 0) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/recon/fingerprint.py b/ares/modules/recon/fingerprint.pyindex 5f74185..0a9c578 100644--- a/ares/modules/recon/fingerprint.py+++ b/ares/modules/recon/fingerprint.py@@ -141,6 +141,55 @@ class FingerprintModule(BaseModule):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 - Security Product & EDR Fingerprinting Enumeration\n"+ "SecurityEvent\n"+ "| where TimeGenerated > ago(2h)\n"+ "| where EventID == 4688\n"+ "| extend Cmd = tolower(CommandLine)\n"+ "| where Cmd has_any (\"csagent\", \"cylance\", \"sentinelone\", \"tanium\", \"carbonblack\", \"msmpeng\", \"cbdefense\")\n"+ " or (Cmd has_any (\"sc query\", \"get-service\", \"tasklist\") and Cmd has_any (\"security\", \"antivirus\", \"edr\"))\n"+ "| project TimeGenerated, Computer, Account, Process, CommandLine, ParentProcessName"+ )+ sigma_rule = (+ "title: Security Software and EDR Vendor Enumeration\n"+ "id: c9d0e1f2-a3b4-45c6-d7e8-f9a0b1c2d3e4\n"+ "status: experimental\n"+ "description: Detects command-line discovery targeting installed antivirus, EDR, and monitoring agents\n"+ "references:\n"+ " - https://attack.mitre.org/techniques/T1518/001/\n"+ " - https://attack.mitre.org/techniques/T1082/\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"+ " CommandLine|contains:\n"+ " - 'csagent'\n"+ " - 'cylance'\n"+ " - 'sentinelone'\n"+ " - 'tanium'\n"+ " - 'carbonblack'\n"+ " - 'msmpeng'\n"+ " condition: selection\n"+ "level: medium\n"+ "tags:\n"+ " - attack.discovery\n"+ " - attack.t1518.001\n"+ " - attack.t1082"+ )+ raw.setdefault("loot", {})+ raw["loot"]["detection_kql"] = kql_rule+ raw["loot"]["detection_sigma"] = sigma_rule+ edrs = raw.get("edr_vendors", [])+ raw["edr_agents_identified"] = bool(edrs)+ raw["active_edr_count"] = len(edrs)+ raw["high_detection_risk_environment"] = bool(edrs) or str(raw.get("detection_risk", "")).lower() == "high"+ raw["endpoint_fingerprint_audited"] = True+return ModuleResult(status="success" if (findings or raw) else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/windows/registry_enum.py b/ares/modules/windows/registry_enum.pyindex 02baa4c..1c63a85 100644--- a/ares/modules/windows/registry_enum.py+++ b/ares/modules/windows/registry_enum.py@@ -277,6 +277,58 @@ class RegistryEnumModule(BaseModule):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 - Suspicious Remote Registry Credential Enumeration\n"+ "SecurityEvent\n"+ "| where TimeGenerated > ago(2h)\n"+ "| where (EventID == 5145 and RelativeTargetName =~ \"winreg\") or\n"+ " (EventID in (4656, 4663) and ObjectType =~ \"Key\" and ObjectName has_any (\"Winlogon\", \"PuTTY\\\\Sessions\", \"SNMP\\\\Parameters\", \"RealVNC\", \"AlwaysInstallElevated\"))\n"+ "| project TimeGenerated, Computer, Account, ObjectName, AccessMask, ProcessName"+ )+ sigma_rule = (+ "title: Remote Registry Credential and Privilege Escalation Keys Enumeration\n"+ "id: a7b8c9d0-e1f2-43a4-b5c6-d7e8f9a0b1c2\n"+ "status: experimental\n"+ "description: Detects access to registry keys commonly storing cleartext credentials or privilege escalation vectors\n"+ "references:\n"+ " - https://attack.mitre.org/techniques/T1552/002/\n"+ "author: ARES Purple Team Modernization\n"+ "date: 2026-03-30\n"+ "logsource:\n"+ " product: windows\n"+ " service: security\n"+ "detection:\n"+ " selection_namedpipe:\n"+ " EventID: 5145\n"+ " ShareRelativeTargetName: 'winreg'\n"+ " selection_regkeys:\n"+ " EventID:\n"+ " - 4656\n"+ " - 4663\n"+ " ObjectName|contains:\n"+ " - 'Winlogon'\n"+ " - 'PuTTY\\Sessions'\n"+ " - 'AlwaysInstallElevated'\n"+ " condition: selection_namedpipe or selection_regkeys\n"+ "level: medium\n"+ "tags:\n"+ " - attack.credential_access\n"+ " - attack.privilege_escalation\n"+ " - attack.t1552.002"+ )+ raw.setdefault("loot", {})+ raw["loot"]["detection_kql"] = kql_rule+ raw["loot"]["detection_sigma"] = sigma_rule+ raw["autologon_credentials_found"] = any(+ "autologon" in str(f).lower() for f in raw.get("cleartext_credentials", [])+ )+ raw["putty_stored_credentials_found"] = bool(raw.get("putty_sessions"))+ raw["always_install_elevated_risk"] = any(+ "alwaysinstallelevated" in str(f).lower() for f in findings+ )+ raw["remote_registry_audited"] = True+return ModuleResult(status="success" if findings else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,diff --git a/ares/modules/windows/scheduled_tasks_enum.py b/ares/modules/windows/scheduled_tasks_enum.pyindex 53e39b0..df5eed0 100644--- a/ares/modules/windows/scheduled_tasks_enum.py+++ b/ares/modules/windows/scheduled_tasks_enum.py@@ -249,6 +249,53 @@ class ScheduledTasksEnumModule(BaseModule):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 - Scheduled Task Enumeration and Modification Detection\n"+ "SecurityEvent\n"+ "| where TimeGenerated > ago(2h)\n"+ "| where (EventID in (4698, 4702) and TaskContent has_any (\"powershell\", \"cmd.exe\", \"cscript\", \"wscript\", \"mshta\"))\n"+ " or (EventID == 4688 and Process has_any (\"schtasks.exe\") and CommandLine has_any (\"/query\", \"/create\", \"/change\"))\n"+ "| project TimeGenerated, Computer, Account, Process, CommandLine, TaskName"+ )+ sigma_rule = (+ "title: Scheduled Task Enumeration or Suspicious Task Registration\n"+ "id: b8c9d0e1-f2a3-44b5-c6d7-e8f9a0b1c2d3\n"+ "status: experimental\n"+ "description: Detects querying or registration of scheduled tasks invoking command interpreters or scripting engines\n"+ "references:\n"+ " - https://attack.mitre.org/techniques/T1053/005/\n"+ "author: ARES Purple Team Modernization\n"+ "date: 2026-03-30\n"+ "logsource:\n"+ " category: process_creation\n"+ " product: windows\n"+ "detection:\n"+ " selection_schtasks:\n"+ " Image|endswith: '\\schtasks.exe'\n"+ " CommandLine|contains:\n"+ " - '/query'\n"+ " - '/create'\n"+ " condition: selection_schtasks\n"+ "level: medium\n"+ "tags:\n"+ " - attack.persistence\n"+ " - attack.privilege_escalation\n"+ " - attack.t1053.005"+ )+ raw.setdefault("loot", {})+ raw["loot"]["detection_kql"] = kql_rule+ raw["loot"]["detection_sigma"] = sigma_rule+ privesc_vecs = raw.get("privesc_vectors", [])+ raw["writable_task_binaries_found"] = any(+ "writable" in str(v).lower() for v in privesc_vecs+ )+ raw["unquoted_task_paths_detected"] = any(+ "unquoted" in str(v).lower() for v in privesc_vecs+ )+ raw["custom_scheduled_tasks_count"] = len(raw.get("scheduled_tasks", []))+ raw["scheduled_tasks_audited"] = True+return ModuleResult(status="success" if findings else "partial",findings=findings, raw=raw, module_id=self.MODULE_ID,