fizz::ReadRecordLayer Class Reference

#include <RecordLayer.h>

Inheritance diagram for fizz::ReadRecordLayer:

Public Member Functions
virtual	~ReadRecordLayer ()=default
virtual folly::Optional< TLSMessage >	read (folly::IOBufQueue &buf)=0
virtual folly::Optional< Param >	readEvent (folly::IOBufQueue &socketBuf)
virtual bool	hasUnparsedHandshakeData () const
virtual EncryptionLevel	getEncryptionLevel () const =0

Static Public Member Functions
static folly::Optional< Param >	decodeHandshakeMessage (folly::IOBufQueue &buf)

Private Attributes
folly::IOBufQueue	unparsedHandshakeData_

Detailed Description

Definition at line 24 of file RecordLayer.h.

Constructor & Destructor Documentation

virtual fizz::ReadRecordLayer::~ReadRecordLayer ( )

virtualdefault

Member Function Documentation

folly::Optional< Param > fizz::ReadRecordLayer::decodeHandshakeMessage ( folly::IOBufQueue &  buf )

static

Definition at line 93 of file RecordLayer.cpp.

References fizz::certificate, fizz::certificate_request, fizz::certificate_verify, folly::IOBufQueue::chainLength(), fizz::client_hello, fizz::compressed_certificate, fizz::encrypted_extensions, fizz::end_of_early_data, fizz::finished, folly::IOBufQueue::front(), fizz::key_update, fizz::kMaxHandshakeSize, folly::gen::move, fizz::new_session_ticket, folly::none, fizz::parse< ServerHello >(), fizz::detail::readBits24(), fizz::server_hello, and folly::IOBufQueue::split().

Referenced by fizz::ExportedAuthenticator::getAuthenticatorContext(), readEvent(), and fizz::ExportedAuthenticator::validate().

                          {
  folly::io::Cursor cursor(buf.front());

  if (!cursor.canAdvance(kHandshakeHeaderSize)) {
    return folly::none;
  }

  auto handshakeType =
      static_cast<HandshakeType>(cursor.readBE<HandshakeTypeType>());
  auto length = detail::readBits24(cursor);

  if (length > kMaxHandshakeSize) {
    throw std::runtime_error("handshake record too big");
  }
  if (buf.chainLength() < (cursor - buf.front()) + length) {
    return folly::none;
  }

  Buf handshakeMsg;
  cursor.clone(handshakeMsg, length);
  auto original = buf.split(kHandshakeHeaderSize + length);

  switch (handshakeType) {
    case HandshakeType::client_hello:
      return parse<ClientHello>(std::move(handshakeMsg), std::move(original));
    case HandshakeType::server_hello:
      return parse<ServerHello>(std::move(handshakeMsg), std::move(original));
    case HandshakeType::end_of_early_data:
      return parse<EndOfEarlyData>(
          std::move(handshakeMsg), std::move(original));
    case HandshakeType::new_session_ticket:
      return parse<NewSessionTicket>(
          std::move(handshakeMsg), std::move(original));
    case HandshakeType::encrypted_extensions:
      return parse<EncryptedExtensions>(
          std::move(handshakeMsg), std::move(original));
    case HandshakeType::certificate:
      return parse<CertificateMsg>(
          std::move(handshakeMsg), std::move(original));
    case HandshakeType::compressed_certificate:
      return parse<CompressedCertificate>(
          std::move(handshakeMsg), std::move(original));
    case HandshakeType::certificate_request:
      return parse<CertificateRequest>(
          std::move(handshakeMsg), std::move(original));
    case HandshakeType::certificate_verify:
      return parse<CertificateVerify>(
          std::move(handshakeMsg), std::move(original));
    case HandshakeType::finished:
      return parse<Finished>(std::move(handshakeMsg), std::move(original));
    case HandshakeType::key_update:
      return parse<KeyUpdate>(std::move(handshakeMsg), std::move(original));
    default:
      throw std::runtime_error("unknown handshake type");
  };
}

virtual EncryptionLevel fizz::ReadRecordLayer::getEncryptionLevel ( ) const

pure virtual

Returns the current encryption level of the data that the read record layer can process.

Implemented in fizz::EncryptedReadRecordLayer, and fizz::PlaintextReadRecordLayer.

bool fizz::ReadRecordLayer::hasUnparsedHandshakeData ( ) const

virtual

Check if there is decrypted but unparsed handshake data buffered.

Definition at line 151 of file RecordLayer.cpp.

References folly::IOBufQueue::empty(), and unparsedHandshakeData_.

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

                                                     {
  return !unparsedHandshakeData_.empty();
}

virtual folly::Optional<TLSMessage> fizz::ReadRecordLayer::read ( folly::IOBufQueue &  buf )

pure virtual

Reads a fragment from the record layer. Returns an empty optional if insuficient data available. Throws if data malformed. On success, advances buf the amount read.

Implemented in fizz::EncryptedReadRecordLayer, and fizz::PlaintextReadRecordLayer.

Referenced by readEvent().

folly::Optional< Param > fizz::ReadRecordLayer::readEvent ( folly::IOBufQueue &  socketBuf )

virtual

Get a message from the record layer. Returns none if insufficient data was available on the socket. Throws on parse error.

Definition at line 18 of file RecordLayer.cpp.

References fizz::alert, fizz::AppData, folly::IOBufQueue::append(), fizz::application_data, folly::apply_visitor(), decodeHandshakeMessage(), folly::IOBufQueue::empty(), fizz::handshake, folly::gen::move, folly::none, read(), fizz::toString(), message::type, and unparsedHandshakeData_.

Referenced by fizz::server::AeadCookieCipher< AeadType, HkdfType >::getTokenOrRetry(), fizz::client::ClientStateMachine::processSocketData(), and fizz::server::ServerStateMachine::processSocketData().

                                {
  if (!unparsedHandshakeData_.empty()) {
    auto param = decodeHandshakeMessage(unparsedHandshakeData_);
    if (param) {
      VLOG(8) << "Received handshake message "
              << toString(boost::apply_visitor(EventVisitor(), *param));
      return param;
    }
  }

  while (true) {
    // Read one record. We read one record at a time since records could cause
    // a change in the record layer.
    auto message = read(socketBuf);
    if (!message) {
      return folly::none;
    }

    if (!unparsedHandshakeData_.empty() &&
        message->type != ContentType::handshake) {
      throw std::runtime_error("spliced handshake data");
    }

    switch (message->type) {
      case ContentType::alert:
        return Param(decode<Alert>(std::move(message->fragment)));
      case ContentType::handshake: {
        unparsedHandshakeData_.append(std::move(message->fragment));
        auto param = decodeHandshakeMessage(unparsedHandshakeData_);
        if (param) {
          VLOG(8) << "Received handshake message "
                  << toString(boost::apply_visitor(EventVisitor(), *param));
          return param;
        } else {
          // If we read handshake data but didn't have enough to get a full
          // message we immediately try to read another record.
          // TODO: add limits on number of records we buffer
          continue;
        }
      }
      case ContentType::application_data:
        return Param(AppData(std::move(message->fragment)));
      default:
        throw std::runtime_error("unknown content type");
    }
  }
}

Member Data Documentation

folly::IOBufQueue fizz::ReadRecordLayer::unparsedHandshakeData_

private

Initial value:

{
      folly::IOBufQueue::cacheChainLength()}

Definition at line 55 of file RecordLayer.h.

Referenced by hasUnparsedHandshakeData(), and readEvent().

---

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

• proxygen/fizz/fizz/record/RecordLayer.h
• proxygen/fizz/fizz/record/RecordLayer.cpp