use heapless::Vec;
use crate::config::Config;
use crate::crypto::SymmetricKey;
use crate::error::{Error, ErrorCode, Result};
use crate::fabric::{CompressedFabricId, operational_group_key};
use crate::im::Status;
use crate::msg::{FabricIndex, GroupId};
use crate::platform::Instant;
pub type KeySetId = u16;
pub const IPK_KEY_SET: KeySetId = 0;
pub const MAX_EPOCH_KEYS: usize = 3;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
pub enum GroupKeySecurityPolicy {
TrustFirst = 0,
CacheAndSync = 1,
}
impl GroupKeySecurityPolicy {
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
pub const fn from_value(value: u8) -> Result<Self> {
Ok(match value {
0 => Self::TrustFirst,
1 => Self::CacheAndSync,
_ => return Err(Error::new(ErrorCode::TlvOutOfRange)),
})
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct EpochKey {
pub key: SymmetricKey,
pub start_time_us: u64,
}
impl EpochKey {
pub const DISABLED: u64 = u64::MAX;
#[must_use]
pub const fn is_enabled(&self) -> bool {
self.start_time_us != Self::DISABLED
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct GroupKeySet {
pub fabric_index: FabricIndex,
pub id: KeySetId,
pub policy: GroupKeySecurityPolicy,
pub epoch_keys: Vec<EpochKey, MAX_EPOCH_KEYS>,
}
impl GroupKeySet {
#[must_use]
pub fn single(
fabric_index: FabricIndex,
id: KeySetId,
policy: GroupKeySecurityPolicy,
key: SymmetricKey,
start_time_us: u64,
) -> Self {
let mut epoch_keys = Vec::new();
let _ = epoch_keys.push(EpochKey { key, start_time_us });
Self {
fabric_index,
id,
policy,
epoch_keys,
}
}
#[must_use]
pub fn current(&self, now: Option<u64>) -> Option<&EpochKey> {
let mut enabled: Vec<&EpochKey, MAX_EPOCH_KEYS> =
self.epoch_keys.iter().filter(|k| k.is_enabled()).collect();
enabled.sort_unstable_by_key(|k| k.start_time_us);
match now {
Some(now) => enabled
.iter()
.rev()
.find(|k| k.start_time_us <= now)
.copied()
.or_else(|| enabled.first().copied()),
None => {
let len = enabled.len();
enabled
.get(len.saturating_sub(2))
.or_else(|| enabled.first())
.copied()
}
}
}
}
#[derive(Debug)]
pub struct GroupKeys<C: Config, const K: usize = 15, const M: usize = 20> {
sets: Vec<GroupKeySet, K>,
map: Vec<(FabricIndex, GroupId, KeySetId), M>,
_config: core::marker::PhantomData<C>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct OperationalKey {
pub key: SymmetricKey,
pub key_set: KeySetId,
pub fabric_index: FabricIndex,
pub policy: GroupKeySecurityPolicy,
pub session_id: u16,
}
impl<C: Config, const K: usize, const M: usize> crate::config::Capacity for GroupKeys<C, K, M> {
const TOTAL: usize = K;
const PER_FABRIC: usize = C::GROUP_KEYS_PER_FABRIC;
}
impl<C: Config, const K: usize, const M: usize> Default for GroupKeys<C, K, M> {
fn default() -> Self {
Self::new()
}
}
impl<C: Config, const K: usize, const M: usize> GroupKeys<C, K, M> {
pub const CHECK: () = {
let () = crate::config::AssertValid::<C>::CHECK;
assert!(
K >= C::GROUP_KEYS_PER_FABRIC * C::FABRICS,
"GroupKeys: Core §2.11.1.2 promises GROUP_KEYS_PER_FABRIC to every fabric, so K \
must be FABRICS × that many"
);
assert!(
M >= C::GROUPS_PER_FABRIC * C::FABRICS,
"GroupKeys: Core §2.11.1.2 promises GROUPS_PER_FABRIC to every fabric, so M must \
be FABRICS × that many"
);
};
#[must_use]
pub fn new() -> Self {
let () = Self::CHECK;
Self {
sets: Vec::new(),
map: Vec::new(),
_config: core::marker::PhantomData,
}
}
#[must_use]
pub const fn max_groups_per_fabric(&self) -> usize {
C::GROUPS_PER_FABRIC
}
#[must_use]
pub const fn max_key_sets_per_fabric(&self) -> usize {
C::GROUP_KEYS_PER_FABRIC
}
#[must_use]
pub fn key_sets(&self) -> &[GroupKeySet] {
&self.sets
}
#[must_use]
pub fn map(&self) -> &[(FabricIndex, GroupId, KeySetId)] {
&self.map
}
pub fn write_key_set(&mut self, set: GroupKeySet) -> core::result::Result<(), Status> {
if set.epoch_keys.is_empty() {
return Err(Status::InvalidCommand);
}
if let Some(existing) = self
.sets
.iter_mut()
.find(|s| s.id == set.id && s.fabric_index == set.fabric_index)
{
*existing = set;
return Ok(());
}
if self.count_sets(set.fabric_index) >= C::GROUP_KEYS_PER_FABRIC {
return Err(Status::ResourceExhausted);
}
self.sets.push(set).map_err(|_| Status::ResourceExhausted)
}
#[must_use]
pub fn key_set(&self, fabric: FabricIndex, id: KeySetId) -> Option<&GroupKeySet> {
self.sets
.iter()
.find(|s| s.id == id && s.fabric_index == fabric)
}
pub fn remove_key_set(
&mut self,
fabric: FabricIndex,
id: KeySetId,
) -> core::result::Result<(), Status> {
if id == IPK_KEY_SET {
return Err(Status::InvalidCommand);
}
if self.key_set(fabric, id).is_none() {
return Err(Status::NotFound);
}
self.sets
.retain(|s| !(s.id == id && s.fabric_index == fabric));
self.map.retain(|(f, _, set)| !(*set == id && *f == fabric));
Ok(())
}
pub fn map_group(
&mut self,
fabric: FabricIndex,
group: GroupId,
key_set: KeySetId,
) -> core::result::Result<(), Status> {
if self.key_set(fabric, key_set).is_none() {
return Err(Status::NotFound);
}
if let Some(entry) = self
.map
.iter_mut()
.find(|(f, g, _)| *f == fabric && *g == group)
{
entry.2 = key_set;
return Ok(());
}
if self.count_groups(fabric) >= C::GROUPS_PER_FABRIC {
return Err(Status::ResourceExhausted);
}
self.map
.push((fabric, group, key_set))
.map_err(|_| Status::ResourceExhausted)
}
pub fn replace_map(
&mut self,
fabric: FabricIndex,
entries: &[(GroupId, KeySetId)],
) -> core::result::Result<(), Status> {
if entries.len() > C::GROUPS_PER_FABRIC {
return Err(Status::ResourceExhausted);
}
for (_, key_set) in entries {
if self.key_set(fabric, *key_set).is_none() {
return Err(Status::NotFound);
}
}
self.map.retain(|(f, _, _)| *f != fabric);
for (group, key_set) in entries {
self.map
.push((fabric, *group, *key_set))
.map_err(|_| Status::ResourceExhausted)?;
}
Ok(())
}
pub fn remove_fabric(&mut self, fabric: FabricIndex) {
self.sets.retain(|s| s.fabric_index != fabric);
self.map.retain(|(f, _, _)| *f != fabric);
}
pub fn sending_key(
&self,
fabric: FabricIndex,
compressed: CompressedFabricId,
group: GroupId,
now: Option<Instant>,
) -> Result<OperationalKey> {
let key_set = self
.map
.iter()
.find(|(f, g, _)| *f == fabric && *g == group)
.map(|(_, _, set)| *set)
.ok_or(Error::new(ErrorCode::NoSession))?;
let set = self
.key_set(fabric, key_set)
.ok_or(Error::new(ErrorCode::NoSession))?;
let epoch = set
.current(now.map(Instant::as_micros))
.ok_or(Error::new(ErrorCode::NoSession))?;
Self::operational(set, epoch, compressed)
}
pub fn receiving_keys<const N: usize>(
&self,
compressed: impl Fn(FabricIndex) -> Option<CompressedFabricId>,
session_id: u16,
) -> Vec<OperationalKey, N> {
let mut out = Vec::new();
for set in &self.sets {
let Some(compressed) = compressed(set.fabric_index) else {
continue;
};
for epoch in set.epoch_keys.iter().filter(|k| k.is_enabled()) {
let Ok(candidate) = Self::operational(set, epoch, compressed) else {
continue;
};
if candidate.session_id == session_id && out.push(candidate).is_err() {
return out;
}
}
}
out
}
fn operational(
set: &GroupKeySet,
epoch: &EpochKey,
compressed: CompressedFabricId,
) -> Result<OperationalKey> {
let key = operational_group_key(&epoch.key, compressed)?;
let session_id = super::session_id(&key)?;
Ok(OperationalKey {
key,
key_set: set.id,
fabric_index: set.fabric_index,
policy: set.policy,
session_id,
})
}
fn count_sets(&self, fabric: FabricIndex) -> usize {
self.sets
.iter()
.filter(|s| s.fabric_index == fabric)
.count()
}
fn count_groups(&self, fabric: FabricIndex) -> usize {
self.map.iter().filter(|(f, _, _)| *f == fabric).count()
}
}
#[cfg(test)]
mod tests {
use super::*;
const F1: FabricIndex = FabricIndex(1);
fn key(byte: u8) -> SymmetricKey {
SymmetricKey::new([byte; 16])
}
fn set_with(times: &[u64]) -> GroupKeySet {
let mut epoch_keys = Vec::new();
for (i, start) in times.iter().enumerate() {
let _ = epoch_keys.push(EpochKey {
key: key(i as u8),
start_time_us: *start,
});
}
GroupKeySet {
fabric_index: F1,
id: 1,
policy: GroupKeySecurityPolicy::TrustFirst,
epoch_keys,
}
}
#[test]
fn the_current_key_is_the_newest_that_has_started() {
let set = set_with(&[100, 200, 300]);
assert_eq!(set.current(Some(250)).unwrap().start_time_us, 200);
assert_eq!(set.current(Some(300)).unwrap().start_time_us, 300);
assert_eq!(set.current(Some(99)).unwrap().start_time_us, 100);
}
#[test]
fn a_node_without_a_clock_uses_the_second_newest() {
let set = set_with(&[100, 200, 300]);
assert_eq!(set.current(None).unwrap().start_time_us, 200);
assert_eq!(
set_with(&[100, 200]).current(None).unwrap().start_time_us,
100
);
assert_eq!(set_with(&[100]).current(None).unwrap().start_time_us, 100);
}
#[test]
fn a_disabled_slot_is_not_a_key() {
let set = set_with(&[100, EpochKey::DISABLED]);
assert_eq!(set.current(Some(u64::MAX)).unwrap().start_time_us, 100);
assert_eq!(set.current(None).unwrap().start_time_us, 100);
}
#[test]
fn keys_out_of_order_still_resolve() {
let set = set_with(&[300, 100, 200]);
assert_eq!(set.current(Some(250)).unwrap().start_time_us, 200);
assert_eq!(set.current(None).unwrap().start_time_us, 200);
}
}