spki: make SubjectPublicKeyInfo own the public key

Author: baloo

pkcs1/src/traits.rs

@@ -16,7 +16,10 @@ use {
 };
 
 #[cfg(feature = "pkcs8")]
-use crate::{ALGORITHM_ID, ALGORITHM_OID};
+use {
+    crate::{ALGORITHM_ID, ALGORITHM_OID},
+    der::asn1::BitString,
+};
 
 #[cfg(feature = "std")]
 use std::path::Path;
@@ -185,7 +188,7 @@ impl<T: pkcs8::DecodePublicKey> DecodeRsaPublicKey for T {
     fn from_pkcs1_der(public_key: &[u8]) -> Result<Self> {
         Ok(Self::try_from(pkcs8::SubjectPublicKeyInfoRef {
             algorithm: ALGORITHM_ID,
-            subject_public_key: public_key,
+            subject_public_key: BitString::from_bytes(public_key)?,
         })?)
     }
 }
@@ -208,6 +211,6 @@ impl<T: pkcs8::EncodePublicKey> EncodeRsaPublicKey for T {
         let doc = self.to_public_key_der()?;
         let spki = pkcs8::SubjectPublicKeyInfoRef::from_der(doc.as_bytes())?;
         spki.algorithm.assert_algorithm_oid(ALGORITHM_OID)?;
-        RsaPublicKey::from_der(spki.subject_public_key)?.try_into()
+        RsaPublicKey::from_der(spki.subject_public_key.raw_bytes())?.try_into()
     }
 }

spki/src/spki.rs

@@ -3,7 +3,7 @@
 use crate::{AlgorithmIdentifier, Error, Result};
 use core::cmp::Ordering;
 use der::{
-    asn1::{AnyRef, BitStringRef},
+    asn1::{AnyRef, BitString, BitStringRef},
     Choice, Decode, DecodeValue, DerOrd, Encode, Header, Reader, Sequence, ValueOrd,
 };
 
@@ -23,7 +23,7 @@ use {
 use der::pem::PemLabel;
 
 /// [`SubjectPublicKeyInfo`] with [`AnyRef`] algorithm parameters.
-pub type SubjectPublicKeyInfoRef<'a> = SubjectPublicKeyInfo<'a, AnyRef<'a>>;
+pub type SubjectPublicKeyInfoRef<'a> = SubjectPublicKeyInfo<AnyRef<'a>>;
 
 /// X.509 `SubjectPublicKeyInfo` (SPKI) as defined in [RFC 5280 § 4.1.2.7].
 ///
@@ -37,23 +37,23 @@ pub type SubjectPublicKeyInfoRef<'a> = SubjectPublicKeyInfo<'a, AnyRef<'a>>;
 /// ```
 ///
 /// [RFC 5280 § 4.1.2.7]: https://tools.ietf.org/html/rfc5280#section-4.1.2.7
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub struct SubjectPublicKeyInfo<'a, Params> {
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct SubjectPublicKeyInfo<Params> {
     /// X.509 [`AlgorithmIdentifier`] for the public key type
     pub algorithm: AlgorithmIdentifier<Params>,
 
     /// Public key data
-    pub subject_public_key: &'a [u8],
+    pub subject_public_key: BitString,
 }
 
-impl<'a, Params> SubjectPublicKeyInfo<'a, Params> {
+impl<Params> SubjectPublicKeyInfo<Params> {
     /// Get a [`BitString`] representing the `subject_public_key`
-    fn bitstring(&self) -> der::Result<BitStringRef<'a>> {
-        BitStringRef::from_bytes(self.subject_public_key)
+    fn bitstring<'a>(&'a self) -> BitStringRef<'a> {
+        BitStringRef::from(&self.subject_public_key)
     }
 }
 
-impl<'a, Params> SubjectPublicKeyInfo<'a, Params>
+impl<'a, Params> SubjectPublicKeyInfo<Params>
 where
     Params: Choice<'a> + Encode,
 {
@@ -84,35 +84,33 @@ where
     }
 }
 
-impl<'a, Params> DecodeValue<'a> for SubjectPublicKeyInfo<'a, Params>
+impl<'a, Params> DecodeValue<'a> for SubjectPublicKeyInfo<Params>
 where
     Params: Choice<'a> + Encode,
 {
     fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> der::Result<Self> {
         reader.read_nested(header.length, |reader| {
             Ok(Self {
                 algorithm: reader.decode()?,
-                subject_public_key: BitStringRef::decode(reader)?
-                    .as_bytes()
-                    .ok_or_else(|| der::Tag::BitString.value_error())?,
+                subject_public_key: BitString::decode(reader)?,
             })
         })
     }
 }
 
-impl<'a, Params> Sequence<'a> for SubjectPublicKeyInfo<'a, Params>
+impl<'a, Params> Sequence<'a> for SubjectPublicKeyInfo<Params>
 where
     Params: Choice<'a> + Encode,
 {
     fn fields<F, T>(&self, f: F) -> der::Result<T>
     where
         F: FnOnce(&[&dyn Encode]) -> der::Result<T>,
     {
-        f(&[&self.algorithm, &self.bitstring()?])
+        f(&[&self.algorithm, &self.bitstring()])
     }
 }
 
-impl<'a, Params> TryFrom<&'a [u8]> for SubjectPublicKeyInfo<'a, Params>
+impl<'a, Params> TryFrom<&'a [u8]> for SubjectPublicKeyInfo<Params>
 where
     Params: Choice<'a> + Encode,
 {
@@ -123,46 +121,46 @@ where
     }
 }
 
-impl<'a, Params> ValueOrd for SubjectPublicKeyInfo<'a, Params>
+impl<'a, Params> ValueOrd for SubjectPublicKeyInfo<Params>
 where
     Params: Choice<'a> + DerOrd + Encode,
 {
     fn value_cmp(&self, other: &Self) -> der::Result<Ordering> {
         match self.algorithm.der_cmp(&other.algorithm)? {
-            Ordering::Equal => self.bitstring()?.der_cmp(&other.bitstring()?),
+            Ordering::Equal => self.bitstring().der_cmp(&other.bitstring()),
             other => Ok(other),
         }
     }
 }
 
 #[cfg(feature = "alloc")]
 #[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
-impl<'a, Params> TryFrom<SubjectPublicKeyInfo<'a, Params>> for Document
+impl<'a, Params> TryFrom<SubjectPublicKeyInfo<Params>> for Document
 where
     Params: Choice<'a> + Encode,
 {
     type Error = Error;
 
-    fn try_from(spki: SubjectPublicKeyInfo<'a, Params>) -> Result<Document> {
+    fn try_from(spki: SubjectPublicKeyInfo<Params>) -> Result<Document> {
         Self::try_from(&spki)
     }
 }
 
 #[cfg(feature = "alloc")]
 #[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
-impl<'a, Params> TryFrom<&SubjectPublicKeyInfo<'a, Params>> for Document
+impl<'a, Params> TryFrom<&SubjectPublicKeyInfo<Params>> for Document
 where
     Params: Choice<'a> + Encode,
 {
     type Error = Error;
 
-    fn try_from(spki: &SubjectPublicKeyInfo<'a, Params>) -> Result<Document> {
+    fn try_from(spki: &SubjectPublicKeyInfo<Params>) -> Result<Document> {
         Ok(Self::encode_msg(spki)?)
     }
 }
 
 #[cfg(feature = "pem")]
 #[cfg_attr(docsrs, doc(cfg(feature = "pem")))]
-impl<Params> PemLabel for SubjectPublicKeyInfo<'_, Params> {
+impl<Params> PemLabel for SubjectPublicKeyInfo<Params> {
     const PEM_LABEL: &'static str = "PUBLIC KEY";
 }

x509-cert/tests/certreq.rs

@@ -52,7 +52,7 @@ fn decode_rsa_2048_der() {
     let alg = cr.info.public_key.algorithm;
     assert_eq!(alg.oid, "1.2.840.113549.1.1.1".parse().unwrap());
     assert!(alg.parameters.unwrap().is_null());
-    assert_eq!(cr.info.public_key.subject_public_key, RSA_KEY);
+    assert_eq!(cr.info.public_key.subject_public_key.raw_bytes(), RSA_KEY);
 
     // Check the attributes (just one; contains extensions).
     assert_eq!(cr.info.attributes.len(), 1);