cbc/
decrypt.rs

1use crate::xor;
2use cipher::{
3    AlgorithmName, Block, BlockCipherDecBackend, BlockCipherDecClosure, BlockCipherDecrypt,
4    BlockModeDecBackend, BlockModeDecClosure, BlockModeDecrypt, BlockSizeUser, InnerIvInit, Iv,
5    IvState, ParBlocks, ParBlocksSizeUser, SetIvState,
6    array::{Array, ArraySize},
7    common::{InnerUser, IvSizeUser},
8    inout::InOut,
9};
10use core::fmt;
11
12#[cfg(feature = "zeroize")]
13use cipher::zeroize::{Zeroize, ZeroizeOnDrop};
14
15/// CBC mode decryptor.
16pub struct Decryptor<C>
17where
18    C: BlockCipherDecrypt,
19{
20    cipher: C,
21    iv: Block<C>,
22}
23
24impl<C> BlockSizeUser for Decryptor<C>
25where
26    C: BlockCipherDecrypt,
27{
28    type BlockSize = C::BlockSize;
29}
30
31impl<C> BlockModeDecrypt for Decryptor<C>
32where
33    C: BlockCipherDecrypt,
34{
35    fn decrypt_with_backend(&mut self, f: impl BlockModeDecClosure<BlockSize = Self::BlockSize>) {
36        struct Closure<'a, BS, BC>
37        where
38            BS: ArraySize,
39            BC: BlockModeDecClosure<BlockSize = BS>,
40        {
41            iv: &'a mut Array<u8, BS>,
42            f: BC,
43        }
44
45        impl<BS, BC> BlockSizeUser for Closure<'_, BS, BC>
46        where
47            BS: ArraySize,
48            BC: BlockModeDecClosure<BlockSize = BS>,
49        {
50            type BlockSize = BS;
51        }
52
53        impl<BS, BC> BlockCipherDecClosure for Closure<'_, BS, BC>
54        where
55            BS: ArraySize,
56            BC: BlockModeDecClosure<BlockSize = BS>,
57        {
58            #[inline(always)]
59            fn call<B: BlockCipherDecBackend<BlockSize = Self::BlockSize>>(
60                self,
61                cipher_backend: &B,
62            ) {
63                let Self { iv, f } = self;
64                f.call(&mut Backend { iv, cipher_backend });
65            }
66        }
67
68        let Self { cipher, iv } = self;
69        cipher.decrypt_with_backend(Closure { iv, f });
70    }
71}
72
73impl<C> InnerUser for Decryptor<C>
74where
75    C: BlockCipherDecrypt,
76{
77    type Inner = C;
78}
79
80impl<C> IvSizeUser for Decryptor<C>
81where
82    C: BlockCipherDecrypt,
83{
84    type IvSize = C::BlockSize;
85}
86
87impl<C> InnerIvInit for Decryptor<C>
88where
89    C: BlockCipherDecrypt,
90{
91    #[inline]
92    fn inner_iv_init(cipher: C, iv: &Iv<Self>) -> Self {
93        Self {
94            cipher,
95            iv: iv.clone(),
96        }
97    }
98}
99
100impl<C> IvState for Decryptor<C>
101where
102    C: BlockCipherDecrypt,
103{
104    #[inline]
105    fn iv_state(&self) -> Iv<Self> {
106        self.iv.clone()
107    }
108}
109
110impl<C> SetIvState for Decryptor<C>
111where
112    C: BlockCipherDecrypt,
113{
114    #[inline]
115    fn set_iv(&mut self, iv: &Iv<Self>) {
116        self.iv = iv.clone();
117    }
118}
119
120impl<C> AlgorithmName for Decryptor<C>
121where
122    C: BlockCipherDecrypt + AlgorithmName,
123{
124    fn write_alg_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
125        f.write_str("cbc::Decryptor<")?;
126        <C as AlgorithmName>::write_alg_name(f)?;
127        f.write_str(">")
128    }
129}
130
131impl<C> fmt::Debug for Decryptor<C>
132where
133    C: BlockCipherDecrypt + AlgorithmName,
134{
135    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
136        f.write_str("cbc::Decryptor<")?;
137        <C as AlgorithmName>::write_alg_name(f)?;
138        f.write_str("> { ... }")
139    }
140}
141
142impl<C: BlockCipherDecrypt> Drop for Decryptor<C> {
143    fn drop(&mut self) {
144        #[cfg(feature = "zeroize")]
145        self.iv.zeroize();
146    }
147}
148
149#[cfg(feature = "zeroize")]
150impl<C: BlockCipherDecrypt + ZeroizeOnDrop> ZeroizeOnDrop for Decryptor<C> {}
151
152struct Backend<'a, BS, BK>
153where
154    BS: ArraySize,
155    BK: BlockCipherDecBackend<BlockSize = BS>,
156{
157    iv: &'a mut Array<u8, BS>,
158    cipher_backend: &'a BK,
159}
160
161impl<BS, BK> BlockSizeUser for Backend<'_, BS, BK>
162where
163    BS: ArraySize,
164    BK: BlockCipherDecBackend<BlockSize = BS>,
165{
166    type BlockSize = BS;
167}
168
169impl<BS, BK> ParBlocksSizeUser for Backend<'_, BS, BK>
170where
171    BS: ArraySize,
172    BK: BlockCipherDecBackend<BlockSize = BS>,
173{
174    type ParBlocksSize = BK::ParBlocksSize;
175}
176
177impl<BS, BK> BlockModeDecBackend for Backend<'_, BS, BK>
178where
179    BS: ArraySize,
180    BK: BlockCipherDecBackend<BlockSize = BS>,
181{
182    #[inline(always)]
183    fn decrypt_block(&mut self, mut block: InOut<'_, '_, Block<Self>>) {
184        let in_block = block.clone_in();
185        let mut t = block.clone_in();
186        self.cipher_backend.decrypt_block((&mut t).into());
187        xor(&mut t, self.iv);
188        *block.get_out() = t;
189        *self.iv = in_block;
190    }
191
192    #[inline(always)]
193    fn decrypt_par_blocks(&mut self, mut blocks: InOut<'_, '_, ParBlocks<Self>>) {
194        let in_blocks = blocks.clone_in();
195        let mut t = blocks.clone_in();
196
197        self.cipher_backend.decrypt_par_blocks((&mut t).into());
198        let n = t.len();
199        xor(&mut t[0], self.iv);
200        for i in 1..n {
201            xor(&mut t[i], &in_blocks[i - 1]);
202        }
203        *blocks.get_out() = t;
204        *self.iv = in_blocks[n - 1].clone();
205    }
206}
cbc/decrypt.rs

cbc/
decrypt.rs
