123 lines
3.8 KiB
Rust
123 lines
3.8 KiB
Rust
//! sym.rs — Stateless symmetric encryption (Phase 1)
|
|
//!
|
|
//! Commands implemented (RESP):
|
|
//! - SYM KEYGEN
|
|
//! - SYM ENCRYPT <key_b64> <message>
|
|
//! - SYM DECRYPT <key_b64> <ciphertext_b64>
|
|
//!
|
|
//! Notes:
|
|
//! - Raw key: exactly 32 bytes, provided as Base64 in commands.
|
|
//! - Cipher: XChaCha20-Poly1305 (AEAD) without AAD in Phase 1
|
|
//! - Ciphertext binary layout: [version:1][nonce:24][ciphertext||tag]
|
|
//! - Encoding for wire I/O: Base64
|
|
|
|
use base64::{engine::general_purpose::STANDARD as B64, Engine as _};
|
|
use chacha20poly1305::{
|
|
aead::{Aead, KeyInit, OsRng},
|
|
XChaCha20Poly1305, XNonce,
|
|
};
|
|
use rand::RngCore;
|
|
|
|
use crate::protocol::Protocol;
|
|
|
|
const VERSION: u8 = 1;
|
|
const NONCE_LEN: usize = 24;
|
|
const TAG_LEN: usize = 16;
|
|
|
|
#[derive(Debug)]
|
|
pub enum SymWireError {
|
|
InvalidKey,
|
|
BadEncoding,
|
|
BadFormat,
|
|
BadVersion(u8),
|
|
Crypto,
|
|
}
|
|
|
|
impl SymWireError {
|
|
fn to_protocol(self) -> Protocol {
|
|
match self {
|
|
SymWireError::InvalidKey => Protocol::err("ERR sym: invalid key"),
|
|
SymWireError::BadEncoding => Protocol::err("ERR sym: bad encoding"),
|
|
SymWireError::BadFormat => Protocol::err("ERR sym: bad format"),
|
|
SymWireError::BadVersion(v) => Protocol::err(&format!("ERR sym: unsupported version {}", v)),
|
|
SymWireError::Crypto => Protocol::err("ERR sym: auth failed"),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn decode_key_b64(s: &str) -> Result<chacha20poly1305::Key, SymWireError> {
|
|
let bytes = B64.decode(s.as_bytes()).map_err(|_| SymWireError::BadEncoding)?;
|
|
if bytes.len() != 32 {
|
|
return Err(SymWireError::InvalidKey);
|
|
}
|
|
Ok(chacha20poly1305::Key::from_slice(&bytes).to_owned())
|
|
}
|
|
|
|
fn encrypt_blob(key: &chacha20poly1305::Key, plaintext: &[u8]) -> Result<Vec<u8>, SymWireError> {
|
|
let cipher = XChaCha20Poly1305::new(key);
|
|
|
|
let mut nonce_bytes = [0u8; NONCE_LEN];
|
|
OsRng.fill_bytes(&mut nonce_bytes);
|
|
let nonce = XNonce::from_slice(&nonce_bytes);
|
|
|
|
let mut out = Vec::with_capacity(1 + NONCE_LEN + plaintext.len() + TAG_LEN);
|
|
out.push(VERSION);
|
|
out.extend_from_slice(&nonce_bytes);
|
|
|
|
let ct = cipher.encrypt(nonce, plaintext).map_err(|_| SymWireError::Crypto)?;
|
|
out.extend_from_slice(&ct);
|
|
Ok(out)
|
|
}
|
|
|
|
fn decrypt_blob(key: &chacha20poly1305::Key, blob: &[u8]) -> Result<Vec<u8>, SymWireError> {
|
|
if blob.len() < 1 + NONCE_LEN + TAG_LEN {
|
|
return Err(SymWireError::BadFormat);
|
|
}
|
|
let ver = blob[0];
|
|
if ver != VERSION {
|
|
return Err(SymWireError::BadVersion(ver));
|
|
}
|
|
let nonce = XNonce::from_slice(&blob[1..1 + NONCE_LEN]);
|
|
let ct = &blob[1 + NONCE_LEN..];
|
|
|
|
let cipher = XChaCha20Poly1305::new(key);
|
|
cipher.decrypt(nonce, ct).map_err(|_| SymWireError::Crypto)
|
|
}
|
|
|
|
// ---------- Command handlers (RESP) ----------
|
|
|
|
pub async fn cmd_sym_keygen() -> Protocol {
|
|
let mut key_bytes = [0u8; 32];
|
|
OsRng.fill_bytes(&mut key_bytes);
|
|
let key_b64 = B64.encode(key_bytes);
|
|
Protocol::BulkString(key_b64)
|
|
}
|
|
|
|
pub async fn cmd_sym_encrypt(key_b64: &str, message: &str) -> Protocol {
|
|
let key = match decode_key_b64(key_b64) {
|
|
Ok(k) => k,
|
|
Err(e) => return e.to_protocol(),
|
|
};
|
|
match encrypt_blob(&key, message.as_bytes()) {
|
|
Ok(blob) => Protocol::BulkString(B64.encode(blob)),
|
|
Err(e) => e.to_protocol(),
|
|
}
|
|
}
|
|
|
|
pub async fn cmd_sym_decrypt(key_b64: &str, ct_b64: &str) -> Protocol {
|
|
let key = match decode_key_b64(key_b64) {
|
|
Ok(k) => k,
|
|
Err(e) => return e.to_protocol(),
|
|
};
|
|
let blob = match B64.decode(ct_b64.as_bytes()) {
|
|
Ok(b) => b,
|
|
Err(_) => return SymWireError::BadEncoding.to_protocol(),
|
|
};
|
|
match decrypt_blob(&key, &blob) {
|
|
Ok(pt) => match String::from_utf8(pt) {
|
|
Ok(s) => Protocol::BulkString(s),
|
|
Err(_) => Protocol::err("ERR sym: invalid UTF-8 plaintext"),
|
|
},
|
|
Err(e) => e.to_protocol(),
|
|
}
|
|
} |