inout: fix output buffer length check in InOutBufReserved::into_padded_blocks (#1560)

`InOutBufReserved` only guarantees that the output buffer is at least as
large as the input buffer. During the refactoring in #1556, the check
that ensured the output buffer had enough space for the tail block was
accidentally removed. Lack of the check allows to break the invariant
important for the unsafe code in `PaddedInOutBuf` methods.

Author: newpavlov

inout/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 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.2.4 (UNRELEASED)
+### Fixed
+- Output buffer length check in `InOutBufReserved::into_padded_blocks` ([#1559])
+
+[#1559]: https://github.com/RustCrypto/utils/pull/1559
+
 ## 0.2.3 (2026-10-14)
 ### Fixed
 - List of safety pre-conditions in `InOutBufReserved::from_raw` docs ([#1502])

inout/src/reserved.rs

@@ -175,13 +175,30 @@ impl<'inp, 'out> InOutBufReserved<'inp, 'out, u8> {
         BS: ArraySize,
     {
         use block_padding::PaddedData;
+        let out_blocks_len = self.out_len / BS::USIZE;
+
         let (blocks, tail_block) = match P::pad_detached(self.get_in()) {
-            PaddedData::Pad { blocks, tail_block } => (blocks, Some(tail_block)),
-            PaddedData::NoPad { blocks } => (blocks, None),
+            PaddedData::Pad { blocks, tail_block } => {
+                // If tail block is present, the output buffer must contain
+                // at least `blocks.len() + 1` full blocks
+                if out_blocks_len <= blocks.len() {
+                    return Err(PadError);
+                }
+                (blocks, Some(tail_block))
+            }
+            PaddedData::NoPad { blocks } => {
+                // If tail block is not present, the output buffer must contain
+                // at least `blocks.len()` full blocks
+                if out_blocks_len < blocks.len() {
+                    return Err(PadError);
+                }
+                (blocks, None)
+            }
             PaddedData::Error => return Err(PadError),
         };
 
-        assert_eq!(blocks.len(), self.in_len / BS::USIZE);
+        // This invariant must hold for all valid padding implementations.
+        debug_assert_eq!(blocks.len(), self.in_len / BS::USIZE);
 
         Ok(PaddedInOutBuf {
             in_ptr: blocks.as_ptr(),

inout/tests/reserved.rs

@@ -3,7 +3,7 @@
 use hybrid_array::sizes::U16;
 use inout::{
     InOutBufReserved,
-    block_padding::{Iso7816, Padding},
+    block_padding::{Iso7816, Padding, Pkcs7},
 };
 
 #[test]
@@ -29,3 +29,50 @@ fn padded_inout_buf_reserved() {
     let out = padded_blocks.into_out();
     assert_eq!(out, &[0xFF; 48]);
 }
+
+#[test]
+fn reserved_invalid_lengths() {
+    let msg = [42; 32];
+    let mut buf = [0; 32];
+
+    for msg_len in 0..msg.len() {
+        let msg = &msg[..msg_len];
+        for out_len in 0..buf.len() {
+            let out_buf = &mut buf[..out_len];
+
+            let reserved = match InOutBufReserved::from_slices(msg, out_buf) {
+                Ok(r) => r,
+                Err(_) => {
+                    assert!(msg_len > out_len);
+                    continue;
+                }
+            };
+
+            assert!(msg_len <= out_len);
+
+            let full_blocks = msg_len / 16;
+            let out_blocks = out_len / 16;
+
+            let mut padded = match reserved.into_padded_blocks::<Pkcs7, U16>() {
+                Ok(r) => r,
+                Err(_) => {
+                    assert!(out_blocks <= full_blocks);
+                    continue;
+                }
+            };
+
+            assert!(out_blocks > full_blocks);
+
+            // Access the referenced memory to check it with Miri
+            let mut full_blocks = padded.get_blocks();
+            full_blocks.get_in().to_vec();
+            full_blocks.get_out().to_vec();
+
+            let mut tail_block = padded.get_tail_block().unwrap();
+            tail_block.get_in().to_vec();
+            tail_block.get_out().to_vec();
+
+            padded.into_out().to_vec();
+        }
+    }
+}