Make asm implementations distinctly named objects, for instance MD5_IA32,

rather than silently replacing the C++ versions. Instead they are silently
replaced (currently, at least) at the lookup level: we switch off the set
of feature macros set to choose the best implementation in the current
build configuration. So you can have (and benchmark) MD5 and MD5_IA32
directly against each other in the same program with no hassles, but if
you ask for "MD5", you'll get maybe an MD5 or maybe MD5_IA32.

Also make the canonical asm names (which aren't guarded by C++ namespaces)
of the form botan_<algo>_<arch>_<func> as in botan_sha160_ia32_compress,
to avoid namespace collisions.

This change has another bonus that it should in many cases be possible to
derive the asm specializations directly from the original implementation,
saving some code (and of course logically SHA_160_IA32 is a SHA_160, just
one with a faster implementation of the compression function, so this seems
reasonable anyway).

34 files changed, 485 insertions, 191 deletions

diff --git a/configure.pl b/configure.pl
index 87ec7f90b..1fddc6121 100755
--- a/configure.pl
+++ b/configure.pl
@@ -411,13 +411,17 @@ sub autoload_modules {
 
     my $asm_ok = $$config{'asm_ok'};
 
-    my @autoloaded;
+    my %loaded; # type -> { mod1 => 1, mod2 => 1 }
 
     MOD: foreach my $mod (sort keys %MODULES) {
         my %modinfo = %{ $MODULES{$mod} };
 
         my $realname = $modinfo{'realname'};
 
+        my $type = $modinfo{'type'};
+
+        #autoconfig("$mod '$realname' is $type");
+
         if(defined($$config{'modules'}{$mod})) {
             my $n = $$config{'modules'}{$mod};
 
@@ -426,28 +430,12 @@ sub autoload_modules {
                 next;
             }
             else {
-                autoconfig("$mod ($realname): loading by user request");
+                #$loaded{$type}{$mod} = 1;
+                #autoconfig("$mod ($realname): loading by user request");
                 next;
             }
         }
 
-        foreach my $req_mod (@{$modinfo{'requires'}}) {
-            if(defined($$config{'modules'}{$req_mod})) {
-                if($$config{'modules'}{$req_mod} < 0) {
-                    autoconfig("Disabling $mod since required module " .
-                               "$req_mod is disabled");
-
-                    $$config{'modules'}{$mod} = -1;
-                    next MOD;
-                }
-
-            } else {
-                autoconfig("Enabling module $req_mod - required by $mod");
-                $$config{'modules'}{$req_mod} = 1;
-                load_module($config, $req_mod);
-            }
-        }
-
         my @arch_list = @{ $modinfo{'arch'} };
         if(scalar @arch_list > 0 &&
            !in_array($arch, \@arch_list) &&
@@ -478,17 +466,37 @@ sub autoload_modules {
             next;
         }
 
+        foreach my $req_mod (@{$modinfo{'requires'}}) {
+            if(defined($$config{'modules'}{$req_mod})) {
+                if($$config{'modules'}{$req_mod} < 0) {
+                    autoconfig("Disabling $mod since required module " .
+                               "$req_mod is disabled");
+                    $$config{'modules'}{$mod} = -1;
+                    next MOD;
+                }
+
+            } else {
+                autoconfig("Enabling module $req_mod - required by $mod");
+                $$config{'modules'}{$req_mod} = 1;
+                $loaded{$type}{$mod} = 1;
+                load_module($config, $req_mod);
+            }
+        }
+
         if($modinfo{'load_on'} eq 'request') {
             autoconfig("$mod ($realname): skipping, loaded by request only");
             next;
         }
 
-        push @autoloaded, $mod;
-        trace("$mod ($realname): loading");
+        autoconfig("$mod ($realname): loading");
+        $loaded{$type}{$mod} = 1;
         $$config{'modules'}{$mod} = 1;
     }
 
-    autoconfig("Loaded " . join(' ', @autoloaded));
+    for my $type (sort keys %loaded) {
+        my %mods = %{$loaded{$type}};
+         autoconfig("*** Loading $type: " . join(' ', sort keys %mods));
+    }
 }
 
 sub get_options {
@@ -1111,6 +1119,8 @@ sub load_module {
 
     trace("load_module($modname)");
 
+    croak("Unknown module $modname") unless defined($MODULES{$modname});
+
     my %module = %{$MODULES{$modname}};
 
     my $works_on = sub {
@@ -1412,8 +1422,12 @@ sub get_module_info {
    $info{'load_on'} = 'request'; # default unless specified
    $info{'libs'} = {};
 
+   my @dir_arr = File::Spec->splitdir($dirs);
+   $info{'type'} = $dir_arr[$#dir_arr-2]; # cipher, hash, ...
+   if($info{'type'} eq 'src') { $info{'type'} = $dir_arr[$#dir_arr-1]; }
+
    while($_ = &$reader()) {
-       match_any_of($_, \%info, 'quoted', 'realname', 'note');
+       match_any_of($_, \%info, 'quoted', 'realname', 'note', 'type');
        match_any_of($_, \%info, 'unquoted', 'define', 'mp_bits', 'modset', 'load_on');
 
        read_list($_, $reader, 'arch', list_push(\@{$info{'arch'}}));
diff --git a/src/bigint/info.txt b/src/bigint/info.txt
index 966d719d6..33b738d49 100644
--- a/src/bigint/info.txt
+++ b/src/bigint/info.txt
@@ -6,7 +6,7 @@ define BIGINT
 
 <requires>
 hex
-mp_generic
+mp_ia32
 </requires>
 
 <add>
diff --git a/src/bigint/mp_amd64/xxxinfo.txt b/src/bigint/mp_amd64/info.txt
index 797d3833a..797d3833a 100644
--- a/src/bigint/mp_amd64/xxxinfo.txt
+++ b/src/bigint/mp_amd64/info.txt
diff --git a/src/bigint/mp_ia32/xxxinfo.txt b/src/bigint/mp_ia32/info.txt
index 98c66e190..51f98fda8 100644
--- a/src/bigint/mp_ia32/xxxinfo.txt
+++ b/src/bigint/mp_ia32/info.txt
@@ -1,4 +1,4 @@
-realname "MPI Core (x86)"
+realname "MPI Core (IA-32)"
 
 mp_bits 32
 
diff --git a/src/cipher/serpent_ia32/info.txt b/src/cipher/serpent_ia32/info.txt
new file mode 100644
index 000000000..67f18beee
--- /dev/null
+++ b/src/cipher/serpent_ia32/info.txt
@@ -0,0 +1,34 @@
+realname "Serpent (IA-32)"
+
+define SERPENT_IA32
+
+load_on auto
+
+<add>
+serp_ia32_imp.S
+serp_ia32.cpp
+serp_ia32.h
+</add>
+
+<required>
+asm_ia32
+utils
+</required>
+
+<arch>
+ia32
+</arch>
+
+<cc>
+gcc
+icc
+</cc>
+
+# ELF systems
+<os>
+linux
+freebsd
+netbsd
+openbsd
+solaris
+</os>
diff --git a/src/cipher/serpent_ia32/serpent.cpp b/src/cipher/serpent_ia32/serp_ia32.cpp
index aacb72b0f..2cd607c18 100644
--- a/src/cipher/serpent_ia32/serpent.cpp
+++ b/src/cipher/serpent_ia32/serp_ia32.cpp
@@ -1,48 +1,48 @@
 /*************************************************
-* Serpent Source File                            *
+* IA-32 Serpent Source File                      *
 * (C) 1999-2007 Jack Lloyd                       *
 *************************************************/
 
-#include <botan/serpent.h>
+#include <botan/serp_ia32.h>
 #include <botan/loadstor.h>
 
 namespace Botan {
 
 extern "C" {
 
-void serpent_encrypt(const byte[16], byte[16], const u32bit[132]);
-void serpent_decrypt(const byte[16], byte[16], const u32bit[132]);
-void serpent_key_schedule(u32bit[140]);
+void botan_serpent_ia32_encrypt(const byte[16], byte[16], const u32bit[132]);
+void botan_serpent_ia32_decrypt(const byte[16], byte[16], const u32bit[132]);
+void botan_serpent_ia32_key_schedule(u32bit[140]);
 
 }
 
 /*************************************************
 * Serpent Encryption                             *
 *************************************************/
-void Serpent::enc(const byte in[], byte out[]) const
+void Serpent_IA32::enc(const byte in[], byte out[]) const
    {
-   serpent_encrypt(in, out, round_key);
+   botan_serpent_ia32_encrypt(in, out, round_key);
    }
 
 /*************************************************
 * Serpent Decryption                             *
 *************************************************/
-void Serpent::dec(const byte in[], byte out[]) const
+void Serpent_IA32::dec(const byte in[], byte out[]) const
    {
-   serpent_decrypt(in, out, round_key);
+   botan_serpent_ia32_decrypt(in, out, round_key);
    }
 
 /*************************************************
 * Serpent Key Schedule                           *
 *************************************************/
-void Serpent::key(const byte key[], u32bit length)
+void Serpent_IA32::key(const byte key[], u32bit length)
    {
    SecureBuffer<u32bit, 140> W;
    for(u32bit j = 0; j != length / 4; ++j)
       W[j] = make_u32bit(key[4*j+3], key[4*j+2], key[4*j+1], key[4*j]);
    W[length / 4] |= u32bit(1) << ((length%4)*8);
 
-   serpent_key_schedule(W);
+   botan_serpent_ia32_key_schedule(W);
    round_key.copy(W + 8, 132);
    }
 
diff --git a/src/cipher/serpent_ia32/serp_ia32.h b/src/cipher/serpent_ia32/serp_ia32.h
new file mode 100644
index 000000000..26f870188
--- /dev/null
+++ b/src/cipher/serpent_ia32/serp_ia32.h
@@ -0,0 +1,33 @@
+/*************************************************
+* Serpent (IA-32) Header File                    *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#ifndef BOTAN_SERPENT_IA32_H__
+#define BOTAN_SERPENT_IA32_H__
+
+#include <botan/base.h>
+
+namespace Botan {
+
+/*************************************************
+* Serpent                                        *
+*************************************************/
+class BOTAN_DLL Serpent_IA32 : public BlockCipher
+   {
+   public:
+      void clear() throw() { round_key.clear(); }
+      std::string name() const { return "Serpent"; }
+      BlockCipher* clone() const { return new Serpent_IA32; }
+      Serpent_IA32() : BlockCipher(16, 16, 32, 8) {}
+   private:
+      void enc(const byte[], byte[]) const;
+      void dec(const byte[], byte[]) const;
+      void key(const byte[], u32bit);
+
+      SecureBuffer<u32bit, 132> round_key;
+   };
+
+}
+
+#endif
diff --git a/src/cipher/serpent_ia32/serp_asm.S b/src/cipher/serpent_ia32/serp_ia32_imp.S
index c8915382d..ddfcc7806 100644
--- a/src/cipher/serpent_ia32/serp_asm.S
+++ b/src/cipher/serpent_ia32/serp_ia32_imp.S
@@ -5,7 +5,7 @@
 
 #include <botan/asm_macr.h>
 
-START_LISTING(serp_asm.S)
+START_LISTING(serp_ia32.S)
 
 #define SBOX_E1(A, B, C, D, T)     \
    XOR(D, A)                     ; \
@@ -439,7 +439,7 @@ START_LISTING(serp_asm.S)
 /*************************************************
 * Serpent Encryption                             *
 *************************************************/
-START_FUNCTION(serpent_encrypt)
+START_FUNCTION(botan_serpent_ia32_encrypt)
    SPILL_REGS()
 #define PUSHED 4
 
@@ -505,12 +505,12 @@ START_FUNCTION(serpent_encrypt)
 
    RESTORE_REGS()
 #undef PUSHED
-END_FUNCTION(serpent_encrypt)
+END_FUNCTION(botan_serpent_ia32_encrypt)
 
 /*************************************************
 * Serpent Decryption                             *
 *************************************************/
-START_FUNCTION(serpent_decrypt)
+START_FUNCTION(botan_serpent_ia32_decrypt)
    SPILL_REGS()
 #define PUSHED 4
 
@@ -576,12 +576,12 @@ START_FUNCTION(serpent_decrypt)
 
    RESTORE_REGS()
 #undef PUSHED
-END_FUNCTION(serpent_decrypt)
+END_FUNCTION(botan_serpent_ia32_decrypt)
 
 /*************************************************
 * Serpent Key Schedule                           *
 *************************************************/
-START_FUNCTION(serpent_key_schedule)
+START_FUNCTION(botan_serpent_ia32_key_schedule)
    SPILL_REGS()
 #define PUSHED 4
 
@@ -664,4 +664,4 @@ LOOP_UNTIL_EQ(ESI, 140, .EXPANSION)
 
    RESTORE_REGS()
 #undef PUSHED
-END_FUNCTION(serpent_key_schedule)
+END_FUNCTION(botan_serpent_ia32_key_schedule)
diff --git a/src/core/def_alg.cpp b/src/core/def_alg.cpp
index b13439fe2..cad5dca5a 100644
--- a/src/core/def_alg.cpp
+++ b/src/core/def_alg.cpp
@@ -80,6 +80,10 @@
   #include <botan/serpent.h>
 #endif
 
+#if defined(BOTAN_HAS_SERPENT_IA32)
+  #include <botan/serp_ia32.h>
+#endif
+
 #if defined(BOTAN_HAS_SKIPJACK)
   #include <botan/skipjack.h>
 #endif
@@ -148,10 +152,18 @@
   #include <botan/md4.h>
 #endif
 
+#if defined(BOTAN_HAS_MD4_IA32)
+  #include <botan/md4_ia32.h>
+#endif
+
 #if defined(BOTAN_HAS_MD5)
   #include <botan/md5.h>
 #endif
 
+#if defined(BOTAN_HAS_MD5_IA32)
+  #include <botan/md5_ia32.h>
+#endif
+
 #if defined(BOTAN_HAS_RIPEMD_128)
   #include <botan/rmd128.h>
 #endif
@@ -164,6 +176,18 @@
   #include <botan/sha160.h>
 #endif
 
+#if defined(BOTAN_HAS_SHA1_IA32)
+  #include <botan/sha1_ia32.h>
+#endif
+
+#if defined(BOTAN_HAS_SHA1_SSE2)
+  #include <botan/sha1_sse2.h>
+#endif
+
+#if defined(BOTAN_HAS_SHA1_AMD64)
+  #include <botan/sha1_amd64.h>
+#endif
+
 #if defined(BOTAN_HAS_SHA2)
   #include <botan/sha256.h>
   #include <botan/sha_64.h>
@@ -333,7 +357,9 @@ Default_Engine::find_block_cipher(const std::string& algo_spec) const
    HANDLE_TYPE_NO_ARGS("SEED", SEED);
 #endif
 
-#if defined(BOTAN_HAS_SERPENT)
+#if defined(BOTAN_HAS_SERPENT_IA32)
+   HANDLE_TYPE_NO_ARGS("Serpent", Serpent_IA32);
+#elif defined(BOTAN_HAS_SERPENT)
    HANDLE_TYPE_NO_ARGS("Serpent", Serpent);
 #endif
 
@@ -444,11 +470,15 @@ Default_Engine::find_hash(const std::string& algo_spec) const
    HANDLE_TYPE_NO_ARGS("MD2", MD2);
 #endif
 
-#if defined(BOTAN_HAS_MD4)
+#if defined(BOTAN_HAS_MD4_IA32)
+   HANDLE_TYPE_NO_ARGS("MD4", MD4_IA32);
+#elif defined(BOTAN_HAS_MD4)
    HANDLE_TYPE_NO_ARGS("MD4", MD4);
 #endif
 
-#if defined(BOTAN_HAS_MD5)
+#if defined(BOTAN_HAS_MD5_IA32)
+   HANDLE_TYPE_NO_ARGS("MD5", MD5_IA32);
+#elif defined(BOTAN_HAS_MD5)
    HANDLE_TYPE_NO_ARGS("MD5", MD5);
 #endif
 
@@ -460,7 +490,13 @@ Default_Engine::find_hash(const std::string& algo_spec) const
    HANDLE_TYPE_NO_ARGS("RIPEMD-160", RIPEMD_160);
 #endif
 
-#if defined(BOTAN_HAS_SHA1)
+#if defined(BOTAN_HAS_SHA1_SSE2)
+   HANDLE_TYPE_NO_ARGS("SHA-160", SHA_160_SSE2);
+#elif defined(BOTAN_HAS_SHA1_AMD64)
+   HANDLE_TYPE_NO_ARGS("SHA-160", SHA_160_AMD64);
+#elif defined(BOTAN_HAS_SHA1_IA32)
+   HANDLE_TYPE_NO_ARGS("SHA-160", SHA_160_IA32);
+#elif defined(BOTAN_HAS_SHA1)
    HANDLE_TYPE_NO_ARGS("SHA-160", SHA_160);
 #endif
 
diff --git a/src/hash/md4_ia32/info.txt b/src/hash/md4_ia32/info.txt
index 4a192cbc2..afc150768 100644
--- a/src/hash/md4_ia32/info.txt
+++ b/src/hash/md4_ia32/info.txt
@@ -1,17 +1,19 @@
-realname "MD4 (x86)"
+realname "MD4 (IA-32)"
 
-define MD4
+define MD4_IA32
 
-load_on requested
+load_on asm_ok
 
 <add>
-md4_ia32.S
-md4.cpp
-md4.h
+md4_ia32_imp.S
+md4_ia32.cpp
+md4_ia32.h
 </add>
 
 <requires>
+asm_ia32
 mdx_hash
+utils
 </requires>
 
 <arch>
diff --git a/src/hash/md4_ia32/md4.cpp b/src/hash/md4_ia32/md4_ia32.cpp
index 12466e86e..a34cbb3a6 100644
--- a/src/hash/md4_ia32/md4.cpp
+++ b/src/hash/md4_ia32/md4_ia32.cpp
@@ -1,36 +1,36 @@
 /*************************************************
-* MD4 Source File                                *
+* MD4 (IA-32) Source File                        *
 * (C) 1999-2007 Jack Lloyd                       *
 *************************************************/
 
-#include <botan/md4.h>
+#include <botan/md4_ia32.h>
 #include <botan/loadstor.h>
 
 namespace Botan {
 
-extern "C" void botan_md4_core_asm(u32bit[4], const byte[64], u32bit[16]);
+extern "C" void botan_md4_ia32_compress(u32bit[4], const byte[64], u32bit[16]);
 
 /*************************************************
 * MD4 Compression Function                       *
 *************************************************/
-void MD4::hash(const byte input[])
+void MD4_IA32::hash(const byte input[])
    {
-   md4_core(digest, input, M);
+   botan_md4_ia32_compress(digest, input, M);
    }
 
 /*************************************************
 * Copy out the digest                            *
 *************************************************/
-void MD4::copy_out(byte output[])
+void MD4_IA32::copy_out(byte output[])
    {
-   for(u32bit j = 0; j != OUTPUT_LENGTH; ++j)
-      output[j] = get_byte(3 - (j % 4), digest[j/4]);
+   for(u32bit j = 0; j != OUTPUT_LENGTH; j += 4)
+      store_le(digest[j/4], output + j);
    }
 
 /*************************************************
 * Clear memory of sensitive data                 *
 *************************************************/
-void MD4::clear() throw()
+void MD4_IA32::clear() throw()
    {
    MDx_HashFunction::clear();
    M.clear();
diff --git a/src/hash/md4_ia32/md4_ia32.h b/src/hash/md4_ia32/md4_ia32.h
new file mode 100644
index 000000000..c6640435e
--- /dev/null
+++ b/src/hash/md4_ia32/md4_ia32.h
@@ -0,0 +1,33 @@
+/*************************************************
+* MD4 (IA-32) Header File                        *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#ifndef BOTAN_MD4_IA32_H__
+#define BOTAN_MD4_IA32_H__
+
+#include <botan/mdx_hash.h>
+
+namespace Botan {
+
+/*************************************************
+* MD4                                            *
+*************************************************/
+class BOTAN_DLL MD4_IA32 : public MDx_HashFunction
+   {
+   public:
+      void clear() throw();
+      std::string name() const { return "MD4"; }
+      HashFunction* clone() const { return new MD4_IA32; }
+      MD4_IA32() : MDx_HashFunction(16, 64, false, true) { clear(); }
+   private:
+      void hash(const byte[]);
+      void copy_out(byte[]);
+
+      SecureBuffer<u32bit, 48> M;
+      SecureBuffer<u32bit, 4> digest;
+   };
+
+}
+
+#endif
diff --git a/src/hash/md4_ia32/md4_ia32.S b/src/hash/md4_ia32/md4_ia32_imp.S
index 410c540e9..9b728c73d 100644
--- a/src/hash/md4_ia32/md4_ia32.S
+++ b/src/hash/md4_ia32/md4_ia32_imp.S
@@ -7,7 +7,7 @@
 
 START_LISTING(md4_ia32.S)
 
-START_FUNCTION(botan_md4_core_asm)
+START_FUNCTION(botan_md4_ia32_compress)
    SPILL_REGS()
 
 #define PUSHED 4
@@ -132,4 +132,4 @@ LOOP_UNTIL_EQ(ESI, 16, .LOAD_INPUT)
    ADD(ARRAY4(EBP, 3), EDX)
 
    RESTORE_REGS()
-END_FUNCTION(botan_md4_core_asm)
+END_FUNCTION(botan_md4_ia32_compress)
diff --git a/src/hash/md5_ia32/info.txt b/src/hash/md5_ia32/info.txt
index 566b6a0d4..652b50a16 100644
--- a/src/hash/md5_ia32/info.txt
+++ b/src/hash/md5_ia32/info.txt
@@ -1,17 +1,19 @@
-realname "MD5 (x86)"
+realname "MD5 (IA-32)"
 
-define MD5
+define MD5_IA32
 
-load_on requested
+load_on asm_ok
 
 <add>
-md5_ia32.S
-md5.cpp
-md5.h
+md5_ia32_imp.S
+md5_ia32.cpp
+md5_ia32.h
 </add>
 
 <requires>
+asm_ia32
 mdx_hash
+utils
 </requires>
 
 <arch>
diff --git a/src/hash/md5_ia32/md5.cpp b/src/hash/md5_ia32/md5_ia32.cpp
index 04e7673c1..b95eb0c56 100644
--- a/src/hash/md5_ia32/md5.cpp
+++ b/src/hash/md5_ia32/md5_ia32.cpp
@@ -1,36 +1,41 @@
 /*************************************************
-* MD5 Source File                                *
+* MD5 (IA-32) Source File                        *
 * (C) 1999-2007 Jack Lloyd                       *
 *************************************************/
 
-#include <botan/md5.h>
+#include <botan/md5_ia32.h>
 #include <botan/loadstor.h>
 
 namespace Botan {
 
-extern "C" void botan_md5_core_asm(u32bit[4], const byte[64], u32bit[16]);
+namespace {
+
+extern "C"
+void botan_md5_ia32_compress(u32bit[4], const byte[64], u32bit[16]);
+
+}
 
 /*************************************************
 * MD5 Compression Function                       *
 *************************************************/
-void MD5::hash(const byte input[])
+void MD5_IA32::hash(const byte input[])
    {
-   md5_core(digest, input, M);
+   botan_md5_ia32_compress(digest, input, M);
    }
 
 /*************************************************
 * Copy out the digest                            *
 *************************************************/
-void MD5::copy_out(byte output[])
+void MD5_IA32::copy_out(byte output[])
    {
-   for(u32bit j = 0; j != OUTPUT_LENGTH; ++j)
-      output[j] = get_byte(3 - (j % 4), digest[j/4]);
+   for(u32bit j = 0; j != OUTPUT_LENGTH; j += 4)
+      store_le(digest[j/4], output + j);
    }
 
 /*************************************************
 * Clear memory of sensitive data                 *
 *************************************************/
-void MD5::clear() throw()
+void MD5_IA32::clear() throw()
    {
    MDx_HashFunction::clear();
    M.clear();
diff --git a/src/hash/md5_ia32/md5_ia32.h b/src/hash/md5_ia32/md5_ia32.h
new file mode 100644
index 000000000..cf5038c1c
--- /dev/null
+++ b/src/hash/md5_ia32/md5_ia32.h
@@ -0,0 +1,33 @@
+/*************************************************
+* MD5 (IA-32) Header File                        *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#ifndef BOTAN_MD5_IA32_H__
+#define BOTAN_MD5_IA32_H__
+
+#include <botan/mdx_hash.h>
+
+namespace Botan {
+
+/*************************************************
+* MD5                                            *
+*************************************************/
+class BOTAN_DLL MD5_IA32 : public MDx_HashFunction
+   {
+   public:
+      void clear() throw();
+      std::string name() const { return "MD5"; }
+      HashFunction* clone() const { return new MD5_IA32; }
+      MD5_IA32() : MDx_HashFunction(16, 64, false, true) { clear(); }
+   private:
+      void hash(const byte[]);
+      void copy_out(byte[]);
+
+      SecureBuffer<u32bit, 16> M;
+      SecureBuffer<u32bit, 4> digest;
+   };
+
+}
+
+#endif
diff --git a/src/hash/md5_ia32/md5_ia32.S b/src/hash/md5_ia32/md5_ia32_imp.S
index 8e1ec2e79..7f9268a1e 100644
--- a/src/hash/md5_ia32/md5_ia32.S
+++ b/src/hash/md5_ia32/md5_ia32_imp.S
@@ -7,7 +7,7 @@
 
 START_LISTING(md5_ia32.S)
 
-START_FUNCTION(botan_md5_core_asm)
+START_FUNCTION(botan_md5_ia32_compress)
    SPILL_REGS()
 
 #define PUSHED 4
@@ -161,4 +161,4 @@ LOOP_UNTIL_EQ(ESI, 16, .LOAD_INPUT)
    ADD(ARRAY4(EBP, 3), EDX)
 
    RESTORE_REGS()
-END_FUNCTION(botan_md5_core_asm)
+END_FUNCTION(botan_md5_ia32_compress)
diff --git a/src/hash/sha1_amd64/info.txt b/src/hash/sha1_amd64/info.txt
index 405b78343..400752b28 100644
--- a/src/hash/sha1_amd64/info.txt
+++ b/src/hash/sha1_amd64/info.txt
@@ -1,13 +1,19 @@
 realname "SHA-1 (x86-64 assembler)"
 
-load_on request
+load_on auto
 
 <add>
-sha160.cpp
-asm_macr.h
-sha1_asm.S
+sha1_amd64_imp.S
+sha1_amd64.cpp
+sha1_amd64.h
 </add>
 
+<requires>
+asm_amd64
+mdx_hash
+utils
+</requires>
+
 <arch>
 amd64
 </arch>
diff --git a/src/hash/sha1_amd64/sha160.cpp b/src/hash/sha1_amd64/sha160.cpp
deleted file mode 100644
index c7fbea25a..000000000
--- a/src/hash/sha1_amd64/sha160.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-/*************************************************
-* SHA-160 Source File                            *
-* (C) 1999-2007 Jack Lloyd                       *
-*************************************************/
-
-#include <botan/sha160.h>
-#include <botan/loadstor.h>
-
-namespace Botan {
-
-extern "C" void botan_sha160_core_asm(u32bit[5], const byte[64], u32bit[80]);
-
-/*************************************************
-* SHA-160 Compression Function                   *
-*************************************************/
-void SHA_160::hash(const byte input[])
-   {
-   botan_sha160_asm_amd64(digest, input, W);
-   }
-
-/*************************************************
-* 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();
-   W.clear();
-   digest[0] = 0x67452301;
-   digest[1] = 0xEFCDAB89;
-   digest[2] = 0x98BADCFE;
-   digest[3] = 0x10325476;
-   digest[4] = 0xC3D2E1F0;
-   }
-
-/*************************************************
-* SHA_160 Constructor                            *
-*************************************************/
-SHA_160::SHA_160() : MDx_HashFunction(20, 64, true, true), W(80)
-   {
-   clear();
-   }
-
-}
diff --git a/src/hash/sha1_sse2/sha160.cpp b/src/hash/sha1_amd64/sha1_amd64.cpp
index dfb5fdfe5..1c780a9c1 100644
--- a/src/hash/sha1_sse2/sha160.cpp
+++ b/src/hash/sha1_amd64/sha1_amd64.cpp
@@ -3,26 +3,30 @@
 * (C) 1999-2007 Jack Lloyd                       *
 *************************************************/
 
-#include <botan/sha160.h>
+#include <botan/sha1_amd64.h>
 #include <botan/loadstor.h>
-#include <botan/bit_ops.h>
 
 namespace Botan {
 
-extern "C" void botan_sha1_sse(u32bit[5], const byte[64]);
+namespace {
+
+extern "C"
+void botan_sha160_amd64_compress(u32bit[5], const byte[64], u32bit[80]);
+
+}
 
 /*************************************************
 * SHA-160 Compression Function                   *
 *************************************************/
-void SHA_160::hash(const byte input[])
+void SHA_160_AMD64::hash(const byte input[])
    {
-   botan_sha1_sse(digest, input);
+   botan_sha160_amd64_compress(digest, input, W);
    }
 
 /*************************************************
 * Copy out the digest                            *
 *************************************************/
-void SHA_160::copy_out(byte output[])
+void SHA_160_AMD64::copy_out(byte output[])
    {
    for(u32bit j = 0; j != OUTPUT_LENGTH; ++j)
       output[j] = get_byte(j % 4, digest[j/4]);
@@ -31,9 +35,10 @@ void SHA_160::copy_out(byte output[])
 /*************************************************
 * Clear memory of sensitive data                 *
 *************************************************/
-void SHA_160::clear() throw()
+void SHA_160_AMD64::clear() throw()
    {
    MDx_HashFunction::clear();
+   W.clear();
    digest[0] = 0x67452301;
    digest[1] = 0xEFCDAB89;
    digest[2] = 0x98BADCFE;
@@ -41,12 +46,4 @@ void SHA_160::clear() throw()
    digest[4] = 0xC3D2E1F0;
    }
 
-/*************************************************
-* SHA_160 Constructor                            *
-*************************************************/
-SHA_160::SHA_160() : MDx_HashFunction(20, 64, true, true)
-   {
-   clear();
-   }
-
 }
diff --git a/src/hash/sha1_amd64/sha1_amd64.h b/src/hash/sha1_amd64/sha1_amd64.h
new file mode 100644
index 000000000..91cbc8293
--- /dev/null
+++ b/src/hash/sha1_amd64/sha1_amd64.h
@@ -0,0 +1,34 @@
+/*************************************************
+* SHA-160 (x86-64) Header File                   *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#ifndef BOTAN_SHA_160_AMD64_H__
+#define BOTAN_SHA_160_AMD64_H__
+
+#include <botan/mdx_hash.h>
+
+namespace Botan {
+
+/*************************************************
+* SHA-160                                        *
+*************************************************/
+class BOTAN_DLL SHA_160_AMD64 : public MDx_HashFunction
+   {
+   public:
+      void clear() throw();
+      std::string name() const { return "SHA-160"; }
+      HashFunction* clone() const { return new SHA_160_AMD64; }
+
+      SHA_160_AMD64() : MDx_HashFunction(20, 64, true, true) { clear(); }
+   private:
+      void hash(const byte[]);
+      void copy_out(byte[]);
+
+      SecureBuffer<u32bit, 5> digest;
+      SecureBuffer<u32bit, 80> W;
+   };
+
+}
+
+#endif
diff --git a/src/hash/sha1_amd64/sha1_asm.S b/src/hash/sha1_amd64/sha1_amd64_imp.S
index b94dfbadc..f20494999 100644
--- a/src/hash/sha1_amd64/sha1_asm.S
+++ b/src/hash/sha1_amd64/sha1_amd64_imp.S
@@ -5,9 +5,9 @@
 
 #include <botan/asm_macr.h>
 
-START_LISTING(sha1_asm.S)
+START_LISTING(sha1_amd64.S)
 
-START_FUNCTION(botan_sha160_core_asm)
+START_FUNCTION(botan_sha160_amd64_compress)
 
 #define DIGEST_ARR %rdi
 #define INPUT %rsi
@@ -255,4 +255,4 @@ ALIGN;
    ADD(ARRAY4(DIGEST_ARR, 3), B)
    ADD(ARRAY4(DIGEST_ARR, 4), C)
 
-END_FUNCTION(botan_core_sha160_asm)
+END_FUNCTION(botan_sha160_amd64_compress)
diff --git a/src/hash/sha1_ia32/info.txt b/src/hash/sha1_ia32/info.txt
index c1a75fc55..ff8b66ddc 100644
--- a/src/hash/sha1_ia32/info.txt
+++ b/src/hash/sha1_ia32/info.txt
@@ -1,17 +1,19 @@
-realname "SHA-1 (x86)"
+realname "SHA-1 (IA-32)"
 
-define SHA1
+define SHA1_IA32
 
-load_on requested
+load_on auto
 
 <add>
-sha1_ia32.S
-sha160.cpp
-sha160.h
+sha1_ia32_imp.S
+sha1_ia32.cpp
+sha1_ia32.h
 </add>
 
 <requires>
+asm_ia32
 mdx_hash
+utils
 </requires>
 
 <arch>
diff --git a/src/hash/sha1_ia32/sha160.cpp b/src/hash/sha1_ia32/sha1_ia32.cpp
index 7725541d5..4e24b0793 100644
--- a/src/hash/sha1_ia32/sha160.cpp
+++ b/src/hash/sha1_ia32/sha1_ia32.cpp
@@ -1,27 +1,32 @@
 /*************************************************
-* SHA-160 Source File                            *
+* SHA-160 (IA-32) Source File                    *
 * (C) 1999-2007 Jack Lloyd                       *
 *************************************************/
 
-#include <botan/sha160.h>
+#include <botan/sha1_ia32.h>
 #include <botan/loadstor.h>
 
 namespace Botan {
 
-extern "C" void botan_sha160_asm_ia32(u32bit[5], const byte[64], u32bit[81]);
+namespace {
+
+extern "C"
+void botan_sha160_ia32_compress(u32bit[5], const byte[64], u32bit[81]);
+
+}
 
 /*************************************************
 * SHA-160 Compression Function                   *
 *************************************************/
-void SHA_160::hash(const byte input[])
+void SHA_160_IA32::hash(const byte input[])
    {
-   botan_sha160_asm_ia32(digest, input, W);
+   botan_sha160_ia32_compress(digest, input, W);
    }
 
 /*************************************************
 * Copy out the digest                            *
 *************************************************/
-void SHA_160::copy_out(byte output[])
+void SHA_160_IA32::copy_out(byte output[])
    {
    for(u32bit j = 0; j != OUTPUT_LENGTH; ++j)
       output[j] = get_byte(j % 4, digest[j/4]);
@@ -30,7 +35,7 @@ void SHA_160::copy_out(byte output[])
 /*************************************************
 * Clear memory of sensitive data                 *
 *************************************************/
-void SHA_160::clear() throw()
+void SHA_160_IA32::clear() throw()
    {
    MDx_HashFunction::clear();
    W.clear();
@@ -41,12 +46,4 @@ void SHA_160::clear() throw()
    digest[4] = 0xC3D2E1F0;
    }
 
-/*************************************************
-* SHA_160 Constructor                            *
-*************************************************/
-SHA_160::SHA_160() : MDx_HashFunction(20, 64, true, true), W(81)
-   {
-   clear();
-   }
-
 }
diff --git a/src/hash/sha1_ia32/sha1_ia32.h b/src/hash/sha1_ia32/sha1_ia32.h
new file mode 100644
index 000000000..ab9dd8ac2
--- /dev/null
+++ b/src/hash/sha1_ia32/sha1_ia32.h
@@ -0,0 +1,36 @@
+/*************************************************
+* SHA-160 (IA-32) Header File                    *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#ifndef BOTAN_SHA_160_IA32_H__
+#define BOTAN_SHA_160_IA32_H__
+
+#include <botan/mdx_hash.h>
+
+namespace Botan {
+
+/*************************************************
+* SHA-160                                        *
+*************************************************/
+class BOTAN_DLL SHA_160_IA32 : public MDx_HashFunction
+   {
+   public:
+      void clear() throw();
+      std::string name() const { return "SHA-160"; }
+      HashFunction* clone() const { return new SHA_160_IA32; }
+
+      SHA_160_IA32() : MDx_HashFunction(20, 64, true, true) { clear(); }
+   private:
+      void hash(const byte[]);
+      void copy_out(byte[]);
+
+      SecureBuffer<u32bit, 5> digest;
+
+      // Note 81 instead of normal 80: IA-32 asm needs an extra temp
+      SecureBuffer<u32bit, 81> W;
+   };
+
+}
+
+#endif
diff --git a/src/hash/sha1_ia32/sha1_ia32.S b/src/hash/sha1_ia32/sha1_ia32_imp.S
index ddd72e316..b7f881383 100644
--- a/src/hash/sha1_ia32/sha1_ia32.S
+++ b/src/hash/sha1_ia32/sha1_ia32_imp.S
@@ -5,9 +5,9 @@
 
 #include <botan/asm_macr.h>
 
-START_LISTING(sha1_asm.S)
+START_LISTING(sha1_ia32.S)
 
-START_FUNCTION(botan_sha160_core_asm)
+START_FUNCTION(botan_sha160_ia32_compress)
    SPILL_REGS()
 
 #define PUSHED 4
@@ -239,4 +239,4 @@ LOOP_UNTIL_EQ(ESI, 80, .EXPANSION)
    ADD(ARRAY4(EBP, 4), ECX)
 
    RESTORE_REGS()
-END_FUNCTION(botan_sha160_core_asm)
+END_FUNCTION(botan_sha160_ia32_compress)
diff --git a/src/hash/sha1_sse2/info.txt b/src/hash/sha1_sse2/info.txt
index 4177c0ab7..cf5fb0943 100644
--- a/src/hash/sha1_sse2/info.txt
+++ b/src/hash/sha1_sse2/info.txt
@@ -1,15 +1,20 @@
 realname "SHA-1 (SSE2)"
 
-define SHA1
+define SHA1_SSE2
 
-load_on request
+load_on auto
 
 <add>
-sha160.cpp
-sha160.h
-sha1_sse.cpp
+sha1_sse2_imp.cpp
+sha1_sse2.cpp
+sha1_sse2.h
 </add>
 
+<requires>
+mdx_hash
+utils
+</requires>
+
 <arch>
 pentium-m
 pentium4
diff --git a/src/hash/sha1_sse2/sha1_sse2.cpp b/src/hash/sha1_sse2/sha1_sse2.cpp
new file mode 100644
index 000000000..df7f2277c
--- /dev/null
+++ b/src/hash/sha1_sse2/sha1_sse2.cpp
@@ -0,0 +1,44 @@
+/*************************************************
+* SHA-160 (SSE2) Source File                     *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#include <botan/sha1_sse2.h>
+#include <botan/loadstor.h>
+#include <botan/bit_ops.h>
+
+namespace Botan {
+
+extern "C" void botan_sha1_sse2_compress(u32bit[5], const byte[64]);
+
+/*************************************************
+* SHA-160 Compression Function                   *
+*************************************************/
+void SHA_160_SSE2::hash(const byte input[])
+   {
+   botan_sha1_sse2_compress(digest, input);
+   }
+
+/*************************************************
+* Copy out the digest                            *
+*************************************************/
+void SHA_160_SSE2::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_SSE2::clear() throw()
+   {
+   MDx_HashFunction::clear();
+   digest[0] = 0x67452301;
+   digest[1] = 0xEFCDAB89;
+   digest[2] = 0x98BADCFE;
+   digest[3] = 0x10325476;
+   digest[4] = 0xC3D2E1F0;
+   }
+
+}
diff --git a/src/hash/sha1_sse2/sha160.h b/src/hash/sha1_sse2/sha1_sse2.h
index c6f8482cf..5683acc4f 100644
--- a/src/hash/sha1_sse2/sha160.h
+++ b/src/hash/sha1_sse2/sha1_sse2.h
@@ -3,8 +3,8 @@
 * (C) 1999-2007 The Botan Project                *
 *************************************************/
 
-#ifndef BOTAN_SHA_160_H__
-#define BOTAN_SHA_160_H__
+#ifndef BOTAN_SHA_160_SSE2_H__
+#define BOTAN_SHA_160_SSE2_H__
 
 #include <botan/mdx_hash.h>
 
@@ -13,13 +13,14 @@ namespace Botan {
 /*************************************************
 * SHA-160                                        *
 *************************************************/
-class SHA_160 : public MDx_HashFunction
+class SHA_160_SSE2 : public MDx_HashFunction
    {
    public:
       void clear() throw();
       std::string name() const { return "SHA-160"; }
-      HashFunction* clone() const { return new SHA_160; }
-      SHA_160();
+      HashFunction* clone() const { return new SHA_160_SSE2; }
+
+      SHA_160_SSE2() : MDx_HashFunction(20, 64, true, true) { clear(); }
    private:
       void hash(const byte[]);
       void copy_out(byte[]);
diff --git a/src/hash/sha1_sse2/sha1_sse.cpp b/src/hash/sha1_sse2/sha1_sse2_imp.cpp
index 23dbfc5e2..759d88afa 100644
--- a/src/hash/sha1_sse2/sha1_sse.cpp
+++ b/src/hash/sha1_sse2/sha1_sse2_imp.cpp
@@ -188,8 +188,8 @@ static inline u32bit f60_79(u32bit x, u32bit y, u32bit z)
 		(xt) += ((xe) + rol((xa), 5));						\
 	} while(0)
 
-extern "C" void botan_sha1_sse(u32bit* H,
-                               const u32bit* inputu)
+extern "C" void botan_sha1_sse2_compress(u32bit* H,
+                                         const u32bit* inputu)
    {
    const __m128i *  input = (const __m128i *)inputu;
    __m128i W0, W1, W2, W3;
diff --git a/src/bigint/asm_amd64/asm_macr.h b/src/utils/asm_amd64/asm_macr.h
index 3cdd42dc6..3cdd42dc6 100644
--- a/src/bigint/asm_amd64/asm_macr.h
+++ b/src/utils/asm_amd64/asm_macr.h
diff --git a/src/utils/asm_amd64/info.txt b/src/utils/asm_amd64/info.txt
new file mode 100644
index 000000000..e190dba88
--- /dev/null
+++ b/src/utils/asm_amd64/info.txt
@@ -0,0 +1,16 @@
+realname "Assembler Macros (x86-64)"
+
+load_on required
+
+<add>
+asm_macr.h
+</add>
+
+<arch>
+amd64
+</arch>
+
+<cc>
+gcc
+icc
+</cc>
diff --git a/src/bigint/asm_ia32/asm_macr.h b/src/utils/asm_ia32/asm_macr.h
index 6d5dbb59d..6d5dbb59d 100644
--- a/src/bigint/asm_ia32/asm_macr.h
+++ b/src/utils/asm_ia32/asm_macr.h
diff --git a/src/utils/asm_ia32/info.txt b/src/utils/asm_ia32/info.txt
new file mode 100644
index 000000000..8f2ada914
--- /dev/null
+++ b/src/utils/asm_ia32/info.txt
@@ -0,0 +1,16 @@
+realname "Assembler Macros (IA-32)"
+
+load_on required
+
+<add>
+asm_macr.h
+</add>
+
+<arch>
+ia32
+</arch>
+
+<cc>
+gcc
+icc
+</cc>