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

//! `privkey` is a module that provides a primary object of [`PrivKey`]
use rst_common::with_cryptography::ed25519_dalek::pkcs8::EncodePrivateKey;
use rst_common::with_cryptography::ed25519_dalek::{self, SigningKey};

use crate::keysecure::types::constants::CONTEXT_ED25519;
use crate::keysecure::types::errors::KeySecureError;
use crate::keysecure::types::ToKeySecure;
use crate::keysecure::builder::Builder;
use crate::keysecure::KeySecure;

use crate::eddsa::types::errors::EddsaError;
use crate::eddsa::types::EdDSAPrivKeyBytes;

/// `PrivKey` is a private key generated from [`SigningKey`]
///
/// This object also able to serialize and encode the private key into `PEM` format
/// Once this object encoded into `PEM`, we also able to encrypt the data and generate [`KeySecure`]
/// object from it through trait [`ToKeySecure`].
#[derive(Debug, Clone)]
pub struct PrivKey {
    key: SigningKey,
}

impl PrivKey {
    pub fn new(key: SigningKey) -> Self {
        Self { key }
    }

    pub fn serialize(&self) -> EdDSAPrivKeyBytes {
        self.key.to_bytes()
    }

    pub fn to_pem(&self) -> Result<String, EddsaError> {
        self.key
            .to_pkcs8_pem(ed25519_dalek::pkcs8::spki::der::pem::LineEnding::default())
            .map(|val| val.to_string())
            .map_err(|err| EddsaError::EncodePemError(err.to_string()))
    }
}

impl ToKeySecure for PrivKey {
    fn to_keysecure(&self, password: String) -> Result<KeySecure, KeySecureError> {
        let pem = self
            .to_pem()
            .map_err(|err| KeySecureError::BuildKeySecureError(err.to_string()))?;

        let keysecure_builder = Builder::new(CONTEXT_ED25519.to_string(), password);
        let keysecure = keysecure_builder.secure(pem)?;

        Ok(keysecure)
    }
}