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