sys/crypto/sha2/sha2.c

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