armdb 0.15.0

sharded bitcask key-value storage optimized for NVMe
Documentation
//! Durable key-admission check for an encrypted collection or txlog directory.

use std::io::{ErrorKind, Write};
use std::path::Path;

use crate::error::{DbError, DbResult};

const MAGIC: &[u8; 4] = b"AEK1";
const LEN: usize = 40;

/// Publish a check using temporary write, file sync, rename and directory sync.
pub(crate) fn write(dir: &Path, check: &[u8; 32]) -> DbResult<()> {
    let mut bytes = [0; LEN];
    bytes[..4].copy_from_slice(MAGIC);
    bytes[4..36].copy_from_slice(check);
    let crc = crc32fast::hash(&bytes[..36]);
    bytes[36..].copy_from_slice(&crc.to_le_bytes());
    let temporary = dir.join("enc.check.tmp");
    let mut file = std::fs::File::create(&temporary)?;
    file.write_all(&bytes)?;
    file.sync_data()?;
    drop(file);
    std::fs::rename(&temporary, dir.join("enc.check"))?;
    std::fs::File::open(dir)?.sync_all()?;
    Ok(())
}

/// Read an optional check, refusing any malformed file.
pub(crate) fn read(dir: &Path) -> DbResult<Option<[u8; 32]>> {
    let bytes = match std::fs::read(dir.join("enc.check")) {
        Ok(bytes) => bytes,
        Err(error) if error.kind() == ErrorKind::NotFound => return Ok(None),
        Err(error) => return Err(DbError::Io(error)),
    };
    if bytes.len() != LEN || &bytes[..4] != MAGIC {
        return Err(DbError::FormatMismatch(
            "invalid enc.check magic or length".into(),
        ));
    }
    let crc = u32::from_le_bytes(bytes[36..40].try_into().expect("enc.check CRC"));
    if crc32fast::hash(&bytes[..36]) != crc {
        return Err(DbError::FormatMismatch("invalid enc.check CRC".into()));
    }
    Ok(Some(bytes[4..36].try_into().expect("enc.check value")))
}

/// Check an encrypted collection's format and key before recovery or migration.
/// This admission check only reads the salt and check sidecars.
pub(crate) fn preflight_collection(
    path: &Path,
    meta_flags: u8,
    key: &[u8; 32],
    ctx: Option<&crate::crypto::EncryptionContext>,
) -> DbResult<()> {
    use crate::meta::{FLAG_ENCRYPTED, FLAG_KEY_RANGES};

    if meta_flags & FLAG_ENCRYPTED != 0 && meta_flags & FLAG_KEY_RANGES == 0 {
        return Err(DbError::FormatMismatch(format!(
            "pre-0.15 encryption format at {}; wipe and recreate",
            path.display()
        )));
    }
    let salt = crate::salt::read(path)?;
    let stored = read(path)?.ok_or_else(|| {
        DbError::FormatMismatch(format!(
            "enc.check missing for encrypted database at {}",
            path.display()
        ))
    })?;
    if stored != crate::crypto::key_check(key, &salt, ctx)? {
        return Err(DbError::EncryptionError(format!(
            "wrong encryption key or context for {}",
            path.display()
        )));
    }
    Ok(())
}

#[cfg(test)]
#[cfg(feature = "encryption")]
mod tests {
    use super::*;
    use tempfile::tempdir;

    #[test]
    fn enccheck_round_trip_and_corruption_is_rejected() {
        let dir = tempdir().unwrap();
        assert_eq!(read(dir.path()).unwrap(), None);
        write(dir.path(), &[0x42; 32]).unwrap();
        assert_eq!(read(dir.path()).unwrap(), Some([0x42; 32]));
        let path = dir.path().join("enc.check");
        let original = std::fs::read(&path).unwrap();
        assert_eq!(original.len(), 40);
        assert_eq!(&original[..4], b"AEK1");
        assert!(!dir.path().join("enc.check.tmp").exists());
        for offset in [0, 4, 36] {
            let mut bytes = original.clone();
            bytes[offset] ^= 1;
            std::fs::write(&path, bytes).unwrap();
            assert!(matches!(read(dir.path()), Err(DbError::FormatMismatch(_))));
        }
        for len in [0, 39, 41] {
            let mut bytes = original.clone();
            bytes.resize(len, 0);
            std::fs::write(&path, bytes).unwrap();
            assert!(matches!(read(dir.path()), Err(DbError::FormatMismatch(_))));
        }
    }
}