stellar_base/crypto/
mod.rs

1//! Cryptographic functions.
2
3#[cfg(feature = "dalek")]
4mod dalek;
5mod public_key;
6mod signature;
7mod strkey;
8
9use crate::error::Error;
10use sha2::Digest;
11use std::convert::TryInto;
12
13pub use self::public_key::{MuxedAccount, MuxedEd25519PublicKey, PublicKey};
14pub use self::signature::*;
15pub use self::strkey::*;
16#[cfg(feature = "dalek")]
17pub use dalek::*;
18pub use ed25519::signature::{Signer as Ed25519Signer, Verifier as Ed25519Verifier};
19pub use ed25519::Signature;
20
21/// Compute sha256 hash of `m`.
22pub fn hash(m: &[u8]) -> Vec<u8> {
23    sha2::Sha256::digest(m).to_vec()
24}
25
26#[derive(Debug, Clone, PartialEq)]
27pub struct SigningKey<S>
28where
29    S: Ed25519Signer<Signature>,
30{
31    pub signing_key: S,
32}
33
34#[derive(Debug, Clone, PartialEq)]
35pub struct VerifyKey<V>
36where
37    V: Ed25519Verifier<Signature> + AsRef<[u8]>,
38{
39    pub verify_key: V,
40}
41
42#[derive(Debug, Clone, PartialEq)]
43pub struct KeyPair<S, V>
44where
45    S: Ed25519Signer<Signature>,
46    V: Ed25519Verifier<Signature> + AsRef<[u8]>,
47{
48    pub signer: SigningKey<S>,
49    pub verifier: VerifyKey<V>,
50}
51
52impl<S, V> KeyPair<S, V>
53where
54    S: Ed25519Signer<Signature>,
55    V: Ed25519Verifier<Signature> + AsRef<[u8]>,
56{
57    pub fn new(signer: S, verifier: V) -> KeyPair<S, V> {
58        KeyPair {
59            signer: SigningKey {
60                signing_key: signer,
61            },
62            verifier: VerifyKey {
63                verify_key: verifier,
64            },
65        }
66    }
67
68    pub fn sign(&self, msg: &[u8]) -> Signature {
69        self.signer.signing_key.sign(msg)
70    }
71
72    pub fn verify(&self, msg: &[u8], sig: &Signature) -> Result<(), ed25519::Error> {
73        self.verifier.verify_key.verify(msg, sig)
74    }
75
76    pub fn public_key(&self) -> Result<PublicKey, Error> {
77        Ok(PublicKey(
78            self.verifier
79                .verify_key
80                .as_ref()
81                .try_into()
82                .map_err(|_| Error::InvalidPublicKey)?,
83        ))
84    }
85
86    /// Sign the `message` together with the signature hint.
87    pub fn sign_decorated(&self, message: &[u8]) -> DecoratedSignature {
88        let hint = self.signature_hint();
89        let signature = self.signer.signing_key.sign(message);
90        DecoratedSignature::new(hint, signature)
91    }
92
93    /// Return the signature hint, that is the last 4 bytes of the public key.
94    pub fn signature_hint(&self) -> SignatureHint {
95        SignatureHint::from_public_key(self.verifier.verify_key.as_ref())
96    }
97}