create-sia-app 0.1.1

package/template/rust/sia-sdk-rs/indexd/src/mock.rs

@@ -0,0 +1,162 @@
+use std::collections::{HashMap, HashSet};
+use std::sync::{Arc, RwLock};
+use std::time::Duration;
+
+use bytes::Bytes;
+use chrono::Utc;
+use sia::rhp::{self, HostPrices};
+use sia::signing::{PrivateKey, PublicKey, Signature};
+use sia::types::{Currency, Hash256};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::time::sleep;
+
+use crate::rhp4::{self, RHP4Client};
+use crate::{
+    DownloadError, DownloadOptions, Downloader, Hosts, Object, PackedUpload, UploadError,
+    UploadOptions, Uploader,
+};
+
+pub struct MockRHP4Client {
+    sectors: RwLock<HashMap<PublicKey, HashMap<Hash256, Bytes>>>,
+    slow_hosts: RwLock<HashSet<PublicKey>>,
+    slow_delay: RwLock<Duration>,
+}
+
+impl MockRHP4Client {
+    pub fn new() -> Self {
+        Self {
+            sectors: RwLock::new(HashMap::new()),
+            slow_hosts: RwLock::new(HashSet::new()),
+            slow_delay: RwLock::new(Duration::ZERO),
+        }
+    }
+
+    pub fn clear(&self) {
+        self.sectors.write().unwrap().clear();
+    }
+
+    /// Sets the given hosts as "slow" - they will sleep for the specified duration
+    /// before completing any write_sector or read_sector operation.
+    pub fn set_slow_hosts(&self, hosts: impl IntoIterator<Item = PublicKey>, delay: Duration) {
+        let mut slow = self.slow_hosts.write().unwrap();
+        slow.clear();
+        slow.extend(hosts);
+        *self.slow_delay.write().unwrap() = delay;
+    }
+
+    /// Clears all slow host settings.
+    pub fn reset_slow_hosts(&self) {
+        self.slow_hosts.write().unwrap().clear();
+        *self.slow_delay.write().unwrap() = Duration::ZERO;
+    }
+}
+
+impl RHP4Client for Arc<MockRHP4Client> {
+    async fn host_prices(&self, _: PublicKey, _: bool) -> Result<HostPrices, rhp4::Error> {
+        Ok(HostPrices {
+            contract_price: Currency::zero(),
+            collateral: Currency::zero(),
+            ingress_price: Currency::zero(),
+            egress_price: Currency::zero(),
+            storage_price: Currency::zero(),
+            free_sector_price: Currency::zero(),
+            tip_height: 0,
+            signature: Signature::default(),
+            valid_until: Utc::now() + chrono::Duration::days(1),
+        })
+    }
+
+    async fn write_sector(
+        &self,
+        host_key: PublicKey,
+        _: &PrivateKey,
+        sector: Bytes,
+    ) -> Result<Hash256, rhp4::Error> {
+        // Check if this host is configured as slow
+        let slow_delay = {
+            let slow_hosts = self.slow_hosts.read().unwrap();
+            if slow_hosts.contains(&host_key) {
+                Some(*self.slow_delay.read().unwrap())
+            } else {
+                None
+            }
+        };
+        if let Some(delay) = slow_delay {
+            sleep(delay).await;
+        }
+
+        sleep(Duration::from_millis(3)).await; // simulate network latency ~ 10Gbps
+        let sector_root = rhp::sector_root(&sector);
+        let mut sectors = self.sectors.write().unwrap();
+        let host_sectors = sectors.entry(host_key).or_default();
+        host_sectors.insert(sector_root, sector);
+        Ok(sector_root)
+    }
+
+    async fn read_sector(
+        &self,
+        host_key: PublicKey,
+        _: &PrivateKey,
+        root: Hash256,
+        offset: usize,
+        length: usize,
+    ) -> Result<Bytes, rhp4::Error> {
+        let sector = {
+            let sectors = self.sectors.read().unwrap();
+            let host_sectors = sectors
+                .get(&host_key)
+                .ok_or_else(|| rhp4::Error::Transport("host not found".to_string()))?;
+            let sector = host_sectors
+                .get(&root)
+                .ok_or_else(|| rhp4::Error::Transport("sector not found".to_string()))?;
+            sector.slice(offset..offset + length)
+        };
+        sleep(Duration::from_nanos(sector.len() as u64 * 8 / 10)).await; // simulate network latency ~ 10Gbps
+        Ok(sector)
+    }
+}
+
+pub struct MockUploader {
+    uploader: Uploader<Arc<MockRHP4Client>>,
+}
+
+impl MockUploader {
+    pub fn new(hosts: Hosts, client: Arc<MockRHP4Client>, app_key: Arc<PrivateKey>) -> Self {
+        Self {
+            uploader: Uploader::new(hosts, client.clone(), app_key),
+        }
+    }
+
+    pub async fn upload<R: AsyncReadExt + Send + Sync + Unpin + 'static>(
+        &self,
+        r: R,
+        options: UploadOptions,
+    ) -> Result<Object, UploadError> {
+        self.uploader.upload(r, options).await
+    }
+
+    pub fn upload_packed(&self, options: UploadOptions) -> PackedUpload {
+        self.uploader.upload_packed(options)
+    }
+}
+
+pub struct MockDownloader {
+    downloader: Downloader<Arc<MockRHP4Client>>,
+}
+
+impl MockDownloader {
+    pub fn new(hosts: Hosts, client: Arc<MockRHP4Client>, app_key: Arc<PrivateKey>) -> Self {
+        Self {
+            downloader: Downloader::new(hosts, client.clone(), app_key),
+        }
+    }
+
+    pub async fn download<W: AsyncWriteExt + Send + Sync + Unpin>(
+        &self,
+        w: &mut W,
+        object: &Object,
+        options: DownloadOptions,
+    ) -> Result<(), DownloadError> {
+        self.downloader.download(w, object, options).await
+    }
+}

package/template/rust/sia-sdk-rs/indexd/src/object_encryption.rs

@@ -0,0 +1,125 @@
+use chacha20poly1305::aead::{Aead, OsRng};
+use chacha20poly1305::{AeadCore, KeyInit, XChaCha20Poly1305};
+use sia::blake2::Blake2b256;
+use sia::encryption::EncryptionKey;
+use sia::signing::PrivateKey;
+use sia::types::Hash256;
+use thiserror::Error;
+
+const NONCE_SIZE: usize = 24;
+
+#[derive(Error, Debug)]
+pub enum DecryptError {
+    #[error("decryption error")]
+    Decryption,
+    #[error("invalid encryption key length")]
+    KeyLength,
+}
+
+pub(crate) fn derive(key: &[u8], salt: &[u8], domain: &[u8], okm: &mut [u8]) {
+    let hkdf = hkdf::SimpleHkdf::<Blake2b256>::new(Some(salt), key);
+    hkdf.expand(domain, okm).unwrap();
+}
+
+pub(crate) fn derive_encryption_key(key: &[u8], salt: &[u8], domain: &[u8]) -> EncryptionKey {
+    let hkdf = hkdf::SimpleHkdf::<Blake2b256>::new(Some(salt), key);
+    let mut okm = [0u8; 32];
+    hkdf.expand(domain, &mut okm).unwrap();
+    okm.into()
+}
+
+pub(crate) fn seal_data_key(
+    app_key: &PrivateKey,
+    object_id: &Hash256,
+    encryption_key: &EncryptionKey,
+) -> Vec<u8> {
+    let data_encryption_key =
+        derive_encryption_key(app_key.as_ref(), object_id.as_ref(), b"dataKey");
+    let encryption_key_cipher = XChaCha20Poly1305::new(data_encryption_key.as_ref().into());
+    let nonce = XChaCha20Poly1305::generate_nonce(&mut OsRng);
+    let encrypted_data_key = encryption_key_cipher
+        .encrypt(&nonce, encryption_key.as_ref().as_ref())
+        .expect("encryption failed");
+    [nonce.to_vec(), encrypted_data_key].concat()
+}
+
+pub(crate) fn seal_metadata_key(
+    app_key: &PrivateKey,
+    object_id: &Hash256,
+    encryption_key: &EncryptionKey,
+) -> Vec<u8> {
+    let meta_encryption_key =
+        derive_encryption_key(app_key.as_ref(), object_id.as_ref(), b"metadataKey");
+    let encryption_key_cipher = XChaCha20Poly1305::new(meta_encryption_key.as_ref().into());
+    let nonce = XChaCha20Poly1305::generate_nonce(&mut OsRng);
+    let encrypted_meta_key = encryption_key_cipher
+        .encrypt(&nonce, encryption_key.as_ref().as_ref())
+        .expect("encryption failed");
+    [nonce.to_vec(), encrypted_meta_key].concat()
+}
+
+pub(crate) fn open_data_key(
+    app_key: &PrivateKey,
+    object_id: &Hash256,
+    encrypted_data_key: &[u8],
+) -> Result<EncryptionKey, DecryptError> {
+    if encrypted_data_key.len() < NONCE_SIZE {
+        return Err(DecryptError::Decryption);
+    }
+    let data_encryption_key =
+        derive_encryption_key(app_key.as_ref(), object_id.as_ref(), b"dataKey");
+    let encryption_key_cipher = XChaCha20Poly1305::new(data_encryption_key.as_ref().into());
+    let (nonce_bytes, ciphertext) = encrypted_data_key.split_at(NONCE_SIZE);
+    let nonce_bytes: [u8; 24] = nonce_bytes.try_into().unwrap(); // safe due to length check above
+    let nonce = chacha20poly1305::XNonce::from(nonce_bytes);
+    let decrypted_data_key = encryption_key_cipher
+        .decrypt(&nonce, ciphertext)
+        .map_err(|_| DecryptError::Decryption)?;
+    EncryptionKey::try_from(decrypted_data_key.as_ref()).map_err(|_| DecryptError::KeyLength)
+}
+
+pub(crate) fn open_metadata_key(
+    app_key: &PrivateKey,
+    object_id: &Hash256,
+    encrypted_meta_key: &[u8],
+) -> Result<EncryptionKey, DecryptError> {
+    if encrypted_meta_key.len() < NONCE_SIZE {
+        return Err(DecryptError::Decryption);
+    }
+    let meta_encryption_key =
+        derive_encryption_key(app_key.as_ref(), object_id.as_ref(), b"metadataKey");
+    let encryption_key_cipher = XChaCha20Poly1305::new(meta_encryption_key.as_ref().into());
+    let (nonce_bytes, ciphertext) = encrypted_meta_key.split_at(NONCE_SIZE);
+    let nonce_bytes: [u8; 24] = nonce_bytes.try_into().unwrap(); // safe due to length check above
+    let nonce = chacha20poly1305::XNonce::from(nonce_bytes);
+    let decrypted_meta_key = encryption_key_cipher
+        .decrypt(&nonce, ciphertext)
+        .map_err(|_| DecryptError::Decryption)?;
+    EncryptionKey::try_from(decrypted_meta_key.as_ref()).map_err(|_| DecryptError::KeyLength)
+}
+
+pub(crate) fn seal_metadata(meta_key: &EncryptionKey, metadata: &[u8]) -> Vec<u8> {
+    let metadata_cipher = XChaCha20Poly1305::new(meta_key.as_ref().into());
+    let nonce = XChaCha20Poly1305::generate_nonce(&mut OsRng);
+    let encrypted_metadata = metadata_cipher
+        .encrypt(&nonce, metadata)
+        .expect("encryption failed");
+    [nonce.to_vec(), encrypted_metadata].concat()
+}
+
+pub(crate) fn open_metadata(
+    meta_key: &EncryptionKey,
+    encrypted_metadata: &[u8],
+) -> Result<Vec<u8>, DecryptError> {
+    if encrypted_metadata.len() < NONCE_SIZE {
+        return Err(DecryptError::Decryption);
+    }
+    let metadata_cipher = XChaCha20Poly1305::new(meta_key.as_ref().into());
+    let (nonce_bytes, ciphertext) = encrypted_metadata.split_at(NONCE_SIZE);
+    let nonce_bytes: [u8; 24] = nonce_bytes.try_into().unwrap(); // safe due to length check above
+    let nonce = chacha20poly1305::XNonce::from(nonce_bytes);
+    let decrypted_metadata = metadata_cipher
+        .decrypt(&nonce, ciphertext)
+        .map_err(|_| DecryptError::Decryption)?;
+    Ok(decrypted_metadata)
+}