Improve TLS ticket key generation

Summary: Improve the way AsyncMcServer generates TLS ticket keys.

Reviewed By: glamtechie

Differential Revision: D4565521

fbshipit-source-id: 7391c76d2af64bf583b38721c7a38f406f66a469

Author: jmswen

mcrouter/Server-inl.h

@@ -94,6 +94,7 @@ bool runServer(
   } else {
     opts.ports = standaloneOpts.ports;
     opts.sslPorts = standaloneOpts.ssl_ports;
+    opts.tlsTicketKeySeedPath = standaloneOpts.tls_ticket_key_seed_path;
     opts.pemCertPath = mcrouterOpts.pem_cert_path;
     opts.pemKeyPath = mcrouterOpts.pem_key_path;
     opts.pemCaPath = mcrouterOpts.pem_ca_path;

mcrouter/lib/network/AsyncMcServer.cpp

@@ -18,13 +18,17 @@
 #include <cstdio>
 #include <mutex>
 #include <thread>
+#include <vector>
 
 #include <folly/Memory.h>
+#include <folly/SharedMutex.h>
 #include <folly/String.h>
 #include <folly/io/async/AsyncServerSocket.h>
 #include <folly/io/async/EventBase.h>
 #include <folly/io/async/SSLContext.h>
 #include <folly/io/async/ScopedEventBaseThread.h>
+#include <wangle/ssl/TLSCredProcessor.h>
+#include <wangle/ssl/TLSTicketKeySeeds.h>
 
 #include "mcrouter/lib/network/AsyncMcServerWorker.h"
 #include "mcrouter/lib/network/ThreadLocalSSLContextProvider.h"
@@ -168,9 +172,14 @@ class McServerThread {
         int fd,
         const folly::SocketAddress& clientAddr) noexcept override final {
       if (secure_) {
-        auto& opts = mcServerThread_->server_.opts_;
-        auto sslCtx =
-            getSSLContext(opts.pemCertPath, opts.pemKeyPath, opts.pemCaPath);
+        const auto& server = mcServerThread_->server_;
+        auto& opts = server.opts_;
+        auto sslCtx = getSSLContext(
+            opts.pemCertPath,
+            opts.pemKeyPath,
+            opts.pemCaPath,
+            server.getTicketKeySeeds());
+
         if (sslCtx) {
           sslCtx->setVerificationOption(
               folly::SSLContext::SSLVerifyPeerEnum::VERIFY_REQ_CLIENT_CERT);
@@ -346,6 +355,14 @@ AsyncMcServer::AsyncMcServer(Options opts) : opts_(std::move(opts)) {
     }
   }
 
+  if (!opts_.tlsTicketKeySeedPath.empty()) {
+    if (auto initialSeeds = wangle::TLSCredProcessor::processTLSTickets(
+            opts_.tlsTicketKeySeedPath)) {
+      tlsTicketKeySeeds_ = std::move(*initialSeeds);
+    }
+    startPollingTicketKeySeeds();
+  }
+
   if (opts_.numThreads == 0) {
     throw std::invalid_argument(folly::sformat(
         "Unexpected option: opts_.numThreads={}", opts_.numThreads));
@@ -466,5 +483,27 @@ void AsyncMcServer::join() {
     thread->join();
   }
 }
+
+void AsyncMcServer::setTicketKeySeeds(wangle::TLSTicketKeySeeds seeds) {
+  folly::SharedMutex::WriteHolder writeGuard(tlsTicketKeySeedsLock_);
+  tlsTicketKeySeeds_ = std::move(seeds);
+}
+
+wangle::TLSTicketKeySeeds AsyncMcServer::getTicketKeySeeds() const {
+  folly::SharedMutex::ReadHolder readGuard(tlsTicketKeySeedsLock_);
+  return tlsTicketKeySeeds_;
 }
-} // facebook::memcache
+
+void AsyncMcServer::startPollingTicketKeySeeds() {
+  // Caller assumed to have checked opts_.tlsTicketKeySeedPath is non-empty
+  ticketKeySeedPoller_ = folly::make_unique<wangle::TLSCredProcessor>(
+      opts_.tlsTicketKeySeedPath, opts_.pemCertPath);
+  ticketKeySeedPoller_->addTicketCallback(
+      [this](wangle::TLSTicketKeySeeds updatedSeeds) {
+        setTicketKeySeeds(std::move(updatedSeeds));
+        VLOG(0) << "Updated TLSTicketKeySeeds";
+      });
+}
+
+} // memcache
+} // facebook

mcrouter/lib/network/AsyncMcServer.h

@@ -17,6 +17,9 @@
 
 #include <sys/socket.h>
 
+#include <folly/SharedMutex.h>
+#include <wangle/ssl/TLSTicketKeySeeds.h>
+
 #include "mcrouter/lib/network/AsyncMcServerWorkerOptions.h"
 #include "mcrouter/lib/network/CongestionController.h"
 
@@ -25,6 +28,10 @@ class EventBase;
 class ScopedEventBaseThread;
 } // folly
 
+namespace wangle {
+class TLSCredProcessor;
+} // wangle
+
 namespace facebook {
 namespace memcache {
 
@@ -80,6 +87,12 @@ class AsyncMcServer {
     std::string pemKeyPath;
     std::string pemCaPath;
 
+    /**
+     * Path to JSON file containing old, current, and new seeds used for TLS
+     * ticket key generation.
+     */
+    std::string tlsTicketKeySeedPath;
+
     /**
      * Number of threads to spawn, must be positive.
      */
@@ -168,22 +181,35 @@ class AsyncMcServer {
    */
   void join();
 
+  /**
+   * Getter/setter for seeds to be used to generate keys encrypting TLS tickets.
+   */
+  void setTicketKeySeeds(wangle::TLSTicketKeySeeds seeds);
+  wangle::TLSTicketKeySeeds getTicketKeySeeds() const;
+
  private:
   std::unique_ptr<folly::ScopedEventBaseThread> auxiliaryEvbThread_;
   Options opts_;
   std::vector<std::unique_ptr<McServerThread>> threads_;
 
+  std::unique_ptr<wangle::TLSCredProcessor> ticketKeySeedPoller_;
+  wangle::TLSTicketKeySeeds tlsTicketKeySeeds_;
+  mutable folly::SharedMutex tlsTicketKeySeedsLock_;
+
   std::atomic<bool> alive_{true};
   std::function<void()> onShutdown_;
 
   enum class SignalShutdownState : uint64_t { STARTUP, SHUTDOWN, SPAWNED };
   std::atomic<SignalShutdownState> signalShutdownState_{
       SignalShutdownState::STARTUP};
 
+  void startPollingTicketKeySeeds();
+
   AsyncMcServer(const AsyncMcServer&) = delete;
   AsyncMcServer& operator=(const AsyncMcServer&) = delete;
 
   friend class McServerThread;
 };
-}
-} // facebook::memcache
+
+} // memcache
+} // facebook

mcrouter/lib/network/ThreadLocalSSLContextProvider.cpp

@@ -13,6 +13,7 @@
 
 #include <folly/io/async/SSLContext.h>
 #include <wangle/ssl/TLSTicketKeyManager.h>
+#include <wangle/ssl/TLSTicketKeySeeds.h>
 
 #include "mcrouter/lib/fbi/cpp/LogFailure.h"
 
@@ -155,7 +156,8 @@ std::shared_ptr<SSLContext> handleSSLCertsUpdate(
 std::shared_ptr<SSLContext> getSSLContext(
     folly::StringPiece pemCertPath,
     folly::StringPiece pemKeyPath,
-    folly::StringPiece pemCaPath) {
+    folly::StringPiece pemCaPath,
+    folly::Optional<wangle::TLSTicketKeySeeds> ticketKeySeeds) {
   static constexpr std::chrono::minutes kSslReloadInterval{30};
   thread_local std::unordered_map<CertPaths, ContextInfo, CertPathsHasher>
       localContexts;
@@ -193,20 +195,27 @@ std::shared_ptr<SSLContext> getSSLContext(
       SSL_CTX_set_timeout(contextInfo.context->getSSLCtx(), kSessionLifeTime);
 
 #ifdef SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB
-      auto mgr = folly::make_unique<wangle::TLSTicketKeyManager>(
-          contextInfo.context.get(), nullptr);
-      mgr->setTLSTicketKeySeeds({"aaaa"}, {"bbbb"}, {"cccc"});
-
-      /* store in the map */
-      const auto mapKey =
-          reinterpret_cast<uintptr_t>(contextInfo.context.get());
-      assert(contextToTicketMgr()->find(mapKey) == contextToTicketMgr()->end());
-      contextToTicketMgr()->emplace(mapKey, std::move(mgr));
+      if (ticketKeySeeds.hasValue()) {
+        auto mgr = folly::make_unique<wangle::TLSTicketKeyManager>(
+            contextInfo.context.get(), nullptr);
+        mgr->setTLSTicketKeySeeds(
+            std::move(ticketKeySeeds->oldSeeds),
+            std::move(ticketKeySeeds->currentSeeds),
+            std::move(ticketKeySeeds->newSeeds));
+
+        /* store in the map */
+        const auto mapKey =
+            reinterpret_cast<uintptr_t>(contextInfo.context.get());
+        assert(
+            contextToTicketMgr()->find(mapKey) == contextToTicketMgr()->end());
+        contextToTicketMgr()->emplace(mapKey, std::move(mgr));
+      }
 #endif
     }
   }
 
   return contextInfo.context;
 }
-}
-} // facebook::memcache
+
+} // memcache
+} // facebook

mcrouter/lib/network/ThreadLocalSSLContextProvider.h

@@ -9,7 +9,11 @@
  */
 #pragma once
 
+#include <memory>
+
+#include <folly/Optional.h>
 #include <folly/Range.h>
+#include <wangle/ssl/TLSTicketKeySeeds.h>
 
 namespace folly {
 class SSLContext;
@@ -26,6 +30,8 @@ namespace memcache {
 std::shared_ptr<folly::SSLContext> getSSLContext(
     folly::StringPiece pemCertPath,
     folly::StringPiece pemKeyPath,
-    folly::StringPiece pemCaPath);
-}
-} // facebook::memcache
+    folly::StringPiece pemCaPath,
+    folly::Optional<wangle::TLSTicketKeySeeds> = folly::none);
+
+} // memcache
+} // facebook

mcrouter/lib/network/test/AsyncMcClientTestSync.cpp

@@ -642,8 +642,15 @@ TEST(AsyncMcClient, curruptedUmbrellaReply) {
 }
 
 TEST(AsyncMcClient, SslSessionCache) {
-  auto server =
-      TestServer::create(true, true, 10, 250, 100, true, 4 /* nThreads */);
+  auto server = TestServer::create(
+      true,
+      true,
+      10,
+      250,
+      100,
+      true,
+      4 /* nThreads */,
+      true /* useTicketKeySeeds */);
   auto constexpr nConnAttempts = 10;
 
   for (int i = 0; i < nConnAttempts; i++) {

mcrouter/lib/network/test/TestClientServerUtil.cpp

@@ -20,6 +20,7 @@
 #include <folly/fibers/EventBaseLoopController.h>
 #include <folly/fibers/FiberManager.h>
 #include <folly/io/async/EventBase.h>
+#include <wangle/ssl/TLSTicketKeySeeds.h>
 
 #include "mcrouter/lib/IOBufUtil.h"
 #include "mcrouter/lib/fbi/cpp/util.h"
@@ -142,8 +143,9 @@ TestServer::TestServer(
     int timeoutMs,
     size_t maxConns,
     bool useDefaultVersion,
-    size_t numThreads)
-    : outOfOrder_(outOfOrder) {
+    size_t numThreads,
+    bool useTicketKeySeeds)
+    : outOfOrder_(outOfOrder), useTicketKeySeeds_(useSsl && useTicketKeySeeds) {
   opts_.existingSocketFd = sock_.getSocketFd();
   opts_.numThreads = numThreads;
   opts_.worker.defaultVersionHandler = useDefaultVersion;
@@ -161,6 +163,12 @@ void TestServer::run(std::function<void(AsyncMcServerWorker&)> init) {
   LOG(INFO) << "Spawning AsyncMcServer";
 
   server_ = folly::make_unique<AsyncMcServer>(opts_);
+  if (useTicketKeySeeds_) {
+    wangle::TLSTicketKeySeeds seeds{
+        .oldSeeds = {"aaaa"}, .currentSeeds = {"bbbb"}, .newSeeds = {"cccc"},
+    };
+    server_->setTicketKeySeeds(std::move(seeds));
+  }
   server_->spawn(
       [this, init](size_t, folly::EventBase& evb, AsyncMcServerWorker& worker) {
         init(worker);

mcrouter/lib/network/test/TestClientServerUtil.h

@@ -77,15 +77,17 @@ class TestServer {
       int timeoutMs = 250,
       size_t maxConns = 100,
       bool useDefaultVersion = false,
-      size_t numThreads = 1) {
+      size_t numThreads = 1,
+      bool useTicketKeySeeds = false) {
     std::unique_ptr<TestServer> server(new TestServer(
         outOfOrder,
         useSsl,
         maxInflight,
         timeoutMs,
         maxConns,
         useDefaultVersion,
-        numThreads));
+        numThreads,
+        useTicketKeySeeds));
     server->run([& s = *server](AsyncMcServerWorker & worker) {
       worker.setOnRequest(
           MemcacheRequestHandler<OnRequest>(s.shutdown_, s.outOfOrder_));
@@ -116,6 +118,7 @@ class TestServer {
   AsyncMcServer::Options opts_;
   std::unique_ptr<AsyncMcServer> server_;
   bool outOfOrder_{false};
+  bool useTicketKeySeeds_{false};
   std::atomic<bool> shutdown_{false};
   std::atomic<size_t> acceptedConns_{0};
 
@@ -126,7 +129,8 @@ class TestServer {
       int timeoutMs,
       size_t maxConns,
       bool useDefaultVersion,
-      size_t numThreads);
+      size_t numThreads,
+      bool useTicketKeySeeds);
 
   void run(std::function<void(AsyncMcServerWorker&)> init);
 };

mcrouter/standalone_options_list.h

@@ -39,6 +39,12 @@ MCROUTER_OPTION_OTHER(
     no_short,
     "SSL Port(s) to listen on (comma separated)")
 
+MCROUTER_OPTION_STRING(
+  tls_ticket_key_seed_path, "",
+  "tls-ticket-key-seed-path", no_short,
+  "Path to file containing JSON object for old, current, and new seeds"
+  " used to generate TLS ticket keys")
+
 MCROUTER_OPTION_INTEGER(
     int,
     listen_sock_fd,