Repository: randombit/botan
Pull request #2631 (2021-02-21 17:03:53)

Remove TLS 1.0, TLS 1.1, and DTLS 1.0 support


Patch:
diff --git a/src/bogo_shim/bogo_shim.cpp b/src/bogo_shim/bogo_shim.cpp
index 34a4b33e0..b0f658451 100644
--- a/src/bogo_shim/bogo_shim.cpp
+++ b/src/bogo_shim/bogo_shim.cpp
@@ -935,28 +935,11 @@ class Shim_Policy final : public Botan::TLS::Policy
          return version.known_version();
          }
 
-      bool allow_tls10() const override
-         {
-         return !m_args.flag_set("dtls") &&
-            !m_args.flag_set("no-tls1") &&
-            allow_version(Botan::TLS::Protocol_Version::TLS_V10);
-         }
-
-      bool allow_tls11() const override
-         {
-         return !m_args.flag_set("dtls") && !m_args.flag_set("no-tls11") && allow_version(Botan::TLS::Protocol_Version::TLS_V11);
-         }
-
       bool allow_tls12() const override
          {
          return !m_args.flag_set("dtls") && !m_args.flag_set("no-tls12") && allow_version(Botan::TLS::Protocol_Version::TLS_V12);
          }
 
-      bool allow_dtls10() const override
-         {
-         return m_args.flag_set("dtls") && !m_args.flag_set("no-tls1") && allow_version(Botan::TLS::Protocol_Version::DTLS_V10);
-         }
-
       bool allow_dtls12() const override
          {
          return m_args.flag_set("dtls") && !m_args.flag_set("no-tls12") && allow_version(Botan::TLS::Protocol_Version::DTLS_V12);
@@ -1002,11 +985,6 @@ class Shim_Policy final : public Botan::TLS::Policy
          return false;
          }
 
-      bool send_fallback_scsv(Botan::TLS::Protocol_Version) const override
-         {
-         return m_args.flag_set("fallback-scsv");
-         }
-
       //bool server_uses_own_ciphersuite_preferences() const override;
 
       //bool negotiate_encrypt_then_mac() const override;
@@ -1057,7 +1035,7 @@ class Shim_Policy final : public Botan::TLS::Policy
       size_t m_sessions;
    };
 
-std::vector<uint16_t> Shim_Policy::ciphersuite_list(Botan::TLS::Protocol_Version version) const
+std::vector<uint16_t> Shim_Policy::ciphersuite_list(Botan::TLS::Protocol_Version) const
    {
    std::vector<uint16_t> ciphersuite_codes;
 
@@ -1113,17 +1091,6 @@ std::vector<uint16_t> Shim_Policy::ciphersuite_list(Botan::TLS::Protocol_Version
                }
             }
 
-         if(!version.supports_aead_modes())
-            {
-            // Are we doing AEAD in a non-AEAD version?
-            if(suite.mac_algo() == "AEAD")
-               continue;
-
-            // Older (v1.0/v1.1) versions also do not support any hash but SHA-1
-            if(suite.mac_algo() != "SHA-1")
-               continue;
-            }
-
          ciphersuite_codes.push_back(suite.ciphersuite_code());
          }
       }
diff --git a/src/bogo_shim/config.json b/src/bogo_shim/config.json
index 8c5c4b1c6..02bc38510 100644
--- a/src/bogo_shim/config.json
+++ b/src/bogo_shim/config.json
@@ -12,6 +12,21 @@
     },
 
     "DisabledTests": {
+        "*TLS1": "No TLS 1.0",
+        "*-TLS1-*": "No TLS 1.0",
+        "*-TLS10-*": "No TLS 1.0",
+        "TLS1-*": "No TLS 1.0",
+        "VersionNegotiation*-TLS": "No TLS 1.0",
+        "VersionNegotiation*-DTLS": "No DTLS 1.0",
+
+        "*TLS11": "No TLS 1.1",
+        "*-TLS11-*": "No TLS 1.1",
+        "TLS11-*": "No TLS 1.1",
+
+        "CBCRecordSplitting*": "No need to split CBC records in TLS 1.2",
+
+        "*SCSV*": "SCSV is meaningless without TLS 1.0/1.1 support",
+
         "*KeyUpdate*": "No TLS 1.3",
         "*TLS13*": "No TLS 1.3",
         "Server-JDK11*": "No TLS 1.3",
diff --git a/src/build-data/policy/bsi.txt b/src/build-data/policy/bsi.txt
index 525d966c0..88ddb4489 100644
--- a/src/build-data/policy/bsi.txt
+++ b/src/build-data/policy/bsi.txt
@@ -174,7 +174,4 @@ x919_mac
 # misc
 bcrypt
 
-# tls
-tls_10
-
 </prohibited>
diff --git a/src/build-data/policy/nist.txt b/src/build-data/policy/nist.txt
index 724a3f242..0ae05feb8 100644
--- a/src/build-data/policy/nist.txt
+++ b/src/build-data/policy/nist.txt
@@ -173,7 +173,6 @@ x919_mac
 bcrypt
 
 # tls
-tls_10
 tls_cbc
 
 </prohibited>
diff --git a/src/cli/tls_client.cpp b/src/cli/tls_client.cpp
index eee97a4c0..be5f7dfcd 100644
--- a/src/cli/tls_client.cpp
+++ b/src/cli/tls_client.cpp
@@ -29,37 +29,11 @@
 
 namespace Botan_CLI {
 
-class CLI_Policy final : public Botan::TLS::Policy
-   {
-   public:
-
-      CLI_Policy(Botan::TLS::Protocol_Version req_version) : m_version(req_version) {}
-
-      std::vector<std::string> allowed_ciphers() const override
-         {
-         // Allow CBC mode only in versions which don't support AEADs
-         if(m_version.supports_aead_modes() == false)
-            {
-            return { "AES-256", "AES-128" };
-            }
-
-         return Botan::TLS::Policy::allowed_ciphers();
-         }
-
-      bool allow_tls10() const override { return m_version == Botan::TLS::Protocol_Version::TLS_V10; }
-      bool allow_tls11() const override { return m_version == Botan::TLS::Protocol_Version::TLS_V11; }
-      bool allow_tls12() const override { return m_version == Botan::TLS::Protocol_Version::TLS_V12; }
-
-   private:
-      Botan::TLS::Protocol_Version m_version;
-   };
-
 class TLS_Client final : public Command, public Botan::TLS::Callbacks
    {
    public:
       TLS_Client()
          : Command("tls_client host --port=443 --print-certs --policy=default "
-                   "--tls1.0 --tls1.1 --tls1.2 "
                    "--skip-system-cert-store --trusted-cas= "
                    "--session-db= --session-db-pass= --next-protocols= --type=tcp")
          {
@@ -124,25 +98,7 @@ class TLS_Client final : public Command, public Botan::TLS::Callbacks
          Botan::TLS::Protocol_Version version =
             use_tcp ? Botan::TLS::Protocol_Version::TLS_V12 : Botan::TLS::Protocol_Version::DTLS_V12;
 
-         if(flag_set("tls1.0"))
-            {
-            version = Botan::TLS::Protocol_Version::TLS_V10;
-            if(!policy)
-               policy.reset(new CLI_Policy(version));
-            }
-         else if(flag_set("tls1.1"))
-            {
-            version = Botan::TLS::Protocol_Version::TLS_V11;
-            if(!policy)
-               policy.reset(new CLI_Policy(version));
-            }
-         else if(flag_set("tls1.2"))
-            {
-            version = Botan::TLS::Protocol_Version::TLS_V12;
-            if(!policy)
-               policy.reset(new CLI_Policy(version));
-            }
-         else if(!policy)
+         if(!policy)
             {
             policy.reset(new Botan::TLS::Policy);
             }
diff --git a/src/cli/tls_helpers.h b/src/cli/tls_helpers.h
index c973d685d..48a856c1a 100644
--- a/src/cli/tls_helpers.h
+++ b/src/cli/tls_helpers.h
@@ -190,8 +190,6 @@ class TLS_All_Policy final : public Botan::TLS::Policy
          return { "ECDSA", "RSA", "DSA", "IMPLICIT" };
          }
 
-      bool allow_tls10() const override { return true; }
-      bool allow_tls11() const override { return true; }
       bool allow_tls12() const override { return true; }
    };
 
diff --git a/src/cli/tls_utils.cpp b/src/cli/tls_utils.cpp
index 698c625e1..a36f2c2df 100644
--- a/src/cli/tls_utils.cpp
+++ b/src/cli/tls_utils.cpp
@@ -31,22 +31,10 @@ class TLS_Ciphersuites final : public Command
             {
             return Botan::TLS::Protocol_Version::TLS_V12;
             }
-         else if(str == "tls1.1" || str == "TLS1.1" || str == "TLS-1.1")
-            {
-            return Botan::TLS::Protocol_Version::TLS_V11;
-            }
-         else if(str == "tls1.0" || str == "TLS1.1" || str == "TLS-1.1")
-            {
-            return Botan::TLS::Protocol_Version::TLS_V10;
-            }
          if(str == "dtls1.2" || str == "DTLS1.2" || str == "DTLS-1.2")
             {
             return Botan::TLS::Protocol_Version::DTLS_V12;
             }
-         else if(str == "dtls1.0" || str == "DTLS1.0" || str == "DTLS-1.0")
-            {
-            return Botan::TLS::Protocol_Version::DTLS_V10;
-            }
          else
             {
             throw CLI_Error("Unknown TLS version '" + str + "'");
diff --git a/src/fuzzer/tls_client.cpp b/src/fuzzer/tls_client.cpp
index 2adc6b350..6f22c3fe1 100644
--- a/src/fuzzer/tls_client.cpp
+++ b/src/fuzzer/tls_client.cpp
@@ -21,27 +21,14 @@ class Fuzzer_TLS_Client_Creds : public Botan::Credentials_Manager
 class Fuzzer_TLS_Policy : public Botan::TLS::Policy
    {
    public:
-      std::vector<uint16_t> ciphersuite_list(Botan::TLS::Protocol_Version version) const override
+      std::vector<uint16_t> ciphersuite_list(Botan::TLS::Protocol_Version) const override
          {
          std::vector<uint16_t> ciphersuites;
 
          for(auto&& suite : Botan::TLS::Ciphersuite::all_known_ciphersuites())
             {
             if(suite.valid() == false)
-               continue;
-
-            if(!version.supports_aead_modes())
-               {
-               // Are we doing AEAD in a non-AEAD version?
-               if(suite.mac_algo() == "AEAD")
-                  continue;
-
-               // Older (v1.0/v1.1) versions also do not support any hash but SHA-1
-               if(suite.mac_algo() != "SHA-1")
-                  continue;
-               }
-
-            ciphersuites.push_back(suite.ciphersuite_code());
+               ciphersuites.push_back(suite.ciphersuite_code());
             }
 
          return ciphersuites;
diff --git a/src/fuzzer/tls_server.cpp b/src/fuzzer/tls_server.cpp
index f251a9df1..a31bde83c 100644
--- a/src/fuzzer/tls_server.cpp
+++ b/src/fuzzer/tls_server.cpp
@@ -112,27 +112,14 @@ class Fuzzer_TLS_Server_Creds : public Botan::Credentials_Manager
 class Fuzzer_TLS_Policy : public Botan::TLS::Policy
    {
    public:
-      std::vector<uint16_t> ciphersuite_list(Botan::TLS::Protocol_Version version) const override
+      std::vector<uint16_t> ciphersuite_list(Botan::TLS::Protocol_Version) const override
          {
          std::vector<uint16_t> ciphersuites;
 
          for(auto&& suite : Botan::TLS::Ciphersuite::all_known_ciphersuites())
             {
-            if(suite.valid() == false)
-               continue;
-
-            if(!version.supports_aead_modes())
-               {
-               // Are we doing AEAD in a non-AEAD version?
-               if(suite.mac_algo() == "AEAD")
-                  continue;
-
-               // Older (v1.0/v1.1) versions also do not support any hash but SHA-1
-               if(suite.mac_algo() != "SHA-1")
-                  continue;
-               }
-
-            ciphersuites.push_back(suite.ciphersuite_code());
+            if(suite.valid())
+               ciphersuites.push_back(suite.ciphersuite_code());
             }
 
          return ciphersuites;
diff --git a/src/lib/kdf/kdf.cpp b/src/lib/kdf/kdf.cpp
index ea143d6c8..6c3cdc2da 100644
--- a/src/lib/kdf/kdf.cpp
+++ b/src/lib/kdf/kdf.cpp
@@ -27,7 +27,7 @@
 #include <botan/internal/kdf1_iso18033.h>
 #endif
 
-#if defined(BOTAN_HAS_TLS_V10_PRF) || defined(BOTAN_HAS_TLS_V12_PRF)
+#if defined(BOTAN_HAS_TLS_V12_PRF)
 #include <botan/internal/prf_tls.h>
 #endif
 
@@ -130,20 +130,6 @@ std::unique_ptr<KDF> KDF::create(const std::string& algo_spec,
       }
 #endif
 
-#if defined(BOTAN_HAS_TLS_V10_PRF)
-   if(req.algo_name() == "TLS-PRF" && req.arg_count() == 0)
-      {
-      if(provider.empty() || provider == "base")
-         {
-         auto hmac_md5 = MessageAuthenticationCode::create("HMAC(MD5)");
-         auto hmac_sha1 = MessageAuthenticationCode::create("HMAC(SHA-1)");
-
-         if(hmac_md5 && hmac_sha1)
-            return std::unique_ptr<KDF>(new TLS_PRF(std::move(hmac_md5), std::move(hmac_sha1)));
-         }
-      }
-#endif
-
 #if defined(BOTAN_HAS_TLS_V12_PRF)
    if(req.algo_name() == "TLS-12-PRF" && req.arg_count() == 1)
       {
diff --git a/src/lib/kdf/prf_tls/info.txt b/src/lib/kdf/prf_tls/info.txt
index 3d76e4b4c..95689b27d 100644
--- a/src/lib/kdf/prf_tls/info.txt
+++ b/src/lib/kdf/prf_tls/info.txt
@@ -1,5 +1,4 @@
 <defines>
-TLS_V10_PRF -> 20131128
 TLS_V12_PRF -> 20131128
 </defines>
 
diff --git a/src/lib/kdf/prf_tls/prf_tls.cpp b/src/lib/kdf/prf_tls/prf_tls.cpp
index a2ac4511d..17d50f469 100644
--- a/src/lib/kdf/prf_tls/prf_tls.cpp
+++ b/src/lib/kdf/prf_tls/prf_tls.cpp
@@ -1,5 +1,5 @@
 /*
-* TLS v1.0 and v1.2 PRFs
+* TLSv1.2 PRF
 * (C) 2004-2010 Jack Lloyd
 *
 * Botan is released under the Simplified BSD License (see license.txt)
@@ -10,12 +10,6 @@
 
 namespace Botan {
 
-TLS_PRF::TLS_PRF() :
-   TLS_PRF(MessageAuthenticationCode::create_or_throw("HMAC(MD5)"),
-           MessageAuthenticationCode::create_or_throw("HMAC(SHA-1)"))
-   {
-   }
-
 namespace {
 
 /*
@@ -58,25 +52,6 @@ void P_hash(uint8_t out[], size_t out_len,
 
 }
 
-void TLS_PRF::kdf(uint8_t key[], size_t key_len,
-                  const uint8_t secret[], size_t secret_len,
-                  const uint8_t salt[], size_t salt_len,
-                  const uint8_t label[], size_t label_len) const
-   {
-   const size_t S1_len = (secret_len + 1) / 2,
-                S2_len = (secret_len + 1) / 2;
-   const uint8_t* S1 = secret;
-   const uint8_t* S2 = secret + (secret_len - S2_len);
-   secure_vector<uint8_t> msg;
-
-   msg.reserve(label_len + salt_len);
-   msg += std::make_pair(label, label_len);
-   msg += std::make_pair(salt, salt_len);
-
-   P_hash(key, key_len, *m_hmac_md5,  S1, S1_len, msg.data(), msg.size());
-   P_hash(key, key_len, *m_hmac_sha1, S2, S2_len, msg.data(), msg.size());
-   }
-
 void TLS_12_PRF::kdf(uint8_t key[], size_t key_len,
                      const uint8_t secret[], size_t secret_len,
                      const uint8_t salt[], size_t salt_len,
diff --git a/src/lib/kdf/prf_tls/prf_tls.h b/src/lib/kdf/prf_tls/prf_tls.h
index cc76df728..19cfc7797 100644
--- a/src/lib/kdf/prf_tls/prf_tls.h
+++ b/src/lib/kdf/prf_tls/prf_tls.h
@@ -1,45 +1,18 @@
 /*
-* TLS v1.0 and v1.2 PRFs
+* TLSv1.2 PRF
 * (C) 2004-2010 Jack Lloyd
 *
 * Botan is released under the Simplified BSD License (see license.txt)
 */
 
-#ifndef BOTAN_TLS_PRF_H_
-#define BOTAN_TLS_PRF_H_
+#ifndef BOTAN_TLS_V12_PRF_H_
+#define BOTAN_TLS_V12_PRF_H_
 
 #include <botan/kdf.h>
 #include <botan/mac.h>
 
 namespace Botan {
 
-/**
-* PRF used in TLS 1.0/1.1
-*/
-class TLS_PRF final : public KDF
-   {
-   public:
-      std::string name() const override { return "TLS-PRF"; }
-
-      KDF* clone() const override { return new TLS_PRF; }
-
-      void kdf(uint8_t key[], size_t key_len,
-               const uint8_t secret[], size_t secret_len,
-               const uint8_t salt[], size_t salt_len,
-               const uint8_t label[], size_t label_len) const override;
-
-      TLS_PRF(std::unique_ptr<MessageAuthenticationCode> hmac_md5,
-              std::unique_ptr<MessageAuthenticationCode> hmac_sha1) :
-         m_hmac_md5(std::move(hmac_md5)),
-         m_hmac_sha1(std::move(hmac_sha1))
-         {}
-
-      TLS_PRF();
-   private:
-      std::unique_ptr<MessageAuthenticationCode> m_hmac_md5;
-      std::unique_ptr<MessageAuthenticationCode> m_hmac_sha1;
-   };
-
 /**
 * PRF used in TLS 1.2
 */
diff --git a/src/lib/tls/info.txt b/src/lib/tls/info.txt
index 18f811f25..3ed102e9c 100644
--- a/src/lib/tls/info.txt
+++ b/src/lib/tls/info.txt
@@ -1,5 +1,5 @@
 <defines>
-TLS -> 20191210
+TLS -> 20201128
 </defines>
 
 <header:public>
diff --git a/src/lib/tls/msg_cert_req.cpp b/src/lib/tls/msg_cert_req.cpp
index a80fbf2b9..ea9ae3711 100644
--- a/src/lib/tls/msg_cert_req.cpp
+++ b/src/lib/tls/msg_cert_req.cpp
@@ -54,24 +54,18 @@ uint8_t cert_type_name_to_code(const std::string& name)
 Certificate_Req::Certificate_Req(Handshake_IO& io,
                                  Handshake_Hash& hash,
                                  const Policy& policy,
-                                 const std::vector<X509_DN>& ca_certs,
-                                 Protocol_Version version) :
+                                 const std::vector<X509_DN>& ca_certs) :
    m_names(ca_certs),
    m_cert_key_types({ "RSA", "ECDSA", "DSA" })
    {
-   if(version.supports_negotiable_signature_algorithms())
-      {
-      m_schemes = policy.acceptable_signature_schemes();
-      }
-
+   m_schemes = policy.acceptable_signature_schemes();
    hash.update(io.send(*this));
    }
 
 /**
 * Deserialize a Certificate Request message
 */
-Certificate_Req::Certificate_Req(const std::vector<uint8_t>& buf,
-                                 Protocol_Version version)
+Certificate_Req::Certificate_Req(const std::vector<uint8_t>& buf)
    {
    if(buf.size() < 4)
       throw Decoding_Error("Certificate_Req: Bad certificate request");
@@ -90,17 +84,14 @@ Certificate_Req::Certificate_Req(const std::vector<uint8_t>& buf,
       m_cert_key_types.emplace_back(cert_type_name);
       }
 
-   if(version.supports_negotiable_signature_algorithms())
-      {
-      const std::vector<uint8_t> algs = reader.get_range_vector<uint8_t>(2, 2, 65534);
+   const std::vector<uint8_t> algs = reader.get_range_vector<uint8_t>(2, 2, 65534);
 
-      if(algs.size() % 2 != 0)
-         throw Decoding_Error("Bad length for signature IDs in certificate request");
+   if(algs.size() % 2 != 0)
+      throw Decoding_Error("Bad length for signature IDs in certificate request");
 
-      for(size_t i = 0; i != algs.size(); i += 2)
-         {
-         m_schemes.push_back(static_cast<Signature_Scheme>(make_uint16(algs[i], algs[i+1])));
-         }
+   for(size_t i = 0; i != algs.size(); i += 2)
+      {
+      m_schemes.push_back(static_cast<Signature_Scheme>(make_uint16(algs[i], algs[i+1])));
       }
 
    const uint16_t purported_size = reader.get_uint16_t();
diff --git a/src/lib/tls/msg_cert_verify.cpp b/src/lib/tls/msg_cert_verify.cpp
index 711566bd0..6fff19b59 100644
--- a/src/lib/tls/msg_cert_verify.cpp
+++ b/src/lib/tls/msg_cert_verify.cpp
@@ -40,16 +40,11 @@ Certificate_Verify::Certificate_Verify(Handshake_IO& io,
 /*
 * Deserialize a Certificate Verify message
 */
-Certificate_Verify::Certificate_Verify(const std::vector<uint8_t>& buf,
-                                       Protocol_Version version)
+Certificate_Verify::Certificate_Verify(const std::vector<uint8_t>& buf)
    {
    TLS_Data_Reader reader("CertificateVerify", buf);
 
-   if(version.supports_negotiable_signature_algorithms())
-      {
-      m_scheme = static_cast<Signature_Scheme>(reader.get_uint16_t());
-      }
-
+   m_scheme = static_cast<Signature_Scheme>(reader.get_uint16_t());
    m_signature = reader.get_range<uint8_t>(2, 0, 65535);
    reader.assert_done();
    }
diff --git a/src/lib/tls/msg_client_hello.cpp b/src/lib/tls/msg_client_hello.cpp
index dfc5df6f7..23869e1f7 100644
--- a/src/lib/tls/msg_client_hello.cpp
+++ b/src/lib/tls/msg_client_hello.cpp
@@ -27,7 +27,6 @@ namespace TLS {
 
 enum {
    TLS_EMPTY_RENEGOTIATION_INFO_SCSV        = 0x00FF,
-   TLS_FALLBACK_SCSV                        = 0x5600
 };
 
 std::vector<uint8_t> make_hello_random(RandomNumberGenerator& rng,
@@ -119,8 +118,7 @@ Client_Hello::Client_Hello(Handshake_IO& io,
    if(reneg_info.empty() && !next_protocols.empty())
       m_extensions.add(new Application_Layer_Protocol_Notification(next_protocols));
 
-   if(m_version.supports_negotiable_signature_algorithms())
-      m_extensions.add(new Signature_Algorithms(policy.acceptable_signature_schemes()));
+   m_extensions.add(new Signature_Algorithms(policy.acceptable_signature_schemes()));
 
    if(m_version.is_datagram_protocol())
       m_extensions.add(new SRTP_Protection_Profiles(policy.srtp_profiles()));
@@ -136,9 +134,6 @@ Client_Hello::Client_Hello(Handshake_IO& io,
 
    cb.tls_modify_extensions(m_extensions, CLIENT);
 
-   if(policy.send_fallback_scsv(client_settings.protocol_version()))
-      m_suites.push_back(TLS_FALLBACK_SCSV);
-
    hash.update(io.send(*this));
    }
 
@@ -192,8 +187,7 @@ Client_Hello::Client_Hello(Handshake_IO& io,
    if(session.supports_encrypt_then_mac())
       m_extensions.add(new Encrypt_then_MAC);
 
-   if(m_version.supports_negotiable_signature_algorithms())
-      m_extensions.add(new Signature_Algorithms(policy.acceptable_signature_schemes()));
+   m_extensions.add(new Signature_Algorithms(policy.acceptable_signature_schemes()));
 
    if(reneg_info.empty() && !next_protocols.empty())
       m_extensions.add(new Application_Layer_Protocol_Notification(next_protocols));
@@ -300,11 +294,6 @@ Client_Hello::Client_Hello(const std::vector<uint8_t>& buf)
       }
    }
 
-bool Client_Hello::sent_fallback_scsv() const
-   {
-   return offered_suite(static_cast<uint16_t>(TLS_FALLBACK_SCSV));
-   }
-
 /*
 * Check if we offered this ciphersuite
 */
diff --git a/src/lib/tls/msg_finished.cpp b/src/lib/tls/msg_finished.cpp
index 3beed2365..4693d9f98 100644
--- a/src/lib/tls/msg_finished.cpp
+++ b/src/lib/tls/msg_finished.cpp
@@ -39,7 +39,7 @@ std::vector<uint8_t> finished_compute_verify(const Handshake_State& state,
    else
       label += std::make_pair(TLS_SERVER_LABEL, sizeof(TLS_SERVER_LABEL));
 
-   input += state.hash().final(state.version(), state.ciphersuite().prf_algo());
+   input += state.hash().final(state.ciphersuite().prf_algo());
 
    return unlock(prf->derive_key(12, state.session_keys().master_secret(), input, label));
    }
diff --git a/src/lib/tls/msg_hello_verify.cpp b/src/lib/tls/msg_hello_verify.cpp
index bc93af9d6..3e9360cc7 100644
--- a/src/lib/tls/msg_hello_verify.cpp
+++ b/src/lib/tls/msg_hello_verify.cpp
@@ -19,8 +19,7 @@ Hello_Verify_Request::Hello_Verify_Request(const std::vector<uint8_t>& buf)
 
    Protocol_Version version(buf[0], buf[1]);
 
-   if(version != Protocol_Version::DTLS_V10 &&
-      version != Protocol_Version::DTLS_V12)
+   if(!version.is_datagram_protocol())
       {
       throw Decoding_Error("Unknown version from server in hello verify request");
       }
@@ -54,7 +53,7 @@ std::vector<uint8_t> Hello_Verify_Request::serialize() const
       negotiated (RFC 6347, section 4.2.1)
    */
 
-   Protocol_Version format_version(Protocol_Version::DTLS_V10);
+   Protocol_Version format_version(254, 255); // DTLS 1.0
 
    std::vector<uint8_t> bits;
    bits.push_back(format_version.major_version());
diff --git a/src/lib/tls/msg_server_hello.cpp b/src/lib/tls/msg_server_hello.cpp
index 651fd14f8..527352e78 100644
--- a/src/lib/tls/msg_server_hello.cpp
+++ b/src/lib/tls/msg_server_hello.cpp
@@ -30,20 +30,8 @@ make_server_hello_random(RandomNumberGenerator& rng,
                          Protocol_Version offered_version,
                          const Policy& policy)
    {
+   BOTAN_UNUSED(offered_version, policy);
    auto random = make_hello_random(rng, policy);
-
-   if((offered_version == Protocol_Version::TLS_V10 ||
-       offered_version == Protocol_Version::TLS_V11) &&
-      policy.allow_tls12())
-      {
-      store_be(DOWNGRADE_TLS11, &random[24]);
-      }
-
-   if(offered_version == Protocol_Version::DTLS_V10 && policy.allow_dtls12())
-      {
-      store_be(DOWNGRADE_TLS11, &random[24]);
-      }
-
    return random;
    }
 
diff --git a/src/lib/tls/msg_server_kex.cpp b/src/lib/tls/msg_server_kex.cpp
index 9aac7df7b..7a2054acb 100644
--- a/src/lib/tls/msg_server_kex.cpp
+++ b/src/lib/tls/msg_server_kex.cpp
@@ -176,6 +176,7 @@ Server_Key_Exchange::Server_Key_Exchange(const std::vector<uint8_t>& buf,
                                          const Auth_Method auth_method,
                                          Protocol_Version version)
    {
+   BOTAN_UNUSED(version); // remove this
    TLS_Data_Reader reader("ServerKeyExchange", buf);
 
    /*
@@ -217,11 +218,7 @@ Server_Key_Exchange::Server_Key_Exchange(const std::vector<uint8_t>& buf,
 
    if(auth_method != Auth_Method::IMPLICIT)
       {
-      if(version.supports_negotiable_signature_algorithms())
-         {
-         m_scheme = static_cast<Signature_Scheme>(reader.get_uint16_t());
-         }
-
+      m_scheme = static_cast<Signature_Scheme>(reader.get_uint16_t());
       m_signature = reader.get_range<uint8_t>(2, 0, 65535);
       }
 
diff --git a/src/lib/tls/tls_10/info.txt b/src/lib/tls/tls_10/info.txt
deleted file mode 100644
index f85a19992..000000000
--- a/src/lib/tls/tls_10/info.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-<defines>
-TLS_V10 -> 20191109
-</defines>
-
-<requires>
-md5
-sha1
-par_hash
-tls_cbc
-</requires>
diff --git a/src/lib/tls/tls_cbc/tls_cbc.cpp b/src/lib/tls/tls_cbc/tls_cbc.cpp
index f8e4e9af4..d2270e3b0 100644
--- a/src/lib/tls/tls_cbc/tls_cbc.cpp
+++ b/src/lib/tls/tls_cbc/tls_cbc.cpp
@@ -40,7 +40,7 @@ TLS_CBC_HMAC_AEAD_Mode::TLS_CBC_HMAC_AEAD_Mode(Cipher_Dir dir,
    m_tag_size = mac->output_length();
    m_block_size = cipher->block_size();
 
-   m_iv_size = version.supports_explicit_cbc_ivs() ? m_block_size : 0;
+   m_iv_size = m_block_size;
 
    m_is_datagram = version.is_datagram_protocol();
 
diff --git a/src/lib/tls/tls_channel.cpp b/src/lib/tls/tls_channel.cpp
index f6198a1c2..3dce68a3a 100644
--- a/src/lib/tls/tls_channel.cpp
+++ b/src/lib/tls/tls_channel.cpp
@@ -559,31 +559,13 @@ void Channel::send_record_array(uint16_t epoch, uint8_t type, const uint8_t inpu
 
    auto cipher_state = write_cipher_state_epoch(epoch);
 
-   if(type == APPLICATION_DATA && m_active_state->version().supports_explicit_cbc_ivs() == false)
+   while(length)
       {
-      while(length)
-         {
-         write_record(cipher_state.get(), epoch, type, input, 1);
-         input += 1;
-         length -= 1;
-
-         const size_t sending = std::min<size_t>(length, MAX_PLAINTEXT_SIZE);
-         write_record(cipher_state.get(), epoch, type, input, sending);
+      const size_t sending = std::min<size_t>(length, MAX_PLAINTEXT_SIZE);
+      write_record(cipher_state.get(), epoch, type, input, sending);
 
-         input += sending;
-         length -= sending;
-         }
-      }
-   else
-      {
-      while(length)
-         {
-         const size_t sending = std::min<size_t>(length, MAX_PLAINTEXT_SIZE);
-         write_record(cipher_state.get(), epoch, type, input, sending);
-
-         input += sending;
-         length -= sending;
-         }
+      input += sending;
+      length -= sending;
       }
    }
 
diff --git a/src/lib/tls/tls_ciphersuite.cpp b/src/lib/tls/tls_ciphersuite.cpp
index cab63bf5c..3e72848e0 100644
--- a/src/lib/tls/tls_ciphersuite.cpp
+++ b/src/lib/tls/tls_ciphersuite.cpp
@@ -39,19 +39,11 @@ size_t Ciphersuite::nonce_bytes_from_handshake() const
 
 size_t Ciphersuite::nonce_bytes_from_record(Protocol_Version version) const
    {
+   BOTAN_UNUSED(version);
    switch(m_nonce_format)
       {
       case Nonce_Format::CBC_MODE:
-         {
-         if(version.supports_explicit_cbc_ivs())
-            {
-            return cipher_algo() == "3DES" ? 8 : 16;
-            }
-         else
-            {
-            return 0;
-            }
-         }
+         return cipher_algo() == "3DES" ? 8 : 16;
       case Nonce_Format::AEAD_IMPLICIT_4:
          return 8;
       case Nonce_Format::AEAD_XOR_12:
@@ -82,13 +74,7 @@ bool Ciphersuite::ecc_ciphersuite() const
 
 bool Ciphersuite::usable_in_version(Protocol_Version version) const
    {
-   if(!version.supports_aead_modes())
-      {
-      // Old versions do not support AEAD, or any MAC but SHA-1
-      if(mac_algo() != "SHA-1")
-         return false;
-      }
-
+   BOTAN_UNUSED(version);
    return true;
    }
 
diff --git a/src/lib/tls/tls_client.cpp b/src/lib/tls/tls_client.cpp
index 7ce9952e6..59a092867 100644
--- a/src/lib/tls/tls_client.cpp
+++ b/src/lib/tls/tls_client.cpp
@@ -558,7 +558,7 @@ void Client::process_handshake_msg(const Handshake_State* active_state,
    else if(type == CERTIFICATE_REQUEST)
       {
       state.set_expected_next(SERVER_HELLO_DONE);
-      state.cert_req(new Certificate_Req(contents, state.version()));
+      state.cert_req(new Certificate_Req(contents));
       }
    else if(type == SERVER_HELLO_DONE)
       {
diff --git a/src/lib/tls/tls_extensions.cpp b/src/lib/tls/tls_extensions.cpp
index ce067d7c0..645c036ea 100644
--- a/src/lib/tls/tls_extensions.cpp
+++ b/src/lib/tls/tls_extensions.cpp
@@ -581,21 +581,11 @@ Supported_Versions::Supported_Versions(Protocol_Version offer, const Policy& pol
       {
       if(offer >= Protocol_Version::DTLS_V12 && policy.allow_dtls12())
          m_versions.push_back(Protocol_Version::DTLS_V12);
-#if defined(BOTAN_HAS_TLS_V10)
-      if(offer >= Protocol_Version::DTLS_V10 && policy.allow_dtls10())
-         m_versions.push_back(Protocol_Version::DTLS_V10);
-#endif
       }
    else
       {
       if(offer >= Protocol_Version::TLS_V12 && policy.allow_tls12())
          m_versions.push_back(Protocol_Version::TLS_V12);
-#if defined(BOTAN_HAS_TLS_V10)
-      if(offer >= Protocol_Version::TLS_V11 && policy.allow_tls11())
-         m_versions.push_back(Protocol_Version::TLS_V11);
-      if(offer >= Protocol_Version::TLS_V10 && policy.allow_tls10())
-         m_versions.push_back(Protocol_Version::TLS_V10);
-#endif
       }
    }
 
diff --git a/src/lib/tls/tls_handshake_hash.cpp b/src/lib/tls/tls_handshake_hash.cpp
index a48251d06..7dd675f69 100644
--- a/src/lib/tls/tls_handshake_hash.cpp
+++ b/src/lib/tls/tls_handshake_hash.cpp
@@ -15,13 +15,10 @@ namespace TLS {
 /**
 * Return a TLS Handshake Hash
 */
-secure_vector<uint8_t> Handshake_Hash::final(Protocol_Version version,
-                                          const std::string& mac_algo) const
+secure_vector<uint8_t> Handshake_Hash::final(const std::string& mac_algo) const
    {
    std::string hash_algo = mac_algo;
-   if(!version.supports_ciphersuite_specific_prf())
-      hash_algo = "Parallel(MD5,SHA-160)";
-   else if(mac_algo == "MD5" || mac_algo == "SHA-1")
+   if(mac_algo == "SHA-1")
       hash_algo = "SHA-256";
 
    std::unique_ptr<HashFunction> hash(HashFunction::create_or_throw(hash_algo));
diff --git a/src/lib/tls/tls_handshake_hash.h b/src/lib/tls/tls_handshake_hash.h
index bb38015c8..0d2ada863 100644
--- a/src/lib/tls/tls_handshake_hash.h
+++ b/src/lib/tls/tls_handshake_hash.h
@@ -27,8 +27,7 @@ class Handshake_Hash final
       void update(const std::vector<uint8_t>& in)
          { m_data += in; }
 
-      secure_vector<uint8_t> final(Protocol_Version version,
-                                const std::string& mac_algo) const;
+      secure_vector<uint8_t> final(const std::string& mac_algo) const;
 
       const std::vector<uint8_t>& get_contents() const { return m_data; }
 
diff --git a/src/lib/tls/tls_handshake_io.cpp b/src/lib/tls/tls_handshake_io.cpp
index 58aa785b1..28a3254b9 100644
--- a/src/lib/tls/tls_handshake_io.cpp
+++ b/src/lib/tls/tls_handshake_io.cpp
@@ -44,7 +44,7 @@ uint64_t steady_clock_ms()
 
 Protocol_Version Stream_Handshake_IO::initial_record_version() const
    {
-   return Protocol_Version::TLS_V10;
+   return Protocol_Version::TLS_V12;
    }
 
 void Stream_Handshake_IO::add_record(const uint8_t record[],
@@ -136,7 +136,7 @@ std::vector<uint8_t> Stream_Handshake_IO::send(const Handshake_Message& msg)
 
 Protocol_Version Datagram_Handshake_IO::initial_record_version() const
    {
-   return Protocol_Version::DTLS_V10;
+   return Protocol_Version::DTLS_V12;
    }
 
 void Datagram_Handshake_IO::retransmit_last_flight()
diff --git a/src/lib/tls/tls_handshake_state.cpp b/src/lib/tls/tls_handshake_state.cpp
index 1129dc58f..3d80c8d91 100644
--- a/src/lib/tls/tls_handshake_state.cpp
+++ b/src/lib/tls/tls_handshake_state.cpp
@@ -369,18 +369,12 @@ std::vector<uint8_t> Handshake_State::session_ticket() const
 
 KDF* Handshake_State::protocol_specific_prf() const
    {
-   if(version().supports_ciphersuite_specific_prf())
-      {
-      const std::string prf_algo = ciphersuite().prf_algo();
-
-      if(prf_algo == "MD5" || prf_algo == "SHA-1")
-         return get_kdf("TLS-12-PRF(SHA-256)");
+   const std::string prf_algo = ciphersuite().prf_algo();
 
-      return get_kdf("TLS-12-PRF(" + prf_algo + ")");
-      }
+   if(prf_algo == "MD5" || prf_algo == "SHA-1")
+      return get_kdf("TLS-12-PRF(SHA-256)");
 
-   // Old PRF used in TLS v1.0, v1.1 and DTLS v1.0
-   return get_kdf("TLS-PRF");
+   return get_kdf("TLS-12-PRF(" + prf_algo + ")");
    }
 
 std::pair<std::string, Signature_Format>
@@ -391,8 +385,6 @@ Handshake_State::choose_sig_format(const Private_Key& key,
    {
    const std::string sig_algo = key.algo_name();
 
-   if(this->version().supports_negotiable_signature_algorithms())
-      {
       const std::vector<Signature_Scheme> allowed = policy.allowed_signature_schemes();
 
       std::vector<Signature_Scheme> requested =
@@ -431,20 +423,6 @@ Handshake_State::choose_sig_format(const Private_Key& key,
          {
          return std::make_pair(padding_string_for_scheme(chosen_scheme), DER_SEQUENCE);
          }
-      }
-   else
-      {
-      if(sig_algo == "RSA")
-         {
-         const std::string padding = "PKCS1v15(Parallel(MD5,SHA-160))";
-         return std::make_pair(padding, IEEE_1363);
-         }
-      else if(sig_algo == "DSA" || sig_algo == "ECDSA")
-         {
-         const std::string padding = "EMSA1(SHA-1)";
-         return std::make_pair(padding, DER_SEQUENCE);
-         }
-      }
 
    throw Invalid_Argument(sig_algo + " is invalid/unknown for TLS signatures");
    }
@@ -485,30 +463,6 @@ Handshake_State::parse_sig_format(const Public_Key& key,
                           "Rejecting " + key_type + " signature");
       }
 
-   if(this->version().supports_negotiable_signature_algorithms() == false)
-      {
-      if(scheme != Signature_Scheme::NONE)
-         throw Decoding_Error("Counterparty sent hash/sig IDs with old version");
-
-      /*
-      There is no check on the acceptability of a v1.0/v1.1 hash type,
-      since it's implicit with use of the protocol
-      */
-
-      if(key_type == "RSA")
-         {
-         const std::string padding = "PKCS1v15(Parallel(MD5,SHA-160))";
-         return std::make_pair(padding, IEEE_1363);
-         }
-      else if(key_type == "DSA" || key_type == "ECDSA")
-         {
-         const std::string padding = "EMSA1(SHA-1)";
-         return std::make_pair(padding, DER_SEQUENCE);
-         }
-      else
-         throw Invalid_Argument(key_type + " is invalid/unknown for TLS signatures");
-      }
-
    if(scheme == Signature_Scheme::NONE)
       throw Decoding_Error("Counterparty did not send hash/sig IDS");
 
diff --git a/src/lib/tls/tls_messages.h b/src/lib/tls/tls_messages.h
index 82b8b593c..08c3682f7 100644
--- a/src/lib/tls/tls_messages.h
+++ b/src/lib/tls/tls_messages.h
@@ -429,11 +429,9 @@ class BOTAN_UNSTABLE_API Certificate_Req final : public Handshake_Message
       Certificate_Req(Handshake_IO& io,
                       Handshake_Hash& hash,
                       const Policy& policy,
-                      const std::vector<X509_DN>& allowed_cas,
-                      Protocol_Version version);
+                      const std::vector<X509_DN>& allowed_cas);
 
-      Certificate_Req(const std::vector<uint8_t>& buf,
-                      Protocol_Version version);
+      Certificate_Req(const std::vector<uint8_t>& buf);
    private:
       std::vector<uint8_t> serialize() const override;
 
@@ -467,8 +465,7 @@ class BOTAN_UNSTABLE_API Certificate_Verify final : public Handshake_Message
                          RandomNumberGenerator& rng,
                          const Private_Key* key);
 
-      Certificate_Verify(const std::vector<uint8_t>& buf,
-                         Protocol_Version version);
+      Certificate_Verify(const std::vector<uint8_t>& buf);
    private:
       std::vector<uint8_t> serialize() const override;
 
diff --git a/src/lib/tls/tls_policy.cpp b/src/lib/tls/tls_policy.cpp
index f54b65aa9..d3fbf78c5 100644
--- a/src/lib/tls/tls_policy.cpp
+++ b/src/lib/tls/tls_policy.cpp
@@ -257,11 +257,6 @@ uint32_t Policy::session_ticket_lifetime() const
    return 86400; // ~1 day
    }
 
-bool Policy::send_fallback_scsv(Protocol_Version version) const
-   {
-   return version != latest_supported_version(version.is_datagram_protocol());
-   }
-
 bool Policy::acceptable_protocol_version(Protocol_Version version) const
    {
    if(version == Protocol_Version::TLS_V12 && allow_tls12())
@@ -270,17 +265,6 @@ bool Policy::acceptable_protocol_version(Protocol_Version version) const
    if(version == Protocol_Version::DTLS_V12 && allow_dtls12())
       return true;
 
-#if defined(BOTAN_HAS_TLS_V10)
-
-   if(version == Protocol_Version::TLS_V11 && allow_tls11())
-      return true;
-   if(version == Protocol_Version::TLS_V10 && allow_tls10())
-      return true;
-   if(version == Protocol_Version::DTLS_V10 && allow_dtls10())
-      return true;
-
-#endif
-
    return false;
    }
 
@@ -290,22 +274,12 @@ Protocol_Version Policy::latest_supported_version(bool datagram) const
       {
       if(acceptable_protocol_version(Protocol_Version::DTLS_V12))
          return Protocol_Version::DTLS_V12;
-#if defined(BOTAN_HAS_TLS_V10)
-      if(acceptable_protocol_version(Protocol_Version::DTLS_V10))
-         return Protocol_Version::DTLS_V10;
-#endif
       throw Invalid_State("Policy forbids all available DTLS version");
       }
    else
       {
       if(acceptable_protocol_version(Protocol_Version::TLS_V12))
          return Protocol_Version::TLS_V12;
-#if defined(BOTAN_HAS_TLS_V10)
-      if(acceptable_protocol_version(Protocol_Version::TLS_V11))
-         return Protocol_Version::TLS_V11;
-      if(acceptable_protocol_version(Protocol_Version::TLS_V10))
-         return Protocol_Version::TLS_V10;
-#endif
       throw Invalid_State("Policy forbids all available TLS version");
       }
    }
@@ -319,10 +293,7 @@ bool Policy::acceptable_ciphersuite(const Ciphersuite& ciphersuite) const
 bool Policy::allow_client_initiated_renegotiation() const { return false; }
 bool Policy::allow_server_initiated_renegotiation() const { return false; }
 bool Policy::allow_insecure_renegotiation() const { return false; }
-bool Policy::allow_tls10()  const { return false; }
-bool Policy::allow_tls11()  const { return false; }
 bool Policy::allow_tls12()  const { return true; }
-bool Policy::allow_dtls10() const { return false; }
 bool Policy::allow_dtls12() const { return true; }
 bool Policy::include_time_in_hello_random() const { return true; }
 bool Policy::hide_unknown_users() const { return false; }
@@ -534,10 +505,7 @@ void print_bool(std::ostream& o,
 
 void Policy::print(std::ostream& o) const
    {
-   print_bool(o, "allow_tls10", allow_tls10());
-   print_bool(o, "allow_tls11", allow_tls11());
    print_bool(o, "allow_tls12", allow_tls12());
-   print_bool(o, "allow_dtls10", allow_dtls10());
    print_bool(o, "allow_dtls12", allow_dtls12());
    print_vec(o, "ciphers", allowed_ciphers());
    print_vec(o, "macs", allowed_macs());
@@ -587,10 +555,7 @@ std::vector<std::string> Strict_Policy::allowed_key_exchange_methods() const
    return { "CECPQ1", "ECDH" };
    }
 
-bool Strict_Policy::allow_tls10()  const { return false; }
-bool Strict_Policy::allow_tls11()  const { return false; }
 bool Strict_Policy::allow_tls12()  const { return true;  }
-bool Strict_Policy::allow_dtls10() const { return false; }
 bool Strict_Policy::allow_dtls12() const { return true;  }
 
 }
diff --git a/src/lib/tls/tls_policy.h b/src/lib/tls/tls_policy.h
index b53c08bb6..f06d68313 100644
--- a/src/lib/tls/tls_policy.h
+++ b/src/lib/tls/tls_policy.h
@@ -137,26 +137,11 @@ class BOTAN_PUBLIC_API(2,0) Policy
 
       virtual bool only_resume_with_exact_version() const;
 
-      /**
-      * Allow TLS v1.0
-      */
-      virtual bool allow_tls10() const;
-
-      /**
-      * Allow TLS v1.1
-      */
-      virtual bool allow_tls11() const;
-
       /**
       * Allow TLS v1.2
       */
       virtual bool allow_tls12() const;
 
-      /**
-      * Allow DTLS v1.0
-      */
-      virtual bool allow_dtls10() const;
-
       /**
       * Allow DTLS v1.2
       */
@@ -247,13 +232,6 @@ class BOTAN_PUBLIC_API(2,0) Policy
       */
       virtual Protocol_Version latest_supported_version(bool datagram) const;
 
-      /**
-      * When offering this version, should we send a fallback SCSV?
-      * Default returns true iff version is not the latest version the
-      * policy allows, exists to allow override in case of interop problems.
-      */
-      virtual bool send_fallback_scsv(Protocol_Version version) const;
-
       /**
       * Allows policy to reject any ciphersuites which are undesirable
       * for whatever reason without having to reimplement ciphersuite_list
@@ -371,10 +349,7 @@ class BOTAN_PUBLIC_API(2,0) NSA_Suite_B_128 : public Policy
 
       size_t minimum_signature_strength() const override { return 128; }
 
-      bool allow_tls10()  const override { return false; }
-      bool allow_tls11()  const override { return false; }
       bool allow_tls12()  const override { return true;  }
-      bool allow_dtls10() const override { return false; }
       bool allow_dtls12() const override { return false; }
    };
 
@@ -404,10 +379,7 @@ class BOTAN_PUBLIC_API(2,7) NSA_Suite_B_192 : public Policy
 
       size_t minimum_signature_strength() const override { return 192; }
 
-      bool allow_tls10()  const override { return false; }
-      bool allow_tls11()  const override { return false; }
       bool allow_tls12()  const override { return true;  }
-      bool allow_dtls10() const override { return false; }
       bool allow_dtls12() const override { return false; }
    };
 
@@ -467,10 +439,7 @@ class BOTAN_PUBLIC_API(2,0) BSI_TR_02102_2 : public Policy
       size_t minimum_ecdh_group_size() const override { return 250; }
       size_t minimum_ecdsa_group_size() const override { return 250; }
 
-      bool allow_tls10()  const override { return false; }
-      bool allow_tls11()  const override { return false; }
       bool allow_tls12()  const override { return true;  }
-      bool allow_dtls10() const override { return false; }
       bool allow_dtls12() const override { return false; }
    };
 
@@ -483,10 +452,7 @@ class BOTAN_PUBLIC_API(2,0) Datagram_Policy : public Policy
       std::vector<std::string> allowed_macs() const override
          { return std::vector<std::string>({"AEAD"}); }
 
-      bool allow_tls10()  const override { return false; }
-      bool allow_tls11()  const override { return false; }
       bool allow_tls12()  const override { return false; }
-      bool allow_dtls10() const override { return false; }
       bool allow_dtls12() const override { return true;  }
    };
 
@@ -508,10 +474,7 @@ class BOTAN_PUBLIC_API(2,0) Strict_Policy : public Policy
 
       std::vector<std::string> allowed_key_exchange_methods() const override;
 
-      bool allow_tls10()  const override;
-      bool allow_tls11()  const override;
       bool allow_tls12()  const override;
-      bool allow_dtls10() const override;
       bool allow_dtls12() const override;
    };
 
@@ -533,14 +496,8 @@ class BOTAN_PUBLIC_API(2,0) Text_Policy : public Policy
 
       bool use_ecc_point_compression() const override;
 
-      bool allow_tls10() const override;
-
-      bool allow_tls11() const override;
-
       bool allow_tls12() const override;
 
-      bool allow_dtls10() const override;
-
       bool allow_dtls12() const override;
 
       bool allow_insecure_renegotiation() const override;
@@ -580,8 +537,6 @@ class BOTAN_PUBLIC_API(2,0) Text_Policy : public Policy
 
       uint32_t session_ticket_lifetime() const override;
 
-      bool send_fallback_scsv(Protocol_Version version) const override;
-
       std::vector<uint16_t> srtp_profiles() const override;
 
       void set(const std::string& k, const std::string& v);
diff --git a/src/lib/tls/tls_server.cpp b/src/lib/tls/tls_server.cpp
index 27832e779..4d59aca71 100644
--- a/src/lib/tls/tls_server.cpp
+++ b/src/lib/tls/tls_server.cpp
@@ -200,43 +200,35 @@ uint16_t choose_ciphersuite(
             continue;
             }
 
-         if(version.supports_negotiable_signature_algorithms())
-            {
-            const std::vector<Signature_Scheme> client_sig_methods =
-               client_hello.signature_schemes();
+         const std::vector<Signature_Scheme> allowed =
+            policy.allowed_signature_schemes();
 
-            /*
-            If the vector is empty (eg because the client did not send the
-            extension), then the loop will fail to find a match and we will
-            reject with a handshake failure.
+         std::vector<Signature_Scheme> client_sig_methods =
+            client_hello.signature_schemes();
 
-            The TLS v1.2 logic said that a client not sending the extension implicitly
-            supported SHA-1 but with draft-ietf-tls-md5-sha1-deprecate instead we
-            are removing support for SHA-1 signatures entirely.
+         /*
+         Contrary to the wording of draft-ietf-tls-md5-sha1-deprecate we do
+         not enforce that clients do not offer support SHA-1 or MD5
+         signatures; we just ignore it.
+         */
+         bool we_support_some_hash_by_client = false;
 
-            Contrary to the wording of draft-ietf-tls-md5-sha1-deprecate we do
-            not enforce that clients do not offer support SHA-1 or MD5
-            signatures; we just ignore it.
-            */
-            bool we_support_some_hash_by_client = false;
+         for(Signature_Scheme scheme : client_sig_methods)
+            {
+            if(signature_scheme_is_known(scheme) == false)
+               continue;
 
-            for(Signature_Scheme scheme : client_sig_methods)
+            if(signature_algorithm_of_scheme(scheme) == suite.sig_algo() &&
+               policy.allowed_signature_hash(hash_function_of_scheme(scheme)))
                {
-               if(signature_scheme_is_known(scheme) == false)
-                  continue;
-
-               if(signature_algorithm_of_scheme(scheme) == suite.sig_algo() &&
-                  policy.allowed_signature_hash(hash_function_of_scheme(scheme)))
-                  {
-                  we_support_some_hash_by_client = true;
-                  }
+               we_support_some_hash_by_client = true;
                }
+            }
 
-            if(we_support_some_hash_by_client == false)
-               {
-               throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
-                                   "Policy does not accept any hash function supported by client");
-               }
+         if(we_support_some_hash_by_client == false)
+            {
+            throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
+                                "Policy does not accept any hash function supported by client");
             }
          }
 
@@ -322,7 +314,6 @@ namespace {
 Protocol_Version select_version(const Botan::TLS::Policy& policy,
                                 Protocol_Version client_offer,
                                 Protocol_Version active_version,
-                                bool is_fallback,
                                 const std::vector<Protocol_Version>& supported_versions)
    {
    const bool is_datagram = client_offer.is_datagram_protocol();
@@ -330,35 +321,18 @@ Protocol_Version select_version(const Botan::TLS::Policy& policy,
 
    const Protocol_Version latest_supported = policy.latest_supported_version(is_datagram);
 
-   if(is_fallback)
-      {
-      if(latest_supported > client_offer)
-         throw TLS_Exception(Alert::INAPPROPRIATE_FALLBACK,
-                              "Client signalled fallback SCSV, possible attack");
-      }
-
    if(supported_versions.size() > 0)
       {
       if(is_datagram)
          {
          if(policy.allow_dtls12() && value_exists(supported_versions, Protocol_Version(Protocol_Version::DTLS_V12)))
             return Protocol_Version::DTLS_V12;
-#if defined(BOTAN_HAS_TLS_V10)
-         if(policy.allow_dtls10() && value_exists(supported_versions, Protocol_Version(Protocol_Version::DTLS_V10)))
-            return Protocol_Version::DTLS_V10;
-#endif
          throw TLS_Exception(Alert::PROTOCOL_VERSION, "No shared DTLS version");
          }
       else
          {
          if(policy.allow_tls12() && value_exists(supported_versions, Protocol_Version(Protocol_Version::TLS_V12)))
             return Protocol_Version::TLS_V12;
-#if defined(BOTAN_HAS_TLS_V10)
-         if(policy.allow_tls11() && value_exists(supported_versions, Protocol_Version(Protocol_Version::TLS_V11)))
-            return Protocol_Version::TLS_V11;
-         if(policy.allow_tls10() && value_exists(supported_versions, Protocol_Version(Protocol_Version::TLS_V10)))
-            return Protocol_Version::TLS_V10;
-#endif
          throw TLS_Exception(Alert::PROTOCOL_VERSION, "No shared TLS version");
          }
       }
@@ -472,7 +446,6 @@ void Server::process_client_hello_msg(const Handshake_State* active_state,
    const Protocol_Version negotiated_version =
       select_version(policy(), client_offer,
                      active_state ? active_state->version() : Protocol_Version(),
-                     pending_state.client_hello()->sent_fallback_scsv(),
                      pending_state.client_hello()->supported_versions());
 
    pending_state.set_version(negotiated_version);
@@ -601,7 +574,7 @@ void Server::process_certificate_verify_msg(Server_Handshake_State& pending_stat
                                             Handshake_Type type,
                                             const std::vector<uint8_t>& contents)
    {
-   pending_state.client_verify(new Certificate_Verify(contents, pending_state.version()));
+   pending_state.client_verify(new Certificate_Verify(contents));
 
    const std::vector<X509_Certificate>& client_certs =
       pending_state.client_certs()->cert_chain();
@@ -956,8 +929,7 @@ void Server::session_create(Server_Handshake_State& pending_state,
          new Certificate_Req(pending_state.handshake_io(),
                              pending_state.hash(),
                              policy(),
-                             client_auth_CAs,
-                             pending_state.version()));
+                             client_auth_CAs));
 
       /*
       SSLv3 allowed clients to skip the Certificate message entirely
diff --git a/src/lib/tls/tls_session_key.cpp b/src/lib/tls/tls_session_key.cpp
index 206681041..1426f8f4c 100644
--- a/src/lib/tls/tls_session_key.cpp
+++ b/src/lib/tls/tls_session_key.cpp
@@ -53,8 +53,7 @@ Session_Keys::Session_Keys(const Handshake_State* state,
       if(extended_master_secret)
          {
          label.assign(EXT_MASTER_SECRET_MAGIC, EXT_MASTER_SECRET_MAGIC + sizeof(EXT_MASTER_SECRET_MAGIC));
-         salt += state->hash().final(state->version(),
-                                     state->ciphersuite().prf_algo());
+         salt += state->hash().final(state->ciphersuite().prf_algo());
          }
       else
          {
diff --git a/src/lib/tls/tls_text_policy.cpp b/src/lib/tls/tls_text_policy.cpp
index d04879a1b..675d74ca0 100644
--- a/src/lib/tls/tls_text_policy.cpp
+++ b/src/lib/tls/tls_text_policy.cpp
@@ -45,26 +45,11 @@ bool Text_Policy::use_ecc_point_compression() const
    return get_bool("use_ecc_point_compression", Policy::use_ecc_point_compression());
    }
 
-bool Text_Policy::allow_tls10() const
-   {
-   return get_bool("allow_tls10", Policy::allow_tls10());
-   }
-
-bool Text_Policy::allow_tls11() const
-   {
-   return get_bool("allow_tls11", Policy::allow_tls11());
-   }
-
 bool Text_Policy::allow_tls12() const
    {
    return get_bool("allow_tls12", Policy::allow_tls12());
    }
 
-bool Text_Policy::allow_dtls10() const
-   {
-   return get_bool("allow_dtls10", Policy::allow_dtls10());
-   }
-
 bool Text_Policy::allow_dtls12() const
    {
    return get_bool("allow_dtls12", Policy::allow_dtls12());
@@ -214,11 +199,6 @@ uint32_t Text_Policy::session_ticket_lifetime() const
    return static_cast<uint32_t>(get_len("session_ticket_lifetime", Policy::session_ticket_lifetime()));
    }
 
-bool Text_Policy::send_fallback_scsv(Protocol_Version version) const
-   {
-   return get_bool("send_fallback_scsv", false) ? Policy::send_fallback_scsv(version) : false;
-   }
-
 std::vector<uint16_t> Text_Policy::srtp_profiles() const
    {
    std::vector<uint16_t> r;
diff --git a/src/lib/tls/tls_version.cpp b/src/lib/tls/tls_version.cpp
index ecbe94897..40a9a83cf 100644
--- a/src/lib/tls/tls_version.cpp
+++ b/src/lib/tls/tls_version.cpp
@@ -50,39 +50,10 @@ bool Protocol_Version::operator>(const Protocol_Version& other) const
 
 bool Protocol_Version::known_version() const
    {
-   return (m_version == Protocol_Version::TLS_V10 ||
-           m_version == Protocol_Version::TLS_V11 ||
-           m_version == Protocol_Version::TLS_V12 ||
-           m_version == Protocol_Version::DTLS_V10 ||
+   return (m_version == Protocol_Version::TLS_V12 ||
            m_version == Protocol_Version::DTLS_V12);
    }
 
-bool Protocol_Version::supports_negotiable_signature_algorithms() const
-   {
-   return (m_version != Protocol_Version::TLS_V10 &&
-           m_version != Protocol_Version::TLS_V11 &&
-           m_version != Protocol_Version::DTLS_V10);
-   }
-
-bool Protocol_Version::supports_explicit_cbc_ivs() const
-   {
-   return (m_version != Protocol_Version::TLS_V10);
-   }
-
-bool Protocol_Version::supports_ciphersuite_specific_prf() const
-   {
-   return (m_version != Protocol_Version::TLS_V10 &&
-           m_version != Protocol_Version::TLS_V11 &&
-           m_version != Protocol_Version::DTLS_V10);
-   }
-
-bool Protocol_Version::supports_aead_modes() const
-   {
-   return (m_version != Protocol_Version::TLS_V10 &&
-           m_version != Protocol_Version::TLS_V11 &&
-           m_version != Protocol_Version::DTLS_V10);
-   }
-
 }
 
 }
diff --git a/src/lib/tls/tls_version.h b/src/lib/tls/tls_version.h
index 18e2c0f65..e116819a6 100644
--- a/src/lib/tls/tls_version.h
+++ b/src/lib/tls/tls_version.h
@@ -22,11 +22,7 @@ class BOTAN_PUBLIC_API(2,0) Protocol_Version final
    {
    public:
       enum Version_Code {
-         TLS_V10            = 0x0301,
-         TLS_V11            = 0x0302,
          TLS_V12            = 0x0303,
-
-         DTLS_V10           = 0xFEFF,
          DTLS_V12           = 0xFEFD
       };
 
@@ -98,23 +94,6 @@ class BOTAN_PUBLIC_API(2,0) Protocol_Version final
       */
       bool is_datagram_protocol() const;
 
-      /**
-      * @return true if this version supports negotiable signature algorithms
-      */
-      bool supports_negotiable_signature_algorithms() const;
-
-      /**
-      * @return true if this version uses explicit IVs for block ciphers
-      */
-      bool supports_explicit_cbc_ivs() const;
-
-      /**
-      * @return true if this version uses a ciphersuite specific PRF
-      */
-      bool supports_ciphersuite_specific_prf() const;
-
-      bool supports_aead_modes() const;
-
       /**
       * @return if this version is equal to other
       */


Test patch:
diff --git a/src/cli/timing_tests.cpp b/src/cli/timing_tests.cpp
index a9904ae2e..0e3cac4f5 100644
--- a/src/cli/timing_tests.cpp
+++ b/src/cli/timing_tests.cpp
@@ -206,7 +206,7 @@ class Lucky13_Timing_Test final : public Timing_Test
          , m_mac_keylen(mac_keylen)
          , m_dec(Botan::BlockCipher::create_or_throw("AES-128"),
                  Botan::MessageAuthenticationCode::create_or_throw("HMAC(" + m_mac_algo + ")"),
-                 16, m_mac_keylen, Botan::TLS::Protocol_Version::TLS_V11, false) {}
+                 16, m_mac_keylen, Botan::TLS::Protocol_Version::TLS_V12, false) {}
 
       std::vector<uint8_t> prepare_input(const std::string& input) override;
       ticks measure_critical_function(const std::vector<uint8_t>& input) override;
diff --git a/src/scripts/test_cli.py b/src/scripts/test_cli.py
index 94e4a907d..aa8fc3ec9 100755
--- a/src/scripts/test_cli.py
+++ b/src/scripts/test_cli.py
@@ -784,7 +784,7 @@ def cli_timing_test_tests(_tmp_dir):
 def cli_tls_ciphersuite_tests(_tmp_dir):
     policies = ['default', 'suiteb_128', 'suiteb_192', 'strict', 'all']
 
-    versions = ['tls1.0', 'tls1.1', 'tls1.2']
+    versions = ['tls1.2']
 
     ciphersuite_re = re.compile('^[A-Z0-9_]+$')
 
diff --git a/src/tests/data/tls/cert_verify.vec b/src/tests/data/tls/cert_verify.vec
index 335cb8353..b87972a68 100644
--- a/src/tests/data/tls/cert_verify.vec
+++ b/src/tests/data/tls/cert_verify.vec
@@ -6,35 +6,15 @@
 
 [cert_verify]
 Buffer = 06010080266481066a8431582157a9a591150d418b63d46154c4cd85bffcfdba8c7f6396f0ceb0402c2142c526a19659d58cd4111bf45f57a56e97d16eeecd350f6e9dc93662e4361053666e5a53c74fe11bd6cf86a9cf7a2488704c5121915820973280ed6afa3e8b79dfb799bddffb52caa2d1a0a895a0e7505d841a882bdd92ec9141
-Protocol = 0303
 Exception = 
 
-Buffer = 008080c920a228dc3f32927fd8026a97fb8474603191a89c49aeeddd1b1caf7f28d6af7b9b7c0bc6b954e909f3d054eb3964d626402b7c932c019111bc854007c90c134d6adce505e5cd60292331f7645fba909017565fc60ee76a5eb6b6a89ab2a3d69be6c0e283ae5a84b1fc367c1a865c35dd8a1c93ac3d538d91a2d5128d8d52
-Protocol = 0302
-Exception = 
-
-Buffer = 0080bb6b1df8c744f961ee3f5334448fac4af0f372763149972b88bec525a3196f87cf0204a50fd516b6808530252d1c6b79414b8b9194b3c5e2958adab5524bc124e16d9f3b05f5bf63c0b184709ce6586a0a4b267280b47576893406c381a401b10bcc5f111b14cd8ce889b5d48fbe47f465cf70bf23b71109f81d4574bbf6f93f
-Protocol = 0301
-Exception  =
-
 Buffer = 0601000100
-Protocol = 0303
 Exception = 
 
 #Incomplete algorithm
 Buffer = 06
-Protocol = 0303
 Exception = Invalid CertificateVerify: Expected 2 bytes remaining, only 1 left
 
 #Incomplete certificate
 Buffer = 0601000500
-Protocol = 0303
 Exception = Invalid CertificateVerify: Expected 5 bytes remaining, only 1 left
-
-Buffer = 000200
-Protocol = 0302
-Exception = Invalid CertificateVerify: Expected 2 bytes remaining, only 1 left
-
-Buffer = 000200
-Protocol = 0301
-Exception = Invalid CertificateVerify: Expected 2 bytes remaining, only 1 left
diff --git a/src/tests/test_tls.cpp b/src/tests/test_tls.cpp
index d9fd80d23..40dac7cf6 100644
--- a/src/tests/test_tls.cpp
+++ b/src/tests/test_tls.cpp
@@ -191,7 +191,7 @@ class TLS_CBC_Tests final : public Text_Based_Test
          Botan::TLS::TLS_CBC_HMAC_AEAD_Decryption tls_cbc(
             std::unique_ptr<Botan::BlockCipher>(new Noop_Block_Cipher(block_size)),
             std::unique_ptr<Botan::MessageAuthenticationCode>(new ZeroMac(mac_len)),
-            0, 0, Botan::TLS::Protocol_Version::TLS_V11, encrypt_then_mac);
+            0, 0, Botan::TLS::Protocol_Version::TLS_V12, encrypt_then_mac);
 
          tls_cbc.set_key(std::vector<uint8_t>(0));
          std::vector<uint8_t> ad(13);
diff --git a/src/tests/test_tls_messages.cpp b/src/tests/test_tls_messages.cpp
index faf4294b1..3e3c41465 100644
--- a/src/tests/test_tls_messages.cpp
+++ b/src/tests/test_tls_messages.cpp
@@ -67,8 +67,7 @@ class TLS_Message_Parsing_Test final : public Text_Based_Test
                {
                if(algo == "cert_verify")
                   {
-                  Botan::TLS::Protocol_Version pv(protocol[0], protocol[1]);
-                  Botan::TLS::Certificate_Verify message(buffer, pv);
+                  Botan::TLS::Certificate_Verify message(buffer);
                   }
                else if(algo == "client_hello")
                   {
@@ -150,10 +149,9 @@ class TLS_Message_Parsing_Test final : public Text_Based_Test
             {
             if(algo == "cert_verify")
                {
-               Botan::TLS::Protocol_Version pv(protocol[0], protocol[1]);
-               result.test_throws("invalid cert_verify input", exception, [&buffer, &pv]()
+               result.test_throws("invalid cert_verify input", exception, [&buffer]()
                   {
-                  Botan::TLS::Certificate_Verify message(buffer, pv);
+                  Botan::TLS::Certificate_Verify message(buffer);
                   });
                }
             else if(algo == "client_hello")
diff --git a/src/tests/unit_tls.cpp b/src/tests/unit_tls.cpp
index f9c466007..1e45a47d5 100644
--- a/src/tests/unit_tls.cpp
+++ b/src/tests/unit_tls.cpp
@@ -612,10 +612,6 @@ class Test_Policy final : public Botan::TLS::Text_Policy
          {
          return true;
          }
-      bool send_fallback_scsv(Botan::TLS::Protocol_Version) const override
-         {
-         return false;
-         }
 
       size_t dtls_initial_timeout() const override
          {
@@ -691,10 +687,7 @@ class TLS_Unit_Tests final : public Test
          policy.set("key_exchange_methods", kex_policy);
          policy.set("negotiate_encrypt_then_mac", etm_policy);
 
-         policy.set("allow_tls10", "true");
-         policy.set("allow_tls11", "true");
          policy.set("allow_tls12", "true");
-         policy.set("allow_dtls10", "true");
          policy.set("allow_dtls12", "true");
 
          if(kex_policy.find("RSA") != std::string::npos)
@@ -704,11 +697,6 @@ class TLS_Unit_Tests final : public Test
 
          std::vector<Botan::TLS::Protocol_Version> versions =
             {
-#if defined(BOTAN_HAS_TLS_V10)
-            Botan::TLS::Protocol_Version::TLS_V10,
-            Botan::TLS::Protocol_Version::TLS_V11,
-            Botan::TLS::Protocol_Version::DTLS_V10,
-#endif
             Botan::TLS::Protocol_Version::TLS_V12,
             Botan::TLS::Protocol_Version::DTLS_V12
             };
@@ -746,10 +734,7 @@ class TLS_Unit_Tests final : public Test
          policy.set("ciphers", cipher_policy);
          policy.set("macs", mac_policy);
          policy.set("key_exchange_methods", kex_policy);
-         policy.set("allow_tls10", "false");
-         policy.set("allow_tls11", "false");
          policy.set("allow_tls12", "true");
-         policy.set("allow_dtls10", "false");
          policy.set("allow_dtls12", "true");
 
          if(kex_policy.find("RSA") != std::string::npos)
@@ -1026,10 +1011,7 @@ class DTLS_Reconnection_Test : public Test
                std::vector<std::string> allowed_key_exchange_methods() const override
                   { return {"PSK"}; }
 
-               bool allow_tls10()  const override { return false; }
-               bool allow_tls11()  const override { return false; }
                bool allow_tls12()  const override { return false; }
-               bool allow_dtls10() const override { return false; }
                bool allow_dtls12() const override { return true;  }
 
                bool allow_dtls_epoch0_restart() const override { return true; }