fizz::detail Namespace Reference

Classes
struct	bits24
class	OpenSSLECKeyDecoder
class	OpenSSLECKeyEncoder
class	OpenSSLECKeyExchange
struct	Reader
struct	Reader< CertificateEntry >
struct	Reader< DistinguishedName >
struct	Reader< Extension >
struct	Reader< KeyShareEntry >
struct	Reader< ProtocolName >
struct	Reader< PskBinder >
struct	Reader< PskIdentity >
struct	Reader< Random >
struct	Reader< ServerName >
struct	ReadVector
struct	ReadVector< bits24, T >
struct	Sizer
struct	Sizer< CertificateEntry >
struct	Sizer< DistinguishedName >
struct	Sizer< Extension >
struct	Sizer< KeyShareEntry >
struct	Sizer< ProtocolName >
struct	Sizer< PskBinder >
struct	Sizer< PskIdentity >
struct	Sizer< ServerName >
struct	Writer
struct	Writer< DistinguishedName >
struct	Writer< KeyShareEntry >
struct	Writer< ProtocolName >
struct	Writer< PskBinder >
struct	Writer< PskIdentity >
struct	Writer< Random >
struct	Writer< ServerName >
struct	WriterVector
struct	WriterVector< bits24, T >

Functions
folly::Optional< std::unique_ptr< folly::IOBuf > >	evpDecrypt (std::unique_ptr< folly::IOBuf > &&ciphertext, const folly::IOBuf *associatedData, folly::ByteRange iv, folly::MutableByteRange tag, bool useBlockOps, EVP_CIPHER_CTX *decryptCtx)
std::unique_ptr< folly::IOBuf >	evpEncrypt (std::unique_ptr< folly::IOBuf > &&plaintext, const folly::IOBuf *associatedData, folly::ByteRange iv, size_t tagLen, bool useBlockOps, size_t headroom, EVP_CIPHER_CTX *encryptCtx)
void	encFunc (EVP_CIPHER_CTX *, const folly::IOBuf &, folly::IOBuf &)
void	encFuncBlocks (EVP_CIPHER_CTX *, const folly::IOBuf &, folly::IOBuf &)
bool	decFunc (EVP_CIPHER_CTX *, const folly::IOBuf &, folly::IOBuf &, folly::MutableByteRange)
bool	decFuncBlocks (EVP_CIPHER_CTX *, const folly::IOBuf &, folly::IOBuf &, folly::MutableByteRange)
void	validateECKey (const folly::ssl::EvpPkeyUniquePtr &key, int curveNid)
std::unique_ptr< folly::IOBuf >	generateEvpSharedSecret (const folly::ssl::EvpPkeyUniquePtr &key, const folly::ssl::EvpPkeyUniquePtr &peerKey)
folly::ssl::EvpPkeyUniquePtr	generateECKeyPair (int curveNid)
folly::ssl::EvpPkeyUniquePtr	decodeECPublicKey (folly::ByteRange range, int curveNid)
std::unique_ptr< folly::IOBuf >	encodeECPublicKey (const folly::ssl::EvpPkeyUniquePtr &key)
std::unique_ptr< folly::IOBuf >	encodeECPublicKey (const folly::ssl::EcKeyUniquePtr &ecKey)
std::string	getOpenSSLError ()
std::unique_ptr< folly::IOBuf >	ecSign (folly::ByteRange data, const folly::ssl::EvpPkeyUniquePtr &pkey, int hashNid)
void	ecVerify (folly::ByteRange data, folly::ByteRange signature, const folly::ssl::EvpPkeyUniquePtr &pkey, int hashNid)
std::unique_ptr< folly::IOBuf >	rsaPssSign (folly::ByteRange data, const folly::ssl::EvpPkeyUniquePtr &pkey, int hashNid)
void	rsaPssVerify (folly::ByteRange data, folly::ByteRange signature, const folly::ssl::EvpPkeyUniquePtr &pkey, int hashNid)
static const EVP_MD *	getHash (int hashNid)
std::tuple< Buf, std::vector< fizz::Extension > >	decodeAuthRequest (const Buf &authRequest)
Buf	computeTranscriptHash (std::unique_ptr< KeyDerivation > &deriver, const Buf &toBeHashed)
void	writeBuf (const Buf &buf, folly::io::Appender &out)
Buf	computeTranscript (const Buf &handshakeContext, const Buf &authenticatorRequest, const Buf &certificate)
Buf	computeFinishedTranscript (const Buf &crTranscript, const Buf &certVerify)
Buf	getFinishedData (std::unique_ptr< KeyDerivation > &deriver, Buf &finishedMacKey, const Buf &finishedTranscript)
folly::Optional< std::vector< SignatureScheme > >	getRequestedSchemes (const std::vector< fizz::Extension > &authRequestExtensions)
folly::Optional< SignatureScheme >	getSignatureScheme (const std::vector< SignatureScheme > &supportedSchemes, const SelfCert &cert, const std::vector< fizz::Extension > &authRequestExtensions)
Buf	getEmptyAuthenticator (std::unique_ptr< KeyDerivation > &kderiver, Buf authRequest, Buf handshakeContext, Buf finishedMacKey)
template<>
size_t	read< TokenBindingID > (TokenBindingID &id, folly::io::Cursor &cursor)
template<>
void	write< TokenBindingID > (const TokenBindingID &id, folly::io::Appender &out)
template<>
size_t	getSize< TokenBindingID > (const TokenBindingID &id)
template<>
size_t	read< TokenBinding > (TokenBinding &tokenBinding, folly::io::Cursor &cursor)
template<>
void	write< TokenBinding > (const TokenBinding &tokenBinding, folly::io::Appender &out)
template<>
size_t	getSize< TokenBinding > (const TokenBinding &tokenBinding)
template<typename ActionsType >
void	addAction (ActionsType &)
template<typename ActionsType , typename ActionType , typename... Args>
void	addAction (ActionsType &acts, ActionType &&thisAct, Args &&...act)
template<class N >
size_t	getBufSize (const Buf &buf)
template<>
size_t	getBufSize< bits24 > (const Buf &buf)
template<class T >
size_t	getSize (const T &t)
template<class T >
void	checkWithin24bits (const typename std::enable_if< std::is_integral< T >::value &&!std::is_signed< T >::value, T >::type &value)
template<class T >
void	writeBits24 (T len, folly::io::Appender &out)
template<class T >
void	write (const T &in, folly::io::Appender &appender)
template<class N , class T >
void	writeVector (const std::vector< T > &data, folly::io::Appender &out)
template<>
void	writeBuf< bits24 > (const Buf &buf, folly::io::Appender &out)
template<>
void	write< Extension > (const Extension &extension, folly::io::Appender &out)
template<>
void	write< CertificateEntry > (const CertificateEntry &entry, folly::io::Appender &out)
uint32_t	readBits24 (folly::io::Cursor &cursor)
template<class N >
size_t	readBuf (Buf &buf, folly::io::Cursor &cursor)
template<>
size_t	readBuf< bits24 > (Buf &buf, folly::io::Cursor &cursor)
template<class T >
size_t	read (T &out, folly::io::Cursor &cursor)
template<class N , class T >
size_t	readVector (std::vector< T > &out, folly::io::Cursor &cursor)

Function Documentation

template<typename ActionsType >

void fizz::detail::addAction

(

ActionsType &

)

Definition at line 67 of file Actions.h.

References testing::Args().

Referenced by fizz::server::detail::actions(), and fizz::client::detail::actions().

{}

template<typename ActionsType , typename ActionType , typename... Args>

void fizz::detail::addAction	(	ActionsType &	acts,
		ActionType &&	thisAct,
		Args &&...	act
	)

Definition at line 70 of file Actions.h.

                                                                       {
  acts.emplace_back(std::forward<ActionType>(thisAct));
  addAction(acts, std::forward<Args>(act)...);
}

template<class T >

void fizz::detail::checkWithin24bits

(

const typename std::enable_if< std::is_integral< T >::value &&!std::is_signed< T >::value, T >::type &

value

)

Definition at line 92 of file Types-inl.h.

References uint32_t.

                                      {
  const uint32_t UINT24_MAX = 0xFFFFFF;
  if (value > UINT24_MAX) {
    throw std::runtime_error("Overflow 24 bit type");
  }
}

Buf fizz::detail::computeFinishedTranscript	(	const Buf &	crTranscript,
		const Buf &	certVerify
	)

Definition at line 290 of file ExportedAuthenticator.cpp.

References folly::IOBuf::create(), uint16_t, and writeBuf().

Referenced by fizz::ExportedAuthenticator::makeAuthenticator(), and fizz::ExportedAuthenticator::validate().

                                                                              {
  constexpr uint16_t capacity = 256;
  auto out = folly::IOBuf::create(capacity);
  folly::io::Appender appender(out.get(), capacity);
  detail::writeBuf(crTranscript, appender);
  detail::writeBuf(certVerify, appender);
  return out;
}

Buf fizz::detail::computeTranscript	(	const Buf &	handshakeContext,
		const Buf &	authenticatorRequest,
		const Buf &	certificate
	)

Definition at line 277 of file ExportedAuthenticator.cpp.

References folly::IOBuf::create(), uint16_t, and writeBuf().

Referenced by getEmptyAuthenticator(), fizz::ExportedAuthenticator::makeAuthenticator(), and fizz::ExportedAuthenticator::validate().

                            {
  constexpr uint16_t capacity = 256;
  auto out = folly::IOBuf::create(capacity);
  folly::io::Appender appender(out.get(), capacity);
  detail::writeBuf(handshakeContext, appender);
  detail::writeBuf(authenticatorRequest, appender);
  detail::writeBuf(certificate, appender);
  return out;
}

Buf fizz::detail::computeTranscriptHash	(	std::unique_ptr< KeyDerivation > &	deriver,
		const Buf &	toBeHashed
	)

Definition at line 254 of file ExportedAuthenticator.cpp.

References folly::IOBuf::create(), and folly::data().

Referenced by getEmptyAuthenticator(), fizz::ExportedAuthenticator::makeAuthenticator(), and fizz::ExportedAuthenticator::validate().

                           {
  auto hashLength = deriver->hashLength();
  auto data = folly::IOBuf::create(hashLength);
  data->append(hashLength);
  auto transcriptHash =
      folly::MutableByteRange(data->writableData(), data->length());
  deriver->hash(*toBeHashed, transcriptHash);
  return data;
}

bool fizz::detail::decFunc	(	EVP_CIPHER_CTX *	decryptCtx,
		const folly::IOBuf &	ciphertext,
		folly::IOBuf &	output,
		folly::MutableByteRange	tagOut
	)

Definition at line 152 of file OpenSSLEVPCipher.cpp.

References folly::Range< Iter >::begin(), cipher, max, folly::Range< Iter >::size(), fizz::transformBuffer(), uint8_t, and folly::IOBuf::writableData().

Referenced by evpDecrypt().

                                  {
  int numWritten = 0;
  int outLen = 0;
  transformBuffer(
      ciphertext,
      output,
      [&](uint8_t* plain, const uint8_t* cipher, size_t len) {
        if (len > std::numeric_limits<int>::max()) {
          throw std::runtime_error("Decryption error: too much cipher text");
        }
        if (EVP_DecryptUpdate(
                decryptCtx, plain, &outLen, cipher, static_cast<int>(len)) !=
            1) {
          throw std::runtime_error("Decryption error");
        }
        numWritten += outLen;
      });

  auto tagLen = tagOut.size();
  if (EVP_CIPHER_CTX_ctrl(
          decryptCtx,
          EVP_CTRL_GCM_SET_TAG,
          tagLen,
          static_cast<void*>(tagOut.begin())) != 1) {
    throw std::runtime_error("Decryption error");
  }
  return EVP_DecryptFinal_ex(
             decryptCtx, output.writableData() + numWritten, &outLen) == 1;
}

bool fizz::detail::decFuncBlocks	(	EVP_CIPHER_CTX *	decryptCtx,
		const folly::IOBuf &	ciphertext,
		folly::IOBuf &	output,
		folly::MutableByteRange	tagOut
	)

Definition at line 100 of file OpenSSLEVPCipher.cpp.

References folly::Range< Iter >::begin(), cipher, max, gmock_output_test::output, folly::Range< Iter >::size(), and uint8_t.

Referenced by evpDecrypt().

                                  {
  if (EVP_CIPHER_CTX_ctrl(
          decryptCtx,
          EVP_CTRL_GCM_SET_TAG,
          tagOut.size(),
          static_cast<void*>(tagOut.begin())) != 1) {
    throw std::runtime_error("Decryption error");
  }

  size_t totalWritten = 0;
  size_t totalInput = 0;
  int outLen = 0;
  auto outputCursor = transformBufferBlocks<16>(
      ciphertext,
      output,
      [&](uint8_t* plain, const uint8_t* cipher, size_t len) {
        if (len > std::numeric_limits<int>::max()) {
          throw std::runtime_error("Decryption error: too much cipher text");
        }
        if (EVP_DecryptUpdate(
                decryptCtx, plain, &outLen, cipher, static_cast<int>(len)) !=
            1) {
          throw std::runtime_error("Decryption error");
        }
        totalWritten += outLen;
        totalInput += len;
        return static_cast<size_t>(outLen);
      });

  // We might end up needing to write more in the final encrypt stage
  auto numBuffered = totalInput - totalWritten;
  auto numLeftInOutput = outputCursor.length();
  if (numBuffered <= numLeftInOutput) {
    auto res =
        EVP_DecryptFinal_ex(decryptCtx, outputCursor.writableData(), &outLen);
    return res == 1;
  } else {
    // we need to copy nicely - this should be at most one block
    std::array<uint8_t, 16> block = {};
    auto res = EVP_DecryptFinal_ex(decryptCtx, block.data(), &outLen);
    if (res != 1) {
      return false;
    }
    outputCursor.push(block.data(), outLen);
    return true;
  }
}

std::tuple<Buf, std::vector<fizz::Extension> > fizz::detail::decodeAuthRequest

(

const Buf &

authRequest

)

Definition at line 238 of file ExportedAuthenticator.cpp.

References folly::IOBuf::copyBuffer(), std::tr1::make_tuple(), and folly::gen::move.

Referenced by getEmptyAuthenticator(), and fizz::ExportedAuthenticator::makeAuthenticator().

                            {
  Buf certRequestContext;
  std::vector<fizz::Extension> exts;
  if (authRequest && !(authRequest->empty())) {
    folly::io::Cursor cursor(authRequest.get());
    CertificateRequest decodedCertRequest = decode<CertificateRequest>(cursor);
    certRequestContext =
        std::move(decodedCertRequest.certificate_request_context);
    exts = std::move(decodedCertRequest.extensions);
  } else {
    certRequestContext = folly::IOBuf::copyBuffer("");
  }
  return std::make_tuple(std::move(certRequestContext), std::move(exts));
}

folly::ssl::EvpPkeyUniquePtr fizz::detail::decodeECPublicKey	(	folly::ByteRange	range,
		int	curveNid
	)

Decodes a EC public key specified as a member of the curve curveNid.

Definition at line 84 of file OpenSSLKeyUtils.cpp.

References folly::Range< Iter >::data(), and folly::Range< Iter >::size().

Referenced by fizz::extensions::Validator::constructEcKeyFromBuf(), and fizz::detail::OpenSSLECKeyDecoder< T >::decode().

                  {
  // Get the peer key.
  folly::ssl::EcGroupUniquePtr curve(EC_GROUP_new_by_curve_name(curveNid));
  folly::ssl::EcKeyUniquePtr peerKey(EC_KEY_new_by_curve_name(curveNid));
  if (!curve || !peerKey) {
    throw std::runtime_error("Error initializing peer key");
  }
  folly::ssl::EcPointUniquePtr point(EC_POINT_new(curve.get()));
  if (!point) {
    throw std::runtime_error("Error initializing point");
  }
  if (EC_POINT_oct2point(
          curve.get(), point.get(), range.data(), range.size(), nullptr) != 1) {
    throw std::runtime_error("Error decoding peer key");
  }
  if (EC_POINT_is_on_curve(curve.get(), point.get(), nullptr) != 1) {
    throw std::runtime_error("Peer key is not on curve");
  }
  if (!EC_KEY_set_public_key(peerKey.get(), point.get())) {
    throw std::runtime_error("Error setting public key");
  }
  folly::ssl::EvpPkeyUniquePtr peerPkey(EVP_PKEY_new());
  if (EVP_PKEY_assign_EC_KEY(peerPkey.get(), peerKey.release()) != 1) {
    throw std::runtime_error("Error assigning EC key");
  }
  return peerPkey;
}

std::unique_ptr< folly::IOBuf > fizz::detail::ecSign	(	folly::ByteRange	data,
		const folly::ssl::EvpPkeyUniquePtr &	pkey,
		int	hashNid
	)

Definition at line 30 of file Signature.cpp.

References folly::IOBuf::create(), folly::Range< Iter >::data(), folly::portability::ssl::EVP_MD_CTX_new(), getHash(), getOpenSSLError(), and folly::Range< Iter >::size().

Referenced by fizz::OpenSSLSignature< T >::sign().

                 {
  folly::ssl::EvpMdCtxUniquePtr mdCtx(EVP_MD_CTX_new());
  if (!mdCtx) {
    throw std::runtime_error(
        to<std::string>("Could not allocate EVP_MD_CTX", getOpenSSLError()));
  }

  auto hash = getHash(hashNid);

  if (EVP_SignInit(mdCtx.get(), hash) != 1) {
    throw std::runtime_error("Could not initialize signature");
  }
  if (EVP_SignUpdate(mdCtx.get(), data.data(), data.size()) != 1) {
    throw std::runtime_error(
        to<std::string>("Could not sign data ", getOpenSSLError()));
  }
  auto out = folly::IOBuf::create(EVP_PKEY_size(pkey.get()));
  unsigned int bytesWritten = 0;
  if (EVP_SignFinal(
          mdCtx.get(), out->writableData(), &bytesWritten, pkey.get()) != 1) {
    throw std::runtime_error("Failed to sign");
  }
  out->append(bytesWritten);
  return out;
}

void fizz::detail::ecVerify	(	folly::ByteRange	data,
		folly::ByteRange	signature,
		const folly::ssl::EvpPkeyUniquePtr &	pkey,
		int	hashNid
	)

Definition at line 59 of file Signature.cpp.

References folly::Range< Iter >::data(), folly::portability::ssl::EVP_MD_CTX_new(), getHash(), getOpenSSLError(), and folly::Range< Iter >::size().

Referenced by fizz::OpenSSLSignature< T >::verify().

                 {
  auto hash = getHash(hashNid);
  folly::ssl::EvpMdCtxUniquePtr mdCtx(EVP_MD_CTX_new());
  if (!mdCtx) {
    throw std::runtime_error(
        to<std::string>("Could not allocate EVP_MD_CTX", getOpenSSLError()));
  }

  if (EVP_VerifyInit(mdCtx.get(), hash) != 1) {
    throw std::runtime_error("Could not initialize verification");
  }

  if (EVP_VerifyUpdate(mdCtx.get(), data.data(), data.size()) != 1) {
    throw std::runtime_error("Could not update verification");
  }

  if (EVP_VerifyFinal(
          mdCtx.get(), signature.data(), signature.size(), pkey.get()) != 1) {
    throw std::runtime_error("Signature verification failed");
  }
}

void fizz::detail::encFunc	(	EVP_CIPHER_CTX *	encryptCtx,
		const folly::IOBuf &	plaintext,
		folly::IOBuf &	output
	)

Definition at line 73 of file OpenSSLEVPCipher.cpp.

References cipher, max, fizz::transformBuffer(), uint8_t, and folly::IOBuf::writableData().

Referenced by evpEncrypt().

                        {
  int numWritten = 0;
  int outLen = 0;
  transformBuffer(
      plaintext,
      output,
      [&](uint8_t* cipher, const uint8_t* plain, size_t len) {
        if (len > std::numeric_limits<int>::max()) {
          throw std::runtime_error("Encryption error: too much plain text");
        }
        if (EVP_EncryptUpdate(
                encryptCtx, cipher, &outLen, plain, static_cast<int>(len)) !=
            1) {
          throw std::runtime_error("Encryption error");
        }
        numWritten += outLen;
      });
  // We don't expect any writes at the end
  if (EVP_EncryptFinal_ex(
          encryptCtx, output.writableData() + numWritten, &outLen) != 1) {
    throw std::runtime_error("Encryption error");
  }
}

void fizz::detail::encFuncBlocks	(	EVP_CIPHER_CTX *	encryptCtx,
		const folly::IOBuf &	plaintext,
		folly::IOBuf &	output
	)

Definition at line 30 of file OpenSSLEVPCipher.cpp.

References cipher, max, gmock_output_test::output, and uint8_t.

Referenced by evpEncrypt().

                        {
  size_t totalWritten = 0;
  size_t totalInput = 0;
  int outLen = 0;
  auto outputCursor = transformBufferBlocks<16>(
      plaintext,
      output,
      [&](uint8_t* cipher, const uint8_t* plain, size_t len) {
        if (len > std::numeric_limits<int>::max()) {
          throw std::runtime_error("Encryption error: too much plain text");
        }
        if (EVP_EncryptUpdate(
                encryptCtx, cipher, &outLen, plain, static_cast<int>(len)) !=
                1 ||
            outLen < 0) {
          throw std::runtime_error("Encryption error");
        }
        totalWritten += outLen;
        totalInput += len;
        return static_cast<size_t>(outLen);
      });

  // We might end up needing to write more in the final encrypt stage
  auto numBuffered = totalInput - totalWritten;
  auto numLeftInOutput = outputCursor.length();
  if (numBuffered <= numLeftInOutput) {
    if (EVP_EncryptFinal_ex(encryptCtx, outputCursor.writableData(), &outLen) !=
        1) {
      throw std::runtime_error("Encryption error");
    }
  } else {
    // we need to copy nicely - this should be at most one block
    std::array<uint8_t, 16> block = {};
    if (EVP_EncryptFinal_ex(encryptCtx, block.data(), &outLen) != 1) {
      throw std::runtime_error("Encryption error");
    }
    outputCursor.push(block.data(), outLen);
  }
}

std::unique_ptr< folly::IOBuf > fizz::detail::encodeECPublicKey

(

const folly::ssl::EvpPkeyUniquePtr &

key

)

Encodes the public key and returns a buffer.

Definition at line 114 of file OpenSSLKeyUtils.cpp.

Referenced by fizz::detail::OpenSSLECKeyEncoder::encode(), and fizz::extensions::TokenBindingConstructor::encodeEcKey().

                                         {
  folly::ssl::EcKeyUniquePtr ecKey(EVP_PKEY_get1_EC_KEY(key.get()));
  if (!ecKey) {
    throw std::runtime_error("Wrong key type");
  }
  return encodeECPublicKey(ecKey);
}

std::unique_ptr< folly::IOBuf > fizz::detail::encodeECPublicKey

(

const folly::ssl::EcKeyUniquePtr &

ecKey

)

Definition at line 123 of file OpenSSLKeyUtils.cpp.

References folly::IOBuf::create(), and group.

                                         {
  auto point = EC_KEY_get0_public_key(ecKey.get());
  auto group = EC_KEY_get0_group(ecKey.get());

  size_t len = EC_POINT_point2oct(
      group, point, POINT_CONVERSION_UNCOMPRESSED, nullptr, 0, nullptr);
  auto buf = folly::IOBuf::create(len);
  // TLS 1.3 only allows uncompressed point formats, so we only support that
  // for now.
  len = EC_POINT_point2oct(
      group,
      point,
      POINT_CONVERSION_UNCOMPRESSED,
      buf->writableData(),
      len,
      nullptr);
  if (len == 0) {
    throw std::runtime_error("Failed to encode key");
  }
  buf->append(len);
  return buf;
}

folly::Optional< std::unique_ptr< folly::IOBuf > > fizz::detail::evpDecrypt	(	std::unique_ptr< folly::IOBuf > &&	ciphertext,
		const folly::IOBuf *	associatedData,
		folly::ByteRange	iv,
		folly::MutableByteRange	tag,
		bool	useBlockOps,
		EVP_CIPHER_CTX *	decryptCtx
	)

Definition at line 264 of file OpenSSLEVPCipher.cpp.

References folly::IOBuf::append(), folly::IOBuf::create(), current, folly::Range< Iter >::data(), decFunc(), decFuncBlocks(), max, folly::gen::move, folly::none, gmock_output_test::output, folly::Range< Iter >::size(), and fizz::trimBytes().

Referenced by fizz::OpenSSLEVPCipher< EVPImpl >::tryDecrypt().

                                {
  auto tagLen = tagOut.size();
  auto inputLength = ciphertext->computeChainDataLength();
  if (inputLength < tagLen) {
    return folly::none;
  }
  inputLength -= tagLen;

  folly::IOBuf* input;
  std::unique_ptr<folly::IOBuf> output;
  trimBytes(*ciphertext, tagOut);
  if (ciphertext->isShared()) {
    // If in is shared, then we have to make a copy of it.
    output = folly::IOBuf::create(inputLength);
    output->append(inputLength);
    input = ciphertext.get();
  } else {
    // If in is not shared we can do decryption in-place.
    output = std::move(ciphertext);
    input = output.get();
  }

  if (EVP_DecryptInit_ex(decryptCtx, nullptr, nullptr, nullptr, iv.data()) !=
      1) {
    throw std::runtime_error("Decryption error");
  }

  if (associatedData) {
    for (auto current : *associatedData) {
      if (current.size() > std::numeric_limits<int>::max()) {
        throw std::runtime_error("too much associated data");
      }
      int len;
      if (EVP_DecryptUpdate(
              decryptCtx,
              nullptr,
              &len,
              current.data(),
              static_cast<int>(current.size())) != 1) {
        throw std::runtime_error("Decryption error");
      }
    }
  }

  auto decrypted = useBlockOps
      ? decFuncBlocks(decryptCtx, *input, *output, tagOut)
      : decFunc(decryptCtx, *input, *output, tagOut);
  if (!decrypted) {
    return folly::none;
  }
  return std::move(output);
}

std::unique_ptr< folly::IOBuf > fizz::detail::evpEncrypt	(	std::unique_ptr< folly::IOBuf > &&	plaintext,
		const folly::IOBuf *	associatedData,
		folly::ByteRange	iv,
		size_t	tagLen,
		bool	useBlockOps,
		size_t	headroom,
		EVP_CIPHER_CTX *	encryptCtx
	)

Definition at line 186 of file OpenSSLEVPCipher.cpp.

References folly::IOBuf::advance(), folly::IOBuf::append(), folly::IOBuf::create(), current, folly::Range< Iter >::data(), encFunc(), encFuncBlocks(), max, folly::gen::move, gmock_output_test::output, folly::IOBuf::prependChain(), folly::IOBuf::prev(), folly::IOBuf::tailroom(), and folly::IOBuf::writableData().

Referenced by fizz::OpenSSLEVPCipher< EVPImpl >::encrypt().

                                {
  auto inputLength = plaintext->computeChainDataLength();
  // Setup input and output buffers.
  std::unique_ptr<folly::IOBuf> output;
  folly::IOBuf* input;

  if (plaintext->isShared()) {
    // create enough to also fit the tag and headroom
    output = folly::IOBuf::create(headroom + inputLength + tagLen);
    output->advance(headroom);
    output->append(inputLength);
    input = plaintext.get();
  } else {
    output = std::move(plaintext);
    input = output.get();
  }

  if (EVP_EncryptInit_ex(encryptCtx, nullptr, nullptr, nullptr, iv.data()) !=
      1) {
    throw std::runtime_error("Encryption error");
  }

  if (associatedData) {
    for (auto current : *associatedData) {
      if (current.size() > std::numeric_limits<int>::max()) {
        throw std::runtime_error("too much associated data");
      }
      int len;
      if (EVP_EncryptUpdate(
              encryptCtx,
              nullptr,
              &len,
              current.data(),
              static_cast<int>(current.size())) != 1) {
        throw std::runtime_error("Encryption error");
      }
    }
  }

  if (useBlockOps) {
    encFuncBlocks(encryptCtx, *input, *output);
  } else {
    encFunc(encryptCtx, *input, *output);
  }

  // output is always something we can modify
  auto tailRoom = output->prev()->tailroom();
  if (tailRoom < tagLen) {
    std::unique_ptr<folly::IOBuf> tag = folly::IOBuf::create(tagLen);
    tag->append(tagLen);
    if (EVP_CIPHER_CTX_ctrl(
            encryptCtx, EVP_CTRL_GCM_GET_TAG, tagLen, tag->writableData()) !=
        1) {
      throw std::runtime_error("Encryption error");
    }
    output->prependChain(std::move(tag));
  } else {
    auto lastBuf = output->prev();
    lastBuf->append(tagLen);
    // we can copy into output directly
    if (EVP_CIPHER_CTX_ctrl(
            encryptCtx,
            EVP_CTRL_GCM_GET_TAG,
            tagLen,
            lastBuf->writableTail() - tagLen) != 1) {
      throw std::runtime_error("Encryption error");
    }
  }
  return output;
}

folly::ssl::EvpPkeyUniquePtr fizz::detail::generateECKeyPair

(

int

curveNid

)

Generates an new EVP_PKEY on the curve. Throws an exception on error.

Definition at line 58 of file OpenSSLKeyUtils.cpp.

References params, and validateECKey().

Referenced by fizz::detail::OpenSSLECKeyExchange< T >::generateKeyPair().

                                                         {
  folly::ssl::EcKeyUniquePtr ecParamKey(EC_KEY_new_by_curve_name(curveNid));
  folly::ssl::EvpPkeyUniquePtr params(EVP_PKEY_new());
  if (!ecParamKey || !params) {
    throw std::runtime_error("Error initializing params");
  }
  if (EVP_PKEY_set1_EC_KEY(params.get(), ecParamKey.get()) != 1) {
    throw std::runtime_error("Error setting ec key for params");
  }
  folly::ssl::EvpPkeyCtxUniquePtr kctx(EVP_PKEY_CTX_new(params.get(), nullptr));
  if (!kctx) {
    throw std::runtime_error("Error creating kctx");
  }
  if (EVP_PKEY_keygen_init(kctx.get()) != 1) {
    throw std::runtime_error("Error initializing ctx");
  }
  EVP_PKEY* pkey = nullptr;
  if (EVP_PKEY_keygen(kctx.get(), &pkey) != 1) {
    throw std::runtime_error("Error generating key");
  }
  folly::ssl::EvpPkeyUniquePtr evpKey(pkey);
  folly::ssl::EcKeyUniquePtr ecKey(EVP_PKEY_get1_EC_KEY(evpKey.get()));
  validateECKey(evpKey, curveNid);
  return evpKey;
}

std::unique_ptr< folly::IOBuf > fizz::detail::generateEvpSharedSecret	(	const folly::ssl::EvpPkeyUniquePtr &	key,
		const folly::ssl::EvpPkeyUniquePtr &	peerKey
	)

Generates a shared secred from a private key, key and the peerKey public key.

Definition at line 34 of file OpenSSLKeyUtils.cpp.

References folly::IOBuf::create().

Referenced by fizz::detail::OpenSSLECKeyExchange< T >::generateSharedSecret().

                                             {
  folly::ssl::EvpPkeyCtxUniquePtr ctx(EVP_PKEY_CTX_new(key.get(), nullptr));
  if (EVP_PKEY_derive_init(ctx.get()) != 1) {
    throw std::runtime_error("Initializing derive context failed");
  }
  // Start deriving the key.
  if (EVP_PKEY_derive_set_peer(ctx.get(), peerKey.get()) != 1) {
    throw std::runtime_error("Error setting peer key");
  }
  size_t secretLen = 0;
  if (EVP_PKEY_derive(ctx.get(), nullptr, &secretLen) != 1) {
    throw std::runtime_error("Error deriving key");
  }
  // secretLen is now the maximum secret length.
  auto buf = folly::IOBuf::create(secretLen);
  if (EVP_PKEY_derive(ctx.get(), buf->writableData(), &secretLen) != 1) {
    throw std::runtime_error("Error deriving key");
  }
  buf->append(secretLen);
  return buf;
}

template<class N >

size_t fizz::detail::getBufSize

(

const Buf &

buf

)

Definition at line 33 of file Types-inl.h.

                                  {
  return sizeof(N) + buf->computeChainDataLength();
}

template<>

size_t fizz::detail::getBufSize< bits24 > ( const Buf &  buf )

inline

Definition at line 38 of file Types-inl.h.

References fizz::detail::bits24::size.

Referenced by fizz::detail::Sizer< CertificateEntry >::getSize().

                                                 {
  return bits24::size + buf->computeChainDataLength();
}

Buf fizz::detail::getEmptyAuthenticator	(	std::unique_ptr< KeyDerivation > &	kderiver,
		Buf	authRequest,
		Buf	handshakeContext,
		Buf	finishedMacKey
	)

Definition at line 361 of file ExportedAuthenticator.cpp.

References fizz::CertificateMsg::certificate_request_context, computeTranscript(), computeTranscriptHash(), decodeAuthRequest(), fizz::encodeHandshake(), getFinishedData(), folly::gen::move, and fizz::Finished::verify_data.

Referenced by fizz::ExportedAuthenticator::makeAuthenticator(), and fizz::ExportedAuthenticator::validate().

                        {
  CertificateMsg emptyCertMsg;
  emptyCertMsg.certificate_request_context =
      std::get<0>(detail::decodeAuthRequest(authRequest));
  auto encodedEmptyCertMsg = encodeHandshake(std::move(emptyCertMsg));
  auto emptyAuthTranscript = detail::computeTranscript(
      handshakeContext, authRequest, encodedEmptyCertMsg);
  auto emptyAuthTranscriptHash =
      detail::computeTranscriptHash(kderiver, emptyAuthTranscript);
  auto finVerify = detail::getFinishedData(
      kderiver, finishedMacKey, emptyAuthTranscriptHash);
  Finished emptyAuth;
  emptyAuth.verify_data = std::move(finVerify);
  auto encodedEmptyAuth = encodeHandshake(std::move(emptyAuth));
  return encodedEmptyAuth;
}

Buf fizz::detail::getFinishedData	(	std::unique_ptr< KeyDerivation > &	deriver,
		Buf &	finishedMacKey,
		const Buf &	finishedTranscript
	)

Definition at line 299 of file ExportedAuthenticator.cpp.

References folly::IOBuf::create(), and folly::data().

Referenced by fizz::client::test::ClientProtocolTest::doFinishedFlow(), getEmptyAuthenticator(), fizz::ExportedAuthenticator::makeAuthenticator(), fizz::test::MockHandshakeContext::setDefaults(), fizz::client::test::TEST_F(), fizz::server::test::TEST_F(), and fizz::ExportedAuthenticator::validate().

                                   {
  auto hashLength = deriver->hashLength();
  auto data = folly::IOBuf::create(hashLength);
  data->append(hashLength);
  auto outRange = folly::MutableByteRange(data->writableData(), data->length());
  deriver->hmac(finishedMacKey->coalesce(), *finishedTranscript, outRange);
  return data;
}

static const EVP_MD* fizz::detail::getHash ( int  hashNid )

static

Definition at line 22 of file Signature.cpp.

Referenced by ecSign(), ecVerify(), rsaPssSign(), and rsaPssVerify().

                                          {
  const auto hash = EVP_get_digestbynid(hashNid);
  if (!hash) {
    throw std::runtime_error("Invalid hash. Have you initialized openssl?");
  }
  return hash;
}

std::string fizz::detail::getOpenSSLError

(

)

Returns the current error in the thread queue as a string.

Definition at line 147 of file OpenSSLKeyUtils.cpp.

References string.

Referenced by ecSign(), ecVerify(), rsaPssSign(), rsaPssVerify(), and fizz::extensions::Validator::verify().

                            {
  auto err = ERR_get_error();
  if (err == 0) {
    return "";
  }
  char errMsg[256];
  ERR_error_string_n(ERR_get_error(), errMsg, sizeof(errMsg));
  return std::string(errMsg);
}

folly::Optional< std::vector< SignatureScheme > > fizz::detail::getRequestedSchemes

(

const std::vector< fizz::Extension > &

authRequestExtensions

)

Definition at line 311 of file ExportedAuthenticator.cpp.

References folly::none.

Referenced by getSignatureScheme().

                                                           {
  if (!(authRequestExtensions.empty())) {
    auto sigAlgsExtension =
        getExtension<SignatureAlgorithms>(authRequestExtensions);
    if (sigAlgsExtension) {
      auto requestedSchemes = sigAlgsExtension->supported_signature_algorithms;
      return requestedSchemes;
    } else {
      return folly::none;
    }
  } else {
    return folly::none;
  }
}

folly::Optional< SignatureScheme > fizz::detail::getSignatureScheme	(	const std::vector< SignatureScheme > &	supportedSchemes,
		const SelfCert &	cert,
		const std::vector< fizz::Extension > &	authRequestExtensions
	)

Definition at line 327 of file ExportedAuthenticator.cpp.

References getRequestedSchemes(), and fizz::SelfCert::getSigSchemes().

Referenced by fizz::ExportedAuthenticator::makeAuthenticator().

                                                           {
  folly::Optional<SignatureScheme> selectedScheme;
  const auto certSchemes = cert.getSigSchemes();
  folly::Optional<std::vector<SignatureScheme>> requestedSchemes =
      getRequestedSchemes(authRequestExtensions);
  if (requestedSchemes) {
    for (const auto& scheme : supportedSchemes) {
      if (std::find(certSchemes.begin(), certSchemes.end(), scheme) !=
              certSchemes.end() &&
          std::find(
              (*requestedSchemes).begin(), (*requestedSchemes).end(), scheme) !=
              (*requestedSchemes).end()) {
        selectedScheme = scheme;
        break;
      }
    }
  }

  if (!selectedScheme) {
    VLOG(1) << "authenticator request without proper signature algorithms";
    for (const auto& scheme : supportedSchemes) {
      if (std::find(certSchemes.begin(), certSchemes.end(), scheme) !=
          certSchemes.end()) {
        selectedScheme = scheme;
        break;
      }
    }
  }
  return selectedScheme;
}

template<class T >

size_t fizz::detail::getSize

(

const T &

t

)

Definition at line 43 of file Types-inl.h.

Referenced by fizz::detail::Sizer< CertificateEntry >::getSize(), and getSize< TokenBinding >().

                           {
  return Sizer<T>().template getSize<T>(t);
}

template<>

size_t fizz::detail::getSize< TokenBinding >

(

const TokenBinding &

tokenBinding

)

Definition at line 60 of file Types.cpp.

References getSize().

                                                               {
  return sizeof(TokenBindingType) + getSize(tokenBinding.tokenbindingid) +
      getBufSize<uint16_t>(tokenBinding.signature) +
      getBufSize<uint16_t>(tokenBinding.extensions);
}

template<>

size_t fizz::detail::getSize< TokenBindingID >

(

const TokenBindingID &

id

)

Definition at line 34 of file Types.cpp.

                                                         {
  return sizeof(TokenBindingKeyParameters) + getBufSize<uint16_t>(id.key);
}

template<class T >

size_t fizz::detail::read	(	T &	out,
		folly::io::Cursor &	cursor
	)

Definition at line 258 of file Types-inl.h.

Referenced by folly::gen::detail::FileReader::apply(), BENCHMARK(), folly::portability::ssl::BIO_meth_set_read(), wangle::Pipeline< int >::create(), fizz::server::TicketCodec< Storage >::decode(), fizz::decode(), fizz::decode< KeyUpdate >(), fizz::decode< NewSessionTicket >(), fizz::server::detail::decodeCookie(), EventHandlerTest::efd_read(), upload.MercurialVCS::GetBaseFile(), fizz::getBinderLength(), fizz::getExtension(), fizz::test::ExtensionsTest::getExtensions(), folly::getSchedTimeWaiting(), fizz::tool::TerminalInputHandler::handlerReady(), folly::symbolizer::ElfFile::init(), folly::ssl::detail::isSSLLockDisabled(), fizz::MockEncryptedReadRecordLayer::MockEncryptedReadRecordLayer(), folly::AsyncIO::pollCompleted(), pwritev(), fizz::detail::Reader< KeyShareEntry >::read(), fizz::detail::Reader< PskIdentity >::read(), fizz::detail::Reader< ServerName >::read(), testing::internal::posix::Read(), read< TokenBinding >(), read< TokenBindingID >(), read_all(), fizz::server::readClientCertificate(), readFromFD(), folly::readFull(), folly::readNoInt(), readUntilEmpty(), fizz::detail::ReadVector< N, T >::readVector(), fizz::detail::ReadVector< bits24, T >::readVector(), folly::test::runCloseTest(), folly::test::runKillTest(), folly::symbolizer::Dwarf::Section::Section(), BroadcastHandlerTest::SetUp(), TEST(), folly::test::TEST(), fizz::test::TEST_F(), TEST_F(), test_message(), test_message_count_body(), test_multiple3(), and test_scan().

                                           {
  return Reader<T>().template read<T>(out, cursor);
}

template<>

size_t fizz::detail::read< TokenBinding >	(	TokenBinding &	tokenBinding,
		folly::io::Cursor &	cursor
	)

Definition at line 39 of file Types.cpp.

References read().

                           {
  auto len = read(tokenBinding.tokenbinding_type, cursor);
  len += read(tokenBinding.tokenbindingid, cursor);
  len += readBuf<uint16_t>(tokenBinding.signature, cursor);
  len += readBuf<uint16_t>(tokenBinding.extensions, cursor);
  return len;
}

template<>

size_t fizz::detail::read< TokenBindingID >	(	TokenBindingID &	id,
		folly::io::Cursor &	cursor
	)

Definition at line 21 of file Types.cpp.

References read().

                                                                       {
  auto len = read(id.key_parameters, cursor);
  len += readBuf<uint16_t>(id.key, cursor);
  return len;
}

uint32_t fizz::detail::readBits24 ( folly::io::Cursor &  cursor )

inline

Definition at line 210 of file Types-inl.h.

References addr, folly::Endian::big(), data, folly::io::detail::CursorBase< Derived, BufType >::pull(), uint32_t, and uint8_t.

Referenced by fizz::decode(), fizz::ReadRecordLayer::decodeHandshakeMessage(), readBuf< bits24 >(), fizz::detail::ReadVector< bits24, T >::readVector(), and fizz::test::TEST().

                                                  {
  uint32_t data = 0;
  uint8_t offset = sizeof(data) - 3;
  uint8_t* addr = reinterpret_cast<uint8_t*>(&data);
  cursor.pull(addr + offset, 3);
  uint32_t length = folly::Endian::big(data);
  return length;
}

template<class N >

size_t fizz::detail::readBuf	(	Buf &	buf,
		folly::io::Cursor &	cursor
	)

Definition at line 220 of file Types-inl.h.

References folly::io::detail::CursorBase< Derived, BufType >::clone(), and folly::io::detail::CursorBase< Derived, BufType >::readBE().

Referenced by folly::AsyncSocket::handleRead(), folly::test::MockReadCallback::readBufferAvailable(), proxygen::HTTPSession::readBufferAvailable(), fizz::test::HandshakeTest::resetTransportsAndStartCookieHandshake(), TEST(), and TEST_F().

                                                {
  auto len = cursor.readBE<N>();
  cursor.clone(buf, len);
  return sizeof(N) + len;
}

template<>

size_t fizz::detail::readBuf< bits24 > ( Buf &  buf, folly::io::Cursor &  cursor  )

inline

Definition at line 227 of file Types-inl.h.

References readBits24(), and fizz::detail::bits24::size.

Referenced by fizz::detail::Reader< CertificateEntry >::read().

                                                               {
  auto len = readBits24(cursor);
  cursor.clone(buf, len);
  return bits24::size + len;
}

template<class N , class T >

size_t fizz::detail::readVector	(	std::vector< T > &	out,
		folly::io::Cursor &	cursor
	)

Definition at line 303 of file Types-inl.h.

                                                            {
  return ReadVector<N, T>().readVector(out, cursor);
}

std::unique_ptr< folly::IOBuf > fizz::detail::rsaPssSign	(	folly::ByteRange	data,
		const folly::ssl::EvpPkeyUniquePtr &	pkey,
		int	hashNid
	)

Definition at line 85 of file Signature.cpp.

References folly::IOBuf::create(), folly::Range< Iter >::data(), folly::portability::ssl::EVP_MD_CTX_new(), getHash(), getOpenSSLError(), and folly::Range< Iter >::size().

Referenced by fizz::OpenSSLSignature< T >::sign().

                 {
  auto hash = getHash(hashNid);
  folly::ssl::EvpMdCtxUniquePtr mdCtx(EVP_MD_CTX_new());
  if (!mdCtx) {
    throw std::runtime_error(
        to<std::string>("Could not allocate EVP_MD_CTX", getOpenSSLError()));
  }

  EVP_PKEY_CTX* ctx;
  if (EVP_DigestSignInit(mdCtx.get(), &ctx, hash, nullptr, pkey.get()) != 1) {
    throw std::runtime_error("Could not initialize signature");
  }

  if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PSS_PADDING) <= 0) {
    throw std::runtime_error("Could not set pss padding");
  }

  if (EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, -1) <= 0) {
    throw std::runtime_error("Could not set pss salt length");
  }

  if (EVP_DigestSignUpdate(mdCtx.get(), data.data(), data.size()) != 1) {
    throw std::runtime_error("Could not update signature");
  }

  size_t bytesWritten = EVP_PKEY_size(pkey.get());
  auto out = folly::IOBuf::create(bytesWritten);
  if (EVP_DigestSignFinal(mdCtx.get(), out->writableData(), &bytesWritten) !=
      1) {
    throw std::runtime_error("Failed to sign");
  }
  out->append(bytesWritten);
  return out;
}

void fizz::detail::rsaPssVerify	(	folly::ByteRange	data,
		folly::ByteRange	signature,
		const folly::ssl::EvpPkeyUniquePtr &	pkey,
		int	hashNid
	)

Definition at line 123 of file Signature.cpp.

References folly::Range< Iter >::data(), folly::portability::ssl::EVP_MD_CTX_new(), getHash(), getOpenSSLError(), and folly::Range< Iter >::size().

Referenced by fizz::OpenSSLSignature< T >::verify().

                 {
  auto hash = getHash(hashNid);
  folly::ssl::EvpMdCtxUniquePtr mdCtx(EVP_MD_CTX_new());
  if (!mdCtx) {
    throw std::runtime_error(
        to<std::string>("Could not allocate EVP_MD_CTX", getOpenSSLError()));
  }

  EVP_PKEY_CTX* ctx;
  if (EVP_DigestVerifyInit(mdCtx.get(), &ctx, hash, nullptr, pkey.get()) != 1) {
    throw std::runtime_error("Could not initialize verification");
  }

  if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PSS_PADDING) <= 0) {
    throw std::runtime_error("Could not set pss padding");
  }

  if (EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, -1) <= 0) {
    throw std::runtime_error("Could not set pss salt length");
  }

  if (EVP_DigestVerifyUpdate(mdCtx.get(), data.data(), data.size()) != 1) {
    throw std::runtime_error("Could not update verification");
  }

  if (EVP_DigestVerifyFinal(mdCtx.get(), signature.data(), signature.size()) !=
      1) {
    throw std::runtime_error("Signature verification failed");
  }
}

void fizz::detail::validateECKey	(	const folly::ssl::EvpPkeyUniquePtr &	key,
		int	curveNid
	)

Validates whether or not the EVP_PKEY belongs to the curve. If not, this throws an exception.

Definition at line 16 of file OpenSSLKeyUtils.cpp.

Referenced by generateECKeyPair(), fizz::OpenSSLSignature< T >::setKey(), fizz::detail::OpenSSLECKeyExchange< T >::setPrivateKey(), and fizz::test::TEST().

                                                                      {
  folly::ssl::EcKeyUniquePtr ecKey(EVP_PKEY_get1_EC_KEY(key.get()));
  if (!ecKey) {
    throw std::runtime_error("Wrong key type");
  }
  if (EC_KEY_check_key(ecKey.get()) != 1) {
    throw std::runtime_error("Private key not valid");
  }
  folly::ssl::EcGroupUniquePtr curve(EC_GROUP_new_by_curve_name(curveNid));
  if (!curve) {
    throw std::runtime_error("Failed to create curve");
  }
  auto keyGroup = EC_KEY_get0_group(ecKey.get());
  if (EC_GROUP_cmp(keyGroup, curve.get(), nullptr) != 0) {
    throw std::runtime_error("Invalid group");
  }
}

template<class T >

void fizz::detail::write	(	const T &	in,
		folly::io::Appender &	appender
	)

Definition at line 112 of file Types-inl.h.

Referenced by folly::PriorityLifoSemMPMCQueue< T, kBehavior >::addWithPriority(), fizz::server::appendClientCertificate(), fizz::test::appWrite(), folly::AsyncPipeWriter::AsyncPipeWriter(), BENCHMARK(), folly::portability::ssl::BIO_meth_set_write(), fizz::test::ExtensionsTest::checkEncode(), folly::gen::detail::FileWriter::compose(), fizz::extensions::TokenBindingUtils::constructMessage(), wangle::Pipeline< int >::create(), fizz::client::test::ClientProtocolTest::doFinishedFlow(), EventHandlerTest::efd_write(), fizz::server::TicketCodec< Storage >::encode(), fizz::encode< Alert >(), fizz::encode< CertificateVerify >(), fizz::encode< CompressedCertificate & >(), fizz::encode< const ClientHello & >(), fizz::encode< HelloRetryRequest >(), fizz::encode< KeyUpdate >(), fizz::encode< NewSessionTicket >(), fizz::encode< ServerHello >(), fizz::server::detail::encodeCookie(), fizz::encodeExtension(), fizz::encodeHandshake(), fizz::encodeHkdfLabel(), encryptGCM(), folly::NotificationQueue< folly::AsyncServerSocket::QueueMessage >::ensureSignalLocked(), fizz::server::test::AsyncFizzServerTest::expectAppClose(), fizz::client::test::AsyncFizzClientTest::expectAppClose(), fizz::test::ProtocolTest< ClientTypes, Actions >::expectError(), folly::gen::detail::FileWriter::flushBuffer(), fizz::sm::generateTicket(), fizz::sm::getCertificateRequest(), fizz::sm::getEarlyDataParams(), fizz::sm::getMaxEarlyDataSize(), fizz::server::detail::handleAppClose(), fizz::client::detail::handleAppClose(), fizz::sm::handleEarlyAppWrite(), fizz::server::detail::handleError(), fizz::client::detail::handleError(), fizz::FizzBase< Derived, ActionMoveVisitor, StateMachine >::moveToErrorState(), fizz::test::TestStateMachine::processAppWrite(), fizz::test::TestStateMachine::processEarlyAppWrite(), fizz::FizzBase< Derived, ActionMoveVisitor, StateMachine >::processPendingEvents(), pwritev(), TelnetHandler::read(), FileServerHandler::read(), EchoHandler::read(), BogoTestServer::readBufferAvailable(), BogoTestClient::readBufferAvailable(), FileServerHandler::readException(), folly::TEST(), TEST(), folly::test::TEST(), fizz::test::TEST_F(), fizz::server::test::TEST_F(), fizz::client::test::TEST_F(), testing::internal::TestResultAccessor::test_part_results(), gtest_output_test.GTestOutputTest::testOutput(), TelnetHandler::transportActive(), ThreadPrintingHandler::transportActive(), FileServerHandler::transportActive(), wangle::Handler< Resp, Resp, folly::Req, folly::Req >::transportInactive(), release_docs.WikiBrancher::UpdateLinksInBranchedFiles(), fizz::PlaintextWriteRecordLayer::write(), folly::gen::detail::FileWriter::write(), fizz::detail::Writer< KeyShareEntry >::write(), fizz::detail::Writer< PskIdentity >::write(), fizz::detail::Writer< ServerName >::write(), testing::internal::posix::Write(), write< TokenBinding >(), write< TokenBindingID >(), fizz::WriteRecordLayer::writeAlert(), fizz::WriteRecordLayer::writeAppData(), folly::AsyncPipeWriter::writeChain(), folly::writeFull(), fizz::WriteRecordLayer::writeHandshake(), fizz::PlaintextWriteRecordLayer::writeInitialClientHello(), fizz::test::writeNewSessionTicket(), folly::writeNoInt(), writeToFD(), writeUntilFull(), fizz::detail::WriterVector< N, T >::writeVector(), and fizz::detail::WriterVector< bits24, T >::writeVector().

                                                   {
  Writer<T>().template write<T>(in, appender);
}

template<>

void fizz::detail::write< CertificateEntry > ( const CertificateEntry &  entry, folly::io::Appender &  out  )

inline

Definition at line 203 of file Types-inl.h.

                          {
  writeBuf<detail::bits24>(entry.cert_data, out);
  writeVector<uint16_t>(entry.extensions, out);
}

template<>

void fizz::detail::write< Extension > ( const Extension &  extension, folly::io::Appender &  out  )

inline

Definition at line 194 of file Types-inl.h.

References type, and folly::io::detail::Writable< Derived >::writeBE().

                          {
  out.writeBE(static_cast<typename std::underlying_type<ExtensionType>::type>(
      extension.extension_type));
  writeBuf<uint16_t>(extension.extension_data, out);
}

template<>

void fizz::detail::write< TokenBinding >	(	const TokenBinding &	tokenBinding,
		folly::io::Appender &	out
	)

Definition at line 50 of file Types.cpp.

References write().

                          {
  write(tokenBinding.tokenbinding_type, out);
  write(tokenBinding.tokenbindingid, out);
  writeBuf<uint16_t>(tokenBinding.signature, out);
  writeBuf<uint16_t>(tokenBinding.extensions, out);
}

template<>

void fizz::detail::write< TokenBindingID >	(	const TokenBindingID &	id,
		folly::io::Appender &	out
	)

Definition at line 28 of file Types.cpp.

References write().

                                                                           {
  write(id.key_parameters, out);
  writeBuf<uint16_t>(id.key, out);
}

template<class T >

void fizz::detail::writeBits24	(	T	len,
		folly::io::Appender &	out
	)

Definition at line 102 of file Types-inl.h.

References addr, folly::Endian::big(), folly::io::detail::Writable< Derived >::push(), fizz::detail::bits24::size, T, and uint8_t.

Referenced by fizz::encode< CompressedCertificate & >(), fizz::encodeHandshake(), fizz::test::TEST(), writeBuf< bits24 >(), and fizz::detail::WriterVector< bits24, T >::writeVector().

                                              {
  static_assert(sizeof(T) > 3, "Type is too short");
  checkWithin24bits<T>(len);
  T lenBE = folly::Endian::big(len);
  uint8_t* addr = reinterpret_cast<uint8_t*>(&lenBE);
  uint8_t offset = sizeof(T) - 3;
  out.push(addr + offset, bits24::size);
}

void fizz::detail::writeBuf	(	const Buf &	buf,
		folly::io::Appender &	out
	)

Definition at line 266 of file ExportedAuthenticator.cpp.

References current, i, and folly::io::detail::Writable< Derived >::push().

Referenced by computeFinishedTranscript(), computeTranscript(), proxygen::fakeMockCodec(), proxygen::HTTPCodec::generateConnectionPreface(), proxygen::HTTP2Codec::getUserAgent(), MockCodecDownstreamTest::MockCodecDownstreamTest(), proxygen::PassThroughHTTPCodecFilter::PassThroughHTTPCodecFilter(), proxygen::HTTP2Codec::requestUpgrade(), proxygen::HTTPSession::runLoopCallback(), proxygen::HTTPSession::sendHeaders(), FlowControlFilterTest< initSize >::SetUp(), MockHTTPUpstreamTest::SetUp(), proxygen::HTTP1xCodec::supportsPushTransactions(), proxygen::SPDYCodec::supportsPushTransactions(), TEST(), TEST_F(), TEST_P(), MockCodecDownstreamTest::testConnFlowControlBlocked(), fizz::ExportedAuthenticator::validate(), writeVector(), and proxygen::FlowControlFilter::Callback::~Callback().

                                                    {
  if (buf && !(buf->empty())) {
    auto current = buf.get();
    size_t chainElements = buf->countChainElements();
    for (size_t i = 0; i < chainElements; ++i) {
      out.push(current->data(), current->length());
      current = current->next();
    }
  }
}

template<>

void fizz::detail::writeBuf< bits24 > ( const Buf &  buf, folly::io::Appender &  out  )

inline

Definition at line 179 of file Types-inl.h.

References current, i, folly::io::detail::Writable< Derived >::push(), and writeBits24().

                                                                   {
  if (!buf) {
    writeBits24(static_cast<size_t>(0), out);
    return;
  }
  writeBits24(buf->computeChainDataLength(), out);
  auto current = buf.get();
  size_t chainElements = buf->countChainElements();
  for (size_t i = 0; i < chainElements; ++i) {
    out.push(current->data(), current->length());
    current = current->next();
  }
}

template<class N , class T >

void fizz::detail::writeVector	(	const std::vector< T > &	data,
		folly::io::Appender &	out
	)

Definition at line 149 of file Types-inl.h.

References current, i, folly::io::detail::Writable< Derived >::push(), folly::io::detail::Writable< Derived >::writeBE(), and writeBuf().

                                                                 {
  return WriterVector<N, T>().writeVector(data, out);
}