Understanding Process Injection:

Process injection is a technique often used by cyber attackers to execute malicious code within the memory space of a legitimate process. By doing so, they can evade detection and gain unauthorized access to system resources. Traditionally, this method involves three key steps: allocating memory in the target process, writing the malicious code into this allocated space, and then executing the code to carry out the attack.

The Role of Windows Thread Pools:

Central to this new technique is the exploitation of Windows thread pools. Thread pools in Windows are integral for managing worker threads, which are used to perform various tasks in the background. These pools efficiently manage the execution of multiple threads, reducing the overhead associated with thread creation and destruction. In legitimate scenarios, thread pools enhance the performance and responsiveness of applications. Windows thread pools are a system feature used to manage multiple threads efficiently. These pools allow for the execution of worker threads that perform tasks in the background, optimizing the use of system resources. Thread pools are integral to the Windows operating system and are used by various applications for performing asynchronous tasks.

SafeBreach’s research delves into how these thread pools can be manipulated for malicious purposes. By exploiting the mechanisms that govern thread pool operations, attackers can inject malicious code into other running processes, bypassing traditional security measures. This technique presents a significant challenge to existing EDR solutions, which are typically designed to detect more conventional forms of process injection. Here are some examples of such manipulations:

1. Inserting Malicious Work Items:
   • Attackers can insert malicious work items into the thread pool. These work items are essentially tasks scheduled to be executed by the pool’s worker threads. By inserting a work item that contains malicious code, an attacker can execute this code under the guise of a legitimate process.
2. Hijacking Worker Threads:
   • An attacker might hijack the worker threads of a thread pool. By taking control of these threads, the attacker can redirect their execution flow to execute malicious code. This method can be particularly effective because worker threads are trusted components within the system.
3. Exploiting Timer Queues:
   • Windows thread pools use timer queues to schedule tasks to be executed at specific times. An attacker could exploit these timer queues to schedule the execution of malicious code at a predetermined time, potentially bypassing some time-based security checks.
4. Manipulating I/O Completion Callbacks:
   • Thread pools handle I/O completion callbacks, which are functions called when an I/O operation is completed. By manipulating these callbacks, an attacker can execute arbitrary code in the context of a legitimate I/O completion routine.
5. Abusing Asynchronous Procedure Calls (APCs):
   • While not directly related to thread pools, attackers can use Asynchronous Procedure Calls, which are mechanisms for executing code asynchronously in the context of a particular thread, in conjunction with thread pool manipulation to execute malicious code.
6. Worker Factory Manipulation:
   • The worker factory in a thread pool manages the worker threads. By manipulating the worker factory, attackers can potentially control the creation and management of worker threads, allowing them to execute malicious tasks.
7. Remote TP_TIMER Work Item Insertion:
   • This involves creating a timer object in the thread pool and then manipulating it to execute malicious code. The timer can be set to trigger at specific intervals, executing the malicious code repeatedly.
8. Queue Manipulation:
   • Attackers can manipulate the queues used by thread pools to prioritize or delay certain tasks. By doing so, they can ensure that their malicious tasks are executed at a time when they are most likely to go undetected.

These examples illustrate the versatility and potential stealth of using Windows thread pools for malicious purposes. The exploitation of such integral system components poses a significant challenge to cybersecurity defenses, requiring advanced detection and prevention mechanisms. The following thread pool work items that can be scheduled in Windows. Here’s how each one could potentially be vulnerable to attacks:

1. Worker Factory Start Routine Overwrite: Overwriting the start routine can redirect worker threads to execute malicious code.
2. TP_WORK Insertion: By inserting TP_WORK objects, attackers could run arbitrary code in the context of a thread pool thread.
3. TP_WAIT Insertion: Manipulating wait objects can trigger the execution of malicious code when certain conditions are met.
4. TP_IO Insertion: By intercepting or inserting IO completion objects, attackers could execute code in response to IO operations.
5. TP_ALPC Insertion: Attackers could insert ALPC (Advanced Local Procedure Call) objects to execute code upon message arrival.
6. TP_JOB Insertion: Jobs can be associated with malicious actions, executed when certain job-related events occur.
7. TP_DIRECT Insertion: Direct insertion allows immediate execution of code, which can be abused for running malware.
8. TP_TIMER Insertion: Timers can be used by attackers to schedule the execution of malicious payloads at specific times.

These vulnerabilities generally stem from the fact that thread pools execute callback functions, which attackers may manipulate to point to their code, thus achieving code execution within the context of a legitimate process.

Implications for Endpoint Detection and Response (EDR) Solutions

The research by SafeBreach Labs tested the newly discovered Pool Party variants against five leading EDR solutions: Palo Alto Cortex, SentinelOne EDR, CrowdStrike Falcon, Microsoft Defender For Endpoint, and Cybereason EDR. The result was startling, as none of the tested EDR solutions were able to detect or prevent the Pool Party attack techniques. This underscores the need for ongoing innovation in cybersecurity defense mechanisms to keep pace with evolving threats. The exploitation of Windows thread pools for process injection, as highlighted in the SafeBreach article, has significant implications for Endpoint Detection and Response (EDR) solutions. These implications necessitate a reevaluation and enhancement of current EDR strategies:

1. Challenge to Traditional Detection Methods:
   • Traditional EDR solutions often rely on signature-based detection and known behavioral patterns to identify threats. However, the manipulation of Windows thread pools represents a more sophisticated attack vector that may not be easily detected through these conventional methods. This calls for an advancement in detection technologies.
2. Need for Deeper System Monitoring:
   • EDR solutions must now consider deeper system monitoring, particularly focusing on the internals of operating systems like thread pool activities, thread creation, and execution patterns. This level of monitoring can help in identifying anomalies that are indicative of thread pool exploitation.
3. Enhancing Behavioral Analysis Capabilities:
   • EDR systems need to enhance their behavioral analysis capabilities to detect unusual activities that could signify a threat. This includes monitoring for irregularities in thread pool usage, unexpected execution of code within thread pools, and other anomalies that deviate from normal system behavior.
4. Integration of Advanced Heuristics:
   • Integrating advanced heuristics and machine learning algorithms can help EDR solutions become more proactive in detecting new and sophisticated attack methods. These technologies can learn from evolving attack patterns and adapt their detection mechanisms accordingly.
5. Improving Response Strategies:
   • In addition to detection, EDR solutions must improve their response strategies to such threats. This includes automated containment measures, quick eradication of threats, and efficient recovery processes to minimize the impact of an attack.
6. Collaboration and Threat Intelligence Sharing:
   • EDR vendors and cybersecurity experts need to collaborate and share threat intelligence actively. By understanding the latest attack trends and techniques, such as those involving thread pool exploitation, EDR solutions can be better equipped to protect against them.
7. Educating Users and Administrators:
   • EDR solutions should also focus on educating users and system administrators about these new threats. Awareness can play a crucial role in early detection and response to sophisticated attacks.
8. Regular Updates and Patch Management:
   • Continuous updating and patch management are crucial. EDR solutions must ensure that they are updated with the latest threat definitions and that they can identify vulnerabilities in systems that need patching or updates.
9. Zero Trust Approach:
   • Implementing a zero trust approach can be beneficial. EDR solutions should treat every process and thread as a potential threat until verified, ensuring strict access controls and monitoring at all levels.
10. Forensic Capabilities:
    • Enhancing forensic capabilities is essential for post-incident analysis. Understanding how an attack was carried out, including thread pool exploitation, can provide valuable insights for strengthening EDR strategies.

In summary, the exploitation of Windows thread pools for process injection presents a complex challenge for EDR solutions, necessitating a shift towards more advanced, intelligent, and comprehensive cybersecurity strategies.

Mitigation

Mitigating threats that involve the exploitation of Windows thread pools for process injection requires a multi-faceted approach, combining advanced technological solutions with proactive security practices. Here are some potential measures and recommendations:

1. Enhanced Detection Algorithms:
   • Endpoint Detection and Response (EDR) solutions should incorporate advanced algorithms capable of detecting anomalous behaviors associated with thread pool manipulation. This includes unusual activity patterns in worker threads and unexpected changes in thread pool configurations.
2. Deep System Monitoring:
   • Implement deep monitoring of system internals, especially focusing on thread pools and worker thread activities. Monitoring should include the creation of work items, modifications to timer queues, and the execution patterns of threads.
3. Regular Security Audits:
   • Conduct regular security audits of systems to identify potential vulnerabilities. This includes reviewing and updating the configurations of thread pools and ensuring that security patches and updates are applied promptly.
4. Advanced Threat Intelligence:
   • Utilize advanced threat intelligence tools to stay informed about new vulnerabilities and attack techniques involving thread pools. This intelligence can be used to update defensive measures continuously.
5. Employee Training and Awareness:
   • Educate IT staff and employees about the latest cybersecurity threats, including those involving thread pool exploitation. Awareness can help in early detection and prevention of such attacks.
6. Behavioral Analysis and Heuristics:
   • Implement security solutions that use behavioral analysis and heuristics to detect unusual patterns that might indicate thread pool exploitation. This approach can identify attacks that traditional signature-based methods might miss.
7. Zero Trust Architecture:
   • Adopt a zero trust architecture where systems do not automatically trust any entity inside or outside the network. This approach can limit the impact of an attack by restricting access and permissions to essential resources only.
8. Regular Software Updates:
   • Ensure that all software, especially operating systems and security tools, are regularly updated. Updates often include patches for known vulnerabilities that could be exploited.
9. Isolation of Sensitive Processes:
   • Isolate sensitive processes in secure environments to reduce the risk of thread pool manipulation affecting critical operations. This can include using virtual machines or containers for added security.
10. Incident Response Planning:
    • Develop and maintain a robust incident response plan that includes procedures for dealing with thread pool exploitation. This plan should include steps for containment, eradication, recovery, and post-incident analysis.

By implementing these measures, organizations can strengthen their defenses against sophisticated attacks that exploit Windows thread pools, thereby enhancing their overall cybersecurity posture.

The post How to Bypass EDRs, AV with Ease using 8 New Process Injection Attacks appeared first on Information Security Newspaper | Hacking News.

Typical methods for process injection include dynamic link library (DLL) injection, portable executable injection, thread execution hijacking, process hollowing, and process doppelganging, amongst others. Some of these methods are more well-known than others.

It is important to note that each of these techniques needs a mix of particular system calls and Windows APIs in order to carry out the injection. This enables defenders to construct proper detection and mitigation processes, which is something that should not be overlooked.

Several different approaches have been created throughout the course of time in order to accomplish the goals of code injection and execution inside the memory area of programs running under Windows. The most frequent Process Injection techniques are outlined and contrasted in the following table, which serves as a reference according to Joes Security company. The table is organized according to the Windows API calls that are necessary for the methods’ effective implementation.

Mockingjay is distinguished from other programs due to the fact that it circumvents these security layers. It does this by removing the requirement to run Windows application programming interfaces (APIs), which are typically monitored by security solutions. Instead, it makes use of pre-existing Windows portable executable files that already come with a memory block that is protected with Read-Write-Execute (RWX) permissions.

This, in turn, is achieved with the help of msys-2.0.dll, which comes with a “generous 16 KB of available RWX space,” making it an excellent candidate to load malicious code and slip under the radar at the same time. Having said that, it is important to highlight the possibility that there might be more vulnerable DLLs that have comparable qualities.

The business said it investigated two distinct approaches, known as self injection and remote process injection, to perform code injection in a way that not only enhanced the effectiveness of the attack but also evaded detection.

The first method involves using a specialized program in order to directly load the vulnerable DLL into the address space of the application, which then allows the RWX section to finally carry out the intended execution of code. In contrast, remote process injection involves using the RWX section of a vulnerable DLL in order to carry out process injection in a remote process such as ssh.exe. This may be accomplished by leveraging the vulnerable DLL.

The distinctiveness of this approach lies in the fact that it is not necessary to allocate memory, set permissions, or create a new thread within the target process in order to initiate the execution of our injected code.It is difficult for Endpoint Detection and Response (EDR) systems to identify this tactic since it differs from other currently used strategies.

The post New Antivirus, EDR detection evading technique allows injecting code in trusted Windows process appeared first on Information Security Newspaper | Hacking News.

In order to circumvent this security precaution, attackers must either devise a method to acquire a malicious driver certified by a trustworthy certificate or engage in a BYOVD attack, in which they exploit a legal commercial software driver in order to accomplish their objective. Both of these options are very difficult to do. In contrast, the malware takes use of a genuine driver that is not up to date and may be exploited. A “bring your own vulnerable driver” (BYOVD) attack is the usual name for this kind of attack.

In this particular instance, the attackers made use of a driver that was not only developed by Microsoft but also signed by the company. The team at Sysinternals has developed a suite of administrative tools, one of which is called Process Explorer driver. This driver has a number of features that allow users to interact with processes that are currently active.

Sophos X-Ops has conducted an investigation into many occurrences over the course of the previous few months, all of which included attackers attempting to deactivate EDR clients by using a novel defensive evasion technique that we have named AuKill. In order to deactivate EDR processes on the target machine before installing either a backdoor or ransomware, the AuKill program takes use of an old version of the driver that is utilized by version 16.32 of the Microsoft application known as Process Explorer.

Since the beginning of 2023, the tool has been used in at least three ransomware instances in order to thwart the target’s protection and install ransomware. These events are as follows: In January and February, attackers utilized the program after delivering the ransomware known as Medusa Locker; in February, one attacker used AuKill just before releasing the malware known as Lockbit.

A driver with the name PROCEXP.SYS is placed in the C:\Windows\System32\drivers directory when using AuKill. This driver is from the release version 16.32 of process Explorer. The official driver for Process Explorer has the filename PROCEXP152.sys, and it is often located in the same directory as the fake driver. Both drivers may be installed on a computer at the same time if that computer is running a copy of Process Explorer. Additionally, the AuKill installer will place an executable version of itself in either the System32 or the TEMP directory, where it will operate automatically as a background service.

For instance, user-mode programs may send the IO control code IOCTL_CLOSE_HANDLE to the driver, which instructs the driver to shut a protected process handle, which ultimately results in the process being terminated.

For an attacker to successfully exploit this process, administrator rights on the target machine are required. When an attacker succeeds in gaining administrator rights, it normally indicates that the attacker now has complete control over the computer.

In order to get beyond such security measures, attackers need to go one step further and start a driver while it is in kernel mode. In this instance, AuKill circumvents these security measures by exploiting a valid driver that is used by Process Explorer.
In most cases, an EDR client is made up of a number of different parts that cooperate with one another. One example of a component is a currently-running process or an already-installed service, each of which has its own set of capabilities. Therefore, in the event that one freezes or shuts down, it often resumes as quickly as it can.

AuKill initiates several threads in order to guarantee that the EDR processes and services do not become active again, which helps avoid these components from having to be restarted. Each thread focuses on a particular component and checks in a continual manner to see whether the processes or services that it is targeting are active. AuKill will deactivate or terminate it if any of them are, if any of them are.
The practice of disabling EDR clients by utilizing drivers, whether such drivers are valid but misused for malicious purposes (BYOVD) or are issued by a certificate that was stolen or leaked, remains common among adversaries who wish to deactivate protection systems.

Over the course of the previous year, members of the security community documented many situations in which drivers were used as weapons for nefarious reasons. The finding of such a tool lends credence to the theory that adversaries are continually working to weaponize drivers.

The post How to use “bring your own vulnerable driver” (BYOVD) technique to kill/evade Antivirus or EDR appeared first on Information Security Newspaper | Hacking News.