1 /* 2 * sha512.c - implementation of SHA256, SHA384 and SHA512 3 * 4 * ***** BEGIN LICENSE BLOCK ***** 5 * Version: MPL 1.1/GPL 2.0/LGPL 2.1 6 * 7 * The contents of this file are subject to the Mozilla Public License Version 8 * 1.1 (the "License"); you may not use this file except in compliance with 9 * the License. You may obtain a copy of the License at 10 * http://www.mozilla.org/MPL/ 11 * 12 * Software distributed under the License is distributed on an "AS IS" basis, 13 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License 14 * for the specific language governing rights and limitations under the 15 * License. 16 * 17 * The Original Code is the Netscape security libraries. 18 * 19 * The Initial Developer of the Original Code is 20 * Netscape Communications Corporation. 21 * Portions created by the Initial Developer are Copyright (C) 2002 22 * the Initial Developer. All Rights Reserved. 23 * 24 * Contributor(s): 25 * 26 * Alternatively, the contents of this file may be used under the terms of 27 * either the GNU General Public License Version 2 or later (the "GPL"), or 28 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), 29 * in which case the provisions of the GPL or the LGPL are applicable instead 30 * of those above. If you wish to allow use of your version of this file only 31 * under the terms of either the GPL or the LGPL, and not to allow others to 32 * use your version of this file under the terms of the MPL, indicate your 33 * decision by deleting the provisions above and replace them with the notice 34 * and other provisions required by the GPL or the LGPL. If you do not delete 35 * the provisions above, a recipient may use your version of this file under 36 * the terms of any one of the MPL, the GPL or the LGPL. 37 * 38 * ***** END LICENSE BLOCK ***** */ 39 /* $Id: sha512.c,v 1.9 2006/10/13 16:54:04 wtchang%redhat.com Exp $ */ 40 41 // Prevent manual unrolling in the sha256 code, which reduces the binary code 42 // size from ~10k to ~1k. The performance should be reasonable for our use. 43 #define NOUNROLL256 1 44 45 #include "base/third_party/nspr/prtypes.h" /* for PRUintXX */ 46 #if defined(_X86_) || defined(SHA_NO_LONG_LONG) 47 #define NOUNROLL512 1 48 #undef HAVE_LONG_LONG 49 #endif 50 #include "crypto/third_party/nss/blapi.h" 51 #include "crypto/third_party/nss/sha256.h" /* for struct SHA256ContextStr */ 52 53 #include <stdlib.h> 54 #include <string.h> 55 #define PORT_New(type) static_cast<type*>(malloc(sizeof(type))) 56 #define PORT_ZFree(ptr, len) do { memset(ptr, 0, len); free(ptr); } while (0) 57 #define PORT_Strlen(s) static_cast<unsigned int>(strlen(s)) 58 #define PORT_Memcpy memcpy 59 60 /* ============= Common constants and defines ======================= */ 61 62 #define W ctx->u.w 63 #define B ctx->u.b 64 #define H ctx->h 65 66 #define SHR(x,n) (x >> n) 67 #define SHL(x,n) (x << n) 68 #define Ch(x,y,z) ((x & y) ^ (~x & z)) 69 #define Maj(x,y,z) ((x & y) ^ (x & z) ^ (y & z)) 70 71 /* Padding used with all flavors of SHA */ 72 static const PRUint8 pad[240] = { 73 0x80,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 74 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 75 /* compiler will fill the rest in with zeros */ 76 }; 77 78 /* ============= SHA256 implemenmtation ================================== */ 79 80 /* SHA-256 constants, K256. */ 81 static const PRUint32 K256[64] = { 82 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 83 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 84 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 85 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 86 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 87 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 88 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 89 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 90 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 91 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 92 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 93 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 94 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 95 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 96 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 97 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 98 }; 99 100 /* SHA-256 initial hash values */ 101 static const PRUint32 H256[8] = { 102 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 103 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 104 }; 105 106 #if defined(_MSC_VER) && defined(_X86_) 107 #ifndef FORCEINLINE 108 #if (_MSC_VER >= 1200) 109 #define FORCEINLINE __forceinline 110 #else 111 #define FORCEINLINE __inline 112 #endif 113 #endif 114 #define FASTCALL __fastcall 115 116 static FORCEINLINE PRUint32 FASTCALL 117 swap4b(PRUint32 dwd) 118 { 119 __asm { 120 mov eax,dwd 121 bswap eax 122 } 123 } 124 125 #define SHA_HTONL(x) swap4b(x) 126 #define BYTESWAP4(x) x = SHA_HTONL(x) 127 128 #elif defined(LINUX) && defined(_X86_) 129 #undef __OPTIMIZE__ 130 #define __OPTIMIZE__ 1 131 #undef __pentium__ 132 #define __pentium__ 1 133 #include <byteswap.h> 134 #define SHA_HTONL(x) bswap_32(x) 135 #define BYTESWAP4(x) x = SHA_HTONL(x) 136 137 #else /* neither windows nor Linux PC */ 138 #define SWAP4MASK 0x00FF00FF 139 #define SHA_HTONL(x) (t1 = (x), t1 = (t1 << 16) | (t1 >> 16), \ 140 ((t1 & SWAP4MASK) << 8) | ((t1 >> 8) & SWAP4MASK)) 141 #define BYTESWAP4(x) x = SHA_HTONL(x) 142 #endif 143 144 #if defined(_MSC_VER) && defined(_X86_) 145 #pragma intrinsic (_lrotr, _lrotl) 146 #define ROTR32(x,n) _lrotr(x,n) 147 #define ROTL32(x,n) _lrotl(x,n) 148 #else 149 #define ROTR32(x,n) ((x >> n) | (x << ((8 * sizeof x) - n))) 150 #define ROTL32(x,n) ((x << n) | (x >> ((8 * sizeof x) - n))) 151 #endif 152 153 /* Capitol Sigma and lower case sigma functions */ 154 #define S0(x) (ROTR32(x, 2) ^ ROTR32(x,13) ^ ROTR32(x,22)) 155 #define S1(x) (ROTR32(x, 6) ^ ROTR32(x,11) ^ ROTR32(x,25)) 156 #define s0(x) (t1 = x, ROTR32(t1, 7) ^ ROTR32(t1,18) ^ SHR(t1, 3)) 157 #define s1(x) (t2 = x, ROTR32(t2,17) ^ ROTR32(t2,19) ^ SHR(t2,10)) 158 159 SHA256Context * 160 SHA256_NewContext(void) 161 { 162 SHA256Context *ctx = PORT_New(SHA256Context); 163 return ctx; 164 } 165 166 void 167 SHA256_DestroyContext(SHA256Context *ctx, PRBool freeit) 168 { 169 if (freeit) { 170 PORT_ZFree(ctx, sizeof *ctx); 171 } 172 } 173 174 void 175 SHA256_Begin(SHA256Context *ctx) 176 { 177 memset(ctx, 0, sizeof *ctx); 178 memcpy(H, H256, sizeof H256); 179 } 180 181 static void 182 SHA256_Compress(SHA256Context *ctx) 183 { 184 { 185 register PRUint32 t1, t2; 186 187 #if defined(IS_LITTLE_ENDIAN) 188 BYTESWAP4(W[0]); 189 BYTESWAP4(W[1]); 190 BYTESWAP4(W[2]); 191 BYTESWAP4(W[3]); 192 BYTESWAP4(W[4]); 193 BYTESWAP4(W[5]); 194 BYTESWAP4(W[6]); 195 BYTESWAP4(W[7]); 196 BYTESWAP4(W[8]); 197 BYTESWAP4(W[9]); 198 BYTESWAP4(W[10]); 199 BYTESWAP4(W[11]); 200 BYTESWAP4(W[12]); 201 BYTESWAP4(W[13]); 202 BYTESWAP4(W[14]); 203 BYTESWAP4(W[15]); 204 #endif 205 206 #define INITW(t) W[t] = (s1(W[t-2]) + W[t-7] + s0(W[t-15]) + W[t-16]) 207 208 /* prepare the "message schedule" */ 209 #ifdef NOUNROLL256 210 { 211 int t; 212 for (t = 16; t < 64; ++t) { 213 INITW(t); 214 } 215 } 216 #else 217 INITW(16); 218 INITW(17); 219 INITW(18); 220 INITW(19); 221 222 INITW(20); 223 INITW(21); 224 INITW(22); 225 INITW(23); 226 INITW(24); 227 INITW(25); 228 INITW(26); 229 INITW(27); 230 INITW(28); 231 INITW(29); 232 233 INITW(30); 234 INITW(31); 235 INITW(32); 236 INITW(33); 237 INITW(34); 238 INITW(35); 239 INITW(36); 240 INITW(37); 241 INITW(38); 242 INITW(39); 243 244 INITW(40); 245 INITW(41); 246 INITW(42); 247 INITW(43); 248 INITW(44); 249 INITW(45); 250 INITW(46); 251 INITW(47); 252 INITW(48); 253 INITW(49); 254 255 INITW(50); 256 INITW(51); 257 INITW(52); 258 INITW(53); 259 INITW(54); 260 INITW(55); 261 INITW(56); 262 INITW(57); 263 INITW(58); 264 INITW(59); 265 266 INITW(60); 267 INITW(61); 268 INITW(62); 269 INITW(63); 270 271 #endif 272 #undef INITW 273 } 274 { 275 PRUint32 a, b, c, d, e, f, g, h; 276 277 a = H[0]; 278 b = H[1]; 279 c = H[2]; 280 d = H[3]; 281 e = H[4]; 282 f = H[5]; 283 g = H[6]; 284 h = H[7]; 285 286 #define ROUND(n,a,b,c,d,e,f,g,h) \ 287 h += S1(e) + Ch(e,f,g) + K256[n] + W[n]; \ 288 d += h; \ 289 h += S0(a) + Maj(a,b,c); 290 291 #ifdef NOUNROLL256 292 { 293 int t; 294 for (t = 0; t < 64; t+= 8) { 295 ROUND(t+0,a,b,c,d,e,f,g,h) 296 ROUND(t+1,h,a,b,c,d,e,f,g) 297 ROUND(t+2,g,h,a,b,c,d,e,f) 298 ROUND(t+3,f,g,h,a,b,c,d,e) 299 ROUND(t+4,e,f,g,h,a,b,c,d) 300 ROUND(t+5,d,e,f,g,h,a,b,c) 301 ROUND(t+6,c,d,e,f,g,h,a,b) 302 ROUND(t+7,b,c,d,e,f,g,h,a) 303 } 304 } 305 #else 306 ROUND( 0,a,b,c,d,e,f,g,h) 307 ROUND( 1,h,a,b,c,d,e,f,g) 308 ROUND( 2,g,h,a,b,c,d,e,f) 309 ROUND( 3,f,g,h,a,b,c,d,e) 310 ROUND( 4,e,f,g,h,a,b,c,d) 311 ROUND( 5,d,e,f,g,h,a,b,c) 312 ROUND( 6,c,d,e,f,g,h,a,b) 313 ROUND( 7,b,c,d,e,f,g,h,a) 314 315 ROUND( 8,a,b,c,d,e,f,g,h) 316 ROUND( 9,h,a,b,c,d,e,f,g) 317 ROUND(10,g,h,a,b,c,d,e,f) 318 ROUND(11,f,g,h,a,b,c,d,e) 319 ROUND(12,e,f,g,h,a,b,c,d) 320 ROUND(13,d,e,f,g,h,a,b,c) 321 ROUND(14,c,d,e,f,g,h,a,b) 322 ROUND(15,b,c,d,e,f,g,h,a) 323 324 ROUND(16,a,b,c,d,e,f,g,h) 325 ROUND(17,h,a,b,c,d,e,f,g) 326 ROUND(18,g,h,a,b,c,d,e,f) 327 ROUND(19,f,g,h,a,b,c,d,e) 328 ROUND(20,e,f,g,h,a,b,c,d) 329 ROUND(21,d,e,f,g,h,a,b,c) 330 ROUND(22,c,d,e,f,g,h,a,b) 331 ROUND(23,b,c,d,e,f,g,h,a) 332 333 ROUND(24,a,b,c,d,e,f,g,h) 334 ROUND(25,h,a,b,c,d,e,f,g) 335 ROUND(26,g,h,a,b,c,d,e,f) 336 ROUND(27,f,g,h,a,b,c,d,e) 337 ROUND(28,e,f,g,h,a,b,c,d) 338 ROUND(29,d,e,f,g,h,a,b,c) 339 ROUND(30,c,d,e,f,g,h,a,b) 340 ROUND(31,b,c,d,e,f,g,h,a) 341 342 ROUND(32,a,b,c,d,e,f,g,h) 343 ROUND(33,h,a,b,c,d,e,f,g) 344 ROUND(34,g,h,a,b,c,d,e,f) 345 ROUND(35,f,g,h,a,b,c,d,e) 346 ROUND(36,e,f,g,h,a,b,c,d) 347 ROUND(37,d,e,f,g,h,a,b,c) 348 ROUND(38,c,d,e,f,g,h,a,b) 349 ROUND(39,b,c,d,e,f,g,h,a) 350 351 ROUND(40,a,b,c,d,e,f,g,h) 352 ROUND(41,h,a,b,c,d,e,f,g) 353 ROUND(42,g,h,a,b,c,d,e,f) 354 ROUND(43,f,g,h,a,b,c,d,e) 355 ROUND(44,e,f,g,h,a,b,c,d) 356 ROUND(45,d,e,f,g,h,a,b,c) 357 ROUND(46,c,d,e,f,g,h,a,b) 358 ROUND(47,b,c,d,e,f,g,h,a) 359 360 ROUND(48,a,b,c,d,e,f,g,h) 361 ROUND(49,h,a,b,c,d,e,f,g) 362 ROUND(50,g,h,a,b,c,d,e,f) 363 ROUND(51,f,g,h,a,b,c,d,e) 364 ROUND(52,e,f,g,h,a,b,c,d) 365 ROUND(53,d,e,f,g,h,a,b,c) 366 ROUND(54,c,d,e,f,g,h,a,b) 367 ROUND(55,b,c,d,e,f,g,h,a) 368 369 ROUND(56,a,b,c,d,e,f,g,h) 370 ROUND(57,h,a,b,c,d,e,f,g) 371 ROUND(58,g,h,a,b,c,d,e,f) 372 ROUND(59,f,g,h,a,b,c,d,e) 373 ROUND(60,e,f,g,h,a,b,c,d) 374 ROUND(61,d,e,f,g,h,a,b,c) 375 ROUND(62,c,d,e,f,g,h,a,b) 376 ROUND(63,b,c,d,e,f,g,h,a) 377 #endif 378 379 H[0] += a; 380 H[1] += b; 381 H[2] += c; 382 H[3] += d; 383 H[4] += e; 384 H[5] += f; 385 H[6] += g; 386 H[7] += h; 387 } 388 #undef ROUND 389 } 390 391 #undef s0 392 #undef s1 393 #undef S0 394 #undef S1 395 396 void 397 SHA256_Update(SHA256Context *ctx, const unsigned char *input, 398 unsigned int inputLen) 399 { 400 unsigned int inBuf = ctx->sizeLo & 0x3f; 401 if (!inputLen) 402 return; 403 404 /* Add inputLen into the count of bytes processed, before processing */ 405 if ((ctx->sizeLo += inputLen) < inputLen) 406 ctx->sizeHi++; 407 408 /* if data already in buffer, attemp to fill rest of buffer */ 409 if (inBuf) { 410 unsigned int todo = SHA256_BLOCK_LENGTH - inBuf; 411 if (inputLen < todo) 412 todo = inputLen; 413 memcpy(B + inBuf, input, todo); 414 input += todo; 415 inputLen -= todo; 416 if (inBuf + todo == SHA256_BLOCK_LENGTH) 417 SHA256_Compress(ctx); 418 } 419 420 /* if enough data to fill one or more whole buffers, process them. */ 421 while (inputLen >= SHA256_BLOCK_LENGTH) { 422 memcpy(B, input, SHA256_BLOCK_LENGTH); 423 input += SHA256_BLOCK_LENGTH; 424 inputLen -= SHA256_BLOCK_LENGTH; 425 SHA256_Compress(ctx); 426 } 427 /* if data left over, fill it into buffer */ 428 if (inputLen) 429 memcpy(B, input, inputLen); 430 } 431 432 void 433 SHA256_End(SHA256Context *ctx, unsigned char *digest, 434 unsigned int *digestLen, unsigned int maxDigestLen) 435 { 436 unsigned int inBuf = ctx->sizeLo & 0x3f; 437 unsigned int padLen = (inBuf < 56) ? (56 - inBuf) : (56 + 64 - inBuf); 438 PRUint32 hi, lo; 439 #ifdef SWAP4MASK 440 PRUint32 t1; 441 #endif 442 443 hi = (ctx->sizeHi << 3) | (ctx->sizeLo >> 29); 444 lo = (ctx->sizeLo << 3); 445 446 SHA256_Update(ctx, pad, padLen); 447 448 #if defined(IS_LITTLE_ENDIAN) 449 W[14] = SHA_HTONL(hi); 450 W[15] = SHA_HTONL(lo); 451 #else 452 W[14] = hi; 453 W[15] = lo; 454 #endif 455 SHA256_Compress(ctx); 456 457 /* now output the answer */ 458 #if defined(IS_LITTLE_ENDIAN) 459 BYTESWAP4(H[0]); 460 BYTESWAP4(H[1]); 461 BYTESWAP4(H[2]); 462 BYTESWAP4(H[3]); 463 BYTESWAP4(H[4]); 464 BYTESWAP4(H[5]); 465 BYTESWAP4(H[6]); 466 BYTESWAP4(H[7]); 467 #endif 468 padLen = PR_MIN(SHA256_LENGTH, maxDigestLen); 469 memcpy(digest, H, padLen); 470 if (digestLen) 471 *digestLen = padLen; 472 } 473 474 /* Comment out unused code, mostly the SHA384 and SHA512 implementations. */ 475 #if 0 476 SECStatus 477 SHA256_HashBuf(unsigned char *dest, const unsigned char *src, 478 unsigned int src_length) 479 { 480 SHA256Context ctx; 481 unsigned int outLen; 482 483 SHA256_Begin(&ctx); 484 SHA256_Update(&ctx, src, src_length); 485 SHA256_End(&ctx, dest, &outLen, SHA256_LENGTH); 486 487 return SECSuccess; 488 } 489 490 491 SECStatus 492 SHA256_Hash(unsigned char *dest, const char *src) 493 { 494 return SHA256_HashBuf(dest, (const unsigned char *)src, PORT_Strlen(src)); 495 } 496 497 498 void SHA256_TraceState(SHA256Context *ctx) { } 499 500 unsigned int 501 SHA256_FlattenSize(SHA256Context *ctx) 502 { 503 return sizeof *ctx; 504 } 505 506 SECStatus 507 SHA256_Flatten(SHA256Context *ctx,unsigned char *space) 508 { 509 PORT_Memcpy(space, ctx, sizeof *ctx); 510 return SECSuccess; 511 } 512 513 SHA256Context * 514 SHA256_Resurrect(unsigned char *space, void *arg) 515 { 516 SHA256Context *ctx = SHA256_NewContext(); 517 if (ctx) 518 PORT_Memcpy(ctx, space, sizeof *ctx); 519 return ctx; 520 } 521 522 void SHA256_Clone(SHA256Context *dest, SHA256Context *src) 523 { 524 memcpy(dest, src, sizeof *dest); 525 } 526 527 528 /* ======= SHA512 and SHA384 common constants and defines ================= */ 529 530 /* common #defines for SHA512 and SHA384 */ 531 #if defined(HAVE_LONG_LONG) 532 #define ROTR64(x,n) ((x >> n) | (x << (64 - n))) 533 #define ROTL64(x,n) ((x << n) | (x >> (64 - n))) 534 535 #define S0(x) (ROTR64(x,28) ^ ROTR64(x,34) ^ ROTR64(x,39)) 536 #define S1(x) (ROTR64(x,14) ^ ROTR64(x,18) ^ ROTR64(x,41)) 537 #define s0(x) (t1 = x, ROTR64(t1, 1) ^ ROTR64(t1, 8) ^ SHR(t1,7)) 538 #define s1(x) (t2 = x, ROTR64(t2,19) ^ ROTR64(t2,61) ^ SHR(t2,6)) 539 540 #if PR_BYTES_PER_LONG == 8 541 #define ULLC(hi,lo) 0x ## hi ## lo ## UL 542 #elif defined(_MSC_VER) 543 #define ULLC(hi,lo) 0x ## hi ## lo ## ui64 544 #else 545 #define ULLC(hi,lo) 0x ## hi ## lo ## ULL 546 #endif 547 548 #define SHA_MASK16 ULLC(0000FFFF,0000FFFF) 549 #define SHA_MASK8 ULLC(00FF00FF,00FF00FF) 550 #define SHA_HTONLL(x) (t1 = x, \ 551 t1 = ((t1 & SHA_MASK8 ) << 8) | ((t1 >> 8) & SHA_MASK8 ), \ 552 t1 = ((t1 & SHA_MASK16) << 16) | ((t1 >> 16) & SHA_MASK16), \ 553 (t1 >> 32) | (t1 << 32)) 554 #define BYTESWAP8(x) x = SHA_HTONLL(x) 555 556 #else /* no long long */ 557 558 #if defined(IS_LITTLE_ENDIAN) 559 #define ULLC(hi,lo) { 0x ## lo ## U, 0x ## hi ## U } 560 #else 561 #define ULLC(hi,lo) { 0x ## hi ## U, 0x ## lo ## U } 562 #endif 563 564 #define SHA_HTONLL(x) ( BYTESWAP4(x.lo), BYTESWAP4(x.hi), \ 565 x.hi ^= x.lo ^= x.hi ^= x.lo, x) 566 #define BYTESWAP8(x) do { PRUint32 tmp; BYTESWAP4(x.lo); BYTESWAP4(x.hi); \ 567 tmp = x.lo; x.lo = x.hi; x.hi = tmp; } while (0) 568 #endif 569 570 /* SHA-384 and SHA-512 constants, K512. */ 571 static const PRUint64 K512[80] = { 572 #if PR_BYTES_PER_LONG == 8 573 0x428a2f98d728ae22UL , 0x7137449123ef65cdUL , 574 0xb5c0fbcfec4d3b2fUL , 0xe9b5dba58189dbbcUL , 575 0x3956c25bf348b538UL , 0x59f111f1b605d019UL , 576 0x923f82a4af194f9bUL , 0xab1c5ed5da6d8118UL , 577 0xd807aa98a3030242UL , 0x12835b0145706fbeUL , 578 0x243185be4ee4b28cUL , 0x550c7dc3d5ffb4e2UL , 579 0x72be5d74f27b896fUL , 0x80deb1fe3b1696b1UL , 580 0x9bdc06a725c71235UL , 0xc19bf174cf692694UL , 581 0xe49b69c19ef14ad2UL , 0xefbe4786384f25e3UL , 582 0x0fc19dc68b8cd5b5UL , 0x240ca1cc77ac9c65UL , 583 0x2de92c6f592b0275UL , 0x4a7484aa6ea6e483UL , 584 0x5cb0a9dcbd41fbd4UL , 0x76f988da831153b5UL , 585 0x983e5152ee66dfabUL , 0xa831c66d2db43210UL , 586 0xb00327c898fb213fUL , 0xbf597fc7beef0ee4UL , 587 0xc6e00bf33da88fc2UL , 0xd5a79147930aa725UL , 588 0x06ca6351e003826fUL , 0x142929670a0e6e70UL , 589 0x27b70a8546d22ffcUL , 0x2e1b21385c26c926UL , 590 0x4d2c6dfc5ac42aedUL , 0x53380d139d95b3dfUL , 591 0x650a73548baf63deUL , 0x766a0abb3c77b2a8UL , 592 0x81c2c92e47edaee6UL , 0x92722c851482353bUL , 593 0xa2bfe8a14cf10364UL , 0xa81a664bbc423001UL , 594 0xc24b8b70d0f89791UL , 0xc76c51a30654be30UL , 595 0xd192e819d6ef5218UL , 0xd69906245565a910UL , 596 0xf40e35855771202aUL , 0x106aa07032bbd1b8UL , 597 0x19a4c116b8d2d0c8UL , 0x1e376c085141ab53UL , 598 0x2748774cdf8eeb99UL , 0x34b0bcb5e19b48a8UL , 599 0x391c0cb3c5c95a63UL , 0x4ed8aa4ae3418acbUL , 600 0x5b9cca4f7763e373UL , 0x682e6ff3d6b2b8a3UL , 601 0x748f82ee5defb2fcUL , 0x78a5636f43172f60UL , 602 0x84c87814a1f0ab72UL , 0x8cc702081a6439ecUL , 603 0x90befffa23631e28UL , 0xa4506cebde82bde9UL , 604 0xbef9a3f7b2c67915UL , 0xc67178f2e372532bUL , 605 0xca273eceea26619cUL , 0xd186b8c721c0c207UL , 606 0xeada7dd6cde0eb1eUL , 0xf57d4f7fee6ed178UL , 607 0x06f067aa72176fbaUL , 0x0a637dc5a2c898a6UL , 608 0x113f9804bef90daeUL , 0x1b710b35131c471bUL , 609 0x28db77f523047d84UL , 0x32caab7b40c72493UL , 610 0x3c9ebe0a15c9bebcUL , 0x431d67c49c100d4cUL , 611 0x4cc5d4becb3e42b6UL , 0x597f299cfc657e2aUL , 612 0x5fcb6fab3ad6faecUL , 0x6c44198c4a475817UL 613 #else 614 ULLC(428a2f98,d728ae22), ULLC(71374491,23ef65cd), 615 ULLC(b5c0fbcf,ec4d3b2f), ULLC(e9b5dba5,8189dbbc), 616 ULLC(3956c25b,f348b538), ULLC(59f111f1,b605d019), 617 ULLC(923f82a4,af194f9b), ULLC(ab1c5ed5,da6d8118), 618 ULLC(d807aa98,a3030242), ULLC(12835b01,45706fbe), 619 ULLC(243185be,4ee4b28c), ULLC(550c7dc3,d5ffb4e2), 620 ULLC(72be5d74,f27b896f), ULLC(80deb1fe,3b1696b1), 621 ULLC(9bdc06a7,25c71235), ULLC(c19bf174,cf692694), 622 ULLC(e49b69c1,9ef14ad2), ULLC(efbe4786,384f25e3), 623 ULLC(0fc19dc6,8b8cd5b5), ULLC(240ca1cc,77ac9c65), 624 ULLC(2de92c6f,592b0275), ULLC(4a7484aa,6ea6e483), 625 ULLC(5cb0a9dc,bd41fbd4), ULLC(76f988da,831153b5), 626 ULLC(983e5152,ee66dfab), ULLC(a831c66d,2db43210), 627 ULLC(b00327c8,98fb213f), ULLC(bf597fc7,beef0ee4), 628 ULLC(c6e00bf3,3da88fc2), ULLC(d5a79147,930aa725), 629 ULLC(06ca6351,e003826f), ULLC(14292967,0a0e6e70), 630 ULLC(27b70a85,46d22ffc), ULLC(2e1b2138,5c26c926), 631 ULLC(4d2c6dfc,5ac42aed), ULLC(53380d13,9d95b3df), 632 ULLC(650a7354,8baf63de), ULLC(766a0abb,3c77b2a8), 633 ULLC(81c2c92e,47edaee6), ULLC(92722c85,1482353b), 634 ULLC(a2bfe8a1,4cf10364), ULLC(a81a664b,bc423001), 635 ULLC(c24b8b70,d0f89791), ULLC(c76c51a3,0654be30), 636 ULLC(d192e819,d6ef5218), ULLC(d6990624,5565a910), 637 ULLC(f40e3585,5771202a), ULLC(106aa070,32bbd1b8), 638 ULLC(19a4c116,b8d2d0c8), ULLC(1e376c08,5141ab53), 639 ULLC(2748774c,df8eeb99), ULLC(34b0bcb5,e19b48a8), 640 ULLC(391c0cb3,c5c95a63), ULLC(4ed8aa4a,e3418acb), 641 ULLC(5b9cca4f,7763e373), ULLC(682e6ff3,d6b2b8a3), 642 ULLC(748f82ee,5defb2fc), ULLC(78a5636f,43172f60), 643 ULLC(84c87814,a1f0ab72), ULLC(8cc70208,1a6439ec), 644 ULLC(90befffa,23631e28), ULLC(a4506ceb,de82bde9), 645 ULLC(bef9a3f7,b2c67915), ULLC(c67178f2,e372532b), 646 ULLC(ca273ece,ea26619c), ULLC(d186b8c7,21c0c207), 647 ULLC(eada7dd6,cde0eb1e), ULLC(f57d4f7f,ee6ed178), 648 ULLC(06f067aa,72176fba), ULLC(0a637dc5,a2c898a6), 649 ULLC(113f9804,bef90dae), ULLC(1b710b35,131c471b), 650 ULLC(28db77f5,23047d84), ULLC(32caab7b,40c72493), 651 ULLC(3c9ebe0a,15c9bebc), ULLC(431d67c4,9c100d4c), 652 ULLC(4cc5d4be,cb3e42b6), ULLC(597f299c,fc657e2a), 653 ULLC(5fcb6fab,3ad6faec), ULLC(6c44198c,4a475817) 654 #endif 655 }; 656 657 struct SHA512ContextStr { 658 union { 659 PRUint64 w[80]; /* message schedule, input buffer, plus 64 words */ 660 PRUint32 l[160]; 661 PRUint8 b[640]; 662 } u; 663 PRUint64 h[8]; /* 8 state variables */ 664 PRUint64 sizeLo; /* 64-bit count of hashed bytes. */ 665 }; 666 667 /* =========== SHA512 implementation ===================================== */ 668 669 /* SHA-512 initial hash values */ 670 static const PRUint64 H512[8] = { 671 #if PR_BYTES_PER_LONG == 8 672 0x6a09e667f3bcc908UL , 0xbb67ae8584caa73bUL , 673 0x3c6ef372fe94f82bUL , 0xa54ff53a5f1d36f1UL , 674 0x510e527fade682d1UL , 0x9b05688c2b3e6c1fUL , 675 0x1f83d9abfb41bd6bUL , 0x5be0cd19137e2179UL 676 #else 677 ULLC(6a09e667,f3bcc908), ULLC(bb67ae85,84caa73b), 678 ULLC(3c6ef372,fe94f82b), ULLC(a54ff53a,5f1d36f1), 679 ULLC(510e527f,ade682d1), ULLC(9b05688c,2b3e6c1f), 680 ULLC(1f83d9ab,fb41bd6b), ULLC(5be0cd19,137e2179) 681 #endif 682 }; 683 684 685 SHA512Context * 686 SHA512_NewContext(void) 687 { 688 SHA512Context *ctx = PORT_New(SHA512Context); 689 return ctx; 690 } 691 692 void 693 SHA512_DestroyContext(SHA512Context *ctx, PRBool freeit) 694 { 695 if (freeit) { 696 PORT_ZFree(ctx, sizeof *ctx); 697 } 698 } 699 700 void 701 SHA512_Begin(SHA512Context *ctx) 702 { 703 memset(ctx, 0, sizeof *ctx); 704 memcpy(H, H512, sizeof H512); 705 } 706 707 #if defined(SHA512_TRACE) 708 #if defined(HAVE_LONG_LONG) 709 #define DUMP(n,a,d,e,h) printf(" t = %2d, %s = %016lx, %s = %016lx\n", \ 710 n, #e, d, #a, h); 711 #else 712 #define DUMP(n,a,d,e,h) printf(" t = %2d, %s = %08x%08x, %s = %08x%08x\n", \ 713 n, #e, d.hi, d.lo, #a, h.hi, h.lo); 714 #endif 715 #else 716 #define DUMP(n,a,d,e,h) 717 #endif 718 719 #if defined(HAVE_LONG_LONG) 720 721 #define ADDTO(x,y) y += x 722 723 #define INITW(t) W[t] = (s1(W[t-2]) + W[t-7] + s0(W[t-15]) + W[t-16]) 724 725 #define ROUND(n,a,b,c,d,e,f,g,h) \ 726 h += S1(e) + Ch(e,f,g) + K512[n] + W[n]; \ 727 d += h; \ 728 h += S0(a) + Maj(a,b,c); \ 729 DUMP(n,a,d,e,h) 730 731 #else /* use only 32-bit variables, and don't unroll loops */ 732 733 #undef NOUNROLL512 734 #define NOUNROLL512 1 735 736 #define ADDTO(x,y) y.lo += x.lo; y.hi += x.hi + (x.lo > y.lo) 737 738 #define ROTR64a(x,n,lo,hi) (x.lo >> n | x.hi << (32-n)) 739 #define ROTR64A(x,n,lo,hi) (x.lo << (64-n) | x.hi >> (n-32)) 740 #define SHR64a(x,n,lo,hi) (x.lo >> n | x.hi << (32-n)) 741 742 /* Capitol Sigma and lower case sigma functions */ 743 #define s0lo(x) (ROTR64a(x,1,lo,hi) ^ ROTR64a(x,8,lo,hi) ^ SHR64a(x,7,lo,hi)) 744 #define s0hi(x) (ROTR64a(x,1,hi,lo) ^ ROTR64a(x,8,hi,lo) ^ (x.hi >> 7)) 745 746 #define s1lo(x) (ROTR64a(x,19,lo,hi) ^ ROTR64A(x,61,lo,hi) ^ SHR64a(x,6,lo,hi)) 747 #define s1hi(x) (ROTR64a(x,19,hi,lo) ^ ROTR64A(x,61,hi,lo) ^ (x.hi >> 6)) 748 749 #define S0lo(x)(ROTR64a(x,28,lo,hi) ^ ROTR64A(x,34,lo,hi) ^ ROTR64A(x,39,lo,hi)) 750 #define S0hi(x)(ROTR64a(x,28,hi,lo) ^ ROTR64A(x,34,hi,lo) ^ ROTR64A(x,39,hi,lo)) 751 752 #define S1lo(x)(ROTR64a(x,14,lo,hi) ^ ROTR64a(x,18,lo,hi) ^ ROTR64A(x,41,lo,hi)) 753 #define S1hi(x)(ROTR64a(x,14,hi,lo) ^ ROTR64a(x,18,hi,lo) ^ ROTR64A(x,41,hi,lo)) 754 755 /* 32-bit versions of Ch and Maj */ 756 #define Chxx(x,y,z,lo) ((x.lo & y.lo) ^ (~x.lo & z.lo)) 757 #define Majx(x,y,z,lo) ((x.lo & y.lo) ^ (x.lo & z.lo) ^ (y.lo & z.lo)) 758 759 #define INITW(t) \ 760 do { \ 761 PRUint32 lo, tm; \ 762 PRUint32 cy = 0; \ 763 lo = s1lo(W[t-2]); \ 764 lo += (tm = W[t-7].lo); if (lo < tm) cy++; \ 765 lo += (tm = s0lo(W[t-15])); if (lo < tm) cy++; \ 766 lo += (tm = W[t-16].lo); if (lo < tm) cy++; \ 767 W[t].lo = lo; \ 768 W[t].hi = cy + s1hi(W[t-2]) + W[t-7].hi + s0hi(W[t-15]) + W[t-16].hi; \ 769 } while (0) 770 771 #define ROUND(n,a,b,c,d,e,f,g,h) \ 772 { \ 773 PRUint32 lo, tm, cy; \ 774 lo = S1lo(e); \ 775 lo += (tm = Chxx(e,f,g,lo)); cy = (lo < tm); \ 776 lo += (tm = K512[n].lo); if (lo < tm) cy++; \ 777 lo += (tm = W[n].lo); if (lo < tm) cy++; \ 778 h.lo += lo; if (h.lo < lo) cy++; \ 779 h.hi += cy + S1hi(e) + Chxx(e,f,g,hi) + K512[n].hi + W[n].hi; \ 780 d.lo += h.lo; \ 781 d.hi += h.hi + (d.lo < h.lo); \ 782 lo = S0lo(a); \ 783 lo += (tm = Majx(a,b,c,lo)); cy = (lo < tm); \ 784 h.lo += lo; if (h.lo < lo) cy++; \ 785 h.hi += cy + S0hi(a) + Majx(a,b,c,hi); \ 786 DUMP(n,a,d,e,h) \ 787 } 788 #endif 789 790 static void 791 SHA512_Compress(SHA512Context *ctx) 792 { 793 #if defined(IS_LITTLE_ENDIAN) 794 { 795 #if defined(HAVE_LONG_LONG) 796 PRUint64 t1; 797 #else 798 PRUint32 t1; 799 #endif 800 BYTESWAP8(W[0]); 801 BYTESWAP8(W[1]); 802 BYTESWAP8(W[2]); 803 BYTESWAP8(W[3]); 804 BYTESWAP8(W[4]); 805 BYTESWAP8(W[5]); 806 BYTESWAP8(W[6]); 807 BYTESWAP8(W[7]); 808 BYTESWAP8(W[8]); 809 BYTESWAP8(W[9]); 810 BYTESWAP8(W[10]); 811 BYTESWAP8(W[11]); 812 BYTESWAP8(W[12]); 813 BYTESWAP8(W[13]); 814 BYTESWAP8(W[14]); 815 BYTESWAP8(W[15]); 816 } 817 #endif 818 819 { 820 PRUint64 t1, t2; 821 #ifdef NOUNROLL512 822 { 823 /* prepare the "message schedule" */ 824 int t; 825 for (t = 16; t < 80; ++t) { 826 INITW(t); 827 } 828 } 829 #else 830 INITW(16); 831 INITW(17); 832 INITW(18); 833 INITW(19); 834 835 INITW(20); 836 INITW(21); 837 INITW(22); 838 INITW(23); 839 INITW(24); 840 INITW(25); 841 INITW(26); 842 INITW(27); 843 INITW(28); 844 INITW(29); 845 846 INITW(30); 847 INITW(31); 848 INITW(32); 849 INITW(33); 850 INITW(34); 851 INITW(35); 852 INITW(36); 853 INITW(37); 854 INITW(38); 855 INITW(39); 856 857 INITW(40); 858 INITW(41); 859 INITW(42); 860 INITW(43); 861 INITW(44); 862 INITW(45); 863 INITW(46); 864 INITW(47); 865 INITW(48); 866 INITW(49); 867 868 INITW(50); 869 INITW(51); 870 INITW(52); 871 INITW(53); 872 INITW(54); 873 INITW(55); 874 INITW(56); 875 INITW(57); 876 INITW(58); 877 INITW(59); 878 879 INITW(60); 880 INITW(61); 881 INITW(62); 882 INITW(63); 883 INITW(64); 884 INITW(65); 885 INITW(66); 886 INITW(67); 887 INITW(68); 888 INITW(69); 889 890 INITW(70); 891 INITW(71); 892 INITW(72); 893 INITW(73); 894 INITW(74); 895 INITW(75); 896 INITW(76); 897 INITW(77); 898 INITW(78); 899 INITW(79); 900 #endif 901 } 902 #ifdef SHA512_TRACE 903 { 904 int i; 905 for (i = 0; i < 80; ++i) { 906 #ifdef HAVE_LONG_LONG 907 printf("W[%2d] = %016lx\n", i, W[i]); 908 #else 909 printf("W[%2d] = %08x%08x\n", i, W[i].hi, W[i].lo); 910 #endif 911 } 912 } 913 #endif 914 { 915 PRUint64 a, b, c, d, e, f, g, h; 916 917 a = H[0]; 918 b = H[1]; 919 c = H[2]; 920 d = H[3]; 921 e = H[4]; 922 f = H[5]; 923 g = H[6]; 924 h = H[7]; 925 926 #ifdef NOUNROLL512 927 { 928 int t; 929 for (t = 0; t < 80; t+= 8) { 930 ROUND(t+0,a,b,c,d,e,f,g,h) 931 ROUND(t+1,h,a,b,c,d,e,f,g) 932 ROUND(t+2,g,h,a,b,c,d,e,f) 933 ROUND(t+3,f,g,h,a,b,c,d,e) 934 ROUND(t+4,e,f,g,h,a,b,c,d) 935 ROUND(t+5,d,e,f,g,h,a,b,c) 936 ROUND(t+6,c,d,e,f,g,h,a,b) 937 ROUND(t+7,b,c,d,e,f,g,h,a) 938 } 939 } 940 #else 941 ROUND( 0,a,b,c,d,e,f,g,h) 942 ROUND( 1,h,a,b,c,d,e,f,g) 943 ROUND( 2,g,h,a,b,c,d,e,f) 944 ROUND( 3,f,g,h,a,b,c,d,e) 945 ROUND( 4,e,f,g,h,a,b,c,d) 946 ROUND( 5,d,e,f,g,h,a,b,c) 947 ROUND( 6,c,d,e,f,g,h,a,b) 948 ROUND( 7,b,c,d,e,f,g,h,a) 949 950 ROUND( 8,a,b,c,d,e,f,g,h) 951 ROUND( 9,h,a,b,c,d,e,f,g) 952 ROUND(10,g,h,a,b,c,d,e,f) 953 ROUND(11,f,g,h,a,b,c,d,e) 954 ROUND(12,e,f,g,h,a,b,c,d) 955 ROUND(13,d,e,f,g,h,a,b,c) 956 ROUND(14,c,d,e,f,g,h,a,b) 957 ROUND(15,b,c,d,e,f,g,h,a) 958 959 ROUND(16,a,b,c,d,e,f,g,h) 960 ROUND(17,h,a,b,c,d,e,f,g) 961 ROUND(18,g,h,a,b,c,d,e,f) 962 ROUND(19,f,g,h,a,b,c,d,e) 963 ROUND(20,e,f,g,h,a,b,c,d) 964 ROUND(21,d,e,f,g,h,a,b,c) 965 ROUND(22,c,d,e,f,g,h,a,b) 966 ROUND(23,b,c,d,e,f,g,h,a) 967 968 ROUND(24,a,b,c,d,e,f,g,h) 969 ROUND(25,h,a,b,c,d,e,f,g) 970 ROUND(26,g,h,a,b,c,d,e,f) 971 ROUND(27,f,g,h,a,b,c,d,e) 972 ROUND(28,e,f,g,h,a,b,c,d) 973 ROUND(29,d,e,f,g,h,a,b,c) 974 ROUND(30,c,d,e,f,g,h,a,b) 975 ROUND(31,b,c,d,e,f,g,h,a) 976 977 ROUND(32,a,b,c,d,e,f,g,h) 978 ROUND(33,h,a,b,c,d,e,f,g) 979 ROUND(34,g,h,a,b,c,d,e,f) 980 ROUND(35,f,g,h,a,b,c,d,e) 981 ROUND(36,e,f,g,h,a,b,c,d) 982 ROUND(37,d,e,f,g,h,a,b,c) 983 ROUND(38,c,d,e,f,g,h,a,b) 984 ROUND(39,b,c,d,e,f,g,h,a) 985 986 ROUND(40,a,b,c,d,e,f,g,h) 987 ROUND(41,h,a,b,c,d,e,f,g) 988 ROUND(42,g,h,a,b,c,d,e,f) 989 ROUND(43,f,g,h,a,b,c,d,e) 990 ROUND(44,e,f,g,h,a,b,c,d) 991 ROUND(45,d,e,f,g,h,a,b,c) 992 ROUND(46,c,d,e,f,g,h,a,b) 993 ROUND(47,b,c,d,e,f,g,h,a) 994 995 ROUND(48,a,b,c,d,e,f,g,h) 996 ROUND(49,h,a,b,c,d,e,f,g) 997 ROUND(50,g,h,a,b,c,d,e,f) 998 ROUND(51,f,g,h,a,b,c,d,e) 999 ROUND(52,e,f,g,h,a,b,c,d) 1000 ROUND(53,d,e,f,g,h,a,b,c) 1001 ROUND(54,c,d,e,f,g,h,a,b) 1002 ROUND(55,b,c,d,e,f,g,h,a) 1003 1004 ROUND(56,a,b,c,d,e,f,g,h) 1005 ROUND(57,h,a,b,c,d,e,f,g) 1006 ROUND(58,g,h,a,b,c,d,e,f) 1007 ROUND(59,f,g,h,a,b,c,d,e) 1008 ROUND(60,e,f,g,h,a,b,c,d) 1009 ROUND(61,d,e,f,g,h,a,b,c) 1010 ROUND(62,c,d,e,f,g,h,a,b) 1011 ROUND(63,b,c,d,e,f,g,h,a) 1012 1013 ROUND(64,a,b,c,d,e,f,g,h) 1014 ROUND(65,h,a,b,c,d,e,f,g) 1015 ROUND(66,g,h,a,b,c,d,e,f) 1016 ROUND(67,f,g,h,a,b,c,d,e) 1017 ROUND(68,e,f,g,h,a,b,c,d) 1018 ROUND(69,d,e,f,g,h,a,b,c) 1019 ROUND(70,c,d,e,f,g,h,a,b) 1020 ROUND(71,b,c,d,e,f,g,h,a) 1021 1022 ROUND(72,a,b,c,d,e,f,g,h) 1023 ROUND(73,h,a,b,c,d,e,f,g) 1024 ROUND(74,g,h,a,b,c,d,e,f) 1025 ROUND(75,f,g,h,a,b,c,d,e) 1026 ROUND(76,e,f,g,h,a,b,c,d) 1027 ROUND(77,d,e,f,g,h,a,b,c) 1028 ROUND(78,c,d,e,f,g,h,a,b) 1029 ROUND(79,b,c,d,e,f,g,h,a) 1030 #endif 1031 1032 ADDTO(a,H[0]); 1033 ADDTO(b,H[1]); 1034 ADDTO(c,H[2]); 1035 ADDTO(d,H[3]); 1036 ADDTO(e,H[4]); 1037 ADDTO(f,H[5]); 1038 ADDTO(g,H[6]); 1039 ADDTO(h,H[7]); 1040 } 1041 } 1042 1043 void 1044 SHA512_Update(SHA512Context *ctx, const unsigned char *input, 1045 unsigned int inputLen) 1046 { 1047 unsigned int inBuf; 1048 if (!inputLen) 1049 return; 1050 1051 #if defined(HAVE_LONG_LONG) 1052 inBuf = (unsigned int)ctx->sizeLo & 0x7f; 1053 /* Add inputLen into the count of bytes processed, before processing */ 1054 ctx->sizeLo += inputLen; 1055 #else 1056 inBuf = (unsigned int)ctx->sizeLo.lo & 0x7f; 1057 ctx->sizeLo.lo += inputLen; 1058 if (ctx->sizeLo.lo < inputLen) ctx->sizeLo.hi++; 1059 #endif 1060 1061 /* if data already in buffer, attemp to fill rest of buffer */ 1062 if (inBuf) { 1063 unsigned int todo = SHA512_BLOCK_LENGTH - inBuf; 1064 if (inputLen < todo) 1065 todo = inputLen; 1066 memcpy(B + inBuf, input, todo); 1067 input += todo; 1068 inputLen -= todo; 1069 if (inBuf + todo == SHA512_BLOCK_LENGTH) 1070 SHA512_Compress(ctx); 1071 } 1072 1073 /* if enough data to fill one or more whole buffers, process them. */ 1074 while (inputLen >= SHA512_BLOCK_LENGTH) { 1075 memcpy(B, input, SHA512_BLOCK_LENGTH); 1076 input += SHA512_BLOCK_LENGTH; 1077 inputLen -= SHA512_BLOCK_LENGTH; 1078 SHA512_Compress(ctx); 1079 } 1080 /* if data left over, fill it into buffer */ 1081 if (inputLen) 1082 memcpy(B, input, inputLen); 1083 } 1084 1085 void 1086 SHA512_End(SHA512Context *ctx, unsigned char *digest, 1087 unsigned int *digestLen, unsigned int maxDigestLen) 1088 { 1089 #if defined(HAVE_LONG_LONG) 1090 unsigned int inBuf = (unsigned int)ctx->sizeLo & 0x7f; 1091 unsigned int padLen = (inBuf < 112) ? (112 - inBuf) : (112 + 128 - inBuf); 1092 PRUint64 lo, t1; 1093 lo = (ctx->sizeLo << 3); 1094 #else 1095 unsigned int inBuf = (unsigned int)ctx->sizeLo.lo & 0x7f; 1096 unsigned int padLen = (inBuf < 112) ? (112 - inBuf) : (112 + 128 - inBuf); 1097 PRUint64 lo = ctx->sizeLo; 1098 PRUint32 t1; 1099 lo.lo <<= 3; 1100 #endif 1101 1102 SHA512_Update(ctx, pad, padLen); 1103 1104 #if defined(HAVE_LONG_LONG) 1105 W[14] = 0; 1106 #else 1107 W[14].lo = 0; 1108 W[14].hi = 0; 1109 #endif 1110 1111 W[15] = lo; 1112 #if defined(IS_LITTLE_ENDIAN) 1113 BYTESWAP8(W[15]); 1114 #endif 1115 SHA512_Compress(ctx); 1116 1117 /* now output the answer */ 1118 #if defined(IS_LITTLE_ENDIAN) 1119 BYTESWAP8(H[0]); 1120 BYTESWAP8(H[1]); 1121 BYTESWAP8(H[2]); 1122 BYTESWAP8(H[3]); 1123 BYTESWAP8(H[4]); 1124 BYTESWAP8(H[5]); 1125 BYTESWAP8(H[6]); 1126 BYTESWAP8(H[7]); 1127 #endif 1128 padLen = PR_MIN(SHA512_LENGTH, maxDigestLen); 1129 memcpy(digest, H, padLen); 1130 if (digestLen) 1131 *digestLen = padLen; 1132 } 1133 1134 SECStatus 1135 SHA512_HashBuf(unsigned char *dest, const unsigned char *src, 1136 unsigned int src_length) 1137 { 1138 SHA512Context ctx; 1139 unsigned int outLen; 1140 1141 SHA512_Begin(&ctx); 1142 SHA512_Update(&ctx, src, src_length); 1143 SHA512_End(&ctx, dest, &outLen, SHA512_LENGTH); 1144 1145 return SECSuccess; 1146 } 1147 1148 1149 SECStatus 1150 SHA512_Hash(unsigned char *dest, const char *src) 1151 { 1152 return SHA512_HashBuf(dest, (const unsigned char *)src, PORT_Strlen(src)); 1153 } 1154 1155 1156 void SHA512_TraceState(SHA512Context *ctx) { } 1157 1158 unsigned int 1159 SHA512_FlattenSize(SHA512Context *ctx) 1160 { 1161 return sizeof *ctx; 1162 } 1163 1164 SECStatus 1165 SHA512_Flatten(SHA512Context *ctx,unsigned char *space) 1166 { 1167 PORT_Memcpy(space, ctx, sizeof *ctx); 1168 return SECSuccess; 1169 } 1170 1171 SHA512Context * 1172 SHA512_Resurrect(unsigned char *space, void *arg) 1173 { 1174 SHA512Context *ctx = SHA512_NewContext(); 1175 if (ctx) 1176 PORT_Memcpy(ctx, space, sizeof *ctx); 1177 return ctx; 1178 } 1179 1180 void SHA512_Clone(SHA512Context *dest, SHA512Context *src) 1181 { 1182 memcpy(dest, src, sizeof *dest); 1183 } 1184 1185 /* ======================================================================= */ 1186 /* SHA384 uses a SHA512Context as the real context. 1187 ** The only differences between SHA384 an SHA512 are: 1188 ** a) the intialization values for the context, and 1189 ** b) the number of bytes of data produced as output. 1190 */ 1191 1192 /* SHA-384 initial hash values */ 1193 static const PRUint64 H384[8] = { 1194 #if PR_BYTES_PER_LONG == 8 1195 0xcbbb9d5dc1059ed8UL , 0x629a292a367cd507UL , 1196 0x9159015a3070dd17UL , 0x152fecd8f70e5939UL , 1197 0x67332667ffc00b31UL , 0x8eb44a8768581511UL , 1198 0xdb0c2e0d64f98fa7UL , 0x47b5481dbefa4fa4UL 1199 #else 1200 ULLC(cbbb9d5d,c1059ed8), ULLC(629a292a,367cd507), 1201 ULLC(9159015a,3070dd17), ULLC(152fecd8,f70e5939), 1202 ULLC(67332667,ffc00b31), ULLC(8eb44a87,68581511), 1203 ULLC(db0c2e0d,64f98fa7), ULLC(47b5481d,befa4fa4) 1204 #endif 1205 }; 1206 1207 SHA384Context * 1208 SHA384_NewContext(void) 1209 { 1210 return SHA512_NewContext(); 1211 } 1212 1213 void 1214 SHA384_DestroyContext(SHA384Context *ctx, PRBool freeit) 1215 { 1216 SHA512_DestroyContext(ctx, freeit); 1217 } 1218 1219 void 1220 SHA384_Begin(SHA384Context *ctx) 1221 { 1222 memset(ctx, 0, sizeof *ctx); 1223 memcpy(H, H384, sizeof H384); 1224 } 1225 1226 void 1227 SHA384_Update(SHA384Context *ctx, const unsigned char *input, 1228 unsigned int inputLen) 1229 { 1230 SHA512_Update(ctx, input, inputLen); 1231 } 1232 1233 void 1234 SHA384_End(SHA384Context *ctx, unsigned char *digest, 1235 unsigned int *digestLen, unsigned int maxDigestLen) 1236 { 1237 #define SHA_MIN(a,b) (a < b ? a : b) 1238 unsigned int maxLen = SHA_MIN(maxDigestLen, SHA384_LENGTH); 1239 SHA512_End(ctx, digest, digestLen, maxLen); 1240 } 1241 1242 SECStatus 1243 SHA384_HashBuf(unsigned char *dest, const unsigned char *src, 1244 unsigned int src_length) 1245 { 1246 SHA512Context ctx; 1247 unsigned int outLen; 1248 1249 SHA384_Begin(&ctx); 1250 SHA512_Update(&ctx, src, src_length); 1251 SHA512_End(&ctx, dest, &outLen, SHA384_LENGTH); 1252 1253 return SECSuccess; 1254 } 1255 1256 SECStatus 1257 SHA384_Hash(unsigned char *dest, const char *src) 1258 { 1259 return SHA384_HashBuf(dest, (const unsigned char *)src, PORT_Strlen(src)); 1260 } 1261 1262 void SHA384_TraceState(SHA384Context *ctx) { } 1263 1264 unsigned int 1265 SHA384_FlattenSize(SHA384Context *ctx) 1266 { 1267 return sizeof(SHA384Context); 1268 } 1269 1270 SECStatus 1271 SHA384_Flatten(SHA384Context *ctx,unsigned char *space) 1272 { 1273 return SHA512_Flatten(ctx, space); 1274 } 1275 1276 SHA384Context * 1277 SHA384_Resurrect(unsigned char *space, void *arg) 1278 { 1279 return SHA512_Resurrect(space, arg); 1280 } 1281 1282 void SHA384_Clone(SHA384Context *dest, SHA384Context *src) 1283 { 1284 memcpy(dest, src, sizeof *dest); 1285 } 1286 #endif /* Comment out unused code. */ 1287 1288 /* ======================================================================= */ 1289 #ifdef SELFTEST 1290 #include <stdio.h> 1291 1292 static const char abc[] = { "abc" }; 1293 static const char abcdbc[] = { 1294 "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" 1295 }; 1296 static const char abcdef[] = { 1297 "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn" 1298 "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu" 1299 }; 1300 1301 void 1302 dumpHash32(const unsigned char *buf, unsigned int bufLen) 1303 { 1304 unsigned int i; 1305 for (i = 0; i < bufLen; i += 4) { 1306 printf(" %02x%02x%02x%02x", buf[i], buf[i+1], buf[i+2], buf[i+3]); 1307 } 1308 printf("\n"); 1309 } 1310 1311 void test256(void) 1312 { 1313 unsigned char outBuf[SHA256_LENGTH]; 1314 1315 printf("SHA256, input = %s\n", abc); 1316 SHA256_Hash(outBuf, abc); 1317 dumpHash32(outBuf, sizeof outBuf); 1318 1319 printf("SHA256, input = %s\n", abcdbc); 1320 SHA256_Hash(outBuf, abcdbc); 1321 dumpHash32(outBuf, sizeof outBuf); 1322 } 1323 1324 void 1325 dumpHash64(const unsigned char *buf, unsigned int bufLen) 1326 { 1327 unsigned int i; 1328 for (i = 0; i < bufLen; i += 8) { 1329 if (i % 32 == 0) 1330 printf("\n"); 1331 printf(" %02x%02x%02x%02x%02x%02x%02x%02x", 1332 buf[i ], buf[i+1], buf[i+2], buf[i+3], 1333 buf[i+4], buf[i+5], buf[i+6], buf[i+7]); 1334 } 1335 printf("\n"); 1336 } 1337 1338 void test512(void) 1339 { 1340 unsigned char outBuf[SHA512_LENGTH]; 1341 1342 printf("SHA512, input = %s\n", abc); 1343 SHA512_Hash(outBuf, abc); 1344 dumpHash64(outBuf, sizeof outBuf); 1345 1346 printf("SHA512, input = %s\n", abcdef); 1347 SHA512_Hash(outBuf, abcdef); 1348 dumpHash64(outBuf, sizeof outBuf); 1349 } 1350 1351 void time512(void) 1352 { 1353 unsigned char outBuf[SHA512_LENGTH]; 1354 1355 SHA512_Hash(outBuf, abc); 1356 SHA512_Hash(outBuf, abcdef); 1357 } 1358 1359 void test384(void) 1360 { 1361 unsigned char outBuf[SHA384_LENGTH]; 1362 1363 printf("SHA384, input = %s\n", abc); 1364 SHA384_Hash(outBuf, abc); 1365 dumpHash64(outBuf, sizeof outBuf); 1366 1367 printf("SHA384, input = %s\n", abcdef); 1368 SHA384_Hash(outBuf, abcdef); 1369 dumpHash64(outBuf, sizeof outBuf); 1370 } 1371 1372 int main (int argc, char *argv[], char *envp[]) 1373 { 1374 int i = 1; 1375 if (argc > 1) { 1376 i = atoi(argv[1]); 1377 } 1378 if (i < 2) { 1379 test256(); 1380 test512(); 1381 test384(); 1382 } else { 1383 while (i-- > 0) { 1384 time512(); 1385 } 1386 printf("done\n"); 1387 } 1388 return 0; 1389 } 1390 1391 #endif 1392
