use crate::error::CryptoResult;
use crate::namespace::KeyNamespace;
use crate::sealed::{
seal_json, seal_string, try_unseal_json, try_unseal_string, unseal_json, unseal_string,
};
use crate::session::SessionKey;
use serde::{de::DeserializeOwned, Serialize};
pub trait EncryptedEntity {
const NAMESPACE: KeyNamespace;
fn entity_id(&self) -> i64;
}
impl SessionKey {
pub fn entity_key<E: EncryptedEntity>(&self, entity: &E) -> CryptoResult<[u8; 32]> {
self.derive(E::NAMESPACE, entity.entity_id())
}
}
pub fn seal_entity_string<E: EncryptedEntity>(
session: &SessionKey,
entity: &E,
plaintext: &str,
) -> CryptoResult<String> {
let key = session.entity_key(entity)?;
seal_string(&key, plaintext)
}
pub fn unseal_entity_string<E: EncryptedEntity>(
session: &SessionKey,
entity: &E,
stored: &str,
) -> CryptoResult<String> {
let key = session.entity_key(entity)?;
unseal_string(&key, stored)
}
pub fn try_unseal_entity_string<E: EncryptedEntity>(
session: &SessionKey,
entity: &E,
stored: &str,
) -> CryptoResult<String> {
let key = session.entity_key(entity)?;
try_unseal_string(&key, stored)
}
pub fn seal_entity_json<E: EncryptedEntity, T: Serialize>(
session: &SessionKey,
entity: &E,
value: &T,
) -> CryptoResult<String> {
let key = session.entity_key(entity)?;
seal_json(&key, value)
}
pub fn unseal_entity_json<E: EncryptedEntity, T: DeserializeOwned>(
session: &SessionKey,
entity: &E,
stored: &str,
) -> CryptoResult<T> {
let key = session.entity_key(entity)?;
unseal_json(&key, stored)
}
pub fn try_unseal_entity_json<E: EncryptedEntity, T: DeserializeOwned>(
session: &SessionKey,
entity: &E,
stored: &str,
) -> CryptoResult<T> {
let key = session.entity_key(entity)?;
try_unseal_json(&key, stored)
}
#[cfg(test)]
mod tests {
use super::*;
struct Dummy {
id: i64,
}
impl EncryptedEntity for Dummy {
const NAMESPACE: KeyNamespace = KeyNamespace::Profile;
fn entity_id(&self) -> i64 {
self.id
}
}
fn session() -> SessionKey {
SessionKey::new([42u8; 32])
}
#[test]
fn roundtrip_string() {
let s = session();
let e = Dummy { id: 7 };
let sealed = seal_entity_string(&s, &e, "hello").unwrap();
assert_eq!(try_unseal_entity_string(&s, &e, &sealed).unwrap(), "hello");
}
#[test]
fn different_ids_cannot_cross_decrypt() {
let s = session();
let a = Dummy { id: 1 };
let b = Dummy { id: 2 };
let sealed = seal_entity_string(&s, &a, "secret").unwrap();
assert!(try_unseal_entity_string(&s, &b, &sealed).is_err());
}
#[test]
fn plaintext_passes_through_try_variant() {
let s = session();
let e = Dummy { id: 1 };
assert_eq!(
try_unseal_entity_string(&s, &e, "legacy-plaintext").unwrap(),
"legacy-plaintext"
);
}
#[test]
fn plaintext_rejected_by_strict_variant() {
let s = session();
let e = Dummy { id: 1 };
assert!(unseal_entity_string(&s, &e, "legacy-plaintext").is_err());
}
struct OtherEntity {
id: i64,
}
impl EncryptedEntity for OtherEntity {
const NAMESPACE: KeyNamespace = KeyNamespace::Proxy;
fn entity_id(&self) -> i64 {
self.id
}
}
#[test]
fn same_id_different_namespace_cannot_cross_decrypt() {
let s = session();
let profile = Dummy { id: 1 };
let proxy = OtherEntity { id: 1 };
let sealed = seal_entity_string(&s, &profile, "profile-secret").unwrap();
assert!(
try_unseal_entity_string(&s, &proxy, &sealed).is_err(),
"a proxy key must not decrypt a profile blob sharing the same id"
);
}
#[test]
fn different_session_key_cannot_decrypt() {
let e = Dummy { id: 7 };
let sealed = seal_entity_string(&session(), &e, "secret").unwrap();
let other_session = SessionKey::new([99u8; 32]);
assert!(unseal_entity_string(&other_session, &e, &sealed).is_err());
}
#[test]
fn roundtrip_json() {
use serde_json::json;
let s = session();
let e = Dummy { id: 3 };
let value = json!({ "host": "1.2.3.4", "port": 1080 });
let sealed = seal_entity_json(&s, &e, &value).unwrap();
let back: serde_json::Value = try_unseal_entity_json(&s, &e, &sealed).unwrap();
assert_eq!(back, value);
}
}