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

use crate::crypto::{
    signature::{self, SigningKey, VerifyingKey},
    symmetric::SymmetricKey,
};

/// Pack a new signed container using symmetric encryption. Encrypts symmetrically and attaches a signature.
///
/// A salt can be added to prevent replay attacks.
pub fn pack(
    key: &mut SymmetricKey,
    signing_key: &mut SigningKey,
    message: &Vec<u8>,
    salt: Option<&Vec<u8>>,
) -> Option<Vec<u8>> {
    let mut encrypted = key.encrypt(message)?;

    // Add the salt to the message (in case there is one)
    if let Some(salt) = salt {
        encrypted.extend(signature::sign(
            signing_key,
            &message.iter().chain(salt).cloned().collect(),
        )?);
    } else {
        encrypted.extend(signature::sign(signing_key, message)?);
    }
    Some(encrypted)
}

/// Unpack a new signed container using symmetric encryption. Decrypts symmetrically and verifies the signature.
/// Returns ``None`` in case of failing to verify the signature.
///
/// A salt can be added to prevent replay attacks.
pub fn unpack(
    key: &mut SymmetricKey,
    verifying_key: &VerifyingKey,
    ciphertext: &Vec<u8>,
    salt: Option<&Vec<u8>>,
) -> Option<Vec<u8>> {
    // Split into signature and ciphertext
    if ciphertext.len() <= signature::SIGNATURE_LEN {
        return None;
    }
    let (ciphertext, signed) = ciphertext.split_at(ciphertext.len() - signature::SIGNATURE_LEN);

    // Decrypt the message
    let decrypted = key.decrypt(&ciphertext.to_vec())?;

    // Verify the signature with the salt (if desired)
    if let Some(salt) = salt {
        if !signature::verify(
            verifying_key,
            &decrypted.iter().chain(salt.iter()).cloned().collect(),
            &signed.to_vec(),
        )? {
            return None;
        }
    } else {
        if !signature::verify(verifying_key, &decrypted, &signed.to_vec())? {
            return None;
        }
    }
    return Some(decrypted);
}