fizz::Protocol Class Reference

#include <Protocol.h>

Static Public Member Functions
template<typename Type >
static void	setAead (Type &recordLayer, CipherSuite cipher, folly::ByteRange secret, const Factory &factory, const KeyScheduler &scheduler)
static Buf	getFinished (folly::ByteRange handshakeWriteSecret, HandshakeContext &handshakeContext)
static Buf	getKeyUpdated (KeyUpdateRequest request_update)
static void	checkAllowedExtensions (const EncryptedExtensions &ee, const std::vector< ExtensionType > &requestedExtensions)
static void	checkAllowedExtensions (const ServerHello &shlo, const std::vector< ExtensionType > &requestedExtensions)
static void	checkAllowedExtensions (const HelloRetryRequest &hrr)
static void	checkDuplicateExtensions (const std::vector< Extension > &exts)

Detailed Description

Definition at line 17 of file Protocol.h.

Member Function Documentation

static void fizz::Protocol::checkAllowedExtensions ( const EncryptedExtensions &  ee, const std::vector< ExtensionType > &  requestedExtensions  )

inlinestatic

Definition at line 50 of file Protocol.h.

References checkDuplicateExtensions(), fizz::cookie, fizz::EncryptedExtensions::extensions, fizz::illegal_parameter, fizz::key_share, fizz::key_share_old, fizz::pre_shared_key, fizz::psk_key_exchange_modes, fizz::signature_algorithms, fizz::supported_versions, and fizz::toString().

Referenced by fizz::sm::getHrrKeyExchangers(), fizz::sm::negotiatePsk(), and fizz::sm::validateAcceptedEarly().

                                                           {
    for (const auto& ext : ee.extensions) {
      // These extensions are not allowed in EE
      switch (ext.extension_type) {
        case ExtensionType::signature_algorithms:
        case ExtensionType::key_share:
        case ExtensionType::key_share_old:
        case ExtensionType::pre_shared_key:
        case ExtensionType::psk_key_exchange_modes:
        case ExtensionType::cookie:
        case ExtensionType::supported_versions:
          throw FizzException(
              "unexpected extension in ee: " + toString(ext.extension_type),
              AlertDescription::illegal_parameter);
        default:
          if (std::find(
                  requestedExtensions.begin(),
                  requestedExtensions.end(),
                  ext.extension_type) == requestedExtensions.end()) {
            throw FizzException(
                "unexpected extension in ee: " + toString(ext.extension_type),
                AlertDescription::illegal_parameter);
          }
          break;
      }
    }
    checkDuplicateExtensions(ee.extensions);
  }

static void fizz::Protocol::checkAllowedExtensions ( const ServerHello &  shlo, const std::vector< ExtensionType > &  requestedExtensions  )

inlinestatic

Definition at line 81 of file Protocol.h.

References checkDuplicateExtensions(), fizz::ServerHello::extensions, fizz::illegal_parameter, fizz::key_share, fizz::key_share_old, fizz::pre_shared_key, fizz::supported_versions, and fizz::toString().

                                                           {
    for (const auto& ext : shlo.extensions) {
      if (std::find(
              requestedExtensions.begin(),
              requestedExtensions.end(),
              ext.extension_type) == requestedExtensions.end() ||
          (ext.extension_type != ExtensionType::key_share &&
           ext.extension_type != ExtensionType::key_share_old &&
           ext.extension_type != ExtensionType::pre_shared_key &&
           ext.extension_type != ExtensionType::supported_versions)) {
        throw FizzException(
            "unexpected extension in shlo: " + toString(ext.extension_type),
            AlertDescription::illegal_parameter);
      }
    }
    checkDuplicateExtensions(shlo.extensions);
  }

static void fizz::Protocol::checkAllowedExtensions ( const HelloRetryRequest &  hrr )

inlinestatic

Definition at line 101 of file Protocol.h.

References checkDuplicateExtensions(), fizz::cookie, fizz::HelloRetryRequest::extensions, fizz::illegal_parameter, fizz::key_share, fizz::key_share_old, fizz::supported_versions, and fizz::toString().

                                                                   {
    // HRR is allowed to send 'cookie' unprompted. Otherwise only other allowed
    // extensions are key_share and supported_versions, which we always send.
    for (const auto& ext : hrr.extensions) {
      if (ext.extension_type != ExtensionType::cookie &&
          ext.extension_type != ExtensionType::key_share &&
          ext.extension_type != ExtensionType::key_share_old &&
          ext.extension_type != ExtensionType::supported_versions) {
        throw FizzException(
            "unexpected extension in hrr: " + toString(ext.extension_type),
            AlertDescription::illegal_parameter);
      }
    }
    checkDuplicateExtensions(hrr.extensions);
  }

static void fizz::Protocol::checkDuplicateExtensions ( const std::vector< Extension > &  exts )

inlinestatic

Definition at line 117 of file Protocol.h.

References fizz::illegal_parameter.

Referenced by checkAllowedExtensions(), and fizz::sm::validateClientHello().

                                                                         {
    std::vector<ExtensionType> extensionList;
    for (const auto& extension : exts) {
      extensionList.push_back(extension.extension_type);
    }
    std::sort(extensionList.begin(), extensionList.end());
    if (std::unique(extensionList.begin(), extensionList.end()) !=
        extensionList.end()) {
      throw FizzException(
          "duplicate extension", AlertDescription::illegal_parameter);
    }
  }

static Buf fizz::Protocol::getFinished ( folly::ByteRange  handshakeWriteSecret, HandshakeContext &  handshakeContext  )

inlinestatic

Definition at line 33 of file Protocol.h.

References fizz::HandshakeContext::appendToTranscript(), fizz::encodeHandshake(), fizz::finished, fizz::HandshakeContext::getFinishedData(), folly::gen::move, and fizz::Finished::verify_data.

Referenced by fizz::sm::getCertificateRequest(), and fizz::sm::handleCertMsg().

                                          {
    Finished finished;
    finished.verify_data =
        handshakeContext.getFinishedData(handshakeWriteSecret);
    auto encodedFinished = encodeHandshake(std::move(finished));
    handshakeContext.appendToTranscript(encodedFinished);
    return encodedFinished;
  }

static Buf fizz::Protocol::getKeyUpdated ( KeyUpdateRequest  request_update )

inlinestatic

Definition at line 44 of file Protocol.h.

References fizz::encodeHandshake(), folly::gen::move, and fizz::KeyUpdate::request_update.

Referenced by fizz::sm::generateTicket(), and fizz::sm::getMaxEarlyDataSize().

                                                            {
    KeyUpdate keyUpdated;
    keyUpdated.request_update = request_update;
    return encodeHandshake(std::move(keyUpdated));
  }

template<typename Type >

static void fizz::Protocol::setAead ( Type &  recordLayer, CipherSuite  cipher, folly::ByteRange  secret, const Factory &  factory, const KeyScheduler &  scheduler  )

inlinestatic

Definition at line 20 of file Protocol.h.

References fizz::KeyScheduler::getTrafficKey(), fizz::Factory::makeAead(), and folly::gen::move.

Referenced by fizz::sm::generateTicket(), fizz::sm::getCertificateRequest(), fizz::sm::getEarlyDataParams(), fizz::sm::getMaxEarlyDataSize(), fizz::sm::handleCertMsg(), and fizz::sm::negotiatePsk().

                                     {
    auto aead = factory.makeAead(cipher);
    auto trafficKey =
        scheduler.getTrafficKey(secret, aead->keyLength(), aead->ivLength());
    aead->setKey(std::move(trafficKey));
    recordLayer.setAead(secret, std::move(aead));
  }

---

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

• proxygen/fizz/fizz/protocol/Protocol.h