use rand_core::{OsRng, RngCore};
use serde::Deserialize;
use sha2::{Digest, Sha256};
use std::fmt;
use zeroize::ZeroizeOnDrop;
#[derive(Clone, Deserialize, ZeroizeOnDrop)]
#[serde(transparent)]
pub struct Secret(String);
impl Secret {
pub fn new(value: impl Into<String>) -> Self {
Self(value.into())
}
pub fn expose(&self) -> &str {
&self.0
}
}
impl fmt::Debug for Secret {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("Secret([REDACTED])")
}
}
pub(crate) fn random() -> capy_core::Result<Secret> {
let mut bytes = [0u8; 32];
OsRng.try_fill_bytes(&mut bytes).map_err(|_| {
capy_core::AppError::Configuration("Operating-system randomness unavailable".into())
})?;
Ok(Secret::new(hex(&bytes)))
}
pub(crate) fn digest(value: &str) -> String {
hex(&Sha256::digest(value.as_bytes()))
}
pub(crate) fn valid_token(value: &str) -> bool {
value.len() == 64
&& value
.bytes()
.all(|c| c.is_ascii_digit() || (b'a'..=b'f').contains(&c))
}
fn hex(bytes: &[u8]) -> String {
bytes.iter().map(|byte| format!("{byte:02x}")).collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn randomness_and_debug_boundaries() {
let a = random().unwrap();
let b = random().unwrap();
assert!(valid_token(a.expose()));
assert_ne!(a.expose(), b.expose());
assert!(!format!("{a:?}").contains(a.expose()));
let model = crate::models::session::ActiveModel {
csrf_token: sea_orm::Set(crate::models::DbSecret(a.expose().into())),
..Default::default()
};
assert!(!format!("{model:?}").contains(a.expose()));
}
}