- While looking at the vulnerable function of SMBGhost, we discovered another vulnerability: SMBleed (CVE-2020-1206).
- SMBleed allows to leak kernel memory remotely.
- Combined with SMBGhost, which was patched three months ago, SMBleed allows to achieve pre-auth Remote Code Execution (RCE).
- POC #1: SMBleed remote kernel memory read
- POC #2: Pre-Auth RCE Combining SMBleed with SMBGhost
The SMBGhost (CVE-2020-0796) bug in the compression mechanism of SMBv3.1.1 was fixed in March 2020. As we found during our research, it’s not the only bug in the SMB decompression functionality. SMBleed happens in the same function as SMBGhost. The bug allows an attacker to read uninitialized kernel memory, as we illustrated in detail in this writeup.
The bug happens in the same function as with SMBGhost, the Srv2DecompressData function in the srv2.sys SMB server driver. Below is a simplified version of the function, with the irrelevant details omitted:
The Srv2DecompressData function receives the compressed message which is sent by the client, allocates the required amount of memory, and decompresses the data. Then, if the Offset field is not zero, it copies the data that is placed before the compressed data as is to the beginning of the allocated buffer.
The SMBGhost bug happened due to lack of integer overflow checks. It was fixed by Microsoft and even though we didn’t add it to our function to keep it simple, this time we will assume that the function checks for integer overflows and discards the message in these cases. Even with these checks in place, there’s still a serious bug. Can you spot it?
Faking OriginalCompressedSegmentSize again
Previously, we exploited SMBGhost by setting the OriginalCompressedSegmentSize field to be a huge number, causing an integer overflow followed by an out of bounds write. What if we set it to be a number which is just a little bit larger than the actual decompressed data we send? For example, if the size of our compressed data is x after decompression, and we set OriginalCompressedSegmentSize to be x + 0x1000, we’ll get the following:
The uninitialized kernel data is going to be treated as a part of our message.
If you didn’t read our previous writeup, you might think that the Srv2DecompressData function call should fail due to the check that follows the SmbCompressionDecompress call:
Specifically, in our example, you might assume that while the value of the OriginalCompressedSegmentSize field is x + 0x1000, FinalCompressedSize will be set to x in this case. In fact, FinalCompressedSize will be set to x + 0x1000 as well due to the implementation of the SmbCompressionDecompress function:
In case of a successful decompression, FinalCompressedSize is updated to hold the value of CompressedBufferSize, which is the size of the buffer. Not only this seemingly unnecessary, deliberate update of the FinalCompressedSize value made the exploitation of SMBGhost easier, it also allowed the SMBleed bug to exist.
The SMB message we used to demonstrate the vulnerability is the SMB2 WRITE message. The message structure contains fields such as the amount of bytes to write and flags, followed by a variable length buffer. That’s perfect for exploiting the bug, since we can craft a message such that we specify the header, but the variable length buffer contains uninitialized data. We based our POC on Microsoft’s WindowsProtocolTestSuites repository (that we also used for the first SMBGhost reproduction), introducing this small addition to the compression function:
Note that our POC requires credentials and a writable share, which are available in many scenarios, but the bug applies to every message, so it can potentially be exploited without authentication. Also note that the leaked memory is from previous allocations in the NonPagedPoolNx pool, and since we control the allocation size, we might be able to control the data that is being leaked to some degree.
Affected Windows versions
Windows 10 versions 1903, 1909 and 2004 are affected. During testing, our POC crashed one of our Windows 10 1903 machines. After analyzing the crash, we saw that the earliest, unpatched versions of Windows 10 1903 have a null pointer dereference bug while handling valid, compressed SMB packets. Please note, we didn’t investigate further to find whether it’s possible to bypass the null pointer dereference bug and exploit the system.
Here’s a summary of the affected Windows versions with the relevant updates installed:
Windows 10 Version 2004
- SMBGhost: Not vulnerable before or after update KB4557957
- SMBleed: Vulnerable before update KB4557957
Windows 10 Version 1909
- SMBGhost: Not vulnerable in updates KB4560960 or KB4551762, but vulnerable prior to update KB4551762
- SMBleed: Not vulnerable in update KB4560960, but vulnerable prior to and including update KB4551762
Windows 10 Version 1903
- Null Dereference bug: Not vulnerable in updates KB4560960, KB4551762 and KB4512941
- SMBGhost: Not vulnerable in updates KB4560960 and KB4551762, vulnerable in update KB4512941
- SMBleed: Not vulnerable in update KB4560960, vulnerable in updates KB4551762 and KB4512941
* We haven’t tried to bypass the null dereference bug, but it may be possible through another method (for example, using SMBGhost Write-What-Where primitive)
SMBleedingGhost? Chaining SMBleed with SMBGhost for pre-auth RCE
Exploiting the SMBleed bug without authentication is less straightforward, but also possible. We were able to use it together with the SMBGhost bug to achieve RCE (Remote Code Execution). A writeup with the technical details will be published soon. For now, please see below a POC demonstrating the exploitation. This POC is released only for educational and research purposes, as well as for evaluation of security defenses. Use at your own risk. Jamf takes no responsibility for any misuse of this POC.
Our software detects exploitation of SMBleed & SMBGhost – no further action is required. SMBleed & SMBGhost can be detected in multiple ways, including crash dump analysis, a network traffic analysis.
You can remediate both SMBleed and SMBGhost by doing one or more of the following things:
- Windows update will solve the issues completely (recommended)
- Blocking port 445 will stop lateral movements using these vulnerabilities
- Enforcing host isolation
- Disabling SMB 3.1.1 compression (not a recommended solution)
Shout out to Chompie that exploited this bug with a different technique. Chompie’s POC is available here.
Have market trends, Apple updates and Jamf news delivered directly to your inbox.