//! Information about directory authorities

//!

//! From a client's point of view, an authority's role is to to sign the

//! consensus directory.

use derive_builder::Builder;

use serde::Deserialize;

use tor_llcrypto::pk::rsa::RsaIdentity;

use tor_netdoc::doc::authcert::{AuthCert, AuthCertKeyIds};

/// A single authority that signs a consensus directory.

//

// Note that we do *not* set serde(deny_unknown_fields)] on this structure:

// we want our authorities format to be future-proof against adding new info

// about each authority.

pub struct Authority {

    /// A memorable nickname for this authority.

    #[builder(setter(into))]

    name: String,

    /// A SHA1 digest of the DER-encoded long-term v3 RSA identity key for

    /// this authority.

    // TODO: It would be lovely to use a better hash for these identities.

    v3ident: RsaIdentity,

}

impl Authority {

    /// Return a new builder for constructing an [`Authority`].

    ///

    /// You only need this if you're using a non-default Tor network

    /// with its own set of directory authorities.

    /// Return the (human-readable) name for this authority.

    /// Return the v3 identity key of this certificate.

    ///

    /// This is the identity of the >=2048-bit RSA key that the

    /// authority uses to sign documents; it is distinct from its

    /// identity keys that it uses when operating as a relay.

    /// Return true if this authority matches a given certificate.

    /// Return true if this authority matches a given key ID.

}

/// Return a vector of the default directory authorities.

impl AuthorityBuilder {

    /// Make a new AuthorityBuilder with no fields set.

}

#[cfg(test)]

mod test {

    #![allow(clippy::unwrap_used)]

    use super::*;

    #[test]

    fn authority() {

        let key1: RsaIdentity = [9_u8; 20].into();

        let key2: RsaIdentity = [10_u8; 20].into();

        let auth = Authority::builder()

            .name("example")

            .v3ident(key1)

            .build()

            .unwrap();

        assert_eq!(auth.v3ident(), &key1);

        let keyids1 = AuthCertKeyIds {

            id_fingerprint: key1,

            sk_fingerprint: key2,

        };

        assert!(auth.matches_keyid(&keyids1));

        let keyids2 = AuthCertKeyIds {

            id_fingerprint: key2,

            sk_fingerprint: key2,

        };

        assert!(!auth.matches_keyid(&keyids2));

    }

    #[test]

    fn auth() {

        let dflt = default_authorities();

        assert_eq!(&dflt[0].name[..], "bastet");

        assert_eq!(

            &dflt[0].v3ident.to_string()[..],

            "$27102bc123e7af1d4741ae047e160c91adc76b21"

        );

    }

}