1// Copyright (c) 2017 Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
2//
3// This Source Code Form is subject to the terms of the Mozilla Public
4// License, v. 2.0. If a copy of the MPL was not distributed with this
5// file, You can obtain one at http://mozilla.org/MPL/2.0/.
6
7use crate::util::error::Error;
8use crate::util::helpers::Base64;
9use base64;
10use minidom::IntoAttributeValue;
11use std::num::ParseIntError;
12use std::ops::{Deref, DerefMut};
13use std::str::FromStr;
14
15/// List of the algorithms we support, or Unknown.
16#[allow(non_camel_case_types)]
17#[derive(Debug, Clone, PartialEq, Eq, Hash)]
18pub enum Algo {
19 /// The Secure Hash Algorithm 1, with known vulnerabilities, do not use it.
20 ///
21 /// See https://tools.ietf.org/html/rfc3174
22 Sha_1,
23
24 /// The Secure Hash Algorithm 2, in its 256-bit version.
25 ///
26 /// See https://tools.ietf.org/html/rfc6234
27 Sha_256,
28
29 /// The Secure Hash Algorithm 2, in its 512-bit version.
30 ///
31 /// See https://tools.ietf.org/html/rfc6234
32 Sha_512,
33
34 /// The Secure Hash Algorithm 3, based on Keccak, in its 256-bit version.
35 ///
36 /// See https://keccak.team/files/Keccak-submission-3.pdf
37 Sha3_256,
38
39 /// The Secure Hash Algorithm 3, based on Keccak, in its 512-bit version.
40 ///
41 /// See https://keccak.team/files/Keccak-submission-3.pdf
42 Sha3_512,
43
44 /// The BLAKE2 hash algorithm, for a 256-bit output.
45 ///
46 /// See https://tools.ietf.org/html/rfc7693
47 Blake2b_256,
48
49 /// The BLAKE2 hash algorithm, for a 512-bit output.
50 ///
51 /// See https://tools.ietf.org/html/rfc7693
52 Blake2b_512,
53
54 /// An unknown hash not in this list, you can probably reject it.
55 Unknown(String),
56}
57
58impl FromStr for Algo {
59 type Err = Error;
60
61 fn from_str(s: &str) -> Result<Algo, Error> {
62 Ok(match s {
63 "" => return Err(Error::ParseError("'algo' argument can’t be empty.")),
64
65 "sha-1" => Algo::Sha_1,
66 "sha-256" => Algo::Sha_256,
67 "sha-512" => Algo::Sha_512,
68 "sha3-256" => Algo::Sha3_256,
69 "sha3-512" => Algo::Sha3_512,
70 "blake2b-256" => Algo::Blake2b_256,
71 "blake2b-512" => Algo::Blake2b_512,
72 value => Algo::Unknown(value.to_owned()),
73 })
74 }
75}
76
77impl From<Algo> for String {
78 fn from(algo: Algo) -> String {
79 String::from(match algo {
80 Algo::Sha_1 => "sha-1",
81 Algo::Sha_256 => "sha-256",
82 Algo::Sha_512 => "sha-512",
83 Algo::Sha3_256 => "sha3-256",
84 Algo::Sha3_512 => "sha3-512",
85 Algo::Blake2b_256 => "blake2b-256",
86 Algo::Blake2b_512 => "blake2b-512",
87 Algo::Unknown(text) => return text,
88 })
89 }
90}
91
92impl IntoAttributeValue for Algo {
93 fn into_attribute_value(self) -> Option<String> {
94 Some(String::from(self))
95 }
96}
97
98generate_element!(
99 /// This element represents a hash of some data, defined by the hash
100 /// algorithm used and the computed value.
101 #[derive(PartialEq)]
102 Hash, "hash", HASHES,
103 attributes: [
104 /// The algorithm used to create this hash.
105 algo: Required<Algo> = "algo"
106 ],
107 text: (
108 /// The hash value, as a vector of bytes.
109 hash: Base64<Vec<u8>>
110 )
111);
112
113impl Hash {
114 /// Creates a [Hash] element with the given algo and data.
115 pub fn new(algo: Algo, hash: Vec<u8>) -> Hash {
116 Hash { algo, hash }
117 }
118
119 /// Like [new](#method.new) but takes base64-encoded data before decoding
120 /// it.
121 pub fn from_base64(algo: Algo, hash: &str) -> Result<Hash, Error> {
122 Ok(Hash::new(algo, base64::decode(hash)?))
123 }
124
125 /// Like [new](#method.new) but takes hex-encoded data before decoding it.
126 pub fn from_hex(algo: Algo, hex: &str) -> Result<Hash, ParseIntError> {
127 let mut bytes = vec![];
128 for i in 0..hex.len() / 2 {
129 let byte = u8::from_str_radix(&hex[2 * i..2 * i + 2], 16)?;
130 bytes.push(byte);
131 }
132 Ok(Hash::new(algo, bytes))
133 }
134
135 /// Formats this hash into base64.
136 pub fn to_base64(&self) -> String {
137 base64::encode(&self.hash[..])
138 }
139
140 /// Formats this hash into hexadecimal.
141 pub fn to_hex(&self) -> String {
142 let mut bytes = vec![];
143 for byte in self.hash.iter() {
144 bytes.push(format!("{:02x}", byte));
145 }
146 bytes.join("")
147 }
148
149 /// Formats this hash into colon-separated hexadecimal.
150 pub fn to_colon_hex(&self) -> String {
151 let mut bytes = vec![];
152 for byte in self.hash.iter() {
153 bytes.push(format!("{:02x}", byte));
154 }
155 bytes.join(":")
156 }
157}
158
159/// Helper for parsing and serialising a SHA-1 attribute.
160#[derive(Debug, Clone, PartialEq)]
161pub struct Sha1HexAttribute(Hash);
162
163impl FromStr for Sha1HexAttribute {
164 type Err = ParseIntError;
165
166 fn from_str(hex: &str) -> Result<Self, Self::Err> {
167 let hash = Hash::from_hex(Algo::Sha_1, hex)?;
168 Ok(Sha1HexAttribute(hash))
169 }
170}
171
172impl IntoAttributeValue for Sha1HexAttribute {
173 fn into_attribute_value(self) -> Option<String> {
174 Some(self.to_hex())
175 }
176}
177
178impl DerefMut for Sha1HexAttribute {
179 fn deref_mut(&mut self) -> &mut Self::Target {
180 &mut self.0
181 }
182}
183
184impl Deref for Sha1HexAttribute {
185 type Target = Hash;
186
187 fn deref(&self) -> &Self::Target {
188 &self.0
189 }
190}
191
192#[cfg(test)]
193mod tests {
194 use super::*;
195 use minidom::Element;
196 use std::convert::TryFrom;
197
198 #[cfg(target_pointer_width = "32")]
199 #[test]
200 fn test_size() {
201 assert_size!(Algo, 16);
202 assert_size!(Hash, 28);
203 }
204
205 #[cfg(target_pointer_width = "64")]
206 #[test]
207 fn test_size() {
208 assert_size!(Algo, 32);
209 assert_size!(Hash, 56);
210 }
211
212 #[test]
213 fn test_simple() {
214 let elem: Element = "<hash xmlns='urn:xmpp:hashes:2' algo='sha-256'>2XarmwTlNxDAMkvymloX3S5+VbylNrJt/l5QyPa+YoU=</hash>".parse().unwrap();
215 let hash = Hash::try_from(elem).unwrap();
216 assert_eq!(hash.algo, Algo::Sha_256);
217 assert_eq!(
218 hash.hash,
219 base64::decode("2XarmwTlNxDAMkvymloX3S5+VbylNrJt/l5QyPa+YoU=").unwrap()
220 );
221 }
222
223 #[test]
224 fn value_serialisation() {
225 let elem: Element = "<hash xmlns='urn:xmpp:hashes:2' algo='sha-256'>2XarmwTlNxDAMkvymloX3S5+VbylNrJt/l5QyPa+YoU=</hash>".parse().unwrap();
226 let hash = Hash::try_from(elem).unwrap();
227 assert_eq!(hash.to_base64(), "2XarmwTlNxDAMkvymloX3S5+VbylNrJt/l5QyPa+YoU=");
228 assert_eq!(hash.to_hex(), "d976ab9b04e53710c0324bf29a5a17dd2e7e55bca536b26dfe5e50c8f6be6285");
229 assert_eq!(hash.to_colon_hex(), "d9:76:ab:9b:04:e5:37:10:c0:32:4b:f2:9a:5a:17:dd:2e:7e:55:bc:a5:36:b2:6d:fe:5e:50:c8:f6:be:62:85");
230 }
231
232 #[test]
233 fn test_unknown() {
234 let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0'/>"
235 .parse()
236 .unwrap();
237 let error = Hash::try_from(elem).unwrap_err();
238 let message = match error {
239 Error::ParseError(string) => string,
240 _ => panic!(),
241 };
242 assert_eq!(message, "This is not a hash element.");
243 }
244
245 #[test]
246 fn test_invalid_child() {
247 let elem: Element = "<hash xmlns='urn:xmpp:hashes:2'><coucou/></hash>"
248 .parse()
249 .unwrap();
250 let error = Hash::try_from(elem).unwrap_err();
251 let message = match error {
252 Error::ParseError(string) => string,
253 _ => panic!(),
254 };
255 assert_eq!(message, "Unknown child in hash element.");
256 }
257}