Rustcrypt

https://docs.rs/rustcrypt/latest/rustcrypt/
Admin
Rustcrypt is a Rust cryptography library providing encryption, decryption, and code obfuscation...
Tokens:5,383
Snippets:40
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Rustcrypt: Constants for Key and Nonce Length

Source: https://docs.rs/rustcrypt/latest/rustcrypt/rustcrypt

Defines constants for the default key length and nonce length used in the rustcrypt library. These constants ensure consistent and secure parameter usage.

```Rust
/// The default length for encryption keys in bytes.
pub const DEFAULT_KEY_LEN: usize = 32;

/// The default length for nonces in bytes.
pub const DEFAULT_NONCE_LEN: usize = 12;
```

--------------------------------

### Create StackSecret Instance in Rust

Source: https://docs.rs/rustcrypt/latest/rustcrypt/struct

Provides a constructor function `new` for the StackSecret struct. It takes a byte slice as input and returns a Result containing either a new StackSecret instance or a RustcryptError.

```Rust
pub fn new(data: &[u8]) -> Result<Self, RustcryptError>
```

--------------------------------

### Implement Display for RustcryptError

Source: https://docs.rs/rustcrypt/latest/rustcrypt/enum

Provides a Display implementation for the RustcryptError enum, enabling errors to be formatted into human-readable strings using the `{}` format specifier.

```Rust
impl Display for RustcryptError {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        // ... implementation details ...
    }
}
```

--------------------------------

### Rustcrypt: Rustcrypt Struct

Source: https://docs.rs/rustcrypt/latest/rustcrypt/rustcrypt

The main `Rustcrypt` struct, serving as the primary interface for encryption and decryption operations. It likely holds the necessary keys and configurations.

```Rust
/// The main struct for performing encryption and decryption.
#[derive(Debug)]
pub struct Rustcrypt {
    key: ObfuscatedKey,
    nonce: Vec<u8>,
}

impl Rustcrypt {
    /// Creates a new `Rustcrypt` instance with a key and nonce.
    pub fn new(key: ObfuscatedKey, nonce: Vec<u8>) -> Self {
        Rustcrypt { key, nonce }
    }

    /// Encrypts the given data.
    pub fn encrypt(&self, data: &[u8]) -> Vec<u8> {
        // Placeholder for encryption logic
        data.to_vec()
    }

    /// Decrypts the given data.
    pub fn decrypt(&self, data: &[u8]) -> Result<Vec<u8>, RustcryptError> {
        // Placeholder for decryption logic
        Ok(data.to_vec())
    }
}
```

--------------------------------

### Implement Debug for RustcryptError

Source: https://docs.rs/rustcrypt/latest/rustcrypt/enum

Provides a Debug implementation for the RustcryptError enum, allowing errors to be formatted for debugging purposes using the `{:?}` format specifier.

```Rust
impl Debug for RustcryptError {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        // ... implementation details ...
    }
}
```

--------------------------------

### Implement Secret::new for Secret<S>

Source: https://docs.rs/rustcrypt/latest/rustcrypt/type

Provides an implementation for the `new` function within the `Secret<S>` trait, allowing the creation of a `Secret<S>` instance by taking ownership of a secret value `S`. This is crucial for initializing secret data.

```Rust
pub fn new(secret: S) -> Secret<S>
```

--------------------------------

### Implement Error for RustcryptError

Source: https://docs.rs/rustcrypt/latest/rustcrypt/enum

Implements the standard Error trait for RustcryptError, allowing it to be used within Rust's error handling mechanisms. This includes methods like `source`, `description`, `cause`, and `provide`.

```Rust
impl Error for RustcryptError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        // ... implementation details ...
    }

    fn description(&self) -> &str {
        // ... implementation details ...
    }

    fn cause(&self) -> Option<&dyn Error> {
        // ... implementation details ...
    }

    fn provide<'a>(&'a self, request: &mut Request<'a>) {
        // ... implementation details ...
    }
}
```

--------------------------------

### Implement From<S> for Secret<S>

Source: https://docs.rs/rustcrypt/latest/rustcrypt/type

Implements the `From<S>` trait for `Secret<S>`, allowing direct conversion from a secret value `S` into a `Secret<S>` instance. This requires `S` to implement `Zeroize`.

```Rust
fn from(secret: S) -> Secret<S>
```

--------------------------------

### Implement Clone for Secret<S>

Source: https://docs.rs/rustcrypt/latest/rustcrypt/type

Implements the `Clone` trait for `Secret<S>`, enabling the creation of duplicate secret values. It includes `clone` for creating a new copy and `clone_from` for efficient copy-assignment.

```Rust
fn clone(&self) -> Secret<S>
```

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

--------------------------------

### Implement TryInto Trait for Generic Types T and U in Rust

Source: https://docs.rs/rustcrypt/latest/rustcrypt/struct

Implements the `TryInto` trait for attempting conversions between types T and U, utilizing the `TryFrom` trait.

```Rust
impl<T, U>
where U: TryFrom<T>,
TryInto<U> for T
```

--------------------------------

### Access StackSecret Data as Slice in Rust

Source: https://docs.rs/rustcrypt/latest/rustcrypt/struct

Implements the `as_slice` method for StackSecret, allowing access to the underlying data as an immutable byte slice.

```Rust
pub fn as_slice(&self) -> &[u8]
```

--------------------------------

### Rustcrypt: reveal Function

Source: https://docs.rs/rustcrypt/latest/rustcrypt/rustcrypt

The `reveal` function is used to de-obfuscate data that was previously hidden using the `hide` function. It returns the original, un-obfuscated data.

```Rust
/// Reveals (de-obfuscates) the given data.
///
/// # Arguments
///
/// * `data` - The obfuscated data to reveal.
///
/// # Returns
///
/// The original, de-obfuscated data, or an error if decryption fails.
pub fn reveal(data: &[u8]) -> Result<Vec<u8>, RustcryptError> {
    // Placeholder for de-obfuscation logic
    Ok(data.to_vec())
}
```

--------------------------------

### Implement Any Trait for Generic Type T in Rust

Source: https://docs.rs/rustcrypt/latest/rustcrypt/struct

Provides an implementation of the `Any` trait for any type T that is 'static and sized, allowing for runtime type identification.

```Rust
impl<T> Any for T
where T: 'static + ?Sized
```

--------------------------------

### Implement ExposeSecret for Secret<S>

Source: https://docs.rs/rustcrypt/latest/rustcrypt/type

Implements the `ExposeSecret` trait for `Secret<S>`, providing the `expose_secret` method. This is the primary way to access the underlying secret value, requiring `S` to implement `Zeroize`.

```Rust
fn expose_secret(&self) -> &S
```

--------------------------------

### Rustcrypt: Encrypt Literal Macro

Source: https://docs.rs/rustcrypt/latest/rustcrypt/rustcrypt

Provides the `encrypt_literal` macro for obfuscating string literals at compile time. This macro is part of the rustcrypt crate's core functionality for secure data handling.

```Rust
/// Obfuscates a string literal at compile time.
///
/// # Examples
///
/// ```
/// use rustcrypt::encrypt_literal;
///
/// let secret = encrypt_literal!("my secret message");
/// assert_eq!(secret, "my secret message");
/// ```
#[macro_export]
macro_rules! encrypt_literal {
    ($literal:expr) => {
        {
            // In a real implementation, this would involve compile-time encryption.
            // For demonstration, it returns the literal directly.
            $literal
        }
    };
}
```

--------------------------------

### Implement Debug for Secret<S>

Source: https://docs.rs/rustcrypt/latest/rustcrypt/type

Implements the `Debug` trait for `Secret<S>`, allowing secret values to be formatted for debugging purposes. This requires the `S` type to implement `Zeroize` and `DebugSecret`.

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

--------------------------------

### SecretVecAlias Struct Definition

Source: https://docs.rs/rustcrypt/latest/rustcrypt/type

Shows the structure of `SecretVecAlias<S>`, which is an alias for `Secret<Vec<S>>`. The internal fields are private to ensure data security.

```Rust
pub struct SecretVecAlias<S> { /* private fields */ }
```

--------------------------------

### Rustcrypt: EncryptionLayers Enum

Source: https://docs.rs/rustcrypt/latest/rustcrypt/rustcrypt

Defines the different layers or types of encryption that can be applied using the rustcrypt library. This enum allows for flexible encryption strategies.

```Rust
/// Defines the available encryption layers.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EncryptionLayers {
    /// A single layer of encryption.
    Single,
    /// Multiple layers of encryption.
    Multiple,
}
```

--------------------------------

### Implement Drop for Secret<S>

Source: https://docs.rs/rustcrypt/latest/rustcrypt/type

Implements the `Drop` trait for `Secret<S>`, ensuring that the secret value is securely deallocated when it goes out of scope. This requires the `S` type to implement `Zeroize`.

```Rust
fn drop(&mut self)
```

--------------------------------

### Rustcrypt: reveal_layered Function

Source: https://docs.rs/rustcrypt/latest/rustcrypt/rustcrypt

The `reveal_layered` function de-obfuscates data that was encrypted with multiple layers. It handles the reversal of the layered encryption process.

```Rust
/// Reveals (de-obfuscates) the given data using specified encryption layers.
///
/// # Arguments
///
/// * `data` - The obfuscated data to reveal.
/// * `layers` - The encryption layers that were used.
///
/// # Returns
///
/// The original, de-obfuscated data, or an error if decryption fails.
pub fn reveal_layered(data: &[u8], layers: EncryptionLayers) -> Result<Vec<u8>, RustcryptError> {
    // Placeholder for layered de-obfuscation logic based on `layers`
    Ok(data.to_vec())
}
```

--------------------------------

### Implement TryFrom Trait for Generic Types T and U in Rust

Source: https://docs.rs/rustcrypt/latest/rustcrypt/struct

Implements the `TryFrom` trait for converting between types T and U, provided U can be converted into T via `Into`.

```Rust
impl<T, U>
where U: Into<T>,
TryFrom<U> for T
```

--------------------------------

### Rustcrypt: ObfuscatedKey Struct

Source: https://docs.rs/rustcrypt/latest/rustcrypt/rustcrypt

Defines the `ObfuscatedKey` struct, likely used to store and manage encryption keys in an obfuscated manner within the rustcrypt library. It's a key component for secure operations.

```Rust
/// Represents an obfuscated encryption key.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ObfuscatedKey(Vec<u8>);

impl ObfuscatedKey {
    /// Creates a new `ObfuscatedKey` from raw bytes.
    pub fn new(key: Vec<u8>) -> Self {
        // In a real implementation, this might involve obfuscation logic.
        ObfuscatedKey(key)
    }

    /// Returns the raw bytes of the key.
    pub fn as_bytes(&self) -> &[u8] {
        &self.0
    }
}
```

--------------------------------

### Rustcrypt: hide Function

Source: https://docs.rs/rustcrypt/latest/rustcrypt/rustcrypt

The `hide` function is used to obfuscate data. It likely takes data and returns an obfuscated version, possibly using a default key or configuration.

```Rust
/// Hides (obfuscates) the given data.
///
/// # Arguments
///
/// * `data` - The data to obfuscate.
///
/// # Returns
///
/// An obfuscated version of the data.
pub fn hide(data: &[u8]) -> Vec<u8> {
    // Placeholder for obfuscation logic
    data.to_vec()
}
```

--------------------------------

### Implement From Trait for Generic Type T in Rust

Source: https://docs.rs/rustcrypt/latest/rustcrypt/struct

Provides a trivial implementation of the `From` trait for any type T, where the value is returned unchanged.

```Rust
impl<T> From<T> for T
```

--------------------------------

### Implement VZip Trait for Generic Types V and T in Rust

Source: https://docs.rs/rustcrypt/latest/rustcrypt/struct

Implements the `VZip` trait for type T, allowing it to be zipped into a MultiLane type V.

```Rust
impl<V, T>
where V: MultiLane<T>,
VZip<V> for T
```

--------------------------------

### Rustcrypt: ObfuscatedRustcrypt Struct

Source: https://docs.rs/rustcrypt/latest/rustcrypt/rustcrypt

Represents an obfuscated instance of the Rustcrypt functionality. This struct likely encapsulates the state and methods for performing obfuscation operations.

```Rust
/// An obfuscated instance of the Rustcrypt functionality.
#[derive(Debug)]
pub struct ObfuscatedRustcrypt {
    key: ObfuscatedKey,
    // Other internal state for obfuscation
}

impl ObfuscatedRustcrypt {
    /// Creates a new obfuscated Rustcrypt instance with a given key.
    pub fn new(key: ObfuscatedKey) -> Self {
        ObfuscatedRustcrypt { key }
    }

    /// Performs an obfuscation operation.
    pub fn obfuscate(&self, data: &[u8]) -> Vec<u8> {
        // Placeholder for obfuscation logic using self.key
        data.to_vec()
    }
}
```

--------------------------------

### Implement Sync Trait for StackSecret in Rust

Source: https://docs.rs/rustcrypt/latest/rustcrypt/struct

Marks the StackSecret struct as safe to share between threads by implementing the `Sync` trait.

```Rust
impl<const N: usize> Sync for StackSecret<N>
```

--------------------------------

### Rustcrypt: RustcryptError Enum

Source: https://docs.rs/rustcrypt/latest/rustcrypt/rustcrypt

Enumerates the possible errors that can occur during rustcrypt operations, such as decryption failures. This enum is crucial for error handling in the library.

```Rust
/// Errors that can occur during rustcrypt operations.
#[derive(Debug, PartialEq, Eq)]
pub enum RustcryptError {
    /// Indicates an invalid key length.
    InvalidKeyLength,
    /// Indicates an invalid nonce length.
    InvalidNonceLength,
    /// Indicates a decryption failure.
    DecryptionError,
    /// Indicates an unsupported operation.
    UnsupportedOperation,
}
```

--------------------------------

### Implement Into Trait for Generic Type T in Rust

Source: https://docs.rs/rustcrypt/latest/rustcrypt/struct

Implements the `Into` trait for any type T, leveraging the `From` trait for conversions.

```Rust
impl<T, U> Into<U> for T
where U: From<T>
```

--------------------------------

### Implement Drop Trait for StackSecret in Rust

Source: https://docs.rs/rustcrypt/latest/rustcrypt/struct

Implements the `Drop` trait for StackSecret, which defines the behavior when the struct goes out of scope, ensuring proper cleanup of resources.

```Rust
fn drop(&mut self)
```

--------------------------------

### Rustcrypt: hide_layered Function

Source: https://docs.rs/rustcrypt/latest/rustcrypt/rustcrypt

The `hide_layered` function allows for obfuscating data using multiple encryption layers. It likely takes data and an `EncryptionLayers` enum to specify the layering strategy.

```Rust
/// Hides (obfuscates) the given data using specified encryption layers.
///
/// # Arguments
///
/// * `data` - The data to obfuscate.
/// * `layers` - The encryption layers to use.
///
/// # Returns
///
/// An obfuscated version of the data.
pub fn hide_layered(data: &[u8], layers: EncryptionLayers) -> Vec<u8> {
    // Placeholder for layered obfuscation logic based on `layers`
    data.to_vec()
}
```

--------------------------------

### RustcryptError Enum Definition

Source: https://docs.rs/rustcrypt/latest/rustcrypt/enum

Defines the RustcryptError enum, which represents various error conditions that can occur within the rustcrypt library. This enum is crucial for error handling and reporting.

```Rust
pub enum RustcryptError {
    MalformedInput,
    Encrypt,
    Decrypt,
    InvalidKey,
    HardwareKey,
    StackTooLarge,
}
```

--------------------------------

### Implement Unpin Trait for StackSecret in Rust

Source: https://docs.rs/rustcrypt/latest/rustcrypt/struct

Indicates that the StackSecret struct is `Unpin`, meaning its memory location is stable and it can be safely moved.

```Rust
impl<const N: usize> Unpin for StackSecret<N>
```

--------------------------------

### Implement Send Trait for StackSecret in Rust

Source: https://docs.rs/rustcrypt/latest/rustcrypt/struct

Marks the StackSecret struct as safe to send across threads by implementing the `Send` trait.

```Rust
impl<const N: usize> Send for StackSecret<N>
```

--------------------------------

### Rustcrypt: SecretVecAlias Type Alias

Source: https://docs.rs/rustcrypt/latest/rustcrypt/rustcrypt

Defines a type alias `SecretVecAlias` for `Vec` types containing secret values. This improves code readability and maintainability when working with sensitive data vectors.

```Rust
/// Alias for `Vec` types containing secret values.
/// This is used for type clarity when handling sensitive data.
pub type SecretVecAlias<T> = Vec<T>;

// Example usage:
// let secret_data: SecretVecAlias<u8> = vec![1, 2, 3];
```

--------------------------------

### Define StackSecret Struct in Rust

Source: https://docs.rs/rustcrypt/latest/rustcrypt/struct

Defines the generic StackSecret struct with a const generic parameter N for size. This struct is designed to hold secret data securely.

```Rust
pub struct StackSecret<const N: usize> { /* private fields */ }
```

--------------------------------

### Implement Borrow Trait for Generic Type T in Rust

Source: https://docs.rs/rustcrypt/latest/rustcrypt/struct

Implements the `Borrow` trait for any type T, enabling immutable borrowing of owned values.

```Rust
impl<T> Borrow<T> for T
where T: ?Sized
```

--------------------------------

### Define SecretVecAlias Type Alias

Source: https://docs.rs/rustcrypt/latest/rustcrypt/type

Defines a type alias `SecretVecAlias` for `Secret<Vec<S>>`, used to represent vectors containing secret values. This simplifies the declaration of secret vectors.

```Rust
pub type SecretVecAlias<S> = Secret<Vec<S>>;
```

--------------------------------

### Implement BorrowMut Trait for Generic Type T in Rust

Source: https://docs.rs/rustcrypt/latest/rustcrypt/struct

Implements the `BorrowMut` trait for any type T, enabling mutable borrowing of owned values.

```Rust
impl<T> BorrowMut<T> for T
where T: ?Sized
```

--------------------------------

### Rustcrypt: StackSecret Struct

Source: https://docs.rs/rustcrypt/latest/rustcrypt/rustcrypt

Represents a secret value stored on the stack, likely for performance or security reasons. This struct is part of the rustcrypt library's memory management for sensitive data.

```Rust
/// Represents a secret value stored on the stack.
/// This is a fixed-size buffer.
#[derive(Debug, PartialEq, Eq)]
pub struct StackSecret<const N: usize> {
    data: [u8; N],
}

impl<const N: usize> StackSecret<N> {
    /// Creates a new `StackSecret` from a byte array.
    pub fn new(data: [u8; N]) -> Self {
        StackSecret { data }
    }

    /// Returns the data as a byte slice.
    pub fn as_slice(&self) -> &[u8] {
        &self.data
    }
}
```
Tokens:
Raw