Struct tor_netdoc::doc::netstatus::UnvalidatedConsensus

#[non_exhaustive]
pub struct UnvalidatedConsensus<RS> {
    pub consensus: Consensus<RS>,
    pub siggroup: SignatureGroup,
    pub n_authorities: Option<u16>,
}

A Microdesc consensus whose signatures have not yet been checked.

To validate this object, call set_n_authorities() on it, then call check_signature() on that result with the set of certs that you have. Make sure only to provide authority certificates representing real authorities!

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

consensus: Consensus<RS>

Available on crate feature dangerous-expose-struct-fields only.

The consensus object. We don’t want to expose this until it’s validated.

siggroup: SignatureGroup

Available on crate feature dangerous-expose-struct-fields only.

The signatures that need to be validated before we can call this consensus valid.

n_authorities: Option<u16>

Available on crate feature dangerous-expose-struct-fields only.

The total number of authorities that we believe in. We need this information in order to validate the signatures, since it determines how many signatures we need to find valid in siggroup.

Implementations

impl<RS> UnvalidatedConsensus<RS>

pub fn set_n_authorities(self, n_authorities: u16) -> Self

Tell the unvalidated consensus how many authorities we believe in.

Without knowing this number, we can’t validate the signature.

pub fn signing_cert_ids(&self) -> impl Iterator<Item = AuthCertKeyIds>

Return an iterator of all the certificate IDs that we might use to validate this consensus.

pub fn peek_lifetime(&self) -> &Lifetime

Return the lifetime of this unvalidated consensus

pub fn authorities_are_correct(&self, authorities: &[&RsaIdentity]) -> bool

Return true if a client who believes in exactly the provided set of authority IDs might might consider this consensus to be well-signed.

(This is the case if the consensus claims to be signed by more than half of the authorities in the list.)

pub fn n_relays(&self) -> usize

Available on crate feature experimental-api only.

Return the number of relays in this unvalidated consensus.

This function is unstable. It is only enabled if the crate was built with the experimental-api feature.

pub fn modify_relays<F>(&mut self, func: F)

where F: FnOnce(&mut Vec<RS>),

Available on crate feature experimental-api only.

Modify the list of relays in this unvalidated consensus.

A use case for this is long-lasting custom directories. To ensure Arti can still quickly build circuits when the directory gets old, a tiny churn file can be regularly obtained, listing no longer available Tor nodes, which can then be removed from the consensus.

This function is unstable. It is only enabled if the crate was built with the experimental-api feature.

Trait Implementations

impl<RS: Clone> Clone for UnvalidatedConsensus<RS>

fn clone(&self) -> UnvalidatedConsensus<RS>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<RS: Debug> Debug for UnvalidatedConsensus<RS>

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

Formats the value using the given formatter.

impl<RS> ExternallySigned<Consensus<RS>> for UnvalidatedConsensus<RS>

type Key = [AuthCert]

The type of the public key object.

type KeyHint = Vec<AuthCertKeyIds>

A type that describes what keys are missing for this object.

type Error = Error

An error type that’s returned when the object is not well-signed.

fn key_is_correct(&self, k: &Self::Key) -> Result<(), Self::KeyHint>

Check whether k is the right key for this object. If not, return an error describing what key would be right.

fn is_well_signed(&self, k: &Self::Key) -> Result<(), Self::Error>

Check the signature on this object

fn dangerously_assume_wellsigned(self) -> Consensus<RS>

Unwrap this object without checking any signatures on it.

fn check_signature(self, k: &Self::Key) -> Result<T, Self::Error>

Unwrap this object if it’s correctly signed by a provided key.