propagate from branch 'net.randombit.botan' (head 23f95467137a0531f74574d1e3eb822734f0c5f2)

            to branch 'net.randombit.botan.c++0x' (head 427be8496e669880b1bf532eb829ebbdbeaf34c9)

118 files changed, 621 insertions, 1640 deletions

diff --git a/src/algo_factory/algo_cache.h b/src/algo_factory/algo_cache.h
index 08b25cd47..09bbc4b5a 100644
--- a/src/algo_factory/algo_cache.h
+++ b/src/algo_factory/algo_cache.h
@@ -8,8 +8,9 @@
 #ifndef BOTAN_ALGORITHM_CACHE_TEMPLATE_H__
 #define BOTAN_ALGORITHM_CACHE_TEMPLATE_H__
 
-#include <botan/mutex.h>
+#include <botan/types.h>
 #include <botan/stl_util.h>
+#include <mutex>
 #include <string>
 #include <vector>
 #include <map>
@@ -50,17 +51,12 @@ class Algorithm_Cache
       */
       std::vector<std::string> providers_of(const std::string& algo_name);
 
-      Algorithm_Cache(Mutex* m) : mutex(m) {}
       ~Algorithm_Cache();
    private:
-      typedef typename std::map<std::string, std::map<std::string, T*> >::iterator
-         algorithms_iterator;
+      typename std::map<std::string, std::map<std::string, T*> >::const_iterator
+         find_algorithm(const std::string& algo_spec);
 
-      typedef typename std::map<std::string, T*>::iterator provider_iterator;
-
-      algorithms_iterator find_algorithm(const std::string& algo_spec);
-
-      Mutex* mutex;
+      std::mutex mutex;
       std::map<std::string, std::string> aliases;
       std::map<std::string, std::string> pref_providers;
       std::map<std::string, std::map<std::string, T*> > algorithms;
@@ -71,16 +67,15 @@ class Algorithm_Cache
 * Assumes object lock is held
 */
 template<typename T>
-typename Algorithm_Cache<T>::algorithms_iterator
+typename std::map<std::string, std::map<std::string, T*> >::const_iterator
 Algorithm_Cache<T>::find_algorithm(const std::string& algo_spec)
    {
-   algorithms_iterator algo = algorithms.find(algo_spec);
+   auto algo = algorithms.find(algo_spec);
 
    // Not found? Check if a known alias
    if(algo == algorithms.end())
       {
-      std::map<std::string, std::string>::const_iterator alias =
-         aliases.find(algo_spec);
+      auto alias = aliases.find(algo_spec);
 
       if(alias != aliases.end())
          algo = algorithms.find(alias->second);
@@ -96,16 +91,16 @@ template<typename T>
 const T* Algorithm_Cache<T>::get(const std::string& algo_spec,
                                  const std::string& requested_provider)
    {
-   Mutex_Holder lock(mutex);
+   std::lock_guard<std::mutex> lock(mutex);
 
-   algorithms_iterator algo = find_algorithm(algo_spec);
+   auto algo = find_algorithm(algo_spec);
    if(algo == algorithms.end()) // algo not found at all (no providers)
       return 0;
 
    // If a provider is requested specifically, return it or fail entirely
    if(requested_provider != "")
       {
-      provider_iterator prov = algo->second.find(requested_provider);
+      auto prov = algo->second.find(requested_provider);
       if(prov != algo->second.end())
          return prov->second;
       return 0;
@@ -117,7 +112,7 @@ const T* Algorithm_Cache<T>::get(const std::string& algo_spec,
 
    const std::string pref_provider = search_map(pref_providers, algo_spec);
 
-   for(provider_iterator i = algo->second.begin(); i != algo->second.end(); ++i)
+   for(auto i = algo->second.begin(); i != algo->second.end(); ++i)
       {
       const std::string prov_name = i->first;
       const u32bit prov_weight = static_provider_weight(prov_name);
@@ -148,7 +143,7 @@ void Algorithm_Cache<T>::add(T* algo,
    if(!algo)
       return;
 
-   Mutex_Holder lock(mutex);
+   std::lock_guard<std::mutex> lock(mutex);
 
    delete algorithms[algo->name()][provider];
    algorithms[algo->name()][provider] = algo;
@@ -166,15 +161,14 @@ void Algorithm_Cache<T>::add(T* algo,
 template<typename T> std::vector<std::string>
 Algorithm_Cache<T>::providers_of(const std::string& algo_name)
    {
-   Mutex_Holder lock(mutex);
+   std::lock_guard<std::mutex> lock(mutex);
 
    std::vector<std::string> providers;
 
-   algorithms_iterator algo = find_algorithm(algo_name);
-
+   auto algo = find_algorithm(algo_name);
    if(algo != algorithms.end())
       {
-      provider_iterator provider = algo->second.begin();
+      auto provider = algo->second.begin();
 
       while(provider != algo->second.end())
          {
@@ -193,7 +187,7 @@ template<typename T>
 void Algorithm_Cache<T>::set_preferred_provider(const std::string& algo_spec,
                                                 const std::string& provider)
    {
-   Mutex_Holder lock(mutex);
+   std::lock_guard<std::mutex> lock(mutex);
 
    pref_providers[algo_spec] = provider;
    }
@@ -204,11 +198,11 @@ void Algorithm_Cache<T>::set_preferred_provider(const std::string& algo_spec,
 template<typename T>
 Algorithm_Cache<T>::~Algorithm_Cache()
    {
-   algorithms_iterator algo = algorithms.begin();
+   auto algo = algorithms.begin();
 
    while(algo != algorithms.end())
       {
-      provider_iterator provider = algo->second.begin();
+      auto provider = algo->second.begin();
 
       while(provider != algo->second.end())
          {
@@ -218,8 +212,6 @@ Algorithm_Cache<T>::~Algorithm_Cache()
 
       ++algo;
       }
-
-   delete mutex;
    }
 
 }
diff --git a/src/algo_factory/algo_factory.cpp b/src/algo_factory/algo_factory.cpp
index 22915d97c..0b8422bcb 100644
--- a/src/algo_factory/algo_factory.cpp
+++ b/src/algo_factory/algo_factory.cpp
@@ -84,15 +84,14 @@ const T* factory_prototype(const std::string& algo_spec,
 /**
 * Setup caches
 */
-Algorithm_Factory::Algorithm_Factory(const std::vector<Engine*>& engines_in,
-                                     Mutex_Factory& mf)
+Algorithm_Factory::Algorithm_Factory(const std::vector<Engine*>& engines_in)
    {
    engines = engines_in;
 
-   block_cipher_cache = new Algorithm_Cache<BlockCipher>(mf.make());
-   stream_cipher_cache = new Algorithm_Cache<StreamCipher>(mf.make());
-   hash_cache = new Algorithm_Cache<HashFunction>(mf.make());
-   mac_cache = new Algorithm_Cache<MessageAuthenticationCode>(mf.make());
+   block_cipher_cache = new Algorithm_Cache<BlockCipher>();
+   stream_cipher_cache = new Algorithm_Cache<StreamCipher>();
+   hash_cache = new Algorithm_Cache<HashFunction>();
+   mac_cache = new Algorithm_Cache<MessageAuthenticationCode>();
    }
 
 /**
@@ -100,7 +99,8 @@ Algorithm_Factory::Algorithm_Factory(const std::vector<Engine*>& engines_in,
 */
 Algorithm_Factory::~Algorithm_Factory()
    {
-   std::for_each(engines.begin(), engines.end(), del_fun<Engine>());
+   for(auto i = engines.begin(); i != engines.end(); ++i)
+      delete *i;
 
    delete block_cipher_cache;
    delete stream_cipher_cache;
diff --git a/src/algo_factory/algo_factory.h b/src/algo_factory/algo_factory.h
index 73e592013..1f4b577ee 100644
--- a/src/algo_factory/algo_factory.h
+++ b/src/algo_factory/algo_factory.h
@@ -8,7 +8,7 @@
 #ifndef BOTAN_ALGORITHM_FACTORY_H__
 #define BOTAN_ALGORITHM_FACTORY_H__
 
-#include <botan/mutex.h>
+#include <botan/types.h>
 #include <string>
 #include <vector>
 
@@ -37,8 +37,7 @@ class BOTAN_DLL Algorithm_Factory
       * @param engines_in the list of engines to use
       * @param mf a mutex factory
       */
-      Algorithm_Factory(const std::vector<Engine*>& engines_in,
-                        Mutex_Factory& mf);
+      Algorithm_Factory(const std::vector<Engine*>& engines_in);
 
       /**
       * Destructor
diff --git a/src/algo_factory/info.txt b/src/algo_factory/info.txt
index 4b25c7fc5..afd350bdb 100644
--- a/src/algo_factory/info.txt
+++ b/src/algo_factory/info.txt
@@ -14,6 +14,5 @@ block
 engine
 hash
 mac
-mutex
 stream
 </requires>
diff --git a/src/alloc/alloc_mmap/mmap_mem.h b/src/alloc/alloc_mmap/mmap_mem.h
index bef166a16..30e6d9ebb 100644
--- a/src/alloc/alloc_mmap/mmap_mem.h
+++ b/src/alloc/alloc_mmap/mmap_mem.h
@@ -18,7 +18,6 @@ namespace Botan {
 class BOTAN_DLL MemoryMapping_Allocator : public Pooling_Allocator
    {
    public:
-      MemoryMapping_Allocator(Mutex* m) : Pooling_Allocator(m) {}
       std::string type() const { return "mmap"; }
    private:
       void* alloc_block(u32bit);
diff --git a/src/alloc/mem_pool/info.txt b/src/alloc/mem_pool/info.txt
index 73a548292..b57a8b647 100644
--- a/src/alloc/mem_pool/info.txt
+++ b/src/alloc/mem_pool/info.txt
@@ -4,7 +4,3 @@ load_on auto
 mem_pool.cpp
 mem_pool.h
 </add>
-
-<requires>
-mutex
-</requires>
diff --git a/src/alloc/mem_pool/mem_pool.cpp b/src/alloc/mem_pool/mem_pool.cpp
index e30a7b98a..820355678 100644
--- a/src/alloc/mem_pool/mem_pool.cpp
+++ b/src/alloc/mem_pool/mem_pool.cpp
@@ -109,7 +109,7 @@ void Pooling_Allocator::Memory_Block::free(void* ptr, u32bit blocks)
 /*
 * Pooling_Allocator Constructor
 */
-Pooling_Allocator::Pooling_Allocator(Mutex* m) : mutex(m)
+Pooling_Allocator::Pooling_Allocator()
    {
    last_used = blocks.begin();
    }
@@ -119,7 +119,6 @@ Pooling_Allocator::Pooling_Allocator(Mutex* m) : mutex(m)
 */
 Pooling_Allocator::~Pooling_Allocator()
    {
-   delete mutex;
    if(blocks.size())
       throw Invalid_State("Pooling_Allocator: Never released memory");
    }
@@ -129,7 +128,7 @@ Pooling_Allocator::~Pooling_Allocator()
 */
 void Pooling_Allocator::destroy()
    {
-   Mutex_Holder lock(mutex);
+   std::lock_guard<std::mutex> lock(mutex);
 
    blocks.clear();
 
@@ -146,7 +145,7 @@ void* Pooling_Allocator::allocate(u32bit n)
    const u32bit BITMAP_SIZE = Memory_Block::bitmap_size();
    const u32bit BLOCK_SIZE = Memory_Block::block_size();
 
-   Mutex_Holder lock(mutex);
+   std::lock_guard<std::mutex> lock(mutex);
 
    if(n <= BITMAP_SIZE * BLOCK_SIZE)
       {
@@ -183,7 +182,7 @@ void Pooling_Allocator::deallocate(void* ptr, u32bit n)
    if(ptr == 0 && n == 0)
       return;
 
-   Mutex_Holder lock(mutex);
+   std::lock_guard<std::mutex> lock(mutex);
 
    if(n > BITMAP_SIZE * BLOCK_SIZE)
       dealloc_block(ptr, n);
@@ -191,8 +190,8 @@ void Pooling_Allocator::deallocate(void* ptr, u32bit n)
       {
       const u32bit block_no = round_up(n, BLOCK_SIZE) / BLOCK_SIZE;
 
-      std::vector<Memory_Block>::iterator i =
-         std::lower_bound(blocks.begin(), blocks.end(), Memory_Block(ptr));
+      auto i = std::lower_bound(blocks.begin(), blocks.end(),
+                                Memory_Block(ptr));
 
       if(i == blocks.end() || !i->contains(ptr, block_no))
          throw Invalid_State("Pointer released to the wrong allocator");
@@ -209,7 +208,7 @@ byte* Pooling_Allocator::allocate_blocks(u32bit n)
    if(blocks.empty())
       return 0;
 
-   std::vector<Memory_Block>::iterator i = last_used;
+   auto i = last_used;
 
    do
       {
diff --git a/src/alloc/mem_pool/mem_pool.h b/src/alloc/mem_pool/mem_pool.h
index 51571405e..dd463d908 100644
--- a/src/alloc/mem_pool/mem_pool.h
+++ b/src/alloc/mem_pool/mem_pool.h
@@ -10,7 +10,7 @@
 
 #include <botan/allocate.h>
 #include <botan/exceptn.h>
-#include <botan/mutex.h>
+#include <mutex>
 #include <utility>
 #include <vector>
 
@@ -27,7 +27,7 @@ class BOTAN_DLL Pooling_Allocator : public Allocator
 
       void destroy();
 
-      Pooling_Allocator(Mutex*);
+      Pooling_Allocator();
       ~Pooling_Allocator();
    private:
       void get_more_core(u32bit);
@@ -66,7 +66,7 @@ class BOTAN_DLL Pooling_Allocator : public Allocator
       std::vector<Memory_Block> blocks;
       std::vector<Memory_Block>::iterator last_used;
       std::vector<std::pair<void*, u32bit> > allocated;
-      Mutex* mutex;
+      std::mutex mutex;
    };
 
 }
diff --git a/src/alloc/system_alloc/defalloc.h b/src/alloc/system_alloc/defalloc.h
index 627e8df70..ed2682ec0 100644
--- a/src/alloc/system_alloc/defalloc.h
+++ b/src/alloc/system_alloc/defalloc.h
@@ -30,8 +30,6 @@ class BOTAN_DLL Malloc_Allocator : public Allocator
 class BOTAN_DLL Locking_Allocator : public Pooling_Allocator
    {
    public:
-      Locking_Allocator(Mutex* m) : Pooling_Allocator(m) {}
-
       std::string type() const { return "locking"; }
    private:
       void* alloc_block(u32bit);
diff --git a/src/asn1/asn1_alt.cpp b/src/asn1/asn1_alt.cpp
index 41974eef6..401eb54e9 100644
--- a/src/asn1/asn1_alt.cpp
+++ b/src/asn1/asn1_alt.cpp
@@ -40,9 +40,8 @@ void AlternativeName::add_attribute(const std::string& type,
    if(type == "" || str == "")
       return;
 
-   typedef std::multimap<std::string, std::string>::iterator iter;
-   std::pair<iter, iter> range = alt_info.equal_range(type);
-   for(iter j = range.first; j != range.second; ++j)
+   auto range = alt_info.equal_range(type);
+   for(auto j = range.first; j != range.second; ++j)
       if(j->second == str)
          return;
 
@@ -83,13 +82,11 @@ std::multimap<std::string, std::string> AlternativeName::contents() const
    {
    std::multimap<std::string, std::string> names;
 
-   typedef std::multimap<std::string, std::string>::const_iterator rdn_iter;
-   for(rdn_iter j = alt_info.begin(); j != alt_info.end(); ++j)
-      multimap_insert(names, j->first, j->second);
+   for(auto i = alt_info.begin(); i != alt_info.end(); ++i)
+      multimap_insert(names, i->first, i->second);
 
-   typedef std::multimap<OID, ASN1_String>::const_iterator on_iter;
-   for(on_iter j = othernames.begin(); j != othernames.end(); ++j)
-      multimap_insert(names, OIDS::lookup(j->first), j->second.value());
+   for(auto i = othernames.begin(); i != othernames.end(); ++i)
+      multimap_insert(names, OIDS::lookup(i->first), i->second.value());
 
    return names;
    }
@@ -111,19 +108,18 @@ void encode_entries(DER_Encoder& encoder,
                     const std::multimap<std::string, std::string>& attr,
                     const std::string& type, ASN1_Tag tagging)
    {
-   typedef std::multimap<std::string, std::string>::const_iterator iter;
+   auto range = attr.equal_range(type);
 
-   std::pair<iter, iter> range = attr.equal_range(type);
-   for(iter j = range.first; j != range.second; ++j)
+   for(auto i = range.first; i != range.second; ++i)
       {
       if(type == "RFC822" || type == "DNS" || type == "URI")
          {
-         ASN1_String asn1_string(j->second, IA5_STRING);
+         ASN1_String asn1_string(i->second, IA5_STRING);
          encoder.add_object(tagging, CONTEXT_SPECIFIC, asn1_string.iso_8859());
          }
       else if(type == "IP")
          {
-         u32bit ip = string_to_ipv4(j->second);
+         u32bit ip = string_to_ipv4(i->second);
          byte ip_buf[4] = { 0 };
          store_be(ip, ip_buf);
          encoder.add_object(tagging, CONTEXT_SPECIFIC, ip_buf, 4);
@@ -145,8 +141,7 @@ void AlternativeName::encode_into(DER_Encoder& der) const
    encode_entries(der, alt_info, "URI", ASN1_Tag(6));
    encode_entries(der, alt_info, "IP", ASN1_Tag(7));
 
-   std::multimap<OID, ASN1_String>::const_iterator i;
-   for(i = othernames.begin(); i != othernames.end(); ++i)
+   for(auto i = othernames.begin(); i != othernames.end(); ++i)
       {
       der.start_explicit(0)
          .encode(i->first)
diff --git a/src/asn1/asn1_dn.cpp b/src/asn1/asn1_dn.cpp
index 3005e3d5e..d86edcd84 100644
--- a/src/asn1/asn1_dn.cpp
+++ b/src/asn1/asn1_dn.cpp
@@ -26,9 +26,8 @@ X509_DN::X509_DN()
 */
 X509_DN::X509_DN(const std::multimap<OID, std::string>& args)
    {
-   std::multimap<OID, std::string>::const_iterator j;
-   for(j = args.begin(); j != args.end(); ++j)
-      add_attribute(j->first, j->second);
+   for(auto i = args.begin(); i != args.end(); ++i)
+      add_attribute(i->first, i->second);
    }
 
 /*
@@ -36,9 +35,8 @@ X509_DN::X509_DN(const std::multimap<OID, std::string>& args)
 */
 X509_DN::X509_DN(const std::multimap<std::string, std::string>& args)
    {
-   std::multimap<std::string, std::string>::const_iterator j;
-   for(j = args.begin(); j != args.end(); ++j)
-      add_attribute(OIDS::lookup(j->first), j->second);
+   for(auto i = args.begin(); i != args.end(); ++i)
+      add_attribute(OIDS::lookup(i->first), i->second);
    }
 
 /*
@@ -59,11 +57,9 @@ void X509_DN::add_attribute(const OID& oid, const std::string& str)
    if(str == "")
       return;
 
-   typedef std::multimap<OID, ASN1_String>::iterator rdn_iter;
-
-   std::pair<rdn_iter, rdn_iter> range = dn_info.equal_range(oid);
-   for(rdn_iter j = range.first; j != range.second; ++j)
-      if(j->second.value() == str)
+   auto range = dn_info.equal_range(oid);
+   for(auto i = range.first; i != range.second; ++i)
+      if(i->second.value() == str)
          return;
 
    multimap_insert(dn_info, oid, ASN1_String(str));
@@ -75,11 +71,9 @@ void X509_DN::add_attribute(const OID& oid, const std::string& str)
 */
 std::multimap<OID, std::string> X509_DN::get_attributes() const
    {
-   typedef std::multimap<OID, ASN1_String>::const_iterator rdn_iter;
-
    std::multimap<OID, std::string> retval;
-   for(rdn_iter j = dn_info.begin(); j != dn_info.end(); ++j)
-      multimap_insert(retval, j->first, j->second.value());
+   for(auto i = dn_info.begin(); i != dn_info.end(); ++i)
+      multimap_insert(retval, i->first, i->second.value());
    return retval;
    }
 
@@ -88,11 +82,9 @@ std::multimap<OID, std::string> X509_DN::get_attributes() const
 */
 std::multimap<std::string, std::string> X509_DN::contents() const
    {
-   typedef std::multimap<OID, ASN1_String>::const_iterator rdn_iter;
-
    std::multimap<std::string, std::string> retval;
-   for(rdn_iter j = dn_info.begin(); j != dn_info.end(); ++j)
-      multimap_insert(retval, OIDS::lookup(j->first), j->second.value());
+   for(auto i = dn_info.begin(); i != dn_info.end(); ++i)
+      multimap_insert(retval, OIDS::lookup(i->first), i->second.value());
    return retval;
    }
 
@@ -101,14 +93,13 @@ std::multimap<std::string, std::string> X509_DN::contents() const
 */
 std::vector<std::string> X509_DN::get_attribute(const std::string& attr) const
    {
-   typedef std::multimap<OID, ASN1_String>::const_iterator rdn_iter;
-
    const OID oid = OIDS::lookup(deref_info_field(attr));
-   std::pair<rdn_iter, rdn_iter> range = dn_info.equal_range(oid);
+
+   auto range = dn_info.equal_range(oid);
 
    std::vector<std::string> values;
-   for(rdn_iter j = range.first; j != range.second; ++j)
-      values.push_back(j->second.value());
+   for(auto i = range.first; i != range.second; ++i)
+      values.push_back(i->second.value());
    return values;
    }
 
@@ -171,15 +162,13 @@ std::string X509_DN::deref_info_field(const std::string& info)
 */
 bool operator==(const X509_DN& dn1, const X509_DN& dn2)
    {
-   typedef std::multimap<OID, std::string>::const_iterator rdn_iter;
-
-   std::multimap<OID, std::string> attr1 = dn1.get_attributes();
-   std::multimap<OID, std::string> attr2 = dn2.get_attributes();
+   auto attr1 = dn1.get_attributes();
+   auto attr2 = dn2.get_attributes();
 
    if(attr1.size() != attr2.size()) return false;
 
-   rdn_iter p1 = attr1.begin();
-   rdn_iter p2 = attr2.begin();
+   auto p1 = attr1.begin();
+   auto p2 = attr2.begin();
 
    while(true)
       {
@@ -209,18 +198,15 @@ bool operator!=(const X509_DN& dn1, const X509_DN& dn2)
 */
 bool operator<(const X509_DN& dn1, const X509_DN& dn2)
    {
-   typedef std::multimap<OID, std::string>::const_iterator rdn_iter;
-
-   std::multimap<OID, std::string> attr1 = dn1.get_attributes();
-   std::multimap<OID, std::string> attr2 = dn2.get_attributes();
+   auto attr1 = dn1.get_attributes();
+   auto attr2 = dn2.get_attributes();
 
    if(attr1.size() < attr2.size()) return true;
    if(attr1.size() > attr2.size()) return false;
 
-   for(rdn_iter p1 = attr1.begin(); p1 != attr1.end(); ++p1)
+   for(auto p1 = attr1.begin(); p1 != attr1.end(); ++p1)
       {
-      std::multimap<OID, std::string>::const_iterator p2;
-      p2 = attr2.find(p1->first);
+      auto p2 = attr2.find(p1->first);
       if(p2 == attr2.end())       return false;
       if(p1->second > p2->second) return false;
       if(p1->second < p2->second) return true;
@@ -238,8 +224,6 @@ void do_ava(DER_Encoder& encoder,
             ASN1_Tag string_type, const std::string& oid_str,
             bool must_exist = false)
    {
-   typedef std::multimap<OID, std::string>::const_iterator rdn_iter;
-
    const OID oid = OIDS::lookup(oid_str);
    const bool exists = (dn_info.find(oid) != dn_info.end());
 
@@ -247,14 +231,14 @@ void do_ava(DER_Encoder& encoder,
       throw Encoding_Error("X509_DN: No entry for " + oid_str);
    if(!exists) return;
 
-   std::pair<rdn_iter, rdn_iter> range = dn_info.equal_range(oid);
+   auto range = dn_info.equal_range(oid);
 
-   for(rdn_iter j = range.first; j != range.second; ++j)
+   for(auto i = range.first; i != range.second; ++i)
       {
       encoder.start_cons(SET)
          .start_cons(SEQUENCE)
             .encode(oid)
-            .encode(ASN1_String(j->second, string_type))
+            .encode(ASN1_String(i->second, string_type))
          .end_cons()
       .end_cons();
       }
@@ -267,7 +251,7 @@ void do_ava(DER_Encoder& encoder,
 */
 void X509_DN::encode_into(DER_Encoder& der) const
    {
-   std::multimap<OID, std::string> dn_info = get_attributes();
+   auto dn_info = get_attributes();
 
    der.start_cons(SEQUENCE);
 
diff --git a/src/asn1/asn1_tm.cpp b/src/asn1/asn1_tm.cpp
index 09bc4d347..c57d1bc73 100644
--- a/src/asn1/asn1_tm.cpp
+++ b/src/asn1/asn1_tm.cpp
@@ -10,7 +10,7 @@
 #include <botan/ber_dec.h>
 #include <botan/charset.h>
 #include <botan/parsing.h>
-#include <botan/timer.h>
+#include <botan/time.h>
 
 namespace Botan {
 
diff --git a/src/asn1/ber_dec.h b/src/asn1/ber_dec.h
index 2e38af301..7de7f3753 100644
--- a/src/asn1/ber_dec.h
+++ b/src/asn1/ber_dec.h
@@ -55,14 +55,14 @@ class BOTAN_DLL BER_Decoder
       BER_Decoder& decode_optional_string(MemoryRegion<byte>&,
                                           ASN1_Tag, u16bit);
 
+      BER_Decoder& operator=(const BER_Decoder&) = delete;
+
       BER_Decoder(DataSource&);
       BER_Decoder(const byte[], u32bit);
       BER_Decoder(const MemoryRegion<byte>&);
       BER_Decoder(const BER_Decoder&);
       ~BER_Decoder();
    private:
-      BER_Decoder& operator=(const BER_Decoder&) { return (*this); }
-
       BER_Decoder* parent;
       DataSource* source;
       BER_Object pushed;
diff --git a/src/benchmark/benchmark.cpp b/src/benchmark/benchmark.cpp
index 41c9cd10c..5c812d732 100644
--- a/src/benchmark/benchmark.cpp
+++ b/src/benchmark/benchmark.cpp
@@ -1,6 +1,6 @@
 /**
 * Runtime benchmarking
-* (C) 2008 Jack Lloyd
+* (C) 2008-2009 Jack Lloyd
 *
 * Distributed under the terms of the Botan license
 */
@@ -12,31 +12,40 @@
 #include <botan/hash.h>
 #include <botan/mac.h>
 #include <memory>
+#include <vector>
+#include <chrono>
 
 namespace Botan {
 
 namespace {
 
+typedef std::chrono::high_resolution_clock benchmark_clock;
+
 /**
 * Benchmark BufferedComputation (hash or MAC)
 */
 std::pair<u64bit, u64bit> bench_buf_comp(BufferedComputation* buf_comp,
-                                         Timer& timer,
                                          u64bit nanoseconds_max,
                                          const byte buf[], u32bit buf_len)
    {
-   const u64bit start = timer.clock();
-   u64bit nanoseconds_used = 0;
    u64bit reps = 0;
 
-   while(nanoseconds_used < nanoseconds_max)
+   std::chrono::nanoseconds max_time(nanoseconds_max);
+   std::chrono::nanoseconds time_used(0);
+
+   auto start = benchmark_clock::now();
+
+   while(time_used < max_time)
       {
       buf_comp->update(buf, buf_len);
       ++reps;
-      nanoseconds_used = timer.clock() - start;
+      time_used = benchmark_clock::now() - start;
       }
 
-   return std::make_pair(reps * buf_len, nanoseconds_used);
+   u64bit ns_taken =
+      std::chrono::duration_cast<std::chrono::nanoseconds>(time_used).count();
+
+   return std::make_pair(reps * buf_len, ns_taken);
    }
 
 /**
@@ -44,28 +53,32 @@ std::pair<u64bit, u64bit> bench_buf_comp(BufferedComputation* buf_comp,
 */
 std::pair<u64bit, u64bit>
 bench_block_cipher(BlockCipher* block_cipher,
-                   Timer& timer,
                    u64bit nanoseconds_max,
                    byte buf[], u32bit buf_len)
    {
-   const u64bit start = timer.clock();
-   u64bit nanoseconds_used = 0;
+   const u32bit in_blocks = buf_len / block_cipher->BLOCK_SIZE;
+
    u64bit reps = 0;
 
-   const u32bit in_blocks = buf_len / block_cipher->BLOCK_SIZE;
+   std::chrono::nanoseconds max_time(nanoseconds_max);
+   std::chrono::nanoseconds time_used(0);
+
+   auto start = benchmark_clock::now();
 
    block_cipher->set_key(buf, block_cipher->MAXIMUM_KEYLENGTH);
 
-   while(nanoseconds_used < nanoseconds_max)
+   while(time_used < max_time)
       {
       block_cipher->encrypt_n(buf, buf, in_blocks);
-
       ++reps;
-      nanoseconds_used = timer.clock() - start;
+      time_used = benchmark_clock::now() - start;
       }
 
+   u64bit ns_taken =
+      std::chrono::duration_cast<std::chrono::nanoseconds>(time_used).count();
+
    return std::make_pair(reps * in_blocks * block_cipher->BLOCK_SIZE,
-                         nanoseconds_used);
+                         ns_taken);
    }
 
 /**
@@ -73,35 +86,40 @@ bench_block_cipher(BlockCipher* block_cipher,
 */
 std::pair<u64bit, u64bit>
 bench_stream_cipher(StreamCipher* stream_cipher,
-                    Timer& timer,
                     u64bit nanoseconds_max,
                     byte buf[], u32bit buf_len)
    {
-   const u64bit start = timer.clock();
-   u64bit nanoseconds_used = 0;
    u64bit reps = 0;
 
    stream_cipher->set_key(buf, stream_cipher->MAXIMUM_KEYLENGTH);
 
-   while(nanoseconds_used < nanoseconds_max)
+   std::chrono::nanoseconds max_time(nanoseconds_max);
+   std::chrono::nanoseconds time_used(0);
+
+   auto start = benchmark_clock::now();
+
+   while(time_used < max_time)
       {
       stream_cipher->cipher1(buf, buf_len);
       ++reps;
-      nanoseconds_used = timer.clock() - start;
+      time_used = benchmark_clock::now() - start;
       }
 
-   return std::make_pair(reps * buf_len, nanoseconds_used);
+   u64bit ns_taken =
+      std::chrono::duration_cast<std::chrono::nanoseconds>(time_used).count();
+
+   return std::make_pair(reps * buf_len, ns_taken);
    }
 
 /**
 * Benchmark hash
 */
 std::pair<u64bit, u64bit>
-bench_hash(HashFunction* hash, Timer& timer,
+bench_hash(HashFunction* hash,
            u64bit nanoseconds_max,
            const byte buf[], u32bit buf_len)
    {
-   return bench_buf_comp(hash, timer, nanoseconds_max, buf, buf_len);
+   return bench_buf_comp(hash, nanoseconds_max, buf, buf_len);
    }
 
 /**
@@ -109,12 +127,11 @@ bench_hash(HashFunction* hash, Timer& timer,
 */
 std::pair<u64bit, u64bit>
 bench_mac(MessageAuthenticationCode* mac,
-          Timer& timer,
           u64bit nanoseconds_max,
           const byte buf[], u32bit buf_len)
    {
    mac->set_key(buf, mac->MAXIMUM_KEYLENGTH);
-   return bench_buf_comp(mac, timer, nanoseconds_max, buf, buf_len);
+   return bench_buf_comp(mac, nanoseconds_max, buf, buf_len);
    }
 
 }
@@ -122,7 +139,6 @@ bench_mac(MessageAuthenticationCode* mac,
 std::map<std::string, double>
 algorithm_benchmark(const std::string& name,
                     u32bit milliseconds,
-                    Timer& timer,
                     RandomNumberGenerator& rng,
                     Algorithm_Factory& af)
    {
@@ -148,7 +164,7 @@ algorithm_benchmark(const std::string& name,
             af.prototype_block_cipher(name, provider))
          {
          std::auto_ptr<BlockCipher> block_cipher(proto->clone());
-         results = bench_block_cipher(block_cipher.get(), timer,
+         results = bench_block_cipher(block_cipher.get(),
                                       ns_per_provider,
                                       &buf[0], buf.size());
          }
@@ -156,7 +172,7 @@ algorithm_benchmark(const std::string& name,
                  af.prototype_stream_cipher(name, provider))
          {
          std::auto_ptr<StreamCipher> stream_cipher(proto->clone());
-         results = bench_stream_cipher(stream_cipher.get(), timer,
+         results = bench_stream_cipher(stream_cipher.get(),
                                        ns_per_provider,
                                        &buf[0], buf.size());
          }
@@ -164,14 +180,14 @@ algorithm_benchmark(const std::string& name,
                  af.prototype_hash_function(name, provider))
          {
          std::auto_ptr<HashFunction> hash(proto->clone());
-         results = bench_hash(hash.get(), timer, ns_per_provider,
+         results = bench_hash(hash.get(), ns_per_provider,
                               &buf[0], buf.size());
          }
       else if(const MessageAuthenticationCode* proto =
                  af.prototype_mac(name, provider))
          {
          std::auto_ptr<MessageAuthenticationCode> mac(proto->clone());
-         results = bench_mac(mac.get(), timer, ns_per_provider,
+         results = bench_mac(mac.get(), ns_per_provider,
                              &buf[0], buf.size());
          }
 
diff --git a/src/benchmark/benchmark.h b/src/benchmark/benchmark.h
index 272cfdfa2..a9c3fc01e 100644
--- a/src/benchmark/benchmark.h
+++ b/src/benchmark/benchmark.h
@@ -1,6 +1,6 @@
 /**
 * Runtime benchmarking
-* (C) 2008 Jack Lloyd
+* (C) 2008-2009 Jack Lloyd
 *
 * Distributed under the terms of the Botan license
 */
@@ -9,35 +9,12 @@
 #define BOTAN_RUNTIME_BENCHMARK_H__
 
 #include <botan/algo_factory.h>
-#include <botan/timer.h>
 #include <botan/rng.h>
 #include <map>
 #include <string>
 
-/**
-* Choose some sort of default timer implementation to use, since some
-* (like hardware tick counters and current Win32 timer) are not
-* reliable for benchmarking.
-*/
-#if defined(BOTAN_HAS_TIMER_POSIX)
-  #include <botan/tm_posix.h>
-#elif defined(BOTAN_HAS_TIMER_UNIX)
-  #include <botan/tm_unix.h>
-#endif
-
 namespace Botan {
 
-#if defined(BOTAN_HAS_TIMER_POSIX)
-  typedef POSIX_Timer Default_Benchmark_Timer;
-#elif defined(BOTAN_HAS_TIMER_UNIX)
-  typedef Unix_Timer Default_Benchmark_Timer;
-#else
-   /* I have not had good success using clock(), the results seem
-    * pretty bogus, but as a last resort it works.
-    */
-  typedef ANSI_Clock_Timer Default_Benchmark_Timer;
-#endif
-
 /**
 * Algorithm benchmark
 * @param name the name of the algorithm to test (cipher, hash, or MAC)
@@ -50,7 +27,6 @@ namespace Botan {
 std::map<std::string, double>
 algorithm_benchmark(const std::string& name,
                     u32bit milliseconds,
-                    Timer& timer,
                     RandomNumberGenerator& rng,
                     Algorithm_Factory& af);
 
diff --git a/src/benchmark/info.txt b/src/benchmark/info.txt
index f148ae5ce..0210971f7 100644
--- a/src/benchmark/info.txt
+++ b/src/benchmark/info.txt
@@ -15,5 +15,4 @@ hash
 mac
 rng
 stream
-timer
 </requires>
diff --git a/src/build-data/cc/gcc.txt b/src/build-data/cc/gcc.txt
index 3cb287f70..0b1668908 100644
--- a/src/build-data/cc/gcc.txt
+++ b/src/build-data/cc/gcc.txt
@@ -1,8 +1,6 @@
 macro_name "GCC"
 
-binary_name "g++"
-
-compiler_has_tr1 yes
+binary_name "g++-4.5-20091112"
 
 compile_option "-c "
 output_to_option "-o "
@@ -10,7 +8,7 @@ add_include_dir_option "-I"
 add_lib_dir_option "-L"
 add_lib_option "-l"
 
-lang_flags "-D_REENTRANT -ansi -Wno-long-long"
+lang_flags "-ansi -Wno-long-long -std=c++0x"
 warning_flags "-W -Wall"
 #warning_flags "-Wextra -Wall -Wstrict-aliasing -Wstrict-overflow=5 -Wcast-align -Wmissing-declarations -Wno-unused-parameter"
 
@@ -72,6 +70,8 @@ ppc64     -> "-mcpu=SUBMODEL" ppc
 
 # Note that the 'linking' bit means "use this for both compiling *and* linking"
 <mach_abi_linking>
+all     -> "-pthread"
+
 amd64   -> "-m64"
 mips64  -> "-mabi=64"
 s390    -> "-m31"
@@ -80,10 +80,6 @@ sparc32 -> "-m32 -mno-app-regs"
 sparc64 -> "-m64 -mno-app-regs"
 ppc64   -> "-m64"
 
-# This should probably be used on most/all targets, but the docs are incomplete
-openbsd -> "-pthread"
-freebsd -> "-pthread"
-dragonfly -> "-pthread"
-netbsd  -> "-pthread -D_NETBSD_SOURCE"
+netbsd  -> "-D_NETBSD_SOURCE"
 qnx     -> "-fexceptions -D_QNX_SOURCE"
 </mach_abi_linking>
diff --git a/src/build-data/cc/icc.txt b/src/build-data/cc/icc.txt
index b5cad542c..7187cae56 100644
--- a/src/build-data/cc/icc.txt
+++ b/src/build-data/cc/icc.txt
@@ -2,8 +2,6 @@ macro_name "INTEL"
 
 binary_name "icpc"
 
-compiler_has_tr1 yes
-
 compile_option "-c "
 output_to_option "-o "
 add_include_dir_option "-I"
diff --git a/src/cert/cvc/asn1_eac_tm.cpp b/src/cert/cvc/asn1_eac_tm.cpp
index 947b9e66d..f361e6098 100644
--- a/src/cert/cvc/asn1_eac_tm.cpp
+++ b/src/cert/cvc/asn1_eac_tm.cpp
@@ -12,7 +12,7 @@
 #include <botan/charset.h>
 #include <botan/parsing.h>
 #include <botan/rounding.h>
-#include <botan/timer.h>
+#include <botan/time.h>
 
 namespace Botan {
 
diff --git a/src/cert/cvc/cvc_ado.cpp b/src/cert/cvc/cvc_ado.cpp
index 6e1484e90..47c972c72 100644
--- a/src/cert/cvc/cvc_ado.cpp
+++ b/src/cert/cvc/cvc_ado.cpp
@@ -12,7 +12,7 @@
 
 namespace Botan {
 
-EAC1_1_ADO::EAC1_1_ADO(std::tr1::shared_ptr<DataSource> in)
+EAC1_1_ADO::EAC1_1_ADO(std::shared_ptr<DataSource> in)
    {
    init(in);
    do_decode();
@@ -20,7 +20,7 @@ EAC1_1_ADO::EAC1_1_ADO(std::tr1::shared_ptr<DataSource> in)
 
 EAC1_1_ADO::EAC1_1_ADO(const std::string& in)
    {
-   std::tr1::shared_ptr<DataSource> stream(new DataSource_Stream(in, true));
+   std::shared_ptr<DataSource> stream(new DataSource_Stream(in, true));
    init(stream);
    do_decode();
    }
@@ -41,18 +41,18 @@ void EAC1_1_ADO::force_decode()
       .end_cons()
       .get_contents();
 
-   std::tr1::shared_ptr<DataSource> req_source(new DataSource_Memory(req_bits));
+   std::shared_ptr<DataSource> req_source(new DataSource_Memory(req_bits));
    m_req = EAC1_1_Req(req_source);
    sig_algo = m_req.sig_algo;
    }
 
 MemoryVector<byte> EAC1_1_ADO::make_signed(
-   std::auto_ptr<PK_Signer> signer,
+   PK_Signer& signer,
    const MemoryRegion<byte>& tbs_bits,
    RandomNumberGenerator& rng)
    {
    SecureVector<byte> concat_sig =
-      EAC1_1_obj<EAC1_1_ADO>::make_signature(signer.get(), tbs_bits, rng);
+      EAC1_1_obj<EAC1_1_ADO>::make_signature(signer, tbs_bits, rng);
    assert(concat_sig.size() % 2 == 0);
    MemoryVector<byte> result = DER_Encoder()
       .start_cons(ASN1_Tag(7), APPLICATION)
diff --git a/src/cert/cvc/cvc_ado.h b/src/cert/cvc/cvc_ado.h
index a0dbec2a6..5968b1ba4 100644
--- a/src/cert/cvc/cvc_ado.h
+++ b/src/cert/cvc/cvc_ado.h
@@ -38,7 +38,7 @@ class BOTAN_DLL EAC1_1_ADO : public EAC1_1_obj<EAC1_1_ADO>
       * Construct a CVC ADO request from a data source
       * @param source the data source
       */
-      EAC1_1_ADO(std::tr1::shared_ptr<DataSource> source);
+      EAC1_1_ADO(std::shared_ptr<DataSource> source);
 
       /**
       * Create a signed CVC ADO request from to be signed (TBS) data
@@ -46,7 +46,7 @@ class BOTAN_DLL EAC1_1_ADO : public EAC1_1_obj<EAC1_1_ADO>
       * @param tbs_bits the TBS data to sign
       */
       static MemoryVector<byte> make_signed(
-         std::auto_ptr<PK_Signer> signer,
+         PK_Signer& signer,
          const MemoryRegion<byte>& tbs_bits,
          RandomNumberGenerator& rng);
 
diff --git a/src/cert/cvc/cvc_ca.cpp b/src/cert/cvc/cvc_ca.cpp
index 8ca8db0c2..b51c1f4ff 100644
--- a/src/cert/cvc/cvc_ca.cpp
+++ b/src/cert/cvc/cvc_ca.cpp
@@ -4,7 +4,7 @@
 #include <botan/oids.h>
 namespace Botan {
 
-EAC1_1_CVC EAC1_1_CVC_CA::make_cert(std::auto_ptr<PK_Signer> signer,
+EAC1_1_CVC EAC1_1_CVC_CA::make_cert(PK_Signer& signer,
                                     MemoryRegion<byte> const& public_key,
                                     ASN1_Car const& car,
                                     ASN1_Chr const& chr,
@@ -37,7 +37,7 @@ EAC1_1_CVC EAC1_1_CVC_CA::make_cert(std::auto_ptr<PK_Signer> signer,
                               EAC1_1_CVC::build_cert_body(tbs),
                               rng);
 
-   std::tr1::shared_ptr<DataSource> source(new DataSource_Memory(signed_cert));
+   std::shared_ptr<DataSource> source(new DataSource_Memory(signed_cert));
 
    return EAC1_1_CVC(source);
    }
diff --git a/src/cert/cvc/cvc_ca.h b/src/cert/cvc/cvc_ca.h
index 3ec307bb3..87699808f 100644
--- a/src/cert/cvc/cvc_ca.h
+++ b/src/cert/cvc/cvc_ca.h
@@ -36,7 +36,7 @@ class BOTAN_DLL EAC1_1_CVC_CA
       * @param ced the CED to appear in the certificate
       * @param ced the CEX to appear in the certificate
       */
-      static EAC1_1_CVC make_cert(std::auto_ptr<PK_Signer> signer,
+      static EAC1_1_CVC make_cert(PK_Signer& signer,
                                   MemoryRegion<byte> const& public_key,
                                   ASN1_Car const& car,
                                   ASN1_Chr const& chr,
diff --git a/src/cert/cvc/cvc_cert.cpp b/src/cert/cvc/cvc_cert.cpp
index d2be12df8..5c2e28c39 100644
--- a/src/cert/cvc/cvc_cert.cpp
+++ b/src/cert/cvc/cvc_cert.cpp
@@ -61,7 +61,7 @@ void EAC1_1_CVC::force_decode()
    // FIXME: PK algos have no notion of EAC encoder/decoder currently
 #if 0
    ECDSA_PublicKey tmp_pk;
-   std::auto_ptr<EAC1_1_CVC_Decoder> dec = tmp_pk.cvc_eac1_1_decoder();
+   std::unique_ptr<EAC1_1_CVC_Decoder> dec = tmp_pk.cvc_eac1_1_decoder();
    sig_algo = dec->public_key(enc_pk);
 
 
@@ -78,7 +78,7 @@ void EAC1_1_CVC::force_decode()
 /*
 * CVC Certificate Constructor
 */
-EAC1_1_CVC::EAC1_1_CVC(std::tr1::shared_ptr<DataSource>& in)
+EAC1_1_CVC::EAC1_1_CVC(std::shared_ptr<DataSource>& in)
    {
    init(in);
    self_signed = false;
@@ -87,7 +87,7 @@ EAC1_1_CVC::EAC1_1_CVC(std::tr1::shared_ptr<DataSource>& in)
 
 EAC1_1_CVC::EAC1_1_CVC(const std::string& in)
    {
-   std::tr1::shared_ptr<DataSource> stream(new DataSource_Stream(in, true));
+   std::shared_ptr<DataSource> stream(new DataSource_Stream(in, true));
    init(stream);
    self_signed = false;
    do_decode();
diff --git a/src/cert/cvc/cvc_cert.h b/src/cert/cvc/cvc_cert.h
index 17671d332..0bc162c0c 100644
--- a/src/cert/cvc/cvc_cert.h
+++ b/src/cert/cvc/cvc_cert.h
@@ -59,7 +59,7 @@ class BOTAN_DLL EAC1_1_CVC : public EAC1_1_gen_CVC<EAC1_1_CVC>//Signed_Object
        * Construct a CVC from a data source
        * @param source the data source
        */
-       EAC1_1_CVC(std::tr1::shared_ptr<DataSource>& source);
+       EAC1_1_CVC(std::shared_ptr<DataSource>& source);
 
        /**
        * Construct a CVC from a file
diff --git a/src/cert/cvc/cvc_gen_cert.h b/src/cert/cvc/cvc_gen_cert.h
index 4a788026c..8620cd89a 100644
--- a/src/cert/cvc/cvc_gen_cert.h
+++ b/src/cert/cvc/cvc_gen_cert.h
@@ -33,7 +33,7 @@ class BOTAN_DLL EAC1_1_gen_CVC : public EAC1_1_obj<Derived> // CRTP continuation
       * Get this certificates public key.
       * @result this certificates public key
       */
-      std::auto_ptr<Public_Key> subject_public_key() const;
+      std::unique_ptr<Public_Key> subject_public_key() const;
 
       /**
       * Find out whether this object is self signed.
@@ -75,7 +75,7 @@ class BOTAN_DLL EAC1_1_gen_CVC : public EAC1_1_obj<Derived> // CRTP continuation
       * @result the DER encoded signed generalized CVC object
       */
       static MemoryVector<byte> make_signed(
-         std::auto_ptr<PK_Signer> signer,
+         PK_Signer& signer,
          const MemoryRegion<byte>& tbs_bits,
          RandomNumberGenerator& rng);
       virtual ~EAC1_1_gen_CVC<Derived>()
@@ -103,11 +103,11 @@ template<typename Derived> bool EAC1_1_gen_CVC<Derived>::is_self_signed() const
    }
 
 template<typename Derived> MemoryVector<byte> EAC1_1_gen_CVC<Derived>::make_signed(
-   std::auto_ptr<PK_Signer> signer,
+   PK_Signer& signer,
    const MemoryRegion<byte>& tbs_bits,
    RandomNumberGenerator& rng) // static
    {
-   SecureVector<byte> concat_sig = EAC1_1_obj<Derived>::make_signature(signer.get(), tbs_bits, rng);
+   SecureVector<byte> concat_sig = EAC1_1_obj<Derived>::make_signature(signer, tbs_bits, rng);
    assert(concat_sig.size() % 2 == 0);
    return DER_Encoder()
       .start_cons(ASN1_Tag(33), APPLICATION)
@@ -117,9 +117,9 @@ template<typename Derived> MemoryVector<byte> EAC1_1_gen_CVC<Derived>::make_sign
       .get_contents();
    }
 
-template<typename Derived> std::auto_ptr<Public_Key> EAC1_1_gen_CVC<Derived>::subject_public_key() const
+template<typename Derived> std::unique_ptr<Public_Key> EAC1_1_gen_CVC<Derived>::subject_public_key() const
    {
-   return std::auto_ptr<Public_Key>(new ECDSA_PublicKey(m_pk));
+   return std::unique_ptr<Public_Key>(new ECDSA_PublicKey(m_pk));
    }
 
 template<typename Derived> SecureVector<byte> EAC1_1_gen_CVC<Derived>::build_cert_body(MemoryRegion<byte> const& tbs)
diff --git a/src/cert/cvc/cvc_req.cpp b/src/cert/cvc/cvc_req.cpp
index 70a44bacd..aa29d8ee6 100644
--- a/src/cert/cvc/cvc_req.cpp
+++ b/src/cert/cvc/cvc_req.cpp
@@ -44,13 +44,13 @@ void EAC1_1_Req::force_decode()
    // FIXME: No EAC support in ECDSA
 #if 0
    ECDSA_PublicKey tmp_pk;
-   std::auto_ptr<EAC1_1_CVC_Decoder> dec = tmp_pk.cvc_eac1_1_decoder();
+   std::unique_ptr<EAC1_1_CVC_Decoder> dec = tmp_pk.cvc_eac1_1_decoder();
    sig_algo = dec->public_key(enc_pk);
    m_pk = tmp_pk;
 #endif
    }
 
-EAC1_1_Req::EAC1_1_Req(std::tr1::shared_ptr<DataSource> in)
+EAC1_1_Req::EAC1_1_Req(std::shared_ptr<DataSource> in)
    {
    init(in);
    self_signed = true;
@@ -59,7 +59,7 @@ EAC1_1_Req::EAC1_1_Req(std::tr1::shared_ptr<DataSource> in)
 
 EAC1_1_Req::EAC1_1_Req(const std::string& in)
    {
-   std::tr1::shared_ptr<DataSource> stream(new DataSource_Stream(in, true));
+   std::shared_ptr<DataSource> stream(new DataSource_Stream(in, true));
    init(stream);
    self_signed = true;
    do_decode();
diff --git a/src/cert/cvc/cvc_req.h b/src/cert/cvc/cvc_req.h
index 28f03db80..ea05fc157 100644
--- a/src/cert/cvc/cvc_req.h
+++ b/src/cert/cvc/cvc_req.h
@@ -35,7 +35,7 @@ class BOTAN_DLL EAC1_1_Req : public EAC1_1_gen_CVC<EAC1_1_Req>
       * Construct a CVC request from a data source.
       * @param source the data source
       */
-      EAC1_1_Req(std::tr1::shared_ptr<DataSource> source);
+      EAC1_1_Req(std::shared_ptr<DataSource> source);
 
       /**
       * Construct a CVC request from a DER encoded CVC reqeust file.
diff --git a/src/cert/cvc/cvc_self.cpp b/src/cert/cvc/cvc_self.cpp
index 777347a18..98d90d0af 100644
--- a/src/cert/cvc/cvc_self.cpp
+++ b/src/cert/cvc/cvc_self.cpp
@@ -14,7 +14,7 @@
 #include <botan/look_pk.h>
 #include <botan/cvc_req.h>
 #include <botan/cvc_ado.h>
-#include <botan/timer.h>
+#include <botan/time.h>
 #include <sstream>
 
 namespace Botan {
@@ -84,16 +84,18 @@ EAC1_1_CVC create_self_signed_cert(Private_Key const& key,
    sig_algo.oid = OIDS::lookup(priv_key->algo_name() + "/" + padding_and_hash);
    sig_algo = AlgorithmIdentifier(sig_algo.oid, AlgorithmIdentifier::USE_NULL_PARAM);
 
-   std::auto_ptr<Botan::PK_Signer> signer(get_pk_signer(*priv_key, padding_and_hash));
+   std::unique_ptr<Botan::PK_Signer> signer(get_pk_signer(*priv_key, padding_and_hash));
 
 #if 0 // FIXME
-   std::auto_ptr<EAC1_1_CVC_Encoder> enc(priv_key->cvc_eac1_1_encoder());
+   std::unique_ptr<EAC1_1_CVC_Encoder> enc(priv_key->cvc_eac1_1_encoder());
    MemoryVector<byte> enc_public_key = enc->public_key(sig_algo);
 #else
    MemoryVector<byte> enc_public_key;
 #endif
 
-   return EAC1_1_CVC_CA::make_cert(signer, enc_public_key, opt.car, chr, opt.holder_auth_templ, opt.ced, opt.cex, rng);
+   return EAC1_1_CVC_CA::make_cert(*signer.get(), enc_public_key,
+                                   opt.car, chr, opt.holder_auth_templ,
+                                   opt.ced, opt.cex, rng);
 
    }
 
@@ -113,10 +115,10 @@ EAC1_1_Req create_cvc_req(Private_Key const& key,
    sig_algo.oid = OIDS::lookup(priv_key->algo_name() + "/" + padding_and_hash);
    sig_algo = AlgorithmIdentifier(sig_algo.oid, AlgorithmIdentifier::USE_NULL_PARAM);
 
-   std::auto_ptr<Botan::PK_Signer> signer(get_pk_signer(*priv_key, padding_and_hash));
+   std::unique_ptr<Botan::PK_Signer> signer(get_pk_signer(*priv_key, padding_and_hash));
 
 #if 0 // FIXME
-   std::auto_ptr<EAC1_1_CVC_Encoder> enc(priv_key->cvc_eac1_1_encoder());
+   std::unique_ptr<EAC1_1_CVC_Encoder> enc(priv_key->cvc_eac1_1_encoder());
    MemoryVector<byte> enc_public_key = enc->public_key(sig_algo);
 #else
    MemoryVector<byte> enc_public_key;
@@ -130,8 +132,11 @@ EAC1_1_Req create_cvc_req(Private_Key const& key,
       .encode(chr)
       .get_contents();
 
-   MemoryVector<byte> signed_cert = EAC1_1_gen_CVC<EAC1_1_Req>::make_signed(signer, EAC1_1_gen_CVC<EAC1_1_Req>::build_cert_body(tbs), rng);
-   std::tr1::shared_ptr<DataSource> source(new DataSource_Memory(signed_cert));
+   MemoryVector<byte> signed_cert =
+      EAC1_1_gen_CVC<EAC1_1_Req>::make_signed(*signer.get(),
+                                              EAC1_1_gen_CVC<EAC1_1_Req>::build_cert_body(tbs), rng);
+
+   std::shared_ptr<DataSource> source(new DataSource_Memory(signed_cert));
    return EAC1_1_Req(source);
    }
 
@@ -146,12 +151,16 @@ EAC1_1_ADO create_ado_req(Private_Key const& key,
       {
       throw Invalid_Argument("CVC_EAC::create_self_signed_cert(): unsupported key type");
       }
+
    std::string padding_and_hash = padding_and_hash_from_oid(req.signature_algorithm().oid);
-   std::auto_ptr<Botan::PK_Signer> signer(get_pk_signer(*priv_key, padding_and_hash));
+
+   std::unique_ptr<Botan::PK_Signer> signer(get_pk_signer(*priv_key, padding_and_hash));
+
    SecureVector<byte> tbs_bits = req.BER_encode();
    tbs_bits.append(DER_Encoder().encode(car).get_contents());
-   MemoryVector<byte> signed_cert = EAC1_1_ADO::make_signed(signer, tbs_bits, rng);
-   std::tr1::shared_ptr<DataSource> source(new DataSource_Memory(signed_cert));
+
+   MemoryVector<byte> signed_cert = EAC1_1_ADO::make_signed(*signer.get(), tbs_bits, rng);
+   std::shared_ptr<DataSource> source(new DataSource_Memory(signed_cert));
    return EAC1_1_ADO(source);
    }
 
@@ -210,19 +219,19 @@ EAC1_1_CVC link_cvca(EAC1_1_CVC const& signer,
       }
    AlgorithmIdentifier sig_algo = signer.signature_algorithm();
    std::string padding_and_hash = padding_and_hash_from_oid(sig_algo.oid);
-   std::auto_ptr<Botan::PK_Signer> pk_signer(get_pk_signer(*priv_key, padding_and_hash));
-   std::auto_ptr<Public_Key> pk = signee.subject_public_key();
+   std::unique_ptr<Botan::PK_Signer> pk_signer(get_pk_signer(*priv_key, padding_and_hash));
+   std::unique_ptr<Public_Key> pk = signee.subject_public_key();
    ECDSA_PublicKey*  subj_pk = dynamic_cast<ECDSA_PublicKey*>(pk.get());
    subj_pk->set_parameter_encoding(ENC_EXPLICIT);
 
 #if 0 // FIXME
-   std::auto_ptr<EAC1_1_CVC_Encoder> enc(subj_pk->cvc_eac1_1_encoder());
+   std::unique_ptr<EAC1_1_CVC_Encoder> enc(subj_pk->cvc_eac1_1_encoder());
    MemoryVector<byte> enc_public_key = enc->public_key(sig_algo);
 #else
    MemoryVector<byte> enc_public_key;
 #endif
 
-   return EAC1_1_CVC_CA::make_cert(pk_signer, enc_public_key,
+   return EAC1_1_CVC_CA::make_cert(*pk_signer.get(), enc_public_key,
                                    signer.get_car(),
                                    signee.get_chr(),
                                    signer.get_chat_value(),
@@ -250,10 +259,10 @@ EAC1_1_CVC sign_request(EAC1_1_CVC const& signer_cert,
    chr_str.append(fixed_len_seqnr(seqnr, seqnr_len));
    ASN1_Chr chr(chr_str);
    std::string padding_and_hash = padding_and_hash_from_oid(signee.signature_algorithm().oid);
-   std::auto_ptr<Botan::PK_Signer> pk_signer(get_pk_signer(*priv_key, padding_and_hash));
-   std::auto_ptr<Public_Key> pk = signee.subject_public_key();
+   std::unique_ptr<Botan::PK_Signer> pk_signer(get_pk_signer(*priv_key, padding_and_hash));
+   std::unique_ptr<Public_Key> pk = signee.subject_public_key();
    ECDSA_PublicKey*  subj_pk = dynamic_cast<ECDSA_PublicKey*>(pk.get());
-   std::auto_ptr<Public_Key> signer_pk = signer_cert.subject_public_key();
+   std::unique_ptr<Public_Key> signer_pk = signer_cert.subject_public_key();
 
    // for the case that the domain parameters are not set...
    // (we use those from the signer because they must fit)
@@ -262,7 +271,7 @@ EAC1_1_CVC sign_request(EAC1_1_CVC const& signer_cert,
    subj_pk->set_parameter_encoding(ENC_IMPLICITCA);
 
 #if 0 // FIXME
-   std::auto_ptr<EAC1_1_CVC_Encoder> enc(subj_pk->cvc_eac1_1_encoder());
+   std::unique_ptr<EAC1_1_CVC_Encoder> enc(subj_pk->cvc_eac1_1_encoder());
    MemoryVector<byte> enc_public_key = enc->public_key(sig_algo);
 #else
    MemoryVector<byte> enc_public_key;
@@ -298,7 +307,7 @@ EAC1_1_CVC sign_request(EAC1_1_CVC const& signer_cert,
       throw Invalid_Argument("sign_request(): encountered illegal value for CHAT");
       // (IS cannot sign certificates)
       }
-   return EAC1_1_CVC_CA::make_cert(pk_signer, enc_public_key,
+   return EAC1_1_CVC_CA::make_cert(*pk_signer.get(), enc_public_key,
                                    ASN1_Car(signer_cert.get_chr().iso_8859()),
                                    chr,
                                    chat_val,
diff --git a/src/cert/cvc/eac_obj.h b/src/cert/cvc/eac_obj.h
index 2c1250a9a..49e78b53d 100644
--- a/src/cert/cvc/eac_obj.h
+++ b/src/cert/cvc/eac_obj.h
@@ -53,7 +53,7 @@ class BOTAN_DLL EAC1_1_obj : public EAC_Signed_Object
    protected:
       void init(SharedPtrConverter<DataSource> in);
 
-      static SecureVector<byte> make_signature(PK_Signer* signer,
+      static SecureVector<byte> make_signature(PK_Signer& signer,
                                                const MemoryRegion<byte>& tbs_bits,
                                                RandomNumberGenerator& rng);
 
@@ -67,12 +67,12 @@ template<typename Derived> SecureVector<byte> EAC1_1_obj<Derived>::get_concat_si
    }
 
 template<typename Derived> SecureVector<byte>
-EAC1_1_obj<Derived>::make_signature(PK_Signer* signer,
+EAC1_1_obj<Derived>::make_signature(PK_Signer& signer,
                                     const MemoryRegion<byte>& tbs_bits,
                                     RandomNumberGenerator& rng)
    {
    // this is the signature as a der sequence
-   SecureVector<byte> seq_sig = signer->sign_message(tbs_bits, rng);
+   SecureVector<byte> seq_sig = signer.sign_message(tbs_bits, rng);
 
    ECDSA_Signature sig(decode_seq(seq_sig));
    SecureVector<byte> concat_sig(sig.get_concatenation());
@@ -111,12 +111,12 @@ bool EAC1_1_obj<Derived>::check_signature(Public_Key& pub_key) const
       if(!dynamic_cast<PK_Verifying_wo_MR_Key*>(&pub_key))
          return false;
 
-      std::auto_ptr<ECDSA_Signature_Encoder> enc(new ECDSA_Signature_Encoder(&m_sig));
+      std::unique_ptr<ECDSA_Signature_Encoder> enc(new ECDSA_Signature_Encoder(&m_sig));
       SecureVector<byte> seq_sig = enc->signature_bits();
       SecureVector<byte> to_sign = tbs_data();
 
       PK_Verifying_wo_MR_Key& sig_key = dynamic_cast<PK_Verifying_wo_MR_Key&>(pub_key);
-      std::auto_ptr<PK_Verifier> verifier(get_pk_verifier(sig_key, padding, format));
+      std::unique_ptr<PK_Verifier> verifier(get_pk_verifier(sig_key, padding, format));
       return verifier->verify_message(to_sign, seq_sig);
       }
    catch(...)
diff --git a/src/cert/cvc/ecdsa_sig.cpp b/src/cert/cvc/ecdsa_sig.cpp
index c33a4550a..1a60f7aa8 100644
--- a/src/cert/cvc/ecdsa_sig.cpp
+++ b/src/cert/cvc/ecdsa_sig.cpp
@@ -41,7 +41,7 @@ ECDSA_Signature const decode_seq(MemoryRegion<byte> const& seq)
    {
    ECDSA_Signature sig;
 
-   std::auto_ptr<ECDSA_Signature_Decoder> dec(new ECDSA_Signature_Decoder(&sig));
+   std::unique_ptr<ECDSA_Signature_Decoder> dec(new ECDSA_Signature_Decoder(&sig));
    dec->signature_bits(seq);
    return sig;
    }
diff --git a/src/cert/cvc/freestore.h b/src/cert/cvc/freestore.h
index 7f8b85388..3049dbd13 100644
--- a/src/cert/cvc/freestore.h
+++ b/src/cert/cvc/freestore.h
@@ -8,14 +8,7 @@
 #define BOTAN_FREESTORE_H__
 
 #include <botan/build.h>
-
-#if defined(BOTAN_USE_STD_TR1)
-  #include <tr1/memory>
-#elif defined(BOTAN_USE_BOOST_TR1)
-  #include <boost/tr1/memory.hpp>
-#else
-  #error "Please choose a TR1 implementation in build.h"
-#endif
+#include <memory>
 
 namespace Botan {
 
@@ -29,7 +22,7 @@ template<typename T>
 class BOTAN_DLL SharedPtrConverter
    {
    public:
-      typedef std::tr1::shared_ptr<T> SharedPtr;
+      typedef std::shared_ptr<T> SharedPtr;
 
       /**
       * Construct a null pointer equivalent object.
diff --git a/src/cert/cvc/info.txt b/src/cert/cvc/info.txt
index bdd496614..ff7e04c07 100644
--- a/src/cert/cvc/info.txt
+++ b/src/cert/cvc/info.txt
@@ -1,7 +1,5 @@
 define CARD_VERIFIABLE_CERTIFICATES
 
-uses_tr1 yes
-
 load_on auto
 
 <add>
diff --git a/src/cert/x509/crl_ent.cpp b/src/cert/x509/crl_ent.cpp
index a8a989c24..42a742ebb 100644
--- a/src/cert/x509/crl_ent.cpp
+++ b/src/cert/x509/crl_ent.cpp
@@ -11,7 +11,7 @@
 #include <botan/ber_dec.h>
 #include <botan/bigint.h>
 #include <botan/oids.h>
-#include <botan/timer.h>
+#include <botan/time.h>
 
 namespace Botan {
 
diff --git a/src/cert/x509/x509_ca.cpp b/src/cert/x509/x509_ca.cpp
index a4159ad2b..80e808177 100644
--- a/src/cert/x509/x509_ca.cpp
+++ b/src/cert/x509/x509_ca.cpp
@@ -14,10 +14,7 @@
 #include <botan/lookup.h>
 #include <botan/look_pk.h>
 #include <botan/oids.h>
-#include <botan/timer.h>
-#include <algorithm>
-#include <typeinfo>
-#include <iterator>
+#include <botan/time.h>
 #include <memory>
 #include <set>
 
@@ -61,7 +58,7 @@ X509_Certificate X509_CA::sign_request(const PKCS10_Request& req,
       constraints = Key_Constraints(KEY_CERT_SIGN | CRL_SIGN);
    else
       {
-      std::auto_ptr<Public_Key> key(req.subject_public_key());
+      std::unique_ptr<Public_Key> key(req.subject_public_key());
       constraints = X509::find_constraints(*key, req.constraints());
       }
 
@@ -173,8 +170,7 @@ X509_CRL X509_CA::update_crl(const X509_CRL& crl,
 
    for(u32bit j = 0; j != already_revoked.size(); ++j)
       {
-      std::set<SecureVector<byte> >::const_iterator i;
-      i = removed_from_crl.find(already_revoked[j].serial_number());
+      auto i = removed_from_crl.find(already_revoked[j].serial_number());
 
       if(i == removed_from_crl.end())
          all_revoked.push_back(already_revoked[j]);
@@ -275,7 +271,7 @@ PK_Signer* choose_sig_format(const Private_Key& key,
 
    sig_algo.oid = OIDS::lookup(algo_name + "/" + padding);
 
-   std::auto_ptr<X509_Encoder> encoding(key.x509_encoder());
+   std::unique_ptr<X509_Encoder> encoding(key.x509_encoder());
    if(!encoding.get())
       throw Encoding_Error("Key " + algo_name + " does not support "
                            "X.509 encoding");
diff --git a/src/cert/x509/x509_ca.h b/src/cert/x509/x509_ca.h
index 6eb4bbbef..b680bd0e4 100644
--- a/src/cert/x509/x509_ca.h
+++ b/src/cert/x509/x509_ca.h
@@ -97,11 +97,11 @@ class BOTAN_DLL X509_CA
               const Private_Key& key,
               const std::string& hash_fn);
 
+      X509_CA(const X509_CA&) = delete;
+      X509_CA& operator=(const X509_CA&) = delete;
+
       ~X509_CA();
    private:
-      X509_CA(const X509_CA&) {}
-      X509_CA& operator=(const X509_CA&) { return (*this); }
-
       X509_CRL make_crl(const std::vector<CRL_Entry>& entries,
                         u32bit crl_number, u32bit next_update,
                         RandomNumberGenerator& rng) const;
diff --git a/src/cert/x509/x509_obj.cpp b/src/cert/x509/x509_obj.cpp
index 31b4a309f..95a1c1cca 100644
--- a/src/cert/x509/x509_obj.cpp
+++ b/src/cert/x509/x509_obj.cpp
@@ -168,7 +168,7 @@ bool X509_Object::check_signature(Public_Key& pub_key) const
       Signature_Format format =
          (pub_key.message_parts() >= 2) ? DER_SEQUENCE : IEEE_1363;
 
-      std::auto_ptr<PK_Verifier> verifier;
+      std::unique_ptr<PK_Verifier> verifier;
 
       if(dynamic_cast<PK_Verifying_with_MR_Key*>(&pub_key))
          {
diff --git a/src/cert/x509/x509cert.cpp b/src/cert/x509/x509cert.cpp
index ac5839fb6..6a062b7ce 100644
--- a/src/cert/x509/x509cert.cpp
+++ b/src/cert/x509/x509cert.cpp
@@ -27,12 +27,8 @@ std::vector<std::string> lookup_oids(const std::vector<std::string>& in)
    {
    std::vector<std::string> out;
 
-   std::vector<std::string>::const_iterator i = in.begin();
-   while(i != in.end())
-      {
+   for(auto i = in.begin(); i != in.end(); ++i)
       out.push_back(OIDS::lookup(OID(*i)));
-      ++i;
-      }
    return out;
    }
 
@@ -304,25 +300,16 @@ bool operator!=(const X509_Certificate& cert1, const X509_Certificate& cert2)
 */
 X509_DN create_dn(const Data_Store& info)
    {
-   class DN_Matcher : public Data_Store::Matcher
+   auto names = info.search_for(
+      [](const std::string& key, const std::string&)
       {
-      public:
-         bool operator()(const std::string& key, const std::string&) const
-            {
-            if(key.find("X520.") != std::string::npos)
-               return true;
-            return false;
-            }
-      };
-
-   std::multimap<std::string, std::string> names =
-      info.search_with(DN_Matcher());
+         return (key.find("X520.") != std::string::npos);
+      });
 
    X509_DN dn;
 
-   std::multimap<std::string, std::string>::iterator j;
-   for(j = names.begin(); j != names.end(); ++j)
-      dn.add_attribute(j->first, j->second);
+   for(auto i = names.begin(); i != names.end(); ++i)
+      dn.add_attribute(i->first, i->second);
 
    return dn;
    }
@@ -332,33 +319,19 @@ X509_DN create_dn(const Data_Store& info)
 */
 AlternativeName create_alt_name(const Data_Store& info)
    {
-   class AltName_Matcher : public Data_Store::Matcher
+   auto names = info.search_for(
+      [](const std::string& key, const std::string&)
       {
-      public:
-         bool operator()(const std::string& key, const std::string&) const
-            {
-            for(u32bit j = 0; j != matches.size(); ++j)
-               if(key.compare(matches[j]) == 0)
-                  return true;
-            return false;
-            }
-
-         AltName_Matcher(const std::string& match_any_of)
-            {
-            matches = split_on(match_any_of, '/');
-            }
-      private:
-         std::vector<std::string> matches;
-      };
-
-   std::multimap<std::string, std::string> names =
-      info.search_with(AltName_Matcher("RFC822/DNS/URI/IP"));
+         return (key == "RFC822" ||
+                 key == "DNS" ||
+                 key == "URI" ||
+                 key == "IP");
+      });
 
    AlternativeName alt_name;
 
-   std::multimap<std::string, std::string>::iterator j;
-   for(j = names.begin(); j != names.end(); ++j)
-      alt_name.add_attribute(j->first, j->second);
+   for(auto i = names.begin(); i != names.end(); ++i)
+      alt_name.add_attribute(i->first, i->second);
 
    return alt_name;
    }
diff --git a/src/cert/x509/x509find.cpp b/src/cert/x509/x509find.cpp
index 257367da9..41643a94a 100644
--- a/src/cert/x509/x509find.cpp
+++ b/src/cert/x509/x509find.cpp
@@ -11,6 +11,8 @@
 
 namespace Botan {
 
+namespace X509_Store_Search {
+
 namespace {
 
 /*
@@ -42,70 +44,65 @@ bool ignore_case(const std::string& searching_for, const std::string& found)
 /*
 * Search based on the contents of a DN entry
 */
-bool DN_Check::match(const X509_Certificate& cert) const
+std::function<bool (const X509_Certificate&)>
+by_dn(const std::string& dn_entry,
+      const std::string& to_find,
+      DN_Search_Type method)
    {
-   std::vector<std::string> info = cert.subject_info(dn_entry);
-
-   for(u32bit j = 0; j != info.size(); ++j)
-      if(compare(info[j], looking_for))
-         return true;
-   return false;
-   }
+   if(method == SUBSTRING_MATCHING)
+      return by_dn(dn_entry, to_find, substring_match);
+   else if(method == IGNORE_CASE)
+      return by_dn(dn_entry, to_find, ignore_case);
 
-/*
-* DN_Check Constructor
-*/
-DN_Check::DN_Check(const std::string& dn_entry, const std::string& looking_for,
-                   compare_fn func)
-   {
-   this->dn_entry = dn_entry;
-   this->looking_for = looking_for;
-   compare = func;
+   throw Invalid_Argument("Unknown method argument to by_dn");
    }
 
-/*
-* DN_Check Constructor
-*/
-DN_Check::DN_Check(const std::string& dn_entry, const std::string& looking_for,
-                   Search_Type method)
+std::function<bool (const X509_Certificate&)>
+by_dn(const std::string& dn_entry,
+      const std::string& to_find,
+      std::function<bool (std::string, std::string)> compare)
    {
-   this->dn_entry = dn_entry;
-   this->looking_for = looking_for;
+   return [&](const X509_Certificate& cert)
+      {
+      std::vector<std::string> info = cert.subject_info(dn_entry);
 
-   if(method == SUBSTRING_MATCHING)
-      compare = &substring_match;
-   else if(method == IGNORE_CASE)
-      compare = &ignore_case;
-   else
-      throw Invalid_Argument("Unknown method argument to DN_Check()");
+      for(u32bit i = 0; i != info.size(); ++i)
+         if(compare(info[i], to_find))
+            return true;
+      return false;
+      };
    }
 
-/*
-* Match by issuer and serial number
-*/
-bool IandS_Match::match(const X509_Certificate& cert) const
+std::function<bool (const X509_Certificate&)>
+by_issuer_and_serial(const X509_DN& issuer, const MemoryRegion<byte>& serial)
    {
-   if(cert.serial_number() != serial)
-      return false;
-   return (cert.issuer_dn() == issuer);
+   /* Serial number compare is much faster than X.509 DN, and unlikely
+   to collide even across issuers, so do that first to fail fast
+   */
+
+   return [&](const X509_Certificate& cert)
+      {
+      if(cert.serial_number() != serial)
+         return false;
+      return (cert.issuer_dn() == issuer);
+      };
    }
 
-/*
-* IandS_Match Constructor
-*/
-IandS_Match::IandS_Match(const X509_DN& issuer,
-                         const MemoryRegion<byte>& serial)
+std::function<bool (const X509_Certificate&)>
+by_issuer_and_serial(const X509_DN& issuer, const BigInt& serial)
    {
-   this->issuer = issuer;
-   this->serial = serial;
+   return by_issuer_and_serial(issuer, BigInt::encode(serial));
    }
 
-/*
-* Match by subject key identifier
-*/
-bool SKID_Match::match(const X509_Certificate& cert) const
+std::function<bool (const X509_Certificate&)>
+by_skid(const MemoryRegion<byte>& subject_key_id)
    {
-   return (cert.subject_key_id() == skid);
+   return [&](const X509_Certificate& cert)
+      {
+      return (cert.subject_key_id() == subject_key_id);
+      };
    }
 
 }
+
+}
diff --git a/src/cert/x509/x509find.h b/src/cert/x509/x509find.h
index a7a84c7a5..1bf29dfbc 100644
--- a/src/cert/x509/x509find.h
+++ b/src/cert/x509/x509find.h
@@ -9,51 +9,43 @@
 #define BOTAN_X509_CERT_STORE_SEARCH_H__
 
 #include <botan/x509stor.h>
+#include <botan/bigint.h>
 
 namespace Botan {
 
+namespace X509_Store_Search {
+
 /*
 * Search based on the contents of a DN entry
 */
-class BOTAN_DLL DN_Check : public X509_Store::Search_Func
-   {
-   public:
-      typedef bool (*compare_fn)(const std::string&, const std::string&);
-      enum Search_Type { SUBSTRING_MATCHING, IGNORE_CASE };
+enum DN_Search_Type { SUBSTRING_MATCHING, IGNORE_CASE };
 
-      bool match(const X509_Certificate& cert) const;
+std::function<bool (const X509_Certificate&)>
+by_dn(const std::string& dn_entry,
+          const std::string& to_find,
+          DN_Search_Type method);
 
-      DN_Check(const std::string&, const std::string&, compare_fn);
-      DN_Check(const std::string&, const std::string&, Search_Type);
-   private:
-      std::string dn_entry, looking_for;
-      compare_fn compare;
-   };
+std::function<bool (const X509_Certificate&)>
+by_dn(const std::string& dn_entry,
+          const std::string& to_find,
+          std::function<bool (std::string, std::string)> method);
 
-/*
-* Search for a certificate by issuer/serial
+/**
+* Search for certs by issuer + serial number
 */
-class BOTAN_DLL IandS_Match : public X509_Store::Search_Func
-   {
-   public:
-      bool match(const X509_Certificate& cert) const;
-      IandS_Match(const X509_DN&, const MemoryRegion<byte>&);
-   private:
-      X509_DN issuer;
-      MemoryVector<byte> serial;
-   };
+std::function<bool (const X509_Certificate&)>
+by_issuer_and_serial(const X509_DN& issuer, const MemoryRegion<byte>& serial);
 
-/*
-* Search for a certificate by subject keyid
+std::function<bool (const X509_Certificate&)>
+by_issuer_and_serial(const X509_DN& issuer, const BigInt& serial);
+
+/**
+* Search for certs by subject key identifier
 */
-class BOTAN_DLL SKID_Match : public X509_Store::Search_Func
-   {
-   public:
-      bool match(const X509_Certificate& cert) const;
-      SKID_Match(const MemoryRegion<byte>& s) : skid(s) {}
-   private:
-      MemoryVector<byte> skid;
-   };
+std::function<bool (const X509_Certificate&)>
+by_skid(const MemoryRegion<byte>& subject_key_id);
+
+}
 
 }
 
diff --git a/src/cert/x509/x509opt.cpp b/src/cert/x509/x509opt.cpp
index 03bcd20f4..c6421d9ca 100644
--- a/src/cert/x509/x509opt.cpp
+++ b/src/cert/x509/x509opt.cpp
@@ -8,7 +8,7 @@
 #include <botan/x509self.h>
 #include <botan/oids.h>
 #include <botan/parsing.h>
-#include <botan/timer.h>
+#include <botan/time.h>
 
 namespace Botan {
 
diff --git a/src/cert/x509/x509self.cpp b/src/cert/x509/x509self.cpp
index f915c6ff5..df31897bb 100644
--- a/src/cert/x509/x509self.cpp
+++ b/src/cert/x509/x509self.cpp
@@ -73,7 +73,7 @@ X509_Certificate create_self_signed_cert(const X509_Cert_Options& opts,
    AlternativeName subject_alt;
 
    MemoryVector<byte> pub_key = shared_setup(opts, key);
-   std::auto_ptr<PK_Signer> signer(choose_sig_format(key, hash_fn, sig_algo));
+   std::unique_ptr<PK_Signer> signer(choose_sig_format(key, hash_fn, sig_algo));
    load_info(opts, subject_dn, subject_alt);
 
    Key_Constraints constraints;
@@ -112,7 +112,7 @@ PKCS10_Request create_cert_req(const X509_Cert_Options& opts,
    AlternativeName subject_alt;
 
    MemoryVector<byte> pub_key = shared_setup(opts, key);
-   std::auto_ptr<PK_Signer> signer(choose_sig_format(key, hash_fn, sig_algo));
+   std::unique_ptr<PK_Signer> signer(choose_sig_format(key, hash_fn, sig_algo));
    load_info(opts, subject_dn, subject_alt);
 
    const u32bit PKCS10_VERSION = 0;
diff --git a/src/cert/x509/x509stor.cpp b/src/cert/x509/x509stor.cpp
index 40801148c..323890f2d 100644
--- a/src/cert/x509/x509stor.cpp
+++ b/src/cert/x509/x509stor.cpp
@@ -10,7 +10,7 @@
 #include <botan/pubkey.h>
 #include <botan/look_pk.h>
 #include <botan/oids.h>
-#include <botan/timer.h>
+#include <botan/time.h>
 #include <algorithm>
 #include <memory>
 
@@ -380,8 +380,8 @@ X509_Code X509_Store::check_sig(const Cert_Info& cert_info,
 */
 X509_Code X509_Store::check_sig(const X509_Object& object, Public_Key* key)
    {
-   std::auto_ptr<Public_Key> pub_key(key);
-   std::auto_ptr<PK_Verifier> verifier;
+   std::unique_ptr<Public_Key> pub_key(key);
+   std::unique_ptr<PK_Verifier> verifier;
 
    try {
       std::vector<std::string> sig_info =
@@ -464,12 +464,12 @@ bool X509_Store::is_revoked(const X509_Certificate& cert) const
 * Retrieve all the certificates in the store
 */
 std::vector<X509_Certificate>
-X509_Store::get_certs(const Search_Func& search) const
+X509_Store::get_certs(std::function<bool (const X509_Certificate&)> pred) const
    {
    std::vector<X509_Certificate> found_certs;
    for(u32bit j = 0; j != certs.size(); ++j)
       {
-      if(search.match(certs[j].cert))
+      if(pred(certs[j].cert))
          found_certs.push_back(certs[j].cert);
       }
    return found_certs;
@@ -603,8 +603,7 @@ X509_Code X509_Store::add_crl(const X509_CRL& crl)
       revoked_info.serial = revoked_certs[j].serial_number();
       revoked_info.auth_key_id = crl.authority_key_id();
 
-      std::vector<CRL_Data>::iterator p =
-         std::find(revoked.begin(), revoked.end(), revoked_info);
+      auto p = std::find(revoked.begin(), revoked.end(), revoked_info);
 
       if(revoked_certs[j].reason_code() == REMOVE_FROM_CRL)
          {
diff --git a/src/cert/x509/x509stor.h b/src/cert/x509/x509stor.h
index 4e6037883..958b6da0f 100644
--- a/src/cert/x509/x509stor.h
+++ b/src/cert/x509/x509stor.h
@@ -11,6 +11,7 @@
 #include <botan/x509cert.h>
 #include <botan/x509_crl.h>
 #include <botan/certstor.h>
+#include <functional>
 
 namespace Botan {
 
@@ -48,13 +49,6 @@ enum X509_Code {
 class BOTAN_DLL X509_Store
    {
    public:
-      class BOTAN_DLL Search_Func
-         {
-         public:
-            virtual bool match(const X509_Certificate&) const = 0;
-            virtual ~Search_Func() {}
-         };
-
       enum Cert_Usage {
          ANY              = 0x00,
          TLS_SERVER       = 0x01,
@@ -67,7 +61,13 @@ class BOTAN_DLL X509_Store
 
       X509_Code validate_cert(const X509_Certificate&, Cert_Usage = ANY);
 
-      std::vector<X509_Certificate> get_certs(const Search_Func&) const;
+      /**
+      * @param match the matching function
+      * @return list of certs for which match returns true
+      */
+      std::vector<X509_Certificate>
+         get_certs(std::function<bool (const X509_Certificate&)> match) const;
+
       std::vector<X509_Certificate> get_cert_chain(const X509_Certificate&);
       std::string PEM_encode() const;
 
@@ -94,14 +94,14 @@ class BOTAN_DLL X509_Store
 
       static X509_Code check_sig(const X509_Object&, Public_Key*);
 
+      X509_Store& operator=(const X509_Store&) = delete;
+
       X509_Store(u32bit time_slack = 24*60*60,
                  u32bit cache_results = 30*60);
 
       X509_Store(const X509_Store&);
       ~X509_Store();
    private:
-      X509_Store& operator=(const X509_Store&) { return (*this); }
-
       class BOTAN_DLL Cert_Info
          {
          public:
diff --git a/src/cms/cms_dalg.cpp b/src/cms/cms_dalg.cpp
index 7ed793f4f..3e8bdb4fa 100644
--- a/src/cms/cms_dalg.cpp
+++ b/src/cms/cms_dalg.cpp
@@ -52,10 +52,11 @@ std::vector<X509_Certificate> get_cert(BER_Decoder& signer_info,
       iands.decode(issuer);
       iands.decode(serial);
 
-      found = store.get_certs(IandS_Match(issuer, BigInt::encode(serial)));
+      found = store.get_certs(
+         X509_Store_Search::by_issuer_and_serial(issuer, serial));
       }
    else if(id.type_tag == 0 && id.class_tag == CONSTRUCTED)
-      found = store.get_certs(SKID_Match(id.value));
+      found = store.get_certs(X509_Store_Search::by_skid(id.value));
    else
       throw Decoding_Error("CMS: Unknown tag for cert identifier");
 
diff --git a/src/filters/data_snk.h b/src/filters/data_snk.h
index 61ddf6e0d..fda06e492 100644
--- a/src/filters/data_snk.h
+++ b/src/filters/data_snk.h
@@ -22,9 +22,9 @@ class BOTAN_DLL DataSink : public Filter
       bool attachable() { return false; }
       DataSink() {}
       virtual ~DataSink() {}
-   private:
-      DataSink& operator=(const DataSink&) { return (*this); }
-      DataSink(const DataSink&);
+
+      DataSink& operator=(const DataSink&) = delete;
+      DataSink(const DataSink&) = delete;
    };
 
 /**
diff --git a/src/filters/data_src.h b/src/filters/data_src.h
index e16217e0f..dea46584c 100644
--- a/src/filters/data_src.h
+++ b/src/filters/data_src.h
@@ -78,9 +78,8 @@ class BOTAN_DLL DataSource
 
       DataSource() {}
       virtual ~DataSource() {}
-   private:
-      DataSource& operator=(const DataSource&) { return (*this); }
-      DataSource(const DataSource&);
+      DataSource& operator=(const DataSource&) = delete;
+      DataSource(const DataSource&) = delete;
    };
 
 /**
diff --git a/src/filters/filter.h b/src/filters/filter.h
index b13a36650..8fc114db7 100644
--- a/src/filters/filter.h
+++ b/src/filters/filter.h
@@ -19,6 +19,8 @@ namespace Botan {
 class BOTAN_DLL Filter
    {
    public:
+      friend class Pipe;
+      friend class Fanout_Filter;
 
       /**
       * Write a portion of a message to this filter.
@@ -56,6 +58,9 @@ class BOTAN_DLL Filter
       */
       void finish_msg();
 
+      Filter(const Filter&) = delete;
+      Filter& operator=(const Filter&) = delete;
+
       virtual ~Filter() {}
    protected:
       void send(const byte[], u32bit);
@@ -63,12 +68,6 @@ class BOTAN_DLL Filter
       void send(const MemoryRegion<byte>& in) { send(in.begin(), in.size()); }
       Filter();
    private:
-      Filter(const Filter&) {}
-      Filter& operator=(const Filter&) { return (*this); }
-
-      friend class Pipe;
-      friend class Fanout_Filter;
-
       u32bit total_ports() const;
       u32bit current_port() const { return port_num; }
       void set_port(u32bit);
diff --git a/src/filters/pipe.cpp b/src/filters/pipe.cpp
index 33824be24..d43868e3f 100644
--- a/src/filters/pipe.cpp
+++ b/src/filters/pipe.cpp
@@ -51,11 +51,12 @@ Pipe::Pipe(Filter* f1, Filter* f2, Filter* f3, Filter* f4)
 /*
 * Pipe Constructor
 */
-Pipe::Pipe(Filter* filter_array[], u32bit count)
+Pipe::Pipe(std::initializer_list<Filter*> args)
    {
    init();
-   for(u32bit j = 0; j != count; ++j)
-      append(filter_array[j]);
+
+   for(auto i = args.begin(); i != args.end(); ++i)
+      append(*i);
    }
 
 /*
diff --git a/src/filters/pipe.h b/src/filters/pipe.h
index 120f2fbdd..58bb6d22a 100644
--- a/src/filters/pipe.h
+++ b/src/filters/pipe.h
@@ -11,6 +11,7 @@
 #include <botan/data_src.h>
 #include <botan/filter.h>
 #include <botan/exceptn.h>
+#include <initializer_list>
 #include <iosfwd>
 
 namespace Botan {
@@ -238,15 +239,16 @@ class BOTAN_DLL Pipe : public DataSource
       Pipe(Filter* = 0, Filter* = 0, Filter* = 0, Filter* = 0);
 
       /**
-      * Construct a Pipe from range of filters passed as an array
+      * Construct a Pipe from a list of filters
       * @param filters the set of filters to use
-      * @param count the number of elements in filters
       */
-      Pipe(Filter* filters[], u32bit count);
+      Pipe(std::initializer_list<Filter*> filters);
+
+      Pipe(const Pipe&) = delete;
+      Pipe& operator=(const Pipe&) = delete;
+
       ~Pipe();
    private:
-      Pipe(const Pipe&) : DataSource() {}
-      Pipe& operator=(const Pipe&) { return (*this); }
       void init();
       void destruct(Filter*);
       void find_endpoints(Filter*);
diff --git a/src/hash/par_hash/par_hash.cpp b/src/hash/par_hash/par_hash.cpp
index 0ba3f5a4f..fdd028f58 100644
--- a/src/hash/par_hash/par_hash.cpp
+++ b/src/hash/par_hash/par_hash.cpp
@@ -1,6 +1,6 @@
 /*
 * Parallel
-* (C) 1999-2007 Jack Lloyd
+* (C) 1999-2009 Jack Lloyd
 *
 * Distributed under the terms of the Botan license
 */
@@ -18,8 +18,8 @@ u32bit sum_of_hash_lengths(const std::vector<HashFunction*>& hashes)
    {
    u32bit sum = 0;
 
-   for(u32bit j = 0; j != hashes.size(); ++j)
-      sum += hashes[j]->OUTPUT_LENGTH;
+   for(auto hash = hashes.begin(); hash != hashes.end(); ++hash)
+      sum += (*hash)->OUTPUT_LENGTH;
 
    return sum;
    }
@@ -31,20 +31,21 @@ u32bit sum_of_hash_lengths(const std::vector<HashFunction*>& hashes)
 */
 void Parallel::add_data(const byte input[], u32bit length)
    {
-   for(u32bit j = 0; j != hashes.size(); ++j)
-      hashes[j]->update(input, length);
+   for(auto hash = hashes.begin(); hash != hashes.end(); ++hash)
+      (*hash)->update(input, length);
    }
 
 /*
 * Finalize the hash
 */
-void Parallel::final_result(byte hash[])
+void Parallel::final_result(byte out[])
    {
    u32bit offset = 0;
-   for(u32bit j = 0; j != hashes.size(); ++j)
+
+   for(auto hash = hashes.begin(); hash != hashes.end(); ++hash)
       {
-      hashes[j]->final(hash + offset);
-      offset += hashes[j]->OUTPUT_LENGTH;
+      (*hash)->final(out + offset);
+      offset += (*hash)->OUTPUT_LENGTH;
       }
    }
 
@@ -54,12 +55,14 @@ void Parallel::final_result(byte hash[])
 std::string Parallel::name() const
    {
    std::string hash_names;
-   for(u32bit j = 0; j != hashes.size(); ++j)
+
+   for(auto hash = hashes.begin(); hash != hashes.end(); ++hash)
       {
-      if(j)
+      if(hash != hashes.begin())
          hash_names += ',';
-      hash_names += hashes[j]->name();
+      hash_names += (*hash)->name();
       }
+
    return "Parallel(" + hash_names + ")";
    }
 
@@ -69,8 +72,10 @@ std::string Parallel::name() const
 HashFunction* Parallel::clone() const
    {
    std::vector<HashFunction*> hash_copies;
-   for(u32bit j = 0; j != hashes.size(); ++j)
-      hash_copies.push_back(hashes[j]->clone());
+
+   for(auto hash = hashes.begin(); hash != hashes.end(); ++hash)
+      hash_copies.push_back((*hash)->clone());
+
    return new Parallel(hash_copies);
    }
 
@@ -79,8 +84,8 @@ HashFunction* Parallel::clone() const
 */
 void Parallel::clear()
    {
-   for(u32bit j = 0; j != hashes.size(); ++j)
-      hashes[j]->clear();
+   for(auto hash = hashes.begin(); hash != hashes.end(); ++hash)
+      (*hash)->clear();
    }
 
 /*
@@ -96,8 +101,8 @@ Parallel::Parallel(const std::vector<HashFunction*>& hash_in) :
 */
 Parallel::~Parallel()
    {
-   for(u32bit j = 0; j != hashes.size(); ++j)
-      delete hashes[j];
+   for(auto hash = hashes.begin(); hash != hashes.end(); ++hash)
+      delete (*hash);
    }
 
 }
diff --git a/src/libstate/info.txt b/src/libstate/info.txt
index e8271ce99..aa74e6573 100644
--- a/src/libstate/info.txt
+++ b/src/libstate/info.txt
@@ -32,8 +32,6 @@ hash
 kdf
 mac
 mode_pad
-mutex
-noop_mutex
 pk_pad
 pubkey
 rng
diff --git a/src/libstate/init.cpp b/src/libstate/init.cpp
index b908de6c7..0d9a2420c 100644
--- a/src/libstate/init.cpp
+++ b/src/libstate/init.cpp
@@ -1,12 +1,11 @@
 /**
 * Default Initialization Function
-* (C) 1999-2007 Jack Lloyd
+* (C) 1999-2009 Jack Lloyd
 *
 * Distributed under the terms of the Botan license
 */
 
 #include <botan/init.h>
-#include <botan/parsing.h>
 #include <botan/libstate.h>
 
 namespace Botan {
@@ -14,36 +13,8 @@ namespace Botan {
 /*
 * Library Initialization
 */
-void LibraryInitializer::initialize(const std::string& arg_string)
+void LibraryInitializer::initialize(const std::string&)
    {
-   bool thread_safe = false;
-
-   const std::vector<std::string> arg_list = split_on(arg_string, ' ');
-   for(u32bit j = 0; j != arg_list.size(); ++j)
-      {
-      if(arg_list[j].size() == 0)
-         continue;
-
-      std::string name, value;
-
-      if(arg_list[j].find('=') == std::string::npos)
-         {
-         name = arg_list[j];
-         value = "true";
-         }
-      else
-         {
-         std::vector<std::string> name_and_value = split_on(arg_list[j], '=');
-         name = name_and_value[0];
-         value = name_and_value[1];
-         }
-
-      bool is_on =
-         (value == "1" || value == "true" || value == "yes" || value == "on");
-
-      if(name == "thread_safe")
-         thread_safe = is_on;
-      }
 
    try
       {
@@ -55,7 +26,7 @@ void LibraryInitializer::initialize(const std::string& arg_string)
       */
       set_global_state(new Library_State);
 
-      global_state().initialize(thread_safe);
+      global_state().initialize();
       }
    catch(...)
       {
diff --git a/src/libstate/libstate.cpp b/src/libstate/libstate.cpp
index 8b039a97a..dd7fe7eaf 100644
--- a/src/libstate/libstate.cpp
+++ b/src/libstate/libstate.cpp
@@ -10,21 +10,11 @@
 #include <botan/selftest.h>
 #include <botan/engine.h>
 #include <botan/stl_util.h>
-#include <botan/mutex.h>
-#include <botan/mux_noop.h>
 #include <botan/charset.h>
 #include <botan/defalloc.h>
 #include <botan/def_eng.h>
 #include <algorithm>
 
-#if defined(BOTAN_HAS_MUTEX_PTHREAD)
-  #include <botan/mux_pthr.h>
-#elif defined(BOTAN_HAS_MUTEX_WIN32)
-  #include <botan/mux_win32.h>
-#elif defined(BOTAN_HAS_MUTEX_QT)
-  #include <botan/mux_qt.h>
-#endif
-
 #if defined(BOTAN_HAS_ALLOC_MMAP)
   #include <botan/mmap_mem.h>
 #endif
@@ -91,25 +81,17 @@ void set_global_state(Library_State* new_state)
 */
 Library_State* swap_global_state(Library_State* new_state)
    {
-   Library_State* old_state = global_lib_state;
+   auto old_state = global_lib_state;
    global_lib_state = new_state;
    return old_state;
    }
 
 /*
-* Get a new mutex object
-*/
-Mutex* Library_State::get_mutex() const
-   {
-   return mutex_factory->make();
-   }
-
-/*
 * Get an allocator by its name
 */
-Allocator* Library_State::get_allocator(const std::string& type) const
+Allocator* Library_State::get_allocator(const std::string& type)
    {
-   Mutex_Holder lock(allocator_lock);
+   std::lock_guard<std::mutex> lock(allocator_lock);
 
    if(type != "")
       return search_map<std::string, Allocator*>(alloc_factory, type, 0);
@@ -133,7 +115,7 @@ Allocator* Library_State::get_allocator(const std::string& type) const
 */
 void Library_State::add_allocator(Allocator* allocator)
    {
-   Mutex_Holder lock(allocator_lock);
+   std::lock_guard<std::mutex> lock(allocator_lock);
 
    allocator->init();
 
@@ -146,11 +128,11 @@ void Library_State::add_allocator(Allocator* allocator)
 */
 void Library_State::set_default_allocator(const std::string& type)
    {
-   Mutex_Holder lock(allocator_lock);
-
    if(type == "")
       return;
 
+   std::lock_guard<std::mutex> lock(allocator_lock);
+
    this->set("conf", "base/default_allocator", type);
    cached_default_allocator = 0;
    }
@@ -159,9 +141,9 @@ void Library_State::set_default_allocator(const std::string& type)
 * Get a configuration value
 */
 std::string Library_State::get(const std::string& section,
-                               const std::string& key) const
+                               const std::string& key)
    {
-   Mutex_Holder lock(config_lock);
+   std::lock_guard<std::mutex> lock(config_lock);
 
    return search_map<std::string, std::string>(config,
                                                section + "/" + key, "");
@@ -171,9 +153,9 @@ std::string Library_State::get(const std::string& section,
 * See if a particular option has been set
 */
 bool Library_State::is_set(const std::string& section,
-                           const std::string& key) const
+                           const std::string& key)
    {
-   Mutex_Holder lock(config_lock);
+   std::lock_guard<std::mutex> lock(config_lock);
 
    return search_map(config, section + "/" + key, false, true);
    }
@@ -184,12 +166,11 @@ bool Library_State::is_set(const std::string& section,
 void Library_State::set(const std::string& section, const std::string& key,
                         const std::string& value, bool overwrite)
    {
-   Mutex_Holder lock(config_lock);
+   std::lock_guard<std::mutex> lock(config_lock);
 
    std::string full_key = section + "/" + key;
 
-   std::map<std::string, std::string>::const_iterator i =
-      config.find(full_key);
+   auto i = config.find(full_key);
 
    if(overwrite || i == config.end() || i->second == "")
       config[full_key] = value;
@@ -206,7 +187,7 @@ void Library_State::add_alias(const std::string& key, const std::string& value)
 /*
 * Dereference an alias to a fixed name
 */
-std::string Library_State::deref_alias(const std::string& key) const
+std::string Library_State::deref_alias(const std::string& key)
    {
    std::string result = key;
    while(is_set("alias", result))
@@ -226,7 +207,7 @@ void Library_State::set_option(const std::string& key,
 /*
 * Get an option value
 */
-std::string Library_State::option(const std::string& key) const
+std::string Library_State::option(const std::string& key)
    {
    return get("conf", key);
    }
@@ -244,73 +225,54 @@ Algorithm_Factory& Library_State::algorithm_factory()
 /*
 * Load a set of modules
 */
-void Library_State::initialize(bool thread_safe)
+void Library_State::initialize()
    {
-   if(mutex_factory)
+   if(m_algorithm_factory)
       throw Invalid_State("Library_State has already been initialized");
 
-   if(!thread_safe)
-      {
-      mutex_factory = new Noop_Mutex_Factory;
-      }
-   else
-      {
-#if defined(BOTAN_HAS_MUTEX_PTHREAD)
-      mutex_factory = new Pthread_Mutex_Factory;
-#elif defined(BOTAN_HAS_MUTEX_WIN32)
-      mutex_factory = new Win32_Mutex_Factory;
-#elif defined(BOTAN_HAS_MUTEX_QT)
-      mutex_factory Qt_Mutex_Factory;
-#else
-      throw Invalid_State("Could not find a thread-safe mutex object to use");
-#endif
-      }
-
-   allocator_lock = mutex_factory->make();
-   config_lock = mutex_factory->make();
-
    cached_default_allocator = 0;
 
    add_allocator(new Malloc_Allocator);
-   add_allocator(new Locking_Allocator(mutex_factory->make()));
+   add_allocator(new Locking_Allocator);
 
 #if defined(BOTAN_HAS_ALLOC_MMAP)
-   add_allocator(new MemoryMapping_Allocator(mutex_factory->make()));
+   add_allocator(new MemoryMapping_Allocator);
 #endif
 
    set_default_allocator("locking");
 
    load_default_config();
 
-   std::vector<Engine*> engines;
+   std::vector<Engine*> engines = {
 
 #if defined(BOTAN_HAS_ENGINE_GNU_MP)
-   engines.push_back(new GMP_Engine);
+      new GMP_Engine,
 #endif
 
 #if defined(BOTAN_HAS_ENGINE_OPENSSL)
-   engines.push_back(new OpenSSL_Engine);
+      new OpenSSL_Engine,
 #endif
 
 #if defined(BOTAN_HAS_ENGINE_AES_ISA)
-   engines.push_back(new AES_ISA_Engine);
+   new AES_ISA_Engine,
 #endif
 
 #if defined(BOTAN_HAS_ENGINE_SIMD)
-   engines.push_back(new SIMD_Engine);
+      new SIMD_Engine,
 #endif
 
 #if defined(BOTAN_HAS_ENGINE_AMD64_ASSEMBLER)
-   engines.push_back(new AMD64_Assembler_Engine);
+      new AMD64_Assembler_Engine,
 #endif
 
 #if defined(BOTAN_HAS_ENGINE_IA32_ASSEMBLER)
-   engines.push_back(new IA32_Assembler_Engine);
+      new IA32_Assembler_Engine,
 #endif
 
-   engines.push_back(new Default_Engine);
+      new Default_Engine
+   };
 
-   m_algorithm_factory = new Algorithm_Factory(engines, *mutex_factory);
+   m_algorithm_factory = new Algorithm_Factory(engines);
 
    if(!passes_self_tests(algorithm_factory()))
       throw Self_Test_Failure("Startup self tests failed");
@@ -321,8 +283,6 @@ void Library_State::initialize(bool thread_safe)
 */
 Library_State::Library_State()
    {
-   mutex_factory = 0;
-   allocator_lock = config_lock = 0;
    cached_default_allocator = 0;
    m_algorithm_factory = 0;
    }
@@ -333,6 +293,7 @@ Library_State::Library_State()
 Library_State::~Library_State()
    {
    delete m_algorithm_factory;
+   m_algorithm_factory = 0;
 
    cached_default_allocator = 0;
 
@@ -341,10 +302,6 @@ Library_State::~Library_State()
       allocators[j]->destroy();
       delete allocators[j];
       }
-
-   delete allocator_lock;
-   delete mutex_factory;
-   delete config_lock;
    }
 
 }
diff --git a/src/libstate/libstate.h b/src/libstate/libstate.h
index a0421953e..e9a08b74b 100644
--- a/src/libstate/libstate.h
+++ b/src/libstate/libstate.h
@@ -12,6 +12,7 @@
 #include <botan/allocate.h>
 #include <botan/algo_factory.h>
 
+#include <mutex>
 #include <string>
 #include <vector>
 #include <map>
@@ -27,11 +28,14 @@ class BOTAN_DLL Library_State
       Library_State();
       ~Library_State();
 
-      void initialize(bool thread_safe);
+      Library_State(const Library_State&) = delete;
+      Library_State& operator=(const Library_State&) = delete;
+
+      void initialize();
 
       Algorithm_Factory& algorithm_factory();
 
-      Allocator* get_allocator(const std::string& = "") const;
+      Allocator* get_allocator(const std::string& = "");
       void add_allocator(Allocator*);
       void set_default_allocator(const std::string&);
 
@@ -42,7 +46,7 @@ class BOTAN_DLL Library_State
       * @result the value of the parameter
       */
       std::string get(const std::string& section,
-                      const std::string& key) const;
+                      const std::string& key);
 
       /**
       * Check whether a certain parameter is set
@@ -52,7 +56,7 @@ class BOTAN_DLL Library_State
       * @result true if the parameters value is set,
       * false otherwise
       */
-      bool is_set(const std::string& section, const std::string& key) const;
+      bool is_set(const std::string& section, const std::string& key);
 
       /**
       * Set a configuration parameter.
@@ -70,7 +74,7 @@ class BOTAN_DLL Library_State
       * referred to as option).
       * @param key the desired keys name
       */
-      std::string option(const std::string& key) const;
+      std::string option(const std::string& key);
 
       /**
       * Set an option.
@@ -91,21 +95,14 @@ class BOTAN_DLL Library_State
       * @param alias the alias to resolve.
       * @return what the alias stands for
       */
-      std::string deref_alias(const std::string&) const;
-
-      class Mutex* get_mutex() const;
+      std::string deref_alias(const std::string&);
    private:
       void load_default_config();
 
-      Library_State(const Library_State&) {}
-      Library_State& operator=(const Library_State&) { return (*this); }
-
-      class Mutex_Factory* mutex_factory;
-
+      std::mutex config_lock;
       std::map<std::string, std::string> config;
-      class Mutex* config_lock;
 
-      class Mutex* allocator_lock;
+      std::mutex allocator_lock;
       std::map<std::string, Allocator*> alloc_factory;
       mutable Allocator* cached_default_allocator;
       std::vector<Allocator*> allocators;
diff --git a/src/libstate/scan_name.cpp b/src/libstate/scan_name.cpp
index 224d2e509..e16ffbcfe 100644
--- a/src/libstate/scan_name.cpp
+++ b/src/libstate/scan_name.cpp
@@ -8,6 +8,7 @@
 #include <botan/scan_name.h>
 #include <botan/parsing.h>
 #include <botan/libstate.h>
+#include <botan/exceptn.h>
 #include <stdexcept>
 
 namespace Botan {
diff --git a/src/math/gfpmath/curve_gfp.cpp b/src/math/gfpmath/curve_gfp.cpp
index 9a3ffd482..d88146dd5 100644
--- a/src/math/gfpmath/curve_gfp.cpp
+++ b/src/math/gfpmath/curve_gfp.cpp
@@ -14,7 +14,7 @@
 
 namespace Botan {
 
-void CurveGFp::set_shrd_mod(const std::tr1::shared_ptr<GFpModulus> mod)
+void CurveGFp::set_shrd_mod(const std::shared_ptr<GFpModulus> mod)
    {
    mp_mod = mod;
    mA.turn_off_sp_red_mul();// m.m. is not needed, must be trf. back
@@ -34,7 +34,7 @@ CurveGFp::CurveGFp(const GFpElement& a, const GFpElement& b,
       {
       throw Invalid_Argument("could not construct curve: moduli of arguments differ");
       }
-   std::tr1::shared_ptr<GFpModulus> p_mod = std::tr1::shared_ptr<GFpModulus>(new GFpModulus(p));
+   std::shared_ptr<GFpModulus> p_mod = std::shared_ptr<GFpModulus>(new GFpModulus(p));
    // the above is the creation of the GFpModuls object which will be shared point-wide
    // (in the context of a point of course)
    set_shrd_mod(p_mod);
@@ -44,21 +44,21 @@ CurveGFp::CurveGFp(const CurveGFp& other)
    :	mA(other.get_a()),
         mB(other.get_b())
    {
-   mp_mod = std::tr1::shared_ptr<GFpModulus>(new GFpModulus(*other.mp_mod));
+   mp_mod = std::shared_ptr<GFpModulus>(new GFpModulus(*other.mp_mod));
    assert(mp_mod->p_equal_to(mA.get_p()));
    assert(mp_mod->p_equal_to(mB.get_p()));
    set_shrd_mod(mp_mod);
    if(other.mp_mres_a.get())
       {
-      mp_mres_a = std::tr1::shared_ptr<GFpElement>(new GFpElement(*other.mp_mres_a));
+      mp_mres_a = std::shared_ptr<GFpElement>(new GFpElement(*other.mp_mres_a));
       }
    if(other.mp_mres_b.get())
       {
-      mp_mres_b = std::tr1::shared_ptr<GFpElement>(new GFpElement(*other.mp_mres_b));
+      mp_mres_b = std::shared_ptr<GFpElement>(new GFpElement(*other.mp_mres_b));
       }
    if(other.mp_mres_one.get())
       {
-      mp_mres_one = std::tr1::shared_ptr<GFpElement>(new GFpElement(*other.mp_mres_one));
+      mp_mres_one = std::shared_ptr<GFpElement>(new GFpElement(*other.mp_mres_one));
       }
 
    }
@@ -72,21 +72,21 @@ const CurveGFp& CurveGFp::operator=(const CurveGFp& other)
    mA.swap(a_tmp);
    mB.swap(b_tmp);
 
-   std::tr1::shared_ptr<GFpModulus> p_mod = std::tr1::shared_ptr<GFpModulus>(new GFpModulus(*other.mp_mod));
+   std::shared_ptr<GFpModulus> p_mod = std::shared_ptr<GFpModulus>(new GFpModulus(*other.mp_mod));
    set_shrd_mod(p_mod);
 
    // exception safety note: no problem if we have a throw from here on...
    if(other.mp_mres_a.get())
       {
-      mp_mres_a = std::tr1::shared_ptr<GFpElement>(new GFpElement(*other.mp_mres_a));
+      mp_mres_a = std::shared_ptr<GFpElement>(new GFpElement(*other.mp_mres_a));
       }
    if(other.mp_mres_b.get())
       {
-      mp_mres_b = std::tr1::shared_ptr<GFpElement>(new GFpElement(*other.mp_mres_b));
+      mp_mres_b = std::shared_ptr<GFpElement>(new GFpElement(*other.mp_mres_b));
       }
    if(other.mp_mres_one.get())
       {
-      mp_mres_one = std::tr1::shared_ptr<GFpElement>(new GFpElement(*other.mp_mres_one));
+      mp_mres_one = std::shared_ptr<GFpElement>(new GFpElement(*other.mp_mres_one));
       }
    return *this;
    }
@@ -123,7 +123,7 @@ GFpElement const CurveGFp::get_mres_a() const
    {
    if(mp_mres_a.get() == 0)
       {
-      mp_mres_a = std::tr1::shared_ptr<GFpElement>(new GFpElement(mA));
+      mp_mres_a = std::shared_ptr<GFpElement>(new GFpElement(mA));
       mp_mres_a->turn_on_sp_red_mul();
       mp_mres_a->get_mres();
       }
@@ -134,18 +134,18 @@ GFpElement const CurveGFp::get_mres_b() const
    {
    if(mp_mres_b.get() == 0)
       {
-      mp_mres_b = std::tr1::shared_ptr<GFpElement>(new GFpElement(mB));
+      mp_mres_b = std::shared_ptr<GFpElement>(new GFpElement(mB));
       mp_mres_b->turn_on_sp_red_mul();
       mp_mres_b->get_mres();
       }
    return GFpElement(*mp_mres_b);
    }
 
-std::tr1::shared_ptr<GFpElement const> const CurveGFp::get_mres_one() const
+std::shared_ptr<GFpElement const> const CurveGFp::get_mres_one() const
    {
    if(mp_mres_one.get() == 0)
       {
-      mp_mres_one = std::tr1::shared_ptr<GFpElement>(new GFpElement(mp_mod->get_p(), 1));
+      mp_mres_one = std::shared_ptr<GFpElement>(new GFpElement(mp_mod->get_p(), 1));
       mp_mres_one->turn_on_sp_red_mul();
       mp_mres_one->get_mres();
       }
diff --git a/src/math/gfpmath/curve_gfp.h b/src/math/gfpmath/curve_gfp.h
index 53bbc1f3c..5b0ec0558 100644
--- a/src/math/gfpmath/curve_gfp.h
+++ b/src/math/gfpmath/curve_gfp.h
@@ -52,7 +52,7 @@ class BOTAN_DLL CurveGFp
       * @param mod a shared pointer to a GFpModulus object suitable for
       * *this.
       */
-      void set_shrd_mod(const std::tr1::shared_ptr<GFpModulus> mod);
+      void set_shrd_mod(const std::shared_ptr<GFpModulus> mod);
 
       // getters
 
@@ -94,14 +94,14 @@ class BOTAN_DLL CurveGFp
       * function.
       * @result the GFpElement 1, transformed to its m-residue
       */
-      std::tr1::shared_ptr<GFpElement const> const get_mres_one() const;
+      std::shared_ptr<GFpElement const> const get_mres_one() const;
 
       /**
       * Get prime modulus of the field of the curve
       * @result prime modulus of the field of the curve
       */
       BigInt const get_p() const;
-      /*inline std::tr1::shared_ptr<BigInt> const get_ptr_p() const
+      /*inline std::shared_ptr<BigInt> const get_ptr_p() const
       {
       return mp_p;
       }*/
@@ -115,7 +115,7 @@ class BOTAN_DLL CurveGFp
       * pointers to a GFpModulus over different threads!
       * @result a shared pointer to a GFpModulus object
       */
-      inline std::tr1::shared_ptr<GFpModulus> const get_ptr_mod() const
+      inline std::shared_ptr<GFpModulus> const get_ptr_mod() const
          {
          return mp_mod;
          }
@@ -127,12 +127,12 @@ class BOTAN_DLL CurveGFp
       void swap(CurveGFp& other);
 
    private:
-      std::tr1::shared_ptr<GFpModulus> mp_mod;
+      std::shared_ptr<GFpModulus> mp_mod;
       GFpElement mA;
       GFpElement mB;
-      mutable std::tr1::shared_ptr<GFpElement> mp_mres_a;
-      mutable std::tr1::shared_ptr<GFpElement> mp_mres_b;
-      mutable std::tr1::shared_ptr<GFpElement> mp_mres_one;
+      mutable std::shared_ptr<GFpElement> mp_mres_a;
+      mutable std::shared_ptr<GFpElement> mp_mres_b;
+      mutable std::shared_ptr<GFpElement> mp_mres_one;
    };
 
 // relational operators
diff --git a/src/math/gfpmath/gfp_element.cpp b/src/math/gfpmath/gfp_element.cpp
index 4b95e68ff..872000a58 100644
--- a/src/math/gfpmath/gfp_element.cpp
+++ b/src/math/gfpmath/gfp_element.cpp
@@ -173,13 +173,13 @@ GFpElement::GFpElement(const BigInt& p, const BigInt& value, bool use_montgm)
      m_is_trf(false)
    {
    assert(mp_mod.get() == 0);
-   mp_mod = std::tr1::shared_ptr<GFpModulus>(new GFpModulus(p));
+   mp_mod = std::shared_ptr<GFpModulus>(new GFpModulus(p));
    assert(mp_mod->m_p_dash == 0);
    if(m_use_montgm)
       ensure_montgm_precomp();
    }
 
-GFpElement::GFpElement(std::tr1::shared_ptr<GFpModulus> const mod, const BigInt& value, bool use_montgm)
+GFpElement::GFpElement(std::shared_ptr<GFpModulus> const mod, const BigInt& value, bool use_montgm)
    : mp_mod(),
      m_value(value % mod->m_p),
      m_use_montgm(use_montgm),
@@ -246,7 +246,7 @@ void GFpElement::ensure_montgm_precomp() const
 
    }
 
-void GFpElement::set_shrd_mod(std::tr1::shared_ptr<GFpModulus> const p_mod)
+void GFpElement::set_shrd_mod(std::shared_ptr<GFpModulus> const p_mod)
    {
    mp_mod = p_mod;
    }
diff --git a/src/math/gfpmath/gfp_element.h b/src/math/gfpmath/gfp_element.h
index 0fc4e0c7f..d340c77b1 100644
--- a/src/math/gfpmath/gfp_element.h
+++ b/src/math/gfpmath/gfp_element.h
@@ -12,14 +12,7 @@
 #include <botan/bigint.h>
 #include <botan/gfp_modulus.h>
 #include <iosfwd>
-
-#if defined(BOTAN_USE_STD_TR1)
-  #include <tr1/memory>
-#elif defined(BOTAN_USE_BOOST_TR1)
-  #include <boost/tr1/memory.hpp>
-#else
-  #error "Please choose a TR1 implementation in build.h"
-#endif
+#include <memory>
 
 namespace Botan {
 
@@ -59,7 +52,7 @@ class BOTAN_DLL GFpElement
       * @param value the element value
       * @param use_montgm whether this object will use Montgomery multiplication
       */
-      explicit GFpElement(std::tr1::shared_ptr<GFpModulus> const mod,
+      explicit GFpElement(std::shared_ptr<GFpModulus> const mod,
                           const BigInt& value, bool use_mongm = false);
 
       /**
@@ -170,7 +163,7 @@ class BOTAN_DLL GFpElement
       * the shared GFpModulus objects!
       * @result the shared pointer to the GFpModulus of *this
       */
-      inline std::tr1::shared_ptr<GFpModulus> const get_ptr_mod() const
+      inline std::shared_ptr<GFpModulus> const get_ptr_mod() const
          {
          return mp_mod;
          }
@@ -183,7 +176,7 @@ class BOTAN_DLL GFpElement
       * the shared GFpModulus objects!
       * @param mod a shared pointer to a GFpModulus that will be held in *this
       */
-      void set_shrd_mod(std::tr1::shared_ptr<GFpModulus> const mod);
+      void set_shrd_mod(std::shared_ptr<GFpModulus> const mod);
 
       /**
       * Tells whether this GFpElement is currently transformed to it´ m-residue,
@@ -245,7 +238,7 @@ class BOTAN_DLL GFpElement
       void trf_to_mres() const;
       void trf_to_ordres() const;
 
-      std::tr1::shared_ptr<GFpModulus> mp_mod;
+      std::shared_ptr<GFpModulus> mp_mod;
       mutable BigInt m_value; // ordinary residue or m-residue respectively
       mutable BigInt workspace;
 
diff --git a/src/math/gfpmath/info.txt b/src/math/gfpmath/info.txt
index abbdb0a47..e1bf892c7 100644
--- a/src/math/gfpmath/info.txt
+++ b/src/math/gfpmath/info.txt
@@ -1,9 +1,7 @@
-uses_tr1 yes
+define BIGINT_GFP
 
 load_on auto
 
-define BIGINT_GFP
-
 <add>
 curve_gfp.cpp
 curve_gfp.h
diff --git a/src/math/gfpmath/point_gfp.cpp b/src/math/gfpmath/point_gfp.cpp
index b67631f7b..b19687537 100644
--- a/src/math/gfpmath/point_gfp.cpp
+++ b/src/math/gfpmath/point_gfp.cpp
@@ -108,7 +108,7 @@ const PointGFp& PointGFp::assign_within_same_curve(PointGFp const& other)
    return *this;
    }
 
-void PointGFp::set_shrd_mod(std::tr1::shared_ptr<GFpModulus> p_mod)
+void PointGFp::set_shrd_mod(std::shared_ptr<GFpModulus> p_mod)
    {
    mX.set_shrd_mod(p_mod);
    mY.set_shrd_mod(p_mod);
@@ -132,7 +132,7 @@ void PointGFp::ensure_worksp() const
          }
       }
 
-   mp_worksp_gfp_el = std::tr1::shared_ptr<std::vector<GFpElement> >(new std::vector<GFpElement>);
+   mp_worksp_gfp_el = std::shared_ptr<std::vector<GFpElement> >(new std::vector<GFpElement>);
    mp_worksp_gfp_el->reserve(9);
    for (u32bit i=0; i<GFPEL_WKSP_SIZE; i++)
       {
@@ -336,8 +336,8 @@ PointGFp& PointGFp::mult_this_secure(const BigInt& scalar,
    // use montgomery mult. in this operation
    this->turn_on_sp_red_mul();
 
-   std::tr1::shared_ptr<PointGFp> H(new PointGFp(this->mC));
-   std::tr1::shared_ptr<PointGFp> tmp; // used for AADA
+   std::shared_ptr<PointGFp> H(new PointGFp(this->mC));
+   std::shared_ptr<PointGFp> tmp; // used for AADA
 
    PointGFp P(*this);
    BigInt m(scalar);
@@ -476,15 +476,15 @@ PointGFp& PointGFp::operator*=(const BigInt& scalar)
    return *this;
    }
 
-inline std::tr1::shared_ptr<PointGFp> PointGFp::mult_loop(int l,
+inline std::shared_ptr<PointGFp> PointGFp::mult_loop(int l,
                                                           const BigInt& m,
-                                                          std::tr1::shared_ptr<PointGFp> H,
-                                                          std::tr1::shared_ptr<PointGFp> tmp,
+                                                          std::shared_ptr<PointGFp> H,
+                                                          std::shared_ptr<PointGFp> tmp,
                                                           const PointGFp& P)
    {
    //assert(l >= (int)m.bits()- 1);
    tmp = H;
-   std::tr1::shared_ptr<PointGFp> to_add(new PointGFp(P)); // we just need some point
+   std::shared_ptr<PointGFp> to_add(new PointGFp(P)); // we just need some point
    // so that we can use op=
    // inside the loop
    for (int i=l; i >=0; i--)
diff --git a/src/math/gfpmath/point_gfp.h b/src/math/gfpmath/point_gfp.h
index 62b3bc7da..ce2bf1626 100644
--- a/src/math/gfpmath/point_gfp.h
+++ b/src/math/gfpmath/point_gfp.h
@@ -232,7 +232,7 @@ class BOTAN_DLL PointGFp
       * @param mod a shared pointer to a GFpModulus that will
       * be held in the members *this
       */
-      void set_shrd_mod(std::tr1::shared_ptr<GFpModulus> p_mod);
+      void set_shrd_mod(std::shared_ptr<GFpModulus> p_mod);
 
       static GFpElement decompress(bool yMod2, GFpElement const& x, const CurveGFp& curve);
 
@@ -240,9 +240,9 @@ class BOTAN_DLL PointGFp
       static const u32bit GFPEL_WKSP_SIZE = 9;
       void ensure_worksp() const;
 
-      inline std::tr1::shared_ptr<PointGFp> mult_loop(int l, const BigInt& m,
-                                                      std::tr1::shared_ptr<PointGFp> H,
-                                                      std::tr1::shared_ptr<PointGFp> tmp,
+      inline std::shared_ptr<PointGFp> mult_loop(int l, const BigInt& m,
+                                                      std::shared_ptr<PointGFp> H,
+                                                      std::shared_ptr<PointGFp> tmp,
                                                       const PointGFp& P);
 
       CurveGFp mC;
@@ -255,7 +255,7 @@ class BOTAN_DLL PointGFp
       mutable bool mZpow2_set;
       mutable bool mZpow3_set;
       mutable bool mAZpow4_set;
-      mutable std::tr1::shared_ptr<std::vector<GFpElement> > mp_worksp_gfp_el;
+      mutable std::shared_ptr<std::vector<GFpElement> > mp_worksp_gfp_el;
 
    };
 
diff --git a/src/math/numbertheory/dsa_gen.cpp b/src/math/numbertheory/dsa_gen.cpp
index 83646e50e..d5f6dc792 100644
--- a/src/math/numbertheory/dsa_gen.cpp
+++ b/src/math/numbertheory/dsa_gen.cpp
@@ -54,7 +54,7 @@ bool generate_dsa_primes(RandomNumberGenerator& rng,
          "Generating a DSA parameter set with a " + to_string(qbits) +
          "long q requires a seed at least as many bits long");
 
-   std::auto_ptr<HashFunction> hash(
+   std::unique_ptr<HashFunction> hash(
       af.make_hash_function("SHA-" + to_string(qbits)));
 
    const u32bit HASH_SIZE = hash->OUTPUT_LENGTH;
diff --git a/src/math/numbertheory/numthry.cpp b/src/math/numbertheory/numthry.cpp
index 448681333..5e36288ff 100644
--- a/src/math/numbertheory/numthry.cpp
+++ b/src/math/numbertheory/numthry.cpp
@@ -20,7 +20,7 @@ u32bit miller_rabin_test_iterations(u32bit bits, bool verify)
    {
    struct mapping { u32bit bits; u32bit verify_iter; u32bit check_iter; };
 
-   static const mapping tests[] = {
+   const mapping tests[] = {
       {   50, 55, 25 },
       {  100, 38, 22 },
       {  160, 32, 18 },
diff --git a/src/mutex/info.txt b/src/mutex/info.txt
deleted file mode 100644
index 0f2836b64..000000000
--- a/src/mutex/info.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-define MUTEX_WRAPPERS
-
-load_on auto
-
-<add>
-mutex.h
-</add>
diff --git a/src/mutex/mutex.h b/src/mutex/mutex.h
deleted file mode 100644
index a04ff83c9..000000000
--- a/src/mutex/mutex.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
-* Mutex
-* (C) 1999-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#ifndef BOTAN_MUTEX_H__
-#define BOTAN_MUTEX_H__
-
-#include <botan/exceptn.h>
-
-namespace Botan {
-
-/*
-* Mutex Base Class
-*/
-class BOTAN_DLL Mutex
-   {
-   public:
-      virtual void lock() = 0;
-      virtual void unlock() = 0;
-      virtual ~Mutex() {}
-   };
-
-/*
-* Mutex Factory
-*/
-class BOTAN_DLL Mutex_Factory
-   {
-   public:
-      virtual Mutex* make() = 0;
-      virtual ~Mutex_Factory() {}
-   };
-
-/*
-* Mutex Holding Class
-*/
-class BOTAN_DLL Mutex_Holder
-   {
-   public:
-      Mutex_Holder(Mutex* m) : mux(m)
-         {
-         if(!mux)
-            throw Invalid_Argument("Mutex_Holder: Argument was NULL");
-         mux->lock();
-         }
-
-      ~Mutex_Holder() { mux->unlock(); }
-   private:
-      Mutex* mux;
-   };
-
-}
-
-#endif
diff --git a/src/mutex/noop_mutex/info.txt b/src/mutex/noop_mutex/info.txt
deleted file mode 100644
index 6025959c2..000000000
--- a/src/mutex/noop_mutex/info.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-load_on auto
-
-define MUTEX_NOOP
-
-<add>
-mux_noop.cpp
-mux_noop.h
-</add>
diff --git a/src/mutex/noop_mutex/mux_noop.cpp b/src/mutex/noop_mutex/mux_noop.cpp
deleted file mode 100644
index 5c45084fe..000000000
--- a/src/mutex/noop_mutex/mux_noop.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
-* No-Op Mutex Factory
-* (C) 1999-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#include <botan/mux_noop.h>
-
-namespace Botan {
-
-/*
-* No-Op Mutex Factory
-*/
-Mutex* Noop_Mutex_Factory::make()
-   {
-   class Noop_Mutex : public Mutex
-      {
-      public:
-         class Mutex_State_Error : public Internal_Error
-            {
-            public:
-               Mutex_State_Error(const std::string& where) :
-                  Internal_Error("Noop_Mutex::" + where + ": " +
-                                 "Mutex is already " + where + "ed") {}
-            };
-
-         void lock()
-            {
-            if(locked)
-               throw Mutex_State_Error("lock");
-            locked = true;
-            }
-
-         void unlock()
-            {
-            if(!locked)
-               throw Mutex_State_Error("unlock");
-            locked = false;
-            }
-
-         Noop_Mutex() { locked = false; }
-      private:
-         bool locked;
-      };
-
-   return new Noop_Mutex;
-   }
-
-}
diff --git a/src/mutex/noop_mutex/mux_noop.h b/src/mutex/noop_mutex/mux_noop.h
deleted file mode 100644
index 94201cb7c..000000000
--- a/src/mutex/noop_mutex/mux_noop.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
-* No-Op Mutex Factory
-* (C) 1999-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#ifndef BOTAN_NOOP_MUTEX_FACTORY_H__
-#define BOTAN_NOOP_MUTEX_FACTORY_H__
-
-#include <botan/mutex.h>
-
-namespace Botan {
-
-/*
-* No-Op Mutex Factory
-*/
-class BOTAN_DLL Noop_Mutex_Factory : public Mutex_Factory
-   {
-   public:
-      Mutex* make();
-   };
-
-}
-
-#endif
diff --git a/src/mutex/pthreads/info.txt b/src/mutex/pthreads/info.txt
deleted file mode 100644
index 7315c186a..000000000
--- a/src/mutex/pthreads/info.txt
+++ /dev/null
@@ -1,28 +0,0 @@
-define MUTEX_PTHREAD
-
-load_on auto
-
-<add>
-mux_pthr.cpp
-mux_pthr.h
-</add>
-
-<libs>
-all!qnx,freebsd,dragonfly,openbsd,netbsd -> pthread
-</libs>
-
-<os>
-aix
-cygwin
-darwin
-freebsd
-dragonfly
-hpux
-irix
-linux
-netbsd
-openbsd
-qnx
-solaris
-tru64
-</os>
diff --git a/src/mutex/pthreads/mux_pthr.cpp b/src/mutex/pthreads/mux_pthr.cpp
deleted file mode 100644
index 9f1d9816e..000000000
--- a/src/mutex/pthreads/mux_pthr.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
-* Pthread Mutex
-* (C) 1999-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#include <botan/mux_pthr.h>
-#include <botan/exceptn.h>
-
-#ifndef _POSIX_C_SOURCE
-  #define _POSIX_C_SOURCE 199506
-#endif
-
-#include <pthread.h>
-
-namespace Botan {
-
-/*
-* Pthread Mutex Factory
-*/
-Mutex* Pthread_Mutex_Factory::make()
-   {
-
-   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;
-      };
-
-   return new Pthread_Mutex();
-   }
-
-}
diff --git a/src/mutex/pthreads/mux_pthr.h b/src/mutex/pthreads/mux_pthr.h
deleted file mode 100644
index 118853947..000000000
--- a/src/mutex/pthreads/mux_pthr.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
-* Pthread Mutex
-* (C) 1999-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#ifndef BOTAN_MUTEX_PTHREAD_H__
-#define BOTAN_MUTEX_PTHREAD_H__
-
-#include <botan/mutex.h>
-
-namespace Botan {
-
-/*
-* Pthread Mutex Factory
-*/
-class BOTAN_DLL Pthread_Mutex_Factory : public Mutex_Factory
-   {
-   public:
-      Mutex* make();
-   };
-
-}
-
-#endif
diff --git a/src/mutex/qt_mutex/info.txt b/src/mutex/qt_mutex/info.txt
deleted file mode 100644
index 346f04c81..000000000
--- a/src/mutex/qt_mutex/info.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-define MUTEX_QT
-
-load_on request
-
-# 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/src/mutex/qt_mutex/mux_qt.cpp b/src/mutex/qt_mutex/mux_qt.cpp
deleted file mode 100644
index 0f670c8b4..000000000
--- a/src/mutex/qt_mutex/mux_qt.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
-* Qt Thread Mutex
-* (C) 2004-2007 Justin Karneges
-*     2004-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#include <botan/mux_qt.h>
-#include <qmutex.h>
-
-#if !defined(QT_THREAD_SUPPORT)
-   #error Your version of Qt does not support threads or mutexes
-#endif
-
-namespace Botan {
-
-/*
-* Qt Mutex Factory
-*/
-Mutex* Qt_Mutex_Factory::make()
-   {
-   class Qt_Mutex : public Mutex
-      {
-      public:
-         void lock() { mutex.lock(); }
-         void unlock() { mutex.unlock(); }
-      private:
-         QMutex mutex;
-      };
-
-   return new Qt_Mutex();
-   }
-
-}
diff --git a/src/mutex/qt_mutex/mux_qt.h b/src/mutex/qt_mutex/mux_qt.h
deleted file mode 100644
index 5aed77f4b..000000000
--- a/src/mutex/qt_mutex/mux_qt.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
-* Qt Mutex
-* (C) 2004-2007 Justin Karneges
-*     2004-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#ifndef BOTAN_MUTEX_QT_H__
-#define BOTAN_MUTEX_QT_H__
-
-#include <botan/mutex.h>
-
-namespace Botan {
-
-/*
-* Qt Mutex
-*/
-class BOTAN_DLL Qt_Mutex_Factory : public Mutex_Factory
-   {
-   public:
-      Mutex* make();
-   };
-
-}
-
-#endif
diff --git a/src/mutex/win32_crit_section/info.txt b/src/mutex/win32_crit_section/info.txt
deleted file mode 100644
index 1533ca2da..000000000
--- a/src/mutex/win32_crit_section/info.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-define MUTEX_WIN32
-
-load_on auto
-
-<os>
-cygwin
-windows
-mingw
-</os>
diff --git a/src/mutex/win32_crit_section/mux_win32.cpp b/src/mutex/win32_crit_section/mux_win32.cpp
deleted file mode 100644
index 2a967892b..000000000
--- a/src/mutex/win32_crit_section/mux_win32.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
-* Win32 Mutex
-* (C) 2006 Luca Piccarreta
-*     2006-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#include <botan/mux_win32.h>
-#include <windows.h>
-
-namespace Botan {
-
-/*
-* Win32 Mutex Factory
-*/
-Mutex* Win32_Mutex_Factory::make()
-   {
-   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;
-      };
-
-   return new Win32_Mutex();
-   }
-
-}
diff --git a/src/mutex/win32_crit_section/mux_win32.h b/src/mutex/win32_crit_section/mux_win32.h
deleted file mode 100644
index a91850e71..000000000
--- a/src/mutex/win32_crit_section/mux_win32.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
-* Win32 Mutex
-* (C) 2006 Luca Piccarreta
-*     2006-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#ifndef BOTAN_MUTEX_WIN32_H__
-#define BOTAN_MUTEX_WIN32_H__
-
-#include <botan/mutex.h>
-
-namespace Botan {
-
-/*
-* Win32 Mutex Factory
-*/
-class BOTAN_DLL Win32_Mutex_Factory : public Mutex_Factory
-   {
-   public:
-      Mutex* make();
-   };
-}
-
-#endif
diff --git a/src/pubkey/dsa/dsa_op.cpp b/src/pubkey/dsa/dsa_op.cpp
index 5b921441d..03eaebfb0 100644
--- a/src/pubkey/dsa/dsa_op.cpp
+++ b/src/pubkey/dsa/dsa_op.cpp
@@ -1,11 +1,12 @@
 /*
 * DSA Operations
-* (C) 1999-2007 Jack Lloyd
+* (C) 1999-2009 Jack Lloyd
 *
 * Distributed under the terms of the Botan license
 */
 
 #include <botan/dsa_op.h>
+#include <botan/async.h>
 
 namespace Botan {
 
@@ -40,8 +41,14 @@ bool Default_DSA_Op::verify(const byte msg[], u32bit msg_len,
       return false;
 
    s = inverse_mod(s, q);
-   s = mod_p.multiply(powermod_g_p(mod_q.multiply(s, i)),
-                      powermod_y_p(mod_q.multiply(s, r)));
+
+   auto future_s_i = std_async(
+      [&]() { return powermod_g_p(mod_q.multiply(s, i)); });
+
+   BigInt s_r = powermod_y_p(mod_q.multiply(s, r));
+   BigInt s_i = future_s_i.get();
+
+   s = mod_p.multiply(s_i, s_r);
 
    return (mod_q.reduce(s) == r);
    }
@@ -55,11 +62,15 @@ SecureVector<byte> Default_DSA_Op::sign(const byte in[], u32bit length,
    if(x == 0)
       throw Internal_Error("Default_DSA_Op::sign: No private key");
 
+   auto future_r = std_async([&]() { return mod_q.reduce(powermod_g_p(k)); });
+
    const BigInt& q = group.get_q();
    BigInt i(in, length);
 
-   BigInt r = mod_q.reduce(powermod_g_p(k));
-   BigInt s = mod_q.multiply(inverse_mod(k, q), mul_add(x, r, i));
+   BigInt s = inverse_mod(k, q);
+   BigInt r = future_r.get();
+
+   s = mod_q.multiply(s, mul_add(x, r, i));
 
    if(r.is_zero() || s.is_zero())
       throw Internal_Error("Default_DSA_Op::sign: r or s was zero");
diff --git a/src/pubkey/ec_dompar/ec_dompar.cpp b/src/pubkey/ec_dompar/ec_dompar.cpp
index 0b5a6e681..e05b01465 100644
--- a/src/pubkey/ec_dompar/ec_dompar.cpp
+++ b/src/pubkey/ec_dompar/ec_dompar.cpp
@@ -553,7 +553,7 @@ EC_Domain_Params decode_ber_ec_dompar(SecureVector<byte> const& encoded)
    BER_Decoder dec(encoded);
    BER_Object obj = dec.get_next_object();
    ASN1_Tag tag = obj.type_tag;
-   std::auto_ptr<EC_Domain_Params> p_result;
+   std::unique_ptr<EC_Domain_Params> p_result;
 
    if(tag == OBJECT_ID)
       {
diff --git a/src/pubkey/ecc_key/ecc_key.cpp b/src/pubkey/ecc_key/ecc_key.cpp
index 677a5088e..8d9e89f1e 100644
--- a/src/pubkey/ecc_key/ecc_key.cpp
+++ b/src/pubkey/ecc_key/ecc_key.cpp
@@ -165,7 +165,7 @@ void EC_PrivateKey::generate_private_key(RandomNumberGenerator& rng)
 
    BigInt tmp_private_value(0);
    tmp_private_value = BigInt::random_integer(rng, 1, mp_dom_pars->get_order());
-   mp_public_point = std::auto_ptr<PointGFp>( new PointGFp (mp_dom_pars->get_base_point()));
+   mp_public_point = std::unique_ptr<PointGFp>( new PointGFp (mp_dom_pars->get_base_point()));
    mp_public_point->mult_this_secure(tmp_private_value,
                                      mp_dom_pars->get_order(),
                                      mp_dom_pars->get_order()-1);
diff --git a/src/pubkey/ecc_key/ecc_key.h b/src/pubkey/ecc_key/ecc_key.h
index 0ca9a0e75..9d5f57d9f 100644
--- a/src/pubkey/ecc_key/ecc_key.h
+++ b/src/pubkey/ecc_key/ecc_key.h
@@ -103,8 +103,8 @@ class BOTAN_DLL EC_PublicKey : public virtual Public_Key
 
       SecureVector<byte> m_enc_public_point; // stores the public point
 
-      std::auto_ptr<EC_Domain_Params> mp_dom_pars;
-      std::auto_ptr<PointGFp> mp_public_point;
+      std::unique_ptr<EC_Domain_Params> mp_dom_pars;
+      std::unique_ptr<PointGFp> mp_public_point;
       EC_dompar_enc m_param_enc;
    };
 
diff --git a/src/pubkey/ecdsa/ecdsa.cpp b/src/pubkey/ecdsa/ecdsa.cpp
index 9d352c70f..aba571eb6 100644
--- a/src/pubkey/ecdsa/ecdsa.cpp
+++ b/src/pubkey/ecdsa/ecdsa.cpp
@@ -19,7 +19,7 @@ namespace Botan {
 ECDSA_PrivateKey::ECDSA_PrivateKey(RandomNumberGenerator& rng,
                                    const EC_Domain_Params& dom_pars)
    {
-   mp_dom_pars = std::auto_ptr<EC_Domain_Params>(new EC_Domain_Params(dom_pars));
+   mp_dom_pars = std::unique_ptr<EC_Domain_Params>(new EC_Domain_Params(dom_pars));
    generate_private_key(rng);
 
    try
@@ -90,11 +90,10 @@ void ECDSA_PublicKey::set_domain_parameters(const EC_Domain_Params& dom_pars)
       throw Invalid_State("EC_PublicKey::set_domain_parameters(): point does not lie on provided curve");
       }
 
-   std::auto_ptr<EC_Domain_Params> p_tmp_pars(new EC_Domain_Params(dom_pars));
-   ECDSA_Core tmp_ecdsa_core(*p_tmp_pars, BigInt(0), tmp_pp);
+   mp_dom_pars.reset(new EC_Domain_Params(dom_pars));
+   ECDSA_Core tmp_ecdsa_core(*mp_dom_pars, BigInt(0), tmp_pp);
    mp_public_point.reset(new PointGFp(tmp_pp));
    m_ecdsa_core = tmp_ecdsa_core;
-   mp_dom_pars = p_tmp_pars;
    }
 
 void ECDSA_PublicKey::set_all_values(const ECDSA_PublicKey& other)
@@ -134,8 +133,8 @@ bool ECDSA_PublicKey::verify(const byte msg[], u32bit msg_len,
 ECDSA_PublicKey::ECDSA_PublicKey(const EC_Domain_Params& dom_par,
                                  const PointGFp& public_point)
    {
-   mp_dom_pars = std::auto_ptr<EC_Domain_Params>(new EC_Domain_Params(dom_par));
-   mp_public_point = std::auto_ptr<PointGFp>(new PointGFp(public_point));
+   mp_dom_pars = std::unique_ptr<EC_Domain_Params>(new EC_Domain_Params(dom_par));
+   mp_public_point = std::unique_ptr<PointGFp>(new PointGFp(public_point));
    m_param_enc = ENC_EXPLICIT;
    m_ecdsa_core = ECDSA_Core(*mp_dom_pars, BigInt(0), *mp_public_point);
    }
diff --git a/src/pubkey/eckaeg/eckaeg.cpp b/src/pubkey/eckaeg/eckaeg.cpp
index dc6eb925b..a2dec5279 100644
--- a/src/pubkey/eckaeg/eckaeg.cpp
+++ b/src/pubkey/eckaeg/eckaeg.cpp
@@ -62,8 +62,8 @@ void ECKAEG_PublicKey::X509_load_hook()
 
 ECKAEG_PublicKey::ECKAEG_PublicKey(EC_Domain_Params const& dom_par, PointGFp const& public_point)
    {
-   mp_dom_pars = std::auto_ptr<EC_Domain_Params>(new EC_Domain_Params(dom_par));
-   mp_public_point = std::auto_ptr<PointGFp>(new PointGFp(public_point));
+   mp_dom_pars = std::unique_ptr<EC_Domain_Params>(new EC_Domain_Params(dom_par));
+   mp_public_point = std::unique_ptr<PointGFp>(new PointGFp(public_point));
    if(mp_public_point->get_curve() != mp_dom_pars->get_curve())
       {
       throw Invalid_Argument("ECKAEG_PublicKey(): curve of arg. point and curve of arg. domain parameters are different");
diff --git a/src/pubkey/eckaeg/eckaeg.h b/src/pubkey/eckaeg/eckaeg.h
index 7c4dfdb2d..b8c164967 100644
--- a/src/pubkey/eckaeg/eckaeg.h
+++ b/src/pubkey/eckaeg/eckaeg.h
@@ -90,7 +90,7 @@ class BOTAN_DLL ECKAEG_PrivateKey : public ECKAEG_PublicKey,
       ECKAEG_PrivateKey(RandomNumberGenerator& rng,
                         const EC_Domain_Params& dom_pars)
          {
-         mp_dom_pars = std::auto_ptr<EC_Domain_Params>(new EC_Domain_Params(dom_pars));
+         mp_dom_pars = std::unique_ptr<EC_Domain_Params>(new EC_Domain_Params(dom_pars));
          generate_private_key(rng);
          mp_public_point->check_invariants();
          m_eckaeg_core = ECKAEG_Core(*mp_dom_pars, m_private_value, *mp_public_point);
diff --git a/src/pubkey/elgamal/elg_op.cpp b/src/pubkey/elgamal/elg_op.cpp
index 1e476ab7a..db828a300 100644
--- a/src/pubkey/elgamal/elg_op.cpp
+++ b/src/pubkey/elgamal/elg_op.cpp
@@ -1,11 +1,12 @@
 /*
 * ElGamal Operations
-* (C) 1999-2007 Jack Lloyd
+* (C) 1999-2009 Jack Lloyd
 *
 * Distributed under the terms of the Botan license
 */
 
 #include <botan/elg_op.h>
+#include <botan/async.h>
 
 namespace Botan {
 
@@ -33,8 +34,9 @@ SecureVector<byte> Default_ELG_Op::encrypt(const byte in[], u32bit length,
    if(m >= p)
       throw Invalid_Argument("Default_ELG_Op::encrypt: Input is too large");
 
-   BigInt a = powermod_g_p(k);
+   auto future_a = std_async([&]() { return powermod_g_p(k); });
    BigInt b = mod_p.multiply(m, powermod_y_p(k));
+   BigInt a = future_a.get();
 
    SecureVector<byte> output(2*p.bytes());
    a.binary_encode(output + (p.bytes() - a.bytes()));
diff --git a/src/pubkey/if_algo/if_op.cpp b/src/pubkey/if_algo/if_op.cpp
index 27aef453e..7974bf4f0 100644
--- a/src/pubkey/if_algo/if_op.cpp
+++ b/src/pubkey/if_algo/if_op.cpp
@@ -1,12 +1,13 @@
 /*
-* IF (RSA/RW) Operation
-* (C) 1999-2007 Jack Lloyd
+* Integer Factorization Scheme (RSA/RW) Operation
+* (C) 1999-2009 Jack Lloyd
 *
 * Distributed under the terms of the Botan license
 */
 
 #include <botan/if_op.h>
 #include <botan/numthry.h>
+#include <botan/async.h>
 
 namespace Botan {
 
@@ -38,8 +39,15 @@ BigInt Default_IF_Op::private_op(const BigInt& i) const
    if(q == 0)
       throw Internal_Error("Default_IF_Op::private_op: No private key");
 
-   BigInt j1 = powermod_d1_p(i);
+   /*
+   * A simple std::bind(powermod_d1_p, i) would work instead of a
+   * lambda but GCC 4.5's std::result_of doesn't use decltype and gets
+   * confused
+   */
+   auto future_j1 = std_async([&]() { return powermod_d1_p(i); });
    BigInt j2 = powermod_d2_q(i);
+   BigInt j1 = future_j1.get();
+
    j1 = reducer.reduce(sub_mul(j1, j2, c));
    return mul_add(j1, q, j2);
    }
diff --git a/src/pubkey/keypair/keypair.cpp b/src/pubkey/keypair/keypair.cpp
index 486577fc5..7eaa33395 100644
--- a/src/pubkey/keypair/keypair.cpp
+++ b/src/pubkey/keypair/keypair.cpp
@@ -22,8 +22,8 @@ void check_key(RandomNumberGenerator& rng,
    if(encryptor->maximum_input_size() == 0)
       return;
 
-   std::auto_ptr<PK_Encryptor> enc(encryptor);
-   std::auto_ptr<PK_Decryptor> dec(decryptor);
+   std::unique_ptr<PK_Encryptor> enc(encryptor);
+   std::unique_ptr<PK_Decryptor> dec(decryptor);
 
    SecureVector<byte> message(enc->maximum_input_size() - 1);
    rng.randomize(message, message.size());
@@ -43,8 +43,8 @@ void check_key(RandomNumberGenerator& rng,
 void check_key(RandomNumberGenerator& rng,
                PK_Signer* signer, PK_Verifier* verifier)
    {
-   std::auto_ptr<PK_Signer> sig(signer);
-   std::auto_ptr<PK_Verifier> ver(verifier);
+   std::unique_ptr<PK_Signer> sig(signer);
+   std::unique_ptr<PK_Verifier> ver(verifier);
 
    SecureVector<byte> message(16);
    rng.randomize(message, message.size());
diff --git a/src/pubkey/nr/nr_op.cpp b/src/pubkey/nr/nr_op.cpp
index b5efa3d37..49aa9fc00 100644
--- a/src/pubkey/nr/nr_op.cpp
+++ b/src/pubkey/nr/nr_op.cpp
@@ -1,11 +1,12 @@
 /*
 * NR Operations
-* (C) 1999-2007 Jack Lloyd
+* (C) 1999-2009 Jack Lloyd
 *
 * Distributed under the terms of the Botan license
 */
 
 #include <botan/nr_op.h>
+#include <botan/async.h>
 
 namespace Botan {
 
@@ -37,7 +38,10 @@ SecureVector<byte> Default_NR_Op::verify(const byte in[], u32bit length) const
    if(c.is_zero() || c >= q || d >= q)
       throw Invalid_Argument("Default_NR_Op::verify: Invalid signature");
 
-   BigInt i = mod_p.multiply(powermod_g_p(d), powermod_y_p(c));
+   auto future_y_c = std_async([&]() { return powermod_y_p(c); });
+   BigInt g_d = powermod_g_p(d);
+
+   BigInt i = mod_p.multiply(g_d, future_y_c.get());
    return BigInt::encode(mod_q.reduce(c - i));
    }
 
diff --git a/src/pubkey/pk_codecs/pkcs8.cpp b/src/pubkey/pk_codecs/pkcs8.cpp
index 3d73b7ab1..b5b0044a8 100644
--- a/src/pubkey/pk_codecs/pkcs8.cpp
+++ b/src/pubkey/pk_codecs/pkcs8.cpp
@@ -89,7 +89,7 @@ SecureVector<byte> PKCS8_decode(DataSource& source, const User_Interface& ui,
          if(is_encrypted)
             {
             DataSource_Memory params(pbe_alg_id.parameters);
-            std::auto_ptr<PBE> pbe(get_pbe(pbe_alg_id.oid, params));
+            std::unique_ptr<PBE> pbe(get_pbe(pbe_alg_id.oid, params));
 
             User_Interface::UI_Result result = User_Interface::OK;
             const std::string passphrase =
@@ -138,7 +138,7 @@ SecureVector<byte> PKCS8_decode(DataSource& source, const User_Interface& ui,
 */
 void encode(const Private_Key& key, Pipe& pipe, X509_Encoding encoding)
    {
-   std::auto_ptr<PKCS8_Encoder> encoder(key.pkcs8_encoder());
+   std::unique_ptr<PKCS8_Encoder> encoder(key.pkcs8_encoder());
    if(!encoder.get())
       throw Encoding_Error("PKCS8::encode: Key does not support encoding");
 
@@ -175,7 +175,7 @@ void encrypt_key(const Private_Key& key,
    encode(key, raw_key, RAW_BER);
    raw_key.end_msg();
 
-   std::auto_ptr<PBE> pbe(get_pbe(((pbe_algo != "") ? pbe_algo : DEFAULT_PBE)));
+   std::unique_ptr<PBE> pbe(get_pbe(((pbe_algo != "") ? pbe_algo : DEFAULT_PBE)));
 
    pbe->new_params(rng);
    pbe->set_key(pass);
@@ -244,13 +244,13 @@ Private_Key* load_key(DataSource& source,
       throw PKCS8_Exception("Unknown algorithm OID: " +
                             alg_id.oid.as_string());
 
-   std::auto_ptr<Private_Key> key(get_private_key(alg_name));
+   std::unique_ptr<Private_Key> key(get_private_key(alg_name));
 
    if(!key.get())
       throw PKCS8_Exception("Unknown PK algorithm/OID: " + alg_name + ", " +
                            alg_id.oid.as_string());
 
-   std::auto_ptr<PKCS8_Decoder> decoder(key->pkcs8_decoder(rng));
+   std::unique_ptr<PKCS8_Decoder> decoder(key->pkcs8_decoder(rng));
 
    if(!decoder.get())
       throw Decoding_Error("Key does not support PKCS #8 decoding");
diff --git a/src/pubkey/pk_codecs/x509_key.cpp b/src/pubkey/pk_codecs/x509_key.cpp
index 3fec15f7f..1a2acfa64 100644
--- a/src/pubkey/pk_codecs/x509_key.cpp
+++ b/src/pubkey/pk_codecs/x509_key.cpp
@@ -24,7 +24,7 @@ namespace X509 {
 */
 void encode(const Public_Key& key, Pipe& pipe, X509_Encoding encoding)
    {
-   std::auto_ptr<X509_Encoder> encoder(key.x509_encoder());
+   std::unique_ptr<X509_Encoder> encoder(key.x509_encoder());
    if(!encoder.get())
       throw Encoding_Error("X509::encode: Key does not support encoding");
 
@@ -94,12 +94,12 @@ Public_Key* load_key(DataSource& source)
          throw Decoding_Error("Unknown algorithm OID: " +
                               alg_id.oid.as_string());
 
-      std::auto_ptr<Public_Key> key_obj(get_public_key(alg_name));
+      std::unique_ptr<Public_Key> key_obj(get_public_key(alg_name));
       if(!key_obj.get())
          throw Decoding_Error("Unknown PK algorithm/OID: " + alg_name + ", " +
                               alg_id.oid.as_string());
 
-      std::auto_ptr<X509_Decoder> decoder(key_obj->x509_decoder());
+      std::unique_ptr<X509_Decoder> decoder(key_obj->x509_decoder());
 
       if(!decoder.get())
          throw Decoding_Error("Key does not support X.509 decoding");
diff --git a/src/rng/auto_rng/info.txt b/src/rng/auto_rng/info.txt
index d5abfc757..357dc17ad 100644
--- a/src/rng/auto_rng/info.txt
+++ b/src/rng/auto_rng/info.txt
@@ -10,5 +10,4 @@ auto_rng.cpp
 <requires>
 hmac
 sha2
-timer
 </requires>
diff --git a/src/rng/hmac_rng/hmac_rng.cpp b/src/rng/hmac_rng/hmac_rng.cpp
index 26ada9047..b43e6d9c2 100644
--- a/src/rng/hmac_rng/hmac_rng.cpp
+++ b/src/rng/hmac_rng/hmac_rng.cpp
@@ -8,7 +8,6 @@
 #include <botan/hmac_rng.h>
 #include <botan/loadstor.h>
 #include <botan/xor_buf.h>
-#include <botan/stl_util.h>
 #include <algorithm>
 
 namespace Botan {
@@ -213,8 +212,8 @@ HMAC_RNG::~HMAC_RNG()
    delete extractor;
    delete prf;
 
-   std::for_each(entropy_sources.begin(), entropy_sources.end(),
-                 del_fun<EntropySource>());
+   for(auto i = entropy_sources.begin(); i != entropy_sources.end(); ++i)
+      delete *i;
 
    counter = 0;
    }
diff --git a/src/rng/randpool/randpool.cpp b/src/rng/randpool/randpool.cpp
index fb51db300..f4ce84079 100644
--- a/src/rng/randpool/randpool.cpp
+++ b/src/rng/randpool/randpool.cpp
@@ -8,9 +8,8 @@
 #include <botan/randpool.h>
 #include <botan/loadstor.h>
 #include <botan/xor_buf.h>
-#include <botan/timer.h>
-#include <botan/stl_util.h>
 #include <algorithm>
+#include <chrono>
 
 namespace Botan {
 
@@ -51,7 +50,9 @@ void Randpool::randomize(byte out[], u32bit length)
 */
 void Randpool::update_buffer()
    {
-   const u64bit timestamp = system_time();
+   const u64bit timestamp =
+      std::chrono::duration_cast<std::chrono::nanoseconds>(
+         std::chrono::high_resolution_clock::now().time_since_epoch()).count();
 
    for(u32bit i = 0; i != counter.size(); ++i)
       if(++counter[i])
@@ -206,8 +207,8 @@ Randpool::~Randpool()
    delete cipher;
    delete mac;
 
-   std::for_each(entropy_sources.begin(), entropy_sources.end(),
-                 del_fun<EntropySource>());
+   for(auto i = entropy_sources.begin(); i != entropy_sources.end(); ++i)
+      delete *i;
    }
 
 }
diff --git a/src/s2k/s2k.h b/src/s2k/s2k.h
index 7af92519b..ca86ab77a 100644
--- a/src/s2k/s2k.h
+++ b/src/s2k/s2k.h
@@ -87,12 +87,13 @@ class BOTAN_DLL S2K
 
       S2K() { iter = 0; }
       virtual ~S2K() {}
-   private:
-      S2K(const S2K&) {}
-      S2K& operator=(const S2K&) { return (*this); }
 
+      S2K(const S2K&) = delete;
+      S2K& operator=(const S2K&) = delete;
+   private:
       virtual OctetString derive(u32bit, const std::string&,
                                  const byte[], u32bit, u32bit) const = 0;
+
       SecureVector<byte> salt;
       u32bit iter;
    };
diff --git a/src/selftest/selftest.cpp b/src/selftest/selftest.cpp
index 660be36e4..d5b184f8f 100644
--- a/src/selftest/selftest.cpp
+++ b/src/selftest/selftest.cpp
@@ -114,8 +114,7 @@ namespace {
 void verify_results(const std::string& algo,
                     const std::map<std::string, bool>& results)
    {
-   for(std::map<std::string, bool>::const_iterator i = results.begin();
-       i != results.end(); ++i)
+   for(auto i = results.begin(); i != results.end(); ++i)
       {
       if(!i->second)
          throw Self_Test_Failure(algo + " self-test failed, provider "+
diff --git a/src/timer/cpu_counter/info.txt b/src/timer/cpu_counter/info.txt
deleted file mode 100644
index 2ab1343bc..000000000
--- a/src/timer/cpu_counter/info.txt
+++ /dev/null
@@ -1,36 +0,0 @@
-define TIMER_HARDWARE
-
-load_on asm_ok
-
-<add>
-tm_hard.cpp
-tm_hard.h
-</add>
-
-<cc>
-gcc
-</cc>
-
-<arch>
-
-# RDTSC: Pentium and up
-i586
-i686
-athlon
-pentium3
-pentium4
-pentium-m
-amd64
-
-ppc     # PPC timebase register
-ppc64   # PPC timebase register
-alpha   # rpcc
-sparc64 # %tick register
-ia64    # ar.itc
-s390x
-hppa
-</arch>
-
-<requires>
-timer
-</requires>
diff --git a/src/timer/cpu_counter/tm_hard.cpp b/src/timer/cpu_counter/tm_hard.cpp
deleted file mode 100644
index 9e31aee39..000000000
--- a/src/timer/cpu_counter/tm_hard.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
-* Hardware Timer
-* (C) 1999-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#include <botan/tm_hard.h>
-
-namespace Botan {
-
-/*
-* Get the timestamp
-*/
-u64bit Hardware_Timer::clock() const
-   {
-   u64bit rtc = 0;
-
-#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 = (static_cast<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 = (static_cast<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));
-
-#elif defined(BOTAN_TARGET_ARCH_IS_IA64)
-   asm volatile("mov %0=ar.itc" : "=r" (rtc));
-
-#elif defined(BOTAN_TARGET_ARCH_IS_S390X)
-   asm volatile("stck 0(%0)" : : "a" (&rtc) : "memory", "cc");
-
-#elif defined(BOTAN_TARGET_ARCH_IS_HPPA)
-   asm volatile("mfctl 16,%0" : "=r" (rtc)); // 64-bit only?
-
-#else
-   #error "Unsure how to access hardware timer on this system"
-#endif
-
-   return rtc;
-   }
-
-}
diff --git a/src/timer/cpu_counter/tm_hard.h b/src/timer/cpu_counter/tm_hard.h
deleted file mode 100644
index 2e338eca8..000000000
--- a/src/timer/cpu_counter/tm_hard.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
-* Hardware Timer
-* (C) 1999-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#ifndef BOTAN_TIMER_HARDWARE_H__
-#define BOTAN_TIMER_HARDWARE_H__
-
-#include <botan/timer.h>
-
-namespace Botan {
-
-/*
-* Hardware Timer
-*/
-class BOTAN_DLL Hardware_Timer : public Timer
-   {
-   public:
-      /*
-      @todo: Add sync(Timer& wall_clock, bool milliseconds) which busy
-      loops using wall_clock and tries to guess the tick rate of the
-      hardware counter, allowing it to be used for benchmarks, etc
-      */
-
-      std::string name() const { return "Hardware Timer"; }
-      u64bit clock() const;
-   };
-
-}
-
-#endif
diff --git a/src/timer/gettimeofday/info.txt b/src/timer/gettimeofday/info.txt
deleted file mode 100644
index d1f6f7d74..000000000
--- a/src/timer/gettimeofday/info.txt
+++ /dev/null
@@ -1,24 +0,0 @@
-define TIMER_UNIX
-
-load_on auto
-
-<os>
-aix
-beos
-cygwin
-darwin
-freebsd
-dragonfly
-hpux
-irix
-linux
-netbsd
-openbsd
-qnx
-solaris
-tru64
-</os>
-
-<requires>
-timer
-</requires>
diff --git a/src/timer/gettimeofday/tm_unix.cpp b/src/timer/gettimeofday/tm_unix.cpp
deleted file mode 100644
index 9d8ac4a04..000000000
--- a/src/timer/gettimeofday/tm_unix.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-* Unix Timer
-* (C) 1999-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#include <botan/tm_unix.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/src/timer/gettimeofday/tm_unix.h b/src/timer/gettimeofday/tm_unix.h
deleted file mode 100644
index c304dbb5c..000000000
--- a/src/timer/gettimeofday/tm_unix.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
-* Unix Timer
-* (C) 1999-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#ifndef BOTAN_TIMER_UNIX_H__
-#define BOTAN_TIMER_UNIX_H__
-
-#include <botan/timer.h>
-
-namespace Botan {
-
-/*
-* Unix Timer
-*/
-class BOTAN_DLL Unix_Timer : public Timer
-   {
-   public:
-      std::string name() const { return "Unix gettimeofday"; }
-      u64bit clock() const;
-   };
-
-}
-
-#endif
diff --git a/src/timer/info.txt b/src/timer/info.txt
deleted file mode 100644
index 1dff5ab6f..000000000
--- a/src/timer/info.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-define TIMER
-
-load_on auto
-
-<add>
-timer.cpp
-timer.h
-</add>
-
-<requires>
-rng
-</requires>
diff --git a/src/timer/posix_rt/info.txt b/src/timer/posix_rt/info.txt
deleted file mode 100644
index 4b23a74fc..000000000
--- a/src/timer/posix_rt/info.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-define TIMER_POSIX
-
-load_on auto
-
-<add>
-tm_posix.cpp
-tm_posix.h
-</add>
-
-<libs>
-linux -> rt
-</libs>
-
-# The *BSDs put clock_gettime in sys/time.h, not time.h like POSIX says
-<os>
-cygwin
-linux
-#freebsd
-dragonfly
-#netbsd
-#openbsd
-</os>
-
-<requires>
-timer
-</requires>
diff --git a/src/timer/posix_rt/tm_posix.cpp b/src/timer/posix_rt/tm_posix.cpp
deleted file mode 100644
index 96182025c..000000000
--- a/src/timer/posix_rt/tm_posix.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
-* POSIX Timer
-* (C) 1999-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#include <botan/tm_posix.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/src/timer/posix_rt/tm_posix.h b/src/timer/posix_rt/tm_posix.h
deleted file mode 100644
index 8bedccfa2..000000000
--- a/src/timer/posix_rt/tm_posix.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
-* POSIX Timer
-* (C) 1999-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#ifndef BOTAN_TIMER_POSIX_H__
-#define BOTAN_TIMER_POSIX_H__
-
-#include <botan/timer.h>
-
-namespace Botan {
-
-/*
-* POSIX Timer
-*/
-class BOTAN_DLL POSIX_Timer : public Timer
-   {
-   public:
-      std::string name() const { return "POSIX clock_gettime"; }
-      u64bit clock() const;
-   };
-
-}
-
-#endif
diff --git a/src/timer/timer.cpp b/src/timer/timer.cpp
deleted file mode 100644
index 16d7dc368..000000000
--- a/src/timer/timer.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-/**
-* Timestamp Functions
-* (C) 1999-2009 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#include <botan/timer.h>
-#include <botan/loadstor.h>
-#include <ctime>
-
-namespace Botan {
-
-/**
-* Get the system clock
-*/
-u64bit system_time()
-   {
-   return static_cast<u64bit>(std::time(0));
-   }
-
-/*
-* Convert a time_t to a struct tm
-*/
-std::tm time_t_to_tm(u64bit timer)
-   {
-   std::time_t time_val = static_cast<std::time_t>(timer);
-
-   std::tm* tm_p = std::gmtime(&time_val);
-   if (tm_p == 0)
-      throw Encoding_Error("time_t_to_tm could not convert");
-   return (*tm_p);
-   }
-
-/**
-* Read the clock and return the output
-*/
-void Timer::poll(Entropy_Accumulator& accum)
-   {
-   const u64bit clock_value = this->clock();
-   accum.add(clock_value, 0);
-   }
-
-/**
-* Combine a two time values into a single one
-*/
-u64bit Timer::combine_timers(u32bit seconds, u32bit parts, u32bit parts_hz)
-   {
-   static const u64bit NANOSECONDS_UNITS = 1000000000;
-
-   u64bit res = seconds * NANOSECONDS_UNITS;
-   res += parts * (NANOSECONDS_UNITS / parts_hz);
-   return res;
-   }
-
-/**
-* ANSI Clock
-*/
-u64bit ANSI_Clock_Timer::clock() const
-   {
-   return combine_timers(std::time(0), std::clock(), CLOCKS_PER_SEC);
-   }
-
-}
diff --git a/src/timer/timer.h b/src/timer/timer.h
deleted file mode 100644
index 603027f6d..000000000
--- a/src/timer/timer.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/**
-* Timestamp Functions
-* (C) 1999-2009 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#ifndef BOTAN_TIMERS_H__
-#define BOTAN_TIMERS_H__
-
-#include <botan/rng.h>
-#include <ctime>
-
-namespace Botan {
-
-/*
-* Time Access/Conversion Functions
-*/
-BOTAN_DLL u64bit system_time();
-
-BOTAN_DLL std::tm time_t_to_tm(u64bit);
-
-/**
-* Timer Interface
-*/
-class BOTAN_DLL Timer : public EntropySource
-   {
-   public:
-      /**
-      @return nanoseconds resolution timestamp, unknown epoch
-      */
-      virtual u64bit clock() const = 0;
-
-      void poll(Entropy_Accumulator& accum);
-
-      virtual ~Timer() {}
-   protected:
-      static u64bit combine_timers(u32bit, u32bit, u32bit);
-   };
-
-/**
-* ANSI Clock Timer
-*/
-class BOTAN_DLL ANSI_Clock_Timer : public Timer
-   {
-   public:
-      std::string name() const { return "ANSI clock"; }
-      u64bit clock() const;
-   };
-
-}
-
-#endif
diff --git a/src/timer/win32_query_perf_ctr/info.txt b/src/timer/win32_query_perf_ctr/info.txt
deleted file mode 100644
index 67db5bc95..000000000
--- a/src/timer/win32_query_perf_ctr/info.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-define TIMER_WIN32
-
-load_on auto
-
-<os>
-cygwin
-windows
-mingw
-</os>
-
-<libs>
-windows -> user32.lib
-</libs>
-
-<requires>
-timer
-</requires>
diff --git a/src/timer/win32_query_perf_ctr/tm_win32.cpp b/src/timer/win32_query_perf_ctr/tm_win32.cpp
deleted file mode 100644
index 6b878e6e2..000000000
--- a/src/timer/win32_query_perf_ctr/tm_win32.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-* Win32 Timer
-* (C) 1999-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#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/src/timer/win32_query_perf_ctr/tm_win32.h b/src/timer/win32_query_perf_ctr/tm_win32.h
deleted file mode 100644
index 5bcb720ab..000000000
--- a/src/timer/win32_query_perf_ctr/tm_win32.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
-* Win32 Timer
-* (C) 1999-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#ifndef BOTAN_TIMER_WIN32_H__
-#define BOTAN_TIMER_WIN32_H__
-
-#include <botan/timer.h>
-
-namespace Botan {
-
-/*
-* Win32 Timer
-*/
-class BOTAN_DLL Win32_Timer : public Timer
-   {
-   public:
-      std::string name() const { return "Win32 QueryPerformanceCounter"; }
-      u64bit clock() const;
-   };
-
-}
-
-#endif
diff --git a/src/utils/async.h b/src/utils/async.h
new file mode 100644
index 000000000..85702c114
--- /dev/null
+++ b/src/utils/async.h
@@ -0,0 +1,33 @@
+/**
+* Standin for C++0x's std::async
+* (C) 2009 Jack Lloyd
+*
+* Distributed under the terms of the Botan license
+*/
+
+#ifndef BOTAN_ASYNC_H__
+#define BOTAN_ASYNC_H__
+
+#include <future>
+#include <thread>
+
+namespace Botan {
+
+/**
+* A simple version of std::async (as it is not in GCC 4.5)
+* Will be removed once GCC supports it natively
+*/
+template<typename F>
+auto std_async(F f) -> std::unique_future<decltype(f())>
+   {
+   typedef decltype(f()) result_type;
+   std::packaged_task<result_type ()> task(std::move(f));
+   std::unique_future<result_type> future = task.get_future();
+   std::thread thread(std::move(task));
+   thread.detach();
+   return future;
+   }
+
+}
+
+#endif
diff --git a/src/utils/datastor/datastor.cpp b/src/utils/datastor/datastor.cpp
index 129dad9bf..5e7c94634 100644
--- a/src/utils/datastor/datastor.cpp
+++ b/src/utils/datastor/datastor.cpp
@@ -14,16 +14,6 @@
 namespace Botan {
 
 /*
-* Default Matcher transform operation (identity)
-*/
-std::pair<std::string, std::string>
-Data_Store::Matcher::transform(const std::string& key,
-                               const std::string& value) const
-   {
-   return std::make_pair(key, value);
-   }
-
-/*
 * Data_Store Equality Comparison
 */
 bool Data_Store::operator==(const Data_Store& other) const
@@ -42,20 +32,14 @@ bool Data_Store::has_value(const std::string& key) const
 /*
 * Search based on an arbitrary predicate
 */
-std::multimap<std::string, std::string>
-Data_Store::search_with(const Matcher& matcher) const
+std::multimap<std::string, std::string> Data_Store::search_for(
+   std::function<bool (std::string, std::string)> predicate) const
    {
    std::multimap<std::string, std::string> out;
 
-   std::multimap<std::string, std::string>::const_iterator i =
-      contents.begin();
-
-   while(i != contents.end())
-      {
-      if(matcher(i->first, i->second))
-         out.insert(matcher.transform(i->first, i->second));
-      ++i;
-      }
+   for(auto i = contents.begin(); i != contents.end(); ++i)
+      if(predicate(i->first, i->second))
+         out.insert(std::make_pair(i->first, i->second));
 
    return out;
    }
@@ -65,12 +49,9 @@ Data_Store::search_with(const Matcher& matcher) const
 */
 std::vector<std::string> Data_Store::get(const std::string& looking_for) const
    {
-   typedef std::multimap<std::string, std::string>::const_iterator iter;
-
-   std::pair<iter, iter> range = contents.equal_range(looking_for);
-
    std::vector<std::string> out;
-   for(iter i = range.first; i != range.second; ++i)
+   auto range = contents.equal_range(looking_for);
+   for(auto i = range.first; i != range.second; ++i)
       out.push_back(i->second);
    return out;
    }
diff --git a/src/utils/datastor/datastor.h b/src/utils/datastor/datastor.h
index 7ee626fda..516d0a16b 100644
--- a/src/utils/datastor/datastor.h
+++ b/src/utils/datastor/datastor.h
@@ -9,6 +9,7 @@
 #define BOTAN_DATA_STORE_H__
 
 #include <botan/secmem.h>
+#include <functional>
 #include <utility>
 #include <string>
 #include <vector>
@@ -22,22 +23,10 @@ namespace Botan {
 class BOTAN_DLL Data_Store
    {
    public:
-      class BOTAN_DLL Matcher
-         {
-         public:
-            virtual bool operator()(const std::string&,
-                                    const std::string&) const = 0;
-
-            virtual std::pair<std::string, std::string>
-               transform(const std::string&, const std::string&) const;
-
-            virtual ~Matcher() {}
-         };
-
       bool operator==(const Data_Store&) const;
 
-      std::multimap<std::string, std::string>
-         search_with(const Matcher&) const;
+      std::multimap<std::string, std::string> search_for(
+         std::function<bool (std::string, std::string)> predicate) const;
 
       std::vector<std::string> get(const std::string&) const;
 
diff --git a/src/utils/parsing.cpp b/src/utils/parsing.cpp
index 58a8e0b38..63dfce64f 100644
--- a/src/utils/parsing.cpp
+++ b/src/utils/parsing.cpp
@@ -19,14 +19,14 @@ u32bit to_u32bit(const std::string& number)
    {
    u32bit n = 0;
 
-   for(std::string::const_iterator j = number.begin(); j != number.end(); ++j)
+   for(auto i = number.begin(); i != number.end(); ++i)
       {
       const u32bit OVERFLOW_MARK = 0xFFFFFFFF / 10;
 
-      if(*j == ' ')
+      if(*i == ' ')
          continue;
 
-      byte digit = Charset::char2digit(*j);
+      byte digit = Charset::char2digit(*i);
 
       if((n > OVERFLOW_MARK) || (n == OVERFLOW_MARK && digit > 5))
          throw Decoding_Error("to_u32bit: Integer overflow");
@@ -106,15 +106,15 @@ std::vector<std::string> parse_algorithm_name(const std::string& namex)
    elems.push_back(name.substr(0, name.find('(')));
    name = name.substr(name.find('('));
 
-   for(std::string::const_iterator j = name.begin(); j != name.end(); ++j)
+   for(auto i = name.begin(); i != name.end(); ++i)
       {
-      char c = *j;
+      char c = *i;
 
       if(c == '(')
          ++level;
       if(c == ')')
          {
-         if(level == 1 && j == name.end() - 1)
+         if(level == 1 && i == name.end() - 1)
             {
             if(elems.size() == 1)
                elems.push_back(substring.substr(1));
@@ -123,7 +123,7 @@ std::vector<std::string> parse_algorithm_name(const std::string& namex)
             return elems;
             }
 
-         if(level == 0 || (level == 1 && j != name.end() - 1))
+         if(level == 0 || (level == 1 && i != name.end() - 1))
             throw Invalid_Algorithm_Name(namex);
          --level;
          }
@@ -155,16 +155,16 @@ std::vector<std::string> split_on(const std::string& str, char delim)
    if(str == "") return elems;
 
    std::string substr;
-   for(std::string::const_iterator j = str.begin(); j != str.end(); ++j)
+   for(auto i = str.begin(); i != str.end(); ++i)
       {
-      if(*j == delim)
+      if(*i == delim)
          {
          if(substr != "")
             elems.push_back(substr);
          substr.clear();
          }
       else
-         substr += *j;
+         substr += *i;
       }
 
    if(substr == "")
@@ -182,9 +182,9 @@ std::vector<u32bit> parse_asn1_oid(const std::string& oid)
    std::string substring;
    std::vector<u32bit> oid_elems;
 
-   for(std::string::const_iterator j = oid.begin(); j != oid.end(); ++j)
+   for(auto i = oid.begin(); i != oid.end(); ++i)
       {
-      char c = *j;
+      char c = *i;
 
       if(c == '.')
          {
@@ -212,8 +212,8 @@ std::vector<u32bit> parse_asn1_oid(const std::string& oid)
 */
 bool x500_name_cmp(const std::string& name1, const std::string& name2)
    {
-   std::string::const_iterator p1 = name1.begin();
-   std::string::const_iterator p2 = name2.begin();
+   auto p1 = name1.begin();
+   auto p2 = name2.begin();
 
    while((p1 != name1.end()) && Charset::is_space(*p1)) ++p1;
    while((p2 != name2.end()) && Charset::is_space(*p2)) ++p2;
@@ -258,9 +258,9 @@ u32bit string_to_ipv4(const std::string& str)
 
    u32bit ip = 0;
 
-   for(size_t j = 0; j != parts.size(); j++)
+   for(auto part = parts.begin(); part != parts.end(); ++part)
       {
-      u32bit octet = to_u32bit(parts[j]);
+      u32bit octet = to_u32bit(*part);
 
       if(octet > 255)
          throw Decoding_Error("Invalid IP string " + str);
@@ -278,11 +278,11 @@ std::string ipv4_to_string(u32bit ip)
    {
    std::string str;
 
-   for(size_t j = 0; j != sizeof(ip); j++)
+   for(size_t i = 0; i != sizeof(ip); i++)
       {
-      if(j)
+      if(i)
          str += ".";
-      str += to_string(get_byte(j, ip));
+      str += to_string(get_byte(i, ip));
       }
 
    return str;
diff --git a/src/utils/stl_util.h b/src/utils/stl_util.h
index 18c8b149b..4cc081733 100644
--- a/src/utils/stl_util.h
+++ b/src/utils/stl_util.h
@@ -13,22 +13,6 @@
 namespace Botan {
 
 /*
-* Copy-on-Predicate Algorithm
-*/
-template<typename InputIterator, typename OutputIterator, typename Predicate>
-OutputIterator copy_if(InputIterator current, InputIterator end,
-                       OutputIterator dest, Predicate copy_p)
-   {
-   while(current != end)
-      {
-      if(copy_p(*current))
-         *dest++ = *current;
-      ++current;
-      }
-   return dest;
-   }
-
-/*
 * Searching through a std::map
 */
 template<typename K, typename V>
@@ -53,25 +37,6 @@ inline R search_map(const std::map<K, V>& mapping, const K& key,
    }
 
 /*
-* Function adaptor for delete operation
-*/
-template<class T>
-class del_fun : public std::unary_function<T, void>
-   {
-   public:
-      void operator()(T* ptr) { delete ptr; }
-   };
-
-/*
-* Delete the second half of a pair of objects
-*/
-template<typename Pair>
-void delete2nd(Pair& pair)
-   {
-   delete pair.second;
-   }
-
-/*
 * Insert a key/value pair into a multimap
 */
 template<typename K, typename V>
diff --git a/src/utils/time.h b/src/utils/time.h
new file mode 100644
index 000000000..3052aec44
--- /dev/null
+++ b/src/utils/time.h
@@ -0,0 +1,39 @@
+/*
+* Time Functions
+* (C) 2009 Jack Lloyd
+*
+* Distributed under the terms of the Botan license
+*/
+
+#ifndef BOTAN_TIME_OPS_H__
+#define BOTAN_TIME_OPS_H__
+
+#include <ctime>
+
+namespace Botan {
+
+/*
+* Convert a time_t value to a struct tm
+*/
+inline std::tm time_t_to_tm(u64bit time_int)
+   {
+   std::time_t time_val = static_cast<std::time_t>(time_int);
+
+   std::tm* tm_p = std::gmtime(&time_val);
+   if (tm_p == 0)
+      throw Encoding_Error("time_t_to_tm could not convert");
+   return (*tm_p);
+   }
+
+/**
+* Get the system clock
+*/
+inline u64bit system_time()
+   {
+   return static_cast<u64bit>(std::time(0));
+   }
+
+}
+
+
+#endif