1 /* CC0 license (public domain) - see LICENSE file for details */
2 /* Based on CC0 reference implementation:
3 * https://github.com/veorq/SipHash c03e6bbf6613243bc30788912ad4afbc0b992d47
5 #include <ccan/crypto/siphash24/siphash24.h>
6 #include <ccan/endian/endian.h>
11 /* default: SipHash-2-4 */
15 #define ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
20 v[1] = ROTL(v[1], 13); \
22 v[0] = ROTL(v[0], 32); \
24 v[3] = ROTL(v[3], 16); \
27 v[3] = ROTL(v[3], 21); \
30 v[1] = ROTL(v[1], 17); \
32 v[2] = ROTL(v[2], 32); \
35 static void invalidate_siphash24(struct siphash24_ctx *ctx)
40 static void check_siphash24(struct siphash24_ctx *ctx)
42 assert(ctx->bytes != -1ULL);
45 static bool alignment_ok(const void *p, size_t n)
47 #if HAVE_UNALIGNED_ACCESS
50 return ((size_t)p % n == 0);
54 static void add_64bits(uint64_t v[4], uint64_t in)
57 uint64_t m = cpu_to_le64(in);
60 for (i = 0; i < cROUNDS; ++i)
66 static void add(struct siphash24_ctx *ctx, const void *p, size_t len)
68 const unsigned char *data = p;
69 size_t bufsize = ctx->bytes % sizeof(ctx->buf.u8);
71 if (bufsize + len >= sizeof(ctx->buf.u8)) {
72 // Fill the buffer, and process it.
73 memcpy(ctx->buf.u8 + bufsize, data,
74 sizeof(ctx->buf.u8) - bufsize);
75 ctx->bytes += sizeof(ctx->buf.u8) - bufsize;
76 data += sizeof(ctx->buf.u8) - bufsize;
77 len -= sizeof(ctx->buf.u8) - bufsize;
78 add_64bits(ctx->v, ctx->buf.u64);
82 while (len >= sizeof(ctx->buf.u8)) {
83 // Process full chunks directly from the source.
84 if (alignment_ok(data, sizeof(uint64_t)))
85 add_64bits(ctx->v, *(const uint64_t *)data);
87 memcpy(ctx->buf.u8, data, sizeof(ctx->buf));
88 add_64bits(ctx->v, ctx->buf.u64);
90 ctx->bytes += sizeof(ctx->buf.u8);
91 data += sizeof(ctx->buf.u8);
92 len -= sizeof(ctx->buf.u8);
96 // Fill the buffer with what remains.
97 memcpy(ctx->buf.u8 + bufsize, data, len);
102 void siphash24_init(struct siphash24_ctx *ctx, const struct siphash_seed *seed)
104 struct siphash24_ctx init = SIPHASH24_INIT(0, 0);
106 ctx->v[0] ^= seed->u.u64[0];
107 ctx->v[1] ^= seed->u.u64[1];
108 ctx->v[2] ^= seed->u.u64[0];
109 ctx->v[3] ^= seed->u.u64[1];
112 void siphash24_update(struct siphash24_ctx *ctx, const void *p, size_t size)
114 check_siphash24(ctx);
118 uint64_t siphash24_done(struct siphash24_ctx *ctx)
123 b = ctx->bytes << 56;
125 switch (ctx->bytes % 8) {
127 b |= ((uint64_t)ctx->buf.u8[6]) << 48;
129 b |= ((uint64_t)ctx->buf.u8[5]) << 40;
131 b |= ((uint64_t)ctx->buf.u8[4]) << 32;
133 b |= ((uint64_t)ctx->buf.u8[3]) << 24;
135 b |= ((uint64_t)ctx->buf.u8[2]) << 16;
137 b |= ((uint64_t)ctx->buf.u8[1]) << 8;
139 b |= ((uint64_t)ctx->buf.u8[0]);
147 for (i = 0; i < cROUNDS; ++i)
154 for (i = 0; i < dROUNDS; ++i)
157 b = ctx->v[0] ^ ctx->v[1] ^ ctx->v[2] ^ ctx->v[3];
159 invalidate_siphash24(ctx);
160 return cpu_to_le64(b);
163 uint64_t siphash24(const struct siphash_seed *seed, const void *p, size_t size)
165 struct siphash24_ctx ctx;
167 siphash24_init(&ctx, seed);
168 siphash24_update(&ctx, p, size);
169 return siphash24_done(&ctx);
172 void siphash24_u8(struct siphash24_ctx *ctx, uint8_t v)
174 siphash24_update(ctx, &v, sizeof(v));
177 void siphash24_u16(struct siphash24_ctx *ctx, uint16_t v)
179 siphash24_update(ctx, &v, sizeof(v));
182 void siphash24_u32(struct siphash24_ctx *ctx, uint32_t v)
184 siphash24_update(ctx, &v, sizeof(v));
187 void siphash24_u64(struct siphash24_ctx *ctx, uint64_t v)
189 siphash24_update(ctx, &v, sizeof(v));
192 /* Add as little-endian */
193 void siphash24_le16(struct siphash24_ctx *ctx, uint16_t v)
195 leint16_t lev = cpu_to_le16(v);
196 siphash24_update(ctx, &lev, sizeof(lev));
199 void siphash24_le32(struct siphash24_ctx *ctx, uint32_t v)
201 leint32_t lev = cpu_to_le32(v);
202 siphash24_update(ctx, &lev, sizeof(lev));
205 void siphash24_le64(struct siphash24_ctx *ctx, uint64_t v)
207 leint64_t lev = cpu_to_le64(v);
208 siphash24_update(ctx, &lev, sizeof(lev));
211 /* Add as big-endian */
212 void siphash24_be16(struct siphash24_ctx *ctx, uint16_t v)
214 beint16_t bev = cpu_to_be16(v);
215 siphash24_update(ctx, &bev, sizeof(bev));
218 void siphash24_be32(struct siphash24_ctx *ctx, uint32_t v)
220 beint32_t bev = cpu_to_be32(v);
221 siphash24_update(ctx, &bev, sizeof(bev));
224 void siphash24_be64(struct siphash24_ctx *ctx, uint64_t v)
226 beint64_t bev = cpu_to_be64(v);
227 siphash24_update(ctx, &bev, sizeof(bev));