use std::sync::Arc;
use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use base64::Engine as _;
use serde::Deserialize;
use crate::anchor::{AnchorStore, InMemoryAnchorStore};
use crate::error::RpError;
use crate::nonce::{InMemoryNonceStore, NonceStore};
use crate::session::{verify, RpSession, VerifyParams};
pub struct Authenticator {
nonces: Arc<dyn NonceStore>,
anchors: Arc<dyn AnchorStore>,
}
impl Authenticator {
pub fn new(nonces: Arc<dyn NonceStore>, anchors: Arc<dyn AnchorStore>) -> Self {
Self { nonces, anchors }
}
pub fn in_memory() -> Self {
Self {
nonces: Arc::new(InMemoryNonceStore::new()),
anchors: Arc::new(InMemoryAnchorStore::new()),
}
}
pub fn issue_nonce(&self, now_unix_secs: u64) -> Result<String, RpError> {
self.nonces.issue(now_unix_secs)
}
pub fn authenticate(&self, jwt: &str, params: &VerifyParams) -> Result<RpSession, RpError> {
let session = verify(jwt, params)?;
if !self
.nonces
.consume(¶ms.expected_nonce, params.now_unix_secs)?
{
return Err(RpError::NonceRejected);
}
self.anchors
.check_and_update(&session.did, &session.presented_roster())?;
Ok(session)
}
pub fn authenticate_with_embedded_nonce(
&self,
jwt: &str,
expected_audience: &str,
now_unix_secs: u64,
max_iat_skew_secs: u64,
) -> Result<RpSession, RpError> {
let (verified, nonce) = match mid_verify::verify_mid_response_echoed_nonce(
jwt,
expected_audience,
now_unix_secs,
max_iat_skew_secs,
) {
Ok(v) => v,
Err(e) => {
peek_nonce(jwt)?;
return Err(e.into());
}
};
let session = RpSession::from_verified(verified);
if !self.nonces.consume(&nonce, now_unix_secs)? {
return Err(RpError::NonceRejected);
}
self.anchors
.check_and_update(&session.did, &session.presented_roster())?;
Ok(session)
}
}
pub fn peek_nonce(jwt: &str) -> Result<String, RpError> {
#[derive(Deserialize)]
struct NonceOnly {
nonce: String,
}
let mut segments = jwt.split('.');
let (_header, payload_b64) = match (segments.next(), segments.next(), segments.next()) {
(Some(h), Some(p), Some(_sig)) if segments.next().is_none() => (h, p),
_ => return Err(RpError::MalformedToken),
};
let payload_bytes = URL_SAFE_NO_PAD
.decode(payload_b64)
.map_err(|_| RpError::MalformedToken)?;
let peeked: NonceOnly =
serde_json::from_slice(&payload_bytes).map_err(|_| RpError::MalformedToken)?;
Ok(peeked.nonce)
}