use super::{
EnvelopeContent, Principal, QueryResponse, ReadClient, ReadError, SubnetObservation,
TimePolicy, authenticate_certificate,
};
use crate::ed25519::{Signature, VerifyingKey};
use std::collections::BTreeSet;
impl ReadClient {
pub async fn query(
&self,
canister: Principal,
method: &str,
args: &[u8],
expiry: u64,
time: TimePolicy,
) -> Result<Vec<u8>, ReadError> {
if args
.len()
.checked_add(method.len())
.is_none_or(|n| n > self.config.message_bytes)
{
return Err(ReadError::ByteLimit);
}
let content = EnvelopeContent::Query {
sender: Principal::anonymous()
.to_string()
.parse()
.map_err(|_| ReadError::Packet)?,
canister_id: canister
.to_string()
.parse()
.map_err(|_| ReadError::Packet)?,
ingress_expiry: expiry,
method_name: method.to_owned(),
arg: args.to_vec(),
nonce: None,
sender_info: None,
};
let request_id =
ic_transport_types::to_request_id(&content).map_err(|_| ReadError::Packet)?;
let bytes = self
.post(&format!("api/v3/canister/{canister}/query"), &content)
.await?;
let response: QueryResponse =
serde_cbor::from_slice(&bytes).map_err(|_| ReadError::Packet)?;
let certificate = self
.state("canister", canister, vec![vec![b"time".to_vec()]], expiry)
.await?;
let evidence = authenticate_certificate(
self.decode(&certificate)?,
&self.config.root,
canister,
time,
self.config.verification,
)?;
let subnet = evidence
.delegation()
.map_or(self.config.root_subnet, |(id, _, _)| id);
let nodes = self.read_subnet(subnet, expiry, time).await?;
admit_response(response, request_id, &nodes, time.certificate)
}
}
fn admit_response(
response: QueryResponse,
request_id: ic_transport_types::RequestId,
nodes: &SubnetObservation,
time: crate::certificate::TimeWindow,
) -> Result<Vec<u8>, ReadError> {
let minimum = time
.reference_ns
.checked_sub(time.max_age_ns)
.ok_or(ReadError::QueryTime)?;
let maximum = time
.reference_ns
.checked_add(time.max_future_skew_ns)
.ok_or(ReadError::QueryTime)?;
let signatures = response.signatures();
if signatures.is_empty() || signatures.len() > nodes.node_keys.len() {
return Err(ReadError::QuerySignature);
}
let mut seen = BTreeSet::new();
for signature in signatures {
if signature.timestamp < minimum || signature.timestamp > maximum {
return Err(ReadError::QueryTime);
}
if !seen.insert(signature.identity.as_slice()) {
return Err(ReadError::QuerySignature);
}
let bytes = nodes
.node_keys
.get(signature.identity.as_slice())
.ok_or(ReadError::QuerySignature)?;
const PREFIX: &[u8] = b"\x30\x2a\x30\x05\x06\x03\x2b\x65\x70\x03\x21\x00";
let raw: &[u8; 32] = bytes
.strip_prefix(PREFIX)
.and_then(|b| b.try_into().ok())
.ok_or(ReadError::QuerySignature)?;
let key = VerifyingKey::from_bytes(raw).map_err(|_| ReadError::QuerySignature)?;
if key.is_weak() {
return Err(ReadError::QuerySignature);
}
let sig =
Signature::from_slice(&signature.signature).map_err(|_| ReadError::QuerySignature)?;
key.verify_strict(&response.signable(request_id, signature.timestamp), &sig)
.map_err(|_| ReadError::QuerySignature)?;
}
match response {
QueryResponse::Replied { reply, .. } => Ok(reply.arg),
QueryResponse::Rejected { reject, .. } => Err(ReadError::Rejected {
code: reject.reject_code as u64,
message: reject.reject_message,
error_code: reject.error_code,
}),
}
}
#[cfg(all(test, feature = "certificate-construction"))]
mod tests;