Skip to content

Commit 3044082

Browse files
newpavlovnewpavlov
authored
crypto-common: remove BlockSizes trait (#2309)
`BlockSizeUser` is no longer limited by block sizes smaller than 256 bytes. `BlockSizes` was moved to `block-buffer` (see RustCrypto/utils#1455) and used in bounds only where it's needed.
1 parent e42238d commit 3044082

16 files changed

Lines changed: 201 additions & 102 deletions

File tree

‎Cargo.lock‎

Lines changed: 13 additions & 13 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎cipher/CHANGELOG.md‎

Lines changed: 8 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6,12 +6,19 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
66
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
77

88
## 0.5.1 (UNRELEASED)
9+
### Changed
10+
- Block sizes no longer bounded by `crypto_common::BlockSizes` ([#2309])
11+
- `StreamCipherCoreWrapper` is now bounded by `block_buffer::BlockSizes`
12+
instead of `crypto_common::BlockSizes` ([#2309])
13+
- Bump `block-buffer` dependency to v0.12 ([#2309])
14+
915
### Fixed
1016
- `Key:` option in the `stream_cipher_bench` macro ([#2290])
1117

1218
[#2290]: https://github.com/RustCrypto/traits/pull/2290
19+
[#2309]: https://github.com/RustCrypto/traits/pull/2309
1320

14-
## 0.5.0 (2026-02-04)
21+
## 0.5.0 (2026-02-04) [YANKED]
1522
### Added
1623
- Traits for tweakable block ciphers ([#1721])
1724
- Methods for writing keystream ([#1907])

‎cipher/Cargo.toml‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
[package]
22
name = "cipher"
3-
version = "0.5.0"
3+
version = "0.5.1"
44
authors = ["RustCrypto Developers"]
55
edition = "2024"
66
rust-version = "1.85"
@@ -18,7 +18,7 @@ inout = "0.2.2"
1818

1919
# optional dependencies
2020
blobby = { version = "0.4", optional = true }
21-
block-buffer = { version = "0.11", optional = true }
21+
block-buffer = { version = "0.12", optional = true }
2222
zeroize = { version = "1.8", optional = true, default-features = false }
2323

2424
[dev-dependencies]

‎cipher/src/block/ctx.rs‎

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
use common::{Block, BlockSizeUser, BlockSizes, typenum::Unsigned};
1+
use common::{Block, BlockSizeUser, array::ArraySize, typenum::Unsigned};
22
use inout::{InOut, InOutBuf};
33

44
use super::{
@@ -7,51 +7,51 @@ use super::{
77
};
88

99
/// Closure used in methods which operate over separate blocks.
10-
pub(super) struct BlockCtx<'inp, 'out, BS: BlockSizes> {
10+
pub(super) struct BlockCtx<'inp, 'out, BS: ArraySize> {
1111
pub block: InOut<'inp, 'out, Block<Self>>,
1212
}
1313

14-
impl<BS: BlockSizes> BlockSizeUser for BlockCtx<'_, '_, BS> {
14+
impl<BS: ArraySize> BlockSizeUser for BlockCtx<'_, '_, BS> {
1515
type BlockSize = BS;
1616
}
1717

18-
impl<BS: BlockSizes> BlockCipherEncClosure for BlockCtx<'_, '_, BS> {
18+
impl<BS: ArraySize> BlockCipherEncClosure for BlockCtx<'_, '_, BS> {
1919
#[inline(always)]
2020
fn call<B: BlockCipherEncBackend<BlockSize = BS>>(self, backend: &B) {
2121
backend.encrypt_block(self.block);
2222
}
2323
}
2424

25-
impl<BS: BlockSizes> BlockCipherDecClosure for BlockCtx<'_, '_, BS> {
25+
impl<BS: ArraySize> BlockCipherDecClosure for BlockCtx<'_, '_, BS> {
2626
#[inline(always)]
2727
fn call<B: BlockCipherDecBackend<BlockSize = BS>>(self, backend: &B) {
2828
backend.decrypt_block(self.block);
2929
}
3030
}
3131

32-
impl<BS: BlockSizes> BlockModeEncClosure for BlockCtx<'_, '_, BS> {
32+
impl<BS: ArraySize> BlockModeEncClosure for BlockCtx<'_, '_, BS> {
3333
#[inline(always)]
3434
fn call<B: BlockModeEncBackend<BlockSize = BS>>(self, backend: &mut B) {
3535
backend.encrypt_block(self.block);
3636
}
3737
}
3838

39-
impl<BS: BlockSizes> BlockModeDecClosure for BlockCtx<'_, '_, BS> {
39+
impl<BS: ArraySize> BlockModeDecClosure for BlockCtx<'_, '_, BS> {
4040
#[inline(always)]
4141
fn call<B: BlockModeDecBackend<BlockSize = BS>>(self, backend: &mut B) {
4242
backend.decrypt_block(self.block);
4343
}
4444
}
4545
/// Closure used in methods which operate over slice of blocks.
46-
pub(super) struct BlocksCtx<'inp, 'out, BS: BlockSizes> {
46+
pub(super) struct BlocksCtx<'inp, 'out, BS: ArraySize> {
4747
pub blocks: InOutBuf<'inp, 'out, Block<Self>>,
4848
}
4949

50-
impl<BS: BlockSizes> BlockSizeUser for BlocksCtx<'_, '_, BS> {
50+
impl<BS: ArraySize> BlockSizeUser for BlocksCtx<'_, '_, BS> {
5151
type BlockSize = BS;
5252
}
5353

54-
impl<BS: BlockSizes> BlockCipherEncClosure for BlocksCtx<'_, '_, BS> {
54+
impl<BS: ArraySize> BlockCipherEncClosure for BlocksCtx<'_, '_, BS> {
5555
#[inline(always)]
5656
fn call<B: BlockCipherEncBackend<BlockSize = BS>>(self, backend: &B) {
5757
if B::ParBlocksSize::USIZE > 1 {
@@ -68,7 +68,7 @@ impl<BS: BlockSizes> BlockCipherEncClosure for BlocksCtx<'_, '_, BS> {
6868
}
6969
}
7070

71-
impl<BS: BlockSizes> BlockCipherDecClosure for BlocksCtx<'_, '_, BS> {
71+
impl<BS: ArraySize> BlockCipherDecClosure for BlocksCtx<'_, '_, BS> {
7272
#[inline(always)]
7373
fn call<B: BlockCipherDecBackend<BlockSize = BS>>(self, backend: &B) {
7474
if B::ParBlocksSize::USIZE > 1 {
@@ -85,7 +85,7 @@ impl<BS: BlockSizes> BlockCipherDecClosure for BlocksCtx<'_, '_, BS> {
8585
}
8686
}
8787

88-
impl<BS: BlockSizes> BlockModeEncClosure for BlocksCtx<'_, '_, BS> {
88+
impl<BS: ArraySize> BlockModeEncClosure for BlocksCtx<'_, '_, BS> {
8989
#[inline(always)]
9090
fn call<B: BlockModeEncBackend<BlockSize = BS>>(self, backend: &mut B) {
9191
if B::ParBlocksSize::USIZE > 1 {
@@ -102,7 +102,7 @@ impl<BS: BlockSizes> BlockModeEncClosure for BlocksCtx<'_, '_, BS> {
102102
}
103103
}
104104

105-
impl<BS: BlockSizes> BlockModeDecClosure for BlocksCtx<'_, '_, BS> {
105+
impl<BS: ArraySize> BlockModeDecClosure for BlocksCtx<'_, '_, BS> {
106106
#[inline(always)]
107107
fn call<B: BlockModeDecBackend<BlockSize = BS>>(self, backend: &mut B) {
108108
if B::ParBlocksSize::USIZE > 1 {

‎cipher/src/stream/core_api.rs‎

Lines changed: 19 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,9 @@
11
use super::StreamCipherError;
2-
use crate::{array::Array, typenum::Unsigned};
3-
use common::{Block, BlockSizeUser, BlockSizes, ParBlocks, ParBlocksSizeUser};
2+
use crate::{
3+
array::{Array, ArraySize},
4+
typenum::Unsigned,
5+
};
6+
use common::{Block, BlockSizeUser, ParBlocks, ParBlocksSizeUser};
47
use inout::{InOut, InOutBuf};
58

69
/// Trait implemented by stream cipher backends.
@@ -197,26 +200,28 @@ macro_rules! impl_counter {
197200

198201
impl_counter! { u32 u64 u128 }
199202

200-
struct WriteBlockCtx<'a, BS: BlockSizes> {
203+
struct WriteBlockCtx<'a, BS: ArraySize> {
201204
block: &'a mut Block<Self>,
202205
}
203-
impl<BS: BlockSizes> BlockSizeUser for WriteBlockCtx<'_, BS> {
206+
impl<BS: ArraySize> BlockSizeUser for WriteBlockCtx<'_, BS> {
204207
type BlockSize = BS;
205208
}
206-
impl<BS: BlockSizes> StreamCipherClosure for WriteBlockCtx<'_, BS> {
209+
impl<BS: ArraySize> StreamCipherClosure for WriteBlockCtx<'_, BS> {
207210
#[inline(always)]
208211
fn call<B: StreamCipherBackend<BlockSize = BS>>(self, backend: &mut B) {
209212
backend.gen_ks_block(self.block);
210213
}
211214
}
212215

213-
struct WriteBlocksCtx<'a, BS: BlockSizes> {
216+
struct WriteBlocksCtx<'a, BS: ArraySize> {
214217
blocks: &'a mut [Block<Self>],
215218
}
216-
impl<BS: BlockSizes> BlockSizeUser for WriteBlocksCtx<'_, BS> {
219+
220+
impl<BS: ArraySize> BlockSizeUser for WriteBlocksCtx<'_, BS> {
217221
type BlockSize = BS;
218222
}
219-
impl<BS: BlockSizes> StreamCipherClosure for WriteBlocksCtx<'_, BS> {
223+
224+
impl<BS: ArraySize> StreamCipherClosure for WriteBlocksCtx<'_, BS> {
220225
#[inline(always)]
221226
fn call<B: StreamCipherBackend<BlockSize = BS>>(self, backend: &mut B) {
222227
if B::ParBlocksSize::USIZE > 1 {
@@ -233,15 +238,15 @@ impl<BS: BlockSizes> StreamCipherClosure for WriteBlocksCtx<'_, BS> {
233238
}
234239
}
235240

236-
struct ApplyBlockCtx<'inp, 'out, BS: BlockSizes> {
241+
struct ApplyBlockCtx<'inp, 'out, BS: ArraySize> {
237242
block: InOut<'inp, 'out, Block<Self>>,
238243
}
239244

240-
impl<BS: BlockSizes> BlockSizeUser for ApplyBlockCtx<'_, '_, BS> {
245+
impl<BS: ArraySize> BlockSizeUser for ApplyBlockCtx<'_, '_, BS> {
241246
type BlockSize = BS;
242247
}
243248

244-
impl<BS: BlockSizes> StreamCipherClosure for ApplyBlockCtx<'_, '_, BS> {
249+
impl<BS: ArraySize> StreamCipherClosure for ApplyBlockCtx<'_, '_, BS> {
245250
#[inline(always)]
246251
fn call<B: StreamCipherBackend<BlockSize = BS>>(mut self, backend: &mut B) {
247252
let mut t = Default::default();
@@ -250,15 +255,15 @@ impl<BS: BlockSizes> StreamCipherClosure for ApplyBlockCtx<'_, '_, BS> {
250255
}
251256
}
252257

253-
struct ApplyBlocksCtx<'inp, 'out, BS: BlockSizes> {
258+
struct ApplyBlocksCtx<'inp, 'out, BS: ArraySize> {
254259
blocks: InOutBuf<'inp, 'out, Block<Self>>,
255260
}
256261

257-
impl<BS: BlockSizes> BlockSizeUser for ApplyBlocksCtx<'_, '_, BS> {
262+
impl<BS: ArraySize> BlockSizeUser for ApplyBlocksCtx<'_, '_, BS> {
258263
type BlockSize = BS;
259264
}
260265

261-
impl<BS: BlockSizes> StreamCipherClosure for ApplyBlocksCtx<'_, '_, BS> {
266+
impl<BS: ArraySize> StreamCipherClosure for ApplyBlocksCtx<'_, '_, BS> {
262267
#[inline(always)]
263268
#[allow(clippy::needless_range_loop)]
264269
fn call<B: StreamCipherBackend<BlockSize = BS>>(self, backend: &mut B) {

0 commit comments

Comments
 (0)