About Kernel Documentation Linux Kernel Contact Linux Resources Linux Blog

Documentation / siphash.txt




Custom Search

Based on kernel version 4.16.1. Page generated on 2018-04-09 11:53 EST.

1	===========================
2	SipHash - a short input PRF
3	===========================
4	
5	:Author: Written by Jason A. Donenfeld <jason@zx2c4.com>
6	
7	SipHash is a cryptographically secure PRF -- a keyed hash function -- that
8	performs very well for short inputs, hence the name. It was designed by
9	cryptographers Daniel J. Bernstein and Jean-Philippe Aumasson. It is intended
10	as a replacement for some uses of: `jhash`, `md5_transform`, `sha_transform`,
11	and so forth.
12	
13	SipHash takes a secret key filled with randomly generated numbers and either
14	an input buffer or several input integers. It spits out an integer that is
15	indistinguishable from random. You may then use that integer as part of secure
16	sequence numbers, secure cookies, or mask it off for use in a hash table.
17	
18	Generating a key
19	================
20	
21	Keys should always be generated from a cryptographically secure source of
22	random numbers, either using get_random_bytes or get_random_once::
23	
24		siphash_key_t key;
25		get_random_bytes(&key, sizeof(key));
26	
27	If you're not deriving your key from here, you're doing it wrong.
28	
29	Using the functions
30	===================
31	
32	There are two variants of the function, one that takes a list of integers, and
33	one that takes a buffer::
34	
35		u64 siphash(const void *data, size_t len, const siphash_key_t *key);
36	
37	And::
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	
48	If you pass the generic siphash function something of a constant length, it
49	will constant fold at compile-time and automatically choose one of the
50	optimized functions.
51	
52	Hashtable 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	
69	You may then iterate like usual over the returned hash bucket.
70	
71	Security
72	========
73	
74	SipHash has a very high security margin, with its 128-bit key. So long as the
75	key is kept secret, it is impossible for an attacker to guess the outputs of
76	the function, even if being able to observe many outputs, since 2^128 outputs
77	is significant.
78	
79	Linux implements the "2-4" variant of SipHash.
80	
81	Struct-passing Pitfalls
82	=======================
83	
84	Often times the XuY functions will not be large enough, and instead you'll
85	want to pass a pre-filled struct to siphash. When doing this, it's important
86	to always ensure the struct has no padding holes. The easiest way to do this
87	is to simply arrange the members of the struct in descending order of size,
88	and to use offsetendof() instead of sizeof() for getting the size. For
89	performance reasons, if possible, it's probably a good thing to align the
90	struct 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	
103	Resources
104	=========
105	
106	Read the SipHash paper if you're interested in learning more:
107	https://131002.net/siphash/siphash.pdf
108	
109	-------------------------------------------------------------------------------
110	
111	===============================================
112	HalfSipHash - SipHash's insecure younger cousin
113	===============================================
114	
115	:Author: Written by Jason A. Donenfeld <jason@zx2c4.com>
116	
117	On the off-chance that SipHash is not fast enough for your needs, you might be
118	able to justify using HalfSipHash, a terrifying but potentially useful
119	possibility. HalfSipHash cuts SipHash's rounds down from "2-4" to "1-3" and,
120	even scarier, uses an easily brute-forcable 64-bit key (with a 32-bit output)
121	instead of SipHash's 128-bit key. However, this may appeal to some
122	high-performance `jhash` users.
123	
124	Danger!
125	
126	Do not ever use HalfSipHash except for as a hashtable key function, and only
127	then when you can be absolutely certain that the outputs will never be
128	transmitted out of the kernel. This is only remotely useful over `jhash` as a
129	means of mitigating hashtable flooding denial of service attacks.
130	
131	Generating a key
132	================
133	
134	Keys should always be generated from a cryptographically secure source of
135	random numbers, either using get_random_bytes or get_random_once:
136	
137	hsiphash_key_t key;
138	get_random_bytes(&key, sizeof(key));
139	
140	If you're not deriving your key from here, you're doing it wrong.
141	
142	Using the functions
143	===================
144	
145	There are two variants of the function, one that takes a list of integers, and
146	one that takes a buffer::
147	
148		u32 hsiphash(const void *data, size_t len, const hsiphash_key_t *key);
149	
150	And::
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	
157	If you pass the generic hsiphash function something of a constant length, it
158	will constant fold at compile-time and automatically choose one of the
159	optimized functions.
160	
161	Hashtable 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	
181	You may then iterate like usual over the returned hash bucket.
182	
183	Performance
184	===========
185	
186	HalfSipHash is roughly 3 times slower than JenkinsHash. For many replacements,
187	this will not be a problem, as the hashtable lookup isn't the bottleneck. And
188	in general, this is probably a good sacrifice to make for the security and DoS
189	resistance of HalfSipHash.
Hide Line Numbers
About Kernel Documentation Linux Kernel Contact Linux Resources Linux Blog

Information is copyright its respective author. All material is available from the Linux Kernel Source distributed under a GPL License. This page is provided as a free service by mjmwired.net.