use super::{
Authority, PreparedRootKey, Principal, TimePolicy, TimeWindow, VerificationLimits, VerifyError,
forest, verify_certificate,
};
use crate::certificate::{
CertificateDecodeLimits, DecodeError, DecodedCanisterSignature, decode_certificate,
};
use ic_certification::LookupResult;
use sha2::{Digest, Sha256};
use spki::{ObjectIdentifier, SubjectPublicKeyInfoRef, der::Decode};
#[derive(Clone, Copy, Debug)]
pub struct CanisterSignatureKey<'a> {
original: &'a [u8],
issuer: Principal,
seed: &'a [u8],
}
impl<'a> CanisterSignatureKey<'a> {
pub fn from_der(bytes: &'a [u8]) -> Result<Self, CanisterSignatureVerifyError> {
use CanisterSignatureVerifyError::InvalidKey;
if !(20..=129).contains(&bytes.len()) {
return Err(InvalidKey);
}
let key = SubjectPublicKeyInfoRef::from_der(bytes).map_err(|_| InvalidKey)?;
if key.algorithm.oid != ObjectIdentifier::new_unwrap("1.3.6.1.4.1.56387.1.2")
|| key.algorithm.parameters.is_some()
{
return Err(InvalidKey);
}
let raw = key.subject_public_key.as_bytes().ok_or(InvalidKey)?;
let (&length, payload) = raw.split_first().ok_or(InvalidKey)?;
let issuer =
Principal::try_from_slice(payload.get(..usize::from(length)).ok_or(InvalidKey)?)
.map_err(|_| InvalidKey)?;
Ok(Self {
original: bytes,
issuer,
seed: &payload[usize::from(length)..],
})
}
#[must_use]
pub const fn as_der(&self) -> &'a [u8] {
self.original
}
#[must_use]
pub const fn issuer(&self) -> Principal {
self.issuer
}
#[must_use]
pub const fn seed(&self) -> &'a [u8] {
self.seed
}
}
#[derive(Clone, Copy, Debug)]
pub struct CanisterSignatureLimits {
pub message_bytes: usize,
pub certificate_bytes: usize,
pub verification: VerificationLimits,
}
#[derive(Debug, thiserror::Error)]
pub enum CanisterSignatureVerifyError {
#[error("invalid canister-signature key")]
InvalidKey,
#[error("canister-signature message exceeds allowance")]
MessageLimit,
#[error("canister-signature certificate requires CBOR tag 55799")]
MissingCertificateTag,
#[error("invalid embedded certificate: {0}")]
Decode(#[from] DecodeError),
#[error("canister-signature certificate or tree refused: {0}")]
Verification(#[from] VerifyError),
#[error("canister-signature witness does not prove the message and seed")]
Witness,
#[error("canister-signature witness is not bound to certified data")]
CertifiedData,
}
#[derive(Debug)]
pub struct AuthenticatedCanisterSignature<'a> {
decoded: DecodedCanisterSignature<'a>,
message: &'a [u8],
key: CanisterSignatureKey<'a>,
root: [u8; 133],
window: TimeWindow,
time_ns: u64,
delegation: Option<(Principal, TimeWindow, u64)>,
}
impl<'a> AuthenticatedCanisterSignature<'a> {
#[must_use]
pub const fn original_bytes(&self) -> &'a [u8] {
self.decoded.original_bytes()
}
#[must_use]
pub const fn message(&self) -> &'a [u8] {
self.message
}
#[must_use]
pub const fn key(&self) -> CanisterSignatureKey<'a> {
self.key
}
#[must_use]
pub const fn root_key_der(&self) -> &[u8; 133] {
&self.root
}
#[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<(Principal, TimeWindow, u64)> {
self.delegation
}
}
pub fn authenticate_canister_signature<'a>(
decoded: DecodedCanisterSignature<'a>,
message: &'a [u8],
key: CanisterSignatureKey<'a>,
root: &PreparedRootKey,
time: TimePolicy,
limits: CanisterSignatureLimits,
) -> Result<AuthenticatedCanisterSignature<'a>, CanisterSignatureVerifyError> {
if message.len() > limits.message_bytes {
return Err(CanisterSignatureVerifyError::MessageLimit);
}
let certificate_bytes = decoded.certificate_bytes();
if certificate_bytes.len() > limits.certificate_bytes {
return Err(DecodeError::InputLimit {
actual: certificate_bytes.len(),
maximum: limits.certificate_bytes,
}
.into());
}
if !certificate_bytes.starts_with(&[0xd9, 0xd9, 0xf7]) {
return Err(CanisterSignatureVerifyError::MissingCertificateTag);
}
let mut verification = limits.verification;
forest(
decoded.unverified_witness().as_ref(),
&mut verification.tree_nodes,
verification.tree_depth,
&mut None,
&mut false,
)?;
let seed_hash: [u8; 32] = Sha256::digest(key.seed).into();
let message_hash: [u8; 32] = Sha256::digest(message).into();
if !matches!(
decoded
.unverified_witness()
.lookup_path([b"sig".as_slice(), &seed_hash, &message_hash]),
LookupResult::Found([])
) {
return Err(CanisterSignatureVerifyError::Witness);
}
let certificate = decode_certificate(
certificate_bytes,
CertificateDecodeLimits {
bytes: limits.certificate_bytes,
},
)?;
let verified = verify_certificate(
certificate.unverified(),
root,
Authority::CanisterSignature(key.issuer),
time,
verification,
)?;
let digest = decoded.unverified_witness().digest();
if !matches!(certificate.unverified().tree.lookup_path([b"canister".as_slice(), key.issuer.as_slice(), b"certified_data"]), LookupResult::Found(value) if value == digest)
{
return Err(CanisterSignatureVerifyError::CertifiedData);
}
Ok(AuthenticatedCanisterSignature {
decoded,
message,
key,
root: *root.as_der(),
window: time.certificate,
time_ns: verified.time_ns,
delegation: verified.delegation,
})
}
#[cfg(test)]
mod tests;