JRASP十分重视自身安全性的建设，采用了多种方式提高RASP自身的安全防护能力，包括：

• 策略配置加密；

• RASP自身代码与业务隔离；

• 安全策略模块磁盘加密、运行时解密；

• Agent与Daemon的socket通讯加密；

作为开源项目，如果熟悉JRASP的初始化和关闭流程，将存在一类重要的绕过方式： 调用RASP的关闭或者卸载开关。 具体可以参考下面的文章：

RASP的安全攻防研究实践 https://www.cnblogs.com/wh4am1/p/16780056.html

本文主要介绍下JRASP如何防止关键方法被反射调用。 先来看下JDK 的反射机制。

1. JDK代码中的反射与限制

1.1 反射Demo

一般的我们可以通过调用class对象的 getDeclaredMethods来获取该类的所有的方法（包含私有方法）。 下面的代码定义了一个Foo类和私有的bar方法，并使用反射获取bar方法。

import java.lang.reflect.Method;
public class Foo {
    private void bar() {    }
    public static void main(String[] args) throws Exception {        Method method = Foo.class.getDeclaredMethod("bar");        if (method != null) {            System.out.println(method.getName());        }    }
}// 代码输出：bar

如果给类Foo中加上如下的静态代码:

static {    Reflection.registerMethodsToFilter(Foo.class, "bar"); }

再次运行main，输出如下：

加上静态代码块之后，方法执行抛出了 java.langNoSuchMethodException

1.2 反射源码解析

在JDK中，对于一些执行权限较高的类如 sun.misc.Unsafe，其中的 getUnsafe方法也是无法通过反射获取。 原因是 sun.misc.Unsafe的静态块中也有这么一行代码:

static {    Reflection.registerMethodsToFilter(Unsafe.class, new String[]{"getUnsafe"});}

这个方法的作用通过方法名就可以看出来了: 注册方法到过滤器。这个方法需要传两个参数,第一指明要过滤的Class对象, 第二个是个String数组，里面放要过滤掉的方法名称。

Reflection在sun.reflect包下,该类维护了两个Map:

private static volatile Map<Class<?>, String[]> fieldFilterMap;private static volatile Map<Class<?>, String[]> methodFilterMap;

以Class对象作为key值，一个保存需要过滤的属性名数组，一个保存需要过滤的方法名数组。 从上面的方法名称可以知道，在获取反射方法或者字段时，JVM根据class对象注册的方法或者字段的过滤器，将指定方法或者字段进行了排除。

下面重点分析下整个过滤的过程：

getDeclaredMethod源码如下， searchMethods使用类名称和参数列表从方法列表中查找出指定的方法。

查找方法的范围来源于 privateGetDeclaredMethods方法返回值，其源码如下：

1处：为方法的缓存，如果已经有缓存，直接返回方法列表；

2处：如果方法的缓存为null，从JVM中获取全部的方法，并对方法进行过滤，然后将过滤的结果设置为缓存。

过滤使用了Reflection的静态字段 methodFilterMap，该字段的定义如下：

1.3 一般应用

JVM提供了禁止反射指定类的方法和字段的功能，对于RASP中的关键方法字段(如关闭、初始化和状态控制等)，我们可以将其设置为禁止反射：

2. 方法调用者鉴权

2.1 @CallerSensitive

还有一类场景能够绕过 禁止方法直接反射，即反射调用其他方法，该方法能够调用关闭的方法，即：

恶意方法--(反射调用)--> 方法A--(直接调用)--> 关键方法B

从而达到任意调用关键方法的目的，JVM 提供了注解 @CallerSensitive来解决反射层次问题，但是该方案存在一些限制, @CallerSensitive 需要配合 Reflection.getCallerClass() 来使用，而调用 getCallerClass的类不能是自定义类加载加载的类。

JRASP核心逻辑全部由自定义加载器加载，@CallerSensitive注解方案不可行。

2.2 调用栈特征识别

JRASP对于自定义加载器加载的类中的关键方法都采用了栈特征校验：

• 检查调用栈是否存在反射，即栈特征是否存在 java.lang.reflect.等相关特征

• 调用来源是否为指定的类。如下所示给出一个例子：

并将caller 定义为不可变常量. 

3. 总结

本文给出了RASP关键方法的保护方案，使用JVM提供的过滤器来禁止直接反射调用， 对于间接反射调用的来源和栈特征做了校验， 提升RASP自身安全防护水平。

-----------------------------------------------------------------

官方网站：https://www.jrasp.com ‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

github:  https://github.com/jvm-rasp/jrasp-agent.git

阅读原文

热加载与卸载已经成为RASP的标配，而涉及到插件或者脚本的卸载问题，却少有技术文档提及， 主要原因是RASP开

热加载与卸载已经成为RASP的标配，而涉及到插件或者脚本的卸载问题，却少有技术文档提及， 主要原因是RASP开发人员更多的偏向安全，即使是经验丰富的Java工程师，遇到内存泄露问题，也会感到棘手。

类卸载的条件十分苛刻，要同时满足下面的三个条件：

• 类所有的实例对象已经被回收;

• 加载该类的Classloder已经被回收;

• 该类对应的java.lang.Class对象没有任何对方被引用;

一般的，无需关心class对象的引用关系，但是有些场景（如反射场景）会缓存类的Class对象，使得class对象的引用存在，导致JRASP无法卸载。

2. 类加载器置空

以JDK8为例子，Java虚拟机自带的类加载器有BootstrapClassLoader、ExtensionClassLoader和SystemClassLoader， 这些类加载器在JVM整个生命周期中都不会被置为空，因此它们加载的类也不会被卸载。

而用户自定义的类加载器，可以在使用完成之后将加载器的对象置空，从而满足类卸载的三个条件之一。

以JRASP代码为例子，执行卸载关闭操作之后，将自定义类加载器置空。

如果自定义类加载器没有正确的置空，JRASP将不会被完全的清理，从而引发内存泄漏。 现在我们做一个测试，将上面代码截图的第90行的 raspClassLoader=null;注释掉（即类加载器不置空)。

打包编译后加载JRASP后再执行卸载操作，主动Full GC jmap-histo:live50730|grep com.jrasp.agent.core，结果如下所示：

 206:            50           3200  com.jrasp.agent.core.log.LogRecord 307:            12           1344  com.jrasp.agent.core.classloader.ModuleJarClassLoader 460:            12            480  com.jrasp.agent.core.module.CoreModule 542:            12            288  [Lcom.jrasp.agent.core.classloader.RoutingURLClassLoader$Routing; 548:            12            288  com.jrasp.agent.core.classloader.RoutingURLClassLoader$Routing // 其他类省略...

在Full GC之后，JRASP实例个数不为空，存在内存泄漏。使用性能诊断（jprofile，eclipse的MAT工具也是可以）工具，查看JRASP的对象：

查看其中一个对象的引用关系，如下所示：

从上图的引用关系可以明显看出，存在一条引用链路，链路从 RaspClassloader开始指向 LogRecord （上图中两个红色圈的之间的灰色线） (黄色为class对象，红色为GC Roots)

内存泄漏的原因：classloader没有置为空，导致内存泄漏。

3. 对象置空和资源关闭

以JRASP为例说明，这里包括线程池关闭、自定义线程、定时器停止、shutdownHook移除、ClassFileTransformer移除和threadlocal线程变量清除等.

3.1 定时器停止

完全停止 java.lang.timer，需要将定时器线程停止，并将任务执行队列清空。

3.2 shutdownHook移除

在Java进程关闭之前，能够即时的清理rasp占用的磁盘等资源，shutdownHook可以执行指定的操作。

如果主动关闭rasp，没有清理shutdownHook，将会导致内存泄漏。

3.3 线程池关闭

如果RASP使用到了线程池，在卸载时需要关闭。即使关闭了线程池，由于jvm线程池重写了 finalize方法，一次FullGC依然无法清除残留的对象。 JRASP 1.2.x(商业版本) 已经把线程池替换为多个 java.lang.timer，卸载时非常清爽干净。

3.4 线程变量的清除

在JRASP中，使用线程变量threadlocal关联请求上下文与具体的hook类，来辅助检测功能。

在RASP卸载时，需要将线程thread中缓存的threadlocal对象。

在介绍JRASP实现方案之前，先来看下tomcat是如何实现热卸载的和内存泄漏检测的。

3.4.1 tomcat资源清除与内存泄漏检测

tomcat在卸载war包时，调用war的类加载器 WebappClassLoaderBase对象的stop方法完成资源的关闭与清理操作。

具体的引用清除实现来在 clearReferences中，主要有：注销JDBC驱动、关闭应用创建的线程、检查线程变量的内存泄漏等，关闭连接和线程的操作容易实现，本节主要针对线程变量的内存泄漏清理与检测。

• 线程变量泄漏检测

在线程Thread对象中使用两个字段保存该线程使用的 threadlocal对象：

public class Thread implements Runnable {
    /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;
    /*
     * InheritableThreadLocal values pertaining to this thread. This map is
     * maintained by the InheritableThreadLocal class.
     */
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
    // 其他代码省略...
}   

threadLocals的类型是 ThreadLocalMap，ThreadLocalMap中用数组table保存threadlocal变量的key、value。 因此最终我们需要清理的是这个table里面的Entry。

static class ThreadLocalMap {
    static class Entry extends WeakReference<ThreadLocal<?>> {
        Object value;
        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
    // 保存threadlocal变量的key、value
    private Entry[] table;
}    

tomcat中线程变量的内存泄漏检测代码在 checkThreadLocalsForLeaks中。

主要是反射threadLocals、inheritableThreadLocals

3.4.2 JRASP线程清除方案

一般的在使用完线程变量之后，要及时的调用 threadlocal.remove() 将线程变量移除。 但是对于RASP来说，业务线程池线程复用机制，并且无法确定什么时候任务执行完成，也就无法在任务执行完成之后清除。

JRASP采用类似于tomcat线程变量内存泄漏的检测方式，即反射调用 threadlocal.remove()方法。

cleanThreadLocals的实现：

上面的方案存在一些限制，JDK17以上禁止了跨模块的反射，上面的反射调用执行会报错，需要业务在JVM参数中增加 --add-opens=java.base/java.lang=ALL-UNNAMED 解除限制。（增加参数成本较低，业务使用了三方包也会开启该参数）

4. 总结

  本文介绍了JRASP卸载时的一些坑，并给出了解决方案，特别是线程池的threadlocal内存泄漏， 给出了检测和卸载代码，该方案在JRASP上使用较为成功。

在宿主机上启动一个tomcat docker镜像启动jrasp守护进程daemon自动发现Java进程，包括

在宿主机上启动一个tomcat docker镜像

启动jrasp守护进程daemon自动发现Java进程，包括容器中Java进程

容器中Java进程pid为1，宿主机上进程的pid为2523392

控制台上看到进程

特性 1：注入容器中 Java 进程‍

进入到进程/proc目录，jrasp需要的安装包已经自动安装到了容器中了（不包含 jrasp-daemon）。

进程已经处于防护状态

特性 2：日志传输使用socket

1.1.x 版本日志写入磁盘，需要借助logagent完成日志收集和投递；1.2.x 版本不再需要安装logagent；所有日志通过socket传输到控制台，agent或者daemon断开连接后日志写入磁盘，重连后自动回传离线日志；

特性 3：模块配置自动提取

编译时通过@RaspValue注解提取配置参数

注：1.2.x 将是2024年主要维护版本

阅读原文

国泰新点软件公司围绕智慧招采、智慧政务、数字建筑三大核心业务领域，为各级政府部门、大型集团企业及相关行业单位

国泰新点软件公司围绕智慧招采、智慧政务、数字建筑三大核心业务领域，为各级政府部门、大型集团企业及相关行业单位提供从规划咨询、软件开发与智能设备研发、实施交付到持续运营维护的全方位服务。

https://www.epoint.com.cn/

一、背景介绍

⽬前开源的RASP产品中，有百度open-rasp、jrasp和字节hids-rasp等多款产品。在产品选型阶段，因为公司内部有不少华为ARM指令架构的国产系统，中间曾经尝试编译ARM V8检测引擎但由于缺少源码最终失败，无奈只能放弃；字节HIDS/RASP安全策略不多，偏向于"⽇志时收集器"，⽆法满⾜当前的⽣产环境的需求。在试⽤了⼀款商业RASP后，“机缘巧合”下找到了开源的jrasp，于是开始安装试用。

二、项目信心

尽管JRASP项⽬在github上star数量和安装量都不多，但是经过与作者⼀段时间的技术交流，发现他⻓期从事JavaAgent开发⼯作，在性能诊断、故障演练、全链路监控等⽅⾯经验⾮常丰富，并且对同类产品如btrace、skywalking和open-rasp等有源码级别的理解。jrasp项⽬吸收了同类产品的优势，核⼼框架层的代码最早的可以追溯到10年前，稳定耐⽤bug极少。

三、业务特征

3.1、业务特征

公司共有3000多个项⽬，分布在全国各地，每个项⽬的节点数量在20～200台，总节点数量超过10万规模。每个项⽬相互隔离，要求在每个项⽬部署安全产品，所有的安全产品共⽤1台主机(RASP产品占⽤约0.5台)。

3.2、JRASP的整体架构

主要包含三个部分：jrasp-agent、jrasp-daemon、jrasp-admin；

检测插件模块化：每种模块解决⼀类安全漏洞，并且模块可以做到热升级；

3.3、安装部署

需要准备的资源：4核8GB配置主机⼀台，⽤做管理端。

管理端编译安装⽂档：https://github.com/jvm-rasp/web/blob/master/README.md
Agent安装⽂档：https://www.jrasp.com/guide/install/v1.1.3/jrasp-agent.html

四、性能对比

在上线之前做了严格的性能测试，并且对多款产品进行性能测试，因为涉及到其他商业化产品，细节数据不便展示，可以总结为：整体性能与open-rasp相当。

五、主要改造

一般来说RASP产品⽆法直接在企业内部使⽤，必须经过⼀定的改造以适应公司内部的⽣态环境。主要的改造有：

1.兼容 windows、macos、linux（x86_64、aarch64）；
2.⽀持宿主机上的docker安装运⾏；
3.新增多个检测模块如内存⻢和SQL注⼊等；
4.模块运⾏时解密，提⾼策略的安全性；
5.管理端由Java改造为Golang，使得管理端资源占⽤少；
6.复⽤jrasp的注⼊层框架，检测策略进⾏了较⼤的重写；
除了通⽤的功能改造外，还对JRASP做了⼀些专属改造，如增加公司⾃研的登录框架的弱密码检测模块，流量解密模块等，管理端增加了内部的移动设备登录功能，简化了模块与策略的配置流程等。

六、安装部署

总接入项目250多个，总接入应用数量1w多个，经过⻓达半年的灰度部署过程中，累计发现并修复数⼗个兼容性问题和bug，产品稳定性、性能逐步稳定。

七、性能优化

jrasp框架层⾯没有性能上的瓶颈，性能主要体现在检测模块上，如新增的sql词法分析算法，初始版本导致cpu飙⾼参考:https://www.jrasp.com/guide/case/case20230619/case20230619.html；web应⽤名称的识别上，存在bug导致守护进程cpu飙升。参考：https://www.jrasp.com/guide/case/case20230902/case20230902.html

阅读原文

跳转微信打开

这里讲讲RASP目前的防护能力与检测思路，开文先讲述整体架构，后面挑一些重点讲讲，包括其中的部分防护策略以及目前的性能情况、运营中遇到的问题。

许纬地，平安银河实验室安全研究员，研究方向为蓝军攻击、RASP防护、云原生等。

🔥🔥🔥国内技术领先的开源RASP社区：https://www.jrasp.com

阅读原文

跳转微信打开

“ RASP漏洞防御之 shiro 反序列化” ApacheShiro框架提供了记住我的功能（Remembe

“ RASP漏洞防御之 shiro 反序列化”

 ApacheShiro框架提供了记住我的功能（RememberMe），用户登陆成功后会生成经过加密并编码的cookie，在服务端接收cookie值后，Base64解码–>AES解密–>反序列化。攻击者只要找到AES加密的密钥，就可以构造一个恶意对象，对其进行序列化–>AES加密–>Base64编码，然后将其作为cookie的rememberMe字段发送，Shiro将rememberMe进行解密并且反序列化，最终造成反序列化漏洞。

    在反序列化时,不会对其进行过滤,所以如果传入恶意代码将会造成安全问题在 1.2.4 版本前,是默认ASE秘钥,Key: kPH+bIxk5D2deZiIxcaaaA==,可以直接反序列化执行恶意代码，而在1.2.4之后,ASE秘钥就不为默认了,需要获取到Key才可以进行渗透。

01

—

模块编写

了解下攻击原理之后，很容易针对性的构建防御模块，借助 jrasp基础设施，很容易堵住漏洞。

• hook类以及密钥设置
  

private Set<String> shiroBlackKeySet = new HashSet<String>(Arrays.asList(       // 在 1.2.4 版本前,是默认ASE秘钥,Key: kPH+bIxk5D2deZiIxcaaaA== 可以直接反序列化执行恶意代码       "kPH+bIxk5D2deZiIxcaaaA=="));
@Overridepublic void loadCompleted() {      new EventWatchBuilder(moduleEventWatcher)            .onClass(new ClassMatcher("org/apache/shiro/mgt/AbstractRememberMeManager")                      .onMethod("getDecryptionCipherKey()[B", new GetDecryptionCipherKeyListener()))            .build();}

检测方法：

public class GetDecryptionCipherKeyListener extends AdviceListener {                                                                                                        @Override                                                                                                                                                               protected void afterReturning(Advice advice) throws Throwable {                                                                                                             if (disable) {                                                                                                                                                              return;                                                                                                                                                             }                                                                                                                                                                       String key = Base64.encode((byte[]) advice.getReturnObj());                                                                                                             for (String item : shiroBlackKeySet) {                                                                                                                                   if (StringUtils.isNotBlank(item) && item.equals(key)) {                                                                                                               boolean enableBlock = shiroRememberMeAction == 1;                                                                                                                       AttackInfo attackInfo = new AttackInfo(                                                                                                                                         context.get(), metaInfo, key, enableBlock,                                                                                                                              "Shiro default passwd", SHIRO_REMEMBER_ME,                                                                                                                              "detect shiro default cipher key: " + key,                                                                                                                              100);                                                                                                                                                           log.attack(attackInfo);                                                                                                                                                 if (enableBlock) {                                                                                                                                                          ProcessController.throwsImmediatelyAndSendResponse(attackInfo, raspConfig, new RuntimeException("detect shiro default cipher key block by JRASP."));                }                                                                                                                                                                       return;                                                                                                                                                             }                                                                                                                                                                   }                                                                                                                                                                   }                                                                                                                                                                   }

代码详见：https://github.com/jvm-rasp/jrasp-agent.git

说明：代码由 @是小易呀、@hycsxs 提供

02

—

实战

攻击日志：

2023-06-30 23:03:16.597 WARNING MacBook-Pro.local [http-nio-8080-exec-1] [attack.attack] {    "context":{        "method":"GET",        "protocol":"HTTP/1.1",        "localAddr":"127.0.0.1",        "remoteHost":"127.0.0.1",        "requestURL":"http://localhost:8080/login",        "requestURI":"/login",        "contentType":"null",        "contentLength":-1,        "characterEncoding":"null",        "parameters":"",        "header":"c:cHdk\naccept-language:zh-CN,zh;q=0.9\ncookie:rememberMe=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\nhost:localhost:8080\nconnection:close\naccept-encoding:gzip, deflate\nuser-agent:Mozilla/5.0 (compatible; Baiduspider/2.0; +http://www.baidu.com/search/spider.html)\naccept:text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",        "queryString":"",        "marks":"",        "body":""    },    "appName":"null",    "metaInfo":"shiro-hook-1.1.2-2023-06-30T15:00:36Z",    "stackTrace":"org.apache.shiro.mgt.AbstractRememberMeManager.getDecryptionCipherKey(AbstractRememberMeManager.java:202),org.apache.shiro.mgt.AbstractRememberMeManager.decrypt(AbstractRememberMeManager.java:489),org.apache.shiro.mgt.AbstractRememberMeManager.convertBytesToPrincipals(AbstractRememberMeManager.java:429),org.apache.shiro.mgt.AbstractRememberMeManager.getRememberedPrincipals(AbstractRememberMeManager.java:396),org.apache.shiro.mgt.DefaultSecurityManager.getRememberedIdentity(DefaultSecurityManager.java:604),org.apache.shiro.mgt.DefaultSecurityManager.resolvePrincipals(DefaultSecurityManager.java:492),org.apache.shiro.mgt.DefaultSecurityManager.createSubject(DefaultSecurityManager.java:342),org.apache.shiro.subject.Subject$Builder.buildSubject(Subject.java:846),org.apache.shiro.web.subject.WebSubject$Builder.buildWebSubject(WebSubject.java:148),org.apache.shiro.web.servlet.AbstractShiroFilter.createSubject(AbstractShiroFilter.java:292),org.apache.shiro.web.servlet.AbstractShiroFilter.doFilterInternal(AbstractShiroFilter.java:359),org.apache.shiro.web.servlet.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:125),org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193),org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166),org.springframework.web.filter.RequestContextFilter.doFilterInternal(RequestContextFilter.java:100),org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119),org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193),org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166),org.springframework.web.filter.FormContentFilter.doFilterInternal(FormContentFilter.java:93),org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119),org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193),org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166),org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:201),org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119),org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193),org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166),org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:202),org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:96),org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:526),org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:139),org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:92),org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:74),org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:343),org.apache.coyote.http11.Http11Processor.service(Http11Processor.java:367),org.apache.coyote.AbstractProcessorLight.process(AbstractProcessorLight.java:65),org.apache.coyote.AbstractProtocol$ConnectionHandler.process(AbstractProtocol.java:860),org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1591),org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:49),java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149),java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624),org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61),java.lang.Thread.run(Thread.java:748)",    "payload":"kPH+bIxk5D2deZiIxcaaaA==",    "isBlocked":false,    "attackType":"Shiro default passwd",    "algorithm":"shiro-remember-me",    "extend":"detect shiro default cipher key: kPH+bIxk5D2deZiIxcaaaA==",    "attackTime":1688137396594,    "level":100}

‍

 如果不阻断，还会有rce日志

2023-06-30 23:03:26.352 WARNING MacBook-Pro.local [http-nio-8080-exec-1] [attack.attack]{    "context":{        "method":"GET",        "protocol":"HTTP/1.1",        "localAddr":"127.0.0.1",        "remoteHost":"127.0.0.1",        "requestURL":"http://localhost:8080/login",        "requestURI":"/login",        "contentType":"null",        "contentLength":-1,        "characterEncoding":"null",        "parameters":"",        "header":"c:cHdk\naccept-language:zh-CN,zh;q=0.9\ncookie:rememberMe=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\nhost:localhost:8080\nconnection:close\naccept-encoding:gzip, deflate\nuser-agent:Mozilla/5.0 (compatible; Baiduspider/2.0; +http://www.baidu.com/search/spider.html)\naccept:text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",        "queryString":"",        "marks":"",        "body":""    },    "appName":"null",    "metaInfo":"rce-algorithm-1.1.2-2023-06-30T15:00:36Z",    "stackTrace":"java.lang.UNIXProcess.forkAndExec(UNIXProcess.java),java.lang.UNIXProcess.<init>(UNIXProcess.java:247),java.lang.ProcessImpl.start(ProcessImpl.java:134),java.lang.ProcessBuilder.start(ProcessBuilder.java:1029),x.Test1188778292502339.<init>(Test1188778292502339.java),sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method),sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62),sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45),java.lang.reflect.Constructor.newInstance(Constructor.java:423),com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl.getTransletInstance(TemplatesImpl.java:457),com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl.newTransformer(TemplatesImpl.java:485),sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method),sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62),sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43),java.lang.reflect.Method.invoke(Method.java:498),org.apache.commons.collections.functors.InvokerTransformer.transform(InvokerTransformer.java:126),org.apache.commons.collections.map.LazyMap.get(LazyMap.java:158),org.apache.commons.collections.keyvalue.TiedMapEntry.getValue(TiedMapEntry.java:74),org.apache.commons.collections.keyvalue.TiedMapEntry.hashCode(TiedMapEntry.java:121),java.util.HashMap.hash(HashMap.java:339),java.util.HashMap.readObject(HashMap.java:1413),sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method),sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62),sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43),java.lang.reflect.Method.invoke(Method.java:498),java.io.ObjectStreamClass.invokeReadObject(ObjectStreamClass.java:1185),java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:2256),java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2147),java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1646),java.io.ObjectInputStream.readObject(ObjectInputStream.java:482),java.io.ObjectInputStream.readObject(ObjectInputStream.java:440),org.apache.shiro.io.DefaultSerializer.deserialize(DefaultSerializer.java:77),org.apache.shiro.mgt.AbstractRememberMeManager.deserialize(AbstractRememberMeManager.java:514),org.apache.shiro.mgt.AbstractRememberMeManager.convertBytesToPrincipals(AbstractRememberMeManager.java:431),org.apache.shiro.mgt.AbstractRememberMeManager.getRememberedPrincipals(AbstractRememberMeManager.java:396),org.apache.shiro.mgt.DefaultSecurityManager.getRememberedIdentity(DefaultSecurityManager.java:604),org.apache.shiro.mgt.DefaultSecurityManager.resolvePrincipals(DefaultSecurityManager.java:492),org.apache.shiro.mgt.DefaultSecurityManager.createSubject(DefaultSecurityManager.java:342),org.apache.shiro.subject.Subject$Builder.buildSubject(Subject.java:846),org.apache.shiro.web.subject.WebSubject$Builder.buildWebSubject(WebSubject.java:148),org.apache.shiro.web.servlet.AbstractShiroFilter.createSubject(AbstractShiroFilter.java:292),org.apache.shiro.web.servlet.AbstractShiroFilter.doFilterInternal(AbstractShiroFilter.java:359),org.apache.shiro.web.servlet.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:125),org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193),org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166),org.springframework.web.filter.RequestContextFilter.doFilterInternal(RequestContextFilter.java:100),org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119),org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193),org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166),org.springframework.web.filter.FormContentFilter.doFilterInternal(FormContentFilter.java:93),org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119),org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193),org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166),org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:201),org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119),org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193),org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166),org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:202),org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:96),org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:526),org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:139),org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:92),org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:74),org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:343),org.apache.coyote.http11.Http11Processor.service(Http11Processor.java:367),org.apache.coyote.AbstractProcessorLight.process(AbstractProcessorLight.java:65),org.apache.coyote.AbstractProtocol$ConnectionHandler.process(AbstractProtocol.java:860),org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1591),org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:49),java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149),java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624),org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61),java.lang.Thread.run(Thread.java:748)",    "payload":"/bin/sh -cpwd",    "isBlocked":false,    "attackType":"\u547d\u4ee4\u6267\u884c",    "algorithm":"rce token contains in http headers",    "extend":" ",    "attackTime":1688137406351,    "level":80}

官网地址：https://www.jrasp.com

开源地址:   https://github.com/jvm-rasp

最近半年，JRASP新版本在甲方内部不断迭，经过性能、功能和稳定性等测试，达到可用标准。

     最近半年，JRASP新版本在甲方内部不断迭，经过性能、功能和稳定性等测试，达到可用标准。

01

—

v1.1.1 四大主要特性

01.模块安全加密

在1.1.1版本之前，模块的策略算法以及配置都是明文，很容易被反编译，RASP自身的安全性不高。业内常用的提高RASP代码安全性的方式是代码混淆，但是混淆后的代码无法debug，对于排查问题非常不便。      

JRASP使用对称加密方式保障模块的安全性，模块磁盘加密在运行时有模块专属类加载器解密，极大的提高了代码的安全性。另外，为了降低加密成本，提供了maven插件，用户仅需要设置加密密钥即可一键打包。详情参考：JRASP v1.1.1 新特性之插件运行时解密技术

02.组件轻量化

在之前版本，管理端和daemon之间依赖配置中心nacos、日志组件 kafka等，这些组件往往需要集群部署才能保证可靠性，部署成本较高。在当前版本中，守护进程与管理端建立websocket通信链路，用来传递配置和心跳数据。日志传输由filebeat使用http方式传递给管理端，省去了中间的kafka等中间过程。仅需要一台机器(2核4g)即可以部署jrasp，支持的agent达到万级别。

03.管理端使用golang重构

使用SpringBoot构建管理端，资源占用几个GB，而实现相同功能，golang 仅需几百MB。并且Java框架潜在漏洞风险较高，所以在新的版本中抛弃了SpringBoot框架（Java ），使用gin 框架（Golang） 重构客户端功能。性能和安全性得到较大提升。

04.新增/加强检测模块

• 新增内存马检测模块，该功能由 @hycsxs 等提供。内存检测模块，采用行为检测算法（无规则算法），经过多种内存马检测工具验证（冰蝎哥斯拉），具备较强的检测能力。
  

• 加强SQL注入检测模块。sql注入检测模块在druid防火墙基础上，增加了词法分析检测， 具备较强的难饶过能力。
  

02

—

v1.1.2 新特性说明

• 日志功能加强。jrasp日志传输当前强依赖于filebeat，并且在容器环境filebeat不太合适。1.1.2版本将所有日志不落盘，日志传输通过rasp自身能力实现，不依赖第三方组件，进一步减少系统依赖。

  
  

• 支持宿主机对容器内的Java进程注入。大多数场景下，宿主机/物理机上既有容器又有java进程，场景较为复杂。当前普遍的做法是在宿主机上部署一套rasp，然后在容器内也安装一套rasp，安装多套对系统的资源压力较大。较为正确的做法是，rasp安装在宿主机层面同时支持容器/java进程注入。困难点：容器内文件与宿主机隔离、对容器内的java进程识别与注入、模块文件更新等。上面的几个困难点，目前均已经攻克，实施方法也是业内首创。（经过验证之后，计划2023年10月开源）

jrasp 官方网站：https://www.jrasp.com

 开源项目：https://github.com/jvm-rasp

"打铁还需自身硬"，JRASP在防护业务安全的同时，也十分重视自身安全性建设。JRASP的防护策略(

    "打铁还需自身硬"，JRASP在防护业务安全的同时，也十分重视自身安全性建设。JRASP的防护策略(包括hook类、参数检测逻辑等) 仍然一定程度上于依赖信息不对称，如何保障策略在传输过程、运行时不被恶意窃取分析是一个重要问题。 JRASP对整个通信链路进行了加密，包括：

• 管理端下发给守护进程的的安全策略加密；

• 守护进程与agent通信的socket加密，防止插件被控制；

• 插件jar包传输全过程加密，在类加载时解密，最大程度防止jar包被反编译；

    上面的第1、2点易实现，技术难点不高，因此本文将介绍第三点运行时类加密解密技术。

1.编译时加密一般原理

    下面为java 对称加密基本实现代码。对于一个编译好的 class 文件，调用加密算法，将class 文件转为密文即可。‍‍

    /**     * AES 加密     *     * @param content 待加密内容     * @param aesKey  密码     * @return     */    public static byte[] encrypt(byte[] content, String aesKey) {        if (aesKey == null || aesKey.length() != 16) {            return null;        }        try {            byte[] bytes = aesKey.getBytes("UTF-8");            SecretKeySpec skeySpec = new SecretKeySpec(bytes, "AES");            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");            cipher.init(Cipher.ENCRYPT_MODE, skeySpec);            return cipher.doFinal(content);        } catch (Exception e) {            throw new RuntimeException(e);        }    }

        jrasp安全插件以 jar 包形式输出，以 file-hook 模块为例子，将 jar 解压后，com.jrasp.agent.module 包下的类需要加密，目标加密文件是FileHook.class （jar包依赖的三方包，如工具类，可以不加密）。‍‍‍‍‍‍‍‍

2.编译加密maven plugin 插件

    为了更友好的将加密逻辑嵌入打包编译流程中，避免繁琐的jar包解压、加密class文件、压缩jar包等流程。jrasp 官方将加密逻辑写入到了maven plugin 插件中，插件代码在jrasp-agent 项目下的 jrasp-encrypt 工程中。并且无需其他配置，仅需要在 bin/DECRYPT_KEY.txt 中配置 加密/解密 密钥即可，简化操作。‍‍

    jrasp-module 工程引入加密插件，并且配置插件参数配置：密钥文件路径和需要加密包(多个包，逗号分隔)

3.运行时解密

    jrasp 采用自定义类加载器加载jar包，在类加载器的loadClass环节（类加载器的该方法作用可以参考其他博文）（class 文件流转换为 class 对象过程），将加密后二进制文件解密为jvm可以识别的class文件。‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

class 解密的技术实现细节：‍

4.加密算法与密钥保存分发

    1.加密算法的选择：‍‍

        由于 jrasp 要兼容不同的jdk版本，不同jdk版本加密算法差异较大，兼容性存在很大问题，考虑兼容性，这里 jrasp 采用了对称加密。（如果业务指为特定jdk如openjdk，可以采用该jdk支持的非对称加密）。

    2.密钥的保存：

    为了保障加密的安全性，密钥理论上是不允许明文配置在conf文件中（配置文件密钥容易泄漏）。密钥jrasp-daemon 编译时固化到可执行文件中。并且密钥与jrasp-daemon 可执行文件的md5一一对应，保证无法篡改。

    3.密钥的分发给：

   jrasp-daemon 通过attach 机制动态传递给 java agent。‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

5.总结‍‍

   jrasp 目前是业内唯一采用运行时加密算法保障安全策略的rasp。安全策略jar包磁盘加密，运行时解密，密钥不落盘。大大提高了rasp自身的安全性。‍‍‍‍‍‍

“ 🔥🔥🔥国内技术领先的开源RASP社区” jrasp 从1.0.4 (2019年) 迭代至今，历经多

“ 🔥🔥🔥国内技术领先的开源RASP社区”

    jrasp 从1.0.4 (2019年) 迭代至今，历经多个版本，1.1.0在原有基础上功能、性能和安全性等方面得到较大提升。

01
—
功能特性‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍


特性说明：

三方依赖更少(仅ASM)、体积更小(核心包仅600KB)功能更加全面；
新增http检测模块、ssrf模块、jndi模块等；
提供 windows 系统安装包；
提供 attach 工具，方便手动测试jrasp-agent功能

版本迭代：https://www.jrasp.com/guide/technology/changelog.html


02
—
安装使用

安装须知：
jrasp 在腾讯云/阿里云上部署了jrasp的基础设施，仅需要安装jrasp-agent，即可接入到jrasp云端管控平台，快速体验jrasp功能!!
仅需2行命令即可以完成安装！！
仅限centos操作系统
使用 root 权限安装

第一步 安装 agent
curl https://jrasp-download.oss-cn-shanghai.aliyuncs.com/jrasp-install.sh|bash
安装成功后如下：

    注意：安装目录在/usr/local/jrasp 下,如果已经安装过1.0.8及以下版本，请先将`jrasp`目录删除再安装。

第二步 安装 filebeat 

(此步骤非必需，如果是内网环境/无法访问公网，可以跳过)
curl https://jrasp-download.oss-cn-shanghai.aliyuncs.com/filebeat-install.sh|bash
‍filebeat 的作用是收集 jrasp-agent的日志。
安装成功之后：


第三步 登陆管理端 

(此步骤非必需，如果是内网环境/无法访问公网，可以跳过)
云端管控平台地址：http://132.232.32.246
用户名称：user2022 密码：123456
在实例管理中查看是agent否成功注册
‍
‍

03
—
单机版本
    如果是内网环境/无法访问公网，无法链接到管理端，可以使用jrasp官方提供的工具`attach`，手动执行注入、参数/模块更新、hook类查看和卸载等功能。
  在完成 jrasp-agent安装之后，安装目录下提供了attach工具。‍‍‍‍‍‍‍功能使用参考文档：https://www.jrasp.com/guide/install/single.html

阅读原文

任意代码执行漏洞中，攻击者通过开启一个新的线程来执行命令时，rasp丢失请求的上下文、执行堆栈等重要参数，导致检测算法（堆栈算法、ip黑名单、请求参数特征等无法关联）失效，极大的影响RASP的防御功能与溯源能力。

    任意代码执行漏洞中，攻击者通过开启一个新的线程来执行命令时，rasp丢失请求的上下文、执行堆栈等重要参数，导致检测算法（堆栈算法、请求参数特征等无法关联）失效，极大的影响RASP的防御功能与溯源能力。
01 案例
    如下案例：http 请求线程执行到下面的代码时，新建一个新的线程来执行任意，命令，http特征参数丢失。

<%@ page language="java" contentType="text/html; charset=UTF-8"    pageEncoding="UTF-8"%>    <%@ page import="java.io.IOException" %>DOCTYPE html><html><head><meta charset="UTF-8"><title>Insert title heretitle>head><body><%    // 创建线程执行命令，而不是直接执行命令    Thread t = new Thread(new Runnable() {            @Override                     public void run() {                           try {                Runtime.getRuntime().exec(new String[]{"touch","/tmp/test"});                           } catch (IOException e) {                 e.printStackTrace();              }            }    });    t.start();    out.println(">==test==<");%>body>html>

    RASP最终截获的参数会丢失http，无法溯源。（实现原理上的缺陷）


02 参数丢失原因与优化措施

    rasp 中使用 ThreadLocal 在线程的不同hook点处传递http等参数，由于无法跨线程，参数必然丢失。
    有更好的线程关联类，来解决上面新建线程参数丢失问题：java.lang.InheritableThreadLocal类。

Inheritable thread-local variables are used in preference to ordinary thread-local variables when the per-thread-attribute being maintained in the variable (e.g., User ID, Transaction ID) must be automatically transmitted to any child threads that are created.

    实现原理：在父线程创建子线程时，向子线程传递变量。可以参考:[InheritableThreadLocal](https://www.jianshu.com/p/94ba4a918ff5)。
03 JRASP实现

使用InheritableThreadLocal创建线程变量

// 线程上下文                                                                                              // 上下文增强：使用 InheritableThreadLocal 代替 ThreadLocal 防止线程注入                                              public static InheritableThreadLocal<Context> requestContext = new InheritableThreadLocal<Context>() {    @Override                                                                                             protected Context initialValue() {                                                                        return new Context();                                                                             }                                                                                                 };  // 模块中使用线程上下文 @RaspResource private ThreadLocal<Context> context;

线程变量的清除

    由于jrasp的基本特征是热卸载（加载），如果不能清除线程变量，将会导致已经加载的 jrasp-agent/module 无法正常卸载，造成比较严重的内存泄漏。
    因此，jrasp-agent 在卸载时, 执行强制清除线程变量操作，彻底解决内存泄漏问题；
 // 除去 context 线程变量                                                                                                                             List<Thread> threadList = ThreadUtil.getThreadList();                                                                                          for (Thread thread : threadList) {                                                                                                                 /**                                                                                                                                             * 在 rasp 退出时清理线程变量，这里使用 inheritableThreadLocals 应该清除 inheritableThreadLocals                                                                   * @see Thread.inheritableThreadLocals                                                                                                          * @see Thread.threadLocals                                                                                                                     */                                                                                                                                            Object threadLocalMap = RaspReflectUtils.unCaughtGetClassDeclaredJavaFieldValue(Thread.class, "inheritableThreadLocals", thread);           if (null != threadLocalMap) {                                                                                                                      //  反射获取 ThreadLocalMap类的 remove 方法                                                                                                            Method method = RaspReflectUtils.unCaughtGetClassDeclaredJavaMethod(threadLocalMap.getClass(), "remove", ThreadLocal.class);                try {                                                                                                                                              RaspReflectUtils.unCaughtInvokeMethod(method, threadLocalMap, requestContext);                                                          } catch (Exception e) {                                                                                                                            e.printStackTrace();                                                                                                                       }                                                                                                                                          }                                                                                                                                          }                                                                                                                                             

04 优化后演示
    在springboot项目中创建一个controller：
    @GetMapping("/get/cmd.do")    public void getProcessBuilder(String cmd) throws Exception {        Thread thread = new Thread(new Runnable() {            @Override            public void run() {                try {                    // 执行命令                    execCMD(cmd);                } catch (Exception e) {                    e.printStackTrace();                }            }        });        thread.start();        return;    }
 发起请求，检测结果，http 参数未丢失。

 卸载jrasp后，触发full gc，可以看到jvm的类卸载事件，完全卸载。
// 卸载jrasp./attach -p <pid> -s


》》》1.1.0 新版本功能预览，欢迎申请试用

### 1.1.0【2022-10】（当前开发版本）#### Enhancement+ [attach] 新增jrasp-attach工程(Golang)，支持手动注入、查看hook类、更新模块参数和卸载RASP+ [agent] agent依赖的bridge打包时指定，防止加载错误依赖+ [agent] 去掉logback/sl4j，使用原生jul ，减少不安全的依赖+ [agent] 去掉内置jetty，使用原生socket+ [agent] 使用InheritableThreadLocal代替ThreadLocal防止线程注入+ [agent] 去掉java-agent的json日志格式，并修改filebeat的日志分割grok表达式+ [module] 上下文对象优化为context对象+ [module] module统一参数更新接口+ [project] 将jrasp-agent、jrasp-module、jrasp-attach和jrasp-daemon等工程合并，统一编译打包+ [project] 全面兼容 windows、linux、mac#### BugFix+ [agent] jar包文件名称增加版本号，解决jar包文件句柄清除问题+ [module] 替换 @Resource 注解，解决与javax包类的冲突+ [agent] 解决jvm-sandbox抛出异常时的内存泄漏 bug （jvm-sandbox 已经合入补丁）+ [jetty module] 解决 http input.read方法重复hook问题 （在openrasp上已经复现该问题）+ [xxe module] 解决dom4j方法重复hook问题 （在openrasp官方已经确认该问题）
#### TODO+ [agent] 优化类匹配机制，全局唯一transform实例，减少stw时间
### 1.0.8 【2022-08】（内部测试版本）#### Enhancement+ [module] 增加多个安全模块+ [daemon] 进程扫描优化+ [daemon] 防止启动多个守护进程
### 1.0.7 【2022-07】（用户使用的稳定版本）#### Enhancement+ [daemon] 上报配置更新时间+ [daemon] daemon启动上报nacos初始化的状态和注册的服务ip+ [daemon] 发现无法连接nacos时，自动重启，24小时检测一次
#### BugFix+ [daemon] 修复软刷新panic+ [daemon] 删除获取依赖的功能，由安全插件自行上报
### 1.0.6 【2022-06】#### BugFix+ [daemon] 使用 os.RemoveAll 删除Java进程文件夹
### 1.0.5 【2022-05】+ [daemon]插件以配置文件为准，配置文件中没有的，删除磁盘上的+ [daemon]注入后增加软刷新功能和参数更新功能
### 1.0.4 【2022-04】 （开源版本）+ [agent] 增加native方法hook+ [daemon] 支持对多个Java进程注入，每个Java进程独立的数据目录

​

当应用是通过用户上传的XML文件或POST请求进行数据的传输，并且应用没有禁止XML引用外部实体，也没有过滤用户提交的XML数据，那么就会产生XML外部实体注入漏洞。

简介

当应用是通过用户上传的XML文件或POST请求进行数据的传输，并且应用没有禁止XML引用外部实体，也没有过滤用户提交的XML数据，那么就会产生XML外部实体注入漏洞。

XXE 漏洞在owasp2021中位置：

A05:2021 – Security Misconfiguration CWE-611 Improper Restriction of XML External Entity Reference（XXE）

防护

使用语言中推荐的禁用外部实体的方法

这里以 Java 语言为例子说明。

使用XML库的Java应用程序特别容易受到XXE攻击，因为大多数Java XML解析器的默认设置是启用XXE。为了安全地使用这些解析器，必须在使用的解析器中显式禁用XXE。下面描述如何在最常用的Java XML解析器中禁用XXE。

01.DocumentBuilderFactory

javax.xml.parsers.DocumentBuilderFactory

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();String FEATURE = null;FEATURE = "http://apache.org/xml/features/disallow-doctype-decl";dbf.setFeature(FEATURE, true);
FEATURE = "http://xml.org/sax/features/external-general-entities";dbf.setFeature(FEATURE, false);
FEATURE = "http://xml.org/sax/features/external-parameter-entities";dbf.setFeature(FEATURE, false);
FEATURE = "http://apache.org/xml/features/nonvalidating/load-external-dtd";dbf.setFeature(FEATURE, false);
dbf.setXIncludeAware(false);dbf.setExpandEntityReferences(false);

02.Dom4j

org.dom4j.io.SAXReader

saxReader.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);saxReader.setFeature("http://xml.org/sax/features/external-general-entities", false);saxReader.setFeature("http://xml.org/sax/features/external-parameter-entities", false);

03.Jdom

org.jdom2.input.SAXBuilder、 org.jdom.input.SAXBuilder

SAXBuilder builder = new SAXBuilder();builder.setFeature("http://apache.org/xml/features/disallow-doctype-decl",true);builder.setFeature("http://xml.org/sax/features/external-general-entities", false);builder.setFeature("http://xml.org/sax/features/external-parameter-entities", false);builder.setExpandEntities(false);Document doc = builder.build(new File(fileName));

04.XMLInputFactory

javax.xml.stream.XMLInputFactory

// This disables DTDs entirely for that factoryxmlInputFactory.setProperty(XMLInputFactory.SUPPORT_DTD, false);// This causes XMLStreamException to be thrown if external DTDs are accessed.xmlInputFactory.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, "");// disable external entitiesxmlInputFactory.setProperty("javax.xml.stream.isSupportingExternalEntities", false);

05.XMLReader

org.xml.sax.XMLReader

XMLReader reader = XMLReaderFactory.createXMLReader();reader.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);// This may not be strictly required as DTDs shouldn't be allowed at all, per previous line.reader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);reader.setFeature("http://xml.org/sax/features/external-general-entities", false);reader.setFeature("http://xml.org/sax/features/external-parameter-entities", false);

RASP防护

上面的修复方式在具体实施时存在缺陷：

• 如果读取xml的代码在第三方包中（或者依赖框架），一般很难直接修改，必须pr框架/包提供者来修复；

  
  

这里以dom4j为例子来说RASP如何修复XX漏洞

package com.example.controller;
import org.dom4j.Document;import org.dom4j.Element;import org.dom4j.io.SAXReader;import org.springframework.http.ResponseEntity;import org.springframework.web.bind.annotation.PostMapping;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;
import java.io.ByteArrayInputStream;
@RestController@RequestMapping("/xxe/dom4j")public class Dom4jController {        @PostMapping("/post/dom4j.do")    public ResponseEntity<String> documentBuilder1(String xml, int fix) throws Exception {        return ResponseEntity.ok(dom4j(xml, fix));    }
    public static String dom4j(String xml, int fix) throws Exception {        SAXReader saxReader = new SAXReader();        // 启用修复方式        if (fix == 1) {            saxReader.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);            saxReader.setFeature("http://xml.org/sax/features/external-general-entities", false);            saxReader.setFeature("http://xml.org/sax/features/external-parameter-entities", false);            saxReader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);        }        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(xml.getBytes());        Document document = saxReader.read(byteArrayInputStream);        Element element = document.getRootElement();        return element.getText();    }}

dom4j版本

 <dependency>    <groupId>org.dom4j</groupId>    <artifactId>dom4j</artifactId>    <version>2.0.0</version></dependency>

POC

curl --location --request POST 'http://localhost:8080/xxe/dom4j/post/dom4j.do' \--header 'Content-Type: application/x-www-form-urlencoded' \--data-urlencode 'xml=<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE root [<!ENTITY xxe SYSTEM "file:///etc/passwd">]><root>&xxe;</root>' \--data-urlencode 'fix=0'

读取 /etc/passwd文本内容

返回结果：

### User Database# # Note that this file is consulted directly only when the system is running# in single-user mode.  At other times this information is provided by# Open Directory.## See the opendirectoryd(8) man page for additional information about# Open Directory.##nobody:*:-2:-2:Unprivileged User:/var/empty:/usr/bin/falseroot:*:0:0:System Administrator:/var/root:/bin/shdaemon:*:1:1:System Services:/var/root:/usr/bin/false...

模块插件举例

    /**     * read重载方法最终调用 read(InputSource)     *     * @see org.dom4j.io.SAXReader#read(InputSource)     */    public void closeDom4jXXE() {        final String className = "org.dom4j.io.SAXReader";        final String methdName = "read";        new EventWatchBuilder(moduleEventWatcher)                .onClass(className)                .includeBootstrap()                .onBehavior(methdName)                .withParameterTypes("org.xml.sax.InputSource")                .onWatch(new AdviceListener() {                    @Override                    public void before(Advice advice) throws Throwable {                        if (!enableCheck) {                            return;                        }                        SAXReader saxReader = (SAXReader) advice.getTarget();                        saxReader.setFeature(FEATURE_DEFAULTS_1, true);                        saxReader.setFeature(FEATURE_DEFAULTS_2, false);                        saxReader.setFeature(FEATURE_DEFAULTS_3, false);                    }
                    @Override                    protected void afterThrowing(Advice advice) throws Throwable {                        requestInfoThreadLocal.remove();                    }                });    }

    需要注意的是，JRASP 对Dom4j的hook类做了进一步的优化，hook了更加底层的方法（如下所示）。

public Document read(InputSource in) throws DocumentException

（经过debug和实际dump字节码发现，open-rasp 存在重复插桩、防护逻辑执行两次的问题。相关issue：https://github.com/baidu/openrasp/issues/396）

选取hook类一般是十分慎重，必须了解hook类的功能，选取类的一般性原则如下：

• 能防护漏洞；

• 选取更底层方法，避免被被绕过；

• 在保证功能的基础上hook类尽量少；

  
  

目前JRASP已经具备上面5类常用XML解析器的漏洞防护插件。

----------------------------------------------------------------------------

XXE漏洞案例：

https://www.jrasp.com/case/CVE-2018-15531.html

https://www.jrasp.com/case/CVE-2018-1259.html

​​

阅读原文

Apache Spark UI提供了通过配置选项Spark.acl.enable启用acl的可能性。使用身份验证过滤器，这将检查用户是否具有查看或修改应用程序的访问权限。

    Apache发布安全公告，修复了一个Apache Spark中存在的命令注入漏洞。漏洞编号：CVE-2022-33891，漏洞威胁等级：高危。    Apache Spark UI提供了通过配置选项Spark.acl.enable启用acl的可能性。使用身份验证过滤器，这将检查用户是否具有查看或修改应用程序的访问权限。
    如果启用了acl，HttpSecurityFilter中的代码路径可以允许某人通过提供任意用户名来执行模拟。恶意用户可能能够访问权限检查功能，该功能最终将根据他们的输入构建一个UnixShell命令并执行它。这将导致任意 shell 命令执行。

    影响版本如下：

• Spark Core - Apache <=3.0.3

• 3.1.1 <= Spark Core - Apache <=3.1.2

• 3.2.0 <= Spark Core - Apache <=3.2.1
  

环境搭建

下载 Apache Spark 3.2.1

https://repo.huaweicloud.com/apache/spark/spark-3.2.1/spark-3.2.1-bin-hadoop2.7.tgz

    漏洞触发的关键在于是否启用ACL，使用身份验证过滤器。启用ACL的方式：1、通过设置选项 spark.acls.enable 启用 。2、运行spark-shell时，通过-c（--conf）参数启动。

./spark-shell --conf spark.acls.enable=true

漏洞复现

管理端：

补充说明

     spark-ui内置jetty处理http请求，并且使用 shade 打包方式修改了 jetty 包的前缀。rasp一般hook的jetty类全限定名称：

org.eclipse.jetty.server.Server

而 spark-ui中该类的名称

org.sparkproject.jetty.server.Server

     对于这种场景，RASP必然丢失http参数。为了解决上面的问题，传统RASP需要修改代码，即：增加hook类、打包编译agent、重新发布、推动业务进程重启的流程（需要重启升级）；而 jrasp 仅需要新增 hook 模块，无需重启业务，下发立即生效。

    spark-jetty-hook 模块部分代码：

    /**     * 1.重置绑定在线程上的线程本地变量，防止线程脏数据；     * 2.绑定本次请求信息；     * 3.如果请求逻辑没有走到这里，将出现脏数据     */    public void jettyRequestPreHook() {        new EventWatchBuilder(moduleEventWatcher)                .onClass("org.sparkproject.jetty.server.Server")                .includeBootstrap()                .onBehavior("handle")                .withParameterTypes("org.sparkproject.jetty.server.HttpChannel")                .onWatch(new AdviceListener() {                    @Override                    public void before(Advice advice) throws Throwable {                        if (!enableCheck) {                            return;                        }                        // 清除上次请求的 requestInfo 信息,防止脏数据                        requestInfoThreadLocal.remove();                        // 绑定本次请求的请求头                        Object httpChannel = advice.getParameterArray()[0];                        if (httpChannel == null) {                            return;                        }                        if (getRequest == null) {                            getRequest = httpChannel.getClass().getMethod("getRequest");                        }                        Object httpRequest = ReflectUtils.invokeMethod(getRequest, httpChannel);                        HashMap<String, Object> context = requestInfoThreadLocal.get();
                        // 俘虏HttpServletRequest参数为傀儡                        final IHttpServletRequest httpServletRequest = puppet(IHttpServletRequest.class, httpRequest);
                        storeRequestInfo(context, httpServletRequest);                    }
                    @Override                    public void afterThrowing(Advice advice) throws Throwable {                        // 代码执行异常情况清除 context 信息，防止内存泄漏                        requestInfoThreadLocal.remove();                    }                });    }

-----------------------------------------------------------------------

🔥🔥🔥国内技术领先的开源RASP社区  https://www.jrasp.com

阅读原文

最近表达式注入的漏洞较多，jrasp 目前已经支持spel/ognl 表达式的检测。

    一方面数据映射框架如mybatis、hiberate等在框架底层已经实现了对sql注入的防御，另一方面白盒/黑盒等扫描器也能解决一部分sql注入问题，sql注入的出现风险被大大降低。但是在研发人员未能恰当的使用框架或者sql语句拼接不当的的情况下，仍然可能导致sql注入的风险。本文分析sql注入的几种情况以及RASP在其中的作用。

1.JDBC 拼接不当造成的SQL注入

    JDBC有两种方法执行SQL语句，分别为PrepareStatement和Statement。两个方法的区别在于PrepareStatement会对SQL语句进行预编译，而Statement方法在每次执行时都需要编译，会增大系统开销。理论上PrepareStatement的效率和安全性会比Statement要好，但并不意味着使用PrepareStatement就绝对安全，不会产生SQL注入。

      PrepareStatement方法支持使用‘?’对变量位进行占位，在预编译阶段填入相应的值构造出完整的SQL语句，此时可以避免SQL注入的产生。但开发者有时为了便利，会直接采取拼接的方式构造SQL语句，此时进行预编译则无法阻止SQL注入的产生。如以下代码所示，PrepareStatement虽然进行了预编译，但在以拼接方式构造SQL语句的情况下仍然会产生SQL注入。代码示例如下（若使用“or 1=1”，仍可判断出这段代码存在SQL注入）

String sql = "select * from user where id =" + req.getParameter("id");out.println(sql);try{    PreparedStatement pstt = con.prepareStatement(sql);    ResultSet re = pstt.executeQuery();    while(rs.next()){        out.println("<br>id:"+rs.getObject("id"));        out.println("<br>name:"+re.getObject("name"));    }    catch(SQLException e){        e.printStackTrace();    }}

     正确地使用PrepareStatement可以有效避免SQL注入的产生，使用“?”作为占位符时，填入对应字段的值会进行严格的类型检查。将前面的“拼接构造SQL语句”改为如下“使用占位符构造SQL语句”的代码片段，即可有效避免SQL注入的产生。

PrintWriter out = resp.getWriter();String sql = "select * from user where id = ?"out.println(sql);try{    PreparedStatement pstt = con.prepareStatement(sql);    pstt.setInt(1,Integer.parseInt(req.getParameter("id")));    ResultSet rs = pstt.executeQuery();    // sql执行结果的代码省去....}

2.框架使用不当造成SQL注入

    如今的Java项目或多或少会使用对JDBC进行更抽象封装的持久化框架，如MyBatis和Hibernate。通常，框架底层已经实现了对SQL注入的防御，但在研发人员未能恰当使用框架的情况下，仍然可能存在SQL注入的风险。

Mybatis框架

    MyBatis框架的思想是将SQL语句编入配置文件中，避免SQL语句在Java程序中大量出现，方便后续对SQL语句的修改与配置。MyBatis中使用parameterType向SQL语句传参，在SQL引用传参可以使用#{Parameter}和${Parameter}两种方式

使用#{Parameter}构造SQL的代码如下所示

<select id="getUsername" resultType="com.example.bean.User">    select id,name,age from user where name #{name}<select>

    从Debug回显的SQL语句执行过程可以看出，使用#{Parameter}方式会使用“?”占位进行预编译，因此不存在SQL注入的问题。用户可以尝试构造“name”值为“z1ng or 1=1”进行验证。回显如下，由于程序未查询到结果出现了空指针异常，因此此时不存在SQL注入。

使用${Parameter}构造SQL的代码如下所示：

<select id = "getUsername" resultType = "com.example.bean.User">    select id,name,age from user where name = ${name}<select>

name”值被拼接进SQL语句之中，因此此时存在SQL注入。${Parameter}采用拼接的方式构造SQL，在对用户输入过滤不严格的前提下，此处很可能存在SQL注入。

Hibernate

    Hibernate是一种ORM框架，全称为 Object_Relative DateBase-Mapping，Hibernate框架是Java持久化API（JPA）规范的一种实现方式。Hibernate 将Java 类映射到数据库表中，从 Java 数据类型映射到 SQL 数据类型。Hibernate是目前主流的Java数据库持久化框架，采用Hibernate查询语言（HQL）注入

    HQL的语法与SQL类似，受语法的影响，HQL注入在实际漏洞利用上具有一定的限制。

3.jrasp mysql检测模块

      不同sql client版本，hook类差别大，这里以mysql8.x 为例子说明。

1）可配置参数：

2）sql拼接hook

com.mysql.cj.jdbc.StatementImpl

3）sql 预编译hook

com.mysql.cj.jdbc.ClientPreparedStatement,com.mysql.cj.jdbc.PreparedStatement

4）检测算法

4.sql注入实战

存在sql拼接的业务代码如下

正常sql（返回用户自己的数据）

sql注入（返回了全部用户数据）

5.检测与防御

    值得注意的是不同于复杂的正则规则检测， jrasp内置了 sql 注入词法分析防火墙，单条sql检测时间在0.1ms内完成，误报/漏报率极低。

---------------------------------------------------------------------------

🔥🔥🔥国内技术领先的开源RASP社区 https://www.jrasp.com

阅读原文

最近表达式注入的漏洞较多，jrasp 目前已经支持spel/ognl 表达式的检测。

    最近表达式注入的漏洞较多，jrasp 目前已经支持spel/ognl 表达式的检测。

1.漏洞复现

参考官网：https://www.jrasp.com/case/CVE-2020-13942.html

这里使用OGNL POC：

2.攻击详情

3.OGNL检测模块

这里以ognl 模块为例子说明，管理端配置参数如下：

hook点选择

第一种检测算法：黑名单检测算法

    默认黑名单（黑名单可以管理端配置）

第二种检测算法：表达式最大长度校验

    ognl最大允许长度在管理端可以配置

4.SPEL检测模块

    仅介绍hook点，检测算法也是黑名单与长度限制，与ognl 差别不大，不做详细介绍。

---------------------------------------------------------------------------

🔥🔥🔥国内技术领先的开源RASP社区 https://www.jrasp.com

阅读原文

介绍Java RASP是基于Java Agent技术实现的，而Java Agent代码无法独立启动，必须依赖

介绍

Java RASP是基于Java Agent技术实现的，而Java Agent代码无法独立启动，必须依赖于一个Java运行时程序才能运行。 如何调试一个Java Agent可以参考之前的一篇推文：如何 debug JRASP Agent代码

在RASP开发的中后期，则需要在真实的Web服务器上测试。通常这些Java应用程序都运行在远端设备上，开发者本地不具备这样的环境。所以我们需要远程调试一个真实的Java应用，来解决bug或者验证RASP的防护效果。下面将以tomcat为例，介绍如何调试一个应用于远端Java应用的RASP程序。

环境条件

1. 运行于Windows上的IDEA CE 2021.2(社区版)

2. 运行于Linux上的apache-tomcat-9.0.0.m1

调试步骤

1. 设置IDEA远程调试

1. 点击编辑运行配置

2. 新建一个远程JVM调试模板

3. 调试器模式设置为附加到远程JVM，传输方式选择Socket。IDEA还有ShareMemory方式的传输方式，这两者的本质都是用于传输远程调试信息。双机调试建议使用Socket模式。

4. 设置目标Java应用所在机器的IP地址，以及一个未被使用的端口。

5. 选择目标Java应用运行时JDK版本，将会自动生成一些启动参数。不同的JDK版本的启动参数不同，所以需要注意这点。

6. 复制自动生成的JVM启动参数，用于后续添加到目标Java应用的启动参数中。

7. 设置需要调试的代码 

   
   

2. 下断点

1. 在刚刚设置的需要调试的代码中下断点。

2. 断点的位置尽量高，而且最好是在逻辑简单且必经之地。因为RASP代码逻辑是由目标Java应用触发，而不是我们手动触发的。另外建议多下几个断点，以保障IDEA可以正确捕获断点。 

   
   

3. 

3. 在目标应用中添加调试的启动参数

1. 将IDEA自动生成的远程JVM启动参数添加到目标应用的启动参数中.

2. 以tomcat为例：

• Linux:

  export JAVA_OPTS='-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005'

• windows

  set JAVA_OPTS=-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005

• e.g

• 

• Linux：${tomcat安装目录}/bin/catalina.sh

• Windows：${tomcat安装目录}/bin/catalina.bat

• e.g: /usr/web/apache-tomcat-9.0.0.M1/bin/catalina.sh

1. tomcat启动脚本目录：${tomcat安装目录}/bin

2. 修改tomcat启动脚本，添加启动参数。将刚刚复制的JVM启动参数以如下的方式添加至catalina.sh的最前面:

3. 保存修改后的脚本

4. 启动目标Java应用

1. 重启修改脚本后的Java应用

2. 以tomcat为例：

   
   

3. 

4. 
   

5. 启动IDEA远程调试

1. 选择刚刚新建的远程JVM调试配置并启动 

   
   

   

2. 如果显示连接成功，则表示双机调试通道已经建立。

3. 如果显示连接失败或者连接超时，则需要排查原因：

1检查双机是否可以ping通。

    2.检查远端机器上的目标Java应用是否正确地监听在调试端口号上。可以使用如下命令：

- `lsof -i:端口号`
- e.g



    3.通常远端服务器都设置了防火墙或者安全组，此时需要放开该调试端口号。

6. 对目标应用启动RASP注入

1. 查看所有Java应用程序pid:

    2.进入到jrasp安装目录

cd /usr/local/jrasp/bin

  3.手动注入jrasp

./jrasp.sh -p pid

7. 触发断点

1. 断点触发与否主要是基于所要测试的代码和断点位置。一般来说，如果断点设置在AgentMain入口处，则jrasp注入的时候，IDEA即可捕获断点。

2. 如果需要调试的代码和AgentMain函数不在一个模块中，则需要针对性的触发。双机调试建立之后，可能IDEA并未捕获断点，这是因为目前调试的RASP模块还未被执行。

3. 此时需要针对性的触发断点。举两个例子：

1. 如果测试的是RASP监控tomcat request请求模块的代码，那么直接浏览器访问tomcat服务器即可触发断点。

2. 如果测试的是RASP对于RCE检测与阻断能力模块的代码，那么需要使用rce相关的exp攻击tomcat服务器；或者在tomcat服务器内部内置jsp脚本模拟RCE，然后通过浏览器网络请求调用该jsp脚本。

总结

    RASP是依赖目标Java进程的，所以RASP的远程调试也是基于Java应用的远程调试。比如说调试Tomcat上的RASP，要先在Tomcat的JVM启动参数中添加远程调试的设置，RASP注入后，RASP的代码将作为Tomcat的一部分被JVM运行，可远程调试Tomcat即可远程调试RASP。补充一点，调试时无需Tomcat源码，在RASP的代码中设置断点，IDEA将自动捕获。但是，RASP大多时候需要hook Tomcat的API，如果无法精准地知道API及其函数描述，可以利用maven中添加对应的tomcat版本的依赖包，上述的远程调试技巧也可以定位到相关的tomcat源码中，这样子在调试堆栈中，既可以看RASP的代码，也可以看JDK源码和tomcat源码，调试过程更加清晰。

阅读原文

跳转微信打开

Spring Data MongoDB 是一个开源项目，它提供了与 MongoDB 文档数据库的集成。近日监控到 Spring Data MongoDB 爆出 SpEL 表达式注入漏洞 CVE-2022-22980

    Spring Data MongoDB 是一个开源项目，它提供了与 MongoDB 文档数据库的集成，可以极大提高 Java 开发人员在使用 MongoDB 时的效率。近日监控到 Spring Data MongoDB 爆出 SpEL 表达式注入漏洞 CVE-2022-22980。

    当使用 `@Query` 或 `@Aggregation` 注释进行查询并且通过 SpEL 表达式中形如 `?0` 、`?1` 等占位符进行参数赋值时，可导致 SpEL 表达式注入漏洞，从而实现 RCE 。影响版本如下：

•  v3.4.0

•  v3.3.0 to v3.3.4

•  Older, unsupported versions are also affected

环境搭建

    为了方便漏洞调试分析，新建一个 SpringBoot 项目，并引入 Spring Data MongoDB v3.4.0 。参考  Spring Data MongoDB 查询 SpEL 解析定义规范以及补丁对比分析结果，完成调试环境配置。最后为了方便构造漏洞测试过程，编写如下控制器：

(https://github.com/threedr3am/learnjavabug/tree/master/spring/spring-data-mongodb-spel-CVE-2022-22980)

漏洞复现

请求参数为 SpEL 表达式注入漏洞载荷，最终效果如下：

curl --location --request POST 'http://49.235.111.228:9999/demo' \--header 'Content-Type: application/x-www-form-urlencoded' \--data-urlencode 'keyword=T(java.lang.String).forName('\''java.lang.Runtime'\'').getRuntime().exec('\''/System/Applications/Calculator.app/Contents/MacOS/Calculator'\'')'

管理端：

匹配到命令执行的调用栈，判定为高危

后续功能迭代

• 增加SPEL插件模块：近期SPEL表达式注入漏洞发生多个，增加表达式检测插件，提高检测能力；

如需获取更多信息，请访问我们的页面(http://www.jrasp.com/)  开源免费，欢迎使用

• 微信：sear2022

• jrasp 目前已经接入主机超过500，防护进程超过5000+，成熟稳定；

JRASP 部署容易、接入便捷和安全插件面向开源社区等特点，得到越来越多的企业用户青睐，本文以 Un

    JRASP 部署容易、接入便捷和安全插件面向开源社区等特点，得到越来越多的企业用户青睐，本文以 Undertow安全插件的视角来介绍下如何定制属于自己的插件。

undertow简介

    Undertow 是红帽公司开发的一款基于 NIO 的高性能 Web 嵌入式服务器。

特点 :

• 轻量级：它是一个 Web 服务器，但不像传统的 Web 服务器有容器概念，它由两个核心 Jar 包组成，加载一个 Web 应用可以小于 10MB 内存

• Servlet3.1 支持：它提供了对 Servlet3.1 的支持

• WebSocket 支持：对 Web Socket 完全支持，用以满足 Web 应用巨大数量的客户端

• 嵌套性：它不需要容器，只需通过 API 即可快速搭建 Web 服务器。

  
  

  springboot 默认内嵌的web容器是tomcat，可以替换为undertow

        <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter-web</artifactId>            <exclusions>                <exclusion>                    <groupId>org.springframework.boot</groupId>                    <artifactId>spring-boot-starter-tomcat</artifactId>                </exclusion>            </exclusions>        </dependency>        <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter-undertow</artifactId>        </dependency>

http request 类

    rasp检测到敏感行为时，可以获取关联到该请求的报文详情（http、socket、rpc等），hook 这些类是实现关联的基础。对于 undertow选择下面的4个类hook。

01

http info

<1> io.undertow.servlet.handlers.ServletInitialHandler#

handleFirstRequest

HttpServerExchange exchange 对象可以获取http请求的相关信息如cookie、header等

02

获取请求参数

<2>io.undertow.server.HttpServerExchange#getQueryParameters

03

截取http body

<3> io.undertow.servlet.spec.ServletInputStreamImpl#read

04

清除线程变量

<4> io.undertow.servlet.handlers.ServletInitialHandler

#dispatchRequest

    保存请求信息使用的是threadlocal，因为线程池的重用，在使用完成之后必须清除。

打包插件

    打包好的jar包上传到对象存储服务中（或者可以提供下载的服务上，并获取下载链接）

    并且计算jar包的hash （linux 平台使用 md5sum 命令、macos 使用md5命令，都是可以的，并且计算结果是一致的）。配置hash的原因是防止插件被篡改而加载后门等，保障插件的安全性。

如果插件有配置参数，也可以加上。

新建配置与配置下发

新增配置，将其勾选上，然后下发到指定机器上（无需重启java进程即可生效）

配置下发：

测试插件是否生效

 请求关联信息上报正常

关于jrasp

• 如需获取更多信息，请访问我们的官网(http://jrasp.com)

• 使用请联系微信：sear2022

jrasp系统各个组件，均提供一键部署的脚本，免去各种复杂环境配置，降低运维安装压力。

1.系统安装

    jrasp系统各个组件，均提供一键部署的脚本，免去各种复杂环境配置，降低运维安装压力。全部安装过程大约耗时30分钟。

## jdk8安装

http://www.jrasp.com/developer/software.html 

## 安装zookeeper集群


节点1: 10.8.0.4（内网） 4c8g30g
节点2: 10.8.0.5（内网） 4c8g30g
节点3: 10.8.0.6（内网） 4c8g30g


一键安装脚本

## 下载解压mkdir -p /opt/zookeeper;mkdir -p /tmp/zookeeper; wget https://repo.huaweicloud.com/apache/zookeeper/zookeeper-3.7.0/apache-zookeeper-3.7.0-bin.tar.gz;tar -zxvf apache-zookeeper-3.7.0-bin.tar.gz -C /opt/zookeeper;       mkdir -p /opt/zookeeper;mkdir -p /tmp/zookeeper;        ## 配置zoo.cfgcat << EOF > /opt/zookeeper/apache-zookeeper-3.7.0-bin/conf/zoo.cfg;tickTime=2000initLimit=10syncLimit=5dataDir=/tmp/zookeeperclientPort=2181server.1=10.8.0.4:2888:3888server.2=10.8.0.5:2888:3888server.3=10.8.0.6:2888:3888EOF## myidcat << EOF > /tmp/zookeeper/myid;1EOF##  自动拉起与开启启动       cat << EOF > /usr/lib/systemd/system/zookeeper.service;[Unit]Description=Zookeeper server manager
[Service]Type=forkingEnvironment=JAVA_HOME=/usr/local/java/jdk1.8.0_181ExecStart=/opt/zookeeper/apache-zookeeper-3.7.0-bin/bin/zkServer.sh startExecStop=/opt/zookeeper/apache-zookeeper-3.7.0-bin/bin/zkServer.sh stopExecReload=/opt/zookeeper/apache-zookeeper-3.7.0-bin/bin/zkServer.sh restartRestart=always
[Install]WantedBy=multi-user.targetEOF
systemctl daemon-reloadsystemctl enable zookeepersystemctl start zookeepersystemctl stop zookeepersystemctl restart zookeepersystemctl status zookeeper

（复制上面的命令在终端执行即可）

• 需要注意的是：/tmp/zookeeper/myid文件的节点编号每个节点不一样，依次为

  1、2、3

• 安装结果验证：观察 /opt/zookeeper/apache-zookeeper-3.7.0-bin/logs/zookeeper--server-{机器名称}.log  是否有错误日志，没有就是安装成功。
  

## 安装kafka集群（与zk在同一机器上）

## 下载解压mkdir -p /opt/kafka;        wget https://repo.huaweicloud.com/apache/kafka/2.8.0/kafka_2.13-2.8.0.tgz;tar -zxvf kafka_2.13-2.8.0.tgz -C /opt/kafka;## 配置server.propertiescat << EOF > /opt/kafka/kafka_2.13-2.8.0/config/server.properties;broker.id=1listeners=PLAINTEXT://10.8.0.4:9092advertised.listeners=PLAINTEXT://{公网ip}:9092num.network.threads=3num.io.threads=8socket.send.buffer.bytes=102400socket.receive.buffer.bytes=102400socket.request.max.bytes=104857600log.dirs=/tmp/kafka-logsnum.partitions=1num.recovery.threads.per.data.dir=1offsets.topic.replication.factor=1transaction.state.log.replication.factor=1transaction.state.log.min.isr=1log.retention.hours=168log.segment.bytes=1073741824log.retention.check.interval.ms=300000zookeeper.connect=10.8.0.4:2181,10.8.0.5:2181,10.8.0.6:2181zookeeper.connection.timeout.ms=18000group.initial.rebalance.delay.ms=0EOF##  自动拉起与开启启动       cat << EOF > /usr/lib/systemd/system/kafka.service;[Unit]Description=kafka service
[Service]Type=simpleEnvironment=JAVA_HOME=/usr/local/java/jdk1.8.0_181ExecStart=/opt/kafka/kafka_2.13-2.8.0/bin/kafka-server-start.sh /opt/kafka/kafka_2.13-2.8.0/config/server.propertiesExecStop=/opt/kafka/kafka_2.13-2.8.0/bin/kafka-server-stop.shRestart=always
[Install]WantedBy=multi-user.targetEOF
systemctl daemon-reloadsystemctl enable kafkasystemctl stop kafka        systemctl start kafkasystemctl status kafka

执行上面的脚本前，请修改broker.id、listeners、advertised.listeners、zookeeper.connect为对应zk节点信息

• broker.id 是节点编号依次为1、2、3
  

• listeners 是该节点的内网地址

• advertised.listeners 是该节点的外网地址

• zookeeper.connect 是zk集群的节点内网地址
  

  
  

安装验证：查看各个节点的日志是否有错误信息：/opt/kafka/kafka_2.13-2.8.0/logs/server.log

创建 jrasp-daemon、jrasp-agent、jrasp-module 三个 topic

### topic 创建./kafka-topics.sh --zookeeper 10.8.0.4:2181,10.8.0.5:2181,10.8.0.6:2181 --create --topic jrasp-daemon --partitions 3 --replication-factor 3./kafka-topics.sh --zookeeper 10.8.0.4:2181,10.8.0.5:2181,10.8.0.6:2181 --create --topic jrasp-agent --partitions 3 --replication-factor 3./kafka-topics.sh --zookeeper 10.8.0.4:2181,10.8.0.5:2181,10.8.0.6:2181 --create --topic jrasp-module --partitions 3 --replication-factor 3

误操作时执行：

./kafka-topics.sh --zookeeper 10.8.0.4:2181,10.8.0.5:2181,10.8.0.6:2181 --delete  --topic jrasp-daemon

## nacos 安装

整个公司机器数量在200台左右，单个节点可以支持

wget https://jrasp-daemon-1254321150.cos.ap-shanghai.myqcloud.com/nacos-server-2.0.3.tar.gz;tar -zxvf nacos-server-2.0.3.tar.gz -C /opt/;cd /opt/nacos/bin;sh startup.sh -m standalone

## 管理端安装 （目前不开放，联系我们免费获取）## mysql 数据库安装初始化 mysql5.7### 后台安装    springboot+ security### 前端安装   antd design pro +nginx

## jrasp-agent 安装

## 安装包下载wget  https://jrasp-daemon-1254321150.cos.ap-shanghai.myqcloud.com/2022-05-05/1.0.4/jrasp-1.0.4.tar.gztar -xvf jrasp-1.0.4.tar.gz -C /usr/local/## 配置守护进程        cat << EOF > /usr/lib/systemd/system/jrasp-daemon.service[Unit]Description=jrasp-daemon service
[Service]Type=simpleWorkingDirectory=/usr/local/jrasp/binExecStart=/usr/local/jrasp/bin/startup.shExecStop=/usr/local/jrasp/bin/shutdown.shRestart=always
[Install]WantedBy=multi-user.targetEOF
## 设置开机启动与自动拉起systemctl daemon-reload;systemctl enable jrasp-daemon.service;systemctl stop jrasp-daemon.service;systemctl start jrasp-daemon.service;systemctl status jrasp-daemon.service;

## filebeat 一键安装

## 日志目录logDir=/usr/local/jrasp/logs## fileBeat 安装目录fileBeatHome=/opt/filebeatcd /opt/ && yum install wget -y && wget https://repo.huaweicloud.com/filebeat/7.9.1/filebeat-7.9.1-linux-x86_64.tar.gz;tar -zxvf filebeat-7.9.1-linux-x86_64.tar.gz -C /opt/ && mv filebeat-7.9.1-linux-x86_64 filebeat && rm -rf filebeat-7.9.1-linux-x86_64.tar.gz;cat << EOF > ${fileBeatHome}/filebeat.ymlfilebeat.inputs:- type: log  fields:        kafka_topic: "jrasp-daemon"  paths:    - ${logDir}/jrasp-daemon.log- type: log  fields:        kafka_topic: "jrasp-agent"  paths:    - ${logDir}/jrasp-agent.log- type: log  fields:        kafka_topic: "jrasp-module"  paths:    - ${logDir}/jrasp-module.logfilebeat.config.modules:  path: \${path.config}/modules.d/*.yml  reload.enabled: falsesetup.template.settings:  index.number_of_shards: 1output.kafka:  enabled: true  hosts: ["kafka_ip_1:9092","kafka_ip_2:9092","kafka_ip_3:9092"]  topic: '%{[fields.kafka_topic]}'processors:  - add_host_metadata:      when.not.contains.tags: forwarded  - add_cloud_metadata: ~  - add_docker_metadata: ~  - add_kubernetes_metadata: ~
processors:  - decode_json_fields:      fields: ['message']      target: ''      overwrite_keys: true  - drop_fields:      fields: ["host","agent","log","input","ecs","@timestamp"]
logging.level: infoEOF## systemctlcat << EOF > /usr/lib/systemd/system/filebeat.service[Unit]Description=filebeatWants=network-online.targetAfter=network-online.target[Service]User=rootExecStart=${fileBeatHome}/filebeat -c ${fileBeatHome}/filebeat.ymlRestart=always[Install]WantedBy=multi-user.targetEOFsystemctl daemon-reload && systemctl enable filebeat.service;systemctl stop filebeat.service && systemctl start filebeat.service;systemctl status filebeat.service;

2.管理端配置

安全总览

实例管理

主机详情

 (用户机器配置较高，一台上机器上安装较多服务)

策略配置

插件管理

• 用户使用的web容器是 undertow，我们临时开发了这个插件 ；
  

• 其他插件会陆续上线，增强系统安全能力，值得一提的是，新插件上线无需用户重启服务；

  
  

攻击日志

   测试环境目前安装了18台机器，稳定运行，漏洞测试拦截符合预期，用户反馈不错。

申请试用请联系：sear2022，提供技术支持。

与原生的Java反序列化的区别在于，FastJson反序列化并未使用readObject()方法，而是通过在反序列化的过程中调用setter/getter方法，将JSON字符串还原成对象，漏洞产生在自动调用的方法中。

    与原生的Java反序列化的区别在于，FastJson反序列化并未使用

ObjectInputStream.readObject()方法，而是由FastJson自定一套反序列化的过程。通过在反序列化的过程中自动调用类属性的setter/getter方法，将JSON字符串还原成对象，当这些自动调用的方法中存在可利用的潜在危险代码时，漏洞便产生了。

1. FastJson反序列化漏洞的演变历程

• 自从2017年爆出FastJson1.2.24版本反序列化漏洞后，近几年安全人员在不断寻找新的利用方式。

• 自FastJson1.2.25版本开始，FastJson关闭了默认开启的AutoType，并且内置了一个黑名单，用于防止存在风险的类进行序列化。

• 由于FastJson 1.2.41版本和1.2.42版本对类名处理不当，导致黑名单机制被绕过，在修复该漏洞的同时还将黑名单进行加密，增加了研究成本。

• 在FastJson1.2.45版本中，研究人员发现新的可利用的类，且不在黑名单中。

• 在FastJson1.2.47版本中，研究人员发现通过缓存机制，能够绕过AutoType的限制和黑名单机制。

• 在2020年，FastJson1.2.68版本又被发现新的绕过AutoType的方式，也是通过缓存的方式绕过，但具体成因的代码逻辑有些差异，利用难度也较先前版本更大。

• 在2022年5月，FastJson1.2.80版本又被发现新的绕过AutoType的方式。

    从上述FastJson反序列化漏洞可以看出漏洞利用主要集中在如下的2个方面。

• 寻找新的利用链，绕过黑名单；

• 寻找绕过AutoType的方式；

2.  FastJson反序列化漏洞的基础

FastJson将JSON还原成对象的方法有以下3种。

parse(String text);parseObject(String text);parseObject(String input, Class clazz);

    当通过这3种方法将JSON还原成对象时，FastJson自动调用类中的setter方法和无参构造函数，以及满足条件的getter方法。当类中定义的属性和方法满足下列要求时，FastJson会自动调用getter方法。

1. 只存在getter方法，无setter方法;

2. 方法名称长度大于等于4;

3. 非静态方法;

4. 方法名以get开头，且第四个字符为大写字母，例如getAge;

5. 方法无须人参;

6. 方法返回值继承自Collection、Map、AtomicBoolean、AtomicInteger和

AtomicLong的其中一个;

FastJson 1.2.24 下的PoC 如下：

import com.alibaba.fastjson.JSON;
import java.util.Properties;
public class User {    public String name;    private int age;    private Boolean sex;    private Properties properties;    public User() {        System.out.println("无参构造函数调用");    }    public int getAge() {        System.out.println("age的getter方法调用");        return age;    }    public void setAge(int age) {        System.out.println("age的setter方法调用");        this.age = age;    }    public Properties getProperties() {        System.out.println("properties的getter方法调用");        return properties;    }    public void setName(String name) {        System.out.println("name的setter方法调用");        this.name = name;    }    public String getName() {        System.out.println("name的getter方法调用");        return name;    }    public void setSex(Boolean sex) {        System.out.println("sex的setter方法调用");        this.sex = sex;    }    public Boolean getSex() {        System.out.println("sex的getter方法调用");        return sex;    }    public static void main(String[] args) {        String jsonstr = "{\"@type\":\"User\",\"sex\":true,\"name\":\"Yu\",\"age\":18,\"properties\":{}}";        Object obj = JSON.parse(jsonstr);    }}

PoC执行结果：

    parseObject(String text)方法将SON申还原成对象后，后会调用一次getter方法，类中所有的getter方法都会被执行一次，如下图所示：

3. checkAutoType 安全机制

    FastJson1.2.25版本中引人了checkAutotype，其中增加了黑白名单的校，验，缓解反序列化需洞的产生，后续版本将内置的黑白名单进行加密，增加了绕过黑白名的研究成本。

    com.alibaba.fastjson.parser.ParserConfig 加入了CheckAutoType方法,在其中有个 autotypeSupport 属性，如果为 false，那么就会检测json中@type的值 开头是否与黑名单中的值一样，若一样就直接返回一个异常，然后加载白名单中的类。

黑名单长这样：

CheckAutoType() 部分代码

若autotypesupport开启，则会先白名单加载，后黑名单检测

    后面的许多更新都是对 checkAutotype 以及本身某些逻辑缺陷导致的漏洞进行修复，以及黑名单的不断增加。

4. RASP 防御

1.2.47 版本的漏洞利用与RASP 防御

复现参考：https://mp.weixin.qq.com/s/A0X3nCq9w4BAlGPCN-jH5Q

受到漏洞影响的服务注册到管理端：

发起攻击后查看日志：

攻击详情：

调用栈：

业务层面影响：请求被阻断

    说明：1.2.80版本的绕过问题，rasp 理论上都可以检测到，由于绕过poc构造难度大，并且没有公开的资料，这里没有复现。

官网：http://www.jrasp.com

github：https://github.com/jvm-rasp/jrasp-agent

加入技术交流群请添加微信：sear2022

Java Agent 核心技术JVM之类的热替换原理

先讲讲怎么用吧

    一上来就说原理还是不怎么合适的，先给大家讲下这个技术怎么用吧。但是这篇文章重点不是讲怎么用，所以我只讲个大概流程。

第一步：写个Agent类，获取Instrumentation对象

public class MyAgent {  private static Instrumentation mInstrumentation;
  public static void agentmain(String agentArgs, Instrumentation inst) {    mInstrumentation = inst;  }
  // 拿到Instrumentation对象后就可以利用ClassModifierTransformer来进行类的热替换了  public static void modifyClass(Class clazz){    ClassFileTransformer transformer = new ClassModifierTransformer();    mInstrumentation.addTransformer(transformer, true);    mInstrumentation.retransformClasses(new Class[]{clazz});    mInstrumentation.removeTransformer(transformer);  }}

第二步：写个ClassFileTransformer，利用ASM/Javassist等工具进行字节码修改

public class ClassModifierTransformer implements ClassFileTransformer {
  @Override  public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {    // 在这里利用Javassist等工具修改类的字节码，返回修改后类的字节数组    return null;  }}

    目前已经有很多文章讲具体使用方法了，大家可以搜索下，我这里先介绍两篇：

• 基于Java Instrument的Agent实现

• 谈谈Java Intrumentation和相关应用

原理探究

热替换的核心就在于Instrumentation的两个方法：

 void addTransformer(ClassFileTransformer transformer, boolean canRetransform); void retransformClasses(Class<?>... classes) throws UnmodifiableClassException;

    addTransformer 用来注册类的修改器；retransformClasses 会让类重新加载，从而使得注册的类修改器能够重新修改类的字节码。

下面让我们重点讲讲这两个方法的实现：

1. addTransformer

      可见我们自己的实现的 ClassFileTransformer 被添加到了 TransformerManager中，让我们跟进去看看:

     ClassFileTransformer对象这次被放入了TransformerManager的一个数组中。    OK，注册完毕，很简单对不对？下面我们再来看下稍微复杂点的retransformClasses 吧。

2.retransformClasses

    这个方法的实现最终调用的是个Native方法。很多同学看到Native方法就头疼，不要急，Native方法也是人写的，不过是一段文本而已。我们来看下具体实现吧：

继续跟进 -->

retransformClasses 最后会调用到 jvmtiEnv.cpp中的 RetransformClasses

补充：Klass是一个抽象基类，它定义了一些接口（纯虚函数），由 InstanceKlass 继承并实现，两者结合可以描述一个java类的方法、字段、父类等信息。InstanceKlass 在jvm层面可以描述绝大部分java类。

上面这段代码主要干了两件事：

(1) 根据 java 层的Class对象，找到JVM层的类实例 InstanceKlass，并获取类的字节码，存放在class_definitions数组中。因为可以一次替换多个类，所以这里加了一个循环体，遍历每个要修改的类。

(2) 调用VMThread::execute(&op)

    在获取了类的字节码之后，创建了一个 VM_RedefineClasses 的 vmop，然后通知VMThread进行处理。

    在分析代码之前，先来看下比较重要的 VM_Operation。VM_Operation 是虚拟机级别的操作，这些操作包含了所有JVM的内置操作，例如GC、获取线程栈等等。这个类是所有这些操作的基类，该类定义在hotspot/src/share/vm/runtime/vmOperations.hpp 。

    首先，该类定义了 Mode 和 VMOp_Type 两个枚举。第一个表示该操作的模式，第二个表示该操作的类型。事实上所有的类型都在文件开头的宏定义中写明了，这里我们只关心 RedefineClasses 这个类型。Mode包括这四种：

 再来看下 VM_RedefineClasses

    VM_RedefineClasses是VM_Operation的子类，实现了类转换的所有逻辑。该类定义和实现分别在hotspot/src/share/vm/prims/jvmtiRedefineClasses.hpp和hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp。

    对于一个VM_Operation的子类，首先需要关心 evaluation_mode 函数。VM_RedefineClasses 类中找不到该函数，因此它是一个需要在 safepoint 阻塞的操作。

    然后就是核心操作，即 doit_prologue、doit、doit_epilogue。代码比较复杂，本节先介绍doit_prologue的实现。我们先从注释上了解每个步骤做了什么

1.doit_prologue

    在 doit_prologue 阶段，整个操作都是在Java线程中进行的，因此不会阻塞VMThread，也不会被计入safepoint的耗时。注意整个源码中 the_class 表示待替换的类，scratch_class表示新的类。

    该阶段主要做的就是准备需要的字节码，包括解析字节码、类的链接、常量池合并、字节码校验等步骤。需要说明的是，如果业务代码中准备新的字节码时间比较长（前面提到的获取新字节码的回调也是在这里发生），这个阶段时间就会变长，但是不会阻塞JVM的核心线程。

    然后，我们看下这部分是如何实现的

   VMThread::execute(&op) 中会调用到 VM_RedefineClasses::doit_prologue，核心逻辑在 VM_RedefineClasses::load_new_class_versions()

由于代码较长，分为多个部分，第一部分如下

parse_stream() 这里又调用了KlassFactory::check_class_file_load_hook

    看名字就知道是个hook方法，它会调用post_class_file_load_hook。

    利用JvmtiClassFileLoadHookPoster来通知类修改器进行类的修改。进入 poster.post() 里面

消息发给所有的 jvmtienv , 最终的调用如下：

实际的消息处理者：

  eventHandlerClassFileLoadHook在收到消息后，会调用transformClassFile 

,继续跟进--->

    这里会利用JNI调用 java 层InstrumentationImpl的transform，你看，我们又绕到Java层了。

    transform 方法的调用如下：

    看到这儿，大家还记得我们开始的时候，会将我们自定义的ClassFileTransformer对象注册到TransformerManager中吗？这里终于派上用场了，TransformerManager的transform（）方法会遍历它的注册数组，调用每个ClassFileTransformer对象的transform（）方法，并将我们修改后的类字节码返回，返回后的字节码最终又回到了上面JVM层的transformClassFile（）中，并最终交还给给class_file_load_hook 消息的发送方。

阅读原文

跳转微信打开