jwt-lab 0.1.1

JWT crate for Rust: decode, verify, sign, mutate, JWK/JWKS, algorithm selection, time validation, and secure APIs.
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

//! JWK and JWKS functionality tests
//!
//! These tests verify that JSON Web Keys can be parsed, converted to internal
//! Key types, and selected from JWKS collections correctly.

use jwt_lab::{Jwk, Jwks, Key, Algorithm};

#[test]
fn test_oct_jwk() {
    let jwk = Jwk {
        kty: "oct".to_string(),
        kid: Some("test-key".to_string()),
        alg: Some("HS256".to_string()),
        use_: Some("sig".to_string()),
        n: None,
        e: None,
        d: None,
        p: None,
        q: None,
        dp: None,
        dq: None,
        qi: None,
        crv: None,
        x: None,
        y: None,
        k: Some("dGVzdC1zZWNyZXQ".to_string()), // "test-secret" in base64url
    };

    let key = jwk.to_key_for(Algorithm::HS256).unwrap();
    match key {
        Key::Hs(bytes) => {
            assert_eq!(bytes, b"test-secret");
        }
        _ => panic!("Expected HS key"),
    }
}

#[test]
fn test_jwks_selection() {
    let jwks = Jwks {
        keys: vec![
            Jwk {
                kty: "oct".to_string(),
                kid: Some("key1".to_string()),
                alg: Some("HS256".to_string()),
                use_: Some("sig".to_string()),
                n: None,
                e: None,
                d: None,
                p: None,
                q: None,
                dp: None,
                dq: None,
                qi: None,
                crv: None,
                x: None,
                y: None,
                k: Some("dGVzdC1rZXkx".to_string()), // "test-key1" in base64url
            },
            Jwk {
                kty: "oct".to_string(),
                kid: Some("key2".to_string()),
                alg: Some("HS256".to_string()),
                use_: Some("sig".to_string()),
                n: None,
                e: None,
                d: None,
                p: None,
                q: None,
                dp: None,
                dq: None,
                qi: None,
                crv: None,
                x: None,
                y: None,
                k: Some("dGVzdC1rZXky".to_string()), // "test-key2" in base64url
            },
        ],
    };

    let key1 = jwks.select_for("key1", Algorithm::HS256).unwrap();
    let key2 = jwks.select_for("key2", Algorithm::HS256).unwrap();

    match (key1, key2) {
        (Key::Hs(bytes1), Key::Hs(bytes2)) => {
            assert_eq!(bytes1, b"test-key1");
            assert_eq!(bytes2, b"test-key2");
        }
        _ => panic!("Expected HS keys"),
    }

    // Test missing key
    assert!(jwks.select_for("missing", Algorithm::HS256).is_err());
}