Rust: a rewrite reads the header with the snapshot reader, not a hand-written prefix parser

push_all reads the file and reuses store_header and readable_store_format, the same pair a load
uses. The 96-byte prefix parser it replaces misread a str16 header and any str8 header past the
prefix as v1 and overwrote a store it could not read. Pins both encodings refused with the file
untouched.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Meta Vens 2026-09-29 21:56:07 +02:00
commit 7ea1aa6a9a

View file

@ -312,7 +312,6 @@ impl<'de> serde::Deserialize<'de> for PersistedRecord {
}
}
const STORE_FORMAT_PREFIX: &str = "cultcache.store.";
const STORE_FORMAT_V1: &str = "cultcache.store.v1";
/// A store that can hold element ids. A reader older than element ids refuses this header: it would skip the id
@ -746,47 +745,24 @@ impl SingleFileMessagePackBackingStore {
self.read_all_unlocked()
}
/// The header a rewrite writes: the one the file on disk carries. A file marked for element ids stays marked (the
/// payloads this store passes through may hold ids, and a reader older than ids would skip them); a file that is
/// gone, empty or legacy is written v1; a header this runtime cannot read refuses the rewrite, so a store that holds
/// variants is never overwritten by a runtime that would drop them. The header is the first thing in the file, so a
/// short prefix answers without reading the store.
fn header_for_rewrite(&self) -> Result<&'static str> {
use std::io::Read;
let mut prefix = [0u8; 96];
let Ok(mut file) = File::open(&self.path) else { return Ok(STORE_FORMAT_V1) };
let read = file.read(&mut prefix).unwrap_or(0);
let bytes = &prefix[..read];
// The store is an array whose first slot is the header string.
let Some(rest) = (match bytes.first() {
Some(0x90..=0x9f) => bytes.get(1..),
Some(0xdc) => bytes.get(3..),
Some(0xdd) => bytes.get(5..),
_ => None,
}) else {
return Ok(STORE_FORMAT_V1);
};
let (length, start) = match rest.first() {
Some(tag @ 0xa0..=0xbf) => ((tag & 0x1f) as usize, 1),
Some(0xd9) => match rest.get(1) {
Some(length) => (*length as usize, 2),
None => return Ok(STORE_FORMAT_V1),
},
_ => return Ok(STORE_FORMAT_V1),
};
match rest.get(start..start + length).and_then(|header| std::str::from_utf8(header).ok()) {
Some(header) if header.starts_with(STORE_FORMAT_PREFIX) => readable_store_format(header),
_ => Ok(STORE_FORMAT_V1),
}
}
fn write_all_unlocked(&self, entries: &[CultCacheEnvelope]) -> Result<()> {
if let Some(parent) = self.path.parent() {
fs::create_dir_all(parent)
.with_context(|| format!("failed to create {}", parent.display()))?;
}
remove_abandoned_staging_files(&self.path)?;
let format = self.header_for_rewrite()?;
// The header a rewrite writes is the one the file on disk carries: a file marked for element ids stays marked (the
// payloads this store passes through may hold ids), one that is gone, empty or legacy is written v1, and a header
// this runtime cannot read refuses the rewrite, so a store that holds variants is never overwritten by a runtime that
// would drop them.
let format = match fs::read(&self.path) {
Ok(bytes) => match store_header(&bytes) {
Some(header) => readable_store_format(&header)?,
None => STORE_FORMAT_V1,
},
Err(error) if error.kind() == std::io::ErrorKind::NotFound => STORE_FORMAT_V1,
Err(error) => return Err(error).with_context(|| format!("failed to read {}", self.path.display())),
};
let bytes = rmp_serde::to_vec(&encode_store_snapshot(entries, format)?)
.context("failed to encode MessagePack")?;
let tmp_path = temporary_path_for(&self.path);
@ -4797,6 +4773,31 @@ mod tests {
Ok(())
}
// The header is read by the one snapshot reader, whatever string encoding carries it.
#[test]
fn push_all_refuses_a_header_it_cannot_read_however_the_string_is_encoded() -> Result<()> {
let long = format!("cultcache.store.v9.{}", "x".repeat(90));
let mut str16 = vec![0x93, 0xda, 0x00, 18];
str16.extend_from_slice(b"cultcache.store.v9");
str16.extend_from_slice(&[0x90, 0x90]);
let mut str8 = vec![0x93, 0xd9, long.len() as u8];
str8.extend_from_slice(long.as_bytes());
str8.extend_from_slice(&[0x90, 0x90]);
for (name, bytes) in [("str16", str16), ("str8 over 90 bytes", str8)] {
let temp = tempfile::tempdir()?;
let path = temp.path().join("store.msgpack");
std::fs::write(&path, &bytes)?;
let mut store = SingleFileMessagePackBackingStore::new(&path);
let message = format!(
"{:#}",
store.push_all(&[snapshot_envelope("x", b"one")], PushAllOptions::default()).unwrap_err()
);
assert!(message.contains("is not readable"), "{name}: {message}");
assert_eq!(std::fs::read(&path)?, bytes, "{name} was rewritten");
}
Ok(())
}
#[test]
fn a_rewrite_of_a_v1_store_stays_v1() -> Result<()> {
assert_eq!(