[pkcs8] Added: Coercion to SetOf for encoding

Author: kraemv

Cargo.lock

@@ -11,7 +11,7 @@
 #![cfg(any(feature = "alloc", feature = "heapless"))]
 
 use crate::{
-    ArrayVec, Decode, DecodeValue, DerOrd, Encode, EncodeValue, Error, ErrorKind, FixedTag, Header,
+    Decode, DecodeValue, DerOrd, Encode, EncodeValue, Error, ErrorKind, FixedTag, Header,
     Length, Reader, SliceReader, Tag, ValueOrd, Writer, ord::iter_cmp,
     ord::iter_cmp_owned,
 };
@@ -49,7 +49,7 @@ enum InnerRef<'a, T> {
 ///
 /// This type implements a viewer in a `SET OF` type
 /// and does not depend on `alloc` support.
-#[derive(Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
 pub struct SetOfRef<'a, T>
 where
     T: DerOrd,
@@ -174,6 +174,7 @@ where
     }
 
     /// Get the nth element from this [`SetOfRef`].
+    #[must_use]
     pub fn get(&self, index: usize) -> Option<T>
     where
         T: Decode<'a> + 'a,
@@ -183,6 +184,7 @@ where
     }
 
     /// Iterate over the elements of this [`SetOfRef`].
+    #[must_use]
     pub fn iter(&self) -> SetOfRefIter<'a, T>
     where
         T: Decode<'a> + 'a,
@@ -211,6 +213,7 @@ where
     }
 
     /// Is this [`SetOfRef`] empty?
+    #[must_use]
     pub fn is_empty(&self) -> bool {
         match self.inner {
             InnerRef::BytesRef(inner) => inner.is_empty(),
@@ -219,6 +222,7 @@ where
     }
 
     /// Number of elements in this [`SetOfRef`].
+    #[must_use]
     pub fn len(&self) -> usize
     where
         T: Decode<'a> + 'a,
@@ -367,6 +371,15 @@ where
     }
 }
 
+impl<'a, T> From<&SetOfRef<'a, T>> for SetOfRef<'a, T>
+where
+    T: Clone + DerOrd,
+{
+    fn from(value: &SetOfRef<'a, T>) -> SetOfRef<'a, T> {
+        value.clone()
+    }
+}
+
 #[cfg(feature = "heapless")]
 impl<T, const N: usize> ValueOrd for SetOf<T, N>
 where
@@ -799,8 +812,7 @@ mod allocating {
         T: Encode,
         T: DerOrd,
     {
-        type Borrowed<'a>
-            = SetOfRef<'a, T>
+        type Borrowed<'a> = SetOfRef<'a, T>
         where
             T: 'a;
 
@@ -813,12 +825,14 @@ mod allocating {
 #[cfg(test)]
 #[allow(clippy::unwrap_used)]
 mod tests {
-    use super::SetOfRef;
+    
     #[cfg(feature = "alloc")]
     use super::SetOfVec;
     use crate::ErrorKind;
     #[cfg(feature = "heapless")]
-    use {super::SetOf, crate::DerOrd};
+    use {super::SetOf};
+    #[cfg(any(feature = "alloc", feature = "heapless"))]
+    use {super::SetOfRef, crate::DerOrd};
 
     #[cfg(feature = "heapless")]
     #[test]
@@ -891,8 +905,8 @@ mod tests {
 
         let arr1 = [0u16, 1, 2, 3, 5];
         let arr2 = [0u16, 1, 2, 3, 4];
-        let set1 = SetOf::try_from(arr1).unwrap();
-        let set2 = SetOf::try_from(arr2).unwrap();
+        let set1 = SetOfRef::try_from(arr1.as_ref()).unwrap();
+        let set2 = SetOfRef::try_from(arr2.as_ref()).unwrap();
         assert_eq!(set1.der_cmp(&set2), Ok(Ordering::Greater));
     }
 

der/src/asn1/set_of.rs

@@ -17,7 +17,7 @@ edition = "2024"
 rust-version = "1.85"
 
 [dependencies]
-der = {  git = "https://github.com/kraemv/formats", features = ["oid"] }
+der = {  git = "https://github.com/kraemv/formats", features = ["heapless", "oid"] }
 spki = { git = "https://github.com/kraemv/formats" }
 x509-cert = { git = "https://github.com/kraemv/formats", default-features = false }
 

pkcs8/Cargo.toml

@@ -3,9 +3,7 @@
 use crate::{Error, Result, Version};
 use core::fmt;
 use der::{
-    Decode, DecodeValue, Encode, EncodeValue, FixedTag, Header, Length, Reader, Sequence, TagMode,
-    TagNumber, Writer,
-    asn1::{AnyRef, BitStringRef, ContextSpecific, OctetStringRef, SetOfRef},
+    Decode, DecodeValue, DerOrd, Encode, EncodeValue, FixedTag, Header, Length, Reader, Sequence, TagMode, TagNumber, Writer, asn1::{AnyRef, BitStringRef, ContextSpecific, OctetStringRef, SetOf, SetOfRef}
 };
 use spki::AlgorithmIdentifier;
 use x509_cert::attr::Attribute;
@@ -143,7 +141,7 @@ where
     PubKey: DecodeValue<'a, Error = der::Error> + FixedTag + 'a,
     PubKey: BitStringLike,
     Attr: DecodeValue<'a, Error = der::Error> + FixedTag + 'a,
-    Attr: EncodeValue,
+    Attr: SetOfLike<'a>,
 {
     /// Encrypt this private key using a symmetric encryption key derived
     /// from the provided password.
@@ -195,6 +193,25 @@ where
     }
 }
 
+
+impl<'a, Params, Key, PubKey, Attr> PrivateKeyInfo<Params, Key, PubKey, Attr>
+where
+    Params: der::Choice<'a> + Encode,
+    Attr: SetOfLike<'a>,
+{
+    /// Get a `SET OF` representation of the attributes, if present.
+    fn attributes_string(&self) -> Option<ContextSpecific<SetOfRef<'a, Attr::Item>>> {
+        self.attributes.as_ref().map(|attributes| {
+            let value = attributes.as_set_of();
+            ContextSpecific {
+                tag_number: ATTRIBUTES_TAG,
+                tag_mode: TagMode::Implicit,
+                value,
+            }
+        })
+    }
+} 
+
 impl<'a, Params, Key, PubKey, Attr> DecodeValue<'a> for PrivateKeyInfo<Params, Key, PubKey, Attr>
 where
     Params: der::Choice<'a, Error = der::Error> + Encode,
@@ -243,21 +260,22 @@ where
     Params: der::Choice<'a, Error = der::Error> + Encode,
     Key: EncodeValue + FixedTag,
     PubKey: BitStringLike,
-    Attr: EncodeValue + FixedTag,
+    Attr: SetOfLike<'a>,
+    Attr::Item: Clone + Decode<'a> + DerOrd + Encode,
 {
     fn value_len(&self) -> der::Result<Length> {
         self.version().encoded_len()?
             + self.algorithm.encoded_len()?
             + self.private_key.encoded_len()?
-            + self.attributes.encoded_len()?
+            + self.attributes_string().encoded_len()?
             + self.public_key_bit_string().encoded_len()?
     }
 
     fn encode_value(&self, writer: &mut impl Writer) -> der::Result<()> {
         self.version().encode(writer)?;
         self.algorithm.encode(writer)?;
         self.private_key.encode(writer)?;
-        self.attributes.encode(writer)?;
+        self.attributes_string().encode(writer)?;
         self.public_key_bit_string().encode(writer)?;
         Ok(())
     }
@@ -270,8 +288,8 @@ where
     Key: EncodeValue,
     PubKey: DecodeValue<'a, Error = der::Error> + FixedTag + 'a,
     PubKey: BitStringLike,
-    Attr: DecodeValue<'a, Error = der::Error> + FixedTag + 'a,
-    Attr: EncodeValue,
+    Attr: DecodeValue<'a, Error = der::Error> + FixedTag + SetOfLike<'a> + 'a,
+    Attr::Item: Clone + Decode<'a> + DerOrd + Encode,
 {
 }
 
@@ -282,8 +300,8 @@ where
     Key: EncodeValue,
     PubKey: DecodeValue<'a, Error = der::Error> + FixedTag + 'a,
     PubKey: BitStringLike,
-    Attr: DecodeValue<'a, Error = der::Error> + FixedTag + 'a,
-    Attr: EncodeValue,
+    Attr: DecodeValue<'a, Error = der::Error> + FixedTag + SetOfLike<'a> + 'a,
+    Attr::Item: Clone + Decode<'a> + DerOrd + Encode,
 {
     type Error = Error;
 
@@ -317,8 +335,8 @@ where
     Key: EncodeValue,
     PubKey: DecodeValue<'a, Error = der::Error> + FixedTag + 'a,
     PubKey: BitStringLike,
-    Attr: DecodeValue<'a, Error = der::Error> + FixedTag + 'a,
-    Attr: EncodeValue,
+    Attr: DecodeValue<'a, Error = der::Error> + FixedTag + SetOfLike<'a> + 'a,
+    Attr::Item: Clone + Decode<'a> + DerOrd + Encode,
 {
     type Error = Error;
 
@@ -336,8 +354,8 @@ where
     Key: EncodeValue,
     PubKey: DecodeValue<'a, Error = der::Error> + FixedTag + 'a,
     PubKey: BitStringLike,
-    Attr: DecodeValue<'a, Error = der::Error> + FixedTag + 'a,
-    Attr: EncodeValue,
+    Attr: DecodeValue<'a, Error = der::Error> + FixedTag + SetOfLike<'a> + 'a,
+    Attr::Item: Clone + Decode<'a> + DerOrd + Encode,
 {
     type Error = Error;
 
@@ -390,9 +408,8 @@ where
 }
 
 /// [`PrivateKeyInfo`] with [`AnyRef`] algorithm parameters, and `&[u8]` key.
-// pub type PrivateKeyInfoRef<'a> = PrivateKeyInfo<AnyRef<'a>, &'a OctetStringRef, BitStringRef<'a>, &'a[&'a Attribute]>; // Consider attr and value here
 pub type PrivateKeyInfoRef<'a> =
-    PrivateKeyInfo<AnyRef<'a>, &'a OctetStringRef, BitStringRef<'a>, SetOfRef<'a, Attribute>>; // Consider attr and value here
+    PrivateKeyInfo<AnyRef<'a>, &'a OctetStringRef, BitStringRef<'a>, SetOfRef<'a, Attribute>>;
 
 /// [`PrivateKeyInfo`] with [`Any`] algorithm parameters, and `Box<[u8]>` key.
 #[cfg(feature = "alloc")]
@@ -411,6 +428,23 @@ impl BitStringLike for BitStringRef<'_> {
     }
 }
 
+pub trait SetOfLike <'a>
+{
+    type Item: Clone + DerOrd + Encode;
+    fn as_set_of(&self) -> SetOfRef<'a, Self::Item>;
+}
+
+impl<'a, T> SetOfLike<'a> for SetOfRef<'a, T> 
+where 
+    T: Clone + DerOrd + Encode,
+{
+    type Item = T;
+
+    fn as_set_of(&self) -> SetOfRef<'a, T> {
+        SetOfRef::from(self)
+    }
+}
+
 #[cfg(feature = "alloc")]
 mod allocating {
     use super::*;
@@ -424,6 +458,17 @@ mod allocating {
         }
     }
 
+    impl<'a, T> SetOfLike<'a> for &'a SetOfVec<T> 
+    where 
+        T: Clone + DerOrd + Encode + 'a,
+    {
+        type Item = T;
+
+        fn as_set_of(&self) -> SetOfRef<'a, T> {
+            self.owned_to_ref()
+        }
+    }
+
     impl<'a> RefToOwned<'a> for PrivateKeyInfoRef<'a> {
         type Owned = PrivateKeyInfoOwned;
         fn ref_to_owned(&self) -> Self::Owned {