fix(fallback): 内容级兜底连 Range 分段一起拦,别让 DDL 被分块拼回来

影响:改名(或任意换名)的 DDL 副本之前只能用「整份响应」判据拦住;
`Range: bytes=0-1000` 这类分块请求的响应体只有 1001 字节 ⇒ 逃过整份比对 ⇒
逐段请求能把整份 DDL **拼回来**(实测 206 吐出 DDL 开头 1001 字节)⇒ 等于完整泄露。

改动:
- `src/routes/fallback.rs`:内容级兜底改为「拿响应体的哪一段去比」——
  无 `Content-Range` 时比整份(`Content-Length` 正好等于 DDL 长度才比),
  有 `Content-Range` 时比**同偏移**的 DDL 片段(`DDL[start..=end]`)⇒ 分块下载同样被拦。
- 新增 `parse_content_range`(只认 `bytes` 单位 + 闭区间,忽略 `total`)。
- `tests/spa_fallback.rs`:补 ④ 片段 Range ④⑤ 中段 Range ⇒ 404 JSON 且不含 DDL,
  ⑥ 片段 Range 打在等长不同内容的文件上 ⇒ 仍 206(证明比的是内容不是长度)。
- `src/main.rs` / `README.md`:兜底描述同步为「整份或 Range 分段」。

设计:`total` 段被忽略 ⇒ 「DDL + 一段尾巴」这类副本的前 N 字节同样被拦。

Co-Authored-By: Claude Code <[email protected]>
This commit is contained in:
adminandClaude Code committed 2026-10-25 10:45:35 +08:00
1 parent 5b0111e7a7
commit 0828bcfbc1
4 files changed
+115 -23

No files matched your search

+2 -1
View File
@@ -32,7 +32,8 @@ PORT=30000 ./target/debug/tdc-connector
- 数据全部落在 Rust 进程内嵌库;控制台(上游 SPA)通过 `/api/ssw/tdc/*` 读写。
- schema DDL 在 `schema/migrate.sql`(**编译期内嵌**,**刻意不在 web root**)⇒ 不可从 HTTP 下载;
另有**两道兜底**(`src/routes/fallback.rs`):**路径级**(任意一段路径的扩展名经 Unicode
大写折叠后等于 `SQL` ⇒ 404 JSON)+ **内容级**(响应体与内嵌 DDL 逐字节相同 ⇒ 404 JSON)。
大写折叠后等于 `SQL` ⇒ 404 JSON)+ **内容级**(响应体是内嵌 DDL 的**整份或 `Range` 分段**
⇒ 404 JSON)。
## 控制台(前端)
+4 -2
View File
@@ -148,14 +148,16 @@ async fn main() {
// 的前置中间件),**两层**:
// ① 路径级:路径中**任意一段的扩展名**(去尾部空白与尾部 `.`、
// **Unicode 大写折叠**后)等于 `SQL` ⇒ 404 + JSON(**类**规则,`.sql` 全覆盖);
// ② 内容级:响应体与**内嵌 DDL 逐字节相同** ⇒ 404 + JSON(与拼法/大小写无关)。
// ② 内容级:响应体是**内嵌 DDL**(整份**或** `Range` 分段)⇒ 404 + JSON
// (与拼法/大小写无关)。
// ⚠️ 两层都是**兜底**;根因修复是「DDL 文件不在 web root」。
.route("/migrate.sql", any(api_not_found))
// ③ 静态托管挂**根**(vite base 是 `/`,产物引用 `/assets/...`)
// 兜底服务(`routes::fallback::spa_fallback`):
// - **前置守卫** `ddl_guard` ⇒ 路径中任意一段的扩展名(Unicode 大写折叠后)
// 等于 `SQL` 时 404 + JSON(**先于** ServeDir)
// - **内容兜底** `ddl_content_guard` ⇒ 响应体与**内嵌 DDL 逐字节相同** ⇒ 404 + JSON
// - **内容兜底** `ddl_content_guard` ⇒ 响应体是**内嵌 DDL**(整份**或** `Range`
// 分段)⇒ 404 + JSON
// - 命中 `static/` 里的真实文件 ⇒ 直接出(`/assets/*.js`、`/logo.png` …)
// - `/api`、`/api/`、`/api/**` ⇒ 404 + JSON(**不是** SPA 的 HTML)
// - 其余(`/tdc/home`、`/login` 等 SPA 深链)⇒ 200 + `index.html`
+58 -20
View File
@@ -11,8 +11,9 @@
//! |---|---|
//! | `/api`、`/api/`、`/api/**` | **404 + JSON**(`api_not_found()`) |
//! | 路径中**任意一段**的**扩展名**(去尾部空白与尾部 `.`、**Unicode 大写折叠**后)等于 `SQL` | **404 + JSON**(**前置守卫** `ddl_guard`) |
//! | 命中 `static/` 里的真实文件、且响应体**不**与内嵌 DDL 逐字节相同 | 由 `ServeDir` 直接出 |
//! | 响应体与**内嵌 DDL 逐字节相同**(**不论文件名**) | **404 + JSON**(**内容级兜底** `ddl_content_guard`) |
//! | 响应体是**内嵌 DDL 的某一片段**(`Range` 分块下载) | **404 + JSON**(**内容级兜底** `ddl_content_guard`) |
//! | 命中 `static/` 里的真实文件、且响应体**不**与内嵌 DDL 逐字节相同 | 由 `ServeDir` 直接出 |
//! | 其余未命中路径(`/tdc/home`、`/login` 等 SPA 深链) | **200 + `text/html`**(`static/index.html`) |
//!
//! ⚠️ **「不命中上表」不等于「响应形状一定是 200 HTML」**:例如 `/migrate.sql%00`
@@ -33,12 +34,14 @@
//! ⇒ web root 里**任何** `.sql` 文件都不会被吐出去(**类**规则,不只 `migrate.sql` 这一个名字)。
//!
//! 🔴 **兜底 2 · 内容级(`ddl_content_guard`,跑在 `ServeDir` 之后)**:
//! 「与**内嵌 DDL 逐字节相同**的响应 ⇒ 404 + JSON」。
//! 「响应体是**内嵌 DDL**(整份**或**它的**某一片段**)⇒ 404 + JSON」。
//! 这条判据**只认内容**,与文件名怎么拼、大小写怎么折叠、路径怎么规范化**全都无关**
//! ⇒ 兜住「改了名字、但内容还是那份 DDL」的副本。
//! ⚠️ **必须连 `Range` 分段一起兜**:`Range: bytes=0-1000` 的响应体只有 1001 字节,
//! 逐段请求能把整份 DDL **拼回来** ⇒ 那等于**完整泄露**。
//!
//! ⚠️ **边界**:兜底 1 覆盖 `.sql` 这一**类**扩展名;兜底 2 只覆盖**与内嵌 DDL 逐字节相同**的内容
//! (**改过一个字节**的副本不覆盖)⇒ 真正的控制仍然是「DDL 文件不在 web root」。
//! (**改过一个字节**的副本:整份响应不拦)⇒ 真正的控制仍然是「DDL 文件不在 web root」。
//!
//! ## 为什么 `/api` 用「精确前缀」而不是裸 `starts_with`
//!
@@ -143,44 +146,79 @@ pub async fn ddl_guard(request: Request, next: Next) -> Response {
ddl_content_guard(next.run(request).await).await
}
/// 🔴 **内容级兜底**:响应体与**内嵌 DDL 逐字节相同** ⇒ 404 + JSON。
/// 🔴 **内容级兜底**:响应体是**内嵌 DDL**(或它的**某一片段**)⇒ 404 + JSON。
///
/// 🔴 这条判据**只认内容**:文件名怎么拼、大小写怎么折叠、路径怎么规范化,**全都无关**
/// ⇒ 兜住「改了名字、但内容还是那份 DDL」的副本。
///
/// 🔴 **只在「长度正好是 DDL 长度」的响应上比对**,理由是**不能吞掉响应体**:
/// - `Content-Length` 缺失 ⇒ 长度未知 ⇒ **不比对**(否则要么无界缓冲、要么把体吃掉);
/// - `Content-Length` ≠ DDL 长度 ⇒ 内容不可能是 DDL ⇒ 直接放行
/// (**含 Range 片段**:片段的 `Content-Length` 小于整份 ⇒ 不比对)。
/// 🔴 **比对哪一段**,由响应头决定(**不能吞掉响应体**,所以只在「有把握的那一段」上比对):
/// - **无 `Content-Range`** ⇒ 比**整份**:`Content-Length` **正好等于** DDL 长度才比
/// (缺失 ⇒ 长度未知 ⇒ **不比对**;不等 ⇒ 内容不可能是 DDL ⇒ 放行);
/// - **有 `Content-Range`** ⇒ 比**该偏移处的片段**:把响应体与
/// `DDL[start..=end]` 逐字节比。
///
/// 🔴 **为什么必须连分段一起兜**:`Range: bytes=0-1000` 这类**分块下载**的响应体
/// 只有 1001 字节(`Content-Length` ≠ DDL 长度)⇒ 只按「整份长度」比对会**放行**
/// ⇒ 而逐段请求可以把整份 DDL **拼回来** ⇒ 那就是**完整泄露**,不是「片段泄露」。
/// ⇒ 分段请求必须拿「同偏移的 DDL 片段」来比。
///
/// `ServeDir` 的文件响应**一定**带 `Content-Length`(`tower-http-0.6.11`
/// `src/services/fs/serve_dir/future.rs:317`;Range 分支在 `:284`),
/// ⇒ 真正的 DDL 文件**一定**落进「长度正好是 DDL 长度」这一支。
/// ⚠️ **整份 Range 请求**(`Range: bytes=0-`)的 `Content-Length` 也等于整份长度
/// ⇒ 同样会被逐字节比较并拦下(**不要**在这里按 `Content-Range` 放行:
/// 那样整份 Range 就成了绕过口)。
/// Range 响应另外带 `Content-Range`(`:290` 附近)⇒ 两条判据都拿得到。
///
/// ⚠️ **边界**:只覆盖**与内嵌 DDL 逐字节相同**的内容(**改过一个字节**的副本不覆盖),
/// **片段响应**(`Content-Length` < DDL 长度,如部分 Range)不覆盖
/// ⚠️ **边界**:只覆盖**与内嵌 DDL 逐字节相同**的内容
/// (**改过一个字节**的副本:整份响应不拦;但该副本的 Range 片段里,
/// **不含**那个改动字节的片段仍与 DDL 对应片段逐字节相同 ⇒ 仍会被拦)
/// ⇒ 根本控制仍然是「DDL 文件不在 web root」。
async fn ddl_content_guard(response: Response) -> Response {
let length = response
let content_length = response
.headers()
.get(header::CONTENT_LENGTH)
.and_then(|v| v.to_str().ok())
.and_then(|v| v.parse::<usize>().ok());
if length != Some(DDL_BYTES.len()) {
let content_range = response
.headers()
.get(header::CONTENT_RANGE)
.and_then(|v| v.to_str().ok())
.and_then(parse_content_range);
// 要拿响应体的**哪一段**去和 DDL 比(`None` ⇒ 不比对,放行)。
let slice: Option<(usize, usize)> = match content_range {
// ① 分段响应 ⇒ 比**同偏移**的 DDL 片段。
Some((start, end)) if start <= end && end < DDL_BYTES.len() => Some((start, end)),
Some(_) => None,
// ② 整份响应 ⇒ 只在长度**正好**是 DDL 长度时才比。
None if content_length == Some(DDL_BYTES.len()) => Some((0, DDL_BYTES.len() - 1)),
None => None,
};
let Some((start, end)) = slice else {
return response;
}
};
let expected = &DDL_BYTES.as_bytes()[start..=end];
let (parts, body) = response.into_parts();
match axum::body::to_bytes(body, DDL_BYTES.len()).await {
Ok(bytes) if bytes.as_ref() == DDL_BYTES.as_bytes() => api_not_found().await,
match axum::body::to_bytes(body, expected.len()).await {
Ok(bytes) if bytes.as_ref() == expected => api_not_found().await,
Ok(bytes) => Response::from_parts(parts, axum::body::Body::from(bytes)),
// `Content-Length` 说谎(实际比声明的长)⇒ fail-closed。
// 长度说谎(实际比声明的长)⇒ fail-closed。
Err(_) => api_not_found().await,
}
}
/// 解析 `Content-Range: bytes <start>-<end>/<total>` ⇒ `(start, end)`。
///
/// 🔴 **只认 `bytes` 单位 + 闭区间 `start-end`**;`total` 段**一律忽略**。
///
/// 🔴 **为什么忽略 `total`**:我们要判的是「**这一段**是不是内嵌 DDL 的对应片段」
/// ⇒ 只需要 `start`/`end`;忽略 `total` 还顺带兜住「DDL + 一段尾巴」这类副本
/// (`total` 比 DDL 长,但它的前 N 字节**就是** DDL 的前 N 字节 ⇒ 片段仍会被拦)。
fn parse_content_range(value: &str) -> Option<(usize, usize)> {
let rest = value.trim().strip_prefix("bytes ")?;
let (range, _total) = rest.split_once('/')?;
let (start, end) = range.trim().split_once('-')?;
Some((start.trim().parse().ok()?, end.trim().parse().ok()?))
}
/// 兜底决策:`/api` 命名空间 ⇒ 404 JSON;否则 ⇒ `index.html`。
///
/// ⚠️ DDL 判定**不在这里**(已由前置守卫 `ddl_guard` 拦在 `ServeDir` 之前 ⇒ 此处再判是死代码)。
+51
View File
@@ -469,6 +469,57 @@ async fn ddl_content_guard_blocks_renamed_copy() {
failures.push(format!("/schema.txt(整份 Range)必须是 JSON,实际 {ct}"));
}
// ④ **片段 Range**(`bytes=0-1000`)⇒ 响应体只有 1001 字节(`Content-Length` ≠ DDL 长度)
// ⇒ 只按「整份长度」比对会放行 ⇒ 而逐段请求能把整份 DDL **拼回来** ⇒ 必须拦。
let (status, ct, body) = call_dir_with_range(&tmp, "/schema.txt", Some("bytes=0-1000")).await;
if status != StatusCode::NOT_FOUND {
failures.push(format!(
"/schema.txt(片段 Range)必须是 404,实际 {status},body={}",
&body[..body.len().min(200)]
));
}
if !ct.starts_with("application/json") {
failures.push(format!("/schema.txt(片段 Range)必须是 JSON,实际 {ct}"));
}
if body.contains("CREATE TABLE") {
failures.push(format!(
"/schema.txt(片段 Range)响应体不得含 DDL:{}",
&body[..body.len().min(200)]
));
}
// ⑤ **中段 Range**(`bytes=5000-6000`)⇒ 比的是**同偏移**的 DDL 片段 ⇒ 同样拦。
let (status, _ct, body) =
call_dir_with_range(&tmp, "/schema.txt", Some("bytes=5000-6000")).await;
if status != StatusCode::NOT_FOUND {
failures.push(format!(
"/schema.txt(中段 Range)必须是 404,实际 {status},body={}",
&body[..body.len().min(200)]
));
}
if body.contains("CREATE TABLE") {
failures.push(format!(
"/schema.txt(中段 Range)响应体不得含 DDL:{}",
&body[..body.len().min(200)]
));
}
// ⑥ **片段 Range 打在等长不同内容的文件上** ⇒ 放行(206 + 该片段)
// ⇒ 证明分段兜底比的是**内容**(同偏移逐字节),不是长度。
let (status, _ct, body) = call_dir_with_range(&tmp, "/other.txt", Some("bytes=0-1000")).await;
if status != StatusCode::PARTIAL_CONTENT {
failures.push(format!(
"/other.txt(片段 Range)应当是 206,实际 {status},body={}",
&body[..body.len().min(200)]
));
}
if body.len() != 1001 {
failures.push(format!(
"/other.txt(片段 Range)响应体长度应为 1001,实际 {}",
body.len()
));
}
let _ = std::fs::remove_dir_all(&tmp);
assert!(failures.is_empty(), "{}", failures.join("\n"));