void_crypto/

blob_types.rs

//! Typed encrypted blob newtypes for compile-time AAD safety.
//!
//! Each blob type corresponds to a distinct encrypted object kind with its own
//! AAD constant. This prevents type confusion at the encryption boundary —
//! you cannot accidentally encrypt with the wrong AAD or pass an encrypted
//! index blob where a stash blob is expected.
//!
//! Local blob types (not stored in ObjectStore):
//! - `EncryptedIndex` — workspace index (`AAD_INDEX`)
//! - `EncryptedStaged` — staged file content (`AAD_STAGED`)
//! - `EncryptedStash` — stash stack metadata (`AAD_STASH`)

use std::fmt;

use crate::aead;
use crate::CryptoResult;

// ============================================================================
// EncryptedBlob trait — common interface for all encrypted blob types
// ============================================================================

/// Common interface for typed encrypted blob newtypes.
///
/// Every blob type wraps `Vec<u8>` ciphertext and provides the same
/// constructors/accessors. This trait enables generic operations
/// (e.g., typed `ObjectStore::put_blob` / `get_blob`) without knowing
/// the concrete blob type.
pub trait EncryptedBlob: Sized {
    /// Wrap raw ciphertext bytes.
    fn from_bytes(bytes: Vec<u8>) -> Self;

    /// Access the underlying ciphertext bytes.
    fn as_bytes(&self) -> &[u8];

    /// Consume and return the underlying ciphertext bytes.
    fn into_bytes(self) -> Vec<u8>;
}

// ============================================================================
// Macro for encrypted blob newtypes
// ============================================================================

/// Defines an encrypted blob newtype wrapping `Vec<u8>` with a fixed AAD constant.
///
/// Generated types include:
/// - `from_bytes(bytes: Vec<u8>) -> Self` (wrap raw ciphertext)
/// - `as_bytes(&self) -> &[u8]` (access ciphertext)
/// - `into_bytes(self) -> Vec<u8>` (consume and return ciphertext)
/// - `encrypt(key, plaintext) -> CryptoResult<Self>` (encrypt with correct AAD)
/// - `decrypt(&self, key) -> CryptoResult<Vec<u8>>` (decrypt with correct AAD)
/// - `decrypt_and_parse<T>(&self, key) -> CryptoResult<T>` (decrypt + CBOR parse)
/// - `Debug` impl showing byte length
macro_rules! define_encrypted_blob {
    (
        $(#[$meta:meta])*
        $name:ident, $aad:expr
    ) => {
        $(#[$meta])*
        pub struct $name(Vec<u8>);

        impl $name {
            /// Wrap raw ciphertext bytes.
            pub fn from_bytes(bytes: Vec<u8>) -> Self {
                Self(bytes)
            }

            /// Access the underlying ciphertext bytes.
            pub fn as_bytes(&self) -> &[u8] {
                &self.0
            }

            /// Consume and return the underlying ciphertext bytes.
            pub fn into_bytes(self) -> Vec<u8> {
                self.0
            }

            /// Encrypt plaintext with this blob type's AAD.
            pub fn encrypt(key: &[u8; 32], plaintext: &[u8]) -> CryptoResult<Self> {
                let ciphertext = aead::encrypt(key, plaintext, $aad)?;
                Ok(Self(ciphertext))
            }

            /// Decrypt this blob with the correct AAD.
            pub fn decrypt(&self, key: &[u8; 32]) -> CryptoResult<Vec<u8>> {
                aead::decrypt(key, &self.0, $aad)
            }

            /// Decrypt and parse a CBOR-encoded type with the correct AAD.
            pub fn decrypt_and_parse<T>(&self, key: &[u8; 32]) -> CryptoResult<T>
            where
                T: serde::de::DeserializeOwned,
            {
                aead::decrypt_and_parse(key, &self.0, $aad)
            }
        }

        impl fmt::Debug for $name {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                write!(f, "{}({} bytes)", stringify!($name), self.0.len())
            }
        }

        impl EncryptedBlob for $name {
            fn from_bytes(bytes: Vec<u8>) -> Self {
                Self(bytes)
            }

            fn as_bytes(&self) -> &[u8] {
                &self.0
            }

            fn into_bytes(self) -> Vec<u8> {
                self.0
            }
        }
    };
}

// ============================================================================
// Local encrypted blob types — not stored in ObjectStore
// ============================================================================

define_encrypted_blob!(
    /// Encrypted workspace index blob (`AAD_INDEX`).
    ///
    /// Contains a CBOR-serialized `WorkspaceIndex` struct encrypted with
    /// AES-256-GCM. Written to `.void/index/index.bin`.
    EncryptedIndex, aead::AAD_INDEX
);

define_encrypted_blob!(
    /// Encrypted staged file content blob (`AAD_STAGED`).
    ///
    /// Contains raw file content encrypted with AES-256-GCM.
    /// Written to `.void/staged/{hex_hash}`.
    EncryptedStaged, aead::AAD_STAGED
);

define_encrypted_blob!(
    /// Encrypted stash stack metadata blob (`AAD_STASH`).
    ///
    /// Contains a CBOR-serialized `StashStack` struct encrypted with
    /// AES-256-GCM. Written to `.void/stash/meta.bin`.
    EncryptedStash, aead::AAD_STASH
);

// ============================================================================
// ObjectStore-flow encrypted blob types
// ============================================================================

define_encrypted_blob!(
    /// Encrypted commit blob (`AAD_COMMIT`).
    ///
    /// Contains a VD01 envelope with a CBOR-serialized `Commit` struct.
    /// Stored in the ObjectStore, addressed by `CommitCid`.
    EncryptedCommit, aead::AAD_COMMIT
);

define_encrypted_blob!(
    /// Encrypted metadata bundle blob (`AAD_METADATA`).
    ///
    /// Contains a CBOR-serialized `MetadataBundle` struct encrypted with
    /// AES-256-GCM. Stored in the ObjectStore, addressed by `MetadataCid`.
    EncryptedMetadata, aead::AAD_METADATA
);

define_encrypted_blob!(
    /// Encrypted content shard blob (`AAD_SHARD`).
    ///
    /// Contains a shard header + compressed file content encrypted with
    /// AES-256-GCM. Stored in the ObjectStore, addressed by `ShardCid`.
    EncryptedShard, aead::AAD_SHARD
);

define_encrypted_blob!(
    /// Encrypted tree manifest blob (`AAD_MANIFEST`).
    ///
    /// Contains a CBOR-serialized `TreeManifest` struct encrypted with
    /// AES-256-GCM. Stored in the ObjectStore, addressed by `ManifestCid`.
    EncryptedManifest, aead::AAD_MANIFEST
);

define_encrypted_blob!(
    /// Encrypted repo manifest blob (`AAD_REPO_MANIFEST`).
    ///
    /// Contains JSON-serialized collaboration `Manifest` encrypted with
    /// AES-256-GCM. Stored in the ObjectStore, addressed by `RepoManifestCid`.
    EncryptedRepoManifest, aead::AAD_REPO_MANIFEST
);

// ============================================================================
// Tests
// ============================================================================

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn encrypted_index_roundtrip() {
        let key = [0x42u8; 32];
        let plaintext = b"index data";

        let blob = EncryptedIndex::encrypt(&key, plaintext).unwrap();
        let decrypted = blob.decrypt(&key).unwrap();
        assert_eq!(decrypted, plaintext);
    }

    #[test]
    fn encrypted_staged_roundtrip() {
        let key = [0x42u8; 32];
        let plaintext = b"staged file content";

        let blob = EncryptedStaged::encrypt(&key, plaintext).unwrap();
        let decrypted = blob.decrypt(&key).unwrap();
        assert_eq!(decrypted, plaintext);
    }

    #[test]
    fn encrypted_stash_roundtrip() {
        let key = [0x42u8; 32];
        let plaintext = b"stash metadata";

        let blob = EncryptedStash::encrypt(&key, plaintext).unwrap();
        let decrypted = blob.decrypt(&key).unwrap();
        assert_eq!(decrypted, plaintext);
    }

    #[test]
    fn wrong_key_fails() {
        let key1 = [0x42u8; 32];
        let key2 = [0x43u8; 32];
        let plaintext = b"secret";

        let blob = EncryptedIndex::encrypt(&key1, plaintext).unwrap();
        assert!(blob.decrypt(&key2).is_err());
    }

    #[test]
    fn debug_format() {
        let key = [0x42u8; 32];
        let blob = EncryptedIndex::encrypt(&key, b"data").unwrap();
        let debug = format!("{:?}", blob);
        assert!(debug.contains("EncryptedIndex"));
        assert!(debug.contains("bytes"));
    }

    #[test]
    fn from_bytes_wraps_raw() {
        let raw = vec![1, 2, 3, 4];
        let blob = EncryptedStaged::from_bytes(raw.clone());
        assert_eq!(blob.as_bytes(), &raw);
        assert_eq!(blob.into_bytes(), raw);
    }

    #[test]
    fn decrypt_and_parse_roundtrip() {
        #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
        struct TestData {
            value: u64,
        }

        let key = [0x42u8; 32];
        let data = TestData { value: 42 };
        let mut serialized = Vec::new();
        ciborium::into_writer(&data, &mut serialized).unwrap();

        let blob = EncryptedStash::encrypt(&key, &serialized).unwrap();
        let parsed: TestData = blob.decrypt_and_parse(&key).unwrap();
        assert_eq!(parsed, data);
    }
}