source: project/release/5/sha2/trunk/sha2-base.c @ 35856

Last change on this file since 35856 was 35856, checked in by Kon Lovett, 2 years ago

C5 initial

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