Add const max_collated_data_roots

Author: SpyCheese

crypto/vm/boc-compression.cpp

@@ -26,6 +26,7 @@
 #include "vm/cellslice.h"
 #include "td/utils/Slice-decl.h"
 #include "td/utils/lz4.h"
+#include "ton/ton-types.h"
 
 namespace vm {
 
@@ -57,7 +58,7 @@ td::Result<std::vector<td::Ref<vm::Cell>>> boc_decompress_baseline_lz4(td::Slice
   }
 
   TRY_RESULT(decompressed, td::lz4_decompress(compressed, decompressed_size));
-  TRY_RESULT(roots, vm::std_boc_deserialize_multi(decompressed, 1000000, true));
+  TRY_RESULT(roots, vm::std_boc_deserialize_multi(decompressed, ton::max_collated_data_roots + 1, true));
   return roots;
 }
 

ton/ton-types.h

@@ -52,6 +52,7 @@ constexpr WorkchainId masterchainId = -1, basechainId = 0, workchainInvalid = 0x
 constexpr ShardId shardIdAll = (1ULL << 63);
 
 constexpr int max_shard_pfx_len = 60;
+constexpr int max_collated_data_roots = 1000000;
 
 enum GlobalCapabilities {
   capIhrEnabled = 1,

validator-session/candidate-serializer.cpp

@@ -79,7 +79,7 @@ td::Result<td::BufferSlice> compress_candidate_data(td::Slice block, td::Slice c
     return td::Status::Error("block candidate should have exactly one root");
   }
   std::vector<td::Ref<vm::Cell>> roots = {boc1.get_root_cell()};
-  TRY_STATUS(boc2.deserialize(collated_data, 1000000));
+  TRY_STATUS(boc2.deserialize(collated_data, max_collated_data_roots));
   for (int i = 0; i < boc2.get_root_count(); ++i) {
     roots.push_back(boc2.get_root_cell(i));
   }
@@ -100,7 +100,7 @@ td::Result<std::pair<td::BufferSlice, td::BufferSlice>> decompress_candidate_dat
     if (decompressed.size() != (size_t)decompressed_size) {
       return td::Status::Error("decompressed size mismatch");
     }
-    TRY_RESULT_ASSIGN(roots, vm::std_boc_deserialize_multi(decompressed, 1000000, true));
+    TRY_RESULT_ASSIGN(roots, vm::std_boc_deserialize_multi(decompressed, max_collated_data_roots + 1, true));
   } else {
     TRY_RESULT_ASSIGN(roots, vm::boc_decompress(compressed, max_decompressed_size));
   }

validator/full-node-serializer.cpp

@@ -153,7 +153,7 @@ static td::Status deserialize_block_full(ton_api::tonNode_dataFull& f, BlockIdEx
 static td::Status deserialize_block_full(ton_api::tonNode_dataFullCompressed& f, BlockIdExt& id, td::BufferSlice& proof,
                                          td::BufferSlice& data, bool& is_proof_link, int max_decompressed_size) {
   TRY_RESULT(decompressed, td::lz4_decompress(f.compressed_, max_decompressed_size));
-  TRY_RESULT(roots, vm::std_boc_deserialize_multi(decompressed, 1000000, true));
+  TRY_RESULT(roots, vm::std_boc_deserialize_multi(decompressed, max_collated_data_roots + 1, true));
   if (roots.size() != 2) {
     return td::Status::Error("expected 2 roots in boc");
   }
@@ -203,7 +203,8 @@ td::Result<td::BufferSlice> serialize_block_candidate_broadcast(BlockIdExt block
   TRY_RESULT(root, vm::std_boc_deserialize(data));
   std::vector<Ref<vm::Cell>> roots = {root};
   if (collated_data) {
-    TRY_RESULT(collated_data_roots, vm::std_boc_deserialize_multi(collated_data.value(), 1000000, true));
+    TRY_RESULT(collated_data_roots,
+               vm::std_boc_deserialize_multi(collated_data.value(), max_collated_data_roots, true));
     roots.insert(roots.end(), collated_data_roots.begin(), collated_data_roots.end());
   }
   TRY_RESULT(data_new, vm::std_boc_serialize_multi(std::move(roots), 2));
@@ -227,7 +228,7 @@ static td::Status deserialize_block_candidate_broadcast(ton_api::tonNode_blockCa
   cc_seqno = obj.catchain_seqno_;
   validator_set_hash = obj.validator_set_hash_;
   TRY_RESULT(decompressed, td::lz4_decompress(obj.compressed_, max_decompressed_data_size));
-  TRY_RESULT(roots, vm::std_boc_deserialize_multi(decompressed, 1000000, true));
+  TRY_RESULT(roots, vm::std_boc_deserialize_multi(decompressed, max_collated_data_roots + 1, true));
   if (roots.empty()) {
     return td::Status::Error("expected at least 1 root in boc");
   }

validator/impl/collated-data-merger.cpp

@@ -134,7 +134,7 @@ void CollatedDataMerger::add_block_candidate_data(BlockIdExt block_id, td::Buffe
     LOG(WARNING) << "Failed to deserialize block data for " << block_id.to_str() << " : " << r_root.error();
     return;
   }
-  auto r_collated_roots = vm::std_boc_deserialize_multi(collated_data, 1000000, true);
+  auto r_collated_roots = vm::std_boc_deserialize_multi(collated_data, max_collated_data_roots, true);
   if (r_collated_roots.is_error()) {
     LOG(WARNING) << "Failed to deserialize collated data for " << block_id.to_str() << " : "
                  << r_collated_roots.error();
@@ -165,7 +165,7 @@ td::Status CollatedDataDeduplicator::add_block_candidate(BlockSeqno seqno, td::S
                                                          td::Slice collated_data) {
   td::Timer timer;
   TRY_RESULT(root, vm::std_boc_deserialize(block_data));
-  TRY_RESULT(collated_roots, vm::std_boc_deserialize_multi(collated_data, 1000000, true));
+  TRY_RESULT(collated_roots, vm::std_boc_deserialize_multi(collated_data, max_collated_data_roots, true));
   std::lock_guard lock{mutex_};
   td::HashSet<vm::CellHash> visited;
   std::function<void(const Ref<vm::Cell> &)> dfs = [&](const Ref<vm::Cell> &cell) {

validator/impl/collator.cpp

@@ -6433,6 +6433,9 @@ bool Collator::create_collated_data() {
   }
 
   // 8. serialize collated data
+  if (collated_roots_.size() > max_collated_data_roots) {
+    return fatal_error(PSTRING() << "too many collated data roots: " << collated_roots_.size());
+  }
   if (collated_roots_.empty()) {
     collated_data_ = td::BufferSlice{0};
   } else {