create-sia-app 0.1.7 → 0.1.9

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

@@ -1,162 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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)
-}