# Quantum-Worm
Quantum-Worm is a Rust crate that implements a secure, quantum-resistant file transfer system. By leveraging post-quantum cryptographic algorithms, it ensures robust security for file transfers, protecting against potential future threats from quantum computing.
## Features
- **Quantum-Resistant Cryptography**: Utilizes state-of-the-art post-quantum cryptographic algorithms for key encapsulation.
- **Secure File Transfer**: Facilitates the secure transfer of files of any size and type.
- **Efficient Serialization**: Employs `serde` and `bincode` for fast and compact serialization of file metadata.
- **Asynchronous Operations**: Implements non-blocking file transfers using the `tokio` runtime.
- **Symmetric Encryption**: Uses AES-GCM for efficient and secure symmetric encryption of file contents.
## Installation
Add Quantum-Worm to your `Cargo.toml`:
```toml
[dependencies]
quantum-worm = "0.1.0"
```
## Usage
Here's a basic example demonstrating how to use the Quantum-Worm crate for file transfer:
```rust
use quantum_worm::{send_file, receive_file};
use tokio;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
// Example file paths
let source_file = "path/to/source/file.txt";
let destination_file = "path/to/destination/file.txt";
// Send file
let file_data = tokio::fs::read(source_file).await?;
send_file(destination_file, &file_data).await?;
// Receive file
let received_data = receive_file(destination_file).await?;
tokio::fs::write(source_file, received_data).await?;
Ok(())
}
```
## API Reference
### `send_file`
```rust
pub async fn send_file(destination: &str, data: &[u8]) -> Result<(), Error>
```
Encrypts and sends a file to the specified destination.
- `destination`: The path where the encrypted file will be saved.
- `data`: The file contents to be sent.
### `receive_file`
```rust
pub async fn receive_file(source: &str) -> Result<Vec<u8>, Error>
```
Receives and decrypts a file from the specified source.
- `source`: The path of the encrypted file to be received.
- Returns the decrypted file contents.
## Security Considerations
Quantum-Worm uses the following cryptographic primitives:
- **Kyber**: A lattice-based key encapsulation mechanism (KEM) for quantum-resistant key exchange.
- **AES-GCM**: For symmetric encryption of file contents.
- **Secure random number generation**: Provided by the `rand` crate.
While these algorithms are considered secure against known quantum attacks, it's important to keep the crate updated and follow best practices for key management and secure coding.
## Error Handling
The crate uses a custom `Error` type that encompasses various error conditions:
- IO errors
- Serialization/deserialization errors
- Encryption/decryption errors
- Key generation errors
Always handle potential errors when using the crate's functions.
## Performance Considerations
- File transfers are performed asynchronously, allowing for efficient handling of multiple transfers.
- The use of `bincode` for serialization provides a good balance between speed and compact representation.
- For large files, consider implementing chunked transfers to manage memory usage.
## Contributing
Contributions to Quantum-Worm are welcome! Please feel free to submit pull requests or create issues for bugs and feature requests.
## License
This project is licensed under the MIT License - see the LICENSE file for details.
## Disclaimer
While Quantum-Worm uses post-quantum cryptographic algorithms, the security landscape is constantly evolving. Always stay informed about the latest developments in cryptography and update your security practices accordingly.