bc_components/encapsulation/
encapsulation_private_key.rs

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
use anyhow::{Result, bail};
use dcbor::prelude::*;
use crate::{Decrypter, KyberPrivateKey};

use crate::{tags, X25519PrivateKey, EncapsulationScheme, EncapsulationCiphertext, SymmetricKey};

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum EncapsulationPrivateKey {
    X25519(X25519PrivateKey),
    Kyber(KyberPrivateKey),
}

impl EncapsulationPrivateKey {
    pub fn encapsulation_scheme(&self) -> EncapsulationScheme {
        match self {
            Self::X25519(_) => EncapsulationScheme::X25519,
            Self::Kyber(pk) => {
                match pk.level() {
                    crate::Kyber::Kyber512 => EncapsulationScheme::Kyber512,
                    crate::Kyber::Kyber768 => EncapsulationScheme::Kyber768,
                    crate::Kyber::Kyber1024 => EncapsulationScheme::Kyber1024,
                }
            }
        }
    }

    pub fn decapsulate_shared_secret(&self, ciphertext: &EncapsulationCiphertext) -> Result<SymmetricKey> {
        match (self, ciphertext) {
            (EncapsulationPrivateKey::X25519(private_key), EncapsulationCiphertext::X25519(public_key)) => {
                Ok(private_key.shared_key_with(public_key))
            }
            (EncapsulationPrivateKey::Kyber(private_key), EncapsulationCiphertext::Kyber(ciphertext)) => {
                private_key.decapsulate_shared_secret(ciphertext)
            }
            _ => bail!("Mismatched key encapsulation types. private key: {:?}, ciphertext: {:?}", self.encapsulation_scheme(), ciphertext.encapsulation_scheme()),
        }
    }
}

impl Decrypter for EncapsulationPrivateKey {
    fn encapsulation_private_key(&self) -> EncapsulationPrivateKey {
        self.clone()
    }

    fn decapsulate_shared_secret(&self, ciphertext: &EncapsulationCiphertext) -> Result<SymmetricKey> {
        self.decapsulate_shared_secret(ciphertext)
    }
}

impl From<EncapsulationPrivateKey> for CBOR {
    fn from(ciphertext: EncapsulationPrivateKey) -> Self {
        match ciphertext {
            EncapsulationPrivateKey::X25519(public_key) => public_key.into(),
            EncapsulationPrivateKey::Kyber(ciphertext) => ciphertext.into(),
        }
    }
}

impl TryFrom<CBOR> for EncapsulationPrivateKey {
    type Error = anyhow::Error;

    fn try_from(cbor: CBOR) -> Result<Self> {
        match cbor.as_case() {
            CBORCase::Tagged(tag, _) => {
                match tag.value() {
                    tags::TAG_X25519_PRIVATE_KEY => Ok(EncapsulationPrivateKey::X25519(X25519PrivateKey::try_from(cbor)?)),
                    tags::TAG_KYBER_PRIVATE_KEY => Ok(EncapsulationPrivateKey::Kyber(KyberPrivateKey::try_from(cbor)?)),
                    _ => bail!("Invalid encapsulation private key")
                }
            }
            _ => bail!("Invalid encapsulation private key")
        }
    }
}