Merge branch 'conflu2update' of https://github.com/splunk/security_content into conflu2update

.vscode/launch.json

@@ -49,6 +49,15 @@
             "justMyCode": true,
             "args": ["-p", "detections", "content_changer", "-cf", "fix_kill_chain"]
         },
+        {
+            "name": "contentctl convert",
+            "type": "python",
+            "request": "launch",
+            "program": "${workspaceFolder}/contentctl.py",
+            "console": "integratedTerminal",
+            "justMyCode": true,
+            "args": ["-p", ".", "convert", "-dm", "ocsf", "-dp", "dev_ssa/endpoint/ssa___windows_wmiprvse_spawn_msbuild.yml", "-o", "ssa_detections/endpoint"]
+        },
         {
             "name": "Python: Current File",
             "type": "python",

bin/contentctl_project/contentctl_infrastructure/builder/backend_splunk_ba.py

@@ -67,6 +67,7 @@ class SplunkBABackend(TextQueryBackend):
     wildcard_match_expression : ClassVar[Optional[str]] = "{field} LIKE {value}"
 
 
+
     def __init__(self, processing_pipeline: Optional["sigma.processing.pipeline.ProcessingPipeline"] = None, collect_errors: bool = False, min_time : str = "-30d", max_time : str = "now", detection : Detection = None, field_mapping: dict = None, **kwargs):
         super().__init__(processing_pipeline, collect_errors, **kwargs)
         self.min_time = min_time or "-30d"
@@ -110,13 +111,29 @@ $main = from source
                     parent = new_val
                     i = i + 1
                     continue
-                parser_str = '| eval ' + new_val + ' = ' + parent + '.' + val + ' '
+                new_val_spaces = new_val + "="
+                if new_val_spaces not in query:
+                    parser_str = '| eval ' + new_val + ' = ' + parent + '.' + val + ' '
+                else:
+                    parser_str = '| eval ' + new_val + ' = ' + 'lower(' + parent + '.' + val + ') '
                 detection_str = detection_str + parser_str
                 parsed_fields.append(new_val)
                 parent = new_val
                 i = i + 1
 
-        detection_str = detection_str + "| where " + query
+        ### Convert sigma values into lower case
+        lower_query = ""
+        in_quotes = False
+        for char in query:
+            if char == '"':
+                in_quotes = not in_quotes
+            if in_quotes:
+                lower_query += char.lower()
+            else:
+                lower_query += char
+
+        detection_str = detection_str + "| where " + lower_query
+        
         detection_str = detection_str.replace("\\\\\\\\", "\\\\")
         return detection_str
 

contentctl.py

@@ -1,6 +1,6 @@
 import sys
 import argparse
-import os
+import os 
 
 from bin.contentctl_project.contentctl_core.domain.entities.link_validator import LinkValidator
 

detections/application/suspicious_email_attachment_extensions.yml

@@ -5,8 +5,8 @@ date: '2023-04-14'
 author: David Dorsey, Splunk
 status: experimental
 type: Anomaly
-description: This search looks for emails that have attachments with suspicious file
-  extensions.
+description: |-
+  The following analytic detects emails that contain attachments with suspicious file extensions. Detecting and responding to emails with suspicious attachments can mitigate the risks associated with phishing and malware attacks, thereby protecting the organization's data and systems from potential harm. The detection is made by using a Splunk query that searches for emails in the datamodel=Email where the filename of the attachment is not empty. The analytic uses the tstats command to summarize the count, first time, and last time of the emails that meet the criteria. It groups the results by the source user, file name, and message ID of the email. The detection is important because it indicates potential phishing or malware delivery attempts in which an attacker attempts to deliver malicious content through email attachments, which can lead to data breaches, malware infections, or unauthorized access to sensitive information. Next steps include reviewing the identified emails and attachments and analyzing the source user, file name, and message ID to determine if they are legitimate or malicious. Additionally, you must inspect any relevant on-disk artifacts associated with the attachments and investigate any concurrent processes to identify the source of the attack.
 data_source: []
 search: '| tstats `security_content_summariesonly` count min(_time) as firstTime max(_time)
   as lastTime from datamodel=Email where All_Email.file_name="*" by All_Email.src_user,

detections/application/web_servers_executing_suspicious_processes.yml

@@ -5,8 +5,8 @@ date: '2019-04-01'
 author: David Dorsey, Splunk
 status: experimental
 type: TTP
-description: This search looks for suspicious processes on all systems labeled as
-  web servers.
+description: |-
+  The following analytic detects suspicious processes on systems labeled as web servers. This detection is made by a Splunk query that searches for specific process names that might indicate malicious activity. These suspicious processes include "whoami", "ping", "iptables", "wget", "service", and "curl". Uses the Splunk data model "Endpoint.Processes" and filters the results to only include systems categorized as web servers. This detection is important because it indicates unauthorized or malicious activity on web servers since these processes are commonly used by attackers to perform reconnaissance, establish persistence, or exfiltrate data from compromised systems. The impact of such an attack can be significant, ranging from data theft to the deployment of additional malicious payloads, potentially leading to ransomware or other damaging outcomes. False positives might occur since the legitimate use of these processes on web servers can trigger the analytic. Next steps include triaging and investigating to determine the legitimacy of the activity. Also, review the source and command of the suspicious process. You must also examine any relevant on-disk artifacts and look for concurrent processes to identify the source of the attack.
 data_source:
 - Sysmon Event ID 1
 search: '| tstats `security_content_summariesonly` count min(_time) as firstTime max(_time)

detections/cloud/amazon_eks_kubernetes_pod_scan_detection.yml

@@ -5,8 +5,8 @@ date: '2020-04-15'
 author: Rod Soto, Splunk
 status: experimental
 type: Hunting
-description: This search provides detection information on unauthenticated requests
-  against Kubernetes' Pods API
+description: |-
+  The following analytic detects unauthenticated requests made against the Kubernetes' Pods API through proactive monitoring to protect the Kubernetes environment from unauthorized access and potential security breaches. The detection is made by using the Splunk query `aws_cloudwatchlogs_eks` with specific filters to identify these requests. Identifies events where the `user.username` is set to "system:anonymous", the `verb` is set to "list", and the `objectRef.resource` is set to "pods". Additionally, the search checks if the `requestURI` is equal to "/api/v1/pods". Analyzing these events helps you to identify any unauthorized access attempts to the Kubernetes' Pods API. Unauthenticated requests can indicate potential security breaches or unauthorized access to sensitive resources within the Kubernetes environment. The detection is important because unauthorized access to Kubernetes' Pods API can lead to the compromise of sensitive data, unauthorized execution of commands, or even the potential for lateral movement within the Kubernetes cluster. False positives might occur since there might be legitimate use cases for unauthenticated requests in certain scenarios. Therefore, you must review and validate any detected events before taking any action.  Next steps include investigating the incident to mitigate any ongoing threats, and strengthening the security measures to prevent future unauthorized access attempts.
 data_source: []
 search: '`aws_cloudwatchlogs_eks` "user.username"="system:anonymous" verb=list objectRef.resource=pods
   requestURI="/api/v1/pods" | rename source as cluster_name sourceIPs{} as src_ip

detections/cloud/azure_ad_privileged_role_assigned_to_service_principal.yml

@@ -5,20 +5,15 @@ date: '2023-04-28'
 author: Mauricio Velazco, Splunk
 status: production
 type: TTP
-description: The following analytic is geared towards detecting potential privilege escalation threats in Azure Active Directory (AD). It identifies instances where privileged roles, which hold elevated permissions, are assigned to Service Principals. These non-human entities that can access Azure resources could be exploited in an attack scenario, leading to unauthorized access or malicious activities. The analytic runs a specific search within the ingested Azure AD events, specifically leveraging the AuditLogs log category. Keep in mind, however, that there could be false positives, as administrators may legitimately assign privileged roles to Service Principals.
+description: "The following analytic detects potential privilege escalation threats in Azure Active Directory (AD). The detection is made by running a specific search within the ingested Azure Active Directory events to leverage the AuditLogs log category. This detection is important because it identifies instances where privileged roles that hold elevated permissions are assigned to service principals. This prevents unauthorized access or malicious activities, which occur when these non-human entities access Azure resources to exploit them. False positives might occur since administrators can legitimately assign privileged roles to service principals."
 data_source: []
-search: ' `azuread` operationName="Add member to role" 
-  | rename properties.* as *
-  | search "targetResources{}.type"=ServicePrincipal
-  | rename initiatedBy.user.userPrincipalName as initiatedBy 
-  | rename targetResources{}.modifiedProperties{}.newValue  as roles 
-  | eval role=mvindex(roles,1) 
-  | rename targetResources{}.displayName as apps
-  | eval displayName=mvindex(apps,0) 
-  | lookup privileged_azure_ad_roles azureadrole AS role OUTPUT isprvilegedadrole description 
-  | search isprvilegedadrole = True
-  | stats values(displayName) by _time, initiatedBy, result, operationName, role
-  | `azure_ad_privileged_role_assigned_to_service_principal_filter`'
+search: ' `azuread` operationName="Add member to role" | rename properties.* as *
+  | search "targetResources{}.type"=ServicePrincipal | rename initiatedBy.user.userPrincipalName
+  as initiatedBy | rename targetResources{}.modifiedProperties{}.newValue  as roles
+  | eval role=mvindex(roles,1) | rename targetResources{}.displayName as apps | eval
+  displayName=mvindex(apps,0) | lookup privileged_azure_ad_roles azureadrole AS role
+  OUTPUT isprvilegedadrole description | search isprvilegedadrole = True | stats values(displayName)
+  by _time, initiatedBy, result, operationName, role | `azure_ad_privileged_role_assigned_to_service_principal_filter`'
 how_to_implement: You must install the latest version of Splunk Add-on for Microsoft
   Cloud Services from Splunkbase (https://splunkbase.splunk.com/app/3110/#/details).
   You must be ingesting Azure Active Directory events into your Splunk environment.
@@ -33,8 +28,8 @@ tags:
   asset_type: Azure Active Directory
   confidence: 50
   impact: 70
-  message: A privileged Azure AD role was assigned to the Service Principal $displayName$ initiated
-    by $initiatedBy$
+  message: A privileged Azure AD role was assigned to the Service Principal $displayName$
+    initiated by $initiatedBy$
   mitre_attack_id:
   - T1098
   - T1098.003

detections/cloud/circle_ci_disable_security_job.yml

@@ -5,7 +5,8 @@ date: '2021-09-02'
 author: Patrick Bareiss, Splunk
 status: production
 type: Anomaly
-description: This search looks for disable security job in CircleCI pipeline.
+description: |-
+  This analytic searches for a specific behavior in CircleCI pipelines such as the disabling of security jobs. The detection is made by using a Splunk query that renames certain fields and retrieves values for specified job names, workflow IDs and names, user information, commit messages, URLs, and branches. Then, the query identifies mandatory jobs for each workflow and searches for instances where they were run. The search also identifies the phase of the pipeline as "build" and extracts the repository name from the URL using regular expressions. The detection is important because it detects attempts to bypass security measures in CircleCI pipelines, which can potentially lead to malicious code being introduced into the pipeline, data breaches, system downtime, and reputational damage.  False positives might occur since legitimate use cases can require the disabling of security jobs. However, you can proactively monitor and identify any suspicious activity in the pipeline using this analytic and mitigate potential threats through early detection.
 data_source: []
 search: '`circleci` | rename vcs.committer_name as user vcs.subject as commit_message
   vcs.url as url workflows.* as *  | stats values(job_name) as job_names by workflow_id

detections/cloud/circle_ci_disable_security_step.yml

@@ -5,7 +5,8 @@ date: '2021-09-01'
 author: Patrick Bareiss, Splunk
 status: experimental
 type: Anomaly
-description: This search looks for disable security step in CircleCI pipeline.
+description: |-
+  The following analytic detects the disablement of security steps in a CircleCI pipeline. Addressing instances of security step disablement in CircleCI pipelines can mitigate the risks associated with potential security vulnerabilities and unauthorized changes. A proactive approach helps protect the organization's infrastructure, data, and overall security posture. The detection is made by a Splunk query that searches for specific criteria within CircleCI logs through a combination of field renaming, joining, and statistical analysis to identify instances where security steps are disabled. It retrieves information such as job IDs, job names, commit details, and user information from the CircleCI logs.  The detection is important because it indicates potential security vulnerabilities or unauthorized changes to the pipeline caused by someone within the organization intentionally or unintentionally disabling security steps in the CircleCI pipeline.Disabling security steps can leave the pipeline and the associated infrastructure exposed to potential attacks, data breaches, or the introduction of malicious code into the pipeline. Investigate by reviewing the job name, commit details, and user information associated with the disablement of security steps. You must also examine any relevant on-disk artifacts and identify concurrent processes that might indicate the source of the attack or unauthorized change.
 data_source: []
 search: '`circleci` | rename workflows.job_id AS job_id | join job_id [ | search `circleci`
   | stats values(name) as step_names count by job_id job_name ] | stats count by step_names

detections/cloud/cloud_api_calls_from_previously_unseen_user_roles.yml

@@ -5,7 +5,8 @@ date: '2020-09-04'
 author: David Dorsey, Splunk
 status: experimental
 type: Anomaly
-description: This search looks for new commands from each user role.
+description: |-
+  The following analytic detects when a new command is run by a user, who typically does not run those commands. The detection is made by a Splunk query to search for these commands in the Change data model. Identifies commands run by users with the user_type of AssumedRole and a status of success. The query retrieves the earliest and latest timestamps of each command run and groups the results by the user and command. Then, it drops the unnecessary data model object name and creates a lookup to verify if the command was seen before. The lookup table contains information about previously seen cloud API calls for each user role, including the first time the command was seen and whether enough data is available for analysis. If the firstTimeSeenUserApiCall field is null or greater than the relative time of 24 hours ago, it indicates that the command is new and was not seen before. The final result table includes the firstTime, user, object, and command fields of the new commands. It also applies the security_content_ctime function to format the timestamps and applies a filter to remove any cloud API calls from previously unseen user roles. The detection is important because it helps to identify new commands run by different user roles. New commands can indicate potential malicious activity or unauthorized actions within the environment. Detecting and investigating these new commands can help identify and mitigate potential security threats earlier, preventing data breaches, unauthorized access, or other damaging outcomes.
 data_source: []
 search: '| tstats earliest(_time) as firstTime, latest(_time) as lastTime from datamodel=Change
   where All_Changes.user_type=AssumedRole AND All_Changes.status=success by All_Changes.user,

detections/cloud/cloud_compute_instance_created_with_previously_unseen_image.yml

@@ -5,8 +5,8 @@ date: '2018-10-12'
 author: David Dorsey, Splunk
 status: experimental
 type: Anomaly
-description: This search looks for cloud compute instances being created with previously
-  unseen image IDs.
+description: |-
+  The following analytic detects potential instances that are created in a cloud computing environment using new or unknown image IDs that have not been seen before. This detection is important because it helps to investigate and take appropriate action to prevent further damage or unauthorized access to the Cloud environment, which can include data breaches, unauthorized access to sensitive information, or the deployment of malicious payloads within the cloud environment. False positives might occur since legitimate instances can also have previously unseen image IDs. Next steps include conducting an extensive triage and investigation to determine the nature of the activity. During triage, review the details of the created instances, including the user responsible for the creation, the image ID used, and any associated metadata. Additionally, consider inspecting any relevant on-disk artifacts and analyzing concurrent processes to identify the source of the attack.
 data_source: []
 search: '| tstats count earliest(_time) as firstTime, latest(_time) as lastTime values(All_Changes.object_id)
   as dest from datamodel=Change where All_Changes.action=created by All_Changes.Instance_Changes.image_id,

detections/cloud/cloud_compute_instance_created_with_previously_unseen_instance_type.yml

@@ -5,7 +5,7 @@ date: '2020-09-12'
 author: David Dorsey, Splunk
 status: experimental
 type: Anomaly
-description: Find EC2 instances being created with previously unseen instance types.
+description: The following analytic detects the creation of EC2 instances with previously unseen instance types. The detection is made by using a Splunk query to identify the EC2 instances. First, the query searches for changes in the EC2 instance creation action and filters for instances with instance types that are not recognized or previously seen. Next, the query uses the Splunk tstats command to gather the necessary information from the Change data model. Then, it filters the instances with unknown instance types and reviews previously seen instance types to determine if they are new or not. The detection is important because it identifies attackers attempting to create instances with unknown or potentially compromised instance types, which can be an attempt to gain unauthorized access to sensitive data, compromise of systems, exfiltrate data, potential disruption of services, or launch other malicious activities within the environment. False positives might occur since there might be legitimate reasons for creating instances with previously unseen instance types. Therefore, you must carefully review and triage all alerts.
 data_source: []
 search: '| tstats earliest(_time) as firstTime, latest(_time) as lastTime values(All_Changes.object_id)
   as dest, count from datamodel=Change where All_Changes.action=created by All_Changes.Instance_Changes.instance_type,

detections/cloud/correlation_by_repository_and_risk.yml

@@ -5,7 +5,8 @@ date: '2021-09-06'
 author: Patrick Bareiss, Splunk
 status: production
 type: Correlation
-description: This search correlations detections by repository and risk_score
+description: |-
+  The following analytic detects by correlating repository and risk score to identify patterns and trends in the data based on the level of risk associated. The analytic adds any null values and calculates the sum of the risk scores for each detection. Then, the analytic captures the source and user information for each detection and sorts the results in ascending order based on the risk score. Finally, the analytic filters the detections with a risk score below 80 and focuses only on high-risk detections.This detection is important because it provides valuable insights into the distribution of high-risk activities across different repositories. It also identifies the most vulnerable repositories that are frequently targeted by potential threats. Additionally, it proactively detects and responds to potential threats, thereby minimizing the impact of attacks and safeguarding critical assets. Finally, it provides a comprehensive view of the risk landscape and helps to make informed decisions to protect the organization's data and infrastructure. False positives might occur so it is important to identify the impact of the attack and prioritize response and mitigation efforts.
 data_source: []
 search: '`risk_index` | fillnull | stats sum(risk_score) as risk_score values(source)
   as signals values(user) as user by repository | sort - risk_score | where risk_score

detections/cloud/correlation_by_user_and_risk.yml

@@ -5,7 +5,8 @@ date: '2021-09-06'
 author: Patrick Bareiss, Splunk
 status: production
 type: Correlation
-description: This search correlations detections by user and risk_score
+description: |-
+  The following analytic detects the correlation between the user and risk score and identifies users with a high risk score that pose a significant security risk such as unauthorized access attempts, suspicious behavior, or potential insider threats. Next, the analytic calculates the sum of the risk scores and groups the results by user, the corresponding signals, and the repository. The results are sorted in descending order based on the risk score and filtered to include records with a risk score greater than 80. Finally, the results are passed through a correlation filter specific to the user and risk. This detection is important because it identifies users who have a high risk score and helps to prioritize investigations and allocate resources. False positives might occur but the impact of such an attack can vary depending on the specific scenario such as data exfiltration, system compromise, or the disruption of critical services. Please investigate this notable event.
 data_source: []
 search: '`risk_index` | fillnull | stats sum(risk_score) as risk_score values(source)
   as signals values(repository) as repository by user | sort - risk_score | where

detections/cloud/github_dependabot_alert.yml

@@ -5,7 +5,7 @@ date: '2021-09-01'
 author: Patrick Bareiss, Splunk
 status: production
 type: Anomaly
-description: This search looks for Dependabot Alerts in Github logs.
+description: "The following analytic is made by first searching for logs that contain the action \"create\" and renames certain fields for easier analysis. Then, this analytic uses the \"stats\" command to calculate the first and last occurrence of the alert based on the timestamp. The fields included in the output are the action, affected package name, affected range, created date, external identifier, external reference, fixed version, severity, repository, repository URL, and user. The \"phase\" field is set to \"code\" to indicate that the alert pertains to code-related issues. The detection is important because dependabot Alerts can indicate vulnerabilities in the codebase that can be exploited by attackers. Detecting and investigating these alerts can help a SOC to proactively address security risks and prevent potential breaches or unauthorized access to sensitive information. False positives might occur since there are legitimate actions that trigger the \"create\" action or if other factors exist that can generate similar log entries. Next steps include reviewing the details of the alert, such as the affected package, severity, and fixed version to determine the appropriate response and mitigation steps."
 data_source: []
 search: '`github` alert.id=* action=create | rename repository.full_name as repository,
   repository.html_url as repository_url sender.login as user | stats min(_time) as

detections/cloud/github_pull_request_from_unknown_user.yml

@@ -5,7 +5,7 @@ date: '2021-09-01'
 author: Patrick Bareiss, Splunk
 status: production
 type: Anomaly
-description: This search looks for Pull Request from unknown user.
+description: The following analytic detects pull requests from unknown users on GitHub. The detection is made by using a Splunk query to search for pull requests in the `check_suite.pull_requests` field where the `id` is not specified. Next, the analytic retrieves information such as the author's name, the repository's full name, the head reference of the pull request, and the commit message from the `check_suite.head_commit` field. The analytic also includes a step to exclude known users by using the `github_known_users` lookup table, which helps to filter out pull requests from known users and focus on the pull requests from unknown users. The detection is important because it locates potential malicious activity or unauthorized access since unknown users can introduce malicious code or gain unauthorized access to repositories leading to unauthorized code changes, data breaches, or other security incidents. Next steps include reviewing the author's name, the repository involved, the head reference of the pull request, and the commit message upon triage of a potential pull request from an unknown user. You must also analyze any relevant on-disk artifacts and investigate any concurrent processes to determine the source and intent of the pull request."
 data_source: []
 search: '`github` check_suite.pull_requests{}.id=* | stats count by check_suite.head_commit.author.name
   repository.full_name check_suite.pull_requests{}.head.ref check_suite.head_commit.message

detections/cloud/o365_new_federated_domain_added.yml

@@ -5,13 +5,13 @@ date: '2023-08-02'
 author: Rod Soto, Splunk
 status: production
 type: TTP
-description: The following search detects the addition of a new Federated domain in O365 environments.  If an attacker adds an unverified domain to Office 365, they may gain unauthorized access to the organization's email and other services, potentially leading to data breaches and information theft. It can be misused to set up adversary infrastruture for phishing, spoofing emails and malware distribution.
+description: |-
+  The following analytic detects the addition of a new federated domain in an organization's Office 365 environment. Identifies instances where a new federated domain is added to the organization's Office 365 configuration and helps to take immediate action to mitigate the risks, prevent further unauthorized access, and protect the organization's data and systems. The detection is made by the Splunk query `o365_management_activity` with the parameters `Workload=Exchange` and `Operation="Add-FederatedDomain"`, which analyzes the management activity logs in Office 365 and filters for the specific operation to add a federated domain. The detection is important because identifying the addition of a new federated domain can indicate potential unauthorized access or compromise of the organization's Office 365 environment. A new Federated domain can be added by an attacker to gain unauthorized access, exfiltrate data, or carry out other malicious activity, which can lead to data breaches, unauthorized access to sensitive information, or compromise of the organization's systems and infrastructure. Next steps include viewing the details of the added federated domain, including the organization name, originating server, user ID, and user key. You must also capture and analyze any relevant on-disk artifacts. Additionally, you must identify the source of the attack by looking for concurrent processes or other indicators of compromise.
 data_source: []
 search: '`o365_management_activity` Operation IN ("*add*", "*new*") AND Operation="*domain*"
-  | stats count values(ModifiedProperties{}.NewValue) as new_value by  user user_agent authentication_service action Workload Operation 
-  | `security_content_ctime(firstTime)` 
-  | `security_content_ctime(lastTime)`
-  | `o365_new_federated_domain_added_filter`'
+  | stats count values(ModifiedProperties{}.NewValue) as new_value by  user user_agent
+  authentication_service action Workload Operation | `security_content_ctime(firstTime)`
+  | `security_content_ctime(lastTime)` | `o365_new_federated_domain_added_filter`'
 how_to_implement: You must install splunk Microsoft Office 365 add-on. This search
   works with o365:management:activity.
 known_false_positives: The creation of a new Federated domain is not necessarily malicious,

detections/cloud/o365_suspicious_user_email_forwarding.yml

@@ -5,8 +5,8 @@ date: '2020-12-16'
 author: Patrick Bareiss, Splunk
 status: production
 type: Anomaly
-description: This search detects when multiple user configured a forwarding rule to
-  the same destination.
+description: |-
+  The following analytic detects when multiple users have configured a forwarding rule to the same destination to proactively identify and investigate potential security risks related to email forwarding and take appropriate actions to protect the organization's data and prevent unauthorized access or data breaches. This detection is made by a Splunk query to O365 management activity logs with the operation `Set-Mailbox` to gather information about mailbox configurations. Then, the query uses the `spath` function to extract the parameters and rename the "Identity" field as "src_user" and searches for entries where the "ForwardingSmtpAddress" field is not empty, which indicates the presence of a forwarding rule. Next, the analytic uses the `stats` command to group the results by the forwarding email address and count the number of unique source users (`src_user`). Finally, it filters the results and only retains entries where the count of source users (`count_src_user`) is greater than 1, which indicates that multiple users have set up forwarding rules to the same destination. This detection is important because it suggests that multiple users are forwarding emails to the same destination without proper authorization, which can lead to the exposure of sensitive information, loss of data control, or unauthorized access to confidential emails. Investigating and addressing this issue promptly can help prevent data breaches and mitigate potential damage.indicates a potential security risk since multiple users forwarding emails to the same destination can be a sign of unauthorized access, data exfiltration, or a compromised account. Additionally, it also helps to determine if the forwarding rules are legitimate or if they indicate a security incident. False positives can occur if there are legitimate reasons for multiple users to forward emails to the same destination, such as a shared mailbox or a team collaboration scenario. Next steps include further investigation and context analysis to determine the legitimacy of the forwarding rules.
 data_source: []
 search: '`o365_management_activity` Operation=Set-Mailbox | spath input=Parameters
   | rename Identity AS src_user | search ForwardingSmtpAddress=* | stats dc(src_user)

detections/endpoint/access_lsass_memory_for_dump_creation.yml

@@ -5,7 +5,8 @@ date: '2019-12-06'
 author: Patrick Bareiss, Splunk
 status: production
 type: TTP
-description: The following analytic is designed to detect potentially malicious activities involving the Local Security Authority Subsystem Service (LSASS) process. Specifically, it identifies when the LSASS process memory is being dumped, an action often associated with credential dumping attacks. This analytic leverages Sysmon logs, particularly those with EventCode 10 related to lsass.exe. It searches for indicators of LSASS memory dumping, such as specific call traces to dbgcore.dll and dbghelp.dll. While memory dumps can be legitimate administrative tasks, LSASS memory dumps are typically unusual and warrant investigation. To implement this analytic, ensure your Sysmon setup includes EventCode 10 logging for lsass.exe and customize the provided macros (sysmon and post-filter macro) to match your specific Splunk environment configuration.
+description: |-
+  The following analytic detects the dumping of the LSASS process memory, which occurs during credential dumping attacks.The detection is made by using Sysmon logs, specifically EventCode 10, which is related to lsass.exe. This helps to search for indicators of LSASS memory dumping such as specific call traces to dbgcore.dll and dbghelp.dll. This detection is important because it prevents credential dumping attacks and the theft of sensitive information such as login credentials, which can be used to gain unauthorized access to systems and data. False positives might occur due to legitimate administrative tasks. Next steps include reviewing and investigating each case, given the high risk associated with potential credential dumping attacks.
 data_source:
 - Sysmon Event ID 1
 search: '`sysmon` EventCode=10 TargetImage=*lsass.exe CallTrace=*dbgcore.dll* OR CallTrace=*dbghelp.dll*

detections/endpoint/allow_inbound_traffic_by_firewall_rule_registry.yml

@@ -5,7 +5,7 @@ date: '2023-03-29'
 author: Steven Dick, Teoderick Contreras, Splunk
 status: production
 type: TTP
-description: This analytic detects a potential suspicious modification of firewall
+description: The following analytic detects a potential suspicious modification of firewall
   rule registry allowing inbound traffic in specific port with public profile. This
   technique was identified when an adversary wants to grant remote access to a machine
   by allowing the traffic in a firewall rule.

detections/endpoint/attacker_tools_on_endpoint.yml

@@ -5,17 +5,8 @@ date: '2021-11-04'
 author: Bhavin Patel, Splunk
 status: production
 type: TTP
-description: The following analytic aims to identify the use of tools commonly exploited
-  by cybercriminals. The use of these tools often signals nefarious activities like
-  unauthorized access, network scanning, or data exfiltration, representing a significant
-  threat to an organization's security infrastructure. By examining process activity
-  on the host, particularly those processes corresponding to known attacker tool names,
-  this analytic serves as an early warning system for potential security incidents.
-  However, its precision must be balanced with the understanding that some administrative
-  activities might also trigger alerts, resulting in false positives. This underlines
-  the importance of cyber analysts having a clear understanding of typical endpoint
-  activities and behaviors within their organization, enabling them to accurately
-  interpret and respond to these alerts.
+description: |-
+  The following analytic detects the use of tools that are commonly exploited by cybercriminals since these tools are usually associated with malicious activities such as unauthorized access, network scanning, or data exfiltration and pose a significant threat to an organization's security infrastructure. It also provides enhanced visibility into potential security threats and helps to proactively detect and respond to mitigate the risks associated with cybercriminal activities. This detection is made by examining the process activity on the host, specifically focusing on processes that are known to be associated with attacker tool names. This detection is important because it acts as an early warning system for potential security incidents that allows you to respond to security incidents promptly. False positives might occur due to legitimate administrative activities that can resemble malicious actions. You must develop a comprehensive understanding of typical endpoint activities and behaviors within the organization to accurately interpret and respond to the alerts generated by this analytic. This ensures a proper balance between precision and minimizing false positives.
 data_source:
 - Sysmon Event ID 1
 search: '| tstats `security_content_summariesonly` count min(_time) as firstTime max(_time)

detections/endpoint/attempt_to_add_certificate_to_untrusted_store.yml

@@ -5,17 +5,8 @@ date: '2021-09-16'
 author: Patrick Bareiss, Rico Valdez, Splunk
 status: production
 type: TTP
-description: The following analytic is designed to detect potential security threats
-  involving the misuse of system trust. It works by detecting events where a process
-  attempts to add a certificate to the untrusted certificate store, an action often
-  associated with disabling security tools. The analytic uses Sysmon Event ID 1 data
-  source, particularly focusing on process activities and command-line arguments related
-  to 'certutil -addstore'. It's essential to ingest data that records process activity
-  and logs containing process names and command lines for its effective operation.
-  Be aware, sometimes administrators might legitimately perform this action. The analytic's
-  value lies in detecting isolated or unexpected instances, indicative of potential
-  malicious activities. Cybersecurity analysts should understand the importance of
-  trust mechanisms and their subversion in system security.
+description: |-
+  The following analytic detects whether a process is attempting to add a certificate to the untrusted certificate store, which might result in security tools being disabled. The detection is made by focusing on process activities and command-line arguments that are related to the 'certutil -addstore' command. This detection is important because it helps to identify attackers who might add a certificate to the untrusted certificate store to disable security tools and gain unauthorized access to a system. False positives might occur since legitimate reasons might exist for a process to add a certificate to the untrusted certificate store, such as system administration tasks. Next steps include conducting an extensive triage and investigation prior to taking any action. Additionally, you must understand the importance of trust and its subversion in system security.
 data_source:
 - Sysmon Event ID 1
 search: '| tstats `security_content_summariesonly` count min(_time) as firstTime values(Processes.process)

detections/endpoint/attempt_to_stop_security_service.yml

@@ -5,8 +5,8 @@ date: '2023-06-13'
 author: Rico Valdez, Splunk
 status: production
 type: TTP
-description: This search looks for attempts to stop security-related services on the
-  endpoint.
+description: |-
+  The following analytic detects attempts to stop security-related services on the endpoint and helps to mitigate potential threats earlier, thereby minimizing the impact on the organization's security. The detection is made by using a Splunk query that searches for processes that involve the "sc.exe" command and include the phrase "stop" in their command. The query collects information such as the process name, process ID, parent process, user, destination, and timestamps. The detection is important because attempts to stop security-related services can indicate malicious activity or an attacker's attempt to disable security measures. This can impact the organization's security posture and can lead to the compromise of the endpoint and potentially the entire network. Disabling security services can allow attackers to gain unauthorized access, exfiltrate sensitive data, or launch further attacks, such as malware installation or privilege escalation. False positives might occur since there might be legitimate reasons for stopping these services in certain situations. Therefore, you must exercise caution and consider the context of the activity before taking any action. Next steps include reviewing the identified process and its associated details. You must also investigate any on-disk artifacts related to the process and review concurrent processes to determine the source of the attack.
 data_source:
 - Sysmon Event ID 1
 search: '| tstats `security_content_summariesonly` values(Processes.process) as process

detections/endpoint/cmlua_or_cmstplua_uac_bypass.yml

@@ -5,7 +5,7 @@ date: '2021-05-13'
 author: Teoderick Contreras, Splunk
 status: production
 type: TTP
-description: This analytic detects a potential process using COM Object like CMLUA
+description: The following analytic detects a potential process using COM Object like CMLUA
   or CMSTPLUA to bypass UAC. This technique has been used by ransomware adversaries
   to gain administrative privileges to its running process.
 data_source:

detections/endpoint/common_ransomware_extensions.yml

@@ -5,8 +5,7 @@ date: '2022-11-10'
 author: David Dorsey, Michael Haag, Splunk, Steven Dick
 status: production
 type: Hunting
-description: The search looks for file modifications with extensions commonly used
-  by Ransomware
+description: "The following analytic detects Searches for file modifications that commonly occur with Ransomware to detect modifications to files with extensions that are commonly used by Ransomware. The detection is made by searches for changes in the datamodel=Endpoint.Filesystem, specifically modifications to file extensions that match those commonly used by Ransomware. The detection is important because it suggests that an attacker is attempting to encrypt or otherwise modify files in the environment using malware, potentially leading to data loss that can cause significant damage to an organization's data and systems. False positives might occur so the SOC must investigate the affected system to determine the source of the modification and take appropriate action to contain and remediate the attack."
 data_source:
 - Sysmon Event ID 11
 search: '| tstats `security_content_summariesonly` min(_time) as firstTime max(_time)

detections/endpoint/create_local_admin_accounts_using_net_exe.yml

@@ -5,8 +5,8 @@ date: '2021-09-08'
 author: Bhavin Patel, Splunk
 status: production
 type: TTP
-description: This search looks for the creation of local administrator accounts using
-  net.exe .
+description: |-
+  The following analytic detects the creation of local administrator accounts using the net.exe command to mitigate the risks associated with unauthorized access and prevent further damage to the environment by responding to potential threats earlier and taking appropriate actions to protect the organization's systems and data. This detection is made by a Splunk query to search for processes with the name net.exe or net1.exe that include the "/add" parameter and have specific keywords related to administrator accounts in their process name. This detection is important because the creation of unauthorized local administrator accounts might indicate that an attacker has successfully created a new administrator account and is trying to gain persistent access to a system or escalate their privileges for data theft, or other malicious activities. False positives might occur since there might be legitimate uses of the net.exe command and the creation of administrator accounts in certain circumstances. You must consider the context of the activity and other indicators of compromise before taking any action. For next steps, review the details of the identified process, including the user, parent process, and parent process name. Examine any relevant on-disk artifacts and look for concurrent processes to determine the source of the attack.
 data_source:
 - Sysmon Event ID 1
 search: '| tstats `security_content_summariesonly` count values(Processes.user) as

detections/endpoint/create_or_delete_windows_shares_using_net_exe.yml

@@ -5,8 +5,8 @@ date: '2020-09-16'
 author: Bhavin Patel, Splunk
 status: production
 type: TTP
-description: This search looks for the creation or deletion of hidden shares using
-  net.exe.
+description: |-
+  The following analytic detects the creation or deletion of hidden shares using the net.exe command for prompt response and mitigation to enhance the overall security posture of the organization and protect against potential data breaches, malware infections, and other damaging outcomes. This detection is made by searching for processes that involve the use of net.exe and filters for actions related to creation or deletion of shares. This detection is important because it suggests that an attacker is attempting to manipulate or exploit the network by creating or deleting hidden shares. The creation or deletion of hidden shares can indicate malicious activity since attackers might use hidden shares to exfiltrate data, distribute malware, or establish persistence within a network. The impact of such an attack can vary, but it often involves unauthorized access to sensitive information, disruption of services, or the introduction of malware. False positives might occur since legitimate actions can also involve the use of net.exe. An extensive triage and investigation is necessary to determine the intent and nature of the detected activity. Next steps include reviewing the details of the process involving the net.exe command, including the user, parent process, and timestamps during the triage. Additionally, capture and inspect any relevant on-disk artifacts and review concurrent processes to identify the source of the attack.
 data_source:
 - Sysmon Event ID 1
 search: '| tstats `security_content_summariesonly` count values(Processes.user) as

detections/endpoint/create_remote_thread_into_lsass.yml

@@ -5,7 +5,7 @@ date: '2019-12-06'
 author: Patrick Bareiss, Splunk
 status: production
 type: TTP
-description: The following analytic developed to detect potential credential dumping attacks where a remote thread is created in the Local Security Authority Subsystem Service (LSASS). Credential dumping, a common tactic used by adversaries to steal user authentication credentials, is a significant threat to network security. The analytic leverages Sysmon Event ID 8 logs and looks for processes creating remote threads in lsass.exe, an unusual activity generally linked to credential theft. The confidence level in this alert is high, but it's worth noting that there might be cases where legitimate tools can access LSASS, generating similar logs. As an analyst, it is critical to understand the broader context of such events and differentiate between legitimate activities and possible threats.
+description: "The following analytic detects the creation of a remote thread in the Local Security Authority Subsystem Service (LSASS), which is a common tactic used by adversaries to steal user authentication credentials, known as credential dumping. The detection is made by leveraging Sysmon Event ID 8 logs and searches for processes that create remote threads in lsass.exe. This is an unusual activity that is generally linked to credential theft or credential dumping, which is a significant threat to network security. The detection is important because it helps to detect potential credential dumping attacks, which can result in significant damage to an organization's security. False positives might occur though the confidence level of this alert is high. There might be cases where legitimate tools can access LSASS and generate similar logs. Therefore, you must understand the broader context of such events and differentiate between legitimate activities and possible threats."
 data_source:
 - Sysmon Event ID 8
 search: '`sysmon` EventID=8 TargetImage=*lsass.exe | stats count min(_time) as firstTime

detections/endpoint/creation_of_shadow_copy_with_wmic_and_powershell.yml

@@ -5,8 +5,8 @@ date: '2021-09-16'
 author: Patrick Bareiss, Splunk
 status: production
 type: TTP
-description: This search detects the use of wmic and Powershell to create a shadow
-  copy.
+description: |-
+  The following analytic detects the use of two specific tools, wmic and Powershell, to create a shadow copy to identify potential threats earlier and take appropriate actions to mitigate the risks. This detection is made by a Splunk query that searches for processes in the Endpoint.Processes data model where either the process name contains "wmic" or "Powershell" and the process command contains "shadowcopy" and "create". This detection is important because it suggests that an attacker is attempting to manipulate or access data in an unauthorized manner, which can lead to data theft, data manipulation, or other malicious activities. Attackers might use shadow copies to backup and exfiltrate sensitive data or to hide their tracks by restoring files to a previous state after an attack. Next steps include reviewing the user associated with the process, the process name, the original file name, the process command, and the destination of the process. Additionally, examine any relevant on-disk artifacts and review other concurrent processes to determine the source of the attack.
 data_source:
 - Sysmon Event ID 1
 search: '| tstats `security_content_summariesonly` count min(_time) as firstTime max(_time)

detections/endpoint/credential_dumping_via_copy_command_from_shadow_copy.yml

@@ -5,8 +5,7 @@ date: '2021-09-16'
 author: Patrick Bareiss, Splunk
 status: production
 type: TTP
-description: This search detects credential dumping using copy command from a shadow
-  copy.
+description: "The following analytic detects the use of the copy command to dump credentials from a shadow copy so that you can detect potential threats earlier and mitigate the risks associated with credential dumping. The detection is made by using a Splunk query to search for specific processes that indicate credential dumping activity. The query looks for processes with command lines that include references to certain files, such as \"sam\", \"security\", \"system\", and \"ntds.dit\", located in system directories like \"system32\" or \"windows\". The detection is important because it suggests that an attacker is attempting to extract credentials from a shadow copy. Credential dumping is a common technique used by attackers to obtain sensitive login information and gain unauthorized access to systems to escalate privileges, move laterally within the network, or gain unauthorized access to sensitive data. False positives might occur since legitimate processes might also reference these files. During triage, it is crucial to review the process details, including the source and the command that is run. Additionally, you must capture and analyze any relevant on-disk artifacts and investigate concurrent processes to determine the source of the attack"
 data_source:
 - Sysmon Event ID 1
 search: '| tstats `security_content_summariesonly` count min(_time) as firstTime max(_time)

detections/endpoint/credential_dumping_via_symlink_to_shadow_copy.yml

@@ -5,7 +5,8 @@ date: '2021-09-16'
 author: Patrick Bareiss, Splunk
 status: production
 type: TTP
-description: This search detects the creation of a symlink to a shadow copy.
+description: |-
+  The following analytic detects the creation of a symlink to a shadow copy to identify potential threats earlier and mitigate the risks associated with symlink creation to shadow copies.  The detection is made by using a Splunk query that searches for processes with commands containing "mklink" and "HarddiskVolumeShadowCopy". This analytic retrieves information such as the destination, user, process name, process ID, parent process, original file name, and parent process ID from the Endpoint.Processes data model.  The detection is important because it indicates potential malicious activity since attackers might use this technique to manipulate or delete shadow copies, which are used for system backup and recovery. This detection helps to determine if an attacker is attempting to cover their tracks or prevent data recovery in the event of an incident. The impact of such an attack can be significant since it can hinder incident response efforts, prevent data restoration, and potentially lead to data loss or compromise. Next steps include reviewing the details of the process, such as the destination and the user responsible for creating the symlink. Additionally, you must examine the parent process, any relevant on-disk artifacts, and concurrent processes to identify the source of the attack.
 data_source:
 - Sysmon Event ID 1
 search: '| tstats `security_content_summariesonly` count min(_time) as firstTime max(_time)

detections/endpoint/detect_baron_samedit_cve_2021_3156.yml

@@ -5,7 +5,8 @@ date: '2021-01-27'
 author: Shannon Davis, Splunk
 status: experimental
 type: TTP
-description: This search detects the heap-based buffer overflow of sudoedit
+description: |-
+  The following analytic detects a specific type of vulnerability known as a heap-based buffer overflow in the sudoedit command, commonly referred to as Baron Samedit CVE-2021-3156. The detection is made by a Splunk query that searches for instances of the sudoedit command with the "-s" flag followed by a double quote. This combination of parameters is indicative of the vulnerability being exploited. The detection is important because it suggests that an attacker is attempting to exploit the Baron Samedit vulnerability. The Baron Samedit vulnerability allows an attacker to gain elevated privileges on a Linux system and run arbitrary code with root privileges, potentially leading to complete control over the affected system. The impact of a successful attack can be severe since it allows the attacker to bypass security measures and gain unauthorized access to sensitive data or systems. This can result in data breaches, unauthorized modifications, or even complete system compromise. Next steps include being aware of this vulnerability and actively monitoring any attempts to exploit it. By detecting and responding to such attacks in a timely manner, you can prevent or minimize the potential damage caused by the heap-based buffer overflow of sudoedit.
 data_source: []
 search: '`linux_hosts` "sudoedit -s \\" | `detect_baron_samedit_cve_2021_3156_filter`'
 how_to_implement: Splunk Universal Forwarder running on Linux systems, capturing logs

detections/endpoint/detect_baron_samedit_cve_2021_3156_segfault.yml

@@ -5,7 +5,8 @@ date: '2021-01-29'
 author: Shannon Davis, Splunk
 status: experimental
 type: TTP
-description: This search detects the heap-based buffer overflow of sudoedit
+description: |-
+  The following analytic detects the occurrence of a heap-based buffer overflow in sudoedit.The detection is made by using a Splunk query to identify Linux hosts where the terms "sudoedit" and "segfault" appear in the logs. The detection is important because the heap-based buffer overflow vulnerability in sudoedit can be exploited by attackers to gain elevated root privileges on a vulnerable system, which might lead to the compromise of sensitive data, unauthorized access, and other malicious activities. False positives might occur. Therefore, you must review the logs and investigate further before taking any action.
 data_source: []
 search: '`linux_hosts` TERM(sudoedit) TERM(segfault) | stats count min(_time) as firstTime
   max(_time) as lastTime by host | where count > 5 | `detect_baron_samedit_cve_2021_3156_segfault_filter`'

detections/endpoint/detect_baron_samedit_cve_2021_3156_via_osquery.yml

@@ -5,7 +5,7 @@ date: '2021-01-28'
 author: Shannon Davis, Splunk
 status: experimental
 type: TTP
-description: This search detects the heap-based buffer overflow of sudoedit
+description: "The following analytic detects the heap-based buffer overflow for the sudoedit command and identifies instances where the command \"sudoedit -s *\" is run using the osquery_process data source. This indicates that the sudoedit command is used with the \"-s\" flag, which is associated with the heap-based buffer overflow vulnerability. The detection is important because it indicates a potential security vulnerability, specifically Baron Samedit CVE-2021-3156, which helps to identify and respond to potential heap-based buffer overflow attacks to enhance the security posture of the organization. This vulnerability allows an attacker to escalate privileges and potentially gain unauthorized access to the system. If the attack is successful, the attacker can gain full control of the system, run arbitrary code, or access sensitive data. Such attacks can lead to data breaches, unauthorized access, and potential disruption of critical systems. False positives might occur since the legitimate use of the sudoedit command with the \"-s\" flag can also trigger this detection. You must carefully review and validate the findings before taking any action. Next steps include investigating all true positive detections promptly, reviewing the associated processes, gather relevant artifacts, identifying the source of the attack to contain the threat, mitigate the risks, and prevent further damage to the environment."
 data_source: []
 search: '`osquery_process` | search "columns.cmdline"="sudoedit -s \\*" | `detect_baron_samedit_cve_2021_3156_via_osquery_filter`'
 how_to_implement: OSQuery installed and configured to pick up process events (info

detections/endpoint/detect_certipy_file_modifications.yml

@@ -0,0 +1,87 @@
+name: Detect Certipy File Modifications
+id: 7e3df743-b1d8-4631-8fa8-bd5819688876
+version: 1
+date: '2023-06-25'
+author: Steven Dick
+status: production
+type: TTP
+description: The following analytic identifies when the attacker tool Certipy is used to enumerate Active Directory Certificate Services (AD CS) environments. The default behavior of this toolkit drops a number of file uniquely named files or file extensions related to it's information gathering and exfiltration process.
+data_source:
+- Windows Security 4663
+- Sysmon Event ID 11
+- Sysmon Event ID 15
+- Sysmon Event ID 26
+search: '| tstats `security_content_summariesonly` count min(_time) AS firstTime max(_time) AS lastTime values(Processes.process_current_directory) as process_current_directory FROM datamodel=Endpoint.Processes where Processes.action="allowed" BY _time span=1h Processes.user Processes.dest Processes.process_id Processes.process_name Processes.process Processes.process_path Processes.parent_process_name Processes.parent_process Processes.process_guid Processes.action
+|`drop_dm_object_name(Processes)` 
+| join max=0 dest process_guid [| tstats `security_content_summariesonly` count min(_time) as firstTime max(_time) as lastTime from datamodel=Endpoint.Filesystem where Filesystem.file_name IN ("*_certipy.zip", "*_certipy.txt", "*_certipy.json", "*.ccache") by Filesystem.file_create_time Filesystem.process_id Filesystem.process_guid Filesystem.file_name Filesystem.file_path Filesystem.dest
+| `drop_dm_object_name(Filesystem)` 
+]
+| fields firstTime lastTime user dest file_create_time file_name file_path parent_process_name parent_process process_name process_path process_current_directory process process_guid process_id
+| where isnotnull(file_name)
+| `security_content_ctime(firstTime)` 
+| `security_content_ctime(lastTime)`
+| `detect_certipy_file_modifications_filter`'
+how_to_implement: To successfully implement this search, you need to be ingesting logs with the process name, parent process, and command-line executions from your endpoints as well as file creation or deletion events. 
+known_false_positives: Unknown
+references:
+- https://github.com/ly4k/Certipy
+tags:
+  analytic_story:
+  - Windows Certificate Services
+  - Data Exfiltration
+  - Ingress Tool Transfer
+  asset_type: Endpoint
+  confidence: 90
+  impact: 50
+  message: Suspicious files $file_name$ related to Certipy detected on $dest$
+  mitre_attack_id:
+  - T1649
+  - T1560
+  observable:
+  - name: dest
+    type: Hostname
+    role:
+    - Victim
+  - name: user
+    type: User
+    role:
+    - Victim
+  - name: file_name
+    type: File Name
+    role:
+    - Attacker
+  - name: process_name
+    type: Process Name
+    role:
+    - Attacker
+  product:
+  - Splunk Enterprise
+  - Splunk Enterprise Security
+  - Splunk Cloud
+  required_fields:
+  - _time
+  - Processes.user 
+  - Processes.dest 
+  - Processes.process_id 
+  - Processes.process_name 
+  - Processes.process 
+  - Processes.process_path 
+  - Processes.parent_process_name 
+  - Processes.parent_process 
+  - Processes.process_guid 
+  - Processes.action
+  - Filesystem.file_create_time 
+  - Filesystem.process_id 
+  - Filesystem.process_guid 
+  - Filesystem.file_name 
+  - Filesystem.file_path 
+  - Filesystem.dest
+  risk_score: 45
+  security_domain: endpoint
+tests:
+- name: True Positive Test
+  attack_data:
+  - data: https://media.githubusercontent.com/media/splunk/attack_data/master/datasets/attack_techniques/T1649/certify_abuse/certify_esc1_abuse_sysmon.log
+    source: XmlWinEventLog:Microsoft-Windows-Sysmon/Operational
+    sourcetype: xmlwineventlog
+    update_timestamp: true

detections/endpoint/detect_credential_dumping_through_lsass_access.yml

@@ -5,8 +5,8 @@ date: '2019-12-03'
 author: Patrick Bareiss, Splunk
 status: production
 type: TTP
-description: This search looks for reading lsass memory consistent with credential
-  dumping.
+description: |-
+  The following analytic detects the reading of lsass memory, which is consistent with credential dumping. Reading lsass memory is a common technique used by attackers to steal credentials from the Windows operating system. The detection is made by monitoring the sysmon events and filtering for specific access permissions (0x1010 and 0x1410) on the lsass.exe process helps identify potential instances of credential dumping.The detection is important because it suggests that an attacker is attempting to extract credentials from the lsass memory, which can lead to unauthorized access, data breaches, and compromise of sensitive information. Credential dumping is often a precursor to further attacks, such as lateral movement, privilege escalation, or data exfiltration. False positives can occur due to legitimate actions that involve accessing lsass memory. Therefore, extensive triage and investigation are necessary to differentiate between malicious and benign activities.
 data_source:
 - Sysmon Event ID 1
 search: '`sysmon` EventCode=10 TargetImage=*lsass.exe (GrantedAccess=0x1010 OR GrantedAccess=0x1410)

detections/endpoint/detect_new_local_admin_account.yml

@@ -5,8 +5,8 @@ date: '2020-07-08'
 author: David Dorsey, Splunk
 status: production
 type: TTP
-description: This search looks for newly created accounts that have been elevated
-  to local administrators.
+description: |-
+  The following analytic detects the creation of new accounts that have been elevated to local administrators so that you can take immediate action to mitigate the risks and prevent further unauthorized access or malicious activities. This detection is made by using the Splunk query `wineventlog_security` EventCode=4720 OR (EventCode=4732 Group_Name=Administrators) to search for relevant security events in the Windows event log. When a new account is created or an existing account is added to the Administrators group, this analytic identifies this behavior by looking for EventCode 4720 (A user account was created) or EventCode 4732 (A member was added to a security-enabled global group). This analytic specifically focuses on events where the Group_Name is set to Administrators. This detection is important because it suggests that an attacker has gained elevated privileges and can perform malicious actions with administrative access. This can lead to significant impact, such as unauthorized access to sensitive data, unauthorized modifications to systems or configurations, and potential disruption of critical services. identifying this behavior is crucial for a Security Operations Center (SOC). Next steps include reviewing the details of the security event, including the user account that was created or added to the Administrators group. Also, examine the time span between the first and last occurrence of the event to determine if the behavior is ongoing. Additionally, consider any contextual information, such as the destination where the account was created or added to understand the scope and potential impact of the attack.
 data_source:
 - Windows Security 4732
 - Windows Security 4720

detections/endpoint/disable_windows_app_hotkeys.yml

@@ -5,7 +5,7 @@ date: '2023-04-27'
 author: Steven Dick, Teoderick Contreras, Splunkk
 status: production
 type: TTP
-description: This analytic detects a suspicious registry modification to disable Windows
+description: The following analytic detects a suspicious registry modification to disable Windows
   hotkey (shortcut keys) for native Windows applications. This technique is commonly
   used to disable certain or several Windows applications like `taskmgr.exe` and `cmd.exe`.
   This technique is used to impair the analyst in analyzing and removing the attacker

detections/endpoint/dump_lsass_via_comsvcs_dll.yml

@@ -5,35 +5,15 @@ date: '2023-04-14'
 author: Patrick Bareiss, Splunk
 status: production
 type: TTP
-description: The following analytic detects the behavior of dumping credentials from
-  memory, a tactic commonly used by adversaries. Specifically, it targets the exploitation
-  of the Local Security Authority Subsystem Service (LSASS) in Windows, which manages
-  system-level authentication. Threat actors can use the comsvcs.dll to exploit this
-  process and obtain valuable credentials. The analytic identifies instances where
-  the rundll32 process is used in conjunction with the comsvcs.dll and MiniDump, indicating
-  potential LSASS dumping attempts. This tactic is often part of more extensive attack
-  campaigns and is associated with numerous threat groups. Identifying this behavior
-  is crucial for security operations center (SOC) analysts, as credential theft can
-  lead to broader system compromise, persistence, lateral movement, and escalated
-  privileges. It is important to note that no legitimate use of this technique has
-  been identified so far. The impact of the attack, if a true positive is found, can
-  be severe. Attackers can use the stolen credentials to access sensitive information
-  or systems, leading to data theft, ransomware attacks, or other damaging outcomes.
-  To implement this analytic, ensure that logs with process information are ingested
-  from your endpoints. However, be aware of potential false positives, as legitimate
-  uses of the LSASS process may cause benign activities to be flagged. Upon triage,
-  review the processes involved in the LSASS dumping attempt, capture and inspect
-  any relevant on-disk artifacts, and look for concurrent processes to identify the
-  attack source. By identifying and mitigating LSASS exploitation attempts early on,
-  SOC analysts can better protect their organization's assets and prevent potential
-  breaches.
+description: |-
+  The following analytic detects the behavior of dumping credentials from memory, a tactic commonly used by adversaries to exploit the Local Security Authority Subsystem Service (LSASS) in Windows, which manages system-level authentication. The detection is made by monitoring logs with process information from endpoints and identifying instances where the rundll32 process is used in conjunction with the comsvcs.dll and MiniDump. This indicates potential LSASS dumping attempts used by threat actors to obtain valuable credentials. The detection is important because credential theft can lead to broader system compromise, persistence, lateral movement, and escalated privileges. No legitimate use of this technique has been identified yet. This behavior is often part of more extensive attack campaigns and is associated with numerous threat groups that use the stolen credentials to access sensitive information or systems, leading to data theft, ransomware attacks, or other damaging outcomes. False positives can occur since legitimate uses of the LSASS process can cause benign activities to be flagged. Next steps include reviewing the processes involved in the LSASS dumping attempt after triage and inspecting any relevant on-disk artifacts and concurrent processes to identify the attack source.
 data_source:
 - Sysmon Event ID 1
 search: '| tstats `security_content_summariesonly` count min(_time) as firstTime max(_time)
   as lastTime from datamodel=Endpoint.Processes where `process_rundll32` Processes.process=*comsvcs.dll*
-  Processes.process=*MiniDump* by Processes.user Processes.parent_process_name Processes.process_name Processes.original_file_name
-  Processes.process Processes.dest | `drop_dm_object_name(Processes)` | `security_content_ctime(firstTime)`
-  | `security_content_ctime(lastTime)` | `dump_lsass_via_comsvcs_dll_filter`'
+  Processes.process=*MiniDump* by Processes.user Processes.parent_process_name Processes.process_name
+  Processes.original_file_name Processes.process Processes.dest | `drop_dm_object_name(Processes)`
+  | `security_content_ctime(firstTime)` | `security_content_ctime(lastTime)` | `dump_lsass_via_comsvcs_dll_filter`'
 how_to_implement: The detection is based on data that originates from Endpoint Detection
   and Response (EDR) agents. These agents are designed to provide security-related
   telemetry from the endpoints where the agent is installed. To implement this search,

detections/endpoint/file_with_samsam_extension.yml

@@ -5,8 +5,8 @@ date: '2018-12-14'
 author: Rico Valdez, Splunk
 status: production
 type: TTP
-description: The search looks for file writes with extensions consistent with a SamSam
-  ransomware attack.
+description: |-
+  The following analytic detects file writes with extensions that are consistent with a SamSam ransomware attack to proactively detect and respond to potential SamSam ransomware attacks, minimizing the impact and reducing the likelihood of successful ransomware infections. This detection is made by a Splunk query to search for specific file extensions that are commonly associated with SamSam ransomware, such as .stubbin, .berkshire, .satoshi, .sophos, and .keyxml. This identifies file extensions in the file names of the written files. If any file write events with these extensions are found, it suggests a potential SamSam ransomware attack. This detection is important because SamSam ransomware is a highly destructive and financially motivated attack and suggests that the organization is at risk of having its files encrypted and held for ransom, which can lead to significant financial losses, operational disruptions, and reputational damage. False positives might occur since legitimate files with these extensions can exist in the environment. Therefore, next steps include conducting a careful analysis and triage to confirm the presence of a SamSam ransomware attack. Next steps include taking immediate action to contain the attack, mitigate the impact, and prevent further spread of the ransomware. This might involve isolating affected systems, restoring encrypted files from backups, and conducting a thorough investigation to identify the attack source and prevent future incidents.
 data_source:
 - Sysmon Event ID 11
 search: '| tstats `security_content_summariesonly` count min(_time) as firstTime max(_time)

detections/endpoint/firewall_allowed_program_enable.yml

@@ -5,7 +5,7 @@ date: '2021-11-12'
 author: Teoderick Contreras, Splunk
 status: production
 type: Anomaly
-description: This analytic detects a potential suspicious modification of firewall
+description: The following analytic detects a potential suspicious modification of firewall
   rule allowing to execute specific application. This technique was identified when
   an adversary and red teams to bypassed firewall file execution restriction in a
   targetted host. Take note that this event or command can run by administrator during

detections/endpoint/linux_decode_base64_to_shell.yml

@@ -5,8 +5,8 @@ date: '2022-07-27'
 author: Michael Haag, Splunk
 status: production
 type: TTP
-description: The following analytic identifies base64 being decoded and passed to
-  a Linux shell.
+description: |-
+  The following analytic detects the behavior of decoding base64-encoded data and passing it to a Linux shell. Additionally, it mitigates the potential damage and protects the organization's systems and data.The detection is made by searching for specific commands in the Splunk query, namely "base64 -d" and "base64 --decode", within the Endpoint.Processes data model. The analytic also includes a filter for Linux shells. The detection is important because  it indicates the presence of malicious activity since Base64 encoding is commonly used to obfuscate malicious commands or payloads, and decoding it can be a step in running those commands. It suggests that an attacker is attempting to run malicious commands on a Linux system to gain unauthorized access, for data exfiltration, or perform other malicious actions.
 data_source:
 - Sysmon Event ID 1
 search: '| tstats `security_content_summariesonly` count min(_time) as firstTime max(_time)

detections/endpoint/powershell_invoke_wmiexec_usage.yml

@@ -8,7 +8,7 @@ type: TTP
 status: production
 data_source:
 - Powershell 4104
-description: This analytic detects the usage of the Invoke-WMIExec utility within PowerShell Script Block Logging (EventCode 4104). The utility is used for executing WMI commands on targets using NTLMv2 pass-the-hash authentication.
+description: The following analytic detects the usage of the Invoke-WMIExec utility within PowerShell Script Block Logging (EventCode 4104). The utility is used for executing WMI commands on targets using NTLMv2 pass-the-hash authentication.
 search: '`powershell` EventCode=4104 ScriptBlockText IN ("*invoke-wmiexec*") 
   | stats count min(_time) as firstTime max(_time) as lastTime by Computer EventCode ScriptBlockText 
   | `security_content_ctime(firstTime)` 

detections/endpoint/remcos_client_registry_install_entry.yml

@@ -5,8 +5,8 @@ date: '2022-11-14'
 author: Steven Dick, Bhavin Patel, Rod Soto, Teoderick Contreras, Splunk
 status: production
 type: TTP
-description: This search detects registry key license at host where Remcos RAT agent
-  is installed.
+description: |-
+  The following analytic detects the presence of a registry key related to the Remcos RAT agent on a host. This detection is made by a Splunk query to search for instances where the registry key "license" is found in the "Software\Remcos" path. This analytic combines information from two data models: Endpoint.Processes and Endpoint.Registry and retrieves process information such as user, process ID, process name, process path, destination, parent process name, parent process, and process GUID. This analytic also retrieves registry information such as registry path, registry key name, registry value name, registry value data, and process GUID. By joining the process GUID from the Endpoint.Processes data model with the process GUID from the Endpoint.Registry data model, the analytic identifies instances where the "license" registry key is found in the "Software\Remcos" path. This detection is important because it suggests that the host has been compromised by the Remcos RAT agent. Remcos is a well-known remote access Trojan that can be used by attackers to gain unauthorized access to systems and exfiltrate sensitive data. Identifying this behavior allows the SOC to take immediate action to remove the RAT agent and prevent further compromise. The impact of this attack can be severe, as the attacker can gain unauthorized access to the system, steal sensitive information, or use the compromised system as a launching point for further attacks. Next steps include using this analytic in conjunction with other security measures and threat intelligence to ensure accurate detection and response.
 data_source:
 - Sysmon Event ID 1
 search: '| tstats `security_content_summariesonly` count min(_time) AS firstTime max(_time)

detections/endpoint/scheduled_task_initiation_on_remote_endpoint.yml

@@ -5,7 +5,7 @@ date: '2021-11-11'
 author: Mauricio Velazco, Splunk
 status: production
 type: TTP
-description: This analytic detects instances of 'schtasks.exe' being used to start
+description: The following analytic detects instances of 'schtasks.exe' being used to start
   a Scheduled Task on a remote endpoint. Adversaries often abuse the Task Scheduler
   for lateral movement and remote code execution. The search parameters include process
   details such as the process  name, parent process, and command-line executions.

detections/endpoint/script_execution_via_wmi.yml

@@ -5,18 +5,8 @@ date: '2020-03-16'
 author: Rico Valdez, Michael Haag, Splunk
 status: production
 type: TTP
-description: The following analytic is designed to detect the potential misuse of
-  Windows Management Instrumentation (WMI) for malicious purposes. WMI can be utilized
-  by adversaries to execute scripts, a method often employed for maintaining stealth
-  while carrying out malicious activities. The process 'scrcons.exe', integral to
-  executing WMI scripts, is primarily monitored by this analytic. The underlying threat
-  lies in the fact that successful execution of a malicious script can lead to numerous
-  negative outcomes, including system compromise, data exfiltration, or the establishment
-  of persistence. It's essential for cybersecurity analysts to remain vigilant towards
-  unexpected or isolated script executions via WMI, as such instances often signal
-  suspicious activities or potential security breaches. Although uncommon, administrators
-  may occasionally use WMI to launch scripts for legitimate purposes. Therefore, discerning
-  malicious activities from benign ones is crucial in this context.
+description: |-
+  The following analytic detects any potential misuse of Windows Management Instrumentation (WMI) for malicious purposes since adversaries often use WMI to run scripts which allows them to carry out malicious activities without raising suspicion. The detection is made by monitoring the process 'scrcons.exe', which is essential to run WMI scripts. The detection is important because it proactively identifies and responds to potential threats that leverage WMI for malicious purposes that can lead to system compromise, data exfiltration, or the establishment of persistence within the environment. False positives might occur since administrators might occasionally use WMI to launch scripts for legitimate purposes. Therefore, you must distinguish between malicious and benign activities.
 data_source:
 - Sysmon Event ID 1
 search: '| tstats `security_content_summariesonly` count min(_time) as firstTime max(_time)

detections/endpoint/secretdumps_offline_ntds_dumping_tool.yml

@@ -5,7 +5,7 @@ date: '2023-06-13'
 author: Teoderick Contreras, Splunk
 status: production
 type: TTP
-description: This analytic detects a potential usage of secretsdump.py tool for dumping
+description: The following analytic detects a potential usage of secretsdump.py tool for dumping
   credentials (ntlm hash) from a copy of ntds.dit and SAM.Security,SYSTEM registrry
   hive. This technique was seen in some attacker that dump ntlm hashes offline after
   having a copy of ntds.dit and SAM/SYSTEM/SECURITY registry hive.

detections/endpoint/short_lived_windows_accounts.yml

@@ -5,8 +5,8 @@ date: '2020-07-06'
 author: David Dorsey, Splunk
 status: production
 type: TTP
-description: This search detects accounts that were created and deleted in a short
-  time period.
+description: |-
+  The following analytic detects the creation and deletion of accounts in a short time period to identify potential threats earlier and take appropriate actions to mitigate the risks. Helps prevent or minimize the potential damage caused by unauthorized access or malicious activities within the environment. This detection is made by a Splunk query that searches for events with the result IDs 4720 and 4726 in the "Change" data model. The query then groups the results by time, user, and destination. The result is filtered to only include events with the specified result IDs. The "transaction" command is used to group events that occur within a specified time span and have the same user but are not connected. Finally, the relevant information such as the first and last time of the event, the count, user, destination, and result ID are displayed in a table. This detection is important because it suggests that an attacker is attempting to create and delete accounts rapidly, potentially to cover their tracks or gain unauthorized access. The impact of such an attack can include unauthorized access to sensitive data, privilege escalation, or the ability to carry out further malicious activities within the environment. Next steps include investigating the events flagged by the analytic, review the account creation and deletion activities, and analyze any associated logs or artifacts to determine the intent and impact of the attack.
 data_source: []
 search: '| tstats `security_content_summariesonly` values(All_Changes.result_id) as
   result_id count min(_time) as firstTime max(_time) as lastTime from datamodel=Change

detections/endpoint/single_letter_process_on_endpoint.yml

@@ -5,7 +5,8 @@ date: '2020-12-08'
 author: David Dorsey, Splunk
 status: production
 type: TTP
-description: This search looks for process names that consist only of a single letter.
+description: |-
+  The following analytic detects a behavior where a process name consists only of a single letter that helps to detect potential threats earlier and mitigate the risks. This detection is important because it indicates the presence of malware or an attacker attempting to evade detection by using a process name that is difficult to identify or track so that he can carry out malicious activities such as data theft or ransomware attacks. False positives might occur since there might be legitimate uses of single-letter process names in your environment. Next steps include reviewing the process details and investigating any suspicious activity upon triage.
 data_source:
 - Sysmon Event ID 1
 search: '| tstats `security_content_summariesonly` count min(_time) as firstTime max(_time)

detections/endpoint/suspicious_process_dns_query_known_abuse_web_services.yml

@@ -5,7 +5,7 @@ date: '2023-04-14'
 author: Teoderick Contreras, Splunk
 status: production
 type: TTP
-description: This analytic detects a suspicious process making a DNS query via known,
+description: The following analytic detects a suspicious process making a DNS query via known,
   abused text-paste web services, VoIP, instant messaging, and digital distribution
   platforms used to download external files. This technique is abused by adversaries,
   malware actors, and red teams to download a malicious file on the target host. This

detections/endpoint/suspicious_writes_to_windows_recycle_bin.yml

@@ -5,8 +5,8 @@ date: '2020-07-22'
 author: Rico Valdez, Splunk
 status: production
 type: TTP
-description: This search detects writes to the recycle bin by a process other than
-  explorer.exe.
+description: |-
+  The following analytic detects when a process other than explorer.exe writes to the Windows Recycle Bin to detect potential threats earlier and mitigate the risks. This detection is made by a Splunk query that utilizes the Endpoint.Filesystem data model and the Endpoint.Processes data model. The query looks for any process writing to the "*$Recycle.Bin*" file path, excluding explorer.exe. This detection is important because it suggests that an attacker is attempting to hide their activities by using the Recycle Bin, which can lead to data theft, ransomware, or other damaging outcomes. Detecting writes to the Recycle Bin by a process other than explorer.exe can help to investigate and determine if the activity is malicious or benign. False positives might occur since there might be legitimate uses of the Recycle Bin by processes other than explorer.exe. Next steps include reviewing the process writing to the Recycle Bin and any relevant on-disk artifacts upon triage.
 data_source:
 - Sysmon Event ID 11
 search: '| tstats `security_content_summariesonly` count min(_time) as firstTime max(_time)

detections/endpoint/unusually_long_command_line.yml

@@ -5,8 +5,8 @@ date: '2020-12-08'
 author: David Dorsey, Splunk
 status: experimental
 type: Anomaly
-description: Command lines that are extremely long may be indicative of malicious
-  activity on your hosts.
+description: |-
+  The following analytic detects command lines that are extremely long, which might be indicative of malicious activity on your hosts because attackers often use obfuscated or complex command lines to hide their actions and evade detection. This helps to mitigate the risks associated with long command lines to enhance your overall security posture and reduce the impact of attacks. This detection is important because it suggests that an attacker might be attempting to execute a malicious command or payload on the host, which can lead to various damaging outcomes such as data theft, ransomware, or further compromise of the system. False positives might occur since legitimate processes or commands can sometimes result in long command lines. Next steps include conducting extensive triage and investigation to differentiate between legitimate and malicious activities. Review the source of the command line and the command itself during the triage. Additionally, capture and inspect any relevant on-disk artifacts and review concurrent processes to identify the source of the attack.
 data_source:
 - Sysmon Event ID 1
 search: '| tstats `security_content_summariesonly` count min(_time) as firstTime max(_time)

detections/endpoint/windows_abused_web_services.yml

@@ -7,7 +7,7 @@ status: production
 type: TTP
 data_source:
 - Sysmon Event ID 22
-description: This analytic detects a suspicious process making a DNS query via known,
+description: The following analytic detects a suspicious process making a DNS query via known,
   abused text-paste web services, VoIP, internet via secure tunneling,instant messaging, and digital distribution
   platforms used to download external files. This technique is abused by adversaries,
   malware actors, and red teams to download a malicious file on the target host. This

detections/endpoint/windows_ad_domain_controller_audit_policy_disabled.yml

@@ -7,12 +7,19 @@ type: TTP
 status: production
 data_source:
 - Windows Security 4719
-description: This analytic looks for audit policies being disabled on a domain controller.
-search: '`wineventlog_security` EventCode=4719 (AuditPolicyChanges IN ("%%8448","%%8450","%%8448, %%8450") OR Changes IN ("Failure removed","Success removed","Success removed, Failure
-  removed")) dest_category="domain_controller"| replace "%%8448" with "Success removed", "%%8450" with "Failure removed", "%%8448, %%8450" with "Success removed, Failure removed" in AuditPolicyChanges | eval AuditPolicyChanges=coalesce(AuditPolicyChanges,Changes), SubcategoryGuid=coalesce(SubcategoryGuid,Subcategory_GUID) | stats min(_time) as _time values(host) as dest by AuditPolicyChanges SubcategoryGuid | lookup advanced_audit_policy_guids GUID as SubcategoryGuid OUTPUT Category SubCategory | `windows_ad_domain_controller_audit_policy_disabled_filter`'
-how_to_implement: Ensure you are ingesting EventCode `4719` from your domain controllers, the category domain_controller exists
-  in assets and identities, and that assets and identities is enabled. If A&I is not configured, you will need to manually filter the results 
-  within the base search. 
+description: The following analytic detects the disabling of audit policies on a domain controller. The detection is made by identifying changes made to audit policies and checks for the removal of success or failure auditing, which are common indicators of policy tampering. The detection is important because it indicates that an attacker has gained access to the domain controller and is attempting to evade detection and cover up malicious activity. The impact of such an attack can be severe, including data theft, privilege escalation, and compromise of the entire network. False positives might occur since legitimate changes to audit policies might also trigger the analytic. Upon triage, review the audit policy change event and investigate the source of the change. Additionally, you must capture and inspect any relevant on-disk artifacts and review concurrent processes to identify the attack source."
+search: '`wineventlog_security` EventCode=4719 (AuditPolicyChanges IN ("%%8448","%%8450","%%8448,
+  %%8450") OR Changes IN ("Failure removed","Success removed","Success removed, Failure
+  removed")) dest_category="domain_controller"| replace "%%8448" with "Success removed",
+  "%%8450" with "Failure removed", "%%8448, %%8450" with "Success removed, Failure
+  removed" in AuditPolicyChanges | eval AuditPolicyChanges=coalesce(AuditPolicyChanges,Changes),
+  SubcategoryGuid=coalesce(SubcategoryGuid,Subcategory_GUID) | stats min(_time) as
+  _time values(host) as dest by AuditPolicyChanges SubcategoryGuid | lookup advanced_audit_policy_guids
+  GUID as SubcategoryGuid OUTPUT Category SubCategory | `windows_ad_domain_controller_audit_policy_disabled_filter`'
+how_to_implement: Ensure you are ingesting EventCode `4719` from your domain controllers,
+  the category domain_controller exists in assets and identities, and that assets
+  and identities is enabled. If A&I is not configured, you will need to manually filter
+  the results within the base search.
 known_false_positives: Unknown
 references:
 - https://learn.microsoft.com/en-us/windows/security/threat-protection/auditing/event-4719
@@ -41,7 +48,8 @@ tags:
   - SubcategoryGuid
   risk_score: 60
   security_domain: endpoint
-  manual_test: This search uses a lookup provided by Enterprise Security and needs to be manually tested
+  manual_test: This search uses a lookup provided by Enterprise Security and needs
+    to be manually tested
 tests:
 - name: True Positive Test
   attack_data:

detections/endpoint/windows_ad_domain_replication_acl_addition.yml

@@ -7,7 +7,7 @@ type: TTP
 status: experimental
 data_source: []
 description:
-  This analytic detects the addition of the permissions necessary to perform a DCSync attack.
+  The following analytic detects the addition of the permissions necessary to perform a DCSync attack.
   In order to replicate AD objects, the initiating user or computer must have the following permissions on the domain.
   - DS-Replication-Get-Changes
   - DS-Replication-Get-Changes-All

detections/endpoint/windows_command_shell_dcrat_forkbomb_payload.yml

@@ -7,7 +7,7 @@ status: production
 type: TTP
 description: The following analytic identifies DCRat "forkbomb" payload feature. This
   technique was seen in dark crystal RAT backdoor capabilities where it will execute
-  several cmd child process executing "notepad.exe & pause". This analytic detects
+  several cmd child process executing "notepad.exe & pause". The following analytic detects
   the multiple cmd.exe and child process notepad.exe  execution using batch script
   in the targeted host within 30s timeframe. this TTP can be a good pivot to check
   DCRat infection.

detections/endpoint/windows_domain_admin_impersonation_indicator.yml

@@ -0,0 +1,55 @@
+name: Windows Domain Admin Impersonation Indicator
+id: 10381f93-6d38-470a-9c30-d25478e3bd3f
+version: 1
+date: '2023-10-06'
+author: Mauricio Velazco, Splunk
+status: production
+type: TTP
+data_source: []
+description: The following analytic identifies potential Kerberos ticket forging attacks, specifically the Diamond Ticket attack. This is detected when a user logs into a host and the GroupMembership field in event 4627 indicates a privileged group (e.g., Domain Admins), but the user does not actually belong to that group in the directory service. The detection leverages Windows Security Event Log 4627, which logs account logon events. The analytic cross-references the GroupMembership field from the event against a pre-populated lookup of actual group memberships. Its crucial to note that the accuracy and effectiveness of this detection heavily rely on the users diligence in populating and regularly updating this lookup table. Any discrepancies between the events GroupMembership and the lookup indicate potential ticket forging. Kerberos ticket forging, especially the Diamond Ticket attack, allows attackers to impersonate any user and potentially gain unauthorized access to resources. By forging a ticket that indicates membership in a privileged group, an attacker can bypass security controls and gain elevated privileges. Detecting such discrepancies in group memberships during logon events can be a strong indicator of this attack in progress, making it crucial for security teams to monitor and investigate. If validated as a true positive, this indicates that an attacker has successfully forged a Kerberos ticket and may have gained unauthorized access to critical resources, potentially with elevated privileges.
+search: ' `wineventlog_security`  EventCode=4627 LogonType=3 NOT TargetUserName IN ("*$", "SYSTEM", "DWM-*","LOCAL SERVICE","NETWORK SERVICE", "ANONYMOUS LOGON", "UMFD-*") 
+  | where match(GroupMembership, "Domain Admins") 
+  | lookup domain_admins username as TargetUserName OUTPUT username | fillnull value=NotDA username
+  | search username = "NotDA"
+  | stats  count by _time, TargetUserName, GroupMembership, host
+  | `windows_domain_admin_impersonation_indicator_filter`'
+how_to_implement: To successfully implement this search, you need to be ingesting Authentication events across all endpoints and ingest Event Id 4627. Specifically, the Audit Group Membership subcategory within the Logon Logooff category needs to be enabled. Its crucial to note that the accuracy and effectiveness of this detection heavily rely on the users diligence in populating and regularly updating this lookup table.
+known_false_positives: False positives may trigger the detections certain scenarios like directory service delays or out of date lookups. Filter as needed.
+references:
+- https://trustedsec.com/blog/a-diamond-in-the-ruff
+- https://unit42.paloaltonetworks.com/next-gen-kerberos-attacks
+- https://github.com/GhostPack/Rubeus/pull/136
+- https://learn.microsoft.com/en-us/windows/security/threat-protection/auditing/event-4627
+tags:
+  analytic_story:
+  - Active Directory Kerberos Attacks
+  - Active Directory Privilege Escalation
+  asset_type: Endpoint
+  confidence: 100
+  impact: 80
+  message: $TargetUserName$ may be impersonating a Domain Administrator through a forged Kerberos ticket.
+  mitre_attack_id:
+  - T1558
+  observable:
+  - name: TargetUserName
+    type: User
+    role:
+    - Attacker
+  product:
+  - Splunk Enterprise
+  - Splunk Enterprise Security
+  - Splunk Cloud
+  risk_score: 80
+  required_fields:
+  - _time,
+  - EventCode
+  - LogonType
+  - TargetUserName
+  - GroupMembership
+  security_domain: endpoint
+tests:
+- name: True Positive Test
+  attack_data:
+  - data: https://media.githubusercontent.com/media/splunk/attack_data/master/datasets/attack_techniques/T1558/diamond_ticket/security.log
+    source: XmlWinEventLog:Security
+    sourcetype: XmlWinEventLog

detections/endpoint/windows_moveit_transfer_writing_aspx.yml

@@ -7,7 +7,7 @@ status: experimental
 type: TTP
 data_source:
 - Sysmon Event ID 11
-description: This analytic detects the creation of new ASPX files in the MOVEit Transfer application's "wwwroot" directory. This activity is indicative of the recent critical vulnerability found in MOVEit Transfer, where threat actors have been observed exploiting a zero-day vulnerability to install a malicious ASPX file (e.g., "human2.aspx") in the wwwroot directory. The injected file could then be used to exfiltrate sensitive data, including user credentials and file metadata. The vulnerability affects the MOVEit Transfer managed file transfer software developed by Progress, a subsidiary of US-based Progress Software Corporation. This analytic requires endpoint data reflecting process and filesystem activity. The identified process must be responsible for the creation of new ASPX or ASHX files in the specified directory.
+description: The following analytic detects the creation of new ASPX files in the MOVEit Transfer application's "wwwroot" directory. This activity is indicative of the recent critical vulnerability found in MOVEit Transfer, where threat actors have been observed exploiting a zero-day vulnerability to install a malicious ASPX file (e.g., "human2.aspx") in the wwwroot directory. The injected file could then be used to exfiltrate sensitive data, including user credentials and file metadata. The vulnerability affects the MOVEit Transfer managed file transfer software developed by Progress, a subsidiary of US-based Progress Software Corporation. This analytic requires endpoint data reflecting process and filesystem activity. The identified process must be responsible for the creation of new ASPX or ASHX files in the specified directory.
 search: '| tstats `security_content_summariesonly` count FROM datamodel=Endpoint.Processes
   where Processes.process_name=System  by _time span=1h Processes.process_id Processes.process_name
   Processes.dest | `drop_dm_object_name(Processes)` | join process_guid, _time [|

detections/endpoint/windows_registry_sip_provider_modification.yml

@@ -0,0 +1,56 @@
+name: 'Windows Registry SIP Provider Modification'
+id: 3b4e18cb-497f-4073-85ad-1ada7c2107ab
+version: 1
+date: '2023-10-10'
+author: Michael Haag, Splunk
+status: production
+type: TTP
+data_source:
+- Sysmon Event ID 7
+description: 'The following analytic detects modifications to the Windows Registry SIP Provider. It identifies this behavior by monitoring Sysmon Event ID 7, which logs registry modification events. The analytic specifically looks for changes in registry paths and values associated with Cryptography Providers and OID Encoding Types. This behavior is worth identifying as it may indicate an attempt to subvert trust controls, a technique often used by adversaries to bypass security measures and maintain persistence in an environment. If a true positive is found, it suggests an attacker is trying to manipulate the system''s cryptographic functions, potentially leading to unauthorized access, data theft, or other damaging outcomes. Upon triage, review the registry paths and values modified, and look for concurrent processes to identify the attack source. Review the path of the SIP being added. This approach helps analysts detect potential threats earlier and mitigate the risks.'
+search: '| tstats `security_content_summariesonly` count values(Registry.registry_key_name)
+  as registry_key_name values(Registry.registry_path) as registry_path min(_time)
+  as firstTime max(_time) as lastTime from datamodel=Endpoint.Registry where Registry.registry_path IN ("*\\SOFTWARE\\Microsoft\\Cryptography\\Providers\\*", "*\\SOFTWARE\\Microsoft\\Cryptography\\OID\\EncodingType*", "*\\SOFTWARE\\WOW6432Node\\Microsoft\\Cryptography\\Providers\\*", "*\\SOFTWARE\\WOW6432Node\\Microsoft\\Cryptography\\OID\\EncodingType*") Registry.registry_value_name IN ("Dll","$DLL") by
+  Registry.dest , Registry.user Registry.registry_value_name, Registry.registry_value_data | `security_content_ctime(lastTime)` | `security_content_ctime(firstTime)`
+  | `drop_dm_object_name(Registry)`| `windows_registry_sip_provider_modification_filter`'
+how_to_implement: To successfully implement this search you need to be ingesting information on process that include the name of the process responsible for the changes from your endpoints into the `Endpoint` datamodel in the `Registry` node. In addition, confirm the latest CIM App 4.20 or higher is installed and the latest TA for the endpoint product.
+known_false_positives: Be aware of potential false positives - legitimate applications may cause benign activities to be flagged.
+references:
+  - https://attack.mitre.org/techniques/T1553/003/
+  - https://github.com/SigmaHQ/sigma/blob/master/rules/windows/registry/registry_set/registry_set_sip_persistence.yml
+  - https://specterops.io/wp-content/uploads/sites/3/2022/06/SpecterOps_Subverting_Trust_in_Windows.pdf
+  - https://github.com/gtworek/PSBits/tree/master/SIP
+  - https://github.com/mattifestation/PoCSubjectInterfacePackage
+  - https://pentestlab.blog/2017/11/06/hijacking-digital-signatures/
+tags:
+  analytic_story:
+  - Subvert Trust Controls SIP and Trust Provider Hijacking
+  asset_type: endpoint
+  atomic_guid: []
+  confidence: 80
+  impact: 80
+  message: Windows Registry SIP Provider Modification detected on $dest$.
+  mitre_attack_id:
+  - T1553.003
+  observable:
+  - name: dest
+    type: Endpoint
+    role:
+    - Victim
+  product:
+  - Splunk Enterprise
+  - Splunk Enterprise Security
+  - Splunk Cloud
+  risk_score: 64
+  required_fields:
+  - Registry.dest
+  - Registry.user
+  - Registry.registry_value_name
+  - Registry.registry_value_data
+  security_domain: endpoint
+tests:
+- name: True Positive Test
+  attack_data:
+  - data: https://media.githubusercontent.com/media/splunk/attack_data/master/datasets/attack_techniques/T1553.003/sip/sip_windows-sysmon.log
+    source: XmlWinEventLog:Microsoft-Windows-Sysmon/Operational
+    sourcetype: xmlwineventlog

detections/endpoint/windows_service_creation_using_registry_entry.yml

@@ -5,19 +5,15 @@ date: '2023-04-27'
 author: Steven Dick, Teoderick Contreras, Splunk
 status: production
 type: TTP
-description: This analytic is to look for suspicious modification or creation of registry
-  to have service entry. This technique is abused by adversaries or threat actor to
-  persist, gain privileges in the machine or even lateral movement. This technique
-  can be executed using reg.exe application or using windows API like for example
-  the CrashOveride malware. This detection is a good indicator that a process is trying
-  to create a service entry using registry ImagePath.
+description: |-
+  The following analytic detects when reg.exe modify registry keys that define Windows services and their configurations in Windows to detect potential threats earlier and mitigate the risks. This detection is made by a Splunk query that searches for specific keywords in the process name, parent process name, user, and process ID. This detection is important because it suggests that an attacker has modified the registry keys that define Windows services and their configurations, which can allow them to maintain access to the system and potentially move laterally within the network. It is a common technique used by attackers to gain persistence on a compromised system and its impact can lead to data theft, ransomware, or other damaging outcomes. False positives can occur since legitimate uses of reg.exe to modify registry keys for Windows services can also trigger this alert. Next steps include reviewing the process and user context of the reg.exe activity and identify any other concurrent processes that might be associated with the attack upon triage.
 data_source:
 - Sysmon Event ID 1
 search: '| tstats `security_content_summariesonly` count FROM datamodel=Endpoint.Registry
   WHERE (Registry.registry_path="*\\SYSTEM\\CurrentControlSet\\Services*" Registry.registry_value_name
-  = ImagePath) BY _time span=1h Registry.dest Registry.user Registry.registry_path Registry.registry_key_name
-  Registry.registry_value_name Registry.registry_value_data Registry.process_guid
-  | `drop_dm_object_name(Registry)` | where isnotnull(registry_value_data)
+  = ImagePath) BY _time span=1h Registry.dest Registry.user Registry.registry_path
+  Registry.registry_key_name Registry.registry_value_name Registry.registry_value_data
+  Registry.process_guid | `drop_dm_object_name(Registry)` | where isnotnull(registry_value_data)
   | `security_content_ctime(firstTime)` | `security_content_ctime(lastTime)` | `windows_service_creation_using_registry_entry_filter`'
 how_to_implement: To successfully implement this search, you need to be ingesting
   logs with the registry value name, registry path, and registry value data from your
@@ -37,7 +33,8 @@ tags:
   asset_type: Endpoint
   confidence: 80
   impact: 80
-  message: A Windows Service was created on a endpoint from $dest$ using a registry entry
+  message: A Windows Service was created on a endpoint from $dest$ using a registry
+    entry
   mitre_attack_id:
   - T1574.011
   observable:

detections/endpoint/windows_sip_provider_inventory.yml

@@ -0,0 +1,45 @@
+name: Windows SIP Provider Inventory
+id: 21c5af91-1a4a-4511-8603-64fb41df3fad
+version: 1
+date: '2023-10-10'
+author: Michael Haag, Splunk
+status: production
+type: Hunting
+data_source: []
+description: The following inventory analytic is used with a PowerShell scripted inputs to capture all SIP providers on a Windows system. This analytic is used to identify potential malicious SIP providers that may be used to subvert trust controls. Upon review, look for new and non-standard paths for SIP providers.
+search: '`subjectinterfacepackage` Dll=*\\*.dll | stats count min(_time) as firstTime max(_time) as lastTime values(Dll) by Path host| `security_content_ctime(firstTime)` | `security_content_ctime(lastTime)`| `windows_sip_provider_inventory_filter`'
+how_to_implement: To implement this analytic, one must first perform inventory using a scripted inputs. Review the following Gist - https://gist.github.com/MHaggis/75dd5db546c143ea67703d0e86cdbbd1
+known_false_positives: False positives are limited as this is a hunting query for inventory.
+references:
+- https://gist.github.com/MHaggis/75dd5db546c143ea67703d0e86cdbbd1
+tags:
+  analytic_story:
+  - Subvert Trust Controls SIP and Trust Provider Hijacking
+  asset_type: endpoint
+  atomic_guid: []
+  confidence: 50
+  impact: 50
+  message: A list of SIP providers on the system is available. Review for new and non-standard paths for SIP providers on $host$.
+  mitre_attack_id:
+  - T1553.003
+  observable:
+  - name: host
+    type: Endpoint
+    role:
+    - Victim
+  product:
+  - Splunk Enterprise
+  - Splunk Enterprise Security
+  - Splunk Cloud
+  risk_score: 25
+  required_fields:
+  - Path
+  - Dll
+  - host
+  security_domain: endpoint
+tests:
+- name: True Positive Test
+  attack_data:
+  - data: https://media.githubusercontent.com/media/splunk/attack_data/master/datasets/attack_techniques/T1553.003/sip/sip_inventory.log
+    source: powershell://SubjectInterfacePackage
+    sourcetype: PwSh:SubjectInterfacePackage

detections/endpoint/windows_sip_winverifytrust_failed_trust_validation.yml

@@ -0,0 +1,52 @@
+name: Windows SIP WinVerifyTrust Failed Trust Validation
+id: 6ffc7f88-415b-4278-a80d-b957d6539e1a
+version: 1
+date: '2023-10-10'
+author: Michael Haag, Splunk
+status: production
+type: Anomaly
+data_source: []
+description: The following analytic utilizes a Windows Event Log - CAPI2 - or CryptoAPI 2, to identify failed trust validation. Typically, this event log is meant for diagnosing PKI issues, however is a great source to identify failed trust validation. Note that this event log is noisy as it captures common PKI requests from many different processes. EventID 81 is generated anytime a trust validation fails. The description for EventID 81 is "The digital signature of the object did not verify." STRT tested this analytic using Mimikatz binary.
+search: '`capi2_operational` EventID=81 "The digital signature of the object did not verify." | xmlkv UserData_Xml | stats count min(_time) as firstTime max(_time) as lastTime by Computer, UserData_Xml | rename Computer as dest | `windows_sip_winverifytrust_failed_trust_validation_filter`'
+how_to_implement: To implement this analytic, one will need to enable the Microsoft-Windows-CAPI2/Operational
+  log within the Windows Event Log. Note this is a debug log for many purposes, and
+  the analytic only focuses in on EventID 81. Review the following gist for additional
+  enabling information.
+known_false_positives: False positives may be present in some instances of legitimate binaries with invalid signatures. Filter as needed.
+references:
+  - https://attack.mitre.org/techniques/T1553/003/
+  - https://specterops.io/wp-content/uploads/sites/3/2022/06/SpecterOps_Subverting_Trust_in_Windows.pdf
+  - https://github.com/gtworek/PSBits/tree/master/SIP
+  - https://github.com/mattifestation/PoCSubjectInterfacePackage
+  - https://pentestlab.blog/2017/11/06/hijacking-digital-signatures/
+tags:
+  analytic_story:
+  - Subvert Trust Controls SIP and Trust Provider Hijacking
+  asset_type: endpoint
+  atomic_guid: []
+  confidence: 80
+  impact: 80
+  message: Failed trust validation via the CryptoAPI 2 on $dest$ for a binary.
+  mitre_attack_id:
+  - T1553.003
+  observable:
+  - name: dest
+    type: Hostname
+    role:
+    - Victim
+  product:
+  - Splunk Enterprise
+  - Splunk Enterprise Security
+  - Splunk Cloud
+  risk_score: 64
+  required_fields:
+  - _time
+  - Computer
+  - UserData_Xml
+  security_domain: endpoint
+tests:
+- name: True Positive Test
+  attack_data:
+  - data: https://media.githubusercontent.com/media/splunk/attack_data/master/datasets/attack_techniques/T1553.003/sip/capi2-operational.log
+    source: XmlWinEventLog:Microsoft-Windows-CAPI2/Operational
+    sourcetype: xmlwineventlog

detections/endpoint/windows_steal_authentication_certificates_esc1_abuse.yml

@@ -0,0 +1,83 @@
+name: Windows Steal Authentication Certificates - ESC1 Abuse
+id: cbe761fc-d945-4c8c-a71d-e26d12255d32
+version: 1
+date: '2023-05-25'
+author: Steven Dick
+status: production
+type: TTP
+description: The following analytic identifies when a new certificate is requested and/or granted against the Active Directory Certificate Services (AD CS) using a Subject Alternative Name (SAN). This action by its self is not malicious, however improperly configured certificate templates can be abused to permit privilege escalation and environment compromise due to over permissive settings (AD CS ESC1)
+data_source:
+- Windows Security 4886
+- Windows Security 4887
+search: >-
+  `wineventlog_security` EventCode IN (4886,4887) Attributes="*SAN:*upn*" Attributes="*CertificateTemplate:*"
+  | stats count min(_time) as firstTime max(_time) as lastTime values(name) as name values(status) as status values(Subject) as ssl_subject
+  values(SubjectKeyIdentifier) as ssl_hash by Computer, EventCode, Requester, Attributes, RequestId
+  | `security_content_ctime(firstTime)` 
+  | `security_content_ctime(lastTime)`
+  | rex field=Attributes "(?i)CertificateTemplate:(?<object>[^\r\n]+)"
+  | rex field=Attributes "(?i)ccm:(?<req_src>[^\r\n]+)"
+  | rex max_match=10 field=Attributes "(?i)(upn=(?<req_user_1>[^\r\n&]+))"
+  | rex max_match=10 field=Attributes "(?i)(dns=(?<req_dest_1>[^\r\n&]+))"
+  | rex field=Requester "(.+\\\\)?(?<src_user>[^\r\n]+)"
+  | eval flavor_text = case(EventCode=="4886","A suspicious certificate was requested using request ID: ".'RequestId',EventCode=="4887", "A suspicious certificate was issued using request ID: ".'RequestId'.". To revoke this certifacte use this request ID or the SSL fingerprint [".'ssl_hash'."]"), dest = upper(coalesce(req_dest_1,req_dest_2)), src = upper(coalesce(req_src,Computer)) | fields - req_* | rename Attributes as object_attrs, EventCode as signature_id, name as signature, RequestId as ssl_serial, Requester as ssl_subject_common_name| `windows_steal_authentication_certificates___esc1_abuse_filter`
+how_to_implement: To implement this analytic, enhanced Audit Logging must be enabled on AD CS and within Group Policy Management for CS server. See Page 115 of first reference. Recommend throttle correlation by RequestId/ssl_serial at minimum.
+known_false_positives: False positives may be generated in environments where administrative users or processes are allowed to generate certificates with Subject Alternative Names. Sources or templates used in these processes may need to be tuned out for accurate function. 
+references:
+- https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified_Pre-Owned.pdf
+- https://github.com/ly4k/Certipy#esc1
+- https://pentestlaboratories.com/2021/11/08/threat-hunting-certificate-account-persistence/
+tags:
+  analytic_story:
+  - Windows Certificate Services
+  asset_type: Endpoint
+  confidence: 60
+  impact: 100
+  message: Possible AD CS ESC1 activity by $src_user$ - $flavor_text$
+  mitre_attack_id:
+    - T1649
+  observable:
+    - name: src
+      type: Hostname
+      role:
+        - Victim
+    - name: dest
+      type: Hostname
+      role:
+        - Victim
+    - name: src_user
+      type: User
+      role:
+        - Victim
+    - name: user
+      type: User
+      role:
+        - Victim
+    - name: ssl_hash
+      type: Other
+      role:
+        - Attacker
+    - name: ssl_serial
+      type: Other
+      role:
+        - Attacker
+  product:
+  - Splunk Enterprise
+  - Splunk Enterprise Security
+  - Splunk Cloud
+  required_fields:
+  - _time
+  - Attributes 
+  - Computer
+  - EventCode
+  - Requester
+  - RequestId
+  risk_score: 60
+  security_domain: endpoint
+tests:
+- name: True Positive Test
+  attack_data:
+  - data: https://media.githubusercontent.com/media/splunk/attack_data/master/datasets/attack_techniques/T1649/certify_abuse/certify_esc1_abuse_winsecurity.log
+    source: XmlWinEventLog:Security
+    sourcetype: XmlWinEventLog
+    update_timestamp: true

detections/endpoint/wmi_permanent_event_subscription.yml

@@ -5,7 +5,8 @@ date: '2018-10-23'
 author: Rico Valdez, Splunk
 status: experimental
 type: TTP
-description: The following analytic seeks to detect the creation of Windows Management Instrumentation (WMI) permanent event subscriptions, a technique often used by adversaries for persistence. Such a subscription allows for the execution of specified scripts or binaries in response to defined system events, potentially enabling malicious activities to persist unnoticed. The analytic uses Sysmon Event ID 5 data, specifically focusing on instances where consumers of these events are not the expected "NTEventLogEventConsumer." Although WMI event subscriptions can be used legitimately by administrators, unusual or unexpected subscription creation should be treated as suspicious. Analysts need to be cognizant of the potential for false positives in legitimate administrative activities and should understand WMI activity within the context of the monitored environment.
+description: |-
+  The following analytic detects the creation of permanent event subscriptions using Windows Management Instrumentation (WMI), which is used by attackers to achieve persistence in a compromised system. By creating a permanent event subscription, an attacker can run malicious scripts or binaries in response to specific system events that enables them to maintain access to the system undetected. The detection is made by using Sysmon Event ID 5 data to detect instances where the consumers of these events are not the expected "NTEventLogEventConsumer." The detection is important because it identifies unusual or unexpected subscription creation, which suggests that an attacker is attempting to achieve persistence within the environment and might be executing malicious scripts or binaries in response to specific system events. The impact of such an attack can be severe, potentially leading to data theft, ransomware, or other damaging outcomes. False positives might occur since False positives might occur since WMI event subscriptions can be used for legitimate purposes by system administrators. You must have a thorough understanding of WMI activity within the context of the monitored environment to effectively differentiate between legitimate and malicious activity.Next steps include investigating the associated scripts or binaries and identifying the source of the attack.
 data_source:
 - Sysmon Event ID 5
 search: '`wmi` EventCode=5861 Binding | rex field=Message "Consumer =\s+(?<consumer>[^;|^$]+)"

detections/endpoint/wmi_temporary_event_subscription.yml

@@ -5,7 +5,7 @@ date: '2018-10-23'
 author: Rico Valdez, Splunk
 status: experimental
 type: TTP
-description: This search looks for the creation of WMI temporary event subscriptions.
+description: "The following analytic detects the creation of WMI temporary event subscriptions. WMI (Windows Management Instrumentation) is a management technology that allows administrators to perform various tasks on Windows-based systems. Temporary event subscriptions are created to monitor specific events or changes on a system that help to detect potential threats early and take proactive measures to protect the organization's systems and data. The detection is made by using the Splunk query `wmi` EventCode=5860 Temporary to search for events with EventCode 5860, which indicates the creation of a temporary WMI event subscription. To further refine the search results, the query uses regular expressions (rex) to extract the query used in the event subscription. Then, it filters known benign queries related to system processes such as 'wsmprovhost.exe' and 'AntiVirusProduct', 'FirewallProduct', 'AntiSpywareProduct', which helps to focus on potentially malicious or suspicious queries. The detection is important because it indicates malicious activity since attackers use WMI to run commands, gather information, or maintain persistence within a compromised system. False positives might occur since legitimate uses of WMI event subscriptions in the environment might trigger benign activities to be flagged. Therefore, an extensive triage is necessary to review the specific query and assess its intent. Additionally, capturing and inspecting relevant on-disk artifacts and analyzing concurrent processes can help to identify the source of the attack. Detecting the creation of these event subscriptions to identify potential threats early and take appropriate actions to mitigate the risks."
 data_source:
 - Sysmon Event ID 5
 search: '`wmi` EventCode=5860 Temporary | rex field=Message "NotificationQuery =\s+(?<query>[^;|^$]+)"

detections/network/detect_windows_dns_sigred_via_splunk_stream.yml

@@ -5,7 +5,7 @@ date: '2020-07-28'
 author: Shannon Davis, Splunk
 status: experimental
 type: TTP
-description: The following analytic is an experimental search designed to identify SIGRed exploitation attempts. SIGRed is a severe, wormable, remote code execution vulnerability in Windows DNS servers, identified as CVE-2020-1350. This analytic specifically looks for DNS SIG and KEY records, and TCP payloads larger than 65KB - potential indicators of the SIGRed exploit. It requires ingestion of both Splunk Stream DNS and TCP data. The search does rely on macro definitions for 'stream:dns' and 'stream:tcp', which should be replaced with appropriate configurations tailored to your Splunk environment. 
+description: "Ensure that the following prerequisites are met: (i) Both Splunk Stream DNS and TCP data are ingested. (ii) The macros 'stream:dns' and 'stream:tcp' are replaced with the appropriate configurations that are specific to your Splunk environment. The following analytic detects SIGRed exploitation attempts. SIGRed is a critical wormable vulnerability found in Windows DNS servers, known as CVE-2020-1350, which allows remote code execution. The detection is made by using an experimental search that focuses on identifying specific indicators that might suggest the presence of the SIGRed exploit such as DNS SIG records, KEY records, and TCP payloads greater than 65KB. This detection is important because it detects and responds to potential SIGRed exploitation attempts and minimizes the risk of a successful attack and its impact on the organization's infrastructure and data. False positives might occur due to the experimental nature of this analytic. Next steps include reviewing and investigating each case thoroughly given the potential for unauthorized Windows DNS server access, data breaches, and service disruptions. Additionally, you must stay updated with Microsoft's guidance on the SIGRed vulnerability."
 data_source: []
 search: '`stream_dns` | spath "query_type{}" | search "query_type{}" IN (SIG,KEY)
   | spath protocol_stack | search protocol_stack="ip:tcp:dns" | append [search `stream_tcp`

detections/network/detect_windows_dns_sigred_via_zeek.yml

@@ -5,7 +5,8 @@ date: '2020-07-28'
 author: Shannon Davis, Splunk
 status: experimental
 type: TTP
-description: This search detects SIGRed via Zeek DNS and Zeek Conn data.
+description: |-
+  The following analytic detects the presence of SIGRed, a critical DNS vulnerability, using Zeek DNS and Zeek Conn data. SIGRed vulnerability allows attackers to run remote code on Windows DNS servers. By detecting SIGRed early, you can prevent further damage and protect the organization's network infrastructure. The detection is made by identifying specific DNS query types (SIG and KEY) in the Zeek DNS data and checks for high data transfer in the Zeek Conn data. If multiple instances of these indicators are found within a flow, it suggests the presence of SIGRed. The detection is important because it indicates a potential compromise of Windows DNS servers that suggests that an attacker might have gained unauthorized access to the DNS server and can run arbitrary code. The impact of this attack can be severe, leading to data exfiltration, unauthorized access, or disruption of critical services. Next steps include investigating the affected flow and taking immediate action to mitigate the vulnerability. This can involve patching the affected DNS server, isolating the server from the network, or conducting a forensic analysis to determine the extent of the compromise.
 data_source: []
 search: '| tstats `security_content_summariesonly` count from datamodel=Network_Resolution
   where DNS.query_type IN (SIG,KEY) by DNS.flow_id | rename DNS.flow_id as flow_id

detections/network/detect_zerologon_via_zeek.yml

@@ -5,8 +5,8 @@ date: '2020-09-15'
 author: Shannon Davis, Splunk
 status: experimental
 type: TTP
-description: This search detects attempts to run exploits for the Zerologon CVE-2020-1472
-  vulnerability via Zeek RPC
+description: |-
+  The following analytic detects attempts to exploit the Zerologon CVE-2020-1472 vulnerability through Zeek RPC. By detecting attempts to exploit the Zerologon vulnerability through Zeek RPC, SOC analysts can identify potential threats earlier and take appropriate action to mitigate the risks. This detection is made by a Splunk query that looks for specific Zeek RPC operations, including NetrServerPasswordSet2, NetrServerReqChallenge, and NetrServerAuthenticate3, which are aggregated by source and destination IP address and time. This detection is important because it suggests that an attacker is attempting to exploit the Zerologon vulnerability to gain unauthorized access to the domain controller. Zerologon vulnerability is a critical vulnerability that allows attackers to take over domain controllers without authentication, leading to a complete takeover of an organization's IT infrastructure. The impact of such an attack can be severe, potentially leading to data theft, ransomware, or other devastating outcomes. False positives might occur since legitimate Zeek RPC activity can trigger the analytic. Next steps include reviewing the identified source and destination IP addresses and the specific RPC operations used. Capture and inspect any relevant on-disk artifacts, and review concurrent processes to identify the attack source upon triage .
 data_source: []
 search: '`zeek_rpc` operation IN (NetrServerPasswordSet2,NetrServerReqChallenge,NetrServerAuthenticate3)
   | bin span=5m _time | stats values(operation) dc(operation) as opscount count(eval(operation=="NetrServerReqChallenge"))

detections/network/smb_traffic_spike.yml

@@ -5,8 +5,8 @@ date: '2020-07-22'
 author: David Dorsey, Splunk
 status: experimental
 type: Anomaly
-description: This search looks for spikes in the number of Server Message Block (SMB)
-  traffic connections.
+description: |-
+  The following analytic detects spikes in the number of Server Message Block (SMB) traffic connections. SMB is a network protocol used for sharing files, printers, and other resources between computers. This detection is made by a Splunk query that looks for SMB traffic connections on ports 139 and 445, as well as connections using the SMB application. The query calculates the average and standard deviation of the number of SMB connections over the past 70 minutes, and identifies any sources that exceed two standard deviations from the average. This helps to filter out false positives caused by normal fluctuations in SMB traffic. This detection is important because it identifies potential SMB-based attacks, such as ransomware or data theft, which often involve a large number of SMB connections. This  suggests that an attacker is attempting to exfiltrate data or spread malware within the network. Next steps include investigating the source of the traffic and determining if it is malicious. This can involve reviewing network logs, capturing and analyzing any relevant network packets, and correlating with other security events to identify the attack source and mitigate the risk.
 data_source: []
 search: '| tstats `security_content_summariesonly` count from datamodel=Network_Traffic
   where All_Traffic.dest_port=139 OR All_Traffic.dest_port=445 OR All_Traffic.app=smb

detections/web/cisco_ios_xe_implant_access.yml

@@ -0,0 +1,61 @@
+name: Cisco IOS XE Implant Access
+id: 07c36cda-6567-43c3-bc1a-89dff61e2cd9
+version: 1
+date: '2023-10-17'
+author: Michael Haag, Splunk
+status: production
+type: TTP
+data_source: []
+description: The following analytic identifies potential exploitation of a previously unknown vulnerability in the Web User Interface (Web UI) feature of Cisco IOS XE software (CVE-2023-20198). Successful exploitation allows an attacker to create an account on the affected device with privilege level 15 access, granting them full control of the compromised device. The detection is based on the observation of suspicious account creation and subsequent actions, including the deployment of an implant consisting of a configuration file. The implant is saved under the file path //usr//binos//conf//nginx-conf//cisco_service.conf and is not persistent, meaning a device reboot will remove it, but the newly created local user accounts remain active even after system reboots. The new user accounts have level 15 privileges, meaning they have full administrator access to the device. This privileged access to the devices and subsequent creation of new users is tracked as CVE-2023-20198.
+search: '| tstats count min(_time) as firstTime max(_time) as lastTime from datamodel=Web where Web.url IN ("/webui/logoutconfirm.html?logon_hash=*") Web.http_method=POST Web.status=200
+  by Web.http_user_agent, Web.status Web.http_method, Web.url, Web.url_length, Web.src, Web.dest, sourcetype
+  | `drop_dm_object_name("Web")`
+  | `security_content_ctime(firstTime)` 
+  | `security_content_ctime(lastTime)`| `cisco_ios_xe_implant_access_filter`'
+how_to_implement: This detection requires the Web datamodel to be populated from a
+  supported Technology Add-On like Splunk for Apache, Splunk for Nginx, or Splunk
+  for Palo Alto. 
+known_false_positives: False positives may be present, restrict to Cisco IOS XE devices or perimeter appliances. Modify the analytic as needed based on hunting for successful exploitation of CVE-2023-20198.
+references:
+- https://blog.talosintelligence.com/active-exploitation-of-cisco-ios-xe-software/
+- https://github.com/vulncheck-oss/cisco-ios-xe-implant-scanner
+tags:
+  cve:
+  - CVE-2023-20198
+  analytic_story:
+  - Cisco IOS XE Software Web Management User Interface vulnerability
+  asset_type: Network
+  atomic_guid: []
+  confidence: 90
+  impact: 90
+  message: Possible exploitation of CVE-2023-20198 against $dest$ by $src$.
+  mitre_attack_id:
+  - T1190
+  observable:
+  - name: dest
+    type: Hostname
+    role:
+    - Victim
+  - name: src
+    type: IP Address
+    role:
+    - Attacker
+  product:
+  - Splunk Enterprise
+  - Splunk Enterprise Security
+  - Splunk Cloud
+  risk_score: 81
+  required_fields:
+  - _time
+  - Web.http_method
+  - Web.url
+  - Web.url_length
+  - Web.src
+  - Web.dest
+  security_domain: network
+tests:
+- name: True Positive Test
+  attack_data:
+  - data: https://media.githubusercontent.com/media/splunk/attack_data/master/datasets/attack_techniques/T1190/cisco/iosxe/ciscocve202320198.log
+    source: suricata
+    sourcetype: suricata

detections/web/confluence_cve_2023_22515_trigger_vulnerability.yml

@@ -0,0 +1,61 @@
+name: Confluence CVE-2023-22515 Trigger Vulnerability
+id: 630ea8b2-2800-4f5d-9cbc-d65c567349b0
+version: 1
+date: '2023-10-12'
+author: Michael Haag, Splunk
+status: production
+type: TTP
+data_source: []
+description: The following analytic identifies potential exploitation attempts on a known vulnerability in Atlassian Confluence, targeting the /server-info.action?bootstrapStatusProvider.applicationConfig.setupComplete=false* and /server-info.action?bootstrapStatusProvider.applicationConfig.setupComplete=0& URLs. By analyzing web logs within the Splunk 'Web' Data Model, it filters for successful accesses (HTTP status 200) to these vulnerable endpoints. Such behavior is crucial for a SOC to monitor, as it suggests attackers might be exploiting a privilege escalation flaw in Confluence. A true positive implies a possible unauthorized access or account creation with escalated privileges. Key details captured include user-agent, HTTP methods, URL length, and source and destination IPs. These insights aid SOCs in swiftly detecting and responding to threats, ensuring vulnerabilities are mitigated before substantial compromise.
+search: '| tstats count min(_time) as firstTime max(_time) as lastTime from datamodel=Web where Web.url IN ("/server-info.action?bootstrapStatusProvider.applicationConfig.setupComplete=false*","/server-info.action?bootstrapStatusProvider.applicationConfig.setupComplete=0&*") Web.http_method=GET Web.status=200 by Web.http_user_agent, Web.status Web.http_method, Web.url, Web.url_length, Web.src, Web.dest, sourcetype
+  | `drop_dm_object_name("Web")`
+  | `security_content_ctime(firstTime)` 
+  | `security_content_ctime(lastTime)` | `confluence_cve_2023_22515_trigger_vulnerability_filter`'
+how_to_implement: To successfully implement this search you need to be ingesting information
+  on Web traffic that include fields relavent for traffic into the `Web` datamodel.
+known_false_positives: False positives may be present with legitimate applications.
+  Attempt to filter by dest IP or use Asset groups to restrict to Confluence servers.
+references:
+- https://github.com/Chocapikk/CVE-2023-22515/blob/main/exploit.py
+- https://x.com/Shadowserver/status/1712378833536741430?s=20
+- https://github.com/j3seer/CVE-2023-22515-POC
+tags:
+  analytic_story:
+  -  CVE-2023-22515 Privilege Escalation Vulnerability Confluence Data Center and Server
+  asset_type: Web server
+  atomic_guid: []
+  confidence: 80
+  impact: 90
+  message: Potential exploitation attempts on a known vulnerability in Atlassian Confluence detected. The source IP is $src$ and the destination hostname is $dest$.
+  mitre_attack_id:
+  - T1190
+  observable:
+  - name: dest
+    type: Hostname
+    role:
+    - Victim
+  - name: src
+    type: IP Address
+    role:
+    - Attacker
+  product:
+  - Splunk Enterprise
+  - Splunk Enterprise Security
+  - Splunk Cloud
+  risk_score: 72
+  required_fields:
+  - _time
+  - Web.http_method
+  - Web.url
+  - Web.url_length
+  - Web.src
+  - Web.dest
+  - Web.http_user_agent
+  - Web.status
+  security_domain: network
+tests:
+- name: True Positive Test
+  attack_data:
+  - data: https://media.githubusercontent.com/media/splunk/attack_data/master/datasets/attack_techniques/T1190/confluence/confluence_vuln_trigger_cve-2023-22515.log
+    source: suricata
+    sourcetype: suricata

detections/web/microsoft_sharepoint_server_elevation_of_privilege.yml

@@ -0,0 +1,64 @@
+name: Microsoft SharePoint Server Elevation of Privilege
+id: fcf4bd3f-a79f-4b7a-83bf-2692d60b859d
+version: 1
+date: '2023-09-27'
+author: Michael Haag, Gowthamaraj Rajendran, Splunk
+status: production
+type: TTP
+data_source: []
+description: The following analytic detects potential exploitation attempts against Microsoft SharePoint Server vulnerability CVE-2023-29357. This vulnerability pertains to an elevation of privilege due to improper handling of authentication tokens. By monitoring for suspicious activities related to SharePoint Server, the analytic identifies attempts to exploit this vulnerability. If a true positive is detected, it indicates a serious security breach where an attacker might have gained privileged access to the SharePoint environment, potentially leading to data theft or other malicious activities.
+search: '| tstats count min(_time) as firstTime max(_time)
+  as lastTime from datamodel=Web where Web.url IN ("/_api/web/siteusers*","/_api/web/currentuser*") Web.status=200 Web.http_method=GET
+  by Web.http_user_agent, Web.status Web.http_method, Web.url, Web.url_length, Web.src, Web.dest, sourcetype
+  | `drop_dm_object_name("Web")`
+  | `security_content_ctime(firstTime)` 
+  | `security_content_ctime(lastTime)`
+  | `microsoft_sharepoint_server_elevation_of_privilege_filter`'
+how_to_implement: This detection requires the Web datamodel to be populated from a supported Technology Add-On like Splunk for Microsoft SharePoint.
+known_false_positives: False positives may occur if there are legitimate activities that mimic the exploitation pattern. It's recommended to review the context of the alerts and adjust the analytic parameters to better fit the specific environment.
+references:
+- https://socradar.io/microsoft-sharepoint-server-elevation-of-privilege-vulnerability-exploit-cve-2023-29357/
+- https://github.com/LuemmelSec/CVE-2023-29357/blob/main/CVE-2023-29357/Program.cs
+tags:
+  cve:
+  - CVE-2023-29357
+  analytic_story:
+  - Microsoft SharePoint Server Elevation of Privilege CVE-2023-29357
+  asset_type: Web Server
+  atomic_guid: []
+  confidence: 50
+  impact: 90
+  message: Possible exploitation of CVE-2023-29357 against $dest$ from $src$. 
+  mitre_attack_id:
+  - T1068
+  observable:
+  - name: dest
+    type: Hostname
+    role:
+    - Victim
+  - name: src
+    type: IP Address
+    role:
+    - Attacker
+  product:
+  - Splunk Enterprise
+  - Splunk Enterprise Security
+  - Splunk Cloud
+  risk_score: 45
+  required_fields:
+  - _time
+  - Web.http_method
+  - Web.url
+  - Web.url_length
+  - Web.src
+  - Web.dest
+  - Web.http_user_agent
+  - Web.status
+  - sourcetype
+  security_domain: network
+tests:
+- name: True Positive Test
+  attack_data:
+  - data: https://media.githubusercontent.com/media/splunk/attack_data/master/datasets/attack_techniques/T1190/sharepoint/sharepointeop.log
+    source: suricata
+    sourcetype: suricata

detections/web/sql_injection_with_long_urls.yml

@@ -5,8 +5,7 @@ date: '2022-03-28'
 author: Bhavin Patel, Splunk
 status: experimental
 type: TTP
-description: This search looks for long URLs that have several SQL commands visible
-  within them.
+description: "The following analytic detects long URLs that contain multiple SQL commands. A proactive approach helps to detect and respond to potential threats earlier, mitigating the risks associated with SQL injection attacks. This detection is made by a Splunk query that searches for web traffic data where the destination category is a web server and the URL length is greater than 1024 characters or the HTTP user agent length is greater than 200 characters. This detection is important because it suggests that an attacker is attempting to exploit a web application through SQL injection. SQL injection is a common technique used by attackers to exploit vulnerabilities in web applications and gain unauthorized access to databases. Attackers can insert malicious SQL commands into a URL to manipulate the application's database and retrieve sensitive information or modify data. The impact of a successful SQL injection attack can be severe, potentially leading to data breaches, unauthorized access, and even complete compromise of the affected system. False positives might occur since the legitimate use of web applications or specific URLs in your environment can trigger the detection. Therefore, you must review and validate any alerts generated by this analytic before taking any action. Next steps include reviewing the source and destination of the web traffic, as well as the specific URL and HTTP user agent. Additionally, capture and analyze any relevant on-disk artifacts and review concurrent processes to determine the source of the attack."
 data_source: []
 search: '| tstats `security_content_summariesonly` count from datamodel=Web where
   Web.dest_category=web_server AND (Web.url_length > 1024 OR Web.http_user_agent_length

detections/web/supernova_webshell.yml

@@ -5,8 +5,8 @@ date: '2021-01-06'
 author: John Stoner, Splunk
 status: experimental
 type: TTP
-description: This search aims to detect the Supernova webshell used in the SUNBURST
-  attack.
+description: |-
+  The following analytic detects the presence of the Supernova webshell, which was used in the SUNBURST attack. This webshell can be used by attackers to gain unauthorized access to a compromised system and run arbitrary code. This detection is made by a Splunk query that searches for specific patterns in web URLs, including "*logoimagehandler.ashx*codes*", "*logoimagehandler.ashx*clazz*", "*logoimagehandler.ashx*method*", and "*logoimagehandler.ashx*args*". These patterns are commonly used by the Supernova webshell to communicate with its command and control server. This detection is important because it indicates a potential compromise and unauthorized access to the system to run arbitrary code, which can lead to data theft, ransomware, or other damaging outcomes. False positives might occur since the patterns used by the webshell can also be present in legitimate web traffic. In such cases, tune the search to the specific environment and monitor it closely for any suspicious activity. Next steps include reviewing the web URLs and inspecting any relevant on-disk artifacts. Additionally, review concurrent processes and network connections to identify the source of the attack.
 data_source: []
 search: '| tstats `security_content_summariesonly` count from datamodel=Web.Web where
   web.url=*logoimagehandler.ashx*codes* OR Web.url=*logoimagehandler.ashx*clazz* OR

detections/web/ws_ftp_remote_code_execution.yml

@@ -14,10 +14,11 @@ search: '| tstats count min(_time) as firstTime max(_time)
   | `security_content_ctime(firstTime)` 
   | `security_content_ctime(lastTime)` | `ws_ftp_remote_code_execution_filter`'
 how_to_implement: The following analytic requires the Web datamodel. Ensure data source is mapped correctly or modify and tune for your data source.
-known_false_positives: If WS_FTP Server is not in use, this analytic will not return results. Monitor and tune for your environment.
+known_false_positives: If WS_FTP Server is not in use, this analytic will not return results. Monitor and tune for your environment. Note the MetaSploit module is focused on only hitting /AHT/ and not the full /AHT/AhtApiService.asmx/AuthUser URL.
 references:
 - https://github.com/projectdiscovery/nuclei-templates/pull/8296/files
 - https://www.assetnote.io/resources/research/rce-in-progress-ws-ftp-ad-hoc-via-iis-http-modules-cve-2023-40044
+- https://github.com/rapid7/metasploit-framework/pull/18414
 tags:
   cve:
   - CVE-2023-40044

lookups/domain_admins.csv

@@ -0,0 +1,2 @@
+username
+Administrator

lookups/domain_admins.yml

@@ -0,0 +1,4 @@
+description: List of domain admins
+filename: domain_admins.csv
+name: domain_admins
+case_sensitive_match: 'false'

macros/subjectinterfacepackage.yml

@@ -0,0 +1,4 @@
+definition: sourcetype="PwSh:SubjectInterfacePackage"
+description: customer specific splunk configurations(eg- index, source, sourcetype).
+  Replace the macro definition with configurations for your Splunk Environmnent.
+name: subjectinterfacepackage

playbooks/G_Suite_for_GMail_Message_Identifier_Activity_Analysis.yml

@@ -1,5 +1,5 @@
 name: G Suite for GMail Message Identifier Activity Analysis
-id: 5299d6dd-e9c4-4afa-b051-928ace0ff816d
+id: 5299d6dd-e9c4-4afa-b051-928ace0ff816
 version: 1
 date: '2023-05-12'
 author: Lou Stella, Splunk

playbooks/Splunk_Attack_Analyzer_Dynamic_Analysis.yml

@@ -1,4 +1,4 @@
-name: Splunk_Attack_Analyzer_Dynamic_Analysis
+name: Splunk Attack Analyzer Dynamic Analysis
 id: c77faffe-1339-43b0-b870-86582da9063e
 version: 1
 date: '2023-03-24'
@@ -26,4 +26,4 @@ tags:
   - Enrichment
   - Phishing
   - Endpoint
-  defend_technique_id: D3-DA
+  defend_technique_id: D3-DA

playbooks/log4j_investigate.yml

@@ -22,7 +22,7 @@ tags:
   - Curl Download and Bash Execution
   - Wget Download and Bash Execution
   - Linux Java Spawning Shell
-  - Windows Java Spawning Shell
+  - Windows Java Spawning Shells
   - Java Class File download by Java User Agent
   - Outbound Network Connection from Java Using Default Ports
   - Log4Shell JNDI Payload Injection Attempt

playbooks/log4j_respond.yml

@@ -22,7 +22,7 @@ tags:
   - Curl Download and Bash Execution
   - Wget Download and Bash Execution
   - Linux Java Spawning Shell
-  - Windows Java Spawning Shell
+  - Windows Java Spawning Shells
   - Java Class File download by Java User Agent
   - Outbound Network Connection from Java Using Default Ports
   - Log4Shell JNDI Payload Injection Attempt

playbooks/risk_notable_block_indicators.yml

@@ -1,5 +1,5 @@
 name: Risk Notable Block Indicators
-id: rn0edc96-ff2b-48b0-9f6f-83da3783fd63
+id: 000edc96-ff2b-48b0-9f6f-83da3783fd63
 version: 1
 date: "2021-10-22"
 author: Kelby Shelton, Splunk

playbooks/risk_notable_enrich.yml

@@ -1,5 +1,5 @@
 name: Risk Notable Enrich
-id: rn0edc96-ff2b-48b0-9f6f-43da3783fd63
+id: 010edc96-ff2b-48b0-9f6f-43da3783fd63
 version: 1
 date: "2021-10-22"
 author: Kelby Shelton, Splunk

playbooks/risk_notable_import_data.yml

@@ -1,5 +1,5 @@
 name: Risk Notable Import Data
-id: rn0edc96-ff2b-48b0-9f6f-23da3783fd63
+id: 020edc96-ff2b-48b0-9f6f-23da3783fd63
 version: 1
 date: "2021-10-22"
 author: Kelby Shelton, Splunk

playbooks/risk_notable_investigate.yml

@@ -1,5 +1,5 @@
 name: Risk Notable Investigate
-id: rn0edc96-ff2b-48b0-9f6f-03da3783fd63
+id: 030edc96-ff2b-48b0-9f6f-03da3783fd63
 version: 1
 date: "2021-10-22"
 author: Kelby Shelton, Splunk

playbooks/risk_notable_merge_events.yml

@@ -1,5 +1,5 @@
 name: Risk Notable Merge Events
-id: rn0edc96-ff2b-48b0-9f6f-53da3783fd63
+id: 040edc96-ff2b-48b0-9f6f-53da3783fd63
 version: 1
 date: "2021-10-22"
 author: Kelby Shelton, Splunk

playbooks/risk_notable_mitigate.yml

@@ -1,5 +1,5 @@
 name: Risk Notable Mitigate
-id: rn0edc96-ff2b-48b0-9f6f-63da3783fd63
+id: 050edc96-ff2b-48b0-9f6f-63da3783fd63
 version: 1
 date: "2021-10-22"
 author: Kelby Shelton, Splunk

playbooks/risk_notable_preprocess.yml

@@ -1,5 +1,5 @@
 name: Risk Notable Preprocess
-id: rn0edc96-ff2b-48b0-9f6f-13da3783fd63
+id: 060edc96-ff2b-48b0-9f6f-13da3783fd63
 version: 1
 date: "2021-10-22"
 author: Kelby Shelton, Splunk

playbooks/risk_notable_protect_assets_and_users.yml

@@ -1,5 +1,5 @@
 name: Risk Notable Protect Assets and Users
-id: rn0edc96-ff2b-48b0-9f6f-93da3783fd63
+id: 070edc96-ff2b-48b0-9f6f-93da3783fd63
 version: 1
 date: "2021-10-22"
 author: Kelby Shelton, Splunk

playbooks/risk_notable_review_indicators.yml

@@ -1,5 +1,5 @@
 name: Risk Notable Review Indicators
-id: rn0edc96-ff2b-48b0-9f6f-73da3783fd63
+id: 080edc96-ff2b-48b0-9f6f-73da3783fd63
 version: 1
 date: "2021-10-22"
 author: Kelby Shelton, Splunk

playbooks/risk_notable_verdict.yml

@@ -1,5 +1,5 @@
 name: Risk Notable Verdict
-id: rn0edc96-ff2b-48b0-9f6f-33da3783fd63
+id: 090edc96-ff2b-48b0-9f6f-33da3783fd63
 version: 1
 date: "2021-10-22"
 author: Kelby Shelton, Splunk

ssa_detections/endpoint/ssa___anomalous_usage_of_archive_tools.yml

@@ -11,12 +11,12 @@ data_source:
 - Windows Security 4688
 search: ' $main = from source  | eval timestamp = time  | eval metadata_uid = metadata.uid  |
   eval process_pid = process.pid | eval process_file = process.file | eval process_file_path
-  = process_file.path | eval process_file_name = process_file.name | eval process_cmd_line
+  = process_file.path | eval process_file_name = lower(process_file.name) | eval process_cmd_line
   = process.cmd_line | eval actor_user = actor.user | eval actor_user_name = actor_user.name
   | eval actor_process = actor.process | eval actor_process_pid = actor_process.pid
   | eval actor_process_file = actor_process.file | eval actor_process_file_path =
   actor_process_file.path | eval actor_process_file_name = actor_process_file.name
-  | eval device_hostname = device.hostname | where (process_file_name="WinRAR.exe"
+  | eval device_hostname = device.hostname | where (process_file_name="winrar.exe"
   OR process_file_name LIKE "7z%" OR process_file_name LIKE "winzip%") AND (actor_process_file_name
   LIKE "%powershell.exe" OR actor_process_file_name LIKE "%cmd.exe") --finding_report--'
 how_to_implement: To successfully implement this search you need to be ingesting information

ssa_detections/endpoint/ssa___attempt_to_delete_services.yml

@@ -14,7 +14,7 @@ data_source:
 - Windows Security 4688
 search: ' $main = from source  | eval timestamp = time  | eval metadata_uid = metadata.uid  |
   eval process_pid = process.pid | eval process_file = process.file | eval process_file_path
-  = process_file.path | eval process_file_name = process_file.name | eval process_cmd_line
+  = process_file.path | eval process_file_name = lower(process_file.name) | eval process_cmd_line
   = process.cmd_line | eval actor_user = actor.user | eval actor_user_name = actor_user.name
   | eval actor_process = actor.process | eval actor_process_pid = actor_process.pid
   | eval actor_process_file = actor_process.file | eval actor_process_file_path =

ssa_detections/endpoint/ssa___attempt_to_disable_services.yml

@@ -14,7 +14,7 @@ data_source:
 - Windows Security 4688
 search: ' $main = from source  | eval timestamp = time  | eval metadata_uid = metadata.uid  |
   eval process_pid = process.pid | eval process_file = process.file | eval process_file_path
-  = process_file.path | eval process_file_name = process_file.name | eval process_cmd_line
+  = process_file.path | eval process_file_name = lower(process_file.name) | eval process_cmd_line
   = process.cmd_line | eval actor_user = actor.user | eval actor_user_name = actor_user.name
   | eval actor_process = actor.process | eval actor_process_pid = actor_process.pid
   | eval actor_process_file = actor_process.file | eval actor_process_file_path =

ssa_detections/endpoint/ssa___attempted_credential_dump_from_registry_via_reg_exe.yml

@@ -12,7 +12,7 @@ data_source:
 - Windows Security 4688
 search: ' $main = from source  | eval timestamp = time  | eval metadata_uid = metadata.uid  |
   eval process_pid = process.pid | eval process_file = process.file | eval process_file_path
-  = process_file.path | eval process_file_name = process_file.name | eval process_cmd_line
+  = process_file.path | eval process_file_name = lower(process_file.name) | eval process_cmd_line
   = process.cmd_line | eval actor_user = actor.user | eval actor_user_name = actor_user.name
   | eval actor_process = actor.process | eval actor_process_pid = actor_process.pid
   | eval actor_process_file = actor_process.file | eval actor_process_file_path =

ssa_detections/endpoint/ssa___bcdedit_failure_recovery_modification.yml

@@ -12,7 +12,7 @@ data_source:
 - Windows Security 4688
 search: ' $main = from source  | eval timestamp = time  | eval metadata_uid = metadata.uid  |
   eval process_pid = process.pid | eval process_file = process.file | eval process_file_path
-  = process_file.path | eval process_file_name = process_file.name | eval process_cmd_line
+  = process_file.path | eval process_file_name = lower(process_file.name) | eval process_cmd_line
   = process.cmd_line | eval actor_user = actor.user | eval actor_user_name = actor_user.name
   | eval actor_process = actor.process | eval actor_process_pid = actor_process.pid
   | eval actor_process_file = actor_process.file | eval actor_process_file_path =

ssa_detections/endpoint/ssa___clear_unallocated_sector_using_cipher_app.yml

@@ -12,13 +12,13 @@ data_source:
 - Windows Security 4688
 search: ' $main = from source  | eval timestamp = time  | eval metadata_uid = metadata.uid  |
   eval process_pid = process.pid | eval process_file = process.file | eval process_file_path
-  = process_file.path | eval process_file_name = process_file.name | eval process_cmd_line
+  = process_file.path | eval process_file_name = lower(process_file.name) | eval process_cmd_line
   = process.cmd_line | eval actor_user = actor.user | eval actor_user_name = actor_user.name
   | eval actor_process = actor.process | eval actor_process_pid = actor_process.pid
   | eval actor_process_file = actor_process.file | eval actor_process_file_path =
   actor_process_file.path | eval actor_process_file_name = actor_process_file.name
   | eval device_hostname = device.hostname | where process_file_name="cipher.exe"
-  AND process_cmd_line LIKE "%/W:%" --finding_report--'
+  AND process_cmd_line LIKE "%/w:%" --finding_report--'
 how_to_implement: To successfully implement this search you need to be ingesting information
   on process that include the name of the process responsible for the changes from
   your endpoints into the `Endpoint` datamodel in the `Processes` node.

ssa_detections/endpoint/ssa___delete_a_net_user.yml

@@ -15,7 +15,7 @@ data_source:
 - Windows Security 4688
 search: ' $main = from source  | eval timestamp = time  | eval metadata_uid = metadata.uid  |
   eval process_pid = process.pid | eval process_file = process.file | eval process_file_path
-  = process_file.path | eval process_file_name = process_file.name | eval process_cmd_line
+  = process_file.path | eval process_file_name = lower(process_file.name) | eval process_cmd_line
   = process.cmd_line | eval actor_user = actor.user | eval actor_user_name = actor_user.name
   | eval actor_process = actor.process | eval actor_process_pid = actor_process.pid
   | eval actor_process_file = actor_process.file | eval actor_process_file_path =