Simple documentation fix.
[BearSSL] / src / mac / hmac_ct.c
1 /*
2 * Copyright (c) 2016 Thomas Pornin <pornin@bolet.org>
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining
5 * a copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sublicense, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be
13 * included in all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
19 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
20 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
21 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24
25 #include "inner.h"
26
27 static inline size_t
28 hash_size(const br_hash_class *dig)
29 {
30 return (unsigned)(dig->desc >> BR_HASHDESC_OUT_OFF)
31 & BR_HASHDESC_OUT_MASK;
32 }
33
34 static inline size_t
35 block_size(const br_hash_class *dig)
36 {
37 unsigned ls;
38
39 ls = (unsigned)(dig->desc >> BR_HASHDESC_LBLEN_OFF)
40 & BR_HASHDESC_LBLEN_MASK;
41 return (size_t)1 << ls;
42 }
43
44 /* see bearssl.h */
45 size_t
46 br_hmac_outCT(const br_hmac_context *ctx,
47 const void *data, size_t len, size_t min_len, size_t max_len,
48 void *out)
49 {
50 /*
51 * Method implemented here is inspired from the descriptions on:
52 * https://www.imperialviolet.org/2013/02/04/luckythirteen.html
53 *
54 * Principle: we input bytes one by one. We use a MUX to push
55 * padding bytes instead of data bytes when appropriate. At each
56 * block limit, we get the current hash function state: this is
57 * a potential output, since we handle MD padding ourselves.
58 *
59 * be 1 for big-endian, 0 for little-endian
60 * po minimal MD padding length
61 * bs block size (always a power of 2)
62 * hlen hash output size
63 */
64
65 const br_hash_class *dig;
66 br_hash_compat_context hc;
67 int be;
68 uint32_t po, bs;
69 uint32_t kr, km, kl, kz, u;
70 uint64_t count, ncount, bit_len;
71 unsigned char tmp1[64], tmp2[64];
72 size_t hlen;
73
74 /*
75 * Copy the current hash context.
76 */
77 hc = ctx->dig;
78
79 /*
80 * Get function-specific information.
81 */
82 dig = hc.vtable;
83 be = (dig->desc & BR_HASHDESC_MD_PADDING_BE) != 0;
84 po = 9;
85 if (dig->desc & BR_HASHDESC_MD_PADDING_128) {
86 po += 8;
87 }
88 bs = block_size(dig);
89 hlen = hash_size(dig);
90
91 /*
92 * Get current input length and compute total bit length.
93 */
94 count = dig->state(&hc.vtable, tmp1);
95 bit_len = (count + (uint64_t)len) << 3;
96
97 /*
98 * We can input the blocks that we are sure we will use.
99 * This offers better performance (no MUX for these blocks)
100 * and also ensures that the remaining lengths fit on 32 bits.
101 */
102 ncount = (count + (uint64_t)min_len) & ~(uint64_t)(bs - 1);
103 if (ncount > count) {
104 size_t zlen;
105
106 zlen = (size_t)(ncount - count);
107 dig->update(&hc.vtable, data, zlen);
108 data = (const unsigned char *)data + zlen;
109 len -= zlen;
110 max_len -= zlen;
111 count = ncount;
112 }
113
114 /*
115 * At that point:
116 * -- 'count' contains the number of bytes already processed
117 * (in total).
118 * -- We must input 'len' bytes. 'min_len' is unimportant: we
119 * used it to know how many full blocks we could process
120 * directly. Now only len and max_len matter.
121 *
122 * We compute kr, kl, kz and km.
123 * kr number of input bytes already in the current block
124 * km index of the first byte after the end of the last padding
125 * block, if length is max_len
126 * kz index of the last byte of the actual last padding block
127 * kl index of the start of the encoded length
128 *
129 * km, kz and kl are counted from the current offset in the
130 * input data.
131 */
132 kr = (uint32_t)count & (bs - 1);
133 kz = ((kr + (uint32_t)len + po + bs - 1) & ~(bs - 1)) - 1 - kr;
134 kl = kz - 7;
135 km = ((kr + (uint32_t)max_len + po + bs - 1) & ~(bs - 1)) - kr;
136
137 /*
138 * We must now process km bytes. For index u from 0 to km-1:
139 * d is from data[] if u < max_len, 0x00 otherwise
140 * e is an encoded length byte or 0x00, depending on u
141 * The tests for d and e need not be constant-time, since
142 * they relate only to u and max_len, not to the actual length.
143 *
144 * Actual input length is then:
145 * d if u < len
146 * 0x80 if u == len
147 * 0x00 if u > len and u < kl
148 * e if u >= kl
149 *
150 * Hash state is obtained whenever we reach a full block. This
151 * is the result we want if and only if u == kz.
152 */
153 memset(tmp2, 0, sizeof tmp2);
154 for (u = 0; u < km; u ++) {
155 uint32_t v;
156 uint32_t d, e, x0, x1;
157 unsigned char x[1];
158
159 d = (u < max_len) ? ((const unsigned char *)data)[u] : 0x00;
160 v = (kr + u) & (bs - 1);
161 if (v >= (bs - 8)) {
162 unsigned j;
163
164 j = (v - (bs - 8)) << 3;
165 if (be) {
166 e = (uint32_t)(bit_len >> (56 - j));
167 } else {
168 e = (uint32_t)(bit_len >> j);
169 }
170 e &= 0xFF;
171 } else {
172 e = 0x00;
173 }
174 x0 = MUX(EQ(u, (uint32_t)len), 0x80, d);
175 x1 = MUX(LT(u, kl), 0x00, e);
176 x[0] = MUX(LE(u, (uint32_t)len), x0, x1);
177 dig->update(&hc.vtable, x, 1);
178 if (v == (bs - 1)) {
179 dig->state(&hc.vtable, tmp1);
180 CCOPY(EQ(u, kz), tmp2, tmp1, hlen);
181 }
182 }
183
184 /*
185 * Inner hash output is in tmp2[]; we finish processing.
186 */
187 dig->init(&hc.vtable);
188 dig->set_state(&hc.vtable, ctx->kso, (uint64_t)bs);
189 dig->update(&hc.vtable, tmp2, hlen);
190 dig->out(&hc.vtable, tmp2);
191 memcpy(out, tmp2, ctx->out_len);
192 return ctx->out_len;
193 }