wip

Author: Mr-Leshiy

rust/signed_doc/Cargo.toml

@@ -30,6 +30,7 @@ futures = "0.3.31"
 base64-url = "3.0.0"
 rand = "0.8.5"
 tokio = { version = "1.42.0", features = [ "macros" ] }
+ed25519-dalek = { version = "2.1.1", features = ["rand_core"] }
 
 [[bin]]
 name = "signed-docs"

rust/signed_doc/src/builder.rs

@@ -26,12 +26,25 @@ impl Builder {
     }
 
     /// Set document metadata
+    ///
+    /// # Errors
+    /// - Fails if it is invalid metadata JSON object.
     #[must_use]
     pub fn with_metadata(mut self, metadata: Metadata) -> Self {
         self.metadata = Some(metadata);
         self
     }
 
+    /// Set document metadata in JSON format
+    ///
+    /// # Errors
+    /// - Fails if it is invalid metadata JSON object.
+    #[must_use]
+    pub fn with_json_metadata(mut self, json: serde_json::Value) -> anyhow::Result<Self> {
+        self.metadata = Some(serde_json::from_value(json)?);
+        Ok(self)
+    }
+
     /// Set decoded (original) document content bytes
     #[must_use]
     pub fn with_decoded_content(mut self, content: Vec<u8>) -> Self {

rust/signed_doc/src/lib.rs

@@ -19,7 +19,9 @@ use catalyst_types::problem_report::ProblemReport;
 pub use catalyst_types::uuid::{Uuid, UuidV4, UuidV7};
 pub use content::Content;
 use coset::{CborSerializable, Header};
-pub use metadata::{ContentEncoding, ContentType, DocumentRef, ExtraFields, Metadata, Section};
+pub use metadata::{
+    Algorithm, ContentEncoding, ContentType, DocumentRef, ExtraFields, Metadata, Section,
+};
 use minicbor::{decode, encode, Decode, Decoder, Encode};
 use providers::VerifyingKeyProvider;
 pub use signature::{IdUri, Signatures};
@@ -226,9 +228,12 @@ impl CatalystSignedDocument {
     /// data.
     ///
     /// # Errors
-    /// Could fails if the `CatalystSignedDocument` object is not valid.
+    /// Fails if the `CatalystSignedDocument` object is not valid.
     #[must_use]
     pub fn into_builder(self) -> anyhow::Result<Builder> {
+        if self.report().is_problematic() {
+            anyhow::bail!("Invalid Document");
+        }
         Ok(Builder::new()
             .with_metadata(self.inner.metadata.clone())
             .with_decoded_content(self.doc_content().decoded_bytes()?.to_vec())
@@ -327,14 +332,16 @@ mod tests {
     use super::*;
 
     fn test_metadata() -> anyhow::Result<(UuidV7, UuidV4, Metadata)> {
+        let alg = Algorithm::EdDSA;
         let uuid_v7 = UuidV7::new();
         let uuid_v4 = UuidV4::new();
-        let section = "some section".to_string();
+        let section = "$".to_string();
         let collabs = vec!["Alex1".to_string(), "Alex2".to_string()];
         let content_type = ContentType::Json;
         let content_encoding = ContentEncoding::Brotli;
 
         let metadata: Metadata = serde_json::from_value(serde_json::json!({
+            "alg": alg.to_string(),
             "content-type": content_type.to_string(),
             "content-encoding": content_encoding.to_string(),
             "type": uuid_v4.to_string(),
@@ -350,7 +357,7 @@ mod tests {
             "brand_id":  {"id": uuid_v7.to_string()},
             "category_id": {"id": uuid_v7.to_string()},
         }))
-        .map_err(|_| anyhow::anyhow!("Invalid example metadata. This should not happen."))?;
+        .map_err(|e| anyhow::anyhow!("Invalid example metadata. This should not happen. Err: {e}"))?;
         Ok((uuid_v7, uuid_v4, metadata))
     }
 

rust/signed_doc/src/metadata/algorithm.rs

@@ -1,5 +1,7 @@
 //! Cryptographic Algorithm in COSE SIGN protected header.
 
+use std::fmt::{Display, Formatter};
+
 use strum::VariantArray;
 
 /// Cryptography Algorithm.
@@ -9,6 +11,20 @@ pub enum Algorithm {
     EdDSA,
 }
 
+impl Default for Algorithm {
+    fn default() -> Self {
+        Self::EdDSA
+    }
+}
+
+impl Display for Algorithm {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        match self {
+            Self::EdDSA => write!(f, "EdDSA"),
+        }
+    }
+}
+
 impl From<Algorithm> for coset::iana::Algorithm {
     fn from(_: Algorithm) -> Self {
         coset::iana::Algorithm::EdDSA

rust/signed_doc/src/metadata/mod.rs

@@ -9,7 +9,7 @@ mod extra_fields;
 mod section;
 pub(crate) mod utils;
 
-use algorithm::Algorithm;
+pub use algorithm::Algorithm;
 use catalyst_types::{
     problem_report::ProblemReport,
     uuid::{UuidV4, UuidV7},
@@ -20,7 +20,7 @@ use coset::iana::CoapContentFormat;
 pub use document_ref::DocumentRef;
 pub use extra_fields::ExtraFields;
 pub use section::Section;
-use utils::{cose_protected_header_find, decode_cbor_uuid, encode_cbor_uuid};
+use utils::{cose_protected_header_find, decode_cbor_uuid, encode_cbor_uuid, validate_option};
 
 /// `content_encoding` field COSE key value
 const CONTENT_ENCODING_KEY: &str = "Content-Encoding";
@@ -37,22 +37,22 @@ const VER_KEY: &str = "ver";
 #[derive(Clone, Debug, PartialEq, serde::Deserialize, Default)]
 pub struct Metadata {
     /// Cryptographic Algorithm
-    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(deserialize_with = "validate_option")]
     alg: Option<Algorithm>,
     /// Document Type `UUIDv4`.
-    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "type", deserialize_with = "validate_option")]
     doc_type: Option<UuidV4>,
     /// Document ID `UUIDv7`.
-    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(deserialize_with = "validate_option")]
     id: Option<UuidV7>,
     /// Document Version `UUIDv7`.
-    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(deserialize_with = "validate_option")]
     ver: Option<UuidV7>,
     /// Document Payload Content Type.
-    #[serde(rename = "content-type")]
+    #[serde(rename = "content-type", deserialize_with = "validate_option")]
     content_type: Option<ContentType>,
     /// Document Payload Content Encoding.
-    #[serde(rename = "content-encoding", skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "content-encoding")]
     content_encoding: Option<ContentEncoding>,
     /// Additional Metadata Fields.
     #[serde(flatten)]
@@ -300,3 +300,69 @@ impl TryFrom<&Metadata> for coset::Header {
         Ok(builder.build())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn metadata_serde_test() {
+        let alg = Algorithm::EdDSA;
+        let uuid_v7 = UuidV7::new();
+        let uuid_v4 = UuidV4::new();
+        let content_type = ContentType::Json;
+
+        let valid = serde_json::json!({
+            "alg": alg.to_string(),
+            "content-type": content_type.to_string(),
+            "type": uuid_v4.to_string(),
+            "id": uuid_v7.to_string(),
+            "ver": uuid_v7.to_string(),
+
+        });
+        assert!(serde_json::from_value::<Metadata>(valid).is_ok());
+
+        let missing_alg = serde_json::json!({
+            "content-type": content_type.to_string(),
+            "type": uuid_v4.to_string(),
+            "id": uuid_v7.to_string(),
+            "ver": uuid_v7.to_string(),
+
+        });
+        assert!(serde_json::from_value::<Metadata>(missing_alg).is_err());
+
+        let missing_content_type = serde_json::json!({
+            "alg": alg.to_string(),
+            "type": uuid_v4.to_string(),
+            "id": uuid_v7.to_string(),
+            "ver": uuid_v7.to_string(),
+        });
+        assert!(serde_json::from_value::<Metadata>(missing_content_type).is_err());
+
+        let missing_type = serde_json::json!({
+            "alg": alg.to_string(),
+            "content-type": content_type.to_string(),
+            "id": uuid_v7.to_string(),
+            "ver": uuid_v7.to_string(),
+
+        });
+        assert!(serde_json::from_value::<Metadata>(missing_type).is_err());
+
+        let missing_id = serde_json::json!({
+            "alg": alg.to_string(),
+            "content-type": content_type.to_string(),
+            "type": uuid_v4.to_string(),
+            "ver": uuid_v7.to_string(),
+
+        });
+        assert!(serde_json::from_value::<Metadata>(missing_id).is_err());
+
+        let missing_ver = serde_json::json!({
+            "alg": alg.to_string(),
+            "content-type": content_type.to_string(),
+            "type": uuid_v4.to_string(),
+            "id": uuid_v7.to_string(),
+        });
+        assert!(serde_json::from_value::<Metadata>(missing_ver).is_err());
+    }
+}

rust/signed_doc/src/metadata/utils.rs

@@ -2,6 +2,22 @@
 
 use catalyst_types::uuid::CborContext;
 use coset::CborSerializable;
+use serde::{Deserialize, Deserializer};
+
+/// Custom serde deserialization function that fails if the field is `None`
+pub(crate) fn validate_option<'de, T, D>(deserializer: D) -> Result<Option<T>, D::Error>
+where
+    T: Deserialize<'de>,
+    D: Deserializer<'de>,
+{
+    let value = Option::deserialize(deserializer)?;
+    if value.is_none() {
+        return Err(serde::de::Error::custom(
+            "Field is required but was missing or null",
+        ));
+    }
+    Ok(value)
+}
 
 /// Find a value for a predicate in the protected header.
 pub(crate) fn cose_protected_header_find(