Struct rpki::crypto::digest::DigestAlgorithm

pub struct DigestAlgorithm(/* private fields */);

The digest algorithms used by RPKI.

These are the algorithms used by the signature algorithms. For use in RPKI, RFC 7935 limits them to exactly one, SHA-256. Because of that, this type is currently a zero-sized struct. If additional algorithms are ever introduced in the future, it will change into an enum.

Implementations

impl DigestAlgorithm

pub fn sha256() -> Self

Creates a value representing the SHA-256 algorithm.

pub fn is_sha256(self) -> bool

Returns whether the algorithm is in fact SHA-256.

pub fn digest_len(&self) -> usize

Returns the digest size in octets for this algorithm.

impl DigestAlgorithm

Creating Digest Values

pub fn digest(self, data: &[u8]) -> Digest

Returns the digest of data using this algorithm.

pub fn digest_file(self, path: impl AsRef<Path>) -> Result<Digest, Error>

Calculates the digest for the content of a file.

pub fn start(self) -> Context

Returns a digest context for multi-step calculation of the digest.

impl DigestAlgorithm

ASN.1 Values

Digest algorithms appear in CMS either alone or in sets with the following syntax:

DigestAlgorithmIdentifiers ::= SET OF DigestAlgorithmIdentifier
DigestAlgorithmIdentifier  ::= AlgorithmIdentifier
AlgorithmIdentifier        ::= SEQUENCE {
     algorithm                 OBJECT IDENTIFIER,
     parameters                ANY DEFINED BY algorithm OPTIONAL }

In RPKI signed objects, a set is limited to exactly one identifer. The allowed algorithms are limited, too. In particular, RFC 7935 only allows SHA-256. Its algorithm identifier is defined in RFC 5754. The object identifier to be used is id-sha256. When encoding, the parameters field must be absent, whereas when decoding, it may either be absent or NULL.

Note that this differs from SignatureAlgorithm identifiers where the NULL must be present when encoding.

The functions and methods in this section allow decoding and encoding such values.

pub fn take_from<S: Source>( cons: &mut Constructed<'_, S> ) -> Result<Self, DecodeError<S::Error>>

Takes and returns a single digest algorithm identifier.

Returns a malformed error if the algorithm isn’t one of the allowed algorithms or if the value isn’t correctly encoded.

pub fn take_opt_from<S: Source>( cons: &mut Constructed<'_, S> ) -> Result<Option<Self>, DecodeError<S::Error>>

Takes and returns an optional digest algorithm identifier.

Returns Ok(None) if the next value isn’t a sequence. Returns a malformed error if the sequence isn’t a correctly encoded algorithm identifier or if algorithm isn’t one of the allowed algorithms.

pub fn take_set_from<S: Source>( cons: &mut Constructed<'_, S> ) -> Result<Self, DecodeError<S::Error>>

Takes and returns a set of digest algorithm identifiers.

The set must contain exactly one identifier as required everywhere for RPKI. If it contains more than one or identifiers that are not allowed, a malformed error is returned.

pub fn skip_set<S: Source>( cons: &mut Constructed<'_, S> ) -> Result<(), DecodeError<S::Error>>

Parses a SET OF DigestAlgorithmIdentifiers.

This is used in the digestAlgorithms field of the SignedData container. It provides all the digest algorithms used later on, so that the data can be read over. We don’t really need this, so this function returns () on success.

Section 2.1.2. of RFC 6488 requires there to be exactly one element chosen from the allowed values.

pub fn take_oid_from<S: Source>( cons: &mut Constructed<'_, S> ) -> Result<Self, DecodeError<S::Error>>

Takes a single algorithm object identifier from a constructed value.

pub fn encode(self) -> impl Values

Provides an encoder for a single algorithm identifier.

pub fn encode_set(self) -> impl Values

Provides an encoder for a indentifer as the sole value of a set.

pub fn encode_oid(self) -> impl Values

Provides an encoder for just the object identifier of the algorithm.

Trait Implementations

impl Clone for DigestAlgorithm

fn clone(&self) -> DigestAlgorithm

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DigestAlgorithm

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DigestAlgorithm

fn default() -> DigestAlgorithm

Returns the “default value” for a type.

impl Hash for DigestAlgorithm

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DigestAlgorithm

fn eq(&self, other: &DigestAlgorithm) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for DigestAlgorithm

impl Eq for DigestAlgorithm

impl StructuralEq for DigestAlgorithm

impl StructuralPartialEq for DigestAlgorithm