Add a bridge to fizz::Aead

Author: deadalnix

quic/api/QuicTransportFunctions.cpp

@@ -453,7 +453,7 @@ uint64_t writeQuicDataToSocket(
     QuicConnectionStateBase& connection,
     const ConnectionId& srcConnId,
     const ConnectionId& dstConnId,
-    const fizz::Aead& aead,
+    const Aead& aead,
     const PacketNumberCipher& headerCipher,
     QuicVersion version,
     uint64_t packetLimit) {
@@ -527,7 +527,7 @@ uint64_t writeCryptoAndAckDataToSocket(
     const ConnectionId& srcConnId,
     const ConnectionId& dstConnId,
     LongHeader::Types packetType,
-    fizz::Aead& cleartextCipher,
+    Aead& cleartextCipher,
     const PacketNumberCipher& headerCipher,
     QuicVersion version,
     uint64_t packetLimit,
@@ -572,7 +572,7 @@ uint64_t writeQuicDataExceptCryptoStreamToSocket(
     QuicConnectionStateBase& connection,
     const ConnectionId& srcConnId,
     const ConnectionId& dstConnId,
-    const fizz::Aead& aead,
+    const Aead& aead,
     const PacketNumberCipher& headerCipher,
     QuicVersion version,
     uint64_t packetLimit) {
@@ -640,7 +640,7 @@ uint64_t writeZeroRttDataToSocket(
     QuicConnectionStateBase& connection,
     const ConnectionId& srcConnId,
     const ConnectionId& dstConnId,
-    const fizz::Aead& aead,
+    const Aead& aead,
     const PacketNumberCipher& headerCipher,
     QuicVersion version,
     uint64_t packetLimit) {
@@ -688,7 +688,7 @@ void writeCloseCommon(
     QuicConnectionStateBase& connection,
     PacketHeader&& header,
     folly::Optional<std::pair<QuicErrorCode, std::string>> closeDetails,
-    const fizz::Aead& aead,
+    const Aead& aead,
     const PacketNumberCipher& headerCipher) {
   // close is special, we're going to bypass all the packet sent logic for all
   // packets we send with a connection close frame.
@@ -773,7 +773,7 @@ void writeLongClose(
     const ConnectionId& dstConnId,
     LongHeader::Types headerType,
     folly::Optional<std::pair<QuicErrorCode, std::string>> closeDetails,
-    const fizz::Aead& aead,
+    const Aead& aead,
     const PacketNumberCipher& headerCipher,
     QuicVersion version) {
   if (!connection.serverConnectionId) {
@@ -802,7 +802,7 @@ void writeShortClose(
     QuicConnectionStateBase& connection,
     const ConnectionId& connId,
     folly::Optional<std::pair<QuicErrorCode, std::string>> closeDetails,
-    const fizz::Aead& aead,
+    const Aead& aead,
     const PacketNumberCipher& headerCipher) {
   auto header = ShortHeader(
       ProtectionType::KeyPhaseZero,
@@ -858,7 +858,7 @@ uint64_t writeConnectionDataToSocket(
     QuicPacketScheduler& scheduler,
     const WritableBytesFunc& writableBytesFunc,
     uint64_t packetLimit,
-    const fizz::Aead& aead,
+    const Aead& aead,
     const PacketNumberCipher& headerCipher,
     QuicVersion version,
     Buf token) {
@@ -961,7 +961,7 @@ uint64_t writeProbingDataToSocket(
     PacketNumberSpace pnSpace,
     FrameScheduler scheduler,
     uint8_t probesToSend,
-    const fizz::Aead& aead,
+    const Aead& aead,
     const PacketNumberCipher& headerCipher,
     QuicVersion version) {
   CloningScheduler cloningScheduler(

quic/api/QuicTransportFunctions.h

@@ -39,7 +39,7 @@ uint64_t writeQuicDataToSocket(
     QuicConnectionStateBase& connection,
     const ConnectionId& srcConnId,
     const ConnectionId& dstConnId,
-    const fizz::Aead& aead,
+    const Aead& aead,
     const PacketNumberCipher& headerCipher,
     QuicVersion version,
     uint64_t packetLimit);
@@ -55,7 +55,7 @@ uint64_t writeCryptoAndAckDataToSocket(
     const ConnectionId& srcConnId,
     const ConnectionId& dstConnId,
     LongHeader::Types packetType,
-    fizz::Aead& cleartextCipher,
+    Aead& cleartextCipher,
     const PacketNumberCipher& headerCipher,
     QuicVersion version,
     uint64_t packetLimit,
@@ -71,7 +71,7 @@ uint64_t writeQuicDataExceptCryptoStreamToSocket(
     QuicConnectionStateBase& connection,
     const ConnectionId& srcConnId,
     const ConnectionId& dstConnId,
-    const fizz::Aead& aead,
+    const Aead& aead,
     const PacketNumberCipher& headerCipher,
     QuicVersion version,
     uint64_t packetLimit);
@@ -85,7 +85,7 @@ uint64_t writeZeroRttDataToSocket(
     QuicConnectionStateBase& connection,
     const ConnectionId& srcConnId,
     const ConnectionId& dstConnId,
-    const fizz::Aead& aead,
+    const Aead& aead,
     const PacketNumberCipher& headerCipher,
     QuicVersion version,
     uint64_t packetLimit);
@@ -154,7 +154,7 @@ void writeCloseCommon(
     QuicConnectionStateBase& connection,
     PacketHeader&& header,
     folly::Optional<std::pair<QuicErrorCode, std::string>> closeDetails,
-    const fizz::Aead& aead,
+    const Aead& aead,
     const PacketNumberCipher& headerCipher);
 
 /**
@@ -168,7 +168,7 @@ void writeLongClose(
     const ConnectionId& dstConnId,
     LongHeader::Types headerType,
     folly::Optional<std::pair<QuicErrorCode, std::string>> closeDetails,
-    const fizz::Aead& aead,
+    const Aead& aead,
     const PacketNumberCipher& headerCipher,
     QuicVersion);
 
@@ -181,7 +181,7 @@ void writeShortClose(
     QuicConnectionStateBase& connection,
     const ConnectionId& connId,
     folly::Optional<std::pair<QuicErrorCode, std::string>> closeDetails,
-    const fizz::Aead& aead,
+    const Aead& aead,
     const PacketNumberCipher& headerCipher);
 
 /**
@@ -213,7 +213,7 @@ uint64_t writeConnectionDataToSocket(
     QuicPacketScheduler& scheduler,
     const WritableBytesFunc& writableBytesFunc,
     uint64_t packetLimit,
-    const fizz::Aead& aead,
+    const Aead& aead,
     const PacketNumberCipher& headerCipher,
     QuicVersion version,
     Buf token = nullptr);
@@ -227,7 +227,7 @@ uint64_t writeProbingDataToSocket(
     PacketNumberSpace pnSpace,
     FrameScheduler scheduler,
     uint8_t probesToSend,
-    const fizz::Aead& aead,
+    const Aead& aead,
     const PacketNumberCipher& headerCipher,
     QuicVersion version);
 

quic/api/test/QuicTransportBaseTest.cpp

@@ -332,7 +332,7 @@ class TestQuicTransport
   }
 
   QuicServerConnectionState* transportConn;
-  std::unique_ptr<fizz::Aead> aead;
+  std::unique_ptr<Aead> aead;
   std::unique_ptr<PacketNumberCipher> headerCipher;
   std::unique_ptr<ConnectionIdAlgo> connIdAlgo_;
   bool transportClosed{false};

quic/api/test/QuicTransportFunctionsTest.cpp

@@ -28,7 +28,7 @@ uint64_t writeProbingDataToSocketForTest(
     folly::AsyncUDPSocket& sock,
     QuicConnectionStateBase& conn,
     uint8_t probesToSend,
-    const fizz::Aead& aead,
+    const Aead& aead,
     const PacketNumberCipher& headerCipher,
     QuicVersion version) {
   FrameScheduler scheduler = std::move(FrameScheduler::Builder(
@@ -57,7 +57,7 @@ void writeCryptoDataProbesToSocketForTest(
     folly::AsyncUDPSocket& sock,
     QuicConnectionStateBase& conn,
     uint8_t probesToSend,
-    const fizz::Aead& aead,
+    const Aead& aead,
     const PacketNumberCipher& headerCipher,
     QuicVersion version,
     LongHeader::Types type = LongHeader::Types::Initial) {
@@ -171,7 +171,7 @@ class QuicTransportFunctionsTest : public Test {
     return conn.version.value_or(*conn.originalVersion);
   }
 
-  std::unique_ptr<fizz::Aead> aead;
+  std::unique_ptr<Aead> aead;
   std::unique_ptr<PacketNumberCipher> headerCipher;
   std::unique_ptr<MockQuicStats> transportInfoCb_;
 };

quic/api/test/QuicTransportTest.cpp

@@ -138,7 +138,7 @@ class TestQuicTransport
     drainTimeoutExpired();
   }
 
-  std::unique_ptr<fizz::Aead> aead;
+  std::unique_ptr<Aead> aead;
   std::unique_ptr<PacketNumberCipher> headerCipher;
   bool closed{false};
 };

quic/client/handshake/ClientHandshake.cpp

@@ -90,35 +90,35 @@ void ClientHandshake::doHandshake(
   }
 }
 
-std::unique_ptr<fizz::Aead> ClientHandshake::getOneRttWriteCipher() {
+std::unique_ptr<Aead> ClientHandshake::getOneRttWriteCipher() {
   if (error_) {
     error_.throw_exception();
   }
   return std::move(oneRttWriteCipher_);
 }
 
-std::unique_ptr<fizz::Aead> ClientHandshake::getOneRttReadCipher() {
+std::unique_ptr<Aead> ClientHandshake::getOneRttReadCipher() {
   if (error_) {
     error_.throw_exception();
   }
   return std::move(oneRttReadCipher_);
 }
 
-std::unique_ptr<fizz::Aead> ClientHandshake::getZeroRttWriteCipher() {
+std::unique_ptr<Aead> ClientHandshake::getZeroRttWriteCipher() {
   if (error_) {
     error_.throw_exception();
   }
   return std::move(zeroRttWriteCipher_);
 }
 
-std::unique_ptr<fizz::Aead> ClientHandshake::getHandshakeReadCipher() {
+std::unique_ptr<Aead> ClientHandshake::getHandshakeReadCipher() {
   if (error_) {
     error_.throw_exception();
   }
   return std::move(handshakeReadCipher_);
 }
 
-std::unique_ptr<fizz::Aead> ClientHandshake::getHandshakeWriteCipher() {
+std::unique_ptr<Aead> ClientHandshake::getHandshakeWriteCipher() {
   if (error_) {
     error_.throw_exception();
   }

quic/client/handshake/ClientHandshake.h

@@ -65,31 +65,31 @@ class ClientHandshake : public Handshake {
    * An edge triggered API to get the oneRttWriteCipher. Once you receive the
    * write cipher subsequent calls will return null.
    */
-  std::unique_ptr<fizz::Aead> getOneRttWriteCipher();
+  std::unique_ptr<Aead> getOneRttWriteCipher();
 
   /**
    * An edge triggered API to get the oneRttReadCipher. Once you receive the
    * read cipher subsequent calls will return null.
    */
-  std::unique_ptr<fizz::Aead> getOneRttReadCipher();
+  std::unique_ptr<Aead> getOneRttReadCipher();
 
   /**
    * An edge triggered API to get the zeroRttWriteCipher. Once you receive the
    * zero rtt write cipher subsequent calls will return null.
    */
-  std::unique_ptr<fizz::Aead> getZeroRttWriteCipher();
+  std::unique_ptr<Aead> getZeroRttWriteCipher();
 
   /**
    * An edge triggered API to get the handshakeReadCipher. Once you
    * receive the handshake read cipher subsequent calls will return null.
    */
-  std::unique_ptr<fizz::Aead> getHandshakeReadCipher();
+  std::unique_ptr<Aead> getHandshakeReadCipher();
 
   /**
    * An edge triggered API to get the handshakeWriteCipher. Once you
    * receive the handshake write cipher subsequent calls will return null.
    */
-  std::unique_ptr<fizz::Aead> getHandshakeWriteCipher();
+  std::unique_ptr<Aead> getHandshakeWriteCipher();
 
   /**
    * An edge triggered API to get the one rtt read header cpher. Once you

quic/client/handshake/test/ClientHandshakeTest.cpp

@@ -244,11 +244,11 @@ class ClientHandshakeTest : public Test, public boost::static_visitor<> {
   folly::IOBufQueue serverReadBuf{folly::IOBufQueue::cacheChainLength()};
   std::unique_ptr<DelayedHolder, folly::DelayedDestruction::Destructor> dg;
 
-  std::unique_ptr<fizz::Aead> handshakeWriteCipher;
-  std::unique_ptr<fizz::Aead> handshakeReadCipher;
-  std::unique_ptr<fizz::Aead> oneRttWriteCipher;
-  std::unique_ptr<fizz::Aead> oneRttReadCipher;
-  std::unique_ptr<fizz::Aead> zeroRttWriteCipher;
+  std::unique_ptr<Aead> handshakeWriteCipher;
+  std::unique_ptr<Aead> handshakeReadCipher;
+  std::unique_ptr<Aead> oneRttWriteCipher;
+  std::unique_ptr<Aead> oneRttReadCipher;
+  std::unique_ptr<Aead> zeroRttWriteCipher;
 
   folly::Optional<bool> zeroRttRejected;
 

quic/client/test/QuicClientTransportTest.cpp

@@ -1321,7 +1321,7 @@ class QuicClientTransportTest : public Test {
       bool handshakeCipher = false) {
     QuicFizzFactory fizzFactory;
     auto codec = std::make_unique<QuicReadCodec>(QuicNodeType::Server);
-    std::unique_ptr<fizz::Aead> handshakeReadCipher;
+    std::unique_ptr<Aead> handshakeReadCipher;
     codec->setClientConnectionId(*originalConnId);
     codec->setOneRttReadCipher(test::createNoOpAead());
     codec->setOneRttHeaderCipher(test::createNoOpHeaderCipher());
@@ -1338,7 +1338,7 @@ class QuicClientTransportTest : public Test {
     return codec;
   }
 
-  const fizz::Aead& getInitialCipher() {
+  const Aead& getInitialCipher() {
     return *client->getConn().readCodec->getInitialCipher();
   }
 
@@ -3441,7 +3441,7 @@ Buf getHandshakePacketWithFrame(
     QuicWriteFrame frame,
     ConnectionId srcConnId,
     ConnectionId destConnId,
-    const fizz::Aead& serverWriteCipher,
+    const Aead& serverWriteCipher,
     const PacketNumberCipher& headerCipher) {
   PacketNum packetNum = folly::Random::rand32();
   LongHeader header(

quic/codec/QuicReadCodec.cpp

@@ -104,7 +104,7 @@ CodecResult QuicReadCodec::parseLongHeaderPacket(
   }
   cursor.pull(sample.data(), sample.size());
   const PacketNumberCipher* headerCipher{nullptr};
-  const fizz::Aead* cipher{nullptr};
+  const Aead* cipher{nullptr};
   auto protectionType = longHeader.getProtectionType();
   switch (protectionType) {
     case ProtectionType::Initial:
@@ -334,15 +334,15 @@ CodecResult QuicReadCodec::parsePacket(
   return decodeRegularPacket(std::move(*shortHeader), params_, packetCursor);
 }
 
-const fizz::Aead* QuicReadCodec::getOneRttReadCipher() const {
+const Aead* QuicReadCodec::getOneRttReadCipher() const {
   return oneRttReadCipher_.get();
 }
 
-const fizz::Aead* QuicReadCodec::getZeroRttReadCipher() const {
+const Aead* QuicReadCodec::getZeroRttReadCipher() const {
   return zeroRttReadCipher_.get();
 }
 
-const fizz::Aead* QuicReadCodec::getHandshakeReadCipher() const {
+const Aead* QuicReadCodec::getHandshakeReadCipher() const {
   return handshakeReadCipher_.get();
 }
 
@@ -352,17 +352,17 @@ QuicReadCodec::getStatelessResetToken() const {
 }
 
 void QuicReadCodec::setInitialReadCipher(
-    std::unique_ptr<fizz::Aead> initialReadCipher) {
+    std::unique_ptr<Aead> initialReadCipher) {
   initialReadCipher_ = std::move(initialReadCipher);
 }
 
 void QuicReadCodec::setOneRttReadCipher(
-    std::unique_ptr<fizz::Aead> oneRttReadCipher) {
+    std::unique_ptr<Aead> oneRttReadCipher) {
   oneRttReadCipher_ = std::move(oneRttReadCipher);
 }
 
 void QuicReadCodec::setZeroRttReadCipher(
-    std::unique_ptr<fizz::Aead> zeroRttReadCipher) {
+    std::unique_ptr<Aead> zeroRttReadCipher) {
   if (nodeType_ == QuicNodeType::Client) {
     throw QuicTransportException(
         "Invalid cipher", TransportErrorCode::INTERNAL_ERROR);
@@ -371,7 +371,7 @@ void QuicReadCodec::setZeroRttReadCipher(
 }
 
 void QuicReadCodec::setHandshakeReadCipher(
-    std::unique_ptr<fizz::Aead> handshakeReadCipher) {
+    std::unique_ptr<Aead> handshakeReadCipher) {
   handshakeReadCipher_ = std::move(handshakeReadCipher);
 }
 
@@ -412,7 +412,7 @@ void QuicReadCodec::setStatelessResetToken(
   statelessResetToken_ = std::move(statelessResetToken);
 }
 
-const fizz::Aead* QuicReadCodec::getInitialCipher() const {
+const Aead* QuicReadCodec::getInitialCipher() const {
   return initialReadCipher_.get();
 }