wae-crypto 0.0.2

WAE Crypto - 统一加密抽象模块
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

//! 加密错误类型

use std::fmt;
use wae_types::{WaeError, WaeErrorKind};

/// 加密错误
#[derive(Debug)]
pub enum CryptoError {
    /// Base64 编解码错误
    Base64Error(base64::DecodeError),

    /// 哈希错误
    HashError(String),

    /// HMAC 错误
    HmacError(String),

    /// 密码哈希错误
    PasswordHashError,

    /// 密码验证错误
    PasswordVerifyError,

    /// 无效的算法
    InvalidAlgorithm,

    /// 密钥错误
    KeyError,

    /// Base32 编解码错误
    Base32Error(String),

    /// 签名无效
    InvalidSignature,
}

impl fmt::Display for CryptoError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            CryptoError::Base64Error(e) => write!(f, "base64 error: {e}"),
            CryptoError::HashError(e) => write!(f, "hash error: {e}"),
            CryptoError::HmacError(e) => write!(f, "hmac error: {e}"),
            CryptoError::PasswordHashError => write!(f, "password hash error"),
            CryptoError::PasswordVerifyError => write!(f, "password verify error"),
            CryptoError::InvalidAlgorithm => write!(f, "invalid algorithm"),
            CryptoError::KeyError => write!(f, "key error"),
            CryptoError::Base32Error(e) => write!(f, "base32 error: {e}"),
            CryptoError::InvalidSignature => write!(f, "invalid signature"),
        }
    }
}

impl std::error::Error for CryptoError {}

impl From<base64::DecodeError> for CryptoError {
    fn from(err: base64::DecodeError) -> Self {
        CryptoError::Base64Error(err)
    }
}

/// 加密结果类型
pub type CryptoResult<T> = Result<T, CryptoError>;

impl From<CryptoError> for WaeError {
    fn from(err: CryptoError) -> Self {
        match err {
            CryptoError::Base64Error(_) => WaeError::invalid_token("invalid base64"),
            CryptoError::HashError(reason) => WaeError::new(WaeErrorKind::HmacError { reason }),
            CryptoError::HmacError(reason) => WaeError::new(WaeErrorKind::HmacError { reason }),
            CryptoError::PasswordHashError => {
                WaeError::new(WaeErrorKind::HmacError { reason: "password hash failed".to_string() })
            }
            CryptoError::PasswordVerifyError => {
                WaeError::new(WaeErrorKind::HmacError { reason: "password verify failed".to_string() })
            }
            CryptoError::InvalidAlgorithm => WaeError::new(WaeErrorKind::InvalidAlgorithm),
            CryptoError::KeyError => WaeError::new(WaeErrorKind::KeyError),
            CryptoError::Base32Error(reason) => WaeError::new(WaeErrorKind::Base32Error { reason }),
            CryptoError::InvalidSignature => WaeError::invalid_signature(),
        }
    }
}