use chrono::{TimeDelta, Utc}; use rocket::request::{FromRequest, Outcome, Request}; use crate::{ CONFIG, api::ApiResult, auth, auth::{BasicJwtClaims, ClientIp}, crypto, db::{ DbConn, models::{SendId, SendOTP}, }, error::{Error, ErrorKind}, mail, }; fn generate_send_access_claims(send_id: &SendId) -> BasicJwtClaims { let time_now = Utc::now(); BasicJwtClaims { nbf: time_now.timestamp(), exp: (time_now + TimeDelta::try_minutes(2).unwrap()).timestamp(), iss: auth::JWT_SEND_ISSUER.to_string(), sub: format!("{send_id}"), } } #[derive(Debug, Serialize, Deserialize)] pub struct SendTokens { pub access_claims: BasicJwtClaims, } impl SendTokens { pub fn as_send_id(access_id: &str) -> Option { data_encoding::BASE64URL_NOPAD .decode(access_id.as_bytes()) .ok() .and_then(|uuid_vec| uuid::Uuid::from_slice(&uuid_vec).ok().map(|u| SendId::from(u.to_string()))) } pub fn to_json(&self) -> serde_json::Value { json!({ "access_token": self.access_claims.token(), "expires_in": self.access_claims.expires_in(), "token_type": "Bearer", "scope": "api.send.access", }) } fn expected_error(msg: &str, error_type: &str) -> ApiResult { let err = json!({ "kind": "expected_server", "error": "invalid_request", "send_access_error_type": error_type, }); Err(Error::new_msg(msg).with_kind(ErrorKind::Json(err)).silent()) } fn invalid_error(msg: &str, error_type: &str, silent: bool) -> ApiResult { let err = json!({ "kind": "expected_server", "error": "invalid_grant", "send_access_error_type": error_type, }); Err(Error::new_msg(msg).with_kind(ErrorKind::Json(err)).with_code(404).with_silent(silent)) } pub async fn generate_tokens( access_id: &str, password: Option, email: Option, otp: Option, ip: &ClientIp, conn: &DbConn, ) -> ApiResult { let Some(send_id) = Self::as_send_id(access_id) else { return Self::invalid_error( &format!("Can't convert {}", access_id.escape_debug()), "send_id_invalid", false, ); }; let Some((send, o_otp)) = SendOTP::find_with_send(&send_id, email.as_ref(), conn).await else { return Self::invalid_error(&format!("Can't find {send_id}"), "send_id_invalid", false); }; if let Some(max_access_count) = send.max_access_count && send.access_count >= max_access_count { return Self::invalid_error(&format!("Send {send_id}, max access reached"), "send_id_invalid", true); } if !send.is_accessible() { return Self::invalid_error(&format!("Send {send_id}, not accessible"), "send_id_invalid", true); } if !CONFIG.mail_enabled() && send.emails.is_some() { return Self::invalid_error( &format!("Send {send_id}, email disabled but require verification"), "send_id_invalid", false, ); } if let Some(mut split) = send.emails.as_ref().map(|s| s.split(',')) { let now = Utc::now().naive_utc(); match email.map(|e| e.trim().to_lowercase()) { Some(e) if split.any(|s| s.trim() == e) => { if let Some(code) = otp { if let Some(db_otp) = o_otp { if crypto::ct_eq(&code, &db_otp.code) && now < db_otp.expiration_date { db_otp.delete(conn).await?; } else { return Self::expected_error("Email OTP required", "email_and_otp_required"); } } else { return Self::invalid_error(&format!("Send {send_id}, disabled"), "send_id_invalid", true); } } else { if let Some(db_otp) = o_otp && now + TimeDelta::try_minutes(1).unwrap() < db_otp.expiration_date { // Code is still valid for a minute do nothing } else { // SEND OTP CODE let code = crypto::generate_email_token(CONFIG.email_token_size()); let send_otp = SendOTP::new(send_id, &e, code.clone()); send_otp.save(conn).await?; if let Err(e) = mail::send_sends_otp(&e, &code).await { drop(send_otp.delete(conn).await); Err(e)?; } } return Self::expected_error("Email OTP required", "email_and_otp_required"); } } Some(_) => return Self::expected_error("Email OTP required", "email_and_otp_required"), None => return Self::expected_error("Email validation required", "email_required"), } } if send.password_hash.is_some() { match password { Some(ref p) if send.check_password(p) => { /* Nothing to do here */ } Some(_) => { return Self::invalid_error( &format!("Send {send_id}, Invalid password from {}", ip.ip), "password_hash_b64_invalid", false, ); } None => return Self::expected_error("Password required", "password_hash_b64_required"), } } Ok(Self { access_claims: generate_send_access_claims(&send_id), }) } } pub struct SendHeaders { pub send_id: SendId, } #[rocket::async_trait] impl<'r> FromRequest<'r> for SendHeaders { type Error = &'static str; async fn from_request(request: &'r Request<'_>) -> Outcome { let headers = request.headers(); // Get access_token let access_token: &str = if let Some(a) = headers.get_one("Authorization") { if let Some(split) = a.rsplit("Bearer ").next() { split } else { err_handler!("No access token provided") } } else { err_handler!("No access token provided") }; // Check JWT token is valid and get send_id let Ok(claims) = auth::decode_send(access_token) else { err_handler!("Invalid claim") }; Outcome::Success(SendHeaders { send_id: claims.sub.into(), }) } }