use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use base64::Engine;
use serde_json::Value;
#[derive(Debug, Clone)]
pub struct DecodedJwt {
pub header_json: String,
pub payload_json: String,
pub algorithm: Option<String>,
pub token_type: Option<String>,
pub issuer: Option<String>,
pub subject: Option<String>,
pub audience: Option<String>,
pub expiration_ms: Option<i64>,
pub issued_at_ms: Option<i64>,
pub not_before_ms: Option<i64>,
pub jwt_id: Option<String>,
}
pub fn decode_jwt(token: &str) -> Option<DecodedJwt> {
let token = token.trim().trim_end_matches('\\');
let parts: Vec<&str> = token.split('.').collect();
if parts.len() != 3 {
return None;
}
let header_bytes = base64url_decode(parts[0])?;
let payload_bytes = base64url_decode(parts[1])?;
let header_str = String::from_utf8(header_bytes).ok()?;
let payload_str = String::from_utf8(payload_bytes).ok()?;
let header: Value = serde_json::from_str(&header_str).ok()?;
let payload: Value = serde_json::from_str(&payload_str).ok()?;
let algorithm = header.get("alg").and_then(Value::as_str).map(String::from);
let token_type = header.get("typ").and_then(Value::as_str).map(String::from);
let issuer = payload.get("iss").and_then(Value::as_str).map(String::from);
let subject = payload.get("sub").and_then(Value::as_str).map(String::from);
let audience = payload.get("aud").map(|v| match v {
Value::String(s) => s.clone(),
other => other.to_string(),
});
let expiration_ms = epoch_seconds_to_ms(&payload, "exp");
let issued_at_ms = epoch_seconds_to_ms(&payload, "iat");
let not_before_ms = epoch_seconds_to_ms(&payload, "nbf");
let jwt_id = payload.get("jti").and_then(Value::as_str).map(String::from);
Some(DecodedJwt {
header_json: header_str,
payload_json: payload_str,
algorithm,
token_type,
issuer,
subject,
audience,
expiration_ms,
issued_at_ms,
not_before_ms,
jwt_id,
})
}
pub fn decode_jwt_base64(encoded: &str) -> Option<DecodedJwt> {
let trimmed = encoded.trim();
if let Some(inner_bytes) = base64url_decode(trimmed) {
if let Ok(inner_str) = String::from_utf8(inner_bytes) {
if let Some(jwt) = decode_jwt(&inner_str) {
return Some(jwt);
}
}
}
decode_jwt(trimmed)
}
fn base64url_decode(input: &str) -> Option<Vec<u8>> {
URL_SAFE_NO_PAD
.decode(input)
.or_else(|_| {
use base64::engine::general_purpose::URL_SAFE;
URL_SAFE.decode(input)
})
.or_else(|_| {
let padded = match input.len() % 4 {
2 => format!("{input}=="),
3 => format!("{input}="),
_ => input.to_string(),
};
URL_SAFE_NO_PAD.decode(&padded)
})
.ok()
}
#[allow(clippy::cast_possible_truncation)] fn epoch_seconds_to_ms(payload: &Value, key: &str) -> Option<i64> {
payload
.get(key)
.and_then(|v| v.as_i64().or_else(|| v.as_f64().map(|f| f as i64)))
.map(|secs| secs.saturating_mul(1000))
}
#[cfg(test)]
mod tests {
use super::*;
const NETLIFY_JWT: &str = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzaXRlX2lkIjoiYTg1ZGYwMDMtZGUyMi00ZTNjLThkODItZDAzMzk5MzVjZTY3IiwiYWNjb3VudF9pZCI6IjYzNDlkYmEzNzI2ODMwMTVhY2Y4ZmI3ZSIsImRlcGxveV9pZCI6IjY5YjJmOWYwMDUzMzgxMDAwODc0NjIyYyIsImlzcyI6Im5ldGxpZnkifQ.7cZdXD18ikgVB87TjYZREggugzGweI0ri0VumAUGDG4";
#[test]
fn test_decode_valid_jwt() {
let result = decode_jwt(NETLIFY_JWT);
assert!(result.is_some(), "Should decode valid JWT");
let jwt = result.unwrap();
assert_eq!(jwt.algorithm.as_deref(), Some("HS256"));
assert_eq!(jwt.token_type.as_deref(), Some("JWT"));
assert_eq!(jwt.issuer.as_deref(), Some("netlify"));
assert!(jwt.header_json.contains("\"alg\""));
assert!(jwt.payload_json.contains("\"site_id\""));
}
#[test]
fn test_decode_jwt_with_expiration() {
let token = "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0IiwiZXhwIjoxNzAwMDAwMDAwLCJpYXQiOjE2OTk5OTkwMDB9.signature";
let jwt = decode_jwt(token).unwrap();
assert_eq!(jwt.subject.as_deref(), Some("1234"));
assert_eq!(jwt.expiration_ms, Some(1_700_000_000_000));
assert_eq!(jwt.issued_at_ms, Some(1_699_999_000_000));
}
#[test]
fn test_decode_malformed_jwt() {
assert!(decode_jwt("not-a-jwt").is_none());
assert!(decode_jwt("only.two").is_none());
assert!(decode_jwt("a.b.c.d").is_none());
assert!(decode_jwt("").is_none());
}
#[test]
fn test_decode_invalid_base64() {
assert!(decode_jwt("!!!.!!!.!!!").is_none());
}
#[test]
fn test_decode_invalid_json() {
let not_json = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(b"not json");
let token = format!("{not_json}.{not_json}.sig");
assert!(decode_jwt(&token).is_none());
}
#[test]
fn test_decode_invalid_utf8_payload_returns_none() {
let not_utf8 = base64::engine::general_purpose::URL_SAFE_NO_PAD
.encode([0xff, 0xfe, 0xfd, 0xfc, 0x80, 0x81]);
let valid_header =
base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(br#"{"alg":"HS256"}"#);
let bad_header = format!("{not_utf8}.{valid_header}.sig");
assert!(decode_jwt(&bad_header).is_none());
let bad_payload = format!("{valid_header}.{not_utf8}.sig");
assert!(decode_jwt(&bad_payload).is_none());
}
#[test]
fn test_decode_jwt_with_trailing_backslash() {
let with_backslash = format!("{NETLIFY_JWT}\\");
let jwt = decode_jwt(&with_backslash).unwrap();
assert_eq!(jwt.algorithm.as_deref(), Some("HS256"));
}
#[test]
fn test_decode_jwt_minimal_claims() {
let header = URL_SAFE_NO_PAD.encode(br#"{"alg":"none"}"#);
let payload = URL_SAFE_NO_PAD.encode(b"{}");
let token = format!("{header}.{payload}.sig");
let jwt = decode_jwt(&token).unwrap();
assert_eq!(jwt.algorithm.as_deref(), Some("none"));
assert!(jwt.issuer.is_none());
assert!(jwt.expiration_ms.is_none());
}
#[test]
fn test_decode_jwt_audience_string() {
let header = URL_SAFE_NO_PAD.encode(br#"{"alg":"HS256"}"#);
let payload = URL_SAFE_NO_PAD.encode(br#"{"aud":"my-app"}"#);
let token = format!("{header}.{payload}.sig");
let jwt = decode_jwt(&token).unwrap();
assert_eq!(jwt.audience.as_deref(), Some("my-app"));
}
#[test]
fn test_decode_jwt_audience_array() {
let header = URL_SAFE_NO_PAD.encode(br#"{"alg":"HS256"}"#);
let payload = URL_SAFE_NO_PAD.encode(br#"{"aud":["app1","app2"]}"#);
let token = format!("{header}.{payload}.sig");
let jwt = decode_jwt(&token).unwrap();
assert_eq!(jwt.audience.as_deref(), Some(r#"["app1","app2"]"#));
}
#[test]
fn test_decode_jwt_base64_falls_back_to_plain_jwt() {
let jwt = decode_jwt_base64(NETLIFY_JWT).expect("plain JWT must decode via fallback");
assert_eq!(jwt.algorithm.as_deref(), Some("HS256"));
assert_eq!(jwt.token_type.as_deref(), Some("JWT"));
assert_eq!(jwt.issuer.as_deref(), Some("netlify"));
}
#[test]
fn test_decode_jwt_base64_decodes_wrapped_jwt() {
let wrapped = URL_SAFE_NO_PAD.encode(NETLIFY_JWT.as_bytes());
let jwt = decode_jwt_base64(&wrapped).expect("wrapped JWT must decode via primary path");
assert_eq!(jwt.algorithm.as_deref(), Some("HS256"));
assert_eq!(jwt.issuer.as_deref(), Some("netlify"));
}
#[test]
fn test_decode_jwt_base64_returns_none_for_garbage() {
assert!(decode_jwt_base64("aGJHY2lPaU").is_none());
assert!(decode_jwt_base64("not-a-jwt-at-all").is_none());
assert!(decode_jwt_base64("").is_none());
}
}