use super::error::PasskeyError;
use super::verify;
#[must_use]
pub fn generate_challenge() -> Vec<u8> {
use rand::RngCore as _;
let mut buf = [0u8; 32];
rand::rngs::OsRng.fill_bytes(&mut buf);
buf.to_vec()
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct RegistrationOutcome {
pub credential_id: String,
pub cose_public_key: Vec<u8>,
pub sign_count: i64,
pub user_verified: bool,
}
impl RegistrationOutcome {
pub fn require(self, policy: UserVerification) -> Result<Self, PasskeyError> {
policy.check(self.user_verified).map(|()| self)
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
#[non_exhaustive]
pub enum UserVerification {
Required,
#[default]
Preferred,
Discouraged,
}
impl UserVerification {
fn as_str(self) -> &'static str {
match self {
Self::Required => "required",
Self::Preferred => "preferred",
Self::Discouraged => "discouraged",
}
}
fn check(self, user_verified: bool) -> Result<(), PasskeyError> {
if self == Self::Required && !user_verified {
return Err(PasskeyError::UserNotVerified);
}
Ok(())
}
}
pub fn verify_registration(
challenge: &[u8],
rp_id: &str,
allowed_origins: &[String],
client_data_json: &[u8],
attestation_object: &[u8],
) -> Result<RegistrationOutcome, PasskeyError> {
verify::parse_and_verify_client_data(
client_data_json,
"webauthn.create",
challenge,
allowed_origins,
)?;
let value: ciborium::value::Value = ciborium::de::from_reader(attestation_object)
.map_err(|e| PasskeyError::Cbor(e.to_string()))?;
let auth_data_bytes = extract_auth_data(&value)?;
let ad = verify::parse_authenticator_data(&auth_data_bytes)?;
verify::verify_rp_id(&ad, rp_id)?;
if !ad.user_present() {
return Err(PasskeyError::UserNotPresent);
}
let user_verified = ad.user_verified();
let attested = ad.attested.ok_or_else(|| {
PasskeyError::AuthData("registration authData has no attested credential data".into())
})?;
verify::cose_es256_key(&attested.cose_public_key)?;
Ok(RegistrationOutcome {
credential_id: verify::b64url_encode(&attested.credential_id),
cose_public_key: attested.cose_public_key,
sign_count: i64::from(ad.sign_count),
user_verified,
})
}
#[allow(clippy::too_many_arguments)]
pub fn verify_authentication(
challenge: &[u8],
rp_id: &str,
allowed_origins: &[String],
stored_cose_public_key: &[u8],
stored_sign_count: i64,
client_data_json: &[u8],
authenticator_data: &[u8],
signature_der: &[u8],
) -> Result<AuthenticationOutcome, PasskeyError> {
verify::parse_and_verify_client_data(
client_data_json,
"webauthn.get",
challenge,
allowed_origins,
)?;
let ad = verify::parse_authenticator_data(authenticator_data)?;
verify::verify_rp_id(&ad, rp_id)?;
if !ad.user_present() {
return Err(PasskeyError::UserNotPresent);
}
verify::verify_es256_assertion(
stored_cose_public_key,
authenticator_data,
client_data_json,
signature_der,
)?;
let new = i64::from(ad.sign_count);
if (new != 0 || stored_sign_count != 0) && new <= stored_sign_count {
return Err(PasskeyError::CounterRegression);
}
Ok(AuthenticationOutcome {
sign_count: new,
user_verified: ad.user_verified(),
})
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct AuthenticationOutcome {
pub sign_count: i64,
pub user_verified: bool,
}
impl AuthenticationOutcome {
pub fn require(self, policy: UserVerification) -> Result<Self, PasskeyError> {
policy.check(self.user_verified).map(|()| self)
}
}
#[must_use]
pub fn registration_options_json(
rp_id: &str,
rp_name: &str,
user_id: &[u8],
user_name: &str,
challenge: &[u8],
exclude_credential_ids: &[String],
) -> serde_json::Value {
RegistrationOptions::new(rp_id, rp_name, user_id, user_name, challenge)
.exclude(exclude_credential_ids)
.to_json()
}
#[must_use]
pub fn authentication_options_json(
rp_id: &str,
challenge: &[u8],
allow_credential_ids: &[String],
) -> serde_json::Value {
AuthenticationOptions::new(rp_id, challenge)
.allow(allow_credential_ids)
.to_json()
}
#[derive(Debug, Clone)]
#[must_use]
pub struct RegistrationOptions<'a> {
rp_id: &'a str,
rp_name: &'a str,
user_id: &'a [u8],
user_name: &'a str,
challenge: &'a [u8],
exclude: &'a [String],
user_verification: UserVerification,
prf: bool,
}
impl<'a> RegistrationOptions<'a> {
pub fn new(
rp_id: &'a str,
rp_name: &'a str,
user_id: &'a [u8],
user_name: &'a str,
challenge: &'a [u8],
) -> Self {
Self {
rp_id,
rp_name,
user_id,
user_name,
challenge,
exclude: &[],
user_verification: UserVerification::default(),
prf: false,
}
}
pub fn exclude(mut self, credential_ids: &'a [String]) -> Self {
self.exclude = credential_ids;
self
}
pub fn user_verification(mut self, policy: UserVerification) -> Self {
self.user_verification = policy;
self
}
pub fn prf(mut self) -> Self {
self.prf = true;
self
}
#[must_use]
pub fn to_json(&self) -> serde_json::Value {
let mut v = serde_json::json!({
"challenge": verify::b64url_encode(self.challenge),
"rp": { "id": self.rp_id, "name": self.rp_name },
"user": {
"id": verify::b64url_encode(self.user_id),
"name": self.user_name,
"displayName": self.user_name,
},
"pubKeyCredParams": [ { "type": "public-key", "alg": -7 } ],
"timeout": 60000,
"attestation": "none",
"excludeCredentials": credential_list(self.exclude),
"authenticatorSelection": {
"userVerification": self.user_verification.as_str(),
"residentKey": "preferred",
},
});
if self.prf {
v["extensions"] = serde_json::json!({ "prf": {} });
}
v
}
}
#[derive(Debug, Clone)]
#[must_use]
pub struct AuthenticationOptions<'a> {
rp_id: &'a str,
challenge: &'a [u8],
allow: &'a [String],
user_verification: UserVerification,
prf_salt: Option<&'a [u8]>,
prf_by_credential: Vec<(&'a str, &'a [u8])>,
}
impl<'a> AuthenticationOptions<'a> {
pub fn new(rp_id: &'a str, challenge: &'a [u8]) -> Self {
Self {
rp_id,
challenge,
allow: &[],
user_verification: UserVerification::default(),
prf_salt: None,
prf_by_credential: Vec::new(),
}
}
pub fn allow(mut self, credential_ids: &'a [String]) -> Self {
self.allow = credential_ids;
self
}
pub fn user_verification(mut self, policy: UserVerification) -> Self {
self.user_verification = policy;
self
}
pub fn prf_salt(mut self, salt: &'a [u8]) -> Self {
self.prf_salt = Some(salt);
self
}
pub fn prf_salt_for(mut self, credential_id: &'a str, salt: &'a [u8]) -> Self {
self.prf_by_credential.push((credential_id, salt));
self
}
#[must_use]
pub fn to_json(&self) -> serde_json::Value {
let mut v = serde_json::json!({
"challenge": verify::b64url_encode(self.challenge),
"rpId": self.rp_id,
"timeout": 60000,
"userVerification": self.user_verification.as_str(),
"allowCredentials": credential_list(self.allow),
});
let mut prf = serde_json::Map::new();
if let Some(salt) = self.prf_salt {
prf.insert("eval".into(), prf_values(salt));
}
if !self.prf_by_credential.is_empty() {
let by: serde_json::Map<String, serde_json::Value> = self
.prf_by_credential
.iter()
.map(|(id, salt)| ((*id).to_owned(), prf_values(salt)))
.collect();
prf.insert("evalByCredential".into(), by.into());
}
if !prf.is_empty() {
v["extensions"] = serde_json::json!({ "prf": prf });
}
v
}
}
fn credential_list(ids: &[String]) -> Vec<serde_json::Value> {
ids.iter()
.map(|id| serde_json::json!({ "type": "public-key", "id": id }))
.collect()
}
fn prf_values(salt: &[u8]) -> serde_json::Value {
serde_json::json!({ "first": verify::b64url_encode(salt) })
}
fn extract_auth_data(value: &ciborium::value::Value) -> Result<Vec<u8>, PasskeyError> {
use ciborium::value::Value;
let Value::Map(entries) = value else {
return Err(PasskeyError::AuthData(
"attestationObject is not a CBOR map".into(),
));
};
for (k, v) in entries {
if let Value::Text(key) = k {
if key == "authData" {
if let Value::Bytes(b) = v {
return Ok(b.clone());
}
return Err(PasskeyError::AuthData(
"authData is not a byte string".into(),
));
}
}
}
Err(PasskeyError::AuthData(
"attestationObject has no authData".into(),
))
}
#[cfg(test)]
mod tests {
use super::*;
use ciborium::value::Value;
use sha2::{Digest, Sha256};
use crate::passkey::verify::tests::TestSigner;
fn rp_hash(rp_id: &str) -> [u8; 32] {
let mut h = Sha256::new();
h.update(rp_id.as_bytes());
h.finalize().into()
}
fn reg_auth_data(rp_id: &str, cred_id: &[u8], cose: &[u8], count: u32) -> Vec<u8> {
let mut d = Vec::new();
d.extend_from_slice(&rp_hash(rp_id));
d.push(0b0100_0001); d.extend_from_slice(&count.to_be_bytes());
d.extend_from_slice(&[0u8; 16]); #[allow(clippy::cast_possible_truncation)]
d.extend_from_slice(&(cred_id.len() as u16).to_be_bytes());
d.extend_from_slice(cred_id);
d.extend_from_slice(cose);
d
}
fn attestation_object(auth_data: &[u8]) -> Vec<u8> {
let map = Value::Map(vec![
(Value::Text("fmt".into()), Value::Text("none".into())),
(Value::Text("attStmt".into()), Value::Map(vec![])),
(
Value::Text("authData".into()),
Value::Bytes(auth_data.to_vec()),
),
]);
let mut out = Vec::new();
ciborium::ser::into_writer(&map, &mut out).unwrap();
out
}
fn client_data(ty: &str, challenge: &[u8], origin: &str) -> Vec<u8> {
serde_json::to_vec(&serde_json::json!({
"type": ty,
"challenge": verify::b64url_encode(challenge),
"origin": origin,
}))
.unwrap()
}
#[test]
fn a_verified_registration_passes_required() {
let (rp_id, origins) = ("example.com", vec!["https://example.com".to_owned()]);
let cose = TestSigner::new().cose();
let challenge = generate_challenge();
let mut ad = reg_auth_data(rp_id, b"cred-uv", &cose, 1);
ad[32] |= 0b0000_0100; let client = client_data("webauthn.create", &challenge, "https://example.com");
let outcome = verify_registration(
&challenge,
rp_id,
&origins,
&client,
&attestation_object(&ad),
)
.unwrap();
assert!(outcome.user_verified);
assert!(outcome.require(UserVerification::Required).is_ok());
}
#[test]
fn full_register_then_authenticate_round_trip() {
let rp_id = "example.com";
let origins = vec!["https://example.com".to_owned()];
let sk = TestSigner::new();
let cose = sk.cose();
let cred_id = b"credential-handle-1";
let reg_challenge = generate_challenge();
let reg_ad = reg_auth_data(rp_id, cred_id, &cose, 1);
let att_obj = attestation_object(®_ad);
let reg_client = client_data("webauthn.create", ®_challenge, "https://example.com");
let outcome =
verify_registration(®_challenge, rp_id, &origins, ®_client, &att_obj).unwrap();
assert_eq!(outcome.credential_id, verify::b64url_encode(cred_id));
assert_eq!(outcome.sign_count, 1);
assert!(!outcome.user_verified);
assert!(matches!(
outcome.clone().require(UserVerification::Required),
Err(PasskeyError::UserNotVerified)
));
verify::cose_es256_key(&outcome.cose_public_key).unwrap();
let auth_challenge = generate_challenge();
let auth_ad = {
let mut d = Vec::new();
d.extend_from_slice(&rp_hash(rp_id));
d.push(0b0000_0001); d.extend_from_slice(&2u32.to_be_bytes()); d
};
let auth_client = client_data("webauthn.get", &auth_challenge, "https://example.com");
let mut signed = auth_ad.clone();
let mut ch = Sha256::new();
ch.update(&auth_client);
signed.extend_from_slice(&ch.finalize());
let sig = sk.sign(&signed);
let new_count = verify_authentication(
&auth_challenge,
rp_id,
&origins,
&outcome.cose_public_key,
outcome.sign_count,
&auth_client,
&auth_ad,
&sig,
)
.unwrap();
assert_eq!(new_count.sign_count, 2);
assert!(!new_count.user_verified);
}
fn assert_with(
flags: u8,
count: u32,
stored: i64,
) -> Result<AuthenticationOutcome, PasskeyError> {
let rp_id = "example.com";
let origins = vec!["https://example.com".to_owned()];
let sk = TestSigner::new();
let cose = sk.cose();
let challenge = generate_challenge();
let mut ad = Vec::new();
ad.extend_from_slice(&rp_hash(rp_id));
ad.push(flags);
ad.extend_from_slice(&count.to_be_bytes());
let client = client_data("webauthn.get", &challenge, "https://example.com");
let mut signed = ad.clone();
let mut h = Sha256::new();
h.update(&client);
signed.extend_from_slice(&h.finalize());
let sig = sk.sign(&signed);
verify_authentication(
&challenge, rp_id, &origins, &cose, stored, &client, &ad, &sig,
)
}
#[test]
fn counter_regression_is_rejected() {
let r = assert_with(0b0000_0001, 3, 5);
assert!(matches!(r, Err(PasskeyError::CounterRegression)));
}
#[test]
fn clone_resetting_counter_to_zero_is_rejected() {
let r = assert_with(0b0000_0001, 0, 5);
assert!(matches!(r, Err(PasskeyError::CounterRegression)));
assert_eq!(assert_with(0b0000_0001, 0, 0).unwrap().sign_count, 0);
}
#[test]
fn user_verified_flag_is_returned() {
assert!(assert_with(0b0000_0101, 1, 0).unwrap().user_verified);
assert!(!assert_with(0b0000_0001, 1, 0).unwrap().user_verified);
}
#[test]
fn options_json_has_required_shape() {
let reg =
registration_options_json("example.com", "Example", b"user1", "alice", b"chal", &[]);
assert_eq!(reg["rp"]["id"], "example.com");
assert_eq!(reg["pubKeyCredParams"][0]["alg"], -7);
let auth = authentication_options_json("example.com", b"chal", &["abc".to_owned()]);
assert_eq!(auth["rpId"], "example.com");
assert_eq!(auth["allowCredentials"][0]["id"], "abc");
assert_eq!(
reg["authenticatorSelection"]["userVerification"],
"preferred"
);
assert_eq!(auth["userVerification"], "preferred");
assert!(reg.get("extensions").is_none() && auth.get("extensions").is_none());
}
#[test]
fn prf_and_required_uv_reach_the_options() {
let reg = RegistrationOptions::new("example.com", "Example", b"u", "alice", b"chal")
.user_verification(UserVerification::Required)
.prf()
.to_json();
assert_eq!(
reg["authenticatorSelection"]["userVerification"],
"required"
);
assert_eq!(reg["extensions"], serde_json::json!({ "prf": {} }));
let ids = ["c1".to_owned()];
let auth = AuthenticationOptions::new("example.com", b"chal")
.allow(&ids)
.user_verification(UserVerification::Required)
.prf_salt(b"s0")
.prf_salt_for("c1", b"s1")
.to_json();
assert_eq!(auth["userVerification"], "required");
assert_eq!(
auth["extensions"]["prf"],
serde_json::json!({
"eval": { "first": verify::b64url_encode(b"s0") },
"evalByCredential": { "c1": { "first": verify::b64url_encode(b"s1") } },
})
);
}
#[test]
fn required_user_verification_refuses_a_touch_only_assertion() {
let touch = assert_with(0b0000_0001, 1, 0).unwrap();
assert!(matches!(
touch.require(UserVerification::Required),
Err(PasskeyError::UserNotVerified)
));
assert!(touch.require(UserVerification::Preferred).is_ok());
let verified = assert_with(0b0000_0101, 1, 0).unwrap();
assert!(verified.require(UserVerification::Required).is_ok());
}
}