src/librustc_data_structures/sip128/tests.rs

   1 use super::*;
   2
   3 use std::hash::{Hash, Hasher};
   4 use std::{slice, mem};
   5
   6 // Hash just the bytes of the slice, without length prefix
   7 struct Bytes<'a>(&'a [u8]);
   8
   9 impl<'a> Hash for Bytes<'a> {
  10     #[allow(unused_must_use)]
  11     fn hash<H: Hasher>(&self, state: &mut H) {
  12         for byte in self.0 {
  13             state.write_u8(*byte);
  14         }
  15     }
  16 }
  17
  18 fn hash_with<T: Hash>(mut st: SipHasher128, x: &T) -> (u64, u64) {
  19     x.hash(&mut st);
  20     st.finish128()
  21 }
  22
  23 fn hash<T: Hash>(x: &T) -> (u64, u64) {
  24     hash_with(SipHasher128::new_with_keys(0, 0), x)
  25 }
  26
  27 const TEST_VECTOR : [[u8; 16]; 64] = [
  28     [0xa3,0x81,0x7f,0x04,0xba,0x25,0xa8,0xe6,0x6d,0xf6,0x72,0x14,0xc7,0x55,0x02,0x93],
  29     [0xda,0x87,0xc1,0xd8,0x6b,0x99,0xaf,0x44,0x34,0x76,0x59,0x11,0x9b,0x22,0xfc,0x45],
  30     [0x81,0x77,0x22,0x8d,0xa4,0xa4,0x5d,0xc7,0xfc,0xa3,0x8b,0xde,0xf6,0x0a,0xff,0xe4],
  31     [0x9c,0x70,0xb6,0x0c,0x52,0x67,0xa9,0x4e,0x5f,0x33,0xb6,0xb0,0x29,0x85,0xed,0x51],
  32     [0xf8,0x81,0x64,0xc1,0x2d,0x9c,0x8f,0xaf,0x7d,0x0f,0x6e,0x7c,0x7b,0xcd,0x55,0x79],
  33     [0x13,0x68,0x87,0x59,0x80,0x77,0x6f,0x88,0x54,0x52,0x7a,0x07,0x69,0x0e,0x96,0x27],
  34     [0x14,0xee,0xca,0x33,0x8b,0x20,0x86,0x13,0x48,0x5e,0xa0,0x30,0x8f,0xd7,0xa1,0x5e],
  35     [0xa1,0xf1,0xeb,0xbe,0xd8,0xdb,0xc1,0x53,0xc0,0xb8,0x4a,0xa6,0x1f,0xf0,0x82,0x39],
  36     [0x3b,0x62,0xa9,0xba,0x62,0x58,0xf5,0x61,0x0f,0x83,0xe2,0x64,0xf3,0x14,0x97,0xb4],
  37     [0x26,0x44,0x99,0x06,0x0a,0xd9,0xba,0xab,0xc4,0x7f,0x8b,0x02,0xbb,0x6d,0x71,0xed],
  38     [0x00,0x11,0x0d,0xc3,0x78,0x14,0x69,0x56,0xc9,0x54,0x47,0xd3,0xf3,0xd0,0xfb,0xba],
  39     [0x01,0x51,0xc5,0x68,0x38,0x6b,0x66,0x77,0xa2,0xb4,0xdc,0x6f,0x81,0xe5,0xdc,0x18],
  40     [0xd6,0x26,0xb2,0x66,0x90,0x5e,0xf3,0x58,0x82,0x63,0x4d,0xf6,0x85,0x32,0xc1,0x25],
  41     [0x98,0x69,0xe2,0x47,0xe9,0xc0,0x8b,0x10,0xd0,0x29,0x93,0x4f,0xc4,0xb9,0x52,0xf7],
  42     [0x31,0xfc,0xef,0xac,0x66,0xd7,0xde,0x9c,0x7e,0xc7,0x48,0x5f,0xe4,0x49,0x49,0x02],
  43     [0x54,0x93,0xe9,0x99,0x33,0xb0,0xa8,0x11,0x7e,0x08,0xec,0x0f,0x97,0xcf,0xc3,0xd9],
  44     [0x6e,0xe2,0xa4,0xca,0x67,0xb0,0x54,0xbb,0xfd,0x33,0x15,0xbf,0x85,0x23,0x05,0x77],
  45     [0x47,0x3d,0x06,0xe8,0x73,0x8d,0xb8,0x98,0x54,0xc0,0x66,0xc4,0x7a,0xe4,0x77,0x40],
  46     [0xa4,0x26,0xe5,0xe4,0x23,0xbf,0x48,0x85,0x29,0x4d,0xa4,0x81,0xfe,0xae,0xf7,0x23],
  47     [0x78,0x01,0x77,0x31,0xcf,0x65,0xfa,0xb0,0x74,0xd5,0x20,0x89,0x52,0x51,0x2e,0xb1],
  48     [0x9e,0x25,0xfc,0x83,0x3f,0x22,0x90,0x73,0x3e,0x93,0x44,0xa5,0xe8,0x38,0x39,0xeb],
  49     [0x56,0x8e,0x49,0x5a,0xbe,0x52,0x5a,0x21,0x8a,0x22,0x14,0xcd,0x3e,0x07,0x1d,0x12],
  50     [0x4a,0x29,0xb5,0x45,0x52,0xd1,0x6b,0x9a,0x46,0x9c,0x10,0x52,0x8e,0xff,0x0a,0xae],
  51     [0xc9,0xd1,0x84,0xdd,0xd5,0xa9,0xf5,0xe0,0xcf,0x8c,0xe2,0x9a,0x9a,0xbf,0x69,0x1c],
  52     [0x2d,0xb4,0x79,0xae,0x78,0xbd,0x50,0xd8,0x88,0x2a,0x8a,0x17,0x8a,0x61,0x32,0xad],
  53     [0x8e,0xce,0x5f,0x04,0x2d,0x5e,0x44,0x7b,0x50,0x51,0xb9,0xea,0xcb,0x8d,0x8f,0x6f],
  54     [0x9c,0x0b,0x53,0xb4,0xb3,0xc3,0x07,0xe8,0x7e,0xae,0xe0,0x86,0x78,0x14,0x1f,0x66],
  55     [0xab,0xf2,0x48,0xaf,0x69,0xa6,0xea,0xe4,0xbf,0xd3,0xeb,0x2f,0x12,0x9e,0xeb,0x94],
  56     [0x06,0x64,0xda,0x16,0x68,0x57,0x4b,0x88,0xb9,0x35,0xf3,0x02,0x73,0x58,0xae,0xf4],
  57     [0xaa,0x4b,0x9d,0xc4,0xbf,0x33,0x7d,0xe9,0x0c,0xd4,0xfd,0x3c,0x46,0x7c,0x6a,0xb7],
  58     [0xea,0x5c,0x7f,0x47,0x1f,0xaf,0x6b,0xde,0x2b,0x1a,0xd7,0xd4,0x68,0x6d,0x22,0x87],
  59     [0x29,0x39,0xb0,0x18,0x32,0x23,0xfa,0xfc,0x17,0x23,0xde,0x4f,0x52,0xc4,0x3d,0x35],
  60     [0x7c,0x39,0x56,0xca,0x5e,0xea,0xfc,0x3e,0x36,0x3e,0x9d,0x55,0x65,0x46,0xeb,0x68],
  61     [0x77,0xc6,0x07,0x71,0x46,0xf0,0x1c,0x32,0xb6,0xb6,0x9d,0x5f,0x4e,0xa9,0xff,0xcf],
  62     [0x37,0xa6,0x98,0x6c,0xb8,0x84,0x7e,0xdf,0x09,0x25,0xf0,0xf1,0x30,0x9b,0x54,0xde],
  63     [0xa7,0x05,0xf0,0xe6,0x9d,0xa9,0xa8,0xf9,0x07,0x24,0x1a,0x2e,0x92,0x3c,0x8c,0xc8],
  64     [0x3d,0xc4,0x7d,0x1f,0x29,0xc4,0x48,0x46,0x1e,0x9e,0x76,0xed,0x90,0x4f,0x67,0x11],
  65     [0x0d,0x62,0xbf,0x01,0xe6,0xfc,0x0e,0x1a,0x0d,0x3c,0x47,0x51,0xc5,0xd3,0x69,0x2b],
  66     [0x8c,0x03,0x46,0x8b,0xca,0x7c,0x66,0x9e,0xe4,0xfd,0x5e,0x08,0x4b,0xbe,0xe7,0xb5],
  67     [0x52,0x8a,0x5b,0xb9,0x3b,0xaf,0x2c,0x9c,0x44,0x73,0xcc,0xe5,0xd0,0xd2,0x2b,0xd9],
  68     [0xdf,0x6a,0x30,0x1e,0x95,0xc9,0x5d,0xad,0x97,0xae,0x0c,0xc8,0xc6,0x91,0x3b,0xd8],
  69     [0x80,0x11,0x89,0x90,0x2c,0x85,0x7f,0x39,0xe7,0x35,0x91,0x28,0x5e,0x70,0xb6,0xdb],
  70     [0xe6,0x17,0x34,0x6a,0xc9,0xc2,0x31,0xbb,0x36,0x50,0xae,0x34,0xcc,0xca,0x0c,0x5b],
  71     [0x27,0xd9,0x34,0x37,0xef,0xb7,0x21,0xaa,0x40,0x18,0x21,0xdc,0xec,0x5a,0xdf,0x89],
  72     [0x89,0x23,0x7d,0x9d,0xed,0x9c,0x5e,0x78,0xd8,0xb1,0xc9,0xb1,0x66,0xcc,0x73,0x42],
  73     [0x4a,0x6d,0x80,0x91,0xbf,0x5e,0x7d,0x65,0x11,0x89,0xfa,0x94,0xa2,0x50,0xb1,0x4c],
  74     [0x0e,0x33,0xf9,0x60,0x55,0xe7,0xae,0x89,0x3f,0xfc,0x0e,0x3d,0xcf,0x49,0x29,0x02],
  75     [0xe6,0x1c,0x43,0x2b,0x72,0x0b,0x19,0xd1,0x8e,0xc8,0xd8,0x4b,0xdc,0x63,0x15,0x1b],
  76     [0xf7,0xe5,0xae,0xf5,0x49,0xf7,0x82,0xcf,0x37,0x90,0x55,0xa6,0x08,0x26,0x9b,0x16],
  77     [0x43,0x8d,0x03,0x0f,0xd0,0xb7,0xa5,0x4f,0xa8,0x37,0xf2,0xad,0x20,0x1a,0x64,0x03],
  78     [0xa5,0x90,0xd3,0xee,0x4f,0xbf,0x04,0xe3,0x24,0x7e,0x0d,0x27,0xf2,0x86,0x42,0x3f],
  79     [0x5f,0xe2,0xc1,0xa1,0x72,0xfe,0x93,0xc4,0xb1,0x5c,0xd3,0x7c,0xae,0xf9,0xf5,0x38],
  80     [0x2c,0x97,0x32,0x5c,0xbd,0x06,0xb3,0x6e,0xb2,0x13,0x3d,0xd0,0x8b,0x3a,0x01,0x7c],
  81     [0x92,0xc8,0x14,0x22,0x7a,0x6b,0xca,0x94,0x9f,0xf0,0x65,0x9f,0x00,0x2a,0xd3,0x9e],
  82     [0xdc,0xe8,0x50,0x11,0x0b,0xd8,0x32,0x8c,0xfb,0xd5,0x08,0x41,0xd6,0x91,0x1d,0x87],
  83     [0x67,0xf1,0x49,0x84,0xc7,0xda,0x79,0x12,0x48,0xe3,0x2b,0xb5,0x92,0x25,0x83,0xda],
  84     [0x19,0x38,0xf2,0xcf,0x72,0xd5,0x4e,0xe9,0x7e,0x94,0x16,0x6f,0xa9,0x1d,0x2a,0x36],
  85     [0x74,0x48,0x1e,0x96,0x46,0xed,0x49,0xfe,0x0f,0x62,0x24,0x30,0x16,0x04,0x69,0x8e],
  86     [0x57,0xfc,0xa5,0xde,0x98,0xa9,0xd6,0xd8,0x00,0x64,0x38,0xd0,0x58,0x3d,0x8a,0x1d],
  87     [0x9f,0xec,0xde,0x1c,0xef,0xdc,0x1c,0xbe,0xd4,0x76,0x36,0x74,0xd9,0x57,0x53,0x59],
  88     [0xe3,0x04,0x0c,0x00,0xeb,0x28,0xf1,0x53,0x66,0xca,0x73,0xcb,0xd8,0x72,0xe7,0x40],
  89     [0x76,0x97,0x00,0x9a,0x6a,0x83,0x1d,0xfe,0xcc,0xa9,0x1c,0x59,0x93,0x67,0x0f,0x7a],
  90     [0x58,0x53,0x54,0x23,0x21,0xf5,0x67,0xa0,0x05,0xd5,0x47,0xa4,0xf0,0x47,0x59,0xbd],
  91     [0x51,0x50,0xd1,0x77,0x2f,0x50,0x83,0x4a,0x50,0x3e,0x06,0x9a,0x97,0x3f,0xbd,0x7c],
  92 ];
  93
  94 // Test vector from reference implementation
  95 #[test]
  96 fn test_siphash_2_4_test_vector() {
  97     let k0 = 0x_07_06_05_04_03_02_01_00;
  98     let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08;
  99
 100     let mut input: Vec<u8> = Vec::new();
 101
 102     for i in 0 .. 64 {
 103         let out = hash_with(SipHasher128::new_with_keys(k0, k1),
 104                             &Bytes(&input[..]));
 105         let expected = (
 106             ((TEST_VECTOR[i][0] as u64) <<  0) |
 107             ((TEST_VECTOR[i][1] as u64) <<  8) |
 108             ((TEST_VECTOR[i][2] as u64) << 16) |
 109             ((TEST_VECTOR[i][3] as u64) << 24) |
 110             ((TEST_VECTOR[i][4] as u64) << 32) |
 111             ((TEST_VECTOR[i][5] as u64) << 40) |
 112             ((TEST_VECTOR[i][6] as u64) << 48) |
 113             ((TEST_VECTOR[i][7] as u64) << 56),
 114
 115             ((TEST_VECTOR[i][8] as u64) <<  0) |
 116             ((TEST_VECTOR[i][9] as u64) <<  8) |
 117             ((TEST_VECTOR[i][10] as u64) << 16) |
 118             ((TEST_VECTOR[i][11] as u64) << 24) |
 119             ((TEST_VECTOR[i][12] as u64) << 32) |
 120             ((TEST_VECTOR[i][13] as u64) << 40) |
 121             ((TEST_VECTOR[i][14] as u64) << 48) |
 122             ((TEST_VECTOR[i][15] as u64) << 56),
 123         );
 124
 125         assert_eq!(out, expected);
 126         input.push(i as u8);
 127     }
 128 }
 129
 130 #[test] #[cfg(target_arch = "arm")]
 131 fn test_hash_usize() {
 132     let val = 0xdeadbeef_deadbeef_u64;
 133     assert!(hash(&(val as u64)) != hash(&(val as usize)));
 134     assert_eq!(hash(&(val as u32)), hash(&(val as usize)));
 135 }
 136 #[test] #[cfg(target_arch = "x86_64")]
 137 fn test_hash_usize() {
 138     let val = 0xdeadbeef_deadbeef_u64;
 139     assert_eq!(hash(&(val as u64)), hash(&(val as usize)));
 140     assert!(hash(&(val as u32)) != hash(&(val as usize)));
 141 }
 142 #[test] #[cfg(target_arch = "x86")]
 143 fn test_hash_usize() {
 144     let val = 0xdeadbeef_deadbeef_u64;
 145     assert!(hash(&(val as u64)) != hash(&(val as usize)));
 146     assert_eq!(hash(&(val as u32)), hash(&(val as usize)));
 147 }
 148
 149 #[test]
 150 fn test_hash_idempotent() {
 151     let val64 = 0xdeadbeef_deadbeef_u64;
 152     assert_eq!(hash(&val64), hash(&val64));
 153     let val32 = 0xdeadbeef_u32;
 154     assert_eq!(hash(&val32), hash(&val32));
 155 }
 156
 157 #[test]
 158 fn test_hash_no_bytes_dropped_64() {
 159     let val = 0xdeadbeef_deadbeef_u64;
 160
 161     assert!(hash(&val) != hash(&zero_byte(val, 0)));
 162     assert!(hash(&val) != hash(&zero_byte(val, 1)));
 163     assert!(hash(&val) != hash(&zero_byte(val, 2)));
 164     assert!(hash(&val) != hash(&zero_byte(val, 3)));
 165     assert!(hash(&val) != hash(&zero_byte(val, 4)));
 166     assert!(hash(&val) != hash(&zero_byte(val, 5)));
 167     assert!(hash(&val) != hash(&zero_byte(val, 6)));
 168     assert!(hash(&val) != hash(&zero_byte(val, 7)));
 169
 170     fn zero_byte(val: u64, byte: usize) -> u64 {
 171         assert!(byte < 8);
 172         val & !(0xff << (byte * 8))
 173     }
 174 }
 175
 176 #[test]
 177 fn test_hash_no_bytes_dropped_32() {
 178     let val = 0xdeadbeef_u32;
 179
 180     assert!(hash(&val) != hash(&zero_byte(val, 0)));
 181     assert!(hash(&val) != hash(&zero_byte(val, 1)));
 182     assert!(hash(&val) != hash(&zero_byte(val, 2)));
 183     assert!(hash(&val) != hash(&zero_byte(val, 3)));
 184
 185     fn zero_byte(val: u32, byte: usize) -> u32 {
 186         assert!(byte < 4);
 187         val & !(0xff << (byte * 8))
 188     }
 189 }
 190
 191 #[test]
 192 fn test_hash_no_concat_alias() {
 193     let s = ("aa", "bb");
 194     let t = ("aabb", "");
 195     let u = ("a", "abb");
 196
 197     assert!(s != t && t != u);
 198     assert!(hash(&s) != hash(&t) && hash(&s) != hash(&u));
 199
 200     let u = [1, 0, 0, 0];
 201     let v = (&u[..1], &u[1..3], &u[3..]);
 202     let w = (&u[..], &u[4..4], &u[4..4]);
 203
 204     assert!(v != w);
 205     assert!(hash(&v) != hash(&w));
 206 }
 207
 208 #[test]
 209 fn test_write_short_works() {
 210     let test_usize = 0xd0c0b0a0usize;
 211     let mut h1 = SipHasher128::new_with_keys(0, 0);
 212     h1.write_usize(test_usize);
 213     h1.write(b"bytes");
 214     h1.write(b"string");
 215     h1.write_u8(0xFFu8);
 216     h1.write_u8(0x01u8);
 217     let mut h2 = SipHasher128::new_with_keys(0, 0);
 218     h2.write(unsafe {
 219         slice::from_raw_parts(&test_usize as *const _ as *const u8,
 220                                 mem::size_of::<usize>())
 221     });
 222     h2.write(b"bytes");
 223     h2.write(b"string");
 224     h2.write(&[0xFFu8, 0x01u8]);
 225     assert_eq!(h1.finish128(), h2.finish128());
 226 }