Struct Encrypted 

pub struct Encrypted<A: Algorithm, M, const N: usize> { /* private fields */ }

An encrypted container that holds data encrypted at compile time.

This struct stores encrypted data that is decrypted on first access via the Deref implementation. The decryption happens exactly once, after which the plaintext is cached for subsequent accesses.

Type Parameters

• A: The encryption algorithm type implementing Algorithm
• M: The mode marker type (StringLiteral or ByteArray)
• N: The size of the encrypted buffer in bytes

Thread Safety

The struct is Sync, allowing concurrent access from multiple threads. The first thread to access the data performs the decryption; subsequent accesses read the already-decrypted buffer.

Drop Behavior

When dropped, the data is handled according to the algorithm’s DropStrategy:

• Zeroize: Overwrites with zeros
• ReEncrypt / ReEncrypt: Re-encrypts
• NoOp: Leaves data unchanged

Example

use const_secret::{
    Encrypted, StringLiteral,
    drop_strategy::Zeroize,
    xor::Xor,
};

const SECRET: Encrypted<Xor<0xAA, Zeroize>, StringLiteral, 5> =
    Encrypted::<Xor<0xAA, Zeroize>, StringLiteral, 5>::new(*b"hello");

fn main() {
    // Decrypts on first access
    let decrypted: &str = &*SECRET;
    assert_eq!(decrypted, "hello");
}

Implementations

impl<const KEY_LEN: usize, D: DropStrategy<Extra = [u8; KEY_LEN]>, M, const N: usize> Encrypted<Rc4<KEY_LEN, D>, M, N>

pub const fn new(buffer: [u8; N], key: [u8; KEY_LEN]) -> Self

Creates a new encrypted buffer using RC4.

Arguments

• buffer - The plaintext data to encrypt (must be an array of length N)
• key - The RC4 key (must be an array of length KEY_LEN)

This function performs RC4 encryption at compile time:

1. Runs the Key Scheduling Algorithm (KSA) to initialize the S-box
2. Runs the Pseudo-Random Generation Algorithm (PRGA) to generate keystream
3. XORs the keystream with the plaintext

impl<const KEY: u8, D: DropStrategy<Extra = ()>, M, const N: usize> Encrypted<Xor<KEY, D>, M, N>

pub const fn new(buffer: [u8; N]) -> Self

Methods from Deref<Target = [u8; N]>

pub fn as_ascii(&self) -> Option<&[AsciiChar; N]>

🔬This is a nightly-only experimental API. (ascii_char)

Converts this array of bytes into an array of ASCII characters, or returns None if any of the characters is non-ASCII.

Examples

#![feature(ascii_char)]

const HEX_DIGITS: [std::ascii::Char; 16] =
    *b"0123456789abcdef".as_ascii().unwrap();

assert_eq!(HEX_DIGITS[1].as_str(), "1");
assert_eq!(HEX_DIGITS[10].as_str(), "a");

pub unsafe fn as_ascii_unchecked(&self) -> &[AsciiChar; N]

🔬This is a nightly-only experimental API. (ascii_char)

Converts this array of bytes into an array of ASCII characters, without checking whether they’re valid.

Safety

Every byte in the array must be in 0..=127, or else this is UB.

pub fn as_slice(&self) -> &[T]

Returns a slice containing the entire array. Equivalent to &s[..].

pub fn each_ref(&self) -> [&T; N]

Borrows each element and returns an array of references with the same size as self.

Example

let floats = [3.1, 2.7, -1.0];
let float_refs: [&f64; 3] = floats.each_ref();
assert_eq!(float_refs, [&3.1, &2.7, &-1.0]);

This method is particularly useful if combined with other methods, like map. This way, you can avoid moving the original array if its elements are not Copy.

let strings = ["Ferris".to_string(), "♥".to_string(), "Rust".to_string()];
let is_ascii = strings.each_ref().map(|s| s.is_ascii());
assert_eq!(is_ascii, [true, false, true]);

// We can still access the original array: it has not been moved.
assert_eq!(strings.len(), 3);

pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index.

The first will contain all indices from [0, M) (excluding the index M itself) and the second will contain all indices from [M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.split_array_ref::<0>();
   assert_eq!(left, &[]);
   assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<2>();
    assert_eq!(left, &[1, 2]);
    assert_eq!(right, &[3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<6>();
    assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
    assert_eq!(right, &[]);
}

pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index from the end.

The first will contain all indices from [0, N - M) (excluding the index N - M itself) and the second will contain all indices from [N - M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.rsplit_array_ref::<0>();
   assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
   assert_eq!(right, &[]);
}

{
    let (left, right) = v.rsplit_array_ref::<2>();
    assert_eq!(left, &[1, 2, 3, 4]);
    assert_eq!(right, &[5, 6]);
}

{
    let (left, right) = v.rsplit_array_ref::<6>();
    assert_eq!(left, &[]);
    assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

Trait Implementations

impl<A: Algorithm, M, const N: usize> Debug for Encrypted<A, M, N>

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

Formats the Encrypted struct for debugging.

Note that the actual buffer contents are not displayed for security reasons. Only the decryption_state is shown. The output uses finish_non_exhaustive() to indicate there are additional fields not shown.

impl<const KEY_LEN: usize, D: DropStrategy<Extra = [u8; KEY_LEN]>, const N: usize> Deref for Encrypted<Rc4<KEY_LEN, D>, ByteArray, N>

type Target = [u8; N]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<const KEY_LEN: usize, D: DropStrategy<Extra = [u8; KEY_LEN]>, const N: usize> Deref for Encrypted<Rc4<KEY_LEN, D>, StringLiteral, N>

type Target = str

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<const KEY: u8, D: DropStrategy<Extra = ()>, const N: usize> Deref for Encrypted<Xor<KEY, D>, ByteArray, N>

type Target = [u8; N]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<const KEY: u8, D: DropStrategy<Extra = ()>, const N: usize> Deref for Encrypted<Xor<KEY, D>, StringLiteral, N>

type Target = str

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<A: Algorithm, M, const N: usize> Drop for Encrypted<A, M, N>

fn drop(&mut self)

Handles the encrypted data when the struct is dropped.

Applies the algorithm’s DropStrategy to the buffer. This may zeroize, re-encrypt, or leave the data unchanged depending on the configured strategy.

impl<A, M, const N: usize> Sync for Encrypted<A, M, N>

where A: Sync + Algorithm, A::Extra: Sync, M: Sync,