use crate::error::BoxError;
use crate::wasm_compat::{WasmBoxedFuture, WasmCompatSend, WasmCompatSync};
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
pub trait TokenStore: WasmCompatSend + WasmCompatSync {
fn load<'a>(&'a self, key: &'a str) -> WasmBoxedFuture<'a, Result<Option<String>, BoxError>>;
fn save<'a>(
&'a self,
key: &'a str,
record: &'a str,
) -> WasmBoxedFuture<'a, Result<(), BoxError>>;
fn delete<'a>(&'a self, key: &'a str) -> WasmBoxedFuture<'a, Result<(), BoxError>>;
fn lock<'a>(&'a self, _key: &'a str) -> WasmBoxedFuture<'a, Result<StoreLock, BoxError>> {
Box::pin(async { Ok(StoreLock::new(())) })
}
}
pub struct StoreLock {
_guard: Mutex<Box<dyn WasmCompatSend>>,
}
impl StoreLock {
pub fn new(guard: impl WasmCompatSend + 'static) -> Self {
Self {
_guard: Mutex::new(Box::new(guard)),
}
}
}
impl std::fmt::Debug for StoreLock {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("StoreLock").finish_non_exhaustive()
}
}
impl<T: TokenStore + ?Sized> TokenStore for Arc<T> {
fn load<'a>(&'a self, key: &'a str) -> WasmBoxedFuture<'a, Result<Option<String>, BoxError>> {
(**self).load(key)
}
fn save<'a>(
&'a self,
key: &'a str,
record: &'a str,
) -> WasmBoxedFuture<'a, Result<(), BoxError>> {
(**self).save(key, record)
}
fn delete<'a>(&'a self, key: &'a str) -> WasmBoxedFuture<'a, Result<(), BoxError>> {
(**self).delete(key)
}
fn lock<'a>(&'a self, key: &'a str) -> WasmBoxedFuture<'a, Result<StoreLock, BoxError>> {
(**self).lock(key)
}
}
#[derive(Default)]
pub struct MemoryTokenStore(Mutex<HashMap<String, String>>);
impl std::fmt::Debug for MemoryTokenStore {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MemoryTokenStore").finish_non_exhaustive()
}
}
impl MemoryTokenStore {
fn records(&self) -> std::sync::MutexGuard<'_, HashMap<String, String>> {
crate::lock(&self.0)
}
}
impl TokenStore for MemoryTokenStore {
fn load<'a>(&'a self, key: &'a str) -> WasmBoxedFuture<'a, Result<Option<String>, BoxError>> {
Box::pin(async move { Ok(self.records().get(key).cloned()) })
}
fn save<'a>(
&'a self,
key: &'a str,
record: &'a str,
) -> WasmBoxedFuture<'a, Result<(), BoxError>> {
Box::pin(async move {
self.records().insert(key.to_owned(), record.to_owned());
Ok(())
})
}
fn delete<'a>(&'a self, key: &'a str) -> WasmBoxedFuture<'a, Result<(), BoxError>> {
Box::pin(async move {
self.records().remove(key);
Ok(())
})
}
}
#[cfg(not(target_family = "wasm"))]
#[derive(Debug, Clone)]
pub struct FileTokenStore {
dir: std::path::PathBuf,
lock_wait: std::time::Duration,
}
#[cfg(not(target_family = "wasm"))]
impl FileTokenStore {
pub fn new(dir: impl Into<std::path::PathBuf>) -> Self {
Self {
dir: dir.into(),
lock_wait: LOCK_WAIT,
}
}
pub fn with_lock_wait(self, wait: std::time::Duration) -> Self {
Self {
lock_wait: wait,
..self
}
}
pub fn path(&self, key: &str) -> std::path::PathBuf {
self.dir.join(format!("{key}.json"))
}
}
#[cfg(not(target_family = "wasm"))]
impl TokenStore for FileTokenStore {
fn load<'a>(&'a self, key: &'a str) -> WasmBoxedFuture<'a, Result<Option<String>, BoxError>> {
Box::pin(async move { read_private(&self.path(key)) })
}
fn save<'a>(
&'a self,
key: &'a str,
record: &'a str,
) -> WasmBoxedFuture<'a, Result<(), BoxError>> {
Box::pin(async move { Ok(write_private(&self.path(key), record.as_bytes())?) })
}
fn delete<'a>(&'a self, key: &'a str) -> WasmBoxedFuture<'a, Result<(), BoxError>> {
Box::pin(async move {
let path = self.path(key);
match std::fs::remove_file(&path) {
Ok(()) => Ok(sync_parent(&path)?),
Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(()),
Err(error) => Err(error.into()),
}
})
}
fn lock<'a>(&'a self, key: &'a str) -> WasmBoxedFuture<'a, Result<StoreLock, BoxError>> {
Box::pin(async move {
let path = self.dir.join(format!("{key}.lock"));
create_private_dir(&path)?;
let mut options = std::fs::OpenOptions::new();
options.read(true).write(true).create(true).truncate(false);
#[cfg(unix)]
std::os::unix::fs::OpenOptionsExt::mode(&mut options, 0o600);
let file = options.open(&path)?;
let started = std::time::Instant::now();
loop {
match file.try_lock() {
Ok(()) => return Ok(StoreLock::new(file)),
Err(std::fs::TryLockError::WouldBlock)
if started.elapsed() < self.lock_wait =>
{
crate::wasm_compat::sleep(std::time::Duration::from_millis(50)).await;
}
Err(std::fs::TryLockError::WouldBlock) => {
return Err(FileStoreError::Busy {
path,
waited: self.lock_wait,
}
.into());
}
Err(std::fs::TryLockError::Error(error)) => return Err(error.into()),
}
}
})
}
}
#[cfg(not(target_family = "wasm"))]
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum FileStoreError {
#[error("{} is a symlink or not a regular file; a credential is read only from a regular file", path.display())]
NotAFile {
path: std::path::PathBuf,
},
#[error("{} is larger than {limit} bytes", path.display())]
TooLarge {
path: std::path::PathBuf,
limit: u64,
},
#[error("{} is open to group or others and could not be made owner-only", path.display())]
NotNarrowed {
path: std::path::PathBuf,
#[source]
source: std::io::Error,
},
#[error("another holder kept {} locked for {waited:?}", path.display())]
Busy {
path: std::path::PathBuf,
waited: std::time::Duration,
},
}
#[cfg(not(target_family = "wasm"))]
const RECORD_LIMIT: u64 = 64 * 1024;
#[cfg(not(target_family = "wasm"))]
fn read_private(path: &std::path::Path) -> Result<Option<String>, BoxError> {
use std::io::Read;
let not_a_file = || FileStoreError::NotAFile {
path: path.to_owned(),
};
let linked = match std::fs::symlink_metadata(path) {
Ok(linked) => linked,
Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None),
Err(error) => return Err(error.into()),
};
if !linked.file_type().is_file() {
return Err(not_a_file().into());
}
let mut options = std::fs::OpenOptions::new();
options.read(true);
#[cfg(windows)]
std::os::windows::fs::OpenOptionsExt::custom_flags(&mut options, 0x0020_0000);
let file = options.open(path)?;
let opened = file.metadata()?;
if !opened.is_file() {
return Err(not_a_file().into());
}
#[cfg(unix)]
{
use std::os::unix::fs::{MetadataExt, PermissionsExt};
if (opened.dev(), opened.ino()) != (linked.dev(), linked.ino()) {
return Err(not_a_file().into());
}
if opened.mode() & 0o077 != 0 {
file.set_permissions(std::fs::Permissions::from_mode(0o600))
.map_err(|source| FileStoreError::NotNarrowed {
path: path.to_owned(),
source,
})?;
}
}
let mut record = Vec::new();
file.take(RECORD_LIMIT + 1).read_to_end(&mut record)?;
if record.len() as u64 > RECORD_LIMIT {
return Err(FileStoreError::TooLarge {
path: path.to_owned(),
limit: RECORD_LIMIT,
}
.into());
}
Ok(Some(String::from_utf8(record)?))
}
#[cfg(not(target_family = "wasm"))]
const LOCK_WAIT: std::time::Duration = std::time::Duration::from_secs(120);
#[cfg(not(target_family = "wasm"))]
fn create_private_dir(path: &std::path::Path) -> Result<(), std::io::Error> {
let Some(parent) = path.parent() else {
return Ok(());
};
let mut builder = std::fs::DirBuilder::new();
builder.recursive(true);
#[cfg(unix)]
std::os::unix::fs::DirBuilderExt::mode(&mut builder, 0o700);
builder.create(parent)
}
#[cfg(not(target_family = "wasm"))]
fn write_private(path: &std::path::Path, bytes: &[u8]) -> Result<(), std::io::Error> {
use std::io::Write;
use std::sync::atomic::{AtomicU64, Ordering};
static WRITES: AtomicU64 = AtomicU64::new(0);
create_private_dir(path)?;
let mut temp = path.as_os_str().to_owned();
temp.push(format!(
".tmp-{}-{}",
std::process::id(),
WRITES.fetch_add(1, Ordering::Relaxed)
));
let temp = std::path::PathBuf::from(temp);
let write = || {
let mut options = std::fs::OpenOptions::new();
options.write(true).create_new(true);
#[cfg(unix)]
std::os::unix::fs::OpenOptionsExt::mode(&mut options, 0o600);
let mut file = options.open(&temp)?;
#[cfg(unix)]
file.set_permissions(std::os::unix::fs::PermissionsExt::from_mode(0o600))?;
file.write_all(bytes)?;
file.sync_all()?;
std::fs::rename(&temp, path)
};
let written = write();
if written.is_err() {
std::fs::remove_file(&temp).ok();
}
written?;
sync_parent(path)
}
#[cfg(not(target_family = "wasm"))]
fn sync_parent(path: &std::path::Path) -> Result<(), std::io::Error> {
#[cfg(unix)]
if let Some(parent) = path.parent() {
std::fs::File::open(parent)?.sync_all()?;
}
#[cfg(not(unix))]
let _ = path;
Ok(())
}
pub(crate) async fn load_record<T: Default + serde::de::DeserializeOwned>(
store: &dyn TokenStore,
key: &str,
) -> Result<T, super::AuthError> {
match store.load(key).await.map_err(super::AuthError::Store)? {
Some(record) => Ok(serde_json::from_str(&record)?),
None => Ok(T::default()),
}
}
pub(crate) async fn save_record<T: serde::Serialize>(
store: &dyn TokenStore,
key: &str,
record: &T,
) -> Result<(), super::AuthError> {
let text = serde_json::to_string_pretty(record)?;
store
.save(key, &text)
.await
.map_err(super::AuthError::Store)
}
#[cfg(test)]
mod tests;