Elastic Defend — CraftedSignal Threat Feed

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 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.

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.

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.

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 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.

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.

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.

Potential Abuse of Certreq for File Transfer via HTTP POST

hello@craftedsignal.io — Sun, 28 Jan 2024 20:47:00 +0000

The Windows Certreq utility is a command-line tool used for managing certificates. Adversaries may abuse Certreq to download files from or upload data to a remote server by initiating an HTTP POST request. This behavior can be used for command and control (C2) or exfiltration. This technique leverages a legitimate system binary (LOLBin) to evade detection. Elastic has observed this behavior being detected through multiple data sources including Elastic Defend, Microsoft Defender XDR, Sysmon, SentinelOne, and Crowdstrike. This is a cross-industry threat that can affect any organization using Windows.

Attack Chain

An attacker gains initial access to a Windows system (e.g., via phishing or exploiting a vulnerability).
The attacker executes Certreq.exe with the -Post argument to initiate an HTTP POST request.
The Certreq process attempts to connect to a remote server to send or receive data.
The remote server responds to the Certreq request, potentially delivering a file or receiving exfiltrated data.
The downloaded file is saved to disk (if applicable).
The attacker may execute the downloaded file or further process the exfiltrated data.
The attacker may attempt to clean up the Certreq command from command history or logs to evade detection.

Impact

Successful exploitation could lead to the download and execution of malicious payloads, potentially compromising the affected system and network. Alternatively, sensitive data could be exfiltrated from the target environment. The impact can range from data theft and system compromise to full network intrusion, depending on the attacker’s objectives and the data accessed. The severity is medium because Certreq is a legitimate tool, and its abuse requires specific command-line arguments and network activity.

Recommendation

Deploy the Sigma rule “Detect Certreq HTTP Post Request” to your SIEM to identify potential abuse of Certreq for file transfer.
Enable Sysmon process creation logging (Event ID 1) to capture the execution of Certreq.exe and its command-line arguments, enabling detections.
Monitor network connections originating from Certreq.exe for unusual destinations or data transfer patterns using network connection logs.
Investigate any instances of Certreq.exe executing with the -Post argument, as this is not typical usage of the utility.

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.

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.

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.

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.

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.

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.

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.

Account Discovery Command via SYSTEM Account

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

This detection rule identifies instances where the SYSTEM account is used to execute account discovery utilities, such as whoami.exe and net1.exe. This behavior is commonly observed after an attacker has successfully achieved privilege escalation within a Windows environment, or after exploiting a web application. The rule is designed to detect post-exploitation discovery activity where an adversary attempts to gain situational awareness by enumerating accounts and system information using the elevated SYSTEM context. The rule leverages data from Elastic Defend and Sysmon Event ID 1 to identify these behaviors, helping defenders spot potential privilege escalation and lateral movement attempts. The original rule was created 2020/03/18 and updated 2026/05/04.

Attack Chain

An attacker gains initial access to a system, potentially through exploiting a vulnerability in a web application or through phishing.
The attacker escalates privileges to the SYSTEM account, possibly by exploiting a local privilege escalation vulnerability.
The attacker executes whoami.exe or net1.exe via the SYSTEM account to enumerate user accounts and gather system information.
The whoami.exe or net1.exe process is spawned by a parent process such as a web server process (e.g., w3wp.exe) or a service process.
The attacker uses the discovered account information to plan further actions, such as lateral movement or credential theft.
The attacker may use net1.exe to query domain information.
The attacker leverages the gained information to identify valuable targets within the network.
The final objective is often data exfiltration, deployment of ransomware, or further compromise of the network.

Impact

A successful attack can lead to unauthorized access to sensitive data, lateral movement within the network, and potential data exfiltration or ransomware deployment. Although this rule has low severity, the execution of discovery commands by the SYSTEM account can be a critical indicator of compromise. Early detection of such activity can prevent more severe damage.

Recommendation

Deploy the provided Sigma rules to detect account discovery commands executed via the SYSTEM account and tune for your environment.
Enable Sysmon process creation logging (Event ID 1) to ensure the necessary data is available for detection.
Investigate any alerts generated by these rules, focusing on the process execution chain to identify the source of the SYSTEM account usage.
If the process tree includes a web-application server process, investigate suspicious file creation or modification to assess for webshell backdoors.
Review and harden web application security to prevent initial access and privilege escalation.

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).

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.

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.

Windows Subsystem for Linux Distribution Installed via Registry Modification

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

Attackers may leverage the Windows Subsystem for Linux (WSL) to evade detection by operating within a Linux environment on a Windows host. The installation of a new WSL distribution involves specific registry modifications. This rule identifies such modifications, providing an alert when a new WSL distribution is installed. This is important for defenders as it could signal an attacker setting up a persistent and potentially hidden environment for malicious activities. WSL allows attackers to utilize Linux tools and techniques on a Windows system, potentially bypassing traditional Windows-based security measures.

Attack Chain

Initial Access: The attacker gains initial access to the Windows system through existing vulnerabilities or compromised credentials.
Privilege Escalation: The attacker elevates their privileges to perform system-level changes, including registry modifications.
WSL Installation: The attacker initiates the installation of a WSL distribution. This may involve downloading and executing a WSL installer package.
Registry Modification: During installation, the system modifies the registry to configure and register the new WSL distribution. Specifically, keys under HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Lxss\\ are created/modified.
WSL Environment Setup: The attacker configures the installed WSL distribution, potentially installing additional tools and software needed for their objectives.
Execution of Malicious Activities: The attacker executes malicious commands and scripts within the WSL environment, leveraging Linux tools to perform actions such as lateral movement, data exfiltration, or persistence.
Defense Evasion: The attacker utilizes WSL to evade detection, as traditional Windows-based security tools may not effectively monitor or analyze activity within the Linux subsystem.
Persistence: The attacker establishes persistence within the WSL environment, ensuring continued access to the compromised system even after reboots or security updates.

Impact

Successful exploitation allows attackers to establish a hidden and persistent environment within the compromised Windows system. This can lead to data theft, system compromise, and further propagation of the attack within the network. The number of victims and affected sectors depends on the scope and objectives of the attacker. The use of WSL for malicious purposes can significantly complicate incident response and remediation efforts.

Recommendation

Deploy the Sigma rule “Detect WSL Installation via Registry Modification” to your SIEM to detect new WSL installations by monitoring registry changes.
Enable Sysmon registry event logging to capture the necessary data for the Sigma rule to function correctly (see setup instructions in the rule description).
Investigate any alerts generated by the Sigma rule to determine the legitimacy of the WSL installation and identify potential malicious activities.
Monitor for execution of suspicious processes within WSL environments, as described in “Execution via Windows Subsystem for Linux - db7dbad5-08d2-4d25-b9b1-d3a1e4a15efd”.

MSBuild запускает необычные процессы

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

The Microsoft Build Engine (MSBuild) is a legitimate tool used for building applications. However, adversaries may abuse MSBuild to execute malicious scripts or compile code, effectively bypassing security controls. This technique is often employed to deploy malicious payloads. This detection focuses on identifying instances where MSBuild initiates unusual processes such as PowerShell, Internet Explorer, or the Visual C# Command Line Compiler (csc.exe). This activity is considered suspicious because legitimate software development workflows do not typically involve MSBuild directly spawning these processes. The original Elastic detection rule was created on 2020-03-25 and last updated on 2026-05-04.

Attack Chain

An attacker gains initial access to a system (e.g., through phishing or exploiting a vulnerability).
The attacker modifies or creates an MSBuild project file (.csproj or .sln) containing malicious commands.
The malicious MSBuild project file is crafted to execute a script or compile code.
The attacker uses the MSBuild.exe or msbuild.exe utility to execute the malicious project file.
MSBuild spawns an unusual process such as powershell.exe, csc.exe, or iexplore.exe based on the malicious project file configuration.
PowerShell executes arbitrary commands, downloads further payloads, or performs other malicious actions.
The C# compiler (csc.exe) compiles malicious code into an executable or library.
The compiled malware or downloaded payloads execute, leading to further compromise, such as data exfiltration or lateral movement.

Impact

Successful exploitation can lead to arbitrary code execution, allowing attackers to deploy malware, compromise sensitive data, and establish persistence on the targeted system. The use of MSBuild for malicious purposes allows attackers to bypass application whitelisting and other security controls that trust signed Microsoft binaries. While the precise number of victims is unknown, this technique can be employed against a wide range of organizations, particularly those with vulnerable systems or inadequate endpoint protection.

Recommendation

Enable process creation logging, specifically including parent-child relationships, to detect unusual process spawning by MSBuild (logs-endpoint.events.process-*, logs-system.security*, logs-windows.forwarded*, logs-windows.sysmon_operational-*, winlogbeat-*).
Deploy the Sigma rule “Microsoft Build Engine Started an Unusual Process” to your SIEM to identify instances of MSBuild spawning suspicious processes, and tune for your environment.
Investigate any instances of MSBuild spawning PowerShell, csc.exe, or iexplore.exe to determine if the activity is legitimate or malicious (process.name:(“csc.exe” or “iexplore.exe” or “powershell.exe”)).
Monitor for modifications to MSBuild project files (.proj or .sln) for signs of tampering.

Detection of Bcdedit Boot Configuration Modification

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

This detection rule identifies the execution of bcdedit.exe with specific arguments that modify the boot configuration data (BCD) store in Windows systems. Attackers or malware may use this technique to disable Windows Error Recovery (recoveryenabled) or to ignore errors during the boot process (bootstatuspolicy ignoreallfailures). These modifications are often performed to prevent systems from recovering properly after an attack, particularly in ransomware scenarios. The rule is designed to work with data from Elastic Defend, CrowdStrike, Microsoft Defender XDR, SentinelOne Cloud Funnel, and Sysmon. The detection logic focuses on process execution events that include the relevant bcdedit.exe command-line arguments. Defenders should be aware of legitimate uses of bcdedit.exe by administrators for troubleshooting or data recovery purposes, so context is crucial.

Attack Chain

Initial Access: The attacker gains initial access to the system through various means, such as phishing or exploiting a vulnerability.
Privilege Escalation: The attacker escalates privileges to gain administrative access, required to modify boot configuration settings.
Reconnaissance: The attacker performs reconnaissance to identify the system’s configuration and identify appropriate targets for modification.
Disable Recovery: The attacker uses bcdedit.exe to disable Windows Error Recovery using the /set {default} recoveryenabled No command.
Ignore Boot Failures: The attacker uses bcdedit.exe to set the boot status policy to ignore all failures using the /set {default} bootstatuspolicy ignoreallfailures command.
System Impact: By modifying the boot configuration, the attacker inhibits system recovery, making it harder for the system to recover from errors or malicious activity.
Payload Execution: The attacker deploys and executes the primary malicious payload, such as ransomware, leveraging the modified boot configuration to maximize impact.
Final Objective: The attacker achieves their final objective, which could include data encryption, data theft, or system disruption.

Impact

Successful modification of boot configuration data can lead to significant system instability and data loss. In ransomware attacks, this technique prevents the system from recovering, increasing the likelihood of the victim paying the ransom. While the exact number of affected organizations is unknown, this technique is widely used in ransomware campaigns and can affect any Windows system if successfully executed.

Recommendation

Deploy the “Modification of Boot Configuration” Sigma rule to your SIEM and tune for your environment to detect the malicious use of bcdedit.exe described in this brief.
Enable Sysmon process creation logging to capture bcdedit.exe executions and their command-line arguments (Sysmon Event ID 1).
Investigate any detected instances of bcdedit.exe modifying boot configuration settings to determine legitimacy, as described in the rule’s “Triage and analysis” section.
Monitor process execution logs for unexpected processes running bcdedit.exe with arguments related to disabling recovery or ignoring boot failures.

Windows Backup Deletion via Wbadmin

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

Attackers, including ransomware groups, often attempt to remove or impair an organization’s ability to recover from an attack. One method to achieve this is by deleting Windows backup catalogs and system state backups using the wbadmin.exe utility. Windows Server Backup stores details about backups (what volumes are backed up and where the backups are located) in a backup catalog. Removing these catalogs renders backups unusable for recovery, increasing the impact of the attack. This technique is frequently observed in ransomware playbooks and other destructive attacks targeting Windows environments. This activity can be detected using endpoint detection and response (EDR) solutions, Windows Security Event Logs, and Sysmon.

Attack Chain

The attacker gains initial access to the system via phishing, exploiting a vulnerability, or using compromised credentials.
The attacker escalates privileges to administrator level to execute wbadmin.exe.
The attacker executes wbadmin.exe with the delete catalog command to remove backup catalogs.
The attacker executes wbadmin.exe with the delete systemstatebackup command to remove system state backups.
The attacker may also delete shadow copies using vssadmin.exe or wmic.exe to further hinder recovery.
The attacker deploys ransomware or initiates other destructive actions.
The attacker encrypts or destroys data on the system and connected network shares.
The attacker demands a ransom payment for data recovery, which is complicated by the deleted backups.

Impact

Successful deletion of backup catalogs and system state backups significantly impairs an organization’s ability to recover from a ransomware attack or other destructive event. This can lead to prolonged downtime, data loss, and financial losses associated with incident response and recovery efforts. While the number of direct victims of this specific technique is difficult to quantify, the impact is typically observed in conjunction with broader ransomware campaigns affecting organizations across various sectors.

Recommendation

Enable Sysmon process creation logging with Event ID 1 to capture wbadmin.exe executions and activate the first Sigma rule.
Deploy the Sigma rules in this brief to your SIEM and tune for your environment.
Monitor Windows Security Event Logs for process creation events related to wbadmin.exe.
Investigate any instances of wbadmin.exe executing with delete arguments.
Review and harden account access controls to prevent unauthorized use of wbadmin.exe.

Suspicious Enumeration Commands Spawned via WMIPrvSE

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

Attackers can leverage the Windows Management Instrumentation (WMI) to execute commands for reconnaissance and enumeration within a compromised system. This involves spawning native Windows tools via the WMI Provider Service (WMIPrvSE). This activity is often used to gather system and network information in a stealthy manner, which could be part of a larger attack, such as lateral movement or privilege escalation. This behavior matters because it allows adversaries to gather information about the target environment without using easily detectable methods, potentially leading to further compromise.

Attack Chain

The attacker gains initial access to a Windows system (e.g., through phishing or exploiting a vulnerability).
The attacker uses WMI to execute a reconnaissance command.
WMIPrvSE.exe is invoked to execute the attacker’s specified command.
The attacker executes commands such as ipconfig.exe, net.exe, or systeminfo.exe via WMIPrvSE.exe to gather network configuration details, user information, and system information.
The enumerated information is collected and potentially exfiltrated to a command and control server.
The attacker uses the gathered information to identify further targets within the network.
The attacker moves laterally to other systems using stolen credentials or exploited vulnerabilities.
The attacker achieves their final objective, such as data exfiltration, ransomware deployment, or persistent access.

Impact

Successful execution of enumeration commands via WMIPrvSE allows attackers to gather sensitive information about the system and network environment. This information can be used to facilitate lateral movement, privilege escalation, and data theft, potentially leading to significant financial loss, reputational damage, and disruption of business operations.

Recommendation

Enable Sysmon process creation logging to capture the execution of enumeration commands (Data Source: Sysmon).
Deploy the Sigma rule “Enumeration Command Spawned via WMIPrvSE” to your SIEM to detect suspicious WMIPrvSE activity (Sigma rule).
Investigate any instances of WMIPrvSE spawning common enumeration tools such as net.exe, ipconfig.exe, or systeminfo.exe (Sigma rule).
Implement network segmentation to limit the scope of potential lateral movement following successful enumeration (Attack Chain).

Suspicious Antimalware Scan Interface DLL Creation

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

The Antimalware Scan Interface (AMSI) is a Windows interface that allows applications and services to integrate with antimalware products. Attackers may attempt to bypass AMSI to execute malicious code without detection. This detection identifies the creation of the AMSI DLL (amsi.dll) in unusual locations, which is a common technique used to load a rogue AMSI module instead of the legitimate one. This technique can be used to evade detection by security products that rely on AMSI for scanning potentially malicious scripts and code. The rule is designed to work with data from Winlogbeat, Elastic Endpoint, Sysmon, Endgame, SentinelOne Cloud Funnel, Microsoft Defender XDR, and Crowdstrike.

Attack Chain

An attacker gains initial access to a Windows system through various means (e.g., phishing, exploit).
The attacker determines the location of the legitimate amsi.dll file.
The attacker identifies a writable directory where a malicious amsi.dll can be placed. This location must be in the search order of applications that use AMSI, such as PowerShell or other scripting hosts.
The attacker copies or creates a malicious amsi.dll in the identified location. This rogue DLL is designed to bypass or disable AMSI functionality.
A process like PowerShell or another scripting host is launched. Because the malicious amsi.dll is in a higher-priority directory, it is loaded instead of the legitimate AMSI library.
The launched process executes malicious code (e.g., PowerShell script).
Because the rogue amsi.dll is loaded, AMSI scans are bypassed, allowing the malicious code to execute without detection.

Impact

A successful AMSI bypass can allow attackers to execute malicious code, such as malware, scripts, or exploits, without detection by antimalware products. This can lead to system compromise, data theft, or other malicious activities. The impact can range from a single compromised endpoint to a wider breach of an organization’s network.

Recommendation

Enable file creation monitoring with Sysmon or Elastic Defend to detect the creation of files, specifically DLLs, in unusual locations.
Deploy the Sigma rule “Suspicious Antimalware Scan Interface DLL Creation” to your SIEM to detect the creation of amsi.dll in non-standard paths. Tune the rule for your environment.
Investigate any alerts generated by the Sigma rule by examining the parent process, file path, and user context to determine if the activity is malicious.

Script Execution via Microsoft HTML Application

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

This detection identifies the execution of scripts via HTML applications, leveraging Windows utilities like rundll32.exe or mshta.exe. Attackers often use this method to bypass process and signature-based defenses by proxying the execution of malicious content through legitimate, signed binaries. The detection focuses on specific command-line arguments and patterns associated with this technique, while also excluding known legitimate uses by applications such as Citrix System32 (wfshell.exe), Microsoft Access (MSACCESS.EXE), and Quokka.Works (GTInstaller.exe). This technique is used by attackers to execute malicious scripts without directly running them, thus evading traditional security measures. The detection rule analyzes process names, command-line arguments, parent processes, and file paths to identify potentially malicious activity indicative of defense evasion.

Attack Chain

An attacker gains initial access through various means (e.g., phishing, drive-by download).
The attacker leverages a malicious HTML application (HTA) file or a scriptlet (SCT) file.
The attacker uses mshta.exe or rundll32.exe to execute the malicious HTA or SCT file. The command line includes obfuscated or encoded script content.
mshta.exe or rundll32.exe process spawns a child process, such as cmd.exe or powershell.exe, to execute further commands.
The spawned process executes malicious code, such as downloading and executing a payload.
The attacker achieves persistence by modifying registry keys or creating scheduled tasks.
The attacker performs lateral movement by exploiting vulnerabilities or using stolen credentials.
The final objective is achieved, such as data exfiltration, ransomware deployment, or system compromise.

Impact

Successful exploitation can lead to arbitrary code execution, allowing attackers to compromise the system, steal sensitive data, deploy ransomware, or establish a persistent foothold. Due to the nature of the technique, it can bypass many traditional security measures. The wide adoption of Windows and the inherent trust placed in signed binaries makes this a potent evasion technique. Failure to detect and prevent this attack can lead to significant financial and reputational damage for the targeted organization.

Recommendation

Deploy the Sigma rule “Script Execution via Microsoft HTML Application” to your SIEM to detect suspicious mshta.exe and rundll32.exe executions. Tune the rule by adding exceptions for known legitimate uses in your environment.
Enable Sysmon process creation logging (Event ID 1) to ensure the visibility required for the Sigma rules to function correctly.
Monitor process command lines for suspicious arguments like “script:eval”, “WScript.Shell”, and “mshta http” which are indicative of this technique.
Implement application control policies to restrict the execution of mshta.exe and rundll32.exe where they are not required for legitimate business purposes.
Investigate and block any identified malicious HTA files or scriptlet URLs found in the command lines of detected processes.

Potential Remote Credential Access via Registry

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

This detection identifies potential remote access to the Windows registry to dump credential data from the Security Account Manager (SAM) registry hive. This activity often precedes credential access and privilege elevation attempts. The rule focuses on detecting the creation of specific file types by svchost.exe, a legitimate Windows process, in temporary directories. However, when svchost.exe creates files with registry file (REGF) header bytes in temporary locations, and those files are also of a significant size, it indicates a potential secretsdump-style attack. The rule is designed for data generated by Elastic Defend.

Attack Chain

Attacker gains initial access to the target system via compromised credentials or exploiting a vulnerability.
Attacker uses remote registry tools or scripts, such as those based on Impacket’s secretsdump.py, to connect to the target system’s registry service.
The attacker initiates a connection to the RemoteRegistry service.
The svchost.exe process on the target system is leveraged to access the SAM, SECURITY, and SYSTEM registry hives.
svchost.exe creates a temporary file (e.g., a .tmp file) in the \Windows\System32\ or \WINDOWS\Temp\ directory.
The temporary file contains the contents of the registry hive, identifiable by the “72656766” (REGF) header bytes and a file size greater than 30000 bytes.
The attacker retrieves the dumped registry hive files from the target system.
The attacker parses the registry hives offline to extract sensitive credential information, such as password hashes. This leads to lateral movement and privilege escalation.

Impact

A successful attack allows adversaries to extract sensitive credentials, including password hashes, from the compromised system. This can lead to lateral movement within the network, privilege escalation, and ultimately, domain compromise. The extraction of credentials provides the attacker with persistent access and the ability to move undetected through the environment.

Recommendation

Deploy the Sigma rule Suspicious Svchost.exe Registry Hive Dump to detect the creation of registry hive files by svchost.exe in temporary directories based on the file.Ext.header_bytes and file.path fields.
Deploy the Sigma rule Suspicious RemoteRegistry File Creation to detect files with REGF header bytes created by svchost.exe, outside the standard system path to catch unusual service context.
Enable and monitor process creation events, specifically focusing on svchost.exe and its command-line arguments, to identify suspicious service groups.
Monitor file creation events for files with the .tmp extension in the \Windows\System32\ and \WINDOWS\Temp\ directories, paying attention to file sizes and header bytes, as indicated by the file path and size conditions in the rule.
Review the investigation steps outlined in the rule documentation to properly triage and analyze potential incidents.

Execution of Persistent Suspicious Programs via Run Keys

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

This rule detects a common persistence technique where attackers configure malicious scripts or programs to run automatically after a user logs on to a Windows system. The technique abuses the Registry Run keys and Startup folders to achieve persistence. The rule specifically identifies processes launched shortly after the userinit.exe and explorer.exe processes start, focusing on processes known to be used for malicious purposes, such as cscript.exe, wscript.exe, PowerShell.exe, MSHTA.exe, RUNDLL32.exe, REGSVR32.exe, RegAsm.exe, MSBuild.exe, and InstallUtil.exe. Additionally, it checks if these processes are launched from or access suspicious paths like C:\Users*, C:\ProgramData*, and C:\Windows\Temp*. This detection is crucial because it helps identify potentially malicious activities that bypass standard security measures by leveraging legitimate system tools.

Attack Chain

The attacker gains initial access to the system, typically through phishing, exploiting vulnerabilities, or using stolen credentials (not covered in the source).
The attacker modifies the Windows Registry Run keys (HKCU\Software\Microsoft\Windows\CurrentVersion\Run or HKLM\Software\Microsoft\Windows\CurrentVersion\Run) to execute a malicious program or script.
The system starts, and the winlogon.exe process initiates userinit.exe.
userinit.exe starts explorer.exe, loading the user’s profile and desktop environment.
The Registry Run keys are processed, and the malicious program or script is executed as a child process of explorer.exe. This often involves suspicious processes like cscript.exe, powershell.exe, or rundll32.exe.
The malicious process executes from a suspicious location, such as C:\\Users\\*, C:\\ProgramData\\*, or C:\\Windows\\Temp\\*.
The malicious process performs its intended actions, such as downloading additional malware, establishing command and control, or exfiltrating data.
The system remains infected, with the malicious process running every time the user logs on, ensuring persistence.

Impact

A successful attack can lead to persistent malware infections, data theft, and complete system compromise. Attackers can maintain long-term access to the compromised system, potentially leading to further lateral movement within the network. This can result in significant financial losses, reputational damage, and operational disruptions.

Recommendation

Deploy the Sigma rule “Persistent Suspicious Program Execution” to detect suspicious processes executed shortly after user logon (rule).
Enable process creation logging via Sysmon or Elastic Defend to provide the data required for the Sigma rule to function effectively.
Investigate any alerts generated by the Sigma rule by examining the process lineage and command-line arguments of the suspicious processes.
Implement strict access controls and regularly audit user accounts to prevent unauthorized modifications to the Registry Run keys.
Block execution of the listed suspicious processes (cscript.exe, wscript.exe, PowerShell.EXE, MSHTA.EXE, RUNDLL32.EXE, REGSVR32.EXE, RegAsm.exe, MSBuild.exe, InstallUtil.exe) from suspicious paths (C:\\Users\\*, C:\\ProgramData\\*, C:\\Windows\\Temp\\*) via application control policies (overview).

Detection of Command and Control Activity via Common Web Services

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

This detection rule, sourced from Elastic, identifies potential command and control (C2) activity by detecting connections to commonly abused web services. Adversaries often leverage popular web services like pastebin, GitHub, Dropbox, and Discord to mask malicious communications within legitimate network traffic. This technique makes it challenging for defenders to distinguish between normal user activity and malicious C2 traffic. The rule focuses on Windows systems and monitors DNS queries to identify processes communicating with a predefined list of services known to be abused by attackers. The rule was last updated on 2026-05-04 and is designed to work with data from Elastic Defend and SentinelOne Cloud Funnel. The goal is to identify anomalous network connections originating from unusual processes.

Attack Chain

A user on a Windows host unknowingly executes a malicious file (e.g., via phishing or drive-by download).
The malicious file executes a process outside of typical program directories (e.g., C:\Windows\Temp).
This process initiates a DNS query to a domain associated with a commonly abused web service (e.g., pastebin.com, githubusercontent.com).
The DNS query resolves to an IP address, and a network connection is established to the web service.
The malicious process uploads or downloads data from the web service, potentially containing commands for the compromised host or exfiltrated data.
The web service acts as an intermediary, relaying commands from the attacker to the compromised host or exfiltrated data from the compromised host to the attacker.
The attacker uses the C2 channel to perform further actions on the compromised host, such as lateral movement or data theft.

Impact

A successful attack using common web services for C2 can lead to data exfiltration, system compromise, and further propagation within the network. The low severity suggests a focus on detecting early-stage C2 activity, which if left unchecked, could escalate into a significant incident. The usage of popular web services makes detection difficult, requiring careful analysis and tuning to avoid false positives.

Recommendation

Deploy the Sigma rule “Connection to Commonly Abused Web Services” to your SIEM and tune it for your environment to minimize false positives.
Enable Sysmon DNS query logging to accurately capture DNS requests for improved detection capabilities, activating the “DNS Query to Commonly Abused Web Services” rule.
Investigate any alerts generated by this rule, focusing on the process execution chain and network connections to determine the legitimacy of the activity, referencing the investigation steps described in the rule documentation.
Review and update the list of excluded processes in the Sigma rule to reflect your organization’s approved software and reduce false positives.

Conhost Proxy Execution for Defense Evasion

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

Attackers are leveraging the Console Window Host (conhost.exe) to proxy execution of commands, using the --headless argument to hide malicious activity. This technique allows adversaries to blend in with legitimate Windows processes, making detection more challenging. This behavior, often associated with defense evasion, involves using conhost.exe to execute commands such as PowerShell, cmd.exe, mshta, curl, and scripts. The activity can be seen across multiple environments including endpoints, Windows systems, and cloud platforms like Microsoft Defender XDR and SentinelOne. Defenders must differentiate between legitimate uses of conhost.exe, such as those by Winget-AutoUpdate or OpenSSH, and malicious proxy executions, which could indicate broader compromise.

Attack Chain

An attacker gains initial access to the system, possibly through phishing or exploiting a vulnerability.
The attacker executes a command that calls conhost.exe with the --headless argument.
Conhost.exe is used to proxy the execution of a malicious command, such as PowerShell, cmd.exe, or mshta.
The proxied command downloads a malicious payload from a remote server using tools like curl or bitsadmin.
The downloaded payload is executed, establishing persistence on the compromised system.
The attacker uses the compromised system to move laterally within the network, compromising additional systems.
Sensitive data is exfiltrated from the network to a remote server controlled by the attacker.
The attacker achieves their final objective, such as deploying ransomware or stealing intellectual property.

Impact

Successful exploitation can lead to a complete compromise of the targeted system and potentially the entire network. This can result in data theft, financial loss, and reputational damage. The use of conhost.exe for proxy execution makes it difficult to detect malicious activity, potentially allowing attackers to remain undetected for extended periods. The impact could range from individual workstation compromises to large-scale network breaches, affecting potentially hundreds or thousands of systems within an organization.

Recommendation

Deploy the “Proxy Execution via Console Window Host” Sigma rule to your SIEM and tune for your environment to detect suspicious conhost.exe activity.
Monitor process creation events for conhost.exe with the --headless argument, focusing on the command-line arguments to identify potentially malicious commands.
Investigate any instances of conhost.exe executing suspicious scripts, downloaders, or task scheduler modifications to identify potential threats.
Enable Sysmon process creation logging (Event ID 1) to capture detailed process execution information, as recommended in the setup instructions linked in the overview.
Review the investigation fields in the brief to understand the key data points for analyzing potential proxy execution attempts.

Windows Firewall Disabled via Netsh

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

Attackers commonly use the netsh.exe utility, a command-line scripting tool, to manage network configurations. Abusers leverage netsh.exe to disable or modify Windows Firewall rules, a built-in host-based firewall. This manipulation weakens the system’s defenses, allowing unauthorized network traffic and enabling lateral movement within the compromised environment. The activity allows for command and control communications and unhindered exploitation of internal resources. Defenders must monitor netsh.exe executions for unexpected firewall modifications.

Attack Chain

Initial Access: An attacker gains initial access to a Windows system through various means such as phishing or exploiting a vulnerability.
Privilege Escalation: The attacker escalates privileges to a level sufficient to modify firewall settings.
Discovery: The attacker uses reconnaissance techniques to identify existing firewall rules.
Defense Evasion: The attacker uses netsh.exe to disable specific firewall rules, using commands like netsh advfirewall firewall set rule name="rule_name" new enable=no.
Defense Evasion: Alternatively, the attacker disables the entire firewall using netsh advfirewall set allprofiles state off.
Lateral Movement: With the firewall weakened, the attacker moves laterally to other systems on the network.
Command and Control: The attacker establishes command and control channels, which may now be unimpeded by firewall rules.
Impact: The attacker achieves their objectives, such as data exfiltration, ransomware deployment, or further compromise of the network.

Impact

Successful disabling of Windows Firewall rules can lead to significant security breaches. Attackers can move laterally within the network, compromise additional systems, and exfiltrate sensitive data. The impact can range from data loss and financial damage to reputational harm and legal consequences. The defense evasion enables attackers to establish persistent command and control channels, maintain a long-term presence within the compromised environment and conduct further malicious activities.

Recommendation

Enable Sysmon process creation logging to monitor netsh.exe executions and related command-line arguments to support detections.
Deploy the Sigma rules in this brief to your SIEM to detect attempts to disable Windows Firewall rules via netsh.exe. Tune the rules for your specific environment.
Investigate any alerts generated by the Sigma rules, focusing on identifying the user account, process execution chain, and the specific firewall rules being modified.
Implement strict access controls to limit the number of users with the privileges necessary to modify firewall settings.
Regularly review and audit firewall configurations to ensure they are properly configured and have not been tampered with.

Suspicious Scripts in the Startup Directory

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

Adversaries may abuse the Windows Startup folder to maintain persistence in an environment. The Startup folder is a special folder in Windows where programs added to this folder are executed during account logon without user interaction. This rule identifies script engines (wscript.exe, cscript.exe) creating files or the creation of script files with specific extensions (vbs, vbe, wsh, wsf, js, jse, sct, hta, ps1, bat, cmd) in the Startup folder. The rule is designed for data generated by Elastic Defend and also supports Microsoft Defender XDR, SentinelOne Cloud Funnel, and Sysmon.

Attack Chain

An attacker gains initial access to a system.
The attacker creates a malicious script (e.g., VBScript, PowerShell) designed to execute arbitrary commands.
The attacker identifies the Startup folder path for a specific user or all users.
The attacker creates a shortcut file (e.g., .lnk) or a script file directly within the Startup folder.
The shortcut or script is configured to execute the malicious script.
The system is restarted or the user logs in.
The operating system automatically executes the script located in the Startup folder.
The malicious script executes, allowing the attacker to perform actions such as installing malware, establishing persistence, or exfiltrating data.

Impact

A successful attack leveraging the Startup folder persistence mechanism allows the attacker to maintain unauthorized access to a compromised system. This can lead to the execution of malicious code, installation of malware, data theft, and further compromise of the network. The impact is significant, potentially affecting all users who log into the system.

Recommendation

Deploy the Sigma rule “Detect Script Creation in Startup Directory” to your SIEM and tune for your environment to identify the creation of suspicious scripts in the Startup folder.
Deploy the Sigma rule “Detect Script Execution via Startup Directory” to your SIEM and tune for your environment to identify script execution from the Startup directory.
Enable Sysmon Event ID 11 (File Create) to collect necessary data for the detections above.
Investigate any alerts generated by these rules promptly to identify and remediate potential persistence attempts.
Block the file extensions listed in the rule query (vbs, vbe, wsh, wsf, js, jse, sct, hta, ps1, bat, cmd) from being written to the startup folder via application control policies where possible.

Suspicious PowerShell Execution via Windows Script Host

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

This detection identifies PowerShell execution initiated by Windows Script Host processes (cscript.exe or wscript.exe). Attackers often use Windows Script Host (WSH) to execute malicious scripts as an initial access method. These scripts can act as droppers for second-stage payloads or download tools and utilities necessary for further compromise. The rule focuses on the parent-child process relationship between WSH and PowerShell, highlighting a common technique used to bypass security controls and execute arbitrary commands on a compromised system. This activity is relevant to defenders as it represents a potential entry point for various attacks, including malware deployment and data exfiltration. The detection logic is based on process execution events observed in Windows environments and is designed to work with data from Elastic Defend, Microsoft Defender XDR, SentinelOne Cloud Funnel, and Sysmon.

Attack Chain

The user receives a phishing email with a malicious attachment (e.g., a .vbs or .js file).
The user opens the attachment, which is processed by either wscript.exe or cscript.exe.
The scripting engine executes the embedded malicious code.
The script downloads a PowerShell script from a remote server or contains an embedded, obfuscated PowerShell command.
The script uses wscript.exe or cscript.exe to launch powershell.exe to execute the downloaded or embedded PowerShell script.
PowerShell executes, performing malicious actions such as downloading additional payloads, modifying system settings, or establishing persistence.
PowerShell attempts to connect to external command-and-control servers to receive further instructions.
The attacker gains initial access to the system and can proceed with lateral movement, data exfiltration, or other malicious activities.

Impact

Successful exploitation can lead to initial access, allowing attackers to deploy malware, steal sensitive information, or perform other malicious activities. The impact can range from data breaches and financial losses to reputational damage. The severity depends on the attacker’s objectives and the level of access they gain. The number of affected systems depends on the scope of the phishing campaign or other initial access methods used to deliver the malicious script.

Recommendation

Enable Sysmon process creation logging to capture the necessary event data for the rules below.
Deploy the Sigma rules in this brief to your SIEM and tune for your environment.
Investigate process execution chains where cscript.exe or wscript.exe spawn powershell.exe using the provided Sigma rules.
Implement email security measures to block phishing emails with script attachments.
Monitor network connections originating from PowerShell processes for suspicious outbound traffic.

Kubelet API Connection Attempt to Internal IP

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

This detection rule identifies suspicious network connections to the Kubernetes Kubelet API, specifically targeting ports 10250 and 10255, from Linux hosts within internal network ranges. Attackers frequently exploit weak authentication or network controls to access the Kubelet API, potentially enabling them to enumerate pods, retrieve logs, and execute commands on nodes. This activity often originates from common scripting utilities like curl, wget, or interpreters like python and node, particularly when executed from world-writable directories such as /tmp, /var/tmp, or /dev/shm. This technique is often a component of container and cluster lateral movement, where the attacker seeks to expand their access within the Kubernetes environment. The rule is designed to detect these unauthorized attempts and alert security teams to investigate potential breaches.

Attack Chain

An attacker gains initial access to a compromised container or host within the Kubernetes cluster, potentially through exploiting a vulnerability in a running application.
The attacker executes a reconnaissance command, such as curl or wget, from within the compromised container, targeting the Kubelet API on port 10250 or 10255.
The curl or wget command is executed from a temporary directory like /tmp or /dev/shm to avoid detection.
The attacker attempts to enumerate running pods and services by querying the /pods or /runningpods endpoints of the Kubelet API.
If successful, the attacker identifies a target pod within the cluster based on the enumerated information.
The attacker leverages the Kubelet API to execute commands within the target pod, potentially escalating privileges or accessing sensitive data.
The attacker attempts to move laterally to other nodes or containers within the Kubernetes cluster, repeating the reconnaissance and exploitation steps.
The ultimate goal is to gain control over the entire Kubernetes cluster, enabling data exfiltration, resource hijacking, or disruption of services.

Impact

Successful exploitation of the Kubelet API can lead to a complete compromise of the Kubernetes cluster. Attackers can gain unauthorized access to sensitive data, escalate privileges, and disrupt critical services. While the number of victims may vary depending on the organization’s security posture, a successful attack could impact all applications and data managed by the cluster. Organizations in any sector utilizing Kubernetes are potentially at risk.

Recommendation

Enable syscall auditing and ensure that event.category:network events are generated for network connections, as outlined in the rule’s setup guide.
Deploy the provided Sigma rule to your SIEM and tune it based on your environment to reduce false positives.
Restrict pod-to-node access to port 10250 using network policies or security groups to limit the attack surface, as noted in the rule’s documentation.
Implement Kubernetes API audit logging to detect unauthorized access attempts and credential access, correlating with process argument telemetry as mentioned in the triage steps.

Proxy Execution via Windows OpenSSH Client

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

This detection identifies attempts to execute commands through a proxy using the Windows OpenSSH client (ssh.exe or sftp.exe). Attackers may abuse this behavior to evade application control policies by leveraging the trusted Windows OpenSSH binaries. The technique involves using the ProxyCommand or LocalCommand options with the OpenSSH client to execute arbitrary commands on the target system. The rule focuses on detecting command lines containing potentially malicious commands such as PowerShell, schtasks, mshta, msiexec, cmd, or script execution, indicating a possible attempt to bypass security measures. The detection logic is applicable to Windows systems.

Attack Chain

An attacker gains initial access to a Windows system.
The attacker executes the Windows OpenSSH client (ssh.exe or sftp.exe) with either the ProxyCommand or LocalCommand option.
The ProxyCommand or LocalCommand parameter specifies a command to be executed locally on the system.
The command includes potentially malicious payloads such as PowerShell commands, scheduled tasks manipulation (schtasks), or execution of other LOLBINs (Living Off the Land Binaries) like mshta or msiexec.
The OpenSSH client executes the specified command.
The malicious command performs actions such as downloading and executing additional payloads, creating scheduled tasks for persistence, or executing arbitrary code.
The attacker achieves their objectives, such as gaining further access to the system, escalating privileges, or deploying malware.

Impact

Successful exploitation can lead to a complete compromise of the affected system. Attackers can bypass application control mechanisms, execute arbitrary code, and establish persistence. This can result in data theft, system disruption, or further propagation of the attack within the network. The severity of the impact depends on the privileges of the account running the OpenSSH client and the specific actions performed by the malicious commands.

Recommendation

Enable process creation logging with command line details to capture the execution of ssh.exe and sftp.exe with malicious parameters.
Deploy the Sigma rule Proxy Execution via Windows OpenSSH to your SIEM to detect suspicious OpenSSH client executions with malicious commands in the command line.
Monitor for the creation of child processes from ssh.exe or sftp.exe, as this can indicate the execution of malicious commands specified in the ProxyCommand or LocalCommand options.
Review and restrict the usage of PermitLocalCommand in OpenSSH server configurations to prevent attackers from executing commands locally on the system after a connection is established.

Windows User Account Creation via Net.exe

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

Attackers may create new accounts (both local and domain) to maintain access to victim systems. This rule identifies the usage of net.exe to create new accounts on Windows systems. The detection logic focuses on process execution events where net.exe or net1.exe are executed with arguments indicative of user creation, specifically the ‘user’ argument in conjunction with either the ‘/ad’ or ‘/add’ flags. While account creation is a common administrative task, suspicious executions, especially those initiated by unusual parent processes or accounts, warrant further investigation. This rule is designed for data generated by Elastic Defend but also supports third-party data sources like CrowdStrike, Microsoft Defender XDR, and SentinelOne Cloud Funnel, enhancing its applicability across various security environments.

Attack Chain

An attacker gains initial access to a Windows system through various means, such as exploiting a vulnerability or using stolen credentials.
The attacker opens a command prompt or PowerShell session.
The attacker uses net.exe or net1.exe to create a new user account. The command includes the user argument along with /add or /ad flags. For example: net user /add.
The attacker may add the newly created user to privileged groups, such as Administrators or Domain Admins, to elevate privileges.
The attacker uses the new account to move laterally within the network, accessing sensitive data or systems.
The attacker establishes persistence by configuring the new account to be a service account or adding it to local administrator groups.

Impact

Successful exploitation can lead to unauthorized access to sensitive data, lateral movement within the network, and long-term persistence on compromised systems. The impact is often determined by the privileges assigned to the newly created account. If the attacker adds the account to the Administrators group, they can effectively take full control of the affected system. In a domain environment, creating a domain account can lead to wider compromise across the entire network.

Recommendation

Enable Sysmon process-creation logging to capture the necessary events for the rules below.
Deploy the Sigma rules in this brief to your SIEM and tune for your environment.
Investigate any instances of net.exe or net1.exe creating user accounts, especially when initiated by unusual parent processes.
Monitor for newly created accounts being added to privileged groups.
Review the triage and analysis steps in the rule’s original documentation for guidance on investigating and responding to potential incidents.

Unusual Network Connection via DllHost

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

The detection rule identifies unusual instances of dllhost.exe making outbound network connections, which may indicate adversarial command and control activity. Dllhost.exe is a legitimate Windows process used to host DLL services. Adversaries may exploit it for stealthy command and control by initiating unauthorized network connections to non-local IPs. This approach helps in identifying potential threats by focusing on unusual network behaviors associated with this process. The rule aims to detect activity related to defense evasion, where adversaries use system binaries to proxy execution. The detection logic relies on identifying dllhost.exe processes initiating network connections to destinations outside of commonly used private IP ranges.

Attack Chain

An attacker gains initial access to a Windows system (e.g., via phishing or exploitation).
The attacker executes a malicious DLL file on the compromised system.
The attacker uses dllhost.exe to host and execute the malicious DLL.
The malicious DLL initiates a network connection to an external IP address, bypassing traditional process-based network monitoring.
The attacker establishes a command and control (C2) channel via the dllhost.exe process.
The attacker uses the C2 channel to send commands and receive data from the compromised system.
The attacker performs lateral movement within the network.
The attacker exfiltrates sensitive data from the compromised network.

Impact

A successful attack can lead to the establishment of a covert command and control channel, allowing attackers to remotely control the compromised system. This can result in data theft, further compromise of the network, and potential financial loss. The references point to APT29 activity, suggesting sophisticated actors may leverage this technique.

Recommendation

Enable Sysmon process creation (Event ID 1) and network connection (Event ID 3) logging to enhance visibility of process execution and network activity (https://ela.st/sysmon-event-1-setup, https://ela.st/sysmon-event-3-setup).
Deploy the Sigma rule Unusual Network Connection via DllHost to your SIEM to detect suspicious outbound connections from dllhost.exe.
Investigate and whitelist legitimate software updates or enterprise applications that use dllhost.exe for network communications to reduce false positives, as described in the rule’s analysis notes.

Unsigned DLL Side-Loading from Suspicious Folders by Trusted Processes

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

This rule detects DLL side-loading attempts where a signed, trusted Windows program running from a suspicious directory loads a recently dropped, unsigned DLL. Attackers leverage this technique to execute malicious code within the context of a trusted process, bypassing security controls that rely on code signatures. The suspicious directories include common locations where users might inadvertently place downloaded or created files. The timeframe for “recently dropped” is defined as DLLs with a relative file creation or modification time of 500 milliseconds or less. This technique is frequently used to evade traditional security measures and gain unauthorized access or persistence on a system. This detection focuses on the combination of a trusted program, a suspicious directory, and an unsigned DLL to reduce false positives.

Attack Chain

An attacker gains initial access to a system (e.g., through social engineering or exploiting a vulnerability).
The attacker drops a malicious, unsigned DLL into a suspicious directory (e.g., C:\Users\Public\).
The attacker identifies a signed, trusted Windows program vulnerable to DLL side-loading.
The attacker executes the trusted program, ensuring it loads the malicious DLL due to DLL search order hijacking.
The malicious DLL executes within the address space of the trusted program.
The malicious DLL performs malicious actions, such as establishing persistence, escalating privileges, or exfiltrating data.
The attacker uses the compromised process to move laterally within the network.

Impact

A successful DLL side-loading attack can lead to complete system compromise, data exfiltration, and potential lateral movement within the network. This technique allows attackers to bypass application whitelisting and signature-based detection mechanisms, making it difficult to detect. The impact is significant because attackers can execute arbitrary code with the privileges of the trusted process, potentially leading to privilege escalation and the compromise of sensitive data.

Recommendation

Deploy the Sigma rule “Unsigned DLL Side-Loading from a Suspicious Folder” to your SIEM and tune for your environment to detect this specific DLL side-loading technique.
Investigate any alerts generated by the “Unsigned DLL Side-Loading from a Suspicious Folder” Sigma rule by reviewing process code signatures and DLL modification times.
Implement application whitelisting to restrict the execution of unauthorized programs.
Monitor process creation events and DLL loading events for suspicious activity, focusing on unsigned DLLs loaded by trusted processes from unusual locations.
Enable Elastic Defend or another endpoint detection and response (EDR) solution, as the rule is designed for data generated by Elastic Defend.