Luigit
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"
        );
    }
}