use super::*;
use crate::certification::{
cbor::{encode_certificate_untagged, encode_hash_tree},
empty, labeled, leaf,
};
#[cfg(feature = "certification-verify")]
#[test]
fn historical_replay_does_not_change_live_freshness() {
use crate::certification::historical::{self, Limits, TimePolicy, TimeWindow};
let raw = include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/tests/fixtures/historical-mainnet-sharded.hex"
));
let bytes: Vec<_> = raw
.trim()
.as_bytes()
.as_chunks::<2>()
.0
.iter()
.map(|pair| u8::from_str_radix(std::str::from_utf8(pair).unwrap(), 16).unwrap())
.collect();
let canister = Principal::from_text("ivg37-qiaaa-aaaab-aaaga-cai").unwrap();
let exact = |reference_ns| TimeWindow {
reference_ns,
max_age_ns: 0,
max_future_skew_ns: 0,
};
let evidence = historical::authenticate_certificate_at(
&bytes,
crate::canister_sig_creation::IC_ROOT_PK_DER,
canister,
TimePolicy {
certificate: exact(1_763_796_896_688_941_908),
delegation: exact(1_763_796_681_781_793_898),
},
Limits {
certificate_bytes: bytes.len(),
delegation_bytes: bytes.len(),
tree_nodes: 1024,
tree_depth: 64,
canister_ranges: 16,
},
)
.unwrap();
assert_eq!(evidence.time_ns, 1_763_796_896_688_941_908);
let agent = Agent::builder()
.with_url("https://icp-api.io")
.build()
.unwrap();
assert!(matches!(
authenticate_certificate(&agent, canister, &bytes, bytes.len()),
Err(EvidenceError::Authentication(source)) if matches!(*source,AgentError::CertificateOutdated(_))
));
}
#[test]
fn witness_matching_requires_the_exact_leaf_and_canister() {
let canister = Principal::from_slice(&[1, 2, 3]);
let witness = leaf(vec![9]);
let certificate = Certificate {
tree: labeled(
b"canister".to_vec(),
labeled(
canister.as_slice().to_vec(),
labeled(b"certified_data".to_vec(), leaf(witness.digest().to_vec())),
),
),
signature: vec![],
delegation: None,
};
verify_witness(&certificate, canister, &witness).unwrap();
assert!(matches!(
verify_witness(&certificate, Principal::anonymous(), &witness),
Err(EvidenceError::WitnessMismatch)
));
assert!(matches!(
verify_witness(&certificate, canister, &leaf(vec![8])),
Err(EvidenceError::WitnessMismatch)
));
let missing = Certificate {
tree: empty(),
..certificate
};
assert!(matches!(
verify_witness(&missing, canister, &witness),
Err(EvidenceError::WitnessMismatch)
));
}
#[test]
fn admission_precedes_authentication_and_unsigned_pairs_never_authenticate() {
let agent = Agent::builder()
.with_url("https://icp-api.io")
.build()
.unwrap();
let canister = Principal::anonymous();
assert!(matches!(
authenticate_hash_tree(&agent, canister, &[0], &[0], 1),
Err(EvidenceError::Budget)
));
assert!(matches!(
authenticate_hash_tree(&agent, canister, &[0], &[0], 2),
Err(EvidenceError::Decode(_))
));
let certificate = Certificate {
tree: empty(),
signature: vec![],
delegation: None,
};
let bytes = encode_certificate_untagged(&certificate, 1024).unwrap();
let witness = encode_hash_tree(&empty(), 1024).unwrap();
assert!(matches!(
authenticate_hash_tree(&agent, canister, &bytes, &witness, 2048),
Err(EvidenceError::Authentication(_))
));
let mut trailing = bytes;
trailing.push(0);
assert!(matches!(
authenticate_hash_tree(&agent, canister, &trailing, &witness, 2048),
Err(EvidenceError::Decode(DecodeError::TrailingData))
));
}
#[cfg(feature = "bls")]
#[test]
fn signed_evidence_uses_the_selected_root_and_preserves_witness_admission() {
let key = crate::bls::PrivateKey::deserialize(&[1; 32]).unwrap();
let mut der = vec![
48, 129, 130, 48, 29, 6, 13, 43, 6, 1, 4, 1, 130, 220, 124, 5, 3, 1, 2, 1, 6, 12, 43, 6, 1,
4, 1, 130, 220, 124, 5, 3, 2, 1, 3, 97, 0,
];
der.extend_from_slice(&key.public_key().serialize());
let agent = Agent::builder()
.with_url("https://icp-api.io")
.build()
.unwrap();
agent.set_root_key(der);
let canister = Principal::from_slice(&[1, 2, 3]);
let witness = leaf(vec![7]);
let mut now = u64::try_from(
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos(),
)
.unwrap();
let mut time = Vec::new();
loop {
let byte = (now & 127) as u8;
now >>= 7;
time.push(if now == 0 { byte } else { byte | 128 });
if now == 0 {
break;
}
}
let tree = crate::certification::fork(
labeled(
b"canister".to_vec(),
labeled(
canister.as_slice().to_vec(),
labeled(b"certified_data".to_vec(), leaf(witness.digest().to_vec())),
),
),
labeled(b"time".to_vec(), leaf(time)),
);
let mut message = vec![13];
message.extend_from_slice(b"ic-state-root");
message.extend_from_slice(&tree.digest());
let certificate = Certificate {
tree,
signature: key.sign(&message).serialize().to_vec(),
delegation: None,
};
let bytes = encode_certificate_untagged(&certificate, 4096).unwrap();
assert_eq!(
authenticate_certificate(&agent, canister, &bytes, bytes.len()).unwrap(),
certificate
);
let encoded = encode_hash_tree(&witness, 4096).unwrap();
let exact = bytes.len() + encoded.len();
assert_eq!(
authenticate_hash_tree(&agent, canister, &bytes, &encoded, exact).unwrap(),
witness
);
assert!(matches!(
authenticate_hash_tree(&agent, canister, &bytes, &encoded, exact - 1),
Err(EvidenceError::Budget)
));
assert!(matches!(
authenticate_hash_tree(&agent, Principal::anonymous(), &bytes, &encoded, exact),
Err(EvidenceError::WitnessMismatch)
));
let other = Agent::builder()
.with_url("https://icp-api.io")
.build()
.unwrap();
assert!(matches!(
authenticate_hash_tree(&other, canister, &bytes, &encoded, exact),
Err(EvidenceError::Authentication(_))
));
let mut trailing = encoded;
trailing.push(0);
assert!(matches!(
authenticate_hash_tree(&agent, canister, &bytes, &trailing, exact + 1),
Err(EvidenceError::Decode(DecodeError::TrailingData))
));
let mut stale = certificate;
stale.tree = labeled(b"time".to_vec(), leaf(vec![0]));
let tampered = encode_certificate_untagged(&stale, 4096).unwrap();
assert!(matches!(
authenticate_certificate(&agent, canister, &tampered, tampered.len()),
Err(EvidenceError::Authentication(_))
));
let mut message = vec![13];
message.extend_from_slice(b"ic-state-root");
message.extend_from_slice(&stale.tree.digest());
stale.signature = key.sign(&message).serialize().to_vec();
let bytes = encode_certificate_untagged(&stale, 4096).unwrap();
assert!(matches!(
authenticate_certificate(&agent, canister, &bytes, bytes.len()),
Err(EvidenceError::Authentication(source))
if matches!(*source, AgentError::CertificateOutdated(_))
));
}
#[test]
fn witness_rejects_unknown_and_nonleaf_commitments() {
let canister = Principal::anonymous();
let witness = empty();
for tree in [
crate::certification::pruned([1; 32]),
labeled(
b"canister".to_vec(),
labeled(
canister.as_slice().to_vec(),
labeled(
b"certified_data".to_vec(),
labeled(b"extra".to_vec(), leaf(witness.digest().to_vec())),
),
),
),
] {
let certificate = Certificate {
tree,
signature: vec![],
delegation: None,
};
assert!(matches!(
verify_witness(&certificate, canister, &witness),
Err(EvidenceError::WitnessMismatch)
));
}
}