Struct RouterSigEd25519 

pub struct RouterSigEd25519(pub Signature);

SHA-256 router descriptor signature including magic and the keyword.

Tuple Fields

0: Signature

Implementations

impl RouterSigEd25519

const HASH_PREFIX_MAGIC: &str = "Tor router descriptor signature v1"

The magic prefix for hashing this type of signature.

fn hash(document_sofar: &str, signature_item_kw_spc: &[&str]) -> [u8; 32]

Calculate the hash for signature

signature_item_kw_spc is the keyword with a trailing space. It’s &[&str] for the convenience of the two call sites.

pub fn new_sign_netdoc( private_key: &Keypair, encoder: &NetdocEncoder, item_keyword: &str, ) -> StdResult<Self, Bug>

Make a signature during document encoding

item_keyword is the keyword for the signature item.

Example

use derive_deftly::Deftly;
use tor_error::Bug;
use tor_llcrypto::pk::ed25519;
use tor_netdoc::derive_deftly_template_NetdocEncodable;
use tor_netdoc::encode::{NetdocEncodable, NetdocEncoder};
use tor_netdoc::types::routerdesc::RouterSigEd25519;

#[derive(Deftly, Default)]
#[derive_deftly(NetdocEncodable)]
pub struct Document {
    pub document_intro_keyword: (),
}
#[derive(Deftly)]
#[derive_deftly(NetdocEncodable)]
pub struct DocumentSignatures {
    pub document_signature: RouterSigEd25519,
}
impl Document {
    pub fn encode_sign(&self, k: &ed25519::Keypair) -> Result<String, Bug> {
        let mut encoder = NetdocEncoder::new();
        self.encode_unsigned(&mut encoder)?;
        let document_signature =
            RouterSigEd25519::new_sign_netdoc(k, &encoder, "document-signature")?;
        let sigs = DocumentSignatures { document_signature };
        sigs.encode_unsigned(&mut encoder)?;
        let encoded = encoder.finish()?;
        Ok(encoded)
    }
}

let k = ed25519::Keypair::generate(&mut tor_basic_utils::test_rng::testing_rng());
let doc = Document::default();
let encoded = doc.encode_sign(&k)?;
assert!(encoded.starts_with(concat!(
    "document-intro-keyword\n",
    "document-signature ",
)));

Trait Implementations

impl Clone for RouterSigEd25519

fn clone(&self) -> RouterSigEd25519

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RouterSigEd25519

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

Formats the value using the given formatter.

impl ItemValueEncodable for RouterSigEd25519

fn write_item_value_onto(&self, out: ItemEncoder<'_>) -> Result<(), Bug>

Write the item’s arguments, and any object, onto out

impl PartialEq for RouterSigEd25519

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl SignatureItemParseable for RouterSigEd25519

type HashAccu = RouterHashAccu

The Rust type of the hash value accumulator for this item.

fn from_unparsed_and_body( item: UnparsedItem<'_>, hash_inputs: &SignatureHashInputs<'_>, hash: &mut Self::HashAccu, ) -> Result<Self, EP>

Parse the item’s value, and also calculate the relevant document hash

impl Eq for RouterSigEd25519

impl StructuralPartialEq for RouterSigEd25519