crypto-common: remove BlockSizes trait

cipher/CHANGELOG.md

@@ -6,12 +6,19 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## 0.5.1 (UNRELEASED)
+### Changed
+- Block sizes no longer bounded by `crypto_common::BlockSizes` ([#2309])
+- `StreamCipherCoreWrapper` is now bounded by `block_buffer::BlockSizes`
+  instead of `crypto_common::BlockSizes` ([#2309])
+- Bump `block-buffer` dependency to v0.12 ([#2309])
+
 ### Fixed
 - `Key:` option in the `stream_cipher_bench` macro ([#2290])
 
 [#2290]: https://github.com/RustCrypto/traits/pull/2290
+[#2309]: https://github.com/RustCrypto/traits/pull/2309
 
-## 0.5.0 (2026-02-04)
+## 0.5.0 (2026-02-04) [YANKED]
 ### Added
 - Traits for tweakable block ciphers ([#1721])
 - Methods for writing keystream ([#1907])

cipher/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cipher"
-version = "0.5.0"
+version = "0.5.1"
 authors = ["RustCrypto Developers"]
 edition = "2024"
 rust-version = "1.85"
@@ -18,7 +18,7 @@ inout = "0.2.2"
 
 # optional dependencies
 blobby = { version = "0.4", optional = true }
-block-buffer = { version = "0.11", optional = true }
+block-buffer = { version = "0.12", optional = true }
 zeroize = { version = "1.8", optional = true, default-features = false }
 
 [dev-dependencies]

cipher/src/block/ctx.rs

@@ -1,4 +1,4 @@
-use common::{Block, BlockSizeUser, BlockSizes, typenum::Unsigned};
+use common::{Block, BlockSizeUser, array::ArraySize, typenum::Unsigned};
 use inout::{InOut, InOutBuf};
 
 use super::{
@@ -7,51 +7,51 @@ use super::{
 };
 
 /// Closure used in methods which operate over separate blocks.
-pub(super) struct BlockCtx<'inp, 'out, BS: BlockSizes> {
+pub(super) struct BlockCtx<'inp, 'out, BS: ArraySize> {
     pub block: InOut<'inp, 'out, Block<Self>>,
 }
 
-impl<BS: BlockSizes> BlockSizeUser for BlockCtx<'_, '_, BS> {
+impl<BS: ArraySize> BlockSizeUser for BlockCtx<'_, '_, BS> {
     type BlockSize = BS;
 }
 
-impl<BS: BlockSizes> BlockCipherEncClosure for BlockCtx<'_, '_, BS> {
+impl<BS: ArraySize> BlockCipherEncClosure for BlockCtx<'_, '_, BS> {
     #[inline(always)]
     fn call<B: BlockCipherEncBackend<BlockSize = BS>>(self, backend: &B) {
         backend.encrypt_block(self.block);
     }
 }
 
-impl<BS: BlockSizes> BlockCipherDecClosure for BlockCtx<'_, '_, BS> {
+impl<BS: ArraySize> BlockCipherDecClosure for BlockCtx<'_, '_, BS> {
     #[inline(always)]
     fn call<B: BlockCipherDecBackend<BlockSize = BS>>(self, backend: &B) {
         backend.decrypt_block(self.block);
     }
 }
 
-impl<BS: BlockSizes> BlockModeEncClosure for BlockCtx<'_, '_, BS> {
+impl<BS: ArraySize> BlockModeEncClosure for BlockCtx<'_, '_, BS> {
     #[inline(always)]
     fn call<B: BlockModeEncBackend<BlockSize = BS>>(self, backend: &mut B) {
         backend.encrypt_block(self.block);
     }
 }
 
-impl<BS: BlockSizes> BlockModeDecClosure for BlockCtx<'_, '_, BS> {
+impl<BS: ArraySize> BlockModeDecClosure for BlockCtx<'_, '_, BS> {
     #[inline(always)]
     fn call<B: BlockModeDecBackend<BlockSize = BS>>(self, backend: &mut B) {
         backend.decrypt_block(self.block);
     }
 }
 /// Closure used in methods which operate over slice of blocks.
-pub(super) struct BlocksCtx<'inp, 'out, BS: BlockSizes> {
+pub(super) struct BlocksCtx<'inp, 'out, BS: ArraySize> {
     pub blocks: InOutBuf<'inp, 'out, Block<Self>>,
 }
 
-impl<BS: BlockSizes> BlockSizeUser for BlocksCtx<'_, '_, BS> {
+impl<BS: ArraySize> BlockSizeUser for BlocksCtx<'_, '_, BS> {
     type BlockSize = BS;
 }
 
-impl<BS: BlockSizes> BlockCipherEncClosure for BlocksCtx<'_, '_, BS> {
+impl<BS: ArraySize> BlockCipherEncClosure for BlocksCtx<'_, '_, BS> {
     #[inline(always)]
     fn call<B: BlockCipherEncBackend<BlockSize = BS>>(self, backend: &B) {
         if B::ParBlocksSize::USIZE > 1 {
@@ -68,7 +68,7 @@ impl<BS: BlockSizes> BlockCipherEncClosure for BlocksCtx<'_, '_, BS> {
     }
 }
 
-impl<BS: BlockSizes> BlockCipherDecClosure for BlocksCtx<'_, '_, BS> {
+impl<BS: ArraySize> BlockCipherDecClosure for BlocksCtx<'_, '_, BS> {
     #[inline(always)]
     fn call<B: BlockCipherDecBackend<BlockSize = BS>>(self, backend: &B) {
         if B::ParBlocksSize::USIZE > 1 {
@@ -85,7 +85,7 @@ impl<BS: BlockSizes> BlockCipherDecClosure for BlocksCtx<'_, '_, BS> {
     }
 }
 
-impl<BS: BlockSizes> BlockModeEncClosure for BlocksCtx<'_, '_, BS> {
+impl<BS: ArraySize> BlockModeEncClosure for BlocksCtx<'_, '_, BS> {
     #[inline(always)]
     fn call<B: BlockModeEncBackend<BlockSize = BS>>(self, backend: &mut B) {
         if B::ParBlocksSize::USIZE > 1 {
@@ -102,7 +102,7 @@ impl<BS: BlockSizes> BlockModeEncClosure for BlocksCtx<'_, '_, BS> {
     }
 }
 
-impl<BS: BlockSizes> BlockModeDecClosure for BlocksCtx<'_, '_, BS> {
+impl<BS: ArraySize> BlockModeDecClosure for BlocksCtx<'_, '_, BS> {
     #[inline(always)]
     fn call<B: BlockModeDecBackend<BlockSize = BS>>(self, backend: &mut B) {
         if B::ParBlocksSize::USIZE > 1 {

cipher/src/stream/core_api.rs

@@ -1,6 +1,9 @@
 use super::StreamCipherError;
-use crate::{array::Array, typenum::Unsigned};
-use common::{Block, BlockSizeUser, BlockSizes, ParBlocks, ParBlocksSizeUser};
+use crate::{
+    array::{Array, ArraySize},
+    typenum::Unsigned,
+};
+use common::{Block, BlockSizeUser, ParBlocks, ParBlocksSizeUser};
 use inout::{InOut, InOutBuf};
 
 /// Trait implemented by stream cipher backends.
@@ -197,26 +200,28 @@ macro_rules! impl_counter {
 
 impl_counter! { u32 u64 u128 }
 
-struct WriteBlockCtx<'a, BS: BlockSizes> {
+struct WriteBlockCtx<'a, BS: ArraySize> {
     block: &'a mut Block<Self>,
 }
-impl<BS: BlockSizes> BlockSizeUser for WriteBlockCtx<'_, BS> {
+impl<BS: ArraySize> BlockSizeUser for WriteBlockCtx<'_, BS> {
     type BlockSize = BS;
 }
-impl<BS: BlockSizes> StreamCipherClosure for WriteBlockCtx<'_, BS> {
+impl<BS: ArraySize> StreamCipherClosure for WriteBlockCtx<'_, BS> {
     #[inline(always)]
     fn call<B: StreamCipherBackend<BlockSize = BS>>(self, backend: &mut B) {
         backend.gen_ks_block(self.block);
     }
 }
 
-struct WriteBlocksCtx<'a, BS: BlockSizes> {
+struct WriteBlocksCtx<'a, BS: ArraySize> {
     blocks: &'a mut [Block<Self>],
 }
-impl<BS: BlockSizes> BlockSizeUser for WriteBlocksCtx<'_, BS> {
+
+impl<BS: ArraySize> BlockSizeUser for WriteBlocksCtx<'_, BS> {
     type BlockSize = BS;
 }
-impl<BS: BlockSizes> StreamCipherClosure for WriteBlocksCtx<'_, BS> {
+
+impl<BS: ArraySize> StreamCipherClosure for WriteBlocksCtx<'_, BS> {
     #[inline(always)]
     fn call<B: StreamCipherBackend<BlockSize = BS>>(self, backend: &mut B) {
         if B::ParBlocksSize::USIZE > 1 {
@@ -233,15 +238,15 @@ impl<BS: BlockSizes> StreamCipherClosure for WriteBlocksCtx<'_, BS> {
     }
 }
 
-struct ApplyBlockCtx<'inp, 'out, BS: BlockSizes> {
+struct ApplyBlockCtx<'inp, 'out, BS: ArraySize> {
     block: InOut<'inp, 'out, Block<Self>>,
 }
 
-impl<BS: BlockSizes> BlockSizeUser for ApplyBlockCtx<'_, '_, BS> {
+impl<BS: ArraySize> BlockSizeUser for ApplyBlockCtx<'_, '_, BS> {
     type BlockSize = BS;
 }
 
-impl<BS: BlockSizes> StreamCipherClosure for ApplyBlockCtx<'_, '_, BS> {
+impl<BS: ArraySize> StreamCipherClosure for ApplyBlockCtx<'_, '_, BS> {
     #[inline(always)]
     fn call<B: StreamCipherBackend<BlockSize = BS>>(mut self, backend: &mut B) {
         let mut t = Default::default();
@@ -250,15 +255,15 @@ impl<BS: BlockSizes> StreamCipherClosure for ApplyBlockCtx<'_, '_, BS> {
     }
 }
 
-struct ApplyBlocksCtx<'inp, 'out, BS: BlockSizes> {
+struct ApplyBlocksCtx<'inp, 'out, BS: ArraySize> {
     blocks: InOutBuf<'inp, 'out, Block<Self>>,
 }
 
-impl<BS: BlockSizes> BlockSizeUser for ApplyBlocksCtx<'_, '_, BS> {
+impl<BS: ArraySize> BlockSizeUser for ApplyBlocksCtx<'_, '_, BS> {
     type BlockSize = BS;
 }
 
-impl<BS: BlockSizes> StreamCipherClosure for ApplyBlocksCtx<'_, '_, BS> {
+impl<BS: ArraySize> StreamCipherClosure for ApplyBlocksCtx<'_, '_, BS> {
     #[inline(always)]
     #[allow(clippy::needless_range_loop)]
     fn call<B: StreamCipherBackend<BlockSize = BS>>(self, backend: &mut B) {