From c91ae3429fa2b209bc6b89ca77d4c0aad6f47307 Mon Sep 17 00:00:00 2001 From: David Laseca Perez Date: Mon, 16 Nov 2026 12:41:16 +0100 Subject: [PATCH 1/2] Refs #25626. Add maximum deserialization depth Signed-off-by: David Laseca Perez --- src/cpp/Cdr.cpp | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/src/cpp/Cdr.cpp b/src/cpp/Cdr.cpp index 9743ca5e..3cbcd635 100644 --- a/src/cpp/Cdr.cpp +++ b/src/cpp/Cdr.cpp @@ -2513,10 +2513,38 @@ Cdr& Cdr::end_serialize_type( return (this->*end_serialize_type_)(current_state); } +namespace { + +// Maximum nesting of deserialize_type() calls on one thread. Real types stay far below this; +// it only stops remote input from nesting types until the stack overflows. +constexpr uint32_t max_deserialization_depth = 100; + +thread_local uint32_t deserialization_depth = 0; + +struct DeserializationDepthGuard +{ + DeserializationDepthGuard() + { + if (deserialization_depth >= max_deserialization_depth) + { + throw eprosima::fastcdr::exception::BadParamException("Maximum deserialization depth exceeded"); + } + deserialization_depth++; + } + + ~DeserializationDepthGuard() + { + deserialization_depth--; + } +}; + +} // namespace + Cdr& Cdr::deserialize_type( EncodingAlgorithmFlag type_encoding, std::function functor) { + DeserializationDepthGuard guard; return (this->*deserialize_type_)(type_encoding, functor); } From 135befeee335cbe788969db10c12fcfb1142ad6c Mon Sep 17 00:00:00 2001 From: David Laseca Perez Date: Mon, 16 Nov 2026 12:42:17 +0100 Subject: [PATCH 2/2] Refs #25626. Add unit test for the deserialization depth Signed-off-by: David Laseca Perez --- test/xcdr/external.cpp | 67 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) diff --git a/test/xcdr/external.cpp b/test/xcdr/external.cpp index 48491f90..f5e088e2 100644 --- a/test/xcdr/external.cpp +++ b/test/xcdr/external.cpp @@ -13,6 +13,7 @@ // limitations under the License. #include +#include #include @@ -1515,6 +1516,72 @@ TEST_P(XCdrExternalTest, optional_external_to_locked_external) false), exception::BadParamException); } +/// Auxiliary self-recursive class, as XTypes' TypeIdentifier -> PlainMapSTypeDefn -> external. +struct RecursiveExternalClass +{ + bool has_child {false}; + external child; +}; + +namespace eprosima { +namespace fastcdr { + +template<> +void deserialize( + Cdr& cdr, + RecursiveExternalClass& data) +{ + cdr.deserialize_type(cdr.get_encoding_flag(), [&data](Cdr& cdr_inner, const MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + cdr_inner >> data.has_child; + break; + case 1: + if (data.has_child) + { + cdr_inner >> data.child; + } + else + { + ret_value = false; + } + break; + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +} // namespace fastcdr +} // namespace eprosima + +/*! + * @test Tests that a type nested through externals beyond the maximum depth is rejected, instead of + * exhausting the stack. + */ +TEST(XCdrExternalTest, max_nesting_depth) +{ + auto deserialize_nested = [](size_t depth) + { + // In PLAIN_CDR2, each nesting level is encoded as its has_child boolean. + std::vector buffer(depth, 1); + buffer.back() = 0; + FastBuffer fast_buffer(buffer.data(), buffer.size()); + Cdr cdr(fast_buffer, Cdr::DEFAULT_ENDIAN, CdrVersion::XCDRv2); + RecursiveExternalClass data; + cdr >> data; + }; + + // Deeper than any real type, but not enough to exhaust the stack when no limit is enforced. + EXPECT_THROW(deserialize_nested(500), exception::BadParamException); + // A realistic depth is still accepted after a rejection on the same thread. + EXPECT_NO_THROW(deserialize_nested(50)); +} INSTANTIATE_TEST_SUITE_P( XCdrTest,