pub mod access_rights;
pub mod agreement;
pub mod gost3410;
pub mod hls;
pub mod signature;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SecuritySuite {
Suite0,
Suite1,
Suite2,
}
impl SecuritySuite {
pub fn id(&self) -> u8 {
match self {
SecuritySuite::Suite0 => 0,
SecuritySuite::Suite1 => 1,
SecuritySuite::Suite2 => 2,
}
}
pub fn from_id(id: u8) -> Option<SecuritySuite> {
match id {
0 => Some(SecuritySuite::Suite0),
1 => Some(SecuritySuite::Suite1),
2 => Some(SecuritySuite::Suite2),
_ => None,
}
}
pub fn name(&self) -> &'static str {
match self {
SecuritySuite::Suite0 => "AES-GCM-128",
SecuritySuite::Suite1 => "ECDH-ECDSA-AES-GCM-128-SHA-256",
SecuritySuite::Suite2 => "ECDH-ECDSA-AES-GCM-256-SHA-384",
}
}
pub fn aes_key_len(&self) -> usize {
match self {
SecuritySuite::Suite0 | SecuritySuite::Suite1 => 16,
SecuritySuite::Suite2 => 32,
}
}
pub fn has_public_key(&self) -> bool {
!matches!(self, SecuritySuite::Suite0)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SecurityPolicy {
None,
Authentication,
Encryption,
AuthenticationEncryption,
}
impl SecurityPolicy {
pub fn security_control_bits(&self) -> u8 {
match self {
SecurityPolicy::None => 0x00,
SecurityPolicy::Authentication => 0x10,
SecurityPolicy::Encryption => 0x20,
SecurityPolicy::AuthenticationEncryption => 0x30,
}
}
pub fn from_security_control(sc: u8) -> SecurityPolicy {
match (sc & 0x10 != 0, sc & 0x20 != 0) {
(false, false) => SecurityPolicy::None,
(true, false) => SecurityPolicy::Authentication,
(false, true) => SecurityPolicy::Encryption,
(true, true) => SecurityPolicy::AuthenticationEncryption,
}
}
pub fn security_control_byte(&self, suite: SecuritySuite) -> u8 {
self.security_control_bits() | (suite.id() & 0x0F)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum AuthMechanism {
None,
Lls,
HlsManufacturer,
HlsMd5,
HlsSha1,
HlsGmac,
HlsSha256,
HlsEcdsa,
HlsGostCmac,
HlsGostStreebog,
HlsGostSignature,
}
impl AuthMechanism {
pub fn id(&self) -> u8 {
match self {
AuthMechanism::None => 0,
AuthMechanism::Lls => 1,
AuthMechanism::HlsManufacturer => 2,
AuthMechanism::HlsMd5 => 3,
AuthMechanism::HlsSha1 => 4,
AuthMechanism::HlsGmac => 5,
AuthMechanism::HlsSha256 => 6,
AuthMechanism::HlsEcdsa => 7,
AuthMechanism::HlsGostCmac => 8,
AuthMechanism::HlsGostStreebog => 9,
AuthMechanism::HlsGostSignature => 10,
}
}
pub fn from_id(id: u8) -> Option<AuthMechanism> {
Some(match id {
0 => AuthMechanism::None,
1 => AuthMechanism::Lls,
2 => AuthMechanism::HlsManufacturer,
3 => AuthMechanism::HlsMd5,
4 => AuthMechanism::HlsSha1,
5 => AuthMechanism::HlsGmac,
6 => AuthMechanism::HlsSha256,
7 => AuthMechanism::HlsEcdsa,
8 => AuthMechanism::HlsGostCmac,
9 => AuthMechanism::HlsGostStreebog,
10 => AuthMechanism::HlsGostSignature,
_ => return None,
})
}
pub fn oid(&self) -> [u8; 7] {
[0x60, 0x85, 0x74, 0x05, 0x08, 0x02, self.id()]
}
pub fn is_hls(&self) -> bool {
self.id() >= 2
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn security_suite_ids_and_key_lengths() {
assert_eq!(SecuritySuite::Suite0.id(), 0);
assert_eq!(SecuritySuite::Suite2.id(), 2);
assert_eq!(SecuritySuite::from_id(1), Some(SecuritySuite::Suite1));
assert_eq!(SecuritySuite::from_id(3), None);
assert_eq!(SecuritySuite::Suite1.aes_key_len(), 16);
assert_eq!(SecuritySuite::Suite2.aes_key_len(), 32);
assert!(!SecuritySuite::Suite0.has_public_key());
assert!(SecuritySuite::Suite2.has_public_key());
}
#[test]
fn security_policy_maps_to_control_byte() {
assert_eq!(SecurityPolicy::None.security_control_bits(), 0x00);
assert_eq!(SecurityPolicy::Authentication.security_control_bits(), 0x10);
assert_eq!(SecurityPolicy::Encryption.security_control_bits(), 0x20);
assert_eq!(SecurityPolicy::AuthenticationEncryption.security_control_bits(), 0x30);
assert_eq!(SecurityPolicy::AuthenticationEncryption.security_control_byte(SecuritySuite::Suite2), 0x32);
assert_eq!(SecurityPolicy::from_security_control(0x30), SecurityPolicy::AuthenticationEncryption);
assert_eq!(SecurityPolicy::from_security_control(0x10), SecurityPolicy::Authentication);
}
#[test]
fn all_mechanisms_round_trip_and_have_oids() {
for id in 0..=10u8 {
let m = AuthMechanism::from_id(id).unwrap();
assert_eq!(m.id(), id);
let oid = m.oid();
assert_eq!(&oid[..6], &[0x60, 0x85, 0x74, 0x05, 0x08, 0x02]);
assert_eq!(oid[6], id);
}
assert_eq!(AuthMechanism::from_id(11), None);
assert!(AuthMechanism::HlsGostStreebog.is_hls());
assert!(!AuthMechanism::Lls.is_hls());
}
}