dsa 0.7.0

Pure Rust implementation of the Digital Signature Algorithm (DSA) as specified in FIPS 186-4 (Digital Signature Standard), providing RFC6979 deterministic signatures as well as support for added entropy
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

//! Integration tests for `dsa::VerifyingKey`.

// We abused the deprecated attribute for unsecure key sizes
// But we want to use those small key sizes for fast tests
#![allow(deprecated)]
#![cfg(feature = "pkcs8")]

use dsa::VerifyingKey;
use pkcs8::{DecodePublicKey, EncodePublicKey, LineEnding};

#[cfg(feature = "hazmat")]
use {
    crypto_bigint::{
        BoxedUint, Odd,
        modular::{BoxedMontyForm, BoxedMontyParams},
    },
    dsa::{Components, KeySize, SigningKey},
    getrandom::SysRng,
};

const OPENSSL_PEM_PUBLIC_KEY: &str = include_str!("pems/public.pem");

#[cfg(feature = "hazmat")]
fn generate_verifying_key() -> VerifyingKey {
    let mut rng = rand_core::UnwrapErr(SysRng);
    let components =
        Components::try_generate_from_rng_with_key_size(&mut rng, KeySize::DSA_1024_160).unwrap();
    let signing_key =
        SigningKey::try_generate_from_rng_with_components(&mut rng, components).unwrap();

    signing_key.verifying_key().clone()
}

#[test]
fn decode_encode_openssl_verifying_key() {
    let verifying_key = VerifyingKey::from_public_key_pem(OPENSSL_PEM_PUBLIC_KEY)
        .expect("Failed to decode PEM encoded OpenSSL public key");

    let reencoded_verifying_key = verifying_key
        .to_public_key_pem(LineEnding::LF)
        .expect("Failed to encode public key into PEM representation");

    assert_eq!(reencoded_verifying_key, OPENSSL_PEM_PUBLIC_KEY);
}

#[cfg(feature = "hazmat")]
#[test]
fn encode_decode_verifying_key() {
    let verifying_key = generate_verifying_key();
    let encoded_verifying_key = verifying_key.to_public_key_pem(LineEnding::LF).unwrap();
    let decoded_verifying_key = VerifyingKey::from_public_key_pem(&encoded_verifying_key).unwrap();

    assert_eq!(verifying_key, decoded_verifying_key);
}

#[cfg(feature = "hazmat")]
#[test]
fn validate_verifying_key() {
    let verifying_key = generate_verifying_key();
    let p = verifying_key.components().p();
    let q = verifying_key.components().q();

    let params = BoxedMontyParams::new(Odd::new((**p).clone()).unwrap());
    let form = BoxedMontyForm::new((**verifying_key.y()).clone(), &params);

    // Taken from the parameter validation from bouncy castle
    assert_eq!(form.pow(q).retrieve(), BoxedUint::one());
}