dlls/rsaenh/sha2.c

   1 /*
   2  * FILE:        sha2.c
   3  * AUTHOR:      Aaron D. Gifford - http://www.aarongifford.com/
   4  *
   5  * Copyright (c) 2000-2001, Aaron D. Gifford
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of the copyright holder nor the names of contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 #include "config.h"
  34
  35 #include <string.h>
  36 #include <assert.h>
  37 #include "sha2.h"
  38
  39 /*
  40  * ASSERT NOTE:
  41  * Some sanity checking code is included using assert().  On my FreeBSD
  42  * system, this additional code can be removed by compiling with NDEBUG
  43  * defined.  Check your own systems manpage on assert() to see how to
  44  * compile WITHOUT the sanity checking code on your system.
  45  *
  46  * UNROLLED TRANSFORM LOOP NOTE:
  47  * You can define SHA2_UNROLL_TRANSFORM to use the unrolled transform
  48  * loop version for the hash transform rounds (defined using macros
  49  * later in this file).  Either define on the command line, for example:
  50  *
  51  *   cc -DSHA2_UNROLL_TRANSFORM -o sha2 sha2.c sha2prog.c
  52  *
  53  * or define below:
  54  *
  55  *   #define SHA2_UNROLL_TRANSFORM
  56  *
  57  */
  58
  59 /*** SHA-256/384/512 Various Length Definitions ***********************/
  60 /* NOTE: Most of these are in sha2.h */
  61 #define SHA256_SHORT_BLOCK_LENGTH       (SHA256_BLOCK_LENGTH - 8)
  62 #define SHA384_SHORT_BLOCK_LENGTH       (SHA384_BLOCK_LENGTH - 16)
  63 #define SHA512_SHORT_BLOCK_LENGTH       (SHA512_BLOCK_LENGTH - 16)
  64
  65 #define SHA2_WORD64_CONST(dw1, dw2) (((sha2_word64)(dw1) << 32) | (dw2))
  66
  67 /*** ENDIAN REVERSAL MACROS *******************************************/
  68 #ifndef WORDS_BIGENDIAN
  69 #define REVERSE32(w,x)  { \
  70         sha2_word32 tmp = (w); \
  71         tmp = (tmp >> 16) | (tmp << 16); \
  72         (x) = ((tmp & 0xff00ff00) >> 8) | ((tmp & 0x00ff00ff) << 8); \
  73 }
  74 #define REVERSE64(w,x)  { \
  75         sha2_word64 tmp = (w); \
  76         tmp = (tmp >> 32) | (tmp << 32); \
  77         tmp = ((tmp & SHA2_WORD64_CONST(0xff00ff00, 0xff00ff00)) >> 8) | \
  78               ((tmp & SHA2_WORD64_CONST(0x00ff00ff, 0x00ff00ff)) << 8); \
  79         (x) = ((tmp & SHA2_WORD64_CONST(0xffff0000, 0xffff0000)) >> 16) | \
  80               ((tmp & SHA2_WORD64_CONST(0x0000ffff, 0x0000ffff)) << 16); \
  81 }
  82 #endif
  83
  84 /*
  85  * Macro for incrementally adding the unsigned 64-bit integer n to the
  86  * unsigned 128-bit integer (represented using a two-element array of
  87  * 64-bit words):
  88  */
  89 #define ADDINC128(w,n)  { \
  90         (w)[0] += (sha2_word64)(n); \
  91         if ((w)[0] < (n)) { \
  92                 (w)[1]++; \
  93         } \
  94 }
  95
  96 /*
  97  * Macros for copying blocks of memory and for zeroing out ranges
  98  * of memory.  Using these macros makes it easy to switch from
  99  * using memset()/memcpy() and using bzero()/bcopy().
 100  *
 101  * Please define either SHA2_USE_MEMSET_MEMCPY or define
 102  * SHA2_USE_BZERO_BCOPY depending on which function set you
 103  * choose to use:
 104  */
 105 #if !defined(SHA2_USE_MEMSET_MEMCPY) && !defined(SHA2_USE_BZERO_BCOPY)
 106 /* Default to memset()/memcpy() if no option is specified */
 107 #define SHA2_USE_MEMSET_MEMCPY  1
 108 #endif
 109 #if defined(SHA2_USE_MEMSET_MEMCPY) && defined(SHA2_USE_BZERO_BCOPY)
 110 /* Abort with an error if BOTH options are defined */
 111 #error Define either SHA2_USE_MEMSET_MEMCPY or SHA2_USE_BZERO_BCOPY, not both!
 112 #endif
 113
 114 #ifdef SHA2_USE_MEMSET_MEMCPY
 115 #define MEMSET_BZERO(p,l)       memset((p), 0, (l))
 116 #define MEMCPY_BCOPY(d,s,l)     memcpy((d), (s), (l))
 117 #endif
 118 #ifdef SHA2_USE_BZERO_BCOPY
 119 #define MEMSET_BZERO(p,l)       bzero((p), (l))
 120 #define MEMCPY_BCOPY(d,s,l)     bcopy((s), (d), (l))
 121 #endif
 122
 123
 124 /*** THE SIX LOGICAL FUNCTIONS ****************************************/
 125 /*
 126  * Bit shifting and rotation (used by the six SHA-XYZ logical functions:
 127  *
 128  *   NOTE:  The naming of R and S appears backwards here (R is a SHIFT and
 129  *   S is a ROTATION) because the SHA-256/384/512 description document
 130  *   (see http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf) uses this
 131  *   same "backwards" definition.
 132  */
 133 /* Shift-right (used in SHA-256, SHA-384, and SHA-512): */
 134 #define R(b,x)          ((x) >> (b))
 135 /* 32-bit Rotate-right (used in SHA-256): */
 136 #define S32(b,x)        (((x) >> (b)) | ((x) << (32 - (b))))
 137 /* 64-bit Rotate-right (used in SHA-384 and SHA-512): */
 138 #define S64(b,x)        (((x) >> (b)) | ((x) << (64 - (b))))
 139
 140 /* Two of six logical functions used in SHA-256, SHA-384, and SHA-512: */
 141 #define Ch(x,y,z)       (((x) & (y)) ^ ((~(x)) & (z)))
 142 #define Maj(x,y,z)      (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
 143
 144 /* Four of six logical functions used in SHA-256: */
 145 #define Sigma0_256(x)   (S32(2,  (x)) ^ S32(13, (x)) ^ S32(22, (x)))
 146 #define Sigma1_256(x)   (S32(6,  (x)) ^ S32(11, (x)) ^ S32(25, (x)))
 147 #define sigma0_256(x)   (S32(7,  (x)) ^ S32(18, (x)) ^ R(3 ,   (x)))
 148 #define sigma1_256(x)   (S32(17, (x)) ^ S32(19, (x)) ^ R(10,   (x)))
 149
 150 /* Four of six logical functions used in SHA-384 and SHA-512: */
 151 #define Sigma0_512(x)   (S64(28, (x)) ^ S64(34, (x)) ^ S64(39, (x)))
 152 #define Sigma1_512(x)   (S64(14, (x)) ^ S64(18, (x)) ^ S64(41, (x)))
 153 #define sigma0_512(x)   (S64( 1, (x)) ^ S64( 8, (x)) ^ R( 7,   (x)))
 154 #define sigma1_512(x)   (S64(19, (x)) ^ S64(61, (x)) ^ R( 6,   (x)))
 155
 156 /*** INTERNAL FUNCTION PROTOTYPES *************************************/
 157 /* NOTE: These should not be accessed directly from outside this
 158  * library -- they are intended for private internal visibility/use
 159  * only.
 160  */
 161 void SHA512_Last(SHA512_CTX*);
 162 void SHA256_Transform(SHA256_CTX*, const sha2_word32*);
 163 void SHA512_Transform(SHA512_CTX*, const sha2_word64*);
 164
 165
 166 /*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/
 167 /* Hash constant words K for SHA-256: */
 168 static const sha2_word32 K256[64] = {
 169         0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
 170         0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
 171         0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
 172         0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
 173         0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
 174         0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
 175         0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
 176         0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
 177         0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
 178         0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
 179         0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
 180         0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
 181         0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
 182         0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
 183         0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
 184         0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
 185 };
 186
 187 /* Initial hash value H for SHA-256: */
 188 static const sha2_word32 sha256_initial_hash_value[8] = {
 189         0x6a09e667,
 190         0xbb67ae85,
 191         0x3c6ef372,
 192         0xa54ff53a,
 193         0x510e527f,
 194         0x9b05688c,
 195         0x1f83d9ab,
 196         0x5be0cd19
 197 };
 198
 199 /* Hash constant words K for SHA-384 and SHA-512: */
 200 static const sha2_word64 K512[80] = {
 201         SHA2_WORD64_CONST(0x428a2f98, 0xd728ae22), SHA2_WORD64_CONST(0x71374491, 0x23ef65cd),
 202         SHA2_WORD64_CONST(0xb5c0fbcf, 0xec4d3b2f), SHA2_WORD64_CONST(0xe9b5dba5, 0x8189dbbc),
 203         SHA2_WORD64_CONST(0x3956c25b, 0xf348b538), SHA2_WORD64_CONST(0x59f111f1, 0xb605d019),
 204         SHA2_WORD64_CONST(0x923f82a4, 0xaf194f9b), SHA2_WORD64_CONST(0xab1c5ed5, 0xda6d8118),
 205         SHA2_WORD64_CONST(0xd807aa98, 0xa3030242), SHA2_WORD64_CONST(0x12835b01, 0x45706fbe),
 206         SHA2_WORD64_CONST(0x243185be, 0x4ee4b28c), SHA2_WORD64_CONST(0x550c7dc3, 0xd5ffb4e2),
 207         SHA2_WORD64_CONST(0x72be5d74, 0xf27b896f), SHA2_WORD64_CONST(0x80deb1fe, 0x3b1696b1),
 208         SHA2_WORD64_CONST(0x9bdc06a7, 0x25c71235), SHA2_WORD64_CONST(0xc19bf174, 0xcf692694),
 209         SHA2_WORD64_CONST(0xe49b69c1, 0x9ef14ad2), SHA2_WORD64_CONST(0xefbe4786, 0x384f25e3),
 210         SHA2_WORD64_CONST(0x0fc19dc6, 0x8b8cd5b5), SHA2_WORD64_CONST(0x240ca1cc, 0x77ac9c65),
 211         SHA2_WORD64_CONST(0x2de92c6f, 0x592b0275), SHA2_WORD64_CONST(0x4a7484aa, 0x6ea6e483),
 212         SHA2_WORD64_CONST(0x5cb0a9dc, 0xbd41fbd4), SHA2_WORD64_CONST(0x76f988da, 0x831153b5),
 213         SHA2_WORD64_CONST(0x983e5152, 0xee66dfab), SHA2_WORD64_CONST(0xa831c66d, 0x2db43210),
 214         SHA2_WORD64_CONST(0xb00327c8, 0x98fb213f), SHA2_WORD64_CONST(0xbf597fc7, 0xbeef0ee4),
 215         SHA2_WORD64_CONST(0xc6e00bf3, 0x3da88fc2), SHA2_WORD64_CONST(0xd5a79147, 0x930aa725),
 216         SHA2_WORD64_CONST(0x06ca6351, 0xe003826f), SHA2_WORD64_CONST(0x14292967, 0x0a0e6e70),
 217         SHA2_WORD64_CONST(0x27b70a85, 0x46d22ffc), SHA2_WORD64_CONST(0x2e1b2138, 0x5c26c926),
 218         SHA2_WORD64_CONST(0x4d2c6dfc, 0x5ac42aed), SHA2_WORD64_CONST(0x53380d13, 0x9d95b3df),
 219         SHA2_WORD64_CONST(0x650a7354, 0x8baf63de), SHA2_WORD64_CONST(0x766a0abb, 0x3c77b2a8),
 220         SHA2_WORD64_CONST(0x81c2c92e, 0x47edaee6), SHA2_WORD64_CONST(0x92722c85, 0x1482353b),
 221         SHA2_WORD64_CONST(0xa2bfe8a1, 0x4cf10364), SHA2_WORD64_CONST(0xa81a664b, 0xbc423001),
 222         SHA2_WORD64_CONST(0xc24b8b70, 0xd0f89791), SHA2_WORD64_CONST(0xc76c51a3, 0x0654be30),
 223         SHA2_WORD64_CONST(0xd192e819, 0xd6ef5218), SHA2_WORD64_CONST(0xd6990624, 0x5565a910),
 224         SHA2_WORD64_CONST(0xf40e3585, 0x5771202a), SHA2_WORD64_CONST(0x106aa070, 0x32bbd1b8),
 225         SHA2_WORD64_CONST(0x19a4c116, 0xb8d2d0c8), SHA2_WORD64_CONST(0x1e376c08, 0x5141ab53),
 226         SHA2_WORD64_CONST(0x2748774c, 0xdf8eeb99), SHA2_WORD64_CONST(0x34b0bcb5, 0xe19b48a8),
 227         SHA2_WORD64_CONST(0x391c0cb3, 0xc5c95a63), SHA2_WORD64_CONST(0x4ed8aa4a, 0xe3418acb),
 228         SHA2_WORD64_CONST(0x5b9cca4f, 0x7763e373), SHA2_WORD64_CONST(0x682e6ff3, 0xd6b2b8a3),
 229         SHA2_WORD64_CONST(0x748f82ee, 0x5defb2fc), SHA2_WORD64_CONST(0x78a5636f, 0x43172f60),
 230         SHA2_WORD64_CONST(0x84c87814, 0xa1f0ab72), SHA2_WORD64_CONST(0x8cc70208, 0x1a6439ec),
 231         SHA2_WORD64_CONST(0x90befffa, 0x23631e28), SHA2_WORD64_CONST(0xa4506ceb, 0xde82bde9),
 232         SHA2_WORD64_CONST(0xbef9a3f7, 0xb2c67915), SHA2_WORD64_CONST(0xc67178f2, 0xe372532b),
 233         SHA2_WORD64_CONST(0xca273ece, 0xea26619c), SHA2_WORD64_CONST(0xd186b8c7, 0x21c0c207),
 234         SHA2_WORD64_CONST(0xeada7dd6, 0xcde0eb1e), SHA2_WORD64_CONST(0xf57d4f7f, 0xee6ed178),
 235         SHA2_WORD64_CONST(0x06f067aa, 0x72176fba), SHA2_WORD64_CONST(0x0a637dc5, 0xa2c898a6),
 236         SHA2_WORD64_CONST(0x113f9804, 0xbef90dae), SHA2_WORD64_CONST(0x1b710b35, 0x131c471b),
 237         SHA2_WORD64_CONST(0x28db77f5, 0x23047d84), SHA2_WORD64_CONST(0x32caab7b, 0x40c72493),
 238         SHA2_WORD64_CONST(0x3c9ebe0a, 0x15c9bebc), SHA2_WORD64_CONST(0x431d67c4, 0x9c100d4c),
 239         SHA2_WORD64_CONST(0x4cc5d4be, 0xcb3e42b6), SHA2_WORD64_CONST(0x597f299c, 0xfc657e2a),
 240         SHA2_WORD64_CONST(0x5fcb6fab, 0x3ad6faec), SHA2_WORD64_CONST(0x6c44198c, 0x4a475817)
 241 };
 242
 243 /* Initial hash value H for SHA-384 */
 244 static const sha2_word64 sha384_initial_hash_value[8] = {
 245         SHA2_WORD64_CONST(0xcbbb9d5d, 0xc1059ed8),
 246         SHA2_WORD64_CONST(0x629a292a, 0x367cd507),
 247         SHA2_WORD64_CONST(0x9159015a, 0x3070dd17),
 248         SHA2_WORD64_CONST(0x152fecd8, 0xf70e5939),
 249         SHA2_WORD64_CONST(0x67332667, 0xffc00b31),
 250         SHA2_WORD64_CONST(0x8eb44a87, 0x68581511),
 251         SHA2_WORD64_CONST(0xdb0c2e0d, 0x64f98fa7),
 252         SHA2_WORD64_CONST(0x47b5481d, 0xbefa4fa4)
 253 };
 254
 255 /* Initial hash value H for SHA-512 */
 256 static const sha2_word64 sha512_initial_hash_value[8] = {
 257         SHA2_WORD64_CONST(0x6a09e667, 0xf3bcc908),
 258         SHA2_WORD64_CONST(0xbb67ae85, 0x84caa73b),
 259         SHA2_WORD64_CONST(0x3c6ef372, 0xfe94f82b),
 260         SHA2_WORD64_CONST(0xa54ff53a, 0x5f1d36f1),
 261         SHA2_WORD64_CONST(0x510e527f, 0xade682d1),
 262         SHA2_WORD64_CONST(0x9b05688c, 0x2b3e6c1f),
 263         SHA2_WORD64_CONST(0x1f83d9ab, 0xfb41bd6b),
 264         SHA2_WORD64_CONST(0x5be0cd19, 0x137e2179)
 265 };
 266
 267 /*
 268  * Constant used by SHA256/384/512_End() functions for converting the
 269  * digest to a readable hexadecimal character string:
 270  */
 271 static const char sha2_hex_digits[] = "0123456789abcdef";
 272
 273
 274 /*** SHA-256: *********************************************************/
 275 void SHA256_Init(SHA256_CTX* context) {
 276         if (context == NULL) {
 277                 return;
 278         }
 279         MEMCPY_BCOPY(context->state, sha256_initial_hash_value, SHA256_DIGEST_LENGTH);
 280         MEMSET_BZERO(context->buffer, SHA256_BLOCK_LENGTH);
 281         context->bitcount = 0;
 282 }
 283
 284 #ifdef SHA2_UNROLL_TRANSFORM
 285
 286 /* Unrolled SHA-256 round macros: */
 287
 288 #ifndef WORDS_BIGENDIAN
 289
 290 #define ROUND256_0_TO_15(a,b,c,d,e,f,g,h)       \
 291         REVERSE32(*data++, W256[j]); \
 292         T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \
 293              K256[j] + W256[j]; \
 294         (d) += T1; \
 295         (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
 296         j++
 297
 298
 299 #else
 300
 301 #define ROUND256_0_TO_15(a,b,c,d,e,f,g,h)       \
 302         T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \
 303              K256[j] + (W256[j] = *data++); \
 304         (d) += T1; \
 305         (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
 306         j++
 307
 308 #endif
 309
 310 #define ROUND256(a,b,c,d,e,f,g,h)       \
 311         s0 = W256[(j+1)&0x0f]; \
 312         s0 = sigma0_256(s0); \
 313         s1 = W256[(j+14)&0x0f]; \
 314         s1 = sigma1_256(s1); \
 315         T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + K256[j] + \
 316              (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0); \
 317         (d) += T1; \
 318         (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
 319         j++
 320
 321 void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
 322         sha2_word32     a, b, c, d, e, f, g, h, s0, s1;
 323         sha2_word32     T1, *W256;
 324         int             j;
 325
 326         W256 = (sha2_word32*)context->buffer;
 327
 328         /* Initialize registers with the prev. intermediate value */
 329         a = context->state[0];
 330         b = context->state[1];
 331         c = context->state[2];
 332         d = context->state[3];
 333         e = context->state[4];
 334         f = context->state[5];
 335         g = context->state[6];
 336         h = context->state[7];
 337
 338         j = 0;
 339         do {
 340                 /* Rounds 0 to 15 (unrolled): */
 341                 ROUND256_0_TO_15(a,b,c,d,e,f,g,h);
 342                 ROUND256_0_TO_15(h,a,b,c,d,e,f,g);
 343                 ROUND256_0_TO_15(g,h,a,b,c,d,e,f);
 344                 ROUND256_0_TO_15(f,g,h,a,b,c,d,e);
 345                 ROUND256_0_TO_15(e,f,g,h,a,b,c,d);
 346                 ROUND256_0_TO_15(d,e,f,g,h,a,b,c);
 347                 ROUND256_0_TO_15(c,d,e,f,g,h,a,b);
 348                 ROUND256_0_TO_15(b,c,d,e,f,g,h,a);
 349         } while (j < 16);
 350
 351         /* Now for the remaining rounds to 64: */
 352         do {
 353                 ROUND256(a,b,c,d,e,f,g,h);
 354                 ROUND256(h,a,b,c,d,e,f,g);
 355                 ROUND256(g,h,a,b,c,d,e,f);
 356                 ROUND256(f,g,h,a,b,c,d,e);
 357                 ROUND256(e,f,g,h,a,b,c,d);
 358                 ROUND256(d,e,f,g,h,a,b,c);
 359                 ROUND256(c,d,e,f,g,h,a,b);
 360                 ROUND256(b,c,d,e,f,g,h,a);
 361         } while (j < 64);
 362
 363         /* Compute the current intermediate hash value */
 364         context->state[0] += a;
 365         context->state[1] += b;
 366         context->state[2] += c;
 367         context->state[3] += d;
 368         context->state[4] += e;
 369         context->state[5] += f;
 370         context->state[6] += g;
 371         context->state[7] += h;
 372
 373         /* Clean up */
 374         a = b = c = d = e = f = g = h = T1 = 0;
 375 }
 376
 377 #else /* SHA2_UNROLL_TRANSFORM */
 378
 379 void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
 380         sha2_word32     a, b, c, d, e, f, g, h, s0, s1;
 381         sha2_word32     T1, T2, *W256;
 382         int             j;
 383
 384         W256 = (sha2_word32*)context->buffer;
 385
 386         /* Initialize registers with the prev. intermediate value */
 387         a = context->state[0];
 388         b = context->state[1];
 389         c = context->state[2];
 390         d = context->state[3];
 391         e = context->state[4];
 392         f = context->state[5];
 393         g = context->state[6];
 394         h = context->state[7];
 395
 396         j = 0;
 397         do {
 398 #ifndef WORDS_BIGENDIAN
 399                 /* Copy data while converting to host byte order */
 400                 REVERSE32(*data++,W256[j]);
 401                 /* Apply the SHA-256 compression function to update a..h */
 402                 T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + W256[j];
 403 #else
 404                 /* Apply the SHA-256 compression function to update a..h with copy */
 405                 T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + (W256[j] = *data++);
 406 #endif
 407                 T2 = Sigma0_256(a) + Maj(a, b, c);
 408                 h = g;
 409                 g = f;
 410                 f = e;
 411                 e = d + T1;
 412                 d = c;
 413                 c = b;
 414                 b = a;
 415                 a = T1 + T2;
 416
 417                 j++;
 418         } while (j < 16);
 419
 420         do {
 421                 /* Part of the message block expansion: */
 422                 s0 = W256[(j+1)&0x0f];
 423                 s0 = sigma0_256(s0);
 424                 s1 = W256[(j+14)&0x0f];
 425                 s1 = sigma1_256(s1);
 426
 427                 /* Apply the SHA-256 compression function to update a..h */
 428                 T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] +
 429                      (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0);
 430                 T2 = Sigma0_256(a) + Maj(a, b, c);
 431                 h = g;
 432                 g = f;
 433                 f = e;
 434                 e = d + T1;
 435                 d = c;
 436                 c = b;
 437                 b = a;
 438                 a = T1 + T2;
 439
 440                 j++;
 441         } while (j < 64);
 442
 443         /* Compute the current intermediate hash value */
 444         context->state[0] += a;
 445         context->state[1] += b;
 446         context->state[2] += c;
 447         context->state[3] += d;
 448         context->state[4] += e;
 449         context->state[5] += f;
 450         context->state[6] += g;
 451         context->state[7] += h;
 452
 453         /* Clean up */
 454         a = b = c = d = e = f = g = h = T1 = T2 = 0;
 455 }
 456
 457 #endif /* SHA2_UNROLL_TRANSFORM */
 458
 459 void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {
 460         unsigned int    freespace, usedspace;
 461
 462         if (len == 0) {
 463                 /* Calling with no data is valid - we do nothing */
 464                 return;
 465         }
 466
 467         /* Sanity check: */
 468         assert(context != NULL && data != NULL);
 469
 470         usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
 471         if (usedspace > 0) {
 472                 /* Calculate how much free space is available in the buffer */
 473                 freespace = SHA256_BLOCK_LENGTH - usedspace;
 474
 475                 if (len >= freespace) {
 476                         /* Fill the buffer completely and process it */
 477                         MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace);
 478                         context->bitcount += freespace << 3;
 479                         len -= freespace;
 480                         data += freespace;
 481                         SHA256_Transform(context, (sha2_word32*)context->buffer);
 482                 } else {
 483                         /* The buffer is not yet full */
 484                         MEMCPY_BCOPY(&context->buffer[usedspace], data, len);
 485                         context->bitcount += len << 3;
 486                         /* Clean up: */
 487                         usedspace = freespace = 0;
 488                         return;
 489                 }
 490         }
 491         while (len >= SHA256_BLOCK_LENGTH) {
 492                 /* Process as many complete blocks as we can */
 493                 SHA256_Transform(context, (const sha2_word32*)data);
 494                 context->bitcount += SHA256_BLOCK_LENGTH << 3;
 495                 len -= SHA256_BLOCK_LENGTH;
 496                 data += SHA256_BLOCK_LENGTH;
 497         }
 498         if (len > 0) {
 499                 /* There's left-overs, so save 'em */
 500                 MEMCPY_BCOPY(context->buffer, data, len);
 501                 context->bitcount += len << 3;
 502         }
 503         /* Clean up: */
 504         usedspace = freespace = 0;
 505 }
 506
 507 void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {
 508         sha2_word32     *d = (sha2_word32*)digest;
 509         unsigned int    usedspace;
 510
 511         /* Sanity check: */
 512         assert(context != NULL);
 513
 514         /* If no digest buffer is passed, we don't bother doing this: */
 515         if (digest != NULL) {
 516                 usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
 517 #ifndef WORDS_BIGENDIAN
 518                 /* Convert FROM host byte order */
 519                 REVERSE64(context->bitcount,context->bitcount);
 520 #endif
 521                 if (usedspace > 0) {
 522                         /* Begin padding with a 1 bit: */
 523                         context->buffer[usedspace++] = 0x80;
 524
 525                         if (usedspace <= SHA256_SHORT_BLOCK_LENGTH) {
 526                                 /* Set-up for the last transform: */
 527                                 MEMSET_BZERO(&context->buffer[usedspace], SHA256_SHORT_BLOCK_LENGTH - usedspace);
 528                         } else {
 529                                 if (usedspace < SHA256_BLOCK_LENGTH) {
 530                                         MEMSET_BZERO(&context->buffer[usedspace], SHA256_BLOCK_LENGTH - usedspace);
 531                                 }
 532                                 /* Do second-to-last transform: */
 533                                 SHA256_Transform(context, (sha2_word32*)context->buffer);
 534
 535                                 /* And set-up for the last transform: */
 536                                 MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LENGTH);
 537                         }
 538                 } else {
 539                         /* Set-up for the last transform: */
 540                         MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LENGTH);
 541
 542                         /* Begin padding with a 1 bit: */
 543                         *context->buffer = 0x80;
 544                 }
 545                 /* Set the bit count: */
 546                 *(sha2_word64*)&context->buffer[SHA256_SHORT_BLOCK_LENGTH] = context->bitcount;
 547
 548                 /* Final transform: */
 549                 SHA256_Transform(context, (sha2_word32*)context->buffer);
 550
 551 #ifndef WORDS_BIGENDIAN
 552                 {
 553                         /* Convert TO host byte order */
 554                         int     j;
 555                         for (j = 0; j < 8; j++) {
 556                                 REVERSE32(context->state[j],context->state[j]);
 557                                 *d++ = context->state[j];
 558                         }
 559                 }
 560 #else
 561                 MEMCPY_BCOPY(d, context->state, SHA256_DIGEST_LENGTH);
 562 #endif
 563         }
 564
 565         /* Clean up state data: */
 566         MEMSET_BZERO(context, sizeof(context));
 567         usedspace = 0;
 568 }
 569
 570 char *SHA256_End(SHA256_CTX* context, char buffer[]) {
 571         sha2_byte       digest[SHA256_DIGEST_LENGTH], *d = digest;
 572         int             i;
 573
 574         /* Sanity check: */
 575         assert(context != NULL);
 576
 577         if (buffer != NULL) {
 578                 SHA256_Final(digest, context);
 579
 580                 for (i = 0; i < SHA256_DIGEST_LENGTH; i++) {
 581                         *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
 582                         *buffer++ = sha2_hex_digits[*d & 0x0f];
 583                         d++;
 584                 }
 585                 *buffer = 0;
 586         } else {
 587                 MEMSET_BZERO(context, sizeof(context));
 588         }
 589         MEMSET_BZERO(digest, SHA256_DIGEST_LENGTH);
 590         return buffer;
 591 }
 592
 593 char* SHA256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIGEST_STRING_LENGTH]) {
 594         SHA256_CTX      context;
 595
 596         SHA256_Init(&context);
 597         SHA256_Update(&context, data, len);
 598         return SHA256_End(&context, digest);
 599 }
 600
 601
 602 /*** SHA-512: *********************************************************/
 603 void SHA512_Init(SHA512_CTX* context) {
 604         if (context == NULL) {
 605                 return;
 606         }
 607         MEMCPY_BCOPY(context->state, sha512_initial_hash_value, SHA512_DIGEST_LENGTH);
 608         MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH);
 609         context->bitcount[0] = context->bitcount[1] =  0;
 610 }
 611
 612 #ifdef SHA2_UNROLL_TRANSFORM
 613
 614 /* Unrolled SHA-512 round macros: */
 615 #ifndef WORDS_BIGENDIAN
 616
 617 #define ROUND512_0_TO_15(a,b,c,d,e,f,g,h)       \
 618         REVERSE64(*data++, W512[j]); \
 619         T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \
 620              K512[j] + W512[j]; \
 621         (d) += T1, \
 622         (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)), \
 623         j++
 624
 625
 626 #else
 627
 628 #define ROUND512_0_TO_15(a,b,c,d,e,f,g,h)       \
 629         T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \
 630              K512[j] + (W512[j] = *data++); \
 631         (d) += T1; \
 632         (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
 633         j++
 634
 635 #endif
 636
 637 #define ROUND512(a,b,c,d,e,f,g,h)       \
 638         s0 = W512[(j+1)&0x0f]; \
 639         s0 = sigma0_512(s0); \
 640         s1 = W512[(j+14)&0x0f]; \
 641         s1 = sigma1_512(s1); \
 642         T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + K512[j] + \
 643              (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0); \
 644         (d) += T1; \
 645         (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
 646         j++
 647
 648 void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
 649         sha2_word64     a, b, c, d, e, f, g, h, s0, s1;
 650         sha2_word64     T1, *W512 = (sha2_word64*)context->buffer;
 651         int             j;
 652
 653         /* Initialize registers with the prev. intermediate value */
 654         a = context->state[0];
 655         b = context->state[1];
 656         c = context->state[2];
 657         d = context->state[3];
 658         e = context->state[4];
 659         f = context->state[5];
 660         g = context->state[6];
 661         h = context->state[7];
 662
 663         j = 0;
 664         do {
 665                 ROUND512_0_TO_15(a,b,c,d,e,f,g,h);
 666                 ROUND512_0_TO_15(h,a,b,c,d,e,f,g);
 667                 ROUND512_0_TO_15(g,h,a,b,c,d,e,f);
 668                 ROUND512_0_TO_15(f,g,h,a,b,c,d,e);
 669                 ROUND512_0_TO_15(e,f,g,h,a,b,c,d);
 670                 ROUND512_0_TO_15(d,e,f,g,h,a,b,c);
 671                 ROUND512_0_TO_15(c,d,e,f,g,h,a,b);
 672                 ROUND512_0_TO_15(b,c,d,e,f,g,h,a);
 673         } while (j < 16);
 674
 675         /* Now for the remaining rounds up to 79: */
 676         do {
 677                 ROUND512(a,b,c,d,e,f,g,h);
 678                 ROUND512(h,a,b,c,d,e,f,g);
 679                 ROUND512(g,h,a,b,c,d,e,f);
 680                 ROUND512(f,g,h,a,b,c,d,e);
 681                 ROUND512(e,f,g,h,a,b,c,d);
 682                 ROUND512(d,e,f,g,h,a,b,c);
 683                 ROUND512(c,d,e,f,g,h,a,b);
 684                 ROUND512(b,c,d,e,f,g,h,a);
 685         } while (j < 80);
 686
 687         /* Compute the current intermediate hash value */
 688         context->state[0] += a;
 689         context->state[1] += b;
 690         context->state[2] += c;
 691         context->state[3] += d;
 692         context->state[4] += e;
 693         context->state[5] += f;
 694         context->state[6] += g;
 695         context->state[7] += h;
 696
 697         /* Clean up */
 698         a = b = c = d = e = f = g = h = T1 = 0;
 699 }
 700
 701 #else /* SHA2_UNROLL_TRANSFORM */
 702
 703 void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
 704         sha2_word64     a, b, c, d, e, f, g, h, s0, s1;
 705         sha2_word64     T1, T2, *W512 = (sha2_word64*)context->buffer;
 706         int             j;
 707
 708         /* Initialize registers with the prev. intermediate value */
 709         a = context->state[0];
 710         b = context->state[1];
 711         c = context->state[2];
 712         d = context->state[3];
 713         e = context->state[4];
 714         f = context->state[5];
 715         g = context->state[6];
 716         h = context->state[7];
 717
 718         j = 0;
 719         do {
 720 #ifndef WORDS_BIGENDIAN
 721                 /* Convert TO host byte order */
 722                 REVERSE64(*data++, W512[j]);
 723                 /* Apply the SHA-512 compression function to update a..h */
 724                 T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + W512[j];
 725 #else
 726                 /* Apply the SHA-512 compression function to update a..h with copy */
 727                 T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + (W512[j] = *data++);
 728 #endif
 729                 T2 = Sigma0_512(a) + Maj(a, b, c);
 730                 h = g;
 731                 g = f;
 732                 f = e;
 733                 e = d + T1;
 734                 d = c;
 735                 c = b;
 736                 b = a;
 737                 a = T1 + T2;
 738
 739                 j++;
 740         } while (j < 16);
 741
 742         do {
 743                 /* Part of the message block expansion: */
 744                 s0 = W512[(j+1)&0x0f];
 745                 s0 = sigma0_512(s0);
 746                 s1 = W512[(j+14)&0x0f];
 747                 s1 =  sigma1_512(s1);
 748
 749                 /* Apply the SHA-512 compression function to update a..h */
 750                 T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] +
 751                      (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0);
 752                 T2 = Sigma0_512(a) + Maj(a, b, c);
 753                 h = g;
 754                 g = f;
 755                 f = e;
 756                 e = d + T1;
 757                 d = c;
 758                 c = b;
 759                 b = a;
 760                 a = T1 + T2;
 761
 762                 j++;
 763         } while (j < 80);
 764
 765         /* Compute the current intermediate hash value */
 766         context->state[0] += a;
 767         context->state[1] += b;
 768         context->state[2] += c;
 769         context->state[3] += d;
 770         context->state[4] += e;
 771         context->state[5] += f;
 772         context->state[6] += g;
 773         context->state[7] += h;
 774
 775         /* Clean up */
 776         a = b = c = d = e = f = g = h = T1 = T2 = 0;
 777 }
 778
 779 #endif /* SHA2_UNROLL_TRANSFORM */
 780
 781 void SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
 782         unsigned int    freespace, usedspace;
 783
 784         if (len == 0) {
 785                 /* Calling with no data is valid - we do nothing */
 786                 return;
 787         }
 788
 789         /* Sanity check: */
 790         assert(context != NULL && data != NULL);
 791
 792         usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
 793         if (usedspace > 0) {
 794                 /* Calculate how much free space is available in the buffer */
 795                 freespace = SHA512_BLOCK_LENGTH - usedspace;
 796
 797                 if (len >= freespace) {
 798                         /* Fill the buffer completely and process it */
 799                         MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace);
 800                         ADDINC128(context->bitcount, freespace << 3);
 801                         len -= freespace;
 802                         data += freespace;
 803                         SHA512_Transform(context, (sha2_word64*)context->buffer);
 804                 } else {
 805                         /* The buffer is not yet full */
 806                         MEMCPY_BCOPY(&context->buffer[usedspace], data, len);
 807                         ADDINC128(context->bitcount, len << 3);
 808                         /* Clean up: */
 809                         usedspace = freespace = 0;
 810                         return;
 811                 }
 812         }
 813         while (len >= SHA512_BLOCK_LENGTH) {
 814                 /* Process as many complete blocks as we can */
 815                 SHA512_Transform(context, (const sha2_word64*)data);
 816                 ADDINC128(context->bitcount, SHA512_BLOCK_LENGTH << 3);
 817                 len -= SHA512_BLOCK_LENGTH;
 818                 data += SHA512_BLOCK_LENGTH;
 819         }
 820         if (len > 0) {
 821                 /* There's left-overs, so save 'em */
 822                 MEMCPY_BCOPY(context->buffer, data, len);
 823                 ADDINC128(context->bitcount, len << 3);
 824         }
 825         /* Clean up: */
 826         usedspace = freespace = 0;
 827 }
 828
 829 void SHA512_Last(SHA512_CTX* context) {
 830         unsigned int    usedspace;
 831
 832         usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
 833 #ifndef WORDS_BIGENDIAN
 834         /* Convert FROM host byte order */
 835         REVERSE64(context->bitcount[0],context->bitcount[0]);
 836         REVERSE64(context->bitcount[1],context->bitcount[1]);
 837 #endif
 838         if (usedspace > 0) {
 839                 /* Begin padding with a 1 bit: */
 840                 context->buffer[usedspace++] = 0x80;
 841
 842                 if (usedspace <= SHA512_SHORT_BLOCK_LENGTH) {
 843                         /* Set-up for the last transform: */
 844                         MEMSET_BZERO(&context->buffer[usedspace], SHA512_SHORT_BLOCK_LENGTH - usedspace);
 845                 } else {
 846                         if (usedspace < SHA512_BLOCK_LENGTH) {
 847                                 MEMSET_BZERO(&context->buffer[usedspace], SHA512_BLOCK_LENGTH - usedspace);
 848                         }
 849                         /* Do second-to-last transform: */
 850                         SHA512_Transform(context, (sha2_word64*)context->buffer);
 851
 852                         /* And set-up for the last transform: */
 853                         MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH - 2);
 854                 }
 855         } else {
 856                 /* Prepare for final transform: */
 857                 MEMSET_BZERO(context->buffer, SHA512_SHORT_BLOCK_LENGTH);
 858
 859                 /* Begin padding with a 1 bit: */
 860                 *context->buffer = 0x80;
 861         }
 862         /* Store the length of input data (in bits): */
 863         *(sha2_word64*)&context->buffer[SHA512_SHORT_BLOCK_LENGTH] = context->bitcount[1];
 864         *(sha2_word64*)&context->buffer[SHA512_SHORT_BLOCK_LENGTH+8] = context->bitcount[0];
 865
 866         /* Final transform: */
 867         SHA512_Transform(context, (sha2_word64*)context->buffer);
 868 }
 869
 870 void SHA512_Final(sha2_byte digest[], SHA512_CTX* context) {
 871         sha2_word64     *d = (sha2_word64*)digest;
 872
 873         /* Sanity check: */
 874         assert(context != NULL);
 875
 876         /* If no digest buffer is passed, we don't bother doing this: */
 877         if (digest != NULL) {
 878                 SHA512_Last(context);
 879
 880                 /* Save the hash data for output: */
 881 #ifndef WORDS_BIGENDIAN
 882                 {
 883                         /* Convert TO host byte order */
 884                         int     j;
 885                         for (j = 0; j < 8; j++) {
 886                                 REVERSE64(context->state[j],context->state[j]);
 887                                 *d++ = context->state[j];
 888                         }
 889                 }
 890 #else
 891                 MEMCPY_BCOPY(d, context->state, SHA512_DIGEST_LENGTH);
 892 #endif
 893         }
 894
 895         /* Zero out state data */
 896         MEMSET_BZERO(context, sizeof(context));
 897 }
 898
 899 char *SHA512_End(SHA512_CTX* context, char buffer[]) {
 900         sha2_byte       digest[SHA512_DIGEST_LENGTH], *d = digest;
 901         int             i;
 902
 903         /* Sanity check: */
 904         assert(context != NULL);
 905
 906         if (buffer != NULL) {
 907                 SHA512_Final(digest, context);
 908
 909                 for (i = 0; i < SHA512_DIGEST_LENGTH; i++) {
 910                         *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
 911                         *buffer++ = sha2_hex_digits[*d & 0x0f];
 912                         d++;
 913                 }
 914                 *buffer = 0;
 915         } else {
 916                 MEMSET_BZERO(context, sizeof(context));
 917         }
 918         MEMSET_BZERO(digest, SHA512_DIGEST_LENGTH);
 919         return buffer;
 920 }
 921
 922 char* SHA512_Data(const sha2_byte* data, size_t len, char digest[SHA512_DIGEST_STRING_LENGTH]) {
 923         SHA512_CTX      context;
 924
 925         SHA512_Init(&context);
 926         SHA512_Update(&context, data, len);
 927         return SHA512_End(&context, digest);
 928 }
 929
 930
 931 /*** SHA-384: *********************************************************/
 932 void SHA384_Init(SHA384_CTX* context) {
 933         if (context == NULL) {
 934                 return;
 935         }
 936         MEMCPY_BCOPY(context->state, sha384_initial_hash_value, SHA512_DIGEST_LENGTH);
 937         MEMSET_BZERO(context->buffer, SHA384_BLOCK_LENGTH);
 938         context->bitcount[0] = context->bitcount[1] = 0;
 939 }
 940
 941 void SHA384_Update(SHA384_CTX* context, const sha2_byte* data, size_t len) {
 942         SHA512_Update((SHA512_CTX*)context, data, len);
 943 }
 944
 945 void SHA384_Final(sha2_byte digest[], SHA384_CTX* context) {
 946         sha2_word64     *d = (sha2_word64*)digest;
 947
 948         /* Sanity check: */
 949         assert(context != NULL);
 950
 951         /* If no digest buffer is passed, we don't bother doing this: */
 952         if (digest != NULL) {
 953                 SHA512_Last((SHA512_CTX*)context);
 954
 955                 /* Save the hash data for output: */
 956 #ifndef WORDS_BIGENDIAN
 957                 {
 958                         /* Convert TO host byte order */
 959                         int     j;
 960                         for (j = 0; j < 6; j++) {
 961                                 REVERSE64(context->state[j],context->state[j]);
 962                                 *d++ = context->state[j];
 963                         }
 964                 }
 965 #else
 966                 MEMCPY_BCOPY(d, context->state, SHA384_DIGEST_LENGTH);
 967 #endif
 968         }
 969
 970         /* Zero out state data */
 971         MEMSET_BZERO(context, sizeof(context));
 972 }
 973
 974 char *SHA384_End(SHA384_CTX* context, char buffer[]) {
 975         sha2_byte       digest[SHA384_DIGEST_LENGTH], *d = digest;
 976         int             i;
 977
 978         /* Sanity check: */
 979         assert(context != NULL);
 980
 981         if (buffer != NULL) {
 982                 SHA384_Final(digest, context);
 983
 984                 for (i = 0; i < SHA384_DIGEST_LENGTH; i++) {
 985                         *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
 986                         *buffer++ = sha2_hex_digits[*d & 0x0f];
 987                         d++;
 988                 }
 989                 *buffer = 0;
 990         } else {
 991                 MEMSET_BZERO(context, sizeof(context));
 992         }
 993         MEMSET_BZERO(digest, SHA384_DIGEST_LENGTH);
 994         return buffer;
 995 }
 996
 997 char* SHA384_Data(const sha2_byte* data, size_t len, char digest[SHA384_DIGEST_STRING_LENGTH]) {
 998         SHA384_CTX      context;
 999
1000         SHA384_Init(&context);
1001         SHA384_Update(&context, data, len);
1002         return SHA384_End(&context, digest);
1003 }