Get the basic random number generator functions to compile
[akaros.git] / kern / lib / random / sha2.c
1 /*      $OpenBSD: sha2.c,v 1.6 2004/05/03 02:57:36 millert Exp $        */
2
3 /*
4  * FILE:        sha2.c
5  * AUTHOR:      Aaron D. Gifford <me@aarongifford.com>
6  *
7  * Copyright (c) 2000-2001, Aaron D. Gifford
8  * All rights reserved.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *        notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *        notice, this list of conditions and the following disclaimer in the
17  *        documentation and/or other materials provided with the distribution.
18  * 3. Neither the name of the copyright holder nor the names of contributors
19  *        may be used to endorse or promote products derived from this software
20  *        without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED.      IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  *
34  * $From: sha2.c,v 1.1 2001/11/08 00:01:51 adg Exp adg $
35  *
36  * contrib/pgcrypto/sha2.c
37  */
38
39 #include <random/sha2.h>
40
41 /*** SHA-256/512 Various Length Definitions ***********************/
42 enum {
43         SHA256ShortBlockLength = (SHA256BlockLength - 8),
44         SHA512ShortBlockLength = (SHA512_block_length - 16)
45 };
46
47 /*
48  * Macro for incrementally adding the unsigned 64-bit integer n to the
49  * unsigned 128-bit integer (represented using a two-element array of
50  * 64-bit words):
51  */
52 #define ADDINC128(w, n)                                                        \
53         {                                                                          \
54                 (w)[0] += (uint64_t)(n);                                               \
55                 if ((w)[0] < (n)) {                                                    \
56                         (w)[1]++;                                                          \
57                 }                                                                      \
58         }
59
60 /*** THE SIX LOGICAL FUNCTIONS ****************************************/
61 /*
62  * Bit shifting and rotation (used by the six SHA-XYZ logical functions:
63  *
64  *   NOTE:  The naming of R and S appears backwards here (R is a SHIFT and
65  *   S is a ROTATION) because the SHA-256/384/512 description document
66  *   (see http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf) uses this
67  *   same "backwards" definition.
68  */
69 /* Shift-right (used in SHA-256, SHA-384, and SHA-512): */
70 #define R(b, x) ((x) >> (b))
71 /* 32-bit Rotate-right (used in SHA-256): */
72 #define S32(b, x) (((x) >> (b)) | ((x) << (32 - (b))))
73 /* 64-bit Rotate-right (used in SHA-384 and SHA-512): */
74 #define S64(b, x) (((x) >> (b)) | ((x) << (64 - (b))))
75
76 /* Two of six logical functions used in SHA-256, SHA-384, and SHA-512: */
77 #define Ch(x, y, z) (((x) & (y)) ^ ((~(x)) & (z)))
78 #define Maj(x, y, z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
79
80 /* Four of six logical functions used in SHA-256: */
81 #define Sigma0_256(x) (S32(2, (x)) ^ S32(13, (x)) ^ S32(22, (x)))
82 #define Sigma1_256(x) (S32(6, (x)) ^ S32(11, (x)) ^ S32(25, (x)))
83 #define sigma0_256(x) (S32(7, (x)) ^ S32(18, (x)) ^ R(3, (x)))
84 #define sigma1_256(x) (S32(17, (x)) ^ S32(19, (x)) ^ R(10, (x)))
85
86 /* Four of six logical functions used in SHA-384 and SHA-512: */
87 #define Sigma0_512(x) (S64(28, (x)) ^ S64(34, (x)) ^ S64(39, (x)))
88 #define Sigma1_512(x) (S64(14, (x)) ^ S64(18, (x)) ^ S64(41, (x)))
89 #define sigma0_512(x) (S64(1, (x)) ^ S64(8, (x)) ^ R(7, (x)))
90 #define sigma1_512(x) (S64(19, (x)) ^ S64(61, (x)) ^ R(6, (x)))
91
92 /*** INTERNAL FUNCTION PROTOTYPES *************************************/
93 /* NOTE: These should not be accessed directly from outside this
94  * library -- they are intended for private internal visibility/use
95  * only.
96  */
97 static void SHA512_Last(SHA512Ctx *);
98 static void SHA256_Transform(SHA256Ctx *, const uint32_t *);
99 static void SHA512_Transform(SHA512Ctx *, const uint64_t *);
100
101 /*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/
102 /* Hash constant words K for SHA-256: */
103 const uint32_t K256[64] = {
104         0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL, 0x3956c25bUL,
105         0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL, 0xd807aa98UL, 0x12835b01UL,
106         0x243185beUL, 0x550c7dc3UL, 0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL,
107         0xc19bf174UL, 0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL,
108         0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL, 0x983e5152UL,
109         0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL, 0xc6e00bf3UL, 0xd5a79147UL,
110         0x06ca6351UL, 0x14292967UL, 0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL,
111         0x53380d13UL, 0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL,
112         0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL, 0xd192e819UL,
113         0xd6990624UL, 0xf40e3585UL, 0x106aa070UL, 0x19a4c116UL, 0x1e376c08UL,
114         0x2748774cUL, 0x34b0bcb5UL, 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL,
115         0x682e6ff3UL, 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
116         0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL};
117
118 /* Initial hash value H for SHA-224: */
119 const uint32_t sha224_initial_hash_value[8] = {
120         0xc1059ed8UL, 0x367cd507UL, 0x3070dd17UL, 0xf70e5939UL,
121         0xffc00b31UL, 0x68581511UL, 0x64f98fa7UL, 0xbefa4fa4UL};
122
123 /* Initial hash value H for SHA-256: */
124 static const uint32_t sha256_initial_hash_value[8] = {
125         0x6a09e667UL, 0xbb67ae85UL, 0x3c6ef372UL, 0xa54ff53aUL,
126         0x510e527fUL, 0x9b05688cUL, 0x1f83d9abUL, 0x5be0cd19UL};
127
128 /* Hash constant words K for SHA-384 and SHA-512: */
129 static const uint64_t K512[80] = {
130         0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL, 0xb5c0fbcfec4d3b2fULL,
131         0xe9b5dba58189dbbcULL, 0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL,
132         0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL, 0xd807aa98a3030242ULL,
133         0x12835b0145706fbeULL, 0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL,
134         0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL, 0x9bdc06a725c71235ULL,
135         0xc19bf174cf692694ULL, 0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL,
136         0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL, 0x2de92c6f592b0275ULL,
137         0x4a7484aa6ea6e483ULL, 0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL,
138         0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL, 0xb00327c898fb213fULL,
139         0xbf597fc7beef0ee4ULL, 0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL,
140         0x06ca6351e003826fULL, 0x142929670a0e6e70ULL, 0x27b70a8546d22ffcULL,
141         0x2e1b21385c26c926ULL, 0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL,
142         0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL, 0x81c2c92e47edaee6ULL,
143         0x92722c851482353bULL, 0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL,
144         0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL, 0xd192e819d6ef5218ULL,
145         0xd69906245565a910ULL, 0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL,
146         0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL, 0x2748774cdf8eeb99ULL,
147         0x34b0bcb5e19b48a8ULL, 0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL,
148         0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL, 0x748f82ee5defb2fcULL,
149         0x78a5636f43172f60ULL, 0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL,
150         0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL, 0xbef9a3f7b2c67915ULL,
151         0xc67178f2e372532bULL, 0xca273eceea26619cULL, 0xd186b8c721c0c207ULL,
152         0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL, 0x06f067aa72176fbaULL,
153         0x0a637dc5a2c898a6ULL, 0x113f9804bef90daeULL, 0x1b710b35131c471bULL,
154         0x28db77f523047d84ULL, 0x32caab7b40c72493ULL, 0x3c9ebe0a15c9bebcULL,
155         0x431d67c49c100d4cULL, 0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL,
156         0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL};
157
158 /* Initial hash value H for SHA-384 */
159 static const uint64_t sha384_initial_hash_value[8] = {
160         0xcbbb9d5dc1059ed8ULL, 0x629a292a367cd507ULL, 0x9159015a3070dd17ULL,
161         0x152fecd8f70e5939ULL, 0x67332667ffc00b31ULL, 0x8eb44a8768581511ULL,
162         0xdb0c2e0d64f98fa7ULL, 0x47b5481dbefa4fa4ULL};
163
164 /* Initial hash value H for SHA-512 */
165 static const uint64_t sha512_initial_hash_value[8] = {
166         0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL, 0x3c6ef372fe94f82bULL,
167         0xa54ff53a5f1d36f1ULL, 0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL,
168         0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL};
169
170 /*** SHA-256: *********************************************************/
171 void SHA256_Init(SHA256Ctx *context)
172 {
173         if (context == NULL)
174                 return;
175         memmove(context->state, sha256_initial_hash_value, SHA256DigestLength);
176         memset(context->buffer, 0, SHA256BlockLength);
177         context->bitcount = 0;
178 }
179 static void SHA256_Transform(SHA256Ctx *context, const uint32_t *data)
180 {
181         uint32_t a, b, c, d, e, f, g, h, s0, s1;
182         uint32_t T1, T2, *W256;
183         int j;
184
185         W256 = (uint32_t *)context->buffer;
186
187         /* Initialize registers with the prev. intermediate value */
188         a = context->state[0];
189         b = context->state[1];
190         c = context->state[2];
191         d = context->state[3];
192         e = context->state[4];
193         f = context->state[5];
194         g = context->state[6];
195         h = context->state[7];
196
197         j = 0;
198         do {
199                 W256[j] = (uint32_t)data[3] | ((uint32_t)data[2] << 8) |
200                                   ((uint32_t)data[1] << 16) | ((uint32_t)data[0] << 24);
201                 data += 4;
202                 /* Apply the SHA-256 compression function to update a..h */
203                 T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + W256[j];
204                 T2 = Sigma0_256(a) + Maj(a, b, c);
205                 h = g;
206                 g = f;
207                 f = e;
208                 e = d + T1;
209                 d = c;
210                 c = b;
211                 b = a;
212                 a = T1 + T2;
213
214                 j++;
215         } while (j < 16);
216
217         do {
218                 /* Part of the message block expansion: */
219                 s0 = W256[(j + 1) & 0x0f];
220                 s0 = sigma0_256(s0);
221                 s1 = W256[(j + 14) & 0x0f];
222                 s1 = sigma1_256(s1);
223
224                 /* Apply the SHA-256 compression function to update a..h */
225                 T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] +
226                          (W256[j & 0x0f] += s1 + W256[(j + 9) & 0x0f] + s0);
227                 T2 = Sigma0_256(a) + Maj(a, b, c);
228                 h = g;
229                 g = f;
230                 f = e;
231                 e = d + T1;
232                 d = c;
233                 c = b;
234                 b = a;
235                 a = T1 + T2;
236
237                 j++;
238         } while (j < 64);
239
240         /* Compute the current intermediate hash value */
241         context->state[0] += a;
242         context->state[1] += b;
243         context->state[2] += c;
244         context->state[3] += d;
245         context->state[4] += e;
246         context->state[5] += f;
247         context->state[6] += g;
248         context->state[7] += h;
249
250         /* Clean up */
251         a = b = c = d = e = f = g = h = T1 = T2 = 0;
252 }
253
254 void SHA256_Update(SHA256Ctx *context, const uint8_t *data, size_t len)
255 {
256         size_t freespace, usedspace;
257
258         /* Calling with no data is valid (we do nothing) */
259         if (len == 0)
260                 return;
261
262         usedspace = (context->bitcount >> 3) % SHA256BlockLength;
263         if (usedspace > 0) {
264                 /* Calculate how much free space is available in the buffer */
265                 freespace = SHA256BlockLength - usedspace;
266
267                 if (len >= freespace) {
268                         /* Fill the buffer completely and process it */
269                         memmove(&context->buffer[usedspace], data, freespace);
270                         context->bitcount += freespace << 3;
271                         len -= freespace;
272                         data += freespace;
273                         SHA256_Transform(context, (uint32_t *)context->buffer);
274                 } else {
275                         /* The buffer is not yet full */
276                         memmove(&context->buffer[usedspace], data, len);
277                         context->bitcount += len << 3;
278                         /* Clean up: */
279                         usedspace = freespace = 0;
280                         return;
281                 }
282         }
283         while (len >= SHA256BlockLength) {
284                 /* Process as many complete blocks as we can */
285                 SHA256_Transform(context, (const uint32_t *)data);
286                 context->bitcount += SHA256BlockLength << 3;
287                 len -= SHA256BlockLength;
288                 data += SHA256BlockLength;
289         }
290         if (len > 0) {
291                 /* There's left-overs, so save 'em */
292                 memmove(context->buffer, data, len);
293                 context->bitcount += len << 3;
294         }
295         /* Clean up: */
296         usedspace = freespace = 0;
297 }
298
299 static void SHA256_Last(SHA256Ctx *context)
300 {
301         unsigned int usedspace;
302
303         usedspace = (context->bitcount >> 3) % SHA256BlockLength;
304
305         if (usedspace > 0) {
306                 /* Begin padding with a 1 bit: */
307                 context->buffer[usedspace++] = 0x80;
308
309                 if (usedspace <= SHA256ShortBlockLength) {
310                         /* Set-up for the last transform: */
311                         memset(&context->buffer[usedspace], 0,
312                                    SHA256ShortBlockLength - usedspace);
313                 } else {
314                         if (usedspace < SHA256BlockLength) {
315                                 memset(&context->buffer[usedspace], 0,
316                                            SHA256BlockLength - usedspace);
317                         }
318                         /* Do second-to-last transform: */
319                         SHA256_Transform(context, (uint32_t *)context->buffer);
320
321                         /* And set-up for the last transform: */
322                         memset(context->buffer, 0, SHA256ShortBlockLength);
323                 }
324         } else {
325                 /* Set-up for the last transform: */
326                 memset(context->buffer, 0, SHA256ShortBlockLength);
327
328                 /* Begin padding with a 1 bit: */
329                 *context->buffer = 0x80;
330         }
331         /* Set the bit count: */
332         *(uint64_t *)&context->buffer[SHA256ShortBlockLength] = context->bitcount;
333
334         /* Final transform: */
335         SHA256_Transform(context, (uint32_t *)context->buffer);
336 }
337
338 void SHA256_Final(uint8_t digest[], SHA256Ctx *context)
339 {
340         /* If no digest buffer is passed, we don't bother doing this: */
341         if (digest != NULL) {
342                 SHA256_Last(context);
343
344                 memmove(digest, context->state, SHA256DigestLength);
345         }
346
347         /* Clean up state data: */
348         memset(context, 0, sizeof(*context));
349 }
350
351 /*** SHA-512: *********************************************************/
352 void SHA512_Init(SHA512Ctx *context)
353 {
354         if (context == NULL)
355                 return;
356         memmove(context->state, sha512_initial_hash_value, SHA512DigestLength);
357         memset(context->buffer, 0, SHA512_block_length);
358         context->bitcount[0] = context->bitcount[1] = 0;
359 }
360
361 static void SHA512_Transform(SHA512Ctx *context, const uint64_t *data)
362 {
363         uint64_t a, b, c, d, e, f, g, h, s0, s1;
364         uint64_t T1, T2, *W512 = (uint64_t *)context->buffer;
365         int j;
366
367         /* Initialize registers with the prev. intermediate value */
368         a = context->state[0];
369         b = context->state[1];
370         c = context->state[2];
371         d = context->state[3];
372         e = context->state[4];
373         f = context->state[5];
374         g = context->state[6];
375         h = context->state[7];
376
377         j = 0;
378         do {
379                 W512[j] = (uint64_t)data[7] | ((uint64_t)data[6] << 8) |
380                                   ((uint64_t)data[5] << 16) | ((uint64_t)data[4] << 24) |
381                                   ((uint64_t)data[3] << 32) | ((uint64_t)data[2] << 40) |
382                                   ((uint64_t)data[1] << 48) | ((uint64_t)data[0] << 56);
383                 data += 8;
384                 /* Apply the SHA-512 compression function to update a..h */
385                 T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + W512[j];
386                 T2 = Sigma0_512(a) + Maj(a, b, c);
387                 h = g;
388                 g = f;
389                 f = e;
390                 e = d + T1;
391                 d = c;
392                 c = b;
393                 b = a;
394                 a = T1 + T2;
395
396                 j++;
397         } while (j < 16);
398
399         do {
400                 /* Part of the message block expansion: */
401                 s0 = W512[(j + 1) & 0x0f];
402                 s0 = sigma0_512(s0);
403                 s1 = W512[(j + 14) & 0x0f];
404                 s1 = sigma1_512(s1);
405
406                 /* Apply the SHA-512 compression function to update a..h */
407                 T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] +
408                          (W512[j & 0x0f] += s1 + W512[(j + 9) & 0x0f] + s0);
409                 T2 = Sigma0_512(a) + Maj(a, b, c);
410                 h = g;
411                 g = f;
412                 f = e;
413                 e = d + T1;
414                 d = c;
415                 c = b;
416                 b = a;
417                 a = T1 + T2;
418
419                 j++;
420         } while (j < 80);
421
422         /* Compute the current intermediate hash value */
423         context->state[0] += a;
424         context->state[1] += b;
425         context->state[2] += c;
426         context->state[3] += d;
427         context->state[4] += e;
428         context->state[5] += f;
429         context->state[6] += g;
430         context->state[7] += h;
431
432         /* Clean up */
433         a = b = c = d = e = f = g = h = T1 = T2 = 0;
434 }
435
436 void SHA512_Update(SHA512Ctx *context, const uint8_t *data, size_t len)
437 {
438         size_t freespace, usedspace;
439
440         /* Calling with no data is valid (we do nothing) */
441         if (len == 0)
442                 return;
443
444         usedspace = (context->bitcount[0] >> 3) % SHA512_block_length;
445         if (usedspace > 0) {
446                 /* Calculate how much free space is available in the buffer */
447                 freespace = SHA512_block_length - usedspace;
448
449                 if (len >= freespace) {
450                         /* Fill the buffer completely and process it */
451                         memmove(&context->buffer[usedspace], data, freespace);
452                         ADDINC128(context->bitcount, freespace << 3);
453                         len -= freespace;
454                         data += freespace;
455                         SHA512_Transform(context, (uint64_t *)context->buffer);
456                 } else {
457                         /* The buffer is not yet full */
458                         memmove(&context->buffer[usedspace], data, len);
459                         ADDINC128(context->bitcount, len << 3);
460                         /* Clean up: */
461                         usedspace = freespace = 0;
462                         return;
463                 }
464         }
465         while (len >= SHA512_block_length) {
466                 /* Process as many complete blocks as we can */
467                 SHA512_Transform(context, (const uint64_t *)data);
468                 ADDINC128(context->bitcount, SHA512_block_length << 3);
469                 len -= SHA512_block_length;
470                 data += SHA512_block_length;
471         }
472         if (len > 0) {
473                 /* There's left-overs, so save 'em */
474                 memmove(context->buffer, data, len);
475                 ADDINC128(context->bitcount, len << 3);
476         }
477         /* Clean up: */
478         usedspace = freespace = 0;
479 }
480
481 static void SHA512_Last(SHA512Ctx *context)
482 {
483         unsigned int usedspace;
484
485         usedspace = (context->bitcount[0] >> 3) % SHA512_block_length;
486
487         if (usedspace > 0) {
488                 /* Begin padding with a 1 bit: */
489                 context->buffer[usedspace++] = 0x80;
490
491                 if (usedspace <= SHA512ShortBlockLength) {
492                         /* Set-up for the last transform: */
493                         memset(&context->buffer[usedspace], 0,
494                                    SHA512ShortBlockLength - usedspace);
495                 } else {
496                         if (usedspace < SHA512_block_length) {
497                                 memset(&context->buffer[usedspace], 0,
498                                            SHA512_block_length - usedspace);
499                         }
500                         /* Do second-to-last transform: */
501                         SHA512_Transform(context, (uint64_t *)context->buffer);
502
503                         /* And set-up for the last transform: */
504                         memset(context->buffer, 0, SHA512_block_length - 2);
505                 }
506         } else {
507                 /* Prepare for final transform: */
508                 memset(context->buffer, 0, SHA512ShortBlockLength);
509
510                 /* Begin padding with a 1 bit: */
511                 *context->buffer = 0x80;
512         }
513         /* Store the length of input data (in bits): */
514         *(uint64_t *)&context->buffer[SHA512ShortBlockLength] =
515                 context->bitcount[1];
516         *(uint64_t *)&context->buffer[SHA512ShortBlockLength + 8] =
517                 context->bitcount[0];
518
519         /* Final transform: */
520         SHA512_Transform(context, (uint64_t *)context->buffer);
521 }
522
523 void SHA512_Final(uint8_t digest[], SHA512Ctx *context)
524 {
525         /* If no digest buffer is passed, we don't bother doing this: */
526         if (digest != NULL) {
527                 SHA512_Last(context);
528
529                 /* Save the hash data for output: */
530                 memmove(digest, context->state, SHA512DigestLength);
531         }
532
533         /* Zero out state data */
534         memset(context, 0, sizeof(*context));
535 }
536
537 /*** SHA-384: *********************************************************/
538 void SHA384_Init(SHA384Ctx *context)
539 {
540         if (context == NULL)
541                 return;
542         memmove(context->state, sha384_initial_hash_value, SHA512DigestLength);
543         memset(context->buffer, 0, SHA384BlockLength);
544         context->bitcount[0] = context->bitcount[1] = 0;
545 }
546
547 void SHA384_Update(SHA384Ctx *context, const uint8_t *data, size_t len)
548 {
549         SHA512_Update((SHA512Ctx *)context, data, len);
550 }
551
552 void SHA384_Final(uint8_t digest[], SHA384Ctx *context)
553 {
554         /* If no digest buffer is passed, we don't bother doing this: */
555         if (digest != NULL) {
556                 SHA512_Last((SHA512Ctx *)context);
557
558                 /* Save the hash data for output: */
559                 memmove(digest, context->state, SHA384DigestLength);
560         }
561
562         /* Zero out state data */
563         memset(context, 0, sizeof(*context));
564 }
565
566 /*** SHA-224: *********************************************************/
567 void SHA224_Init(SHA224Ctx *context)
568 {
569         if (context == NULL)
570                 return;
571         memmove(context->state, sha224_initial_hash_value, SHA256DigestLength);
572         memset(context->buffer, 0, SHA256BlockLength);
573         context->bitcount = 0;
574 }
575
576 void SHA224_Update(SHA224Ctx *context, const uint8_t *data, size_t len)
577 {
578         SHA256_Update((SHA256Ctx *)context, data, len);
579 }
580
581 void SHA224_Final(uint8_t digest[], SHA224Ctx *context)
582 {
583         /* If no digest buffer is passed, we don't bother doing this: */
584         if (digest != NULL) {
585                 SHA256_Last(context);
586
587                 memmove(digest, context->state, SHA224DigestLength);
588         }
589
590         /* Clean up state data: */
591         memset(context, 0, sizeof(*context));
592 }