ironcrypt 0.1.2

Library-first crypto toolkit: Argon2 password hashing, AES-256-GCM / XChaCha20 streaming, RSA/ECC hybrid encryption, and optional CLI/daemon.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use ironcrypt::{CryptoStandard, IronCrypt, IronCryptConfig, DataType, config::KeyManagementConfig};
use std::collections::HashMap;

#[tokio::test]
async fn test_nist_standard_applies_correct_params() {
    // Arrange
    let temp_dir = tempfile::tempdir().unwrap();
    let key_dir = temp_dir.path().to_str().unwrap();
    let mut config = IronCryptConfig {
        standard: CryptoStandard::Nist,
        ..IronCryptConfig::default()
    };

    let mut data_type_config = HashMap::new();
    data_type_config.insert(
        DataType::Generic,
        KeyManagementConfig {
            key_directory: key_dir.to_string(),
            key_version: "v1".to_string(),
            passphrase: None,
        },
    );
    config.data_type_config = Some(data_type_config);

    // Act
    let crypt = IronCrypt::new(config, DataType::Generic).await.unwrap();

    // Assert
    let expected_params = CryptoStandard::Nist.get_params().unwrap();
    assert_eq!(crypt.config.symmetric_algorithm, expected_params.symmetric_algorithm);
    assert_eq!(crypt.config.asymmetric_algorithm, expected_params.asymmetric_algorithm);
    assert_eq!(crypt.config.rsa_key_size, expected_params.rsa_key_size);
}

#[tokio::test]
async fn test_fips_standard_applies_correct_params() {
    // Arrange
    let temp_dir = tempfile::tempdir().unwrap();
    let key_dir = temp_dir.path().to_str().unwrap();
    let mut config = IronCryptConfig {
        standard: CryptoStandard::Fips140_2,
        ..IronCryptConfig::default()
    };

    let mut data_type_config = HashMap::new();
    data_type_config.insert(
        DataType::Generic,
        KeyManagementConfig {
            key_directory: key_dir.to_string(),
            key_version: "v1".to_string(),
            passphrase: None,
        },
    );
    config.data_type_config = Some(data_type_config);

    // Act
    let crypt = IronCrypt::new(config, DataType::Generic).await.unwrap();

    // Assert
    let expected_params = CryptoStandard::Fips140_2.get_params().unwrap();
    assert_eq!(crypt.config.symmetric_algorithm, expected_params.symmetric_algorithm);
    assert_eq!(crypt.config.asymmetric_algorithm, expected_params.asymmetric_algorithm);
    assert_eq!(crypt.config.rsa_key_size, expected_params.rsa_key_size);
}

#[tokio::test]
async fn test_custom_standard_retains_user_params() {
    // Arrange
    let temp_dir = tempfile::tempdir().unwrap();
    let key_dir = temp_dir.path().to_str().unwrap();
    let mut config = IronCryptConfig {
        standard: CryptoStandard::Custom,
        symmetric_algorithm: ironcrypt::algorithms::SymmetricAlgorithm::ChaCha20Poly1305,
        asymmetric_algorithm: ironcrypt::algorithms::AsymmetricAlgorithm::Ecc,
        rsa_key_size: 4096, // This will be ignored for ECC, but we test it's not overwritten
        ..Default::default()
    };

    let mut data_type_config = HashMap::new();
    data_type_config.insert(
        DataType::Generic,
        KeyManagementConfig {
            key_directory: key_dir.to_string(),
            key_version: "v1".to_string(),
            passphrase: None,
        },
    );
    config.data_type_config = Some(data_type_config);

    // Act
    let crypt = IronCrypt::new(config.clone(), DataType::Generic).await.unwrap();

    // Assert
    assert_eq!(crypt.config.standard, CryptoStandard::Custom);
    assert_eq!(crypt.config.symmetric_algorithm, config.symmetric_algorithm);
    assert_eq!(crypt.config.asymmetric_algorithm, config.asymmetric_algorithm);
    assert_eq!(crypt.config.rsa_key_size, config.rsa_key_size);
}

#[tokio::test]
async fn test_anssi_standard_applies_correct_params() {
    // Arrange
    let temp_dir = tempfile::tempdir().unwrap();
    let key_dir = temp_dir.path().to_str().unwrap();
    let mut config = IronCryptConfig {
        standard: CryptoStandard::Anssi,
        ..IronCryptConfig::default()
    };

    let mut data_type_config = HashMap::new();
    data_type_config.insert(
        DataType::Generic,
        KeyManagementConfig {
            key_directory: key_dir.to_string(),
            key_version: "v1".to_string(),
            passphrase: None,
        },
    );
    config.data_type_config = Some(data_type_config);

    // Act
    let crypt = IronCrypt::new(config, DataType::Generic).await.unwrap();

    // Assert
    let expected_params = CryptoStandard::Anssi.get_params().unwrap();
    assert_eq!(crypt.config.symmetric_algorithm, expected_params.symmetric_algorithm);
    assert_eq!(crypt.config.asymmetric_algorithm, expected_params.asymmetric_algorithm);
    assert_eq!(crypt.config.rsa_key_size, expected_params.rsa_key_size);
}