mediasoup 3.20.4 → 3.20.6

package/worker/include/RTC/SCTP/association/StateCookie.hpp

@@ -6,7 +6,6 @@
 #include "RTC/SCTP/public/SctpTypes.hpp"
 #include "RTC/Serializable.hpp"
 #include "Utils.hpp"
-#include <string_view>
 
 namespace RTC
 {
@@ -58,6 +57,28 @@ namespace RTC
 		 *   Interleaving (I-DATA).
 		 * - Flag C (reconfig): Stream Reconfiguration.
 		 * - Flag D (zeroChecksum): Zero Checksum.
+		 *
+		 * When State Cookie authentication is enabled (see
+		 * `SctpOptions::requireAuthenticatedCookie`), two extra fields are appended
+		 * after the Negotiated Capabilities so the receiver can verify that the
+		 * cookie was generated by itself and is not stale:
+		 *
+		 *  0                   1                   2                   3
+		 *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+		 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+		 * |                       Creation Timestamp                      |
+		 * |                                                               |
+		 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+		 * \                                                               \
+		 * /            MAC (HMAC-SHA1 over all preceding bytes)           /
+		 * \                                                               \
+		 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+		 *
+		 * The MAC is keyed with a per-association secret that never leaves the
+		 * worker, making the cookie unforgeable. The Creation Timestamp (in ms) is
+		 * used to detect stale cookies.
+		 *
+		 * @see RFC 9260 sections 5.1.3 and 5.1.4.
 		 */
 		class StateCookie : public Serializable
 		{
@@ -84,7 +105,8 @@ namespace RTC
 			};
 
 		public:
-			// Fixed total length of our generated State Cookies.
+			// Fixed length of our generated State Cookies when authentication is
+			// disabled.
 			static constexpr size_t StateCookieLength{ 44 };
 			// Offset in the State Cookie where the Negotiated Capabilitied are
 			// located.
@@ -95,13 +117,27 @@ namespace RTC
 			static constexpr size_t Magic1Length{ 8 };
 			// Magic value used within the Negotiated Capabilities block.
 			static constexpr uint16_t Magic2{ 0xAD81 };
+			// Offset of the creation timestamp present in authenticated State
+			// Cookies.
+			static constexpr size_t TimestampOffset{ StateCookie::StateCookieLength };
+			// Length of the creation timestamp field (a uint64_t with the time in
+			// milliseconds).
+			static constexpr size_t TimestampLength{ 8 };
+			// Offset of the MAC present in authenticated State Cookies.
+			static constexpr size_t MacOffset{ StateCookie::TimestampOffset + StateCookie::TimestampLength };
+			// Length of the MAC. We use HMAC-SHA1 so it's 20 bytes.
+			static constexpr size_t MacLength{ 20 };
+			// Fixed length of our generated State Cookies when authentication is
+			// enabled.
+			static constexpr size_t AuthenticatedStateCookieLength{ StateCookie::MacOffset +
+				                                                      StateCookie::MacLength };
+			// State Cookie lifespan (Valid.Cookie.Life) in milliseconds. Used to
+			// reject stale authenticated cookies.
+			//
+			// @see RFC 9260 section 16.
+			static constexpr uint64_t ValidCookieLifeMs{ 60000 };
 
 		public:
-			/**
-			 * Whether the given buffer is a StateCookie generated by mediasoup.
-			 */
-			static bool IsMediasoupStateCookie(const uint8_t* buffer, size_t bufferLength);
-
 			/**
 			 * Parse a StateCookie supposely generated by mediasoup.
 			 *
@@ -114,8 +150,11 @@ namespace RTC
 			 * Create a StateCookie.
 			 *
 			 * @remarks
-			 * `bufferLength` could be greater than the real length of the State
-			 * cookie.
+			 * - `bufferLength` could be greater than the real length of the State
+			 *   cookie.
+			 * - If `macKey` is not nullptr, an authenticated cookie (with creation
+			 *   timestamp and MAC) is generated. Otherwise a plain cookie is
+			 *   generated and `creationTimestampMs`/`macKey` are ignored.
 			 */
 			static StateCookie* Factory(
 			  uint8_t* buffer,
@@ -126,10 +165,18 @@ namespace RTC
 			  uint32_t remoteInitialTsn,
 			  uint32_t remoteAdvertisedReceiverWindowCredit,
 			  uint64_t tieTag,
-			  const NegotiatedCapabilities& negotiatedCapabilities);
+			  const NegotiatedCapabilities& negotiatedCapabilities,
+			  uint64_t creationTimestampMs = 0,
+			  const uint8_t* macKey        = nullptr,
+			  size_t macKeyLength          = 0);
 
 			/**
 			 * Serialize a StateCookie (based on given arguments) in the given buffer.
+			 *
+			 * @remarks
+			 * - If `macKey` is not nullptr, an authenticated cookie (with creation
+			 *   timestamp and MAC) is generated. Otherwise a plain cookie is
+			 *   generated and `creationTimestampMs`/`macKey` are ignored.
 			 */
 			static void Write(
 			  uint8_t* buffer,
@@ -140,7 +187,33 @@ namespace RTC
 			  uint32_t remoteInitialTsn,
 			  uint32_t remoteAdvertisedReceiverWindowCredit,
 			  uint64_t tieTag,
-			  const NegotiatedCapabilities& negotiatedCapabilities);
+			  const NegotiatedCapabilities& negotiatedCapabilities,
+			  uint64_t creationTimestampMs = 0,
+			  const uint8_t* macKey        = nullptr,
+			  size_t macKeyLength          = 0);
+
+			/**
+			 * Whether the given buffer is a StateCookie generated by mediasoup.
+			 *
+			 * @remarks
+			 * - This only checks magic values and length. It does NOT verify the
+			 *   MAC of authenticated cookies (which requires the per-association
+			 *   secret). Use `VerifyMac()` for that.
+			 */
+			static bool IsMediasoupStateCookie(const uint8_t* buffer, size_t bufferLength);
+
+			/**
+			 * Verify the MAC of an authenticated StateCookie generated by mediasoup.
+			 *
+			 * @remarks
+			 * - Returns false if the buffer is not an authenticated cookie (i.e. its
+			 *   length is not `AuthenticatedStateCookieLength`) or if the MAC doesn't
+			 *   match the one computed with the given secret key.
+			 *
+			 * @see RFC 9260 section 5.1.4.
+			 */
+			static bool VerifyMac(
+			  const uint8_t* buffer, size_t bufferLength, const uint8_t* macKey, size_t macKeyLength);
 
 			/**
 			 * Determine the SCTP implementation of the generator of State Cookie
@@ -218,6 +291,26 @@ namespace RTC
 			 */
 			NegotiatedCapabilities GetNegotiatedCapabilities() const;
 
+			/**
+			 * Whether this is an authenticated StateCookie (i.e. it carries a
+			 * creation timestamp and a MAC).
+			 */
+			bool IsAuthenticated() const
+			{
+				return GetLength() == StateCookie::AuthenticatedStateCookieLength;
+			}
+
+			/**
+			 * The time (in milliseconds) at which this StateCookie was created.
+			 *
+			 * @remarks
+			 * - Only meaningful in authenticated cookies (see `IsAuthenticated()`).
+			 */
+			uint64_t GetCreationTimestampMs() const
+			{
+				return Utils::Byte::Get8Bytes(GetBuffer(), StateCookie::TimestampOffset);
+			}
+
 		private:
 			NegotiatedCapabilitiesField* GetNegotiatedCapabilitiesField() const
 			{

package/worker/include/RTC/SCTP/packet/parameters/StateCookieParameter.hpp

@@ -104,7 +104,10 @@ namespace RTC
 			  uint32_t remoteInitialTsn,
 			  uint32_t remoteAdvertisedReceiverWindowCredit,
 			  uint64_t tieTag,
-			  const NegotiatedCapabilities& negotiatedCapabilities);
+			  const NegotiatedCapabilities& negotiatedCapabilities,
+			  uint64_t creationTimestampMs = 0,
+			  const uint8_t* macKey        = nullptr,
+			  size_t macKeyLength          = 0);
 
 		protected:
 			StateCookieParameter* SoftClone(const uint8_t* buffer) const final;

package/worker/include/RTC/SCTP/public/SctpOptions.hpp

@@ -264,6 +264,19 @@ namespace RTC
 				ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod::NONE
 			};
 
+			/**
+			 * Whether received State Cookies must be authenticated with a MAC keyed
+			 * by a per-association secret, and checked for staleness.
+			 *
+			 * This MUST be enabled in transports whose SCTP traffic is not protected
+			 * by DTLS to comply with RFC 9260 section 5.1.3 and prevent State Cookie
+			 * forgery (an on-path attacker could otherwise craft a COOKIE-ECHO chunk
+			 * that passes validation and establish an unauthorized association).
+			 *
+			 * @see RFC 9260 sections 5.1.3 and 5.1.4.
+			 */
+			bool requireAuthenticatedCookie{ false };
+
 			void Dump(int indentation = 0) const;
 		};
 

package/worker/include/RTC/SeqManager.hpp

@@ -3,7 +3,7 @@
 
 #include "common.hpp"
 #include <limits> // std::numeric_limits
-#include <set>
+#include <vector>
 
 namespace RTC
 {
@@ -53,7 +53,7 @@ namespace RTC
 		T maxInput{ 0 };
 		T maxDropped{ 0 };
 		T maxForwarded{ 0 };
-		std::set<T, SeqLowerThan> dropped;
+		std::vector<T> dropped;
 	};
 } // namespace RTC
 

package/worker/include/RTC/SimpleProducerStreamManager.hpp

@@ -0,0 +1,72 @@
+#ifndef MS_RTC_SIMPLE_CONSUMER_STREAM_HPP
+#define MS_RTC_SIMPLE_CONSUMER_STREAM_HPP
+
+#include "RTC/ProducerStreamManager.hpp"
+
+namespace RTC
+{
+	class SimpleProducerStreamManager : public ProducerStreamManager
+	{
+	public:
+		SimpleProducerStreamManager(
+		  const std::vector<RTC::RtpEncodingParameters>& consumableRtpEncodings,
+		  const RTC::ConsumerTypes::VideoLayers& preferredLayers,
+		  std::unique_ptr<RTC::RTP::Codecs::EncodingContext> encodingContext,
+		  RTC::Media::Kind kind,
+		  bool keyFrameSupported,
+		  Listener* listener,
+		  SharedInterface* shared);
+
+	public:
+		RTC::ConsumerTypes::VideoLayers GetTargetLayers() const override
+		{
+			return {};
+		}
+		int16_t GetCurrentSpatialLayer() const override
+		{
+			return 0;
+		}
+		int16_t GetCurrentTemporalLayer() const override
+		{
+			return 0;
+		}
+		RTC::RTP::RtpStreamRecv* GetProducerCurrentRtpStream() const override;
+		RTC::RTP::RtpStreamRecv* GetProducerTargetRtpStream() const override;
+		bool IsPacketForCurrentStream(const RTC::RTP::Packet* /*packet*/) const override
+		{
+			return true;
+		}
+		bool IsActive() const override;
+		void ProducerRtpStream(RTC::RTP::RtpStreamRecv* rtpStream, uint32_t mappedSsrc) override;
+		void ProducerNewRtpStream(RTC::RTP::RtpStreamRecv* rtpStream, uint32_t mappedSsrc) override;
+		void ProducerRtpStreamScore(
+		  RTC::RTP::RtpStreamRecv* rtpStream, uint8_t score, uint8_t previousScore) override;
+		void ProducerRtcpSenderReport(RTC::RTP::RtpStreamRecv* rtpStream, bool first) override;
+		uint32_t IncreaseLayer(
+		  uint32_t bitrate, bool considerLoss, float lossPercentage, uint64_t nowMs) override;
+		void ApplyLayers(uint64_t rtpStreamActiveMs) override;
+		uint32_t GetDesiredBitrate(uint64_t nowMs) const override;
+		RtpPacketProcessResult ProcessRtpPacket(
+		  RTC::RTP::Packet* packet,
+		  bool lastSentPacketHasMarker,
+		  uint32_t clockRate,
+		  uint32_t maxPacketTs) override;
+		void RequestKeyFrame() override;
+		void RequestKeyFrameForTargetSpatialLayer() override;
+		void RequestKeyFrameForCurrentSpatialLayer() override;
+		void UpdateTargetLayers(int16_t spatial, int16_t temporal) override;
+		bool RecalculateTargetLayers(RTC::ConsumerTypes::VideoLayers& newTargetLayers) const override;
+		void OnTransportConnected() override;
+		void OnTransportDisconnected() override;
+		void OnPaused() override;
+		void OnResumed() override;
+
+	private:
+		// Producer RTP stream (single stream for Simple).
+		RTC::RTP::RtpStreamRecv* producerRtpStream{ nullptr };
+		// Prevents double IncreaseLayer in one BWE round.
+		bool managingBitrate{ false };
+	};
+} // namespace RTC
+
+#endif

package/worker/include/RTC/SimulcastProducerStreamManager.hpp

@@ -0,0 +1,93 @@
+#ifndef MS_RTC_SIMULCAST_CONSUMER_STREAM_HPP
+#define MS_RTC_SIMULCAST_CONSUMER_STREAM_HPP
+
+#include "RTC/ProducerStreamManager.hpp"
+#include <ankerl/unordered_dense.h>
+
+namespace RTC
+{
+	class SimulcastProducerStreamManager : public ProducerStreamManager
+	{
+	public:
+		SimulcastProducerStreamManager(
+		  const std::vector<RTC::RtpEncodingParameters>& consumableRtpEncodings,
+		  const RTC::ConsumerTypes::VideoLayers& preferredLayers,
+		  std::unique_ptr<RTC::RTP::Codecs::EncodingContext> encodingContext,
+		  RTC::Media::Kind kind,
+		  bool keyFrameSupported,
+		  Listener* listener,
+		  SharedInterface* shared);
+
+	public:
+		RTC::ConsumerTypes::VideoLayers GetTargetLayers() const override
+		{
+			return this->targetLayers;
+		}
+		int16_t GetCurrentSpatialLayer() const override
+		{
+			return this->currentSpatialLayer;
+		}
+		int16_t GetCurrentTemporalLayer() const override
+		{
+			return this->encodingContext->GetCurrentTemporalLayer();
+		}
+		RTC::RTP::RtpStreamRecv* GetProducerCurrentRtpStream() const override;
+		RTC::RTP::RtpStreamRecv* GetProducerTargetRtpStream() const override;
+		bool IsPacketForCurrentStream(const RTC::RTP::Packet* packet) const override
+		{
+			const auto it = this->mapMappedSsrcSpatialLayer.find(packet->GetSsrc());
+			if (it == this->mapMappedSsrcSpatialLayer.end())
+			{
+				return false;
+			}
+			return it->second == this->currentSpatialLayer;
+		}
+		bool IsActive() const override;
+		void ProducerRtpStream(RTC::RTP::RtpStreamRecv* rtpStream, uint32_t mappedSsrc) override;
+		void ProducerNewRtpStream(RTC::RTP::RtpStreamRecv* rtpStream, uint32_t mappedSsrc) override;
+		void ProducerRtpStreamScore(
+		  RTC::RTP::RtpStreamRecv* rtpStream, uint8_t score, uint8_t previousScore) override;
+		void ProducerRtcpSenderReport(RTC::RTP::RtpStreamRecv* rtpStream, bool first) override;
+		uint32_t IncreaseLayer(
+		  uint32_t bitrate, bool considerLoss, float lossPercentage, uint64_t nowMs) override;
+		void ApplyLayers(uint64_t rtpStreamActiveMs) override;
+		uint32_t GetDesiredBitrate(uint64_t nowMs) const override;
+		RtpPacketProcessResult ProcessRtpPacket(
+		  RTC::RTP::Packet* packet,
+		  bool lastSentPacketHasMarker,
+		  uint32_t clockRate,
+		  uint32_t maxPacketTs) override;
+		void RequestKeyFrame() override;
+		void RequestKeyFrameForTargetSpatialLayer() override;
+		void RequestKeyFrameForCurrentSpatialLayer() override;
+		void UpdateTargetLayers(int16_t newTargetSpatialLayer, int16_t newTargetTemporalLayer) override;
+		bool RecalculateTargetLayers(RTC::ConsumerTypes::VideoLayers& newTargetLayers) const override;
+		void OnTransportConnected() override;
+		void OnTransportDisconnected() override;
+		void OnPaused() override;
+		void OnResumed() override;
+
+	private:
+		bool CanSwitchToSpatialLayer(int16_t spatialLayer) const;
+		RTC::RTP::RtpStreamRecv* GetProducerTsReferenceRtpStream() const;
+
+	private:
+		// Producer RTP streams (multiple for Simulcast).
+		std::vector<RTC::RTP::RtpStreamRecv*> producerRtpStreams;
+		ankerl::unordered_dense::map<uint32_t, int16_t> mapMappedSsrcSpatialLayer;
+		RTC::ConsumerTypes::VideoLayers targetLayers;
+		int16_t currentSpatialLayer{ -1 };
+		int16_t spatialLayerToSync{ -1 };
+		// Timestamp synchronization.
+		int16_t tsReferenceSpatialLayer{ -1 };
+		uint32_t tsOffset{ 0u };
+		bool keyFrameForTsOffsetRequested{ false };
+		// Old-packet filtering after spatial switch.
+		uint16_t snReferenceSpatialLayer{ 0u };
+		bool checkingForOldPacketsInSpatialLayer{ false };
+		// BWE downgrade tracking.
+		uint64_t lastBweDowngradeAtMs{ 0u };
+	};
+} // namespace RTC
+
+#endif

package/worker/include/RTC/SvcProducerStreamManager.hpp

@@ -0,0 +1,72 @@
+#ifndef MS_RTC_SVC_CONSUMER_STREAM_HPP
+#define MS_RTC_SVC_CONSUMER_STREAM_HPP
+
+#include "RTC/ProducerStreamManager.hpp"
+
+namespace RTC
+{
+	class SvcProducerStreamManager : public ProducerStreamManager
+	{
+	public:
+		SvcProducerStreamManager(
+		  const std::vector<RTC::RtpEncodingParameters>& consumableRtpEncodings,
+		  const RTC::ConsumerTypes::VideoLayers& preferredLayers,
+		  std::unique_ptr<RTC::RTP::Codecs::EncodingContext> encodingContext,
+		  RTC::Media::Kind kind,
+		  bool keyFrameSupported,
+		  Listener* listener,
+		  SharedInterface* shared);
+
+	public:
+		RTC::ConsumerTypes::VideoLayers GetTargetLayers() const override
+		{
+			return this->encodingContext->GetTargetLayers();
+		}
+		int16_t GetCurrentSpatialLayer() const override
+		{
+			return this->encodingContext->GetCurrentSpatialLayer();
+		}
+		int16_t GetCurrentTemporalLayer() const override
+		{
+			return this->encodingContext->GetCurrentTemporalLayer();
+		}
+		RTC::RTP::RtpStreamRecv* GetProducerCurrentRtpStream() const override;
+		RTC::RTP::RtpStreamRecv* GetProducerTargetRtpStream() const override;
+		bool IsPacketForCurrentStream(const RTC::RTP::Packet* /*packet*/) const override
+		{
+			return true;
+		}
+		bool IsActive() const override;
+		void ProducerRtpStream(RTC::RTP::RtpStreamRecv* rtpStream, uint32_t mappedSsrc) override;
+		void ProducerNewRtpStream(RTC::RTP::RtpStreamRecv* rtpStream, uint32_t mappedSsrc) override;
+		void ProducerRtpStreamScore(
+		  RTC::RTP::RtpStreamRecv* rtpStream, uint8_t score, uint8_t previousScore) override;
+		void ProducerRtcpSenderReport(RTC::RTP::RtpStreamRecv* rtpStream, bool first) override;
+		uint32_t IncreaseLayer(
+		  uint32_t bitrate, bool considerLoss, float lossPercentage, uint64_t nowMs) override;
+		void ApplyLayers(uint64_t rtpStreamActiveMs) override;
+		uint32_t GetDesiredBitrate(uint64_t nowMs) const override;
+		RtpPacketProcessResult ProcessRtpPacket(
+		  RTC::RTP::Packet* packet,
+		  bool lastSentPacketHasMarker,
+		  uint32_t clockRate,
+		  uint32_t maxPacketTs) override;
+		void RequestKeyFrame() override;
+		void RequestKeyFrameForTargetSpatialLayer() override;
+		void RequestKeyFrameForCurrentSpatialLayer() override;
+		void UpdateTargetLayers(int16_t newTargetSpatialLayer, int16_t newTargetTemporalLayer) override;
+		bool RecalculateTargetLayers(RTC::ConsumerTypes::VideoLayers& newTargetLayers) const override;
+		void OnTransportConnected() override;
+		void OnTransportDisconnected() override;
+		void OnPaused() override;
+		void OnResumed() override;
+
+	private:
+		// Producer RTP stream (single stream for SVC).
+		RTC::RTP::RtpStreamRecv* producerRtpStream{ nullptr };
+		// BWE downgrade tracking.
+		uint64_t lastBweDowngradeAtMs{ 0u };
+	};
+} // namespace RTC
+
+#endif

package/worker/include/RTC/Transport.hpp

@@ -154,7 +154,13 @@ namespace RTC
 		  SharedInterface* shared,
 		  const std::string& id,
 		  RTC::Transport::Listener* listener,
-		  const FBS::Transport::Options* options);
+		  const FBS::Transport::Options* options,
+		  /**
+		   * Whether the SCTP association (if enabled) must authenticate received
+		   * State Cookies. This must be `true` for transports whose SCTP traffic
+		   * is not protected by DTLS (PlainTransport and PipeTransport).
+		   */
+		  bool requireSctpStateCookieAuthentication);
 		~Transport() override;
 
 	public:

package/worker/meson.build

@@ -119,7 +119,6 @@ common_sources = [
   'src/RTC/DtlsTransport.cpp',
   'src/RTC/KeyFrameRequestManager.cpp',
   'src/RTC/NackGenerator.cpp',
-  'src/RTC/PipeConsumer.cpp',
   'src/RTC/PipeTransport.cpp',
   'src/RTC/PlainTransport.cpp',
   'src/RTC/PortManager.cpp',
@@ -133,10 +132,11 @@ common_sources = [
   'src/RTC/SenderBandwidthEstimator.cpp',
   'src/RTC/SeqManager.cpp',
   'src/RTC/Serializable.cpp',
-  'src/RTC/SimpleConsumer.cpp',
-  'src/RTC/SimulcastConsumer.cpp',
+  'src/RTC/PipeProducerStreamManager.cpp',
+  'src/RTC/SimpleProducerStreamManager.cpp',
+  'src/RTC/SimulcastProducerStreamManager.cpp',
   'src/RTC/SrtpSession.cpp',
-  'src/RTC/SvcConsumer.cpp',
+  'src/RTC/SvcProducerStreamManager.cpp',
   'src/RTC/TcpConnection.cpp',
   'src/RTC/TcpServer.cpp',
   'src/RTC/Transport.cpp',
@@ -449,13 +449,17 @@ mock_sources = [
 test_sources = [
   'test/src/tests.cpp',
   'test/src/testHelpers.cpp',
+  'test/src/RTC/TestConsumer.cpp',
+  'test/src/RTC/TestPipeProducerStreamManager.cpp',
+  'test/src/RTC/TestSimpleProducerStreamManager.cpp',
+  'test/src/RTC/TestSimulcastProducerStreamManager.cpp',
+  'test/src/RTC/TestSvcProducerStreamManager.cpp',
   'test/src/RTC/TestKeyFrameRequestManager.cpp',
   'test/src/RTC/TestNackGenerator.cpp',
   'test/src/RTC/TestPortManager.cpp',
   'test/src/RTC/TestRateCalculator.cpp',
   'test/src/RTC/TestRtpEncodingParameters.cpp',
   'test/src/RTC/TestSeqManager.cpp',
-  'test/src/RTC/TestSimpleConsumer.cpp',
   'test/src/RTC/TestTransportCongestionControlServer.cpp',
   'test/src/RTC/TestTransportTuple.cpp',
   'test/src/RTC/TestTrendCalculator.cpp',