Updating to fix serialization

- Removing tags from all enumerations
- Using `#[serde(flatten)]` where appropriate
- Swapping renames to numbers per the spec
- Renamed methods to clarify raw values where
  appropriate.

Signed-off-by: Larry Dewey <[email protected]>

Author: larrydewey

src/comid.rs

@@ -114,20 +114,24 @@ generate_tagged!((
 pub struct ConciseMidTag<'a> {
     /// Optional language identifier for the tag content
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "0")]
     pub language: Option<Text<'a>>,
     /// Identity information for this tag
-    #[serde(rename = "tag-identity")]
+    #[serde(rename = "1")]
     pub tag_identity: TagIdentityMap<'a>,
     /// List of entities associated with this tag
+    #[serde(rename = "2")]
     pub entities: OneOrMany<ComidEntityMap<'a>>,
     /// Optional references to other related tags
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(rename = "linked-tags")]
+    #[serde(rename = "3")]
     pub linked_tags: Option<OneOrMany<LinkedTagMap<'a>>>,
     /// Collection of triples describing the module
+    #[serde(rename = "4")]
     pub triples: TriplesMap<'a>,
     /// Optional extensible attributes
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(flatten)]
     pub extension: Option<ExtensionMap<'a>>,
 }
 
@@ -189,10 +193,10 @@ impl<'a> ConciseMidTag<'a> {
     ///    - If no reference triples exist, a new one is created
     ///    - If a reference triple with the matching environment exists, the measurement is added to it
     ///    - If reference triples exist but none match the environment, a new triple is added
-    pub fn add_reference_value<T>(
+    pub fn add_reference_raw_value<T>(
         &mut self,
         environment: &EnvironmentMap<'a>,
-        mkey: Option<MeasuredElementTypeChoice<'a>>,
+        mkey: MeasuredElementTypeChoice<'a>,
         value: &T,
     ) -> Result<(), std::io::Error>
     where
@@ -204,7 +208,7 @@ impl<'a> ConciseMidTag<'a> {
         let raw_value = TaggedBytes::new(raw_bytes);
 
         let measurement = MeasurementMap {
-            mkey,
+            mkey: Some(mkey),
             mval: MeasurementValuesMap {
                 raw: Some(RawValueType {
                     raw_value: raw_value.into(),
@@ -262,10 +266,10 @@ impl<'a> ConciseMidTag<'a> {
         }
         Ok(())
     }
-    pub fn add_endorsement_value<T>(
+    pub fn add_endorsement_raw_value<T>(
         &mut self,
         environment: &EnvironmentMap<'a>,
-        mkey: Option<MeasuredElementTypeChoice<'a>>,
+        mkey: MeasuredElementTypeChoice<'a>,
         value: &T,
     ) -> Result<(), std::io::Error>
     where
@@ -277,7 +281,7 @@ impl<'a> ConciseMidTag<'a> {
         let raw_value = TaggedBytes::new(raw_bytes);
 
         let measurement = MeasurementMap {
-            mkey,
+            mkey: Some(mkey),
             mval: MeasurementValuesMap {
                 raw: Some(RawValueType {
                     raw_value: raw_value.into(),
@@ -355,6 +359,7 @@ pub struct TagIdentityMap<'a> {
 /// Represents either a string or UUID tag identifier
 #[derive(Debug, Serialize, Deserialize, From, TryFrom, PartialEq, Eq, PartialOrd, Ord, Clone)]
 #[repr(C)]
+#[serde(untagged)]
 pub enum TagIdTypeChoice<'a> {
     /// Text string identifier
     Tstr(Tstr<'a>),
@@ -392,6 +397,7 @@ pub struct ComidEntityMap<'a> {
 /// Role types that can be assigned to entities
 #[derive(Debug, Serialize, Deserialize, From, TryFrom, PartialEq, Eq, PartialOrd, Ord, Clone)]
 #[repr(C)]
+#[serde(untagged)]
 pub enum ComidRoleTypeChoice {
     /// Entity that created the tag (value: 0)
     TagCreator = 0,
@@ -408,16 +414,17 @@ pub enum ComidRoleTypeChoice {
 #[repr(C)]
 pub struct LinkedTagMap<'a> {
     /// Identifier of the linked tag
-    #[serde(rename = "linked-tag-id")]
+    #[serde(rename = "0")]
     pub linked_tag_id: TagIdTypeChoice<'a>,
     /// Relationship type between the tags
-    #[serde(rename = "tag-rel")]
+    #[serde(rename = "1")]
     pub tag_rel: TagRelTypeChoice,
 }
 
 /// Types of relationships between tags
 #[derive(Debug, Serialize, Deserialize, From, TryFrom, PartialEq, Eq, PartialOrd, Ord, Clone)]
 #[repr(C)]
+#[serde(untagged)]
 pub enum TagRelTypeChoice {
     /// This tag supplements the linked tag by providing additional information
     /// without replacing or invalidating the linked tag's content
@@ -433,48 +440,48 @@ pub enum TagRelTypeChoice {
 pub struct TriplesMap<'a> {
     /// Optional reference triples that link to external references
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(rename = "reference-triples")]
+    #[serde(rename = "0")]
     pub reference_triples: Option<OneOrMany<ReferenceTripleRecord<'a>>>,
 
     /// Optional endorsement triples that contain verification information
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(rename = "endorse-triples")]
+    #[serde(rename = "1")]
     pub endorse_triples: Option<OneOrMany<EndorsedTripleRecord<'a>>>,
 
     /// Optional identity triples that provide identity information
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(rename = "identity-triples")]
+    #[serde(rename = "2")]
     pub identity_triples: Option<OneOrMany<IdentityTripleRecord<'a>>>,
 
     /// Optional attestation key triples containing cryptographic keys
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(rename = "attest_key-triples")]
+    #[serde(rename = "3")]
     pub attest_key_triples: Option<OneOrMany<AttestKeyTripleRecord<'a>>>,
 
     /// Optional domain dependency triples describing relationships between domains
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(rename = "dependency-triples")]
+    #[serde(rename = "4")]
     pub dependency_triples: Option<OneOrMany<DomainDependencyTripleRecord<'a>>>,
 
     /// Optional domain membership triples describing domain associations
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(rename = "membership-triples")]
+    #[serde(rename = "5")]
     pub membership_triples: Option<OneOrMany<DomainMembershipTripleRecord<'a>>>,
 
     /// Optional SWID triples containing software identification data
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(rename = "coswid-triples")]
+    #[serde(rename = "6")]
     pub coswid_triples: Option<OneOrMany<CoswidTripleRecord<'a>>>,
 
     /// Optional conditional endorsement series triples for complex endorsement chains
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(rename = "conditional-endorsement-series-triples")]
+    #[serde(rename = "8")]
     pub conditional_endorsement_series_triples:
         Option<OneOrMany<ConditionalEndorsementSeriesTripleRecord<'a>>>,
 
     /// Optional conditional endorsement triples for conditional verification
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(rename = "conditional-endorsement-triples")]
+    #[serde(rename = "10")]
     pub conditional_endorsement_triples: Option<OneOrMany<ConditionalEndorsementTripleRecord<'a>>>,
 
     /// Optional extensible attributes for future expansion

src/core.rs

@@ -343,7 +343,10 @@ pub struct MaskedRawValue {
 #[repr(C)]
 /// Container for raw values with optional masking
 pub struct RawValueType {
+    #[serde(rename = "4")]
     pub raw_value: RawValueTypeChoice,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "5")]
     pub raw_value_mask: Option<RawValueMaskType>,
 }
 

src/corim.rs

@@ -93,6 +93,7 @@ pub type UnsignedCorimMap<'a> = CorimMap<'a>;
 /// A type choice representing either a signed or unsigned CoRIM manifest
 #[repr(C)]
 #[derive(Debug, Serialize, Deserialize, From, TryFrom)]
+#[serde(untagged)]
 pub enum ConciseRimTypeChoice<'a> {
     /// An unprotected CoRIM with CBOR tag 501
     TaggedUnsignedCorimMap(TaggedUnsignedCorimMap<'a>),
@@ -122,24 +123,29 @@ generate_tagged!(
 #[derive(
     Debug, Serialize, Deserialize, From, Constructor, PartialEq, Eq, PartialOrd, Ord, Clone,
 )]
+#[repr(C)]
 pub struct CorimMap<'a> {
     /// Unique identifier for the CoRIM
+    #[serde(rename = "0")]
     pub id: CorimIdTypeChoice<'a>,
     /// Collection of tags contained in this CoRIM
+    #[serde(rename = "1")]
     pub tags: OneOrMany<ConciseTagTypeChoice<'a>>,
     /// Optional references to other CoRIMs this one depends on
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(rename = "dependent-rims")]
+    #[serde(rename = "2")]
     pub dependent_rims: Option<Vec<CorimLocatorMap<'a>>>,
     /// Optional profile information
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "3")]
     pub profile: Option<ProfileTypeChoice<'a>>,
     /// Optional validity period for the CoRIM
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(rename = "rim-validity")]
+    #[serde(rename = "4")]
     pub rim_validity: Option<ValidityMap>,
     /// Optional list of entities associated with this CoRIM
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "5")]
     pub entities: Option<OneOrMany<CorimEntityMap<'a>>>,
     /// Optional extensible attributes
     #[serde(flatten)]
@@ -150,6 +156,8 @@ pub struct CorimMap<'a> {
 /// Represents either a string or UUID identifier for a CoRIM
 #[repr(C)]
 #[derive(Debug, Serialize, Deserialize, From, TryFrom, PartialEq, Eq, PartialOrd, Ord, Clone)]
+#[serde(untagged)]
+
 pub enum CorimIdTypeChoice<'a> {
     /// Text string identifier
     Tstr(Tstr<'a>),
@@ -166,6 +174,7 @@ impl<'a> From<&'a str> for CorimIdTypeChoice<'a> {
 /// Types of tags that can be included in a CoRIM
 #[repr(C)]
 #[derive(Debug, Serialize, Deserialize, From, TryFrom, PartialEq, Eq, PartialOrd, Ord, Clone)]
+#[serde(untagged)]
 pub enum ConciseTagTypeChoice<'a> {
     /// A Concise Software Identity (CoSWID) tag
     Swid(TaggedConciseSwidTag<'a>),
@@ -245,15 +254,18 @@ impl<'a> From<ConciseTlTag<'a>> for ConciseTagTypeChoice<'a> {
 )]
 pub struct CorimLocatorMap<'a> {
     /// URI(s) where the dependent CoRIM can be found
+    #[serde(rename = "0")]
     pub href: OneOrMany<Uri<'a>>,
     /// Optional cryptographic thumbprint for verification
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "1")]
     pub thumbprint: Option<Digest<'a>>,
 }
 
 /// Profile identifier that can be either a URI or OID
 #[repr(C)]
 #[derive(Debug, Serialize, Deserialize, From, TryFrom, PartialEq, Eq, PartialOrd, Ord, Clone)]
+#[serde(untagged)]
 pub enum ProfileTypeChoice<'a> {
     /// URI-based profile identifier
     Uri(Uri<'a>),
@@ -268,10 +280,10 @@ pub enum ProfileTypeChoice<'a> {
 )]
 pub struct ValidityMap {
     /// Optional start time of the validity period
-    #[serde(rename = "not-before")]
+    #[serde(rename = "0")]
     pub not_before: Option<Time>,
     /// Required end time of the validity period
-    #[serde(rename = "not-after")]
+    #[serde(rename = "1")]
     pub not_after: Time,
 }
 
@@ -282,20 +294,25 @@ pub struct ValidityMap {
 )]
 pub struct CorimEntityMap<'a> {
     /// Name of the entity
-    #[serde(rename = "entity-name")]
+    #[serde(rename = "0")]
     pub entity_name: Text<'a>,
     /// Optional registration identifier for the entity
-    #[serde(rename = "reg-id")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "1")]
     pub reg_id: Option<Uri<'a>>,
     /// Role of the entity in relation to the CoRIM
+    #[serde(rename = "2")]
     pub role: CorimRoleTypeChoice,
     /// Optional extensible attributes
+    #[serde(flatten)]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub extension: Option<ExtensionMap<'a>>,
 }
 
 /// Roles that entities can have in relation to a CoRIM manifest
 #[derive(Debug, Serialize, Deserialize, From, TryFrom, PartialEq, Eq, PartialOrd, Ord, Clone)]
 #[repr(u8)]
+#[serde(untagged)]
 pub enum CorimRoleTypeChoice {
     /// Entity that created the manifest content
     ManifestCreator = 1,
@@ -334,19 +351,20 @@ pub struct COSESign1Corim<'a> {
 #[repr(C)]
 pub struct ProtectedCorimHeaderMap<'a> {
     /// Algorithm identifier for the signature
+    #[serde(rename = "1")]
     pub alg: Int,
     /// Content type indicator (should be "application/rim+cbor")
-    #[serde(rename = "content-type")]
+    #[serde(rename = "3")]
     pub content_type: Text<'a>,
     /// Key identifier for the signing key
+    #[serde(rename = "4")]
     pub kid: Bytes,
     /// CoRIM-specific metadata
-    #[serde(rename = "corim-meta")]
+    #[serde(rename = "8")]
     pub corim_meta: CorimMetaMap<'a>,
     /// Optional COSE header parameters
     #[serde(skip_serializing_if = "Option::is_none")]
     #[serde(flatten)]
-    #[serde(rename = "cose-map")]
     pub cose_map: Option<CoseMap<'a>>,
 }
 
@@ -357,9 +375,11 @@ pub struct ProtectedCorimHeaderMap<'a> {
 #[repr(C)]
 pub struct CorimMetaMap<'a> {
     /// Information about the signer
+    #[serde(rename = "0")]
     pub signer: CorimSignerMap<'a>,
     /// Optional validity period for the signature
-    #[serde(rename = "signature-validity")]
+    #[serde(rename = "1")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub signature_validity: Option<ValidityMap>,
 }
 
@@ -370,12 +390,14 @@ pub struct CorimMetaMap<'a> {
 #[repr(C)]
 pub struct CorimSignerMap<'a> {
     /// Name of the signing entity
-    #[serde(rename = "signer-name")]
+    #[serde(rename = "0")]
     pub signer_name: EntityNameTypeChoice<'a>,
     /// Optional URI identifying the signer
-    #[serde(rename = "signer-uri")]
+    #[serde(rename = "1")]
     pub signer_uri: Option<Uri<'a>>,
     /// Optional COSE-specific extensions
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(flatten)]
     pub extension: Option<CoseMap<'a>>,
 }
 

src/cotl.rs

@@ -22,14 +22,14 @@ They can be used to establish trust relationships and manage tag distribution."#
 #[repr(C)]
 pub struct ConciseTlTag<'a> {
     /// Identity information for this trust list tag
-    #[serde(rename = "tag-identity")]
+    #[serde(rename = "0")]
     pub tag_identity: TagIdentityMap<'a>,
 
     /// List of trusted tags referenced by this trust list
-    #[serde(rename = "tags-list")]
+    #[serde(rename = "1")]
     pub tags_list: OneOrMany<TagIdentityMap<'a>>,
 
     /// Validity period for this trust list
-    #[serde(rename = "tl-validity")]
+    #[serde(rename = "2")]
     pub tl_validity: ValidityMap,
 }