use std::io::{ErrorKind, Write};
use std::path::Path;
use crate::error::{DbError, DbResult};
const MAGIC: &[u8; 4] = b"AEK1";
const LEN: usize = 40;
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(())
}
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")))
}
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(_))));
}
}
}