Enables switching SSL certificates on QUIC with QUICHE

iocore/net/P_QUICNetVConnection_quiche.h

@@ -39,6 +39,9 @@
 #include "P_UDPNet.h"
 #include "P_ALPNSupport.h"
 #include "TLSBasicSupport.h"
+#include "TLSSessionResumptionSupport.h"
+#include "TLSSNISupport.h"
+#include "TLSCertSwitchSupport.h"
 #include "tscore/ink_apidefs.h"
 #include "tscore/List.h"
 
@@ -57,6 +60,9 @@ class QUICNetVConnection : public UnixNetVConnection,
                            public QUICConnection,
                            public RefCountObj,
                            public ALPNSupport,
+                           public TLSSNISupport,
+                           public TLSSessionResumptionSupport,
+                           public TLSCertSwitchSupport,
                            public TLSBasicSupport
 {
   using super = UnixNetVConnection; ///< Parent type.
@@ -66,7 +72,7 @@ class QUICNetVConnection : public UnixNetVConnection,
   ~QUICNetVConnection();
   void init(QUICVersion version, QUICConnectionId peer_cid, QUICConnectionId original_cid, UDPConnection *, QUICPacketHandler *);
   void init(QUICVersion version, QUICConnectionId peer_cid, QUICConnectionId original_cid, QUICConnectionId first_cid,
-            QUICConnectionId retry_cid, UDPConnection *, quiche_conn *, QUICPacketHandler *, QUICConnectionTable *ctable);
+            QUICConnectionId retry_cid, UDPConnection *, quiche_conn *, QUICPacketHandler *, QUICConnectionTable *ctable, SSL *);
 
   // Event handlers
   int acceptEvent(int event, Event *e);
@@ -88,13 +94,16 @@ class QUICNetVConnection : public UnixNetVConnection,
   VIO *do_io_write(Continuation *c, int64_t nbytes, IOBufferReader *buf, bool owner = false) override;
   int connectUp(EThread *t, int fd) override;
   int64_t load_buffer_and_write(int64_t towrite, MIOBufferAccessor &buf, int64_t &total_written, int &needs) override;
+  bool getSSLHandShakeComplete() const override;
 
   // NetEvent
   virtual void net_read_io(NetHandler *nh, EThread *lthread) override;
 
   // NetVConnection
   int populate_protocol(std::string_view *results, int n) const override;
   const char *protocol_contains(std::string_view tag) const override;
+  const char *get_server_name() const override;
+  bool support_sni() const override;
 
   // QUICConnection
   QUICStreamManager *stream_manager() override;
@@ -144,7 +153,19 @@ class QUICNetVConnection : public UnixNetVConnection,
   SSL *_get_ssl_object() const override;
   ssl_curve_id _get_tls_curve() const override;
 
+  // TLSSNISupport
+  void _fire_ssl_servername_event() override;
+
+  // TLSSessionResumptionSupport
+  const IpEndpoint &_getLocalEndpoint() override;
+
+  // TLSCertSwitchSupport
+  bool _isTryingRenegotiation() const override;
+  shared_SSL_CTX _lookupContextByName(const std::string &servername, SSLCertContextType ctxType) override;
+  shared_SSL_CTX _lookupContextByIP() override;
+
 private:
+  SSL *_ssl;
   QUICConfig::scoped_config _quic_config;
 
   QUICConnectionId _peer_quic_connection_id;      // dst cid in local
@@ -159,6 +180,9 @@ class QUICNetVConnection : public UnixNetVConnection,
   quiche_conn *_quiche_con     = nullptr;
   QUICConnectionTable *_ctable = nullptr;
 
+  void _bindSSLObject();
+  void _unbindSSLObject();
+
   void _schedule_packet_write_ready(bool delay = false);
   void _unschedule_packet_write_ready();
   void _close_packet_write_ready(Event *data);

iocore/net/QUICMultiCertConfigLoader.cc

@@ -109,77 +109,6 @@ QUICMultiCertConfigLoader::_set_npn_callback(SSL_CTX *ctx)
   return true;
 }
 
-void
-QUICMultiCertConfigLoader::_set_handshake_callbacks(SSL_CTX *ssl_ctx)
-{
-  SSL_CTX_set_cert_cb(ssl_ctx, QUICMultiCertConfigLoader::ssl_cert_cb, nullptr);
-  SSL_CTX_set_tlsext_servername_callback(ssl_ctx, QUICMultiCertConfigLoader::ssl_sni_cb);
-
-  // Set client hello callback if needed
-  // SSL_CTX_set_client_hello_cb(ctx, QUIC::ssl_client_hello_cb, nullptr);
-}
-
-int
-QUICMultiCertConfigLoader::ssl_sni_cb(SSL *ssl, int * /*ad*/, void * /*arg*/)
-{
-  // XXX: add SNIConfig support ?
-  // XXX: add TRANSPORT_BLIND_TUNNEL support ?
-  return 1;
-}
-
-int
-QUICMultiCertConfigLoader::ssl_cert_cb(SSL *ssl, void * /*arg*/)
-{
-  shared_SSL_CTX ctx = nullptr;
-  SSLCertContext *cc = nullptr;
-  QUICCertConfig::scoped_config lookup;
-  const char *servername = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
-  QUICConnection *qc     = static_cast<QUICConnection *>(SSL_get_ex_data(ssl, QUIC::ssl_quic_qc_index));
-
-  if (servername == nullptr) {
-    servername = "";
-  }
-  QUICGlobalQCDebug(qc, "SNI=%s", servername);
-
-  // The incoming SSL_CTX is either the one mapped from the inbound IP address or the default one. If we
-  // don't find a name-based match at this point, we *do not* want to mess with the context because we've
-  // already made a best effort to find the best match.
-  if (likely(servername)) {
-    cc = lookup->find(const_cast<char *>(servername));
-    if (cc && cc->getCtx()) {
-      ctx = cc->getCtx();
-    }
-  }
-
-  // If there's no match on the server name, try to match on the peer address.
-  if (ctx == nullptr) {
-    QUICFiveTuple five_tuple = qc->five_tuple();
-    IpEndpoint ip            = five_tuple.destination();
-    cc                       = lookup->find(ip);
-
-    if (cc && cc->getCtx()) {
-      ctx = cc->getCtx();
-    }
-  }
-
-  bool found = true;
-  if (ctx != nullptr) {
-    SSL_set_SSL_CTX(ssl, ctx.get());
-  } else {
-    found = false;
-  }
-
-  SSL_CTX *verify_ctx = nullptr;
-  verify_ctx          = SSL_get_SSL_CTX(ssl);
-  QUICGlobalQCDebug(qc, "%s SSL_CTX %p for requested name '%s'", found ? "found" : "using", verify_ctx, servername);
-
-  if (verify_ctx == nullptr) {
-    return 0;
-  }
-
-  return 1;
-}
-
 const char *
 QUICMultiCertConfigLoader::_debug_tag() const
 {

iocore/net/QUICMultiCertConfigLoader.h

@@ -49,12 +49,8 @@ class QUICMultiCertConfigLoader : public SSLMultiCertConfigLoader
 
 private:
   const char *_debug_tag() const override;
-  virtual void _set_handshake_callbacks(SSL_CTX *ssl_ctx) override;
   virtual bool _setup_session_cache(SSL_CTX *ctx) override;
   virtual bool _set_cipher_suites_for_legacy_versions(SSL_CTX *ctx) override;
   virtual bool _set_info_callback(SSL_CTX *ctx) override;
   virtual bool _set_npn_callback(SSL_CTX *ctx) override;
-
-  static int ssl_cert_cb(SSL *ssl, void *arg);
-  static int ssl_sni_cb(SSL *ssl, int *ad, void *arg);
 };

iocore/net/QUICNetProcessor_quiche.cc

@@ -75,19 +75,11 @@ QUICNetProcessor::start(int, size_t stacksize)
   // QUICInitializeLibrary();
   QUICConfig::startup();
   QUICCertConfig::startup();
-  QUICCertConfig::scoped_config certs;
   QUICConfig::scoped_config params;
-  SSLCertContext *context = certs->get(0);
 
   quiche_enable_debug_logging(debug_log, NULL);
   this->_quiche_config = quiche_config_new(QUICHE_PROTOCOL_VERSION);
   quiche_config_set_application_protos(this->_quiche_config, (uint8_t *)"\02h3\x05h3-29\x05hq-29\x05h3-27\x05hq-27", 27);
-  if (context->userconfig->cert != nullptr) {
-    quiche_config_load_cert_chain_from_pem_file(this->_quiche_config, context->userconfig->cert);
-  }
-  if (context->userconfig->key != nullptr) {
-    quiche_config_load_priv_key_from_pem_file(this->_quiche_config, context->userconfig->key);
-  }
 
   quiche_config_set_max_idle_timeout(this->_quiche_config, params->no_activity_timeout_in());
   quiche_config_set_max_recv_udp_payload_size(this->_quiche_config, params->get_max_recv_udp_payload_size_in());

iocore/net/QUICNetVConnection_quiche.cc

@@ -23,7 +23,9 @@
 
 #include "P_QUICNetVConnection_quiche.h"
 #include "P_QUICPacketHandler_quiche.h"
+#include "QUICMultiCertConfigLoader.h"
 #include "quic/QUICStream_quiche.h"
+#include "quic/QUICGlobals.h"
 #include <quiche.h>
 
 static constexpr ink_hrtime WRITE_READY_INTERVAL = HRTIME_MSECONDS(2);
@@ -46,7 +48,7 @@ QUICNetVConnection::init(QUICVersion version, QUICConnectionId peer_cid, QUICCon
 void
 QUICNetVConnection::init(QUICVersion version, QUICConnectionId peer_cid, QUICConnectionId original_cid, QUICConnectionId first_cid,
                          QUICConnectionId retry_cid, UDPConnection *udp_con, quiche_conn *quiche_con,
-                         QUICPacketHandler *packet_handler, QUICConnectionTable *ctable)
+                         QUICPacketHandler *packet_handler, QUICConnectionTable *ctable, SSL *ssl)
 {
   SET_HANDLER((NetVConnHandler)&QUICNetVConnection::acceptEvent);
   this->_udp_con                     = udp_con;
@@ -61,6 +63,10 @@ QUICNetVConnection::init(QUICVersion version, QUICConnectionId peer_cid, QUICCon
     this->_ctable->insert(this->_quic_connection_id, this);
     this->_ctable->insert(this->_original_quic_connection_id, this);
   }
+
+  this->_ssl = ssl;
+  SSL_set_ex_data(ssl, QUIC::ssl_quic_qc_index, static_cast<QUICConnection *>(this));
+  this->_bindSSLObject();
 }
 
 void
@@ -114,6 +120,7 @@ QUICNetVConnection::free(EThread *t)
   this->_context->trigger(QUICContext::CallbackEvent::CONNECTION_CLOSE);
   ALPNSupport::clear();
   TLSBasicSupport::clear();
+  TLSCertSwitchSupport::_clear();
 
   this->_packet_handler->close_connection(this);
   this->_packet_handler = nullptr;
@@ -489,6 +496,32 @@ QUICNetVConnection::load_buffer_and_write(int64_t towrite, MIOBufferAccessor &bu
   return 0;
 }
 
+bool
+QUICNetVConnection::getSSLHandShakeComplete() const
+{
+  return quiche_conn_is_established(this->_quiche_con);
+}
+
+void
+QUICNetVConnection::_bindSSLObject()
+{
+  TLSBasicSupport::bind(this->_ssl, this);
+  ALPNSupport::bind(this->_ssl, this);
+  TLSSessionResumptionSupport::bind(this->_ssl, this);
+  TLSSNISupport::bind(this->_ssl, this);
+  TLSCertSwitchSupport::bind(this->_ssl, this);
+}
+
+void
+QUICNetVConnection::_unbindSSLObject()
+{
+  TLSBasicSupport::unbind(this->_ssl);
+  ALPNSupport::unbind(this->_ssl);
+  TLSSessionResumptionSupport::unbind(this->_ssl);
+  TLSSNISupport::unbind(this->_ssl);
+  TLSCertSwitchSupport::unbind(this->_ssl);
+}
+
 void
 QUICNetVConnection::_schedule_packet_write_ready(bool delay)
 {
@@ -632,14 +665,79 @@ QUICNetVConnection::protocol_contains(std::string_view tag) const
   return "";
 }
 
+const char *
+QUICNetVConnection::get_server_name() const
+{
+  return get_sni_server_name();
+}
+
+bool
+QUICNetVConnection::support_sni() const
+{
+  return true;
+}
+
 SSL *
 QUICNetVConnection::_get_ssl_object() const
 {
-  return nullptr;
+  return this->_ssl;
 }
 
 ssl_curve_id
 QUICNetVConnection::_get_tls_curve() const
 {
-  return 0;
+  if (getSSLSessionCacheHit()) {
+    return getSSLCurveNID();
+  } else {
+    return SSLGetCurveNID(this->_ssl);
+  }
+}
+
+void
+QUICNetVConnection::_fire_ssl_servername_event()
+{
+}
+
+const IpEndpoint &
+QUICNetVConnection::_getLocalEndpoint()
+{
+  return this->local_addr;
+}
+
+bool
+QUICNetVConnection::_isTryingRenegotiation() const
+{
+  // Renegotiation is not allowed on QUIC (TLS 1.3) connections.
+  // If handshake is completed when this function is called, that should be unallowed attempt of renegotiation.
+  return this->getSSLHandShakeComplete();
+}
+
+shared_SSL_CTX
+QUICNetVConnection::_lookupContextByName(const std::string &servername, SSLCertContextType ctxType)
+{
+  shared_SSL_CTX ctx = nullptr;
+  QUICCertConfig::scoped_config lookup;
+  SSLCertContext *cc = lookup->find(servername, ctxType);
+
+  if (cc && cc->getCtx()) {
+    ctx = cc->getCtx();
+  }
+
+  return ctx;
+}
+
+shared_SSL_CTX
+QUICNetVConnection::_lookupContextByIP()
+{
+  shared_SSL_CTX ctx = nullptr;
+  QUICCertConfig::scoped_config lookup;
+  QUICFiveTuple five_tuple = this->five_tuple();
+  IpEndpoint ip            = five_tuple.destination();
+  SSLCertContext *cc       = lookup->find(ip);
+
+  if (cc && cc->getCtx()) {
+    ctx = cc->getCtx();
+  }
+
+  return ctx;
 }

iocore/net/QUICPacketHandler_quiche.cc

@@ -29,6 +29,7 @@
 #include "P_QUICNetProcessor_quiche.h"
 #include "P_QUICClosedConCollector.h"
 #include "quic/QUICConnectionTable.h"
+#include "QUICMultiCertConfigLoader.h"
 #include <quiche.h>
 
 static constexpr char debug_tag[]   = "quic_sec";
@@ -274,10 +275,14 @@ QUICPacketHandlerIn::_recv_packet(int event, UDPPacket *udp_packet)
     }
 
     QUICConnectionId new_cid;
-    quiche_conn *quiche_con = quiche_accept(
+
+    QUICCertConfig::scoped_config server_cert;
+    SSL *ssl = SSL_new(server_cert->defaultContext());
+
+    quiche_conn *quiche_con = quiche_conn_new_with_tls(
       new_cid, new_cid.length(), retry_token.original_dcid(), retry_token.original_dcid().length(), &udp_packet->to.sa,
       udp_packet->to.isIp4() ? sizeof(udp_packet->to.sin) : sizeof(udp_packet->to.sin6), &udp_packet->from.sa,
-      udp_packet->from.isIp4() ? sizeof(udp_packet->from.sin) : sizeof(udp_packet->from.sin6), &this->_quiche_config);
+      udp_packet->from.isIp4() ? sizeof(udp_packet->from.sin) : sizeof(udp_packet->from.sin6), &this->_quiche_config, ssl, true);
 
     if (params->get_qlog_file_base_name() != nullptr) {
       char qlog_filepath[PATH_MAX];
@@ -296,7 +301,7 @@ QUICPacketHandlerIn::_recv_packet(int event, UDPPacket *udp_packet)
     // vc->init(version, peer_cid, original_cid, ocid_in_retry_token, rcid_in_retry_token, udp_packet->getConnection(), this,
     // &this->_ctable);
     vc->init(version, peer_cid, new_cid, QUICConnectionId::ZERO(), QUICConnectionId::ZERO(), udp_packet->getConnection(),
-             quiche_con, this, &this->_ctable);
+             quiche_con, this, &this->_ctable, ssl);
     vc->id = net_next_connection_number();
     vc->con.move(con);
     vc->submit_time = Thread::get_hrtime();

tests/gold_tests/timeout/active_timeout.test.py

@@ -64,7 +64,7 @@
 tr3.Processes.Default.Command = 'curl -k -i --http2 https://127.0.0.1:{0}/file'.format(ts.Variables.ssl_port)
 tr3.Processes.Default.Streams.stdout = Testers.ContainsExpression("Activity Timeout", "Request should fail with active timeout")
 
-if Condition.HasATSFeature('TS_USE_QUIC') and Condition.HasCurlFeature('http3'):
+if Condition.HasATSFeature('TS_HAS_QUICHE') and Condition.HasCurlFeature('http3'):
     tr4 = Test.AddTestRun("tr")
     tr4.Processes.Default.Command = 'curl -k -i --http3 https://127.0.0.1:{0}/file'.format(ts.Variables.ssl_port)
     tr4.Processes.Default.Streams.stdout = Testers.ContainsExpression("Activity Timeout", "Request should fail with active timeout")