Struct CtEngine 

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

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

Implementations

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

where A: Alphabet,

pub const fn new() -> Self

Creates a new constant-time-oriented decoder engine.

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 input errors are intentionally non-localized; use the normal strict decoder when exact error indexes 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");

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));

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");

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");

Trait Implementations

impl<A: Clone, const PAD: bool> Clone for CtEngine<A, PAD>

fn clone(&self) -> CtEngine<A, PAD>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A: Debug, const PAD: bool> Debug for CtEngine<A, PAD>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A: Default, const PAD: bool> Default for CtEngine<A, PAD>

fn default() -> CtEngine<A, PAD>

Returns the “default value” for a type.

impl<A: PartialEq, const PAD: bool> PartialEq for CtEngine<A, PAD>

fn eq(&self, other: &CtEngine<A, PAD>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A: Copy, const PAD: bool> Copy for CtEngine<A, PAD>

impl<A: Eq, const PAD: bool> Eq for CtEngine<A, PAD>

impl<A, const PAD: bool> StructuralPartialEq for CtEngine<A, PAD>