feat: C509 Name type

catalyst-gateway-crates/c509-certificate/Cargo.toml

@@ -57,6 +57,7 @@ bimap = "0.6.3"
 once_cell = "1.19.0"
 strum = "0.26.3"
 strum_macros = "0.26.3"
+regex = "1.10.5"
 
 [package.metadata.cargo-machete]
 ignored = ["strum"]

catalyst-gateway-crates/c509-certificate/src/c509_attributes/attribute.rs

@@ -0,0 +1,219 @@
+//! C509 Attribute
+//!
+//! ```cddl
+//! Attribute = ( attributeType: int, attributeValue: text ) //
+//! ( attributeType: ~oid, attributeValue: bytes ) //
+//! ( attributeType: pen, attributeValue: bytes )
+//! ```
+//!
+//! For more information about Attribute,
+//! visit [C509 Certificate](https://datatracker.ietf.org/doc/draft-ietf-cose-cbor-encoded-cert/09/)
+
+use asn1_rs::Oid;
+use minicbor::{encode::Write, Decode, Decoder, Encode, Encoder};
+
+use super::data::{get_oid_from_int, ATTRIBUTES_LOOKUP};
+use crate::c509_oid::{C509oid, C509oidRegistered};
+
+/// A struct of C509 `Attribute`
+#[derive(Debug, Clone, PartialEq)]
+pub struct Attribute {
+    /// A registered OID of C509 `Attribute`.
+    registered_oid: C509oidRegistered,
+    /// A flag to indicate whether the value can have multiple value.
+    multi_value: bool,
+    /// A value of C509 `Attribute` can be a vector of text or bytes.
+    value: Vec<AttributeValue>,
+}
+
+impl Attribute {
+    /// Create a new instance of `Attribute`.
+    #[must_use]
+    pub fn new(oid: Oid<'static>) -> Self {
+        Self {
+            registered_oid: C509oidRegistered::new(oid, ATTRIBUTES_LOOKUP.get_int_to_oid_table()),
+            multi_value: false,
+            value: Vec::new(),
+        }
+    }
+
+    /// Add a value to `Attribute`.
+    pub fn add_value(&mut self, value: AttributeValue) {
+        self.value.push(value);
+    }
+
+    /// Get the registered OID of `Attribute`.
+    pub(crate) fn get_registered_oid(&self) -> &C509oidRegistered {
+        &self.registered_oid
+    }
+
+    /// Get the value of `Attribute`.
+    pub(crate) fn get_value(&self) -> &Vec<AttributeValue> {
+        &self.value
+    }
+
+    /// Set whether `Attribute` can be PEN encoded.
+    pub(crate) fn set_pen_supported(self) -> Self {
+        Self {
+            registered_oid: self.registered_oid.pen_encoded(),
+            multi_value: self.multi_value,
+            value: self.value,
+        }
+    }
+
+    /// Set whether `Attribute` can have multiple value.
+    pub(crate) fn set_multi_value(mut self) -> Self {
+        self.multi_value = true;
+        self
+    }
+}
+
+impl Encode<()> for Attribute {
+    fn encode<W: Write>(
+        &self, e: &mut Encoder<W>, ctx: &mut (),
+    ) -> Result<(), minicbor::encode::Error<W::Error>> {
+        // Encode CBOR int if available
+        if let Some(&oid) = self
+            .registered_oid
+            .get_table()
+            .get_map()
+            .get_by_right(&self.registered_oid.get_c509_oid().get_oid())
+        {
+            e.i16(oid)?;
+        } else {
+            // Encode unwrapped CBOR OID or CBOR PEN
+            self.registered_oid.get_c509_oid().encode(e, ctx)?;
+        }
+
+        // Check if the attribute value is empty
+        if self.value.is_empty() {
+            return Err(minicbor::encode::Error::message("Attribute value is empty"));
+        }
+
+        // If multi-value attributes, encode it as array
+        if self.multi_value {
+            e.array(self.value.len() as u64)?;
+        }
+
+        // Encode each value in the attribute
+        for value in &self.value {
+            value.encode(e, ctx)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl Decode<'_, ()> for Attribute {
+    fn decode(d: &mut Decoder<'_>, ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+        // Handle CBOR int
+        let mut attr = if d.datatype()? == minicbor::data::Type::U8 {
+            let i = d.i16()?;
+            let oid = get_oid_from_int(i).map_err(minicbor::decode::Error::message)?;
+            Attribute::new(oid.clone())
+        } else {
+            // Handle unwrapped CBOR OID or CBOR PEN
+            let c509_oid: C509oid = d.decode()?;
+            Attribute::new(c509_oid.get_oid())
+        };
+
+        // Handle attribute value
+        if d.datatype()? == minicbor::data::Type::Array {
+            // When multi-value attribute
+            let len = d.array()?.ok_or_else(|| {
+                minicbor::decode::Error::message("Failed to get array length for attribute value")
+            })?;
+
+            if len == 0 {
+                return Err(minicbor::decode::Error::message("Attribute value is empty"));
+            }
+
+            for _ in 0..len {
+                attr.add_value(AttributeValue::decode(d, ctx)?);
+            }
+            attr = attr.set_multi_value();
+        } else {
+            let value = AttributeValue::decode(d, ctx)?;
+            attr.add_value(value);
+        }
+        Ok(attr)
+    }
+}
+
+// ------------------AttributeValue----------------------
+
+/// An enum of possible value types for `Attribute`.
+#[allow(clippy::module_name_repetitions)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum AttributeValue {
+    /// A text string.
+    Text(String),
+    /// A byte vector.
+    Bytes(Vec<u8>),
+}
+
+impl Encode<()> for AttributeValue {
+    fn encode<W: Write>(
+        &self, e: &mut Encoder<W>, _ctx: &mut (),
+    ) -> Result<(), minicbor::encode::Error<W::Error>> {
+        match self {
+            AttributeValue::Text(text) => e.str(text)?,
+            AttributeValue::Bytes(bytes) => e.bytes(bytes)?,
+        };
+        Ok(())
+    }
+}
+
+impl Decode<'_, ()> for AttributeValue {
+    fn decode(d: &mut Decoder<'_>, _ctx: &mut ()) -> Result<Self, minicbor::decode::Error> {
+        match d.datatype()? {
+            minicbor::data::Type::String => Ok(AttributeValue::Text(d.str()?.to_string())),
+            minicbor::data::Type::Bytes => Ok(AttributeValue::Bytes(d.bytes()?.to_vec())),
+            _ => {
+                Err(minicbor::decode::Error::message(
+                    "Invalid AttributeValue, value should be either String or Bytes",
+                ))
+            },
+        }
+    }
+}
+
+// ------------------Test----------------------
+
+#[cfg(test)]
+mod test_attribute {
+    use asn1_rs::oid;
+
+    use super::*;
+
+    #[test]
+    fn encode_decode_attribute_int() {
+        let mut buffer = Vec::new();
+        let mut encoder = Encoder::new(&mut buffer);
+        let mut attribute = Attribute::new(oid!(1.2.840 .113549 .1 .9 .1));
+        attribute.add_value(AttributeValue::Text("example@example.com".to_string()));
+        attribute
+            .encode(&mut encoder, &mut ())
+            .expect("Failed to encode Attribute");
+        // Email Address example@example.com: 0x00736578616d706c65406578616d706c652e636f6d
+        assert_eq!(
+            hex::encode(buffer.clone()),
+            "00736578616d706c65406578616d706c652e636f6d"
+        );
+
+        let mut decoder = Decoder::new(&buffer);
+        let attribute_decoded =
+            Attribute::decode(&mut decoder, &mut ()).expect("Failed to decode Attribute");
+        assert_eq!(attribute_decoded, attribute);
+    }
+
+    #[test]
+    fn empty_attribute_value() {
+        let mut buffer = Vec::new();
+        let mut encoder = Encoder::new(&mut buffer);
+        let attribute = Attribute::new(oid!(1.2.840 .113549 .1 .9 .1));
+        attribute
+            .encode(&mut encoder, &mut ())
+            .expect_err("Failed to encode Attribute");
+    }
+}

catalyst-gateway-crates/c509-certificate/src/c509_attributes/data.rs

@@ -0,0 +1,88 @@
+//! Attribute data provides a necessary information for encoding and decoding of C509
+//! Attribute. See [C509 Certificate](https://datatracker.ietf.org/doc/draft-ietf-cose-cbor-encoded-cert/09/)
+//! Section 9.3 C509 Attributes Registry for more information.
+
+use anyhow::Error;
+use asn1_rs::{oid, Oid};
+use once_cell::sync::Lazy;
+
+use crate::tables::IntegerToOidTable;
+
+/// Type of `Attribute` data
+/// Int | OID | Name
+type AttributeDataTuple = (i16, Oid<'static>, &'static str);
+
+/// `Attribute` data table
+#[rustfmt::skip]
+const ATTRIBUTE_DATA: [AttributeDataTuple; 30] = [
+    // Int |           OID               |       Name
+    (0, oid!(1.2.840.113549.1.9.1),         "Email Address"),
+    (1, oid!(2.5.4.3),                      "Common Name"),
+    (2, oid!(2.5.4.4),                      "Surname"),
+    (3, oid!(2.5.4.5),                      "Serial Number"),
+    (4, oid!(2.5.4.6),                      "Country"),
+    (5, oid!(2.5.4.7),                      "Locality"),
+    (6, oid!(2.5.4.8),                      "State or Province"),
+    (7, oid!(2.5.4.9),                      "Street Address"),
+    (8, oid!(2.5.4.10),                     "Organization"),
+    (9, oid!(2.5.4.11),                     "Organizational Unit"),
+    (10, oid!(2.5.4.12),                    "Title"),
+    (11, oid!(2.5.4.15),                    "Business Category"),
+    (12, oid!(2.5.4.17),                    "Postal Code"),
+    (13, oid!(2.5.4.42),                    "Given Name"),
+    (14, oid!(2.5.4.43),                    "Initials"),
+    (15, oid!(2.5.4.44),                    "Generation Qualifier"),
+    (16, oid!(2.5.4.46),                    "DN Qualifier"),
+    (17, oid!(2.5.4.65),                    "Pseudonym"),
+    (18, oid!(2.5.4.97),                    "Organization Identifier"),
+    (19, oid!(1.3.6.1.4.1.311.60.2.1.1),    "Inc. Locality"),
+    (20, oid!(1.3.6.1.4.1.311.60.2.1.2),    "Inc. State or Province"),
+    (21, oid!(1.3.6.1.4.1.311.60.2.1.3),    "Inc. Country"),
+    (22, oid!(0.9.2342.19200300.100.1.25),  "Domain Component"),
+    (23, oid!(2.5.4.16),                    "Postal Address"),
+    (24, oid!(2.5.4.41),                    "Name"),
+    (25, oid!(2.5.4.20),                    "Telephone Number"),
+    (26, oid!(2.5.4.54),                    "Directory Management Domain Name"),
+    (27, oid!(0.9.2342.19200300.100.1.1),   "userid"),
+    (28, oid!(1.2.840.113549.1.9.2),        "Unstructured Name"),
+    (29, oid!(1.2.840.113549.1.9.8),        "Unstructured Address"),
+];
+
+/// A struct of data that contains lookup tables for `Attribute`.
+pub(crate) struct AttributeData {
+    /// A table of integer to OID, provide a bidirectional lookup.
+    int_to_oid_table: IntegerToOidTable,
+}
+
+impl AttributeData {
+    /// Get the `IntegerToOidTable`.
+    pub(crate) fn get_int_to_oid_table(&self) -> &IntegerToOidTable {
+        &self.int_to_oid_table
+    }
+}
+
+/// Define static lookup for attributes table
+static ATTRIBUTES_TABLES: Lazy<AttributeData> = Lazy::new(|| {
+    let mut int_to_oid_table = IntegerToOidTable::new();
+
+    for data in ATTRIBUTE_DATA {
+        int_to_oid_table.add(data.0, data.1);
+    }
+
+    AttributeData { int_to_oid_table }
+});
+
+/// Static reference to the `AttributeData` lookup table.
+pub(crate) static ATTRIBUTES_LOOKUP: &Lazy<AttributeData> = &ATTRIBUTES_TABLES;
+
+/// Get the OID from the int value.
+pub(crate) fn get_oid_from_int(i: i16) -> Result<Oid<'static>, Error> {
+    ATTRIBUTES_TABLES
+        .get_int_to_oid_table()
+        .get_map()
+        .get_by_left(&i)
+        .ok_or(Error::msg(format!(
+            "OID int not found in the attribute registry table given {i}"
+        )))
+        .cloned()
+}