- 协议版本收敛为单一常量 3.2,移除联调期自创的 env 覆盖 - 按真源同步 5 项契约:Dispute 下线、Billing/List 增 side、internalCatalog 6 过滤字段、新增 ServiceCatalog/Detail、出向方法收敛 - 修正 /api/** 未命中非 GET 请求被静态兜底判成 405 的偏差,恢复 404 契约 - 新增上游用例跨进程验证脚本与 4 份联调文档;部署级凭据只从环境变量读取 - 全量测试 308 passed;132 端点契约一致;真 TDS 21 条用例 19 PASS / 1 FAIL / 1 INFO
599 lines
24 KiB
Rust
599 lines
24 KiB
Rust
//! 兜底服务(404 / SPA 深链)的行为锁定。
|
||
//!
|
||
//! ⚠️ **只测兜底服务本身**(对它 `oneshot`),**不接鉴权中间件**
|
||
//! (接了就会先吃 401,测不到 404)。
|
||
//! ⚠️ 本测试二进制**不需要 PGlite**(兜底不碰 DB)⇒ 不建 PGlite 实例。
|
||
|
||
use std::path::{Path, PathBuf};
|
||
|
||
use axum::body::Body;
|
||
use axum::http::{header, Method, Request, StatusCode};
|
||
use http_body_util::BodyExt;
|
||
use tower::ServiceExt;
|
||
|
||
use tdc_connector::platform::fallback::spa_fallback;
|
||
|
||
/// 仓库里的 `static/`(SPA 构建产物)。
|
||
fn static_dir() -> PathBuf {
|
||
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("static")
|
||
}
|
||
|
||
/// 打一个请求到兜底服务,返回 `(状态码, content-type, body 文本)`。
|
||
async fn call(uri: &str) -> (StatusCode, String, String) {
|
||
call_dir(&static_dir(), uri).await
|
||
}
|
||
|
||
/// 打一个请求到**指定** web root 的兜底服务,返回 `(状态码, content-type, body 文本)`。
|
||
async fn call_dir(dir: &Path, uri: &str) -> (StatusCode, String, String) {
|
||
call_dir_with_range(dir, uri, None).await
|
||
}
|
||
|
||
/// 同上,但可带一个 `Range` 头(`range = None` 时不带)。
|
||
async fn call_dir_with_range(
|
||
dir: &Path,
|
||
uri: &str,
|
||
range: Option<&str>,
|
||
) -> (StatusCode, String, String) {
|
||
let svc = spa_fallback(dir);
|
||
let mut builder = Request::builder().uri(uri);
|
||
if let Some(value) = range {
|
||
builder = builder.header(header::RANGE, value);
|
||
}
|
||
let req = builder.body(Body::empty()).expect("构造请求失败");
|
||
let resp = svc.oneshot(req).await.expect("兜底服务不应出错");
|
||
let status = resp.status();
|
||
let ct = resp
|
||
.headers()
|
||
.get(header::CONTENT_TYPE)
|
||
.and_then(|v| v.to_str().ok())
|
||
.unwrap_or("")
|
||
.to_string();
|
||
let bytes = resp
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("读取 body 失败")
|
||
.to_bytes();
|
||
let text = String::from_utf8_lossy(&bytes).to_string();
|
||
(status, ct, text)
|
||
}
|
||
|
||
/// `/api/**` 未命中 ⇒ 404 + JSON(**无 `data` 键**)。
|
||
///
|
||
/// 🔴 附带断言(R2-3):
|
||
/// - `/api%2Ffoo`(**编码斜杠**)⇒ 判定前先 percent-decode ⇒ 解码后是 `/api/foo`
|
||
/// ⇒ 落在 `/api` 命名空间 ⇒ **404 + JSON**(**不是** SPA 的 HTML);
|
||
/// - `/apifoo`(**非** `/api` 命名空间)⇒ **不能**被误吞 ⇒ 仍回 SPA HTML(200 `text/html`)。
|
||
#[tokio::test]
|
||
async fn api_prefix_returns_404_json_without_data_key() {
|
||
let (status, ct, body) = call("/api/anything").await;
|
||
assert_eq!(status, StatusCode::NOT_FOUND, "body={}", body);
|
||
assert_eq!(ct, "application/json", "body={}", body);
|
||
let v: serde_json::Value = serde_json::from_str(&body).expect("body 必须是 JSON");
|
||
assert_eq!(v["code"], 404);
|
||
assert_eq!(v["msg"], "接口不存在");
|
||
assert!(
|
||
v.get("data").is_none(),
|
||
"404 信封不得有 data 键(与 auth::reject 同族):{:?}",
|
||
v
|
||
);
|
||
|
||
// R2-3:编码斜杠 ⇒ 解码后属于 `/api` 命名空间 ⇒ 404 + JSON。
|
||
let (status, ct, body) = call("/api%2Ffoo").await;
|
||
assert_eq!(status, StatusCode::NOT_FOUND, "body={}", body);
|
||
assert_eq!(ct, "application/json", "body={}", body);
|
||
let v: serde_json::Value = serde_json::from_str(&body).expect("body 必须是 JSON");
|
||
assert_eq!(v["code"], 404);
|
||
|
||
// R2-3:`/apifoo` 不是 `/api` 命名空间 ⇒ 不能被误吞成 404 JSON。
|
||
let (status, ct, _body) = call("/apifoo").await;
|
||
assert_eq!(status, StatusCode::OK, "`/apifoo` 不应被误吞");
|
||
assert!(ct.starts_with("text/html"), "content-type={:?}", ct);
|
||
}
|
||
|
||
/// `/api/`(**带尾斜杠**)⇒ 404 + JSON。
|
||
///
|
||
/// 🔴 这条是回归点:matchit 的 `{*rest}` **不匹配空 rest** ⇒ 旧实现里它落到 SPA 兜底回 HTML。
|
||
#[tokio::test]
|
||
async fn api_prefix_with_trailing_slash_returns_404_json() {
|
||
let (status, ct, body) = call("/api/").await;
|
||
assert_eq!(status, StatusCode::NOT_FOUND, "body={}", body);
|
||
assert_eq!(ct, "application/json", "body={}", body);
|
||
let v: serde_json::Value = serde_json::from_str(&body).expect("body 必须是 JSON");
|
||
assert_eq!(v["code"], 404);
|
||
}
|
||
|
||
/// 同上,但可指定 HTTP 方法(用于验证**非 GET** 的 `/api/**` 未命中)。
|
||
async fn call_with_method(method: Method, uri: &str) -> (StatusCode, String, String) {
|
||
let svc = spa_fallback(&static_dir());
|
||
let req = Request::builder()
|
||
.method(method)
|
||
.uri(uri)
|
||
.body(Body::empty())
|
||
.expect("构造请求失败");
|
||
let resp = svc.oneshot(req).await.expect("兜底服务不应出错");
|
||
let status = resp.status();
|
||
let ct = resp
|
||
.headers()
|
||
.get(header::CONTENT_TYPE)
|
||
.and_then(|v| v.to_str().ok())
|
||
.unwrap_or("")
|
||
.to_string();
|
||
let bytes = resp
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("读取 body 失败")
|
||
.to_bytes();
|
||
let text = String::from_utf8_lossy(&bytes).to_string();
|
||
(status, ct, text)
|
||
}
|
||
|
||
/// 🔴 回归:`/api/**` 未命中在**任意方法**下都必须是 404 JSON。
|
||
///
|
||
/// 旧实现把请求先交给静态服务,而静态服务对非 `GET`/`HEAD` 一律先回
|
||
/// `405 + Allow` ⇒ 已下线的 API 端点用 `PUT` 探活会拿到 405,
|
||
/// 既违反本模块第一行契约,也不符合上游 `ssw-tdc` `chg_0022/C5`
|
||
/// 「账单无异议 ⇒ 端点 404」的验收口径。
|
||
#[tokio::test]
|
||
async fn api_unmatched_non_get_returns_404_json() {
|
||
for method in [Method::PUT, Method::POST, Method::DELETE, Method::PATCH] {
|
||
let (status, ct, body) =
|
||
call_with_method(method.clone(), "/api/ssw/tdc/Billing/LEDGER-1/Dispute").await;
|
||
assert_eq!(
|
||
status,
|
||
StatusCode::NOT_FOUND,
|
||
"method={} body={}",
|
||
method,
|
||
body
|
||
);
|
||
assert_eq!(ct, "application/json", "method={} body={}", method, body);
|
||
let v: serde_json::Value = serde_json::from_str(&body).expect("body 必须是 JSON");
|
||
assert_eq!(v["code"], 404, "method={}", method);
|
||
assert_eq!(v["msg"], "接口不存在", "method={}", method);
|
||
assert!(
|
||
v.get("data").is_none(),
|
||
"404 信封不得有 data 键:method={} {:?}",
|
||
method,
|
||
v
|
||
);
|
||
}
|
||
|
||
// HEAD 按 HTTP 语义不回 body ⇒ 只锁状态码。
|
||
let (status, _, _) =
|
||
call_with_method(Method::HEAD, "/api/ssw/tdc/Billing/LEDGER-1/Dispute").await;
|
||
assert_eq!(status, StatusCode::NOT_FOUND, "HEAD 未命中 /api 也应 404");
|
||
|
||
// 🔴 反向锁定:非 `/api` 路径的非 GET 仍由静态服务按 RFC 9110 回 405,
|
||
// 前置判定不得把整站的非 GET 请求都吞成 404。
|
||
let (status, _, body) = call_with_method(Method::PUT, "/tdc/home").await;
|
||
assert_eq!(
|
||
status,
|
||
StatusCode::METHOD_NOT_ALLOWED,
|
||
"SPA 深链的非 GET 仍应是 405:body={}",
|
||
body
|
||
);
|
||
}
|
||
|
||
/// `/migrate.sql` ⇒ 404,且**响应体不含 `CREATE TABLE`**(不得泄露 DDL)。
|
||
#[tokio::test]
|
||
async fn migrate_sql_is_not_downloadable() {
|
||
let (status, _ct, body) = call("/migrate.sql").await;
|
||
assert_eq!(status, StatusCode::NOT_FOUND, "body={}", body);
|
||
assert!(
|
||
!body.contains("CREATE TABLE"),
|
||
"响应体不得含 DDL:{}",
|
||
&body[..body.len().min(200)]
|
||
);
|
||
}
|
||
|
||
/// `/MIGRATE.SQL`(**大小写变体**)⇒ 响应体不得含 `CREATE TABLE`。
|
||
///
|
||
/// 🔴 这条是回归点:macOS 文件系统大小写不敏感 ⇒ 旧实现里它能下到完整 DDL。
|
||
#[tokio::test]
|
||
async fn migrate_sql_case_variant_is_not_downloadable() {
|
||
let (status, _ct, body) = call("/MIGRATE.SQL").await;
|
||
assert!(
|
||
!body.contains("CREATE TABLE"),
|
||
"大小写变体不得泄露 DDL:{}",
|
||
&body[..body.len().min(200)]
|
||
);
|
||
assert_ne!(status, StatusCode::OK, "大小写变体不应 200");
|
||
}
|
||
|
||
/// SPA 深链 ⇒ 200 + `text/html`(内容是上游 SPA 外壳)。
|
||
#[tokio::test]
|
||
async fn spa_deep_link_returns_index_html() {
|
||
let (status, ct, body) = call("/tdc/home").await;
|
||
assert_eq!(status, StatusCode::OK, "body={}", body);
|
||
assert!(
|
||
ct.starts_with("text/html"),
|
||
"content-type 应为 text/html,实际 {:?}",
|
||
ct
|
||
);
|
||
assert!(
|
||
body.contains("<title>尚数网可信数据空间(连接器)</title>"),
|
||
"应是上游 SPA 外壳:{}",
|
||
&body[..body.len().min(200)]
|
||
);
|
||
}
|
||
|
||
/// 静态资源(`/assets/*.js`)⇒ 200(由 `ServeDir` 直接出,不走兜底)。
|
||
///
|
||
/// 🔴 R3-2 补的断言:**content-type 不得以 `text/html` 开头**。
|
||
/// 只断言 `status == 200` 时,`ServeDir` 的根目录坏掉(资源不存在)也会绿——
|
||
/// 因为请求落到决策层、回的是 `static/index.html`(200 `text/html`)。
|
||
/// 加上 content-type 后,「资源被 `ServeDir` 命中」与「回落成 SPA index」才可区分。
|
||
#[tokio::test]
|
||
async fn static_assets_are_still_served() {
|
||
let asset = std::fs::read_dir(static_dir().join("assets"))
|
||
.expect("读 static/assets 失败")
|
||
.filter_map(|e| e.ok())
|
||
.map(|e| e.file_name().to_string_lossy().into_owned())
|
||
.find(|n| n.starts_with("index-") && n.ends_with(".js"))
|
||
.expect("static/assets 里应有 index-*.js");
|
||
let (status, ct, body) = call(&format!("/assets/{}", asset)).await;
|
||
assert_eq!(
|
||
status,
|
||
StatusCode::OK,
|
||
"body={}",
|
||
&body[..body.len().min(200)]
|
||
);
|
||
assert!(
|
||
!ct.starts_with("text/html"),
|
||
"静态资源应由 ServeDir 直接出(实测 text/javascript),不该回落成 SPA index.html:ct={:?}",
|
||
ct
|
||
);
|
||
}
|
||
|
||
/// 在 `temp_dir` 下造一个 web root,写入给定的 `(相对路径, 内容)` 文件对。
|
||
///
|
||
/// 🔴 名字 = **pid + 纳秒 + 进程内自增序号**:单靠纳秒仍有残余竞争
|
||
/// (同进程内两个并发用例可能拿到同一个纳秒 ⇒ 目录名撞车 ⇒
|
||
/// 先结束的那个把后者的目录删了 ⇒ 后者读到 `index.html missing`)。
|
||
/// 自增序号保证同进程内唯一。
|
||
fn tmp_web_root_with_files(files: &[(&str, &str)]) -> PathBuf {
|
||
use std::sync::atomic::{AtomicU32, Ordering};
|
||
static SEQ: AtomicU32 = AtomicU32::new(0);
|
||
let tmp = std::env::temp_dir().join(format!(
|
||
"tdc-ddl-guard-{}-{}-{}",
|
||
std::process::id(),
|
||
std::time::SystemTime::now()
|
||
.duration_since(std::time::UNIX_EPOCH)
|
||
.map(|d| d.as_nanos())
|
||
.unwrap_or(0),
|
||
SEQ.fetch_add(1, Ordering::Relaxed),
|
||
));
|
||
std::fs::create_dir_all(&tmp).expect("创建临时 web root 失败");
|
||
for (name, content) in files {
|
||
let path = tmp.join(name);
|
||
if let Some(parent) = path.parent() {
|
||
std::fs::create_dir_all(parent).expect("创建子目录失败");
|
||
}
|
||
std::fs::write(&path, content).expect("写临时文件失败");
|
||
}
|
||
tmp
|
||
}
|
||
|
||
/// 在 `temp_dir` 下造一个「含 `migrate.sql` 的 web root」(并发安全的名字)。
|
||
///
|
||
/// 内容用**可识别的标记串**(不是真 DDL,避免报告里出现真 DDL 片段)。
|
||
fn tmp_web_root_with_ddl() -> PathBuf {
|
||
tmp_web_root_with_files(&[
|
||
(
|
||
"migrate.sql",
|
||
"CREATE TABLE tdc_secret (id text);\n-- DDL MUST NOT LEAK\n",
|
||
),
|
||
("index.html", "<title>tmp</title>"),
|
||
])
|
||
}
|
||
|
||
/// 🔴 **回归点(R2-1 / R3-1)**:DDL 文件**就在 web root 里**时,下列**每一条**变体都**必须**下不到。
|
||
///
|
||
/// 这条测试证明的是「前置守卫 `ddl_guard` 真的跑在 `ServeDir` **之前**」:
|
||
/// - 若守卫只在 `ServeDir` 的 decision 层(文件没找到时)判定 ⇒ 这里会 **200 + 完整 DDL**;
|
||
/// - 若守卫是前置中间件 ⇒ 无论文件在不在 web root,都是 **404 + JSON**。
|
||
///
|
||
/// 🔴 R3-2:**每一条**变体都必须同时满足「404 + `application/json` + 响应体不含标记串」。
|
||
/// R2 时的变体清单只有 4 条,且**恰好全在旧守卫的判定口径内**(只看末段)
|
||
/// ⇒ 用例对「末段带 `.`」那一族(`/migrate.sql/.` 等 24 条)**零敏感**。
|
||
/// 现在清单覆盖了复评实测漏网的 24 条 + 回归护栏 ⇒ **任一条漏网即红**。
|
||
#[tokio::test]
|
||
async fn ddl_in_web_root_is_still_not_downloadable() {
|
||
// 在临时目录里造一个「含 migrate.sql 的 web root」。
|
||
let tmp = tmp_web_root_with_ddl();
|
||
|
||
// 变体清单:复评实测漏网的 24 条 + R2 的 4 条 + 尾斜杠 / 编码斜杠 / 尾部空白等护栏
|
||
// + R4 的 Unicode casefold 一族(`ſ` 家族:旧守卫用 ASCII 折叠 ⇒ 这一族会漏网)。
|
||
const VARIANTS: [&str; 44] = [
|
||
// R2 的 4 条(原本就在)
|
||
"/migrate.sql",
|
||
"/MIGRATE.SQL",
|
||
"/migrate%2Esql",
|
||
"//migrate.sql",
|
||
// 大小写 / 编码变体
|
||
"/Migrate.sql",
|
||
"/migrate%2esql",
|
||
"/%6digrate.sql",
|
||
// 尾斜杠 / 编码斜杠
|
||
"/migrate.sql/",
|
||
"/migrate.sql%2f",
|
||
// 末段带 `.` 的一族(R2 漏网 ⇒ R3 的重点)
|
||
"/migrate.sql/.",
|
||
"/migrate.sql/./",
|
||
"/migrate.sql/%2e",
|
||
"/migrate.sql/%2E",
|
||
"/migrate.sql/%2e%2f",
|
||
"/migrate.sql/././.",
|
||
"/MIGRATE.SQL/.",
|
||
"/MIGRATE.SQL/./",
|
||
"/MIGRATE.SQL/%2e",
|
||
"/MIGRATE.SQL/%2E",
|
||
"/MIGRATE.SQL/%2e%2f",
|
||
"/MIGRATE.SQL/././.",
|
||
"/migrate%2Esql/.",
|
||
"/migrate%2Esql/./",
|
||
"/migrate%2Esql/%2e",
|
||
"/migrate%2Esql/%2E",
|
||
"/migrate%2Esql/%2e%2f",
|
||
"/migrate%2Esql/././.",
|
||
"/%6digrate.sql/.",
|
||
"/%6digrate.sql/./",
|
||
"/%6digrate.sql/%2e",
|
||
"/%6digrate.sql/%2E",
|
||
"/%6digrate.sql/%2e%2f",
|
||
"/%6digrate.sql/././.",
|
||
// 「任一段」口径的护栏(不止是修 `.` 那一族)
|
||
"/migrate.sql/..",
|
||
"/schema/migrate.sql",
|
||
// 尾部空白(收紧项)
|
||
"/migrate.sql%20",
|
||
// R4:Unicode casefold 一族(`ſ` = U+017F,APFS 上与 `s` 等价)
|
||
"/migrate.%C5%BFql",
|
||
"/MIGRATE.%C5%BFQL",
|
||
"/migrate.%C5%BFql/.",
|
||
"/migrate.%C5%BFql/./",
|
||
"/migrate.%C5%BFql%2f",
|
||
"/schema/migrate.%C5%BFql",
|
||
// 扩展名里的字母被 percent 编码(解码后仍命中)
|
||
"/migrate.s%71l",
|
||
"/migrate.%73ql",
|
||
];
|
||
|
||
let mut failures: Vec<String> = Vec::new();
|
||
for uri in VARIANTS {
|
||
let (status, ct, body) = call_dir(&tmp, uri).await;
|
||
let head: String = body.chars().take(200).collect();
|
||
if status != StatusCode::NOT_FOUND {
|
||
failures.push(format!(
|
||
"uri={uri} 必须是 404(DDL 在 web root 里也下不到),实际 {status},body={head}"
|
||
));
|
||
}
|
||
if !ct.starts_with("application/json") {
|
||
failures.push(format!("uri={uri} 必须是 JSON,实际 {ct},body={head}"));
|
||
}
|
||
if body.contains("CREATE TABLE") || body.contains("DDL MUST NOT LEAK") {
|
||
failures.push(format!("uri={uri} 响应体不得含 DDL:{head}"));
|
||
}
|
||
}
|
||
|
||
// 只删**自己**在 temp_dir 下建的那个目录(不碰仓库里任何东西)。
|
||
let _ = std::fs::remove_dir_all(&tmp);
|
||
|
||
assert!(failures.is_empty(), "{}", failures.join("\n"));
|
||
}
|
||
|
||
/// 🔴 **回归点(R3-1)**:「**任意一段**命中」的口径被**单独**钉住。
|
||
///
|
||
/// 守卫的判据是「路径中任意一段(去尾部空白、忽略大小写)等于 `migrate.sql`」,
|
||
/// 而不是「最后一段」。这三条路径分别覆盖:
|
||
/// - `/schema/migrate.sql` ⇒ DDL 文件名在**中间**一段(不是末段);
|
||
/// - `/migrate.sql/..` ⇒ 末段是 `..`,DDL 文件名在**前一段**;
|
||
/// - `/migrate.sql/.` ⇒ 末段是 `.`(`ServeDir` 归一化时会被**丢弃**,
|
||
/// 于是它把 `migrate.sql` 当成末段文件直接吐出 ⇒ 这条是 R2 漏网的那一族)。
|
||
///
|
||
/// 三条都必须是 **404 + JSON + 响应体不含标记串**。
|
||
#[tokio::test]
|
||
async fn ddl_is_blocked_by_any_path_segment() {
|
||
let tmp = tmp_web_root_with_ddl();
|
||
|
||
let mut failures: Vec<String> = Vec::new();
|
||
for uri in ["/schema/migrate.sql", "/migrate.sql/..", "/migrate.sql/."] {
|
||
let (status, ct, body) = call_dir(&tmp, uri).await;
|
||
let head: String = body.chars().take(200).collect();
|
||
if status != StatusCode::NOT_FOUND {
|
||
failures.push(format!("uri={uri} 必须是 404,实际 {status},body={head}"));
|
||
}
|
||
if !ct.starts_with("application/json") {
|
||
failures.push(format!("uri={uri} 必须是 JSON,实际 {ct},body={head}"));
|
||
}
|
||
if body.contains("CREATE TABLE") || body.contains("DDL MUST NOT LEAK") {
|
||
failures.push(format!("uri={uri} 响应体不得含 DDL:{head}"));
|
||
}
|
||
}
|
||
|
||
let _ = std::fs::remove_dir_all(&tmp);
|
||
|
||
assert!(failures.is_empty(), "{}", failures.join("\n"));
|
||
}
|
||
|
||
/// 🔴 **回归点(R4-1)**:**Unicode casefold** 家族(`ſ` = U+017F)**必须**下不到。
|
||
///
|
||
/// macOS APFS 的文件名比较用的是 **Unicode casefold**(不是 ASCII 折叠)⇒
|
||
/// 磁盘上叫 `migrate.sql` 的文件,用 `migrate.ſql` 也能打开
|
||
/// (**本机实测**:12 种扩展名拼法 `s∈{s,S,ſ} × q∈{q,Q} × l∈{l,L}` 全部命中同一个文件)。
|
||
///
|
||
/// 旧守卫用 `eq_ignore_ascii_case` ⇒ 只能覆盖 1536 种拼法里的 1024 种
|
||
/// ⇒ 含 `ſ` 的 512 种**全部漏网** ⇒ 这一族是 R3 复评的 Critical。
|
||
/// 新守卫用「扩展名 + **Unicode 大写折叠**」⇒ 覆盖 1536 / 1536。
|
||
#[tokio::test]
|
||
async fn ddl_unicode_casefold_variants_are_not_downloadable() {
|
||
let tmp = tmp_web_root_with_ddl();
|
||
|
||
const VARIANTS: [&str; 8] = [
|
||
"/migrate.%C5%BFql",
|
||
"/MIGRATE.%C5%BFQL",
|
||
"/migrate.%C5%BFql/.",
|
||
"/migrate.%C5%BFql/./",
|
||
"/migrate.%C5%BFql%2f",
|
||
"/schema/migrate.%C5%BFql",
|
||
"/migrate.s%71l",
|
||
"/migrate.%73ql",
|
||
];
|
||
|
||
let mut failures: Vec<String> = Vec::new();
|
||
for uri in VARIANTS {
|
||
let (status, ct, body) = call_dir(&tmp, uri).await;
|
||
let head: String = body.chars().take(200).collect();
|
||
if status != StatusCode::NOT_FOUND {
|
||
failures.push(format!(
|
||
"uri={uri} 必须是 404(Unicode casefold 变体同样下不到 DDL),实际 {status},body={head}"
|
||
));
|
||
}
|
||
if !ct.starts_with("application/json") {
|
||
failures.push(format!("uri={uri} 必须是 JSON,实际 {ct},body={head}"));
|
||
}
|
||
if body.contains("CREATE TABLE") || body.contains("DDL MUST NOT LEAK") {
|
||
failures.push(format!("uri={uri} 响应体不得含 DDL:{head}"));
|
||
}
|
||
}
|
||
|
||
let _ = std::fs::remove_dir_all(&tmp);
|
||
|
||
assert!(failures.is_empty(), "{}", failures.join("\n"));
|
||
}
|
||
|
||
/// 🔴 **回归点(R4-2)**:**改了名**、但内容**逐字节相同**的 DDL 副本**必须**下不到。
|
||
///
|
||
/// 路径级守卫只认**扩展名** ⇒ `schema.txt` 不在它的射程内
|
||
/// ⇒ 由**内容级**兜底(与**内嵌** DDL 逐字节比较)拦住。
|
||
///
|
||
/// 🔴 同时钉住**反向护栏**:**长度与 DDL 相同、但内容不同**的文件**必须**照常吐出
|
||
/// (否则说明兜底是按「长度」而不是按「内容」判的 ⇒ 会误伤一切等长文件)。
|
||
#[tokio::test]
|
||
async fn ddl_content_guard_blocks_renamed_copy() {
|
||
/// 仓库里的真 DDL(与 lib 里 `include_str!` 内嵌的是**同一个文件** ⇒ 逐字节相同)。
|
||
const DDL: &str = include_str!("../schema/migrate.sql");
|
||
// 等长但内容不同的对照文件。
|
||
let same_length_other = "x".repeat(DDL.len());
|
||
|
||
let tmp = tmp_web_root_with_files(&[
|
||
("schema.txt", DDL),
|
||
("other.txt", same_length_other.as_str()),
|
||
("index.html", "<title>tmp</title>"),
|
||
]);
|
||
|
||
let mut failures: Vec<String> = Vec::new();
|
||
|
||
// ① 改名副本(内容逐字节相同)⇒ 404 + JSON,且响应体不含 DDL。
|
||
let (status, ct, body) = call_dir(&tmp, "/schema.txt").await;
|
||
if status != StatusCode::NOT_FOUND {
|
||
failures.push(format!(
|
||
"/schema.txt(改名但内容相同)必须是 404,实际 {status},body={}",
|
||
&body[..body.len().min(200)]
|
||
));
|
||
}
|
||
if !ct.starts_with("application/json") {
|
||
failures.push(format!("/schema.txt 必须是 JSON,实际 {ct}"));
|
||
}
|
||
if body.contains("CREATE TABLE") {
|
||
failures.push(format!(
|
||
"/schema.txt 响应体不得含 DDL:{}",
|
||
&body[..body.len().min(200)]
|
||
));
|
||
}
|
||
|
||
// ② 等长但内容不同 ⇒ 照常吐出(证明兜底比的是**内容**不是长度)。
|
||
let (status, ct, body) = call_dir(&tmp, "/other.txt").await;
|
||
if status != StatusCode::OK {
|
||
failures.push(format!(
|
||
"/other.txt(等长不同内容)应当照常吐出,实际 {status},body={}",
|
||
&body[..body.len().min(200)]
|
||
));
|
||
}
|
||
if body.len() != DDL.len() {
|
||
failures.push(format!(
|
||
"/other.txt 响应体长度应为 {},实际 {}",
|
||
DDL.len(),
|
||
body.len()
|
||
));
|
||
}
|
||
if ct.starts_with("text/html") {
|
||
failures.push(format!("/other.txt 不应回落成 SPA index.html,ct={ct}"));
|
||
}
|
||
|
||
// ③ **整份 Range**(`bytes=0-`)⇒ `Content-Length` 仍等于整份长度
|
||
// ⇒ 同样必须拿不到 DDL(否则 Range 就成了绕过口)。
|
||
let (status, ct, body) = call_dir_with_range(&tmp, "/schema.txt", Some("bytes=0-")).await;
|
||
if body.contains("CREATE TABLE") {
|
||
failures.push(format!(
|
||
"/schema.txt(整份 Range)响应体不得含 DDL:{}",
|
||
&body[..body.len().min(200)]
|
||
));
|
||
}
|
||
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}"));
|
||
}
|
||
|
||
// ④ **片段 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"));
|
||
}
|