sys/crypto/sha2/sha2.c

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