rigspark-runtime 3.1.1

Hardware detection, backend adapters, lifecycle, memory and harness runtime for rigspark.
Documentation
use ed25519_dalek::{Signature, Signer, SigningKey, VerifyingKey};
use rigspark_core::catalog::Catalog;
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use thiserror::Error;
use time::{OffsetDateTime, format_description::well_known::Rfc3339};

mod store;
mod transport;
pub use store::{CatalogStatus, CatalogStore, LoadedCatalog};
pub use transport::{CATALOG_URL, CatalogTransport, OfficialCatalogTransport};

pub const MAX_ARTIFACT_BYTES: usize = 16 * 1024 * 1024;

#[derive(Debug, Error)]
pub enum CatalogUpdateError {
    #[error("catalog artifact exceeds the size limit")]
    TooLarge,
    #[error("catalog signature or public key is invalid")]
    Signature,
    #[error("invalid catalog artifact: {0}")]
    Invalid(&'static str),
    #[error("catalog updates are unavailable: production signing key is not provisioned")]
    NotConfigured,
    #[error("catalog storage operation failed")]
    Storage(#[from] std::io::Error),
    #[error("catalog update is older than the installed snapshot or reuses its revision")]
    Rollback,
    #[error("another catalog update is in progress")]
    Busy,
    #[error("catalog download failed")]
    Download,
}

#[derive(Clone, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct SignedCatalog {
    pub payload: String,
    pub signature: String,
}

#[derive(Deserialize, Serialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct CatalogPayload {
    pub format_version: u8,
    pub revision: u64,
    pub published_at: String,
    pub catalog: String,
}

pub struct VerifiedCatalog {
    pub revision: u64,
    pub published_at: String,
    pub digest: String,
    pub catalog: Catalog,
    pub raw: String,
}

pub fn decode_hex<const SIZE: usize>(raw: &str) -> Result<[u8; SIZE], CatalogUpdateError> {
    if raw.len() != SIZE * 2 || !raw.bytes().all(|byte| byte.is_ascii_hexdigit()) {
        return Err(CatalogUpdateError::Signature);
    }
    let mut result = [0; SIZE];
    for (index, byte) in result.iter_mut().enumerate() {
        *byte = u8::from_str_radix(&raw[index * 2..index * 2 + 2], 16)
            .map_err(|_| CatalogUpdateError::Signature)?;
    }
    Ok(result)
}

pub fn verify(bytes: &[u8], key: &[u8; 32]) -> Result<VerifiedCatalog, CatalogUpdateError> {
    if bytes.len() > MAX_ARTIFACT_BYTES {
        return Err(CatalogUpdateError::TooLarge);
    }
    let envelope: SignedCatalog = serde_json::from_slice(bytes)
        .map_err(|_| CatalogUpdateError::Invalid("signed envelope"))?;
    let key = VerifyingKey::from_bytes(key).map_err(|_| CatalogUpdateError::Signature)?;
    let signature = Signature::from_bytes(&decode_hex(&envelope.signature)?);
    key.verify_strict(envelope.payload.as_bytes(), &signature)
        .map_err(|_| CatalogUpdateError::Signature)?;
    let payload: CatalogPayload = serde_json::from_str(&envelope.payload)
        .map_err(|_| CatalogUpdateError::Invalid("payload"))?;
    if payload.format_version != 1 || payload.revision == 0 {
        return Err(CatalogUpdateError::Invalid(
            "unsupported format or revision",
        ));
    }
    let published = OffsetDateTime::parse(&payload.published_at, &Rfc3339)
        .map_err(|_| CatalogUpdateError::Invalid("publication date"))?;
    let catalog = Catalog::parse(&payload.catalog)
        .map_err(|_| CatalogUpdateError::Invalid("catalog schema or metadata"))?;
    let generated = OffsetDateTime::parse(&catalog.generated_at, &Rfc3339)
        .map_err(|_| CatalogUpdateError::Invalid("generation date"))?;
    if catalog.models.is_empty() || generated > published || catalog.has_local() {
        return Err(CatalogUpdateError::Invalid(
            "empty catalog or inconsistent dates",
        ));
    }
    Ok(VerifiedCatalog {
        revision: payload.revision,
        published_at: payload.published_at,
        digest: format!("{:x}", Sha256::digest(envelope.payload.as_bytes())),
        catalog,
        raw: payload.catalog,
    })
}

pub fn sign_catalog(
    payload: CatalogPayload,
    seed: &[u8; 32],
    public_key: &[u8; 32],
) -> Result<Vec<u8>, CatalogUpdateError> {
    let signing_key = SigningKey::from_bytes(seed);
    if signing_key.verifying_key().to_bytes() != *public_key {
        return Err(CatalogUpdateError::Signature);
    }
    if payload.catalog.len() > MAX_ARTIFACT_BYTES {
        return Err(CatalogUpdateError::TooLarge);
    }
    let payload =
        serde_json::to_string(&payload).map_err(|_| CatalogUpdateError::Invalid("payload"))?;
    let signature = signing_key
        .sign(payload.as_bytes())
        .to_bytes()
        .iter()
        .map(|byte| format!("{byte:02x}"))
        .collect();
    let bytes = serde_json::to_vec(&SignedCatalog { payload, signature })
        .map_err(|_| CatalogUpdateError::Invalid("envelope"))?;
    verify(&bytes, public_key)?;
    Ok(bytes)
}