Added encoding and decoding with padding

Author: Gulianrdgd

.gitignore

@@ -154,4 +154,4 @@ dist
 .idea/
 
 # OS specific
-.DS_Store/
+.DS_Store

src/lib/high_level/data_types.rs

@@ -6,6 +6,7 @@ use crate::low_level::elgamal::{ElGamal, ELGAMAL_LENGTH};
 use derive_more::{Deref, From};
 use rand_core::{CryptoRng, RngCore};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::io::{Error, ErrorKind};
 
 /// A pseudonym (in the background, this is a [`GroupElement`]) that can be used to identify a user
 /// within a specific context, which can be encrypted, rekeyed and reshuffled.
@@ -196,6 +197,115 @@ pub trait Encryptable {
     fn as_bytes(&self) -> Option<[u8; 16]> {
         self.value().encode_lizard()
     }
+
+    /// Encodes an arbitrary byte array into one or more Encryptables
+    /// Uses PKCS#7 style padding where the padding byte value equals the number of padding bytes
+    fn from_bytes_padded(data: &[u8]) -> Vec<Self>
+    where
+        Self: Sized,
+    {
+        if data.is_empty() {
+            return vec![];
+        }
+
+        let mut result = Vec::new();
+
+        // Process all full blocks, that do not need padding
+        // Initialize the last block with the padding value
+        // Copy remaining data if there is any
+        for i in 0..(data.len() / 16) {
+            let start = i * 16;
+            // This is safe, as we know that the slice is 16 bytes long
+            result.push(Self::from_bytes(
+                &data[start..start + 16].try_into().unwrap(),
+            ));
+        }
+
+        let remaining = data.len() % 16;
+        let padding_byte = (16 - remaining) as u8;
+
+        let mut last_block = [padding_byte; 16];
+
+        if remaining > 0 {
+            last_block[..remaining].copy_from_slice(&data[data.len() - remaining..]);
+        }
+
+        result.push(Self::from_bytes(&last_block));
+
+        result
+    }
+
+    /// Encodes an arbitrary string into one or more Encrtypb
+    /// Uses PKCS#7 style padding where the padding byte value equals the number of padding bytes
+    fn from_string_padded(text: &str) -> Vec<Self>
+    where
+        Self: Sized,
+    {
+        // Convert string to bytes and pass to the byte encoding function
+        Self::from_bytes_padded(text.as_bytes())
+    }
+
+    /// Decodes encryptables back to the original string
+    /// Returns an error if the decoded bytes are not valid UTF-8
+    fn to_string_padded(encryptables: &[Self]) -> Result<String, Error>
+    where
+        Self: Sized,
+    {
+        let bytes = Self::to_bytes_padded(encryptables)?;
+        String::from_utf8(bytes).map_err(|e| Error::new(ErrorKind::InvalidData, e.to_string()))
+    }
+
+    /// Decodes encryptables back to the original byte array
+    fn to_bytes_padded(encryptables: &[Self]) -> Result<Vec<u8>, Error>
+    where
+        Self: Sized,
+    {
+        if encryptables.is_empty() {
+            return Err(Error::new(
+                ErrorKind::InvalidInput,
+                "No encryptables provided",
+            ));
+        }
+
+        let mut result = Vec::with_capacity(encryptables.len() * 16);
+
+        // Copy over all blocks except the last one
+        // Validate padding and copy the data part of the last block
+        // Copy over all blocks except the last one
+        for data_point in &encryptables[..encryptables.len() - 1] {
+            let block = data_point.as_bytes().ok_or(Error::new(
+                ErrorKind::InvalidData,
+                "Encryptable conversion to bytes failed",
+            ))?;
+            result.extend_from_slice(&block);
+        }
+
+        // This is safe, we know that there is at least one element in the slice
+        let last_block = encryptables.last().unwrap().as_bytes().ok_or(Error::new(
+            ErrorKind::InvalidData,
+            "Last encryptables conversion to bytes failed",
+        ))?;
+
+        let padding_byte = last_block[15];
+
+        if padding_byte == 0 || padding_byte > 16 {
+            return Err(Error::new(ErrorKind::InvalidData, "Invalid padding"));
+        }
+
+        if last_block[16 - padding_byte as usize..]
+            .iter()
+            .any(|&b| b != padding_byte)
+        {
+            return Err(Error::new(ErrorKind::InvalidData, "Inconsistent padding"));
+        }
+
+        // Add the data part of the last block
+        let data_bytes = 16 - padding_byte as usize;
+        result.extend_from_slice(&last_block[..data_bytes]);
+
+        Ok(result)
+    }
+
     /// Create multiple messages from a byte array.
     /// TODO: remove this method, as it cannot handle data that is not a multiple of 16 bytes and padding should generally not belong in this library.
     #[deprecated]