tor/src/ext/siphash.h

#ifndef SIPHASH_H
#define SIPHASH_H

#include <stdint.h>

struct sipkey {
  uint64_t k0;
  uint64_t k1;
};
uint64_t siphash24(const void *src, unsigned long src_sz, const struct sipkey *key);

void siphash_set_global_key(const struct sipkey *key);
uint64_t siphash24g(const void *src, unsigned long src_sz);
void siphash_unset_global_key(void);

#endif
Tests for siphash, from reference implementation. 2014-02-12 16:58:03 +01:00			`#ifndef SIPHASH_H`
			`#define SIPHASH_H`
Siphash-2-4 is now our hash in nearly all cases. I've made an exception for cases where I'm sure that users can't influence the inputs. This is likely to cause a slowdown somewhere, but it's safer to siphash everything and then look for cases to optimize. This patch doesn't actually get us any _benefit_ from siphash yet, since we don't really randomize the key at any point. 2014-02-07 23:38:16 +01:00
siphash.h: include stdint. Doing this gives us a valid uint64_t type, freeing us from dependencies on include order. 2019-12-16 19:06:00 +01:00			`#include <stdint.h>`

Tests for siphash, from reference implementation. 2014-02-12 16:58:03 +01:00			`struct sipkey {`
			`uint64_t k0;`
			`uint64_t k1;`
			`};`
			`uint64_t siphash24(const void src, unsigned long src_sz, const struct sipkey key);`

csiphash: Add functions to take a global key. 2014-02-12 17:27:03 +01:00			`void siphash_set_global_key(const struct sipkey *key);`
			`uint64_t siphash24g(const void *src, unsigned long src_sz);`
On shutdown, mark openssl as uninitialized. This causes openssl to get completely reinitialized on startup, which is probably a good idea. 2018-01-11 18:49:28 +01:00			`void siphash_unset_global_key(void);`
csiphash: Add functions to take a global key. 2014-02-12 17:27:03 +01:00
Tests for siphash, from reference implementation. 2014-02-12 16:58:03 +01:00			`#endif`