Luigit
repositories / smith

smith

There are many coding harnesses - but this one is fast

owned by admin

smith-harness/src/oauth/store.rs

Raw
//! Protected atomic OAuth profile storage (`SMH-SPEC-SPEC0001`).
use super::{Profile, ProfileMetadata};
use serde::{Deserialize, Serialize};
use std::fmt::Write as _;
use std::fs::{self, File, OpenOptions};
use std::io::{Read, Write};
use std::path::{Path, PathBuf};

const STORE_VERSION: u8 = 2;
const STORE_BYTES_MAX: u64 = 512 * 1024;
const PROFILES_MAX: usize = 16;

/// Separate OAuth profile namespace; API-key files are never read or modified.
#[derive(Clone)]
pub struct ProfileStore {
    root: PathBuf,
}

#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
struct Store {
    version: u8,
    host_id: String,
    profiles: Vec<Profile>,
}

impl ProfileStore {
    /// Select the trusted store directory explicitly.
    #[must_use]
    pub const fn at(root: PathBuf) -> Self {
        Self { root }
    }

    pub(super) fn host_id(&self) -> Result<String, &'static str> {
        let _lock = self.lock()?;
        if let Some(store) = self.read()? {
            return Ok(store.host_id);
        }
        let mut bytes =
            smith::entropy::bytes::<16>().map_err(|_| "OAuth host entropy unavailable")?;
        bytes[6] = (bytes[6] & 15) | 64;
        bytes[8] = (bytes[8] & 63) | 128;
        let mut host_id = String::with_capacity(45);
        host_id.push_str("urn:uuid:");
        for (index, byte) in bytes.iter().enumerate() {
            if matches!(index, 4 | 6 | 8 | 10) {
                host_id.push('-');
            }
            write!(host_id, "{byte:02x}").map_err(|_| "OAuth host identity encoding failed")?;
        }
        self.write(&Store {
            version: STORE_VERSION,
            host_id: host_id.clone(),
            profiles: Vec::new(),
        })?;
        Ok(host_id)
    }

    pub(super) fn save(&self, profile: Profile) -> Result<ProfileMetadata, &'static str> {
        let _lock = self.lock()?;
        let mut store = self.read()?.ok_or("OAuth host identity missing")?;
        let index = match store
            .profiles
            .binary_search_by(|existing| existing.metadata.id.cmp(&profile.metadata.id))
        {
            Ok(index) => {
                let existing = &store.profiles[index].metadata;
                if existing.flow != profile.metadata.flow
                    || existing.connection_id != profile.metadata.connection_id
                    || existing.issuer != profile.metadata.issuer
                    || existing.subject != profile.metadata.subject
                    || existing.client_id != profile.metadata.client_id
                    || existing.workspace != profile.metadata.workspace
                    || existing.code_assist_project != profile.metadata.code_assist_project
                {
                    return Err("OAuth profile identity collision");
                }
                store.profiles[index] = profile;
                index
            }
            Err(index) => {
                if store.profiles.len() == PROFILES_MAX {
                    return Err("OAuth profile count bound exceeded");
                }
                store.profiles.insert(index, profile);
                index
            }
        };
        self.write(&store)?;
        // Move the acknowledgement out of temporary resident state after publication.
        Ok(store.profiles.remove(index).metadata)
    }

    /// Reject unusable renewable state without exposing or consuming credentials.
    pub(super) fn renewable_profile_available(
        &self,
        id: &str,
    ) -> Result<(), super::AuthorizationFault> {
        use super::AuthorizationFault;
        let _lock = self.lock().map_err(AuthorizationFault::Storage)?;
        let store = self
            .read()
            .map_err(AuthorizationFault::Storage)?
            .ok_or(AuthorizationFault::ReauthenticationRequired)?;
        let profile = store
            .profiles
            .iter()
            .find(|profile| profile.metadata.id == id)
            .ok_or(AuthorizationFault::ReauthenticationRequired)?;
        if profile.refresh_pending || profile.tokens.is_none() {
            return Err(AuthorizationFault::ReauthenticationRequired);
        }
        Ok(())
    }

    pub(super) fn end_session(
        &self,
        id: &str,
        policy: &super::LoginPolicy,
        cancel: &smith::tool::CancelHandle,
    ) -> Result<bool, super::AuthorizationFault> {
        use super::AuthorizationFault;
        let _lock = self.lock().map_err(AuthorizationFault::Storage)?;
        let mut store = self
            .read()
            .map_err(AuthorizationFault::Storage)?
            .ok_or(AuthorizationFault::ReauthenticationRequired)?;
        let index = store
            .profiles
            .iter()
            .position(|profile| profile.metadata.id == id)
            .ok_or(AuthorizationFault::ReauthenticationRequired)?;
        if !store.profiles[index].metadata.matches_policy(policy) {
            return Err(AuthorizationFault::Authority);
        }
        let uncertain = store.profiles[index].refresh_pending;
        store.profiles[index].refresh_pending = true;
        self.write(&store).map_err(AuthorizationFault::Storage)?;
        let confirmed = store.profiles[index].tokens.as_ref().is_some_and(|tokens| {
            super::revoke_session(
                policy,
                &store.profiles[index].metadata.client_id,
                &tokens.refresh,
                cancel,
            )
            .is_ok()
                && !uncertain
        });
        store.profiles[index].tokens = None;
        store.profiles[index].refresh_pending = false;
        self.write(&store).map_err(AuthorizationFault::Storage)?;
        Ok(confirmed)
    }

    pub(super) fn renew(
        &self,
        id: &str,
        policy: &super::LoginPolicy,
        cancel: &smith::tool::CancelHandle,
    ) -> Result<super::TokenSet, super::AuthorizationFault> {
        use super::AuthorizationFault;
        let _lock = self.lock().map_err(AuthorizationFault::Storage)?;
        let mut store = self
            .read()
            .map_err(AuthorizationFault::Storage)?
            .ok_or(AuthorizationFault::ReauthenticationRequired)?;
        let index = store
            .profiles
            .iter()
            .position(|profile| profile.metadata.id == id)
            .ok_or(AuthorizationFault::ReauthenticationRequired)?;
        let profile = &store.profiles[index];
        if !profile.metadata.matches_policy(policy) {
            return Err(AuthorizationFault::Authority);
        }
        if profile.refresh_pending
            || profile.tokens.is_none()
            || policy
                .required_scopes
                .iter()
                .any(|scope| !profile.metadata.scopes.contains(scope))
        {
            return Err(AuthorizationFault::ReauthenticationRequired);
        }
        let now = super::now()?;
        if profile.metadata.expires_at > now.saturating_add(60) {
            return store
                .profiles
                .remove(index)
                .tokens
                .ok_or(AuthorizationFault::ReauthenticationRequired);
        }
        if cancel.is_cancelled() {
            return Err(AuthorizationFault::Cancelled);
        }
        // Publication precedes dispatch: a crash or lost response must never replay rotation.
        store.profiles[index].refresh_pending = true;
        self.write(&store).map_err(AuthorizationFault::Storage)?;
        let result = super::refresh_profile(policy, &store.profiles[index], cancel);
        match result {
            Ok(profile) => {
                if cancel.is_cancelled() {
                    return Err(AuthorizationFault::ExchangeUncertain);
                }
                if profile.metadata.id != id {
                    return Err(AuthorizationFault::Rejected(
                        "OAuth refresh identity mismatch",
                    ));
                }
                store.profiles[index] = profile;
                self.write(&store).map_err(AuthorizationFault::Storage)?;
                store
                    .profiles
                    .remove(index)
                    .tokens
                    .ok_or(AuthorizationFault::ReauthenticationRequired)
            }
            Err(AuthorizationFault::ReauthenticationRequired) => {
                store.profiles[index].tokens = None;
                self.write(&store).map_err(AuthorizationFault::Storage)?;
                Err(AuthorizationFault::ReauthenticationRequired)
            }
            Err(fault) => Err(fault),
        }
    }

    /// Read only metadata for local profile listing.
    /// # Errors
    /// Rejects malformed, oversized, or insecure stores.
    pub fn list(&self) -> Result<Vec<ProfileMetadata>, &'static str> {
        if !self
            .root
            .try_exists()
            .map_err(|_| "OAuth store status failed")?
        {
            return Ok(Vec::new());
        }
        let _lock = self.lock()?;
        Ok(self.read()?.map_or_else(Vec::new, |store| {
            store
                .profiles
                .into_iter()
                .map(|profile| profile.metadata)
                .collect()
        }))
    }

    fn lock(&self) -> Result<File, &'static str> {
        #[cfg(unix)]
        {
            use std::os::unix::fs::DirBuilderExt;
            fs::DirBuilder::new()
                .recursive(true)
                .mode(0o700)
                .create(&self.root)
                .map_err(|_| "OAuth store directory creation failed")?;
        }
        #[cfg(not(unix))]
        fs::create_dir_all(&self.root).map_err(|_| "OAuth store directory creation failed")?;
        let metadata =
            fs::symlink_metadata(&self.root).map_err(|_| "OAuth store directory status failed")?;
        if !metadata.is_dir() || metadata.file_type().is_symlink() {
            return Err("OAuth store requires a regular directory");
        }
        #[cfg(unix)]
        {
            use std::os::unix::fs::PermissionsExt;
            if metadata.permissions().mode() & 0o077 != 0 {
                return Err("OAuth store directory must be owner-only");
            }
        }
        let lock_path = self.root.join("lock");
        let mut options = OpenOptions::new();
        options.read(true).write(true).create_new(true);
        #[cfg(unix)]
        {
            use std::os::unix::fs::OpenOptionsExt;
            options.mode(0o600);
        }
        let file = match options.open(&lock_path) {
            Ok(file) => file,
            Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => {
                protected_open(&lock_path)?
            }
            Err(_) => return Err("OAuth store lock creation failed"),
        };
        file.try_lock()
            .map_err(|_| "OAuth profile store busy; no exchange started")?;
        Ok(file)
    }

    fn read(&self) -> Result<Option<Store>, &'static str> {
        let path = self.root.join("profiles.json");
        if !path.try_exists().map_err(|_| "OAuth store status failed")? {
            if fs::symlink_metadata(&path).is_ok() {
                return Err("OAuth store cannot be a dangling link");
            }
            return Ok(None);
        }
        let file = protected_open(&path)?;
        let mut bytes = Vec::new();
        #[expect(
            clippy::disallowed_methods,
            reason = "Take caps OAuth store bytes before checking overflow"
        )]
        file.take(STORE_BYTES_MAX + 1)
            .read_to_end(&mut bytes)
            .map_err(|_| "OAuth store read failed")?;
        if bytes.len() as u64 > STORE_BYTES_MAX {
            return Err("OAuth profile store exceeds byte bound");
        }
        let store: Store =
            serde_json::from_slice(&bytes).map_err(|_| "corrupt OAuth profile store")?;
        if !valid_host_id(&store.host_id) {
            return Err(
                "invalid OAuth host UUID URI; restore the original store or explicitly remove this prototype store to register a new host",
            );
        }
        if store.version != STORE_VERSION
            || store.profiles.len() > PROFILES_MAX
            || store
                .profiles
                .windows(2)
                .any(|pair| pair[0].metadata.id >= pair[1].metadata.id)
            || store.profiles.iter().any(|profile| {
                profile.metadata.id.len() != 64
                    || !profile
                        .metadata
                        .id
                        .bytes()
                        .all(|byte| byte.is_ascii_hexdigit())
            })
        {
            return Err("invalid OAuth profile store schema");
        }
        for profile in &store.profiles {
            super::validate_metadata_secrecy(profile)?;
        }
        Ok(Some(store))
    }

    fn write(&self, store: &Store) -> Result<(), &'static str> {
        let bytes = serde_json::to_vec(store).map_err(|_| "OAuth store serialization failed")?;
        if bytes.len() as u64 > STORE_BYTES_MAX {
            return Err("OAuth profile store exceeds byte bound");
        }
        let suffix = super::encode(
            &smith::entropy::bytes::<16>().map_err(|_| "OAuth storage entropy unavailable")?,
        );
        let temporary = self.root.join(format!("pending-{suffix}"));
        let mut options = OpenOptions::new();
        options.write(true).create_new(true);
        #[cfg(unix)]
        {
            use std::os::unix::fs::OpenOptionsExt;
            options.mode(0o600);
        }
        let result = (|| {
            let mut file = options
                .open(&temporary)
                .map_err(|_| "OAuth atomic store creation failed")?;
            file.write_all(&bytes)
                .and_then(|()| file.sync_all())
                .map_err(|_| "OAuth atomic store write failed")?;
            publish(&temporary, &self.root.join("profiles.json"), &self.root)
        })();
        if result.is_err() {
            let _cleanup = fs::remove_file(temporary);
        }
        result
    }
}

fn publish(temporary: &Path, profile: &Path, root: &Path) -> Result<(), &'static str> {
    publish_with(
        temporary,
        profile,
        root,
        |from, to| fs::rename(from, to),
        |directory| File::open(directory).and_then(|file| file.sync_all()),
    )
}

fn publish_with<Rename, Sync>(
    temporary: &Path,
    profile: &Path,
    root: &Path,
    rename: Rename,
    sync: Sync,
) -> Result<(), &'static str>
where
    Rename: FnOnce(&Path, &Path) -> std::io::Result<()>,
    Sync: FnOnce(&Path) -> std::io::Result<()>,
{
    rename(temporary, profile).map_err(|_| "OAuth atomic store publication failed")?;
    sync(root).map_err(|_| "OAuth directory sync failed; publication uncertain")
}

fn valid_host_id(identity: &str) -> bool {
    let Some(uuid) = identity.strip_prefix("urn:uuid:") else {
        return false;
    };
    uuid.len() == 36
        && uuid.bytes().enumerate().all(|(index, byte)| {
            if matches!(index, 8 | 13 | 18 | 23) {
                byte == b'-'
            } else {
                byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte)
            }
        })
        && uuid.as_bytes()[14] == b'4'
        && matches!(uuid.as_bytes()[19], b'8' | b'9' | b'a' | b'b')
}

fn protected_open(path: &Path) -> Result<File, &'static str> {
    let before = fs::symlink_metadata(path).map_err(|_| "OAuth protected file status failed")?;
    if !before.is_file() || before.file_type().is_symlink() {
        return Err("OAuth store requires regular files");
    }
    #[cfg(unix)]
    {
        use std::os::unix::fs::{MetadataExt, PermissionsExt};
        if before.permissions().mode() & 0o777 != 0o600 || before.nlink() != 1 {
            return Err("OAuth store file must be private and unlinked elsewhere");
        }
    }
    let file = OpenOptions::new()
        .read(true)
        .write(true)
        .open(path)
        .map_err(|_| "OAuth protected file open failed")?;
    let after = file
        .metadata()
        .map_err(|_| "OAuth protected file status failed")?;
    #[cfg(unix)]
    {
        use std::os::unix::fs::MetadataExt;
        if before.dev() != after.dev() || before.ino() != after.ino() {
            return Err("OAuth protected file changed during open");
        }
    }
    if !after.is_file() {
        return Err("OAuth store requires regular files");
    }
    Ok(file)
}

#[cfg(test)]
mod publication_tests {
    use super::publish_with;
    use std::fs;
    use std::io;

    fn fixture_root() -> std::path::PathBuf {
        let root =
            std::env::temp_dir().join(format!("oauth-publication-{}", smith::id::SessionId::new()));
        fs::create_dir(&root).unwrap();
        root
    }

    #[test]
    fn rename_failure_retains_canonical_profile_and_temporary_generation() {
        let root = fixture_root();
        let profile = root.join("profiles.json");
        let temporary = root.join("pending");
        fs::write(&profile, b"canonical").unwrap();
        fs::write(&temporary, b"verified-next").unwrap();

        let error = publish_with(
            &temporary,
            &profile,
            &root,
            |_, _| Err(io::Error::other("fixture rename failure")),
            |_| Ok(()),
        )
        .unwrap_err();

        assert_eq!(error, "OAuth atomic store publication failed");
        assert_eq!(fs::read(&profile).unwrap(), b"canonical");
        assert_eq!(fs::read(&temporary).unwrap(), b"verified-next");
        fs::remove_dir_all(root).unwrap();
    }

    #[test]
    fn directory_sync_failure_after_rename_leaves_complete_new_generation() {
        let root = fixture_root();
        let profile = root.join("profiles.json");
        let temporary = root.join("pending");
        fs::write(&profile, b"old-access\nold-refresh").unwrap();
        fs::write(&temporary, b"new-access\nnew-refresh").unwrap();

        let error = publish_with(
            &temporary,
            &profile,
            &root,
            |from, to| fs::rename(from, to),
            |_| Err(io::Error::other("fixture directory sync failure")),
        )
        .unwrap_err();

        assert_eq!(error, "OAuth directory sync failed; publication uncertain");
        assert_eq!(fs::read(&profile).unwrap(), b"new-access\nnew-refresh");
        assert!(!temporary.exists());
        fs::remove_dir_all(root).unwrap();
    }
}