200 lines · plain
1===========================2SipHash - a short input PRF3===========================4 5:Author: Written by Jason A. Donenfeld <jason@zx2c4.com>6 7SipHash is a cryptographically secure PRF -- a keyed hash function -- that8performs very well for short inputs, hence the name. It was designed by9cryptographers Daniel J. Bernstein and Jean-Philippe Aumasson. It is intended10as a replacement for some uses of: `jhash`, `md5_transform`, `sha1_transform`,11and so forth.12 13SipHash takes a secret key filled with randomly generated numbers and either14an input buffer or several input integers. It spits out an integer that is15indistinguishable from random. You may then use that integer as part of secure16sequence numbers, secure cookies, or mask it off for use in a hash table.17 18Generating a key19================20 21Keys should always be generated from a cryptographically secure source of22random numbers, either using get_random_bytes or get_random_once::23 24 siphash_key_t key;25 get_random_bytes(&key, sizeof(key));26 27If you're not deriving your key from here, you're doing it wrong.28 29Using the functions30===================31 32There are two variants of the function, one that takes a list of integers, and33one that takes a buffer::34 35 u64 siphash(const void *data, size_t len, const siphash_key_t *key);36 37And::38 39 u64 siphash_1u64(u64, const siphash_key_t *key);40 u64 siphash_2u64(u64, u64, const siphash_key_t *key);41 u64 siphash_3u64(u64, u64, u64, const siphash_key_t *key);42 u64 siphash_4u64(u64, u64, u64, u64, const siphash_key_t *key);43 u64 siphash_1u32(u32, const siphash_key_t *key);44 u64 siphash_2u32(u32, u32, const siphash_key_t *key);45 u64 siphash_3u32(u32, u32, u32, const siphash_key_t *key);46 u64 siphash_4u32(u32, u32, u32, u32, const siphash_key_t *key);47 48If you pass the generic siphash function something of a constant length, it49will constant fold at compile-time and automatically choose one of the50optimized functions.51 52Hashtable key function usage::53 54 struct some_hashtable {55 DECLARE_HASHTABLE(hashtable, 8);56 siphash_key_t key;57 };58 59 void init_hashtable(struct some_hashtable *table)60 {61 get_random_bytes(&table->key, sizeof(table->key));62 }63 64 static inline hlist_head *some_hashtable_bucket(struct some_hashtable *table, struct interesting_input *input)65 {66 return &table->hashtable[siphash(input, sizeof(*input), &table->key) & (HASH_SIZE(table->hashtable) - 1)];67 }68 69You may then iterate like usual over the returned hash bucket.70 71Security72========73 74SipHash has a very high security margin, with its 128-bit key. So long as the75key is kept secret, it is impossible for an attacker to guess the outputs of76the function, even if being able to observe many outputs, since 2^128 outputs77is significant.78 79Linux implements the "2-4" variant of SipHash.80 81Struct-passing Pitfalls82=======================83 84Often times the XuY functions will not be large enough, and instead you'll85want to pass a pre-filled struct to siphash. When doing this, it's important86to always ensure the struct has no padding holes. The easiest way to do this87is to simply arrange the members of the struct in descending order of size,88and to use offsetofend() instead of sizeof() for getting the size. For89performance reasons, if possible, it's probably a good thing to align the90struct to the right boundary. Here's an example::91 92 const struct {93 struct in6_addr saddr;94 u32 counter;95 u16 dport;96 } __aligned(SIPHASH_ALIGNMENT) combined = {97 .saddr = *(struct in6_addr *)saddr,98 .counter = counter,99 .dport = dport100 };101 u64 h = siphash(&combined, offsetofend(typeof(combined), dport), &secret);102 103Resources104=========105 106Read the SipHash paper if you're interested in learning more:107https://131002.net/siphash/siphash.pdf108 109-------------------------------------------------------------------------------110 111===============================================112HalfSipHash - SipHash's insecure younger cousin113===============================================114 115:Author: Written by Jason A. Donenfeld <jason@zx2c4.com>116 117On the off-chance that SipHash is not fast enough for your needs, you might be118able to justify using HalfSipHash, a terrifying but potentially useful119possibility. HalfSipHash cuts SipHash's rounds down from "2-4" to "1-3" and,120even scarier, uses an easily brute-forcable 64-bit key (with a 32-bit output)121instead of SipHash's 128-bit key. However, this may appeal to some122high-performance `jhash` users.123 124HalfSipHash support is provided through the "hsiphash" family of functions.125 126.. warning::127 Do not ever use the hsiphash functions except for as a hashtable key128 function, and only then when you can be absolutely certain that the outputs129 will never be transmitted out of the kernel. This is only remotely useful130 over `jhash` as a means of mitigating hashtable flooding denial of service131 attacks.132 133On 64-bit kernels, the hsiphash functions actually implement SipHash-1-3, a134reduced-round variant of SipHash, instead of HalfSipHash-1-3. This is because in13564-bit code, SipHash-1-3 is no slower than HalfSipHash-1-3, and can be faster.136Note, this does *not* mean that in 64-bit kernels the hsiphash functions are the137same as the siphash ones, or that they are secure; the hsiphash functions still138use a less secure reduced-round algorithm and truncate their outputs to 32139bits.140 141Generating a hsiphash key142=========================143 144Keys should always be generated from a cryptographically secure source of145random numbers, either using get_random_bytes or get_random_once::146 147 hsiphash_key_t key;148 get_random_bytes(&key, sizeof(key));149 150If you're not deriving your key from here, you're doing it wrong.151 152Using the hsiphash functions153============================154 155There are two variants of the function, one that takes a list of integers, and156one that takes a buffer::157 158 u32 hsiphash(const void *data, size_t len, const hsiphash_key_t *key);159 160And::161 162 u32 hsiphash_1u32(u32, const hsiphash_key_t *key);163 u32 hsiphash_2u32(u32, u32, const hsiphash_key_t *key);164 u32 hsiphash_3u32(u32, u32, u32, const hsiphash_key_t *key);165 u32 hsiphash_4u32(u32, u32, u32, u32, const hsiphash_key_t *key);166 167If you pass the generic hsiphash function something of a constant length, it168will constant fold at compile-time and automatically choose one of the169optimized functions.170 171Hashtable key function usage172============================173 174::175 176 struct some_hashtable {177 DECLARE_HASHTABLE(hashtable, 8);178 hsiphash_key_t key;179 };180 181 void init_hashtable(struct some_hashtable *table)182 {183 get_random_bytes(&table->key, sizeof(table->key));184 }185 186 static inline hlist_head *some_hashtable_bucket(struct some_hashtable *table, struct interesting_input *input)187 {188 return &table->hashtable[hsiphash(input, sizeof(*input), &table->key) & (HASH_SIZE(table->hashtable) - 1)];189 }190 191You may then iterate like usual over the returned hash bucket.192 193Performance194===========195 196hsiphash() is roughly 3 times slower than jhash(). For many replacements, this197will not be a problem, as the hashtable lookup isn't the bottleneck. And in198general, this is probably a good sacrifice to make for the security and DoS199resistance of hsiphash().200