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 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 decode_slice( &self, input: &[u8], output: &mut [u8], ) -> Result<usize, DecodeError>

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

This path uses branch-minimized arithmetic 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_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");