pq_envelope/
keys.rs

1use crate::{Error, Result, Scheme, util::*};
2use derive_more::Display;
3use serde::{Deserialize, Deserializer, Serialize, Serializer};
4use std::{
5    fmt::{self, Debug, Formatter},
6    ops::Deref,
7};
8
9macro_rules! serde_impl {
10    ($name:ident, $err:expr) => {
11        impl Serialize for $name {
12            fn serialize<S>(&self, s: S) -> std::result::Result<S::Ok, S::Error>
13            where
14                S: Serializer,
15            {
16                serdect::slice::serialize_hex_lower_or_bin(&self.0, s)
17            }
18        }
19
20        impl<'de> Deserialize<'de> for $name {
21            fn deserialize<D>(d: D) -> std::result::Result<Self, D::Error>
22            where
23                D: Deserializer<'de>,
24            {
25                let bytes = serdect::slice::deserialize_hex_or_bin_vec(d)?;
26                Self::from_slice(&bytes).map_err(|_| serde::de::Error::custom($err))
27            }
28        }
29    };
30}
31
32/// A public encapsulation key
33#[derive(Clone, Display, Eq, PartialEq)]
34#[display("{}", hex::encode(self.0.as_ref()))]
35#[repr(transparent)]
36pub struct PublicKey(oqs::kem::PublicKey);
37
38impl AsRef<[u8]> for PublicKey {
39    fn as_ref(&self) -> &[u8] {
40        self.0.as_ref()
41    }
42}
43
44impl Deref for PublicKey {
45    type Target = oqs::kem::PublicKey;
46
47    fn deref(&self) -> &Self::Target {
48        &self.0
49    }
50}
51
52impl Debug for PublicKey {
53    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
54        debug_key(&self.0, scheme_from_public_key_length, f)
55    }
56}
57
58impl From<oqs::kem::PublicKey> for PublicKey {
59    fn from(pk: oqs::kem::PublicKey) -> Self {
60        PublicKey(pk)
61    }
62}
63
64serde_impl!(PublicKey, "invalid public key");
65
66impl PublicKey {
67    /// Convert a public key from a slice of bytes
68    pub fn from_slice(bytes: &[u8]) -> Result<Self> {
69        let kem: oqs::kem::Kem = scheme_from_public_key_length(bytes.len())?.into();
70        kem.public_key_from_bytes(bytes)
71            .map(|p| Self(p.to_owned()))
72            .ok_or(Error::InvalidEncapsulationKey(bytes.len()))
73    }
74}
75
76/// A private decapsulation key
77#[derive(Clone, Display, Eq, PartialEq)]
78#[display("{}", hex::encode(self.0.as_ref()))]
79#[repr(transparent)]
80pub struct SecretKey(oqs::kem::SecretKey);
81
82impl AsRef<[u8]> for SecretKey {
83    fn as_ref(&self) -> &[u8] {
84        self.0.as_ref()
85    }
86}
87
88impl Deref for SecretKey {
89    type Target = oqs::kem::SecretKey;
90
91    fn deref(&self) -> &Self::Target {
92        &self.0
93    }
94}
95
96impl Debug for SecretKey {
97    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
98        debug_key(&self.0, scheme_from_secret_key_length, f)
99    }
100}
101
102impl From<oqs::kem::SecretKey> for SecretKey {
103    fn from(pk: oqs::kem::SecretKey) -> Self {
104        SecretKey(pk)
105    }
106}
107
108serde_impl!(SecretKey, "invalid secret key");
109
110impl SecretKey {
111    /// Convert a secret key from a slice of bytes
112    pub fn from_slice(bytes: &[u8]) -> Result<Self> {
113        let kem: oqs::kem::Kem = scheme_from_public_key_length(bytes.len())?.into();
114        kem.secret_key_from_bytes(bytes)
115            .map(|p| Self(p.to_owned()))
116            .ok_or(Error::InvalidDecapsulationKey)
117    }
118}
119
120fn debug_key<B: AsRef<[u8]>, S: FnOnce(usize) -> Result<Scheme>>(
121    b: B,
122    s: S,
123    f: &mut Formatter,
124) -> fmt::Result {
125    let bytes = b.as_ref();
126    let scheme = s(bytes.len()).map_err(|_| fmt::Error)?;
127    write!(f, "{} {{ {} }}", scheme, hex::encode(bytes))
128}
pq_envelope/keys.rs

pq_envelope/
keys.rs
