use super::{
CreatedQrLogin, QrLoginAction, QrLoginConfig, QrLoginPollOutcome, QrLoginScanView,
QrLoginService, QrLoginSessionData, QrLoginStatus, QrLoginWebContext,
};
use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use crate::loc;
use base64::engine::general_purpose::URL_SAFE as BASE64_URL_SAFE;
use base64::Engine;
use hmac::{Hmac, KeyInit, Mac};
use sha2::Sha256;
use std::sync::Arc;
use subtle::ConstantTimeEq;
use uuid::Uuid;
type HmacSha256 = Hmac<Sha256>;
const SESSION_KEY_PREFIX: &str = "garrison:qrlogin:session:";
const CONFIRM_KEY_PREFIX: &str = "garrison:qrlogin:confirm:";
fn is_hex64(s: &str) -> bool {
s.len() == 64 && s.bytes().all(|b| b.is_ascii_hexdigit())
}
const BIND_KEY_PREFIX: &str = "garrison:qrlogin:bind:";
fn session_key(qr_id: &str) -> String {
format!("{SESSION_KEY_PREFIX}{qr_id}")
}
fn confirm_key(token: &str) -> String {
format!("{CONFIRM_KEY_PREFIX}{token}")
}
impl Default for QrLoginConfig {
fn default() -> Self {
Self {
session_ttl_secs: 120,
confirm_ttl_secs: 60,
allowed_domains: None,
}
}
}
impl std::fmt::Debug for QrLoginService {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("QrLoginService")
.field("dao", &"<dyn GarrisonDao>")
.field("secret", &"[REDACTED]")
.field("config", &self.config)
.finish()
}
}
fn device_label(user_agent: Option<&str>) -> String {
let Some(ua) = user_agent else {
return "Unknown device".to_string();
};
if ua.contains("Edg") {
"Edge".to_string()
} else if ua.contains("Firefox") {
"Firefox".to_string()
} else if ua.contains("Chrome") {
"Chrome".to_string()
} else if ua.contains("Safari") {
"Safari".to_string()
} else {
"Unknown device".to_string()
}
}
fn extract_host(qr_content: &str) -> Option<String> {
let rest = qr_content.split_once("://")?.1;
let host_end = rest.find(['/', '?']).unwrap_or(rest.len());
let host = &rest[..host_end];
if host.is_empty() {
None
} else {
Some(host.to_string())
}
}
fn extract_ticket(qr_content: &str) -> Option<&str> {
let idx = qr_content.find("t=")?;
let value = &qr_content[idx + 2..];
let value = value.split('&').next().unwrap_or(value);
if value.is_empty() {
None
} else {
Some(value)
}
}
impl QrLoginService {
pub fn new(dao: Arc<dyn GarrisonDao>, secret: impl Into<String>) -> GarrisonResult<Self> {
let secret: String = secret.into();
if secret.is_empty() {
return Err(GarrisonError::InvalidParam(loc!(
"qrlogin-secret-empty",
"QR login HMAC secret must not be empty".to_string()
)));
}
if secret.len() < 32 {
return Err(GarrisonError::InvalidParam(loc!(
"qrlogin-secret-too-short",
"QR login HMAC secret must be at least 32 bytes".to_string()
)));
}
Ok(Self {
dao,
secret,
config: QrLoginConfig::default(),
#[cfg(feature = "listener")]
listener_manager: None,
})
}
#[must_use]
pub fn with_config(mut self, config: QrLoginConfig) -> Self {
self.config = config;
self
}
#[cfg(feature = "listener")]
#[must_use]
pub fn with_listener_manager(
mut self,
listener_manager: Arc<crate::listener::GarrisonListenerManager>,
) -> Self {
self.listener_manager = Some(listener_manager);
self
}
pub async fn create_session(&self, web: QrLoginWebContext) -> GarrisonResult<CreatedQrLogin> {
let qr_id = Self::random_hex64();
let sig = self.sign_ticket(&qr_id)?;
let ticket = format!("{qr_id}.{sig}");
let qr_content = match self.config.allowed_domains.as_ref().and_then(|d| d.first()) {
Some(domain) => format!("https://{domain}/qrlogin/confirm?t={ticket}"),
None => format!("garrison://qrlogin?t={ticket}"),
};
#[cfg(feature = "listener")]
let request_context = web.ip.clone().map(|ip| crate::listener::RequestContext {
ip: Some(ip),
user_agent: web.user_agent.clone(),
});
let data = QrLoginSessionData {
qr_id: qr_id.clone(),
status: QrLoginStatus::Pending,
tenant_id: 0,
app_login_id: None,
confirm_token_hash: None,
web,
};
let value = serde_json::to_string(&data)
.map_err(|e| GarrisonError::Internal(format!("qrlogin-session-serialize::{}", e)))?;
let key = session_key(&qr_id);
if !self
.dao
.set_if_absent(&key, &value, self.config.session_ttl_secs)
.await?
{
return Err(GarrisonError::Internal(
"qrlogin-session-id-collision".to_string(),
));
}
let bind_token = Self::random_hex64();
let bind_key = format!("{BIND_KEY_PREFIX}{bind_token}");
if !self
.dao
.set_if_absent(&bind_key, &qr_id, self.config.session_ttl_secs)
.await?
{
return Err(GarrisonError::Internal(
"qrlogin-bind-token-collision".to_string(),
));
}
let created = CreatedQrLogin {
qr_id,
bind_token,
qr_content,
expires_in_secs: self.config.session_ttl_secs,
};
#[cfg(feature = "listener")]
self.broadcast(crate::listener::GarrisonEvent::QrLoginCreated {
qr_id: Self::mask_id(&created.qr_id),
request_context,
})
.await;
Ok(created)
}
pub async fn scan(
&self,
qr_content: &str,
app_login_id: &str,
app_context: Option<(String, String)>,
) -> GarrisonResult<QrLoginScanView> {
#[cfg(not(feature = "listener"))]
let _ = app_context;
if let Some(domains) = &self.config.allowed_domains {
let host_ok = extract_host(qr_content)
.map(|host| domains.iter().any(|d| d.eq_ignore_ascii_case(&host)))
.unwrap_or(false);
if !host_ok {
return Err(GarrisonError::InvalidParam(loc!(
"qrlogin-domain-not-allowed",
"QR login ticket domain is not allowed".to_string()
)));
}
}
let ticket = extract_ticket(qr_content).ok_or_else(Self::invalid_ticket)?;
let qr_id = self.verify_ticket_signature(ticket)?;
let (data, remaining_secs) = self
.load_session_with_ttl(&qr_id)
.await?
.ok_or_else(|| Self::session_err("qrlogin-session-not-found"))?;
match data.status {
QrLoginStatus::Pending => {},
QrLoginStatus::Scanned | QrLoginStatus::Confirmed => {
return Err(Self::session_err("qrlogin-already-scanned"));
},
QrLoginStatus::Cancelled => return Err(Self::session_err("qrlogin-cancelled")),
}
let confirm_token = Self::random_hex64();
if !self
.dao
.set_if_absent(
&confirm_key(&confirm_token),
&qr_id,
self.config.confirm_ttl_secs,
)
.await?
{
return Err(GarrisonError::Internal(
"qrlogin-confirm-token-collision".to_string(),
));
}
let updated = QrLoginSessionData {
status: QrLoginStatus::Scanned,
app_login_id: Some(app_login_id.to_string()),
confirm_token_hash: Some(Self::token_digest(&confirm_token)),
..data
};
self.write_session(&qr_id, &updated, remaining_secs).await?;
#[cfg(feature = "listener")]
self.broadcast(crate::listener::GarrisonEvent::QrLoginScanned {
qr_id: Self::mask_id(&qr_id),
app_login_id: app_login_id.to_string(),
request_context: app_context.map(|(ip, user_agent)| crate::listener::RequestContext {
ip: Some(ip),
user_agent: Some(user_agent),
}),
})
.await;
Ok(QrLoginScanView {
confirm_token,
web_device_label: device_label(updated.web.user_agent.as_deref()),
web_created_at_ms: updated.web.created_at_ms,
expires_in_secs: self.config.confirm_ttl_secs,
})
}
pub async fn confirm(
&self,
confirm_token: &str,
app_login_id: &str,
action: QrLoginAction,
app_context: Option<(String, String)>,
) -> GarrisonResult<QrLoginStatus> {
#[cfg(not(feature = "listener"))]
let _ = app_context;
let qr_id = self
.dao
.get_and_delete(&confirm_key(confirm_token))
.await?
.ok_or_else(|| Self::session_err("qrlogin-confirm-token-invalid"))?;
let (data, remaining_secs) = self
.load_session_with_ttl(&qr_id)
.await?
.ok_or_else(|| Self::session_err("qrlogin-already-consumed"))?;
if data.confirm_token_hash.as_deref() != Some(Self::token_digest(confirm_token).as_str()) {
return Err(Self::session_err("qrlogin-confirm-token-invalid"));
}
if data.app_login_id.as_deref() != Some(app_login_id) {
return Err(Self::session_err("qrlogin-confirm-token-invalid"));
}
let new_status = match (action, data.status) {
(QrLoginAction::Confirm, QrLoginStatus::Scanned) => QrLoginStatus::Confirmed,
(QrLoginAction::Confirm, QrLoginStatus::Pending) => {
return Err(Self::session_err("qrlogin-not-scanned"));
},
(QrLoginAction::Confirm, QrLoginStatus::Cancelled) => {
return Err(Self::session_err("qrlogin-cancelled"));
},
(QrLoginAction::Confirm, QrLoginStatus::Confirmed) => {
return Err(Self::session_err("qrlogin-already-consumed"));
},
(QrLoginAction::Cancel, QrLoginStatus::Pending | QrLoginStatus::Scanned) => {
QrLoginStatus::Cancelled
},
(QrLoginAction::Cancel, QrLoginStatus::Cancelled) => {
return Err(Self::session_err("qrlogin-cancelled"));
},
(QrLoginAction::Cancel, QrLoginStatus::Confirmed) => {
return Err(Self::session_err("qrlogin-already-consumed"));
},
};
let updated = QrLoginSessionData {
status: new_status,
..data
};
self.write_session(&qr_id, &updated, remaining_secs).await?;
#[cfg(feature = "listener")]
{
let app_login_id = updated.app_login_id.clone().unwrap_or_default();
let request_context =
app_context.map(|(ip, user_agent)| crate::listener::RequestContext {
ip: Some(ip),
user_agent: Some(user_agent),
});
let event = if action == QrLoginAction::Confirm {
crate::listener::GarrisonEvent::QrLoginConfirmed {
qr_id: Self::mask_id(&qr_id),
app_login_id,
request_context,
}
} else {
crate::listener::GarrisonEvent::QrLoginCancelled {
qr_id: Self::mask_id(&qr_id),
app_login_id,
request_context,
}
};
self.broadcast(event).await;
}
Ok(new_status)
}
pub async fn poll(&self, qr_id: &str, bind_token: &str) -> GarrisonResult<QrLoginPollOutcome> {
if !is_hex64(qr_id) || !is_hex64(bind_token) {
return Ok(QrLoginPollOutcome::Expired);
}
let Some((data, _)) = self.load_session_with_ttl(qr_id).await? else {
return Ok(QrLoginPollOutcome::Expired);
};
let bind_ok = |consumed: bool| async move {
let bound = if consumed {
self.dao
.get_and_delete(&format!("{BIND_KEY_PREFIX}{bind_token}"))
.await?
} else {
self.dao
.get(&format!("{BIND_KEY_PREFIX}{bind_token}"))
.await?
};
Ok::<_, crate::error::GarrisonError>(matches!(bound,
Some(b) if bool::from(b.as_bytes().ct_eq(qr_id.as_bytes()))))
};
match data.status {
QrLoginStatus::Pending => {
if bind_ok(false).await? {
Ok(QrLoginPollOutcome::Pending)
} else {
Ok(QrLoginPollOutcome::Expired)
}
},
QrLoginStatus::Scanned => {
if bind_ok(false).await? {
Ok(QrLoginPollOutcome::Scanned)
} else {
Ok(QrLoginPollOutcome::Expired)
}
},
QrLoginStatus::Cancelled => {
if bind_ok(false).await? {
Ok(QrLoginPollOutcome::Cancelled)
} else {
Ok(QrLoginPollOutcome::Expired)
}
},
QrLoginStatus::Confirmed => {
if !bind_ok(true).await? {
return Ok(QrLoginPollOutcome::Expired);
}
match self.dao.get_and_delete(&session_key(qr_id)).await {
Ok(Some(_)) => Ok(QrLoginPollOutcome::Confirmed {
login_id: data.app_login_id.unwrap_or_default(),
tenant_id: data.tenant_id,
}),
Ok(None) => Ok(QrLoginPollOutcome::Expired),
Err(e) => {
let _ = self
.dao
.set(
&format!("{BIND_KEY_PREFIX}{bind_token}"),
qr_id,
self.config.session_ttl_secs,
)
.await;
Err(e)
},
}
},
}
}
pub(crate) async fn load_session_with_ttl(
&self,
qr_id: &str,
) -> GarrisonResult<Option<(QrLoginSessionData, u64)>> {
let Some((json, ttl)) = self.dao.get_with_ttl(&session_key(qr_id)).await? else {
return Ok(None);
};
let data: QrLoginSessionData = serde_json::from_str(&json)
.map_err(|e| GarrisonError::Internal(format!("qrlogin-session-parse::{}", e)))?;
let remaining = ttl
.map(|d| d.as_secs())
.filter(|s| *s > 0)
.unwrap_or(self.config.session_ttl_secs);
Ok(Some((data, remaining)))
}
#[cfg(test)]
pub(crate) async fn load_session(
&self,
qr_id: &str,
) -> GarrisonResult<Option<QrLoginSessionData>> {
Ok(self.load_session_with_ttl(qr_id).await?.map(|(d, _)| d))
}
#[cfg(test)]
pub(crate) async fn store_confirm_token_for_test(&self, token: &str, qr_id: &str) {
self.dao
.set(&confirm_key(token), qr_id, self.config.confirm_ttl_secs)
.await
.expect("test confirm token set should succeed");
if let Some((mut data, remaining)) = self.load_session_with_ttl(qr_id).await.unwrap() {
data.confirm_token_hash = Some(Self::token_digest(token));
data.app_login_id = Some("user-1".to_string());
self.write_session(qr_id, &data, remaining)
.await
.expect("test session write-back should succeed");
}
}
async fn write_session(
&self,
qr_id: &str,
data: &QrLoginSessionData,
remaining_secs: u64,
) -> GarrisonResult<()> {
let value = serde_json::to_string(data)
.map_err(|e| GarrisonError::Internal(format!("qrlogin-session-serialize::{}", e)))?;
self.dao
.set(&session_key(qr_id), &value, remaining_secs)
.await
}
pub(super) fn sign_ticket(&self, random_part: &str) -> GarrisonResult<String> {
let mut mac = HmacSha256::new_from_slice(self.secret.as_bytes())
.map_err(|e| GarrisonError::Internal(format!("qrlogin-ticket-hmac-init::{}", e)))?;
mac.update(random_part.as_bytes());
Ok(BASE64_URL_SAFE.encode(mac.finalize().into_bytes()))
}
pub(super) fn verify_ticket_signature(&self, ticket: &str) -> GarrisonResult<String> {
let (random_part, sig_b64) = ticket.split_once('.').ok_or_else(Self::invalid_ticket)?;
let mut mac = HmacSha256::new_from_slice(self.secret.as_bytes())
.map_err(|e| GarrisonError::Internal(format!("qrlogin-ticket-hmac-init::{}", e)))?;
mac.update(random_part.as_bytes());
let sig_bytes = BASE64_URL_SAFE
.decode(sig_b64)
.map_err(|_| Self::invalid_ticket())?;
mac.verify_slice(&sig_bytes)
.map_err(|_| Self::invalid_ticket())?;
Ok(random_part.to_string())
}
pub(super) fn random_hex64() -> String {
format!("{}{}", Uuid::new_v4().simple(), Uuid::new_v4().simple())
}
#[cfg(feature = "listener")]
pub(super) fn mask_id(id: &str) -> String {
let mut out: String = id.chars().take(8).collect();
out.push_str("***");
out
}
#[cfg(feature = "listener")]
async fn broadcast(&self, event: crate::listener::GarrisonEvent) {
if let Some(lm) = &self.listener_manager {
lm.broadcast(&event).await;
}
}
pub(super) fn token_digest(token: &str) -> String {
use sha2::Digest;
let mut hasher = Sha256::new();
hasher.update(token.as_bytes());
hasher
.finalize()
.iter()
.map(|b| format!("{b:02x}"))
.collect()
}
fn invalid_ticket() -> GarrisonError {
GarrisonError::InvalidParam(loc!(
"qrlogin-invalid-ticket",
"QR login ticket signature is invalid".to_string()
))
}
fn session_err(key: &'static str) -> GarrisonError {
GarrisonError::InvalidToken(loc!(
key,
format!(
"QR login session state error: {}",
key.replace("qrlogin-", "")
)
.to_string()
))
}
}