# 
# patch "ChangeLog"
#  from [af7bcfbb9185e6c1fe4e23cb79df4ba5a6865dbc]
#    to [7165b58d6714df0d8f33919e4cb91021799d6fd6]
# 
# patch "botan/sha160.cpp"
#  from [26bf25fdedd24cff075222e44da9f6a98af846c2]
#    to [f3c39163a2977d63f172f75ffe1891f2a2832239]
# 
# patch "botan/sha160.h"
#  from [e6c428fdf6c80f8c58de85a857e31e27fed82b2d]
#    to [e2ad1d38fddf6502076da1b95be4eafbbc7a54a2]
# 
===============================================
--- ChangeLog	af7bcfbb9185e6c1fe4e23cb79df4ba5a6865dbc
+++ ChangeLog	7165b58d6714df0d8f33919e4cb91021799d6fd6
@@ -1,3 +1,8 @@
+2005-07-18  Matt Johnston  <address@hidden>
+
+	* botan/sha160.{cpp,h}: new faster sha160 implementation from Jack Lloyd
+	and Kaushik Veeraraghavan.
+
 2005-07-17  Nathaniel Smith  <address@hidden>
 
 	* configure.ac, win32/monotone.iss, monotone.spec:
@@ -279,6 +284,16 @@
 
 	* interner.hh: make slightly faster
 
+2005-07-11  Matt Johnston  <address@hidden>
+
+	* hmac.cc: <string> not <string.h>
+
+2005-07-11  Matt Johnston  <address@hidden>
+
+	* keys.cc (encrypt_rsa): fix typo
+	* hmac.{cc,hh}: store key as SymmetricKey, pass correctly to
+	MAC_Filter
+
 2005-07-10  Nathaniel Smith  <address@hidden>
 
 	* ChangeLog, configure.ac: Re-remove mysteriously revived
@@ -342,6 +357,16 @@
 
 2005-07-08  Matt Johnston  <address@hidden>
 
+	* propagate mainline to botan branch
+
+	* constants.{cc,hh}: add sha1_digest_length as botan
+	doesn't provide a convenient definition.
+	* hmac.{cc,hh}: convert to use botan
+	* keys.cc (encrypt_rsa, decrypt_rsa): use botan
+	* transforms.{cc,hh}: use botan
+
+2005-07-08  Matt Johnston  <address@hidden>
+
 	* tests/t_normalized_filenames.at: expect exit code of 1 not 3 for
 	"cat manifest" with a directory in MT/work
 	* file_io.cc, netcmd.cc, transforms.cc, vocab.hh: revert changes which
===============================================
--- botan/sha160.cpp	26bf25fdedd24cff075222e44da9f6a98af846c2
+++ botan/sha160.cpp	f3c39163a2977d63f172f75ffe1891f2a2832239
@@ -1,122 +1,142 @@
 /*************************************************
 * SHA-160 Source File                            *
-* (C) 1999-2004 The Botan Project                *
+* (C) 1999-2005 The Botan Project                *
 *************************************************/
 
 #include <botan/sha160.h>
 
 namespace Botan {
 
-/*************************************************
-* SHA-160 Compression Function                   *
-*************************************************/
-void SHA_160::hash(const byte input[])
-   {
-   for(u32bit j = 0; j != 16; j++)
-      W[j] = make_u32bit(input[4*j], input[4*j+1], input[4*j+2], input[4*j+3]);
-   for(u32bit j = 16; j != 80; j++)
-      W[j] = rotate_left((W[j-3] ^ W[j-8] ^ W[j-14] ^ W[j-16]), 1);
+  namespace {
 
-   u32bit A = digest[0], B = digest[1], C = digest[2],
-          D = digest[3], E = digest[4];
+    /*************************************************
+     * SHA-160 F1 Function                            *
+     *************************************************/
+    inline void F1(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E, u32bit msg)
+    {
+      E += rotate_left(A, 5) + (D ^ (B & (C ^ D))) + msg + 0x5A827999;
+      B  = rotate_left(B, 30);
+    }
 
-   F1(A,B,C,D,E,W[ 0]);   F1(E,A,B,C,D,W[ 1]);   F1(D,E,A,B,C,W[ 2]);
-   F1(C,D,E,A,B,W[ 3]);   F1(B,C,D,E,A,W[ 4]);   F1(A,B,C,D,E,W[ 5]);
-   F1(E,A,B,C,D,W[ 6]);   F1(D,E,A,B,C,W[ 7]);   F1(C,D,E,A,B,W[ 8]);
-   F1(B,C,D,E,A,W[ 9]);   F1(A,B,C,D,E,W[10]);   F1(E,A,B,C,D,W[11]);
-   F1(D,E,A,B,C,W[12]);   F1(C,D,E,A,B,W[13]);   F1(B,C,D,E,A,W[14]);
-   F1(A,B,C,D,E,W[15]);   F1(E,A,B,C,D,W[16]);   F1(D,E,A,B,C,W[17]);
-   F1(C,D,E,A,B,W[18]);   F1(B,C,D,E,A,W[19]);
+    /*************************************************
+     * SHA-160 F2 Function                            *
+     *************************************************/
+    inline void F2(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E, u32bit msg)
+    {
+      E += rotate_left(A, 5) + (B ^ C ^ D) + msg + 0x6ED9EBA1;
+      B  = rotate_left(B, 30);
+    }
 
-   F2(A,B,C,D,E,W[20]);   F2(E,A,B,C,D,W[21]);   F2(D,E,A,B,C,W[22]);
-   F2(C,D,E,A,B,W[23]);   F2(B,C,D,E,A,W[24]);   F2(A,B,C,D,E,W[25]);
-   F2(E,A,B,C,D,W[26]);   F2(D,E,A,B,C,W[27]);   F2(C,D,E,A,B,W[28]);
-   F2(B,C,D,E,A,W[29]);   F2(A,B,C,D,E,W[30]);   F2(E,A,B,C,D,W[31]);
-   F2(D,E,A,B,C,W[32]);   F2(C,D,E,A,B,W[33]);   F2(B,C,D,E,A,W[34]);
-   F2(A,B,C,D,E,W[35]);   F2(E,A,B,C,D,W[36]);   F2(D,E,A,B,C,W[37]);
-   F2(C,D,E,A,B,W[38]);   F2(B,C,D,E,A,W[39]);
+    /*************************************************
+     * SHA-160 F3 Function                            *
+     *************************************************/
+    inline void F3(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E, u32bit msg)
+    {
+      E += rotate_left(A, 5) + ((B & C) | ((B | C) & D)) + msg + 0x8F1BBCDC;
+      B  = rotate_left(B, 30);
+    }
 
-   F3(A,B,C,D,E,W[40]);   F3(E,A,B,C,D,W[41]);   F3(D,E,A,B,C,W[42]);
-   F3(C,D,E,A,B,W[43]);   F3(B,C,D,E,A,W[44]);   F3(A,B,C,D,E,W[45]);
-   F3(E,A,B,C,D,W[46]);   F3(D,E,A,B,C,W[47]);   F3(C,D,E,A,B,W[48]);
-   F3(B,C,D,E,A,W[49]);   F3(A,B,C,D,E,W[50]);   F3(E,A,B,C,D,W[51]);
-   F3(D,E,A,B,C,W[52]);   F3(C,D,E,A,B,W[53]);   F3(B,C,D,E,A,W[54]);
-   F3(A,B,C,D,E,W[55]);   F3(E,A,B,C,D,W[56]);   F3(D,E,A,B,C,W[57]);
-   F3(C,D,E,A,B,W[58]);   F3(B,C,D,E,A,W[59]);
+    /*************************************************
+     * SHA-160 F4 Function                            *
+     *************************************************/
+    inline void F4(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E, u32bit msg)
+    {
+      E +=  rotate_left(A, 5) + (B ^ C ^ D) + msg + 0xCA62C1D6;
+      B  = rotate_left(B, 30);
+    }
 
-   F4(A,B,C,D,E,W[60]);   F4(E,A,B,C,D,W[61]);   F4(D,E,A,B,C,W[62]);
-   F4(C,D,E,A,B,W[63]);   F4(B,C,D,E,A,W[64]);   F4(A,B,C,D,E,W[65]);
-   F4(E,A,B,C,D,W[66]);   F4(D,E,A,B,C,W[67]);   F4(C,D,E,A,B,W[68]);
-   F4(B,C,D,E,A,W[69]);   F4(A,B,C,D,E,W[70]);   F4(E,A,B,C,D,W[71]);
-   F4(D,E,A,B,C,W[72]);   F4(C,D,E,A,B,W[73]);   F4(B,C,D,E,A,W[74]);
-   F4(A,B,C,D,E,W[75]);   F4(E,A,B,C,D,W[76]);   F4(D,E,A,B,C,W[77]);
-   F4(C,D,E,A,B,W[78]);   F4(B,C,D,E,A,W[79]);
+  }
 
-   digest[0] += A; digest[1] += B; digest[2] += C;
-   digest[3] += D; digest[4] += E;
-   }
+  /*************************************************
+   * SHA-160 Compression Function                   *
+   *************************************************/
+  void SHA_160::hash(const byte input[])
+  {
+    class SHA_Expander
+    {
+    public:
+      u32bit operator[](u32bit i)
+      {
+        if(i < 16)
+          W[i] = make_u32bit(in[4*i], in[4*i+1], in[4*i+2], in[4*i+3]);
+        else
+          W[i%16] = rotate_left(W[(i+13)%16] ^ W[(i+8)%16] ^
+                                W[(i+2)%16] ^ W[i%16], 1);
 
-/*************************************************
-* Copy out the digest                            *
-*************************************************/
-void SHA_160::copy_out(byte output[])
-   {
-   for(u32bit j = 0; j != OUTPUT_LENGTH; j++)
-      output[j] = get_byte(j % 4, digest[j/4]);
-   }
+        return W[i%16];
+      }
 
-/*************************************************
-* SHA-160 F1 Function                            *
-*************************************************/
-void SHA_160::F1(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E,
-                 u32bit msg)
-   {
-   E += rotate_left(A, 5) + (D ^ (B & (C ^ D))) + msg + 0x5A827999;
-   B  = rotate_left(B, 30);
-   }
+      void set_input(const byte* x) { in = x; }
 
-/*************************************************
-* SHA-160 F2 Function                            *
-*************************************************/
-void SHA_160::F2(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E,
-                 u32bit msg)
-   {
-   E += rotate_left(A, 5) + (B ^ C ^ D) + msg + 0x6ED9EBA1;
-   B  = rotate_left(B, 30);
-   }
+      ~SHA_Expander() { clear_mem(W, 16); }
+    private:
+      const byte* in;
+      u32bit W[16];
+    };
 
-/*************************************************
-* SHA-160 F3 Function                            *
-*************************************************/
-void SHA_160::F3(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E,
-                 u32bit msg)
-   {
-   E += rotate_left(A, 5) + ((B & C) | ((B | C) & D)) + msg + 0x8F1BBCDC;
-   B  = rotate_left(B, 30);
-   }
+    SHA_Expander W;
+    W.set_input(input);
 
-/*************************************************
-* SHA-160 F4 Function                            *
-*************************************************/
-void SHA_160::F4(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E,
-                 u32bit msg)
-   {
-   E += rotate_left(A, 5) + (B ^ C ^ D) + msg + 0xCA62C1D6;
-   B  = rotate_left(B, 30);
-   }
+    u32bit A = digest[0], B = digest[1], C = digest[2],
+      D = digest[3], E = digest[4];
 
-/*************************************************
-* Clear memory of sensitive data                 *
-*************************************************/
-void SHA_160::clear() throw()
-   {
-   MDx_HashFunction::clear();
-   W.clear();
-   digest[0] = 0x67452301;
-   digest[1] = 0xEFCDAB89;
-   digest[2] = 0x98BADCFE;
-   digest[3] = 0x10325476;
-   digest[4] = 0xC3D2E1F0;
-   }
+    F1(A,B,C,D,E,W[ 0]);   F1(E,A,B,C,D,W[ 1]);   F1(D,E,A,B,C,W[ 2]);
+    F1(C,D,E,A,B,W[ 3]);   F1(B,C,D,E,A,W[ 4]);   F1(A,B,C,D,E,W[ 5]);
+    F1(E,A,B,C,D,W[ 6]);   F1(D,E,A,B,C,W[ 7]);   F1(C,D,E,A,B,W[ 8]);
+    F1(B,C,D,E,A,W[ 9]);   F1(A,B,C,D,E,W[10]);   F1(E,A,B,C,D,W[11]);
+    F1(D,E,A,B,C,W[12]);   F1(C,D,E,A,B,W[13]);   F1(B,C,D,E,A,W[14]);
+    F1(A,B,C,D,E,W[15]);   F1(E,A,B,C,D,W[16]);   F1(D,E,A,B,C,W[17]);
+    F1(C,D,E,A,B,W[18]);   F1(B,C,D,E,A,W[19]);
 
+    F2(A,B,C,D,E,W[20]);   F2(E,A,B,C,D,W[21]);   F2(D,E,A,B,C,W[22]);
+    F2(C,D,E,A,B,W[23]);   F2(B,C,D,E,A,W[24]);   F2(A,B,C,D,E,W[25]);
+    F2(E,A,B,C,D,W[26]);   F2(D,E,A,B,C,W[27]);   F2(C,D,E,A,B,W[28]);
+    F2(B,C,D,E,A,W[29]);   F2(A,B,C,D,E,W[30]);   F2(E,A,B,C,D,W[31]);
+    F2(D,E,A,B,C,W[32]);   F2(C,D,E,A,B,W[33]);   F2(B,C,D,E,A,W[34]);
+    F2(A,B,C,D,E,W[35]);   F2(E,A,B,C,D,W[36]);   F2(D,E,A,B,C,W[37]);
+    F2(C,D,E,A,B,W[38]);   F2(B,C,D,E,A,W[39]);
+
+    F3(A,B,C,D,E,W[40]);   F3(E,A,B,C,D,W[41]);   F3(D,E,A,B,C,W[42]);
+    F3(C,D,E,A,B,W[43]);   F3(B,C,D,E,A,W[44]);   F3(A,B,C,D,E,W[45]);
+    F3(E,A,B,C,D,W[46]);   F3(D,E,A,B,C,W[47]);   F3(C,D,E,A,B,W[48]);
+    F3(B,C,D,E,A,W[49]);   F3(A,B,C,D,E,W[50]);   F3(E,A,B,C,D,W[51]);
+    F3(D,E,A,B,C,W[52]);   F3(C,D,E,A,B,W[53]);   F3(B,C,D,E,A,W[54]);
+    F3(A,B,C,D,E,W[55]);   F3(E,A,B,C,D,W[56]);   F3(D,E,A,B,C,W[57]);
+    F3(C,D,E,A,B,W[58]);   F3(B,C,D,E,A,W[59]);
+
+    F4(A,B,C,D,E,W[60]);   F4(E,A,B,C,D,W[61]);   F4(D,E,A,B,C,W[62]);
+    F4(C,D,E,A,B,W[63]);   F4(B,C,D,E,A,W[64]);   F4(A,B,C,D,E,W[65]);
+    F4(E,A,B,C,D,W[66]);   F4(D,E,A,B,C,W[67]);   F4(C,D,E,A,B,W[68]);
+    F4(B,C,D,E,A,W[69]);   F4(A,B,C,D,E,W[70]);   F4(E,A,B,C,D,W[71]);
+    F4(D,E,A,B,C,W[72]);   F4(C,D,E,A,B,W[73]);   F4(B,C,D,E,A,W[74]);
+    F4(A,B,C,D,E,W[75]);   F4(E,A,B,C,D,W[76]);   F4(D,E,A,B,C,W[77]);
+    F4(C,D,E,A,B,W[78]);   F4(B,C,D,E,A,W[79]);
+
+    digest[0] += A; digest[1] += B; digest[2] += C;
+    digest[3] += D; digest[4] += E;
+  }
+
+  /*************************************************
+   * Copy out the digest                            *
+   *************************************************/
+  void SHA_160::copy_out(byte output[])
+  {
+    for(u32bit j = 0; j != OUTPUT_LENGTH; j++)
+      output[j] = get_byte(j % 4, digest[j/4]);
+  }
+
+  /*************************************************
+   * Clear memory of sensitive data                 *
+   *************************************************/
+  void SHA_160::clear() throw()
+  {
+    MDx_HashFunction::clear();
+    digest[0] = 0x67452301;
+    digest[1] = 0xEFCDAB89;
+    digest[2] = 0x98BADCFE;
+    digest[3] = 0x10325476;
+    digest[4] = 0xC3D2E1F0;
+  }
+
 }
+
===============================================
--- botan/sha160.h	e6c428fdf6c80f8c58de85a857e31e27fed82b2d
+++ botan/sha160.h	e2ad1d38fddf6502076da1b95be4eafbbc7a54a2
@@ -1,6 +1,6 @@
 /*************************************************
 * SHA-160 Header File                            *
-* (C) 1999-2004 The Botan Project                *
+* (C) 1999-2005 The Botan Project                *
 *************************************************/
 
 #ifndef BOTAN_SHA_160_H__
@@ -27,14 +27,10 @@
       void hash(const byte[]);
       void copy_out(byte[]);
 
-      static void F1(u32bit, u32bit&, u32bit, u32bit, u32bit&, u32bit);
-      static void F2(u32bit, u32bit&, u32bit, u32bit, u32bit&, u32bit);
-      static void F3(u32bit, u32bit&, u32bit, u32bit, u32bit&, u32bit);
-      static void F4(u32bit, u32bit&, u32bit, u32bit, u32bit&, u32bit);
-      SecureBuffer<u32bit, 80> W;
       SecureBuffer<u32bit, 5> digest;
    };
 
 }
 
 #endif
+