mediasoup 3.21.2 → 3.23.0

package/worker/src/RTC/SrtpSession.cpp

@@ -5,7 +5,6 @@
 #include "DepLibSRTP.hpp"
 #include "Logger.hpp"
 #include "MediaSoupErrors.hpp"
-#include <cstring> // std::memset()
 
 namespace RTC
 {
@@ -127,42 +126,34 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		srtp_policy_t policy; // NOLINT(cppcoreguidelines-pro-type-member-init)
-
-		// Set all policy fields to 0.
-		std::memset(&policy, 0, sizeof(srtp_policy_t));
+		srtp_profile_t profile;
 
 		switch (cryptoSuite)
 		{
 			case CryptoSuite::AEAD_AES_256_GCM:
 			{
-				srtp_crypto_policy_set_aes_gcm_256_16_auth(&policy.rtp);
-				srtp_crypto_policy_set_aes_gcm_256_16_auth(&policy.rtcp);
+				profile = srtp_profile_aead_aes_256_gcm;
 
 				break;
 			}
 
 			case CryptoSuite::AEAD_AES_128_GCM:
 			{
-				srtp_crypto_policy_set_aes_gcm_128_16_auth(&policy.rtp);
-				srtp_crypto_policy_set_aes_gcm_128_16_auth(&policy.rtcp);
+				profile = srtp_profile_aead_aes_128_gcm;
 
 				break;
 			}
 
 			case CryptoSuite::AES_CM_128_HMAC_SHA1_80:
 			{
-				srtp_crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy.rtp);
-				srtp_crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy.rtcp);
+				profile = srtp_profile_aes128_cm_sha1_80;
 
 				break;
 			}
 
 			case CryptoSuite::AES_CM_128_HMAC_SHA1_32:
 			{
-				srtp_crypto_policy_set_aes_cm_128_hmac_sha1_32(&policy.rtp);
-				// NOTE: Must be 80 for RTCP.
-				srtp_crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy.rtcp);
+				profile = srtp_profile_aes128_cm_sha1_32;
 
 				break;
 			}
@@ -173,35 +164,101 @@ namespace RTC
 			}
 		}
 
-		MS_ASSERT(
-		  keyLen == policy.rtp.cipher_key_len, "given keyLen does not match policy.rtp.cipher_keyLen");
+		// Create the policy object.
+		srtp_policy_t policy{ nullptr };
+		srtp_err_status_t err = srtp_policy_create(std::addressof(policy));
+
+		if (DepLibSRTP::IsError(err))
+		{
+			MS_THROW_ERROR("srtp_policy_create() failed: %s", DepLibSRTP::GetErrorString(err).c_str());
+		}
+
+		// Set SSRC.
+		srtp_ssrc_t ssrc{};
 
 		switch (type)
 		{
 			case Type::INBOUND:
 			{
-				policy.ssrc.type = ssrc_any_inbound;
+				ssrc.type = ssrc_any_inbound;
 
 				break;
 			}
 
 			case Type::OUTBOUND:
 			{
-				policy.ssrc.type = ssrc_any_outbound;
+				ssrc.type = ssrc_any_outbound;
 
 				break;
 			}
 		}
 
-		policy.ssrc.value = 0;
-		policy.key        = key;
+		ssrc.value = 0;
+
+		err = srtp_policy_set_ssrc(policy, ssrc);
+
+		if (DepLibSRTP::IsError(err))
+		{
+			srtp_policy_destroy(policy);
+			MS_THROW_ERROR("srtp_policy_set_ssrc() failed: %s", DepLibSRTP::GetErrorString(err).c_str());
+		}
+
+		// Set the crypto profile.
+		err = srtp_policy_set_profile(policy, profile);
+
+		if (DepLibSRTP::IsError(err))
+		{
+			srtp_policy_destroy(policy);
+			MS_THROW_ERROR("srtp_policy_set_profile() failed: %s", DepLibSRTP::GetErrorString(err).c_str());
+		}
+
+		// Split the concatenated key+salt buffer using the profile's lengths.
+		const size_t masterKeyLen  = srtp_profile_get_master_key_length(profile);
+		const size_t masterSaltLen = srtp_profile_get_master_salt_length(profile);
+
+		MS_ASSERT(
+		  keyLen == masterKeyLen + masterSaltLen,
+		  "given keyLen does not match profile master key + salt length");
+
+		err = srtp_policy_add_key(
+		  policy,
+		  /*key*/ key,
+		  /*key_len*/ masterKeyLen,
+		  /*salt*/ key + masterKeyLen,
+		  /*salt_len*/ masterSaltLen,
+		  /*mki*/ nullptr,
+		  /*mki_len*/ 0);
+
+		if (DepLibSRTP::IsError(err))
+		{
+			srtp_policy_destroy(policy);
+			MS_THROW_ERROR("srtp_policy_add_key() failed: %s", DepLibSRTP::GetErrorString(err).c_str());
+		}
+
 		// Required for sending RTP retransmission without RTX.
-		policy.allow_repeat_tx = true;
-		policy.window_size     = 1024;
-		policy.next            = nullptr;
+		err = srtp_policy_set_allow_repeat_tx(policy, true);
+
+		if (DepLibSRTP::IsError(err))
+		{
+			srtp_policy_destroy(policy);
+			MS_THROW_ERROR(
+			  "srtp_policy_set_allow_repeat_tx() failed: %s", DepLibSRTP::GetErrorString(err).c_str());
+		}
+
+		err = srtp_policy_set_window_size(policy, 1024);
+
+		if (DepLibSRTP::IsError(err))
+		{
+			srtp_policy_destroy(policy);
+			MS_THROW_ERROR(
+			  "srtp_policy_set_window_size() failed: %s", DepLibSRTP::GetErrorString(err).c_str());
+		}
+
+		// Create the SRTP session.
+		err = srtp_create(std::addressof(this->session), policy);
 
-		// Set the SRTP session.
-		const srtp_err_status_t err = srtp_create(&this->session, &policy);
+		// Policy is no longer needed once the session is created.
+		srtp_policy_destroy(policy);
 
 		if (DepLibSRTP::IsError(err))
 		{

package/worker/src/RTC/SubchannelsCodec.cpp

@@ -0,0 +1,153 @@
+#define MS_CLASS "RTC::SubchannelsCodec"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "RTC/SubchannelsCodec.hpp"
+#include "Logger.hpp"
+#include "Utils.hpp"
+
+namespace RTC
+{
+	/* Class methods. */
+
+	bool SubchannelsCodec::EncodeSubchannels(
+	  RTC::SCTP::Message& message,
+	  const std::vector<uint16_t>& subchannels,
+	  std::optional<uint16_t> requiredSubchannel)
+	{
+		MS_TRACE();
+
+		// Nothing to encode.
+		if (subchannels.empty() && !requiredSubchannel.has_value())
+		{
+			return false;
+		}
+
+		if (subchannels.size() > 0xFFFF)
+		{
+			MS_ERROR("too many subchannels to encode [count:%zu]", subchannels.size());
+
+			return false;
+		}
+
+		const auto subchannelsCount       = static_cast<uint16_t>(subchannels.size());
+		const bool requiredSubchannelFlag = requiredSubchannel.has_value();
+
+		// Length of the header to prepend.
+		size_t headerLen =
+		  8 /* Magic Token */ + 2 /* subchannelsCount */ + (static_cast<size_t>(subchannelsCount) * 2);
+
+		if (requiredSubchannelFlag)
+		{
+			headerLen += 2;
+		}
+
+		const auto payload = message.GetPayload();
+
+		// Build the whole new payload at once (header followed by the original
+		// payload) so it can be moved into the message with a single allocation.
+		std::vector<uint8_t> newPayload(headerLen + payload.size());
+
+		uint64_t magicToken = SubchannelsCodec::MagicToken;
+
+		if (requiredSubchannelFlag)
+		{
+			magicToken |= SubchannelsCodec::RequiredSubchannelFlagMask;
+		}
+
+		size_t offset = 0;
+
+		Utils::Byte::Set8Bytes(newPayload.data(), offset, magicToken);
+		offset += 8;
+
+		Utils::Byte::Set2Bytes(newPayload.data(), offset, subchannelsCount);
+		offset += 2;
+
+		for (const auto subchannel : subchannels)
+		{
+			Utils::Byte::Set2Bytes(newPayload.data(), offset, subchannel);
+			offset += 2;
+		}
+
+		if (requiredSubchannelFlag)
+		{
+			Utils::Byte::Set2Bytes(newPayload.data(), offset, requiredSubchannel.value());
+			offset += 2;
+		}
+
+		// Append the original payload right after the encoded header.
+		std::ranges::copy(payload, newPayload.begin() + offset);
+
+		message.SetPayload(std::move(newPayload));
+
+		return true;
+	}
+
+	bool SubchannelsCodec::DecodeSubchannels(
+	  RTC::SCTP::Message& message,
+	  std::vector<uint16_t>& subchannels,
+	  std::optional<uint16_t>& requiredSubchannel)
+	{
+		MS_TRACE();
+
+		const auto payload = message.GetPayload();
+		const size_t len   = payload.size();
+
+		// Not even enough bytes to hold the Magic Token and `subchannelsCount` field,
+		// so nothing to decode.
+		if (len < 10)
+		{
+			return false;
+		}
+
+		const uint64_t magicToken = Utils::Byte::Get8Bytes(payload.data(), 0);
+
+		// The message does not start with the Magic Token, so nothing to decode.
+		if ((magicToken & ~SubchannelsCodec::RequiredSubchannelFlagMask) != SubchannelsCodec::MagicToken)
+		{
+			return false;
+		}
+
+		const bool requiredSubchannelFlag =
+		  (magicToken & SubchannelsCodec::RequiredSubchannelFlagMask) != 0;
+
+		const uint16_t subchannelsCount = Utils::Byte::Get2Bytes(payload.data(), 8);
+
+		// Offset right after the Magic Token and subchannelsCount fields.
+		size_t offset = 10;
+
+		// Bytes needed to hold all announced subchannels and, if present, the
+		// requiredSubchannel.
+		size_t neededLen = offset + (static_cast<size_t>(subchannelsCount) * 2);
+
+		if (requiredSubchannelFlag)
+		{
+			neededLen += 2;
+		}
+
+		if (len < neededLen)
+		{
+			MS_WARN_DEV("message too short to hold announced subchannels, ignoring");
+
+			return false;
+		}
+
+		subchannels.reserve(subchannelsCount);
+
+		for (uint16_t i = 0; i < subchannelsCount; ++i)
+		{
+			subchannels.push_back(Utils::Byte::Get2Bytes(payload.data(), offset));
+			offset += 2;
+		}
+
+		if (requiredSubchannelFlag)
+		{
+			requiredSubchannel = Utils::Byte::Get2Bytes(payload.data(), offset);
+			offset += 2;
+		}
+
+		// Remove the decoded header from the beginning of the message payload.
+		message.RemovePayloadFront(offset);
+
+		return true;
+	}
+} // namespace RTC

package/worker/src/RTC/Transport.cpp

@@ -18,6 +18,7 @@
 #include "RTC/RtpDictionaries.hpp"
 #include "RTC/SCTP/association/Association.hpp"
 #include "RTC/SCTP/public/SctpOptions.hpp"
+#include "RTC/SubchannelsCodec.hpp"
 #include "Utils.hpp"
 #ifdef MS_RTC_LOGGER_RTP
 #include "RTC/RtcLogger.hpp"
@@ -48,20 +49,10 @@ namespace RTC
 	{
 		MS_TRACE();
 
+		this->direct                = options->direct();
 		this->maxSendMessageSize    = options->maxSendMessageSize();
 		this->maxReceiveMessageSize = options->maxReceiveMessageSize();
 
-		if (options->direct())
-		{
-			this->direct = true;
-		}
-		else
-		{
-			this->sctpSendBufferSize              = options->sctpSendBufferSize();
-			this->sctpPerStreamSendQueueLimit     = options->sctpPerStreamSendQueueLimit();
-			this->sctpMaxReceiverWindowBufferSize = options->sctpMaxReceiverWindowBufferSize();
-		}
-
 		if (
 		  auto initialAvailableOutgoingBitrate = options->initialAvailableOutgoingBitrate();
 		  initialAvailableOutgoingBitrate.has_value())
@@ -79,11 +70,13 @@ namespace RTC
 			const RTC::SCTP::SctpOptions sctpOptions = {
 				.mtu                         = RTC::Consts::MaxSafeMtuSizeForSctp,
 				.maxSendMessageSize          = this->maxSendMessageSize,
-				.maxSendBufferSize           = this->sctpSendBufferSize,
-				.perStreamSendQueueLimit     = this->sctpPerStreamSendQueueLimit,
+				.maxSendBufferSize           = options->sctpSendBufferSize(),
+				.perStreamSendQueueLimit     = options->sctpPerStreamSendQueueLimit(),
 				.maxReceiveMessageSize       = this->maxReceiveMessageSize,
-				.maxReceiverWindowBufferSize = this->sctpMaxReceiverWindowBufferSize,
-				.requireAuthenticatedCookie  = requireSctpStateCookieAuthentication
+				.maxReceiverWindowBufferSize = options->sctpMaxReceiverWindowBufferSize(),
+				.defaultStreamBufferedAmountLowThreshold =
+				  options->sctpDefaultStreamBufferedAmountLowThreshold(),
+				.requireAuthenticatedCookie = requireSctpStateCookieAuthentication
 			};
 
 			this->sctpAssociation = std::make_unique<RTC::SCTP::Association>(
@@ -1111,7 +1104,13 @@ namespace RTC
 
 				// This may throw.
 				auto* dataConsumer = new RTC::DataConsumer(
-				  this->shared, dataConsumerId, dataProducerId, this, body, this->maxSendMessageSize);
+				  this->shared,
+				  dataConsumerId,
+				  dataProducerId,
+				  this,
+				  body,
+				  this->maxSendMessageSize,
+				  this->IsPipe());
 
 				// Verify the type of the DataConsumer.
 				switch (dataConsumer->GetType())
@@ -1189,19 +1188,8 @@ namespace RTC
 
 				request->Accept(FBS::Response::Body::DataConsumer_DumpResponse, dumpOffset);
 
-				if (IsConnected())
-				{
-					dataConsumer->TransportConnected();
-				}
-
 				if (dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
 				{
-					if (this->sctpAssociation->GetAssociationState() == RTC::SCTP::Types::AssociationState::CONNECTED)
-					{
-						// Tell to the DataConsumer.
-						dataConsumer->SctpAssociationConnected();
-					}
-
 					// Tell to the SCTP association.
 					this->sctpAssociation->MayConnect();
 				}
@@ -1480,14 +1468,6 @@ namespace RTC
 			consumer->TransportConnected();
 		}
 
-		// Tell all DataConsumers.
-		for (auto& kv : this->mapDataConsumers)
-		{
-			auto* dataConsumer = kv.second;
-
-			dataConsumer->TransportConnected();
-		}
-
 		// Tell the SctpAssociation.
 		if (this->sctpAssociation)
 		{
@@ -1530,14 +1510,6 @@ namespace RTC
 			consumer->TransportDisconnected();
 		}
 
-		// Tell all DataConsumers.
-		for (auto& kv : this->mapDataConsumers)
-		{
-			auto* dataConsumer = kv.second;
-
-			dataConsumer->TransportDisconnected();
-		}
-
 		// Stop the RTCP timer.
 		this->rtcpTimer->Stop();
 
@@ -2999,17 +2971,6 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		// Tell all DataConsumers.
-		for (auto& kv : this->mapDataConsumers)
-		{
-			auto* dataConsumer = kv.second;
-
-			if (dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
-			{
-				dataConsumer->SctpAssociationConnected();
-			}
-		}
-
 		// Notify the upper layer.
 
 		// First tell it about the SCTP negotiated capabilities.
@@ -3041,7 +3002,7 @@ namespace RTC
 
 // For debugging purposes.
 #if MS_LOG_DEV_LEVEL == 3
-		MS_DUMP("--- SCTP association connected:");
+		MS_DUMP("SCTP association connected:");
 		this->sctpAssociation->Dump();
 #endif
 	}
@@ -3187,10 +3148,17 @@ namespace RTC
 		// Pass the SCTP message to the corresponding DataProducer.
 		try
 		{
-			static thread_local std::vector<uint16_t> emptySubchannels;
+			std::vector<uint16_t> subchannels;
+			std::optional<uint16_t> requiredSubchannel;
+
+			// When this is a pipe transport, the subchannels and required subchannel
+			// may be encoded at the beginning of the message payload.
+			if (this->IsPipe())
+			{
+				RTC::SubchannelsCodec::DecodeSubchannels(message, subchannels, requiredSubchannel);
+			}
 
-			dataProducer->ReceiveMessage(
-			  std::move(message), emptySubchannels, /*requiredSubchannel*/ std::nullopt);
+			dataProducer->ReceiveMessage(std::move(message), subchannels, requiredSubchannel);
 		}
 		catch (std::exception& error)
 		{

package/worker/subprojects/libsrtp3.wrap

@@ -1,8 +1,8 @@
 [wrap-file]
-directory = libsrtp-3.0.0-beta
-source_url = https://github.com/versatica/libsrtp/archive/v3.0.0-beta.zip
-source_filename = libsrtp-3.0.0-beta.zip
-source_hash = b0cb21aaf27120b1a242f3d9b07c145b4a6c7a02a25da0824539fd95611f690c
+directory = libsrtp-3.0.0-beta-2fc078db
+source_url = https://github.com/versatica/libsrtp/archive/v3.0.0-beta-2fc078db.zip
+source_filename = libsrtp-3.0.0-beta-2fc078db.zip
+source_hash = d2c0fc2fdb84c615ed835471014611fb0b55f92c183c690ebeceb6ad4821a8b9
 
 [provide]
 libsrtp3 = libsrtp3_dep

package/worker/tasks.py

@@ -43,7 +43,7 @@ NUM_CORES = (
 )
 PYTHON = os.getenv("PYTHON") or sys.executable
 MESON = os.getenv("MESON") or f"{PIP_MESON_NINJA_DIR}/bin/meson"
-MESON_VERSION = os.getenv("MESON_VERSION") or "1.9.1"
+MESON_VERSION = os.getenv("MESON_VERSION") or "1.11.2"
 # MESON_ARGS can be used to provide extra configuration parameters to meson,
 # such as adding defines or changing optimization options. For instance, use
 # `MESON_ARGS="-Dms_log_trace=true -Dms_log_file_line=true" npm i` to compile

package/worker/test/src/RTC/SCTP/association/TestAssociation.cpp

@@ -1057,6 +1057,40 @@ SCENARIO("SCTP Association", "[sctp][association]")
 		REQUIRE(a.listener.HasOnStreamBufferedAmountLowBeenCalledWithStreamId(1) == true);
 	}
 
+	SECTION("applies the configured default buffered amount low threshold to new streams")
+	{
+		auto sctpOptions = makeSctpOptions();
+
+		sctpOptions.defaultStreamBufferedAmountLowThreshold = 1024;
+
+		AssociationUnderTest a(sctpOptions);
+
+		// Sending a message creates the outgoing stream, which must inherit the
+		// configured default buffered amount low threshold.
+		sendMessage(a, 1, 53, std::vector<uint8_t>(10));
+
+		REQUIRE(a.association.GetStreamBufferedAmountLowThreshold(1) == 1024);
+	}
+
+	SECTION("does not trigger buffered amount low until crossing a non-zero default threshold")
+	{
+		auto sctpOptions = makeSctpOptions();
+
+		sctpOptions.defaultStreamBufferedAmountLowThreshold = 1024;
+
+		AssociationUnderTest a(sctpOptions);
+		AssociationUnderTest z;
+
+		connectAssociations(a, z);
+
+		// A small message never takes the buffered amount above the threshold, so
+		// draining it must not trigger the event.
+		sendMessage(a, 1, 53, std::vector<uint8_t>(10));
+		exchangeMessages(a, z);
+
+		REQUIRE(a.listener.HasOnStreamBufferedAmountLowBeenCalledWithStreamId(1) == false);
+	}
+
 	SECTION("detects the peer implementation")
 	{
 		AssociationUnderTest a;

package/worker/test/src/RTC/SCTP/association/TestStreamResetHandler.cpp

@@ -57,6 +57,7 @@ namespace
 		      this->associationListener,
 		      this->sctpOptions.mtu,
 		      this->sctpOptions.defaultStreamPriority,
+		      this->sctpOptions.defaultStreamBufferedAmountLowThreshold,
 		      this->sctpOptions.totalBufferedAmountLowThreshold),
 		    dataTracker(this->delayedAckTimer.get(), RemoteInitialTsn),
 		    reassemblyQueue(this->sctpOptions.maxReceiverWindowBufferSize),

package/worker/test/src/RTC/SCTP/packet/errorCauses/TestMissingMandatoryParameterErrorCause.cpp

@@ -164,6 +164,30 @@ SCENARIO("Invalid Stream Identifier Error Cause (2)", "[serializable][sctp][erro
 		// clang-format on
 
 		REQUIRE(!RTC::SCTP::MissingMandatoryParameterErrorCause::Parse(buffer3, sizeof(buffer3)));
+
+		// Security advisory.
+		// See https://github.com/versatica/mediasoup/security/advisories/GHSA-p9cq-fqxc-987w
+		//
+		// Number of missing parameters chosen so that, multiplied by 2 in 32-bit
+		// arithmetic, it wraps around to a value that would falsely match the
+		// length field. 0x80000001 (2147483649) * 2 wraps to 2, which equals
+		// Length 10 minus the 8-byte header. The check must be done in 64-bit
+		// arithmetic so this malformed cause is rejected instead of accepted
+		// (which would later drive an out-of-bounds read while iterating the
+		// bogus 2.1 billion parameter count).
+		// clang-format off
+		alignas(4) uint8_t buffer4[] =
+		{
+			// Code:2 (MISSING-MANDATORY-PARAMETER), Length: 10
+			0x00, 0x02, 0x00, 0x0A,
+			// Number of missing params: 0x80000001 (2147483649)
+			0x80, 0x00, 0x00, 0x01,
+			// A single param type (2 bytes) plus 2 bytes of padding
+			0x00, 0x05, 0x00, 0x00,
+		};
+		// clang-format on
+
+		REQUIRE(!RTC::SCTP::MissingMandatoryParameterErrorCause::Parse(buffer4, sizeof(buffer4)));
 	}
 
 	SECTION("MissingMandatoryParameterErrorCause::Factory() succeeds")