Webauthn-rs

https://docs.rs/webauthn-rs/latest/webauthn_rs/
Admin
Webauthn-rs is a secure WebAuthn implementation library for Rust server applications that enables...
Tokens:284,772
Snippets:2,508
Trust Score:9.7
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Start attested passkey registration with webauthn-rs

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/struct.Webauthn.html

Rust example for starting an attested passkey registration using `start_attested_passkey_registration`. It creates a user ID, builds an attestation CA list from a device catalog, and enforces platform attachment. The returned `CreationChallengeResponse` must be sent to the user agent, and the `AttestedPasskeyRegistration` state must be stored server-side to prevent replay attacks.

```rust
use webauthn_rs_device_catalog::Data;
// you must store this user's unique id with the account. Alternatively you can
// use an existed UUID source.
let user_unique_id = Uuid::new_v4();

// Create a device catalog reference that contains a list of known high quality authenticators
let device_catalog = Data::all_known_devices();

let attestation_ca_list = (&device_catalog)
    .try_into()
    .expect("Failed to build attestation ca list");

// Initiate a basic registration flow, allowing any attested cryptograhpic authenticator to proceed.
// Hint (but do not enforce) that we prefer this to be a token/key like a yubikey.
// To enforce this you can validate the properties of the returned device aaguid.
let (ccr, skr) = webauthn
    .start_attested_passkey_registration(
        user_unique_id,
        "claire",
        "Claire",
        None,
        attestation_ca_list,
        Some(AuthenticatorAttachment::CrossPlatform),
    )
    .expect("Failed to start registration.");

// Only allow credentials from manufacturers that are trusted and part of the webauthn-rs
// strict "high quality" list.
// Hint (but do not enforce) that we prefer this to be a device like TouchID.
// To enforce this you can validate the attestation ca used along with the returned device aaguid

let device_catalog = Data::strict();

let attestation_ca_list = (&device_catalog)
    .try_into()
    .expect("Failed to build attestation ca list");

let (ccr, skr) = webauthn
    .start_attested_passkey_registration(
        Uuid::new_v4(),
        "claire",
        "Claire",
        None,
        attestation_ca_list,
        Some(AuthenticatorAttachment::Platform),
    )
    .expect("Failed to start registration.");
```

--------------------------------

### Passkey Registration Setup with WebauthnBuilder

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/index.html?search=

Initializes a WebauthnBuilder with a relying party ID and origin, builds the Webauthn instance, and starts a passkey registration flow. Requires the webauthn_rs::prelude module and a valid URL for the origin.

```rust
use webauthn_rs::prelude::*;

let rp_id = "example.com";
let rp_origin = Url::parse("https://idm.example.com")
    .expect("Invalid URL");
let mut builder = WebauthnBuilder::new(rp_id, &rp_origin)
    .expect("Invalid configuration");
let webauthn = builder.build()
    .expect("Invalid configuration");

// Initiate a basic registration flow to enroll a cryptographic authenticator
let (ccr, skr) = webauthn
    .start_passkey_registration(
        Uuid::new_v4(),
        "claire",
        "Claire",
        None,
    )
    .expect("Failed to start registration.");
```

--------------------------------

### Url::options example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Url.html?search=std%3A%3Avec

Gets default ParseOptions and changes the base URL to parse relative URLs. The example shows parsing 'version.json' against a base URL.

```rust
use url::Url;
let options = Url::options();
let api = Url::parse("https://api.example.com")?;
let base_url = options.base_url(Some(&api));
let version_url = base_url.parse("version.json")?;
assert_eq!(version_url.as_str(), "https://api.example.com/version.json");
```

--------------------------------

### as_simd example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Base64UrlSafeData.html?search=

Nightly-only example of as_simd with portable_simd feature. Shows splitting a slice into prefix, middle, and suffix, and a basic SIMD sum function.

```rust
#![feature(portable_simd)]
use core::simd::prelude::*;

let short = &[1, 2, 3];
let (prefix, middle, suffix) = short.as_simd::<4>();
assert_eq!(middle, []); // Not enough elements for anything in the middle

// They might be split in any possible way between prefix and suffix
let it = prefix.iter().chain(suffix).copied();
assert_eq!(it.collect::<Vec<_>>(), vec![1, 2, 3]);

fn basic_simd_sum(x: &[f32]) -> f32 {
    use std::ops::Add;
    let (prefix, middle, suffix) = x.as_simd();
    let sums = f32x4::from_array([
        prefix.iter().copied().sum(),
        0.0,
        0.0,
        suffix.iter().copied().sum(),
    ]);
    let sums = middle.iter().copied().fold(sums, f32x4::add);
    sums.reduce_sum()
}

let numbers: Vec<f32> = (1..101).map(|x| x as _).collect();
assert_eq!(basic_simd_sum(&numbers[1..99]), 4949.0);
```

--------------------------------

### set_query example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Url.html?search=std%3A%3Avec

Demonstrates setting the query string of a URL with `set_query`. The example parses a URL, sets a query, and verifies the serialized string and query value.

```rust
use url::Url;

let mut url = Url::parse("https://example.com/products")?;
assert_eq!(url.as_str(), "https://example.com/products");

url.set_query(Some("page=2"));
assert_eq!(url.as_str(), "https://example.com/products?page=2");
assert_eq!(url.query(), Some("page=2"));
```

--------------------------------

### Get URL path with path()

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Url.html?search=std%3A%3Avec

Shows how to get the percent-encoded path of a URL. For cannot-be-a-base URLs the path is an arbitrary string not starting with '/', otherwise it starts with '/'. The example includes a URL with non-ASCII characters that are percent-encoded.

```rust
use url::{Url, ParseError};

let url = Url::parse("https://example.com/api/versions?page=2")?;
assert_eq!(url.path(), "/api/versions");

let url = Url::parse("https://example.com")?;
assert_eq!(url.path(), "/");

let url = Url::parse("https://example.com/countries/việt nam")?;
assert_eq!(url.path(), "/countries/vi%E1%BB%87t%20nam");
```

--------------------------------

### element_offset basic example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Base64UrlSafeData.html?search=

Basic usage of `element_offset` to get the index of an element reference. Returns `Some(index)` when the reference points to the start of an element.

```rust
let nums: &[u32] = &[1, 7, 1, 1];
let num = &nums[2];

assert_eq!(num, &1);
assert_eq!(nums.element_offset(num), Some(2));
```

--------------------------------

### Start security key registration with start_securitykey_registration

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/struct.Webauthn.html

Shows three ways to call start_securitykey_registration: basic, with a CrossPlatform attachment hint, and with an attestation CA list built from the strict device catalog. The returned CreationChallengeResponse must be sent to the user agent and the SecurityKeyRegistration persisted server-side; finish_securitykey_registration completes the flow.

```rust
// you must store this user's unique id with the account. Alternatelly you can
// use an existed UUID source.
let user_unique_id = Uuid::new_v4();

// Initiate a basic registration flow, allowing any cryptograhpic authenticator to proceed.
let (ccr, skr) = webauthn
    .start_securitykey_registration(
        user_unique_id,
        "claire",
        "Claire",
        None,
        None,
        None,
    )
    .expect("Failed to start registration.");

// Initiate a basic registration flow, hinting that the device is probably roaming (i.e. a usb),
// but it could have any attachement in reality
let (ccr, skr) = webauthn
    .start_securitykey_registration(
        Uuid::new_v4(),
        "claire",
        "Claire",
        None,
        None,
        Some(AuthenticatorAttachment::CrossPlatform),
    )
    .expect("Failed to start registration.");

// Only allow credentials from manufacturers that are trusted and part of the webauthn-rs
// strict "high quality" list.

use webauthn_rs_device_catalog::Data;
let device_catalog = Data::strict();

let attestation_ca_list = (&device_catalog)
    .try_into()
    .expect("Failed to build attestation ca list");

let (ccr, skr) = webauthn
    .start_securitykey_registration(
        Uuid::new_v4(),
        "claire",
        "Claire",
        None,
        Some(attestation_ca_list),
        None,
    )
    .expect("Failed to start registration.");
```

--------------------------------

### Slice get() example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Base64UrlSafeData.html?search=

Shows `get` returning a reference to an element or subslice, or `None` if out of bounds.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

--------------------------------

### start_securitykey_registration

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/struct.Webauthn.html

Documentation for the start_securitykey_registration method, including its signature, parameters, return type, and usage examples.

```APIDOC
## start_securitykey_registration

### Description
Initiates the registration of a new security key for a user. A security key is any cryptographic authenticator acting as a single factor of authentication to supplement a password or some other authentication factor. This method returns a `CreationChallengeResponse` to send to the user agent and a `SecurityKeyRegistration` to persist server-side.

### Method
start_securitykey_registration

### Signature
pub fn start_securitykey_registration(
    &self,
    user_unique_id: Uuid,
    user_name: &str,
    user_display_name: &str,
    exclude_credentials: Option<Vec<CredentialID>>,
    attestation_ca_list: Option<AttestationCaList>,
    ui_hint_authenticator_attachment: Option<AuthenticatorAttachment>,
) -> WebauthnResult<(CreationChallengeResponse, SecurityKeyRegistration)>

### Parameters
- **user_unique_id** (Uuid) - Required - The unique identifier for the user. May be stored in the authenticator.
- **user_name** (&str) - Required - A friendly account name such as "claire@example.com". May be stored in the authenticator.
- **user_display_name** (&str) - Required - The person's chosen way to be identified such as "Claire". May be stored in the authenticator.
- **exclude_credentials** (Option<Vec<CredentialID>>) - Optional - A list of credentials that may not participate in this registration. Should be provided to prevent duplicate credential registrations.
- **attestation_ca_list** (Option<AttestationCaList>) - Optional - A list of Root CA certificates of authenticator manufacturers to trust. Extensions may only be accessed if this is provided.
- **ui_hint_authenticator_attachment** (Option<AuthenticatorAttachment>) - Optional - A hint for the user agent about the expected authenticator attachment.

### Returns
Returns a `WebauthnResult<(CreationChallengeResponse, SecurityKeyRegistration)>`. The `CreationChallengeResponse` must be serialized to JSON and sent to the user agent. The `SecurityKeyRegistration` must be persisted server-side and is paired with the `CreationChallengeResponse`. After the user agent completes the registration, call `finish_securitykey_registration` to complete the registration.

### Example
```rust
// you must store this user's unique id with the account. Alternatelly you can
// use an existed UUID source.
let user_unique_id = Uuid::new_v4();

// Initiate a basic registration flow, allowing any cryptograhpic authenticator to proceed.
let (ccr, skr) = webauthn
    .start_securitykey_registration(
        user_unique_id,
        "claire",
        "Claire",
        None,
        None,
        None,
    )
    .expect("Failed to start registration.");

// Initiate a basic registration flow, hinting that the device is probably roaming (i.e. a usb),
// but it could have any attachement in reality
let (ccr, skr) = webauthn
    .start_securitykey_registration(
        Uuid::new_v4(),
        "claire",
        "Claire",
        None,
        None,
        Some(AuthenticatorAttachment::CrossPlatform),
    )
    .expect("Failed to start registration.");

// Only allow credentials from manufacturers that are trusted and part of the webauthn-rs
// strict "high quality" list.

use webauthn_rs_device_catalog::Data;
let device_catalog = Data::strict();

let attestation_ca_list = (&device_catalog)
    .try_into()
    .expect("Failed to build attestation ca list");

let (ccr, skr) = webauthn
    .start_securitykey_registration(
        Uuid::new_v4(),
        "claire",
        "Claire",
        None,
        Some(attestation_ca_list),
        None,
    )
    .expect("Failed to start registration.");
```
```

--------------------------------

### element_offset unaligned example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Base64UrlSafeData.html?search=

Shows `element_offset` returning `None` when the reference does not point to the start of an element. The example uses `as_flattened` to create a flat slice and then constructs references that may be unaligned.

```rust
let arr: &[[u32; 2]] = &[[0, 1], [2, 3]];
let flat_arr: &[u32] = arr.as_flattened();

let ok_elm: &[u32; 2] = flat_arr[0..2].try_into().unwrap();
let weird_elm: &[u32; 2] = flat_arr[1..3].try_into().unwrap();

assert_eq!(ok_elm, &[0, 1]);
assert_eq!(weird_elm, &[1, 2]);

assert_eq!(arr.element_offset(ok_elm), Some(0)); // Points to element 0
assert_eq!(arr.element_offset(weird_elm), None); // Points between element 0 and 1
```

--------------------------------

### set_path example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Url.html?search=std%3A%3Avec

Shows how to change a URL's path with `set_path`. The example covers setting a path on a base URL, replacing an existing path, and demonstrates that `set_path` percent-encodes spaces but does not double-encode already percent-encoded strings.

```rust
use url::Url;

let mut url = Url::parse("https://example.com")?;
url.set_path("api/comments");
assert_eq!(url.as_str(), "https://example.com/api/comments");
assert_eq!(url.path(), "/api/comments");

let mut url = Url::parse("https://example.com/api")?;
url.set_path("data/report.csv");
assert_eq!(url.as_str(), "https://example.com/data/report.csv");
assert_eq!(url.path(), "/data/report.csv");

// `set_path` percent-encodes the given string if it's not already percent-encoded.
let mut url = Url::parse("https://example.com")?;
url.set_path("api/some comments");
assert_eq!(url.as_str(), "https://example.com/api/some%20comments");
assert_eq!(url.path(), "/api/some%20comments");

// `set_path` will not double percent-encode the string if it's already percent-encoded.
let mut url = Url::parse("https://example.com")?;
url.set_path("api/some%20comments");
assert_eq!(url.as_str(), "https://example.com/api/some%20comments");
assert_eq!(url.path(), "/api/some%20comments");
```

--------------------------------

### Slice len() example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Base64UrlSafeData.html?search=

Shows how to use the `len` method to get the number of elements in a slice.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

--------------------------------

### Start passkey registration with start_passkey_registration

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/struct.Webauthn.html

Initiates a basic passkey registration flow. Requires a user unique ID, user name, display name, and optional excluded credentials. The returned CreationChallengeResponse must be sent to the user agent, and the PasskeyRegistration must be stored server-side to prevent replay attacks.

```rust
// you must store this user's unique id with the account. Alternatelly you can
// use an existed UUID source.
let user_unique_id = Uuid::new_v4();

// Initiate a basic registration flow, allowing any cryptograhpic authenticator to proceed.
let (ccr, skr) = webauthn
    .start_passkey_registration(
        user_unique_id,
        "claire",
        "Claire",
        None, // No other credentials are registered yet.
    )
    .expect("Failed to start registration.");
```

--------------------------------

### rchunks example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Base64UrlSafeData.html?search=

Demonstrates the rchunks method, which returns an iterator over chunks of the slice starting from the end. The example shows a slice of five characters and iterates through chunks of size 2, with the last chunk being a single element.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert_eq!(iter.next().unwrap(), &['l']);
assert!(iter.next().is_none());
```

--------------------------------

### starts_with

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Base64UrlSafeData.html?search=u32+-%3E+bool

Documentation for the `starts_with` method on slices.

```APIDOC
## starts_with

### Description
Returns `true` if `needle` is a prefix of the slice or equal to the slice. Always returns `true` if `needle` is an empty slice.

### Method
Function

### Signature
`pub fn starts_with(&self, needle: &[T]) -> bool where T: PartialEq`

### Parameters
- `needle` (&[T]) - Required - The slice to check as a prefix.

### Return Value
Returns `bool` - `true` if `needle` is a prefix, `false` otherwise.

### Example
```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```
```

--------------------------------

### as_rchunks example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Base64UrlSafeData.html?search=

Demonstrates the as_rchunks method, which splits a slice into N-element arrays starting from the end, with a remainder slice of length less than N. The example uses N=2 and shows the remainder and chunks. Panics if N is zero.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let (remainder, chunks) = slice.as_rchunks();
assert_eq!(remainder, &['l']);
assert_eq!(chunks, &[['o', 'r'], ['e', 'm']]);
```

--------------------------------

### strip_prefix slice method example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Base64UrlSafeData.html?search=

Demonstrates the `strip_prefix` method on slices. It returns `Some` with the subslice after the prefix if the slice starts with the prefix, or `None` otherwise. The example includes cases with empty prefix, full match, and a string slice converted to bytes.

```rust
let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[10, 40, 30]), Some(&[][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);

let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));
```

--------------------------------

### expect example: panic on Err

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/type.WebauthnResult.html?search=u32+-%3E+bool

Shows how to use expect to return the Ok value or panic with a message if Err. The first example panics, the second shows recommended message style.

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.expect("Testing expect"); // panics with `Testing expect: emergency failure`
```

```rust
let path = std::env::var("IMPORTANT_PATH")
    .expect("env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`");
```

--------------------------------

### set_port example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Url.html?search=std%3A%3Avec

Demonstrates setting and clearing a URL's port with `set_port`. The example changes the port to 4096 and then clears it, verifying the serialized URL. Note that default port numbers are not reflected in serialization.

```rust
use url::Url;


let mut url = Url::parse("ssh://example.net:2048/")?;

url.set_port(Some(4096)).map_err(|_| "cannot be base")?;
assert_eq!(url.as_str(), "ssh://example.net:4096/");

url.set_port(None).map_err(|_| "cannot be base")?;
assert_eq!(url.as_str(), "ssh://example.net/");
```

--------------------------------

### rchunks_exact example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Base64UrlSafeData.html?search=

Demonstrates the rchunks_exact method, which returns an iterator over chunks of exactly chunk_size elements starting from the end. The example shows a slice of five characters and iterates through chunks of size 2, then retrieves the remainder using the remainder function.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks_exact(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), &['l']);
```

--------------------------------

### binary_search with partition_point for range

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Base64UrlSafeData.html?search=

Shows how to find the entire range of matching items using `partition_point` instead of an arbitrary match. The example computes the lower and upper bounds for the value 1 and verifies the range. It also demonstrates that for a value not present, the range is empty and `binary_search` returns `Err`.

```rust
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

let low = s.partition_point(|x| x < &1);
assert_eq!(low, 1);
let high = s.partition_point(|x| x <= &1);
assert_eq!(high, 5);
let r = s.binary_search(&1);
assert!((low..high).contains(&r.unwrap()));

assert!(s[..low].iter().all(|&x| x < 1));
assert!(s[low..high].iter().all(|&x| x == 1));
assert!(s[high..].iter().all(|&x| x > 1));

// For something not found, the "range" of equal items is empty
assert_eq!(s.partition_point(|x| x < &11), 9);
assert_eq!(s.partition_point(|x| x <= &11), 9);
assert_eq!(s.binary_search(&11), Err(9));
```

--------------------------------

### iter_mut example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/type.WebauthnResult.html?search=

Shows how to use Result::iter_mut to get a mutable iterator over the possibly contained value, allowing modification of the Ok value.

```rust
let mut x: Result<u32, &str> = Ok(7);
match x.iter_mut().next() {
    Some(v) => *v = 40,
    None => {},
}
assert_eq!(x, Ok(40));

let mut x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter_mut().next(), None);
```

--------------------------------

### binary_search_by_key example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Base64UrlSafeData.html?search=

Demonstrates binary_search_by_key on a slice of pairs sorted by their second elements. Shows Ok and Err results, and a match on a range for a value with multiple matches.

```rust
let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1),
         (1, 2), (2, 3), (4, 5), (5, 8), (3, 13),
         (1, 21), (2, 34), (4, 55)];

assert_eq!(s.binary_search_by_key(&13, |&(a, b)| b),  Ok(9));
assert_eq!(s.binary_search_by_key(&4, |&(a, b)| b),   Err(7));
assert_eq!(s.binary_search_by_key(&100, |&(a, b)| b), Err(13));
let r = s.binary_search_by_key(&1, |&(a, b)| b);
assert!(match r { Ok(1..=4) => true, _ => false, });
```

--------------------------------

### trim_prefix slice method example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Base64UrlSafeData.html?search=

Demonstrates the `trim_prefix` method on slices. It returns the subslice after the prefix if the slice starts with the prefix; otherwise returns the original slice. The example includes cases with empty prefix, full match, and a string slice converted to bytes.

```rust
let v = &[10, 40, 30];

// Prefix present - removes it
assert_eq!(v.trim_prefix(&[10]), &[40, 30][..]);
assert_eq!(v.trim_prefix(&[10, 40]), &[30][..]);
assert_eq!(v.trim_prefix(&[10, 40, 30]), &[][..]);

// Prefix absent - returns original slice
assert_eq!(v.trim_prefix(&[50]), &[10, 40, 30][..]);
assert_eq!(v.trim_prefix(&[10, 50]), &[10, 40, 30][..]);

let prefix : &str = "he";
assert_eq!(b"hello".trim_prefix(prefix.as_bytes()), b"llo".as_ref());
```

--------------------------------

### strip_circumfix slice method example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Base64UrlSafeData.html?search=

Demonstrates the `strip_circumfix` method on slices. It returns `Some` with the subslice after the prefix and before the suffix if the slice starts with the prefix, ends with the suffix, and they don't overlap; otherwise returns `None`. The example includes cases with empty prefix/suffix and overlapping prefix/suffix.

```rust
let v = &[10, 50, 40, 30];
assert_eq!(v.strip_circumfix(&[10], &[30]), Some(&[50, 40][..]));
assert_eq!(v.strip_circumfix(&[10], &[40, 30]), Some(&[50][..]));
assert_eq!(v.strip_circumfix(&[10, 50], &[40, 30]), Some(&[][..]));
assert_eq!(v.strip_circumfix(&[50], &[30]), None);
assert_eq!(v.strip_circumfix(&[10], &[40]), None);
assert_eq!(v.strip_circumfix(&[], &[40, 30]), Some(&[10, 50][..]));
assert_eq!(v.strip_circumfix(&[10, 50], &[]), Some(&[40, 30][..]));
assert_eq!(v.strip_circumfix(&[10, 50, 40], &[50, 40, 30]), None);
```

--------------------------------

### Result::ok example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/type.WebauthnResult.html?search=

Demonstrates `Result::ok` converting a `Result` into an `Option`, returning `Some` for `Ok` and `None` for `Err`.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.ok(), Some(2));

let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.ok(), None);
```

--------------------------------

### iter example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/type.WebauthnResult.html?search=

Shows how to use Result::iter to get an iterator over the possibly contained value, yielding one value if Ok and none if Err.

```rust
let x: Result<u32, &str> = Ok(7);
assert_eq!(x.iter().next(), Some(&7));

let x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter().next(), None);
```

--------------------------------

### start_passkey_registration

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/struct.Webauthn.html

Starts a new passkey registration flow for a user. Returns a challenge response to send to the client and a registration state to persist.

```APIDOC
## start_passkey_registration

### Description
Initiates the registration of a new passkey for a user. Returns a CreationChallengeResponse to send to the user agent and a PasskeyRegistration to persist server-side.

### Method
pub fn start_passkey_registration(
    &self,
    user_unique_id: Uuid,
    user_name: &str,
    user_display_name: &str,
    exclude_credentials: Option<Vec<CredentialID>>,
) -> WebauthnResult<(CreationChallengeResponse, PasskeyRegistration)>

### Parameters
- **user_unique_id** (Uuid) - Required - The unique identifier for the user. May be stored in the authenticator.
- **user_name** (&str) - Required - A friendly account name (e.g., "claire@example.com"). May be stored in the authenticator.
- **user_display_name** (&str) - Required - The person's chosen display name (e.g., "Claire"). May be stored in the authenticator.
- **exclude_credentials** (Option<Vec<CredentialID>>) - Optional - A list of credential IDs to exclude from this registration. Should include credentials already registered to the user.

### Returns
- **WebauthnResult<(CreationChallengeResponse, PasskeyRegistration)>** - A result containing the CreationChallengeResponse (to send to the user agent) and the PasskeyRegistration (to persist server-side).

### Notes
- The PasskeyRegistration MUST be stored server-side to prevent replay attacks.
- After this call, you must call finish_passkey_registration to complete the registration.

```

--------------------------------

### Result::as_mut example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/type.WebauthnResult.html?search=

Demonstrates `Result::as_mut` to get mutable references to the contained values, allowing modification of the `Ok` or `Err` value in place.

```rust
fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);
```

--------------------------------

### Get URL query string with query()

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Url.html?search=std%3A%3Avec

Returns the query string as a percent-encoded ASCII string, or None if there is no query. The example shows a query with non-ASCII characters that are percent-encoded.

```rust
use url::Url;

fn run() -> Result<(), ParseError> {
let url = Url::parse("https://example.com/products?page=2")?;
let query = url.query();
assert_eq!(query, Some("page=2"));

let url = Url::parse("https://example.com/products")?;
let query = url.query();
assert!(query.is_none());

let url = Url::parse("https://example.com/?country=español")?;
let query = url.query();
assert_eq!(query, Some("country=espa%C3%B1ol"));
}
```

--------------------------------

### insert example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Base64UrlSafeData.html?search=

Demonstrates `insert` adding an element at a given index, shifting subsequent elements right. The example inserts at index 1 and then at index 4 (the end).

```rust
let mut vec = vec!['a', 'b', 'c'];
vec.insert(1, 'd');
assert_eq!(vec, ['a', 'd', 'b', 'c']);
vec.insert(4, 'e');
assert_eq!(vec, ['a', 'd', 'b', 'c', 'e']);
```

--------------------------------

### Get URL username

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Url.html?search=std%3A%3Avec

Returns the username as a percent-encoded ASCII string. The example shows a username, an empty username when only a password is present, and an empty username when none is present.

```rust
use url::Url;

let url = Url::parse("ftp://rms@example.com")?;
assert_eq!(url.username(), "rms");

let url = Url::parse("ftp://:secret123@example.com")?;
assert_eq!(url.username(), "");

let url = Url::parse("https://example.com")?;
assert_eq!(url.username(), "");
```

--------------------------------

### Result::as_ref example

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/type.WebauthnResult.html?search=

Demonstrates `Result::as_ref` converting a `Result` into a `Result` with references, leaving the original in place.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

--------------------------------

### start_passkey_authentication

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/struct.Webauthn.html

Begins an authentication of the user given a set of passkeys.

```APIDOC
## start_passkey_authentication

### Description
Begins an authentication of the user given a set of `Passkey`s. Returns a `RequestChallengeResponse` that should be serialized to JSON and sent to the user agent (e.g., a browser). The server must persist the `PasskeyAuthentication` state as it is paired to the `RequestChallengeResponse` and required to complete the authentication.

### Method
Function call

### Signature
`pub fn start_passkey_authentication(&self, creds: &[Passkey]) -> WebauthnResult<(RequestChallengeResponse, PasskeyAuthentication)>`

### Parameters
- **creds** (`&[Passkey]`) - Required - A slice of passkeys associated with the user.

### Returns
- **RequestChallengeResponse** - The challenge response to be sent to the user agent.
- **PasskeyAuthentication** - The authentication state that must be stored server-side.

### Errors
Returns a `WebauthnError` if the operation fails.

### Notes
- WARNING: You MUST store the `PasskeyAuthentication` value server-side. Failure to do so may open you to replay attacks which can significantly weaken the security of this system.
```

--------------------------------

### Get URL scheme

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Url.html?search=std%3A%3Avec

Returns the lower-cased scheme of the URL without the colon delimiter. The example parses a file URL and asserts the scheme is "file".

```rust
use url::Url;

let url = Url::parse("file:///tmp/foo")?;
assert_eq!(url.scheme(), "file");
```

--------------------------------

### iter: Iterate over slice elements

Source: https://docs.rs/webauthn-rs/latest/webauthn_rs/prelude/struct.Base64UrlSafeData.html?search=

Shows how to iterate over a slice using the iter method, yielding all items from start to end. The example asserts each next value and the final None.

```rust
let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);
```
Tokens:
Raw