cbc/
encrypt.rs

1use crate::xor;
2use cipher::{
3    consts::U1,
4    crypto_common::{InnerUser, IvSizeUser},
5    generic_array::{ArrayLength, GenericArray},
6    inout::InOut,
7    AlgorithmName, Block, BlockBackend, BlockCipher, BlockClosure, BlockEncryptMut, BlockSizeUser,
8    InnerIvInit, Iv, IvState, ParBlocksSizeUser,
9};
10use core::fmt;
11
12#[cfg(feature = "zeroize")]
13use cipher::zeroize::{Zeroize, ZeroizeOnDrop};
14
15/// CBC mode encryptor.
16#[derive(Clone)]
17pub struct Encryptor<C>
18where
19    C: BlockEncryptMut + BlockCipher,
20{
21    cipher: C,
22    iv: Block<C>,
23}
24
25impl<C> BlockSizeUser for Encryptor<C>
26where
27    C: BlockEncryptMut + BlockCipher,
28{
29    type BlockSize = C::BlockSize;
30}
31
32impl<C> BlockEncryptMut for Encryptor<C>
33where
34    C: BlockEncryptMut + BlockCipher,
35{
36    fn encrypt_with_backend_mut(&mut self, f: impl BlockClosure<BlockSize = Self::BlockSize>) {
37        let Self { cipher, iv } = self;
38        cipher.encrypt_with_backend_mut(Closure { iv, f })
39    }
40}
41
42impl<C> InnerUser for Encryptor<C>
43where
44    C: BlockEncryptMut + BlockCipher,
45{
46    type Inner = C;
47}
48
49impl<C> IvSizeUser for Encryptor<C>
50where
51    C: BlockEncryptMut + BlockCipher,
52{
53    type IvSize = C::BlockSize;
54}
55
56impl<C> InnerIvInit for Encryptor<C>
57where
58    C: BlockEncryptMut + BlockCipher,
59{
60    #[inline]
61    fn inner_iv_init(cipher: C, iv: &Iv<Self>) -> Self {
62        Self {
63            cipher,
64            iv: iv.clone(),
65        }
66    }
67}
68
69impl<C> IvState for Encryptor<C>
70where
71    C: BlockEncryptMut + BlockCipher,
72{
73    #[inline]
74    fn iv_state(&self) -> Iv<Self> {
75        self.iv.clone()
76    }
77}
78
79impl<C> AlgorithmName for Encryptor<C>
80where
81    C: BlockEncryptMut + BlockCipher + AlgorithmName,
82{
83    fn write_alg_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
84        f.write_str("cbc::Encryptor<")?;
85        <C as AlgorithmName>::write_alg_name(f)?;
86        f.write_str(">")
87    }
88}
89
90impl<C> fmt::Debug for Encryptor<C>
91where
92    C: BlockEncryptMut + BlockCipher + AlgorithmName,
93{
94    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
95        f.write_str("cbc::Encryptor<")?;
96        <C as AlgorithmName>::write_alg_name(f)?;
97        f.write_str("> { ... }")
98    }
99}
100
101#[cfg(feature = "zeroize")]
102#[cfg_attr(docsrs, doc(cfg(feature = "zeroize")))]
103impl<C: BlockEncryptMut + BlockCipher> Drop for Encryptor<C> {
104    fn drop(&mut self) {
105        self.iv.zeroize();
106    }
107}
108
109#[cfg(feature = "zeroize")]
110#[cfg_attr(docsrs, doc(cfg(feature = "zeroize")))]
111impl<C: BlockEncryptMut + BlockCipher + ZeroizeOnDrop> ZeroizeOnDrop for Encryptor<C> {}
112
113struct Closure<'a, BS, BC>
114where
115    BS: ArrayLength<u8>,
116    BC: BlockClosure<BlockSize = BS>,
117{
118    iv: &'a mut GenericArray<u8, BS>,
119    f: BC,
120}
121
122impl<'a, BS, BC> BlockSizeUser for Closure<'a, BS, BC>
123where
124    BS: ArrayLength<u8>,
125    BC: BlockClosure<BlockSize = BS>,
126{
127    type BlockSize = BS;
128}
129
130impl<'a, BS, BC> BlockClosure for Closure<'a, BS, BC>
131where
132    BS: ArrayLength<u8>,
133    BC: BlockClosure<BlockSize = BS>,
134{
135    #[inline(always)]
136    fn call<B: BlockBackend<BlockSize = Self::BlockSize>>(self, backend: &mut B) {
137        let Self { iv, f } = self;
138        f.call(&mut Backend { iv, backend });
139    }
140}
141
142struct Backend<'a, BS, BK>
143where
144    BS: ArrayLength<u8>,
145    BK: BlockBackend<BlockSize = BS>,
146{
147    iv: &'a mut GenericArray<u8, BS>,
148    backend: &'a mut BK,
149}
150
151impl<'a, BS, BK> BlockSizeUser for Backend<'a, BS, BK>
152where
153    BS: ArrayLength<u8>,
154    BK: BlockBackend<BlockSize = BS>,
155{
156    type BlockSize = BS;
157}
158
159impl<'a, BS, BK> ParBlocksSizeUser for Backend<'a, BS, BK>
160where
161    BS: ArrayLength<u8>,
162    BK: BlockBackend<BlockSize = BS>,
163{
164    type ParBlocksSize = U1;
165}
166
167impl<'a, BS, BK> BlockBackend for Backend<'a, BS, BK>
168where
169    BS: ArrayLength<u8>,
170    BK: BlockBackend<BlockSize = BS>,
171{
172    #[inline(always)]
173    fn proc_block(&mut self, mut block: InOut<'_, '_, Block<Self>>) {
174        let mut t = block.clone_in();
175        xor(&mut t, self.iv);
176        self.backend.proc_block((&mut t).into());
177        *self.iv = t.clone();
178        *block.get_out() = t;
179    }
180}
cbc/encrypt.rs

cbc/
encrypt.rs
