--- /dev/null
+/* CC0 license (public domain) - see LICENSE file for details */
+/* Based on CC0 reference implementation:
+ * https://github.com/veorq/SipHash c03e6bbf6613243bc30788912ad4afbc0b992d47
+ */
+#include <ccan/crypto/siphash24/siphash24.h>
+#include <ccan/endian/endian.h>
+#include <stdbool.h>
+#include <assert.h>
+#include <string.h>
+
+/* default: SipHash-2-4 */
+#define cROUNDS 2
+#define dROUNDS 4
+
+#define ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
+
+#define SIPROUND(v) \
+ do { \
+ v[0] += v[1]; \
+ v[1] = ROTL(v[1], 13); \
+ v[1] ^= v[0]; \
+ v[0] = ROTL(v[0], 32); \
+ v[2] += v[3]; \
+ v[3] = ROTL(v[3], 16); \
+ v[3] ^= v[2]; \
+ v[0] += v[3]; \
+ v[3] = ROTL(v[3], 21); \
+ v[3] ^= v[0]; \
+ v[2] += v[1]; \
+ v[1] = ROTL(v[1], 17); \
+ v[1] ^= v[2]; \
+ v[2] = ROTL(v[2], 32); \
+ } while (0)
+
+static void invalidate_siphash24(struct siphash24_ctx *ctx)
+{
+ ctx->bytes = -1ULL;
+}
+
+static void check_siphash24(struct siphash24_ctx *ctx)
+{
+ assert(ctx->bytes != -1ULL);
+}
+
+static bool alignment_ok(const void *p, size_t n)
+{
+#if HAVE_UNALIGNED_ACCESS
+ return true;
+#else
+ return ((size_t)p % n == 0);
+#endif
+}
+
+static void add_64bits(uint64_t v[4], uint64_t in)
+{
+ int i;
+ uint64_t m = cpu_to_le64(in);
+ v[3] ^= m;
+
+ for (i = 0; i < cROUNDS; ++i)
+ SIPROUND(v);
+
+ v[0] ^= m;
+}
+
+static void add(struct siphash24_ctx *ctx, const void *p, size_t len)
+{
+ const unsigned char *data = p;
+ size_t bufsize = ctx->bytes % sizeof(ctx->buf.u8);
+
+ if (bufsize + len >= sizeof(ctx->buf.u8)) {
+ // Fill the buffer, and process it.
+ memcpy(ctx->buf.u8 + bufsize, data,
+ sizeof(ctx->buf.u8) - bufsize);
+ ctx->bytes += sizeof(ctx->buf.u8) - bufsize;
+ data += sizeof(ctx->buf.u8) - bufsize;
+ len -= sizeof(ctx->buf.u8) - bufsize;
+ add_64bits(ctx->v, ctx->buf.u64);
+ bufsize = 0;
+ }
+
+ while (len >= sizeof(ctx->buf.u8)) {
+ // Process full chunks directly from the source.
+ if (alignment_ok(data, sizeof(uint64_t)))
+ add_64bits(ctx->v, *(const uint64_t *)data);
+ else {
+ memcpy(ctx->buf.u8, data, sizeof(ctx->buf));
+ add_64bits(ctx->v, ctx->buf.u64);
+ }
+ ctx->bytes += sizeof(ctx->buf.u8);
+ data += sizeof(ctx->buf.u8);
+ len -= sizeof(ctx->buf.u8);
+ }
+
+ if (len) {
+ // Fill the buffer with what remains.
+ memcpy(ctx->buf.u8 + bufsize, data, len);
+ ctx->bytes += len;
+ }
+}
+
+void siphash24_init(struct siphash24_ctx *ctx, const struct siphash_seed *seed)
+{
+ struct siphash24_ctx init = SIPHASH24_INIT(0, 0);
+ *ctx = init;
+ ctx->v[0] ^= seed->u.u64[0];
+ ctx->v[1] ^= seed->u.u64[1];
+ ctx->v[2] ^= seed->u.u64[0];
+ ctx->v[3] ^= seed->u.u64[1];
+}
+
+void siphash24_update(struct siphash24_ctx *ctx, const void *p, size_t size)
+{
+ check_siphash24(ctx);
+ add(ctx, p, size);
+}
+
+uint64_t siphash24_done(struct siphash24_ctx *ctx)
+{
+ uint64_t b;
+ int i;
+
+ b = ctx->bytes << 56;
+
+ switch (ctx->bytes % 8) {
+ case 7:
+ b |= ((uint64_t)ctx->buf.u8[6]) << 48;
+ case 6:
+ b |= ((uint64_t)ctx->buf.u8[5]) << 40;
+ case 5:
+ b |= ((uint64_t)ctx->buf.u8[4]) << 32;
+ case 4:
+ b |= ((uint64_t)ctx->buf.u8[3]) << 24;
+ case 3:
+ b |= ((uint64_t)ctx->buf.u8[2]) << 16;
+ case 2:
+ b |= ((uint64_t)ctx->buf.u8[1]) << 8;
+ case 1:
+ b |= ((uint64_t)ctx->buf.u8[0]);
+ break;
+ case 0:
+ break;
+ }
+
+ ctx->v[3] ^= b;
+
+ for (i = 0; i < cROUNDS; ++i)
+ SIPROUND(ctx->v);
+
+ ctx->v[0] ^= b;
+
+ ctx->v[2] ^= 0xff;
+
+ for (i = 0; i < dROUNDS; ++i)
+ SIPROUND(ctx->v);
+
+ b = ctx->v[0] ^ ctx->v[1] ^ ctx->v[2] ^ ctx->v[3];
+
+ invalidate_siphash24(ctx);
+ return cpu_to_le64(b);
+}
+
+uint64_t siphash24(const struct siphash_seed *seed, const void *p, size_t size)
+{
+ struct siphash24_ctx ctx;
+
+ siphash24_init(&ctx, seed);
+ siphash24_update(&ctx, p, size);
+ return siphash24_done(&ctx);
+}
+
+void siphash24_u8(struct siphash24_ctx *ctx, uint8_t v)
+{
+ siphash24_update(ctx, &v, sizeof(v));
+}
+
+void siphash24_u16(struct siphash24_ctx *ctx, uint16_t v)
+{
+ siphash24_update(ctx, &v, sizeof(v));
+}
+
+void siphash24_u32(struct siphash24_ctx *ctx, uint32_t v)
+{
+ siphash24_update(ctx, &v, sizeof(v));
+}
+
+void siphash24_u64(struct siphash24_ctx *ctx, uint64_t v)
+{
+ siphash24_update(ctx, &v, sizeof(v));
+}
+
+/* Add as little-endian */
+void siphash24_le16(struct siphash24_ctx *ctx, uint16_t v)
+{
+ leint16_t lev = cpu_to_le16(v);
+ siphash24_update(ctx, &lev, sizeof(lev));
+}
+
+void siphash24_le32(struct siphash24_ctx *ctx, uint32_t v)
+{
+ leint32_t lev = cpu_to_le32(v);
+ siphash24_update(ctx, &lev, sizeof(lev));
+}
+
+void siphash24_le64(struct siphash24_ctx *ctx, uint64_t v)
+{
+ leint64_t lev = cpu_to_le64(v);
+ siphash24_update(ctx, &lev, sizeof(lev));
+}
+
+/* Add as big-endian */
+void siphash24_be16(struct siphash24_ctx *ctx, uint16_t v)
+{
+ beint16_t bev = cpu_to_be16(v);
+ siphash24_update(ctx, &bev, sizeof(bev));
+}
+
+void siphash24_be32(struct siphash24_ctx *ctx, uint32_t v)
+{
+ beint32_t bev = cpu_to_be32(v);
+ siphash24_update(ctx, &bev, sizeof(bev));
+}
+
+void siphash24_be64(struct siphash24_ctx *ctx, uint64_t v)
+{
+ beint64_t bev = cpu_to_be64(v);
+ siphash24_update(ctx, &bev, sizeof(bev));
+}
projects / ccan / blobdiff