cipher/block/
ctx.rs

1use common::{Block, BlockSizeUser, array::ArraySize, typenum::Unsigned};
2use inout::{InOut, InOutBuf};
3
4use super::{
5    BlockCipherDecBackend, BlockCipherDecClosure, BlockCipherEncBackend, BlockCipherEncClosure,
6    BlockModeDecBackend, BlockModeDecClosure, BlockModeEncBackend, BlockModeEncClosure,
7};
8
9/// Closure used in methods which operate over separate blocks.
10pub(super) struct BlockCtx<'inp, 'out, BS: ArraySize> {
11    pub block: InOut<'inp, 'out, Block<Self>>,
12}
13
14impl<BS: ArraySize> BlockSizeUser for BlockCtx<'_, '_, BS> {
15    type BlockSize = BS;
16}
17
18impl<BS: ArraySize> BlockCipherEncClosure for BlockCtx<'_, '_, BS> {
19    #[inline(always)]
20    fn call<B: BlockCipherEncBackend<BlockSize = BS>>(self, backend: &B) {
21        backend.encrypt_block(self.block);
22    }
23}
24
25impl<BS: ArraySize> BlockCipherDecClosure for BlockCtx<'_, '_, BS> {
26    #[inline(always)]
27    fn call<B: BlockCipherDecBackend<BlockSize = BS>>(self, backend: &B) {
28        backend.decrypt_block(self.block);
29    }
30}
31
32impl<BS: ArraySize> BlockModeEncClosure for BlockCtx<'_, '_, BS> {
33    #[inline(always)]
34    fn call<B: BlockModeEncBackend<BlockSize = BS>>(self, backend: &mut B) {
35        backend.encrypt_block(self.block);
36    }
37}
38
39impl<BS: ArraySize> BlockModeDecClosure for BlockCtx<'_, '_, BS> {
40    #[inline(always)]
41    fn call<B: BlockModeDecBackend<BlockSize = BS>>(self, backend: &mut B) {
42        backend.decrypt_block(self.block);
43    }
44}
45/// Closure used in methods which operate over slice of blocks.
46pub(super) struct BlocksCtx<'inp, 'out, BS: ArraySize> {
47    pub blocks: InOutBuf<'inp, 'out, Block<Self>>,
48}
49
50impl<BS: ArraySize> BlockSizeUser for BlocksCtx<'_, '_, BS> {
51    type BlockSize = BS;
52}
53
54impl<BS: ArraySize> BlockCipherEncClosure for BlocksCtx<'_, '_, BS> {
55    #[inline(always)]
56    fn call<B: BlockCipherEncBackend<BlockSize = BS>>(self, backend: &B) {
57        if B::ParBlocksSize::USIZE > 1 {
58            let (chunks, tail) = self.blocks.into_chunks();
59            for chunk in chunks {
60                backend.encrypt_par_blocks(chunk);
61            }
62            backend.encrypt_tail_blocks(tail);
63        } else {
64            for block in self.blocks {
65                backend.encrypt_block(block);
66            }
67        }
68    }
69}
70
71impl<BS: ArraySize> BlockCipherDecClosure for BlocksCtx<'_, '_, BS> {
72    #[inline(always)]
73    fn call<B: BlockCipherDecBackend<BlockSize = BS>>(self, backend: &B) {
74        if B::ParBlocksSize::USIZE > 1 {
75            let (chunks, tail) = self.blocks.into_chunks();
76            for chunk in chunks {
77                backend.decrypt_par_blocks(chunk);
78            }
79            backend.decrypt_tail_blocks(tail);
80        } else {
81            for block in self.blocks {
82                backend.decrypt_block(block);
83            }
84        }
85    }
86}
87
88impl<BS: ArraySize> BlockModeEncClosure for BlocksCtx<'_, '_, BS> {
89    #[inline(always)]
90    fn call<B: BlockModeEncBackend<BlockSize = BS>>(self, backend: &mut B) {
91        if B::ParBlocksSize::USIZE > 1 {
92            let (chunks, tail) = self.blocks.into_chunks();
93            for chunk in chunks {
94                backend.encrypt_par_blocks(chunk);
95            }
96            backend.encrypt_tail_blocks(tail);
97        } else {
98            for block in self.blocks {
99                backend.encrypt_block(block);
100            }
101        }
102    }
103}
104
105impl<BS: ArraySize> BlockModeDecClosure for BlocksCtx<'_, '_, BS> {
106    #[inline(always)]
107    fn call<B: BlockModeDecBackend<BlockSize = BS>>(self, backend: &mut B) {
108        if B::ParBlocksSize::USIZE > 1 {
109            let (chunks, tail) = self.blocks.into_chunks();
110            for chunk in chunks {
111                backend.decrypt_par_blocks(chunk);
112            }
113            backend.decrypt_tail_blocks(tail);
114        } else {
115            for block in self.blocks {
116                backend.decrypt_block(block);
117            }
118        }
119    }
120}
cipher/block/ctx.rs

cipher/block/
ctx.rs
