magic_crypt/ciphers/
des64.rs

1use alloc::vec::Vec;
2#[cfg(feature = "std")]
3use std::io::{Read, Write};
4
5#[cfg(feature = "std")]
6use aes::cipher::{
7    array::ArraySize,
8    typenum::{IsGreaterOrEqual, PartialDiv, True, U16},
9};
10use crc_any::CRCu64;
11use des::{
12    Des,
13    cipher::{
14        BlockModeDecrypt, BlockModeEncrypt, Iv, Key, KeyIvInit, array::Array, block_padding::Pkcs7,
15    },
16};
17
18#[cfg(feature = "std")]
19use crate::functions::{
20    decrypt_reader_to_writer as decrypt_stream, encrypt_reader_to_writer as encrypt_stream,
21    to_blocks,
22};
23use crate::{MagicCryptError, MagicCryptTrait};
24
25type Des64CbcEnc = cbc::Encryptor<Des>;
26type Des64CbcDec = cbc::Decryptor<Des>;
27
28#[cfg(feature = "std")]
29const BLOCK_SIZE: usize = 8;
30
31/// This struct can help you encrypt or decrypt data via DES in a quick way.
32#[derive(Clone)]
33pub struct MagicCrypt64 {
34    key: Key<Des64CbcEnc>,
35    iv:  Iv<Des64CbcEnc>,
36}
37
38impl_cipher_secret_traits!(MagicCrypt64);
39
40impl MagicCryptTrait for MagicCrypt64 {
41    fn new<S: AsRef<[u8]>, V: AsRef<[u8]>>(key: S, iv: Option<V>) -> MagicCrypt64 {
42        let iv = match iv {
43            Some(s) => {
44                let mut hasher = CRCu64::crc64we();
45                hasher.digest(s.as_ref());
46
47                Array::try_from(hasher.get_crc_vec_be().as_slice()).unwrap()
48            },
49            None => Array::default(),
50        };
51
52        let key = {
53            let mut hasher = CRCu64::crc64we();
54            hasher.digest(key.as_ref());
55
56            Array::try_from(hasher.get_crc_vec_be().as_slice()).unwrap()
57        };
58
59        MagicCrypt64 {
60            key,
61            iv,
62        }
63    }
64
65    #[inline]
66    fn encrypt_to_bytes<T: ?Sized + AsRef<[u8]>>(&self, data: &T) -> Vec<u8> {
67        let data = data.as_ref();
68
69        let cipher = Des64CbcEnc::new(&self.key, &self.iv);
70
71        cipher.encrypt_padded_vec::<Pkcs7>(data)
72    }
73
74    #[cfg(feature = "std")]
75    fn encrypt_reader_to_bytes(&self, reader: &mut dyn Read) -> Result<Vec<u8>, MagicCryptError> {
76        let mut final_result = Vec::new();
77
78        let data_length = reader.read_to_end(&mut final_result)?;
79
80        let padding_length = BLOCK_SIZE - (data_length % BLOCK_SIZE);
81        let final_length = data_length + padding_length;
82
83        final_result.resize(final_length, 0);
84
85        let cipher = Des64CbcEnc::new(&self.key, &self.iv);
86
87        cipher.encrypt_padded::<Pkcs7>(&mut final_result, data_length).unwrap();
88
89        Ok(final_result)
90    }
91
92    #[cfg(feature = "std")]
93    fn encrypt_reader_to_writer2<
94        N: ArraySize + PartialDiv<U16> + IsGreaterOrEqual<U16, Output = True>,
95    >(
96        &self,
97        reader: &mut dyn Read,
98        writer: &mut dyn Write,
99    ) -> Result<(), MagicCryptError> {
100        let mut cipher = Des64CbcEnc::new(&self.key, &self.iv);
101
102        encrypt_stream::<N>(reader, writer, BLOCK_SIZE, |buffer| {
103            cipher.encrypt_blocks(to_blocks(buffer));
104        })
105    }
106
107    #[inline]
108    fn decrypt_bytes_to_bytes<T: ?Sized + AsRef<[u8]>>(
109        &self,
110        bytes: &T,
111    ) -> Result<Vec<u8>, MagicCryptError> {
112        let bytes = bytes.as_ref();
113
114        let cipher = Des64CbcDec::new(&self.key, &self.iv);
115
116        let final_result = cipher.decrypt_padded_vec::<Pkcs7>(bytes)?;
117
118        Ok(final_result)
119    }
120
121    #[cfg(feature = "std")]
122    fn decrypt_reader_to_bytes(&self, reader: &mut dyn Read) -> Result<Vec<u8>, MagicCryptError> {
123        let mut final_result = Vec::new();
124
125        reader.read_to_end(&mut final_result)?;
126
127        let cipher = Des64CbcDec::new(&self.key, &self.iv);
128
129        let data_length = cipher.decrypt_padded::<Pkcs7>(&mut final_result)?.len();
130
131        final_result.truncate(data_length);
132
133        Ok(final_result)
134    }
135
136    #[cfg(feature = "std")]
137    fn decrypt_reader_to_writer2<
138        N: ArraySize + PartialDiv<U16> + IsGreaterOrEqual<U16, Output = True>,
139    >(
140        &self,
141        reader: &mut dyn Read,
142        writer: &mut dyn Write,
143    ) -> Result<(), MagicCryptError> {
144        let mut cipher = Des64CbcDec::new(&self.key, &self.iv);
145
146        decrypt_stream::<N>(reader, writer, BLOCK_SIZE, |buffer| {
147            cipher.decrypt_blocks(to_blocks(buffer));
148        })
149    }
150}
magic_crypt/ciphers/des64.rs

magic_crypt/ciphers/
des64.rs
