keri_core/prefix/
basic.rs

1use core::{fmt, str::FromStr};
2
3use serde::{Deserialize, Deserializer, Serialize, Serializer};
4
5use super::{error::Error, verify, SelfSigningPrefix};
6use crate::{event::sections::key_config::SignatureError, keys::PublicKey};
7use cesrox::{
8    conversion::from_text_to_bytes,
9    derivation_code::DerivationCode,
10    primitives::{
11        codes::{basic::Basic as CesrBasic, PrimitiveCode},
12        CesrPrimitive,
13    },
14};
15
16#[derive(Clone, Eq, PartialEq, Hash, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
17#[rkyv(compare(PartialEq), derive(Debug))]
18pub enum BasicPrefix {
19    ECDSAsecp256k1NT(PublicKey),
20    ECDSAsecp256k1(PublicKey),
21    Ed25519NT(PublicKey),
22    Ed25519(PublicKey),
23    Ed448NT(PublicKey),
24    Ed448(PublicKey),
25    X25519(PublicKey),
26    X448(PublicKey),
27}
28
29impl fmt::Debug for BasicPrefix {
30    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
31        write!(f, "{:?}", self.to_str())
32    }
33}
34
35impl BasicPrefix {
36    pub fn new(code: CesrBasic, public_key: PublicKey) -> Self {
37        match code {
38            CesrBasic::ECDSAsecp256k1Nontrans => Self::ECDSAsecp256k1NT(public_key),
39            CesrBasic::ECDSAsecp256k1 => Self::ECDSAsecp256k1(public_key),
40            CesrBasic::Ed25519Nontrans => Self::Ed25519NT(public_key),
41            CesrBasic::Ed25519 => Self::Ed25519(public_key),
42            CesrBasic::Ed448Nontrans => Self::Ed448NT(public_key),
43            CesrBasic::Ed448 => Self::Ed448(public_key),
44            CesrBasic::X25519 => Self::X25519(public_key),
45            CesrBasic::X448 => Self::X448(public_key),
46        }
47    }
48
49    pub fn verify(
50        &self,
51        data: &[u8],
52        signature: &SelfSigningPrefix,
53    ) -> Result<bool, SignatureError> {
54        verify(data, self, signature)
55    }
56
57    /// Non transferable means that the public key is always the current public key.
58    /// Transferable means that the public key might have changed and
59    /// you need to request KEL to obtain the newest one.
60    pub fn is_transferable(&self) -> bool {
61        match self {
62            BasicPrefix::ECDSAsecp256k1NT(_)
63            | BasicPrefix::Ed25519NT(_)
64            | BasicPrefix::Ed448NT(_) => false,
65            _ => true,
66        }
67    }
68
69    pub fn get_code(&self) -> CesrBasic {
70        match self {
71            BasicPrefix::ECDSAsecp256k1NT(_) => CesrBasic::ECDSAsecp256k1Nontrans,
72            BasicPrefix::ECDSAsecp256k1(_) => CesrBasic::ECDSAsecp256k1,
73            BasicPrefix::Ed25519NT(_) => CesrBasic::Ed25519Nontrans,
74            BasicPrefix::Ed25519(_) => CesrBasic::Ed25519,
75            BasicPrefix::Ed448NT(_) => CesrBasic::Ed448Nontrans,
76            BasicPrefix::Ed448(_) => CesrBasic::Ed448,
77            BasicPrefix::X25519(_) => CesrBasic::X25519,
78            BasicPrefix::X448(_) => CesrBasic::X448,
79        }
80    }
81}
82
83impl FromStr for BasicPrefix {
84    type Err = Error;
85
86    fn from_str(s: &str) -> Result<Self, Self::Err> {
87        let code = CesrBasic::from_str(s)?;
88
89        if s.len() == code.full_size() {
90            let k_vec =
91                from_text_to_bytes(s[code.code_size()..].as_bytes())?[code.code_size()..].to_vec();
92            Ok(Self::new(code, PublicKey::new(k_vec)))
93        } else {
94            Err(Error::IncorrectLengthError(s.into()))
95        }
96    }
97}
98
99impl CesrPrimitive for BasicPrefix {
100    fn derivative(&self) -> Vec<u8> {
101        match self {
102            BasicPrefix::ECDSAsecp256k1NT(pk)
103            | BasicPrefix::ECDSAsecp256k1(pk)
104            | BasicPrefix::Ed25519NT(pk)
105            | BasicPrefix::Ed25519(pk)
106            | BasicPrefix::Ed448NT(pk)
107            | BasicPrefix::Ed448(pk)
108            | BasicPrefix::X25519(pk)
109            | BasicPrefix::X448(pk) => pk.key(),
110        }
111    }
112    fn derivation_code(&self) -> PrimitiveCode {
113        PrimitiveCode::Basic(self.get_code())
114    }
115}
116
117/// Serde compatible Serialize
118impl Serialize for BasicPrefix {
119    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
120    where
121        S: Serializer,
122    {
123        serializer.serialize_str(&self.to_str())
124    }
125}
126
127/// Serde compatible Deserialize
128impl<'de> Deserialize<'de> for BasicPrefix {
129    fn deserialize<D>(deserializer: D) -> Result<BasicPrefix, D::Error>
130    where
131        D: Deserializer<'de>,
132    {
133        let s = String::deserialize(deserializer)?;
134
135        BasicPrefix::from_str(&s).map_err(serde::de::Error::custom)
136    }
137}
138
139#[test]
140fn serialize_deserialize() {
141    use ed25519_dalek::Keypair;
142    use rand::rngs::OsRng;
143
144    let kp = Keypair::generate(&mut OsRng);
145
146    let bp = BasicPrefix::Ed25519(PublicKey::new(kp.public.to_bytes().to_vec()));
147
148    let serialized = serde_json::to_string(&bp);
149    assert!(serialized.is_ok());
150
151    let deserialized = serde_json::from_str::<BasicPrefix>(&serialized.unwrap());
152
153    assert!(deserialized.is_ok());
154    assert_eq!(bp, deserialized.unwrap());
155}
156
157#[test]
158fn to_from_string() {
159    use ed25519_dalek::Keypair;
160    use rand::rngs::OsRng;
161
162    use crate::keys::PrivateKey;
163
164    let kp = Keypair::generate(&mut OsRng);
165
166    let signer = PrivateKey::new(kp.secret.to_bytes().to_vec());
167
168    let message = b"hello there";
169    let sig = SelfSigningPrefix::Ed25519Sha512(signer.sign_ed(message).unwrap());
170
171    let bp = BasicPrefix::Ed25519(PublicKey::new(kp.public.to_bytes().to_vec()));
172
173    assert!(bp.verify(message, &sig).unwrap());
174
175    let string = bp.to_str();
176
177    let from_str = BasicPrefix::from_str(&string);
178
179    assert!(from_str.is_ok());
180    let deser = from_str.unwrap();
181    assert_eq!(bp, deser);
182
183    assert!(deser.verify(message, &sig).unwrap());
184}
keri_core/prefix/basic.rs

keri_core/prefix/
basic.rs
