TLSTicketKeyManager.h

Go to the documentation of this file.

/*
 * Copyright 2017-present Facebook, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once

#include <folly/io/async/SSLContext.h>
#include <folly/io/async/EventBase.h>

namespace wangle {

#ifndef SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB
class TLSTicketKeyManager {};
#else
class SSLStats;
class TLSTicketKeyManager : private boost::noncopyable {
 public:
  explicit TLSTicketKeyManager(
      folly::SSLContext* ctx,
      SSLStats* stats);

  virtual ~TLSTicketKeyManager();

  static int callback(SSL* ssl, unsigned char* keyName,
                      unsigned char* iv,
                      EVP_CIPHER_CTX* cipherCtx,
                      HMAC_CTX* hmacCtx, int encrypt);

  bool setTLSTicketKeySeeds(const std::vector<std::string>& oldSeeds,
                            const std::vector<std::string>& currentSeeds,
                            const std::vector<std::string>& newSeeds);

  bool getTLSTicketKeySeeds(std::vector<std::string>& oldSeeds,
                            std::vector<std::string>& currentSeeds,
                            std::vector<std::string>& newSeeds) const;

  struct Unsafe {
    TLSTicketKeyManager* obj;
    int processTicket(SSL* ssl,
                      uint8_t* keyName,
                      uint8_t* iv,
                      EVP_CIPHER_CTX* cipherCtx,
                      HMAC_CTX* hmacCtx,
                      int encrypt) {
      return CHECK_NOTNULL(obj)
        ->processTicket(ssl, keyName, iv, cipherCtx, hmacCtx, encrypt);
    }
  };

  Unsafe unsafe() { return Unsafe{this}; }

 private:
  enum TLSTicketSeedType {
    SEED_OLD = 0,
    SEED_CURRENT,
    SEED_NEW
  };

  /* The seeds supplied by the configuration */
  struct TLSTicketSeed {
    std::string seed_;
    TLSTicketSeedType type_;
    unsigned char seedName_[SHA256_DIGEST_LENGTH];
  };

  struct TLSTicketKeySource {
    int32_t hashCount_;
    std::string keyName_;
    TLSTicketSeedType type_;
    unsigned char keySource_[SHA256_DIGEST_LENGTH];
  };

  int processTicket(SSL* ssl, unsigned char* keyName,
                    unsigned char* iv,
                    EVP_CIPHER_CTX* cipherCtx,
                    HMAC_CTX* hmacCtx, int encrypt);

  // Creates the name for the nth key generated from seed
  std::string makeKeyName(TLSTicketSeed* seed, uint32_t n,
                          unsigned char* nameBuf);

  TLSTicketKeySource* insertNewKey(TLSTicketSeed* seed, uint32_t hashCount,
                                   TLSTicketKeySource* prevKeySource);

  void hashNth(const unsigned char* input, size_t input_len,
               unsigned char* output, uint32_t n);

  TLSTicketSeed* insertSeed(const std::string& seedInput,
                            TLSTicketSeedType type);

  TLSTicketKeySource* findEncryptionKey();

  TLSTicketKeySource* findDecryptionKey(unsigned char* keyName);

  void recordTlsTicketRotation(
      const std::vector<std::string>& oldSeeds,
      const std::vector<std::string>& currentSeeds,
      const std::vector<std::string>& newSeeds);

  void makeUniqueKeys(unsigned char* parentKey, size_t keyLen,
                      unsigned char* salt, unsigned char* output);

  typedef std::vector<std::unique_ptr<TLSTicketSeed>> TLSTicketSeedList;
  typedef std::map<std::string, std::unique_ptr<TLSTicketKeySource> >
    TLSTicketKeyMap;
  typedef std::vector<TLSTicketKeySource *> TLSActiveKeyList;

  TLSTicketSeedList ticketSeeds_;
  // All key sources that can be used for decryption
  TLSTicketKeyMap ticketKeys_;
  // Key sources that can be used for encryption
  TLSActiveKeyList activeKeys_;

  folly::SSLContext* ctx_;
  SSLStats* stats_{nullptr};

  static int32_t sExDataIndex_;
};
#endif

} // namespace wangle