Skip to main content

rigspark_runtime/
catalog_update.rs

1use ed25519_dalek::{Signature, Signer, SigningKey, VerifyingKey};
2use rigspark_core::catalog::Catalog;
3use serde::{Deserialize, Serialize};
4use sha2::{Digest, Sha256};
5use thiserror::Error;
6use time::{OffsetDateTime, format_description::well_known::Rfc3339};
7
8mod store;
9mod transport;
10pub use store::{CatalogStatus, CatalogStore, LoadedCatalog};
11pub use transport::{CATALOG_URL, CatalogTransport, OfficialCatalogTransport};
12
13pub const MAX_ARTIFACT_BYTES: usize = 16 * 1024 * 1024;
14
15#[derive(Debug, Error)]
16pub enum CatalogUpdateError {
17    #[error("catalog artifact exceeds the size limit")]
18    TooLarge,
19    #[error("catalog signature or public key is invalid")]
20    Signature,
21    #[error("invalid catalog artifact: {0}")]
22    Invalid(&'static str),
23    #[error("catalog updates are unavailable: production signing key is not provisioned")]
24    NotConfigured,
25    #[error("catalog storage operation failed")]
26    Storage(#[from] std::io::Error),
27    #[error("catalog update is older than the installed snapshot or reuses its revision")]
28    Rollback,
29    #[error("another catalog update is in progress")]
30    Busy,
31    #[error("catalog download failed")]
32    Download,
33}
34
35#[derive(Clone, Deserialize, Serialize)]
36#[serde(deny_unknown_fields)]
37pub struct SignedCatalog {
38    pub payload: String,
39    pub signature: String,
40}
41
42#[derive(Deserialize, Serialize)]
43#[serde(rename_all = "camelCase", deny_unknown_fields)]
44pub struct CatalogPayload {
45    pub format_version: u8,
46    pub revision: u64,
47    pub published_at: String,
48    pub catalog: String,
49}
50
51pub struct VerifiedCatalog {
52    pub revision: u64,
53    pub published_at: String,
54    pub digest: String,
55    pub catalog: Catalog,
56    pub raw: String,
57}
58
59pub fn decode_hex<const SIZE: usize>(raw: &str) -> Result<[u8; SIZE], CatalogUpdateError> {
60    if raw.len() != SIZE * 2 || !raw.bytes().all(|byte| byte.is_ascii_hexdigit()) {
61        return Err(CatalogUpdateError::Signature);
62    }
63    let mut result = [0; SIZE];
64    for (index, byte) in result.iter_mut().enumerate() {
65        *byte = u8::from_str_radix(&raw[index * 2..index * 2 + 2], 16)
66            .map_err(|_| CatalogUpdateError::Signature)?;
67    }
68    Ok(result)
69}
70
71pub fn verify(bytes: &[u8], key: &[u8; 32]) -> Result<VerifiedCatalog, CatalogUpdateError> {
72    if bytes.len() > MAX_ARTIFACT_BYTES {
73        return Err(CatalogUpdateError::TooLarge);
74    }
75    let envelope: SignedCatalog = serde_json::from_slice(bytes)
76        .map_err(|_| CatalogUpdateError::Invalid("signed envelope"))?;
77    let key = VerifyingKey::from_bytes(key).map_err(|_| CatalogUpdateError::Signature)?;
78    let signature = Signature::from_bytes(&decode_hex(&envelope.signature)?);
79    key.verify_strict(envelope.payload.as_bytes(), &signature)
80        .map_err(|_| CatalogUpdateError::Signature)?;
81    let payload: CatalogPayload = serde_json::from_str(&envelope.payload)
82        .map_err(|_| CatalogUpdateError::Invalid("payload"))?;
83    if payload.format_version != 1 || payload.revision == 0 {
84        return Err(CatalogUpdateError::Invalid(
85            "unsupported format or revision",
86        ));
87    }
88    let published = OffsetDateTime::parse(&payload.published_at, &Rfc3339)
89        .map_err(|_| CatalogUpdateError::Invalid("publication date"))?;
90    let catalog = Catalog::parse(&payload.catalog)
91        .map_err(|_| CatalogUpdateError::Invalid("catalog schema or metadata"))?;
92    let generated = OffsetDateTime::parse(&catalog.generated_at, &Rfc3339)
93        .map_err(|_| CatalogUpdateError::Invalid("generation date"))?;
94    if catalog.models.is_empty() || generated > published || catalog.has_local() {
95        return Err(CatalogUpdateError::Invalid(
96            "empty catalog or inconsistent dates",
97        ));
98    }
99    Ok(VerifiedCatalog {
100        revision: payload.revision,
101        published_at: payload.published_at,
102        digest: format!("{:x}", Sha256::digest(envelope.payload.as_bytes())),
103        catalog,
104        raw: payload.catalog,
105    })
106}
107
108pub fn sign_catalog(
109    payload: CatalogPayload,
110    seed: &[u8; 32],
111    public_key: &[u8; 32],
112) -> Result<Vec<u8>, CatalogUpdateError> {
113    let signing_key = SigningKey::from_bytes(seed);
114    if signing_key.verifying_key().to_bytes() != *public_key {
115        return Err(CatalogUpdateError::Signature);
116    }
117    if payload.catalog.len() > MAX_ARTIFACT_BYTES {
118        return Err(CatalogUpdateError::TooLarge);
119    }
120    let payload =
121        serde_json::to_string(&payload).map_err(|_| CatalogUpdateError::Invalid("payload"))?;
122    let signature = signing_key
123        .sign(payload.as_bytes())
124        .to_bytes()
125        .iter()
126        .map(|byte| format!("{byte:02x}"))
127        .collect();
128    let bytes = serde_json::to_vec(&SignedCatalog { payload, signature })
129        .map_err(|_| CatalogUpdateError::Invalid("envelope"))?;
130    verify(&bytes, public_key)?;
131    Ok(bytes)
132}