From 5d90bc115ab1869a313097ddb360ab2991240dca Mon Sep 17 00:00:00 2001 From: funa-tk <1781263+funa-tk@users.noreply.github.com> Date: Sun, 4 Sep 2022 00:01:24 +0900 Subject: [PATCH] add experimental quic codes --- LICENSES/Agent15-LICENSE | 165 ++++++++++++ LICENSES/bouncy-castle-LICENSE | 8 - LICENSES/jackson-databind-LICENSE | 202 -------------- LICENSES/jackson-dataformat-cbor-LICENSE | 202 -------------- LICENSES/jackson-dataformat-msgpack-LICENSE | 202 -------------- LICENSES/pulpcore-LICENSE | 26 -- build.gradle | 14 +- libs/agent15.jar | Bin 0 -> 139260 bytes .../core/packetproxy/PrivateDNSClient.java | 87 ++++-- .../java/core/packetproxy/ProxyFactory.java | 12 +- .../packetproxy/ProxyHttpTransparent.java | 4 +- .../core/packetproxy/ProxyQuicForward.java | 66 +++++ .../packetproxy/ProxyQuicTransparent.java | 73 +++++ .../gui/GUIOptionListenPortDialog.java | 17 +- .../packetproxy/gui/GUIOptionListenPorts.java | 2 +- src/main/java/core/packetproxy/http/Http.java | 2 +- .../java/core/packetproxy/http2/Grpc.java | 2 +- .../http2/frames/HeadersFrame.java | 10 +- .../core/packetproxy/model/ListenPort.java | 12 +- .../java/core/packetproxy/model/Server.java | 4 +- .../quic/service/LossDetection.java | 125 +++++++++ .../core/packetproxy/quic/service/Pto.java | 98 +++++++ .../quic/service/RttEstimator.java | 82 ++++++ .../service/connection/ClientConnection.java | 87 ++++++ .../service/connection/ClientConnections.java | 106 ++++++++ .../quic/service/connection/Connection.java | 251 ++++++++++++++++++ .../service/connection/ServerConnection.java | 92 +++++++ .../connection/helper/AwaitingPackets.java | 61 +++++ .../quic/service/frame/FrameParser.java | 82 ++++++ .../quic/service/frame/Frames.java | 97 +++++++ .../quic/service/frame/FramesBuilder.java | 60 +++++ .../framegenerator/AckFrameGenerator.java | 120 +++++++++ .../CryptoFramesToMessages.java | 139 ++++++++++ .../MessagesToCryptoFrames.java | 58 ++++ .../MessagesToStreamFrames.java | 81 ++++++ .../StreamFramesToMessages.java | 83 ++++++ .../helper/ContinuousStream.java | 65 +++++ .../framegenerator/helper/OneshotStream.java | 61 +++++ .../helper/ReceivedPacketNumbers.java | 85 ++++++ .../service/handshake/ClientHandshake.java | 161 +++++++++++ .../quic/service/handshake/Handshake.java | 25 ++ .../service/handshake/HandshakeState.java | 59 ++++ .../service/handshake/ServerHandshake.java | 219 +++++++++++++++ .../packetproxy/quic/service/key/Keys.java | 104 ++++++++ .../quic/service/key/RoleKeys.java | 102 +++++++ .../service/packet/QuicPacketBuilder.java | 88 ++++++ .../quic/service/packet/QuicPacketParser.java | 124 +++++++++ .../quic/service/pnspace/PnSpace.java | 239 +++++++++++++++++ .../quic/service/pnspace/PnSpaces.java | 106 ++++++++ .../service/pnspace/helper/LostPackets.java | 51 ++++ .../pnspace/helper/SendFrameQueue.java | 54 ++++ .../service/pnspace/helper/SentPackets.java | 99 +++++++ .../pnspace/level/ApplicationDataPnSpace.java | 66 +++++ .../pnspace/level/HandshakePnSpace.java | 61 +++++ .../service/pnspace/level/InitialPnSpace.java | 63 +++++ .../TransportParameterParser.java | 67 +++++ .../TransportParameters.java | 174 ++++++++++++ .../quic/utils/AwaitingException.java | 23 ++ .../packetproxy/quic/utils/Constants.java | 45 ++++ .../packetproxy/quic/utils/PacketNumbers.java | 57 ++++ .../quic/utils/ScheduledTimer.java | 53 ++++ .../packetproxy/quic/value/ConnectionId.java | 54 ++++ .../quic/value/ConnectionIdPair.java | 30 +++ .../quic/value/FixedLengthPrecededBytes.java | 50 ++++ .../packetproxy/quic/value/PacketNumber.java | 89 +++++++ .../packetproxy/quic/value/QuicMessage.java | 77 ++++++ .../packetproxy/quic/value/SentPacket.java | 50 ++++ .../packetproxy/quic/value/SimpleBytes.java | 39 +++ .../core/packetproxy/quic/value/Token.java | 47 ++++ .../quic/value/TruncatedPacketNumber.java | 135 ++++++++++ .../quic/value/VariableLengthInteger.java | 112 ++++++++ .../value/VariableLengthPrecededBytes.java | 50 ++++ .../quic/value/frame/AckEcnFrame.java | 105 ++++++++ .../quic/value/frame/AckFrame.java | 118 ++++++++ .../value/frame/ConnectionCloseFrame.java | 74 ++++++ .../quic/value/frame/CryptoFrame.java | 79 ++++++ .../packetproxy/quic/value/frame/Frame.java | 27 ++ .../quic/value/frame/HandshakeDoneFrame.java | 56 ++++ .../value/frame/NewConnectionIdFrame.java | 90 +++++++ .../quic/value/frame/NewTokenFrame.java | 76 ++++++ .../quic/value/frame/PaddingFrame.java | 61 +++++ .../quic/value/frame/PingFrame.java | 56 ++++ .../quic/value/frame/ResetStreamFrame.java | 81 ++++++ .../quic/value/frame/StopSendingFrame.java | 77 ++++++ .../value/frame/StreamDataBlockedFrame.java | 62 +++++ .../quic/value/frame/StreamFrame.java | 111 ++++++++ .../value/frame/StreamsBlockedBidiFrame.java | 60 +++++ .../value/frame/StreamsBlockedUniFrame.java | 60 +++++ .../quic/value/frame/UnknownFrame.java | 60 +++++ .../quic/value/frame/helper/AckRange.java | 63 +++++ .../quic/value/frame/helper/AckRanges.java | 90 +++++++ .../core/packetproxy/quic/value/key/Key.java | 109 ++++++++ .../quic/value/key/level/ApplicationKey.java | 36 +++ .../quic/value/key/level/HandshakeKey.java | 36 +++ .../quic/value/key/level/InitialKey.java | 44 +++ .../quic/value/key/level/ZeroRttKey.java | 36 +++ .../quic/value/packet/PnSpacePacket.java | 38 +++ .../quic/value/packet/QuicPacket.java | 93 +++++++ .../packet/longheader/LongHeaderPacket.java | 125 +++++++++ .../longheader/LongHeaderPnSpacePacket.java | 187 +++++++++++++ .../value/packet/longheader/RetryPacket.java | 68 +++++ .../longheader/pnspace/HandshakePacket.java | 58 ++++ .../longheader/pnspace/InitialPacket.java | 83 ++++++ .../longheader/pnspace/ZeroRttPacket.java | 60 +++++ .../packet/shortheader/ShortHeaderPacket.java | 187 +++++++++++++ .../TransportParameter.java | 74 ++++++ .../transportparameter/UnknownParameter.java | 42 +++ .../bool/DisableActiveMigrationParameter.java | 40 +++ .../bool/ExpGreaseQuicBitParameter.java | 40 +++ .../bytearray/InitSrcConnIdParameter.java | 43 +++ .../bytearray/OrigDestConnIdParameter.java | 44 +++ .../bytearray/RetrySrcConnIdParameter.java | 44 +++ .../StatelessResetTokenParameter.java | 44 +++ .../complex/PreferredAddressParameter.java | 40 +++ .../number/AckDelayExponentParameter.java | 28 ++ .../number/ActiveConnIdLimitParameter.java | 28 ++ .../number/ExpMinAckDelayParameter.java | 29 ++ .../number/InitMaxDataParameter.java | 28 ++ .../number/InitMaxStreamBidiParameter.java | 28 ++ .../InitMaxStreamDataBidiLocalParameter.java | 28 ++ .../InitMaxStreamDataBidiRemoteParameter.java | 28 ++ .../number/InitMaxStreamDataUniParameter.java | 28 ++ .../number/InitMaxStreamUniParameter.java | 28 ++ .../number/MaxAckDelayParameter.java | 28 ++ .../number/MaxIdleTimeoutParameter.java | 28 ++ .../number/MaxUdpPayloadSizeParameter.java | 28 ++ .../number/OldMinAckDelayParameter.java | 30 +++ .../number/OldTimestampParameter.java | 28 ++ .../java/core/packetproxy/util/Throwing.java | 20 ++ .../packetproxy/util/ThrowingConsumer.java | 18 ++ .../packetproxy/PrivateDNSClientTest.java | 83 ++++++ .../java/packetproxy/http3/QpackTest.java | 81 ++++++ .../ackgenerator/AckFrameGeneratorTest.java | 123 +++++++++ .../ReceivedQuicPacketNumbersTest.java | 115 ++++++++ .../CryptoFramesToMessagesTest.java | 141 ++++++++++ .../quic/service/pnspace/SentPacketsTest.java | 64 +++++ .../TransportParametersTest.java | 37 +++ .../quic/value/ConnectionIdTest.java | 49 ++++ .../quic/value/QuicPacketNumbersTest.java | 36 +++ .../value/TruncatedQuicPacketNumberTest.java | 120 +++++++++ .../quic/value/VariableLengthIntegerTest.java | 92 +++++++ .../quic/value/frame/AckEcnFrameTest.java | 43 +++ .../quic/value/frame/AckFrameTest.java | 76 ++++++ .../quic/value/frame/CryptoFrameTest.java | 44 +++ .../quic/value/frame/FramesTest.java | 52 ++++ .../value/frame/NewConnectionIdFrameTest.java | 38 +++ .../quic/value/packet/InitialPacketTest.java | 148 +++++++++++ .../quic/value/packet/helper/TestPacket.java | 82 ++++++ .../shortheader/ShortHeaderPacketTest.java | 40 +++ .../DisableActiveMigrationParameterTest.java | 14 + 150 files changed, 9922 insertions(+), 682 deletions(-) create mode 100644 LICENSES/Agent15-LICENSE delete mode 100644 LICENSES/bouncy-castle-LICENSE delete mode 100644 LICENSES/jackson-databind-LICENSE delete mode 100644 LICENSES/jackson-dataformat-cbor-LICENSE delete mode 100644 LICENSES/jackson-dataformat-msgpack-LICENSE delete mode 100644 LICENSES/pulpcore-LICENSE create mode 100644 libs/agent15.jar create mode 100644 src/main/java/core/packetproxy/ProxyQuicForward.java create mode 100644 src/main/java/core/packetproxy/ProxyQuicTransparent.java create mode 100644 src/main/java/core/packetproxy/quic/service/LossDetection.java create mode 100644 src/main/java/core/packetproxy/quic/service/Pto.java create mode 100644 src/main/java/core/packetproxy/quic/service/RttEstimator.java create mode 100644 src/main/java/core/packetproxy/quic/service/connection/ClientConnection.java create mode 100644 src/main/java/core/packetproxy/quic/service/connection/ClientConnections.java create mode 100644 src/main/java/core/packetproxy/quic/service/connection/Connection.java create mode 100644 src/main/java/core/packetproxy/quic/service/connection/ServerConnection.java create mode 100644 src/main/java/core/packetproxy/quic/service/connection/helper/AwaitingPackets.java create mode 100644 src/main/java/core/packetproxy/quic/service/frame/FrameParser.java create mode 100644 src/main/java/core/packetproxy/quic/service/frame/Frames.java create mode 100644 src/main/java/core/packetproxy/quic/service/frame/FramesBuilder.java create mode 100644 src/main/java/core/packetproxy/quic/service/framegenerator/AckFrameGenerator.java create mode 100644 src/main/java/core/packetproxy/quic/service/framegenerator/CryptoFramesToMessages.java create mode 100644 src/main/java/core/packetproxy/quic/service/framegenerator/MessagesToCryptoFrames.java create mode 100644 src/main/java/core/packetproxy/quic/service/framegenerator/MessagesToStreamFrames.java create mode 100644 src/main/java/core/packetproxy/quic/service/framegenerator/StreamFramesToMessages.java create mode 100644 src/main/java/core/packetproxy/quic/service/framegenerator/helper/ContinuousStream.java create mode 100644 src/main/java/core/packetproxy/quic/service/framegenerator/helper/OneshotStream.java create mode 100644 src/main/java/core/packetproxy/quic/service/framegenerator/helper/ReceivedPacketNumbers.java create mode 100644 src/main/java/core/packetproxy/quic/service/handshake/ClientHandshake.java create mode 100644 src/main/java/core/packetproxy/quic/service/handshake/Handshake.java create mode 100644 src/main/java/core/packetproxy/quic/service/handshake/HandshakeState.java create mode 100644 src/main/java/core/packetproxy/quic/service/handshake/ServerHandshake.java create mode 100644 src/main/java/core/packetproxy/quic/service/key/Keys.java create mode 100644 src/main/java/core/packetproxy/quic/service/key/RoleKeys.java create mode 100644 src/main/java/core/packetproxy/quic/service/packet/QuicPacketBuilder.java create mode 100644 src/main/java/core/packetproxy/quic/service/packet/QuicPacketParser.java create mode 100644 src/main/java/core/packetproxy/quic/service/pnspace/PnSpace.java create mode 100644 src/main/java/core/packetproxy/quic/service/pnspace/PnSpaces.java create mode 100644 src/main/java/core/packetproxy/quic/service/pnspace/helper/LostPackets.java create mode 100644 src/main/java/core/packetproxy/quic/service/pnspace/helper/SendFrameQueue.java create mode 100644 src/main/java/core/packetproxy/quic/service/pnspace/helper/SentPackets.java create mode 100644 src/main/java/core/packetproxy/quic/service/pnspace/level/ApplicationDataPnSpace.java create mode 100644 src/main/java/core/packetproxy/quic/service/pnspace/level/HandshakePnSpace.java create mode 100644 src/main/java/core/packetproxy/quic/service/pnspace/level/InitialPnSpace.java create mode 100644 src/main/java/core/packetproxy/quic/service/transportparameter/TransportParameterParser.java create mode 100644 src/main/java/core/packetproxy/quic/service/transportparameter/TransportParameters.java create mode 100644 src/main/java/core/packetproxy/quic/utils/AwaitingException.java create mode 100644 src/main/java/core/packetproxy/quic/utils/Constants.java create mode 100644 src/main/java/core/packetproxy/quic/utils/PacketNumbers.java create mode 100644 src/main/java/core/packetproxy/quic/utils/ScheduledTimer.java create mode 100644 src/main/java/core/packetproxy/quic/value/ConnectionId.java create mode 100644 src/main/java/core/packetproxy/quic/value/ConnectionIdPair.java create mode 100644 src/main/java/core/packetproxy/quic/value/FixedLengthPrecededBytes.java create mode 100644 src/main/java/core/packetproxy/quic/value/PacketNumber.java create mode 100644 src/main/java/core/packetproxy/quic/value/QuicMessage.java create mode 100644 src/main/java/core/packetproxy/quic/value/SentPacket.java create mode 100644 src/main/java/core/packetproxy/quic/value/SimpleBytes.java create mode 100644 src/main/java/core/packetproxy/quic/value/Token.java create mode 100644 src/main/java/core/packetproxy/quic/value/TruncatedPacketNumber.java create mode 100644 src/main/java/core/packetproxy/quic/value/VariableLengthInteger.java create mode 100644 src/main/java/core/packetproxy/quic/value/VariableLengthPrecededBytes.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/AckEcnFrame.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/AckFrame.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/ConnectionCloseFrame.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/CryptoFrame.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/Frame.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/HandshakeDoneFrame.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/NewConnectionIdFrame.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/NewTokenFrame.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/PaddingFrame.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/PingFrame.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/ResetStreamFrame.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/StopSendingFrame.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/StreamDataBlockedFrame.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/StreamFrame.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/StreamsBlockedBidiFrame.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/StreamsBlockedUniFrame.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/UnknownFrame.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/helper/AckRange.java create mode 100644 src/main/java/core/packetproxy/quic/value/frame/helper/AckRanges.java create mode 100644 src/main/java/core/packetproxy/quic/value/key/Key.java create mode 100644 src/main/java/core/packetproxy/quic/value/key/level/ApplicationKey.java create mode 100644 src/main/java/core/packetproxy/quic/value/key/level/HandshakeKey.java create mode 100644 src/main/java/core/packetproxy/quic/value/key/level/InitialKey.java create mode 100644 src/main/java/core/packetproxy/quic/value/key/level/ZeroRttKey.java create mode 100644 src/main/java/core/packetproxy/quic/value/packet/PnSpacePacket.java create mode 100644 src/main/java/core/packetproxy/quic/value/packet/QuicPacket.java create mode 100644 src/main/java/core/packetproxy/quic/value/packet/longheader/LongHeaderPacket.java create mode 100644 src/main/java/core/packetproxy/quic/value/packet/longheader/LongHeaderPnSpacePacket.java create mode 100644 src/main/java/core/packetproxy/quic/value/packet/longheader/RetryPacket.java create mode 100644 src/main/java/core/packetproxy/quic/value/packet/longheader/pnspace/HandshakePacket.java create mode 100644 src/main/java/core/packetproxy/quic/value/packet/longheader/pnspace/InitialPacket.java create mode 100644 src/main/java/core/packetproxy/quic/value/packet/longheader/pnspace/ZeroRttPacket.java create mode 100644 src/main/java/core/packetproxy/quic/value/packet/shortheader/ShortHeaderPacket.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/TransportParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/UnknownParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/bool/DisableActiveMigrationParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/bool/ExpGreaseQuicBitParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/bytearray/InitSrcConnIdParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/bytearray/OrigDestConnIdParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/bytearray/RetrySrcConnIdParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/bytearray/StatelessResetTokenParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/complex/PreferredAddressParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/number/AckDelayExponentParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/number/ActiveConnIdLimitParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/number/ExpMinAckDelayParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxDataParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamBidiParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamDataBidiLocalParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamDataBidiRemoteParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamDataUniParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamUniParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/number/MaxAckDelayParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/number/MaxIdleTimeoutParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/number/MaxUdpPayloadSizeParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/number/OldMinAckDelayParameter.java create mode 100644 src/main/java/core/packetproxy/quic/value/transportparameter/number/OldTimestampParameter.java create mode 100644 src/main/java/core/packetproxy/util/Throwing.java create mode 100644 src/main/java/core/packetproxy/util/ThrowingConsumer.java create mode 100644 src/test/java/packetproxy/PrivateDNSClientTest.java create mode 100644 src/test/java/packetproxy/http3/QpackTest.java create mode 100644 src/test/java/packetproxy/quic/service/ackgenerator/AckFrameGeneratorTest.java create mode 100644 src/test/java/packetproxy/quic/service/ackgenerator/ReceivedQuicPacketNumbersTest.java create mode 100644 src/test/java/packetproxy/quic/service/framegenerator/CryptoFramesToMessagesTest.java create mode 100644 src/test/java/packetproxy/quic/service/pnspace/SentPacketsTest.java create mode 100644 src/test/java/packetproxy/quic/service/transportparameter/TransportParametersTest.java create mode 100644 src/test/java/packetproxy/quic/value/ConnectionIdTest.java create mode 100644 src/test/java/packetproxy/quic/value/QuicPacketNumbersTest.java create mode 100644 src/test/java/packetproxy/quic/value/TruncatedQuicPacketNumberTest.java create mode 100644 src/test/java/packetproxy/quic/value/VariableLengthIntegerTest.java create mode 100644 src/test/java/packetproxy/quic/value/frame/AckEcnFrameTest.java create mode 100644 src/test/java/packetproxy/quic/value/frame/AckFrameTest.java create mode 100644 src/test/java/packetproxy/quic/value/frame/CryptoFrameTest.java create mode 100644 src/test/java/packetproxy/quic/value/frame/FramesTest.java create mode 100644 src/test/java/packetproxy/quic/value/frame/NewConnectionIdFrameTest.java create mode 100644 src/test/java/packetproxy/quic/value/packet/InitialPacketTest.java create mode 100644 src/test/java/packetproxy/quic/value/packet/helper/TestPacket.java create mode 100644 src/test/java/packetproxy/quic/value/packet/shortheader/ShortHeaderPacketTest.java create mode 100644 src/test/java/packetproxy/quic/value/transportparameter/bool/DisableActiveMigrationParameterTest.java diff --git a/LICENSES/Agent15-LICENSE b/LICENSES/Agent15-LICENSE new file mode 100644 index 0000000..4bc4625 --- /dev/null +++ b/LICENSES/Agent15-LICENSE @@ -0,0 +1,165 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. \ No newline at end of file diff --git a/LICENSES/bouncy-castle-LICENSE b/LICENSES/bouncy-castle-LICENSE deleted file mode 100644 index d067d15..0000000 --- a/LICENSES/bouncy-castle-LICENSE +++ /dev/null @@ -1,8 +0,0 @@ -LICENSE -Copyright (c) 2000 - 2019 The Legion of the Bouncy Castle Inc. (https://www.bouncycastle.org) - -Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/LICENSES/jackson-databind-LICENSE b/LICENSES/jackson-databind-LICENSE deleted file mode 100644 index 7a4a3ea..0000000 --- a/LICENSES/jackson-databind-LICENSE +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/LICENSES/jackson-dataformat-cbor-LICENSE b/LICENSES/jackson-dataformat-cbor-LICENSE deleted file mode 100644 index 7a4a3ea..0000000 --- a/LICENSES/jackson-dataformat-cbor-LICENSE +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/LICENSES/jackson-dataformat-msgpack-LICENSE b/LICENSES/jackson-dataformat-msgpack-LICENSE deleted file mode 100644 index 7a4a3ea..0000000 --- a/LICENSES/jackson-dataformat-msgpack-LICENSE +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. \ No newline at end of file diff --git a/LICENSES/pulpcore-LICENSE b/LICENSES/pulpcore-LICENSE deleted file mode 100644 index 517bd47..0000000 --- a/LICENSES/pulpcore-LICENSE +++ /dev/null @@ -1,26 +0,0 @@ -Copyright (c) 2007, Interactive Pulp, LLC -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. - * Neither the name of Interactive Pulp, LLC nor the names of its - contributors may be used to endorse or promote products derived from - this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE -LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -POSSIBILITY OF SUCH DAMAGE. diff --git a/build.gradle b/build.gradle index b0102b8..b78d0b6 100644 --- a/build.gradle +++ b/build.gradle @@ -25,10 +25,15 @@ repositories { dependencies { - compileOnly 'org.projectlombok:lombok:1.18.20' - annotationProcessor 'org.projectlombok:lombok:1.18.20' + compileOnly 'org.projectlombok:lombok:1.18.22' + annotationProcessor 'org.projectlombok:lombok:1.18.22' + testCompileOnly 'org.projectlombok:lombok:1.18.22' + testAnnotationProcessor 'org.projectlombok:lombok:1.18.22' testImplementation 'org.junit.jupiter:junit-jupiter:5.4.2' + testImplementation 'org.assertj:assertj-core:3.23.1' + testImplementation 'org.mockito:mockito-core:4.7.0' + testImplementation 'org.projectlombok:lombok:1.18.22' implementation 'com.google.guava:guava:24.1-jre' implementation 'commons-codec:commons-codec:1.6' @@ -50,13 +55,16 @@ dependencies { implementation 'com.fasterxml.jackson.core:jackson-databind:2.10.0' implementation 'org.msgpack:jackson-dataformat-msgpack:0.8.18' implementation 'org.bouncycastle:bcpkix-jdk15on:1.64' - implementation 'org.eclipse.jetty.http2:http2-hpack:9.4.22.v20191022' implementation 'commons-net:commons-net:3.6' implementation 'org.nanohttpd:nanohttpd:2.3.1' implementation 'com.google.code.gson:gson:2.8.6' implementation 'org.apache.commons:commons-math3:3.0' implementation 'org.jfree:jfreechart:1.5.3' implementation 'org.ejml:ejml-all:0.41' + implementation 'at.favre.lib:hkdf:1.1.0' + implementation 'org.eclipse.jetty.http2:http2-hpack:11.0.11' + implementation 'org.eclipse.jetty.http3:http3-qpack:11.0.11' + implementation files('libs/agent15.jar') izpack 'org.codehaus.izpack:izpack-dist:5.1.3' diff --git a/libs/agent15.jar b/libs/agent15.jar new file mode 100644 index 0000000000000000000000000000000000000000..26abd4737df558cb7f40ed26c9c554d4e015f6c2 GIT binary patch literal 139260 zcmb4q1CS=cx@Aur)0(!8zcp>!wr#urHl}S%+tapf+qP}nJNLca7klq}aW^(2s-hy} zR905jm#0pCbxK|e3>+2&1R5Gdpp!@i(#^n2(Nay0Pt_^X&ogZw+{%oP&pA&@ z(9kt14olI_i~%Ml#>Z$DsYd{d0j2u~y9c2EaHK z^<=f3O}&8X`}>62hT`u44EWg6D)hw7WUVOn)XPE>jpU$pb@@yKk6>vFHuCju)4#d} zh0hsXp8A_x8F+9bRcFsSK8DsS*V!`7e*wd{8Vq`?A5%MROvqtK#&lEmWVJG3?GzQ% z0tI#gV_A{Qrf8|R$dRxq3(=6$pncmbYA=yX&9`XgzRjcfCjceCsH93N1(;uK`{WDD7)L6{O6z~D(T3fC?N49+pf55plj9) zCubGg2%w`1TazV18X1B0FN*HYx#*n6T`ZnM1!wKp@$1b)`B94I?W_=(WO!PLD;Uno zJWft#rZOF^bG@BCHD!SuI`F~5u%Sr{#K*=lR1gMZb*}Hmt|9lM)z+=2Mi7o%;9=c; zpRH>-fe7x*J$YRWHaYIp*zhr7EG8Rb*vPH${Byz}orpKLbe?U&kyP~3SfpZ8wd}~P z=jvtmUUiGRz&E2;1>wBLh@ZapeTQ}f0Xm76VR)|r>Y!*04f4Xhsk#F+1bQN$Ne4q} zU=eP2TCEY+iOhUarm1wvW;GV#^c1pBv9-O#?j)^(3%+8vEopApr1c`6rs?}ejprBYaXIskzqq4 z87^rKY!9!)+}2B0>5r9<74|3cQH1R~{+hN}{N8qebmRvt+(T78OE27suWXrQLI?Z9 zbulT&TF^Rg;Tm6pW_oNEK4V9T7R+wpYaOTMA%QT>H;x!$Mi?%T0o8}(t~PutwgUF% z|3@g0H+G0#+Nvt_LjDt4bnT_?7`aVSanwiT8R^H=6-O+eXqiVs5L`3mE-HtlLWl@r>SXPtZ4hLIMc&a6@H&V-$buNK&1Gb_WG#cx3INDApd9 zK#|FNSMjqEaY~@?F)!*)W^8Y-QXk(i{KX8gLdsK~`c1!Ws5S<(o$M{z_zGzykJrLD zaKcbhfpjQQ(+Lk;s4?4JXi5aHy-6AT2T1QG;<_Wu>&vIaIL#$t|k&i4O1wv{gw z*Hn>sFvgO~sf1mMU!bQUzb}*bEH8sw3Q7PZ)|;nA`zz98unfQ*sK&6QCimt337K2sH4q~tb;Z{BORTyJb`nVTrz@=o1lUFRCSw{9S6S*BoaZL2nJHGO#PKi(_P z>|D6{syn*ny3Wc2)1;`$78870)b;ru%hl;HR3Q?~3T9ys5D*>-I0gn>KWBFrc4PH4 zwRL!Jli>zH9Ee`G) zl8&sORy}21mo}Zk6biN{{kj{ZFKRyKC)*lbQ=0s3$GFNf4#49ZWanJYT$%<(bJ}+m zV2(aXWa`ReEvxD1y+%hDEE{Dndh*cWsY`*sRnMmD0(6sAm>A0{ST^K|;|y{grOn39 z8kROa-_Gg@HcszbWsXE6*#5BVwshClZ#M2hHF5f6?`namJs0TFPj|b5I$gE=_9I(o zs`h__JakCyPyvf?Hr5ZHU`}UF$6~FsK3q0lHeT7cm(ai7&j#K5YWn8!kY+oSR};** zVq{id_q1#Q$?Wm+3_pBT@e?E~X=xkMchRs~QH^+v9N}gMLc(s+o9H-fj>l5@Wb&v_w8BgLNqk17R4l zL}c3hkJ$bcQo6L8KzULI+tXi2XeV=G^YX9s<)Za50%gc&ef8Lu1QKOA4-CdE(z%M@ z{ZU9r9HK~9M(Z9hH@g?k1^fG~I(PWCeLYUN+hVNT>gvXn`PtH4POu3yY;T4XaXGp3AF3 zo`eO3Uu;~S`*Er}Pit&;n@^jr?N?uTLVw<_ON2m7!{XP?yV2Qf2W%Xhbr7^vyk_7< z=%|~8c6fUTl-Ey!aa<2}rJA{*9+nGt@!4)`L^{1R20Cm}cX=f`x1yl&hkF9t#Ah4Z zIJjw+@JAqDUzNE}d)3x4Lx!}MiI%#kLWXqQ1Z}rYdg(C!BuKUCEbj?c!FlQ|Q*d0l z?f@_lhEIB8l}}T(y->DB2bylq#Y z93LGK5`9D_eMmzH#&#%d+ryXkSF%dobOvxhU#JbwaQt_Ck!`-G&)|QXz(By6c_HFK zXEFqB$$tYCUH+a%8m)I|^+?O*xso>Mq=lXS(Rnaog+AXjUv=}Q$_5La<;#__jGGVw zm$rC5N{On0%<^vaP>if@dCyGFmSB3U!Itbl&pJkB>CoeV9`B%&l>Z)>j~0tL z5giDT5eDH`euw?cn(jE>0%~#)0M3Sk@e-9{y#B*l&o0Fo?FgFvPzTo5u(-N z-nC78hnKdds&lRw5j-@34D^pWc@^`ZsK_ekZjH+yxO!4V7~|xzGKJO$^GLhT+rUtJ zdc}=tBW(DaXao{XwVM$-qOCz&xp?GD<|Wu>e?UcjpjqZ`X`|qIF~Xmw zrwUB)Q3`+{HwKTmbT&)i$vnsUiIj+3TvB{)YBU*{$p$*Q^1Ji^Y_R^` zpi7?CC<&c*W-x$dcV0o4=%)GEO(eB@b`MkH<4vC_tNcLI4ks^po2BtT&r z9}$@d-X%LRA!}(HCtq5MauAOAlN9K@@&hxAL<#8j~>8=vCbtF|=XM+3E8 zXj~|y5RraQh>mNU4!`5i*^_IkybJdIyrG7-+ogr?g2YSO;)}O@hTr_5?&f73tGK0l zqXpm9cf~>jDT9-Uu1*kj%JYK+JB@V2bzPeb;!B{9>p3r&&!8@x&+3`_v(SJD-NFs= z%IcZxlSrOJJ{O-c*Yp82FB7en0Xs@qsYF&k^5;7K$teO>p+fI59gL~^i<}<{DF-&o z>I7;5sqw)~9J~kRWZ4G>g4HufIs`fV>ew}2bsJU$<}?@-;p60LQ(-+KCTk6(;>*f7cFfDIh&JIB+f)!^@2%)Fel^029i{| z^78V+#G58vSsHRSQ`mCeGoq8e5UJtdc=2Y(IQ^0+XbrNgm%48!vh1vV9(mxfqDUh- zuAoAY5(*V-{2^8ML)tL1t;{~G42nCk9tw%DA35xRxJ=}aJQnb3K@|Lxc$Q{<6p{5v z1S^@ynSS-1g?@Hi)d4pd)Cicg6iQj7;*V!cv|{|vYkCS%c!h_saNzeBX_C@(WR2YD z1(}(Ladldud!>)D;0=W+aT{4y73n(bvO&iUKA>5FrdaFn%!o&euoOyA2+L3Y+kO;;;zg$YO!plzfOPlbp+15I-83P#`nhsTc9ge4lAKvvUJ2 z&xSISUAL!?>%2Nj-FvlZhd@Ljyh>Jxfmo23)`gL!b4`xchS1*h#{O5|8pW9ZdBeLE ziNf4%(68>q=LyPm_A-o-%Y@6v(KDPvJK*RfQHFm1p9$o;RX7TgiRrdyyhTLhFcpAr z3};gcDLLXE0s)`;04h37M;q6?5<#7C!lTh5GGddIol29ixQ=<3LIFb`bpD3UIX?+{ zmHWYvDNEof>Dp@D5%!1ok4~y*h5tuzpM8L4#)6nF{E&2Ro|lsI+vyl=Dzc-^qqdrywSrvn1f_@)25S7 z)*5#~`jIVq0e;C~U5!0kH9pY}!SXsuaG{tv+}~X|v+wNQ%_Vvgm3qWBL<+fpL5Wp3 zf{d1S*gpzp4rVb(5Wp`5)nz0?ZR;MWglBlhwjr+K?>mrXafzJ^2prg=;_~m5`o{%S zc3`#;{`3g2y*gyeL73GD-i?wAB#kd&=|Y0dG-{_q292;k(Uzv`lPx1;w^nK&T4@8MHuOV%nKDZZx%M296G1w{wkAuhqrsHLww8AdrH45j1DRo zKqQ(igqow2KuB3=n3)p&J0*yY0mEP>G?X1hbA~{YAAjvM%YV|8$>g9s#wt4W|qmCZ-ksQAXEh~wBay$IGjpW8TBUhJGDPZ z+h>hjK@OCi4_Sb^W{XZ*f_EagR?MAUbGjNW61^on%tp*zoD{J><+>a^cA8OlAc$h_ zjh#`-GSXoVH!}`2(~mS?PSbXz*f^ENM>aimSl<|)Q#vw={XoMK)Fp#ISfJc>Lu+5| z2ls%tbfEp#p1R#0J^79+;0i|97lq3gQ_&3bv}ej4_;cIAx<_|Ce90bXbMWH*cr*N| zWL05ZLVc5Ly?M=lRs(#{Bv1x~Jo62Eur{>cL=)YeRlWUPaEpHlZuA!zhK7F005z*R z_H{c1859SGVP0Z3nJ{_JjF_=RC=$MKSUCPRv?;-Wn{3QDE+r+-Upxc&`%pi|Zdxiz#m!oTs@sD8PPBq#zTI zih1E4)4Z~J-ION!$Vx$bnDw73{cWk|BO}<#YMLL-alF;1;3(p?(@2VP`TblK17g9H zjA5J|VODC0Bl-G-@pyfVEx}exvu}n-@e(oc`n68<@t{rT8|QsY&04eC(UM`4i+)FJ zCK;~C<_>4vIQ(z#(r@irl3C875Eg_XWsL02FmiLdK&4VcIq7!=gh_u3xm@!imFT&m zv18wK+UO>vNykKva4&Rw-qd=*!`qkNzrf4P$diBl^u+j;dW5DVQb0*z-eoF43>R`d zTZ9$1Rc*G_H8Q?Yca-tAewUHl_WrSD_X~tQ*lu?@s)rnCPz+PV zfLp};V;~h%bT5>UV2CIqYA3@hT4K)~5EbHUHkA(~3XZsS2ZWC?pzfx0C$cx{GX?`* z+Nq-Ee!Qk7nC{=kGHWN#!ndqP8nVLb5ME+WhVMk4Nd@z-Ez^37Olh=s{HAt`w)mNW zWPZ+MGlzp@F4tu_DGeJKGD>D^i^pVR)LzSM#*XruQLsHKvXM5Ar_}j2THR#c3fjW3 zcI~KY61HtSS+}0yu*77&M6=c+h%|fM8tnjl9$GWyU~4|b3P^l$?^8gw_LMao2X-*@ z>0YBl2gmp+tx#F_8I>s3H37C7G;M#veLk9Skd+q8@Wd8OPH}AN>UtcLHTou1sEg*{&e^;CAq}fXZdW{;=W}&%&&fwQF33(6N+0VM=VrqF7(#k6VaOVMnf( zDS+jYLc34LeU^%M<{I$I>=iu4vfhV*&D))<=*Z#~vo(DfWV;j$JX<*6QpRBbK+-*mHQfN29cDj&Wdb$X&!J+72feW5m13RF}PA# zNH`sh?I8ilsqKln3C@)@qSn?~t?t4-koke9g>aY#>k)XIV=OBiZ$xv_pJXDNZwATa z4B1H{kAY$GtZQ5RiW)kZ{9$of;rtY}uqH9T!Clj-qpKN}#23%7QR}AQ;kZ2e;$a}V z9EZm7I+plA3e1OlXcxMVLvYq`Ezm>BY?mi)-8(J=9a&O=@qBh(oruBy>FJIlA1;5m z?zl13gv@*m)n6AwSi8}cyJObLvTajIyNwa`$H0SCp)SjAt!$IsmpPj>j0)8>nAI@c z^fGi>wbby_U)~&k=X1ZQ`FEsO%ppanbQ24&;QiDkOFv{>X6(w9mrZNL{#JqnBP`})s)xgW2QRLT!kGKYl~FPr=nK}iH&mlbiI zM^`m_JD0+4@aaW=^v8h2>x++=S_B4bUbU2zpG~39ju#j{%(hN~FUcN05{LY}XE5E1$&0 zpkutkeb|j#S8Hgg@Kd6uS5IQ`bul$Y?I9DlNO)G_(hsBytx_wA!*r_>L2+dMh8>Vp zaY{T^$6iQ4+azxoZK6Ag#~u|`v$Sv8d7qpu8{IJL{ebbfo{Zg0Z$BfH!IPOHQ_~ck zX|Z|mJ5u+MVm$pOWtaoyBd0=R_Nf><K^U*w?pz z=I6keps#&s5D-li5D@8q%g+M#_SXOSF7r17CT-wu;wbNE2edP?vz9e6vjbZENBzGL zcZ1rCC(05U56Kul5u!lofDqo^MSoMi$m^qD-Ua!uHs4 zjS^2RGRgT;vt$;n`4-|~D~jgntTuDNttW50FF&6T$*FX#ky_fDhL2Uf&Gwe7&9_OO zr_MLiKW|4b5g?UATmHx0;z-o?!rx0HXFz5Jo?|V9G3woyeHj>(z%VhU!sss|MN@{S z`YNjX<)IbF5QzP9Blo_oqYGnVVNv+26K7D+V|8EbzBppJhI-4ws<{Re?WpuFY(zCf zRiW1|L02q=?>HMgUy~Dg*1360VLCUn`8Gj05Nr~8wJU{gkp;VsHR}z6{Wv_JonxIV z)cuVliLVk8p;StE~xP~Dyf zgV<3}a|OokDvTBrtj1iZ>(QMDYsG2?#e&4d>QxYPc2v5{V(b+i07X9=wRYJ7K@jFn zsWFXrvFeZqJR-Nw9a(`U6UK${3N+~kALh(VOSwSOP2F{zg< z1pAcE>Skjm zCN(%`7Pd46Eh$1RHmOjRqk0bps>B}Uo2C*`JSIfNKZk!hb2b(|Y~UCAl*!O~5;W>( zHT6{I=L^5`P1#_xU|ILPVK-wE{Go1s2eQm@kpXpZ)E;cD+EeDfw`K4yssY-?HCevT zMMqj9(yzyMAm+S7Vi+Pm2uC76qo(BzM68pzPbt)?re)cxT0t=_ ztj_+17;+6wKmcQ)-jnxS92o<6X6Gf^i--Nw4SYSjuI1m{!Y@2*-Hycw^Ikp8!|QKCfb8>Edl{%=!UMRcx~cE7I;+ry6}7Z%H2z* zXXyqWVoNw~)(+y@2I8+8Bb(piUS4tth`a(k^ZI1#|MV%|7JIJ23@y0&H8(}7t+b{P zw5Y;_s2$dsY9=hGGk-EoN@=k@#bX>w@dMSQm&-r=&rv0n-4{u`5PN!--P;%I2`uw8!atK@oe)!E%sVB54bK>dXCDUeqT z7&{$1i-p5bs6=JZm%&x}SQ**$*<6azl9{lJHBzQ3Ky7tCGao5_6n+j zv{;e#ImwR(HJc>gLdCnZD04`hk6=lX$V?lVAJ!E#zQVBfAbuRV6zr`QIZ>Y2$sSqY zy^;Zb;8y9*)huhUXfeT;CSW9Yz>+{Ts9_1@q&N|y1B+X2!?BT?9CKCA{k&>~S8vTr zlT=k?5nyF~M)GnBMeO3IHTG_+(Ca9{SY3Ct@r^u{MHs|NXO&dZI7-z-?7r`+J+s)o z+4Asha1#HRl9uHuobh!)G`R?KtdYsO3$OZPiE(}F2z~;i;P2AD#LaOVJA&ZegWF}U8Q&R7aWe% z)u@O1gwT2q0jJMeI3fja)j>L9I(>|jkFvvg{yyEO*UPgu4i{L-hsL;FmcJdWGot<{ z#4}>h*;Mw9V)+Nnei0J8$N;DIkOSb9L$|MMMAfz$eL{Uo163=7Wr*lYzz!s1C2D!} zqR|20|B4abi;;EseeSN?x+nHGJM%nRNI%E(GfGEblghMbnAe=1UebsSoIB;tmB* zOrq^S;A(nKe%5+V4dGch5OfavI_X|~eJp$hFvAbXlGuNvMqpuhPCS}E?~{kKi8gM< z@9?taRNx7O2Xf}q7-vgiS;E1n%gwSeP18miQwS~h-GDUM3H%hThC_ET`r+LS_S3QW z)KH$wVo3&%uR&GGE?EhjV(dOMUxr{r9XeB$htwD_c+wK04(=y&t#>%+6VeU7#_9jn zy)e5q6O6&-jxs=X1IK)VcErSdf5$=W|KPYq?ASFrv||agCIo+}DBK&HDCWYPHE`;O zkbDOy$2v7nVtQ(cmk;1VdBr=@XuY346&gZa!RJ} ztajDnLVZp?ia>Z!Gkd}T150sKgOGA@A|6zfeFi{9RSP*HlDXjg*3Q%ZNt3H&eimcX z>~@7}C{zQlWKO`T;)3Zy%)`$Hn1rgykPW;GJ?jobo*d`d7oh1DPz{d3x$V7WZI9jr zPZ?CV=!=M%=xuKTbs|BSN$no@oN=mIiQq(X!kM>zi$Z(+)-Jq^vMYsGk-VcMOUb() zK6L#&N&b%TYw!w&Q|g5?*e#)TNWGE6%mqW&PmQx~X%F6wWK*)r?hWIg)zlEbAJHB8-NIoz3 z4g5qAGUC0QuAV-9wp@=Uv%cORp?nbyM5e=f(5;6UM1nQ#aVdzk;hXfKc%!$GL{T|P z445Nppf%|$Nl^?kX6-rsCom)J`AQOIM_*AIIP=6sW9!1DE!c~8+WF7?4JNqY2IIyz zsHEUAM$)vWeoW6LkzFv%+2fu--<#2#6poKN&QNgzmVk;Jb6C_G(N^k}b8r4Pzxe~P z=Vo2P$)xy=Aq0mkjuGJUckOlo475m?)DuiOw5hpdMO0%>vy)g()T* zY^H5G)YPkPYK46nHBG7<G z+gvF)JEhdv+$s z7Vk>GDcAxp%TRU5M0@5Y)$mvJPoVaIFaNDc^LM3HTTAW3l`)t#x|OH|h(?SGoM4TN zs}hoVBaepC&?O+|G5T_B<1N`*l6zB;pQMb8epN`8g?fjh(OL9g*P^8z!vZCcJh=lawt$ zk8w$0^i#HrPM4&~vVAf6QK3lpcELkW_YK>v2ZF-QYNZ-)Wm{I#NEeOahSls`Wa|Vx zCgBfTg!SzLghd(|`UKIFBtZqf-#O^q(M_qy-66@@sz}*3p29{f>)$ne$bK?fA5eFe zkF9Aq6-QFLP%6N~y^oAF^9GnZk^}FUK&=duO#J}Pxwm4v>SGBAnlXjdxuKRZ5$J1- z(gJP!L}WYPp`9I(8Vo7sY~Kt&N}d7%ms`f4?O4|#+!`|TyhRqSy(01&arw1P^xox0 z{wAKs{LMpR>j0vjz=pjWue!og{L-getAxMT>6b5KD+WRZ^QbEK)5oaymN&S+6*R)r zme?`A>FZ*4!`{mhn4dbKdS^h-r8=Sg1r+WhBDhhH`nK4;A{jSQcu>lUj&K~}c2_`> zF-mH9TDA&I+$f@rYRw4)>lANq5=E(G zm)Zd;r#Q+u+X&TLvu6z3nSg3qFY;zCg*~Q`wobo7CkW!r2XiRd_nzGft(<%6?|ZDG z*R&0teSsmyo~Z<-84+}Kp?*NOwPQWitYK6;9bdQTKb^SA! zLaNa@()`UF2LH_*{!g|+lmBCy_$gxGXzea+05td)4oy^Db3#$U{gjP2ovYsYA=#23 zn5a01g#GQOxfP&;Ur9+`u|&PbI^L!Y*oNaOmp!l+&(!&rYsWhh&oruUU@y7_9K6v} ze4n%x|7lTH&vew-b@$PE<+?JF^~L>y)_wNO?HAxi;>R|#m??~n*E^@#8T=NO6Y@DG#L~)@yVYv&>4d!={_EaF@`GTWK$Wt z*^~zNII3o{zD`@Wq}3&aJjb3}2oJbufRl@Jn7ohds?Vf$QsJIfWqcVErnif5(ae3b zBl#dpJH>BYri|JyeVVj*YP8%__aTN3gSBh#_+yfj-wj4BEjefw2r5U1(p6PGNBI|s zZP7pB#a?xA2;UOwmaXmOw!4$;K{ZF5NyFfbv!Jx}f9X`rYS3r8x9~f-Q&CIi)w3HY z`@2~XM)e;%j+BdID`|RdCWHr63C=R{2-EzLX5No#!76G1M$Fb_xce;vr&^VRi@dQ5 zL-l}Vx+CqzCGWV_kv>(eg?rGeEbUc$ki63l&><|+XU$C$l0QS_0 z8+z-x_!i{4eoL$e?xnJ_AIH@hT){SpTxSL+H1PsOc;KQff94nvD{0mjYeJnkts8WD zu}q0<=v4M45hI+3oeO^QEhzL1Ik;JxZr4sJd4f{7(Enry&TmLorQyLO%gEf4XlZ0spewhwG#iaV9co(5X zIwJi%k<2uHCwmPbMK=#dGM%`YkwlvoBVb9>Bug~ikvLd!Nw5Ln!M-f@=n`YKQd=>< z%+(NrF41F@oPAJb_L6LXSkft11@F|5%W(mm15^eZPh5kNyrb$H+b~fj@?P#+^UCU) zCgRq!8z33R@6l;3ZlfMjyGOnTWVV+lUEKT#rUTw#VVO(Vu+|)`z|FQrgkMg01{3kIci1_>s!6~RzTJji6Npp!j^7NKzhcF*WN-BJ#e<)c z4@-Sh*8=%d?pLxv)cWI_HCq;7x$BswbQ^402@%OV^l+HU5Nri%x^rj*;exB)M7DzX z(}Y^H6Z&IQ?Cs~WGf4rT;B8a1U99#RKr+@>kxi5R5s5dzn_cFpgL`VnB;x=vRE@!R zi9Y!5+k&)st}Kfj%n2d7JF&623jwVhk<|GdH;?bI5~v7Ey~Xi@y?-ICgnt0PKc51HL ze4lb^F32b&KCoAG&5}KKI{6F2RGs|V9exF~iHUF?oW#1>MbzVIq_o8rpjHvIi8!ZWK`@ zD}TY^Ue4i1?0n*q90`KClnUryLR9ES8s_@QBI*tC$JpHC?9#hJlVi`|)HGj$@^LaL zgv*KgUPpTW%)LGn*gV^RUF&dvwJhJi)vB-L0?+$*bs=_M6JoBmwPfa9KMsW{@>Rocsu5#$z(=aZ$2U`%2Jf6-dfOgv#9U5T z9VUy7!_{>dY8#W`+~{&BBt|>^@=x$_^a~i0d{YUJ)3EY=nILqf-{^=4x!>(#15+Jq znd9De#(Hu>TY7YQPdQ9(W$C8VzZBNEZSM5W)ejMMcJyp(Orp*wa8j*puG96?rZ~l_ zT6#^juDl?f7i09DFY$Ul)dkI-GmJog!-wELEB7$Bq#V4@GDKb-`OPxf6yHmeM0`-I zV>ZF8q_s&Np_C({I4+Tn{DcYE^JgI1p{mRTZTx~VD7dbS-;;4d#(uacrss=TQq~%x2urms`xMT!5DXx}3fp0)t%A463{I1W}Zf zw)UtAr`oOF@j{F-qp)!r zw4LOG-`#vxlYPQbOvoY?3dH-Mb|3_!~}X2#%<0%$?;W7FOU>nYXet1 zPp9v^7&?7)?(SWaY@=6Dz)p#j_49o#;AeIOUw>08B@O;(bwukkiEO9L{cExMt5NRj zkn?BYWD^s7Ri&oMrKR~((8Q@eb9=-{F%0B{y-GJmSPF8X0U%3Exk9V0^Yv6^K}Ky! zbxCivx%Qj1Wz~(%lL}De!!Mju@5n1qC!mY=IKm}JhFqWW-)OqR9r>vxf5bGQ7mIwsWU zG+Gs%oeSb>E{hP&U!<_PF90Q>EtN*h#Y?zG;Z^Uo@j;!;!pW@u`O$qq;cO4qV-9*w z6WPlAPr;>*ionCkVywt#p`P$Splkk4Dd6?C$UL+jV}a`w{lsNZBAkfVy_6AIRtTZ#4UkxCj|7Za>(1d=R=UhB83voc8-o=zpeVV} z@2oHMfKY}Atl0x)D0eZOi10jM7T-X1{Ns8^6M&7W3OnJ-)oAD=gRNB!Xjt_O43_=@ zoZhswrf^E4%S~VryQV1Jo=4ZQhF^iQH2himC`~7LoOpp6L|3KC(qjOcQ^bL?H<`~S z`Q!#L4t+WmQ3LGc&E)iC3H=%Z(Ypc4p>Ff2oKtk={;tQ2h6kc^gXF6HK##s;iRg<{Jcg;GOyLLixfp&Kxw1+k1mIo(R>i~n=Nqu+NqWZ zi~5I-J`9^G^+US|wx5di!n(1E7M7e1^QEb(&{D=DbJ8nj2#F$s_5bp#Sa z28G37r=CF@1Af3XprBlDpx<_7`#X7=36B_b_8)O1HRQt2nj%f%x zFr1RZiy++KU+FiDr)hy@0tDIVz)hp;%y$i6WxK}m3s}()JX1lr`lT_!9CK3aN9V=V znMZjksHsg$op}wxbVFPaJg@~nNL{lS%{ck ze7|B#+>Uu=Y)RU61W;cW`OQOm^!$6C$KF9Y-~8~O@xQ6edW6^D!^?GZMk#OK1<`O&|R!iR~wiPwR%){5C$X>9qr| z!L{0pl`U@=V$u42T2Il-8RxIQZM)kh;3uoEaj3xI{#ED@KFcvrAk%?s(45ims8111 z00G8I=a3xxi-g9lcfc=xSLhGKgPR0_n3+9k3>7u^88+c|Je}BL*RqobsE%C6J32cn z%5{V57~`2ax9Ph3j2^zjtmYSn;~OQm4#VrI=Of53|15{QpA1js>AI}X9G{6jU58uE zCnDn?s^mUJcUM7|h>%|j{T_ex=%3|)v)g=kdfz{(yUee*p2-6AOvgVmzYMOa-+g<& z_SN8hqNeE4z87fYymNkyZL>X>_k0!F26W2MFL8*H%i!C84Dx>8OlWYu(SrPl{j>Da zo)bGr4E_Dlta|^KWm=^PW|~YL7Ymd*3!a6ZPJxxI(Ad0oa8d!*jj{9^6n&JWnkLfY zD!se$5J~mc={~H%wA_iAAn*G0`YJSTcJQJqz5CgFEOdAYn+qg{m?tu1Cp+z|&9OI> zv=+*}vrDj0Ci@Rj89TG~TX&Pxu7$006i%HnVU`W&kF*SVhD~T_D^*ijQUwZL|}x9>nJhZMcf zF&pG4yHWr}Lvh0$fI&XsVQZn#>3G1d;|L!;oh3KdW&Y(zb5}Y@xhtbhq~d{f>&lO2 z9%8=cODKB`^8%+d#UyfqJ+=;TFk8v&@bXoaxZqz*H|f3wCkSZct%g z#70K(Lz4BnlFpdB!8^lSJBY-OX7=*E%2pnc8pW0xja^QrP zqNqWEMs5?Ug;=QRsB%Z)iVRCeN;0Kgtfg8`PlIf*oV^_ecLPqQ@KA8;91JnG@Jrza zyy^VlbopE5`AUXleN?V-ca0xbz^}VQm=n#OLQ|yJY_a4UTTRT`O^1bNSmkb!nMsI4 zV>qW8fgNiE8?7T5T@Z_X(gHgRH;37~L>iXyTYQ3nR)Sh}3&O&Myi<_NK-d&*geYr`i=H&c59PDbj zH`uQ@^HbRSDgyte^(V;OWyE}*ngTK<2!`^{J`miIUp7<{PN4*tl{(0=v`J!Ezg7Bi z*{dtKrtX>UXcsdk6ZYgn03&he{Q4PtN(e6;Yp7fz}p1pBlJ&G>h% zMal@4bj6abPoKIe7270}s)p?3<|b(}RVUO%byqvIpc9@9A5~T50^R4wuB`A-Bk6y=1BahJp zKTNnjF783J_poB~14jFtGrLErvet{~x{v@+E;W_DinrE4gRJ%QiLbLc)Y7jFX~uWW zUn_bq2v1i}O@uns2~sgXbf{VC87tPaneJN!s%EVqKLT_aj>$Y$vb$y@Zn$s;CJ5H? zS4{`o^)qJ;HHxg}e(N^mOtT7na>Wfq($><^95iFolR%&!ynpU+Oba^yIhNzKN6Z?} zg$=6hsp34B_~2bEO*cB20C76%xIWZ@` zD0D@RjpBBUmyo{dOBZF^{Qv_h?S7cPw*}d%>>*N2{0elW?~LLNKN_NU3P0Z#sc(O# zbhv?;O^a3>Br&F@^9(!}8&>d$1V&xv$5ITh1U~I0NB|SGi^2)W*I-61sc1PQ2N|#n zXM+2-;{^zY?uch^v|%Uj%-L!46zVhDm1XA4$y5~Jy+QRND!flzUP)uIy~BCoON{Ta zTES{Z#eu`wJeWs6vY^1yW!s!fXDq^H3Hs|PosPbu7*`}ycTN&D(3A?%N9To77k-=2 zCRkv~r%oZLq)t639NrP4o6v!ceShbSkdkDIj(e-V&4S)nJg*E?S1Xz5K-V#JqSz2| zEt|-+l#04kK<)!ptr}D{fc?UD%3bYLc1py}L2k4iO*I;8Sb3VQMq#c6n9VDU@~C(O zie43+#@S*s4MoSaJkq)jb;cxKwLEe}YY*u#6E7)fGj^tP(>mcoO@8q#)lj6Kf=qzt zIlPq+Ea82G?hET$><>v>kudG+7(wUf^+&-GBY& zA!)PyJIV>q+hx)jH%D+sJ%7f6>asAd%_7q4ak;I88N))2eB4RSz1sQ3rxYS4oWrBC za!ZKG39m7!ijz8%4Bw1RW^KF1GlPe@gRxExTFx{Mb+M7D++2h7yV<6g#x0i>U*ZvG zx8%>8V+K_Z#EDAaV4aQ|#jQ>`XXk;RaLNWh%C#3_Z@b!_YibB-rSj&d+zmF$+O>d|Naz%sVfG#C{qY^ObB}WU4D;xI|JsA)Ug0~VzkPl z8s3>B+95m9i0jF3ST%4dZgGZi2!Ln^^8aG&9m6XNmv!xqZM$RJwr$(C(@Dp+ZL{N~ z;~CqwZS!Ppoo}yipLNdPd0pere8;G&x9WNB%D`UnB*p{M1y8LIk1@q#I4u# zxe{R=S%8|Gc1bS4#$mh13_9&_R_rz;mBaBzD#(eYi08Ee8(oNwbN*QnWPD)EAO>Pr z-?h&PnIUDWNSg7%qK!+_8FqOK=m^ehp$>CATx(hHQkdGB6^=X|`z?+zw`-?WpHHKo z164m>-?7ZytU0P;d1vt3c?iEIP7#e5xPkh@6xnNxpu}oGIGB9Xo7g3Iypj_werybp zF|{H*xwQNcQ+IIMR+W80jVoe|C&sQq`bCX?%f$!K*A8-T5QP!I$jv6g z9N9Cm$FZWHk?@OUaa33)aF>Hf&eYiJv{Pl@@qSt>mUvPh$*Qqa?=^>7(U)9Cz)@gQGzWI1MS2iNdITh;xQ$F;CN<%k5r-{UxCyxh z$S*iVZ{+Pa*Zn?r#Lz7f8Q(~+WA3zHNjYL7e8RCaW5W^5_q<+#Iomt;B=SX9&ZHl| z)#sGg<>Z|qK7#B^a&N2enY*HMcGgZbyApHursis2_+DwZL}zyJr274e+vdXcE5>e?lKTmlcJbsa(ni9+p(uAiDP(jjO7#M|Lz1*kS^{4x z$tEv8x)_0>x8yY(ub6ye(|eeLvWe#~^{JDE)Og0DrRCma zOb=TxfzaQ}7@UCP3;8u@HgTg7C@C`7iC_YxI7;Az7LVTKP|Z{8$0N$XWd zvYg1-+tky(S~mzMT=gLsMY^#KB8NP!>&S3|p{M1Z*R|ERP$J3c?W9v5&&3eJUQsfSF3#mpqH~ zFOZHWtf2{(6%7fwf zEh=UXvXKj)Gxyv2cD}mR90a*wv^sON}v()h0E+;=IxlF8$j{2E186hiXZJ z++xGkL#>C_WRp3-*bv)Pw41?4Q2BJOjY6fNd2t0`&Dw>&sAmx=$Y<4NC zm|z;guw_i~CRYe+2Jx23OG|QEiXU7g5&Hv_T0?W}=Y{LHl-n~MzAfuk{Zd2Q2b9Nj z1NKisck@1|?p#ocy*4|TloMAwrAG!A{KBJ^PG*54z6tZfmCC)Mq%5Plz@BANAXCy5 zvjxvoQ8`Z}w5MAErQ5VcQl-8?!VRM?<_vM6c~ZBzK&t+(d+frJp5X{V!28s!Gb4TC zuJAF+5B*&Mmy>K)&ZWMC2XcyalFhS{Va14uhQAp+&9jA#yx_02fiF&M6N(uVVyHvE zG^^UHz)bdnS)wpzB=n+UETL5M`X_fxSyC$%EK>@HRmk5tqaqac{orzlfuwg=VBcek zwx;a~y}@iAxCK)2SQ##-OeH_7iuwEBH7g@HhpPYZUQWoo5UBQdc>2NOMnn*huI)sD z4UpT?!ra|G=F5-ewv};obJ&|1J8nJ?;xyf{GdaBlZ@SQx(v*b+g4GH=)Pl$@CiYq@ z?9!L&=t+C7|JG}aC%fU|a1`zfZ&Nq`drg#DC3s83)^WIDGe zqT!gjNLY(Xn?Hai-;w;ao&up{a3g_CvpP+3LEN{R`kQfab#z&aeN@{~$x`~jnIk+F zhr%^<_YPqjwbX!F%7luI;52aJOJpE!pcZ(%Y9KM`(IL``!#!_@rwHDr6W0#>1M7F5 zs6NEy?)o{h3*O!(;fC998?4Tc;-*8grZbC3r3Zr|v9Ew@HOys6<`f2_b2u&><4#Fa z5Ss|SfzHNIw}L4L?}aOxC!Y7m>6*~8>oCOeejNneCqzzo@_xM1MR}03ldyFxhbx(% zlPvr9Hp^dIqYOvCH;IZu;zq=nY0^)7JlN$V($iLCugG4$5R&KKQav1EC`%D&Z>}Nf zj^0u{8i}ffsL2p2tBPgrW5(sSjlt!2BijU`q1(bD7g8-xIprtRZk%e=3X^pJspX1z zOMAJ~pkMz488H(fN#FeLrkj6{WxgBh{{}PqPf*c6;6wj=9R4rJ0^ASwOMKwq;LhMc zbl_&-dT!u+Zs5LR;B1-W9plK{V&GW-2B|ak$N3D?h`VG=G%DzbcL308IB#ETs${Tj9n@J^XrLn-3^K9>{ zEbpW7^z4s^qcis(%EKZvAtI=fMJ%wPjL4#hg;Z?Go|vGMlSHi{e;5W;596W9lGw|4 z{)AA5Op~Q%5!S^M>f@h7gEx;)^B8lcWEn#aqFA#uY}?JsXfHbTpGi^DccA68P@;^r zgW1(OPANIEVkNApr5kdbL0YaRBR5fH&eCNX=|h*=w8gZYo^xD!o1YNHn^~+L=%rU+ z?5?=`#Ae1EWTb;oG9_2j?i8bZEmd<~r82s(oQwU?<`8Y0n9fM-sJn}}Qd<#EeS|Sm zSHf8hR6})|QKvwar-)WD8b}RKBFyhYt?UYlK3tDbN2I4&C@##ID=Wy~BjaM>nYlp) zfgO3Jb=3Bl)jLM8AP!>c-&b#F`nyS=NU zg$uh1*DN~S*Z0M%3e|4I;sam6|9w734i8ra@;%sHh4}G<@?U-!|NKR$+A8CyejD*t zOy=s6*hq_iPS5`)*&$t|Dzp4^t5)D|6{ynRlDRL0{z%&39k>nQ7rK>oV&3gC=%4N; z*8P^rwb=02(Nmh6mAQ@He9ANDF3b7qa_fud4W)<1S7Mv0gw7Cg4oXLm(BIv04QEr? zkv!%JC2R-8o*xBBuSgmJmj4jD(`)CtS-<_@X+Ujb>=+ zuj&ZcU$U32M2%IDdKfVgo*_BYt-i}72Gu5-eVPodXV63%qbcq$eDoUax@r7LMqN#v zv{}1gtFC}=Ux2!kbbF!s&&Xn(@P4%qfe;mOo?SEuS;fQx{36B|KTL_-BlGVMSZ~IU z3{`AAyf`q!LaIJKt9Q~#$~T60*M_nt_)V0~Q&WSxUQiEh#M-;EW93rBM_d9SVmjHz zE>bF^Y?-!{EXDQe=76EtGFDR>mK!s7?f;pfFY?)glW|KL)J& zp{;iN?9PNLA&%R|MfA=X2mZHzE}QTU93omkj)OqWy*!ty>-6W@LZ?aCrE}rILyZtJ zH%lZB?8bbtpM9D2P07Wnps3QtAx%wH|NNGiBBC?hKWUjAK?_=#-j+h~^@ zuc`F13;Yl}Hn=~7vQo8IGCG+w{%|~Im_{eqErX`*RI?!t8;v#&)DyD{+iCZiKJsy& z*r~CuE0EN^44Z-i7HeL~5<7&t9}u zN*4Dca|WU~PxjgUxr5qGF>s`)X6L9E6=NW@$Z0w; z`SEaKiu>5b1@dFhm}N61Ua@z2CS55q-*iQ#(P{f*-TtERxCJNPdx*I>f5Q9t%Gc+ZkiH z`^-2C_T^hJquMI@3}VTB=u+a*=azc!V>!RC~0R>Kkj5mFPJj;a;bddfMLPUzYoje$nDHqaf=G#j=&p^IO ze+2q5qw`Z&(q+ud-#%|%!GEYLgm3>05DvEqo74Ylv@%S<-56JpC%vXa=M69C`rVi7o)b|Rne>52Y~^Q-*+eUR^E zwy9w84>ch9&{fK~IViUvx)GyYEK12mp9H~!%^l@7SEvNrPiYM44 zX)d0E>sk`65RC&xl$1}^zrnO;T?f^b17pC`hf7S}SXF|M7MvIy%nTKSv7CrHYo#xk znCGy6&3qt3I~e7-nJP#1h7(M+Ifr$YT$eoe4s{-0Z=U`nyu)5A zTyXA=8&!pD0!sVot|tE{myU{B9^7*Cj+=J-5f;mZhLM-eG~0Vn@>E9i38~MRbd-i( zi?Mf?-J9NAKxvHJrIK%ym2YW4^K<(}hB#W#-)t8D1=x&c#;mCrtjjPyGe=Uk<02Pp z6?a)idYX`rD9N&mv1W#v=a7r^m~4qdXU?IABg&I(3`FC3y6`T~4F)uuScvuIlEmYT z+vuA2=hhvmcUBm_;Gpd!pwCPb6B#SYGVK|S-V~x^{Ea0DIPbnGie(+AoIC5xgsz+n z+*#)YaI{==noe~kvB^@#mZ~&{_rA*=kGmJTKB`xEpR#A*1t0R0za_l+2G$*%0;VUA zB19UbMOIwcbQ7h^9eS2xc>2w)e{^POc)3#+Gi~;q<_N(c_Qs}!T40yt?=dOO#B0yE z>=@Tc9}y@y5D7H=Mze`UOYBWX3}#3EQWj33hA*^gt>U8kTUiWZcpAV6@?W;UCWYw$ zKrEDQNa6GcRnhcku5r6ccFsKX0IWX3f@813d+;UML^iLiHhwLnv2r$_!1Cjb^d~9l zo4kZS&`s%gGpV|Ych;WaE4#-WeWu(W*5h`}vl`WvV^XaglVek@Z*<{mx4o&lYIh(! zQ~}nldXY<%Z-%sTR?kSjRlDTan?0FSz7^ZOu1*y@wC^&2sT&x$?tVD9?!H>qcku3o zYc}7~ohJ`n0KxP~w4K^E9^BP#EYs|)!*k9NBTvUoyV`ZnsTir2wi<=d;Zt8c{Bua< z8$8C?Zb5w|Mkz~ilq0oq&6BJzVC!q#)DmmqK1Cnjt zz#?5atrvwk8IG44OV}N?gWhZauqaSqYz&3n4zDAvy!|;Fa=IUNa_9e3}koj7Huea1A^v0>i>HtiC z*s%RwnuiheWo#{G7zNo_Qj3C3oB3y%fqFfUG07fRDjKd9V@yFT8Uw|08~O#wDswKY z30?U9EbSOlR9L24&Wq`iY0)$>s+qnh9e-}j+TO?l4b`}jBz=iP*L-=QnTvfIoUjoR zmcf{$2!6WJJ{UxA({$~c z<=Axw@I=f(nHqD_$F?6bxOR>0T8GZ+#JEI8{boiA6i6M=)2}<9j>oUq_Pj1Hc`Zg@ zG(Y7!d);N!b1m&yw64%xl5KGjnfK3aX99D={`}icELvRcHYa>j9WZPyJ7LSV$mx|e z3U7p+6m7_s$)Cu5>Fz~_I766yxS1T6qHuVZJ-)cxqs={F@I*kvEuju!IAPKFB~dt( z!i`Flf16zj7u^+W<#90RdS+5?F&yo1|=@N3~RzYS9Tn9TW@Gx zpuSOi>pR1EDqDiGx+dsNJ+N${9Q~-{MlcM~)dYE$7HyEFT|8k&Z4SqS>%2&+=}{F3 znVf?#imZh>`{zW5zmmu>=L&K8CplhkAms}2_N0h?$8xFNV==`nW^X6C{!*#21Q!1Z+Wx5&;R;$(i=-Kl6l? zlof5RmK_g*VS0}QK1YtqY)r^>QnqMby9B-3?0|g`dLfD`Z%B!`cR;cFfb7(_MEZcU z#ik^wH_1>9w~(87;w7gEtwQO^J_muaO3e1Q(+~%vKjxMVDf{>)Px0^2KQl9*GACUX zy<2|r1B_=5);P#KU{jCpZ~gu$vx^tae42k}_C|#No9y=ggGm;2b+NE_vUIUD{pSRq zt^Vfy&5`t-GIJ;Yn;wU#L5O&a4!m!){1ZF~l!Tqc6<|w@Sge zEyS|9h|9(c%$j@*Q0zpErZKI8V{9`bOVo8ee~Hmytqg4!7k>bC^V>I=s35O2l7%rd zZV;K7cVi=bh%?I#mfCiowc&{ZF8B?0%pn%qrFrAx&!aPNuOPSZ5}YJpRvz6sv7Na@ zHY16J^rF!$XAW1mM!GML+m<1Av#9tlR6|j$7o98>Nc-0 zrAt8MTU4WO2@|yc-xzg+hT6|Vx%$6dwQIzr0=u)yBH3J&7J>}=KCi^=5zZ7-M_L+UF< z6VJ-#^d+lHnjaVTPqj%q$fc^;o7PRltaYPGU2}W>G}&+KQDA5WS-8PrY&?l<$0KLn zO4~$~oEIc6#^NN@R_6i+J7?n~HVi0mQsPeCac$N5ij5%Ls9FnlGoMoeN>zCxE2+97 zk5qgRwlI!0G$Au2W5Wrvb>?}=QtZ_XU;_8y=IA6b**hzvNmi? z6m@TxKjV({P?v9BbTF2+26^pP?AGgcg#qS!%FT&$X~)vfNI3JqZU2HT&D<7pxiSZb zF!-*ArM}!r5sRt3gYv6hS48CQ96{?T-?YO%V>o$$bgSG@ziSQHUz-tc?#6Gi8O26y z?bxDSZR?_S4>6+o#Q|8;ck}7jML^xu__gz!4B;xE=Nl!_Yqa$+QLWQqD?6(T?6WdD z%1Spj-MZlYboOe7#`}I=%`MQhOl!Guvt^RsovK$YAdSst3o28inzY$T(VITc*R$__ zs&+QD<18Kzb{wMK*WU-#n3}`@R7daeZDNN{6FMmdwsjDi=b?R+=seRNA~OD})aJJf zIIji!KT_#3lRT9Xkd3*}imTC`DR!w~AIjUK`t{{ju8)NIEPVBOE!}!LH+M4_%{ZSi z87qrY)0XFAHne$nG#VjhR&bbfak`nUH8d@sT$)%#Pq*nt7SA^A-LU3HFc`>L!!N| zL1GWud#Enu&>2-9rLw-F<2sHkljC+3@bod*P{bF#Z%TGMgR&nuNKOWVw&bH(jE`9+H7K8(dBOa^RW*ZpUj^Nj| zuqbv>`@Bp2HTZ9XAp4CB4W`#$rB9t}X3spyU#|ib=n-IB)$38gt?FO!uSWTPi}>*F zY@tVgE`4Y)VNBsY$~VLS9?s9;*dM61`8##Hc=icHwW_P_%?=M-%$_Oq2WJ}ctt7}8 z>D+1AvHkcg%I(=2=S1L8ho3)&0*?og&H=>Bv9;TRMbm-g4nMGXf^gyUdt!sAkBbk8 z8#m<75biE`2Ql1!+n*tB4mtV^&mr$L^k2e>SUM7*=A4&=esqkY<`f;^2a(j9z8@VQ z{4};ZWd1~S2Z_31^*T4aN7$zNcx1TMv%(iL@y`cG>qonX0`iIYz5Gn6)eo$iEZT+$ zUASNOi82qyCrI+UkO#jg5%LS)Y?&|jQy3$GL^J$W)&{XPIJ!r+9~k#?FZEo_&m0A3 zW7Qu#ZMHG8H-xFVZ(!GfyUHwDScsVz@+I55IuSGfO?;1}V@9yylJp8}- zrjwGp3{pXIOaSHn8y0hOhVUUC67KhFDGgR<`Q1Ky)z5~dE5ilZa}rX#{8_D*+Z#Rr#5)M#<*+u zKJ5B6M56~fhPNm1<5|V-&Pzz|Hi|I;c(bqG)B!$?M8gbNZK>U?NmA7$U3&}ezxBGK z&0|>iuAYCx+6;<}w1{m;7LDj}HW(0p`Th6qYJ{C?M(1}9FGKqAgXdr0&MnRD3|(BE zOa*Ps|B=8gZ2yM@u8q3%oxuO?hAt{_jjqB1Q&8Fb2Rup-CW@{}u6_!NYle32ia|g&m`t{y7EUWIoEe z`gSvZ(3wBxUTt(DYy+OfQP&tMwv82o7_=g*F(Y?jCl_~cCzp1C`S1@`$qO)hz8NPK zy&kBF7OZJyz=wwg7NS%UEcax6x)p)pRk&4TkQ|Dw*Qh!v2I~6`s=G4M%cTc%rTeR; zXAD78!#fR4B6sXL<-JF!JeAvbz={)D^>~0W6J7toe$k71^eOKUEP2eDC31yKmJ*tY zG46H&;p;3J(|a2AdBX2d3#9C}vla7^34DS> zAz!Wg^d!Z4S&e7fljPdl!8h@AX>gP>PK~8KlD0Tzap1Mo`Hl@XiMT2QwA@kuyzjKX zXj-dfmec>4Djsw-f=(j@?<)84{_}mm=<=Crb=`-~oI58+Pk}I2Ar{l98FYoD&b!Gf zxc6HAxgAt1g~gu_JfEk+Q%k6&q$5h;4cTnss#?-Z>vXm*@C zrAkHdZ}A#c`=7*k?Y!-q7SL9dqsEqcA_U5JZ;ham09NIBYL&qLASzc9|E-l{7yLT1DGJPFl zU_x&t18(m8ZbPd@mG}LA(a}d*MH4iv`mp03tCjKFIYuM+c!(1jXS9(;>@Ml6@)53gwq09S7#B z?@5KF(MgAr_KUQ}IN2F2GV&ouGs~kt$KHnSvstR{83FN!jdZ8C{3v1 zmtW!jCNg075ws@~38@*D&r5pBr1b)Le{)Vw3$cc}cA49d2a(wzZFIuDwMvWUiq=?j z7C*8QCCk1G1<&|gsJnOd_1SnM5ajXM3>{xS+cl$+0}`vKJarl}r>@ZJsDznyBsZch z^mK@nFXS1M9IDpZUE6oj0m&>S#waBJY8bi()z#E{kG^ium8B+0TG4sS`ZQe+auB?u9cAdICTI;6&?P1C zl@PNbse`p(DE(Cd zL4B*Y9dVKe1AZgzZ+FirBc-?;v>tDOn^t%FqkZXx3D)yj{722xiHN-N4F zfdWRVHLLiR>U*J2(GQ-rKAyiP>c_ydKc*TmAgX`vm->9j-TwJRqu9ZLRPV&EQ;g$O zQo{WP+w}Nx$#w@{X@U|yFxdY{AdZ%*xBPMTvN^i$`Ru?==inQE$NddsANNV40UiyB z_wTidmuGW&-v9b1H3B_&)cE}OnB?nQjqr~JSpV2X^*_ru{+)yRFGL*K{}3j8Z$oOi z2U#rsi3$pIFg9x!pG=P=IIxI}gCnE_jKCLH+&R2kZ+mG6^?~;ZM=)=|`tOF?wlO8h zMv~judP{|P(7|!d!SQ?lL9=m+ZD-E_BSvNb20U!9^pyv#_vaS0 zu(l99oGR=N;<^}-p9L;XyKTyY%f!LS=_els^@uhg^oa*Fq^qO{R_d{6n3_(N8|fJK zf}oWe2A5Le_E$!JDpRoaERsF4JY`a4!SIr7`M@!pirKykn&N%A!VFe#RRkDKg-1j& zWKOxppfeh^hUyJ4y=q5aM#K`Pp+?8T4A%YPFIuj~O1zMP;L7eD(bcdjMAMmRssNY7 zSK6_WxR@Hlzmp~)9+hf@j$F0m52>DHQtZXuKqKxVC8z!1*2HQD+*N=%-F6A>xjoT~A2oz7vWgFevc_CS0NrQ+qUdnl{e+KRJk}=_&7rzvqf7-%FML zHI(xIworvc!P#2US8LUp^x4?ODW(kS|Vo#KM}$ zK4?j4~XAL4#{t~d{i&x-BYa=-Beu1 z6dbXWhsi9v0cv6jS0zKTubvh&<2s>`EUQtVS{whK983*d7jyXBR2rPX-k^kd61nWm zQTn=9#Y}oBHXM|63H3(bfg@znVt3XjN8hPbNw5!nbldLl;QIkiOqPQGY>Y1>qZ_F> z(2F4zV=_}PSH0(QVwveSh&b{}v4MLNHNnPyWv?Nu4*_?^0rO`5M!&$iEVNC86)g3q z8cFL=-xn{kzK}P#fDngVjV2Bv;JF7LX_xmSdkNkiY7MJx{0$BSCFZx0xWpiCo7SRJ z`1^b;Ew@op;;&Br2U71FrRNNUJddG|76V}s%)kOAM_K^D-S2mIHVC}qgu3n!T&?{s z@(J{Uh{;sJJIa5*b>%S70{eWwG5OyiR{mdx*Z-F{M#$36#MDXje*+Av6=kJ~1rdMo zVlk7&Y!RF-i7H4Cafl0=B0x#?=LIB0mdYuSRA=L-U50&92kU|&Y^odj%^FQ$V(>r_ zeS4NGeIF_!ygr|vK@D&!MV~b&eufeNp@YysJ$H85z<6M&`oHHejeekFQtGOV$$nN1 z;322kPzVnN`bH)=ugv16TlU+QXEG^L;)DNMQdTqAo!3)MK2fN**Kwjo#K#tvl$Ev) z|BA&9(J6xXMQ27_YAeDX6Q%km+)69n(RG%KPxiQq9OV>u=Hipv@T2gtMqrv$eM;g^dqoy*+73$>2V%s&Z%%OamUtfV3a-7C3Zkv7$#si)wb(r7&@k zv?;r1a_Iofsn`j{x7D}=6&bg z{IJU)YNihdhmg#FTv`<@mr@3SwGh_1bCll0{p;XX^V*&a1s=yMam0|!c*2Oz`>4%@ zYJ$0rKcHXay6}d7I1Zbc12aksF0wWHBJH{v!)62!!0ZUlZ;F>RfCcKI2c{T( z1PLMNcJU$V2l?BEOU3 zLb>DCrKsaW;^mJ@hIDm>UtaZz)Di;bt*;LSCUmw!gx%^@xJm94(JhVJ?r(7j9w_Fw z`ShhBLRTe=x1cTV!*C1f?CClLaxD~s#yF~|Vt4e{HD$a&6o?oecK2VWoZ%fyLRTg( zOI8n-Q1tRaIsC4VyDU)sa|}4GEHm#LupXj1&K$<1{qeS;~H)*4QRhKr(5W3bg< z20=TYrqjmDFEGu)*nq{PC?*zq#kBm7Df`>q??6Hevv}g3et&hWY6hBU7H4OivyWD< z7jHY=HEm(%2WHJ8A7^co+w&|ki3?4F5l{Y(ETh(kt1T8^ohR|xgcP@^YEU-As|g@=40z}8FhrKgu7)qHDdbtF zc7d;loxc^(*<~yT&zeb`S#ukQl=BBdt zCjZmi<(oT&`e}#1!DeGgiK-2)k!LU~1_FsjD|QS*Srh;o*+lgZ>=esN^k1B!E`sg1 z;P;vsX87)iKv4%VKlgX`cLLl&q;BuT65ChIH7qaptIi{z?|uyr+xyMc#?}v>kTayl z0)2o0DA4^REeCC?`GHdjx@Eb8S_Ch7 zQ^>&@XB*F!2nzk!+MScPU|_zXOrGOt7Jh41I?Fkf^YBOpeykEkw6s{kv38rt=b0}puFd3` zv&|H{&DNPl)N*3cP6hz=DG?Z=pmH%54kqX|$sUe!j4hY)a7gB%hR(USjc7t0$YscY%{$ zPFR>HF+EK>jZ8~A)tn`A)oA~SJ~Sk&o?bSgES&=tCitm2K9kmtZlR|nZD1VS9Qqhab~bT_Fw=p`$XT%c}5d5$Nzwi_2y`G{mJ{sGzBH>T?= ztg)6EV{o+*%nX6TORQtjnU5FN3xyLG2dag1QTuDTFY_(2$i!O3a?l;BE($@X;RYav zS+Dwf%N+<|ySsXXom?x8b~lz4pfaqa(!KS;8rQ&)_k2>%v1Ohj#=cpHYl(=g~c z-k-bpyPZ`&W{!M%*8BOUeB8Y#CHAY=OoB1cyvc$A9>zyc9Os5de}gY7y}U}oI~OJf^e*A+Dyk@A8;rS1oY(I1=52gtvj(7>^XuZk^9uH}zb8p&>wQj5^`Q(7tCwTmwkN8FRJUVDj)-eYX6wb=+@EPz7^< zZL?blx%@;8_SpjXiRV3G@@u#uAsjACl+L$TgAkYCYq)2AZ-8zB(3W)qwl4_N{*EdvDZICs)N#+_u0Hav?oQ-?$OjeQEIN$5Cdaipe$k%@E4oy)8rH&S)N<5vg`8alktFDjMQMwleL62>pr7DbQjnaQ99wA`Q}C+CUsoGvxoWx z_`*DF85Y7uWh$AlBPOe#9qCu+c2f1SN^lJHOmKoHMB%v9_X`AAZbn`#4;?=_yZ;Cs z7EPFezg_zLzD%OaUmHJ>Z0>HL;VROQVre8?L7j$_yNA4btGd;yJ-3hEiAzdQcW*#= z;N&Gk8C?|`~nU_4c$oS@k2!XGKgJvLU4Twd&4Xi5-Ho;BJ@(K2(k}D-M?$4 zs^_*qZFTslTXfsOu)&N-T-CP7=pA&vVQW$gs+lmD<7|uE5@mLP$OH+S+V&@)erUtP zUhC}^;gs}nOvuf9Z-Y{7(gD;(K&D**iiuComs>${ z1iMfMn1fcJhe`sH)=jaA8h%lO=NLg*`58Y+cc>-i*Z_Uf-@z6^!JfAnQ^5vZpg!`% z_;cll;G!k?T5KazBW%g@JFfl?44GBY`4mhN)uIq`vbQ^!GkWlK;~~LY^+Bs^3rl$Ij_!HC< z6D!pZ9QeX990cJpP$Mt;}2m+KQoZT9cY zZAR$0bGj5VV61Dpd1)FuE#tMad(LJC(EWDk;j@3%gAL*%IlX(~eZt9wc=@z*b6c!{ zy_+}C0XU=QSxJbi-#AeWC$Ye?p_&T%Vj zV`Yep@aNP3Km22`EqafMDHQtyM)?enr`hZGV{;Py)Mhi4e~c&yn;niu0N}0Q2+UW3 zxe`UK?s($m!jXo28~a*8c3YNn3HjO;6#P^p9&iO$wHtHKIy}p1uub=AkcU9c^=Yw9 zyN8oC=?Jvlx%h(8hLi@$BNN^2fJk|x*_8|l z@|e0rxrHuqEoL1hnWEP8&xCiAX`+M}k&>75yQS2Wh==TVZ#jH}1oX{*MWifI?K7(Nndj)*EG9} z+QCA4)lI#Fw9>My_tVqLyNR1?(>!K~*S=g2jbXILdO<4Y(Y&>CTB`IF|zCHgVgyH#O8a z*+_-v_-TML(<5)*FR0WT(hdNTEkKwd!s!eH=_6-X8UWbmM!Qcn-Qz zBS(NQ?Dan6)f&wM#mByDaxF5D~>s z;b{oRs7k`yzAsix_!(W2fItyq&IsmJ6hiR~k%ir383_80Zy z%wrrTgQGsu%6s7y+h?+DaYe3y`Im5!$GgFv{fbJ#>&T!xj|U%*$8z_8CjLmB6{?y7 za_#gTXT73{59ux@V9XF$=_9{Gs$`VVI6`F6=v=C@f=nWyifUw1j^fK-%&mWf zAY2^Wy#Q-H6g9r+X@4mWf5N>s-`MPmJ$%ke@6dHghL2jlecsii*~6RgyxNgUuFi_w z@|KDF78>r8s^7iCFrh3&ScUgJac$TbK`z*H-ol(jBv%N6InG#w+X37>v#zTEV#Jd% z_fm#@sqT$+cg?w3+qp}UB{A-7$|@$Pv{>ovcvk&R^I`Gua#4KlDS0_C+V7EHH(mYY z2;18!WWziA+g#21!iA(mer4ade6im;Vi*5TaJW9$ihX`bRGDxi>!#_QEi^{{szO#mUgl+1Sa_ z!9~K**@EQX+(ss*CK85rCe9Xy)}|_+4yOMBkWAW8`*t1;eSr|B2l>kY7ym}3E@lCe ze*UDJC4xi~go_@maFmc6?qSGhMoGfB-o(-G)#lb+rPFQqI+_)~M)Lt~a%+1s+&AvM z4bVB)|9s18c;Ym_;_U8x-!cD@SSE_p2f^qQ<^u|YoD9Z&&WZIRyh2#sc_Nm5JmYX|Bti4=8+t`qfO%`(qA28-=Nb8v$NRt>cd7>afC zHItg{RHH2Wo~E7I9HULkaoXEv#EzO5JuI`dqs|U47?>f)qG7&?M@WF0Ax1XfmwXa*fbiY7L(N!`BS(`hGDJMnhO-zt#zO^#E?7F} zQOT~sr%ZtMZj!p7=w~xEJWSI^0&G0&qdS@1kmr$Oo(F>)GCkJ%@e1NmHaTIypF~7B zh!E96)lpus_|5f=CJ1RwutWrU?=wTJ*h_1!QNc8IN_=Cxdtbi`AE&hgzhEHU1OU@ zvzBv&(aOGZW0o%4uqMR^*Tb3A!UNIr(lvND4h%MauOfq6dIxsOwpA;FJOFR}uDgZx zey=%1kPVAX*d}Bpst(JPdC)9t0yI;SP1&YoWxOuklsR+_I%7&NKH&0ei`vzFref6v zrn>yT{B2`-6-hMK&g$LeVLy`DTTwk*R{Cs}uEL9}g+at#H$(4WUkHK#|0g{7I4CYO z2d)FjwnfjM-+Mshz;fVO&>VOUWZO19oMgy4-~w0sy9w}w5r11Dz#@yh!rmia6uQJW zoag08Z!N6Z(Bl41Tb#vpCWruetd!Xy@GRC%hTilvjoj>VZMO(QGVrBW>$7Fgr1Aj?~=en%V?m=}V#U#~yiPU)I;{Wy;4o#V0f3}!B z1n}M4@a+<(PgL@0HF#$0*n-|Rp$xA`hP@sWDJZ+3VE@t~x8U=Fl;!h+n&5kdbR;N0 zN1=#~{cD!a1%F&Dv?+q|TJ~nI$f>L{%;HouirE9CHBuMu17&x~<_DsQ3#6=Hj2NllQ<3uEO8d^#siSyv###7# zmxGI;or^PxppB`Mi-_sJN4W155C35+PFYdLT|yh|h5?z20&fjOgp9HgSHu;7Nua4k z#KQ7tK?ar#j1!9_mz@jLV%aFX#3$j5Y#<-KJRi*w?;g02$|^pm@ZP1(Of8}s@y5S} z*e6YPj;Yc4S*ZkuuvPoN2z%$py7z4hv~ASbMjP99W81cECyiE|G>vWB_KMTkw$s>p zYwvx|eRrR`&wGEs_m?%+oMU_@#_VcK_d0JGz3BDxyW;r{bOG0PM~fqDHd5?_%%AeK8t5W8Yc9*hfa#kmN5-_Q{XX zuyJE$7|{&;76##ul&~{na#|cCFOk7UV-uPj<1gvKDA(5*rpa=e96c`q!5aIRwCTpa z!@ZRINwo1PdNuZ`k1DWc$$EA6i5|atIrkUp9sq*tmwk&B;0D_&RTPIlow%f+kP2(p z+z$TOKmqBG8};al*H+UzX}n1$hA?r8OH5FG8fsax41 zyFIR!xXRIpsU6(N>D7tSB8#Pvb4F2*i%Qp~Fo#G_i8j8{rAb(a(#mAVs&7P z0KcWeJ1AS6-$nqu)ufH&cqvW2rN)DAz@uxuZi=67Z$G3hxYcL;Og}XZn|a;_+o)Hv z6x*>&W}E+mxdDAp)w}^eL{&M(4J@W__rL=A8jU?%&~inRtyNLV)>9{_eJ%}y$7p!^n_W?Gaw)XByg?G)}OT4ni^NFQ#B6!7^wNO)3 zj>-uq3K|cGQwZ4lW+40+1$A6~Zo51p#~G~uJ%1!;bXX%kx>hqN zOA<+*Uvw|i_ZlBAzLm>xi-TJ1DYzQv?k6AWE0M!9P7CnXORDDG53&>DJh$j?gmdf&_*fW6MJ!6yjU@DX?lz+m$aPiMz9JyV=E=4= zI5I@W(R8K^wmlj&Tt8rRR#f}Q^zAA1yIrXR-LBo?(BH1EvHH~so;3zE$kY+4@r)^J z@eDb~n1&sLOu|i4_b5g|MMWCYMC?RVnmQVC4cVG_4cWSM1I|%L1S4l5H8aJW^Y@A< zS?-Sdj~kh9{^)58yl(!wq9eyX)J^KTD_biWEpvg2U6m{NQT|I)IyXRmL4Lh&09fRANv9UB7H)D5O{L<7%W+ASzH2E9#i+#YGV!~_g?$?i~KFhzS=E|K4yR! z`~;)ICiBNbT|UEIX7e6AJc_Zn73tkBZJ1jj7HzSe`(euF{9lUqcnwvCJ@p%bkd(h% zj3NDk3QvaYp8+ao6LI@?^#LKUigIE<<$i017D%yaX7M<(f zpj_mq7~&^Y$DC7uq8Sc&IAH{zrHj{PRc{VG9013Ciz2g~-h4$%aSWMTe4x?H6p&qQ zjT{gA6=7pDong2FY-B&7tI@P3EPL*E4b`zb5~#^AWIr_RQ1MQBu+5lT0otK$IP0FHbZNY-xRkBa`bIps9kTgUJ$M1T zl$uVUFJHHz>gS<=h~XQhuusJgHrq`n2)xw3ArFKdx>*=qN-uP4B}u?@48N-NY_Ll& z;6_oKv&_ru_Ls@Er`!jqe*S#+WA&H5?GTq3Szt`4U()Znr2g|cHy$z4D9VoHJ?U`o zlGXU!3T0c_9H~9)@My&)$tevgE2?86`6ba$=yxcZiZ{rI;2RR^N!zx9eEp_^R^hZk zjcE5s%Stz>&fx-rg#B!SV&V8fx0J3ZTuP^8*5WlGlL_0tf^OkZ(6~yVE`tQ4;Gs-S z(+%A0jNN+DXP^9u8RR!?wk@v4tplt9`a_=w(zQ9gDV+z_SJ+ov?S4B4_^v*s2VUPu zOmRKn#s$h-aMI2*;R&yYdLYZ zhTIk;drGhf?jsox;{-yM64ovn7r(Re_T8P&+J(p9^!3Q8sx7&eSL`e=t;M^MopujF zksJMzPX_c#RRmj5+g4;_(2hzlvJ*-4Bgx!an<5;KEzuJ{7l|`%Eteym>PNpx)nc8| z>>u3>TOt3R!e_b5>e1cgjomTuAJ=}8C-p-8sIf;+v=vbz{~bw+WXFIrYS@T3Dz`Bw zXyj;s{O=V&*_@mvZ_op34>V6q{$D}*6Bk7jBRfaqf9+MP=%|4XCa)!VOT!6#Wuf}S z=B*9}s(#g6<)Fu-;0D1YXf7YiI7&bQQp!`Hd$qniqdpbd@jVC7EYEe`$K1%pH$KZ6 zntWXD)jU||ykGUXU%wyQz3;m7gRloH;8^|{438+eEc`7_4>KMWmAEc(OP}R zxG`=K3*MiVC0V$`)q0G){%`FSFXbvLB=JeNwDi=pdrwQ;TztwRgS0ZAg-fSzn<+Df zt43*4STjxyf0dybI}n?xS-t%{r)uHM(GZr-KsxlWEBJPu=*T-$b1>#8@@*G zDd35h=qsB@J2yD^O||G2N$ugQ@^bU}7IWH9FBJaht1(+vQ4i|b_xxTV`Jeb{Et2YB zgI!d1Z(Z7tB3F9}8+6W(FdILHC{7;T(9bmweMmqr)Y+#UxP({r7`4-e9m+rPi60LY z@UKgYXWm&9IjTzb4Q8H5YCN|9u5LO=yK0-dXl9w)kL}%*?*zSl?J#rJ$yQ40$_o@U z*@ODDIAj)$lLRspjY6d?5v&+XdbscjE#FL({!J1N**TYV8836|`m4Sv9e$3Y}V#YuV7wc9w)rekw1h?2OokMm<2RF&B^f>5h z?q#Yn8H)#jk(kzM_y%1B1A^|2-u4sbx?YH`ukuRvyWmUmRfqBErcz?wCKk3Q{AG9? znRho9{7+tSMzUiFj=(y+CCfu&boPkRa^~a}>~)cua0Df;)#K>SZ{_4qc(nY)Hyqf$ zQA2i~Ikb%xAzuc1OYCA_*HDQ0(9vnH7{gWB=r z0g*&dhiKcgS%;`l=8OzqTh()-Y>3j3WRE7~*F;~27=et;^%46L_=T-R^popri5~v@ z#)gQrAZQN?<-RdIa1%oTa{VrA@^AvrL#MOH)pN#%%(&IJ)dZBcHI*S{2Ywo1jK zk&y*IJH#3cU{D$I;KykWpmy(N9A9<&@cn1y zS-J6AJ+Y?^e8G%d7PG*jk|8ZWi3%aH)jq*a@)Fd#*9}XGJ=B=$LLa#BFNUyB=)sn~ z`sP{)4=^76a+2Ac*n?m2NR^O1F2EQ3DV!20Z^-c|hYQzseWa%O%$3hU!JPhP(!i^9 zpHQQ%QTOEvr}w5FPveLhFh&#KsvvpTIv9m)tmevNb7){0#J#iC>ors`kWT(mB!02I zCqlZ|hw_@G&ydOpv~Zy)Lng@Kb#Q)xyo(;9CPk*1NrgiUM@#yVO~Fry(uo2?`lFX> zShyNvKEDQEHP&Uw;H38AKRm|NB4R9cKyWpH;QA-atiRwA22qW%$)Az{GzDQ||Hnn> ze}g3>_X#8mMD!ul1klj>fmMOqg9N<#k&q0Ggt}j~Wi)WgHChX42f7L{Q4!xh_{BT8 z?vVtUr`0o8*{w^PK0V&PecXi8!rrY(7eRr5qDD}~o<2~N@amE0G3UJ?{|%uH-`+T< z2yYpp12E=2g#~C!Q8{qq+y(u<(ETQ!gZ{*G=txWK2S;|+!2&l(OInT@2_UiM!NrP! z64a_9^j5U8#6RAzqbI0z8xQKHDSFj0eZC+G2_(u#5ivt%H6s0EQ9jw{FL_N@PKCnWdx z;Htaqqg(PC`l0d!f(i-NWYaL#7)3qY$Wc8euh@dZ@T~R){_oO&@r)x#9|Tng2&#WN zvho*H64urxW(L+E(-i|76OfeqTVTmZ{UPB>Do*At`RnIYAs`Sfr+7V!Lkmai&m%=o%b`qo1&qa0P#Hd=+a9>oHFuBd(Dy9=p9PB zP0Rv2T8LIVdq4=K$zO?WQxXf)IUWV9(zba^Xe-EKz&x-A7sl%Gt3pO82&$-oLi$SM z^jtQjT@r+A`Qe;!O$2Of#@TlT@V?*HcLj`7LE8ptws%Q$N{#3iC(W*|{96sdXSke> zOw(||78DCpn#qaV^DxIM3bMy7xUU#MBEF)!s-HvRg^H04kIwyi)WkC|_R{dK) z(BM*-%0dns=J^l3-SNFFcA-JDR3UHPOuVr-M}NpQA7vr#^4lT77x186?wpB0z6GZ6 zuAcmkI6%(2La%3!vGn#po&Tl#*ZSLW(CmTgx@4BtRAe<|AT!3mg+e*!9GFlmu53L$ zor!Wbi_kWOq@(;;c4P&d;-YEsYs*JK#?mTmg%G|Ho-!7KU!AAFMevAvW%*KshmCss-`p_K38D1oZIy$Tz?D`o*Hg{B*~E}{4)<0{zY1mw`h*)(!|m2fdPS}fZZ_V z=}aaxw=~3;lr}y!-X@a<<&I5NYAu{7G8mBpYx%zulS>4PIae{>X#2 zO3)`yAb&;Ng{OhN&dK?TxLCL89aZfzG4%Fg%}_P$^iBrAJ<(b$AJ%k*em1WIVINU~ zpK)}rFjN8Di2ARu{;Yt$5*&j?oC*E~u1Vy60h36}753Y2*rN%o+{jggkwtrP3I2vd zQGzK_pj7w_N`l)zOYuOmS-K*L_w7hNnza$&O}-iH4E(1tez;}O z;Gy){mv;XS;yXzJxH{vRseZ`EH1Sw992DrRh#<&@|XW0 zt;R6_8dDHnzd(5XlQHIBp`~K$^zVzi|Kn=+cf|h6hI1|_PbxMIU%~^R_$T}0Ko8nw znBHxXGZjNzOXDrd1a_i`k$ z91j%AxwnPMEL7jomZgdj!U-fPys*TAd*00$;jFrtH8sV!;2q>m7GJSlkW)qT|KP7E zmP$%#u~C0g3qXs(5Vwltq3BQ)@@$jfi_T2K168;!!|X(CNwLl^z0B(@qTv%YF@@@A z#wV#^eU?E+fqB9zS$BY{o7VyIDRc^yBU3U-niS$leN}gX&L#1WixTCb;1G+S!}?@< zV}_h23itBe(+)@Ye-AW@ut5}q|6dCGpKhS2fra&-%d-DV8~%^nP~byDn+0V>sz0+L zv^dM3aw8aKZkpBR((kAr7|7rK#Ux$lh6o5`OL5iRXit%SzI?nx*aTmp-2EX(932p% zf@lRdtW;9KZA9_A>HHD(9(_TmYbSEHZ&@IQaQ!nRhwdDqydYvCDi1H^9p0sb9 zV{_i&2iC+j0eOuW<7#n?VOkrMCr+f1*Yqs}i^zURv~+X8P|whLtoEAfL`34b6e_Ig z41L3=T+%+YgchPfgX9oJNE2lyas9ZQrx+qESCBf1gq9Y*tQKK^{&h^X^10qco4XD3 zGPU}j_0%$9LG&Vml*ZN4OpN8i zj2hO$APz&T@zs6%58udjDvU!|&_>1ur~$(EUlXIOoq)Z)wS|$vAF@#1(azb<$jy1X{H^X*9I(FQcozUBLF}^F;{MygZ-&xx?Qdy$BnQVG;cqNVD4en?NG4Jb-@W!}(u|;Qj2rYZ-)qY-F zw%=Or`bID_aFLSCMmvP2w7b@0TgZFax+p1$`Lj8yJnp17iL0NzxEQm#jc{SrjgwzC za(`^@)5*pEEd5kd4P?-b@jM9jI0{L9=E5u4OcYU9wAB~808f!;ik zWX1ZZ!99c+I5Vk98>nEC#2hvEEQg|W%si+SfB<8nd4UgjlWr{3Gc1D^rianL!qKdbaI%GFLYCJ|7 zJIK^`+r@fnof;c}-$_g1Q-8NUrxg-r+`L3`za)y<2a=;T7r^=pX09=@%E~V4CXoa} zgwEbyu6H!;*~e)4tI?kTat$b@vX__c1F!IMLBxzq3;9yA_AGiyWEY507GrFRyDbOk zI<$@$x=gDNa5lnxm{Ax8FJ!|VT6Vs)gn7_od6<-GPU%`?UyUl}h2xepA~+T@M%s6LCJ z^*`TWwMMeUlHfmU;7UX4K7ifj4XgvV_0bF1J-V_EhSOf&oV=hm!Bm+^lJWaL?<9ScH7b8>(gcGf<;*%q_NH=T0PPb+!_y>Ef+$&UhBq zZC?1hM&(!XRJ$hZtCya7yRHNs)+on25?brHNtWkHg{E250&>=WYNp?`+8EHgYbltP znn+gCwImS!CP#hO_<4H!G1vWQds5Sg7@kt5t(S8>Odd?qg40`{^PIg2urB6m>)D7V z#xzv+j#`aM;bg2nuFy}>x9s#2n~i{wzhNM4y137-AT*s)6>A-yG|pf@b`WMo&l85+ zL+G6<$4?X&&h2ZJpf7-t%PD-Ef`E{F-u)T2yv8SRBxaFC_CT11c4iYMs$3DSe61-j zTH>oGJ#?xFJrekXMf-6drm;}P@l&g>3j}BdNSM(6S3p6pX-5xx=YPUg5R@jZmd{cPH8g#}Ap|sLeNKBqg<(G( ziCnU(>R9izs<|#?XQ|K&AijS0Rc5)z0jE@KtLApP8%r@T<>%X2|CnwtD1vb!0gQF3 z-qMdVc+{q{pvSrjsepPL;>{|{S!mQOHK7}r!!ZAXl@ zi~{U9O@;b_tU`nJ{STV0j1F615Ap*mA6bzNw`oje?IvDry;eNl-F?8S1CL2yD8~%x zqM*@u<9WtFZb11zU9$*vSDFpQS^98$e%MHmjz4!aPA0YE%jZwRaPu^8Yqnl8Bv&_0 zGgvpoSNl$$Bab|=G4LSC2-D&WMRbZFcz5&=|lNNGUFqrFe&16iQtVP zWu;>Ug;NL=5yH0HOMX4M4^b^qA?LF&AP~y_`YM%-<)|Q=8Qwx8>eu^e1S%ry?}+jd zpd|W(Iwm_H7qx#%q_QS%N}xI;NS-KL7+IP8tI(LCYUPDHhwK|e>P73}6N6g>t=!U5 zYc1amUC){il>H>R3sfevWysf&vhuR=STJ9R&X}Htm0uQw?GU6t>NtW}o-`zd=kY!b zc|-9PUb)FwYp|AL3g+|7blM+FNnySo7kQp|U-iW7etq!5^Koa2Mr}qL6nfBx>v(8~ zB#sv4p$xHT8HH6r8bPxZE!N1{52_7HjWPNtl7q1`)ScLmOf4nIODZLSp%#c)G+T?O zD!f@MUshW_>?o2*KXm1crw2?Den_F?dTub~S%C;XVD;7^tlg!fV3CfZaQ0C3?YR+^ zD%{eD_L;tr4vs!;uQAL|;w?+Y7_SZ>7|KXyl|zGpIgS)m>Q*#|4J~Iil2wnGRl^R> z*26WBZD;~;@Da%yH26YAeophWICHxryUHYv2rurzbBIFIHNlylf_JbAgxA_d7)$c zb!Ql-BrG@Wnq(|BjkAxg*=Zm^!^k2M%4i-B!wgqvBIGQOTT6A(W}zvY;l_`rY*MoC zF__V4c<@^vEKa9@+D|27K3|9cDdnOhGt)7YI%MP7#`K$^RI}&@Yt1mI5?IIV8k(T# zAF~%S!HEG!so<@L8+TzxhynK25sEBJ^eXf1y-r*8N>|sT$L6W59ha*bT%v}#ve2%i z&sGuD9YpO4A@u{2r=)&qm?;4kUWrZnu+^Kbl=h{C`>DL-2MIJ@ss;-KP9lAoGEl1q z@Eb&eoMtWY>~dO)=Dc%T>$H+w0DI-Z2&|b)l+KEs9r0S~#M4(uY{x+0o~r z4?5zQ__J<0<#!)k1(Ff=3+k^ zYz%C*i>z4HhXTKd@=@rif^54eHV#b+MGay$l5SVD@(kyZ;c|zWnK1Lunb^Q0$0U<$ zezurTLdTl3g^P@<4vX3`UHf7L5>_Gibi2~qoPS*x&e`Ne@irQEpq+@J<{3pIiB}a4)?t8>RJoV+8sVfU>kd;xC{Ma= zOGa}Yj}pOZWv5F-j&!Jkx9SJN6<_jD2pDCLh9wz+ba9U`11)NQHCa#z+HX14m{RGA zt=8*38H+@hV4*a(#E$LiW3brn%NfyiCrK+DTcpYI9U2-`4ql@bQ;T}@=E`AnT^Um= zYjB(A&)g;Ets$TKw=~&Z71PzVm`+0FOv<>uw5)T&6jYVQiO_Itsqo&ubyBWAzBw*V zoTu>lj+=*${2)b7s5w5zD}D1-8#?%Q>lUr#*R{}PN7`@kOD@NV2i`$#6;}zgVnQyyZk$>-J^0BZLN2Z7wUum+XxB=yqe({K(2+?uG^A&84gwS7AXX_j z_sF-p_;JQw$^k~1`vZsRkOT8gUx-WyNpfuMNJVmo@C&>Fi??ZSr{rorX{uwP`9Q!5 z%fjK#btnMt`HPJ*Phed_Zuo=v;JWC!2vPlkXF+x9OGHQ$n#!1;MmSYO&1831U#{j^ zWV>6OUIJK(YQ9n5(cHARvz;V?FXO0D4n+49$ggmAPTJ)5&~X%-4u+h;q&)uU zj%-p6tU%2^CBEKp#|qz50m^~N3wmv$%%51kzCrSl%nF~B^hki;wh3vRCa?_xW6e6h z$zGD(b?HLf++busQ>}69e&o`z@at8{C`f6oc&9L`P?;}HI5?rY-l@u6l~;)FP$;lo zQ1LCVT%nz#PdcXhVz9A5)uaa2sHo;qTe*@kXRB9I_M)K;mym_7yBIFm0^>rD@L3?MEqub{?EN}}|k@vZP`u=G~YF{ONKY-pgD))1q5#=()6u?_TfkBrX)SgM&#ESl ze=zu8eJ2;?ziJ9XpX16$`@e^V!ce5@v*^kzqoJeOeT-LER^X!@4uu`IwWQD1+bw(g zkf?l=hUg2jbU~2pziIDN6yOcMS%|59-TkI+SMwF(7ewgk? zEt%b9&TUCqUO|1{(4bpDuH-zb>N0m_ZNr|C(ZdbeMpAHAmM;dd7GA*$%+Z%qO*HA4 z0pe3lxIYChvG>bZtxze`n&rvE@T@E)hq2YS!xtXffx%+oQkfT`U=8grJGAncsKk>q z%zm?JV!-V5DdSPm2t#rNx8l7+^lf~3@X?qH6!ph%ZO51_3HcaDT_#%HhNiw(AyP(w zuWp#hny@-aT?V1W-fgYwrV*0H0T2iiBO@^C0a6T*WG1_Zn|&I5pCM#(ZA;1h-Quzb z(Rf9gnda_Kv@-uDZtaogiJM$$s1QMlI*P@7i4u5fx7xCB&f_NbWe`YR{t}FEFQU(Z zpbnkUU0H%r&FM&Nu31?*sJtVn)x zTU@6hS<2CJus7o)YSVqJ=8Bjn=&$X?q1fIG>lB;I{Z6U)C02JtZ&}3dP0Zno*aA}u z@6CIt+89SKKHY^=f=K4zsR0D)%hT-?JN}Wd@&Sp}rxeP_IEO@q19O=RPO*IrCUW=j z>ttf3ETeb_;!_|8qX6)$T|gNcL9B~^B+a{$IKkxMk0A*`!Q6unC}98@YR6dO8=@kS zECC~?0eFve}z(XjcxBYBw@3jMSbaSu}Hc3#FUOE zF!DGgR8ZkxpXxY!a{3az4_+|QQAGH@ehIE+t6xeGWtU?vd+yNj`_OKLlpCh|z378a z0RKXY>zAPY8xyGuj7M4Ir<(EEQXbOM#UUVrNA$IFY6Xq+-j_)yC>!V<4kg*-D_~K% z{Xn>!NyTazHsQ<2D3OYk&R!mrANPnIc8^d5!&8wImNKP*aU<>zO~ za-hZPfCYg~YNG^Bo6TyWMQZ)gsLRQ~tC{P)Wy5lUJ%3J0i`jTO^L5r>x&Zy#_Lb8I zTVx~OR3+5yYQTx*L z)B`X-#XsbJkz#JwyWWYpyroL-X5T$bbG)I2_siXpWA)amm9cza=2snl<5rx^8r`Qa zy-0ef#Pg9G_t6{l!1qJ{-Ys?YYy$6hR+Qg$xl{L`CGnVp*FlulHFI%~~wu$(O{1_;DK=xf4+X zc>cKi6rrhM2IQ8R_4%dIK#Br|g=vLRcr6F&ZOy*38s*tq)*3;51yelP!Cl*^O5xtx zm7T&J_4tmQ&YZ=&l{n~3x-BlNYYe4eMoR}5$WLOZ)M08>oTl*SO>sx@@oZhy*z2lc zqQ4}p+BYJXo|y&X8ow2PxD15AtC;>-XcHZ*1bRjmesT?&6)h;xW742&l0{Lo(9rqR z(691C3@Pg=U}@c$13#>>Uo7q=GTJ3QOr4TFQTj(m%l8IqhmpuZ0I#kc>|?}B7*9J! zHyl-fInS0k6j! zFWP6Tj=Zf!0$Z}5(#`YO?5E2$z+z`TQa)QUQCw!0-|ij&EGahE+dUy9dq*bT;{AdA zq9j;LfKeXfLZlaqKT}J@iB!e#LStcbg8P*>oeVz3mg55QsH+ii&F8J7iBX6-S;F$P zbv#FD$XIvjBP6%aG?%+Bq~^l@T!@vtJC$>$EBo$x%X?@a8^#!qxYwhxy{7>Ojy5P3rfTzQ6~N3?qu0sCqFiE0#1nQ!ZD2mJ^k2PwD!q0j|*3)231i6+2JbpCk86>ATmmegEaTxvk2SM?XkT-21Tlak zTnx^k4a-;?52h)&&j$Co&tQ0{ytObi&CxY6j)^gtdxee7Zf!vSe5tESLfFR_LQyIm3YmwUb@Hdfs2pqKJ}ayN(6 z==rHm_Ek}JM?+Xs$6APa%%&en{&y)g&61h<$G!3Ph}iCePvUEldanID^Az;T8U_0) z{PDlI3B{I(;>BBY9PYF+BSvfcy5nxRc}UZWOs*r*+V^3OXEY3^*qzzSl>J=_Fz?i( zjiRq0WkorD7HqjVRepaV8OCK)1o}zM)k-6)se3A1zK~LmuCqIFBJXXJjUiSpqil^G zCjrrP`fNv{k95}Et(@ZU=(iK53ueWd4W(XJx63aAXcSFPY?;*7bW}Fv>pQ8*l1)1F z_&f~9;O~csN~*I}YgpO4N{PNzR`SfWyI7%K=bn!x(yn-5v3qbNY{vz=gzCYK;`nHA z#YRC{aj;NDp`ie+BYlMyJpu^|%qKp4;@$w(~tz+1pA7ANqJich~9bv3yw%<4JwmwZqmIjq_*p$g@aZchRu-deG2#E(R zo0XnOw~T0Y)CZ39g~S}}c(@$tF_E~VV|uC)#Q#hf-_e-{r^>)lCA;9Xyk#vQ_+6gj zF*e@rnKa?13UU^V>m$ZDQv|PC!K>Yt9$cTH@+)(qG=KLfZ?U7EN-54fH*jvRL(|1ykVm(A3q33FbU7MxYhk6Oo~) z7-Bfmoxj!B*ukf)%8kd|m$uAJxqo@rrK@}O-SZ}5VI-n|RIdzGkkUva^$0U1F?QVM zW9|j=Rfff}Shz8HDC*iATnmiQjVSNcW`}BxFTcE)@ChdWp&kz_=m6S9J(x}Cm!ZPQ8sBo7fv_yo; zuE-AzVJ0)UWcDiOT(Y!&7;2-PcN*GG9~*do(%M%TEA&Z}r~Ced`s53JPgMNmW&lwW zE5`G+-vBpp2V=U?h*)!SB#Z6z8^7x|gX@;-DVgV)uoXR?v%L>H=~ZUqrekULl{m$9!9AKHoCa9GuFRnNzy)K;>mfsiR{Oj4;BxkGK+5HyW zqUB9la~4Ba+|Jx&(gL0CBNv91`zCxi?To!(pT%eR9xxo$!}{JpH08qbD@t=T==7{! zDnkbyDUoVJ7?;4#iIc!R)*OF{AWK&{{adAG-%nO#)vhh)3Wxr6*a#}ewtp1xwre9w#O8G*L8oC;X($5!RE#DQax z+upYz=z;;`2#0Jv<95FhoqOkEn_!x9a7-yK(rTKn;Xa!0a6bLWb*&)CCEmp5u}+~z z^56uR%pi5Y?;*3dkmL@&M_7u^xkn)bc!c zDwN-$mU3ti9a>50nRrm5p9IGq4j5OjQT6*5BCHDc$orwHru_7|kYg;EhcW zs&j`^qsQba3heo?FnnLNHijwxi+AGU1D7VT)RlKtj@7Hl#!%I(-v> z-M1^5t!n8qv3yLtjCK3i2i&p1Gz*`lCZ??0DGY=z6F>T{FWX-30UNdNC|zBF=R2gn zX6?ItL5rPP-+h0e@BuG;f*koI!w#l^-_1=JPP41rCi|Wb;X{s~DK#f@3UrnqbT#j3 z&OD=4y+aE*<#u=~SbP(;yaRCPw>|hqy8vb-9zR>@m7Yo4BPX^7-4Uv`BSv;azrL3z z4VUlDsuwU>ak}i9oAEB^i+Qc*b(~HeB4qM+7WQggI9HWAD-^zzV-MgmNylep%rwtv zb5-J`F>?U@{c14JLLQ&NC*oTopo--@z2rq7Vb$ZIpH}E)4eS~02T7u3oS49FP#PMl zCiUqVLOWC4R?{@Edu6FJo0( zM-VKlDw=(WC0pp04^uBVnHt~vE~jyPCE@w=09g}7Iq7`Vqh-*Zgvkxw)%^|ju22rC zuh@47i(OW3@{!?fBJrQzes~k^H}L0nSC!sDmA+!my(L-qZ~y1b=ov%i`4*7*LI~Q2 z5A6S+&)xs*iT$l6Q1GuiLgZd4YbIX_$zo+b=}`BYGSavUkbXystYv{dcBItDC2NZ_ z9x^s<Nsf_yuOqnc%TFxRqfunA^AzhTE?`*Hzk7FXh#;?at4? zV{#xuRCtj3PA&+3ii$z}An!kf%JqJ zp5iIn4uQe(Wa>!C#OL+l)mb_%JZXKZP2tsniH{6;Ov7*6J#K7MY7&k5utuw#-C}CH zXwMFhlXm4XVxxj|mxwlddZx@Uk#@`FIxb(`o#v7T2C#~@&sm?0m0d$z~ zwR%QuSL|oz4?``|3hJ#ArbYJ*TCEbjp>!(q^4kOizAiN?3E0=g6`d{H&aioki9JPa zyLN1#thZ*Q+n&uv6ecHO2LAq`p=f_ZQzX=yK@We_C)&Ee@q<;ecgZ!ZD+JYNGW)=s zsm{gjU|n{LO_jh7J+2kmXLT@@)vhp4UVuJv(N4zod|~jW-iGUF9D3mp4Mv)B>J>d=K`KJOSh$xlIAKkf(xig`>i#Cgazmb{_wTO&dGM9_3G>>fS zb`|rEtOKAcq_5DKjTd|hxA3&=(Qcs?< zI9B$_G^m+z#$6`Tt`SI^tr4*=Op&3eFs76zt`;F3yrsUJB^^~(BjGc^Q*V@wf@j)9 z9}bXwra!HDvnZYw=tHkBcK6p>QG~v5#TKSDS^;@*6(mXazK`sl#xL3?Pz_es-_W?U zMoqe7dofV5tDMvwi!n@i-;h!1Dp$*YNOhp_2zOt%dL>Vo`Q?&%UfeZ)eHt?g)gB95 z7gHRdqH=eohu}hU5{cn7&`>y(HP0#AE!oova8a+?V$!ZOfUlgiFEFp{wS>UTicm5* zNCq?<>{orS-u@MH4+Zcqx@s07P`cSCY%OAa`y?M#ec37h+O>2zh zsWTr`pn~vtD>CTf7`=Bc+W)1LBdZOMf}=|E5j9vqSMIjaA-igq)Lw6|xAS3jL?*Dj zZfCFHI}Xv*Xu95wieQ@eB(c}A`Foqx7* zDM=rABeW8q{??A-I8rR+S&~Fa7jaAg=ueCTgtxDrG`_vIvvCa#NP;0#2q+#!(^DupT-`U=d5CvdwMdYIyH{;+@xH3A@|rnJ|X0fEPrgnMp zU#Bs47M9DUMe@&uZ7xaVk}HCP-kre`^eSS_CVQ0Y`65+mL1G{=YgXa(HatqPGPv?T1M^Ysprzbg?4vci%NW#yLV0x}A>Al&H0IWgEL8rY_n7d6*msG|Y(* zN2`NdE?6B`evx+^_ONxztbOOoR#MI3WR=a=)6)+aVLdxU)uxs(m7~vV>kGw5z!Z zym9p)YV_Q>s>#rhA}`y%@~sCfGL3?^Fh%;2}Wjb9nGv=1`bB%smCIjmPUse zL(3Q8?(Qg~uKj%hE8lnTP>7&nLl^=eIXJSs#5c8e8@u6X7-MuCSw?&azV14#20;%m zMe$JnGViw?#{T#$eVdSilE?d#l5u%d;ajw=AxXeZUGS8;Oc%F0!&CB!!Eh=-zt8M5 z;49`|cT!ql<+x(%K`ub@yNJ++Fu`o$H+6iOomwV5anN z_V8fgyERYU75#fNOnf7X@^Xj?@E-)mS0U}QnD-iz9A7t2iGa00nGIW+_=K67{xs@~ zPEBi&>wS-zIBl0#R!c|!&gZfoTlFoutTIjSeco4^?HEg_C)@ZOXQo+D3u>va*MeWs z&jw`7`;}HUs;cvFtG;zqPCz8G>F}_sz75k({E!flO3^g%_lkA>#QwrNtmghTXn;IA zsB6&wN3#5-+?MFy_t^ylhXnzFh6WMtB~d5zd6~@p-T~EpC(8e)Fy?<*Vf! zm5ZzM|7GX5ByK8f3L%I73-N~;O>R}n-*QTjD(|gcQd3ul6BE-$K7nW*AKNk2lI%K6 z?FM5~s!&{r5&%I8(F`jTizglWjg_l4yZ;Z+bc*%sFDNiB280Q$8+FZAD^YIu%tCIa zVhX?NXWDC(;8-wdHT0BtWm;m4%P=|fE_0}Daf!vuGFl5WA@-9*ltCVK#5P6xqD5!Cg554{f-&S@K@HreA7gd`)AZGEU{ox7 zOZz%(c*JFat8>O37`Hr}@ zqqF33^edy{l)6o_nkG?MCt8M@tNA0O(q13mJkAtJ1>Ak=`j7SwOZ%YZ2u=&co2ZKcdot{TtrviMDb`>(Lmnk@M9b z1pI99f1voUPaEmSq_^5P%sS?K<@dio?f(>I`Y*5jIa;2E`050Icl4XqG68A{}FiNA3qB?W2)i`&wT_3H>-O>?Blh1B`PX|SZpqV_0o&C*Dg${pYU zCFT2G2M9GarHEZ`wyq5FEY3f1Q#0PT9)5k7@*fM{-Y;O>`s^Wdft&0;l;BAAbRszR zX>qd?qXfg6!F-}?v0Wm%I|Kv#?HV_}3WL5RXYKNgH>-C-D4Yksk>Bs)L&GSp$(-*! z-+*e2eZ<53lxYS_^`e7^!T^*3cmU4O3^L;=BLW!7)NsD;RjSI1TbRmeaYv0WQ_c1zbGCMMuSiM&nGEdafWJ8x8V|GU#6vYEvS|A~NZC#Q+m^I4xEp zsc<(AaiY}3bMAACjm#F&x418WZ(`^*`N$3%?PA3BfZS*uI&jPtx!?x(9RE5BjG}{u zXW)Wv()Ffk=_+m(>K2WSqIk>@FBw6ajm4tHpAk0DsEwr3<@m8@WxdkhGN!m*F{bp3 zHoBIa?dY!Q8PW4(3DmKj`*i2c(Ptq95`AQDGSil7#b%2Vxb-E17DEg3M`&Wwur)R7 za{y(_ZjOhFKk2DzwfkJnpG(-lWK8>RE&T9 z$Z`s@e~y-z0+#2xhgq|lwzti_)-|od`aN6WPMajiT`fLUE;5qkv}(rHTFW%73x*%{ zyi#VGl33WbbENbZI(e+0b?(&?jlr^(GK4&Z*&^V+WOXcxS)ImzyUJwwPQ3sd%eLj7 zHG6RV=#VF(iVt9qJ0@XLwRjojGX)Sat92EdvpV#s{TPL*@RaFNc0{Vc`D^*XTQ;Zj z0nGulZa+FU>fuEsk*7^1v>lR?kGO0DX&5mxQaIJk2w~Dxpgu{*=MyI=84&Dn{YG=5 z$6XbvX9`WOtg0FS`^d&11oq_EP>v=7_HO*E}(xES|@C}?H$b_vWFwZ!x#RH|Bcq~|7 zmBBLM8S`qKC{@OrwJHcr6U(Nq`xpXxuj2kMktb>s6Pi{Q8Y(6xFge@)L4tI$|R*Wg(_HVcd3l# z2YPznc2hSN$=+!U_0DvvSm>xX(@I1%RHtIi{HTyZ39OcOZ7dXBhB?Rdnh3jaU3Frf&?XkagzpwzG2b8W_hGl|G3{iml3(fR#5neC zB5{!~m!c2NR1~;g!T~!8@{_vPr|}2JTmdLiF%QI8moC@y+v{10@}baf4>R$~iR&&B z@Jilozm@S&B_qT?Cr}ZZH_vVrnM3%j5pOduQg?FXE9vdI*F6iiF%GHA3VbE{@b927 zn0xPC?WPh`r7GAj$qh@cNHbNT0{|4qmdf5F_3bBy$q;lUhGHA!<=xQ1=;c+ccG9xX zA%U7T^7l&+n(_7J`~fKt4LIXU{al2nESW5SX~^QoA8^=FBa(A+|3)24vfpl0H-Idv zYV99K(N{UqF;b(gEA*aobh%V2D0v(NgxmE*#UZ)23D3e^Br1XbB z!>VBn(JRu*E;@|e&z_ZMRd?Pa{3@q@TzM{4O&hya6&JiTl$SvpJu{B5T)LN5Fy9)I zj#AtUMQLjQJ{+J|mFekW@GQjKZ1q#$;OSc(fP>EG%IKw=>2)8pj-nXuLYivGrDs@Y zIj^soa}X9?6#iQ+sCn4yZZT2RN!QA8YGsnApGKG$eH--R=O#EQfM)>tOb=ML4Cx=& z^>l>&2h{j^+s#;Ipr7yAE76lT)5o^tneJ_IKrg`8(TS&@3lftc96lxhTtOP>g6j=` zsn}zDC3EXSF83x(B6aI3aQY`4OxlH#j1ETam7T3$eeCih^3~QK=@0d=vE1N%dV~ox zmMpR`nTD(rex@U5Md>ngn4!1MVB6(UiA#l!CH zg@or%CjKPK53)ZCuU>rcJRkfMf60)K9@$6#x^L_T$W&&C;$bRD2k)o4Ypl~gxUW_u zqg=>`_7}3z0%G4C=z#*F_Gmz zuXF)@J$JC>`0lzvKGGkAJhnk7^RO$5!X3v!N~`z0E==L=?4D9ST8l_kZd6I?qOO8} zfgJ0x8n|dN`&;Ru*gZ>hRF`LQ_@C<~)`~2MyR*MN8;yL6jzQ^e{+)x(=emWKWgck0 z5JAUOyhhmcz4CI`)R+q+6leRM**J;BnZ82+Y4(rt9P@a#i6)FE7f71U3><-*(6Ply zF0bS`2`)2Tp=rN~zIa!{5aU1x{S-;IeP1Nm*9c7PLi;?KG67*Zj?4@-C9m@0OhrGp zjebuNHB!3AV|=CkyOU2F$H&&Kk5)8`nmf*SbB9s>utM9Xw2wSkPKXOyFw_p`f9}o6 z(>pOd^4cY>NG_`ykdVq8{+`v}Ihc-HcXV;uAXZP00S%n3ATofVu1uDcZcp#km@qvz zGoRAUF1C(SilWl=Kx1Z2jCO|v#qZ9Ed^OfhgWCJg-y}s_FVrl&NL+j7Qyzs)FpFGG?I7bbv?Tmw}uY8O{c7nWtuUB@$ zff^vbhas|uv7krZpdK*6PDSEg#k^d49E+t9mqNX~5++e_h+AjNrVK($VoI?GM|a8x zT4_T~cYr^Jl`5f1Uj1_Nt-bGR$d{0iq%HcxN8735dzjdG5>8=b1yczA$4_qv3C|J| z=?p`h4w7couKQ<_q;gIod+ama;1khWJ@&O+%6x1^HzO)U!D^dyut@vN`J*P)AkO=o z;W>XMXuEtjsK^veZwUo)2L9Q;T7%qs{YkoEZ4l~~6;Fd1E!OHmeS&s3f@1$X%fhC? z4vf3CYT=Zi-)T^A>tz_UK?ibfP2J#pGwQG;9}N($_6}K}%)txL$5kFU^&NWiqx=B7 zvPD{G4C8qwG^+DP$GgX-vxd_1$tDyW=O!{V%~Mw9TXCQL%{SCUx3m|H{9<>MI@pwh zLwbK>Se7<_ckJCE|A%Dx{te>hsj+>rRyLzno{#t0=FBSXVYK>E{v$y)L}iuS)Wmj~T5_+beM5P3uUVCK)RfD1B13c+hJeo zg!Hr=_V5(^N7e#Tw-0sNae=-{*&7ab1gbgwRHFK%S-tcr(^|vI>0tr5#k3178*acU;$!qUk+ z5U|%s5kDIZvY9jm&!m%F+?OJc6#uWP9i=a{p-}~&E*5LFfg6z<=NbNAZ!ps#-Nm(8 z_W*c;!|veA{ri8%Bi;BOLcx5e16#k1&i_+F@c&KZ|EaZ%oaO&GHA_@C?a^3}`4tvy zQCr!;MHZc{3N|T^F$02ud$b~zY8}lgN}gv)O%0u!+?*S3k?&xiu(STb$Rb}Le_@7z z7%jdPY84A!<}=a00NlK<$JIm4T$>x%E(42cOeq5Q;TAhy|n5iyB*{ zD+|5@tCt+~F_J`2XV++qJ@G)7O0AF!2TANH7g42jXyK!y@ToXdx^@eJd7AsJcTqrPytvTdRDWQMVZ#X9epDEl8RfQR zqS;(_nON21rT9YSSC0bAV=IvmtGm^`4R8L3c6H{l z&!@6`mG(D4&ioRN^%~q9W+q!G%#bs{;2cP}dN!Lb3_+(!W-yEfpvW7+N3lSA@1stX zpYKepzJdyKca1|}rKZ5EMa>X5Yg|o|!ii@#qG`KxXXVTMh7GVJI#QD9x+0z2YFW2=aCwb=!Px9g(Pr zx|6-{0HZ{D`?0gZ&CQ4RFA!U11ZEgy)K8K2r5zZ3^t_i~vn&tw64RL+cHVs^<+2th zO0LNI@Png~ylk3UxYQ2q3u9Smw#B6mZYc`rrliJ<`c}QVE=Hr05R*zzDFz0YiN?gs zDuy?``d-=em)X%t`J)*sWXLo2J7`g$&?VU`0|_|6=<9zIxA;)#6<5AHPsRxUXLQy7 z`zuNP{~q7}B6bXG!T{BlG5*e)CUSXZq$A@H$M=K$XhaqJL4qtL5^w0=EKF^PXJD?M z$l`Dk+fq}r&84%tv9h9#6`$+9YpVsb?05VD zbh+h!$@QN7HS;#x<9YD)g#@N4MyJ-i-$W}AHi_=D6U0cfu4Q5UqUAxAxYne-4;D>rLPY%?O6`|T40>-g%m-7`SnK$~C zx-x@AWrN~xzZ58>av=0BJ?K84=PP3`l|Wo25Pp{_5H7B&eE3-8^t%OItpQsxVrCIG zSGi&7{8Q<76KyJ=&OfQ&aq8^6IeFAT1#!0Ai9yBtCQ``DQ(C_O1KQV=NR9)1n>!mM zKeDO6HG#V{ulytyR@A7CmoQq#7CqCXccRY^51Ui77Imu}!CI&EA}l5P;c z$dAe>!$|_$C{X8XC`F@&U4QbobsL92AV^e?M-SOD7>`as(pwxK7G+{AsuoqbF_h~B zpFFHAw%BRgk(;h?K5u%NbXUo?UBpUw$cn=aF4JJ4`V3wiK3@7N^BZ0Yk7gIlMSH!I zvM}KzQT1CRT^kY%eVn|&2V3c`Wi+TXwfy8?uzR`7cGrP>s$DLGxhjt!TKTYrU_y4@6x~Ld zj@9w$B_R6iE*nO_lJvY>N?%iTs+#lln~P{t-wxEohFjBFwF#za#MSoM(RwW+Fi=ep z2MkSx3?Dvq+k8Z%b!z}CeAJc=aAp`>SyUe=Dl-e6Hc%jeq2r}#BA;;Ms#_Av885u% zFP6>t&XiNWrwIF3uKn=e#Y97xu9F5es+?D`der*#IdnREH$tHER_l{nY(js75)r7K zJ*;~vGMQ>qH0VzU%l(=BpPbaklP4&xslSNxC1ht9z%{}>G&ZN(G3GQvg4=w9=mvC+ z+Odd!e{+Y9ceLuWILY)sUGOelb03XZ zb$jYe`hy10i{w+GnCG>2Ebu)#Y}lkaiWRDNomk%*1N!H76xSWnNY_03b-JC^d`suH z38V=G&ubZ!gV#M%_pvzB4DnJi^B<28SF$rCm)18vw?6X^gdBo{yxUv!t4l7q{bG|v zmL)?i?LKI7roS<59sVWThi&qUM3*cKsXaj+JwT-IgyMNmcKqF?50D@Gu?&oi!f;V&sK^iwzdbDrtMMOeF+p-OkSCtK_D2iwq_vaIoW$@Eg~yAPnLw%L^>t-UZ}B z%a`K2ht}vI7%$0=Dg}sy=;KO?L-4rTl61UT_>jDHvjmoI}7oKb~cJJ-G=|PO5pJ%J4 z?)Yj(mtVG89{@WREmJQ0s_zi)V()ww3`w2NfDZqgyT<<|wN{!z*)le5qGCWa1+~wb&ELPw- zXo;JV24glTr$8wWSx3lLKZjx-Td+XUVP{B^Gz(X2)+?5g^toxTquX#X)I=8LQ09!d zE8Em&C84Y9-JzGB+td5#DzVTpHgWpnR!u*lKmpM?g8`d;Xq8fbfe=;_LC+CS^~&EZ z!lc|4f0`;eUNB$$MCySP+puq1;67<^=PH=FXsq9P%+5GhMp!PLE!v7<@aj-=j!{!j zdus+mpjxY^n$NSEBreicHV(!gFu&w$?;2LNwa*Rsr6kBi`Bp>*8RJB1uUe2T+7vUlJ@sbIK_IOsO-F;QEO`HA4JhRFG+TkB7y|=CYN*x zPcu1GTgkee*{9t4TFH2(ASx#QU^lXC&*YCyYBM3gAJD|Zq>t!3FI@S536bCqiDci9 zw(?_*&3S%GI4C_b%;uDH83f2SPlA%+yp22;rPai?^)hSy+|NjyBM7EEw*Q> zwo>OLZ=zCU+r^G}i3_-$MI3CQU@m7kAr)8Ihov%h!Dpm1vLz_7oM2&CluNlOY~>;y zB7vHCODhUeB(n1AP?ynE|&QqU@J{#a1}(#UmP}0&>z7NN-KIF zF7+Ee9;S!6FdJxV-)in_(&`X!%WMB4WOr?BDZ~(pf1wt}a<%W!+PvRFWEI&)W$>66 zmMaY^FC%@DDt?_9Y7cSj4DL&NnNHkWy|0_AQ2RNrf3(X7{TJ=HfRbDFNSRp2NC37( zP110}O}XM7UeawP$tPQv(B6DYmnJzDg_=O<$Du)cEX84DkdiLitn~Y|QHkeIyfR!XW1$_l>-n@@6!fk0s(XxhVs~ zr*z_|IfA~**>st{%4mHn82*+(==!85y$x$r{rVKxFMxl0FbfmBtyxb5C%(ksC1&ed zxMc}yqt)HfXpNLg?skQ;(3$L7k<2J7Q-`+jo(wS=0zsEJz!p+ZLSc(OP+D9s3awH4 z#3|cTmAC+@eNf>C|F)c>{^6*CnF@^Lk1NP8T}#SlnNI5=stV|_+&{KidrDe=`YB1D zeWDr|$#mMB^?ik02KzHnwa@ij&gpQxOemoRyupw1)+dYF;aDs?%SnKl7bZMbM4)I7 zCnf<+IacyR1|1PB7RJ{ieB=4aAe?FDpQ4U4fy+J2U}CN6 z{@wk+$xBUy8zV`jE>!mCtbhSp8M|i*Du_`$xHeSUV;|lN1d|^&D_1;QUx=tD+|LVx z?@T^h`gV_AgVVhe*0I)xcgAD+0Cd$@_eeV+N>9FBjB>4F?3lyNrxkm%C3Gi{p{XNB z-@+Z*nN|Ak)QjU#7f0 zQqhlNWFMEZz$W9q)&#OA_jJo2qCMgKycFFgH6J@K@p(psWG3zPJ_1$KlRJ-bkEM5$ zbyI(g0m~*gDvCS_7T~<^MWjz!Nvk%jM`@&ur-**VRU0WQN%5}_BGMacOY0nsPp!g2 z>6rT*Yiy;gB&^fy%Ne8EkaVO3b>JJT6fnpImvs+itEC*R_xbTR(pXz;@=T2L)GJld zEXdvvg6qI2_YJx?#9{I;($UM?f0rA?G{%I}zQHI*$RHrx|LbV@pH{-(L2D~>&;K$j zTu!oYz56!3d)Yp2|Lyz&*;@o6 z{}%A+g~ZKG8ytoXYrq9WVUcnNVR3YmYm6LEih(0Aa~h$ZOI&C>yGtWB#UMM9jUB+@ ze#-3ai_#ETj;Wgn1X9vVT}?XQM~0?VIjJl3QBV6w&*)c>Jft08sq=JGhSjMZR^jSn zS>noN%fstq;}hXam3S#4MVFysL4k{jbYLP)=-zza>B&Z z*0?RWmImPj@Qxxt;&XBFlQFOfe#rPJ`{_EC$}yRA!GWbMnse6chH(xgSu5suR9~Xk z!$Df(bYsDH^irsw2U^VFz>j6}LuUTTZUtaRgYO^z0c>Z!p5B z9kN*uw(6%IpWM(+5WcosSDRPpM-DEnjcgqy&zDv%x!3yyAY_Gv=dmvqANZek=v$={ zigOd+sj;`Plx;9Q^lScLOLTV8-vF3N)86V=z3Vk%^B$b7pooXXD)`8Z=KFl{_7)t< z`y?sYW~=k|hP1i*;O)-e>-i`Sx)C@Wet`b*t;Kr{urP(1HXO-$;0n7B^7@RABU(Nj z<@F29yLiR%t3AYeHRHE;Jk0URUcIOL)E;zj{lxsvu6hT|#2krN?xKhD`*DD4qbh9t z0k9D?&m0$7PrIm{Tq5yynpW-%b%A;dJcC2C(;FS7a=Lw@++Mt*?JVA(eqN==_U+a2 z+V7Xfz9bZ*VP$KL>N#phK{YI=q2QPWYB9<-IH6A{O8~DW$m&a`P%td%z*vqt0Q!yI9JXpn}!c(1ty}(rE|gy*Kiio6B!Yb9fI*#QseI$^@`1PnUtQ_ zUIxB5e2w1trY~!jI%}mq6A-BcREzQ^jJYaExpG`&T?3jsHk*#6ho_WG2}bvY4s_2+n)M z&0ZeBVFw(o&ZSZEy|Ce`*Bizf;W5?-F4rbmiU}_;>Cc!$P^zUdL(2Dg(aTWYd3y}m zO!v^_&VoZ#AfA=9kEml9ey4L>**|%guAZcF|!{_PHAI7lXJP>A$+^ z?(sivn;N&zZ1XfxQ_FWq0bg+#as6nQlSW81U2#N{Bv(Rs&yR;+Xg*c_RBw50)tQfl z>a&c0qLnCP!SInDruRBO*LG05;7~5xgCaFg3Dia~QM?Rj_=lb7D!E52i@`X8tH_kd z_7R<0IO<}{?&0&z7pj%mtlC8~E*aDLhRU|85>HYQ#9qODVU?uk>5qWt+M0`^E|hKFZxjyRe*NTklDLC~;St~->f4AbQ;V}mHa zC3GET>DAlt#@PCotyMPC?sBasJXM*dTOM}Qo}fa7m9H57%eEh{J@i_xEc&b|zHbtd z4N9{85yy6r<>w1`lw)ARALkOHGDlPk7JucLQb%0G7Ux&|TGEKs4i^N`&t@+LvtvMI z#J=FsICS+7!4QgYSaU!CUWyd91`j*D9hMn#uAfVb3O zCgr~w=(o5&9IML8cF+Qr>R{T){HQ=iO1R@_thfH=>grQV97eS{yHP zP`?xwy9kXb{+uaspDAJd(A7LpjWs=f9Q6bV9UqRZV08IMHJP5-JNe`6fo_Hr-A@VY zRI@Lob$0bywbq|>tCFUh4Ai&keh=|9o!1oG_B5|%!TJ+T8dyhA5sYyrdQhsZhXj@d zSkJly|1`yuD}>TLcki00sdfYAM~m%XZ)v%8tIl$ouq!~YS2 zTeQ4=@YON?+CQ^&Wm&Oqb6O>FUbo6y>9Yqcq;i(9%d6r_$zF#hH%n#MQjRb92CuIt zt0^I)Bl{4CcY}*j=jQ`9mFkHjiSxtvzznEi%c*;j)%5*5%$wH9vl1UZG6ZL~I$p9} zX8Ct{PIK1*_cwpRKvJV9e$bD;{qOax<^~$ zPc#vL9}KsPxW@-%hvp)D+4ued2%svNQ~lvXB&c-P3|M=E^`mBX2||gYXv0qBX&>e$ zvn#G9*hi3;WYnWns`srCIv-h)uffaOaJRLE3CoJLS)X5NJa2zS04-EElyPBAXnYD@ zE*M=1jZ!E_Q&N>6x5L$W67yhXWbV3l^%bgXqbgc4^yRi_QSLXp=mPIH5A9+`y}o6e za^$tff%O}TI7xuHu$L!?Z{jH}Q<0F#FJ&;&{L|nH$P6#NsL`zK5ZK<=MuFl4uvZ0cml=HmA*$yQ?-*z_!qq5b1R>nNEleSgY<>|ydXG@02(tjp{ME8)?H zA_y=+6n3nxDlRNUu?Q{dvg&N3+g>E&NaMbWux#|Z&Nr)WDYLRZKLbO0Mk4C`2+CsB z(kvd9sWTea!vIXS?=oL0@le#aSHAB_L?4`50lqpj3ile+J>xcc^|!^4y-XwuS1(Ko z;koBKNj4_igidN0IwoU3lYOkN?I)QPqi}k>Oql_IUDR{gL?)`Y?Eb9%I}WPDuhPM; z`TF<7ZCBy71u{Oai!V-i*q@HGscd8teH6m#ciH}Nj7ed}Qk_+mW-RwE=IxB=P5|1r z%bnSXqD4>GV;yG|R;ha@=?>$qqa)P@>eA7!&Ob7El@k;IaIV<696^=BT`y>><`{MQ zA`+vkO2B|ZsgE!-ji{OBdlMWe92Et}MlfVR<-K&W2iJJnC;Iy6AVFN?O_->?vM<*#6W%MTQR>ce^W zSQvHVtKXGm7{3PZasMh%{F}Q|#Hc$opxx=uqWv55ul$uszx0$c#i`q6d#rliJ0?CwE>y)=dNEM|C_B8laOH7VD`e;ATf>s!)iB*zF^VwB zoOM(!K9aiv3|CVqUb=}|rj&5^xcUu-1ZqBeU-#Gv<>JHaQ%EIFe0 z{D`ic4~w;PAf8i!N@DF1DKoYw9etx_Ii67I2p31&EkdF+PzLj>K?9s!xg1tqPFXyG z`ez7bDJC6hc|i~(<{~1Ot!ED3Q6cc(?zbhi-^l^ zAv400Y4ZgciNuC%Y8o6GPciJvRB0xR$59gzSNIdawc&u!xCn@CcaAoVmGJJ=$4xS z>M80zSW$4^g6D%UUI-4qHX3Vkw3c~M;^F{C8FPtr0F<;S-9)2-8i0GUqQ69#SdsI? zvX;B0msn^@zw#SXO1IR+tNf^)cQWA$6aN4vNitRiebttn8}9{yuYy@MUo+vD1Flm} zb;J(KC{=2N!lKnz_MwB1lG<>C@l28#YqHvW+S5lt9+ruBt}k!A{SZ!-{J zXH2bY-D0jOag!7{SO}N%c+@( z8@qAVTMJsuS!=;guH{ssfMx>L7RpKx&h2dkW#_7-e23L}`GRAi-t3cR5n$X1^l~(h z{1@JbpE3@9AJldD^W0u?LOrN)Lb-8fPV!oY)QwDVHYaCtA|tGNg!M`(cU!Rtp}o!0 z#U!t)2+LLL)*2Zsn$AvQczV!R>U_?oALiz@;f)+H(QaEfkz7&ok|Rd%Nia^0Ls?#n zIl}n&OyS{jsr&wq9plMNypSk;j5nwa0HQ>^mPwj0dHh}QIwF0uJT#i>WyxT z-cR8v>~9Hr*hHSH;G235I;cW8k;`s*A`k;A;!+rKsLNc>Ci5x2E=horWz0R5etoc|q?abr4L( zqy9C!XRbB1qpVZco5iiFN2o+NmYXFeZo`{pTWdm2O_$Ojr)Og8Lz&crj=>*LH7Rg; z554itwQ;8}MJb2nwGjBB9qbldAA(#%1zy7)v!x80Oe)p|GyevDX8gX#TDv31BxOKw z3?#X%;>R%8~PN^igC z$6wU87q4;lHa6^yFi#|eAgxQF@86$q-FR@JN}d=#ze7a1J8vl&2`Ji)S6{?_y( z(i3+^ou3z-H*lO$Za~g|(;1ax6(r&LSp2zXL_kjqh_LqIb$_6(GUGnq4YbE_eVd;n z!yGvYj~NyBbOEE#o<#tVAYx!GP ziIcH#IMR6WJj{h|pPAs?t5{?|bBOHcO3uk-H1SoG!A~@MC@}{A`n&1V9fSaDd|)Ss zg&zNd6bMh!$HG>io(IDa=eoYO_O7d7>)F`gCZTUMtGPe<2%F`)2{hW(+^2hl)sf;; z=9gLH`1!i=eFtkJSVBC+&T7^tvNiU5USGJbVl#9(%j9#xWnfuMG_Qa*8jYQ;r_ZaB zPb$43C~dX%Uw883dBqB_Ng5;|5MCwJ%tFovfx5-0O^1?~-EIE!tuQhqqOjS~WaBz5 zM_9WD_jctpQNAz^OPXJfzt3n3twh`skeKbnFY~msVlJJT))%g01|IDuHR8K=HkWPk zZEtixE5x}=dY5T5ZSY}Smpm)vxx0Cnoh-Ymh-b-MEF#9gx4p+EHbY6t+HtTot4do~!&+sy6IgYeQ00{L zNb%};XE%#k>SCShv0YQr^$r0M~#24w-c`Z2?Mw#vDg?XoL#F7RhF|U#QULZ&ZSs5J;`zStX zUHs4g4N|u_2L5~adrr}D0s;A-3X=Yxf8#$owr#D<>|OseWv#~t2BocNk5Y zfIRLm6(NOOoK6HTKeamC3PO)*CQMy_(nba?z!D>CaesIPqE9~tE+D}5Ax)g$h_{8M}!_NtatmZgw5^fmdfX~m#Oh}ia_GG?pUrX;2 zYuD_dw=C)wsvmuoC1mwu7~w~Q>ed($*ZIK-h%IK@-Du6{+Hl+^&`WTyVoRUekJ_&| zitqDa283L^#^4H3Bq1FWSrEm8?f&KLV8{QJW_Hz()I0p6!z+%F@Gc4p%n?zss0?DR zH0qhOUFgc>;`wdZkMI;E&Lv(J>1}xM$Ezmb04wbEtK0xE@+3GzBxqs(FR+V$A4?H( zkM2I%;4^Vo5i8PSsIL7@>u1!d>%C1MPymFB#YG|#D{{zT$ieNt(BP91q^$uoC2IF$ zSQh>nD)(k`>pJeoYsRap(5F`S0oJd5BZK3MRqR`Xj@8RfV9>{B491>(?O#5Pe?dh5 zOtT&C#dgd?dy1kwv^IARGhegQid5F#n)J>iH??P1fq4!tS)5JWYkWTnlvjj$jzANFmMhoQkF=8j( z=M^)ezAGK@x=BC3bwOgNF%><;qZeX7_?6>$;-?hhKK#nbc*d}|<2#Vg9LyB_{WP;q z{EEpU&pngRM%^@wA3%*I%yAhWnKboIa+kXVe9?hKlL$#?U7^@C(;x2#=fd?r7=%G9zl@XF^EoG?EbXlLXZn* zCuEu9`yndNK*qE??+OFdgvn25PY`dKj!87P4v{psA6H}=7tZP+ALGkEIwW$7CtEso zvHAm?`CX1p^>Pa*Rl&H$?DHY06%UODw;Jb}F2NdwGds76CnfYa&shWas$@e{Yox)8 zC^6Z-p;P;&3&pbnE*i5nTC8neEW>9C58#?5s$zC>elvFLpY;G;qp{SM zzPKejz74)knv9rn%u-RYz|Iz`f;gu{VZzdL$vxyn_+@y__)2OjkkpKGDyo@1Bchm5 zQIfh*;6j^>=7Q_;j{7`NUH2-3y~wJa&>ibb)TE>6774?ndY2lrhEzQ^8reV$v+qKSrsV8N<27TDzIVPH{D5BMnsY zgk0OpQOM7eKPX~ihmcE;>f7*M)4P7Zub9&Abh8TAmF#1mdj^(`%x#W5fG3TYgSx&D zw;!Z;w8UaUMwprv`!!{VVCN3TZ&VAwuc9lK8W%rTO@q(>E;=4yn7I&jEV+-N$*fq9 zk4eJjt&rWGAPFwhUrO8pwDs=TlDx%N)AyurW?E|}{4@;y{j(;@W{X4t5K~WW0c`Zu zf!ZBh^1f;vKOA8}8f7SJ(Ic{gkz9T);c35I>Wo5D3~fhtu#QWc z_HC*iJI;u2XG&E@yxSKXz?`^qgcPI-tQ?njm?e2O%#f;8tV91f4zsdE+N}IpEirdO zBf4$_Qz2t#^C-dAz}n4HX>0p!bk-wK5PRLMT~d)pDRfeMxgL{~RAvpQ=us%Ka{d%i zY*d92&k+eBp3E5P545Xxv7L17&`MLTG!~qzr$%wG6E2@HQwwdmKC3dX&ieDHEe#Eg zu^mc=H2)>sxXq2U(Z+FNwejA`J1b856-)I-5g0HF^ZN6dUC z+*q;O&Aw%P7(;mfiRA5gk|t=hl9j+1*sQE5W^FxBkrO62OO~)gwWsufsW6argsTnHfJud&Mp! z!?vJSS8EG5D*m4fQaA@RSvMIxMssD2zcFNlr+Qgv?_kavWb^vY>JX*5rF1M-ST z5-*0At)MP0)Y9qie&Gp}XxUu)j2`)k9Op8~aCg1&SiLk&gPOx>XgXe#L6KS;Ry;(H zXZ~qBhKc-QuE-uvGvkY`Wpkvs7#I0pX#Y-}TLRnVdOWrJ1cW_|4OVW@* zaD*f?=&%qCpNK$5)`SIAeweI@m9GFgbW)t9De69ENqlY0N9Dtx<*>3qeQ%T(0aIT$ z2s>LA5t}XL<&JrY*v71}&Q$Z?d}k2=c7n;H=GCFr;GzV`% z-ly$N`XBR^$54{JLyUSmdO%iiW2ymc}*BP81l@o1D7W;0dox@%i{#}oXs zga;ct8`&s=apbDc0>y87L!&xOnM*Aco3cJM&3w6w*k;#%h;a)U8*b~t6HUjVtuZ4lz z0V~n9EM8#+6XGbW+EX0@BXGe#U~?dY6Se~nfJ1U-lu;7N9w`he_~h-jNYX_os98ys zMrVl_~hu|xil$Ro9Ns=^|mkW{Ofa8 zp@oeL&Enz=o@6BuSr3M3c6(6DbWDD`IkLhGB~!-mSGu1192@Ztb$OHK^I^M|-MF!C zmlx^1%eNii)_>u^xa>+3Pu-jtaRa-2J#PkFDV%?bufJMBt9Dr#J7fK1?5x;s)4c57 zD|4k>EJ4xEZ;*hJ)GqC?r1Vx-c&N-CqkD5ax!oY~-p|UvGjpokgioL>({gTzeW@fb zNHf(?cqu1Cak#ocj{`g&u-vJ|b``RS+SNd_bTo8Yf z;3vty`nagJb7UTl!0QIMLDrh4A6x(dDaF*yW)&IMkzC~7Z%3)d9Vz;ok;BTNTZ|sq z?TD**4|36X4?4gilG%gN^#^<~yoM0jQ``r@+qJQ$K!BbSJtW?Ph-U&L6Xy}dgG%QA z$JjeXXBx#>-c_+vv6G5zyJFk6^TuYyM#Z*m+qP}vjh#%UduFY#`=aN&dTyS(v(`EL zkNw;E9TPnY!o?lhx&o>-Lj0C_3iXV*nd#=%0M$_@?hO*2?VE9Gc=yDPH1~TmP%F$& zY-=_<7+KbX#%IdD8C>ZMh|^F_q%p%A<P0U;pND(n- zpQ;h1=PJJlyIQ~T8(|@zm}ABsp_hf{;P{}PrTFZ*LLqzx&V)qcj zYZCZ`_QM!>FYIi_1D#v);0~O0C-)e_>%%8G2@-y4bnyGOm`CjpgLmjXAEB#nlFDwc z;p}#-r%5{D`XQgtRWc++*JK?=Fb@U67A3oBm&_FX!87m^0WD(d-UHP@W27KRcJltWHzPYqqBff~TXTEO zK&4Ar!REUb15AG`@!@f{fG>1xAjfU%xxQrpuroBQwm)+!$Ew( z@hzp-a%^|PvE!be$b2qI$b4=v2PKV_qa%lk95yFTj8IC3UTsCnidON#d|co=^@~nm zI9EE-Zh=q~k<4Tw-02X-V08zF^GgL`wh^*#R0Dsu&w$NH?DRMW+zZZ&mQdHo(Y5RQ zGq2T-RE4E4!@;;4+a+5En!XB6=3Rr5X%hro0gyH8_w+xQMvl=o`GpO`xG27&ML!r$ z=uZScQlUw7y0|Zb2$6quU&bT+<7#j(7%xKi(r;YhPRUn(~SyY@>g3kuvzbVu|?dHZM)X#p}|T`|{Kse^T` zhpVe!dLV4Fb_iACM&|{;a_}BZ8w!pGUykA6&Di|_(%9^vJ0N1^-_B zbpt=5hJnXpS}ei%xzkISAK-R7_&w%*qQ~>57(aRzdBRKSwAWvlD65GmfIGN`DM%Pz z$_xb{Kcc}O8FO;m9sI8CMZjzn8-aC7;{yrX zb-?K@;v?ci+s(+5Q)+2$E*OthmJJ$e#S!ino|ICAB-Q|e4iIUM0UH6B^En`=*_ivp zrK^slfV@-el^mkbVRdK==>V3oR1k&E!)%FhGsS=wto5bKjk=v)nv5TbsIU@QLa^xL zp!cio>L&+$4Sc~%YUgG|r7I-Y-!hB{K!O^sZ^SR{2ku)0SXVez6u3a= zTYA02!p`BmkbFZJNcxv*Nw_EAio?U}?+V-4qJ(ZL@r@2QGu=35rVuRQ0c~C}$tQ5S zm(0$9q+C2H96!O86{%&@`26{3V#+DXA$li373A$ylWwqThZGb+?9})$T|*y6+AyPr_?4&7)P2tj@5wxz-zgm>p;2@9%;^;u(c7~ zbhkt-mvWwpLtKy)ZkOFBq*RDOxg1aTA&gH*k-JjgFeLE}Q(^g9frX=xWYtI{O+m>5www|@J zLYI}o==oeg_Ph%*ay#0Kf1Fl`e3zM~spG~+fyVAt{{H||ysmoyZ#s_bnc?$&g=WY{ zU9GFo>gHjA+RMq?^-mV{qf~5-f;7xZB(fS?$i=(8*^)*qiQ5-BM=41Y8;~`!%73`I zZ+6zJL-VC(q7ai+FgxN=Y&zh(Nl6qMkGWWoIJ(U$uwlclwrdGc# zOM0n?gN4M@jh%Z(Y+)~y?BN6Cf60ojU9B`(WE3jkFVtJBOp;ScD{X=@v+Hbve7M-|hB5xDXuQ;l}C64Xal( zc+q?;W)xNVKRF&Gt$!0^|JtWC`nwQtZoZH(~%~Um8RL- zdgD}IP2#`T_69(ZV``VJlB$@NRfwy%QQW~{WFJVuEaV}@ze}2Zul3>N@cM^5w+U)- zI}c=ndyn&gyw%$&4-YCW^2f1#8+N6wu^3v7fL30+Px%3YXi=4(UJ7#|y;!2RL_=cC zRRLV=14cv0yMQ9G!=8=t0=y`%sNt#%vqBq*1M6xdc-Vv`)4)ctV+yS-ZKQMGD{q{B zrrxA2`C_=f3{K$OXcs<5Re8Edt7`>3JAMqFF+@wgYZCtB$ZOS^7cg>*nKs0X9>H17 zUK;~)HWf(KG`5;{pv!g(sIBIez2*uAqQ=9hJ33I&Nwmz#LdGz<)+t>59;~1s-Ol&6*q} zUK_TzStfok&mj28^7z9ZTL(AY1Q_$zzR_*lAHcN{Uq>h0Q7N1s7l_;p_?youubVi# z=GR}jH}#m^?rRlrpwk)hltS8W#9t8Kem!ebl4xzUm>fgQOp#Bc*{}97_W!*-^TLzV z*uHJ}Ucw_;_I^$4?<}1g{doIyPou!x(V{qQpCfK-TQ5&2{XHS|4|8p8E{7vub)IX> zZTa9|ug1Z7XOIqxR4daj4=TQ8LB3U`rK_z|E2mT+&XTK9jUjP7vYO~=it8o&;HSiW z10CIYa$ZubC5qmK^s_x3x+0s+$7OYF-0s8H?rJD1n~9F~bY*G_Z*ouytc*+~&ch02 z?(fOVqfwi4ZKlL+i^}3DV#k8FTC#!sT)zALL4AjKUq#fgrB=RWxdTF9(o~IEAr9g( zwk3u=MvM=g$Vg_T;5R)0Q6A!WXzOZRZ}9YQn-MhKzTVjZI42KrjjTpxScnA|joFF4 zUIR|Ix0LM>G&vUi`J>Mf#H0ijnu0n0wk6q7&?+3FLp3s6oAZT{`Oi{J67nw&`!$kr zr|Ej1ycvF@$Y=t}SP3f@ZXbD-5<`v8%D}2jF*fRt_ArYr1*=b^EGF1E49YU$_0i49 znl{nX(TZC-hrB8sdq0cABe$Ps@4kqy?rllNLtV>)fcm8B?%V1Vp6db4cBy08Xly^y z?zxA318-Q{?qq-=UddhCVk+_Ss8^$lPBYW6Sc(pQ?DQZ?Yx>?JqU_K?<7!r~UzPXz z%+xX+)4(tL1VV_g-ZmFTf=?a8P`|vMUxn|OJuyCc-Gr|WrHK6gdCi29Ey^_EaI+Co z!6ycxKYY<|i}l2Xo&#;5qWHmmiF}N9mfxQVd@Od3pTYYIh-aH3+Y|n+ByrGQk)HXS zD>9>P9k?|dMbqoFN2*T6xp^@YRPmf2B}DbKL0OuV#F?ndA-bj^$^-19OJ=d_99P0O zR6lQoGamxt>oPvmb{aQZt zniX=V;{KCP`C6n!z0->6G4cV*&ClO?V)lxh47L^0km?o>xJ-c#VUJkU3!b^kCO&0l}x7KjA#Gz_4lj ziPS*^IFMfZH8J7N^)V|#s5r2S`Y7e$i~AH;ew6RBY>59NjNqvlhWMevB;i%^4et2s zPc|1S!vZ6B%+WUuAZ1D1^30jWKWRsNZ4~%I5Cj1Okw+Yy$$?;?`C;`VQa)9F=M)A| zALYV_)GIG~NFmsU2;ru0U0}gV8TnDsg)j;+#31|3WZ(SPcq5NrA!l|Zzx*+Ns_!Qz zR1E zuGAJGjMfb{bTRo~e@pLZ=9%pIqzHew2+f?XA;gy=ddu!kGrguu`p&0dzT)tO&&F(n z&aWE`>85B%=rOPBFX?h5Nq$pkLRLY<4To!QHH?&EIN?Nn9oKWxA^;3Ax}P5m1b(U2 zlt;FCg$OlR9zx8gig07UW!sW|>qz#|i1#v?lhUq>el#gn<1ILl@pgk_^l8|kWWYc5 zy4yj~{q^k=0WxaCZTFC#1dP{!(GB<7fk*$Pws_Gl1mlK=F^}|dgCJ9Xhh)la4CuCbZS;`=f0{@ zR_qXUdk;L-ME(NNaztNCV_sKj9;r&tgI|UI>{^SGclw1MzhZ^Z>VY@iDf>%Vv#+qw zAHNX_P;;T6z6C)pOL?LtPt>SWp-R03alU3yh~t%*U#I$ZR`JM+@EX5yV)m@B%tL`*3M@OIXEeLXL&Sq}au4XK5#dlQA?VI@0%MkpCA4z;u=h zr%SNgIinu{Z=kZrG&x}%AOo1ev|fY!xB06k;lc?&l?y=?&%12@h%K~9pnj2Xh>B}$ zX__rGey>SAT&m4ISd0BS5XR#wkWW|v{DP>n1KzX;uO>xPwa3PAJZAK4Q>190yr9uF zK6pzGy9Kg}XucKYQ6c6-*)eti_=^WFrl(q5N$;=NE+P=@^gJGj!~>t*Uk_yE5#xFT zc?`f{1nVAlcm|CQNUp{H3?1&LK9JQV9R_0C1b4?BbqR3Yv-2Qs4M^==yTQK;oj$@y zrQ=3*p-&IkQvUBxU%iCd+s>*RLMtvb8fLF!X@LMS=jt7By@3wD$bNblwnuCMZveKm zfO^u*$h=YKqCrOxP;njb8;B?Gh)+a$ff^tOMcRTThZn_ zt=88_N7mqAz5684gV6f80zPXU;TX@s`Ku}5(hFxD{B2hdOqWu%IpUYgY7Yi;O+K6F z4ziYBMRYPu@>E4|*S!~{lUuUa$=g6aq5+8)2+FRKgU}b5>3c}Wf!WNDuOKKd@P;tI zJ9BPVB$yTm(v82^8xm`F1n7Nya6N=H{${iCOj!WNDSPSZ-9xt^2jA&crYywdJ=YaW zq)#Z_Qe!Vr>7jCTIm{2;x)3Iu-F%D8n`0Ksb(o(0M6 z$YmUNPPa-M&87!uGjdFo+kvX5i0?2PjT)bcns%b@p4wGV`HMHa7#(_XHL0v`GRNdZ zVtA`k4y1)VW2qjr`}@`bC1j5}E|`)%#l)aN4Q5C`3@-FJMfire!og`n!c-58+V42K zl;oc4-6ym=Wb`{!X0L%rLefDEo|dVl&6fq;KeX+)z@7Hfw(C{qFTVD(-F)VXHD@-& zs_a~qB+Co!>LciDKb$pvGn|c**UbhtH%IObhtN)d0M3SFwQiGRmk0m%_@HTh3Bq>< zp_#ye@gf8ZuDpmLtOJeF8jjH#7p_lYprKSgY(CVYKGb5kmnZ`iXCy?#?kA%aA+5j2 z0ewu!IpsuWqW?z2ae)Q*#Cp*3K76=)yY*ywpz1~#J90cmuY?=Qmh`zFmL>=|X=it! z0GHPdDQ^BgEpfe@XZhqhH?(qbl39n_`8xDZ#oD#aoO#sLQU|BD>6i;XbVwT2ErE)L ziMLEZjc2f^3_soCW3P_I(WfxulR%3nc@P7@P7ZRT6MaJtt7_->yEVW)7~Dg? z3{j1+$JDgGLr4qEZaANRpwFWI_7>0vN~w1#I>I*=7ljvDEsGMDFsI(hc5U8k)3!-GeZ&+}Trh4{ znQV}2NGk166_|SYYtd|405etNwlfuN0cFw3Cxq*+JQoPg2(d=wh`uL3T7P-)i`rPw z^IUPjVysLv_xj}am{%`B$Wi2wa}s^K%1-JcS-p6|evT-g8V5_7FT(d_HU!%iL2rZ1 zTf9v4>)3&8$&TF-bEFQ`Vz~;zGMYecft$@*(+{>&LUdtt#qc|0^_}CQ>xQ`Q^M(g4 zx5DK@gsF<;!l!f2z!79dg3pKg0Z!-p2|cH2$(K^KQ8?E!eZdp<3Df@mO*KZv?>AvN zqk@XH!!K@|S3W(q#8^(2?3O3uoJLx4e-4!FD99%(H>F%u_nBljbZSJf#jozyx_^?@ z8=mN}vVG1f=q{csh1V9I`OU(B0!$zBjUbiq%D!7 zNP0$;IASj8{pu@y=3IzRW844w9i;aU?=>xN-F8RQ@VXLYmyS?BW(IdSk?8nN3XSvP zuf@BTjp3e%d{DO{!l@=ysd*n{^BlsFMxAd*1%6GTvY^ckr)GvY<6|OKPJP9)TkLjh zE=q^Ec{=I4yx>=tLG6mlT-n?||M+s}=M_fh;{ETwIKEyDv$g9#O<-EC45#4b3ERLH z#hUz81G2KXf=D+N+RmmCD|*S0VPYG$e)EVY6K}>$?%z7N=fh6utMee+lWjBacSW7KkoRO5AX4u+WUd>e^L zcbow)%6rL?_+5f7ggDDNoeZ=%%i?{`PWajxJf_;!akUK`Eo(z2B^!Z>y65W9=tD3R z$cgT8!OV3PkjuE|Bo2D{b9%hPOt+D&X+zlYW);d)>KTcWF%MjcTfeo!T$orKDc9}{?k>|8^C-^O8b@q5tEvCo4gBGqs z4+vdW`X%07_-`2#Vvl`NLmSd!fEH7;IZV zw`&7^8f&n0QNULN)cAtE>ojV)h1lnN_#6P}cH*Pazt&&Qte3WBJ3q1t9pk8T7T|80+;`IFq8L?tRTeLQ9uq8eLEFU^rr`4D=gBN%F|9%A>%a*%K!vC- zCyKwbeRWd&$LzQ==u}bRk;GQT%dNw~OqtyRV8eb1Ew0^0{JLzX8L^15xpVp?#Q+ zYpK$ck$tkx6Eoxxwy&_WRNdqT*XPlgY22{}o`*5x6cv5B1}R49brm%>Sc-QN+f`!QIZu#8|}5$;9S= z$HF`Qr;#yJ?L`P@8R;{tDsjLN6$y7g_783x6jJQ|N;DqsaPSXR>QEe{lJg=rB-oJ( zm&MIQz}%8db-`2Omg`)*jMjP-BUx$u79efQH67nqT+7w85h^!8(069N`OdV9{cbYd zy&U7S-V3}(=h+OinGj`&W#Lzo0hx5aHPn-S)lc{lQHfFWKls(~{egqbT7rZye&9at zEkCRK&sT5Z4KfCCIt7?^R*88!C}9w{hW^AbT^Z4MwgP*W@BO@@jH&IG(!;?oV%P*aavBF2HRTt^3vkc(^R>n$O|2ldmh(V2(FJ&&a^_1Gw3Lgkh~%yr$p?uhupPeZvZ^ByLpi!+HtiguHx!(_E_UgS-tg4T>;cc zJYr`w#vE#>j+7g59`3(?!v>e>xQPW|ikk>2?``IE9tfm+MMd!mzK7F5`2~XQe3(Ub5WmxUR$5a^Qszb07JJUd-awP`-VS3~D zIHNbTB+_@yp#aS4-5JXtg?vYCguCpl_vg)gepA?EVlw?~Ou?$?X5*G=5O6a2`r*bw z3))+{I}-}aN@^z=G~J&z+uGC!Gn|Tv89fhHW6cyY1({-cnB9ZdU^dR1Y9f1?QR>_+uTE%(k;lF;W@~{Q+i&Rro#)1 z^d6NyjtHG?1)7&cyj_9xjflRPHSZ+0lRTT%O_Fii=O3Nk+|!!G1?Y}?HZ>!N$|NLo z5>4FHp4_yJ3f2-N9NJ`#HC^9CCVe!ADKiAt=_BmPWX&^+`1pk}yrwB|yb%oR;dMZ* zF>mJY(}LDK4Qd^^ay8exmlTX+!(*2S9t78YHTWlo_B=u8;pD!bs>wUQ0_4kzHYPL)167V00qPgBcVv zgc+q{j3b6(a7`Mf-H`uP`gSs!@;2(vC^s`NG);?O>WY=u3|AX6q#HO=FM1n^)Qn!K zEu4i$+|u5FBZXX;@@nq#BVUB>2Ru|{ek$A@mnbYpWvk}=+D2pln&yT|tZ z-h)I($~>{~^g^0M+2kE>NvhQ3Q8zJ!eCB`QYd~@Jq{#B5%rbb5`S^jbhuK+*isy+> z?{Vz0CCl}J!0btp51N31D6wY$-Su`2s?1x8?H^-^ZfV6LBKaK0i*#)c6S1x|w(ME0 z&M#3K6Q1cspQ1Uvcw!2X@Jr@Cp~U#mBY~Y!y3`$T{?`+4?gddfoVQND`+6+C(6lVJ z4?l}Def3Z;8u0}ksQLbh*6Feo;i~sXY#P}n&vAZpPir7L%q_j2E_H)vb`qC9&ymQd zN_d}67OE8~k0E`uP}RX4QZzI}f#?CPfl0I;@?}5PV-Ac-m@dS<=ERy(x)HVLEO@jY zsqTR*&noh1KMs`F@WO>eY}}*&p6f`y zaGc^VxW8JA2)LRS+hLn!tft?fcRY0eSN+j7NPL#?9hU_D4QFQiAN9w7+L8VbB1zuC z*2u)s(bnNVB}k&8j+~OfFJ2`}+t!>vXx+ekL=t~S-TeqeReUAp^o$=(B=cyF3gUP6BDbeoSeKoAV8QHlnt9bS(v^}uqWgVxf)?} z^orGsyT3J!bI!QT+*{03fi!Eehhy-9Rb38E2Jr1Iqf4(-q-(`}VoS4bPg&%->{#|@ z&LQ&KKv1#?=cxV48{O=PtTQbEO`Yn*O@$!J562pOM-(XfFUmd8kepx|kw*2dlV6rx zcF^ z;@tsV4VK#s&NRC4r5W%Bf?0gTW^a)}8rqOl=MYC_Z>V?bv7t#T&H^@LT`Gs_@Bd9_ zzPp;Tkba-BImG|#od28ij6})Fz{&alN=+3lrTIUopMpa1Nxu`*|859a-zb9JER79n zf>kmYC8S1o1=jsxux6FO`Vi={%2W^&8#en2@EyF#AcZN}r#PK>dE`F6Xmw_PxxM@# z|B-CZ{u6IGZiLWwC&BMr!pR_bup;b=1navyIwef7-x20BghK{_2}=fnWt)a+NRx(X zs?EUI=QiGx2Vo@9mV54oz2|Zg*!U-)k)#j^n}q`Ae_|{V&TziyqJ0XnIs;p$6|Iff zlrc=?xeW`GMQyB}kY0tF?@8!@t@*eR(RWwIM$6K$+P96?HMfC+wtE%s3{M_Wx5w{` z9R9FZFF(>#Ii|n8ru56_#HIy}9QA2nJ`JkR+i0C|9})2M^Rf)M8Fl>jy@0Q^vRBC1 z#--;W-@q!(%OmM~qcdE7<5V=CN(?>&yXY+7NcGR9wW*%${cS2u3|mMyLh7`i*z_!SWmq2sD*GwC%4;=1)u3lVL(|g+1^i^ z+$OhjRa8L3ClX$`s((bS+wgMa*D0d0KKkW*$*e3rSGDvWu5Q@M#v)sd^VD&L?jnEmReK90e>{}zb_FM z3P7C-fp5sr^vr7aZtRyv+)@_C)NV)J{MVm2V(mYXK7Sc~ik@iqsz2*Cf16R^#gCc6 zkZBa>33e$Gzjr+U=-jXz*y{6&3M7)y`9~&FAu5uF#)+<0Ao4FEcf?*qQ$}PB)k5y_ z#hGFWi!)0+l^|^R%t>#|15d`KwKm$c9k)7vkPgQgw|U$&Q}^E?YAF|#xNDye{N>_w zYV<6Np9RZ4vd77}9kyCYX?e;pE6qIn9@6a!Srk4iuZ&M*@@UKrm26q-+-9NkwDz*= zf4yLtUv_gOzj1Vg-#9wX|M`M7ad5IQwJ+h2)a+1D0D+OHF7V72lPK61F9?5DbpuiB?mXSZ#9-C%q0HzM~4c^3Uq zQY=Nm&)`lZ2EDKr_WJEdE{Gb4_;p*m+k zAZ=i8-DK(9kVlg{|FD6tW+V?yH~$WUtc$OB@wsT(*Fg9~0GlO8qVx36)1le>(io+hQ0F*~OsOfrcMx#U~FW zNu2HhA|w>~Hu4xe?Qxa?bB|%kQ}8#>*%WdkEr9dL&A?#jo-7J0of*%9-D-s#ZaQxN z)|g{N1McQV#q$WxY-t+ncw*q2OcwpUgEf&J`5RqJsfMZQXw1JSn$;bejz!GZZd z+D%uJ4Cu&l4&0JL_|T6*m>&f_DCd&7MQs`oJW6es#Ya<<8V zOrvleL9j~k3Z)MVs;@aw4$M(tD4|)CbdZ6Qp^7092Sf_3s+{W6 ztRs#D%*ChSLaUle%j7ZCVq$Ec%nG9|#y?XrwNF{~hN-gMuvpCF9JP%NP1Jd=`}s?( zCdn%+_RXX5`KqETNqVRDr0i+9NWE-}GA#wOsP=cwVf3DIS|X+woalG#m;w0vTxIb= z$dE}AI&pS0M#x73inzCOz$98mg|dL*+~Ha7ZD_h}MLl6+eb2IAc@4tAC%bagOsjUZ zuD;`k%2tD3EDmqyK&H%MiSHm-BmkA@$e$^_dyK}v`tOr4%qFidQe(x!n6i_arK3!Yz;;BIc zaChC_S}f1+ID(@$lJAH2k*Yl9@lx8_jLtqr`uxklwr^k!iSjoe;$kPJT6*#LE&k4a z@p|93I4#C5x>}cjbJa5dS!@nh~k7e|AF*)ABV&z07>z8ce_s9P^f7d7k^@5!S$c5f(Zln;d>j;gl^dQ1#)}C}CgWO3Fy4t_$AiO{xaoXOiUu z*{_0P;gJWl*#`ctr=JZjm7zz3(fRHDH&Zoh4a{E99(wOoeIgCgl+5;^T={W6n``$M zORlr8PEyV|PqXFr_1|ciV7od!nL?Q=x1OMF2Pd zhU-K3N5^~0PfpIi_DxFf)3-DT1_)vcqxjT=+MF8EKA!GXqQ;Ekfe=J|QQj9pp`ID$ z>+Vy8nr!*IY%VZ__(UBY7U*PYi1eG8m_<@3YIKYTGcrz4UgC=ODCamUPB0e{;@CDa z?6S70Tif2CI74rvLn_uZhV#n4;*FbY7gi!pG7r@AY6lr-{{}vh!_tdinzmJ$khOTO(gJBP2xen5WOX7&l)e#JDADH0+R>A+{*GNQL74ge3)J zE&=T5e=YmCCgR&9MTgxYk92V}@375H+ zON~;LOB6g`=wCB*1rkHH0mV@56BCZc_|O50ApiA&Ce2uuYy5to_0axbnHt~9 z`2Uta1`duU|EKmTRMS$!Sw{OrfPxs^xlr%uB^_75TAQ%zNtI&Ma3gHoh(_^2dhgKH=-o zNEuSCK@w!Y++TWkc~5Pb5p2CIkEQ>x8Rqu6=uZ{B2s#>u%i|evi;W63N(u=C*^Gh6 z0QBL;MHZl9`jl|=2aMXK?TVqQ`&gU0FQj?(|v!RP% zdVKCp0WT3iD?KrY)D!evek9LE^6uS+*kyt#|KP%W%X6x}2gMJl0nmlTYQs9yb1?QL z!zVXF)NxnPh%p7H`#2aW5mLNLmU?_v)O>Vy=b%9o@mmr`0m;N?1C`Lho>EAaP7}6u z>5oM7zg=6BEMNUHX$);RDooU?6rDpRM10LbYD}7ojzo(da50jch4vUEp%sfcSD0+I zA*WzOR5o+g=8OB+q-4!QZ>QxvgfjQNNg>j7qg)u?V#+y~jtZ20o-Q$CpuF(36 zkn3`!1wS)hMDg5gV<3O8A|(bSU6IuN*n7f6gK8#W>ZmaCfgajPIljp_K`V(Le1L&c zM$%|0H_{@SL(|DdSgM`1a%UXmvv;sWx*k@mm-IC{1&f+0#Hs3KX)gTgP+SGKM*!{3 zKHZ;O*$Z5*%ne3Q<%T6o8CVgH0n7`p-X-XZzwy@2=Q`wC*zFZJk=;H$EpQeP-0U{vvS5%IxTq)m6E{=3Z_7 z+%O~HHy}_`?wI0hE35j+);U%*PUSOJL|9hzbyS5 zG8}GfQ!2l_0Hu`1N?yY|(ljY{;+fyx&vh;v`&HFk&gLKNRwYvD&gp(e=X-$n6sILw z?U4=N$^bB1-)-1`6!Lpp%BHgFrkC>=)g7;sFiDl52L zFHDvVp==%&jO`9&$VDUC)mh1 zCGa|>yq)~IF3`I!1|`T3@QICnMJ1Kam;vWHaBP9aumi)eXQ#`}R>kZYZ-G=}5dRDT zvRw_fbA=_A<`;Lk`g4Vq}JfYBAD1?gw&2LNf+S zAoT|9u@nuk$cEQ*kfPgZX7mf~f#9QK*o*Q6VX@rK3q5V{1}=+xE?95h^%;H*sL_Wb z-g|tqef-}kvh>rwbqU`IbwS`iehB@~HTr)rnf`+!OCs-RC1v6+;^<^xXl>zW4)}&O z$=Dj3{AWkBQ0ZE3ULKV<#@R|OJQ6xxXh1KA8Vc>F0=r!}^Di>}aFU4ZHU*7bPnjhI zp*;dpVx;_8;41%^o1Vr*sJZkK>C^q=#@ke<>-FdJ%OUq)aGD`P1I-}6Hzp<~Q)Lq1 zpA-#nP^y3RM251xu|4kKlzxb41>kfeZUf)6k#)FJ8DHN?KAKlQ6??pH)n<3#*gB!8 z*5QT?O?%SyI$!@hax-W@UFU20kw}E5c;k;); z5^IP(8A(IeBkU7KWWu*|0mr1x zwN2gs>^sURTyE1M5TMa%q>Gct+m0>2c$fM0r$wYSqH4tbLE9i0okc(kpVnBo^~bI} zjuJo`RvIpXQlTJ_BiJ4dj`(1c2sLI6rM>Zv*c zX(`O3rAL?;?{EM%#<-W8FPS@!!==gM^eT9)NaOT+XnP={=~Owc2-|7Oxh9yc5#2ar ziywgZfiD1~P=|8TPXd35Un(~X(j#rr0(v!w&V3=Ohwj`neV+}=z9V{ddzYU`@Y4tE z1u4!x9@OE1(SW;!v9DUe2e2>J9+{4}GeG-3*BfK>a#ODDv~Q1KiFe(D0$hIg$V2(z z8y``;kM;gsiSldOe&?rKRpjwq4lL%qAURaW05q~L-M%U}!Z7u-J*iR4*iWMyOGw>- zZbyIk>iyp3aW^4^EsA{^gp(nD4t*jUM?v)b5mQuOryiD$MQA47<3QZ2)_G``&x@Vp z_RIl@7+H4 z&`W0|KgSN3^*{S+P}u8&#yYW=5YyH-0Cn=I!H%UAWU>0Qq9si^a zXMo}McOEBN13rZf{d4T--lvNiA*6|V3{?(FH((oMju?+MogdEds1W{}?0Eu-?s_Ag z0%b^Y)(DJvBc4X`axOj*?$|5=6sJKdhG=%gLNms(pY1>(#@)(@R56EG z3daH4ZVIWC(}-s(a=J|*C6R2n1cz~huq>kTlSvkRDOZ8QjI*ECj2Y0|M3Fv%qlpuv z@Y@nLG-$tKQ{^1CwPGJ?Fd+**&rM!ad-;^U8Y-L@m$gsA1tF++b`9rNWNVO0s18AQ z?Ie0JTL~AcVqfYHIkF>{#U}L%dXggC;kT2w0z%k8_TPa-Rm=<)Od zQ4Dt$P(ET(>4aese{Equif~Q!gp}H>-b*&fY_Nuedm`gZ4fVOdXwO^hcYLnir7Wex~&L)rX+Gx<=Ob!^FS43nM(eKW+F zc(y1jNo9CyZavwn7D#PtFEmOx;#H86okb~*%v%@xvE;+C^w1H+f_Dq@HI_PWQ4~#G z7aHj2r;+WRY%1?VzHlFS73FhpG+6D-v2Rd33y3i7SL{Uzn)Fu* zCMamsTHl4hvs=AtA`JI-8>56y)rg^N>eOorWquY*N`$dlcGQYSOB=y^ig=SG#-L`- zuT~rGd1)Cgy@%^S%F85P$T|c%81SPB9SU{9ESGuW)_nL`MCb_fym0a0*uaWPsHlaI zi|C|7;A31N?tm#1NU&kAAjo2n(aKFTj2x&q%z7VifMmT)YUh0B*(G4!#!6zztcwq` zYVO-3ENWR=#%4t1rb^;riZ!((h_Yodz_WF(mJ+Upj>#*CTG0rodGuOQOiClETW>_- zIag;(EVP7B3S=9ZyAo8fSySrP(Y^bv%jkk64E18&hH-lcIYXpS($-4h7tltl#i#R3 zc;PJ!9+|^f!NOH!%uEG={4tI!UunQpI}Nxm99E$Hm1RtL{B7>&c@*D^ZOuzai#K_| zpgEl?8cJg^!A)_h#2S+_tvYGMH+U~Y$DF$K-8Ewf?Ap8!^CUAZ5Wv7XWFuVz>6ldW zkpk}c!~qvf*gDaW4z$VZr;p-U?8(>5GEt7BY>!P{!<#$z&ArPwv3{cRvQ(WqPc;6k zRH5nhj|5bqet9n)teB6YZLAS%=W{~%XY-hTXM)m_YnVh63+6)69SiG9X=+XIBC@(# z$$@MNHl^wjeTBp?Y55rlhP?B_O?s=uLIRlylTkHJcw=f4n~Bbo78#G4WL#QbOS7&d z*iPsXQc%ic2-YzT<_{)vLdj|?^Kw^&f+X{+a#`gZOIH#^hH5ufq+g@Y)~JJL5<)z^ zYx=@bORx-ijtS(9!z#6JytNluJjO;Fdl?f;?{ko~(vrtIgt${G)w7gpxyiL$rYvDApxIX&AV`)yIQ7c*uoa9 zfiRx?9S9&MpM}K7%qwEpz33-d)1<&{v`U&^AdUAfh;Q=v23KJ>@_D z;Svz}A!ZmJka()w-#l^`BSzKofgk(8qAEkMQ5q!Z)D7W!`=TDmhX1C$Rd`%uLFNXX zVS1*UdlBp@iqvQdf87Ssq){1Rs!<(4HRkaA?J;1G63r!7sTR`?l1&V zupkZv5E=F4ezR#Oq!=nv8%2}-i4$_9`TDFvoVc0&9?=U_z!CQ!Bc6UWEro>VD^&Q* zk~tg}A_?Y~%&Cb`{z*~hh+VnG7R@2_tBznEF$y833B?q?ejaXkA)0p>Uiuv+f_1KL zOQI{A$ro(KFO6_>TOU6NF<$okBIt?dcAf@{8utH$2?M$zeP zPqw&S*ucix`#>R@Lq2Oh#S2sTnSL4-)e&IoT1Z5Pj6r>X>_~ao17|qkpXN^%)v2?T zO+<&Gjr828(U!wp8Py@AGtqZMC8|SPr#O7mfL!?gCk=-B;ANOVZkUORpf;6Nf5qxg zl>^6bHq_%91PjeZZ_OQ}_B@K@`+C)3SEE=E`yuYA4!!My2dsBDoC%-3L|w#aNW z$LQB$B0DsHrD5A6|B6q2p!clbJX59CFR=(g@t55z8 zW>d|&UVvw}i2yj~N28|9KruRs=_cTSF`n|kaS_2sTnSY^f*kEG#bc8Qq{$;p zk*_-9^!L_-N&f-(9g&daA89kOdt_oyO{Dq=D$Sm%h&6>K1DW;(V$i>732EfmP;kOK zYZ$i>Ln)RbJB1!ISI^Z~Rr*NvC_`sP$a@CJd#LJ@2efRP?a2_MZtUB&jE=oSFuv*d zH<2%ylfO{!2#a4Ma!1AvP((jfeX1hnI&Pfrzy~Roo@4Wz)Izeiv@Ayo@QED8WJ1gZLivdUZ{8Ocd10*gx`{yM_}zV zeQLw(2l`R3YM5*SWmifuX;%Q5xr5birWbbQOZsVRRE^J(E_rkW{7gCS?OAW ze8OM1CG&&bFHPxT3HdrF3ElF08pSMpw&KW!GX8FFwEbtsHA1Ylki3L1;8RuUSze_^ zS0RLNG)RJF0n24{x^vo0(Nc@?SmAXQmDV*CRn|E?rfP@#sjacDu+$Xhggz=8<){l@ zP8DcaZ3k9)a$wMRzo|1GZNuOQix+#w^yh2DsFR-~n<~K+cx$1ClHI5t_1GldGY=8@ zBlB?^v_bf!R5bacKQ?_C^GUN9>+NAJ@ET);43sYoEHvnuQG73azbP&}-5kwGdX?i1 z$o)54`Z3G~!^!R}H?i<_bdu<-&9Ed5N!UX~|1r+x$S3f%#6B8yOyVo5w}b?%0L!!; z(IMCgVh%>gRKpU+TgZu6nTZf|M1RbK4=GM#Tf&j5SvURG$E?uWLo}w5-rzB=*&p%bhMp=vnW@+mo!_iniB;WjA`;d}CzX;)b2AA2s zwaQKD!`@17o$8ZNwT@VFa-yl;7!BT6lV>qJJb{m4&75E>(6D9mGfBK4dCRco$*;2H z-*TciCD;;=5j_z{;D1fZI651NU3nPOF`6mHW&UDcMX(N7#F%;Zxsc35y0^Ajzzl4y zwb-qfr8lHy>Lw8#3t#rsURLX~NnB+fFCuB>x|j(`pBw2N5LiB3Qm-^Zviw+IC(9+b zOQ4O90+zb14{ zvd^c@3~$R3U4KIP%}m?Al$%+6{K<&B2;Xg5n#GNBoHwp6Y`M4m8&@o4ic~l!*E7&K? zLj37#dqmNo12ZO>rI?jbQ=#!rl0=j@QGLOy>qX>#C``>6EFN*CVod$k=CXxtt|r1+ z1Ui*Y5xzvz*^42l|JLnk;ZoSrH&#?2zWjR0)><(w3m573+5RFTVD=9LtVr5~(V|X) zDq?$DXn~jd=0{_RuRL|ZE|}oTZ_$=s5j^OWRT;v&h};yd&0fPjEcfb6GlXOII#yz_ zN$s|hmQFEj#hiAlrE_`QPhi#um+r+c%JsPZD~uLM`2|vO6_}d#rAiEPEDI|4Xs+GIv=XkaXj5CsBSrsA1ggXlzp=slmud;$4!_9(9#; z92B6=&P?s7>`oUV+Z5avD(QjoZ`vsV3MOf`6(($>PgsjhdWaNYfjF@aY3+B_1{TK zv1NilJ_njcS0RMmYe>uJ&YAN~aW%s8J7qxz?Wb6?d@4q*HL9Y`1!C zMCWZ{Q96g|G&HGY$?Qx1rtu2mGVpWO{vt4?!TrTMVx~V=w=VZ@fV9O54K^Y^^<% zTa(WZ<;NEmp5oU0(9@Q^(|z!(7g3aL>BpC*^DowSZ`|GaP5VLZ&6};;xaSYL9`Qdz z(9gcF0lWNQ0vI#-vb~9mbp1+}kP(Xm1Xm$7xCy#kevsp(C~g9B=fk)L^sXCj0mUtl zPS{-n8^E5W?!von<2NBesgb*bBFzz5vtdH+7;u}w!6;wCQo132XSpo3VE79U3KRvW za73m|>xNWtL75G|rh~o=*kXd5D8e|Gy%`2@K~^4hfWreJPlE8N2;d$7#_-{z5I!LO z$N%n9weqcu_E*hGBnn$Kj*?d2b3*KvwDc1?ngG&P)DWNLB;OeV|H>jSZXQV-1ryBn zJz=EAZbA%E$hvImYUtKa<=|5^9W78)6TdMs#;GEbRe|&e_**Pt4ouL7C;qQ*gM`pq z`B$wq)n{{pWVAqAh4WWA2Uk!`yK}lla+e_}!T7J1moH#0!=o?2E-)nGHU+#LMhsi< zRS+Y@@;d2HGKd?8137B?7MYt+B*b+S>t)DdYPUg;rwX~uI!qm2#yWs!ybXI2izL0) zj$Gz%(8NooSymFyl8SMe<*{a6ja-JEOhfczE*Se#K(=b0tq>bGX2mv8mNH#-0D>IS z03n=fh4gjEP}|V9T?L{8_>pDEoHSwEB2NoXxXfmue=fa1mf@IFICVKnRomdpqoo8p zjllY31%kZ;-DS|8o^(Dq*JC#!T2_R!Fj8bhsxiEEyng^E zm%&9l4YF}XoCWwP@Dyq~(_cCA)TMQS{Se(Lb{c{6;NsT-?@D+ri#!%+FD!_i)%8H; zl*lr_YAhY_R=~xxHF?NpjfgK2JUAtWoWNs>C0DNl6F-NXJzqb%Y7^#+&LE^>&DJY5 z|1lKCFD!%0%D}Z+z_c!>?m%B~7iJEe)t939Y+r`JbH&9%@dE7E5o&c2&jKxDh%4Y1 zyM%1qJ89AtFY$CbbsHjgoxKUR`$fdM2sYtuLDZfFxZ`;P1liK5ms^-8w874jjEpRd z#C8^-$Nq|ZO8w)MD?j$AV!6_uK-qy8<#hnzEY=@$$RF>B?gEtD^T0dnvFF$r%o0!2 zjSV%_LCP6Ybi&Hf&aD;Pcki=+M)d&fI~sB2ZbFzRVWo7zAG3r{$Xy5Rr(nGSGRT8E z>V_COs(K}{bbrH|V;4kuwDA29;MXeo+EHey=WYTYuyx*a9RxiC*{TY#=~%?j&YY3Y zMBS|dLvRq=h8C9f;6fEZg$vNP9l%lqaB1t&TIAwL+EwIx;TvGogi&e;|9PU?lrfGa z=jw>)J!xq`vIk;Z7u0hb@^Y4$-G|ZM!n{(%*pTp_lcz7k@CyMo6NCgCpj?9*;=m)} zKx#WcxBzrG5Y&ev*WtQt7?96pe}!9RrQx3u9m0Pk^f8)X3GIxKjIGwOr` zJu33az%9xroap7Iao`{u6mTLacq^C`Du`7nuLW_Ybc5920h=g0wsp!{K}=@~g&tyA zQSK8VHZw)pA_Khf4lNgBK6C*DJ4AM4Li9jf?Gf2Cl3LDTW(`ToiDZ#{kv)h*Lj)To<8`k|5T~WO4jaB<@?F~+655Bb=P+6l(q~htDDH!* zS_B02o~+)IUmvVp-mkd#O;}x!C*<5u=iAzw4(t&tZLJs%VIp?px9-;G^xfEg`S8bV zww{|^`&z(}%VrQq3lFeS+xkgCe?TxOdt+L(PD56psZ+jI3_JPqMip)G08uHsFOu352u{O zn4C!sQ_tH&4!&KHdF${S-N?5K9F=aGTnA&1HA&jCbu>xZF*k&p>|@J0<;b9518uE1 zxD0VLQImTV#D9~wfRQJTDp<=7RBCl87iqSM;7x`uMVMfhGQ4r*YH2dW{mu~NXofZ+ zn_YC3%agVs#?5g=7WLQ2L~KZNNF3Rm(8>%dS<3fJ6sDmlQC?AY!F90Ub8&Wyl-VpPXi z&KYfW6UR|yb4&igAIqF#nkSeo2B%zvz$itaYx`XzZN^7fIS38`{s3>sagQFmc4$T= zk20=7p5>u*z(eW5LAUHtH7W`*$_gQN`WhYx^34`C#=bY!q?J8iXJ?)~ZbOa|SE(R^ zp4@*EbLf6x6eU-I`3I~5m8-)+9%UEQVX$`Mb4bd+q8w1)9yZiTbcX@oo&f zF1KNWtXziHHJR%B1>wRmd1<{GZuzP};1C+g9-;7+M$_V|TY&#J{f z_GcIQ-#dBF%vm??4a0le*bgl+bj9$_)d=g3<@t zu110WghB%eOdTvbN}IwS&q74%c_z@(PC?u2P*`r{;1W|v=Y4+sF& z25JG`Fj5dmv_OwE36|T-bT`eQ@fT;C*&;p!b3HKwaAQYYuTN2Y2?Yt~1~*I8qBc@i ze+0IJE2W~mw|Vmj$5ppPUVkE|?Wc?A&RZAh96pM172mmX9y_9PyG%LbJ?STDy{~i7 z{ICeL30IYfg|)v3hKYlLOYVQm843yqa@e}Mncg2U> zB!T;^{|6SN{6l>GVCPDv=9bPbPM(ss4mST~c4*av^ick>K-SY-Xf86RVL}+f zfx(S~;)sE)3-pVPGBsf`A*!7V`?cYxk*azTCB(T1WU-vvZI+SXT4tBXZX#pBg|W!0 zZ@Ih@{&HH{vD*&z*462dWy5zM zjQZ8(fPbAn6Rslx7;@SZCkb3~dJPC-rb{_2hQV_w1To(^8{-5&)r~Oj4}I$($d0zF z85M4N%Lt0^ZulKP9-HrQKTb}XD?hPYuKNmymkOJ&ddvCt@?ggkMlTcEpT6@7)5nzx zl3hYNx`ENZ|`xa&6Q$^`3Gbo?>HB>lTCOY$QyNMJ9&aJe%9U~{V)?2C z9h<^{i57yCYC_X~=|IONEatkxtPHuUKXyoc4ZOHZ6GQR|Q;}HHTrA0zmn8FY!Rx6j zPJ*d;TdsFYA}jJRu+O8!2{9@x5`Siz)uup!S(bRaI$N+<`sZbM6ksU{H|C)SXoyFh zKm>y5uh;>5E7vHeTVX2p@~*gR$h%mC6L*0Tp|28kw}udoWlDB$7$=NILBonCUiJl; zXdua*WmUFcteLjCY9zHe7Pwx(_>ltam=1Woh*Fqj?t50&IHGVf;WoK6Gn>6xtdww+ zld028iL_d}=}gFCEZl`xIJ9C2@m3tl6K&%~hfw8MkQW+A0|cH*rzG>4n3JHV@wBZ1 zEwy;?7zeW?HQUII%xG|;O?Ft+aRa%(^(Bs{!Hko|W|zuwAFLzC?`ElOZNX``;(Vz>F-QI$~ND!(wXl618Ac;Qu^~9R|Pb_VR9UgRS==k&B0O zeq~gOlOA@JMGP3zdXXS+<;@H8Y6;zx1bq*{r*fv$j=O$HSnG)W{a3B4TX~egdeApT zy6&-NIbO%~JnTF(@6`FqoD)Lag)Tetb#HW@t5Xt;Dq_5L2fe!F3}QQHogw{VZ+U(n zvFhHTT#Yl+?G)M{ws5P*<@q)rBkb21vhJnVb6A?N;^lt#pIcRw_Hb#nRLvZuhIy=_4ck|lI+Ei zTEM&C+vuVkPwqVrP+|Dfs^ssTWPmBuMrBu1|^YSbu#%BQLlX%(M7a*2hkR~7x~ zw~jI`l0#CjGV0VQj7l{^+q>RJ8Yix!QXF2v+pdXPF^Z*Hjq*}uiEypbpwEUMl*Yh{ zI@&_O-=Csa;6|FFJir3pEA7JpX&#lT35!gct$|>jBohEBEvDmp$l+nn&ve*D$mHMs~WA^kHkvrOKw!CB&V*IMN{n;I)`eewkO@yTQIU)h;gi9$Y;Jk&#RsE z^nJyuGEqLq)W~OIiF*z$?G6>ijXF<4Q)?~29trY=Geg8O5^1XmeV5r@WeYP6#kFE4 zM$p{q+(}Sza!?eDAMtj1A-74wI-i!vv9(?2O9V2n!e*IUX=qBkMTP5fXr`2S6s{g& z@!(2hiOs3R<`sz&vBW=V1_9ndR80JhtB;PR;cB#aEYU<;2=RA<>~>PrV2?`G`QLue zkrZgpQTkuzgk4V`4Wisv6PNSDjgqA$7ILaK0le%hmoiGmkJZ~i~d>M&D z4kV)XgpmZ23Lim~V})yuYaJ8BUtrY>xi`#SYF@1QTq0%p$@hKu8J^OHs zR?fMU7;2gSc*5$5Y1SSaZunMFTBaeAwzQfJU@*SdJh@1mL)^$+j2t`%UJ}{!;C}Ej z&=bB+Gk84~4|dRqPri+t_=7VPn7B{6V(wY7h$j8o>hLT7PtR|&_Q{J&0BbX!mE6m* zYH`FxW`cqV3AXE^nft5nc|zouVz% z4)bfVdN)f%i3l;j&=$xV&XOK6W!y%$!>IwoUJYcTgl5G^vX}M{2EqAr%ENVg9UJJPO{YKE9XI*Q6N3qiYI z)nS^ri6xjR*GoK5O{`owIpGy^LEbujI4kQ25UFXUOwV^PrJC041_(5QuBPUBBrK2q zS#?xTS*Lql72z+*nMZQbD5_}>tChB!Ms_yhL)N&q({RwJ+2IVr(h6?RJ7f$>sO_^* zF9;Lv=y10#e=98P2HnT`$<({6@I!g?o7JfC6+eJ;M_G0PjEL5P-r9@>iE zc%nl{iKf`ozH-eQ%89N>=)Gqexu`g{tDmyw5AOucP!HhU9TaE0Av(E91)EHP6Ruy< zUXQ1qH5@qSu|923sM0g2?8~4CVxuf0ojg-8-ZY;xDM0LRLgRkY(jv0Eie!kl?AKt0Vs$nuj ztg#(W3f8hq2mDhB4M=WAdkRI5+8u;c6!rN~^yQX1t|)u9LsiWYzdA<&Kgc`1MnPul z2HyffZG>Np+@i4J#&yIN+#Gt=8bm4C!fheg639ef)K%t~Os4kqt{-BQvO4TL3{eAd zC4fBx)|u0$sL{ikPdA~D((%Uh_Fa`3U~Y&kZ#<-2l-m1?-SO8am z9V$IpQjG1e+eE&MMNUkAD`phsYCUnBHhBVb-5XkSCp-hC`88q)0i zlgz|vxp>|QRWqT-Ds1RYM3wVQ^`Vo-iE;|!r%@Rh#nNF`bQsP?s#rl1NKn@3Kr2jn z51o70DFtm)Q4GvN2nG5Itv3mt_@iMCjIZw}Aj;dsX@y(!Bg#@5_#`3l-uf>5i)(zr z@o}W8WhE>%`6Ls*2zJeny_j|lavKV9@Ko@j;$UBL;1-6>Rg(>NO40@BD z+Vk<+xN-|bZBan6UwC=dWHa4R&)#=@-zGPXK1ljaUiw38cktCOzCW2epZ~*?>Re;x zWCsQWWDNcP8mB zjkTs~KQW9I{sOL1ct6Wqd`ibDtlut<@a!HRb1=Hhc9JwKaM+Hna|m&g8*P9=hrzaS zqb5D1dqx^vR18)wQ=5C6b;XtZcM|K8u>_h8;gVXjoQa;6mR{HBRh0T6BvEgb5v$?` zV%}Iak#K=lZn~s^&{er==r*4f6ns7tTy1YqC1P-&-PYiY_VxpqEpxuavrUVwr{~x+ zNqZ^#3qQvd%RHb?oaar%FdzTE#g^-QI}x?>WH--&`J&h5^c*4G=l76@KATiSh;HhS zY!mmZyJ$9Ys1BWLVSRF`$wDIe$clnNgtrR1eL7#lFvLbd$7NE1sPZqfNMbIEXtXV- zY&(sb?D5AsrR#%KLLBt;Sw{pTF8i_#Xf_-%=U8H%i>I;hc$V^A*pLU#fH@c67zS3G zi_M`lJU3U=tJK)qtJoM_-^yKX7mm8g-XSEeya0B}a?MZNwgfYY{uUp^;pMj72G<1E z`*FVRIp4%Ka-9r)G?VK?)CHH_n)kg|eR1sm7yEhn?`H+m49}zS*XqNO3)_i1u;_G^ zuOztizaa!kOzEP^t6eV39MD#rf81&8)R(juOP>oyGdXID04mj0OAu5=%QaL6^fEiV z7#}P|t_r!`kR`;4JjIG*pC3iuU91DtFzt)~*gR3mmNi>l8UA)vuyd&1i(nHI$Mab-ZiFPR#d^S#T4e7F8UK%l-b znofu7kxp9krS8i8RbbR9q}>F2zzv$mhx%F_3IED)1i}7mbQ-}9F!nF4NXpCg6WsQQ zbEpEZwJ3?OHmM68PjY;_fy!k!h4pE3%qoj@`Q2K^G+YnvA)_uroDe}>p zPw7jS&l9GnxSC^NVR~DR|Joi5H4^`3$gK%QO7gRL4B_HHXO!^AsY_@9!%MonjC`kc z0YgaYX%q0GT)NvtUfg+4#4P{Pzt--~_8kaZ0<`i02r3md+bgD2_Q1!ttQ zLi*(IpbYWmUxNPu{il+mr6n99`=f73{5)R_|Es?B-wf&hh|o!%lLKKy3@?wMIp9b2 z1pW1QfY%FPL4bt@M*#Vx)D4Pi6>Tf{yu$Me#Fx@24Hwx_*UjtN_xLhnlH}*p*9+Q@ zslvPdV304MNG!}Z6d>?$rd9Mb@|Y=Y=R+OCU&6#7%q8|u$06kzBvheQf6lJ8X`Dv= z9!7Wxo?L_b8i``%6pkE;4NrxKBPP?rf;jt1hXQ`E9ZP$~Kbxjk_6 zp3i*w03J&iGGp^2VR1`%=EG3Un|oq6VjVHKX7Pi>5=EbT_LNC?cGRMI5?}ecIF??S zCG)8?F3Tzmo-RS)iTi4o$zA!~MZ`R%e_{`%h72mDIEKCg=e4#x(OMGVz`BPfy}r8&U;*3%PCeQX`&%u_Fq_eaI?Q&gAvb?o zwYzRo@D27qx5kE=C>Q8Qb`<-eeE;{1qyNGj{@*t!H)YE1C;KMsUvgMSi-7c0uK+B3 zFM$d%olzn*uLP_mw(J6ZPBV3tJ$x+ zer;x2#G2>#Rvq9&w zjQ!11*q>jnz=ym%r=V|lCS?m-2j35oxAbz;1b5PhAqPYTza2*a8}!rBJ;P;%r4W@jv_{gg2}#f5%Ay=1s`0?N%K9jCteLLO${OXaTA5S zeQSS9K>N`ao9Vv!Q(xn78He9?Siqv77t3t9_JDfVdt0=i;E^fMo~Zxp-F9<53ZnOU zX>o*}a>P8}vVV~)Mhj{jjlq0yugNg~iR0)qa-*M#D0&={A=OBR?Z=(Y^1M1iJY|F& zuJ+W4n1jY}oG_so#w4XVaDvmD1gR$tNOvSf^I?VU$ph*OyQlALc6e-ImA5CrSBPuG)z0Pc#Bx-<4@GlRaAXyWY6O78=NFD1jBC{>6B zHSy-uC*b$?>f;R=fQJ*-fIkQdI3g{`Ozvzed`6(dHqnS~#_F6hDlNW=uH-o(n(QJxI+2LFy#T5?HKxMV>(3?3 zfeIr~eg9_J1>Z|BoE41?!`-vhZ(iXJ&V2 zhIE4_q=ARUB84Y`z(A!y02#D|3~@sOPUXbY=bb9GhRx>f5+*tWK|)|ZlPZ+d6OjC}(>+V4y7n)f9qlatxm?Av@+67SRMjOwYO(zIFG51nd5Rk>*D4&ZbeAF5O;L=pX+Xg4FL z9MUeq7nQ3aM@OETumwLKBXmD6<2mgVe5OI3x}=jD*SvHmH%*kC{6-b>79#YSBj+Mq zNL5&euF1;8r7tF*v;clzp=w!}E0;DadapqfPl|w3pq!&3Ue48!EQiv!Bs!?%Ns~P0 zRQM5qqNqh!n<{5hjKgUMwYxz-HJgWv!xhF)YRSXCu<*;QkM~%E8rEf7L@DiyxpONUOFON#-PX3BE8&~o z?x~Ctm<6qjB`kOXHOlrku)`1-CLD@%w|Q%G)!xFMtGK$c)7Ewgf_`AdDX>qsK6dOg za1-61r7Z?<`|cg=MT57`34{H$&qsU^`(gaq>VtE4pH_fW4L|(xCFtM6h90rn23b_h zEKa@XkzQ*su%w;6#@fEx?$XNU+52Rj)uolST5G94wON?PU@OCI|B&VSbY*UDabM*^ zTF6nFu(oFY*i2L%Czt5>S;o{Bfp>}UgtBef#FpX9QzZ(Izhp15I4w7yk^8+aP|I$c zQdzs>B|}b;jSZFO;9|Wrn}HPbE-Yv-6FmqdQ&~>1wGRt2MUF zdKD{BKq6+{h-ykOZw2D|Wu&-K;U7mVG^@BFUb!TTb0Ew|tcA)A>n7x2O((4Zn76U7 z3_63C>t4SYF*55!6enlt%JxoDi9*1*?&7;WetDCIX01Vj_}I z4agr~ZSALqbBokErE@EU%(7fQVwx^y4WFO}n$9C&-gWJZSkcdcUDHFMHT)RNM7$ky z5$kNMt%Dd!zAy~u%G}G8D>0MYUHg(nB3)!*VULtR2P3~AXxbaiO4-8!$rhTs#_q=q z|7iaH8fc0V*&d3^rik5?G~p#?;*>QO%+iH_?6LQ2Wn9 zBy}0Lyp$kuGuar#kl4mS_iV-va_me( zqKEqq6v)h7C=U)fGP16vY%tfV@cPC%4}l7)?e@^m8jIc`nVq~-KSi0Xwe>#vcBgRX zY+jEZ1ZjD&Xl z#SBi*EXh!s%q8a)mY)(bsL!xxo3ss}yvVI7oH`t^qbmd{#N|QT8Si%2BPd#seZ-9AlV-Pm6w4>CPcSW&vT(eG^5p5sj}JfD{`(jfgI=d*-%E#@$$sT5+9g}6-P#4xH*#kQ z5oV-FhcPT!)Uz@6+GQdA?FkLTSGBl)fiAVLZh`%bF1An7z57gigvxg-)Zgk6ce8d8 zFZOwn*XL;bI`<@?0u9g%VGpb$vnow*Xy@$Ejd$ywPM-Q4i}vsMtBee5NBYI`wWVeN zwEfH0mJe!fM!|NB|?E4de&^K5W3p)zOI6EzIEj{ zg*;JaOtna&{Bp_AgLAWzMrFqSU{z4aq6581w( zLh()X34cNOv14_Z{DCqSuMq#T11n$QLh)mU7=O_i>pSC@NOArm3e{H(3iDn~Lc|;A z{wvR7Mlu_FD!VI!RIxr2^q0j~1`lD}l>zd*JTm(6fHgXFW{y14U$T81TG79ty@YiU z@9)f=`LoDb#@jd$W;`YhJjDz2XX#kH(tj4uI5k`K4>V)*%IUk$)^H-|J8sLw=ojr- zydw3~&fBrRrgGCWEI6Tm*@t?2G}op)zfSZ;pUY? z)vb+~38ts&LymSHL2s(pNv8R;K>S=Fr+W+znDuwpBtoKSP})R=8WZSIC1BT}@x~n$ z07Hgx!3c#E%|ay8g5isSI0}f$0uP`IBP*{$&6H_nk&O7 zHzaFtb&jrx(G8BS24`PN8MboF9$#s&aQZfyUX6JKsOq=YnaYjSagKUerkh70%8q!Z zBOQ`-3hAH_snQ?691VM!{a6ff-K%9MSGznyxP*q#BC;^4cJ~(8rqa za*_!ES_Emfa{O_+iHC2WBniH(?&nDHY0cDRFw74nl%crazub5^=Bvhhe3ALYHQeJ` zFe?$W6Lj!2-xrikVben_R~BL}XOo7~SpWV}@Y792&cQ=FK`W&1IZNq+681mO@QNke zeUSw(c7k5VkAo*coa-VbS(9+fB_1*d$tA_XAgP&-goz{g;Pt$wM|@nTSVzYXO~p*z z)yZ-5hv8%n_C-}Zjw+ImuVem|5+k2fE%-qE5R=Q~{%o>86fp**?hWQJ9>d6J_Kn1` zXjd5GV|Dy$@DuEx%1OU||L2fPY9v+R7d~8kNd1IQ!}-q6Q((X)5bXvCX<*8Lf`UDjr4B5K7596u&QPvWg>yp-;*P>l-W7H z2|Pv?rw-Wv4?h_h`zf4~_VD^Z=ES^yW^~DVIi$}WP`Pxle%x^oPBwPaE<4FJx~b!; znuq%Ne+)^zYI;-MjEL& z)H99D$#KN=#*TT$L!Odn$X|l+1e9j*o7c6zH zv9!B;tS>zG61V4I{mR6Oywo|ct`6Eg&5fAoIlA^RDx$QN%cz!EKe7KU-2VDh9@@K0 z3;T0Ff#rX4i2EJEUn!M|vtnj~6Y@21MMxK;H7z})MqKuCc5ny$u(n!BubMgWwt@^} zo0>d)cwR;dPIBE177Z%aLL`_uQrr0(C3MCcQ$~i9(|%=mL2UQDH!r5L&lU5;BvuEeH6nj5o;+z5FUfo21(Ck1+2W)WUvlK9NJ1&ajuW#n( zpEAau#`f*_-N$45NtNcz$~RzJt}}kOMceLq^1*e2l65g-FG?4-bVTJOnfcy_q}=I? z!Z&m^2a?96Q3(7v@>fvdi6LcHP~$qd)eIj-?RKbaHU{MNoRN8rEL&}yEed=oB8~ME6 zEfv3I57J%ssn_9VXc@s-t5u~JUQ4#pYd-JtXCgwIgP8vO+fFmXS4-F^%Ac)qO(YIP}ksJtTyLw z#JJ91V@*_J*W#S}K=jP8ymAAy71flq+u?`YRn}n&j`(tjMPU1p_v{iMjPe7*6`wrY zWoJ}Ky0uV+G7RO~H8pja#6-iZR*lxb=ySo@g_n6F^UZIIXoVSnh-zyFY->j%z6hc+f3n+<{gMgYeO)?=w>00++S^j?(qL*eyM=SFN@nj0TD;jx#6*f9eDgv(EHo4$q?HzLIJag1!Kz+&u!l5vcwEd0h_MG*#TPAfl@anenH#; zTsN5dTueu_-3j0q*V>0JO4FU=>w*M%7vK0h|1?cF=$C$ftqfr;{Q(<-g5^#eH-|*| z!pbZ1l4e8F>`?A@6OoweD^oj+1AON#n%%~FlKQQxU8T)f@+(&RWzF4;4dtBR{Z`Wd z;q0A*Yk!;V!Gk0xc5<>~+qP}nw#}1d$F^y(PP8l?bA7p3$hpY&3RG^o;wlXuuNYR#6$+PD4T-hCWy|&bD?-@l=&79P@R!o(2!YN=e`Bw%9Fkr z{)WsAD^kP&mVpB$3UAGTsje#fYS4?d zLZDNcgfe3{r4~mbWX~?L-u1{Gek=)<&TXdS`H$=+y4%biC9COGz3LiAMWSkPzWaZJ75 z?nL$6E)g}&ncS%oBmqrhmrM-3O;x?Hh9a?*>oUl8k&5)D8K+-OzwJ+Ym{xb^ChpbmMH><={>jW%seoq4C1-aEPwdvE($5DxCZdPTw7 zR>oQ-Gq~|(&NJA(5gzVgi#l{~9BItQ?oYrn{u%1ft{wX3=Hc~6;fhZz6briteplUC&KWAb*Stz|2;&`8>UrD5VXcyVgE|n4YXAWf#PeQ_T z(k#%2;tXI#B$1^*20d8(24G@Ztc-Tz0^(=dP+Ppi+q|Y5<*|)d7{WSO&}if)|Lft* z!x&cL>}{Q#R)eRz4_bFN7FuOuk-)NJ!;)(>(^faKcDdhxq%__wym_e>+s>Uj2W6r_ z{T)2Y0Mg?CX7Dbn+WU9iA&-$GmGRa4G^M2G`A?qAZRL;<`~$KK?$p_n(tK$@%F>WA zm26w!ZwUswm8xBn{N1C&zdsM}#85b-y1gM;DX%{i0eOv~MO%Y6L3RnDCc>;>>mtT1 ze|hqDDfMHEgj6F!QU3PC_pK|X3AX55Ptn|1BJN(%`)1{23WPnK!%;Plfyi$<=;7yY zA6kB<4Do~o+EM5Ax%nTjW|(I3tWq}PxEBQsp$RmvaRgJf5eb3qaK!Upoe-;cjoonh zsqb{N(_5O&>5+%6KkK@k!SF|^GlL&=YKjf|dSPjOOF+)1RLjDi@SxgG-4l941HH7?(@ zl<|flf75dmMQ=H5;WSq!n+`&_L?Ow?EQG7vsK>tOYs&&OsEi4H+cf^H$!=c)_^-V0 z$X z*?Y=|d$>m0LraJ>80~zd^hGupq=kLdmCZ`ZXPd#e`{^#@+y3O&FXq?hqEjOqZ+>5B zg;E~dC@Gg3K9h)3F;woL)hOg-kbufIEepnbvTBb*_9_&c+^+fEg9p5f8Kt&lK7=#C z@E6#}o`)eAtytz#tsR1{Q^dXgJlbwujZi@I-8XevuD{WG{~coQ#NlE7s|mw(_JTfY zY?4bFy8Kp`EyFkJ`VG=sXXNVVJNDs|!@GCp7JCMtuM)OV>h8|Rn1JTVjhNs8bfYYp zR1tk0Q`+G)-AJdKqFE!e{I3jyMnB|S+uDXWuw#CBt^5C>5-0mBb$|TT?H&GVt^efNJFfo&Z6`%LZ#6kAhSsyt(Vd&JSx8o zuYQ2Dl=NN$Af-NCL3Fu~RD{_HA79435sk58RXezkF8pNi@Y(Af6GXgln>+cK132Kt zMM>4Mjs6zu^`et(R!vmfh~jsnZe{o=gjn*C(v`rk7ncH96`4PC?)4+BqQq))!7eeB zB7rl-Q-p&53g+jgRA4G;)wIa{G@KdWQUj3=$vmU#X_C#MXF7KO9w|iq#GLFwNi+x*Ed4K)(=p zSo_q*IA^_;fs7I{nooq&o~W?jTo3yA=A39U*zbAaHjM#j_kKZccicW*PsW>5Iyzn7 zReN_yB{e7U{VCKb%r8mnA?a#SGf2q1- z-!zZ?^h+UMXnH}q1m(2!fJ0x)Eg_#I07E?){Dh=SjyVlZ*0a>QIh-Wl!eCB6v0VX# zo5rW33pjI~4ocZgEzP9(G%;2|6gx|aI`PDg@~;d+EHe+%niwFfVX)9n*`9R;HEgdW z5Bf#iHIGE|up{>M+SSBCoQN=3<;4EgO{Qe?;Z)u&$BcGLz;SiiOMW7qA-7U8!#NI+ znoUPHHuGVqpC^+%cJuYr?)v5iJxxI%VxL})GD>@l?K1YJdufut-r|LZ6FbW}qKW7& zj5{Uf;~Qrvr4TL-?hYx+C>4W0Y?hAwg9qyehxH5BxMSD*PqrtdStIr)oj@5E0rZta-lX{`uq|lTjnIpIh zY0r%iR>A14`HddniZI09ZIE0&q8WfJws<40qV=zxKm|t=vLQk*#FDLlBG%Y%T44VR zvG8AxB;5ah5c{7f{!hRvZb&2Xp>fS6Qd5=T;;MfKtyrZN{qDod8^BD*k50(n+>>U+ z;TvGow32~-)}`(GWibYu+Dv!T`|J9HS!yh1hpK z020?Rg1+mTRLE z)J>N^OnMvkiKAty7C+KJ`ougm(ncER72mefQ%r(H=2UYxKV;UWmtN%R+j=$cBAdx9 z%n!cDpg(9D+)RgtuXj(xUk^wz49<_4;Wrg7DPch1&bUwe@~fo&0?Ybl=9S$ak=VV8bm{)uAj^)#EHxHNY=bHKH$7 zEkac)ujeXNwJ_jOP9t`5)1RMK&88%60%S$MUx(S!qkCe+%wRyJ8iK@NS$&uO3+uh~ zizNNuRSo}F#J6`g zvj30$jly~cjyCrH8R#2SUUZO;0Dobt$LYg$e-rsB&zNdb|GvT3mHehcR4uB8Z(ZN8 zN8de6-?oxbfL9@9Id?C4MPW5pe-cwDr4dISJ&o?sbmFCR;)UbG_x3XHy|v=s5q%K! zYG<s1@2~4samgL0-Ma_+&Ft=O43u^VIP&7&v<%lU*Dj^OHRSR>H+ct2yjC)Uj98#6#w%#9ieHMwbD9DQc&4I4ydGIqvHUWfZU{a{44@d+J-#ji;- zhEx)30N&Iegt}Hj#pehJg}Plit=`Y{1OJe#WbAMe7>h-ueEO*oFDn)k(+hS%BBh>! z5N|JKey_>NoMO5-)x7#K$bolvN@L)Jo|m6ub5F2Ogz!x^Q3~DE2nhZp_3N>;G0c{*A5(vVaeZ?qfanes)PIO7-#fX5iYid2E z0V-Ev{xx&!AAaW&#-PCf_ayw zifJgC_*F8O_)dzRzqbgO9|N(kW;%N~naDe%a76!v;_QmhdzbH$JeP!K?HnPVCNfd$ zDTLZ{)g@YEOm1g}>l8l|WhUKNpmg=v2+?*ae0h@a^)@D$RqjSTD>SYN^m&n(w&!eN zh_YAjYhI>?^6a_I22&>8{Pyk9AzD|&)KGed@tKO#zC7NCpdKx3^Jhw zL*_wrSyv)8U(i-QZ1C9FW>-o*{A5p^)3AVqxh0Mo8NP@?W4*{dQRg=`tA0$h9+eYm z%96K1k8-v>f77dFy5FmOT1G?Fu{UoH`Xfpn=b+^)R7qNme}=X+4g81C1<66>^Bn0rJb7*fA48Ok8%t zDXZD0m_0*zfG{j(a@tOtp#(iY)SBt+*k|vB{CAbgPfN{9#fd!L&{tzr-kD9BNvmbF zcD2I~NT{7wslr~3;!*vZmrPuc1q6Sj3eoX;D03LQPG@(mr$NIuc&q7_VjQc$)5a<_ zXudu;wwqI&Ca=82?R(@Hsg1dLioYjdlEez7=|)Wgg%@LVI@J7p5XMyG=Y)$xBVG

h%jGn8RYHyY>=1gQ1ltv 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 literal 0 HcmV?d00001 diff --git a/src/main/java/core/packetproxy/PrivateDNSClient.java b/src/main/java/core/packetproxy/PrivateDNSClient.java index aa1dee0..97aea7b 100644 --- a/src/main/java/core/packetproxy/PrivateDNSClient.java +++ b/src/main/java/core/packetproxy/PrivateDNSClient.java @@ -1,10 +1,30 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + package packetproxy; import org.xbill.DNS.Address; import org.xbill.DNS.SystemResolverConfig; +import packetproxy.util.PacketProxyUtility; import java.net.InetAddress; import java.net.UnknownHostException; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.util.List; public class PrivateDNSClient { @@ -19,37 +39,60 @@ private static boolean isLocalAddress(String addr) throws UnknownHostException { return addr.equals(localAddr); } + private static boolean dnsLooping(String serverName) throws Exception { + return dnsLoopDetectedInDnsServer() || dnsLoopDetectedInEtcHosts(serverName); + } + // システムのDNS設定が、PacketProxyのDNSサーバが設定されているときtrueになる - private static boolean dnsLooping() { - try { - if (!PrivateDNS.getInstance().isRunning()) { - return false; - } - - // current system dns server setting - SystemResolverConfig systemResolver = new SystemResolverConfig(); - String dnsServer = systemResolver.server(); - - if (isLoopbackAddress(dnsServer)) { - return true; - } - if (isLocalAddress(dnsServer)) { - return true; - } + private static boolean dnsLoopDetectedInDnsServer() throws Exception { + if (!PrivateDNS.getInstance().isRunning()) { return false; + } + + // current system dns server setting + SystemResolverConfig systemResolver = new SystemResolverConfig(); + String dnsServer = systemResolver.server(); - } catch (Exception e) { - e.printStackTrace(); + if (isLoopbackAddress(dnsServer)) { + return true; + } + if (isLocalAddress(dnsServer)) { + return true; + } + return false; + } + + public static boolean dnsLoopDetectedInEtcHosts(String serverName) throws Exception { + if (PacketProxyUtility.getInstance().isMac() || PacketProxyUtility.getInstance().isUnix()) { + return dnsLoopingFromHostsLines(Files.readAllLines(Paths.get("/etc/hosts")), serverName); + } else { return false; } } - public static InetAddress getByName(String name) throws UnknownHostException { - return dnsLooping() ? Address.getByName(name) : InetAddress.getByName(name); + public static boolean dnsLoopingFromHostsLines(List fileLines, String serverName) { + return fileLines.stream() + .map(line -> line.contains("#") ? line.substring(0, line.indexOf("#")) : line) + .filter(line -> line.contains(serverName)) + .anyMatch(line -> { + try { + String addr = line.split(" ")[0]; + if (isLoopbackAddress(addr) || isLocalAddress(addr)) { + return true; + } + } catch (Exception e) { + e.printStackTrace(); + } + return false; + }); + } + + public static InetAddress getByName(String serverName) throws Exception { + return dnsLooping(serverName) ? Address.getByName(serverName) : InetAddress.getByName(serverName); } - public static InetAddress[] getAllByName(String name) throws UnknownHostException { - return dnsLooping() ? Address.getAllByName(name) : InetAddress.getAllByName(name); + public static InetAddress[] getAllByName(String serverName) throws Exception { + return dnsLooping(serverName) ? Address.getAllByName(serverName) : InetAddress.getAllByName(serverName); } } diff --git a/src/main/java/core/packetproxy/ProxyFactory.java b/src/main/java/core/packetproxy/ProxyFactory.java index 8755237..c2e96ed 100644 --- a/src/main/java/core/packetproxy/ProxyFactory.java +++ b/src/main/java/core/packetproxy/ProxyFactory.java @@ -15,14 +15,12 @@ */ package packetproxy; -import java.net.ServerSocket; - import packetproxy.common.I18nString; -import packetproxy.http.Https; -import packetproxy.model.CAs.CA; import packetproxy.model.ListenPort; import packetproxy.util.PacketProxyUtility; +import java.net.ServerSocket; + public class ProxyFactory { public static Proxy create(ListenPort listen_info) throws Exception { @@ -49,6 +47,12 @@ public static Proxy create(ListenPort listen_info) throws Exception { } else if (listen_info.getType() == ListenPort.TYPE.UDP_FORWARDER) { proxy = new ProxyUDPForward(listen_info); + } else if (listen_info.getType() == ListenPort.TYPE.QUIC_FORWARDER) { + proxy = new ProxyQuicForward(listen_info); + + } else if (listen_info.getType() == ListenPort.TYPE.QUIC_TRANSPARENT_PROXY) { + proxy = new ProxyQuicTransparent(listen_info); + } else if (listen_info.getType() == ListenPort.TYPE.XMPP_SSL_FORWARDER) { PacketProxyUtility.getInstance().packetProxyLog("type is XMPP_SSL_FORWARDER"); ServerSocket listen_socket = new ServerSocket(listen_info.getPort()); diff --git a/src/main/java/core/packetproxy/ProxyHttpTransparent.java b/src/main/java/core/packetproxy/ProxyHttpTransparent.java index c2dae4f..4c1997a 100644 --- a/src/main/java/core/packetproxy/ProxyHttpTransparent.java +++ b/src/main/java/core/packetproxy/ProxyHttpTransparent.java @@ -1,5 +1,5 @@ /* - * Copyright 2019 DeNA Co., Ltd. + * Copyright 2022 DeNA Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -65,7 +65,7 @@ public void run() { static class HostPort { String hostName; int port; - InetSocketAddress getInetSocketAddress() throws UnknownHostException { + InetSocketAddress getInetSocketAddress() throws Exception { return new InetSocketAddress(PrivateDNSClient.getByName(this.hostName), this.port); } } diff --git a/src/main/java/core/packetproxy/ProxyQuicForward.java b/src/main/java/core/packetproxy/ProxyQuicForward.java new file mode 100644 index 0000000..0f59280 --- /dev/null +++ b/src/main/java/core/packetproxy/ProxyQuicForward.java @@ -0,0 +1,66 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package packetproxy; + +import packetproxy.model.ListenPort; +import packetproxy.quic.service.connection.ClientConnection; +import packetproxy.quic.service.connection.ClientConnections; +import packetproxy.quic.service.connection.ServerConnection; +import packetproxy.quic.value.ConnectionIdPair; +import packetproxy.util.PacketProxyUtility; + +public class ProxyQuicForward extends Proxy +{ + private ListenPort listen_info; + private ClientConnections clientConnections; + + public ProxyQuicForward(ListenPort listenInfo) throws Exception { + this.listen_info = listenInfo; + this.clientConnections = new ClientConnections(listenInfo.getPort(), listenInfo.getCA().get()); + } + + @Override + public void run() { + try { + while (true) { + ClientConnection clientConnection = this.clientConnections.accept(); + PacketProxyUtility.getInstance().packetProxyLog("accept"); + + String serverName = this.listen_info.getServer().getIp(); + PacketProxyUtility.getInstance().packetProxyLog(String.format("[QUIC-forward!] %s", serverName)); + + ServerConnection serverConnection = new ServerConnection( + ConnectionIdPair.generateRandom(), + serverName, + this.listen_info.getPort()); + + DuplexAsync duplex = DuplexFactory.createDuplexAsync( + clientConnection, + serverConnection, + this.listen_info.getServer().getEncoder()); + + duplex.start(); + DuplexManager.getInstance().registerDuplex(duplex); + } + } catch (Exception e) { + e.printStackTrace(); + } + } + + public void close() throws Exception { + this.clientConnections.close(); + } +} diff --git a/src/main/java/core/packetproxy/ProxyQuicTransparent.java b/src/main/java/core/packetproxy/ProxyQuicTransparent.java new file mode 100644 index 0000000..9e1eb07 --- /dev/null +++ b/src/main/java/core/packetproxy/ProxyQuicTransparent.java @@ -0,0 +1,73 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy; + +import packetproxy.model.ListenPort; +import packetproxy.model.Servers; +import packetproxy.quic.service.connection.ClientConnection; +import packetproxy.quic.service.connection.ClientConnections; +import packetproxy.quic.service.connection.ServerConnection; +import packetproxy.quic.value.ConnectionIdPair; +import packetproxy.util.PacketProxyUtility; + +public class ProxyQuicTransparent extends Proxy +{ + private ListenPort listen_info; + private ClientConnections clientConnections; + + public ProxyQuicTransparent(ListenPort listenInfo) throws Exception { + this.listen_info = listenInfo; + this.clientConnections = new ClientConnections(listenInfo.getPort(), listenInfo.getCA().get()); + } + + @Override + public void run() { + try { + while (true) { + ClientConnection clientConnection = this.clientConnections.accept(); + PacketProxyUtility.getInstance().packetProxyLog("accept"); + + String sniServerName = clientConnection.getSNI(); + PacketProxyUtility.getInstance().packetProxyLog(String.format("[QUIC-forward! using SNI] %s", sniServerName)); + + ServerConnection serverConnection = new ServerConnection( + ConnectionIdPair.generateRandom(), + sniServerName, + this.listen_info.getPort()); + + String encoder = Servers.getInstance().queryByHostName(sniServerName).getEncoder(); + if (encoder == null) { + encoder = "Sample"; + } + + DuplexAsync duplex = DuplexFactory.createDuplexAsync( + clientConnection, + serverConnection, + encoder); + + duplex.start(); + DuplexManager.getInstance().registerDuplex(duplex); + } + } catch (Exception e) { + e.printStackTrace(); + } + } + + public void close() throws Exception { + this.clientConnections.close(); + } +} diff --git a/src/main/java/core/packetproxy/gui/GUIOptionListenPortDialog.java b/src/main/java/core/packetproxy/gui/GUIOptionListenPortDialog.java index df737b9..948415b 100644 --- a/src/main/java/core/packetproxy/gui/GUIOptionListenPortDialog.java +++ b/src/main/java/core/packetproxy/gui/GUIOptionListenPortDialog.java @@ -149,6 +149,15 @@ private void updateNextHopList(String item) throws Exception { JOptionPane.showMessageDialog(this, I18nString.get("Set server you wish to connect into 'Servers setting' first.")); dispose(); } + } else if (item.equals("QUIC_FORWARDER")) { + servers = Servers.getInstance().queryNonHttpProxies(); + if (servers.isEmpty()) { + JOptionPane.showMessageDialog(this, I18nString.get("Set server you wish to connect into 'Servers setting' first.")); + dispose(); + } + } else if (item.equals("QUIC_TRANSPARENT_PROXY")) { + servers = new ArrayList(); + combo.addItem(I18nString.get("Forward to server specified in SNI header")); } else if (item.equals("XMPP_SSL_FORWARDER")) { servers = Servers.getInstance().queryNonHttpProxies(); if (servers.isEmpty()) { @@ -174,9 +183,11 @@ private JComponent createTypeSetting() { type_combo.addItem("SSL_TRANSPARENT_PROXY"); type_combo.addItem("HTTP_TRANSPARENT_PROXY"); type_combo.addItem("UDP_FORWARDER"); + type_combo.addItem("QUIC_FORWARDER"); + type_combo.addItem("QUIC_TRANSPARENT_PROXY"); type_combo.addItem("XMPP_SSL_FORWARDER"); type_combo.setEnabled(true); - type_combo.setMaximumRowCount(6); + type_combo.setMaximumRowCount(9); type_combo.addItemListener(new ItemListener(){ @Override public void itemStateChanged(ItemEvent event) { @@ -246,6 +257,10 @@ public void actionPerformed(ActionEvent e) { type = ListenPort.TYPE.HTTP_TRANSPARENT_PROXY; } else if (type_combo.getSelectedItem().toString().equals("XMPP_SSL_FORWARDER")) { type = ListenPort.TYPE.XMPP_SSL_FORWARDER; + } else if (type_combo.getSelectedItem().toString().equals("QUIC_FORWARDER")) { + type = ListenPort.TYPE.QUIC_FORWARDER; + } else if (type_combo.getSelectedItem().toString().equals("QUIC_TRANSPARENT_PROXY")) { + type = ListenPort.TYPE.QUIC_TRANSPARENT_PROXY; } else { type = ListenPort.TYPE.SSL_FORWARDER; } diff --git a/src/main/java/core/packetproxy/gui/GUIOptionListenPorts.java b/src/main/java/core/packetproxy/gui/GUIOptionListenPorts.java index 82cb28e..5013aab 100644 --- a/src/main/java/core/packetproxy/gui/GUIOptionListenPorts.java +++ b/src/main/java/core/packetproxy/gui/GUIOptionListenPorts.java @@ -115,7 +115,7 @@ protected void addTableContent(ListenPort listenPort) { try { String serverNullStr = ""; TYPE type = listenPort.getType(); - if(type==TYPE.FORWARDER || type==TYPE.SSL_FORWARDER || type==TYPE.UDP_FORWARDER) + if(type==TYPE.FORWARDER || type==TYPE.SSL_FORWARDER || type==TYPE.UDP_FORWARDER || type==TYPE.QUIC_FORWARDER) serverNullStr = "Deleted"; option_model.addRow(new Object[] { listenPort.isEnabled(), diff --git a/src/main/java/core/packetproxy/http/Http.java b/src/main/java/core/packetproxy/http/Http.java index 43faff7..c43cc16 100644 --- a/src/main/java/core/packetproxy/http/Http.java +++ b/src/main/java/core/packetproxy/http/Http.java @@ -537,7 +537,7 @@ private static byte[] getChankedHttpBody(byte[] input_data) throws Exception return null; } - public InetSocketAddress getServerAddr() throws UnknownHostException { + public InetSocketAddress getServerAddr() throws Exception { return new InetSocketAddress(PrivateDNSClient.getByName(proxyHost), proxyPort); } diff --git a/src/main/java/core/packetproxy/http2/Grpc.java b/src/main/java/core/packetproxy/http2/Grpc.java index a8f67f9..8067bea 100644 --- a/src/main/java/core/packetproxy/http2/Grpc.java +++ b/src/main/java/core/packetproxy/http2/Grpc.java @@ -117,7 +117,7 @@ private byte[] encodeToFrames(byte[] data, HpackEncoder encoder) throws Exceptio int flags = Integer.valueOf(http.getFirstHeader("X-PacketProxy-HTTP2-Flags")); if (http.getBody() != null && http.getBody().length > 0) { http.updateHeader("X-PacketProxy-HTTP2-Flags", String.valueOf(flags & 0xff & ~HeadersFrame.FLAG_END_STREAM)); - HttpFields GRPC2ndHeaderHttpFields = new HttpFields(); + HttpFields.Mutable GRPC2ndHeaderHttpFields = HttpFields.build(); List unusedHeaders = new ArrayList<>(); for (HeaderField field : http.getHeader().getFields()) { diff --git a/src/main/java/core/packetproxy/http2/frames/HeadersFrame.java b/src/main/java/core/packetproxy/http2/frames/HeadersFrame.java index 9ca9b7a..d81f9ca 100644 --- a/src/main/java/core/packetproxy/http2/frames/HeadersFrame.java +++ b/src/main/java/core/packetproxy/http2/frames/HeadersFrame.java @@ -110,7 +110,7 @@ private void encodeFromHttp(HpackEncoder encoder, boolean originalHttpHeader) th version = HttpVersion.fromString("HTTP/2"); HttpHeader headers = (originalHttpHeader == true ? http.getOriginalHeader() : http.getHeader()); - fields = new HttpFields(); + HttpFields.Mutable mutableFields = HttpFields.build(); for (HeaderField field : headers.getFields()) { if (field.getName().equals("X-PacketProxy-HTTP2-Host")) { scheme = "https"; @@ -125,9 +125,10 @@ private void encodeFromHttp(HpackEncoder encoder, boolean originalHttpHeader) th } else if (field.getName().equals("X-PacketProxy-HTTP2-Weight")) { weight = Integer.parseInt(field.getValue()); } else { - fields.add(field.getName(), field.getValue()); + mutableFields.add(field.getName(), field.getValue()); } } + fields = mutableFields; MetaData meta; if (http.isRequest()) { @@ -136,9 +137,10 @@ private void encodeFromHttp(HpackEncoder encoder, boolean originalHttpHeader) th contentLength = (http.getBody().length == 0 ? Long.MIN_VALUE : http.getBody().length); } else if (method.equals("POST") || method.equals("PUT")) { contentLength = http.getBody().length; - fields.add("content-length", String.valueOf(contentLength)); + mutableFields.add("content-length", String.valueOf(contentLength)); + fields = mutableFields; } - HttpURI uri = new HttpURI(uriString); + HttpURI uri = HttpURI.build().uri(uriString); meta = new MetaData.Request(method, uri, version, fields, contentLength); } else { this.status = Integer.valueOf(http.getStatusCode()); diff --git a/src/main/java/core/packetproxy/model/ListenPort.java b/src/main/java/core/packetproxy/model/ListenPort.java index 2a70802..774bf51 100644 --- a/src/main/java/core/packetproxy/model/ListenPort.java +++ b/src/main/java/core/packetproxy/model/ListenPort.java @@ -23,7 +23,17 @@ @DatabaseTable(tableName = "listenports") public class ListenPort { - public enum TYPE { HTTP_PROXY, FORWARDER, SSL_FORWARDER, UDP_FORWARDER, SSL_TRANSPARENT_PROXY, HTTP_TRANSPARENT_PROXY, XMPP_SSL_FORWARDER }; + public enum TYPE { + HTTP_PROXY, + FORWARDER, + SSL_FORWARDER, + UDP_FORWARDER, + SSL_TRANSPARENT_PROXY, + HTTP_TRANSPARENT_PROXY, + XMPP_SSL_FORWARDER, + QUIC_FORWARDER, + QUIC_TRANSPARENT_PROXY + } @DatabaseField(generatedId = true) private int id; diff --git a/src/main/java/core/packetproxy/model/Server.java b/src/main/java/core/packetproxy/model/Server.java index 5bb699b..df126cb 100644 --- a/src/main/java/core/packetproxy/model/Server.java +++ b/src/main/java/core/packetproxy/model/Server.java @@ -79,7 +79,7 @@ static private boolean isHostName(String host){ public String toString() { return String.format("%s:%d(%s)", ip, port, encoder); } - public InetSocketAddress getAddress() throws UnknownHostException { + public InetSocketAddress getAddress() throws Exception { return new InetSocketAddress(PrivateDNSClient.getByName(ip), port); } public int getId() { @@ -147,7 +147,7 @@ public List getIps(){ ips.add(InetAddress.getByName(ip)); return ips; } - } catch (UnknownHostException e) { + } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); return new ArrayList(); diff --git a/src/main/java/core/packetproxy/quic/service/LossDetection.java b/src/main/java/core/packetproxy/quic/service/LossDetection.java new file mode 100644 index 0000000..eec3b92 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/LossDetection.java @@ -0,0 +1,125 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service; + +import packetproxy.quic.service.connection.Connection; +import packetproxy.quic.service.pnspace.helper.LostPackets; +import packetproxy.quic.utils.ScheduledTimer; +import packetproxy.quic.value.frame.PingFrame; +import packetproxy.util.PacketProxyUtility; + +import java.time.Instant; + +import static packetproxy.quic.utils.Constants.PnSpaceType; +import static packetproxy.quic.utils.Constants.PnSpaceType.PnSpaceHandshake; +import static packetproxy.quic.utils.Constants.PnSpaceType.PnSpaceInitial; + +public class LossDetection { + + private final Connection conn; + private final ScheduledTimer scheduledTimer; + + public LossDetection(Connection conn) { + this.conn = conn; + this.scheduledTimer = new ScheduledTimer(this::onLossDetectionTimeout); + } + + public synchronized void setLossDetectionTimer() { + Instant earliestLossTime = this.conn.getPnSpaces().getEarliestLossTime(); + if (earliestLossTime != Instant.MAX) { + /* + * Time threshold loss detection. + * パケットロスが発生する時間にタイマーをセット + */ + scheduledTimer.update(earliestLossTime); + return; + } + if (this.conn.isServerAntiAmplifiedLimit()) { + /* + * The server's timer is not set if nothing can be sent. + * anti-amplification状態のときは、タイマーはセットしない。 + * ただ、PacketProxyでは、anti-amplificationは未実装なのでここに入らない。 + */ + scheduledTimer.cancel(); + return; + } + if (!this.conn.getPnSpaces().hasAnyAckElicitingPacket() && this.conn.peerCompletedAddressValidation()){ + /* + * There is nothing to detect lost, so no timer is set. + * However, the client needs to arm the timer if the + * server might be blocked by the anti-amplification limit. + * 何もパケットを送信していないし、anti-amplificationも解除されているので、タイマーをセットする必要がない + */ + scheduledTimer.cancel(); + return; + } + /* + * 最後にAckElicitingパケットを投げた時刻から計算したAckが返ってくる制限時間にタイマーをセット + */ + scheduledTimer.update(conn.getPto().getPtoTime()); + } + + private synchronized void onLossDetectionTimeout() { + // PacketProxyUtility.getInstance().packetProxyLogErr("[QUIC] LossDetection Timeout!"); + + var earliestLossTimeAndSpace = this.conn.getPnSpaces().getEarliestLossTimeAndSpace(); + Instant earliestLossTime = earliestLossTimeAndSpace.getLeft(); + PnSpaceType earliestPnSpaceType = earliestLossTimeAndSpace.getRight(); + + if (earliestLossTime != Instant.MAX) { + /* + * Time threshold loss Detection + * パケットロスが発生したので該当パケットを再送 + */ + LostPackets lostPackets = this.conn.getPnSpace(earliestPnSpaceType).detectAndRemoveLostPackets(); + assert (!lostPackets.isEmpty()); + this.conn.getPnSpace(earliestPnSpaceType).OnPacketsLost(lostPackets); + setLossDetectionTimer(); + return; + } + if (!this.conn.getPnSpaces().hasAnyAckElicitingPacket()) { + if (this.conn.peerAwaitingAddressValidation()) { + /* + * Client sends an anti-deadlock packet: Initial is padded to earn more anti-amplification credit, + * a Handshake packet proves address ownership. + * サーバーがanti-amplificationのため、何も送信できない状態に陥っているため、何かパケットを投げて送信できるようにする + */ + if (this.conn.getHandshakeState().hasHandshakeKeys()) { + this.conn.getPnSpace(PnSpaceHandshake).addSendFrame(new PingFrame()); + } else { + this.conn.getPnSpace(PnSpaceInitial).addSendFrame(new PingFrame()); + } + } + } else { + /* + * PTO. Send new data if available, else retransmit old data. + * If neither is available, send a single PING frame. + * AckElicitingパケットを投げたのに、Ackが返ってこないので催促する + */ + PnSpaceType ptoPnSpaceType = this.conn.getPto().getPtoSpaceType(); + PacketProxyUtility.getInstance().packetProxyLogErr( + String.format("[QUIC] Probe Timeout: send ack-eliciting packet (%s:%s)", + this.conn.getRole(), + ptoPnSpaceType.toString())); + + this.conn.getPnSpace(ptoPnSpaceType).addSendFrame(new PingFrame()); + } + this.conn.getPto().incrementPtoCount(); + setLossDetectionTimer(); + } + +} \ No newline at end of file diff --git a/src/main/java/core/packetproxy/quic/service/Pto.java b/src/main/java/core/packetproxy/quic/service/Pto.java new file mode 100644 index 0000000..193991c --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/Pto.java @@ -0,0 +1,98 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service; + + +import org.apache.commons.lang3.tuple.ImmutablePair; +import packetproxy.quic.utils.Constants; +import packetproxy.quic.utils.Constants.*; +import packetproxy.quic.service.connection.Connection; + +import java.time.Instant; + +import static packetproxy.quic.utils.Constants.PnSpaceType.*; + + +public class Pto { + + private final Connection conn; + private long ptoCount = 0; + + public Pto(Connection conn) { + this.conn = conn; + } + + public void clearPtoCount() { + this.ptoCount = 0; + } + + public void incrementPtoCount() { + this.ptoCount++; + } + + public Instant getPtoTime() { + return this.getPtoTimeAndSpace().getLeft(); + } + + public PnSpaceType getPtoSpaceType() { + return this.getPtoTimeAndSpace().getRight(); + } + + public ImmutablePair getPtoTimeAndSpace() { + long smoothedRtt = this.conn.getRttEstimator().getSmoothedRtt(); + long rttVar = this.conn.getRttEstimator().getRttVar(); + + long duration = (smoothedRtt + Math.max(4 * rttVar, Constants.kGranularity)) * (long)(Math.pow(2, this.ptoCount)); + + // Anti-deadlock PTO starts from the current time + if (this.conn.peerAwaitingAddressValidation()) { + if (this.conn.getHandshakeState().hasNoHandshakeKeys()) { + return ImmutablePair.of( + Instant.now().plusMillis(duration), + PnSpaceInitial); + } else { + return ImmutablePair.of( + Instant.now().plusMillis(duration), + PnSpaceHandshake); + } + } + + Instant ptoTimeout = Instant.MAX; + PnSpaceType ptoPnSpaceType = PnSpaceInitial; + + for (PnSpaceType pnSpaceType : PnSpaceType.values()) { + if (!this.conn.getPnSpace(pnSpaceType).hasAnyAckElicitingPacket()) { + continue; + } + if (pnSpaceType == PnSpaceApplicationData) { + // Skip Application Data until handshake confirmed. + if (this.conn.getHandshakeState().isNotConfirmed()) { + return ImmutablePair.of(ptoTimeout, ptoPnSpaceType); + } + // Include max_ack_delay and backoff for Application Data. + duration += this.conn.getRttEstimator().getMaxAckDelay() * (long)(Math.pow(2, this.ptoCount)); + } + Instant t = this.conn.getPnSpace(pnSpaceType).getTimeOfLastAckElicitingPacket().plusMillis(duration); + if (t.isBefore(ptoTimeout)) { + ptoTimeout = t; + ptoPnSpaceType = pnSpaceType; + } + } + return ImmutablePair.of(ptoTimeout, ptoPnSpaceType); + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/RttEstimator.java b/src/main/java/core/packetproxy/quic/service/RttEstimator.java new file mode 100644 index 0000000..80668ee --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/RttEstimator.java @@ -0,0 +1,82 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service; + +import lombok.Getter; +import packetproxy.quic.service.connection.Connection; +import packetproxy.quic.utils.Constants; + +import java.time.Duration; +import java.time.Instant; + +import static java.lang.Math.min; + +@Getter +public class RttEstimator { + + private final Connection conn; + private long initialRtt = 333; + private Instant firstRttSample = Instant.MIN; + private long minRtt = 0; + private long smoothedRtt = initialRtt; + private long rttVar = initialRtt / 2; + private long latestRtt = 0; + private long maxAckDelay = 25; /* a default of 25 milliseconds is assumed (rfc9000) */ + + public RttEstimator(Connection conn) { + this.conn = conn; + } + + /** + * ref: https://www.rfc-editor.org/rfc/rfc9002.html#section-a.7 + */ + public void updateRtt(Instant timeSent, long ackDelay) { + + Instant timeReceived = Instant.now(); + this.latestRtt = Duration.between(timeReceived, timeSent).toMillis(); + + if (firstRttSample == Instant.MIN) { + this.minRtt = this.latestRtt; + this.smoothedRtt = this.latestRtt; + this.rttVar = this.latestRtt / 2; + this.firstRttSample = timeReceived; + } + + // min_rtt ignores acknowledgment delay. + this.minRtt = min(this.minRtt, this.latestRtt); + + // Limit ack_delay by max_ack_delay after handshake confirmation. + if (conn.getHandshakeState().isConfirmed()) { + ackDelay = min(ackDelay, this.maxAckDelay); + } + + // Adjust for acknowledgment delay if plausible. + long adjustedRtt = this.latestRtt; + if (this.latestRtt >= this.minRtt + ackDelay) { + adjustedRtt = this.latestRtt - ackDelay; + } + + long currentRttVar = Math.abs(this.smoothedRtt - adjustedRtt); + this.rttVar = (3 * this.rttVar + currentRttVar) / 4; + this.smoothedRtt = (7 * this.smoothedRtt + adjustedRtt) / 8; + } + + public long getLossDelay() { + // Minimum time of kGranularity before packets are deemed lost. + return (long)(Constants.kTimeThreshold * Math.max(this.latestRtt, this.smoothedRtt)); + } +} diff --git a/src/main/java/core/packetproxy/quic/service/connection/ClientConnection.java b/src/main/java/core/packetproxy/quic/service/connection/ClientConnection.java new file mode 100644 index 0000000..9b67d06 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/connection/ClientConnection.java @@ -0,0 +1,87 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.connection; + +import lombok.Getter; +import packetproxy.common.Endpoint; +import packetproxy.model.CAs.CA; +import packetproxy.quic.service.handshake.ServerHandshake; +import packetproxy.quic.utils.Constants; +import packetproxy.quic.value.ConnectionId; +import packetproxy.quic.value.ConnectionIdPair; +import packetproxy.util.PacketProxyUtility; + +import javax.crypto.AEADBadTagException; +import java.net.DatagramPacket; +import java.net.DatagramSocket; +import java.net.InetSocketAddress; + +@Getter +public class ClientConnection extends Connection implements Endpoint { + + private final int listenPortNum; + + private final ServerHandshake handshake; + + public ClientConnection(ConnectionIdPair connIdPair, ConnectionId initialSecret, DatagramSocket socket, InetSocketAddress peerAddr, CA ca, int listenPortNum) throws Exception { + super(Constants.Role.SERVER, connIdPair, initialSecret, socket, peerAddr); + this.listenPortNum = listenPortNum; + this.handshake = new ServerHandshake(this, ca); + super.start(); + } + + /** + * ClientHello内部のSNIフィールドを取得する (Blocking) + */ + public String getSNI() throws Exception { + return this.handshake.getSNI(); + } + + /** + * クライアントからの受信パケット -> 処理 -> パケットキュー + */ + public void recvUdpPacket(DatagramPacket udpPacket) { + awaitingReceivedPackets.put(udpPacket); + awaitingReceivedPackets.forEachAndRemovedIfReturnTrue(packet -> { + try { + clientPacketParser.parseOnePacket(packet); + return true; + } catch (AEADBadTagException e) { + PacketProxyUtility.getInstance().packetProxyLogErr("[QUIC] Error: malformed packet received"); + return true; /* 読み飛ばす */ + } catch (Exception e) { + e.printStackTrace(); + return false; + } + }); + } + + @Override + public boolean peerCompletedAddressValidation() { + return true; + } + + @Override + public int getLocalPort() { + return this.listenPortNum; + } + + @Override + public String getName() { + return "QUIC Client Endpoint"; + } +} diff --git a/src/main/java/core/packetproxy/quic/service/connection/ClientConnections.java b/src/main/java/core/packetproxy/quic/service/connection/ClientConnections.java new file mode 100644 index 0000000..4ea50e0 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/connection/ClientConnections.java @@ -0,0 +1,106 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.connection; + +import lombok.Getter; +import org.apache.commons.lang3.ArrayUtils; +import packetproxy.model.CAs.CA; +import packetproxy.quic.value.ConnectionId; +import packetproxy.quic.value.ConnectionIdPair; +import packetproxy.quic.service.packet.QuicPacketParser; + +import java.net.DatagramPacket; +import java.net.DatagramSocket; +import java.net.InetSocketAddress; +import java.util.*; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +@Getter +public class ClientConnections { + private final Map connes = new HashMap<>(); + private final List alreadyReceivedInitialSecrets = new ArrayList<>(); + private final ExecutorService executor = Executors.newFixedThreadPool(2); + private final int listenPort; + private final CA ca; + private DatagramSocket socket; + + + public ClientConnections(int listenPort, CA ca) { + this.listenPort = listenPort; + this.ca = ca; + try { + this.socket = new DatagramSocket(listenPort); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public void close() { + if (!this.socket.isClosed()) { + this.connes.values().forEach(Connection::close); + this.executor.shutdownNow(); + this.socket.close(); + } + } + + /** + * Blocking until accepting UDP packet. + */ + public ClientConnection accept() throws Exception { + while (true) { + DatagramPacket udpPacket = recvUdpPacket(); + ConnectionId destConnId = QuicPacketParser.getDestConnectionId(udpPacket.getData()); + + if (find(destConnId).isPresent()) { + find(destConnId).get().recvUdpPacket(udpPacket); + } else { + Optional conn = this.create(destConnId, new InetSocketAddress(udpPacket.getAddress(), udpPacket.getPort())); + if (conn.isPresent()) { + conn.get().recvUdpPacket(udpPacket); + return conn.get(); + } + } + } + } + + public Optional find(ConnectionId destConnId) { + ClientConnection conn = this.connes.get(destConnId); + return (conn != null) ? Optional.of(conn) : Optional.empty(); + } + + public Optional create(ConnectionId initialSecret, InetSocketAddress peerAddr) throws Exception { + if (alreadyReceivedInitialSecrets.contains(initialSecret)) { + /* 以前受信したことのある initialSecret を受信した。再送を意味するので無視 */ + return Optional.empty(); + } + alreadyReceivedInitialSecrets.add(initialSecret); + ConnectionIdPair connIdPair = ConnectionIdPair.generateRandom(); + ClientConnection conn = new ClientConnection(connIdPair, initialSecret, this.socket, peerAddr, this.ca, this.listenPort); + connes.put(connIdPair.getSrcConnId(), conn); + return Optional.of(conn); + } + + private DatagramPacket recvUdpPacket() throws Exception { + byte[] buf = new byte[4096]; + DatagramPacket udpPacket = new DatagramPacket(buf, 4096); + this.socket.receive(udpPacket); + udpPacket.setData(ArrayUtils.subarray(udpPacket.getData(), 0, udpPacket.getLength())); + return udpPacket; + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/connection/Connection.java b/src/main/java/core/packetproxy/quic/service/connection/Connection.java new file mode 100644 index 0000000..817e626 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/connection/Connection.java @@ -0,0 +1,251 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.connection; + +import lombok.Getter; +import packetproxy.common.Endpoint; +import packetproxy.common.PipeEndpoint; +import packetproxy.quic.service.LossDetection; +import packetproxy.quic.service.Pto; +import packetproxy.quic.service.RttEstimator; +import packetproxy.quic.service.connection.helper.AwaitingPackets; +import packetproxy.quic.service.handshake.Handshake; +import packetproxy.quic.service.handshake.HandshakeState; +import packetproxy.quic.service.key.Keys; +import packetproxy.quic.service.packet.QuicPacketParser; +import packetproxy.quic.service.pnspace.PnSpace; +import packetproxy.quic.service.pnspace.PnSpaces; +import packetproxy.quic.utils.Constants; +import packetproxy.quic.utils.Constants.PnSpaceType; +import packetproxy.quic.value.ConnectionId; +import packetproxy.quic.value.ConnectionIdPair; +import packetproxy.quic.value.QuicMessage; +import packetproxy.quic.value.SimpleBytes; +import packetproxy.quic.value.packet.QuicPacket; +import packetproxy.quic.value.packet.longheader.pnspace.HandshakePacket; +import packetproxy.quic.value.packet.longheader.pnspace.InitialPacket; +import packetproxy.quic.value.packet.shortheader.ShortHeaderPacket; + +import java.io.ByteArrayOutputStream; +import java.io.InputStream; +import java.io.InterruptedIOException; +import java.io.OutputStream; +import java.net.DatagramPacket; +import java.net.DatagramSocket; +import java.net.InetSocketAddress; +import java.nio.ByteBuffer; +import java.util.List; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +import static packetproxy.util.Throwing.rethrow; + +@Getter +public abstract class Connection implements Endpoint { + final ExecutorService executor = Executors.newFixedThreadPool(3); + final QuicPacketParser clientPacketParser; + final QuicPacketParser serverPacketParser; + final AwaitingPackets awaitingSendPackets = new AwaitingPackets(); + final AwaitingPackets awaitingReceivedPackets = new AwaitingPackets(); + final HandshakeState handshakeState = new HandshakeState(); + final Keys keys = new Keys(); + final Constants.Role role; + final DatagramSocket socket; + final Pto pto; + final LossDetection lossDetection; + final RttEstimator rttEstimator; + final PnSpaces pnSpaces; + final PipeEndpoint pipe; + final InetSocketAddress peerAddr; + ConnectionIdPair connIdPair; + ConnectionId initialSecret; + boolean serverAntiAmplifiedLimit = false; + + public Connection(Constants.Role role, ConnectionIdPair connIdPair, ConnectionId initialSecret, DatagramSocket socket, InetSocketAddress peerAddr) throws Exception { + this.role = role; + this.connIdPair = connIdPair; + this.socket = socket; + this.peerAddr = peerAddr; + this.clientPacketParser = new QuicPacketParser(this, keys.getClientKeys()); + this.serverPacketParser = new QuicPacketParser(this, keys.getServerKeys()); + this.pto = new Pto(this); + this.lossDetection = new LossDetection(this); + this.rttEstimator = new RttEstimator(this); + this.pnSpaces = new PnSpaces(this); + this.pipe = new PipeEndpoint(peerAddr); + this.connIdPair = connIdPair; + this.initialSecret = initialSecret; + this.keys.computeInitialKey(initialSecret); + } + + protected void start() throws Exception { + /* 送信パケットキュー -> 送信 */ + this.executor.submit(new Runnable() { + @Override + public void run() { + while (true) { + List packets = pnSpaces.pollSendPackets(); // Blocking here + awaitingSendPackets.put(packets); + awaitingSendPackets.forEachAndRemovedIfReturnTrue(packet -> { + try { + //if (role == Constants.Role.SERVER) { + // PacketProxyUtility.getInstance().packetProxyLog("[QUIC] CLIENT<--- " + packet); + //} else { + // PacketProxyUtility.getInstance().packetProxyLog("[QUIC] --->SERVER " + packet); + //} + if (packet instanceof InitialPacket) { + InitialPacket ip = (InitialPacket) packet; + if (keys.discardedInitialKey()) { + return true; /* Initialキーは破棄済みなのでInitialパケットは送信せずに破棄する */ + } + byte[] udpData = (role == Constants.Role.CLIENT) ? + ip.getBytes(keys.getClientKeys().getInitialKey(), getPnSpace(ip.getPnSpaceType()).getLargestAckedPn()): + ip.getBytes(keys.getServerKeys().getInitialKey(), getPnSpace(ip.getPnSpaceType()).getLargestAckedPn()); + sendUdpPacket(udpData); + return true; + } + if (packet instanceof HandshakePacket) { + HandshakePacket hp = (HandshakePacket) packet; + if (keys.discardedHandshakeKey()) { + return true; /* Handshakeキーは破棄済みなのでHandshakeパケットは送信せずに破棄する */ + } + byte[] udpData = (role == Constants.Role.CLIENT) ? + hp.getBytes(keys.getClientKeys().getHandshakeKey(), getPnSpace(hp.getPnSpaceType()).getLargestAckedPn()): + hp.getBytes(keys.getServerKeys().getHandshakeKey(), getPnSpace(hp.getPnSpaceType()).getLargestAckedPn()); + sendUdpPacket(udpData); + return true; + } + if (packet instanceof ShortHeaderPacket && keys.hasApplicationKey()) { + if (role == Constants.Role.CLIENT && getHandshakeState().isNotConfirmed()) { + return false; /* Handshakeが終わってからShortHeaderPacketを送信しないとサーバー側でエラーになってしまうので、後ほど送信 */ + } + ShortHeaderPacket sp = (ShortHeaderPacket) packet; + byte[] udpData = (role == Constants.Role.CLIENT) ? + sp.getBytes(keys.getClientKeys().getApplicationKey(), getPnSpace(sp.getPnSpaceType()).getLargestAckedPn()): + sp.getBytes(keys.getServerKeys().getApplicationKey(), getPnSpace(sp.getPnSpaceType()).getLargestAckedPn()); + sendUdpPacket(udpData); + return true; + } + } catch (Exception e) { + e.printStackTrace(); + } + return false; + }); + } + } + }); + + /* エンコーダー -> 送信パケットキュー */ + this.executor.submit(new Runnable() { + @Override + public void run() { + try { + InputStream in = pipe.getRawEndpoint().getInputStream(); + + /* + * ハンドシェイクが完了するまで待ってからエンコーダーからの入力をパケット化する + * ハンドシェイクが完了してApplicationKeyを得ていないとパケット化できないため + */ + if (role == Constants.Role.CLIENT) { + while (true) { + if (handshakeState.isConfirmed()) { + break; + } + Thread.sleep(100); + } + } + + byte[] readChunk = new byte[4096]; + ByteArrayOutputStream readQueue = new ByteArrayOutputStream(); + int length; + while ((length = in.read(readChunk)) > 0) { + readQueue.write(readChunk, 0, length); + ByteBuffer buffer = ByteBuffer.wrap(readQueue.toByteArray()); + QuicMessage.parse(buffer).forEach(rethrow(msg -> { + getPnSpace(Constants.PnSpaceType.PnSpaceApplicationData).addSendQuicMessage(msg); + })); + readQueue.reset(); + if (buffer.hasRemaining()) { + readQueue.write(SimpleBytes.parse(buffer, buffer.remaining()).getBytes()); + } + } + } catch (InterruptedIOException e) { + /* exception simply ignored */ + } catch (Exception e) { + e.printStackTrace(); + } + } + }); + } + + private void sendUdpPacket(byte[] data) throws Exception { + DatagramPacket udpPacket = new DatagramPacket(data, 0, data.length, this.peerAddr); + socket.send(udpPacket); + } + + public void updateDestConnId(ConnectionId destConnId) { + this.connIdPair = ConnectionIdPair.of(this.connIdPair.getSrcConnId(), destConnId); + } + + public PnSpace getPnSpace(PnSpaceType pnSpaceType) { + return this.pnSpaces.getPnSpace(pnSpaceType); + } + + public void close() { + try { + this.pipe.getRawEndpoint().getInputStream().close(); + this.pipe.getRawEndpoint().getOutputStream().close(); + this.executor.shutdownNow(); + } catch (Exception e) { + e.printStackTrace(); + } + } + + @Override + public InputStream getInputStream() throws Exception { + return this.pipe.getProxyRawEndpoint().getInputStream(); + } + + @Override + public OutputStream getOutputStream() throws Exception { + return this.pipe.getProxyRawEndpoint().getOutputStream(); + } + + @Override + public InetSocketAddress getAddress() { + return this.peerAddr; + } + + @Override + public int getLocalPort() { + return 0; + } + + @Override + public String getName() { + return "QUIC Endpoint"; + } + + public boolean peerAwaitingAddressValidation() { + return !this.peerCompletedAddressValidation(); + } + + public abstract boolean peerCompletedAddressValidation(); + + public abstract Handshake getHandshake(); + +} diff --git a/src/main/java/core/packetproxy/quic/service/connection/ServerConnection.java b/src/main/java/core/packetproxy/quic/service/connection/ServerConnection.java new file mode 100644 index 0000000..0a36cd4 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/connection/ServerConnection.java @@ -0,0 +1,92 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.connection; + +import lombok.Getter; +import lombok.SneakyThrows; +import org.apache.commons.lang3.ArrayUtils; +import packetproxy.PrivateDNSClient; +import packetproxy.quic.service.handshake.ClientHandshake; +import packetproxy.quic.utils.AwaitingException; +import packetproxy.quic.utils.Constants; +import packetproxy.quic.value.ConnectionIdPair; + +import java.net.DatagramPacket; +import java.net.DatagramSocket; +import java.net.InetSocketAddress; + +@Getter +public class ServerConnection extends Connection { + + private final ClientHandshake handshake; + + public ServerConnection(ConnectionIdPair connIdPair, String serverName, int serverPort) throws Exception { + super(Constants.Role.CLIENT, + connIdPair, + connIdPair.getDestConnId(), + new DatagramSocket(), + new InetSocketAddress(PrivateDNSClient.getByName(serverName), serverPort)); + this.handshake = new ClientHandshake(this); + this.handshake.start(serverName); + super.executor.submit(new RecvUdpPacketsLoop()); + super.start(); + } + + /* サーバから受信 -> 処理 -> SendPacketキュー */ + public class RecvUdpPacketsLoop implements Runnable { + @Override + @SneakyThrows + public void run() { + while (true) { + DatagramPacket udpPacket = recvUdpPacket(); // Blocking here + awaitingReceivedPackets.put(udpPacket); + awaitingReceivedPackets.forEachAndRemovedIfReturnTrue(packet -> { + try { + serverPacketParser.parseOnePacket(packet); + return true; + } catch (AwaitingException e) { + return false; + } catch (Exception e) { + e.printStackTrace(); + return false; + } + }); + } + } + } + + private DatagramPacket recvUdpPacket() throws Exception { + byte[] buf = new byte[4096]; + DatagramPacket recvPacket = new DatagramPacket(buf, 4096); + socket.receive(recvPacket); + recvPacket.setData(ArrayUtils.subarray(recvPacket.getData(), 0, recvPacket.getLength())); + return recvPacket; + } + + @Override + public boolean peerCompletedAddressValidation() { + // Servers complete address validation when a protected packet is received. + return this.handshakeState.isAckReceived(); + } + + @Override + public String getName() { + return "QUIC Server Endpoint"; + } + +} + diff --git a/src/main/java/core/packetproxy/quic/service/connection/helper/AwaitingPackets.java b/src/main/java/core/packetproxy/quic/service/connection/helper/AwaitingPackets.java new file mode 100644 index 0000000..abec1bf --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/connection/helper/AwaitingPackets.java @@ -0,0 +1,61 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.connection.helper; + +import java.util.ArrayList; +import java.util.List; +import java.util.Queue; +import java.util.concurrent.ConcurrentLinkedDeque; +import java.util.function.Predicate; + +public class AwaitingPackets { + + private final Queue awaitings = new ConcurrentLinkedDeque<>(); + + public synchronized void put(List packets) { + awaitings.addAll(packets); + } + + public synchronized void put(T packet) { + this.awaitings.offer(packet); + } + + public synchronized T get() { + return this.awaitings.poll(); + } + + /** + * 全ての要素に対して関数を適用する。関数の結果がtrueになった場合は要素から削除 + */ + public synchronized void forEachAndRemovedIfReturnTrue(Predicate predicate) { + T e; + List targets = new ArrayList<>(); + while ((e = awaitings.poll()) != null) { + targets.add(e); + } + List failed = new ArrayList<>(); + targets.forEach(target -> { + if (!predicate.test(target)) { + failed.add(target); + } + }); + if (!failed.isEmpty()) { + this.awaitings.addAll(failed); + } + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/frame/FrameParser.java b/src/main/java/core/packetproxy/quic/service/frame/FrameParser.java new file mode 100644 index 0000000..f27350c --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/frame/FrameParser.java @@ -0,0 +1,82 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.frame; + +import com.google.common.collect.Sets; +import lombok.SneakyThrows; +import packetproxy.quic.value.frame.Frame; +import packetproxy.quic.value.frame.UnknownFrame; + +import javax.tools.*; +import java.lang.reflect.Modifier; +import java.nio.ByteBuffer; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +public class FrameParser { + + private static final String framePackage = "packetproxy.quic.value.frame"; + private static final Class frameClass = Frame.class; + private static Map> frameMap; + + @SneakyThrows + private static void createFrameMap() { + frameMap = new HashMap<>(); + JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); + JavaFileManager fm = compiler.getStandardFileManager(new DiagnosticCollector(), null, null); + + Set kind = Sets.newHashSet(JavaFileObject.Kind.CLASS); + for (JavaFileObject f : fm.list(StandardLocation.CLASS_PATH, framePackage, kind, true)) { + Path encode_file_path = Paths.get(f.getName()); + String encode_class_path = encode_file_path.toString() + .replaceAll("/",".") + .replaceFirst("^.*" + framePackage, framePackage) + .replaceAll("\\.class.*$", ""); + Class klass = Class.forName(encode_class_path); + if(frameClass.isAssignableFrom(klass) && !Modifier.isAbstract(klass.getModifiers())){ + List types = (List) klass.getMethod("supportedTypes").invoke(null); + types.forEach(type -> frameMap.put(type, (Class)klass)); + } + } + } + + static private Frame createInstance(Class klass, ByteBuffer buffer) throws Exception { + return (Frame) klass.getMethod("parse", ByteBuffer.class).invoke(null, buffer); + } + + static public Frame create(ByteBuffer buffer) throws Exception { + int saved = buffer.position(); + byte type = buffer.get(); + buffer.position(saved); + + if (frameMap == null) { + createFrameMap(); + } + + Class klass = frameMap.get(type); + if (klass == null) { + throw new Exception(String.format("Error: unknown frame type: %x", type)); + } else { + return createInstance(klass, buffer); + } + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/frame/Frames.java b/src/main/java/core/packetproxy/quic/service/frame/Frames.java new file mode 100644 index 0000000..084a549 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/frame/Frames.java @@ -0,0 +1,97 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.frame; + +import com.google.common.collect.ImmutableList; +import lombok.Value; +import packetproxy.quic.value.frame.AckFrame; +import packetproxy.quic.value.frame.Frame; + +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.Optional; +import java.util.stream.Collectors; + +@Value +public class Frames implements Iterable { + + static public final Frames empty = new Frames(ImmutableList.of()); + + static public Frames parse(byte[] bytes) { + return Frames.parse(ByteBuffer.wrap(bytes)); + } + + static public Frames parse(ByteBuffer buffer) { + try { + List frames = new ArrayList<>(); + while (buffer.remaining() > 0) { + Frame frame = FrameParser.create(buffer); + frames.add(frame); + } + return new Frames(frames); + } catch (Exception e) { + e.printStackTrace(); + } + return Frames.empty; + } + + static public Frames of(Frame e1) { + return new Frames(ImmutableList.of(e1)); + } + + static public Frames of(Frame e1, Frame e2) { + return new Frames(ImmutableList.of(e1, e2)); + } + + static public Frames of(Frame e1, Frame e2, Frame e3) { + return new Frames(ImmutableList.of(e1, e2, e3)); + } + + static public Frames of(List frameList) { + return new Frames(new ArrayList<>(frameList)); + } + + List frames; + + public boolean isAckEliciting() { + return frames.stream().anyMatch(Frame::isAckEliciting); + } + + public boolean hasAckFrame() { + return frames.stream().anyMatch(frame -> frame instanceof AckFrame); + } + + public Optional getAckFrame() { + return frames.stream() + .filter(f -> f instanceof AckFrame) + .map(f -> (AckFrame)f) + .findFirst(); + } + + public String toString() { + return String.format("Frames(%s)", + frames.stream().map(Object::toString).collect(Collectors.joining(","))); + } + + @Override + public Iterator iterator() { + return frames.iterator(); + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/frame/FramesBuilder.java b/src/main/java/core/packetproxy/quic/service/frame/FramesBuilder.java new file mode 100644 index 0000000..17693af --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/frame/FramesBuilder.java @@ -0,0 +1,60 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.frame; + +import packetproxy.quic.value.SimpleBytes; +import packetproxy.quic.value.frame.Frame; +import packetproxy.quic.value.frame.PaddingFrame; + +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.List; + +public class FramesBuilder { + List frames = new ArrayList<>(); + + public FramesBuilder add(Frame frame) { + frames.add(frame); + return this; + } + + /* + * Clients MUST ensure that UDP datagrams containing Initial packets have + * UDP payloads of at least 1200 bytes, adding PADDING frames as necessary. + */ + public FramesBuilder addPaddingFramesToEnsure1200Bytes() { + long currentBytesLength = getBytes().length; + long paddingFrameLength = 1200 - currentBytesLength; + if (paddingFrameLength > 0) { + this.add(new PaddingFrame(paddingFrameLength)); + } + return this; + } + + public byte[] getBytes() { + ByteBuffer buffer = ByteBuffer.allocate(1500); + for (Frame frame: frames) { + buffer.put(frame.getBytes()); + } + buffer.flip(); + return SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + } + + public Frames build() { + return new Frames(frames); + } +} diff --git a/src/main/java/core/packetproxy/quic/service/framegenerator/AckFrameGenerator.java b/src/main/java/core/packetproxy/quic/service/framegenerator/AckFrameGenerator.java new file mode 100644 index 0000000..b2b1ed5 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/framegenerator/AckFrameGenerator.java @@ -0,0 +1,120 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.framegenerator; + +import packetproxy.quic.service.framegenerator.helper.ReceivedPacketNumbers; +import packetproxy.quic.value.frame.AckFrame; +import packetproxy.quic.value.frame.helper.AckRange; +import packetproxy.quic.value.frame.helper.AckRanges; +import packetproxy.quic.value.PacketNumber; + +import java.util.ArrayList; +import java.util.List; + +public class AckFrameGenerator { + private long largestAckedPn = -1; + private long smallestValidPn = 0; + private ReceivedPacketNumbers receivedPacketNumbers = new ReceivedPacketNumbers(); + + public void received(PacketNumber packetNumber) { + this.received(packetNumber.getNumber()); + } + + public void received(long receivedPn) { + if (receivedPn < this.smallestValidPn) { + return; + } + if (this.largestAckedPn < receivedPn) { + for (long i = this.largestAckedPn +1; i < receivedPn; i++) { + this.receivedPacketNumbers.unreceived(i); + } + this.receivedPacketNumbers.received(receivedPn); + this.largestAckedPn = receivedPn; + } + else if (receivedPn < this.largestAckedPn) { + this.receivedPacketNumbers.received(receivedPn); + } + } + + public void confirmedAckFrame(AckFrame ackFrameConfirmedByPeer) { + this.smallestValidPn = ackFrameConfirmedByPeer.getLargestAcknowledged()+1; + receivedPacketNumbers.clearLessThan(this.smallestValidPn); + if (largestAckedPn == ackFrameConfirmedByPeer.getLargestAcknowledged()) { + largestAckedPn = -1; + } + } + + private boolean ackRangeExists(long packetNumber) { + // 最低でも2個分スペースがないと、AckRangeを生成できない + return packetNumber >= this.smallestValidPn + 2; + } + + public AckFrame generateAckFrame() { + if (largestAckedPn == -1) { + return null; + } + long smallestOfRange = this.receivedPacketNumbers.getSmallestOfRange(this.largestAckedPn, this.smallestValidPn); + long firstAckRange = this.largestAckedPn - smallestOfRange; + if (!ackRangeExists(smallestOfRange)) { + return new AckFrame(this.largestAckedPn, 0, 0, firstAckRange, AckRanges.emptyAckRanges); + } + AckRanges ackRanges = generateAckRanges(smallestOfRange); + + return new AckFrame(this.largestAckedPn, 0, ackRanges.size(), firstAckRange, ackRanges); + } + + public PacketNumber getLargestAckedPn() { + return this.largestAckedPn == -1 ? + PacketNumber.Infinite : + PacketNumber.of(this.largestAckedPn); + } + + public AckRanges generateAckRanges(long smallestOfRange) { + List ackRanges = new ArrayList<>(); + while (ackRangeExists(smallestOfRange)) { + long largestOfGap = smallestOfRange - 1; + AckRange ackRange = generateAckRange(largestOfGap); + if (ackRange == null) { + break; + } + ackRanges.add(ackRange); + smallestOfRange -= ackRange.size(); + } + return new AckRanges(ackRanges); + } + + public AckRange generateAckRange(long largestOfGap) { + if (this.receivedPacketNumbers.isReceived(largestOfGap)) { + System.err.println(String.format("largestGap(%d) is not a gap", largestOfGap)); + return null; + } + + long smallestOfGap = this.receivedPacketNumbers.getSmallestOfGap(largestOfGap, this.smallestValidPn); + long gap = largestOfGap - smallestOfGap; + + if (smallestOfGap == this.smallestValidPn) { + return null; + } + + long largestOfRange = smallestOfGap - 1; + long smallestOfRange = this.receivedPacketNumbers.getSmallestOfRange(largestOfRange, this.smallestValidPn); + long range = largestOfRange - smallestOfRange; + + return new AckRange(gap, range); + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/framegenerator/CryptoFramesToMessages.java b/src/main/java/core/packetproxy/quic/service/framegenerator/CryptoFramesToMessages.java new file mode 100644 index 0000000..34caa60 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/framegenerator/CryptoFramesToMessages.java @@ -0,0 +1,139 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.framegenerator; + +import lombok.SneakyThrows; +import net.luminis.tls.ProtectionKeysType; +import net.luminis.tls.TlsProtocolException; +import net.luminis.tls.handshake.*; +import org.apache.commons.lang3.ArrayUtils; +import packetproxy.quic.value.frame.CryptoFrame; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +public class CryptoFramesToMessages { + + static public HandshakeMessage convertToHandshakeMessage(byte[] handshakeMsgBytes) throws Exception { + TlsMessageParser parser = new TlsMessageParser(); + DebugMessageProcessor processor = new DebugMessageProcessor(); + return parser.parseAndProcessHandshakeMessage(ByteBuffer.wrap(handshakeMsgBytes), processor, ProtectionKeysType.None); + } + + private final List cryptoFrames = new ArrayList<>(); + private final ByteArrayOutputStream messages = new ByteArrayOutputStream(); + private int nextMessageLength; + private int alreadyParsedBytes; + + + public CryptoFramesToMessages() { + this.nextMessageLength = 0; + this.alreadyParsedBytes = 0; + } + + public void write(CryptoFrame cryptoFrame) { + cryptoFrames.add(cryptoFrame); + } + + public List getHandshakeMessages() { + List messages = new ArrayList<>(); + for (var msgOpt = getHandshakeMessage(); msgOpt.isPresent(); msgOpt = getHandshakeMessage()) { + messages.add(msgOpt.get()); + } + return messages; + } + + @SneakyThrows + public Optional getHandshakeMessage() { + + if (this.nextMessageLength == 0) { + if (this.messages.size() < 4) { /* header(4B) = messageType(1B) + messageLength(3B) */ + if (!refillOneCryptoFrameToNextMessageBuffer(this.alreadyParsedBytes + this.messages.size())) { + return Optional.empty(); + } + } + byte[] data = this.messages.toByteArray(); + this.nextMessageLength = 4; /* header(4B) */ + this.nextMessageLength += ((data[1] & 0xff) << 16) | ((data[2] & 0xff) << 8) | (data[3] & 0xff); + } + + while (this.messages.size() < this.nextMessageLength) { + if (!refillOneCryptoFrameToNextMessageBuffer(this.alreadyParsedBytes + this.messages.size())) { + return Optional.empty(); + } + } + + byte[] messagesBytes = this.messages.toByteArray(); + byte[] message = ArrayUtils.subarray(messagesBytes, 0, this.nextMessageLength); + byte[] remaining = ArrayUtils.subarray(messagesBytes, this.nextMessageLength, messagesBytes.length); + this.messages.reset(); + this.messages.write(remaining); /* 読み過ぎた分は書き戻す */ + this.nextMessageLength = 0; + this.alreadyParsedBytes += message.length; + + TlsMessageParser parser = new TlsMessageParser(); + DebugMessageProcessor processor = new DebugMessageProcessor(); + HandshakeMessage handshakeMessage = parser.parseAndProcessHandshakeMessage(ByteBuffer.wrap(message), processor, ProtectionKeysType.None); + return Optional.of(handshakeMessage); + } + + private Optional getCryptoFrameByOffset(long requiredOffset) { + return cryptoFrames.stream().filter(frame -> frame.getOffset() == requiredOffset).findFirst(); + } + + @SneakyThrows + private boolean refillOneCryptoFrameToNextMessageBuffer(long offset) { + Optional cryptoFrameOptional = getCryptoFrameByOffset(offset); + if (cryptoFrameOptional.isPresent()) { + this.messages.write(cryptoFrameOptional.get().getData()); + return true; + } + return false; + } + + static private class DebugMessageProcessor implements MessageProcessor { + @Override + public void received(ClientHello ch, ProtectionKeysType protectedBy) throws TlsProtocolException, IOException { + } + @Override + public void received(ServerHello sh, ProtectionKeysType protectedBy) throws TlsProtocolException, IOException { + } + @Override + public void received(EncryptedExtensions ee, ProtectionKeysType protectedBy) throws TlsProtocolException, IOException { + } + @Override + public void received(CertificateMessage cm, ProtectionKeysType protectedBy) throws TlsProtocolException, IOException { + } + @Override + public void received(CertificateVerifyMessage cv, ProtectionKeysType protectedBy) throws TlsProtocolException, IOException { + } + @Override + public void received(FinishedMessage fm, ProtectionKeysType protectedBy) throws TlsProtocolException, IOException { + } + @Override + public void received(NewSessionTicketMessage nst, ProtectionKeysType protectedBy) throws TlsProtocolException, IOException { + } + @Override + public void received(CertificateRequestMessage cr, ProtectionKeysType protectedBy) throws TlsProtocolException, IOException { + } + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/framegenerator/MessagesToCryptoFrames.java b/src/main/java/core/packetproxy/quic/service/framegenerator/MessagesToCryptoFrames.java new file mode 100644 index 0000000..21507f1 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/framegenerator/MessagesToCryptoFrames.java @@ -0,0 +1,58 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.framegenerator; + +import net.luminis.tls.handshake.HandshakeMessage; +import org.apache.commons.lang3.ArrayUtils; +import packetproxy.quic.value.frame.CryptoFrame; +import packetproxy.quic.service.frame.Frames; +import packetproxy.quic.service.frame.FramesBuilder; + +import java.util.ArrayList; +import java.util.List; + +public class MessagesToCryptoFrames { + private final List handshakeMessages = new ArrayList<>(); + private long offset = 0; + + public synchronized void write(HandshakeMessage handshakeMessage) { + this.handshakeMessages.add(handshakeMessage); + } + + + public synchronized Frames toCryptoFrames() { + FramesBuilder framesBuilder = new FramesBuilder(); + + for (HandshakeMessage msg : handshakeMessages) { + byte[] msgBytes = msg.getBytes(); + int msgLen = msgBytes.length; + int msgOff = 0; + while (msgLen > 0) { + int subMsgLen = Math.min(msgLen, 1200); + byte[] subMsg = ArrayUtils.subarray(msgBytes, msgOff, msgOff+subMsgLen); + CryptoFrame cryptoFrame = new CryptoFrame(this.offset, subMsg); + framesBuilder.add(cryptoFrame); + this.offset += subMsgLen; + msgOff += subMsgLen; + msgLen -= subMsgLen; + } + } + this.handshakeMessages.clear(); /* remove all messages */ + return framesBuilder.build(); + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/framegenerator/MessagesToStreamFrames.java b/src/main/java/core/packetproxy/quic/service/framegenerator/MessagesToStreamFrames.java new file mode 100644 index 0000000..7022e8f --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/framegenerator/MessagesToStreamFrames.java @@ -0,0 +1,81 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.framegenerator; + +import org.apache.commons.lang3.ArrayUtils; +import packetproxy.quic.service.frame.Frames; +import packetproxy.quic.value.QuicMessage; +import packetproxy.quic.value.frame.Frame; +import packetproxy.quic.value.frame.StreamFrame; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class MessagesToStreamFrames { + + private final List frameList = new ArrayList<>(); + private final Map continuousStreamMap = new HashMap<>(); + + public synchronized void put(QuicMessage msg) { + long streamId = msg.getStreamId(); + + if ((streamId & 0x02) == 0x00) { /* bi-directional stream */ + byte[] data = msg.getData(); + int remaining = data.length; + int subOffset = 0; + while (remaining > 0) { + int subLength = Math.min(remaining, 1200); + byte[] subData = ArrayUtils.subarray(data, subOffset, subOffset + subLength); + boolean finishFlag = (subOffset + subLength == data.length); + this.frameList.add(StreamFrame.of(streamId, subOffset, subLength, subData, finishFlag)); + remaining -= subLength; + subOffset += subLength; + } + + } else { /* uni-directional stream */ + Long offsetObj = this.continuousStreamMap.get(streamId); + long offset = 0; + if (offsetObj != null) { + offset = offsetObj; + } + byte[] data = msg.getData(); + int remaining = data.length; + int subOffset = 0; + while (remaining > 0) { + int subLength = Math.min(remaining, 1200); + byte[] subData = ArrayUtils.subarray(data, subOffset, subOffset + subLength); + this.frameList.add(StreamFrame.of(streamId, offset, subLength, subData, false)); + remaining -= subLength; + subOffset += subLength; + offset += subLength; + } + this.continuousStreamMap.put(streamId, offset); + } + } + + /** + * get and remove all StreamFrames + */ + public synchronized Frames get() { + Frames frames = Frames.of(this.frameList); + this.frameList.clear(); + return frames; + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/framegenerator/StreamFramesToMessages.java b/src/main/java/core/packetproxy/quic/service/framegenerator/StreamFramesToMessages.java new file mode 100644 index 0000000..2fc281e --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/framegenerator/StreamFramesToMessages.java @@ -0,0 +1,83 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.framegenerator; + +import lombok.SneakyThrows; +import packetproxy.quic.service.framegenerator.helper.ContinuousStream; +import packetproxy.quic.service.framegenerator.helper.OneshotStream; +import packetproxy.quic.value.frame.StreamFrame; +import packetproxy.quic.value.QuicMessage; + +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +public class StreamFramesToMessages { + + private final Map continuousStreamMap = new HashMap<>(); + private final Map oneshotStreamMap = new HashMap<>(); + + public void put(StreamFrame frame) { + long streamId = frame.getStreamId(); + if ((streamId & 0x02) == 0x00) { /* bi-directional */ + this.putToOneshot(frame); + } else { /* uni-directional */ + this.putToContinuous(frame); + } + } + + private void putToContinuous(StreamFrame frame) { + long streamId = frame.getStreamId(); + if (!continuousStreamMap.containsKey(streamId)) { + continuousStreamMap.put(streamId, new ContinuousStream(streamId)); + } + this.continuousStreamMap.get(streamId).put(frame); + } + + private void putToOneshot(StreamFrame frame) { + long streamId = frame.getStreamId(); + if (!oneshotStreamMap.containsKey(streamId)) { + oneshotStreamMap.put(streamId, new OneshotStream(streamId)); + } + this.oneshotStreamMap.get(streamId).put(frame); + } + + public Optional get(long streamId) { + if ((streamId & 0x02) == 0x00) { /* bi-directional */ + return this.getFromOneshot(streamId); + } else { /* uni-directional */ + return this.getFromContinuous(streamId); + } + } + + @SneakyThrows + private Optional getFromContinuous(long streamId) { + if (!this.continuousStreamMap.containsKey(streamId)) { + return Optional.empty(); + } + return this.continuousStreamMap.get(streamId).get(); + } + + @SneakyThrows + private Optional getFromOneshot(long streamId) { + if (!this.oneshotStreamMap.containsKey(streamId)) { + return Optional.empty(); + } + return this.oneshotStreamMap.get(streamId).get(); + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/framegenerator/helper/ContinuousStream.java b/src/main/java/core/packetproxy/quic/service/framegenerator/helper/ContinuousStream.java new file mode 100644 index 0000000..f6d6d00 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/framegenerator/helper/ContinuousStream.java @@ -0,0 +1,65 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.framegenerator.helper; + +import lombok.Getter; +import packetproxy.quic.value.QuicMessage; +import packetproxy.quic.value.frame.StreamFrame; + +import java.io.ByteArrayOutputStream; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +@Getter +public class ContinuousStream { + private final Map frameMap = new HashMap<>(); + private final long streamId; + private long currentOffset = 0; + private boolean finished = false; + + public ContinuousStream(long streamId) { + this.streamId = streamId; + } + + public void put(StreamFrame frame) { + if (frame.isFinished()) { + this.finished = true; + } + this.frameMap.put(frame.getOffset(), frame); + } + + public Optional get() throws Exception { + ByteArrayOutputStream data = new ByteArrayOutputStream(); + + StreamFrame frame = this.frameMap.get(this.currentOffset); + if (frame == null) { + return Optional.empty(); + } + data.write(frame.getStreamData()); + this.currentOffset += frame.getLength(); + + /* process continuous frame if they exist */ + while (this.frameMap.get(this.currentOffset) != null) { + StreamFrame extraFrame = this.frameMap.get(this.currentOffset); + data.write(extraFrame.getBytes()); + this.currentOffset += extraFrame.getLength(); + } + + return Optional.of(QuicMessage.of(this.streamId, data.toByteArray())); + } +} diff --git a/src/main/java/core/packetproxy/quic/service/framegenerator/helper/OneshotStream.java b/src/main/java/core/packetproxy/quic/service/framegenerator/helper/OneshotStream.java new file mode 100644 index 0000000..1198601 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/framegenerator/helper/OneshotStream.java @@ -0,0 +1,61 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.framegenerator.helper; + +import packetproxy.quic.value.frame.StreamFrame; +import packetproxy.quic.value.QuicMessage; + +import java.io.ByteArrayOutputStream; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +public class OneshotStream { + private final Map frameMap = new HashMap<>(); + private final long streamId; + private boolean lastFrameReceived = false; + private long totalLength = 0; + + public OneshotStream(long streamId) { + this.streamId = streamId; + } + + public void put(StreamFrame frame) { + if (frame.isFinished()) { + this.lastFrameReceived = true; + this.totalLength = frame.getOffset() + frame.getLength(); + } + this.frameMap.put(frame.getOffset(), frame); + } + + public Optional get() throws Exception { + if (!this.lastFrameReceived) { + return Optional.empty(); + } + long offset = 0; + ByteArrayOutputStream data = new ByteArrayOutputStream(); + while (offset < this.totalLength) { + StreamFrame frame = this.frameMap.get(offset); + if (frame == null) { + return Optional.empty(); + } + offset += frame.getLength(); + data.write(frame.getStreamData()); + } + return Optional.of(QuicMessage.of(this.streamId, data.toByteArray())); + } +} diff --git a/src/main/java/core/packetproxy/quic/service/framegenerator/helper/ReceivedPacketNumbers.java b/src/main/java/core/packetproxy/quic/service/framegenerator/helper/ReceivedPacketNumbers.java new file mode 100644 index 0000000..553b0ba --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/framegenerator/helper/ReceivedPacketNumbers.java @@ -0,0 +1,85 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.framegenerator.helper; + +import packetproxy.util.PacketProxyUtility; + +import java.util.TreeSet; + +public class ReceivedPacketNumbers { + private TreeSet unreceivedPacketNumbers = new TreeSet<>(); + + public void unreceived(long packetNumber) { + unreceivedPacketNumbers.add(packetNumber); + } + + public void received(long packetNumber) { + unreceivedPacketNumbers.remove(packetNumber); + } + + public boolean isReceived(long packetNumber) { + return !unreceivedPacketNumbers.contains(packetNumber); + } + + public boolean isUnreceived(long packetNumber) { + return unreceivedPacketNumbers.contains(packetNumber); + } + + public long getSmallestOfRange(long largestOfRange, long smallestValid) { + assert(smallestValid <= largestOfRange); + if (unreceivedPacketNumbers.contains(largestOfRange)) { + PacketProxyUtility.getInstance().packetProxyLogErr(String.format("[QUIC] Error: AckRange: %d isn't in ack_range", largestOfRange)); + return 0; + } + return getSmallestReceived(largestOfRange, smallestValid); + } + + public long getSmallestOfGap(long largestOfGap, long smallestValid) { + assert(smallestValid <= largestOfGap); + if (!unreceivedPacketNumbers.contains(largestOfGap)) { + PacketProxyUtility.getInstance().packetProxyLogErr(String.format("[QUIC] Error: AckRange: %d isn't in gap", largestOfGap)); + return 0; + } + return getSmallestUnreceived(largestOfGap, smallestValid); + } + + public void clearLessThan(long packetNumber) { + unreceivedPacketNumbers.removeIf(pn -> pn < packetNumber); + } + + private long getSmallestUnreceived(long largestOfGap, long smallestValid) { + assert(smallestValid <= largestOfGap); + for (long i = largestOfGap; i >= smallestValid; i--) { + if (!unreceivedPacketNumbers.contains(i)) { + return i+1; + } + } + return smallestValid; + } + + private long getSmallestReceived(long largestOfRange, long smallestValid) { + assert(smallestValid <= largestOfRange); + if (unreceivedPacketNumbers.isEmpty()) { // 全部受信済み + return smallestValid; + } + if (largestOfRange < unreceivedPacketNumbers.first()) { // 全部受信済み + return smallestValid; + } + return Math.max(smallestValid, unreceivedPacketNumbers.floor(largestOfRange)+1); + } + +} \ No newline at end of file diff --git a/src/main/java/core/packetproxy/quic/service/handshake/ClientHandshake.java b/src/main/java/core/packetproxy/quic/service/handshake/ClientHandshake.java new file mode 100644 index 0000000..c3d7ba5 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/handshake/ClientHandshake.java @@ -0,0 +1,161 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.handshake; + +import net.luminis.tls.*; +import net.luminis.tls.extension.ApplicationLayerProtocolNegotiationExtension; +import net.luminis.tls.extension.Extension; +import net.luminis.tls.handshake.*; +import packetproxy.quic.service.connection.Connection; +import packetproxy.quic.service.frame.Frames; +import packetproxy.quic.service.framegenerator.MessagesToCryptoFrames; +import packetproxy.quic.service.transportparameter.TransportParameters; +import packetproxy.quic.utils.Constants; + +import javax.net.ssl.X509TrustManager; +import java.io.IOException; +import java.security.cert.CertificateException; +import java.security.cert.X509Certificate; +import java.util.List; + +import static packetproxy.quic.service.handshake.HandshakeState.State.*; +import static packetproxy.quic.utils.Constants.PnSpaceType.PnSpaceHandshake; +import static packetproxy.quic.utils.Constants.PnSpaceType.PnSpaceInitial; + +public class ClientHandshake implements Handshake { + + private final Connection conn; + private final TlsClientEngine engine; + + public ClientHandshake(Connection conn) { + this.conn = conn; + this.engine = new TlsClientEngine(new MyClientMessageSender(), new MyClientTlsStatusEventHandler()); + this.engine.addSupportedCiphers(List.of(TlsConstants.CipherSuite.TLS_AES_128_GCM_SHA256)); + this.engine.add(new ApplicationLayerProtocolNegotiationExtension("h3")); + this.engine.setTrustManager(new X509TrustManager() { + @Override + public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException { + } + @Override + public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException { + } + @Override + public X509Certificate[] getAcceptedIssuers() { + return new X509Certificate[0]; + } + }); + this.engine.setHostnameVerifier(new HostnameVerifier() { + @Override + public boolean verify(String s, X509Certificate x509Certificate) { + return true; + } + }); + TransportParameters tp = new TransportParameters(Constants.Role.CLIENT); + tp.setInitSrcConnId(this.conn.getConnIdPair().getSrcConnId().getBytes()); + tp.setMaxUdpPayloadSize(1472); + tp.setAckDelayExponent(10); + tp.setMaxIdleTimeout(30_000); + tp.setOldMinAckDelay(25_000); + tp.setInitMaxStreamUni(10 * 1024); + tp.setInitMaxStreamBidi(10 * 1024); + tp.setInitMaxData(10L * 1024 * 1024 * 1024); + tp.setInitMaxStreamDataBidiLocal(10L * 1024 * 1024 * 1024); + tp.setInitMaxStreamDataBidiRemote(10L * 1024 * 1024 * 1024); + tp.setInitMaxStreamDataUni(10L * 1024 * 1024 * 1024); + tp.setActiveConnIdLimit(4); + this.engine.add(tp); + } + + @Override + public void received(Message message) throws Exception { + if (message instanceof ServerHello) { + this.engine.received((ServerHello) message, ProtectionKeysType.None); + } else if (message instanceof EncryptedExtensions) { + this.engine.received((EncryptedExtensions) message, ProtectionKeysType.Handshake); + } else if (message instanceof CertificateMessage) { + this.engine.received((CertificateMessage) message, ProtectionKeysType.Handshake); + } else if (message instanceof CertificateVerifyMessage) { + this.engine.received((CertificateVerifyMessage) message, ProtectionKeysType.Handshake); + } else if (message instanceof FinishedMessage) { + this.engine.received((FinishedMessage) message, ProtectionKeysType.Handshake); + } else if (message instanceof NewSessionTicketMessage) { + this.engine.received((NewSessionTicketMessage) message, ProtectionKeysType.Application); + } else { + System.err.println("Error: couldn't process message " + message); + } + } + + public void start(String serverName) throws Exception { + this.engine.setServerName(serverName); + this.engine.startHandshake(); + } + + class MyClientMessageSender implements ClientMessageSender { + @Override + public void send(ClientHello clientHello) throws IOException { + MessagesToCryptoFrames stream = conn.getPnSpace(PnSpaceInitial).getMsgToFrameCryptoStream(); + stream.write(clientHello); + Frames frames = stream.toCryptoFrames(); + conn.getPnSpace(PnSpaceInitial).addSendFrames(frames); + conn.getKeys().setClientRandom(clientHello.getClientRandom()); + } + @Override + public void send(FinishedMessage finishedMessage) throws IOException { + MessagesToCryptoFrames stream = conn.getPnSpace(PnSpaceHandshake).getMsgToFrameCryptoStream(); + stream.write(finishedMessage); + Frames frames = stream.toCryptoFrames(); + conn.getPnSpace(PnSpaceHandshake).addSendFrames(frames); + conn.getHandshakeState().transit(Confirmed); + } + @Override + public void send(CertificateMessage certificateMessage) throws IOException { + /* do nothing */ + } + @Override + public void send(CertificateVerifyMessage certificateVerifyMessage) { + /* do nothing */ + } + } + + class MyClientTlsStatusEventHandler implements TlsStatusEventHandler { + @Override + public void earlySecretsKnown() { + conn.getKeys().computeZeroRttKey(engine.getClientEarlyTrafficSecret()); + } + @Override + public void handshakeSecretsKnown() { + conn.getKeys().computeHandshakeKey(engine.getClientHandshakeTrafficSecret(), engine.getServerHandshakeTrafficSecret()); + conn.getHandshakeState().transit(HasHandshakeKeys); + } + @Override + public void handshakeFinished() { + conn.getKeys().computeApplicationKey(engine.getClientApplicationTrafficSecret(), engine.getServerApplicationTrafficSecret()); + conn.getHandshakeState().transit(HasAppKeys); + } + @Override + public void newSessionTicketReceived(NewSessionTicket ticket) { + } + @Override + public void extensionsReceived(List extensions) throws TlsProtocolException { + } + @Override + public boolean isEarlyDataAccepted() { + return false; + } + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/handshake/Handshake.java b/src/main/java/core/packetproxy/quic/service/handshake/Handshake.java new file mode 100644 index 0000000..a84b81f --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/handshake/Handshake.java @@ -0,0 +1,25 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.handshake; + +import net.luminis.tls.Message; + +public interface Handshake { + + void received(Message message) throws Exception; + +} diff --git a/src/main/java/core/packetproxy/quic/service/handshake/HandshakeState.java b/src/main/java/core/packetproxy/quic/service/handshake/HandshakeState.java new file mode 100644 index 0000000..38ac1ce --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/handshake/HandshakeState.java @@ -0,0 +1,59 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.handshake; + +public class HandshakeState { + + public enum State { + Initial, + HasHandshakeKeys, + AckReceived, + HasAppKeys, + Confirmed + } + + private State state; + + public HandshakeState() { + this.state = State.Initial; + } + + public void transit(HandshakeState.State newlyState) { + this.state = newlyState; + } + + public boolean hasNoHandshakeKeys() { + return this.state.ordinal() < State.HasHandshakeKeys.ordinal(); + } + + public boolean hasHandshakeKeys() { + return this.state.ordinal() >= State.HasHandshakeKeys.ordinal(); + } + + public boolean isAckReceived() { + return this.state.ordinal() >= State.AckReceived.ordinal(); + } + + public boolean isNotConfirmed() { + return this.state.ordinal() < State.Confirmed.ordinal(); + } + + public boolean isConfirmed() { + return this.state.ordinal() >= State.Confirmed.ordinal(); + } + +} \ No newline at end of file diff --git a/src/main/java/core/packetproxy/quic/service/handshake/ServerHandshake.java b/src/main/java/core/packetproxy/quic/service/handshake/ServerHandshake.java new file mode 100644 index 0000000..1f1c984 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/handshake/ServerHandshake.java @@ -0,0 +1,219 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.handshake; + +import net.luminis.tls.*; +import net.luminis.tls.extension.ApplicationLayerProtocolNegotiationExtension; +import net.luminis.tls.extension.Extension; +import net.luminis.tls.extension.ServerNameExtension; +import net.luminis.tls.handshake.*; +import packetproxy.CertCacheManager; +import packetproxy.model.CAs.CA; +import packetproxy.quic.service.connection.Connection; +import packetproxy.quic.service.frame.Frames; +import packetproxy.quic.service.framegenerator.MessagesToCryptoFrames; +import packetproxy.quic.service.transportparameter.TransportParameters; +import packetproxy.quic.utils.Constants; +import packetproxy.quic.value.ConnectionId; +import packetproxy.quic.value.Token; +import packetproxy.quic.value.frame.NewConnectionIdFrame; + +import java.io.IOException; +import java.security.KeyStore; +import java.security.cert.X509Certificate; +import java.security.interfaces.RSAPrivateKey; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.LinkedBlockingQueue; +import java.util.stream.Collectors; + +import static packetproxy.quic.utils.Constants.PnSpaceType.PnSpaceHandshake; +import static packetproxy.quic.utils.Constants.PnSpaceType.PnSpaceInitial; +import static packetproxy.quic.utils.Constants.TOKEN_SIZE; +import static packetproxy.util.Throwing.rethrow; + +public class ServerHandshake implements Handshake { + + static private final TlsSessionRegistry tlsSessionRegistry = new TlsSessionRegistryImpl(); + + final Connection conn; + final BlockingQueue sniQueue = new LinkedBlockingQueue<>(); + final CA ca; + Optional sniName = Optional.empty(); + TlsServerEngine engine; + + public ServerHandshake(Connection conn, CA ca) { + this.conn = conn; + this.ca = ca; + } + + public void startHandshake(String sniName) throws Exception { + KeyStore ks = CertCacheManager.getInstance().getKeyStore(sniName, new String[]{sniName}, this.ca); + RSAPrivateKey key = (RSAPrivateKey) ks.getKey("newalias", "testtest".toCharArray()); + List certs = Arrays.stream(ks.getCertificateChain("newalias")) + .map(cert -> (X509Certificate)cert) + .collect(Collectors.toList()); + this.engine = new TlsServerEngine(certs, key, new MyServerMessageSender(), new MyTlsStatusEventHandler(), tlsSessionRegistry); + this.engine.addSupportedCiphers(List.of(TlsConstants.CipherSuite.TLS_AES_128_GCM_SHA256)); + } + + @Override + public void received(Message message) throws Exception { + if (message instanceof ClientHello) { + /* SNIを取得 */ + ClientHello ch = (ClientHello) message; + ch.getExtensions().stream() + .filter(ext -> ext instanceof ServerNameExtension) + .findFirst() + .ifPresent(rethrow(ext -> { + ServerNameExtension serverNameExtension = (ServerNameExtension) ext; + sniName = Optional.of(serverNameExtension.getHostName()); + })); + if (sniName.isEmpty()) { + throw new Exception("Error: SNI name was not found in TLS ClientHello HandShake message"); + } + sniName.ifPresent(rethrow(sni -> { + this.startHandshake(sni); + this.sniQueue.put(sni); + this.engine.received((ClientHello) message, ProtectionKeysType.None); + })); + + } else if (message instanceof EncryptedExtensions) { + /* do nothing */ + } else if (message instanceof FinishedMessage) { + this.engine.received((FinishedMessage) message, ProtectionKeysType.Handshake); + } else { + System.err.println("Error: couldn't process message " + message); + } + } + + public String getSNI() throws Exception { + return this.sniQueue.take(); + } + + class MyServerMessageSender implements ServerMessageSender { + @Override + public void send(ServerHello serverHello) throws IOException { + MessagesToCryptoFrames stream = conn.getPnSpace(Constants.PnSpaceType.PnSpaceInitial).getMsgToFrameCryptoStream(); + stream.write(serverHello); + Frames frames = stream.toCryptoFrames(); + conn.getPnSpace(Constants.PnSpaceType.PnSpaceInitial).addSendFrames(frames); + conn.getKeys().setClientRandom(serverHello.getRandom()); + } + @Override + public void send(EncryptedExtensions encryptedExtensions) throws IOException { + MessagesToCryptoFrames stream = conn.getPnSpace(Constants.PnSpaceType.PnSpaceHandshake).getMsgToFrameCryptoStream(); + stream.write(encryptedExtensions); + Frames frames = stream.toCryptoFrames(); + conn.getPnSpace(Constants.PnSpaceType.PnSpaceHandshake).addSendFrames(frames); + } + @Override + public void send(CertificateMessage certificateMessage) throws IOException { + MessagesToCryptoFrames stream = conn.getPnSpace(Constants.PnSpaceType.PnSpaceHandshake).getMsgToFrameCryptoStream(); + stream.write(certificateMessage); + Frames frames = stream.toCryptoFrames(); + conn.getPnSpace(Constants.PnSpaceType.PnSpaceHandshake).addSendFrames(frames); + } + @Override + public void send(CertificateVerifyMessage certificateVerifyMessage) throws IOException { + MessagesToCryptoFrames stream = conn.getPnSpace(Constants.PnSpaceType.PnSpaceHandshake).getMsgToFrameCryptoStream(); + stream.write(certificateVerifyMessage); + Frames frames = stream.toCryptoFrames(); + conn.getPnSpace(Constants.PnSpaceType.PnSpaceHandshake).addSendFrames(frames); + } + @Override + public void send(FinishedMessage finishedMessage) throws IOException { + MessagesToCryptoFrames stream = conn.getPnSpace(Constants.PnSpaceType.PnSpaceHandshake).getMsgToFrameCryptoStream(); + stream.write(finishedMessage); + Frames frames = stream.toCryptoFrames(); + conn.getPnSpace(Constants.PnSpaceType.PnSpaceHandshake).addSendFrames(frames); + } + @Override + public void send(NewSessionTicketMessage ticket) throws IOException { + /* send CryptFrame(NewSessionTicketMassage) */ + MessagesToCryptoFrames stream = conn.getPnSpace(Constants.PnSpaceType.PnSpaceApplicationData).getMsgToFrameCryptoStream(); + stream.write(ticket); + Frames frames = stream.toCryptoFrames(); + conn.getPnSpace(Constants.PnSpaceType.PnSpaceApplicationData).addSendFrames(frames); + + /* send NewConnectionIdFrame */ + NewConnectionIdFrame frame1 = new NewConnectionIdFrame(1, 0, ConnectionId.generateRandom(), Token.generateRandom(TOKEN_SIZE)); + NewConnectionIdFrame frame2 = new NewConnectionIdFrame(2, 0, ConnectionId.generateRandom(), Token.generateRandom(TOKEN_SIZE)); + NewConnectionIdFrame frame3 = new NewConnectionIdFrame(3, 0, ConnectionId.generateRandom(), Token.generateRandom(TOKEN_SIZE)); + conn.getPnSpace(Constants.PnSpaceType.PnSpaceApplicationData).addSendFrames(Frames.of(frame1, frame2, frame3)); + } + } + + class MyTlsStatusEventHandler implements TlsStatusEventHandler { + @Override + public void earlySecretsKnown() { + //System.out.println("earlySecretsKnown"); + conn.getKeys().computeZeroRttKey(engine.getClientEarlyTrafficSecret()); + } + @Override + public void handshakeSecretsKnown() { + //System.out.println("handshakeSecretsKnown"); + conn.getKeys().computeHandshakeKey(engine.getClientHandshakeTrafficSecret(), engine.getServerHandshakeTrafficSecret()); + } + @Override + public void handshakeFinished() { + //System.out.println("handshakeFinished"); + conn.getKeys().computeApplicationKey(engine.getClientApplicationTrafficSecret(), engine.getServerApplicationTrafficSecret()); + conn.getKeys().discardInitialKey(); + conn.getPnSpace(PnSpaceInitial).close(); + conn.getKeys().discardHandshakeKey(); + conn.getPnSpace(PnSpaceHandshake).close(); + } + @Override + public void newSessionTicketReceived(NewSessionTicket ticket) { + //System.out.println("newSessionTicketReceived"); + } + @Override + public void extensionsReceived(List extensions) throws TlsProtocolException { + /* use always h3 mode */ + engine.addServerExtensions(new ApplicationLayerProtocolNegotiationExtension("h3")); + + /* quic transport parameter */ + TransportParameters tp = new TransportParameters(Constants.Role.SERVER); + tp.setMaxUdpPayloadSize(1472); + tp.setAckDelayExponent(10); + tp.setMaxIdleTimeout(30_000); + tp.setOldMinAckDelay(25000); + tp.setOrigDestConnId(conn.getInitialSecret().getBytes()); + tp.setInitSrcConnId(conn.getConnIdPair().getSrcConnId().getBytes()); + tp.setInitMaxStreamUni(10 * 1024); + tp.setInitMaxStreamBidi(10 * 1024); + tp.setInitMaxData(10L * 1024 * 1024 * 1024); + tp.setInitMaxStreamDataBidiLocal(10L * 1024 * 1024 * 1024); + tp.setInitMaxStreamDataBidiRemote(10L * 1024 * 1024 * 1024); + tp.setInitMaxStreamDataUni(10L * 1024 * 1024 * 1024); + tp.setActiveConnIdLimit(4); + tp.setDisableActiveMigration(true); + //if (retryRequired) { + // tp.setRetrySrcConnId(); + //} + engine.addServerExtensions(tp); + } + @Override + public boolean isEarlyDataAccepted() { + //System.out.println("isEarlyDataAccepted"); + return false; + } + } +} diff --git a/src/main/java/core/packetproxy/quic/service/key/Keys.java b/src/main/java/core/packetproxy/quic/service/key/Keys.java new file mode 100644 index 0000000..3c3b519 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/key/Keys.java @@ -0,0 +1,104 @@ +package packetproxy.quic.service.key; + +import lombok.Getter; +import org.apache.commons.codec.binary.Hex; +import packetproxy.quic.value.ConnectionId; +import packetproxy.quic.utils.Constants; + +import java.io.*; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; + +@Getter +public class Keys { + + private final RoleKeys clientKeys = new RoleKeys(Constants.Role.CLIENT); + private final RoleKeys serverKeys = new RoleKeys(Constants.Role.SERVER); + private byte[] clientRandom; + + public void computeInitialKey(ConnectionId destConnId) { + this.clientKeys.computeInitialKey(destConnId); + this.serverKeys.computeInitialKey(destConnId); + } + + public void computeZeroRttKey(byte[] secret) { + this.clientKeys.computeZeroRttKey(secret); + } + + public void computeHandshakeKey(byte[] clientSecret, byte[] serverSecret) { + this.clientKeys.computeHandshakeKey(clientSecret); + this.serverKeys.computeHandshakeKey(serverSecret); + } + + public void computeApplicationKey(byte[] clientSecret, byte[] serverSecret) { + this.clientKeys.computeApplicationKey(clientSecret); + this.serverKeys.computeApplicationKey(serverSecret); + outputSecretsForWireshark(); /* for wireshark debug */ + } + + public boolean hasInitialKey() { + return this.clientKeys.hasInitialKey(); + } + + public boolean hasHandshakeKey() { + return this.clientKeys.hasHandshakeKey(); + } + + public boolean hasApplicationKey() { + return this.clientKeys.hasApplicationKey(); + } + + public RoleKeys getRoleKeys(Constants.Role role) { + return (role == Constants.Role.CLIENT) ? this.clientKeys : this.serverKeys; + } + + public void setClientRandom(byte[] clientRandom) { + this.clientRandom = clientRandom; + } + + public void discardInitialKey() { + this.clientKeys.discardInitialKey(); + this.serverKeys.discardInitialKey(); + } + + public void discardHandshakeKey() { + this.clientKeys.discardHandshakeKey(); + this.serverKeys.discardHandshakeKey(); + } + + public boolean discardedInitialKey() { + return this.clientKeys.discardedInitialKey(); + } + + public boolean discardedHandshakeKey() { + return this.clientKeys.discardedHandshakeKey(); + } + + static private Path logDir = Paths.get(System.getProperty("user.home") + "/.packetproxy/logs"); + static private Path keylogFile = Paths.get(logDir + "/quic_tls.keylog"); + + /** + * Wiresharkのメニューから、Preference > Advanced > tls.keylog_file に keylog ファイルのパスを入力した後、 + * View > Reload で再読み込みするとQUICパケットのペイロードが読めるようになる + */ + public void outputSecretsForWireshark() { + if (this.clientRandom != null && this.clientKeys.hasHandshakeKey() && this.clientKeys.hasApplicationKey()) { + try { + if (!Files.exists(logDir)) { + Files.createDirectories(logDir); + } + try (FileWriter file = new FileWriter(keylogFile.toFile())) { + String clientRandomStr = Hex.encodeHexString(this.clientRandom); + file.write(String.format("CLIENT_HANDSHAKE_TRAFFIC_SECRET %s %s\n", clientRandomStr, Hex.encodeHexString(this.clientKeys.getHandshakeKey().getSecret()))); + file.write(String.format("SERVER_HANDSHAKE_TRAFFIC_SECRET %s %s\n", clientRandomStr, Hex.encodeHexString(this.serverKeys.getHandshakeKey().getSecret()))); + file.write(String.format("CLIENT_TRAFFIC_SECRET_0 %s %s\n", clientRandomStr, Hex.encodeHexString(this.clientKeys.getApplicationKey().getSecret()))); + file.write(String.format("SERVER_TRAFFIC_SECRET_0 %s %s\n", clientRandomStr, Hex.encodeHexString(this.serverKeys.getApplicationKey().getSecret()))); + } + } catch (Exception e) { + e.printStackTrace(); + } + } + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/key/RoleKeys.java b/src/main/java/core/packetproxy/quic/service/key/RoleKeys.java new file mode 100644 index 0000000..9e26dbe --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/key/RoleKeys.java @@ -0,0 +1,102 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.key; + +import lombok.Getter; +import packetproxy.quic.utils.Constants; +import packetproxy.quic.value.key.level.ZeroRttKey; +import packetproxy.quic.value.key.level.ApplicationKey; +import packetproxy.quic.value.key.level.HandshakeKey; +import packetproxy.quic.value.key.level.InitialKey; +import packetproxy.quic.value.ConnectionId; + +import java.util.Optional; + +@Getter +public class RoleKeys { + + private Constants.Role role; + + private Optional optionalInitialKey = Optional.empty(); + private Optional optionalZeroRttKey = Optional.empty(); + private Optional optionalHandshakeKey = Optional.empty(); + private Optional optionalApplicationKey = Optional.empty(); + + boolean discardedInitialKey = false; + boolean discardedHandshakeKey = false; + + public RoleKeys(Constants.Role role) { + this.role = role; + } + + public InitialKey getInitialKey() { + return optionalInitialKey.orElseThrow(); + } + public HandshakeKey getHandshakeKey() { + return this.optionalHandshakeKey.orElseThrow(); + } + public ZeroRttKey getZeroRttKey() { + return this.optionalZeroRttKey.orElseThrow(); + } + public ApplicationKey getApplicationKey() { + return this.optionalApplicationKey.orElseThrow(); + } + + public boolean hasInitialKey() { + return this.optionalInitialKey.isPresent(); + } + public boolean hasHandshakeKey() { + return this.optionalHandshakeKey.isPresent(); + } + public boolean hasZeroRttKey() { + return this.optionalZeroRttKey.isPresent(); + } + public boolean hasApplicationKey() { + return this.optionalApplicationKey.isPresent(); + } + + public void computeInitialKey(ConnectionId destConnId) { + this.optionalInitialKey = Optional.of(InitialKey.of(this.role, destConnId)); + } + public void computeZeroRttKey(byte[] secret) { + this.optionalZeroRttKey = Optional.of(ZeroRttKey.of(secret)); + } + public void computeHandshakeKey(byte[] secret) { + this.optionalHandshakeKey = Optional.of(HandshakeKey.of(secret)); + } + public void computeApplicationKey(byte[] secret) { + this.optionalApplicationKey = Optional.of(ApplicationKey.of(secret)); + } + + public void discardInitialKey() { + this.optionalInitialKey = Optional.empty(); + this.discardedInitialKey = true; + } + + public void discardHandshakeKey() { + this.optionalHandshakeKey = Optional.empty(); + this.discardedHandshakeKey = true; + } + + public boolean discardedInitialKey() { + return discardedInitialKey; + } + + public boolean discardedHandshakeKey() { + return discardedHandshakeKey; + } +} diff --git a/src/main/java/core/packetproxy/quic/service/packet/QuicPacketBuilder.java b/src/main/java/core/packetproxy/quic/service/packet/QuicPacketBuilder.java new file mode 100644 index 0000000..a6aa890 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/packet/QuicPacketBuilder.java @@ -0,0 +1,88 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.packet; + +import lombok.AccessLevel; +import lombok.Getter; +import lombok.NoArgsConstructor; +import packetproxy.quic.value.packet.QuicPacket; +import packetproxy.quic.value.packet.longheader.pnspace.HandshakePacket; +import packetproxy.quic.value.packet.longheader.pnspace.InitialPacket; +import packetproxy.quic.value.packet.shortheader.ShortHeaderPacket; +import packetproxy.quic.value.ConnectionIdPair; +import packetproxy.quic.value.PacketNumber; +import packetproxy.quic.utils.Constants; + +@Getter +@NoArgsConstructor(access = AccessLevel.NONE) +public class QuicPacketBuilder { + + static public QuicPacketBuilder getBuilder() { + return new QuicPacketBuilder(); + } + + Constants.PnSpaceType pnSpaceType; + Constants.QuicPacketType quicPacketType; + byte[] token = new byte[0]; /* for Initial Packet */ + byte[] payload = new byte[0]; + PacketNumber packetNumber; + ConnectionIdPair connIdPair; + + public QuicPacketBuilder setPnSpaceType(Constants.PnSpaceType pnSpaceType) { + this.pnSpaceType = pnSpaceType; + return this; + } + + public QuicPacketBuilder setPacketType(Constants.QuicPacketType quicPacketType) { + this.quicPacketType = quicPacketType; + return this; + } + + public QuicPacketBuilder setToken(byte[] token) { + this.token = token; + return this; + } + + public QuicPacketBuilder setPayload(byte[] payload) { + this.payload = payload; + return this; + } + + public QuicPacketBuilder setConnectionIdPair(ConnectionIdPair connIdPair) { + this.connIdPair = connIdPair; + return this; + } + + public QuicPacketBuilder setPacketNumber(PacketNumber packetNumber) { + this.packetNumber = packetNumber; + return this; + } + + public QuicPacket build() throws Exception { + if (this.quicPacketType == Constants.QuicPacketType.PacketInitial) { + return InitialPacket.of(1, this.connIdPair, this.packetNumber, this.payload, this.token); + } + if (this.quicPacketType == Constants.QuicPacketType.PacketHandshake) { + return HandshakePacket.of(1, this.connIdPair, this.packetNumber, this.payload); + } + if (this.quicPacketType == Constants.QuicPacketType.PacketApplication) { + return ShortHeaderPacket.of(this.connIdPair.getDestConnId(), this.packetNumber, this.payload); + } + throw new Exception("error: unknown packet type"); + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/packet/QuicPacketParser.java b/src/main/java/core/packetproxy/quic/service/packet/QuicPacketParser.java new file mode 100644 index 0000000..9e0cc1a --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/packet/QuicPacketParser.java @@ -0,0 +1,124 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.packet; + +import packetproxy.quic.service.connection.Connection; +import packetproxy.quic.service.key.RoleKeys; +import packetproxy.quic.utils.AwaitingException; +import packetproxy.quic.value.ConnectionId; +import packetproxy.quic.value.PacketNumber; +import packetproxy.quic.value.packet.QuicPacket; +import packetproxy.quic.value.packet.longheader.LongHeaderPacket; +import packetproxy.quic.value.packet.longheader.pnspace.HandshakePacket; +import packetproxy.quic.value.packet.longheader.pnspace.InitialPacket; +import packetproxy.quic.value.packet.longheader.pnspace.ZeroRttPacket; +import packetproxy.quic.value.packet.shortheader.ShortHeaderPacket; + +import java.net.DatagramPacket; +import java.nio.ByteBuffer; +import java.util.Optional; + +import static packetproxy.quic.utils.Constants.PnSpaceType.*; + + +public class QuicPacketParser { + + static public ConnectionId getDestConnectionId(byte[] bytes) throws Exception { + return getDestConnectionId(ByteBuffer.wrap(bytes)); + } + + static public ConnectionId getDestConnectionId(ByteBuffer buffer) throws Exception { + byte type = getTypeWithoutIncrement(buffer); + if (LongHeaderPacket.is(type)) { + return LongHeaderPacket.getDestConnId(buffer); + } else if (ShortHeaderPacket.is(type)){ + return ShortHeaderPacket.getDestConnId(buffer); + } + throw new Exception("Error: unknown packet (LongHeaderPacket nor ShortHeaderPacket)"); + } + + static private byte getTypeWithoutIncrement(ByteBuffer buffer) { + int pos = buffer.position(); + byte type = buffer.get(); + buffer.position(pos); + return type; + } + + private final Connection conn; + private final RoleKeys roleKeys; + + public QuicPacketParser(Connection conn, RoleKeys roleKeys) { + this.conn = conn; + this.roleKeys = roleKeys; + } + + public void parseOnePacket(DatagramPacket udpPacket) throws Exception { + ByteBuffer buffer = ByteBuffer.wrap(udpPacket.getData()); + while (buffer.hasRemaining()) { + this.parse(buffer).ifPresent(packet -> { + //if (this.conn.getRole() == Constants.Role.SERVER) { + // PacketProxyUtility.getInstance().packetProxyLog("[QUIC] CLIENT---> " + packet); + //} else { + // PacketProxyUtility.getInstance().packetProxyLog("[QUIC] <---SERVER " + packet); + //} + this.conn.getPnSpaces().receivePacket(packet); + }); + } + } + + private Optional parse(ByteBuffer buffer) throws Exception { + + byte type = getTypeWithoutIncrement(buffer); + + if (InitialPacket.is(type) && this.roleKeys.hasInitialKey()) { + PacketNumber largestAckedPn = this.conn.getPnSpace(PnSpaceInitial).getLargestAckedPn(); + InitialPacket initialPacket = new InitialPacket(buffer, this.roleKeys.getInitialKey(), largestAckedPn); + return Optional.of(initialPacket); + + } else if (HandshakePacket.is(type) && this.roleKeys.hasHandshakeKey()) { + PacketNumber largestAckedPn = this.conn.getPnSpace(PnSpaceHandshake).getLargestAckedPn(); + HandshakePacket handshakePacket = new HandshakePacket(buffer, this.roleKeys.getHandshakeKey(), largestAckedPn); + return Optional.of(handshakePacket); + + } else if (ShortHeaderPacket.is(type) && this.roleKeys.hasApplicationKey()) { + PacketNumber largestAckedPn = this.conn.getPnSpace(PnSpaceApplicationData).getLargestAckedPn(); + ShortHeaderPacket shortHeaderPacket = new ShortHeaderPacket(buffer, this.roleKeys.getApplicationKey(), largestAckedPn); + return Optional.of(shortHeaderPacket); + + } else if (ZeroRttPacket.is(type) && this.roleKeys.hasZeroRttKey()) { + PacketNumber largestAckedPn = this.conn.getPnSpace(PnSpaceApplicationData).getLargestAckedPn(); + ZeroRttPacket zeroRttPacket = new ZeroRttPacket(buffer, this.roleKeys.getZeroRttKey(), largestAckedPn); + return Optional.of(zeroRttPacket); + + } else if (type == 0x0) { + /* remaining data in the packet is paddings */ + buffer.position(buffer.limit()); + return Optional.empty(); + + } else { + if (HandshakePacket.is(type)) { + throw new AwaitingException("wait until deploying handshake key"); + } + if (ShortHeaderPacket.is(type) || ZeroRttPacket.is(type)) { + throw new AwaitingException("wait until deploying application key"); + } + // TODO: ZeroRttPacket, RetryPacket + throw new Exception(String.format("Error: packet type (%x) is not supported", type)); + } + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/pnspace/PnSpace.java b/src/main/java/core/packetproxy/quic/service/pnspace/PnSpace.java new file mode 100644 index 0000000..47912c5 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/pnspace/PnSpace.java @@ -0,0 +1,239 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.pnspace; + +import lombok.AccessLevel; +import lombok.Getter; +import lombok.NoArgsConstructor; +import packetproxy.quic.service.connection.Connection; +import packetproxy.quic.service.frame.Frames; +import packetproxy.quic.service.framegenerator.AckFrameGenerator; +import packetproxy.quic.service.framegenerator.CryptoFramesToMessages; +import packetproxy.quic.service.framegenerator.MessagesToCryptoFrames; +import packetproxy.quic.service.framegenerator.StreamFramesToMessages; +import packetproxy.quic.service.packet.QuicPacketBuilder; +import packetproxy.quic.service.pnspace.helper.LostPackets; +import packetproxy.quic.service.pnspace.helper.SendFrameQueue; +import packetproxy.quic.service.pnspace.helper.SentPackets; +import packetproxy.quic.utils.Constants; +import packetproxy.quic.value.PacketNumber; +import packetproxy.quic.value.QuicMessage; +import packetproxy.quic.value.SentPacket; +import packetproxy.quic.value.frame.*; +import packetproxy.quic.value.packet.PnSpacePacket; +import packetproxy.quic.value.packet.QuicPacket; +import packetproxy.util.PacketProxyUtility; + +import java.io.OutputStream; +import java.time.Instant; +import java.util.List; + +import static packetproxy.quic.service.handshake.HandshakeState.State.Confirmed; +import static packetproxy.quic.utils.Constants.PnSpaceType.PnSpaceHandshake; +import static packetproxy.quic.utils.Constants.PnSpaceType.PnSpaceInitial; +import static packetproxy.util.Throwing.rethrow; + +@Getter +@NoArgsConstructor(access = AccessLevel.NONE) +public abstract class PnSpace { + + protected final CryptoFramesToMessages frameToMsgCryptoStream = new CryptoFramesToMessages(); + protected final MessagesToCryptoFrames msgToFrameCryptoStream = new MessagesToCryptoFrames(); + protected final StreamFramesToMessages frameToMsgStream = new StreamFramesToMessages(); + + protected final AckFrameGenerator ackFrameGenerator = new AckFrameGenerator(); + protected final SentPackets sentPackets = new SentPackets(); + protected final SendFrameQueue sendFrameQueue = new SendFrameQueue(); + protected final Connection conn; + protected PacketNumber largestAckedPn = PacketNumber.Infinite; + protected Instant lossTime = Instant.MAX; /* パケットが欠落することになる未来時刻 */ + protected Instant timeOfLastAckElicitingPacket = Instant.MIN; /* 最後にAckを誘発するPacketを送信した時刻 */ + protected PacketNumber nextPacketNumber; + + public PnSpace(Connection conn) { + this.conn = conn; + this.nextPacketNumber = PacketNumber.of(0); + } + + public synchronized boolean hasAnyAckElicitingPacket() { + return this.sentPackets.hasAnyAckElicitingPacket(); + } + + public synchronized void close() { + this.sentPackets.clear(); + this.sendFrameQueue.clear(); + this.lossTime = Instant.MAX; + this.timeOfLastAckElicitingPacket = Instant.MIN; + } + + public synchronized void OnAckReceived(AckFrame ackFrame) { + if (this.largestAckedPn == PacketNumber.Infinite) { + this.largestAckedPn = ackFrame.getLargestAckedPn(); + } else { + this.largestAckedPn = PacketNumber.max(this.largestAckedPn, ackFrame.getLargestAckedPn()); + } + + SentPackets newlyAckedPackets = sentPackets.detectAndRemoveAckedPackets(ackFrame); + if (newlyAckedPackets.isEmpty()) { + return; + } + + /* Update the RTT if the largest acknowledged is newly acked, and at least one ack-eliciting was newly acked. */ + newlyAckedPackets.getLargest().ifPresent(packet -> { + if (packet.getPacketNumber() == ackFrame.getLargestAckedPn() && newlyAckedPackets.hasAnyAckElicitingPacket()) { + this.conn.getRttEstimator().updateRtt(packet.getTimeSent(), ackFrame.getAckDelay()); + } + }); + + if (ackFrame instanceof AckEcnFrame) { + /* PacketProxyでは通信路の輻輳制御機能は実装しない */ + // ProcessECN(ackFrame, pn_space); + } + + LostPackets lostPackets = this.detectAndRemoveLostPackets(); + if (!lostPackets.isEmpty()) { + PacketProxyUtility.getInstance().packetProxyLogErr("[QUIC] lost packets: " + lostPackets); + OnPacketsLost(lostPackets); + } + + /* Reset pto_count unless the client is unsure if the server has validated the client's address. */ + if (this.conn.peerCompletedAddressValidation()) { + this.conn.getPto().clearPtoCount(); + } + this.conn.getLossDetection().setLossDetectionTimer(); + } + + public synchronized void receivePacket(QuicPacket packet) { + if (packet instanceof PnSpacePacket) { + PnSpacePacket pnSpacePacket = (PnSpacePacket) packet; + + this.ackFrameGenerator.received(pnSpacePacket.getPacketNumber()); + + if (pnSpacePacket.isAckEliciting()) { + this.addSendFrame(ackFrameGenerator.generateAckFrame()); + } + + this.receiveFrames(pnSpacePacket.getFrames()); + } + } + + private synchronized void receiveFrames(Frames frames) { + for (Frame frame : frames) { + if (frame instanceof CryptoFrame) { + frameToMsgCryptoStream.write((CryptoFrame) frame); + frameToMsgCryptoStream.getHandshakeMessages().forEach(rethrow(msg -> { + this.conn.getHandshake().received(msg); + })); + } else if (frame instanceof StreamFrame) { + StreamFrame streamFrame = (StreamFrame) frame; + this.frameToMsgStream.put(streamFrame); + this.frameToMsgStream.get(streamFrame.getStreamId()).ifPresent(rethrow(msg -> { + /* Application Data received from peer */ + OutputStream os = this.conn.getPipe().getRawEndpoint().getOutputStream(); + os.write(msg.getBytes()); + os.flush(); + })); + } else if (frame instanceof AckFrame) { + this.OnAckReceived((AckFrame) frame); + } else if (frame instanceof HandshakeDoneFrame) { + this.conn.getHandshakeState().transit(Confirmed); + if (this.conn.getRole() == Constants.Role.CLIENT) { + this.conn.getKeys().discardInitialKey(); + this.conn.getPnSpace(PnSpaceInitial).close(); + this.conn.getKeys().discardHandshakeKey(); + this.conn.getPnSpace(PnSpaceHandshake).close(); + } + } else if (frame instanceof ConnectionCloseFrame) { + this.conn.close(); + } else if (frame instanceof NewConnectionIdFrame) { + /* not implemented yet */ + } else if (frame instanceof NewTokenFrame) { + /* not implemented yet */ + } else if (frame instanceof PingFrame) { + /* Do Nothing */ + } else if (frame instanceof PaddingFrame) { + /* Do Nothing */ + } else { + System.err.println("Error: couldn't process frame: " + frame); + } + } + } + + public synchronized void addSendQuicMessage(QuicMessage msg) { + /* defined on ApplicationData PnSpace only */ + } + + public void addSendFrame(Frame frame) { + this.addSendFrames(Frames.of(frame)); + } + + public synchronized void addSendFrames(Frames frames) { + this.sendFrameQueue.add(frames); + this.conn.getPnSpaces().addSendPackets(this.getAndRemoveSendFramesAndConvertPacketBuilders()); + } + public abstract List getAndRemoveSendFramesAndConvertPacketBuilders(); + + public synchronized void addSentPacket(QuicPacket packet) { + if (packet instanceof PnSpacePacket) { + PnSpacePacket pnSpacePacket = (PnSpacePacket) packet; + if (pnSpacePacket.isAckEliciting()) { + this.sentPackets.add(new SentPacket(pnSpacePacket)); + this.timeOfLastAckElicitingPacket = Instant.now(); + } + } + } + + public void OnPacketsLost(LostPackets lostPackets) { + lostPackets.stream().forEach(sentPacket -> { + this.addSendFrames(sentPacket.getPacket().getFrames()); /* resend packet */ + }); + } + + public synchronized LostPackets detectAndRemoveLostPackets() { + assert (this.largestAckedPn != PacketNumber.Infinite); + this.lossTime = Instant.MAX; + + LostPackets lostPackets = new LostPackets(); + long lossDelay = this.conn.getRttEstimator().getLossDelay(); + + /* Packets sent before this time are deemed lost. */ + Instant lostSendTime = Instant.now().minusMillis(lossDelay); + + for (SentPacket unAcked : this.sentPackets.getUnAckedPackets()) { + PacketNumber largestAckedPn = this.largestAckedPn; + PacketNumber unAckedPn = unAcked.getPacketNumber(); + if (unAckedPn.isLargerThan(largestAckedPn)) { + continue; + } + /* + * Mark packet as lost, or set time when it should be marked. + * Note: The use of kPacketThreshold here assumes that there were no sender-induced gaps in the packet number space. + */ + if (unAcked.getTimeSent().isBefore(lostSendTime) || largestAckedPn.isLargerThanOrEquals(unAckedPn.plus(Constants.kPacketThreshold))) { + this.sentPackets.removePacket(unAcked); + lostPackets.add(unAcked); + } else { + Instant newlyLossTime = unAcked.getTimeSent().plusMillis(lossDelay); + if (newlyLossTime.isBefore(this.lossTime)) { + this.lossTime = newlyLossTime; + } + } + } + return lostPackets; + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/pnspace/PnSpaces.java b/src/main/java/core/packetproxy/quic/service/pnspace/PnSpaces.java new file mode 100644 index 0000000..8d9b597 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/pnspace/PnSpaces.java @@ -0,0 +1,106 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.pnspace; + +import com.google.common.collect.ImmutableList; +import lombok.SneakyThrows; +import org.apache.commons.lang3.tuple.ImmutablePair; +import packetproxy.quic.utils.Constants.PnSpaceType; +import packetproxy.quic.service.pnspace.level.ApplicationDataPnSpace; +import packetproxy.quic.service.pnspace.level.HandshakePnSpace; +import packetproxy.quic.service.pnspace.level.InitialPnSpace; +import packetproxy.quic.value.packet.QuicPacket; +import packetproxy.quic.service.packet.QuicPacketBuilder; +import packetproxy.quic.value.packet.longheader.pnspace.HandshakePacket; +import packetproxy.quic.value.packet.longheader.pnspace.InitialPacket; +import packetproxy.quic.value.packet.shortheader.ShortHeaderPacket; +import packetproxy.quic.service.connection.Connection; + +import java.time.Instant; +import java.util.*; +import java.util.concurrent.LinkedBlockingQueue; + +import static packetproxy.quic.utils.Constants.PnSpaceType.*; +import static packetproxy.util.Throwing.rethrow; + +public class PnSpaces { + + private final LinkedBlockingQueue sendPacketQueue = new LinkedBlockingQueue<>(); + private final PnSpace[] pnSpaces = new PnSpace[PnSpaceType.values().length]; + private final Connection conn; + + public PnSpaces(Connection conn) { + this.conn = conn; + this.pnSpaces[PnSpaceInitial.ordinal()] = new InitialPnSpace(conn); + this.pnSpaces[PnSpaceHandshake.ordinal()] = new HandshakePnSpace(conn); + this.pnSpaces[PnSpaceApplicationData.ordinal()] = new ApplicationDataPnSpace(conn); + } + + public PnSpace getPnSpace(PnSpaceType pnSpaceType) { + return this.pnSpaces[pnSpaceType.ordinal()]; + } + + public void receivePacket(QuicPacket packet) { + if (packet instanceof InitialPacket) { + this.pnSpaces[PnSpaceInitial.ordinal()].receivePacket(packet); + } else if (packet instanceof HandshakePacket) { + this.pnSpaces[PnSpaceHandshake.ordinal()].receivePacket(packet); + } else if (packet instanceof ShortHeaderPacket) { + this.pnSpaces[PnSpaceApplicationData.ordinal()].receivePacket(packet); + } + } + + /** + * 送信するパケットをキューに入れる + */ + public void addSendPackets(List packets) { + packets.forEach(rethrow(this.sendPacketQueue::put)); + } + + /** + * 送信するパケットをキューから取得する (Blocking) + */ + @SneakyThrows + public List pollSendPackets() { + QuicPacketBuilder builder = this.sendPacketQueue.take(); + QuicPacket packet = builder.setConnectionIdPair(this.conn.getConnIdPair()).build(); + this.conn.getPnSpace(builder.getPnSpaceType()).addSentPacket(packet); + return new ArrayList<>(List.of(packet)); + } + + public ImmutablePair getEarliestLossTimeAndSpace() { + Instant lossTime = this.pnSpaces[PnSpaceInitial.ordinal()].getLossTime(); + PnSpaceType space = PnSpaceInitial; + + for (PnSpaceType pnSpaceType : ImmutableList.of(PnSpaceHandshake, PnSpaceApplicationData)) { + if (lossTime == Instant.MIN || this.pnSpaces[pnSpaceType.ordinal()].getLossTime().isBefore(lossTime)) { + lossTime = this.pnSpaces[pnSpaceType.ordinal()].getLossTime(); + space = pnSpaceType; + } + } + return ImmutablePair.of(lossTime, space); + } + + public Instant getEarliestLossTime() { + return this.getEarliestLossTimeAndSpace().getLeft(); + } + + public boolean hasAnyAckElicitingPacket() { + return Arrays.stream(this.pnSpaces).anyMatch(PnSpace::hasAnyAckElicitingPacket); + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/pnspace/helper/LostPackets.java b/src/main/java/core/packetproxy/quic/service/pnspace/helper/LostPackets.java new file mode 100644 index 0000000..3c204bb --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/pnspace/helper/LostPackets.java @@ -0,0 +1,51 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.pnspace.helper; + +import packetproxy.quic.value.PacketNumber; +import packetproxy.quic.value.SentPacket; + +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; +import java.util.stream.Stream; + +public class LostPackets implements Iterable { + private Map lostPackets = new HashMap<>(); + + public String toString() { + return String.format("Lost %d packets", this.lostPackets.values().size()); + } + + public void add(SentPacket sentPacket) { + lostPackets.put(sentPacket.getPacketNumber(), sentPacket); + } + + public boolean isEmpty() { + return lostPackets.isEmpty(); + } + + public Stream stream() { + return lostPackets.values().stream(); + } + + @Override + public Iterator iterator() { + return lostPackets.values().iterator(); + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/pnspace/helper/SendFrameQueue.java b/src/main/java/core/packetproxy/quic/service/pnspace/helper/SendFrameQueue.java new file mode 100644 index 0000000..01f4bf7 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/pnspace/helper/SendFrameQueue.java @@ -0,0 +1,54 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.pnspace.helper; + +import lombok.Getter; +import packetproxy.quic.value.frame.Frame; +import packetproxy.quic.service.frame.Frames; + +import java.util.*; + +@Getter +public class SendFrameQueue { + + Queue frames; + + public SendFrameQueue() { + this.frames = new ArrayDeque<>(); + } + + public synchronized void add(Frame frame) { + this.frames.add(frame); + } + + public synchronized void add(Frames frames) { + this.frames.addAll(frames.getFrames()); + } + + public synchronized List pollAll() { + List frames = new ArrayList<>(); + for (Frame frame = this.frames.poll(); frame != null; frame = this.frames.poll()) { + frames.add(frame); + } + return frames; + } + + public synchronized void clear() { + this.frames.clear(); + } + +} \ No newline at end of file diff --git a/src/main/java/core/packetproxy/quic/service/pnspace/helper/SentPackets.java b/src/main/java/core/packetproxy/quic/service/pnspace/helper/SentPackets.java new file mode 100644 index 0000000..b1adf3a --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/pnspace/helper/SentPackets.java @@ -0,0 +1,99 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.pnspace.helper; + +import lombok.NoArgsConstructor; +import packetproxy.quic.value.SentPacket; +import packetproxy.quic.value.frame.AckFrame; +import packetproxy.quic.value.packet.PnSpacePacket; +import packetproxy.quic.value.PacketNumber; +import packetproxy.quic.utils.PacketNumbers; + +import java.util.*; + +@NoArgsConstructor +public class SentPackets implements Iterable { + private Map sentPacketMap = new HashMap<>(); + + public SentPackets(Collection sentPacketList) { + sentPacketList.stream().forEach(spkt -> this.sentPacketMap.put(spkt.getPacketNumber(), spkt)); + } + + public synchronized void add(SentPacket sentPacket) { + this.sentPacketMap.put(sentPacket.getPacketNumber(), sentPacket); + } + + public synchronized void sent(PnSpacePacket packet) { + this.sentPacketMap.put(packet.getPacketNumber(), new SentPacket(packet)); + } + + public synchronized boolean isEmpty() { + return this.sentPacketMap.isEmpty(); + } + + public synchronized boolean hasAnyAckElicitingPacket() { + return this.sentPacketMap.values().stream().anyMatch(SentPacket::isAckEliciting); + } + + public synchronized Optional getLargest() { + return this.sentPacketMap.values().stream().max(Comparator.comparingLong(spkt -> spkt.getPacketNumber().getNumber())); + } + + public synchronized Optional getLargestAckFrame() { + return this.sentPacketMap.values().stream() + .filter(SentPacket::hasAckFrame) + .map(spkt -> spkt.getAckFrame()) + .max(Comparator.comparingLong(ackFrame -> ackFrame.get().getLargestAcknowledged())) + .flatMap(a -> a); + } + + /** + * @return newly acked PacketNumbers + */ + public synchronized SentPackets detectAndRemoveAckedPackets(AckFrame ackFrame) { + PacketNumbers ackPns = ackFrame.getAckedPacketNumbers(); + SentPackets newlyAckedPns = new SentPackets(); + ackPns.stream().forEach(pn -> { + if (sentPacketMap.containsKey(pn)) { + SentPacket sentPacket = sentPacketMap.remove(pn); + newlyAckedPns.add(sentPacket); + } + }); + return newlyAckedPns; + } + + public void removePacket(SentPacket sentPacket) { + this.removePacket(sentPacket.getPacketNumber()); + } + + public synchronized void removePacket(PacketNumber packetNumber) { + this.sentPacketMap.remove(packetNumber); + } + + public synchronized SentPackets getUnAckedPackets() { + return new SentPackets(new ArrayList<>(this.sentPacketMap.values())); + } + + public synchronized void clear() { + this.sentPacketMap.clear(); + } + + @Override + public Iterator iterator() { + return this.sentPacketMap.values().iterator(); + } +} diff --git a/src/main/java/core/packetproxy/quic/service/pnspace/level/ApplicationDataPnSpace.java b/src/main/java/core/packetproxy/quic/service/pnspace/level/ApplicationDataPnSpace.java new file mode 100644 index 0000000..6f21ec8 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/pnspace/level/ApplicationDataPnSpace.java @@ -0,0 +1,66 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.pnspace.level; + +import lombok.Getter; +import packetproxy.quic.service.frame.Frames; +import packetproxy.quic.service.framegenerator.MessagesToStreamFrames; +import packetproxy.quic.utils.Constants; +import packetproxy.quic.service.pnspace.PnSpace; +import packetproxy.quic.value.QuicMessage; +import packetproxy.quic.value.frame.Frame; +import packetproxy.quic.service.frame.FramesBuilder; +import packetproxy.quic.service.packet.QuicPacketBuilder; +import packetproxy.quic.service.connection.Connection; + +import java.util.ArrayList; +import java.util.List; + +import static packetproxy.quic.utils.Constants.QuicPacketType.PacketApplication; + +@Getter +public class ApplicationDataPnSpace extends PnSpace { + + private final MessagesToStreamFrames msgToStreamFrames = new MessagesToStreamFrames(); + + public ApplicationDataPnSpace(Connection conn) { + super(conn); + } + + @Override + public void addSendQuicMessage(QuicMessage msg) { + this.msgToStreamFrames.put(msg); + Frames frames = this.msgToStreamFrames.get(); + super.addSendFrames(frames); + } + + @Override + public List getAndRemoveSendFramesAndConvertPacketBuilders() { + List builders = new ArrayList<>(); + for (Frame frame: sendFrameQueue.pollAll()) { + byte[] payload = new FramesBuilder().add(frame).getBytes(); + builders.add(QuicPacketBuilder.getBuilder() + .setPnSpaceType(Constants.PnSpaceType.PnSpaceApplicationData) + .setPacketType(PacketApplication) + .setPacketNumber(this.nextPacketNumber) + .setPayload(payload)); + this.nextPacketNumber = this.nextPacketNumber.plus(1); + } + return builders; + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/pnspace/level/HandshakePnSpace.java b/src/main/java/core/packetproxy/quic/service/pnspace/level/HandshakePnSpace.java new file mode 100644 index 0000000..1c83a1a --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/pnspace/level/HandshakePnSpace.java @@ -0,0 +1,61 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.pnspace.level; + +import lombok.Getter; +import packetproxy.quic.service.connection.Connection; +import packetproxy.quic.service.frame.FramesBuilder; +import packetproxy.quic.service.packet.QuicPacketBuilder; +import packetproxy.quic.service.pnspace.PnSpace; +import packetproxy.quic.utils.Constants; +import packetproxy.quic.value.frame.AckFrame; +import packetproxy.quic.value.frame.Frame; + +import java.util.ArrayList; +import java.util.List; + +import static packetproxy.quic.service.handshake.HandshakeState.State.AckReceived; + +@Getter +public class HandshakePnSpace extends PnSpace { + + public HandshakePnSpace(Connection conn) { + super(conn); + } + + @Override + public void OnAckReceived(AckFrame ackFrame) { + super.conn.getHandshakeState().transit(AckReceived); + super.OnAckReceived(ackFrame); + } + + @Override + public List getAndRemoveSendFramesAndConvertPacketBuilders() { + List builders = new ArrayList<>(); + for (Frame frame: sendFrameQueue.pollAll()) { + byte[] payload = new FramesBuilder().add(frame).getBytes(); + builders.add(QuicPacketBuilder.getBuilder() + .setPnSpaceType(Constants.PnSpaceType.PnSpaceHandshake) + .setPacketType(Constants.QuicPacketType.PacketHandshake) + .setPacketNumber(this.nextPacketNumber) + .setPayload(payload)); + this.nextPacketNumber = this.nextPacketNumber.plus(1); + } + return builders; + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/pnspace/level/InitialPnSpace.java b/src/main/java/core/packetproxy/quic/service/pnspace/level/InitialPnSpace.java new file mode 100644 index 0000000..a89f9c2 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/pnspace/level/InitialPnSpace.java @@ -0,0 +1,63 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.pnspace.level; + +import lombok.Getter; +import packetproxy.quic.utils.Constants; +import packetproxy.quic.service.pnspace.PnSpace; +import packetproxy.quic.value.frame.Frame; +import packetproxy.quic.service.frame.FramesBuilder; +import packetproxy.quic.value.packet.QuicPacket; +import packetproxy.quic.service.packet.QuicPacketBuilder; +import packetproxy.quic.value.packet.longheader.pnspace.InitialPacket; +import packetproxy.quic.service.connection.Connection; + +import java.util.ArrayList; +import java.util.List; + +@Getter +public class InitialPnSpace extends PnSpace { + + public InitialPnSpace(Connection conn) { + super(conn); + } + + @Override + public void receivePacket(QuicPacket packet) { + if (packet instanceof InitialPacket) { + InitialPacket ip = (InitialPacket) packet; + this.conn.updateDestConnId(ip.getSrcConnId()); + } + super.receivePacket(packet); + } + + @Override + public List getAndRemoveSendFramesAndConvertPacketBuilders() { + List builders = new ArrayList<>(); + for (Frame frame: sendFrameQueue.pollAll()) { + byte[] payload = new FramesBuilder().add(frame).addPaddingFramesToEnsure1200Bytes().getBytes(); + builders.add(QuicPacketBuilder.getBuilder() + .setPnSpaceType(Constants.PnSpaceType.PnSpaceInitial) + .setPacketType(Constants.QuicPacketType.PacketInitial) + .setPacketNumber(super.nextPacketNumber) + .setPayload(payload)); + super.nextPacketNumber = super.nextPacketNumber.plus(1); + } + return builders; + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/transportparameter/TransportParameterParser.java b/src/main/java/core/packetproxy/quic/service/transportparameter/TransportParameterParser.java new file mode 100644 index 0000000..05115e2 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/transportparameter/TransportParameterParser.java @@ -0,0 +1,67 @@ +package packetproxy.quic.service.transportparameter; + +import com.google.common.collect.Sets; +import packetproxy.quic.value.VariableLengthInteger; +import packetproxy.quic.value.transportparameter.TransportParameter; +import packetproxy.quic.value.transportparameter.UnknownParameter; + +import javax.tools.*; +import java.lang.reflect.Modifier; +import java.nio.ByteBuffer; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.HashMap; +import java.util.Map; +import java.util.Set; + +public class TransportParameterParser { + + private static final String transportParameterPackage = "packetproxy.quic.value.transportparameter"; + private static final Class transportParameterClass = TransportParameter.class; + private static Map> transportParameterMap; + + static public TransportParameter parse(ByteBuffer buffer) throws Exception { + int saved = buffer.position(); + long type = VariableLengthInteger.parse(buffer).getValue(); + buffer.position(saved); + + if (transportParameterMap == null) { + createTransportParameterMap(); + } + + Class klass = transportParameterMap.get(type); + if (klass == null) { + klass = transportParameterMap.get(UnknownParameter.ID); + } + return createInstance(klass, buffer); + } + + static private TransportParameter createInstance(Class klass, ByteBuffer buffer) throws Exception { + return klass.getConstructor(ByteBuffer.class).newInstance(buffer); + } + + static private TransportParameter createInstance(Class klass) throws Exception { + return klass.getConstructor().newInstance(); + } + + private static void createTransportParameterMap() throws Exception { + transportParameterMap = new HashMap<>(); + JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); + JavaFileManager fm = compiler.getStandardFileManager(new DiagnosticCollector(), null, null); + + Set kind = Sets.newHashSet(JavaFileObject.Kind.CLASS); + for (JavaFileObject f : fm.list(StandardLocation.CLASS_PATH, transportParameterPackage, kind, true)) { + Path encode_file_path = Paths.get(f.getName()); + String encode_class_path = encode_file_path.toString() + .replaceAll("/",".") + .replaceFirst("^.*" + transportParameterPackage, transportParameterPackage) + .replaceAll("\\.class.*$", ""); + Class klass = Class.forName(encode_class_path); + if(transportParameterClass.isAssignableFrom(klass) && !Modifier.isAbstract(klass.getModifiers())){ + long id = klass.getField("ID").getLong(null); + transportParameterMap.put(id, (Class)klass); + } + } + } + +} diff --git a/src/main/java/core/packetproxy/quic/service/transportparameter/TransportParameters.java b/src/main/java/core/packetproxy/quic/service/transportparameter/TransportParameters.java new file mode 100644 index 0000000..225d5ef --- /dev/null +++ b/src/main/java/core/packetproxy/quic/service/transportparameter/TransportParameters.java @@ -0,0 +1,174 @@ +package packetproxy.quic.service.transportparameter; + +import lombok.Getter; +import lombok.Setter; +import lombok.ToString; +import net.luminis.tls.extension.Extension; +import packetproxy.quic.utils.Constants; +import packetproxy.quic.value.SimpleBytes; +import packetproxy.quic.value.transportparameter.*; +import packetproxy.quic.value.transportparameter.bool.DisableActiveMigrationParameter; +import packetproxy.quic.value.transportparameter.bool.ExpGreaseQuicBitParameter; +import packetproxy.quic.value.transportparameter.bytearray.InitSrcConnIdParameter; +import packetproxy.quic.value.transportparameter.bytearray.OrigDestConnIdParameter; +import packetproxy.quic.value.transportparameter.bytearray.RetrySrcConnIdParameter; +import packetproxy.quic.value.transportparameter.bytearray.StatelessResetTokenParameter; +import packetproxy.quic.value.transportparameter.complex.PreferredAddressParameter; +import packetproxy.quic.value.transportparameter.number.*; + +import java.nio.ByteBuffer; + +@Getter +@Setter +@ToString +public class TransportParameters extends Extension { + private final Constants.Role role; + private long initMaxData = 0; + private long initMaxStreamDataBidiLocal = 0; + private long initMaxStreamDataBidiRemote = 0; + private long initMaxStreamBidi = 0; + private long initMaxStreamDataUni = 0; + private long initMaxStreamUni = 0; + private byte[] initSrcConnId = new byte[0]; + private long ackDelayExponent = 3; + private long activeConnIdLimit = 2; + private boolean disableActiveMigration = false; + private long maxAckDelay = 25; + private long oldMinAckDelay = 0; + private long expMinAckDelay = 0; + private long maxIdleTimeout = 0; + private long maxUdpPayloadSize = 65527; + private byte[] origDestConnId = new byte[0]; + private byte[] preferredAddress = new byte[0]; + private byte[] retrySrcConnId = new byte[0]; + private byte[] statelessResetToken = new byte[0]; + private long oldTimestamp = 0; + private boolean expGreaseQuicBit = false; + + public TransportParameters(Constants.Role role) { + this.role = role; + } + + public TransportParameters(Constants.Role role, byte[] bytes) throws Exception { + this(role, ByteBuffer.wrap(bytes)); + } + + public TransportParameters(Constants.Role role, ByteBuffer buffer) throws Exception { + this.role = role; + short type = buffer.getShort(); + if (type != 0x39) { + throw new Exception(String.format("[Error] not TransportParameterExtension (type: %04x)", type)); + } + + short length = buffer.getShort(); + if (length == 0) { + return; + } + + int endPosition = buffer.position() + length; + while (buffer.position() < endPosition) { + TransportParameter param = TransportParameterParser.parse(buffer); + setLocalVariableFromTransportParameter(param); + } + } + + private void setLocalVariableFromTransportParameter(TransportParameter param) { + if (param instanceof InitMaxStreamDataBidiLocalParameter) { + this.initMaxStreamDataBidiLocal = ((InitMaxStreamDataBidiLocalParameter) param).getValue(); + + } else if (param instanceof InitMaxStreamDataBidiRemoteParameter) { + this.initMaxStreamDataBidiRemote = ((InitMaxStreamDataBidiRemoteParameter) param).getValue(); + + } else if (param instanceof InitMaxStreamDataUniParameter) { + this.initMaxStreamDataUni = ((InitMaxStreamDataUniParameter) param).getValue(); + + } else if (param instanceof InitMaxStreamBidiParameter) { + this.initMaxStreamBidi = ((InitMaxStreamBidiParameter) param).getValue(); + + } else if (param instanceof InitMaxStreamUniParameter) { + this.initMaxStreamUni = ((InitMaxStreamUniParameter) param).getValue(); + + } else if (param instanceof InitMaxDataParameter) { + this.initMaxData = ((InitMaxDataParameter) param).getValue(); + + } else if (param instanceof InitSrcConnIdParameter) { + this.initSrcConnId = ((InitSrcConnIdParameter) param).getValue(); + + } else if (param instanceof AckDelayExponentParameter) { + this.ackDelayExponent = ((AckDelayExponentParameter) param).getValue(); + + } else if (param instanceof ActiveConnIdLimitParameter) { + this.activeConnIdLimit = ((ActiveConnIdLimitParameter) param).getValue(); + + } else if (param instanceof DisableActiveMigrationParameter) { + this.disableActiveMigration = true; + + } else if (param instanceof MaxAckDelayParameter) { + this.maxAckDelay = ((MaxAckDelayParameter) param).getValue(); + + } else if (param instanceof MaxIdleTimeoutParameter) { + this.maxIdleTimeout = ((MaxIdleTimeoutParameter) param).getValue(); + + } else if (param instanceof MaxUdpPayloadSizeParameter) { + this.maxUdpPayloadSize = ((MaxUdpPayloadSizeParameter) param).getValue(); + + } else if (param instanceof OrigDestConnIdParameter) { + this.origDestConnId = ((OrigDestConnIdParameter) param).getValue(); + + } else if (param instanceof PreferredAddressParameter) { + this.preferredAddress = ((PreferredAddressParameter) param).getValue(); + + } else if (param instanceof RetrySrcConnIdParameter) { + this.retrySrcConnId = ((RetrySrcConnIdParameter) param).getValue(); + + } else if (param instanceof StatelessResetTokenParameter) { + this.statelessResetToken = ((StatelessResetTokenParameter) param).getValue(); + + } else if (param instanceof OldMinAckDelayParameter) { + this.oldMinAckDelay = ((OldMinAckDelayParameter) param).getValue(); + + } else if (param instanceof ExpMinAckDelayParameter) { + this.expMinAckDelay = ((ExpMinAckDelayParameter) param).getValue(); + + } else if (param instanceof OldTimestampParameter) { + this.oldTimestamp = ((OldTimestampParameter) param).getValue(); + + } else if (param instanceof ExpGreaseQuicBitParameter) { + this.expGreaseQuicBit = true; + + } else if (param instanceof UnknownParameter) { + System.err.println(String.format("[Error] Unknown Transport Parameter: %s", param)); + } + } + + @Override + public byte[] getBytes() { + ByteBuffer paramsBuffer = ByteBuffer.allocate(1500); + paramsBuffer.put(new MaxUdpPayloadSizeParameter(this.maxUdpPayloadSize).getBytes()); + paramsBuffer.put(new InitSrcConnIdParameter(this.initSrcConnId).getBytes()); + paramsBuffer.put(new InitMaxDataParameter(this.initMaxData).getBytes()); + paramsBuffer.put(new InitMaxStreamUniParameter(this.initMaxStreamUni).getBytes()); + paramsBuffer.put(new InitMaxStreamBidiParameter(this.initMaxStreamBidi).getBytes()); + paramsBuffer.put(new InitMaxStreamDataBidiLocalParameter(this.initMaxStreamDataBidiLocal).getBytes()); + paramsBuffer.put(new InitMaxStreamDataBidiRemoteParameter(this.initMaxStreamDataBidiRemote).getBytes()); + paramsBuffer.put(new InitMaxStreamDataUniParameter(this.initMaxStreamDataUni).getBytes()); + //paramsBuffer.put(new OldMinAckDelayParameter(this.oldMinAckDelay).getBytes()); + paramsBuffer.put(new AckDelayExponentParameter(this.ackDelayExponent).getBytes()); + paramsBuffer.put(new MaxIdleTimeoutParameter(this.maxIdleTimeout).getBytes()); + if (this.role == Constants.Role.SERVER) { + paramsBuffer.put(new OrigDestConnIdParameter(this.origDestConnId).getBytes()); + paramsBuffer.put(new ActiveConnIdLimitParameter(this.activeConnIdLimit).getBytes()); + if (this.disableActiveMigration) { + paramsBuffer.put(new DisableActiveMigrationParameter().getBytes()); + } + } + paramsBuffer.flip(); + + ByteBuffer buffer = ByteBuffer.allocate(1500); + buffer.putShort((short)0x39); + buffer.putShort((short)paramsBuffer.remaining()); + buffer.put(SimpleBytes.parse(paramsBuffer, paramsBuffer.remaining()).getBytes()); + buffer.flip(); + return SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + } +} diff --git a/src/main/java/core/packetproxy/quic/utils/AwaitingException.java b/src/main/java/core/packetproxy/quic/utils/AwaitingException.java new file mode 100644 index 0000000..0a4bb2b --- /dev/null +++ b/src/main/java/core/packetproxy/quic/utils/AwaitingException.java @@ -0,0 +1,23 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.utils; + +public class AwaitingException extends Exception { + public AwaitingException(String msg) { + super(msg); + } +} diff --git a/src/main/java/core/packetproxy/quic/utils/Constants.java b/src/main/java/core/packetproxy/quic/utils/Constants.java new file mode 100644 index 0000000..29c12d2 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/utils/Constants.java @@ -0,0 +1,45 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.utils; + +public class Constants { + + public enum Role { + CLIENT, + SERVER, + } + + public enum QuicPacketType { + PacketInitial, + PacketHandshake, + PacketZeroRTT, + PacketApplication, + } + + public enum PnSpaceType { + PnSpaceInitial, + PnSpaceHandshake, + PnSpaceApplicationData, + } + + static public final int CONNECTION_ID_SIZE = 8; // Max: 20 bytes + static public final int TOKEN_SIZE = 16; + static public final long kGranularity = 1; // 1ms + static public final float kTimeThreshold = 9f/8f; + static public final long kPacketThreshold = 3; + +} diff --git a/src/main/java/core/packetproxy/quic/utils/PacketNumbers.java b/src/main/java/core/packetproxy/quic/utils/PacketNumbers.java new file mode 100644 index 0000000..30b96f7 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/utils/PacketNumbers.java @@ -0,0 +1,57 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.utils; + +import packetproxy.quic.value.PacketNumber; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; +import java.util.Optional; +import java.util.stream.Stream; + +public class PacketNumbers { + + List packetNumberList; + + public PacketNumbers() { + this.packetNumberList = new ArrayList<>(); + } + + public boolean add(PacketNumber packetNumber) { + return this.packetNumberList.add(packetNumber); + } + + public boolean addAll(PacketNumbers packetNumbers) { + return this.packetNumberList.addAll(packetNumbers.packetNumberList); + } + + public Stream stream() { + return this.packetNumberList.stream(); + } + + public boolean isEmpty() { + return this.packetNumberList.isEmpty(); + } + + public PacketNumber largest() { + Optional pn = this.packetNumberList.stream().max(Comparator.comparingLong(PacketNumber::getNumber)); + return pn.orElse(null); + } + + +} diff --git a/src/main/java/core/packetproxy/quic/utils/ScheduledTimer.java b/src/main/java/core/packetproxy/quic/utils/ScheduledTimer.java new file mode 100644 index 0000000..7053764 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/utils/ScheduledTimer.java @@ -0,0 +1,53 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.utils; + + +import java.time.Duration; +import java.time.Instant; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.ScheduledFuture; +import java.util.concurrent.TimeUnit; + +public class ScheduledTimer { + + private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1); + private final Runnable onTimeout; + private ScheduledFuture future; + + public ScheduledTimer(Runnable onTimeout) { + this.onTimeout = onTimeout; + this.future = null; + } + + public synchronized void update(Instant time) { + if (time == Instant.MAX) { + this.cancel(); + } else { + long delay = Duration.between(Instant.now(), time).toMillis(); + this.future = this.scheduler.schedule(this.onTimeout, delay, TimeUnit.MILLISECONDS); + } + } + + public synchronized void cancel() { + if (this.future != null) { + this.future.cancel(false); + } + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/ConnectionId.java b/src/main/java/core/packetproxy/quic/value/ConnectionId.java new file mode 100644 index 0000000..681a4db --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/ConnectionId.java @@ -0,0 +1,54 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value; + +import lombok.AccessLevel; +import lombok.Getter; +import lombok.Value; +import org.apache.commons.codec.binary.Hex; +import packetproxy.quic.utils.Constants; + +import java.nio.ByteBuffer; +import java.security.SecureRandom; + +@Value(staticConstructor = "of") +public class ConnectionId { + + static public ConnectionId generateRandom() { + byte[] connId = new byte[Constants.CONNECTION_ID_SIZE]; + new SecureRandom().nextBytes(connId); + return new ConnectionId(connId); + } + + static public ConnectionId parse(ByteBuffer buffer, long length) { + byte[] connId = SimpleBytes.parse(buffer, length).getBytes(); + return new ConnectionId(connId); + } + + @Getter(AccessLevel.NONE) + byte[] connId; + + + public byte[] getBytes() { + return connId; + } + + @Override + public String toString() { + return String.format("ConnectionId([%s])", Hex.encodeHexString(this.connId)); + } +} diff --git a/src/main/java/core/packetproxy/quic/value/ConnectionIdPair.java b/src/main/java/core/packetproxy/quic/value/ConnectionIdPair.java new file mode 100644 index 0000000..edb6f64 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/ConnectionIdPair.java @@ -0,0 +1,30 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value; + +import lombok.Value; + +@Value(staticConstructor = "of") +public class ConnectionIdPair { + + static public ConnectionIdPair generateRandom() { + return ConnectionIdPair.of(ConnectionId.generateRandom(), ConnectionId.generateRandom()); + } + + ConnectionId srcConnId; + ConnectionId destConnId; +} diff --git a/src/main/java/core/packetproxy/quic/value/FixedLengthPrecededBytes.java b/src/main/java/core/packetproxy/quic/value/FixedLengthPrecededBytes.java new file mode 100644 index 0000000..858912f --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/FixedLengthPrecededBytes.java @@ -0,0 +1,50 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value; + +import lombok.Getter; + +import java.nio.ByteBuffer; + +@Getter +public class FixedLengthPrecededBytes { + + static public FixedLengthPrecededBytes of(byte[] bytes) { + return new FixedLengthPrecededBytes(bytes); + } + + static public FixedLengthPrecededBytes parse(ByteBuffer buffer) { + byte length = buffer.get(); + byte[] bytes = new byte[length]; + buffer.get(bytes); + return new FixedLengthPrecededBytes(bytes); + } + + private byte[] bytes; + + private FixedLengthPrecededBytes(byte[] bytes) { + this.bytes = bytes; + } + + public byte[] serialize() { + ByteBuffer buffer = ByteBuffer.allocate(255); + buffer.put((byte)bytes.length); + buffer.put(bytes); + buffer.flip(); + return SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + } +} diff --git a/src/main/java/core/packetproxy/quic/value/PacketNumber.java b/src/main/java/core/packetproxy/quic/value/PacketNumber.java new file mode 100644 index 0000000..32f44fe --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/PacketNumber.java @@ -0,0 +1,89 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value; + +import lombok.AccessLevel; +import lombok.Getter; +import lombok.SneakyThrows; +import lombok.Value; + +@Value +public class PacketNumber { + + static public final PacketNumber Infinite = new PacketNumber(); + + static public PacketNumber of(long number) { + return new PacketNumber(number); + } + + static public PacketNumber max(PacketNumber a, PacketNumber b) { + return a.getNumber() > b.getNumber() ? a : b; + } + + @Getter(AccessLevel.NONE) + boolean infinite; + long number; + + private PacketNumber() { + this.number = -1; + this.infinite = true; + } + + private PacketNumber(long number) { + assert(number >= 0); + this.number = number; + this.infinite = false; + } + + public boolean isInfinite() { + return infinite; + } + + public TruncatedPacketNumber getTruncatedPacketNumber(PacketNumber largestAckedPn) { + if (!this.infinite) { + return new TruncatedPacketNumber(this, largestAckedPn); + } + return null; + } + + @SneakyThrows + public PacketNumber plus(long num) { + return new PacketNumber(this.number + num); + } + + @SneakyThrows + public PacketNumber minus(long num) { + return new PacketNumber(this.number - num); + } + + public long minus(PacketNumber packetPn) { + return this.number - packetPn.number; + } + + public boolean isLargerThan(PacketNumber packetPn) { + return this.number > packetPn.getNumber(); + } + + public boolean isLargerThanOrEquals(PacketNumber packetPn) { + return this.number >= packetPn.getNumber(); + } + + public String toString() { + return "PacketNumber(" + (this.infinite ? "INF": this.number) + ")"; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/QuicMessage.java b/src/main/java/core/packetproxy/quic/value/QuicMessage.java new file mode 100644 index 0000000..b9e9851 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/QuicMessage.java @@ -0,0 +1,77 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value; + +import lombok.AllArgsConstructor; +import lombok.Value; +import org.apache.commons.codec.binary.Hex; + +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.List; + +/* +QuicMessage { + streamId: 8 bytes + dataLength: 8 bytes + data: ... +} +*/ +@AllArgsConstructor(staticName = "of") +@Value +public class QuicMessage { + + static public List parse(ByteBuffer buffer) { + List msgs = new ArrayList<>(); + while (buffer.remaining() > 16) { + int savedPosition = buffer.position(); + long streamId = buffer.getLong(); + long dataLength = buffer.getLong(); + if (buffer.remaining() < dataLength) { + buffer.position(savedPosition); + break; + } + byte[] data = SimpleBytes.parse(buffer, dataLength).getBytes(); + msgs.add(new QuicMessage(streamId, data)); + } + return msgs; + } + + long streamId; + byte[] data; + + /** + * @return data to be passed to encoder module + * streamId: 8 bytes + * dataLength: 8 bytes + * data: x bytes + */ + public byte[] getBytes() { + ByteBuffer buffer = ByteBuffer.allocate(data.length + 16); + buffer.putLong(this.streamId); + buffer.putLong(this.data.length); + buffer.put(data); + return buffer.array(); + } + + @Override + public String toString() { + return String.format("QuicMessage(streamId=%d, data=[%s])", + this.streamId, + Hex.encodeHexString(this.data)); + } +} diff --git a/src/main/java/core/packetproxy/quic/value/SentPacket.java b/src/main/java/core/packetproxy/quic/value/SentPacket.java new file mode 100644 index 0000000..be3a770 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/SentPacket.java @@ -0,0 +1,50 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value; + +import lombok.Value; +import packetproxy.quic.value.frame.AckFrame; +import packetproxy.quic.value.packet.PnSpacePacket; + +import java.time.Instant; +import java.util.Optional; + +@Value +public class SentPacket { + + PacketNumber packetNumber; + Instant timeSent; + PnSpacePacket packet; + + public SentPacket(PnSpacePacket packet) { + this.packet = packet; + this.packetNumber = packet.getPacketNumber(); + this.timeSent = Instant.now(); + } + + public boolean isAckEliciting() { + return this.packet.isAckEliciting(); + } + + public boolean hasAckFrame() { + return this.packet.hasAckFrame(); + } + + public Optional getAckFrame() { + return this.packet.getAckFrame(); + } +} diff --git a/src/main/java/core/packetproxy/quic/value/SimpleBytes.java b/src/main/java/core/packetproxy/quic/value/SimpleBytes.java new file mode 100644 index 0000000..ec7685b --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/SimpleBytes.java @@ -0,0 +1,39 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value; + +import lombok.Value; + +import java.nio.ByteBuffer; + +@Value +public class SimpleBytes { + + static public SimpleBytes parse(ByteBuffer buffer, long sizeOfBytes) { + byte[] bytes = new byte[(int)sizeOfBytes]; + buffer.get(bytes); + return new SimpleBytes(bytes); + } + + static public SimpleBytes parse(ByteBuffer buffer, int sizeOfBytes) { + byte[] bytes = new byte[sizeOfBytes]; + buffer.get(bytes); + return new SimpleBytes(bytes); + } + + byte[] bytes; +} diff --git a/src/main/java/core/packetproxy/quic/value/Token.java b/src/main/java/core/packetproxy/quic/value/Token.java new file mode 100644 index 0000000..554b13c --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/Token.java @@ -0,0 +1,47 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value; + +import lombok.AccessLevel; +import lombok.Getter; +import lombok.Value; +import org.apache.commons.codec.binary.Hex; + +import java.security.SecureRandom; + +@Value(staticConstructor = "of") +public class Token { + + static public Token generateRandom(int size) { + byte[] token = new byte[size]; + new SecureRandom().nextBytes(token); + return new Token(token); + } + + @Getter(AccessLevel.NONE) + byte[] token; + + public byte[] getBytes() { + return token; + } + + @Override + public String toString() { + return String.format("Token([%s])", Hex.encodeHexString(this.token)); + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/TruncatedPacketNumber.java b/src/main/java/core/packetproxy/quic/value/TruncatedPacketNumber.java new file mode 100644 index 0000000..f2d4b8f --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/TruncatedPacketNumber.java @@ -0,0 +1,135 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value; + +import lombok.AccessLevel; +import lombok.Getter; +import lombok.Value; +import org.apache.commons.codec.binary.Hex; + +import java.nio.ByteBuffer; + +@Value +public class TruncatedPacketNumber { + + @Getter(AccessLevel.NONE) + byte[] truncatedPacketNumber; + + public TruncatedPacketNumber(byte[] truncatedPacketNumber) { + this.truncatedPacketNumber = truncatedPacketNumber; + } + + public TruncatedPacketNumber(PacketNumber packetNumber, PacketNumber largestAckPn) { + this.truncatedPacketNumber = this.encode(packetNumber, largestAckPn); + } + + static public byte[] unmaskTruncatedPacketNumber(byte[] truncatedPacketNumber, byte[] maskKey) { + return maskTruncatedPacketNumber(truncatedPacketNumber, maskKey); + } + + static public byte[] maskTruncatedPacketNumber(byte[] truncatedPacketNumber, byte[] maskKey) { + ByteBuffer pn = ByteBuffer.allocate(truncatedPacketNumber.length); + for (int i = 0; i < truncatedPacketNumber.length; i++) { + pn.put((byte)(truncatedPacketNumber[i] ^ maskKey[1+i])); + } + pn.flip(); + return pn.array(); + } + + public byte[] getBytes() { + return truncatedPacketNumber; + } + + public PacketNumber getPacketNumber(PacketNumber largestAckedPn) { + long packetNumber = decode(this.truncatedPacketNumber, largestAckedPn); + return PacketNumber.of(packetNumber); + } + + public String toString() { + return String.format("TruncatedPacketNumber([%s])", Hex.encodeHexString(this.truncatedPacketNumber)); + } + + /* https://www.rfc-editor.org/rfc/rfc9000.html#section-a.2 */ + static private byte[] encode(PacketNumber packetNumber, PacketNumber largestAckPn) { + /* + * The number of bits must be at least one more + * than the base-2 logarithm of the number of contiguous + * unacknowledged packet numbers, including the new packet. + */ + long numUnAcked = (largestAckPn.isInfinite()) ? + packetNumber.getNumber() + 1: + packetNumber.getNumber() - largestAckPn.getNumber(); + + double minBits = Math.log(numUnAcked) / Math.log(2) + 1; + int numBytes = (int)Math.ceil(minBits / 8); + + /* truncate to the least significant bytes. */ + return truncate(packetNumber.getNumber(), numBytes); + } + + /* https://www.rfc-editor.org/rfc/rfc9000.html#section-a.1 */ + static private long decode(byte[] truncatedPacketNumberBytes, PacketNumber largestAckPn) { + long truncatedPn = bytesToLong(truncatedPacketNumberBytes); + int bits = truncatedPacketNumberBytes.length * 8; + long expectedPn = largestAckPn.getNumber() + 1; + long pnWindow = 1L << bits; + long pnHalfWindow = pnWindow / 2; + long pnMask = ~(pnWindow - 1); + + long candidatePn = (expectedPn & pnMask) | truncatedPn; + if (candidatePn <= expectedPn - pnHalfWindow && candidatePn < (1L << 62) - pnWindow) { + return candidatePn + pnWindow; + } + if (candidatePn > expectedPn + pnHalfWindow && candidatePn >= pnWindow) { + return candidatePn - pnWindow; + } + return candidatePn; + } + + static private long bytesToLong(byte[] bytes) { + switch (bytes.length) { + case 1: + return bytes[0] & 0xff; + case 2: + return ((bytes[0] & 0xff) << 8) | (bytes[1] & 0xff); + case 3: + return ((bytes[0] & 0xff) << 16) | ((bytes[1] & 0xff) << 8) | (bytes[2] & 0xff); + case 4: + return ((long) (bytes[0] & 0xff) << 24) | ((bytes[1] & 0xff) << 16) | ((bytes[2] & 0xff) << 8) | (bytes[3] & 0xff); + default: + System.err.println("[Error] can't decode packetNumber from ByteArray to Long"); + return 0; + } + } + + static private byte[] truncate(long packetNumber, int byteLength) { + if (byteLength == 1) { + return new byte[] { (byte)(packetNumber & 0xff) }; + } + else if (byteLength == 2) { + return new byte[] { (byte)((packetNumber >> 8) & 0xff), (byte)(packetNumber & 0xff) }; + } + else if (byteLength == 3) { + return new byte[] { (byte)((packetNumber >> 16) & 0xff), (byte)((packetNumber >> 8) & 0xff), (byte)(packetNumber & 0xff) }; + } + else if (byteLength >= 4) { + return new byte[] { (byte)((packetNumber >> 24) & 0xff), (byte)((packetNumber >> 16) & 0xff), (byte)((packetNumber >> 8) & 0xff), (byte)(packetNumber & 0xff) }; + } + System.err.println(String.format("[Error] can't encode packetNumber from Long to ByteArray (byteLength=%d)", byteLength)); + return null; + } +} diff --git a/src/main/java/core/packetproxy/quic/value/VariableLengthInteger.java b/src/main/java/core/packetproxy/quic/value/VariableLengthInteger.java new file mode 100644 index 0000000..0cb58be --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/VariableLengthInteger.java @@ -0,0 +1,112 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value; + +import lombok.Value; + +import java.nio.ByteBuffer; + +/* +https://datatracker.ietf.org/doc/html/draft-ietf-quic-transport-20#section-16 ++------+--------+-------------+-----------------------+ +| 2Bit | Length | Usable Bits | Range | ++------+--------+-------------+-----------------------+ +| 00 | 1 | 6 | 0-63 | +| 01 | 2 | 14 | 0-16383 | +| 10 | 4 | 30 | 0-1073741823 | +| 11 | 8 | 62 | 0-4611686018427387903 | ++------+--------+-------------+-----------------------+ +*/ +@Value +public class VariableLengthInteger { + + static public VariableLengthInteger of(long value) { + return new VariableLengthInteger(value); + } + + static public VariableLengthInteger parse(byte[] bytes) { + int len = bytes.length; + long val = 0; + for (int i = 0; i < len; i++) { + if (i == 0) { + val = bytes[0] & 0x3f; + } else { + val = (val << 8) | (((long)bytes[i]) & 0xff); + } + } + return new VariableLengthInteger(val); + } + + static public VariableLengthInteger parse(ByteBuffer buffer) { + byte byte0 = buffer.get(); + int length = estimateLength(byte0); + buffer.position(buffer.position() - 1); + return parse(SimpleBytes.parse(buffer, length).getBytes()); + } + + static private int estimateLength(byte byte0) { + switch (byte0 & 0xc0) { + case 0x00: + return 1; + case 0x40: + return 2; + case 0x80: + return 4; + case 0xc0: + return 8; + default: + return -1; // never reach here + } + } + + + static private int estimateLength(long value) { + assert(0 <= value && value < 0x4000000000000000L); + if (value < 0x40L) { + return 1; + } else if (value < 0x4000L) { + return 2; + } else if (value < 0x40000000L) { + return 4; + } else { + return 8; + } + } + + long value; + + public byte[] getBytes() { + int len = estimateLength(this.value); + ByteBuffer buf = ByteBuffer.allocate(len); + switch (len) { + case 1: + buf.put( (byte)this.value ); + break; + case 2: + buf.putShort( (short)(((short)this.value) | 0x4000) ); + break; + case 4: + buf.putInt( ((int)this.value) | 0x80000000 ); + break; + case 8: + buf.putLong(this.value | 0xC000000000000000L); + break; + } + return buf.array(); + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/VariableLengthPrecededBytes.java b/src/main/java/core/packetproxy/quic/value/VariableLengthPrecededBytes.java new file mode 100644 index 0000000..e1d36b4 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/VariableLengthPrecededBytes.java @@ -0,0 +1,50 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value; + +import lombok.Getter; +import org.apache.commons.lang3.ArrayUtils; + +import java.nio.ByteBuffer; + +@Getter +public class VariableLengthPrecededBytes { + + static public VariableLengthPrecededBytes of(byte[] bytes) { + return new VariableLengthPrecededBytes(bytes); + } + + static public VariableLengthPrecededBytes parse(ByteBuffer buffer) { + long length = VariableLengthInteger.parse(buffer).getValue(); + byte[] bytes = new byte[]{}; + if (length > 0) { + bytes = new byte[(int) length]; + buffer.get(bytes); + } + return new VariableLengthPrecededBytes(bytes); + } + + private byte[] bytes; + + private VariableLengthPrecededBytes(byte[] bytes) { + this.bytes = bytes; + } + + public byte[] serialize() { + return ArrayUtils.addAll(VariableLengthInteger.of(bytes.length).getBytes(), bytes); + } +} diff --git a/src/main/java/core/packetproxy/quic/value/frame/AckEcnFrame.java b/src/main/java/core/packetproxy/quic/value/frame/AckEcnFrame.java new file mode 100644 index 0000000..c33f376 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/AckEcnFrame.java @@ -0,0 +1,105 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import com.google.common.collect.ImmutableList; +import lombok.*; +import packetproxy.quic.value.frame.helper.AckRanges; +import packetproxy.quic.value.VariableLengthInteger; + +import java.nio.ByteBuffer; +import java.util.List; + + +/* RFC9000 19.3 +ACK Frame { + Type (i) = 0x02..0x03, + Largest Acknowledged (i), + ACK Delay (i), + ACK Range Count (i), + First ACK Range (i), + ACK Range (..) ..., + [ECN Counts (..)], // if type is 0x03 +} + +ACK Range { + Gap (i), + ACK Range Length (i), +} + +ECN Counts { + ECT0 Count (i), + ECT1 Count (i), + ECN-CE Count (i), +} +*/ + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class AckEcnFrame extends AckFrame { + + static public final byte TYPE = 0x03; + + static public List supportedTypes() { + return ImmutableList.of(TYPE); + } + + long etc0Count; + long etc1Count; + long ecnCeCount; + + static public AckEcnFrame parse(byte[] bytes) { + return AckEcnFrame.parse(ByteBuffer.wrap(bytes)); + } + + static public AckEcnFrame parse(ByteBuffer buffer) { + AckFrame ackFrame = AckFrame.parse(buffer); + long etc0Count = VariableLengthInteger.parse(buffer).getValue(); + long etc1Count = VariableLengthInteger.parse(buffer).getValue(); + long ecnCeCount = VariableLengthInteger.parse(buffer).getValue(); + return new AckEcnFrame( + ackFrame.getLargestAcknowledged(), + ackFrame.getAckDelay(), + ackFrame.getAckRangeCount(), + ackFrame.getFirstAckRange(), + ackFrame.getAckRanges(), + etc0Count, + etc1Count, + ecnCeCount); + } + + public AckEcnFrame(long largestAcknowledged, + long ackDelay, + long ackRangeCount, + long firstAckRange, + AckRanges ackRanges, + long etc0Count, + long etc1Count, + long ecnCeCount) { + super(largestAcknowledged, ackDelay, ackRangeCount, firstAckRange, ackRanges); + this.etc0Count = etc0Count; + this.etc1Count = etc1Count; + this.ecnCeCount = ecnCeCount; + } + + @Override + public boolean isAckEliciting() { + return false; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/frame/AckFrame.java b/src/main/java/core/packetproxy/quic/value/frame/AckFrame.java new file mode 100644 index 0000000..57ab3b5 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/AckFrame.java @@ -0,0 +1,118 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import com.google.common.collect.ImmutableList; +import lombok.*; +import lombok.experimental.NonFinal; +import packetproxy.quic.value.frame.helper.AckRanges; +import packetproxy.quic.value.PacketNumber; +import packetproxy.quic.utils.PacketNumbers; +import packetproxy.quic.value.SimpleBytes; +import packetproxy.quic.value.VariableLengthInteger; + +import java.nio.ByteBuffer; +import java.util.List; + + +/* RFC9000 19.3 +ACK Frame { + Type (i) = 0x02..0x03, + Largest Acknowledged (i), + ACK Delay (i), + ACK Range Count (i), + First ACK Range (i), + ACK Range (..) ..., + [ECN Counts (..)], // if type is 0x03 +} + +ACK Range { + Gap (i), + ACK Range Length (i), +} + +ECN Counts { + ECT0 Count (i), + ECT1 Count (i), + ECN-CE Count (i), +} +*/ + +@Value +@NonFinal +@EqualsAndHashCode(callSuper = true) +public class AckFrame extends Frame { + + static public final byte TYPE = 0x02; + + static public List supportedTypes() { + return ImmutableList.of(TYPE); + } + + long largestAcknowledged; + long ackDelay; + long ackRangeCount; + long firstAckRange; + AckRanges ackRanges; + + static public AckFrame parse(byte[] bytes) { + return AckFrame.parse(ByteBuffer.wrap(bytes)); + } + + static public AckFrame parse(ByteBuffer buffer) { + byte type = buffer.get(); + long largestAcknowledged = VariableLengthInteger.parse(buffer).getValue(); + long ackDelay = VariableLengthInteger.parse(buffer).getValue(); + long ackRangeCount = VariableLengthInteger.parse(buffer).getValue(); + long firstAckRange = VariableLengthInteger.parse(buffer).getValue(); + AckRanges ackRanges = new AckRanges(buffer, ackRangeCount); + return new AckFrame(largestAcknowledged, ackDelay, ackRangeCount, firstAckRange, ackRanges); + } + + @SneakyThrows + public PacketNumber getLargestAckedPn() { + return PacketNumber.of(this.largestAcknowledged); + } + + public PacketNumbers getAckedPacketNumbers() { + PacketNumbers pns = new PacketNumbers(); + for (long pn = this.largestAcknowledged; pn >= this.largestAcknowledged - this.firstAckRange; pn--) { + pns.add(PacketNumber.of(pn)); + } + pns.addAll(ackRanges.getAckPacketNumbers(this.largestAcknowledged - this.firstAckRange - 1)); + return pns; + } + + @Override + public byte[] getBytes() { + ByteBuffer buffer = ByteBuffer.allocate(1500); + buffer.put(TYPE); + buffer.put(VariableLengthInteger.of(this.largestAcknowledged).getBytes()); + buffer.put(VariableLengthInteger.of(this.ackDelay).getBytes()); + buffer.put(VariableLengthInteger.of(this.ackRanges.size()).getBytes()); + buffer.put(VariableLengthInteger.of(this.firstAckRange).getBytes()); + buffer.put(ackRanges.serialize()); + buffer.flip(); + return SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + } + + @Override + public boolean isAckEliciting() { + return false; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/frame/ConnectionCloseFrame.java b/src/main/java/core/packetproxy/quic/value/frame/ConnectionCloseFrame.java new file mode 100644 index 0000000..e5b15d7 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/ConnectionCloseFrame.java @@ -0,0 +1,74 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Value; +import packetproxy.quic.value.SimpleBytes; +import packetproxy.quic.value.VariableLengthInteger; + +import java.nio.ByteBuffer; +import java.util.List; + +@Value +@EqualsAndHashCode(callSuper = true) +public class ConnectionCloseFrame extends Frame { + + static public List supportedTypes() { + return ImmutableList.of((byte)0x1c, (byte)0x1d); + } + + static public ConnectionCloseFrame parse(byte[] bytes) { + return ConnectionCloseFrame.parse(ByteBuffer.wrap(bytes)); + } + + static public ConnectionCloseFrame parse(ByteBuffer buffer) { + byte type = buffer.get(); + assert(supportedTypes().stream().anyMatch(t -> t == type)); + long errorCode = VariableLengthInteger.parse(buffer).getValue(); + long frameType = (type == (byte)0x1c) ? VariableLengthInteger.parse(buffer).getValue() : 0; + long reasonPhraseLength = VariableLengthInteger.parse(buffer).getValue(); + byte[] reasonPhrase = SimpleBytes.parse(buffer, reasonPhraseLength).getBytes(); + return new ConnectionCloseFrame(type, errorCode, frameType, reasonPhrase); + } + + byte type; + long errorCode; + long frameType; + byte[] reasonPhrase; + + @Override + public byte[] getBytes() { + ByteBuffer buffer = ByteBuffer.allocate(1500); + buffer.put(type); + buffer.putLong(errorCode); + if (type == (byte)0x1c) { + buffer.putLong(frameType); + } + buffer.put(VariableLengthInteger.of(reasonPhrase.length).getBytes()); + buffer.put(reasonPhrase); + buffer.flip(); + return SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + } + + @Override + public boolean isAckEliciting() { + return false; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/frame/CryptoFrame.java b/src/main/java/core/packetproxy/quic/value/frame/CryptoFrame.java new file mode 100644 index 0000000..487f800 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/CryptoFrame.java @@ -0,0 +1,79 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Value; +import org.apache.commons.codec.binary.Hex; +import packetproxy.quic.value.SimpleBytes; +import packetproxy.quic.value.VariableLengthInteger; + +import java.nio.ByteBuffer; +import java.util.List; + +@Value +@EqualsAndHashCode(callSuper = true) +public class CryptoFrame extends Frame { + + static public final byte TYPE = 0x06; + + static public List supportedTypes() { + return ImmutableList.of(TYPE); + } + + long offset; + + byte[] data; + + static public CryptoFrame parse(byte[] bytes) { + return CryptoFrame.parse(ByteBuffer.wrap(bytes)); + } + + static public CryptoFrame parse(ByteBuffer buffer) { + byte type = buffer.get(); + assert(type == TYPE); + long offset = VariableLengthInteger.parse(buffer).getValue(); + long length = VariableLengthInteger.parse(buffer).getValue(); + byte[] data = SimpleBytes.parse(buffer, length).getBytes(); + return new CryptoFrame(offset, data); + } + + @Override + public byte[] getBytes() { + ByteBuffer buffer = ByteBuffer.allocate(1500); + buffer.put(TYPE); + buffer.put(VariableLengthInteger.of(this.offset).getBytes()); + buffer.put(VariableLengthInteger.of(this.data.length).getBytes()); + buffer.put(data); + buffer.flip(); + return SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + } + + @Override + public String toString() { + return String.format("CryptFrame(offset=%d, length=%d, data=%s)", + this.offset, + this.data.length, + Hex.encodeHexString(this.data)); + } + + @Override + public boolean isAckEliciting() { + return true; + } +} diff --git a/src/main/java/core/packetproxy/quic/value/frame/Frame.java b/src/main/java/core/packetproxy/quic/value/frame/Frame.java new file mode 100644 index 0000000..2293390 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/Frame.java @@ -0,0 +1,27 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import lombok.Value; +import lombok.experimental.NonFinal; + +@NonFinal +@Value +public abstract class Frame { + public abstract byte[] getBytes(); + public abstract boolean isAckEliciting(); +} \ No newline at end of file diff --git a/src/main/java/core/packetproxy/quic/value/frame/HandshakeDoneFrame.java b/src/main/java/core/packetproxy/quic/value/frame/HandshakeDoneFrame.java new file mode 100644 index 0000000..94f216a --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/HandshakeDoneFrame.java @@ -0,0 +1,56 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Value; + +import java.nio.ByteBuffer; +import java.util.List; + +@Value +@EqualsAndHashCode(callSuper = true) +public class HandshakeDoneFrame extends Frame { + + static public final byte TYPE = 0x1e; + + static public List supportedTypes() { + return ImmutableList.of(TYPE); + } + + static public HandshakeDoneFrame parse(byte[] bytes) { + return HandshakeDoneFrame.parse(ByteBuffer.wrap(bytes)); + } + + static public HandshakeDoneFrame parse(ByteBuffer buffer) { + byte type = buffer.get(); + assert(type == TYPE); + return new HandshakeDoneFrame(); + } + + @Override + public byte[] getBytes() { + return new byte[]{ TYPE }; + } + + @Override + public boolean isAckEliciting() { + return true; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/frame/NewConnectionIdFrame.java b/src/main/java/core/packetproxy/quic/value/frame/NewConnectionIdFrame.java new file mode 100644 index 0000000..e1ffc8d --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/NewConnectionIdFrame.java @@ -0,0 +1,90 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Value; +import packetproxy.quic.value.SimpleBytes; +import packetproxy.quic.value.ConnectionId; +import packetproxy.quic.value.FixedLengthPrecededBytes; +import packetproxy.quic.value.Token; +import packetproxy.quic.value.VariableLengthInteger; + +import java.nio.ByteBuffer; +import java.util.List; + +/* +https://www.rfc-editor.org/rfc/rfc9000.html#section-19.15 + +NEW_CONNECTION_ID Frame { + Type (i) = 0x18, + Sequence Number (i), + Retire Prior To (i), + Length (8), + Connection ID (8..160), + Stateless Reset Token (128), +} +*/ +@Value +@EqualsAndHashCode(callSuper = true) +public class NewConnectionIdFrame extends Frame { + + static public final byte TYPE = 0x18; + + static public List supportedTypes() { + return ImmutableList.of(TYPE); + } + + long sequenceNumber; + long retirePriorTo; + ConnectionId connectionId; + Token stateResetToken; + + static public NewConnectionIdFrame parse(byte[] bytes) { + return NewConnectionIdFrame.parse(ByteBuffer.wrap(bytes)); + } + + static public NewConnectionIdFrame parse(ByteBuffer buffer) { + byte type = buffer.get(); + assert(type == TYPE); + long sequenceNumber = VariableLengthInteger.parse(buffer).getValue(); + long retirePriorTo = VariableLengthInteger.parse(buffer).getValue(); + ConnectionId connectionId = ConnectionId.of(FixedLengthPrecededBytes.parse(buffer).getBytes()); + Token statelessResetToken = Token.of(SimpleBytes.parse(buffer, 16).getBytes()); + + return new NewConnectionIdFrame(sequenceNumber, retirePriorTo, connectionId, statelessResetToken); + } + + @Override + public byte[] getBytes() { + ByteBuffer buffer = ByteBuffer.allocate(1500); + buffer.put(TYPE); + buffer.put(VariableLengthInteger.of(this.sequenceNumber).getBytes()); + buffer.put(VariableLengthInteger.of(this.retirePriorTo).getBytes()); + buffer.put(FixedLengthPrecededBytes.of(this.connectionId.getBytes()).serialize()); + buffer.put(this.stateResetToken.getBytes()); + buffer.flip(); + return SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + } + + @Override + public boolean isAckEliciting() { + return true; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/frame/NewTokenFrame.java b/src/main/java/core/packetproxy/quic/value/frame/NewTokenFrame.java new file mode 100644 index 0000000..d049ff2 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/NewTokenFrame.java @@ -0,0 +1,76 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Value; +import packetproxy.quic.value.SimpleBytes; +import packetproxy.quic.value.Token; +import packetproxy.quic.value.VariableLengthInteger; + +import java.nio.ByteBuffer; +import java.util.List; + +/* +https://www.rfc-editor.org/rfc/rfc9000.html#section-19.7 + +NEW_TOKEN Frame { + Type (i) = 0x07, + Token Length (i), + Token (..), +} + */ +@Value +@EqualsAndHashCode(callSuper = true) +public class NewTokenFrame extends Frame { + + static public final byte TYPE = 0x7; + + static public List supportedTypes() { + return ImmutableList.of(TYPE); + } + + Token token; + + static public NewTokenFrame parse(byte[] bytes) { + return NewTokenFrame.parse(ByteBuffer.wrap(bytes)); + } + + static public NewTokenFrame parse(ByteBuffer buffer) { + byte type = buffer.get(); + assert(type == TYPE); + long tokenLength = VariableLengthInteger.parse(buffer).getValue(); + if (tokenLength == 0) { + System.err.println("NewTokenFrame: error: FRAME_ENCODING_ERROR"); + } + Token token = Token.of(SimpleBytes.parse(buffer, tokenLength).getBytes()); + + return new NewTokenFrame(token); + } + + @Override + public byte[] getBytes() { + return new byte[]{ TYPE }; + } + + @Override + public boolean isAckEliciting() { + return true; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/frame/PaddingFrame.java b/src/main/java/core/packetproxy/quic/value/frame/PaddingFrame.java new file mode 100644 index 0000000..0e2c075 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/PaddingFrame.java @@ -0,0 +1,61 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Value; + +import java.nio.ByteBuffer; +import java.util.List; + +@Value +@EqualsAndHashCode(callSuper = true) +public class PaddingFrame extends Frame { + + static public final byte TYPE = 0x00; + + static public List supportedTypes() { + return ImmutableList.of(TYPE); + } + long length; + + static public PaddingFrame parse(byte[] bytes) { + return PaddingFrame.parse(ByteBuffer.wrap(bytes)); + } + + static public PaddingFrame parse(ByteBuffer buffer) { + long length = 0; + while (buffer.remaining() > 0) { + byte type = buffer.get(); + assert (type == TYPE); + length++; + } + return new PaddingFrame(length); + } + + @Override + public byte[] getBytes() { + return new byte[(int)this.length]; + } + + @Override + public boolean isAckEliciting() { + return false; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/frame/PingFrame.java b/src/main/java/core/packetproxy/quic/value/frame/PingFrame.java new file mode 100644 index 0000000..bbd4307 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/PingFrame.java @@ -0,0 +1,56 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Value; + +import java.nio.ByteBuffer; +import java.util.List; + +@Value +@EqualsAndHashCode(callSuper = true) +public class PingFrame extends Frame { + + static public final byte TYPE = 0x01; + + static public List supportedTypes() { + return ImmutableList.of(TYPE); + } + + static public PingFrame parse(byte[] bytes) { + return PingFrame.parse(ByteBuffer.wrap(bytes)); + } + + static public PingFrame parse(ByteBuffer buffer) { + byte type = buffer.get(); + assert(type == TYPE); + return new PingFrame(); + } + + @Override + public byte[] getBytes() { + return new byte[]{ TYPE }; + } + + @Override + public boolean isAckEliciting() { + return true; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/frame/ResetStreamFrame.java b/src/main/java/core/packetproxy/quic/value/frame/ResetStreamFrame.java new file mode 100644 index 0000000..77e287f --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/ResetStreamFrame.java @@ -0,0 +1,81 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Value; +import packetproxy.quic.value.SimpleBytes; +import packetproxy.quic.value.VariableLengthInteger; + +import java.nio.ByteBuffer; +import java.util.List; + +/* +https://www.rfc-editor.org/rfc/rfc9000.html#section-19.4 + +RESET_STREAM Frame { + Type (i) = 0x04, + Stream ID (i), + Application Protocol Error Code (i), + Final Size (i), +} +*/ +@Value +@EqualsAndHashCode(callSuper = true) +public class ResetStreamFrame extends Frame { + + static public final byte TYPE = 0x04; + + static public List supportedTypes() { + return ImmutableList.of(TYPE); + } + + static public ResetStreamFrame parse(byte[] bytes) { + return ResetStreamFrame.parse(ByteBuffer.wrap(bytes)); + } + + static public ResetStreamFrame parse(ByteBuffer buffer) { + byte type = buffer.get(); + assert(type == TYPE); + long streamId = VariableLengthInteger.parse(buffer).getValue(); + long applicationProtocolErrorCode = VariableLengthInteger.parse(buffer).getValue(); + long finalSize = VariableLengthInteger.parse(buffer).getValue(); + return new ResetStreamFrame(streamId, applicationProtocolErrorCode, finalSize); + } + + long streamId; + long applicationErrorCode; + long finalSize; + + @Override + public byte[] getBytes() { + ByteBuffer buffer = ByteBuffer.allocate(1500); + buffer.put(TYPE); + buffer.put(VariableLengthInteger.of(this.streamId).getBytes()); + buffer.put(VariableLengthInteger.of(this.applicationErrorCode).getBytes()); + buffer.put(VariableLengthInteger.of(this.finalSize).getBytes()); + buffer.flip(); + return SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + } + + @Override + public boolean isAckEliciting(){ + return true; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/frame/StopSendingFrame.java b/src/main/java/core/packetproxy/quic/value/frame/StopSendingFrame.java new file mode 100644 index 0000000..1d52739 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/StopSendingFrame.java @@ -0,0 +1,77 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Value; +import packetproxy.quic.value.SimpleBytes; +import packetproxy.quic.value.VariableLengthInteger; + +import java.nio.ByteBuffer; +import java.util.List; + +/* +https://www.rfc-editor.org/rfc/rfc9000.html#section-19.5 + +STOP_SENDING Frame { + Type (i) = 0x05, + Stream ID (i), + Application Protocol Error Code (i), +} +*/ +@Value +@EqualsAndHashCode(callSuper = true) +public class StopSendingFrame extends Frame { + + static public final byte TYPE = 0x05; + + static public List supportedTypes() { + return ImmutableList.of(TYPE); + } + + static public StopSendingFrame parse(byte[] bytes) { + return StopSendingFrame.parse(ByteBuffer.wrap(bytes)); + } + + static public StopSendingFrame parse(ByteBuffer buffer) { + byte type = buffer.get(); + assert(type == TYPE); + long streamId = VariableLengthInteger.parse(buffer).getValue(); + long applicationProtocolErrorCode = VariableLengthInteger.parse(buffer).getValue(); + return new StopSendingFrame(streamId, applicationProtocolErrorCode); + } + + long streamId; + long applicationErrorCode; + + @Override + public byte[] getBytes() { + ByteBuffer buffer = ByteBuffer.allocate(1500); + buffer.put(TYPE); + buffer.put(VariableLengthInteger.of(this.streamId).getBytes()); + buffer.put(VariableLengthInteger.of(this.applicationErrorCode).getBytes()); + buffer.flip(); + return SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + } + + @Override + public boolean isAckEliciting(){ + return true; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/frame/StreamDataBlockedFrame.java b/src/main/java/core/packetproxy/quic/value/frame/StreamDataBlockedFrame.java new file mode 100644 index 0000000..9174c46 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/StreamDataBlockedFrame.java @@ -0,0 +1,62 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Value; +import packetproxy.quic.value.VariableLengthInteger; + +import java.nio.ByteBuffer; +import java.util.List; + +@Value +@EqualsAndHashCode(callSuper = true) +public class StreamDataBlockedFrame extends Frame { + + static public final byte TYPE = 0x15; + + static public List supportedTypes() { + return ImmutableList.of(TYPE); + } + + long streamId; + long maxStreamData; + + static public StreamDataBlockedFrame parse(byte[] bytes) { + return StreamDataBlockedFrame.parse(ByteBuffer.wrap(bytes)); + } + + static public StreamDataBlockedFrame parse(ByteBuffer buffer) { + byte type = buffer.get(); + assert(type == TYPE); + long streamId = VariableLengthInteger.parse(buffer).getValue(); + long maxStreamData = VariableLengthInteger.parse(buffer).getValue(); + return new StreamDataBlockedFrame(streamId, maxStreamData); + } + + @Override + public byte[] getBytes() { + return new byte[]{ TYPE }; + } + + @Override + public boolean isAckEliciting() { + return true; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/frame/StreamFrame.java b/src/main/java/core/packetproxy/quic/value/frame/StreamFrame.java new file mode 100644 index 0000000..88550d4 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/StreamFrame.java @@ -0,0 +1,111 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Value; +import org.apache.commons.codec.binary.Hex; +import packetproxy.quic.value.SimpleBytes; +import packetproxy.quic.value.VariableLengthInteger; + +import java.nio.ByteBuffer; +import java.util.List; + +@EqualsAndHashCode(callSuper = true) +@Value(staticConstructor = "of") +public class StreamFrame extends Frame { + + static public boolean is(byte type) { + return supportedTypes().stream().anyMatch(t -> t == type); + } + + static public List supportedTypes() { + return ImmutableList.of((byte)0x08, (byte)0x09, (byte)0x0a, (byte)0x0b, (byte)0x0c, (byte)0x0d, (byte)0x0e, (byte)0x0f); + } + + static private boolean hasOffsetField(byte type) { + return (type & 0x04) > 0; + } + + static private boolean hasLengthField(byte type) { + return (type & 0x02) > 0; + } + + static private boolean hasFinishBit(byte type) { + return (type & 0x01) > 0; + } + + static public StreamFrame parse(ByteBuffer buffer) { + byte type = buffer.get(); + assert(StreamFrame.is(type)); + + long streamId = VariableLengthInteger.parse(buffer).getValue(); + long offset = hasOffsetField(type) ? VariableLengthInteger.parse(buffer).getValue() : 0; + long length = hasLengthField(type) ? VariableLengthInteger.parse(buffer).getValue() : 0; + boolean finished = hasFinishBit(type); + byte[] streamData; + if (length > 0) { + streamData = SimpleBytes.parse(buffer, length).getBytes(); + } else { + streamData = SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + length = streamData.length; + } + return StreamFrame.of(streamId, offset, length, streamData, finished); + } + + long streamId; + long offset; + long length; + byte[] streamData; + boolean finished; + + @Override + public String toString() { + return String.format("StreamFrame(streamId=0x%x, offset=%d, length=%d, data=[%s])", + this.streamId, this.offset, this.length, Hex.encodeHexString(this.streamData)); + } + + private byte getType() { + byte offsetBit = (this.offset > 0) ? (byte) 0x04 : 0x00; + byte lengthBit = (this.length > 0) ? (byte) 0x02 : 0x00; + byte finishBit = this.finished ? (byte) 0x01: 0x00; + return (byte)(0x08 | offsetBit | lengthBit | finishBit); + } + + @Override + public byte[] getBytes() { + ByteBuffer buffer = ByteBuffer.allocate(1500); + buffer.put(this.getType()); + buffer.put(VariableLengthInteger.of(this.streamId).getBytes()); + if (this.offset > 0) { + buffer.put(VariableLengthInteger.of(this.offset).getBytes()); + } + if (this.length > 0) { + buffer.put(VariableLengthInteger.of(this.length).getBytes()); + } + buffer.put(this.streamData); + buffer.flip(); + return SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + } + + @Override + public boolean isAckEliciting() { + return true; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/frame/StreamsBlockedBidiFrame.java b/src/main/java/core/packetproxy/quic/value/frame/StreamsBlockedBidiFrame.java new file mode 100644 index 0000000..4b920cd --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/StreamsBlockedBidiFrame.java @@ -0,0 +1,60 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Value; +import packetproxy.quic.value.VariableLengthInteger; + +import java.nio.ByteBuffer; +import java.util.List; + +@Value +@EqualsAndHashCode(callSuper = true) +public class StreamsBlockedBidiFrame extends Frame { + + static public final byte TYPE = 0x16; + + static public List supportedTypes() { + return ImmutableList.of(TYPE); + } + + long maxStreams; + + static public StreamsBlockedBidiFrame parse(byte[] bytes) { + return StreamsBlockedBidiFrame.parse(ByteBuffer.wrap(bytes)); + } + + static public StreamsBlockedBidiFrame parse(ByteBuffer buffer) { + byte type = buffer.get(); + assert(type == TYPE); + long maxStreams = VariableLengthInteger.parse(buffer).getValue(); + return new StreamsBlockedBidiFrame(maxStreams); + } + + @Override + public byte[] getBytes() { + return new byte[]{ TYPE }; + } + + @Override + public boolean isAckEliciting() { + return true; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/frame/StreamsBlockedUniFrame.java b/src/main/java/core/packetproxy/quic/value/frame/StreamsBlockedUniFrame.java new file mode 100644 index 0000000..7d618ee --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/StreamsBlockedUniFrame.java @@ -0,0 +1,60 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Value; +import packetproxy.quic.value.VariableLengthInteger; + +import java.nio.ByteBuffer; +import java.util.List; + +@Value +@EqualsAndHashCode(callSuper = true) +public class StreamsBlockedUniFrame extends Frame { + + static public final byte TYPE = 0x17; + + static public List supportedTypes() { + return ImmutableList.of(TYPE); + } + + long maxStreams; + + static public StreamsBlockedUniFrame parse(byte[] bytes) { + return StreamsBlockedUniFrame.parse(ByteBuffer.wrap(bytes)); + } + + static public StreamsBlockedUniFrame parse(ByteBuffer buffer) { + byte type = buffer.get(); + assert(type == TYPE); + long maxStreams = VariableLengthInteger.parse(buffer).getValue(); + return new StreamsBlockedUniFrame(maxStreams); + } + + @Override + public byte[] getBytes() { + return new byte[]{ TYPE }; + } + + @Override + public boolean isAckEliciting() { + return true; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/frame/UnknownFrame.java b/src/main/java/core/packetproxy/quic/value/frame/UnknownFrame.java new file mode 100644 index 0000000..35cc67e --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/UnknownFrame.java @@ -0,0 +1,60 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Value; + +import java.nio.ByteBuffer; +import java.util.List; + +@Value +@EqualsAndHashCode(callSuper = true) +public class UnknownFrame extends Frame { + + static public List supportedTypes() { + return ImmutableList.of(); + } + + byte type; + + static public UnknownFrame parse(byte[] bytes) { + return UnknownFrame.parse(ByteBuffer.wrap(bytes)); + } + + static public UnknownFrame parse(ByteBuffer buffer) { + byte type = buffer.get(); + return new UnknownFrame(type); + } + + @Override + public byte[] getBytes() { + return new byte[] { this.type }; + } + + @Override + public boolean isAckEliciting() { + return false; + } + + @Override + public String toString() { + return String.format("Unknown(type=%02x)", this.type); + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/frame/helper/AckRange.java b/src/main/java/core/packetproxy/quic/value/frame/helper/AckRange.java new file mode 100644 index 0000000..23d1e43 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/helper/AckRange.java @@ -0,0 +1,63 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame.helper; + +import lombok.AllArgsConstructor; +import lombok.Value; +import packetproxy.quic.value.PacketNumber; +import packetproxy.quic.utils.PacketNumbers; +import packetproxy.quic.value.SimpleBytes; +import packetproxy.quic.value.VariableLengthInteger; + +import java.nio.ByteBuffer; + +@AllArgsConstructor +@Value +public class AckRange { + long gap; + long ackRangeLength; + + public AckRange(ByteBuffer buffer) { + this.gap = VariableLengthInteger.parse(buffer).getValue(); + this.ackRangeLength = VariableLengthInteger.parse(buffer).getValue(); + } + + public long size() { + return this.gap + this.ackRangeLength + 2; + } + + public PacketNumbers getAckPacketNumbers(long largestGapPn) { + long largestAckPn = largestGapPn - this.gap - 1; + PacketNumbers pns = new PacketNumbers(); + for (long pn = largestAckPn; pn >= largestAckPn - this.ackRangeLength; pn--) { + pns.add(PacketNumber.of(pn)); + } + return pns; + } + + public byte[] serialize() { + ByteBuffer buffer = ByteBuffer.allocate(1500); + buffer.put(VariableLengthInteger.of(this.gap).getBytes()); + buffer.put(VariableLengthInteger.of(this.ackRangeLength).getBytes()); + buffer.flip(); + return SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + } + + public String toString() { + return String.format("gap:%d, ackRangeLength:%d", this.gap, this.ackRangeLength); + } +} diff --git a/src/main/java/core/packetproxy/quic/value/frame/helper/AckRanges.java b/src/main/java/core/packetproxy/quic/value/frame/helper/AckRanges.java new file mode 100644 index 0000000..fa03c37 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/frame/helper/AckRanges.java @@ -0,0 +1,90 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame.helper; + +import lombok.EqualsAndHashCode; +import lombok.Getter; +import packetproxy.quic.utils.PacketNumbers; +import packetproxy.quic.value.SimpleBytes; + +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; + +@Getter +@EqualsAndHashCode +public class AckRanges implements Iterable { + static public final AckRanges emptyAckRanges = new AckRanges(); + + private List ackRanges; + + public AckRanges(ByteBuffer buffer, long rangeCount) { + this.ackRanges = new ArrayList<>(); + for (long i = 0; i < rangeCount; i++) { + this.ackRanges.add(new AckRange(buffer)); + } + } + + public AckRanges(List ackRanges) { + this.ackRanges = ackRanges; + } + + private AckRanges() { + this.ackRanges = Collections.emptyList(); + } + + public PacketNumbers getAckPacketNumbers(long largestGapPn) { + PacketNumbers pns = new PacketNumbers(); + for (AckRange ackRange : ackRanges) { + pns.addAll(ackRange.getAckPacketNumbers(largestGapPn)); + largestGapPn -= ackRange.size(); + } + return pns; + } + + public byte[] serialize() { + ByteBuffer buffer = ByteBuffer.allocate(1500); + for (AckRange ackRange: this.ackRanges) { + buffer.put(ackRange.serialize()); + } + buffer.flip(); + return SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + } + + public String toString() { + String rangeMsg = ""; + for (AckRange ackRange: this.ackRanges) { + rangeMsg += ackRange + "|"; + } + return "{" + rangeMsg + "}"; + } + + public int size() { + return this.ackRanges.size(); + } + + public AckRange get(int index) { + return this.ackRanges.get(0); + } + + @Override + public Iterator iterator() { + return this.ackRanges.iterator(); + } +} diff --git a/src/main/java/core/packetproxy/quic/value/key/Key.java b/src/main/java/core/packetproxy/quic/value/key/Key.java new file mode 100644 index 0000000..c25d1b5 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/key/Key.java @@ -0,0 +1,109 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.key; + +import at.favre.lib.crypto.HKDF; +import lombok.AllArgsConstructor; +import lombok.Value; +import lombok.experimental.NonFinal; +import org.apache.commons.codec.binary.Hex; + +import javax.crypto.Cipher; +import javax.crypto.spec.GCMParameterSpec; +import javax.crypto.spec.SecretKeySpec; +import java.nio.ByteBuffer; + +@NonFinal +@Value +@AllArgsConstructor +public class Key { + static final protected byte[] STATIC_SALT_V1 = new byte[]{ + (byte) 0x38, (byte) 0x76, (byte) 0x2c, (byte) 0xf7, (byte) 0xf5, (byte) 0x59, (byte) 0x34, (byte) 0xb3, + (byte) 0x4d, (byte) 0x17, (byte) 0x9a, (byte) 0xe6, (byte) 0xa4, (byte) 0xc8, (byte) 0x0c, (byte) 0xad, + (byte) 0xcc, (byte) 0xbb, (byte) 0x7f, (byte) 0x0a}; + + static public byte[] hkdfExpandLabel(byte[] secret, String labelStr, String contextStr, short length) { + byte[] label = String.format("tls13 %s", labelStr).getBytes(); + byte[] context = contextStr.getBytes(); + HKDF hkdf = HKDF.fromHmacSha256(); + ByteBuffer hkdfLabel = ByteBuffer.allocate(2 + 1 + label.length + 1 + context.length); + hkdfLabel.putShort(length); + hkdfLabel.put((byte) label.length); + hkdfLabel.put(label); + hkdfLabel.put((byte) context.length); + hkdfLabel.put(context); + return hkdf.expand(secret, hkdfLabel.array(), length); + } + + static public Key of(byte[] secret) { + byte[] key = hkdfExpandLabel(secret, "quic key", "", (short) 16); + byte[] iv = hkdfExpandLabel(secret, "quic iv", "", (short) 12); + byte[] hp = hkdfExpandLabel(secret, "quic hp", "", (short) 16); + return new Key(secret, key, iv, hp); + } + + byte[] secret; + byte[] key; + byte[] iv; + byte[] hp; + + public byte[] getMaskForHeaderProtection(byte[] sample) throws Exception { + SecretKeySpec keySpec = new SecretKeySpec(this.hp, "AES"); + Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding"); + cipher.init(Cipher.ENCRYPT_MODE, keySpec); + return cipher.doFinal(sample); + } + + public byte[] aesGCM(int cipherMode, byte[] packetNumber, byte[] payload, byte[] associatedData) throws Exception { + byte[] nonce = getNonce(packetNumber); + SecretKeySpec keySpec = new SecretKeySpec(this.key, "AES"); + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(128, nonce); + cipher.init(cipherMode, keySpec, gcmParameterSpec); + cipher.updateAAD(associatedData); + return cipher.doFinal(payload); + } + + public byte[] decryptPayload(byte[] packetNumber, byte[] encryptPayload, byte[] associatedData) throws Exception { + return aesGCM(Cipher.DECRYPT_MODE, packetNumber, encryptPayload, associatedData); + } + + public byte[] encryptPayload(byte[] packetNumber, byte[] payload, byte[] associatedData) throws Exception { + return aesGCM(Cipher.ENCRYPT_MODE, packetNumber, payload, associatedData); + } + + private byte[] getNonce(byte[] packetNumber) { + byte[] nonce = new byte[12]; + for (int i = 0; i < 12; i++) { + nonce[i] = this.iv[i]; + if (i >= nonce.length - packetNumber.length) { + nonce[i] ^= packetNumber[i - (nonce.length - packetNumber.length)]; + } + } + return nonce; + } + + @Override + public String toString() { + return String.format("Key(secret=%s, key=%s, iv=%s, hp=%s)", + Hex.encodeHexString(this.secret), + Hex.encodeHexString(this.key), + Hex.encodeHexString(this.iv), + Hex.encodeHexString(this.hp)); + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/key/level/ApplicationKey.java b/src/main/java/core/packetproxy/quic/value/key/level/ApplicationKey.java new file mode 100644 index 0000000..da5992a --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/key/level/ApplicationKey.java @@ -0,0 +1,36 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.key.level; + +import lombok.EqualsAndHashCode; +import lombok.Value; +import packetproxy.quic.value.key.Key; + +@EqualsAndHashCode(callSuper = true) +@Value +public class ApplicationKey extends Key { + + static public ApplicationKey of(byte[] secret) { + Key key = Key.of(secret); + return new ApplicationKey(key.getSecret(), key.getKey(), key.getIv(), key.getHp()); + } + + public ApplicationKey(byte[] secret, byte[] key, byte[] iv, byte[] hp) { + super(secret, key, iv, hp); + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/key/level/HandshakeKey.java b/src/main/java/core/packetproxy/quic/value/key/level/HandshakeKey.java new file mode 100644 index 0000000..92f894c --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/key/level/HandshakeKey.java @@ -0,0 +1,36 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.key.level; + +import lombok.EqualsAndHashCode; +import lombok.Value; +import packetproxy.quic.value.key.Key; + +@EqualsAndHashCode(callSuper = true) +@Value +public class HandshakeKey extends Key { + + static public HandshakeKey of(byte[] secret) { + Key key = Key.of(secret); + return new HandshakeKey(key.getSecret(), key.getKey(), key.getIv(), key.getHp()); + } + + public HandshakeKey(byte[] secret, byte[] key, byte[] iv, byte[] hp) { + super(secret, key, iv, hp); + } + +} \ No newline at end of file diff --git a/src/main/java/core/packetproxy/quic/value/key/level/InitialKey.java b/src/main/java/core/packetproxy/quic/value/key/level/InitialKey.java new file mode 100644 index 0000000..bf95223 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/key/level/InitialKey.java @@ -0,0 +1,44 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.key.level; + +import at.favre.lib.crypto.HKDF; +import lombok.EqualsAndHashCode; +import lombok.Value; +import packetproxy.quic.value.ConnectionId; +import packetproxy.quic.utils.Constants; +import packetproxy.quic.value.key.Key; + +@EqualsAndHashCode(callSuper = true) +@Value +public class InitialKey extends Key { + + static public InitialKey of(Constants.Role role, ConnectionId destConnId) { + HKDF hkdf = HKDF.fromHmacSha256(); + byte[] initialSecret = hkdf.extract(STATIC_SALT_V1, destConnId.getBytes()); + byte[] secret = (role == Constants.Role.CLIENT) ? + hkdfExpandLabel(initialSecret, "client in", "", (short) 32) : + hkdfExpandLabel(initialSecret, "server in", "", (short) 32); + Key key = Key.of(secret); + return new InitialKey(key.getSecret(), key.getKey(), key.getIv(), key.getHp()); + } + + public InitialKey(byte[] secret, byte[] key, byte[] iv, byte[] hp) { + super(secret, key, iv, hp); + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/key/level/ZeroRttKey.java b/src/main/java/core/packetproxy/quic/value/key/level/ZeroRttKey.java new file mode 100644 index 0000000..a1fab02 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/key/level/ZeroRttKey.java @@ -0,0 +1,36 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.key.level; + +import lombok.EqualsAndHashCode; +import lombok.Value; +import packetproxy.quic.value.key.Key; + +@EqualsAndHashCode(callSuper = true) +@Value +public class ZeroRttKey extends Key { + + static public ZeroRttKey of(byte[] secret) { + Key key = Key.of(secret); + return new ZeroRttKey(key.getSecret(), key.getKey(), key.getIv(), key.getHp()); + } + + public ZeroRttKey(byte[] secret, byte[] key, byte[] iv, byte[] hp) { + super(secret, key, iv, hp); + } + +} \ No newline at end of file diff --git a/src/main/java/core/packetproxy/quic/value/packet/PnSpacePacket.java b/src/main/java/core/packetproxy/quic/value/packet/PnSpacePacket.java new file mode 100644 index 0000000..e479985 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/packet/PnSpacePacket.java @@ -0,0 +1,38 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.packet; + +import packetproxy.quic.utils.Constants.PnSpaceType; +import packetproxy.quic.value.frame.AckFrame; +import packetproxy.quic.service.frame.Frames; +import packetproxy.quic.value.PacketNumber; + +import java.util.Optional; + +public interface PnSpacePacket { + PacketNumber getPacketNumber(); + + boolean isAckEliciting(); + + boolean hasAckFrame(); + + Optional getAckFrame(); + + PnSpaceType getPnSpaceType(); + + Frames getFrames(); +} diff --git a/src/main/java/core/packetproxy/quic/value/packet/QuicPacket.java b/src/main/java/core/packetproxy/quic/value/packet/QuicPacket.java new file mode 100644 index 0000000..2a0a80b --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/packet/QuicPacket.java @@ -0,0 +1,93 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.packet; + +import lombok.Value; +import lombok.experimental.NonFinal; + +import java.nio.ByteBuffer; + +@NonFinal +@Value +public class QuicPacket { + + byte maskedType; + @NonFinal + byte type; /* Packet number length bits are not included. all the bits should be cleared */ + @NonFinal + int origPnLength; + + protected QuicPacket(ByteBuffer buffer) { + this(buffer.get()); + } + + protected QuicPacket(byte type) { + this.maskedType = type; + this.type = type; + this.origPnLength = (type & 0x03) + 1; + } + + protected enum PacketHeaderType { + LongHeaderType, + ShortHeaderType, + } + + protected void unmaskType(PacketHeaderType headerType, byte[] maskKey) { + this.type = QuicPacket.xor(this.maskedType, headerType, maskKey); + this.origPnLength = (this.type & 0x03) + 1; + } + + static private byte xor(byte type, PacketHeaderType headerType, byte[] maskKey) { + byte leftHand; + byte rightHand; + if (headerType == PacketHeaderType.ShortHeaderType) { + leftHand = (byte) (type & (byte) 0xe0); + rightHand = (byte) ((type ^ maskKey[0]) & 0x1f); + } else { /* headerType == LongHeaderType */ + leftHand = (byte) (type & (byte) 0xf0); + rightHand = (byte) ((type ^ maskKey[0]) & 0x0f); + } + return (byte) (leftHand | rightHand); + } + + protected byte getType(int newlyPnLength) { + byte lengthCleared = (byte) (this.type & (byte)0xfc); + return (byte) (lengthCleared | (newlyPnLength - 1)); + } + + protected byte getMaskedType(int newlyPnLength, PacketHeaderType headerType, byte[] maskKey) { + byte typeWithNewPnLength = this.getType(newlyPnLength); + return QuicPacket.xor(typeWithNewPnLength, headerType, maskKey); + } + + protected byte[] getBytes() { + return new byte[] { this.getType() }; + } + + protected byte[] getBytes(int newlyPnLength) { + return new byte[] { this.getType(newlyPnLength) }; + } + + protected byte[] getMaskedBytes(int newlyPnLength, PacketHeaderType headerType, byte[] maskKey) { + return new byte[] { this.getMaskedType(newlyPnLength, headerType, maskKey) }; + } + + protected int size() { + return 1; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/packet/longheader/LongHeaderPacket.java b/src/main/java/core/packetproxy/quic/value/packet/longheader/LongHeaderPacket.java new file mode 100644 index 0000000..908668a --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/packet/longheader/LongHeaderPacket.java @@ -0,0 +1,125 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.packet.longheader; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import lombok.experimental.NonFinal; +import packetproxy.quic.value.packet.QuicPacket; +import packetproxy.quic.value.ConnectionId; +import packetproxy.quic.value.ConnectionIdPair; +import packetproxy.quic.value.FixedLengthPrecededBytes; +import packetproxy.quic.value.SimpleBytes; + +import java.nio.ByteBuffer; + +/* +https://www.rfc-editor.org/rfc/rfc9000.html#name-long-header-packets + +Long Header Packet { + Header Form (1) = 1, + Fixed Bit (1) = 1, + Long Packet Type (2), + Type-Specific Bits (4), + Version (32), + Destination Connection ID Length (8), + Destination Connection ID (0..160), + Source Connection ID Length (8), + Source Connection ID (0..160), + Type-Specific Payload (..), +} +*/ +@ToString(callSuper = true) +@EqualsAndHashCode(callSuper = true) +@NonFinal +@Value +public class LongHeaderPacket extends QuicPacket { + + static public boolean is(byte type) { + return (type & (byte)0xc0) == (byte)0xc0; + } + + static public ConnectionId getDestConnId(ByteBuffer buffer) { + int savedPosition = buffer.position(); + buffer.get(); + buffer.getInt(); + byte[] destConnId = FixedLengthPrecededBytes.parse(buffer).getBytes(); + buffer.position(savedPosition); + return ConnectionId.of(destConnId); + } + + protected int version; + protected ConnectionIdPair connectionIdPair; + + protected LongHeaderPacket(byte type, int version, ConnectionIdPair connIdPair) { + super(type); + this.version = version; + this.connectionIdPair = connIdPair; + } + + protected LongHeaderPacket(ByteBuffer buffer) { + super(buffer); + this.version = buffer.getInt(); + ConnectionId destConnId = ConnectionId.of(FixedLengthPrecededBytes.parse(buffer).getBytes()); + ConnectionId srcConnId = ConnectionId.of(FixedLengthPrecededBytes.parse(buffer).getBytes()); + this.connectionIdPair = ConnectionIdPair.of(srcConnId, destConnId); + } + + protected int size() { + return this.getBytes().length; + } + + protected byte[] getBytes() { + ByteBuffer buffer = ByteBuffer.allocate(1500); + buffer.put(super.getType()); + buffer.putInt(this.version); + buffer.put(FixedLengthPrecededBytes.of(this.connectionIdPair.getDestConnId().getBytes()).serialize()); + buffer.put(FixedLengthPrecededBytes.of(this.connectionIdPair.getSrcConnId().getBytes()).serialize()); + buffer.flip(); + return SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + } + + protected byte[] getBytes(int newlyPnLength) { + ByteBuffer buffer = ByteBuffer.allocate(1500); + buffer.put(super.getType(newlyPnLength)); + buffer.putInt(this.version); + buffer.put(FixedLengthPrecededBytes.of(this.connectionIdPair.getDestConnId().getBytes()).serialize()); + buffer.put(FixedLengthPrecededBytes.of(this.connectionIdPair.getSrcConnId().getBytes()).serialize()); + buffer.flip(); + return SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + } + + protected byte[] getMaskedBytes(int newlyPnLength, byte[] maskKey) { + ByteBuffer buffer = ByteBuffer.allocate(1500); + buffer.put(super.getMaskedBytes(newlyPnLength, PacketHeaderType.LongHeaderType, maskKey)); + buffer.putInt(this.version); + buffer.put(FixedLengthPrecededBytes.of(this.connectionIdPair.getDestConnId().getBytes()).serialize()); + buffer.put(FixedLengthPrecededBytes.of(this.connectionIdPair.getSrcConnId().getBytes()).serialize()); + buffer.flip(); + return SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + } + + public ConnectionId getSrcConnId() { + return this.connectionIdPair.getSrcConnId(); + } + + public ConnectionId getDestConnId() { + return this.connectionIdPair.getDestConnId(); + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/packet/longheader/LongHeaderPnSpacePacket.java b/src/main/java/core/packetproxy/quic/value/packet/longheader/LongHeaderPnSpacePacket.java new file mode 100644 index 0000000..75fc260 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/packet/longheader/LongHeaderPnSpacePacket.java @@ -0,0 +1,187 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.packet.longheader; + +import lombok.EqualsAndHashCode; +import lombok.SneakyThrows; +import lombok.Value; +import lombok.experimental.NonFinal; +import org.apache.commons.lang3.ArrayUtils; +import packetproxy.quic.utils.Constants.PnSpaceType; +import packetproxy.quic.value.SimpleBytes; +import packetproxy.quic.value.ConnectionIdPair; +import packetproxy.quic.value.PacketNumber; +import packetproxy.quic.value.TruncatedPacketNumber; +import packetproxy.quic.value.VariableLengthInteger; +import packetproxy.quic.value.frame.AckFrame; +import packetproxy.quic.service.frame.Frames; +import packetproxy.quic.value.key.Key; +import packetproxy.quic.value.packet.PnSpacePacket; + +import java.nio.ByteBuffer; +import java.util.Optional; + +import static packetproxy.quic.utils.Constants.PnSpaceType.PnSpaceInitial; + +/* +https://www.rfc-editor.org/rfc/rfc9000.html#name-long-header-packets + +Long Header Packet { + Header Form (1) = 1, + Fixed Bit (1) = 1, + Long Packet Type (2), + Type-Specific Bits (4), + Version (32), + Destination Connection ID Length (8), + Destination Connection ID (0..160), + Source Connection ID Length (8), + Source Connection ID (0..160), + Type-Specific Payload (..), +} +*/ +@EqualsAndHashCode(callSuper = true) +@NonFinal +@Value +public class LongHeaderPnSpacePacket extends LongHeaderPacket implements PnSpacePacket { + + protected PacketNumber packetNumber; + protected byte[] payload; + + protected LongHeaderPnSpacePacket(byte type, int version, ConnectionIdPair connIdPair, PacketNumber packetNumber, byte[] payload) { + super(type, version, connIdPair); + this.packetNumber = packetNumber; + this.payload = payload; + } + + protected LongHeaderPnSpacePacket(ByteBuffer buffer, Key key, PacketNumber largestAckedPn) throws Exception { + super(buffer); + int startPosition = buffer.position() - super.size(); + this.parseExtra(buffer); + + long length = VariableLengthInteger.parse(buffer).getValue(); + + // get the sampling data + int packetNumberPosition = buffer.position(); + buffer.position(buffer.position() + 4); + byte[] sample = SimpleBytes.parse(buffer, 16).getBytes(); + + // get the maskKey from the sampling data + byte[] maskKey = key.getMaskForHeaderProtection(sample); + + super.unmaskType(PacketHeaderType.LongHeaderType, maskKey); + int packetNumberLength = super.getOrigPnLength(); + + // decode header protection of truncatedPacketNumber + buffer.position(packetNumberPosition); + byte[] maskedTruncatedPn = SimpleBytes.parse(buffer, packetNumberLength).getBytes(); + byte[] truncatedPn = TruncatedPacketNumber.unmaskTruncatedPacketNumber(maskedTruncatedPn, maskKey); + + int payloadPosition = buffer.position(); + int payloadLength = (int) length - packetNumberLength; + byte[] encodedPayload = SimpleBytes.parse(buffer, payloadLength).getBytes(); + int positionPacketEnd = buffer.position(); + + buffer.position(startPosition); + byte[] header = SimpleBytes.parse(buffer, payloadPosition - startPosition).getBytes(); + header[0] = super.getType(); + for (int i = 0; i < truncatedPn.length; i++) { + header[packetNumberPosition - startPosition + i] = truncatedPn[i]; + } + + this.payload = key.decryptPayload(truncatedPn, encodedPayload, header); + this.packetNumber = new TruncatedPacketNumber(truncatedPn).getPacketNumber(largestAckedPn); + + buffer.position(positionPacketEnd); + } + + @SneakyThrows + public byte[] getBytes(Key key, PacketNumber largestAckedPn) { + ByteBuffer headerBuffer = ByteBuffer.allocate(1500); + + byte[] truncatedPn = this.packetNumber.getTruncatedPacketNumber(largestAckedPn).getBytes(); + if (truncatedPn.length + this.payload.length + 16 /* AES auth hash */ < 20) { + int dummyBytesLength = 20 - truncatedPn.length - this.payload.length - 16; + truncatedPn = ArrayUtils.addAll(new byte[dummyBytesLength], truncatedPn); + } + + byte[] payloadLength = VariableLengthInteger.of(truncatedPn.length + payload.length + 16 /* GCM auth hash */).getBytes(); + + /* create original header for associated data of AES encryption */ + headerBuffer.put(super.getBytes(truncatedPn.length)); + this.getBytesExtra(headerBuffer); + headerBuffer.put(payloadLength); + headerBuffer.put(truncatedPn); + headerBuffer.flip(); + byte[] header = SimpleBytes.parse(headerBuffer, headerBuffer.remaining()).getBytes(); + + byte[] encryptedPayload = key.encryptPayload(truncatedPn, payload, header); + byte[] sample = ArrayUtils.subarray(ArrayUtils.addAll(truncatedPn, encryptedPayload), 4, 4+16); + byte[] maskKey = key.getMaskForHeaderProtection(sample); + byte[] maskedTruncatedPn = TruncatedPacketNumber.maskTruncatedPacketNumber(truncatedPn, maskKey); + + ByteBuffer buffer = ByteBuffer.allocate(1500); + buffer.put(super.getMaskedBytes(truncatedPn.length, maskKey)); + this.getBytesExtra(buffer); + buffer.put(payloadLength); + buffer.put(maskedTruncatedPn); + buffer.put(encryptedPayload); + buffer.flip(); + return SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + } + + @Override + @SneakyThrows + public Frames getFrames() { + return Frames.parse(this.payload); + } + + @Override + @SneakyThrows + public boolean isAckEliciting() { + return Frames.parse(this.payload).isAckEliciting(); + } + + @Override + @SneakyThrows + public boolean hasAckFrame() { + return Frames.parse(this.payload).hasAckFrame(); + } + + @Override + @SneakyThrows + public Optional getAckFrame() { + return Frames.parse(this.payload).getAckFrame(); + } + + @Override + public PnSpaceType getPnSpaceType() { + return PnSpaceInitial; + } + + @Override + public String toString() { + return String.format("LongHeaderPacket(version=%d, connIdPair=%s, packetNumber=%s, payload=%s", + this.version, + this.connectionIdPair, + this.packetNumber, + Frames.parse(this.payload)); + } + + protected void parseExtra(ByteBuffer buffer) {}; + protected void getBytesExtra(ByteBuffer buffer) throws Exception {}; + +} diff --git a/src/main/java/core/packetproxy/quic/value/packet/longheader/RetryPacket.java b/src/main/java/core/packetproxy/quic/value/packet/longheader/RetryPacket.java new file mode 100644 index 0000000..f66f812 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/packet/longheader/RetryPacket.java @@ -0,0 +1,68 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.packet.longheader; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.SimpleBytes; +import packetproxy.quic.value.ConnectionIdPair; +import packetproxy.quic.value.VariableLengthInteger; + +import java.nio.ByteBuffer; + +/* +https://datatracker.ietf.org/doc/html/rfc9000#section-17.2.5 +Retry Packet { + Header Form (1) = 1, + Fixed Bit (1) = 1, + Long Packet Type (2) = 3, + Unused (4), + Version (32), + Destination Connection ID Length (8), + Destination Connection ID (0..160), + Source Connection ID Length (8), + Source Connection ID (0..160), + Retry Token (..), + Retry Integrity Tag (128), +} +*/ +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class RetryPacket extends LongHeaderPacket { + + static public boolean is(byte type) { + return (type & 0xf0) == 0xf0; + } + + byte[] token; + byte[] tag; + + public RetryPacket(ByteBuffer buffer) { + super(buffer); + long length = VariableLengthInteger.parse(buffer).getValue(); + this.token = SimpleBytes.parse(buffer, length).getBytes(); + this.tag = SimpleBytes.parse(buffer, 16).getBytes(); + } + + public RetryPacket(byte type, int version, ConnectionIdPair connIdPair, byte[] token, byte[] tag) { + super(type, version, connIdPair); + this.token = token; + this.tag = tag; + } +} diff --git a/src/main/java/core/packetproxy/quic/value/packet/longheader/pnspace/HandshakePacket.java b/src/main/java/core/packetproxy/quic/value/packet/longheader/pnspace/HandshakePacket.java new file mode 100644 index 0000000..604693f --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/packet/longheader/pnspace/HandshakePacket.java @@ -0,0 +1,58 @@ +package packetproxy.quic.value.packet.longheader.pnspace; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.key.Key; +import packetproxy.quic.value.packet.longheader.LongHeaderPnSpacePacket; +import packetproxy.quic.value.ConnectionIdPair; +import packetproxy.quic.value.PacketNumber; +import packetproxy.quic.utils.Constants; + +import java.nio.ByteBuffer; + +/* Ref: RFC 9000 +Handshake Packet { + Header Form (1) = 1, + Fixed Bit (1) = 1, + Long Packet Type (2) = 2, + Reserved Bits (2), + Packet Number Length (2), + Version (32), + Destination Connection ID Length (8), + Destination Connection ID (0..160), + Source Connection ID Length (8), + Source Connection ID (0..160), + Length (i), + Packet Number (8..32), + Packet Payload (8..), +} +*/ +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class HandshakePacket extends LongHeaderPnSpacePacket { + + static public final byte TYPE = (byte)0xe0; + + static public boolean is(byte type) { + return (type & (byte)0xf0) == TYPE; + } + + static public HandshakePacket of(int version, ConnectionIdPair connIdPair, PacketNumber packetNumber, byte[] payload) { + return new HandshakePacket(TYPE, version, connIdPair, packetNumber, payload); + } + + public HandshakePacket(byte type, int version, ConnectionIdPair connIdPair, PacketNumber packetNumber, byte[] payload) { + super(type, version, connIdPair, packetNumber, payload); + } + + public HandshakePacket(ByteBuffer buffer, Key key, PacketNumber largestAckedPn) throws Exception { + super(buffer, key, largestAckedPn); + } + + @Override + public Constants.PnSpaceType getPnSpaceType() { + return Constants.PnSpaceType.PnSpaceHandshake; + } +} diff --git a/src/main/java/core/packetproxy/quic/value/packet/longheader/pnspace/InitialPacket.java b/src/main/java/core/packetproxy/quic/value/packet/longheader/pnspace/InitialPacket.java new file mode 100644 index 0000000..cf49f8f --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/packet/longheader/pnspace/InitialPacket.java @@ -0,0 +1,83 @@ +package packetproxy.quic.value.packet.longheader.pnspace; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import lombok.experimental.NonFinal; +import org.apache.commons.codec.binary.Hex; +import packetproxy.quic.value.key.Key; +import packetproxy.quic.value.packet.longheader.LongHeaderPnSpacePacket; +import packetproxy.quic.value.ConnectionIdPair; +import packetproxy.quic.value.PacketNumber; +import packetproxy.quic.value.VariableLengthPrecededBytes; +import packetproxy.quic.utils.Constants; + +import java.nio.ByteBuffer; + +/* Ref: RFC 9000 +Initial Packet { + Header Form (1) = 1, + Fixed Bit (1) = 1, + Long Packet Type (2) = 0, + Reserved Bits (2), + Packet Number Length (2), + Version (32), + Destination Connection ID Length (8), + Destination Connection ID (0..160), + Source Connection ID Length (8), + Source Connection ID (0..160), + Token Length (i), + Token (..), + Length (i), + Packet Number (8..32), + Packet Payload (8..), +} +*/ +@EqualsAndHashCode(callSuper = true) +@Value +public class InitialPacket extends LongHeaderPnSpacePacket { + + static public final byte TYPE = (byte)0xc0; + + static public boolean is(byte type) { + return (type & (byte)0xf0) == TYPE; + } + + static public InitialPacket of(int version, ConnectionIdPair connIdPair, PacketNumber packetNumber, byte[] payload, byte[] token) { + return new InitialPacket(TYPE, version, connIdPair, packetNumber, payload, token); + } + + @NonFinal + byte[] token; + + public InitialPacket(byte type, int version, ConnectionIdPair connIdPair, PacketNumber packetNumber, byte[] payload, byte[] token) { + super(type, version, connIdPair, packetNumber, payload); + this.token = token; + } + + public InitialPacket(ByteBuffer buffer, Key key, PacketNumber largestAckedPn) throws Exception { + super(buffer, key, largestAckedPn); + } + + @Override + protected void parseExtra(ByteBuffer buffer) { + this.token = VariableLengthPrecededBytes.parse(buffer).getBytes(); + } + + @Override + protected void getBytesExtra(ByteBuffer buffer) { + buffer.put(VariableLengthPrecededBytes.of(token).serialize()); + } + + @Override + public Constants.PnSpaceType getPnSpaceType() { + return Constants.PnSpaceType.PnSpaceInitial; + } + + @Override + public String toString() { + return String.format("InitialPacket(token=[%s], super=%s", + Hex.encodeHexString(this.token), + super.toString()); + } +} diff --git a/src/main/java/core/packetproxy/quic/value/packet/longheader/pnspace/ZeroRttPacket.java b/src/main/java/core/packetproxy/quic/value/packet/longheader/pnspace/ZeroRttPacket.java new file mode 100644 index 0000000..1fea380 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/packet/longheader/pnspace/ZeroRttPacket.java @@ -0,0 +1,60 @@ +package packetproxy.quic.value.packet.longheader.pnspace; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.utils.Constants.PnSpaceType; +import packetproxy.quic.value.key.Key; +import packetproxy.quic.value.packet.longheader.LongHeaderPnSpacePacket; +import packetproxy.quic.value.ConnectionIdPair; +import packetproxy.quic.value.PacketNumber; + +import java.nio.ByteBuffer; + +import static packetproxy.quic.utils.Constants.PnSpaceType.PnSpaceApplicationData; + +/* Ref: RFC 9000 (0RTT Packet) +0-RTT Packet { + Header Form (1) = 1, + Fixed Bit (1) = 1, + Long Packet Type (2) = 1, + Reserved Bits (2), + Packet Number Length (2), + Version (32), + Destination Connection ID Length (8), + Destination Connection ID (0..160), + Source Connection ID Length (8), + Source Connection ID (0..160), + Length (i), + Packet Number (8..32), + Packet Payload (8..), +} +*/ +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class ZeroRttPacket extends LongHeaderPnSpacePacket { + + static public final byte TYPE = (byte)0xd0; + + static public boolean is(byte type) { + return (type & (byte)0xf0) == TYPE; + } + + static public ZeroRttPacket of(int version, ConnectionIdPair connIdPair, PacketNumber packetNumber, byte[] payload) { + return new ZeroRttPacket(TYPE, version, connIdPair, packetNumber, payload); + } + + public ZeroRttPacket(byte type, int version, ConnectionIdPair connIdPair, PacketNumber packetNumber, byte[] payload) { + super(type, version, connIdPair, packetNumber, payload); + } + + public ZeroRttPacket(ByteBuffer buffer, Key key, PacketNumber largestAckedPn) throws Exception { + super(buffer, key, largestAckedPn); + } + + @Override + public PnSpaceType getPnSpaceType() { + return PnSpaceApplicationData; + } +} diff --git a/src/main/java/core/packetproxy/quic/value/packet/shortheader/ShortHeaderPacket.java b/src/main/java/core/packetproxy/quic/value/packet/shortheader/ShortHeaderPacket.java new file mode 100644 index 0000000..b9fb9b1 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/packet/shortheader/ShortHeaderPacket.java @@ -0,0 +1,187 @@ +package packetproxy.quic.value.packet.shortheader; + +import lombok.EqualsAndHashCode; +import lombok.Value; +import org.apache.commons.lang3.ArrayUtils; +import packetproxy.quic.utils.Constants; +import packetproxy.quic.value.frame.AckFrame; +import packetproxy.quic.service.frame.Frames; +import packetproxy.quic.value.key.Key; +import packetproxy.quic.value.packet.PnSpacePacket; +import packetproxy.quic.value.packet.QuicPacket; +import packetproxy.quic.value.ConnectionId; +import packetproxy.quic.value.PacketNumber; +import packetproxy.quic.value.SimpleBytes; +import packetproxy.quic.value.TruncatedPacketNumber; + +import java.nio.ByteBuffer; +import java.util.Optional; + +/* +https://datatracker.ietf.org/doc/html/rfc9000#section-17.3 +1-RTT Packet { + Header Form (1) = 0, + Fixed Bit (1) = 1, + Spin Bit (1), + Reserved Bits (2), + Key Phase (1), + Packet Number Length (2), + Destination Connection ID (0..160), + Packet Number (8..32), + Packet Payload (8..), +} +*/ +@EqualsAndHashCode(callSuper = true) +@Value +public class ShortHeaderPacket extends QuicPacket implements PnSpacePacket { + + static public final byte TYPE = (byte)0x40; + + static public boolean is(byte type) { + return (type & (byte)0xc0) == TYPE; + } + + static public ConnectionId getDestConnId(ByteBuffer buffer) { + int savedPosition = buffer.position(); + buffer.get(); + byte[] destConnId = SimpleBytes.parse(buffer, Constants.CONNECTION_ID_SIZE).getBytes(); + buffer.position(savedPosition); + return ConnectionId.of(destConnId); + } + + static public ShortHeaderPacket of(ConnectionId destConnId, PacketNumber packetNumber, byte[] payload) { + return new ShortHeaderPacket(TYPE, destConnId, packetNumber, payload); + } + + ConnectionId destConnId; + PacketNumber packetNumber; + byte[] payload; + + public ShortHeaderPacket(byte type, ConnectionId destConnId, PacketNumber packetNumber, byte[] payload) { + super(type); + this.destConnId = destConnId; + this.packetNumber = packetNumber; + this.payload = payload; + } + + public ShortHeaderPacket(ByteBuffer buffer, Key key, PacketNumber largestAckedPn) throws Exception { + super(buffer); + int startPosition = buffer.position() - super.size(); + + this.destConnId = ConnectionId.parse(buffer, Constants.CONNECTION_ID_SIZE); + + // get the sampling data + int packetNumberPosition = buffer.position(); + buffer.position(buffer.position() + 4); + byte[] sample = SimpleBytes.parse(buffer, 16).getBytes(); + + // get the maskKey from the sampling data + byte[] maskKey = key.getMaskForHeaderProtection(sample); + + super.unmaskType(PacketHeaderType.ShortHeaderType, maskKey); + int packetNumberLength = super.getOrigPnLength(); + + // decode header protection of truncatedPacketNumber + buffer.position(packetNumberPosition); + byte[] maskedTruncatedPn = SimpleBytes.parse(buffer, packetNumberLength).getBytes(); + byte[] truncatedPn = TruncatedPacketNumber.unmaskTruncatedPacketNumber(maskedTruncatedPn, maskKey); + + int payloadPosition = buffer.position(); + int payloadLength = buffer.limit() - payloadPosition; + byte[] encodedPayload = SimpleBytes.parse(buffer, payloadLength).getBytes(); + int positionPacketEnd = buffer.position(); + + /* create unmasked header for associated data of AES decryption */ + buffer.position(startPosition); + byte[] header = SimpleBytes.parse(buffer, payloadPosition - startPosition).getBytes(); + header[0] = super.getType(); + for (int i = 0; i < truncatedPn.length; i++) { + header[packetNumberPosition - startPosition + i] = truncatedPn[i]; + } + + this.payload = key.decryptPayload(truncatedPn, encodedPayload, header); + this.packetNumber = new TruncatedPacketNumber(truncatedPn).getPacketNumber(largestAckedPn); + + buffer.position(positionPacketEnd); + } + + public byte[] getBytes(Key key, PacketNumber largestAckedPn) throws Exception { + ByteBuffer headerBuffer = ByteBuffer.allocate(1500); + + byte[] truncatedPn = this.packetNumber.getTruncatedPacketNumber(largestAckedPn).getBytes(); + if (truncatedPn.length + this.payload.length + 16 /* AES auth hash */ < 20) { + int dummyBytesLength = 20 - truncatedPn.length - this.payload.length - 16; + truncatedPn = ArrayUtils.addAll(new byte[dummyBytesLength], truncatedPn); + } + + /* create original header for associated data of AES encryption */ + byte type = super.getType(truncatedPn.length); + headerBuffer.put(type); + headerBuffer.put(this.destConnId.getBytes()); + headerBuffer.put(truncatedPn); + headerBuffer.flip(); + byte[] header = SimpleBytes.parse(headerBuffer, headerBuffer.remaining()).getBytes(); + + byte[] encryptedPayload = key.encryptPayload(truncatedPn, payload, header); + byte[] sample = ArrayUtils.subarray(ArrayUtils.addAll(truncatedPn, encryptedPayload), 4, 4+16); + byte[] maskKey = key.getMaskForHeaderProtection(sample); + byte maskedType = super.getMaskedType(truncatedPn.length, PacketHeaderType.ShortHeaderType, maskKey); + byte[] maskedTruncatedPn = TruncatedPacketNumber.maskTruncatedPacketNumber(truncatedPn, maskKey); + + ByteBuffer buffer = ByteBuffer.allocate(1500); + buffer.put(maskedType); + buffer.put(this.destConnId.getBytes()); + buffer.put(maskedTruncatedPn); + buffer.put(encryptedPayload); + buffer.flip(); + return SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + } + + public int size() { + return this.getBytes().length; + } + + @Override + public String toString() { + try { + return String.format("ShortHeaderPacket(connIdPair=%s, packetNumber=%s, payload=%s", + this.destConnId, + this.packetNumber, + Frames.parse(this.payload)); + } catch (Exception e) { + e.printStackTrace(); + return ""; + } + } + + @Override + public PacketNumber getPacketNumber() { + return this.packetNumber; + } + + @Override + public boolean isAckEliciting() { + return Frames.parse(this.payload).isAckEliciting(); + } + + @Override + public boolean hasAckFrame() { + return Frames.parse(this.payload).hasAckFrame(); + } + + @Override + public Optional getAckFrame() { + return Frames.parse(this.payload).getAckFrame(); + } + + @Override + public Constants.PnSpaceType getPnSpaceType() { + return Constants.PnSpaceType.PnSpaceApplicationData; + } + + @Override + public Frames getFrames() { + Frames frames = Frames.parse(this.payload); + return frames; + } +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/TransportParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/TransportParameter.java new file mode 100644 index 0000000..28fdd0e --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/TransportParameter.java @@ -0,0 +1,74 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.transportparameter; + +import lombok.*; +import lombok.experimental.NonFinal; +import packetproxy.quic.value.SimpleBytes; +import packetproxy.quic.value.VariableLengthInteger; + +import java.nio.ByteBuffer; + +/* +https://www.rfc-editor.org/rfc/rfc9000.html#transport-parameter-encoding + +Transport Parameter { + Transport Parameter ID (i), + Transport Parameter Length (i), + Transport Parameter Value (..), +} + +// Old Transport Parameters +ID: Description +====================== +0x0020: datagram +0x0040: multi path +0x1057: loss bits +0x173e: discard +0x2ab2: grease quic bit // https://datatracker.ietf.org/doc/html/draft-ietf-quic-bit-grease +0x7157: timestamp // https://datatracker.ietf.org/doc/html/draft-huitema-quic-ts-02#section-5 +0x7158: timestamp // https://datatracker.ietf.org/doc/html/draft-huitema-quic-ts-05#section-5 +0x73db: version negotiation // https://datatracker.ietf.org/doc/html/draft-ietf-quic-version-negotiation-03#section-12.1 +0xff73db: version negotiation // https://datatracker.ietf.org/doc/html/draft-ietf-quic-version-negotiation-08 +0xde1a: min ack delay // https://datatracker.ietf.org/doc/html/draft-iyengar-quic-delayed-ack-01#section-3 +0xff02de1a: min ack delay // https://datatracker.ietf.org/doc/html/draft-iyengar-quic-delayed-ack-02#section-3 +0xff03de1a: min ack delay // https://datatracker.ietf.org/doc/html/draft-ietf-quic-ack-frequency +*/ + +@NonFinal +@AllArgsConstructor +@Value +public abstract class TransportParameter { + protected long parameterId; + protected long parameterLength; + protected byte[] parameterValue; + + public TransportParameter(ByteBuffer buffer) { + this.parameterId = VariableLengthInteger.parse(buffer).getValue(); + this.parameterLength = VariableLengthInteger.parse(buffer).getValue(); + this.parameterValue = SimpleBytes.parse(buffer, this.parameterLength).getBytes(); + } + + public byte[] getBytes() { + ByteBuffer buffer = ByteBuffer.allocate(4096); + buffer.put(VariableLengthInteger.of(this.parameterId).getBytes()); + buffer.put(VariableLengthInteger.of(this.parameterLength).getBytes()); + buffer.put(this.parameterValue); + buffer.flip(); + return SimpleBytes.parse(buffer, buffer.remaining()).getBytes(); + } +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/UnknownParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/UnknownParameter.java new file mode 100644 index 0000000..74bc38b --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/UnknownParameter.java @@ -0,0 +1,42 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.transportparameter; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class UnknownParameter extends TransportParameter { + static public final long ID = 0xdeadbeefL; + + public UnknownParameter(ByteBuffer buffer) { + super(buffer); + } + + public UnknownParameter(byte[] unknownBytes) { + super(ID, unknownBytes.length, unknownBytes); + } + public byte[] getValue() { + return super.parameterValue; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/bool/DisableActiveMigrationParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/bool/DisableActiveMigrationParameter.java new file mode 100644 index 0000000..b4b6685 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/bool/DisableActiveMigrationParameter.java @@ -0,0 +1,40 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.transportparameter.bool; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class DisableActiveMigrationParameter extends TransportParameter { + static public final long ID = 0xc; + + public DisableActiveMigrationParameter(ByteBuffer buffer) { + super(buffer); + } + + public DisableActiveMigrationParameter() { + super(ID, 0, new byte[0]); + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/bool/ExpGreaseQuicBitParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/bool/ExpGreaseQuicBitParameter.java new file mode 100644 index 0000000..278697e --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/bool/ExpGreaseQuicBitParameter.java @@ -0,0 +1,40 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.transportparameter.bool; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class ExpGreaseQuicBitParameter extends TransportParameter { + static public final long ID = 0x2ab2; + + public ExpGreaseQuicBitParameter(ByteBuffer buffer) { + super(buffer); + } + + public ExpGreaseQuicBitParameter() { + super(ID, 0, new byte[0]); + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/bytearray/InitSrcConnIdParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/bytearray/InitSrcConnIdParameter.java new file mode 100644 index 0000000..0e483e4 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/bytearray/InitSrcConnIdParameter.java @@ -0,0 +1,43 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.transportparameter.bytearray; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class InitSrcConnIdParameter extends TransportParameter { + static public final long ID = 0xf; + + public InitSrcConnIdParameter(ByteBuffer buffer) { + super(buffer); + } + + public InitSrcConnIdParameter(byte[] srcConnId) { + super(ID, srcConnId.length, srcConnId); + } + + public byte[] getValue() { + return super.parameterValue; + } +} \ No newline at end of file diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/bytearray/OrigDestConnIdParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/bytearray/OrigDestConnIdParameter.java new file mode 100644 index 0000000..02df834 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/bytearray/OrigDestConnIdParameter.java @@ -0,0 +1,44 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.transportparameter.bytearray; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class OrigDestConnIdParameter extends TransportParameter { + static public final long ID = 0x0; + + public OrigDestConnIdParameter(ByteBuffer buffer) { + super(buffer); + } + + public OrigDestConnIdParameter(byte[] destConnId) { + super(ID, destConnId.length, destConnId); + } + + public byte[] getValue() { + return super.parameterValue; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/bytearray/RetrySrcConnIdParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/bytearray/RetrySrcConnIdParameter.java new file mode 100644 index 0000000..0b1e887 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/bytearray/RetrySrcConnIdParameter.java @@ -0,0 +1,44 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.transportparameter.bytearray; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class RetrySrcConnIdParameter extends TransportParameter { + static public final long ID = 0x10; + + public RetrySrcConnIdParameter(ByteBuffer buffer) { + super(buffer); + } + + public RetrySrcConnIdParameter(byte[] srcConnId) { + super(ID, srcConnId.length, srcConnId); + } + + public byte[] getValue() { + return super.parameterValue; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/bytearray/StatelessResetTokenParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/bytearray/StatelessResetTokenParameter.java new file mode 100644 index 0000000..18682d4 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/bytearray/StatelessResetTokenParameter.java @@ -0,0 +1,44 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.transportparameter.bytearray; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class StatelessResetTokenParameter extends TransportParameter { + static public final long ID = 0x2; + + public StatelessResetTokenParameter(ByteBuffer buffer) { + super(buffer); + } + + public StatelessResetTokenParameter(byte[] token) { + super(ID, token.length, token); + } + + public byte[] getValue() { + return super.parameterValue; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/complex/PreferredAddressParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/complex/PreferredAddressParameter.java new file mode 100644 index 0000000..98f66b9 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/complex/PreferredAddressParameter.java @@ -0,0 +1,40 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.transportparameter.complex; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class PreferredAddressParameter extends TransportParameter { + static public final long ID = 0xd; + + public PreferredAddressParameter(ByteBuffer buffer) { + super(buffer); + } + + public byte[] getValue() { + return super.parameterValue; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/number/AckDelayExponentParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/number/AckDelayExponentParameter.java new file mode 100644 index 0000000..333b54c --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/number/AckDelayExponentParameter.java @@ -0,0 +1,28 @@ +package packetproxy.quic.value.transportparameter.number; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.VariableLengthInteger; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class AckDelayExponentParameter extends TransportParameter { + static public final long ID = 0xa; + long value; + + public AckDelayExponentParameter(ByteBuffer buffer) { + super(buffer); + value = VariableLengthInteger.parse(super.parameterValue).getValue(); + } + + public AckDelayExponentParameter(long value) { + super(ID, VariableLengthInteger.of(value).getBytes().length, VariableLengthInteger.of(value).getBytes()); + this.value = value; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/number/ActiveConnIdLimitParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/number/ActiveConnIdLimitParameter.java new file mode 100644 index 0000000..adf4983 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/number/ActiveConnIdLimitParameter.java @@ -0,0 +1,28 @@ +package packetproxy.quic.value.transportparameter.number; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.VariableLengthInteger; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class ActiveConnIdLimitParameter extends TransportParameter { + static public final long ID = 0xe; + long value; + + public ActiveConnIdLimitParameter(ByteBuffer buffer) { + super(buffer); + value = VariableLengthInteger.parse(super.parameterValue).getValue(); + } + + public ActiveConnIdLimitParameter(long value) { + super(ID, VariableLengthInteger.of(value).getBytes().length, VariableLengthInteger.of(value).getBytes()); + this.value = value; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/number/ExpMinAckDelayParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/number/ExpMinAckDelayParameter.java new file mode 100644 index 0000000..46fa973 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/number/ExpMinAckDelayParameter.java @@ -0,0 +1,29 @@ +package packetproxy.quic.value.transportparameter.number; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.VariableLengthInteger; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +/* https://datatracker.ietf.org/doc/html/draft-ietf-quic-ack-frequency */ +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class ExpMinAckDelayParameter extends TransportParameter { + static public final long ID = 0xff03de1aL; + long value; + + public ExpMinAckDelayParameter(ByteBuffer buffer) { + super(buffer); + value = VariableLengthInteger.parse(super.parameterValue).getValue(); + } + + public ExpMinAckDelayParameter(long value) { + super(ID, VariableLengthInteger.of(value).getBytes().length, VariableLengthInteger.of(value).getBytes()); + this.value = value; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxDataParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxDataParameter.java new file mode 100644 index 0000000..3123285 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxDataParameter.java @@ -0,0 +1,28 @@ +package packetproxy.quic.value.transportparameter.number; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.VariableLengthInteger; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class InitMaxDataParameter extends TransportParameter { + static public final long ID = 0x4; + long value; + + public InitMaxDataParameter(ByteBuffer buffer) { + super(buffer); + this.value = VariableLengthInteger.parse(super.parameterValue).getValue(); + } + + public InitMaxDataParameter(long value) { + super(ID, VariableLengthInteger.of(value).getBytes().length, VariableLengthInteger.of(value).getBytes()); + this.value = value; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamBidiParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamBidiParameter.java new file mode 100644 index 0000000..6b1a155 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamBidiParameter.java @@ -0,0 +1,28 @@ +package packetproxy.quic.value.transportparameter.number; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.VariableLengthInteger; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class InitMaxStreamBidiParameter extends TransportParameter { + static public final long ID = 0x8; + long value; + + public InitMaxStreamBidiParameter(ByteBuffer buffer) { + super(buffer); + this.value = VariableLengthInteger.parse(super.parameterValue).getValue(); + } + + public InitMaxStreamBidiParameter(long value) { + super(ID, VariableLengthInteger.of(value).getBytes().length, VariableLengthInteger.of(value).getBytes()); + this.value = value; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamDataBidiLocalParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamDataBidiLocalParameter.java new file mode 100644 index 0000000..fb8d164 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamDataBidiLocalParameter.java @@ -0,0 +1,28 @@ +package packetproxy.quic.value.transportparameter.number; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.VariableLengthInteger; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class InitMaxStreamDataBidiLocalParameter extends TransportParameter { + static public final long ID = 0x5; + long value; + + public InitMaxStreamDataBidiLocalParameter(ByteBuffer buffer) { + super(buffer); + value = VariableLengthInteger.parse(super.parameterValue).getValue(); + } + + public InitMaxStreamDataBidiLocalParameter(long value) { + super(ID, VariableLengthInteger.of(value).getBytes().length, VariableLengthInteger.of(value).getBytes()); + this.value = value; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamDataBidiRemoteParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamDataBidiRemoteParameter.java new file mode 100644 index 0000000..29b5afe --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamDataBidiRemoteParameter.java @@ -0,0 +1,28 @@ +package packetproxy.quic.value.transportparameter.number; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.VariableLengthInteger; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class InitMaxStreamDataBidiRemoteParameter extends TransportParameter { + static public final long ID = 0x6; + long value; + + public InitMaxStreamDataBidiRemoteParameter(ByteBuffer buffer) { + super(buffer); + value = VariableLengthInteger.parse(super.parameterValue).getValue(); + } + + public InitMaxStreamDataBidiRemoteParameter(long value) { + super(ID, VariableLengthInteger.of(value).getBytes().length, VariableLengthInteger.of(value).getBytes()); + this.value = value; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamDataUniParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamDataUniParameter.java new file mode 100644 index 0000000..0047d6e --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamDataUniParameter.java @@ -0,0 +1,28 @@ +package packetproxy.quic.value.transportparameter.number; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.VariableLengthInteger; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class InitMaxStreamDataUniParameter extends TransportParameter { + static public final long ID = 0x7; + long value; + + public InitMaxStreamDataUniParameter(ByteBuffer buffer) { + super(buffer); + this.value = VariableLengthInteger.parse(super.parameterValue).getValue(); + } + + public InitMaxStreamDataUniParameter(long value) { + super(ID, VariableLengthInteger.of(value).getBytes().length, VariableLengthInteger.of(value).getBytes()); + this.value = value; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamUniParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamUniParameter.java new file mode 100644 index 0000000..cf7e823 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/number/InitMaxStreamUniParameter.java @@ -0,0 +1,28 @@ +package packetproxy.quic.value.transportparameter.number; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.VariableLengthInteger; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class InitMaxStreamUniParameter extends TransportParameter { + static public final long ID = 0x9; + long value; + + public InitMaxStreamUniParameter(ByteBuffer buffer) { + super(buffer); + this.value = VariableLengthInteger.parse(super.parameterValue).getValue(); + } + + public InitMaxStreamUniParameter(long value) { + super(ID, VariableLengthInteger.of(value).getBytes().length, VariableLengthInteger.of(value).getBytes()); + this.value = value; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/number/MaxAckDelayParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/number/MaxAckDelayParameter.java new file mode 100644 index 0000000..06deb88 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/number/MaxAckDelayParameter.java @@ -0,0 +1,28 @@ +package packetproxy.quic.value.transportparameter.number; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.VariableLengthInteger; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class MaxAckDelayParameter extends TransportParameter { + static public final long ID = 0xb; + long value; + + public MaxAckDelayParameter(ByteBuffer buffer) { + super(buffer); + value = VariableLengthInteger.parse(super.parameterValue).getValue(); + } + + public MaxAckDelayParameter(long value) { + super(ID, VariableLengthInteger.of(value).getBytes().length, VariableLengthInteger.of(value).getBytes()); + this.value = value; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/number/MaxIdleTimeoutParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/number/MaxIdleTimeoutParameter.java new file mode 100644 index 0000000..df436f3 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/number/MaxIdleTimeoutParameter.java @@ -0,0 +1,28 @@ +package packetproxy.quic.value.transportparameter.number; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.VariableLengthInteger; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class MaxIdleTimeoutParameter extends TransportParameter { + static public final long ID = 0x1; + long value; + + public MaxIdleTimeoutParameter(ByteBuffer buffer) { + super(buffer); + value = VariableLengthInteger.parse(super.parameterValue).getValue(); + } + + public MaxIdleTimeoutParameter(long value) { + super(ID, VariableLengthInteger.of(value).getBytes().length, VariableLengthInteger.of(value).getBytes()); + this.value = value; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/number/MaxUdpPayloadSizeParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/number/MaxUdpPayloadSizeParameter.java new file mode 100644 index 0000000..8be02e4 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/number/MaxUdpPayloadSizeParameter.java @@ -0,0 +1,28 @@ +package packetproxy.quic.value.transportparameter.number; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.VariableLengthInteger; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class MaxUdpPayloadSizeParameter extends TransportParameter { + static public final long ID = 0x3; + long value; + + public MaxUdpPayloadSizeParameter(ByteBuffer buffer) { + super(buffer); + value = VariableLengthInteger.parse(super.parameterValue).getValue(); + } + + public MaxUdpPayloadSizeParameter(long value) { + super(ID, VariableLengthInteger.of(value).getBytes().length, VariableLengthInteger.of(value).getBytes()); + this.value = value; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/number/OldMinAckDelayParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/number/OldMinAckDelayParameter.java new file mode 100644 index 0000000..d9a6961 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/number/OldMinAckDelayParameter.java @@ -0,0 +1,30 @@ +package packetproxy.quic.value.transportparameter.number; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.VariableLengthInteger; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +/* https://datatracker.ietf.org/doc/html/draft-iyengar-quic-delayed-ack-02#section-3 */ +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class OldMinAckDelayParameter extends TransportParameter { + static public final long ID = 0xff02de1aL; + + long value; + + public OldMinAckDelayParameter(ByteBuffer buffer) { + super(buffer); + value = VariableLengthInteger.parse(super.parameterValue).getValue(); + } + + public OldMinAckDelayParameter(long value) { + super(ID, VariableLengthInteger.of(value).getBytes().length, VariableLengthInteger.of(value).getBytes()); + this.value = value; + } + +} diff --git a/src/main/java/core/packetproxy/quic/value/transportparameter/number/OldTimestampParameter.java b/src/main/java/core/packetproxy/quic/value/transportparameter/number/OldTimestampParameter.java new file mode 100644 index 0000000..1c78049 --- /dev/null +++ b/src/main/java/core/packetproxy/quic/value/transportparameter/number/OldTimestampParameter.java @@ -0,0 +1,28 @@ +package packetproxy.quic.value.transportparameter.number; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.value.VariableLengthInteger; +import packetproxy.quic.value.transportparameter.TransportParameter; + +import java.nio.ByteBuffer; + +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Value +public class OldTimestampParameter extends TransportParameter { + static public final long ID = 0x7158; + long value; + + public OldTimestampParameter(ByteBuffer buffer) { + super(buffer); + value = VariableLengthInteger.parse(super.parameterValue).getValue(); + } + + public OldTimestampParameter(long value) { + super(ID, VariableLengthInteger.of(value).getBytes().length, VariableLengthInteger.of(value).getBytes()); + this.value = value; + } + +} diff --git a/src/main/java/core/packetproxy/util/Throwing.java b/src/main/java/core/packetproxy/util/Throwing.java new file mode 100644 index 0000000..67c739e --- /dev/null +++ b/src/main/java/core/packetproxy/util/Throwing.java @@ -0,0 +1,20 @@ +package packetproxy.util; + +import javax.annotation.Nonnull; +import java.util.function.Consumer; + +public class Throwing { + + private Throwing() {} + + @Nonnull + public static Consumer rethrow(@Nonnull final ThrowingConsumer consumer) { + return consumer; + } + + @SuppressWarnings("unchecked") + @Nonnull + public static void sneakyThrow(@Nonnull Throwable ex) throws E { + throw (E) ex; + } +} diff --git a/src/main/java/core/packetproxy/util/ThrowingConsumer.java b/src/main/java/core/packetproxy/util/ThrowingConsumer.java new file mode 100644 index 0000000..33c5e7f --- /dev/null +++ b/src/main/java/core/packetproxy/util/ThrowingConsumer.java @@ -0,0 +1,18 @@ +package packetproxy.util; + +import java.util.function.Consumer; + +@FunctionalInterface +public interface ThrowingConsumer extends Consumer { + + @Override + default void accept(final T e) { + try { + accept0(e); + } catch (Throwable ex) { + Throwing.sneakyThrow(ex); + } + } + + void accept0(T e) throws Throwable; +} \ No newline at end of file diff --git a/src/test/java/packetproxy/PrivateDNSClientTest.java b/src/test/java/packetproxy/PrivateDNSClientTest.java new file mode 100644 index 0000000..6b3432b --- /dev/null +++ b/src/test/java/packetproxy/PrivateDNSClientTest.java @@ -0,0 +1,83 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy; + +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; + +import static org.junit.jupiter.api.Assertions.*; + +class PrivateDNSClientTest { + + @Test + public void 成功するケース() throws Exception { + ArrayList lines = new ArrayList<>(); + lines.add("127.0.0.1 aaa aaa.example.com # for test"); + assertTrue(PrivateDNSClient.dnsLoopingFromHostsLines(lines, "aaa.example.com")); + } + + @Test + public void 成功するケース2() throws Exception { + ArrayList lines = new ArrayList<>(); + lines.add("2.3.4.5 aaa bbb.example.com"); + lines.add("127.0.0.1 aaa aaa.example.com"); + assertTrue(PrivateDNSClient.dnsLoopingFromHostsLines(lines, "aaa.example.com")); + } + + @Test + public void 成功するケース3() throws Exception { + ArrayList lines = new ArrayList<>(); + lines.add(" # this is a comment."); + lines.add("# 2.3.4.5 aaa bbb.example.com"); + lines.add("127.0.0.1 aaa aaa.example.com"); + lines.add(" # 3.3.3.3 aaa ccc.example.com"); + assertTrue(PrivateDNSClient.dnsLoopingFromHostsLines(lines, "aaa.example.com")); + } + + @Test + public void 失敗するケース() throws Exception { + ArrayList lines = new ArrayList<>(); + lines.add("127.0.0.2 aaa aaa.example.com # for test"); + assertFalse(PrivateDNSClient.dnsLoopingFromHostsLines(lines, "aaa.example.com")); + } + + @Test + public void 失敗するケース2() throws Exception { + ArrayList lines = new ArrayList<>(); + lines.add("# 127.0.0.2 aaa aaa.example.com"); + assertFalse(PrivateDNSClient.dnsLoopingFromHostsLines(lines, "aaa.example.com")); + } + + @Test + public void 失敗するケース3() throws Exception { + ArrayList lines = new ArrayList<>(); + lines.add("# 127.0.0.2 aaa bbb.example.com"); + assertFalse(PrivateDNSClient.dnsLoopingFromHostsLines(lines, "aaa.example.com")); + } + + @Test + public void 失敗するケース4() throws Exception { + ArrayList lines = new ArrayList<>(); + lines.add(" # this is a comment."); + lines.add("# 2.3.4.5 aaa bbb.example.com"); + lines.add("127.0.0.1 aaa ddd.example.com"); + lines.add(" # 3.3.3.3 aaa ccc.example.com"); + assertFalse(PrivateDNSClient.dnsLoopingFromHostsLines(lines, "aaa.example.com")); + } + +} \ No newline at end of file diff --git a/src/test/java/packetproxy/http3/QpackTest.java b/src/test/java/packetproxy/http3/QpackTest.java new file mode 100644 index 0000000..d8e0569 --- /dev/null +++ b/src/test/java/packetproxy/http3/QpackTest.java @@ -0,0 +1,81 @@ +package packetproxy.http3; + +import org.apache.commons.codec.binary.Hex; +import org.eclipse.jetty.http.HttpFields; +import org.eclipse.jetty.http.HttpVersion; +import org.eclipse.jetty.http.MetaData; +import org.eclipse.jetty.http3.qpack.Instruction; +import org.eclipse.jetty.http3.qpack.QpackDecoder; +import org.eclipse.jetty.http3.qpack.QpackEncoder; +import org.eclipse.jetty.io.ByteBufferPool; +import org.eclipse.jetty.io.MappedByteBufferPool; +import org.junit.jupiter.api.Test; +import packetproxy.quic.value.SimpleBytes; + +import java.nio.ByteBuffer; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +public class QpackTest { + @Test + public void Encode後DeCodeできるかテスト() throws Exception { + + ByteBufferPool bufferPool = new MappedByteBufferPool(); + ByteBufferPool.Lease lease = new ByteBufferPool.Lease(bufferPool); + + ByteBufferPool bufferPool2 = new MappedByteBufferPool(); + ByteBufferPool.Lease lease2 = new ByteBufferPool.Lease(bufferPool2); + + QpackEncoder encoder = new QpackEncoder(new Instruction.Handler() { + @Override + public void onInstructions(List instructions) { + System.out.println("Encode Instructions: " + instructions); + instructions.stream().forEach(i -> i.encode(lease)); + } + }, 100); + + QpackDecoder decoder = new QpackDecoder(new Instruction.Handler() { + @Override + public void onInstructions(List instructions) { + System.out.println("Decode Instructions: " + instructions); + instructions.stream().forEach(i -> i.encode(lease2)); + } + }, 100); + + encoder.setCapacity(100); + ByteBuffer buffer = ByteBuffer.allocate(1024); + HttpFields httpFields = HttpFields.build().add("hoge", "fuga"); + encoder.encode(buffer, 0, new MetaData(HttpVersion.HTTP_3, httpFields)); + buffer.flip(); + System.out.println("Stream data: " + Hex.encodeHexString(SimpleBytes.parse(buffer, buffer.remaining()).getBytes())); + + lease.getByteBuffers().forEach(b -> { + try { + decoder.parseInstructions(b); + } catch (Exception e) { + e.printStackTrace(); + } + }); + + buffer.position(0); + decoder.decode(0, buffer, new QpackDecoder.Handler() { + @Override + public void onMetaData(long streamId, MetaData metadata) { + System.out.println("streamId: " + streamId + ", meta: " + metadata); + assertThat(httpFields.asImmutable()).isEqualTo(metadata.getFields()); + } + }); + + System.out.println(encoder.dump()); + lease2.getByteBuffers().forEach(b -> { + try { + encoder.parseInstructions(b); + } catch (Exception e) { + e.printStackTrace(); + } + }); + System.out.println(encoder.dump()); + + } +} diff --git a/src/test/java/packetproxy/quic/service/ackgenerator/AckFrameGeneratorTest.java b/src/test/java/packetproxy/quic/service/ackgenerator/AckFrameGeneratorTest.java new file mode 100644 index 0000000..881351b --- /dev/null +++ b/src/test/java/packetproxy/quic/service/ackgenerator/AckFrameGeneratorTest.java @@ -0,0 +1,123 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.ackgenerator; + + +import org.apache.commons.codec.binary.Hex; +import org.junit.jupiter.api.Test; +import packetproxy.quic.value.frame.AckFrame; +import packetproxy.quic.service.framegenerator.AckFrameGenerator; + +import static org.junit.jupiter.api.Assertions.*; + +class AckFrameGeneratorTest { + + @Test + public void 全て受信() throws Exception { + AckFrameGenerator ackFrameGenerator = new AckFrameGenerator(); + + ackFrameGenerator.received(0); + ackFrameGenerator.received(1); + ackFrameGenerator.received(2); + ackFrameGenerator.received(3); + + AckFrame ackFrame = ackFrameGenerator.generateAckFrame(); + assertEquals(3, ackFrame.getLargestAcknowledged()); + assertEquals(3, ackFrame.getFirstAckRange()); + assertEquals(0, ackFrame.getAckRangeCount()); + } + + @Test + public void 受信できていないpacketが存在() throws Exception { + AckFrameGenerator ackFrameGenerator = new AckFrameGenerator(); + + ackFrameGenerator.received(100); + + AckFrame ackFrame = ackFrameGenerator.generateAckFrame(); + assertEquals(100, ackFrame.getLargestAcknowledged()); + assertEquals(0, ackFrame.getFirstAckRange()); + assertEquals(0, ackFrame.getAckRangeCount()); + } + + @Test + public void 受信できていないpacketが複数存在() throws Exception { + AckFrameGenerator ackFrameGenerator = new AckFrameGenerator(); + + ackFrameGenerator.received(2); + ackFrameGenerator.received(3); + ackFrameGenerator.received(4); + ackFrameGenerator.received(5); + ackFrameGenerator.received(6); + ackFrameGenerator.received(7); + ackFrameGenerator.received(10); + + AckFrame ackFrame = ackFrameGenerator.generateAckFrame(); + assertEquals(10, ackFrame.getLargestAcknowledged()); + assertEquals(0, ackFrame.getFirstAckRange()); + assertEquals(1, ackFrame.getAckRangeCount()); + assertEquals(1, ackFrame.getAckRanges().get(0).getGap()); + assertEquals(5, ackFrame.getAckRanges().get(0).getAckRangeLength()); + } + + @Test + public void 最初のpacketを受信した後getBytesできること() throws Exception { + AckFrameGenerator ackFrameGenerator = new AckFrameGenerator(); + ackFrameGenerator.received(0); + AckFrame ackFrame = ackFrameGenerator.generateAckFrame(); + + assertEquals(0, ackFrame.getLargestAcknowledged()); + assertEquals(0, ackFrame.getFirstAckRange()); + assertEquals(0, ackFrame.getAckRangeCount()); + assertArrayEquals(Hex.decodeHex("0200000000".toCharArray()), ackFrame.getBytes()); + } + + @Test + public void 相手に受信されるとAckFrameは生成されない() throws Exception { + AckFrameGenerator ackFrameGenerator = new AckFrameGenerator(); + ackFrameGenerator.received(2); + ackFrameGenerator.received(4); + ackFrameGenerator.received(6); + AckFrame ackFrame = ackFrameGenerator.generateAckFrame(); + ackFrameGenerator.confirmedAckFrame(ackFrame); + AckFrame ackFrame2 = ackFrameGenerator.generateAckFrame(); + + assertNotNull(ackFrame); + assertNull(ackFrame2); + } + + @Test + public void 相手に受信された後さらに受信すると差分のAckFrameが生成される() throws Exception { + AckFrameGenerator ackFrameGenerator = new AckFrameGenerator(); + ackFrameGenerator.received(2); + ackFrameGenerator.received(4); + ackFrameGenerator.received(6); + AckFrame ackFrame = ackFrameGenerator.generateAckFrame(); + ackFrameGenerator.received(7); + ackFrameGenerator.received(9); + ackFrameGenerator.confirmedAckFrame(ackFrame); + AckFrame ackFrame2 = ackFrameGenerator.generateAckFrame(); + + assertNotNull(ackFrame); + assertNotNull(ackFrame2); + assertEquals(9, ackFrame2.getLargestAcknowledged()); + assertEquals(0, ackFrame2.getFirstAckRange()); + assertEquals(1, ackFrame2.getAckRangeCount()); + assertEquals(0, ackFrame2.getAckRanges().get(0).getGap()); + assertEquals(0, ackFrame2.getAckRanges().get(0).getAckRangeLength()); + } + +} \ No newline at end of file diff --git a/src/test/java/packetproxy/quic/service/ackgenerator/ReceivedQuicPacketNumbersTest.java b/src/test/java/packetproxy/quic/service/ackgenerator/ReceivedQuicPacketNumbersTest.java new file mode 100644 index 0000000..e355de6 --- /dev/null +++ b/src/test/java/packetproxy/quic/service/ackgenerator/ReceivedQuicPacketNumbersTest.java @@ -0,0 +1,115 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.ackgenerator; + + +import org.junit.jupiter.api.Test; +import packetproxy.quic.service.framegenerator.helper.ReceivedPacketNumbers; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class ReceivedQuicPacketNumbersTest { + + @Test + public void smoke() throws Exception { + ReceivedPacketNumbers receivedPacketNumbers = new ReceivedPacketNumbers(); + receivedPacketNumbers.received(0); + receivedPacketNumbers.received(1); + receivedPacketNumbers.received(2); + receivedPacketNumbers.received(3); + receivedPacketNumbers.unreceived(4); + receivedPacketNumbers.unreceived(5); + receivedPacketNumbers.unreceived(6); + + assertEquals(7, receivedPacketNumbers.getSmallestOfRange(10, 0)); + assertEquals(4, receivedPacketNumbers.getSmallestOfGap(6, 0)); + assertEquals(0, receivedPacketNumbers.getSmallestOfRange(3, 0)); + } + + @Test + public void 渡した値がそのまま返るパターン() throws Exception { + ReceivedPacketNumbers receivedPacketNumbers = new ReceivedPacketNumbers(); + receivedPacketNumbers.unreceived(5); + + assertEquals(6, receivedPacketNumbers.getSmallestOfRange(6, 0)); + assertEquals(5, receivedPacketNumbers.getSmallestOfGap(5, 0)); + } + + @Test + public void 何も受信していない() throws Exception { + ReceivedPacketNumbers receivedPacketNumbers = new ReceivedPacketNumbers(); + receivedPacketNumbers.unreceived(0); + receivedPacketNumbers.unreceived(1); + receivedPacketNumbers.unreceived(2); + receivedPacketNumbers.unreceived(3); + + assertEquals(0, receivedPacketNumbers.getSmallestOfGap(3, 0)); + } + + @Test + public void 全て受信している() throws Exception { + ReceivedPacketNumbers receivedPacketNumbers = new ReceivedPacketNumbers(); + receivedPacketNumbers.received(0); + receivedPacketNumbers.received(1); + receivedPacketNumbers.received(2); + receivedPacketNumbers.received(3); + assertEquals(0, receivedPacketNumbers.getSmallestOfRange(3, 0)); + } + + @Test + public void smallestValidで限定している() throws Exception { + ReceivedPacketNumbers receivedPacketNumbers = new ReceivedPacketNumbers(); + receivedPacketNumbers.received(0); + receivedPacketNumbers.received(1); + receivedPacketNumbers.received(2); + receivedPacketNumbers.received(3); + receivedPacketNumbers.unreceived(4); + receivedPacketNumbers.unreceived(5); + receivedPacketNumbers.unreceived(6); + + assertEquals(7, receivedPacketNumbers.getSmallestOfRange(10, 2)); + assertEquals(4, receivedPacketNumbers.getSmallestOfGap(6, 2)); + assertEquals(5, receivedPacketNumbers.getSmallestOfGap(6, 5)); + assertEquals(2, receivedPacketNumbers.getSmallestOfRange(3, 2)); + assertEquals(3, receivedPacketNumbers.getSmallestOfRange(3, 3)); + } + + @Test + public void largestOfGapとsmallestValidが同じ() throws Exception { + ReceivedPacketNumbers receivedPacketNumbers = new ReceivedPacketNumbers(); + receivedPacketNumbers.unreceived(0); + receivedPacketNumbers.unreceived(1); + receivedPacketNumbers.received(2); + receivedPacketNumbers.received(3); + + assertEquals(1, receivedPacketNumbers.getSmallestOfGap(1, 1)); + assertEquals(0, receivedPacketNumbers.getSmallestOfGap(0, 0)); + } + + @Test + public void largestOfRangeとsmallestValidが同じ() throws Exception { + ReceivedPacketNumbers receivedPacketNumbers = new ReceivedPacketNumbers(); + receivedPacketNumbers.unreceived(0); + receivedPacketNumbers.unreceived(1); + receivedPacketNumbers.received(2); + receivedPacketNumbers.received(3); + + assertEquals(3, receivedPacketNumbers.getSmallestOfRange(3, 3)); + assertEquals(2, receivedPacketNumbers.getSmallestOfRange(2, 2)); + } + +} \ No newline at end of file diff --git a/src/test/java/packetproxy/quic/service/framegenerator/CryptoFramesToMessagesTest.java b/src/test/java/packetproxy/quic/service/framegenerator/CryptoFramesToMessagesTest.java new file mode 100644 index 0000000..78450a2 --- /dev/null +++ b/src/test/java/packetproxy/quic/service/framegenerator/CryptoFramesToMessagesTest.java @@ -0,0 +1,141 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.framegenerator; + +import net.luminis.tls.handshake.ClientHello; +import net.luminis.tls.handshake.HandshakeMessage; +import org.apache.commons.codec.binary.Hex; +import org.apache.commons.lang3.ArrayUtils; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import packetproxy.quic.value.frame.CryptoFrame; + +import java.util.Optional; + +import static org.assertj.core.api.Assertions.assertThat; + +class CryptoFramesToMessagesTest { + + private CryptoFramesToMessages stream; + private byte[] clientHelloBytes; + private HandshakeMessage clientHello; + + @BeforeEach + public void before() throws Exception { + this.stream = new CryptoFramesToMessages(); + this.clientHelloBytes = Hex.decodeHex("010000ed0303ebf8fa56f12939b9584a3896472ec40bb863cfd3e86804fe3a47f06a2b69484c00000413011302010000c000000010000e00000b6578616d706c652e636f6dff01000100000a00080006001d0017001800100007000504616c706e000500050100000000003300260024001d00209370b2c9caa47fbabaf4559fedba753de171fa71f50f1ce15d43e994ec74d748002b0003020304000d0010000e0403050306030203080408050806002d00020101001c00024001003900320408ffffffffffffffff05048000ffff07048000ffff0801100104800075300901100f088394c8f03e51570806048000ffff".toCharArray()); + this.clientHello = CryptoFramesToMessages.convertToHandshakeMessage(clientHelloBytes); + } + + @Test + public void 複数のHandshakeMessageを処理できる() { + this.stream.write(new CryptoFrame(0, this.clientHelloBytes)); + this.stream.write(new CryptoFrame(this.clientHelloBytes.length, this.clientHelloBytes)); + Optional retMsg1 = this.stream.getHandshakeMessage(); + Optional retMsg2 = this.stream.getHandshakeMessage(); + assertThat(retMsg1.get()).isInstanceOf(ClientHello.class); + assertThat(retMsg2.get()).isInstanceOf(ClientHello.class); + } + + @Test + public void 一つのHandshakeMessageが分割された状態でも処理できる() { + byte[] array1 = ArrayUtils.subarray(this.clientHelloBytes, 0, 10); + byte[] array2 = ArrayUtils.subarray(this.clientHelloBytes, 10, 50); + byte[] array3 = ArrayUtils.subarray(this.clientHelloBytes, 50, this.clientHelloBytes.length); + + CryptoFrame cryptoFrame1 = new CryptoFrame(0, array1); + CryptoFrame cryptoFrame2 = new CryptoFrame(10, array2); + CryptoFrame cryptoFrame3 = new CryptoFrame(50, array3); + + this.stream.write(cryptoFrame1); + this.stream.write(cryptoFrame2); + this.stream.write(cryptoFrame3); + + Optional ret = stream.getHandshakeMessage(); + assertThat(ret.get()).isInstanceOf(ClientHello.class); + } + + @Test + public void 一つのHandshakeMessageが分割されてシャフルされた状態でも処理できる() { + byte[] array1 = ArrayUtils.subarray(this.clientHelloBytes, 0, 10); + byte[] array2 = ArrayUtils.subarray(this.clientHelloBytes, 10, 50); + byte[] array3 = ArrayUtils.subarray(this.clientHelloBytes, 50, this.clientHelloBytes.length); + + CryptoFrame cryptoFrame1 = new CryptoFrame(0, array1); + CryptoFrame cryptoFrame2 = new CryptoFrame(10, array2); + CryptoFrame cryptoFrame3 = new CryptoFrame(50, array3); + + this.stream.write(cryptoFrame3); + this.stream.write(cryptoFrame1); + this.stream.write(cryptoFrame2); + + Optional ret = stream.getHandshakeMessage(); + assertThat(ret.get()).isInstanceOf(ClientHello.class); + } + + @Test + public void 複数のHandshakeMessageが分割されてシャフルされた状態でも処理できる() { + byte[] array10 = ArrayUtils.subarray(this.clientHelloBytes, 0, 10); + byte[] array40 = ArrayUtils.subarray(this.clientHelloBytes, 10, 50); + byte[] arrayRemaining = ArrayUtils.subarray(this.clientHelloBytes, 50, this.clientHelloBytes.length); + + CryptoFrame cryptoFrame1 = new CryptoFrame(0, array10); + CryptoFrame cryptoFrame2 = new CryptoFrame(10, array40); + CryptoFrame cryptoFrame3 = new CryptoFrame(50, arrayRemaining); + CryptoFrame cryptoFrame4 = new CryptoFrame(this.clientHelloBytes.length, array10); + CryptoFrame cryptoFrame5 = new CryptoFrame(this.clientHelloBytes.length + 10, array40); + CryptoFrame cryptoFrame6 = new CryptoFrame(this.clientHelloBytes.length + 50, arrayRemaining); + + this.stream.write(cryptoFrame4); + this.stream.write(cryptoFrame1); + this.stream.write(cryptoFrame2); + this.stream.write(cryptoFrame5); + this.stream.write(cryptoFrame6); + this.stream.write(cryptoFrame3); + + Optional ret1 = stream.getHandshakeMessage(); + Optional ret2 = stream.getHandshakeMessage(); + assertThat(ret1.get()).isInstanceOf(ClientHello.class); + assertThat(ret2.get()).isInstanceOf(ClientHello.class); + } + + @Test + public void 一つのCryptoFrameに複数のHandshakeMessageが入った状態でも処理できる() { + byte[] array10 = ArrayUtils.subarray(this.clientHelloBytes, 0, 10); + byte[] array40 = ArrayUtils.subarray(this.clientHelloBytes, 10, 50); + byte[] arrayRemaining = ArrayUtils.subarray(this.clientHelloBytes, 50, this.clientHelloBytes.length); + + CryptoFrame cryptoFrame1 = new CryptoFrame(0, array10); + CryptoFrame cryptoFrame2 = new CryptoFrame(10, array40); + CryptoFrame cryptoFrame3 = new CryptoFrame(50, ArrayUtils.addAll(arrayRemaining, array10)); /* 次のMessageが混じった状態 */ + CryptoFrame cryptoFrame4 = new CryptoFrame(this.clientHelloBytes.length + 10, array40); + CryptoFrame cryptoFrame5 = new CryptoFrame(this.clientHelloBytes.length + 50, arrayRemaining); + + this.stream.write(cryptoFrame4); + this.stream.write(cryptoFrame1); + this.stream.write(cryptoFrame2); + this.stream.write(cryptoFrame5); + this.stream.write(cryptoFrame3); + + Optional ret1 = stream.getHandshakeMessage(); + Optional ret2 = stream.getHandshakeMessage(); + assertThat(ret1.get()).isInstanceOf(ClientHello.class); + assertThat(ret2.get()).isInstanceOf(ClientHello.class); + } + + +} \ No newline at end of file diff --git a/src/test/java/packetproxy/quic/service/pnspace/SentPacketsTest.java b/src/test/java/packetproxy/quic/service/pnspace/SentPacketsTest.java new file mode 100644 index 0000000..27b723f --- /dev/null +++ b/src/test/java/packetproxy/quic/service/pnspace/SentPacketsTest.java @@ -0,0 +1,64 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.pnspace; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import packetproxy.quic.value.SentPacket; +import packetproxy.quic.service.pnspace.helper.SentPackets; +import packetproxy.quic.value.frame.AckFrame; +import packetproxy.quic.value.frame.helper.AckRanges; +import packetproxy.quic.value.packet.helper.TestPacket; +import packetproxy.quic.value.PacketNumber; + +import java.util.Optional; + +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; + +class SentPacketsTest { + + private SentPackets sentPackets; + + @BeforeEach + void beforeEach() throws Exception { + this.sentPackets = new SentPackets(); + } + + @Test + void getLargestAckFrameが動作すること() throws Exception { + this.sentPackets.add(new SentPacket(TestPacket.of(PacketNumber.of(0), new AckFrame(0, 0, 0, 0, AckRanges.emptyAckRanges)))); + this.sentPackets.add(new SentPacket(TestPacket.of(PacketNumber.of(1)))); + this.sentPackets.add(new SentPacket(TestPacket.of(PacketNumber.of(2), new AckFrame(2, 0, 0, 0, AckRanges.emptyAckRanges)))); + this.sentPackets.add(new SentPacket(TestPacket.of(PacketNumber.of(3)))); + this.sentPackets.add(new SentPacket(TestPacket.of(PacketNumber.of(4)))); + this.sentPackets.add(new SentPacket(TestPacket.of(PacketNumber.of(5), new AckFrame(1, 0, 0, 0, AckRanges.emptyAckRanges)))); + this.sentPackets.add(new SentPacket(TestPacket.of(PacketNumber.of(6)))); + + Optional a = sentPackets.getLargestAckFrame(); + assertThat(a).hasValue(new AckFrame(2, 0, 0, 0, AckRanges.emptyAckRanges)); + } + + @Test + void getLargestAckFrameがEmptyになること() throws Exception { + this.sentPackets.add(new SentPacket(TestPacket.of(PacketNumber.of(1)))); + this.sentPackets.add(new SentPacket(TestPacket.of(PacketNumber.of(3)))); + this.sentPackets.add(new SentPacket(TestPacket.of(PacketNumber.of(4)))); + this.sentPackets.add(new SentPacket(TestPacket.of(PacketNumber.of(6)))); + + assertThat(sentPackets.getLargestAckFrame()).isEqualTo(Optional.empty()); + } +} \ No newline at end of file diff --git a/src/test/java/packetproxy/quic/service/transportparameter/TransportParametersTest.java b/src/test/java/packetproxy/quic/service/transportparameter/TransportParametersTest.java new file mode 100644 index 0000000..a4767b9 --- /dev/null +++ b/src/test/java/packetproxy/quic/service/transportparameter/TransportParametersTest.java @@ -0,0 +1,37 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.service.transportparameter; + +import org.apache.commons.codec.binary.Hex; +import org.junit.jupiter.api.Test; +import packetproxy.quic.utils.Constants; + +import static org.junit.jupiter.api.Assertions.assertEquals; + + +class TransportParametersTest { + + @Test + public void smoke() throws Exception { + byte[] test = Hex.decodeHex("0039005505048020000004048010000008024201010480007530030245a00902420106048001006307048000ffff0e01080b010a0f087c67f19599d5b680537b0480004fb0c0000000ff02de1a0243e88000715801036ab200".toCharArray()); + TransportParameters params = new TransportParameters(Constants.Role.CLIENT, test); + System.out.println(params); + assertEquals(2097152, params.getInitMaxStreamDataBidiLocal()); + assertEquals(1048576, params.getInitMaxData()); + } + +} \ No newline at end of file diff --git a/src/test/java/packetproxy/quic/value/ConnectionIdTest.java b/src/test/java/packetproxy/quic/value/ConnectionIdTest.java new file mode 100644 index 0000000..509c056 --- /dev/null +++ b/src/test/java/packetproxy/quic/value/ConnectionIdTest.java @@ -0,0 +1,49 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value; + +import org.apache.commons.codec.binary.Hex; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import packetproxy.quic.utils.Constants; + +import static org.junit.jupiter.api.Assertions.*; + +class ConnectionIdTest { + + @Test + public void ランダムなConnectionIdを生成できること() { + ConnectionId connId = ConnectionId.generateRandom(); + Assertions.assertEquals(Constants.CONNECTION_ID_SIZE, connId.getBytes().length); + } + + @Test + public void ByteArrayが同じならEqualになること() throws Exception { + byte[] connIdBytes = Hex.decodeHex("11223344".toCharArray()); + ConnectionId connId1 = ConnectionId.of(connIdBytes); + ConnectionId connId2= ConnectionId.of(connIdBytes); + assertEquals(connId1, connId2); + } + + @Test + public void 複数個のインスタンスがお互いにランダムになっていること() throws Exception { + ConnectionId connId1 = ConnectionId.generateRandom(); + ConnectionId connId2 = ConnectionId.generateRandom(); + assertNotEquals(connId1, connId2); + } + +} \ No newline at end of file diff --git a/src/test/java/packetproxy/quic/value/QuicPacketNumbersTest.java b/src/test/java/packetproxy/quic/value/QuicPacketNumbersTest.java new file mode 100644 index 0000000..f7c0338 --- /dev/null +++ b/src/test/java/packetproxy/quic/value/QuicPacketNumbersTest.java @@ -0,0 +1,36 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value; + +import org.junit.jupiter.api.Test; +import packetproxy.quic.utils.PacketNumbers; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class QuicPacketNumbersTest { + + @Test + void testLargest() throws Exception { + PacketNumbers pns = new PacketNumbers(); + pns.add(PacketNumber.of(100L)); + pns.add(PacketNumber.of(1L)); + pns.add(PacketNumber.of(33L)); + pns.add(PacketNumber.of(0x7fffffffffffffffL)); + + assertEquals(PacketNumber.of(0x7fffffffffffffffL), pns.largest()); + } +} \ No newline at end of file diff --git a/src/test/java/packetproxy/quic/value/TruncatedQuicPacketNumberTest.java b/src/test/java/packetproxy/quic/value/TruncatedQuicPacketNumberTest.java new file mode 100644 index 0000000..c88703d --- /dev/null +++ b/src/test/java/packetproxy/quic/value/TruncatedQuicPacketNumberTest.java @@ -0,0 +1,120 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value; + + +import org.apache.commons.codec.binary.Hex; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class TruncatedQuicPacketNumberTest { + + @Test + public void _0() throws Exception { + PacketNumber packetNumber = PacketNumber.of(0); + PacketNumber largestAckedPn = PacketNumber.Infinite; + + TruncatedPacketNumber truncatedPn = new TruncatedPacketNumber(packetNumber, largestAckedPn); + assertEquals(packetNumber, truncatedPn.getPacketNumber(largestAckedPn)); + } + + @Test + public void _1() throws Exception { + PacketNumber packetNumber = PacketNumber.of(1); + PacketNumber largestAckedPn = PacketNumber.of(0); + + TruncatedPacketNumber truncatedPn = new TruncatedPacketNumber(packetNumber, largestAckedPn); + assertEquals(packetNumber, truncatedPn.getPacketNumber(largestAckedPn)); + } + + @Test + public void _255() throws Exception { + PacketNumber packetNumber = PacketNumber.of(255); + PacketNumber largestAckedPn = PacketNumber.of(0); + + TruncatedPacketNumber truncatedPn = new TruncatedPacketNumber(packetNumber, largestAckedPn); + assertEquals(packetNumber, truncatedPn.getPacketNumber(largestAckedPn)); + } + + @Test + public void _256() throws Exception { + PacketNumber packetNumber = PacketNumber.of(256); + PacketNumber largestAckedPn = PacketNumber.of(0); + + TruncatedPacketNumber truncatedPn = new TruncatedPacketNumber(packetNumber, largestAckedPn); + assertEquals(packetNumber, truncatedPn.getPacketNumber(largestAckedPn)); + } + + @Test + public void _123456789() throws Exception { + PacketNumber packetNumber = PacketNumber.of(123456789); + PacketNumber largestAckedPn = PacketNumber.of(0); + + TruncatedPacketNumber truncatedPn = new TruncatedPacketNumber(packetNumber, largestAckedPn); + assertEquals(packetNumber, truncatedPn.getPacketNumber(largestAckedPn)); + } + + @Test + public void _aabbccdd() throws Exception { + PacketNumber packetNumber = PacketNumber.of(0xaabbccddL); + PacketNumber largestAckedPn = PacketNumber.of(0); + + TruncatedPacketNumber truncatedPn = new TruncatedPacketNumber(packetNumber, largestAckedPn); + assertEquals(packetNumber, truncatedPn.getPacketNumber(largestAckedPn)); + } + + @Test + public void _aabbccd0() throws Exception { + PacketNumber packetNumber = PacketNumber.of(0xaabbccddL); + PacketNumber largestAckedPn = PacketNumber.of(0xaabbccd0L); + + TruncatedPacketNumber truncatedPn = new TruncatedPacketNumber(packetNumber, largestAckedPn); + assertEquals(packetNumber, truncatedPn.getPacketNumber(largestAckedPn)); + } + + @Test + public void rfc1() throws Exception { + /* + * if an endpoint has received an acknowledgment for packet 0xabe8b3 and is sending a packet with a number of 0xac5c02, + * there are 29,519 (0x734f) outstanding packet numbers. In order to represent at least twice this range (59,038 packets, or 0xe69e), 16 bits are required. + */ + PacketNumber packetNumber = PacketNumber.of(0xac5c02); + PacketNumber largestAckedPn = PacketNumber.of(0xabe8b3); + byte[] truncatedPnBytes = Hex.decodeHex("5c02".toCharArray()); + + TruncatedPacketNumber truncatedPn = new TruncatedPacketNumber(packetNumber, largestAckedPn); + assertArrayEquals(truncatedPnBytes, truncatedPn.getBytes()); + } + + @Test + public void rfc2() throws Exception { + /* + * if the highest successfully authenticated packet had a packet number of 0xa82f30ea, * then a packet containing a 16-bit value of 0x9b32 will be decoded as 0xa82f9b32 + */ + byte[] truncatedPnBytes = Hex.decodeHex("9b32".toCharArray()); + PacketNumber packetNumber = PacketNumber.of(0xa82f9b32L); + PacketNumber largestAckedPn = PacketNumber.of(0xa82f30eaL); + + TruncatedPacketNumber truncatedPn1 = new TruncatedPacketNumber(truncatedPnBytes); + TruncatedPacketNumber truncatedPn2 = new TruncatedPacketNumber(packetNumber, largestAckedPn); + assertEquals(packetNumber, truncatedPn1.getPacketNumber(largestAckedPn)); + assertEquals(packetNumber, truncatedPn2.getPacketNumber(largestAckedPn)); + assertEquals(truncatedPn1, truncatedPn2); + } + +} \ No newline at end of file diff --git a/src/test/java/packetproxy/quic/value/VariableLengthIntegerTest.java b/src/test/java/packetproxy/quic/value/VariableLengthIntegerTest.java new file mode 100644 index 0000000..f89beda --- /dev/null +++ b/src/test/java/packetproxy/quic/value/VariableLengthIntegerTest.java @@ -0,0 +1,92 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value; + +import org.apache.commons.codec.binary.Hex; +import org.junit.jupiter.api.Test; + +import java.nio.ByteBuffer; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; + +/* https://tools.ietf.org/html/draft-ietf-quic-transport-19#section-16 */ +class VariableLengthIntegerTest { + + @Test + void smoke() throws Exception { + VariableLengthInteger t = VariableLengthInteger.parse(Hex.decodeHex("800061a8".toCharArray())); + assertEquals(25000, t.getValue()); + } + + @Test + void parseSingleByte() throws Exception { + // "and the single byte 25 decodes to 37" + byte[] testBytes = Hex.decodeHex("25".toCharArray()); + VariableLengthInteger var = VariableLengthInteger.parse(ByteBuffer.wrap(testBytes)); + + assertEquals(37, var.getValue()); + assertArrayEquals(testBytes, var.getBytes()); + } + + @Test + void parseTwoBytes() throws Exception { + // "the two byte sequence 7b bd decodes to 15293; " + byte[] testBytes = Hex.decodeHex("7bbd".toCharArray()); + VariableLengthInteger var = VariableLengthInteger.parse(ByteBuffer.wrap(testBytes)); + + assertEquals(15293, var.getValue()); + assertArrayEquals(testBytes, var.getBytes()); + } + + @Test + void parseTwoBytes2() throws Exception { + // "(as does the two byte sequence 40 25)" + byte[] testBytes = Hex.decodeHex("4025".toCharArray()); + VariableLengthInteger var = VariableLengthInteger.parse(ByteBuffer.wrap(testBytes)); + + assertEquals(37, var.getValue()); + } + + @Test + void parseFourBytes() throws Exception { + // "the four byte sequence 9d 7f 3e 7d decodes to 494878333;" + byte[] testBytes = Hex.decodeHex("9d7f3e7d".toCharArray()); + VariableLengthInteger var = VariableLengthInteger.parse(ByteBuffer.wrap(testBytes)); + + assertEquals(494878333, var.getValue()); + assertArrayEquals(testBytes, var.getBytes()); + } + + @Test + void parseEightBytes() throws Exception { + // "the eight byte sequence c2 19 7c 5e ff 14 e8 8c decodes to 151288809941952652;" + byte[] testBytes = Hex.decodeHex("c2197c5eff14e88c".toCharArray()); + VariableLengthInteger var = VariableLengthInteger.parse(ByteBuffer.wrap(testBytes)); + + assertEquals(151288809941952652L, var.getValue()); + assertArrayEquals(testBytes, var.getBytes()); + } + + @Test + void parseExampleBytes() throws Exception { + System.out.println(VariableLengthInteger.parse(Hex.decodeHex("80200000".toCharArray()))); /* 2MB */ + System.out.println(VariableLengthInteger.parse(Hex.decodeHex("80100000".toCharArray()))); /* 1MB */ + System.out.println(VariableLengthInteger.parse(Hex.decodeHex("4201".toCharArray()))); /* 513 */ + } + +} \ No newline at end of file diff --git a/src/test/java/packetproxy/quic/value/frame/AckEcnFrameTest.java b/src/test/java/packetproxy/quic/value/frame/AckEcnFrameTest.java new file mode 100644 index 0000000..ebf3be2 --- /dev/null +++ b/src/test/java/packetproxy/quic/value/frame/AckEcnFrameTest.java @@ -0,0 +1,43 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import org.apache.commons.codec.binary.Hex; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +class AckEcnFrameTest { + + @Test + public void smoke() throws Exception { + byte[] test = Hex.decodeHex("030a0001000105000102".toCharArray()); + AckEcnFrame ackEcnFrame = AckEcnFrame.parse(test); + assertThat(ackEcnFrame.getEtc0Count()).isEqualTo(0); + assertThat(ackEcnFrame.getEtc1Count()).isEqualTo(1); + assertThat(ackEcnFrame.getEcnCeCount()).isEqualTo(2); + } + + @Test + public void equalsが正常に動作すること() throws Exception { + byte[] test = Hex.decodeHex("030a0001000105000102".toCharArray()); + AckEcnFrame ackEcnFrame1 = AckEcnFrame.parse(test); + AckEcnFrame ackEcnFrame2 = AckEcnFrame.parse(test); + assertThat(ackEcnFrame1).isEqualTo(ackEcnFrame2); + } + +} \ No newline at end of file diff --git a/src/test/java/packetproxy/quic/value/frame/AckFrameTest.java b/src/test/java/packetproxy/quic/value/frame/AckFrameTest.java new file mode 100644 index 0000000..5c396f0 --- /dev/null +++ b/src/test/java/packetproxy/quic/value/frame/AckFrameTest.java @@ -0,0 +1,76 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import org.apache.commons.codec.binary.Hex; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; + +class AckFrameTest { + + @Test + public void シンプルなbyteArrayをparseできること() throws Exception { + byte[] test = Hex.decodeHex("0200030000".toCharArray()); + AckFrame ackFrame = AckFrame.parse(test); + assertEquals(0, ackFrame.getLargestAcknowledged()); + assertEquals(3, ackFrame.getAckDelay()); + assertEquals(0, ackFrame.getAckRangeCount()); + assertEquals(0, ackFrame.getFirstAckRange()); + Assertions.assertEquals(0, ackFrame.getAckRanges().size()); + } + + @Test + public void ackRangeがあるbyteArrayをparseできること() throws Exception { + byte[] test = Hex.decodeHex("020a0001000105".toCharArray()); + AckFrame ackFrame = AckFrame.parse(test); + assertEquals(10, ackFrame.getLargestAcknowledged()); + assertEquals(0, ackFrame.getFirstAckRange()); + assertEquals(1, ackFrame.getAckRangeCount()); + Assertions.assertEquals(1, ackFrame.getAckRanges().get(0).getGap()); + Assertions.assertEquals(5, ackFrame.getAckRanges().get(0).getAckRangeLength()); + } + + @Test + public void parseしてgetBytesすると元に戻ること() throws Exception { + byte[] test = Hex.decodeHex("0200030000".toCharArray()); + AckFrame ackFrame = AckFrame.parse(test); + byte[] test2 = ackFrame.getBytes(); + assertArrayEquals(test, test2); + } + + @Test + public void rangeありのbyteをparseしてgetBytesすると元に戻ること() throws Exception { + byte[] test = Hex.decodeHex("020a0001000105".toCharArray()); + AckFrame ackFrame = AckFrame.parse(test); + byte[] test2 = ackFrame.getBytes(); + assertArrayEquals(test, test2); + } + + @Test + public void ackRangeがあるbyteArray2つが等しくなること() throws Exception { + byte[] test1 = Hex.decodeHex("020a0001000105".toCharArray()); + byte[] test2 = Hex.decodeHex("020a0001000105".toCharArray()); + AckFrame ackFrame1 = AckFrame.parse(test1); + AckFrame ackFrame2 = AckFrame.parse(test2); + assertThat(ackFrame1).isEqualTo(ackFrame2); + } + +} \ No newline at end of file diff --git a/src/test/java/packetproxy/quic/value/frame/CryptoFrameTest.java b/src/test/java/packetproxy/quic/value/frame/CryptoFrameTest.java new file mode 100644 index 0000000..4c81634 --- /dev/null +++ b/src/test/java/packetproxy/quic/value/frame/CryptoFrameTest.java @@ -0,0 +1,44 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import org.apache.commons.codec.binary.Hex; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; + +class CryptoFrameTest { + + @Test + public void parse後getBytesで元に戻ること() throws Exception { + byte[] testData = Hex.decodeHex("060040f1010000ed0303ebf8fa56f12939b9584a3896472ec40bb863cfd3e86804fe3a47f06a2b69484c00000413011302010000c000000010000e00000b6578616d706c652e636f6dff01000100000a00080006001d0017001800100007000504616c706e000500050100000000003300260024001d00209370b2c9caa47fbabaf4559fedba753de171fa71f50f1ce15d43e994ec74d748002b0003020304000d0010000e0403050306030203080408050806002d00020101001c00024001003900320408ffffffffffffffff05048000ffff07048000ffff0801100104800075300901100f088394c8f03e51570806048000ffff".toCharArray()); + CryptoFrame cryptoFrame = CryptoFrame.parse(testData); + System.out.println(cryptoFrame); + assertArrayEquals(testData, cryptoFrame.getBytes()); + } + + @Test + public void equalsが正常に動作すること() throws Exception { + byte[] data1 = Hex.decodeHex("060040f1010000ed0303ebf8fa56f12939b9584a3896472ec40bb863cfd3e86804fe3a47f06a2b69484c00000413011302010000c000000010000e00000b6578616d706c652e636f6dff01000100000a00080006001d0017001800100007000504616c706e000500050100000000003300260024001d00209370b2c9caa47fbabaf4559fedba753de171fa71f50f1ce15d43e994ec74d748002b0003020304000d0010000e0403050306030203080408050806002d00020101001c00024001003900320408ffffffffffffffff05048000ffff07048000ffff0801100104800075300901100f088394c8f03e51570806048000ffff".toCharArray()); + byte[] data2 = Hex.decodeHex("060040f1010000ed0303ebf8fa56f12939b9584a3896472ec40bb863cfd3e86804fe3a47f06a2b69484c00000413011302010000c000000010000e00000b6578616d706c652e636f6dff01000100000a00080006001d0017001800100007000504616c706e000500050100000000003300260024001d00209370b2c9caa47fbabaf4559fedba753de171fa71f50f1ce15d43e994ec74d748002b0003020304000d0010000e0403050306030203080408050806002d00020101001c00024001003900320408ffffffffffffffff05048000ffff07048000ffff0801100104800075300901100f088394c8f03e51570806048000ffff".toCharArray()); + CryptoFrame cryptoFrame1 = CryptoFrame.parse(data1); + CryptoFrame cryptoFrame2 = CryptoFrame.parse(data2); + assertThat(cryptoFrame1).isEqualTo(cryptoFrame2); + } + +} \ No newline at end of file diff --git a/src/test/java/packetproxy/quic/value/frame/FramesTest.java b/src/test/java/packetproxy/quic/value/frame/FramesTest.java new file mode 100644 index 0000000..65f9c5d --- /dev/null +++ b/src/test/java/packetproxy/quic/value/frame/FramesTest.java @@ -0,0 +1,52 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import org.apache.commons.codec.binary.Hex; +import org.junit.jupiter.api.Test; +import packetproxy.quic.service.frame.Frames; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class FramesTest { + + @Test + public void clientHelloSample() throws Exception { + byte[] testData = Hex.decodeHex("060040f1010000ed0303ebf8fa56f12939b9584a3896472ec40bb863cfd3e86804fe3a47f06a2b69484c00000413011302010000c000000010000e00000b6578616d706c652e636f6dff01000100000a00080006001d0017001800100007000504616c706e000500050100000000003300260024001d00209370b2c9caa47fbabaf4559fedba753de171fa71f50f1ce15d43e994ec74d748002b0003020304000d0010000e0403050306030203080408050806002d00020101001c00024001003900320408ffffffffffffffff05048000ffff07048000ffff0801100104800075300901100f088394c8f03e51570806048000ffff".toCharArray()); + List frames = Frames.parse(testData).getFrames(); + assertEquals(1, frames.size()); + assertTrue(frames.get(0) instanceof CryptoFrame); + } + + @Test + public void serverHelloSample() throws Exception { + byte[] testData = Hex.decodeHex("02000300000600407b020000770303afea1ef3ac12e018d10201ef251dab9ca22fb662faa45b5b151126b9a7550a7400130100004f002b000203040033004500170041047254be2b315b10396eeea8b68d454772bf5817e99cb88f5f4aaec6fd12beca033448965c0fd649cc59e6c90698a4f50d388a5c3722fba5770dfbcdbb5063210d0000000000000000".toCharArray()); + List frames = Frames.parse(testData).getFrames(); + assertEquals(3, frames.size()); + assertTrue(frames.get(0) instanceof AckFrame); + assertTrue(frames.get(1) instanceof CryptoFrame); + assertTrue(frames.get(2) instanceof PaddingFrame); + for (Frame frame : frames) { + System.out.println(frame.toString()); + } + } + + +} \ No newline at end of file diff --git a/src/test/java/packetproxy/quic/value/frame/NewConnectionIdFrameTest.java b/src/test/java/packetproxy/quic/value/frame/NewConnectionIdFrameTest.java new file mode 100644 index 0000000..fe38293 --- /dev/null +++ b/src/test/java/packetproxy/quic/value/frame/NewConnectionIdFrameTest.java @@ -0,0 +1,38 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.frame; + +import org.apache.commons.codec.binary.Hex; +import org.junit.jupiter.api.Test; +import packetproxy.quic.value.ConnectionId; +import packetproxy.quic.value.Token; + +import static org.assertj.core.api.Assertions.assertThat; + +class NewConnectionIdFrameTest { + + @Test + public void smoke() throws Exception { + NewConnectionIdFrame frame = new NewConnectionIdFrame(1, 0, ConnectionId.generateRandom(), Token.of(Hex.decodeHex("11223344556677889900112233445566".toCharArray()))); + byte[] data = frame.getBytes(); + + NewConnectionIdFrame frame2 = NewConnectionIdFrame.parse(data); + System.out.println(frame2); + assertThat(frame).isEqualTo(frame2); + } + +} \ No newline at end of file diff --git a/src/test/java/packetproxy/quic/value/packet/InitialPacketTest.java b/src/test/java/packetproxy/quic/value/packet/InitialPacketTest.java new file mode 100644 index 0000000..cdefe7c --- /dev/null +++ b/src/test/java/packetproxy/quic/value/packet/InitialPacketTest.java @@ -0,0 +1,148 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.packet; + +import org.apache.commons.codec.binary.Hex; +import org.junit.jupiter.api.Test; +import packetproxy.quic.utils.Constants.Role; +import packetproxy.quic.value.key.level.InitialKey; +import packetproxy.quic.value.packet.longheader.LongHeaderPacket; +import packetproxy.quic.value.packet.longheader.pnspace.InitialPacket; +import packetproxy.quic.value.PacketNumber; + +import java.nio.ByteBuffer; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertTrue; + + +class InitialPacketTest { + + @Test + void rfc9001のサンプルをparseできること() throws Exception { + // https://www.rfc-editor.org/rfc/rfc9001.html#name-client-initial + // https://www.rfc-editor.org/rfc/rfc9001.html#name-server-initial + byte[] clientReq = Hex.decodeHex("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".toCharArray()); + byte[] serverRes = Hex.decodeHex("cf000000010008f067a5502a4262b5004075c0d95a482cd0991cd25b0aac406a5816b6394100f37a1c69797554780bb38cc5a99f5ede4cf73c3ec2493a1839b3dbcba3f6ea46c5b7684df3548e7ddeb9c3bf9c73cc3f3bded74b562bfb19fb84022f8ef4cdd93795d77d06edbb7aaf2f58891850abbdca3d20398c276456cbc42158407dd074ee".toCharArray()); + + ByteBuffer clientReqBuffer = ByteBuffer.wrap(clientReq); + InitialKey clientInitialKey = InitialKey.of(Role.CLIENT, LongHeaderPacket.getDestConnId(clientReqBuffer)); + InitialKey serverInitialKey = InitialKey.of(Role.SERVER, LongHeaderPacket.getDestConnId(clientReqBuffer)); + + InitialPacket ipCli = new InitialPacket(ByteBuffer.wrap(clientReq), clientInitialKey, PacketNumber.Infinite); + System.out.println(ipCli); + InitialPacket ipServ = new InitialPacket(ByteBuffer.wrap(serverRes), serverInitialKey, PacketNumber.Infinite); + + assertTrue(ipCli.getPayload().length > 0); + assertTrue(ipServ.getPayload().length > 0); + } + + @Test + void 自分のサンプルをparseできること() throws Exception { + byte[] clientReq = Hex.decodeHex("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".toCharArray()); + byte[] serverRes = Hex.decodeHex("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".toCharArray()); + + ByteBuffer clientReqBuffer = ByteBuffer.wrap(clientReq); + InitialKey clientInitialKey = InitialKey.of(Role.CLIENT, LongHeaderPacket.getDestConnId(clientReqBuffer)); + InitialKey serverInitialKey = InitialKey.of(Role.SERVER, LongHeaderPacket.getDestConnId(clientReqBuffer)); + + InitialPacket ipCli = new InitialPacket(ByteBuffer.wrap(clientReq), clientInitialKey, PacketNumber.Infinite); + InitialPacket ipServ = new InitialPacket(ByteBuffer.wrap(serverRes), serverInitialKey, PacketNumber.Infinite); + + System.out.println(ipCli); + System.out.println(ipServ); + + assertTrue(ipCli.getPayload().length > 0); + assertTrue(ipServ.getPayload().length > 0); + } + + @Test + void 自分のサンプルをparseできること2() throws Exception { + byte[] clientReq = Hex.decodeHex("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".toCharArray()); + + ByteBuffer clientReqBuffer = ByteBuffer.wrap(clientReq); + InitialKey clientInitialKey = InitialKey.of(Role.CLIENT, LongHeaderPacket.getDestConnId(clientReqBuffer)); + + InitialPacket ipCli = new InitialPacket(ByteBuffer.wrap(clientReq), clientInitialKey, PacketNumber.Infinite); + System.out.println(ipCli); + assertTrue(ipCli.getPayload().length > 0); + } + + @Test + void rfc9001のサンプルをparse後getBytesできること() throws Exception { + // https://www.rfc-editor.org/rfc/rfc9001.html#name-client-initial + byte[] clientReq = Hex.decodeHex("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".toCharArray()); + byte[] serverRes = Hex.decodeHex("cf000000010008f067a5502a4262b5004075c0d95a482cd0991cd25b0aac406a5816b6394100f37a1c69797554780bb38cc5a99f5ede4cf73c3ec2493a1839b3dbcba3f6ea46c5b7684df3548e7ddeb9c3bf9c73cc3f3bded74b562bfb19fb84022f8ef4cdd93795d77d06edbb7aaf2f58891850abbdca3d20398c276456cbc42158407dd074ee".toCharArray()); + + ByteBuffer clientReqBuffer = ByteBuffer.wrap(clientReq); + InitialKey clientInitialKey = InitialKey.of(Role.CLIENT, LongHeaderPacket.getDestConnId(clientReqBuffer)); + InitialKey serverInitialKey = InitialKey.of(Role.SERVER, LongHeaderPacket.getDestConnId(clientReqBuffer)); + + InitialPacket ipCli = new InitialPacket(ByteBuffer.wrap(clientReq), clientInitialKey, PacketNumber.Infinite); + InitialPacket ipServ = new InitialPacket(ByteBuffer.wrap(serverRes), serverInitialKey, PacketNumber.Infinite); + + byte[] ipCliBytes = ipCli.getBytes(clientInitialKey, PacketNumber.Infinite); + byte[] ipServBytes = ipServ.getBytes(serverInitialKey, PacketNumber.Infinite); + assertTrue(ipCliBytes.length > 0); + assertTrue(serverRes.length > 0); + } + + @Test + void equalsが正常に動作すること() throws Exception { + // https://www.rfc-editor.org/rfc/rfc9001.html#name-client-initial + byte[] clientReq = Hex.decodeHex("c000000001088394c8f03e5157080000449e7b9aec34d1b1c98dd7689fb8ec11d242b123dc9bd8bab936b47d92ec356c0bab7df5976d27cd449f63300099f3991c260ec4c60d17b31f8429157bb35a1282a643a8d2262cad67500cadb8e7378c8eb7539ec4d4905fed1bee1fc8aafba17c750e2c7ace01e6005f80fcb7df621230c83711b39343fa028cea7f7fb5ff89eac2308249a02252155e2347b63d58c5457afd84d05dfffdb20392844ae812154682e9cf012f9021a6f0be17ddd0c2084dce25ff9b06cde535d0f920a2db1bf362c23e596d11a4f5a6cf3948838a3aec4e15daf8500a6ef69ec4e3feb6b1d98e610ac8b7ec3faf6ad760b7bad1db4ba3485e8a94dc250ae3fdb41ed15fb6a8e5eba0fc3dd60bc8e30c5c4287e53805db059ae0648db2f64264ed5e39be2e20d82df566da8dd5998ccabdae053060ae6c7b4378e846d29f37ed7b4ea9ec5d82e7961b7f25a9323851f681d582363aa5f89937f5a67258bf63ad6f1a0b1d96dbd4faddfcefc5266ba6611722395c906556be52afe3f565636ad1b17d508b73d8743eeb524be22b3dcbc2c7468d54119c7468449a13d8e3b95811a198f3491de3e7fe942b330407abf82a4ed7c1b311663ac69890f4157015853d91e923037c227a33cdd5ec281ca3f79c44546b9d90ca00f064c99e3dd97911d39fe9c5d0b23a229a234cb36186c4819e8b9c5927726632291d6a418211cc2962e20fe47feb3edf330f2c603a9d48c0fcb5699dbfe5896425c5bac4aee82e57a85aaf4e2513e4f05796b07ba2ee47d80506f8d2c25e50fd14de71e6c418559302f939b0e1abd576f279c4b2e0feb85c1f28ff18f58891ffef132eef2fa09346aee33c28eb130ff28f5b766953334113211996d20011a198e3fc433f9f2541010ae17c1bf202580f6047472fb36857fe843b19f5984009ddc324044e847a4f4a0ab34f719595de37252d6235365e9b84392b061085349d73203a4a13e96f5432ec0fd4a1ee65accdd5e3904df54c1da510b0ff20dcc0c77fcb2c0e0eb605cb0504db87632cf3d8b4dae6e705769d1de354270123cb11450efc60ac47683d7b8d0f811365565fd98c4c8eb936bcab8d069fc33bd801b03adea2e1fbc5aa463d08ca19896d2bf59a071b851e6c239052172f296bfb5e72404790a2181014f3b94a4e97d117b438130368cc39dbb2d198065ae3986547926cd2162f40a29f0c3c8745c0f50fba3852e566d44575c29d39a03f0cda721984b6f440591f355e12d439ff150aab7613499dbd49adabc8676eef023b15b65bfc5ca06948109f23f350db82123535eb8a7433bdabcb909271a6ecbcb58b936a88cd4e8f2e6ff5800175f113253d8fa9ca8885c2f552e657dc603f252e1a8e308f76f0be79e2fb8f5d5fbbe2e30ecadd220723c8c0aea8078cdfcb3868263ff8f0940054da48781893a7e49ad5aff4af300cd804a6b6279ab3ff3afb64491c85194aab760d58a606654f9f4400e8b38591356fbf6425aca26dc85244259ff2b19c41b9f96f3ca9ec1dde434da7d2d392b905ddf3d1f9af93d1af5950bd493f5aa731b4056df31bd267b6b90a079831aaf579be0a39013137aac6d404f518cfd46840647e78bfe706ca4cf5e9c5453e9f7cfd2b8b4c8d169a44e55c88d4a9a7f9474241e221af44860018ab0856972e194cd934".toCharArray()); + + ByteBuffer clientReqBuffer = ByteBuffer.wrap(clientReq); + InitialKey clientInitialKey = InitialKey.of(Role.CLIENT, LongHeaderPacket.getDestConnId(clientReqBuffer)); + + InitialPacket ipCli1 = new InitialPacket(ByteBuffer.wrap(clientReq), clientInitialKey, PacketNumber.Infinite); + InitialPacket ipCli2 = new InitialPacket(ByteBuffer.wrap(clientReq), clientInitialKey, PacketNumber.Infinite); + + assertThat(ipCli1).isEqualTo(ipCli2); + } + + @Test + void equalsが正常に動作すること2() throws Exception { + byte[] req1 = Hex.decodeHex("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".toCharArray()); + byte[] req2 = Hex.decodeHex("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".toCharArray()); + + ByteBuffer clientReqBuffer = ByteBuffer.wrap(req1); + InitialKey clientInitialKey = InitialKey.of(Role.CLIENT, LongHeaderPacket.getDestConnId(clientReqBuffer)); + + InitialPacket ipCli1 = new InitialPacket(ByteBuffer.wrap(req1), clientInitialKey, PacketNumber.Infinite); + InitialPacket ipCli2 = new InitialPacket(ByteBuffer.wrap(req2), clientInitialKey, PacketNumber.Infinite); + assertThat(ipCli1).isEqualTo(ipCli2); + } + + @Test + void parseとgetBytesを複数回繰り返せること() throws Exception { + byte[] req1 = Hex.decodeHex("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".toCharArray()); + + ByteBuffer clientReqBuffer = ByteBuffer.wrap(req1); + InitialKey clientInitialKey = InitialKey.of(Role.CLIENT, LongHeaderPacket.getDestConnId(clientReqBuffer)); + + InitialPacket ipCli1 = new InitialPacket(ByteBuffer.wrap(req1), clientInitialKey, PacketNumber.Infinite); + byte[] req2 = ipCli1.getBytes(clientInitialKey, PacketNumber.Infinite); + InitialPacket ipCli2 = new InitialPacket(ByteBuffer.wrap(req2), clientInitialKey, PacketNumber.Infinite); + byte[] req3 = ipCli2.getBytes(clientInitialKey, PacketNumber.Infinite); + InitialPacket ipCli3 = new InitialPacket(ByteBuffer.wrap(req3), clientInitialKey, PacketNumber.Infinite); + byte[] req4 = ipCli3.getBytes(clientInitialKey, PacketNumber.Infinite); + assertThat(ipCli2).isEqualTo(ipCli3); + } + + +} \ No newline at end of file diff --git a/src/test/java/packetproxy/quic/value/packet/helper/TestPacket.java b/src/test/java/packetproxy/quic/value/packet/helper/TestPacket.java new file mode 100644 index 0000000..7b26776 --- /dev/null +++ b/src/test/java/packetproxy/quic/value/packet/helper/TestPacket.java @@ -0,0 +1,82 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.packet.helper; + +import lombok.EqualsAndHashCode; +import lombok.ToString; +import lombok.Value; +import packetproxy.quic.utils.Constants.PnSpaceType; +import packetproxy.quic.value.frame.AckFrame; +import packetproxy.quic.service.frame.Frames; +import packetproxy.quic.service.frame.FramesBuilder; +import packetproxy.quic.value.PacketNumber; +import packetproxy.quic.value.packet.PnSpacePacket; +import packetproxy.quic.value.packet.QuicPacket; + +import java.util.Optional; + +import static packetproxy.quic.utils.Constants.PnSpaceType.PnSpaceInitial; + +@ToString(callSuper = true) +@EqualsAndHashCode(callSuper = true) +@Value +public class TestPacket extends QuicPacket implements PnSpacePacket { + + static public final byte TYPE = 0x0; + + static public boolean is(byte type) { + return (type & (byte)0xf0) == TYPE; + } + + static public TestPacket of(PacketNumber packetNumber, AckFrame ackFrame) { + return new TestPacket(TYPE, packetNumber, new FramesBuilder().add(ackFrame).build()); + } + + static public TestPacket of(PacketNumber packetNumber) { + return new TestPacket(TYPE, packetNumber, Frames.empty); + } + + PacketNumber packetNumber; + Frames frames; + + public TestPacket(byte type, PacketNumber packetNumber, Frames frames) { + super(type); + this.packetNumber = packetNumber; + this.frames = frames; + } + + @Override + public boolean isAckEliciting() { + return frames.isAckEliciting(); + } + + @Override + public boolean hasAckFrame() { + return frames.hasAckFrame(); + } + + @Override + public Optional getAckFrame() { + return frames.getAckFrame(); + } + + @Override + public PnSpaceType getPnSpaceType() { + return PnSpaceInitial; + } + +} diff --git a/src/test/java/packetproxy/quic/value/packet/shortheader/ShortHeaderPacketTest.java b/src/test/java/packetproxy/quic/value/packet/shortheader/ShortHeaderPacketTest.java new file mode 100644 index 0000000..0539528 --- /dev/null +++ b/src/test/java/packetproxy/quic/value/packet/shortheader/ShortHeaderPacketTest.java @@ -0,0 +1,40 @@ +/* + * Copyright 2022 DeNA Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package packetproxy.quic.value.packet.shortheader; + +import org.apache.commons.codec.binary.Hex; +import org.junit.jupiter.api.Test; +import packetproxy.quic.value.PacketNumber; +import packetproxy.quic.value.key.Key; + +import java.nio.ByteBuffer; + +import static org.assertj.core.api.Assertions.assertThat; + +class ShortHeaderPacketTest { + + @Test + public void dataをインスタンス化した後getBytesで元に戻ること() throws Exception { + byte[] data = Hex.decodeHex("5d7be5e8ca341134a2a0de5cced82ebb3f369cc7035c0b52465da032887b7a0c".toCharArray()); + byte[] secret = Hex.decodeHex("24ba37689b6e1e5ed9e1fbbf563718baeb2f11e4d1da18a04218761b386ab269".toCharArray()); + Key key = Key.of(secret); + ShortHeaderPacket packet = new ShortHeaderPacket(ByteBuffer.wrap(data), key, PacketNumber.Infinite); + byte[] restoredData = packet.getBytes(key, PacketNumber.Infinite); + assertThat(data).isEqualTo(restoredData); + } + +} \ No newline at end of file diff --git a/src/test/java/packetproxy/quic/value/transportparameter/bool/DisableActiveMigrationParameterTest.java b/src/test/java/packetproxy/quic/value/transportparameter/bool/DisableActiveMigrationParameterTest.java new file mode 100644 index 0000000..87cbfe3 --- /dev/null +++ b/src/test/java/packetproxy/quic/value/transportparameter/bool/DisableActiveMigrationParameterTest.java @@ -0,0 +1,14 @@ +package packetproxy.quic.value.transportparameter.bool; + +import org.apache.commons.codec.binary.Hex; +import org.junit.jupiter.api.Test; + +class DisableActiveMigrationParameterTest { + + @Test + public void smoke() { + DisableActiveMigrationParameter param = new DisableActiveMigrationParameter(); + System.out.println(Hex.encodeHexString(param.getBytes())); + } + +} \ No newline at end of file