#[cfg(feature = "certificate-authentication")]
mod authentication;
mod wire;
#[cfg(feature = "certificate-authentication")]
pub use authentication::{
AuthenticatedCertificate, AuthenticatedSubnetTime, PreparedRootKey, TimePolicy, TimeWindow,
VerificationLimits, VerifyError, authenticate_certificate, authenticate_direct_certificate,
authenticate_subnet_time, authenticate_subnet_time_from_certificate,
};
#[derive(Clone, Copy, Debug)]
pub struct CertificateDecodeLimits {
pub bytes: usize,
}
#[derive(Debug, thiserror::Error)]
pub enum DecodeError {
#[error("certificate input has {actual} bytes, exceeding {maximum}")]
InputLimit {
actual: usize,
maximum: usize,
},
#[error("invalid certificate encoding: {0}")]
InvalidEncoding(#[source] serde_cbor::Error),
}
#[derive(Debug)]
pub struct DecodedCertificate<'a> {
original: &'a [u8],
certificate: ic_certification::Certificate,
}
impl<'a> DecodedCertificate<'a> {
#[must_use]
pub const fn original_bytes(&self) -> &'a [u8] {
self.original
}
#[must_use]
pub const fn unverified(&self) -> &ic_certification::Certificate {
&self.certificate
}
}
pub fn decode_certificate(
bytes: &[u8],
limits: CertificateDecodeLimits,
) -> Result<DecodedCertificate<'_>, DecodeError> {
if bytes.len() > limits.bytes {
return Err(DecodeError::InputLimit {
actual: bytes.len(),
maximum: limits.bytes,
});
}
let certificate = wire::decode(bytes).map_err(DecodeError::InvalidEncoding)?;
Ok(DecodedCertificate {
original: bytes,
certificate,
})
}
#[cfg(test)]
mod tests;
#[cfg(feature = "canister-signature-decode")]
mod canister_signature;
#[cfg(feature = "canister-signature-decode")]
pub use canister_signature::{
CanisterSignatureDecodeError, DecodedCanisterSignature, decode_canister_signature,
};
#[cfg(feature = "canister-signature-authentication")]
pub use authentication::{
AuthenticatedCanisterSignature, CanisterSignatureKey, CanisterSignatureLimits,
CanisterSignatureVerifyError, authenticate_canister_signature,
};