fix(compat): 修复真实系统性验证发现的 6 处运行时缺陷

- ResetPassword 改读官方 userPassword(已是 md5,原样落库),兼容 password/newPassword;改密后吊销该用户会话
- 修复三处 count SQL 与参数不匹配导致的 code=500;RecordList 同时补 f_monitor_id 过滤(原先会串监控记录)
- updatePasswordMessage 改 200 + data:null(官方前端每页无条件调用且不 catch)
- ensure_schema_all 不再吞掉业务包装载错误
- 路径参数非法时返回信封 400,不再吐纯文本
- 新增 tests/verify_fixes_it.rs 7 条回归;全量 661 passed,verify.sh --smoke 14 步全绿
This commit is contained in:
admin committed 2026-11-02 23:15:40 +08:00
1 parent fc31804f4e
commit 31e0e457ba
12 files changed
+755 -25

No files matched your search

+12 -5
View File
@@ -165,13 +165,20 @@ pub async fn ensure_pack_schema(db: &Db, reg: &PackRegistry) -> Result<(), pglit
/// ⇒ 两段打包成一个函数 ⇒ 生产(`main.rs`)与测试(23 个集成测试文件)都调它。
///
/// - `db`:库句柄。
pub async fn ensure_schema_all(db: &Db) -> Result<(), pglite::Error> {
///
/// 🔴 **错误必须往上抛**:这里曾经写 `if let Ok(reg) = packs()` —— 业务包装载失败时
/// 只建平台表、不建业务表,启动却照常成功 ⇒ 业务包端点全在、表全无(`relation does not exist`)。
/// ⇒ 现在 `packs()` 的 Err 直接转成返回值,由 `main.rs` 打印人话并退出。
pub async fn ensure_schema_all(db: &Db) -> Result<(), String> {
// ---- 第 1 段:平台表(`db/schema.sql`)----
db.ensure_schema().await?;
db.ensure_schema()
.await
.map_err(|e| format!("平台表建库失败: {e}"))?;
// ---- 第 2 段:业务包的表(跟着包走)----
if let Ok(reg) = packs() {
ensure_pack_schema(db, reg).await?;
}
let reg = packs().map_err(|e| format!("业务包装载失败: {e}"))?;
ensure_pack_schema(db, reg)
.await
.map_err(|e| format!("业务包建表失败: {e}"))?;
Ok(())
}
+9 -2
View File
@@ -291,9 +291,16 @@ pub async fn set_code_certificate_status(
/// 官方 `LoginController.java:269-273`:调 `loginService.updatePasswordMessage()`
/// ⇒ 走**邮件 / 短信**通道把「您的密码即将过期」发给用户。
///
/// 🔴 本仓**无邮件服务、无短信通道** ⇒ 如实失败(不假装发成功)。
/// 🔴 本仓**无邮件服务、无短信通道** ⇒ 没有提醒可发。
/// 🔴 **但不能返 400**:官方前端 `layouts/header/index.vue:74` 在**每个页面挂载时
/// 无条件调用且没有 catch** ⇒ `code=400` 会变成一条未捕获 Promise 异常。
/// ⇒ 返回 `200 + data:null`,并在 `msg` 里说清「已跳过」,不假装发过。
pub async fn update_password_message() -> Json<ActionResult> {
unsupported("修改密码提醒(没有邮件 / 短信通道)")
Json(ActionResult {
code: code::SUCCESS,
msg: "本极简引擎无邮件 / 短信通道,已跳过改密提醒".to_string(),
data: Value::Null,
})
}
// ================================================================ SaaS 多租户
@@ -3317,7 +3317,13 @@ pub async fn monitor_record_list(
}
let page = Paging::of(&raw);
let status = qv(&raw, "status");
let mut filters: Vec<String> = vec!["COALESCE(r.f_delete_mark, 0) = 0".to_string()];
let mut filters: Vec<String> = vec![
"COALESCE(r.f_delete_mark, 0) = 0".to_string(),
// 🔴 `$1` 必须真的出现在 WHERE 里:只把 id 塞进 values 而不写条件,
// count SQL 会是「0 个占位符 + 1 个参数」⇒ pglite 直接报协议错 ⇒ 500。
// 而且不写这条条件会把**所有**监控的发送记录都返回(串数据)。
"r.f_monitor_id = $1::text".to_string(),
];
let mut values: Vec<Option<String>> = vec![Some(id.clone())];
if !status.is_empty() {
filters.push("r.f_status = $2::text::integer".to_string());
+10 -3
View File
@@ -2238,7 +2238,6 @@ pub async fn share_selector(
if let Err(resp) = require_login_face_b(&state, &headers).await {
return resp;
}
let system_id = current_system_id(&state.db).await;
// 🔴 官方:只要「在线开发 + 带列表」的(`type=1` 且 `webType=2`),且查**已发布**。
let current_rows = match state
@@ -2263,7 +2262,7 @@ pub async fn share_selector(
WHERE COALESCE(s.f_delete_mark, 0) = 0 AND v.f_delete_mark = 0 \
AND COALESCE(v.f_type, 0) = 1 AND COALESCE(v.f_web_type, 0) = 2 \
ORDER BY v.f_full_name ASC",
&[&system_id],
&[],
)
.await
{
@@ -2335,9 +2334,17 @@ pub async fn online_log_list(
format!(" AND f_model_id = $1::text")
}
);
// 🔴 count SQL 与 list SQL 必须**用同一组参数**:`modelId` 为空时计数 SQL 里
// 根本没有 `$1`,仍传一个参数会让 pglite 报
// `statement takes 0 parameters, 1 given` ⇒ 500。
let count_values: Vec<Option<String>> = if model_id.is_empty() {
Vec::new()
} else {
vec![Some(model_id.clone())]
};
let total = match state
.db
.query_json_params(&count_sql, &params_of(&[Some(model_id.clone())]))
.query_json_params(&count_sql, &params_of(&count_values))
.await
{
Ok(rows) => rows
+25 -8
View File
@@ -678,8 +678,12 @@ pub async fn users_batch_update_state(
/// `POST /api/permission/Users/{id}/Actions/ResetPassword` —— 重置口令。
///
/// 🔴 官方表单字段是 `password`(`views/permission/user/ResetPassword.vue`),
/// 这里额外兼容 `newPassword`(部分版本的 DTO 用它)。
/// 🔴 **官方 v7 的字段是 `userPassword` / `validatePassword`,且值已经是 md5**
/// (`UserResetPasswordForm` 注释:`新密码,需要 MD5 加密后传输`;
/// 前端 `views/permission/user/ResetPassword.vue` 用 `encryptByMd5` 后再提交)。
/// ⇒ `userPassword` **原样落库**,绝不能再哈希一次(否则存成 md5(md5),用户永远登不上)。
/// 🔴 兼容旧调用 `password` / `newPassword`:值是 32 位 hex 视为 md5,否则按明文 md5。
/// 🔴 官方改密后会 `logoutUser` ⇒ 本仓同样吊销该用户的全部会话。
pub async fn user_reset_password(
State(state): State<AppState>,
headers: HeaderMap,
@@ -695,16 +699,22 @@ pub async fn user_reset_password(
Ok(_) => return fail(code::FAIL, "请求参数格式错误"),
Err(resp) => return resp,
};
let plain = obj
.get("password")
let raw = obj
.get("userPassword")
.or_else(|| obj.get("password"))
.or_else(|| obj.get("newPassword"))
.and_then(Value::as_str)
.unwrap_or_default()
.to_string();
if plain.is_empty() {
.map(str::trim)
.unwrap_or_default();
if raw.is_empty() {
return fail(code::FAIL, "口令不能为空");
}
let values = [Some(id), Some(md5_hex(&plain))];
let stored = if is_md5_hex(raw) {
raw.to_ascii_lowercase()
} else {
md5_hex(raw)
};
let values = [Some(id.clone()), Some(stored)];
if let Err(e) = state
.db
.exec_params(
@@ -716,9 +726,16 @@ pub async fn user_reset_password(
{
return db_error(e, "重置口令");
}
// 官方 `UserController.modifyPassword`:改密后强制该用户重新登录。
state.sessions.revoke_user_ids(&[id]);
ok(Value::Null)
}
/// 32 位 hex ⇒ 视为**已经是 md5 密文**(官方前端提交的就是这种形状)。
fn is_md5_hex(s: &str) -> bool {
s.len() == 32 && s.chars().all(|c| c.is_ascii_hexdigit())
}
/// `PUT /api/permission/Users/{id}/Actions/unlock` —— 解除锁定。
pub async fn user_unlock(
State(state): State<AppState>,
+11 -1
View File
@@ -13672,15 +13672,25 @@ pub async fn module_data_authorize_link_info(
/// 表名获取字段(官方 `GET /{linkId}/Tables/{tableName}/Fields/{menuType}/{dataType}` ⇒ `PageListVO<DbFieldVO>`)。
/// 🔴 依赖 dbTableService.getFieldList(数据库内省)⇒ 本仓无该能力,返回空 PageListVO。
///
/// 🔴 **路径参数一律按 `String` 接**:用 `i64` 接时,非法值会被 axum 的 `Path`
/// 反序列化直接拒成**纯文本 400**(`Invalid URL: Cannot parse value at index 2`),
/// 不走 `ActionResult` 信封 ⇒ 违反「所有响应都是信封」的约定。
/// ⇒ 自己解析,非法就返信封 400。
pub async fn module_data_authorize_link_table_fields(
State(state): State<AppState>,
headers: HeaderMap,
Path((_link_id, _table_name, _menu_type, _data_type)): Path<(String, String, i64, i64)>,
Path((_link_id, _table_name, menu_type, data_type)): Path<(String, String, String, String)>,
raw: RawQuery,
) -> Json<ActionResult> {
if let Err(resp) = guard_any(&state, &headers, &[EN_PERMISSION_RESOURCE, EN_APP_RESOURCE]).await {
return resp;
}
if !menu_type.chars().all(|c| c.is_ascii_digit())
|| !data_type.chars().all(|c| c.is_ascii_digit())
{
return fail(code::FAIL, "参数格式错误");
}
let paging = Paging::of(&raw);
ok(page_list(paging.current_page, paging.page_size, 0, vec![]))
}
+2 -1
View File
@@ -401,7 +401,8 @@ async fn capability_missing_core_endpoints_fail_explicitly() {
let (port, token) = boot().await;
let cases: Vec<(&str, &str, Option<&str>)> = vec![
("POST", "/api/oauth/updatePasswordMessage", None),
// 🔴 `updatePasswordMessage` **不在这里**:它虽是「能力缺失」,但官方前端
// `layouts/header/index.vue:74` 每页无条件调用且不 catch ⇒ 只能 200(见 `verify_fixes_it`)。
("POST", "/api/oauth/Login/saas", Some("{}")),
("GET", "/api/oauth/mobilecode/saas?mobile=13800000000", None),
("POST", "/api/oauth/apply/saas", Some("{}")),
+317
View File
@@ -0,0 +1,317 @@
//! 2026-11-02 验证发现的缺陷 —— 回归测试。
//!
//! 每条测试对应 `docs/verify-report-2026-11-02.md` 里的一个编号:
//! - `reset_password_*` ⇒ P0-1(官方 v7 字段 `userPassword` 已是 md5,不能再哈希)
//! - `online_log_*` / `share_selector_*` / `monitor_record_*` ⇒ P0-2(count SQL 与参数必须对齐)
//! - `update_password_message_*` ⇒ P1-1(官方前端每页无条件调用且不 catch)
//! - `authorize_link_fields_*` ⇒ P3-1(非法路径参数必须是信封 400,不是纯文本)
use std::path::PathBuf;
use std::sync::Arc;
use serde_json::{json, Value};
use ssw_platform::platform::db::Db;
use ssw_platform::platform::seed::first_seed;
use ssw_platform::platform::session::{SessionStore, TicketStore};
use ssw_platform::platform::state::AppState;
use ssw_platform::routes::build_app;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio::sync::{Mutex, OnceCell};
static DB: OnceCell<Db> = OnceCell::const_new();
static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
ssw_platform::bootstrap::ensure_schema_all(&db)
.await
.expect("ensure_schema_all 失败");
ssw_platform::bootstrap::ensure_base(&db)
.await
.expect("ensure_base 失败");
first_seed(&db, "123456").await.expect("first_seed 失败");
db
})
.await
}
async fn serve(state: AppState) -> u16 {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("绑定失败");
let port = listener.local_addr().expect("取本地地址失败").port();
let server = tokio::spawn(async move {
let _ = axum::serve(listener, build_app(state)).await;
});
tokio::task::yield_now().await;
std::mem::forget(server);
port
}
fn new_state(db: &Db) -> AppState {
AppState {
config: Arc::new(ssw_platform::platform::config::Config::from_env(PathBuf::from(
"/tmp/ssw-platform-verify-fixes-it",
))),
db: Arc::new(db.clone()),
sessions: Arc::new(SessionStore::default()),
tickets: Arc::new(TicketStore::default()),
}
}
async fn raw_call(
port: u16,
method: &str,
path: &str,
token: &str,
body: Option<&str>,
) -> (u16, String) {
let mut stream = TcpStream::connect(("127.0.0.1", port))
.await
.expect("连接失败");
let payload = body.unwrap_or("");
let req = format!(
"{method} {path} HTTP/1.1\r\n\
Host: 127.0.0.1\r\n\
Vue-Version: 3\r\n\
App-Code: mainSystem\r\n\
Authorization: {token}\r\n\
Content-Type: application/json\r\n\
Content-Length: {}\r\n\
Connection: close\r\n\r\n{payload}",
payload.len()
);
stream
.write_all(req.as_bytes())
.await
.expect("写请求失败");
let mut buf = Vec::new();
tokio::time::timeout(
std::time::Duration::from_secs(15),
stream.read_to_end(&mut buf),
)
.await
.expect("读响应超时")
.expect("读响应失败");
let text = String::from_utf8_lossy(&buf).to_string();
let (head, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔");
let status = head
.split_whitespace()
.nth(1)
.and_then(|s| s.parse::<u16>().ok())
.unwrap_or(0);
(status, body.trim().to_string())
}
async fn call(port: u16, method: &str, path: &str, token: &str, body: Option<&str>) -> Value {
let (_, body) = raw_call(port, method, path, token, body).await;
serde_json::from_str(&body).unwrap_or(Value::Null)
}
async fn login_as(port: u16, account: &str, plain: &str) -> Value {
let enc = ssw_platform::platform::cipher::encrypt_password(plain);
let payload = format!("account={account}&password={enc}");
let mut stream = TcpStream::connect(("127.0.0.1", port))
.await
.expect("连接失败");
let req = format!(
"POST /api/oauth/Login HTTP/1.1\r\n\
Host: 127.0.0.1\r\n\
Vue-Version: 3\r\n\
App-Code: mainSystem\r\n\
Content-Type: application/x-www-form-urlencoded\r\n\
Content-Length: {}\r\n\
Connection: close\r\n\r\n{payload}",
payload.len()
);
stream
.write_all(req.as_bytes())
.await
.expect("写请求失败");
let mut buf = Vec::new();
tokio::time::timeout(
std::time::Duration::from_secs(15),
stream.read_to_end(&mut buf),
)
.await
.expect("读响应超时")
.expect("读响应失败");
let text = String::from_utf8_lossy(&buf).to_string();
let (_, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔");
serde_json::from_str(body.trim()).unwrap_or(Value::Null)
}
async fn boot() -> (u16, String) {
let state = new_state(db().await);
let port = serve(state).await;
let v = login_as(port, "admin", "123456").await;
let token = v["data"]["token"].as_str().expect("登录必须返 token").to_string();
(port, token)
}
/// 建一个测试用户,返回 id。
async fn create_user(port: u16, token: &str, account: &str) -> String {
let v = call(
port,
"POST",
"/api/permission/Users",
token,
Some(&json!({"account": account, "realName": account, "enabledMark": 1, "gender": "1"}).to_string()),
)
.await;
assert_eq!(v["code"], 200, "建用户失败: {v}");
v["data"]["id"].as_str().expect("必须有 id").to_string()
}
/// P0-1:官方 v7 的 `userPassword` **已经是 md5**,必须原样落库(不能再哈希)。
#[tokio::test]
async fn reset_password_accepts_official_user_password_md5() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
let id = create_user(port, &token, "verify_official_pwd").await;
let md5 = ssw_platform::platform::cipher::md5_hex("newpass123");
let body = json!({
"id": id,
"userPassword": md5,
"validatePassword": md5,
})
.to_string();
let v = call(
port,
"POST",
&format!("/api/permission/Users/{id}/Actions/ResetPassword"),
&token,
Some(&body),
)
.await;
assert_eq!(v["code"], 200, "官方字段必须被接受: {v}");
let login = login_as(port, "verify_official_pwd", "newpass123").await;
assert_eq!(login["code"], 200, "重置后必须能用新口令登录: {login}");
}
/// P0-1:旧的 `password` 字段仍可用(明文 → 后端 md5)。
#[tokio::test]
async fn reset_password_accepts_plaintext_legacy_field() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
let id = create_user(port, &token, "verify_legacy_pwd").await;
let v = call(
port,
"POST",
&format!("/api/permission/Users/{id}/Actions/ResetPassword"),
&token,
Some(&json!({"password": "abcdef"}).to_string()),
)
.await;
assert_eq!(v["code"], 200, "旧字段必须仍可用: {v}");
let login = login_as(port, "verify_legacy_pwd", "abcdef").await;
assert_eq!(login["code"], 200, "旧字段重置后必须能登录: {login}");
}
/// P0-2:`modelId` 为空时,count SQL 没有 `$1`,不能再传参数(否则 500)。
#[tokio::test]
async fn online_log_works_with_and_without_model_filter() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
let all = call(port, "GET", "/api/visualdev/OnlineLog", &token, None).await;
assert_eq!(all["code"], 200, "无 modelId 必须 200: {all}");
assert!(all["data"]["list"].is_array(), "必须是 PageListVO: {all}");
let filtered = call(
port,
"GET",
"/api/visualdev/OnlineLog?modelId=abc",
&token,
None,
)
.await;
assert_eq!(filtered["code"], 200, "带 modelId 必须 200: {filtered}");
}
/// P0-2:跨应用下拉的 SQL 没有占位符,参数数组也必须为空。
#[tokio::test]
async fn share_selector_returns_two_fixed_categories() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
let v = call(port, "GET", "/api/visualdev/share/Selector", &token, None).await;
assert_eq!(v["code"], 200, "必须 200: {v}");
assert_eq!(v["data"]["list"][0]["id"], "category1");
assert_eq!(v["data"]["list"][1]["id"], "category2");
}
/// P0-2:`RecordList` 必须按 monitorId 过滤(既修 500,也防串数据)。
#[tokio::test]
async fn monitor_record_list_is_scoped_to_monitor() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
db()
.await
.exec(
"INSERT INTO base_msg_record (f_id, f_monitor_id, f_status, f_send_time, f_delete_mark, f_tenant_id) \
VALUES ('verify-rec-1','monitor-A',1,now(),0,'0'), \
('verify-rec-2','monitor-B',1,now(),0,'0')",
)
.await
.expect("插消息记录失败");
let v = call(
port,
"GET",
"/api/message/Monitor/monitor-A/RecordList",
&token,
None,
)
.await;
assert_eq!(v["code"], 200, "必须 200: {v}");
assert_eq!(v["data"]["pagination"]["total"], 1, "只能返回本监控的记录: {v}");
assert_eq!(v["data"]["list"][0]["id"], "verify-rec-1");
}
/// P1-1:官方前端每页无条件调用且不 catch ⇒ 不能再返 400。
#[tokio::test]
async fn update_password_message_is_non_blocking() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
let v = call(port, "POST", "/api/oauth/updatePasswordMessage", &token, None).await;
assert_eq!(v["code"], 200, "必须 200(否则官方前端每页抛未捕获异常): {v}");
assert_eq!(v["data"], Value::Null);
assert!(
v["msg"].as_str().unwrap_or_default().contains("跳过"),
"msg 必须说清已跳过: {v}"
);
}
/// P3-1:非法路径参数必须走信封(HTTP 200 + code=400),不能吐纯文本 400。
#[tokio::test]
async fn authorize_link_fields_bad_params_stay_enveloped() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
let (status, body) = raw_call(
port,
"GET",
"/api/system/ModuleDataAuthorizeLink/x/Tables/base_user/Fields/not-a-number/1",
&token,
None,
)
.await;
assert_eq!(status, 200, "必须是信封响应(HTTP 200): {status} {body}");
let v: Value = serde_json::from_str(&body).unwrap_or(Value::Null);
assert_eq!(v["code"], 400, "必须是信封 400: {v}");
// 合法参数仍然返回空 PageListVO
let ok = call(
port,
"GET",
"/api/system/ModuleDataAuthorizeLink/x/Tables/base_user/Fields/1/2",
&token,
None,
)
.await;
assert_eq!(ok["code"], 200);
assert!(ok["data"]["list"].is_array());
}