{"id":75639,"date":"2017-06-16T11:17:42","date_gmt":"2017-06-16T18:17:42","guid":{"rendered":""},"modified":"2025-12-08T13:50:32","modified_gmt":"2025-12-08T21:50:32","slug":"analysis-of-the-shadow-brokers-release-and-mitigation-with-windows-10-virtualization-based-security","status":"publish","type":"post","link":"https:\/\/www.microsoft.com\/en-us\/security\/blog\/2017\/06\/16\/analysis-of-the-shadow-brokers-release-and-mitigation-with-windows-10-virtualization-based-security\/","title":{"rendered":"Analysis of the Shadow Brokers release and mitigation with Windows 10 virtualization-based security"},"content":{"rendered":"\n

On April 14, a group calling themselves the Shadow Brokers caught the attention of the security community by releasing a set of weaponized exploits<\/a>. Shortly thereafter, one of these exploits was used to create wormable malware that we now know as WannaCrypt<\/a>, which targeted a large number of out-of-date systems and held encrypted files for ransom.<\/p>\n\n\n\n

Although the exploits are ineffective on newer platforms or attempt to take advantage of already patched vulnerabilities, they nevertheless provide an opportunity to analyze and evaluate whether the exploitation techniques used are still viable on Windows 10 systems with Creators Update.<\/p>\n\n\n\n

In Windows 10, key security enhancements such as kernel Address Space Layout Randomization (kASLR<\/a>), kernel Data Execution Prevention (DEP<\/a>), and virtualization-based security (VBS) capabilities delivered with Device Guard<\/a> all contribute to breaking the exploit techniques observed in the wild. Through VBS\u2019s usage of CPU hypervisor functionality, Device Guard-enabled systems can verify and enforce integrity of code that’s mapped in the kernel address space. Alongside Device Guard is the new kernel Control Flow Guard<\/a> (kCFG) introduced with Windows 10 Creators Update. kCFG prevents many exploitation techniques that rely on corrupting function pointers to achieve code execution.<\/p>\n\n\n\n

In this blog, we provide an in-depth analysis of two of the exploits released by the Shadow Brokers. Both exploits allow arbitrary code execution through vulnerabilities in the Server Message Block (SMBv1) file-sharing server implementation.<\/p>\n\n\n\n

We follow with a discussion about how Device Guard and kCFG prevent these exploits\u2014and many other exploits\u2014from installing backdoor implants in kernel memory.<\/p>\n\n\n\n

The exploit kit<\/h2>\n\n\n\n

The kit\u2019s directory structure shows a modular exploitation framework, where payloads are kept separate from exploits.<\/p>\n\n\n\n

All the binaries in the kit contain multiple strings that describe their purpose. Furthermore, the kit exports common functionality to DLL files, revealing additional information through referenced function names. While the strings and the function calls were not necessary for us to examine the kit, both helped speed up our initial analysis.<\/p>\n\n\n\n

For more information about the individual exploits in the kit that targeted Microsoft products, refer to the blog post from Microsoft Security Response Center<\/a>.<\/p>\n\n\n\n

ETERNALROMANCE SMB exploit<\/h2>\n\n\n\n

Let\u2019s dig into the guts of one of the exploits in the kit.<\/p>\n\n\n\n

ETERNALROMANCE is a remote code execution (RCE) exploit against the legacy SMBv1 file sharing protocol. It takes advantage of CVE-2017-0145<\/a>, which has been patched with the MS17-010 security bulletin<\/a>. One might note that file sharing over SMB is normally used only within local networks and that the SMB ports are typically blocked from the internet at the firewall. However, if an attacker has access to a vulnerable endpoint running SMB, the ability to run arbitrary code in kernel context from a remote location is a serious compromise.<\/p>\n\n\n\n

This exploit was written to remotely install and launch an SMB backdoor. At the core of this exploit is a type confusion<\/em> vulnerability leading to an attacker offset controlled<\/em> arbitrary heap write. As with almost any heap corruption<\/em> exploit, the attacker must know or control the layout of the heap to consistently succeed. With SMB, most objects are allocated in the non-paged pool.<\/p>\n\n\n\n

Getting a reliable heap layout<\/h3>\n\n\n\n

The exploit begins to spray the heap by starting several concurrent instances of SMB_ COM_TRANSACTION<\/a>. The exploit binary supports three different heap spray methods, allowing it to deal with varying pool behaviors between Windows versions. Apart from the first few allocations (the exact number depends on the pool state), transaction objects are allocated with a fixed, predictable displacement from each other. After the spray has finished, the exploit uses an info leak in a TRANS_PEEK_NMPIPE<\/em> transaction. It uses the info leak to determine whether the target is running a 32- or 64-bit version of Windows and to get kernel pointers for various SMB objects.<\/p>\n\n\n\n

Building primitives from heap corruption<\/h3>\n\n\n\n

The spray has placed many TRANSACTION<\/em> objects on the heap at a known distance from each other. And because the exploit has leaked the size of a pointer, it knows the offsets to all fields in the TRANSACTION<\/em> object. The exploit can now\u2014using carefully crafted offsets\u2014use the type confusion out-of-bounds write<\/em> from one object to corrupt an adjacent one.<\/p>\n\n\n\n

By overwriting the ID associated with the victim object with a hardcoded number (zero), the exploit can now refer to the object without knowing what the original ID was.<\/p>\n\n\n\n

The exploit proceeds to corrupt the transaction structure in a variety of ways, constructing arbitrary read-write (RW) primitives. It writes additional fields to prevent the transaction from being freed when consumed, allowing the exploit to continue reusing the same transaction for multiple requests without having to pick a new target object to corrupt.<\/p>\n\n\n\n

Installing in-memory backdoor<\/h3>\n\n\n\n

At this point, the exploit code attempts to plant backdoor code inside the SMB driver. This step consists of copying shellcode into the non-paged pool, corrupting a function pointer to point to the shellcode and having that function pointer executed. Note that starting with Windows 8, SMB has moved to using non-executable pools, rendering this method ineffective on newer platforms.<\/p>\n\n\n\n

To find a good spot for the function pointer, the exploit follows a pointer on the heap to reach the data segment. Scanning the data segment, it proceeds to look for a table of function pointers that is used to dispatch different SMB_COM_TRANSACTION2<\/em> subcommands to different functions.<\/p>\n\n\n\n

When it finds the table of function pointers, the exploit overwrites the 14th entry on this table, which corresponds to the TRANS2_SESSION_SETUP<\/em> subcommand. MSDN documentation<\/a> describes this subcommand as reserved, making it an ideal candidate for triggering the backdoor as it is almost never present in SMB traffic.<\/p>\n\n\n\n

Whenever an SMB packet is sent with this subcommand ID to the target device, the function pointer gets executed, triggering the shellcode. This mechanism and the backdoor code are not persistent\u2014they require a persistent second-stage component to survive a reboot.<\/p>\n\n\n\n

ETERNALBLUE SMB exploit<\/h2>\n\n\n\n

The WannaCrypt malware spreads by using an adapted version of the ETERNALBLUE exploit. This bug, which targets a different SMBv1 vulnerability, is a linear buffer overrun on the pool.<\/p>\n\n\n\n

The bug occurs in a special case when converting a list of extended attributes<\/a> (EA) from one format to another. If the list contains an EA entry that goes outside the packet buffer, the list is truncated as if it only included up to the last valid entry.<\/p>\n\n\n\n

When updating the length of the list, the size is written to as if it were a 16-bit ushort, when it is actually a 32-bit ulong. This means that the upper 16-bits are not updated when the list gets truncated:<\/p>\n\n\n\n

The code allocates a buffer with a size calculated to fit all EA entries up to the truncation. But as the list size was increased, this leads to a linear heap overflow with attacker controlled data.<\/p>\n\n\n\n

In a similar way as before, heap is sprayed but this time with srvnet!SRVBUFFER<\/em> objects using the SMBv2 protocol. This object contains two key pointers that they target: an MDL<\/a> pointer that receives network packet payload and a pointer to a srvnet!SRVNET_CONNECTION<\/em> object. Both pointers are overwritten so that they point to fixed addresses in the HAL region (used by the hardware abstraction layer<\/em>).<\/p>\n\n\n\n

Because of the corrupted MDL pointer, the next packet payload will get written to the HAL region. This payload contains shellcode and initializes the memory structure for a fake srvnet!SRVNET_CONNECTION<\/em> object. The connection object has a pointer to a srvnet!SRVNET_CLIENT_CONNECTION_DISPATCH<\/em> structure that contains function pointers.<\/p>\n\n\n\n

After the packet payload has been received, the SRVNET_RECEIVE_HANDLER<\/em> function pointer is executed from the attacker-controlled srvnet!SRVNET_CLIENT_CONNECTION_DISPATCH<\/em> structure, jumping to the shellcode.<\/p>\n\n\n\n

On Windows 7, which is the system that the exploit targets, the HAL region is mapped as readable, writable, and executable. On newer systems the HAL region is no longer executable, meaning that the CPU would fault when trying to execute the shellcode. Furthermore, the HAL region and other kernel regions (such as page tables) have been randomized on the latest 64-bit versions of Windows 10, breaking assumptions of the 64-bit version in the ETERNALBLUE exploit.<\/p>\n\n\n\n

Mitigation with virtualization-based security<\/h2>\n\n\n\n

Virtualization-based security (VBS) provided with Device Guard on Windows 10 and kCFG enhancements with Creators Update stop common exploitation techniques, including those utilized by ETERNALROMANCE and ETERNALBLUE.<\/p>\n\n\n\n

Stopping shellcode execution with W^X enforcement<\/h3>\n\n\n\n

On systems that have Device Guard VBS enabled<\/a>, writing and then executing shellcode\u2014such as the ETERNALROMANCE backdoor\u2014in the kernel is not possible due to W^X enforcement policies in the hypervisor. These policies ensure that a kernel memory page is never both writable and executable at any given time.<\/p>\n\n\n\n

Even if an attacker tries to attack page tables, the hypervisor is still able to force the execute-disable<\/em> bit through extended page tables (EPT)<\/a>. This in turn forces attackers to rely on code-reuse methods, such as return-orientation programming (ROP). As a consequence, the shellcode implant library in the Shadow Brokers release is fundamentally incompatible with VBS-protected systems.<\/p>\n\n\n\n

Preventing use of corrupt function pointers with kCFG<\/h3>\n\n\n\n

In Windows 10 Creators Update<\/a>, we introduced a new security mitigation in the kernel space for VBS-enabled systems. The kernel is now compiled with Control Flow Guard<\/a> (CFG)\u2014a control flow integrity solution designed to prevent common stack-pivoting techniques that rely on corrupt function pointers or C++ virtual method tables.<\/p>\n\n\n\n

Control Flow Guard in the compiled kernel (also known as kCFG<\/em>) aims to verify all indirect call targets before invoking them. This makes it harder for an attacker to execute code by abusing function pointers or other indirect calls.<\/p>\n\n\n\n

In the case of the ETERNALROMANCE exploit, the subverted function pointer would lead to a security fault when invoked, making the exploit non-functional in its current form. The same applies for ETERNALBLUE, which also relies on a corrupted function pointer to achieve code execution.<\/p>\n\n\n\n

On early Windows 10 systems before Creators Update and without Device Guard, it is possible to attack the page tables of the HAL region to turn it executable and gain code execution using the ETERNALBLUE exploit technique.<\/p>\n\n\n\n

Secure computing with Windows 10 Creators Update<\/h2>\n\n\n\n

While we actively provide patches for vulnerabilities in services like SMBv1, we strive to deliver more and more system-wide mitigations that proactively protect our users from current, as well as future, exploitation and attack methods.<\/p>\n\n\n\n

Customers who run Windows 10 Creators Update benefit from Device Guard<\/a> and security enhancements like kCFG and W^X. They also benefit from a host of other security features<\/a> that have been strengthened with Windows 10 Creators Update, including:<\/p>\n\n\n\n