use super::funejson::Value; use super::auth_email_token_hash_email_token::{check_email_token_purpose, hash_email_token}; use super::crypto_constant_time_equal::constant_time_equal; use super::encoding_hex_hex_decode::hex_decode; fn is_hash(h: &str) -> bool { h.len() == 64 && h.bytes().all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)) } /// Where a token's record is among records, and its outcome now: None when unknown. pub fn find_email_token( records: &[EmailTokenRecord], token: &str, purpose: &str, now: i64, ) -> (Option, EmailTokenCheck) { check_email_token_purpose(purpose); if records.iter().any(|r| !is_hash(&r.token_hash)) { panic!("tokenHash must be 64 lowercase hex characters"); } let unknown = EmailTokenCheck { outcome: "unknown".to_string(), record: None }; if token.is_empty() { return (None, unknown); } let attempt = hex_decode(&hash_email_token(token, purpose)); let mut index: Option = None; for (i, r) in records.iter().enumerate() { // Every record is compared, with no early exit. let same = constant_time_equal(&attempt, &hex_decode(&r.token_hash)); if same && index.is_none() { index = Some(i); } } let found = match index { Some(i) if records[i].purpose == purpose => i, _ => return (None, unknown), }; let record = records[found].clone(); let outcome = if record.used_at.is_some() { "used" } else if now >= record.expires_at { "expired" } else { "ok" }; (Some(found), EmailTokenCheck { outcome: outcome.to_string(), record: Some(record) }) } /// What a token from a link is worth now, without using it up. /// /// # Panics /// Panics on a malformed purpose or a stored tokenHash that is not 64 /// lowercase hex characters. pub fn check_email_token(records: &[EmailTokenRecord], token: &str, purpose: &str, now: i64) -> EmailTokenCheck { find_email_token(records, token, purpose, now).1 } pub fn email_token_record_from_value(value: &Value) -> EmailTokenRecord { let text = |key: &str| match value.get(key) { Value::Str(s) => s.clone(), _ => panic!("tokenHash must be 64 lowercase hex characters"), }; EmailTokenRecord { token_hash: text("tokenHash"), purpose: text("purpose"), subject: text("subject"), expires_at: match value.get("expiresAt") { Value::Int(i) => *i, _ => panic!("expiresAt must be a whole number of Unix seconds"), }, used_at: match value.get("usedAt") { Value::Int(i) => Some(*i), _ => None, }, } } pub fn email_token_record_to_value(r: &EmailTokenRecord) -> Value { Value::obj(vec![ ("tokenHash", Value::str(&r.token_hash)), ("purpose", Value::str(&r.purpose)), ("subject", Value::str(&r.subject)), ("expiresAt", Value::Int(r.expires_at)), ("usedAt", match r.used_at { Some(i) => Value::Int(i), None => Value::Null, }), ]) } pub fn email_token_args(args: &[Value]) -> (Vec, String, String, i64) { let records: Vec = match &args[0] { Value::Arr(items) => items.iter().map(email_token_record_from_value).collect(), _ => panic!("records must be a list of EmailTokenRecord"), }; let token = match &args[1] { Value::Str(s) => s.clone(), _ => panic!("token must be a string"), }; let purpose = match &args[2] { Value::Str(s) => s.clone(), _ => panic!("purpose must be 1 to 40 characters of a-z, 0-9 and -"), }; let now = match &args[3] { Value::Int(i) => *i, _ => panic!("now must be a whole number of Unix seconds"), }; (records, token, purpose, now) } pub fn fune_vector(args: &[Value]) -> Value { let (records, token, purpose, now) = email_token_args(args); let check = check_email_token(&records, &token, &purpose, now); Value::obj(vec![ ("outcome", Value::str(&check.outcome)), ("record", match &check.record { Some(r) => email_token_record_to_value(r), None => Value::Null, }), ]) }