From e565f0512c1f0ed96f1a8fcc20b005b076e7049b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=A2=D0=BE=D0=BB=D0=BB=D0=B8?= Date: Thu, 12 Nov 2026 14:18:51 +0300 Subject: [PATCH 1/2] sv2: read SetupConnection strings with a one-byte length The spec encodes STR0_255 with a one-byte length, but SetupConnection was read with Bitcoin's CompactSize length. The two agree up to 252 bytes, so a valid 253-255 byte vendor, firmware or other string made sv2-tp reject the message and disconnect the client. --- src/sv2/messages.h | 35 ++++++++++++++++++++++++++++----- src/test/fuzz/sv2_messages.cpp | 7 +++++-- src/test/sv2_connman_tests.cpp | 22 +++++++++++++++++++++ src/test/sv2_messages_tests.cpp | 28 ++++++++++++++++++++++++++ 4 files changed, 85 insertions(+), 7 deletions(-) diff --git a/src/sv2/messages.h b/src/sv2/messages.h index 143acb3a..2e8c1768 100644 --- a/src/sv2/messages.h +++ b/src/sv2/messages.h @@ -35,6 +35,31 @@ inline constexpr uint16_t TEMPLATE_DISTRIBUTION_MAX_VERSION{2}; */ using u24_t = uint8_t[3]; +/** + * Formatter for the STR0_255 and B0_255 types: a one-byte length followed by + * that many bytes. Bitcoin's default string serialization uses a CompactSize + * length instead, which differs from 253 bytes up. + */ +struct Sv2Bytes255Formatter +{ + template + void Ser(Stream& s, const V& v) + { + if (v.size() > 255) throw std::ios_base::failure("B0_255 length limit exceeded"); + s << static_cast(v.size()); + if (!v.empty()) s.write(MakeByteSpan(v)); + } + + template + void Unser(Stream& s, V& v) + { + uint8_t size; + s >> size; + v.resize(size); + if (size != 0) s.read(MakeWritableByteSpan(v)); + } +}; + /** * All the stratum v2 message types handled by the template provider. */ @@ -130,12 +155,12 @@ struct Sv2SetupConnectionMsg >> m_min_version >> m_max_version >> m_required_flags - >> m_endpoint_host + >> Using(m_endpoint_host) >> m_endpoint_port - >> m_vendor - >> m_hardware_version - >> m_firmware - >> m_device_id; + >> Using(m_vendor) + >> Using(m_hardware_version) + >> Using(m_firmware) + >> Using(m_device_id); } }; diff --git a/src/test/fuzz/sv2_messages.cpp b/src/test/fuzz/sv2_messages.cpp index ffb57748..2f748d53 100644 --- a/src/test/fuzz/sv2_messages.cpp +++ b/src/test/fuzz/sv2_messages.cpp @@ -110,8 +110,11 @@ FUZZ_TARGET(sv2_setup_connection, .init = Sv2FuzzInitialize) std::string device_id = FuzzedString(provider); ss << protocol << min_version << max_version << flags - << endpoint_host << endpoint_port - << vendor << hardware_version << firmware << device_id; + << Using(endpoint_host) << endpoint_port + << Using(vendor) + << Using(hardware_version) + << Using(firmware) + << Using(device_id); Sv2SetupConnectionMsg msg; ss >> msg; diff --git a/src/test/sv2_connman_tests.cpp b/src/test/sv2_connman_tests.cpp index b1538049..f2bc7703 100644 --- a/src/test/sv2_connman_tests.cpp +++ b/src/test/sv2_connman_tests.cpp @@ -435,4 +435,26 @@ BOOST_AUTO_TEST_CASE(send_error_removes_client_with_queued_messages) BOOST_CHECK(tester.WaitForClientCount(0)); } +// STR0_255 fields have a one-byte length, so a 255-byte vendor string is valid. +BOOST_AUTO_TEST_CASE(setup_connection_with_255_byte_string) +{ + ConnTester tester{}; + tester.handshake(); + + DataStream ss{}; + ss << node::TEMPLATE_DISTRIBUTION_PROTOCOL << uint16_t{2} << uint16_t{2} << uint32_t{0}; + ss << uint8_t{0} << uint16_t{0}; + ss << uint8_t{255}; + ss.write(MakeByteSpan(std::string(255, 'v'))); + ss << uint8_t{0} << uint8_t{0} << uint8_t{0}; + std::vector bytes(ss.size()); + ss >> MakeWritableByteSpan(bytes); + + node::Sv2NetMsg setup{node::Sv2MsgType::SETUP_CONNECTION, std::move(bytes)}; + tester.RemoteToLocalMsg(setup); + auto [response, response_bytes]{tester.LocalToRemoteMsg()}; + BOOST_CHECK(response.m_msg_type == node::Sv2MsgType::SETUP_CONNECTION_SUCCESS); + BOOST_CHECK(tester.IsFullyConnected()); +} + BOOST_AUTO_TEST_SUITE_END() diff --git a/src/test/sv2_messages_tests.cpp b/src/test/sv2_messages_tests.cpp index 6cbe555b..a88ef106 100644 --- a/src/test/sv2_messages_tests.cpp +++ b/src/test/sv2_messages_tests.cpp @@ -311,4 +311,32 @@ BOOST_AUTO_TEST_CASE(Sv2SubmitSolution_test) BOOST_CHECK_EQUAL(submit_solution.m_ntime, 1661877399); BOOST_CHECK_EQUAL(submit_solution.m_nonce, 58720255); } + +BOOST_AUTO_TEST_CASE(Sv2SetupConnection_long_strings_test) +{ + for (const size_t len : {252, 253, 254, 255}) { + DataStream ss{}; + ss << uint8_t{0} << uint16_t{2} << uint16_t{2} << uint32_t{0}; + ss << uint8_t{0}; // endpoint_host + ss << uint16_t{0}; // endpoint_port + ss << uint8_t(len); // vendor + ss.write(MakeByteSpan(std::string(len, 'v'))); + ss << uint8_t{0} << uint8_t{0}; // hardware_version, firmware + ss << uint8_t{3}; // device_id + ss.write(MakeByteSpan(std::string{"dev"})); + + node::Sv2SetupConnectionMsg setup_conn; + BOOST_CHECK_NO_THROW(ss >> setup_conn); + BOOST_CHECK_EQUAL(setup_conn.m_vendor.size(), len); + BOOST_CHECK_EQUAL(setup_conn.m_device_id, "dev"); + BOOST_CHECK(ss.empty()); + } + + // A length byte announcing more data than the stream holds. + DataStream short_ss{}; + short_ss << uint8_t{255}; + short_ss.write(MakeByteSpan(std::string(254, 'x'))); + std::string str; + BOOST_CHECK_THROW(short_ss >> Using(str), std::ios_base::failure); +} BOOST_AUTO_TEST_SUITE_END() From 6512db01a4dae5a965ab45884f28a287a1047a34 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=A2=D0=BE=D0=BB=D0=BB=D0=B8?= Date: Thu, 12 Nov 2026 14:19:22 +0300 Subject: [PATCH 2/2] sv2: write STR0_255, B0_255 and SEQ0_255 with a one-byte length Error codes, the coinbase prefix and the merkle path were also written with a CompactSize length. The bytes are the same for every value sv2-tp sends today, so this only aligns the code with the spec. Values over 255 now throw instead of producing an invalid message. --- src/sv2/messages.cpp | 2 ++ src/sv2/messages.h | 23 ++++++++++++++++------- src/test/fuzz/sv2_messages.cpp | 4 ++-- src/test/sv2_messages_tests.cpp | 26 ++++++++++++++++++++++++++ 4 files changed, 46 insertions(+), 9 deletions(-) diff --git a/src/sv2/messages.cpp b/src/sv2/messages.cpp index 610d6c71..38b35e9d 100644 --- a/src/sv2/messages.cpp +++ b/src/sv2/messages.cpp @@ -9,6 +9,8 @@ node::Sv2NewTemplateMsg::Sv2NewTemplateMsg(const CBlockHeader& header, const node::CoinbaseTx coinbase, std::vector coinbase_merkle_path, uint64_t template_id, bool future_template) : m_template_id{template_id}, m_future_template{future_template} { + Assert(coinbase_merkle_path.size() <= 255); + m_version = header.nVersion; m_coinbase_tx_version = coinbase.version; diff --git a/src/sv2/messages.h b/src/sv2/messages.h index 2e8c1768..ccfeaecb 100644 --- a/src/sv2/messages.h +++ b/src/sv2/messages.h @@ -60,6 +60,18 @@ struct Sv2Bytes255Formatter } }; +/** Formatter for the SEQ0_255 type: a one-byte element count followed by the elements. */ +struct Sv2Seq255Formatter +{ + template + void Ser(Stream& s, const V& v) + { + if (v.size() > 255) throw std::ios_base::failure("SEQ0_255 length limit exceeded"); + s << static_cast(v.size()); + for (const auto& elem : v) s << elem; + } +}; + /** * All the stratum v2 message types handled by the template provider. */ @@ -264,7 +276,7 @@ struct Sv2SetupConnectionErrorMsg void Serialize(Stream& s) const { s << m_flags - << m_error_code; + << Using(m_error_code); } }; @@ -353,7 +365,7 @@ struct Sv2NewTemplateMsg << m_future_template << m_version << m_coinbase_tx_version - << m_coinbase_prefix + << Using(m_coinbase_prefix) << m_coinbase_tx_input_sequence << m_coinbase_tx_value_remaining << m_coinbase_tx_outputs_count; @@ -377,10 +389,7 @@ struct Sv2NewTemplateMsg } s << m_coinbase_tx_locktime - // Technically using VARINT is a problem for a merkle path longer - // than 127 elements, but a block can't have enough transactions to - // run into that. - << m_merkle_path; + << Using(m_merkle_path); } }; @@ -555,7 +564,7 @@ struct Sv2RequestTransactionDataErrorMsg void Serialize(Stream& s) const { s << m_template_id - << m_error_code; + << Using(m_error_code); } }; diff --git a/src/test/fuzz/sv2_messages.cpp b/src/test/fuzz/sv2_messages.cpp index 2f748d53..92a7cfb1 100644 --- a/src/test/fuzz/sv2_messages.cpp +++ b/src/test/fuzz/sv2_messages.cpp @@ -271,7 +271,7 @@ FUZZ_TARGET(sv2_setup_connection_error, .init = Sv2FuzzInitialize) // Roundtrip: read back serialized fields and verify uint32_t rt_flags; std::string rt_error; - ss >> rt_flags >> rt_error; + ss >> rt_flags >> Using(rt_error); assert(rt_flags == flags); assert(rt_error == error_code_expect); } @@ -365,7 +365,7 @@ FUZZ_TARGET(sv2_request_transaction_data_error, .init = Sv2FuzzInitialize) // Roundtrip: read back serialized fields and verify uint64_t rt_template_id; std::string rt_error; - ss >> rt_template_id >> rt_error; + ss >> rt_template_id >> Using(rt_error); assert(rt_template_id == template_id); assert(rt_error == error_code_expect); } diff --git a/src/test/sv2_messages_tests.cpp b/src/test/sv2_messages_tests.cpp index a88ef106..3514cbb6 100644 --- a/src/test/sv2_messages_tests.cpp +++ b/src/test/sv2_messages_tests.cpp @@ -339,4 +339,30 @@ BOOST_AUTO_TEST_CASE(Sv2SetupConnection_long_strings_test) std::string str; BOOST_CHECK_THROW(short_ss >> Using(str), std::ios_base::failure); } + +BOOST_AUTO_TEST_CASE(Sv2SetupConnectionError_long_error_code_test) +{ + for (const size_t len : {252, 253, 255}) { + node::Sv2SetupConnectionErrorMsg msg{0, std::string(len, 'e')}; + DataStream ss{}; + ss << msg; + BOOST_CHECK_EQUAL(ss.size(), 4 + 1 + len); + BOOST_CHECK_EQUAL(uint8_t(ss[4]), len); + } + node::Sv2SetupConnectionErrorMsg msg{0, std::string(256, 'e')}; + DataStream ss{}; + BOOST_CHECK_THROW(ss << msg, std::ios_base::failure); +} + +BOOST_AUTO_TEST_CASE(Sv2_length_limit_test) +{ + DataStream ss{}; + const std::vector bytes(256); + BOOST_CHECK_THROW(ss << Using(CScript(bytes.begin(), bytes.end())), std::ios_base::failure); + BOOST_CHECK_THROW(ss << Using(std::vector(256)), std::ios_base::failure); + + ss << Using(std::vector(255)); + BOOST_CHECK_EQUAL(ss.size(), 1 + 255 * 32); + BOOST_CHECK_EQUAL(uint8_t(ss[0]), 255); +} BOOST_AUTO_TEST_SUITE_END()