PrivateBox provides a small and easy to use API to encrypt your data. It is meant to do one thing, be a simple wrapper and validator around the RustCrypto XChaCha20Poly1305 AEAD encryption algorithm.
PrivateBox is inspired/based off of Cocoon. PrivateBox is meant to be a smaller API, more flexible with associated data, and uses XChaCha for random nonces.
The examples just use array generation for the key to keep the code duplication down. However, keys should be random or pseudo-random (aka derived from something like a password).
Example:
```rust use rand_core::{OsRng, RngCore};
let mut key = [0u8; 32]; OsRng.fill_bytes(&mut key); ```
Detached encryption/decryption methods compute in place to avoid re-allocations. It returns a prefix (the nonce and tag) that is used for decryption. This is suitable for a no_std build, when you want to avoid re-allocations of data, and if you want to manage serialization yourself.
Example:
```rust let mut privatebox = PrivateBox::new(&[1;32], OsRng);
let mut message = *b"secret data"; let assoc_data = *b"plain text";
let detachedprefix = privatebox.encryptdetached(&mut message, &assocdata)?; assertne!(&message, b"secret data");
privatebox.decryptdetached(&mut message, &assocdata, &detachedprefix)?; asserteq!(&message, b"secret data"); ```
See the docs for examples and more information.
The encrypt/decrypt methods handle serialization for you and returns a container. It enables the easy use of stored associated data and separate associated data. It is much simpler to use than detached encryption/decryption. It uses alloc (enabled by default).
Example:
```rust let mut privatebox = PrivateBox::new(&[1; 32], OsRng); t header = &[5, 4, 3, 2]; let metadata = &[3, 3, 3];
let wrapped = privatebox.encrypt(b"secret data", header, metadata).expect("encrypt"); let (message, authenticated_header) = privatebox.decrypt(&wrapped, metadata).expect("decrypt");
asserteq!(message, b"secret data"); asserteq!(&authenticated_header, header); ```
See the docs for examples and more information.