use base64::Engine;
use serde_json::Value;
use crate::protocol::crypto::{self, IdentityKey};
pub const CLIENT_LABEL: &[u8] = b"WSE-SIG client\0";
pub const SERVER_LABEL: &[u8] = b"WSE-SIG server\0";
pub const MAX_NONCE_LEN: usize = 128;
fn b64() -> base64::engine::GeneralPurpose {
base64::engine::general_purpose::STANDARD
}
pub fn key_id(public_key: &[u8]) -> String {
hex::encode(&crypto::sha256(public_key)[..8])
}
pub fn now_ms() -> u64 {
web_time::SystemTime::now()
.duration_since(web_time::UNIX_EPOCH)
.map_or(0, |d| d.as_millis() as u64)
}
pub fn signed_input(label: &[u8], body: &str) -> Vec<u8> {
let mut input = Vec::with_capacity(label.len() + body.len());
input.extend_from_slice(label);
input.extend_from_slice(body.as_bytes());
input
}
pub struct PublicKey {
pub kid: String,
key: crypto::VerifyingKey,
point: Vec<u8>,
}
impl PublicKey {
pub fn from_sec1(public_key: &[u8]) -> Option<Self> {
if public_key.len() != crypto::P256_PUBLIC_LEN || public_key[0] != 0x04 {
return None;
}
let key = crypto::VerifyingKey::from_sec1(public_key)?;
Some(Self {
kid: key_id(public_key),
key,
point: public_key.to_vec(),
})
}
pub fn point(&self) -> &[u8] {
&self.point
}
pub fn from_base64(public_key: &str) -> Option<Self> {
Self::from_sec1(&b64().decode(public_key.trim()).ok()?)
}
pub fn from_jwk(jwk: &Value) -> Option<Self> {
if jwk.get("kty")?.as_str()? != "EC" || jwk.get("crv")?.as_str()? != "P-256" {
return None;
}
let coordinate = |name: &str| {
base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(jwk.get(name)?.as_str()?)
.ok()
.filter(|bytes| bytes.len() == 32)
};
let mut point = Vec::with_capacity(crypto::P256_PUBLIC_LEN);
point.push(0x04);
point.extend_from_slice(&coordinate("x")?);
point.extend_from_slice(&coordinate("y")?);
Self::from_sec1(&point)
}
pub fn verifies(&self, label: &[u8], body: &str, signature: &[u8]) -> bool {
self.key.verifies(&signed_input(label, body), signature)
}
}
pub enum Binding {
Key(PublicKey),
Thumbprint(String),
}
impl Binding {
pub fn from_claims(claims: &Value) -> Result<Option<Self>, BadBinding> {
let Some(cnf) = claims.get("cnf") else {
return Ok(None);
};
if let Some(jwk) = cnf.get("jwk") {
return PublicKey::from_jwk(jwk)
.map(|key| Some(Self::Key(key)))
.ok_or(BadBinding);
}
match cnf.get("jkt").and_then(Value::as_str) {
Some(jkt) if is_thumbprint(jkt) => Ok(Some(Self::Thumbprint(jkt.to_owned()))),
_ => Err(BadBinding),
}
}
pub fn holds(&self, point: &[u8]) -> bool {
match self {
Self::Key(key) => key.point() == point,
Self::Thumbprint(jkt) => thumbprint(point).is_some_and(|t| t == *jkt),
}
}
pub fn thumbprint(&self) -> String {
match self {
Self::Key(key) => thumbprint(key.point()).unwrap_or_default(),
Self::Thumbprint(jkt) => jkt.clone(),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct BadBinding;
pub fn thumbprint(point: &[u8]) -> Option<String> {
if point.len() != crypto::P256_PUBLIC_LEN || point[0] != 0x04 {
return None;
}
let b64u = base64::engine::general_purpose::URL_SAFE_NO_PAD;
let jwk = format!(
r#"{{"crv":"P-256","kty":"EC","x":"{}","y":"{}"}}"#,
b64u.encode(&point[1..33]),
b64u.encode(&point[33..])
);
Some(b64u.encode(crypto::sha256(jwk.as_bytes())))
}
fn is_thumbprint(jkt: &str) -> bool {
base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(jkt)
.is_ok_and(|digest| digest.len() == 32)
}
pub struct Signer {
key: IdentityKey,
pub kid: String,
pub public_key: String,
}
impl Signer {
pub fn thumbprint(&self) -> String {
thumbprint(self.key.public_key()).unwrap_or_default()
}
pub fn prove_session(&self, th: &[u8; 32]) -> Result<String, crate::protocol::e2e::E2eError> {
crate::protocol::e2e::client_auth(th, &self.key)
}
pub fn from_pkcs8(key: &[u8]) -> Result<Self, crypto::Error> {
let key = IdentityKey::from_pkcs8(key)?;
let public = key.public_key();
Ok(Self {
kid: key_id(public),
public_key: b64().encode(public),
key,
})
}
pub fn sign_envelope(&self, label: &[u8], body: &str) -> Result<String, crypto::Error> {
let signature = self.key.sign(&signed_input(label, body))?;
Ok(serde_json::json!({
"t": "signed",
"sb": body,
"sig": b64().encode(signature),
"kid": self.kid,
})
.to_string())
}
}
pub fn parse_exact(body: &str) -> Option<Value> {
if !integers_exact(body) {
return None;
}
let mut de = serde_json::Deserializer::from_str(body);
let Exact(value) = serde::Deserialize::deserialize(&mut de).ok()?;
de.end().ok()?;
Some(value)
}
fn integers_exact(body: &str) -> bool {
let bytes = body.as_bytes();
let mut i = 0;
let mut in_string = false;
while i < bytes.len() {
let b = bytes[i];
if in_string {
match b {
b'\\' => i += 1,
b'"' => in_string = false,
_ => {}
}
i += 1;
continue;
}
match b {
b'"' => {
in_string = true;
i += 1;
}
b'-' | b'0'..=b'9' => {
let start = i;
while i < bytes.len()
&& matches!(bytes[i], b'-' | b'+' | b'.' | b'e' | b'E' | b'0'..=b'9')
{
i += 1;
}
let literal = &body[start..i];
if !literal.contains(['.', 'e', 'E'])
&& literal.parse::<i64>().is_err()
&& literal.parse::<u64>().is_err()
{
return false;
}
}
_ => i += 1,
}
}
true
}
struct Exact(Value);
impl<'de> serde::Deserialize<'de> for Exact {
fn deserialize<D: serde::Deserializer<'de>>(de: D) -> Result<Self, D::Error> {
de.deserialize_any(ExactVisitor).map(Exact)
}
}
struct ExactVisitor;
impl<'de> serde::de::Visitor<'de> for ExactVisitor {
type Value = Value;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("JSON")
}
fn visit_bool<E>(self, v: bool) -> Result<Value, E> {
Ok(Value::Bool(v))
}
fn visit_i64<E>(self, v: i64) -> Result<Value, E> {
Ok(v.into())
}
fn visit_u64<E>(self, v: u64) -> Result<Value, E> {
Ok(v.into())
}
fn visit_f64<E: serde::de::Error>(self, v: f64) -> Result<Value, E> {
serde_json::Number::from_f64(v)
.map(Value::Number)
.ok_or_else(|| E::custom("not a finite number"))
}
fn visit_str<E>(self, v: &str) -> Result<Value, E> {
Ok(Value::String(v.to_owned()))
}
fn visit_string<E>(self, v: String) -> Result<Value, E> {
Ok(Value::String(v))
}
fn visit_unit<E>(self) -> Result<Value, E> {
Ok(Value::Null)
}
fn visit_seq<A: serde::de::SeqAccess<'de>>(self, mut seq: A) -> Result<Value, A::Error> {
let mut items = Vec::new();
while let Some(Exact(item)) = seq.next_element()? {
items.push(item);
}
Ok(Value::Array(items))
}
fn visit_map<A: serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Value, A::Error> {
let mut object = serde_json::Map::new();
while let Some(key) = map.next_key::<String>()? {
if object.contains_key(&key) {
return Err(serde::de::Error::custom("a key twice"));
}
let Exact(value) = map.next_value()?;
object.insert(key, value);
}
Ok(Value::Object(object))
}
}
#[cfg(test)]
mod tests {
use super::*;
fn pair() -> (IdentityKey, PublicKey) {
let pair = IdentityKey::from_pkcs8(&crypto::generate_p256_pkcs8().unwrap()).unwrap();
let key = PublicKey::from_sec1(pair.public_key()).unwrap();
(pair, key)
}
#[test]
fn a_jwk_names_the_same_key_as_its_point() {
let (_, key) = pair();
let (other, _) = pair();
let point = other.public_key();
let url = base64::engine::general_purpose::URL_SAFE_NO_PAD;
let jwk = serde_json::json!({
"kty": "EC", "crv": "P-256",
"x": url.encode(&point[1..33]), "y": url.encode(&point[33..]),
});
let from_jwk = PublicKey::from_jwk(&jwk).unwrap();
assert_eq!(from_jwk.kid, key_id(point));
assert_ne!(from_jwk.kid, key.kid);
let claims = serde_json::json!({"sub": "u", "cnf": {"jwk": jwk}});
let Ok(Some(Binding::Key(bound))) = Binding::from_claims(&claims) else {
panic!("bound by its jwk");
};
assert_eq!(bound.kid, from_jwk.kid);
assert!(
PublicKey::from_jwk(&serde_json::json!({"kty": "OKP", "crv": "Ed25519"})).is_none()
);
assert!(PublicKey::from_base64("not base64!").is_none());
}
#[test]
fn a_thumbprint_is_rfc_7638s() {
let url = base64::engine::general_purpose::URL_SAFE_NO_PAD;
let mut point = vec![0x04];
point.extend(
url.decode("l8tFrhx-34tV3hRICRDY9zCkDlpBhF42UQUfWVAWBFs")
.unwrap(),
);
point.extend(
url.decode("9VE4jf_Ok_o64zbTTlcuNJajHmt6v9TDVrU0CdvGRDA")
.unwrap(),
);
assert_eq!(
thumbprint(&point).as_deref(),
Some("0ZcOCORZNYy-DWpqq30jZyJGHTN0d2HglBV3uiguA4I")
);
assert_eq!(thumbprint(&point[1..]), None);
}
#[test]
fn a_token_binds_by_key_or_thumbprint_and_nothing_else() {
let (pair, key) = pair();
let point = pair.public_key();
let jkt = thumbprint(point).unwrap();
let claims = |cnf: Value| serde_json::json!({"sub": "u", "cnf": cnf});
let by_jkt = Binding::from_claims(&claims(serde_json::json!({"jkt": jkt})))
.unwrap()
.unwrap();
assert!(by_jkt.holds(point));
assert_eq!(by_jkt.thumbprint(), jkt);
let (other, _) = super::tests::pair();
assert!(!by_jkt.holds(other.public_key()));
let by_key = Binding::Key(key);
assert!(by_key.holds(point));
assert_eq!(by_key.thumbprint(), jkt);
assert!(matches!(
Binding::from_claims(&serde_json::json!({"sub": "u"})),
Ok(None)
));
for bad in [
serde_json::json!({"jkt": "short"}),
serde_json::json!({"jkt": 7}),
serde_json::json!({"jwk": {"kty": "OKP", "crv": "Ed25519", "x": "AA"}}),
serde_json::json!({"x5t#S256": "AAAA"}),
serde_json::json!("a string"),
] {
assert_eq!(
Binding::from_claims(&claims(bad.clone())).err(),
Some(BadBinding),
"{bad}"
);
}
}
#[test]
fn a_session_proof_holds_for_its_session_and_key_only() {
let pkcs8 = crypto::generate_p256_pkcs8().unwrap();
let signer = Signer::from_pkcs8(&pkcs8).unwrap();
let th = [7u8; 32];
let message: Value = serde_json::from_str(&signer.prove_session(&th).unwrap()).unwrap();
assert_eq!(message["t"], "client_auth");
let proved = crate::protocol::e2e::check_client_auth(&th, &message["p"]).unwrap();
assert_eq!(key_id(&proved), signer.kid);
assert!(crate::protocol::e2e::check_client_auth(&[8u8; 32], &message["p"]).is_none());
let mut p = message["p"].clone();
let input = crate::protocol::e2e::client_auth_input(&th, &proved);
let mut relabeled = CLIENT_LABEL.to_vec();
relabeled.extend_from_slice(&input[crate::protocol::e2e::CLIENT_AUTH_LABEL.len()..]);
let other_label = IdentityKey::from_pkcs8(&pkcs8)
.unwrap()
.sign(&relabeled)
.unwrap();
p["sig"] = b64().encode(other_label).into();
assert!(crate::protocol::e2e::check_client_auth(&th, &p).is_none());
let (other, _) = pair();
let mut p = message["p"].clone();
p["key"] = b64().encode(other.public_key()).into();
assert!(crate::protocol::e2e::check_client_auth(&th, &p).is_none());
}
#[test]
fn a_signer_signs_under_its_label_only() {
let pkcs8 = crypto::generate_p256_pkcs8().unwrap();
let signer = Signer::from_pkcs8(&pkcs8).unwrap();
let body = r#"{"t":"order","ts":1,"n":"a"}"#;
let env: Value =
serde_json::from_str(&signer.sign_envelope(CLIENT_LABEL, body).unwrap()).unwrap();
assert_eq!(
(env["sb"].as_str(), env["kid"].as_str()),
(Some(body), Some(signer.kid.as_str()))
);
let key = PublicKey::from_base64(&signer.public_key).unwrap();
let sig = b64().decode(env["sig"].as_str().unwrap()).unwrap();
assert!(key.verifies(CLIENT_LABEL, body, &sig));
assert!(!key.verifies(SERVER_LABEL, body, &sig));
}
#[test]
fn a_body_reads_one_way_only() {
assert!(parse_exact(r#"{"a":1,"a":2}"#).is_none());
assert!(parse_exact(r#"{"a":12345678901234567890123}"#).is_none());
assert!(parse_exact(r#"{"a":"12345678901234567890123","b":-1.5e3}"#).is_some());
}
}