/rust/registry/src/index.crates.io-1949cf8c6b5b557f/spki-0.7.3/src/algorithm.rs

Source
//! X.509 `AlgorithmIdentifier`

use crate::{Error, Result};
use core::cmp::Ordering;
use der::{
    asn1::{AnyRef, Choice, ObjectIdentifier},
    Decode, DecodeValue, DerOrd, Encode, EncodeValue, Header, Length, Reader, Sequence, ValueOrd,
    Writer,
};

#[cfg(feature = "alloc")]
use der::asn1::Any;

/// X.509 `AlgorithmIdentifier` as defined in [RFC 5280 Section 4.1.1.2].
///
/// ```text
/// AlgorithmIdentifier  ::=  SEQUENCE  {
///      algorithm               OBJECT IDENTIFIER,
///      parameters              ANY DEFINED BY algorithm OPTIONAL  }
/// ```
///
/// [RFC 5280 Section 4.1.1.2]: https://tools.ietf.org/html/rfc5280#section-4.1.1.2
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
pub struct AlgorithmIdentifier<Params> {
    /// Algorithm OID, i.e. the `algorithm` field in the `AlgorithmIdentifier`
    /// ASN.1 schema.
    pub oid: ObjectIdentifier,

    /// Algorithm `parameters`.
    pub parameters: Option<Params>,
}

impl<'a, Params> DecodeValue<'a> for AlgorithmIdentifier<Params>
where
    Params: Choice<'a>,
{
    fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> der::Result<Self> {
        reader.read_nested(header.length, |reader| {
            Ok(Self {
                oid: reader.decode()?,
                parameters: reader.decode()?,
            })
        })
    }
}

impl<Params> EncodeValue for AlgorithmIdentifier<Params>
where
    Params: Encode,
{
    fn value_len(&self) -> der::Result<Length> {
        self.oid.encoded_len()? + self.parameters.encoded_len()?
    }

    fn encode_value(&self, writer: &mut impl Writer) -> der::Result<()> {
        self.oid.encode(writer)?;
        self.parameters.encode(writer)?;
        Ok(())
    }
}

impl<'a, Params> Sequence<'a> for AlgorithmIdentifier<Params> where Params: Choice<'a> + Encode {}

impl<'a, Params> TryFrom<&'a [u8]> for AlgorithmIdentifier<Params>
where
    Params: Choice<'a> + Encode,
{
    type Error = Error;

    fn try_from(bytes: &'a [u8]) -> Result<Self> {
        Ok(Self::from_der(bytes)?)
    }
}

impl<Params> ValueOrd for AlgorithmIdentifier<Params>
where
    Params: DerOrd,
{
    fn value_cmp(&self, other: &Self) -> der::Result<Ordering> {
        match self.oid.der_cmp(&other.oid)? {
            Ordering::Equal => self.parameters.der_cmp(&other.parameters),
            other => Ok(other),
        }
    }
}

/// `AlgorithmIdentifier` reference which has `AnyRef` parameters.
pub type AlgorithmIdentifierRef<'a> = AlgorithmIdentifier<AnyRef<'a>>;

/// `AlgorithmIdentifier` with `ObjectIdentifier` parameters.
pub type AlgorithmIdentifierWithOid = AlgorithmIdentifier<ObjectIdentifier>;

/// `AlgorithmIdentifier` reference which has `Any` parameters.
#[cfg(feature = "alloc")]
pub type AlgorithmIdentifierOwned = AlgorithmIdentifier<Any>;

impl<Params> AlgorithmIdentifier<Params> {
    /// Assert the `algorithm` OID is an expected value.
    pub fn assert_algorithm_oid(&self, expected_oid: ObjectIdentifier) -> Result<ObjectIdentifier> {
        if self.oid == expected_oid {
            Ok(expected_oid)
        } else {
            Err(Error::OidUnknown { oid: expected_oid })
        }
    }
}

impl<'a> AlgorithmIdentifierRef<'a> {
    /// Assert `parameters` is an OID and has the expected value.
    pub fn assert_parameters_oid(
        &self,
        expected_oid: ObjectIdentifier,
    ) -> Result<ObjectIdentifier> {
        let actual_oid = self.parameters_oid()?;

        if actual_oid == expected_oid {
            Ok(actual_oid)
        } else {
            Err(Error::OidUnknown { oid: expected_oid })
        }
    }

    /// Assert the values of the `algorithm` and `parameters` OIDs.
    pub fn assert_oids(
        &self,
        algorithm: ObjectIdentifier,
        parameters: ObjectIdentifier,
    ) -> Result<()> {
        self.assert_algorithm_oid(algorithm)?;
        self.assert_parameters_oid(parameters)?;
        Ok(())
    }

    /// Get the `parameters` field as an [`AnyRef`].
    ///
    /// Returns an error if `parameters` are `None`.
    pub fn parameters_any(&self) -> Result<AnyRef<'a>> {
        self.parameters.ok_or(Error::AlgorithmParametersMissing)
    }

    /// Get the `parameters` field as an [`ObjectIdentifier`].
    ///
    /// Returns an error if it is absent or not an OID.
    pub fn parameters_oid(&self) -> Result<ObjectIdentifier> {
        Ok(ObjectIdentifier::try_from(self.parameters_any()?)?)
    }

    /// Convert to a pair of [`ObjectIdentifier`]s.
    ///
    /// This method is helpful for decomposing in match statements. Note in
    /// particular that `NULL` parameters are treated the same as missing
    /// parameters.
    ///
    /// Returns an error if parameters are present but not an OID.
    pub fn oids(&self) -> der::Result<(ObjectIdentifier, Option<ObjectIdentifier>)> {
        Ok((
            self.oid,
            match self.parameters {
                None => None,
                Some(p) => match p {
                    AnyRef::NULL => None,
                    _ => Some(p.decode_as::<ObjectIdentifier>()?),
                },
            },
        ))
    }
}

#[cfg(feature = "alloc")]
mod allocating {
    use super::*;
    use der::referenced::*;

    impl<'a> RefToOwned<'a> for AlgorithmIdentifierRef<'a> {
        type Owned = AlgorithmIdentifierOwned;
        fn ref_to_owned(&self) -> Self::Owned {
            AlgorithmIdentifier {
                oid: self.oid,
                parameters: self.parameters.ref_to_owned(),
            }
        }
    }

    impl OwnedToRef for AlgorithmIdentifierOwned {
        type Borrowed<'a> = AlgorithmIdentifierRef<'a>;
        fn owned_to_ref(&self) -> Self::Borrowed<'_> {
            AlgorithmIdentifier {
                oid: self.oid,
                parameters: self.parameters.owned_to_ref(),
            }
        }
    }
}

Line	Count	Source
1		//! X.509 `AlgorithmIdentifier`
2
3		use crate::{Error, Result};
4		use core::cmp::Ordering;
5		use der::{
6		asn1::{AnyRef, Choice, ObjectIdentifier},
7		Decode, DecodeValue, DerOrd, Encode, EncodeValue, Header, Length, Reader, Sequence, ValueOrd,
8		Writer,
9		};
10
11		#[cfg(feature = "alloc")]
12		use der::asn1::Any;
13
14		/// X.509 `AlgorithmIdentifier` as defined in [RFC 5280 Section 4.1.1.2].
15		///
16		/// ```text
17		/// AlgorithmIdentifier ::= SEQUENCE {
18		/// algorithm OBJECT IDENTIFIER,
19		/// parameters ANY DEFINED BY algorithm OPTIONAL }
20		/// ```
21		///
22		/// [RFC 5280 Section 4.1.1.2]: https://tools.ietf.org/html/rfc5280#section-4.1.1.2
23		#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
24		#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
25		pub struct AlgorithmIdentifier<Params> {
26		/// Algorithm OID, i.e. the `algorithm` field in the `AlgorithmIdentifier`
27		/// ASN.1 schema.
28		pub oid: ObjectIdentifier,
29
30		/// Algorithm `parameters`.
31		pub parameters: Option<Params>,
32		}
33
34		impl<'a, Params> DecodeValue<'a> for AlgorithmIdentifier<Params>
35		where
36		Params: Choice<'a>,
37		{
38	0	fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> der::Result<Self> {
39	0	reader.read_nested(header.length, \|reader\| {
40		Ok(Self {
41	0	oid: reader.decode()?,
42	0	parameters: reader.decode()?,
43		})
44	0	}) Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<spki::algorithm::AlgorithmIdentifier<der::asn1::any::AnyRef>> as der::decode::DecodeValue>::decode_value::<der::reader::nested::NestedReader<der::reader::nested::NestedReader<der::reader::slice::SliceReader>>>::{closure#0} Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<spki::algorithm::AlgorithmIdentifier<der::asn1::any::AnyRef>> as der::decode::DecodeValue>::decode_value::<der::reader::nested::NestedReader<der::reader::slice::SliceReader>>::{closure#0} Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<der::asn1::any::AnyRef> as der::decode::DecodeValue>::decode_value::<der::reader::nested::NestedReader<der::reader::nested::NestedReader<der::reader::nested::NestedReader<der::reader::slice::SliceReader>>>>::{closure#0} Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<der::asn1::any::AnyRef> as der::decode::DecodeValue>::decode_value::<der::reader::nested::NestedReader<der::reader::nested::NestedReader<der::reader::slice::SliceReader>>>::{closure#0} Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<der::asn1::any::AnyRef> as der::decode::DecodeValue>::decode_value::<der::reader::nested::NestedReader<der::reader::slice::SliceReader>>::{closure#0} Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<der::asn1::any::AnyRef> as der::decode::DecodeValue>::decode_value::<der::reader::slice::SliceReader>::{closure#0} Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<_> as der::decode::DecodeValue>::decode_value::<_>::{closure#0}
45	0	} Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<spki::algorithm::AlgorithmIdentifier<der::asn1::any::AnyRef>> as der::decode::DecodeValue>::decode_value::<der::reader::nested::NestedReader<der::reader::nested::NestedReader<der::reader::slice::SliceReader>>> Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<spki::algorithm::AlgorithmIdentifier<der::asn1::any::AnyRef>> as der::decode::DecodeValue>::decode_value::<der::reader::nested::NestedReader<der::reader::slice::SliceReader>> Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<der::asn1::any::AnyRef> as der::decode::DecodeValue>::decode_value::<der::reader::nested::NestedReader<der::reader::nested::NestedReader<der::reader::nested::NestedReader<der::reader::slice::SliceReader>>>> Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<der::asn1::any::AnyRef> as der::decode::DecodeValue>::decode_value::<der::reader::nested::NestedReader<der::reader::nested::NestedReader<der::reader::slice::SliceReader>>> Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<der::asn1::any::AnyRef> as der::decode::DecodeValue>::decode_value::<der::reader::nested::NestedReader<der::reader::slice::SliceReader>> Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<der::asn1::any::AnyRef> as der::decode::DecodeValue>::decode_value::<der::reader::slice::SliceReader> Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<_> as der::decode::DecodeValue>::decode_value::<_>
46		}
47
48		impl<Params> EncodeValue for AlgorithmIdentifier<Params>
49		where
50		Params: Encode,
51		{
52	0	fn value_len(&self) -> der::Result<Length> {
53	0	self.oid.encoded_len()? + self.parameters.encoded_len()?
54	0	} Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<spki::algorithm::AlgorithmIdentifier<der::asn1::any::AnyRef>> as der::encode::EncodeValue>::value_len Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<der::asn1::any::AnyRef> as der::encode::EncodeValue>::value_len Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<_> as der::encode::EncodeValue>::value_len
55
56	0	fn encode_value(&self, writer: &mut impl Writer) -> der::Result<()> {
57	0	self.oid.encode(writer)?;
58	0	self.parameters.encode(writer)?;
59	0	Ok(())
60	0	} Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<der::asn1::any::AnyRef> as der::encode::EncodeValue>::encode_value::<der::writer::slice::SliceWriter> Unexecuted instantiation: <spki::algorithm::AlgorithmIdentifier<_> as der::encode::EncodeValue>::encode_value::<_>
61		}
62
63		impl<'a, Params> Sequence<'a> for AlgorithmIdentifier<Params> where Params: Choice<'a> + Encode {}
64
65		impl<'a, Params> TryFrom<&'a [u8]> for AlgorithmIdentifier<Params>
66		where
67		Params: Choice<'a> + Encode,
68		{
69		type Error = Error;
70
71	0	fn try_from(bytes: &'a [u8]) -> Result<Self> {
72	0	Ok(Self::from_der(bytes)?)
73	0	}
74		}
75
76		impl<Params> ValueOrd for AlgorithmIdentifier<Params>
77		where
78		Params: DerOrd,
79		{
80	0	fn value_cmp(&self, other: &Self) -> der::Result<Ordering> {
81	0	match self.oid.der_cmp(&other.oid)? {
82	0	Ordering::Equal => self.parameters.der_cmp(&other.parameters),
83	0	other => Ok(other),
84		}
85	0	}
86		}
87
88		/// `AlgorithmIdentifier` reference which has `AnyRef` parameters.
89		pub type AlgorithmIdentifierRef<'a> = AlgorithmIdentifier<AnyRef<'a>>;
90
91		/// `AlgorithmIdentifier` with `ObjectIdentifier` parameters.
92		pub type AlgorithmIdentifierWithOid = AlgorithmIdentifier<ObjectIdentifier>;
93
94		/// `AlgorithmIdentifier` reference which has `Any` parameters.
95		#[cfg(feature = "alloc")]
96		pub type AlgorithmIdentifierOwned = AlgorithmIdentifier<Any>;
97
98		impl<Params> AlgorithmIdentifier<Params> {
99		/// Assert the `algorithm` OID is an expected value.
100	0	pub fn assert_algorithm_oid(&self, expected_oid: ObjectIdentifier) -> Result<ObjectIdentifier> {
101	0	if self.oid == expected_oid {
102	0	Ok(expected_oid)
103		} else {
104	0	Err(Error::OidUnknown { oid: expected_oid })
105		}
106	0	}
107		}
108
109		impl<'a> AlgorithmIdentifierRef<'a> {
110		/// Assert `parameters` is an OID and has the expected value.
111	0	pub fn assert_parameters_oid(
112	0	&self,
113	0	expected_oid: ObjectIdentifier,
114	0	) -> Result<ObjectIdentifier> {
115	0	let actual_oid = self.parameters_oid()?;
116
117	0	if actual_oid == expected_oid {
118	0	Ok(actual_oid)
119		} else {
120	0	Err(Error::OidUnknown { oid: expected_oid })
121		}
122	0	}
123
124		/// Assert the values of the `algorithm` and `parameters` OIDs.
125	0	pub fn assert_oids(
126	0	&self,
127	0	algorithm: ObjectIdentifier,
128	0	parameters: ObjectIdentifier,
129	0	) -> Result<()> {
130	0	self.assert_algorithm_oid(algorithm)?;
131	0	self.assert_parameters_oid(parameters)?;
132	0	Ok(())
133	0	}
134
135		/// Get the `parameters` field as an [`AnyRef`].
136		///
137		/// Returns an error if `parameters` are `None`.
138	0	pub fn parameters_any(&self) -> Result<AnyRef<'a>> {
139	0	self.parameters.ok_or(Error::AlgorithmParametersMissing)
140	0	}
141
142		/// Get the `parameters` field as an [`ObjectIdentifier`].
143		///
144		/// Returns an error if it is absent or not an OID.
145	0	pub fn parameters_oid(&self) -> Result<ObjectIdentifier> {
146	0	Ok(ObjectIdentifier::try_from(self.parameters_any()?)?)
147	0	}
148
149		/// Convert to a pair of [`ObjectIdentifier`]s.
150		///
151		/// This method is helpful for decomposing in match statements. Note in
152		/// particular that `NULL` parameters are treated the same as missing
153		/// parameters.
154		///
155		/// Returns an error if parameters are present but not an OID.
156	0	pub fn oids(&self) -> der::Result<(ObjectIdentifier, Option<ObjectIdentifier>)> {
157		Ok((
158	0	self.oid,
159	0	match self.parameters {
160	0	None => None,
161	0	Some(p) => match p {
162	0	AnyRef::NULL => None,
163	0	_ => Some(p.decode_as::<ObjectIdentifier>()?),
164		},
165		},
166		))
167	0	}
168		}
169
170		#[cfg(feature = "alloc")]
171		mod allocating {
172		use super::*;
173		use der::referenced::*;
174
175		impl<'a> RefToOwned<'a> for AlgorithmIdentifierRef<'a> {
176		type Owned = AlgorithmIdentifierOwned;
177	0	fn ref_to_owned(&self) -> Self::Owned {
178	0	AlgorithmIdentifier {
179	0	oid: self.oid,
180	0	parameters: self.parameters.ref_to_owned(),
181	0	}
182	0	}
183		}
184
185		impl OwnedToRef for AlgorithmIdentifierOwned {
186		type Borrowed<'a> = AlgorithmIdentifierRef<'a>;
187	0	fn owned_to_ref(&self) -> Self::Borrowed<'_> {
188	0	AlgorithmIdentifier {
189	0	oid: self.oid,
190	0	parameters: self.parameters.owned_to_ref(),
191	0	}
192	0	}
193		}
194		}

Coverage Report

Created: 2026-06-14 06:21