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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

// Test the asymmetric auth container
#[test]
fn test_auth_asymmetric() {
    use crate::crypto::{asymmetric, signature};

    use super::auth_asymmetric;

    // Make keypairs
    let mut sender_s_kp = signature::SignatureKeyPair::generate();
    let receiver_e_kp = asymmetric::AsymmetricKeyPair::generate();
    let receiver_s_kp = signature::SignatureKeyPair::generate();

    // Verify basic functionality
    let msg = b"Hello asymmetric auth!".to_vec();
    let packed = auth_asymmetric::pack(
        &receiver_e_kp.public_key,
        &mut sender_s_kp.signature_key,
        &msg,
        None,
    )
    .expect("Packing failed");
    let unpacked = auth_asymmetric::unpack(
        &receiver_e_kp.secret_key,
        &sender_s_kp.verify_key,
        &packed,
        None,
    )
    .expect("Unpacking failed");
    assert_eq!(msg.as_slice(), unpacked.as_slice());

    // Verify failure in case of changing the message
    let mut copy = packed.clone();
    copy.extend(b"b");
    assert!(
        auth_asymmetric::unpack(
            &receiver_e_kp.secret_key,
            &sender_s_kp.verify_key,
            &copy,
            None
        )
        .is_none()
    );
    copy.extend(b"adhuasuduaiui");
    assert!(
        auth_asymmetric::unpack(
            &receiver_e_kp.secret_key,
            &sender_s_kp.verify_key,
            &copy,
            None
        )
        .is_none()
    );

    // Make sure verifying with an invalid key doesn't work
    assert!(
        auth_asymmetric::unpack(
            &receiver_e_kp.secret_key,
            &receiver_s_kp.verify_key,
            &packed,
            None
        )
        .is_none()
    );

    // Test with salt
    let salt = b"random_salt_data".to_vec();
    let packed_with_salt = auth_asymmetric::pack(
        &receiver_e_kp.public_key,
        &mut sender_s_kp.signature_key,
        &msg,
        Some(&salt),
    )
    .expect("Packing with salt failed");

    // Unpacking with correct salt should work
    let unpacked_with_salt = auth_asymmetric::unpack(
        &receiver_e_kp.secret_key,
        &sender_s_kp.verify_key,
        &packed_with_salt,
        Some(&salt),
    )
    .expect("Unpacking with salt failed");
    assert_eq!(msg.as_slice(), unpacked_with_salt.as_slice());

    // Unpacking with wrong salt should fail
    let wrong_salt = b"wrong_salt_value".to_vec();
    assert!(
        auth_asymmetric::unpack(
            &receiver_e_kp.secret_key,
            &sender_s_kp.verify_key,
            &packed_with_salt,
            Some(&wrong_salt)
        )
        .is_none()
    );
}

// Test symmetric auth encryption
#[test]
fn test_auth_symmetric() {
    use crate::crypto::signature;
    use crate::crypto::symmetric;

    use super::auth_symmetric; // Make keypairs/keys
    let mut key = symmetric::SymmetricKey::generate();
    let mut sender_s_kp = signature::SignatureKeyPair::generate();
    let receiver_s_kp = signature::SignatureKeyPair::generate();

    // Verify basic functionality
    let msg = b"Hello symmetric auth!".to_vec();
    let packed = auth_symmetric::pack(&mut key, &mut sender_s_kp.signature_key, &msg, None)
        .expect("Packing failed");
    let unpacked = auth_symmetric::unpack(&mut key, &sender_s_kp.verify_key, &packed, None)
        .expect("Unpacking failed");
    assert_eq!(msg.as_slice(), unpacked.as_slice());

    // Verify failure in case of changing the message
    let mut copy = packed.clone();
    copy.extend(b"b");
    assert!(auth_symmetric::unpack(&mut key, &sender_s_kp.verify_key, &copy, None).is_none());
    copy.extend(b"adhuasuduaiui");
    assert!(auth_symmetric::unpack(&mut key, &sender_s_kp.verify_key, &copy, None).is_none());

    // Make sure verifying with an invalid key doesn't work
    assert!(auth_symmetric::unpack(&mut key, &receiver_s_kp.verify_key, &packed, None).is_none());

    // Test with salt
    let salt = b"random_salt_data".to_vec();
    let packed_with_salt =
        auth_symmetric::pack(&mut key, &mut sender_s_kp.signature_key, &msg, Some(&salt))
            .expect("Packing with salt failed");

    // Unpacking with correct salt should work
    let unpacked_with_salt = auth_symmetric::unpack(
        &mut key,
        &sender_s_kp.verify_key,
        &packed_with_salt,
        Some(&salt),
    )
    .expect("Unpacking with salt failed");
    assert_eq!(msg.as_slice(), unpacked_with_salt.as_slice());

    // Unpacking with wrong salt should fail
    let wrong_salt = b"wrong_salt_value".to_vec();
    assert!(
        auth_symmetric::unpack(
            &mut key,
            &sender_s_kp.verify_key,
            &packed_with_salt,
            Some(&wrong_salt)
        )
        .is_none()
    );
}