rigspark_runtime/
catalog_update.rs1use 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 {
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}