mediasoup 3.20.5 → 3.20.7

package/worker/src/RTC/SCTP/association/Association.cpp

@@ -7,6 +7,7 @@
 #include "RTC/SCTP/packet/errorCauses/NoUserDataErrorCause.hpp"
 #include "RTC/SCTP/packet/errorCauses/OutOfResourceErrorCause.hpp"
 #include "RTC/SCTP/packet/errorCauses/ProtocolViolationErrorCause.hpp"
+#include "RTC/SCTP/packet/errorCauses/StaleCookieErrorCause.hpp"
 #include "RTC/SCTP/packet/errorCauses/UnrecognizedChunkTypeErrorCause.hpp"
 #include "RTC/SCTP/packet/errorCauses/UserInitiatedAbortErrorCause.hpp"
 #include "RTC/SCTP/packet/parameters/ForwardTsnSupportedParameter.hpp"
@@ -83,6 +84,15 @@ namespace RTC
 		    mayConnectOnReceivedSctpData(mayConnectOnReceivedSctpData)
 		{
 			MS_TRACE();
+
+			// Generate the per-association secret used to authenticate the State
+			// Cookies we generate.
+			//
+			// @see RFC 9260 section 5.1.3.
+			if (this->sctpOptions.requireAuthenticatedCookie)
+			{
+				Utils::Crypto::WriteRandomBytes(this->stateCookieSecret, Association::StateCookieSecretLength);
+			}
 		}
 
 		Association::~Association()
@@ -650,6 +660,8 @@ namespace RTC
 
 			const auto prevState = this->state;
 
+			// Notice that, contrary to what happens in dcsctp, here the association
+			// never transitions back to NEW state.
 			SetState(State::CLOSED, message);
 
 			if (prevState == State::COOKIE_WAIT || prevState == State::COOKIE_ECHOED)
@@ -1057,6 +1069,32 @@ namespace RTC
 		{
 			MS_TRACE();
 
+			// https://datatracker.ietf.org/doc/html/rfc9653#section-5.3
+			//
+			// "If an endpoint has sent the Zero Checksum Acceptable Chunk Parameter
+			// indicating the support of an alternate error detection method in an INIT
+			// or INIT ACK chunk, in addition to SCTP packets containing the correct
+			// CRC32c checksum value it MUST accept SCTP packets that have an incorrect
+			// checksum value of zero [...]"
+			const bool acceptZeroChecksum =
+			  this->sctpOptions.zeroChecksumAlternateErrorDetectionMethod !=
+			  ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod::NONE;
+
+			// Validate the CRC32c checksum unless this is a zero checksum packet that we
+			// announced we are willing to accept.
+			if (!acceptZeroChecksum || receivedPacket->GetChecksum() != 0)
+			{
+				if (!receivedPacket->ValidateCRC32cChecksum())
+				{
+					MS_WARN_TAG(sctp, "invalid CRC32c checksum, packet discarded");
+
+					this->associationListenerDeferrer.OnAssociationError(
+					  Types::ErrorKind::PARSE_FAILED, "invalid CRC32c checksum");
+
+					return false;
+				}
+			}
+
 			const uint32_t localVerificationTag = this->tcb ? this->tcb->GetLocalVerificationTag() : 0;
 
 			// https://datatracker.ietf.org/doc/html/rfc9260#section-8.5.1
@@ -1113,7 +1151,7 @@ namespace RTC
 				{
 					MS_WARN_TAG(
 					  sctp,
-					  "receievd ABORT chunk has invalid verification tag %" PRIu32 ", packet discarded",
+					  "received ABORT chunk has invalid verification tag %" PRIu32 ", packet discarded",
 					  receivedPacket->GetVerificationTag());
 
 					this->associationListenerDeferrer.OnAssociationError(
@@ -1537,6 +1575,12 @@ namespace RTC
 			const auto negotiatedCapabilities =
 			  NegotiatedCapabilities::Factory(this->sctpOptions, receivedInitChunk);
 
+			// When authentication is enabled, generate an authenticated cookie with a
+			// creation timestamp and a MAC keyed with our per-association secret.
+			//
+			// @see RFC 9260 section 5.1.3.
+			const bool authenticateCookie = this->sctpOptions.requireAuthenticatedCookie;
+
 			// Write the StateCookie in place in the parameter.
 			stateCookieParameter->WriteStateCookieInPlace(
 			  localVerificationTag,
@@ -1545,7 +1589,10 @@ namespace RTC
 			  receivedInitChunk->GetInitialTsn(),
 			  receivedInitChunk->GetAdvertisedReceiverWindowCredit(),
 			  tieTag,
-			  negotiatedCapabilities);
+			  negotiatedCapabilities,
+			  /*creationTimestampMs*/ authenticateCookie ? this->shared->GetTimeMs() : 0,
+			  /*macKey*/ authenticateCookie ? this->stateCookieSecret : nullptr,
+			  /*macKeyLength*/ authenticateCookie ? Association::StateCookieSecretLength : 0);
 
 			stateCookieParameter->Consolidate();
 
@@ -1678,6 +1725,18 @@ namespace RTC
 				return;
 			}
 
+			// When authentication is enabled, verify that the cookie was generated by
+			// us (valid MAC) and is not stale before trusting any of its contents.
+			//
+			// @see RFC 9260 section 5.1.4.
+			if (this->sctpOptions.requireAuthenticatedCookie)
+			{
+				if (!VerifyReceivedStateCookie(cookie.get()))
+				{
+					return;
+				}
+			}
+
 			if (this->tcb)
 			{
 				if (!HandleReceivedCookieEchoChunkWithTcb(receivedPacket, cookie.get()))
@@ -2073,6 +2132,10 @@ namespace RTC
 				errorCausesStr.append(errorCause->ToString());
 			}
 
+			// https://datatracker.ietf.org/doc/html/rfc9260#section-3.3.7
+			//
+			// "If an endpoint receives an ABORT with a format error or no TCB is
+			// found, it MUST silently discard it."
 			if (!this->tcb)
 			{
 				MS_DEBUG_TAG(
@@ -2083,7 +2146,7 @@ namespace RTC
 				return;
 			}
 
-			MS_WARN_TAG(sctp, "received ABORT chunk, closing association: %s", errorCausesStr.c_str());
+			MS_DEBUG_TAG(sctp, "received ABORT chunk, closing association: %s", errorCausesStr.c_str());
 
 			InternalClose(Types::ErrorKind::PEER_REPORTED, errorCausesStr);
 		}
@@ -2306,11 +2369,11 @@ namespace RTC
 			// to deliver messages.
 			if (this->tcb->GetReassemblyQueue().IsAboveWatermark())
 			{
-				MS_WARN_TAG(sctp, "reassembly queue is above watermark");
+				MS_WARN_DEV("reassembly queue is above watermark");
 
 				if (!this->tcb->GetDataTracker().WillIncreaseCumAckTsn(tsn))
 				{
-					MS_WARN_TAG(sctp, "reassembly queue is above watermark");
+					MS_WARN_TAG(sctp, "rejecting received data because reassembly queue is above watermark");
 
 					this->tcb->GetDataTracker().ForceImmediateSack();
 
@@ -2320,7 +2383,7 @@ namespace RTC
 
 			if (!this->tcb->GetDataTracker().IsTsnValid(tsn))
 			{
-				MS_WARN_TAG(sctp, "data rejected because of failing TSN validity");
+				MS_WARN_TAG(sctp, "rejecting received data because of failing TSN validity");
 
 				return;
 			}
@@ -2371,8 +2434,7 @@ namespace RTC
 			}
 			else
 			{
-				MS_WARN_TAG(
-				  sctp,
+				MS_WARN_DEV(
 				  "dropping received out-of-order SACK [TSN:%" PRIu32 "]",
 				  receivedSackChunk->GetCumulativeTsnAck());
 			}
@@ -2432,6 +2494,86 @@ namespace RTC
 			return !skipProcessing;
 		}
 
+		bool Association::VerifyReceivedStateCookie(const StateCookie* cookie)
+		{
+			MS_TRACE();
+
+			// https://datatracker.ietf.org/doc/html/rfc9260#section-5.1.4
+			//
+			// "Authenticate the State Cookie as one that it previously generated by
+			// comparing the computed MAC against the one carried in the State Cookie.
+			// If this comparison fails, the SCTP packet, including the COOKIE ECHO and
+			// any DATA chunks, should be silently discarded."
+			//
+			// NOTE: The Verification Tag check (RFC 9260 section 5.1.4) is not done
+			// here but in the COOKIE-ECHO handling logic (with and without TCB), which
+			// is performed regardless of whether authentication is enabled.
+			if (!StateCookie::VerifyMac(
+			      cookie->GetBuffer(),
+			      cookie->GetLength(),
+			      this->stateCookieSecret,
+			      Association::StateCookieSecretLength))
+			{
+				MS_WARN_TAG(
+				  sctp,
+				  "received COOKIE-ECHO chunk with State Cookie that failed MAC authentication, discarding");
+
+				this->associationListenerDeferrer.OnAssociationError(
+				  Types::ErrorKind::PARSE_FAILED,
+				  "received COOKIE-ECHO chunk with unauthenticated State Cookie");
+
+				return false;
+			}
+
+			// https://datatracker.ietf.org/doc/html/rfc9260#section-5.1.4
+			//
+			// "Compare the creation timestamp in the State Cookie to the current local
+			// time. If the elapsed time is longer than the lifespan carried in the
+			// State Cookie, then the packet, including the COOKIE ECHO and any attached
+			// DATA chunks, SHOULD be discarded, and the endpoint MUST transmit an ERROR
+			// chunk with a 'Stale Cookie' error cause to the peer endpoint."
+			const uint64_t nowMs      = this->shared->GetTimeMs();
+			const uint64_t creationMs = cookie->GetCreationTimestampMs();
+
+			if (nowMs > creationMs && nowMs - creationMs > StateCookie::ValidCookieLifeMs)
+			{
+				const uint64_t stalenessMs = nowMs - creationMs - StateCookie::ValidCookieLifeMs;
+
+				MS_WARN_TAG(
+				  sctp,
+				  "received COOKIE-ECHO chunk with stale State Cookie, sending Stale Cookie error [staleness:%" PRIu64
+				  "ms]",
+				  stalenessMs);
+
+				// Respond with an ERROR chunk carrying a Stale Cookie error cause. The
+				// packet must use the verification tag the peer expects (the remote
+				// verification tag stored in the cookie we generated).
+				auto packet = CreatePacketWithVerificationTag(cookie->GetRemoteVerificationTag());
+				auto* operationErrorChunk = packet->BuildChunkInPlace<OperationErrorChunk>();
+				auto* staleCookieErrorCause =
+				  operationErrorChunk->BuildErrorCauseInPlace<StaleCookieErrorCause>();
+
+				// The Measure of Staleness is expressed in microseconds.
+				const uint64_t stalenessUs = stalenessMs * 1000;
+
+				staleCookieErrorCause->SetMeasureOfStaleness(
+				  stalenessUs > std::numeric_limits<uint32_t>::max() ? std::numeric_limits<uint32_t>::max()
+				                                                     : static_cast<uint32_t>(stalenessUs));
+
+				staleCookieErrorCause->Consolidate();
+				operationErrorChunk->Consolidate();
+
+				this->packetSender.SendPacket(packet.get());
+
+				this->associationListenerDeferrer.OnAssociationError(
+				  Types::ErrorKind::WRONG_SEQUENCE, "received COOKIE-ECHO chunk with stale State Cookie");
+
+				return false;
+			}
+
+			return true;
+		}
+
 		void Association::OnT1InitTimer(uint64_t& /*baseTimeoutMs*/, bool& /*stop*/)
 		{
 			MS_TRACE();

package/worker/src/RTC/SCTP/association/StateCookie.cpp

@@ -4,6 +4,8 @@
 #include "RTC/SCTP/association/StateCookie.hpp"
 #include "Logger.hpp"
 #include "MediaSoupErrors.hpp"
+#include <cstring> // std::memcpy(), std::memcmp()
+#include <string_view>
 
 namespace RTC
 {
@@ -11,31 +13,6 @@ namespace RTC
 	{
 		/* Class methods. */
 
-		bool StateCookie::IsMediasoupStateCookie(const uint8_t* buffer, size_t bufferLength)
-		{
-			MS_TRACE();
-
-			if (bufferLength != StateCookie::StateCookieLength)
-			{
-				return false;
-			}
-
-			if (Utils::Byte::Get8Bytes(buffer, 0) != StateCookie::Magic1)
-			{
-				return false;
-			}
-
-			auto* negotiatedCapabilitiesField = reinterpret_cast<NegotiatedCapabilitiesField*>(
-			  const_cast<uint8_t*>(buffer) + StateCookie::NegotiatedCapabilitiesOffset);
-
-			if (ntohs(negotiatedCapabilitiesField->magic2) != StateCookie::Magic2)
-			{
-				return false;
-			}
-
-			return true;
-		}
-
 		StateCookie* StateCookie::Parse(const uint8_t* buffer, size_t bufferLength)
 		{
 			MS_TRACE();
@@ -61,7 +38,10 @@ namespace RTC
 		  uint32_t remoteInitialTsn,
 		  uint32_t remoteAdvertisedReceiverWindowCredit,
 		  uint64_t tieTag,
-		  const NegotiatedCapabilities& negotiatedCapabilities)
+		  const NegotiatedCapabilities& negotiatedCapabilities,
+		  uint64_t creationTimestampMs,
+		  const uint8_t* macKey,
+		  size_t macKeyLength)
 		{
 			MS_TRACE();
 
@@ -75,9 +55,15 @@ namespace RTC
 			  remoteInitialTsn,
 			  remoteAdvertisedReceiverWindowCredit,
 			  tieTag,
-			  negotiatedCapabilities);
+			  negotiatedCapabilities,
+			  creationTimestampMs,
+			  macKey,
+			  macKeyLength);
+
+			const size_t cookieLength = macKey != nullptr ? StateCookie::AuthenticatedStateCookieLength
+			                                              : StateCookie::StateCookieLength;
 
-			return new StateCookie(buffer, StateCookie::StateCookieLength);
+			return new StateCookie(buffer, cookieLength);
 		}
 
 		void StateCookie::Write(
@@ -89,11 +75,18 @@ namespace RTC
 		  uint32_t remoteInitialTsn,
 		  uint32_t remoteAdvertisedReceiverWindowCredit,
 		  uint64_t tieTag,
-		  const NegotiatedCapabilities& negotiatedCapabilities)
+		  const NegotiatedCapabilities& negotiatedCapabilities,
+		  uint64_t creationTimestampMs,
+		  const uint8_t* macKey,
+		  size_t macKeyLength)
 		{
 			MS_TRACE();
 
-			if (bufferLength < StateCookie::StateCookieLength)
+			const bool authenticate = macKey != nullptr;
+			const size_t cookieLength =
+			  authenticate ? StateCookie::AuthenticatedStateCookieLength : StateCookie::StateCookieLength;
+
+			if (bufferLength < cookieLength)
 			{
 				MS_THROW_TYPE_ERROR("buffer too small");
 			}
@@ -119,6 +112,65 @@ namespace RTC
 			  htons(negotiatedCapabilities.negotiatedMaxOutboundStreams);
 			negotiatedCapabilitiesField->negotiatedMaxInboundStreams =
 			  htons(negotiatedCapabilities.negotiatedMaxInboundStreams);
+
+			if (!authenticate)
+			{
+				return;
+			}
+
+			// Append the creation timestamp and the MAC computed over all preceding
+			// bytes (including the timestamp).
+			//
+			// @see RFC 9260 section 5.1.3.
+			Utils::Byte::Set8Bytes(buffer, StateCookie::TimestampOffset, creationTimestampMs);
+
+			const uint8_t* mac = Utils::Crypto::GetHmacSha1(
+			  reinterpret_cast<const char*>(macKey), macKeyLength, buffer, StateCookie::MacOffset);
+
+			std::memcpy(buffer + StateCookie::MacOffset, mac, StateCookie::MacLength);
+		}
+
+		bool StateCookie::IsMediasoupStateCookie(const uint8_t* buffer, size_t bufferLength)
+		{
+			MS_TRACE();
+
+			if (bufferLength != StateCookie::StateCookieLength && bufferLength != StateCookie::AuthenticatedStateCookieLength)
+			{
+				return false;
+			}
+
+			if (Utils::Byte::Get8Bytes(buffer, 0) != StateCookie::Magic1)
+			{
+				return false;
+			}
+
+			auto* negotiatedCapabilitiesField = reinterpret_cast<NegotiatedCapabilitiesField*>(
+			  const_cast<uint8_t*>(buffer) + StateCookie::NegotiatedCapabilitiesOffset);
+
+			if (ntohs(negotiatedCapabilitiesField->magic2) != StateCookie::Magic2)
+			{
+				return false;
+			}
+
+			return true;
+		}
+
+		bool StateCookie::VerifyMac(
+		  const uint8_t* buffer, size_t bufferLength, const uint8_t* macKey, size_t macKeyLength)
+		{
+			MS_TRACE();
+
+			// An authenticated cookie has a fixed length.
+			if (bufferLength != StateCookie::AuthenticatedStateCookieLength)
+			{
+				return false;
+			}
+
+			// Recompute the MAC over all bytes preceding the MAC field.
+			const uint8_t* expectedMac = Utils::Crypto::GetHmacSha1(
+			  reinterpret_cast<const char*>(macKey), macKeyLength, buffer, StateCookie::MacOffset);
+
+			return std::memcmp(buffer + StateCookie::MacOffset, expectedMac, StateCookie::MacLength) == 0;
 		}
 
 		Types::SctpImplementation StateCookie::DetermineSctpImplementation(
@@ -158,7 +210,13 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			SetLength(StateCookie::StateCookieLength);
+			// The cookie length is determined by whether it carries a MAC. When the
+			// cookie is cloned into a larger buffer, `CloneInto()` will set the
+			// proper length afterwards.
+			SetLength(
+			  bufferLength == StateCookie::AuthenticatedStateCookieLength
+			    ? StateCookie::AuthenticatedStateCookieLength
+			    : StateCookie::StateCookieLength);
 		}
 
 		StateCookie::~StateCookie()
@@ -183,6 +241,13 @@ namespace RTC
 			  "  remote advertised receiver window credit: %" PRIu32,
 			  GetRemoteAdvertisedReceiverWindowCredit());
 			MS_DUMP_CLEAN(indentation, "  tie-tag: %" PRIu64, GetTieTag());
+			MS_DUMP_CLEAN(indentation, "  authenticated: %s", IsAuthenticated() ? "yes" : "no");
+
+			if (IsAuthenticated())
+			{
+				MS_DUMP_CLEAN(indentation, "  creation timestamp (ms): %" PRIu64, GetCreationTimestampMs());
+			}
+
 			negotiatedCapabilities.Dump(indentation + 1);
 			MS_DUMP_CLEAN(indentation, "</SCTP::StateCookie>");
 		}

package/worker/src/RTC/SCTP/packet/Packet.cpp

@@ -419,7 +419,7 @@ namespace RTC
 
 			auto crc32c = GetChecksum();
 
-			// NOTE: Cannot use SetChecksum() because its a `const` method.
+			// NOTE: Cannot use `SetChecksum()` because this is a `const` method.
 			GetHeaderPointer()->checksum = 0;
 
 			auto computedCrc32c = Utils::Crypto::GetCRC32c(GetBuffer(), GetLength());

package/worker/src/RTC/SCTP/packet/parameters/StateCookieParameter.cpp

@@ -122,7 +122,10 @@ namespace RTC
 		  uint32_t remoteInitialTsn,
 		  uint32_t remoteAdvertisedReceiverWindowCredit,
 		  uint64_t tieTag,
-		  const NegotiatedCapabilities& negotiatedCapabilities)
+		  const NegotiatedCapabilities& negotiatedCapabilities,
+		  uint64_t creationTimestampMs,
+		  const uint8_t* macKey,
+		  size_t macKeyLength)
 		{
 			MS_TRACE();
 
@@ -144,9 +147,15 @@ namespace RTC
 			  remoteInitialTsn,
 			  remoteAdvertisedReceiverWindowCredit,
 			  tieTag,
-			  negotiatedCapabilities);
+			  negotiatedCapabilities,
+			  creationTimestampMs,
+			  macKey,
+			  macKeyLength);
 
-			SetVariableLengthValueLength(StateCookie::StateCookieLength);
+			const size_t cookieLength = macKey != nullptr ? StateCookie::AuthenticatedStateCookieLength
+			                                              : StateCookie::StateCookieLength;
+
+			SetVariableLengthValueLength(cookieLength);
 		}
 
 		StateCookieParameter* StateCookieParameter::SoftClone(const uint8_t* buffer) const

package/worker/src/RTC/SCTP/public/SctpOptions.cpp

@@ -84,6 +84,10 @@ namespace RTC
 			  ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethodToString(
 			    this->zeroChecksumAlternateErrorDetectionMethod)
 			    .c_str());
+			MS_DUMP_CLEAN(
+			  indentation,
+			  "  require authenticated cookie: %s",
+			  this->requireAuthenticatedCookie ? "yes" : "no");
 			MS_DUMP_CLEAN(indentation, "</SCTP::SctpOptions>");
 		}
 	} // namespace SCTP