Branch data Line data Source code
1 : : /*
2 : : *****************************************************************************
3 : : *
4 : : * File: sha2.c
5 : : *
6 : : * Purpose: An implementation of the SHA 26/384/512 digests.
7 : : *
8 : : * AUTHOR: Aaron D. Gifford - http://www.aarongifford.com/
9 : : *
10 : : * Copyright (c) 2000-2001, Aaron D. Gifford
11 : : *
12 : : * All rights reserved.
13 : : *
14 : : * Redistribution and use in source and binary forms, with or without
15 : : * modification, are permitted provided that the following conditions
16 : : * are met:
17 : : * 1. Redistributions of source code must retain the above copyright
18 : : * notice, this list of conditions and the following disclaimer.
19 : : * 2. Redistributions in binary form must reproduce the above copyright
20 : : * notice, this list of conditions and the following disclaimer in the
21 : : * documentation and/or other materials provided with the distribution.
22 : : * 3. Neither the name of the copyright holder nor the names of contributors
23 : : * may be used to endorse or promote products derived from this software
24 : : * without specific prior written permission.
25 : : *
26 : : * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
27 : : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 : : * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
30 : : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 : : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 : : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 : : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 : : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 : : * SUCH DAMAGE.
37 : : *
38 : : *****************************************************************************
39 : : */
40 : : #include <string.h> /* memcpy()/memset() or bcopy()/bzero() */
41 : : #include <assert.h> /* assert() */
42 : : #include "sha2.h"
43 : :
44 : : #if HAVE_SYS_BYTEORDER_H
45 : : #include <sys/byteorder.h>
46 : : #endif
47 : :
48 : : /*
49 : : * ASSERT NOTE:
50 : : * Some sanity checking code is included using assert(). On my FreeBSD
51 : : * system, this additional code can be removed by compiling with NDEBUG
52 : : * defined. Check your own systems manpage on assert() to see how to
53 : : * compile WITHOUT the sanity checking code on your system.
54 : : *
55 : : * UNROLLED TRANSFORM LOOP NOTE:
56 : : * You can define SHA2_UNROLL_TRANSFORM to use the unrolled transform
57 : : * loop version for the hash transform rounds (defined using macros
58 : : * later in this file). Either define on the command line, for example:
59 : : *
60 : : * cc -DSHA2_UNROLL_TRANSFORM -o sha2 sha2.c sha2prog.c
61 : : *
62 : : * or define below:
63 : : *
64 : : * #define SHA2_UNROLL_TRANSFORM
65 : : *
66 : : */
67 : :
68 : :
69 : : /*** SHA-256/384/512 Machine Architecture Definitions *****************/
70 : : /*
71 : : * BYTE_ORDER NOTE:
72 : : *
73 : : * Please make sure that your system defines BYTE_ORDER. If your
74 : : * architecture is little-endian, make sure it also defines
75 : : * LITTLE_ENDIAN and that the two (BYTE_ORDER and LITTLE_ENDIAN) are
76 : : * equivilent.
77 : : *
78 : : * If your system does not define the above, then you can do so by
79 : : * hand like this:
80 : : *
81 : : * #define LITTLE_ENDIAN 1234
82 : : * #define BIG_ENDIAN 4321
83 : : *
84 : : * And for little-endian machines, add:
85 : : *
86 : : * #define BYTE_ORDER LITTLE_ENDIAN
87 : : *
88 : : * Or for big-endian machines:
89 : : *
90 : : * #define BYTE_ORDER BIG_ENDIAN
91 : : *
92 : : * The FreeBSD machine this was written on defines BYTE_ORDER
93 : : * appropriately by including <sys/types.h> (which in turn includes
94 : : * <machine/endian.h> where the appropriate definitions are actually
95 : : * made).
96 : : */
97 : :
98 : : #ifndef BYTE_ORDER
99 : : #ifdef WIN32
100 : : #define BYTE_ORDER BIG_ENDIAN
101 : : #elif defined(_BIG_ENDIAN)
102 : : #define BYTE_ORDER BIG_ENDIAN
103 : : #elif defined(_LITTLE_ENDIAN)
104 : : #define BYTE_ORDER LITTLE_ENDIAN
105 : : #endif
106 : : #endif
107 : :
108 : : #if !defined(BYTE_ORDER) || (BYTE_ORDER != LITTLE_ENDIAN && BYTE_ORDER != BIG_ENDIAN)
109 : : #error Define BYTE_ORDER to be equal to either LITTLE_ENDIAN or BIG_ENDIAN
110 : : #endif
111 : :
112 : : /*
113 : : * Define the followingsha2_* types to types of the correct length on
114 : : * the native archtecture. Most BSD systems and Linux define u_intXX_t
115 : : * types. Machines with very recent ANSI C headers, can use the
116 : : * uintXX_t definintions from inttypes.h by defining SHA2_USE_INTTYPES_H
117 : : * during compile or in the sha.h header file.
118 : : *
119 : : * Machines that support neither u_intXX_t nor inttypes.h's uintXX_t
120 : : * will need to define these three typedefs below (and the appropriate
121 : : * ones in sha.h too) by hand according to their system architecture.
122 : : *
123 : : * Thank you, Jun-ichiro itojun Hagino, for suggesting using u_intXX_t
124 : : * types and pointing out recent ANSI C support for uintXX_t in inttypes.h.
125 : : */
126 : : #ifdef SHA2_USE_INTTYPES_H
127 : :
128 : : typedef uint8_t sha2_byte; /* Exactly 1 byte */
129 : : typedef uint32_t sha2_word32; /* Exactly 4 bytes */
130 : : typedef uint64_t sha2_word64; /* Exactly 8 bytes */
131 : :
132 : : #else /* SHA2_USE_INTTYPES_H */
133 : :
134 : : typedef u_int8_t sha2_byte; /* Exactly 1 byte */
135 : : typedef u_int32_t sha2_word32; /* Exactly 4 bytes */
136 : : typedef u_int64_t sha2_word64; /* Exactly 8 bytes */
137 : :
138 : : #endif /* SHA2_USE_INTTYPES_H */
139 : :
140 : :
141 : : /*** SHA-256/384/512 Various Length Definitions ***********************/
142 : : /* NOTE: Most of these are in sha2.h */
143 : : #define SHA256_SHORT_BLOCK_LEN (SHA256_BLOCK_LEN - 8)
144 : : #define SHA384_SHORT_BLOCK_LEN (SHA384_BLOCK_LEN - 16)
145 : : #define SHA512_SHORT_BLOCK_LEN (SHA512_BLOCK_LEN - 16)
146 : :
147 : :
148 : : /*** ENDIAN REVERSAL MACROS *******************************************/
149 : : #if BYTE_ORDER == LITTLE_ENDIAN
150 : : #define REVERSE32(w,x) { \
151 : : sha2_word32 tmp = (w); \
152 : : tmp = (tmp >> 16) | (tmp << 16); \
153 : : (x) = ((tmp & 0xff00ff00UL) >> 8) | ((tmp & 0x00ff00ffUL) << 8); \
154 : : }
155 : : #define REVERSE64(w,x) { \
156 : : sha2_word64 tmp = (w); \
157 : : tmp = (tmp >> 32) | (tmp << 32); \
158 : : tmp = ((tmp & 0xff00ff00ff00ff00ULL) >> 8) | \
159 : : ((tmp & 0x00ff00ff00ff00ffULL) << 8); \
160 : : (x) = ((tmp & 0xffff0000ffff0000ULL) >> 16) | \
161 : : ((tmp & 0x0000ffff0000ffffULL) << 16); \
162 : : }
163 : : #endif /* BYTE_ORDER == LITTLE_ENDIAN */
164 : :
165 : : /*
166 : : * Macro for incrementally adding the unsigned 64-bit integer n to the
167 : : * unsigned 128-bit integer (represented using a two-element array of
168 : : * 64-bit words):
169 : : */
170 : : #define ADDINC128(w,n) { \
171 : : (w)[0] += (sha2_word64)(n); \
172 : : if ((w)[0] < (n)) { \
173 : : (w)[1]++; \
174 : : } \
175 : : }
176 : :
177 : : /*
178 : : * Macros for copying blocks of memory and for zeroing out ranges
179 : : * of memory. Using these macros makes it easy to switch from
180 : : * using memset()/memcpy() and using bzero()/bcopy().
181 : : *
182 : : * Please define either SHA2_USE_MEMSET_MEMCPY or define
183 : : * SHA2_USE_BZERO_BCOPY depending on which function set you
184 : : * choose to use:
185 : : */
186 : : #if !defined(SHA2_USE_MEMSET_MEMCPY) && !defined(SHA2_USE_BZERO_BCOPY)
187 : : /* Default to memset()/memcpy() if no option is specified */
188 : : #define SHA2_USE_MEMSET_MEMCPY 1
189 : : #endif
190 : : #if defined(SHA2_USE_MEMSET_MEMCPY) && defined(SHA2_USE_BZERO_BCOPY)
191 : : /* Abort with an error if BOTH options are defined */
192 : : #error Define either SHA2_USE_MEMSET_MEMCPY or SHA2_USE_BZERO_BCOPY, not both!
193 : : #endif
194 : :
195 : : #ifdef SHA2_USE_MEMSET_MEMCPY
196 : : #define MEMSET_BZERO(p,l) memset((p), 0, (l))
197 : : #define MEMCPY_BCOPY(d,s,l) memcpy((d), (s), (l))
198 : : #endif
199 : : #ifdef SHA2_USE_BZERO_BCOPY
200 : : #define MEMSET_BZERO(p,l) bzero((p), (l))
201 : : #define MEMCPY_BCOPY(d,s,l) bcopy((s), (d), (l))
202 : : #endif
203 : :
204 : :
205 : : /*** THE SIX LOGICAL FUNCTIONS ****************************************/
206 : : /*
207 : : * Bit shifting and rotation (used by the six SHA-XYZ logical functions:
208 : : *
209 : : * NOTE: The naming of R and S appears backwards here (R is a SHIFT and
210 : : * S is a ROTATION) because the SHA-256/384/512 description document
211 : : * (see http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf) uses this
212 : : * same "backwards" definition.
213 : : */
214 : : /* Shift-right (used in SHA-256, SHA-384, and SHA-512): */
215 : : #define R(b,x) ((x) >> (b))
216 : : /* 32-bit Rotate-right (used in SHA-256): */
217 : : #define S32(b,x) (((x) >> (b)) | ((x) << (32 - (b))))
218 : : /* 64-bit Rotate-right (used in SHA-384 and SHA-512): */
219 : : #define S64(b,x) (((x) >> (b)) | ((x) << (64 - (b))))
220 : :
221 : : /* Two of six logical functions used in SHA-256, SHA-384, and SHA-512: */
222 : : #define Ch(x,y,z) (((x) & (y)) ^ ((~(x)) & (z)))
223 : : #define Maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
224 : :
225 : : /* Four of six logical functions used in SHA-256: */
226 : : #define Sigma0_256(x) (S32(2, (x)) ^ S32(13, (x)) ^ S32(22, (x)))
227 : : #define Sigma1_256(x) (S32(6, (x)) ^ S32(11, (x)) ^ S32(25, (x)))
228 : : #define sigma0_256(x) (S32(7, (x)) ^ S32(18, (x)) ^ R(3 , (x)))
229 : : #define sigma1_256(x) (S32(17, (x)) ^ S32(19, (x)) ^ R(10, (x)))
230 : :
231 : : /* Four of six logical functions used in SHA-384 and SHA-512: */
232 : : #define Sigma0_512(x) (S64(28, (x)) ^ S64(34, (x)) ^ S64(39, (x)))
233 : : #define Sigma1_512(x) (S64(14, (x)) ^ S64(18, (x)) ^ S64(41, (x)))
234 : : #define sigma0_512(x) (S64( 1, (x)) ^ S64( 8, (x)) ^ R( 7, (x)))
235 : : #define sigma1_512(x) (S64(19, (x)) ^ S64(61, (x)) ^ R( 6, (x)))
236 : :
237 : : /*** INTERNAL FUNCTION PROTOTYPES *************************************/
238 : : /* NOTE: These should not be accessed directly from outside this
239 : : * library -- they are intended for private internal visibility/use
240 : : * only.
241 : : */
242 : : void SHA512_Last(SHA512_CTX*);
243 : : void SHA256_Transform(SHA256_CTX*, const sha2_word32*);
244 : : void SHA512_Transform(SHA512_CTX*, const sha2_word64*);
245 : :
246 : :
247 : : /*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/
248 : : /* Hash constant words K for SHA-256: */
249 : : const static sha2_word32 K256[64] = {
250 : : 0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL,
251 : : 0x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL,
252 : : 0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL,
253 : : 0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL, 0xc19bf174UL,
254 : : 0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL,
255 : : 0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL,
256 : : 0x983e5152UL, 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL,
257 : : 0xc6e00bf3UL, 0xd5a79147UL, 0x06ca6351UL, 0x14292967UL,
258 : : 0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL, 0x53380d13UL,
259 : : 0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL,
260 : : 0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL,
261 : : 0xd192e819UL, 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL,
262 : : 0x19a4c116UL, 0x1e376c08UL, 0x2748774cUL, 0x34b0bcb5UL,
263 : : 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL, 0x682e6ff3UL,
264 : : 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
265 : : 0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL
266 : : };
267 : :
268 : : /* Initial hash value H for SHA-256: */
269 : : const static sha2_word32 sha256_initial_hash_value[8] = {
270 : : 0x6a09e667UL,
271 : : 0xbb67ae85UL,
272 : : 0x3c6ef372UL,
273 : : 0xa54ff53aUL,
274 : : 0x510e527fUL,
275 : : 0x9b05688cUL,
276 : : 0x1f83d9abUL,
277 : : 0x5be0cd19UL
278 : : };
279 : :
280 : : /* Hash constant words K for SHA-384 and SHA-512: */
281 : : const static sha2_word64 K512[80] = {
282 : : 0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL,
283 : : 0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL,
284 : : 0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL,
285 : : 0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL,
286 : : 0xd807aa98a3030242ULL, 0x12835b0145706fbeULL,
287 : : 0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL,
288 : : 0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL,
289 : : 0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL,
290 : : 0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL,
291 : : 0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL,
292 : : 0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL,
293 : : 0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL,
294 : : 0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL,
295 : : 0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL,
296 : : 0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL,
297 : : 0x06ca6351e003826fULL, 0x142929670a0e6e70ULL,
298 : : 0x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL,
299 : : 0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL,
300 : : 0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL,
301 : : 0x81c2c92e47edaee6ULL, 0x92722c851482353bULL,
302 : : 0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL,
303 : : 0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL,
304 : : 0xd192e819d6ef5218ULL, 0xd69906245565a910ULL,
305 : : 0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL,
306 : : 0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL,
307 : : 0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL,
308 : : 0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL,
309 : : 0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL,
310 : : 0x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL,
311 : : 0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL,
312 : : 0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL,
313 : : 0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL,
314 : : 0xca273eceea26619cULL, 0xd186b8c721c0c207ULL,
315 : : 0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL,
316 : : 0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL,
317 : : 0x113f9804bef90daeULL, 0x1b710b35131c471bULL,
318 : : 0x28db77f523047d84ULL, 0x32caab7b40c72493ULL,
319 : : 0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL,
320 : : 0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL,
321 : : 0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL
322 : : };
323 : :
324 : : /* Initial hash value H for SHA-384 */
325 : : const static sha2_word64 sha384_initial_hash_value[8] = {
326 : : 0xcbbb9d5dc1059ed8ULL,
327 : : 0x629a292a367cd507ULL,
328 : : 0x9159015a3070dd17ULL,
329 : : 0x152fecd8f70e5939ULL,
330 : : 0x67332667ffc00b31ULL,
331 : : 0x8eb44a8768581511ULL,
332 : : 0xdb0c2e0d64f98fa7ULL,
333 : : 0x47b5481dbefa4fa4ULL
334 : : };
335 : :
336 : : /* Initial hash value H for SHA-512 */
337 : : const static sha2_word64 sha512_initial_hash_value[8] = {
338 : : 0x6a09e667f3bcc908ULL,
339 : : 0xbb67ae8584caa73bULL,
340 : : 0x3c6ef372fe94f82bULL,
341 : : 0xa54ff53a5f1d36f1ULL,
342 : : 0x510e527fade682d1ULL,
343 : : 0x9b05688c2b3e6c1fULL,
344 : : 0x1f83d9abfb41bd6bULL,
345 : : 0x5be0cd19137e2179ULL
346 : : };
347 : :
348 : :
349 : : /*** SHA-256: *********************************************************/
350 : 6234859 : void SHA256_Init(SHA256_CTX* context) {
351 [ + - ]: 6234859 : if (context == (SHA256_CTX*)0) {
352 : 6234859 : return;
353 : : }
354 : 6234859 : MEMCPY_BCOPY(context->state, sha256_initial_hash_value, SHA256_DIGEST_LEN);
355 : 6234859 : MEMSET_BZERO(context->buffer, SHA256_BLOCK_LEN);
356 : 6234859 : context->bitcount = 0;
357 : : }
358 : :
359 : : #ifdef SHA2_UNROLL_TRANSFORM
360 : :
361 : : /* Unrolled SHA-256 round macros: */
362 : :
363 : : #if BYTE_ORDER == LITTLE_ENDIAN
364 : :
365 : : #define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \
366 : : REVERSE32(*data++, W256[j]); \
367 : : T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \
368 : : K256[j] + W256[j]; \
369 : : (d) += T1; \
370 : : (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
371 : : j++
372 : :
373 : :
374 : : #else /* BYTE_ORDER == LITTLE_ENDIAN */
375 : :
376 : : #define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \
377 : : T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \
378 : : K256[j] + (W256[j] = *data++); \
379 : : (d) += T1; \
380 : : (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
381 : : j++
382 : :
383 : : #endif /* BYTE_ORDER == LITTLE_ENDIAN */
384 : :
385 : : #define ROUND256(a,b,c,d,e,f,g,h) \
386 : : s0 = W256[(j+1)&0x0f]; \
387 : : s0 = sigma0_256(s0); \
388 : : s1 = W256[(j+14)&0x0f]; \
389 : : s1 = sigma1_256(s1); \
390 : : T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + K256[j] + \
391 : : (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0); \
392 : : (d) += T1; \
393 : : (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
394 : : j++
395 : :
396 : : void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
397 : : sha2_word32 a, b, c, d, e, f, g, h, s0, s1;
398 : : sha2_word32 T1, *W256;
399 : : int j;
400 : :
401 : : W256 = (sha2_word32*)context->buffer;
402 : :
403 : : /* Initialize registers with the prev. intermediate value */
404 : : a = context->state[0];
405 : : b = context->state[1];
406 : : c = context->state[2];
407 : : d = context->state[3];
408 : : e = context->state[4];
409 : : f = context->state[5];
410 : : g = context->state[6];
411 : : h = context->state[7];
412 : :
413 : : j = 0;
414 : : do {
415 : : /* Rounds 0 to 15 (unrolled): */
416 : : ROUND256_0_TO_15(a,b,c,d,e,f,g,h);
417 : : ROUND256_0_TO_15(h,a,b,c,d,e,f,g);
418 : : ROUND256_0_TO_15(g,h,a,b,c,d,e,f);
419 : : ROUND256_0_TO_15(f,g,h,a,b,c,d,e);
420 : : ROUND256_0_TO_15(e,f,g,h,a,b,c,d);
421 : : ROUND256_0_TO_15(d,e,f,g,h,a,b,c);
422 : : ROUND256_0_TO_15(c,d,e,f,g,h,a,b);
423 : : ROUND256_0_TO_15(b,c,d,e,f,g,h,a);
424 : : } while (j < 16);
425 : :
426 : : /* Now for the remaining rounds to 64: */
427 : : do {
428 : : ROUND256(a,b,c,d,e,f,g,h);
429 : : ROUND256(h,a,b,c,d,e,f,g);
430 : : ROUND256(g,h,a,b,c,d,e,f);
431 : : ROUND256(f,g,h,a,b,c,d,e);
432 : : ROUND256(e,f,g,h,a,b,c,d);
433 : : ROUND256(d,e,f,g,h,a,b,c);
434 : : ROUND256(c,d,e,f,g,h,a,b);
435 : : ROUND256(b,c,d,e,f,g,h,a);
436 : : } while (j < 64);
437 : :
438 : : /* Compute the current intermediate hash value */
439 : : context->state[0] += a;
440 : : context->state[1] += b;
441 : : context->state[2] += c;
442 : : context->state[3] += d;
443 : : context->state[4] += e;
444 : : context->state[5] += f;
445 : : context->state[6] += g;
446 : : context->state[7] += h;
447 : :
448 : : /* Clean up */
449 : : a = b = c = d = e = f = g = h = T1 = 0;
450 : : }
451 : :
452 : : #else /* SHA2_UNROLL_TRANSFORM */
453 : :
454 : 25449764 : void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
455 : : sha2_word32 a, b, c, d, e, f, g, h, s0, s1;
456 : : sha2_word32 T1, T2, *W256;
457 : : int j;
458 : :
459 : 25449764 : W256 = (sha2_word32*)context->buffer;
460 : :
461 : : /* Initialize registers with the prev. intermediate value */
462 : 25449764 : a = context->state[0];
463 : 25449764 : b = context->state[1];
464 : 25449764 : c = context->state[2];
465 : 25449764 : d = context->state[3];
466 : 25449764 : e = context->state[4];
467 : 25449764 : f = context->state[5];
468 : 25449764 : g = context->state[6];
469 : 25449764 : h = context->state[7];
470 : :
471 : 25449764 : j = 0;
472 : : do {
473 : : #if BYTE_ORDER == LITTLE_ENDIAN
474 : : /* Copy data while converting to host byte order */
475 : 407196224 : REVERSE32(*data++,W256[j]);
476 : : /* Apply the SHA-256 compression function to update a..h */
477 : 407196224 : T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + W256[j];
478 : : #else /* BYTE_ORDER == LITTLE_ENDIAN */
479 : : /* Apply the SHA-256 compression function to update a..h with copy */
480 : : T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + (W256[j] = *data++);
481 : : #endif /* BYTE_ORDER == LITTLE_ENDIAN */
482 : 407196224 : T2 = Sigma0_256(a) + Maj(a, b, c);
483 : 407196224 : h = g;
484 : 407196224 : g = f;
485 : 407196224 : f = e;
486 : 407196224 : e = d + T1;
487 : 407196224 : d = c;
488 : 407196224 : c = b;
489 : 407196224 : b = a;
490 : 407196224 : a = T1 + T2;
491 : :
492 : 407196224 : j++;
493 [ + + ]: 407196224 : } while (j < 16);
494 : :
495 : : do {
496 : : /* Part of the message block expansion: */
497 : 1221588672 : s0 = W256[(j+1)&0x0f];
498 : 1221588672 : s0 = sigma0_256(s0);
499 : 1221588672 : s1 = W256[(j+14)&0x0f];
500 : 1221588672 : s1 = sigma1_256(s1);
501 : :
502 : : /* Apply the SHA-256 compression function to update a..h */
503 : 2443177344 : T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] +
504 : 1221588672 : (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0);
505 : 1221588672 : T2 = Sigma0_256(a) + Maj(a, b, c);
506 : 1221588672 : h = g;
507 : 1221588672 : g = f;
508 : 1221588672 : f = e;
509 : 1221588672 : e = d + T1;
510 : 1221588672 : d = c;
511 : 1221588672 : c = b;
512 : 1221588672 : b = a;
513 : 1221588672 : a = T1 + T2;
514 : :
515 : 1221588672 : j++;
516 [ + + ]: 1221588672 : } while (j < 64);
517 : :
518 : : /* Compute the current intermediate hash value */
519 : 25449764 : context->state[0] += a;
520 : 25449764 : context->state[1] += b;
521 : 25449764 : context->state[2] += c;
522 : 25449764 : context->state[3] += d;
523 : 25449764 : context->state[4] += e;
524 : 25449764 : context->state[5] += f;
525 : 25449764 : context->state[6] += g;
526 : 25449764 : context->state[7] += h;
527 : :
528 : : /* Clean up */
529 : 25449764 : a = b = c = d = e = f = g = h = T1 = T2 = 0;
530 : 25449764 : }
531 : :
532 : : #endif /* SHA2_UNROLL_TRANSFORM */
533 : :
534 : 9282911 : void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {
535 : : unsigned int freespace, usedspace;
536 : :
537 [ + + ]: 9282911 : if (len == 0) {
538 : : /* Calling with no data is valid - we do nothing */
539 : : return;
540 : : }
541 : :
542 : : /* Sanity check: */
543 [ - + ]: 9280511 : assert(context != (SHA256_CTX*)0 && data != (sha2_byte*)0);
544 : :
545 : 9280511 : usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LEN;
546 [ - + ]: 9280511 : if (usedspace > 0) {
547 : : /* Calculate how much free space is available in the buffer */
548 : 0 : freespace = SHA256_BLOCK_LEN - usedspace;
549 : :
550 [ # # ]: 0 : if (len >= freespace) {
551 : : /* Fill the buffer completely and process it */
552 : 0 : MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace);
553 : 0 : context->bitcount += freespace << 3;
554 : 0 : len -= freespace;
555 : 0 : data += freespace;
556 : 9280511 : SHA256_Transform(context, (sha2_word32*)context->buffer);
557 : : } else {
558 : : /* The buffer is not yet full */
559 : 0 : MEMCPY_BCOPY(&context->buffer[usedspace], data, len);
560 : 0 : context->bitcount += len << 3;
561 : : /* Clean up: */
562 : 0 : usedspace = freespace = 0;
563 : 0 : return;
564 : : }
565 : : }
566 [ + + ]: 28352235 : while (len >= SHA256_BLOCK_LEN) {
567 : : /* Process as many complete blocks as we can */
568 : 19071724 : SHA256_Transform(context, (sha2_word32*)data);
569 : 19071724 : context->bitcount += SHA256_BLOCK_LEN << 3;
570 : 19071724 : len -= SHA256_BLOCK_LEN;
571 : 19071724 : data += SHA256_BLOCK_LEN;
572 : : }
573 [ + + ]: 9280511 : if (len > 0) {
574 : : /* There's left-overs, so save 'em */
575 : 4180860 : MEMCPY_BCOPY(context->buffer, data, len);
576 : 4180860 : context->bitcount += len << 3;
577 : : }
578 : : /* Clean up: */
579 : : usedspace = freespace = 0;
580 : : }
581 : :
582 : 6234859 : void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {
583 : 6234859 : sha2_word32 *d = (sha2_word32*)digest;
584 : : unsigned int usedspace;
585 : :
586 : : /* Sanity check: */
587 [ - + ]: 6234859 : assert(context != (SHA256_CTX*)0);
588 : :
589 : : /* If no digest buffer is passed, we don't bother doing this: */
590 [ + - ]: 6234859 : if (digest != (sha2_byte*)0) {
591 : 6234859 : usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LEN;
592 : : #if BYTE_ORDER == LITTLE_ENDIAN
593 : : /* Convert FROM host byte order */
594 : 6234859 : REVERSE64(context->bitcount,context->bitcount);
595 : : #endif
596 [ + + ]: 6234859 : if (usedspace > 0) {
597 : : /* Begin padding with a 1 bit: */
598 : 4180860 : context->buffer[usedspace++] = 0x80;
599 : :
600 [ + + ]: 4180860 : if (usedspace <= SHA256_SHORT_BLOCK_LEN) {
601 : : /* Set-up for the last transform: */
602 : 4037679 : MEMSET_BZERO(&context->buffer[usedspace], SHA256_SHORT_BLOCK_LEN - usedspace);
603 : : } else {
604 [ + + ]: 143181 : if (usedspace < SHA256_BLOCK_LEN) {
605 : 112691 : MEMSET_BZERO(&context->buffer[usedspace], SHA256_BLOCK_LEN - usedspace);
606 : : }
607 : : /* Do second-to-last transform: */
608 : 143181 : SHA256_Transform(context, (sha2_word32*)context->buffer);
609 : :
610 : : /* And set-up for the last transform: */
611 : 143181 : MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LEN);
612 : : }
613 : : } else {
614 : : /* Set-up for the last transform: */
615 : 2053999 : MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LEN);
616 : :
617 : : /* Begin padding with a 1 bit: */
618 : 2053999 : *context->buffer = 0x80;
619 : : }
620 : : /* Set the bit count: */
621 : 6234859 : memcpy(&(context->buffer[SHA256_SHORT_BLOCK_LEN]), &(context->bitcount), sizeof(sha2_word64));
622 : :
623 : : /* Final transform: */
624 : 6234859 : SHA256_Transform(context, (sha2_word32*)context->buffer);
625 : :
626 : : #if BYTE_ORDER == LITTLE_ENDIAN
627 : : {
628 : : /* Convert TO host byte order */
629 : : int j;
630 [ + + ]: 56113731 : for (j = 0; j < 8; j++) {
631 : 49878872 : REVERSE32(context->state[j],context->state[j]);
632 : 49878872 : *d++ = context->state[j];
633 : : }
634 : : }
635 : : #else
636 : : MEMCPY_BCOPY(d, context->state, SHA256_DIGEST_LEN);
637 : : #endif
638 : : }
639 : :
640 : : /* Clean up state data: */
641 : : MEMSET_BZERO(context, sizeof(*context));
642 : 6234859 : usedspace = 0;
643 : 6234859 : }
644 : :
645 : : /*** SHA-512: *********************************************************/
646 : 222 : void SHA512_Init(SHA512_CTX* context) {
647 [ + - ]: 222 : if (context == (SHA512_CTX*)0) {
648 : 222 : return;
649 : : }
650 : 222 : MEMCPY_BCOPY(context->state, sha512_initial_hash_value, SHA512_DIGEST_LEN);
651 : 222 : MEMSET_BZERO(context->buffer, SHA512_BLOCK_LEN);
652 : 222 : context->bitcount[0] = context->bitcount[1] = 0;
653 : : }
654 : :
655 : : #ifdef SHA2_UNROLL_TRANSFORM
656 : :
657 : : /* Unrolled SHA-512 round macros: */
658 : : #if BYTE_ORDER == LITTLE_ENDIAN
659 : :
660 : : #define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) \
661 : : REVERSE64(*data++, W512[j]); \
662 : : T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \
663 : : K512[j] + W512[j]; \
664 : : (d) += T1, \
665 : : (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)), \
666 : : j++
667 : :
668 : :
669 : : #else /* BYTE_ORDER == LITTLE_ENDIAN */
670 : :
671 : : #define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) \
672 : : T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \
673 : : K512[j] + (W512[j] = *data++); \
674 : : (d) += T1; \
675 : : (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
676 : : j++
677 : :
678 : : #endif /* BYTE_ORDER == LITTLE_ENDIAN */
679 : :
680 : : #define ROUND512(a,b,c,d,e,f,g,h) \
681 : : s0 = W512[(j+1)&0x0f]; \
682 : : s0 = sigma0_512(s0); \
683 : : s1 = W512[(j+14)&0x0f]; \
684 : : s1 = sigma1_512(s1); \
685 : : T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + K512[j] + \
686 : : (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0); \
687 : : (d) += T1; \
688 : : (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
689 : : j++
690 : :
691 : : void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
692 : : sha2_word64 a, b, c, d, e, f, g, h, s0, s1;
693 : : sha2_word64 T1, *W512 = (sha2_word64*)context->buffer;
694 : : int j;
695 : :
696 : : /* Initialize registers with the prev. intermediate value */
697 : : a = context->state[0];
698 : : b = context->state[1];
699 : : c = context->state[2];
700 : : d = context->state[3];
701 : : e = context->state[4];
702 : : f = context->state[5];
703 : : g = context->state[6];
704 : : h = context->state[7];
705 : :
706 : : j = 0;
707 : : do {
708 : : ROUND512_0_TO_15(a,b,c,d,e,f,g,h);
709 : : ROUND512_0_TO_15(h,a,b,c,d,e,f,g);
710 : : ROUND512_0_TO_15(g,h,a,b,c,d,e,f);
711 : : ROUND512_0_TO_15(f,g,h,a,b,c,d,e);
712 : : ROUND512_0_TO_15(e,f,g,h,a,b,c,d);
713 : : ROUND512_0_TO_15(d,e,f,g,h,a,b,c);
714 : : ROUND512_0_TO_15(c,d,e,f,g,h,a,b);
715 : : ROUND512_0_TO_15(b,c,d,e,f,g,h,a);
716 : : } while (j < 16);
717 : :
718 : : /* Now for the remaining rounds up to 79: */
719 : : do {
720 : : ROUND512(a,b,c,d,e,f,g,h);
721 : : ROUND512(h,a,b,c,d,e,f,g);
722 : : ROUND512(g,h,a,b,c,d,e,f);
723 : : ROUND512(f,g,h,a,b,c,d,e);
724 : : ROUND512(e,f,g,h,a,b,c,d);
725 : : ROUND512(d,e,f,g,h,a,b,c);
726 : : ROUND512(c,d,e,f,g,h,a,b);
727 : : ROUND512(b,c,d,e,f,g,h,a);
728 : : } while (j < 80);
729 : :
730 : : /* Compute the current intermediate hash value */
731 : : context->state[0] += a;
732 : : context->state[1] += b;
733 : : context->state[2] += c;
734 : : context->state[3] += d;
735 : : context->state[4] += e;
736 : : context->state[5] += f;
737 : : context->state[6] += g;
738 : : context->state[7] += h;
739 : :
740 : : /* Clean up */
741 : : a = b = c = d = e = f = g = h = T1 = 0;
742 : : }
743 : :
744 : : #else /* SHA2_UNROLL_TRANSFORM */
745 : :
746 : 817 : void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
747 : : sha2_word64 a, b, c, d, e, f, g, h, s0, s1;
748 : 817 : sha2_word64 T1, T2, *W512 = (sha2_word64*)context->buffer;
749 : : int j;
750 : :
751 : : /* Initialize registers with the prev. intermediate value */
752 : 817 : a = context->state[0];
753 : 817 : b = context->state[1];
754 : 817 : c = context->state[2];
755 : 817 : d = context->state[3];
756 : 817 : e = context->state[4];
757 : 817 : f = context->state[5];
758 : 817 : g = context->state[6];
759 : 817 : h = context->state[7];
760 : :
761 : 817 : j = 0;
762 : : do {
763 : : #if BYTE_ORDER == LITTLE_ENDIAN
764 : : /* Convert TO host byte order */
765 : 13072 : REVERSE64(*data++, W512[j]);
766 : : /* Apply the SHA-512 compression function to update a..h */
767 : 13072 : T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + W512[j];
768 : : #else /* BYTE_ORDER == LITTLE_ENDIAN */
769 : : /* Apply the SHA-512 compression function to update a..h with copy */
770 : : T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + (W512[j] = *data++);
771 : : #endif /* BYTE_ORDER == LITTLE_ENDIAN */
772 : 13072 : T2 = Sigma0_512(a) + Maj(a, b, c);
773 : 13072 : h = g;
774 : 13072 : g = f;
775 : 13072 : f = e;
776 : 13072 : e = d + T1;
777 : 13072 : d = c;
778 : 13072 : c = b;
779 : 13072 : b = a;
780 : 13072 : a = T1 + T2;
781 : :
782 : 13072 : j++;
783 [ + + ]: 13072 : } while (j < 16);
784 : :
785 : : do {
786 : : /* Part of the message block expansion: */
787 : 52288 : s0 = W512[(j+1)&0x0f];
788 : 52288 : s0 = sigma0_512(s0);
789 : 52288 : s1 = W512[(j+14)&0x0f];
790 : 52288 : s1 = sigma1_512(s1);
791 : :
792 : : /* Apply the SHA-512 compression function to update a..h */
793 : 104576 : T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] +
794 : 52288 : (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0);
795 : 52288 : T2 = Sigma0_512(a) + Maj(a, b, c);
796 : 52288 : h = g;
797 : 52288 : g = f;
798 : 52288 : f = e;
799 : 52288 : e = d + T1;
800 : 52288 : d = c;
801 : 52288 : c = b;
802 : 52288 : b = a;
803 : 52288 : a = T1 + T2;
804 : :
805 : 52288 : j++;
806 [ + + ]: 52288 : } while (j < 80);
807 : :
808 : : /* Compute the current intermediate hash value */
809 : 817 : context->state[0] += a;
810 : 817 : context->state[1] += b;
811 : 817 : context->state[2] += c;
812 : 817 : context->state[3] += d;
813 : 817 : context->state[4] += e;
814 : 817 : context->state[5] += f;
815 : 817 : context->state[6] += g;
816 : 817 : context->state[7] += h;
817 : :
818 : : /* Clean up */
819 : 817 : a = b = c = d = e = f = g = h = T1 = T2 = 0;
820 : 817 : }
821 : :
822 : : #endif /* SHA2_UNROLL_TRANSFORM */
823 : :
824 : 629 : void SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
825 : : unsigned int freespace, usedspace;
826 : :
827 [ + - ]: 629 : if (len == 0) {
828 : : /* Calling with no data is valid - we do nothing */
829 : : return;
830 : : }
831 : :
832 : : /* Sanity check: */
833 [ - + ]: 629 : assert(context != (SHA512_CTX*)0 && data != (sha2_byte*)0);
834 : :
835 : 629 : usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LEN;
836 [ - + ]: 629 : if (usedspace > 0) {
837 : : /* Calculate how much free space is available in the buffer */
838 : 0 : freespace = SHA512_BLOCK_LEN - usedspace;
839 : :
840 [ # # ]: 0 : if (len >= freespace) {
841 : : /* Fill the buffer completely and process it */
842 : 0 : MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace);
843 [ # # ]: 0 : ADDINC128(context->bitcount, freespace << 3);
844 : 0 : len -= freespace;
845 : 0 : data += freespace;
846 : 629 : SHA512_Transform(context, (sha2_word64*)context->buffer);
847 : : } else {
848 : : /* The buffer is not yet full */
849 : 0 : MEMCPY_BCOPY(&context->buffer[usedspace], data, len);
850 [ # # ]: 0 : ADDINC128(context->bitcount, len << 3);
851 : : /* Clean up: */
852 : : usedspace = freespace = 0;
853 : : return;
854 : : }
855 : : }
856 [ + + ]: 1037 : while (len >= SHA512_BLOCK_LEN) {
857 : : /* Process as many complete blocks as we can */
858 : 408 : SHA512_Transform(context, (sha2_word64*)data);
859 [ - + ]: 408 : ADDINC128(context->bitcount, SHA512_BLOCK_LEN << 3);
860 : 408 : len -= SHA512_BLOCK_LEN;
861 : 408 : data += SHA512_BLOCK_LEN;
862 : : }
863 [ + + ]: 629 : if (len > 0) {
864 : : /* There's left-overs, so save 'em */
865 : 380 : MEMCPY_BCOPY(context->buffer, data, len);
866 [ - + ]: 380 : ADDINC128(context->bitcount, len << 3);
867 : : }
868 : : /* Clean up: */
869 : : usedspace = freespace = 0;
870 : : }
871 : :
872 : 397 : void SHA512_Last(SHA512_CTX* context) {
873 : : unsigned int usedspace;
874 : :
875 : 397 : usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LEN;
876 : : #if BYTE_ORDER == LITTLE_ENDIAN
877 : : /* Convert FROM host byte order */
878 : 397 : REVERSE64(context->bitcount[0],context->bitcount[0]);
879 : 397 : REVERSE64(context->bitcount[1],context->bitcount[1]);
880 : : #endif
881 [ + + ]: 397 : if (usedspace > 0) {
882 : : /* Begin padding with a 1 bit: */
883 : 380 : context->buffer[usedspace++] = 0x80;
884 : :
885 [ + + ]: 380 : if (usedspace <= SHA512_SHORT_BLOCK_LEN) {
886 : : /* Set-up for the last transform: */
887 : 368 : MEMSET_BZERO(&context->buffer[usedspace], SHA512_SHORT_BLOCK_LEN - usedspace);
888 : : } else {
889 [ + - ]: 12 : if (usedspace < SHA512_BLOCK_LEN) {
890 : 12 : MEMSET_BZERO(&context->buffer[usedspace], SHA512_BLOCK_LEN - usedspace);
891 : : }
892 : : /* Do second-to-last transform: */
893 : 12 : SHA512_Transform(context, (sha2_word64*)context->buffer);
894 : :
895 : : /* And set-up for the last transform: */
896 : 12 : MEMSET_BZERO(context->buffer, SHA512_BLOCK_LEN - 2);
897 : : }
898 : : } else {
899 : : /* Prepare for final transform: */
900 : 17 : MEMSET_BZERO(context->buffer, SHA512_SHORT_BLOCK_LEN);
901 : :
902 : : /* Begin padding with a 1 bit: */
903 : 17 : *context->buffer = 0x80;
904 : : }
905 : : /* Store the length of input data (in bits): */
906 : 397 : memcpy(&(context->buffer[SHA512_SHORT_BLOCK_LEN]), &(context->bitcount[1]), sizeof(sha2_word64));
907 : 397 : memcpy(&(context->buffer[SHA512_SHORT_BLOCK_LEN+8]), &(context->bitcount[0]), sizeof(sha2_word64));
908 : :
909 : : /* Final transform: */
910 : 397 : SHA512_Transform(context, (sha2_word64*)context->buffer);
911 : 397 : }
912 : :
913 : 222 : void SHA512_Final(sha2_byte digest[], SHA512_CTX* context) {
914 : 222 : sha2_word64 *d = (sha2_word64*)digest;
915 : :
916 : : /* Sanity check: */
917 [ - + ]: 222 : assert(context != (SHA512_CTX*)0);
918 : :
919 : : /* If no digest buffer is passed, we don't bother doing this: */
920 [ + - ]: 222 : if (digest != (sha2_byte*)0) {
921 : 222 : SHA512_Last(context);
922 : :
923 : : /* Save the hash data for output: */
924 : : #if BYTE_ORDER == LITTLE_ENDIAN
925 : : {
926 : : /* Convert TO host byte order */
927 : : int j;
928 [ + + ]: 1998 : for (j = 0; j < 8; j++) {
929 : 1776 : REVERSE64(context->state[j],context->state[j]);
930 : 1776 : *d++ = context->state[j];
931 : : }
932 : : }
933 : : #else
934 : : MEMCPY_BCOPY(d, context->state, SHA512_DIGEST_LEN);
935 : : #endif
936 : : }
937 : :
938 : : /* Zero out state data */
939 : : MEMSET_BZERO(context, sizeof(*context));
940 : 222 : }
941 : :
942 : :
943 : : /*** SHA-384: *********************************************************/
944 : 175 : void SHA384_Init(SHA384_CTX* context) {
945 [ + - ]: 175 : if (context == (SHA384_CTX*)0) {
946 : 175 : return;
947 : : }
948 : 175 : MEMCPY_BCOPY(context->state, sha384_initial_hash_value, SHA512_DIGEST_LEN);
949 : 175 : MEMSET_BZERO(context->buffer, SHA384_BLOCK_LEN);
950 : 175 : context->bitcount[0] = context->bitcount[1] = 0;
951 : : }
952 : :
953 : 277 : void SHA384_Update(SHA384_CTX* context, const sha2_byte* data, size_t len) {
954 : 277 : SHA512_Update((SHA512_CTX*)context, data, len);
955 : 277 : }
956 : :
957 : 175 : void SHA384_Final(sha2_byte digest[], SHA384_CTX* context) {
958 : 175 : sha2_word64 *d = (sha2_word64*)digest;
959 : :
960 : : /* Sanity check: */
961 [ - + ]: 175 : assert(context != (SHA384_CTX*)0);
962 : :
963 : : /* If no digest buffer is passed, we don't bother doing this: */
964 [ + - ]: 175 : if (digest != (sha2_byte*)0) {
965 : 175 : SHA512_Last((SHA512_CTX*)context);
966 : :
967 : : /* Save the hash data for output: */
968 : : #if BYTE_ORDER == LITTLE_ENDIAN
969 : : {
970 : : /* Convert TO host byte order */
971 : : int j;
972 [ + + ]: 1225 : for (j = 0; j < 6; j++) {
973 : 1050 : REVERSE64(context->state[j],context->state[j]);
974 : 1050 : *d++ = context->state[j];
975 : : }
976 : : }
977 : : #else
978 : : MEMCPY_BCOPY(d, context->state, SHA384_DIGEST_LEN);
979 : : #endif
980 : : }
981 : :
982 : : /* Zero out state data */
983 : : MEMSET_BZERO(context, sizeof(*context));
984 : 175 : }
|
