286 lines
10 KiB
Rust
286 lines
10 KiB
Rust
//! Separate bounded binary store. Existing 256KiB package artifacts are unchanged.
|
|
//! A completed object is published only after complete length/hash verification.
|
|
use anyhow::{Result, ensure};
|
|
use sha2::{Digest, Sha256};
|
|
use std::{
|
|
fs::{self, File, OpenOptions},
|
|
io::{Read, Seek, SeekFrom, Write},
|
|
os::unix::fs::{MetadataExt, OpenOptionsExt, PermissionsExt},
|
|
path::{Path, PathBuf},
|
|
};
|
|
use uuid::Uuid;
|
|
|
|
pub const MAX_CHUNK_BYTES: u32 = 512 * 1024;
|
|
pub struct UpdateArtifacts {
|
|
root: PathBuf,
|
|
owner: u32,
|
|
}
|
|
pub struct Staging {
|
|
file: File,
|
|
temporary: PathBuf,
|
|
final_path: PathBuf,
|
|
parent: PathBuf,
|
|
expected_hash: String,
|
|
expected_size: u64,
|
|
written: u64,
|
|
hasher: Sha256,
|
|
}
|
|
fn descriptor(hash: &str, bytes: u64) -> bool {
|
|
rmm_domain::agent_update::digest(hash) && (1..=rmm_updater::MAX_ARTIFACT_BYTES).contains(&bytes)
|
|
}
|
|
fn directory(path: &Path, owner: u32) -> Result<()> {
|
|
let m = fs::symlink_metadata(path)?;
|
|
ensure!(
|
|
m.is_dir() && m.uid() == owner && m.mode() & 0o777 == 0o700,
|
|
"private update store directory"
|
|
);
|
|
Ok(())
|
|
}
|
|
fn regular(file: &File, owner: u32, expected_size: u64) -> Result<fs::Metadata> {
|
|
let m = file.metadata()?;
|
|
ensure!(
|
|
m.is_file()
|
|
&& m.uid() == owner
|
|
&& m.mode() & 0o777 == 0o600
|
|
&& m.nlink() == 1
|
|
&& m.len() == expected_size,
|
|
"immutable update object metadata"
|
|
);
|
|
Ok(m)
|
|
}
|
|
impl UpdateArtifacts {
|
|
pub fn new(profile: &str, root: PathBuf, owner: u32) -> Result<Self> {
|
|
ensure!(
|
|
profile == "development",
|
|
"update object adapter is development-only"
|
|
);
|
|
match fs::create_dir(&root) {
|
|
Ok(()) => fs::set_permissions(&root, fs::Permissions::from_mode(0o700))?,
|
|
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {}
|
|
Err(e) => return Err(e.into()),
|
|
}
|
|
directory(&root, owner)?;
|
|
Ok(Self { root, owner })
|
|
}
|
|
fn parent(&self, tenant: Uuid) -> Result<PathBuf> {
|
|
ensure!(!tenant.is_nil(), "update tenant identity");
|
|
directory(&self.root, self.owner)?;
|
|
let parent = self.root.join(tenant.to_string());
|
|
match fs::create_dir(&parent) {
|
|
Ok(()) => {
|
|
fs::set_permissions(&parent, fs::Permissions::from_mode(0o700))?;
|
|
File::open(&self.root)?.sync_all()?;
|
|
}
|
|
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {}
|
|
Err(e) => return Err(e.into()),
|
|
}
|
|
directory(&parent, self.owner)?;
|
|
Ok(parent)
|
|
}
|
|
pub fn begin(&self, tenant: Uuid, hash: &str, bytes: u64) -> Result<Staging> {
|
|
ensure!(descriptor(hash, bytes), "bounded update object descriptor");
|
|
let parent = self.parent(tenant)?;
|
|
let temporary = parent.join(format!(".staging-{}", Uuid::new_v4()));
|
|
let file = OpenOptions::new()
|
|
.create_new(true)
|
|
.write(true)
|
|
.mode(0o600)
|
|
.custom_flags(libc::O_NOFOLLOW | libc::O_CLOEXEC)
|
|
.open(&temporary)?;
|
|
Ok(Staging {
|
|
file,
|
|
temporary,
|
|
final_path: parent.join(hash),
|
|
parent,
|
|
expected_hash: hash.into(),
|
|
expected_size: bytes,
|
|
written: 0,
|
|
hasher: Sha256::new(),
|
|
})
|
|
}
|
|
fn verified_file(&self, tenant: Uuid, hash: &str, bytes: u64) -> Result<File> {
|
|
ensure!(descriptor(hash, bytes), "bounded update object descriptor");
|
|
let parent = self.parent(tenant)?;
|
|
let mut file = OpenOptions::new()
|
|
.read(true)
|
|
.custom_flags(libc::O_NOFOLLOW | libc::O_CLOEXEC)
|
|
.open(parent.join(hash))?;
|
|
let before = regular(&file, self.owner, bytes)?;
|
|
let mut hasher = Sha256::new();
|
|
let mut buffer = [0_u8; 32768];
|
|
let mut seen = 0;
|
|
loop {
|
|
let n = file.read(&mut buffer)?;
|
|
if n == 0 {
|
|
break;
|
|
}
|
|
seen += n as u64;
|
|
ensure!(seen <= bytes, "update object additional bytes");
|
|
hasher.update(&buffer[..n]);
|
|
}
|
|
let after = regular(&file, self.owner, bytes)?;
|
|
ensure!(
|
|
seen == bytes
|
|
&& hex::encode(hasher.finalize()) == hash
|
|
&& (
|
|
before.dev(),
|
|
before.ino(),
|
|
before.ctime(),
|
|
before.ctime_nsec(),
|
|
before.mtime(),
|
|
before.mtime_nsec()
|
|
) == (
|
|
after.dev(),
|
|
after.ino(),
|
|
after.ctime(),
|
|
after.ctime_nsec(),
|
|
after.mtime(),
|
|
after.mtime_nsec()
|
|
),
|
|
"complete immutable update object integrity"
|
|
);
|
|
file.seek(SeekFrom::Start(0))?;
|
|
Ok(file)
|
|
}
|
|
pub fn verify(&self, tenant: Uuid, hash: &str, bytes: u64) -> Result<()> {
|
|
self.verified_file(tenant, hash, bytes).map(|_| ())
|
|
}
|
|
pub fn read_chunk(
|
|
&self,
|
|
tenant: Uuid,
|
|
hash: &str,
|
|
bytes: u64,
|
|
offset: u64,
|
|
length: u32,
|
|
) -> Result<Vec<u8>> {
|
|
ensure!(
|
|
offset < bytes && (1..=MAX_CHUNK_BYTES).contains(&length),
|
|
"bounded update range"
|
|
);
|
|
let mut file = self.verified_file(tenant, hash, bytes)?;
|
|
let before = regular(&file, self.owner, bytes)?;
|
|
file.seek(SeekFrom::Start(offset))?;
|
|
let mut chunk = vec![0; (bytes - offset).min(length as u64) as usize];
|
|
file.read_exact(&mut chunk)?;
|
|
let after = regular(&file, self.owner, bytes)?;
|
|
ensure!(
|
|
(
|
|
before.dev(),
|
|
before.ino(),
|
|
before.ctime(),
|
|
before.ctime_nsec(),
|
|
before.mtime(),
|
|
before.mtime_nsec()
|
|
) == (
|
|
after.dev(),
|
|
after.ino(),
|
|
after.ctime(),
|
|
after.ctime_nsec(),
|
|
after.mtime(),
|
|
after.mtime_nsec()
|
|
),
|
|
"update object changed during bounded range"
|
|
);
|
|
Ok(chunk)
|
|
}
|
|
}
|
|
impl Staging {
|
|
pub fn append(&mut self, chunk: &[u8]) -> Result<()> {
|
|
ensure!(
|
|
!chunk.is_empty()
|
|
&& chunk.len() <= MAX_CHUNK_BYTES as usize
|
|
&& self.written + chunk.len() as u64 <= self.expected_size,
|
|
"bounded update import chunk"
|
|
);
|
|
self.file.write_all(chunk)?;
|
|
self.hasher.update(chunk);
|
|
self.written += chunk.len() as u64;
|
|
Ok(())
|
|
}
|
|
pub fn finish(mut self, store: &UpdateArtifacts, tenant: Uuid) -> Result<()> {
|
|
ensure!(
|
|
self.written == self.expected_size
|
|
&& hex::encode(self.hasher.clone().finalize()) == self.expected_hash,
|
|
"complete update import hash/length"
|
|
);
|
|
self.file.flush()?;
|
|
self.file.sync_all()?;
|
|
if let Err(e) = fs::hard_link(&self.temporary, &self.final_path) {
|
|
ensure!(
|
|
e.kind() == std::io::ErrorKind::AlreadyExists,
|
|
"update publication failed"
|
|
);
|
|
store.verify(tenant, &self.expected_hash, self.expected_size)?;
|
|
}
|
|
fs::remove_file(&self.temporary)?;
|
|
File::open(&self.parent)?.sync_all()?;
|
|
store.verify(tenant, &self.expected_hash, self.expected_size)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
impl Drop for Staging {
|
|
fn drop(&mut self) {
|
|
// Only this create-once temporary object, never a published object/job.
|
|
let _ = fs::remove_file(&self.temporary);
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
#[test]
|
|
fn large_update_stream_preserves_legacy_bound_and_denies_corruption_or_foreign_tenant() {
|
|
let root = std::env::temp_dir().join(format!("rmm-update-store-{}", Uuid::new_v4()));
|
|
fs::create_dir(&root).unwrap();
|
|
fs::set_permissions(&root, fs::Permissions::from_mode(0o700)).unwrap();
|
|
let owner = fs::metadata(&root).unwrap().uid();
|
|
let store = UpdateArtifacts::new("development", root.clone(), owner).unwrap();
|
|
assert!(UpdateArtifacts::new("production", root.clone(), owner).is_err());
|
|
let tenant = Uuid::new_v4();
|
|
let bytes = vec![37_u8; 300_007];
|
|
let hash = rmm_domain::jobs::hash(&bytes);
|
|
let mut staging = store.begin(tenant, &hash, bytes.len() as u64).unwrap();
|
|
for chunk in bytes.chunks(32768) {
|
|
staging.append(chunk).unwrap();
|
|
}
|
|
staging.finish(&store, tenant).unwrap();
|
|
assert_eq!(
|
|
store
|
|
.read_chunk(tenant, &hash, bytes.len() as u64, 299_999, 16)
|
|
.unwrap(),
|
|
bytes[299_999..]
|
|
);
|
|
assert!(
|
|
store
|
|
.read_chunk(Uuid::new_v4(), &hash, bytes.len() as u64, 0, 32)
|
|
.is_err()
|
|
);
|
|
assert!(
|
|
store
|
|
.read_chunk(tenant, &hash, bytes.len() as u64, bytes.len() as u64, 1)
|
|
.is_err()
|
|
);
|
|
assert!(
|
|
store
|
|
.read_chunk(tenant, &hash, bytes.len() as u64, 0, MAX_CHUNK_BYTES + 1)
|
|
.is_err()
|
|
);
|
|
assert!(store.begin(tenant, "../escape", 1).is_err());
|
|
// An incomplete object is never published, including a clean early EOF.
|
|
let truncated = rmm_domain::jobs::hash(b"truncated");
|
|
let mut short = store.begin(tenant, &truncated, 9).unwrap();
|
|
short.append(b"trunc").unwrap();
|
|
assert!(short.finish(&store, tenant).is_err());
|
|
assert!(!root.join(tenant.to_string()).join(truncated).exists());
|
|
let object = root.join(tenant.to_string()).join(&hash);
|
|
fs::write(&object, vec![38_u8; bytes.len()]).unwrap();
|
|
assert!(store.verify(tenant, &hash, bytes.len() as u64).is_err());
|
|
// Existing small package storage retains its own 256KiB boundary.
|
|
use crate::artifact_store::ArtifactStore;
|
|
let legacy =
|
|
crate::artifact_store::LocalArtifacts::new("development", root.join("legacy")).unwrap();
|
|
assert!(legacy.put(tenant, &bytes).is_err());
|
|
fs::remove_dir_all(root).unwrap();
|
|
}
|
|
}
|