wip(rust/signed_doc): add CBOR encode for signed doc

Author: saibatizoku

rust/signed_doc/examples/mk_signed_doc.rs

@@ -10,7 +10,7 @@ use std::{
 
 use catalyst_signed_doc::{CatalystSignedDocument, Decode, Decoder, KidUri, Metadata};
 use clap::Parser;
-use coset::{iana::CoapContentFormat, CborSerializable};
+use coset::{CborSerializable, Header};
 use ed25519_dalek::{ed25519::signature::Signer, pkcs8::DecodePrivateKey};
 
 fn main() {
@@ -55,16 +55,6 @@ enum Cli {
     },
 }
 
-const CONTENT_ENCODING_KEY: &str = "Content-Encoding";
-const UUID_CBOR_TAG: u64 = 37;
-
-fn encode_cbor_uuid(uuid: &uuid::Uuid) -> coset::cbor::Value {
-    coset::cbor::Value::Tag(
-        UUID_CBOR_TAG,
-        coset::cbor::Value::Bytes(uuid.as_bytes().to_vec()).into(),
-    )
-}
-
 impl Cli {
     fn exec(self) -> anyhow::Result<()> {
         match self {
@@ -76,12 +66,12 @@ 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}"))?;
                 println!("{json_meta}");
                 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);
+                let empty_cose_sign = build_empty_cose_doc(compressed_doc, json_meta)?;
                 store_cose_file(empty_cose_sign, &output)?;
             },
             Self::Sign { sk, doc, kid } => {
@@ -159,39 +149,12 @@ fn brotli_compress_json(doc: &serde_json::Value) -> anyhow::Result<Vec<u8>> {
     Ok(buf)
 }
 
-fn build_empty_cose_doc(doc_bytes: Vec<u8>, meta: &Metadata) -> coset::CoseSign {
-    let mut builder =
-        coset::HeaderBuilder::new().content_format(CoapContentFormat::from(meta.content_type()));
-
-    if let Some(content_encoding) = meta.content_encoding() {
-        builder = builder.text_value(
-            CONTENT_ENCODING_KEY.to_string(),
-            format!("{content_encoding}").into(),
-        );
-    }
-    let mut protected_header = builder.build();
-
-    protected_header.rest.push((
-        coset::Label::Text("type".to_string()),
-        encode_cbor_uuid(&meta.doc_type()),
-    ));
-    protected_header.rest.push((
-        coset::Label::Text("id".to_string()),
-        encode_cbor_uuid(&meta.doc_id()),
-    ));
-    protected_header.rest.push((
-        coset::Label::Text("ver".to_string()),
-        encode_cbor_uuid(&meta.doc_ver()),
-    ));
-    let meta_rest = meta.extra().header_rest().unwrap_or_default();
-
-    if !meta_rest.is_empty() {
-        protected_header.rest.extend(meta_rest);
-    }
-    coset::CoseSignBuilder::new()
+fn build_empty_cose_doc(doc_bytes: Vec<u8>, meta: &Metadata) -> anyhow::Result<coset::CoseSign> {
+    let protected_header = Header::try_from(meta)?;
+    Ok(coset::CoseSignBuilder::new()
         .protected(protected_header)
         .payload(doc_bytes)
-        .build()
+        .build())
 }
 
 fn load_cose_from_file(cose_path: &PathBuf) -> anyhow::Result<coset::CoseSign> {

rust/signed_doc/src/lib.rs

@@ -15,9 +15,9 @@ use std::{
 use anyhow::anyhow;
 pub use builder::Builder;
 use content::Content;
-use coset::CborSerializable;
-pub use metadata::{AdditionalFields, DocumentRef, Metadata, UuidV7};
-pub use minicbor::{decode, Decode, Decoder};
+use coset::{CborSerializable, Header};
+pub use metadata::{AdditionalFields, DocumentRef, Metadata, UuidV4, UuidV7};
+pub use minicbor::{decode, encode, Decode, Decoder, Encode};
 pub use signature::KidUri;
 use signature::Signatures;
 
@@ -56,19 +56,19 @@ impl CatalystSignedDocument {
 
     /// Return Document Type `UUIDv4`.
     #[must_use]
-    pub fn doc_type(&self) -> uuid::Uuid {
+    pub fn doc_type(&self) -> UuidV4 {
         self.inner.metadata.doc_type()
     }
 
     /// Return Document ID `UUIDv7`.
     #[must_use]
-    pub fn doc_id(&self) -> uuid::Uuid {
+    pub fn doc_id(&self) -> UuidV7 {
         self.inner.metadata.doc_id()
     }
 
     /// Return Document Version `UUIDv7`.
     #[must_use]
-    pub fn doc_ver(&self) -> uuid::Uuid {
+    pub fn doc_ver(&self) -> UuidV7 {
         self.inner.metadata.doc_ver()
     }
 
@@ -151,3 +151,25 @@ impl Decode<'_, ()> for CatalystSignedDocument {
         }
     }
 }
+
+impl Encode<()> for CatalystSignedDocument {
+    fn encode<W: minicbor::encode::Write>(
+        &self, e: &mut encode::Encoder<W>, ctx: &mut (),
+    ) -> Result<(), encode::Error<W::Error>> {
+        let protected_header = Header::try_from(&self.inner.metadata).map_err(|e| {
+            minicbor::encode::Error::message(format!("Failed to encode Document Metadata: {e}"))
+        })?;
+        let mut builder = coset::CoseSignBuilder::new()
+            .protected(protected_header)
+            .payload(self.inner.content.bytes().to_vec());
+        for signature in self.signatures().signatures() {
+            builder = builder.add_signature(signature);
+        }
+        let cose_sign = builder.build();
+        let cose_bytes = cose_sign.to_vec().map_err(|e| {
+            minicbor::encode::Error::message(format!("Failed to encode COSE Sign document: {e}"))
+        })?;
+        cose_bytes.encode(e, ctx)?;
+        Ok(())
+    }
+}

rust/signed_doc/src/metadata/additional_fields.rs

@@ -3,7 +3,7 @@
 use anyhow::anyhow;
 use coset::{cbor::Value, Label, ProtectedHeader};
 
-use super::{cose_protected_header_find, decode_cbor_uuid, encode_cbor_value, DocumentRef, UuidV4};
+use super::{cose_protected_header_find, decode_cbor_uuid, encode_cbor_uuid, DocumentRef, UuidV4};
 
 /// Additional Metadata Fields.
 ///
@@ -36,71 +36,56 @@ impl AdditionalFields {
     ///
     /// # Errors
     /// If any internal field cannot be converted into `Value`.
-    pub fn header_rest(&self) -> anyhow::Result<Vec<(Label, Value)>> {
+    pub fn header_rest(&self) -> anyhow::Result<Vec<(String, Value)>> {
         self.try_into()
     }
 }
 
-impl TryFrom<&AdditionalFields> for Vec<(Label, Value)> {
+impl TryFrom<&AdditionalFields> for Vec<(String, Value)> {
     type Error = anyhow::Error;
 
     fn try_from(fields: &AdditionalFields) -> anyhow::Result<Self> {
         let mut vec = Vec::new();
 
         if let Some(doc_ref) = &fields.doc_ref {
-            vec.push((Label::Text("ref".to_string()), doc_ref.try_into()?));
+            vec.push(("ref".to_string(), Value::try_from(*doc_ref)?));
         }
 
         if let Some(template) = &fields.template {
-            vec.push((Label::Text("template".to_string()), template.try_into()?));
+            vec.push(("template".to_string(), Value::try_from(*template)?));
         }
 
         if let Some(reply) = &fields.reply {
-            vec.push((Label::Text("reply".to_string()), reply.try_into()?));
+            vec.push(("reply".to_string(), Value::try_from(*reply)?));
         }
 
         if let Some(section) = &fields.section {
-            vec.push((
-                Label::Text("section".to_string()),
-                Value::Text(section.clone()),
-            ));
+            vec.push(("section".to_string(), Value::Text(section.clone())));
         }
 
         if let Some(collabs) = &fields.collabs {
             if !collabs.is_empty() {
                 vec.push((
-                    Label::Text("collabs".to_string()),
+                    "collabs".to_string(),
                     Value::Array(collabs.iter().cloned().map(Value::Text).collect()),
                 ));
             }
         }
 
         if let Some(brand_id) = &fields.brand_id {
-            vec.push((
-                Label::Text("brand_id".to_string()),
-                encode_cbor_value(brand_id)?,
-            ));
+            vec.push(("brand_id".to_string(), encode_cbor_uuid(brand_id)?));
         }
 
         if let Some(campaign_id) = &fields.campaign_id {
-            vec.push((
-                Label::Text("campaign_id".to_string()),
-                encode_cbor_value(campaign_id)?,
-            ));
+            vec.push(("campaign_id".to_string(), encode_cbor_uuid(campaign_id)?));
         }
 
         if let Some(election_id) = &fields.election_id {
-            vec.push((
-                Label::Text("election_id".to_string()),
-                encode_cbor_value(election_id)?,
-            ));
+            vec.push(("election_id".to_string(), encode_cbor_uuid(election_id)?));
         }
 
         if let Some(category_id) = &fields.category_id {
-            vec.push((
-                Label::Text("category_id".to_string()),
-                encode_cbor_value(*category_id)?,
-            ));
+            vec.push(("category_id".to_string(), encode_cbor_uuid(*category_id)?));
         }
 
         Ok(vec)

rust/signed_doc/src/metadata/document_id.rs

@@ -1,7 +1,9 @@
 //! Document ID.
 use std::fmt::{Display, Formatter};
 
-use super::UuidV7;
+use coset::cbor::Value;
+
+use super::{encode_cbor_uuid, UuidV7};
 
 /// Catalyst Document ID.
 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd, serde::Deserialize)]
@@ -27,3 +29,17 @@ impl From<UuidV7> for DocumentId {
         Self(uuid)
     }
 }
+
+impl From<DocumentId> for UuidV7 {
+    fn from(value: DocumentId) -> Self {
+        value.0
+    }
+}
+
+impl TryFrom<DocumentId> for Value {
+    type Error = anyhow::Error;
+
+    fn try_from(value: DocumentId) -> Result<Self, Self::Error> {
+        encode_cbor_uuid(value.0).map_err(|e| anyhow::anyhow!("{e}"))
+    }
+}

rust/signed_doc/src/metadata/document_ref.rs

@@ -1,7 +1,7 @@
 //! Catalyst Signed Document Metadata.
 use coset::cbor::Value;
 
-use super::{decode_cbor_uuid, encode_cbor_value, UuidV7};
+use super::{decode_cbor_uuid, encode_cbor_uuid, UuidV7};
 
 /// Reference to a Document.
 #[derive(Copy, Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -21,16 +21,16 @@ pub enum DocumentRef {
     },
 }
 
-impl TryFrom<&DocumentRef> for Value {
+impl TryFrom<DocumentRef> for Value {
     type Error = anyhow::Error;
 
-    fn try_from(value: &DocumentRef) -> Result<Self, Self::Error> {
+    fn try_from(value: DocumentRef) -> Result<Self, Self::Error> {
         match value {
-            DocumentRef::Latest { id } => encode_cbor_value(id),
+            DocumentRef::Latest { id } => encode_cbor_uuid(id),
             DocumentRef::WithVer { id, ver } => {
                 Ok(Value::Array(vec![
-                    encode_cbor_value(id)?,
-                    encode_cbor_value(ver)?,
+                    encode_cbor_uuid(id)?,
+                    encode_cbor_uuid(ver)?,
                 ]))
             },
         }

rust/signed_doc/src/metadata/document_type.rs

@@ -1,7 +1,9 @@
 //! Document Type.
 use std::fmt::{Display, Formatter};
 
-use super::UuidV4;
+use coset::cbor::Value;
+
+use super::{encode_cbor_uuid, UuidV4};
 
 /// Catalyst Document Type.
 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd, serde::Deserialize)]
@@ -27,3 +29,17 @@ impl From<UuidV4> for DocumentType {
         Self(value)
     }
 }
+
+impl From<DocumentType> for UuidV4 {
+    fn from(value: DocumentType) -> Self {
+        value.0
+    }
+}
+
+impl TryFrom<DocumentType> for Value {
+    type Error = anyhow::Error;
+
+    fn try_from(value: DocumentType) -> Result<Self, Self::Error> {
+        encode_cbor_uuid(value.0).map_err(|e| anyhow::anyhow!("{e}"))
+    }
+}

rust/signed_doc/src/metadata/document_version.rs

@@ -1,7 +1,9 @@
 //! Document Version.
 use std::fmt::{Display, Formatter};
 
-use super::UuidV7;
+use coset::cbor::Value;
+
+use super::{encode_cbor_uuid, UuidV7};
 
 /// Catalyst Document Version.
 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd, serde::Deserialize)]
@@ -26,3 +28,17 @@ impl From<UuidV7> for DocumentVersion {
         Self(value)
     }
 }
+
+impl From<DocumentVersion> for UuidV7 {
+    fn from(value: DocumentVersion) -> Self {
+        value.0
+    }
+}
+
+impl TryFrom<DocumentVersion> for Value {
+    type Error = anyhow::Error;
+
+    fn try_from(value: DocumentVersion) -> Result<Self, Self::Error> {
+        encode_cbor_uuid(value.0).map_err(|e| anyhow::anyhow!("{e}"))
+    }
+}