ipmail 0.1.0

Rust implementation of SP-centric decentralized instant message synchronization protocol(DIMSP)
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
122
123
124
125
126
127
128
129
130
131
132
133
134

use std::fmt::Display;

use hex::{FromHex, ToHex};

use libipld::{
    cbor::DagCborCodec,
    prelude::{Decode, Encode},
    DagCbor,
};
use serde::{Deserialize, Serialize};

#[derive(Debug, thiserror::Error)]
pub enum PublicKeyError {
    #[error("MNS public key deserialize length({0}) error, {1}")]
    DeserializeLength(usize, String),
}

#[derive(Debug, Serialize, DagCbor, Deserialize, Clone, Hash, PartialEq, Eq)]
#[serde(tag = "type", content = "value")]
pub enum PublicKey {
    /// rsa1024 public key
    #[serde(rename = "rsa1024")]
    RSA1024(PublicKeyBuff<128>),
    /// rsa2048 public key
    #[serde(rename = "rsa2048")]
    RSA2048(PublicKeyBuff<256>),
    /// rsa4096 public key
    #[serde(rename = "rsa4096")]
    RSA4096(PublicKeyBuff<512>),
    /// Ed25519 public key
    #[serde(rename = "ed25519")]
    Ed25519(PublicKeyBuff<32>),
    /// ECSDA public key
    #[serde(rename = "ecdsa")]
    ECDSA(PublicKeyBuff<33>),
}

impl Default for PublicKey {
    fn default() -> Self {
        Self::ECDSA(Default::default())
    }
}

impl Display for PublicKey {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::RSA1024(value) => {
                write!(f, "RSA1024: {}", value)
            }
            Self::RSA2048(value) => {
                write!(f, "RSA2048: {}", value)
            }
            Self::RSA4096(value) => {
                write!(f, "RSA4096: {}", value)
            }
            Self::Ed25519(value) => {
                write!(f, "Ed25519: {}", value)
            }
            Self::ECDSA(value) => {
                write!(f, "ECDSA: {}", value)
            }
        }
    }
}

#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub struct PublicKeyBuff<const LEN: usize>(pub [u8; LEN]);

impl<const LEN: usize> Encode<DagCborCodec> for PublicKeyBuff<LEN> {
    fn encode<W: std::io::Write>(&self, c: DagCborCodec, w: &mut W) -> anyhow::Result<()> {
        Ok(self.0.to_vec().encode(c, w)?)
    }
}

impl<const LEN: usize> Decode<DagCborCodec> for PublicKeyBuff<LEN> {
    fn decode<R: std::io::Read + std::io::Seek>(
        c: DagCborCodec,
        r: &mut R,
    ) -> anyhow::Result<Self> {
        let buff = Vec::<u8>::decode(c, r)?;

        if buff.len() != LEN {
            return Err(anyhow::format_err!(
                "DagCbor: read public key({}) length error, {}",
                LEN,
                buff.len(),
            ));
        }

        return Ok(PublicKeyBuff(buff.try_into().unwrap()));
    }
}

impl<const LEN: usize> Default for PublicKeyBuff<LEN> {
    fn default() -> Self {
        Self([0u8; LEN])
    }
}

impl<const LEN: usize> Display for PublicKeyBuff<LEN> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "0x{}", self.0.encode_hex::<String>())
    }
}

impl<const LEN: usize> Serialize for PublicKeyBuff<LEN> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(&self.to_string())
    }
}

impl<'de, const LEN: usize> Deserialize<'de> for PublicKeyBuff<LEN> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let text = String::deserialize(deserializer)?;

        let buff = Vec::<u8>::from_hex(&text.trim_start_matches("0x"))
            .map_err(serde::de::Error::custom)?;

        if buff.len() != LEN {
            return Err(PublicKeyError::DeserializeLength(LEN, text))
                .map_err(serde::de::Error::custom);
        }

        let buff: [u8; LEN] = buff.try_into().unwrap();

        Ok(Self(buff))
    }
}