Struct RsaSha1Signature 

#[non_exhaustive]
pub struct RsaSha1Signature {
    pub signature: Vec<u8>,
}

RSA signature using SHA-1 as per “Signing documents” in dir-spec

https://spec.torproject.org/dir-spec/netdoc.html#signing

Used for AuthCert::dir-key-certification, for example.

Caveats

This type MUST NOT be used for anomalous signatures such as AuthCert::dir_key_crosscert; in that case because dir_key_crosscert’s set of allowed object labels includes ID SIGNATURE whereas this type is always SIGNATURE

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.

signature: Vec<u8>

The bytes of the signature (base64-decoded).

Implementations

impl RsaSha1Signature

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

Make a signature according to “Signing documents” in the netdoc spec

https://spec.torproject.org/dir-spec/netdoc.html#signing

NetdocEncoder should have had the body of the document (everything except the signatures) already encoded.

item_keyword is the keyword for the signature item. This is needed because different documents use different keywords, and the keyword is covered by the signature (an annoying is a layering violation). See https://gitlab.torproject.org/tpo/core/torspec/-/issues/322.

Example

use derive_deftly::Deftly;
use tor_error::Bug;
use tor_llcrypto::pk::rsa;
use tor_netdoc::derive_deftly_template_NetdocEncodable;
use tor_netdoc::encode::{NetdocEncodable, NetdocEncoder};
use tor_netdoc::types::RsaSha1Signature;

#[derive(Deftly, Default)]
#[derive_deftly(NetdocEncodable)]
pub struct Document {
    pub document_intro_keyword: (),
}
#[derive(Deftly)]
#[derive_deftly(NetdocEncodable)]
pub struct DocumentSignatures {
    pub document_signature: RsaSha1Signature,
}
impl Document {
    pub fn encode_sign(&self, k: &rsa::KeyPair) -> Result<String, Bug> {
        let mut encoder = NetdocEncoder::new();
        self.encode_unsigned(&mut encoder)?;
        let document_signature =
            RsaSha1Signature::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 = rsa::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\n",
    "-----BEGIN SIGNATURE-----\n",
)));

Trait Implementations

impl Clone for RsaSha1Signature

fn clone(&self) -> RsaSha1Signature

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RsaSha1Signature

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

Formats the value using the given formatter.

impl ItemValueEncodable for RsaSha1Signature

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

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

impl PartialEq for RsaSha1Signature

fn eq(&self, other: &RsaSha1Signature) -> 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 RsaSha1Signature

type HashAccu = Sha1WholeKeywordLine

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

fn from_unparsed_and_body<'s>( input: UnparsedItem<'s>, document_body: &SignatureHashInputs<'_>, hash_accu: &mut Sha1WholeKeywordLine, ) -> Result<Self, EP>

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

impl Eq for RsaSha1Signature

impl StructuralPartialEq for RsaSha1Signature