repositories / smith
smith
There are many coding harnesses - but this one is fast
owned by admin
smith-harness/src/oauth_crypto.rs
Raw//! OAuth encoding and signature engine facade (`SMH-SPEC-SPEC0001`).
use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
use serde_json::Value;
pub fn encode(bytes: &[u8]) -> String {
URL_SAFE_NO_PAD.encode(bytes)
}
pub fn decode(text: &str) -> Result<Vec<u8>, &'static str> {
URL_SAFE_NO_PAD
.decode(text)
.map_err(|_| "invalid OAuth base64url")
}
pub fn challenge(verifier: &str) -> String {
encode(ring::digest::digest(&ring::digest::SHA256, verifier.as_bytes()).as_ref())
}
pub fn verify_identity(token: &str, keys: &Value) -> Result<Value, &'static str> {
const TOKEN_BYTES_MAX: usize = 32 * 1024;
if token.len() > TOKEN_BYTES_MAX {
return Err("OAuth ID token exceeds byte bound");
}
let mut parts = token.split('.');
let header = parts.next().ok_or("missing OAuth JWT header")?;
let payload = parts.next().ok_or("missing OAuth JWT payload")?;
let signature = parts.next().ok_or("missing OAuth JWT signature")?;
if parts.next().is_some() {
return Err("invalid OAuth JWT segments");
}
let header: Value =
serde_json::from_slice(&decode(header)?).map_err(|_| "invalid OAuth JWT header")?;
let fields = header.as_object().ok_or("invalid OAuth JWT header")?;
if fields
.keys()
.any(|name| !matches!(name.as_str(), "alg" | "kid" | "typ"))
|| header.get("typ").is_some_and(|kind| kind != "JWT")
{
return Err("unsupported OAuth JWT header");
}
let algorithm = header["alg"]
.as_str()
.ok_or("missing OAuth JWT algorithm")?;
let key_id = header["kid"]
.as_str()
.filter(|id| !id.is_empty())
.ok_or("missing OAuth JWT key id")?;
let keys = keys["keys"]
.as_array()
.filter(|keys| keys.len() <= 64)
.ok_or("invalid OAuth JWKS key bound")?;
let mut matching = keys
.iter()
.filter(|key| key["kid"].as_str() == Some(key_id));
let key = matching.next().ok_or("unknown OAuth signing key")?;
if matching.next().is_some()
|| key
.get("alg")
.is_some_and(|value| value.as_str() != Some(algorithm))
|| key.get("use").is_some_and(|value| value != "sig")
|| key
.get("key_ops")
.is_some_and(|value| value != &serde_json::json!(["verify"]))
{
return Err("ambiguous or unauthorized OAuth signing key");
}
let signature = decode(signature)?;
// The signature covers original encoded segments, never reserialized JSON.
let message = token
.rsplit_once('.')
.ok_or("invalid OAuth JWT")?
.0
.as_bytes();
match (algorithm, key["kty"].as_str()) {
("RS256", Some("RSA")) => {
let modulus = decode(key["n"].as_str().ok_or("missing OAuth RSA modulus")?)?;
let exponent = decode(key["e"].as_str().ok_or("missing OAuth RSA exponent")?)?;
ring::signature::RsaPublicKeyComponents {
n: modulus,
e: exponent,
}
.verify(
&ring::signature::RSA_PKCS1_2048_8192_SHA256,
message,
&signature,
)
.map_err(|_| "invalid OAuth ID signature")?;
}
("EdDSA", Some("OKP")) if key["crv"] == "Ed25519" => {
let public = decode(key["x"].as_str().ok_or("missing OAuth Ed25519 key")?)?;
ring::signature::UnparsedPublicKey::new(&ring::signature::ED25519, public)
.verify(message, &signature)
.map_err(|_| "invalid OAuth ID signature")?;
}
_ => return Err("unsupported OAuth signature algorithm or key type"),
}
serde_json::from_slice(&decode(payload)?).map_err(|_| "invalid OAuth JWT claims")
}
#[cfg(test)]
pub(crate) mod tests {
//! SMH-SPEC-SPEC0001: signed synthetic identities, no provider keys.
use super::*;
use ring::signature::{Ed25519KeyPair, KeyPair};
use serde_json::json;
pub(crate) fn signed(payload: &Value) -> (String, Value) {
let pair = Ed25519KeyPair::from_seed_unchecked(&[42; 32]).unwrap();
let header = encode(br#"{"alg":"EdDSA","kid":"fixture","typ":"JWT"}"#);
let body = encode(&serde_json::to_vec(payload).unwrap());
let message = format!("{header}.{body}");
let signature = encode(pair.sign(message.as_bytes()).as_ref());
let keys = json!({"keys":[{"kty":"OKP","crv":"Ed25519","alg":"EdDSA","use":"sig","kid":"fixture","x":encode(pair.public_key().as_ref())}]});
(format!("{message}.{signature}"), keys)
}
#[test]
fn signed_identity_requires_authentic_signature_and_unambiguous_key() {
let payload = json!({"sub":"synthetic-account","aud":"oaiapp_fixture"});
let (token, keys) = signed(&payload);
assert_eq!(verify_identity(&token, &keys).unwrap(), payload);
let tampered = token.replace(
&encode(&serde_json::to_vec(&payload).unwrap()),
&encode(br#"{"sub":"attacker"}"#),
);
assert!(verify_identity(&tampered, &keys).is_err());
let mut duplicate = keys.clone();
duplicate["keys"]
.as_array_mut()
.unwrap()
.push(keys["keys"][0].clone());
assert!(verify_identity(&token, &duplicate).is_err());
let mut wrong = keys.clone();
wrong["keys"][0]["kty"] = json!("RSA");
assert!(verify_identity(&token, &wrong).is_err());
}
#[test]
fn pkce_matches_rfc7636_s256_example() {
assert_eq!(
challenge("dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk"),
"E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM"
);
}
}