propagate from branch 'net.randombit.botan' (head 303b2518a80553214b1e5ab4d9b96ef54629cbc7)

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

147 files changed, 758 insertions, 1213 deletions

diff --git a/doc/examples/gtk/Makefile b/Attic/gtk/Makefile
index 10e069bb3..10e069bb3 100644
--- a/doc/examples/gtk/Makefile
+++ b/Attic/gtk/Makefile
diff --git a/doc/examples/gtk/dsa.cpp b/Attic/gtk/dsa.cpp
index 2cd91b0e8..2cd91b0e8 100644
--- a/doc/examples/gtk/dsa.cpp
+++ b/Attic/gtk/dsa.cpp
diff --git a/doc/examples/gtk/gtk_ui.cpp b/Attic/gtk/gtk_ui.cpp
index d4e9cd238..d4e9cd238 100644
--- a/doc/examples/gtk/gtk_ui.cpp
+++ b/Attic/gtk/gtk_ui.cpp
diff --git a/doc/examples/gtk/gtk_ui.h b/Attic/gtk/gtk_ui.h
index 065a4f76b..065a4f76b 100644
--- a/doc/examples/gtk/gtk_ui.h
+++ b/Attic/gtk/gtk_ui.h
diff --git a/doc/examples/gtk/readme.txt b/Attic/gtk/readme.txt
index 4f3691166..4f3691166 100644
--- a/doc/examples/gtk/readme.txt
+++ b/Attic/gtk/readme.txt
diff --git a/src/mutex/info.txt b/Attic/mutex/info.txt
index af4cf9bb3..af4cf9bb3 100644
--- a/src/mutex/info.txt
+++ b/Attic/mutex/info.txt
diff --git a/src/mutex/mutex.h b/Attic/mutex/mutex.h
index f209466d5..f209466d5 100644
--- a/src/mutex/mutex.h
+++ b/Attic/mutex/mutex.h
diff --git a/src/mutex/noop_mutex/info.txt b/Attic/mutex/noop_mutex/info.txt
index 16670b1dd..16670b1dd 100644
--- a/src/mutex/noop_mutex/info.txt
+++ b/Attic/mutex/noop_mutex/info.txt
diff --git a/src/mutex/noop_mutex/mux_noop.cpp b/Attic/mutex/noop_mutex/mux_noop.cpp
index 18151274a..18151274a 100644
--- a/src/mutex/noop_mutex/mux_noop.cpp
+++ b/Attic/mutex/noop_mutex/mux_noop.cpp
diff --git a/src/mutex/noop_mutex/mux_noop.h b/Attic/mutex/noop_mutex/mux_noop.h
index 20989a635..20989a635 100644
--- a/src/mutex/noop_mutex/mux_noop.h
+++ b/Attic/mutex/noop_mutex/mux_noop.h
diff --git a/src/mutex/pthreads/info.txt b/Attic/mutex/pthreads/info.txt
index 1d826b61c..1d826b61c 100644
--- a/src/mutex/pthreads/info.txt
+++ b/Attic/mutex/pthreads/info.txt
diff --git a/src/mutex/pthreads/mux_pthr.cpp b/Attic/mutex/pthreads/mux_pthr.cpp
index 165132239..165132239 100644
--- a/src/mutex/pthreads/mux_pthr.cpp
+++ b/Attic/mutex/pthreads/mux_pthr.cpp
diff --git a/src/mutex/pthreads/mux_pthr.h b/Attic/mutex/pthreads/mux_pthr.h
index 5cecd09ad..5cecd09ad 100644
--- a/src/mutex/pthreads/mux_pthr.h
+++ b/Attic/mutex/pthreads/mux_pthr.h
diff --git a/src/mutex/qt_mutex/info.txt b/Attic/mutex/qt_mutex/info.txt
index 7b014f886..7b014f886 100644
--- a/src/mutex/qt_mutex/info.txt
+++ b/Attic/mutex/qt_mutex/info.txt
diff --git a/src/mutex/qt_mutex/mux_qt.cpp b/Attic/mutex/qt_mutex/mux_qt.cpp
index da4e5ce5c..da4e5ce5c 100644
--- a/src/mutex/qt_mutex/mux_qt.cpp
+++ b/Attic/mutex/qt_mutex/mux_qt.cpp
diff --git a/src/mutex/qt_mutex/mux_qt.h b/Attic/mutex/qt_mutex/mux_qt.h
index 3805acc3b..3805acc3b 100644
--- a/src/mutex/qt_mutex/mux_qt.h
+++ b/Attic/mutex/qt_mutex/mux_qt.h
diff --git a/src/mutex/win32_crit_section/info.txt b/Attic/mutex/win32_crit_section/info.txt
index d90b8b64b..d90b8b64b 100644
--- a/src/mutex/win32_crit_section/info.txt
+++ b/Attic/mutex/win32_crit_section/info.txt
diff --git a/src/mutex/win32_crit_section/mux_win32.cpp b/Attic/mutex/win32_crit_section/mux_win32.cpp
index fa6051798..fa6051798 100644
--- a/src/mutex/win32_crit_section/mux_win32.cpp
+++ b/Attic/mutex/win32_crit_section/mux_win32.cpp
diff --git a/src/mutex/win32_crit_section/mux_win32.h b/Attic/mutex/win32_crit_section/mux_win32.h
index 2aa51e18b..2aa51e18b 100644
--- a/src/mutex/win32_crit_section/mux_win32.h
+++ b/Attic/mutex/win32_crit_section/mux_win32.h
diff --git a/checks/bench.cpp b/checks/bench.cpp
index d4531d181..8502d0232 100644
--- a/checks/bench.cpp
+++ b/checks/bench.cpp
@@ -14,9 +14,12 @@
 #include <botan/engine.h>
 #include <botan/parsing.h>
 #include <botan/symkey.h>
-#include <botan/time.h>
 #include <botan/hex.h>
 
+#include <chrono>
+
+typedef std::chrono::high_resolution_clock benchmark_clock;
+
 #include "common.h"
 #include "bench.h"
 
@@ -220,17 +223,23 @@ bool bench_algo(const std::string& algo,
          Botan::Pipe pipe(filt, new Botan::BitBucket);
          pipe.start_msg();
 
-         const u64bit start = Botan::get_nanoseconds_clock();
-         u64bit nanoseconds_used = 0;
+         std::chrono::nanoseconds max_time(nanoseconds_max);
+         std::chrono::nanoseconds time_used(0);
+
+         auto start = benchmark_clock::now();
+
          u64bit reps = 0;
 
-         while(nanoseconds_used < nanoseconds_max)
+         while(time_used < max_time)
             {
             pipe.write(&buf[0], buf.size());
             ++reps;
-            nanoseconds_used = Botan::get_nanoseconds_clock() - start;
+            time_used = benchmark_clock::now() - start;
             }
 
+         u64bit nanoseconds_used =
+            std::chrono::duration_cast<std::chrono::nanoseconds>(time_used).count();
+
          double mbytes_per_second =
             (953.67 * (buf.size() * reps)) / nanoseconds_used;
 
diff --git a/checks/cvc_tests.cpp b/checks/cvc_tests.cpp
index d6f5e1312..49bb94925 100644
--- a/checks/cvc_tests.cpp
+++ b/checks/cvc_tests.cpp
@@ -161,8 +161,8 @@ void test_enc_gen_selfsigned(RandomNumberGenerator& rng)
       }
    CHECK(ill_date_exc2);
    //cout << "readable = '" << cert_in.get_ced().readable_string() << "'\n";
-   std::auto_ptr<Public_Key> p_pk = cert_in.subject_public_key();
-   //auto_ptr<ECDSA_PublicKey> ecdsa_pk = dynamic_cast<auto_ptr<ECDSA_PublicKey> >(p_pk);
+   std::unique_ptr<Public_Key> p_pk = cert_in.subject_public_key();
+   //unique_ptr<ECDSA_PublicKey> ecdsa_pk = dynamic_cast<auto_ptr<ECDSA_PublicKey> >(p_pk);
    ECDSA_PublicKey* p_ecdsa_pk = dynamic_cast<ECDSA_PublicKey*>(p_pk.get());
    // let´s see if encoding is truely implicitca, because this is what the key should have
    // been set to when decoding (see above)(because it has no domain params):
@@ -180,7 +180,7 @@ void test_enc_gen_selfsigned(RandomNumberGenerator& rng)
    CHECK(exc);
    // set them and try again
    //cert_in.set_domain_parameters(dom_pars);
-   std::auto_ptr<Public_Key> p_pk2 = cert_in.subject_public_key();
+   std::unique_ptr<Public_Key> p_pk2 = cert_in.subject_public_key();
    ECDSA_PublicKey* p_ecdsa_pk2 = dynamic_cast<ECDSA_PublicKey*>(p_pk2.get());
    //p_ecdsa_pk2->set_domain_parameters(dom_pars);
    CHECK(p_ecdsa_pk2->domain().get_order() == dom_pars.get_order());
@@ -211,7 +211,7 @@ void test_enc_gen_req(RandomNumberGenerator& rng)
    // read and check signature...
    EAC1_1_Req req_in(TEST_DATA_DIR "/my_cv_req.ber");
    //req_in.set_domain_parameters(dom_pars);
-   std::auto_ptr<Public_Key> p_pk = req_in.subject_public_key();
+   std::unique_ptr<Public_Key> p_pk = req_in.subject_public_key();
    ECDSA_PublicKey* p_ecdsa_pk = dynamic_cast<ECDSA_PublicKey*>(p_pk.get());
    //p_ecdsa_pk->set_domain_parameters(dom_pars);
    CHECK(p_ecdsa_pk->domain().get_order() == dom_pars.get_order());
@@ -226,7 +226,7 @@ void test_cvc_req_ext(RandomNumberGenerator&)
    EAC1_1_Req req_in(TEST_DATA_DIR "/DE1_flen_chars_cvcRequest_ECDSA.der");
    EC_Domain_Params dom_pars(OID("1.3.36.3.3.2.8.1.1.5")); // "german curve"
    //req_in.set_domain_parameters(dom_pars);
-   std::auto_ptr<Public_Key> p_pk = req_in.subject_public_key();
+   std::unique_ptr<Public_Key> p_pk = req_in.subject_public_key();
    ECDSA_PublicKey* p_ecdsa_pk = dynamic_cast<ECDSA_PublicKey*>(p_pk.get());
    //p_ecdsa_pk->set_domain_parameters(dom_pars);
    CHECK(p_ecdsa_pk->domain().get_order() == dom_pars.get_order());
@@ -348,8 +348,7 @@ void test_eac_time(RandomNumberGenerator&)
    {
    std::cout << "." << std::flush;
 
-   const u64bit current_time = system_time();
-   EAC_Time time(current_time);
+   EAC_Time time(std::chrono::system_clock::now());
    //     std::cout << "time as std::string = " << time.as_string() << std::endl;
    EAC_Time sooner("", ASN1_Tag(99));
    //X509_Time sooner("", ASN1_Tag(99));
@@ -388,11 +387,11 @@ void test_ver_cvca(RandomNumberGenerator&)
 
    EAC1_1_CVC req_in(TEST_DATA_DIR "/cvca01.cv.crt");
 
-   //auto_ptr<ECDSA_PublicKey> ecdsa_pk = dynamic_cast<auto_ptr<ECDSA_PublicKey> >(p_pk);
+   //unique_ptr<ECDSA_PublicKey> ecdsa_pk = dynamic_cast<auto_ptr<ECDSA_PublicKey> >(p_pk);
    //ECDSA_PublicKey* p_ecdsa_pk = dynamic_cast<ECDSA_PublicKey*>(p_pk.get());
    bool exc = false;
 
-   std::auto_ptr<Public_Key> p_pk2 = req_in.subject_public_key();
+   std::unique_ptr<Public_Key> p_pk2 = req_in.subject_public_key();
    ECDSA_PublicKey* p_ecdsa_pk2 = dynamic_cast<ECDSA_PublicKey*>(p_pk2.get());
    bool ver_ec = req_in.check_signature(*p_pk2);
    CHECK_MESSAGE(ver_ec, "could not positively verify correct selfsigned cvca certificate");
@@ -510,7 +509,7 @@ void test_cvc_chain(RandomNumberGenerator& rng)
    CHECK(link12.check_signature(cvca_privk));
    EAC1_1_CVC link12_reloaded(TEST_DATA_DIR "/cvc_chain_link12.cer");
    EAC1_1_CVC cvca1_reloaded(TEST_DATA_DIR "/cvc_chain_cvca.cer");
-   std::auto_ptr<Public_Key> cvca1_rel_pk = cvca1_reloaded.subject_public_key();
+   std::unique_ptr<Public_Key> cvca1_rel_pk = cvca1_reloaded.subject_public_key();
    CHECK(link12_reloaded.check_signature(*cvca1_rel_pk));
 
    // create first round dvca-req
@@ -540,7 +539,7 @@ void test_cvc_chain(RandomNumberGenerator& rng)
 
    // verify the ado and sign the request too
 
-   std::auto_ptr<Public_Key> ap_pk = dvca_cert1.subject_public_key();
+   std::unique_ptr<Public_Key> ap_pk = dvca_cert1.subject_public_key();
    ECDSA_PublicKey* cert_pk = dynamic_cast<ECDSA_PublicKey*>(ap_pk.get());
 
    //cert_pk->set_domain_parameters(dom_pars);
diff --git a/checks/ec_tests.cpp b/checks/ec_tests.cpp
index 979414ed4..777d60f45 100644
--- a/checks/ec_tests.cpp
+++ b/checks/ec_tests.cpp
@@ -616,11 +616,11 @@ void test_enc_dec_uncompressed_521_prime_too_large()
    BigInt bi_b_secp = BigInt::decode ( &sv_b_secp[0], sv_b_secp.size() );
 
    CurveGFp secp521r1 (bi_p_secp, bi_a_secp, bi_b_secp);
-   std::auto_ptr<PointGFp> p_G;
+   std::unique_ptr<PointGFp> p_G;
    bool exc = false;
    try
       {
-      p_G = std::auto_ptr<PointGFp>(new PointGFp(OS2ECP ( sv_G_secp_uncomp, secp521r1)));
+      p_G = std::unique_ptr<PointGFp>(new PointGFp(OS2ECP ( sv_G_secp_uncomp, secp521r1)));
       if(!p_G->on_the_curve())
          throw Internal_Error("Point not on the curve");
       }
diff --git a/checks/ecdsa.cpp b/checks/ecdsa.cpp
index 91ea8cfbb..afe4cfd89 100644
--- a/checks/ecdsa.cpp
+++ b/checks/ecdsa.cpp
@@ -124,7 +124,7 @@ void test_decode_ecdsa_X509()
    CHECK_MESSAGE(to_hex(cert.authority_key_id()) == "0096452DE588F966C4CCDF161DD1F3F5341B71E7", "error reading authority key id from x509 ecdsa certificate");
    CHECK_MESSAGE(to_hex(cert.subject_key_id()) == "0096452DE588F966C4CCDF161DD1F3F5341B71E7", "error reading Subject key id from x509 ecdsa certificate");
 
-   std::auto_ptr<X509_PublicKey> pubkey(cert.subject_public_key());
+   std::unique_ptr<X509_PublicKey> pubkey(cert.subject_public_key());
    bool ver_ec = cert.check_signature(*pubkey);
    CHECK_MESSAGE(ver_ec, "could not positively verify correct selfsigned x509-ecdsa certificate");
    }
@@ -136,7 +136,7 @@ void test_decode_ver_link_SHA256()
    X509_Certificate root_cert(TEST_DATA_DIR "/root2_SHA256.cer");
    X509_Certificate link_cert(TEST_DATA_DIR "/link_SHA256.cer");
 
-   std::auto_ptr<X509_PublicKey> pubkey(root_cert.subject_public_key());
+   std::unique_ptr<X509_PublicKey> pubkey(root_cert.subject_public_key());
    bool ver_ec = link_cert.check_signature(*pubkey);
    CHECK_MESSAGE(ver_ec, "could not positively verify correct SHA256 link x509-ecdsa certificate");
 
@@ -148,7 +148,7 @@ void test_decode_ver_link_SHA1()
    X509_Certificate root_cert(TEST_DATA_DIR "/root_SHA1.163.crt");
    X509_Certificate link_cert(TEST_DATA_DIR "/link_SHA1.166.crt");
 
-   std::auto_ptr<X509_PublicKey> pubkey(root_cert.subject_public_key());
+   std::unique_ptr<X509_PublicKey> pubkey(root_cert.subject_public_key());
    bool ver_ec = link_cert.check_signature(*pubkey);
    CHECK_MESSAGE(ver_ec, "could not positively verify correct SHA1 link x509-ecdsa certificate");
    }
@@ -271,11 +271,11 @@ void test_create_and_verify(RandomNumberGenerator& rng)
    std::ofstream priv_key(TEST_DATA_DIR "/dompar_private.pkcs8.pem");
    priv_key << PKCS8::PEM_encode(key);
 
-   std::auto_ptr<PKCS8_PrivateKey> loaded_key(PKCS8::load_key(TEST_DATA_DIR "/wo_dompar_private.pkcs8.pem", rng));
+   std::unique_ptr<PKCS8_PrivateKey> loaded_key(PKCS8::load_key(TEST_DATA_DIR "/wo_dompar_private.pkcs8.pem", rng));
    ECDSA_PrivateKey* loaded_ec_key = dynamic_cast<ECDSA_PrivateKey*>(loaded_key.get());
    CHECK_MESSAGE(loaded_ec_key, "the loaded key could not be converted into an ECDSA_PrivateKey");
 
-   std::auto_ptr<PKCS8_PrivateKey> loaded_key_1(PKCS8::load_key(TEST_DATA_DIR "/rsa_private.pkcs8.pem", rng));
+   std::unique_ptr<PKCS8_PrivateKey> loaded_key_1(PKCS8::load_key(TEST_DATA_DIR "/rsa_private.pkcs8.pem", rng));
    ECDSA_PrivateKey* loaded_rsa_key = dynamic_cast<ECDSA_PrivateKey*>(loaded_key_1.get());
    CHECK_MESSAGE(!loaded_rsa_key, "the loaded key is ECDSA_PrivateKey -> shouldn't be, is a RSA-Key");
 
@@ -309,7 +309,7 @@ void test_create_and_verify(RandomNumberGenerator& rng)
    std::string key_odd_oid_str = PKCS8::PEM_encode(key_odd_oid);
 
    DataSource_Memory key_data_src(key_odd_oid_str);
-   std::auto_ptr<PKCS8_PrivateKey> loaded_key2(PKCS8::load_key(key_data_src, rng));
+   std::unique_ptr<PKCS8_PrivateKey> loaded_key2(PKCS8::load_key(key_data_src, rng));
 
    if(!dynamic_cast<ECDSA_PrivateKey*>(loaded_key.get()))
       {
@@ -385,7 +385,7 @@ void test_read_pkcs8(RandomNumberGenerator& rng)
 
    try
       {
-      std::auto_ptr<PKCS8_PrivateKey> loaded_key(PKCS8::load_key(TEST_DATA_DIR "/wo_dompar_private.pkcs8.pem", rng));
+      std::unique_ptr<PKCS8_PrivateKey> loaded_key(PKCS8::load_key(TEST_DATA_DIR "/wo_dompar_private.pkcs8.pem", rng));
       ECDSA_PrivateKey* ecdsa = dynamic_cast<ECDSA_PrivateKey*>(loaded_key.get());
       CHECK_MESSAGE(ecdsa, "the loaded key could not be converted into an ECDSA_PrivateKey");
 
@@ -405,7 +405,7 @@ void test_read_pkcs8(RandomNumberGenerator& rng)
 
    try
       {
-      std::auto_ptr<PKCS8_PrivateKey> loaded_key_nodp(PKCS8::load_key(TEST_DATA_DIR "/nodompar_private.pkcs8.pem", rng));
+      std::unique_ptr<PKCS8_PrivateKey> loaded_key_nodp(PKCS8::load_key(TEST_DATA_DIR "/nodompar_private.pkcs8.pem", rng));
       // anew in each test with unregistered domain-parameters
       ECDSA_PrivateKey* ecdsa_nodp = dynamic_cast<ECDSA_PrivateKey*>(loaded_key_nodp.get());
       CHECK_MESSAGE(ecdsa_nodp, "the loaded key could not be converted into an ECDSA_PrivateKey");
@@ -420,7 +420,7 @@ void test_read_pkcs8(RandomNumberGenerator& rng)
 
       try
          {
-         std::auto_ptr<PKCS8_PrivateKey> loaded_key_withdp(
+         std::unique_ptr<PKCS8_PrivateKey> loaded_key_withdp(
             PKCS8::load_key(TEST_DATA_DIR "/withdompar_private.pkcs8.pem", rng));
 
          std::cout << "Unexpected success: loaded key with unknown OID\n";
diff --git a/checks/pk.cpp b/checks/pk.cpp
index f38cf97a6..18cbb9f70 100644
--- a/checks/pk.cpp
+++ b/checks/pk.cpp
@@ -247,7 +247,7 @@ u32bit validate_rsa_enc_pkcs8(const std::string& algo,
    DataSource_Memory keysource(reinterpret_cast<const byte*>(str[0].c_str()),
                                str[0].length());
 
-   std::auto_ptr<Private_Key> privkey(PKCS8::load_key(keysource, rng, pass));
+   std::unique_ptr<Private_Key> privkey(PKCS8::load_key(keysource, rng, pass));
 
    RSA_PrivateKey* rsapriv = dynamic_cast<RSA_PrivateKey*>(privkey.get());
    if(!rsapriv)
@@ -388,7 +388,7 @@ u32bit validate_rsa_ver_x509(const std::string& algo,
    DataSource_Memory keysource(reinterpret_cast<const byte*>(str[0].c_str()),
                                str[0].length());
 
-   std::auto_ptr<Public_Key> key(X509::load_key(keysource));
+   std::unique_ptr<Public_Key> key(X509::load_key(keysource));
 
    RSA_PublicKey* rsakey = dynamic_cast<RSA_PublicKey*>(key.get());
 
@@ -476,7 +476,7 @@ u32bit validate_dsa_sig(const std::string& algo,
    DataSource_Memory keysource(reinterpret_cast<const byte*>(str[0].c_str()),
                                str[0].length());
 
-   std::auto_ptr<Private_Key> privkey(PKCS8::load_key(keysource, rng, pass));
+   std::unique_ptr<Private_Key> privkey(PKCS8::load_key(keysource, rng, pass));
 
    DSA_PrivateKey* dsapriv = dynamic_cast<DSA_PrivateKey*>(privkey.get());
    if(!dsapriv)
@@ -560,7 +560,7 @@ u32bit validate_dsa_ver(const std::string& algo,
 
 
 #if defined(BOTAN_HAS_DSA)
-   std::auto_ptr<Public_Key> key(X509::load_key(keysource));
+   std::unique_ptr<Public_Key> key(X509::load_key(keysource));
 
    DSA_PublicKey* dsakey = dynamic_cast<DSA_PublicKey*>(key.get());
 
diff --git a/checks/pk_bench.cpp b/checks/pk_bench.cpp
index 2eb87dfeb..48c7dc994 100644
--- a/checks/pk_bench.cpp
+++ b/checks/pk_bench.cpp
@@ -237,7 +237,7 @@ void benchmark_rsa(RandomNumberGenerator& rng,
                               sig_timer, rng, 10000, seconds);
             }
 
-         const std::string rsa_keylen = "RSA-" + to_string(keylen);
+         const std::string rsa_keylen = "RSA-" + std::to_string(keylen);
 
          report.report(rsa_keylen, keygen_timer);
          report.report(rsa_keylen, verify_timer);
@@ -289,7 +289,7 @@ void benchmark_rw(RandomNumberGenerator& rng,
                            rng, 10000, seconds);
          }
 
-      const std::string nm = "RW-" + to_string(keylen);
+      const std::string nm = "RW-" + std::to_string(keylen);
       report.report(nm, keygen_timer);
       report.report(nm, verify_timer);
       report.report(nm, sig_timer);
@@ -316,7 +316,7 @@ void benchmark_ecdsa(RandomNumberGenerator& rng,
       if(hashbits == 521)
          hashbits = 512;
 
-      const std::string padding = "EMSA1(SHA-" + to_string(hashbits) + ")";
+      const std::string padding = "EMSA1(SHA-" + std::to_string(hashbits) + ")";
 
       Timer keygen_timer("keygen");
       Timer verify_timer(padding + " verify");
@@ -336,7 +336,7 @@ void benchmark_ecdsa(RandomNumberGenerator& rng,
                            sig_timer, rng, 1000, seconds);
          }
 
-      const std::string nm = "ECDSA-" + to_string(pbits);
+      const std::string nm = "ECDSA-" + std::to_string(pbits);
 
       report.report(nm, keygen_timer);
       report.report(nm, verify_timer);
@@ -365,7 +365,7 @@ void benchmark_gost_3410(RandomNumberGenerator& rng,
       if(hashbits == 521)
          hashbits = 512;
 
-      const std::string padding = "EMSA1(SHA-" + to_string(hashbits) + ")";
+      const std::string padding = "EMSA1(SHA-" + std::to_string(hashbits) + ")";
 
       Timer keygen_timer("keygen");
       Timer verify_timer(padding + " verify");
@@ -385,7 +385,7 @@ void benchmark_gost_3410(RandomNumberGenerator& rng,
                            sig_timer, rng, 1000, seconds);
          }
 
-      const std::string nm = "GOST-34.10-" + to_string(pbits);
+      const std::string nm = "GOST-34.10-" + std::to_string(pbits);
 
       report.report(nm, keygen_timer);
       report.report(nm, verify_timer);
@@ -443,7 +443,7 @@ void benchmark_ecdh(RandomNumberGenerator& rng,
             }
          }
 
-      const std::string nm = "ECDH-" + to_string(pbits);
+      const std::string nm = "ECDH-" + std::to_string(pbits);
       report.report(nm, keygen_timer);
       report.report(nm, kex_timer);
       }
@@ -469,7 +469,7 @@ void benchmark_dsa_nr(RandomNumberGenerator& rng,
       u32bit pbits = to_u32bit(split_on(domains[j], '/')[2]);
       u32bit qbits = (pbits <= 1024) ? 160 : 256;
 
-      const std::string padding = "EMSA1(SHA-" + to_string(qbits) + ")";
+      const std::string padding = "EMSA1(SHA-" + std::to_string(qbits) + ")";
 
       Timer keygen_timer("keygen");
       Timer verify_timer(padding + " verify");
@@ -492,7 +492,7 @@ void benchmark_dsa_nr(RandomNumberGenerator& rng,
                            sig_timer, rng, 1000, seconds);
          }
 
-      const std::string nm = algo_name + "-" + to_string(pbits);
+      const std::string nm = algo_name + "-" + std::to_string(pbits);
       report.report(nm, keygen_timer);
       report.report(nm, verify_timer);
       report.report(nm, sig_timer);
@@ -661,7 +661,7 @@ void benchmark_elg(RandomNumberGenerator& rng,
                            rng, 1000, seconds);
          }
 
-      const std::string nm = algo_name + "-" + to_string(pbits);
+      const std::string nm = algo_name + "-" + std::to_string(pbits);
       report.report(nm, keygen_timer);
       report.report(nm, enc_timer);
       report.report(nm, dec_timer);
diff --git a/checks/timer.cpp b/checks/timer.cpp
index 3736a4779..9f3d34607 100644
--- a/checks/timer.cpp
+++ b/checks/timer.cpp
@@ -5,7 +5,7 @@
 */
 
 #include "timer.h"
-#include <botan/time.h>
+#include <chrono>
 #include <iomanip>
 
 Timer::Timer(const std::string& n, u32bit e_mul) :
@@ -38,7 +38,8 @@ void Timer::stop()
 
 u64bit Timer::get_clock()
    {
-   return Botan::get_nanoseconds_clock();
+   auto now = std::chrono::high_resolution_clock::now().time_since_epoch();
+   return std::chrono::duration_cast<std::chrono::nanoseconds>(now).count();
    }
 
 std::ostream& operator<<(std::ostream& out, Timer& timer)
diff --git a/configure.py b/configure.py
index b99577135..0bd2a3b9a 100755
--- a/configure.py
+++ b/configure.py
@@ -202,10 +202,6 @@ def process_command_line(args):
                            default=False, action='store_true',
                            help='generate amalgamation files')
 
-    build_group.add_option('--with-tr1-implementation', metavar='WHICH',
-                           dest='with_tr1', default=None,
-                           help='enable TR1 (choices: none, system, boost)')
-
     build_group.add_option('--with-build-dir',
                            metavar='DIR', default='',
                            help='setup the build in DIR')
@@ -446,7 +442,6 @@ class ModuleInfo(object):
                        'requires', 'os', 'arch', 'cc', 'libs'],
                       { 'load_on': 'auto',
                         'define': None,
-                        'uses_tr1': 'false',
                         'need_isa': None,
                         'mp_bits': 0 })
 
@@ -494,8 +489,6 @@ class ModuleInfo(object):
 
         self.mp_bits = int(self.mp_bits)
 
-        self.uses_tr1 = (True if self.uses_tr1 == 'yes' else False)
-
     def sources(self):
         return self.source
 
@@ -532,12 +525,6 @@ class ModuleInfo(object):
     def compatible_compiler(self, cc):
         return self.cc == [] or cc in self.cc
 
-    def tr1_ok(self, with_tr1):
-        if self.uses_tr1:
-            return with_tr1 in ['boost', 'system']
-        else:
-            return True
-
     def dependencies(self):
         # utils is an implicit dep (contains types, etc)
         deps = self.requires + ['utils']
@@ -664,8 +651,7 @@ class CompilerInfo(object):
                         'maintainer_warning_flags': '',
                         'dll_import_flags': '',
                         'ar_command': None,
-                        'makefile_style': '',
-                        'has_tr1': False,
+                        'makefile_style': ''
                         })
 
         self.so_link_flags = force_to_dict(self.so_link_flags)
@@ -750,19 +736,8 @@ class CompilerInfo(object):
     """
     Return defines for build.h
     """
-    def defines(self, with_tr1):
-
-        def tr1_macro():
-            if with_tr1:
-                if with_tr1 == 'boost':
-                    return ['USE_BOOST_TR1']
-                elif with_tr1 == 'system':
-                    return ['USE_STD_TR1']
-            elif self.has_tr1:
-                return ['USE_STD_TR1']
-            return []
-
-        return ['BUILD_COMPILER_IS_' + self.macro_name] + tr1_macro()
+    def defines(self):
+        return ['BUILD_COMPILER_IS_' + self.macro_name]
 
 class OsInfo(object):
     def __init__(self, infofile):
@@ -993,8 +968,7 @@ def create_template_vars(build_config, options, modules, cc, arch, osinfo):
 
         'target_os_defines': make_cpp_macros(osinfo.defines()),
 
-        'target_compiler_defines': make_cpp_macros(
-            cc.defines(options.with_tr1)),
+        'target_compiler_defines': make_cpp_macros(cc.defines()),
 
         'target_cpu_defines': make_cpp_macros(arch.defines(options)),
 
@@ -1077,8 +1051,6 @@ def choose_modules_to_use(modules, archinfo, options):
             cannot_use_because(modname, 'incompatible compiler')
         elif not module.compatible_cpu(archinfo, options):
             cannot_use_because(modname, 'incompatible CPU')
-        elif not module.tr1_ok(options.with_tr1):
-            cannot_use_because(modname, 'missing TR1')
 
         else:
             if module.load_on == 'never':
@@ -1569,9 +1541,6 @@ def main(argv = None):
             logging.info('Setting -fpermissive to work around gcc bug')
             options.extra_flags = ' -fpermissive'
 
-    if options.with_tr1 == None:
-        options.with_tr1 = ('system' if ccinfo[options.compiler].has_tr1 else 'none')
-
     if options.gen_amalgamation:
         if options.asm_ok:
             logging.info('Disabling assembly code, cannot use in amalgamation')
diff --git a/doc/api.tex b/doc/api.tex
index c53a36529..ffcc82c53 100644
--- a/doc/api.tex
+++ b/doc/api.tex
@@ -1281,9 +1281,15 @@ decrypt, if necessary) a PKCS \#8 private key:
 
 \begin{verbatim}
 namespace PKCS8 {
-   Private_Key* load_key(DataSource& in,
-                         RandomNumberGenerator& rng,
-                         const User_Interface& ui);
+   Private_Key* load_key(
+      DataSource& in,
+      RandomNumberGenerator& rng,
+      std::function<std::pair<bool, std::string> ()> get_passphrase);
+
+   Private_Key* load_key(
+      const std::string& filename,
+      RandomNumberGenerator& rng,
+      std::function<std::pair<bool, std::string> ()> get_passphrase);
 
    Private_Key* load_key(DataSource& in,
                          RandomNumberGenerator& rng,
@@ -1291,28 +1297,27 @@ namespace PKCS8 {
 
    Private_Key* load_key(const std::string& filename,
                          RandomNumberGenerator& rng,
-                         const User_Interface& ui);
-
-   Private_Key* load_key(const std::string& filename,
-                         RandomNumberGenerator& rng,
                          const std::string& passphrase = "");
 }
 \end{verbatim}
 
 The versions that take \type{std::string} \arg{passphrase}s are
 primarily for compatibility, but they are useful in limited
-circumstances. The \type{User\_Interface} versions are how
-\function{load\_key} is implemented, and provides for much more
-flexibility. If the passphrase passed in is not correct, then an
-exception is thrown and that is that. However, if you pass in an UI
-object, then the UI object can keep asking the user for the passphrase
-until they get it right (or until they cancel the action, though the
-UI interface). A \type{User\_Interface} has very little to do with
-talking to users; it's just a way to glue together Botan and whatever
-user interface you happen to be using. You can think of it as a user
-interface interface. The default \type{User\_Interface} is rather
-dumb, and acts rather like the versions taking the \type{std::string};
-it tries the passphrase passed in first, and then it cancels.
+circumstances. The versions using \type{std::function} callbacks are
+how \function{load\_key} is implemented, and provides for much more
+flexibility. If you use the versions that take just a single
+passphrase, then if the passphrase passed in is not correct, then an
+exception is thrown and that is that. However, if you pass in a
+callback, then you can keep querying to the user until they get it
+right (or they cancel the action). The first return value of the
+callback is if the action should continue - if false,
+\function{load_key} will bail out. Otherwise, it will use the second
+return value as the supposed passphrase that was used to decrypt the
+key.
+
+If you know (or want to assume) the key is not encrypted, just ignore
+the passphrase/callback entirely, letting the third parameter default
+to an empty string. The call will fail if the key was encrypted.
 
 All versions need access to a \type{RandomNumberGenerator} in order to
 perform probabilistic tests on the loaded key material.
diff --git a/doc/examples/GNUmakefile b/doc/examples/GNUmakefile
index 44fcfeea5..a96e8d65d 100644
--- a/doc/examples/GNUmakefile
+++ b/doc/examples/GNUmakefile
@@ -1,8 +1,8 @@
 
 BOTAN_CONFIG = botan-config
 
-CXX       = g++
-CFLAGS    = -O2 -ansi -W -Wall -I../../build/include
+CXX       = g++-4.5-20091112
+CFLAGS    = -O2 -ansi -std=c++0x -W -Wall -I../../build/include
 LIBS      = -L../.. -lbotan
 
 SRCS=$(wildcard *.cpp)
diff --git a/doc/examples/asn1.cpp b/doc/examples/asn1.cpp
index b0a6aa104..11e283a64 100644
--- a/doc/examples/asn1.cpp
+++ b/doc/examples/asn1.cpp
@@ -121,7 +121,7 @@ void decode(BER_Decoder& decoder, u32bit level)
             if((class_tag & APPLICATION) || (class_tag & CONTEXT_SPECIFIC) ||
                (class_tag & PRIVATE))
                {
-               name = "cons [" + to_string(type_tag) + "]";
+               name = "cons [" + std::to_string(type_tag) + "]";
 
                if(class_tag & APPLICATION)
                   name += " appl";
@@ -148,7 +148,7 @@ void decode(BER_Decoder& decoder, u32bit level)
 
          Pipe pipe(((not_text) ? new Hex_Encoder : 0));
          pipe.process_msg(bits);
-         emit("[" + to_string(type_tag) + "]", level, length,
+         emit("[" + std::to_string(type_tag) + "]", level, length,
               pipe.read_all_as_string());
          }
       else if(type_tag == OBJECT_ID)
diff --git a/doc/examples/bench.cpp b/doc/examples/bench.cpp
index 20e6ec40b..884bc2ecc 100644
--- a/doc/examples/bench.cpp
+++ b/doc/examples/bench.cpp
@@ -67,41 +67,29 @@ const std::string algos[] = {
    "",
 };
 
-void benchmark_algo(const std::string& algo,
-                    RandomNumberGenerator& rng)
+int main()
    {
-   u32bit milliseconds = 3000;
-   Algorithm_Factory& af = global_state().algorithm_factory();
+   LibraryInitializer init;
 
    std::map<std::string, double> speeds =
       algorithm_benchmark(algo, af, rng, milliseconds, 16*1024);
 
-   std::cout << algo << ":";
+   Algorithm_Factory& af = global_state().algorithm_factory();
 
-   for(std::map<std::string, double>::const_iterator i = speeds.begin();
-       i != speeds.end(); ++i)
+   for(u32bit i = 0; algos[i] != ""; ++i)
       {
-      std::cout << " " << i->second << " [" << i->first << "]";
-      }
-   std::cout << "\n";
-   }
+      std::string algo = algos[i];
 
-}
+      std::map<std::string, double> speeds =
+         algorithm_benchmark(algos[i], milliseconds, rng, af);
 
-int main(int argc, char* argv[])
-   {
-   LibraryInitializer init;
-
-   AutoSeeded_RNG rng;
+      std::cout << algo << ":";
 
-   if(argc == 1) // no args, benchmark everything
-      {
-      for(u32bit i = 0; algos[i] != ""; ++i)
-         benchmark_algo(algos[i], rng);
-      }
-   else
-      {
-      for(int i = 1; argv[i]; ++i)
-         benchmark_algo(argv[i], rng);
+      for(std::map<std::string, double>::const_iterator i = speeds.begin();
+          i != speeds.end(); ++i)
+         {
+         std::cout << " " << i->second << " [" << i->first << "]";
+         }
+      std::cout << "\n";
       }
    }
diff --git a/doc/examples/ca.cpp b/doc/examples/ca.cpp
index 8dd3e981f..25a3b5a03 100644
--- a/doc/examples/ca.cpp
+++ b/doc/examples/ca.cpp
@@ -17,11 +17,11 @@
 
 #include <botan/botan.h>
 #include <botan/x509_ca.h>
-#include <botan/time.h>
 using namespace Botan;
 
 #include <iostream>
 #include <memory>
+#include <chrono>
 
 int main(int argc, char* argv[])
    {
@@ -58,8 +58,13 @@ int main(int argc, char* argv[])
       // (this example should be extended to show how)
 
       // now sign the request
-      X509_Time start_time(system_time());
-      X509_Time end_time(system_time() + 365 * 60 * 60 * 24);
+      auto now = std::chrono::system_clock::now();
+
+      X509_Time start_time(now);
+
+      typedef std::chrono::duration<int, std::ratio<31556926>> years;
+
+      X509_Time end_time(now + years(1));
 
       X509_Certificate new_cert = ca.sign_request(req, rng,
                                                   start_time, end_time);
diff --git a/doc/examples/gen_certs.cpp b/doc/examples/gen_certs.cpp
index f8c9fe124..73d667edb 100644
--- a/doc/examples/gen_certs.cpp
+++ b/doc/examples/gen_certs.cpp
@@ -11,9 +11,9 @@
 
 #include <botan/botan.h>
 #include <botan/rsa.h>
-#include <botan/time.h>
 #include <botan/x509self.h>
 #include <botan/x509_ca.h>
+#include <chrono>
 
 using namespace Botan;
 
@@ -79,16 +79,14 @@ void save_pair(const std::string& name,
    key_out.close();
    }
 
-}
+typedef std::chrono::duration<int, std::ratio<31556926>> years;
 
 int main()
    {
-   const u32bit seconds_in_a_year = 31556926;
-
-   const u32bit current_time = system_time();
+   auto current_time = std::chrono::system_clock::now();
 
    X509_Time now = X509_Time(current_time);
-   X509_Time later = X509_Time(current_time + 4*seconds_in_a_year);
+   X509_Time later = X509_Time(current_time + years(4));
 
    LibraryInitializer init;
 
diff --git a/doc/examples/rsa_manykey.cpp b/doc/examples/rsa_manykey.cpp
index e6a511753..c282e7882 100644
--- a/doc/examples/rsa_manykey.cpp
+++ b/doc/examples/rsa_manykey.cpp
@@ -31,7 +31,7 @@ int main()
 
       RSA_PrivateKey key(rng, j);
 
-      std::ofstream priv(("rsa/" + to_string(j) + ".pem").c_str());
+      std::ofstream priv(("rsa/" + std::to_string(j) + ".pem").c_str());
       priv << PKCS8::PEM_encode(key);
       priv.close();
 
diff --git a/src/algo_factory/algo_cache.h b/src/algo_factory/algo_cache.h
index 0d891ad3f..279ba9389 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/internal/mutex.h>
+#include <botan/types.h>
 #include <botan/internal/stl_util.h>
+#include <mutex>
 #include <string>
 #include <vector>
 #include <map>
@@ -67,21 +68,12 @@ class Algorithm_Cache
       */
       void clear_cache();
 
-      /**
-      * Constructor
-      * @param m a mutex to serialize internal access
-      */
-      Algorithm_Cache(Mutex* m) : mutex(m) {}
-      ~Algorithm_Cache() { clear_cache(); delete mutex; }
+      ~Algorithm_Cache() { clear_cache(); }
    private:
-      typedef typename std::map<std::string, std::map<std::string, T*> >::iterator
-         algorithms_iterator;
-
-      typedef typename std::map<std::string, T*>::iterator provider_iterator;
+      typename std::map<std::string, std::map<std::string, T*> >::const_iterator
+         find_algorithm(const std::string& algo_spec);
 
-      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;
@@ -92,16 +84,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);
@@ -117,16 +108,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;
@@ -138,7 +129,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 size_t prov_weight = static_provider_weight(prov_name);
@@ -169,7 +160,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;
@@ -187,15 +178,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())
          {
@@ -214,7 +204,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;
    }
@@ -225,11 +215,11 @@ void Algorithm_Cache<T>::set_preferred_provider(const std::string& algo_spec,
 template<typename T>
 void Algorithm_Cache<T>::clear_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())
          {
diff --git a/src/algo_factory/algo_factory.cpp b/src/algo_factory/algo_factory.cpp
index 3d640ab8a..9e4f78569 100644
--- a/src/algo_factory/algo_factory.cpp
+++ b/src/algo_factory/algo_factory.cpp
@@ -94,13 +94,13 @@ const T* factory_prototype(const std::string& algo_spec,
 /*
 * Setup caches
 */
-Algorithm_Factory::Algorithm_Factory(Mutex_Factory& mf)
+Algorithm_Factory::Algorithm_Factory()
    {
-   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());
-   pbkdf_cache = new Algorithm_Cache<PBKDF>(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>();
+   pbkdf_cache = new Algorithm_Cache<PBKDF>();
    }
 
 /*
@@ -114,7 +114,8 @@ Algorithm_Factory::~Algorithm_Factory()
    delete mac_cache;
    delete pbkdf_cache;
 
-   std::for_each(engines.begin(), engines.end(), del_fun<Engine>());
+   for(auto i = engines.begin(); i != engines.end(); ++i)
+      delete *i;
    }
 
 void Algorithm_Factory::clear_caches()
diff --git a/src/algo_factory/algo_factory.h b/src/algo_factory/algo_factory.h
index b9f15757d..1bec2adf7 100644
--- a/src/algo_factory/algo_factory.h
+++ b/src/algo_factory/algo_factory.h
@@ -26,7 +26,6 @@ class PBKDF;
 template<typename T> class Algorithm_Cache;
 
 class Engine;
-class Mutex_Factory;
 
 /**
 * Algorithm Factory
@@ -38,7 +37,7 @@ class BOTAN_DLL Algorithm_Factory
       * Constructor
       * @param mf a mutex factory
       */
-      Algorithm_Factory(Mutex_Factory& mf);
+      Algorithm_Factory();
 
       /**
       * Destructor
diff --git a/src/algo_factory/info.txt b/src/algo_factory/info.txt
index eae4b3934..236fdda0e 100644
--- a/src/algo_factory/info.txt
+++ b/src/algo_factory/info.txt
@@ -20,6 +20,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 fa4e5e715..c9983ed23 100644
--- a/src/alloc/alloc_mmap/mmap_mem.h
+++ b/src/alloc/alloc_mmap/mmap_mem.h
@@ -21,10 +21,6 @@ namespace Botan {
 class MemoryMapping_Allocator : public Pooling_Allocator
    {
    public:
-      /**
-      * @param mutex used for internal locking
-      */
-      MemoryMapping_Allocator(Mutex* mutex) : Pooling_Allocator(mutex) {}
       std::string type() const { return "mmap"; }
    private:
       void* alloc_block(size_t);
diff --git a/src/alloc/mem_pool/info.txt b/src/alloc/mem_pool/info.txt
index 5097c325f..f87ea4c4c 100644
--- a/src/alloc/mem_pool/info.txt
+++ b/src/alloc/mem_pool/info.txt
@@ -6,7 +6,3 @@ mem_pool.cpp
 <header:internal>
 mem_pool.h
 </header:internal>
-
-<requires>
-mutex
-</requires>
diff --git a/src/alloc/mem_pool/mem_pool.cpp b/src/alloc/mem_pool/mem_pool.cpp
index f32eb9604..92515e5b2 100644
--- a/src/alloc/mem_pool/mem_pool.cpp
+++ b/src/alloc/mem_pool/mem_pool.cpp
@@ -96,7 +96,7 @@ void Pooling_Allocator::Memory_Block::free(void* ptr, size_t blocks)
 /*
 * Pooling_Allocator Constructor
 */
-Pooling_Allocator::Pooling_Allocator(Mutex* m) : mutex(m)
+Pooling_Allocator::Pooling_Allocator()
    {
    last_used = blocks.begin();
    }
@@ -106,7 +106,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");
    }
@@ -116,7 +115,7 @@ Pooling_Allocator::~Pooling_Allocator()
 */
 void Pooling_Allocator::destroy()
    {
-   Mutex_Holder lock(mutex);
+   std::lock_guard<std::mutex> lock(mutex);
 
    blocks.clear();
 
@@ -133,7 +132,7 @@ void* Pooling_Allocator::allocate(size_t n)
    const size_t BITMAP_SIZE = Memory_Block::bitmap_size();
    const size_t BLOCK_SIZE = Memory_Block::block_size();
 
-   Mutex_Holder lock(mutex);
+   std::lock_guard<std::mutex> lock(mutex);
 
    if(n <= BITMAP_SIZE * BLOCK_SIZE)
       {
@@ -170,7 +169,7 @@ void Pooling_Allocator::deallocate(void* ptr, size_t 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);
@@ -178,8 +177,8 @@ void Pooling_Allocator::deallocate(void* ptr, size_t n)
       {
       const size_t 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");
@@ -196,7 +195,7 @@ byte* Pooling_Allocator::allocate_blocks(size_t 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 28d4dd903..f2225e573 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/internal/mutex.h>
+#include <mutex>
 #include <utility>
 #include <vector>
 
@@ -27,10 +27,7 @@ class Pooling_Allocator : public Allocator
 
       void destroy();
 
-      /**
-      * @param mutex used for internal locking
-      */
-      Pooling_Allocator(Mutex* mutex);
+      Pooling_Allocator();
       ~Pooling_Allocator();
    private:
       void get_more_core(size_t);
@@ -69,7 +66,7 @@ class Pooling_Allocator : public Allocator
       std::vector<Memory_Block> blocks;
       std::vector<Memory_Block>::iterator last_used;
       std::vector<std::pair<void*, size_t> > allocated;
-      Mutex* mutex;
+      std::mutex mutex;
    };
 
 }
diff --git a/src/alloc/system_alloc/defalloc.h b/src/alloc/system_alloc/defalloc.h
index 6fba0e511..c4b90d081 100644
--- a/src/alloc/system_alloc/defalloc.h
+++ b/src/alloc/system_alloc/defalloc.h
@@ -30,11 +30,6 @@ class Malloc_Allocator : public Allocator
 class Locking_Allocator : public Pooling_Allocator
    {
    public:
-      /**
-      * @param mutex used for internal locking
-      */
-      Locking_Allocator(Mutex* mutex) : Pooling_Allocator(mutex) {}
-
       std::string type() const { return "locking"; }
    private:
       void* alloc_block(size_t);
diff --git a/src/asn1/asn1_alt.cpp b/src/asn1/asn1_alt.cpp
index 1fc1f66e2..3689a4bba 100644
--- a/src/asn1/asn1_alt.cpp
+++ b/src/asn1/asn1_alt.cpp
@@ -58,9 +58,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;
 
@@ -101,13 +100,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;
    }
@@ -129,19 +126,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);
@@ -163,8 +159,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_int.cpp b/src/asn1/asn1_int.cpp
index 75cb1f90c..bb4a3ecf7 100644
--- a/src/asn1/asn1_int.cpp
+++ b/src/asn1/asn1_int.cpp
@@ -20,11 +20,11 @@ BER_Decoding_Error::BER_Decoding_Error(const std::string& str) :
    Decoding_Error("BER: " + str) {}
 
 BER_Bad_Tag::BER_Bad_Tag(const std::string& str, ASN1_Tag tag) :
-      BER_Decoding_Error(str + ": " + to_string(tag)) {}
+      BER_Decoding_Error(str + ": " + std::to_string(tag)) {}
 
 BER_Bad_Tag::BER_Bad_Tag(const std::string& str,
                          ASN1_Tag tag1, ASN1_Tag tag2) :
-   BER_Decoding_Error(str + ": " + to_string(tag1) + "/" + to_string(tag2)) {}
+   BER_Decoding_Error(str + ": " + std::to_string(tag1) + "/" + std::to_string(tag2)) {}
 
 namespace ASN1 {
 
diff --git a/src/asn1/asn1_obj.h b/src/asn1/asn1_obj.h
index 692a6fde6..3cd8422e6 100644
--- a/src/asn1/asn1_obj.h
+++ b/src/asn1/asn1_obj.h
@@ -15,6 +15,7 @@
 #include <botan/alg_id.h>
 #include <vector>
 #include <map>
+#include <chrono>
 
 namespace Botan {
 
@@ -53,7 +54,7 @@ class BOTAN_DLL X509_Time : public ASN1_Object
       void set_to(const std::string&);
       void set_to(const std::string&, ASN1_Tag);
 
-      X509_Time(u64bit);
+      X509_Time(const std::chrono::system_clock::time_point& time);
       X509_Time(const std::string& = "");
       X509_Time(const std::string&, ASN1_Tag);
    private:
diff --git a/src/asn1/asn1_oid.cpp b/src/asn1/asn1_oid.cpp
index ae3d48ce2..750eb90f7 100644
--- a/src/asn1/asn1_oid.cpp
+++ b/src/asn1/asn1_oid.cpp
@@ -52,7 +52,7 @@ std::string OID::as_string() const
    std::string oid_str;
    for(size_t i = 0; i != id.size(); ++i)
       {
-      oid_str += to_string(id[i]);
+      oid_str += std::to_string(id[i]);
       if(i != id.size() - 1)
          oid_str += '.';
       }
diff --git a/src/asn1/asn1_str.cpp b/src/asn1/asn1_str.cpp
index b28f36d90..44db189f9 100644
--- a/src/asn1/asn1_str.cpp
+++ b/src/asn1/asn1_str.cpp
@@ -77,7 +77,7 @@ ASN1_String::ASN1_String(const std::string& str, ASN1_Tag t) : tag(t)
       tag != UTF8_STRING &&
       tag != BMP_STRING)
       throw Invalid_Argument("ASN1_String: Unknown string type " +
-                             to_string(tag));
+                             std::to_string(tag));
    }
 
 /*
diff --git a/src/asn1/asn1_tm.cpp b/src/asn1/asn1_tm.cpp
index a059e0528..6e6868972 100644
--- a/src/asn1/asn1_tm.cpp
+++ b/src/asn1/asn1_tm.cpp
@@ -23,11 +23,11 @@ X509_Time::X509_Time(const std::string& time_str)
    }
 
 /*
-* Create an X509_Time
+* Create a X509_Time from a time point
 */
-X509_Time::X509_Time(u64bit timer)
+X509_Time::X509_Time(const std::chrono::system_clock::time_point& time)
    {
-   calendar_point cal = calendar_value(timer);
+   calendar_point cal = calendar_value(time);
 
    year   = cal.year;
    month  = cal.month;
@@ -98,7 +98,7 @@ void X509_Time::set_to(const std::string& time_str)
 void X509_Time::set_to(const std::string& t_spec, ASN1_Tag spec_tag)
    {
    if(spec_tag != GENERALIZED_TIME && spec_tag != UTC_TIME)
-      throw Invalid_Argument("X509_Time: Invalid tag " + to_string(spec_tag));
+      throw Invalid_Argument("X509_Time: Invalid tag " + std::to_string(spec_tag));
 
    if(spec_tag == GENERALIZED_TIME && t_spec.size() != 13 && t_spec.size() != 15)
       throw Invalid_Argument("Invalid GeneralizedTime: " + t_spec);
@@ -182,24 +182,30 @@ std::string X509_Time::as_string() const
    if(time_is_set() == false)
       throw Invalid_State("X509_Time::as_string: No time set");
 
-   std::string asn1rep;
-   if(tag == GENERALIZED_TIME)
-      asn1rep = to_string(year, 4);
-   else if(tag == UTC_TIME)
+   u32bit full_year = year;
+
+   if(tag == UTC_TIME)
       {
       if(year < 1950 || year >= 2050)
          throw Encoding_Error("X509_Time: The time " + readable_string() +
                               " cannot be encoded as a UTCTime");
-      u32bit asn1year = (year >= 2000) ? (year - 2000) : (year - 1900);
-      asn1rep = to_string(asn1year, 2);
+
+      full_year = (year >= 2000) ? (year - 2000) : (year - 1900);
       }
-   else
-      throw Invalid_Argument("X509_Time: Invalid tag " + to_string(tag));
 
-   asn1rep += to_string(month, 2) + to_string(day, 2);
-   asn1rep += to_string(hour, 2) + to_string(minute, 2) + to_string(second, 2);
-   asn1rep += "Z";
-   return asn1rep;
+   std::string repr = std::to_string(full_year*10000000000 +
+                                     month*100000000 +
+                                     day*1000000 +
+                                     hour*10000 +
+                                     minute*100 +
+                                     second) + "Z";
+
+   u32bit desired_size = (tag == UTC_TIME) ? 13 : 15;
+
+   while(repr.size() < desired_size)
+      repr = "0" + repr;
+
+   return repr;
    }
 
 /*
@@ -218,14 +224,12 @@ std::string X509_Time::readable_string() const
    if(time_is_set() == false)
       throw Invalid_State("X509_Time::readable_string: No time set");
 
-   std::string readable;
-   readable += to_string(year,   4) + "/";
-   readable += to_string(month    ) + "/";
-   readable += to_string(day      ) + " ";
-   readable += to_string(hour     ) + ":";
-   readable += to_string(minute, 2) + ":";
-   readable += to_string(second, 2) + " UTC";
-   return readable;
+   std::string output(24, 0);
+
+   std::sprintf(&output[0], "%04d/%02d/%02d %02d:%02d:%02d UTC",
+                year, month, day, hour, minute, second);
+
+   return output;
    }
 
 /*
diff --git a/src/asn1/ber_dec.h b/src/asn1/ber_dec.h
index 8dddcb7f4..79a15a298 100644
--- a/src/asn1/ber_dec.h
+++ b/src/asn1/ber_dec.h
@@ -74,14 +74,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[], size_t);
       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/asn1/der_enc.cpp b/src/asn1/der_enc.cpp
index c6ceaf86d..1d12ed5f6 100644
--- a/src/asn1/der_enc.cpp
+++ b/src/asn1/der_enc.cpp
@@ -24,7 +24,7 @@ SecureVector<byte> encode_tag(ASN1_Tag type_tag, ASN1_Tag class_tag)
    {
    if((class_tag | 0xE0) != 0xE0)
       throw Encoding_Error("DER_Encoder: Invalid class tag " +
-                           to_string(class_tag));
+                           std::to_string(class_tag));
 
    SecureVector<byte> encoded_tag;
    if(type_tag <= 30)
diff --git a/src/asn1/x509_dn.cpp b/src/asn1/x509_dn.cpp
index 0a4760391..0deed1a70 100644
--- a/src/asn1/x509_dn.cpp
+++ b/src/asn1/x509_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/benchmark/benchmark.cpp b/src/benchmark/benchmark.cpp
index dbccd45c1..cb5d8bb41 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
 */
@@ -11,13 +11,15 @@
 #include <botan/stream_cipher.h>
 #include <botan/hash.h>
 #include <botan/mac.h>
-#include <botan/time.h>
 #include <memory>
-
+#include <vector>
+#include <chrono>
 namespace Botan {
 
 namespace {
 
+typedef std::chrono::high_resolution_clock benchmark_clock;
+
 /**
 * Benchmark Buffered_Computation (hash or MAC)
 */
@@ -26,18 +28,23 @@ std::pair<u64bit, u64bit> bench_buf_comp(Buffered_Computation* buf_comp,
                                          const byte buf[], size_t buf_len)
    {
    u64bit reps = 0;
-   u64bit nanoseconds_used = 0;
 
-   while(nanoseconds_used < nanoseconds_max)
+   std::chrono::nanoseconds max_time(nanoseconds_max);
+   std::chrono::nanoseconds time_used(0);
+
+   while(time_used < max_time)
       {
-      const u64bit start = get_nanoseconds_clock();
+      auto start = benchmark_clock::now();
       buf_comp->update(buf, buf_len);
-      nanoseconds_used += get_nanoseconds_clock() - start;
+      time_used += benchmark_clock::now() - start;
 
       ++reps;
       }
 
-   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);
    }
 
 /**
@@ -51,21 +58,26 @@ bench_block_cipher(BlockCipher* block_cipher,
    const size_t in_blocks = buf_len / block_cipher->block_size();
 
    u64bit reps = 0;
-   u64bit nanoseconds_used = 0;
+
+   std::chrono::nanoseconds max_time(nanoseconds_max);
+   std::chrono::nanoseconds time_used(0);
 
    block_cipher->set_key(buf, block_cipher->maximum_keylength());
 
-   while(nanoseconds_used < nanoseconds_max)
+   while(time_used < max_time)
       {
-      const u64bit start = get_nanoseconds_clock();
+      auto start = benchmark_clock::now();
       block_cipher->encrypt_n(buf, buf, in_blocks);
-      nanoseconds_used += get_nanoseconds_clock() - start;
+      time_used += benchmark_clock::now() - start;
 
       ++reps;
       }
 
+   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);
    }
 
 /**
@@ -77,20 +89,25 @@ bench_stream_cipher(StreamCipher* stream_cipher,
                     byte buf[], size_t buf_len)
    {
    u64bit reps = 0;
-   u64bit nanoseconds_used = 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);
+
+   while(time_used < max_time)
       {
-      const u64bit start = get_nanoseconds_clock();
+      auto start = benchmark_clock::now();
       stream_cipher->cipher1(buf, buf_len);
-      nanoseconds_used += get_nanoseconds_clock() - start;
+      time_used += benchmark_clock::now() - start;
 
       ++reps;
       }
 
-   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);
    }
 
 /**
@@ -146,7 +163,7 @@ algorithm_benchmark(const std::string& name,
       if(const BlockCipher* proto =
             af.prototype_block_cipher(name, provider))
          {
-         std::auto_ptr<BlockCipher> block_cipher(proto->clone());
+         std::unique_ptr<BlockCipher> block_cipher(proto->clone());
          results = bench_block_cipher(block_cipher.get(),
                                       ns_per_provider,
                                       &buf[0], buf.size());
@@ -154,7 +171,7 @@ algorithm_benchmark(const std::string& name,
       else if(const StreamCipher* proto =
                  af.prototype_stream_cipher(name, provider))
          {
-         std::auto_ptr<StreamCipher> stream_cipher(proto->clone());
+         std::unique_ptr<StreamCipher> stream_cipher(proto->clone());
          results = bench_stream_cipher(stream_cipher.get(),
                                        ns_per_provider,
                                        &buf[0], buf.size());
@@ -162,14 +179,14 @@ algorithm_benchmark(const std::string& name,
       else if(const HashFunction* proto =
                  af.prototype_hash_function(name, provider))
          {
-         std::auto_ptr<HashFunction> hash(proto->clone());
+         std::unique_ptr<HashFunction> hash(proto->clone());
          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());
+         std::unique_ptr<MessageAuthenticationCode> mac(proto->clone());
          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 c47fdc166..f3e43bd06 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
 */
@@ -12,7 +12,6 @@
 #include <botan/rng.h>
 #include <map>
 #include <string>
-
 namespace Botan {
 
 /**
diff --git a/src/block/lion/lion.cpp b/src/block/lion/lion.cpp
index 46308e428..8c39eee65 100644
--- a/src/block/lion/lion.cpp
+++ b/src/block/lion/lion.cpp
@@ -83,7 +83,7 @@ std::string Lion::name() const
    {
    return "Lion(" + hash->name() + "," +
                     cipher->name() + "," +
-                    to_string(BLOCK_SIZE) + ")";
+                    std::to_string(BLOCK_SIZE) + ")";
    }
 
 /*
diff --git a/src/block/misty1/misty1.cpp b/src/block/misty1/misty1.cpp
index 36c25a814..77d1047b1 100644
--- a/src/block/misty1/misty1.cpp
+++ b/src/block/misty1/misty1.cpp
@@ -255,7 +255,7 @@ MISTY1::MISTY1(size_t rounds) : EK(100), DK(100)
    {
    if(rounds != 8)
       throw Invalid_Argument("MISTY1: Invalid number of rounds: "
-                             + to_string(rounds));
+                             + std::to_string(rounds));
    }
 
 }
diff --git a/src/block/rc5/rc5.cpp b/src/block/rc5/rc5.cpp
index cfcc4cb64..981f73564 100644
--- a/src/block/rc5/rc5.cpp
+++ b/src/block/rc5/rc5.cpp
@@ -116,7 +116,7 @@ void RC5::key_schedule(const byte key[], size_t length)
 */
 std::string RC5::name() const
    {
-   return "RC5(" + to_string(get_rounds()) + ")";
+   return "RC5(" + std::to_string(get_rounds()) + ")";
    }
 
 /*
@@ -126,7 +126,7 @@ RC5::RC5(size_t rounds)
    {
    if(rounds < 8 || rounds > 32 || (rounds % 4 != 0))
       throw Invalid_Argument("RC5: Invalid number of rounds " +
-                             to_string(rounds));
+                             std::to_string(rounds));
 
    S.resize(2*rounds + 2);
    }
diff --git a/src/block/safer/safer_sk.cpp b/src/block/safer/safer_sk.cpp
index 59a6cc276..1d103040d 100644
--- a/src/block/safer/safer_sk.cpp
+++ b/src/block/safer/safer_sk.cpp
@@ -117,7 +117,7 @@ void SAFER_SK::key_schedule(const byte key[], size_t)
 */
 std::string SAFER_SK::name() const
    {
-   return "SAFER-SK(" + to_string(get_rounds()) + ")";
+   return "SAFER-SK(" + std::to_string(get_rounds()) + ")";
    }
 
 /*
diff --git a/src/build-data/cc/compaq.txt b/src/build-data/cc/compaq.txt
deleted file mode 100644
index 7e7f1ea56..000000000
--- a/src/build-data/cc/compaq.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-macro_name COMPAQ
-
-binary_name cxx
-
-compile_option "-c "
-output_to_option "-o "
-add_include_dir_option -I
-add_lib_dir_option -L
-add_lib_option -l
-
-# -O3 and up seem to be unhappy with Botan
-lib_opt_flags "-O2"
-check_opt_flags "-O2"
-debug_flags -g
-no_debug_flags ""
-lang_flags "-std ansi -D__USE_STD_IOSTREAM"
-
-makefile_style unix
-
-<so_link_flags>
-default -> "$(CXX) -shared -soname $(SONAME)"
-</so_link_flags>
-
-<mach_opt>
-alpha -> "-arch=SUBMODEL" alpha-
-</mach_opt>
diff --git a/src/build-data/cc/gcc.txt b/src/build-data/cc/gcc.txt
index c60b9c6bb..6eeb837ed 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++
-
-has_tr1 yes
+binary_name g++-4.5.1
 
 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 -Wno-long-long"
+lang_flags "-D_REENTRANT -std=c++0x"
 warning_flags "-W -Wall"
 
 maintainer_warning_flags "-Werror -Wall -Wextra -Wstrict-aliasing -Wstrict-overflow=5 -Wcast-align -Wmissing-declarations -Wpointer-arith -Wcast-qual"
@@ -73,6 +71,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"
@@ -81,10 +81,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 e8d14c581..1aab4d111 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
 
-has_tr1 yes
-
 compile_option "-c "
 output_to_option "-o "
 add_include_dir_option -I
@@ -14,7 +12,7 @@ lib_opt_flags "-O2 -ip -unroll"
 check_opt_flags "-O2"
 debug_flags -g
 no_debug_flags "-fomit-frame-pointer"
-lang_flags ""
+lang_flags "-std=c++0x"
 warning_flags "-w1"
 shared_flags "-fPIC"
 
diff --git a/src/build-data/cc/kai.txt b/src/build-data/cc/kai.txt
deleted file mode 100644
index 2d9c0cd65..000000000
--- a/src/build-data/cc/kai.txt
+++ /dev/null
@@ -1,27 +0,0 @@
-macro_name KAI
-
-binary_name KCC
-
-compile_option "-c "
-output_to_option "-o "
-add_include_dir_option -I
-add_lib_dir_option -L
-add_lib_option -l
-
-ar_command "KCC -o"
-
-lib_opt_flags "+K3 --inline_auto_space_time=65 --abstract_pointer"
-check_opt_flags "+K3"
-lang_flags "-D__KAI_STRICT"
-debug_flags -g
-no_debug_flags ""
-
-makefile_style unix
-
-<so_link_flags>
-default -> "$(CXX) --soname $(SONAME)"
-</so_link_flags>
-
-<mach_abi_linking>
-all -> "--one_per"
-</mach_abi_linking>
diff --git a/src/build-data/cc/mipspro.txt b/src/build-data/cc/mipspro.txt
deleted file mode 100644
index 28b47b30d..000000000
--- a/src/build-data/cc/mipspro.txt
+++ /dev/null
@@ -1,39 +0,0 @@
-macro_name MIPSPRO
-
-binary_name CC
-
-compile_option "-c "
-output_to_option "-o "
-add_include_dir_option -I
-add_lib_dir_option -L
-add_lib_option -l
-
-lib_opt_flags "-O3 -OPT:alias=TYPED"
-check_opt_flags "-O3 -OPT:alias=TYPED"
-debug_flags "-g3"
-no_debug_flags ""
-shared_flags "-KPIC"
-lang_flags "-ansi -LANG:ansi-for-init-scope=ON"
-# Disabled, because, while my code is fine, it warns about a lot of it's own
-# headers <g>
-#warning_flags "-fullwarn"
-
-makefile_style unix
-
-<so_link_flags>
-default -> "$(CXX) -shared -Wl,-soname,$(SONAME)"
-</so_link_flags>
-
-<mach_opt>
-mips32  -> "-mips1"
-mips64  -> "-mips3"
-
-mips64-r5000  -> "-mips4 -r5000"
-mips64-r8000  -> "-mips4 -r8000"
-mips64-r10000 -> "-mips4 -r10000"
-</mach_opt>
-
-<mach_abi_linking>
-mips32 -> "-n32"
-mips64 -> "-64"
-</mach_abi_linking>
diff --git a/src/build-data/cc/sgipro64.txt b/src/build-data/cc/sgipro64.txt
deleted file mode 100644
index e6a58f16d..000000000
--- a/src/build-data/cc/sgipro64.txt
+++ /dev/null
@@ -1,27 +0,0 @@
-macro_name SGI_PRO64
-
-binary_name sgiCC
-
-compile_option "-c "
-output_to_option "-o "
-add_include_dir_option -I
-add_lib_dir_option -L
-add_lib_option -l
-
-lib_opt_flags "-O3 -OPT:alias=TYPED"
-check_opt_flags "-O3 -OPT:alias=TYPED"
-debug_flags "-g3"
-no_debug_flags ""
-shared_flags "-KPIC"
-lang_flags "-ansi -LANG:ansi-for-init-scope=ON"
-warning_flags "-Wall -W"
-
-makefile_style unix
-
-<so_link_flags>
-default -> "$(CXX) -shared -Wl,-soname,$(SONAME)"
-</so_link_flags>
-
-<mach_opt>
-
-</mach_opt>
diff --git a/src/build-data/makefile/python.in b/src/build-data/makefile/python.in
index d0e33f6e3..cbc21d66a 100644
--- a/src/build-data/makefile/python.in
+++ b/src/build-data/makefile/python.in
@@ -5,7 +5,7 @@ PYTHON_ROOT = /usr/lib/python%{python_version}/config
 PYTHON_INC = -I/usr/include/python%{python_version}
 PYTHON_SITE_PACKAGE_DIR = /usr/lib/python%{python_version}/site-packages/
 
-PYTHON_FLAGS = -Isrc/wrap/python -Os -fPIC -ftemplate-depth-255 $(WARN_FLAGS) $(PYTHON_INC)
+PYTHON_FLAGS = -Isrc/wrap/python -Os -std=c++0x -fPIC -ftemplate-depth-255 $(WARN_FLAGS) $(PYTHON_INC)
 
 BOTAN_PYTHON_MODDIR = %{python_obj_dir}
 
diff --git a/src/build-data/os/windows.txt b/src/build-data/os/windows.txt
index 2f344e33c..30a6b77f8 100644
--- a/src/build-data/os/windows.txt
+++ b/src/build-data/os/windows.txt
@@ -11,10 +11,11 @@ install_cmd_data "copy"
 install_cmd_exec "copy"
 
 <target_features>
-win32_virtual_lock
-win32_get_systemtime
 gmtime_s
 loadlibrary
+win32_get_systemtime
+win32_query_perf_counter
+win32_virtual_lock
 </target_features>
 
 <aliases>
diff --git a/src/cert/cvc/asn1_eac_tm.cpp b/src/cert/cvc/asn1_eac_tm.cpp
index 0eaca49d6..38466f9ff 100644
--- a/src/cert/cvc/asn1_eac_tm.cpp
+++ b/src/cert/cvc/asn1_eac_tm.cpp
@@ -1,7 +1,7 @@
 /*
 * EAC Time Types
 * (C) 2007 FlexSecure GmbH
-*     2008 Jack Lloyd
+*     2008-2009 Jack Lloyd
 *
 * Distributed under the terms of the Botan license
 */
@@ -22,7 +22,7 @@ SecureVector<byte> enc_two_digit(u32bit in)
    {
    SecureVector<byte> result;
    in %= 100;
-   if (in < 10)
+   if(in < 10)
       result.push_back(0x00);
    else
       {
@@ -50,9 +50,10 @@ u32bit dec_two_digit(byte b1, byte b2)
 /*
 * Create an EAC_Time
 */
-EAC_Time::EAC_Time(u64bit timer, ASN1_Tag t) : tag(t)
+EAC_Time::EAC_Time(const std::chrono::system_clock::time_point& time,
+                   ASN1_Tag t) : tag(t)
    {
-   calendar_point cal = calendar_value(timer);
+   calendar_point cal = calendar_value(time);
 
    year   = cal.year;
    month  = cal.month;
@@ -62,11 +63,11 @@ EAC_Time::EAC_Time(u64bit timer, ASN1_Tag t) : tag(t)
 /*
 * Create an EAC_Time
 */
-EAC_Time::EAC_Time(const std::string& t_spec, ASN1_Tag t)
-   :tag(t)
+EAC_Time::EAC_Time(const std::string& t_spec, ASN1_Tag t) : tag(t)
    {
    set_to(t_spec);
    }
+
 /*
 * Create an EAC_Time
 */
@@ -83,7 +84,7 @@ EAC_Time::EAC_Time(u32bit y, u32bit m, u32bit d, ASN1_Tag t)
 */
 void EAC_Time::set_to(const std::string& time_str)
    {
-   if (time_str == "")
+   if(time_str == "")
       {
       year = month = day = 0;
       return;
@@ -92,28 +93,28 @@ void EAC_Time::set_to(const std::string& time_str)
    std::vector<std::string> params;
    std::string current;
 
-   for (u32bit j = 0; j != time_str.size(); ++j)
+   for(u32bit j = 0; j != time_str.size(); ++j)
       {
-      if (Charset::is_digit(time_str[j]))
+      if(Charset::is_digit(time_str[j]))
          current += time_str[j];
       else
          {
-         if (current != "")
+         if(current != "")
             params.push_back(current);
          current.clear();
          }
       }
-   if (current != "")
+   if(current != "")
       params.push_back(current);
 
-   if (params.size() != 3)
+   if(params.size() != 3)
       throw Invalid_Argument("Invalid time specification " + time_str);
 
    year   = to_u32bit(params[0]);
    month  = to_u32bit(params[1]);
    day    = to_u32bit(params[2]);
 
-   if (!passes_sanity_check())
+   if(!passes_sanity_check())
       throw Invalid_Argument("Invalid time specification " + time_str);
    }
 
@@ -132,15 +133,10 @@ void EAC_Time::encode_into(DER_Encoder& der) const
 */
 std::string EAC_Time::as_string() const
    {
-   if (time_is_set() == false)
+   if(time_is_set() == false)
       throw Invalid_State("EAC_Time::as_string: No time set");
 
-   std::string asn1rep;
-   asn1rep = to_string(year, 2);
-
-   asn1rep += to_string(month, 2) + to_string(day, 2);
-
-   return asn1rep;
+   return std::to_string(year * 10000 + month * 100 + day);
    }
 
 /*
@@ -156,15 +152,14 @@ bool EAC_Time::time_is_set() const
 */
 std::string EAC_Time::readable_string() const
    {
-   if (time_is_set() == false)
+   if(time_is_set() == false)
       throw Invalid_State("EAC_Time::readable_string: No time set");
 
-   std::string readable;
-   readable += to_string(year,     2) + "/";
-   readable += to_string(month,    2) + "/";
-   readable += to_string(day,      2) + " ";
+   std::string output(11, 0);
+
+   std::sprintf(&output[0], "%04d/%02d/%02d", year, month, day);
 
-   return readable;
+   return output;
    }
 
 /*
@@ -172,11 +167,11 @@ std::string EAC_Time::readable_string() const
 */
 bool EAC_Time::passes_sanity_check() const
    {
-   if (year < 2000 || year > 2099)
+   if(year < 2000 || year > 2099)
       return false;
-   if (month == 0 || month > 12)
+   if(month == 0 || month > 12)
       return false;
-   if (day == 0 || day > 31)
+   if(day == 0 || day > 31)
       return false;
 
    return true;
@@ -185,11 +180,11 @@ bool EAC_Time::passes_sanity_check() const
 /*
 * modification functions
 */
-
 void EAC_Time::add_years(u32bit years)
    {
    year += years;
    }
+
 void EAC_Time::add_months(u32bit months)
    {
    year += months/12;
@@ -201,23 +196,22 @@ void EAC_Time::add_months(u32bit months)
       }
    }
 
-
 /*
 * Compare this time against another
 */
 s32bit EAC_Time::cmp(const EAC_Time& other) const
    {
-   if (time_is_set() == false)
+   if(time_is_set() == false)
       throw Invalid_State("EAC_Time::cmp: No time set");
 
    const s32bit EARLIER = -1, LATER = 1, SAME_TIME = 0;
 
-   if (year < other.year)     return EARLIER;
-   if (year > other.year)     return LATER;
-   if (month < other.month)   return EARLIER;
-   if (month > other.month)   return LATER;
-   if (day < other.day)       return EARLIER;
-   if (day > other.day)       return LATER;
+   if(year < other.year)     return EARLIER;
+   if(year > other.year)     return LATER;
+   if(month < other.month)   return EARLIER;
+   if(month > other.month)   return LATER;
+   if(day < other.day)       return EARLIER;
+   if(day > other.day)       return LATER;
 
    return SAME_TIME;
    }
@@ -229,22 +223,27 @@ bool operator==(const EAC_Time& t1, const EAC_Time& t2)
    {
    return (t1.cmp(t2) == 0);
    }
+
 bool operator!=(const EAC_Time& t1, const EAC_Time& t2)
    {
    return (t1.cmp(t2) != 0);
    }
+
 bool operator<=(const EAC_Time& t1, const EAC_Time& t2)
    {
    return (t1.cmp(t2) <= 0);
    }
+
 bool operator>=(const EAC_Time& t1, const EAC_Time& t2)
    {
    return (t1.cmp(t2) >= 0);
    }
+
 bool operator>(const EAC_Time& t1, const EAC_Time& t2)
    {
    return (t1.cmp(t2) > 0);
    }
+
 bool operator<(const EAC_Time& t1, const EAC_Time& t2)
    {
    return (t1.cmp(t2) < 0);
@@ -281,19 +280,6 @@ void EAC_Time::decode_from(BER_Decoder& source)
 
    }
 
-u32bit EAC_Time::get_year() const
-   {
-   return year;
-   }
-u32bit EAC_Time::get_month() const
-   {
-   return month;
-   }
-u32bit EAC_Time::get_day() const
-   {
-   return day;
-   }
-
 /*
 * make the value an octet string for encoding
 */
@@ -306,28 +292,4 @@ SecureVector<byte> EAC_Time::encoded_eac_time() const
    return result;
    }
 
-ASN1_Ced::ASN1_Ced(std::string const& str)
-   : EAC_Time(str, ASN1_Tag(37))
-   {}
-
-ASN1_Ced::ASN1_Ced(u64bit val)
-   : EAC_Time(val, ASN1_Tag(37))
-   {}
-
-ASN1_Ced::ASN1_Ced(EAC_Time const& other)
-   : EAC_Time(other.get_year(), other.get_month(), other.get_day(), ASN1_Tag(37))
-   {}
-
-ASN1_Cex::ASN1_Cex(std::string const& str)
-   : EAC_Time(str, ASN1_Tag(36))
-   {}
-
-ASN1_Cex::ASN1_Cex(u64bit val)
-   : EAC_Time(val, ASN1_Tag(36))
-   {}
-
-ASN1_Cex::ASN1_Cex(EAC_Time const& other)
-   : EAC_Time(other.get_year(), other.get_month(), other.get_day(), ASN1_Tag(36))
-   {}
-
 }
diff --git a/src/cert/cvc/cvc_gen_cert.h b/src/cert/cvc/cvc_gen_cert.h
index 61861df41..7b125c10d 100644
--- a/src/cert/cvc/cvc_gen_cert.h
+++ b/src/cert/cvc/cvc_gen_cert.h
@@ -31,7 +31,7 @@ class EAC1_1_gen_CVC : public EAC1_1_obj<Derived> // CRTP continuation from EAC1
       * 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.
@@ -121,9 +121,9 @@ MemoryVector<byte> EAC1_1_gen_CVC<Derived>::make_signed(
    }
 
 template<typename Derived>
-std::auto_ptr<Public_Key> EAC1_1_gen_CVC<Derived>::subject_public_key() const
+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_self.cpp b/src/cert/cvc/cvc_self.cpp
index f1d539923..16b338942 100644
--- a/src/cert/cvc/cvc_self.cpp
+++ b/src/cert/cvc/cvc_self.cpp
@@ -163,6 +163,7 @@ 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);
    PK_Signer signer(*priv_key, padding_and_hash);
    SecureVector<byte> tbs_bits = req.BER_encode();
@@ -192,9 +193,8 @@ EAC1_1_CVC create_cvca(Private_Key const& key,
       }
    EAC1_1_CVC_Options opts;
    opts.car = car;
-   const u64bit current_time = system_time();
 
-   opts.ced = ASN1_Ced(current_time);
+   opts.ced = ASN1_Ced(std::chrono::system_clock::now());
    opts.cex = ASN1_Cex(opts.ced);
    opts.cex.add_months(cvca_validity_months);
    opts.holder_auth_templ = (CVCA | (iris * IRIS) | (fingerpr * FINGERPRINT));
@@ -209,12 +209,12 @@ EAC1_1_CVC link_cvca(EAC1_1_CVC const& signer,
                      EAC1_1_CVC const& signee,
                      RandomNumberGenerator& rng)
    {
-   ECDSA_PrivateKey const* priv_key = dynamic_cast<ECDSA_PrivateKey const*>(&key);
+   const ECDSA_PrivateKey* priv_key = dynamic_cast<ECDSA_PrivateKey const*>(&key);
+
    if (priv_key == 0)
-      {
-      throw Invalid_Argument("CVC_EAC::create_self_signed_cert(): unsupported key type");
-      }
-   ASN1_Ced ced(system_time());
+      throw Invalid_Argument("link_cvca(): unsupported key type");
+
+   ASN1_Ced ced(std::chrono::system_clock::now());
    ASN1_Cex cex(signee.get_cex());
    if (*static_cast<EAC_Time*>(&ced) > *static_cast<EAC_Time*>(&cex))
       {
@@ -231,7 +231,7 @@ 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);
    PK_Signer pk_signer(*priv_key, padding_and_hash);
-   std::auto_ptr<Public_Key> pk = signee.subject_public_key();
+   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(EC_DOMPAR_ENC_EXPLICIT);
 
@@ -261,13 +261,19 @@ EAC1_1_CVC sign_request(EAC1_1_CVC const& signer_cert,
       throw Invalid_Argument("CVC_EAC::create_self_signed_cert(): unsupported key type");
       }
    std::string chr_str = signee.get_chr().value();
-   chr_str += to_string(seqnr, seqnr_len);
+
+   std::string seqnr_string = std::to_string(seqnr);
+
+   while(seqnr_string.size() < seqnr_len)
+      seqnr_string = '0' + seqnr_string;
+
+   chr_str += seqnr_string;
    ASN1_Chr chr(chr_str);
    std::string padding_and_hash = padding_and_hash_from_oid(signee.signature_algorithm().oid);
    PK_Signer pk_signer(*priv_key, padding_and_hash);
-   std::auto_ptr<Public_Key> pk = signee.subject_public_key();
+   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)
@@ -276,8 +282,9 @@ EAC1_1_CVC sign_request(EAC1_1_CVC const& signer_cert,
    subj_pk->set_parameter_encoding(EC_DOMPAR_ENC_IMPLICITCA);
 
    AlgorithmIdentifier sig_algo(signer_cert.signature_algorithm());
-   const u64bit current_time = system_time();
-   ASN1_Ced ced(current_time);
+
+   ASN1_Ced ced(std::chrono::system_clock::now());
+
    u32bit chat_val;
    u32bit chat_low = signer_cert.get_chat_value() & 0x3; // take the chat rights from signer
    ASN1_Cex cex(ced);
diff --git a/src/cert/cvc/eac_asn_obj.h b/src/cert/cvc/eac_asn_obj.h
index d0bab6fdd..dc4f82578 100644
--- a/src/cert/cvc/eac_asn_obj.h
+++ b/src/cert/cvc/eac_asn_obj.h
@@ -56,7 +56,6 @@ class BOTAN_DLL EAC_Time : public ASN1_Object
       * e.g. "2007 08 01"
       */
       void set_to(const std::string& str);
-      //void set_to(const std::string&, ASN1_Tag);
 
       /**
       * Add the specified number of years to this.
@@ -74,24 +73,28 @@ class BOTAN_DLL EAC_Time : public ASN1_Object
       * Get the year value of this objects.
       * @return year value
       */
-      u32bit get_year() const;
+      u32bit get_year() const { return year; }
 
       /**
       * Get the month value of this objects.
       * @return month value
       */
-      u32bit get_month() const;
+      u32bit get_month() const { return month; }
 
       /**
       * Get the day value of this objects.
       * @return day value
       */
-      u32bit get_day() const;
+      u32bit get_day() const { return day; }
 
-      EAC_Time(u64bit, ASN1_Tag t = ASN1_Tag(0));
-      //EAC_Time(const std::string& = "");
-      EAC_Time(const std::string&, ASN1_Tag = ASN1_Tag(0));
-      EAC_Time(u32bit year, u32bit month, u32bit day, ASN1_Tag = ASN1_Tag(0));
+      EAC_Time(const std::chrono::system_clock::time_point& time,
+               ASN1_Tag tag = ASN1_Tag(0));
+
+      EAC_Time(const std::string& yyyy_mm_dd,
+               ASN1_Tag tag = ASN1_Tag(0));
+
+      EAC_Time(u32bit year, u32bit month, u32bit day,
+               ASN1_Tag tag = ASN1_Tag(0));
 
       virtual ~EAC_Time() {}
    private:
@@ -113,25 +116,25 @@ class BOTAN_DLL ASN1_Ced : public EAC_Time
       * @param str a string in the format "yyyy mm dd",
       * e.g. "2007 08 01"
       */
-      ASN1_Ced(std::string const& str = "");
+      ASN1_Ced(std::string const& str = "") :
+         EAC_Time(str, ASN1_Tag(37)) {}
 
       /**
-      * Construct a CED from a timer value.
-      * @param time the number of seconds elapsed midnight, 1st
-      * January 1970 GMT (or 7pm, 31st December 1969 EST) up to the
-      * desired date
+      * Construct a CED from a time point
       */
-      ASN1_Ced(u64bit time);
+      ASN1_Ced(const std::chrono::system_clock::time_point& time) :
+         EAC_Time(time, ASN1_Tag(37)) {}
 
       /**
       * Copy constructor (for general EAC_Time objects).
       * @param other the object to copy from
       */
-      ASN1_Ced(EAC_Time const& other);
-      //ASN1_Ced(ASN1_Cex const& cex);
+      ASN1_Ced(EAC_Time const& other) :
+         EAC_Time(other.get_year(), other.get_month(), other.get_day(),
+                  ASN1_Tag(37))
+         {}
    };
 
-
 /**
 * This class represents CVC CEXs. Only limited sanity checks of
 * the inputted date value are performed.
@@ -140,27 +143,20 @@ class BOTAN_DLL ASN1_Cex : public EAC_Time
    {
    public:
       /**
-      * Construct a CED from a string value.
+      * Construct a CEX from a string value.
       * @param str a string in the format "yyyy mm dd",
       * e.g. "2007 08 01"
       */
-      ASN1_Cex(std::string const& str="");
+      ASN1_Cex(std::string const& str = "") :
+         EAC_Time(str, ASN1_Tag(36)) {}
 
-      /**
-      * Construct a CED from a timer value.
-      * @param time the number of seconds elapsed
-      *  midnight, 1st
-      * January 1970 GMT (or 7pm, 31st December 1969 EST)
-      * up to the desired date
-      */
-      ASN1_Cex(u64bit time);
+      ASN1_Cex(const std::chrono::system_clock::time_point& time) :
+         EAC_Time(time, ASN1_Tag(36)) {}
 
-      /**
-      * Copy constructor (for general EAC_Time objects).
-      * @param other the object to copy from
-      */
-      ASN1_Cex(EAC_Time const& other);
-      //ASN1_Cex(ASN1_Ced const& ced);
+      ASN1_Cex(EAC_Time const& other) :
+         EAC_Time(other.get_year(), other.get_month(), other.get_day(),
+                  ASN1_Tag(36))
+         {}
    };
 
 /**
diff --git a/src/cert/cvc/info.txt b/src/cert/cvc/info.txt
index c42d909b5..d6281802b 100644
--- a/src/cert/cvc/info.txt
+++ b/src/cert/cvc/info.txt
@@ -1,5 +1,4 @@
 define CARD_VERIFIABLE_CERTIFICATES
-
 load_on auto
 
 <header:public>
diff --git a/src/cert/pkcs10/pkcs10.cpp b/src/cert/pkcs10/pkcs10.cpp
index 539022d08..202fd659c 100644
--- a/src/cert/pkcs10/pkcs10.cpp
+++ b/src/cert/pkcs10/pkcs10.cpp
@@ -45,7 +45,7 @@ void PKCS10_Request::force_decode()
    cert_req_info.decode(version);
    if(version != 0)
       throw Decoding_Error("Unknown version code in PKCS #10 request: " +
-                           to_string(version));
+                           std::to_string(version));
 
    X509_DN dn_subject;
    cert_req_info.decode(dn_subject);
diff --git a/src/cert/x509ca/x509_ca.cpp b/src/cert/x509ca/x509_ca.cpp
index 4c4e62baa..7c0e103d1 100644
--- a/src/cert/x509ca/x509_ca.cpp
+++ b/src/cert/x509ca/x509_ca.cpp
@@ -13,10 +13,6 @@
 #include <botan/parsing.h>
 #include <botan/lookup.h>
 #include <botan/oids.h>
-#include <botan/time.h>
-#include <algorithm>
-#include <typeinfo>
-#include <iterator>
 #include <memory>
 #include <set>
 
@@ -56,7 +52,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());
       }
 
@@ -172,7 +168,8 @@ X509_CRL X509_CA::make_crl(const std::vector<CRL_Entry>& revoked,
       next_update = timespec_to_u32bit("7d");
 
    // Totally stupid: ties encoding logic to the return of std::time!!
-   const u64bit current_time = system_time();
+   auto current_time = std::chrono::system_clock::now();
+   auto expire_time = current_time + std::chrono::seconds(next_update);
 
    Extensions extensions;
    extensions.add(
@@ -185,7 +182,7 @@ X509_CRL X509_CA::make_crl(const std::vector<CRL_Entry>& revoked,
             .encode(ca_sig_algo)
             .encode(cert.issuer_dn())
             .encode(X509_Time(current_time))
-            .encode(X509_Time(current_time + next_update))
+            .encode(X509_Time(expire_time))
             .encode_if(revoked.size() > 0,
                  DER_Encoder()
                     .start_cons(SEQUENCE)
diff --git a/src/cert/x509ca/x509_ca.h b/src/cert/x509ca/x509_ca.h
index 97be6a415..7aca26d03 100644
--- a/src/cert/x509ca/x509_ca.h
+++ b/src/cert/x509ca/x509_ca.h
@@ -99,11 +99,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/x509cert/x509cert.cpp b/src/cert/x509cert/x509cert.cpp
index 05f23298b..e3844e8e9 100644
--- a/src/cert/x509cert/x509cert.cpp
+++ b/src/cert/x509cert/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;
    }
 
@@ -84,7 +80,7 @@ void X509_Certificate::force_decode()
       .decode(dn_subject);
 
    if(version > 2)
-      throw Decoding_Error("Unknown X.509 cert version " + to_string(version));
+      throw Decoding_Error("Unknown X.509 cert version " + std::to_string(version));
    if(sig_algo != sig_algo_inner)
       throw Decoding_Error("Algorithm identifier mismatch");
 
@@ -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/x509crl/crl_ent.cpp b/src/cert/x509crl/crl_ent.cpp
index d566637f6..a5663e6bb 100644
--- a/src/cert/x509crl/crl_ent.cpp
+++ b/src/cert/x509crl/crl_ent.cpp
@@ -11,7 +11,6 @@
 #include <botan/ber_dec.h>
 #include <botan/bigint.h>
 #include <botan/oids.h>
-#include <botan/time.h>
 
 namespace Botan {
 
@@ -31,7 +30,7 @@ CRL_Entry::CRL_Entry(const X509_Certificate& cert, CRL_Code why) :
    throw_on_unknown_critical(false)
    {
    serial = cert.serial_number();
-   time = X509_Time(system_time());
+   time = X509_Time(std::chrono::system_clock::now());
    reason = why;
    }
 
diff --git a/src/cert/x509crl/x509_crl.cpp b/src/cert/x509crl/x509_crl.cpp
index f6a344dba..3613c1a91 100644
--- a/src/cert/x509crl/x509_crl.cpp
+++ b/src/cert/x509crl/x509_crl.cpp
@@ -44,7 +44,7 @@ void X509_CRL::force_decode()
 
    if(version != 0 && version != 1)
       throw X509_CRL_Error("Unknown X.509 CRL version " +
-                           to_string(version+1));
+                           std::to_string(version+1));
 
    AlgorithmIdentifier sig_algo_inner;
    tbs_crl.decode(sig_algo_inner);
diff --git a/src/cert/x509self/x509opt.cpp b/src/cert/x509self/x509opt.cpp
index 0702ebf19..8d235ad5d 100644
--- a/src/cert/x509self/x509opt.cpp
+++ b/src/cert/x509self/x509opt.cpp
@@ -8,7 +8,7 @@
 #include <botan/x509self.h>
 #include <botan/oids.h>
 #include <botan/parsing.h>
-#include <botan/time.h>
+#include <chrono>
 
 namespace Botan {
 
@@ -78,16 +78,16 @@ void X509_Cert_Options::sanity_check() const
 * Initialize the certificate options
 */
 X509_Cert_Options::X509_Cert_Options(const std::string& initial_opts,
-                                     u32bit expiration_time_in_seconds)
+                                     u32bit expiration_time)
    {
    is_CA = false;
    path_limit = 0;
    constraints = NO_CONSTRAINTS;
 
-   const u64bit now = system_time();
+   auto now = std::chrono::system_clock::now();
 
    start = X509_Time(now);
-   end = X509_Time(now + expiration_time_in_seconds);
+   end = X509_Time(now + std::chrono::seconds(expiration_time));
 
    if(initial_opts == "")
       return;
diff --git a/src/cert/x509self/x509self.cpp b/src/cert/x509self/x509self.cpp
index e420ca503..6e570d3b6 100644
--- a/src/cert/x509self/x509self.cpp
+++ b/src/cert/x509self/x509self.cpp
@@ -54,7 +54,7 @@ X509_Certificate create_self_signed_cert(const X509_Cert_Options& opts,
    opts.sanity_check();
 
    MemoryVector<byte> pub_key = X509::BER_encode(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;
@@ -100,7 +100,7 @@ PKCS10_Request create_cert_req(const X509_Cert_Options& opts,
    opts.sanity_check();
 
    MemoryVector<byte> pub_key = X509::BER_encode(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/x509store/x509stor.cpp b/src/cert/x509store/x509stor.cpp
index 3fe1adf62..a635b3930 100644
--- a/src/cert/x509store/x509stor.cpp
+++ b/src/cert/x509store/x509stor.cpp
@@ -9,8 +9,8 @@
 #include <botan/parsing.h>
 #include <botan/pubkey.h>
 #include <botan/oids.h>
-#include <botan/time.h>
 #include <algorithm>
+#include <chrono>
 #include <memory>
 
 namespace Botan {
@@ -21,13 +21,14 @@ namespace {
 * Do a validity check
 */
 s32bit validity_check(const X509_Time& start, const X509_Time& end,
-                      u64bit current_time, u32bit slack)
+                      const std::chrono::system_clock::time_point& now,
+                      std::chrono::seconds slack)
    {
    const s32bit NOT_YET_VALID = -1, VALID_TIME = 0, EXPIRED = 1;
 
-   if(start.cmp(current_time + slack) > 0)
+   if(start.cmp(now + slack) > 0)
       return NOT_YET_VALID;
-   if(end.cmp(current_time - slack) < 0)
+   if(end.cmp(now - slack) < 0)
       return EXPIRED;
    return VALID_TIME;
    }
@@ -168,7 +169,8 @@ bool X509_Store::CRL_Data::operator<(const X509_Store::CRL_Data& other) const
 /*
 * X509_Store Constructor
 */
-X509_Store::X509_Store(u32bit slack, u32bit cache_timeout)
+X509_Store::X509_Store(std::chrono::seconds slack,
+                       std::chrono::seconds cache_timeout)
    {
    revoked_info_valid = true;
 
@@ -211,10 +213,11 @@ X509_Code X509_Store::validate_cert(const X509_Certificate& cert,
    if(chaining_result != VERIFIED)
       return chaining_result;
 
-   const u64bit current_time = system_time();
+   auto current_time = std::chrono::system_clock::now();
 
    s32bit time_check = validity_check(cert.start_time(), cert.end_time(),
                                       current_time, time_slack);
+
    if(time_check < 0)      return CERT_NOT_YET_VALID;
    else if(time_check > 0) return CERT_HAS_EXPIRED;
 
@@ -373,7 +376,7 @@ 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::unique_ptr<Public_Key> pub_key(key);
 
    try {
       std::vector<std::string> sig_info =
@@ -528,8 +531,10 @@ void X509_Store::add_trusted_certs(DataSource& source)
 */
 X509_Code X509_Store::add_crl(const X509_CRL& crl)
    {
+   auto current_time = std::chrono::system_clock::now();
+
    s32bit time_check = validity_check(crl.this_update(), crl.next_update(),
-                                      system_time(), time_slack);
+                                      current_time, time_slack);
 
    if(time_check < 0)      return CRL_NOT_YET_VALID;
    else if(time_check > 0) return CRL_HAS_EXPIRED;
@@ -568,8 +573,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)
          {
@@ -607,8 +611,8 @@ X509_Store::Cert_Info::Cert_Info(const X509_Certificate& c,
                                  bool t) : cert(c), trusted(t)
    {
    checked = false;
+   last_checked = std::chrono::system_clock::time_point::min();
    result = UNKNOWN_X509_ERROR;
-   last_checked = 0;
    }
 
 /*
@@ -626,9 +630,9 @@ X509_Code X509_Store::Cert_Info::verify_result() const
 */
 void X509_Store::Cert_Info::set_result(X509_Code code) const
    {
-   result = code;
-   last_checked = system_time();
    checked = true;
+   last_checked = std::chrono::system_clock::now();
+   result = code;
    }
 
 /*
@@ -642,16 +646,16 @@ bool X509_Store::Cert_Info::is_trusted() const
 /*
 * Check if this certificate has been verified
 */
-bool X509_Store::Cert_Info::is_verified(u32bit timeout) const
+bool X509_Store::Cert_Info::is_verified(std::chrono::seconds timeout) const
    {
    if(!checked)
       return false;
    if(result != VERIFIED && result != CERT_NOT_YET_VALID)
       return true;
 
-   const u64bit current_time = system_time();
+   auto now = std::chrono::system_clock::now();
 
-   if(current_time > last_checked + timeout)
+   if(now > last_checked + timeout)
       checked = false;
 
    return checked;
diff --git a/src/cert/x509store/x509stor.h b/src/cert/x509store/x509stor.h
index b4b50022c..532db6190 100644
--- a/src/cert/x509store/x509stor.h
+++ b/src/cert/x509store/x509stor.h
@@ -11,6 +11,7 @@
 #include <botan/x509cert.h>
 #include <botan/x509_crl.h>
 #include <botan/certstor.h>
+#include <functional>
 
 namespace Botan {
 
@@ -70,14 +71,18 @@ class BOTAN_DLL X509_Store
 
       void add_new_certstore(Certificate_Store*);
 
-      X509_Store(u32bit time_slack = 24*60*60,
-                 u32bit cache_results = 30*60);
+      X509_Store& operator=(const X509_Store&) = delete;
+
+      /**
+      * @param slack the slack in checking validity times against current clock
+      * @param cache how long to cache validation results before rechecking
+      */
+      X509_Store(std::chrono::seconds slack = std::chrono::seconds(24*60*60),
+                 std::chrono::seconds cache = std::chrono::seconds(30*60));
 
       X509_Store(const X509_Store&);
       ~X509_Store();
    private:
-      X509_Store& operator=(const X509_Store&) { return (*this); }
-
       class BOTAN_DLL CRL_Data
          {
          public:
@@ -91,7 +96,7 @@ class BOTAN_DLL X509_Store
       class BOTAN_DLL Cert_Info
          {
          public:
-            bool is_verified(u32bit timeout) const;
+            bool is_verified(std::chrono::seconds cache_timeout) const;
             bool is_trusted() const;
             X509_Code verify_result() const;
             void set_result(X509_Code) const;
@@ -102,7 +107,7 @@ class BOTAN_DLL X509_Store
          private:
             mutable bool checked;
             mutable X509_Code result;
-            mutable u64bit last_checked;
+            mutable std::chrono::system_clock::time_point last_checked;
          };
 
       static X509_Code check_sig(const X509_Object&, Public_Key*);
@@ -122,7 +127,8 @@ class BOTAN_DLL X509_Store
       std::vector<Cert_Info> certs;
       std::vector<CRL_Data> revoked;
       std::vector<Certificate_Store*> stores;
-      u32bit time_slack, validation_cache_timeout;
+
+      std::chrono::seconds time_slack, validation_cache_timeout;
       mutable bool revoked_info_valid;
    };
 
diff --git a/src/cms/cms_dalg.cpp b/src/cms/cms_dalg.cpp
index 8b168902b..719b791d2 100644
--- a/src/cms/cms_dalg.cpp
+++ b/src/cms/cms_dalg.cpp
@@ -28,7 +28,7 @@ SecureVector<byte> hash_of(const SecureVector<byte>& content,
 
    Algorithm_Factory& af = global_state().algorithm_factory();
 
-   std::auto_ptr<HashFunction> hash_fn(af.make_hash_function(hash_name));
+   std::unique_ptr<HashFunction> hash_fn(af.make_hash_function(hash_name));
    return hash_fn->process(content);
    }
 
@@ -51,10 +51,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");
 #endif
diff --git a/src/cms/cms_ealg.cpp b/src/cms/cms_ealg.cpp
index 262c74b86..57b44b80e 100644
--- a/src/cms/cms_ealg.cpp
+++ b/src/cms/cms_ealg.cpp
@@ -57,7 +57,7 @@ SecureVector<byte> hash_of(const SecureVector<byte>& content,
                            const std::string& hash_name)
    {
    Algorithm_Factory& af = global_state().algorithm_factory();
-   std::auto_ptr<HashFunction> hash_fn(af.make_hash_function(hash_name));
+   std::unique_ptr<HashFunction> hash_fn(af.make_hash_function(hash_name));
    return hash_fn->process(content);
    }
 
@@ -96,7 +96,7 @@ void CMS_Encoder::encrypt(RandomNumberGenerator& rng,
    {
    const std::string cipher = choose_algo(user_cipher, "TripleDES");
 
-   std::auto_ptr<Public_Key> key(to.subject_public_key());
+   std::unique_ptr<Public_Key> key(to.subject_public_key());
    const std::string algo = key->algo_name();
 
    Key_Constraints constraints = to.constraints();
diff --git a/src/constructs/passhash/passhash9.cpp b/src/constructs/passhash/passhash9.cpp
index e5f379052..367583a0a 100644
--- a/src/constructs/passhash/passhash9.cpp
+++ b/src/constructs/passhash/passhash9.cpp
@@ -62,7 +62,8 @@ std::string generate_passhash9(const std::string& pass,
    MessageAuthenticationCode* prf = get_pbkdf_prf(alg_id);
 
    if(!prf)
-      throw Invalid_Argument("Passhash9: Algorithm id " + to_string(alg_id) +
+      throw Invalid_Argument("Passhash9: Algorithm id " +
+                             std::to_string(alg_id) +
                              " is not defined");
 
    PKCS5_PBKDF2 kdf(prf); // takes ownership of pointer
diff --git a/src/constructs/tss/tss.cpp b/src/constructs/tss/tss.cpp
index e949c5a09..2bd4ec016 100644
--- a/src/constructs/tss/tss.cpp
+++ b/src/constructs/tss/tss.cpp
@@ -205,7 +205,7 @@ RTSS_Share::reconstruct(const std::vector<RTSS_Share>& shares)
 
    byte hash_id = shares[0].contents[16];
 
-   std::auto_ptr<HashFunction> hash(get_rtss_hash_by_id(hash_id));
+   std::unique_ptr<HashFunction> hash(get_rtss_hash_by_id(hash_id));
 
    if(shares[0].size() != secret_len + hash->output_length() + RTSS_HEADER_SIZE + 1)
       throw Decoding_Error("Bad RTSS length field in header");
diff --git a/src/engine/dyn_engine/dyn_engine.cpp b/src/engine/dyn_engine/dyn_engine.cpp
index b76544d0f..2d8dbae3b 100644
--- a/src/engine/dyn_engine/dyn_engine.cpp
+++ b/src/engine/dyn_engine/dyn_engine.cpp
@@ -35,7 +35,7 @@ Dynamically_Loaded_Engine::Dynamically_Loaded_Engine(
       if(mod_version != 20101003)
          throw std::runtime_error("Incompatible version in " +
                                   library_path + " of " +
-                                  to_string(mod_version));
+                                  std::to_string(mod_version));
 
       creator_func creator =
          lib->resolve<creator_func>("create_engine");
diff --git a/src/engine/openssl/ossl_arc4.cpp b/src/engine/openssl/ossl_arc4.cpp
index 1273d239d..3c3f6903b 100644
--- a/src/engine/openssl/ossl_arc4.cpp
+++ b/src/engine/openssl/ossl_arc4.cpp
@@ -40,7 +40,7 @@ std::string ARC4_OpenSSL::name() const
    {
    if(SKIP == 0)   return "ARC4";
    if(SKIP == 256) return "MARK-4";
-   else            return "RC4_skip(" + to_string(SKIP) + ")";
+   else            return "RC4_skip(" + std::to_string(SKIP) + ")";
    }
 
 /*
diff --git a/src/entropy/hres_timer/hres_timer.cpp b/src/entropy/hres_timer/hres_timer.cpp
index b0bbf6fa7..e9307743f 100644
--- a/src/entropy/hres_timer/hres_timer.cpp
+++ b/src/entropy/hres_timer/hres_timer.cpp
@@ -7,9 +7,8 @@
 
 #include <botan/internal/hres_timer.h>
 #include <botan/cpuid.h>
-#include <botan/time.h>
 
-#if defined(BOTAN_TARGET_OS_IS_WINDOWS)
+#if defined(BOTAN_TARGET_OS_HAS_QUERY_PERF_COUNTER)
   #include <windows.h>
 #endif
 
@@ -20,8 +19,7 @@ namespace Botan {
 */
 void High_Resolution_Timestamp::poll(Entropy_Accumulator& accum)
    {
-   // If Windows, grab the Performance Counter (usually TSC or PIT)
-#if defined(BOTAN_TARGET_OS_IS_WINDOWS)
+#if defined(BOTAN_TARGET_OS_HAS_QUERY_PERF_COUNTER)
    LARGE_INTEGER tv;
    ::QueryPerformanceCounter(&tv);
    accum.add(tv.QuadPart, 0);
diff --git a/src/filters/data_snk.h b/src/filters/data_snk.h
index e31cb9d28..6b9da0b4d 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 a274de8e2..d2d51fe23 100644
--- a/src/filters/data_src.h
+++ b/src/filters/data_src.h
@@ -81,9 +81,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 962b2816e..b62846075 100644
--- a/src/filters/filter.h
+++ b/src/filters/filter.h
@@ -78,9 +78,6 @@ class BOTAN_DLL Filter
 
       Filter();
    private:
-      Filter(const Filter&) {}
-      Filter& operator=(const Filter&) { return (*this); }
-
       /**
       * Start a new message in *this and all following filters. Only for
       * internal use, not intended for use in client applications.
@@ -96,6 +93,9 @@ class BOTAN_DLL Filter
       friend class Pipe;
       friend class Fanout_Filter;
 
+      Filter(const Filter&) = delete;
+      Filter& operator=(const Filter&) = delete;
+
       size_t total_ports() const;
       size_t current_port() const { return port_num; }
 
diff --git a/src/filters/modes/cfb/cfb.cpp b/src/filters/modes/cfb/cfb.cpp
index 8f7471c98..22d4a9c2e 100644
--- a/src/filters/modes/cfb/cfb.cpp
+++ b/src/filters/modes/cfb/cfb.cpp
@@ -26,7 +26,7 @@ CFB_Encryption::CFB_Encryption(BlockCipher* ciph, size_t fback_bits)
 
    if(feedback == 0 || fback_bits % 8 != 0 || feedback > cipher->block_size())
       throw Invalid_Argument("CFB_Encryption: Invalid feedback size " +
-                             to_string(fback_bits));
+                             std::to_string(fback_bits));
    }
 
 /*
@@ -46,7 +46,7 @@ CFB_Encryption::CFB_Encryption(BlockCipher* ciph,
 
    if(feedback == 0 || fback_bits % 8 != 0 || feedback > cipher->block_size())
       throw Invalid_Argument("CFB_Encryption: Invalid feedback size " +
-                             to_string(fback_bits));
+                             std::to_string(fback_bits));
 
    set_key(key);
    set_iv(iv);
@@ -103,7 +103,7 @@ CFB_Decryption::CFB_Decryption(BlockCipher* ciph, size_t fback_bits)
 
    if(feedback == 0 || fback_bits % 8 != 0 || feedback > cipher->block_size())
       throw Invalid_Argument("CFB_Decryption: Invalid feedback size " +
-                             to_string(fback_bits));
+                             std::to_string(fback_bits));
    }
 
 /*
@@ -123,7 +123,7 @@ CFB_Decryption::CFB_Decryption(BlockCipher* ciph,
 
    if(feedback == 0 || fback_bits % 8 != 0 || feedback > cipher->block_size())
       throw Invalid_Argument("CFB_Decryption: Invalid feedback size " +
-                             to_string(fback_bits));
+                             std::to_string(fback_bits));
 
    set_key(key);
    set_iv(iv);
diff --git a/src/filters/modes/eax/eax.cpp b/src/filters/modes/eax/eax.cpp
index 6d6d9ec18..791286cc6 100644
--- a/src/filters/modes/eax/eax.cpp
+++ b/src/filters/modes/eax/eax.cpp
@@ -45,7 +45,7 @@ EAX_Base::EAX_Base(BlockCipher* cipher, size_t tag_size) :
    ctr = new CTR_BE(cipher); // takes ownership
 
    if(tag_size % 8 != 0 || TAG_SIZE == 0 || TAG_SIZE > cmac->output_length())
-      throw Invalid_Argument(name() + ": Bad tag size " + to_string(tag_size));
+      throw Invalid_Argument(name() + ": Bad tag size " + std::to_string(tag_size));
    }
 
 /*
diff --git a/src/filters/pipe.cpp b/src/filters/pipe.cpp
index 3c3b5e6a4..53bab3e94 100644
--- a/src/filters/pipe.cpp
+++ b/src/filters/pipe.cpp
@@ -43,11 +43,12 @@ Pipe::Pipe(Filter* f1, Filter* f2, Filter* f3, Filter* f4)
 /*
 * Pipe Constructor
 */
-Pipe::Pipe(Filter* filter_array[], size_t count)
+Pipe::Pipe(std::initializer_list<Filter*> args)
    {
    init();
-   for(size_t 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 e5cb5f445..6df518d3e 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 {
@@ -42,7 +43,7 @@ class BOTAN_DLL Pipe : public DataSource
          */
          Invalid_Message_Number(const std::string& where, message_id msg) :
             Invalid_Argument("Pipe::" + where + ": Invalid message number " +
-                             to_string(msg))
+                             std::to_string(msg))
             {}
          };
 
@@ -264,15 +265,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[], size_t 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 328be6a11..6e3357660 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
 */
@@ -14,20 +14,21 @@ namespace Botan {
 */
 void Parallel::add_data(const byte input[], size_t length)
    {
-   for(size_t i = 0; i != hashes.size(); ++i)
-      hashes[i]->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[])
    {
-   size_t offset = 0;
-   for(size_t i = 0; i != hashes.size(); ++i)
+   u32bit offset = 0;
+
+   for(auto hash = hashes.begin(); hash != hashes.end(); ++hash)
       {
-      hashes[i]->final(hash + offset);
-      offset += hashes[i]->output_length();
+      (*hash)->final(out + offset);
+      offset += (*hash)->OUTPUT_LENGTH;
       }
    }
 
@@ -48,12 +49,14 @@ size_t Parallel::output_length() const
 std::string Parallel::name() const
    {
    std::string hash_names;
-   for(size_t i = 0; i != hashes.size(); ++i)
+
+   for(auto hash = hashes.begin(); hash != hashes.end(); ++hash)
       {
-      if(i)
+      if(hash != hashes.begin())
          hash_names += ',';
-      hash_names += hashes[i]->name();
+      hash_names += (*hash)->name();
       }
+
    return "Parallel(" + hash_names + ")";
    }
 
@@ -63,8 +66,10 @@ std::string Parallel::name() const
 HashFunction* Parallel::clone() const
    {
    std::vector<HashFunction*> hash_copies;
-   for(size_t i = 0; i != hashes.size(); ++i)
-      hash_copies.push_back(hashes[i]->clone());
+
+   for(auto hash = hashes.begin(); hash != hashes.end(); ++hash)
+      hash_copies.push_back((*hash)->clone());
+
    return new Parallel(hash_copies);
    }
 
@@ -73,8 +78,8 @@ HashFunction* Parallel::clone() const
 */
 void Parallel::clear()
    {
-   for(size_t i = 0; i != hashes.size(); ++i)
-      hashes[i]->clear();
+   for(auto hash = hashes.begin(); hash != hashes.end(); ++hash)
+      (*hash)->clear();
    }
 
 /*
@@ -90,8 +95,8 @@ Parallel::Parallel(const std::vector<HashFunction*>& hash_in) :
 */
 Parallel::~Parallel()
    {
-   for(size_t i = 0; i != hashes.size(); ++i)
-      delete hashes[i];
+   for(auto hash = hashes.begin(); hash != hashes.end(); ++hash)
+      delete (*hash);
    }
 
 }
diff --git a/src/hash/skein/skein_512.cpp b/src/hash/skein/skein_512.cpp
index 3ed3e32a7..92acf0814 100644
--- a/src/hash/skein/skein_512.cpp
+++ b/src/hash/skein/skein_512.cpp
@@ -180,7 +180,7 @@ Skein_512::Skein_512(size_t arg_output_bits,
 
 std::string Skein_512::name() const
    {
-   return "Skein-512(" + to_string(output_bits) + ")";
+   return "Skein-512(" + std::to_string(output_bits) + ")";
    }
 
 HashFunction* Skein_512::clone() const
diff --git a/src/hash/tiger/tiger.cpp b/src/hash/tiger/tiger.cpp
index 6f40f84c8..daa0939b9 100644
--- a/src/hash/tiger/tiger.cpp
+++ b/src/hash/tiger/tiger.cpp
@@ -160,7 +160,8 @@ void Tiger::clear()
 */
 std::string Tiger::name() const
    {
-   return "Tiger(" + to_string(output_length()) + "," + to_string(passes) + ")";
+   return "Tiger(" + std::to_string(output_length()) + "," +
+                     std::to_string(passes) + ")";
    }
 
 /*
@@ -175,11 +176,11 @@ Tiger::Tiger(size_t hash_len, size_t passes) :
    {
    if(output_length() != 16 && output_length() != 20 && output_length() != 24)
       throw Invalid_Argument("Tiger: Illegal hash output size: " +
-                             to_string(output_length()));
+                             std::to_string(output_length()));
 
    if(passes < 3)
       throw Invalid_Argument("Tiger: Invalid number of passes: "
-                             + to_string(passes));
+                             + std::to_string(passes));
    clear();
    }
 
diff --git a/src/libstate/global_rng.cpp b/src/libstate/global_rng.cpp
index a73924213..7968613c9 100644
--- a/src/libstate/global_rng.cpp
+++ b/src/libstate/global_rng.cpp
@@ -6,7 +6,6 @@
 */
 
 #include <botan/libstate.h>
-#include <botan/internal/mutex.h>
 
 #if defined(BOTAN_HAS_RANDPOOL)
   #include <botan/randpool.h>
@@ -107,60 +106,60 @@ class Serialized_PRNG : public RandomNumberGenerator
    public:
       void randomize(byte out[], size_t len)
          {
-         Mutex_Holder lock(mutex);
+         std::lock_guard<std::mutex> lock(mutex);
          rng->randomize(out, len);
          }
 
       bool is_seeded() const
          {
-         Mutex_Holder lock(mutex);
+         std::lock_guard<std::mutex> lock(mutex);
          return rng->is_seeded();
          }
 
       void clear()
          {
-         Mutex_Holder lock(mutex);
+         std::lock_guard<std::mutex> lock(mutex);
          rng->clear();
          }
 
       std::string name() const
          {
-         Mutex_Holder lock(mutex);
+         std::lock_guard<std::mutex> lock(mutex);
          return rng->name();
          }
 
       void reseed(size_t poll_bits)
          {
-         Mutex_Holder lock(mutex);
+         std::lock_guard<std::mutex> lock(mutex);
          rng->reseed(poll_bits);
          }
 
       void add_entropy_source(EntropySource* es)
          {
-         Mutex_Holder lock(mutex);
+         std::lock_guard<std::mutex> lock(mutex);
          rng->add_entropy_source(es);
          }
 
       void add_entropy(const byte in[], size_t len)
          {
-         Mutex_Holder lock(mutex);
+         std::lock_guard<std::mutex> lock(mutex);
          rng->add_entropy(in, len);
          }
 
       // We do not own the mutex; Library_State does
-      Serialized_PRNG(RandomNumberGenerator* r, Mutex* m) :
+      Serialized_PRNG(RandomNumberGenerator* r, std::mutex& m) :
          mutex(m), rng(r) {}
 
       ~Serialized_PRNG() { delete rng; }
    private:
-      Mutex* mutex;
+      std::mutex& mutex;
       RandomNumberGenerator* rng;
    };
 
 }
 
 RandomNumberGenerator* Library_State::make_global_rng(Algorithm_Factory& af,
-                                                      Mutex* mutex)
+                                                      std::mutex& mutex)
    {
    RandomNumberGenerator* rng = 0;
 
diff --git a/src/libstate/global_state.cpp b/src/libstate/global_state.cpp
index 00b71039f..2b9162f12 100644
--- a/src/libstate/global_state.cpp
+++ b/src/libstate/global_state.cpp
@@ -37,7 +37,7 @@ Library_State& global_state()
    if(!global_lib_state)
       {
       global_lib_state = new Library_State;
-      global_lib_state->initialize(true);
+      global_lib_state->initialize();
       }
 
    return (*global_lib_state);
diff --git a/src/libstate/info.txt b/src/libstate/info.txt
index 94ae8101a..a017589fc 100644
--- a/src/libstate/info.txt
+++ b/src/libstate/info.txt
@@ -35,8 +35,6 @@ hash
 kdf
 mac
 mode_pad
-mutex
-noop_mutex
 pbkdf
 pk_pad
 pubkey
diff --git a/src/libstate/init.cpp b/src/libstate/init.cpp
index 7cdc615bd..5fd476994 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>
 #include <botan/global_state.h>
 
@@ -15,36 +14,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(size_t i = 0; i != arg_list.size(); ++i)
-      {
-      if(arg_list[i].size() == 0)
-         continue;
-
-      std::string name, value;
-
-      if(arg_list[i].find('=') == std::string::npos)
-         {
-         name = arg_list[i];
-         value = "true";
-         }
-      else
-         {
-         std::vector<std::string> name_and_value = split_on(arg_list[i], '=');
-         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
       {
@@ -56,7 +27,7 @@ void LibraryInitializer::initialize(const std::string& arg_string)
       */
       Global_State_Management::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 076b55fcf..588c5db1b 100644
--- a/src/libstate/libstate.cpp
+++ b/src/libstate/libstate.cpp
@@ -11,8 +11,6 @@
 #include <botan/cpuid.h>
 #include <botan/internal/defalloc.h>
 #include <botan/internal/core_engine.h>
-#include <botan/internal/mutex.h>
-#include <botan/internal/mux_noop.h>
 #include <botan/internal/stl_util.h>
 #include <botan/internal/mlock.h>
 #include <algorithm>
@@ -21,14 +19,6 @@
   #include <botan/selftest.h>
 #endif
 
-#if defined(BOTAN_HAS_MUTEX_PTHREAD)
-  #include <botan/internal/mux_pthr.h>
-#elif defined(BOTAN_HAS_MUTEX_WIN32)
-  #include <botan/internal/mux_win32.h>
-#elif defined(BOTAN_HAS_MUTEX_QT)
-  #include <botan/internal/mux_qt.h>
-#endif
-
 #if defined(BOTAN_HAS_ALLOC_MMAP)
   #include <botan/internal/mmap_mem.h>
 #endif
@@ -56,19 +46,11 @@
 namespace Botan {
 
 /*
-* 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);
@@ -88,7 +70,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();
 
@@ -101,11 +83,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);
+
    default_allocator_name = type;
    cached_default_allocator = 0;
    }
@@ -114,9 +96,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, "");
@@ -126,9 +108,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 config.count(section + "/" + key) != 0;
    }
@@ -139,12 +121,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;
@@ -161,7 +142,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))
@@ -184,7 +165,7 @@ Algorithm_Factory& Library_State::algorithm_factory() const
 */
 RandomNumberGenerator& Library_State::global_rng()
    {
-   Mutex_Holder lock(global_rng_lock);
+   std::lock_guard<std::mutex> lock(global_rng_lock);
 
    if(!global_rng_ptr)
       global_rng_ptr = make_global_rng(algorithm_factory(),
@@ -196,46 +177,26 @@ RandomNumberGenerator& Library_State::global_rng()
 /*
 * Load a set of modules
 */
-void Library_State::initialize(bool thread_safe)
+void Library_State::initialize()
    {
    CPUID::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 = get_mutex();
-   config_lock = get_mutex();
-   global_rng_lock = get_mutex();
-
+   cached_default_allocator = 0;
    default_allocator_name = has_mlock() ? "locking" : "malloc";
 
    add_allocator(new Malloc_Allocator);
-   add_allocator(new Locking_Allocator(get_mutex()));
+   add_allocator(new Locking_Allocator);
 
 #if defined(BOTAN_HAS_ALLOC_MMAP)
-   add_allocator(new MemoryMapping_Allocator(get_mutex()));
+   add_allocator(new MemoryMapping_Allocator);
 #endif
 
    load_default_config();
 
-   m_algorithm_factory = new Algorithm_Factory(*mutex_factory);
+   m_algorithm_factory = new Algorithm_Factory();
 
 #if defined(BOTAN_HAS_ENGINE_GNU_MP)
    algorithm_factory().add_engine(new GMP_Engine);
@@ -269,12 +230,9 @@ 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;
 
-   global_rng_lock = 0;
    global_rng_ptr = 0;
    }
 
@@ -284,7 +242,11 @@ Library_State::Library_State()
 Library_State::~Library_State()
    {
    delete m_algorithm_factory;
+   m_algorithm_factory = 0;
+
    delete global_rng_ptr;
+   global_rng_ptr = 0;
+
 
    cached_default_allocator = 0;
 
@@ -293,11 +255,6 @@ Library_State::~Library_State()
       allocators[i]->destroy();
       delete allocators[i];
       }
-
-   delete global_rng_lock;
-   delete allocator_lock;
-   delete mutex_factory;
-   delete config_lock;
    }
 
 }
diff --git a/src/libstate/libstate.h b/src/libstate/libstate.h
index aa957c8c9..49908a1e3 100644
--- a/src/libstate/libstate.h
+++ b/src/libstate/libstate.h
@@ -13,16 +13,15 @@
 #include <botan/algo_factory.h>
 #include <botan/rng.h>
 
+#include <mutex>
 #include <string>
 #include <vector>
 #include <map>
 
 namespace Botan {
 
-class Mutex;
-
-/**
-* Global state container aka the buritto at the center of it all
+/*
+* Global State Container Base
 */
 class BOTAN_DLL Library_State
    {
@@ -30,10 +29,10 @@ class BOTAN_DLL Library_State
       Library_State();
       ~Library_State();
 
-      /**
-      * @param thread_safe should a mutex be used for serialization
-      */
-      void initialize(bool thread_safe);
+      Library_State(const Library_State&) = delete;
+      Library_State& operator=(const Library_State&) = delete;
+
+      void initialize();
 
       /**
       * @return global Algorithm_Factory
@@ -49,7 +48,7 @@ class BOTAN_DLL Library_State
       * @param name the name of the allocator
       * @return allocator matching this name, or NULL
       */
-      Allocator* get_allocator(const std::string& name = "") const;
+      Allocator* get_allocator(const std::string& name = "");
 
       /**
       * Add a new allocator to the list of available ones
@@ -70,7 +69,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 or not.
@@ -80,7 +79,7 @@ class BOTAN_DLL Library_State
       * false otherwise
       */
       bool is_set(const std::string& section,
-                  const std::string& key) const;
+                  const std::string& key);
 
       /**
       * Set a configuration parameter.
@@ -109,30 +108,20 @@ class BOTAN_DLL Library_State
       * @param alias the alias to resolve.
       * @return what the alias stands for
       */
-      std::string deref_alias(const std::string& alias) const;
-
-      /**
-      * @return newly created Mutex (free with delete)
-      */
-      Mutex* get_mutex() const;
+      std::string deref_alias(const std::string&);
    private:
       static RandomNumberGenerator* make_global_rng(Algorithm_Factory& af,
-                                                    Mutex* mutex);
+                                                    std::mutex& mutex);
 
       void load_default_config();
 
-      Library_State(const Library_State&) {}
-      Library_State& operator=(const Library_State&) { return (*this); }
-
-      class Mutex_Factory* mutex_factory;
-
-      Mutex* global_rng_lock;
+      std::mutex global_rng_lock;
       RandomNumberGenerator* global_rng_ptr;
 
-      Mutex* config_lock;
+      std::mutex config_lock;
       std::map<std::string, std::string> config;
 
-      Mutex* allocator_lock;
+      std::mutex allocator_lock;
       std::string default_allocator_name;
       std::map<std::string, Allocator*> alloc_factory;
       mutable Allocator* cached_default_allocator;
diff --git a/src/math/bigint/bigint.cpp b/src/math/bigint/bigint.cpp
index 6ee5a75e3..a49335e75 100644
--- a/src/math/bigint/bigint.cpp
+++ b/src/math/bigint/bigint.cpp
@@ -40,7 +40,7 @@ BigInt::BigInt(Sign s, size_t size)
    }
 
 /*
-* Construct a BigInt from a "raw" BigInt
+* Copy constructor
 */
 BigInt::BigInt(const BigInt& b)
    {
@@ -100,6 +100,25 @@ BigInt::BigInt(RandomNumberGenerator& rng, size_t bits)
    randomize(rng, bits);
    }
 
+/**
+* Move constructor
+*/
+BigInt::BigInt(BigInt&& other)
+   {
+   std::swap(*this, other);
+   }
+
+/**
+* Move assignment
+*/
+BigInt& BigInt::operator=(BigInt&& other)
+   {
+   if(this != &other)
+      std::swap(*this, other);
+
+   return (*this);
+   }
+
 /*
 * Swap this BigInt with another
 */
diff --git a/src/math/bigint/bigint.h b/src/math/bigint/bigint.h
index 12a7f1701..5b3dcc2dd 100644
--- a/src/math/bigint/bigint.h
+++ b/src/math/bigint/bigint.h
@@ -493,6 +493,15 @@ class BOTAN_DLL BigInt
      */
      BigInt(NumberType type, size_t n);
 
+     /**
+     * Move constructor
+     */
+     BigInt(BigInt&& other);
+
+     /**
+     * Move assignment
+     */
+     BigInt& operator=(BigInt&& other);
    private:
       SecureVector<word> reg;
       Sign signedness;
diff --git a/src/math/numbertheory/dsa_gen.cpp b/src/math/numbertheory/dsa_gen.cpp
index 670f103da..612370804 100644
--- a/src/math/numbertheory/dsa_gen.cpp
+++ b/src/math/numbertheory/dsa_gen.cpp
@@ -47,15 +47,15 @@ bool generate_dsa_primes(RandomNumberGenerator& rng,
    if(!fips186_3_valid_size(pbits, qbits))
       throw Invalid_Argument(
          "FIPS 186-3 does not allow DSA domain parameters of " +
-         to_string(pbits) + "/" + to_string(qbits) + " bits long");
+         std::to_string(pbits) + "/" + std::to_string(qbits) + " bits long");
 
    if(seed_c.size() * 8 < qbits)
       throw Invalid_Argument(
-         "Generating a DSA parameter set with a " + to_string(qbits) +
+         "Generating a DSA parameter set with a " + std::to_string(qbits) +
          "long q requires a seed at least as many bits long");
 
-   std::auto_ptr<HashFunction> hash(
-      af.make_hash_function("SHA-" + to_string(qbits)));
+   std::unique_ptr<HashFunction> hash(
+      af.make_hash_function("SHA-" + std::to_string(qbits)));
 
    const size_t HASH_SIZE = hash->output_length();
 
diff --git a/src/math/numbertheory/make_prm.cpp b/src/math/numbertheory/make_prm.cpp
index 4fb3f908c..1e8d11000 100644
--- a/src/math/numbertheory/make_prm.cpp
+++ b/src/math/numbertheory/make_prm.cpp
@@ -20,7 +20,7 @@ BigInt random_prime(RandomNumberGenerator& rng,
    {
    if(bits <= 1)
       throw Invalid_Argument("random_prime: Can't make a prime of " +
-                             to_string(bits) + " bits");
+                             std::to_string(bits) + " bits");
    else if(bits == 2)
       return ((rng.next_byte() % 2) ? 2 : 3);
    else if(bits == 3)
@@ -88,7 +88,7 @@ BigInt random_safe_prime(RandomNumberGenerator& rng, size_t bits)
    {
    if(bits <= 64)
       throw Invalid_Argument("random_safe_prime: Can't make a prime of " +
-                             to_string(bits) + " bits");
+                             std::to_string(bits) + " bits");
 
    BigInt p;
    do
diff --git a/src/math/numbertheory/numthry.cpp b/src/math/numbertheory/numthry.cpp
index 8018c1d2d..7809e4beb 100644
--- a/src/math/numbertheory/numthry.cpp
+++ b/src/math/numbertheory/numthry.cpp
@@ -77,7 +77,7 @@ size_t miller_rabin_test_iterations(size_t bits, size_t level)
    {
    struct mapping { size_t bits; size_t verify_iter; size_t check_iter; };
 
-   static const mapping tests[] = {
+   const mapping tests[] = {
       {   50, 55, 25 },
       {  100, 38, 22 },
       {  160, 32, 18 },
diff --git a/src/pbkdf/pbkdf2/pbkdf2.cpp b/src/pbkdf/pbkdf2/pbkdf2.cpp
index 7e4d1cd8a..39d53d417 100644
--- a/src/pbkdf/pbkdf2/pbkdf2.cpp
+++ b/src/pbkdf/pbkdf2/pbkdf2.cpp
@@ -30,7 +30,7 @@ OctetString PKCS5_PBKDF2::derive_key(size_t key_len,
    catch(Invalid_Key_Length)
       {
       throw Exception(name() + " cannot accept passphrases of length " +
-                      to_string(passphrase.length()));
+                      std::to_string(passphrase.length()));
       }
 
    SecureVector<byte> key(key_len);
diff --git a/src/pubkey/dl_group/dl_group.cpp b/src/pubkey/dl_group/dl_group.cpp
index 7f0160b6b..3904841ba 100644
--- a/src/pubkey/dl_group/dl_group.cpp
+++ b/src/pubkey/dl_group/dl_group.cpp
@@ -47,7 +47,7 @@ DL_Group::DL_Group(RandomNumberGenerator& rng,
                    PrimeType type, size_t pbits, size_t qbits)
    {
    if(pbits < 512)
-      throw Invalid_Argument("DL_Group: prime size " + to_string(pbits) +
+      throw Invalid_Argument("DL_Group: prime size " + std::to_string(pbits) +
                              " is too small");
 
    if(type == Strong)
@@ -239,7 +239,7 @@ SecureVector<byte> DL_Group::DER_encode(Format format) const
       .get_contents();
       }
 
-   throw Invalid_Argument("Unknown DL_Group encoding " + to_string(format));
+   throw Invalid_Argument("Unknown DL_Group encoding " + std::to_string(format));
    }
 
 /*
@@ -255,7 +255,7 @@ std::string DL_Group::PEM_encode(Format format) const
    else if(format == ANSI_X9_42)
       return PEM_Code::encode(encoding, "X942 DH PARAMETERS");
    else
-      throw Invalid_Argument("Unknown DL_Group encoding " + to_string(format));
+      throw Invalid_Argument("Unknown DL_Group encoding " + std::to_string(format));
    }
 
 /*
@@ -289,7 +289,7 @@ void DL_Group::BER_decode(DataSource& source, Format format)
          .discard_remaining();
       }
    else
-      throw Invalid_Argument("Unknown DL_Group encoding " + to_string(format));
+      throw Invalid_Argument("Unknown DL_Group encoding " + std::to_string(format));
 
    initialize(new_p, new_q, new_g);
    }
diff --git a/src/pubkey/dsa/dsa.cpp b/src/pubkey/dsa/dsa.cpp
index 5e511840f..c3b4f260b 100644
--- a/src/pubkey/dsa/dsa.cpp
+++ b/src/pubkey/dsa/dsa.cpp
@@ -8,7 +8,7 @@
 #include <botan/dsa.h>
 #include <botan/numthry.h>
 #include <botan/keypair.h>
-
+#include <future>
 namespace Botan {
 
 /*
@@ -89,8 +89,12 @@ DSA_Signature_Operation::sign(const byte msg[], size_t msg_len,
          k.randomize(rng, q.bits());
       while(k >= q);
 
-      r = mod_q.reduce(powermod_g_p(k));
-      s = mod_q.multiply(inverse_mod(k, q), mul_add(x, r, i));
+      auto future_r = std::async(std::launch::async,
+                            [&]() { return mod_q.reduce(powermod_g_p(k)); });
+
+      s = inverse_mod(k, q);
+      r = future_r.get();
+      s = mod_q.multiply(s, mul_add(x, r, i));
       }
 
    SecureVector<byte> output(2*q.bytes());
@@ -124,8 +128,14 @@ bool DSA_Verification_Operation::verify(const byte msg[], size_t 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(std::launch::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);
    }
diff --git a/src/pubkey/nr/nr.cpp b/src/pubkey/nr/nr.cpp
index 61cf7eb3f..e1c5e51da 100644
--- a/src/pubkey/nr/nr.cpp
+++ b/src/pubkey/nr/nr.cpp
@@ -8,6 +8,7 @@
 #include <botan/nr.h>
 #include <botan/numthry.h>
 #include <botan/keypair.h>
+#include <future>
 
 namespace Botan {
 
@@ -132,7 +133,10 @@ NR_Verification_Operation::verify_mr(const byte msg[], size_t msg_len)
    if(c.is_zero() || c >= q || d >= q)
       throw Invalid_Argument("NR verification: Invalid signature");
 
-   BigInt i = mod_p.multiply(powermod_g_p(d), powermod_y_p(c));
+   auto future_y_c = std::async(std::launch::async, 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/pkcs8.cpp b/src/pubkey/pkcs8.cpp
index 4a43f4402..661f461a8 100644
--- a/src/pubkey/pkcs8.cpp
+++ b/src/pubkey/pkcs8.cpp
@@ -41,8 +41,10 @@ SecureVector<byte> PKCS8_extract(DataSource& source,
 /*
 * PEM decode and/or decrypt a private key
 */
-SecureVector<byte> PKCS8_decode(DataSource& source, const User_Interface& ui,
-                                AlgorithmIdentifier& pk_alg_id)
+SecureVector<byte> PKCS8_decode(
+   DataSource& source,
+   std::function<std::pair<bool,std::string> ()> get_passphrase,
+   AlgorithmIdentifier& pk_alg_id)
    {
    AlgorithmIdentifier pbe_alg_id;
    SecureVector<byte> key_data, key;
@@ -89,16 +91,14 @@ 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 =
-               ui.get_passphrase("PKCS #8 private key", source.id(), result);
+            std::pair<bool, std::string> pass = get_passphrase();
 
-            if(result == User_Interface::CANCEL_ACTION)
+            if(pass.first == false)
                break;
 
-            pbe->set_key(passphrase);
+            pbe->set_key(pass.second);
             Pipe decryptor(pbe.release());
 
             decryptor.process_msg(key_data);
@@ -162,7 +162,7 @@ SecureVector<byte> BER_encode(const Private_Key& key,
    {
    const std::string DEFAULT_PBE = "PBE-PKCS5v20(SHA-1,AES-256/CBC)";
 
-   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);
@@ -200,10 +200,10 @@ std::string PEM_encode(const Private_Key& key,
 */
 Private_Key* load_key(DataSource& source,
                       RandomNumberGenerator& rng,
-                      const User_Interface& ui)
+                      std::function<std::pair<bool, std::string> ()> get_pass)
    {
    AlgorithmIdentifier alg_id;
-   SecureVector<byte> pkcs8_key = PKCS8_decode(source, ui, alg_id);
+   SecureVector<byte> pkcs8_key = PKCS8_decode(source, get_pass, alg_id);
 
    const std::string alg_name = OIDS::lookup(alg_id.oid);
    if(alg_name == "" || alg_name == alg_id.oid.as_string())
@@ -218,12 +218,38 @@ Private_Key* load_key(DataSource& source,
 */
 Private_Key* load_key(const std::string& fsname,
                       RandomNumberGenerator& rng,
-                      const User_Interface& ui)
+                      std::function<std::pair<bool, std::string> ()> get_pass)
    {
    DataSource_Stream source(fsname, true);
-   return PKCS8::load_key(source, rng, ui);
+   return PKCS8::load_key(source, rng, get_pass);
    }
 
+namespace {
+
+class Single_Shot_Passphrase
+   {
+   public:
+      Single_Shot_Passphrase(const std::string& pass) :
+         passphrase(pass), first(true) {}
+
+      std::pair<bool, std::string> operator()()
+         {
+         if(first)
+            {
+            first = false;
+            return std::make_pair(true, passphrase);
+            }
+         else
+            return std::make_pair(false, "");
+         }
+
+   private:
+      std::string passphrase;
+      bool first;
+   };
+
+}
+
 /*
 * Extract a private key and return it
 */
@@ -231,7 +257,7 @@ Private_Key* load_key(DataSource& source,
                       RandomNumberGenerator& rng,
                       const std::string& pass)
    {
-   return PKCS8::load_key(source, rng, User_Interface(pass));
+   return PKCS8::load_key(source, rng, Single_Shot_Passphrase(pass));
    }
 
 /*
@@ -241,7 +267,7 @@ Private_Key* load_key(const std::string& fsname,
                       RandomNumberGenerator& rng,
                       const std::string& pass)
    {
-   return PKCS8::load_key(fsname, rng, User_Interface(pass));
+   return PKCS8::load_key(fsname, rng, Single_Shot_Passphrase(pass));
    }
 
 /*
diff --git a/src/pubkey/pkcs8.h b/src/pubkey/pkcs8.h
index 00607b329..d573fb460 100644
--- a/src/pubkey/pkcs8.h
+++ b/src/pubkey/pkcs8.h
@@ -9,7 +9,7 @@
 #define BOTAN_PKCS8_H__
 
 #include <botan/x509_key.h>
-#include <botan/ui.h>
+#include <functional>
 
 namespace Botan {
 
@@ -123,18 +123,19 @@ inline void encrypt_key(const Private_Key& key,
 * Load a key from a data source.
 * @param source the data source providing the encoded key
 * @param rng the rng to use
-* @param ui the user interface to be used for passphrase dialog
+* @param get_passphrase a function that returns passphrases
 * @return loaded private key object
 */
-BOTAN_DLL Private_Key* load_key(DataSource& source,
-                                RandomNumberGenerator& rng,
-                                const User_Interface& ui);
+BOTAN_DLL Private_Key* load_key(
+  DataSource& source,
+  RandomNumberGenerator& rng,
+  std::function<std::pair<bool, std::string> ()> get_passphrase);
 
 /** Load a key from a data source.
 * @param source the data source providing the encoded key
 * @param rng the rng to use
 * @param pass the passphrase to decrypt the key. Provide an empty
-* string if the key is not encoded.
+* string if the key is not encrypted
 * @return loaded private key object
 */
 BOTAN_DLL Private_Key* load_key(DataSource& source,
@@ -145,18 +146,19 @@ BOTAN_DLL Private_Key* load_key(DataSource& source,
 * Load a key from a file.
 * @param filename the path to the file containing the encoded key
 * @param rng the rng to use
-* @param ui the user interface to be used for passphrase dialog
+* @param get_passphrase a function that returns passphrases
 * @return loaded private key object
 */
-BOTAN_DLL Private_Key* load_key(const std::string& filename,
-                                RandomNumberGenerator& rng,
-                                const User_Interface& ui);
+BOTAN_DLL Private_Key* load_key(
+  const std::string& filename,
+  RandomNumberGenerator& rng,
+  std::function<std::pair<bool, std::string> ()> get_passphrase);
 
 /** Load a key from a file.
 * @param filename the path to the file containing the encoded key
 * @param rng the rng to use
 * @param pass the passphrase to decrypt the key. Provide an empty
-* string if the key is not encoded.
+* string if the key is not encrypted
 * @return loaded private key object
 */
 BOTAN_DLL Private_Key* load_key(const std::string& filename,
diff --git a/src/pubkey/pubkey.cpp b/src/pubkey/pubkey.cpp
index 6e63f9fc9..d0b74071c 100644
--- a/src/pubkey/pubkey.cpp
+++ b/src/pubkey/pubkey.cpp
@@ -238,7 +238,7 @@ SecureVector<byte> PK_Signer::signature(RandomNumberGenerator& rng)
       }
    else
       throw Encoding_Error("PK_Signer: Unknown signature format " +
-                           to_string(sig_format));
+                           std::to_string(sig_format));
    }
 
 /*
@@ -324,7 +324,7 @@ bool PK_Verifier::check_signature(const byte sig[], size_t length)
          }
       else
          throw Decoding_Error("PK_Verifier: Unknown signature format " +
-                              to_string(sig_format));
+                              std::to_string(sig_format));
       }
    catch(Invalid_Argument) { return false; }
    }
diff --git a/src/pubkey/rsa/rsa.cpp b/src/pubkey/rsa/rsa.cpp
index 40c3968af..2da366699 100644
--- a/src/pubkey/rsa/rsa.cpp
+++ b/src/pubkey/rsa/rsa.cpp
@@ -11,6 +11,7 @@
 #include <botan/numthry.h>
 #include <botan/keypair.h>
 #include <botan/internal/assert.h>
+#include <future>
 
 namespace Botan {
 
@@ -22,7 +23,7 @@ RSA_PrivateKey::RSA_PrivateKey(RandomNumberGenerator& rng,
    {
    if(bits < 512)
       throw Invalid_Argument(algo_name() + ": Can't make a key that is only " +
-                             to_string(bits) + " bits long");
+                             std::to_string(bits) + " bits long");
    if(exp < 3 || exp % 2 == 0)
       throw Invalid_Argument(algo_name() + ": Invalid encryption exponent");
 
@@ -78,8 +79,9 @@ BigInt RSA_Private_Operation::private_op(const BigInt& m) const
    if(m >= n)
       throw Invalid_Argument("RSA private op - input is too large");
 
-   BigInt j1 = powermod_d1_p(m);
+   auto future_j1 = std::async(std::launch::async, powermod_d1_p, m);
    BigInt j2 = powermod_d2_q(m);
+   BigInt j1 = future_j1.get();
 
    j1 = mod_p.reduce(sub_mul(j1, j2, c));
 
diff --git a/src/pubkey/rw/rw.cpp b/src/pubkey/rw/rw.cpp
index 5f58d8e88..dab84b59f 100644
--- a/src/pubkey/rw/rw.cpp
+++ b/src/pubkey/rw/rw.cpp
@@ -21,7 +21,7 @@ RW_PrivateKey::RW_PrivateKey(RandomNumberGenerator& rng,
    {
    if(bits < 512)
       throw Invalid_Argument(algo_name() + ": Can't make a key that is only " +
-                             to_string(bits) + " bits long");
+                             std::to_string(bits) + " bits long");
    if(exp < 2 || exp % 2 == 1)
       throw Invalid_Argument(algo_name() + ": Invalid encryption exponent");
 
diff --git a/src/rng/hmac_rng/hmac_rng.cpp b/src/rng/hmac_rng/hmac_rng.cpp
index 7912e58af..4f6a90565 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/get_byte.h>
 #include <botan/internal/xor_buf.h>
-#include <botan/internal/stl_util.h>
 #include <algorithm>
 
 namespace Botan {
@@ -216,8 +215,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 92f225a9c..51354db12 100644
--- a/src/rng/randpool/randpool.cpp
+++ b/src/rng/randpool/randpool.cpp
@@ -8,8 +8,8 @@
 #include <botan/randpool.h>
 #include <botan/get_byte.h>
 #include <botan/internal/xor_buf.h>
-#include <botan/internal/stl_util.h>
 #include <algorithm>
+#include <chrono>
 
 namespace Botan {
 
@@ -202,8 +202,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/selftest/selftest.cpp b/src/selftest/selftest.cpp
index 4d2837dac..c5b707b70 100644
--- a/src/selftest/selftest.cpp
+++ b/src/selftest/selftest.cpp
@@ -125,8 +125,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/ssl/cert_ver.cpp b/src/ssl/cert_ver.cpp
index 3220a8c9e..3dcd38141 100644
--- a/src/ssl/cert_ver.cpp
+++ b/src/ssl/cert_ver.cpp
@@ -75,7 +75,7 @@ bool Certificate_Verify::verify(const X509_Certificate& cert,
    {
    // FIXME: duplicate of Server_Key_Exchange::verify
 
-   std::auto_ptr<Public_Key> key(cert.subject_public_key());
+   std::unique_ptr<Public_Key> key(cert.subject_public_key());
 
    std::string padding = "";
    Signature_Format format = IEEE_1363;
diff --git a/src/ssl/info.txt b/src/ssl/info.txt
index 8b566ae60..8f1eda497 100644
--- a/src/ssl/info.txt
+++ b/src/ssl/info.txt
@@ -1,7 +1,5 @@
 define SSL_TLS
 
-uses_tr1 yes
-
 <header:public>
 socket.h
 tls_client.h
diff --git a/src/ssl/rec_wri.cpp b/src/ssl/rec_wri.cpp
index 59dead3cd..04b58e12f 100644
--- a/src/ssl/rec_wri.cpp
+++ b/src/ssl/rec_wri.cpp
@@ -16,7 +16,7 @@ namespace Botan {
 /**
 * Record_Writer Constructor
 */
-Record_Writer::Record_Writer(std::tr1::function<void (const byte[], size_t)> out) :
+Record_Writer::Record_Writer(std::function<void (const byte[], size_t)> out) :
    output_fn(out),
    buffer(DEFAULT_BUFFERSIZE)
    {
@@ -262,7 +262,7 @@ void Record_Writer::send_record(byte type, byte major, byte minor,
 */
 void Record_Writer::alert(Alert_Level level, Alert_Type type)
    {
-   byte alert[2] = { level, type };
+   byte alert[2] = { (byte)level, (byte)type };
    send(ALERT, alert, sizeof(alert));
    flush();
    }
diff --git a/src/ssl/s_kex.cpp b/src/ssl/s_kex.cpp
index 1e7de31d0..ffec0aa8f 100644
--- a/src/ssl/s_kex.cpp
+++ b/src/ssl/s_kex.cpp
@@ -151,7 +151,7 @@ bool Server_Key_Exchange::verify(const X509_Certificate& cert,
                                  const MemoryRegion<byte>& s_random) const
    {
 
-   std::auto_ptr<Public_Key> key(cert.subject_public_key());
+   std::unique_ptr<Public_Key> key(cert.subject_public_key());
 
    std::string padding = "";
    Signature_Format format = IEEE_1363;
diff --git a/src/ssl/tls_client.cpp b/src/ssl/tls_client.cpp
index 5447e9904..03c8117cc 100644
--- a/src/ssl/tls_client.cpp
+++ b/src/ssl/tls_client.cpp
@@ -81,8 +81,8 @@ void client_check_state(Handshake_Type new_msg, Handshake_State* state)
 /**
 * TLS Client Constructor
 */
-TLS_Client::TLS_Client(std::tr1::function<size_t (byte[], size_t)> input_fn,
-                       std::tr1::function<void (const byte[], size_t)> output_fn,
+TLS_Client::TLS_Client(std::function<size_t (byte[], size_t)> input_fn,
+                       std::function<void (const byte[], size_t)> output_fn,
                        const TLS_Policy& policy,
                        RandomNumberGenerator& rng) :
    input_fn(input_fn),
diff --git a/src/ssl/tls_client.h b/src/ssl/tls_client.h
index 7d2ce9cda..0268c34c1 100644
--- a/src/ssl/tls_client.h
+++ b/src/ssl/tls_client.h
@@ -33,8 +33,8 @@ class BOTAN_DLL TLS_Client : public TLS_Connection
       void add_client_cert(const X509_Certificate& cert,
                            Private_Key* cert_key);
 
-      TLS_Client(std::tr1::function<size_t (byte[], size_t)> input_fn,
-                 std::tr1::function<void (const byte[], size_t)> output_fn,
+      TLS_Client(std::function<size_t (byte[], size_t)> input_fn,
+                 std::function<void (const byte[], size_t)> output_fn,
                  const TLS_Policy& policy,
                  RandomNumberGenerator& rng);
 
@@ -51,7 +51,7 @@ class BOTAN_DLL TLS_Client : public TLS_Connection
       void read_handshake(byte, const MemoryRegion<byte>&);
       void process_handshake_msg(Handshake_Type, const MemoryRegion<byte>&);
 
-      std::tr1::function<size_t (byte[], size_t)> input_fn;
+      std::function<size_t (byte[], size_t)> input_fn;
 
       const TLS_Policy& policy;
       RandomNumberGenerator& rng;
diff --git a/src/ssl/tls_record.h b/src/ssl/tls_record.h
index 7a223095f..40b6a6f8d 100644
--- a/src/ssl/tls_record.h
+++ b/src/ssl/tls_record.h
@@ -14,18 +14,9 @@
 #include <botan/mac.h>
 #include <botan/secqueue.h>
 #include <vector>
+#include <functional>
 
-#if defined(BOTAN_USE_STD_TR1)
-  #include <tr1/functional>
-#elif defined(BOTAN_USE_BOOST_TR1)
-  #include <boost/tr1/functional.hpp>
-#else
-  #error "No TR1 library defined for use"
-#endif
-
-namespace Botan {
-
-using namespace std::tr1::placeholders;
+using namespace std::placeholders;
 
 /**
 * TLS Record Writer
@@ -46,7 +37,7 @@ class BOTAN_DLL Record_Writer
 
       void reset();
 
-      Record_Writer(std::tr1::function<void (const byte[], size_t)> output_fn);
+      Record_Writer(std::function<void (const byte[], size_t)> output_fn);
 
       ~Record_Writer() { delete mac; }
    private:
@@ -54,7 +45,7 @@ class BOTAN_DLL Record_Writer
       void send_record(byte type, byte major, byte minor,
                        const byte input[], size_t length);
 
-      std::tr1::function<void (const byte[], size_t)> output_fn;
+      std::function<void (const byte[], size_t)> output_fn;
       Pipe cipher;
       MessageAuthenticationCode* mac;
 
diff --git a/src/ssl/tls_suites.cpp b/src/ssl/tls_suites.cpp
index 07cbec608..304d0b5db 100644
--- a/src/ssl/tls_suites.cpp
+++ b/src/ssl/tls_suites.cpp
@@ -230,7 +230,8 @@ std::pair<std::string, size_t> cipher_code_to_name(TLS_Ciphersuite_Algos algo)
       return std::make_pair("SEED", 16);
 
    throw TLS_Exception(INTERNAL_ERROR,
-                       "CipherSuite: Unknown cipher type " + to_string(algo));
+                       "CipherSuite: Unknown cipher type " +
+                       std::to_string(algo));
    }
 
 std::string mac_code_to_name(TLS_Ciphersuite_Algos algo)
@@ -248,7 +249,8 @@ std::string mac_code_to_name(TLS_Ciphersuite_Algos algo)
       return "SHA-384";
 
    throw TLS_Exception(INTERNAL_ERROR,
-                       "CipherSuite: Unknown MAC type " + to_string(algo));
+                       "CipherSuite: Unknown MAC type " +
+                       std::to_string(algo));
    }
 
 }
@@ -264,7 +266,8 @@ CipherSuite::CipherSuite(u16bit suite_code)
    TLS_Ciphersuite_Algos algos = lookup_ciphersuite(suite_code);
 
    if(algos == 0)
-      throw Invalid_Argument("Unknown ciphersuite: " + to_string(suite_code));
+      throw Invalid_Argument("Unknown ciphersuite: " +
+                             std::to_string(suite_code));
 
    sig_algo = TLS_Ciphersuite_Algos(algos & TLS_ALGO_SIGNER_MASK);
 
diff --git a/src/stream/arc4/arc4.cpp b/src/stream/arc4/arc4.cpp
index cd6230022..313e777a5 100644
--- a/src/stream/arc4/arc4.cpp
+++ b/src/stream/arc4/arc4.cpp
@@ -85,7 +85,7 @@ std::string ARC4::name() const
    {
    if(SKIP == 0)   return "ARC4";
    if(SKIP == 256) return "MARK-4";
-   else            return "RC4_skip(" + to_string(SKIP) + ")";
+   else            return "RC4_skip(" + std::to_string(SKIP) + ")";
    }
 
 /*
diff --git a/src/utils/charset.cpp b/src/utils/charset.cpp
index 8e20e6492..7ee637f80 100644
--- a/src/utils/charset.cpp
+++ b/src/utils/charset.cpp
@@ -119,7 +119,7 @@ std::string transcode(const std::string& str,
       return ucs2_to_latin1(str);
 
    throw Invalid_Argument("Unknown transcoding operation from " +
-                          to_string(from) + " to " + to_string(to));
+                          std::to_string(from) + " to " + std::to_string(to));
    }
 
 /*
diff --git a/src/utils/datastor/datastor.cpp b/src/utils/datastor/datastor.cpp
index 49e7b2dda..363136c69 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,26 +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))
-         {
-         std::pair<std::string, std::string> p(
-            matcher.transform(i->first, i->second));
-
-         multimap_insert(out, p.first, p.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;
    }
@@ -71,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;
    }
@@ -144,7 +119,7 @@ void Data_Store::add(const std::string& key, const std::string& val)
 */
 void Data_Store::add(const std::string& key, u32bit val)
    {
-   add(key, to_string(val));
+   add(key, std::to_string(val));
    }
 
 /*
diff --git a/src/utils/datastor/datastor.h b/src/utils/datastor/datastor.h
index 8d41b07a8..26a0d418c 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>
@@ -25,22 +26,10 @@ class BOTAN_DLL Data_Store
       /**
       * A search function
       */
-      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/exceptn.h b/src/utils/exceptn.h
index 1177a4e7d..8c74420df 100644
--- a/src/utils/exceptn.h
+++ b/src/utils/exceptn.h
@@ -56,7 +56,7 @@ struct BOTAN_DLL Invalid_Key_Length : public Invalid_Argument
    {
    Invalid_Key_Length(const std::string& name, size_t length) :
       Invalid_Argument(name + " cannot accept a key of length " +
-                       to_string(length))
+                       std::to_string(length))
       {}
    };
 
@@ -78,7 +78,7 @@ struct BOTAN_DLL Invalid_Block_Size : public Invalid_Argument
 struct BOTAN_DLL Invalid_IV_Length : public Invalid_Argument
    {
    Invalid_IV_Length(const std::string& mode, size_t bad_len) :
-      Invalid_Argument("IV length " + to_string(bad_len) +
+      Invalid_Argument("IV length " + std::to_string(bad_len) +
                        " is invalid for " + mode)
       {}
    };
diff --git a/src/utils/info.txt b/src/utils/info.txt
index fcf16bd5a..4350ed410 100644
--- a/src/utils/info.txt
+++ b/src/utils/info.txt
@@ -9,7 +9,6 @@ cpuid.cpp
 mlock.cpp
 parsing.cpp
 time.cpp
-ui.cpp
 version.cpp
 </source>
 
@@ -34,7 +33,6 @@ parsing.h
 rotate.h
 time.h
 types.h
-ui.h
 version.h
 get_byte.h
 </header:public>
diff --git a/src/utils/parsing.cpp b/src/utils/parsing.cpp
index 9ec00040c..ff0718bb0 100644
--- a/src/utils/parsing.cpp
+++ b/src/utils/parsing.cpp
@@ -13,53 +13,6 @@
 namespace Botan {
 
 /*
-* Convert a string into an integer
-*/
-u32bit to_u32bit(const std::string& number)
-   {
-   u32bit n = 0;
-
-   for(std::string::const_iterator i = number.begin(); i != number.end(); ++i)
-      {
-      const u32bit OVERFLOW_MARK = 0xFFFFFFFF / 10;
-
-      if(*i == ' ')
-         continue;
-
-      byte digit = Charset::char2digit(*i);
-
-      if((n > OVERFLOW_MARK) || (n == OVERFLOW_MARK && digit > 5))
-         throw Decoding_Error("to_u32bit: Integer overflow");
-      n *= 10;
-      n += digit;
-      }
-   return n;
-   }
-
-/*
-* Convert an integer into a string
-*/
-std::string to_string(u64bit n, size_t min_len)
-   {
-   std::string lenstr;
-   if(n)
-      {
-      while(n > 0)
-         {
-         lenstr = Charset::digit2char(n % 10) + lenstr;
-         n /= 10;
-         }
-      }
-   else
-      lenstr = "0";
-
-   while(lenstr.size() < min_len)
-      lenstr = "0" + lenstr;
-
-   return lenstr;
-   }
-
-/*
 * Convert a string into a time duration
 */
 u32bit timespec_to_u32bit(const std::string& timespec)
@@ -106,7 +59,7 @@ 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 i = name.begin(); i != name.end(); ++i)
+   for(auto i = name.begin(); i != name.end(); ++i)
       {
       char c = *i;
 
@@ -155,7 +108,7 @@ std::vector<std::string> split_on(const std::string& str, char delim)
    if(str == "") return elems;
 
    std::string substr;
-   for(std::string::const_iterator i = str.begin(); i != str.end(); ++i)
+   for(auto i = str.begin(); i != str.end(); ++i)
       {
       if(*i == delim)
          {
@@ -182,7 +135,7 @@ std::vector<u32bit> parse_asn1_oid(const std::string& oid)
    std::string substring;
    std::vector<u32bit> oid_elems;
 
-   for(std::string::const_iterator i = oid.begin(); i != oid.end(); ++i)
+   for(auto i = oid.begin(); i != oid.end(); ++i)
       {
       char c = *i;
 
@@ -212,8 +165,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 +211,9 @@ u32bit string_to_ipv4(const std::string& str)
 
    u32bit ip = 0;
 
-   for(size_t i = 0; i != parts.size(); ++i)
+   for(auto part = parts.begin(); part != parts.end(); ++part)
       {
-      u32bit octet = to_u32bit(parts[i]);
+      u32bit octet = to_u32bit(*part);
 
       if(octet > 255)
          throw Decoding_Error("Invalid IP string " + str);
@@ -282,7 +235,7 @@ std::string ipv4_to_string(u32bit ip)
       {
       if(i)
          str += ".";
-      str += to_string(get_byte(i, ip));
+      str += std::to_string(get_byte(i, ip));
       }
 
    return str;
diff --git a/src/utils/parsing.h b/src/utils/parsing.h
index 12370bf2b..98dcd82b5 100644
--- a/src/utils/parsing.h
+++ b/src/utils/parsing.h
@@ -48,19 +48,12 @@ BOTAN_DLL bool x500_name_cmp(const std::string& name1,
                              const std::string& name2);
 
 /**
-* Convert a number to a string
-* @param n the integer to convert to a string
-* @param min_len the min length of the output string
-* @return n convert to a string
-*/
-BOTAN_DLL std::string to_string(u64bit n, size_t min_len = 0);
-
-/**
 * Convert a string to a number
 * @param str the string to convert
 * @return number value of the string
 */
-BOTAN_DLL u32bit to_u32bit(const std::string& str);
+inline u32bit to_u32bit(const std::string& str)
+   { return std::stoul(str); }
 
 /**
 * Convert a time specification to a number
diff --git a/src/utils/stl_util.h b/src/utils/stl_util.h
index 0e0617d5b..0eb078244 100644
--- a/src/utils/stl_util.h
+++ b/src/utils/stl_util.h
@@ -12,27 +12,7 @@
 
 namespace Botan {
 
-/**
-* Copy-on-Predicate Algorithm
-* @param current the first iterator value
-* @param end the final iterator value
-* @param dest an output iterator
-* @param copy_p the predicate
-*/
-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
 * @param mapping the map to search
 * @param key is what to look for
@@ -50,26 +30,17 @@ inline V search_map(const std::map<K, V>& mapping,
    return i->second;
    }
 
-/**
-* Function adaptor for delete operation
-*/
-template<class T>
-class del_fun : public std::unary_function<T, void>
+template<typename K, typename V, typename R>
+inline R search_map(const std::map<K, V>& mapping, const K& key,
+                    const R& null_result, const R& found_result)
    {
-   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;
+   typename std::map<K, V>::const_iterator i = mapping.find(key);
+   if(i == mapping.end())
+      return null_result;
+   return found_result;
    }
 
-/**
+/*
 * Insert a key/value pair into a multimap
 */
 template<typename K, typename V>
diff --git a/src/utils/time.cpp b/src/utils/time.cpp
index 65e808c04..d5b74828b 100644
--- a/src/utils/time.cpp
+++ b/src/utils/time.cpp
@@ -47,7 +47,7 @@ u64bit combine_timers(u32bit seconds, u32bit parts, u32bit parts_hz)
    return res;
    }
 
-std::tm do_gmtime(time_t time_val)
+std::tm do_gmtime(std::time_t time_val)
    {
    std::tm tm;
 
@@ -68,19 +68,12 @@ std::tm do_gmtime(time_t time_val)
 }
 
 /*
-* Get the system clock
-*/
-u64bit system_time()
-   {
-   return static_cast<u64bit>(std::time(0));
-   }
-
-/*
 * Convert a time_point to a calendar_point
 */
-calendar_point calendar_value(u64bit a_time_t)
+calendar_point calendar_value(
+   const std::chrono::system_clock::time_point& time_point)
    {
-   std::tm tm = do_gmtime(static_cast<std::time_t>(a_time_t));
+   std::tm tm = do_gmtime(std::chrono::system_clock::to_time_t(time_point));
 
    return calendar_point(tm.tm_year + 1900,
                          tm.tm_mon + 1,
diff --git a/src/utils/time.h b/src/utils/time.h
index 56d15513c..516efba3e 100644
--- a/src/utils/time.h
+++ b/src/utils/time.h
@@ -9,7 +9,7 @@
 #define BOTAN_TIME_H__
 
 #include <botan/types.h>
-#include <ctime>
+#include <chrono>
 
 namespace Botan {
 
@@ -51,16 +51,12 @@ struct BOTAN_DLL calendar_point
       year(y), month(mon), day(d), hour(h), minutes(min), seconds(sec) {}
    };
 
-/**
+/*
 * @param time_point a time point from the system clock
 * @return calendar_point object representing this time point
 */
-BOTAN_DLL calendar_point calendar_value(u64bit time_point);
-
-/**
-* @return seconds resolution timestamp, unknown epoch
-*/
-BOTAN_DLL u64bit system_time();
+BOTAN_DLL calendar_point calendar_value(
+   const std::chrono::system_clock::time_point& time_point);
 
 /**
 * @return nanoseconds resolution timestamp, unknown epoch
diff --git a/src/utils/ui.cpp b/src/utils/ui.cpp
deleted file mode 100644
index e6c3430ff..000000000
--- a/src/utils/ui.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
-* User Interface
-* (C) 1999-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#include <botan/ui.h>
-
-namespace Botan {
-
-/*
-* Get a passphrase from the user
-*/
-std::string User_Interface::get_passphrase(const std::string&,
-                                           const std::string&,
-                                           UI_Result& action) const
-   {
-   action = OK;
-
-   if(!first_try)
-      action = CANCEL_ACTION;
-
-   return preset_passphrase;
-   }
-
-/*
-* User_Interface Constructor
-*/
-User_Interface::User_Interface(const std::string& preset) :
-   preset_passphrase(preset)
-   {
-   first_try = true;
-   }
-
-}
diff --git a/src/utils/ui.h b/src/utils/ui.h
deleted file mode 100644
index f69bb2c6d..000000000
--- a/src/utils/ui.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
-* User Interface
-* (C) 1999-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#ifndef BOTAN_UI_H__
-#define BOTAN_UI_H__
-
-#include <botan/build.h>
-#include <string>
-
-namespace Botan {
-
-/**
-* User Interface
-* Only really used for callbacks for PKCS #8 decryption
-*/
-class BOTAN_DLL User_Interface
-   {
-   public:
-      enum UI_Result { OK, CANCEL_ACTION };
-
-      virtual std::string get_passphrase(const std::string&,
-                                         const std::string&,
-                                         UI_Result&) const;
-      User_Interface(const std::string& = "");
-      virtual ~User_Interface() {}
-   protected:
-      std::string preset_passphrase;
-      mutable bool first_try;
-   };
-
-}
-
-#endif
diff --git a/src/utils/version.cpp b/src/utils/version.cpp
index 22827cbe5..ce2083bc0 100644
--- a/src/utils/version.cpp
+++ b/src/utils/version.cpp
@@ -21,9 +21,9 @@ namespace Botan {
 */
 std::string version_string()
    {
-   return to_string(version_major()) + "." +
-          to_string(version_minor()) + "." +
-          to_string(version_patch());
+   return std::to_string(version_major()) + "." +
+          std::to_string(version_minor()) + "." +
+          std::to_string(version_patch());
    }
 
 u32bit version_datestamp() { return BOTAN_VERSION_DATESTAMP; }
diff --git a/src/wrap/python/core.cpp b/src/wrap/python/core.cpp
index 7dac7be7f..6dcceee74 100644
--- a/src/wrap/python/core.cpp
+++ b/src/wrap/python/core.cpp
@@ -178,7 +178,7 @@ std::string python_kdf2(const std::string& param,
                         const std::string& masterkey,
                         u32bit outputlength)
    {
-   std::auto_ptr<KDF> kdf(get_kdf("KDF2(SHA-1)"));
+   std::unique_ptr<KDF> kdf(get_kdf("KDF2(SHA-1)"));
 
    return make_string(
       kdf->derive_key(outputlength,
diff --git a/src/wrap/python/filter.cpp b/src/wrap/python/filter.cpp
index 343c0831b..a2ad620de 100644
--- a/src/wrap/python/filter.cpp
+++ b/src/wrap/python/filter.cpp
@@ -111,19 +111,19 @@ Filter* make_filter4(const std::string& name,
       name);
    }
 
-void append_filter(Pipe& pipe, std::auto_ptr<Filter> filter)
+void append_filter(Pipe& pipe, std::unique_ptr<Filter> filter)
    {
    pipe.append(filter.get());
    filter.release();
    }
 
-void prepend_filter(Pipe& pipe, std::auto_ptr<Filter> filter)
+void prepend_filter(Pipe& pipe, std::unique_ptr<Filter> filter)
    {
    pipe.prepend(filter.get());
    filter.release();
    }
 
-void do_send(std::auto_ptr<FilterWrapper> filter, const std::string& data)
+void do_send(std::unique_ptr<FilterWrapper> filter, const std::string& data)
    {
    printf("Sending %s to %p\n", data.c_str(), filter.get());
    filter->send_str(data);
@@ -133,7 +133,7 @@ BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(rallas_ovls, read_all_as_string, 0, 1)
 
 void export_filters()
    {
-   class_<Filter, std::auto_ptr<Filter>, boost::noncopyable>
+   class_<Filter, std::unique_ptr<Filter>, boost::noncopyable>
       ("__Internal_FilterObj", no_init);
 
    def("make_filter", make_filter1,
@@ -147,7 +147,7 @@ void export_filters()
 
    // This might not work - Pipe will delete the filter, but Python
    // might have allocated the space with malloc() or who-knows-what -> bad
-   class_<FilterWrapper, std::auto_ptr<FilterWrapper>,
+   class_<FilterWrapper, std::unique_ptr<FilterWrapper>,
           bases<Filter>, boost::noncopyable>
       ("FilterObj")
       .def("write", pure_virtual(&Py_Filter::write_str))
@@ -155,8 +155,8 @@ void export_filters()
       .def("start_msg", &Filter::start_msg, &FilterWrapper::default_start_msg)
       .def("end_msg", &Filter::end_msg, &FilterWrapper::default_end_msg);
 
-   implicitly_convertible<std::auto_ptr<FilterWrapper>,
-                          std::auto_ptr<Filter> >();
+   implicitly_convertible<std::unique_ptr<FilterWrapper>,
+                          std::unique_ptr<Filter> >();
 
    void (Pipe::*pipe_write_str)(const std::string&) = &Pipe::write;
    void (Pipe::*pipe_process_str)(const std::string&) = &Pipe::process_msg;
diff --git a/src/wrap/python/python_botan.h b/src/wrap/python/python_botan.h
index a7a2e505e..ac0a17d7f 100644
--- a/src/wrap/python/python_botan.h
+++ b/src/wrap/python/python_botan.h
@@ -24,7 +24,8 @@ class Bad_Size : public Exception
    public:
       Bad_Size(u32bit got, u32bit expected) :
          Exception("Bad size detected in Python/C++ conversion layer: got " +
-                   to_string(got) + " bytes, expected " + to_string(expected))
+                   std::to_string(got) + " bytes, expected " +
+                   std::to_string(expected))
          {}
    };
 
diff --git a/src/wrap/python/rsa.cpp b/src/wrap/python/rsa.cpp
index cbccf96e8..fd9fff37e 100644
--- a/src/wrap/python/rsa.cpp
+++ b/src/wrap/python/rsa.cpp
@@ -63,7 +63,7 @@ class Py_RSA_PrivateKey
 std::string Py_RSA_PrivateKey::decrypt(const std::string& in,
                                        const std::string& padding)
    {
-   std::auto_ptr<PK_Decryptor> enc(get_pk_decryptor(*rsa_key, padding));
+   std::unique_ptr<PK_Decryptor> enc(get_pk_decryptor(*rsa_key, padding));
 
    const byte* in_bytes = reinterpret_cast<const byte*>(in.data());
 
@@ -74,7 +74,7 @@ std::string Py_RSA_PrivateKey::sign(const std::string& in,
                                     const std::string& padding,
                                     Python_RandomNumberGenerator& rng)
    {
-   std::auto_ptr<PK_Signer> sign(get_pk_signer(*rsa_key, padding));
+   std::unique_ptr<PK_Signer> sign(get_pk_signer(*rsa_key, padding));
    const byte* in_bytes = reinterpret_cast<const byte*>(in.data());
    sign->update(in_bytes, in.size());
    return make_string(sign->signature(rng.get_underlying_rng()));
@@ -160,7 +160,7 @@ std::string Py_RSA_PublicKey::encrypt(const std::string& in,
                                       const std::string& padding,
                                       Python_RandomNumberGenerator& rng)
    {
-   std::auto_ptr<PK_Encryptor> enc(get_pk_encryptor(*rsa_key, padding));
+   std::unique_ptr<PK_Encryptor> enc(get_pk_encryptor(*rsa_key, padding));
 
    const byte* in_bytes = reinterpret_cast<const byte*>(in.data());
 
@@ -172,7 +172,7 @@ bool Py_RSA_PublicKey::verify(const std::string& in,
                               const std::string& signature,
                               const std::string& padding)
    {
-   std::auto_ptr<PK_Verifier> ver(get_pk_verifier(*rsa_key, padding));
+   std::unique_ptr<PK_Verifier> ver(get_pk_verifier(*rsa_key, padding));
 
    const byte* in_bytes = reinterpret_cast<const byte*>(in.data());
    const byte* sig_bytes = reinterpret_cast<const byte*>(signature.data());