Files
ipass/rust/src/util.rs
T
admin e14d2c6512 feat(domains): 子域名规则固化为 i + 8 位随机数 + dm
管理台「新建域名(直接放行)」的子域名不再是自由输入,改为三段拼装:
固定 i + 8 位随机数字(带「换一个」)+ 固定 dm。

- **规则真源收敛到 config.rs**(ENTERPRISE_ZONE / SUBDOMAIN_PREFIX /
  SUBDOMAIN_SUFFIX / SUBDOMAIN_RAND_DIGITS / SUBDOMAIN_GEN_ATTEMPTS),
  经 GET /api/admin/domains 的 subdomain_rule 下发给面板,前端不硬编码。
- **dm 后缀是硬约束**:conf/nginx.conf 企业域名 server 的 `^(?<subdomain>.+dm)`
  要求捕获组以 dm 结尾,否则域名建出来也匹配不上转发 server。已在
  config.rs / CLAUDE.md / readme §4 三处互标(改一处必改另一处)。
- **API 同规则**:POST /api/admin/domains/create 的 subdomain 缺省/空串即
  自动生成同形态子域名,撞车自动换号重试(最多 5 次);手填撞车直接报错。
  管理台与 API 共用 domains::create_by_admin,规则不会两处漂移。
- **域名列表点完整域名即复制**,且带端口——端口跟随调用方(location.port),
  用 :88 打开面板就复制成 …:88;view() 增 host 字段供面板渲染。
- util::rand_digits 用**拒绝采样**(只收 <250 的字节)保证 0-9 等概率;
  随机源不可用时退化 xorshift,绝不 panic(panic=abort 会打死 worker)。

回归:网关 +13 条(→90),全量 **201 条**(网关 90 + LLM 111)失败 0;
新增段覆盖规则下发 / 形态 ^i[0-9]{8}dm$ / 空串同自动 / 两次随机不同 /
手填合规 / 重复手填 400。另用真实 Chromium 实测布局、换号、非数字过滤、复制。

顺带纠正文档里偏 1 的旧条数(78→90 / 77→111),readme §16 补本条目。
2026-09-12 15:43:12 +08:00

333 lines
11 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.
//! 通用工具:时间 / 随机 / 摘要 / 口令哈希 / 常量时间比较 / 格式化 / 参数解码。
//!
//! 对应旧版的 `lua/util.lua`。其中 `hash_password` 的算法**必须逐位一致**,
//! 否则旧的 `data/users.json` 里的口令哈希将全部失效。
use sha2::{Digest, Sha256};
use crate::config::HASH_ROUNDS;
// ===========================================================================
// 日志
// ===========================================================================
/// 写 nginx error log。
///
/// 形参顺序容易记错:`ngx_log_error_core(level, log, err, fmt, ...)`,
/// 其中 `err` 只在需要附带系统错误号时非 0。
pub fn log_at(level: usize, msg: &str) {
// SAFETY: 传入的 CString 在本调用期间存活;日志接口不持有其引用
unsafe {
let c = std::ffi::CString::new(msg).unwrap_or_default();
let lg = if nginx_sys::ngx_cycle.is_null() {
core::ptr::null_mut()
} else {
(*nginx_sys::ngx_cycle).log
};
nginx_sys::ngx_log_error_core(level, lg, 0, c"%s".as_ptr(), c.as_ptr());
}
}
pub fn log_err(msg: &str) {
log_at(nginx_sys::NGX_LOG_ERR as usize, msg);
}
pub fn log_warn(msg: &str) {
log_at(nginx_sys::NGX_LOG_WARN as usize, msg);
}
pub fn log_notice(msg: &str) {
log_at(nginx_sys::NGX_LOG_NOTICE as usize, msg);
}
// ===========================================================================
// 时间
// ===========================================================================
/// 当前 Unix 时间戳(秒)。
///
/// nginx 的 `ngx_time()` 是宏,bindgen 拿不到;直接走 libc 的 `time()`,
/// 在 Linux/macOS 上都由 vDSO 提供,代价与读一个全局变量相当。
#[inline]
pub fn now() -> i64 {
// SAFETY: time(NULL) 只读系统时钟,无副作用
unsafe { libc::time(core::ptr::null_mut()) as i64 }
}
/// `%Y-%m-%d %H:%M:%S`(本地时区,等价旧版 `os.date`);ts <= 0 返回 `-`
pub fn fmt_time(ts: i64) -> String {
if ts <= 0 {
return "-".to_owned();
}
// SAFETY: 传入有效指针;localtime_r 不返回静态数据,线程安全
unsafe {
let t = ts as libc::time_t;
let mut tm: libc::tm = core::mem::zeroed();
if libc::localtime_r(&t, &mut tm).is_null() {
return "-".to_owned();
}
let mut buf = [0 as libc::c_char; 40];
let fmt = c"%Y-%m-%d %H:%M:%S";
let n = libc::strftime(buf.as_mut_ptr(), buf.len(), fmt.as_ptr(), &tm);
if n == 0 {
return "-".to_owned();
}
core::ffi::CStr::from_ptr(buf.as_ptr()).to_string_lossy().into_owned()
}
}
/// 本地时区的「日窗 id」(年份×1000 + 年内第几天),跨天自动翻窗。
///
/// 限流配额按**本地日**切(面向中国用户,即东八区自然日),不用 UTC——
/// UTC 的日界线在北京时间早上 8 点,「每日额度」会在半夜重置,反直觉。
pub fn day_id(ts: i64) -> i64 {
// SAFETY: localtime_r 只读时间戳并填充调用方的结构体
unsafe {
let t = ts as libc::time_t;
let mut tm: libc::tm = core::mem::zeroed();
if libc::localtime_r(&t, &mut tm).is_null() {
return ts.div_euclid(86400); // 兜底:退化成 UTC 日
}
tm.tm_year as i64 * 1000 + tm.tm_yday as i64
}
}
/// 剩余时长的中文描述(与旧版 `fmt_left` 输出一致)
pub fn fmt_left(seconds: i64) -> String {
if seconds <= 0 {
return "已过期".to_owned();
}
let h = seconds / 3600;
let m = (seconds % 3600) / 60;
let s = seconds % 60;
if h > 0 {
format!("{h} 小时 {m} 分")
} else if m > 0 {
format!("{m} 分 {s} 秒")
} else {
format!("{s} 秒")
}
}
// ===========================================================================
// 随机与十六进制
// ===========================================================================
pub fn to_hex(bytes: &[u8]) -> String {
const HEX: &[u8; 16] = b"0123456789abcdef";
let mut out = String::with_capacity(bytes.len() * 2);
for &b in bytes {
out.push(HEX[(b >> 4) as usize] as char);
out.push(HEX[(b & 0x0f) as usize] as char);
}
out
}
/// 密码学安全随机字节。取不到随机源时返回 None(调用方必须显式处理,
/// **不允许**退化成可预测的伪随机——那等于把 API Key 直接送给攻击者)。
fn rand_bytes(buf: &mut [u8]) -> Option<()> {
getrandom::getrandom(buf).ok()
}
/// `n` 字节随机数的 hex 表示(会话 token 等场景)
pub fn rand_hex(n: usize) -> String {
let mut b = vec![0u8; n];
if rand_bytes(&mut b).is_none() {
let mut seed = now() as u64 ^ 0x2545_f491_4f6c_dd1d;
for byte in b.iter_mut() {
// xorshift:随机源失效时的最后手段,至少不产出常量
seed ^= seed << 13;
seed ^= seed >> 7;
seed ^= seed << 17;
*byte = (seed & 0xff) as u8;
}
}
to_hex(&b)
}
/// 口令盐:16 字节 → 32 位 hex
pub fn gen_salt() -> String {
let mut b = [0u8; 16];
if rand_bytes(&mut b).is_none() {
// 极罕见:随机源不可用。此处不能 panic(会崩掉整个 worker),
// 退化为基于时间的混淆值并让上层记录失败。
let n = now() as u64 ^ 0x9e37_79b9_7f4a_7c15;
b[..8].copy_from_slice(&n.to_le_bytes());
b[8..].copy_from_slice(&n.rotate_left(17).to_le_bytes());
}
to_hex(&b)
}
/// 账号 API Key:`sk_` + 24 字节 → 48 位 hex
pub fn gen_key() -> String {
let mut b = [0u8; 24];
if rand_bytes(&mut b).is_none() {
let n = now() as u64;
for (i, chunk) in b.chunks_mut(8).enumerate() {
chunk.copy_from_slice(&n.rotate_left((i as u32) * 13).to_le_bytes());
}
}
format!("sk_{}", to_hex(&b))
}
/// 域名记录 id:`d_` + 6 字节 → 12 位 hex
pub fn gen_id() -> String {
let mut b = [0u8; 6];
if rand_bytes(&mut b).is_none() {
let n = now() as u32;
b[..4].copy_from_slice(&n.to_le_bytes());
b[4..].copy_from_slice(&(n ^ 0xa5a5).to_le_bytes()[..2]);
}
format!("d_{}", to_hex(&b))
}
/// `n` 位纯数字随机串(每位 0-9 等概率)。
///
/// 用**拒绝采样**而不是 `byte % 10`:256 不是 10 的倍数,直接取模会让 0-5
/// 比 6-9 各多出现约 0.4%(对子域名无害,但没理由留这个瑕疵)。
/// 只接受 `< 250` 的字节(250 = 25×10),落桶严格均匀。
///
/// 非安全场景(子域名后缀),但仍复用 `getrandom`——顺带拿到「随机源不可用」
/// 的统一退化路径,且随机源失效时绝不 panic。
pub fn rand_digits(n: usize) -> String {
let mut out = String::with_capacity(n);
let mut buf = [0u8; 32];
// 随机源不可用时退化为 xorshift(与 rand_hex 同款兜底),仍会终止
let mut seed = now() as u64 ^ 0x2545_f491_4f6c_dd1d;
while out.len() < n {
let take = (n - out.len()).min(buf.len());
let slice = &mut buf[..take];
let ok = rand_bytes(slice).is_some();
if !ok {
for byte in slice.iter_mut() {
seed ^= seed << 13;
seed ^= seed >> 7;
seed ^= seed << 17;
*byte = (seed & 0xff) as u8;
}
}
for &b in slice.iter() {
if b < 250 && out.len() < n {
out.push((b'0' + (b % 10)) as char);
}
}
}
out
}
// ===========================================================================
// 摘要与口令
// ===========================================================================
pub fn sha256_hex(data: &[u8]) -> String {
let mut h = Sha256::new();
h.update(data);
to_hex(&h.finalize())
}
/// 迭代加盐哈希,降低撞库速度。
///
/// 算法(与旧版 `util.hash_password` 完全一致):
/// x = sha256(salt + ":" + password)
/// 重复 HASH_ROUNDS 次:x = sha256(x + salt)
pub fn hash_password(password: &str, salt: &str) -> String {
let mut x = sha256_hex(format!("{salt}:{password}").as_bytes());
for _ in 0..HASH_ROUNDS {
x = sha256_hex(format!("{x}{salt}").as_bytes());
}
x
}
pub fn verify_password(password: &str, salt: &str, expected: &str) -> bool {
ct_eq(&hash_password(password, salt), expected)
}
/// 常量时间比较:无论差异出现在第几位,都在同一轮数内完成。
pub fn ct_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 i in 0..a.len() {
diff |= a[i] ^ b[i];
}
diff == 0
}
// ===========================================================================
// 文本
// ===========================================================================
pub fn trim(v: &str) -> &str {
v.trim()
}
pub fn to_bool(v: Option<&String>) -> bool {
match v {
Some(s) => matches!(s.to_ascii_lowercase().as_str(), "1" | "true" | "on" | "yes"),
None => false,
}
}
/// `sk_12345678...abcd` → `sk_12345...abcd`
pub fn mask_key(key: &str) -> String {
if key.len() < 12 {
return key.to_owned();
}
format!("{}...{}", &key[..8], &key[key.len() - 4..])
}
/// percent-decode(`%XX`)并把 `+` 还原为空格。
///
/// 旧版由 `ngx.req.get_uri_args` / `get_post_args` 自动完成,
/// Rust 侧必须自己实现,否则带中文或特殊字符的参数会解析错误。
pub fn url_decode(input: &str) -> String {
let bytes = input.as_bytes();
let mut out: Vec<u8> = Vec::with_capacity(bytes.len());
let mut i = 0;
while i < bytes.len() {
match bytes[i] {
b'+' => {
out.push(b' ');
i += 1;
}
b'%' if i + 2 < bytes.len() => {
let hi = (bytes[i + 1] as char).to_digit(16);
let lo = (bytes[i + 2] as char).to_digit(16);
match (hi, lo) {
(Some(h), Some(l)) => {
out.push((h * 16 + l) as u8);
i += 3;
}
_ => {
out.push(b'%');
i += 1;
}
}
}
b => {
out.push(b);
i += 1;
}
}
}
String::from_utf8_lossy(&out).into_owned()
}
/// 解析 `a=1&b=2` 形式的键值对(自动 percent-decode)。
pub fn parse_kv(raw: &[u8]) -> Vec<(String, String)> {
let mut out = Vec::new();
let text = String::from_utf8_lossy(raw);
for pair in text.split('&') {
if pair.is_empty() {
continue;
}
let mut it = pair.splitn(2, '=');
let k = it.next().unwrap_or("");
let v = it.next().unwrap_or("");
out.push((url_decode(k), url_decode(v)));
}
out
}