Add constant-time decoded length helper

Author: eldryoth

CHANGELOG.md

@@ -74,6 +74,8 @@
   policy logging uses the same dependency-free formatting surface.
 - Added `Engine::profile()` for explicit dependency-free promotion to an
   unwrapped `Profile`.
+- Added `ct::CtEngine::decoded_len()` so sensitive decode paths can size
+  caller-owned buffers without switching to the diagnostic decoder.
 
 ## 0.8.0 - 2026-05-16
 

README.md

@@ -390,8 +390,9 @@ returning the error. The legacy whitespace profile also provides
 `decode_in_place_wrapped`, `decode_in_place_wrapped_clear_tail`, and the same
 in-place behavior through `Profile::decode_in_place`. The `ct` module provides
 the same clear-tail decode variants for callers using the constant-time-oriented
-scalar decoder, plus `ct::CtEngine::decode_buffer` for stack-backed no-alloc
-decoded output.
+scalar decoder, `ct::CtEngine::decoded_len` for sizing caller-owned buffers
+under the same opaque malformed-input policy, plus
+`ct::CtEngine::decode_buffer` for stack-backed no-alloc decoded output.
 
 For short values, `encode_buffer` returns a stack-backed `EncodedBuffer`
 and `decode_buffer` returns a stack-backed `DecodedBuffer` without requiring

portability/no_alloc_smoke/src/lib.rs

@@ -93,6 +93,9 @@ pub fn ct_stack_decode() -> bool {
     if ct_policy.as_bytes() != b"ct padded=true" {
         return false;
     }
+    if ct::STANDARD.decoded_len(b"aGVsbG8=") != Ok(5) {
+        return false;
+    }
 
     let decoded = match ct::STANDARD.decode_buffer::<5>(b"aGVsbG8=") {
         Ok(decoded) => decoded,

src/lib.rs

@@ -1671,7 +1671,7 @@ pub mod stream {
 pub mod ct {
     use super::{
         Alphabet, DecodeError, DecodedBuffer, Standard, UrlSafe, ct_decode_in_place,
-        ct_decode_slice, ct_validate_decode,
+        ct_decode_slice, ct_decoded_len, ct_validate_decode,
     };
     use core::marker::PhantomData;
 
@@ -1748,6 +1748,15 @@ pub mod ct {
             self.validate_result(input).is_ok()
         }
 
+        /// Returns the exact decoded length for valid input.
+        ///
+        /// This uses the same constant-time-oriented validation policy as
+        /// [`Self::decode_slice`] before returning a length. Input length,
+        /// padding length, and final success or failure remain public.
+        pub fn decoded_len(&self, input: &[u8]) -> Result<usize, DecodeError> {
+            ct_decoded_len::<A, PAD>(input)
+        }
+
         /// Decodes `input` into `output`, returning the number of bytes
         /// written.
         ///
@@ -6024,6 +6033,25 @@ fn ct_validate_decode<A: Alphabet, const PAD: bool>(input: &[u8]) -> Result<(),
     }
 }
 
+fn ct_decoded_len<A: Alphabet, const PAD: bool>(input: &[u8]) -> Result<usize, DecodeError> {
+    ct_validate_decode::<A, PAD>(input)?;
+    if input.is_empty() {
+        return Ok(0);
+    }
+
+    if PAD {
+        Ok(input.len() / 4 * 3 - ct_padding_len(input))
+    } else {
+        let full_quads = input.len() / 4 * 3;
+        match input.len() % 4 {
+            0 => Ok(full_quads),
+            2 => Ok(full_quads + 1),
+            3 => Ok(full_quads + 2),
+            _ => Err(DecodeError::InvalidLength),
+        }
+    }
+}
+
 fn ct_validate_padded<A: Alphabet>(input: &[u8]) -> Result<(), DecodeError> {
     if !input.len().is_multiple_of(4) {
         return Err(DecodeError::InvalidLength);

tests/rfc4648.rs

@@ -735,6 +735,35 @@ fn ct_validate_matches_constant_time_decode_policy() {
     );
 }
 
+#[test]
+fn ct_decoded_len_matches_constant_time_decode_policy() {
+    assert_eq!(ct::STANDARD.decoded_len(b""), Ok(0));
+    assert_eq!(ct::STANDARD.decoded_len(b"Zg=="), Ok(1));
+    assert_eq!(ct::STANDARD.decoded_len(b"Zm8="), Ok(2));
+    assert_eq!(ct::STANDARD.decoded_len(b"Zm9v"), Ok(3));
+    assert_eq!(ct::STANDARD_NO_PAD.decoded_len(b""), Ok(0));
+    assert_eq!(ct::STANDARD_NO_PAD.decoded_len(b"Zg"), Ok(1));
+    assert_eq!(ct::STANDARD_NO_PAD.decoded_len(b"Zm8"), Ok(2));
+    assert_eq!(ct::STANDARD_NO_PAD.decoded_len(b"Zm9v"), Ok(3));
+
+    assert_eq!(
+        ct::STANDARD.decoded_len(b"AA-A"),
+        Err(DecodeError::InvalidInput)
+    );
+    assert_eq!(
+        ct::STANDARD.decoded_len(b"Zh=="),
+        Err(DecodeError::InvalidInput)
+    );
+    assert_eq!(
+        ct::STANDARD_NO_PAD.decoded_len(b"Zg=="),
+        Err(DecodeError::InvalidInput)
+    );
+    assert_eq!(
+        ct::STANDARD.decoded_len(b"Zg"),
+        Err(DecodeError::InvalidLength)
+    );
+}
+
 fn assert_ct_validate_decode_agree<A, const PAD: bool>(
     engine: ct::CtEngine<A, PAD>,
     cases: &[&[u8]],