use super::{
Authority, DecodedCertificate, PreparedRootKey, Principal, TimePolicy, TimeWindow,
VerificationLimits, VerifyError, verify_certificate,
};
#[derive(Debug)]
pub struct AuthenticatedSubnetTime<'a> {
source: Source<'a>,
root_der: [u8; 133],
subnet: Principal,
time_ns: u64,
window: TimeWindow,
delegation: Option<(TimeWindow, u64)>,
}
impl<'a> AuthenticatedSubnetTime<'a> {
#[must_use]
pub const fn original_bytes(&self) -> Option<&'a [u8]> {
match self.source {
Source::Encoded(bytes) => Some(bytes),
Source::Parsed(_) => None,
}
}
#[must_use]
pub const fn certificate(&self) -> Option<&'a ic_certification::Certificate> {
match self.source {
Source::Parsed(value) => Some(value),
Source::Encoded(_) => None,
}
}
#[must_use]
pub const fn root_key_der(&self) -> &[u8; 133] {
&self.root_der
}
#[must_use]
pub const fn subnet(&self) -> Principal {
self.subnet
}
#[must_use]
pub const fn time_ns(&self) -> u64 {
self.time_ns
}
#[must_use]
pub const fn time_window(&self) -> TimeWindow {
self.window
}
#[must_use]
pub const fn delegation(&self) -> Option<(TimeWindow, u64)> {
self.delegation
}
}
pub fn authenticate_subnet_time<'a>(
decoded: DecodedCertificate<'a>,
root: &PreparedRootKey,
requested_subnet: Principal,
trusted_root_subnet: Option<Principal>,
time: TimePolicy,
limits: VerificationLimits,
) -> Result<AuthenticatedSubnetTime<'a>, VerifyError> {
let verified = verify_certificate(
&decoded.certificate,
root,
Authority::Subnet {
requested: requested_subnet,
root_subnet: trusted_root_subnet,
},
time,
limits,
)?;
let original = decoded.original_bytes();
drop(decoded);
Ok(AuthenticatedSubnetTime {
source: Source::Encoded(original),
root_der: *root.as_der(),
subnet: requested_subnet,
time_ns: verified.time_ns,
window: time.certificate,
delegation: verified.delegation.map(|(_, window, time)| (window, time)),
})
}
#[derive(Debug)]
enum Source<'a> {
Encoded(&'a [u8]),
Parsed(&'a ic_certification::Certificate),
}
pub fn authenticate_subnet_time_from_certificate<'a>(
certificate: &'a ic_certification::Certificate,
root: &PreparedRootKey,
requested_subnet: Principal,
trusted_root_subnet: Option<Principal>,
time: TimePolicy,
limits: VerificationLimits,
) -> Result<AuthenticatedSubnetTime<'a>, VerifyError> {
let verified = verify_certificate(
certificate,
root,
Authority::Subnet {
requested: requested_subnet,
root_subnet: trusted_root_subnet,
},
time,
limits,
)?;
Ok(AuthenticatedSubnetTime {
source: Source::Parsed(certificate),
root_der: *root.as_der(),
subnet: requested_subnet,
time_ns: verified.time_ns,
window: time.certificate,
delegation: verified.delegation.map(|(_, window, time)| (window, time)),
})
}