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
use std::error;
use std::fmt;
use std::io;
pub type BcryptResult<T> = Result<T, BcryptError>;
#[derive(Debug)]
pub enum BcryptError {
Io(io::Error),
CostNotAllowed(u32),
InvalidPassword,
InvalidCost(String),
InvalidPrefix(String),
InvalidHash(String),
InvalidBase64(char, String),
Rand(rand::Error),
}
macro_rules! impl_from_error {
($f: ty, $e: expr) => {
impl From<$f> for BcryptError {
fn from(f: $f) -> BcryptError {
$e(f)
}
}
};
}
impl_from_error!(io::Error, BcryptError::Io);
impl_from_error!(rand::Error, BcryptError::Rand);
impl fmt::Display for BcryptError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BcryptError::Io(ref err) => write!(f, "IO error: {}", err),
BcryptError::InvalidCost(ref cost) => write!(f, "Invalid Cost: {}", cost),
BcryptError::CostNotAllowed(ref cost) => write!(
f,
"Cost needs to be between {} and {}, got {}",
crate::MIN_COST,
crate::MAX_COST,
cost
),
BcryptError::InvalidPassword => write!(f, "Invalid password: contains NULL byte"),
BcryptError::InvalidPrefix(ref prefix) => write!(f, "Invalid Prefix: {}", prefix),
BcryptError::InvalidHash(ref hash) => write!(f, "Invalid hash: {}", hash),
BcryptError::InvalidBase64(ref c, ref hash) => {
write!(f, "Invalid base64 char {} in {}", c, hash)
}
BcryptError::Rand(ref err) => write!(f, "Rand error: {}", err),
}
}
}
impl error::Error for BcryptError {
fn source(&self) -> Option<&(dyn error::Error + 'static)> {
match *self {
BcryptError::Io(ref err) => Some(err),
BcryptError::InvalidCost(_)
| BcryptError::CostNotAllowed(_)
| BcryptError::InvalidPassword
| BcryptError::InvalidPrefix(_)
| BcryptError::InvalidBase64(_, _)
| BcryptError::InvalidHash(_) => None,
BcryptError::Rand(ref err) => Some(err),
}
}
}