passly/crates/ctap2-proto/src/authenticator/device.rs

use crate::authenticator::client_pin::AuthProtocolVersion;
use crate::authenticator::Transport;
use crate::extensions;
use fido_common::credential::public_key;
use fido_common::{attestation, registry};
use std::collections::{BTreeMap, BTreeSet};
use std::num::NonZeroUsize;
use std::usize;

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

/// A usize with a minimum value of N
#[derive(Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct UsizeN<const N: usize>(bounded_integer::BoundedUsize<N, { usize::MAX }>);

/// > data type byte string and identifying the authenticator model, i.e.
/// > identical values mean that they refer to the same authenticator model and
/// > different values mean they refer to different authenticator models.
pub type Aaguid = [u8; 16];

#[derive(Debug, Hash, PartialEq, Eq, Clone, Copy, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum Version {
    #[cfg_attr(feature = "serde", serde(rename = "FIDO_2_1"))]
    Fido2_1,
    #[cfg_attr(feature = "serde", serde(rename = "FIDO_2_0"))]
    Fido2_0,
    #[cfg_attr(feature = "serde", serde(rename = "FIDO_2_1_PRE"))]
    Fido2_1Preview,
    #[cfg_attr(feature = "serde", serde(rename = "U2F_V2"))]
    U2fV2,
}

/// > The certifications member provides a hint to the platform with additional
/// > information about certifications that the authenticator has received.
/// > Certification programs may revoke certification of specific devices at any
/// > time. Relying partys are responsible for validating attestations and
/// > `AAGUID` via appropriate methods. Platforms may alter their behaviour
/// > based on these hints such as selecting a PIN protocol or `credProtect`
/// > level.
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum Certification {
    /// > The [FIPS140-2] Cryptographic-Module-Validation-Program overall
    /// > certification level.
    FipsCryptoValidation2(FipsCryptoValidation2Level),
    FipsCryptoValidation3(FipsCryptoValidation3Level),
    FipsPhysicalCryptoValidation2(FipsPhysicalCryptoValidation2Level),
    FipsPhysicalCryptoValidation3(FipsPhysicalCryptoValidation3Level),
    CommonCriteria(CommonCriterialLevel),
    Fido(FidoLevel),
}

#[repr(usize)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum FipsCryptoValidation2Level {
    Level1 = 1,
    Level2 = 2,
    Level3 = 3,
    Level4 = 4,
}

#[repr(usize)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum FipsCryptoValidation3Level {
    Level1 = 1,
    Level2 = 2,
    Level3 = 3,
    Level4 = 4,
}

#[repr(usize)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum FipsPhysicalCryptoValidation2Level {
    Level1 = 1,
    Level2 = 2,
    Level3 = 3,
    Level4 = 4,
}

#[repr(usize)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum FipsPhysicalCryptoValidation3Level {
    Level1 = 1,
    Level2 = 2,
    Level3 = 3,
    Level4 = 4,
}

/// > Common Criteria Evaluation Assurance Level [CC1V3-1R5]. This is a integer
/// > from 1 to 7. The intermediate-plus levels are not represented.
#[repr(usize)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum CommonCriterialLevel {
    EAL1 = 1,
    EAL2 = 2,
    EAL3 = 3,
    EAL4 = 4,
    EAL5 = 5,
    EAL6 = 6,
    EAL7 = 7,
}

/// > FIDO Alliance certification level. This is an integer from 1 to 6. The
/// > numbered levels are mapped to the odd numbers, with the plus levels mapped
/// > to the even numbers e.g., level 3+ is mapped to 6.
#[repr(usize)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum FidoLevel {
    L1 = 1,
    L1Plus = 2,
    L2 = 3,
    L2Plus = 4,
    L3 = 5,
    L3Plus = 6,
}

/// These options describe properties of a CTAP device.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum OptionId {
    /// > Indicates that the device is attached to the client and therefore
    /// > can’t be removed and used on another client.
    #[cfg_attr(feature = "serde", serde(rename = "plat"))]
    PlatformDevice,
    /// > Specifies whether this authenticator can create discoverable
    /// > credentials, and therefore can satisfy `authenticatorGetAssertion`
    /// > requests with the `allowList` parameter omitted.
    #[cfg_attr(feature = "serde", serde(rename = "rk"))]
    DiscoverableCredentials,
    /// > ClientPIN feature support:
    /// > If present and set to true, it indicates that the device is capable of
    /// > accepting a PIN from the client and PIN has been set.
    /// >
    /// > If present and set to false, it indicates that the device is capable
    /// > of accepting a PIN from the client and PIN has not been set yet.
    /// >
    /// > If absent, it indicates that the device is not capable of accepting a
    /// > PIN from the client.
    #[cfg_attr(feature = "serde", serde(rename = "clientPin"))]
    ClientPin,
    /// > Indicates that the device is capable of testing user presence.
    #[cfg_attr(feature = "serde", serde(rename = "up"))]
    UserPresence,
    /// > Indicates that the authenticator supports a built-in user verification
    /// > method. For example, devices with UI, biometrics fall into this
    /// > category.
    /// >
    /// > If present and set to true, it indicates that the device is capable of
    /// > built-in user verification and its user verification feature is
    /// > presently configured.
    /// >
    /// > If present and set to false, it indicates that the authenticator is
    /// > capable of built-in user verification and its user verification
    /// > feature is not presently configured. For example, an authenticator
    /// > featuring a built-in biometric user verification feature that is not
    /// > presently configured will return this "uv" option id set to false.
    /// >
    /// > If absent, it indicates that the authenticator does not have a
    /// > built-in user verification capability.
    /// >
    /// > A device that can only do Client PIN will not return the "uv" option
    /// > id.
    /// >
    /// > If a device is capable of both built-in user verification and Client
    /// > PIN, the authenticator will return both the "uv" and the "clientPin"
    /// > option ids.
    #[cfg_attr(feature = "serde", serde(rename = "uv"))]
    UserVerification,
    #[cfg_attr(feature = "serde", serde(rename = "pinUvAuthToken"))]
    PinUvAuthToken,
    /// > If this noMcGaPermissionsWithClientPin is:
    /// > - present and set to true: A `pinUvAuthToken` obtained via
    /// > `getPinUvAuthTokenUsingPinWithPermissions` (or `getPinToken`) cannot
    /// > be used for `authenticatorMakeCredential` or
    /// > `authenticatorGetAssertion` commands, because it will lack the
    /// > necessary `mc` and `ga` permissions. In this situation, platforms
    /// > SHOULD NOT attempt to use `getPinUvAuthTokenUsingPinWithPermissions`
    /// > if using `getPinUvAuthTokenUsingUvWithPermissions` fails.
    /// >
    /// > - present and set to false, or absent: A `pinUvAuthToken` obtained via
    /// > `getPinUvAuthTokenUsingPinWithPermissions` (or `getPinToken`) can be
    /// > used for `authenticatorMakeCredential` or `authenticatorGetAssertion`
    /// > commands.
    /// >
    /// > Note: `noMcGaPermissionsWithClientPin` MUST only be present if the
    /// > `clientPin` option ID is present.
    #[cfg_attr(feature = "serde", serde(rename = "noMcGaPermissionsWithClientPin"))]
    NoMcGaPermissionsWithClientPin,
    #[cfg_attr(feature = "serde", serde(rename = "largeBlobs"))]
    LargeBlobs,
    #[cfg_attr(feature = "serde", serde(rename = "ep"))]
    EnterpriseAttestation,
    #[cfg_attr(feature = "serde", serde(rename = "bioEnroll"))]
    BiometricEnroll,
    #[cfg_attr(feature = "serde", serde(rename = "userVerificationMgmtPreview"))]
    UvManagementPreview,
    #[cfg_attr(feature = "serde", serde(rename = "uvBioEnroll"))]
    UvBiometricEnroll,
    #[cfg_attr(feature = "serde", serde(rename = "authnrCfg"))]
    AuthenticatorConfig,
    #[cfg_attr(feature = "serde", serde(rename = "uvAcfg"))]
    UvAuthenticatorConfig,
    #[cfg_attr(feature = "serde", serde(rename = "credMgmt"))]
    CredentialManagement,
    #[cfg_attr(feature = "serde", serde(rename = "credentialMgmtPreview"))]
    CredentialManagementPreview,
    #[cfg_attr(feature = "serde", serde(rename = "setMinPINLength"))]
    SetMinPinLength,
    #[cfg_attr(feature = "serde", serde(rename = "makeCredUvNotRqd"))]
    MakeCredentialUvNotRequired,
    #[cfg_attr(feature = "serde", serde(rename = "alwaysUv"))]
    AlwaysRequireUv,
}

/// > Using this method, platforms can request that the authenticator report a
/// > list of its supported protocol versions and extensions, its AAGUID, and
/// > other aspects of its overall capabilities. Platforms should use this
/// > information to tailor their command parameters choices.
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Debug)]
pub struct Info {
    /// > List of supported CTAP versions.
    #[cfg_attr(feature = "serde", serde(rename = 0x01))]
    pub versions: BTreeSet<Version>,
    /// > List of supported extensions.
    #[cfg_attr(feature = "serde", serde(rename = 0x02))]
    pub extensions: Option<BTreeSet<extensions::Identifier>>,
    /// > The claimed AAGUID.
    #[cfg_attr(feature = "serde", serde(rename = 0x03))]
    pub aaguid: Aaguid,
    /// > List of supported options.
    #[cfg_attr(feature = "serde", serde(rename = 0x04))]
    pub options: Option<BTreeMap<OptionId, bool>>,
    /// > Maximum message size supported by the authenticator.
    #[cfg_attr(feature = "serde", serde(rename = 0x05))]
    pub max_message_size: Option<usize>,
    /// > List of supported PIN/UV auth protocols in order of decreasing
    /// > authenticator preference. MUST NOT contain duplicate values...
    // Cannot be empty if present
    #[cfg_attr(feature = "serde", serde(rename = 0x06))]
    pub pin_uv_auth_protocols: Option<Vec<AuthProtocolVersion>>,
    /// > Maximum number of credentials supported in credentialID list at a time
    /// > by the authenticator.
    #[cfg_attr(feature = "serde", serde(rename = 0x07))]
    pub max_credential_count_in_list: Option<NonZeroUsize>,
    /// > Maximum Credential ID Length supported by the authenticator.
    #[cfg_attr(feature = "serde", serde(rename = 0x08))]
    pub max_credential_id_length: Option<NonZeroUsize>,
    /// > List of supported transports.
    #[cfg_attr(feature = "serde", serde(rename = 0x09))]
    pub transports: Option<BTreeSet<Transport>>,
    /// > List of supported algorithms for credential generation... The array is
    /// > ordered from most preferred to least preferred and MUST NOT include
    /// > duplicate entries...
    #[cfg_attr(feature = "serde", serde(rename = 0x0A))]
    // Cannot be empty if present
    pub algorithms: Option<Vec<public_key::Parameters>>,
    /// > The maximum size, in bytes, of the serialized large-blob array that
    /// > this authenticator can store. If the `authenticatorLargeBlobs` command
    /// > is supported, this MUST be specified. Otherwise it MUST NOT be.
    #[cfg_attr(feature = "serde", serde(rename = 0x0B))]
    pub max_serialized_large_blob_array_size: Option<UsizeN<1024>>,
    /// > If this member is:
    /// > - present and set to true: `getPinToken` and
    /// > `getPinUvAuthTokenUsingPinWithPermissions` will return errors until
    /// > after a successful PIN Change.
    /// > - present and set to false, or absent: no PIN Change is required.
    #[cfg_attr(feature = "serde", serde(rename = 0x0C))]
    pub force_pin_change: Option<bool>,
    /// > This specifies the current minimum PIN length, in Unicode code points,
    /// > the authenticator enforces for ClientPIN. This is applicable for
    /// > ClientPIN only: the minPINLength member MUST be absent if the
    /// > clientPin option ID is absent; it MUST be present if the authenticator
    /// > supports authenticatorClientPIN.
    #[cfg_attr(feature = "serde", serde(rename = 0x0D))]
    pub min_pin_length: Option<usize>,
    /// > Indicates the firmware version of the authenticator model identified
    /// > by AAGUID.
    #[cfg_attr(feature = "serde", serde(rename = 0x0E))]
    pub firmware_version: Option<usize>,
    /// > Maximum credBlob length in bytes supported by the authenticator. Must
    /// > be present if, and only if, credBlob is included in the supported
    /// > extensions list.
    #[cfg_attr(feature = "serde", serde(rename = 0x0F))]
    pub max_cred_blob_length: Option<UsizeN<32>>,
    /// > This specifies the max number of RP IDs that authenticator can set via
    /// > `setMinPINLength` subcommand. This is in addition to pre-configured
    /// > list authenticator may have. If the authenticator does not support
    /// > adding additional RP IDs, its value is 0. This MUST ONLY be present
    /// > if, and only if, the authenticator supports the `setMinPINLength`
    /// > subcommand.
    #[cfg_attr(feature = "serde", serde(rename = 0x10))]
    pub max_rpids_for_set_min_pin_length: Option<usize>,
    /// > This specifies the preferred number of invocations of the
    /// > `getPinUvAuthTokenUsingUvWithPermissions` subCommand the platform may
    /// > attempt before falling back to the
    /// > `getPinUvAuthTokenUsingPinWithPermissions` subCommand or displaying an
    /// > error.
    #[cfg_attr(feature = "serde", serde(rename = 0x11))]
    pub preferred_platform_uv_attempts: Option<NonZeroUsize>,
    /// > This specifies the user verification modality supported by the
    /// > authenticator via `authenticatorClientPIN`'s
    /// > `getPinUvAuthTokenUsingUvWithPermissions` subcommand. This is a hint
    /// > to help the platform construct user dialogs. If `clientPin`
    /// > is supported it MUST NOT be included in the bit-flags, as `clientPIN`
    /// > is not a built-in user verification method.
    #[cfg_attr(feature = "serde", serde(rename = 0x12))]
    pub uv_modality: Option<BTreeSet<registry::UserVerify>>,
    /// > This specifies a list of authenticator certifications.
    #[cfg_attr(feature = "serde", serde(rename = 0x13))]
    pub certifications: Option<BTreeSet<Certification>>,
    /// > If this member is present it indicates the estimated number of
    /// > additional discoverable credentials that can be stored. If this value
    /// > is zero then platforms SHOULD create non-discoverable credentials if
    /// > possible.
    /// >
    /// > This estimate SHOULD be based on the assumption that all future
    /// > discoverable credentials will have maximally-sized fields and SHOULD
    /// > be zero whenever an attempt to create a discoverable credential may
    /// > fail due to lack of space, even if it’s possible that some specific
    /// > request might succeed. For example, a specific request might include
    /// > fields that are smaller than the maximum possible size and thus
    /// > succeed, but this value should be zero if a request with maximum-sized
    /// > fields would fail. Also, a specific request might have an rp.id and
    /// > user.id that match an existing discoverable credential and thus
    /// > overwrite it, but this value should be set assuming that will not
    /// > happen.
    #[cfg_attr(feature = "serde", serde(rename = 0x14))]
    pub remaining_discoverable_credentials: Option<usize>,
    /// > If present the authenticator supports the `authenticatorConfig`
    /// > `vendorPrototype` subcommand, and its value is a list of
    /// > `authenticatorConfig` `vendorCommandId` values supported, which MAY be
    /// > empty.
    #[cfg_attr(feature = "serde", serde(rename = 0x15))]
    pub vendor_prototype_config_commands: Option<BTreeSet<usize>>,
    /// > List of supported attestation formats.
    #[cfg_attr(feature = "serde", serde(rename = 0x16))]
    pub attestation_formats: Option<BTreeSet<attestation::FormatIdentifier>>,
    /// > If present the number of internal User Verification operations since
    /// > the last pin entry including all failed attempts.
    #[cfg_attr(feature = "serde", serde(rename = 0x17))]
    pub uv_count_since_last_pin_entry: Option<usize>,
    /// > If present the authenticator requires a 10 second touch for reset.
    #[cfg_attr(feature = "serde", serde(rename = 0x18))]
    pub long_touch_for_reset: Option<bool>,
}