modelbridge 0.5.2

One provider-neutral Rust client for OpenAI, Anthropic, Gemini, Groq, Ollama and friends: streaming, tool calling, an agent loop, usage accounting, and subscription sign-in
Documentation
//! PKCE (RFC 7636) with S256, and the percent-encoding the flows need.

use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use base64::Engine;
use sha2::{Digest, Sha256};

use crate::Error;

pub struct Pkce {
    pub verifier: String,
    pub challenge: String,
    pub state: String,
}

impl Pkce {
    pub fn generate() -> crate::Result<Self> {
        let verifier = random(32)?;
        let challenge = URL_SAFE_NO_PAD.encode(Sha256::digest(verifier.as_bytes()));
        Ok(Self {
            verifier,
            challenge,
            state: random(16)?,
        })
    }
}

pub(crate) fn random(bytes: usize) -> crate::Result<String> {
    let mut buffer = vec![0u8; bytes];
    getrandom::getrandom(&mut buffer)
        .map_err(|error| Error::Config(format!("no OS randomness available: {error}")))?;
    Ok(URL_SAFE_NO_PAD.encode(buffer))
}

/// Percent-encode for a query string. Spaces become `%20`, not `+`, because
/// these values also travel in form bodies that the token endpoints parse
/// strictly.
pub fn encode(value: &str) -> String {
    let mut out = String::with_capacity(value.len());
    for byte in value.bytes() {
        match byte {
            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
                out.push(byte as char)
            }
            b' ' => out.push_str("%20"),
            _ => out.push_str(&format!("%{byte:02X}")),
        }
    }
    out
}

pub fn decode(value: &str) -> String {
    let bytes = value.as_bytes();
    let mut out = Vec::with_capacity(bytes.len());
    let mut index = 0;
    while index < bytes.len() {
        match bytes[index] {
            b'%' if index + 2 < bytes.len() => {
                match u8::from_str_radix(&value[index + 1..index + 3], 16) {
                    Ok(byte) => {
                        out.push(byte);
                        index += 3;
                    }
                    Err(_) => {
                        out.push(bytes[index]);
                        index += 1;
                    }
                }
            }
            b'+' => {
                out.push(b' ');
                index += 1;
            }
            byte => {
                out.push(byte);
                index += 1;
            }
        }
    }
    String::from_utf8_lossy(&out).into_owned()
}

pub fn form(pairs: &[(&str, &str)]) -> String {
    pairs
        .iter()
        .map(|(key, value)| format!("{}={}", encode(key), encode(value)))
        .collect::<Vec<_>>()
        .join("&")
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn a_challenge_is_the_sha256_of_the_verifier() {
        let pkce = Pkce::generate().unwrap();
        let expected = URL_SAFE_NO_PAD.encode(Sha256::digest(pkce.verifier.as_bytes()));
        assert_eq!(pkce.challenge, expected);
        assert_ne!(pkce.verifier, pkce.state);
    }

    #[test]
    fn two_generations_never_match() {
        let one = Pkce::generate().unwrap();
        let two = Pkce::generate().unwrap();
        assert_ne!(one.verifier, two.verifier);
        assert_ne!(one.state, two.state);
    }

    #[test]
    fn encoding_survives_a_round_trip() {
        let value = "scope one/two+three&four";
        assert_eq!(decode(&encode(value)), value);
        assert!(!encode(value).contains(' '));
    }

    #[test]
    fn decoding_tolerates_malformed_input() {
        assert_eq!(decode("a%2"), "a%2");
        assert_eq!(decode("a%zzb"), "a%zzb");
        assert_eq!(decode("one+two"), "one two");
    }

    #[test]
    fn form_bodies_encode_both_sides_of_each_pair() {
        assert_eq!(
            form(&[("grant_type", "authorization_code"), ("code", "a b&c")]),
            "grant_type=authorization_code&code=a%20b%26c"
        );
    }
}