#![doc = include_str!("../README.md")]
#![forbid(unsafe_code)]
#![warn(missing_docs)]
pub mod ckdf;
pub mod crypto;
pub mod drbg;
pub mod dsk;
pub mod kex;
pub mod provisioning;
pub mod qr;
pub mod s0;
pub mod s2;
use std::fmt;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
pub enum SecurityClass {
S0Legacy,
S2Unauthenticated,
S2Authenticated,
S2AccessControl,
}
impl SecurityClass {
pub const HIGHEST_FIRST: [SecurityClass; 4] = [
SecurityClass::S2AccessControl,
SecurityClass::S2Authenticated,
SecurityClass::S2Unauthenticated,
SecurityClass::S0Legacy,
];
pub const fn key_bit(self) -> u8 {
match self {
SecurityClass::S2Unauthenticated => 0x01,
SecurityClass::S2Authenticated => 0x02,
SecurityClass::S2AccessControl => 0x04,
SecurityClass::S0Legacy => 0x80,
}
}
pub const fn from_key_bit(bit: u8) -> Option<SecurityClass> {
match bit {
0x01 => Some(SecurityClass::S2Unauthenticated),
0x02 => Some(SecurityClass::S2Authenticated),
0x04 => Some(SecurityClass::S2AccessControl),
0x80 => Some(SecurityClass::S0Legacy),
_ => None,
}
}
pub fn from_key_bits(bits: u8) -> Vec<SecurityClass> {
Self::HIGHEST_FIRST
.into_iter()
.filter(|c| bits & c.key_bit() != 0)
.collect()
}
pub fn to_key_bits(classes: &[SecurityClass]) -> u8 {
classes.iter().fold(0, |acc, c| acc | c.key_bit())
}
pub const fn needs_pin(self) -> bool {
matches!(
self,
SecurityClass::S2Authenticated | SecurityClass::S2AccessControl
)
}
pub const fn is_s2(self) -> bool {
!matches!(self, SecurityClass::S0Legacy)
}
pub const fn name(self) -> &'static str {
match self {
SecurityClass::S0Legacy => "s0_legacy",
SecurityClass::S2Unauthenticated => "s2_unauthenticated",
SecurityClass::S2Authenticated => "s2_authenticated",
SecurityClass::S2AccessControl => "s2_access_control",
}
}
}
impl fmt::Display for SecurityClass {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.name())
}
}
pub type NetworkKey = [u8; 16];
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum Error {
#[error("malformed frame: {0}")]
Malformed(&'static str),
#[error("no nonce established with the peer")]
NoSpan,
#[error("no valid nonce from the peer")]
NoNonce,
#[error("decryption failed")]
DecryptFailed,
#[error("duplicate frame")]
Duplicate,
#[error("no key for {0}")]
NoKey(SecurityClass),
#[error("unsupported critical extension {0:#04x}")]
UnsupportedExtension(u8),
#[error("invalid {0}")]
Invalid(&'static str),
#[error("random number source failed")]
Random,
}
pub fn random_fill(buf: &mut [u8]) -> Result<(), Error> {
getrandom::fill(buf).map_err(|_| Error::Random)
}
pub fn random_bytes<const N: usize>() -> Result<[u8; N], Error> {
let mut b = [0u8; N];
random_fill(&mut b)?;
Ok(b)
}