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
148
149
150
151

//! Hash functions used in the library

use std::fmt;
use std::str::FromStr;

pub enum HashFunctionError {
    ImportError,
}

/// ## C interface
/// The C interface uses an enum of type `libreauth_hash_function` and
/// the members has been renamed as follows:
/// <table>
///     <thead>
///         <tr>
///             <th>Rust</th>
///             <th>C</th>
///         </tr>
///     </thead>
///     <tbody>
///         <tr>
///             <td>Sha1</td>
///             <td>LIBREAUTH_HASH_SHA_1</td>
///         </tr>
///         <tr>
///             <td>Sha224</td>
///             <td>LIBREAUTH_HASH_SHA_224</td>
///         </tr>
///         <tr>
///             <td>Sha256</td>
///             <td>LIBREAUTH_HASH_SHA_256</td>
///         </tr>
///         <tr>
///             <td>Sha384</td>
///             <td>LIBREAUTH_HASH_SHA_384</td>
///         </tr>
///         <tr>
///             <td>Sha512</td>
///             <td>LIBREAUTH_HASH_SHA_512</td>
///         </tr>
///         <tr>
///             <td>Sha512Trunc224</td>
///             <td>LIBREAUTH_HASH_SHA_512_TRUNC_224</td>
///         </tr>
///         <tr>
///             <td>Sha512Trunc256</td>
///             <td>LIBREAUTH_HASH_SHA_512_TRUNC_256</td>
///         </tr>
///         <tr>
///             <td>Sha3_224</td>
///             <td>LIBREAUTH_HASH_SHA_3_224</td>
///         </tr>
///         <tr>
///             <td>Sha3_256</td>
///             <td>LIBREAUTH_HASH_SHA_3_256</td>
///         </tr>
///         <tr>
///             <td>Sha3_384</td>
///             <td>LIBREAUTH_HASH_SHA_3_384</td>
///         </tr>
///         <tr>
///             <td>Sha3_512</td>
///             <td>LIBREAUTH_HASH_SHA_3_512</td>
///         </tr>
///         <tr>
///             <td>Keccak224</td>
///             <td>LIBREAUTH_HASH_KECCAK_224</td>
///         </tr>
///         <tr>
///             <td>Keccak256</td>
///             <td>LIBREAUTH_HASH_KECCAK_256</td>
///         </tr>
///         <tr>
///             <td>Keccak384</td>
///             <td>LIBREAUTH_HASH_KECCAK_384</td>
///         </tr>
///         <tr>
///             <td>Keccak512</td>
///             <td>LIBREAUTH_HASH_KECCAK_512</td>
///         </tr>
///     </tbody>
/// </table>
#[repr(C)]
#[derive(Clone, Copy, Eq, PartialEq)]
pub enum HashFunction {
    Sha1 = 1,
    Sha224 = 2,
    Sha256 = 3,
    Sha384 = 4,
    Sha512 = 5,
    Sha512Trunc224 = 6,
    Sha512Trunc256 = 7,
    Sha3_224 = 8,
    Sha3_256 = 9,
    Sha3_384 = 10,
    Sha3_512 = 11,
    Keccak224 = 12,
    Keccak256 = 13,
    Keccak384 = 14,
    Keccak512 = 15,
}

impl fmt::Display for HashFunction {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s = match self {
            HashFunction::Sha1 => "SHA1",
            HashFunction::Sha224 => "SHA224",
            HashFunction::Sha256 => "SHA256",
            HashFunction::Sha384 => "SHA384",
            HashFunction::Sha512 => "SHA512",
            HashFunction::Sha512Trunc224 => "SHA512-224",
            HashFunction::Sha512Trunc256 => "SHA512-256",
            HashFunction::Sha3_224 => "SHA3-224",
            HashFunction::Sha3_256 => "SHA3-256",
            HashFunction::Sha3_384 => "SHA3-384",
            HashFunction::Sha3_512 => "SHA3-512",
            HashFunction::Keccak224 => "Keccak224",
            HashFunction::Keccak256 => "Keccak256",
            HashFunction::Keccak384 => "Keccak384",
            HashFunction::Keccak512 => "Keccak512",
        };
        write!(f, "{}", s)
    }
}

impl FromStr for HashFunction {
    type Err = HashFunctionError;

    fn from_str(data: &str) -> Result<Self, Self::Err> {
        Ok(match data.to_lowercase().as_str() {
            "sha1" => HashFunction::Sha1,
            "sha224" => HashFunction::Sha224,
            "sha256" => HashFunction::Sha256,
            "sha384" => HashFunction::Sha384,
            "sha512" => HashFunction::Sha512,
            "sha512-224" | "sha512t224" => HashFunction::Sha512Trunc224,
            "sha512-256" | "sha512t256" => HashFunction::Sha512Trunc256,
            "sha3-224" => HashFunction::Sha3_224,
            "sha3-256" => HashFunction::Sha3_256,
            "sha3-384" => HashFunction::Sha3_384,
            "sha3-512" => HashFunction::Sha3_512,
            "keccak224" => HashFunction::Keccak224,
            "keccak256" => HashFunction::Keccak256,
            "keccak384" => HashFunction::Keccak384,
            "keccak512" => HashFunction::Keccak512,
            _ => {
                return Err(HashFunctionError::ImportError);
            }
        })
    }
}