Split repository traits, Preserve metadata hashes

src/crypto.rs

@@ -75,6 +75,13 @@ pub fn hash_preference<'a>(
     Err(Error::NoSupportedHashAlgorithm)
 }
 
+#[cfg(test)]
+pub(crate) fn calculate_hash(data: &[u8], hash_alg: HashAlgorithm) -> HashValue {
+    let mut context = hash_alg.digest_context().unwrap();
+    context.update(data);
+    HashValue::new(context.finish().as_ref().to_vec())
+}
+
 /// Calculate the size and hash digest from a given `Read`.
 pub fn calculate_hashes<R: Read>(
     mut read: R,

src/metadata.rs

@@ -237,7 +237,39 @@ pub trait Metadata: Debug + PartialEq + Serialize + DeserializeOwned {
     fn expires(&self) -> &DateTime<Utc>;
 }
 
-/// A piece of raw metadata with attached signatures.
+/// Unverified raw metadata with attached signatures and type information identifying the
+/// metadata's type and serialization format.
+#[derive(Debug, Clone, PartialEq)]
+pub struct RawSignedMetadata<D, M> {
+    bytes: Vec<u8>,
+    _marker: PhantomData<(D, M)>,
+}
+
+impl<D, M> RawSignedMetadata<D, M>
+where
+    D: DataInterchange,
+    M: Metadata,
+{
+    /// Create a new [`RawSignedMetadata`] using the provided `bytes`.
+    pub fn new(bytes: Vec<u8>) -> Self {
+        Self {
+            bytes,
+            _marker: PhantomData,
+        }
+    }
+
+    /// Access this metadata's inner raw bytes.
+    pub fn as_bytes(&self) -> &[u8] {
+        &self.bytes
+    }
+
+    /// Parse this metadata.
+    pub fn parse(&self) -> Result<SignedMetadata<D, M>> {
+        D::from_slice(&self.bytes)
+    }
+}
+
+/// A piece of metadata with attached signatures.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct SignedMetadata<D, M> {
     signatures: Vec<Signature>,
@@ -280,6 +312,23 @@ where
         })
     }
 
+    /// Serialize this metadata to canonical bytes suitable for serialization. Note that this
+    /// method is only intended to serialize signed metadata generated by this crate, not to
+    /// re-serialize metadata that was originally obtained from a remote source.
+    ///
+    /// TUF metadata hashes are on the raw bytes of the metadata, so it is not guaranteed that the
+    /// hash of the returned bytes will match a hash included in, for example, a snapshot metadata
+    /// file, as:
+    /// * Parsing metadata removes unknown fields, which would not be included in the returned
+    /// bytes,
+    /// * DataInterchange implementations only guarantee the bytes are canonical for the purpose of
+    /// a signature. Metadata obtained from a remote source may have included different whitespace
+    /// or ordered fields in a way that is not preserved when parsing that metadata.
+    pub fn to_raw(&self) -> Result<RawSignedMetadata<D, M>> {
+        let bytes = D::canonicalize(&D::serialize(self)?)?;
+        Ok(RawSignedMetadata::new(bytes))
+    }
+
     /// Append a signature to this signed metadata. Will overwrite signature by keys with the same
     /// ID.
     ///