Files
tdc-rs/src/tdc/service/account.rs
T
admin 43dcd3f9eb chore(p4): 收拢库操作到唯一出口,为统一 sspf Db.lock 做准备
- 新增 platform::db::exec_params,收拢业务层 12 处裸 state.db.query
- 新增 check-db-access.sh 护栏:白名单 3 文件,7 处命中 0 越界
- 平台侧需求写入 ssw-platform/docs/SSPF-BUSINESS-DB-ACCESS.md(目标 v0.5.0)
- Cargo.toml 仍锁 v0.3.0,132 端点契约与响应形状未变
2026-11-04 22:20:55 +08:00

860 lines
34 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 账号层:**`base_user` / `base_role` / `base_role_relation`**(照上游 j7 同款)。
//!
//! 🔴 **B4 起,本文件不再读写本机 JSON 文件**(`data/accounts.json`):
//! 账号载体换成上游 j7 的 `base_user` 表 ⇒ 存量 JSON **不导入**(D5/D8),
//! 文件**保留不删**(运行期数据不擅自删),但**后端不再读取它**。
//!
//! ## 口令:官方双 md5 公式(**单向不可逆**)
//!
//! | 环节 | 口径 |
//! |---|---|
//! | 前端加密 | `md5(明文)` → AES-256-ECB-PKCS7 → hex(`platform::cipher`,**一字不改**) |
//! | 服务端解密 | 密文 hex → `md5(明文)`(32 个小写 hex) |
//! | **入库** | `f_password = md5(lower(md5(明文)) + lower(f_secretkey))` |
//! | 登录比对 | 解密得 `md5(明文)` → 拼 `lower(secretkey)` → 再 `md5` → 与 `f_password` 比 |
//!
//! 上游出处:`PasswordTokenGranter.java:186` 的
//! `Md5Util.getStringMd5(inputPwd + secretkey.toLowerCase())`(`inputPwd` 已是 `md5(明文)`)。
//!
//! 🔴 **改密不换 secretkey**(v3 spec §4.2;与官方一致)——改密只重算 `f_password`。
//! 🔴 **一次性换算不可逆**:从旧裸 md5 换到新公式需要**旧 md5**(前端手里那份)+ 新 secretkey。
//!
//! ## 权限三件套(照上游 §5.1)
//!
//! 1. **登录态**:`/api/oauth/Login` 成功 ⇒ 会话令牌;
//! 2. **角色码**:`base_role.f_en_code` ∈ {`tdcProvider`,`tdcConsumer`,`tdsReadOnly`}
//! (经 `base_role_relation` 关联用户)——SQL 形状逐字照抄上游 `AuthController#me`;
//! 3. **管理员位**:`base_user.f_is_administrator = 1`(**fail-closed**)⇒ 守用户管理端点。
//!
//! ⚠️ **D9 / S7**:`tdsReadOnly` **判据在、种子不种**(上游自身的不一致,照抄)。
use rand::RngCore;
use serde_json::Value;
use crate::platform::cipher::md5_hex;
use crate::platform::db::{query_json_params, query_scalar_text};
use crate::platform::state::AppState;
use crate::tdc::config::TdcConfig;
use crate::tdc::mapper::bind_refs;
/// 新建账号的初始口令(上游取 `base_sys_config.newUserDefaultPassword`,本端固定值)。
pub const DEFAULT_NEW_USER_PASSWORD: &str = "123456";
/// 首次启动引导的管理员账号名 / 口令 ⇒ **业务常量**(`tdc::constant`,一处定义)。
pub use crate::tdc::constant::{
DEFAULT_BOOTSTRAP_ADMIN_ACCOUNT as BOOTSTRAP_ADMIN_ACCOUNT,
DEFAULT_BOOTSTRAP_ADMIN_PASSWORD as BOOTSTRAP_ADMIN_PASSWORD,
};
/// 角色**判据**里的三个角色码(照抄上游 `AuthController#me` 的 `f_en_code IN (...)`)。
///
/// 🔴 `tdsReadOnly` 是**悬空码**:上游 `connector_seed` 只种了
/// `tdcProvider` / `tdcConsumer` / `user`(D9 / S7)⇒ 判据保留、种子不种。
pub const ROLE_CODES: &[&str] = &["tdcProvider", "tdcConsumer", "tdsReadOnly"];
/// 上游 `V1.0.1__connector_seed.sql` 种的三个角色(`f_id` / `f_full_name` / `f_en_code`)——**逐字照抄**。
pub const SEED_ROLES: &[(&str, &str, &str)] = &[
("a0000000-0000-4000-8000-000000000001", "TDC数据提供方", "tdcProvider"),
("a0000000-0000-4000-8000-000000000002", "TDC数据使用方", "tdcConsumer"),
("a0000000-0000-4000-8000-000000000003", "使用者", "user"),
];
/// 引导管理员绑定的角色码(上游 `connector_seed` 建的第三个角色 `user`)。
pub const BOOTSTRAP_ADMIN_ROLE: &str = "user";
/// 常量时间比较(**实现上收到平台层**,v3 spec §2.3.1 C11 ⇒ 全仓只有一份)。
pub use crate::platform::compare::constant_time_eq;
/// 账号层的失败:**业务失败**(code 400)与**服务端失败**(code 500)分开。
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AccountError {
/// 业务失败:账号已存在 / 账号不存在 / 管理员账号不可删除 ……
Business(String),
/// 服务端失败:DB 读写出错。
Server(String),
}
impl AccountError {
pub fn msg(&self) -> &str {
match self {
AccountError::Business(m) | AccountError::Server(m) => m,
}
}
}
/// 一行账号(`base_user` 的一行)。
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Account {
pub id: String,
pub account: String,
pub real_name: String,
/// `f_gender`(上游是 `varchar(50)`)⇒ 本仓**存文本、读成数字**(出参形状不变)。
pub gender: i64,
pub mobile_phone: Option<String>,
pub description: Option<String>,
/// 1 = 启用,0 = 禁用(上游 `enabledMark`)。
pub enabled_mark: i64,
/// 是否管理员(上游 `f_is_administrator`)⇒ 能不能管 `/api/permission/Users*`。
pub administrator: bool,
/// `f_password`(官方双 md5 公式的散列)。**永不回显**。
pub password_hash: String,
/// `f_secretkey`(每账号随机)。**永不回显**。
pub secretkey: String,
/// `f_creator_time`(DB `now()` ⇒ **服务器本地时区**),格式 `YYYY-MM-DD HH:MM:SS`。
pub creator_time: String,
}
/// 账号层引导的结果。
#[derive(Debug, Clone)]
pub struct AccountBootstrap {
/// 本次启动**新建**了引导管理员(`false` = 库里已有账号 ⇒ 幂等,不动)。
pub admin_created: bool,
/// 引导管理员的账号名。
pub admin_account: String,
}
// ==========================================================================
// 纯函数(口令公式 / id 生成 / 行映射)
// ==========================================================================
/// 官方口令公式:`md5(lower(md5(明文)) + lower(f_secretkey))`。
///
/// 🔴 入参 `plain_md5_hex` 是**明文的 md5 hex**(不是明文本身)——与上游
/// `PasswordTokenGranter` 的 `inputPwd` 同义。
pub fn official_password_hash(plain_md5_hex: &str, secretkey: &str) -> String {
md5_hex(&format!(
"{}{}",
plain_md5_hex.to_lowercase(),
secretkey.to_lowercase()
))
}
/// 上游 j7 的 id / 秘钥形状:`UUID.randomUUID().toString().toUpperCase()`(36 字符,带连字符)。
///
/// 🔴 与 `platform::ids::next_id()`(雪花号十进制串)**刻意不同**:
/// `base_*` 是上游 j7 的表 ⇒ 行 id 用 j7 的形状(`TdcLocalJ7SeedService` 就是这么插的),
/// 免得同一张表里混两种 id 风格。
pub fn new_j7_id() -> String {
let mut b = [0u8; 16];
rand::rngs::OsRng.fill_bytes(&mut b);
// RFC 4122 v4:version 位 + variant 位
b[6] = (b[6] & 0x0f) | 0x40;
b[8] = (b[8] & 0x3f) | 0x80;
let h = hex::encode(b).to_uppercase();
format!(
"{}-{}-{}-{}-{}",
&h[0..8],
&h[8..12],
&h[12..16],
&h[16..20],
&h[20..32]
)
}
/// 绑定参数占位符:Rust 侧只送 text,类型转换全交给 SQL(`platform::db` 的红线)。
///
/// 🔴 **必须双层 CAST**:只写 `CAST($1 AS text)` 时,参数被钉成 text,
/// 插进 `integer` / `character varying(50)` 列时 PG 会报
/// 「column is of type integer but expression is of type text」
/// ⇒ 必须再显式转一次到目标列类型。
fn p(idx: usize, ty: &str) -> String {
format!("CAST(CAST(${idx} AS text) AS {ty})", idx = idx)
}
/// 可空文本列的绑定表达式:**空串 ⇒ NULL**。
///
/// 🔴 为什么要这一层:出参里 `mobilePhone` / `description` 是 `null` 还是 `""`
/// 是**可观测**的(v3 spec W3「出参形状不变」)⇒ 传空串时必须落成 `NULL`,
/// 否则老账号的 `null` 会变成 `""`。
fn opt_p(idx: usize, ty: &str) -> String {
format!("NULLIF({}, '')", p(idx, ty))
}
/// 账号行的 SELECT 列(**只 SELECT 明确列**,永不 `SELECT *` —— 见 v3 spec C10 的同款纪律)。
const ACCOUNT_COLUMNS: &str = "f_id, f_account, \
COALESCE(f_real_name, '') AS f_real_name, \
COALESCE(f_gender, '') AS f_gender, \
f_mobile_phone, f_description, \
COALESCE(f_enabled_mark, 0) AS f_enabled_mark, \
COALESCE(f_is_administrator, 0) AS f_is_administrator, \
f_password, f_secretkey, \
COALESCE(to_char(f_creator_time, 'YYYY-MM-DD HH24:MI:SS'), '') AS f_creator_time";
/// 一行 JSON → [`Account`](列名取自 `ACCOUNT_COLUMNS`)。
fn row_to_account(row: &Value) -> Option<Account> {
let id = row.get("f_id")?.as_str()?.to_string();
let account = row
.get("f_account")
.and_then(|v| v.as_str())
.unwrap_or_default()
.to_string();
let real_name = row
.get("f_real_name")
.and_then(|v| v.as_str())
.unwrap_or_default()
.to_string();
// 🔴 `f_gender` 上游是 `varchar(50)` ⇒ 存文本、读成数字(读不出数字 ⇒ 0 = 未知)。
let gender = row
.get("f_gender")
.and_then(|v| v.as_str())
.and_then(|s| s.trim().parse::<i64>().ok())
.unwrap_or(0);
let mobile_phone = row
.get("f_mobile_phone")
.and_then(|v| v.as_str())
.map(|s| s.to_string());
let description = row
.get("f_description")
.and_then(|v| v.as_str())
.map(|s| s.to_string());
let enabled_mark = row
.get("f_enabled_mark")
.and_then(|v| v.as_i64())
.unwrap_or(0);
let administrator = row
.get("f_is_administrator")
.and_then(|v| v.as_i64())
.unwrap_or(0)
== 1;
let password_hash = row
.get("f_password")
.and_then(|v| v.as_str())
.unwrap_or_default()
.to_string();
let secretkey = row
.get("f_secretkey")
.and_then(|v| v.as_str())
.unwrap_or_default()
.to_string();
let creator_time = row
.get("f_creator_time")
.and_then(|v| v.as_str())
.unwrap_or_default()
.to_string();
Some(Account {
id,
account,
real_name,
gender,
mobile_phone,
description,
enabled_mark,
administrator,
password_hash,
secretkey,
creator_time,
})
}
/// 🔴 存活谓词(对齐上游 `TdcCrudController.ALIVE`)。
const ALIVE_USER: &str = "(f_delete_mark IS NULL OR f_delete_mark = 0)";
// ==========================================================================
// 读
// ==========================================================================
/// 按 `f_id` 取一行账号(存活)。
pub async fn find(state: &AppState, id: &str) -> Result<Option<Account>, AccountError> {
let sql = format!(
"SELECT {ACCOUNT_COLUMNS} FROM base_user WHERE f_id = CAST($1 AS text) AND {ALIVE_USER} LIMIT 1"
);
let rows = {
let _g = state.db_lock.lock().await;
query_json_params(state.db.as_ref(), &sql, &[&id.to_string()]).await
};
let rows = rows.map_err(|e| AccountError::Server(format!("查询账号失败: {}", e)))?;
Ok(rows.first().and_then(row_to_account))
}
/// 按账号名取一行账号(存活)。
pub async fn find_by_account(
state: &AppState,
account: &str,
) -> Result<Option<Account>, AccountError> {
let sql = format!(
"SELECT {ACCOUNT_COLUMNS} FROM base_user WHERE f_account = CAST($1 AS text) AND {ALIVE_USER} \
ORDER BY f_creator_time DESC LIMIT 1"
);
let rows = {
let _g = state.db_lock.lock().await;
query_json_params(state.db.as_ref(), &sql, &[&account.to_string()]).await
};
let rows = rows.map_err(|e| AccountError::Server(format!("查询账号失败: {}", e)))?;
Ok(rows.first().and_then(row_to_account))
}
/// 管理员位(`base_user.f_is_administrator = 1`)。
///
/// 🔴 **fail-closed**:查不到行 / 查出错 ⇒ `false`(对齐上游 `TdcConnectorAdminGuard`)。
pub async fn is_administrator(state: &AppState, id: &str) -> bool {
let sql = "SELECT COALESCE(f_is_administrator, 0) AS f_is_administrator FROM base_user \
WHERE f_id = CAST($1 AS text) AND (f_delete_mark IS NULL OR f_delete_mark = 0) LIMIT 1";
let rows = {
let _g = state.db_lock.lock().await;
query_json_params(state.db.as_ref(), sql, &[&id.to_string()]).await
};
match rows {
Ok(rows) => rows
.first()
.and_then(|r| r.get("f_is_administrator"))
.and_then(|v| v.as_i64())
.map(|v| v == 1)
.unwrap_or(false),
Err(_) => false,
}
}
/// 角色码(**逐字照抄上游 `AuthController#me` 的 SQL 形状**)。
///
/// ```sql
/// SELECT b.f_en_code FROM base_role b JOIN base_role_relation r ON r.f_role_id = b.f_id
/// WHERE r.f_object_type = 'user' AND r.f_object_id = ?
/// AND (b.f_delete_mark IS NULL OR b.f_delete_mark = 0)
/// AND b.f_en_code IN ('tdcProvider','tdcConsumer','tdsReadOnly')
/// ```
///
/// ⚠️ 判据里的三个码与**种子**里的三个角色**不是同一组**(D9 / S7):
/// `tdsReadOnly` 在判据里、**不在种子里**;`user` 在种子里、**不在判据里**
/// ⇒ 绑了 `user` 角色的账号(本仓的引导管理员)在这条 SQL 下**查不到任何角色码**
/// —— 这正是上游自己的口径,照抄。
pub async fn role_codes(state: &AppState, user_id: &str) -> Vec<String> {
let in_list = ROLE_CODES
.iter()
.map(|c| format!("'{}'", c))
.collect::<Vec<_>>()
.join(", ");
let sql = format!(
"SELECT b.f_en_code FROM base_role b JOIN base_role_relation r ON r.f_role_id = b.f_id \
WHERE r.f_object_type = 'user' AND r.f_object_id = CAST($1 AS text) \
AND (b.f_delete_mark IS NULL OR b.f_delete_mark = 0) \
AND b.f_en_code IN ({})",
in_list
);
let rows = {
let _g = state.db_lock.lock().await;
query_json_params(state.db.as_ref(), &sql, &[&user_id.to_string()]).await
};
let Ok(rows) = rows else {
return Vec::new();
};
rows.iter()
.filter_map(|r| r.get("f_en_code"))
.filter_map(|v| v.as_str())
.map(|s| s.to_string())
.collect()
}
/// 分页列账号(`keyword` 命中账号名或姓名;空 ⇒ 全量)。
///
/// 返回 `(当页行, 总条数)`。
pub async fn list(
state: &AppState,
keyword: &str,
page: usize,
size: usize,
) -> Result<(Vec<Account>, i64), AccountError> {
let kw = keyword.trim().to_lowercase();
let where_clause = if kw.is_empty() {
ALIVE_USER.to_string()
} else {
format!(
"{ALIVE_USER} AND (lower(f_account) LIKE '%' || CAST($1 AS text) || '%' \
OR lower(COALESCE(f_real_name, '')) LIKE '%' || CAST($1 AS text) || '%')"
)
};
let binds: Vec<String> = if kw.is_empty() {
Vec::new()
} else {
vec![kw.clone()]
};
let refs = bind_refs(&binds);
let count_sql = format!("SELECT count(*)::text FROM base_user WHERE {}", where_clause);
let total: i64 = {
let _g = state.db_lock.lock().await;
match query_scalar_text(state.db.as_ref(), &count_sql, &refs).await {
Ok(Some(t)) => t.trim().parse().unwrap_or(0),
Ok(None) => 0,
Err(e) => return Err(AccountError::Server(format!("统计账号数失败: {}", e))),
}
};
// 🔴 `page` / `size` 由调用方**夹紧**过(page ≥ 1、1 ≤ size ≤ 500)⇒ 内联进 SQL 是安全的
// (与通用 CRUD 引擎的 `LIMIT/OFFSET` 内联同款做法)。
let offset = page.saturating_sub(1).saturating_mul(size);
let sql = format!(
"SELECT {ACCOUNT_COLUMNS} FROM base_user WHERE {} ORDER BY f_creator_time DESC, f_id LIMIT {} OFFSET {}",
where_clause, size, offset
);
let rows = {
let _g = state.db_lock.lock().await;
query_json_params(state.db.as_ref(), &sql, &refs).await
};
let rows = rows.map_err(|e| AccountError::Server(format!("查询账号列表失败: {}", e)))?;
let list: Vec<Account> = rows.iter().filter_map(row_to_account).collect();
Ok((list, total))
}
// ==========================================================================
// 写
// ==========================================================================
/// 新建账号。
///
/// 🔴 **初始口令 = 系统默认口令**(`DEFAULT_NEW_USER_PASSWORD`),
/// **不取请求里的 password**(上游口径:新建账号的初始口令是系统默认值)。
/// 🔴 每个账号一条**独立随机** `f_secretkey` ⇒ 两个同名口令的不同账号散列不同。
pub async fn create(
state: &AppState,
operator: &str,
account: &str,
real_name: &str,
gender: i64,
mobile_phone: Option<&str>,
description: Option<&str>,
) -> Result<Account, AccountError> {
let account = account.trim();
if account.is_empty() {
return Err(AccountError::Business("账号必填".to_string()));
}
let dup = find_by_account(state, account).await?;
if dup.is_some() {
return Err(AccountError::Business("账号已存在".to_string()));
}
let secretkey = new_j7_id();
let id = new_j7_id();
let password_hash = official_password_hash(&md5_hex(DEFAULT_NEW_USER_PASSWORD), &secretkey);
let sql = format!(
"INSERT INTO base_user (f_id, f_account, f_real_name, f_gender, f_mobile_phone, f_description, \
f_password, f_secretkey, f_is_administrator, f_enabled_mark, f_creator_time, f_creator_user_id, \
f_tenant_id) \
VALUES ({}, {}, {}, {}, {}, {}, {}, {}, 0, 1, NOW(), {}, '0')",
p(1, "character varying(50)"),
p(2, "character varying(50)"),
p(3, "character varying(50)"),
p(4, "character varying(50)"),
opt_p(5, "character varying(20)"),
opt_p(6, "character varying(500)"),
p(7, "character varying(50)"),
p(8, "character varying(50)"),
p(9, "character varying(50)"),
);
let params: Vec<String> = vec![
id.clone(),
account.to_string(),
real_name.trim().to_string(),
gender.to_string(),
mobile_phone.unwrap_or_default().to_string(),
description.unwrap_or_default().to_string(),
password_hash,
secretkey,
operator.to_string(),
];
let refs = bind_refs(&params);
{
let _g = state.db_lock.lock().await;
crate::platform::db::exec_params(&state.db, &sql, &refs).await
.map_err(|e| AccountError::Server(format!("新建账号失败: {}", e)))?;
}
find(state, &id)
.await?
.ok_or_else(|| AccountError::Server("新建账号后读不回来".to_string()))
}
/// 更新资料(**不动口令**)。
pub async fn update(
state: &AppState,
operator: &str,
id: &str,
real_name: &str,
gender: i64,
mobile_phone: Option<&str>,
description: Option<&str>,
) -> Result<Account, AccountError> {
let current = find(state, id)
.await?
.ok_or_else(|| AccountError::Business("账号不存在".to_string()))?;
let sql = format!(
"UPDATE base_user SET f_real_name = {}, f_gender = {}, f_mobile_phone = {}, f_description = {}, \
f_last_modify_time = NOW(), f_last_modify_user_id = {} \
WHERE f_id = CAST($8 AS text) AND {ALIVE_USER}",
p(1, "character varying(50)"),
p(2, "character varying(50)"),
opt_p(3, "character varying(20)"),
opt_p(4, "character varying(500)"),
p(5, "character varying(50)"),
);
let params: Vec<String> = vec![
real_name.trim().to_string(),
gender.to_string(),
mobile_phone.unwrap_or_default().to_string(),
description.unwrap_or_default().to_string(),
operator.to_string(),
id.to_string(),
];
let refs = bind_refs(&params);
{
let _g = state.db_lock.lock().await;
crate::platform::db::exec_params(&state.db, &sql, &refs).await
.map_err(|e| AccountError::Server(format!("更新账号失败: {}", e)))?;
}
let _ = current;
find(state, id)
.await?
.ok_or_else(|| AccountError::Business("账号不存在".to_string()))
}
/// 删除(**逻辑删除**;**管理员账号不许删**)。
pub async fn remove(state: &AppState, operator: &str, id: &str) -> Result<(), AccountError> {
let current = find(state, id)
.await?
.ok_or_else(|| AccountError::Business("账号不存在".to_string()))?;
if current.administrator {
return Err(AccountError::Business("管理员账号不可删除".to_string()));
}
let sql = format!(
"UPDATE base_user SET f_delete_mark = 1, f_delete_time = NOW(), f_delete_user_id = {} \
WHERE f_id = CAST($2 AS text) AND {ALIVE_USER}",
p(1, "character varying(50)")
);
let params: Vec<String> = vec![operator.to_string(), id.to_string()];
let refs = bind_refs(&params);
let _g = state.db_lock.lock().await;
crate::platform::db::exec_params(&state.db, &sql, &refs).await
.map(|_| ())
.map_err(|e| AccountError::Server(format!("删除账号失败: {}", e)))
}
/// 启用 / 禁用。
pub async fn set_enabled(
state: &AppState,
operator: &str,
id: &str,
enabled_mark: i64,
) -> Result<Account, AccountError> {
let current = find(state, id)
.await?
.ok_or_else(|| AccountError::Business("账号不存在".to_string()))?;
let mark = if enabled_mark == 0 { 0 } else { 1 };
let sql = format!(
"UPDATE base_user SET f_enabled_mark = {}, f_last_modify_time = NOW(), f_last_modify_user_id = {} \
WHERE f_id = CAST($3 AS text) AND {ALIVE_USER}",
p(1, "integer"),
p(2, "character varying(50)")
);
let params: Vec<String> = vec![
mark.to_string(),
operator.to_string(),
id.to_string(),
];
let refs = bind_refs(&params);
{
let _g = state.db_lock.lock().await;
crate::platform::db::exec_params(&state.db, &sql, &refs).await
.map_err(|e| AccountError::Server(format!("设置账号状态失败: {}", e)))?;
}
let _ = current;
find(state, id)
.await?
.ok_or_else(|| AccountError::Business("账号不存在".to_string()))
}
/// 重设口令(传入的是 `md5(明文)`,32 个 hex 字符)。
///
/// 🔴 **改密不换 secretkey**(v3 spec §4.2;与官方一致)⇒ 只重算 `f_password`。
pub async fn reset_password(
state: &AppState,
operator: &str,
id: &str,
password_md5: &str,
) -> Result<Account, AccountError> {
let current = find(state, id)
.await?
.ok_or_else(|| AccountError::Business("账号不存在".to_string()))?;
let password_hash = official_password_hash(password_md5, &current.secretkey);
let sql = format!(
"UPDATE base_user SET f_password = {}, f_change_password_date = NOW(), \
f_last_modify_time = NOW(), f_last_modify_user_id = {} \
WHERE f_id = CAST($3 AS text) AND {ALIVE_USER}",
p(1, "character varying(50)"),
p(2, "character varying(50)")
);
let params: Vec<String> = vec![
password_hash,
operator.to_string(),
id.to_string(),
];
let refs = bind_refs(&params);
{
let _g = state.db_lock.lock().await;
crate::platform::db::exec_params(&state.db, &sql, &refs).await
.map_err(|e| AccountError::Server(format!("重设口令失败: {}", e)))?;
}
find(state, id)
.await?
.ok_or_else(|| AccountError::Business("账号不存在".to_string()))
}
// ==========================================================================
// 引导(幂等)
// ==========================================================================
/// 账号层引导:种三个角色 +(库里没有账号时)引导**一个**管理员。
///
/// 🔴 **幂等**:角色用 `WHERE NOT EXISTS` 种;管理员只在 **`base_user` 没有存活行**时建。
/// 重复启动不会覆盖既有账号(口令只由引导决定)。
/// 🔴 全程持 `db_lock` ⇒ 进程内串行(pglite 单 backend)。
pub async fn bootstrap_account_layer(
state: &AppState,
tdc_config: &TdcConfig,
) -> Result<AccountBootstrap, AccountError> {
let account = {
let raw = tdc_config.bootstrap_admin_account.trim();
if raw.is_empty() {
BOOTSTRAP_ADMIN_ACCOUNT.to_string()
} else {
raw.to_string()
}
};
let password = tdc_config
.bootstrap_admin_password
.clone()
.unwrap_or_else(|| BOOTSTRAP_ADMIN_PASSWORD.to_string());
let _g = state.db_lock.lock().await;
// ① 三个角色(照抄上游 `connector_seed` 的三行)。
for (id, full_name, en_code) in SEED_ROLES {
let sql = format!(
"INSERT INTO base_role (f_id, f_full_name, f_en_code, f_type, f_enabled_mark, f_sort_code, \
f_creator_time, f_creator_user_id, f_delete_mark, f_tenant_id, f_global_mark) \
SELECT {}, {}, {}, 'user', 1, 0, NOW(), 'admin', NULL, '0', 0 \
WHERE NOT EXISTS (SELECT 1 FROM base_role WHERE f_en_code = {})",
p(1, "character varying(50)"),
p(2, "character varying(200)"),
p(3, "character varying(200)"),
p(3, "character varying(200)"),
);
let params: Vec<String> = vec![
id.to_string(),
full_name.to_string(),
en_code.to_string(),
];
let refs: Vec<&(dyn pglite::ToSql + Sync)> = params
.iter()
.map(|s| s as &(dyn pglite::ToSql + Sync))
.collect();
crate::platform::db::exec_params(&state.db, &sql, &refs).await
.map_err(|e| AccountError::Server(format!("种角色 {} 失败: {}", en_code, e)))?;
}
// ② `base_user` 有没有存活行 ⇒ 有则不引导(幂等)。
let count = query_scalar_text(
state.db.as_ref(),
&format!("SELECT count(*)::text FROM base_user WHERE {}", ALIVE_USER),
&[],
)
.await
.map_err(|e| AccountError::Server(format!("统计账号数失败: {}", e)))?;
let existing: i64 = count
.and_then(|t| t.trim().parse().ok())
.unwrap_or(0);
if existing > 0 {
return Ok(AccountBootstrap {
admin_created: false,
admin_account: account,
});
}
// ③ 引导一个管理员(`f_is_administrator = 1`)。
let secretkey = new_j7_id();
let id = new_j7_id();
let password_hash = official_password_hash(&md5_hex(&password), &secretkey);
let sql = format!(
"INSERT INTO base_user (f_id, f_account, f_real_name, f_gender, f_description, \
f_password, f_secretkey, f_is_administrator, f_enabled_mark, f_creator_time, \
f_creator_user_id, f_tenant_id) \
VALUES ({}, {}, '管理员', '1', '首次启动引导', {}, {}, 1, 1, NOW(), 'admin', '0')",
p(1, "character varying(50)"),
p(2, "character varying(50)"),
p(3, "character varying(50)"),
p(4, "character varying(50)"),
);
let params: Vec<String> = vec![id.clone(), account.clone(), password_hash, secretkey];
let refs = bind_refs(&params);
crate::platform::db::exec_params(&state.db, &sql, &refs).await
.map_err(|e| AccountError::Server(format!("引导管理员账号失败: {}", e)))?;
// ④ 绑定角色(`f_object_type='user'` + `f_object_id=<admin f_id>`)⇒ 管理员具备 `user` 角色码。
let role_id = query_scalar_text(
state.db.as_ref(),
"SELECT f_id::text FROM base_role WHERE f_en_code = CAST($1 AS text) LIMIT 1",
&[&BOOTSTRAP_ADMIN_ROLE.to_string()],
)
.await
.ok()
.flatten();
if let Some(role_id) = role_id {
let rel_sql = format!(
"INSERT INTO base_role_relation (f_id, f_role_id, f_object_type, f_object_id, \
f_sort_code, f_creator_time, f_creator_user_id, f_delete_mark, f_tenant_id) \
SELECT {}, {}, 'user', {}, 0, NOW(), 'admin', NULL, '0' \
WHERE NOT EXISTS (SELECT 1 FROM base_role_relation \
WHERE f_object_type = 'user' AND f_object_id = {})",
p(1, "character varying(50)"),
p(2, "character varying(50)"),
p(3, "character varying(50)"),
p(3, "character varying(50)"),
);
let params: Vec<String> = vec![new_j7_id(), role_id, id.clone()];
let refs: Vec<&(dyn pglite::ToSql + Sync)> = params
.iter()
.map(|s| s as &(dyn pglite::ToSql + Sync))
.collect();
crate::platform::db::exec_params(&state.db, &rel_sql, &refs).await
.map_err(|e| AccountError::Server(format!("绑定管理员角色失败: {}", e)))?;
}
Ok(AccountBootstrap {
admin_created: true,
admin_account: account,
})
}
/// 是否**还有管理员账号在用默认口令**(`admin`)。
///
/// 🔴 供 `TDC_STRICT_SECRETS=1` 的护栏用:默认口令是**公开已知**的
/// ⇒ 生产档必须拒绝启动;口令改过(或引导时用环境变量覆盖过)就放行。
/// 判据是「**任何管理员账号**的散列等于默认散列」⇒ 换个账号名继续用
/// 默认口令**也**会被拦(fail-closed)。
pub async fn bootstrap_admin_uses_default_password(state: &AppState) -> bool {
let default_md5 = md5_hex(BOOTSTRAP_ADMIN_PASSWORD);
let sql = format!(
"SELECT f_password, f_secretkey FROM base_user \
WHERE COALESCE(f_is_administrator, 0) = 1 AND {ALIVE_USER}"
);
let rows = {
let _g = state.db_lock.lock().await;
query_json_params(state.db.as_ref(), &sql, &[]).await
};
let Ok(rows) = rows else {
// 🔴 查不出来 ⇒ **fail-closed**(当作「还在用默认口令」⇒ 生产档拒绝启动)。
return true;
};
rows.iter().any(|r| {
let hash = r.get("f_password").and_then(|v| v.as_str()).unwrap_or("");
let key = r.get("f_secretkey").and_then(|v| v.as_str()).unwrap_or("");
!key.is_empty() && constant_time_eq(&official_password_hash(&default_md5, key), hash)
})
}
#[cfg(test)]
mod tests {
use super::*;
/// 🔴 **上游公式自证**(向量用系统 `md5` 独立算出,不是本仓自己算自己证):
///
/// | 明文 | `md5(明文)` | secretkey | 期望 `f_password` |
/// |---|---|---|---|
/// | `123456` | `e10adc3949ba59abbe56e057f20f883e` | `A1B2C3D4` | `f5aed9cb34072037071de9e90f3ef650` |
/// | `123456` | `e10adc3949ba59abbe56e057f20f883e` | `00-11-22` | `cf1150bde4e2f01f1f0a4558a800cbb0` |
///
/// (secretkey 故意用**大写**与**带连字符**两种形状 ⇒ 同时钉住 `lower()` 归一。)
#[test]
fn official_password_hash_matches_the_upstream_formula() {
assert_eq!(
official_password_hash(&md5_hex("123456"), "A1B2C3D4"),
"f5aed9cb34072037071de9e90f3ef650"
);
assert_eq!(
official_password_hash(&md5_hex("123456"), "00-11-22"),
"cf1150bde4e2f01f1f0a4558a800cbb0"
);
}
/// 🔴 公式**不是**裸 md5(否则整条「双 md5」白做了)。
#[test]
fn official_password_hash_is_not_the_bare_md5() {
let bare = md5_hex("123456");
let with_key = official_password_hash(&bare, "A1B2C3D4");
assert_ne!(with_key, bare);
}
/// 公式对 secretkey **大小写不敏感**(上游 `secretkey.toLowerCase()`)。
#[test]
fn official_password_hash_lowercases_both_sides() {
let bare = md5_hex("123456");
assert_eq!(
official_password_hash(&bare, "A1B2C3D4"),
official_password_hash(&bare, "a1b2c3d4")
);
assert_eq!(
official_password_hash(&bare.to_uppercase(), "A1B2C3D4"),
official_password_hash(&bare, "A1B2C3D4")
);
}
/// j7 的 id 形状:36 字符、带连字符、全大写 hex。
#[test]
fn j7_id_shape_matches_the_upstream_uuid_uppercase() {
let id = new_j7_id();
assert_eq!(id.len(), 36, "UUID 形状:{}", id);
assert_eq!(id.chars().filter(|c| *c == '-').count(), 4);
assert!(
id.chars().all(|c| c.is_ascii_hexdigit() || c == '-'),
"j7 id 应是 hex + 连字符:{}",
id
);
assert_ne!(id, new_j7_id(), "每次都应是新的随机 id");
}
/// 角色判据三件套照上游(`tdsReadOnly` 判据在、种子不种 ⇒ D9 / S7)。
#[test]
fn role_codes_are_the_upstream_three() {
assert_eq!(ROLE_CODES, &["tdcProvider", "tdcConsumer", "tdsReadOnly"]);
// 种子里的三个角色(上游 `connector_seed` 的三行)
let seeded: Vec<&str> = SEED_ROLES.iter().map(|(_, _, code)| *code).collect();
assert_eq!(seeded, &["tdcProvider", "tdcConsumer", "user"]);
// 🔴 判据里有、种子里没有的悬空码
assert!(ROLE_CODES.contains(&"tdsReadOnly"));
assert!(!seeded.contains(&"tdsReadOnly"));
// 🔴 种子里有、判据里没有的(`user` 角色绑上去也查不出角色码 —— 上游同口径)
assert!(seeded.contains(&"user"));
assert!(!ROLE_CODES.contains(&"user"));
}
/// 引导管理员绑的角色码 = `user`(上游 `connector_seed` 的第三个角色)。
#[test]
fn bootstrap_admin_binds_the_user_role() {
assert_eq!(BOOTSTRAP_ADMIN_ROLE, "user");
}
/// 行映射:`f_gender` 是 varchar ⇒ 读成数字;读不出数字 ⇒ 0。
#[test]
fn row_mapping_reads_gender_as_a_number() {
let row = serde_json::json!({
"f_id": "U-1",
"f_account": "admin",
"f_real_name": "管理员",
"f_gender": "1",
"f_mobile_phone": null,
"f_description": null,
"f_enabled_mark": 1,
"f_is_administrator": 1,
"f_password": "hash",
"f_secretkey": "key",
"f_creator_time": "2026-10-26 10:00:00",
});
let a = row_to_account(&row).expect("应能映射");
assert_eq!(a.id, "U-1");
assert_eq!(a.gender, 1);
assert!(a.administrator);
assert_eq!(a.enabled_mark, 1);
assert_eq!(a.creator_time, "2026-10-26 10:00:00");
assert!(a.mobile_phone.is_none());
let mut bad = row.clone();
bad["f_gender"] = serde_json::json!("男");
assert_eq!(row_to_account(&bad).unwrap().gender, 0);
}
}