botan 0.11.1

Rust wrapper for Botan cryptography library
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

use crate::utils::*;
use botan_sys::*;

use crate::pubkey::{Privkey, Pubkey};
use crate::rng::RandomNumberGenerator;

#[derive(Debug)]
/// An object that can perform key encapsulation
pub struct KeyEncapsulation {
    obj: botan_pk_op_kem_encrypt_t,
    encap_length: usize,
}

unsafe impl Sync for KeyEncapsulation {}
unsafe impl Send for KeyEncapsulation {}

botan_impl_drop!(KeyEncapsulation, botan_pk_op_kem_encrypt_destroy);

impl KeyEncapsulation {
    /// Create a KeyEncapsulation operation
    pub fn new(key: &Pubkey, kdf: &str) -> Result<Self> {
        let kdf = make_cstr(kdf)?;
        let obj = botan_init!(botan_pk_op_kem_encrypt_create, key.handle(), kdf.as_ptr())?;

        let encap_length = botan_usize!(botan_pk_op_kem_encrypt_encapsulated_key_length, obj)?;
        Ok(Self { obj, encap_length })
    }

    /// Return the shared key length
    pub fn shared_key_length(&self, desired_shared_key_length: usize) -> Result<usize> {
        let mut val = 0;
        let rc = unsafe {
            botan_pk_op_kem_encrypt_shared_key_length(self.obj, desired_shared_key_length, &mut val)
        };
        if rc != 0 {
            Err(Error::from_rc(rc))
        } else {
            Ok(val)
        }
    }

    /// Create a new encapsulated key
    pub fn create_shared_key(
        &self,
        rng: &mut RandomNumberGenerator,
        salt: &[u8],
        desired_key_len: usize,
    ) -> Result<(Vec<u8>, Vec<u8>)> {
        let mut shared_key_len = self.shared_key_length(desired_key_len)?;
        let mut shared_key = vec![0; shared_key_len];
        let mut encap_key_len = self.encap_length;
        let mut encap_key = vec![0; encap_key_len];

        let rc = unsafe {
            botan_pk_op_kem_encrypt_create_shared_key(
                self.obj,
                rng.handle(),
                salt.as_ptr(),
                salt.len(),
                desired_key_len,
                shared_key.as_mut_ptr(),
                &mut shared_key_len,
                encap_key.as_mut_ptr(),
                &mut encap_key_len,
            )
        };

        if rc != 0 {
            return Err(Error::from_rc(rc));
        }

        Ok((shared_key, encap_key))
    }
}

#[derive(Debug)]
/// An object that can perform key decapsulation
pub struct KeyDecapsulation {
    obj: botan_pk_op_kem_decrypt_t,
}

unsafe impl Sync for KeyDecapsulation {}
unsafe impl Send for KeyDecapsulation {}

botan_impl_drop!(KeyDecapsulation, botan_pk_op_kem_decrypt_destroy);

impl KeyDecapsulation {
    /// Create a KeyDecapsulation operation
    pub fn new(key: &Privkey, kdf: &str) -> Result<Self> {
        let kdf = make_cstr(kdf)?;
        let obj = botan_init!(botan_pk_op_kem_decrypt_create, key.handle(), kdf.as_ptr())?;

        Ok(Self { obj })
    }

    /// Return the shared key length
    pub fn shared_key_length(&self, desired_shared_key_length: usize) -> Result<usize> {
        let mut val = 0;
        let rc = unsafe {
            botan_pk_op_kem_decrypt_shared_key_length(self.obj, desired_shared_key_length, &mut val)
        };
        if rc != 0 {
            Err(Error::from_rc(rc))
        } else {
            Ok(val)
        }
    }

    /// Decrypt an encapsulated key
    pub fn decrypt_shared_key(
        &self,
        encapsulated_key: &[u8],
        salt: &[u8],
        desired_key_len: usize,
    ) -> Result<Vec<u8>> {
        let mut shared_key_len = self.shared_key_length(desired_key_len)?;
        let mut shared_key = vec![0; shared_key_len];

        let rc = unsafe {
            botan_pk_op_kem_decrypt_shared_key(
                self.obj,
                salt.as_ptr(),
                salt.len(),
                encapsulated_key.as_ptr(),
                encapsulated_key.len(),
                desired_key_len,
                shared_key.as_mut_ptr(),
                &mut shared_key_len,
            )
        };

        if rc != 0 {
            return Err(Error::from_rc(rc));
        }

        Ok(shared_key)
    }
}