uselesskey 0.3.0

Deterministic cryptographic key and certificate fixtures for Rust tests. Seed-stable, cached, scanner-safe.
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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

mod testutil;

#[test]
fn prelude_exposes_core_items() {
    use uselesskey::prelude::*;

    let fx = Factory::random();
    assert!(matches!(fx.mode(), Mode::Random));

    let seed = Seed::from_env_value("facade-seed").unwrap();
    let fx = Factory::deterministic(seed);
    assert!(matches!(fx.mode(), Mode::Deterministic { .. }));

    let pem = "-----BEGIN TEST-----\nAAA=\n-----END TEST-----\n";
    let corrupted = corrupt_pem(pem, CorruptPem::BadHeader);
    assert!(corrupted.contains("CORRUPTED"));
}

#[test]
#[cfg(feature = "rsa")]
fn rsa_reexport_works() {
    use uselesskey::RsaFactoryExt;
    use uselesskey::RsaSpec;

    let fx = testutil::fx();
    let key = fx.rsa("issuer", RsaSpec::rs256());
    assert!(key.private_key_pkcs8_pem().contains("BEGIN PRIVATE KEY"));
}

#[test]
#[cfg(feature = "ecdsa")]
fn ecdsa_reexport_works() {
    use uselesskey::EcdsaFactoryExt;
    use uselesskey::EcdsaSpec;

    let fx = testutil::fx();
    let key = fx.ecdsa("issuer", EcdsaSpec::es256());
    assert!(key.private_key_pkcs8_pem().contains("BEGIN PRIVATE KEY"));
}

#[test]
#[cfg(feature = "ed25519")]
fn ed25519_reexport_works() {
    use uselesskey::Ed25519FactoryExt;
    use uselesskey::Ed25519Spec;

    let fx = testutil::fx();
    let key = fx.ed25519("issuer", Ed25519Spec::new());
    assert!(key.private_key_pkcs8_pem().contains("BEGIN PRIVATE KEY"));
}

#[test]
#[cfg(feature = "hmac")]
fn hmac_reexport_works() {
    use uselesskey::HmacFactoryExt;
    use uselesskey::HmacSpec;

    let fx = testutil::fx();
    let secret = fx.hmac("issuer", HmacSpec::hs256());
    assert_eq!(secret.secret_bytes().len(), HmacSpec::hs256().byte_len());
}

#[test]
#[cfg(feature = "token")]
fn token_reexport_works() {
    use uselesskey::TokenFactoryExt;
    use uselesskey::TokenSpec;

    let fx = testutil::fx();
    let token = fx.token("issuer", TokenSpec::api_key());
    assert!(token.value().starts_with("uk_test_"));
}

#[test]
#[cfg(all(feature = "rsa", feature = "token"))]
fn deterministic_facade_usage_is_order_independent() {
    use uselesskey::{Factory, RsaFactoryExt, RsaSpec, Seed, TokenFactoryExt, TokenSpec};

    let seed = Seed::new([0x5A; 32]);

    let fx_a = Factory::deterministic(seed);
    let token_a = fx_a.token("dogfood-token", TokenSpec::api_key());
    let rsa_a = fx_a.rsa("dogfood-rsa", RsaSpec::rs256());

    let fx_b = Factory::deterministic(seed);
    let rsa_b = fx_b.rsa("dogfood-rsa", RsaSpec::rs256());
    let token_b = fx_b.token("dogfood-token", TokenSpec::api_key());

    assert_eq!(token_a.value(), token_b.value());
    assert_eq!(rsa_a.kid(), rsa_b.kid());
    assert_eq!(rsa_a.private_key_pkcs8_der(), rsa_b.private_key_pkcs8_der());
}

#[test]
#[cfg(feature = "x509")]
fn x509_reexport_works() {
    use uselesskey::{ChainSpec, X509FactoryExt, X509Spec};

    let fx = testutil::fx();
    let cert = fx.x509_self_signed("issuer", X509Spec::self_signed("facade.example.com"));
    assert!(cert.cert_pem().contains("BEGIN CERTIFICATE"));
    assert!(cert.private_key_pkcs8_pem().contains("BEGIN PRIVATE KEY"));

    let chain = fx.x509_chain("issuer-chain", ChainSpec::new("facade.example.com"));
    assert!(chain.chain_pem().contains("BEGIN CERTIFICATE"));
    assert!(chain.root_cert_pem().contains("BEGIN CERTIFICATE"));
    assert!(
        chain
            .leaf_private_key_pkcs8_pem()
            .contains("BEGIN PRIVATE KEY")
    );
}

#[test]
#[cfg(feature = "pgp")]
fn pgp_reexport_works() {
    use uselesskey::PgpFactoryExt;
    use uselesskey::PgpSpec;

    let fx = testutil::fx();
    let key = fx.pgp("issuer", PgpSpec::ed25519());
    assert!(
        key.private_key_armored()
            .contains("BEGIN PGP PRIVATE KEY BLOCK")
    );
}

#[test]
#[cfg(feature = "jwk")]
fn jwk_module_reexports_work() {
    use uselesskey::jwk::{JwksBuilder, PublicJwk, RsaPublicJwk};

    let jwk = PublicJwk::Rsa(RsaPublicJwk {
        kty: "RSA",
        use_: "sig",
        alg: "RS256",
        kid: "kid".to_string(),
        n: "n".to_string(),
        e: "e".to_string(),
    });

    let jwks = JwksBuilder::new().add_public(jwk).build();
    assert_eq!(jwks.keys.len(), 1);
}