bevy_slinet/serializers/
custom_crypt.rs

1//! A custom packet serializer capable of handling encryption and decryption.
2//! Demonstrates usage with mutable serializers that can mutate their internal state.
3
4use std::{
5    error::Error,
6    fmt::{self, Display},
7    marker::PhantomData,
8};
9
10use crate::serializer::MutableSerializer;
11use serde::{Deserialize, Serialize};
12
13/// Represents custom packets sent from the client, allowing different types of content.
14#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
15pub enum CustomCryptClientPacket {
16    String(String),
17}
18
19impl Default for CustomCryptClientPacket {
20    fn default() -> Self {
21        CustomCryptClientPacket::String(String::new())
22    }
23}
24
25/// Represents custom packets received by the server, allowing different types of content.
26#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
27pub enum CustomCryptServerPacket {
28    String(String),
29}
30
31impl Default for CustomCryptServerPacket {
32    fn default() -> Self {
33        CustomCryptServerPacket::String(String::new())
34    }
35}
36
37// Define a custom error type for serialization errors.
38#[derive(Debug)]
39pub struct CustomSerializationError;
40impl Display for CustomSerializationError {
41    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
42        write!(f, "SerializationFailed")
43    }
44}
45
46impl Error for CustomSerializationError {}
47
48/// Defines a trait for cryptographic engines with methods for packet encryption and decryption.
49pub trait CryptEngine<ReceivingPacket, SendingPacket>: Default {
50    fn encrypt(&mut self, packet: SendingPacket) -> Result<Vec<u8>, CustomSerializationError>;
51    fn decrypt(&mut self, packet: &[u8]) -> Result<ReceivingPacket, CustomSerializationError>;
52}
53
54/// A simple key pair structure used for XOR encryption operations.
55#[derive(Debug, Default, Clone)]
56pub struct ExampleKeyPair(u64, u64);
57
58/// A cryptographic engine implementing XOR encryption, typically not secure but used for demonstration.
59#[derive(Debug, Default, Clone)]
60pub struct CustomCryptEngine {
61    key_pair: ExampleKeyPair,
62}
63
64impl CustomCryptEngine {
65    /// Encrypts data using XOR operation and rotates the key to simulate a stream cipher.
66    fn xor_encrypt(&mut self, data: Vec<u8>) -> Vec<u8> {
67        let mut key = self.key_pair.0;
68        let encrypted: Vec<u8> = data
69            .into_iter()
70            .map(|byte| {
71                let result = byte ^ (key as u8);
72                key = key.wrapping_add(1);
73                result
74            })
75            .collect();
76        self.key_pair.0 = key;
77        encrypted
78    }
79
80    /// Decrypts data using XOR operation, ensuring the key is rotated in the same manner as encryption.
81    fn xor_decrypt(&mut self, data: Vec<u8>) -> Vec<u8> {
82        let mut key = self.key_pair.1;
83        let decrypted: Vec<u8> = data
84            .into_iter()
85            .map(|byte| {
86                let result = byte ^ (key as u8);
87                key = key.wrapping_add(1);
88                result
89            })
90            .collect();
91        self.key_pair.1 = key;
92        decrypted
93    }
94}
95
96/// Implements the encryption and decryption processes for specified packet types using the XOR method.
97/// This implement server-side encryption
98impl CryptEngine<CustomCryptClientPacket, CustomCryptServerPacket> for CustomCryptEngine {
99    fn encrypt(
100        &mut self,
101        packet: CustomCryptServerPacket,
102    ) -> Result<Vec<u8>, CustomSerializationError> {
103        let packet_data = bincode::serialize(&packet).unwrap();
104        let encrypted_data = self.xor_encrypt(packet_data);
105        Ok(encrypted_data)
106    }
107
108    fn decrypt(
109        &mut self,
110        packet: &[u8],
111    ) -> Result<CustomCryptClientPacket, CustomSerializationError> {
112        let decrypted_data = self.xor_decrypt(packet.to_vec());
113        let packet = bincode::deserialize(&decrypted_data).unwrap();
114        Ok(packet)
115    }
116}
117// This is the client-side encryption
118impl CryptEngine<CustomCryptServerPacket, CustomCryptClientPacket> for CustomCryptEngine {
119    fn encrypt(
120        &mut self,
121        packet: CustomCryptClientPacket,
122    ) -> Result<Vec<u8>, CustomSerializationError> {
123        let packet_data = bincode::serialize(&packet).unwrap();
124        let encrypted_data = self.xor_encrypt(packet_data);
125        Ok(encrypted_data)
126    }
127
128    fn decrypt(
129        &mut self,
130        packet: &[u8],
131    ) -> Result<CustomCryptServerPacket, CustomSerializationError> {
132        let decrypted_data = self.xor_decrypt(packet.to_vec());
133        let packet = bincode::deserialize(&decrypted_data).unwrap();
134        Ok(packet)
135    }
136}
137
138/// A serializer that integrates encryption, using a cryptographic engine to ensure secure data transmission.
139#[derive(Default, Clone)]
140pub struct CustomCryptSerializer<C, ReceivingPacket, SendingPacket>
141where
142    C: Send + Sync + 'static + CryptEngine<ReceivingPacket, SendingPacket>,
143{
144    crypt_engine: C,
145    _client: PhantomData<ReceivingPacket>,
146    _server: PhantomData<SendingPacket>,
147}
148impl<
149        C: Send + Sync + 'static + CryptEngine<ReceivingPacket, SendingPacket>,
150        SendingPacket,
151        ReceivingPacket,
152    > CustomCryptSerializer<C, ReceivingPacket, SendingPacket>
153where
154    C: Send + Sync + 'static + CryptEngine<ReceivingPacket, SendingPacket>,
155{
156    pub fn new(crypt_engine: C) -> Self {
157        Self {
158            crypt_engine,
159            _client: PhantomData,
160            _server: PhantomData,
161        }
162    }
163}
164impl<ReceivingPacket, SendingPacket, C> MutableSerializer<ReceivingPacket, SendingPacket>
165    for CustomCryptSerializer<C, ReceivingPacket, SendingPacket>
166where
167    C: Send + Sync + 'static + CryptEngine<ReceivingPacket, SendingPacket>,
168    ReceivingPacket: Send + Sync + 'static,
169    SendingPacket: Send + Sync + 'static,
170{
171    type Error = CustomSerializationError;
172
173    /// Serializes a packet into a byte vector.
174    fn serialize(&mut self, packet: SendingPacket) -> Result<Vec<u8>, Self::Error> {
175        Ok(self.crypt_engine.encrypt(packet).unwrap())
176    }
177
178    /// Deserializes a packet from a byte slice
179    fn deserialize(&mut self, buffer: &[u8]) -> Result<ReceivingPacket, Self::Error> {
180        match self.crypt_engine.decrypt(buffer) {
181            Ok(encrypted) => Ok(encrypted),
182            Err(e) => {
183                log::error!("{}", e);
184                Err(e)
185            }
186        }
187    }
188}
189
190#[cfg(test)]
191mod tests {
192    use super::*;
193
194    #[test]
195    fn test_xor_encrypt_decrypt() {
196        let mut engine = CustomCryptEngine::default();
197        let data = vec![1, 2, 3, 4, 5];
198
199        let encrypted = engine.xor_encrypt(data.clone());
200        assert_ne!(
201            encrypted, data,
202            "Encrypted data should not be equal to original data"
203        );
204
205        let decrypted = engine.xor_decrypt(encrypted);
206        assert_eq!(
207            decrypted, data,
208            "Decrypted data should be equal to original data"
209        );
210    }
211
212    #[test]
213    fn test_crypt_engine_encrypt_decrypt() {
214        let mut engine = CustomCryptEngine::default();
215        let client_packet = CustomCryptClientPacket::String("Hello, Server!".to_string());
216        let server_packet = CustomCryptServerPacket::String("Hello, Client!".to_string());
217
218        // Client packet encryption and decryption
219        let encrypted = engine.encrypt(client_packet.clone()).unwrap();
220        let decrypted: CustomCryptClientPacket = engine.decrypt(&encrypted).unwrap();
221        assert_eq!(
222            decrypted, client_packet,
223            "Decrypted client packet should be equal to original packet"
224        );
225
226        // Server packet encryption and decryption
227        let encrypted = engine.encrypt(server_packet.clone()).unwrap();
228        let decrypted: CustomCryptServerPacket = engine.decrypt(&encrypted).unwrap();
229        assert_eq!(
230            decrypted, server_packet,
231            "Decrypted server packet should be equal to original packet"
232        );
233    }
234}
bevy_slinet/serializers/custom_crypt.rs

bevy_slinet/serializers/
custom_crypt.rs
