Struct CtEngine

Source

pub struct CtEngine<A, const PAD: bool> { /* private fields */ }

Expand description

A zero-sized constant-time-oriented Base64 decoder.

Implementations§

Source §

impl<A, const PAD: bool> CtEngine<A, PAD>
where A: Alphabet,

Source

pub const fn new() -> Self

Creates a new constant-time-oriented decoder engine.

Source

pub const fn is_padded(&self) -> bool

Returns whether this constant-time-oriented decoder expects padded input.

Source

pub fn validate_result(&self, input: &[u8]) -> Result<(), DecodeError>

Validates input without writing decoded bytes.

This uses the same constant-time-oriented symbol mapping and opaque malformed-input error behavior as Self::decode_slice. Input length, padding length, and final success or failure remain public.

§Examples

use base64_ng::ct;

ct::STANDARD.validate_result(b"aGVsbG8=").unwrap();
assert!(ct::STANDARD.validate_result(b"aGVsbG8").is_err());

Source

pub fn validate(&self, input: &[u8]) -> bool

Returns whether input is valid for this constant-time-oriented decoder.

This is a convenience wrapper around Self::validate_result.

§Examples

use base64_ng::ct;

assert!(ct::URL_SAFE_NO_PAD.validate(b"-_8"));
assert!(!ct::URL_SAFE_NO_PAD.validate(b"+/8"));

Source

pub fn decoded_len(&self, input: &[u8]) -> Result<usize, DecodeError>

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.

Source

pub fn decode_slice( &self, input: &[u8], output: &mut [u8], ) -> Result<usize, DecodeError>

Decodes input into output, returning the number of bytes written.

This path uses a fixed alphabet scan for Base64 symbol mapping and avoids secret-indexed lookup tables. Input length, padding length, output length, and final success or failure remain public. Malformed content errors are intentionally opaque and non-localized; use the normal strict decoder when exact diagnostics are required.

§Examples

use base64_ng::ct;

let mut output = [0u8; 5];
let written = ct::STANDARD
    .decode_slice(b"aGVsbG8=", &mut output)
    .unwrap();

assert_eq!(&output[..written], b"hello");

Source

pub fn decode_slice_clear_tail( &self, input: &[u8], output: &mut [u8], ) -> Result<usize, DecodeError>

Decodes input into output and clears all bytes after the decoded prefix.

If decoding fails, the entire output buffer is cleared before the error is returned. Use this variant for sensitive payloads where partially decoded bytes from rejected input should not remain in the caller-owned output buffer.

§Examples

use base64_ng::ct;

let mut output = [0xff; 8];
let written = ct::STANDARD
    .decode_slice_clear_tail(b"aGk=", &mut output)
    .unwrap();

assert_eq!(&output[..written], b"hi");
assert!(output[written..].iter().all(|byte| *byte == 0));

Source

pub fn decode_buffer<const CAP: usize>( &self, input: &[u8], ) -> Result<DecodedBuffer<CAP>, DecodeError>

Decodes input into a stack-backed buffer.

This uses the same constant-time-oriented scalar decoder as Self::decode_slice_clear_tail and clears the internal backing array before returning an error.

§Examples

use base64_ng::ct;

let decoded = ct::STANDARD.decode_buffer::<5>(b"aGVsbG8=").unwrap();

assert_eq!(decoded.as_bytes(), b"hello");

Source

pub fn decode_in_place<'a>( &self, buffer: &'a mut [u8], ) -> Result<&'a mut [u8], DecodeError>

Decodes buffer in place and returns the decoded prefix.

This uses the constant-time-oriented scalar decoder while reading each Base64 quantum into local values before writing decoded bytes back to the front of the same buffer.

§Examples

use base64_ng::ct;

let mut buffer = *b"aGk=";
let decoded = ct::STANDARD.decode_in_place(&mut buffer).unwrap();

assert_eq!(decoded, b"hi");

Source

pub fn decode_in_place_clear_tail<'a>( &self, buffer: &'a mut [u8], ) -> Result<&'a mut [u8], DecodeError>

Decodes buffer in place and clears all bytes after the decoded prefix.

If decoding fails, the entire buffer is cleared before the error is returned.

§Examples

use base64_ng::ct;

let mut buffer = *b"aGk=";
let decoded = ct::STANDARD.decode_in_place_clear_tail(&mut buffer).unwrap();

assert_eq!(decoded, b"hi");