Add support for client-side QUIC 0-RTT

source/common/quic/BUILD

@@ -112,6 +112,17 @@ envoy_cc_library(
     ],
 )
 
+envoy_cc_library(
+    name = "envoy_quic_session_cache_lib",
+    srcs = ["envoy_quic_session_cache.cc"],
+    hdrs = ["envoy_quic_session_cache.h"],
+    external_deps = ["quiche_quic_platform"],
+    tags = ["nofips"],
+    deps = [
+        "@com_googlesource_quiche//:quic_core_crypto_crypto_handshake_lib",
+    ],
+)
+
 envoy_cc_library(
     name = "spdy_server_push_utils_for_envoy_lib",
     srcs = ["spdy_server_push_utils_for_envoy.cc"],
@@ -150,6 +161,7 @@ envoy_cc_library(
         ":envoy_quic_connection_helper_lib",
         ":envoy_quic_proof_verifier_lib",
         ":envoy_quic_server_session_lib",
+        ":envoy_quic_session_cache_lib",
         ":envoy_quic_utils_lib",
         "//include/envoy/http:codec_interface",
         "//include/envoy/registry",

source/common/quic/client_connection_factory_impl.cc

@@ -1,5 +1,6 @@
 #include "common/quic/client_connection_factory_impl.h"
 
+#include "common/quic/envoy_quic_session_cache.h"
 #include "common/quic/quic_transport_socket_factory.h"
 
 namespace Envoy {
@@ -20,9 +21,10 @@ PersistentQuicInfoImpl::PersistentQuicInfoImpl(
     : conn_helper_(dispatcher), alarm_factory_(dispatcher, *conn_helper_.GetClock()),
       server_id_{getConfig(transport_socket_factory).serverNameIndication(),
                  static_cast<uint16_t>(server_addr->ip()->port()), false},
-      crypto_config_(
-          std::make_unique<quic::QuicCryptoClientConfig>(std::make_unique<EnvoyQuicProofVerifier>(
-              stats_scope, getConfig(transport_socket_factory), time_source))) {
+      crypto_config_(std::make_unique<quic::QuicCryptoClientConfig>(
+          std::make_unique<EnvoyQuicProofVerifier>(stats_scope, getConfig(transport_socket_factory),
+                                                   time_source),
+          std::make_unique<EnvoyQuicSessionCache>(time_source))) {
   quiche::FlagRegistry::getInstance();
 }
 

source/common/quic/envoy_quic_session_cache.cc

@@ -0,0 +1,168 @@
+#include "common/quic/envoy_quic_session_cache.h"
+
+namespace Envoy {
+namespace Quic {
+namespace {
+
+constexpr size_t MaxSessionCacheEntries = 1024;
+
+// Returns false if the SSL |session| doesn't exist or it is expired at |system_time|.
+bool isSessionValid(SSL_SESSION* session, SystemTime system_time) {
+  if (session == nullptr) {
+    return false;
+  }
+  const time_t now = std::chrono::system_clock::to_time_t(system_time);
+  if (now < 0) {
+    return false;
+  }
+  const uint64_t now_u64 = static_cast<uint64_t>(now);
+  const uint64_t session_time = SSL_SESSION_get_time(session);
+  const uint64_t session_expiration = session_time + SSL_SESSION_get_timeout(session);
+  // now_u64 may be slightly behind because of differences in how time is calculated at this layer
+  // versus BoringSSL. Add a second of wiggle room to account for this.
+  return session_time <= now_u64 + 1 && now_u64 < session_expiration;
+}
+
+bool doApplicationStatesMatch(const quic::ApplicationState* state, quic::ApplicationState* other) {
+  if (state == other) {
+    return true;
+  }
+  if ((state != nullptr && other == nullptr) || (state == nullptr && other != nullptr)) {
+    return false;
+  }
+  return (*state == *other);
+}
+
+} // namespace
+
+EnvoyQuicSessionCache::EnvoyQuicSessionCache(TimeSource& time_source) : time_source_(time_source) {}
+
+EnvoyQuicSessionCache::~EnvoyQuicSessionCache() = default;
+
+void EnvoyQuicSessionCache::Insert(const quic::QuicServerId& server_id,
+                                   bssl::UniquePtr<SSL_SESSION> session,
+                                   const quic::TransportParameters& params,
+                                   const quic::ApplicationState* application_state) {
+  auto it = cache_.find(server_id);
+  if (it == cache_.end()) {
+    // New server ID, add a new entry.
+    createAndInsertEntry(server_id, std::move(session), params, application_state);
+    return;
+  }
+  Entry& entry = it->second;
+  if (params == *entry.params &&
+      doApplicationStatesMatch(application_state, entry.application_state.get())) {
+    // The states are both the same, so we only need to insert the session.
+    entry.pushSession(std::move(session));
+    return;
+  }
+  // States are different, replace the entry.
+  cache_.erase(it);
+  createAndInsertEntry(server_id, std::move(session), params, application_state);
+}
+
+std::unique_ptr<quic::QuicResumptionState>
+EnvoyQuicSessionCache::Lookup(const quic::QuicServerId& server_id, const SSL_CTX* /*ctx*/) {
+  auto it = cache_.find(server_id);
+  if (it == cache_.end()) {
+    return nullptr;
+  }
+  Entry& entry = it->second;
+  const SystemTime system_time = time_source_.systemTime();
+  if (!isSessionValid(entry.peekSession(), system_time)) {
+    cache_.erase(it);
+    return nullptr;
+  }
+  auto state = std::make_unique<quic::QuicResumptionState>();
+  state->tls_session = entry.popSession();
+  if (entry.params != nullptr) {
+    state->transport_params = std::make_unique<quic::TransportParameters>(*entry.params);
+  }
+  if (entry.application_state != nullptr) {
+    state->application_state = std::make_unique<quic::ApplicationState>(*entry.application_state);
+  }
+  return state;
+}
+
+void EnvoyQuicSessionCache::ClearEarlyData(const quic::QuicServerId& server_id) {
+  auto it = cache_.find(server_id);
+  if (it == cache_.end()) {
+    return;
+  }
+  for (bssl::UniquePtr<SSL_SESSION>& session : it->second.sessions) {
+    if (session != nullptr) {
+      session.reset(SSL_SESSION_copy_without_early_data(session.get()));
+    }
+  }
+}
+
+void EnvoyQuicSessionCache::prune() {
+  quic::QuicServerId oldest_id;
+  uint64_t oldest_expiration = std::numeric_limits<uint64_t>::max();
+  const SystemTime system_time = time_source_.systemTime();
+  auto it = cache_.begin();
+  while (it != cache_.end()) {
+    Entry& entry = it->second;
+    SSL_SESSION* session = entry.peekSession();
+    if (!isSessionValid(session, system_time)) {
+      it = cache_.erase(it);
+    } else {
+      if (cache_.size() >= MaxSessionCacheEntries) {
+        // Only save oldest if we are at the size limit.
+        const uint64_t session_expiration =
+            SSL_SESSION_get_time(session) + SSL_SESSION_get_timeout(session);
+        if (session_expiration < oldest_expiration) {
+          oldest_expiration = session_expiration;
+          oldest_id = it->first;
+        }
+      }
+      ++it;
+    }
+  }
+  if (cache_.size() >= MaxSessionCacheEntries) {
+    cache_.erase(oldest_id);
+  }
+}
+
+void EnvoyQuicSessionCache::createAndInsertEntry(const quic::QuicServerId& server_id,
+                                                 bssl::UniquePtr<SSL_SESSION> session,
+                                                 const quic::TransportParameters& params,
+                                                 const quic::ApplicationState* application_state) {
+  prune();
+  ASSERT(cache_.size() < MaxSessionCacheEntries);
+  Entry entry;
+  entry.pushSession(std::move(session));
+  entry.params = std::make_unique<quic::TransportParameters>(params);
+  if (application_state != nullptr) {
+    entry.application_state = std::make_unique<quic::ApplicationState>(*application_state);
+  }
+  cache_.insert(std::make_pair(server_id, std::move(entry)));
+}
+
+size_t EnvoyQuicSessionCache::size() const { return cache_.size(); }
+
+EnvoyQuicSessionCache::Entry::Entry() = default;
+EnvoyQuicSessionCache::Entry::Entry(Entry&&) noexcept = default;
+EnvoyQuicSessionCache::Entry::~Entry() = default;
+
+void EnvoyQuicSessionCache::Entry::pushSession(bssl::UniquePtr<SSL_SESSION> session) {
+  if (sessions[0] != nullptr) {
+    sessions[1] = std::move(sessions[0]);
+  }
+  sessions[0] = std::move(session);
+}
+
+bssl::UniquePtr<SSL_SESSION> EnvoyQuicSessionCache::Entry::popSession() {
+  if (sessions[0] == nullptr) {
+    return nullptr;
+  }
+  bssl::UniquePtr<SSL_SESSION> session = std::move(sessions[0]);
+  sessions[0] = std::move(sessions[1]);
+  sessions[1] = nullptr;
+  return session;
+}
+
+SSL_SESSION* EnvoyQuicSessionCache::Entry::peekSession() { return sessions[0].get(); }
+
+} // namespace Quic
+} // namespace Envoy

source/common/quic/envoy_quic_session_cache.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include "envoy/common/time.h"
+
+#include "quiche/quic/core/crypto/quic_crypto_client_config.h"
+
+namespace Envoy {
+namespace Quic {
+
+// Implementation of quic::SessionCache using an Envoy time source.
+class EnvoyQuicSessionCache : public quic::SessionCache {
+public:
+  explicit EnvoyQuicSessionCache(TimeSource& time_source);
+  ~EnvoyQuicSessionCache() override;
+
+  // From quic::SessionCache.
+  void Insert(const quic::QuicServerId& server_id, bssl::UniquePtr<SSL_SESSION> session,
+              const quic::TransportParameters& params,
+              const quic::ApplicationState* application_state) override;
+  std::unique_ptr<quic::QuicResumptionState> Lookup(const quic::QuicServerId& server_id,
+                                                    const SSL_CTX* ctx) override;
+  void ClearEarlyData(const quic::QuicServerId& server_id) override;
+
+  // Returns number of entries in the cache.
+  size_t size() const;
+
+private:
+  struct Entry {
+    Entry();
+    Entry(Entry&&) noexcept;
+    ~Entry();
+
+    // Adds a new |session| onto sessions, dropping the oldest one if two are
+    // already stored.
+    void pushSession(bssl::UniquePtr<SSL_SESSION> session);
+
+    // Retrieves the latest session from the entry, meanwhile removing it.
+    bssl::UniquePtr<SSL_SESSION> popSession();
+
+    SSL_SESSION* peekSession();
+
+    bssl::UniquePtr<SSL_SESSION> sessions[2];
+    std::unique_ptr<quic::TransportParameters> params;
+    std::unique_ptr<quic::ApplicationState> application_state;
+  };
+
+  // Remove all entries that are no longer valid. If after that we are still at the size limit, also
+  // remove the oldest entry.
+  void prune();
+
+  // Creates a new entry and insert into |cache_|.
+  void createAndInsertEntry(const quic::QuicServerId& server_id,
+                            bssl::UniquePtr<SSL_SESSION> session,
+                            const quic::TransportParameters& params,
+                            const quic::ApplicationState* application_state);
+
+  std::map<quic::QuicServerId, Entry> cache_;
+  TimeSource& time_source_;
+};
+
+} // namespace Quic
+} // namespace Envoy

test/common/quic/BUILD

@@ -54,6 +54,16 @@ envoy_cc_test(
     ],
 )
 
+envoy_cc_test(
+    name = "envoy_quic_session_cache_test",
+    srcs = ["envoy_quic_session_cache_test.cc"],
+    external_deps = ["quiche_quic_platform"],
+    tags = ["nofips"],
+    deps = [
+        "//source/common/quic:envoy_quic_session_cache_lib",
+    ],
+)
+
 envoy_cc_test(
     name = "envoy_quic_proof_verifier_test",
     srcs = ["envoy_quic_proof_verifier_test.cc"],