prople_did_core/keys/
verification.rs

1use multibase::{self, Base::Base58Btc};
2
3use prople_crypto::eddsa::privkey::PrivKey;
4use prople_crypto::eddsa::{keypair::KeyPair, pubkey::PubKey};
5use prople_crypto::keysecure::types::{Password, ToKeySecure};
6use prople_crypto::keysecure::KeySecure;
7use prople_crypto::types::{ByteHex, Hexer};
8
9use crate::keys::{KeySecureBuilder, KeySecureError};
10
11/// `Error` is a specific error types used for verification only
12#[derive(Debug, PartialEq)]
13pub enum Error {
14    GeneratePrivKeyError,
15    DecodePublicKeyError,
16    GenerateSecureKeyError,
17}
18
19/// `Pairs` used to generate public and private keys from `EdDSA` algorithm
20#[derive(Debug, Clone)]
21pub struct Pairs {
22    pub pub_key: String,
23    pub priv_key: PrivKey,
24}
25
26impl Pairs {
27    pub fn is_valid(&self) -> bool {
28        let try_to_pem = self.priv_key.to_pem();
29        let pem = match try_to_pem {
30            Ok(value) => value,
31            Err(_) => return false,
32        };
33
34        !self.pub_key.is_empty() || !pem.is_empty()
35    }
36
37    pub fn decode_pub_key(&self) -> Result<PubKey, Error> {
38        let (_, pubkey_bytes) =
39            multibase::decode(&self.pub_key).map_err(|_| Error::DecodePublicKeyError)?;
40        let pubkey_string =
41            String::from_utf8(pubkey_bytes).map_err(|_| Error::DecodePublicKeyError)?;
42        let pubkey = PubKey::from_hex(ByteHex::from(pubkey_string))
43            .map_err(|_| Error::DecodePublicKeyError)?;
44
45        Ok(pubkey)
46    }
47}
48
49impl KeySecureBuilder for Pairs {
50    fn build_keysecure(&self, password: String) -> Result<KeySecure, KeySecureError> {
51        self.priv_key
52            .to_keysecure(Password::from(password))
53            .map_err(|_| KeySecureError::BuildKeySecureError)
54    }
55}
56
57/// `Key` used to hold a key pair from [`Ed25519::KeyPair`]
58pub struct Key {
59    keypair: KeyPair,
60}
61
62impl Default for Key {
63    fn default() -> Self {
64        Self::new()
65    }
66}
67
68impl Key {
69    pub fn new() -> Self {
70        Self {
71            keypair: KeyPair::generate(),
72        }
73    }
74
75    pub fn generate(&self) -> Pairs {
76        let pub_key = self.keypair.pub_key();
77        let priv_key = self.keypair.priv_key();
78
79        let pub_key_hex = pub_key.to_hex();
80        let pub_key_encoded = multibase::encode(Base58Btc, pub_key_hex.hex().as_bytes());
81
82        Pairs {
83            pub_key: pub_key_encoded,
84            priv_key,
85        }
86    }
87}
88
89#[cfg(test)]
90mod tests {
91    use super::*;
92
93    #[test]
94    fn test_generate_keypairs() {
95        let verification = Key::new();
96        let keypairs = verification.generate();
97        assert!(keypairs.is_valid())
98    }
99
100    #[test]
101    fn test_decode_public_key() {
102        let verification = Key::new();
103        let pairs = verification.generate();
104
105        let privkey_pem = pairs.priv_key.to_pem();
106        assert!(!privkey_pem.is_err());
107
108        let keypair_generated = KeyPair::from_pem(privkey_pem.unwrap());
109        assert!(!keypair_generated.is_err());
110
111        let pubkey_decoded = pairs.decode_pub_key();
112        assert!(!pubkey_decoded.is_err());
113
114        let keypair = keypair_generated.unwrap();
115        let pubkey_regenerated = keypair.pub_key().to_hex();
116        assert_eq!(pubkey_regenerated, pubkey_decoded.unwrap().to_hex())
117    }
118}
prople_did_core/keys/verification.rs

prople_did_core/keys/
verification.rs
