TESTS: add SipHash tests with digestsize controls
[openssl.git] / crypto / siphash / siphash.c
1 /*
2  * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 /* Based on https://131002.net/siphash C reference implementation */
11 /*
12    SipHash reference C implementation
13
14    Copyright (c) 2012-2016 Jean-Philippe Aumasson
15    Copyright (c) 2012-2014 Daniel J. Bernstein
16
17    To the extent possible under law, the author(s) have dedicated all copyright
18    and related and neighboring rights to this software to the public domain
19    worldwide. This software is distributed without any warranty.
20
21    You should have received a copy of the CC0 Public Domain Dedication along
22    with this software. If not, see
23    <http://creativecommons.org/publicdomain/zero/1.0/>.
24  */
25
26 #include <stdlib.h>
27 #include <string.h>
28 #include <openssl/crypto.h>
29
30 #include "internal/siphash.h"
31 #include "siphash_local.h"
32
33 /* default: SipHash-2-4 */
34 #define SIPHASH_C_ROUNDS 2
35 #define SIPHASH_D_ROUNDS 4
36
37 #define ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
38
39 #define U32TO8_LE(p, v)                                                        \
40     (p)[0] = (uint8_t)((v));                                                   \
41     (p)[1] = (uint8_t)((v) >> 8);                                              \
42     (p)[2] = (uint8_t)((v) >> 16);                                             \
43     (p)[3] = (uint8_t)((v) >> 24);
44
45 #define U64TO8_LE(p, v)                                                        \
46     U32TO8_LE((p), (uint32_t)((v)));                                           \
47     U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
48
49 #define U8TO64_LE(p)                                                           \
50     (((uint64_t)((p)[0])) | ((uint64_t)((p)[1]) << 8) |                        \
51      ((uint64_t)((p)[2]) << 16) | ((uint64_t)((p)[3]) << 24) |                 \
52      ((uint64_t)((p)[4]) << 32) | ((uint64_t)((p)[5]) << 40) |                 \
53      ((uint64_t)((p)[6]) << 48) | ((uint64_t)((p)[7]) << 56))
54
55 #define SIPROUND                                                               \
56     do {                                                                       \
57         v0 += v1;                                                              \
58         v1 = ROTL(v1, 13);                                                     \
59         v1 ^= v0;                                                              \
60         v0 = ROTL(v0, 32);                                                     \
61         v2 += v3;                                                              \
62         v3 = ROTL(v3, 16);                                                     \
63         v3 ^= v2;                                                              \
64         v0 += v3;                                                              \
65         v3 = ROTL(v3, 21);                                                     \
66         v3 ^= v0;                                                              \
67         v2 += v1;                                                              \
68         v1 = ROTL(v1, 17);                                                     \
69         v1 ^= v2;                                                              \
70         v2 = ROTL(v2, 32);                                                     \
71     } while (0)
72
73 size_t SipHash_ctx_size(void)
74 {
75     return sizeof(SIPHASH);
76 }
77
78 size_t SipHash_hash_size(SIPHASH *ctx)
79 {
80     return ctx->hash_size;
81 }
82
83 /* hash_size = crounds = drounds = 0 means SipHash24 with 16-byte output */
84 int SipHash_Init(SIPHASH *ctx, const unsigned char *k, int hash_size, int crounds, int drounds)
85 {
86     uint64_t k0 = U8TO64_LE(k);
87     uint64_t k1 = U8TO64_LE(k + 8);
88
89     if (hash_size == 0)
90         hash_size = SIPHASH_MAX_DIGEST_SIZE;
91     else if (hash_size != SIPHASH_MIN_DIGEST_SIZE &&
92              hash_size != SIPHASH_MAX_DIGEST_SIZE)
93         return 0;
94
95     if (drounds == 0)
96         drounds = SIPHASH_D_ROUNDS;
97     if (crounds == 0)
98         crounds = SIPHASH_C_ROUNDS;
99
100     ctx->crounds = crounds;
101     ctx->drounds = drounds;
102     ctx->hash_size = hash_size;
103
104     ctx->len = 0;
105     ctx->total_inlen = 0;
106
107     ctx->v0 = 0x736f6d6570736575ULL ^ k0;
108     ctx->v1 = 0x646f72616e646f6dULL ^ k1;
109     ctx->v2 = 0x6c7967656e657261ULL ^ k0;
110     ctx->v3 = 0x7465646279746573ULL ^ k1;
111
112     if (ctx->hash_size == SIPHASH_MAX_DIGEST_SIZE)
113         ctx->v1 ^= 0xee;
114
115     return 1;
116 }
117
118 void SipHash_Update(SIPHASH *ctx, const unsigned char *in, size_t inlen)
119 {
120     uint64_t m;
121     const uint8_t *end;
122     int left;
123     int i;
124     uint64_t v0 = ctx->v0;
125     uint64_t v1 = ctx->v1;
126     uint64_t v2 = ctx->v2;
127     uint64_t v3 = ctx->v3;
128
129     ctx->total_inlen += inlen;
130
131     if (ctx->len) {
132         /* deal with leavings */
133         size_t available = SIPHASH_BLOCK_SIZE - ctx->len;
134
135         /* not enough to fill leavings */
136         if (inlen < available) {
137             memcpy(&ctx->leavings[ctx->len], in, inlen);
138             ctx->len += inlen;
139             return;
140         }
141
142         /* copy data into leavings and reduce input */
143         memcpy(&ctx->leavings[ctx->len], in, available);
144         inlen -= available;
145         in += available;
146
147         /* process leavings */
148         m = U8TO64_LE(ctx->leavings);
149         v3 ^= m;
150         for (i = 0; i < ctx->crounds; ++i)
151             SIPROUND;
152         v0 ^= m;
153     }
154     left = inlen & (SIPHASH_BLOCK_SIZE-1); /* gets put into leavings */
155     end = in + inlen - left;
156
157     for (; in != end; in += 8) {
158         m = U8TO64_LE(in);
159         v3 ^= m;
160         for (i = 0; i < ctx->crounds; ++i)
161             SIPROUND;
162         v0 ^= m;
163     }
164
165     /* save leavings and other ctx */
166     if (left)
167         memcpy(ctx->leavings, end, left);
168     ctx->len = left;
169
170     ctx->v0 = v0;
171     ctx->v1 = v1;
172     ctx->v2 = v2;
173     ctx->v3 = v3;
174 }
175
176 int SipHash_Final(SIPHASH *ctx, unsigned char *out, size_t outlen)
177 {
178     /* finalize hash */
179     int i;
180     uint64_t b = ctx->total_inlen << 56;
181     uint64_t v0 = ctx->v0;
182     uint64_t v1 = ctx->v1;
183     uint64_t v2 = ctx->v2;
184     uint64_t v3 = ctx->v3;
185
186     if (outlen != (size_t)ctx->hash_size)
187         return 0;
188
189     switch (ctx->len) {
190     case 7:
191         b |= ((uint64_t)ctx->leavings[6]) << 48;
192         /* fall thru */
193     case 6:
194         b |= ((uint64_t)ctx->leavings[5]) << 40;
195         /* fall thru */
196     case 5:
197         b |= ((uint64_t)ctx->leavings[4]) << 32;
198         /* fall thru */
199     case 4:
200         b |= ((uint64_t)ctx->leavings[3]) << 24;
201         /* fall thru */
202     case 3:
203         b |= ((uint64_t)ctx->leavings[2]) << 16;
204         /* fall thru */
205     case 2:
206         b |= ((uint64_t)ctx->leavings[1]) <<  8;
207         /* fall thru */
208     case 1:
209         b |= ((uint64_t)ctx->leavings[0]);
210     case 0:
211         break;
212     }
213
214     v3 ^= b;
215     for (i = 0; i < ctx->crounds; ++i)
216         SIPROUND;
217     v0 ^= b;
218     if (ctx->hash_size == SIPHASH_MAX_DIGEST_SIZE)
219         v2 ^= 0xee;
220     else
221         v2 ^= 0xff;
222     for (i = 0; i < ctx->drounds; ++i)
223         SIPROUND;
224     b = v0 ^ v1 ^ v2  ^ v3;
225     U64TO8_LE(out, b);
226     if (ctx->hash_size == SIPHASH_MIN_DIGEST_SIZE)
227         return 1;
228     v1 ^= 0xdd;
229     for (i = 0; i < ctx->drounds; ++i)
230         SIPROUND;
231     b = v0 ^ v1 ^ v2  ^ v3;
232     U64TO8_LE(out + 8, b);
233     return 1;
234 }