uselesskey 0.4.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
145
146
147
148
149
150
151

//! Adapter example: uselesskey + jsonwebtoken crate.
//!
//! Demonstrates signing and verifying JWTs using uselesskey fixtures
//! with the popular `jsonwebtoken` crate via `uselesskey-jsonwebtoken`.
//!
//! Run with: cargo run -p uselesskey --example adapter_jsonwebtoken --features full

#[cfg(all(
    feature = "rsa",
    feature = "ecdsa",
    feature = "ed25519",
    feature = "hmac"
))]
fn main() {
    use jsonwebtoken::{Algorithm, Header, Validation, decode, encode};
    use serde::{Deserialize, Serialize};
    use uselesskey::{
        EcdsaFactoryExt, EcdsaSpec, Ed25519FactoryExt, Ed25519Spec, Factory, HmacFactoryExt,
        HmacSpec, RsaFactoryExt, RsaSpec,
    };
    use uselesskey_jsonwebtoken::JwtKeyExt;

    #[derive(Debug, Serialize, Deserialize, PartialEq)]
    struct Claims {
        sub: String,
        exp: usize,
    }

    let fx = Factory::random();
    let claims = Claims {
        sub: "user-42".to_string(),
        exp: 2_000_000_000,
    };

    // =========================================================================
    // 1. RSA (RS256) — sign and verify
    // =========================================================================
    println!("=== RSA RS256 ===\n");

    let rsa = fx.rsa("jwt-issuer", RsaSpec::rs256());
    let token = encode(&Header::new(Algorithm::RS256), &claims, &rsa.encoding_key()).unwrap();

    let decoded = decode::<Claims>(
        &token,
        &rsa.decoding_key(),
        &Validation::new(Algorithm::RS256),
    )
    .unwrap();

    assert_eq!(decoded.claims, claims);
    println!("  Token length : {} chars", token.len());
    println!("  Verified     : ✓");

    // =========================================================================
    // 2. ECDSA (ES256) — sign and verify
    // =========================================================================
    println!("\n=== ECDSA ES256 ===\n");

    let ec = fx.ecdsa("jwt-issuer-ec", EcdsaSpec::es256());
    let ec_token = encode(&Header::new(Algorithm::ES256), &claims, &ec.encoding_key()).unwrap();

    let ec_decoded = decode::<Claims>(
        &ec_token,
        &ec.decoding_key(),
        &Validation::new(Algorithm::ES256),
    )
    .unwrap();

    assert_eq!(ec_decoded.claims, claims);
    println!("  Token length : {} chars", ec_token.len());
    println!("  Verified     : ✓");

    // =========================================================================
    // 3. Ed25519 (EdDSA) — sign and verify
    // =========================================================================
    println!("\n=== Ed25519 EdDSA ===\n");

    let ed = fx.ed25519("jwt-issuer-ed", Ed25519Spec::default());
    let ed_token = encode(&Header::new(Algorithm::EdDSA), &claims, &ed.encoding_key()).unwrap();

    let ed_decoded = decode::<Claims>(
        &ed_token,
        &ed.decoding_key(),
        &Validation::new(Algorithm::EdDSA),
    )
    .unwrap();

    assert_eq!(ed_decoded.claims, claims);
    println!("  Token length : {} chars", ed_token.len());
    println!("  Verified     : ✓");

    // =========================================================================
    // 4. HMAC (HS256) — sign and verify
    // =========================================================================
    println!("\n=== HMAC HS256 ===\n");

    let hmac = fx.hmac("jwt-secret", HmacSpec::hs256());
    let hmac_token = encode(
        &Header::new(Algorithm::HS256),
        &claims,
        &hmac.encoding_key(),
    )
    .unwrap();

    let hmac_decoded = decode::<Claims>(
        &hmac_token,
        &hmac.decoding_key(),
        &Validation::new(Algorithm::HS256),
    )
    .unwrap();

    assert_eq!(hmac_decoded.claims, claims);
    println!("  Token length : {} chars", hmac_token.len());
    println!("  Verified     : ✓");

    // =========================================================================
    // 5. Cross-key verification failure (proves keys are distinct)
    // =========================================================================
    println!("\n=== Cross-Key Verification ===\n");

    let other_rsa = fx.rsa("different-issuer", RsaSpec::rs256());
    let result = decode::<Claims>(
        &token,
        &other_rsa.decoding_key(),
        &Validation::new(Algorithm::RS256),
    );
    assert!(result.is_err());
    println!("  Wrong key → verification fails : ✓");

    // =========================================================================
    // 6. Token size comparison across algorithms
    // =========================================================================
    println!("\n=== Token Size Comparison ===\n");
    println!("  RS256  : {} chars", token.len());
    println!("  ES256  : {} chars", ec_token.len());
    println!("  EdDSA  : {} chars", ed_token.len());
    println!("  HS256  : {} chars", hmac_token.len());

    println!("\n=== All jsonwebtoken adapter examples passed ===");
}

#[cfg(not(all(
    feature = "rsa",
    feature = "ecdsa",
    feature = "ed25519",
    feature = "hmac"
)))]
fn main() {
    eprintln!("Enable all key type features:");
    eprintln!("  cargo run -p uselesskey --example adapter_jsonwebtoken --features full");
}