use crate::encryption;
use crate::error::{CryptoError, CryptoResult};
use base64::Engine;
use serde::{de::DeserializeOwned, Serialize};
pub const E2EE_PREFIX: &str = "e2ee:";
pub fn seal_bytes(entity_key: &[u8; 32], plaintext: &[u8]) -> CryptoResult<String> {
let raw = encryption::encrypt(entity_key, plaintext)?;
let b64 = base64::engine::general_purpose::STANDARD.encode(&raw);
Ok(format!("{}{}", E2EE_PREFIX, b64))
}
pub fn unseal_bytes(entity_key: &[u8; 32], stored: &str) -> CryptoResult<Vec<u8>> {
let b64 = stored
.strip_prefix(E2EE_PREFIX)
.ok_or(CryptoError::MissingE2eePrefix)?;
let raw = base64::engine::general_purpose::STANDARD.decode(b64)?;
encryption::decrypt(entity_key, &raw)
}
pub fn try_unseal_bytes(entity_key: &[u8; 32], stored: &str) -> CryptoResult<Vec<u8>> {
if stored.starts_with(E2EE_PREFIX) {
unseal_bytes(entity_key, stored)
} else {
Ok(stored.as_bytes().to_vec())
}
}
pub fn seal_string(entity_key: &[u8; 32], plaintext: &str) -> CryptoResult<String> {
seal_bytes(entity_key, plaintext.as_bytes())
}
pub fn unseal_string(entity_key: &[u8; 32], stored: &str) -> CryptoResult<String> {
let bytes = unseal_bytes(entity_key, stored)?;
Ok(String::from_utf8(bytes)?)
}
pub fn try_unseal_string(entity_key: &[u8; 32], stored: &str) -> CryptoResult<String> {
let bytes = try_unseal_bytes(entity_key, stored)?;
Ok(String::from_utf8(bytes)?)
}
pub fn seal_json<T: Serialize>(entity_key: &[u8; 32], value: &T) -> CryptoResult<String> {
let s = serde_json::to_string(value)?;
seal_string(entity_key, &s)
}
pub fn unseal_json<T: DeserializeOwned>(entity_key: &[u8; 32], stored: &str) -> CryptoResult<T> {
let s = unseal_string(entity_key, stored)?;
Ok(serde_json::from_str(&s)?)
}
pub fn try_unseal_json<T: DeserializeOwned>(
entity_key: &[u8; 32],
stored: &str,
) -> CryptoResult<T> {
let s = try_unseal_string(entity_key, stored)?;
Ok(serde_json::from_str(&s)?)
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
const KEY: [u8; 32] = [7u8; 32];
#[test]
fn string_roundtrip() {
let sealed = seal_string(&KEY, "hello").unwrap();
assert!(sealed.starts_with(E2EE_PREFIX));
assert_eq!(unseal_string(&KEY, &sealed).unwrap(), "hello");
}
#[test]
fn json_roundtrip() {
let v = json!({"a": 1, "b": "two"});
let sealed = seal_json(&KEY, &v).unwrap();
let back: serde_json::Value = unseal_json(&KEY, &sealed).unwrap();
assert_eq!(v, back);
}
#[test]
fn strict_rejects_plaintext() {
let result = unseal_string(&KEY, "hello plaintext");
assert!(matches!(result, Err(CryptoError::MissingE2eePrefix)));
}
#[test]
fn lenient_passes_plaintext_through() {
let out = try_unseal_string(&KEY, "hello plaintext").unwrap();
assert_eq!(out, "hello plaintext");
}
#[test]
fn wrong_key_fails() {
let sealed = seal_string(&KEY, "secret").unwrap();
let wrong = [9u8; 32];
assert!(unseal_string(&wrong, &sealed).is_err());
}
#[test]
fn lenient_invalid_base64_after_prefix_still_errors() {
let result = try_unseal_string(&KEY, "e2ee:!!!not-base64!!!");
assert!(result.is_err());
}
#[test]
fn lenient_sealed_blob_with_wrong_key_fails_closed() {
let sealed = seal_string(&KEY, "top secret").unwrap();
let wrong = [9u8; 32];
let result = try_unseal_string(&wrong, &sealed);
assert!(
result.is_err(),
"a prefixed blob under the wrong key must error, not pass ciphertext through"
);
}
#[test]
fn tampered_wire_format_is_detected() {
let sealed = seal_string(&KEY, "integrity matters").unwrap();
let mut bytes: Vec<u8> = sealed.into_bytes();
let body_start = E2EE_PREFIX.len();
let idx = body_start + 4;
bytes[idx] = if bytes[idx] == b'A' { b'B' } else { b'A' };
let tampered = String::from_utf8(bytes).unwrap();
assert!(
unseal_string(&KEY, &tampered).is_err(),
"strict must reject tamper"
);
assert!(
try_unseal_string(&KEY, &tampered).is_err(),
"lenient must also reject tamper on a prefixed blob"
);
}
#[test]
fn bytes_roundtrip_handles_non_utf8() {
let payload = [0x00u8, 0xFF, 0xFE, 0x80, 0x01];
let sealed = seal_bytes(&KEY, &payload).unwrap();
assert!(sealed.starts_with(E2EE_PREFIX));
assert_eq!(unseal_bytes(&KEY, &sealed).unwrap(), payload);
}
}