Struct EncryptionConfig 

pub struct EncryptionConfig {
    pub algorithm: EncryptionAlgorithm,
    pub key_derivation: KeyDerivationFunction,
    pub key_size: u32,
    pub nonce_size: u32,
    pub salt_size: u32,
    pub iterations: u32,
    pub memory_cost: Option<u32>,
    pub parallel_cost: Option<u32>,
    pub associated_data: Option<Vec<u8>>,
}

Encryption configuration that encapsulates all parameters for encryption operations

This configuration struct provides comprehensive control over encryption behavior, including algorithm selection, key derivation parameters, and security settings. The configuration is immutable and thread-safe.

Configuration Parameters

• Algorithm: The encryption algorithm to use
• Key Derivation: Function for deriving keys from passwords
• Key Size: Size of encryption keys in bytes
• Nonce Size: Size of nonces/initialization vectors in bytes
• Salt Size: Size of salt for key derivation in bytes
• Iterations: Number of iterations for key derivation
• Memory Cost: Memory usage for memory-hard functions (optional)
• Parallel Cost: Parallelism level for key derivation (optional)
• Associated Data: Additional authenticated data (optional)

Examples

Security Considerations

• Key Size: Larger keys provide better security but may impact performance
• Iterations: Higher iteration counts increase security but slow key derivation
• Memory Cost: Higher memory usage improves resistance to attacks
• Salt Size: Larger salts prevent rainbow table attacks
• Associated Data: Additional data authenticated but not encrypted

Fields

algorithm: EncryptionAlgorithm

The encryption algorithm to use for processing

key_derivation: KeyDerivationFunction

Key derivation function for generating keys from passwords

key_size: u32

Size of encryption keys in bytes

nonce_size: u32

Size of nonces/initialization vectors in bytes

salt_size: u32

Size of salt for key derivation in bytes

iterations: u32

Number of iterations for key derivation functions

memory_cost: Option<u32>

Memory cost for memory-hard functions (bytes)

parallel_cost: Option<u32>

Parallelism level for key derivation functions

associated_data: Option<Vec<u8>>

Additional authenticated data (not encrypted)

Implementations

impl EncryptionConfig

pub fn new(algorithm: EncryptionAlgorithm) -> Self

Creates a new encryption configuration

pub fn with_key_derivation(self, kdf: KeyDerivationFunction) -> Self

Sets key derivation function

pub fn with_key_size(self, size: u32) -> Self

Sets key size

pub fn with_iterations(self, iterations: u32) -> Self

Sets iterations

pub fn with_memory_cost(self, cost: u32) -> Self

Sets memory cost (for Argon2)

pub fn with_parallel_cost(self, cost: u32) -> Self

Sets parallel cost (for Argon2)

pub fn with_associated_data(self, data: Vec<u8>) -> Self

Sets associated data

pub fn high_security() -> Self

Creates a high-security configuration

pub fn performance_optimized() -> Self

Creates a performance-optimized configuration

Trait Implementations

impl Clone for EncryptionConfig

fn clone(&self) -> EncryptionConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EncryptionConfig

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

Formats the value using the given formatter.

impl Default for EncryptionConfig

fn default() -> Self

Returns the “default value” for a type.

impl FromParameters for EncryptionConfig

Implementation of FromParameters for type-safe config extraction.

This implementation converts StageConfiguration.parameters HashMap into a typed EncryptionConfig object.

Expected Parameters

• algorithm (required): Encryption algorithm name

  • Valid values: “aes256gcm”, “aes128gcm”, “chacha20poly1305”, “xchacha20poly1305”
  • Example: "algorithm" => "aes256gcm"

• key_size (optional): Key size in bytes

  • Default: 32
  • Example: "key_size" => "32"

• iterations (optional): KDF iterations

  • Default: 3
  • Example: "iterations" => "10000"

Usage Example

use adaptive_pipeline_domain::services::{EncryptionConfig, FromParameters};
use std::collections::HashMap;

let mut params = HashMap::new();
params.insert("algorithm".to_string(), "aes256gcm".to_string());

let config = EncryptionConfig::from_parameters(&params).unwrap();

fn from_parameters( params: &HashMap<String, String>, ) -> Result<Self, PipelineError>

Converts HashMap parameters to typed configuration.