linux/Documentation/security/siphash.rst
<<
>>
Prefs
   1===========================
   2SipHash - a short input PRF
   3===========================
   4
   5:Author: Written by Jason A. Donenfeld <jason@zx2c4.com>
   6
   7SipHash is a cryptographically secure PRF -- a keyed hash function -- that
   8performs very well for short inputs, hence the name. It was designed by
   9cryptographers Daniel J. Bernstein and Jean-Philippe Aumasson. It is intended
  10as 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 either
  14an input buffer or several input integers. It spits out an integer that is
  15indistinguishable from random. You may then use that integer as part of secure
  16sequence numbers, secure cookies, or mask it off for use in a hash table.
  17
  18Generating a key
  19================
  20
  21Keys should always be generated from a cryptographically secure source of
  22random 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 functions
  30===================
  31
  32There are two variants of the function, one that takes a list of integers, and
  33one 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, it
  49will constant fold at compile-time and automatically choose one of the
  50optimized 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
  71Security
  72========
  73
  74SipHash has a very high security margin, with its 128-bit key. So long as the
  75key is kept secret, it is impossible for an attacker to guess the outputs of
  76the function, even if being able to observe many outputs, since 2^128 outputs
  77is significant.
  78
  79Linux implements the "2-4" variant of SipHash.
  80
  81Struct-passing Pitfalls
  82=======================
  83
  84Often times the XuY functions will not be large enough, and instead you'll
  85want to pass a pre-filled struct to siphash. When doing this, it's important
  86to always ensure the struct has no padding holes. The easiest way to do this
  87is to simply arrange the members of the struct in descending order of size,
  88and to use offsetendof() instead of sizeof() for getting the size. For
  89performance reasons, if possible, it's probably a good thing to align the
  90struct 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 = dport
 100        };
 101        u64 h = siphash(&combined, offsetofend(typeof(combined), dport), &secret);
 102
 103Resources
 104=========
 105
 106Read the SipHash paper if you're interested in learning more:
 107https://131002.net/siphash/siphash.pdf
 108
 109-------------------------------------------------------------------------------
 110
 111===============================================
 112HalfSipHash - SipHash's insecure younger cousin
 113===============================================
 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 be
 118able to justify using HalfSipHash, a terrifying but potentially useful
 119possibility. 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 some
 122high-performance `jhash` users.
 123
 124Danger!
 125
 126Do not ever use HalfSipHash except for as a hashtable key function, and only
 127then when you can be absolutely certain that the outputs will never be
 128transmitted out of the kernel. This is only remotely useful over `jhash` as a
 129means of mitigating hashtable flooding denial of service attacks.
 130
 131Generating a HalfSipHash key
 132============================
 133
 134Keys should always be generated from a cryptographically secure source of
 135random numbers, either using get_random_bytes or get_random_once:
 136
 137hsiphash_key_t key;
 138get_random_bytes(&key, sizeof(key));
 139
 140If you're not deriving your key from here, you're doing it wrong.
 141
 142Using the HalfSipHash functions
 143===============================
 144
 145There are two variants of the function, one that takes a list of integers, and
 146one that takes a buffer::
 147
 148        u32 hsiphash(const void *data, size_t len, const hsiphash_key_t *key);
 149
 150And::
 151
 152        u32 hsiphash_1u32(u32, const hsiphash_key_t *key);
 153        u32 hsiphash_2u32(u32, u32, const hsiphash_key_t *key);
 154        u32 hsiphash_3u32(u32, u32, u32, const hsiphash_key_t *key);
 155        u32 hsiphash_4u32(u32, u32, u32, u32, const hsiphash_key_t *key);
 156
 157If you pass the generic hsiphash function something of a constant length, it
 158will constant fold at compile-time and automatically choose one of the
 159optimized functions.
 160
 161Hashtable key function usage
 162============================
 163
 164::
 165
 166        struct some_hashtable {
 167                DECLARE_HASHTABLE(hashtable, 8);
 168                hsiphash_key_t key;
 169        };
 170
 171        void init_hashtable(struct some_hashtable *table)
 172        {
 173                get_random_bytes(&table->key, sizeof(table->key));
 174        }
 175
 176        static inline hlist_head *some_hashtable_bucket(struct some_hashtable *table, struct interesting_input *input)
 177        {
 178                return &table->hashtable[hsiphash(input, sizeof(*input), &table->key) & (HASH_SIZE(table->hashtable) - 1)];
 179        }
 180
 181You may then iterate like usual over the returned hash bucket.
 182
 183Performance
 184===========
 185
 186HalfSipHash is roughly 3 times slower than JenkinsHash. For many replacements,
 187this will not be a problem, as the hashtable lookup isn't the bottleneck. And
 188in general, this is probably a good sacrifice to make for the security and DoS
 189resistance of HalfSipHash.
 190