* main.h, keylist.c (print_revokers): New. Print the "rvk" designated
[gnupg.git] / cipher / sha1.c
index 1685058..d150fad 100644 (file)
@@ -1,69 +1,24 @@
 /* sha1.c - SHA1 hash function
- *     Copyright (c) 1997 by Werner Koch (dd9jn)
+ *     Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
  *
- * Please see below for more legal informations!
+ * Please see below for more legal information!
  *
- * This file is part of G10.
+ * This file is part of GnuPG.
  *
- * G10 is free software; you can redistribute it and/or modify
+ * GnuPG is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
- * G10 is distributed in the hope that it will be useful,
+ * GnuPG is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-/* I took the code for transform() from the Linux kernel
- * (/usr/src/linux/drivers/char/random.c) which has
- *
- * a) This notice:
- * ---------------
- * SHA transform algorithm, taken from code written by Peter Gutman,
- * and apparently in the public domain.
- *
- * b) This copyright notice:
- * -------------------------
- * Version 1.00, last modified 26-May-96
- *
- * Copyright Theodore Ts'o, 1994, 1995, 1996.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, and the entire permission notice in its entirety,
- *    including the disclaimer of warranties.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote
- *    products derived from this software without specific prior
- *    written permission.
- *
- * ALTERNATIVELY, this product may be distributed under the terms of
- * the GNU Public License, in which case the provisions of the GPL are
- * required INSTEAD OF the above restrictions. (This clause is
- * necessary due to a potential bad interaction between the GPL and
- * the restrictions contained in a BSD-style copyright.)
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
  */
 
 
 #include <assert.h>
 #include "util.h"
 #include "memory.h"
-#include "cipher.h" /* grrrr */
-#include "sha1.h"
-
-
-/* The SHA f()-functions.  */
-#define f1(x,y,z)   ( z ^ ( x & ( y ^ z ) ) )          /* Rounds  0-19 */
-#define f2(x,y,z)   ( x ^ y ^ z )                      /* Rounds 20-39 */
-#define f3(x,y,z)   ( ( x & y ) | ( z & ( x | y ) ) )  /* Rounds 40-59 */
-#define f4(x,y,z)   ( x ^ y ^ z )                      /* Rounds 60-79 */
+#include "algorithms.h"
+#include "bithelp.h"
 
-/* The SHA Mysterious Constants */
-#define K1  0x5A827999L                                /* Rounds  0-19 */
-#define K2  0x6ED9EBA1L                                /* Rounds 20-39 */
-#define K3  0x8F1BBCDCL                                /* Rounds 40-59 */
-#define K4  0xCA62C1D6L                                /* Rounds 60-79 */
 
-#define ROTL(n,X)  ( ( ( X ) << n ) | ( ( X ) >> ( 32 - n ) ) )
+typedef struct {
+    u32  h0,h1,h2,h3,h4;
+    u32  nblocks;
+    byte buf[64];
+    int  count;
+} SHA1_CONTEXT;
 
-#define expand(W,i) ( W[ i & 15 ] = \
-                    ROTL( 1, ( W[ i & 15 ] ^ W[ (i - 14) & 15 ] ^ \
-                               W[ (i - 8) & 15 ] ^ W[ (i - 3) & 15 ] ) ) )
-
-#define subRound(a, b, c, d, e, f, k, data) \
-    ( e += ROTL( 5, a ) + f( b, c, d ) + k + data, b = ROTL( 30, b ) )
+static void
+burn_stack (int bytes)
+{
+    char buf[128];
+    
+    wipememory(buf,sizeof buf);
+    bytes -= sizeof buf;
+    if (bytes > 0)
+        burn_stack (bytes);
+}
 
 
-static void
-initialize( SHA1HANDLE hd )
+void
+sha1_init( SHA1_CONTEXT *hd )
 {
     hd->h0 = 0x67452301;
     hd->h1 = 0xefcdab89;
     hd->h2 = 0x98badcfe;
     hd->h3 = 0x10325476;
     hd->h4 = 0xc3d2e1f0;
-    hd->bufcount = 0;
     hd->nblocks = 0;
+    hd->count = 0;
 }
 
 
@@ -127,189 +79,160 @@ initialize( SHA1HANDLE hd )
  * Transform the message X which consists of 16 32-bit-words
  */
 static void
-transform( SHA1HANDLE hd, byte *data )
+transform( SHA1_CONTEXT *hd, byte *data )
 {
-    u32 A, B, C, D, E;    /* Local vars */
-    u32 eData[ 16 ];      /* Expanded data */
-
-    /* Set up first buffer and local data buffer */
-    A = hd->h0;
-    B = hd->h1;
-    C = hd->h2;
-    D = hd->h3;
-    E = hd->h4;
-
-  #ifdef BIG_ENDIAN_HOST
-    memcpy( eData, data, 64 );
-  #else
+    u32 a,b,c,d,e,tm;
+    u32 x[16];
+
+    /* get values from the chaining vars */
+    a = hd->h0;
+    b = hd->h1;
+    c = hd->h2;
+    d = hd->h3;
+    e = hd->h4;
+
+#ifdef BIG_ENDIAN_HOST
+    memcpy( x, data, 64 );
+#else
     { int i;
       byte *p2;
-      for(i=0, p2=(byte*)eData; i < 16; i++, p2 += 4 ) {
+      for(i=0, p2=(byte*)x; i < 16; i++, p2 += 4 ) {
        p2[3] = *data++;
        p2[2] = *data++;
        p2[1] = *data++;
        p2[0] = *data++;
       }
     }
-  #endif
-
-    /* Heavy mangling, in 4 sub-rounds of 20 iterations each. */
-    subRound( A, B, C, D, E, f1, K1, eData[  0 ] );
-    subRound( E, A, B, C, D, f1, K1, eData[  1 ] );
-    subRound( D, E, A, B, C, f1, K1, eData[  2 ] );
-    subRound( C, D, E, A, B, f1, K1, eData[  3 ] );
-    subRound( B, C, D, E, A, f1, K1, eData[  4 ] );
-    subRound( A, B, C, D, E, f1, K1, eData[  5 ] );
-    subRound( E, A, B, C, D, f1, K1, eData[  6 ] );
-    subRound( D, E, A, B, C, f1, K1, eData[  7 ] );
-    subRound( C, D, E, A, B, f1, K1, eData[  8 ] );
-    subRound( B, C, D, E, A, f1, K1, eData[  9 ] );
-    subRound( A, B, C, D, E, f1, K1, eData[ 10 ] );
-    subRound( E, A, B, C, D, f1, K1, eData[ 11 ] );
-    subRound( D, E, A, B, C, f1, K1, eData[ 12 ] );
-    subRound( C, D, E, A, B, f1, K1, eData[ 13 ] );
-    subRound( B, C, D, E, A, f1, K1, eData[ 14 ] );
-    subRound( A, B, C, D, E, f1, K1, eData[ 15 ] );
-    subRound( E, A, B, C, D, f1, K1, expand( eData, 16 ) );
-    subRound( D, E, A, B, C, f1, K1, expand( eData, 17 ) );
-    subRound( C, D, E, A, B, f1, K1, expand( eData, 18 ) );
-    subRound( B, C, D, E, A, f1, K1, expand( eData, 19 ) );
-
-    subRound( A, B, C, D, E, f2, K2, expand( eData, 20 ) );
-    subRound( E, A, B, C, D, f2, K2, expand( eData, 21 ) );
-    subRound( D, E, A, B, C, f2, K2, expand( eData, 22 ) );
-    subRound( C, D, E, A, B, f2, K2, expand( eData, 23 ) );
-    subRound( B, C, D, E, A, f2, K2, expand( eData, 24 ) );
-    subRound( A, B, C, D, E, f2, K2, expand( eData, 25 ) );
-    subRound( E, A, B, C, D, f2, K2, expand( eData, 26 ) );
-    subRound( D, E, A, B, C, f2, K2, expand( eData, 27 ) );
-    subRound( C, D, E, A, B, f2, K2, expand( eData, 28 ) );
-    subRound( B, C, D, E, A, f2, K2, expand( eData, 29 ) );
-    subRound( A, B, C, D, E, f2, K2, expand( eData, 30 ) );
-    subRound( E, A, B, C, D, f2, K2, expand( eData, 31 ) );
-    subRound( D, E, A, B, C, f2, K2, expand( eData, 32 ) );
-    subRound( C, D, E, A, B, f2, K2, expand( eData, 33 ) );
-    subRound( B, C, D, E, A, f2, K2, expand( eData, 34 ) );
-    subRound( A, B, C, D, E, f2, K2, expand( eData, 35 ) );
-    subRound( E, A, B, C, D, f2, K2, expand( eData, 36 ) );
-    subRound( D, E, A, B, C, f2, K2, expand( eData, 37 ) );
-    subRound( C, D, E, A, B, f2, K2, expand( eData, 38 ) );
-    subRound( B, C, D, E, A, f2, K2, expand( eData, 39 ) );
-
-    subRound( A, B, C, D, E, f3, K3, expand( eData, 40 ) );
-    subRound( E, A, B, C, D, f3, K3, expand( eData, 41 ) );
-    subRound( D, E, A, B, C, f3, K3, expand( eData, 42 ) );
-    subRound( C, D, E, A, B, f3, K3, expand( eData, 43 ) );
-    subRound( B, C, D, E, A, f3, K3, expand( eData, 44 ) );
-    subRound( A, B, C, D, E, f3, K3, expand( eData, 45 ) );
-    subRound( E, A, B, C, D, f3, K3, expand( eData, 46 ) );
-    subRound( D, E, A, B, C, f3, K3, expand( eData, 47 ) );
-    subRound( C, D, E, A, B, f3, K3, expand( eData, 48 ) );
-    subRound( B, C, D, E, A, f3, K3, expand( eData, 49 ) );
-    subRound( A, B, C, D, E, f3, K3, expand( eData, 50 ) );
-    subRound( E, A, B, C, D, f3, K3, expand( eData, 51 ) );
-    subRound( D, E, A, B, C, f3, K3, expand( eData, 52 ) );
-    subRound( C, D, E, A, B, f3, K3, expand( eData, 53 ) );
-    subRound( B, C, D, E, A, f3, K3, expand( eData, 54 ) );
-    subRound( A, B, C, D, E, f3, K3, expand( eData, 55 ) );
-    subRound( E, A, B, C, D, f3, K3, expand( eData, 56 ) );
-    subRound( D, E, A, B, C, f3, K3, expand( eData, 57 ) );
-    subRound( C, D, E, A, B, f3, K3, expand( eData, 58 ) );
-    subRound( B, C, D, E, A, f3, K3, expand( eData, 59 ) );
-
-    subRound( A, B, C, D, E, f4, K4, expand( eData, 60 ) );
-    subRound( E, A, B, C, D, f4, K4, expand( eData, 61 ) );
-    subRound( D, E, A, B, C, f4, K4, expand( eData, 62 ) );
-    subRound( C, D, E, A, B, f4, K4, expand( eData, 63 ) );
-    subRound( B, C, D, E, A, f4, K4, expand( eData, 64 ) );
-    subRound( A, B, C, D, E, f4, K4, expand( eData, 65 ) );
-    subRound( E, A, B, C, D, f4, K4, expand( eData, 66 ) );
-    subRound( D, E, A, B, C, f4, K4, expand( eData, 67 ) );
-    subRound( C, D, E, A, B, f4, K4, expand( eData, 68 ) );
-    subRound( B, C, D, E, A, f4, K4, expand( eData, 69 ) );
-    subRound( A, B, C, D, E, f4, K4, expand( eData, 70 ) );
-    subRound( E, A, B, C, D, f4, K4, expand( eData, 71 ) );
-    subRound( D, E, A, B, C, f4, K4, expand( eData, 72 ) );
-    subRound( C, D, E, A, B, f4, K4, expand( eData, 73 ) );
-    subRound( B, C, D, E, A, f4, K4, expand( eData, 74 ) );
-    subRound( A, B, C, D, E, f4, K4, expand( eData, 75 ) );
-    subRound( E, A, B, C, D, f4, K4, expand( eData, 76 ) );
-    subRound( D, E, A, B, C, f4, K4, expand( eData, 77 ) );
-    subRound( C, D, E, A, B, f4, K4, expand( eData, 78 ) );
-    subRound( B, C, D, E, A, f4, K4, expand( eData, 79 ) );
-
-    /* Build message digest */
-    hd->h0 += A;
-    hd->h1 += B;
-    hd->h2 += C;
-    hd->h3 += D;
-    hd->h4 += E;
-}
-
-
-
-
-SHA1HANDLE
-sha1_open( int secure )
-{
-    SHA1HANDLE hd;
-
-    hd = secure? m_alloc_secure( sizeof *hd )
-              : m_alloc( sizeof *hd );
-    initialize(hd);
-    return hd;
-}
-
-
-SHA1HANDLE
-sha1_copy( SHA1HANDLE a )
-{
-    SHA1HANDLE b;
-
-    assert(a);
-    b = m_is_secure(a)? m_alloc_secure( sizeof *b )
-                     : m_alloc( sizeof *b );
-    memcpy( b, a, sizeof *a );
-    return b;
+#endif
+
+
+#define K1  0x5A827999L
+#define K2  0x6ED9EBA1L
+#define K3  0x8F1BBCDCL
+#define K4  0xCA62C1D6L
+#define F1(x,y,z)   ( z ^ ( x & ( y ^ z ) ) )
+#define F2(x,y,z)   ( x ^ y ^ z )
+#define F3(x,y,z)   ( ( x & y ) | ( z & ( x | y ) ) )
+#define F4(x,y,z)   ( x ^ y ^ z )
+
+
+#define M(i) ( tm =   x[i&0x0f] ^ x[(i-14)&0x0f] \
+                   ^ x[(i-8)&0x0f] ^ x[(i-3)&0x0f] \
+              , (x[i&0x0f] = rol(tm,1)) )
+
+#define R(a,b,c,d,e,f,k,m)  do { e += rol( a, 5 )     \
+                                     + f( b, c, d )  \
+                                     + k             \
+                                     + m;            \
+                                b = rol( b, 30 );    \
+                              } while(0)
+    R( a, b, c, d, e, F1, K1, x[ 0] );
+    R( e, a, b, c, d, F1, K1, x[ 1] );
+    R( d, e, a, b, c, F1, K1, x[ 2] );
+    R( c, d, e, a, b, F1, K1, x[ 3] );
+    R( b, c, d, e, a, F1, K1, x[ 4] );
+    R( a, b, c, d, e, F1, K1, x[ 5] );
+    R( e, a, b, c, d, F1, K1, x[ 6] );
+    R( d, e, a, b, c, F1, K1, x[ 7] );
+    R( c, d, e, a, b, F1, K1, x[ 8] );
+    R( b, c, d, e, a, F1, K1, x[ 9] );
+    R( a, b, c, d, e, F1, K1, x[10] );
+    R( e, a, b, c, d, F1, K1, x[11] );
+    R( d, e, a, b, c, F1, K1, x[12] );
+    R( c, d, e, a, b, F1, K1, x[13] );
+    R( b, c, d, e, a, F1, K1, x[14] );
+    R( a, b, c, d, e, F1, K1, x[15] );
+    R( e, a, b, c, d, F1, K1, M(16) );
+    R( d, e, a, b, c, F1, K1, M(17) );
+    R( c, d, e, a, b, F1, K1, M(18) );
+    R( b, c, d, e, a, F1, K1, M(19) );
+    R( a, b, c, d, e, F2, K2, M(20) );
+    R( e, a, b, c, d, F2, K2, M(21) );
+    R( d, e, a, b, c, F2, K2, M(22) );
+    R( c, d, e, a, b, F2, K2, M(23) );
+    R( b, c, d, e, a, F2, K2, M(24) );
+    R( a, b, c, d, e, F2, K2, M(25) );
+    R( e, a, b, c, d, F2, K2, M(26) );
+    R( d, e, a, b, c, F2, K2, M(27) );
+    R( c, d, e, a, b, F2, K2, M(28) );
+    R( b, c, d, e, a, F2, K2, M(29) );
+    R( a, b, c, d, e, F2, K2, M(30) );
+    R( e, a, b, c, d, F2, K2, M(31) );
+    R( d, e, a, b, c, F2, K2, M(32) );
+    R( c, d, e, a, b, F2, K2, M(33) );
+    R( b, c, d, e, a, F2, K2, M(34) );
+    R( a, b, c, d, e, F2, K2, M(35) );
+    R( e, a, b, c, d, F2, K2, M(36) );
+    R( d, e, a, b, c, F2, K2, M(37) );
+    R( c, d, e, a, b, F2, K2, M(38) );
+    R( b, c, d, e, a, F2, K2, M(39) );
+    R( a, b, c, d, e, F3, K3, M(40) );
+    R( e, a, b, c, d, F3, K3, M(41) );
+    R( d, e, a, b, c, F3, K3, M(42) );
+    R( c, d, e, a, b, F3, K3, M(43) );
+    R( b, c, d, e, a, F3, K3, M(44) );
+    R( a, b, c, d, e, F3, K3, M(45) );
+    R( e, a, b, c, d, F3, K3, M(46) );
+    R( d, e, a, b, c, F3, K3, M(47) );
+    R( c, d, e, a, b, F3, K3, M(48) );
+    R( b, c, d, e, a, F3, K3, M(49) );
+    R( a, b, c, d, e, F3, K3, M(50) );
+    R( e, a, b, c, d, F3, K3, M(51) );
+    R( d, e, a, b, c, F3, K3, M(52) );
+    R( c, d, e, a, b, F3, K3, M(53) );
+    R( b, c, d, e, a, F3, K3, M(54) );
+    R( a, b, c, d, e, F3, K3, M(55) );
+    R( e, a, b, c, d, F3, K3, M(56) );
+    R( d, e, a, b, c, F3, K3, M(57) );
+    R( c, d, e, a, b, F3, K3, M(58) );
+    R( b, c, d, e, a, F3, K3, M(59) );
+    R( a, b, c, d, e, F4, K4, M(60) );
+    R( e, a, b, c, d, F4, K4, M(61) );
+    R( d, e, a, b, c, F4, K4, M(62) );
+    R( c, d, e, a, b, F4, K4, M(63) );
+    R( b, c, d, e, a, F4, K4, M(64) );
+    R( a, b, c, d, e, F4, K4, M(65) );
+    R( e, a, b, c, d, F4, K4, M(66) );
+    R( d, e, a, b, c, F4, K4, M(67) );
+    R( c, d, e, a, b, F4, K4, M(68) );
+    R( b, c, d, e, a, F4, K4, M(69) );
+    R( a, b, c, d, e, F4, K4, M(70) );
+    R( e, a, b, c, d, F4, K4, M(71) );
+    R( d, e, a, b, c, F4, K4, M(72) );
+    R( c, d, e, a, b, F4, K4, M(73) );
+    R( b, c, d, e, a, F4, K4, M(74) );
+    R( a, b, c, d, e, F4, K4, M(75) );
+    R( e, a, b, c, d, F4, K4, M(76) );
+    R( d, e, a, b, c, F4, K4, M(77) );
+    R( c, d, e, a, b, F4, K4, M(78) );
+    R( b, c, d, e, a, F4, K4, M(79) );
+
+    /* update chainig vars */
+    hd->h0 += a;
+    hd->h1 += b;
+    hd->h2 += c;
+    hd->h3 += d;
+    hd->h4 += e;
 }
 
 
-/* BAD Kludge!!! */
-MD_HANDLE *
-sha1_copy2md( SHA1HANDLE a )
-{
-    MD_HANDLE *md = md_makecontainer( DIGEST_ALGO_SHA1 );
-    md->u.sha1 = sha1_copy( a );
-    return md;
-}
-
-
-
-void
-sha1_close(SHA1HANDLE hd)
-{
-    if( hd )
-       m_free(hd);
-}
-
-
-
 /* Update the message digest with the contents
  * of INBUF with length INLEN.
  */
-void
-sha1_write( SHA1HANDLE hd, byte *inbuf, size_t inlen)
+static void
+sha1_write( SHA1_CONTEXT *hd, byte *inbuf, size_t inlen)
 {
-    if( hd->bufcount == 64 ) { /* flush the buffer */
-       transform( hd, hd->buffer );
-       hd->bufcount = 0;
+    if( hd->count == 64 ) { /* flush the buffer */
+       transform( hd, hd->buf );
+        burn_stack (88+4*sizeof(void*));
+       hd->count = 0;
        hd->nblocks++;
     }
     if( !inbuf )
        return;
-    if( hd->bufcount ) {
-       for( ; inlen && hd->bufcount < 64; inlen-- )
-           hd->buffer[hd->bufcount++] = *inbuf++;
+    if( hd->count ) {
+       for( ; inlen && hd->count < 64; inlen-- )
+           hd->buf[hd->count++] = *inbuf++;
        sha1_write( hd, NULL, 0 );
        if( !inlen )
            return;
@@ -317,13 +240,14 @@ sha1_write( SHA1HANDLE hd, byte *inbuf, size_t inlen)
 
     while( inlen >= 64 ) {
        transform( hd, inbuf );
-       hd->bufcount = 0;
+       hd->count = 0;
        hd->nblocks++;
        inlen -= 64;
        inbuf += 64;
     }
-    for( ; inlen && hd->bufcount < 64; inlen-- )
-       hd->buffer[hd->bufcount++] = *inbuf++;
+    burn_stack (88+4*sizeof(void*));
+    for( ; inlen && hd->count < 64; inlen-- )
+       hd->buf[hd->count++] = *inbuf++;
 }
 
 
@@ -334,66 +258,102 @@ sha1_write( SHA1HANDLE hd, byte *inbuf, size_t inlen)
  * Returns: 20 bytes representing the digest.
  */
 
-byte *
-sha1_final(SHA1HANDLE hd)
+static void
+sha1_final(SHA1_CONTEXT *hd)
 {
     u32 t, msb, lsb;
     byte *p;
 
     sha1_write(hd, NULL, 0); /* flush */;
 
-    msb = 0;
     t = hd->nblocks;
-    if( (lsb = t << 6) < t ) /* multiply by 64 to make a byte count */
-       msb++;
-    msb += t >> 26;
+    /* multiply by 64 to make a byte count */
+    lsb = t << 6;
+    msb = t >> 26;
+    /* add the count */
     t = lsb;
-    if( (lsb = t + hd->bufcount) < t ) /* add the bufcount */
+    if( (lsb += hd->count) < t )
        msb++;
+    /* multiply by 8 to make a bit count */
     t = lsb;
-    if( (lsb = t << 3) < t ) /* multiply by 8 to make a bit count */
-       msb++;
-    msb += t >> 29;
-
-    if( hd->bufcount < 56 ) { /* enough room */
-       hd->buffer[hd->bufcount++] = 0x80; /* pad */
-       while( hd->bufcount < 56 )
-           hd->buffer[hd->bufcount++] = 0;  /* pad */
+    lsb <<= 3;
+    msb <<= 3;
+    msb |= t >> 29;
+
+    if( hd->count < 56 ) { /* enough room */
+       hd->buf[hd->count++] = 0x80; /* pad */
+       while( hd->count < 56 )
+           hd->buf[hd->count++] = 0;  /* pad */
     }
     else { /* need one extra block */
-       hd->buffer[hd->bufcount++] = 0x80; /* pad character */
-       while( hd->bufcount < 64 )
-           hd->buffer[hd->bufcount++] = 0;
+       hd->buf[hd->count++] = 0x80; /* pad character */
+       while( hd->count < 64 )
+           hd->buf[hd->count++] = 0;
        sha1_write(hd, NULL, 0);  /* flush */;
-       memset(hd->buffer, 0, 56 ); /* fill next block with zeroes */
+       memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
     }
     /* append the 64 bit count */
-    hd->buffer[56] = msb >> 24;
-    hd->buffer[57] = msb >> 16;
-    hd->buffer[58] = msb >>  8;
-    hd->buffer[59] = msb      ;
-    hd->buffer[60] = lsb >> 24;
-    hd->buffer[61] = lsb >> 16;
-    hd->buffer[62] = lsb >>  8;
-    hd->buffer[63] = lsb      ;
-    transform( hd, hd->buffer );
-
-    p = hd->buffer;
-  #ifdef BIG_ENDIAN_HOST
-    #define X(a) do { *(u32*)p = hd->h##a ; p += 4; } while(0)
-  #else /* little endian */
-    #define X(a) do { *p++ = hd->h##a >> 24; *p++ = hd->h##a >> 16;     \
+    hd->buf[56] = msb >> 24;
+    hd->buf[57] = msb >> 16;
+    hd->buf[58] = msb >>  8;
+    hd->buf[59] = msb     ;
+    hd->buf[60] = lsb >> 24;
+    hd->buf[61] = lsb >> 16;
+    hd->buf[62] = lsb >>  8;
+    hd->buf[63] = lsb     ;
+    transform( hd, hd->buf );
+    burn_stack (88+4*sizeof(void*));
+
+    p = hd->buf;
+#ifdef BIG_ENDIAN_HOST
+#define X(a) do { *(u32*)p = hd->h##a ; p += 4; } while(0)
+#else /* little endian */
+#define X(a) do { *p++ = hd->h##a >> 24; *p++ = hd->h##a >> 16;         \
                      *p++ = hd->h##a >> 8; *p++ = hd->h##a; } while(0)
-  #endif
+#endif
     X(0);
     X(1);
     X(2);
     X(3);
     X(4);
-  #undef X
-
-    initialize( hd );  /* prepare for next cycle */
-    return hd->buffer; /* now contains the digest */
+#undef X
 }
 
+static byte *
+sha1_read( SHA1_CONTEXT *hd )
+{
+    return hd->buf;
+}
 
+/****************
+ * Return some information about the algorithm.  We need algo here to
+ * distinguish different flavors of the algorithm.
+ * Returns: A pointer to string describing the algorithm or NULL if
+ *         the ALGO is invalid.
+ */
+const char *
+sha1_get_info( int algo, size_t *contextsize,
+              byte **r_asnoid, int *r_asnlen, int *r_mdlen,
+              void (**r_init)( void *c ),
+              void (**r_write)( void *c, byte *buf, size_t nbytes ),
+              void (**r_final)( void *c ),
+              byte *(**r_read)( void *c )
+            )
+{
+    static byte asn[15] = /* Object ID is 1.3.14.3.2.26 */
+                   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
+                     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
+    if( algo != 2 )
+       return NULL;
+
+    *contextsize = sizeof(SHA1_CONTEXT);
+    *r_asnoid = asn;
+    *r_asnlen = DIM(asn);
+    *r_mdlen = 20;
+    *(void  (**)(SHA1_CONTEXT *))r_init                = sha1_init;
+    *(void  (**)(SHA1_CONTEXT *, byte*, size_t))r_write = sha1_write;
+    *(void  (**)(SHA1_CONTEXT *))r_final               = sha1_final;
+    *(byte *(**)(SHA1_CONTEXT *))r_read                = sha1_read;
+
+    return "SHA1";
+}