botan 0.8.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

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

use crate::mp::MPI;

#[derive(Debug)]
/// Represents an instance of format preserving encryption
///
/// # Examples
///
/// ```
/// use std::str::FromStr;
/// let modulus = botan::MPI::from_str("1000000000").unwrap();
/// let key = vec![0; 32];
/// let rounds = 16;
/// let compat_mode = false;
/// let fpe = botan::FPE::new_fe1(&modulus, &key, rounds, compat_mode).unwrap();
/// let input = botan::MPI::from_str("9392024").unwrap();
/// let tweak = vec![1,2,3,4,5];
/// let ctext = fpe.encrypt(&input, &tweak).unwrap();
/// assert!(ctext < modulus);
/// let ptext = fpe.decrypt(&ctext, &tweak).unwrap();
/// assert_eq!(ptext, input);
/// ```
pub struct FPE {
    obj: botan_fpe_t,
}

impl Drop for FPE {
    fn drop(&mut self) {
        unsafe {
            botan_fpe_destroy(self.obj);
        }
    }
}

impl FPE {
    /// Create a new FPE instance, FE1 scheme
    /// Rounds should be 16 or higher for best security
    pub fn new_fe1(modulus: &MPI, key: &[u8], rounds: usize, compat_mode: bool) -> Result<FPE> {
        let mut obj = ptr::null_mut();

        let flags = if compat_mode { 1 } else { 0 };

        call_botan! {
            botan_fpe_fe1_init(&mut obj, modulus.handle(),
                               key.as_ptr(), key.len(),
                               rounds, flags)
        }

        Ok(FPE { obj })
    }

    /// Encrypt value under the FPE scheme using provided tweak
    pub fn encrypt(&self, x: &MPI, tweak: &[u8]) -> Result<MPI> {
        let r = x.duplicate()?;
        call_botan! {
            botan_fpe_encrypt(self.obj, r.handle(), tweak.as_ptr(), tweak.len())
        }

        Ok(r)
    }

    /// Decrypt value under the FPE scheme using provided tweak
    pub fn decrypt(&self, x: &MPI, tweak: &[u8]) -> Result<MPI> {
        let r = x.duplicate()?;
        call_botan! {
            botan_fpe_decrypt(self.obj, r.handle(), tweak.as_ptr(), tweak.len())
        }

        Ok(r)
    }
}