structured-webauthn 0.1.0

Server-side Web Authentication (WebAuthn) Relying Party (RP) API in pure Rust: registration and authentication ceremonies, passkeys, no OpenSSL.
Documentation
use super::{
    super::{super::PublicKeyCredentialHint, ExtensionReq},
    ClientCredentialRequestOptions, CredentialMediationRequirement, CredentialUiMode,
    ExtensionOwned, FIVE_MINUTES, Hints, NonZeroU32, PublicKeyCredentialRequestOptionsOwned,
    UserVerificationRequirement,
};
use serde_json::Error;
#[expect(
    clippy::panic_in_result_fn,
    clippy::unwrap_used,
    reason = "OK in tests"
)]
#[expect(clippy::cognitive_complexity, reason = "a lot to test")]
#[test]
fn client_options() -> Result<(), Error> {
    let mut err =
        serde_json::from_str::<ClientCredentialRequestOptions>(r#"{"bob":true}"#).unwrap_err();
    assert_eq!(
        err.to_string().get(..71),
        Some("unknown field `bob`, expected one of `mediation`, `uiMode`, `publicKey`")
    );
    err = serde_json::from_str::<ClientCredentialRequestOptions>(
        r#"{"mediation":"required","mediation":"required"}"#,
    )
    .unwrap_err();
    assert_eq!(
        err.to_string().get(..27),
        Some("duplicate field `mediation`")
    );
    let mut options = serde_json::from_str::<ClientCredentialRequestOptions>("{}")?;
    assert!(matches!(
        options.mediation,
        CredentialMediationRequirement::Required
    ));
    assert!(options.ui_mode.is_none());
    assert!(options.public_key.rp_id.is_none());
    assert_eq!(options.public_key.timeout, FIVE_MINUTES);
    assert!(matches!(
        options.public_key.user_verification,
        UserVerificationRequirement::Preferred
    ));
    assert_eq!(options.public_key.hints, Hints::EMPTY);
    assert!(options.public_key.extensions.prf.is_none());
    options = serde_json::from_str::<ClientCredentialRequestOptions>(
        r#"{"mediation":null,"uiMode":null,"publicKey":null}"#,
    )?;
    assert!(matches!(
        options.mediation,
        CredentialMediationRequirement::Required
    ));
    assert!(options.ui_mode.is_none());
    assert!(options.public_key.rp_id.is_none());
    assert_eq!(options.public_key.timeout, FIVE_MINUTES);
    assert!(matches!(
        options.public_key.user_verification,
        UserVerificationRequirement::Preferred
    ));
    assert_eq!(options.public_key.hints, Hints::EMPTY);
    assert!(options.public_key.extensions.prf.is_none());
    options = serde_json::from_str::<ClientCredentialRequestOptions>(r#"{"publicKey":{}}"#)?;
    assert!(options.public_key.rp_id.is_none());
    assert_eq!(options.public_key.timeout, FIVE_MINUTES);
    assert!(matches!(
        options.public_key.user_verification,
        UserVerificationRequirement::Preferred
    ));
    assert_eq!(options.public_key.hints, Hints::EMPTY);
    assert!(options.public_key.extensions.prf.is_none());
    options = serde_json::from_str::<ClientCredentialRequestOptions>(
        r#"{"mediation":"conditional","uiMode":"immediate","publicKey":{"rpId":"example.com","timeout":300000,"allowCredentials":[],"userVerification":"required","extensions":{"prf":{"eval":{"first":"","second":""}}},"hints":["security-key"],"challenge":null}}"#,
    )?;
    assert!(matches!(
        options.mediation,
        CredentialMediationRequirement::Conditional
    ));
    assert_eq!(options.ui_mode, Some(CredentialUiMode::Immediate));
    assert!(
        options
            .public_key
            .rp_id
            .is_some_and(|val| val.as_ref() == "example.com")
    );
    assert_eq!(options.public_key.timeout, FIVE_MINUTES);
    assert!(matches!(
        options.public_key.user_verification,
        UserVerificationRequirement::Required
    ));
    assert!(
        options
            .public_key
            .extensions
            .prf
            .is_some_and(|prf| prf.first.is_empty()
                && prf.second.is_some_and(|p| p.is_empty())
                && matches!(prf.ext_req, ExtensionReq::Allow))
    );
    Ok(())
}
#[expect(
    clippy::panic_in_result_fn,
    clippy::unwrap_used,
    reason = "OK in tests"
)]
#[expect(clippy::cognitive_complexity, reason = "a lot to test")]
#[test]
fn key_options() -> Result<(), Error> {
    let mut err = serde_json::from_str::<PublicKeyCredentialRequestOptionsOwned>(r#"{"bob":true}"#)
        .unwrap_err();
    assert_eq!(
        err.to_string().get(..130),
        Some(
            "unknown field `bob`, expected one of `rpId`, `userVerification`, `challenge`, `timeout`, `allowCredentials`, `hints`, `extensions`"
        )
    );
    err = serde_json::from_str::<PublicKeyCredentialRequestOptionsOwned>(
        r#"{"rpId":"example.com","rpId":"example.com"}"#,
    )
    .unwrap_err();
    assert_eq!(err.to_string().get(..22), Some("duplicate field `rpId`"));
    err = serde_json::from_str::<PublicKeyCredentialRequestOptionsOwned>(
        r#"{"challenge":"AAAAAAAAAAAAAAAAAAAAAA"}"#,
    )
    .unwrap_err();
    assert_eq!(
        err.to_string().get(..41),
        Some("invalid type: Option value, expected null")
    );
    err = serde_json::from_str::<PublicKeyCredentialRequestOptionsOwned>(
        r#"{"allowCredentials":[{"type":"public-key","transports":["usb"],"id":"AAAAAAAAAAAAAAAAAAAAAA"}]}"#,
    )
    .unwrap_err();
    assert_eq!(err.to_string().get(..19), Some("trailing characters"));
    err = serde_json::from_str::<PublicKeyCredentialRequestOptionsOwned>(r#"{"timeout":0}"#)
        .unwrap_err();
    assert_eq!(
        err.to_string().get(..50),
        Some("invalid value: integer `0`, expected a nonzero u32")
    );
    err =
        serde_json::from_str::<PublicKeyCredentialRequestOptionsOwned>(r#"{"timeout":4294967296}"#)
            .unwrap_err();
    assert_eq!(
        err.to_string().get(..59),
        Some("invalid value: integer `4294967296`, expected a nonzero u32")
    );
    let mut key = serde_json::from_str::<PublicKeyCredentialRequestOptionsOwned>("{}")?;
    assert!(key.rp_id.is_none());
    assert_eq!(key.timeout, FIVE_MINUTES);
    assert!(matches!(
        key.user_verification,
        UserVerificationRequirement::Preferred
    ));
    assert!(key.extensions.prf.is_none());
    assert_eq!(key.hints, Hints::EMPTY);
    key = serde_json::from_str::<PublicKeyCredentialRequestOptionsOwned>(
        r#"{"rpId":null,"timeout":null,"allowCredentials":null,"userVerification":null,"extensions":null,"hints":null,"challenge":null}"#,
    )?;
    assert!(key.rp_id.is_none());
    assert_eq!(key.timeout, FIVE_MINUTES);
    assert!(matches!(
        key.user_verification,
        UserVerificationRequirement::Preferred
    ));
    assert!(key.extensions.prf.is_none());
    assert_eq!(key.hints, Hints::EMPTY);
    key = serde_json::from_str::<PublicKeyCredentialRequestOptionsOwned>(
        r#"{"allowCredentials":[],"extensions":{},"hints":[]}"#,
    )?;
    assert!(matches!(
        key.user_verification,
        UserVerificationRequirement::Preferred
    ));
    assert_eq!(key.hints, Hints::EMPTY);
    assert!(key.extensions.prf.is_none());
    key = serde_json::from_str::<PublicKeyCredentialRequestOptionsOwned>(
        r#"{"extensions":{"prf":null}}"#,
    )?;
    assert!(key.extensions.prf.is_none());
    key = serde_json::from_str::<PublicKeyCredentialRequestOptionsOwned>(
        r#"{"rpId":"example.com","timeout":300000,"allowCredentials":[],"userVerification":"required","extensions":{"prf":{"eval":{"first":"","second":""}}},"hints":["security-key"],"challenge":null}"#,
    )?;
    assert!(key.rp_id.is_some_and(|val| val.as_ref() == "example.com"));
    assert_eq!(key.timeout, FIVE_MINUTES);
    assert!(matches!(
        key.user_verification,
        UserVerificationRequirement::Required
    ));
    assert_eq!(
        key.hints,
        Hints::EMPTY.add(PublicKeyCredentialHint::SecurityKey)
    );
    assert!(key.extensions.prf.is_some_and(|prf| prf.first.is_empty()
        && prf.second.is_some_and(|p| p.is_empty())
        && matches!(prf.ext_req, ExtensionReq::Allow)));
    key = serde_json::from_str::<PublicKeyCredentialRequestOptionsOwned>(
        r#"{"timeout":4294967295}"#,
    )?;
    assert_eq!(key.timeout, NonZeroU32::MAX);
    Ok(())
}
#[expect(
    clippy::panic_in_result_fn,
    clippy::unwrap_used,
    reason = "OK in tests"
)]
#[test]
fn extension() -> Result<(), Error> {
    let mut err = serde_json::from_str::<ExtensionOwned>(r#"{"bob":true}"#).unwrap_err();
    assert_eq!(
        err.to_string().get(..35),
        Some("unknown field `bob`, expected `prf`")
    );
    err = serde_json::from_str::<ExtensionOwned>(
        r#"{"prf":{"eval":{"first":"","second":""}},"prf":{"eval":{"first":"","second":""}}}"#,
    )
    .unwrap_err();
    assert_eq!(err.to_string().get(..21), Some("duplicate field `prf`"));
    err = serde_json::from_str::<ExtensionOwned>(r#"{"prf":{"eval":{"first":null}}}"#).unwrap_err();
    assert_eq!(
        err.to_string().get(..51),
        Some("invalid type: null, expected base64url-encoded data")
    );
    let mut ext =
        serde_json::from_str::<ExtensionOwned>(r#"{"prf":{"eval":{"first":"","second":""}}}"#)?;
    assert!(ext.prf.is_some_and(|prf| prf.first.is_empty()
        && prf.second.is_some_and(|v| v.is_empty())
        && matches!(prf.ext_req, ExtensionReq::Allow)));
    ext = serde_json::from_str::<ExtensionOwned>(r#"{"prf":null}"#)?;
    assert!(ext.prf.is_none());
    ext = serde_json::from_str::<ExtensionOwned>("{}")?;
    assert!(ext.prf.is_none());
    Ok(())
}