cryptimitives 0.20.0

Cryptographic primitives collection.
Documentation 
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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! Crate custom errors.

#[cfg(feature = "std")]
use std::fmt::Display;

use cryptraits_macros::Error;

/// AEAD algorithm error.
#[derive(Debug, Error, Clone)]
pub struct AeadError;

/// KDF algorithm error.
#[derive(Debug, Error, Clone)]
pub enum KdfError {
    InvalidLength,
}

/// KeyPair errors.
#[derive(Debug, Error, Clone)]
pub enum KeyPairError {
    BytesLengthError,
    UnknownError(String),
    MnemonicPhraseError(String),
    InvalidEntropy,
    ScalarFormatError,
    EquationFalse,
    SignatureError,
}

/// HMAC algorithm errors.
#[derive(Debug, Error, Clone)]
pub enum HmacError {
    InvalidLength,
    MacError,
}

/// Stream cipher algorithm errors.
#[derive(Debug, Error, Clone)]
pub enum StreamCipherError {
    /// The error returned when key or nonce used in stream cipher
    /// has an invalid length.
    InvalidLength,

    /// The error returned when cipher reached the end of stream.
    LoopError,
}

/// Errors which may occur while processing signatures.
#[derive(Debug, Error, PartialEq, Clone)]
pub enum SignatureError {
    /// A signature verification equation failed.
    EquationFalse,
}

impl From<bip39::Error> for KeyPairError {
    fn from(e: bip39::Error) -> Self {
        Self::MnemonicPhraseError(e.to_string())
    }
}

impl From<schnorrkel::SignatureError> for KeyPairError {
    fn from(e: schnorrkel::SignatureError) -> Self {
        match e {
            schnorrkel::SignatureError::EquationFalse => KeyPairError::EquationFalse,
            schnorrkel::SignatureError::ScalarFormatError => KeyPairError::ScalarFormatError,
            schnorrkel::SignatureError::BytesLengthError {
                name: _,
                description: _,
                length: _,
            } => KeyPairError::BytesLengthError,
            schnorrkel::SignatureError::NotMarkedSchnorrkel => todo!(),
            _ => KeyPairError::UnknownError(e.to_string()),
        }
    }
}

impl From<ed25519_dalek::ed25519::Error> for KeyPairError {
    fn from(_: ed25519_dalek::ed25519::Error) -> Self {
        Self::SignatureError
    }
}

impl From<ed25519_dalek::ed25519::Error> for SignatureError {
    fn from(_: ed25519_dalek::ed25519::Error) -> Self {
        Self::EquationFalse
    }
}

#[cfg(feature = "std")]
impl Display for AeadError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str("AeadError")
    }
}

#[cfg(feature = "std")]
impl Display for KdfError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(&format!("KdfError::{self:?}"))
    }
}

#[cfg(feature = "std")]
impl Display for KeyPairError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(&format!("KeyPairError::{self:?}"))
    }
}

#[cfg(feature = "std")]
impl Display for HmacError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(&format!("HmacError::{self:?}"))
    }
}

#[cfg(feature = "std")]
impl Display for StreamCipherError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(&format!("StreamCipherError::{self:?}"))
    }
}

#[cfg(feature = "std")]
impl Display for SignatureError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(&format!("SignatureErrors::{self:?}"))
    }
}

#[cfg(feature = "std")]
impl std::error::Error for AeadError {}

#[cfg(feature = "std")]
impl std::error::Error for KdfError {}

#[cfg(feature = "std")]
impl std::error::Error for KeyPairError {}

#[cfg(feature = "std")]
impl std::error::Error for HmacError {}

#[cfg(feature = "std")]
impl std::error::Error for StreamCipherError {}

#[cfg(feature = "std")]
impl std::error::Error for SignatureError {}