State.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2018-present, Facebook, Inc.
 *  All rights reserved.
 *
 *  This source code is licensed under the BSD-style license found in the
 *  LICENSE file in the root directory of this source tree.
 */

#pragma once

#include <fizz/client/ClientExtensions.h>
#include <fizz/client/FizzClientContext.h>
#include <fizz/protocol/Certificate.h>
#include <fizz/protocol/KeyScheduler.h>
#include <fizz/protocol/Types.h>
#include <fizz/record/RecordLayer.h>

namespace fizz {
namespace client {

enum class StateEnum {
  Uninitialized,
  ExpectingServerHello,
  ExpectingEncryptedExtensions,
  ExpectingCertificate,
  ExpectingCertificateVerify,
  ExpectingFinished,
  Established,
  Error,
  NUM_STATES
};

enum class ClientAuthType { NotRequested, Sent, RequestedNoMatch, Stored };

struct EarlyDataParams {
  ProtocolVersion version;
  CipherSuite cipher;
  std::shared_ptr<const Cert> serverCert;
  std::shared_ptr<const Cert> clientCert;
  folly::Optional<std::string> alpn;
  Buf earlyExporterSecret;
};

class State {
 public:
  StateEnum state() const {
    return state_;
  }

  const FizzClientContext* context() const {
    return context_.get();
  }

  std::shared_ptr<const Cert> serverCert() const {
    return serverCert_;
  }

  std::shared_ptr<const Cert> clientCert() const {
    return clientCert_;
  }

  folly::Optional<ClientAuthType> clientAuthRequested() const {
    return clientAuthRequested_;
  }

  folly::Optional<SignatureScheme> clientAuthSigScheme() const {
    return clientAuthSigScheme_;
  }

  folly::Optional<ProtocolVersion> version() const {
    return version_;
  }

  folly::Optional<CipherSuite> cipher() const {
    return cipher_;
  }

  folly::Optional<NamedGroup> group() const {
    return group_;
  }

  folly::Optional<SignatureScheme> sigScheme() const {
    return sigScheme_;
  }

  folly::Optional<PskType> pskType() const {
    return pskType_;
  }

  folly::Optional<PskKeyExchangeMode> pskMode() const {
    return pskMode_;
  }

  folly::Optional<KeyExchangeType> keyExchangeType() const {
    return keyExchangeType_;
  }

  folly::Optional<EarlyDataType> earlyDataType() const {
    return earlyDataType_;
  }

  const folly::Optional<EarlyDataParams>& earlyDataParams() const {
    return earlyDataParams_;
  }

  const folly::Optional<std::string>& alpn() const {
    return alpn_;
  }

  const folly::Optional<std::string>& sni() const {
    return sni_;
  }

  const folly::Optional<CertificateCompressionAlgorithm>& serverCertCompAlgo()
      const {
    return serverCertCompAlgo_;
  }

  const CertificateVerifier* verifier() const {
    return verifier_.get();
  }

  const Random& clientRandom() const {
    return *clientRandom_;
  }

  const Buf& legacySessionId() const {
    return *legacySessionId_;
  }

  bool sentCCS() const {
    return sentCCS_;
  }

  KeyScheduler* keyScheduler() const {
    return keyScheduler_.get();
  }

  ReadRecordLayer* readRecordLayer() const {
    return readRecordLayer_.get();
  }

  const WriteRecordLayer* writeRecordLayer() const {
    return writeRecordLayer_.get();
  }

  const WriteRecordLayer* earlyWriteRecordLayer() const {
    return earlyWriteRecordLayer_.get();
  }

  const Buf& encodedClientHello() const {
    return *encodedClientHello_;
  }

  const folly::Optional<std::vector<ExtensionType>>& requestedExtensions()
      const {
    return requestedExtensions_;
  }

  const Buf& clientHandshakeSecret() const {
    return *clientHandshakeSecret_;
  }

  const Buf& serverHandshakeSecret() const {
    return *serverHandshakeSecret_;
  }

  const Buf& resumptionSecret() const {
    return *resumptionSecret_;
  }

  const std::vector<std::shared_ptr<const PeerCert>>& unverifiedCertChain()
      const {
    return *unverifiedCertChain_;
  }

  std::shared_ptr<const SelfCert> selectedClientCert() const {
    return selectedClientCert_;
  }

  const folly::Optional<Buf>& exporterMasterSecret() const {
    return exporterMasterSecret_;
  }

  const folly::Optional<CachedPsk>& attemptedPsk() const {
    return attemptedPsk_;
  }

  /*
   * Get the extensions interface to add extensions to ClientHello and check the
   * extensions negotiated by server.
   */
  ClientExtensions* extensions() const {
    return extensions_.get();
  }

  auto& state() {
    return state_;
  }

  auto& context() {
    return context_;
  }

  auto& verifier() {
    return verifier_;
  }

  auto& keyScheduler() {
    return keyScheduler_;
  }

  auto& readRecordLayer() {
    return readRecordLayer_;
  }

  auto& writeRecordLayer() {
    return writeRecordLayer_;
  }

  auto& earlyWriteRecordLayer() {
    return earlyWriteRecordLayer_;
  }

  auto& handshakeContext() const {
    return handshakeContext_;
  }

  auto& serverCert() {
    return serverCert_;
  }

  auto& clientCert() {
    return clientCert_;
  }

  auto& selectedClientCert() {
    return selectedClientCert_;
  }

  auto& clientAuthRequested() {
    return clientAuthRequested_;
  }

  auto& clientAuthSigScheme() {
    return clientAuthSigScheme_;
  }

  auto& version() {
    return version_;
  }

  auto& cipher() {
    return cipher_;
  }

  auto& group() {
    return group_;
  }

  auto& sigScheme() {
    return sigScheme_;
  }

  auto& pskType() {
    return pskType_;
  }

  auto& pskMode() {
    return pskMode_;
  }

  auto& keyExchangeType() {
    return keyExchangeType_;
  }

  auto& earlyDataType() {
    return earlyDataType_;
  }

  auto& earlyDataParams() {
    return earlyDataParams_;
  }

  auto& alpn() {
    return alpn_;
  }

  auto& sni() {
    return sni_;
  }

  auto& serverCertCompAlgo() {
    return serverCertCompAlgo_;
  }

  auto& clientRandom() {
    return clientRandom_;
  }

  auto& legacySessionId() {
    return legacySessionId_;
  }

  auto& sentCCS() {
    return sentCCS_;
  }

  auto& encodedClientHello() {
    return encodedClientHello_;
  }

  auto& keyExchangers() const {
    return keyExchangers_;
  }

  auto& requestedExtensions() {
    return requestedExtensions_;
  }

  auto& clientHandshakeSecret() {
    return clientHandshakeSecret_;
  }

  auto& serverHandshakeSecret() {
    return serverHandshakeSecret_;
  }

  auto& resumptionSecret() {
    return resumptionSecret_;
  }

  auto& unverifiedCertChain() {
    return unverifiedCertChain_;
  }

  auto& attemptedPsk() {
    return attemptedPsk_;
  }

  auto& exporterMasterSecret() {
    return exporterMasterSecret_;
  }

  auto& extensions() {
    return extensions_;
  }

 private:
  StateEnum state_{StateEnum::Uninitialized};

  std::shared_ptr<const FizzClientContext> context_;

  std::shared_ptr<const CertificateVerifier> verifier_;

  std::unique_ptr<KeyScheduler> keyScheduler_;

  std::unique_ptr<ReadRecordLayer> readRecordLayer_;
  std::unique_ptr<WriteRecordLayer> writeRecordLayer_;
  std::unique_ptr<EncryptedWriteRecordLayer> earlyWriteRecordLayer_;

  mutable std::unique_ptr<HandshakeContext> handshakeContext_;

  std::shared_ptr<const Cert> serverCert_;
  std::shared_ptr<const Cert> clientCert_;
  std::shared_ptr<const SelfCert> selectedClientCert_;

  folly::Optional<ClientAuthType> clientAuthRequested_;
  folly::Optional<SignatureScheme> clientAuthSigScheme_;

  folly::Optional<ProtocolVersion> version_;
  folly::Optional<CipherSuite> cipher_;
  folly::Optional<NamedGroup> group_;
  folly::Optional<SignatureScheme> sigScheme_;
  folly::Optional<PskType> pskType_;
  folly::Optional<PskKeyExchangeMode> pskMode_;
  folly::Optional<KeyExchangeType> keyExchangeType_;
  folly::Optional<EarlyDataType> earlyDataType_;
  folly::Optional<std::string> alpn_;
  folly::Optional<std::string> sni_;
  folly::Optional<CertificateCompressionAlgorithm> serverCertCompAlgo_;

  folly::Optional<EarlyDataParams> earlyDataParams_;

  folly::Optional<Random> clientRandom_;
  folly::Optional<Buf> legacySessionId_;
  bool sentCCS_{false};
  folly::Optional<Buf> encodedClientHello_;
  mutable folly::Optional<std::map<NamedGroup, std::unique_ptr<KeyExchange>>>
      keyExchangers_;
  folly::Optional<std::vector<ExtensionType>> requestedExtensions_;

  folly::Optional<Buf> clientHandshakeSecret_;
  folly::Optional<Buf> serverHandshakeSecret_;
  folly::Optional<Buf> resumptionSecret_;

  folly::Optional<std::vector<std::shared_ptr<const PeerCert>>>
      unverifiedCertChain_;
  folly::Optional<CachedPsk> attemptedPsk_;
  folly::Optional<Buf> exporterMasterSecret_;
  std::shared_ptr<ClientExtensions> extensions_;
};
} // namespace client

folly::StringPiece toString(client::StateEnum);
folly::StringPiece toString(client::ClientAuthType);

namespace client {
inline std::ostream& operator<<(std::ostream& os, StateEnum state) {
  os << toString(state);
  return os;
}

inline std::ostream& operator<<(std::ostream& os, ClientAuthType auth) {
  os << toString(auth);
  return os;
}
} // namespace client
} // namespace fizz