/*
* (C) 2019 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

/*
* This is a shim for testing Botan against BoringSSL's test TLS stack (BoGo).
*
* Instructions on use should go here.
*/

#include <botan/tls_client.h>
#include <botan/tls_server.h>
#include <botan/tls_exceptn.h>
#include <botan/tls_algos.h>
#include <botan/data_src.h>
#include <botan/pkcs8.h>
#include <botan/loadstor.h>
#include <botan/oids.h>
#include <botan/chacha_rng.h>
#include <botan/base64.h>
#include <botan/hex.h>
#include <botan/parsing.h>
#include <botan/mem_ops.h>
#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <ctime>
#include <unordered_map>

#if defined(BOTAN_TARGET_OS_HAS_SOCKETS)
  #include <sys/socket.h>
  #include <sys/time.h>
  #include <netinet/in.h>
  #include <netdb.h>
  #include <string.h>
  #include <unistd.h>
  #include <errno.h>
  #include <fcntl.h>
#endif

namespace {

int shim_output(const std::string& s, int rc = 0)
   {
   std::cout << s << "\n";
   return rc;
   }

void shim_log(const std::string& s)
   {
   if(::getenv("BOTAN_BOGO_SHIM_LOG"))
      {
      static FILE* log = std::fopen("/tmp/bogo_shim.log", "w");
      struct timeval tv;
      ::gettimeofday(&tv, nullptr);
      std::fprintf(log, "%lld.%lu: %s\n", static_cast<unsigned long long>(tv.tv_sec), tv.tv_usec, s.c_str());
      std::fflush(log);
      }
   }

void BOTAN_NORETURN shim_exit_with_error(const std::string& s, int rc = 1)
   {
   shim_log("Exiting with " + s);
   std::cerr << s << "\n";
   std::exit(rc);
   }

std::string map_to_bogo_error(const std::string& e)
   {
   shim_log("Original error " + e);

   static const std::unordered_map<std::string, std::string> err_map
      {
         { "Application data before handshake done", ":APPLICATION_DATA_INSTEAD_OF_HANDSHAKE:" },
         { "Bad Hello_Request, has non-zero size", ":BAD_HELLO_REQUEST:" },
         { "Bad code for TLS alert level", ":UNKNOWN_ALERT_TYPE:" },
         { "Bad extension size", ":DECODE_ERROR:" },
         { "Bad length in hello verify request", ":DECODE_ERROR:" },
         { "Bad lengths in DTLS header", ":BAD_HANDSHAKE_RECORD:" },
         { "Bad signature on server key exchange", ":BAD_SIGNATURE:" },
         { "Bad size (1) for TLS alert message", ":BAD_ALERT:" },
         { "Bad size (4) for TLS alert message", ":BAD_ALERT:" },
         { "CERTIFICATE decoding failed with PEM: No PEM header found", ":CANNOT_PARSE_LEAF_CERT:" },
         { "Can't agree on a ciphersuite with client", ":NO_SHARED_CIPHER:" },
         { "Can't interleave application and handshake data", ":UNEXPECTED_RECORD:" },
         { "Certificate chain exceeds policy specified maximum size", ":EXCESSIVE_MESSAGE_SIZE:" },
         { "Certificate key type did not match ciphersuite", ":WRONG_CERTIFICATE_TYPE:" },
         { "Certificate usage constraints do not allow this ciphersuite", ":KEY_USAGE_BIT_INCORRECT:" },
         { "Certificate: Message malformed", ":DECODE_ERROR:" },
         { "Channel::key_material_export cannot export during renegotiation", "failed to export keying material" },
         { "Client cert verify failed", ":BAD_SIGNATURE:" },
         { "Client did not offer NULL compression", ":INVALID_COMPRESSION_LIST:" },
         { "Client offered TLS version with major version under 3", ":UNSUPPORTED_PROTOCOL:" },
         { "Client offered DTLS version with major version 0xFF",  ":UNSUPPORTED_PROTOCOL:" },
         { "Client policy prohibits insecure renegotiation", ":RENEGOTIATION_MISMATCH:" },
         { "Client policy prohibits renegotiation", ":NO_RENEGOTIATION:" },
         { "Client resumed extended ms session without sending extension", ":RESUMED_EMS_SESSION_WITHOUT_EMS_EXTENSION:" },
         { "Client signalled fallback SCSV, possible attack", ":INAPPROPRIATE_FALLBACK:" },
         { "Client version DTLS v1.0 is unacceptable by policy", ":UNSUPPORTED_PROTOCOL:" },
         { "Client version TLS v1.0 is unacceptable by policy", ":UNSUPPORTED_PROTOCOL:" },
         { "Client version TLS v1.1 is unacceptable by policy", ":UNSUPPORTED_PROTOCOL:" },
         { "Client: No certificates sent by server", ":DECODE_ERROR:" },
         { "Counterparty sent inconsistent key and sig types", ":WRONG_SIGNATURE_TYPE:" },
         { "Downgrade attack detected", ":TLS13_DOWNGRADE:" },
         { "Empty ALPN protocol not allowed", ":PARSE_TLSEXT:" },
         { "Encoding error: Cannot encode PSS string, output length too small", ":NO_COMMON_SIGNATURE_ALGORITHMS:" },
         { "Expected TLS but got a record with DTLS version", ":WRONG_VERSION_NUMBER:" },
         { "Finished message didn't verify", ":DIGEST_CHECK_FAILED:" },
         { "Got unexpected TLS record version", ":WRONG_VERSION_NUMBER:" },
         { "Inconsistent length in certificate request", ":DECODE_ERROR:" },
         { "Inconsistent values in fragmented DTLS handshake header", ":FRAGMENT_MISMATCH:" },
         { "Invalid CertificateRequest: Length field outside parameters", ":DECODE_ERROR:" },
         { "Invalid CertificateVerify: Extra bytes at end of message", ":DECODE_ERROR:" },
         { "Invalid Certificate_Status: invalid length field", ":DECODE_ERROR:" },
         { "Invalid ChangeCipherSpec", ":BAD_CHANGE_CIPHER_SPEC:" },
         { "Invalid ClientHello: Length field outside parameters", ":DECODE_ERROR:" },
         { "Invalid ClientKeyExchange: Extra bytes at end of message", ":DECODE_ERROR:" },
         { "Invalid ServerKeyExchange: Extra bytes at end of message", ":DECODE_ERROR:" },
         { "Invalid SessionTicket: Extra bytes at end of message", ":DECODE_ERROR:" },
         { "Invalid authentication tag: ChaCha20Poly1305 tag check failed", ":DECRYPTION_FAILED_OR_BAD_RECORD_MAC:" },
         { "Invalid authentication tag: GCM tag check failed", ":DECRYPTION_FAILED_OR_BAD_RECORD_MAC:" },
         { "Message authentication failure", ":DECRYPTION_FAILED_OR_BAD_RECORD_MAC:" },
         { "No shared TLS version", ":UNSUPPORTED_PROTOCOL:" },
         { "No shared DTLS version", ":UNSUPPORTED_PROTOCOL:" },
         { "OS2ECP: Unknown format type 251", ":BAD_ECPOINT:" },
         { "Policy forbids all available TLS version", ":NO_SUPPORTED_VERSIONS_ENABLED:" },
         { "Policy forbids all available DTLS version", ":NO_SUPPORTED_VERSIONS_ENABLED:" },
         { "Policy refuses to accept signing with any hash supported by peer", ":NO_COMMON_SIGNATURE_ALGORITHMS:" },
         { "Policy requires client send a certificate, but it did not", ":PEER_DID_NOT_RETURN_A_CERTIFICATE:" },
         { "Received a record that exceeds maximum size", ":ENCRYPTED_LENGTH_TOO_LONG:" },
         { "Received unexpected record version in initial record", ":WRONG_VERSION_NUMBER:" },
         { "Received unexpected record version", ":WRONG_VERSION_NUMBER:" },
         { "Received application data after connection closure", ":APPLICATION_DATA_ON_SHUTDOWN:" },
         { "Received handshake data after connection closure", ":NO_RENEGOTIATION:" },
         { "Server certificate changed during renegotiation", ":SERVER_CERT_CHANGED:" },
         { "Server changed its mind about extended master secret", ":RENEGOTIATION_EMS_MISMATCH:" },
         { "Server changed its mind about secure renegotiation", ":RENEGOTIATION_MISMATCH:" },
         { "Server changed version after renegotiation", ":WRONG_SSL_VERSION:" },
         { "Server downgraded version after renegotiation", ":WRONG_SSL_VERSION:" },
         { "Server policy prohibits renegotiation", ":NO_RENEGOTIATION:" },
         { "Server replied using a ciphersuite not allowed in version it offered", ":WRONG_CIPHER_RETURNED:" },
         { "Server replied with DTLS-SRTP alg we did not send", ":BAD_SRTP_PROTECTION_PROFILE_LIST:" },
         { "Server replied with ciphersuite we didn't send", ":WRONG_CIPHER_RETURNED:" },
         { "Server replied with later version than client offered", ":UNSUPPORTED_PROTOCOL:" },
         { "Server replied with non-null compression method", ":UNSUPPORTED_COMPRESSION_ALGORITHM:" },
         { "Server replied with some unknown ciphersuite", ":UNKNOWN_CIPHER_RETURNED:" },
         { "Server replied with unsupported extensions: 0", ":UNEXPECTED_EXTENSION:" },
         { "Server replied with unsupported extensions: 1234", ":UNEXPECTED_EXTENSION:" },
         { "Server replied with unsupported extensions: 16", ":UNEXPECTED_EXTENSION:" },
         { "Server replied with unsupported extensions: 43", ":UNEXPECTED_EXTENSION:" },
         { "Server replied with unsupported extensions: 5", ":UNEXPECTED_EXTENSION:" },
         { "Server resumed session and removed extended master secret", ":RESUMED_EMS_SESSION_WITHOUT_EMS_EXTENSION:" },
         { "Server resumed session but added extended master secret", ":RESUMED_NON_EMS_SESSION_WITH_EMS_EXTENSION:" },
         { "Server resumed session but with wrong version", ":OLD_SESSION_VERSION_NOT_RETURNED:" },
         { "Server sent ECC curve prohibited by policy", ":WRONG_CURVE:" },
         { "Server sent an unsupported extension", ":UNEXPECTED_EXTENSION:" },
         { "Server sent bad values for secure renegotiation", ":RENEGOTIATION_MISMATCH:" },
         { "Server version DTLS v1.0 is unacceptable by policy", ":UNSUPPORTED_PROTOCOL:" },
         { "Server version TLS v1.0 is unacceptable by policy", ":UNSUPPORTED_PROTOCOL:" },
         { "Server version TLS v1.1 is unacceptable by policy", ":UNSUPPORTED_PROTOCOL:" },
         { "Server_Hello_Done: Must be empty, and is not", ":DECODE_ERROR:" },
         { "Simulated OCSP callback failure", ":OCSP_CB_ERROR:" },
         { "Simulating cert verify callback failure", ":CERT_CB_ERROR:" },
         { "Simulating failure from OCSP response callback", ":OCSP_CB_ERROR:" },
         { "TLS plaintext record is larger than allowed maximum", ":DATA_LENGTH_TOO_LONG:" },
         { "TLS signature extension did not allow for RSA/SHA-256 signature", ":WRONG_SIGNATURE_TYPE:", },
         { "Test requires rejecting cert", ":CERTIFICATE_VERIFY_FAILED:" },
         { "Unexpected ALPN protocol", ":INVALID_ALPN_PROTOCOL:" },
         { "Unexpected record type 42 from counterparty", ":UNEXPECTED_RECORD:" },

         { "Unexpected state transition in handshake got a certificate_request expected server_hello_done seen server_hello+server_key_exchange", ":UNEXPECTED_MESSAGE:" },
         { "Unexpected state transition in handshake got a certificate_request expected server_key_exchange|server_hello_done seen server_hello", ":UNEXPECTED_MESSAGE:" },
         { "Unexpected state transition in handshake got a certificate_status expected certificate seen server_hello", ":UNEXPECTED_MESSAGE:" },
         { "Unexpected state transition in handshake got a change_cipher_spec expected certificate_verify seen client_hello+certificate+client_key_exchange", ":UNEXPECTED_RECORD:" },
         { "Unexpected state transition in handshake got a change_cipher_spec expected client_key_exchange seen client_hello", ":UNEXPECTED_RECORD:" },
         { "Unexpected state transition in handshake got a change_cipher_spec expected new_session_ticket seen server_hello+certificate+certificate_status+server_key_exchange+server_hello_done", ":UNEXPECTED_RECORD:" },
         { "Unexpected state transition in handshake got a client_key_exchange expected certificate seen client_hello", ":UNEXPECTED_MESSAGE:" },
         { "Unexpected state transition in handshake got a finished expected change_cipher_spec seen client_hello", ":UNEXPECTED_RECORD:" },
         { "Unexpected state transition in handshake got a finished expected change_cipher_spec seen client_hello+client_key_exchange", ":UNEXPECTED_RECORD:" },
         { "Unexpected state transition in handshake got a finished expected change_cipher_spec seen server_hello", ":UNEXPECTED_RECORD:" },
         { "Unexpected state transition in handshake got a finished expected change_cipher_spec seen server_hello+certificate+certificate_status+server_key_exchange+server_hello_done+new_session_ticket", ":UNEXPECTED_RECORD:" },
         { "Unexpected state transition in handshake got a hello_request expected server_hello", ":UNEXPECTED_MESSAGE:" },
         { "Unexpected state transition in handshake got a server_hello_done expected server_key_exchange seen server_hello+certificate+certificate_status", ":UNEXPECTED_MESSAGE:" },
         { "Unexpected state transition in handshake got a server_key_exchange not expecting messages", ":BAD_HELLO_REQUEST:" },
         { "Unexpected state transition in handshake got a server_key_exchange expected certificate_request|server_hello_done seen server_hello+certificate+certificate_status", ":UNEXPECTED_MESSAGE:" },

         { "Unknown TLS handshake message type 43", ":UNEXPECTED_MESSAGE:" },
         { "Unknown TLS handshake message type 44", ":UNEXPECTED_MESSAGE:" },
         { "Unknown TLS handshake message type 45", ":UNEXPECTED_MESSAGE:" },
         { "Unknown TLS handshake message type 46", ":UNEXPECTED_MESSAGE:" },
         { "Unknown TLS handshake message type 53", ":UNEXPECTED_MESSAGE:" },
         { "Unknown TLS handshake message type 54", ":UNEXPECTED_MESSAGE:" },
         { "Unknown TLS handshake message type 55", ":UNEXPECTED_MESSAGE:" },
         { "Unknown TLS handshake message type 56", ":UNEXPECTED_MESSAGE:" },
         { "Unknown TLS handshake message type 57", ":UNEXPECTED_MESSAGE:" },
         { "Unknown TLS handshake message type 58", ":UNEXPECTED_MESSAGE:" },
         { "Unknown TLS handshake message type 6", ":UNEXPECTED_MESSAGE:" },
         { "Unknown TLS handshake message type 62", ":UNEXPECTED_MESSAGE:" },
         { "Unknown TLS handshake message type 64", ":UNEXPECTED_MESSAGE:" },
         { "signature_algorithm_of_scheme: Unknown signature algorithm enum", ":WRONG_SIGNATURE_TYPE:" },
      };

   auto err_map_i = err_map.find(e);
   if(err_map_i != err_map.end())
      return err_map_i->second;

   return "Unmapped error: '" + e + "'";
   }

class Shim_Exception final : public std::exception
   {
   public:
      Shim_Exception(const std::string& msg, int rc = 1) :
         m_msg(msg), m_rc(rc) {}

      const char* what() const noexcept override { return m_msg.c_str(); }

      int rc() const { return m_rc; }
   private:
      const std::string m_msg;
      int m_rc;
   };

#if defined(BOTAN_TARGET_OS_HAS_SOCKETS)

class Shim_Socket final
   {
   private:
      typedef int socket_type;
      typedef ssize_t socket_op_ret_type;
      static void close_socket(socket_type s) { ::close(s); }
      static std::string get_last_socket_error() { return ::strerror(errno); }

   public:
      Shim_Socket(const std::string& hostname, int port) : m_socket(-1)
         {
         addrinfo hints;
         std::memset(&hints, 0, sizeof(hints));
         hints.ai_family = AF_UNSPEC;
         hints.ai_socktype = SOCK_STREAM;
         hints.ai_flags = AI_NUMERICSERV;
         addrinfo* res;

         const std::string service = std::to_string(port);
         int rc = ::getaddrinfo(hostname.c_str(), service.c_str(), &hints, &res);
         shim_log("Connecting " + hostname + ":" + service);

         if(rc != 0)
            {
            throw Shim_Exception("Name resolution failed for " + hostname);
            }

         for(addrinfo* rp = res; (m_socket == -1) && (rp != nullptr); rp = rp->ai_next)
            {
            if(rp->ai_family != AF_INET && rp->ai_family != AF_INET6)
               continue;

            m_socket = ::socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);

            if(m_socket == -1)
               {
               // unsupported socket type?
               continue;
               }

            int err = ::connect(m_socket, rp->ai_addr, rp->ai_addrlen);

            if(err != 0)
               {
               ::close(m_socket);
               m_socket = -1;
               }
            }

         if(m_socket < 0)
            throw Shim_Exception("Failed to connect to host");
         }

      ~Shim_Socket()
         {
         ::close(m_socket);
         m_socket = -1;
         }

      void write(const uint8_t buf[], size_t len)
         {
         if(m_socket < 0)
            throw Shim_Exception("Socket was bad on write");
         size_t sent_so_far = 0;
         while(sent_so_far != len)
            {
            const size_t left = len - sent_so_far;
            socket_op_ret_type sent = ::send(m_socket, Botan::cast_uint8_ptr_to_char(&buf[sent_so_far]), left, MSG_NOSIGNAL);
            if(sent < 0)
               {
               if(errno == EPIPE)
                  return;
               else
                  throw Shim_Exception("Socket write failed", errno);
               }
            else
               sent_so_far += static_cast<size_t>(sent);
            }
         }

      size_t read(uint8_t buf[], size_t len)
         {
         if(m_socket < 0)
            throw Shim_Exception("Socket was bad on read");
         socket_op_ret_type got = ::read(m_socket, Botan::cast_uint8_ptr_to_char(buf), len);

         if(got < 0)
            {
            if(errno == ECONNRESET)
               return 0;
            throw Shim_Exception("Socket read failed: " + std::string(strerror(errno)));
            }

         return static_cast<size_t>(got);
         }

      void read_exactly(uint8_t buf[], size_t len)
         {
         if(m_socket < 0)
            throw Shim_Exception("Socket was bad on read");

         while(len > 0)
            {
            socket_op_ret_type got = ::read(m_socket, Botan::cast_uint8_ptr_to_char(buf), len);

            if(got == 0)
               throw Shim_Exception("Socket read EOF");
            else if(got < 0)
               throw Shim_Exception("Socket read failed: " + std::string(strerror(errno)));

            buf += static_cast<size_t>(got);
            len -= static_cast<size_t>(got);
            }
         }

   private:
      socket_type m_socket;
   };

#endif

std::set<std::string> combine_options(
   const std::set<std::string>& a,
   const std::set<std::string>& b,
   const std::set<std::string>& c,
   const std::set<std::string>& d)
   {
   std::set<std::string> combined;

   for(auto i : a)
      combined.insert(i);
   for(auto i : b)
      combined.insert(i);
   for(auto i : c)
      combined.insert(i);
   for(auto i : d)
      combined.insert(i);

   return combined;
   }

class Shim_Arguments final
   {
   public:
      Shim_Arguments(const std::set<std::string>& flags,
                     const std::set<std::string>& string_opts,
                     const std::set<std::string>& base64_opts,
                     const std::set<std::string>& int_opts,
                     const std::set<std::string>& int_vec_opts) :
         m_flags(flags),
         m_string_opts(string_opts),
         m_base64_opts(base64_opts),
         m_int_opts(int_opts),
         m_int_vec_opts(int_vec_opts),
         m_all_options(combine_options(string_opts, base64_opts, int_opts, int_vec_opts))
         {}

      void parse_args(char* argv[]);

      bool flag_set(const std::string& flag) const
         {
         if(m_flags.count(flag) == 0)
            throw Shim_Exception("Unknown bool flag " + flag);

         return m_parsed_flags.count(flag);
         }

      std::string test_name() const
         {
         return get_string_opt("test-name");
         }

      std::string get_string_opt(const std::string& key) const
         {
         if(m_string_opts.count(key) == 0)
            throw Shim_Exception("Unknown string key " + key);
         return get_opt(key);
         }

      std::string get_string_opt_or_else(const std::string& key, const std::string& def) const
         {
         if(m_string_opts.count(key) == 0)
            throw Shim_Exception("Unknown string key " + key);
         if(!option_used(key))
            return def;
         return get_opt(key);
         }

      std::vector<uint8_t> get_b64_opt(const std::string& key) const
         {
         if(m_base64_opts.count(key) == 0)
            throw Shim_Exception("Unknown base64 key " + key);
         return Botan::unlock(Botan::base64_decode(get_opt(key)));
         }

      size_t get_int_opt(const std::string& key) const
         {
         if(m_int_opts.count(key) == 0)
            throw Shim_Exception("Unknown int key " + key);
         return Botan::to_u32bit(get_opt(key));
         }

      size_t get_int_opt_or_else(const std::string& key, size_t def) const
         {
         if(m_int_opts.count(key) == 0)
            throw Shim_Exception("Unknown int key " + key);
         if(!option_used(key))
            return def;

         return Botan::to_u32bit(get_opt(key));
         }

      std::vector<size_t> get_int_vec_opt(const std::string& key) const
         {
         if(m_int_vec_opts.count(key) == 0)
            throw Shim_Exception("Unknown int vec key " + key);

         auto i = m_parsed_int_vec_opts.find(key);
         if(i == m_parsed_int_vec_opts.end())
            return std::vector<size_t>();
         else
            return i->second;
         }

      std::vector<std::string> get_alpn_string_vec_opt(const std::string& option) const
         {
         // hack used for alpn list (relies on all ALPNs being 3 chars long...)
         char delim = 0x03;

         if(option_used(option))
            return Botan::split_on(get_string_opt(option), delim);
         else
            return std::vector<std::string>();
         }

      bool option_used(const std::string& key) const
         {
         if(m_all_options.count(key) == 0)
            throw Shim_Exception("Invalid option " + key);
         if(m_parsed_opts.find(key) != m_parsed_opts.end())
            return true;
         if(m_parsed_int_vec_opts.find(key) != m_parsed_int_vec_opts.end())
            return true;
         return false;
         }

   private:
      std::string get_opt(const std::string& key) const
         {
         auto i = m_parsed_opts.find(key);
         if(i == m_parsed_opts.end())
            throw Shim_Exception("Option " + key + " was not provided");
         return i->second;
         }

      const std::set<std::string> m_flags;
      const std::set<std::string> m_string_opts;
      const std::set<std::string> m_base64_opts;
      const std::set<std::string> m_int_opts;
      const std::set<std::string> m_int_vec_opts;
      const std::set<std::string> m_all_options;

      std::set<std::string> m_parsed_flags;
      std::map<std::string, std::string> m_parsed_opts;
      std::map<std::string, std::vector<size_t>> m_parsed_int_vec_opts;
   };

void Shim_Arguments::parse_args(char* argv[])
   {
   int i = 1; // skip argv[0]

   while(argv[i] != nullptr)
      {
      const std::string param(argv[i]);

      if(param.find("-") == 0)
         {
         const std::string flag_name = param.substr(1, std::string::npos);

         if(m_flags.count(flag_name))
            {
            shim_log("flag " + flag_name);
            m_parsed_flags.insert(flag_name);
            i += 1;
            }
         else if(m_all_options.count(flag_name))
            {
            if(argv[i+1] == nullptr)
               throw Shim_Exception("Expected argument following " + param);
            std::string val(argv[i+1]);
            shim_log("param " + flag_name + "=" + val);

            if(m_int_vec_opts.count(flag_name))
               {
               const size_t v = Botan::to_u32bit(val);
               m_parsed_int_vec_opts[flag_name].push_back(v);
               }
            else
               {
               m_parsed_opts[flag_name] = val;
               }
            i += 2;
            }
         else
            {
            shim_log("Unknown option " + param);
            throw Shim_Exception("Unknown option " + param, 89);
            }
         }
      else
         {
         shim_log("Unknown option " + param);
         throw Shim_Exception("Unknown option " + param, 89);
         }
      }
   }

std::unique_ptr<Shim_Arguments> parse_options(char* argv[])
   {
   const std::set<std::string> bogo_shim_flags = {
      "allow-false-start-without-alpn",
      "allow-unknown-alpn-protos",
      "async",
      "cbc-record-splitting",
      "check-close-notify",
      "decline-alpn",
      "decline-ocsp-callback",
      "dtls",
      "enable-all-curves",
      "enable-channel-id",
      "enable-early-data",
      "enable-ed25519",
      "enable-grease",
      "enable-ocsp-stapling",
      "enable-signed-cert-timestamps",
      "enforce-rsa-key-usage",
      //"expect-accept-early-data",
      "expect-extended-master-secret",
      "expect-no-offer-early-data",
      "expect-no-secure-renegotiation",
      "expect-no-session",
      "expect-no-session-id",
      //"expect-reject-early-data",
      "expect-secure-renegotiation",
      "expect-session-id",
      "expect-session-miss",
      "expect-sha256-client-cert",
      "expect-ticket-renewal",
      "expect-ticket-supports-early-data",
      //"expect-tls13-downgrade",
      "expect-verify-result",
      "expect-no-hrr",
      //"export-traffic-secrets",
      "fail-cert-callback",
      //"fail-ddos-callback",
      //"fail-early-callback",
      "fail-ocsp-callback",
      "fallback-scsv",
      //"false-start",
      "forbid-renegotiation-after-handshake",
      "handoff",
      "handshake-never-done",
      "handshake-twice",
      "handshaker-resume",
      //"ignore-tls13-downgrade",
      "implicit-handshake",
      "install-cert-compression-algs",
      "install-ddos-callback",
      "is-handshaker-supported",
      //"jdk11-workaround",
      //"key-update",
      "no-op-extra-handshake",
      "no-rsa-pss-rsae-certs",
      "no-ticket",
      "no-tls1",
      "no-tls11",
      "no-tls12",
      "no-tls13", // implict due to 1.3 not being implemented
      "on-resume-no-ticket",
      //"on-resume-verify-fail",
      //"partial-write",
      //"peek-then-read",
      //"read-with-unfinished-write",
      "renegotiate-freely",
      "renegotiate-ignore",
      "renegotiate-once",
      //"renew-ticket",
      "require-any-client-certificate",
      "retain-only-sha256-client-cert",
      //"reverify-on-resume",
      "select-empty-alpn",
      "send-alert",
      "server",
      "server-preference",
      "set-ocsp-in-callback",
      "shim-shuts-down",
      "shim-writes-first",
      //"tls-unique",
      "use-custom-verify-callback",
      "use-early-callback",
      "use-export-context",
      "use-exporter-between-reads",
      "use-ocsp-callback",
      //"use-old-client-cert-callback",
      //"use-ticket-callback",
      "verify-fail",
      "verify-peer",
      //"verify-peer-if-no-obc",
      "write-different-record-sizes",
   };

   const std::set<std::string> bogo_shim_string_opts = {
      "advertise-alpn",
      //"advertise-npn",
      "cert-file",
      "cipher",
      //"delegated-credential",
      "expect-advertised-alpn",
      "expect-alpn",
      "expect-client-ca-list",
      "expect-late-alpn",
      "expect-msg-callback",
      //"expect-next-proto",
      "expect-peer-cert-file",
      "expect-server-name",
      "export-context",
      "export-label",
      "handshaker-path",
      "host-name",
      "key-file",
      "psk",
      "psk-identity",
      "select-alpn",
      "select-next-proto",
      "srtp-profiles",
      "test-name",
      "use-client-ca-list",
      //"send-channel-id",
      //"write-settings",
   };

   const std::set<std::string> bogo_shim_base64_opts = {
      "expect-certificate-types",
      //"expect-channel-id",
      "expect-ocsp-response",
      //"expect-quic-transport-params",
      //"expect-signed-cert-timestamps",
      "ocsp-response",
      //"quic-transport-params",
      //"signed-cert-timestamps",
      //"ticket-key", /* we use a different ticket format from Boring */
      //"token-binding-params",
   };

   const std::set<std::string> bogo_shim_int_opts {
      "expect-cipher-aes",
      "expect-cipher-no-aes",
      "expect-curve-id",
      "expect-peer-signature-algorithm",
      "expect-ticket-age-skew",
      "expect-token-binding-param",
      "expect-total-renegotiations",
      "expect-version",
      //"export-early-keying-material",
      "export-keying-material",
      "initial-timeout-duration-ms",
      "max-cert-list",
      //"max-send-fragment",
      "max-version",
      "min-version",
      "mtu",
      "port",
      "read-size",
      "resume-count",
      "resumption-delay",
   };

   const std::set<std::string> bogo_shim_int_vec_opts {
      "curves",
      "expect-peer-verify-pref",
      "signing-prefs",
      "verify-prefs",
   };

   std::unique_ptr<Shim_Arguments> args(
      new Shim_Arguments(bogo_shim_flags,
                         bogo_shim_string_opts,
                         bogo_shim_base64_opts,
                         bogo_shim_int_opts,
                         bogo_shim_int_vec_opts));

   // may throw:
   args->parse_args(argv);

   return args;
   }

class Shim_Policy final : public Botan::TLS::Policy
   {
   public:
      Shim_Policy(const Shim_Arguments& args) : m_args(args), m_sessions(0) {}

      void incr_session_established() { m_sessions += 1; }

      std::vector<std::string> allowed_ciphers() const override
         {
         return {
            "AES-256/OCB(12)",
            "AES-128/OCB(12)",
            "ChaCha20Poly1305",
            "AES-256/GCM",
            "AES-128/GCM",
            "AES-256/CCM",
            "AES-128/CCM",
            "AES-256/CCM(8)",
            "AES-128/CCM(8)",
            "Camellia-256/GCM",
            "Camellia-128/GCM",
            "ARIA-256/GCM",
            "ARIA-128/GCM",
            "AES-256",
            "AES-128",
            "Camellia-256",
            "Camellia-128",
            "SEED",
            "3DES",
         };

         }

      std::vector<std::string> allowed_signature_hashes() const override
         {
         if(m_args.option_used("signing-prefs"))
            {
            std::vector<std::string> pref_hash;
            for(size_t pref : m_args.get_int_vec_opt("signing-prefs"))
               {
               const auto scheme = static_cast<Botan::TLS::Signature_Scheme>(pref);
               if(Botan::TLS::signature_scheme_is_known(scheme) == false)
                  continue;
               pref_hash.push_back(Botan::TLS::hash_function_of_scheme(scheme));
               }

            if(m_args.flag_set("server"))
               pref_hash.push_back("SHA-256");
            return pref_hash;
            }
         else
            {
            return { "SHA-512", "SHA-384", "SHA-256", "SHA-1" };
            }
         }

      //std::vector<std::string> allowed_macs() const override;

      std::vector<std::string> allowed_key_exchange_methods() const override
         {
         return {
            "ECDHE_PSK",
            "DHE_PSK",
            "PSK",
            "CECPQ1",
            "ECDH",
            "DH",
            "RSA",
         };
         }

      std::vector<std::string> allowed_signature_methods() const override
         {
         return {
            "ECDSA",
            "RSA",
            "IMPLICIT",
         };

         }

      std::vector<Botan::TLS::Signature_Scheme> allowed_signature_schemes() const override
         {
         if(m_args.option_used("signing-prefs"))
            {
            std::vector<Botan::TLS::Signature_Scheme> schemes;
            for(size_t pref : m_args.get_int_vec_opt("signing-prefs"))
               {
               schemes.push_back(static_cast<Botan::TLS::Signature_Scheme>(pref));
               }

            // BoGo gets sad if these are not included in our signature_algorithms extension
            if(!m_args.flag_set("server"))
               {
               schemes.push_back(Botan::TLS::Signature_Scheme::RSA_PKCS1_SHA256);
               schemes.push_back(Botan::TLS::Signature_Scheme::ECDSA_SHA256);
               }

            return schemes;
            }

         if(m_args.option_used("verify-prefs"))
            {
            std::vector<Botan::TLS::Signature_Scheme> schemes;
            for(size_t pref : m_args.get_int_vec_opt("verify-prefs"))
               {
               schemes.push_back(static_cast<Botan::TLS::Signature_Scheme>(pref));
               }

            return schemes;
            }

         return Botan::TLS::Policy::allowed_signature_schemes();
         }

      //size_t minimum_signature_strength() const override;

      //bool require_cert_revocation_info() const override;

      std::vector<Botan::TLS::Group_Params> key_exchange_groups() const override
         {
         if(m_args.option_used("curves"))
            {
            std::vector<Botan::TLS::Group_Params> groups;
            for(size_t pref : m_args.get_int_vec_opt("curves"))
               {
               groups.push_back(static_cast<Botan::TLS::Group_Params>(pref));
               }

            return groups;
            }

         return Botan::TLS::Policy::key_exchange_groups();
         }

      bool use_ecc_point_compression() const override { return false; } // BoGo expects this

      //Botan::TLS::Group_Params choose_key_exchange_group(const std::vector<Botan::TLS::Group_Params>& peer_groups) const override;

      bool require_client_certificate_authentication() const override
         {
         return m_args.flag_set("require-any-client-certificate");
         }

      bool request_client_certificate_authentication() const override
         {
         return m_args.flag_set("verify-peer") ||
            m_args.flag_set("fail-cert-callback") ||
            require_client_certificate_authentication();
         }

      bool allow_insecure_renegotiation() const override
         {
         if(m_args.flag_set("expect-no-secure-renegotiation"))
            return true;
         else
            return false;
         }

      //bool include_time_in_hello_random() const override;

      bool allow_client_initiated_renegotiation() const override
         {
         if(m_args.flag_set("renegotiate-freely"))
            return true;

         if(m_args.flag_set("renegotiate-once") && m_sessions <= 1)
            return true;

         return false;
         }

      bool allow_server_initiated_renegotiation() const override
         {
         return allow_client_initiated_renegotiation(); // same logic
         }

      bool allow_version(Botan::TLS::Protocol_Version version) const
         {
         if(m_args.option_used("min-version"))
            {
            const uint16_t min_version_16 = static_cast<uint16_t>(m_args.get_int_opt("min-version"));
            Botan::TLS::Protocol_Version min_version(min_version_16 >> 8, min_version_16 & 0xFF);
            if(min_version > version)
               return false;
            }

         if(m_args.option_used("max-version"))
            {
            const uint16_t max_version_16 = static_cast<uint16_t>(m_args.get_int_opt("max-version"));
            Botan::TLS::Protocol_Version max_version(max_version_16 >> 8, max_version_16 & 0xFF);
            if(version > max_version)
               return false;
            }

         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);
         }

      //Botan::TLS::Group_Params default_dh_group() const override;

      //size_t minimum_dh_group_size() const override;

      size_t minimum_ecdsa_group_size() const override { return 224; }

      size_t minimum_ecdh_group_size() const override { return 224; }

      //size_t minimum_rsa_bits() const override;

      //size_t minimum_dsa_group_size() const override;

      //void check_peer_key_acceptable(const Botan::Public_Key& public_key) const override;

      //bool hide_unknown_users() const override;

      //uint32_t session_ticket_lifetime() const override;

      std::vector<uint16_t> srtp_profiles() const override
         {
         if(m_args.option_used("srtp-profiles"))
            {
            std::string srtp = m_args.get_string_opt("srtp-profiles");

            if(srtp == "SRTP_AES128_CM_SHA1_80:SRTP_AES128_CM_SHA1_32")
               return {1,2};
            else if(srtp == "SRTP_AES128_CM_SHA1_80")
               return {1};
            else
               shim_exit_with_error("unknown srtp-profiles");
            }
         else
            return {};
         }

      bool only_resume_with_exact_version() const override
         {
         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;

      bool support_cert_status_message() const override
         {
         if(m_args.flag_set("server"))
            {
            if(!m_args.option_used("ocsp-response"))
               return false;
            if(m_args.flag_set("decline-ocsp-callback"))
               return false;
            }
         return true;
         }

      std::vector<uint16_t> ciphersuite_list(Botan::TLS::Protocol_Version version,
                                             bool have_srp) const override;

      size_t dtls_default_mtu() const override
         {
         return m_args.get_int_opt_or_else("mtu", 1500);
         }

      //size_t dtls_initial_timeout() const override;

      //size_t dtls_maximum_timeout() const override;

      bool allow_resumption_for_renegotiation() const override
         {
         return false; // BoGo expects this
         }

      bool abort_connection_on_undesired_renegotiation() const override
         {
         if(m_args.flag_set("renegotiate-ignore"))
            return false;
         else
            return true;
         }

      size_t maximum_certificate_chain_size() const override
         {
         return m_args.get_int_opt_or_else("max-cert-list", 0);
         }

   private:
      const Shim_Arguments& m_args;
      size_t m_sessions;
   };

std::vector<uint16_t> Shim_Policy::ciphersuite_list(Botan::TLS::Protocol_Version version,
                                                    bool have_srp) const
   {
   std::vector<uint16_t> ciphersuite_codes;

   const std::string cipher_limit = m_args.get_string_opt_or_else("cipher", "");
   if(cipher_limit == "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256:[TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384|TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256|TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA]:TLS_RSA_WITH_AES_128_GCM_SHA256:TLS_RSA_WITH_AES_128_CBC_SHA:[TLS_RSA_WITH_AES_256_GCM_SHA384|TLS_RSA_WITH_AES_256_CBC_SHA]")
      {
      std::vector<std::string> suites = {
         "ECDHE_RSA_WITH_AES_128_GCM_SHA256",
         "ECDHE_RSA_WITH_AES_256_GCM_SHA384",
         "ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256",
         "ECDHE_RSA_WITH_AES_256_CBC_SHA",
         "RSA_WITH_AES_256_GCM_SHA384",
         "RSA_WITH_AES_256_CBC_SHA",
      };

      for(auto suite_name : suites)
         {
         const auto suite = Botan::TLS::Ciphersuite::from_name(suite_name);
         if(suite.valid() == false)
            shim_exit_with_error("Bad ciphersuite name " + suite_name);
         ciphersuite_codes.push_back(suite.ciphersuite_code());
         }
      }
   else
      {
      // Hack: go in reverse order to avoid preferring 3DES
      auto ciphersuites = Botan::TLS::Ciphersuite::all_known_ciphersuites();
      for(auto i = ciphersuites.rbegin(); i != ciphersuites.rend(); ++i)
         {
         const auto suite = *i;
         // Can we use it?
         if(suite.valid() == false)
            continue;

         // Are we doing SRP?
         if(!have_srp && suite.kex_method() == Botan::TLS::Kex_Algo::SRP_SHA)
            continue;

         if(cipher_limit != "")
            {
            if(cipher_limit == "DEFAULT:!AES")
               {
               const std::string suite_algo = suite.cipher_algo();

               if(suite_algo == "AES-128" || suite_algo == "AES-256" ||
                  suite_algo == "AES-128/GCM" || suite_algo == "AES-256/GCM" ||
                  suite_algo == "AES-128/CCM" || suite_algo == "AES-256/CCM" ||
                  suite_algo == "AES-128/CCM(8)" || suite_algo == "AES-256/CCM(8)" ||
                  suite_algo == "AES-128/OCB(12)" || suite_algo == "AES-256/OCB(12)")
                  {
                  continue;
                  }
               }
            else
               {
               shim_exit_with_error("Unknown cipher " + cipher_limit);
               }
            }

         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());
         }
      }

   return ciphersuite_codes;
   }

class Shim_Credentials final : public Botan::Credentials_Manager
   {
   public:
      Shim_Credentials(const Shim_Arguments& args) : m_args(args)
         {
         m_psk_identity = m_args.get_string_opt_or_else("psk-identity", "");

         const std::string psk_str = m_args.get_string_opt_or_else("psk", "");
         m_psk = Botan::SymmetricKey(reinterpret_cast<const uint8_t*>(psk_str.data()), psk_str.size());

         if(m_args.option_used("key-file") && m_args.option_used("cert-file"))
            {
            Botan::DataSource_Stream key_stream(m_args.get_string_opt("key-file"));
            m_key = Botan::PKCS8::load_key(key_stream);

            Botan::DataSource_Stream cert_stream(m_args.get_string_opt("cert-file"));

            while(!cert_stream.end_of_data())
               {
               try
                  {
                  m_cert_chain.push_back(Botan::X509_Certificate(cert_stream));
                  }
               catch(...) {}
               }
            }
         }

      std::string psk_identity(const std::string& /*type*/,
                               const std::string& /*context*/,
                               const std::string& /*identity_hint*/) override
         {
         return m_psk_identity;
         }

      std::string psk_identity_hint(const std::string& /*type*/,
                                    const std::string& /*context*/) override
         {
         return m_psk_identity;
         }

      Botan::SymmetricKey psk(const std::string& type,
                              const std::string& context,
                              const std::string& identity) override
         {
         if(type == "tls-server" && context == "session-ticket")
            {
            if(!m_args.flag_set("no-ticket") && !m_args.flag_set("on-resume-no-ticket"))
               return Botan::SymmetricKey("ABCDEF0123456789");
            }

         if(type == "tls-server" && context == "dtls-cookie-secret")
            {
            return Botan::SymmetricKey("F00FB00FD00F100F700F");
            }

         if(identity != m_psk_identity)
            throw Shim_Exception("Unexpected PSK identity");
         return m_psk;
         }

      std::vector<Botan::X509_Certificate> cert_chain(
         const std::vector<std::string>& cert_key_types,
         const std::string& /*type*/,
         const std::string& /*context*/) override
         {
         if(m_args.flag_set("fail-cert-callback"))
            throw std::runtime_error("Simulating cert verify callback failure");

         if(m_key != nullptr && m_cert_chain.size() > 0)
            {
            for(std::string t : cert_key_types)
               {
               if(t == m_key->algo_name())
                  return m_cert_chain;
               }
            }

         return {};
         }

      Botan::Private_Key* private_key_for(const Botan::X509_Certificate& /*cert*/,
                                          const std::string& /*type*/,
                                          const std::string& /*context*/) override
         {
         // assumes cert == m_cert
         return m_key.get();
         }

   private:
      const Shim_Arguments& m_args;
      Botan::SymmetricKey m_psk;
      std::string m_psk_identity;
      std::unique_ptr<Botan::Private_Key> m_key;
      std::vector<Botan::X509_Certificate> m_cert_chain;
   };

class Shim_Callbacks final : public Botan::TLS::Callbacks
   {
   public:
      Shim_Callbacks(const Shim_Arguments& args, Shim_Socket& socket, Shim_Policy& policy) :
         m_channel(nullptr),
         m_args(args),
         m_policy(policy),
         m_socket(socket),
         m_is_datagram(args.flag_set("dtls")),
         m_warning_alerts(0),
         m_empty_records(0),
         m_sessions_established(0),
         m_got_close(false)
         {}

      size_t sessions_established() const { return m_sessions_established; }

      void set_channel(Botan::TLS::Channel* channel)
         {
         m_channel = channel;
         }

      bool saw_close_notify() const { return m_got_close; }

      void tls_emit_data(const uint8_t data[], size_t size) override
         {
         shim_log("sending record of len " + std::to_string(size));

         if(m_is_datagram)
            {
            std::vector<uint8_t> packet(size + 5);

            packet[0] = 'P';
            for(size_t i = 0; i != 4; ++i)
               packet[i+1] = static_cast<uint8_t>((size >> (24-8*i)) & 0xFF);
            std::memcpy(packet.data() + 5, data, size);

            m_socket.write(packet.data(), packet.size());
            }
         else
            {
            m_socket.write(data, size);
            }
         }

      std::vector<uint8_t> tls_provide_cert_status(const std::vector<Botan::X509_Certificate>&,
                                                   const Botan::TLS::Certificate_Status_Request&) override
          {
          if(m_args.flag_set("use-ocsp-callback") && m_args.flag_set("fail-ocsp-callback"))
             throw std::runtime_error("Simulating failure from OCSP response callback");

          if(m_args.flag_set("decline-ocsp-callback"))
             return {};

          if(m_args.option_used("ocsp-response"))
             {
             return m_args.get_b64_opt("ocsp-response");
             }

          return {};
          }

      void tls_record_received(uint64_t /*seq_no*/, const uint8_t data[], size_t size) override
         {
         if(size == 0)
            {
            m_empty_records += 1;
            if(m_empty_records > 32)
               shim_exit_with_error(":TOO_MANY_EMPTY_FRAGMENTS:");
            }
         else
            {
            m_empty_records = 0;
            }

         shim_log("Reflecting application_data len " + std::to_string(size));

         std::vector<uint8_t> buf(data, data + size);
         for(size_t i = 0; i != size; ++i)
            buf[i] ^= 0xFF;

         m_channel->send(buf);
         }

      bool tls_verify_message(const Botan::Public_Key& key,
                              const std::string& emsa,
                              Botan::Signature_Format format,
                              const std::vector<uint8_t>& msg,
                              const std::vector<uint8_t>& sig) override
         {
         if(m_args.option_used("expect-peer-signature-algorithm"))
            {
            const auto scheme = static_cast<Botan::TLS::Signature_Scheme>(m_args.get_int_opt("expect-peer-signature-algorithm"));
            if(scheme != Botan::TLS::Signature_Scheme::NONE)
               {
               const std::string exp_emsa = Botan::TLS::padding_string_for_scheme(scheme);
               if(emsa != exp_emsa)
                  shim_exit_with_error("Unexpected signature scheme got " + emsa + " expected " + exp_emsa);
               }
            }
         return Botan::TLS::Callbacks::tls_verify_message(key, emsa, format, msg, sig);
         }

      void tls_verify_cert_chain(const std::vector<Botan::X509_Certificate>& /*cert_chain*/,
                                 const std::vector<std::shared_ptr<const Botan::OCSP::Response>>& /*ocsp_responses*/,
                                 const std::vector<Botan::Certificate_Store*>& /*trusted_roots*/,
                                 Botan::Usage_Type /*usage*/,
                                 const std::string& /*hostname*/,
                                 const Botan::TLS::Policy& /*policy*/) override
         {
         if(m_args.flag_set("enable-ocsp-stapling") &&
            m_args.flag_set("use-ocsp-callback") &&
            m_args.flag_set("fail-ocsp-callback"))
            {
            throw Botan::TLS::TLS_Exception(Botan::TLS::Alert::BAD_CERTIFICATE_STATUS_RESPONSE,
                                            "Simulated OCSP callback failure");
            }

         if(m_args.flag_set("verify-peer") && m_args.flag_set("verify-fail"))
            {
            throw Botan::TLS::TLS_Exception(Botan::TLS::Alert::BAD_CERTIFICATE,
                                            "Test requires rejecting cert");
            }
         }

      std::string tls_server_choose_app_protocol(const std::vector<std::string>& client_protos) override
         {
         if(client_protos.empty())
            return ""; // shouldn't happen?

         if(m_args.flag_set("decline-alpn"))
            return "";

         if(m_args.option_used("expect-advertised-alpn"))
            {
            const std::vector<std::string> expected = m_args.get_alpn_string_vec_opt("expect-advertised-alpn");

            if(client_protos != expected)
               shim_exit_with_error("Bad ALPN from client");
            }

         if(m_args.option_used("select-alpn"))
            return m_args.get_string_opt("select-alpn");

         return client_protos[0]; // if not configured just pick something
         }

      void tls_alert(Botan::TLS::Alert alert) override
         {
         if(alert.is_fatal())
            shim_log("Got a fatal alert " + alert.type_string());
         else
            shim_log("Got a warning alert " + alert.type_string());

         if(alert.type() == Botan::TLS::Alert::RECORD_OVERFLOW)
            {
            shim_exit_with_error(":TLSV1_ALERT_RECORD_OVERFLOW:");
            }

         if(alert.type() == Botan::TLS::Alert::DECOMPRESSION_FAILURE)
            {
            shim_exit_with_error(":SSLV3_ALERT_DECOMPRESSION_FAILURE:");
            }

         if(!alert.is_fatal())
            {
            m_warning_alerts++;
            if(m_warning_alerts > 5)
               shim_exit_with_error(":TOO_MANY_WARNING_ALERTS:");
            }

         if(alert.type() == Botan::TLS::Alert::CLOSE_NOTIFY)
            {
            if(m_got_close == false && !m_args.flag_set("shim-shuts-down"))
               {
               shim_log("Sending return close notify");
               m_channel->send_alert(alert);
               }
            m_got_close = true;
            }
         else if(alert.is_fatal())
            {
            shim_exit_with_error("Unexpected fatal alert " + alert.type_string());
            }
         }

      bool tls_session_established(const Botan::TLS::Session& session) override
         {
         shim_log("Session established: " + Botan::hex_encode(session.session_id()) +
                  " version " + session.version().to_string() +
                  " cipher " + session.ciphersuite().to_string() +
                  " EMS " + std::to_string(session.supports_extended_master_secret()));
         // probably need tests here?

         m_policy.incr_session_established();
         m_sessions_established++;

         if(m_args.flag_set("expect-no-session-id"))
            {
            // BoGo expects that ticket issuance implies no stateful session...
            if(!m_args.flag_set("server") && session.session_id().size() > 0)
               shim_exit_with_error("Unexpectedly got a session ID");
            }
         else if(m_args.flag_set("expect-session-id"))
            {
            if(session.session_id().empty())
               shim_exit_with_error("Unexpectedly got no session ID");
            }

         if(m_args.option_used("expect-version"))
            {
            if(session.version().version_code() != m_args.get_int_opt("expect-version"))
               shim_exit_with_error("Unexpected version");
            }

         if(m_args.flag_set("expect-secure-renegotiation"))
            {
            if(m_channel->secure_renegotiation_supported() == false)
               shim_exit_with_error("Expected secure renegotiation");
            }
         else if(m_args.flag_set("expect-no-secure-renegotiation"))
            {
            if(m_channel->secure_renegotiation_supported() == true)
               shim_exit_with_error("Expected no secure renegotation");
            }

         if(m_args.flag_set("expect-extended-master-secret"))
            {
            if(session.supports_extended_master_secret() == false)
               shim_exit_with_error("Expected extended maseter secret");
            }

         return true;
         }

      void tls_session_activated() override
         {
         if(m_args.flag_set("send-alert"))
            {
            m_channel->send_fatal_alert(Botan::TLS::Alert::DECOMPRESSION_FAILURE);
            return;
            }

         if(size_t length = m_args.get_int_opt_or_else("export-keying-material", 0))
            {
            const std::string label = m_args.get_string_opt("export-label");
            const std::string context = m_args.get_string_opt("export-context");
            const auto exported = m_channel->key_material_export(label, context, length);
            shim_log("Sending " + std::to_string(length) + " bytes of key material");
            m_channel->send(exported.bits_of());
            }

         const std::string alpn = m_channel->application_protocol();

         if(m_args.option_used("expect-alpn"))
            {
            if(alpn != m_args.get_string_opt("expect-alpn"))
               shim_exit_with_error("Got unexpected ALPN");
            }

         if(alpn == "baz" && !m_args.flag_set("allow-unknown-alpn-protos"))
            {
            throw Botan::TLS::TLS_Exception(Botan::TLS::Alert::ILLEGAL_PARAMETER,
                                            "Unexpected ALPN protocol");
            }

         if(m_args.flag_set("shim-shuts-down"))
            {
            shim_log("Shim shutting down");
            m_channel->close();
            }

         if(m_args.flag_set("write-different-record-sizes"))
            {
            static const size_t record_sizes[] = {
               0, 1, 255, 256, 257, 16383, 16384, 16385, 32767, 32768, 32769
            };

            std::vector<uint8_t> buf(32769, 0x42);

            for(size_t sz : record_sizes)
               {
               m_channel->send(buf.data(), sz);
               }

            m_channel->close();
            }
         }

   private:
      Botan::TLS::Channel* m_channel;
      const Shim_Arguments& m_args;
      Shim_Policy& m_policy;
      Shim_Socket& m_socket;
      const bool m_is_datagram;
      size_t m_warning_alerts;
      size_t m_empty_records;
      size_t m_sessions_established;
      bool m_got_close;
   };

}

int main(int /*argc*/, char* argv[])
   {
   try
      {
      std::unique_ptr<Shim_Arguments> args = parse_options(argv);

      if(args->flag_set("is-handshaker-supported"))
         {
         return shim_output("No\n");
         }

      const uint16_t port = static_cast<uint16_t>(args->get_int_opt("port"));
      const size_t resume_count = args->get_int_opt_or_else("resume-count", 0);
      const bool is_server = args->flag_set("server");
      const bool is_datagram = args->flag_set("dtls");

      const size_t buf_size = args->get_int_opt_or_else("read-size", 18*1024);

      Botan::ChaCha_RNG rng(Botan::secure_vector<uint8_t>(64));
      Botan::TLS::Session_Manager_In_Memory session_manager(rng, 1024);
      Shim_Credentials creds(*args);

      for(size_t i = 0; i != resume_count+1; ++i)
         {
         Shim_Socket socket("localhost", port);

         shim_log("Connection " + std::to_string(i+1) + "/" + std::to_string(resume_count+1));

         Shim_Policy policy(*args);
         Shim_Callbacks callbacks(*args, socket, policy);

         std::unique_ptr<Botan::TLS::Channel> chan;

         if(is_server)
            {
            chan.reset(new Botan::TLS::Server(callbacks, session_manager, creds, policy, rng, is_datagram));
            }
         else
            {
            Botan::TLS::Protocol_Version offer_version = policy.latest_supported_version(is_datagram);
            shim_log("Offering " + offer_version.to_string());

            std::string host_name = args->get_string_opt_or_else("host-name", "localhost");
            if(args->test_name().find("UnsolicitedServerNameAck-TLS1") == 0)
               host_name = ""; // avoid sending SNI for this test

            Botan::TLS::Server_Information server_info(host_name, port);
            const std::vector<std::string> next_protocols = args->get_alpn_string_vec_opt("advertise-alpn");
            chan.reset(new Botan::TLS::Client(callbacks, session_manager, creds, policy, rng,
                                              server_info, offer_version, next_protocols));
            }

         callbacks.set_channel(chan.get());

         std::vector<uint8_t> buf(buf_size);

         for(;;)
            {
            if(is_datagram)
               {
               uint8_t opcode;
               size_t got = socket.read(&opcode, 1);
               if(got == 0)
                  {
                  shim_log("EOF on socket");
                  break;
                  }

               if(opcode == 'P')
                  {
                  uint8_t len_bytes[4];
                  socket.read_exactly(len_bytes, sizeof(len_bytes));

                  size_t packet_len = Botan::load_be<uint32_t>(len_bytes, 0);

                  if(buf.size() < packet_len)
                     buf.resize(packet_len);
                  socket.read_exactly(buf.data(), packet_len);

                  chan->received_data(buf.data(), packet_len);
                  }
               else if(opcode == 'T')
                  {
                  uint8_t timeout_ack = 't';

                  uint8_t timeout_bytes[8];
                  socket.read_exactly(timeout_bytes, sizeof(timeout_bytes));

                  const uint64_t nsec = Botan::load_be<uint64_t>(timeout_bytes, 0);

                  shim_log("Timeout nsec " + std::to_string(nsec));

                  // FIXME handle this!

                  socket.write(&timeout_ack, 1); // ack it anyway
                  }
               else
                  shim_exit_with_error("Unknown opcode " + std::to_string(opcode));
               }
            else
               {
               size_t got = socket.read(buf.data(), buf.size());
               if(got == 0)
                  {
                  shim_log("EOF on socket");
                  break;
                  }

               shim_log("Got packet of " + std::to_string(got));

               if(args->flag_set("use-exporter-between-reads") && chan->is_active())
                  {
                  chan->key_material_export("some label", "some context", 42);
                  }
               const size_t needed = chan->received_data(buf.data(), got);

               if(needed)
                  shim_log("Short read still need " + std::to_string(needed));
               }
            }

         if(args->flag_set("check-close-notify"))
            {
            if(!callbacks.saw_close_notify())
               throw Shim_Exception("Unexpected SSL_shutdown result: -1 != 1");
            }

         if(args->option_used("expect-total-renegotiations"))
            {
            const size_t exp = args->get_int_opt("expect-total-renegotiations");

            if(exp != callbacks.sessions_established() - 1)
               throw Shim_Exception("Unexpected number of renegotiations: saw " +
                                    std::to_string(callbacks.sessions_established() - 1) +
                                    " exp " + std::to_string(exp));
            }
         shim_log("End of resume loop");
         }

      }
   catch(Shim_Exception& e)
      {
      shim_exit_with_error(e.what(), e.rc());
      }
   catch(std::exception& e)
      {
      shim_exit_with_error(map_to_bogo_error(e.what()));
      }
   catch(...)
      {
      shim_exit_with_error("Unknown exception", 3);
      }
   return 0;
   }
