Initial checkin1.5.6

93 files changed, 6592 insertions, 0 deletions

diff --git a/modules/alloc_mmap/mmap_mem.cpp b/modules/alloc_mmap/mmap_mem.cpp
new file mode 100644
index 000000000..d2e66d0cc
--- /dev/null
+++ b/modules/alloc_mmap/mmap_mem.cpp
@@ -0,0 +1,88 @@
+/*************************************************
+* Memory Mapping Allocator Source File           *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/mmap_mem.h>
+#include <cstring>
+
+#ifndef _XOPEN_SOURCE
+  #define _XOPEN_SOURCE 500
+#endif
+
+#ifndef _XOPEN_SOURCE_EXTENDED
+  #define _XOPEN_SOURCE_EXTENDED 1
+#endif
+
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <fcntl.h>
+
+#ifndef MAP_FAILED
+   #define MAP_FAILED -1
+#endif
+
+namespace Botan {
+
+/*************************************************
+* Memory Map a File into Memory                  *
+*************************************************/
+void* MemoryMapping_Allocator::alloc_block(u32bit n)
+   {
+   const std::string path = "/tmp/botan_XXXXXX";
+
+   char* filepath = new char[path.length() + 1];
+   std::strcpy(filepath, path.c_str());
+
+   mode_t old_umask = umask(077);
+   int fd = mkstemp(filepath);
+   umask(old_umask);
+
+   if(fd == -1)
+      throw Exception("MemoryMapping_Allocator: Could not create file");
+   if(unlink(filepath))
+      throw Exception("MemoryMapping_Allocator: Could not unlink file " +
+                      std::string(filepath));
+   delete[] filepath;
+
+   lseek(fd, n-1, SEEK_SET);
+   if(write(fd, "\0", 1) != 1)
+      throw Exception("MemoryMapping_Allocator: Could not write to file");
+   void* ptr = mmap(0, n, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+   if(ptr == (void*)MAP_FAILED)
+      throw Exception("MemoryMapping_Allocator: Could not map file");
+   if(close(fd))
+      throw Exception("MemoryMapping_Allocator: Could not close file");
+
+   return ptr;
+   }
+
+/*************************************************
+* Remove a Memory Mapping                        *
+*************************************************/
+void MemoryMapping_Allocator::dealloc_block(void* ptr, u32bit n)
+   {
+   if(ptr == 0) return;
+
+   const u32bit OVERWRITE_PASSES = 12;
+   const byte PATTERNS[] = { 0x00, 0xFF, 0xAA, 0x55, 0x73, 0x8C, 0x5F, 0xA0,
+                             0x6E, 0x91, 0x30, 0xCF, 0xD3, 0x2C, 0xAC, 0x53 };
+
+   for(u32bit j = 0; j != OVERWRITE_PASSES; j++)
+      {
+      std::memset(ptr, PATTERNS[j % sizeof(PATTERNS)], n);
+      if(msync(ptr, n, MS_SYNC))
+         throw Exception("MemoryMapping_Allocator: Sync operation failed");
+      }
+   std::memset(ptr, 0, n);
+   if(msync(ptr, n, MS_SYNC))
+      throw Exception("MemoryMapping_Allocator: Sync operation failed");
+
+   if(munmap(ptr, n))
+      throw Exception("MemoryMapping_Allocator: Could not unmap file");
+   }
+
+}
diff --git a/modules/alloc_mmap/mmap_mem.h b/modules/alloc_mmap/mmap_mem.h
new file mode 100644
index 000000000..0530e54be
--- /dev/null
+++ b/modules/alloc_mmap/mmap_mem.h
@@ -0,0 +1,27 @@
+/*************************************************
+* Memory Mapping Allocator Header File           *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_MMAP_ALLOCATOR_H__
+#define BOTAN_EXT_MMAP_ALLOCATOR_H__
+
+#include <botan/mem_pool.h>
+
+namespace Botan {
+
+/*************************************************
+* Memory Mapping Allocator                       *
+*************************************************/
+class MemoryMapping_Allocator : public Pooling_Allocator
+   {
+   public:
+      MemoryMapping_Allocator() : Pooling_Allocator(64*1024, false) {}
+   private:
+      void* alloc_block(u32bit);
+      void dealloc_block(void*, u32bit);
+   };
+
+}
+
+#endif
diff --git a/modules/alloc_mmap/modinfo.txt b/modules/alloc_mmap/modinfo.txt
new file mode 100644
index 000000000..f51e3cb68
--- /dev/null
+++ b/modules/alloc_mmap/modinfo.txt
@@ -0,0 +1,20 @@
+realname "Disk Based Allocation System"
+
+define ALLOC_MMAP
+
+add_file mmap_mem.cpp
+add_file mmap_mem.h
+
+<os>
+linux
+freebsd
+openbsd
+netbsd
+solaris
+qnx
+darwin
+tru64
+
+# Only without -ansi, otherwise can't get mkstemp
+#cygwin
+</os>
diff --git a/modules/comp_bzip2/bzip2.cpp b/modules/comp_bzip2/bzip2.cpp
new file mode 100644
index 000000000..e5934b635
--- /dev/null
+++ b/modules/comp_bzip2/bzip2.cpp
@@ -0,0 +1,258 @@
+/*************************************************
+* Bzip Compressor Source File                    *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/bzip2.h>
+#include <map>
+#include <cstring>
+#define BZ_NO_STDIO
+#include <bzlib.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* Allocation Information for Bzip                *
+*************************************************/
+class Bzip_Alloc_Info
+   {
+   public:
+      std::map<void*, u32bit> current_allocs;
+      Allocator* alloc;
+
+      Bzip_Alloc_Info() { alloc = get_allocator(); }
+   };
+
+/*************************************************
+* Allocation Function for Bzip                   *
+*************************************************/
+void* bzip_malloc(void* info_ptr, int n, int size)
+   {
+   Bzip_Alloc_Info* info = static_cast<Bzip_Alloc_Info*>(info_ptr);
+   void* ptr = info->alloc->allocate(n * size);
+   info->current_allocs[ptr] = n * size;
+   return ptr;
+   }
+
+/*************************************************
+* Allocation Function for Bzip                   *
+*************************************************/
+void bzip_free(void* info_ptr, void* ptr)
+   {
+   Bzip_Alloc_Info* info = static_cast<Bzip_Alloc_Info*>(info_ptr);
+   std::map<void*, u32bit>::const_iterator i = info->current_allocs.find(ptr);
+   if(i == info->current_allocs.end())
+      throw Invalid_Argument("bzip_free: Got pointer not allocated by us");
+   info->alloc->deallocate(ptr, i->second);
+   }
+
+}
+
+/*************************************************
+* Wrapper Type for Bzip2 Stream                  *
+*************************************************/
+class Bzip_Stream
+   {
+   public:
+      bz_stream stream;
+
+      Bzip_Stream()
+         {
+         std::memset(&stream, 0, sizeof(bz_stream));
+         stream.bzalloc = bzip_malloc;
+         stream.bzfree = bzip_free;
+         stream.opaque = new Bzip_Alloc_Info;
+         }
+      ~Bzip_Stream()
+         {
+         Bzip_Alloc_Info* info = static_cast<Bzip_Alloc_Info*>(stream.opaque);
+         delete info;
+         std::memset(&stream, 0, sizeof(bz_stream));
+         }
+   };
+
+/*************************************************
+* Bzip_Compression Constructor                   *
+*************************************************/
+Bzip_Compression::Bzip_Compression(u32bit l) :
+   level((l >= 9) ? 9 : l), buffer(DEFAULT_BUFFERSIZE)
+   {
+   bz = 0;
+   }
+
+/*************************************************
+* Start Compressing with Bzip                    *
+*************************************************/
+void Bzip_Compression::start_msg()
+   {
+   clear();
+   bz = new Bzip_Stream;
+   if(BZ2_bzCompressInit(&(bz->stream), level, 0, 0) != BZ_OK)
+      throw Exception("Bzip_Compression: Memory allocation error");
+   }
+
+/*************************************************
+* Compress Input with Bzip                       *
+*************************************************/
+void Bzip_Compression::write(const byte input[], u32bit length)
+   {
+   bz->stream.next_in = (char*)input;
+   bz->stream.avail_in = length;
+
+   while(bz->stream.avail_in != 0)
+      {
+      bz->stream.next_out = (char*)buffer.begin();
+      bz->stream.avail_out = buffer.size();
+      BZ2_bzCompress(&(bz->stream), BZ_RUN);
+      send(buffer, buffer.size() - bz->stream.avail_out);
+      }
+   }
+
+/*************************************************
+* Finish Compressing with Bzip                   *
+*************************************************/
+void Bzip_Compression::end_msg()
+   {
+   bz->stream.next_in = 0;
+   bz->stream.avail_in = 0;
+
+   int rc = BZ_OK;
+   while(rc != BZ_STREAM_END)
+      {
+      bz->stream.next_out = (char*)buffer.begin();
+      bz->stream.avail_out = buffer.size();
+      rc = BZ2_bzCompress(&(bz->stream), BZ_FINISH);
+      send(buffer, buffer.size() - bz->stream.avail_out);
+      }
+   clear();
+   }
+
+/*************************************************
+* Flush the Bzip Compressor                      *
+*************************************************/
+void Bzip_Compression::flush()
+   {
+   bz->stream.next_in = 0;
+   bz->stream.avail_in = 0;
+
+   int rc = BZ_OK;
+   while(rc != BZ_RUN_OK)
+      {
+      bz->stream.next_out = (char*)buffer.begin();
+      bz->stream.avail_out = buffer.size();
+      rc = BZ2_bzCompress(&(bz->stream), BZ_FLUSH);
+      send(buffer, buffer.size() - bz->stream.avail_out);
+      }
+   }
+
+/*************************************************
+* Clean up Compression Context                   *
+*************************************************/
+void Bzip_Compression::clear()
+   {
+   if(!bz) return;
+   BZ2_bzCompressEnd(&(bz->stream));
+   delete bz;
+   bz = 0;
+   }
+
+/*************************************************
+* Bzip_Decompression Constructor                 *
+*************************************************/
+Bzip_Decompression::Bzip_Decompression(bool s) :
+   small_mem(s), buffer(DEFAULT_BUFFERSIZE)
+   {
+   no_writes = true;
+   bz = 0;
+   }
+
+/*************************************************
+* Decompress Input with Bzip                     *
+*************************************************/
+void Bzip_Decompression::write(const byte input[], u32bit length)
+   {
+   if(length) no_writes = false;
+   bz->stream.next_in = (char*)input;
+   bz->stream.avail_in = length;
+
+   while(bz->stream.avail_in != 0)
+      {
+      bz->stream.next_out = (char*)buffer.begin();
+      bz->stream.avail_out = buffer.size();
+
+      int rc = BZ2_bzDecompress(&(bz->stream));
+      if(rc != BZ_OK && rc != BZ_STREAM_END)
+         {
+         clear();
+         if(rc == BZ_DATA_ERROR)
+            throw Decoding_Error("Bzip_Decompression: Data integrity error");
+         if(rc == BZ_DATA_ERROR_MAGIC)
+            throw Decoding_Error("Bzip_Decompression: Invalid input");
+         if(rc == BZ_MEM_ERROR)
+            throw Exception("Bzip_Decompression: Memory allocation error");
+         throw Exception("Bzip_Decompression: Unknown decompress error");
+         }
+      send(buffer, buffer.size() - bz->stream.avail_out);
+      if(rc == BZ_STREAM_END)
+         {
+         u32bit read_from_block = length - bz->stream.avail_in;
+         start_msg();
+         bz->stream.next_in = (char*)input + read_from_block;
+         bz->stream.avail_in = length - read_from_block;
+         input += read_from_block;
+         length -= read_from_block;
+         }
+      }
+   }
+
+/*************************************************
+* Start Decompressing with Bzip                  *
+*************************************************/
+void Bzip_Decompression::start_msg()
+   {
+   clear();
+   bz = new Bzip_Stream;
+   if(BZ2_bzDecompressInit(&(bz->stream), 0, small_mem) != BZ_OK)
+      throw Exception("Bzip_Decompression: Memory allocation error");
+   no_writes = true;
+   }
+
+/*************************************************
+* Finish Decompressing with Bzip                 *
+*************************************************/
+void Bzip_Decompression::end_msg()
+   {
+   if(no_writes) return;
+   bz->stream.next_in = 0;
+   bz->stream.avail_in = 0;
+
+   int rc = BZ_OK;
+   while(rc != BZ_STREAM_END)
+      {
+      bz->stream.next_out = (char*)buffer.begin();
+      bz->stream.avail_out = buffer.size();
+      rc = BZ2_bzDecompress(&(bz->stream));
+      if(rc != BZ_OK && rc != BZ_STREAM_END)
+         {
+         clear();
+         throw Exception("Bzip_Decompression: Error finalizing decompression");
+         }
+      send(buffer, buffer.size() - bz->stream.avail_out);
+      }
+   clear();
+   }
+
+/*************************************************
+* Clean up Decompression Context                 *
+*************************************************/
+void Bzip_Decompression::clear()
+   {
+   if(!bz) return;
+   BZ2_bzDecompressEnd(&(bz->stream));
+   delete bz;
+   bz = 0;
+   }
+
+}
diff --git a/modules/comp_bzip2/bzip2.h b/modules/comp_bzip2/bzip2.h
new file mode 100644
index 000000000..40bfd1a77
--- /dev/null
+++ b/modules/comp_bzip2/bzip2.h
@@ -0,0 +1,58 @@
+/*************************************************
+* Bzip Compressor Header File                    *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_BZIP2_H__
+#define BOTAN_EXT_BZIP2_H__
+
+#include <botan/filter.h>
+
+namespace Botan {
+
+/*************************************************
+* Bzip Compression Filter                        *
+*************************************************/
+class Bzip_Compression : public Filter
+   {
+   public:
+      void write(const byte input[], u32bit length);
+      void start_msg();
+      void end_msg();
+
+      void flush();
+
+      Bzip_Compression(u32bit = 9);
+      ~Bzip_Compression() { clear(); }
+   private:
+      void clear();
+
+      const u32bit level;
+      SecureVector<byte> buffer;
+      class Bzip_Stream* bz;
+   };
+
+/*************************************************
+* Bzip Decompression Filter                      *
+*************************************************/
+class Bzip_Decompression : public Filter
+   {
+   public:
+      void write(const byte input[], u32bit length);
+      void start_msg();
+      void end_msg();
+
+      Bzip_Decompression(bool = false);
+      ~Bzip_Decompression() { clear(); }
+   private:
+      void clear();
+
+      const bool small_mem;
+      SecureVector<byte> buffer;
+      class Bzip_Stream* bz;
+      bool no_writes;
+   };
+
+}
+
+#endif
diff --git a/modules/comp_bzip2/modinfo.txt b/modules/comp_bzip2/modinfo.txt
new file mode 100644
index 000000000..3f1428e2c
--- /dev/null
+++ b/modules/comp_bzip2/modinfo.txt
@@ -0,0 +1,14 @@
+# This module was written by Peter J. Jones
+
+uses_external_libs
+
+realname "Bzip2 Compressor"
+
+define COMPRESSOR_BZIP2
+
+add_file bzip2.h
+add_file bzip2.cpp
+
+<libs>
+all -> bz2
+</libs>
diff --git a/modules/comp_zlib/modinfo.txt b/modules/comp_zlib/modinfo.txt
new file mode 100644
index 000000000..32acec513
--- /dev/null
+++ b/modules/comp_zlib/modinfo.txt
@@ -0,0 +1,16 @@
+realname "Zlib Compressor"
+#realname "Zlib/Gzip Compressor"
+
+uses_external_libs
+
+define COMPRESSOR_ZLIB
+#define COMPRESSOR_GZIP
+
+add_file zlib.h
+add_file zlib.cpp
+#add_file gzip.h
+#add_file gzip.cpp
+
+<libs>
+all -> z
+</libs>
diff --git a/modules/comp_zlib/zlib.cpp b/modules/comp_zlib/zlib.cpp
new file mode 100644
index 000000000..8bbafcea2
--- /dev/null
+++ b/modules/comp_zlib/zlib.cpp
@@ -0,0 +1,266 @@
+/*************************************************
+* Zlib Compressor Source File                    *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/zlib.h>
+#include <cstring>
+#include <map>
+#include <zlib.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* Allocation Information for Zlib                *
+*************************************************/
+class Zlib_Alloc_Info
+   {
+   public:
+      std::map<void*, u32bit> current_allocs;
+      Allocator* alloc;
+
+      Zlib_Alloc_Info() { alloc = get_allocator(); }
+   };
+
+/*************************************************
+* Allocation Function for Zlib                   *
+*************************************************/
+void* zlib_malloc(void* info_ptr, unsigned int n, unsigned int size)
+   {
+   Zlib_Alloc_Info* info = static_cast<Zlib_Alloc_Info*>(info_ptr);
+   void* ptr = info->alloc->allocate(n * size);
+   info->current_allocs[ptr] = n * size;
+   return ptr;
+   }
+
+/*************************************************
+* Allocation Function for Zlib                   *
+*************************************************/
+void zlib_free(void* info_ptr, void* ptr)
+   {
+   Zlib_Alloc_Info* info = static_cast<Zlib_Alloc_Info*>(info_ptr);
+   std::map<void*, u32bit>::const_iterator i = info->current_allocs.find(ptr);
+   if(i == info->current_allocs.end())
+      throw Invalid_Argument("zlib_free: Got pointer not allocated by us");
+   info->alloc->deallocate(ptr, i->second);
+   }
+
+}
+
+/*************************************************
+* Wrapper Type for Zlib z_stream                 *
+*************************************************/
+class Zlib_Stream
+   {
+   public:
+      z_stream stream;
+
+      Zlib_Stream()
+         {
+         std::memset(&stream, 0, sizeof(z_stream));
+         stream.zalloc = zlib_malloc;
+         stream.zfree = zlib_free;
+         stream.opaque = new Zlib_Alloc_Info;
+         }
+      ~Zlib_Stream()
+         {
+         Zlib_Alloc_Info* info = static_cast<Zlib_Alloc_Info*>(stream.opaque);
+         delete info;
+         std::memset(&stream, 0, sizeof(z_stream));
+         }
+   };
+
+/*************************************************
+* Zlib_Compression Constructor                   *
+*************************************************/
+Zlib_Compression::Zlib_Compression(u32bit l) :
+   level((l >= 9) ? 9 : l), buffer(DEFAULT_BUFFERSIZE)
+   {
+   zlib = 0;
+   }
+
+/*************************************************
+* Start Compressing with Zlib                    *
+*************************************************/
+void Zlib_Compression::start_msg()
+   {
+   clear();
+   zlib = new Zlib_Stream;
+   if(deflateInit(&(zlib->stream), level) != Z_OK)
+      throw Exception("Zlib_Compression: Memory allocation error");
+   }
+
+/*************************************************
+* Compress Input with Zlib                       *
+*************************************************/
+void Zlib_Compression::write(const byte input[], u32bit length)
+   {
+   zlib->stream.next_in = (Bytef*)input;
+   zlib->stream.avail_in = length;
+
+   while(zlib->stream.avail_in != 0)
+      {
+      zlib->stream.next_out = (Bytef*)buffer.begin();
+      zlib->stream.avail_out = buffer.size();
+      deflate(&(zlib->stream), Z_NO_FLUSH);
+      send(buffer.begin(), buffer.size() - zlib->stream.avail_out);
+      }
+   }
+
+/*************************************************
+* Finish Compressing with Zlib                   *
+*************************************************/
+void Zlib_Compression::end_msg()
+   {
+   zlib->stream.next_in = 0;
+   zlib->stream.avail_in = 0;
+
+   int rc = Z_OK;
+   while(rc != Z_STREAM_END)
+      {
+      zlib->stream.next_out = (Bytef*)buffer.begin();
+      zlib->stream.avail_out = buffer.size();
+      rc = deflate(&(zlib->stream), Z_FINISH);
+      send(buffer.begin(), buffer.size() - zlib->stream.avail_out);
+      }
+   clear();
+   }
+
+/*************************************************
+* Flush the Zlib Compressor                      *
+*************************************************/
+void Zlib_Compression::flush()
+   {
+   zlib->stream.next_in = 0;
+   zlib->stream.avail_in = 0;
+
+   while(true)
+      {
+      zlib->stream.next_out = (Bytef*)buffer.begin();
+      zlib->stream.avail_out = buffer.size();
+      deflate(&(zlib->stream), Z_FULL_FLUSH);
+      send(buffer.begin(), buffer.size() - zlib->stream.avail_out);
+      if(zlib->stream.avail_out == buffer.size()) break;
+      }
+   }
+
+/*************************************************
+* Clean up Compression Context                   *
+*************************************************/
+void Zlib_Compression::clear()
+   {
+   if(zlib)
+      {
+      deflateEnd(&(zlib->stream));
+      delete zlib;
+      zlib = 0;
+      }
+
+   buffer.clear();
+   }
+
+/*************************************************
+* Zlib_Decompression Constructor                 *
+*************************************************/
+Zlib_Decompression::Zlib_Decompression() : buffer(DEFAULT_BUFFERSIZE)
+   {
+   zlib = 0;
+   no_writes = true;
+   }
+
+/*************************************************
+* Start Decompressing with Zlib                  *
+*************************************************/
+void Zlib_Decompression::start_msg()
+   {
+   clear();
+   zlib = new Zlib_Stream;
+   if(inflateInit(&(zlib->stream)) != Z_OK)
+      throw Exception("Zlib_Decompression: Memory allocation error");
+   }
+
+/*************************************************
+* Decompress Input with Zlib                     *
+*************************************************/
+void Zlib_Decompression::write(const byte input[], u32bit length)
+   {
+   if(length) no_writes = false;
+
+   zlib->stream.next_in = (Bytef*)input;
+   zlib->stream.avail_in = length;
+
+   while(zlib->stream.avail_in != 0)
+      {
+      zlib->stream.next_out = (Bytef*)buffer.begin();
+      zlib->stream.avail_out = buffer.size();
+
+      int rc = inflate(&(zlib->stream), Z_SYNC_FLUSH);
+      if(rc != Z_OK && rc != Z_STREAM_END)
+         {
+         clear();
+         if(rc == Z_DATA_ERROR)
+            throw Decoding_Error("Zlib_Decompression: Data integrity error");
+         if(rc == Z_NEED_DICT)
+            throw Decoding_Error("Zlib_Decompression: Need preset dictionary");
+         if(rc == Z_MEM_ERROR)
+            throw Exception("Zlib_Decompression: Memory allocation error");
+         throw Exception("Zlib_Decompression: Unknown decompress error");
+         }
+      send(buffer.begin(), buffer.size() - zlib->stream.avail_out);
+      if(rc == Z_STREAM_END)
+         {
+         u32bit read_from_block = length - zlib->stream.avail_in;
+         start_msg();
+         zlib->stream.next_in = (Bytef*)input + read_from_block;
+         zlib->stream.avail_in = length - read_from_block;
+         input += read_from_block;
+         length -= read_from_block;
+         }
+      }
+   }
+
+/*************************************************
+* Finish Decompressing with Zlib                 *
+*************************************************/
+void Zlib_Decompression::end_msg()
+   {
+   if(no_writes) return;
+   zlib->stream.next_in = 0;
+   zlib->stream.avail_in = 0;
+
+   int rc = Z_OK;
+   while(rc != Z_STREAM_END)
+      {
+      zlib->stream.next_out = (Bytef*)buffer.begin();
+      zlib->stream.avail_out = buffer.size();
+      rc = inflate(&(zlib->stream), Z_SYNC_FLUSH);
+      if(rc != Z_OK && rc != Z_STREAM_END)
+         {
+         clear();
+         throw Exception("Zlib_Decompression: Error finalizing decompression");
+         }
+      send(buffer.begin(), buffer.size() - zlib->stream.avail_out);
+      }
+   clear();
+   }
+
+/*************************************************
+* Clean up Decompression Context                 *
+*************************************************/
+void Zlib_Decompression::clear()
+   {
+   no_writes = true;
+
+   if(zlib)
+      {
+      inflateEnd(&(zlib->stream));
+      delete zlib;
+      zlib = 0;
+      }
+
+   buffer.clear();
+   }
+
+}
diff --git a/modules/comp_zlib/zlib.h b/modules/comp_zlib/zlib.h
new file mode 100644
index 000000000..1557afaab
--- /dev/null
+++ b/modules/comp_zlib/zlib.h
@@ -0,0 +1,55 @@
+/*************************************************
+* Zlib Compressor Header File                    *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_ZLIB_H__
+#define BOTAN_EXT_ZLIB_H__
+
+#include <botan/filter.h>
+
+namespace Botan {
+
+/*************************************************
+* Zlib Compression Filter                        *
+*************************************************/
+class Zlib_Compression : public Filter
+   {
+   public:
+      void write(const byte input[], u32bit length);
+      void start_msg();
+      void end_msg();
+
+      void flush();
+
+      Zlib_Compression(u32bit = 6);
+      ~Zlib_Compression() { clear(); }
+   private:
+      void clear();
+      const u32bit level;
+      SecureVector<byte> buffer;
+      class Zlib_Stream* zlib;
+   };
+
+/*************************************************
+* Zlib Decompression Filter                      *
+*************************************************/
+class Zlib_Decompression : public Filter
+   {
+   public:
+      void write(const byte input[], u32bit length);
+      void start_msg();
+      void end_msg();
+
+      Zlib_Decompression();
+      ~Zlib_Decompression() { clear(); }
+   private:
+      void clear();
+      SecureVector<byte> buffer;
+      class Zlib_Stream* zlib;
+      bool no_writes;
+   };
+
+}
+
+#endif
diff --git a/modules/eng_aep/aep_conn.cpp b/modules/eng_aep/aep_conn.cpp
new file mode 100644
index 000000000..9293f45fc
--- /dev/null
+++ b/modules/eng_aep/aep_conn.cpp
@@ -0,0 +1,92 @@
+/*************************************************
+* AEP Connection Management Source File          *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/aep_conn.h>
+#include <botan/libstate.h>
+#include <botan/parsing.h>
+#include <botan/hw_aep.h>
+
+namespace Botan {
+
+/*************************************************
+* Persistent connection pool                     *
+*************************************************/
+std::vector<AEP_Connection::Connection_Info> AEP_Connection::pool;
+Mutex* AEP_Connection::guard = 0;
+
+/*************************************************
+* Close all currently open connections           *
+*************************************************/
+void AEP_Connection::close_all_connections()
+   {
+   guard->lock();
+   for(u32bit j = 0; j != pool.size(); j++)
+      AEP::AEP_CloseConnection(pool[j].id);
+   pool.clear();
+   guard->unlock();
+   delete guard;
+   guard = 0;
+   }
+
+/*************************************************
+* Get a new connection handle                    *
+*************************************************/
+AEP_Connection::AEP_Connection()
+   {
+   // FIXME: race condition
+   if(!guard)
+      guard = global_state().get_mutex();
+
+   Mutex_Holder lock(guard);
+
+   this_connection = 0;
+
+   for(u32bit j = 0; j != pool.size(); j++)
+      {
+      if(pool[j].in_use)
+         continue;
+
+      pool[j].in_use = true;
+      this_connection = pool[j].id;
+      }
+
+   if(this_connection == 0)
+      {
+      Connection_Info new_conn;
+
+      u32bit retval = AEP::AEP_OpenConnection(&new_conn.id);
+      if(retval != 0)
+         throw Stream_IO_Error("AEP_OpenConnection failed");
+      new_conn.in_use = true;
+
+      if(pool.size() < MAX_CACHED_CONNECTIONS)
+         pool.push_back(new_conn);
+
+      this_connection = new_conn.id;
+      }
+   }
+
+/*************************************************
+* Free a connection handle                       *
+*************************************************/
+AEP_Connection::~AEP_Connection()
+   {
+   Mutex_Holder lock(guard);
+
+   for(u32bit j = 0; j != pool.size(); j++)
+      {
+      if(pool[j].id != this_connection)
+         continue;
+
+      pool[j].in_use = false;
+      return;
+      }
+
+   int retval = AEP::AEP_CloseConnection(this_connection);
+   if(retval != 0)
+      throw Exception("AEP_CloseConnection returned " + to_string(retval));
+   }
+
+}
diff --git a/modules/eng_aep/aep_conn.h b/modules/eng_aep/aep_conn.h
new file mode 100644
index 000000000..18b8c76db
--- /dev/null
+++ b/modules/eng_aep/aep_conn.h
@@ -0,0 +1,38 @@
+/*************************************************
+* AEP Connection Management Header File          *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_AEP_CONNECTION_H__
+#define BOTAN_EXT_AEP_CONNECTION_H__
+
+#include <botan/eng_aep.h>
+#include <botan/mutex.h>
+
+namespace Botan {
+
+/*************************************************
+* AEP Connection                                 *
+*************************************************/
+class AEP_Connection
+   {
+   public:
+      operator u32bit () { return this_connection; }
+
+      static void close_all_connections();
+
+      AEP_Connection();
+      ~AEP_Connection();
+   private:
+      struct Connection_Info { u32bit id; bool in_use; };
+
+      static const u32bit MAX_CACHED_CONNECTIONS = 8;
+      static std::vector<Connection_Info> pool;
+      static Mutex* guard;
+
+      u32bit this_connection;
+   };
+
+}
+
+#endif
diff --git a/modules/eng_aep/aep_main.cpp b/modules/eng_aep/aep_main.cpp
new file mode 100644
index 000000000..d941597da
--- /dev/null
+++ b/modules/eng_aep/aep_main.cpp
@@ -0,0 +1,191 @@
+/*************************************************
+* AEP Interface Source File                      *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/eng_aep.h>
+#include <botan/parsing.h>
+#include <botan/util.h>
+#include <botan/mutex.h>
+#include <botan/aep_conn.h>
+#include <botan/hw_aep.h>
+#include <botan/es_aep.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* AEP Exception                                  *
+*************************************************/
+class AEP_Exception : public Exception
+   {
+   public:
+      AEP_Exception(const std::string func, u32bit retval) :
+         Exception(func + " failed; returned " + to_string(retval)) {}
+   };
+
+/*************************************************
+* Return the size in bytes of this BigInt        *
+*************************************************/
+u32bit get_bigint_size(void* bigint_ptr, u32bit* bytes)
+   {
+   const BigInt* bigint = static_cast<BigInt*>(bigint_ptr);
+   const u32bit actual_bytes = bigint->bytes();
+   *bytes = round_up(actual_bytes, 4);
+   return 0;
+   }
+
+/*************************************************
+* Store a BigInt into AEP format                 *
+*************************************************/
+u32bit store_bigint(void* bigint_ptr, u32bit output_size, byte* output)
+   {
+   const BigInt* bigint = static_cast<BigInt*>(bigint_ptr);
+
+   const u32bit leading_zeros = round_up(bigint->bytes(), 4) - bigint->bytes();
+
+   clear_mem(output, output_size);
+   bigint->binary_encode(output + leading_zeros);
+   for(u32bit j = 0; j != output_size / 2; j++)
+      std::swap(output[j], output[output_size-j-1]);
+
+   return 0;
+   }
+
+/*************************************************
+* Read a BigInt from the AEP format              *
+*************************************************/
+u32bit create_bigint(void* bigint_ptr, u32bit input_size, byte* input)
+   {
+   BigInt* bigint = static_cast<BigInt*>(bigint_ptr);
+
+   for(u32bit j = 0; j != input_size / 2; j++)
+      std::swap(input[j], input[input_size-j-1]);
+   bigint->binary_decode(input, input_size);
+
+   return 0;
+   }
+
+}
+
+/*************************************************
+* AEP Modular Exponentiation Operation           *
+*************************************************/
+BigInt AEP_Engine::pow_mod(const BigInt& i, const BigInt& x, const BigInt& m)
+   {
+   BigInt output;
+
+   AEP_Connection conn;
+   u32bit retval = AEP::AEP_ModExp(conn, &i, &x, &m, &output, 0);
+
+   if(retval != 0)
+      throw AEP_Exception("AEP_ModExp", retval);
+
+   return output;
+   }
+
+/*************************************************
+* AEP Modular Exponentiation with CRT Operation  *
+*************************************************/
+BigInt AEP_Engine::pow_mod_crt(const BigInt& i, const BigInt&,
+                               const BigInt& p, const BigInt& q,
+                               const BigInt& d1, const BigInt& d2,
+                               const BigInt& c)
+   {
+   BigInt output;
+
+   AEP_Connection conn;
+   u32bit retval = AEP::AEP_ModExpCrt(conn, &i, &p, &q, &d1, &d2, &c,
+                                      &output, 0);
+
+   if(retval != 0)
+      throw AEP_Exception("AEP_ModExpCrt", retval);
+   return output;
+   }
+
+/*************************************************
+* AEP RNG Operation                              *
+*************************************************/
+u32bit AEP_Engine::get_entropy(byte output[], u32bit length) throw()
+   {
+   if(length > 256)
+      length = 256;
+
+   try {
+      AEP_Connection conn;
+      u32bit retval = AEP::AEP_GenRandom(conn, length, 1, output, 0);
+
+      if(retval != 0)
+         return 0;
+      return length;
+   }
+   catch(...)
+      {
+      return 0;
+      }
+   }
+
+/*************************************************
+* AEP usability check                            *
+*************************************************/
+bool AEP_Engine::ok_to_use(const BigInt& x) throw()
+   {
+   if(daemon_is_up && (x.bits() <= AEP::MAX_MODULO_BITS))
+      return true;
+   return false;
+   }
+
+/*************************************************
+* AEP daemon status flag                         *
+*************************************************/
+bool AEP_Engine::daemon_is_up = false;
+
+/*************************************************
+* AEP_Engine Constructor                         *
+*************************************************/
+AEP_Engine::AEP_Engine()
+   {
+   daemon_is_up = false;
+
+   try {
+      u32bit retval = AEP::AEP_Initialize(0);
+
+      if(retval != 0 && retval != AEP::ALREADY_INIT)
+         throw AEP_Exception("AEP_Initialize", retval);
+
+      if(retval == 0)
+         {
+         retval = AEP::AEP_SetBNCallBacks(get_bigint_size, store_bigint,
+                                          create_bigint);
+         if(retval != 0)
+            throw AEP_Exception("AEP_SetBNCallBacks", retval);
+
+         AEP_Connection conn;
+         daemon_is_up = true;
+         }
+
+   }
+   catch(AEP_Exception&) {}
+   }
+
+/*************************************************
+* AEP_Engine Destructor                          *
+*************************************************/
+AEP_Engine::~AEP_Engine()
+   {
+   AEP_Connection::close_all_connections();
+   u32bit retval = AEP::AEP_Finalize();
+   if(retval != 0)
+      throw AEP_Exception("AEP_Finalize", retval);
+   }
+
+/*************************************************
+* Gather Entropy from AEP Hardware RNG           *
+*************************************************/
+u32bit AEP_EntropySource::slow_poll(byte output[], u32bit length)
+   {
+   return AEP_Engine::get_entropy(output, length);
+   }
+
+}
diff --git a/modules/eng_aep/eng_aep.cpp b/modules/eng_aep/eng_aep.cpp
new file mode 100644
index 000000000..557132b37
--- /dev/null
+++ b/modules/eng_aep/eng_aep.cpp
@@ -0,0 +1,352 @@
+/*************************************************
+* AEP Engine Source File                         *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/eng_aep.h>
+#include <botan/numthry.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* AEP IF Operation                               *
+*************************************************/
+class AEP_IF_Op : public IF_Operation
+   {
+   public:
+      BigInt public_op(const BigInt&) const;
+      BigInt private_op(const BigInt&) const;
+
+      IF_Operation* clone() const { return new AEP_IF_Op(*this); }
+
+      AEP_IF_Op(const BigInt&, const BigInt&, const BigInt&,
+                const BigInt&, const BigInt&, const BigInt&,
+                const BigInt&, const BigInt&);
+   private:
+      const BigInt e, n, p, q, d1, d2, c;
+   };
+
+/*************************************************
+* AEP_IF_Op Constructor                          *
+*************************************************/
+AEP_IF_Op::AEP_IF_Op(const BigInt& ex, const BigInt& nx, const BigInt&,
+                     const BigInt& px, const BigInt& qx,
+                     const BigInt& d1x, const BigInt& d2x,
+                     const BigInt& cx) :
+   e(ex), n(nx), p(px), q(qx), d1(d1x), d2(d2x), c(cx)
+   {
+   }
+
+/*************************************************
+* AEP IF Public Operation                        *
+*************************************************/
+BigInt AEP_IF_Op::public_op(const BigInt& i) const
+   {
+   return AEP_Engine::pow_mod(i, e, n);
+   }
+
+/*************************************************
+* AEP IF Private Operation                       *
+*************************************************/
+BigInt AEP_IF_Op::private_op(const BigInt& i) const
+   {
+   if(p == 0 || q == 0)
+      throw Internal_Error("AEP_IF_Op::private_op: No private key");
+
+   return AEP_Engine::pow_mod_crt(i, n, p, q, d1, d2, c);
+   }
+
+/*************************************************
+* AEP DSA Operation                              *
+*************************************************/
+class AEP_DSA_Op : public DSA_Operation
+   {
+   public:
+      bool verify(const byte[], u32bit, const byte[], u32bit) const;
+      SecureVector<byte> sign(const byte[], u32bit, const BigInt&) const;
+
+      DSA_Operation* clone() const { return new AEP_DSA_Op(*this); }
+
+      AEP_DSA_Op(const DL_Group&, const BigInt&, const BigInt&);
+   private:
+      const BigInt x, y;
+      const DL_Group group;
+   };
+
+/*************************************************
+* AEP_DSA_Op Constructor                         *
+*************************************************/
+AEP_DSA_Op::AEP_DSA_Op(const DL_Group& grp, const BigInt& y1,
+                       const BigInt& x1) : x(x1), y(y1), group(grp)
+   {
+   }
+
+/*************************************************
+* AEP DSA Verify Operation                       *
+*************************************************/
+bool AEP_DSA_Op::verify(const byte msg[], u32bit msg_len,
+                        const byte sig[], u32bit sig_len) const
+   {
+   const BigInt& g = group.get_g();
+   const BigInt& q = group.get_q();
+   const BigInt& p = group.get_p();
+
+   if(sig_len != 2*q.bytes() || msg_len > q.bytes())
+      return false;
+
+   BigInt r(sig, q.bytes());
+   BigInt s(sig + q.bytes(), q.bytes());
+   BigInt i(msg, msg_len);
+
+   if(r <= 0 || r >= q || s <= 0 || s >= q)
+      return false;
+
+   s = inverse_mod(s, q);
+   s = mul_mod(AEP_Engine::pow_mod(g, mul_mod(s, i, q), p),
+               AEP_Engine::pow_mod(y, mul_mod(s, r, q), p), p);
+
+   return (s % q == r);
+   }
+
+/*************************************************
+* AEP DSA Sign Operation                         *
+*************************************************/
+SecureVector<byte> AEP_DSA_Op::sign(const byte in[], u32bit length,
+                                    const BigInt& k) const
+   {
+   if(x == 0)
+      throw Internal_Error("AEP_DSA_Op::sign: No private key");
+
+   const BigInt& g = group.get_g();
+   const BigInt& q = group.get_q();
+   const BigInt& p = group.get_p();
+   BigInt i(in, length);
+
+   BigInt r = AEP_Engine::pow_mod(g, k, p) % q;
+   BigInt s = mul_mod(inverse_mod(k, q), mul_add(x, r, i), q);
+   if(r.is_zero() || s.is_zero())
+      throw Internal_Error("AEP_DSA_Op::sign: r or s was zero");
+
+   SecureVector<byte> output(2*q.bytes());
+   r.binary_encode(output + (output.size() / 2 - r.bytes()));
+   s.binary_encode(output + (output.size() - s.bytes()));
+   return output;
+   }
+
+/*************************************************
+* AEP NR Operation                               *
+*************************************************/
+class AEP_NR_Op : public NR_Operation
+   {
+   public:
+      SecureVector<byte> verify(const byte[], u32bit) const;
+      SecureVector<byte> sign(const byte[], u32bit, const BigInt&) const;
+
+      NR_Operation* clone() const { return new AEP_NR_Op(*this); }
+
+      AEP_NR_Op(const DL_Group&, const BigInt&, const BigInt&);
+   private:
+      const BigInt x, y;
+      const DL_Group group;
+   };
+
+/*************************************************
+* AEP_NR_Op Constructor                          *
+*************************************************/
+AEP_NR_Op::AEP_NR_Op(const DL_Group& grp, const BigInt& y1,
+                     const BigInt& x1) : x(x1), y(y1), group(grp)
+   {
+   }
+
+/*************************************************
+* AEP NR Verify Operation                        *
+*************************************************/
+SecureVector<byte> AEP_NR_Op::verify(const byte in[], u32bit length) const
+   {
+   const BigInt& g = group.get_g();
+   const BigInt& q = group.get_q();
+   const BigInt& p = group.get_p();
+
+   if(length != 2*q.bytes())
+      return false;
+
+   BigInt c(in, q.bytes());
+   BigInt d(in + q.bytes(), q.bytes());
+
+   if(c.is_zero() || c >= q || d >= q)
+      throw Invalid_Argument("AEP_NR_Op::verify: Invalid signature");
+
+   BigInt i = mul_mod(AEP_Engine::pow_mod(g, d, p),
+                      AEP_Engine::pow_mod(y, c, p), p);
+   return BigInt::encode((c - i) % q);
+   }
+
+/*************************************************
+* AEP NR Sign Operation                          *
+*************************************************/
+SecureVector<byte> AEP_NR_Op::sign(const byte in[], u32bit length,
+                                   const BigInt& k) const
+   {
+   if(x == 0)
+      throw Internal_Error("AEP_NR_Op::sign: No private key");
+
+   const BigInt& g = group.get_g();
+   const BigInt& q = group.get_q();
+   const BigInt& p = group.get_p();
+
+   BigInt f(in, length);
+
+   if(f >= q)
+      throw Invalid_Argument("AEP_NR_Op::sign: Input is out of range");
+
+   BigInt c = (AEP_Engine::pow_mod(g, k, p) + f) % q;
+   if(c.is_zero())
+      throw Internal_Error("AEP_NR_Op::sign: c was zero");
+   BigInt d = (k - x * c) % q;
+
+   SecureVector<byte> output(2*q.bytes());
+   c.binary_encode(output + (output.size() / 2 - c.bytes()));
+   d.binary_encode(output + (output.size() - d.bytes()));
+   return output;
+   }
+
+/*************************************************
+* AEP ElGamal Operation                          *
+*************************************************/
+class AEP_ELG_Op : public ELG_Operation
+   {
+   public:
+      SecureVector<byte> encrypt(const byte[], u32bit, const BigInt&) const;
+      BigInt decrypt(const BigInt&, const BigInt&) const;
+
+      ELG_Operation* clone() const { return new AEP_ELG_Op(*this); }
+
+      AEP_ELG_Op(const DL_Group&, const BigInt&, const BigInt&);
+   private:
+      const BigInt x, y;
+      const DL_Group group;
+   };
+
+/*************************************************
+* AEP_ELG_Op Constructor                         *
+*************************************************/
+AEP_ELG_Op::AEP_ELG_Op(const DL_Group& grp, const BigInt& y1,
+                       const BigInt& x1) : x(x1), y(y1), group(grp)
+   {
+   }
+
+/*************************************************
+* AEP ElGamal Encrypt Operation                  *
+*************************************************/
+SecureVector<byte> AEP_ELG_Op::encrypt(const byte in[], u32bit length,
+                                       const BigInt& k) const
+   {
+   const BigInt& g = group.get_g();
+   const BigInt& p = group.get_p();
+
+   BigInt m(in, length);
+   if(m >= p)
+      throw Invalid_Argument("AEP_ELG_Op::encrypt: Input is too large");
+
+   BigInt a = AEP_Engine::pow_mod(g, k, p);
+   BigInt b = mul_mod(m, AEP_Engine::pow_mod(y, k, p), p);
+
+   SecureVector<byte> output(2*p.bytes());
+   a.binary_encode(output + (p.bytes() - a.bytes()));
+   b.binary_encode(output + output.size() / 2 + (p.bytes() - b.bytes()));
+   return output;
+   }
+
+/*************************************************
+* AEP ElGamal Decrypt Operation                  *
+*************************************************/
+BigInt AEP_ELG_Op::decrypt(const BigInt& a, const BigInt& b) const
+   {
+   if(x == 0)
+      throw Internal_Error("AEP_ELG_Op::decrypt: No private key");
+
+   const BigInt& p = group.get_p();
+
+   if(a >= p || b >= p)
+      throw Invalid_Argument("AEP_ELG_Op: Invalid message");
+
+   return mul_mod(b, inverse_mod(AEP_Engine::pow_mod(a, x, p), p), p);
+   }
+
+/*************************************************
+* AEP DH Operation                               *
+*************************************************/
+class AEP_DH_Op : public DH_Operation
+   {
+   public:
+      BigInt agree(const BigInt& i) const
+         { return AEP_Engine::pow_mod(i, x, p); }
+      DH_Operation* clone() const { return new AEP_DH_Op(*this); }
+
+      AEP_DH_Op(const DL_Group& group, const BigInt& x1) :
+         x(x1), p(group.get_p()) {}
+   private:
+      const BigInt x, p;
+   };
+
+}
+
+/*************************************************
+* Acquire an IF op                               *
+*************************************************/
+IF_Operation* AEP_Engine::if_op(const BigInt& e, const BigInt& n,
+                                const BigInt& d, const BigInt& p,
+                                const BigInt& q, const BigInt& d1,
+                                const BigInt& d2, const BigInt& c) const
+   {
+   if(AEP_Engine::ok_to_use(n))
+      return new AEP_IF_Op(e, n, d, p, q, d1, d2, c);
+   return 0;
+   }
+
+/*************************************************
+* Acquire a DSA op                               *
+*************************************************/
+DSA_Operation* AEP_Engine::dsa_op(const DL_Group& group, const BigInt& y,
+                                  const BigInt& x) const
+   {
+   if(AEP_Engine::ok_to_use(group.get_p()))
+      return new AEP_DSA_Op(group, y, x);
+   return 0;
+   }
+
+/*************************************************
+* Acquire a NR op                                *
+*************************************************/
+NR_Operation* AEP_Engine::nr_op(const DL_Group& group, const BigInt& y,
+                                const BigInt& x) const
+   {
+   if(AEP_Engine::ok_to_use(group.get_p()))
+      return new AEP_NR_Op(group, y, x);
+   return 0;
+   }
+
+/*************************************************
+* Acquire an ElGamal op                          *
+*************************************************/
+ELG_Operation* AEP_Engine::elg_op(const DL_Group& group, const BigInt& y,
+                                  const BigInt& x) const
+   {
+   if(AEP_Engine::ok_to_use(group.get_p()))
+      return new AEP_ELG_Op(group, y, x);
+   return 0;
+   }
+
+/*************************************************
+* Acquire a DH op                                *
+*************************************************/
+DH_Operation* AEP_Engine::dh_op(const DL_Group& group, const BigInt& x) const
+   {
+   if(AEP_Engine::ok_to_use(group.get_p()))
+      return new AEP_DH_Op(group, x);
+   return 0;
+   }
+
+}
diff --git a/modules/eng_aep/eng_aep.h b/modules/eng_aep/eng_aep.h
new file mode 100644
index 000000000..0b47c7322
--- /dev/null
+++ b/modules/eng_aep/eng_aep.h
@@ -0,0 +1,51 @@
+/*************************************************
+* AEP Engine Header File                         *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_AEP_ENGINE_H__
+#define BOTAN_EXT_AEP_ENGINE_H__
+
+#include <botan/engine.h>
+#include <vector>
+
+namespace Botan {
+
+/*************************************************
+* AEP Engine                                     *
+*************************************************/
+class AEP_Engine : public Engine
+   {
+   public:
+      IF_Operation* if_op(const BigInt&, const BigInt&, const BigInt&,
+                          const BigInt&, const BigInt&, const BigInt&,
+                          const BigInt&, const BigInt&) const;
+
+      DSA_Operation* dsa_op(const DL_Group&, const BigInt&,
+                            const BigInt&) const;
+
+      NR_Operation* nr_op(const DL_Group&, const BigInt&, const BigInt&) const;
+
+      ELG_Operation* elg_op(const DL_Group&, const BigInt&,
+                            const BigInt&) const;
+
+      DH_Operation* dh_op(const DL_Group&, const BigInt&) const;
+
+      static BigInt pow_mod(const BigInt&, const BigInt&, const BigInt&);
+
+      static BigInt pow_mod_crt(const BigInt&, const BigInt&, const BigInt&,
+                                const BigInt&, const BigInt&, const BigInt&,
+                                const BigInt&);
+
+      static u32bit get_entropy(byte[], u32bit) throw();
+      static bool ok_to_use(const BigInt&) throw();
+
+      AEP_Engine();
+      ~AEP_Engine();
+   private:
+      static bool daemon_is_up;
+   };
+
+}
+
+#endif
diff --git a/modules/eng_aep/es_aep.h b/modules/eng_aep/es_aep.h
new file mode 100644
index 000000000..bb58a9ef5
--- /dev/null
+++ b/modules/eng_aep/es_aep.h
@@ -0,0 +1,24 @@
+/*************************************************
+* AEP EntropySource Header File                  *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_ENTROPY_SRC_AEP_H__
+#define BOTAN_EXT_ENTROPY_SRC_AEP_H__
+
+#include <botan/base.h>
+
+namespace Botan {
+
+/*************************************************
+* AEP Entropy Source                             *
+*************************************************/
+class AEP_EntropySource : public EntropySource
+   {
+   public:
+      u32bit slow_poll(byte[], u32bit);
+   };
+
+}
+
+#endif
diff --git a/modules/eng_aep/hw_aep.h b/modules/eng_aep/hw_aep.h
new file mode 100644
index 000000000..6e690e4a8
--- /dev/null
+++ b/modules/eng_aep/hw_aep.h
@@ -0,0 +1,48 @@
+/*************************************************
+* AEP Interface Header File                      *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_HW_AEP_H__
+#define BOTAN_EXT_HW_AEP_H__
+
+#include <botan/types.h>
+
+namespace Botan {
+
+namespace AEP {
+
+const u32bit MAX_MODULO_BITS = 2048;
+
+const u32bit ALREADY_INIT = 0x10000191;
+
+extern "C" {
+
+u32bit AEP_Initialize(void*);
+u32bit AEP_Finalize();
+
+u32bit AEP_OpenConnection(u32bit*);
+u32bit AEP_CloseConnection(u32bit);
+
+u32bit AEP_ModExp(u32bit, const void*, const void*, const void*, void*,
+                  u32bit*);
+u32bit AEP_ModExpCrt(u32bit, const void*, const void*, const void*,
+                     const void*, const void*, const void*, void*,
+                     u32bit*);
+
+u32bit AEP_GenRandom(u32bit, u32bit, u32bit, void*, u32bit*);
+
+typedef u32bit (*AEP_get_bignum_size_fn)(void*, u32bit*);
+typedef u32bit (*AEP_read_bignum_fn)(void*, u32bit, byte*);
+typedef u32bit (*AEP_write_bignum_fn)(void*, u32bit, byte*);
+
+u32bit AEP_SetBNCallBacks(AEP_get_bignum_size_fn, AEP_read_bignum_fn,
+                          AEP_write_bignum_fn);
+
+}
+
+}
+
+}
+
+#endif
diff --git a/modules/eng_aep/modinfo.txt b/modules/eng_aep/modinfo.txt
new file mode 100644
index 000000000..b84790b97
--- /dev/null
+++ b/modules/eng_aep/modinfo.txt
@@ -0,0 +1,22 @@
+realname "AEP Engine"
+
+uses_external_libs
+
+add_file eng_aep.cpp
+add_file aep_main.cpp
+add_file aep_conn.cpp
+
+add_file eng_aep.h
+add_file es_aep.h
+add_file hw_aep.h
+add_file aep_conn.h
+
+local_only aep_conn.h
+local_only hw_aep.h
+
+define ENGINE_AEP
+define ENTROPY_SRC_AEP
+
+<libs>
+all -> aep
+</libs>
diff --git a/modules/eng_gmp/eng_gmp.cpp b/modules/eng_gmp/eng_gmp.cpp
new file mode 100644
index 000000000..944fa90f7
--- /dev/null
+++ b/modules/eng_gmp/eng_gmp.cpp
@@ -0,0 +1,377 @@
+/*************************************************
+* GMP Engine Source File                         *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/eng_gmp.h>
+#include <botan/gmp_wrap.h>
+#include <gmp.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* GMP IF Operation                               *
+*************************************************/
+class GMP_IF_Op : public IF_Operation
+   {
+   public:
+      BigInt public_op(const BigInt&) const;
+      BigInt private_op(const BigInt&) const;
+
+      IF_Operation* clone() const { return new GMP_IF_Op(*this); }
+
+      GMP_IF_Op(const BigInt& e_bn, const BigInt& n_bn, const BigInt&,
+                const BigInt& p_bn, const BigInt& q_bn, const BigInt& d1_bn,
+                const BigInt& d2_bn, const BigInt& c_bn) :
+         e(e_bn), n(n_bn), p(p_bn), q(q_bn), d1(d1_bn), d2(d2_bn), c(c_bn) {}
+   private:
+      const GMP_MPZ e, n, p, q, d1, d2, c;
+   };
+
+/*************************************************
+* GMP IF Public Operation                        *
+*************************************************/
+BigInt GMP_IF_Op::public_op(const BigInt& i_bn) const
+   {
+   GMP_MPZ i(i_bn);
+   mpz_powm(i.value, i.value, e.value, n.value);
+   return i.to_bigint();
+   }
+
+/*************************************************
+* GMP IF Private Operation                       *
+*************************************************/
+BigInt GMP_IF_Op::private_op(const BigInt& i_bn) const
+   {
+   if(mpz_cmp_ui(p.value, 0) == 0)
+      throw Internal_Error("GMP_IF_Op::private_op: No private key");
+
+   GMP_MPZ j1, j2, h(i_bn);
+
+   mpz_powm(j1.value, h.value, d1.value, p.value);
+   mpz_powm(j2.value, h.value, d2.value, q.value);
+   mpz_sub(h.value, j1.value, j2.value);
+   mpz_mul(h.value, h.value, c.value);
+   mpz_mod(h.value, h.value, p.value);
+   mpz_mul(h.value, h.value, q.value);
+   mpz_add(h.value, h.value, j2.value);
+   return h.to_bigint();
+   }
+
+/*************************************************
+* GMP DSA Operation                              *
+*************************************************/
+class GMP_DSA_Op : public DSA_Operation
+   {
+   public:
+      bool verify(const byte[], u32bit, const byte[], u32bit) const;
+      SecureVector<byte> sign(const byte[], u32bit, const BigInt&) const;
+
+      DSA_Operation* clone() const { return new GMP_DSA_Op(*this); }
+
+      GMP_DSA_Op(const DL_Group& group, const BigInt& y1, const BigInt& x1) :
+         x(x1), y(y1), p(group.get_p()), q(group.get_q()), g(group.get_g()) {}
+   private:
+      const GMP_MPZ x, y, p, q, g;
+   };
+
+/*************************************************
+* GMP DSA Verify Operation                       *
+*************************************************/
+bool GMP_DSA_Op::verify(const byte msg[], u32bit msg_len,
+                        const byte sig[], u32bit sig_len) const
+   {
+   const u32bit q_bytes = q.bytes();
+
+   if(sig_len != 2*q_bytes || msg_len > q_bytes)
+      return false;
+
+   GMP_MPZ r(sig, q_bytes);
+   GMP_MPZ s(sig + q_bytes, q_bytes);
+   GMP_MPZ i(msg, msg_len);
+
+   if(mpz_cmp_ui(r.value, 0) <= 0 || mpz_cmp(r.value, q.value) >= 0)
+      return false;
+   if(mpz_cmp_ui(s.value, 0) <= 0 || mpz_cmp(s.value, q.value) >= 0)
+      return false;
+
+   if(mpz_invert(s.value, s.value, q.value) == 0)
+      return false;
+
+   GMP_MPZ si;
+   mpz_mul(si.value, s.value, i.value);
+   mpz_mod(si.value, si.value, q.value);
+   mpz_powm(si.value, g.value, si.value, p.value);
+
+   GMP_MPZ sr;
+   mpz_mul(sr.value, s.value, r.value);
+   mpz_mod(sr.value, sr.value, q.value);
+   mpz_powm(sr.value, y.value, sr.value, p.value);
+
+   mpz_mul(si.value, si.value, sr.value);
+   mpz_mod(si.value, si.value, p.value);
+   mpz_mod(si.value, si.value, q.value);
+
+   if(mpz_cmp(si.value, r.value) == 0)
+      return true;
+   return false;
+   }
+
+/*************************************************
+* GMP DSA Sign Operation                         *
+*************************************************/
+SecureVector<byte> GMP_DSA_Op::sign(const byte in[], u32bit length,
+                                    const BigInt& k_bn) const
+   {
+   if(mpz_cmp_ui(x.value, 0) == 0)
+      throw Internal_Error("GMP_DSA_Op::sign: No private key");
+
+   GMP_MPZ i(in, length);
+   GMP_MPZ k(k_bn);
+
+   GMP_MPZ r;
+   mpz_powm(r.value, g.value, k.value, p.value);
+   mpz_mod(r.value, r.value, q.value);
+
+   mpz_invert(k.value, k.value, q.value);
+
+   GMP_MPZ s;
+   mpz_mul(s.value, x.value, r.value);
+   mpz_add(s.value, s.value, i.value);
+   mpz_mul(s.value, s.value, k.value);
+   mpz_mod(s.value, s.value, q.value);
+
+   if(mpz_cmp_ui(r.value, 0) == 0 || mpz_cmp_ui(s.value, 0) == 0)
+      throw Internal_Error("GMP_DSA_Op::sign: r or s was zero");
+
+   const u32bit q_bytes = q.bytes();
+
+   SecureVector<byte> output(2*q_bytes);
+   r.encode(output, q_bytes);
+   s.encode(output + q_bytes, q_bytes);
+   return output;
+   }
+
+/*************************************************
+* GMP NR Operation                               *
+*************************************************/
+class GMP_NR_Op : public NR_Operation
+   {
+   public:
+      SecureVector<byte> verify(const byte[], u32bit) const;
+      SecureVector<byte> sign(const byte[], u32bit, const BigInt&) const;
+
+      NR_Operation* clone() const { return new GMP_NR_Op(*this); }
+
+      GMP_NR_Op(const DL_Group& group, const BigInt& y1, const BigInt& x1) :
+         x(x1), y(y1), p(group.get_p()), q(group.get_q()), g(group.get_g()) {}
+   private:
+      const GMP_MPZ x, y, p, q, g;
+   };
+
+/*************************************************
+* GMP NR Verify Operation                        *
+*************************************************/
+SecureVector<byte> GMP_NR_Op::verify(const byte sig[], u32bit sig_len) const
+   {
+   const u32bit q_bytes = q.bytes();
+
+   if(sig_len != 2*q_bytes)
+      return false;
+
+   GMP_MPZ c(sig, q_bytes);
+   GMP_MPZ d(sig + q_bytes, q_bytes);
+
+   if(mpz_cmp_ui(c.value, 0) <= 0 || mpz_cmp(c.value, q.value) >= 0 ||
+                                     mpz_cmp(d.value, q.value) >= 0)
+      throw Invalid_Argument("GMP_NR_Op::verify: Invalid signature");
+
+   GMP_MPZ i1, i2;
+   mpz_powm(i1.value, g.value, d.value, p.value);
+   mpz_powm(i2.value, y.value, c.value, p.value);
+   mpz_mul(i1.value, i1.value, i2.value);
+   mpz_mod(i1.value, i1.value, p.value);
+   mpz_sub(i1.value, c.value, i1.value);
+   mpz_mod(i1.value, i1.value, q.value);
+   return BigInt::encode(i1.to_bigint());
+   }
+
+/*************************************************
+* GMP NR Sign Operation                          *
+*************************************************/
+SecureVector<byte> GMP_NR_Op::sign(const byte in[], u32bit length,
+                                    const BigInt& k_bn) const
+   {
+   if(mpz_cmp_ui(x.value, 0) == 0)
+      throw Internal_Error("GMP_NR_Op::sign: No private key");
+
+   GMP_MPZ f(in, length);
+   GMP_MPZ k(k_bn);
+
+   if(mpz_cmp(f.value, q.value) >= 0)
+      throw Invalid_Argument("GMP_NR_Op::sign: Input is out of range");
+
+   GMP_MPZ c, d;
+   mpz_powm(c.value, g.value, k.value, p.value);
+   mpz_add(c.value, c.value, f.value);
+   mpz_mod(c.value, c.value, q.value);
+   mpz_mul(d.value, x.value, c.value);
+   mpz_sub(d.value, k.value, d.value);
+   mpz_mod(d.value, d.value, q.value);
+
+   if(mpz_cmp_ui(c.value, 0) == 0)
+      throw Internal_Error("Default_NR_Op::sign: c was zero");
+
+   const u32bit q_bytes = q.bytes();
+   SecureVector<byte> output(2*q_bytes);
+   c.encode(output, q_bytes);
+   d.encode(output + q_bytes, q_bytes);
+   return output;
+   }
+
+/*************************************************
+* GMP ElGamal Operation                          *
+*************************************************/
+class GMP_ELG_Op : public ELG_Operation
+   {
+   public:
+      SecureVector<byte> encrypt(const byte[], u32bit, const BigInt&) const;
+      BigInt decrypt(const BigInt&, const BigInt&) const;
+
+      ELG_Operation* clone() const { return new GMP_ELG_Op(*this); }
+
+      GMP_ELG_Op(const DL_Group& group, const BigInt& y1, const BigInt& x1) :
+         x(x1), y(y1), g(group.get_g()), p(group.get_p()) {}
+   private:
+      GMP_MPZ x, y, g, p;
+   };
+
+/*************************************************
+* GMP ElGamal Encrypt Operation                  *
+*************************************************/
+SecureVector<byte> GMP_ELG_Op::encrypt(const byte in[], u32bit length,
+                                       const BigInt& k_bn) const
+   {
+   GMP_MPZ i(in, length);
+
+   if(mpz_cmp(i.value, p.value) >= 0)
+      throw Invalid_Argument("GMP_ELG_Op: Input is too large");
+
+   GMP_MPZ a, b, k(k_bn);
+
+   mpz_powm(a.value, g.value, k.value, p.value);
+   mpz_powm(b.value, y.value, k.value, p.value);
+   mpz_mul(b.value, b.value, i.value);
+   mpz_mod(b.value, b.value, p.value);
+
+   const u32bit p_bytes = p.bytes();
+   SecureVector<byte> output(2*p_bytes);
+   a.encode(output, p_bytes);
+   b.encode(output + p_bytes, p_bytes);
+   return output;
+   }
+
+/*************************************************
+* GMP ElGamal Decrypt Operation                  *
+*************************************************/
+BigInt GMP_ELG_Op::decrypt(const BigInt& a_bn, const BigInt& b_bn) const
+   {
+   if(mpz_cmp_ui(x.value, 0) == 0)
+      throw Internal_Error("GMP_ELG_Op::decrypt: No private key");
+
+   GMP_MPZ a(a_bn), b(b_bn);
+
+   if(mpz_cmp(a.value, p.value) >= 0 || mpz_cmp(b.value, p.value) >= 0)
+      throw Invalid_Argument("GMP_ELG_Op: Invalid message");
+
+   mpz_powm(a.value, a.value, x.value, p.value);
+   mpz_invert(a.value, a.value, p.value);
+   mpz_mul(a.value, a.value, b.value);
+   mpz_mod(a.value, a.value, p.value);
+   return a.to_bigint();
+   }
+
+/*************************************************
+* GMP DH Operation                               *
+*************************************************/
+class GMP_DH_Op : public DH_Operation
+   {
+   public:
+      BigInt agree(const BigInt& i) const;
+      DH_Operation* clone() const { return new GMP_DH_Op(*this); }
+
+      GMP_DH_Op(const DL_Group& group, const BigInt& x_bn) :
+         x(x_bn), p(group.get_p()) {}
+   private:
+      GMP_MPZ x, p;
+   };
+
+/*************************************************
+* GMP DH Key Agreement Operation                 *
+*************************************************/
+BigInt GMP_DH_Op::agree(const BigInt& i_bn) const
+   {
+   GMP_MPZ i(i_bn);
+   mpz_powm(i.value, i.value, x.value, p.value);
+   return i.to_bigint();
+   }
+
+}
+
+/*************************************************
+* GMP_Engine Constructor                         *
+*************************************************/
+GMP_Engine::GMP_Engine()
+   {
+   set_memory_hooks();
+   }
+
+/*************************************************
+* Acquire an IF op                               *
+*************************************************/
+IF_Operation* GMP_Engine::if_op(const BigInt& e, const BigInt& n,
+                                const BigInt& d, const BigInt& p,
+                                const BigInt& q, const BigInt& d1,
+                                const BigInt& d2, const BigInt& c) const
+   {
+   return new GMP_IF_Op(e, n, d, p, q, d1, d2, c);
+   }
+
+/*************************************************
+* Acquire a DSA op                               *
+*************************************************/
+DSA_Operation* GMP_Engine::dsa_op(const DL_Group& group, const BigInt& y,
+                                  const BigInt& x) const
+   {
+   return new GMP_DSA_Op(group, y, x);
+   }
+
+/*************************************************
+* Acquire a NR op                                *
+*************************************************/
+NR_Operation* GMP_Engine::nr_op(const DL_Group& group, const BigInt& y,
+                                const BigInt& x) const
+   {
+   return new GMP_NR_Op(group, y, x);
+   }
+
+/*************************************************
+* Acquire an ElGamal op                          *
+*************************************************/
+ELG_Operation* GMP_Engine::elg_op(const DL_Group& group, const BigInt& y,
+                                  const BigInt& x) const
+   {
+   return new GMP_ELG_Op(group, y, x);
+   }
+
+/*************************************************
+* Acquire a DH op                                *
+*************************************************/
+DH_Operation* GMP_Engine::dh_op(const DL_Group& group, const BigInt& x) const
+   {
+   return new GMP_DH_Op(group, x);
+   }
+
+}
diff --git a/modules/eng_gmp/eng_gmp.h b/modules/eng_gmp/eng_gmp.h
new file mode 100644
index 000000000..08a66a3f8
--- /dev/null
+++ b/modules/eng_gmp/eng_gmp.h
@@ -0,0 +1,43 @@
+/*************************************************
+* GMP Engine Header File                         *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_ENGINE_GMP_H__
+#define BOTAN_EXT_ENGINE_GMP_H__
+
+#include <botan/engine.h>
+
+namespace Botan {
+
+/*************************************************
+* GMP Engine                                     *
+*************************************************/
+class GMP_Engine : public Engine
+   {
+   public:
+      IF_Operation* if_op(const BigInt&, const BigInt&, const BigInt&,
+                          const BigInt&, const BigInt&, const BigInt&,
+                          const BigInt&, const BigInt&) const;
+
+      DSA_Operation* dsa_op(const DL_Group&, const BigInt&,
+                            const BigInt&) const;
+
+      NR_Operation* nr_op(const DL_Group&, const BigInt&, const BigInt&) const;
+
+      ELG_Operation* elg_op(const DL_Group&, const BigInt&,
+                            const BigInt&) const;
+
+      DH_Operation* dh_op(const DL_Group&, const BigInt&) const;
+
+      Modular_Exponentiator* mod_exp(const BigInt&,
+                                     Power_Mod::Usage_Hints) const;
+
+      GMP_Engine();
+   private:
+      static void set_memory_hooks();
+   };
+
+}
+
+#endif
diff --git a/modules/eng_gmp/gmp_mem.cpp b/modules/eng_gmp/gmp_mem.cpp
new file mode 100644
index 000000000..1919c39e1
--- /dev/null
+++ b/modules/eng_gmp/gmp_mem.cpp
@@ -0,0 +1,60 @@
+/*************************************************
+* GNU MP Memory Handlers Source File             *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/eng_gmp.h>
+#include <cstring>
+#include <gmp.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* Allocator used by GNU MP                       *
+*************************************************/
+Allocator* gmp_alloc = 0;
+
+/*************************************************
+* Allocation Function for GNU MP                 *
+*************************************************/
+void* gmp_malloc(size_t n)
+   {
+   return gmp_alloc->allocate(n);
+   }
+
+/*************************************************
+* Reallocation Function for GNU MP               *
+*************************************************/
+void* gmp_realloc(void* ptr, size_t old_n, size_t new_n)
+   {
+   void* new_buf = gmp_alloc->allocate(new_n);
+   std::memcpy(new_buf, ptr, std::min(old_n, new_n));
+   gmp_alloc->deallocate(ptr, old_n);
+   return new_buf;
+   }
+
+/*************************************************
+* Deallocation Function for GNU MP               *
+*************************************************/
+void gmp_free(void* ptr, size_t n)
+   {
+   gmp_alloc->deallocate(ptr, n);
+   }
+
+}
+
+/*************************************************
+* Set the GNU MP memory functions                *
+*************************************************/
+void GMP_Engine::set_memory_hooks()
+   {
+   if(gmp_alloc == 0)
+      {
+      gmp_alloc = get_allocator();
+      mp_set_memory_functions(gmp_malloc, gmp_realloc, gmp_free);
+      }
+   }
+
+}
diff --git a/modules/eng_gmp/gmp_powm.cpp b/modules/eng_gmp/gmp_powm.cpp
new file mode 100644
index 000000000..c966a7b1c
--- /dev/null
+++ b/modules/eng_gmp/gmp_powm.cpp
@@ -0,0 +1,51 @@
+/*************************************************
+* GMP Modular Exponentiation Source File         *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/eng_gmp.h>
+#include <botan/gmp_wrap.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* GMP Modular Exponentiator                      *
+*************************************************/
+class GMP_Modular_Exponentiator : public Modular_Exponentiator
+   {
+   public:
+      void set_base(const BigInt& b) { base = b; }
+      void set_exponent(const BigInt& e) { exp = e; }
+      BigInt execute() const;
+      Modular_Exponentiator* copy() const
+         { return new GMP_Modular_Exponentiator(*this); }
+
+      GMP_Modular_Exponentiator(const BigInt& n) : mod(n) {}
+   private:
+      GMP_MPZ base, exp, mod;
+   };
+
+/*************************************************
+* Compute the result                             *
+*************************************************/
+BigInt GMP_Modular_Exponentiator::execute() const
+   {
+   GMP_MPZ r;
+   mpz_powm(r.value, base.value, exp.value, mod.value);
+   return r.to_bigint();
+   }
+
+}
+
+/*************************************************
+* Return the GMP-based modular exponentiator     *
+*************************************************/
+Modular_Exponentiator* GMP_Engine::mod_exp(const BigInt& n,
+                                           Power_Mod::Usage_Hints) const
+   {
+   return new GMP_Modular_Exponentiator(n);
+   }
+
+}
diff --git a/modules/eng_gmp/gmp_wrap.cpp b/modules/eng_gmp/gmp_wrap.cpp
new file mode 100644
index 000000000..b6b80560e
--- /dev/null
+++ b/modules/eng_gmp/gmp_wrap.cpp
@@ -0,0 +1,96 @@
+/*************************************************
+* GMP Wrapper Source File                        *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/gmp_wrap.h>
+
+#define GNU_MP_VERSION_CODE_FOR(a,b,c) ((a << 16) | (b << 8) | (c))
+
+#define GNU_MP_VERSION_CODE \
+   GNU_MP_VERSION_CODE_FOR(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, \
+                           __GNU_MP_VERSION_PATCHLEVEL)
+
+#if GNU_MP_VERSION_CODE < GNU_MP_VERSION_CODE_FOR(4,1,0)
+  #error Your GNU MP install is too old, upgrade to 4.1 or later
+#endif
+
+namespace Botan {
+
+/*************************************************
+* GMP_MPZ Constructor                            *
+*************************************************/
+GMP_MPZ::GMP_MPZ(const BigInt& in)
+   {
+   mpz_init(value);
+   if(in != 0)
+      mpz_import(value, in.sig_words(), -1, sizeof(word), 0, 0, in.data());
+   }
+
+/*************************************************
+* GMP_MPZ Constructor                            *
+*************************************************/
+GMP_MPZ::GMP_MPZ(const byte in[], u32bit length)
+   {
+   mpz_init(value);
+   mpz_import(value, length, 1, 1, 0, 0, in);
+   }
+
+/*************************************************
+* GMP_MPZ Copy Constructor                       *
+*************************************************/
+GMP_MPZ::GMP_MPZ(const GMP_MPZ& other)
+   {
+   mpz_init_set(value, other.value);
+   }
+
+/*************************************************
+* GMP_MPZ Destructor                             *
+*************************************************/
+GMP_MPZ::~GMP_MPZ()
+   {
+   mpz_clear(value);
+   }
+
+/*************************************************
+* GMP_MPZ Assignment Operator                    *
+*************************************************/
+GMP_MPZ& GMP_MPZ::operator=(const GMP_MPZ& other)
+   {
+   mpz_set(value, other.value);
+   return (*this);
+   }
+
+/*************************************************
+* Export the mpz_t as a bytestring               *
+*************************************************/
+void GMP_MPZ::encode(byte out[], u32bit length) const
+   {
+   size_t dummy = 0;
+   mpz_export(out + (length - bytes()), &dummy, 1, 1, 0, 0, value);
+   }
+
+/*************************************************
+* Return the number of significant bytes         *
+*************************************************/
+u32bit GMP_MPZ::bytes() const
+   {
+   return ((mpz_sizeinbase(value, 2) + 7) / 8);
+   }
+
+/*************************************************
+* GMP to BigInt Conversions                      *
+*************************************************/
+BigInt GMP_MPZ::to_bigint() const
+   {
+   BigInt out(BigInt::Positive, (bytes() + sizeof(word) - 1) / sizeof(word));
+   size_t dummy = 0;
+   mpz_export(out.get_reg(), &dummy, -1, sizeof(word), 0, 0, value);
+
+   if(mpz_sgn(value) < 0)
+      out.flip_sign();
+
+   return out;
+   }
+
+}
diff --git a/modules/eng_gmp/gmp_wrap.h b/modules/eng_gmp/gmp_wrap.h
new file mode 100644
index 000000000..34038d5f9
--- /dev/null
+++ b/modules/eng_gmp/gmp_wrap.h
@@ -0,0 +1,36 @@
+/*************************************************
+* GMP MPZ Wrapper Header File                    *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_GMP_MPZ_WRAP_H__
+#define BOTAN_EXT_GMP_MPZ_WRAP_H__
+
+#include <botan/bigint.h>
+#include <gmp.h>
+
+namespace Botan {
+
+/*************************************************
+* Lightweight GMP mpz_t Wrapper                  *
+*************************************************/
+class GMP_MPZ
+   {
+   public:
+      mpz_t value;
+
+      BigInt to_bigint() const;
+      void encode(byte[], u32bit) const;
+      u32bit bytes() const;
+
+      GMP_MPZ& operator=(const GMP_MPZ&);
+
+      GMP_MPZ(const GMP_MPZ&);
+      GMP_MPZ(const BigInt& = 0);
+      GMP_MPZ(const byte[], u32bit);
+      ~GMP_MPZ();
+   };
+
+}
+
+#endif
diff --git a/modules/eng_gmp/modinfo.txt b/modules/eng_gmp/modinfo.txt
new file mode 100644
index 000000000..0e7d5465d
--- /dev/null
+++ b/modules/eng_gmp/modinfo.txt
@@ -0,0 +1,19 @@
+realname "GMP Engine"
+
+uses_external_libs
+
+add_file eng_gmp.cpp
+add_file gmp_wrap.cpp
+add_file gmp_mem.cpp
+add_file gmp_powm.cpp
+
+add_file eng_gmp.h
+add_file gmp_wrap.h
+
+local_only gmp_wrap.h
+
+define ENGINE_GNU_MP
+
+<libs>
+all -> gmp
+</libs>
diff --git a/modules/eng_ossl/bn_powm.cpp b/modules/eng_ossl/bn_powm.cpp
new file mode 100644
index 000000000..524379b72
--- /dev/null
+++ b/modules/eng_ossl/bn_powm.cpp
@@ -0,0 +1,52 @@
+/*************************************************
+* OpenSSL Modular Exponentiation Source File     *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/eng_ossl.h>
+#include <botan/bn_wrap.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* OpenSSL Modular Exponentiator                  *
+*************************************************/
+class OpenSSL_Modular_Exponentiator : public Modular_Exponentiator
+   {
+   public:
+      void set_base(const BigInt& b) { base = b; }
+      void set_exponent(const BigInt& e) { exp = e; }
+      BigInt execute() const;
+      Modular_Exponentiator* copy() const
+         { return new OpenSSL_Modular_Exponentiator(*this); }
+
+      OpenSSL_Modular_Exponentiator(const BigInt& n) : mod(n) {}
+   private:
+      OSSL_BN base, exp, mod;
+      OSSL_BN_CTX ctx;
+   };
+
+/*************************************************
+* Compute the result                             *
+*************************************************/
+BigInt OpenSSL_Modular_Exponentiator::execute() const
+   {
+   OSSL_BN r;
+   BN_mod_exp(r.value, base.value, exp.value, mod.value, ctx.value);
+   return r.to_bigint();
+   }
+
+}
+
+/*************************************************
+* Return the OpenSSL-based modular exponentiator *
+*************************************************/
+Modular_Exponentiator* OpenSSL_Engine::mod_exp(const BigInt& n,
+                                           Power_Mod::Usage_Hints) const
+   {
+   return new OpenSSL_Modular_Exponentiator(n);
+   }
+
+}
diff --git a/modules/eng_ossl/bn_wrap.cpp b/modules/eng_ossl/bn_wrap.cpp
new file mode 100644
index 000000000..50c097724
--- /dev/null
+++ b/modules/eng_ossl/bn_wrap.cpp
@@ -0,0 +1,114 @@
+/*************************************************
+* OpenSSL BN Wrapper Source File                 *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/bn_wrap.h>
+
+namespace Botan {
+
+/*************************************************
+* OSSL_BN Constructor                            *
+*************************************************/
+OSSL_BN::OSSL_BN(const BigInt& in)
+   {
+   value = BN_new();
+   SecureVector<byte> encoding = BigInt::encode(in);
+   if(in != 0)
+      BN_bin2bn(encoding, encoding.size(), value);
+   }
+
+/*************************************************
+* OSSL_BN Constructor                            *
+*************************************************/
+OSSL_BN::OSSL_BN(const byte in[], u32bit length)
+   {
+   value = BN_new();
+   BN_bin2bn(in, length, value);
+   }
+
+/*************************************************
+* OSSL_BN Copy Constructor                       *
+*************************************************/
+OSSL_BN::OSSL_BN(const OSSL_BN& other)
+   {
+   value = BN_dup(other.value);
+   }
+
+/*************************************************
+* OSSL_BN Destructor                             *
+*************************************************/
+OSSL_BN::~OSSL_BN()
+   {
+   BN_clear_free(value);
+   }
+
+/*************************************************
+* OSSL_BN Assignment Operator                    *
+*************************************************/
+OSSL_BN& OSSL_BN::operator=(const OSSL_BN& other)
+   {
+   BN_copy(value, other.value);
+   return (*this);
+   }
+
+/*************************************************
+* Export the BIGNUM as a bytestring              *
+*************************************************/
+void OSSL_BN::encode(byte out[], u32bit length) const
+   {
+   BN_bn2bin(value, out + (length - bytes()));
+   }
+
+/*************************************************
+* Return the number of significant bytes         *
+*************************************************/
+u32bit OSSL_BN::bytes() const
+   {
+   return BN_num_bytes(value);
+   }
+
+/*************************************************
+* OpenSSL to BigInt Conversions                  *
+*************************************************/
+BigInt OSSL_BN::to_bigint() const
+   {
+   SecureVector<byte> out(bytes());
+   BN_bn2bin(value, out);
+   return BigInt::decode(out);
+   }
+
+/*************************************************
+* OSSL_BN_CTX Constructor                        *
+*************************************************/
+OSSL_BN_CTX::OSSL_BN_CTX()
+   {
+   value = BN_CTX_new();
+   }
+
+/*************************************************
+* OSSL_BN_CTX Copy Constructor                   *
+*************************************************/
+OSSL_BN_CTX::OSSL_BN_CTX(const OSSL_BN_CTX&)
+   {
+   value = BN_CTX_new();
+   }
+
+/*************************************************
+* OSSL_BN_CTX Destructor                         *
+*************************************************/
+OSSL_BN_CTX::~OSSL_BN_CTX()
+   {
+   BN_CTX_free(value);
+   }
+
+/*************************************************
+* OSSL_BN_CTX Assignment Operator                *
+*************************************************/
+OSSL_BN_CTX& OSSL_BN_CTX::operator=(const OSSL_BN_CTX&)
+   {
+   value = BN_CTX_new();
+   return (*this);
+   }
+
+}
diff --git a/modules/eng_ossl/bn_wrap.h b/modules/eng_ossl/bn_wrap.h
new file mode 100644
index 000000000..2b90d643c
--- /dev/null
+++ b/modules/eng_ossl/bn_wrap.h
@@ -0,0 +1,51 @@
+/*************************************************
+* OpenSSL BN Wrapper Header File                 *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_OPENSSL_BN_WRAP_H__
+#define BOTAN_EXT_OPENSSL_BN_WRAP_H__
+
+#include <botan/bigint.h>
+#include <openssl/bn.h>
+
+namespace Botan {
+
+/*************************************************
+* Lightweight OpenSSL BN Wrapper                 *
+*************************************************/
+class OSSL_BN
+   {
+   public:
+      BIGNUM* value;
+
+      BigInt to_bigint() const;
+      void encode(byte[], u32bit) const;
+      u32bit bytes() const;
+
+      OSSL_BN& operator=(const OSSL_BN&);
+
+      OSSL_BN(const OSSL_BN&);
+      OSSL_BN(const BigInt& = 0);
+      OSSL_BN(const byte[], u32bit);
+      ~OSSL_BN();
+   };
+
+/*************************************************
+* Lightweight OpenSSL BN_CTX Wrapper             *
+*************************************************/
+class OSSL_BN_CTX
+   {
+   public:
+      BN_CTX* value;
+
+      OSSL_BN_CTX& operator=(const OSSL_BN_CTX&);
+
+      OSSL_BN_CTX();
+      OSSL_BN_CTX(const OSSL_BN_CTX&);
+      ~OSSL_BN_CTX();
+   };
+
+}
+
+#endif
diff --git a/modules/eng_ossl/eng_ossl.cpp b/modules/eng_ossl/eng_ossl.cpp
new file mode 100644
index 000000000..9c249876f
--- /dev/null
+++ b/modules/eng_ossl/eng_ossl.cpp
@@ -0,0 +1,374 @@
+/*************************************************
+* OpenSSL Engine Source File                     *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/eng_ossl.h>
+#include <botan/bn_wrap.h>
+#include <openssl/opensslv.h>
+
+#if OPENSSL_VERSION_NUMBER < 0x0090700F
+  #error Your OpenSSL install is too old, upgrade to 0.9.7 or later
+#endif
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* OpenSSL IF Operation                           *
+*************************************************/
+class OpenSSL_IF_Op : public IF_Operation
+   {
+   public:
+      BigInt public_op(const BigInt&) const;
+      BigInt private_op(const BigInt&) const;
+
+      IF_Operation* clone() const { return new OpenSSL_IF_Op(*this); }
+
+      OpenSSL_IF_Op(const BigInt& e_bn, const BigInt& n_bn, const BigInt&,
+                const BigInt& p_bn, const BigInt& q_bn, const BigInt& d1_bn,
+                const BigInt& d2_bn, const BigInt& c_bn) :
+         e(e_bn), n(n_bn), p(p_bn), q(q_bn), d1(d1_bn), d2(d2_bn), c(c_bn) {}
+   private:
+      const OSSL_BN e, n, p, q, d1, d2, c;
+      OSSL_BN_CTX ctx;
+   };
+
+/*************************************************
+* OpenSSL IF Public Operation                    *
+*************************************************/
+BigInt OpenSSL_IF_Op::public_op(const BigInt& i_bn) const
+   {
+   OSSL_BN i(i_bn), r;
+   BN_mod_exp(r.value, i.value, e.value, n.value, ctx.value);
+   return r.to_bigint();
+   }
+
+/*************************************************
+* OpenSSL IF Private Operation                   *
+*************************************************/
+BigInt OpenSSL_IF_Op::private_op(const BigInt& i_bn) const
+   {
+   if(BN_is_zero(p.value))
+      throw Internal_Error("OpenSSL_IF_Op::private_op: No private key");
+
+   OSSL_BN j1, j2, h(i_bn);
+
+   BN_mod_exp(j1.value, h.value, d1.value, p.value, ctx.value);
+   BN_mod_exp(j2.value, h.value, d2.value, q.value, ctx.value);
+   BN_sub(h.value, j1.value, j2.value);
+   BN_mod_mul(h.value, h.value, c.value, p.value, ctx.value);
+   BN_mul(h.value, h.value, q.value, ctx.value);
+   BN_add(h.value, h.value, j2.value);
+   return h.to_bigint();
+   }
+
+/*************************************************
+* OpenSSL DSA Operation                          *
+*************************************************/
+class OpenSSL_DSA_Op : public DSA_Operation
+   {
+   public:
+      bool verify(const byte[], u32bit, const byte[], u32bit) const;
+      SecureVector<byte> sign(const byte[], u32bit, const BigInt&) const;
+
+      DSA_Operation* clone() const { return new OpenSSL_DSA_Op(*this); }
+
+      OpenSSL_DSA_Op(const DL_Group& group, const BigInt& y1,
+                     const BigInt& x1) :
+         x(x1), y(y1), p(group.get_p()), q(group.get_q()), g(group.get_g()) {}
+   private:
+      const OSSL_BN x, y, p, q, g;
+      OSSL_BN_CTX ctx;
+   };
+
+/*************************************************
+* OpenSSL DSA Verify Operation                   *
+*************************************************/
+bool OpenSSL_DSA_Op::verify(const byte msg[], u32bit msg_len,
+                            const byte sig[], u32bit sig_len) const
+   {
+   const u32bit q_bytes = q.bytes();
+
+   if(sig_len != 2*q_bytes || msg_len > q_bytes)
+      return false;
+
+   OSSL_BN r(sig, q_bytes);
+   OSSL_BN s(sig + q_bytes, q_bytes);
+   OSSL_BN i(msg, msg_len);
+
+   if(BN_is_zero(r.value) || BN_cmp(r.value, q.value) >= 0)
+      return false;
+   if(BN_is_zero(s.value) || BN_cmp(s.value, q.value) >= 0)
+      return false;
+
+   if(BN_mod_inverse(s.value, s.value, q.value, ctx.value) == 0)
+      return false;
+
+   OSSL_BN si;
+   BN_mod_mul(si.value, s.value, i.value, q.value, ctx.value);
+   BN_mod_exp(si.value, g.value, si.value, p.value, ctx.value);
+
+   OSSL_BN sr;
+   BN_mod_mul(sr.value, s.value, r.value, q.value, ctx.value);
+   BN_mod_exp(sr.value, y.value, sr.value, p.value, ctx.value);
+
+   BN_mod_mul(si.value, si.value, sr.value, p.value, ctx.value);
+   BN_nnmod(si.value, si.value, q.value, ctx.value);
+
+   if(BN_cmp(si.value, r.value) == 0)
+      return true;
+   return false;
+   }
+
+/*************************************************
+* OpenSSL DSA Sign Operation                     *
+*************************************************/
+SecureVector<byte> OpenSSL_DSA_Op::sign(const byte in[], u32bit length,
+                                        const BigInt& k_bn) const
+   {
+   if(BN_is_zero(x.value))
+      throw Internal_Error("OpenSSL_DSA_Op::sign: No private key");
+
+   OSSL_BN i(in, length);
+   OSSL_BN k(k_bn);
+
+   OSSL_BN r;
+   BN_mod_exp(r.value, g.value, k.value, p.value, ctx.value);
+   BN_nnmod(r.value, r.value, q.value, ctx.value);
+
+   BN_mod_inverse(k.value, k.value, q.value, ctx.value);
+
+   OSSL_BN s;
+   BN_mul(s.value, x.value, r.value, ctx.value);
+   BN_add(s.value, s.value, i.value);
+   BN_mod_mul(s.value, s.value, k.value, q.value, ctx.value);
+
+   if(BN_is_zero(r.value) || BN_is_zero(s.value))
+      throw Internal_Error("OpenSSL_DSA_Op::sign: r or s was zero");
+
+   const u32bit q_bytes = q.bytes();
+
+   SecureVector<byte> output(2*q_bytes);
+   r.encode(output, q_bytes);
+   s.encode(output + q_bytes, q_bytes);
+   return output;
+   }
+
+/*************************************************
+* OpenSSL NR Operation                           *
+*************************************************/
+class OpenSSL_NR_Op : public NR_Operation
+   {
+   public:
+      SecureVector<byte> verify(const byte[], u32bit) const;
+      SecureVector<byte> sign(const byte[], u32bit, const BigInt&) const;
+
+      NR_Operation* clone() const { return new OpenSSL_NR_Op(*this); }
+
+      OpenSSL_NR_Op(const DL_Group& group, const BigInt& y1,
+                    const BigInt& x1) :
+         x(x1), y(y1), p(group.get_p()), q(group.get_q()), g(group.get_g()) {}
+   private:
+      const OSSL_BN x, y, p, q, g;
+      OSSL_BN_CTX ctx;
+   };
+
+/*************************************************
+* OpenSSL NR Verify Operation                    *
+*************************************************/
+SecureVector<byte> OpenSSL_NR_Op::verify(const byte sig[],
+                                         u32bit sig_len) const
+   {
+   const u32bit q_bytes = q.bytes();
+
+   if(sig_len != 2*q_bytes)
+      return false;
+
+   OSSL_BN c(sig, q_bytes);
+   OSSL_BN d(sig + q_bytes, q_bytes);
+
+   if(BN_is_zero(c.value) || BN_cmp(c.value, q.value) >= 0 ||
+                             BN_cmp(d.value, q.value) >= 0)
+      throw Invalid_Argument("OpenSSL_NR_Op::verify: Invalid signature");
+
+   OSSL_BN i1, i2;
+   BN_mod_exp(i1.value, g.value, d.value, p.value, ctx.value);
+   BN_mod_exp(i2.value, y.value, c.value, p.value, ctx.value);
+   BN_mod_mul(i1.value, i1.value, i2.value, p.value, ctx.value);
+   BN_sub(i1.value, c.value, i1.value);
+   BN_nnmod(i1.value, i1.value, q.value, ctx.value);
+   return BigInt::encode(i1.to_bigint());
+   }
+
+/*************************************************
+* OpenSSL NR Sign Operation                      *
+*************************************************/
+SecureVector<byte> OpenSSL_NR_Op::sign(const byte in[], u32bit length,
+                                       const BigInt& k_bn) const
+   {
+   if(BN_is_zero(x.value))
+      throw Internal_Error("OpenSSL_NR_Op::sign: No private key");
+
+   OSSL_BN f(in, length);
+   OSSL_BN k(k_bn);
+
+   if(BN_cmp(f.value, q.value) >= 0)
+      throw Invalid_Argument("OpenSSL_NR_Op::sign: Input is out of range");
+
+   OSSL_BN c, d;
+   BN_mod_exp(c.value, g.value, k.value, p.value, ctx.value);
+   BN_add(c.value, c.value, f.value);
+   BN_nnmod(c.value, c.value, q.value, ctx.value);
+   BN_mul(d.value, x.value, c.value, ctx.value);
+   BN_sub(d.value, k.value, d.value);
+   BN_nnmod(d.value, d.value, q.value, ctx.value);
+
+   if(BN_is_zero(c.value))
+      throw Internal_Error("Default_NR_Op::sign: c was zero");
+
+   const u32bit q_bytes = q.bytes();
+   SecureVector<byte> output(2*q_bytes);
+   c.encode(output, q_bytes);
+   d.encode(output + q_bytes, q_bytes);
+   return output;
+   }
+
+/*************************************************
+* OpenSSL ElGamal Operation                      *
+*************************************************/
+class OpenSSL_ELG_Op : public ELG_Operation
+   {
+   public:
+      SecureVector<byte> encrypt(const byte[], u32bit, const BigInt&) const;
+      BigInt decrypt(const BigInt&, const BigInt&) const;
+
+      ELG_Operation* clone() const { return new OpenSSL_ELG_Op(*this); }
+      OpenSSL_ELG_Op(const DL_Group& group, const BigInt& y1,
+                     const BigInt& x1) :
+         x(x1), y(y1), g(group.get_g()), p(group.get_p()) {}
+   private:
+      OSSL_BN x, y, g, p;
+      OSSL_BN_CTX ctx;
+   };
+
+/*************************************************
+* OpenSSL ElGamal Encrypt Operation              *
+*************************************************/
+SecureVector<byte> OpenSSL_ELG_Op::encrypt(const byte in[], u32bit length,
+                                           const BigInt& k_bn) const
+   {
+   OSSL_BN i(in, length);
+
+   if(BN_cmp(i.value, p.value) >= 0)
+      throw Invalid_Argument("OpenSSL_ELG_Op: Input is too large");
+
+   OSSL_BN a, b, k(k_bn);
+
+   BN_mod_exp(a.value, g.value, k.value, p.value, ctx.value);
+   BN_mod_exp(b.value, y.value, k.value, p.value, ctx.value);
+   BN_mod_mul(b.value, b.value, i.value, p.value, ctx.value);
+
+   const u32bit p_bytes = p.bytes();
+   SecureVector<byte> output(2*p_bytes);
+   a.encode(output, p_bytes);
+   b.encode(output + p_bytes, p_bytes);
+   return output;
+   }
+
+/*************************************************
+* OpenSSL ElGamal Decrypt Operation              *
+*************************************************/
+BigInt OpenSSL_ELG_Op::decrypt(const BigInt& a_bn, const BigInt& b_bn) const
+   {
+   if(BN_is_zero(x.value))
+      throw Internal_Error("OpenSSL_ELG_Op::decrypt: No private key");
+
+   OSSL_BN a(a_bn), b(b_bn), t;
+
+   if(BN_cmp(a.value, p.value) >= 0 || BN_cmp(b.value, p.value) >= 0)
+      throw Invalid_Argument("OpenSSL_ELG_Op: Invalid message");
+
+   BN_mod_exp(t.value, a.value, x.value, p.value, ctx.value);
+   BN_mod_inverse(a.value, t.value, p.value, ctx.value);
+   BN_mod_mul(a.value, a.value, b.value, p.value, ctx.value);
+   return a.to_bigint();
+   }
+
+/*************************************************
+* OpenSSL DH Operation                           *
+*************************************************/
+class OpenSSL_DH_Op : public DH_Operation
+   {
+   public:
+      BigInt agree(const BigInt& i) const;
+      DH_Operation* clone() const { return new OpenSSL_DH_Op(*this); }
+
+      OpenSSL_DH_Op(const DL_Group& group, const BigInt& x_bn) :
+         x(x_bn), p(group.get_p()) {}
+   private:
+      OSSL_BN x, p;
+      OSSL_BN_CTX ctx;
+   };
+
+/*************************************************
+* OpenSSL DH Key Agreement Operation             *
+*************************************************/
+BigInt OpenSSL_DH_Op::agree(const BigInt& i_bn) const
+   {
+   OSSL_BN i(i_bn), r;
+   BN_mod_exp(r.value, i.value, x.value, p.value, ctx.value);
+   return r.to_bigint();
+   }
+
+}
+
+/*************************************************
+* Acquire an IF op                               *
+*************************************************/
+IF_Operation* OpenSSL_Engine::if_op(const BigInt& e, const BigInt& n,
+                                    const BigInt& d, const BigInt& p,
+                                    const BigInt& q, const BigInt& d1,
+                                    const BigInt& d2, const BigInt& c) const
+   {
+   return new OpenSSL_IF_Op(e, n, d, p, q, d1, d2, c);
+   }
+
+/*************************************************
+* Acquire a DSA op                               *
+*************************************************/
+DSA_Operation* OpenSSL_Engine::dsa_op(const DL_Group& group, const BigInt& y,
+                                      const BigInt& x) const
+   {
+   return new OpenSSL_DSA_Op(group, y, x);
+   }
+
+/*************************************************
+* Acquire a NR op                                *
+*************************************************/
+NR_Operation* OpenSSL_Engine::nr_op(const DL_Group& group, const BigInt& y,
+                                    const BigInt& x) const
+   {
+   return new OpenSSL_NR_Op(group, y, x);
+   }
+
+/*************************************************
+* Acquire an ElGamal op                          *
+*************************************************/
+ELG_Operation* OpenSSL_Engine::elg_op(const DL_Group& group, const BigInt& y,
+                                      const BigInt& x) const
+   {
+   return new OpenSSL_ELG_Op(group, y, x);
+   }
+
+/*************************************************
+* Acquire a DH op                                *
+*************************************************/
+DH_Operation* OpenSSL_Engine::dh_op(const DL_Group& group,
+                                    const BigInt& x) const
+   {
+   return new OpenSSL_DH_Op(group, x);
+   }
+
+}
diff --git a/modules/eng_ossl/eng_ossl.h b/modules/eng_ossl/eng_ossl.h
new file mode 100644
index 000000000..e72b3ca43
--- /dev/null
+++ b/modules/eng_ossl/eng_ossl.h
@@ -0,0 +1,40 @@
+/*************************************************
+* OpenSSL Engine Header File                     *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_ENGINE_OPENSSL_H__
+#define BOTAN_EXT_ENGINE_OPENSSL_H__
+
+#include <botan/engine.h>
+#include <botan/mutex.h>
+
+namespace Botan {
+
+/*************************************************
+* OpenSSL Engine                                 *
+*************************************************/
+class OpenSSL_Engine : public Engine
+   {
+   public:
+      IF_Operation* if_op(const BigInt&, const BigInt&, const BigInt&,
+                          const BigInt&, const BigInt&, const BigInt&,
+                          const BigInt&, const BigInt&) const;
+      DSA_Operation* dsa_op(const DL_Group&, const BigInt&,
+                            const BigInt&) const;
+      NR_Operation* nr_op(const DL_Group&, const BigInt&, const BigInt&) const;
+      ELG_Operation* elg_op(const DL_Group&, const BigInt&,
+                            const BigInt&) const;
+      DH_Operation* dh_op(const DL_Group&, const BigInt&) const;
+
+      Modular_Exponentiator* mod_exp(const BigInt&,
+                                     Power_Mod::Usage_Hints) const;
+   private:
+      BlockCipher* find_block_cipher(const std::string&) const;
+      StreamCipher* find_stream_cipher(const std::string&) const;
+      HashFunction* find_hash(const std::string&) const;
+   };
+
+}
+
+#endif
diff --git a/modules/eng_ossl/modinfo.txt b/modules/eng_ossl/modinfo.txt
new file mode 100644
index 000000000..8d32bf247
--- /dev/null
+++ b/modules/eng_ossl/modinfo.txt
@@ -0,0 +1,21 @@
+realname "OpenSSL Engine"
+
+uses_external_libs
+
+add_file eng_ossl.cpp
+add_file bn_wrap.cpp
+add_file bn_powm.cpp
+add_file ossl_bc.cpp
+add_file ossl_rc4.cpp
+add_file ossl_md.cpp
+
+add_file eng_ossl.h
+add_file bn_wrap.h
+
+local_only bn_wrap.h
+
+define ENGINE_OPENSSL
+
+<libs>
+all -> crypto
+</libs>
diff --git a/modules/eng_ossl/ossl_bc.cpp b/modules/eng_ossl/ossl_bc.cpp
new file mode 100644
index 000000000..73b5f564a
--- /dev/null
+++ b/modules/eng_ossl/ossl_bc.cpp
@@ -0,0 +1,204 @@
+/*************************************************
+* OpenSSL Block Cipher Source File               *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/eng_ossl.h>
+#include <botan/parsing.h>
+#include <botan/lookup.h>
+#include <openssl/evp.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* EVP Block Cipher                               *
+*************************************************/
+class EVP_BlockCipher : public BlockCipher
+   {
+   public:
+      void clear() throw();
+      std::string name() const { return cipher_name; }
+      BlockCipher* clone() const;
+      EVP_BlockCipher(const EVP_CIPHER*, const std::string&);
+      EVP_BlockCipher(const EVP_CIPHER*, const std::string&,
+                      u32bit, u32bit, u32bit);
+
+      ~EVP_BlockCipher();
+   private:
+      void enc(const byte[], byte[]) const;
+      void dec(const byte[], byte[]) const;
+      void key(const byte[], u32bit);
+      std::string cipher_name;
+      mutable EVP_CIPHER_CTX encrypt, decrypt;
+   };
+
+/*************************************************
+* EVP Block Cipher Constructor                   *
+*************************************************/
+EVP_BlockCipher::EVP_BlockCipher(const EVP_CIPHER* algo,
+                                 const std::string& algo_name) :
+   BlockCipher(EVP_CIPHER_block_size(algo), EVP_CIPHER_key_length(algo)),
+   cipher_name(algo_name)
+   {
+   if(EVP_CIPHER_mode(algo) != EVP_CIPH_ECB_MODE)
+      throw Invalid_Argument("EVP_BlockCipher: Non-ECB EVP was passed in");
+
+   EVP_CIPHER_CTX_init(&encrypt);
+   EVP_CIPHER_CTX_init(&decrypt);
+
+   EVP_EncryptInit_ex(&encrypt, algo, 0, 0, 0);
+   EVP_DecryptInit_ex(&decrypt, algo, 0, 0, 0);
+
+   EVP_CIPHER_CTX_set_padding(&encrypt, 0);
+   EVP_CIPHER_CTX_set_padding(&decrypt, 0);
+   }
+
+/*************************************************
+* EVP Block Cipher Constructor                   *
+*************************************************/
+EVP_BlockCipher::EVP_BlockCipher(const EVP_CIPHER* algo,
+                                 const std::string& algo_name,
+                                 u32bit key_min, u32bit key_max,
+                                 u32bit key_mod) :
+   BlockCipher(EVP_CIPHER_block_size(algo), key_min, key_max, key_mod),
+   cipher_name(algo_name)
+   {
+   if(EVP_CIPHER_mode(algo) != EVP_CIPH_ECB_MODE)
+      throw Invalid_Argument("EVP_BlockCipher: Non-ECB EVP was passed in");
+
+   EVP_CIPHER_CTX_init(&encrypt);
+   EVP_CIPHER_CTX_init(&decrypt);
+
+   EVP_EncryptInit_ex(&encrypt, algo, 0, 0, 0);
+   EVP_DecryptInit_ex(&decrypt, algo, 0, 0, 0);
+
+   EVP_CIPHER_CTX_set_padding(&encrypt, 0);
+   EVP_CIPHER_CTX_set_padding(&decrypt, 0);
+   }
+
+/*************************************************
+* EVP Block Cipher Destructor                    *
+*************************************************/
+EVP_BlockCipher::~EVP_BlockCipher()
+   {
+   EVP_CIPHER_CTX_cleanup(&encrypt);
+   EVP_CIPHER_CTX_cleanup(&decrypt);
+   }
+
+/*************************************************
+* Encrypt a block                                *
+*************************************************/
+void EVP_BlockCipher::enc(const byte in[], byte out[]) const
+   {
+   int out_len = 0;
+   EVP_EncryptUpdate(&encrypt, out, &out_len, in, BLOCK_SIZE);
+   }
+
+/*************************************************
+* Decrypt a block                                *
+*************************************************/
+void EVP_BlockCipher::dec(const byte in[], byte out[]) const
+   {
+   int out_len = 0;
+   EVP_DecryptUpdate(&decrypt, out, &out_len, in, BLOCK_SIZE);
+   }
+
+/*************************************************
+* Set the key                                    *
+*************************************************/
+void EVP_BlockCipher::key(const byte key[], u32bit length)
+   {
+   SecureVector<byte> full_key(key, length);
+
+   if(cipher_name == "TripleDES" && length == 16)
+      full_key.append(key, 8);
+   else
+      if(EVP_CIPHER_CTX_set_key_length(&encrypt, length) == 0 ||
+         EVP_CIPHER_CTX_set_key_length(&decrypt, length) == 0)
+         throw Invalid_Argument("EVP_BlockCipher: Bad key length for " +
+                                cipher_name);
+
+   if(cipher_name == "RC2")
+      {
+      EVP_CIPHER_CTX_ctrl(&encrypt, EVP_CTRL_SET_RC2_KEY_BITS, length*8, 0);
+      EVP_CIPHER_CTX_ctrl(&decrypt, EVP_CTRL_SET_RC2_KEY_BITS, length*8, 0);
+      }
+
+   EVP_EncryptInit_ex(&encrypt, 0, 0, full_key.begin(), 0);
+   EVP_DecryptInit_ex(&decrypt, 0, 0, full_key.begin(), 0);
+   }
+
+/*************************************************
+* Return a clone of this object                  *
+*************************************************/
+BlockCipher* EVP_BlockCipher::clone() const
+   {
+   return new EVP_BlockCipher(EVP_CIPHER_CTX_cipher(&encrypt),
+                              cipher_name, MINIMUM_KEYLENGTH,
+                              MAXIMUM_KEYLENGTH, KEYLENGTH_MULTIPLE);
+   }
+
+/*************************************************
+* Clear memory of sensitive data                 *
+*************************************************/
+void EVP_BlockCipher::clear() throw()
+   {
+   const EVP_CIPHER* algo = EVP_CIPHER_CTX_cipher(&encrypt);
+
+   EVP_CIPHER_CTX_cleanup(&encrypt);
+   EVP_CIPHER_CTX_cleanup(&decrypt);
+   EVP_CIPHER_CTX_init(&encrypt);
+   EVP_CIPHER_CTX_init(&decrypt);
+   EVP_EncryptInit_ex(&encrypt, algo, 0, 0, 0);
+   EVP_DecryptInit_ex(&decrypt, algo, 0, 0, 0);
+   EVP_CIPHER_CTX_set_padding(&encrypt, 0);
+   EVP_CIPHER_CTX_set_padding(&decrypt, 0);
+   }
+
+}
+
+/*************************************************
+* Look for an algorithm with this name           *
+*************************************************/
+BlockCipher*
+OpenSSL_Engine::find_block_cipher(const std::string& algo_spec) const
+   {
+#define HANDLE_EVP_CIPHER(NAME, EVP)            \
+   if(algo_name == NAME)                        \
+      {                                         \
+      if(name.size() == 1)                      \
+         return new EVP_BlockCipher(EVP, NAME); \
+      throw Invalid_Algorithm_Name(algo_spec);  \
+      }
+
+#define HANDLE_EVP_CIPHER_KEYLEN(NAME, EVP, MIN, MAX, MOD)     \
+   if(algo_name == NAME)                                       \
+      {                                                        \
+      if(name.size() == 1)                                     \
+         return new EVP_BlockCipher(EVP, NAME, MIN, MAX, MOD); \
+      throw Invalid_Algorithm_Name(algo_spec);                 \
+      }
+
+   std::vector<std::string> name = parse_algorithm_name(algo_spec);
+   if(name.size() == 0)
+      return 0;
+   const std::string algo_name = deref_alias(name[0]);
+
+   HANDLE_EVP_CIPHER_KEYLEN("Blowfish", EVP_bf_ecb(), 1, 56, 1);
+   HANDLE_EVP_CIPHER_KEYLEN("CAST-128", EVP_cast5_ecb(), 1, 16, 1);
+   HANDLE_EVP_CIPHER_KEYLEN("RC2", EVP_rc2_ecb(), 1, 32, 1);
+   HANDLE_EVP_CIPHER_KEYLEN("TripleDES", EVP_des_ede3_ecb(), 16, 24, 8);
+   HANDLE_EVP_CIPHER("DES", EVP_des_ecb());
+   HANDLE_EVP_CIPHER("AES-128", EVP_aes_128_ecb());
+   HANDLE_EVP_CIPHER("AES-192", EVP_aes_192_ecb());
+   HANDLE_EVP_CIPHER("AES-256", EVP_aes_256_ecb());
+
+#undef HANDLE_EVP_CIPHER
+#undef HANDLE_EVP_CIPHER_KEYLEN
+
+   return 0;
+   }
+
+}
diff --git a/modules/eng_ossl/ossl_md.cpp b/modules/eng_ossl/ossl_md.cpp
new file mode 100644
index 000000000..173c4efbe
--- /dev/null
+++ b/modules/eng_ossl/ossl_md.cpp
@@ -0,0 +1,121 @@
+/*************************************************
+* OpenSSL Hash Functions Source File             *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/eng_ossl.h>
+#include <botan/parsing.h>
+#include <botan/lookup.h>
+#include <openssl/evp.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* EVP Hash Function                              *
+*************************************************/
+class EVP_HashFunction : public HashFunction
+   {
+   public:
+      void clear() throw();
+      std::string name() const { return algo_name; }
+      HashFunction* clone() const;
+      EVP_HashFunction(const EVP_MD*, const std::string&);
+      ~EVP_HashFunction();
+   private:
+      void add_data(const byte[], u32bit);
+      void final_result(byte[]);
+
+      std::string algo_name;
+      EVP_MD_CTX md;
+   };
+
+/*************************************************
+* Update an EVP Hash Calculation                 *
+*************************************************/
+void EVP_HashFunction::add_data(const byte input[], u32bit length)
+   {
+   EVP_DigestUpdate(&md, input, length);
+   }
+
+/*************************************************
+* Finalize an EVP Hash Calculation               *
+*************************************************/
+void EVP_HashFunction::final_result(byte output[])
+   {
+   EVP_DigestFinal_ex(&md, output, 0);
+   const EVP_MD* algo = EVP_MD_CTX_md(&md);
+   EVP_DigestInit_ex(&md, algo, 0);
+   }
+
+/*************************************************
+* Clear memory of sensitive data                 *
+*************************************************/
+void EVP_HashFunction::clear() throw()
+   {
+   const EVP_MD* algo = EVP_MD_CTX_md(&md);
+   EVP_DigestInit_ex(&md, algo, 0);
+   }
+
+/*************************************************
+* Return a clone of this object                  *
+*************************************************/
+HashFunction* EVP_HashFunction::clone() const
+   {
+   const EVP_MD* algo = EVP_MD_CTX_md(&md);
+   return new EVP_HashFunction(algo, name());
+   }
+
+/*************************************************
+* Create an EVP hash function                    *
+*************************************************/
+EVP_HashFunction::EVP_HashFunction(const EVP_MD* algo,
+                                   const std::string& name) :
+   HashFunction(EVP_MD_size(algo), EVP_MD_block_size(algo)),
+   algo_name(name)
+   {
+   EVP_MD_CTX_init(&md);
+   EVP_DigestInit_ex(&md, algo, 0);
+   }
+
+/*************************************************
+* Destroy an EVP hash function                   *
+*************************************************/
+EVP_HashFunction::~EVP_HashFunction()
+   {
+   EVP_MD_CTX_cleanup(&md);
+   }
+
+}
+
+/*************************************************
+* Look for an algorithm with this name           *
+*************************************************/
+HashFunction* OpenSSL_Engine::find_hash(const std::string& algo_spec) const
+   {
+   std::vector<std::string> name = parse_algorithm_name(algo_spec);
+   if(name.size() == 0)
+      return 0;
+   const std::string algo_name = deref_alias(name[0]);
+
+#define HANDLE_EVP_MD(NAME, EVP)                 \
+   if(algo_name == NAME)                         \
+      {                                          \
+      if(name.size() == 1)                       \
+         return new EVP_HashFunction(EVP, NAME); \
+      throw Invalid_Algorithm_Name(algo_spec);   \
+      }
+
+   HANDLE_EVP_MD("SHA-160", EVP_sha1());
+   HANDLE_EVP_MD("MD2", EVP_md2());
+   HANDLE_EVP_MD("MD4", EVP_md4());
+   HANDLE_EVP_MD("MD5", EVP_md5());
+   HANDLE_EVP_MD("RIPEMD-160", EVP_ripemd160());
+
+#undef HANDLE_EVP_MD
+
+   return 0;
+   }
+
+}
diff --git a/modules/eng_ossl/ossl_rc4.cpp b/modules/eng_ossl/ossl_rc4.cpp
new file mode 100644
index 000000000..3c8f96f72
--- /dev/null
+++ b/modules/eng_ossl/ossl_rc4.cpp
@@ -0,0 +1,92 @@
+/*************************************************
+* OpenSSL ARC4 Source File                       *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/eng_ossl.h>
+#include <botan/lookup.h>
+#include <botan/parsing.h>
+#include <openssl/rc4.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* OpenSSL ARC4                                   *
+*************************************************/
+class OpenSSL_ARC4 : public StreamCipher
+   {
+   public:
+      void clear() throw() { std::memset(&state, 0, sizeof(state)); }
+      std::string name() const;
+      StreamCipher* clone() const { return new OpenSSL_ARC4(SKIP); }
+      OpenSSL_ARC4(u32bit s = 0) : StreamCipher(1, 32), SKIP(s) { clear(); }
+      ~OpenSSL_ARC4() { clear(); }
+   private:
+      void cipher(const byte[], byte[], u32bit);
+      void key(const byte[], u32bit);
+
+      const u32bit SKIP;
+      RC4_KEY state;
+   };
+
+/*************************************************
+* Return the name of this type                   *
+*************************************************/
+std::string OpenSSL_ARC4::name() const
+   {
+   if(SKIP == 0)   return "ARC4";
+   if(SKIP == 256) return "MARK-4";
+   else            return "RC4_skip(" + to_string(SKIP) + ")";
+   }
+
+/*************************************************
+* ARC4 Key Schedule                              *
+*************************************************/
+void OpenSSL_ARC4::key(const byte key[], u32bit length)
+   {
+   RC4_set_key(&state, length, key);
+   byte dummy = 0;
+   for(u32bit j = 0; j != SKIP; j++)
+      RC4(&state, 1, &dummy, &dummy);
+   }
+
+/*************************************************
+* ARC4 Encryption                                *
+*************************************************/
+void OpenSSL_ARC4::cipher(const byte in[], byte out[], u32bit length)
+   {
+   RC4(&state, length, in, out);
+   }
+
+}
+
+/*************************************************
+* Look for an algorithm with this name           *
+*************************************************/
+StreamCipher*
+OpenSSL_Engine::find_stream_cipher(const std::string& algo_spec) const
+   {
+   std::vector<std::string> name = parse_algorithm_name(algo_spec);
+   if(name.size() == 0)
+      return 0;
+   const std::string algo_name = deref_alias(name[0]);
+
+#define HANDLE_TYPE_ONE_U32BIT(NAME, TYPE, DEFAULT) \
+   if(algo_name == NAME)                            \
+      {                                             \
+      if(name.size() == 1)                          \
+         return new TYPE(DEFAULT);                  \
+      if(name.size() == 2)                          \
+         return new TYPE(to_u32bit(name[1]));       \
+      throw Invalid_Algorithm_Name(algo_spec);      \
+      }
+
+   HANDLE_TYPE_ONE_U32BIT("ARC4", OpenSSL_ARC4, 0);
+   HANDLE_TYPE_ONE_U32BIT("RC4_drop", OpenSSL_ARC4, 768);
+
+   return 0;
+   }
+
+}
diff --git a/modules/es_beos/es_beos.cpp b/modules/es_beos/es_beos.cpp
new file mode 100644
index 000000000..f1c575063
--- /dev/null
+++ b/modules/es_beos/es_beos.cpp
@@ -0,0 +1,65 @@
+/*************************************************
+* BeOS EntropySource Source File                 *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/es_beos.h>
+#include <kernel/OS.h>
+#include <kernel/image.h>
+#include <interface/InterfaceDefs.h>
+
+namespace Botan {
+
+/*************************************************
+* BeOS Fast Poll                                 *
+*************************************************/
+void BeOS_EntropySource::do_fast_poll()
+   {
+   system_info info_sys;
+   get_system_info(&info_sys);
+   add_bytes(&info_sys, sizeof(system_info));
+
+   key_info info_key;
+   get_key_info(&info_key);
+   add_bytes(&info_key, sizeof(key_info));
+
+   add_bytes(idle_time());
+   }
+
+/*************************************************
+* BeOS Slow Poll                                 *
+*************************************************/
+void BeOS_EntropySource::do_slow_poll()
+   {
+   team_info info_team;
+   int32 cookie_team = 0;
+
+   while(get_next_team_info(&cookie_team, &info_team) == B_OK)
+      {
+      add_bytes(&info_team, sizeof(team_info));
+
+      team_id id = info_team.team;
+      int32 cookie = 0;
+
+      thread_info info_thr;
+      while(get_next_thread_info(id, &cookie, &info_thr) == B_OK)
+         add_bytes(&info_thr, sizeof(thread_info));
+
+      cookie = 0;
+      image_info info_img;
+      while(get_next_image_info(id, &cookie, &info_img) == B_OK)
+         add_bytes(&info_img, sizeof(image_info));
+
+      cookie = 0;
+      sem_info info_sem;
+      while(get_next_sem_info(id, &cookie, &info_sem) == B_OK)
+         add_bytes(&info_sem, sizeof(sem_info));
+
+      cookie = 0;
+      area_info info_area;
+      while(get_next_area_info(id, &cookie, &info_area) == B_OK)
+         add_bytes(&info_area, sizeof(area_info));
+      }
+   }
+
+}
diff --git a/modules/es_beos/es_beos.h b/modules/es_beos/es_beos.h
new file mode 100644
index 000000000..591443256
--- /dev/null
+++ b/modules/es_beos/es_beos.h
@@ -0,0 +1,25 @@
+/*************************************************
+* BeOS EntropySource Header File                 *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_ENTROPY_SRC_BEOS_H__
+#define BOTAN_EXT_ENTROPY_SRC_BEOS_H__
+
+#include <botan/buf_es.h>
+
+namespace Botan {
+
+/*************************************************
+* BeOS Entropy Source                            *
+*************************************************/
+class BeOS_EntropySource : public Buffered_EntropySource
+   {
+   private:
+      void do_fast_poll();
+      void do_slow_poll();
+   };
+
+}
+
+#endif
diff --git a/modules/es_beos/modinfo.txt b/modules/es_beos/modinfo.txt
new file mode 100644
index 000000000..717978417
--- /dev/null
+++ b/modules/es_beos/modinfo.txt
@@ -0,0 +1,14 @@
+realname "BeOS Entropy Source"
+
+define ENTROPY_SRC_BEOS
+
+add_file es_beos.h
+add_file es_beos.cpp
+
+<os>
+beos
+</os>
+
+<libs>
+beos -> root,be
+</libs>
diff --git a/modules/es_capi/es_capi.cpp b/modules/es_capi/es_capi.cpp
new file mode 100644
index 000000000..95bc3d969
--- /dev/null
+++ b/modules/es_capi/es_capi.cpp
@@ -0,0 +1,109 @@
+/*************************************************
+* Win32 CryptoAPI EntropySource Source File      *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/es_capi.h>
+#include <botan/parsing.h>
+#include <botan/conf.h>
+#include <windows.h>
+#include <wincrypt.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* CSP Handle                                     *
+*************************************************/
+class CSP_Handle
+   {
+   public:
+      CSP_Handle(u64bit);
+      ~CSP_Handle();
+
+      void gen_random(byte[], u32bit) const;
+      bool is_valid() const { return valid; }
+
+      HCRYPTPROV get_handle() const { return handle; }
+   private:
+      HCRYPTPROV handle;
+      bool valid;
+   };
+
+/*************************************************
+* Call CryptGenRandom                            *
+*************************************************/
+void CSP_Handle::gen_random(byte out[], u32bit n) const
+   {
+   CryptGenRandom(handle, n, out);
+   }
+
+/*************************************************
+* Initialize a CSP Handle                        *
+*************************************************/
+CSP_Handle::CSP_Handle(u64bit capi_provider)
+   {
+   valid = false;
+   DWORD prov_type = (DWORD)capi_provider;
+
+   if(CryptAcquireContext(&handle, 0, 0, prov_type, CRYPT_VERIFYCONTEXT))
+      valid = true;
+   }
+
+/*************************************************
+* Destroy a CSP Handle                           *
+*************************************************/
+CSP_Handle::~CSP_Handle()
+   {
+   if(valid)
+      CryptReleaseContext(handle, 0);
+   }
+
+}
+
+/*************************************************
+* Gather Entropy from Win32 CAPI                 *
+*************************************************/
+u32bit Win32_CAPI_EntropySource::slow_poll(byte output[], u32bit length)
+   {
+   if(length > 64)
+      length = 64;
+
+   for(u32bit j = 0; j != prov_types.size(); j++)
+      {
+      CSP_Handle csp(prov_types[j]);
+      if(!csp.is_valid())
+         continue;
+
+      csp.gen_random(output, length);
+      break;
+      }
+   return length;
+   }
+
+/*************************************************
+* Gather Entropy from Win32 CAPI                 *
+*************************************************/
+Win32_CAPI_EntropySource::Win32_CAPI_EntropySource(const std::string& provs)
+   {
+   std::vector<std::string> capi_provs;
+
+   if(provs == "")
+      capi_provs = Config::get_list("rng/ms_capi_prov_type");
+   else
+      capi_provs = split_on(provs, ':');
+
+   for(u32bit j = 0; j != capi_provs.size(); j++)
+      {
+      if(capi_provs[j] == "RSA_FULL")  prov_types.push_back(PROV_RSA_FULL);
+      if(capi_provs[j] == "INTEL_SEC") prov_types.push_back(PROV_INTEL_SEC);
+      if(capi_provs[j] == "FORTEZZA")  prov_types.push_back(PROV_FORTEZZA);
+      if(capi_provs[j] == "RNG")       prov_types.push_back(PROV_RNG);
+      }
+
+   if(prov_types.size() == 0)
+      prov_types.push_back(PROV_RSA_FULL);
+   }
+
+}
diff --git a/modules/es_capi/es_capi.h b/modules/es_capi/es_capi.h
new file mode 100644
index 000000000..8025e9ce7
--- /dev/null
+++ b/modules/es_capi/es_capi.h
@@ -0,0 +1,28 @@
+/*************************************************
+* Win32 CAPI EntropySource Header File           *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_ENTROPY_SRC_WIN32_CAPI_H__
+#define BOTAN_EXT_ENTROPY_SRC_WIN32_CAPI_H__
+
+#include <botan/base.h>
+#include <vector>
+
+namespace Botan {
+
+/*************************************************
+* Win32 CAPI Entropy Source                      *
+*************************************************/
+class Win32_CAPI_EntropySource : public EntropySource
+   {
+   public:
+      u32bit slow_poll(byte[], u32bit);
+      Win32_CAPI_EntropySource(const std::string& = "");
+   private:
+      std::vector<u64bit> prov_types;
+   };
+
+}
+
+#endif
diff --git a/modules/es_capi/modinfo.txt b/modules/es_capi/modinfo.txt
new file mode 100644
index 000000000..a61e33834
--- /dev/null
+++ b/modules/es_capi/modinfo.txt
@@ -0,0 +1,17 @@
+realname "Win32 CryptoAPI Entropy Source"
+
+define ENTROPY_SRC_CAPI
+
+add_file es_capi.h
+add_file es_capi.cpp
+
+# We'll just assume CAPI is there; this is OK except for 3.x, early versions
+# of 95, and maybe NT 3.5
+<os>
+windows
+cygwin
+</os>
+
+<libs>
+windows -> advapi32
+</libs>
diff --git a/modules/es_egd/es_egd.cpp b/modules/es_egd/es_egd.cpp
new file mode 100644
index 000000000..cf46b15d2
--- /dev/null
+++ b/modules/es_egd/es_egd.cpp
@@ -0,0 +1,91 @@
+/*************************************************
+* EGD EntropySource Source File                  *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/es_egd.h>
+#include <botan/conf.h>
+#include <botan/bit_ops.h>
+#include <botan/parsing.h>
+#include <cstring>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#ifndef PF_LOCAL
+  #define PF_LOCAL PF_UNIX
+#endif
+
+namespace Botan {
+
+/*************************************************
+* EGD_EntropySource Constructor                  *
+*************************************************/
+EGD_EntropySource::EGD_EntropySource(const std::string& egd_paths)
+   {
+   std::vector<std::string> path_list = split_on(egd_paths, ':');
+   std::vector<std::string> defaults = Config::get_list("rng/egd_path");
+
+   for(u32bit j = 0; j != path_list.size(); j++)
+      paths.push_back(path_list[j]);
+   for(u32bit j = 0; j != defaults.size(); j++)
+      paths.push_back(defaults[j]);
+   }
+
+/*************************************************
+* Gather Entropy from EGD                        *
+*************************************************/
+u32bit EGD_EntropySource::do_poll(byte output[], u32bit length,
+                                  const std::string& path) const
+   {
+   if(length > 128)
+      length = 128;
+
+   sockaddr_un addr;
+   std::memset(&addr, 0, sizeof(addr));
+   addr.sun_family = PF_LOCAL;
+
+   if(sizeof(addr.sun_path) < path.length() + 1)
+      throw Exception("EGD_EntropySource: Socket path is too long");
+   std::strcpy(addr.sun_path, path.c_str());
+
+   int fd = socket(addr.sun_family, SOCK_STREAM, 0);
+   if(fd == -1) return 0;
+
+   int len = sizeof(addr.sun_family) + std::strlen(addr.sun_path) + 1;
+   if(connect(fd, (struct sockaddr*)&addr, len))
+      { close(fd); return 0; }
+
+   byte buffer[2];
+   buffer[0] = 1;
+   buffer[1] = (byte)length;
+
+   if(write(fd, buffer, 2) != 2) { close(fd); return 0; }
+   if(read(fd, buffer, 1) != 1)  { close(fd); return 0; }
+
+   ssize_t count = read(fd, output, buffer[0]);
+
+   if(count == -1) { close(fd); return 0; }
+
+   close(fd);
+
+   return count;
+   }
+
+/*************************************************
+* Gather Entropy from EGD                        *
+*************************************************/
+u32bit EGD_EntropySource::slow_poll(byte output[], u32bit length)
+   {
+   for(u32bit j = 0; j != paths.size(); j++)
+      {
+      u32bit got = do_poll(output, length, paths[j]);
+      if(got)
+         return got;
+      }
+   return 0;
+   }
+
+}
diff --git a/modules/es_egd/es_egd.h b/modules/es_egd/es_egd.h
new file mode 100644
index 000000000..3af50ef35
--- /dev/null
+++ b/modules/es_egd/es_egd.h
@@ -0,0 +1,30 @@
+/*************************************************
+* EGD EntropySource Header File                  *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_ENTROPY_SRC_EGD_H__
+#define BOTAN_EXT_ENTROPY_SRC_EGD_H__
+
+#include <botan/base.h>
+#include <string>
+#include <vector>
+
+namespace Botan {
+
+/*************************************************
+* EGD Entropy Source                             *
+*************************************************/
+class EGD_EntropySource : public EntropySource
+   {
+   public:
+      u32bit slow_poll(byte[], u32bit);
+      EGD_EntropySource(const std::string& = "");
+   private:
+      u32bit do_poll(byte[], u32bit, const std::string&) const;
+      std::vector<std::string> paths;
+   };
+
+}
+
+#endif
diff --git a/modules/es_egd/modinfo.txt b/modules/es_egd/modinfo.txt
new file mode 100644
index 000000000..7ba68274d
--- /dev/null
+++ b/modules/es_egd/modinfo.txt
@@ -0,0 +1,26 @@
+realname "EGD Entropy Source"
+
+define ENTROPY_SRC_EGD
+
+add_file es_egd.h
+add_file es_egd.cpp
+
+<libs>
+solaris -> socket
+qnx -> socket
+</libs>
+
+<os>
+aix
+cygwin
+darwin
+freebsd
+hpux
+irix
+linux
+netbsd
+openbsd
+qnx
+solaris
+tru64
+</os>
diff --git a/modules/es_ftw/es_ftw.cpp b/modules/es_ftw/es_ftw.cpp
new file mode 100644
index 000000000..08a03c0e4
--- /dev/null
+++ b/modules/es_ftw/es_ftw.cpp
@@ -0,0 +1,110 @@
+/*************************************************
+* FTW EntropySource Source File                  *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/es_ftw.h>
+#include <botan/util.h>
+#include <fstream>
+#include <cstring>
+#include <vector>
+
+#ifndef _POSIX_C_SOURCE
+  #define _POSIX_C_SOURCE 199309
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <fcntl.h>
+
+namespace Botan {
+
+/*************************************************
+* FTW_EntropySource Constructor                  *
+*************************************************/
+FTW_EntropySource::FTW_EntropySource(const std::string& p) : path(p)
+   {
+   }
+
+/*************************************************
+* FTW Fast Poll                                  *
+*************************************************/
+void FTW_EntropySource::do_fast_poll()
+   {
+   files_read = 0;
+   max_read = 32;
+   gather_from_dir(path);
+   }
+
+/*************************************************
+* FTW Slow Poll                                  *
+*************************************************/
+void FTW_EntropySource::do_slow_poll()
+   {
+   files_read = 0;
+   max_read = 256;
+   gather_from_dir(path);
+   }
+
+/*************************************************
+* Gather Entropy From Directory Tree             *
+*************************************************/
+void FTW_EntropySource::gather_from_dir(const std::string& dirname)
+   {
+   if(dirname == "" || files_read >= max_read)
+      return;
+
+   DIR* dir = opendir(dirname.c_str());
+   if(dir == 0)
+      return;
+
+   std::vector<std::string> subdirs;
+
+   dirent* entry = readdir(dir);
+   while(entry && (files_read < max_read))
+      {
+      if((std::strcmp(entry->d_name, ".") == 0) ||
+         (std::strcmp(entry->d_name, "..") == 0))
+         { entry = readdir(dir); continue; }
+
+      const std::string filename = dirname + '/' + entry->d_name;
+
+      struct stat stat_buf;
+      if(lstat(filename.c_str(), &stat_buf) == -1)
+         { entry = readdir(dir); continue; }
+
+      if(S_ISREG(stat_buf.st_mode))
+         gather_from_file(filename);
+      else if(S_ISDIR(stat_buf.st_mode))
+         subdirs.push_back(filename);
+      entry = readdir(dir);
+      }
+   closedir(dir);
+
+   for(u32bit j = 0; j != subdirs.size(); j++)
+      gather_from_dir(subdirs[j]);
+   }
+
+/*************************************************
+* Gather Entropy From A File                     *
+*************************************************/
+void FTW_EntropySource::gather_from_file(const std::string& filename)
+   {
+   int fd = ::open(filename.c_str(), O_RDONLY | O_NOCTTY);
+   if(fd == -1)
+      return;
+
+   SecureVector<byte> read_buf(1024);
+   ssize_t got = ::read(fd, (byte*)read_buf.begin(), read_buf.size());
+   close(fd);
+
+   if(got > 0)
+      {
+      add_bytes(read_buf, got);
+      files_read++;
+      }
+   }
+
+}
diff --git a/modules/es_ftw/es_ftw.h b/modules/es_ftw/es_ftw.h
new file mode 100644
index 000000000..7b450798b
--- /dev/null
+++ b/modules/es_ftw/es_ftw.h
@@ -0,0 +1,31 @@
+/*************************************************
+* File Tree Walking EntropySource Header File    *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_ENTROPY_SRC_FTW_H__
+#define BOTAN_EXT_ENTROPY_SRC_FTW_H__
+
+#include <botan/buf_es.h>
+
+namespace Botan {
+
+/*************************************************
+* File Tree Walking Entropy Source               *
+*************************************************/
+class FTW_EntropySource : public Buffered_EntropySource
+   {
+   public:
+      FTW_EntropySource(const std::string& = "/proc");
+   private:
+      void do_fast_poll();
+      void do_slow_poll();
+      void gather_from_dir(const std::string&);
+      void gather_from_file(const std::string&);
+      const std::string path;
+      u32bit files_read, max_read;
+   };
+
+}
+
+#endif
diff --git a/modules/es_ftw/modinfo.txt b/modules/es_ftw/modinfo.txt
new file mode 100644
index 000000000..d68ac7ac9
--- /dev/null
+++ b/modules/es_ftw/modinfo.txt
@@ -0,0 +1,24 @@
+realname "File Tree Walking Entropy Source"
+
+define ENTROPY_SRC_FTW
+
+add_file es_ftw.h
+add_file es_ftw.cpp
+
+<os>
+aix
+cygwin
+darwin
+freebsd
+hpux
+irix
+linux
+openbsd
+qnx
+solaris
+tru64
+
+# Doesn't build on 2.0.2/x86 due to libc/libstdc++ header issues; no
+# big deal since it has /dev/*random
+#netbsd
+</os>
diff --git a/modules/es_unix/es_unix.cpp b/modules/es_unix/es_unix.cpp
new file mode 100644
index 000000000..d1efd4fa9
--- /dev/null
+++ b/modules/es_unix/es_unix.cpp
@@ -0,0 +1,105 @@
+/*************************************************
+* Unix EntropySource Source File                 *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/es_unix.h>
+#include <botan/unix_cmd.h>
+#include <botan/parsing.h>
+#include <botan/conf.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* Sort ordering by priority                      *
+*************************************************/
+bool Unix_Program_Cmp(const Unix_Program& a, const Unix_Program& b)
+   { return (a.priority < b.priority); }
+
+}
+
+/*************************************************
+* Unix_EntropySource Constructor                 *
+*************************************************/
+Unix_EntropySource::Unix_EntropySource()
+   {
+   add_default_sources(sources);
+   }
+
+/*************************************************
+* Add sources to the list                        *
+*************************************************/
+void Unix_EntropySource::add_sources(const Unix_Program srcs[], u32bit count)
+   {
+   sources.insert(sources.end(), srcs, srcs + count);
+   std::sort(sources.begin(), sources.end(), Unix_Program_Cmp);
+   }
+
+/*************************************************
+* Unix Fast Poll                                 *
+*************************************************/
+void Unix_EntropySource::do_fast_poll()
+   {
+   gather(2*1024);
+   }
+
+/*************************************************
+* Unix Slow Poll                                 *
+*************************************************/
+void Unix_EntropySource::do_slow_poll()
+   {
+   gather(16*1024);
+   }
+
+/*************************************************
+* Gather Entropy From Several Unix_Programs      *
+*************************************************/
+void Unix_EntropySource::gather(u32bit target_amount)
+   {
+   const u32bit MINIMAL_WORKING = 32;
+
+   u32bit got = 0;
+   for(u32bit j = 0; j != sources.size(); j++)
+      {
+      add_timestamp();
+
+      got += gather_from(sources[j]);
+      sources[j].working = (got >= MINIMAL_WORKING) ? true : false;
+
+      if(got >= target_amount)
+         break;
+      }
+   }
+
+/*************************************************
+* Gather entropy from a Unix program             *
+*************************************************/
+u32bit Unix_EntropySource::gather_from(const Unix_Program& prog)
+   {
+   const std::string BASE_PATH = "/bin:/sbin:/usr/bin:/usr/sbin";
+   const std::string EXTRA_PATH = Config::get_string("rng/unix_path");
+
+   std::string PATH = BASE_PATH;
+   if(EXTRA_PATH != "")
+      PATH += ':' + EXTRA_PATH;
+
+   DataSource_Command pipe(prog.name_and_args, PATH);
+   if(pipe.end_of_data())
+      return 0;
+
+   u32bit got = 0;
+   SecureVector<byte> buffer(DEFAULT_BUFFERSIZE);
+
+   while(!pipe.end_of_data())
+      {
+      u32bit this_loop = pipe.read(buffer, buffer.size());
+      add_bytes(buffer, this_loop);
+      got += this_loop;
+      }
+
+   return got;
+   }
+
+}
diff --git a/modules/es_unix/es_unix.h b/modules/es_unix/es_unix.h
new file mode 100644
index 000000000..74f960eb8
--- /dev/null
+++ b/modules/es_unix/es_unix.h
@@ -0,0 +1,35 @@
+/*************************************************
+* Unix EntropySource Header File                 *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_ENTROPY_SRC_UNIX_H__
+#define BOTAN_EXT_ENTROPY_SRC_UNIX_H__
+
+#include <botan/buf_es.h>
+#include <botan/unix_cmd.h>
+#include <vector>
+
+namespace Botan {
+
+/*************************************************
+* Unix Entropy Source                            *
+*************************************************/
+class Unix_EntropySource : public Buffered_EntropySource
+   {
+   public:
+      void add_sources(const Unix_Program[], u32bit);
+      Unix_EntropySource();
+   private:
+      void do_fast_poll();
+      void do_slow_poll();
+      void gather(u32bit);
+      u32bit gather_from(const Unix_Program&);
+      static void add_default_sources(std::vector<Unix_Program>&);
+
+      std::vector<Unix_Program> sources;
+   };
+
+}
+
+#endif
diff --git a/modules/es_unix/modinfo.txt b/modules/es_unix/modinfo.txt
new file mode 100644
index 000000000..94d922c05
--- /dev/null
+++ b/modules/es_unix/modinfo.txt
@@ -0,0 +1,25 @@
+realname "Generic Unix Entropy Source"
+
+define ENTROPY_SRC_UNIX
+
+add_file es_unix.cpp
+add_file unix_src.cpp
+add_file unix_cmd.cpp
+
+add_file es_unix.h
+add_file unix_cmd.h
+
+<os>
+aix
+beos
+cygwin
+darwin
+freebsd
+hpux
+irix
+linux
+netbsd
+qnx
+solaris
+tru64
+</os>
diff --git a/modules/es_unix/unix_cmd.cpp b/modules/es_unix/unix_cmd.cpp
new file mode 100644
index 000000000..db79478df
--- /dev/null
+++ b/modules/es_unix/unix_cmd.cpp
@@ -0,0 +1,241 @@
+/*************************************************
+* Unix Command Execution Source File             *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef _XOPEN_SOURCE
+  #define _XOPEN_SOURCE 500
+#endif
+
+#ifndef _XOPEN_SOURCE_EXTENDED
+  #define _XOPEN_SOURCE_EXTENDED 1
+#endif
+
+#include <botan/unix_cmd.h>
+#include <botan/parsing.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <signal.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* Attempt to execute the command                 *
+************************************************/
+void do_exec(const std::vector<std::string>& arg_list,
+             const std::vector<std::string>& paths)
+   {
+   const u32bit args = arg_list.size() - 1;
+
+   const char* arg1 = (args >= 1) ? arg_list[1].c_str() : 0;
+   const char* arg2 = (args >= 2) ? arg_list[2].c_str() : 0;
+   const char* arg3 = (args >= 3) ? arg_list[3].c_str() : 0;
+   const char* arg4 = (args >= 4) ? arg_list[4].c_str() : 0;
+
+   for(u32bit j = 0; j != paths.size(); j++)
+      {
+      const std::string full_path = paths[j] + "/" + arg_list[0];
+      const char* fsname = full_path.c_str();
+      execl(fsname, fsname, arg1, arg2, arg3, arg4, 0);
+      }
+   }
+
+}
+
+/*************************************************
+* Local information about the pipe               *
+*************************************************/
+struct pipe_wrapper
+   {
+   int fd;
+   pid_t pid;
+   pipe_wrapper() { fd = -1; pid = 0; }
+   };
+
+/*************************************************
+* Read from the pipe                             *
+*************************************************/
+u32bit DataSource_Command::read(byte buf[], u32bit length)
+   {
+   if(end_of_data())
+      return 0;
+
+   fd_set set;
+   FD_ZERO(&set);
+   FD_SET(pipe->fd, &set);
+
+   struct timeval tv;
+   tv.tv_sec = 0;
+   tv.tv_usec = MAX_BLOCK_USECS;
+
+   ssize_t got = 0;
+   if(select(pipe->fd + 1, &set, 0, 0, &tv) == 1)
+      {
+      if(FD_ISSET(pipe->fd, &set))
+         got = ::read(pipe->fd, buf, length);
+      }
+
+   if(got <= 0)
+      {
+      shutdown_pipe();
+      return 0;
+      }
+
+   return (u32bit)got;
+   }
+
+/*************************************************
+* Peek at the pipe contents                      *
+*************************************************/
+u32bit DataSource_Command::peek(byte[], u32bit, u32bit) const
+   {
+   if(end_of_data())
+      throw Invalid_State("DataSource_Command: Cannot peek when out of data");
+   throw Stream_IO_Error("Cannot peek/seek on a command pipe");
+   }
+
+/*************************************************
+* Check if we reached EOF                        *
+*************************************************/
+bool DataSource_Command::end_of_data() const
+   {
+   return (pipe) ? false : true;
+   }
+
+/*************************************************
+* Return the Unix file descriptor of the pipe    *
+*************************************************/
+int DataSource_Command::fd() const
+   {
+   if(!pipe)
+      return -1;
+   return pipe->fd;
+   }
+
+/*************************************************
+* Return a human-readable ID for this stream     *
+*************************************************/
+std::string DataSource_Command::id() const
+   {
+   return "Unix command: " + arg_list[0];
+   }
+
+/*************************************************
+* Create the pipe                                *
+*************************************************/
+void DataSource_Command::create_pipe(const std::string& path)
+   {
+   const std::vector<std::string> paths = split_on(path, ':');
+
+   bool found_something = false;
+   for(u32bit j = 0; j != paths.size(); j++)
+      {
+      const std::string full_path = paths[j] + "/" + arg_list[0];
+      if(access(full_path.c_str(), X_OK) == 0)
+         {
+         found_something = true;
+         break;
+         }
+      }
+   if(!found_something)
+      return;
+
+   int pipe_fd[2];
+   if(::pipe(pipe_fd) != 0)
+      return;
+
+   pid_t pid = fork();
+
+   if(pid == -1)
+      {
+      close(pipe_fd[0]);
+      close(pipe_fd[1]);
+      }
+   else if(pid > 0)
+      {
+      pipe = new pipe_wrapper;
+      pipe->fd = pipe_fd[0];
+      pipe->pid = pid;
+      close(pipe_fd[1]);
+      }
+   else
+      {
+      if(dup2(pipe_fd[1], STDOUT_FILENO) == -1)
+         exit(127);
+      if(close(pipe_fd[0]) != 0 || close(pipe_fd[1]) != 0)
+         exit(127);
+      if(close(STDERR_FILENO) != 0)
+         exit(127);
+
+      do_exec(arg_list, paths);
+      exit(127);
+      }
+   }
+
+/*************************************************
+* Shutdown the pipe                              *
+*************************************************/
+void DataSource_Command::shutdown_pipe()
+   {
+   if(pipe)
+      {
+      pid_t reaped = waitpid(pipe->pid, 0, WNOHANG);
+
+      if(reaped == 0)
+         {
+         kill(pipe->pid, SIGTERM);
+
+         struct timeval tv;
+         tv.tv_sec = 0;
+         tv.tv_usec = KILL_WAIT;
+         select(0, 0, 0, 0, &tv);
+
+         reaped = waitpid(pipe->pid, 0, WNOHANG);
+
+         if(reaped == 0)
+            {
+            kill(pipe->pid, SIGKILL);
+            do
+               reaped = waitpid(pipe->pid, 0, 0);
+            while(reaped == -1);
+            }
+         }
+
+      close(pipe->fd);
+      delete pipe;
+      pipe = 0;
+      }
+   }
+
+/*************************************************
+* DataSource_Command Constructor                 *
+*************************************************/
+DataSource_Command::DataSource_Command(const std::string& prog_and_args,
+                                       const std::string& path) :
+   MAX_BLOCK_USECS(100000), KILL_WAIT(10000)
+   {
+   arg_list = split_on(prog_and_args, ' ');
+
+   if(arg_list.size() == 0)
+      throw Invalid_Argument("DataSource_Command: No command given");
+   if(arg_list.size() > 5)
+      throw Invalid_Argument("DataSource_Command: Too many args");
+
+   pipe = 0;
+   create_pipe(path);
+   }
+
+/*************************************************
+* DataSource_Command Destructor                  *
+*************************************************/
+DataSource_Command::~DataSource_Command()
+   {
+   if(!end_of_data())
+      shutdown_pipe();
+   }
+
+}
diff --git a/modules/es_unix/unix_cmd.h b/modules/es_unix/unix_cmd.h
new file mode 100644
index 000000000..8da81ccbd
--- /dev/null
+++ b/modules/es_unix/unix_cmd.h
@@ -0,0 +1,56 @@
+/*************************************************
+* Unix Command Execution Header File             *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_UNIX_CMD_H__
+#define BOTAN_EXT_UNIX_CMD_H__
+
+#include <botan/types.h>
+#include <botan/data_src.h>
+#include <string>
+#include <vector>
+
+namespace Botan {
+
+/*************************************************
+* Unix Program Info                              *
+*************************************************/
+struct Unix_Program
+   {
+   Unix_Program(const char* n, u32bit p)
+      { name_and_args = n; priority = p; working = true; }
+
+   std::string name_and_args;
+   u32bit priority;
+   bool working;
+   };
+
+/*************************************************
+* Command Output DataSource                      *
+*************************************************/
+class DataSource_Command : public DataSource
+   {
+   public:
+      u32bit read(byte[], u32bit);
+      u32bit peek(byte[], u32bit, u32bit) const;
+      bool end_of_data() const;
+      std::string id() const;
+
+      int fd() const;
+
+      DataSource_Command(const std::string&, const std::string&);
+      ~DataSource_Command();
+   private:
+      void create_pipe(const std::string&);
+      void shutdown_pipe();
+
+      const u32bit MAX_BLOCK_USECS, KILL_WAIT;
+
+      std::vector<std::string> arg_list;
+      struct pipe_wrapper* pipe;
+   };
+
+}
+
+#endif
diff --git a/modules/es_unix/unix_src.cpp b/modules/es_unix/unix_src.cpp
new file mode 100644
index 000000000..5493d9fd8
--- /dev/null
+++ b/modules/es_unix/unix_src.cpp
@@ -0,0 +1,59 @@
+/*************************************************
+* Program List for Unix_EntropySource            *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/es_unix.h>
+
+namespace Botan {
+
+/*************************************************
+* Default Commands for Entropy Gathering         *
+*************************************************/
+void Unix_EntropySource::add_default_sources(std::vector<Unix_Program>& srcs)
+   {
+   srcs.push_back(Unix_Program("vmstat",                1));
+   srcs.push_back(Unix_Program("vmstat -s",             1));
+   srcs.push_back(Unix_Program("pfstat",                1));
+   srcs.push_back(Unix_Program("netstat -in",           1));
+
+   srcs.push_back(Unix_Program("iostat",                2));
+   srcs.push_back(Unix_Program("mpstat",                2));
+   srcs.push_back(Unix_Program("nfsstat",               2));
+   srcs.push_back(Unix_Program("portstat",              2));
+   srcs.push_back(Unix_Program("arp -a -n",             2));
+   srcs.push_back(Unix_Program("ifconfig -a",           2));
+   srcs.push_back(Unix_Program("pstat -T",              2));
+   srcs.push_back(Unix_Program("pstat -s",              2));
+   srcs.push_back(Unix_Program("uname -a",              2));
+   srcs.push_back(Unix_Program("uptime",                2));
+   srcs.push_back(Unix_Program("ipcs -a",               2));
+   srcs.push_back(Unix_Program("procinfo -a",           2));
+
+   srcs.push_back(Unix_Program("sysinfo",               3));
+   srcs.push_back(Unix_Program("listarea",              3));
+   srcs.push_back(Unix_Program("listdev",               3));
+
+   srcs.push_back(Unix_Program("who",                   3));
+   srcs.push_back(Unix_Program("finger",                3));
+   srcs.push_back(Unix_Program("netstat -s",            3));
+   srcs.push_back(Unix_Program("netstat -an",           3));
+   srcs.push_back(Unix_Program("ps -A",                 3));
+   srcs.push_back(Unix_Program("mailstats",             3));
+   srcs.push_back(Unix_Program("rpcinfo -p localhost",  3));
+
+   srcs.push_back(Unix_Program("dmesg",                 4));
+   srcs.push_back(Unix_Program("ls -alni /tmp",         4));
+   srcs.push_back(Unix_Program("ls -alni /proc",        4));
+   srcs.push_back(Unix_Program("df -l",                 4));
+   srcs.push_back(Unix_Program("last -5",               4));
+   srcs.push_back(Unix_Program("pstat -f",              4));
+
+   srcs.push_back(Unix_Program("ps aux",                5));
+   srcs.push_back(Unix_Program("ps -elf",               5));
+
+   srcs.push_back(Unix_Program("sar -A",                6));
+   srcs.push_back(Unix_Program("lsof",                  6));
+   }
+
+}
diff --git a/modules/es_win32/es_win32.cpp b/modules/es_win32/es_win32.cpp
new file mode 100644
index 000000000..fda02effe
--- /dev/null
+++ b/modules/es_win32/es_win32.cpp
@@ -0,0 +1,105 @@
+/*************************************************
+* Win32 EntropySource Source File                *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/es_win32.h>
+#include <windows.h>
+#include <tlhelp32.h>
+
+namespace Botan {
+
+/*************************************************
+* Win32 Slow Poll                                *
+*************************************************/
+void Win32_EntropySource::do_slow_poll()
+   {
+   const u32bit MAX_ITEMS = 256;
+
+   do_fast_poll();
+
+   HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPALL, 0);
+
+#define TOOLHELP32_ITER(DATA_TYPE, FUNC_FIRST, FUNC_NEXT) \
+   {                                                      \
+   u32bit items = 0;                                      \
+   DATA_TYPE info;                                        \
+   info.dwSize = sizeof(DATA_TYPE);                       \
+   if(FUNC_FIRST(snapshot, &info))                        \
+      {                                                   \
+      do                                                  \
+         {                                                \
+         if(items++ > MAX_ITEMS) break;                   \
+         add_bytes(&info, sizeof(info));                  \
+         } while(FUNC_NEXT(snapshot, &info));             \
+      }                                                   \
+   }
+
+   TOOLHELP32_ITER(MODULEENTRY32, Module32First, Module32Next);
+   TOOLHELP32_ITER(PROCESSENTRY32, Process32First, Process32Next);
+   TOOLHELP32_ITER(THREADENTRY32, Thread32First, Thread32Next);
+
+#undef TOOLHELP32_ITER
+
+   u32bit heap_lists_found = 0;
+   HEAPLIST32 heap_list;
+   heap_list.dwSize = sizeof(HEAPLIST32);
+
+   const u32bit HEAP_LISTS_MAX = 32;
+   const u32bit HEAP_OBJS_PER_LIST = 128;
+   if(Heap32ListFirst(snapshot, &heap_list))
+      {
+      do
+         {
+         add_bytes(&heap_list, sizeof(HEAPLIST32));
+
+         if(heap_lists_found++ > HEAP_LISTS_MAX)
+            break;
+
+         u32bit heap_objs_found = 0;
+         HEAPENTRY32 heap_entry;
+         heap_entry.dwSize = sizeof(HEAPENTRY32);
+         if(Heap32First(&heap_entry, heap_list.th32ProcessID,
+                                     heap_list.th32HeapID))
+            {
+            do
+               {
+               if(heap_objs_found++ > HEAP_OBJS_PER_LIST)
+                  break;
+               add_bytes(&heap_entry, sizeof(HEAPENTRY32));
+               } while(Heap32Next(&heap_entry));
+            }
+         } while(Heap32ListNext(snapshot, &heap_list));
+      }
+
+   CloseHandle(snapshot);
+   }
+
+/*************************************************
+* Win32 Fast Poll                                *
+*************************************************/
+void Win32_EntropySource::do_fast_poll()
+   {
+   add_bytes(GetTickCount());
+   add_bytes(GetMessagePos());
+   add_bytes(GetMessageTime());
+   add_bytes(GetInputState());
+   add_bytes(GetCurrentProcessId());
+   add_bytes(GetCurrentThreadId());
+
+   SYSTEM_INFO sys_info;
+   GetSystemInfo(&sys_info);
+   add_bytes(&sys_info, sizeof(sys_info));
+
+   MEMORYSTATUS mem_info;
+   GlobalMemoryStatus(&mem_info);
+   add_bytes(&mem_info, sizeof(mem_info));
+
+   POINT point;
+   GetCursorPos(&point);
+   add_bytes(&point, sizeof(point));
+   GetCaretPos(&point);
+   add_bytes(&point, sizeof(point));
+   }
+
+}
diff --git a/modules/es_win32/es_win32.h b/modules/es_win32/es_win32.h
new file mode 100644
index 000000000..7ca9f1285
--- /dev/null
+++ b/modules/es_win32/es_win32.h
@@ -0,0 +1,25 @@
+/*************************************************
+* Win32 EntropySource Header File                *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_ENTROPY_SRC_WIN32_H__
+#define BOTAN_EXT_ENTROPY_SRC_WIN32_H__
+
+#include <botan/buf_es.h>
+
+namespace Botan {
+
+/*************************************************
+* Win32 Entropy Source                           *
+*************************************************/
+class Win32_EntropySource : public Buffered_EntropySource
+   {
+   private:
+      void do_fast_poll();
+      void do_slow_poll();
+   };
+
+}
+
+#endif
diff --git a/modules/es_win32/modinfo.txt b/modules/es_win32/modinfo.txt
new file mode 100644
index 000000000..67e1a6ec0
--- /dev/null
+++ b/modules/es_win32/modinfo.txt
@@ -0,0 +1,18 @@
+realname "MS Windows Entropy Source"
+
+# Probably not much of an issue anymore
+#note "This module will not run under NT4"
+
+define ENTROPY_SRC_WIN32
+
+add_file es_win32.h
+add_file es_win32.cpp
+
+<os>
+windows
+cygwin
+</os>
+
+<libs>
+windows -> user32
+</libs>
diff --git a/modules/fd_unix/fd_unix.cpp b/modules/fd_unix/fd_unix.cpp
new file mode 100644
index 000000000..8b7b2648a
--- /dev/null
+++ b/modules/fd_unix/fd_unix.cpp
@@ -0,0 +1,50 @@
+/*************************************************
+* Pipe I/O for Unix Source File                  *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/pipe.h>
+#include <unistd.h>
+
+namespace Botan {
+
+/*************************************************
+* Write data from a pipe into a Unix fd          *
+*************************************************/
+int operator<<(int fd, Pipe& pipe)
+   {
+   SecureVector<byte> buffer(DEFAULT_BUFFERSIZE);
+   while(pipe.remaining())
+      {
+      u32bit got = pipe.read(buffer, buffer.size());
+      u32bit position = 0;
+      while(got)
+         {
+         ssize_t ret = write(fd, buffer + position, got);
+         if(ret == -1)
+            throw Stream_IO_Error("Pipe output operator (unixfd) has failed");
+         position += ret;
+         got -= ret;
+         }
+      }
+   return fd;
+   }
+
+/*************************************************
+* Read data from a Unix fd into a pipe           *
+*************************************************/
+int operator>>(int fd, Pipe& pipe)
+   {
+   SecureVector<byte> buffer(DEFAULT_BUFFERSIZE);
+   while(true)
+      {
+      ssize_t ret = read(fd, buffer, buffer.size());
+      if(ret == 0) break;
+      if(ret == -1)
+         throw Stream_IO_Error("Pipe input operator (unixfd) has failed");
+      pipe.write(buffer, ret);
+      }
+   return fd;
+   }
+
+}
diff --git a/modules/fd_unix/fd_unix.h b/modules/fd_unix/fd_unix.h
new file mode 100644
index 000000000..f00cb8020
--- /dev/null
+++ b/modules/fd_unix/fd_unix.h
@@ -0,0 +1,21 @@
+/*************************************************
+* Pipe I/O for Unix Header File                  *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_PIPE_UNIXFD_H__
+#define BOTAN_EXT_PIPE_UNIXFD_H__
+
+#include <botan/pipe.h>
+
+namespace Botan {
+
+/*************************************************
+* Unix I/O Operators for Pipe                    *
+*************************************************/
+int operator<<(int, Pipe&);
+int operator>>(int, Pipe&);
+
+}
+
+#endif
diff --git a/modules/fd_unix/modinfo.txt b/modules/fd_unix/modinfo.txt
new file mode 100644
index 000000000..062b93cca
--- /dev/null
+++ b/modules/fd_unix/modinfo.txt
@@ -0,0 +1,22 @@
+realname "Pipe Unix I/O support"
+
+define PIPE_UNIXFD_IO
+
+add_file fd_unix.h
+add_file fd_unix.cpp
+
+<os>
+aix
+beos
+cygwin
+darwin
+freebsd
+hpux
+irix
+linux
+netbsd
+openbsd
+qnx
+solaris
+tru64
+</os>
diff --git a/modules/ml_unix/mlock.cpp b/modules/ml_unix/mlock.cpp
new file mode 100644
index 000000000..937308739
--- /dev/null
+++ b/modules/ml_unix/mlock.cpp
@@ -0,0 +1,33 @@
+/*************************************************
+* Memory Locking Functions Source File           *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/util.h>
+
+#ifndef _POSIX_C_SOURCE
+  #define _POSIX_C_SOURCE 199309
+#endif
+
+#include <sys/types.h>
+#include <sys/mman.h>
+
+namespace Botan {
+
+/*************************************************
+* Lock an area of memory into RAM                *
+*************************************************/
+void lock_mem(void* ptr, u32bit bytes)
+   {
+   mlock(ptr, bytes);
+   }
+
+/*************************************************
+* Unlock a previously locked region of memory    *
+*************************************************/
+void unlock_mem(void* ptr, u32bit bytes)
+   {
+   munlock(ptr, bytes);
+   }
+
+}
diff --git a/modules/ml_unix/modinfo.txt b/modules/ml_unix/modinfo.txt
new file mode 100644
index 000000000..bc05f0d08
--- /dev/null
+++ b/modules/ml_unix/modinfo.txt
@@ -0,0 +1,21 @@
+realname "Memory Locking for Unix"
+
+replace_file mlock.cpp
+
+<os>
+aix
+darwin
+freebsd
+hpux
+irix
+linux
+netbsd
+openbsd
+qnx
+solaris
+tru64
+</os>
+
+<libs>
+tru64 -> rt
+</libs>
diff --git a/modules/ml_win32/mlock.cpp b/modules/ml_win32/mlock.cpp
new file mode 100644
index 000000000..7384beb07
--- /dev/null
+++ b/modules/ml_win32/mlock.cpp
@@ -0,0 +1,27 @@
+/*************************************************
+* Memory Locking Functions Source File           *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/util.h>
+#include <windows.h>
+
+namespace Botan {
+
+/*************************************************
+* Lock an area of memory into RAM                *
+*************************************************/
+void lock_mem(void* ptr, u32bit bytes)
+   {
+   VirtualLock(ptr, bytes);
+   }
+
+/*************************************************
+* Unlock a previously locked region of memory    *
+*************************************************/
+void unlock_mem(void* ptr, u32bit bytes)
+   {
+   VirtualUnlock(ptr, bytes);
+   }
+
+}
diff --git a/modules/ml_win32/modinfo.txt b/modules/ml_win32/modinfo.txt
new file mode 100644
index 000000000..31b5d2afa
--- /dev/null
+++ b/modules/ml_win32/modinfo.txt
@@ -0,0 +1,8 @@
+realname "Memory Locking for Windows"
+
+replace_file mlock.cpp
+
+<os>
+windows
+cygwin
+</os>
diff --git a/modules/mod_qt/modinfo.txt b/modules/mod_qt/modinfo.txt
new file mode 100644
index 000000000..ee91ef735
--- /dev/null
+++ b/modules/mod_qt/modinfo.txt
@@ -0,0 +1,19 @@
+realname "Support for Qt/QCA"
+
+define MUTEX_QT
+
+note "You'll probably have to add -I/-L flags to the Makefile to find Qt"
+
+replace_file types.h
+
+uses_external_libs
+
+replace_file types.h
+add_file mux_qt.cpp
+add_file mux_qt.h
+
+# I think we want to always use qt-mt, not qt -- not much point in supporting
+# mutexes in a single threaded application, after all.
+<libs>
+all -> qt-mt
+</libs>
diff --git a/modules/mod_qt/mux_qt.cpp b/modules/mod_qt/mux_qt.cpp
new file mode 100644
index 000000000..0d419d38a
--- /dev/null
+++ b/modules/mod_qt/mux_qt.cpp
@@ -0,0 +1,56 @@
+/*************************************************
+* Qt Thread Mutex Source File                    *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/mux_qt.h>
+#include <botan/exceptn.h>
+#include <qmutex.h>
+
+#if !defined(QT_THREAD_SUPPORT)
+   #error Your version of Qt does not support threads or mutexes
+#endif
+
+namespace Botan {
+
+/*************************************************
+* Wrapper Type for Qt Thread Mutex               *
+*************************************************/
+struct mutex_wrapper
+   {
+   QMutex m;
+   };
+
+/*************************************************
+* Constructor                                    *
+*************************************************/
+Qt_Mutex::Qt_Mutex()
+   {
+   mutex = new mutex_wrapper;
+   }
+
+/*************************************************
+* Destructor                                     *
+*************************************************/
+Qt_Mutex::~Qt_Mutex()
+   {
+   delete mutex;
+   }
+
+/*************************************************
+* Lock the Mutex                                 *
+*************************************************/
+void Qt_Mutex::lock()
+   {
+   mutex->m.lock();
+   }
+
+/*************************************************
+* Unlock the Mutex                               *
+*************************************************/
+void Qt_Mutex::unlock()
+   {
+   mutex->m.unlock();
+   }
+
+}
diff --git a/modules/mod_qt/mux_qt.h b/modules/mod_qt/mux_qt.h
new file mode 100644
index 000000000..1535b3d36
--- /dev/null
+++ b/modules/mod_qt/mux_qt.h
@@ -0,0 +1,31 @@
+/*************************************************
+* Qt Thread Mutex Header File                    *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_MUTEX_QT_H__
+#define BOTAN_EXT_MUTEX_QT_H__
+
+#include <botan/mutex.h>
+
+namespace Botan {
+
+/*************************************************
+* Qt Mutex                                       *
+*************************************************/
+class Qt_Mutex : public Mutex
+   {
+   public:
+      void lock();
+      void unlock();
+      Mutex* clone() const { return new Qt_Mutex; }
+
+      Qt_Mutex();
+      ~Qt_Mutex();
+   private:
+      struct mutex_wrapper* mutex;
+   };
+
+}
+
+#endif
diff --git a/modules/mod_qt/types.h b/modules/mod_qt/types.h
new file mode 100644
index 000000000..9f1b40666
--- /dev/null
+++ b/modules/mod_qt/types.h
@@ -0,0 +1,28 @@
+/*************************************************
+* Low Level Types Header File                    *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_TYPES_H__
+#define BOTAN_TYPES_H__
+
+#include <qglobal.h>
+
+namespace Botan {
+
+typedef Q_UINT8 byte;
+typedef Q_UINT16 u16bit;
+typedef Q_UINT32 u32bit;
+typedef Q_UINT64 u64bit;
+
+typedef Q_INT32 s32bit;
+}
+
+namespace Botan_types {
+
+typedef Botan::byte byte;
+typedef Botan::u32bit u32bit;
+
+}
+
+#endif
diff --git a/modules/mp_amd64/modinfo.txt b/modules/mp_amd64/modinfo.txt
new file mode 100644
index 000000000..12537da0e
--- /dev/null
+++ b/modules/mp_amd64/modinfo.txt
@@ -0,0 +1,15 @@
+realname "MPI Assembler Backend for x86-64/AMD64 Systems"
+
+mp_bits 64
+
+replace_file mp_asm.h
+replace_file mp_asmi.h
+
+<arch>
+amd64
+</arch>
+
+<cc>
+gcc
+icc
+</cc>
diff --git a/modules/mp_amd64/mp_asm.h b/modules/mp_amd64/mp_asm.h
new file mode 100644
index 000000000..17f33224c
--- /dev/null
+++ b/modules/mp_amd64/mp_asm.h
@@ -0,0 +1,84 @@
+/*************************************************
+* Lowest Level MPI Algorithms Header File        *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_MP_ASM_H__
+#define BOTAN_MP_ASM_H__
+
+#include <botan/mp_types.h>
+
+#if (BOTAN_MP_WORD_BITS != 64)
+   #error The mp_amd64 module requires that BOTAN_MP_WORD_BITS == 64
+#endif
+
+namespace Botan {
+
+extern "C" {
+
+/*************************************************
+* Word Multiply                                  *
+*************************************************/
+inline word word_madd2(word a, word b, word c, word* carry)
+   {
+   asm(
+      "mulq %1\n\t"        // a(in eax) * b(wherever) -> edx:eax
+      "addq %5,%0\n\t"     // add c to low word (eax)
+      "adcq $0,%2"         // add carry from previous to high word (edx)
+      : "=a"(a), "=rm"(b), "=&d"(*carry)
+      : "0"(a), "1"(b), "g"(c) : "cc");
+   return a;
+   }
+
+/*************************************************
+* Word Multiply/Add                              *
+*************************************************/
+inline word word_madd3(word a, word b, word c, word d, word* carry)
+   {
+   asm(
+      "mulq %1\n\t"        // a(in eax) * b(wherever) -> edx:eax
+      "addq %5,%0\n\t"     // add c to low word (eax)
+      "adcq $0,%2\n\t"     // add carry from previous to high word (edx)
+      "addq %6,%0\n\t"     // add d to low word (eax)
+      "adcq $0,%2"         // add carry from previous to high word (edx)
+      : "=a"(a), "=rm"(b), "=&d"(*carry)
+      : "0"(a), "1"(b), "g"(c), "g"(d) : "cc");
+   return a;
+   }
+
+/*************************************************
+* Multiply-Add Accumulator                       *
+*************************************************/
+inline void word3_muladd(word* w2, word* w1, word* w0, word a, word b)
+   {
+   asm("mulq %[b]\n\t"        // a(in eax) * b(wherever) -> edx:eax
+       "addq %3,%[w0]\n\t"     // add c to low word (eax)
+       "adcq %4,%[w1]\n\t"     // add carry from previous to high word (edx)
+       "adcq $0,%[w2]\n\t"     // add carry from previous to high word (edx)
+       : [w0]"=r"(*w0), [w1]"=r"(*w1), [w2]"=r"(*w2)
+       : "a"(a), [b]"d"(b), "0"(*w0), "1"(*w1), "2"(*w2)
+       : "cc");
+   }
+
+/*************************************************
+* Multiply-Add Accumulator                       *
+*************************************************/
+inline void word3_muladd_2(word* w2, word* w1, word* w0, word a, word b)
+   {
+   asm("mulq %[b]\n\t"        // a(in eax) * b(wherever) -> edx:eax
+       "addq %3,%[w0]\n\t"     // add c to low word (eax)
+       "adcq %4,%[w1]\n\t"     // add carry from previous to high word (edx)
+       "adcq $0,%[w2]\n\t"     // add carry from previous to high word (edx)
+       "addq %3,%[w0]\n\t"     // add c to low word (eax)
+       "adcq %4,%[w1]\n\t"     // add carry from previous to high word (edx)
+       "adcq $0,%[w2]\n\t"     // add carry from previous to high word (edx)
+       : [w0]"=r"(*w0), [w1]"=r"(*w1), [w2]"=r"(*w2)
+       : "a"(a), [b]"d"(b), "0"(*w0), "1"(*w1), "2"(*w2)
+       : "cc");
+      }
+
+}
+
+}
+
+#endif
diff --git a/modules/mp_amd64/mp_asmi.h b/modules/mp_amd64/mp_asmi.h
new file mode 100644
index 000000000..daa1243ca
--- /dev/null
+++ b/modules/mp_amd64/mp_asmi.h
@@ -0,0 +1,174 @@
+/*************************************************
+* Lowest Level MPI Algorithms Header File        *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_MP_ASM_INTERNAL_H__
+#define BOTAN_MP_ASM_INTERNAL_H__
+
+#include <botan/mp_types.h>
+
+namespace Botan {
+
+/*************************************************
+* Helper Macros for amd64 Assembly               *
+*************************************************/
+#define ASM(x) x "\n\t"
+
+#define ADDSUB2_OP(OPERATION, INDEX)                    \
+        ASM("movq 8*" INDEX "(%[y]), %[carry]")         \
+        ASM(OPERATION " %[carry], 8*" INDEX "(%[x])")   \
+
+#define ADDSUB3_OP(OPERATION, INDEX)                    \
+        ASM("movq 8*" INDEX "(%[x]), %[carry]")         \
+        ASM(OPERATION " 8*" INDEX "(%[y]), %[carry]")   \
+        ASM("movq %[carry], 8*" INDEX "(%[z])")         \
+
+#define LINMUL_OP(WRITE_TO, INDEX)                      \
+        ASM("movq 8*" INDEX "(%[x]),%%rax")             \
+        ASM("mulq %[y]")                                \
+        ASM("addq %[carry],%%rax")                      \
+        ASM("adcq $0,%%rdx")                            \
+        ASM("movq %%rdx,%[carry]")                      \
+        ASM("movq %%rax, 8*" INDEX "(%[" WRITE_TO "])")
+
+#define MULADD_OP(IGNORED, INDEX)                       \
+        ASM("movq 8*" INDEX "(%[x]),%%rax")             \
+        ASM("mulq %[y]")                                \
+        ASM("addq %[carry],%%rax")                      \
+        ASM("adcq $0,%%rdx")                            \
+        ASM("addq 8*" INDEX "(%[z]),%%rax")             \
+        ASM("adcq $0,%%rdx")                            \
+        ASM("movq %%rdx,%[carry]")                      \
+        ASM("movq %%rax, 8*" INDEX " (%[z])")
+
+#define DO_8_TIMES(MACRO, ARG) \
+        MACRO(ARG, "0") MACRO(ARG, "1") MACRO(ARG, "2") MACRO(ARG, "3") \
+        MACRO(ARG, "4") MACRO(ARG, "5") MACRO(ARG, "6") MACRO(ARG, "7")
+
+#define ADD_OR_SUBTRACT(CORE_CODE)     \
+        ASM("rorq %[carry]")           \
+        CORE_CODE                      \
+        ASM("sbbq %[carry],%[carry]")  \
+        ASM("negq %[carry]")
+
+/*************************************************
+* Word Addition                                  *
+*************************************************/
+inline word word_add(word x, word y, word* carry)
+   {
+   asm(
+      ADD_OR_SUBTRACT(ASM("adcq %[y],%[x]"))
+      : [x]"=r"(x), [carry]"=r"(*carry)
+      : "0"(x), [y]"rm"(y), "1"(*carry)
+      : "cc");
+   return x;
+   }
+
+/*************************************************
+* Eight Word Block Addition, Two Argument        *
+*************************************************/
+inline word word8_add2(word x[8], const word y[8], word carry)
+   {
+   asm(
+      ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB2_OP, "adcq"))
+      : [carry]"=r"(carry)
+      : [x]"r"(x), [y]"r"(y), "0"(carry)
+      : "cc", "memory");
+   return carry;
+   }
+
+/*************************************************
+* Eight Word Block Addition, Three Argument      *
+*************************************************/
+inline word word8_add3(word z[8], const word x[8], const word y[8], word carry)
+   {
+   asm(
+      ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB3_OP, "adcq"))
+      : [carry]"=r"(carry)
+      : [x]"r"(x), [y]"r"(y), [z]"r"(z), "0"(carry)
+      : "cc", "memory");
+   return carry;
+   }
+
+/*************************************************
+* Word Subtraction                               *
+*************************************************/
+inline word word_sub(word x, word y, word* carry)
+   {
+   asm(
+      ADD_OR_SUBTRACT(ASM("sbbq %[y],%[x]"))
+      : [x]"=r"(x), [carry]"=r"(*carry)
+      : "0"(x), [y]"rm"(y), "1"(*carry)
+      : "cc");
+   return x;
+   }
+
+/*************************************************
+* Eight Word Block Subtraction, Two Argument     *
+*************************************************/
+inline word word8_sub2(word x[8], const word y[8], word carry)
+   {
+   asm(
+      ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB2_OP, "sbbq"))
+      : [carry]"=r"(carry)
+      : [x]"r"(x), [y]"r"(y), "0"(carry)
+      : "cc", "memory");
+   return carry;
+   }
+
+/*************************************************
+* Eight Word Block Subtraction, Three Argument   *
+*************************************************/
+inline word word8_sub3(word z[8], const word x[8], const word y[8], word carry)
+   {
+   asm(
+      ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB3_OP, "sbbq"))
+      : [carry]"=r"(carry)
+      : [x]"r"(x), [y]"r"(y), [z]"r"(z), "0"(carry)
+      : "cc", "memory");
+   return carry;
+   }
+
+/*************************************************
+* Eight Word Block Linear Multiplication         *
+*************************************************/
+inline word word8_linmul2(word x[8], word y, word carry)
+   {
+   asm(
+      DO_8_TIMES(LINMUL_OP, "x")
+      : [carry]"=r"(carry)
+      : [x]"r"(x), [y]"rm"(y), "0"(carry)
+      : "cc", "%rax", "%rdx");
+   return carry;
+   }
+
+/*************************************************
+* Eight Word Block Linear Multiplication          *
+*************************************************/
+inline word word8_linmul3(word z[8], const word x[8], word y, word carry)
+   {
+   asm(
+      DO_8_TIMES(LINMUL_OP, "z")
+      : [carry]"=r"(carry)
+      : [z]"r"(z), [x]"r"(x), [y]"rm"(y), "0"(carry)
+      : "cc", "%rax", "%rdx");
+   return carry;
+   }
+
+/*************************************************
+* Eight Word Block Multiply/Add                  *
+*************************************************/
+inline word word8_madd3(word z[8], const word x[8], word y, word carry)
+   {
+   asm(
+      DO_8_TIMES(MULADD_OP, "")
+      : [carry]"=r"(carry)
+      : [z]"r"(z), [x]"r"(x), [y]"rm"(y), "0"(carry)
+      : "cc", "%rax", "%rdx");
+   return carry;
+   }
+
+}
+
+#endif
diff --git a/modules/mp_asm64/modinfo.txt b/modules/mp_asm64/modinfo.txt
new file mode 100644
index 000000000..203608d9e
--- /dev/null
+++ b/modules/mp_asm64/modinfo.txt
@@ -0,0 +1,23 @@
+realname "MPI Assembler Backend for 64 bit Systems"
+
+mp_bits 64
+
+replace_file mp_asm.h
+
+# Disable amd64 since (nominally) the mp_amd64 module has that covered
+<arch>
+alpha
+# amd64
+ia64
+mips64
+ppc64
+sparc64
+</arch>
+
+# The inline asm only works with gcc, but it looks like (at least on
+# UltraSPARC), using 64-bit words and the sythensized multiply is a 5 to 25%
+# win, so it's probably worth using elsewhere.
+<cc>
+gcc
+sunwspro
+</cc>
diff --git a/modules/mp_asm64/mp_asm.h b/modules/mp_asm64/mp_asm.h
new file mode 100644
index 000000000..8c6df078e
--- /dev/null
+++ b/modules/mp_asm64/mp_asm.h
@@ -0,0 +1,119 @@
+/*************************************************
+* MPI Multiply-Add Core Header File              *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_MP_MADD_H__
+#define BOTAN_MP_MADD_H__
+
+#include <botan/mp_types.h>
+
+#if (BOTAN_MP_WORD_BITS != 64)
+   #error The mp_asm64 module requires that BOTAN_MP_WORD_BITS == 64
+#endif
+
+#if defined(BOTAN_TARGET_ARCH_IS_AMD64)
+
+#define BOTAN_WORD_MUL(a,b,z1,z0) do {       \
+   asm("mulq %3" : "=d" (z0), "=a" (z1) :    \
+       "a" (a), "rm" (b) : "cc");            \
+} while(0);
+
+#elif defined(BOTAN_TARGET_ARCH_IS_ALPHA)
+
+#define BOTAN_WORD_MUL(a,b,z1,z0) do {                   \
+   asm("umulh %1,%2,%0" : "=r" (z0) : "r" (a), "r" (b)); \
+   z1 = a * b;                                           \
+} while(0);
+
+#elif defined(BOTAN_TARGET_ARCH_IS_IA64)
+
+#define BOTAN_WORD_MUL(a,b,z1,z0) do {                     \
+   asm("xmpy.hu %0=%1,%2" : "=f" (z0) : "f" (a), "f" (b)); \
+   z1 = a * b;                                             \
+} while(0);
+
+#elif defined(BOTAN_TARGET_ARCH_IS_PPC64)
+
+#define BOTAN_WORD_MUL(a,b,z1,z0) do {                           \
+   asm("mulhdu %0,%1,%2" : "=r" (z0) : "r" (a), "r" (b) : "cc"); \
+   z1 = a * b;                                                   \
+} while(0);
+
+#elif defined(BOTAN_TARGET_ARCH_IS_MIPS64)
+
+#define BOTAN_WORD_MUL(a,b,z1,z0) do {                            \
+   asm("dmultu %2,%3" : "=h" (z0), "=l" (z1) : "r" (a), "r" (b)); \
+} while(0);
+
+#else
+
+#include <botan/mp_core.h>
+
+#define BOTAN_WORD_MUL(a,b,z1,z0) \
+   do { bigint_wordmul(a, b, &z1, &z0); } while(0);
+
+#endif
+
+namespace Botan {
+
+/*************************************************
+* Word Multiply/Add                              *
+*************************************************/
+inline word word_madd2(word a, word b, word c, word* carry)
+   {
+   word z0 = 0, z1 = 0;
+
+   BOTAN_WORD_MUL(a, b, z1, z0);
+
+   z1 += c; if(z1 < c) z0++;
+
+   *carry = z0;
+   return z1;
+   }
+
+/*************************************************
+* Word Multiply/Add                              *
+*************************************************/
+inline word word_madd3(word a, word b, word c, word d, word* carry)
+   {
+   word z0 = 0, z1 = 0;
+
+   BOTAN_WORD_MUL(a, b, z1, z0);
+
+   z1 += c; if(z1 < c) z0++;
+   z1 += d; if(z1 < d) z0++;
+
+   *carry = z0;
+   return z1;
+   }
+
+/*************************************************
+* Multiply-Add Accumulator                       *
+*************************************************/
+inline void word3_muladd(word* w2, word* w1, word* w0, word a, word b)
+   {
+   *w0 = word_madd2(a, b, *w0, &a);
+   *w1 += a;
+   *w2 += (*w1 < a) ? 1 : 0;
+   }
+
+/*************************************************
+* Multiply-Add Accumulator                       *
+*************************************************/
+inline void word3_muladd_2(word* w2, word* w1, word* w0, word a, word b)
+   {
+   a = word_madd2(a, b, 0, &b);
+
+   *w0 += a;
+   *w1 += b + ((*w0 < a) ? 1 : 0);
+   *w2 += (*w1 < b) ? 1 : 0;
+
+   *w0 += a;
+   *w1 += b + ((*w0 < a) ? 1 : 0);
+   *w2 += (*w1 < b) ? 1 : 0;
+   }
+
+}
+
+#endif
diff --git a/modules/mp_ia32/modinfo.txt b/modules/mp_ia32/modinfo.txt
new file mode 100644
index 000000000..ff2114fd8
--- /dev/null
+++ b/modules/mp_ia32/modinfo.txt
@@ -0,0 +1,15 @@
+realname "MPI Assembler Backend for x86 Systems"
+
+mp_bits 32
+
+replace_file mp_asm.h
+replace_file mp_asmi.h
+
+<arch>
+ia32
+</arch>
+
+<cc>
+gcc
+icc
+</cc>
diff --git a/modules/mp_ia32/mp_asm.h b/modules/mp_ia32/mp_asm.h
new file mode 100644
index 000000000..8fb4af8fb
--- /dev/null
+++ b/modules/mp_ia32/mp_asm.h
@@ -0,0 +1,88 @@
+/*************************************************
+* Lowest Level MPI Algorithms Header File        *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_MP_ASM_H__
+#define BOTAN_MP_ASM_H__
+
+#include <botan/mp_types.h>
+
+#if (BOTAN_MP_WORD_BITS != 32)
+   #error The mp_ia32 module requires that BOTAN_MP_WORD_BITS == 32
+#endif
+
+namespace Botan {
+
+extern "C" {
+
+/*************************************************
+* Word Multiply                                  *
+*************************************************/
+inline word word_madd2(word a, word b, word c, word* carry)
+   {
+   asm(
+      "mull %1\n\t"        // a (eax) * b (anywhere) -> edx:eax
+      "addl %5,%0\n\t"     // add c to low word (eax)
+      "adcl $0,%2"         // add carry from previous to high word (edx)
+      : "=a"(a), "=rm"(b), "=&d"(*carry)
+      : "0"(a), "1"(b), "g"(c) : "cc");
+
+   return a;
+   }
+
+/*************************************************
+* Word Multiply/Add                              *
+*************************************************/
+inline word word_madd3(word a, word b, word c, word d, word* carry)
+   {
+   asm(
+      "mull %1\n\t"        // a (eax) * b (anywhere) -> edx:eax
+      "addl %5,%0\n\t"     // add c to low word (eax)
+      "adcl $0,%2\n\t"     // add carry from previous add to high word (edx)
+      "addl %6,%0\n\t"     // add d to low word (eax)
+      "adcl $0,%2"         // add carry from previous add to high word (edx)
+      : "=a"(a), "=rm"(b), "=&d"(*carry)
+      : "0"(a), "1"(b), "g"(c), "g"(d) : "cc");
+
+   return a;
+   }
+
+/*************************************************
+* Multiply-Add Accumulator                       *
+*************************************************/
+inline void word3_muladd(word* w2, word* w1, word* w0, word x, word y)
+   {
+   asm(
+      "mull %[y]\n\t"      // a (eax) * b (anywhere) -> edx:eax
+      "addl %3,%[w0]\n\t"  // add c to low word (eax)
+      "adcl %4,%[w1]\n\t"  // add carry from previous add to high word (edx)
+      "adcl $0,%[w2]\n\t"  // add carry from previous add to high word (edx)
+      : [w0]"=r"(*w0), [w1]"=r"(*w1), [w2]"=r"(*w2)
+      : "a"(x), [y]"d"(y), "0"(*w0), "1"(*w1), "2"(*w2)
+      : "cc");
+   }
+
+/*************************************************
+* Multiply-Add Accumulator                       *
+*************************************************/
+inline void word3_muladd_2(word* w2, word* w1, word* w0, word x, word y)
+   {
+   asm(
+      "mull %[y]\n\t"      // a (eax) * b (anywhere) -> edx:eax
+      "addl %3,%[w0]\n\t"  // add c to low word (eax)
+      "adcl %4,%[w1]\n\t"  // add carry from previous add to high word (edx)
+      "adcl $0,%[w2]\n\t"  // add carry from previous add to high word (edx)
+      "addl %3,%[w0]\n\t"  // add c to low word (eax)
+      "adcl %4,%[w1]\n\t"  // add carry from previous add to high word (edx)
+      "adcl $0,%[w2]\n\t"  // add carry from previous add to high word (edx)
+      : [w0]"=r"(*w0), [w1]"=r"(*w1), [w2]"=r"(*w2)
+      : "a"(x), [y]"d"(y), "0"(*w0), "1"(*w1), "2"(*w2)
+      : "cc");
+   }
+
+}
+
+}
+
+#endif
diff --git a/modules/mp_ia32/mp_asmi.h b/modules/mp_ia32/mp_asmi.h
new file mode 100644
index 000000000..a0e5a82e4
--- /dev/null
+++ b/modules/mp_ia32/mp_asmi.h
@@ -0,0 +1,174 @@
+/*************************************************
+* Lowest Level MPI Algorithms Header File        *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_MP_ASM_INTERNAL_H__
+#define BOTAN_MP_ASM_INTERNAL_H__
+
+#include <botan/mp_types.h>
+
+namespace Botan {
+
+/*************************************************
+* Helper Macros for x86 Assembly                 *
+*************************************************/
+#define ASM(x) x "\n\t"
+
+#define ADDSUB2_OP(OPERATION, INDEX)                    \
+        ASM("movl 4*" INDEX "(%[y]), %[carry]")         \
+        ASM(OPERATION " %[carry], 4*" INDEX "(%[x])")   \
+
+#define ADDSUB3_OP(OPERATION, INDEX)                    \
+        ASM("movl 4*" INDEX "(%[x]), %[carry]")         \
+        ASM(OPERATION " 4*" INDEX "(%[y]), %[carry]")   \
+        ASM("movl %[carry], 4*" INDEX "(%[z])")         \
+
+#define LINMUL_OP(WRITE_TO, INDEX)                      \
+        ASM("movl 4*" INDEX "(%[x]),%%eax")             \
+        ASM("mull %[y]")                                \
+        ASM("addl %[carry],%%eax")                      \
+        ASM("adcl $0,%%edx")                            \
+        ASM("movl %%edx,%[carry]")                      \
+        ASM("movl %%eax, 4*" INDEX "(%[" WRITE_TO "])")
+
+#define MULADD_OP(IGNORED, INDEX)                       \
+        ASM("movl 4*" INDEX "(%[x]),%%eax")             \
+        ASM("mull %[y]")                                \
+        ASM("addl %[carry],%%eax")                      \
+        ASM("adcl $0,%%edx")                            \
+        ASM("addl 4*" INDEX "(%[z]),%%eax")             \
+        ASM("adcl $0,%%edx")                            \
+        ASM("movl %%edx,%[carry]")                      \
+        ASM("movl %%eax, 4*" INDEX " (%[z])")
+
+#define DO_8_TIMES(MACRO, ARG) \
+        MACRO(ARG, "0") MACRO(ARG, "1") MACRO(ARG, "2") MACRO(ARG, "3") \
+        MACRO(ARG, "4") MACRO(ARG, "5") MACRO(ARG, "6") MACRO(ARG, "7")
+
+#define ADD_OR_SUBTRACT(CORE_CODE)     \
+        ASM("rorl %[carry]")           \
+        CORE_CODE                      \
+        ASM("sbbl %[carry],%[carry]")  \
+        ASM("negl %[carry]")
+
+/*************************************************
+* Word Addition                                  *
+*************************************************/
+inline word word_add(word x, word y, word* carry)
+   {
+   asm(
+      ADD_OR_SUBTRACT(ASM("adcl %[y],%[x]"))
+      : [x]"=r"(x), [carry]"=r"(*carry)
+      : "0"(x), [y]"rm"(y), "1"(*carry)
+      : "cc");
+   return x;
+   }
+
+/*************************************************
+* Eight Word Block Addition, Two Argument        *
+*************************************************/
+inline word word8_add2(word x[8], const word y[8], word carry)
+   {
+   asm(
+      ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB2_OP, "adcl"))
+      : [carry]"=r"(carry)
+      : [x]"r"(x), [y]"r"(y), "0"(carry)
+      : "cc", "memory");
+   return carry;
+   }
+
+/*************************************************
+* Eight Word Block Addition, Three Argument      *
+*************************************************/
+inline word word8_add3(word z[8], const word x[8], const word y[8], word carry)
+   {
+   asm(
+      ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB3_OP, "adcl"))
+      : [carry]"=r"(carry)
+      : [x]"r"(x), [y]"r"(y), [z]"r"(z), "0"(carry)
+      : "cc", "memory");
+   return carry;
+   }
+
+/*************************************************
+* Word Subtraction                               *
+*************************************************/
+inline word word_sub(word x, word y, word* carry)
+   {
+   asm(
+      ADD_OR_SUBTRACT(ASM("sbbl %[y],%[x]"))
+      : [x]"=r"(x), [carry]"=r"(*carry)
+      : "0"(x), [y]"rm"(y), "1"(*carry)
+      : "cc");
+   return x;
+   }
+
+/*************************************************
+* Eight Word Block Subtraction, Two Argument     *
+*************************************************/
+inline word word8_sub2(word x[8], const word y[8], word carry)
+   {
+   asm(
+      ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB2_OP, "sbbl"))
+      : [carry]"=r"(carry)
+      : [x]"r"(x), [y]"r"(y), "0"(carry)
+      : "cc", "memory");
+   return carry;
+   }
+
+/*************************************************
+* Eight Word Block Subtraction, Three Argument   *
+*************************************************/
+inline word word8_sub3(word z[8], const word x[8], const word y[8], word carry)
+   {
+   asm(
+      ADD_OR_SUBTRACT(DO_8_TIMES(ADDSUB3_OP, "sbbl"))
+      : [carry]"=r"(carry)
+      : [x]"r"(x), [y]"r"(y), [z]"r"(z), "0"(carry)
+      : "cc", "memory");
+   return carry;
+   }
+
+/*************************************************
+* Eight Word Block Linear Multiplication         *
+*************************************************/
+inline word word8_linmul2(word x[8], word y, word carry)
+   {
+   asm(
+      DO_8_TIMES(LINMUL_OP, "x")
+      : [carry]"=r"(carry)
+      : [x]"r"(x), [y]"rm"(y), "0"(carry)
+      : "cc", "%eax", "%edx");
+   return carry;
+   }
+
+/*************************************************
+* Eight Word Block Linear Multiplication          *
+*************************************************/
+inline word word8_linmul3(word z[8], const word x[8], word y, word carry)
+   {
+   asm(
+      DO_8_TIMES(LINMUL_OP, "z")
+      : [carry]"=r"(carry)
+      : [z]"r"(z), [x]"r"(x), [y]"rm"(y), "0"(carry)
+      : "cc", "%eax", "%edx");
+   return carry;
+   }
+
+/*************************************************
+* Eight Word Block Multiply/Add                  *
+*************************************************/
+inline word word8_madd3(word z[8], const word x[8], word y, word carry)
+   {
+   asm(
+      DO_8_TIMES(MULADD_OP, "")
+      : [carry]"=r"(carry)
+      : [z]"r"(z), [x]"r"(x), [y]"rm"(y), "0"(carry)
+      : "cc", "%eax", "%edx");
+   return carry;
+   }
+
+}
+
+#endif
diff --git a/modules/mp_ia32_msvc/modinfo.txt b/modules/mp_ia32_msvc/modinfo.txt
new file mode 100644
index 000000000..835a68d9f
--- /dev/null
+++ b/modules/mp_ia32_msvc/modinfo.txt
@@ -0,0 +1,13 @@
+realname "MPI Assembler Backend for x86 Systems"
+
+mp_bits 32
+
+replace_file mp_asmi.h
+
+<arch>
+ia32
+</arch>
+
+<cc>
+msvc
+</cc>
diff --git a/modules/mp_ia32_msvc/mp_asmi.h b/modules/mp_ia32_msvc/mp_asmi.h
new file mode 100644
index 000000000..ad1451010
--- /dev/null
+++ b/modules/mp_ia32_msvc/mp_asmi.h
@@ -0,0 +1,486 @@
+/*************************************************
+* Lowest Level MPI Algorithms Header File        *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_MP_ASM_INTERNAL_H__
+#define BOTAN_MP_ASM_INTERNAL_H__
+
+#include <botan/mp_asm.h>
+
+namespace Botan {
+
+extern "C" {
+
+/*************************************************
+* Word Addition                                  *
+*************************************************/
+inline word word_add(word x, word y, word* carry)
+   {
+   word z = x + y;
+   word c1 = (z < x);
+   z += *carry;
+   *carry = c1 | (z < *carry);
+   return z;
+   }
+
+/*************************************************
+* Four Word Block Addition, Two Argument         *
+*************************************************/
+inline word word4_addcarry(word x[4], word carry)
+   {
+      __asm {
+       mov edx,[x]
+       xor eax,eax
+       sub eax,[carry] //force CF=1 iff *carry==1
+       adc [edx],0
+       mov eax,[esi+4]      
+       adc [edx+4],0
+       mov eax,[esi+8]
+       adc [edx+8],0
+       mov eax,[esi+12]     
+       adc [edx+12],0
+       sbb eax,eax
+       neg eax
+   }
+   }
+
+   /*************************************************
+* Four Word Block Addition, Two Argument         *
+*************************************************/
+inline word word8_add2(word x[8], const word y[8], word carry)
+   {
+      __asm {
+       mov edx,[x]
+       mov esi,[y]
+       xor eax,eax
+       sub eax,[carry] //force CF=1 iff *carry==1
+       mov eax,[esi]        
+       adc [edx],eax
+       mov eax,[esi+4]      
+       adc [edx+4],eax
+       mov eax,[esi+8]
+       adc [edx+8],eax
+       mov eax,[esi+12]     
+       adc [edx+12],eax
+       mov eax,[esi+16]
+       adc [edx+16],eax
+       mov eax,[esi+20]     
+       adc [edx+20],eax
+       mov eax,[esi+24]     
+       adc [edx+24],eax
+       mov eax,[esi+28]     
+       adc [edx+28],eax
+       sbb eax,eax
+       neg eax
+   }
+   }
+
+/*************************************************
+* Four Word Block Addition, Three Argument       *
+*************************************************/
+inline word word8_add3(word z[8], const word x[8], const word y[8], word carry)
+   {
+       __asm {
+       mov edi,[x]
+       mov esi,[y]
+       mov ebx,[z]
+       xor eax,eax
+       sub eax,[carry] //force CF=1 iff *carry==1
+       mov eax,[edi]        
+       adc eax,[esi]
+       mov [ebx],eax
+
+       mov eax,[edi+4]      
+       adc eax,[esi+4]
+       mov [ebx+4],eax
+
+       mov eax,[edi+8]      
+       adc eax,[esi+8]
+       mov [ebx+8],eax
+
+       mov eax,[edi+12]     
+       adc eax,[esi+12]
+       mov [ebx+12],eax
+
+       mov eax,[edi+16]     
+       adc eax,[esi+16]
+       mov [ebx+16],eax
+
+       mov eax,[edi+20]     
+       adc eax,[esi+20]
+       mov [ebx+20],eax
+
+       mov eax,[edi+24]     
+       adc eax,[esi+24]
+       mov [ebx+24],eax
+
+       mov eax,[edi+28]     
+       adc eax,[esi+28]
+       mov [ebx+28],eax
+
+       sbb eax,eax
+       neg eax
+       }
+   }
+
+/*************************************************
+* Word Subtraction                               *
+*************************************************/
+inline word word_sub(word x, word y, word* carry)
+   {
+   word t0 = x - y;
+   word c1 = (t0 > x);
+   word z = t0 - *carry;
+   *carry = c1 | (z > t0);
+   return z;
+   }
+
+/*************************************************
+* Four Word Block Subtraction, Two Argument      *
+*************************************************/
+inline word word8_sub2(word x[8], const word y[8], word carry)
+   {
+    _asm {
+       mov edi,[x]
+       mov esi,[y]
+       xor eax,eax
+       sub eax,[carry] //force CF=1 iff *carry==1
+       mov eax,[edi]        
+       sbb eax,[esi]
+       mov [edi],eax
+       mov eax,[edi+4]      
+       sbb eax,[esi+4]
+       mov [edi+4],eax
+       mov eax,[edi+8]      
+       sbb eax,[esi+8]
+       mov [edi+8],eax
+       mov eax,[edi+12]     
+       sbb eax,[esi+12]
+       mov [edi+12],eax
+       mov eax,[edi+16]
+       sbb eax,[esi+16]
+       mov [edi+16],eax
+       mov eax,[edi+20]     
+       sbb eax,[esi+20]
+       mov [edi+20],eax
+       mov eax,[edi+24]     
+       sbb eax,[esi+24]
+       mov [edi+24],eax
+       mov eax,[edi+28]     
+       sbb eax,[esi+28]
+       mov [edi+28],eax
+       sbb eax,eax
+       neg eax
+    }
+   }
+
+/*************************************************
+* Four Word Block Subtraction, Three Argument    *
+*************************************************/
+__forceinline word word8_sub3(word z[8], const word x[8],
+                              const word y[8], word carry)
+   {
+   __asm
+      {
+      mov edi,[x]
+       mov esi,[y]
+       xor eax,eax
+       sub eax,[carry] //force CF=1 iff *carry==1
+       mov ebx,[z]
+       mov eax,[edi]
+       sbb eax,[esi]
+       mov [ebx],eax
+       mov eax,[edi+4]
+       sbb eax,[esi+4]
+       mov [ebx+4],eax
+       mov eax,[edi+8]      
+       sbb eax,[esi+8]
+       mov [ebx+8],eax
+       mov eax,[edi+12]     
+       sbb eax,[esi+12]
+       mov [ebx+12],eax
+       mov eax,[edi+16]     
+       sbb eax,[esi+16]
+       mov [ebx+16],eax
+       mov eax,[edi+20]     
+       sbb eax,[esi+20]
+       mov [ebx+20],eax
+       mov eax,[edi+24]     
+       sbb eax,[esi+24]
+       mov [ebx+24],eax
+       mov eax,[edi+28]     
+       sbb eax,[esi+28]
+       mov [ebx+28],eax
+       sbb eax,eax
+       neg eax
+       }
+   }
+
+/*************************************************
+* Four Word Block Linear Multiplication          *
+*************************************************/
+inline word word4_linmul2(word x[4], word y, word carry)
+{
+   __asm
+   {
+       mov esi,[x]
+       mov eax,[esi]        //load a
+       mul [y]           //edx(hi):eax(lo)=a*b
+       add eax,[carry]      //sum lo carry
+       adc edx,0          //sum hi carry
+       mov ecx,edx      //store carry
+       mov [esi],eax        //load a
+
+       mov eax,[esi+4]        //load a
+       mul [y]           //edx(hi):eax(lo)=a*b
+       add eax,ecx      //sum lo carry
+       adc edx,0          //sum hi carry
+       mov ecx,edx      //store carry
+       mov [esi+4],eax        //load a
+
+       mov eax,[esi+8]        //load a
+       mul [y]           //edx(hi):eax(lo)=a*b
+       add eax,ecx      //sum lo carry
+       adc edx,0          //sum hi carry
+       mov ecx,edx      //store carry
+       mov [esi+8],eax        //load a
+
+       mov eax,[esi+12]        //load a
+       mul [y]           //edx(hi):eax(lo)=a*b
+       add eax,ecx      //sum lo carry
+       adc edx,0          //sum hi carry
+       mov [esi+12],eax        //load a
+       mov eax,edx      //store carry
+   }
+   }
+
+/*************************************************
+* Eight Word Block Linear Multiplication          *
+*************************************************/
+
+__forceinline word word8_muladd(word z[8], const word x[8], word y, word carry)
+   {
+   __asm
+   {
+       mov esi,[x]
+       mov ebx,[y]
+       mov edi,[z]
+       mov eax,[esi]     //load a
+       mul ebx           //edx(hi):eax(lo)=a*b
+       add eax,[carry]   //sum lo carry
+       adc edx,0         //sum hi carry
+       add eax,[edi]     //sum lo z
+       adc edx,0         //sum hi z
+       mov ecx,edx       //carry for next block = hi z
+       mov [edi],eax     //save lo z
+
+       mov eax,[esi+4]   
+       mul ebx           
+       add eax,ecx      
+       adc edx,0        
+       add eax,[edi+4]  
+       adc edx,0        
+       mov ecx,edx      
+       mov [edi+4],eax  
+
+       mov eax,[esi+8]  
+       mul ebx          
+       add eax,ecx      
+       adc edx,0        
+       add eax,[edi+8]  
+       adc edx,0        
+       mov ecx,edx      
+       mov [edi+8],eax  
+
+       mov eax,[esi+12] 
+       mul ebx          
+       add eax,ecx      
+       adc edx,0        
+       add eax,[edi+12] 
+       adc edx,0        
+       mov ecx,edx      
+       mov [edi+12],eax 
+
+       mov eax,[esi+16] 
+       mul ebx          
+       add eax,ecx      
+       adc edx,0        
+       add eax,[edi+16] 
+       adc edx,0        
+       mov ecx,edx      
+       mov [edi+16],eax 
+
+       mov eax,[esi+20] 
+       mul ebx          
+       add eax,ecx      
+       adc edx,0        
+       add eax,[edi+20] 
+       adc edx,0        
+       mov ecx,edx      
+       mov [edi+20],eax 
+
+       mov eax,[esi+24] 
+       mul ebx          
+       add eax,ecx      
+       adc edx,0        
+       add eax,[edi+24] 
+       adc edx,0        
+       mov ecx,edx      
+       mov [edi+24],eax 
+
+       mov eax,[esi+28] 
+       mul ebx          
+       add eax,ecx      
+       adc edx,0        
+       add eax,[edi+28] 
+       adc edx,0        
+       mov [edi+28],eax 
+       mov eax,edx      
+   }
+   }
+
+__forceinline word word8_linmul3(word z[4], const word x[4], word y, word carry)
+   {
+   __asm
+   {
+#if 0
+        //it's slower!!!
+       mov edx,[z]
+       mov eax,[x]
+        movd mm7,[y]
+
+        movd mm0,[eax]
+        movd mm1,[eax+4]
+        movd mm2,[eax+8]
+        pmuludq mm0,mm7
+        pmuludq mm1,mm7
+        pmuludq mm2,mm7
+
+        movd mm6,[carry]
+        paddq mm0,mm6
+        movd [edx],mm0
+
+        psrlq mm0,32
+        paddq mm1,mm0
+        movd [edx+4],mm1
+
+        movd mm3,[eax+12]
+        psrlq mm1,32
+        paddq mm2,mm1
+        movd [edx+8],mm2
+
+        pmuludq mm3,mm7
+        movd mm4,[eax+16]
+        psrlq mm2,32
+        paddq mm3,mm2
+        movd [edx+12],mm3
+
+        pmuludq mm4,mm7
+        movd mm5,[eax+20]
+        psrlq mm3,32
+        paddq mm4,mm3
+        movd [edx+16],mm4
+
+        pmuludq mm5,mm7
+        movd mm0,[eax+24]
+        psrlq mm4,32
+        paddq mm5,mm4
+        movd [edx+20],mm5
+
+        pmuludq mm0,mm7
+        movd mm1,[eax+28]
+        psrlq mm5,32
+        paddq mm0,mm5
+        movd [edx+24],mm0
+
+        pmuludq mm1,mm7
+        psrlq mm0,32
+        paddq mm1,mm0
+        movd [edx+28],mm1
+
+        psrlq mm1,32
+        movd eax,mm1
+        emms
+#else
+       mov edi,[z]
+       mov esi,[x]
+       mov eax,[esi]        //load a
+       mul [y]           //edx(hi):eax(lo)=a*b
+       add eax,[carry]    //sum lo carry
+       adc edx,0          //sum hi carry
+       mov ecx,edx      //store carry
+       mov [edi],eax        //load a
+
+       mov eax,[esi+4]        //load a
+       mul [y]           //edx(hi):eax(lo)=a*b
+       add eax,ecx      //sum lo carry
+       adc edx,0          //sum hi carry
+       mov ecx,edx      //store carry
+       mov [edi+4],eax        //load a
+
+       mov eax,[esi+8]        //load a
+       mul [y]           //edx(hi):eax(lo)=a*b
+       add eax,ecx      //sum lo carry
+       adc edx,0          //sum hi carry
+       mov ecx,edx      //store carry
+       mov [edi+8],eax        //load a
+
+       mov eax,[esi+12]        //load a
+       mul [y]           //edx(hi):eax(lo)=a*b
+       add eax,ecx      //sum lo carry
+       adc edx,0          //sum hi carry
+       mov ecx,edx      //store carry
+       mov [edi+12],eax        //load a
+
+       mov eax,[esi+16]        //load a
+       mul [y]           //edx(hi):eax(lo)=a*b
+       add eax,ecx      //sum lo carry
+       adc edx,0          //sum hi carry
+       mov ecx,edx      //store carry
+       mov [edi+16],eax        //load a
+
+       mov eax,[esi+20]        //load a
+       mul [y]           //edx(hi):eax(lo)=a*b
+       add eax,ecx      //sum lo carry
+       adc edx,0          //sum hi carry
+       mov ecx,edx      //store carry
+       mov [edi+20],eax        //load a
+
+       mov eax,[esi+24]        //load a
+       mul [y]           //edx(hi):eax(lo)=a*b
+       add eax,ecx      //sum lo carry
+       adc edx,0          //sum hi carry
+       mov ecx,edx      //store carry
+       mov [edi+24],eax        //load a
+
+       mov eax,[esi+28]        //load a
+       mul [y]           //edx(hi):eax(lo)=a*b
+       add eax,ecx      //sum lo carry
+       adc edx,0          //sum hi carry
+       mov [edi+28],eax        //load a
+       mov eax,edx      //store carry
+#endif
+   }
+   }
+
+/*************************************************
+* Eight Word Block Multiply-Add                  *
+*************************************************/
+inline void word8_madd3(word z[], word x, const word y[], word* carry)
+   {
+   word_madd(x, y[0], z[0], *carry, z + 0, carry);
+   word_madd(x, y[1], z[1], *carry, z + 1, carry);
+   word_madd(x, y[2], z[2], *carry, z + 2, carry);
+   word_madd(x, y[3], z[3], *carry, z + 3, carry);
+   word_madd(x, y[4], z[4], *carry, z + 4, carry);
+   word_madd(x, y[5], z[5], *carry, z + 5, carry);
+   word_madd(x, y[6], z[6], *carry, z + 6, carry);
+   word_madd(x, y[7], z[7], *carry, z + 7, carry);
+   }
+
+}
+
+}
+
+#endif
diff --git a/modules/mux_pthr/modinfo.txt b/modules/mux_pthr/modinfo.txt
new file mode 100644
index 000000000..0aeca05d6
--- /dev/null
+++ b/modules/mux_pthr/modinfo.txt
@@ -0,0 +1,25 @@
+realname "Pthread Mutex"
+
+define MUTEX_PTHREAD
+
+add_file mux_pthr.cpp
+add_file mux_pthr.h
+
+<libs>
+all!qnx,freebsd,openbsd,netbsd -> pthread
+</libs>
+
+<os>
+aix
+cygwin
+darwin
+freebsd
+hpux
+irix
+linux
+netbsd
+openbsd
+qnx
+solaris
+tru64
+</os>
diff --git a/modules/mux_pthr/mux_pthr.cpp b/modules/mux_pthr/mux_pthr.cpp
new file mode 100644
index 000000000..ec2308fae
--- /dev/null
+++ b/modules/mux_pthr/mux_pthr.cpp
@@ -0,0 +1,62 @@
+/*************************************************
+* Pthread Mutex Source File                      *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/mux_pthr.h>
+#include <botan/exceptn.h>
+
+#ifndef _POSIX_C_SOURCE
+  #define _POSIX_C_SOURCE 199506
+#endif
+
+#include <pthread.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* Pthread Mutex                                  *
+*************************************************/
+class Pthread_Mutex : public Mutex
+   {
+   public:
+      void lock()
+         {
+         if(pthread_mutex_lock(&mutex) != 0)
+            throw Exception("Pthread_Mutex::lock: Error occured");
+         }
+
+      void unlock()
+         {
+         if(pthread_mutex_unlock(&mutex) != 0)
+            throw Exception("Pthread_Mutex::unlock: Error occured");
+         }
+
+      Pthread_Mutex()
+         {
+         if(pthread_mutex_init(&mutex, 0) != 0)
+            throw Exception("Pthread_Mutex: initialization failed");
+         }
+
+      ~Pthread_Mutex()
+         {
+         if(pthread_mutex_destroy(&mutex) != 0)
+            throw Invalid_State("~Pthread_Mutex: mutex is still locked");
+         }
+   private:
+      pthread_mutex_t mutex;
+   };
+
+}
+
+/*************************************************
+* Pthread Mutex Factory                          *
+*************************************************/
+Mutex* Pthread_Mutex_Factory::make()
+   {
+   return new Pthread_Mutex();
+   }
+
+}
diff --git a/modules/mux_pthr/mux_pthr.h b/modules/mux_pthr/mux_pthr.h
new file mode 100644
index 000000000..47503d390
--- /dev/null
+++ b/modules/mux_pthr/mux_pthr.h
@@ -0,0 +1,24 @@
+/*************************************************
+* Pthread Mutex Header File                      *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_MUTEX_PTHREAD_H__
+#define BOTAN_EXT_MUTEX_PTHREAD_H__
+
+#include <botan/mutex.h>
+
+namespace Botan {
+
+/*************************************************
+* Pthread Mutex Factory                          *
+*************************************************/
+class Pthread_Mutex_Factory : public Mutex_Factory
+   {
+   public:
+      Mutex* make();
+   };
+
+}
+
+#endif
diff --git a/modules/mux_win32/modinfo.txt b/modules/mux_win32/modinfo.txt
new file mode 100644
index 000000000..ed8d688b3
--- /dev/null
+++ b/modules/mux_win32/modinfo.txt
@@ -0,0 +1,11 @@
+realname "Win32 Mutex"
+
+define MUTEX_WIN32
+
+add_file mux_win32.cpp
+add_file mux_win32.h
+
+<os>
+cygwin
+windows
+</os>
diff --git a/modules/mux_win32/mux_win32.cpp b/modules/mux_win32/mux_win32.cpp
new file mode 100644
index 000000000..400aea183
--- /dev/null
+++ b/modules/mux_win32/mux_win32.cpp
@@ -0,0 +1,39 @@
+/*************************************************
+* Win32 Mutex Source File                        *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/mux_win32.h>
+#include <botan/exceptn.h>
+#include <windows.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* Win32 Mutex                                    *
+*************************************************/
+class Win32_Mutex : public Mutex
+   {
+   public:
+      void lock() { EnterCriticalSection(&mutex); }
+      void unlock() { LeaveCriticalSection(&mutex); }
+
+      Win32_Mutex() { InitializeCriticalSection(&mutex); }
+      ~Win32_Mutex() { DeleteCriticalSection(&mutex); }
+   private:
+      CRITICAL_SECTION mutex;
+   };
+
+}
+
+/*************************************************
+* Win32 Mutex Factory                            *
+*************************************************/
+Mutex* Win32_Mutex_Factory::make()
+   {
+   return new Win32_Mutex();
+   }
+
+}
diff --git a/modules/mux_win32/mux_win32.h b/modules/mux_win32/mux_win32.h
new file mode 100644
index 000000000..7ff1276aa
--- /dev/null
+++ b/modules/mux_win32/mux_win32.h
@@ -0,0 +1,23 @@
+/*************************************************
+* Win32 Mutex Header File                        *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_MUTEX_WIN32_H__
+#define BOTAN_EXT_MUTEX_WIN32_H__
+
+#include <botan/mutex.h>
+
+namespace Botan {
+
+/*************************************************
+* Win32 Mutex Factory                            *
+*************************************************/
+class Win32_Mutex_Factory : public Mutex_Factory
+   {
+   public:
+      Mutex* make();
+   };
+}
+
+#endif
diff --git a/modules/tm_hard/modinfo.txt b/modules/tm_hard/modinfo.txt
new file mode 100644
index 000000000..d03df5d30
--- /dev/null
+++ b/modules/tm_hard/modinfo.txt
@@ -0,0 +1,24 @@
+realname "Hardware Timer"
+
+define TIMER_HARDWARE
+
+add_file tm_hard.cpp
+add_file tm_hard.h
+
+<cc>
+gcc
+</cc>
+
+<arch>
+# RDTSC: Pentium and up
+i586
+i686
+athlon
+pentium4
+amd64
+
+ppc   # PPC timebase register
+ppc64 # PPC timebase register
+alpha # rpcc
+sparc64 # %tick register
+</arch>
diff --git a/modules/tm_hard/tm_hard.cpp b/modules/tm_hard/tm_hard.cpp
new file mode 100644
index 000000000..0005f79c2
--- /dev/null
+++ b/modules/tm_hard/tm_hard.cpp
@@ -0,0 +1,41 @@
+/*************************************************
+* Hardware Timer Source File                     *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/tm_hard.h>
+#include <botan/config.h>
+
+namespace Botan {
+
+/*************************************************
+* Get the timestamp                              *
+*************************************************/
+u64bit Hardware_Timer::clock() const
+   {
+   u64bit rtc = 0;
+
+#if !defined(__GNUC__)
+   #error "This module uses GCC-style inline asm"
+#endif
+
+#if defined(BOTAN_TARGET_ARCH_IS_IA32) || defined(BOTAN_TARGET_ARCH_IS_AMD64)
+   u32bit rtc_low = 0, rtc_high = 0;
+   asm volatile("rdtsc" : "=d" (rtc_high), "=a" (rtc_low));
+   rtc = ((u64bit)rtc_high << 32) | rtc_low;
+#elif defined(BOTAN_TARGET_ARCH_IS_PPC) || defined(BOTAN_TARGET_ARCH_IS_PPC64)
+   u32bit rtc_low = 0, rtc_high = 0;
+   asm volatile("mftbu %0; mftb %1" : "=r" (rtc_high), "=r" (rtc_low));
+   rtc = ((u64bit)rtc_high << 32) | rtc_low;
+#elif defined(BOTAN_TARGET_ARCH_IS_ALPHA)
+   asm volatile("rpcc %0" : "=r" (rtc));
+#elif defined(BOTAN_TARGET_ARCH_IS_SPARC64)
+   asm volatile("rd %%tick, %0" : "=r" (rtc));
+#else
+   #error "Unsure how to access hardware timer on this system"
+#endif
+
+   return rtc;
+   }
+
+}
diff --git a/modules/tm_hard/tm_hard.h b/modules/tm_hard/tm_hard.h
new file mode 100644
index 000000000..017bc5cad
--- /dev/null
+++ b/modules/tm_hard/tm_hard.h
@@ -0,0 +1,24 @@
+/*************************************************
+* Hardware Timer Header File                     *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_TIMER_HARDWARE_H__
+#define BOTAN_EXT_TIMER_HARDWARE_H__
+
+#include <botan/timers.h>
+
+namespace Botan {
+
+/*************************************************
+* Hardware Timer                                 *
+*************************************************/
+class Hardware_Timer : public Timer
+   {
+   public:
+      u64bit clock() const;
+   };
+
+}
+
+#endif
diff --git a/modules/tm_posix/modinfo.txt b/modules/tm_posix/modinfo.txt
new file mode 100644
index 000000000..df8d63122
--- /dev/null
+++ b/modules/tm_posix/modinfo.txt
@@ -0,0 +1,19 @@
+realname "POSIX Timer"
+
+define TIMER_POSIX
+
+add_file tm_posix.cpp
+add_file tm_posix.h
+
+<libs>
+linux -> rt
+</libs>
+
+# The *BSDs put clock_gettime in sys/time.h, not time.h like POSIX says
+<os>
+cygwin
+linux
+#freebsd
+#netbsd
+#openbsd
+</os>
diff --git a/modules/tm_posix/tm_posix.cpp b/modules/tm_posix/tm_posix.cpp
new file mode 100644
index 000000000..bec82bc41
--- /dev/null
+++ b/modules/tm_posix/tm_posix.cpp
@@ -0,0 +1,31 @@
+/*************************************************
+* POSIX Timer Source File                        *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/tm_posix.h>
+#include <botan/util.h>
+
+#ifndef _POSIX_C_SOURCE
+  #define _POSIX_C_SOURCE 199309
+#endif
+
+#include <time.h>
+
+#ifndef CLOCK_REALTIME
+  #define CLOCK_REALTIME 0
+#endif
+
+namespace Botan {
+
+/*************************************************
+* Get the timestamp                              *
+*************************************************/
+u64bit POSIX_Timer::clock() const
+   {
+   struct timespec tv;
+   clock_gettime(CLOCK_REALTIME, &tv);
+   return combine_timers(tv.tv_sec, tv.tv_nsec, 1000000000);
+   }
+
+}
diff --git a/modules/tm_posix/tm_posix.h b/modules/tm_posix/tm_posix.h
new file mode 100644
index 000000000..9a921ab3e
--- /dev/null
+++ b/modules/tm_posix/tm_posix.h
@@ -0,0 +1,24 @@
+/*************************************************
+* POSIX Timer Header File                        *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_TIMER_POSIX_H__
+#define BOTAN_EXT_TIMER_POSIX_H__
+
+#include <botan/timers.h>
+
+namespace Botan {
+
+/*************************************************
+* POSIX Timer                                    *
+*************************************************/
+class POSIX_Timer : public Timer
+   {
+   public:
+      u64bit clock() const;
+   };
+
+}
+
+#endif
diff --git a/modules/tm_unix/modinfo.txt b/modules/tm_unix/modinfo.txt
new file mode 100644
index 000000000..78400fbc9
--- /dev/null
+++ b/modules/tm_unix/modinfo.txt
@@ -0,0 +1,22 @@
+realname "Unix Timer"
+
+define TIMER_UNIX
+
+add_file tm_unix.cpp
+add_file tm_unix.h
+
+<os>
+aix
+beos
+cygwin
+darwin
+freebsd
+hpux
+irix
+linux
+netbsd
+openbsd
+qnx
+solaris
+tru64
+</os>
diff --git a/modules/tm_unix/tm_unix.cpp b/modules/tm_unix/tm_unix.cpp
new file mode 100644
index 000000000..3cf6928be
--- /dev/null
+++ b/modules/tm_unix/tm_unix.cpp
@@ -0,0 +1,22 @@
+/*************************************************
+* Unix Timer Source File                         *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/tm_unix.h>
+#include <botan/util.h>
+#include <sys/time.h>
+
+namespace Botan {
+
+/*************************************************
+* Get the timestamp                              *
+*************************************************/
+u64bit Unix_Timer::clock() const
+   {
+   struct timeval tv;
+   gettimeofday(&tv, 0);
+   return combine_timers(tv.tv_sec, tv.tv_usec, 1000000);
+   }
+
+}
diff --git a/modules/tm_unix/tm_unix.h b/modules/tm_unix/tm_unix.h
new file mode 100644
index 000000000..2c14cb2d0
--- /dev/null
+++ b/modules/tm_unix/tm_unix.h
@@ -0,0 +1,24 @@
+/*************************************************
+* Unix Timer Header File                         *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_TIMER_UNIX_H__
+#define BOTAN_EXT_TIMER_UNIX_H__
+
+#include <botan/timers.h>
+
+namespace Botan {
+
+/*************************************************
+* Unix Timer                                     *
+*************************************************/
+class Unix_Timer : public Timer
+   {
+   public:
+      u64bit clock() const;
+   };
+
+}
+
+#endif
diff --git a/modules/tm_win32/modinfo.txt b/modules/tm_win32/modinfo.txt
new file mode 100644
index 000000000..db9c4d9b8
--- /dev/null
+++ b/modules/tm_win32/modinfo.txt
@@ -0,0 +1,15 @@
+realname "Win32 Timer"
+
+define TIMER_WIN32
+
+add_file tm_win32.cpp
+add_file tm_win32.h
+
+<os>
+cygwin
+windows
+</os>
+
+<libs>
+windows -> user32
+</libs>
diff --git a/modules/tm_win32/tm_win32.cpp b/modules/tm_win32/tm_win32.cpp
new file mode 100644
index 000000000..1f4a33bf4
--- /dev/null
+++ b/modules/tm_win32/tm_win32.cpp
@@ -0,0 +1,21 @@
+/*************************************************
+* Win32 Timer Source File                        *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#include <botan/tm_win32.h>
+#include <windows.h>
+
+namespace Botan {
+
+/*************************************************
+* Get the timestamp                              *
+*************************************************/
+u64bit Win32_Timer::clock() const
+   {
+   LARGE_INTEGER tv;
+   ::QueryPerformanceCounter(&tv);
+   return tv.QuadPart;
+   }
+
+}
diff --git a/modules/tm_win32/tm_win32.h b/modules/tm_win32/tm_win32.h
new file mode 100644
index 000000000..ec4175d2d
--- /dev/null
+++ b/modules/tm_win32/tm_win32.h
@@ -0,0 +1,24 @@
+/*************************************************
+* Win32 Timer Header File                        *
+* (C) 1999-2006 The Botan Project                *
+*************************************************/
+
+#ifndef BOTAN_EXT_TIMER_WIN32_H__
+#define BOTAN_EXT_TIMER_WIN32_H__
+
+#include <botan/timers.h>
+
+namespace Botan {
+
+/*************************************************
+* Win32 Timer                                    *
+*************************************************/
+class Win32_Timer : public Timer
+   {
+   public:
+      u64bit clock() const;
+   };
+
+}
+
+#endif