Elastic — CraftedSignal Threat Feed

Kubernetes Pod Exec Sensitive File or Credential Path Access

hello@craftedsignal.io — Mon, 04 May 2026 21:42:34 +0000

This detection identifies Kubernetes pod exec sessions accessing sensitive files or credential paths. The goal is to detect attackers attempting to steal credentials or configuration information from within Kubernetes pods. This often occurs after initial access and may precede lateral movement, privilege escalation, or data exfiltration. The detection focuses on command lines that reference paths related to service account tokens, kubelet configuration, host identity stores, common private keys, keystore extensions, process environment dumps, and configuration files with embedded secrets. The rule is designed to catch both interactive and scripted access, and includes exclusions for benign reads of resolv.conf.

Attack Chain

Attacker gains initial access to a Kubernetes cluster, potentially through a compromised application or misconfigured service.
Attacker uses kubectl exec or similar tools to execute commands within a pod.
The executed command attempts to read sensitive files or directories within the pod’s filesystem, such as /var/run/secrets/kubernetes.io/serviceaccount/token to obtain the pod’s service account token.
The command may also target host-level files if the pod has hostPath mounts or runs in a privileged context, like /etc/shadow or /etc/passwd for credential access.
The attacker may attempt to dump process environments via /proc//environ to extract sensitive information stored as environment variables.
The attacker leverages obtained credentials or configuration to move laterally to other pods or nodes within the cluster.
The attacker escalates privileges within the cluster by abusing stolen service account tokens or node credentials.
The final objective is to exfiltrate sensitive data, deploy malicious workloads, or disrupt services within the Kubernetes environment.

Impact

A successful attack can lead to the compromise of sensitive data, including credentials, configuration files, and application secrets. This can enable attackers to move laterally within the Kubernetes cluster, escalate privileges, and potentially gain control over the entire environment. The severity of the impact depends on the sensitivity of the data exposed and the level of access achieved by the attacker.

Recommendation

Deploy the provided Sigma rule to your SIEM to detect sensitive file access within Kubernetes pod exec sessions.
Investigate any alerts triggered by the Sigma rule, focusing on the Esql.access_type field to prioritize incidents.
Review and tighten RBAC permissions for pod exec to limit access to authorized users and service accounts.
Implement admission controls to prevent pods from running in privileged mode or using hostPath mounts unless absolutely necessary.
Monitor Kubernetes audit logs for suspicious kubectl exec activity, including unusual command lines or access patterns.
Regularly rotate Kubernetes service account tokens and other sensitive credentials to minimize the impact of potential breaches.
Use the provided Kubernetes audit log query to proactively search for historical instances of sensitive file access.

Windows Port Forwarding Rule Addition via Registry Modification

hello@craftedsignal.io — Mon, 04 May 2026 14:17:05 +0000

Attackers may configure port forwarding rules to bypass network segmentation restrictions, effectively using the compromised host as a jump box to access previously unreachable systems. This involves modifying the registry to redirect incoming TCP connections from a local port to another port or a remote computer. The technique is typically employed post-compromise to facilitate lateral movement and maintain unauthorized access within the network. This activity is detected by monitoring changes to the HKLM\SYSTEM\*ControlSet*\Services\PortProxy\v4tov4\ registry subkeys.

Attack Chain

The attacker gains initial access to the target system through an exploit or compromised credentials.
The attacker executes a command-line interface (e.g., cmd.exe or powershell.exe) with administrative privileges.
The attacker uses reg.exe or PowerShell’s Set-ItemProperty cmdlet to modify the HKLM\SYSTEM\CurrentControlSet\Services\PortProxy\v4tov4\ registry key.
The attacker configures a new port forwarding rule by creating a new subkey under v4tov4\ with specific settings for the local port, remote address, and remote port.
The attacker sets the ListenAddress, ListenPort, ConnectAddress, and ConnectPort values within the new subkey.
The attacker verifies the successful creation and activation of the port forwarding rule using netsh interface portproxy show v4tov4.
The attacker leverages the newly created port forwarding rule to tunnel traffic through the compromised host, bypassing network segmentation.
The attacker uses the proxied connection to access internal resources and conduct further attacks, such as lateral movement or data exfiltration.

Impact

Successful exploitation enables attackers to bypass network segmentation restrictions, leading to unauthorized access to internal systems and data. This can facilitate lateral movement, data exfiltration, and further compromise of the network. The severity of the impact depends on the sensitivity of the accessible resources and the extent of the attacker’s lateral movement.

Recommendation

Enable Sysmon registry event logging to capture modifications to the HKLM\SYSTEM\*ControlSet*\Services\PortProxy\v4tov4\ registry subkeys, enabling detection of malicious port forwarding rule additions.
Deploy the Sigma rule “Port Forwarding Rule Addition via Registry Modification” to your SIEM to detect suspicious registry modifications related to port forwarding.
Investigate any alerts generated by the Sigma rule, focusing on identifying the process execution chain and the user account that performed the action.
Regularly review and audit existing port forwarding rules to identify and remove any unauthorized or suspicious configurations.

Suspicious Zoom Child Process Execution

hello@craftedsignal.io — Mon, 04 May 2026 14:17:05 +0000

This detection identifies suspicious child processes spawned by Zoom.exe, potentially indicating an attempt to evade detection or exploit vulnerabilities within the Zoom application. The rule focuses on detecting instances where command interpreters like cmd.exe, PowerShell, or PowerShell ISE are launched as child processes of Zoom. This behavior can be indicative of an attacker attempting to execute malicious commands or scripts within the context of the Zoom application, potentially escalating privileges or gaining unauthorized access to system resources. It’s crucial for defenders to investigate such occurrences, as they may signify ongoing exploitation or malicious activity leveraging Zoom as an initial access vector.

Attack Chain

User launches the Zoom application (Zoom.exe).
A vulnerability in Zoom is exploited, or the user is socially engineered into running a malicious command.
Zoom.exe spawns a child process, such as cmd.exe, powershell.exe, pwsh.exe, or powershell_ise.exe.
The spawned process executes commands or scripts, potentially downloading or executing malware.
The malicious script or command performs reconnaissance activities on the system.
The script establishes persistence by creating a scheduled task or modifying registry keys.
The attacker gains remote access to the compromised system.
The attacker performs lateral movement and data exfiltration.

Impact

Successful exploitation could allow attackers to execute arbitrary commands, escalate privileges, and compromise the affected system. Depending on the user’s privileges, attackers could gain access to sensitive data, install malware, or pivot to other systems on the network. The impact ranges from data breaches to complete system compromise, potentially affecting all users within the organization who utilize the Zoom application.

Recommendation

Deploy the Sigma rule “Suspicious Zoom Child Process” to your SIEM to detect command interpreters spawned by Zoom.exe. Tune the rule for your environment to minimize false positives.
Enable Sysmon process creation logging (Event ID 1) to capture detailed information about process executions, which is essential for the Sigma rule above.
Investigate any alerts generated by the Sigma rule, focusing on the command-line arguments and network connections of the spawned processes.
Monitor Windows Security Event Logs for process creation events related to Zoom.exe and its child processes to identify suspicious behavior.
Consider implementing application control policies to restrict the execution of unauthorized processes within the Zoom application context.

Suspicious Windows PowerShell Arguments Detected

hello@craftedsignal.io — Mon, 04 May 2026 14:17:05 +0000

This detection rule identifies the execution of PowerShell with suspicious argument values on Windows systems. This behavior is frequently associated with malware installation and other malicious activities. PowerShell is a powerful scripting language, and adversaries often exploit its capabilities to execute malicious scripts, download payloads, and obfuscate commands. The rule focuses on detecting patterns such as encoded commands, suspicious downloads (e.g., using WebClient or Invoke-WebRequest), and various obfuscation techniques used to evade detection. The rule is designed to work with various data sources, including Elastic Defend, Windows Security Event Logs, Sysmon, and third-party EDR solutions like CrowdStrike, Microsoft Defender XDR, and SentinelOne, enhancing its applicability across different environments.

Attack Chain

An attacker gains initial access to a Windows system (e.g., through phishing or exploiting a vulnerability).
The attacker uses PowerShell to download a malicious payload from a remote server using commands like DownloadFile or DownloadString.
The downloaded payload is often encoded or obfuscated to evade detection. Common techniques include Base64 encoding, character manipulation, and compression.
PowerShell is then used to decode or deobfuscate the payload using methods like [Convert]::FromBase64String or [char[]](...) -join ''.
The deobfuscated payload is executed directly in memory using techniques like iex (Invoke-Expression) or Reflection.Assembly.Load.
The executed payload performs malicious actions, such as installing malware, establishing persistence, or exfiltrating data.
The attacker may use techniques like WebClient to download files from a remote URL.
Commands like nslookup -q=txt are used for command and control.

Impact

Successful exploitation can lead to malware installation, data theft, system compromise, and further propagation of the attack within the network. The detection of suspicious PowerShell arguments helps to identify and prevent these malicious activities before significant damage can occur. Without proper detection, attackers can maintain persistence, escalate privileges, and compromise sensitive data. The rule helps defenders identify and respond to these threats quickly, minimizing the impact of potential attacks.

Recommendation

Deploy the Sigma rules provided in this brief to your SIEM to detect suspicious PowerShell activity.
Enable Sysmon process creation logging with command line arguments to ensure the necessary data is captured for the Sigma rules to function effectively.
Investigate any alerts generated by the Sigma rules to determine the legitimacy of the PowerShell activity and take appropriate remediation steps.
Continuously tune the Sigma rules based on your environment to reduce false positives and improve detection accuracy.

Suspicious Execution via Windows Command Debugging Utility

hello@craftedsignal.io — Mon, 04 May 2026 14:17:05 +0000

The Windows command line debugging utility, cdb.exe, is a legitimate tool used for debugging applications. However, adversaries can exploit it to execute unauthorized commands or shellcode, bypassing security measures. This can be achieved by running cdb.exe from non-standard installation paths and using specific command-line arguments to execute malicious commands. The LOLBAS project documents this technique, highlighting its potential for defense evasion. This activity has been observed across various environments, necessitating detection strategies that focus on identifying anomalous executions of cdb.exe.

Attack Chain

An attacker gains initial access to a Windows system.
The attacker copies cdb.exe to a non-standard location (outside “Program Files” and “Program Files (x86)”).
The attacker executes cdb.exe with the -cf, -c, or -pd command-line arguments.
These arguments are used to specify a command file or execute a direct command.
The command file or command directly executes malicious code, such as shellcode.
The malicious code performs actions such as creating new processes, modifying files, or establishing network connections.
These actions allow the attacker to maintain persistence or escalate privileges.
The ultimate goal is to evade defenses and execute arbitrary code on the system.

Impact

Successful exploitation allows adversaries to execute arbitrary commands and shellcode on the affected system, potentially leading to complete system compromise. This can result in data theft, installation of malware, or further propagation within the network. The technique is effective at bypassing application whitelisting and other security controls that rely on standard execution paths.

Recommendation

Deploy the Sigma rule “Execution via Windows Command Debugging Utility” to your SIEM to detect suspicious cdb.exe executions (see rules section).
Enable process creation logging via Sysmon or Windows Security Event Logs to provide the necessary data for the Sigma rule.
Implement application whitelisting to prevent execution of cdb.exe from non-standard paths.
Monitor process command lines for the -cf, -c, and -pd flags when cdb.exe is executed.
Investigate any instances of cdb.exe running from unusual directories to determine legitimacy.

SIP Provider Modification for Defense Evasion

hello@craftedsignal.io — Mon, 04 May 2026 14:17:05 +0000

This detection rule identifies modifications to Subject Interface Package (SIP) providers, a critical component of the Windows cryptographic system responsible for validating file signatures. Attackers may attempt to subvert trust controls by modifying SIP providers, allowing them to bypass signature validation checks and potentially inject malicious code into trusted processes. This activity is a form of defense evasion, allowing unauthorized code execution. The rule focuses on detecting suspicious registry changes associated with SIP providers, while excluding known benign processes to minimize false positives. The rule is designed for data generated by Elastic Defend, but also supports third-party data sources like CrowdStrike, Microsoft Defender XDR, SentinelOne Cloud Funnel, and Sysmon. This activity is related to MITRE ATT&CK technique T1553.003 (SIP and Trust Provider Hijacking).

Attack Chain

The attacker gains initial access to the system through various means (e.g., phishing, exploitation of vulnerabilities).
The attacker escalates privileges to gain necessary permissions to modify the registry.
The attacker modifies the registry keys associated with SIP providers, specifically targeting CryptSIPDllPutSignedDataMsg and Trust\\FinalPolicy locations.
The attacker changes the Dll value within these registry keys to point to a malicious DLL.
The system, upon attempting to validate a file signature, loads the malicious DLL instead of the legitimate SIP provider.
The malicious DLL executes arbitrary code, potentially injecting it into other processes.
The attacker uses the injected code to further compromise the system or network.
The attacker achieves their final objective, such as data exfiltration, ransomware deployment, or establishing persistence.

Impact

Successful modification of SIP providers allows attackers to bypass signature validation checks, leading to the execution of unsigned or malicious code. This can compromise the integrity of the system, leading to data breaches, system instability, or further propagation of malware within the network. The impact can range from individual workstation compromise to widespread organizational damage, depending on the scope of the attack.

Recommendation

Deploy the Sigma rule Detect SIP Provider Modification via Registry to your SIEM and tune it for your environment to detect suspicious registry modifications related to SIP providers.
Enable Sysmon registry event logging to collect the necessary data for the Sigma rules above.
Investigate any alerts generated by the rules, focusing on the process responsible for the registry change and the DLL being loaded, as described in the rule’s triage section.
Implement application control policies to restrict the execution of unsigned or untrusted code.
Monitor the registry paths listed in the Sigma rules for unexpected changes.

Service DACL Modification via sc.exe

hello@craftedsignal.io — Mon, 04 May 2026 14:17:05 +0000

This detection identifies the modification of Discretionary Access Control Lists (DACLs) for Windows services using the sc.exe utility. Attackers can leverage this technique to deny access to a service, making it unmanageable or hiding it from system administrators and users. The detection rule focuses on identifying instances where sc.exe is used with the sdset argument, specifically targeting the denial of access for key user groups such as IU, SU, BA, SY, and WD. This activity is indicative of a defense evasion attempt aimed at hindering security tools or preventing remediation. The rule is designed for data generated by Elastic Defend, but also supports integrations with third-party data sources like CrowdStrike, Microsoft Defender XDR, and SentinelOne Cloud Funnel, offering broad coverage for detecting this malicious behavior across diverse environments.

Attack Chain

An attacker gains initial access to a system through various means (e.g., compromised credentials, phishing).
The attacker elevates privileges to gain necessary permissions to modify service configurations.
The attacker executes sc.exe with the sdset command to modify the DACL of a targeted service.
The sdset command arguments specify the new security descriptor, denying access to specific user groups (e.g., IU, SU, BA, SY, WD).
The service becomes inaccessible to the targeted user groups, potentially disrupting legitimate operations or security tools.
The attacker may repeat this process for multiple services to further impair system functionality or evade detection.
The attacker leverages the disabled or hidden services to maintain persistence or carry out other malicious activities.

Impact

Successful modification of service DACLs can lead to a denial-of-service condition for legitimate users and system administrators. This can impair the functionality of critical security tools, hinder incident response efforts, and provide attackers with a persistent foothold on the compromised system. The hiding of services can also prevent users from identifying and removing malicious services. While the number of victims is not specified in the source, organizations across various sectors are potentially vulnerable to this type of attack.

Recommendation

Deploy the Sigma rule Service DACL Modification via sc.exe to your SIEM to detect this specific behavior.
Enable Sysmon process creation logging to provide the necessary data for the Sigma rule to function effectively.
Investigate any instances where sc.exe is used with the sdset argument and access denial flags, focusing on the targeted user groups (IU, SU, BA, SY, WD).
Implement strict access controls and monitor for unauthorized attempts to modify service configurations.
Regularly audit service permissions to identify and remediate any unauthorized changes.
Review and update endpoint protection policies to prevent similar threats in the future, ensuring that all systems are equipped with the latest security patches and configurations.

Remote Desktop File Opened from Suspicious Path

hello@craftedsignal.io — Mon, 04 May 2026 14:17:05 +0000

Attackers are increasingly using malicious Remote Desktop Protocol (RDP) files to gain initial access to systems. These RDP files, often delivered via spearphishing attachments, contain connection settings that, when opened, can compromise a system. This technique allows adversaries to bypass traditional security measures by leveraging a legitimate tool (mstsc.exe) with a malicious configuration file. The observed activity involves opening RDP files from suspicious locations like Downloads, temporary folders (AppData\Local\Temp), and Outlook content cache (INetCache\Content.Outlook). This campaign has been observed as recently as October 2024, where Midnight Blizzard conducted large-scale spear-phishing using RDP files. Defenders should monitor for the execution of mstsc.exe with RDP files from untrusted locations.

Attack Chain

The attacker crafts a spearphishing email containing a malicious RDP file as an attachment.
The victim receives the email and, lured by social engineering, downloads the attached RDP file to a local directory, often the Downloads folder.
The victim double-clicks the RDP file, initiating the execution of mstsc.exe.
mstsc.exe reads the connection settings from the RDP file, which may include malicious configurations such as altered gateway settings or credential theft mechanisms.
mstsc.exe attempts to establish a remote desktop connection based on the RDP file’s settings.
If the connection is successful, the attacker gains unauthorized access to the remote system.
The attacker may then perform reconnaissance, move laterally, and escalate privileges within the compromised network.
The final objective could be data exfiltration, ransomware deployment, or establishing persistent access.

Impact

A successful attack using malicious RDP files can lead to unauthorized access to sensitive systems and data. The consequences range from data breaches and financial loss to complete system compromise and disruption of operations. The Microsoft Security blog reported a large-scale spear-phishing campaign utilizing RDP files as recently as October 2024. The targets may be across various sectors, with potentially widespread impact depending on the attacker’s objectives and the scope of the compromised network.

Recommendation

Deploy the Sigma rule Remote Desktop File Opened from Suspicious Path to your SIEM and tune for your environment, focusing on the specified file paths and mstsc.exe execution.
Enable process creation logging with command-line arguments to capture the execution of mstsc.exe and the paths of the RDP files being opened.
Educate users on the risks associated with opening RDP files from untrusted sources, particularly those received as email attachments.
Implement strict email filtering to block or quarantine emails with RDP attachments from external sources.
Monitor network connections for unusual RDP traffic originating from systems where suspicious RDP files were executed.

Potential Secure File Deletion via SDelete Utility

hello@craftedsignal.io — Mon, 04 May 2026 14:17:05 +0000

The Sysinternals SDelete utility is a legitimate tool developed by Microsoft for securely deleting files by overwriting and renaming them multiple times. While intended for secure data disposal, adversaries can abuse SDelete to remove forensic artifacts, destroy evidence of their activities, and impede data recovery efforts after a successful ransomware attack or data theft. This activity can be used as a post-exploitation technique. This detection rule focuses on identifying file name patterns indicative of SDelete’s operation, specifically detecting files with names resembling “*AAA.AAA”. The rule is designed to work with various endpoint detection and response solutions, including Elastic Defend, Microsoft Defender XDR, SentinelOne Cloud Funnel, and CrowdStrike.

Attack Chain

The attacker gains initial access to the system (e.g., via phishing or exploiting a vulnerability).
The attacker escalates privileges to gain the necessary permissions to delete files.
The attacker deploys or utilizes an existing copy of the SDelete utility.
The attacker executes SDelete against targeted files or directories.
SDelete overwrites the targeted file(s) multiple times with random data.
SDelete renames the file(s) multiple times, often with patterns such as “*AAA.AAA”.
SDelete deletes the file(s) making recovery difficult.
The attacker removes SDelete or any associated tools to further cover their tracks.

Impact

Successful exploitation of this technique can result in the permanent deletion of crucial forensic artifacts, log files, or even critical data. This can severely hinder incident response efforts, making it challenging to identify the scope of the attack, the attacker’s methods, and the compromised assets. The number of victims and affected sectors depends on the scale of the initial breach and the attacker’s objectives.

Recommendation

Deploy the “Potential Secure File Deletion via SDelete Utility” detection rule to your SIEM and tune for your environment.
Investigate any alerts generated by the detection rule, focusing on the process execution chain and identifying the user account involved.
Review the privileges assigned to the user account to ensure the least privilege principle is followed.
Enable Sysmon Event ID 11 (File Create) logging to enhance visibility into file creation events.

Potential NetNTLMv1 Downgrade Attack via Registry Modification

hello@craftedsignal.io — Mon, 04 May 2026 14:17:05 +0000

This rule detects a specific defense evasion technique where an attacker modifies the Windows registry to force a system to use the less secure NTLMv1 authentication protocol. This is known as a NetNTLMv1 downgrade attack. The registry modification involves changing the LmCompatibilityLevel value, which controls the authentication level. Attackers with local administrator privileges can perform this modification to weaken the authentication mechanism, making it easier to intercept and crack credentials. The rule is designed to detect this activity by monitoring registry events from various sources, including Elastic Defend, Microsoft Defender XDR, SentinelOne Cloud Funnel, Sysmon, and Crowdstrike. It is important to monitor for this activity as it can lead to credential theft and further compromise of the system.

Attack Chain

The attacker gains local administrator privileges on a Windows system.
The attacker uses a registry editor or command-line tool (e.g., reg.exe, PowerShell) to modify the LmCompatibilityLevel value in the registry.
The attacker navigates to one of the following registry paths: HKLM\System\CurrentControlSet\Control\Lsa\LmCompatibilityLevel or HKLM\SYSTEM\CurrentControlSet\Control\Lsa.
The attacker sets the LmCompatibilityLevel value to “0”, “1”, or “2” (or their hexadecimal equivalents “0x00000000”, “0x00000001”, “0x00000002”). These values force the system to use NTLMv1.
The system now uses NTLMv1 for authentication attempts.
The attacker initiates a man-in-the-middle attack to capture NTLMv1 authentication traffic using tools like Responder or Inveigh.
The captured NTLMv1 hashes are cracked using brute-force or dictionary attacks, revealing the user’s credentials.
The attacker uses the compromised credentials to gain unauthorized access to network resources or other systems.

Impact

A successful NetNTLMv1 downgrade attack can lead to the compromise of user credentials, enabling attackers to move laterally within the network, access sensitive data, and potentially escalate privileges. The impact can range from data breaches to complete system compromise, depending on the attacker’s objectives and the compromised user’s privileges.

Recommendation

Deploy the Sigma rule “Potential NetNTLMv1 Downgrade Attack” to detect registry modifications setting LmCompatibilityLevel to insecure values (0, 1, 2) within the specified registry paths.
Enable Sysmon registry event logging to ensure the necessary data is available for the Sigma rule to function correctly.
Review registry event logs for unauthorized modifications of LmCompatibilityLevel to confirm legitimate administrative actions.
Implement strict access control policies to limit local administrator privileges and reduce the attack surface.
Monitor the references URL for updates on recommended security configurations related to NTLM authentication.

Potential Evasion via Windows Filtering Platform Blocking Security Software

hello@craftedsignal.io — Mon, 04 May 2026 14:17:05 +0000

The Windows Filtering Platform (WFP) provides APIs and system services for network filtering and packet processing. Attackers can abuse WFP by creating malicious rules to block endpoint security processes, hindering their ability to send telemetry. This can be achieved by tools like Shutter, EDRSilencer, and Nighthawk. This detection rule identifies patterns of blocked network events linked to security software processes, signaling potential evasion tactics. The rule specifically looks for blocked network events linked to processes associated with known security software, aiming to detect and alert on attempts to disable or modify security tools. This behavior is especially concerning as it allows attackers to operate with reduced visibility.

Attack Chain

Attacker gains initial access to the target system (e.g., via compromised credentials or exploiting a vulnerability).
The attacker escalates privileges to gain administrative rights, necessary to interact with the Windows Filtering Platform.
The attacker uses a tool or script (e.g., leveraging the netsh command or custom WFP API calls) to create a new WFP filter.
The WFP filter is configured to block network traffic originating from specific processes associated with endpoint security software (e.g., elastic-agent.exe, sysmon.exe).
The system begins blocking network communication from the targeted security software.
The attacker executes malicious commands or malware on the system, knowing that security telemetry will be suppressed.
The attacker moves laterally within the network, repeating the WFP filter deployment on other systems to further impair defenses.
The attacker achieves their final objective, such as data exfiltration or ransomware deployment, with reduced risk of detection.

Impact

A successful attack using WFP to impair defenses can lead to a significant reduction in the effectiveness of endpoint security solutions. This can result in delayed detection of malicious activities, increased dwell time for attackers, and ultimately, a higher likelihood of successful data breaches or ransomware attacks. With endpoint telemetry blocked, organizations may remain unaware of the ongoing compromise until significant damage has occurred. The number of affected systems can vary depending on the attacker’s scope and objectives.

Recommendation

Enable and review Windows Audit Filtering Platform Connection and Packet Drop events to populate the logs required for the provided EQL rule (logs-system.security*, logs-windows.forwarded*, winlogbeat-*).
Deploy the provided EQL rule to your SIEM to detect suspicious WFP modifications and tune for your environment.
Investigate any alerts generated by the EQL rule, focusing on identifying the specific processes being blocked and the source of the WFP rule modifications.
Regularly review and audit WFP rules to identify any unauthorized or suspicious entries.
Implement strict access controls and monitoring for systems authorized to modify WFP rules.

Potential Data Exfiltration via Rclone

hello@craftedsignal.io — Mon, 04 May 2026 14:17:05 +0000

Attackers are leveraging Rclone, a legitimate command-line program to manage files on cloud storage, for malicious purposes. The primary abuse case involves renaming Rclone (e.g., to TrendFileSecurityCheck.exe) to evade detection based on process name. Once renamed, attackers use Rclone’s copy/sync functionalities with cloud backends like S3 or HTTP endpoints. They often employ --include filters to target specific sensitive file types for exfiltration. This activity is frequently blended with regular administrative traffic to further obfuscate the malicious intent. Defenders should be aware of this tactic, particularly when unusual processes are observed interacting with cloud storage services.

Attack Chain

The attacker gains initial access to the system through an undisclosed method.
Rclone is downloaded or transferred to the victim machine.
The rclone executable is renamed to a benign-sounding name (e.g., TrendFileSecurityCheck.exe) to masquerade as a legitimate system utility.
The attacker configures rclone to connect to a cloud storage backend (e.g., an S3 bucket or HTTP endpoint) controlled by the attacker.
A command is executed using the renamed rclone executable, specifying the copy or sync command.
The command includes --include flags to filter and select specific file types (e.g., documents, source code, databases) for exfiltration.
Rclone transfers the targeted files from the victim machine to the attacker’s cloud storage backend, potentially using the --transfers option for faster exfiltration.
The attacker accesses the exfiltrated data from their cloud storage.

Impact

Successful exploitation can lead to the exfiltration of sensitive data, including proprietary information, customer data, financial records, or intellectual property. The impact can range from reputational damage and financial losses to legal and regulatory repercussions. The scope of damage depends on the sensitivity and volume of the exfiltrated data, the number of affected systems, and the effectiveness of the attacker’s filtering criteria.

Recommendation

Deploy the Sigma rule Suspicious Rclone Usage to detect renamed rclone executables executing copy/sync commands.
Enable Sysmon process creation logging (Event ID 1) to collect the necessary process execution data for the Sigma rules.
Investigate any process identified by the Sigma rule Suspicious Rclone Usage by examining command-line arguments for cloud backend destinations and --include filters.
Monitor network connections for unusual outbound traffic to cloud storage providers (AWS S3, Azure Blob Storage, Google Cloud Storage) from processes other than approved backup solutions.
Implement application control policies to restrict the execution of unauthorized or renamed executables.

Potential Account Takeover - Logon from New Source IP

hello@craftedsignal.io — Mon, 04 May 2026 14:17:05 +0000

This detection rule identifies potential account takeover activity by analyzing Windows Security Event Logs for unusual login patterns. Specifically, it looks for user accounts that typically log in with high frequency from a single source IP address but then exhibit successful logins from a different source IP address with significantly lower frequency. This pattern may indicate that an attacker has compromised the account credentials and is accessing the network from a new, potentially malicious, location. This activity is detected by analyzing Windows Security Event ID 4624 events related to successful logins. The rule is designed to trigger when a user account logs in from a new IP address after establishing a pattern of high-volume logins from a primary IP address.

Attack Chain

Initial Access: The attacker gains access to valid user credentials through methods such as phishing, credential stuffing, or malware. (T1078)
Successful Logon: The attacker uses the compromised credentials to successfully log in to a Windows system from a new IP address (Event ID 4624, Logon Type Network/RemoteInteractive).
Lateral Movement (Possible): Once authenticated, the attacker may attempt to move laterally within the network to access additional resources or systems.
Privilege Escalation (Possible): The attacker may attempt to escalate their privileges to gain administrative access to the system or domain (TA0004).
Data Exfiltration (Possible): The attacker may attempt to exfiltrate sensitive data from the compromised system or network.
Persistence (Possible): The attacker may attempt to establish persistence mechanisms to maintain access to the system or network over time.

Impact

A successful account takeover can have significant consequences, including unauthorized access to sensitive data, lateral movement within the network, privilege escalation, and data exfiltration. The rule specifically looks for logon patterns indicative of account takeover. If an account is taken over, attackers could potentially gain access to systems and data the user has rights to access.

Recommendation

Deploy the Sigma rule provided below to your SIEM and tune for your environment, paying close attention to the max_logon threshold.
Enable Audit Logon within Windows to ensure the events needed for detection are available as mentioned in the setup instructions.
Investigate any alerts generated by the Sigma rule by confirming with the account owner if they logged in from the new source IP.
Check the new source IP for reputation, geography, and whether it is expected as described in the rule’s triage steps.
Correlate any generated alerts with other alerts for the same user or source IP such as logon failures, password changes, or MFA changes as part of your investigation.

Local Account TokenFilter Policy Modification for Defense Evasion and Lateral Movement

hello@craftedsignal.io — Mon, 04 May 2026 14:17:05 +0000

The LocalAccountTokenFilterPolicy is a Windows registry setting that, when enabled (set to 1), allows remote connections from local members of the Administrators group to be granted full high-integrity tokens during negotiation. This bypasses User Account Control (UAC) restrictions, allowing for elevated privileges remotely. Attackers may modify this registry setting to facilitate lateral movement within a network. This rule detects modifications to this specific registry setting, alerting on potential unauthorized changes that could lead to defense evasion and privilege escalation. The modification of this policy has been observed being leveraged in conjunction with pass-the-hash attacks.

Attack Chain

The attacker gains initial access to a system through an exploit, such as phishing or exploiting a vulnerability.
The attacker obtains local administrator credentials on the compromised system.
The attacker modifies the LocalAccountTokenFilterPolicy registry key to a value of 1. This is done to allow remote connections from local administrator accounts to receive high-integrity tokens. The registry key is typically located at HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\LocalAccountTokenFilterPolicy.
The attacker leverages a “pass the hash” attack (T1550.002) using the compromised local administrator credentials.
The attacker attempts to move laterally to other systems within the network using the “pass the hash” technique and the modified LocalAccountTokenFilterPolicy.
Due to the LocalAccountTokenFilterPolicy being enabled, the remote connection from the local administrator account receives a full high-integrity token.
The attacker bypasses UAC on the remote system, gaining elevated privileges.
The attacker performs malicious activities on the remote system, such as data exfiltration or deploying ransomware.

Impact

Successful modification of the LocalAccountTokenFilterPolicy allows attackers to bypass User Account Control (UAC) and gain elevated privileges on remote systems, potentially leading to unauthorized access to sensitive data, lateral movement across the network, and the deployment of ransomware. The overall impact can include data breaches, financial loss, and reputational damage.

Recommendation

Deploy the Sigma rule Local Account TokenFilter Policy Enabled to your SIEM and tune for your environment to detect unauthorized modifications to the LocalAccountTokenFilterPolicy registry key.
Enable Sysmon registry event logging to capture modifications to the registry, which is required for the Local Account TokenFilter Policy Enabled Sigma rule.
Review the processes excluded in the rule query and ensure they are legitimate and necessary to prevent false positives.
Monitor registry events for changes to the HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\LocalAccountTokenFilterPolicy path, specifically looking for changes to the value data.

Detection of VScode Remote Tunneling for Command and Control

hello@craftedsignal.io — Mon, 04 May 2026 14:17:05 +0000

This detection focuses on identifying the misuse of Visual Studio Code’s (VScode) remote tunnel feature to establish unauthorized access or control over systems. While the VScode remote tunnel feature is designed to allow developers to connect to remote environments seamlessly, attackers can abuse this functionality for malicious purposes. The rule specifically looks for the execution of the VScode portable binary with the “tunnel” command-line option, which is indicative of an attempt to establish a remote tunnel session to either GitHub or a remote VScode instance. Successful exploitation can lead to command and control capabilities, allowing attackers to remotely manage and compromise the affected system. The rule aims to detect this suspicious behavior by monitoring process execution and command-line arguments.

Attack Chain

The attacker gains initial access to the target system through unspecified means.
The attacker downloads a portable version of Visual Studio Code (VScode) onto the compromised system.
The attacker executes the VScode binary with the tunnel command-line argument to initiate a remote tunnel session.
The attacker specifies additional arguments such as --accept-server-license-terms to bypass license agreement prompts.
The VScode tunnel attempts to establish a connection to a remote server, potentially a GitHub repository or a remote VScode instance controlled by the attacker.
If successful, the tunnel creates a persistent connection, allowing the attacker to execute commands and transfer files.
The attacker uses the established tunnel to remotely access the compromised system, enabling them to perform malicious activities such as data exfiltration or lateral movement.
The attacker maintains persistent access through the established tunnel, allowing for long-term command and control of the compromised system.

Impact

Successful exploitation allows attackers to establish a persistent command and control channel, enabling them to remotely manage the compromised system. This can lead to data theft, deployment of ransomware, or further lateral movement within the network. While the number of potential victims and specific sectors targeted are not explicitly stated, the widespread use of VScode makes a wide range of organizations vulnerable.

Recommendation

Deploy the “Attempt to Establish VScode Remote Tunnel” rule to detect suspicious VScode tunnel activity in your environment.
Enable Sysmon process-creation logging to capture the necessary process execution data.
Investigate any alerts triggered by the rule, focusing on the command-line arguments and process behaviors to confirm malicious intent.
Monitor network connections originating from VScode processes for unusual or unauthorized connections to external servers.
Review and whitelist legitimate uses of VScode’s tunnel feature by authorized developers to reduce false positives.

Command Shell Activity Started via RunDLL32

hello@craftedsignal.io — Mon, 04 May 2026 14:17:05 +0000

Attackers commonly abuse RunDLL32, a legitimate Windows utility, to execute malicious code by hosting it within DLLs. This technique allows adversaries to launch command shells like cmd.exe or PowerShell, effectively bypassing traditional security controls. Defenders should be aware of this technique because it provides a stealthy way for attackers to execute arbitrary commands, potentially leading to further compromise of the system. This activity is detected by monitoring for command shells initiated by RunDLL32, while excluding known benign patterns to reduce false positives. The detection rule was last updated on 2026/05/04 and supports multiple data sources, including Elastic Defend, Microsoft Defender XDR, and Sysmon.

Attack Chain

The attacker gains initial access to the system through an exploit or social engineering.
The attacker uses RunDLL32.exe to execute a malicious DLL.
RunDLL32.exe loads the specified DLL into memory.
The malicious DLL contains code to execute a command shell (cmd.exe or powershell.exe).
RunDLL32.exe spawns a command shell process.
The attacker uses the command shell to execute commands for reconnaissance.
The attacker may use the command shell to download additional payloads.
The attacker leverages the command shell to perform lateral movement.

Impact

Successful exploitation allows attackers to execute arbitrary commands on the compromised system. While the rule is rated “low” severity, this initial access can lead to credential access (T1552) and further lateral movement within the network. Attackers can potentially gain full control of the system, leading to data theft, system disruption, or other malicious activities.

Recommendation

Deploy the Sigma rule “Command Shell Activity Started via RunDLL32” to your SIEM and tune for your environment.
Enable Sysmon process creation logging (Event ID 1) to provide the necessary data for this detection.
Review the process details of RunDLL32.exe to confirm the parent-child relationship with the command shell, helping to reduce false positives.
Implement enhanced monitoring for rundll32.exe and related processes to detect similar activities in the future and improve response times.

Potential Chroot Container Escape via Mount

hello@craftedsignal.io — Sat, 02 May 2026 12:45:21 +0000

This detection rule monitors for a specific sequence of commands on Linux systems that could indicate an attempt to escape a containerized environment. The attack involves first mounting a file system, typically targeting the host’s root file system, and then using the chroot command to change the root directory. This combination, if successful, allows an attacker inside a container to gain unauthorized access to the host system. The rule is designed to identify this uncommon behavior pattern, which is a strong indicator of malicious activity. The rule is applicable to environments utilizing Elastic Defend, SentinelOne Cloud Funnel, and Crowdstrike FDR. The detection looks for this sequence occurring within a 5-minute timeframe.

Attack Chain

An attacker gains initial access to a container, possibly through exploiting a vulnerability or misconfiguration in the application running within the container.
The attacker attempts to mount the host’s root filesystem within the container using the mount command, often targeting /dev/sd* devices. This requires sufficient privileges within the container, or the exploitation of a container escape vulnerability to gain such privileges.
The mount command is executed with arguments specifying the device to mount and the mount point within the container’s file system.
The attacker then executes the chroot command, changing the root directory of the current process to the mounted host’s root filesystem.
After successfully executing chroot, the attacker’s perspective shifts to the host’s file system, allowing them to access and modify sensitive files and configurations.
The attacker uses their newly acquired access to install backdoors, create new user accounts with elevated privileges, or modify system configurations to establish persistence.
The attacker may attempt to move laterally to other containers or systems within the network, leveraging their compromised position on the host.
The final objective is to gain complete control over the host system and potentially the entire infrastructure, leading to data exfiltration, system disruption, or other malicious activities.

Impact

A successful container escape can have severe consequences, potentially leading to complete compromise of the host system and the data it contains. Depending on the environment, this could affect a single server or spread to many hosts. The compromise of containerized environments can lead to data breaches, service disruption, and reputational damage. Given the sensitive nature of data often processed within containers, the impact can range from financial losses to regulatory penalties.

Recommendation

Deploy the Sigma rules in this brief to your SIEM and tune for your environment to detect potential container escapes.
Enable Elastic Defend integration to collect process data, and ensure Session View data is enabled to enhance visibility as mentioned in the setup guide.
Review and harden container configurations to minimize privileges granted to containerized processes, reducing the attack surface for escape attempts.
Implement network segmentation to limit the potential for lateral movement following a successful container escape.
Monitor process execution logs for unusual mount and chroot command sequences within container environments using Elastic Defend, SentinelOne, and Crowdstrike logs.

Chroot Execution in Container Context on Linux

hello@craftedsignal.io — Sat, 02 May 2026 12:45:21 +0000

This detection rule identifies instances of the chroot command being executed within a Linux containerized environment. It leverages process execution telemetry from Elastic Defend and Auditd Manager to detect potential container escape attempts. The rule focuses on processes where the name is chroot or the command-line arguments contain chroot. Container context is determined by identifying processes with a title matching runc init, a container workload entry leader, or runc as the parent process. Successful container escapes can allow attackers to gain unauthorized access to the host system. The technique is often combined with sensitive host mounts, which are then leveraged after the chroot to access files and processes outside the container.

Attack Chain

An attacker gains initial access to a container, potentially through exploiting a vulnerability in the containerized application.
The attacker identifies sensitive host mounts within the container’s filesystem, such as /host, /proc/1/root, or other unexpected node paths.
The attacker executes the chroot command, specifying an alternate root filesystem, typically a host-linked mount.
The chroot command redirects system calls to the new root filesystem, effectively isolating the attacker from the container’s original environment.
The attacker leverages the new root filesystem to access files, directories, and processes on the host system outside the container’s boundaries.
The attacker may then attempt to escalate privileges by exploiting vulnerabilities in host system services or binaries.
The attacker may install malware or establish persistence mechanisms on the host system.
The attacker uses the compromised host system to pivot to other systems on the network or to exfiltrate sensitive data.

Impact

A successful container escape can lead to full compromise of the underlying host system, potentially impacting all containers running on the same host. This can enable attackers to access sensitive data, disrupt services, and move laterally within the network. In multi-tenant environments, a container escape can compromise the security of other tenants sharing the same infrastructure. A single successful container escape can lead to a widespread breach impacting numerous systems and applications.

Recommendation

Deploy the Sigma rule Chroot Execution in Container Context to your SIEM and tune for your environment.
Enable process execution telemetry from Elastic Defend and Auditd Manager on Linux to ensure the required data is available for detection.
Investigate any alerts generated by the Sigma rule to determine if the chroot execution was authorized and the target directory is an internal build root versus a host filesystem mount.
Monitor for follow-on shell execution, access to the container runtime socket, or kubelet credential paths, as these are common indicators of container escape attempts.

GenAI Tools Accessing Sensitive Files for Credential Access and Persistence

hello@craftedsignal.io — Fri, 01 May 2026 22:46:51 +0000

Attackers are increasingly leveraging GenAI agents to automate the discovery and exfiltration of sensitive information, including credentials, API keys, and tokens stored within files on compromised systems. The observed activity involves GenAI tools accessing critical files such as cloud credentials, SSH keys, browser password databases, and shell configuration files. Successful exploitation allows attackers to harvest credentials, gain unauthorized access to systems, and establish persistence mechanisms for continued access. The GenAI tools mentioned include ollama, textgen, lmstudio, claude, cursor, copilot, codex, jan, gpt4all, gemini-cli, genaiscript, grok, qwen, koboldcpp, llama-server, windsurf, zed, opencode, and goose. This activity highlights the emerging threat landscape of AI-assisted attacks and the need for robust detection and mitigation strategies.

Attack Chain

Initial compromise of a system through an unrelated vulnerability or social engineering.
Installation or execution of a GenAI tool (e.g., ollama, lmstudio) on the compromised system.
The GenAI tool is configured or instructed to scan the file system for sensitive files.
The GenAI tool accesses files containing credentials, such as .aws/credentials, browser password databases (Login Data, key3.db), or SSH keys (.ssh/id_*).
The GenAI tool exfiltrates the harvested credentials and API keys to a remote server controlled by the attacker.
The attacker uses the stolen credentials to gain unauthorized access to cloud resources, internal systems, or other sensitive accounts.
The GenAI tool attempts to modify shell configuration files (e.g., .bashrc, .zshrc) to establish persistence.
Upon system restart or user login, the modified shell configuration executes malicious commands, granting the attacker persistent access.

Impact

Successful exploitation of this threat can lead to significant data breaches, unauthorized access to critical systems, and persistent compromise of affected environments. Attackers can leverage stolen credentials to escalate privileges, move laterally within the network, and exfiltrate sensitive data. The number of victims and sectors targeted are currently unknown, but the potential impact is widespread given the increasing adoption of GenAI tools in various industries. Credential theft leads to financial loss, intellectual property theft, and reputational damage.

Recommendation

Deploy the Sigma rule “GenAI Process Accessing Sensitive Files” to your SIEM to detect GenAI tools accessing sensitive files on endpoints.
Enable file access monitoring on systems where GenAI tools are used to capture access events for analysis.
Review and restrict the use of GenAI tools within the environment, especially concerning access to sensitive file paths.
Monitor for modifications to shell configuration files (e.g., .bashrc, .zshrc, .profile) as an indicator of persistence attempts.
Implement regular credential rotation policies to minimize the impact of stolen credentials.

Potential Kerberos SPN Spoofing via Suspicious DNS Query

hello@craftedsignal.io — Fri, 01 May 2026 17:31:25 +0000

This detection identifies a specific pattern in DNS queries indicative of Kerberos SPN spoofing, a technique used to coerce systems into authenticating to attacker-controlled hosts. The pattern “UWhRCA…BAAAA” represents a marshaled CREDENTIAL_TARGET_INFORMATION structure. Attackers exploit this by crafting malicious DNS names to trick victim systems into requesting Kerberos tickets for legitimate services, often their own identity, but directed towards an attacker-controlled endpoint. This can lead to Kerberos relay or NTLM reflection/relay attacks, bypassing normal NTLM fallback mechanisms. The technique is associated with tools like RemoteKrbRelay and wspcoerce. This activity has been observed in various attacks targeting Windows environments where Kerberos authentication is prevalent. Defenders need to detect and mitigate this early stage of credential access.

Attack Chain

The attacker identifies a target Windows system within the network.
The attacker sets up a malicious server to receive coerced authentication requests.
The attacker crafts a malicious DNS query containing a base64-encoded blob “UWhRCA…BAAAA” representing a marshaled CREDENTIAL_TARGET_INFORMATION structure.
The victim system, triggered by an external factor (e.g., RPC call, scheduled task, or web request), attempts to resolve the crafted DNS name.
The malicious DNS query is sent to the DNS server, which resolves to the attacker’s server.
The victim system initiates a Kerberos authentication request to the attacker’s server, believing it to be a legitimate service.
The attacker’s server relays the Kerberos ticket or uses NTLM reflection/relay techniques to gain unauthorized access.
The attacker compromises the victim system or pivots to other systems within the network using the stolen credentials.

Impact

Successful exploitation can lead to credential compromise, lateral movement, and domain takeover. Victims in Active Directory environments are particularly vulnerable. The impact includes unauthorized access to sensitive data, disruption of services, and potential ransomware deployment. If the coerced service has high privileges, the attacker can gain complete control over the compromised system or even the entire domain. Organizations using Kerberos authentication are at risk.

Recommendation

Deploy the “Potential Kerberos SPN Spoofing via Suspicious DNS Query” rule to your SIEM and tune for your environment to detect malicious DNS queries.
Enable Sysmon Event ID 22 - DNS Query logging to provide the necessary data for detection.
Investigate and block any DNS queries resolving to external IPs that contain the “UWhRCA…BAAAA” pattern.
Monitor process creation events for processes initiating DNS queries containing the suspicious pattern, specifically looking for known coercion tools.
Implement network segmentation to limit the impact of lateral movement if a system is compromised.
Review and harden Kerberos configurations to prevent SPN spoofing and relay attacks.

Potential Root Effective Shell from Non-Standard Path via Auditd

hello@craftedsignal.io — Fri, 01 May 2026 09:51:29 +0000

This detection identifies potential privilege escalation attempts on Linux systems by monitoring for processes with a root effective user ID (EUID) but a non-root real user ID (RUID), combined with the use of the -p flag (commonly used to preserve privileges in shells like bash or dash) and execution from a non-standard path (outside of /bin, /sbin, /usr/bin, etc.). Attackers may copy or link setuid-capable shells or similar helpers into writable locations to regain a root context after local exploitation. This behavior is often associated with post-exploitation activities where attackers attempt to maintain or regain elevated privileges. The rule relies on Auditd data to provide visibility into process execution events and user context. The original rule was published on 2026-04-24 by Elastic.

Attack Chain

Attacker gains initial access to the system with limited privileges (e.g., through exploiting a vulnerability or using stolen credentials).
Attacker identifies a writable directory outside of standard system binary paths (e.g., /tmp, /var/tmp).
Attacker copies or creates a symbolic link to a setuid-capable shell (e.g., /bin/bash, /bin/dash) into the identified writable directory. This copied shell retains the setuid bit.
Attacker executes the copied or linked shell from the non-standard path with the -p flag (e.g., /tmp/bash -p). The -p flag instructs the shell to preserve privileges, effectively running with the effective user ID (EUID) of root.
Auditd logs this process execution event, capturing the non-standard path, the use of the -p flag, the root EUID, and the non-root RUID.
The detection rule identifies the process execution event based on the criteria outlined above.
Attacker now has a root shell and can perform administrative tasks, install malware, or further compromise the system.

Impact

A successful privilege escalation attack can grant an attacker complete control over the compromised system. This allows them to access sensitive data, install malicious software, modify system configurations, and potentially pivot to other systems on the network. This can lead to data breaches, system downtime, and significant financial losses. The risk score for this type of activity is considered high due to the potential for significant impact.

Recommendation

Deploy the Sigma rule Potential Root Effective Shell from Non-Standard Path via Auditd to your SIEM and tune for your environment.
Ensure that Auditd Manager or Auditbeat is properly configured to collect process execution events with relevant fields (event.action, user.id, user.effective.id, process.args, and process.executable) as described in the rule setup to enable the rule to function correctly.
Investigate any alerts generated by this rule by inspecting process.executable, process.args, process.parent, and the full command line reconstructed in audit logs.
Regularly audit all setuid binaries on the filesystem to identify any unauthorized or malicious setuid executables.
Implement access controls and file integrity monitoring to prevent unauthorized modification of system binaries and writable directories.

Potential Copy Fail (CVE-2026-31431) Exploitation via AF_ALG Socket

hello@craftedsignal.io — Thu, 30 Apr 2026 16:24:01 +0000

CVE-2026-31431, dubbed Copy Fail, is a Linux kernel vulnerability that allows an attacker to write controlled bytes into the page cache of a readable file by abusing the authencesn AEAD path through AF_ALG and splice(). Public exploitation targets setuid-root binaries such as /usr/bin/su, then executes the corrupted in-memory copy to gain root. The vulnerability lies in the shared host page cache, making container-originated activity a possible node-compromise attempt. This exploit leverages the AF_ALG interface, which, while uncommon for unprivileged users, may be used in specific environments like kernel crypto testing or HSM integrations. Defenders should prioritize patching vulnerable kernels and restricting AF_ALG socket creation for untrusted workloads to mitigate this risk.

Attack Chain

An unprivileged user initiates multiple AF_ALG socket creation events (auditd.data.syscall == “socket” and auditd.data.a0 == “26”) or splice operations.
The attacker leverages the vulnerability to corrupt the page cache of a setuid-root binary, such as /usr/bin/su.
The attacker executes the targeted setuid-root binary (e.g., /usr/bin/su).
Due to the corrupted page cache, the executed binary behaves in an unexpected manner, leading to a privilege escalation.
The process transitions to a root UID, indicating successful privilege escalation.
A root shell is spawned, providing the attacker with elevated privileges.
The attacker performs actions requiring root privileges, such as creating persistence mechanisms or accessing sensitive credentials.
The attacker potentially compromises the entire host or node, especially in containerized environments.

Impact

Successful exploitation of CVE-2026-31431 leads to privilege escalation, allowing attackers to gain root access on the affected Linux system. This can result in complete system compromise, data exfiltration, and the ability to install malware or create persistent backdoors. In containerized environments, a compromised container can lead to node compromise, affecting other containers running on the same host. The vulnerability affects systems running vulnerable kernel versions, potentially impacting a wide range of servers and workstations.

Recommendation

Deploy the Sigma rule “Potential Copy Fail (CVE-2026-31431) Exploitation via AF_ALG Socket - Socket Creation Burst” to detect initial exploitation attempts based on AF_ALG socket activity.
Deploy the Sigma rule “Potential Copy Fail (CVE-2026-31431) Exploitation via AF_ALG Socket - Privilege Escalation” to detect privilege escalation attempts by monitoring executed processes with an effective user ID of root.
Immediately patch the kernel with the vendor fix for CVE-2026-31431 to eliminate the underlying vulnerability.
Until patching is possible, consider blocking algif_aead module loading or restricting AF_ALG socket creation via seccomp for untrusted workloads.
Add audit rules for socket, splice, and bind events as described in the rule’s Setup instructions to ensure comprehensive monitoring of AF_ALG related syscalls.

LLM-Based Compromised User Triage

hello@craftedsignal.io — Tue, 28 Apr 2026 17:17:03 +0000

This Elastic Security rule, designed for Elastic Cloud deployments 9.3.0 and later, leverages an Elastic Managed LLM to analyze correlated security alerts and identify potentially compromised user accounts. The rule aggregates alerts associated with a single user, examining patterns, MITRE ATT&CK tactic progression, unusual geographic locations, and multi-host activity. The LLM then provides a verdict (compromised, benign, or suspicious) and a confidence score. It aims to reduce analyst workload by surfacing users exhibiting indicators of credential theft or unauthorized access and is intended to be used in conjunction with other detection mechanisms to provide a higher-order analysis.

Attack Chain

Multiple security alerts are triggered across various data sources, such as endpoint activity, network traffic, and authentication logs.
Alerts are aggregated and correlated by user.name and user.id, filtering out system accounts and noisy rule types.
The rule extracts key alert details, including rule names, threat tactics, techniques, affected hosts, source IPs, and event datasets.
An alert summary is constructed, including the user’s name, email, number of alerts, distinct rules triggered, affected hosts, time window, and maximum risk score.
The LLM analyzes the alert summary, considering multi-host activity, credential access alerts, unusual source IPs, and tactic progression.
The LLM provides a verdict (TP, FP, or SUSPICIOUS), a confidence score, and a brief summary explaining the assessment.
The rule filters results to surface only compromised or suspicious accounts with a confidence score above 0.7.
ECS fields are mapped for timeline visibility and alert exclusion and the analyst is presented with a high-confidence alert.

Impact

A successful attack using compromised credentials can lead to unauthorized access to sensitive data, lateral movement within the network, and potentially data exfiltration or ransomware deployment. This detection rule helps to quickly identify compromised user accounts, allowing security teams to respond promptly and prevent further damage. The rule reduces the amount of time analysts spend manually triaging alerts and helps them prioritize high-risk users based on an LLM’s assessment.

Recommendation

Ensure that your Elastic Cloud deployment is running version 9.3.0 or later to leverage the ES|QL COMPLETION command with Elastic’s managed LLM.
Review the Esql.summary field in the generated alerts to understand the LLM’s assessment of why the user was flagged.
Investigate alerts where the Esql.confidence score is above 0.9, as these indicate strong indicators of compromise.
Examine the Esql.kibana_alert_rule_name_values and Esql.kibana_alert_rule_threat_tactic_name_values to understand which detection rules triggered and what MITRE ATT&CK tactics were observed.
Use the provided investigation steps in the rule’s note to conduct a thorough investigation, checking for unusual login times, locations, password resets, and MFA changes.

WDAC Policy File Creation by Unusual Process

hello@craftedsignal.io — Sat, 02 Nov 2024 12:00:00 +0000

Attackers are increasingly targeting Windows Defender Application Control (WDAC) to disable or weaken endpoint defenses. By crafting malicious WDAC policies, adversaries can block legitimate security software and evade detection. This technique involves creating WDAC policy files (.p7b or .cip) in protected system directories using unauthorized processes. The activity often occurs when attackers have already gained a foothold in the system and are attempting to solidify their position. Successful deployment of a malicious WDAC policy can significantly hinder incident response and allow malware to operate undetected. This tactic has gained traction since late 2024, with offensive tools like Krueger demonstrating the potential for weaponizing WDAC against EDR solutions.

Attack Chain

Initial Access: The attacker gains initial access to the system through methods such as phishing or exploiting a software vulnerability.
Privilege Escalation: The attacker escalates privileges to gain administrative access, which is required to modify WDAC policies.
Policy Creation: The attacker crafts a malicious WDAC policy using tools or scripts. This policy is designed to block specific security products or processes.
Staging: The malicious policy is staged in a temporary location on the system, often within user-writable directories.
Policy Placement: The attacker moves the malicious WDAC policy file (.p7b or .cip) to a protected system directory, such as C:\Windows\System32\CodeIntegrity\ or C:\Windows\System32\CodeIntegrity\CiPolicies\Active\. The tool used may be a Living-off-the-Land Binary (LOLBin) or a custom .NET assembly.
Activation: The attacker triggers the activation of the new WDAC policy, which often requires a system reboot or the use of a service control utility.
Defense Evasion: Once the policy is active, the targeted security products are blocked, allowing the attacker to operate with reduced risk of detection.
Lateral Movement/Objectives: With defenses weakened, the attacker can move laterally within the network, exfiltrate data, or achieve other objectives.

Impact

A successful attack targeting WDAC can severely impair an organization’s ability to detect and respond to threats. By blocking security software, attackers can operate with impunity, leading to data breaches, financial losses, and reputational damage. Observed damage includes disabled endpoint detection and response (EDR) solutions, allowing ransomware and other malware to execute without interference. The scope of impact can range from individual workstations to entire domains, depending on the breadth of the WDAC policy deployment.

Recommendation

Deploy the “WDAC Policy File by an Unusual Process” Sigma rule to your SIEM to detect unauthorized WDAC policy modifications.
Monitor file creation events with extensions .p7b and .cip in C:\Windows\System32\CodeIntegrity\ and C:\Windows\System32\CodeIntegrity\CiPolicies\Active\ directories, specifically filtering for processes other than poqexec.exe, TiWorker.exe, and omadmclient.exe.
Enable Sysmon Event ID 11 (File Create) logging to capture file creation events and provide the necessary data for the Sigma rule to function effectively.
Implement strict access control policies on WDAC policy directories to prevent unauthorized modification.

Potential Privilege Escalation via SUID/SGID on Linux

hello@craftedsignal.io — Sat, 02 Nov 2024 12:00:00 +0000

The SUID (Set User ID) and SGID (Set Group ID) bits are file permission mechanisms in Unix-like operating systems that allow a program to be executed with the privileges of the file’s owner or group, respectively. While intended for legitimate purposes, such as allowing users to perform specific administrative tasks, they can be abused by attackers to escalate privileges. Attackers can exploit misconfigured SUID/SGID binaries to gain elevated access or persistence. This detection focuses on identifying processes running with root privileges (UID/GID 0) but initiated by non-root users, flagging potential misuse of SUID/SGID permissions on Linux systems monitored by Elastic Defend. This can indicate an attacker attempting to exploit a misconfiguration in order to escalate their privileges to root, or establish a backdoor for persistence.

Attack Chain

An attacker gains initial access to a Linux system via some vulnerability or compromised credentials.
The attacker identifies binaries with SUID/SGID bits set.
The attacker executes a vulnerable SUID/SGID binary, such as find or nmap.
The binary executes with root privileges, even though the attacker is a non-root user.
The attacker leverages the elevated privileges to read sensitive files, modify system configurations, or install malicious software.
The attacker escalates privileges to root.
The attacker establishes persistence by creating a new SUID/SGID binary or modifying an existing one.

Impact

Successful exploitation of SUID/SGID misconfigurations can lead to complete system compromise, as attackers gain root privileges. Attackers can install malware, steal sensitive data, or disrupt critical services. The impact can range from data breaches to denial-of-service attacks. Given the broad range of binaries potentially affected, this vulnerability can impact various sectors and potentially affect a large number of Linux systems.

Recommendation

Deploy the provided Sigma rule Privilege Escalation via SUID/SGID to your SIEM to detect potential privilege escalation attempts.
Enable Elastic Defend integration to ensure the necessary process execution data is available.
Regularly audit SUID/SGID permissions across your Linux systems and remove unnecessary SUID/SGID bits.
Investigate any alerts generated by the Sigma rule by checking process.real_user.id and process.real_group.id to determine if non-root users initiated the process.
Review the process details, including process.name and process.args, to understand the nature of the executed command and its intended function.
Monitor system logs for suspicious activity around the time of the alert to identify any related actions.

MsiExec Child Process Spawning Network Connections for Defense Evasion

hello@craftedsignal.io — Sat, 26 Oct 2024 12:00:00 +0000

Adversaries may abuse the Windows Installer service (msiexec.exe) to proxy the execution of malicious payloads, effectively bypassing application control and other security mechanisms. This technique, known as “Msiexec” proxy execution (T1218.007), involves using msiexec.exe to execute malicious DLLs or scripts. The detection focuses on identifying child processes spawned by MsiExec, particularly those exhibiting network activity. This behavior is atypical for legitimate software installations and updates, making it a strong indicator of potential malicious use. Defenders should be aware of this technique as it allows attackers to blend in with legitimate system processes. The Elastic detection rule, updated on 2026-05-04, aims to identify this suspicious activity across multiple data sources including Elastic Defend, Sysmon, and SentinelOne.

Attack Chain

Attacker gains initial access to the system through an exploit or social engineering.
Attacker leverages msiexec.exe to execute a malicious MSI package with a /v parameter, commonly used to pass verbose logging options, potentially hiding malicious commands.
The malicious MSI package contains custom actions that execute arbitrary code.
Msiexec.exe spawns a child process (e.g., powershell.exe, cmd.exe, or another executable) to carry out malicious actions.
The child process establishes a network connection to an external server or performs DNS lookups, possibly for command and control (C2) communication or to download additional payloads.
The attacker uses the network connection to download and execute further tools or scripts.
The attacker performs lateral movement within the network.
The final objective could be data exfiltration, ransomware deployment, or persistent access.

Impact

Successful exploitation allows attackers to bypass application control and execute arbitrary code on the system. This can lead to malware installation, data theft, or complete system compromise. While the exact number of victims is not specified in the provided source, the technique can be applied across various sectors. The impact can range from individual workstation compromises to large-scale breaches affecting entire organizations.

Recommendation

Deploy the Sigma rule MsiExec Child Process with Unusual Executable and Network Connection to detect suspicious msiexec.exe child processes initiating network connections based on unusual executable paths.
Enable Sysmon process creation logging (Event ID 1) and network connection logging (Event ID 3) to provide the necessary data for the Sigma rule.
Investigate any alerts triggered by the Sigma rules, focusing on the process tree, command-line arguments, and network destinations.
Review and whitelist legitimate software installations and automated deployment tools that use MsiExec and require network access to minimize false positives, as detailed in the “False positive analysis” section of the source material.

Alternate Data Stream Creation/Execution at Volume Root Directory

hello@craftedsignal.io — Mon, 08 Jul 2024 12:00:00 +0000

This detection rule identifies the creation or execution of Alternate Data Streams (ADS) within the root directory of a volume on Windows systems. Attackers leverage this technique to conceal malicious tools or data, as ADSs created in this manner are not easily discoverable by standard system utilities. This method allows for the persistence and execution of malware while evading typical detection mechanisms. This rule is designed for data generated by Elastic Defend, Microsoft Defender XDR, and SentinelOne Cloud Funnel, providing broad coverage across different endpoint security solutions. Monitoring for ADS activity at the volume root is crucial to identify potential defense evasion attempts and hidden malicious payloads.

Attack Chain

Attacker gains initial access to the target system (e.g., through phishing or exploiting a vulnerability).
The attacker executes a script or program (e.g., PowerShell) to create a hidden ADS at the root of a volume (e.g., C:\:evil.exe).
The ADS is populated with malicious code, such as a reverse shell or malware payload.
The attacker uses a command-line tool or script to execute the hidden ADS file. For example: wmic process call create "cmd.exe /c start C:\:evil.exe".
The malicious code within the ADS executes, allowing the attacker to perform unauthorized actions, such as data exfiltration or establishing persistence.
The attacker uses the hidden ADS to maintain persistence on the system, ensuring continued access even after reboots.
The attacker further leverages the compromised system to move laterally within the network, compromising additional systems and escalating privileges.

Impact

Successful exploitation allows attackers to hide malicious tools and maintain persistence on compromised systems. The creation of ADSs at the volume root directory makes it difficult for administrators and security tools to detect the presence of malware. This can lead to prolonged compromise, data breaches, and significant disruption of business operations. The rule has a risk score of 47, and a medium severity is applied.

Recommendation

Deploy the Sigma rules provided in this brief to your SIEM to detect ADS creation and execution at the volume root directory.
Enable logging for file creation events (Sysmon Event ID 11) and process creation events (Sysmon Event ID 1) for enhanced visibility into ADS activity.
Investigate alerts generated by the Sigma rules to determine the legitimacy of ADS creation or execution, focusing on processes and file paths that match the [A-Z]:\\:.+ regex pattern in the rule query.
Regularly scan systems for hidden ADS files using specialized tools to uncover any potential malicious files.
Implement application control policies to restrict the execution of unauthorized applications and prevent the creation of malicious ADSs.

Unsigned DLL Loaded by DNS Service

hello@craftedsignal.io — Wed, 03 Jul 2024 12:00:00 +0000

The detection rule identifies the loading of unusual DLLs by the Windows DNS Server process (dns.exe), potentially indicating the abuse of the ServerLevelPluginDll functionality, as described in public research and proof-of-concept code. This technique allows attackers to load arbitrary DLLs into the DNS service, leading to privilege escalation and remote code execution with SYSTEM privileges. The rule focuses on detecting unsigned or untrusted DLLs loaded by dns.exe, highlighting potential exploitation attempts and unauthorized modifications to the DNS service. Successful exploitation grants the attacker elevated privileges, allowing them to perform malicious actions on the system. The rule is designed for data generated by Elastic Defend and supports Sysmon Event ID 7 (Image Loaded) as an additional data source.

Attack Chain

An attacker gains initial access to the system through unspecified means.
The attacker modifies the DNS Server configuration to enable the loading of server-level plugin DLLs.
The attacker places a malicious, unsigned DLL in a location accessible to the DNS service.
The DNS service (dns.exe) loads the malicious DLL upon startup or configuration change.
The malicious DLL executes code within the context of the DNS service, inheriting SYSTEM privileges.
The attacker uses the elevated privileges to perform malicious actions, such as installing backdoors or modifying system settings.
The attacker maintains persistence by ensuring the malicious DLL is loaded on subsequent system restarts.

Impact

Successful exploitation allows attackers to execute arbitrary code with SYSTEM privileges, granting them complete control over the compromised system. This can lead to data theft, system corruption, or the installation of persistent backdoors. The impact includes potential privilege escalation, remote code execution, and complete system compromise.

Recommendation

Deploy the Sigma rule “Unsigned DLL loaded by DNS Service” to your SIEM and tune for your environment.
Ensure Sysmon Event ID 7 (Image Loaded) is enabled to provide the necessary data for the detection rule.
Investigate any alerts generated by the Sigma rule by reviewing the DLL file path and code signature status.
Regularly review and validate the DNS server configuration to ensure that only trusted DLLs are loaded.
Implement code signing policies to prevent the loading of unsigned DLLs.

NTDS Dump via Wbadmin

hello@craftedsignal.io — Wed, 03 Jul 2024 10:00:00 +0000

This detection identifies the execution of wbadmin.exe with arguments indicative of an attempt to access and dump the NTDS.dit file from a Windows domain controller. Attackers with sufficient privileges, specifically those belonging to groups like Backup Operators, can abuse the legitimate wbadmin.exe utility to create a backup of the Active Directory database (NTDS.dit). This file contains sensitive credential information, and once obtained, attackers can extract password hashes and compromise the entire domain. This activity is often part of a larger attack aimed at gaining persistent access and control over the network. The Elastic detection rule was published on 2024-06-05 and last updated on 2026-05-04.

Attack Chain

An attacker gains initial access to a system within the target network. This may be achieved through phishing, exploiting vulnerabilities, or compromised credentials.
The attacker escalates privileges to obtain membership in the Backup Operators group or a similar privileged group capable of running backups.
The attacker executes wbadmin.exe with the recovery argument, targeting the NTDS.dit file. The command line includes parameters to create a system state backup.
Wbadmin creates a backup of the system state, including the NTDS.dit file, in a specified location.
The attacker copies the NTDS.dit file from the backup location to a separate location for offline analysis.
The attacker uses tools such as ntdsutil.exe or secretsdump.py to extract password hashes from the NTDS.dit file.
The attacker cracks the password hashes or uses them in pass-the-hash attacks to gain access to other systems and resources within the domain.
The attacker achieves domain dominance and persistence, allowing them to control critical systems and data.

Impact

Successful exploitation allows attackers to dump credentials from the NTDS.dit file, leading to complete compromise of the Active Directory domain. This enables them to move laterally, access sensitive data, and establish persistent control over the environment. The impact can include data breaches, ransomware deployment, and long-term disruption of business operations. The medium risk score indicates that while the attack requires specific privileges, the consequences are significant if successful.

Recommendation

Enable process creation logging with command line arguments to detect wbadmin.exe execution as described in the Attack Chain (Data Source: Windows Security Event Logs, Sysmon).
Implement the provided Sigma rule to detect suspicious wbadmin.exe execution with NTDS.dit related arguments in your SIEM (Rule: NTDS Dump via Wbadmin).
Monitor and restrict membership in privileged groups like Backup Operators to minimize the risk of abuse (Reference: https://medium.com/r3d-buck3t/windows-privesc-with-sebackupprivilege-65d2cd1eb960).
Review and whitelist legitimate backup schedules or disaster recovery processes to reduce false positives (False positive analysis).

Microsoft Management Console File Execution from Unusual Path

hello@craftedsignal.io — Wed, 03 Jul 2024 10:00:00 +0000

Attackers may exploit Microsoft Management Console (MMC) by executing .msc files from non-standard directories to bypass security controls. This technique can be used for initial access and execution. This detection focuses on identifying the execution of mmc.exe with .msc files from paths outside the typical system directories, which are generally considered trusted. By monitoring process executions and filtering out known legitimate paths, analysts can identify potentially malicious activity related to the misuse of MMC. The rule aims to detect deviations from standard administrative practices that could indicate unauthorized access or command execution via malicious or compromised .msc files. The detection logic specifically excludes executions from common directories like System32, SysWOW64, and Program Files.

Attack Chain

An attacker gains initial access to the system through an unspecified method.
The attacker places a malicious .msc file in an unusual or untrusted directory (e.g., C:\Users\Public).
The attacker executes mmc.exe with the malicious .msc file as an argument from the untrusted path.
mmc.exe processes the .msc file, potentially executing embedded commands or scripts.
The malicious .msc file performs unauthorized actions on the system, such as modifying system settings or executing arbitrary code.
The attacker leverages the execution context of mmc.exe to bypass security controls and escalate privileges.
The attacker may establish persistence by creating a scheduled task or modifying registry keys to execute the malicious .msc file automatically.

Impact

Successful exploitation can lead to unauthorized access, command execution, and privilege escalation, potentially compromising the entire system. While specific victim counts or sector targeting are not available, the technique is applicable across various Windows environments. The use of a trusted system binary like mmc.exe for malicious purposes can evade traditional security measures, making detection more challenging.

Recommendation

Implement the Sigma rule Microsoft Management Console File from Unusual Path to detect the execution of mmc.exe with .msc files from untrusted paths.
Enable process creation logging with command-line arguments to provide the necessary data for the Sigma rule to function effectively.
Investigate any alerts generated by the Sigma rule, focusing on the origin and content of the .msc file.
Consider implementing application control policies to restrict the execution of .msc files to authorized directories only.
Review and audit the use of MMC in the environment to identify any legitimate use cases that might trigger false positives.

DNS Global Query Block List Modified or Disabled

hello@craftedsignal.io — Wed, 03 Jul 2024 10:00:00 +0000

The DNS Global Query Block List (GQBL) is a Windows security feature designed to prevent the resolution of specific DNS names, commonly exploited in attacks like WPAD spoofing. Attackers who have obtained elevated privileges, such as DNSAdmin, can modify or disable this list to bypass security controls. This allows exploitation of hosts running WPAD with default settings. The modification of the GQBL can be used for privilege escalation and lateral movement within a network. This rule detects changes to the registry values associated with the GQBL, specifically “EnableGlobalQueryBlockList” and “GlobalQueryBlockList.” This activity could indicate an attacker attempting to weaken defenses to facilitate further malicious activities.

Attack Chain

An attacker gains initial access to a system, possibly through compromised credentials or exploiting a vulnerability.
The attacker escalates privileges to obtain DNSAdmin rights.
The attacker modifies the “EnableGlobalQueryBlockList” registry value to “0” or “0x00000000,” effectively disabling the GQBL.
Alternatively, the attacker modifies the “GlobalQueryBlockList” registry value to remove “wpad” from the list.
The attacker leverages the disabled GQBL to conduct WPAD spoofing attacks, redirecting network traffic to attacker-controlled servers.
The attacker captures user credentials transmitted during WPAD authentication.
The attacker uses the captured credentials to move laterally to other systems on the network.
The attacker achieves their final objective, such as data exfiltration or deploying ransomware.

Impact

Successful modification or disabling of the DNS Global Query Block List can lead to WPAD spoofing attacks, credential theft, lateral movement, and ultimately, complete compromise of the network. Attackers can leverage this technique to gain unauthorized access to sensitive data or systems. The impact includes potential data breaches, financial loss, and reputational damage.

Recommendation

Deploy the Sigma rule Registry Modification of DNS Global Query Block List to your SIEM to detect unauthorized changes to the GQBL configuration.
Enable Sysmon registry event logging to capture the necessary events for the Sigma rule to function (reference the logsource in the rule).
Review and restrict DNSAdmin privileges to only necessary accounts to minimize the attack surface (reference: Overview section).
Monitor network traffic for unusual DNS queries or WPAD-related activity, correlating with registry modification events (reference: Attack Chain step 5).
Regularly audit registry settings related to DNS configuration, including the GQBL, to identify unauthorized modifications (reference: Attack Chain steps 3 & 4).
Update security policies and procedures to include specific measures for monitoring and protecting the DNS Global Query Block List (reference: Impact section).

Suspicious Registry Hive Access via RegBack

hello@craftedsignal.io — Tue, 02 Jul 2024 12:00:00 +0000

This detection identifies suspicious attempts to access registry backup hives (SAM, SECURITY, and SYSTEM) located in the RegBack folder on Windows systems. These hives contain sensitive credential material, making them attractive targets for attackers seeking to compromise system security. The detection logic focuses on file access events, specifically successful file opens, while excluding known benign processes such as taskhostw.exe and various AV/EDR solutions (SophosScanCoordinator.exe, MsSense.exe, ccSvcHst.exe, etc.) to minimize false positives. The rule is designed to provide defenders with high-fidelity alerts when unauthorized access to these critical registry hives is detected. The scope includes any Windows system where endpoint file access logging is enabled.

Attack Chain

An attacker gains initial access to the system through various means.
The attacker attempts to access the SAM, SECURITY, or SYSTEM registry hives located in the C:\\Windows\\System32\\config\\RegBack\\ directory.
The attacker leverages a tool or script to open one or more of these registry hives. This could involve using built-in Windows utilities, scripting languages, or custom-developed tools.
If the attacker successfully opens the SAM and SYSTEM hives, they can extract user account credentials, including usernames, password hashes, and other sensitive information. The SECURITY hive is also useful.
The attacker may stage the registry hive files by copying them to a different location on the system for further analysis or exfiltration.
The attacker uses credential dumping tools (e.g., Mimikatz, secretsdump.py) or custom scripts to extract credentials from the staged registry hives.
The attacker leverages the extracted credentials to escalate privileges, move laterally within the network, or access sensitive data.
The final objective is typically to gain unauthorized access to critical systems, steal sensitive data, or establish long-term persistence within the compromised environment.

Impact

Successful exploitation of this technique can lead to the compromise of user account credentials, enabling attackers to escalate privileges, move laterally within the network, and gain unauthorized access to sensitive data. The impact can range from data breaches and financial losses to reputational damage and disruption of critical business operations. The number of victims can vary depending on the scope of the attacker’s activities and the security posture of the targeted organization. Sectors commonly targeted include finance, healthcare, government, and critical infrastructure.

Recommendation

Enable file access monitoring for the C:\\Windows\\System32\\config\\RegBack\\ directory to capture file open events.
Deploy the Sigma rule Registry Hive Access via RegBack to your SIEM and tune the exclusions based on your environment.
Monitor process_creation events for unusual processes accessing files in C:\\Windows\\System32\\config\\RegBack\\, using the rule Suspicious Process Accessing RegBack Hives.
Enable Sysmon process creation logging and file creation to activate the rules above.

Suspicious ScreenConnect Client Child Process Activity

hello@craftedsignal.io — Thu, 16 May 2024 16:10:00 +0000

This threat brief focuses on the detection of suspicious activities related to the ScreenConnect remote access tool. ScreenConnect is a legitimate remote support software, but adversaries can exploit it to execute unauthorized commands on compromised systems. This detection identifies suspicious child processes spawned by ScreenConnect client processes, such as ScreenConnect.ClientService.exe or ScreenConnect.WindowsClient.exe, which can indicate malicious activities such as spawning PowerShell or cmd.exe with unusual arguments. This activity can indicate potential abuse of remote access capabilities, leading to data exfiltration, command and control communication, or the establishment of persistence mechanisms. Recent exploitation of CVE-2024-1709 and CVE-2024-1708 have highlighted the risk associated with ScreenConnect exploitation.

Attack Chain

The attacker gains unauthorized access to a system with ScreenConnect installed. This could be achieved through exploiting vulnerabilities like CVE-2024-1709 and CVE-2024-1708, or through credential compromise.
The attacker uses ScreenConnect to connect to the compromised system remotely.
The attacker uses the ScreenConnect interface to execute commands on the remote system.
The attacker spawns a command interpreter, such as cmd.exe, using ScreenConnect. This process is a child process of the ScreenConnect client process.
The attacker uses cmd.exe to execute malicious commands, such as downloading and executing a malicious payload.
Alternatively, the attacker spawns powershell.exe with encoded commands or commands to download and execute malicious payloads from a remote server.
The attacker establishes persistence by creating a scheduled task using schtasks.exe or creates a new service using sc.exe.
The attacker uses tools like net.exe to modify user accounts or privileges to maintain access to the compromised system.

Impact

Successful exploitation can lead to unauthorized access to sensitive data, installation of malware, and establishment of persistent access to the compromised system. This can result in data theft, disruption of services, and further lateral movement within the network. The number of victims and specific sectors targeted varies depending on the attacker’s objectives, but the impact can be significant for organizations relying on ScreenConnect for remote support.

Recommendation

Deploy the Sigma rules provided in this brief to your SIEM to detect suspicious child processes spawned by ScreenConnect and tune for your environment.
Monitor process creation events for ScreenConnect client processes spawning suspicious child processes like powershell.exe, cmd.exe, net.exe, schtasks.exe, sc.exe, rundll32.exe, mshta.exe, certutil.exe, wscript.exe, cscript.exe, curl.exe, ssh.exe, scp.exe, wevtutil.exe, wget.exe, or wmic.exe as detailed in the Sigma rules.
Enable Sysmon process-creation logging to capture the necessary process execution data to activate the rules above.
Review and revoke any unauthorized user accounts or privileges that may have been created or modified using tools like net.exe as described in the attack chain.

Windows Parent Process PID Spoofing Detection

hello@craftedsignal.io — Thu, 09 May 2024 14:22:00 +0000

Parent process PID spoofing is a defense evasion technique where a process is created with a parent process ID (PPID) that differs from its actual creator. This can be used to circumvent process monitoring tools that rely on accurate parent-child relationships. Adversaries may leverage this technique to disguise malicious processes as legitimate system processes or to elevate privileges by associating malicious activities with trusted processes. The technique involves manipulating process creation APIs to set an arbitrary PPID. The Elastic Defend integration is designed to capture the necessary process telemetry to detect these discrepancies. This activity matters because it can allow attackers to hide their actions and persist on compromised systems undetected. The referenced Elastic detection rule was last updated on 2026/04/30, demonstrating continued relevance.

Attack Chain

Attacker gains initial access to the Windows system (e.g., via phishing or exploit).
Attacker executes a malicious process, such as a script or executable.
The malicious process uses API calls (e.g., CreateProcess, NtCreateProcessEx) to spawn a new process.
During process creation, the attacker modifies the PPID parameter to spoof a legitimate parent process.
The new process is launched with the spoofed PPID, appearing as a child of the chosen parent.
The spoofed process executes malicious code, potentially downloading additional payloads or establishing command and control.
The adversary leverages the trusted appearance of the spoofed process to evade detection by security tools.
The attacker achieves their final objective, such as data exfiltration, lateral movement, or persistence.

Impact

Successful parent process PID spoofing can allow attackers to evade detection and maintain persistence on a compromised system. This can lead to data breaches, system compromise, and financial loss. While the number of victims and specific sectors targeted are not specified in the provided source material, the technique is applicable across various sectors and organizations utilizing Windows-based systems. The lack of detection can lead to prolonged dwell time, increasing the potential for significant damage.

Recommendation

Deploy the Sigma rule Detect Suspicious Process Creation with PPID Spoofing to your SIEM to identify potential parent process PID spoofing attempts based on process telemetry data.
Enable and monitor process creation events with parent-child relationships using Elastic Defend to capture the necessary data for the provided rule.
Investigate alerts generated by the Sigma rule by examining the process tree and verifying the legitimacy of parent-child relationships as outlined in the rule’s description.
Configure endpoint detection and response (EDR) solutions to identify and block suspicious processes spawned by common exploitation vectors like Office applications and script hosts, as these are often associated with PPID spoofing.
Review and tune the Sigma rule, specifically the process.pe.original_file_name and process.executable lists, to match your organization’s baseline and reduce false positives.

GenAI Process Connection to Unusual Domain on macOS

hello@craftedsignal.io — Thu, 02 May 2024 14:22:30 +0000

This threat brief addresses the risk of GenAI tools on macOS connecting to unusual domains, which may indicate a compromised state. Attackers can exploit GenAI tools through prompt injection, malicious MCP (Model Context Protocol) servers, or poisoned plugins to establish command-and-control (C2) channels or exfiltrate sensitive data. Given the network access capabilities of AI agents, adversaries may manipulate them to beacon to external servers, download malicious payloads, or transmit harvested credentials and documents. The Elastic detection rule 9050506c-df6d-4bdf-bc82-fcad0ef1e8c1 focuses on identifying such anomalous network connections originating from a predefined list of GenAI processes, excluding known legitimate domains. The rule has been actively maintained since its creation on December 4, 2025, with its latest update on April 29, 2026.

Attack Chain

Adversary compromises a GenAI tool on a macOS system through prompt injection, malicious MCP servers, or poisoned plugins.
The compromised GenAI tool is configured to connect to an attacker-controlled domain for C2.
The GenAI process initiates a network connection attempt to the unusual domain using standard web protocols (HTTP/HTTPS).
The macOS system’s network stack resolves the attacker’s domain to its corresponding IP address.
The GenAI process sends data to the attacker-controlled domain, potentially including sensitive information.
The attacker uses the C2 channel to send commands to the compromised GenAI tool.
The GenAI tool executes the commands, potentially leading to further compromise or data exfiltration.

Impact

Compromised GenAI tools can lead to data exfiltration, unauthorized access to sensitive information, and the establishment of persistent C2 channels within an organization’s network. The impact ranges from the loss of intellectual property and customer data to the potential disruption of business operations. The risk is amplified if the GenAI tool has access to internal systems or sensitive data stores, allowing attackers to pivot and escalate their attacks.

Recommendation

Deploy the Sigma rule “GenAI Process Connecting to Unusual Domain” to your SIEM and tune for your environment (see rule below).
Enable process creation and network connection logging on macOS endpoints to collect the data required for the Sigma rule.
Investigate any alerts generated by the Sigma rule to determine the legitimacy of the domain and the GenAI process’s behavior.
Block any identified malicious domains at the network level (see query in the provided source).
Review the GenAI tool’s configuration for unauthorized MCP servers, plugins, or extensions that initiated the connection.
Regularly update the list of allowed domains in the Sigma rule’s filter to account for legitimate updates to GenAI tool infrastructure.

Suspicious Child Processes from Communication Applications

hello@craftedsignal.io — Wed, 31 Jan 2024 12:00:00 +0000

This detection rule focuses on identifying suspicious child processes of communication applications such as Slack, Cisco Webex, Microsoft Teams, Discord, WhatsApp, Zoom, and Thunderbird on Windows operating systems. Attackers may attempt to masquerade as legitimate processes or exploit vulnerabilities in these applications to execute malicious code. The rule monitors for the creation of child processes by these communication apps and checks if those child processes are unexpected, untrusted, or lack a valid code signature. This detection is crucial because successful exploitation can lead to unauthorized access, data exfiltration, or further compromise of the system. The rule has been actively maintained since August 2023, with updates as recent as May 2026, indicating its relevance and ongoing refinement to address emerging threats.

Attack Chain

User launches a communication application (e.g., Slack, Teams, Webex).
The communication application executes a vulnerable or compromised component.
The compromised component spawns a child process (e.g., powershell.exe, cmd.exe).
The child process executes a malicious command or script.
The script attempts to download additional payloads from an external source.
The payload executes, establishing persistence through registry modification or scheduled tasks.
The attacker gains remote access to the system.
Data exfiltration or lateral movement within the network occurs.

Impact

A successful attack can lead to the compromise of sensitive data, installation of malware, and potential lateral movement within the organization’s network. By exploiting communication applications, attackers can gain access to internal communications, confidential documents, and user credentials. The number of affected users and the extent of the damage depend on the compromised application and the attacker’s objectives. If successful, this attack may lead to significant financial loss, reputational damage, and disruption of business operations.

Recommendation

Deploy the Sigma rule Suspicious Communication App Child Process to your SIEM to detect anomalous child processes spawned by communication applications and tune for your environment.
Enable process creation logging with command line arguments in Windows to ensure that the Sigma rule has the necessary data to function correctly (logsource: process_creation, product: windows).
Investigate any alerts generated by the rule and review the command line arguments of the spawned processes to identify potential malicious activity.
Implement application whitelisting to restrict the execution of unauthorized applications and reduce the attack surface.
Ensure that all communication applications are updated to the latest versions to patch known vulnerabilities and reduce the risk of exploitation.
Examine the network activity of the affected system to identify any suspicious outbound connections that may indicate data exfiltration or communication with a command and control server, referencing the setup guide.

Network-Level Authentication (NLA) Disabled via Registry Modification

hello@craftedsignal.io — Wed, 31 Jan 2024 12:00:00 +0000

Network Level Authentication (NLA) is a security feature in Windows that requires users to authenticate before establishing a full RDP session, adding an extra layer of protection against unauthorized access. Attackers might attempt to disable NLA to gain access to the Windows sign-in screen without proper authentication. This tactic can facilitate the deployment of persistence mechanisms, such as leveraging Accessibility Features like Sticky Keys, or enable unauthorized remote access. This brief addresses the registry modifications associated with disabling NLA and provides detection strategies to identify such attempts. The references indicate that this technique is used in conjunction with other attacks for lateral movement within a compromised network.

Attack Chain

Initial access to the system is gained (potentially via compromised credentials or vulnerability exploitation).
The attacker elevates privileges to modify system-level settings.
The attacker modifies the registry key HKLM\SYSTEM\ControlSet*\Control\Terminal Server\WinStations\RDP-Tcp\UserAuthentication to disable NLA.
The UserAuthentication value is set to “0” or “0x00000000”.
The attacker attempts to establish an RDP connection to the compromised system.
Due to the disabled NLA, the attacker bypasses the initial authentication screen.
The attacker leverages accessibility features (e.g., Sticky Keys) for persistence or further exploitation.
The attacker gains unauthorized access to the system.

Impact

Successful disabling of NLA allows attackers to bypass authentication and gain unauthorized access to systems via RDP. This can lead to data theft, malware installation, or further lateral movement within the network. While the exact number of victims and sectors targeted are unspecified, the potential impact includes significant data breaches and system compromise.

Recommendation

Enable Sysmon process-creation and registry event logging to detect the registry modifications (Elastic Defend, Elastic Endgame, Microsoft Defender XDR, SentinelOne, Sysmon).
Deploy the Sigma rule provided to detect attempts to modify the UserAuthentication registry key (Sysmon Registry Events).
Review and harden RDP configurations across the environment to prevent unauthorized access (Microsoft documentation).
Monitor endpoint security policies to detect unauthorized registry modifications (Endpoint Security Policies).

Wireless Credential Dumping via Netsh

hello@craftedsignal.io — Tue, 30 Jan 2024 12:00:00 +0000

Attackers often target wireless credentials to gain unauthorized network access. This involves using the legitimate Windows command-line tool netsh.exe to extract Wi-Fi passwords stored on a compromised system. By leveraging netsh, attackers can bypass traditional security measures and retrieve sensitive information without deploying custom malware. The technique involves specific command-line arguments that instruct netsh to display wireless keys in cleartext, exposing the network passwords. Defenders must monitor netsh command-line activity to identify potential credential access attempts. This activity can lead to lateral movement within the network.

Attack Chain

The attacker gains initial access to a Windows system (e.g., via phishing or exploiting a software vulnerability).
The attacker executes netsh.exe with specific arguments to list available wireless profiles.
The attacker identifies a target wireless profile from the list.
The attacker executes netsh.exe again, this time specifying the target profile and requesting the key to be displayed in cleartext using the key=clear argument.
Netsh.exe retrieves the Wi-Fi password from the Windows Wireless LAN service.
The password is displayed in the command output, which the attacker captures.
The attacker uses the obtained Wi-Fi password to connect to the wireless network.
The attacker can now perform lateral movement and access internal resources.

Impact

Successful credential dumping allows attackers to gain unauthorized access to wireless networks. This can lead to lateral movement within the organization’s network, access to sensitive data, and further compromise of systems and resources. The impact includes potential data breaches, financial losses, and reputational damage. This technique allows attackers to bypass traditional network access controls.

Recommendation

Deploy the Sigma rule Detect Wireless Credential Dumping via Netsh to identify suspicious netsh.exe commands in your environment.
Enable Sysmon process creation logging to capture the netsh.exe command-line arguments.
Investigate any alerts triggered by the Sigma rule, focusing on the process lineage and user context as outlined in the “Triage and analysis” section of the source.
Implement strong password policies for Wi-Fi networks, including the use of WPA2 or WPA3 encryption.
Review and restrict the use of netsh.exe on systems where it is not required, using application control solutions.
Monitor for related alerts indicating lateral movement, staging, remote access, or persistence, as mentioned in the “Triage and analysis” section of the source.

Windows Console History Clearing

hello@craftedsignal.io — Tue, 30 Jan 2024 12:00:00 +0000

Attackers can try to cover their tracks by clearing the PowerShell console history on Windows systems. PowerShell offers multiple ways to log commands, including the built-in history and the command history managed by the PSReadLine module. This activity is often part of post-compromise behavior aimed at evading detection and forensic analysis. This rule detects the execution of specific commands that clear the built-in PowerShell logs or delete the ConsoleHost_history.txt file. The rule focuses on PowerShell activity and covers scenarios where commands like Clear-History, Remove-Item, rm, and Set-PSReadlineOption are used to manipulate command history.

Attack Chain

Initial access is gained through an unspecified method, potentially exploiting a vulnerability or using stolen credentials.
The attacker executes PowerShell (powershell.exe, pwsh.exe, or powershell_ise.exe) to perform reconnaissance and other malicious activities.
The attacker attempts to clear the PowerShell command history using the Clear-History cmdlet.
Alternatively, the attacker attempts to remove the ConsoleHost_history.txt file using Remove-Item or rm, which stores the PSReadLine command history.
Another method involves using the Set-PSReadlineOption cmdlet with the SaveNothing parameter to prevent the saving of future command history.
The attacker may leverage other tools and techniques to further obscure their activities and maintain persistence on the compromised system.
The attacker attempts to move laterally to other systems within the network to increase their impact.
The final objective is data exfiltration, deployment of ransomware, or other malicious activities, all while attempting to evade detection by clearing logs and command history.

Impact

Successful clearing of console history hinders forensic investigations and incident response efforts. If command history is cleared, administrators will have difficulty reconstructing the attacker’s actions and identifying the extent of the compromise. This can lead to prolonged incident response times, increased damage, and potential for further exploitation of the compromised systems.

Recommendation

Deploy the Sigma rule Detect Clearing PowerShell History to your SIEM to detect the use of Clear-History cmdlet, potentially indicating an attempt to remove command history.
Deploy the Sigma rule Detect Removal of PowerShell History File to detect the use of Remove-Item or rm command against the PowerShell history file.
Enable PowerShell logging and auditing policies to ensure adequate visibility into PowerShell activity as described in the setup instructions to improve detection capabilities.

System File Ownership Change for Defense Evasion

hello@craftedsignal.io — Tue, 30 Jan 2024 12:00:00 +0000

Attackers often attempt to modify file or directory ownership to bypass access controls and gain unauthorized access to sensitive data or system resources. This involves altering permissions associated with critical files or directories, granting broader access to accounts under attacker control or resetting permissions to default values which might be more permissive. This defense evasion technique can be used to establish persistence, escalate privileges, or exfiltrate data without triggering standard security alerts. The common tools used include icacls.exe and takeown.exe, typically targeting files within the C:\Windows\ directory.

Attack Chain

Initial access is achieved through an existing compromised account or vulnerability.
The attacker uses takeown.exe /f to take ownership of a target file or directory.
The attacker uses icacls.exe /reset to reset the ACL of the file or directory.
Alternatively, the attacker uses icacls.exe /grant Everyone:F to grant full control to everyone, weakening security.
The attacker modifies the contents of the file, such as injecting malicious code or configuration changes.
The attacker leverages the modified file for persistence, such as a modified system DLL loaded at boot.
The system executes the malicious code when the compromised file is accessed or executed.
The attacker achieves their objective, such as maintaining persistence, escalating privileges, or executing arbitrary commands.

Impact

Compromising file and directory permissions can lead to significant security breaches. Successful attacks can allow unauthorized access to sensitive data, system instability, or the execution of malicious code with elevated privileges. This can affect any Windows environment where file permissions are improperly managed, with potential for widespread system compromise and data exfiltration. The impact is most severe on systems containing sensitive data or critical infrastructure components.

Recommendation

Monitor process execution for icacls.exe and takeown.exe with suspicious arguments targeting system files (e.g., C:\Windows\*) to detect potential permission modification attempts using the provided Sigma rules.
Enable Windows Security Auditing for file system changes to capture events related to permission modifications and ownership changes.
Deploy the provided Sigma rules to your SIEM and tune for your environment, specifically focusing on processes modifying permissions on files within the C:\Windows\ directory.
Investigate any alerts triggered by the Sigma rules, focusing on the process execution chain and the target files being modified.

Potential Account Takeover via Mixed Logon Types

hello@craftedsignal.io — Tue, 30 Jan 2024 12:00:00 +0000

This detection identifies a user account, often a service account, that typically logs in with high volume using a specific logon type but suddenly shows successful logons using a different logon type with low count. This anomalous behavior may signal account takeover or the use of stolen credentials from a new context, such as an interactive or network logon when only batch/service logons were expected. This is critical for defenders as compromised service accounts can lead to privilege escalation and lateral movement within the network. The detection logic is based on Windows Security Event Logs (Event ID 4624).

Attack Chain

Initial Access: An attacker gains access to a valid user account’s credentials.
Credential Compromise: The attacker compromises a service account’s credentials.
Lateral Movement: The attacker attempts to move laterally within the network using the compromised credentials.
Authentication: The attacker uses the stolen credentials to authenticate to a system using a previously unseen logon type.
Privilege Escalation: The attacker leverages the service account permissions to escalate privileges.
Resource Access: The attacker accesses sensitive resources using the compromised account.
Data Exfiltration: The attacker exfiltrates sensitive data.

Impact

A successful account takeover can lead to significant damage, including data breaches, privilege escalation, and lateral movement within the network. If a service account is compromised, attackers can gain access to sensitive systems and data, potentially affecting hundreds or thousands of users or systems. The shift in logon types often goes unnoticed, enabling attackers to maintain persistence.

Recommendation

Enable Audit Logon to generate the necessary events for detection (reference: Setup section in content).
Deploy the Sigma rule “Potential Account Takeover - Mixed Logon Types” to your SIEM and tune the thresholds (max_logon, min_logon) based on your environment.
Investigate any alerts generated by the Sigma rule by confirming with the account owner or service owner whether the additional logon type is expected (reference: Investigation Guide section).
Implement multi-factor authentication (MFA) for all user accounts, including service accounts, to mitigate the risk of credential compromise.

Netsh Helper DLL Persistence

hello@craftedsignal.io — Tue, 30 Jan 2024 12:00:00 +0000

The netsh.exe utility in Windows supports the addition of Helper DLLs to extend its functionality. An attacker can abuse this mechanism to establish persistence by adding a malicious DLL. When netsh.exe is executed, the malicious DLL is loaded and executed, allowing the attacker to run arbitrary code with the privileges of the user or process that initiated netsh.exe. This can be done by administrators or scheduled tasks, making it a stealthy and effective persistence technique. The registry key targeted by this technique is HKLM\Software\Microsoft\netsh\.

Attack Chain

Attacker gains initial access to the target system through unspecified means.
Attacker creates a malicious DLL to be used as a Netsh Helper DLL.
Attacker modifies the Windows Registry to add the malicious DLL as a Netsh Helper DLL under HKLM\Software\Microsoft\netsh\.
The system administrator or a scheduled task executes netsh.exe.
netsh.exe loads and executes the malicious DLL, granting the attacker code execution.
The malicious DLL performs its intended actions, such as establishing a reverse shell or deploying additional malware.
The attacker maintains persistence on the system through the malicious Netsh Helper DLL.

Impact

Successful exploitation allows attackers to establish persistent access to a compromised system. This can lead to data theft, system compromise, and further malicious activities. While the risk score is low, the persistence mechanism can allow attackers to maintain a foothold for extended periods, increasing the potential for significant damage.

Recommendation

Monitor registry modifications under the HKLM\Software\Microsoft\netsh\ path for suspicious DLL additions using the “Netsh Helper DLL Registry Modification” Sigma rule.
Enable Sysmon registry event logging to collect the necessary data for the Sigma rule.
Investigate any alerts generated by the Sigma rule by reviewing the DLL file properties, timestamps, and related processes.

Expired or Revoked Driver Loaded

hello@craftedsignal.io — Tue, 30 Jan 2024 12:00:00 +0000

Attackers may attempt to load expired or revoked drivers to bypass security controls and execute code in kernel mode. This technique can be used for privilege escalation or defense evasion. The loading of such drivers, especially by the System process (PID 4), is a strong indicator of malicious activity. The referenced Elastic detection rule, last updated on May 4, 2026, aims to identify such attempts by monitoring the code signature status of loaded drivers on Windows systems. The rule focuses on identifying drivers with “errorExpired” or “errorRevoked” status, providing defenders with a means to detect potentially malicious activity related to driver manipulation.

Attack Chain

The attacker gains initial access to the system (e.g., through social engineering or exploiting a vulnerability).
The attacker obtains or creates a malicious driver signed with an expired or revoked certificate, or an outdated driver with known vulnerabilities.
The attacker attempts to load the malicious driver onto the targeted Windows system.
The Windows operating system attempts to verify the driver’s code signature.
The code signature verification fails due to the driver’s expired or revoked certificate.
Despite the signature failure, the attacker attempts to force the system to load the driver, possibly by exploiting a bypass or misconfiguration.
The driver is loaded into kernel mode, granting the attacker elevated privileges and control over the system.
The attacker leverages the compromised driver to execute malicious code, escalate privileges, or evade security defenses.

Impact

A successful attack involving the loading of an expired or revoked driver can lead to complete system compromise. An attacker could gain unauthorized access to sensitive data, install malware, or disrupt critical services. The consequences range from data breaches to system instability and loss of integrity. The Elastic detection rule aims to detect these attempts before significant damage can occur.

Recommendation

Deploy the Sigma rule provided below to detect instances of expired or revoked drivers being loaded (reference: Sigma rule).
Investigate any alerts generated by the Sigma rule to determine the legitimacy and potential risk associated with the loaded driver (reference: Sigma rule).
Enable endpoint detection and response (EDR) solutions like Elastic Defend to enhance visibility into driver loading events (reference: Elastic Defend).
Regularly update driver blocklists to prevent the loading of known malicious or vulnerable drivers (reference: References URL).
Monitor process creation events for unusual driver loading activity, particularly by the System process (PID 4) (reference: Sigma rule, process.pid == 4).

MsXsl.exe Network Connection for Defense Evasion

hello@craftedsignal.io — Tue, 30 Jan 2024 10:00:00 +0000

MsXsl.exe is a Windows utility designed to transform XML data using XSLT stylesheets. Adversaries are known to abuse this utility to execute malicious scripts, bypassing application control and other security measures. This behavior is often used as a defense evasion technique to download or execute malicious payloads. This activity has been observed since at least March 2020. The abuse of msxsl.exe allows attackers to establish command and control or exfiltrate sensitive data without being easily detected, as the tool is a signed Microsoft binary. This matters for defenders because it highlights the need to monitor legitimate system utilities for anomalous behavior, specifically network connections to external IP addresses.

Attack Chain

An attacker gains initial access to a Windows system through unspecified means.
The attacker leverages msxsl.exe to execute a malicious script.
Msxsl.exe initiates a network connection to an external IP address.
The script downloads a malicious payload from the external server.
The downloaded payload is executed on the compromised system.
The attacker establishes a command and control channel through the network connection.
The attacker performs data exfiltration via the established C2 channel.

Impact

Compromised systems can be used for further malicious activities, including data theft, lateral movement, and deployment of additional malware. Successful exploitation can lead to sensitive data exfiltration, disruption of services, or complete system compromise. The low risk score does not represent impact, but instead reflects that the behavior is not always malicious, and may be a feature of normal software operation.

Recommendation

Enable Sysmon network connection logging to monitor msxsl.exe network activity.
Deploy the Sigma rule “Network Connection via MsXsl” to your SIEM and tune for your environment to detect suspicious network connections originating from msxsl.exe.
Investigate any alerts generated by the Sigma rule, focusing on the destination IP address and the parent process of msxsl.exe.
Whitelist legitimate uses of msxsl.exe in your environment based on known good processes or applications to reduce false positives.

VaultCmd Usage for Listing Windows Credentials

hello@craftedsignal.io — Mon, 29 Jan 2024 12:00:00 +0000

Attackers may abuse the Windows Credential Manager to list or dump credentials stored within. This allows for the exfiltration of saved usernames and passwords. The tool vaultcmd.exe can be used to interact with the Credential Manager and list the stored credentials. This activity is often performed in preparation for lateral movement within a compromised network. This detection focuses on identifying instances where vaultcmd.exe is executed with the /list* argument, indicating an attempt to enumerate stored credentials. The detection rule is designed to identify abuse of vaultcmd for credential access, enabling defenders to detect unauthorized credential access activities.

Attack Chain

An attacker gains initial access to a Windows system through various means (e.g., phishing, exploitation of a vulnerability).
The attacker executes vaultcmd.exe with the /list argument to enumerate the credentials stored in the Windows Credential Manager.
The vaultcmd.exe process accesses the Credential Manager to retrieve the list of saved credentials.
The output of vaultcmd.exe (the list of credentials) is captured or redirected to a file for later exfiltration.
The attacker parses the output to identify valuable credentials, such as domain administrator accounts or service accounts.
The attacker uses the acquired credentials to authenticate to other systems on the network (lateral movement).
The attacker elevates privileges on the target systems.
The final objective is achieved, such as data theft or ransomware deployment.

Impact

Successful execution of this attack chain can lead to unauthorized access to sensitive resources, lateral movement within the network, and ultimately, data theft, system compromise, or ransomware deployment. A compromised user account can grant the attacker access to internal systems, confidential data, and critical infrastructure. If the attacker gains domain administrator credentials, they can compromise the entire Windows domain.

Recommendation

Monitor process execution events for instances of vaultcmd.exe being executed with the /list* argument (Data Source: Windows Security Event Logs, Sysmon, Microsoft Defender XDR, SentinelOne, Crowdstrike).
Deploy the Sigma rule “Detect VaultCmd Credential Listing” to your SIEM to identify potential credential access attempts.
Investigate any identified instances of vaultcmd.exe being executed with the /list* argument to determine the legitimacy of the activity.
Review and update endpoint protection configurations to ensure that similar threats are detected and blocked in the future.

Suspicious Managed Code Hosting Process

hello@craftedsignal.io — Mon, 29 Jan 2024 12:00:00 +0000

This detection identifies suspicious managed code hosting processes on Windows systems. Attackers may leverage processes like wscript.exe, cscript.exe, mshta.exe, wmic.exe, svchost.exe, dllhost.exe, cmstp.exe, and regsvr32.exe to execute malicious code, often bypassing traditional security controls. These processes can be abused to load and execute .NET assemblies or other managed code components. The detection focuses on identifying unusual file creation events associated with these processes which could indicate an attacker is attempting to leverage these processes for malicious purposes. This activity might be indicative of code injection, defense evasion, or other suspicious code execution techniques. The rule uses EQL to search for file events associated with specific processes.

Attack Chain

An attacker gains initial access to the system through a phishing email or compromised software.
The attacker uses a LOLBin such as mshta.exe or regsvr32.exe to bypass application control.
The LOLBin executes a malicious script or loads a malicious DLL from a user-writable location.
The malicious script or DLL performs reconnaissance activities, such as gathering system information or enumerating network resources.
The attacker then attempts to escalate privileges by exploiting a vulnerability or using stolen credentials.
The attacker uses the compromised process to download and execute additional malware.
The malware establishes persistence on the system through scheduled tasks or registry modifications.
The attacker performs lateral movement within the network, compromising additional systems and exfiltrating sensitive data.

Impact

Successful exploitation can lead to arbitrary code execution, allowing attackers to compromise systems, steal sensitive data, and establish persistence. The use of LOLBins can bypass application control, making detection more challenging. Depending on the scope of the attack, this could result in significant financial losses, reputational damage, and disruption of business operations. This is a high-severity finding due to the potential for attackers to gain full control over affected systems.

Recommendation

Enable Sysmon file creation logging (Event ID 11) to collect the necessary data for this detection.
Deploy the Sigma rule “Suspicious Managed Code Hosting Process” to your SIEM and tune for your environment.
Investigate any alerts generated by this rule, focusing on the file paths, process command lines, and parent processes involved.
Monitor for unexpected file creation events associated with processes like wscript.exe, cscript.exe, and mshta.exe in user-writable directories.
Implement application control policies to restrict the execution of LOLBins and other potentially malicious processes.
Correlate the detection with other security events to identify related malicious activity.

Program Files Directory Masquerading

hello@craftedsignal.io — Mon, 29 Jan 2024 12:00:00 +0000

This detection identifies processes executing from directories that masquerade as the legitimate Windows Program Files directories. Attackers may create directories with similar names (e.g., “C:\Program Files Bad” or “C:\Program Files(x86) Malicious”) to host and execute malicious executables, bypassing security measures that trust the standard Program Files locations. This technique is particularly effective when combined with low-privilege accounts, as it allows attackers to evade detections that whitelist only the standard, trusted Program Files paths. The timeframe for this rule is the last 9 months. This matters to defenders because it highlights a common tactic used to bypass established trust relationships within the Windows operating system, requiring more granular inspection of process execution paths.

Attack Chain

An attacker gains initial access to a system, potentially through phishing or exploiting a vulnerability.
The attacker creates a new directory that mimics the “Program Files” or “Program Files (x86)” directory (e.g., “C:\Program Files Bad”).
The attacker copies or downloads malicious executable files into the newly created masquerading directory.
The attacker executes the malicious executable from the masquerading directory.
The operating system loads the executable and begins its execution, potentially bypassing any allowlisting rules that only check the standard “Program Files” locations.
The malicious executable performs its intended actions, such as installing malware, establishing persistence, or exfiltrating data.
The attacker leverages the compromised system to move laterally within the network, repeating the masquerading technique on other systems.

Impact

A successful attack can lead to malware infection, data theft, or complete system compromise. The impact is significant, as it undermines the trust placed in the “Program Files” directory and allows attackers to operate undetected for extended periods. While no specific victim counts are given, the technique is broadly applicable to any Windows environment, especially those relying on simple path-based allowlisting for security.

Recommendation

Deploy the Sigma rule Program Files Directory Masquerading Detection to your SIEM to detect suspicious process executions from masquerading directories.
Enable Sysmon process creation logging (Event ID 1) to collect the necessary process execution data for the Sigma rule.
Regularly review and update allowlisting rules to include more specific criteria beyond just the “Program Files” directory, such as file hashes or digital signatures.
Investigate any alerts generated by the Sigma rule, focusing on the parent processes and user accounts associated with the suspicious executions.
Monitor file creation events in the root directory to detect suspicious folders being created (file_event category)

Potential Remote Install via MsiExec

hello@craftedsignal.io — Mon, 29 Jan 2024 10:00:00 +0000

Adversaries may abuse Windows Installer (msiexec.exe) to perform remote installations of malicious payloads. This technique is used for initial access, defense evasion, and execution of arbitrary code. The detection rule identifies attempts to install a file from a remote server using MsiExec. The rule looks for msiexec.exe processes running with arguments such as -i, /i, -p, or /p, indicative of remote installations, and executed from suspicious parent processes like sihost.exe, explorer.exe, cmd.exe, wscript.exe, mshta.exe, powershell.exe, wmiprvse.exe, pcalua.exe, forfiles.exe, and conhost.exe. The rule includes exceptions to reduce false positives from legitimate software installations, specifically excluding command lines containing --set-server, UPGRADEADD, --url, USESERVERCONFIG, RCTENTERPRISESERVER, app.ninjarmm.com, zoom.us/client, SUPPORTSERVERSTSURI, START_URL, AUTOCONFIG, awscli.amazonaws.com, */i \"C:*, and */i C:\\*. This technique can lead to complete system compromise and data exfiltration.

Attack Chain

An attacker gains initial access via an unspecified method (e.g., phishing, exploit).
The attacker uses a script or command-line interpreter (e.g., cmd.exe, powershell.exe) to initiate the msiexec.exe process.
The msiexec.exe process is launched with arguments that specify a remote MSI package (-i, /i, -p, /p) and enable silent installation (/qn, -qn, -q, /q, /quiet).
The msiexec.exe process downloads the MSI package from a remote server over HTTP or HTTPS.
msiexec.exe executes the downloaded MSI package, which may contain malicious payloads.
The malicious payload executes, potentially performing actions such as installing malware, establishing persistence, or escalating privileges.
The attacker gains control over the compromised system.
The attacker performs further actions, such as data exfiltration or lateral movement.

Impact

Successful exploitation can lead to arbitrary code execution, allowing attackers to install malware, steal sensitive data, or disrupt system operations. A compromised system can be used as a pivot point to access other systems on the network. The impact can range from data breaches and financial losses to reputational damage and disruption of critical services. The number of potential victims depends on the scope of the initial access and the attacker’s objectives.

Recommendation

Deploy the provided Sigma rule to your SIEM to detect suspicious MsiExec invocations with remote payloads.
Enable Sysmon process creation logging (Event ID 1) to ensure the required data is available for the Sigma rule.
Investigate any alerts generated by the Sigma rule, focusing on the parent process, command-line arguments, and network connections associated with the msiexec.exe process.
Monitor process execution events for child processes spawned by msiexec.exe for anomalous activity.
Implement application control policies to restrict the execution of msiexec.exe to authorized users and processes only.

Potential Exploitation of an Unquoted Service Path Vulnerability

hello@craftedsignal.io — Mon, 29 Jan 2024 10:00:00 +0000

Unquoted service paths in Windows can be exploited to escalate privileges. When a service path lacks quotes, Windows may execute a malicious executable placed in a higher-level directory. This detection rule identifies suspicious processes starting from common unquoted paths, like “C:\Program.exe” or executables within “C:\Program Files (x86)\” or “C:\Program Files\”, signaling potential exploitation attempts. The rule aims to detect early stages of privilege escalation threats. This rule is designed for data generated by Elastic Defend, Microsoft Defender XDR, SentinelOne Cloud Funnel, Sysmon, Windows Security Event Logs, and Crowdstrike.

Attack Chain

An attacker identifies a service running with an unquoted path, such as “C:\Program Files\Unquoted Path Service\Common\Service.exe”.
The attacker places a malicious executable named “Program.exe” in “C:"
The operating system attempts to start the service “C:\Program Files\Unquoted Path Service\Common\Service.exe”.
Due to the unquoted path, the OS incorrectly parses the path and first attempts to execute “C:\Program.exe”.
The malicious “Program.exe” executes with the privileges of the service account.
The malicious executable performs actions to escalate privileges, such as adding a user to the local administrators group.
The attacker gains elevated access to the system.

Impact

Successful exploitation of an unquoted service path vulnerability can lead to complete system compromise, as the attacker gains the privileges of the service account. This can allow the attacker to install programs, view, change, or delete data, or create new accounts with full user rights. The impact is high, potentially leading to a loss of confidentiality, integrity, and availability of the affected system.

Recommendation

Review process executable paths to confirm if they match the patterns specified in the rule query, such as “?:\Program.exe” or executables within “C:\Program Files (x86)\” or “C:\Program Files\”.
Deploy the Sigma rule “Potential Exploitation of an Unquoted Service Path Vulnerability” to your SIEM and tune for your environment.
Enable Sysmon process-creation logging with Event ID 1 to activate the Sigma rules above.
Conduct a thorough review of service configurations to identify and correct any unquoted service paths as part of remediation steps.

AMSI Enable Registry Key Modification for Defense Evasion

hello@craftedsignal.io — Sat, 27 Jan 2024 18:23:00 +0000

Attackers can disable the Antimalware Scan Interface (AMSI) to evade detection by modifying the AmsiEnable registry key. This technique is commonly employed to execute malicious scripts without triggering security warnings or blocks. The AMSI, a Windows feature, allows applications and services to request the scanning of potentially malicious content (e.g., PowerShell scripts, JScript) before execution. By setting the AmsiEnable value to 0, an attacker can disable AMSI for the current user, effectively bypassing real-time script scanning. This action is often a precursor to deploying further malicious payloads or establishing persistence on a compromised system. This behavior has been observed since at least 2019 and continues to be a relevant defense evasion technique.

Attack Chain

An attacker gains initial access to the target system, possibly through phishing or exploiting a vulnerability.
The attacker executes a script or binary that attempts to modify the AmsiEnable registry key.
The script or binary uses reg.exe, PowerShell, or another tool to set the AmsiEnable registry value to 0. The registry key location is typically HKEY_USERS\\Software\Microsoft\Windows Script\Settings\AmsiEnable.
After successfully disabling AMSI, the attacker proceeds to execute malicious scripts or code. These scripts may use powershell.exe, wscript.exe, or cscript.exe.
The malicious scripts download and execute additional payloads, such as malware or remote access tools (RATs).
The attacker performs lateral movement within the network using the compromised system as a pivot.
The attacker attempts to establish persistence, ensuring continued access to the system even after reboots.
The attacker exfiltrates sensitive data or deploys ransomware to achieve their objectives.

Impact

Successful modification of the AmsiEnable registry key allows attackers to execute malicious scripts without triggering AMSI alerts, leading to potential malware infections, data breaches, and system compromise. Disabling AMSI significantly reduces the effectiveness of endpoint security solutions, making the system more vulnerable to attack. The impact can range from individual workstation compromise to widespread network infections, depending on the attacker’s objectives and the organization’s security posture.

Recommendation

Deploy the Sigma rule Detect AmsiEnable Registry Modification via Registry Events to your SIEM to detect modifications to the AmsiEnable registry key.
Enable Sysmon registry event logging to provide the necessary data for the Sigma rule to function.
Monitor process creation events for processes modifying registry keys, especially reg.exe and PowerShell, using the rule Detect AmsiEnable Registry Modification via Process Creation.
Investigate any alerts generated by these rules promptly to determine if the activity is malicious or legitimate.
Implement application control policies to restrict the execution of unsigned or untrusted scripts and binaries.
Harden systems by restricting user permissions to modify critical registry keys.

Microsoft Office 'Office Test' Registry Persistence Abuse

hello@craftedsignal.io — Sat, 27 Jan 2024 17:30:00 +0000

The “Office Test” registry key, located under HKCU\Software\Microsoft\Office Test\Special\Perf, is a legitimate feature that allows specifying a DLL to be executed every time an MS Office application is started. Attackers can abuse this functionality by modifying the registry to point to a malicious DLL, achieving persistence on a compromised host. This allows for continued malicious activity even after a system restart or user logout. Elastic has published a rule to detect this behavior. The modification of this registry key, excluding deletions, is a strong indicator of potential abuse, and can be detected via endpoint detection and response (EDR) solutions as well as traditional Sysmon logging.

Attack Chain

An attacker gains initial access to a system, often through phishing or exploiting a vulnerability.
The attacker establishes a foothold and escalates privileges to make necessary registry modifications.
The attacker modifies the HKCU\Software\Microsoft\Office Test\Special\Perf registry key, adding a new entry or modifying an existing one to point to a malicious DLL.
The attacker ensures the malicious DLL is present on the system, either by dropping it directly or using existing system tools to download it.
A user launches a Microsoft Office application (e.g., Word, Excel, PowerPoint).
The Office application loads the DLL specified in the “Office Test” registry key during startup.
The malicious DLL executes its payload, which could include establishing a reverse shell, installing malware, or exfiltrating data.
The attacker maintains persistence, allowing them to regain access to the system each time an Office application is started.

Impact

Successful exploitation allows attackers to maintain persistent access to a compromised system. The injected DLL can be used to execute arbitrary code, potentially leading to data theft, malware installation, or further compromise of the network. The relatively low risk score suggests a common technique, but the potential for persistent access makes it a significant threat.

Recommendation

Deploy the provided Sigma rule to your SIEM and tune for your environment to detect unauthorized modifications to the “Office Test” registry key (HKCU\Software\Microsoft\Office Test\Special\Perf\*).
Enable Sysmon Registry event logging to capture registry modifications and activate the Sigma rule above.
Monitor process execution logs for Office applications to detect if a suspicious DLL has been loaded or executed, as described in the investigation guide.
Implement enhanced monitoring and alerting for similar registry modifications across the network, as described in the remediation steps.

Suspicious Alternate Data Stream (ADS) File Creation

hello@craftedsignal.io — Fri, 26 Jan 2024 18:00:00 +0000

This detection focuses on identifying the creation of Alternate Data Streams (ADS) on Windows systems, a technique often employed by adversaries to conceal malicious code or data within seemingly benign files. Attackers leverage scripting engines and command interpreters to write ADS to various file types, including executables, documents, and media files. This activity is uncommon in legitimate workflows, making it a valuable indicator of potential compromise. The rule is designed to trigger on file creation events where the process creating the file is a known script or command interpreter (cmd.exe, powershell.exe, etc.) and the target file has a suspicious extension. The detection excludes common legitimate ADS usage patterns. This technique is used for defense evasion, allowing malware to persist without being easily detected by traditional security measures.

Attack Chain

An attacker gains initial access to a Windows system (e.g., through phishing or exploiting a vulnerability).
The attacker uses a command interpreter (cmd.exe, powershell.exe, etc.) or scripting engine (wscript.exe, cscript.exe) to execute malicious code.
The malicious code creates an Alternate Data Stream (ADS) on a targeted file (e.g., an executable, document, or image). The targeted file’s extension could be pdf, dll, exe, dat, etc.
The attacker hides malicious code or data within the ADS, making it less visible to standard file system scans and security tools. The ADS is written to a file path using the C:\\*:\* syntax.
The attacker may rename or clean up any staging files to further conceal their activity.
The attacker can then execute the hidden code within the ADS, or use the ADS to store configuration data for later use.
The attacker maintains persistence by using the ADS to store and execute malicious code, bypassing typical file-based security measures.
The ultimate goal is to maintain unauthorized access to the system, potentially leading to data exfiltration, lateral movement, or other malicious activities.

Impact

Successful exploitation allows attackers to hide malicious code within legitimate files, evading detection by traditional security measures. This can lead to prolonged persistence on compromised systems, enabling data theft, ransomware deployment, or other malicious activities. While the specific number of victims is unknown, this technique is broadly applicable across Windows environments, potentially affecting a wide range of organizations.

Recommendation

Deploy the Sigma rule Suspicious ADS File Creation via Cmd to detect ADS creation events initiated by cmd.exe.
Deploy the Sigma rule Suspicious ADS File Creation via PowerShell to detect ADS creation events initiated by powershell.exe.
Enable Sysmon Event ID 15 (FileCreateStreamHash) to provide detailed information about ADS creation events, as referenced in the rule’s setup instructions.
Investigate any alerts generated by these rules, focusing on the file paths, creating processes, and command-line arguments involved, as detailed in the rule’s triage and analysis notes.

System Shells Launched via Windows Services

hello@craftedsignal.io — Fri, 26 Jan 2024 12:00:00 +0000

Attackers may configure existing Windows services or create new ones to execute system shells, in order to elevate their privileges from administrator to SYSTEM. This tactic is used to gain SYSTEM permissions and establish persistence. The detection rule focuses on identifying instances where services.exe is the parent process of a command shell (cmd.exe, powershell.exe, pwsh.exe, powershell_ise.exe), indicating that a service is being abused to run a shell. The rule is designed to work with data from Elastic Defend, CrowdStrike, Microsoft Defender XDR, SentinelOne Cloud Funnel, Sysmon, and Windows Security Event Logs.

Attack Chain

Attacker gains initial access to the system with administrator privileges.
Attacker identifies a legitimate service or creates a new service to abuse for privilege escalation.
Attacker modifies the service configuration to execute a command shell (cmd.exe, powershell.exe, pwsh.exe, or powershell_ise.exe). This may involve modifying the service’s executable path or adding command-line arguments.
The system’s Service Control Manager (SCM) starts the service.
services.exe spawns the configured command shell process.
The command shell executes with SYSTEM privileges.
Attacker uses the SYSTEM shell to perform malicious activities, such as installing malware, accessing sensitive data, or creating new user accounts.
The service continues to run, providing persistent access to the system.

Impact

Successful exploitation leads to privilege escalation to SYSTEM, granting the attacker complete control over the compromised system. This can result in data theft, malware installation, or further lateral movement within the network. The rule has a risk score of 47 and is categorized as medium severity.

Recommendation

Deploy the Sigma rule System Shells via Services to detect the execution of command shells spawned by services.exe within your SIEM environment, and tune for your environment.
Investigate any process creation events where services.exe is the parent process of cmd.exe, powershell.exe, pwsh.exe, or powershell_ise.exe using the investigation guide provided in the content section.
Review service creation and modification events in Windows Event Logs (Event IDs 4697 and 7045) for suspicious entries.
Enable Sysmon process creation logging (Event ID 1) to capture detailed process information.
Utilize osquery to retrieve detailed service information to identify potentially malicious services. Reference queries $osquery_0, $osquery_1, and $osquery_2 in the investigation guide.

LSASS Credential Dumping via Windows Error Reporting (WER) Abuse

hello@craftedsignal.io — Fri, 26 Jan 2024 12:00:00 +0000

The LSASS Shtinkering attack involves abusing Windows Error Reporting (WER) to dump the memory of the LSASS process, which contains sensitive credentials. By enabling full user-mode dumps system-wide, attackers can fake a crash on LSASS, causing WER to generate a dump file. This setting is not enabled by default and requires modifying the registry. The DeepInstinct researchers publicized this attack at Defcon 30, demonstrating a method to access credentials without directly injecting malware into the LSASS process. This technique allows attackers to bypass traditional endpoint detection mechanisms that focus on malware signatures, making it a stealthy approach to credential theft. Defenders should monitor for registry modifications related to WER dump settings to detect and prevent this attack.

Attack Chain

The attacker gains initial access to the system, potentially through phishing or exploitation of a vulnerability.
The attacker modifies the registry key HKLM\SOFTWARE\Microsoft\Windows\Windows Error Reporting\LocalDumps\DumpType to the value 2 or 0x00000002 to enable full user-mode dumps system-wide.
The attacker triggers a crash or fakes a crash of the LSASS process.
Windows Error Reporting (WER) generates a full user-mode dump file of the LSASS process.
The dump file is stored in the location specified in the registry, typically C:\ProgramData\Microsoft\Windows\WER\ReportQueue.
The attacker accesses the generated dump file.
The attacker extracts credentials from the LSASS dump file using tools like Mimikatz or custom scripts.
The attacker uses the stolen credentials to move laterally within the network or access sensitive resources.

Impact

Successful exploitation can lead to the compromise of domain credentials and other sensitive information stored in LSASS memory, such as NTLM hashes and Kerberos tickets. This can enable attackers to move laterally within the network, escalate privileges, and access critical systems and data. A single compromised system can lead to a widespread breach affecting numerous users and systems. The sectors most vulnerable are those handling sensitive data or critical infrastructure.

Recommendation

Deploy the Sigma rule “Full User-Mode Dumps Enabled System-Wide” to your SIEM to detect suspicious registry modifications related to Windows Error Reporting (WER).
Examine process execution logs to identify any suspicious processes that may have triggered the dump, especially those not matching the legitimate svchost.exe process with user IDs S-1-5-18, S-1-5-19, or S-1-5-20 as described in the rule’s investigation guide.
Monitor for access to WER dump files located in C:\ProgramData\Microsoft\Windows\WER\ReportQueue using file monitoring rules.
Review and update endpoint protection configurations to ensure they can detect and block credential dumping techniques as mentioned in the rule’s response and remediation steps.

Group Policy Discovery via Microsoft GPResult Utility

hello@craftedsignal.io — Fri, 26 Jan 2024 12:00:00 +0000

Attackers may leverage the gpresult.exe utility, a built-in Windows tool, to gather information about Group Policy Objects (GPOs) within an Active Directory environment. This reconnaissance activity allows adversaries to understand the existing security policies, identify potential misconfigurations, and discover pathways for privilege escalation or lateral movement. The rule focuses on detecting the execution of gpresult.exe with specific command-line arguments (/z, /v, /r, /x) commonly associated with malicious reconnaissance. This behavior is typically observed after an initial compromise, where the attacker is attempting to map out the network and identify valuable targets. This activity matters for defenders as it provides an early indicator of post-compromise activity and can help prevent further damage.

Attack Chain

The attacker gains initial access to a Windows system through methods such as phishing, exploiting vulnerabilities, or using stolen credentials.
The attacker executes gpresult.exe from the command line or through a script.
The attacker uses command-line arguments such as /z, /v, /r, or /x to request detailed information about Group Policy settings.
gpresult.exe queries the Active Directory domain to retrieve GPO information applicable to the user or computer.
The attacker parses the output of gpresult.exe to identify security policies, user rights assignments, and other relevant configurations.
The attacker identifies potential weaknesses in the GPO configuration, such as overly permissive user rights or insecure password policies.
The attacker uses the gathered information to exploit identified weaknesses and escalate privileges or move laterally to other systems within the network.
The attacker achieves their objective, such as data exfiltration, system compromise, or deployment of ransomware.

Impact

Successful exploitation can lead to a comprehensive understanding of the target environment’s security posture, enabling attackers to identify and exploit weaknesses for privilege escalation and lateral movement. While the source does not specify a number of victims or sectors targeted, the impact of a successful attack can range from data breaches and financial losses to reputational damage and disruption of operations. The discovery of misconfigured group policies can open doors for attackers to compromise critical systems and data within the network.

Recommendation

Deploy the Sigma rule “Group Policy Discovery via GPResult” to your SIEM to detect the execution of gpresult.exe with suspicious parameters.
Enable Windows process creation logging to capture command-line arguments used with gpresult.exe and other executables.
Review and harden Group Policy configurations to minimize the risk of exploitation by attackers.
Investigate any alerts generated by the Sigma rule “Group Policy Discovery via GPResult” to determine the context and intent of the activity.

Detection of Malicious Browser Extension Installation

hello@craftedsignal.io — Fri, 26 Jan 2024 12:00:00 +0000

This detection rule identifies the installation of browser extensions on Windows systems, which can be a sign of malicious activity. Threat actors may install malicious browser extensions through app store downloads disguised as legitimate extensions, social engineering tactics, or by directly compromising a system. These extensions can then be used for persistence, data theft, or other malicious purposes. The rule focuses on monitoring file creation events related to browser extension installations, specifically targeting the file paths and types associated with Firefox (.xpi) and Chromium-based browsers (.crx). It excludes known safe processes and extensions to reduce false positives. This detection is relevant for defenders because malicious browser extensions can provide a persistent foothold for attackers, allowing them to maintain access to compromised systems and user data. The rule is based on EQL and can be used with Elastic Defend, Microsoft Defender XDR, SentinelOne Cloud Funnel, and Sysmon data.

Attack Chain

The user’s system is compromised, potentially through social engineering or existing malware.
The attacker gains access to the system and attempts to install a malicious browser extension.
The attacker drops the extension file (.xpi for Firefox, .crx for Chromium) into the appropriate browser extension directory (e.g., C:\\Users\\*\\AppData\\Roaming\\*\\Profiles\\*\\Extensions\\ for Firefox or C:\\Users\\*\\AppData\\Local\\*\\*\\User Data\\Webstore Downloads\\ for Chromium).
A file creation event is triggered as the extension file is created in the target directory.
The detection rule identifies this file creation event based on the file name and path, filtering out known safe processes like firefox.exe.
The malicious extension installs itself into the browser.
The extension gains persistence by loading every time the browser starts.
The attacker can now perform malicious actions such as monitoring browsing activity, stealing credentials, or injecting malicious content into web pages.

Impact

A successful attack using malicious browser extensions can lead to persistent access to the compromised system, allowing attackers to steal sensitive information such as credentials, financial data, or personal information. This can result in financial loss, identity theft, and reputational damage. The installation of malicious extensions can also lead to the injection of malicious content into web pages, redirecting users to phishing sites or distributing malware. The scope of the impact can range from individual users to entire organizations, depending on the extent of the compromise.

Recommendation

Enable Sysmon Event ID 11 (File Create) logging to capture the necessary file creation events for this detection.
Deploy the provided Sigma rule Browser Extension Install via File Creation to your SIEM and tune the exclusions for your specific environment.
Review and update the list of known safe processes and extensions in the Sigma rule Browser Extension Install via File Creation to minimize false positives.
Implement application whitelisting policies to restrict the installation of unauthorized browser extensions.
Educate users on the risks associated with installing browser extensions from untrusted sources and encourage them to only install extensions from official browser stores.
Implement policies to regularly review installed browser extensions across the organization.

Unusual Network Connection via RunDLL32

hello@craftedsignal.io — Fri, 26 Jan 2024 10:00:00 +0000

Attackers often abuse the rundll32.exe utility to execute malicious Dynamic Link Libraries (DLLs), blending their activity with legitimate system operations. This detection identifies instances where rundll32.exe establishes outbound network connections, particularly when executed without command-line arguments. Such behavior deviates from typical usage and may indicate command and control (C2) activity or other malicious actions. The rule is designed to detect command and control activity where adversaries are using rundll32.exe without arguments to make external network connections. The rule uses data from Elastic Defend, Sysmon, and SentinelOne to detect this behavior. The rule specifically excludes connections to well-known private and reserved IP ranges to reduce false positives.

Attack Chain

An attacker gains initial access to a Windows system, possibly through phishing or exploiting a software vulnerability.
The attacker attempts to execute a malicious DLL using rundll32.exe without specifying arguments, which is an anomaly.
rundll32.exe is invoked with a command line resembling: rundll32.exe .
The malicious DLL initiates an outbound network connection to an external IP address.
The network connection attempts to bypass firewall rules by masquerading as a legitimate system process.
The attacker uses this connection to establish a command and control channel.
Data exfiltration or further exploitation activities occur over the established C2 channel.
The attacker achieves their final objective, such as data theft, ransomware deployment, or system compromise.

Impact

Successful exploitation allows attackers to establish command and control channels on compromised systems, leading to potential data exfiltration, lateral movement within the network, and deployment of ransomware. This can result in significant financial losses, reputational damage, and disruption of business operations. The impact is broad, affecting any Windows environment where rundll32.exe is used.

Recommendation

Deploy the Sigma rule Detect Unusual Network Connection via RunDLL32 to your SIEM and tune for your environment to detect unusual network connections made by rundll32.exe.
Enable Sysmon process creation and network connection logging to capture necessary events for the Sigma rule.
Investigate any alerts generated by the Sigma rule, focusing on the parent processes of rundll32.exe and the destination IP addresses of the network connections.
Review and harden firewall rules to prevent unauthorized outbound connections from system processes like rundll32.exe.
Implement application control policies to restrict the execution of unsigned or untrusted DLLs via rundll32.exe.

Persistence via BITS Job Notify Cmdline

hello@craftedsignal.io — Fri, 26 Jan 2024 10:00:00 +0000

The Background Intelligent Transfer Service (BITS) is a Windows service used for asynchronous, prioritized, and throttled file transfers. Attackers can abuse BITS to establish persistence by using the SetNotifyCmdLine method to execute a program after a BITS job completes or enters a specific state. This technique allows adversaries to run arbitrary code with elevated privileges, bypassing traditional security measures. The detection rule identifies suspicious processes initiated by BITS, excluding known legitimate executables like WerFaultSecure.exe, WerFault.exe, wermgr.exe, and directxdatabaseupdater.exe. This behavior can be employed to maintain access to a compromised system, even after a reboot or user logout. Defenders need to monitor BITS activity for unusual command-line executions to detect and prevent potential persistence attempts.

Attack Chain

An attacker gains initial access to a system through other means (e.g., phishing, exploitation of a vulnerability).
The attacker uses the BITSAdmin tool or PowerShell cmdlets to create a new BITS job.
The attacker configures the BITS job to download a malicious payload or execute a malicious script.
The attacker utilizes the SetNotifyCmdLine method to set a command that will be executed upon job completion or a specified state change.
The BITS service executes the specified command, which can be a script interpreter (e.g., powershell.exe, cmd.exe) or a malicious executable.
The malicious command downloads or executes further payloads, establishing persistence on the system.
The attacker maintains persistent access, allowing them to execute commands, steal data, or perform other malicious activities.

Impact

Successful exploitation allows attackers to maintain persistent access to compromised systems. This can lead to data theft, further malware deployment, or complete system compromise. The BITS service runs with elevated privileges, so any command executed via SetNotifyCmdLine will also run with those privileges. This persistence mechanism is difficult to detect because BITS is a legitimate Windows service, and its activity can be easily masked as normal system operations.

Recommendation

Monitor process creation events for processes spawned by svchost.exe with arguments containing “BITS” but not in the exclusion list (WerFaultSecure.exe, WerFault.exe, wermgr.exe, directxdatabaseupdater.exe) using the “Persistence via BITS Job Notify Cmdline” rule.
Implement the Sigma rule “Detect Suspicious BITS Job Creation” to identify unusual BITS job creation activities.
Review BITS job configurations on systems to identify and remove any unauthorized or suspicious jobs.
Enable Sysmon process creation logging to capture detailed information about process execution, including parent-child relationships and command-line arguments.

Suspicious Microsoft Diagnostics Wizard Execution

hello@craftedsignal.io — Thu, 25 Jan 2024 14:23:00 +0000

The Microsoft Diagnostics Troubleshooting Wizard (MSDT) is a built-in Windows tool used for troubleshooting various system issues. Attackers can abuse MSDT to proxy malicious command or binary execution through carefully crafted process arguments, evading traditional defense mechanisms. This technique leverages the trust associated with a signed Microsoft binary (msdt.exe) to execute arbitrary commands. The detection rule identifies suspicious MSDT executions based on command-line arguments, filename discrepancies, and unusual process relationships. This activity has been observed since at least May 2022 and continues to be a relevant defense evasion technique. Defenders should monitor for unusual invocations of MSDT, especially when launched from untrusted sources or with suspicious arguments.

Attack Chain

Attacker gains initial access via an unspecified vector (e.g., phishing, drive-by download).
The attacker uses a malicious document or script to invoke msdt.exe with specific arguments.
MSDT is executed with a crafted IT_RebrowseForFile or IT_BrowseForFile parameter containing a malicious payload.
Alternatively, MSDT is executed with -af /skip and a path to a malicious PCWDiagnostic.xml file.
MSDT processes the malicious input, leading to the execution of attacker-controlled code.
The attacker’s code executes, potentially downloading or executing further payloads.
The attacker achieves persistence by modifying registry keys or creating scheduled tasks.
The attacker moves laterally through the network, compromising additional systems and data.

Impact

Successful exploitation allows attackers to bypass security controls and execute arbitrary code on compromised systems. This can lead to data theft, system compromise, and further propagation of the attack within the network. The defense evasion tactic can obscure malicious activities, making it more difficult to detect and respond to incidents. Depending on the user’s privileges, the attacker might gain elevated privileges on the system.

Recommendation

Deploy the provided Sigma rules to detect suspicious MSDT executions based on process arguments, filename discrepancies, and unusual parent-child relationships.
Monitor process creation events for msdt.exe with arguments containing IT_RebrowseForFile=*, *FromBase64*, or */../../../* using the provided Sigma rule.
Enable Sysmon process creation logging (Event ID 1) to capture the necessary process execution details for the provided Sigma rules.
Investigate any alerts generated by these rules, focusing on the process command line, parent process, and any spawned child processes.
Block execution of msdt.exe from non-standard paths as highlighted in the detection rule.

Unusual Executable File Creation by a System Critical Process

hello@craftedsignal.io — Thu, 25 Jan 2024 12:00:00 +0000

This detection rule identifies anomalous creation or modification of executable files by critical Windows system processes, like smss.exe, csrss.exe, and lsass.exe. Attackers may attempt to leverage these processes to evade detection, and the rule is designed to detect such activities. The rule leverages data from Elastic Defend, Microsoft Defender XDR, SentinelOne, CrowdStrike, and Sysmon. It provides investigation steps to help analysts triage and analyze potential incidents, focusing on the identity of the writing process, its lineage, and the characteristics of the written file. This rule is designed to detect potential remote code execution or other forms of exploitation targeting Windows systems. The rule logic excludes specific legitimate file paths to minimize false positives.

Attack Chain

An attacker gains initial access to the system through methods such as phishing or exploiting a vulnerability.
The attacker executes code on the system.
The attacker attempts to escalate privileges.
The attacker leverages a system critical process to create or modify an executable file.
The created/modified file may be a backdoor, malware component, or a tool for further exploitation.
The attacker uses the created executable to establish persistence.
The attacker uses the newly created executable to perform lateral movement.
The attacker achieves their objective, such as data exfiltration or system compromise.

Impact

Successful exploitation can lead to arbitrary code execution with elevated privileges. The number of victims is dependent on the scope of the initial compromise. The targeted sectors include any organization running vulnerable Windows systems. If the attack succeeds, the adversary can gain full control over the system, leading to data theft, system disruption, or further propagation of malware.

Recommendation

Deploy the “Unusual Executable File Creation by a System Critical Process” detection rule to your SIEM and tune for your environment.
Enable Sysmon file creation logging (Event ID 11) to enhance detection capabilities (see setup instructions in the rule source).
Investigate any alerts generated by this rule, paying close attention to the writing process’s identity, lineage, and the characteristics of the written file as detailed in the rule’s triage and analysis section.
Correlate alerts from this rule with other endpoint and network activity to identify the scope of the potential compromise.

Detecting Rare SMB Connections for Potential NTLM Credential Theft

hello@craftedsignal.io — Thu, 25 Jan 2024 12:00:00 +0000

This detection strategy focuses on identifying unusual Server Message Block (SMB) traffic that originates from internal IP addresses and connects to external networks. The SMB protocol, commonly used for file and printer sharing within a network, can be exploited to exfiltrate data by injecting rogue UNC paths to capture NTLM credentials. This activity is often associated with threat actors attempting to steal credentials for lateral movement or data exfiltration. Defenders should be aware of this technique as it allows adversaries to bypass traditional security controls by leveraging a legitimate protocol for malicious purposes. This detection is relevant for environments utilizing Windows operating systems and SMB for internal network communications. The goal is to identify and alert on SMB connections to external IPs, excluding known safe ranges and legitimate business applications.

Attack Chain

An attacker compromises an internal system via phishing or other means (not detailed in source).
The attacker injects a rogue UNC path into a document, email, or other medium.
A user opens the malicious document or clicks the injected link, triggering an SMB connection to a malicious external server.
The SMB connection attempts to authenticate with the user’s NTLM credentials.
The attacker captures the NTLM hash from the authentication attempt.
The attacker attempts to crack the NTLM hash to obtain the user’s password.
Using the cracked password, the attacker gains unauthorized access to other systems and resources on the network.

Impact

Successful exploitation can lead to credential theft, allowing attackers to gain unauthorized access to sensitive data and systems within the organization. This can result in data breaches, financial losses, and reputational damage. The impact is significant because SMB is a common protocol within many Windows environments, making this technique highly effective if not properly monitored.

Recommendation

Deploy the Sigma rule “Detect SMB Connection to External IP” to your SIEM to identify potentially malicious SMB connections to the internet. Tune the rule by excluding known good external IPs used by legitimate services.
Enable Sysmon Event ID 3 (Network Connection) with proper filtering to capture SMB traffic details as recommended in the linked setup guide, to enhance the fidelity of the detection.
Implement network segmentation to restrict SMB traffic to only necessary internal communications, reducing the attack surface and mitigating the risk of external exposure.

Windows Script Execution from Archive File

hello@craftedsignal.io — Wed, 24 Jan 2024 12:00:00 +0000

Attackers commonly use archive files (ZIP, RAR, 7z) to deliver malicious scripts, such as JScript and VBScript, to Windows systems. This technique allows them to bypass some initial security checks and deliver payloads that can execute arbitrary code. The “Windows Script Execution from Archive” detection identifies instances where Windows Script Host (wscript.exe) is launched from temporary directories containing extracted archive contents. This activity can indicate a user has opened a malicious archive, leading to potential malware execution. This detection focuses on the parent-child process relationship, where explorer.exe, winrar.exe, or 7zFM.exe spawns wscript.exe to execute scripts from the temp directory.

Attack Chain

A user receives a malicious archive file (e.g., ZIP, RAR, 7z) via email or downloads it from a website.
The user opens the archive file using a file archiver tool like Explorer, WinRAR, or 7-Zip.
The archiver extracts the contents, including a malicious JScript (.js) or VBScript (.vbs) file, to a temporary directory, such as \Users\*\AppData\Local\Temp\7z*\.
The user (or the archiver tool) inadvertently executes the extracted script using Windows Script Host (wscript.exe).
Wscript.exe executes the malicious script, which may perform a variety of actions, such as downloading and executing additional payloads.
The script establishes persistence via registry modification, adding a run key to execute upon system startup.
The script connects to a command-and-control server to receive further instructions.
The attacker gains control of the compromised system and begins lateral movement.

Impact

A successful attack of this nature can lead to arbitrary code execution on the victim’s machine, potentially resulting in data theft, malware installation, or complete system compromise. While the number of affected organizations is not specified, the technique is broadly applicable to any Windows environment where users handle archive files, potentially affecting numerous individuals and organizations across various sectors.

Recommendation

Enable process creation logging with command line arguments to capture the execution of wscript.exe and its arguments.
Deploy the Sigma rule “Detect Script Execution from Archive” to your SIEM to identify suspicious script execution patterns.
Monitor process activity for wscript.exe and other scripting engines executing from temporary directories.
Configure endpoint security solutions to block execution of scripts from common temporary directories.

Potential Privilege Escalation via SUID/SGID Abuse on Linux

hello@craftedsignal.io — Wed, 24 Jan 2024 12:00:00 +0000

This detection rule, sourced from Elastic, identifies instances where a process executes with root privileges (UID/GID 0) while the real user/group ID is non-zero. This condition suggests that the process has been granted SUID/SGID permissions, potentially allowing it to run with elevated privileges. Attackers may exploit such misconfigurations to escalate their privileges to root or establish persistence mechanisms. The rule focuses on Linux systems and leverages Elastic Defend data to identify such events. The initial publication date of the rule was in June 2024, with updates made as recently as May 2026. This type of misconfiguration can lead to significant security breaches.

Attack Chain

A user (non-root) executes a binary that has the SUID or SGID bit set.
The system checks the permissions of the executable and identifies the SUID/SGID bit.
The process spawns with the effective UID/GID set to the owner/group of the executable file (typically root).
The process attempts to perform actions that require elevated privileges.
If the SUID/SGID binary is vulnerable, the attacker can leverage it to execute arbitrary commands as root.
The attacker escalates privileges to root, gaining full control over the system.
The attacker installs a backdoor for persistent access.
The attacker performs malicious activities, such as data exfiltration or system compromise.

Impact

Successful exploitation of SUID/SGID misconfigurations can grant an attacker root-level access to a Linux system. This can lead to complete system compromise, including data theft, installation of malware, and the potential for lateral movement to other systems on the network. A single compromised system can be leveraged to attack other internal assets.

Recommendation

Deploy the provided Sigma rule to your SIEM to detect potential SUID/SGID exploitation (see the rules section).
Review the SUID/SGID binaries identified by the rule and verify their configurations to ensure they are correctly set and necessary.
Implement enhanced monitoring and logging for SUID/SGID execution attempts to detect and respond to similar threats in the future (Data Source: Elastic Defend).
Consider implementing stricter access controls and reducing the number of SUID/SGID binaries on the system to minimize the attack surface.
Investigate the parent process of the flagged binaries to determine the origin of the execution and whether it aligns with expected behavior.

Multiple Alerts in Different ATT&CK Tactics by Host

hello@craftedsignal.io — Wed, 24 Jan 2024 12:00:00 +0000

This detection rule, created by Elastic, is designed to identify potentially compromised hosts by aggregating alert data. It focuses on scenarios where a single host triggers multiple alerts associated with different phases of an attack, as defined by the ATT&CK framework. The rule calculates a risk score based on the number and severity of alerts, prioritizing hosts exceeding a defined threshold. By focusing on hosts exhibiting diverse attack tactics, analysts can more effectively triage and respond to complex, multi-stage intrusions. This rule helps filter out noisy alerts such as “Agent Spoofing”, “Compression DLL Loaded by Unusual Process”, and “Potential PrintNightmare File Modification”, and focuses on alerts where kibana.alert.risk_score is greater than 0.

Attack Chain

An adversary gains initial access to a host through various methods.
The adversary executes malicious code or commands on the host.
The attacker establishes persistence to maintain access.
The adversary attempts to escalate privileges to gain higher-level control.
The attacker performs lateral movement to compromise other systems.
The adversary gathers information about the compromised environment.
The attacker exfiltrates sensitive data from the network.
The attacker achieves their final objective, such as data theft or disruption of services.

Impact

A successful attack, as identified by this rule, can lead to significant data breaches, system compromise, and operational disruption. Multiple alerts across various tactics suggest a sophisticated and persistent attacker. Prioritizing hosts identified by this rule enables security teams to quickly contain and remediate advanced threats, minimizing potential damage and reducing the overall impact on the organization. Without this detection, analysts might miss critical correlations between seemingly isolated alerts.

Recommendation

Deploy the provided Sigma rule to your SIEM to identify potentially compromised hosts based on multiple alerts across different ATT&CK tactics.
Investigate any hosts flagged by this rule, correlating the alert data with other logs and telemetry to understand the full scope of the attack.
Tune the threshold values in the Sigma rule (distinct rule count, tactic count, risk score) to align with your environment and risk tolerance.
Enable logging for process creation, network connections, and file modifications on all hosts to provide sufficient data for the detection rule.
Review the “False positive analysis” section of the rule’s documentation to identify and exclude known benign activities that may trigger the rule.
Use the Esql.kibana_alert_rule_name_values field in the rule output to quickly identify the specific alert types triggering the rule.

First Time Seen Remote Monitoring and Management Tool Execution

hello@craftedsignal.io — Wed, 24 Jan 2024 12:00:00 +0000

Attackers commonly abuse legitimate remote monitoring and management (RMM) tools and remote access software for command and control (C2), persistence, and execution of native commands on compromised endpoints. These tools provide attackers with the ability to maintain access, execute commands, and move laterally within a network. This detection identifies when a process associated with commonly abused RMM/remote access tools is observed for the first time on a host. The rule is designed to trigger when a new process name or code signature associated with RMM software, or a child process of such software, is seen within a configured history window. This helps defenders quickly identify potentially malicious use of legitimate tools.

Attack Chain

Initial Access: The attacker gains initial access to a target system through various methods, such as exploiting vulnerabilities or using compromised credentials.
Tool Deployment: The attacker deploys a remote monitoring and management (RMM) tool or remote access software on the compromised endpoint. This may involve downloading and installing the tool, or exploiting existing installations.
Persistence: The RMM tool is configured to run persistently on the system, ensuring that the attacker maintains access even after a reboot or other disruption. This may involve creating a service or adding a registry key to ensure the tool starts automatically.
Command and Control: The attacker uses the RMM tool to establish a command and control (C2) channel with the compromised system. This allows them to remotely execute commands, transfer files, and monitor activity on the system.
Lateral Movement: Using the RMM tool, the attacker moves laterally within the network, compromising additional systems and escalating their access. This may involve using the tool to access shared resources or execute commands on other systems.
Data Exfiltration or Ransomware Deployment: The attacker uses their access to exfiltrate sensitive data from the compromised network or deploy ransomware to encrypt files and demand a ransom payment.
Cleanup: The attacker may attempt to remove traces of their activity, such as logs or files associated with the RMM tool, to avoid detection.

Impact

Compromise via RMM tools can lead to significant data breaches, financial losses, and reputational damage. The use of legitimate tools makes detection more difficult. Successful attacks can result in ransomware deployment, data theft, and prolonged unauthorized access to sensitive systems. Organizations in all sectors are potentially at risk.

Recommendation

Deploy the process creation rule to detect the execution of RMM tools on endpoints based on process.name and process.code_signature.subject_name criteria in the query.
Enable Sysmon process creation logging (Event ID 1) to ensure the collection of necessary event data for the detection rule.
Investigate any alerts generated by the detection rule to determine whether the execution of the RMM tool is authorized and legitimate. Refer to the references for a list of commonly abused RMM tools and associated indicators.

Executable File Creation with Multiple Extensions

hello@craftedsignal.io — Wed, 24 Jan 2024 12:00:00 +0000

Adversaries may use masquerading techniques to evade defenses and blend into the environment by manipulating the name or location of a file, tricking users into executing malicious code disguised as a benign file type. This rule detects the creation of executable files with multiple extensions, a common method of masquerading. The rule focuses on identifying suspicious file creations that use misleading extensions, specifically targeting files with an “.exe” extension preceded by common benign extensions. It excludes known legitimate processes to minimize false positives. This activity is relevant for defenders to identify potential threats where adversaries attempt to bypass security measures by disguising malicious files.

Attack Chain

An attacker crafts a malicious executable file with a double extension (e.g., “document.pdf.exe”).
The attacker delivers the malicious file to the target system via phishing or other means.
The user downloads or receives the file and attempts to open it.
Windows displays the file with the first extension (“document.pdf”) by default, misleading the user.
Upon execution, Windows recognizes the “.exe” extension and executes the file.
The malicious executable runs, potentially deploying malware or performing other unauthorized actions.
The malware establishes persistence or attempts lateral movement within the network.
The attacker achieves their objective, such as data theft or system compromise.

Impact

Successful exploitation can lead to malware infection, data breaches, and system compromise. This technique bypasses common file type restrictions and user awareness, potentially affecting a wide range of users and systems. While the number of victims is not specified, the impact can be significant, particularly in organizations where users handle sensitive data. The affected sectors are broad, encompassing any organization where users are susceptible to social engineering attacks.

Recommendation

Deploy the Sigma rule “Executable File Creation with Multiple Extensions” to your SIEM and tune for your environment to detect the creation of suspicious files with multiple extensions.
Enable Sysmon Event ID 11 (File Create) for comprehensive file creation monitoring to improve the effectiveness of the detection rule.
Implement enhanced monitoring and logging for similar file creation activities to improve detection and response capabilities.
Educate users on the risks associated with double file extensions and encourage caution when opening attachments from unknown sources.
Review and whitelist legitimate software installations that may create executables with multiple extensions to reduce false positives, as described in the rule’s triage notes.

Credential Acquisition via Registry Hive Dumping

hello@craftedsignal.io — Wed, 24 Jan 2024 12:00:00 +0000

This detection identifies attempts to export registry hives containing sensitive credential information using the Windows reg.exe utility. Attackers may target the HKLM\SAM and HKLM\SECURITY hives to extract stored credentials, including password hashes and LSA secrets. The activity is often part of a broader credential access campaign. The rule focuses on detecting the execution of reg.exe with specific arguments indicating an attempt to save or export these critical registry hives. The use of reg.exe makes this technique accessible to various threat actors, including ransomware groups and nation-state actors. Defenders need to monitor for this activity to prevent unauthorized credential access and potential lateral movement within the network. This rule specifically looks for “save” and “export” arguments targeting SAM and SECURITY hives.

Attack Chain

An attacker gains initial access to a Windows system, potentially through phishing or exploiting a vulnerability.
The attacker executes reg.exe from the command line or through a script.
The reg.exe command includes arguments to save or export registry hives.
The target registry hives are HKLM\SAM and HKLM\SECURITY, containing sensitive credential information.
The exported registry hive is saved to a file on disk or a network share.
The attacker may compress or encrypt the exported registry hive to evade detection.
The attacker retrieves the exported registry hive for offline analysis.
The attacker extracts credential information from the registry hive, such as password hashes and LSA secrets, to use in lateral movement or privilege escalation.

Impact

Successful exploitation allows attackers to acquire sensitive credentials stored within the registry. This can lead to lateral movement within the network, privilege escalation, and ultimately, data exfiltration or system compromise. Compromised credentials can be used to access critical systems and data, causing significant damage to the organization. The impact is considered high due to the potential for widespread access and control over the compromised environment.

Recommendation

Enable process creation auditing with command line arguments to capture the execution of reg.exe with relevant arguments. (Data Source: Windows Security Event Logs, Sysmon)
Deploy the Sigma rule Detect Registry Hive Export via Reg.exe to your SIEM to detect the execution of reg.exe with arguments indicative of registry hive dumping.
Implement access controls and monitor file system activity to detect unauthorized access or modification of registry hive files.
Review and restrict the use of reg.exe to authorized personnel and processes.
Monitor for parent processes of reg.exe that are unusual or unexpected, which might indicate malicious activity.
Investigate any alerts generated by the Sigma rule by reviewing the process command line, parent process, and destination of the exported registry hive.

Multiple Alerts Involving a User Detection

hello@craftedsignal.io — Wed, 24 Jan 2024 10:00:00 +0000

This detection rule, sourced from Elastic’s detection ruleset, is designed to identify potential user account compromises by aggregating and analyzing existing alert data. The rule focuses on scenarios where a single user triggers multiple distinct alerts, suggesting a higher likelihood of malicious activity. By excluding low-severity alerts and known system accounts, the rule aims to minimize false positives and prioritize investigations. This approach is particularly useful in environments where attackers may attempt to blend in with normal user activity while escalating privileges or moving laterally within the network. The rule utilizes esql to correlate alerts based on user ID. The rule was last updated on 2026/04/27.

Attack Chain

An attacker gains initial access to a user account, potentially through phishing, credential stuffing, or other methods.
The attacker attempts to escalate privileges within the compromised account.
The attacker performs reconnaissance activities, such as discovering sensitive files or network shares.
The attacker attempts to move laterally to other systems within the network using the compromised credentials.
The attacker accesses sensitive data, potentially exfiltrating it from the network.
These actions trigger various security alerts related to privilege escalation, lateral movement, and data access.
The “Multiple Alerts Involving a User” rule detects the correlation between these alerts based on the user ID.
Security analysts are alerted to investigate the compromised user account and contain the potential damage.

Impact

A successful attack leveraging a compromised user account can lead to significant data breaches, financial losses, and reputational damage. The impact can range from unauthorized access to sensitive data to the complete takeover of critical systems. By identifying compromised user accounts early, organizations can mitigate the potential damage and prevent further escalation of the attack. This detection rule helps prioritize investigations and ensures that security analysts focus on the most critical threats.

Recommendation

Deploy the Sigma rule Multiple Alerts Involving a User to your SIEM to detect potential user account compromises based on correlated alerts.
Enable audit logging on systems to capture user activity and generate alerts for suspicious actions.
Review and tune the threshold values (e.g., distinct alert count) in the Sigma rule to align with your environment and risk tolerance.
Use the Resources: Investigation Guide tag to access guidance on investigating triggered alerts and identifying compromised user accounts.
Implement role-based access control (RBAC) to minimize the impact of compromised accounts by limiting access to sensitive resources.

Renamed Automation Script Interpreter

hello@craftedsignal.io — Tue, 23 Jan 2024 12:00:00 +0000

Malware operators often rename legitimate system and scripting tools to blend in with normal system processes and bypass security measures. This rule specifically detects instances where automation script interpreters like AutoIt, AutoHotkey, and KIX32 have been renamed. By comparing the process name against the original file name embedded in the executable, this detection identifies potential attempts to masquerade malicious scripts as legitimate software. This technique is employed to bypass application whitelisting and other security controls that rely on file names or process names for identification and authorization. This detection is relevant for any Windows environment where these scripting tools are used, as it can highlight potentially malicious activity masked by a common evasion technique.

Attack Chain

An attacker gains initial access to the system, often through phishing or exploiting a software vulnerability.
The attacker uploads or drops a malicious script (e.g., AutoIt, AutoHotkey, or KIX32 script) onto the target machine.
The attacker renames the legitimate AutoIt, AutoHotkey, or KIX32 interpreter executable to a non-standard name (e.g., “svchost.exe” or “wininit.exe”) to masquerade as a legitimate process.
The attacker executes the renamed interpreter, which in turn executes the malicious script.
The script performs malicious actions, such as downloading additional malware, modifying system settings, or establishing persistence.
The attacker uses the compromised system for lateral movement within the network or for data exfiltration.
The attacker attempts to maintain persistence on the system to ensure continued access.

Impact

Successful renaming of script interpreters allows attackers to execute malicious scripts undetected, potentially leading to data theft, system compromise, or further propagation within the network. The impact can range from minor disruption to significant financial loss and reputational damage, depending on the attacker’s objectives and the sensitivity of the compromised data.

Recommendation

Deploy the Sigma rule “Renamed AutoIt Interpreter” to your SIEM to detect when AutoIt executables are renamed, focusing on process.pe.original_file_name and process.name.
Deploy the Sigma rule “Renamed AutoHotkey Interpreter” to your SIEM to detect when AutoHotkey executables are renamed, focusing on process.pe.original_file_name and process.name.
Enable Sysmon process creation logging to capture the necessary process metadata, as referenced in the rule logsource.
Investigate any alerts generated by these rules to determine the legitimacy of the renamed executable and its associated activity as described in the note section.

Curl or Wget Execution from Container Context

hello@craftedsignal.io — Tue, 23 Jan 2024 12:00:00 +0000

This detection rule identifies instances of curl or wget being executed from within containers managed by runc on Linux systems. The rule leverages Auditd Manager to monitor system calls and flags processes running with the title runc init that then execute curl or wget. This activity is noteworthy because attackers often use these tools to download malicious payloads (stagers, scripts, implants) or to exfiltrate data after compromising a container. While these tools can be used legitimately within containers, their execution in the context of runc init suggests a higher risk of malicious activity. The rule focuses on narrowing the signal to the container runtime boundary where unexpected download clients are more worthy of review. The rule specifically leverages Auditd Manager for data collection.

Attack Chain

An attacker gains initial access to a host system, possibly through exploiting a vulnerability in an application running outside the container (e.g., web application).
The attacker identifies a containerized application running on the compromised host.
The attacker exploits a vulnerability within the container, or abuses a privileged workload within the container, to gain elevated privileges or code execution within the container.
The attacker uses curl or wget to download additional tools or scripts into the container. These tools might include reverse shells, credential dumping tools, or data exfiltration utilities.
The attacker executes the downloaded tools to further compromise the container or the underlying host.
The attacker uses curl or wget to stage data for exfiltration to an external server. This may involve compressing and encoding data before transmission.
The attacker initiates the data exfiltration process using curl or wget to send the staged data to a remote server controlled by the attacker.
The attacker achieves their final objective, which could include data theft, system disruption, or further lateral movement within the network.

Impact

Compromised containers can lead to data breaches, service disruptions, and further attacks on internal systems. Successful exploitation could allow attackers to steal sensitive data, install malware, or pivot to other parts of the network, impacting confidentiality, integrity, and availability. The number of affected systems depends on the scope of the container deployment and the privileges granted to the compromised container.

Recommendation

Deploy the Sigma rule Detect Curl or Wget Execution from Container Context to your SIEM and tune for your environment.
Enable Auditd Manager with syscall coverage including execve to capture process execution and arguments within containers, as mentioned in the rule’s setup instructions.
Correlate alerts from this rule with network logs to identify the destination IP addresses and domains contacted by the compromised container.
Baseline trusted images and exclude stable image digests or namespaces when noisy to reduce false positives, as suggested in the rule’s false positives section.

Suspicious WMIC XSL Script Execution

hello@craftedsignal.io — Mon, 22 Jan 2024 12:00:00 +0000

This detection identifies WMIC allowlist bypass techniques by alerting on suspicious execution of scripts. When WMIC loads scripting libraries, such as jscript.dll or vbscript.dll, it may be indicative of an allowlist bypass. Adversaries exploit WMIC to bypass security measures by executing scripts via XSL files. This technique is often used for defense evasion and execution of malicious code. The detection logic focuses on monitoring WMIC executions with atypical arguments (format*:, /format:, -format:) in conjunction with the loading of scripting libraries, indicating potential misuse. The rule is designed for data generated by Elastic Defend and also supports Sysmon data sources.

Attack Chain

An attacker gains initial access to the system through various means (e.g., phishing, exploit).
The attacker executes WMIC.exe or wmic.exe with suspicious arguments such as “format*:”, “/format:”, or “-format*:*” to leverage XSL script processing.
WMIC attempts to load scripting libraries like jscript.dll or vbscript.dll to enable script execution.
The attacker uses the loaded scripting libraries to execute malicious code embedded in an XSL file.
The script performs various malicious actions, such as downloading additional payloads, modifying system configurations, or escalating privileges.
The attacker leverages the WMI functionality for lateral movement or persistence within the network.
The attacker evades detection by abusing trusted system binaries (WMIC) and allowlisted scripting engines.
The final objective is to achieve code execution and maintain control over the compromised system for data exfiltration or further malicious activities.

Impact

Successful exploitation allows attackers to bypass security measures and execute malicious code on compromised systems. This can lead to a range of adverse effects, including data theft, system compromise, and further propagation of malware within the network. The use of WMIC for defense evasion can make it difficult to detect malicious activity, increasing the risk of successful attacks.

Recommendation

Deploy the Sigma rule Detect Suspicious WMIC XSL Script Execution to your SIEM and tune for your environment.
Enable Sysmon Event ID 1 (Process Creation) and Event ID 7 (Image Loaded) logging to activate the Sigma rule above.
Investigate any alerts triggered by the Sigma rule by reviewing process execution details and command-line arguments.
Review the parent process of suspicious WMIC executions to understand the context and origin of the activity.
Correlate the process.entity_id with other related events within a 2-minute window to identify any additional suspicious activities.
Implement application control policies to restrict the execution of unauthorized or suspicious XSL files and scripts.

Potential Ransomware Behavior - Note Files Dropped via SMB

hello@craftedsignal.io — Mon, 22 Jan 2024 12:00:00 +0000

This detection identifies potential ransomware activity through the rapid creation of ransom notes via SMB shares. The rule focuses on file creation events originating from the SYSTEM account (PID 4), targeting common ransom note file extensions like .txt, .html, .pdf, and image files. This activity suggests an attacker has achieved lateral movement and is deploying ransom notes across multiple systems. The rule aggregates events within a 60-second window to reduce false positives and focus on high-frequency creation patterns indicative of automated ransomware deployment. Successful detection can help defenders quickly identify and contain ransomware outbreaks before widespread encryption occurs. The original Elastic detection rule was published on 2024-05-03 and updated on 2026-05-04.

Attack Chain

The attacker gains initial access to a system through an exploit or compromised credentials.
The attacker moves laterally to other systems on the network using valid accounts or exploits. (T1021.002 - SMB/Windows Admin Shares)
The attacker uses a tool to remotely create files over SMB. (T1021.002 - SMB/Windows Admin Shares)
The SYSTEM account (PID 4) on a compromised host is used to create multiple files with the same name but different paths (C:*) over SMB.
The created files have file extensions commonly associated with ransom notes: .txt, .htm, .html, .hta, .pdf, .jpg, .bmp, .png.
The files are dropped into at least 3 unique paths within a short time frame (60 seconds).
The attacker encrypts data and leaves the ransom notes to instruct victims on how to pay the ransom. (T1486 - Data Encrypted for Impact)
The organization experiences data loss, financial damage, and reputational harm.

Impact

Successful ransomware attacks can lead to significant data loss, financial costs associated with ransom payments, recovery efforts, and reputational damage. Organizations may experience business disruption, regulatory fines, and legal liabilities. The Akira ransomware group, referenced in the original rule’s documentation, has been known to target various sectors, demanding substantial ransoms from victims. The widespread distribution of ransom notes indicates an advanced stage of the ransomware attack, necessitating immediate containment to prevent further data encryption and system compromise.

Recommendation

Deploy the Sigma rule Potential Ransomware Note File Dropped via SMB to your SIEM to detect suspicious file creation activity indicative of ransomware deployment.
Enable Elastic Defend for enhanced endpoint detection and response capabilities, as recommended in the rule’s setup instructions.
Monitor incoming network connections to port 445 (SMB) on critical assets, as suggested in the rule’s triage analysis.
Investigate file names with unusual extensions to identify potential ransom notes, as mentioned in the triage analysis.
Isolate any hosts identified as creating multiple note files over SMB to prevent further lateral movement and data encryption, as described in the rule’s response and remediation steps.
Review and enforce network segmentation policies to limit lateral movement and reduce the impact of potential ransomware attacks (TA0008).

Windows Sandbox Abuse with Sensitive Configuration

hello@craftedsignal.io — Wed, 10 Jan 2024 12:00:00 +0000

Attackers may abuse the Windows Sandbox feature to evade detection by running malicious code within the isolated environment. This involves configuring the sandbox with sensitive options such as granting write access to the host file system, enabling network connections, and setting up automatic command execution via logon. By running within the sandbox with these configurations, malware can potentially interact with the host system, while making detection more difficult. This technique is used for defense evasion, hiding artifacts, and executing malicious activities within a virtualized environment to avoid direct exposure on the host. The rule identifies the start of a new container with sensitive configurations like write access to the host file system, network connection and automatic execution via logon command.

Attack Chain

An attacker gains initial access to the system through an exploit or social engineering.
The attacker leverages Windows Sandbox by executing wsb.exe or WindowsSandboxClient.exe.
The attacker configures the sandbox to enable networking using Enable or true.
The attacker grants the sandbox write access to the host file system using C:\\false.
The attacker sets up a logon command to automatically execute malicious code when the sandbox starts using .
The sandbox initializes and executes the configured logon command.
The malicious code interacts with the host file system and network, performing actions such as data exfiltration or lateral movement.
The attacker achieves their objective, such as deploying ransomware or stealing sensitive information, while operating from within the isolated sandbox environment.

Impact

A successful attack using Windows Sandbox abuse can lead to a range of negative impacts. Attackers may gain unauthorized access to sensitive data, compromise system integrity, or disrupt business operations. The use of the sandbox environment helps to conceal malicious activity, making detection and remediation more challenging. The damage can include data breaches, financial losses, reputational damage, and regulatory penalties. Successful exploitation allows malware to interact with the host system, potentially affecting multiple systems on the network.

Recommendation

Deploy the “Windows Sandbox with Sensitive Configuration” detection rule to your SIEM to identify potential sandbox abuse attempts.
Monitor process creation events for wsb.exe and WindowsSandboxClient.exe with command-line arguments that enable networking (Enable, true).
Monitor process creation events for wsb.exe and WindowsSandboxClient.exe with command-line arguments that enable write access to the host file system (C:\\false).
Monitor process creation events for wsb.exe and WindowsSandboxClient.exe with command-line arguments that define logon commands ().
Enable Sysmon process creation logging (Event ID 1) to capture the necessary command-line arguments.

PowerShell Kerberos Ticket Request via KerberosRequestorSecurityToken

hello@craftedsignal.io — Tue, 09 Jan 2024 18:45:00 +0000

This detection identifies PowerShell scripts leveraging the KerberosRequestorSecurityToken class to request Kerberos service tickets. Attackers often use this technique to perform Kerberoasting, where they obtain service tickets for various service principal names (SPNs) and crack the associated service account passwords offline. This activity can be indicative of an attacker attempting to gain unauthorized access to sensitive resources within the network. The rule is designed to trigger on potentially malicious uses of KerberosRequestorSecurityToken while attempting to filter out legitimate uses, such as those within Sentinel breakpoints or authorized Kerberos diagnostic scripts. Defenders should investigate any instances of this activity to determine whether it represents a genuine threat.

Attack Chain

Initial Access: An attacker gains initial access to a Windows system, potentially through phishing, compromised credentials, or exploiting a vulnerability.
Execution: The attacker executes a PowerShell script, either interactively or via a scheduled task or other means of remote execution.
Obfuscation (Optional): The PowerShell script may be obfuscated to evade detection, using techniques such as Base64 encoding or string manipulation.
Ticket Request: The script uses the KerberosRequestorSecurityToken class to request Kerberos service tickets for one or more SPNs.
Data Collection: The script collects the requested service tickets and potentially saves them to a file or transmits them over the network.
Credential Access: The attacker extracts the Kerberos hashes from the collected tickets.
Offline Cracking: The attacker uses tools like John the Ripper or Hashcat to crack the service account passwords offline.
Privilege Escalation/Lateral Movement: Upon successfully cracking the passwords, the attacker uses the compromised credentials to escalate privileges or move laterally within the network.

Impact

Successful Kerberoasting attacks can lead to the compromise of service accounts, potentially granting attackers unauthorized access to critical systems and sensitive data. The impact can range from data breaches and financial losses to complete system compromise and disruption of business operations. The rule’s medium severity reflects the potential for significant impact if the attack succeeds.

Recommendation

Enable PowerShell Script Block Logging to capture the PowerShell script content necessary for detection, and ensure the logs are being ingested into your SIEM. Reference: Setup instructions.
Deploy the Sigma rule “PowerShell Kerberos Ticket Request” to your SIEM to detect suspicious use of KerberosRequestorSecurityToken in PowerShell scripts.
Investigate any alerts triggered by the Sigma rule, focusing on reconstructing the full script content, identifying the targeted SPNs, and analyzing the process execution context to determine if the activity is malicious.
Review Windows Security event logs on domain controllers for event ID 4769, filtering for the TargetUserName associated with the alerting user to identify related Kerberos ticket requests.

Unsigned DLL Loaded by Svchost for Persistence and Privilege Escalation

hello@craftedsignal.io — Tue, 09 Jan 2024 18:30:00 +0000

Attackers may attempt to load malicious, unsigned DLLs into svchost.exe, a legitimate Windows service host process, to maintain persistence or escalate privileges. This technique abuses the shared service host process to execute arbitrary code with SYSTEM privileges. The svchost.exe process, which typically hosts multiple Windows services, can be targeted to load malicious DLLs from unusual file paths, potentially bypassing security measures that rely on code signing validation. This is especially concerning because svchost.exe is a trusted process, making detection more challenging. The loading of unsigned DLLs by svchost.exe from atypical directories is a strong indicator of potential malicious activity, as legitimate Windows services rarely load unsigned libraries from such locations.

Attack Chain

An adversary gains initial access to the system through an undisclosed method (e.g., exploitation of a vulnerability or social engineering).
The attacker creates a malicious, unsigned DLL on the compromised system in a non-standard directory like C:\ProgramData\.
The attacker modifies the Windows Registry to configure a service hosted by svchost.exe to load the malicious DLL. This often involves manipulating service dependencies or service parameters.
The system is restarted, or the targeted service is manually restarted, causing svchost.exe to load the specified DLL.
svchost.exe executes the code within the malicious DLL, now running with the privileges of the hosted service (typically SYSTEM).
The malicious DLL performs actions such as installing backdoors, escalating privileges further, or establishing command and control (C2) communication.
The attacker uses the established C2 channel to remotely control the compromised system, exfiltrate data, or perform other malicious activities.
The attacker maintains persistence on the system by ensuring the malicious DLL is loaded each time the service or system starts.

Impact

Successful exploitation allows attackers to gain persistent access to the compromised system with elevated (SYSTEM) privileges. This can lead to complete system compromise, data theft, installation of backdoors, and lateral movement within the network. The use of svchost.exe as a host for malicious DLLs makes detection more difficult, allowing attackers to operate undetected for extended periods.

Recommendation

Implement the provided Sigma rule to detect unsigned DLLs loaded by svchost.exe, focusing on the specified file paths and code signature status.
Examine dll.Ext.relative_file_creation_time to identify DLLs created shortly before being loaded to catch newly created malicious files.
Review and validate the legitimacy of all DLLs loaded by svchost.exe, focusing on those located in unusual paths.
Update endpoint detection and response (EDR) systems to specifically monitor for the loading of unsigned DLLs by system processes like svchost.exe.
Continuously update the exclusion list of known good DLL hashes to reduce false positives.

Uncommon Destination Port Connection by Web Server on Linux

hello@craftedsignal.io — Tue, 09 Jan 2024 18:28:00 +0000

This detection rule focuses on identifying potentially malicious activity stemming from Linux-based web servers. The rule is triggered when a web server process, such as Apache, Nginx, or others, initiates an outbound network connection to a destination port that is considered non-standard. This activity can signal the presence of a web shell, a malicious script uploaded to a web server to enable remote access and control. Attackers may exploit compromised web servers to establish covert communication channels, exfiltrate data, or launch further attacks on internal systems. The rule leverages data from Elastic Defend to monitor network connections and filter out legitimate traffic based on a predefined list of common ports and internal IP ranges.

Attack Chain

Initial access is gained via exploitation of a vulnerability in a web application or web server component running on a Linux system (e.g., through SQL injection or remote code execution).
A web shell is uploaded to the compromised web server, often disguised as a legitimate file or hidden within existing directories.
The attacker interacts with the web shell through HTTP requests, using it as a command and control interface.
The web shell executes commands on the server, initiating outbound network connections to non-standard ports.
These connections may be used to communicate with external C2 servers, download additional payloads, or exfiltrate sensitive data.
The attacker uses the web shell to move laterally within the network, targeting other systems and services.
The attacker attempts to establish persistence on the compromised server, ensuring continued access even after system reboots.
The final objective is data theft, system compromise, or disruption of services.

Impact

Compromised web servers can lead to significant data breaches, system downtime, and reputational damage. While this rule triggers on low-severity behavior, successful exploitation can lead to complete system compromise. The number of affected systems depends on the scope of the initial vulnerability and the attacker’s ability to move laterally. Organizations in all sectors that rely on web-based applications are potentially at risk.

Recommendation

Deploy the provided Sigma rule to your SIEM to detect web server processes initiating connections to unusual destination ports and tune for your environment.
Enable Elastic Defend integration to collect the necessary network event data from Linux endpoints to activate the rule.
Review and customize the list of excluded destination ports and internal IP ranges in the Sigma rule to match your organization’s specific network configuration and legitimate traffic patterns.
Investigate any alerts generated by the rule to determine if the activity is malicious or benign, focusing on the process name, user, destination IP, and destination port.

Detecting External RPC Traffic for Initial Access

hello@craftedsignal.io — Tue, 09 Jan 2024 18:23:00 +0000

This detection rule identifies RPC traffic originating from the internet, which can indicate malicious activity. RPC is used for remote system administration and resource sharing but should rarely be exposed to the internet. Threat actors frequently target RPC for initial access or as a backdoor. This rule analyzes network traffic, specifically looking for TCP connections to port 135 (a common RPC port) originating from outside the internal network. The rule aims to detect unauthorized attempts to access or control systems via RPC from external sources, enhancing network security and preventing potential breaches. The rule was last updated on 2026-04-24.

Attack Chain

An attacker scans the internet for systems with exposed RPC services on TCP port 135.
The attacker establishes a TCP connection to the target system’s port 135.
The attacker attempts to negotiate an RPC connection, potentially exploiting vulnerabilities in the RPC service.
Successful exploitation allows the attacker to execute commands remotely on the target system.
The attacker uses the compromised system to perform reconnaissance, gathering information about the internal network.
The attacker attempts lateral movement to other systems within the network, using the initial foothold.
The attacker installs malware or creates a backdoor for persistent access.

Impact

Successful exploitation of exposed RPC services can lead to complete system compromise, allowing attackers to execute arbitrary commands, install malware, and steal sensitive data. This can result in data breaches, financial loss, and reputational damage. The rule aims to prevent attackers from gaining initial access to internal systems, mitigating the risk of wider network compromise.

Recommendation

Deploy the Sigma rule “Detect RPC from Internet” to your SIEM to identify potentially malicious connections to port 135.
Review and harden systems that provide RPC services to ensure they are not directly exposed to the internet, as detected by the rule “Detect RPC from Internet”.
Enforce network segmentation to limit the exposure of critical systems and services, preventing RPC services from being accessible from the Internet (reference: note section in the rule).
Investigate any alerts generated by the Sigma rule by examining the source and destination IP addresses and related network traffic logs (reference: note section in the rule).

Microsoft Build Engine Started by an Office Application

hello@craftedsignal.io — Tue, 09 Jan 2024 18:22:00 +0000

The Microsoft Build Engine (MSBuild) is a software build platform commonly used by Windows developers. When MSBuild is started by an Office application like Word or Excel, it deviates from typical usage patterns. This behavior can be indicative of a malicious document executing a script payload as part of a defense evasion tactic. Attackers may leverage MSBuild to execute code or perform actions that would otherwise be blocked or detected. This activity is particularly concerning because it can bypass traditional security measures that focus on blocking suspicious executables or scripts directly launched by Office applications. The rule was created in March 2020, and last updated in April 2026.

Attack Chain

A user opens a malicious Office document (e.g., Word, Excel, PowerPoint).
The Office document contains an embedded macro or exploit that triggers the execution of MSBuild.exe.
MSBuild.exe is launched as a child process of the Office application (e.g., winword.exe, excel.exe, powerpnt.exe).
MSBuild executes a project file or inline task specified in the command line. This can involve compiling code, executing scripts, or performing other actions.
The executed code or script performs malicious activities, such as downloading additional payloads, modifying system settings, or establishing persistence.
MSBuild may spawn child processes, such as cmd.exe, powershell.exe, or other utilities, to further execute malicious commands.
The attacker achieves their objective, which could include data exfiltration, installing malware, or gaining unauthorized access to the system.

Impact

Successful exploitation can lead to the execution of arbitrary code on the victim’s machine, potentially resulting in data theft, malware installation, or complete system compromise. Since MSBuild is a legitimate Microsoft tool, its use by malicious actors can make detection more challenging. The impact is high because it leverages a trusted process to carry out malicious activities, evading standard security measures.

Recommendation

Deploy the Sigma rule “Microsoft Build Engine Started by an Office Application” to your SIEM to detect this specific behavior based on process creation events.
Enable Sysmon process creation logging with the appropriate configuration to capture the necessary process start events for the Sigma rule to function correctly.
Investigate any alerts generated by the Sigma rule, focusing on the command-line arguments of MSBuild.exe and the parent process information, including the executable name and command line.
Monitor process execution events for MSBuild.exe with parent processes being Office applications as a high priority indicator of potential compromise.
Review and harden Office macro settings to prevent execution of malicious macros.

Potential Local NTLM Relay via HTTP

hello@craftedsignal.io — Tue, 09 Jan 2024 14:00:00 +0000

This detection identifies attempts to coerce local NTLM authentication over HTTP through WebDAV named-pipe paths, focusing on Print Spooler and SRVSVC. Attackers can exploit this vulnerability, often combined with tools like NTLMRelay2Self, PetitPotam, or modified versions of krbrelayx’s printerbug.py, to relay the obtained credentials and escalate their privileges within the network. This technique allows attackers to bypass traditional security measures by leveraging legitimate Windows protocols for malicious purposes. Successful exploitation can lead to domain dominance and unauthorized access to sensitive resources. This activity is often associated with post-exploitation activity following initial access via other means.

Attack Chain

An attacker gains initial access to a Windows system.
The attacker executes rundll32.exe to load davclnt.dll using the DavSetCookie function.
The rundll32.exe process is invoked with arguments specifying a named pipe path over HTTP, such as http*/print/pipe/*, http*/pipe/spoolss, or http*/pipe/srvsvc.
The system attempts to authenticate to the specified HTTP endpoint using NTLM.
The attacker intercepts the NTLM authentication request.
Using a relay tool like NTLMRelay2Self or ntlmrelayx, the attacker relays the captured NTLM credentials to another service or machine.
The attacker leverages the relayed credentials to escalate privileges or gain unauthorized access to network resources.
The attacker may then perform lateral movement, data exfiltration, or other malicious activities.

Impact

Successful exploitation allows attackers to escalate privileges within the compromised system and potentially the entire domain. This can lead to unauthorized access to sensitive data, deployment of ransomware, or other destructive activities. The impact ranges from data breaches and financial losses to complete system compromise. Depending on the targeted accounts, the attacker may be able to achieve domain administrator privileges.

Recommendation

Deploy the Sigma rule “Potential Local NTLM Relay via HTTP” to your SIEM to detect the execution of rundll32.exe with specific arguments indicative of NTLM relay attempts.
Enable Sysmon process creation logging to ensure the necessary data is available for the Sigma rule to function correctly.
Monitor network connections originating from processes that load davclnt.dll to identify potential NTLM relay traffic.
Investigate and block the usage of tools like NTLMRelay2Self, PetitPotam, and ntlmrelayx within the environment.
Implement mitigations for NTLM relay attacks, such as enabling Extended Protection for Authentication (EPA) and disabling NTLM where possible.
Review and restrict the usage of WebClient service and Print Spooler service where not required.

Persistence via Scheduled Job Creation

hello@craftedsignal.io — Tue, 09 Jan 2024 12:00:00 +0000

Adversaries may abuse scheduled tasks to maintain persistence on a compromised system. This involves creating or modifying scheduled tasks to execute malicious code at specific times or intervals. This activity can be used to ensure that the attacker’s code remains active even after a system restart or user logout. The detection rule identifies suspicious job creation by monitoring specific file paths and extensions, excluding known legitimate processes to flag potential abuse. The rule is designed for data generated by Elastic Defend, but also supports Microsoft Defender XDR, SentinelOne Cloud Funnel, and Sysmon.

Attack Chain

An attacker gains initial access to a Windows system (e.g., via phishing or exploiting a vulnerability).
The attacker attempts to establish persistence.
The attacker uses a script or program to create a new scheduled job within the C:\Windows\Tasks\ directory.
The scheduled job is configured to execute a malicious payload at a specified time or interval.
The malicious payload could be a script (e.g., PowerShell) or an executable.
The scheduled job executes, triggering the malicious payload.
The attacker maintains persistent access to the system.
The attacker performs malicious activities, such as data exfiltration or lateral movement.

Impact

Successful exploitation allows attackers to maintain a persistent presence on the compromised system. This allows them to execute malicious code, steal sensitive information, or perform other malicious activities over an extended period. The number of affected systems can vary depending on the scope of the initial compromise and the attacker’s objectives.

Recommendation

Enable Sysmon Event ID 11 (File Create) logging to monitor file creation events on Windows systems.
Deploy the Sigma rule “Detect Suspicious Scheduled Job Creation” to your SIEM and tune for your environment.
Investigate any alerts generated by the Sigma rule, focusing on scheduled jobs created in the C:\Windows\Tasks\ directory with a “.job” extension.
Review and update exclusion lists for known legitimate scheduled job creation processes (e.g., CCleaner, ManageEngine) to minimize false positives.

LSASS Process Access via Windows API

hello@craftedsignal.io — Tue, 09 Jan 2024 12:00:00 +0000

This rule identifies attempts to access the LSASS process via Windows API calls, specifically OpenProcess, OpenThread, and ReadProcessMemory. The Local Security Authority Subsystem Service (LSASS) is a critical Windows component responsible for managing user authentication and security policies. Attackers often target LSASS to dump credentials from memory for lateral movement and privilege escalation. This detection focuses on identifying unusual processes attempting to access the LSASS process, excluding common legitimate applications and directories. The rule leverages data from Elastic Defend and Microsoft Defender XDR to identify suspicious activity and provide defenders with actionable alerts.

Attack Chain

An attacker gains initial access to the target system through various means.
The attacker attempts to escalate privileges to gain administrative rights.
The attacker uses a custom tool or script to call the OpenProcess, OpenThread or ReadProcessMemory Windows APIs.
The tool targets the lsass.exe process to obtain a handle for memory access.
The attacker uses the obtained handle to read LSASS memory, searching for credential data.
The attacker extracts usernames, passwords, and other sensitive information from the dumped memory.
The attacker uses the stolen credentials for lateral movement to other systems on the network.
The attacker achieves their final objective, which may include data exfiltration or system compromise.

Impact

Successful exploitation can lead to the compromise of domain credentials, allowing attackers to move laterally within the network and gain access to sensitive resources. This can result in data breaches, system compromise, and significant financial or reputational damage. The rule aims to detect these attacks early, limiting the scope of the potential compromise.

Recommendation

Deploy the Sigma rule “LSASS API Access by Non-Standard Process” to your SIEM and tune for your environment to detect suspicious access to the LSASS process.
Investigate any alerts triggered by this rule, focusing on the process execution chain and the access rights requested as documented in the provided Microsoft documentation.
Enable process creation and API call logging via Elastic Defend or Microsoft Defender XDR to provide the necessary data for this detection.
Review and harden LSASS protection mechanisms such as Credential Guard to minimize the risk of successful credential dumping.
Implement the Osquery queries to gather system information like DNS cache, services, and unsigned executables, to aid in investigation and threat hunting.

Suspicious WerFault Child Process Abuse

hello@craftedsignal.io — Tue, 09 Jan 2024 10:00:00 +0000

This detection identifies suspicious child processes spawned by WerFault.exe, the Windows Error Reporting tool. Attackers can abuse WerFault by manipulating the SilentProcessExit registry key to execute malicious processes. This technique allows for defense evasion, persistence, and privilege escalation. The detection focuses on WerFault processes with specific command-line arguments (-s, -t, and -c) known to be used in SilentProcessExit exploitation, while excluding legitimate executables like Initcrypt.exe and Heimdal.Guard.exe. The rule helps defenders identify potential attempts to hijack the error reporting mechanism for malicious purposes. The monitored data sources include Windows Event Logs, Sysmon, Elastic Defend, Microsoft Defender XDR, and SentinelOne.

Attack Chain

An attacker gains initial access to the system (e.g., via phishing or exploiting a vulnerability).
The attacker modifies the SilentProcessExit registry key to specify a malicious process to be executed when a target application crashes. This involves setting the ReportingMode and Debugger values under the SilentProcessExit key for the target application.
The attacker triggers a crash in the target application or waits for a legitimate crash to occur.
WerFault.exe is invoked to handle the application crash.
Due to the registry modification, WerFault.exe spawns the attacker-controlled process, passing command-line arguments such as -s, -t, and -c.
The attacker-controlled process executes with the privileges of WerFault.exe, potentially achieving privilege escalation.
The malicious process performs actions such as injecting code into other processes, establishing persistence, or exfiltrating data.
The attacker achieves their objectives, such as maintaining persistence, escalating privileges, or evading detection.

Impact

A successful attack can lead to persistence, privilege escalation, and defense evasion. Attackers can use this technique to execute malicious code with elevated privileges, potentially bypassing security controls and gaining unauthorized access to sensitive data and system resources. The number of victims and affected sectors can vary depending on the attacker’s objectives and the scope of the initial compromise.

Recommendation

Enable Sysmon process creation logging to capture WerFault.exe child processes (Data Source: Sysmon).
Deploy the Sigma rule “WerFault Child Process Masquerading” to your SIEM and tune for your environment.
Review the SilentProcessExit registry key for unauthorized modifications (registry_set event).
Investigate any WerFault.exe processes with command-line arguments -s, -t, and -c (process_creation event).

Potential LSASS Clone Creation via PssCaptureSnapShot

hello@craftedsignal.io — Tue, 09 Jan 2024 10:00:00 +0000

This detection identifies the creation of an LSASS process clone via PssCaptureSnapShot on Windows systems. The rule focuses on scenarios where the parent process of the new LSASS instance is also lsass.exe. This behavior is often associated with attackers attempting to bypass security controls and dump LSASS memory to extract credentials. The technique is used to evade detection mechanisms that monitor the primary LSASS process. Successful exploitation can lead to the compromise of domain or local credentials stored in memory, allowing for lateral movement and privilege escalation within the network. The detection is based on Windows Security Event Logs, specifically event code 4688, and is designed to identify this specific cloning behavior.

Attack Chain

The attacker gains initial access to the system (e.g., through phishing or exploiting a vulnerability).
The attacker executes code on the target system, potentially using tools like PowerShell or command-line utilities.
The attacker initiates a process to clone the LSASS process using PssCaptureSnapShot.
The newly created process, a clone of LSASS, runs alongside the original.
The attacker leverages the cloned LSASS process to dump its memory. This may involve tools like comsvcs.dll, rundll32.exe or custom scripts leveraging the MiniDumpWriteDump function.
The attacker extracts sensitive information from the dumped memory, including usernames, passwords, and Kerberos tickets.
The attacker uses the extracted credentials to move laterally within the network, accessing additional systems and resources.
The attacker achieves their final objective, such as data exfiltration or deploying ransomware.

Impact

Successful exploitation can result in the compromise of sensitive credentials stored in LSASS memory, including domain and local account credentials. This can lead to unauthorized access to critical systems and data, potentially resulting in data breaches, financial loss, and reputational damage. Domain controllers, jump hosts, and systems with privileged accounts are at especially high risk. The number of affected systems can range from a single machine to a large portion of the network, depending on the attacker’s objectives and the scope of the compromised credentials.

Recommendation

Enable and monitor Windows Security Event Logs with event code 4688 for process creation events, specifically focusing on the process and parent process names to identify LSASS cloning attempts (see rule below).
Deploy the provided Sigma rule to your SIEM to detect potential LSASS clone creation via PssCaptureSnapShot. Tune the rule for your environment to reduce false positives.
Investigate any alerts generated by the Sigma rule, focusing on identifying the processes involved in cloning and dumping LSASS memory.
Enable Audit Process Creation and Command Line logging as per the Elastic documentation to ensure the events used by the provided Sigma rules are captured.
If a LSASS clone is detected, review authentication events (4624, 4648, 4625) on the affected host to identify any suspicious logons or credential usage.
Monitor for file activity related to memory dumps (e.g., .dmp files) using the process clone to identify potential credential theft attempts.

Detection of Custom Shim Database Installation for Persistence

hello@craftedsignal.io — Tue, 09 Jan 2024 10:00:00 +0000

Attackers can exploit the Windows Application Compatibility Shim functionality to maintain persistence and execute arbitrary code within legitimate Windows processes. This is achieved by installing custom shim databases, which are designed to ensure older applications run smoothly on newer operating systems. By manipulating these databases, attackers can stealthily inject malicious code into trusted processes. The rule detects changes in specific registry paths associated with the installation of these databases, excluding known legitimate processes to minimize false positives. This technique allows for the execution of malicious code without directly modifying the target application’s executable, making it difficult to detect with traditional methods.

Attack Chain

The attacker gains initial access to the system (e.g., via phishing or exploiting a vulnerability).
The attacker modifies the registry to create a new entry for a custom shim database. The registry path targeted is typically under HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Custom\.
The attacker writes a malicious .sdb file containing the custom shim database to a location on disk.
The registry entry created points to the malicious .sdb file.
When a targeted application is launched, Windows checks the AppCompatFlags registry keys.
The system loads the malicious shim database specified in the registry.
The malicious code within the shim database is executed in the context of the targeted application.
The attacker achieves persistence, as the malicious shim database is loaded every time the targeted application is run.

Impact

Successful exploitation allows attackers to maintain persistent access to the system, even after reboots or software updates. The injected code runs within the context of a legitimate process, which can evade detection by traditional security tools. This can lead to data theft, system compromise, or further malicious activities, such as lateral movement within the network. The use of application shimming for persistence affects systems running Windows and can impact organizations of any size or sector.

Recommendation

Deploy the Sigma rule Detect Custom Shim Database Installation to your SIEM to identify suspicious registry modifications related to application shimming.
Enable Sysmon registry event logging to ensure the necessary data is available for the Sigma rule to function.
Investigate any alerts generated by the Sigma rule, focusing on processes that are not in the exclusion list.
Block or quarantine any identified malicious .sdb files to prevent further execution.
Review and update the exclusion list in the Sigma rule with any newly identified legitimate applications that use shim databases, reducing false positives.

Potential Privilege Escalation in Container via Runc Init

hello@craftedsignal.io — Fri, 05 Jan 2024 14:22:00 +0000

This detection identifies a potential privilege escalation vulnerability within container environments utilizing runc, the low-level container runtime used by Docker and containerd. The rule focuses on audit events triggered by runc init child processes. Specifically, it flags instances where the effective user ID is root (0), while the login user ID is not root. This discrepancy can indicate malicious activity, such as exploiting credential separation or namespace transitions to gain unauthorized root privileges within the container or escape to the host. This is relevant for defenders because a compromised container can lead to host compromise, data exfiltration, or denial of service.

Attack Chain

Attacker gains initial access to a container with limited privileges.
The attacker exploits a vulnerability within the container to execute code as the runc init process.
The runc init process spawns a child process while retaining a non-root user ID in audit telemetry.
The child process is assigned an effective user ID of 0 (root), bypassing normal permission controls.
The attacker leverages the elevated privileges to modify sensitive files or execute commands as root within the container’s namespace.
The attacker may then attempt to escape the container by exploiting kernel vulnerabilities or misconfigurations to gain access to the host system.
Upon gaining access to the host system, the attacker can install malware, steal sensitive data, or disrupt services.

Impact

A successful privilege escalation attack within a container environment can lead to complete compromise of the container and potentially the host system. This can result in data breaches, service disruptions, and unauthorized access to sensitive resources. The impact is significant because a single compromised container can become a launchpad for attacks against other containers or the underlying infrastructure.

Recommendation

Deploy the Sigma rule “Potential Privilege Escalation via Runc Init” to your SIEM to detect suspicious runc init process executions.
Enable Linux audit logging via the Auditd Manager integration, ensuring that execve and identity-related fields are captured.
Investigate any alerts generated by the Sigma rule by examining the full audit event details, including process ancestry, user IDs, and container metadata.
Review container configurations and security profiles to identify potential misconfigurations that could facilitate privilege escalation.
Implement network segmentation to limit the blast radius of a compromised container.

Suspicious PDF Reader Child Process Activity

hello@craftedsignal.io — Thu, 04 Jan 2024 18:45:00 +0000

Attackers are increasingly leveraging PDF reader applications as an initial access vector, exploiting vulnerabilities within these programs or using social engineering to trick users into opening malicious PDF documents. Upon successful exploitation, adversaries often spawn built-in Windows utilities from the compromised PDF reader process to perform reconnaissance, escalate privileges, or establish persistence. This activity is designed to blend in with normal system operations, making it difficult to detect without specific monitoring and detection rules. The targeted software commonly includes Adobe Acrobat, Adobe Reader, and Foxit Reader. Defenders should be vigilant for unexpected child processes of PDF readers, especially command-line interpreters and system administration tools.

Attack Chain

A user receives a malicious PDF document via phishing or other means.
The user opens the PDF document using a vulnerable PDF reader application (e.g., Adobe Acrobat, Foxit Reader).
The PDF document exploits a vulnerability or uses a malicious script to execute an arbitrary command.
The PDF reader application spawns a command-line interpreter (e.g., cmd.exe, powershell.exe) or a system administration tool (e.g., reg.exe, net.exe).
The spawned process executes commands to gather system information (e.g., ipconfig.exe, systeminfo.exe, whoami.exe).
The attacker may attempt to discover network configuration, user accounts, or running processes.
The attacker could leverage the spawned process to download and execute further payloads.
The attacker gains a foothold on the system and can proceed with lateral movement, data exfiltration, or other malicious activities.

Impact

Successful exploitation of PDF reader applications can lead to initial access, privilege escalation, and further compromise of the affected system. While individual incidents may have a low risk score, widespread exploitation can lead to significant data breaches, system downtime, and reputational damage. The use of legitimate system utilities for malicious purposes can make detection challenging, allowing attackers to operate undetected for extended periods.

Recommendation

Enable process creation logging with command line arguments to capture the execution of suspicious child processes (Sysmon Event ID 1, Windows Security Event Logs).
Deploy the Sigma rule “Suspicious PDF Reader Child Process” to your SIEM and tune for your environment to detect the execution of suspicious processes spawned by PDF reader applications.
Monitor for network connections originating from PDF reader applications to unusual or external IP addresses.
Implement application control policies to restrict the execution of unauthorized or unknown executables.

Detection of Downloaded URL Files Used in Phishing Campaigns

hello@craftedsignal.io — Thu, 04 Jan 2024 17:49:12 +0000

Attackers commonly use .url shortcut files in phishing campaigns to deliver malicious payloads. These files, when downloaded from non-local sources, may bypass traditional security measures. This detection rule identifies such files by monitoring their creation events on Windows systems. The rule focuses on files with the .url extension and a zone identifier indicating they originated from outside the local network. These files are often delivered via email or malicious websites, tricking users into clicking them, which can lead to the execution of arbitrary commands or the redirection to malicious websites. This technique allows attackers to gain initial access or execute malicious code on the victim’s machine.

Attack Chain

The attacker crafts a phishing email or a malicious website containing a link to a .url file.
The victim clicks the link, resulting in the download of the .url file to their Windows system.
The .url file is created on the filesystem, triggering a file creation event.
The operating system assigns a Zone Identifier to the file, marking it as originating from an external source.
The victim double-clicks the .url file, which contains a URL pointing to a malicious website or an executable.
The operating system attempts to open the URL using the default web browser or execute the embedded command.
If the URL points to a malicious website, the victim may be prompted to download and execute malware.
The malware executes, potentially leading to system compromise, data theft, or other malicious activities.

Impact

Successful exploitation can lead to the execution of arbitrary commands, redirection to malicious websites, and subsequent malware infection. If successful, attackers can compromise user systems, steal sensitive information, or establish a foothold for further malicious activities within the organization’s network. The impact can range from individual system compromise to broader network breaches, depending on the attacker’s objectives and the extent of the infection.

Recommendation

Deploy the Sigma rule Downloaded URL Files Created to your SIEM to detect the creation of downloaded .url files with a non-local Zone Identifier and tune for your environment.
Investigate any file creation events where file.extension == "url" and file.Ext.windows.zone_identifier == 3 using the provided investigation steps in the advisory.
Update security policies and endpoint protection configurations to block the download and execution of .url files from untrusted sources, as mentioned in the advisory.
Educate users on safe downloading practices and the risks associated with opening .url files from untrusted sources, as highlighted in the advisory’s false positive analysis.

Unusual Service Host Child Process - Childless Service

hello@craftedsignal.io — Thu, 04 Jan 2024 12:00:00 +0000

The Windows Service Host process (svchost.exe) is a critical system component that hosts multiple Windows services to optimize resource utilization. Certain services running under svchost.exe are not expected to spawn child processes. Attackers may inject malicious code into these “childless” svchost processes to execute unauthorized commands and evade traditional detection methods. This detection rule identifies anomalies by monitoring child processes of svchost.exe instances associated with services known to be childless, such as WdiSystemHost, LicenseManager, and StorSvc, flagging potential process injection or exploitation attempts. The rule aims to identify deviations from the expected behavior of these services, providing an early warning of potential malicious activity.

Attack Chain

Attacker gains initial access to the system through an exploit or by leveraging existing credentials.
The attacker injects malicious code into a running svchost.exe process associated with a childless service like WdiSystemHost or StorSvc.
The injected code spawns a child process from the targeted svchost.exe instance. This could involve executing a system utility or a custom payload.
The child process executes commands or performs actions dictated by the injected code, such as establishing a reverse shell or downloading additional payloads.
The attacker uses the spawned process to perform reconnaissance activities, gathering information about the system and network.
The attacker escalates privileges, potentially leveraging vulnerabilities or misconfigurations accessible from the compromised svchost process.
The attacker moves laterally to other systems on the network, using the compromised system as a pivot point.
The attacker achieves their final objective, which may include data exfiltration, ransomware deployment, or establishing persistent access.

Impact

Successful exploitation can lead to privilege escalation, allowing attackers to gain control of the compromised system and potentially the entire network. Attackers can use the compromised system as a staging ground for further attacks, exfiltrate sensitive data, deploy ransomware, or disrupt critical services. The medium severity score reflects the potential for significant impact if the activity is not detected and contained promptly.

Recommendation

Deploy the Sigma rule Unusual Svchost Child Process - Childless Service to your SIEM to detect potential process injection attacks targeting svchost.exe.
Tune the rule by adding known false positives to the exclusion list, such as WerFault.exe, WerFaultSecure.exe, and wermgr.exe to reduce alert fatigue.
Enable process creation logging via Sysmon (Event ID 1) with command line details for better visibility into spawned processes, as described in the setup guide.
Investigate any alerts generated by the rule, focusing on the process details and parent-child relationships to determine the legitimacy of the spawned process.
Consider using endpoint detection and response (EDR) solutions like Elastic Defend for enhanced visibility and automated response capabilities, as the rule is designed for data generated by Elastic Defend.

UAC Bypass via DiskCleanup Scheduled Task Hijack

hello@craftedsignal.io — Thu, 04 Jan 2024 12:00:00 +0000

This rule identifies User Account Control (UAC) bypass attempts via hijacking the DiskCleanup Scheduled Task. Attackers exploit this method to execute code with elevated privileges, bypassing standard security controls. The technique involves leveraging the cleanmgr.exe or taskhostw.exe executables with specific arguments (/autoclean and /d) outside of their expected paths. This allows attackers to run malicious code under the guise of a legitimate system process, making detection more challenging. This technique is used to gain elevated privileges on a compromised system, allowing for further malicious activities.

Attack Chain

An attacker gains initial access to the system (e.g., via phishing or exploiting a software vulnerability).
The attacker modifies or creates a scheduled task to execute cleanmgr.exe or taskhostw.exe with the /autoclean and /d arguments.
The modified scheduled task is triggered, executing the specified executable with the supplied arguments.
The executable, such as cleanmgr.exe, attempts to run Disk Cleanup.
If the executable path is outside the standard locations (e.g., C:\\Windows\\System32 or C:\\Windows\\SysWOW64), it indicates a potential hijack.
Malicious code is executed with elevated privileges due to the UAC bypass.
The attacker uses these elevated privileges to install malware, modify system settings, or perform other malicious activities.

Impact

Successful exploitation allows attackers to bypass User Account Control (UAC) and execute code with elevated privileges. This can lead to the installation of malware, modification of system settings, data theft, and other malicious activities. While the exact number of victims is unknown, this technique is effective on systems where UAC is enabled but misconfigured or vulnerable.

Recommendation

Deploy the Sigma rule “UAC Bypass via DiskCleanup with Suspicious Path” to your SIEM and tune for your environment to detect UAC bypass attempts.
Deploy the Sigma rule “UAC Bypass via DiskCleanup and Taskhostw” to your SIEM to detect UAC bypass attempts.
Monitor process creation events for cleanmgr.exe and taskhostw.exe with the /autoclean and /d arguments, focusing on executions outside the standard system directories.
Review and harden scheduled tasks to prevent unauthorized modifications.
Ensure that UAC settings are properly configured and enforced across the organization.

Disable Windows Event and Security Logs Using Built-in Tools

hello@craftedsignal.io — Thu, 04 Jan 2024 10:00:00 +0000

Attackers often disable Windows Event and Security Logs to evade detection on compromised systems. This activity involves tampering with, clearing, and deleting event log data to break SIEM detections, cover their tracks, and slow down incident response. The methods employed include using the logman utility, PowerShell commands to disable the EventLog service, or auditpol to disable auditing. These actions are typically performed after initial access and privilege escalation to hinder forensic investigations and maintain persistence within the environment. Defenders should monitor for these specific tools and command-line arguments to identify potential attempts to disable logging.

Attack Chain

The attacker gains initial access to the system, possibly through phishing or exploiting a vulnerability.
The attacker escalates privileges to administrator level to gain the necessary permissions to modify event logging settings.
The attacker uses logman.exe with arguments to stop or delete EventLog traces (e.g., logman.exe stop EventLog-*, logman.exe delete EventLog-*).
Alternatively, the attacker uses PowerShell with Set-Service cmdlet to disable the EventLog service (e.g., powershell.exe Set-Service EventLog -StartupType Disabled).
The attacker can also use auditpol.exe to disable auditing policies, preventing future events from being logged (e.g., auditpol.exe /success:disable).
After disabling logging, the attacker performs malicious activities such as lateral movement, data exfiltration, or malware deployment, with a reduced risk of detection.
The attacker removes traces of their activity from other logs if possible.
The attacker maintains persistence and continues to exploit the compromised environment.

Impact

Successful disabling of Windows Event and Security Logs can severely hinder incident response and forensic investigations. The absence of log data makes it difficult to detect ongoing malicious activity, understand the scope of the compromise, and attribute the attack. This can lead to prolonged dwell time for attackers, increased data exfiltration, and greater overall damage to the organization.

Recommendation

Deploy the Sigma rule “Disable Windows Event and Security Logs Using Built-in Tools” to your SIEM to detect the execution of logman.exe, PowerShell, and auditpol.exe with specific arguments related to disabling event logs.
Monitor process creation events for logman.exe, powershell.exe, pwsh.exe, powershell_ise.exe, and auditpol.exe with command-line arguments that indicate an attempt to disable event logging.
Enable Sysmon process creation logging to capture detailed command-line arguments for process monitoring.
Regularly review and audit Group Policy settings related to event logging to prevent unauthorized modifications.
Monitor for changes to the EventLog service configuration, including startup type and status, using system monitoring tools.

Incoming Execution via PowerShell Remoting

hello@craftedsignal.io — Wed, 03 Jan 2024 18:53:23 +0000

This detection identifies potential lateral movement through the exploitation of Windows PowerShell remoting. PowerShell remoting is a feature that enables administrators and attackers to execute commands on remote Windows systems. The detection focuses on identifying incoming network connections on ports 5985 (HTTP) and 5986 (HTTPS), the default ports used for PowerShell Remoting, followed by the execution of processes spawned by wsmprovhost.exe, the Windows Remote Management process host. This activity, when originating from unexpected sources, may indicate unauthorized access and lateral movement within a network. The rule is designed to detect suspicious activity by monitoring network traffic and process execution, flagging potential unauthorized remote executions, and enabling security teams to respond swiftly.

Attack Chain

An attacker gains initial access to a network, possibly through phishing or exploiting a vulnerability on an internet-facing system.
The attacker leverages PowerShell remoting to initiate a connection to a target system on ports 5985 or 5986.
The target system accepts the incoming PowerShell Remoting connection.
The wsmprovhost.exe process is launched on the target system to facilitate the remote PowerShell session.
The attacker executes commands remotely, spawning child processes from wsmprovhost.exe.
The attacker attempts to escalate privileges or move laterally to other systems within the network using the remote PowerShell session.
The attacker uses tools such as net.exe or PsExec over the remote PowerShell session to further propagate.
The attacker achieves their objective, such as data exfiltration or deploying ransomware, by leveraging the established remote session.

Impact

Successful exploitation of PowerShell Remoting for lateral movement can lead to widespread compromise within an organization. An attacker could gain control over multiple systems, potentially leading to data breaches, system outages, or ransomware deployment. The number of affected systems could range from a few critical servers to a significant portion of the network, depending on the attacker’s objectives and the organization’s security posture. The impact could include financial losses, reputational damage, and disruption of business operations.

Recommendation

Deploy the Sigma rule Incoming Execution via PowerShell Remoting to your SIEM to detect suspicious PowerShell remoting activity and tune for your environment.
Monitor network connections to ports 5985 and 5986, and investigate any unauthorized or unexpected traffic using the network_connection log source.
Investigate processes spawned by wsmprovhost.exe for unusual or malicious activity using the process_creation log source.
Whitelist authorized administrative IP addresses or user accounts that frequently perform remote management tasks, as mentioned in the false positives analysis.
Review and document automated scripts or scheduled tasks that use PowerShell Remoting for system maintenance, then create exceptions for their specific process names or execution paths.

Process Activity via Compiled HTML File Execution

hello@craftedsignal.io — Wed, 03 Jan 2024 18:30:00 +0000

Attackers are known to deliver malicious payloads within compiled HTML files (.chm) to bypass security measures and gain initial access to systems. This technique leverages the Microsoft HTML Help system and its associated executable, hh.exe, to proxy the execution of malicious code. Compiled HTML files can contain various types of content, including HTML documents, images, and scripting languages like VBA, JScript, Java, and ActiveX. By embedding malicious scripts or executables within a .chm file, attackers can trick users into executing them when they open the file. This is particularly effective because hh.exe is a signed binary, which may allow it to bypass certain security controls. The scope of this technique affects Windows systems where the HTML Help system is installed.

Attack Chain

The attacker crafts a malicious .chm file containing embedded malicious code, such as a PowerShell script or executable.
The attacker delivers the .chm file to the victim via social engineering, such as phishing or malicious websites.
The victim opens the .chm file, causing hh.exe to launch.
hh.exe processes the .chm file, rendering its content, which includes the embedded malicious script or executable.
The malicious code executes, often spawning a scripting interpreter like powershell.exe or cmd.exe.
The scripting interpreter executes commands to download additional payloads or perform malicious actions on the system.
The attacker gains initial access to the victim’s system.
The attacker escalates privileges and moves laterally within the network.

Impact

Successful exploitation can lead to initial access, code execution, and potentially full system compromise. This can result in data theft, malware installation, and further lateral movement within the network. The severity and impact depend on the permissions of the user running hh.exe and the nature of the malicious payload.

Recommendation

Deploy the Sigma rule “Compiled HTML File Spawning Suspicious Processes” to your SIEM to detect instances where hh.exe is the parent process of scripting interpreters.
Enable Sysmon process creation logging to provide the necessary data for the Sigma rule to function correctly.
Monitor process execution chains for unknown processes originating from hh.exe, as mentioned in the investigation guide.
Implement email filtering and security awareness training to prevent users from opening malicious .chm files delivered via phishing.
Block the execution of unsigned or untrusted executables in the environment to reduce the risk of malicious code execution.
Use endpoint detection and response (EDR) solutions like Elastic Defend, CrowdStrike, Microsoft Defender XDR, and SentinelOne to detect and respond to malicious activity.

Detection of Downloaded Shortcut Files

hello@craftedsignal.io — Wed, 03 Jan 2024 18:22:32 +0000

This detection identifies suspicious .lnk files created on Windows systems, especially those downloaded from external sources, which may indicate potential phishing attempts. The rule leverages file creation events and zone identifiers to trace the file’s origin. Adversaries exploit shortcut files by embedding malicious commands within them, often distributing these files via phishing campaigns. This can lead to arbitrary code execution upon user interaction. The rule is designed for data generated by Elastic Defend.

Attack Chain

User receives a phishing email containing a malicious .lnk file.
The user downloads the .lnk file to their Windows system.
The Windows OS marks the file with a Zone Identifier indicating it came from an external source.
The user double-clicks the .lnk file, triggering its execution.
The .lnk file executes embedded commands, such as PowerShell or cmd.exe.
The command downloads and executes a malicious payload from a remote server.
The payload establishes persistence on the compromised system.
The attacker gains remote access and control over the infected host.

Impact

A successful attack can lead to the compromise of the user’s system, potentially resulting in data theft, malware installation, or further propagation of the attack within the network. The severity of the impact depends on the privileges of the compromised user account and the attacker’s objectives. The rule aims to detect and prevent such attacks early in the attack chain, reducing the potential damage.

Recommendation

Deploy the Sigma rule “Downloaded Shortcut Files” to your SIEM and tune for your environment.
Enable Elastic Defend to capture the necessary file creation events for the rule to function.
Investigate any alerts generated by the rule, paying close attention to the file path, zone identifier, and associated user account.
Update security policies to restrict the execution of .lnk files from untrusted sources.
Educate users about the risks of opening suspicious attachments, especially .lnk files, to prevent initial access.

Symbolic Link Creation to Shadow Copies for Credential Access

hello@craftedsignal.io — Wed, 03 Jan 2024 18:15:00 +0000

This rule identifies the creation of symbolic links to shadow copies on Windows systems. Attackers use this technique to gain access to sensitive files stored within shadow copies, including the ntds.dit file (containing password hashes), system boot keys, and browser offline credentials. This approach allows them to bypass normal file access controls and extract credentials for lateral movement or privilege escalation. The detection rule is designed to ingest data from various sources, including Elastic Defend, CrowdStrike, Microsoft Defender XDR, SentinelOne Cloud Funnel, Sysmon, and Windows Security Event Logs, providing broad coverage across different endpoint security solutions. The activity is typically initiated by command-line tools like cmd.exe or powershell.exe, making detection through process monitoring feasible. This technique is particularly relevant as it targets credential dumping, a critical stage in many attack campaigns.

Attack Chain

An attacker gains initial access to a Windows system, possibly through phishing or exploitation of a vulnerability.
The attacker elevates privileges to gain administrative rights, which are required to create shadow copies and symbolic links.
The attacker creates a volume shadow copy using vssadmin.exe or similar tools.
The attacker uses mklink command or PowerShell New-Item -ItemType SymbolicLink to create a symbolic link to the shadow copy path.
The symbolic link points to a directory within the shadow copy containing sensitive files like ntds.dit or browser credential stores.
The attacker copies the targeted sensitive files (e.g., ntds.dit) from the shadow copy using the symbolic link.
The attacker removes the shadow copy to cover their tracks, although the symbolic link creation remains as evidence.
The attacker extracts credentials from the copied ntds.dit file offline for use in lateral movement or further attacks.

Impact

Successful exploitation allows attackers to gain unauthorized access to sensitive credentials stored on the compromised system. This can lead to lateral movement within the network, privilege escalation, and ultimately, the compromise of critical assets. If the ntds.dit file is accessed, the entire Active Directory domain could be at risk, potentially affecting thousands of users and systems. This type of attack is particularly damaging as it allows attackers to operate undetected for extended periods while they harvest credentials.

Recommendation

Deploy the provided Sigma rule “Symbolic Link to Shadow Copy Created via Cmd” to detect the creation of symbolic links to shadow copies via cmd.exe (rules).
Deploy the provided Sigma rule “Symbolic Link to Shadow Copy Created via PowerShell” to detect the creation of symbolic links to shadow copies via powershell.exe (rules).
Enable Sysmon Event ID 1 (Process Creation) logging to provide necessary data for the Sigma rules to function correctly (setup).
Review the “Investigating Symbolic Link to Shadow Copy Created” section in the rule’s notes for triage and analysis steps when the rule triggers.
Monitor for the usage of mklink command with the HarddiskVolumeShadowCopy argument in process command lines.

InstallUtil Process Making Network Connections for Defense Evasion

hello@craftedsignal.io — Wed, 03 Jan 2024 18:15:00 +0000

InstallUtil.exe is a legitimate Windows utility used for installing and uninstalling server resources. Adversaries abuse InstallUtil.exe to execute malicious code under the guise of legitimate processes, often to evade detection. This technique allows attackers to proxy execution through a trusted system binary, potentially bypassing application control and security monitoring. The detection rule identifies suspicious network activity by monitoring InstallUtil.exe’s outbound connections, flagging potential misuse by alerting on the initial network connection attempt. This activity is detected via the Elastic EQL rule “InstallUtil Process Making Network Connections.”

Attack Chain

An attacker gains initial access through an undisclosed method.
The attacker uses InstallUtil.exe to execute a malicious .NET assembly.
InstallUtil.exe loads the malicious assembly into its process.
The malicious assembly executes code that establishes an outbound network connection.
The connection is used for command and control (C2) or data exfiltration.
The attacker may use the C2 channel to download and execute further payloads.
The attacker performs lateral movement within the network.
The attacker achieves their objective, such as data theft or system compromise.

Impact

Successful exploitation can lead to arbitrary code execution within the context of a trusted Windows process (InstallUtil.exe), bypassing application control and potentially evading detection. This could result in a compromised system, data exfiltration, or further malicious activities within the network. The scope of impact depends on the attacker’s objectives and the level of access gained, potentially affecting entire organizations.

Recommendation

Enable process creation logging and network connection logging via Sysmon or Elastic Defend to provide the data needed for the rules below.
Deploy the Sigma rule “InstallUtil Network Connection” to your SIEM and tune for your environment to detect suspicious outbound network connections from InstallUtil.exe.
Investigate any alerts triggered by the Sigma rule by examining the parent process of InstallUtil.exe, destination IP addresses, and associated activities.
Implement network monitoring and alerting for unusual outbound connections from critical systems to enhance detection of similar threats in the future.

Browser Process Spawned from an Unusual Parent

hello@craftedsignal.io — Wed, 03 Jan 2024 18:15:00 +0000

This detection identifies instances where a browser process, specifically Google Chrome or Microsoft Edge, is initiated from an unexpected parent process on a Windows system. The rule focuses on scenarios where browsers are launched with arguments indicative of remote debugging, headless automation, or minimal user interaction. Such activity can signal an attempt to manipulate a browser session for malicious purposes, potentially leading to credential theft or unauthorized access to sensitive information. The rule is designed to leverage data from Elastic Defend, Microsoft Defender XDR, SentinelOne Cloud Funnel, Sysmon, and Windows Process Creation Logs.

Attack Chain

An attacker gains initial access to a Windows system (e.g., via phishing or exploiting a vulnerability).
The attacker executes a script or command to launch a browser process (chrome.exe or msedge.exe).
The browser is launched with specific command-line arguments, such as --remote-debugging-port, --headless, or --window-position=-x,-y, to enable remote control or hide the browser window.
The parent process of the browser is an unusual executable, not typically associated with launching browsers (e.g., not explorer.exe).
The attacker leverages the remote debugging port to interact with the browser session programmatically.
The attacker attempts to steal credentials or session cookies from the browser.
The attacker uses stolen credentials to access sensitive data.

Impact

Successful exploitation can lead to the theft of user credentials, enabling unauthorized access to sensitive data and systems. This could result in financial loss, data breaches, and reputational damage for affected organizations. The targeted use of browser manipulation techniques increases the likelihood of bypassing traditional security controls.

Recommendation

Deploy the Sigma rule Browser Process Spawned from Unusual Parent to your SIEM and tune for your environment.
Enable Sysmon process-creation logging (Event ID 1) to collect the necessary data for the Sigma rule.
Investigate any alerts generated by the Browser Process Spawned from Unusual Parent Sigma rule.
Review process command lines for arguments like --remote-debugging-port or --headless to identify potential browser manipulation attempts.
Monitor network connections originating from browser processes for unexpected destinations, as described in the investigation guide from the source.

Third-party Backup Files Deleted via Unexpected Process

hello@craftedsignal.io — Wed, 03 Jan 2024 18:12:00 +0000

This rule identifies the deletion of backup files, specifically those created by Veeam and Veritas Backup Exec, through unexpected processes on Windows systems. The rule aims to detect potential attempts to inhibit system recovery by adversaries, particularly in the context of ransomware attacks. Attackers often target backup files to eliminate recovery options for victims. This detection focuses on identifying file deletion events where the process responsible for the deletion does not belong to the trusted backup software suite. The rule excludes known legitimate processes and directories like Trend Micro’s, Microsoft Exchange Mailbox Assistants, and the Recycle Bin to minimize false positives. The original Elastic detection rule was created in October 2021 and last updated May 4, 2026.

Attack Chain

Adversary gains initial access to the target Windows system.
The attacker performs reconnaissance to identify backup file locations.
The attacker uses a non-backup related process (e.g., cmd.exe, powershell.exe) to delete backup files.
The attacker targets Veeam backup files with extensions VBK, VIB, and VBM.
The attacker targets Veritas Backup Exec files with the BKF extension.
The deletion events are logged by the endpoint detection system.
The detection rule triggers, identifying the anomalous deletion activity based on file extension and process context.
Successful deletion of backups impairs the victim’s ability to recover from ransomware or other destructive attacks.

Impact

Successful deletion of backup files can severely impact an organization’s ability to recover from a ransomware attack or other data loss events. Without viable backups, the victim organization may be forced to pay a ransom or face significant data loss and business disruption. This tactic directly increases the attacker’s leverage and potential financial gain. The rule’s documentation cites a report from AdvIntel detailing backup removal solutions seen with Conti ransomware.

Recommendation

Deploy the Sigma rule Unexpected Veeam Backup File Deletion to your SIEM and tune for your environment to detect unexpected deletion of Veeam backup files.
Deploy the Sigma rule Unexpected Veritas Backup File Deletion to your SIEM and tune for your environment to detect unexpected deletion of Veritas Backup Exec files.
Investigate any alerts generated by these rules to determine the source of the deletion and assess potential impact.
Enable endpoint file event logging to capture file deletion events, which are crucial for the Sigma rules.
Review process execution chains (parent process tree) for unknown processes to identify the root cause of unexpected file deletions.

Windows Account Discovery of Administrator Accounts

hello@craftedsignal.io — Wed, 03 Jan 2024 17:14:00 +0000

Attackers often perform reconnaissance activities within a compromised environment to understand the available resources and potential targets. This reconnaissance helps them plan subsequent actions, such as privilege escalation and lateral movement. This activity involves using built-in Windows utilities like net.exe and wmic.exe to enumerate administrator-related user accounts and groups. This information can reveal potential targets for credential compromise or other post-exploitation activities. Lower privileged accounts commonly perform this enumeration.

Attack Chain

The attacker gains initial access to a Windows system.
The attacker executes net.exe with arguments to list users and groups.
The attacker filters the output for administrator-related keywords like “admin”, “Domain Admins”, “Enterprise Admins”, “Remote Desktop Users”, or “Organization Management”.
Alternatively, the attacker executes wmic.exe to query user accounts.
The attacker parses the output from wmic.exe to identify administrator accounts.
The attacker identifies privileged accounts to target for credential theft or privilege escalation.
The attacker uses the identified accounts to perform lateral movement or access sensitive data.

Impact

Successful enumeration of administrator accounts allows an attacker to identify high-value targets within the environment. This can lead to credential theft, privilege escalation, lateral movement, and ultimately, unauthorized access to sensitive data or systems. While the risk score is low, this activity serves as a precursor to more serious compromises.

Recommendation

Monitor process creation events for net.exe and wmic.exe commands with arguments related to user and group enumeration using the Sigma rules provided.
Investigate any instances of lower-privileged accounts executing these commands and filter out authorized administrative accounts performing the same actions.
Enable Windows process creation logging to capture the necessary events.
Deploy the Sigma rules in this brief to your SIEM and tune for your environment.

Mimikatz MemSSP Log File Detection

hello@craftedsignal.io — Wed, 03 Jan 2024 17:00:00 +0000

This detection identifies the creation of the mimilsa.log file, a default log generated by the Mimikatz misc::memssp module. The misc::memssp module injects a malicious Security Support Provider (SSP) into the Local Security Authority Subsystem Service (LSASS) process. This injected SSP logs credentials from subsequent logons to the compromised host, allowing attackers to capture sensitive information. The creation of this log file is a strong indicator of credential access attempts and the potential compromise of user accounts and system security. This rule is designed for data generated by Elastic Defend and also supports data from CrowdStrike, Microsoft Defender XDR, and SentinelOne Cloud Funnel.

Attack Chain

An attacker gains initial access to a Windows system (e.g., via phishing or exploiting a vulnerability).
The attacker executes Mimikatz or a similar tool with the misc::memssp module.
Mimikatz injects a malicious SSP library (e.g., mimilib.dll) into the LSASS process (lsass.exe).
The injected SSP hooks into the authentication process.
When users log on to the system, the SSP captures their credentials.
The captured credentials are written to the mimilsa.log file, typically located in C:\Windows\System32\.
The attacker retrieves the mimilsa.log file to obtain the captured credentials.
The attacker uses the stolen credentials to escalate privileges, move laterally within the network, and access sensitive resources.

Impact

A successful Mimikatz MemSSP attack can lead to the compromise of user accounts, including those with administrative privileges. This allows attackers to gain unauthorized access to sensitive data, systems, and resources within the organization. Lateral movement becomes easier, potentially impacting a large number of systems. The compromised credentials can also be used for external attacks, such as gaining access to cloud services or other external resources.

Recommendation

Deploy the Sigma rule Mimikatz Memssp Log File Detected to your SIEM and tune for your environment.
Enable Sysmon file creation logging to detect the creation of mimilsa.log files.
Investigate any alerts generated by the Sigma rule, focusing on the process that created the log file and any subsequent file access.
Monitor for the presence of mimilib.dll and any LSA Security Packages registry modifications, as these may indicate persistent SSP installation.
Review and restrict interactive logons to high-value hosts to minimize the potential for credential theft.
Investigate related alerts for the same host.id in the last 48 hours covering delivery, privilege escalation, LSASS access, persistence, lateral movement, or additional credential access.

Long Base64 Encoded Command via Scripting Interpreter

hello@craftedsignal.io — Wed, 03 Jan 2024 17:00:00 +0000

This rule identifies the execution of scripting interpreters (Python, PowerShell, Node.js, and Deno) with unusually long command lines containing base64 encoded payloads. The rule focuses on scenarios where the initial process.command_line field is ignored due to its excessive length, but the complete command line is still available in process.command_line.text. Attackers leverage this technique to evade traditional command-line inspection and execute malicious content across Windows, macOS, and Linux systems. This approach allows attackers to embed and execute code without writing it to disk, making it harder to detect. The rule is designed to detect this behavior, allowing for closer inspection of the executed commands and their intent.

Attack Chain

An attacker gains initial access to a system (e.g., via phishing or exploiting a vulnerability).
The attacker uses PowerShell, Python, Node.js, or Deno to execute commands.
A long, base64-encoded string is crafted, designed to evade detection.
The interpreter is invoked with the encoded string passed as an argument, exceeding typical command-line limits.
The process.command_line field is truncated due to its length, but the full command line is available in process.command_line.text.
The interpreter decodes and executes the payload from the process.command_line.text.
The decoded payload performs malicious actions such as downloading malware, establishing persistence, or exfiltrating data.
The attacker achieves their objective, such as gaining control of the system or stealing sensitive information.

Impact

Successful exploitation can lead to a wide range of malicious activities, including malware installation, data theft, privilege escalation, and system compromise. Due to the defense evasion capabilities, it is difficult to identify and prevent. The impact includes potential data breaches, financial losses, and reputational damage. The rule’s detection helps defenders identify this attack vector and prevent further exploitation of affected systems.

Recommendation

Deploy the Sigma rule Detect Long Base64 Encoded Command via Scripting Interpreter to your SIEM to detect this behavior.
Investigate any alerts generated by this rule, focusing on the process.command_line.text field to understand the full command being executed.
Review parent processes and execution chains of the interpreter to understand the initial attack vector.
Implement controls to restrict the execution of scripting interpreters from untrusted sources.
Monitor process execution logs for command lines exceeding a certain length threshold.
Improve logging coverage to capture the full command line even when it exceeds standard limits.