fizz::server::AeadTokenCipher< AeadType, HkdfType > Class Template Reference

#include <AeadTokenCipher.h>

Public Member Functions
	AeadTokenCipher (std::vector< std::string > contextStrings)
	~AeadTokenCipher ()
bool	setSecrets (const std::vector< folly::ByteRange > &tokenSecrets)
folly::Optional< Buf >	encrypt (Buf plaintext) const
folly::Optional< Buf >	decrypt (Buf) const

Static Public Attributes
static constexpr size_t	kMinTokenSecretLength = 32

Private Types
using	Secret = std::vector< uint8_t >
using	Salt = std::array< uint8_t, kSaltLength >
using	SeqNum = uint32_t

Private Member Functions
AeadType	createAead (folly::ByteRange secret, folly::ByteRange salt) const
void	clearSecrets ()

Private Attributes
std::vector< Secret >	secrets_
std::vector< std::string >	contextStrings_

Static Private Attributes
static constexpr size_t	kSaltLength = HkdfType::HashLen
static constexpr size_t	kTokenHeaderLength = kSaltLength + sizeof(SeqNum)

Detailed Description

template<typename AeadType, typename HkdfType>
class fizz::server::AeadTokenCipher< AeadType, HkdfType >

Used to encrypt and decrypt various tokens (for example PSKs).

Definition at line 22 of file AeadTokenCipher.h.

Member Typedef Documentation

template<typename AeadType, typename HkdfType>

using fizz::server::AeadTokenCipher< AeadType, HkdfType >::Salt = std::array<uint8_t, kSaltLength>

private

Definition at line 53 of file AeadTokenCipher.h.

template<typename AeadType, typename HkdfType>

using fizz::server::AeadTokenCipher< AeadType, HkdfType >::Secret = std::vector<uint8_t>

private

Definition at line 51 of file AeadTokenCipher.h.

template<typename AeadType, typename HkdfType>

using fizz::server::AeadTokenCipher< AeadType, HkdfType >::SeqNum = uint32_t

private

Definition at line 54 of file AeadTokenCipher.h.

Constructor & Destructor Documentation

template<typename AeadType, typename HkdfType>

fizz::server::AeadTokenCipher< AeadType, HkdfType >::AeadTokenCipher ( std::vector< std::string >  contextStrings )

inlineexplicit

Set additional context strings for use with these tokens. The strings will be used, in order, as part of the key derivation so that different contexts will result in different keys, preventing keys from one context from being used for another.

Definition at line 32 of file AeadTokenCipher.h.

      : contextStrings_(std::move(contextStrings)) {}

template<typename AeadType, typename HkdfType>

fizz::server::AeadTokenCipher< AeadType, HkdfType >::~AeadTokenCipher ( )

inline

Definition at line 35 of file AeadTokenCipher.h.

References fizz::server::AeadTokenCipher< AeadType, HkdfType >::clearSecrets(), fizz::server::AeadTokenCipher< AeadType, HkdfType >::decrypt(), fizz::server::AeadTokenCipher< AeadType, HkdfType >::encrypt(), and fizz::server::AeadTokenCipher< AeadType, HkdfType >::setSecrets().

                     {
    clearSecrets();
  }

Member Function Documentation

template<typename AeadType , typename HkdfType >

void fizz::server::AeadTokenCipher< AeadType, HkdfType >::clearSecrets ( )

private

Definition at line 125 of file AeadTokenCipher-inl.h.

References fizz::CryptoUtils::clean(), folly::range(), and secret.

Referenced by fizz::server::AeadTokenCipher< AeadType, HkdfType >::~AeadTokenCipher().

                                                       {
  for (auto& secret : secrets_) {
    CryptoUtils::clean(folly::range(secret));
  }
  secrets_.clear();
}

template<typename AeadType , typename HkdfType >

AeadType fizz::server::AeadTokenCipher< AeadType, HkdfType >::createAead ( folly::ByteRange  secret, folly::ByteRange  salt  ) const

private

Definition at line 109 of file AeadTokenCipher-inl.h.

References deadlock::info(), folly::gen::move, and folly::IOBuf::wrapBuffer().

                               {
  AeadType aead;
  std::unique_ptr<folly::IOBuf> info = folly::IOBuf::wrapBuffer(salt);
  auto keys =
      HkdfType().expand(secret, *info, aead.keyLength() + aead.ivLength());
  folly::io::Cursor cursor(keys.get());
  TrafficKey key;
  cursor.clone(key.key, aead.keyLength());
  cursor.clone(key.iv, aead.ivLength());
  aead.setKey(std::move(key));
  return aead;
}

template<typename AeadType , typename HkdfType >

folly::Optional< Buf > fizz::server::AeadTokenCipher< AeadType, HkdfType >::decrypt

(

Buf

token

)

const

Definition at line 83 of file AeadTokenCipher-inl.h.

References folly::gen::move, folly::none, folly::range(), and secret.

Referenced by fizz::server::AeadTokenCipher< AeadType, HkdfType >::~AeadTokenCipher().

                     {
  folly::io::Cursor cursor(token.get());
  if (secrets_.empty() || !cursor.canAdvance(kTokenHeaderLength)) {
    return folly::none;
  }

  Salt salt;
  cursor.pull(salt.data(), salt.size());
  auto seqNum = cursor.readBE<SeqNum>();
  Buf ciphertext;
  cursor.clone(ciphertext, cursor.totalLength());

  for (const auto& secret : secrets_) {
    auto aead = createAead(folly::range(secret), folly::range(salt));
    auto result = aead.tryDecrypt(ciphertext->clone(), nullptr, seqNum);
    if (result) {
      return std::move(result);
    }
  }

  VLOG(6) << "Failed to decrypt token.";
  return folly::none;
}

template<typename AeadType , typename HkdfType >

folly::Optional< Buf > fizz::server::AeadTokenCipher< AeadType, HkdfType >::encrypt

(

Buf

plaintext

)

const

Definition at line 62 of file AeadTokenCipher-inl.h.

References folly::IOBuf::create(), folly::gen::move, folly::none, folly::io::detail::Writable< Derived >::push(), and folly::range().

Referenced by fizz::server::AeadTokenCipher< AeadType, HkdfType >::~AeadTokenCipher().

                         {
  if (secrets_.empty()) {
    return folly::none;
  }

  auto salt = RandomGenerator<kSaltLength>().generateRandom();
  auto aead = createAead(folly::range(secrets_.front()), folly::range(salt));

  // For now we always use sequence number 0.
  SeqNum seqNum = 0;
  auto token = folly::IOBuf::create(kTokenHeaderLength);
  folly::io::Appender appender(token.get(), kTokenHeaderLength);
  appender.push(folly::range(salt));
  appender.writeBE(seqNum);
  token->prependChain(aead.encrypt(std::move(plaintext), nullptr, seqNum));

  return std::move(token);
}

template<typename AeadType , typename HkdfType >

bool fizz::server::AeadTokenCipher< AeadType, HkdfType >::setSecrets

(

const std::vector< folly::ByteRange > &

tokenSecrets

)

Set secrets to use for token encryption/decryption. The first one will be used for encryption. All secrets must be at least kMinTokenSecretLength long.

Definition at line 37 of file AeadTokenCipher-inl.h.

References folly::gen::move, and folly::range().

Referenced by fizz::server::AeadTokenCipher< AeadType, HkdfType >::~AeadTokenCipher().

                                                   {
  VLOG(3) << "Updating token secrets";

  for (const auto& tokenSecret : tokenSecrets) {
    if (tokenSecret.size() < kMinTokenSecretLength) {
      LOG(ERROR) << "Token cipher secret too small - not updating.";
      return false;
    }
  }

  VLOG(4) << "Updating token secrets, num=" << tokenSecrets.size();
  clearSecrets();
  for (const auto& tokenSecret : tokenSecrets) {
    Secret extracted(tokenSecret.begin(), tokenSecret.end());
    for (const auto& contextString : contextStrings_) {
      extracted = HkdfType().extract(
          folly::range(contextString), folly::range(extracted));
    }
    secrets_.push_back(std::move(extracted));
  }
  return true;
}

Member Data Documentation

template<typename AeadType, typename HkdfType>

std::vector<std::string> fizz::server::AeadTokenCipher< AeadType, HkdfType >::contextStrings_

private

Definition at line 64 of file AeadTokenCipher.h.

template<typename AeadType, typename HkdfType>

constexpr size_t fizz::server::AeadTokenCipher< AeadType, HkdfType >::kMinTokenSecretLength = 32

static

Definition at line 24 of file AeadTokenCipher.h.

template<typename AeadType, typename HkdfType>

constexpr size_t fizz::server::AeadTokenCipher< AeadType, HkdfType >::kSaltLength = HkdfType::HashLen

staticprivate

Definition at line 52 of file AeadTokenCipher.h.

template<typename AeadType, typename HkdfType>

constexpr size_t fizz::server::AeadTokenCipher< AeadType, HkdfType >::kTokenHeaderLength = kSaltLength + sizeof(SeqNum)

staticprivate

Definition at line 55 of file AeadTokenCipher.h.

template<typename AeadType, typename HkdfType>

std::vector<Secret> fizz::server::AeadTokenCipher< AeadType, HkdfType >::secrets_

private

Definition at line 62 of file AeadTokenCipher.h.

---

The documentation for this class was generated from the following files:

• proxygen/fizz/fizz/server/AeadTokenCipher.h
• proxygen/fizz/fizz/server/AeadTokenCipher-inl.h