mcf 0.6.0

Pure Rust implementation of the Modular Crypt Format (MCF) which is used to store password hashes in the form `${id}$...`
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

//! Base64 encoding variants.

#![cfg(feature = "base64")]

use base64ct::{
    Base64Bcrypt, Base64Pbkdf2, Base64ShaCrypt, Base64Unpadded as B64, Encoding as _,
    Error as B64Error,
};

#[cfg(feature = "alloc")]
use alloc::{string::String, vec::Vec};

/// Base64 encoding variants used in various MCF encodings.
#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
#[non_exhaustive]
pub enum Base64 {
    /// "B64" encoding: standard Base64 without padding, as used by the PHC string format.
    ///
    /// ```text
    /// [A-Z]      [a-z]      [0-9]      +     /
    /// 0x41-0x5a, 0x61-0x7a, 0x30-0x39, 0x2b, 0x2f
    /// ```
    /// <https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md#b64>
    B64,

    /// bcrypt encoding.
    ///
    /// ```text
    /// ./         [A-Z]      [a-z]      [0-9]
    /// 0x2e-0x2f, 0x41-0x5a, 0x61-0x7a, 0x30-0x39
    /// ```
    Bcrypt,

    /// `crypt(3)` Base64 encoding.
    ///
    /// Used by the following schemes:
    /// - MD5-Crypt
    /// - scrypt
    /// - SHA1-Crypt
    /// - SHA256-Crypt
    /// - SHA512-Crypt
    /// - yescrypt
    ///
    /// ```text
    /// [.-9]      [A-Z]      [a-z]
    /// 0x2e-0x39, 0x41-0x5a, 0x61-0x7a
    /// ```
    Crypt,

    /// PBKDF2 Base64 encoding.
    ///
    /// This is a variant of the unpadded standard Base64 with `.` in place of `+`:
    ///
    /// ```text
    /// [A-Z]      [a-z]      [0-9]      .     /
    /// 0x41-0x5a, 0x61-0x7a, 0x30-0x39, 0x2e, 0x2f
    /// ```
    Pbkdf2,
}

impl Base64 {
    /// Decode a Base64 string into the provided destination buffer.
    pub fn decode(self, src: impl AsRef<[u8]>, dst: &mut [u8]) -> Result<&[u8], B64Error> {
        match self {
            Self::B64 => B64::decode(src, dst),
            Self::Bcrypt => Base64Bcrypt::decode(src, dst),
            Self::Crypt => Base64ShaCrypt::decode(src, dst),
            Self::Pbkdf2 => Base64Pbkdf2::decode(src, dst),
        }
    }

    /// Decode a Base64 string into a byte vector.
    #[cfg(feature = "alloc")]
    pub fn decode_vec(self, input: &str) -> Result<Vec<u8>, B64Error> {
        match self {
            Self::B64 => B64::decode_vec(input),
            Self::Bcrypt => Base64Bcrypt::decode_vec(input),
            Self::Crypt => Base64ShaCrypt::decode_vec(input),
            Self::Pbkdf2 => Base64Pbkdf2::decode_vec(input),
        }
    }

    /// Encode the input byte slice as Base64.
    ///
    /// Writes the result into the provided destination slice, returning an
    /// ASCII-encoded Base64 string value.
    pub fn encode<'a>(self, src: &[u8], dst: &'a mut [u8]) -> Result<&'a str, B64Error> {
        match self {
            Self::B64 => B64::encode(src, dst),
            Self::Bcrypt => Base64Bcrypt::encode(src, dst),
            Self::Crypt => Base64ShaCrypt::encode(src, dst),
            Self::Pbkdf2 => Base64Pbkdf2::encode(src, dst),
        }
        .map_err(Into::into)
    }

    /// Encode input byte slice into a [`String`] containing Base64.
    ///
    /// # Panics
    /// If `input` length is greater than `usize::MAX/4`.
    #[cfg(feature = "alloc")]
    pub fn encode_string(self, input: &[u8]) -> String {
        match self {
            Self::B64 => B64::encode_string(input),
            Self::Bcrypt => Base64Bcrypt::encode_string(input),
            Self::Crypt => Base64ShaCrypt::encode_string(input),
            Self::Pbkdf2 => Base64Pbkdf2::encode_string(input),
        }
    }

    /// Get the length of Base64 produced by encoding the given bytes.
    pub fn encoded_len(self, bytes: &[u8]) -> usize {
        match self {
            Self::B64 => B64::encoded_len(bytes),
            Self::Bcrypt => Base64Bcrypt::encoded_len(bytes),
            Self::Crypt => Base64ShaCrypt::encoded_len(bytes),
            Self::Pbkdf2 => Base64Pbkdf2::encoded_len(bytes),
        }
    }
}