sequoia-openpgp 2.2.0

OpenPGP data types and associated machinery
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

//! Implementation of AEAD using the Botan cryptographic library.

use crate::{Error, Result};

use crate::crypto::aead::{Context, CipherOp};
use crate::crypto::mem::Protected;
use crate::seal;
use crate::types::{AEADAlgorithm, SymmetricAlgorithm};

struct Cipher(botan::Cipher, usize);

impl seal::Sealed for Cipher {}
impl Context for Cipher {
    fn encrypt_seal(&mut self, dst: &mut [u8], src: &[u8]) -> Result<()> {
        debug_assert_eq!(dst.len(), src.len() + self.digest_size());
        self.0.finish_into(src, dst)?;
        Ok(())
    }

    fn decrypt_verify(&mut self, dst: &mut [u8], src: &[u8]) -> Result<()> {
        debug_assert_eq!(dst.len() + self.digest_size(), src.len());
        self.0.finish_into(src, dst)?;
        Ok(())
    }
    fn digest_size(&self) -> usize {
        self.1
    }
}

impl AEADAlgorithm {
    /// Returns the name of the algorithm for use with Botan's
    /// constructor.
    fn botan_name(self) -> Result<&'static str> {
        match self {
            AEADAlgorithm::EAX => Ok("EAX"),
            AEADAlgorithm::OCB => Ok("OCB"),
            AEADAlgorithm::GCM => Ok("GCM"),
            _ => Err(Error::UnsupportedAEADAlgorithm(self).into()),
        }
    }
}


impl crate::crypto::backend::interface::Aead for super::Backend {
    fn supports_algo(algo: AEADAlgorithm) -> bool {
        use self::AEADAlgorithm::*;
        match algo {
            EAX | OCB | GCM
                => true,
            Private(_) | Unknown(_)
                => false,
        }
    }

    fn supports_algo_with_symmetric(algo: AEADAlgorithm,
                                    symm: SymmetricAlgorithm)
                                    -> bool
    {
        match algo {
            AEADAlgorithm::EAX => match symm {
                SymmetricAlgorithm::AES128 |
                SymmetricAlgorithm::AES192 |
                SymmetricAlgorithm::AES256 |
                SymmetricAlgorithm::Twofish |
                SymmetricAlgorithm::Camellia128 |
                SymmetricAlgorithm::Camellia192 |
                SymmetricAlgorithm::Camellia256 => true,
                _ => false,
            },

            AEADAlgorithm::OCB => match symm {
                SymmetricAlgorithm::AES128 |
                SymmetricAlgorithm::AES192 |
                SymmetricAlgorithm::AES256 |
                SymmetricAlgorithm::Twofish |
                SymmetricAlgorithm::Camellia128 |
                SymmetricAlgorithm::Camellia192 |
                SymmetricAlgorithm::Camellia256 => true,
                _ => false,
            },

            AEADAlgorithm::GCM => match symm {
                SymmetricAlgorithm::AES128 |
                SymmetricAlgorithm::AES192 |
                SymmetricAlgorithm::AES256 |
                SymmetricAlgorithm::Twofish |
                SymmetricAlgorithm::Camellia128 |
                SymmetricAlgorithm::Camellia192 |
                SymmetricAlgorithm::Camellia256 => true,
                _ => false,
            },

            AEADAlgorithm::Private(_) |
            AEADAlgorithm::Unknown(_) => false,
        }
    }

    fn context(algo: AEADAlgorithm,
               sym_algo: SymmetricAlgorithm,
               key: &Protected,
               aad: &[u8],
               nonce: &[u8],
               op: CipherOp)
               -> Result<Box<dyn Context>>
    {
        let mut cipher = botan::Cipher::new(
            &format!("{}/{}", sym_algo.botan_name()?, algo.botan_name()?),
            match op {
                CipherOp::Encrypt => botan::CipherDirection::Encrypt,
                CipherOp::Decrypt => botan::CipherDirection::Decrypt,
            })
        // XXX it could be the cipher that is not supported.
            .map_err(|_| Error::UnsupportedAEADAlgorithm(algo))?;

        cipher.set_key(key)?;
        cipher.set_associated_data(aad)?;
        cipher.start(nonce)?;

        Ok(Box::new(Cipher(cipher, algo.digest_size()?)))
    }
}