1 SipHash - a short input PRF 2----------------------------------------------- 3Written by Jason A. Donenfeld <jason@zx2c4.com> 4 5SipHash is a cryptographically secure PRF -- a keyed hash function -- that 6performs very well for short inputs, hence the name. It was designed by 7cryptographers Daniel J. Bernstein and Jean-Philippe Aumasson. It is intended 8as a replacement for some uses of: `jhash`, `md5_transform`, `sha_transform`, 9and so forth. 10 11SipHash takes a secret key filled with randomly generated numbers and either 12an input buffer or several input integers. It spits out an integer that is 13indistinguishable from random. You may then use that integer as part of secure 14sequence numbers, secure cookies, or mask it off for use in a hash table. 15 161. Generating a key 17 18Keys should always be generated from a cryptographically secure source of 19random numbers, either using get_random_bytes or get_random_once: 20 21siphash_key_t key; 22get_random_bytes(&key, sizeof(key)); 23 24If you're not deriving your key from here, you're doing it wrong. 25 262. Using the functions 27 28There are two variants of the function, one that takes a list of integers, and 29one that takes a buffer: 30 31u64 siphash(const void *data, size_t len, const siphash_key_t *key); 32 33And: 34 35u64 siphash_1u64(u64, const siphash_key_t *key); 36u64 siphash_2u64(u64, u64, const siphash_key_t *key); 37u64 siphash_3u64(u64, u64, u64, const siphash_key_t *key); 38u64 siphash_4u64(u64, u64, u64, u64, const siphash_key_t *key); 39u64 siphash_1u32(u32, const siphash_key_t *key); 40u64 siphash_2u32(u32, u32, const siphash_key_t *key); 41u64 siphash_3u32(u32, u32, u32, const siphash_key_t *key); 42u64 siphash_4u32(u32, u32, u32, u32, const siphash_key_t *key); 43 44If you pass the generic siphash function something of a constant length, it 45will constant fold at compile-time and automatically choose one of the 46optimized functions. 47 483. Hashtable key function usage: 49 50struct some_hashtable { 51 DECLARE_HASHTABLE(hashtable, 8); 52 siphash_key_t key; 53}; 54 55void init_hashtable(struct some_hashtable *table) 56{ 57 get_random_bytes(&table->key, sizeof(table->key)); 58} 59 60static inline hlist_head *some_hashtable_bucket(struct some_hashtable *table, struct interesting_input *input) 61{ 62 return &table->hashtable[siphash(input, sizeof(*input), &table->key) & (HASH_SIZE(table->hashtable) - 1)]; 63} 64 65You may then iterate like usual over the returned hash bucket. 66 674. Security 68 69SipHash has a very high security margin, with its 128-bit key. So long as the 70key is kept secret, it is impossible for an attacker to guess the outputs of 71the function, even if being able to observe many outputs, since 2^128 outputs 72is significant. 73 74Linux implements the "2-4" variant of SipHash. 75 765. Struct-passing Pitfalls 77 78Often times the XuY functions will not be large enough, and instead you'll 79want to pass a pre-filled struct to siphash. When doing this, it's important 80to always ensure the struct has no padding holes. The easiest way to do this 81is to simply arrange the members of the struct in descending order of size, 82and to use offsetendof() instead of sizeof() for getting the size. For 83performance reasons, if possible, it's probably a good thing to align the 84struct to the right boundary. Here's an example: 85 86const struct { 87 struct in6_addr saddr; 88 u32 counter; 89 u16 dport; 90} __aligned(SIPHASH_ALIGNMENT) combined = { 91 .saddr = *(struct in6_addr *)saddr, 92 .counter = counter, 93 .dport = dport 94}; 95u64 h = siphash(&combined, offsetofend(typeof(combined), dport), &secret); 96 976. Resources 98 99Read the SipHash paper if you're interested in learning more: 100https://131002.net/siphash/siphash.pdf 101 102 103~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~ 104 105HalfSipHash - SipHash's insecure younger cousin 106----------------------------------------------- 107Written by Jason A. Donenfeld <jason@zx2c4.com> 108 109On the off-chance that SipHash is not fast enough for your needs, you might be 110able to justify using HalfSipHash, a terrifying but potentially useful 111possibility. HalfSipHash cuts SipHash's rounds down from "2-4" to "1-3" and, 112even scarier, uses an easily brute-forcable 64-bit key (with a 32-bit output) 113instead of SipHash's 128-bit key. However, this may appeal to some 114high-performance `jhash` users. 115 116Danger! 117 118Do not ever use HalfSipHash except for as a hashtable key function, and only 119then when you can be absolutely certain that the outputs will never be 120transmitted out of the kernel. This is only remotely useful over `jhash` as a 121means of mitigating hashtable flooding denial of service attacks. 122 1231. Generating a key 124 125Keys should always be generated from a cryptographically secure source of 126random numbers, either using get_random_bytes or get_random_once: 127 128hsiphash_key_t key; 129get_random_bytes(&key, sizeof(key)); 130 131If you're not deriving your key from here, you're doing it wrong. 132 1332. Using the functions 134 135There are two variants of the function, one that takes a list of integers, and 136one that takes a buffer: 137 138u32 hsiphash(const void *data, size_t len, const hsiphash_key_t *key); 139 140And: 141 142u32 hsiphash_1u32(u32, const hsiphash_key_t *key); 143u32 hsiphash_2u32(u32, u32, const hsiphash_key_t *key); 144u32 hsiphash_3u32(u32, u32, u32, const hsiphash_key_t *key); 145u32 hsiphash_4u32(u32, u32, u32, u32, const hsiphash_key_t *key); 146 147If you pass the generic hsiphash function something of a constant length, it 148will constant fold at compile-time and automatically choose one of the 149optimized functions. 150 1513. Hashtable key function usage: 152 153struct some_hashtable { 154 DECLARE_HASHTABLE(hashtable, 8); 155 hsiphash_key_t key; 156}; 157 158void init_hashtable(struct some_hashtable *table) 159{ 160 get_random_bytes(&table->key, sizeof(table->key)); 161} 162 163static inline hlist_head *some_hashtable_bucket(struct some_hashtable *table, struct interesting_input *input) 164{ 165 return &table->hashtable[hsiphash(input, sizeof(*input), &table->key) & (HASH_SIZE(table->hashtable) - 1)]; 166} 167 168You may then iterate like usual over the returned hash bucket. 169 1704. Performance 171 172HalfSipHash is roughly 3 times slower than JenkinsHash. For many replacements, 173this will not be a problem, as the hashtable lookup isn't the bottleneck. And 174in general, this is probably a good sacrifice to make for the security and DoS 175resistance of HalfSipHash. 176