use super::{
super::super::bin::{
Decode, DecodeBuffer, EncDecErr, Encode, EncodeBuffer, EncodeBufferFallible as _,
},
Aaguid, Attestation, AuthenticationExtensionsPrfOutputs, AuthenticatorAttachment,
AuthenticatorExtensionOutputMetadata, AuthenticatorExtensionOutputStaticState, Backup,
ClientExtensionsOutputsMetadata, ClientExtensionsOutputsStaticState, CompressedP256PubKey,
CompressedP384PubKey, CompressedPubKeyOwned, CredentialPropertiesOutput,
CredentialProtectionPolicy, DynamicState, Ed25519PubKey, FourToSixtyThree, Metadata,
MlDsa44PubKey, MlDsa65PubKey, MlDsa87PubKey, ResidentKeyRequirement, RsaPubKey, StaticState,
UncompressedP256PubKey, UncompressedP384PubKey, UncompressedPubKey,
};
use core::{
convert::Infallible,
error::Error,
fmt::{self, Display, Formatter},
};
use p256::{
NistP256,
elliptic_curve::{Curve, common::typenum::ToInt as _},
};
use p384::NistP384;
impl EncodeBuffer for CredentialProtectionPolicy {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
match *self {
Self::None => 0u8,
Self::UserVerificationOptional => 1,
Self::UserVerificationOptionalWithCredentialIdList => 2,
Self::UserVerificationRequired => 3,
}
.encode_into_buffer(buffer);
}
}
impl<'a> DecodeBuffer<'a> for CredentialProtectionPolicy {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
u8::decode_from_buffer(data).and_then(|val| match val {
0 => Ok(Self::None),
1 => Ok(Self::UserVerificationOptional),
2 => Ok(Self::UserVerificationOptionalWithCredentialIdList),
3 => Ok(Self::UserVerificationRequired),
_ => Err(EncDecErr),
})
}
}
impl EncodeBuffer for ResidentKeyRequirement {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
match *self {
Self::Required => 0u8,
Self::Discouraged => 1,
Self::Preferred => 2,
}
.encode_into_buffer(buffer);
}
}
impl<'a> DecodeBuffer<'a> for ResidentKeyRequirement {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
u8::decode_from_buffer(data).and_then(|val| match val {
0 => Ok(Self::Required),
1 => Ok(Self::Discouraged),
2 => Ok(Self::Preferred),
_ => Err(EncDecErr),
})
}
}
impl EncodeBuffer for MlDsa87PubKey<&[u8]> {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
buffer.extend_from_slice(self.0);
}
}
impl<'a> DecodeBuffer<'a> for MlDsa87PubKey<Box<[u8]>> {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
let mut key = vec![0; 2592];
data.split_at_checked(key.len())
.ok_or(EncDecErr)
.map(|(key_slice, rem)| {
*data = rem;
key.copy_from_slice(key_slice);
Self(key.into_boxed_slice())
})
}
}
impl EncodeBuffer for MlDsa65PubKey<&[u8]> {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
buffer.extend_from_slice(self.0);
}
}
impl<'a> DecodeBuffer<'a> for MlDsa65PubKey<Box<[u8]>> {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
let mut key = vec![0; 1952];
data.split_at_checked(key.len())
.ok_or(EncDecErr)
.map(|(key_slice, rem)| {
*data = rem;
key.copy_from_slice(key_slice);
Self(key.into_boxed_slice())
})
}
}
impl EncodeBuffer for MlDsa44PubKey<&[u8]> {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
buffer.extend_from_slice(self.0);
}
}
impl<'a> DecodeBuffer<'a> for MlDsa44PubKey<Box<[u8]>> {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
let mut key = vec![0; 1312];
data.split_at_checked(key.len())
.ok_or(EncDecErr)
.map(|(key_slice, rem)| {
*data = rem;
key.copy_from_slice(key_slice);
Self(key.into_boxed_slice())
})
}
}
impl EncodeBuffer for Ed25519PubKey<&[u8]> {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
buffer.extend_from_slice(self.0);
}
}
impl<'a> DecodeBuffer<'a> for Ed25519PubKey<[u8; ed25519_dalek::PUBLIC_KEY_LENGTH]> {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
<[u8; ed25519_dalek::PUBLIC_KEY_LENGTH]>::decode_from_buffer(data).map(Self)
}
}
impl EncodeBuffer for UncompressedP256PubKey<'_> {
#[expect(clippy::indexing_slicing, reason = "comment justifies its correctness")]
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
const Y_LEN: usize = <NistP256 as Curve>::FieldBytesSize::INT;
const ODD_BYTE_INDEX: usize = Y_LEN - 1;
buffer.extend_from_slice(self.0);
(self.1[ODD_BYTE_INDEX] & 1 == 1).encode_into_buffer(buffer);
}
}
impl<'a> DecodeBuffer<'a> for CompressedP256PubKey<[u8; <NistP256 as Curve>::FieldBytesSize::INT]> {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
<[u8; <NistP256 as Curve>::FieldBytesSize::INT]>::decode_from_buffer(data)
.and_then(|x| bool::decode_from_buffer(data).map(|y_is_odd| Self { x, y_is_odd }))
}
}
impl EncodeBuffer for UncompressedP384PubKey<'_> {
#[expect(clippy::indexing_slicing, reason = "comment justifies its correctness")]
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
const Y_LEN: usize = <NistP384 as Curve>::FieldBytesSize::INT;
const ODD_BYTE_INDEX: usize = Y_LEN - 1;
buffer.extend_from_slice(self.0);
(self.1[ODD_BYTE_INDEX] & 1 == 1).encode_into_buffer(buffer);
}
}
impl<'a> DecodeBuffer<'a> for CompressedP384PubKey<[u8; <NistP384 as Curve>::FieldBytesSize::INT]> {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
let mut x = [0; <NistP384 as Curve>::FieldBytesSize::INT];
data.split_at_checked(x.len())
.ok_or(EncDecErr)
.and_then(|(x_slice, rem)| {
*data = rem;
bool::decode_from_buffer(data).map(|y_is_odd| {
x.copy_from_slice(x_slice);
Self { x, y_is_odd }
})
})
}
}
impl EncodeBuffer for RsaPubKey<&[u8]> {
#[expect(clippy::unreachable, reason = "we want to crash when there is a bug")]
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
self.0
.encode_into_buffer(buffer)
.unwrap_or_else(|_e| unreachable!("there is a bug in [u8]::encode_into_buffer"));
self.1.encode_into_buffer(buffer);
}
}
impl<'a> DecodeBuffer<'a> for RsaPubKey<Box<[u8]>> {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
Box::decode_from_buffer(data).and_then(|n| {
u32::decode_from_buffer(data)
.and_then(|e| Self::try_from((n, e)).map_err(|_e| EncDecErr))
})
}
}
impl EncodeBuffer for UncompressedPubKey<'_> {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
match *self {
Self::MlDsa87(key) => {
4u8.encode_into_buffer(buffer);
key.encode_into_buffer(buffer);
}
Self::MlDsa65(key) => {
5u8.encode_into_buffer(buffer);
key.encode_into_buffer(buffer);
}
Self::MlDsa44(key) => {
6u8.encode_into_buffer(buffer);
key.encode_into_buffer(buffer);
}
Self::Ed25519(key) => {
0u8.encode_into_buffer(buffer);
key.encode_into_buffer(buffer);
}
Self::P256(key) => {
1u8.encode_into_buffer(buffer);
key.encode_into_buffer(buffer);
}
Self::P384(key) => {
2u8.encode_into_buffer(buffer);
key.encode_into_buffer(buffer);
}
Self::Rsa(key) => {
3u8.encode_into_buffer(buffer);
key.encode_into_buffer(buffer);
}
}
}
}
impl<'a> DecodeBuffer<'a> for CompressedPubKeyOwned {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
u8::decode_from_buffer(data).and_then(|val| match val {
0 => Ed25519PubKey::decode_from_buffer(data).map(Self::Ed25519),
1 => CompressedP256PubKey::decode_from_buffer(data).map(Self::P256),
2 => CompressedP384PubKey::decode_from_buffer(data).map(Self::P384),
3 => RsaPubKey::decode_from_buffer(data).map(Self::Rsa),
4 => MlDsa87PubKey::decode_from_buffer(data).map(Self::MlDsa87),
5 => MlDsa65PubKey::decode_from_buffer(data).map(Self::MlDsa65),
6 => MlDsa44PubKey::decode_from_buffer(data).map(Self::MlDsa44),
_ => Err(EncDecErr),
})
}
}
impl EncodeBuffer for AuthenticatorExtensionOutputStaticState {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
self.cred_protect.encode_into_buffer(buffer);
self.hmac_secret.encode_into_buffer(buffer);
}
}
impl<'a> DecodeBuffer<'a> for AuthenticatorExtensionOutputStaticState {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
CredentialProtectionPolicy::decode_from_buffer(data).and_then(|cred_protect| {
Option::decode_from_buffer(data).map(|hmac_secret| Self {
cred_protect,
hmac_secret,
})
})
}
}
impl EncodeBuffer for Attestation {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
match *self {
Self::None => 0u8,
Self::Surrogate => 1,
}
.encode_into_buffer(buffer);
}
}
impl<'a> DecodeBuffer<'a> for Attestation {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
u8::decode_from_buffer(data).and_then(|val| match val {
0 => Ok(Self::None),
1 => Ok(Self::Surrogate),
_ => Err(EncDecErr),
})
}
}
impl EncodeBuffer for Aaguid<'_> {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
buffer.extend_from_slice(self.0);
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct AaguidOwned(pub [u8; super::AAGUID_LEN]);
impl<'a: 'b, 'b> From<&'a AaguidOwned> for Aaguid<'b> {
#[inline]
fn from(value: &'a AaguidOwned) -> Self {
Self(value.0.as_slice())
}
}
impl<'a> DecodeBuffer<'a> for AaguidOwned {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
<[u8; super::AAGUID_LEN]>::decode_from_buffer(data).map(Self)
}
}
impl EncodeBuffer for FourToSixtyThree {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
self.into_u8().encode_into_buffer(buffer);
}
}
impl EncodeBuffer for AuthenticatorExtensionOutputMetadata {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
self.min_pin_length.encode_into_buffer(buffer);
}
}
impl<'a> DecodeBuffer<'a> for FourToSixtyThree {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
u8::decode_from_buffer(data).and_then(|val| Self::from_u8(val).ok_or(EncDecErr))
}
}
impl<'a> DecodeBuffer<'a> for AuthenticatorExtensionOutputMetadata {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
Option::decode_from_buffer(data).map(|min_pin_length| Self { min_pin_length })
}
}
impl EncodeBuffer for CredentialPropertiesOutput {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
self.rk.encode_into_buffer(buffer);
}
}
impl<'a> DecodeBuffer<'a> for CredentialPropertiesOutput {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
Option::decode_from_buffer(data).map(|rk| Self { rk })
}
}
impl EncodeBuffer for AuthenticationExtensionsPrfOutputs {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
self.enabled.encode_into_buffer(buffer);
}
}
impl<'a> DecodeBuffer<'a> for AuthenticationExtensionsPrfOutputs {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
bool::decode_from_buffer(data).map(|enabled| Self { enabled })
}
}
impl EncodeBuffer for ClientExtensionsOutputsMetadata {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
self.cred_props.encode_into_buffer(buffer);
}
}
impl EncodeBuffer for ClientExtensionsOutputsStaticState {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
self.prf.encode_into_buffer(buffer);
}
}
impl<'a> DecodeBuffer<'a> for ClientExtensionsOutputsMetadata {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
Option::decode_from_buffer(data).map(|cred_props| Self { cred_props })
}
}
impl<'a> DecodeBuffer<'a> for ClientExtensionsOutputsStaticState {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
Option::decode_from_buffer(data).map(|prf| Self { prf })
}
}
impl Encode for Metadata<'_> {
type Output<'a>
= Vec<u8>
where
Self: 'a;
type Err = Infallible;
#[inline]
fn encode(&self) -> Result<Self::Output<'_>, Self::Err> {
let mut buffer = Vec::with_capacity(1 + 16 + 1 + 1 + 1);
self.attestation.encode_into_buffer(&mut buffer);
self.aaguid.encode_into_buffer(&mut buffer);
self.extensions.encode_into_buffer(&mut buffer);
self.client_extension_results
.encode_into_buffer(&mut buffer);
self.resident_key.encode_into_buffer(&mut buffer);
Ok(buffer)
}
}
#[derive(Clone, Copy, Debug)]
pub struct MetadataOwned {
pub attestation: Attestation,
pub aaguid: AaguidOwned,
pub extensions: AuthenticatorExtensionOutputMetadata,
pub client_extension_results: ClientExtensionsOutputsMetadata,
pub resident_key: ResidentKeyRequirement,
}
impl<'a: 'b, 'b> From<&'a MetadataOwned> for Metadata<'b> {
#[inline]
fn from(value: &'a MetadataOwned) -> Self {
Self {
attestation: value.attestation,
aaguid: (&value.aaguid).into(),
extensions: value.extensions,
client_extension_results: value.client_extension_results,
resident_key: value.resident_key,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DecodeMetadataOwnedErr {
Attestation,
Aaguid,
Extensions,
ClientExtensionResults,
ResidentKey,
TrailingData,
}
impl Display for DecodeMetadataOwnedErr {
#[inline]
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
f.write_str(match *self {
Self::Attestation => "attestation could not be decoded",
Self::Aaguid => "aaguid could not be decoded",
Self::Extensions => "extensions could not be decoded",
Self::ClientExtensionResults => "client_extension_results could not be decoded",
Self::ResidentKey => "resident_key could not be decoded",
Self::TrailingData => "trailing data existed after decoding MetadataOwned",
})
}
}
impl Error for DecodeMetadataOwnedErr {}
impl Decode for MetadataOwned {
type Input<'a> = &'a [u8];
type Err = DecodeMetadataOwnedErr;
#[inline]
fn decode(mut input: Self::Input<'_>) -> Result<Self, Self::Err> {
Attestation::decode_from_buffer(&mut input)
.map_err(|_e| DecodeMetadataOwnedErr::Attestation)
.and_then(|attestation| {
AaguidOwned::decode_from_buffer(&mut input)
.map_err(|_e| DecodeMetadataOwnedErr::Aaguid)
.and_then(|aaguid| {
AuthenticatorExtensionOutputMetadata::decode_from_buffer(&mut input)
.map_err(|_e| DecodeMetadataOwnedErr::Extensions)
.and_then(|extensions| {
ClientExtensionsOutputsMetadata::decode_from_buffer(&mut input)
.map_err(|_e| DecodeMetadataOwnedErr::ClientExtensionResults)
.and_then(|client_extension_results| {
ResidentKeyRequirement::decode_from_buffer(&mut input)
.map_err(|_e| DecodeMetadataOwnedErr::ResidentKey)
.and_then(|resident_key| {
if input.is_empty() {
Ok(Self {
attestation,
aaguid,
extensions,
client_extension_results,
resident_key,
})
} else {
Err(DecodeMetadataOwnedErr::TrailingData)
}
})
})
})
})
})
}
}
impl Encode for StaticState<UncompressedPubKey<'_>> {
type Output<'a>
= Vec<u8>
where
Self: 'a;
type Err = Infallible;
#[expect(
clippy::arithmetic_side_effects,
reason = "comment justifies its correctness"
)]
#[inline]
fn encode(&self) -> Result<Self::Output<'_>, Self::Err> {
let mut buffer = Vec::with_capacity(
match self.credential_public_key {
UncompressedPubKey::MlDsa87(_) => 2593,
UncompressedPubKey::MlDsa65(_) => 1953,
UncompressedPubKey::MlDsa44(_) => 1313,
UncompressedPubKey::Ed25519(_) => 33,
UncompressedPubKey::P256(_) => 34,
UncompressedPubKey::P384(_) => 50,
UncompressedPubKey::Rsa(key) => 1 + 2 + key.0.len() + 4,
} + 1
+ 1
+ usize::from(self.extensions.hmac_secret.is_some())
+ 1
+ usize::from(self.client_extension_results.prf.is_some()),
);
self.credential_public_key.encode_into_buffer(&mut buffer);
self.extensions.encode_into_buffer(&mut buffer);
self.client_extension_results
.encode_into_buffer(&mut buffer);
Ok(buffer)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DecodeStaticStateErr {
CredentialPublicKey,
Extensions,
ClientExtensionResults,
TrailingData,
}
impl Display for DecodeStaticStateErr {
#[inline]
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
f.write_str(match *self {
Self::CredentialPublicKey => "credential_public_key could not be decoded",
Self::Extensions => "extensions could not be decoded",
Self::ClientExtensionResults => "client_extension_results could not be decoded",
Self::TrailingData => "there was trailing data after decoding a StaticState",
})
}
}
impl Error for DecodeStaticStateErr {}
impl Decode for StaticState<CompressedPubKeyOwned> {
type Input<'a> = &'a [u8];
type Err = DecodeStaticStateErr;
#[inline]
fn decode(mut input: Self::Input<'_>) -> Result<Self, Self::Err> {
CompressedPubKeyOwned::decode_from_buffer(&mut input)
.map_err(|_e| DecodeStaticStateErr::CredentialPublicKey)
.and_then(|credential_public_key| {
AuthenticatorExtensionOutputStaticState::decode_from_buffer(&mut input)
.map_err(|_e| DecodeStaticStateErr::Extensions)
.and_then(|extensions| {
ClientExtensionsOutputsStaticState::decode_from_buffer(&mut input)
.map_err(|_e| DecodeStaticStateErr::ClientExtensionResults)
.and_then(|client_extension_results| {
if input.is_empty() {
Ok(Self {
credential_public_key,
extensions,
client_extension_results,
})
} else {
Err(DecodeStaticStateErr::TrailingData)
}
})
})
})
}
}
impl Encode for DynamicState {
type Output<'a>
= [u8; 7]
where
Self: 'a;
type Err = Infallible;
#[expect(
clippy::little_endian_bytes,
reason = "need cross-platform correctness"
)]
#[inline]
fn encode(&self) -> Result<Self::Output<'_>, Self::Err> {
let mut buffer = [
u8::from(self.user_verified),
match self.backup {
Backup::NotEligible => 0,
Backup::Eligible => 1,
Backup::Exists => 2,
},
0,
0,
0,
0,
match self.authenticator_attachment {
AuthenticatorAttachment::None => 0,
AuthenticatorAttachment::Platform => 1,
AuthenticatorAttachment::CrossPlatform => 2,
},
];
buffer[2..6].copy_from_slice(self.sign_count.to_le_bytes().as_slice());
Ok(buffer)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DecodeDynamicStateErr {
UserVerified,
Backup,
SignCount,
AuthenticatorAttachment,
}
impl Display for DecodeDynamicStateErr {
#[inline]
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
f.write_str(match *self {
Self::UserVerified => "user_verified could not be decoded",
Self::Backup => "backup could not be decoded",
Self::SignCount => "sign_count could not be decoded",
Self::AuthenticatorAttachment => "authenticator_attachment could not be decoded",
})
}
}
impl Error for DecodeDynamicStateErr {}
impl Decode for DynamicState {
type Input<'a> = [u8; 7];
type Err = DecodeDynamicStateErr;
#[expect(
clippy::panic_in_result_fn,
reason = "want to crash when there is a bug"
)]
#[inline]
fn decode(input: Self::Input<'_>) -> Result<Self, Self::Err> {
let mut buffer = input.as_slice();
bool::decode_from_buffer(&mut buffer)
.map_err(|_e| DecodeDynamicStateErr::UserVerified)
.and_then(|user_verified| {
Backup::decode_from_buffer(&mut buffer)
.map_err(|_e| DecodeDynamicStateErr::Backup)
.and_then(|backup| {
u32::decode_from_buffer(&mut buffer)
.map_err(|_e| DecodeDynamicStateErr::SignCount)
.and_then(|sign_count| {
AuthenticatorAttachment::decode_from_buffer(&mut buffer)
.map_err(|_e| DecodeDynamicStateErr::AuthenticatorAttachment)
.map(|authenticator_attachment| {
assert!(
buffer.is_empty(),
"there is a bug in DynamicState::decode"
);
Self {
user_verified,
backup,
sign_count,
authenticator_attachment,
}
})
})
})
})
}
}