did_crypto/crypto/
eddsa.rs

1use ed25519_dalek::{
2    pkcs8::DecodePrivateKey, pkcs8::DecodePublicKey, Signer, SigningKey, Verifier,
3};
4use ed25519_dalek::{Signature, VerifyingKey};
5
6use crate::algorithms::Algorithm;
7use crate::errors::Error;
8use crate::log;
9
10use super::{SignFromKey, VerifyFromKey};
11
12pub struct EDDSASigningKey {
13    key: SigningKey,
14}
15
16impl SignFromKey for EDDSASigningKey {
17    fn sign(&self, content: String, _alg: Algorithm) -> Result<String, Error> {
18        let sig_result: Result<Signature, ed25519_dalek::ed25519::Error> =
19            self.key.try_sign(content.as_bytes());
20        let signature = match sig_result {
21            Ok(val) => val,
22            Err(error) => {
23                log::error(error.to_string().as_str());
24                return Err(Error::SIGNING_FAILED);
25            }
26        };
27
28        Ok(base64_url::encode(signature.to_bytes().as_slice()))
29    }
30}
31
32impl EDDSASigningKey {
33    pub fn from_pem(key_str: &str) -> Result<Self, Error> {
34        let pkc8_key = match SigningKey::from_pkcs8_pem(key_str) {
35            Ok(val) => val,
36            Err(error) => {
37                log::error(error.to_string().as_str());
38                return Err(Error::PRIVATE_KEY_IDENTIFICATION_ERROR);
39            }
40        };
41
42        Ok(EDDSASigningKey { key: pkc8_key })
43    }
44}
45
46pub struct EDDSAVerifyingKey {
47    key: VerifyingKey,
48}
49
50impl VerifyFromKey for EDDSAVerifyingKey {
51    fn verify(&self, content: String, sig: String, _alg: Algorithm) -> Result<bool, Error> {
52        let decoded_sig = match base64_url::decode(sig.as_bytes()) {
53            Ok(val) => val,
54            Err(error) => {
55                log::error(error.to_string().as_str());
56                return Err(Error::DECODING_ERROR);
57            }
58        };
59
60        let signature = match Signature::from_slice(&decoded_sig) {
61            Ok(val) => val,
62            Err(error) => {
63                log::error(error.to_string().as_str());
64                return Err(Error::SIGNATURE_IDENTIFICATION_FAILED);
65            }
66        };
67
68        let verify_result: Result<(), ed25519_dalek::ed25519::Error> =
69            self.key.verify(content.as_bytes(), &signature);
70        if verify_result.is_ok() {
71            return Ok(true);
72        } else {
73            match verify_result.err() {
74                Some(error) => {
75                    log::error(error.to_string().as_str());
76                }
77                None => {}
78            };
79            return Ok(false);
80        }
81    }
82}
83
84impl EDDSAVerifyingKey {
85    pub fn from_pem(key_str: &str) -> Result<Self, Error> {
86        let pkc8_key = match VerifyingKey::from_public_key_pem(key_str) {
87            Ok(val) => val,
88            Err(error) => {
89                log::error(error.to_string().as_str());
90                return Err(Error::PUBLIC_KEY_IDENTIFICATION_ERROR);
91            }
92        };
93
94        Ok(EDDSAVerifyingKey { key: pkc8_key })
95    }
96}
97
98pub fn sign_eddsa(message: String, key: impl SignFromKey, alg: Algorithm) -> Result<String, Error> {
99    key.sign(message, alg)
100}
101
102pub fn verify_eddsa(
103    message: String,
104    sig: String,
105    key: impl VerifyFromKey,
106    alg: Algorithm,
107) -> Result<bool, Error> {
108    key.verify(message, sig, alg)
109}
did_crypto/crypto/eddsa.rs

did_crypto/crypto/
eddsa.rs
