ciphern 0.2.1

Enterprise-grade cryptographic library
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

// Copyright (c) 2025 Kirky.X
//
// Licensed under the MIT License
// See LICENSE file in the project root for full license information.

use crate::{Algorithm, Cipher, KeyManager};

#[test]
fn test_aes_gcm_vectors() {
    // Vector 1 (AES-128-GCM) - Using public API
    let key_manager = KeyManager::new().unwrap();
    let key_id = key_manager.generate_key(Algorithm::AES128GCM).unwrap();
    let cipher = Cipher::new(Algorithm::AES128GCM).unwrap();

    let plaintext = b"00000000000000000000000000000000";
    let ciphertext = cipher.encrypt(&key_manager, &key_id, plaintext).unwrap();
    let decrypted = cipher.decrypt(&key_manager, &key_id, &ciphertext).unwrap();

    assert_eq!(plaintext, &decrypted[..]);

    // Vector 4 (AES-192-GCM) - Using public API
    let key_id = key_manager.generate_key(Algorithm::AES192GCM).unwrap();
    let cipher = Cipher::new(Algorithm::AES192GCM).unwrap();

    let plaintext = b"00000000000000000000000000000000";
    let ciphertext = cipher.encrypt(&key_manager, &key_id, plaintext).unwrap();
    let decrypted = cipher.decrypt(&key_manager, &key_id, &ciphertext).unwrap();

    assert_eq!(plaintext, &decrypted[..]);
}

#[test]
fn test_aes256_encrypt_decrypt() {
    let key_manager = KeyManager::new().unwrap();
    let key_id = key_manager.generate_key(Algorithm::AES256GCM).unwrap();
    let cipher = Cipher::new(Algorithm::AES256GCM).unwrap();

    let plaintext = b"Hello, SecureVault!";
    let ciphertext = cipher.encrypt(&key_manager, &key_id, plaintext).unwrap();
    let decrypted = cipher.decrypt(&key_manager, &key_id, &ciphertext).unwrap();

    assert_eq!(plaintext, &decrypted[..]);
}

#[test]
fn test_aes256_wrong_key_fails() {
    let key_manager = KeyManager::new().unwrap();
    let key1_id = key_manager.generate_key(Algorithm::AES256GCM).unwrap();
    let key2_id = key_manager.generate_key(Algorithm::AES256GCM).unwrap();

    let cipher = Cipher::new(Algorithm::AES256GCM).unwrap();

    let plaintext = b"Secret message";
    let ciphertext = cipher.encrypt(&key_manager, &key1_id, plaintext).unwrap();

    // Attempt to decrypt with wrong key ID
    assert!(cipher.decrypt(&key_manager, &key2_id, &ciphertext).is_err());
}

#[test]
fn test_sm4_encrypt_decrypt() {
    let key_manager = KeyManager::new().unwrap();
    let key_id = key_manager.generate_key(Algorithm::SM4GCM).unwrap();
    let cipher = Cipher::new(Algorithm::SM4GCM).unwrap();

    let plaintext = b"Chinese cryptography standard";
    let ciphertext = cipher.encrypt(&key_manager, &key_id, plaintext).unwrap();
    let decrypted = cipher.decrypt(&key_manager, &key_id, &ciphertext).unwrap();

    assert_eq!(plaintext, &decrypted[..]);
}

#[test]
fn test_empty_plaintext() {
    let key_manager = KeyManager::new().unwrap();
    let key_id = key_manager.generate_key(Algorithm::AES256GCM).unwrap();
    let cipher = Cipher::new(Algorithm::AES256GCM).unwrap();

    let plaintext = b"";
    let ciphertext = cipher.encrypt(&key_manager, &key_id, plaintext).unwrap();
    let decrypted = cipher.decrypt(&key_manager, &key_id, &ciphertext).unwrap();

    assert_eq!(plaintext, &decrypted[..]);
}