bc_components/kyber/
kyber_level.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
75
76
77
78
79
80
81
82
83
84
85
86
use anyhow::{Result, Error, bail};
use dcbor::prelude::*;
use pqcrypto_kyber::*;

use super::{KyberPrivateKey, KyberPublicKey};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u32)]
pub enum Kyber {
    Kyber512 = 512,
    Kyber768 = 768,
    Kyber1024 = 1024,
}

impl Kyber {
    pub const SHARED_SECRET_SIZE: usize = kyber512::shared_secret_bytes();

    pub fn keypair(self) -> (KyberPrivateKey, KyberPublicKey) {
        match self {
            Kyber::Kyber512 => {
                let (pk, sk) = kyber512::keypair();
                (KyberPrivateKey::Kyber512(sk.into()), KyberPublicKey::Kyber512(pk.into()))
            }
            Kyber::Kyber768 => {
                let (pk, sk) = kyber768::keypair();
                (KyberPrivateKey::Kyber768(sk.into()), KyberPublicKey::Kyber768(pk.into()))
            }
            Kyber::Kyber1024 => {
                let (pk, sk) = kyber1024::keypair();
                (KyberPrivateKey::Kyber1024(sk.into()), KyberPublicKey::Kyber1024(pk.into()))
            }
        }
    }

    pub fn private_key_size(&self) -> usize {
        match self {
            Kyber::Kyber512 => kyber512::secret_key_bytes(),
            Kyber::Kyber768 => kyber768::secret_key_bytes(),
            Kyber::Kyber1024 => kyber1024::secret_key_bytes(),
        }
    }

    pub fn public_key_size(&self) -> usize {
        match self {
            Kyber::Kyber512 => kyber512::public_key_bytes(),
            Kyber::Kyber768 => kyber768::public_key_bytes(),
            Kyber::Kyber1024 => kyber1024::public_key_bytes(),
        }
    }

    pub fn shared_secret_size(&self) -> usize {
        match self {
            Kyber::Kyber512 => kyber512::shared_secret_bytes(),
            Kyber::Kyber768 => kyber768::shared_secret_bytes(),
            Kyber::Kyber1024 => kyber1024::shared_secret_bytes(),
        }
    }

    pub fn ciphertext_size(&self) -> usize {
        match self {
            Kyber::Kyber512 => kyber512::ciphertext_bytes(),
            Kyber::Kyber768 => kyber768::ciphertext_bytes(),
            Kyber::Kyber1024 => kyber1024::ciphertext_bytes(),
        }
    }
}

impl From<Kyber> for CBOR {
    fn from(kyber: Kyber) -> Self {
        (kyber as u32).into()
    }
}

impl TryFrom<CBOR> for Kyber {
    type Error = Error;

    fn try_from(cbor: CBOR) -> Result<Self> {
        let level = u32::try_from(cbor)?;
        match level {
            512 => Ok(Kyber::Kyber512),
            768 => Ok(Kyber::Kyber768),
            1024 => Ok(Kyber::Kyber1024),
            _ => bail!("Invalid Kyber level: {}", level),
        }
    }
}