diff options
Diffstat (limited to 'src/cmd')
| -rw-r--r-- | src/cmd/tls_proxy.cpp | 592 | ||||
| -rw-r--r-- | src/cmd/tls_server_asio.cpp | 326 |
2 files changed, 592 insertions, 326 deletions
diff --git a/src/cmd/tls_proxy.cpp b/src/cmd/tls_proxy.cpp new file mode 100644 index 000000000..867e2280e --- /dev/null +++ b/src/cmd/tls_proxy.cpp @@ -0,0 +1,592 @@ +/* +* TLS Server Proxy +* (C) 2014,2015 Jack Lloyd +* +* Botan is released under the Simplified BSD License (see license.txt) +*/ + +#include "apps.h" + +#if defined(BOTAN_HAS_TLS) + +#include <iostream> +#include <string> +#include <vector> +#include <thread> + +#define _GLIBCXX_HAVE_GTHR_DEFAULT +#include <boost/asio.hpp> +#include <boost/bind.hpp> +#include <boost/shared_ptr.hpp> +#include <boost/enable_shared_from_this.hpp> + +#include <botan/tls_server.h> +#include <botan/x509cert.h> +#include <botan/pkcs8.h> +#include <botan/auto_rng.h> + +#if defined(BOTAN_HAS_TLS_SQLITE3_SESSION_MANAGER) + #include <botan/tls_session_manager_sqlite.h> +#endif + +using boost::asio::ip::tcp; + +namespace Botan { + +namespace { + +void log_exception(const char* where, const std::exception& e) + { + std::cout << where << ' ' << e.what() << std::endl; + } + +void log_error(const char* where, const boost::system::error_code& error) + { + std::cout << where << ' ' << error.message() << std::endl; + } + +void log_binary_message(const char* where, const byte buf[], size_t buf_len) + { + //std::cout << where << ' ' << hex_encode(buf, buf_len) << std::endl; + } + +void log_text_message(const char* where, const byte buf[], size_t buf_len) + { + //const char* c = reinterpret_cast<const char*>(buf); + //std::cout << where << ' ' << std::string(c, c + buf_len) << std::endl; + } + +class tls_proxy_session : public boost::enable_shared_from_this<tls_proxy_session> + { + public: + enum { readbuf_size = 4 * 1024 }; + + typedef boost::shared_ptr<tls_proxy_session> pointer; + + static pointer create(boost::asio::io_service& io, + TLS::Session_Manager& session_manager, + Credentials_Manager& credentials, + TLS::Policy& policy, + RandomNumberGenerator& rng, + tcp::resolver::iterator endpoints) + { + return pointer( + new tls_proxy_session( + io, + session_manager, + credentials, + policy, + rng, + endpoints) + ); + } + + tcp::socket& client_socket() { return m_client_socket; } + + void start() + { + m_c2p.resize(readbuf_size); + + client_read(boost::system::error_code(), 0); // start read loop + } + + void stop() { m_client_socket.close(); } + + private: + tls_proxy_session(boost::asio::io_service& io, + TLS::Session_Manager& session_manager, + Credentials_Manager& credentials, + TLS::Policy& policy, + RandomNumberGenerator& rng, + tcp::resolver::iterator endpoints) : + m_strand(io), + m_server_endpoints(endpoints), + m_client_socket(io), + m_server_socket(io), + m_tls(boost::bind(&tls_proxy_session::tls_proxy_write_to_client, this, _1, _2), + boost::bind(&tls_proxy_session::tls_client_write_to_proxy, this, _1, _2), + boost::bind(&tls_proxy_session::tls_alert_cb, this, _1, _2, _3), + boost::bind(&tls_proxy_session::tls_handshake_complete, this, _1), + session_manager, + credentials, + policy, + rng) + { + } + + void client_read(const boost::system::error_code& error, + size_t bytes_transferred) + { + if(error) + { + log_error("Read failed", error); + stop(); + return; + } + + try + { + if(!m_tls.is_active()) + log_binary_message("From client", &m_c2p[0], bytes_transferred); + m_tls.received_data(&m_c2p[0], bytes_transferred); + } + catch(std::exception& e) + { + log_exception("TLS connection failed", e); + stop(); + return; + } + + m_client_socket.async_read_some( + boost::asio::buffer(&m_c2p[0], m_c2p.size()), + m_strand.wrap(boost::bind(&tls_proxy_session::client_read, shared_from_this(), + boost::asio::placeholders::error, + boost::asio::placeholders::bytes_transferred))); + } + + void handle_client_write_completion(const boost::system::error_code& error) + { + if(error) + { + log_error("Client write", error); + stop(); + return; + } + + m_p2c.clear(); + tls_proxy_write_to_client(nullptr, 0); // initiate another write if needed + } + + void handle_server_write_completion(const boost::system::error_code& error) + { + if(error) + { + log_error("Server write", error); + stop(); + return; + } + + m_p2s.clear(); + tls_proxy_write_to_server(nullptr, 0); // initiate another write if needed + } + + void tls_client_write_to_proxy(const byte buf[], size_t buf_len) + { + tls_proxy_write_to_server(buf, buf_len); + } + + void tls_proxy_write_to_client(const byte buf[], size_t buf_len) + { + if(buf_len > 0) + m_p2c_pending.insert(m_p2c_pending.end(), buf, buf + buf_len); + + // no write now active and we still have output pending + if(m_p2c.empty() && !m_p2c_pending.empty()) + { + std::swap(m_p2c_pending, m_p2c); + + //log_binary_message("To Client", &m_p2c[0], m_p2c.size()); + + boost::asio::async_write( + m_client_socket, + boost::asio::buffer(&m_p2c[0], m_p2c.size()), + m_strand.wrap(boost::bind( + &tls_proxy_session::handle_client_write_completion, + shared_from_this(), + boost::asio::placeholders::error))); + } + } + + void tls_proxy_write_to_server(const byte buf[], size_t buf_len) + { + if(buf_len > 0) + m_p2s_pending.insert(m_p2s_pending.end(), buf, buf + buf_len); + + // no write now active and we still have output pending + if(m_p2s.empty() && !m_p2s_pending.empty()) + { + std::swap(m_p2s_pending, m_p2s); + + log_text_message("To Server", &m_p2s[0], m_p2s.size()); + + boost::asio::async_write( + m_server_socket, + boost::asio::buffer(&m_p2s[0], m_p2s.size()), + m_strand.wrap(boost::bind( + &tls_proxy_session::handle_server_write_completion, + shared_from_this(), + boost::asio::placeholders::error))); + } + } + + void server_read(const boost::system::error_code& error, + size_t bytes_transferred) + { + if(error) + { + log_error("Server read failed", error); + stop(); + return; + } + + try + { + if(bytes_transferred) + { + log_text_message("Server to client", &m_s2p[0], m_s2p.size()); + log_binary_message("Server to client", &m_s2p[0], m_s2p.size()); + m_tls.send(&m_s2p[0], bytes_transferred); + } + } + catch(std::exception& e) + { + log_exception("TLS connection failed", e); + stop(); + return; + } + + m_s2p.resize(readbuf_size); + + m_server_socket.async_read_some( + boost::asio::buffer(&m_s2p[0], m_s2p.size()), + m_strand.wrap(boost::bind(&tls_proxy_session::server_read, shared_from_this(), + boost::asio::placeholders::error, + boost::asio::placeholders::bytes_transferred))); + } + + bool tls_handshake_complete(const TLS::Session& session) + { + //std::cout << "Handshake from client complete\n"; + + m_hostname = session.server_info().hostname(); + + if(m_hostname != "") + std::cout << "Client requested hostname '" << m_hostname << "'\n"; + + async_connect(m_server_socket, m_server_endpoints, + [this](boost::system::error_code ec, tcp::resolver::iterator endpoint) + { + if(ec) + { + log_error("Server connection", ec); + return; + } + //std::cout << "Connected to " << endpoint->host_name() << ' ' + //<< endpoint->service_name() << "\n"; + tls_proxy_write_to_server(nullptr, 0); + + server_read(boost::system::error_code(), 0); // start read loop + }); + return true; + } + + void tls_alert_cb(TLS::Alert alert, const byte[], size_t) + { + if(alert.type() == TLS::Alert::CLOSE_NOTIFY) + { + m_tls.close(); + return; + } + else + std::cout << "Alert " << alert.type_string() << "\n"; + } + + boost::asio::io_service::strand m_strand; + + tcp::resolver::iterator m_server_endpoints; + + tcp::socket m_client_socket; + tcp::socket m_server_socket; + + TLS::Server m_tls; + std::string m_hostname; + + std::vector<byte> m_c2p; + std::vector<byte> m_p2c; + std::vector<byte> m_p2c_pending; + + std::vector<byte> m_s2p; + std::vector<byte> m_p2s; + std::vector<byte> m_p2s_pending; + }; + +class tls_proxy_server + { + public: + typedef tls_proxy_session session; + + tls_proxy_server(boost::asio::io_service& io, unsigned short port, + tcp::resolver::iterator endpoints, + Credentials_Manager& creds, + TLS::Policy& policy, + TLS::Session_Manager& session_mgr, + RandomNumberGenerator& rng) : + m_acceptor(io, tcp::endpoint(tcp::v4(), port)), + m_server_endpoints(endpoints), + m_creds(creds), + m_policy(policy), + m_session_manager(session_mgr), + m_rng(rng) + { + session::pointer new_session = make_session(); + + m_acceptor.async_accept( + new_session->client_socket(), + boost::bind( + &tls_proxy_server::handle_accept, + this, + new_session, + boost::asio::placeholders::error) + ); + } + + private: + session::pointer make_session() + { + return session::create( + m_acceptor.get_io_service(), + m_session_manager, + m_creds, + m_policy, + m_rng, + m_server_endpoints + ); + } + + void handle_accept(session::pointer new_session, + const boost::system::error_code& error) + { + if (!error) + { + new_session->start(); + + new_session = make_session(); + + m_acceptor.async_accept( + new_session->client_socket(), + boost::bind( + &tls_proxy_server::handle_accept, + this, + new_session, + boost::asio::placeholders::error) + ); + } + } + + tcp::acceptor m_acceptor; + tcp::resolver::iterator m_server_endpoints; + + Credentials_Manager& m_creds; + TLS::Policy& m_policy; + TLS::Session_Manager& m_session_manager; + RandomNumberGenerator& m_rng; + }; + +size_t choose_thread_count() + { + size_t result = std::thread::hardware_concurrency(); + + if(result) + return result; + + return 2; + } + +class Proxy_Credentials_Manager : public Credentials_Manager + { + public: + Proxy_Credentials_Manager(RandomNumberGenerator& rng, + const std::string& server_crt, + const std::string& server_key) + { + try + { + Certificate_Info cert; + + + try + { + cert.key.reset(PKCS8::load_key(server_key, rng)); + } + catch(std::exception& e) + { + log_exception("Loading server key", e); + throw; // fatal + } + + try + { + DataSource_Stream in(server_crt); + while(!in.end_of_data()) + cert.certs.push_back(X509_Certificate(in)); + } + catch(std::exception& e) + { + log_exception("Loading certs", e); + } + + // TODO: attempt to validate chain ourselves + + m_creds.push_back(cert); + } + catch(std::exception& e) + { + log_exception("Loading server key", e); + throw; // fatal + } + + try + { + // TODO: make path configurable + std::shared_ptr<Certificate_Store> cs(new Certificate_Store_In_Memory("/usr/share/ca-certificates")); + m_certstores.push_back(cs); + } + catch(std::exception& e) + { + log_exception("Loading CA certs", e); + //throw; // not fatal + } + } + + std::vector<Botan::Certificate_Store*> + trusted_certificate_authorities(const std::string& type, + const std::string& /*hostname*/) + { + std::vector<Botan::Certificate_Store*> v; + + // don't ask for client certs + if(type == "tls-server") + return v; + + for(auto&& cs : m_certstores) + v.push_back(cs.get()); + + return v; + } + + void verify_certificate_chain( + const std::string& type, + const std::string& purported_hostname, + const std::vector<X509_Certificate>& cert_chain) + { + try + { + Credentials_Manager::verify_certificate_chain(type, + purported_hostname, + cert_chain); + } + catch(std::exception& e) + { + std::cout << "Certificate validation failure: " << e.what() << "\n"; + throw; + } + } + + std::vector<X509_Certificate> cert_chain( + const std::vector<std::string>& algos, + const std::string& type, + const std::string& hostname) + { + for(auto&& i : m_creds) + { + if(std::find(algos.begin(), algos.end(), i.key->algo_name()) == algos.end()) + continue; + + if(hostname != "" && !i.certs[0].matches_dns_name(hostname)) + continue; + + return i.certs; + } + + return std::vector<X509_Certificate>(); + } + + Private_Key* private_key_for(const X509_Certificate& cert, + const std::string& /*type*/, + const std::string& /*context*/) + { + for(auto&& i : m_creds) + { + if(cert == i.certs[0]) + return i.key.get(); + } + + return nullptr; + } + + private: + struct Certificate_Info + { + std::vector<X509_Certificate> certs; + std::shared_ptr<Private_Key> key; + }; + + std::vector<Certificate_Info> m_creds; + std::vector<std::shared_ptr<Certificate_Store>> m_certstores; + }; + +int tls_proxy(int argc, char* argv[]) + { + if(argc != 6) + { + std::cout << "Usage: " << argv[0] << " listen_port target_host target_port server_cert server_key\n"; + return 1; + } + + const size_t listen_port = to_u32bit(argv[1]); + const std::string target = argv[2]; + const std::string target_port = argv[3]; + + const std::string server_crt = argv[4]; + const std::string server_key = argv[5]; + + const size_t num_threads = choose_thread_count(); // make configurable + + AutoSeeded_RNG rng; + Proxy_Credentials_Manager creds(rng, server_crt, server_key); + + TLS::Policy policy; // TODO: Read policy from text file + + try + { + boost::asio::io_service io; + + tcp::resolver resolver(io); + auto server_endpoint_iterator = resolver.resolve({ target, target_port }); + +#if defined(BOTAN_HAS_TLS_SQLITE3_SESSION_MANAGER) + // Todo: make configurable + const std::string sessions_passphrase = "correct horse battery staple"; + const std::string sessions_db = "sessions.db"; + TLS::Session_Manager_SQLite sessions(sessions_passphrase, rng, sessions_db); +#else + TLS::Session_Manager_In_Memory sessions(rng); +#endif + + tls_proxy_server server(io, listen_port, server_endpoint_iterator, creds, policy, sessions, rng); + + std::vector<std::shared_ptr<std::thread>> threads; + + for(size_t i = 2; i <= num_threads; ++i) + threads.push_back(std::make_shared<std::thread>([&io]() { io.run(); })); + + io.run(); + + for (size_t i = 0; i < threads.size(); ++i) + threads[i]->join(); + } + catch (std::exception& e) + { + std::cerr << e.what() << std::endl; + } + + return 0; + } + +} + +} + +REGISTER_APP(tls_proxy); + +#endif diff --git a/src/cmd/tls_server_asio.cpp b/src/cmd/tls_server_asio.cpp deleted file mode 100644 index 9d31107bb..000000000 --- a/src/cmd/tls_server_asio.cpp +++ /dev/null @@ -1,326 +0,0 @@ -/* -* (C) 2014 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#include "apps.h" - -#if defined(BOTAN_HAS_TLS) -#include <iostream> -#include <string> -#include <vector> -#include <thread> -#define _GLIBCXX_HAVE_GTHR_DEFAULT -#include <boost/asio.hpp> -#include <boost/bind.hpp> -//#include <boost/thread.hpp> -#include <boost/shared_ptr.hpp> -#include <boost/enable_shared_from_this.hpp> - -#include <botan/tls_server.h> -#include <botan/x509cert.h> -#include <botan/pkcs8.h> -#include <botan/auto_rng.h> - -#include "credentials.h" - -using Botan::byte; -using boost::asio::ip::tcp; - -namespace { - -class tls_server_session : public boost::enable_shared_from_this<tls_server_session> - { - public: - typedef boost::shared_ptr<tls_server_session> pointer; - - static pointer create(boost::asio::io_service& io_service, - Botan::TLS::Session_Manager& session_manager, - Botan::Credentials_Manager& credentials, - Botan::TLS::Policy& policy, - Botan::RandomNumberGenerator& rng) - { - return pointer( - new tls_server_session( - io_service, - session_manager, - credentials, - policy, - rng) - ); - } - - tcp::socket& socket() { return m_socket; } - - void start() - { - m_socket.async_read_some( - boost::asio::buffer(m_read_buf, sizeof(m_read_buf)), - m_strand.wrap( - boost::bind(&tls_server_session::handle_read, shared_from_this(), - boost::asio::placeholders::error, - boost::asio::placeholders::bytes_transferred))); - } - - void stop() { m_socket.close(); } - - private: - tls_server_session(boost::asio::io_service& io_service, - Botan::TLS::Session_Manager& session_manager, - Botan::Credentials_Manager& credentials, - Botan::TLS::Policy& policy, - Botan::RandomNumberGenerator& rng) : - m_strand(io_service), - m_socket(io_service), - m_tls(boost::bind(&tls_server_session::tls_output_wanted, this, _1, _2), - boost::bind(&tls_server_session::tls_data_recv, this, _1, _2), - boost::bind(&tls_server_session::tls_alert_cb, this, _1, _2, _3), - boost::bind(&tls_server_session::tls_handshake_complete, this, _1), - session_manager, - credentials, - policy, - rng) - { - } - - void handle_read(const boost::system::error_code& error, - size_t bytes_transferred) - { - if(!error) - { - try - { - m_tls.received_data(m_read_buf, bytes_transferred); - } - catch(std::exception& e) - { - std::cout << "Read failed " << e.what() << "\n"; - stop(); - return; - } - - m_socket.async_read_some( - boost::asio::buffer(m_read_buf, sizeof(m_read_buf)), - m_strand.wrap(boost::bind(&tls_server_session::handle_read, shared_from_this(), - boost::asio::placeholders::error, - boost::asio::placeholders::bytes_transferred))); - } - else - { - stop(); - } - } - - void handle_write(const boost::system::error_code& error) - { - if(!error) - { - m_write_buf.clear(); - - // initiate another write if needed - tls_output_wanted(nullptr, 0); - } - else - { - stop(); - } - } - - void tls_output_wanted(const byte buf[], size_t buf_len) - { - if(buf_len > 0) - m_outbox.insert(m_outbox.end(), buf, buf + buf_len); - - // no write pending and have output pending - if(m_write_buf.empty() && !m_outbox.empty()) - { - std::swap(m_outbox, m_write_buf); - - boost::asio::async_write(m_socket, - boost::asio::buffer(&m_write_buf[0], m_write_buf.size()), - m_strand.wrap( - boost::bind(&tls_server_session::handle_write, - shared_from_this(), - boost::asio::placeholders::error))); - } - } - - void tls_alert_cb(Botan::TLS::Alert alert, const byte[], size_t) - { - if(alert.type() == Botan::TLS::Alert::CLOSE_NOTIFY) - { - m_tls.close(); - return; - } - } - - void tls_data_recv(const byte buf[], size_t buf_len) - { - m_client_data.insert(m_client_data.end(), buf, buf + buf_len); - - if(ready_to_respond()) - write_response(); - } - - bool ready_to_respond() - { - return true; // parse headers? - } - - void write_response() - { - std::string out; - out += "\r\n"; - out += "HTTP/1.0 200 OK\r\n"; - out += "Server: Botan ASIO test server\r\n"; - if(m_hostname != "") - out += "Host: " + m_hostname + "\r\n"; - out += "Content-Type: text/html\r\n"; - out += "\r\n"; - out += "<html><body>Greets. You said: "; - out += std::string(reinterpret_cast<const char*>(&m_client_data[0]), - m_client_data.size()); - out += "</body></html>\r\n\r\n"; - - m_tls.send(out); - m_tls.close(); - } - - bool tls_handshake_complete(const Botan::TLS::Session& session) - { - m_hostname = session.server_info().hostname(); - return true; - } - - boost::asio::io_service::strand m_strand; // serialization - - tcp::socket m_socket; - Botan::TLS::Server m_tls; - std::string m_hostname; - - unsigned char m_read_buf[1024]; - - // used to hold the data currently being written by the system - std::vector<byte> m_write_buf; - - // used to hold data queued for writing - std::vector<byte> m_outbox; - - std::vector<byte> m_client_data; - }; - -class asio_tls_server - { - public: - typedef tls_server_session session; - - asio_tls_server(boost::asio::io_service& io_service, unsigned short port) : - m_acceptor(io_service, tcp::endpoint(tcp::v4(), port)), - m_session_manager(m_rng), - m_creds(m_rng) - { - session::pointer new_session = make_session(); - - m_acceptor.async_accept( - new_session->socket(), - boost::bind( - &asio_tls_server::handle_accept, - this, - new_session, - boost::asio::placeholders::error) - ); - } - - private: - session::pointer make_session() - { - return session::create( - m_acceptor.get_io_service(), - m_session_manager, - m_creds, - m_policy, - m_rng - ); - } - - void handle_accept(session::pointer new_session, - const boost::system::error_code& error) - { - if (!error) - { - new_session->start(); - - new_session = make_session(); - - m_acceptor.async_accept( - new_session->socket(), - boost::bind( - &asio_tls_server::handle_accept, - this, - new_session, - boost::asio::placeholders::error) - ); - } - } - - tcp::acceptor m_acceptor; - - Botan::AutoSeeded_RNG m_rng; - Botan::TLS::Session_Manager_In_Memory m_session_manager; - Botan::TLS::Policy m_policy; - Credentials_Manager_Simple m_creds; - }; - -size_t choose_thread_count() - { - size_t result = std::thread::hardware_concurrency(); - - if(result) - return result; - - return 2; - } - -int tls_server_asio(int argc, char* argv[]) - { - try - { - boost::asio::io_service io_service; - - const unsigned short port = 4434; - asio_tls_server server(io_service, port); - - size_t num_threads = choose_thread_count(); - if(argc == 2) - std::istringstream(argv[1]) >> num_threads; - - std::cout << "Using " << num_threads << " threads\n"; - - std::vector<boost::shared_ptr<std::thread> > threads; - - for(size_t i = 0; i != num_threads; ++i) - { - boost::shared_ptr<std::thread> thread( - new std::thread( - boost::bind(&boost::asio::io_service::run, &io_service))); - threads.push_back(thread); - } - - // Wait for all threads in the pool to exit. - for (size_t i = 0; i < threads.size(); ++i) - threads[i]->join(); - } - catch (std::exception& e) - { - std::cerr << e.what() << std::endl; - } - - return 0; - } - -} - -REGISTER_APP(tls_server_asio); - -#endif |