sal-vault 0.1.0

SAL Vault - Cryptographic functionality including key management, digital signatures, symmetric encryption, Ethereum wallets, and encrypted key-value store
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

use sal_vault::error::CryptoError;
use sal_vault::keyspace::{KeyPair, KeySpace};
use sal_vault::symmetric::implementation::{
    decrypt_symmetric, encrypt_symmetric, generate_symmetric_key,
};

#[test]
fn test_symmetric_key_generation() {
    let key1 = generate_symmetric_key();
    let key2 = generate_symmetric_key();

    // Keys should be different
    assert_ne!(key1, key2);

    // Keys should be 32 bytes
    assert_eq!(key1.len(), 32);
    assert_eq!(key2.len(), 32);
}

#[test]
fn test_symmetric_encryption_decryption() {
    let key = generate_symmetric_key();
    let message = b"Hello, World!";

    // Encrypt the message
    let encrypted = encrypt_symmetric(&key, message).expect("Encryption should succeed");

    // Encrypted data should be different from original
    assert_ne!(encrypted.as_slice(), message);

    // Decrypt the message
    let decrypted = decrypt_symmetric(&key, &encrypted).expect("Decryption should succeed");

    // Decrypted data should match original
    assert_eq!(decrypted.as_slice(), message);
}

#[test]
fn test_symmetric_encryption_with_wrong_key() {
    let key1 = generate_symmetric_key();
    let key2 = generate_symmetric_key();
    let message = b"Secret message";

    // Encrypt with key1
    let encrypted = encrypt_symmetric(&key1, message).expect("Encryption should succeed");

    // Try to decrypt with key2 (should fail)
    let result = decrypt_symmetric(&key2, &encrypted);
    assert!(result.is_err());
}

#[test]
fn test_keyspace_creation() {
    let mut keyspace = KeySpace::new("test_space");

    assert_eq!(keyspace.name, "test_space");
    assert!(keyspace.keypairs.is_empty());

    // Add a keypair
    keyspace
        .add_keypair("test_key")
        .expect("Adding keypair should succeed");

    assert_eq!(keyspace.keypairs.len(), 1);
    assert!(keyspace.keypairs.contains_key("test_key"));
}

#[test]
fn test_keypair_creation() {
    let keypair = KeyPair::new("test_keypair");

    // Test that we can get the public key
    let public_key = keypair.pub_key();
    assert!(!public_key.is_empty());

    // Test signing and verification
    let message = b"test message";
    let signature = keypair.sign(message);

    let is_valid = keypair
        .verify(message, &signature)
        .expect("Verification should succeed");
    assert!(is_valid);

    // Test with wrong message
    let wrong_message = b"wrong message";
    let is_valid = keypair
        .verify(wrong_message, &signature)
        .expect("Verification should succeed");
    assert!(!is_valid);
}

#[test]
fn test_keyspace_serialization() {
    let mut keyspace = KeySpace::new("test_space");
    keyspace
        .add_keypair("test_key")
        .expect("Adding keypair should succeed");

    // Serialize
    let serialized = serde_json::to_string(&keyspace).expect("Serialization should succeed");

    // Deserialize
    let deserialized: KeySpace =
        serde_json::from_str(&serialized).expect("Deserialization should succeed");

    assert_eq!(deserialized.name, keyspace.name);
    assert_eq!(deserialized.keypairs.len(), keyspace.keypairs.len());
}

#[test]
fn test_error_types() {
    let error = CryptoError::InvalidKeyLength;
    assert_eq!(error.to_string(), "Invalid key length");

    let error = CryptoError::EncryptionFailed("test error".to_string());
    assert_eq!(error.to_string(), "Encryption failed: test error");

    let error = CryptoError::KeypairNotFound("test_key".to_string());
    assert_eq!(error.to_string(), "Keypair not found: test_key");
}