aries-askar 0.4.6

Askar cryptographic primitives and secure storage
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

use super::local_key::LocalKey;
use crate::{
    crypto::{
        alg::{x25519::X25519KeyPair, KeyAlg},
        buffer::SecretBytes,
        encrypt::crypto_box::{
            crypto_box as nacl_box, crypto_box_open as nacl_box_open,
            crypto_box_seal as nacl_box_seal, crypto_box_seal_open as nacl_box_seal_open,
            CBOX_NONCE_LENGTH, CBOX_TAG_LENGTH,
        },
        kdf::{ecdh_1pu::Ecdh1PU, ecdh_es::EcdhEs},
        random::fill_random,
    },
    error::Error,
};

#[inline]
fn cast_x25519(key: &LocalKey) -> Result<&X25519KeyPair, Error> {
    if let Some(kp) = key.inner.downcast_ref::<X25519KeyPair>() {
        Ok(kp)
    } else {
        Err(err_msg!(Input, "x25519 keypair required"))
    }
}

/// Generate a new random nonce for crypto_box
pub fn crypto_box_random_nonce() -> Result<[u8; CBOX_NONCE_LENGTH], Error> {
    let mut nonce = [0u8; CBOX_NONCE_LENGTH];
    fill_random(&mut nonce);
    Ok(nonce)
}

/// Encrypt a message with crypto_box and a detached nonce
pub fn crypto_box(
    recip_x25519: &LocalKey,
    sender_x25519: &LocalKey,
    message: &[u8],
    nonce: &[u8],
) -> Result<Vec<u8>, Error> {
    let recip_pk = cast_x25519(recip_x25519)?;
    let sender_sk = cast_x25519(sender_x25519)?;
    let mut buffer = SecretBytes::from_slice_reserve(message, CBOX_TAG_LENGTH);
    nacl_box(recip_pk, sender_sk, &mut buffer, nonce)?;
    Ok(buffer.into_vec())
}

/// Decrypt a message with crypto_box and a detached nonce
pub fn crypto_box_open(
    recip_x25519: &LocalKey,
    sender_x25519: &LocalKey,
    message: &[u8],
    nonce: &[u8],
) -> Result<SecretBytes, Error> {
    let recip_pk = cast_x25519(recip_x25519)?;
    let sender_sk = cast_x25519(sender_x25519)?;
    let mut buffer = SecretBytes::from_slice(message);
    nacl_box_open(recip_pk, sender_sk, &mut buffer, nonce)?;
    Ok(buffer)
}

/// Perform message encryption equivalent to libsodium's `crypto_box_seal`
pub fn crypto_box_seal(recip_x25519: &LocalKey, message: &[u8]) -> Result<Vec<u8>, Error> {
    let kp = cast_x25519(recip_x25519)?;
    let sealed = nacl_box_seal(kp, message)?;
    Ok(sealed.into_vec())
}

/// Perform message decryption equivalent to libsodium's `crypto_box_seal_open`
pub fn crypto_box_seal_open(
    recip_x25519: &LocalKey,
    ciphertext: &[u8],
) -> Result<SecretBytes, Error> {
    let kp = cast_x25519(recip_x25519)?;
    Ok(nacl_box_seal_open(kp, ciphertext)?)
}

/// Derive an ECDH-1PU shared key for authenticated encryption
#[allow(clippy::too_many_arguments)]
pub fn derive_key_ecdh_1pu(
    key_alg: KeyAlg,
    ephem_key: &LocalKey,
    sender_key: &LocalKey,
    recip_key: &LocalKey,
    alg_id: &[u8],
    apu: &[u8],
    apv: &[u8],
    cc_tag: &[u8],
    receive: bool,
) -> Result<LocalKey, Error> {
    let derive = Ecdh1PU::new(
        ephem_key, sender_key, recip_key, alg_id, apu, apv, cc_tag, receive,
    );
    LocalKey::from_key_derivation(key_alg, derive)
}

/// Derive an ECDH-ES shared key for anonymous encryption
pub fn derive_key_ecdh_es(
    key_alg: KeyAlg,
    ephem_key: &LocalKey,
    recip_key: &LocalKey,
    alg_id: &[u8],
    apu: &[u8],
    apv: &[u8],
    receive: bool,
) -> Result<LocalKey, Error> {
    let derive = EcdhEs::new(ephem_key, recip_key, alg_id, apu, apv, receive);
    LocalKey::from_key_derivation(key_alg, derive)
}