distant_net/common/transport/framed/exchange/
pkb.rs

1use std::convert::TryFrom;
2use std::io;
3
4use p256::{EncodedPoint, PublicKey};
5use serde::{Deserialize, Deserializer, Serialize, Serializer};
6
7/// Represents a wrapper around [`EncodedPoint`], and exists to
8/// fix an issue with [`serde`] deserialization failing when
9/// directly serializing the [`EncodedPoint`] type
10#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
11#[serde(into = "Vec<u8>", try_from = "Vec<u8>")]
12pub struct PublicKeyBytes(EncodedPoint);
13
14impl From<PublicKey> for PublicKeyBytes {
15    fn from(pk: PublicKey) -> Self {
16        Self(EncodedPoint::from(pk))
17    }
18}
19
20impl TryFrom<PublicKeyBytes> for PublicKey {
21    type Error = io::Error;
22
23    fn try_from(pkb: PublicKeyBytes) -> Result<Self, Self::Error> {
24        PublicKey::from_sec1_bytes(pkb.0.as_ref())
25            .map_err(|x| io::Error::new(io::ErrorKind::InvalidData, x))
26    }
27}
28
29impl From<PublicKeyBytes> for Vec<u8> {
30    fn from(pkb: PublicKeyBytes) -> Self {
31        pkb.0.as_bytes().to_vec()
32    }
33}
34
35impl TryFrom<Vec<u8>> for PublicKeyBytes {
36    type Error = io::Error;
37
38    fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
39        Ok(Self(EncodedPoint::from_bytes(bytes).map_err(|x| {
40            io::Error::new(io::ErrorKind::InvalidData, x.to_string())
41        })?))
42    }
43}
44
45impl serde_bytes::Serialize for PublicKeyBytes {
46    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
47    where
48        S: Serializer,
49    {
50        serializer.serialize_bytes(self.0.as_ref())
51    }
52}
53
54impl<'de> serde_bytes::Deserialize<'de> for PublicKeyBytes {
55    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
56    where
57        D: Deserializer<'de>,
58    {
59        let bytes = Deserialize::deserialize(deserializer).map(serde_bytes::ByteBuf::into_vec)?;
60        PublicKeyBytes::try_from(bytes).map_err(serde::de::Error::custom)
61    }
62}