开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
sha_fast.c
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：14k
源码类别：

CA认证

开发平台：

WINDOWS

sha_fast.c：源码内容
  1. /* 
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is SHA 180-1 Reference Implementation (Optimized)
  13.  * 
  14.  * The Initial Developer of the Original Code is Paul Kocher of
  15.  * Cryptography Research.  Portions created by Paul Kocher are 
  16.  * Copyright (C) 1995-9 by Cryptography Research, Inc.  All
  17.  * Rights Reserved.
  18.  * 
  19.  * Contributor(s):
  20.  *
  21.  *     Paul Kocher
  22.  * 
  23.  * Alternatively, the contents of this file may be used under the
  24.  * terms of the GNU General Public License Version 2 or later (the
  25.  * "GPL"), in which case the provisions of the GPL are applicable 
  26.  * instead of those above.  If you wish to allow use of your 
  27.  * version of this file only under the terms of the GPL and not to
  28.  * allow others to use your version of this file under the MPL,
  29.  * indicate your decision by deleting the provisions above and
  30.  * replace them with the notice and other provisions required by
  31.  * the GPL.  If you do not delete the provisions above, a recipient
  32.  * may use your version of this file under either the MPL or the
  33.  * GPL.
  34.  */
  35. #include <memory.h>
  36. #include "blapi.h"
  37. #include "sha_fast.h"
  39. #ifdef TRACING_SSL
  40. #include "ssl.h"
  41. #include "ssltrace.h"
  42. #endif
  44. static void shaCompress(SHA1Context *ctx);
  46. #define W u.w
  47. #define B u.b
  49. #define SHA_ROTL(X,n) (((X) << (n)) | ((X) >> (32-(n))))
  50. #define SHA_F1(X,Y,Z) ((((Y)^(Z))&(X))^(Z))
  51. #define SHA_F2(X,Y,Z) ((X)^(Y)^(Z))
  52. #define SHA_F3(X,Y,Z) (((X)&(Y))|((Z)&((X)|(Y))))
  53. #define SHA_F4(X,Y,Z) ((X)^(Y)^(Z))
  54. #define SHA_MIX(t)    ctx->W[t] = 
  55.   (A = ctx->W[t-3] ^ ctx->W[t-8] ^ ctx->W[t-14] ^ ctx->W[t-16], SHA_ROTL(A, 1))
  58. /*
  59.  *  SHA: Zeroize and initialize context
  60.  */
  61. void 
  62. SHA1_Begin(SHA1Context *ctx)
  63. {
  64.   memset(ctx, 0, sizeof(SHA1Context));
  66.   /*
  67.    *  Initialize H with constants from FIPS180-1.
  68.    */
  69.   ctx->H[0] = 0x67452301L;
  70.   ctx->H[1] = 0xefcdab89L;
  71.   ctx->H[2] = 0x98badcfeL;
  72.   ctx->H[3] = 0x10325476L;
  73.   ctx->H[4] = 0xc3d2e1f0L;
  75. }
  78. /*
  79.  *  SHA: Add data to context.
  80.  */
  81. void 
  82. SHA1_Update(SHA1Context *ctx, const unsigned char *dataIn, unsigned int len) 
  83. {
  84.   register unsigned int lenB = ctx->sizeLo & 63;
  85.   register unsigned int togo;
  87.   if (!len)
  88.     return;
  90.   /* accumulate the byte count. */
  91.   ctx->sizeLo += len;
  92.   ctx->sizeHi += (ctx->sizeLo < len);
  94.   /*
  95.    *  Read the data into W and process blocks as they get full
  96.    */
  97.   if (lenB > 0) {
  98.     togo = 64 - lenB;
  99.     if (len < togo)
  100.       togo = len;
  101.     memcpy(ctx->B + lenB, dataIn, togo);
  102.     len    -= togo;
  103.     dataIn += togo;
  104.     lenB    = (lenB + togo) & 63;
  105.     if (!lenB) {
  106.       shaCompress(ctx);
  107.     }
  108.   }
  109.   while (len >= 64) {
  110.     memcpy(ctx->B, dataIn, 64);
  111.     dataIn += 64;
  112.     len    -= 64;
  113.     shaCompress(ctx);
  114.   }
  115.   if (len) {
  116.     memcpy(ctx->B, dataIn, len);
  117.   }
  118. }
  121. /*
  122.  *  SHA: Generate hash value from context
  123.  */
  124. void 
  125. SHA1_End(SHA1Context *ctx, unsigned char *hashout,
  126.          unsigned int *pDigestLen, unsigned int maxDigestLen)
  127. {
  128.   register PRUint32 sizeHi, sizeLo, lenB;
  129.   static const unsigned char bulk_pad[64] = { 0x80,0,0,0,0,0,0,0,0,0,
  130.           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,
  131.           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  };
  132. #define A lenB
  134.   PORT_Assert (maxDigestLen >= SHA1_LENGTH);
  136.   /*
  137.    *  Pad with a binary 1 (e.g. 0x80), then zeroes, then length in bits
  138.    */
  139.   sizeHi = ctx->sizeHi;
  140.   sizeLo = ctx->sizeLo;
  141.   lenB = sizeLo & 63;
  142.   SHA1_Update(ctx, bulk_pad, (((55+64) - lenB) & 63) + 1);
  143.   PORT_Assert((ctx->sizeLo & 63) == 56);
  145.   /* Convert size{Hi,Lo} from bytes to bits. */
  146.   sizeHi = (sizeHi << 3) | (sizeLo >> 29);
  147.   sizeLo <<= 3;
  149.   ctx->W[14] = SHA_HTONL(sizeHi);
  150.   ctx->W[15] = SHA_HTONL(sizeLo);
  151.   shaCompress(ctx);
  153.   /*
  154.    *  Output hash
  155.    */
  156. #if defined(IS_LITTLE_ENDIAN)
  157.   SHA_BYTESWAP(ctx->H[0]);
  158.   SHA_BYTESWAP(ctx->H[1]);
  159.   SHA_BYTESWAP(ctx->H[2]);
  160.   SHA_BYTESWAP(ctx->H[3]);
  161.   SHA_BYTESWAP(ctx->H[4]);
  162. #endif
  163.   memcpy(hashout, ctx->H, SHA1_LENGTH);
  164.   *pDigestLen = SHA1_LENGTH;
  166.   /*
  167.    *  Re-initialize the context (also zeroizes contents)
  168.    */
  169.   SHA1_Begin(ctx);
  170. }
  172. #undef A
  173. #undef B
  174. /*
  175.  *  SHA: Compression function, unrolled.
  176.  */
  177. static void 
  178. shaCompress(SHA1Context *ctx) 
  179. {
  180.   register PRUint32 A, B, C, D, E;
  182. #if defined(IS_LITTLE_ENDIAN)
  183.   SHA_BYTESWAP(ctx->W[0]);
  184.   SHA_BYTESWAP(ctx->W[1]);
  185.   SHA_BYTESWAP(ctx->W[2]);
  186.   SHA_BYTESWAP(ctx->W[3]);
  187.   SHA_BYTESWAP(ctx->W[4]);
  188.   SHA_BYTESWAP(ctx->W[5]);
  189.   SHA_BYTESWAP(ctx->W[6]);
  190.   SHA_BYTESWAP(ctx->W[7]);
  191.   SHA_BYTESWAP(ctx->W[8]);
  192.   SHA_BYTESWAP(ctx->W[9]);
  193.   SHA_BYTESWAP(ctx->W[10]);
  194.   SHA_BYTESWAP(ctx->W[11]);
  195.   SHA_BYTESWAP(ctx->W[12]);
  196.   SHA_BYTESWAP(ctx->W[13]);
  197.   SHA_BYTESWAP(ctx->W[14]);
  198.   SHA_BYTESWAP(ctx->W[15]);
  199. #endif
  201.   /*
  202.    *  This can be moved into the main code block below, but doing
  203.    *  so can cause some compilers to run out of registers and resort
  204.    *  to storing intermediates in RAM.
  205.    */
  207.                SHA_MIX(16); SHA_MIX(17); SHA_MIX(18); SHA_MIX(19);
  208.   SHA_MIX(20); SHA_MIX(21); SHA_MIX(22); SHA_MIX(23); SHA_MIX(24);
  209.   SHA_MIX(25); SHA_MIX(26); SHA_MIX(27); SHA_MIX(28); SHA_MIX(29);
  210.   SHA_MIX(30); SHA_MIX(31); SHA_MIX(32); SHA_MIX(33); SHA_MIX(34);
  211.   SHA_MIX(35); SHA_MIX(36); SHA_MIX(37); SHA_MIX(38); SHA_MIX(39);
  212.   SHA_MIX(40); SHA_MIX(41); SHA_MIX(42); SHA_MIX(43); SHA_MIX(44);
  213.   SHA_MIX(45); SHA_MIX(46); SHA_MIX(47); SHA_MIX(48); SHA_MIX(49);
  214.   SHA_MIX(50); SHA_MIX(51); SHA_MIX(52); SHA_MIX(53); SHA_MIX(54);
  215.   SHA_MIX(55); SHA_MIX(56); SHA_MIX(57); SHA_MIX(58); SHA_MIX(59);
  216.   SHA_MIX(60); SHA_MIX(61); SHA_MIX(62); SHA_MIX(63); SHA_MIX(64);
  217.   SHA_MIX(65); SHA_MIX(66); SHA_MIX(67); SHA_MIX(68); SHA_MIX(69);
  218.   SHA_MIX(70); SHA_MIX(71); SHA_MIX(72); SHA_MIX(73); SHA_MIX(74);
  219.   SHA_MIX(75); SHA_MIX(76); SHA_MIX(77); SHA_MIX(78); SHA_MIX(79);
  221.   A = ctx->H[0];
  222.   B = ctx->H[1];
  223.   C = ctx->H[2];
  224.   D = ctx->H[3];
  225.   E = ctx->H[4];
  227.   E = SHA_ROTL(A,5)+SHA_F1(B,C,D)+E+ctx->W[ 0]+0x5a827999L; B=SHA_ROTL(B,30); 
  228.   D = SHA_ROTL(E,5)+SHA_F1(A,B,C)+D+ctx->W[ 1]+0x5a827999L; A=SHA_ROTL(A,30); 
  229.   C = SHA_ROTL(D,5)+SHA_F1(E,A,B)+C+ctx->W[ 2]+0x5a827999L; E=SHA_ROTL(E,30); 
  230.   B = SHA_ROTL(C,5)+SHA_F1(D,E,A)+B+ctx->W[ 3]+0x5a827999L; D=SHA_ROTL(D,30); 
  231.   A = SHA_ROTL(B,5)+SHA_F1(C,D,E)+A+ctx->W[ 4]+0x5a827999L; C=SHA_ROTL(C,30); 
  232.   E = SHA_ROTL(A,5)+SHA_F1(B,C,D)+E+ctx->W[ 5]+0x5a827999L; B=SHA_ROTL(B,30); 
  233.   D = SHA_ROTL(E,5)+SHA_F1(A,B,C)+D+ctx->W[ 6]+0x5a827999L; A=SHA_ROTL(A,30); 
  234.   C = SHA_ROTL(D,5)+SHA_F1(E,A,B)+C+ctx->W[ 7]+0x5a827999L; E=SHA_ROTL(E,30); 
  235.   B = SHA_ROTL(C,5)+SHA_F1(D,E,A)+B+ctx->W[ 8]+0x5a827999L; D=SHA_ROTL(D,30); 
  236.   A = SHA_ROTL(B,5)+SHA_F1(C,D,E)+A+ctx->W[ 9]+0x5a827999L; C=SHA_ROTL(C,30); 
  237.   E = SHA_ROTL(A,5)+SHA_F1(B,C,D)+E+ctx->W[10]+0x5a827999L; B=SHA_ROTL(B,30); 
  238.   D = SHA_ROTL(E,5)+SHA_F1(A,B,C)+D+ctx->W[11]+0x5a827999L; A=SHA_ROTL(A,30); 
  239.   C = SHA_ROTL(D,5)+SHA_F1(E,A,B)+C+ctx->W[12]+0x5a827999L; E=SHA_ROTL(E,30); 
  240.   B = SHA_ROTL(C,5)+SHA_F1(D,E,A)+B+ctx->W[13]+0x5a827999L; D=SHA_ROTL(D,30); 
  241.   A = SHA_ROTL(B,5)+SHA_F1(C,D,E)+A+ctx->W[14]+0x5a827999L; C=SHA_ROTL(C,30); 
  242.   E = SHA_ROTL(A,5)+SHA_F1(B,C,D)+E+ctx->W[15]+0x5a827999L; B=SHA_ROTL(B,30); 
  243.   D = SHA_ROTL(E,5)+SHA_F1(A,B,C)+D+ctx->W[16]+0x5a827999L; A=SHA_ROTL(A,30); 
  244.   C = SHA_ROTL(D,5)+SHA_F1(E,A,B)+C+ctx->W[17]+0x5a827999L; E=SHA_ROTL(E,30); 
  245.   B = SHA_ROTL(C,5)+SHA_F1(D,E,A)+B+ctx->W[18]+0x5a827999L; D=SHA_ROTL(D,30); 
  246.   A = SHA_ROTL(B,5)+SHA_F1(C,D,E)+A+ctx->W[19]+0x5a827999L; C=SHA_ROTL(C,30); 
  248.   E = SHA_ROTL(A,5)+SHA_F2(B,C,D)+E+ctx->W[20]+0x6ed9eba1L; B=SHA_ROTL(B,30); 
  249.   D = SHA_ROTL(E,5)+SHA_F2(A,B,C)+D+ctx->W[21]+0x6ed9eba1L; A=SHA_ROTL(A,30); 
  250.   C = SHA_ROTL(D,5)+SHA_F2(E,A,B)+C+ctx->W[22]+0x6ed9eba1L; E=SHA_ROTL(E,30); 
  251.   B = SHA_ROTL(C,5)+SHA_F2(D,E,A)+B+ctx->W[23]+0x6ed9eba1L; D=SHA_ROTL(D,30); 
  252.   A = SHA_ROTL(B,5)+SHA_F2(C,D,E)+A+ctx->W[24]+0x6ed9eba1L; C=SHA_ROTL(C,30); 
  253.   E = SHA_ROTL(A,5)+SHA_F2(B,C,D)+E+ctx->W[25]+0x6ed9eba1L; B=SHA_ROTL(B,30); 
  254.   D = SHA_ROTL(E,5)+SHA_F2(A,B,C)+D+ctx->W[26]+0x6ed9eba1L; A=SHA_ROTL(A,30); 
  255.   C = SHA_ROTL(D,5)+SHA_F2(E,A,B)+C+ctx->W[27]+0x6ed9eba1L; E=SHA_ROTL(E,30); 
  256.   B = SHA_ROTL(C,5)+SHA_F2(D,E,A)+B+ctx->W[28]+0x6ed9eba1L; D=SHA_ROTL(D,30); 
  257.   A = SHA_ROTL(B,5)+SHA_F2(C,D,E)+A+ctx->W[29]+0x6ed9eba1L; C=SHA_ROTL(C,30); 
  258.   E = SHA_ROTL(A,5)+SHA_F2(B,C,D)+E+ctx->W[30]+0x6ed9eba1L; B=SHA_ROTL(B,30); 
  259.   D = SHA_ROTL(E,5)+SHA_F2(A,B,C)+D+ctx->W[31]+0x6ed9eba1L; A=SHA_ROTL(A,30); 
  260.   C = SHA_ROTL(D,5)+SHA_F2(E,A,B)+C+ctx->W[32]+0x6ed9eba1L; E=SHA_ROTL(E,30); 
  261.   B = SHA_ROTL(C,5)+SHA_F2(D,E,A)+B+ctx->W[33]+0x6ed9eba1L; D=SHA_ROTL(D,30); 
  262.   A = SHA_ROTL(B,5)+SHA_F2(C,D,E)+A+ctx->W[34]+0x6ed9eba1L; C=SHA_ROTL(C,30); 
  263.   E = SHA_ROTL(A,5)+SHA_F2(B,C,D)+E+ctx->W[35]+0x6ed9eba1L; B=SHA_ROTL(B,30); 
  264.   D = SHA_ROTL(E,5)+SHA_F2(A,B,C)+D+ctx->W[36]+0x6ed9eba1L; A=SHA_ROTL(A,30); 
  265.   C = SHA_ROTL(D,5)+SHA_F2(E,A,B)+C+ctx->W[37]+0x6ed9eba1L; E=SHA_ROTL(E,30); 
  266.   B = SHA_ROTL(C,5)+SHA_F2(D,E,A)+B+ctx->W[38]+0x6ed9eba1L; D=SHA_ROTL(D,30); 
  267.   A = SHA_ROTL(B,5)+SHA_F2(C,D,E)+A+ctx->W[39]+0x6ed9eba1L; C=SHA_ROTL(C,30); 
  269.   E = SHA_ROTL(A,5)+SHA_F3(B,C,D)+E+ctx->W[40]+0x8f1bbcdcL; B=SHA_ROTL(B,30); 
  270.   D = SHA_ROTL(E,5)+SHA_F3(A,B,C)+D+ctx->W[41]+0x8f1bbcdcL; A=SHA_ROTL(A,30); 
  271.   C = SHA_ROTL(D,5)+SHA_F3(E,A,B)+C+ctx->W[42]+0x8f1bbcdcL; E=SHA_ROTL(E,30); 
  272.   B = SHA_ROTL(C,5)+SHA_F3(D,E,A)+B+ctx->W[43]+0x8f1bbcdcL; D=SHA_ROTL(D,30); 
  273.   A = SHA_ROTL(B,5)+SHA_F3(C,D,E)+A+ctx->W[44]+0x8f1bbcdcL; C=SHA_ROTL(C,30); 
  274.   E = SHA_ROTL(A,5)+SHA_F3(B,C,D)+E+ctx->W[45]+0x8f1bbcdcL; B=SHA_ROTL(B,30); 
  275.   D = SHA_ROTL(E,5)+SHA_F3(A,B,C)+D+ctx->W[46]+0x8f1bbcdcL; A=SHA_ROTL(A,30); 
  276.   C = SHA_ROTL(D,5)+SHA_F3(E,A,B)+C+ctx->W[47]+0x8f1bbcdcL; E=SHA_ROTL(E,30); 
  277.   B = SHA_ROTL(C,5)+SHA_F3(D,E,A)+B+ctx->W[48]+0x8f1bbcdcL; D=SHA_ROTL(D,30); 
  278.   A = SHA_ROTL(B,5)+SHA_F3(C,D,E)+A+ctx->W[49]+0x8f1bbcdcL; C=SHA_ROTL(C,30); 
  279.   E = SHA_ROTL(A,5)+SHA_F3(B,C,D)+E+ctx->W[50]+0x8f1bbcdcL; B=SHA_ROTL(B,30); 
  280.   D = SHA_ROTL(E,5)+SHA_F3(A,B,C)+D+ctx->W[51]+0x8f1bbcdcL; A=SHA_ROTL(A,30); 
  281.   C = SHA_ROTL(D,5)+SHA_F3(E,A,B)+C+ctx->W[52]+0x8f1bbcdcL; E=SHA_ROTL(E,30); 
  282.   B = SHA_ROTL(C,5)+SHA_F3(D,E,A)+B+ctx->W[53]+0x8f1bbcdcL; D=SHA_ROTL(D,30); 
  283.   A = SHA_ROTL(B,5)+SHA_F3(C,D,E)+A+ctx->W[54]+0x8f1bbcdcL; C=SHA_ROTL(C,30); 
  284.   E = SHA_ROTL(A,5)+SHA_F3(B,C,D)+E+ctx->W[55]+0x8f1bbcdcL; B=SHA_ROTL(B,30); 
  285.   D = SHA_ROTL(E,5)+SHA_F3(A,B,C)+D+ctx->W[56]+0x8f1bbcdcL; A=SHA_ROTL(A,30); 
  286.   C = SHA_ROTL(D,5)+SHA_F3(E,A,B)+C+ctx->W[57]+0x8f1bbcdcL; E=SHA_ROTL(E,30); 
  287.   B = SHA_ROTL(C,5)+SHA_F3(D,E,A)+B+ctx->W[58]+0x8f1bbcdcL; D=SHA_ROTL(D,30); 
  288.   A = SHA_ROTL(B,5)+SHA_F3(C,D,E)+A+ctx->W[59]+0x8f1bbcdcL; C=SHA_ROTL(C,30); 
  290.   E = SHA_ROTL(A,5)+SHA_F4(B,C,D)+E+ctx->W[60]+0xca62c1d6L; B=SHA_ROTL(B,30); 
  291.   D = SHA_ROTL(E,5)+SHA_F4(A,B,C)+D+ctx->W[61]+0xca62c1d6L; A=SHA_ROTL(A,30); 
  292.   C = SHA_ROTL(D,5)+SHA_F4(E,A,B)+C+ctx->W[62]+0xca62c1d6L; E=SHA_ROTL(E,30); 
  293.   B = SHA_ROTL(C,5)+SHA_F4(D,E,A)+B+ctx->W[63]+0xca62c1d6L; D=SHA_ROTL(D,30); 
  294.   A = SHA_ROTL(B,5)+SHA_F4(C,D,E)+A+ctx->W[64]+0xca62c1d6L; C=SHA_ROTL(C,30); 
  295.   E = SHA_ROTL(A,5)+SHA_F4(B,C,D)+E+ctx->W[65]+0xca62c1d6L; B=SHA_ROTL(B,30); 
  296.   D = SHA_ROTL(E,5)+SHA_F4(A,B,C)+D+ctx->W[66]+0xca62c1d6L; A=SHA_ROTL(A,30); 
  297.   C = SHA_ROTL(D,5)+SHA_F4(E,A,B)+C+ctx->W[67]+0xca62c1d6L; E=SHA_ROTL(E,30); 
  298.   B = SHA_ROTL(C,5)+SHA_F4(D,E,A)+B+ctx->W[68]+0xca62c1d6L; D=SHA_ROTL(D,30); 
  299.   A = SHA_ROTL(B,5)+SHA_F4(C,D,E)+A+ctx->W[69]+0xca62c1d6L; C=SHA_ROTL(C,30); 
  300.   E = SHA_ROTL(A,5)+SHA_F4(B,C,D)+E+ctx->W[70]+0xca62c1d6L; B=SHA_ROTL(B,30); 
  301.   D = SHA_ROTL(E,5)+SHA_F4(A,B,C)+D+ctx->W[71]+0xca62c1d6L; A=SHA_ROTL(A,30); 
  302.   C = SHA_ROTL(D,5)+SHA_F4(E,A,B)+C+ctx->W[72]+0xca62c1d6L; E=SHA_ROTL(E,30); 
  303.   B = SHA_ROTL(C,5)+SHA_F4(D,E,A)+B+ctx->W[73]+0xca62c1d6L; D=SHA_ROTL(D,30); 
  304.   A = SHA_ROTL(B,5)+SHA_F4(C,D,E)+A+ctx->W[74]+0xca62c1d6L; C=SHA_ROTL(C,30); 
  305.   E = SHA_ROTL(A,5)+SHA_F4(B,C,D)+E+ctx->W[75]+0xca62c1d6L; B=SHA_ROTL(B,30); 
  306.   D = SHA_ROTL(E,5)+SHA_F4(A,B,C)+D+ctx->W[76]+0xca62c1d6L; A=SHA_ROTL(A,30); 
  307.   C = SHA_ROTL(D,5)+SHA_F4(E,A,B)+C+ctx->W[77]+0xca62c1d6L; E=SHA_ROTL(E,30); 
  308.   B = SHA_ROTL(C,5)+SHA_F4(D,E,A)+B+ctx->W[78]+0xca62c1d6L; D=SHA_ROTL(D,30); 
  309.   A = SHA_ROTL(B,5)+SHA_F4(C,D,E)+A+ctx->W[79]+0xca62c1d6L; C=SHA_ROTL(C,30); 
  311.   ctx->H[0] += A;
  312.   ctx->H[1] += B;
  313.   ctx->H[2] += C;
  314.   ctx->H[3] += D;
  315.   ctx->H[4] += E;
  316. }
  318. /*************************************************************************
  319. ** Code below this line added to make SHA code support BLAPI interface
  320. */
  322. SHA1Context *
  323. SHA1_NewContext(void)
  324. {
  325.     SHA1Context *cx;
  327.     cx = PORT_ZNew(SHA1Context);
  328.     return cx;
  329. }
  331. void
  332. SHA1_DestroyContext(SHA1Context *cx, PRBool freeit)
  333. {
  334.     if (freeit) {
  335.         PORT_ZFree(cx, sizeof(SHA1Context));
  336.     }
  337. }
  339. SECStatus
  340. SHA1_HashBuf(unsigned char *dest, const unsigned char *src, uint32 src_length)
  341. {
  342.     SHA1Context ctx;
  343.     unsigned int outLen;
  345.     SHA1_Begin(&ctx);
  346.     SHA1_Update(&ctx, src, src_length);
  347.     SHA1_End(&ctx, dest, &outLen, SHA1_LENGTH);
  349.     return SECSuccess;
  350. }
  352. /* Hash a null-terminated character string. */
  353. SECStatus
  354. SHA1_Hash(unsigned char *dest, const char *src)
  355. {
  356.     return SHA1_HashBuf(dest, (const unsigned char *)src, PORT_Strlen (src));
  357. }
  359. /*
  360.  * need to support save/restore state in pkcs11. Stores all the info necessary
  361.  * for a structure into just a stream of bytes.
  362.  */
  363. unsigned int
  364. SHA1_FlattenSize(SHA1Context *cx)
  365. {
  366.     return sizeof(SHA1Context);
  367. }
  369. SECStatus
  370. SHA1_Flatten(SHA1Context *cx,unsigned char *space)
  371. {
  372.     PORT_Memcpy(space,cx, sizeof(SHA1Context));
  373.     return SECSuccess;
  374. }
  376. SHA1Context *
  377. SHA1_Resurrect(unsigned char *space,void *arg)
  378. {
  379.     SHA1Context *cx = SHA1_NewContext();
  380.     if (cx == NULL) return NULL;
  382.     PORT_Memcpy(cx,space, sizeof(SHA1Context));
  383.     return cx;
  384. }
  386. #ifdef TRACING_SSL
  387. void
  388. SHA1_TraceState(SHA1Context *ctx)
  389. {
  390.     uint32        W;
  391.     int           i;
  392.     int           len;
  393.     int           fixWord = -1;
  394.     int           remainder; /* bytes in last word */
  395.     unsigned char buf[64 * 4];
  397.     SSL_TRC(99, ("%d: SSL: SHA1 state: %08x %08x %08x %08x %08x", SSL_GETPID(), 
  398.          ctx->H[0], ctx->H[1], ctx->H[2], ctx->H[3], ctx->H[4]));
  400.     len = (int)(ctx->sizeLo & 63);
  401.     remainder = len % 4;
  402.     if (remainder) 
  403.      fixWord = len - remainder;
  404.     for (i = 0; i < len; i++) {
  405. if (0 == (i % 4)) {
  406.     W = ctx->W[i / 4];
  407.     if (i == fixWord) {
  408.         W <<= 8 * (4 - remainder);
  409.     }
  410. }
  411. buf[i] = (unsigned char)(W >> 24);
  412. W <<= 8;
  413.     }
  415.     PRINT_BUF(99, (0, "SHA1_TraceState: buffered input", buf, len));
  417. }
  418. #endif