use crate::record::{EpistemicType, Link, LinkType};
use crate::store::RecordSource;
use evidence_request::time::parse_utc;
use rand_core::{OsRng, RngCore};
use serde_json::{json, Map, Value};
use sha2::{Digest, Sha256};
pub const PROFILE_ID: &str = "evidence-interop/0";
pub const MINIMUM_ABSENCE_WINDOW_SECONDS: i64 = 60;
#[derive(Clone, Debug, PartialEq)]
pub struct Entry {
pub record_type: String,
pub epistemic_type: EpistemicType,
pub links: Vec<Link>,
pub statement: Value,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Sealed {
pub record_id: String,
pub committed_at: String,
}
#[derive(Debug, thiserror::Error)]
#[error("seal: {0}")]
pub struct SealError(pub String);
pub trait Book: RecordSource {
fn len(&self) -> u64;
fn now(&self) -> String;
fn seal(&mut self, entry: &Entry) -> Result<Sealed, SealError>;
fn checkpoint(&mut self) -> Result<(), SealError>;
fn is_empty(&self) -> bool {
self.len() == 0
}
}
#[derive(Debug, thiserror::Error)]
pub enum AskError {
#[error("invalid: {0}")]
Invalid(String),
#[error("not found: {0}")]
NotFound(String),
#[error("corrupt: {0}")]
Corrupt(String),
#[error(transparent)]
Seal(#[from] SealError),
}
#[derive(Clone, Debug, PartialEq)]
pub struct AskedRequest {
pub subject: Value,
pub coverage: Value,
pub derivation: Option<String>,
pub deadline: Option<String>,
pub route: Option<String>,
pub nonce: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SentRequest {
pub bytes: Vec<u8>,
pub digest: String,
pub record_id: String,
}
fn sha256_hex(bytes: &[u8]) -> String {
hex::encode(Sha256::digest(bytes))
}
pub fn request(
book: &mut dyn Book,
asked: &AskedRequest,
responder: &str,
) -> Result<SentRequest, AskError> {
let nonce = match asked.nonce.as_deref().filter(|n| !n.is_empty()) {
Some(n) => n.to_string(),
None => {
let mut raw = [0u8; 16];
OsRng.fill_bytes(&mut raw);
hex::encode(raw)
}
};
let mut map = Map::new();
map.insert("subject".into(), asked.subject.clone());
map.insert("coverage".into(), asked.coverage.clone());
if let Some(d) = asked.derivation.as_deref().filter(|d| !d.is_empty()) {
map.insert("derivation".into(), json!(d));
}
if let Some(d) = asked.deadline.as_deref().filter(|d| !d.is_empty()) {
map.insert("deadline".into(), json!(d));
}
if let Some(r) = asked.route.as_deref().filter(|r| !r.is_empty()) {
map.insert("route".into(), json!(r));
}
map.insert("nonce".into(), json!(nonce));
map.insert("profile".into(), json!(PROFILE_ID));
let value = Value::Object(map);
let bytes = evidence_request::jcs::to_string(&value)
.map_err(|e| AskError::Invalid(format!("request: {e}")))?
.into_bytes();
parse_request(&bytes).map_err(|why| AskError::Invalid(format!("request: {why}")))?;
record_request(book, value, bytes, Some(nonce), responder, false)
}
pub fn request_sent(
book: &mut dyn Book,
octets: &[u8],
responder: &str,
) -> Result<SentRequest, AskError> {
let req = crate::respond::read_sent_request(octets).map_err(|reason| {
AskError::Invalid(format!("not a well-formed request ({})", reason.token()))
})?;
let value: Value =
serde_json::from_slice(octets).map_err(|e| AskError::Invalid(format!("request: {e}")))?;
let jcs = evidence_request::jcs::to_string(&value)
.map_err(|e| AskError::Invalid(format!("request: {e}")))?;
if jcs.as_bytes() != octets {
return Err(AskError::Invalid(
"a sent request must be in JCS (RFC 8785), as it was transmitted".into(),
));
}
let nonce = req.nonce.filter(|n| !n.is_empty());
record_request(book, value, octets.to_vec(), nonce, responder, true)
}
fn record_request(
book: &mut dyn Book,
value: Value,
bytes: Vec<u8>,
nonce: Option<String>,
responder: &str,
composed_elsewhere: bool,
) -> Result<SentRequest, AskError> {
for leaf in 0..book.len() {
let Some(nonce) = nonce.as_deref() else {
break;
};
let Some(record) = book.record_at(leaf) else {
continue;
};
let Some(header) = book.header_of(&record) else {
continue;
};
if header.get("record_type").and_then(Value::as_str)
!= Some(crate::record::record_types::REQUEST)
{
continue;
}
if let Ok(prior) = sent_request(book, &record.digest) {
if prior.nonce.as_deref() == Some(nonce) {
return Err(AskError::Invalid(format!(
"nonce already used by request {}",
record.digest
)));
}
}
}
let mut statement = Map::new();
statement.insert("request".into(), value);
if !responder.is_empty() {
statement.insert("responder_ref".into(), json!(responder));
}
if composed_elsewhere {
statement.insert("composed_elsewhere".into(), json!(true));
}
let sealed = book.seal(&Entry {
record_type: crate::record::record_types::REQUEST.into(),
epistemic_type: EpistemicType::ObservedEvent,
links: Vec::new(),
statement: Value::Object(statement),
})?;
Ok(SentRequest {
digest: sha256_hex(&bytes),
bytes,
record_id: sealed.record_id,
})
}
fn parse_request(bytes: &[u8]) -> Result<evidence_request::request::Request, String> {
let req = evidence_request::request::parse_json(bytes).map_err(|e| e.to_string())?;
if !derivation_is_well_formed(&req) {
return Err("derivation is neither a registered token form nor a definition digest".into());
}
Ok(req)
}
pub(crate) fn derivation_is_well_formed(req: &evidence_request::request::Request) -> bool {
use evidence_request::request::Derivation;
match &req.derivation {
Some(Derivation::Token(t)) => derivation_text_is_well_formed(t),
_ => true,
}
}
pub(crate) fn derivation_text_is_well_formed(text: &str) -> bool {
crate::record::is_digest(text)
|| text.split_once('/').is_some_and(|(name, version)| {
!name.is_empty()
&& name
.bytes()
.all(|b| matches!(b, b'a'..=b'z' | b'0'..=b'9' | b'_'))
&& !version.is_empty()
&& version.bytes().all(|b| b.is_ascii_digit())
})
}
struct Sent {
digest: String,
committed_at: String,
deadline: Option<String>,
route: Option<String>,
nonce: Option<String>,
}
fn sent_request(book: &dyn Book, record_id: &str) -> Result<Sent, AskError> {
let not_a_request =
|| AskError::NotFound(format!("{record_id} is not a request this book recorded"));
let record = book.record_by_digest(record_id).ok_or_else(not_a_request)?;
let header = book.header_of(&record).ok_or_else(not_a_request)?;
if header.get("record_type").and_then(Value::as_str)
!= Some(crate::record::record_types::REQUEST)
{
return Err(not_a_request());
}
let committed_at = header
.get("committed_at")
.and_then(Value::as_str)
.ok_or_else(|| {
AskError::Corrupt(format!("request record {record_id} has no committed_at"))
})?
.to_string();
let request = header
.get("statement")
.and_then(|s| s.get("request"))
.ok_or_else(|| AskError::Corrupt(format!("request record {record_id} holds no request")))?;
let bytes = evidence_request::jcs::to_string(request)
.map_err(|e| AskError::Corrupt(format!("request record {record_id}: {e}")))?
.into_bytes();
parse_request(&bytes).map_err(|why| {
AskError::Corrupt(format!(
"request record {record_id} holds no well-formed request: {why}"
))
})?;
let text = |name: &str| {
request
.get(name)
.and_then(Value::as_str)
.map(str::to_string)
};
Ok(Sent {
digest: sha256_hex(&bytes),
committed_at,
deadline: text("deadline"),
route: text("route"),
nonce: text("nonce"),
})
}
fn outcome_recorded(book: &dyn Book, request_record_id: &str) -> bool {
(0..book.len()).any(|leaf| {
let Some(record) = book.record_at(leaf) else {
return false;
};
let Some(header) = book.header_of(&record) else {
return false;
};
let kind = header.get("record_type").and_then(Value::as_str);
matches!(
kind,
Some(crate::record::record_types::RESPONSE)
| Some(crate::record::record_types::RECORDED_ABSENCE)
) && header
.get("links")
.and_then(Value::as_array)
.is_some_and(|links| {
links.iter().any(|l| {
l.get("type").and_then(Value::as_str) == Some(LinkType::Cites.as_str())
&& l.get("target").and_then(Value::as_str) == Some(request_record_id)
})
})
})
}
pub fn record_absence(
book: &mut dyn Book,
request_record_id: &str,
window_end: &str,
route: &str,
) -> Result<Sealed, AskError> {
let sent = sent_request(book, request_record_id)?;
let now = book.now();
let end = parse_utc(window_end).ok_or_else(|| {
AskError::Invalid(format!(
"window end {window_end:?} is not an RFC 3339 UTC time"
))
})?;
let now_t = parse_utc(&now)
.ok_or_else(|| AskError::Corrupt(format!("the book's clock read {now:?}")))?;
if end > now_t {
return Err(AskError::Invalid(
"the waiting window has not closed; the request is pending".into(),
));
}
let asked = parse_utc(&sent.committed_at).ok_or_else(|| {
AskError::Corrupt(format!(
"committed_at of request {request_record_id}: {:?}",
sent.committed_at
))
})?;
if end.seconds < asked.seconds + MINIMUM_ABSENCE_WINDOW_SECONDS
|| (end.seconds == asked.seconds + MINIMUM_ABSENCE_WINDOW_SECONDS
&& end.nanos < asked.nanos)
{
return Err(AskError::Invalid(format!(
"a waiting window must end at least {MINIMUM_ABSENCE_WINDOW_SECONDS}s after the request was recorded"
)));
}
if let Some(deadline) = &sent.deadline {
let deadline = parse_utc(deadline)
.ok_or_else(|| AskError::Corrupt(format!("committed deadline {deadline:?}")))?;
if end < deadline {
return Err(AskError::Invalid(
"the window closes before the request's own deadline".into(),
));
}
}
let route = match &sent.route {
Some(committed) => {
if !route.is_empty() && route != committed {
return Err(AskError::Invalid(format!(
"the request named route {committed:?}, not {route:?}"
)));
}
committed.clone()
}
None => route.to_string(),
};
if outcome_recorded(book, request_record_id) {
return Err(AskError::Invalid(format!(
"an outcome is already recorded for request {}",
sent.digest
)));
}
let mut statement = Map::new();
statement.insert(
"outcome".into(),
json!(crate::record::record_types::RECORDED_ABSENCE),
);
statement.insert("request_digest".into(), json!(sent.digest));
if !route.is_empty() {
statement.insert("route".into(), json!(route));
}
statement.insert(
"window".into(),
json!({"opened": profile_time(&sent.committed_at), "closed": profile_time(window_end)}),
);
statement.insert("recorded_at".into(), json!(profile_time(&now)));
Ok(book.seal(&Entry {
record_type: crate::record::record_types::RECORDED_ABSENCE.into(),
epistemic_type: EpistemicType::ObservedEvent,
links: vec![Link {
link_type: LinkType::Cites,
target: request_record_id.to_string(),
}],
statement: Value::Object(statement),
})?)
}
pub(crate) fn profile_time(timestamp: &str) -> String {
match timestamp.split_once('.') {
Some((seconds, _)) => format!("{seconds}Z"),
None => timestamp.to_string(),
}
}