ecb/
encrypt.rs

1use cipher::{
2    AlgorithmName, Block, BlockCipherEncBackend, BlockCipherEncClosure, BlockCipherEncrypt,
3    BlockModeEncBackend, BlockModeEncClosure, BlockModeEncrypt, BlockSizeUser, InOut, InOutBuf,
4    ParBlocks, ParBlocksSizeUser,
5    array::ArraySize,
6    common::{InnerInit, InnerUser},
7};
8use core::fmt;
9
10/// ECB mode encryptor.
11#[derive(Clone)]
12pub struct Encryptor<C>
13where
14    C: BlockCipherEncrypt,
15{
16    cipher: C,
17}
18
19impl<C> BlockSizeUser for Encryptor<C>
20where
21    C: BlockCipherEncrypt,
22{
23    type BlockSize = C::BlockSize;
24}
25
26impl<C> BlockModeEncrypt for Encryptor<C>
27where
28    C: BlockCipherEncrypt,
29{
30    fn encrypt_with_backend(&mut self, f: impl BlockModeEncClosure<BlockSize = Self::BlockSize>) {
31        let Self { cipher } = self;
32        cipher.encrypt_with_backend(Closure { f })
33    }
34}
35
36impl<C> InnerUser for Encryptor<C>
37where
38    C: BlockCipherEncrypt,
39{
40    type Inner = C;
41}
42
43impl<C> InnerInit for Encryptor<C>
44where
45    C: BlockCipherEncrypt,
46{
47    #[inline]
48    fn inner_init(cipher: C) -> Self {
49        Self { cipher }
50    }
51}
52
53impl<C> AlgorithmName for Encryptor<C>
54where
55    C: BlockCipherEncrypt + AlgorithmName,
56{
57    fn write_alg_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
58        f.write_str("ecb::Encryptor<")?;
59        <C as AlgorithmName>::write_alg_name(f)?;
60        f.write_str(">")
61    }
62}
63
64impl<C> fmt::Debug for Encryptor<C>
65where
66    C: BlockCipherEncrypt + AlgorithmName,
67{
68    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
69        f.write_str("ecb::Encryptor<")?;
70        <C as AlgorithmName>::write_alg_name(f)?;
71        f.write_str("> { ... }")
72    }
73}
74
75struct Closure<BS, BC>
76where
77    BS: ArraySize,
78    BC: BlockModeEncClosure<BlockSize = BS>,
79{
80    f: BC,
81}
82
83impl<BS, BC> BlockSizeUser for Closure<BS, BC>
84where
85    BS: ArraySize,
86    BC: BlockModeEncClosure<BlockSize = BS>,
87{
88    type BlockSize = BS;
89}
90
91impl<BS, BC> BlockCipherEncClosure for Closure<BS, BC>
92where
93    BS: ArraySize,
94    BC: BlockModeEncClosure<BlockSize = BS>,
95{
96    #[inline(always)]
97    fn call<B: BlockCipherEncBackend<BlockSize = Self::BlockSize>>(self, cipher_backend: &B) {
98        let Self { f } = self;
99        f.call(&mut Backend { cipher_backend });
100    }
101}
102
103struct Backend<'a, BS, BK>
104where
105    BS: ArraySize,
106    BK: BlockCipherEncBackend<BlockSize = BS>,
107{
108    cipher_backend: &'a BK,
109}
110
111impl<'a, BS, BK> BlockSizeUser for Backend<'a, BS, BK>
112where
113    BS: ArraySize,
114    BK: BlockCipherEncBackend<BlockSize = BS>,
115{
116    type BlockSize = BS;
117}
118
119impl<'a, BS, BK> ParBlocksSizeUser for Backend<'a, BS, BK>
120where
121    BS: ArraySize,
122    BK: BlockCipherEncBackend<BlockSize = BS>,
123{
124    type ParBlocksSize = BK::ParBlocksSize;
125}
126
127impl<'a, BS, BK> BlockModeEncBackend for Backend<'a, BS, BK>
128where
129    BS: ArraySize,
130    BK: BlockCipherEncBackend<BlockSize = BS>,
131{
132    #[inline(always)]
133    fn encrypt_block(&mut self, block: InOut<'_, '_, Block<Self>>) {
134        self.cipher_backend.encrypt_block(block);
135    }
136
137    #[inline(always)]
138    fn encrypt_par_blocks(&mut self, blocks: InOut<'_, '_, ParBlocks<Self>>) {
139        self.cipher_backend.encrypt_par_blocks(blocks);
140    }
141
142    #[inline(always)]
143    fn encrypt_tail_blocks(&mut self, blocks: InOutBuf<'_, '_, Block<Self>>) {
144        self.cipher_backend.encrypt_tail_blocks(blocks);
145    }
146}
ecb/encrypt.rs

ecb/
encrypt.rs
