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