external/ton
1
0
Fork 0
mirror of https://github.com/ton-blockchain/ton synced 2025-02-15 04:32:21 +00:00
Code Issues Releases Wiki Activity

Increase limit for t_Block.validate, simplify validating StateInit (#691)

Browse source 
Co-authored-by: SpyCheese <mikle98@yandex.ru>
This commit is contained in:
EmelyanenkoK 2023-05-03 14:18:18 +03:00
parent 6b0968097a
commit daa714552c
6 changed files with 63 additions and 10 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
crypto/block/block-parse.cpp
View file

@ -2292,5 +2292,37 @@ bool Aug_ShardFees::eval_leaf(vm::CellBuilder& cb, vm::CellSlice& cs) const {
const Aug_ShardFees aug_ShardFees;
bool validate_message_libs(const td::Ref<vm::Cell> &cell) {
gen::Message::Record rec;
if (!type_unpack_cell(cell, gen::t_Message_Any, rec)) {
return false;
}
vm::CellSlice& state_init = rec.init.write();
if (!state_init.fetch_long(1)) {
return true;
}
if (state_init.fetch_long(1)) {
return gen::t_StateInitWithLibs.validate_ref(state_init.prefetch_ref());
} else {
return gen::t_StateInitWithLibs.validate_csr(rec.init);
}
}
bool validate_message_relaxed_libs(const td::Ref<vm::Cell> &cell) {
gen::MessageRelaxed::Record rec;
if (!type_unpack_cell(cell, gen::t_MessageRelaxed_Any, rec)) {
return false;
}
vm::CellSlice& state_init = rec.init.write();
if (!state_init.fetch_long(1)) {
return true;
}
if (state_init.fetch_long(1)) {
return gen::t_StateInitWithLibs.validate_ref(state_init.prefetch_ref());
} else {
return gen::t_StateInitWithLibs.validate_csr(rec.init);
}
}
} // namespace tlb
} // namespace block

4
crypto/block/block-parse.h
View file

@ -1113,5 +1113,9 @@ struct Aug_ShardFees final : AugmentationCheckData {
extern const Aug_ShardFees aug_ShardFees;
// Validate dict of libraries in message: used when sending and receiving message
bool validate_message_libs(const td::Ref<vm::Cell> &cell);
bool validate_message_relaxed_libs(const td::Ref<vm::Cell> &cell);
} // namespace tlb
} // namespace block

9
crypto/block/block.tlb
View file

@ -143,8 +143,13 @@ tick_tock$_ tick:Bool tock:Bool = TickTock;
_ split_depth:(Maybe (## 5)) special:(Maybe TickTock)
code:(Maybe ^Cell) data:(Maybe ^Cell)
library:(HashmapE 256 SimpleLib) = StateInit;
library:(Maybe ^Cell) = StateInit;
// StateInitWithLibs is used to validate sent and received messages
_ split_depth:(Maybe (## 5)) special:(Maybe TickTock)
code:(Maybe ^Cell) data:(Maybe ^Cell)
library:(HashmapE 256 SimpleLib) = StateInitWithLibs;
simple_lib$_ public:Bool root:^Cell = SimpleLib;
message$_ {X:Type} info:CommonMsgInfo

9
crypto/block/transaction.cpp
View file

@ -635,14 +635,15 @@ bool Transaction::unpack_input_msg(bool ihr_delivered, const ActionPhaseConfig*
vm::CellBuilder cb;
if (!(cs.advance(2) && block::gen::t_StateInit.fetch_to(cs, state_init) &&
cb.append_cellslice_bool(std::move(state_init)) && cb.finalize_to(in_msg_state) &&
block::gen::t_StateInit.validate_ref(in_msg_state))) {
block::gen::t_StateInitWithLibs.validate_ref(in_msg_state))) {
LOG(DEBUG) << "cannot parse StateInit in inbound message";
return false;
}
break;
}
case 3: { // (just$1 (right$1 _:^StateInit ))
if (!(cs.advance(2) && cs.fetch_ref_to(in_msg_state) && block::gen::t_StateInit.validate_ref(in_msg_state))) {
if (!(cs.advance(2) && cs.fetch_ref_to(in_msg_state) &&
block::gen::t_StateInitWithLibs.validate_ref(in_msg_state))) {
LOG(DEBUG) << "cannot parse ^StateInit in inbound message";
return false;
}
@ -1534,6 +1535,10 @@ int Transaction::try_action_send_msg(const vm::CellSlice& cs0, ActionPhase& ap,
if (!tlb::type_unpack_cell(act_rec.out_msg, block::gen::t_MessageRelaxed_Any, msg)) {
return -1;
}
if (!block::tlb::validate_message_relaxed_libs(act_rec.out_msg)) {
LOG(DEBUG) << "outbound message has invalid libs in StateInit";
return -1;
}
if (redoing >= 1) {
if (msg.init->size_refs() >= 2) {
LOG(DEBUG) << "moving the StateInit of a suggested outbound message into a separate cell";

11
validator/impl/collator.cpp
View file

@ -2565,7 +2565,7 @@ bool Collator::process_inbound_message(Ref<vm::CellSlice> enq_msg, ton::LogicalT
return false;
}
if (!block::tlb::t_MsgEnvelope.validate_ref(msg_env)) {
LOG(ERROR) << "inbound internal MsgEnvelope is invalid according to automated checks";
LOG(ERROR) << "inbound internal MsgEnvelope is invalid according to hand-written checks";
return false;
}
// 1. unpack MsgEnvelope
@ -2590,6 +2590,10 @@ bool Collator::process_inbound_message(Ref<vm::CellSlice> enq_msg, ton::LogicalT
"its contents";
return false;
}
if (!block::tlb::validate_message_libs(env.msg)) {
LOG(ERROR) << "inbound internal message has invalid StateInit";
return false;
}
// 2.0. update last_proc_int_msg
if (!update_last_proc_int_msg(std::pair<ton::LogicalTime, ton::Bits256>(lt, env.msg->get_hash().bits()))) {
return fatal_error("processing a message AFTER a newer message has been processed");
@ -3876,7 +3880,7 @@ bool Collator::create_block() {
}
if (verify >= 1) {
LOG(INFO) << "verifying new Block";
if (!block::gen::t_Block.validate_ref(1000000, new_block)) {
if (!block::gen::t_Block.validate_ref(10000000, new_block)) {
return fatal_error("new Block failed to pass automatic validity tests");
}
}
@ -4030,6 +4034,9 @@ td::Result<bool> Collator::register_external_message_cell(Ref<vm::Cell> ext_msg,
if (!block::tlb::t_Message.validate_ref(256, ext_msg)) {
return td::Status::Error("external message is not a (Message Any) according to hand-written checks");
}
if (!block::tlb::validate_message_libs(ext_msg)) {
return td::Status::Error("external message has invalid libs in StateInit");
}
block::gen::CommonMsgInfo::Record_ext_in_msg_info info;
if (!tlb::unpack_cell_inexact(ext_msg, info)) {
return td::Status::Error("cannot unpack external message header");

8
validator/impl/validate-query.cpp
View file

@ -2111,13 +2111,13 @@ bool ValidateQuery::unpack_block_data() {
auto outmsg_cs = vm::load_cell_slice_ref(std::move(extra.out_msg_descr));
// run some hand-written checks from block::tlb::
// (automatic tests from block::gen:: have been already run for the entire block)
if (!block::tlb::t_InMsgDescr.validate_upto(1000000, *inmsg_cs)) {
if (!block::tlb::t_InMsgDescr.validate_upto(10000000, *inmsg_cs)) {
return reject_query("InMsgDescr of the new block failed to pass handwritten validity tests");
}
if (!block::tlb::t_OutMsgDescr.validate_upto(1000000, *outmsg_cs)) {
if (!block::tlb::t_OutMsgDescr.validate_upto(10000000, *outmsg_cs)) {
return reject_query("OutMsgDescr of the new block failed to pass handwritten validity tests");
}
if (!block::tlb::t_ShardAccountBlocks.validate_ref(1000000, extra.account_blocks)) {
if (!block::tlb::t_ShardAccountBlocks.validate_ref(10000000, extra.account_blocks)) {
return reject_query("ShardAccountBlocks of the new block failed to pass handwritten validity tests");
}
in_msg_dict_ = std::make_unique<vm::AugmentedDictionary>(std::move(inmsg_cs), 256, block::tlb::aug_InMsgDescr);
@ -5507,7 +5507,7 @@ bool ValidateQuery::try_validate() {
}
}
LOG(INFO) << "running automated validity checks for block candidate " << id_.to_str();
if (!block::gen::t_Block.validate_ref(1000000, block_root_)) {
if (!block::gen::t_Block.validate_ref(10000000, block_root_)) {
return reject_query("block "s + id_.to_str() + " failed to pass automated validity checks");
}
if (!fix_all_processed_upto()) {