blake2b 0.6.1

BLAKE2b hash function
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

extern crate blake2b;
extern crate rustc_serialize;

use blake2b::{Blake2b, blake2b, blake2b_keyed, blake2xb_keyed};

#[test]
fn multiple_updates() {
	const DATA: [u8; 1110] = [0x55; 1110];
	const SIZES: [usize; 4] = [0, 5, 50, 500];

	let mut hasher = Blake2b::default();
	for &s in &SIZES             { hasher.update(&DATA[..s]); }
	for &s in SIZES.iter().rev() { hasher.update(&DATA[..s]); }

	assert_eq!(hasher.finish(), blake2b(64, &DATA));
}

#[test]
fn selftest() {
	assert!(blake2b::selftest());
}

#[test]
fn testvectors() {
	use rustc_serialize::hex::{FromHex};
	use rustc_serialize::json::{self};

	const KAT: &'static str = include_str!("blake2-kat.json");

	#[derive(RustcDecodable)]
	struct Data {
		hash: String,
		data: String,
		key: String,
		out: String
	}

	let data: Vec<Data> = json::decode(KAT).unwrap();
	for d in data {
		let data = d.data.from_hex().unwrap();
		let key = d.key.from_hex().unwrap();
		let out = d.out.from_hex().unwrap();

		match &*d.hash {
			"blake2b" => {
				assert_eq!(
					&blake2b_keyed(out.len(), &key, &data),
					&out[..]
				);
			}
			"blake2xb" => {
				let mut hash = Vec::with_capacity(out.len());
				for h in blake2xb_keyed(Some(out.len() as u32), &key, &data) {
					hash.extend_from_slice(&h);
				}

				assert_eq!(hash, out);
			}
			"blake2bp" => {}
			hash => { unreachable!(hash); }
		}
	}
}