feat(rust/signed-doc): add types for Metadata fields.

* add content_encoding and content_type fields to Metadata
* update the example for making signed docs

Author: saibatizoku

rust/signed_doc/examples/mk_signed_doc.rs

@@ -6,7 +6,6 @@ use std::{
     fs::{read_to_string, File},
     io::{Read, Write},
     path::PathBuf,
-    str::FromStr,
 };
 
 use clap::Parser;
@@ -58,7 +57,7 @@ enum Cli {
     },
 }
 
-const CONTENT_ENCODING_KEY: &str = "content encoding";
+const CONTENT_ENCODING_KEY: &str = "Content-Encoding";
 const CONTENT_ENCODING_VALUE: &str = "br";
 const UUID_CBOR_TAG: u64 = 37;
 
@@ -120,7 +119,8 @@ impl Cli {
             } => {
                 let doc_schema = load_schema_from_file(&schema)?;
                 let json_doc = load_json_from_file(&doc)?;
-                let json_meta = load_json_from_file(&meta)?;
+                let json_meta = load_json_from_file(&meta)
+                    .map_err(|e| anyhow::anyhow!("Failed to load metadata from file: {e}"))?;
                 validate_json(&json_doc, &doc_schema)?;
                 let compressed_doc = brotli_compress_json(&json_doc)?;
                 let empty_cose_sign = build_empty_cose_doc(compressed_doc, &json_meta);
@@ -299,14 +299,13 @@ fn validate_cose(
     validate_json(&json_doc, schema)?;
 
     for sign in &cose.signatures {
-        let key_id = sign.protected.header.key_id.clone();
+        let key_id = &sign.protected.header.key_id;
         anyhow::ensure!(
             !key_id.is_empty(),
             "COSE missing signature protected header `kid` field "
         );
 
-        let kid_str = String::from_utf8_lossy(&key_id);
-        let kid = Kid::from_str(&kid_str)?;
+        let kid = Kid::try_from(key_id.as_ref())?;
         println!("Signature Key ID: {kid}");
         let data_to_sign = cose.tbs_data(&[], sign);
         let signature_bytes = sign.signature.as_slice().try_into().map_err(|_| {
@@ -338,12 +337,13 @@ fn validate_cose_protected_header(cose: &coset::CoseSign) -> anyhow::Result<()>
         cose.protected.header.content_type == expected_header.content_type,
         "Invalid COSE document protected header `content-type` field"
     );
+    println!("HEADER REST: \n{:?}", cose.protected.header.rest);
     anyhow::ensure!(
         cose.protected.header.rest.iter().any(|(key, value)| {
             key == &coset::Label::Text(CONTENT_ENCODING_KEY.to_string())
                 && value == &coset::cbor::Value::Text(CONTENT_ENCODING_VALUE.to_string())
         }),
-        "Invalid COSE document protected header {CONTENT_ENCODING_KEY} field"
+        "Invalid COSE document protected header"
     );
 
     let Some((_, value)) = cose

rust/signed_doc/src/lib.rs

@@ -14,11 +14,6 @@ mod signature;
 pub use metadata::{DocumentRef, Metadata, UuidV7};
 pub use signature::Kid;
 
-/// Catalyst Signed Document Content Encoding Key.
-const CONTENT_ENCODING_KEY: &str = "Content-Encoding";
-/// Catalyst Signed Document Content Encoding Value.
-const CONTENT_ENCODING_VALUE: &str = "br";
-
 /// Keep all the contents private.
 /// Better even to use a structure like this.  Wrapping in an Arc means we don't have to
 /// manage the Arc anywhere else. These are likely to be large, best to have the Arc be
@@ -77,37 +72,23 @@ impl TryFrom<Vec<u8>> for CatalystSignedDocument {
         let cose = coset::CoseSign::from_tagged_slice(&cose_bytes)
             .or(coset::CoseSign::from_slice(&cose_bytes))
             .map_err(|e| anyhow::anyhow!("Invalid COSE Sign document: {e}"))?;
-        let mut content_errors = Vec::new();
-        let expected_header = cose_protected_header();
 
-        if cose.protected.header.content_type != expected_header.content_type {
-            content_errors
-                .push("Invalid COSE document protected header `content-type` field".to_string());
-        }
+        let mut content_errors = Vec::new();
 
-        if !cose.protected.header.rest.iter().any(|(key, value)| {
-            key == &coset::Label::Text(CONTENT_ENCODING_KEY.to_string())
-                && value == &coset::cbor::Value::Text(CONTENT_ENCODING_VALUE.to_string())
-        }) {
-            content_errors.push(
-                "Invalid COSE document protected header {CONTENT_ENCODING_KEY} field".to_string(),
-            );
-        }
         let metadata = Metadata::from(&cose.protected);
+
         if metadata.has_error() {
             content_errors.extend_from_slice(metadata.content_errors());
         }
-        let payload = match &cose.payload {
-            Some(payload) => {
-                let mut buf = Vec::new();
-                let mut bytes = payload.as_slice();
-                brotli::BrotliDecompress(&mut bytes, &mut buf)?;
-                serde_json::from_slice(&buf)?
-            },
-            None => {
-                println!("COSE missing payload field with the JSON content in it");
-                serde_json::Value::Object(serde_json::Map::new())
-            },
+
+        let payload = if let Some(payload) = &cose.payload {
+            let mut buf = Vec::new();
+            let mut bytes = payload.as_slice();
+            brotli::BrotliDecompress(&mut bytes, &mut buf)?;
+            serde_json::from_slice(&buf)?
+        } else {
+            println!("COSE missing payload field with the JSON content in it");
+            serde_json::Value::Object(serde_json::Map::new())
         };
         let signatures = cose.signatures.clone();
         let inner = InnerCatalystSignedDocument {
@@ -173,27 +154,5 @@ impl CatalystSignedDocument {
     pub fn doc_section(&self) -> Option<String> {
         self.inner.metadata.doc_section()
     }
-}
-
-/// Generate the COSE protected header used by Catalyst Signed Document.
-fn cose_protected_header() -> coset::Header {
-    coset::HeaderBuilder::new()
-        .content_format(coset::iana::CoapContentFormat::Json)
-        .text_value(
-            CONTENT_ENCODING_KEY.to_string(),
-            CONTENT_ENCODING_VALUE.to_string().into(),
-        )
-        .build()
-}
 
-/// Find a value for a given key in the protected header.
-fn cose_protected_header_find(
-    cose: &coset::CoseSign, rest_key: &str,
-) -> Option<coset::cbor::Value> {
-    cose.protected
-        .header
-        .rest
-        .iter()
-        .find(|(key, _)| key == &coset::Label::Text(rest_key.to_string()))
-        .map(|(_, value)| value.clone())
 }

rust/signed_doc/src/metadata/content_encoding.rs

@@ -0,0 +1,32 @@
+//! Document Payload Content Encoding.
+
+/// Catalyst Signed Document Content Encoding Key.
+const CONTENT_ENCODING_KEY: &str = "Content-Encoding";
+
+/// IANA `CoAP` Content Encoding.
+#[derive(Debug, serde::Deserialize)]
+#[serde(untagged)]
+pub enum ContentEncoding {
+    /// Brotli compression.format.
+    #[serde(rename = "br")]
+    Brotli,
+}
+
+impl TryFrom<&coset::cbor::Value> for ContentEncoding {
+    type Error = anyhow::Error;
+
+    #[allow(clippy::todo)]
+    fn try_from(val: &coset::cbor::Value) -> anyhow::Result<ContentEncoding> {
+        match val.as_text() {
+            Some(encoding) => {
+                match encoding.to_string().to_lowercase().as_ref() {
+                    "br" => Ok(ContentEncoding::Brotli),
+                    _ => anyhow::bail!("Unsupported Content Encoding: {encoding}"),
+                }
+            },
+            _ => {
+                anyhow::bail!("Expected Content Encoding to be a string");
+            },
+        }
+    }
+}

rust/signed_doc/src/metadata/content_type.rs

@@ -0,0 +1,24 @@
+//! Document Payload Content Type.
+
+/// Payload Content Type.
+#[derive(Debug, serde::Deserialize)]
+#[serde(untagged, rename_all_fields = "lowercase")]
+pub enum ContentType {
+    /// 'application/cbor'
+    Cbor,
+    /// 'application/json'
+    Json,
+}
+
+impl TryFrom<&coset::ContentType> for ContentType {
+    type Error = anyhow::Error;
+
+    fn try_from(value: &coset::ContentType) -> Result<Self, Self::Error> {
+        use coset::iana::CoapContentFormat as Format;
+        match value {
+            coset::ContentType::Assigned(Format::Json) => Ok(ContentType::Json),
+            coset::ContentType::Assigned(Format::Cbor) => Ok(ContentType::Cbor),
+            _ => anyhow::bail!("Unsupported Content Type {value:?}"),
+        }
+    }
+}

rust/signed_doc/src/metadata/document_id.rs

@@ -0,0 +1,44 @@
+//! Document ID.
+use std::fmt::{Display, Formatter};
+
+use super::UuidV7;
+
+/// Catalyst Document ID.
+#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, serde::Deserialize)]
+#[serde(from = "UuidV7")]
+pub struct DocumentId {
+    /// Inner UUID type
+    uuid: UuidV7,
+}
+
+impl DocumentId {
+    /// Generates a zeroed out `UUIDv7` that can never be valid.
+    pub fn invalid() -> Self {
+        Self {
+            uuid: UuidV7::invalid(),
+        }
+    }
+
+    /// Check if this is a valid `UUIDv7`.
+    pub fn is_valid(&self) -> bool {
+        self.uuid.is_valid()
+    }
+
+    /// Returns the `uuid::Uuid` type.
+    #[must_use]
+    pub fn uuid(&self) -> uuid::Uuid {
+        self.uuid.uuid()
+    }
+}
+
+impl Display for DocumentId {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        write!(f, "{}", self.uuid)
+    }
+}
+
+impl From<UuidV7> for DocumentId {
+    fn from(uuid: UuidV7) -> Self {
+        Self { uuid }
+    }
+}

rust/signed_doc/src/metadata/document_type.rs

@@ -0,0 +1,39 @@
+//! Document Type.
+use std::fmt::{Display, Formatter};
+
+use super::UuidV4;
+
+/// Catalyst Document Type.
+#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, serde::Deserialize)]
+#[serde(from = "UuidV4")]
+pub struct DocumentType(UuidV4);
+
+impl DocumentType {
+    /// Generates a zeroed out `UUIDv4` that can never be valid.
+    pub fn invalid() -> Self {
+        Self(UuidV4::invalid())
+    }
+
+    /// Check if this is a valid `UUIDv4`.
+    pub fn is_valid(&self) -> bool {
+        self.0.is_valid()
+    }
+
+    /// Returns the `uuid::Uuid` type.
+    #[must_use]
+    pub fn uuid(&self) -> uuid::Uuid {
+        self.0.uuid()
+    }
+}
+
+impl Display for DocumentType {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl From<UuidV4> for DocumentType {
+    fn from(value: UuidV4) -> Self {
+        Self(value)
+    }
+}

rust/signed_doc/src/metadata/document_version.rs

@@ -0,0 +1,38 @@
+//! Document Version.
+use std::fmt::{Display, Formatter};
+
+use super::UuidV7;
+
+/// Catalyst Document Version.
+#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, serde::Deserialize)]
+pub struct DocumentVersion(UuidV7);
+
+impl DocumentVersion {
+    /// Generates a zeroed out `UUIDv7` that can never be valid.
+    pub fn invalid() -> Self {
+        Self(UuidV7::invalid())
+    }
+
+    /// Check if this is a valid `UUIDv7`.
+    pub fn is_valid(&self) -> bool {
+        self.0.is_valid()
+    }
+
+    /// Returns the `uuid::Uuid` type.
+    #[must_use]
+    pub fn uuid(&self) -> uuid::Uuid {
+        self.0.uuid()
+    }
+}
+
+impl Display for DocumentVersion {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl From<UuidV7> for DocumentVersion {
+    fn from(value: UuidV7) -> Self {
+        Self(value)
+    }
+}