use std::fmt;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use crate::{Hex, SecretBytes, SecretString};
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
#[non_exhaustive]
pub enum HpkeKem {
X25519,
P256,
#[default]
XWing,
#[serde(rename = "x25519-ml-kem-768")]
X25519MlKem768,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
#[non_exhaustive]
pub enum HpkeAead {
#[default]
#[serde(rename = "chacha20-poly1305")]
ChaCha20Poly1305,
#[serde(rename = "aes-128-gcm")]
Aes128Gcm,
}
#[derive(Clone)]
pub enum HpkeData {
Text(SecretString),
Bytes(SecretBytes),
}
impl Default for HpkeData {
fn default() -> Self {
HpkeData::Text(SecretString::default())
}
}
impl fmt::Debug for HpkeData {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("HpkeData(<redacted>)")
}
}
impl From<&str> for HpkeData {
fn from(text: &str) -> Self {
HpkeData::Text(text.into())
}
}
impl From<Vec<u8>> for HpkeData {
fn from(bytes: Vec<u8>) -> Self {
HpkeData::Bytes(bytes.into())
}
}
fn reads_as_hex(text: &str) -> bool {
text.len() % 2 == 0 && text.bytes().all(|b| b.is_ascii_hexdigit())
}
impl Serialize for HpkeData {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
HpkeData::Bytes(bytes) => bytes.serialize(serializer),
HpkeData::Text(text) if reads_as_hex(text.expose_secret()) => {
SecretBytes::new(text.expose_secret().as_bytes()).serialize(serializer)
}
HpkeData::Text(text) => text.serialize(serializer),
}
}
}
impl<'de> Deserialize<'de> for HpkeData {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
SecretString::deserialize(deserializer).map(HpkeData::Text)
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct HpkeKeygenRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub kem: Option<HpkeKem>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct HpkeSealRequest {
pub recipient_public_key: Hex,
pub plaintext: HpkeData,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub kem: Option<HpkeKem>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub aead: Option<HpkeAead>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub info: Option<HpkeData>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub aad: Option<HpkeData>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub psk: Option<SecretString>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub psk_id: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct HpkeSealed {
pub encapsulated_key: Hex,
pub ciphertext: Hex,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct HpkeOpenRequest {
pub key_id: String,
pub encapsulated_key: Hex,
pub ciphertext: Hex,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub aead: Option<HpkeAead>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub info: Option<HpkeData>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub aad: Option<HpkeData>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub psk: Option<SecretString>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub psk_id: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct HpkeOpened {
pub plaintext: SecretString,
pub hex: SecretBytes,
}
#[cfg(test)]
mod tests;