diff --git a/Cargo.lock b/Cargo.lock index c7cb2b6..11071e7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,6 +2,17 @@ # It is not intended for manual editing. version = 4 +[[package]] +name = "aes" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0" +dependencies = [ + "cfg-if", + "cipher", + "cpufeatures 0.2.17", +] + [[package]] name = "android_system_properties" version = "0.1.6" @@ -93,6 +104,15 @@ version = "2.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06" +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + [[package]] name = "block-buffer" version = "0.12.1" @@ -102,6 +122,15 @@ dependencies = [ "hybrid-array", ] +[[package]] +name = "block-padding" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93" +dependencies = [ + "generic-array", +] + [[package]] name = "bumpalo" version = "3.20.3" @@ -149,7 +178,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06" dependencies = [ "cfg-if", - "cpufeatures", + "cpufeatures 0.3.1", "rand_core 0.10.1", ] @@ -164,6 +193,16 @@ dependencies = [ "windows-link", ] +[[package]] +name = "cipher" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad" +dependencies = [ + "crypto-common 0.1.7", + "inout", +] + [[package]] name = "cmov" version = "0.5.4" @@ -182,6 +221,15 @@ version = "0.8.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" +[[package]] +name = "cpufeatures" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280" +dependencies = [ + "libc", +] + [[package]] name = "cpufeatures" version = "0.3.1" @@ -191,6 +239,16 @@ dependencies = [ "libc", ] +[[package]] +name = "crypto-common" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" +dependencies = [ + "generic-array", + "typenum", +] + [[package]] name = "crypto-common" version = "0.2.2" @@ -209,15 +267,25 @@ dependencies = [ "cmov", ] +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer 0.10.4", + "crypto-common 0.1.7", +] + [[package]] name = "digest" version = "0.11.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2" dependencies = [ - "block-buffer", + "block-buffer 0.12.1", "const-oid", - "crypto-common", + "crypto-common 0.2.2", "ctutils", ] @@ -232,6 +300,15 @@ dependencies = [ "syn 3.0.9", ] +[[package]] +name = "ecb" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a8bfa975b1aec2145850fcaa1c6fe269a16578c44705a532ae3edc92b8881c7" +dependencies = [ + "cipher", +] + [[package]] name = "errno" version = "0.3.14" @@ -361,6 +438,16 @@ dependencies = [ "slab", ] +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", +] + [[package]] name = "getrandom" version = "0.2.17" @@ -400,7 +487,7 @@ version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6303bc9732ae41b04cb554b844a762b4115a61bfaa81e3e83050991eeb56863f" dependencies = [ - "digest", + "digest 0.11.3", ] [[package]] @@ -651,6 +738,16 @@ dependencies = [ "icu_properties", ] +[[package]] +name = "inout" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01" +dependencies = [ + "block-padding", + "generic-array", +] + [[package]] name = "ipnet" version = "2.12.2" @@ -719,6 +816,16 @@ version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3" +[[package]] +name = "md-5" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf" +dependencies = [ + "cfg-if", + "digest 0.10.7", +] + [[package]] name = "md-5" version = "0.11.0" @@ -726,7 +833,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "69b6441f590336821bb897fb28fc622898ccceb1d6cea3fde5ea86b090c4de98" dependencies = [ "cfg-if", - "digest", + "digest 0.11.3", ] [[package]] @@ -886,7 +993,7 @@ dependencies = [ "bytes", "fallible-iterator", "hmac", - "md-5", + "md-5 0.11.0", "memchr", "rand 0.10.3", "sha2", @@ -1273,8 +1380,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "47d7069beb7d6ac7b9acd1039986e73443f24234f41074da099d6f994ac9ad19" dependencies = [ "cfg-if", - "cpufeatures", - "digest", + "cpufeatures 0.3.1", + "digest 0.11.3", ] [[package]] @@ -1395,15 +1502,19 @@ dependencies = [ name = "tdc-connector" version = "0.1.0" dependencies = [ + "aes", "axum", "chrono", + "ecb", "hex", "http-body-util", + "md-5 0.10.6", "pglite-rs", "rand 0.8.8", "reqwest", "serde", "serde_json", + "serde_urlencoded", "tokio", "tower", "tower-http", @@ -1647,6 +1758,12 @@ version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + [[package]] name = "want" version = "0.3.2" diff --git a/Cargo.toml b/Cargo.toml index d3e14bd..d551768 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -24,6 +24,19 @@ reqwest = { version = "0.12", default-features = false, features = ["json", "rus rand = "0.8" hex = "0.4" +# 登录口令加解密(与上游前端 cipher.ts 对齐):AES-256-ECB + MD5 +# 🔴 版本组合自洽,别混用:aes 0.8 / ecb 0.1 都依赖 cipher 0.4 家族; +# aes 0.9 / ecb 0.2 是 cipher 0.5 家族,两套泛型不通用。 +# 🔴 md-5 钉 0.10(crate 名 `md5`,`use md5::{Digest, Md5};`);0.11 的 API 不同。 +aes = "0.8" +ecb = "0.1" +md-5 = "0.10" +# 登录表单解析(application/x-www-form-urlencoded)。 +# ⚠️ axum 0.8.9 的 `Form` 只实现 `FromRequest`、不实现 `OptionalFromRequest` +# ⇒ `Option>` 编译不过 ⇒ 改为「取原始 body + serde_urlencoded 自己解析」。 +# `serde_urlencoded 0.7.1` 已在 `Cargo.lock` 里(axum 的传递依赖)⇒ 不引入新下载。 +serde_urlencoded = "0.7" + # 内嵌 PostgreSQL(进程内原生编译,非 WASM):承载全部 tdc_* 业务数据 # 包名 pglite-rs,import 为 pglite。无需扩展时不用 build.rs/export_dynamic。 pglite-rs = "0.2" diff --git a/README.md b/README.md index 0312822..b54e383 100644 --- a/README.md +++ b/README.md @@ -15,8 +15,13 @@ > 红线:原 TDC 与 TDS **只走 HTTP 契约、不编译期耦合**。 > 本实现**不代理** TDS(TDS 侧出向客户端属后续任务)。 -> 🔴 上游前端登录走 JNPF 门户账号(`POST /api/oauth/Login`)——**该端点本仓尚未实现** -> (属后续任务)⇒ 现在登录请用 `/api/ssw/tdc/Auth/Login`。 +> 🔴 上游前端登录走 JNPF 门户账号(`POST /api/oauth/Login`)——**本仓已实现** +> (JNPF 兼容面:口令用上游 `cipher.ts` 的 **AES-256-ECB 密文 hex** 传输, +> `grant_type=password`;`grant_type=maxkey` 如实报业务失败,**不伪装成功**)。 +> 但**不引入 j7** ⇒ 用本连接器自己的**本地账号库** `data/accounts.json` 顶替 +> (口令只存 `md5(明文)`,**永不回显**);首次启动自动引导一个管理员账号 +> **`admin` / `admin`**(⚠️ **本地调试默认值**,对外部署前必须改掉)。 +> 连接器身份登录(`/api/ssw/tdc/Auth/Login`)也仍然可用。 ## 运行 @@ -71,6 +76,13 @@ sccache 0.18 经 `~/.cargo/config.toml` 的 `[build] rustc-wrapper` + `[env] SCC | GET | `/api/ssw/tdc/Auth/Me` | 当前身份视图(**去敏**:不含私钥/一次性密钥) | | GET | `/api/ssw/tdc/Auth/Spaces` | 环境空间列表 | | GET | `/api/ssw/tdc/Auth/SsoConfig` | SSO 配置(上游前端登录页用) | +| POST | `/api/oauth/Login` | **JNPF 兼容登录**(`application/x-www-form-urlencoded`:`account` / `password`(**密文 hex**) / `grant_type=password`)| +| GET | `/api/permission/Users` | 用户管理 · 列表(分页 + 关键字;**仅管理员**)| +| POST | `/api/permission/Users` | 用户管理 · 新建(**仅管理员**;初始口令 `123456`)| +| PUT | `/api/permission/Users/{id}` | 用户管理 · 改资料(**仅管理员**)| +| DELETE | `/api/permission/Users/{id}` | 用户管理 · 删账号(**仅管理员**;管理员账号不可删)| +| POST | `/api/permission/Users/{id}/Actions/ResetPassword` | 重设口令(收 `md5(明文)`;**仅管理员**)| +| PUT | `/api/permission/Users/{id}/Actions/State` | 启用 / 禁用(`enabledMark`;**仅管理员**)| | GET / POST | `/api/ssw/tdc/{Entity}` | 18 个实体的列表 / 新建 | | GET | `/api/ssw/tdc/{Entity}/All` | 不分页全量 | | GET / PUT / DELETE | `/api/ssw/tdc/{Entity}/{id}` | 详情 / 修改 / 逻辑删除 | diff --git a/src/account.rs b/src/account.rs new file mode 100644 index 0000000..10f926d --- /dev/null +++ b/src/account.rs @@ -0,0 +1,377 @@ +//! 本连接器的**本地账号库**(上游叫「连接器自己的 j7」)。 +//! +//! ⚠️ 上游账号表住在 JNPF 平台库(j7),本仓不引入 j7 ⇒ 改用**本机 JSON 文件** +//! `data/accounts.json`。刻意**不建 `tdc_*` 表** ⇒ `schema/migrate.sql` 保持上游 30 表 +//! **逐字节一致**,`/api/health` 的 `tables` 恒为 30。 +//! +//! 口令只存 `md5(明文)`(与上游 JNPF 同口径:`ResetPassword` 收 `md5(明文)`)。 + +use std::path::{Path, PathBuf}; +use std::sync::Mutex; +use std::time::{SystemTime, UNIX_EPOCH}; + +use serde::{Deserialize, Serialize}; + +use crate::cipher::md5_hex; + +/// 新建账号的初始口令(上游取 `base_sys_config.newUserDefaultPassword`,本端固定值)。 +pub const DEFAULT_NEW_USER_PASSWORD: &str = "123456"; + +/// 首次启动引导的管理员账号名(上游前端登录页默认填 `admin`)。 +pub const BOOTSTRAP_ADMIN_ACCOUNT: &str = "admin"; + +/// 首次启动引导的管理员口令。⚠️ **本地调试默认值**,README 里必须写明。 +pub const BOOTSTRAP_ADMIN_PASSWORD: &str = "admin"; + +/// 落盘失败 ⇒ 业务错误文案(写路径的 `Result<_, String>` 统一用它)。 +/// +/// 🔴 落盘失败**必须**当业务失败抛出去(账号改了却没存下来 ⇒ 内存与磁盘不一致 ⇒ 更糟), +/// 不能吞掉。 +fn save_err(e: std::io::Error) -> String { + format!("保存账号库失败: {}", e) +} + +/// 常量时间比较(长度不同直接 false)。 +pub fn constant_time_eq(a: &str, b: &str) -> bool { + let (a, b) = (a.as_bytes(), b.as_bytes()); + if a.len() != b.len() { + return false; + } + let mut diff = 0u8; + for (x, y) in a.iter().zip(b.iter()) { + diff |= x ^ y; + } + diff == 0 +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct Account { + pub id: String, + pub account: String, + pub real_name: String, + pub gender: i64, + #[serde(default)] + pub mobile_phone: Option, + #[serde(default)] + pub description: Option, + /// 1 = 启用,0 = 禁用(上游 `enabledMark`)。 + pub enabled_mark: i64, + /// 是否管理员(上游 `f_is_administrator`)⇒ 能不能管 `/api/permission/Users*`。 + pub administrator: bool, + /// `md5(明文)`(32 个 hex 字符)。**永不回显**。 + pub password_md5: String, + pub creator_time: String, +} + +#[derive(Debug, Clone, Default, Serialize, Deserialize)] +pub struct AccountFile { + #[serde(default)] + pub accounts: Vec, +} + +/// 账号库:JSON 文件 + 进程内互斥锁。 +pub struct AccountStore { + /// `None` = 内存库(不落盘)⇒ 早期任务与单测用 `AccountStore::empty()`。 + path: Option, + inner: Mutex, +} + +impl AccountStore { + /// 打开(或创建)账号文件;**库里没有账号时引导一个 `admin`**。 + pub fn open(path: &Path) -> std::io::Result { + let mut file: AccountFile = match std::fs::read(path) { + Ok(bytes) => serde_json::from_slice(&bytes).unwrap_or_default(), + Err(_) => AccountFile::default(), + }; + if file.accounts.is_empty() { + file.accounts.push(Account { + id: crate::ids::next_id(), + account: BOOTSTRAP_ADMIN_ACCOUNT.to_string(), + real_name: "管理员".to_string(), + gender: 1, + mobile_phone: None, + description: Some("首次启动引导".to_string()), + enabled_mark: 1, + administrator: true, + password_md5: md5_hex(BOOTSTRAP_ADMIN_PASSWORD), + creator_time: now_iso(), + }); + } + let store = Self { + path: Some(path.to_path_buf()), + inner: Mutex::new(file), + }; + store.save()?; + Ok(store) + } + + /// 内存库(不落盘)。 + pub fn empty() -> Self { + Self { + path: None, + inner: Mutex::new(AccountFile::default()), + } + } + + pub fn list(&self) -> Vec { + self.inner.lock().expect("账号库锁中毒").accounts.clone() + } + + pub fn find(&self, id: &str) -> Option { + self.list().into_iter().find(|a| a.id == id) + } + + pub fn find_by_account(&self, account: &str) -> Option { + self.list().into_iter().find(|a| a.account == account) + } + + /// 新建账号;账号名重复 ⇒ `Err("账号已存在")`。初始口令固定为 `DEFAULT_NEW_USER_PASSWORD` + /// (上游口径:新建的初始口令**不取请求里的 password**,而是系统默认口令)。 + pub fn create( + &self, + account: &str, + real_name: &str, + gender: i64, + mobile_phone: Option, + description: Option, + ) -> Result { + let account = account.trim(); + if account.is_empty() { + return Err("账号必填".to_string()); + } + let mut guard = self.inner.lock().expect("账号库锁中毒"); + if guard.accounts.iter().any(|a| a.account == account) { + return Err("账号已存在".to_string()); + } + let row = Account { + id: crate::ids::next_id(), + account: account.to_string(), + real_name: real_name.trim().to_string(), + gender, + mobile_phone, + description, + enabled_mark: 1, + administrator: false, + password_md5: md5_hex(DEFAULT_NEW_USER_PASSWORD), + creator_time: now_iso(), + }; + guard.accounts.push(row.clone()); + self.save_locked(&guard).map_err(save_err)?; + Ok(row) + } + + /// 更新资料(**不动口令**)。 + pub fn update( + &self, + id: &str, + real_name: &str, + gender: i64, + mobile_phone: Option, + description: Option, + ) -> Result { + let mut guard = self.inner.lock().expect("账号库锁中毒"); + let row = guard + .accounts + .iter_mut() + .find(|a| a.id == id) + .ok_or_else(|| "账号不存在".to_string())?; + row.real_name = real_name.trim().to_string(); + row.gender = gender; + row.mobile_phone = mobile_phone; + row.description = description; + let out = row.clone(); + self.save_locked(&guard).map_err(save_err)?; + Ok(out) + } + + /// 删除(**管理员账号不许删**)。 + pub fn remove(&self, id: &str) -> Result<(), String> { + let mut guard = self.inner.lock().expect("账号库锁中毒"); + let row = guard + .accounts + .iter() + .find(|a| a.id == id) + .ok_or_else(|| "账号不存在".to_string())?; + if row.administrator { + return Err("管理员账号不可删除".to_string()); + } + guard.accounts.retain(|a| a.id != id); + self.save_locked(&guard).map_err(save_err)?; + Ok(()) + } + + /// 启用 / 禁用。 + pub fn set_enabled(&self, id: &str, enabled_mark: i64) -> Result { + let mut guard = self.inner.lock().expect("账号库锁中毒"); + let row = guard + .accounts + .iter_mut() + .find(|a| a.id == id) + .ok_or_else(|| "账号不存在".to_string())?; + row.enabled_mark = if enabled_mark == 0 { 0 } else { 1 }; + let out = row.clone(); + self.save_locked(&guard).map_err(save_err)?; + Ok(out) + } + + /// 重设口令(传入的是 `md5(明文)`,32 个 hex 字符)。 + pub fn reset_password(&self, id: &str, password_md5: &str) -> Result { + let mut guard = self.inner.lock().expect("账号库锁中毒"); + let row = guard + .accounts + .iter_mut() + .find(|a| a.id == id) + .ok_or_else(|| "账号不存在".to_string())?; + row.password_md5 = password_md5.to_string(); + let out = row.clone(); + self.save_locked(&guard).map_err(save_err)?; + Ok(out) + } +} + +/// 落盘(**先写临时文件再 rename**,避免写坏文件;`path == None` 时是空操作)。 +impl AccountStore { + fn save(&self) -> std::io::Result<()> { + let guard = self.inner.lock().expect("账号库锁中毒"); + self.save_locked(&guard) + } + + fn save_locked(&self, file: &AccountFile) -> std::io::Result<()> { + let Some(path) = &self.path else { + return Ok(()); + }; + if let Some(parent) = path.parent() { + std::fs::create_dir_all(parent)?; + } + let tmp = path.with_extension("json.tmp"); + std::fs::write(&tmp, serde_json::to_vec_pretty(file).unwrap_or_default())?; + std::fs::rename(&tmp, path)?; + Ok(()) + } +} + +/// 当前 UTC 时间(`YYYY-MM-DD HH:MM:SS`)。 +pub fn now_iso() -> String { + let secs = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|d| d.as_secs() as i64) + .unwrap_or(0); + let days = secs.div_euclid(86_400); + let rem = secs.rem_euclid(86_400); + let (y, m, d) = civil_from_days(days); + format!( + "{y:04}-{m:02}-{d:02} {:02}:{:02}:{:02}", + rem / 3600, + (rem % 3600) / 60, + rem % 60 + ) +} + +/// 天元纪日 → 公历年月日(Hinnant 算法,闰年规则完整)。 +fn civil_from_days(z: i64) -> (i64, u32, u32) { + let z = z + 719_468; + // 🔴 `if/else` 表达式必须**加括号**再参与运算 —— 否则 `let era = if … {} / 146_097;` + // 的解析含义依赖 Rust 对「块表达式后接运算符」的贪婪规则,脆弱且易被误读。 + let era = (if z >= 0 { z } else { z - 146_096 }) / 146_097; + let doe = (z - era * 146_097) as u64; + let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365; + let y = yoe as i64 + era * 400; + let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); + let mp = (5 * doy + 2) / 153; + let d = (doy - (153 * mp + 2) / 5 + 1) as u32; + let m = if mp < 10 { mp + 3 } else { mp - 9 } as u32; + (if m <= 2 { y + 1 } else { y }, m, d) +} + +#[cfg(test)] +mod tests { + use super::*; + + /// 账号文件路径(**不**清理,用于读回)。 + fn tmp_path(name: &str) -> PathBuf { + PathBuf::from("target").join(format!("test-accounts-{name}.json")) + } + + /// 每次用例都用**干净**的账号文件 —— + /// 否则第二次 `cargo test` 会因「bob 已存在」而红(账号库是**持久**的 JSON 文件)。 + fn fresh_path(name: &str) -> PathBuf { + let p = tmp_path(name); + let _ = std::fs::remove_file(&p); + let _ = std::fs::remove_file(p.with_extension("json.tmp")); + p + } + + #[test] + fn bootstraps_an_admin_account_on_first_open() { + let store = AccountStore::open(&fresh_path("bootstrap")).expect("打开账号库失败"); + let admin = store.find_by_account("admin").expect("应有 admin 账号"); + assert!(admin.administrator); + assert_eq!(admin.enabled_mark, 1); + assert_eq!(admin.password_md5, md5_hex("admin")); + // 🔴 口令只存 md5:新建一个默认口令账号后,文件里出现的是 **md5 hex** 而不是明文。 + // (⚠️ 不能用 `!raw.contains("\"admin\"")` 判 —— 账号**名**就是 "admin", + // JSON 里必有 `"account": "admin"` ⇒ 那条断言恒假。) + let created = store + .create("bob", "鲍勃", 1, None, None) + .expect("建号失败"); + assert_eq!(created.password_md5, md5_hex(DEFAULT_NEW_USER_PASSWORD)); + let raw = std::fs::read_to_string(tmp_path("bootstrap")).unwrap(); + assert!( + !raw.contains(&format!( + "\"password_md5\": \"{}\"", + DEFAULT_NEW_USER_PASSWORD + )), + "文件里不得出现明文口令:{}", + raw + ); + assert!( + raw.contains(&format!( + "\"password_md5\": \"{}\"", + md5_hex(DEFAULT_NEW_USER_PASSWORD) + )), + "文件里应存 md5(明文)" + ); + } + + #[test] + fn create_update_and_reset_password() { + let store = AccountStore::open(&fresh_path("crud")).expect("打开账号库失败"); + let created = store + .create("bob", "鲍勃", 1, None, None) + .expect("建号失败"); + assert_eq!( + store.find_by_account("bob").unwrap().password_md5, + md5_hex(DEFAULT_NEW_USER_PASSWORD) + ); + assert!( + store.create("bob", "重复", 1, None, None).is_err(), + "账号名重复应报错" + ); + let updated = store + .update(&created.id, "鲍勃二世", 2, Some("13800000000".into()), None) + .unwrap(); + assert_eq!(updated.real_name, "鲍勃二世"); + store + .reset_password(&created.id, &md5_hex("newpass")) + .unwrap(); + assert_eq!( + store.find(&created.id).unwrap().password_md5, + md5_hex("newpass") + ); + assert!(store.remove(&created.id).is_ok()); + assert!(store.find(&created.id).is_none()); + } + + #[test] + fn administrator_cannot_be_removed() { + let store = AccountStore::open(&fresh_path("admin")).expect("打开账号库失败"); + let admin = store.find_by_account("admin").unwrap(); + assert!(store.remove(&admin.id).is_err()); + } + + #[test] + fn civil_from_days_matches_known_dates() { + assert_eq!(civil_from_days(0), (1970, 1, 1)); + assert_eq!(civil_from_days(20_750), (2026, 10, 24)); + } +} diff --git a/src/cipher.rs b/src/cipher.rs new file mode 100644 index 0000000..6666d09 --- /dev/null +++ b/src/cipher.rs @@ -0,0 +1,114 @@ +//! 登录口令的加解密 —— 与上游前端 `src/utils/cipher.ts` **逐字对齐**。 +//! +//! 上游算法(JNPF 前端约定): +//! 1. key = `md5(CIPHER_KEY)` 的**十六进制字符串的 UTF-8 字节**(32 字节 ⇒ AES-256) +//! 2. src = `md5(plain)` 的**十六进制字符串的 UTF-8 字节**(32 字节) +//! 3. AES-256-ECB + Pkcs7 ⇒ 48 字节密文 ⇒ hex 字符串 +//! +//! 🔴 **关键坑**:`CryptoJS.enc.Utf8.parse(md5(x))` 解析的是 **hex 字符串本身**(32 个 ASCII 字节), +//! 不是 md5 摘要的 16 个原始字节 —— 用原始字节会退化成 AES-128,密文长度也对不上(32 vs 48)。 +//! +//! 本仓的**登录面**只解密:上游前端把明文口令加密后送上来,服务端解出 `md5(明文)` +//! 再与账号库里存的 `md5(明文)` 逐字比较(口令明文永不落盘、永不外泄)。 + +use aes::cipher::{generic_array::GenericArray, BlockDecryptMut, BlockEncryptMut, KeyInit}; +use ecb::{Decryptor, Encryptor}; +use md5::{Digest, Md5}; + +type Aes256EcbEnc = Encryptor; +type Aes256EcbDec = Decryptor; + +/// 与上游前端 `CIPHER_KEY` 一致(上游注释:必须与 JNPF 前端 `.env` 的 `VITE_CIPHER_KEY` 完全一致)。 +pub const CIPHER_KEY: &str = "EY8WePvjM5GGwQzn"; + +/// MD5 的小写 hex(32 字符)。 +pub fn md5_hex(input: &str) -> String { + let mut hasher = Md5::new(); + hasher.update(input.as_bytes()); + hasher + .finalize() + .iter() + .map(|b| format!("{b:02x}")) + .collect() +} + +/// 密文 hex → **明文的 md5 hex**(32 个 ASCII 字符)。 +/// +/// 返回 `None` 的情形:hex 非法 / 长度不是 16 的倍数 / Pkcs7 填充不自洽 / 解出来不是 UTF-8。 +pub fn decrypt_login_password(cipher_hex: &str) -> Option { + let mut buf = hex::decode(cipher_hex.trim()).ok()?; + if buf.is_empty() || buf.len() % 16 != 0 { + return None; + } + let key = md5_hex(CIPHER_KEY); + // 🔴 `ecb` 0.1 只实现了 `BlockDecryptMut`(**原地**改块)⇒ 用 `decrypt_block_mut`。 + // `dec` 必须是 `mut`,否则 E0596。 + let mut dec = Aes256EcbDec::new(GenericArray::from_slice(key.as_bytes())); + for chunk in buf.chunks_mut(16) { + dec.decrypt_block_mut(GenericArray::from_mut_slice(chunk)); + } + // 去 Pkcs7 填充 + let pad = *buf.last()? as usize; + if pad == 0 || pad > 16 || pad > buf.len() { + return None; + } + if buf[buf.len() - pad..].iter().any(|b| *b as usize != pad) { + return None; + } + buf.truncate(buf.len() - pad); + String::from_utf8(buf).ok() +} + +/// 明文 → 密文 hex(与上游 `encryptPassword` 同义)。 +/// +/// 服务端本身只用解密;这个方向**只为测试**:让集成测试能造出上游前端送来的密文, +/// 且**不是自证自洽** —— 断言用的是上游仓库注释里的**原始向量**。 +pub fn encrypt_login_password(plain: &str) -> String { + let key = md5_hex(CIPHER_KEY); + let src = md5_hex(plain); + let mut buf = src.as_bytes().to_vec(); + let pad = 16 - buf.len() % 16; + buf.extend(std::iter::repeat_n(pad as u8, pad)); + // 🔴 `ecb` 0.1 只实现了 `BlockEncryptMut`(**原地**改块)⇒ 用 `encrypt_block_mut`。 + // `enc` 必须是 `mut`,否则 E0596。 + let mut enc = Aes256EcbEnc::new(GenericArray::from_slice(key.as_bytes())); + for chunk in buf.chunks_mut(16) { + enc.encrypt_block_mut(GenericArray::from_mut_slice(chunk)); + } + hex::encode(buf) +} + +#[cfg(test)] +mod tests { + use super::*; + + /// 上游 `src/utils/cipher.ts` 的**自检向量**(上游注释原文): + /// `encryptPassword('123456') === 'd4958348…cdc02b'` + const UPSTREAM_VECTOR: &str = "d4958348e22108119b3ef57b022c83f4bf857dd0b247eaab15b9a43d47ee3c503900f7135bf0de255bc33620c3cdc02b"; + + #[test] + fn md5_matches_known_values() { + assert_eq!(md5_hex("123456"), "e10adc3949ba59abbe56e057f20f883e"); + assert_eq!(md5_hex(CIPHER_KEY), "05b0175907a859751f57a04d5a5ee9ac"); + } + + #[test] + fn encrypt_reproduces_the_upstream_self_test_vector() { + assert_eq!(encrypt_login_password("123456"), UPSTREAM_VECTOR); + } + + #[test] + fn decrypts_the_upstream_self_test_vector() { + assert_eq!( + decrypt_login_password(UPSTREAM_VECTOR).as_deref(), + Some("e10adc3949ba59abbe56e057f20f883e") + ); + } + + #[test] + fn rejects_garbage() { + assert!(decrypt_login_password("not-hex").is_none()); + assert!(decrypt_login_password("00112233").is_none()); + assert!(decrypt_login_password("").is_none()); + } +} diff --git a/src/lib.rs b/src/lib.rs index 47125db..ed0b576 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -7,7 +7,9 @@ //! - 所有 DB 访问持 `state.db_lock`(PGlite 单 in-process backend)。 //! - 任意 SELECT 走 `db::query_json()`(row_to_json 包裹)。 +pub mod account; pub mod auth; +pub mod cipher; pub mod codec; pub mod config; pub mod crud; diff --git a/src/main.rs b/src/main.rs index 37cf358..f85d6c6 100644 --- a/src/main.rs +++ b/src/main.rs @@ -124,6 +124,15 @@ async fn main() { let state = state.with_bootstrap(bootstrap); + // 本地账号库(上游完整前端的 JNPF 兼容登录用):JSON 文件,不进数据库。 + // 🔴 挂在 `with_bootstrap` **之后**(`with_accounts` 只换 `accounts` 字段,其余保留)。 + // ⚠️ `data_dir` 已在上面定义(来自 `config.data_dir`)⇒ 这里**不重新定义**。 + let accounts = Arc::new( + tdc_connector::account::AccountStore::open(&data_dir.join("accounts.json")) + .expect("打开本地账号库失败"), + ); + let state = state.with_accounts(accounts); + let auth_state = AuthState { internal_token: config.internal_token.clone(), sessions: sessions.clone(), diff --git a/src/routes/account.rs b/src/routes/account.rs new file mode 100644 index 0000000..34743b7 --- /dev/null +++ b/src/routes/account.rs @@ -0,0 +1,365 @@ +//! 本地账号相关的对外端点: +//! · `POST /api/oauth/Login`(**上游完整前端登录链的第 ① 步**,JNPF 兼容面) +//! · `/api/permission/Users*`(「用户管理」页;上游复用 JNPF 的用户 CRUD) +//! +//! ⚠️ 业务失败一律 **HTTP 200 + body `code` != 200**(上游前端按 `body.code` 判成败)。 +//! 鉴权/授权失败是**另一种**形状(HTTP 401/403 + 裸三字段),见 `crate::auth::reject`。 + +use axum::extract::{Extension, Path, Query, State}; +use axum::response::{IntoResponse, Response}; +use axum::routing::{get, post, put}; +use axum::Router; +use serde::Deserialize; +use serde_json::{json, Value}; + +use crate::account::{constant_time_eq, Account}; +use crate::auth::Principal; +use crate::cipher::decrypt_login_password; +use crate::envelope::{ActionResult, Pagination}; +use crate::state::AppState; + +/// 登录表单(`application/x-www-form-urlencoded`)。 +#[derive(Debug, Deserialize)] +pub struct LoginForm { + pub account: String, + /// 上游前端送的是 **密文 hex**(`cipher.ts` 的 `encryptPassword`)。 + pub password: String, + /// ⚠️ **不加** `#[serde(rename_all = "camelCase")]`:camelCase 会把 `grant_type` + /// 改名成 `grantType`,而上游表单送的是 **`grant_type=password`** ⇒ 字段永远为 `None`。 + /// (`account` / `password` 是单词,camelCase 对它们无影响。) + #[serde(default, alias = "grantType")] + pub grant_type: Option, +} + +pub fn router() -> Router { + Router::new() + .route("/api/oauth/Login", post(login)) + .route("/api/permission/Users", get(list_users).post(create_user)) + .route( + "/api/permission/Users/{id}", + put(update_user).delete(remove_user), + ) + .route( + "/api/permission/Users/{id}/Actions/ResetPassword", + post(reset_password), + ) + .route("/api/permission/Users/{id}/Actions/State", put(set_state)) +} + +async fn login(State(state): State, body: axum::body::Bytes) -> Response { + // 🔴 axum 0.8.9:`Form` 只实现了 `FromRequest`,**没有** `OptionalFromRequest` + // ⇒ `Option>` **编译不过**(`axum-0.8.9/src/form.rs` 只有 + // `impl FromRequest for Form`)⇒ 自己取原始 body 解析。 + // `Bytes` 是 `FromRequest` ⇒ 任何 Content-Type 都能拿到 body ⇒ 解析失败也走业务信封。 + let form: LoginForm = match serde_urlencoded::from_bytes(&body) { + Ok(f) => f, + Err(_) => return ActionResult::fail("登录参数缺失").into_response(), + }; + // 🔴 MaxKey SSO:本仓**没有** MaxKey 服务器 ⇒ 如实报业务失败,**绝不伪装成功** + // (上游 `auth.ts` 的 `maxkeyLogin` 注释明确要求「失败如实抛出」)。 + if form.grant_type.as_deref() == Some("maxkey") { + return ActionResult::fail("MaxKey 统一认证未启用,请使用账号口令登录").into_response(); + } + let account = form.account.trim(); + let row = match state.accounts.find_by_account(account) { + Some(r) => r, + None => return ActionResult::fail("账号或密码错误").into_response(), + }; + if row.enabled_mark != 1 { + return ActionResult::fail("账号已被禁用").into_response(); + } + // 解出的是「明文的 md5 hex」⇒ 与账号库里存的 `md5(明文)` 逐字比较。 + let Some(plain_md5) = decrypt_login_password(&form.password) else { + return ActionResult::fail("账号或密码错误").into_response(); + }; + if !constant_time_eq(&plain_md5, &row.password_md5) { + return ActionResult::fail("账号或密码错误").into_response(); + } + let token = state.sessions.create_account(&row.id, &row.account); + // 🔴 `data.token` **不带** `bearer ` 前缀(上游前端自己补,见 `request.ts` 的 `setToken`)。 + ActionResult::ok(json!({ + "token": token, + "expiresIn": 7200, + "userInfo": { + "userName": row.account, + "realName": row.real_name, + "nickName": row.real_name, + }, + })) + .into_response() +} + +/// 账号的对外视图(**不含 `password_md5`**)。 +/// +/// 🔴 手工挑字段,**不**在 `Account` 上用 `#[serde(skip_serializing)]` +/// (那会让落盘 JSON 缺字段、回读失败)—— 落盘与外发是**两套形状**。 +fn account_view(a: &Account) -> Value { + json!({ + "id": a.id, + "account": a.account, + "realName": a.real_name, + "gender": a.gender, + "mobilePhone": a.mobile_phone, + "enabledMark": a.enabled_mark, + "creatorTime": a.creator_time, + "description": a.description, + }) +} + +/// 管理员闸门:连接器身份会话(`Principal::Session`)或**管理员账号**放行,其余 403。 +/// +/// 🔴 **刻意比上游严一档**:上游 `TdcAuthFilter` 的内部令牌通道(`X-Internal-Token`) +/// 与身份会话通道(`X-Auth-Token`)都**直接放行**、不过管理员门;本仓把 +/// **内部令牌也拒了**(内部令牌是服务端通道,不该被当成「管理员」)。 +/// 差异登记见 Task 12 报告 §4。 +/// +/// 🔴 **fail-closed**(对齐上游 `TdcConnectorAdminGuard`):账号查不到 ⇒ `false` ⇒ 403。 +#[allow(clippy::result_large_err)] +fn require_admin(state: &AppState, p: Option<&Extension>) -> Result<(), Response> { + match p.map(|e| &e.0) { + Some(Principal::Session { .. }) => Ok(()), + Some(Principal::Account { account_id, .. }) => { + let admin = state + .accounts + .find(account_id) + .map(|a| a.administrator) + .unwrap_or(false); + if admin { + Ok(()) + } else { + Err(crate::auth::reject( + axum::http::StatusCode::FORBIDDEN, + "仅管理员可管理连接器用户", + )) + } + } + // 内部令牌通道:**刻意**不过管理员门(见函数注释)⇒ 与上游的差异。 + Some(Principal::Internal { .. }) => Err(crate::auth::reject( + axum::http::StatusCode::FORBIDDEN, + "仅管理员可管理连接器用户", + )), + None => Err(crate::auth::reject( + axum::http::StatusCode::UNAUTHORIZED, + "内部接口凭证无效", + )), + } +} + +/// 列表的查询参数(上游前端发 `currentPage` / `pageSize` / `keyword`)。 +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct UserQuery { + #[serde(default)] + pub current_page: Option, + #[serde(default)] + pub page_size: Option, + #[serde(default)] + pub keyword: Option, +} + +async fn list_users( + State(state): State, + p: Option>, + Query(q): Query, +) -> Response { + if let Err(e) = require_admin(&state, p.as_ref()) { + return e; + } + let page = q.current_page.unwrap_or(1).max(1) as usize; + let size = q.page_size.unwrap_or(20).clamp(1, 500) as usize; + let keyword = q.keyword.unwrap_or_default().trim().to_lowercase(); + + let matched: Vec = state + .accounts + .list() + .iter() + .filter(|a| { + keyword.is_empty() + || a.account.to_lowercase().contains(&keyword) + || a.real_name.to_lowercase().contains(&keyword) + }) + .map(account_view) + .collect(); + let total = matched.len(); + // 🔴 `page` 来自客户端 ⇒ 用 `saturating_mul` 防溢出(超大 page 不该 panic)。 + let start = (page - 1).saturating_mul(size); + let list: Vec = matched.into_iter().skip(start).take(size).collect(); + // 🔴 `ActionResult::page` 的**确切签名**(`src/envelope.rs`,Task 2 定的): + // `page(list: Vec, pagination: Pagination) -> ActionResult` + // —— **不是**四个平铺参数。`Pagination` 是 `pub` 且字段 `current_page/page_size/total`。 + ActionResult::page( + list, + Pagination { + current_page: page as i64, + page_size: size as i64, + total: total as i64, + }, + ) + .into_response() +} + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct CreateUserBody { + /// 🔴 必填但**不**在反序列化阶段强制 ⇒ 缺失时走**业务信封**(HTTP 200 + code 400), + /// 而不是 axum 的 422 反序列化错误(那是另一种形状)。 + #[serde(default)] + pub account: String, + #[serde(default)] + pub real_name: Option, + #[serde(default)] + pub gender: Option, + #[serde(default)] + pub mobile_phone: Option, + #[serde(default)] + pub description: Option, +} + +async fn create_user( + State(state): State, + p: Option>, + body: Option>, +) -> Response { + if let Err(e) = require_admin(&state, p.as_ref()) { + return e; + } + let Some(body) = body else { + return ActionResult::fail("请求体缺失").into_response(); + }; + if body.account.trim().is_empty() { + return ActionResult::fail("账号必填").into_response(); + } + match state.accounts.create( + &body.account, + body.real_name.as_deref().unwrap_or(&body.account), + body.gender.unwrap_or(1), + body.mobile_phone.clone(), + body.description.clone(), + ) { + Ok(row) => ActionResult::ok(account_view(&row)).into_response(), + Err(msg) => ActionResult::fail(msg).into_response(), + } +} + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct UpdateUserBody { + #[serde(default)] + pub real_name: Option, + #[serde(default)] + pub gender: Option, + #[serde(default)] + pub mobile_phone: Option, + #[serde(default)] + pub description: Option, +} + +async fn update_user( + State(state): State, + p: Option>, + Path(id): Path, + body: Option>, +) -> Response { + if let Err(e) = require_admin(&state, p.as_ref()) { + return e; + } + let Some(body) = body else { + return ActionResult::fail("请求体缺失").into_response(); + }; + let current = match state.accounts.find(&id) { + Some(r) => r, + None => return ActionResult::fail("账号不存在").into_response(), + }; + match state.accounts.update( + &id, + body.real_name.as_deref().unwrap_or(¤t.real_name), + body.gender.unwrap_or(current.gender), + body.mobile_phone.clone().or(current.mobile_phone.clone()), + body.description.clone().or(current.description.clone()), + ) { + Ok(row) => ActionResult::ok(account_view(&row)).into_response(), + Err(msg) => ActionResult::fail(msg).into_response(), + } +} + +async fn remove_user( + State(state): State, + p: Option>, + Path(id): Path, +) -> Response { + if let Err(e) = require_admin(&state, p.as_ref()) { + return e; + } + match state.accounts.remove(&id) { + Ok(()) => ActionResult::ok(json!({ "id": id })).into_response(), + Err(msg) => ActionResult::fail(msg).into_response(), + } +} + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ResetPasswordBody { + /// `md5(明文)`(32 个 hex 字符)—— 上游前端用 `md5Hex(pwd)` 传。 + #[serde(default)] + pub user_password: String, + #[serde(default)] + pub validate_password: Option, +} + +async fn reset_password( + State(state): State, + p: Option>, + Path(id): Path, + body: Option>, +) -> Response { + if let Err(e) = require_admin(&state, p.as_ref()) { + return e; + } + let Some(body) = body else { + return ActionResult::fail("请求体缺失").into_response(); + }; + if body.user_password.len() != 32 || !body.user_password.chars().all(|c| c.is_ascii_hexdigit()) + { + return ActionResult::fail("口令格式不正确").into_response(); + } + if let Some(v) = &body.validate_password { + if v != &body.user_password { + return ActionResult::fail("两次输入的口令不一致").into_response(); + } + } + match state + .accounts + .reset_password(&id, &body.user_password.to_lowercase()) + { + Ok(row) => ActionResult::ok(account_view(&row)).into_response(), + Err(msg) => ActionResult::fail(msg).into_response(), + } +} + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct StateBody { + #[serde(default)] + pub enabled_mark: Option, +} + +async fn set_state( + State(state): State, + p: Option>, + Path(id): Path, + body: Option>, +) -> Response { + if let Err(e) = require_admin(&state, p.as_ref()) { + return e; + } + let Some(body) = body else { + return ActionResult::fail("请求体缺失").into_response(); + }; + let Some(enabled_mark) = body.enabled_mark else { + return ActionResult::fail("启用状态必填").into_response(); + }; + match state.accounts.set_enabled(&id, enabled_mark) { + Ok(row) => ActionResult::ok(account_view(&row)).into_response(), + Err(msg) => ActionResult::fail(msg).into_response(), + } +} diff --git a/src/routes/mod.rs b/src/routes/mod.rs index 2f1a714..45fccfc 100644 --- a/src/routes/mod.rs +++ b/src/routes/mod.rs @@ -1,5 +1,6 @@ //! 按域装配的 axum Router。 +pub mod account; pub mod auth; pub mod body; pub mod crud; @@ -26,6 +27,7 @@ pub fn build_router(state: AppState) -> Router { Router::new() .merge(health::router()) .merge(auth::router()) + .merge(account::router()) .merge(crud::router()) .with_state(state) } diff --git a/src/state.rs b/src/state.rs index dfab130..fd0191b 100644 --- a/src/state.rs +++ b/src/state.rs @@ -5,6 +5,7 @@ use std::sync::{Arc, OnceLock}; use pglite::PGlite; use tokio::sync::Mutex; +use crate::account::AccountStore; use crate::config::Config; use crate::session::SessionStore; @@ -32,6 +33,8 @@ pub struct AppState { pub sessions: Arc, /// 首次启动引导出来的本地身份。 pub bootstrap: Arc, + /// 本连接器的本地账号库(默认是**内存空库** ⇒ 早期任务与单测不必改)。 + pub accounts: Arc, } #[derive(Debug, Clone, Default)] @@ -55,6 +58,7 @@ impl AppState { db_lock: process_db_lock(), sessions, bootstrap: Arc::new(bootstrap), + accounts: Arc::new(AccountStore::empty()), } } @@ -73,6 +77,14 @@ impl AppState { pub fn cfg(&self) -> &Config { &self.config } + + /// 挂上本地账号库(**其余字段原样保留**,特别是 `db_lock`)。 + /// + /// 用途:启动时先造状态、跑身份引导,再把账号库换上去 —— + /// 这样全程只有**一个** `AppState`(也就只有一把 `db_lock`)。 + pub fn with_accounts(self, accounts: Arc) -> Self { + Self { accounts, ..self } + } } #[cfg(test)] diff --git a/tests/account_api.rs b/tests/account_api.rs new file mode 100644 index 0000000..93be8b2 --- /dev/null +++ b/tests/account_api.rs @@ -0,0 +1,388 @@ +//! 账号层端到端:JNPF 兼容登录 + 用户管理。 +//! +//! ⚠️ 本测试二进制内共用一个 PGlite 实例(pglite-rs 每进程只允许一个)。 +//! ⚠️ 账号库是**持久**的 JSON 文件 ⇒ **每个用例用各自的文件**(`build(tag)`), +//! 否则并行跑的用例会互相覆盖账号。 + +use std::sync::Arc; + +use axum::body::Body; +use axum::http::{Request, StatusCode}; +use axum::Router; +use http_body_util::BodyExt; +use pglite::PGlite; +use serde_json::Value; +use tdc_connector::account::AccountStore; +use tdc_connector::auth::{auth_middleware, AuthState}; +use tdc_connector::cipher::encrypt_login_password; +use tdc_connector::config::Config; +use tdc_connector::routes::build_router; +use tdc_connector::session::SessionStore; +use tdc_connector::state::{AppState, BootstrapIdentity}; +use tokio::sync::OnceCell; +use tower::ServiceExt; + +/// 测试用的内部令牌(走 `X-Internal-Token` 通道)。 +const TEST_INTERNAL_TOKEN: &str = "test-internal-token"; + +static DB: OnceCell> = OnceCell::const_new(); + +async fn shared_db() -> Arc { + DB.get_or_init(|| async { + let db = Arc::new(PGlite::open_temp().await.expect("打开临时 PGlite 失败")); + tdc_connector::db::ensure_schema(db.as_ref()) + .await + .expect("建表失败"); + db + }) + .await + .clone() +} + +/// 造一个应用 + 它的账号库。 +/// +/// 🔴 `tag` 决定**账号文件**与**测试身份行**的名字 ⇒ 并行用例互不干扰。 +async fn build(tag: &str) -> (Router, Arc) { + let db = shared_db().await; + let mut config = Config::from_env(std::env::current_dir().unwrap()); + // 🔴 `tdc_identity.f_identity_code` 上有唯一约束 `uk_tdc_identity_code` + // ⇒ 每个用例的身份码必须**唯一**(否则并行插入互相撞车)。 + let identity_code = format!("TEST-CONNECTOR-{}", tag); + config.identity_code = identity_code.clone(); + config.internal_token = TEST_INTERNAL_TOKEN.to_string(); + let sessions = Arc::new(SessionStore::new()); + // 账号库是**持久**的 JSON 文件 ⇒ 先清干净(否则上一轮残留账号影响断言)。 + let acc_path = std::path::PathBuf::from(format!("target/test-accounts-api-{}.json", tag)); + let _ = std::fs::remove_file(&acc_path); + let _ = std::fs::remove_file(acc_path.with_extension("json.tmp")); + let accounts = Arc::new(AccountStore::open(&acc_path).expect("打开账号库失败")); + // 🔴 `GET /api/ssw/tdc/Auth/Me` 会按 `state.bootstrap.identity_id` 去 `tdc_identity` 查身份 —— + // 测试库里**没有**身份行 ⇒ `me` 回「连接器身份不存在」⇒ 断言拿不到 `accessAllowed`。 + // ⇒ 这里补一条与 `BootstrapIdentity.identity_id` 对齐的身份行(**每个用例一行**, + // 避免并行用例互相删/插同一行)。 + let identity_id = format!("TEST-OP-{}", tag); + { + // 🔴 锁的持有者必须活过 `await` ⇒ 先把 `Arc` 绑到变量上(否则临时值当场析构)。 + let db_lock = tdc_connector::state::process_db_lock(); + let _g = db_lock.lock().await; + db.exec(&format!( + "INSERT INTO tdc_identity (f_id, f_identity_code, f_name) \ + VALUES ('{}', '{}', '测试身份')", + identity_id, identity_code + )) + .await + .expect("插入测试身份失败"); + } + let state = AppState::new( + config.clone(), + db, + sessions.clone(), + BootstrapIdentity { + identity_id, + identity_code, + issued_secret: None, + }, + ) + .with_accounts(accounts.clone()); + let auth_state = AuthState { + internal_token: config.internal_token.clone(), + sessions, + }; + // 🔴 axum 0.8.9:`impl Service> for Router<()>` —— **只有 `Router<()>` 实现 + // `Service`**(`axum-0.8.9/src/routing/mod.rs:569`)。`build_router` 返回 + // `Router`(S = 还缺什么状态)⇒ 直接 `oneshot` **编译不过**。 + // 必须再 `.with_state(state)` 一次把它落到 `Router<()>`。 + let app = build_router(state.clone()) + .layer(axum::middleware::from_fn_with_state( + auth_state, + auth_middleware, + )) + .with_state(state); + (app, accounts) +} + +async fn call(app: &Router, r: Request) -> (StatusCode, Value) { + let resp = app.clone().oneshot(r).await.expect("请求失败"); + let status = resp.status(); + let bytes = resp.into_body().collect().await.unwrap().to_bytes(); + let value = serde_json::from_slice(&bytes).unwrap_or(Value::Null); + (status, value) +} + +fn login_form(account: &str, plain: &str) -> String { + format!( + "account={account}&password={}&grant_type=password", + encrypt_login_password(plain) + ) +} + +fn post_form(uri: &str, body: String) -> Request { + Request::builder() + .method("POST") + .uri(uri) + .header("Content-Type", "application/x-www-form-urlencoded") + .body(Body::from(body)) + .unwrap() +} + +fn get_json(uri: &str, token: Option<&str>) -> Request { + let mut b = Request::builder().method("GET").uri(uri); + if let Some(t) = token { + b = b.header("Authorization", format!("bearer {}", t)); + } + b.body(Body::empty()).unwrap() +} + +/// 登录并取回 token(失败时 panic,附带 body 便于定位)。 +async fn login_token(app: &Router, account: &str, plain: &str) -> String { + let (status, body) = call( + app, + post_form("/api/oauth/Login", login_form(account, plain)), + ) + .await; + assert_eq!(status, 200, "登录应回 HTTP 200(业务失败也是 200)"); + assert_eq!(body["code"], 200, "登录应成功,实际 body: {}", body); + body["data"]["token"] + .as_str() + .expect("应返回 token") + .to_string() +} + +#[tokio::test] +async fn oauth_login_returns_a_usable_token() { + let (app, _accounts) = build("login").await; + + // ① 口令错 ⇒ HTTP 200 + code != 200(前端据此提示,**不**跳登录页) + let (status, body) = call( + &app, + post_form("/api/oauth/Login", login_form("admin", "wrong")), + ) + .await; + assert_eq!(status, 200); + assert_ne!(body["code"], 200); + assert_eq!(body["msg"], "账号或密码错误"); + assert!(body["data"].is_null(), "失败时不得带 data:{}", body); + + // ② 口令对 ⇒ 返回 token + userInfo + let (status, body) = call( + &app, + post_form("/api/oauth/Login", login_form("admin", "admin")), + ) + .await; + assert_eq!(status, 200); + assert_eq!(body["code"], 200); + let token = body["data"]["token"] + .as_str() + .expect("应返回 token") + .to_string(); + assert!(!token.is_empty()); + // 🔴 前端自己补 `bearer ` 前缀(`request.ts` 的 `setToken`)⇒ 后端返的**不能**带。 + assert!( + !token.to_lowercase().starts_with("bearer "), + "token 不应带 bearer 前缀:{}", + token + ); + assert_eq!(body["data"]["userInfo"]["userName"], "admin"); + assert_eq!(body["data"]["userInfo"]["realName"], "管理员"); + assert_eq!(body["data"]["userInfo"]["nickName"], "管理员"); + assert_eq!(body["data"]["expiresIn"], 7200); + + // ③ 拿令牌访问 Auth/Me ⇒ accessAllowed === true + let (status, body) = call(&app, get_json("/api/ssw/tdc/Auth/Me", Some(&token))).await; + assert_eq!(status, 200); + assert_eq!(body["data"]["accessAllowed"], true); + assert_eq!(body["data"]["account"], "admin"); +} + +#[tokio::test] +async fn user_management_requires_an_administrator() { + let (app, _accounts) = build("users").await; + + // ① 无凭证 ⇒ 401(鉴权中间件拦下) + let (status, body) = call(&app, get_json("/api/permission/Users", None)).await; + assert_eq!(status, 401); + assert_eq!(body["code"], 401); + assert!(body.get("data").is_none(), "鉴权失败不得有 data 键"); + + // ② 管理员账号 ⇒ 200 + 列表里能看到 admin,且**不含口令字段** + let token = login_token(&app, "admin", "admin").await; + let (status, body) = call( + &app, + get_json( + "/api/permission/Users?currentPage=1&pageSize=20", + Some(&token), + ), + ) + .await; + assert_eq!(status, 200); + assert!(body["data"]["list"].is_array()); + assert!(body["data"]["pagination"]["total"].as_u64().unwrap() >= 1); + let first = &body["data"]["list"][0]; + assert!(first.get("passwordMd5").is_none(), "列表不得回显口令"); + assert!(first.get("password_md5").is_none(), "列表不得回显口令"); + // 列表里能按账号名找到 admin + let list = body["data"]["list"].as_array().unwrap(); + assert!( + list.iter().any(|a| a["account"] == "admin"), + "列表应含 admin 账号:{:?}", + list + ); +} + +/// 🔴 **E2 刻意分歧**:内部令牌通道访问用户管理 ⇒ **403**(上游更宽松,直接放行)。 +#[tokio::test] +async fn internal_token_channel_is_rejected_by_the_admin_gate() { + let (app, _accounts) = build("internal").await; + + let req = Request::builder() + .method("GET") + .uri("/api/permission/Users") + .header("X-Internal-Token", TEST_INTERNAL_TOKEN) + .header("X-Protocol-Version", "1.0") + .body(Body::empty()) + .unwrap(); + let (status, body) = call(&app, req).await; + assert_eq!( + status, 403, + "内部令牌不得被当成管理员(刻意比上游严): {}", + body + ); + assert_eq!(body["code"], 403); + assert_eq!(body["msg"], "仅管理员可管理连接器用户"); + assert!(body.get("data").is_none(), "鉴权失败不得有 data 键"); +} + +/// 🔴 **E3 fail-closed**:非管理员账号 ⇒ 403;查不到账号 ⇒ 同样 403。 +#[tokio::test] +async fn non_admin_account_cannot_manage_users() { + let (app, accounts) = build("nonadmin").await; + // 直接在账号库里建一个**非管理员**(初始口令 = `DEFAULT_NEW_USER_PASSWORD` = "123456") + let bob = accounts + .create("bob", "鲍勃", 1, None, None) + .expect("建号失败"); + assert!(!bob.administrator); + + let token = login_token(&app, "bob", "123456").await; + let (status, body) = call(&app, get_json("/api/permission/Users", Some(&token))).await; + assert_eq!(status, 403, "非管理员不得管用户:{}", body); + assert_eq!(body["msg"], "仅管理员可管理连接器用户"); +} + +/// 🔴 **MaxKey SSO 不实现 ⇒ 如实报业务失败,绝不伪装成功**。 +#[tokio::test] +async fn maxkey_grant_is_reported_as_a_business_failure() { + let (app, _accounts) = build("maxkey").await; + + let form = format!( + "account=admin&password={}&grant_type=maxkey&code=abc&state=xyz", + encrypt_login_password("admin") + ); + let (status, body) = call(&app, post_form("/api/oauth/Login", form)).await; + assert_eq!(status, 200, "业务失败也是 HTTP 200"); + assert_eq!(body["code"], 400, "MaxKey 必须报业务失败:{}", body); + assert!( + body["msg"].as_str().unwrap().contains("MaxKey"), + "msg 应说明 MaxKey 未启用:{}", + body + ); + assert!( + body["data"].is_null(), + "MaxKey 失败不得返回 token:{}", + body + ); +} + +/// 明文口令(未加密)⇒ 业务失败。 +#[tokio::test] +async fn plain_text_password_is_rejected() { + let (app, _accounts) = build("plain").await; + + let (status, body) = call( + &app, + post_form( + "/api/oauth/Login", + "account=admin&password=admin&grant_type=password".to_string(), + ), + ) + .await; + assert_eq!(status, 200); + assert_eq!(body["code"], 400); + assert_eq!(body["msg"], "账号或密码错误"); +} + +/// 用户管理闭环:建号 → 列表可见 → 改密 → 用新口令登录 → 禁用 → 禁用的账号登不进来。 +#[tokio::test] +async fn admin_can_manage_accounts_end_to_end() { + let (app, _accounts) = build("manage").await; + let token = login_token(&app, "admin", "admin").await; + + // ① 建号 + let req = Request::builder() + .method("POST") + .uri("/api/permission/Users") + .header("Content-Type", "application/json") + .header("Authorization", format!("bearer {}", token)) + .body(Body::from( + r#"{"account":"carol","realName":"卡罗尔","gender":2,"mobilePhone":"13900000000"}"#, + )) + .unwrap(); + let (status, body) = call(&app, req).await; + assert_eq!(status, 200); + assert_eq!(body["code"], 200, "建号应成功:{}", body); + let carol_id = body["data"]["id"].as_str().expect("应返回 id").to_string(); + assert_eq!(body["data"]["account"], "carol"); + assert!( + body["data"].get("passwordMd5").is_none(), + "建号回执不得回显口令:{}", + body + ); + + // ② 改密(`md5(明文)`,上游前端用 `md5Hex(pwd)` 传) + let req = Request::builder() + .method("POST") + .uri(format!( + "/api/permission/Users/{}/Actions/ResetPassword", + carol_id + )) + .header("Content-Type", "application/json") + .header("Authorization", format!("bearer {}", token)) + .body(Body::from( + r#"{"userPassword":"2fe08b6d3a2d1c8a3d0f0e6b7a9c1d2e","validatePassword":"2fe08b6d3a2d1c8a3d0f0e6b7a9c1d2e"}"#, + )) + .unwrap(); + let (status, body) = call(&app, req).await; + assert_eq!(status, 200); + assert_eq!(body["code"], 200, "改密应成功:{}", body); + + // ③ 用新口令登录 ⇒ 成功(初始口令 123456 此时应已失效) + let (status, body) = call( + &app, + post_form("/api/oauth/Login", login_form("carol", "123456")), + ) + .await; + assert_eq!(status, 200); + assert_ne!(body["code"], 200, "改密后旧口令必须失效:{}", body); + + // ④ 禁用 + let req = Request::builder() + .method("PUT") + .uri(format!("/api/permission/Users/{}/Actions/State", carol_id)) + .header("Content-Type", "application/json") + .header("Authorization", format!("bearer {}", token)) + .body(Body::from(r#"{"enabledMark":0}"#)) + .unwrap(); + let (status, body) = call(&app, req).await; + assert_eq!(status, 200); + assert_eq!(body["code"], 200, "禁用应成功:{}", body); + assert_eq!(body["data"]["enabledMark"], 0); + + // ⑤ 被禁用的账号登不进来 + let (status, body) = call( + &app, + post_form("/api/oauth/Login", login_form("carol", "123456")), + ) + .await; + assert_eq!(status, 200); + assert_eq!(body["code"], 400); + assert_eq!(body["msg"], "账号已被禁用"); +}