src: split up different uses of SHA-256

src/fsverity.rs defines Sha256HashValue as an implementation of
FsVerityHashValue but we also use it for situations where we handle
SHA-256 digests that aren't fs-verity hash values.  This happens a lot
in the OCI code (to refer to images and layers) and correspondingly in
the splitstream code (which stores those things).

Introduce a util::Sha256Digest type, returned by util::parse_sha256()
and use it consistently for all of the cases that have nothing to do
with fs-verity.

parse_sha256() is still used in some places in the code for values that
are intended as fs-verity digests.  We'll start fixing that up in the
following commits when we add some helpers directly on the types
themselves.

Signed-off-by: Allison Karlitskaya <[email protected]>

Author: allisonkarlitskaya

src/oci/mod.rs

@@ -19,12 +19,12 @@ use crate::{
     oci::tar::{get_entry, split_async},
     repository::Repository,
     splitstream::DigestMap,
-    util::parse_sha256,
+    util::{parse_sha256, Sha256Digest},
 };
 
 pub fn import_layer(
     repo: &Repository,
-    sha256: &Sha256HashValue,
+    sha256: &Sha256Digest,
     name: Option<&str>,
     tar_stream: &mut impl Read,
 ) -> Result<Sha256HashValue> {
@@ -48,21 +48,21 @@ struct ImageOp<'repo> {
     progress: MultiProgress,
 }
 
-fn sha256_from_descriptor(descriptor: &Descriptor) -> Result<Sha256HashValue> {
+fn sha256_from_descriptor(descriptor: &Descriptor) -> Result<Sha256Digest> {
     let Some(digest) = descriptor.as_digest_sha256() else {
         bail!("Descriptor in oci config is not sha256");
     };
     Ok(parse_sha256(digest)?)
 }
 
-fn sha256_from_digest(digest: &str) -> Result<Sha256HashValue> {
+fn sha256_from_digest(digest: &str) -> Result<Sha256Digest> {
     match digest.strip_prefix("sha256:") {
         Some(rest) => Ok(parse_sha256(rest)?),
         None => bail!("Manifest has non-sha256 digest"),
     }
 }
 
-type ContentAndVerity = (Sha256HashValue, Sha256HashValue);
+type ContentAndVerity = (Sha256Digest, Sha256HashValue);
 
 impl<'repo> ImageOp<'repo> {
     async fn new(repo: &'repo Repository, imgref: &str) -> Result<Self> {
@@ -93,7 +93,7 @@ impl<'repo> ImageOp<'repo> {
 
     pub async fn ensure_layer(
         &self,
-        layer_sha256: &Sha256HashValue,
+        layer_sha256: &Sha256Digest,
         descriptor: &Descriptor,
     ) -> Result<Sha256HashValue> {
         // We need to use the per_manifest descriptor to download the compressed layer but it gets
@@ -245,7 +245,7 @@ pub fn open_config(
     Ok((config, stream.refs))
 }
 
-fn hash(bytes: &[u8]) -> Sha256HashValue {
+fn hash(bytes: &[u8]) -> Sha256Digest {
     let mut context = Sha256::new();
     context.update(bytes);
     context.finalize().into()

src/repository.rs

@@ -24,7 +24,7 @@ use crate::{
     },
     mount::mount_composefs_at,
     splitstream::{DigestMap, SplitStreamReader, SplitStreamWriter},
-    util::{parse_sha256, proc_self_fd},
+    util::{parse_sha256, proc_self_fd, Sha256Digest},
 };
 
 #[derive(Debug)]
@@ -136,7 +136,7 @@ impl Repository {
     /// store the result.
     pub fn create_stream(
         &self,
-        sha256: Option<Sha256HashValue>,
+        sha256: Option<Sha256Digest>,
         maps: Option<DigestMap>,
     ) -> SplitStreamWriter {
         SplitStreamWriter::new(self, maps, sha256)
@@ -166,7 +166,7 @@ impl Repository {
         format!("objects/{:02x}/{}", id[0], hex::encode(&id[1..]))
     }
 
-    pub fn has_stream(&self, sha256: &Sha256HashValue) -> Result<Option<Sha256HashValue>> {
+    pub fn has_stream(&self, sha256: &Sha256Digest) -> Result<Option<Sha256HashValue>> {
         let stream_path = format!("streams/{}", hex::encode(sha256));
 
         match readlinkat(&self.repository, &stream_path, []) {
@@ -191,7 +191,7 @@ impl Repository {
     }
 
     /// Basically the same as has_stream() except that it performs expensive verification
-    pub fn check_stream(&self, sha256: &Sha256HashValue) -> Result<Option<Sha256HashValue>> {
+    pub fn check_stream(&self, sha256: &Sha256Digest) -> Result<Option<Sha256HashValue>> {
         match self.openat(&format!("streams/{}", hex::encode(sha256)), OFlags::RDONLY) {
             Ok(stream) => {
                 let measured_verity: Sha256HashValue = measure_verity(&stream)?;
@@ -245,7 +245,7 @@ impl Repository {
 
     /// Assign the given name to a stream.  The stream must already exist.  After this operation it
     /// will be possible to refer to the stream by its new name 'refs/{name}'.
-    pub fn name_stream(&self, sha256: Sha256HashValue, name: &str) -> Result<()> {
+    pub fn name_stream(&self, sha256: Sha256Digest, name: &str) -> Result<()> {
         let stream_path = format!("streams/{}", hex::encode(sha256));
         let reference_path = format!("streams/refs/{name}");
         self.symlink(&reference_path, &stream_path)?;
@@ -268,7 +268,7 @@ impl Repository {
     /// ID will be used when referring to the stream from other linked streams.
     pub fn ensure_stream(
         &self,
-        sha256: &Sha256HashValue,
+        sha256: &Sha256Digest,
         callback: impl FnOnce(&mut SplitStreamWriter) -> Result<()>,
         reference: Option<&str>,
     ) -> Result<Sha256HashValue> {

src/splitstream.rs

@@ -12,12 +12,12 @@ use zstd::stream::{read::Decoder, write::Encoder};
 use crate::{
     fsverity::{FsVerityHashValue, Sha256HashValue},
     repository::Repository,
-    util::read_exactish,
+    util::{read_exactish, Sha256Digest},
 };
 
 #[derive(Debug)]
 pub struct DigestMapEntry {
-    pub body: Sha256HashValue,
+    pub body: Sha256Digest,
     pub verity: Sha256HashValue,
 }
 
@@ -37,14 +37,14 @@ impl DigestMap {
         DigestMap { map: vec![] }
     }
 
-    pub fn lookup(&self, body: &Sha256HashValue) -> Option<&Sha256HashValue> {
+    pub fn lookup(&self, body: &Sha256Digest) -> Option<&Sha256HashValue> {
         match self.map.binary_search_by_key(body, |e| e.body) {
             Ok(idx) => Some(&self.map[idx].verity),
             Err(..) => None,
         }
     }
 
-    pub fn insert(&mut self, body: &Sha256HashValue, verity: &Sha256HashValue) {
+    pub fn insert(&mut self, body: &Sha256Digest, verity: &Sha256HashValue) {
         match self.map.binary_search_by_key(body, |e| e.body) {
             Ok(idx) => assert_eq!(self.map[idx].verity, *verity), // or else, bad things...
             Err(idx) => self.map.insert(
@@ -62,7 +62,7 @@ pub struct SplitStreamWriter<'a> {
     repo: &'a Repository,
     inline_content: Vec<u8>,
     writer: Encoder<'a, Vec<u8>>,
-    pub sha256: Option<(Sha256, Sha256HashValue)>,
+    pub sha256: Option<(Sha256, Sha256Digest)>,
 }
 
 impl std::fmt::Debug for SplitStreamWriter<'_> {
@@ -80,7 +80,7 @@ impl SplitStreamWriter<'_> {
     pub fn new(
         repo: &Repository,
         refs: Option<DigestMap>,
-        sha256: Option<Sha256HashValue>,
+        sha256: Option<Sha256Digest>,
     ) -> SplitStreamWriter {
         // SAFETY: we surely can't get an error writing the header to a Vec<u8>
         let mut writer = Encoder::new(vec![], 0).unwrap();
@@ -157,7 +157,7 @@ impl SplitStreamWriter<'_> {
         self.flush_inline(vec![])?;
 
         if let Some((context, expected)) = self.sha256 {
-            if Into::<Sha256HashValue>::into(context.finalize()) != expected {
+            if Into::<Sha256Digest>::into(context.finalize()) != expected {
                 bail!("Content doesn't have expected SHA256 hash value!");
             }
         }
@@ -362,13 +362,13 @@ impl<R: Read> SplitStreamReader<R> {
         }
     }
 
-    pub fn get_stream_refs(&mut self, mut callback: impl FnMut(&Sha256HashValue)) {
+    pub fn get_stream_refs(&mut self, mut callback: impl FnMut(&Sha256Digest)) {
         for entry in &self.refs.map {
             callback(&entry.body);
         }
     }
 
-    pub fn lookup(&self, body: &Sha256HashValue) -> Result<&Sha256HashValue> {
+    pub fn lookup(&self, body: &Sha256Digest) -> Result<&Sha256HashValue> {
         match self.refs.lookup(body) {
             Some(id) => Ok(id),
             None => bail!("Reference is not found in splitstream"),

src/util.rs

@@ -5,8 +5,6 @@ use std::{
 
 use tokio::io::{AsyncRead, AsyncReadExt};
 
-use crate::fsverity::{FsVerityHashValue, Sha256HashValue};
-
 /// Formats a string like "/proc/self/fd/3" for the given fd.  This can be used to work with kernel
 /// APIs that don't directly accept file descriptors.
 ///
@@ -83,14 +81,17 @@ pub(crate) async fn read_exactish_async(
     Ok(true)
 }
 
-/// Parse a string containing a SHA256 digest in hexidecimal form into a Sha256HashValue.
+/// A utility type representing a SHA-256 digest in binary.
+pub type Sha256Digest = [u8; 32];
+
+/// Parse a string containing a SHA256 digest in hexidecimal form into a Sha256Digest.
 ///
 /// The string must contain exactly 64 characters and consist entirely of [0-9a-f], case
 /// insensitive.
 ///
 /// In case of a failure to parse the string, this function returns ErrorKind::InvalidInput.
-pub fn parse_sha256(string: impl AsRef<str>) -> Result<Sha256HashValue> {
-    let mut value = Sha256HashValue::EMPTY;
+pub fn parse_sha256(string: impl AsRef<str>) -> Result<Sha256Digest> {
+    let mut value = [0u8; 32];
     hex::decode_to_slice(string.as_ref(), &mut value)
         .map_err(|source| Error::new(ErrorKind::InvalidInput, source))?;
     Ok(value)