Add serialization of LongPseudonyms and LongAttributes

Author: JobDoesburg

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "libpep"
 edition = "2021"
-version = "0.7.4"
+version = "0.7.5"
 authors = ["Bernard van Gastel <bvgastel@bitpowder.com>", "Job Doesburg <job@jobdoesburg.nl>"]
 homepage = "https://github.com/NOLAI/libpep"
 repository = "https://github.com/NOLAI/libpep"

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nolai/libpep-wasm",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "The WebAssembly version of the libpep library",
   "repository": {
     "type": "git",

src/lib/high_level/padding.rs

@@ -1,7 +1,8 @@
 use crate::high_level::data_types::{
-    Attribute, Encryptable, EncryptedAttribute, EncryptedPseudonym, Pseudonym,
+    Attribute, Encryptable, Encrypted, EncryptedAttribute, EncryptedPseudonym, Pseudonym,
 };
 use derive_more::{Deref, From};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::io::{Error, ErrorKind};
 
 /// A trait for encryptable types that support PKCS#7 padding for single-block (16 byte) encoding.
@@ -272,6 +273,164 @@ impl LongAttribute {
     }
 }
 
+impl LongEncryptedPseudonym {
+    /// Serializes a `LongEncryptedPseudonym` to a string by concatenating the base64-encoded
+    /// individual `EncryptedPseudonym` items with "|" as a delimiter.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use libpep::high_level::padding::LongEncryptedPseudonym;
+    ///
+    /// let long_enc_pseudo = LongEncryptedPseudonym(vec![/* ... */]);
+    /// let serialized = long_enc_pseudo.serialize();
+    /// ```
+    pub fn serialize(&self) -> String {
+        self.0
+            .iter()
+            .map(|item| item.as_base64())
+            .collect::<Vec<_>>()
+            .join("|")
+    }
+
+    /// Deserializes a `LongEncryptedPseudonym` from a string by splitting on "|" and
+    /// decoding each base64-encoded `EncryptedPseudonym`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if any of the base64-encoded parts cannot be decoded.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use libpep::high_level::padding::LongEncryptedPseudonym;
+    ///
+    /// let serialized = "base64_1|base64_2|base64_3";
+    /// let long_enc_pseudo = LongEncryptedPseudonym::deserialize(serialized).unwrap();
+    ///
+    /// // Empty string deserializes to empty vector
+    /// let empty = LongEncryptedPseudonym::deserialize("").unwrap();
+    /// assert_eq!(empty.0.len(), 0);
+    /// ```
+    pub fn deserialize(s: &str) -> Result<Self, Error> {
+        if s.is_empty() {
+            return Ok(LongEncryptedPseudonym(vec![]));
+        }
+
+        let items: Result<Vec<EncryptedPseudonym>, Error> = s
+            .split('|')
+            .map(|part| {
+                EncryptedPseudonym::from_base64(part).ok_or_else(|| {
+                    Error::new(
+                        ErrorKind::InvalidData,
+                        format!("Invalid base64 encoding: {}", part),
+                    )
+                })
+            })
+            .collect();
+
+        items.map(LongEncryptedPseudonym)
+    }
+}
+
+impl LongEncryptedAttribute {
+    /// Serializes a `LongEncryptedAttribute` to a string by concatenating the base64-encoded
+    /// individual `EncryptedAttribute` items with "|" as a delimiter.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use libpep::high_level::padding::LongEncryptedAttribute;
+    ///
+    /// let long_enc_attr = LongEncryptedAttribute(vec![/* ... */]);
+    /// let serialized = long_enc_attr.serialize();
+    /// ```
+    pub fn serialize(&self) -> String {
+        self.0
+            .iter()
+            .map(|item| item.as_base64())
+            .collect::<Vec<_>>()
+            .join("|")
+    }
+
+    /// Deserializes a `LongEncryptedAttribute` from a string by splitting on "|" and
+    /// decoding each base64-encoded `EncryptedAttribute`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if any of the base64-encoded parts cannot be decoded.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use libpep::high_level::padding::LongEncryptedAttribute;
+    ///
+    /// let serialized = "base64_1|base64_2|base64_3";
+    /// let long_enc_attr = LongEncryptedAttribute::deserialize(serialized).unwrap();
+    ///
+    /// // Empty string deserializes to empty vector
+    /// let empty = LongEncryptedAttribute::deserialize("").unwrap();
+    /// assert_eq!(empty.0.len(), 0);
+    /// ```
+    pub fn deserialize(s: &str) -> Result<Self, Error> {
+        if s.is_empty() {
+            return Ok(LongEncryptedAttribute(vec![]));
+        }
+
+        let items: Result<Vec<EncryptedAttribute>, Error> = s
+            .split('|')
+            .map(|part| {
+                EncryptedAttribute::from_base64(part).ok_or_else(|| {
+                    Error::new(
+                        ErrorKind::InvalidData,
+                        format!("Invalid base64 encoding: {}", part),
+                    )
+                })
+            })
+            .collect();
+
+        items.map(LongEncryptedAttribute)
+    }
+}
+
+impl Serialize for LongEncryptedPseudonym {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&self.serialize())
+    }
+}
+
+impl<'de> Deserialize<'de> for LongEncryptedPseudonym {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        Self::deserialize(&s).map_err(serde::de::Error::custom)
+    }
+}
+
+impl Serialize for LongEncryptedAttribute {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&self.serialize())
+    }
+}
+
+impl<'de> Deserialize<'de> for LongEncryptedAttribute {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        Self::deserialize(&s).map_err(serde::de::Error::custom)
+    }
+}
+
 /// Internal helper function to encode bytes with PKCS#7 padding
 fn from_bytes_padded_impl<T: Encryptable>(data: &[u8]) -> Result<Vec<T>, Error> {
     // Handle empty data

src/lib/python/high_level.rs

@@ -2,7 +2,9 @@ use crate::high_level::contexts::*;
 use crate::high_level::data_types::*;
 use crate::high_level::keys::*;
 use crate::high_level::ops::*;
-use crate::high_level::padding::{LongAttribute, LongPseudonym, Padded};
+use crate::high_level::padding::{
+    LongAttribute, LongEncryptedAttribute, LongEncryptedPseudonym, LongPseudonym, Padded,
+};
 use crate::high_level::secrets::{EncryptionSecret, PseudonymizationSecret};
 use crate::internal::arithmetic::GroupElement;
 use crate::python::arithmetic::{PyGroupElement, PyScalarNonZero};
@@ -782,6 +784,110 @@ impl PyEncryptedAttribute {
     }
 }
 
+/// A collection of encrypted pseudonyms that can be serialized as a pipe-delimited string.
+#[pyclass(name = "LongEncryptedPseudonym")]
+#[derive(Clone, Eq, PartialEq, Debug, From, Deref)]
+pub struct PyLongEncryptedPseudonym(pub(crate) LongEncryptedPseudonym);
+
+#[pymethods]
+impl PyLongEncryptedPseudonym {
+    /// Create from a vector of encrypted pseudonyms.
+    #[new]
+    fn new(encrypted_pseudonyms: Vec<PyEncryptedPseudonym>) -> Self {
+        let rust_enc_pseudonyms: Vec<EncryptedPseudonym> =
+            encrypted_pseudonyms.into_iter().map(|p| p.0).collect();
+        Self(LongEncryptedPseudonym(rust_enc_pseudonyms))
+    }
+
+    /// Serializes to a pipe-delimited base64 string.
+    #[pyo3(name = "serialize")]
+    fn serialize(&self) -> String {
+        self.0.serialize()
+    }
+
+    /// Deserializes from a pipe-delimited base64 string.
+    #[staticmethod]
+    #[pyo3(name = "deserialize")]
+    fn deserialize(s: &str) -> PyResult<Self> {
+        LongEncryptedPseudonym::deserialize(s)
+            .map(Self)
+            .map_err(|e| {
+                pyo3::exceptions::PyValueError::new_err(format!("Deserialization failed: {e}"))
+            })
+    }
+
+    /// Get the underlying encrypted pseudonyms.
+    #[pyo3(name = "encrypted_pseudonyms")]
+    fn encrypted_pseudonyms(&self) -> Vec<PyEncryptedPseudonym> {
+        self.0 .0.iter().map(|p| PyEncryptedPseudonym(*p)).collect()
+    }
+
+    /// Get the number of encrypted pseudonym blocks.
+    fn __len__(&self) -> usize {
+        self.0 .0.len()
+    }
+
+    fn __repr__(&self) -> String {
+        format!("LongEncryptedPseudonym({} blocks)", self.0 .0.len())
+    }
+
+    fn __eq__(&self, other: &PyLongEncryptedPseudonym) -> bool {
+        self.0 == other.0
+    }
+}
+
+/// A collection of encrypted attributes that can be serialized as a pipe-delimited string.
+#[pyclass(name = "LongEncryptedAttribute")]
+#[derive(Clone, Eq, PartialEq, Debug, From, Deref)]
+pub struct PyLongEncryptedAttribute(pub(crate) LongEncryptedAttribute);
+
+#[pymethods]
+impl PyLongEncryptedAttribute {
+    /// Create from a vector of encrypted attributes.
+    #[new]
+    fn new(encrypted_attributes: Vec<PyEncryptedAttribute>) -> Self {
+        let rust_enc_attributes: Vec<EncryptedAttribute> =
+            encrypted_attributes.into_iter().map(|a| a.0).collect();
+        Self(LongEncryptedAttribute(rust_enc_attributes))
+    }
+
+    /// Serializes to a pipe-delimited base64 string.
+    #[pyo3(name = "serialize")]
+    fn serialize(&self) -> String {
+        self.0.serialize()
+    }
+
+    /// Deserializes from a pipe-delimited base64 string.
+    #[staticmethod]
+    #[pyo3(name = "deserialize")]
+    fn deserialize(s: &str) -> PyResult<Self> {
+        LongEncryptedAttribute::deserialize(s)
+            .map(Self)
+            .map_err(|e| {
+                pyo3::exceptions::PyValueError::new_err(format!("Deserialization failed: {e}"))
+            })
+    }
+
+    /// Get the underlying encrypted attributes.
+    #[pyo3(name = "encrypted_attributes")]
+    fn encrypted_attributes(&self) -> Vec<PyEncryptedAttribute> {
+        self.0 .0.iter().map(|a| PyEncryptedAttribute(*a)).collect()
+    }
+
+    /// Get the number of encrypted attribute blocks.
+    fn __len__(&self) -> usize {
+        self.0 .0.len()
+    }
+
+    fn __repr__(&self) -> String {
+        format!("LongEncryptedAttribute({} blocks)", self.0 .0.len())
+    }
+
+    fn __eq__(&self, other: &PyLongEncryptedAttribute) -> bool {
+        self.0 == other.0
+    }
+}
+
 // Pseudonym global key pair
 #[pyclass(name = "PseudonymGlobalKeyPair")]
 #[derive(Copy, Clone, Debug)]
@@ -977,6 +1083,8 @@ pub fn register_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyLongAttribute>()?;
     m.add_class::<PyEncryptedPseudonym>()?;
     m.add_class::<PyEncryptedAttribute>()?;
+    m.add_class::<PyLongEncryptedPseudonym>()?;
+    m.add_class::<PyLongEncryptedAttribute>()?;
     m.add_class::<PyPseudonymGlobalKeyPair>()?;
     m.add_class::<PyAttributeGlobalKeyPair>()?;
     m.add_class::<PyPseudonymSessionKeyPair>()?;