jsonwebtoken (Rust)

Facts and the checks behind them

Nothing below is copied from documentation. The check content/libraries/verify/jsonwebtoken-rust/run.sh ran jsonwebtoken (Rust) 11.1.0 in the container image rust:1.99.1-trixie on October 20, 2026; the page must match what it printed, and each fact lists those lines.

• JWS algorithms

  HS256HS384HS512RS256RS384RS512PS256PS384PS512ES256ES384EdDSA

  HS, RS and PS at 256/384/512, ES256, ES384 and EdDSA signed and verified; ES512, ES256K and Ed25519 are not Algorithm variants.

  Recorded by the check

  fact jws-algorithms = HS256, HS384, HS512, RS256, RS384, RS512, PS256, PS384, PS512, ES256, ES384, EdDSA
  evidence jws-algorithms: ES512: not an Algorithm variant
  evidence jws-algorithms: ES256K: not an Algorithm variant
  evidence jws-algorithms: Ed25519: not an Algorithm variant

• ES256 signature encoding

  raw

  ES256 signatures are 64 bytes of raw r‖s.

  Recorded by the check

  fact jws-ecdsa-encoding = raw

• DER signature inside a JWS

  rejected

  A DER-encoded ES256 signature fails with InvalidSignature.

  Recorded by the check

  fact jws-der-signature = rejected
  evidence jws-der-signature: Err("InvalidSignature")

• Algorithm allow-list

  required

  Validation::new(alg) sets the allowed algorithms; an HS256 token checked with Validation::new(ES256) failed with InvalidAlgorithm.

  Recorded by the check

  fact jwt-algorithm-allowlist = required
  evidence jwt-algorithm-allowlist: HS256 token with Validation::new(ES256): Err("InvalidAlgorithm")

• Unsigned tokens (alg none)

  rejected

  none is not an Algorithm variant: the header fails to parse with unknown variant none.

  Recorded by the check

  fact jwt-alg-none = rejected
  evidence jwt-alg-none: Err("JSON error: unknown variant `none`, expected one of `HS256`, `HS384`, `HS512`, `ES256`, `ES384`, `RS256`, `RS384`, `RS512`, `PS256`, `PS384`, `PS512`, `EdDSA` at line 1 column 13"); "none" parses as Algorithm: false

• Public key used as an HMAC secret

  rejected

  With ES256 and HS256 both allowed, an HS256 token keyed with the PEM text failed against the EC DecodingKey with InvalidKeyFormat.

  Recorded by the check

  fact jwt-hmac-public-key = rejected
  evidence jwt-hmac-public-key: algorithms [ES256, HS256], EC DecodingKey: Err("InvalidKeyFormat")

• Curve checked against alg

  enforced

  Signing ES256 with a P-384 key fails with InvalidEcdsaKey.

  Recorded by the check

  fact jwt-ecdsa-curve-check = enforced
  evidence jwt-ecdsa-curve-check: Ok(Err("InvalidEcdsaKey"))

• Default clock skew

  60s

  Validation::new sets leeway to 60 seconds: a token expired 57 seconds earlier validated, one expired 63 seconds earlier did not.

  Recorded by the check

  fact jwt-clock-skew = 60s
  evidence jwt-clock-skew: Validation::new(HS256).leeway = 60

• Expiry claim required

  yes

  A token without exp fails with Missing required claim: exp.

  Recorded by the check

  fact jwt-exp-required = yes
  evidence jwt-exp-required: Err("Missing required claim: exp")

• No cryptography backend selected

  runtime-panic

  With neither aws_lc_rs nor rust_crypto enabled, the crate compiled and the first encode() panicked with Could not automatically determine the process-level CryptoProvider from jsonwebtoken crate features.

  Recorded by the check

  fact crypto-provider-without-feature = runtime-panic
  evidence crypto-provider-without-feature: default features compile; the first encode() panics with: Could not automatically determine the process-level CryptoProvider from jsonwebtoken crate features.

Usage

use jsonwebtoken::{decode, encode, Algorithm, DecodingKey, EncodingKey, Header, Validation};
use serde::{Deserialize, Serialize};
use std::time::{SystemTime, UNIX_EPOCH};

#[derive(Serialize, Deserialize)]
struct Claims {
    sub: String,
    iss: String,
    exp: u64,
}

fn main() {
    // Choose a backend explicitly: features = ["aws_lc_rs"] or ["rust_crypto"].
    let secret = b"use at least 32 random bytes from a secrets manager";
    let exp = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs() + 600;
    let claims = Claims { sub: "user-42".into(), iss: "https://auth.example.com".into(), exp };
    let token = encode(&Header::new(Algorithm::HS256), &claims, &EncodingKey::from_secret(secret)).unwrap();

    // Validation::new(alg) is the allow-list; exp is required, leeway defaults to 60 s.
    let mut validation = Validation::new(Algorithm::HS256);
    validation.set_issuer(&["https://auth.example.com"]);
    validation.leeway = 30;
    let data = decode::<Claims>(&token, &DecodingKey::from_secret(secret), &validation).unwrap();
    println!("sub: {}", data.claims.sub);
}