dcrypt-pke 1.2.3

Public Key Encryption schemes for the dcrypt library
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

//! Error handling for PKE operations.
#![cfg_attr(not(feature = "std"), no_std)]

use core::fmt;
use dcrypt_algorithms::error::Error as PrimitiveError;
use dcrypt_api::error::Error as CoreError;

// Ensure String and format! are available for no_std + alloc
#[cfg(all(not(feature = "std"), feature = "alloc"))]
use alloc::format;
#[cfg(all(not(feature = "std"), feature = "alloc"))]
use alloc::string::{String, ToString};

/// Error type for PKE operations.
#[derive(Debug)]
pub enum Error {
    Primitive(PrimitiveError),
    Api(CoreError),
    InvalidCiphertextFormat(&'static str),
    EncryptionFailed(&'static str),
    DecryptionFailed(&'static str),
    KeyDerivationFailed(&'static str),
    UnsupportedOperation(&'static str),
    SerializationError(&'static str),
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Error::Primitive(e) => write!(f, "PKE primitive error: {}", e),
            Error::Api(e) => write!(f, "PKE API error: {}", e),
            Error::InvalidCiphertextFormat(reason) => {
                write!(f, "Invalid PKE ciphertext format: {}", reason)
            }
            Error::EncryptionFailed(reason) => write!(f, "PKE encryption failed: {}", reason),
            Error::DecryptionFailed(reason) => write!(f, "PKE decryption failed: {}", reason),
            Error::KeyDerivationFailed(reason) => {
                write!(f, "PKE key derivation failed: {}", reason)
            }
            Error::UnsupportedOperation(op) => write!(f, "PKE unsupported operation: {}", op),
            Error::SerializationError(reason) => {
                write!(f, "PKE internal serialization error: {}", reason)
            }
        }
    }
}

#[cfg(feature = "std")]
impl std::error::Error for Error {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            Error::Primitive(e) => Some(e),
            Error::Api(e) => Some(e),
            _ => None,
        }
    }
}

impl From<PrimitiveError> for Error {
    fn from(err: PrimitiveError) -> Self {
        Error::Primitive(err)
    }
}

impl From<CoreError> for Error {
    fn from(err: CoreError) -> Self {
        Error::Api(err)
    }
}

// Conversion from PKE Error to API Error
impl From<Error> for CoreError {
    fn from(err: Error) -> Self {
        match err {
            Error::Primitive(e) => e.into(),
            Error::Api(e) => e,
            Error::InvalidCiphertextFormat(reason) => CoreError::InvalidCiphertext {
                context: "ECIES",
                #[cfg(feature = "std")]
                message: reason.to_string(),
            },
            Error::EncryptionFailed(reason) => CoreError::Other {
                context: "ECIES Encryption",
                #[cfg(feature = "std")]
                message: reason.to_string(),
            },
            Error::DecryptionFailed(reason) => {
                // Provide more specific context for the AEAD-auth failure that
                // the unit-tests look for, while keeping the generic string for
                // every other reason.
                let ctx: &'static str = if reason == "AEAD authentication failed" {
                    "ECIES Decryption: AEAD authentication failed"
                } else {
                    "ECIES Decryption"
                };
                CoreError::DecryptionFailed {
                    context: ctx,
                    #[cfg(feature = "std")]
                    message: reason.to_string(),
                }
            }
            Error::KeyDerivationFailed(reason) => CoreError::Other {
                context: "ECIES KDF",
                #[cfg(feature = "std")]
                message: reason.to_string(),
            },
            Error::UnsupportedOperation(op) => CoreError::NotImplemented { feature: op },
            Error::SerializationError(reason) => CoreError::SerializationError {
                context: "ECIES Internal",
                #[cfg(feature = "std")]
                message: reason.to_string(),
            },
        }
    }
}

/// Result type for PKE operations.
pub type Result<T> = core::result::Result<T, Error>;