fix(platform-config): read a file secret into one buffer at its bound

read_bounded grew a zeroizing Vec from empty while reading, and each
growth copied the bytes read so far into a new buffer and freed the old
one without erasing it, leaving prefixes of the secret in freed memory.
The buffer is now allocated once at MAX_SECRET_BYTES + 1, which the
bounded read never outgrows, so the value is held in one buffer that is
erased on drop.

Signed-off-by: Jeremi Joslin <jeremi@joslin.fr>

Author: jeremi

crates/registry-platform-config/src/secrets.rs

@@ -265,8 +265,11 @@ fn read_secret_file(root: &Path, name: &str) -> Result<Zeroizing<Vec<u8>>, Secre
     read_bounded(file)
 }
 
+/// Read at most one byte past [`MAX_SECRET_BYTES`] into one buffer allocated
+/// at that size, which the read never outgrows: a grown buffer would copy
+/// the value and free the old buffer without erasing it.
 fn read_bounded(file: File) -> Result<Zeroizing<Vec<u8>>, SecretError> {
-    let mut bytes = Zeroizing::new(Vec::new());
+    let mut bytes = Zeroizing::new(Vec::with_capacity(MAX_SECRET_BYTES + 1));
     file.take((MAX_SECRET_BYTES + 1) as u64)
         .read_to_end(&mut bytes)
         .map_err(|_| SecretError::Read)?;
@@ -455,6 +458,29 @@ mod tests {
         }
     }
 
+    /// A grown buffer copies the value and frees the old one unerased, so
+    /// the read must fit one buffer allocated at the bound whatever the
+    /// file holds.
+    #[test]
+    fn a_bounded_read_never_grows_its_buffer() {
+        use std::io::{Seek as _, SeekFrom, Write as _};
+
+        for length in [
+            1,
+            4096,
+            MAX_SECRET_BYTES,
+            MAX_SECRET_BYTES + 1,
+            2 * MAX_SECRET_BYTES,
+        ] {
+            let mut file = tempfile::tempfile().expect("temporary file");
+            file.write_all(&vec![b'x'; length]).expect("write");
+            file.seek(SeekFrom::Start(0)).expect("rewind");
+            let bytes = read_bounded(file).expect("read");
+            assert_eq!(bytes.len(), length.min(MAX_SECRET_BYTES + 1));
+            assert_eq!(bytes.capacity(), MAX_SECRET_BYTES + 1, "{length} bytes");
+        }
+    }
+
     #[test]
     fn binary_values_keep_zero_bytes_within_the_same_bounds() {
         let secret = validate_binary_secret(Zeroizing::new(b"canary\0value".to_vec()))