libcgc 0.1.0

Liphium's encryption library to make encryption easy and reliable.
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

// Test signature public and secret key encoding and decoding
#[test]
fn test_signature_encoding() {
    use super::signature::{SignatureKeyPair, SigningKey, VerifyingKey};

    let mut pair = SignatureKeyPair::generate();

    let encoded_pub = pair.verify_key.encode();
    let decoded_pub = VerifyingKey::decode(encoded_pub).unwrap();
    assert_eq!(
        pair.verify_key.sodium_key.as_slice(),
        decoded_pub.sodium_key.as_slice()
    );
    assert_eq!(
        pair.verify_key.ml_dsa_key.encode().as_slice(),
        decoded_pub.ml_dsa_key.encode().as_slice(),
    );

    let encoded_priv = pair.signature_key.encode();
    let mut decoded_priv: SigningKey = SigningKey::decode(encoded_priv).unwrap();
    assert_eq!(
        pair.signature_key.ml_dsa_key.encode().as_slice(),
        decoded_priv.ml_dsa_key.encode().as_slice()
    );
    assert_eq!(
        pair.signature_key.sodium_key.lock().as_slice(),
        decoded_priv.sodium_key.lock().as_slice(),
    );
}

// Test signature signing and verifiying
#[test]
fn test_signature_signing() {
    use super::signature::{self, SignatureKeyPair};

    let mut pair = SignatureKeyPair::generate();

    let message = b"some signature".as_slice();
    let signed =
        signature::sign(&mut pair.signature_key, &message.to_vec()).expect("Signing failed");

    assert!(
        signature::verify(&mut pair.verify_key, &message.to_vec(), &signed)
            .expect("Verification failed")
    );
    assert!(signed.len() == signature::SIGNATURE_LEN);

    let message = b"some longer signature".as_slice();
    let signed =
        signature::sign(&mut pair.signature_key, &message.to_vec()).expect("Signing failed");

    assert!(
        signature::verify(&mut pair.verify_key, &message.to_vec(), &signed)
            .expect("Verification failed")
    );
    assert!(signed.len() == signature::SIGNATURE_LEN);
}

// Test asymmetric public and secret key encoding and decoding
#[test]
fn test_asymmetric_encoding() {
    use super::asymmetric::{AsymmetricKeyPair, PublicKey, SecretKey};

    let mut pair = AsymmetricKeyPair::generate();

    let encoded_pub = pair.public_key.encode();
    let decoded_pub = PublicKey::decode(encoded_pub).unwrap();
    assert_eq!(pair.public_key.key.as_bytes(), decoded_pub.key.as_bytes());

    let encoded_priv = pair.secret_key.encode();
    let decoded_priv: SecretKey = SecretKey::decode(encoded_priv).unwrap();
    assert_eq!(pair.secret_key.key.as_bytes(), decoded_priv.key.as_bytes());
}

// Test encryption and decryption using asymmetric (uses x_wing)
#[test]
fn test_asymmetric_encryption() {
    use super::asymmetric::{self, AsymmetricKeyPair};

    // Test regular encryption, decryption and key generation
    let pair: AsymmetricKeyPair = AsymmetricKeyPair::generate();
    let message = b"Hello symmetric encryption!".to_vec();
    let encrypted = asymmetric::encrypt(&pair.public_key, &message).expect("Encryption failed");
    let decrypted = asymmetric::decrypt(&pair.secret_key, &encrypted).expect("Decryption failed");
    assert_eq!(message, decrypted);

    // Make sure the decryption fails with invalid input
    assert!(asymmetric::decrypt(&pair.secret_key, &vec![0u8; 10]).is_none());
    assert!(asymmetric::decrypt(&pair.secret_key, &vec![0u8; 1000]).is_none());
    assert!(asymmetric::decrypt(&pair.secret_key, &vec![0u8; 2000]).is_none());
    assert!(asymmetric::decrypt(&pair.secret_key, &vec![0u8; 3000]).is_none());
    assert!(asymmetric::decrypt(&pair.secret_key, &vec![0u8; 4000]).is_none());
}

// Test symmetric key encoding and decoding
#[test]
fn test_symmetric_key_encoding() {
    use super::symmetric::SymmetricKey;

    let mut key = SymmetricKey::generate();
    let encoded = key.encode();
    let mut decoded = SymmetricKey::decode(encoded).unwrap();

    assert_eq!(key.key.lock().as_slice(), decoded.key.lock().as_slice());
}

// Test symmetric encryption and decryption on a sample message
#[test]
fn test_symmetric_encryption() {
    use super::symmetric::SymmetricKey;

    // Test regular encryption, decryption and key generation
    let mut key = SymmetricKey::generate();
    let message = b"Hello symmetric encryption!".to_vec();
    let encrypted = key.encrypt(&message).expect("Encryption failed");
    let decrypted = key.decrypt(&encrypted).expect("Decryption failed");
    assert_eq!(message, decrypted);

    // Make sure the decryption fails with invalid input
    assert!(key.decrypt(&vec![0u8; 10]).is_none());
    assert!(key.decrypt(&vec![0u8; 1000]).is_none());
    assert!(key.decrypt(&vec![0u8; 2000]).is_none());
    assert!(key.decrypt(&vec![0u8; 3000]).is_none());
    assert!(key.decrypt(&vec![0u8; 4000]).is_none());
}