use crate::error::GarrisonResult;
use crate::session::GarrisonSession;
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use std::sync::Arc;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DeviceSession {
pub device: String,
pub login_id: String,
pub token: String,
pub ip: Option<String>,
pub user_agent: Option<String>,
pub last_active_at: i64,
}
pub struct DeviceManager {
session: Arc<GarrisonSession>,
}
impl DeviceManager {
pub fn new(session: Arc<GarrisonSession>) -> Self {
Self { session }
}
pub async fn list_devices(&self, login_id: &str) -> GarrisonResult<Vec<DeviceSession>> {
let tokens = self.session.get_tokens_by_login_id(login_id);
let mut devices = Vec::with_capacity(tokens.len());
for token in tokens {
if let Some(ts) = self.session.get_token_session(&token).await? {
devices.push(DeviceSession {
device: ts.device.unwrap_or_default(),
login_id: ts.login_id,
token: ts.token,
ip: ts.ip,
user_agent: ts.user_agent,
last_active_at: ts.last_active_at,
});
}
}
Ok(devices)
}
pub async fn kickout_device(&self, login_id: &str, device: &str) -> GarrisonResult<()> {
self.session.kickout_by_device(login_id, device).await
}
}
pub fn device_fingerprint(user_agent: &str, ip: &str) -> String {
let mut hasher = Sha256::new();
hasher.update(user_agent.as_bytes());
hasher.update([0x1f]);
hasher.update(ip.as_bytes());
let result = hasher.finalize();
hex_prefix_16(&result)
}
#[derive(Debug, Clone, Copy)]
pub struct DeviceFingerprintInput<'a> {
pub user_agent: &'a str,
pub ip: &'a str,
pub accept_language: Option<&'a str>,
pub sec_ch_ua: Option<&'a str>,
pub sec_ch_ua_platform: Option<&'a str>,
}
impl<'a> DeviceFingerprintInput<'a> {
pub fn new(
user_agent: &'a str,
ip: &'a str,
accept_language: Option<&'a str>,
sec_ch_ua: Option<&'a str>,
sec_ch_ua_platform: Option<&'a str>,
) -> Self {
Self {
user_agent,
ip,
accept_language,
sec_ch_ua,
sec_ch_ua_platform,
}
}
pub fn from_ua_ip(user_agent: &'a str, ip: &'a str) -> Self {
Self {
user_agent,
ip,
accept_language: None,
sec_ch_ua: None,
sec_ch_ua_platform: None,
}
}
}
fn hex_prefix_16(hash: &[u8]) -> String {
const HEX: &[u8; 16] = b"0123456789abcdef";
let mut out = String::with_capacity(32);
for b in hash.iter().take(16) {
out.push(HEX[(b >> 4) as usize] as char);
out.push(HEX[(b & 0x0f) as usize] as char);
}
out
}
pub fn device_fingerprint_rich(input: &DeviceFingerprintInput<'_>) -> String {
let mut hasher = Sha256::new();
const SEP: u8 = 0x1f;
hasher.update(input.user_agent.as_bytes());
hasher.update([SEP]);
hasher.update(input.ip.as_bytes());
hasher.update([SEP]);
match input.accept_language {
Some(v) => hasher.update(v.as_bytes()),
None => hasher.update([0x00]),
}
hasher.update([SEP]);
match input.sec_ch_ua {
Some(v) => hasher.update(v.as_bytes()),
None => hasher.update([0x00]),
}
hasher.update([SEP]);
match input.sec_ch_ua_platform {
Some(v) => hasher.update(v.as_bytes()),
None => hasher.update([0x00]),
}
let result = hasher.finalize();
hex_prefix_16(&result)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn device_fingerprint_deterministic() {
let fp1 = device_fingerprint("Mozilla/5.0 Chrome", "192.168.1.1");
let fp2 = device_fingerprint("Mozilla/5.0 Chrome", "192.168.1.1");
assert_eq!(fp1, fp2, "相同输入应生成相同指纹");
}
#[test]
fn device_fingerprint_different_inputs_different_output() {
let fp1 = device_fingerprint("Mozilla/5.0 Chrome", "192.168.1.1");
let fp2 = device_fingerprint("Mozilla/5.0 Firefox", "192.168.1.1");
assert_ne!(fp1, fp2, "不同 UA 应生成不同指纹");
let fp3 = device_fingerprint("Mozilla/5.0 Chrome", "10.0.0.1");
assert_ne!(fp1, fp3, "不同 IP 应生成不同指纹");
}
#[test]
fn device_fingerprint_length_is_32() {
let fp = device_fingerprint("TestAgent", "127.0.0.1");
assert_eq!(fp.len(), 32, "指纹应为 32 字符(16 字节 hex)");
}
#[test]
fn device_fingerprint_delimiter_prevents_concat_ambiguity() {
let fp1 = device_fingerprint("ab", "c");
let fp2 = device_fingerprint("a", "bc");
assert_ne!(fp1, fp2, "分隔符应防止指纹的维度拼接歧义");
}
#[test]
fn a10_rich_fingerprint_deterministic() {
let input = DeviceFingerprintInput::new(
"Mozilla/5.0 Chrome",
"192.168.1.1",
Some("zh-CN,zh;q=0.9"),
Some("\"Chromium\";v=\"120\""),
Some("\"Windows\""),
);
let fp1 = device_fingerprint_rich(&input);
let fp2 = device_fingerprint_rich(&input);
assert_eq!(fp1, fp2, "相同输入应生成相同指纹");
}
#[test]
fn a10_rich_fingerprint_length_is_32() {
let input = DeviceFingerprintInput::new("UA", "IP", None, None, None);
let fp = device_fingerprint_rich(&input);
assert_eq!(fp.len(), 32, "强化指纹应为 32 字符(16 字节 hex)");
}
#[test]
fn a10_rich_fingerprint_spoofing_partial_dimensions_detected() {
let base = DeviceFingerprintInput::new(
"Mozilla/5.0 Chrome",
"192.168.1.1",
Some("zh-CN,zh;q=0.9"),
Some("\"Chromium\";v=\"120\""),
Some("\"Windows\""),
);
let base_fp = device_fingerprint_rich(&base);
let spoof_ua = DeviceFingerprintInput::new(
"Mozilla/5.0 Firefox",
"192.168.1.1",
Some("zh-CN,zh;q=0.9"),
Some("\"Chromium\";v=\"120\""),
Some("\"Windows\""),
);
assert_ne!(
device_fingerprint_rich(&spoof_ua),
base_fp,
"伪造 UA 应改变指纹"
);
let spoof_ip = DeviceFingerprintInput::new(
"Mozilla/5.0 Chrome",
"10.0.0.1",
Some("zh-CN,zh;q=0.9"),
Some("\"Chromium\";v=\"120\""),
Some("\"Windows\""),
);
assert_ne!(
device_fingerprint_rich(&spoof_ip),
base_fp,
"伪造 IP 应改变指纹"
);
let spoof_al = DeviceFingerprintInput::new(
"Mozilla/5.0 Chrome",
"192.168.1.1",
Some("en-US,en;q=0.9"),
Some("\"Chromium\";v=\"120\""),
Some("\"Windows\""),
);
assert_ne!(
device_fingerprint_rich(&spoof_al),
base_fp,
"伪造 Accept-Language 应改变指纹"
);
let spoof_chua = DeviceFingerprintInput::new(
"Mozilla/5.0 Chrome",
"192.168.1.1",
Some("zh-CN,zh;q=0.9"),
Some("\"Firefox\";v=\"121\""),
Some("\"Windows\""),
);
assert_ne!(
device_fingerprint_rich(&spoof_chua),
base_fp,
"伪造 sec-ch-ua 应改变指纹"
);
let spoof_plat = DeviceFingerprintInput::new(
"Mozilla/5.0 Chrome",
"192.168.1.1",
Some("zh-CN,zh;q=0.9"),
Some("\"Chromium\";v=\"120\""),
Some("\"macOS\""),
);
assert_ne!(
device_fingerprint_rich(&spoof_plat),
base_fp,
"伪造 sec-ch-ua-platform 应改变指纹"
);
}
#[test]
fn a10_rich_fingerprint_none_vs_some_empty_differ() {
let with_none = DeviceFingerprintInput::new("UA", "IP", None, None, None);
let with_empty = DeviceFingerprintInput::new("UA", "IP", Some(""), Some(""), Some(""));
assert_ne!(
device_fingerprint_rich(&with_none),
device_fingerprint_rich(&with_empty),
"None 与 Some(\"\") 应产生不同指纹(哨兵字节区分)"
);
}
#[test]
fn a10_rich_fingerprint_from_ua_ip_equivalent_to_none() {
let input1 = DeviceFingerprintInput::from_ua_ip("UA", "IP");
let input2 = DeviceFingerprintInput::new("UA", "IP", None, None, None);
assert_eq!(
device_fingerprint_rich(&input1),
device_fingerprint_rich(&input2),
"from_ua_ip 应等价于显式 None 构造"
);
}
#[test]
fn a10_rich_fingerprint_delimiter_prevents_concat_ambiguity() {
let ambiguous1 = DeviceFingerprintInput::from_ua_ip("ab", "c");
let ambiguous2 = DeviceFingerprintInput::from_ua_ip("a", "bc");
assert_ne!(
device_fingerprint_rich(&ambiguous1),
device_fingerprint_rich(&ambiguous2),
"分隔符应防止维度拼接歧义"
);
}
fn make_device_session(timeout: u64, active_timeout: u64) -> Arc<GarrisonSession> {
use crate::dao::tests::MockDao;
let dao: Arc<dyn crate::dao::GarrisonDao> = Arc::new(MockDao::new());
Arc::new(GarrisonSession::new(dao, timeout, active_timeout, 0))
}
#[tokio::test]
async fn list_devices_returns_all_active_sessions() {
let session = make_device_session(3600, 86400);
session.create("user-001", "token-1").await.unwrap();
session.create("user-001", "token-2").await.unwrap();
let mgr = DeviceManager::new(session);
let devices = mgr.list_devices("user-001").await.unwrap();
assert_eq!(devices.len(), 2, "应有 2 个设备会话");
for d in &devices {
assert_eq!(d.login_id, "user-001");
assert!(!d.token.is_empty());
}
}
#[tokio::test]
async fn list_devices_empty_when_no_sessions() {
let session = make_device_session(3600, 86400);
let mgr = DeviceManager::new(session);
let devices = mgr.list_devices("nonexistent-user").await.unwrap();
assert!(devices.is_empty(), "无会话时应返回空列表");
}
#[tokio::test]
async fn kickout_device_removes_matching_session() {
let session = make_device_session(3600, 86400);
let params = crate::stp::LoginParams {
device: Some("web".to_string()),
..Default::default()
};
session
.create_token_session("user-kickout-001", "token-with-device", ¶ms)
.await
.unwrap();
session
.create("user-kickout-001", "token-no-device")
.await
.unwrap();
let mgr = DeviceManager::new(session.clone());
let result = mgr.kickout_device("user-kickout-001", "web").await;
assert!(result.is_ok(), "kickout_device 应成功");
let removed = session
.get_token_session("token-with-device")
.await
.unwrap();
assert!(removed.is_none(), "device 匹配的会话应被踢出");
let kept = session.get_token_session("token-no-device").await.unwrap();
assert!(kept.is_some(), "device 不匹配的会话应保留");
}
}