From a817ce721d91d7708aa529fda99b92895550e2ea Mon Sep 17 00:00:00 2001
From: Roman Khlopkov <roman.khlopkov@demlabs.net>
Date: Thu, 15 Aug 2024 09:38:54 +0000
Subject: [PATCH] support-12700
---
modules/chain/dap_chain_ch.c | 15 +++++-----
modules/chain/include/dap_chain.h | 6 ++++
.../dap_stream_ch_chain_net_srv.c | 17 ++++++-----
.../chain-net/dap_stream_ch_chain_net.c | 8 +++--
.../chain-net/dap_stream_ch_chain_net_pkt.c | 1 -
modules/common/dap_chain_datum_tx_receipt.c | 28 ++++++++---------
modules/common/include/dap_chain_datum.h | 4 +--
.../consensus/esbocs/dap_chain_cs_esbocs.c | 2 +-
modules/net/dap_chain_ledger.c | 30 ++++++++++++-------
modules/net/srv/dap_chain_net_srv_order.c | 7 +++--
.../net/srv/include/dap_chain_net_srv_order.h | 2 +-
modules/service/vpn/dap_chain_net_srv_vpn.c | 2 --
modules/type/blocks/dap_chain_cs_blocks.c | 4 +--
.../type/blocks/include/dap_chain_cs_blocks.h | 6 ----
modules/type/dag/dap_chain_cs_dag_event.c | 23 +++++++++-----
.../type/dag/include/dap_chain_cs_dag_event.h | 4 +--
16 files changed, 90 insertions(+), 69 deletions(-)
diff --git a/modules/chain/dap_chain_ch.c b/modules/chain/dap_chain_ch.c
index 344e252e38..2f78d6ae01 100644
--- a/modules/chain/dap_chain_ch.c
+++ b/modules/chain/dap_chain_ch.c
@@ -143,7 +143,7 @@ static uint32_t s_sync_packets_per_thread_call = 10;
static uint32_t s_sync_ack_window_size = 512; // atoms
// Legacy
-static uint_fast16_t s_update_pack_size = 100; // Number of hashes packed into the one packet
+static const uint_fast16_t s_update_pack_size = 100; // Number of hashes packed into the one packet
#ifdef DAP_SYS_DEBUG
@@ -653,7 +653,7 @@ static bool s_sync_in_chains_callback(void *a_arg)
break;
}
if (l_ack_send && l_args->ack_req) {
- uint64_t l_ack_num = (l_chain_pkt->hdr.num_hi << 16) | l_chain_pkt->hdr.num_lo;
+ uint64_t l_ack_num = ((uint32_t)l_chain_pkt->hdr.num_hi << 16) | l_chain_pkt->hdr.num_lo;
dap_chain_ch_pkt_t *l_pkt = dap_chain_ch_pkt_new(l_chain_pkt->hdr.net_id, l_chain_pkt->hdr.chain_id, l_chain_pkt->hdr.cell_id,
&l_ack_num, sizeof(uint64_t), DAP_CHAIN_CH_PKT_VERSION_CURRENT);
dap_stream_ch_pkt_send_by_addr(&l_args->addr, DAP_CHAIN_CH_ID, DAP_CHAIN_CH_PKT_TYPE_CHAIN_ACK, l_pkt, dap_chain_ch_pkt_get_size(l_pkt));
@@ -745,7 +745,7 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
} break;
case DAP_CHAIN_CH_PKT_TYPE_CHAIN: {
- if (!l_chain_pkt_data_size) {
+ if (!l_chain_pkt_data_size || l_chain_pkt_data_size > sizeof(dap_chain_ch_pkt_t) + DAP_CHAIN_ATOM_MAX_SIZE) {
log_it(L_WARNING, "Incorrect data size %zu in packet %s", l_chain_pkt_data_size,
dap_chain_ch_pkt_type_to_str(l_ch_pkt->hdr.type));
dap_stream_ch_write_error_unsafe(a_ch, l_chain_pkt->hdr.net_id,
@@ -1100,7 +1100,7 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
// Response with gdb element hashes and sizes
case DAP_CHAIN_CH_PKT_TYPE_UPDATE_GLOBAL_DB: {
- if (l_chain_pkt_data_size % sizeof(dap_chain_ch_update_element_t)) {
+ if (l_chain_pkt_data_size % sizeof(dap_chain_ch_update_element_t) || l_chain_pkt_data_size > UINT16_MAX) {
log_it(L_WARNING, "Incorrect data size %zu in packet %s", l_chain_pkt_data_size,
dap_chain_ch_pkt_type_to_str(l_ch_pkt->hdr.type));
dap_stream_ch_write_error_unsafe(a_ch, l_chain_pkt->hdr.net_id,
@@ -1213,7 +1213,8 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
case DAP_CHAIN_CH_PKT_TYPE_GLOBAL_DB: {
dap_global_db_pkt_old_t *l_pkt = (dap_global_db_pkt_old_t *)l_chain_pkt->data;
if (l_chain_pkt_data_size < sizeof(dap_global_db_pkt_old_t) ||
- l_chain_pkt_data_size != sizeof(*l_pkt) + l_pkt->data_size) {
+ (uint64_t)sizeof(*l_pkt) + l_pkt->data_size < l_pkt->data_size ||
+ l_chain_pkt_data_size != (uint64_t)sizeof(*l_pkt) + l_pkt->data_size) {
log_it(L_WARNING, "Incorrect data size %zu in packet %s", l_chain_pkt_data_size,
dap_chain_ch_pkt_type_to_str(l_ch_pkt->hdr.type));
dap_stream_ch_write_error_unsafe(a_ch, l_chain_pkt->hdr.net_id,
@@ -1352,7 +1353,7 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
// Response with atom hashes and sizes
case DAP_CHAIN_CH_PKT_TYPE_UPDATE_CHAINS: {
- if (l_chain_pkt_data_size > sizeof(dap_chain_ch_update_element_t) * s_update_pack_size) {
+ if (l_chain_pkt_data_size % sizeof(dap_chain_ch_update_element_t) || l_chain_pkt_data_size > UINT16_MAX) {
log_it(L_WARNING, "Incorrect data size %zu in packet %s", l_chain_pkt_data_size,
dap_chain_ch_pkt_type_to_str(l_ch_pkt->hdr.type));
dap_stream_ch_write_error_unsafe(a_ch, l_chain_pkt->hdr.net_id,
@@ -1469,7 +1470,7 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
} break;
case DAP_CHAIN_CH_PKT_TYPE_CHAIN_OLD: {
- if (!l_chain_pkt_data_size) {
+ if (!l_chain_pkt_data_size || l_chain_pkt_data_size > sizeof(dap_chain_ch_pkt_t) + DAP_CHAIN_ATOM_MAX_SIZE) {
log_it(L_WARNING, "Incorrect data size %zu in packet %s", l_chain_pkt_data_size,
dap_chain_ch_pkt_type_to_str(l_ch_pkt->hdr.type));
dap_stream_ch_write_error_unsafe(a_ch, l_chain_pkt->hdr.net_id,
diff --git a/modules/chain/include/dap_chain.h b/modules/chain/include/dap_chain.h
index 825915ef41..a177889b13 100644
--- a/modules/chain/include/dap_chain.h
+++ b/modules/chain/include/dap_chain.h
@@ -30,6 +30,12 @@
#include "dap_chain_common.h"
#include "dap_chain_datum.h"
+#ifdef DAP_TPS_TEST
+#define DAP_CHAIN_ATOM_MAX_SIZE (100 * 1024 * 1024)
+#else
+#define DAP_CHAIN_ATOM_MAX_SIZE (256 * 1024) // 256 KB
+#endif
+
typedef struct dap_chain dap_chain_t;
typedef struct dap_chain_cell dap_chain_cell_t;
diff --git a/modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c b/modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c
index 75f0adec6b..5dcf39ce43 100644
--- a/modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c
+++ b/modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c
@@ -769,7 +769,7 @@ static bool s_grace_period_start(dap_chain_net_srv_grace_t *a_grace)
if ( !l_price ) {
log_it( L_WARNING, "Request can't be processed because no acceptable price in pricelist for token %s in network %s",
l_ticker, l_net->pub.name );
- l_err.code =DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR_CODE_TX_COND_NOT_ACCEPT_TOKEN;
+ l_err.code = DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR_CODE_TX_COND_NOT_ACCEPT_TOKEN;
s_grace_error(a_grace, l_err);
return false;
}
@@ -1265,6 +1265,12 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t *a_ch, void *a_arg)
return false;
}
pkt_test_t *l_request = (pkt_test_t*)l_ch_pkt->data;
+ if (l_request->data_size_recv > DAP_CHAIN_NET_SRV_CH_REQUEST_SIZE_MAX || l_request->data_size > DAP_CHAIN_NET_SRV_CH_REQUEST_SIZE_MAX) {
+ log_it(L_WARNING, "Too large payload %zu [pkt seq %"DAP_UINT64_FORMAT_U"]", l_request->data_size_recv, l_ch_pkt->hdr.seq_id);
+ l_err.code = DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR_CODE_BIG_SIZE;
+ dap_stream_ch_pkt_write_unsafe(a_ch, DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR, &l_err, sizeof(l_err));
+ return false;
+ }
size_t l_request_size = l_request->data_size + sizeof(pkt_test_t);
if (l_ch_pkt->hdr.data_size != l_request_size) {
log_it(L_WARNING, "Wrong CHECK_REQUEST size %u, must be %zu [pkt seq %"DAP_UINT64_FORMAT_U"]", l_ch_pkt->hdr.data_size, l_request_size, l_ch_pkt->hdr.seq_id);
@@ -1272,14 +1278,8 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t *a_ch, void *a_arg)
dap_stream_ch_pkt_write_unsafe(a_ch, DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR, &l_err, sizeof(l_err));
return false;
}
- if(l_request->data_size_recv > DAP_CHAIN_NET_SRV_CH_REQUEST_SIZE_MAX) {
- log_it(L_WARNING, "Too large payload %zu [pkt seq %"DAP_UINT64_FORMAT_U"]", l_request->data_size_recv, l_ch_pkt->hdr.seq_id);
- l_err.code = DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR_CODE_BIG_SIZE;
- dap_stream_ch_pkt_write_unsafe(a_ch, DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR, &l_err, sizeof(l_err));
- return false;
- }
dap_chain_hash_fast_t l_data_hash;
- dap_hash_fast(l_request->data, l_request->data_size, &l_data_hash);
+ dap_hash_fast(l_request->data, l_request->data_size, &l_data_hash); // TODO change it to less CPU consuming algorithm
if (l_request->data_size > 0 && !dap_hash_fast_compare(&l_data_hash, &l_request->data_hash)) {
log_it(L_WARNING, "Wrong hash [pkt seq %"DAP_UINT64_FORMAT_U"]", l_ch_pkt->hdr.seq_id);
l_err.code = DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR_CODE_WRONG_HASH;
@@ -1353,6 +1353,7 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t *a_ch, void *a_arg)
return false;
}
dap_chain_datum_tx_receipt_t * l_receipt = (dap_chain_datum_tx_receipt_t *) l_ch_pkt->data;
+ // TODO calculate actual receipt size and compare it with provided packet size
size_t l_receipt_size = l_ch_pkt->hdr.data_size;
bool l_is_found = false;
diff --git a/modules/channel/chain-net/dap_stream_ch_chain_net.c b/modules/channel/chain-net/dap_stream_ch_chain_net.c
index 3039ce38e7..fe4c18c862 100644
--- a/modules/channel/chain-net/dap_stream_ch_chain_net.c
+++ b/modules/channel/chain-net/dap_stream_ch_chain_net.c
@@ -125,20 +125,24 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t *a_ch, void* a_arg)
return false;
}
dap_stream_ch_chain_net_pkt_t *l_ch_chain_net_pkt = (dap_stream_ch_chain_net_pkt_t *)l_ch_pkt->data;
- if (l_ch_chain_net_pkt->hdr.data_size + sizeof(dap_stream_ch_chain_net_pkt_t) > l_ch_pkt->hdr.data_size) {
+ if ((uint32_t)l_ch_chain_net_pkt->hdr.data_size + sizeof(dap_stream_ch_chain_net_pkt_t) > l_ch_pkt->hdr.data_size) {
log_it(L_WARNING, "Too small stream channel N packet size %u (expected at least %zu)",
l_ch_pkt->hdr.data_size, l_ch_chain_net_pkt->hdr.data_size + sizeof(dap_stream_ch_chain_net_pkt_t));
return false;
}
dap_chain_net_t *l_net = dap_chain_net_by_id(l_ch_chain_net_pkt->hdr.net_id);
if (!l_net) {
- log_it(L_ERROR, "Invalid net id in packet");
+ log_it(L_ERROR, "Invalid net id 0x%016" DAP_UINT64_FORMAT_x " in stream channel N packet", l_ch_chain_net_pkt->hdr.net_id.uint64);
char l_err_str[] = "ERROR_NET_INVALID_ID";
dap_stream_ch_chain_net_pkt_write(a_ch, DAP_STREAM_CH_CHAIN_NET_PKT_TYPE_ERROR ,
l_ch_chain_net_pkt->hdr.net_id, l_err_str, sizeof(l_err_str));
return false;
}
if (l_ch_pkt->hdr.type == DAP_STREAM_CH_CHAIN_NET_PKT_TYPE_ERROR) {
+ if (l_ch_chain_net_pkt->data[l_ch_chain_net_pkt->hdr.data_size - 1] != '\0') {
+ log_it(L_WARNING, "Invalid error string format with no trailing zero");
+ return false;
+ }
char *l_err_str = (char *)l_ch_chain_net_pkt->data;
log_it(L_WARNING, "Stream channel N for network communication got error on other side: %s", l_err_str);
if (a_ch->stream->authorized) {
diff --git a/modules/channel/chain-net/dap_stream_ch_chain_net_pkt.c b/modules/channel/chain-net/dap_stream_ch_chain_net_pkt.c
index 24be3ab116..a53bb80396 100644
--- a/modules/channel/chain-net/dap_stream_ch_chain_net_pkt.c
+++ b/modules/channel/chain-net/dap_stream_ch_chain_net_pkt.c
@@ -19,7 +19,6 @@
#include <dap_stream.h>
#include <dap_stream_pkt.h>
#include <dap_stream_ch_pkt.h>
-#include "dap_stream_ch_chain_net.h"
#include "dap_stream_ch_chain_net_pkt.h"
#define LOG_TAG "dap_stream_ch_chain_net_pkt"
diff --git a/modules/common/dap_chain_datum_tx_receipt.c b/modules/common/dap_chain_datum_tx_receipt.c
index b4e4c836c4..51a4dda42b 100644
--- a/modules/common/dap_chain_datum_tx_receipt.c
+++ b/modules/common/dap_chain_datum_tx_receipt.c
@@ -96,26 +96,26 @@ dap_chain_datum_tx_receipt_t *dap_chain_datum_tx_receipt_sign_add(dap_chain_datu
* @param a_sign_position
* @return
*/
-dap_sign_t* dap_chain_datum_tx_receipt_sign_get(dap_chain_datum_tx_receipt_t *a_receipt, size_t a_receipt_size, uint16_t a_sign_position)
+dap_sign_t *dap_chain_datum_tx_receipt_sign_get(dap_chain_datum_tx_receipt_t *a_receipt, size_t a_receipt_size, uint16_t a_sign_position)
{
dap_return_val_if_fail(a_receipt && a_receipt_size == a_receipt->size &&
+ a_receipt_size > a_receipt->exts_size &&
a_receipt_size >= sizeof(dap_chain_datum_tx_receipt_t) + a_receipt->exts_size,
NULL);
- if (a_receipt_size < sizeof(dap_chain_datum_tx_receipt_t) + a_receipt->exts_size + sizeof(dap_sign_t))
- return NULL; // No signs at all
- dap_sign_t *l_sign = (dap_sign_t *)(a_receipt->exts_n_signs + a_receipt->exts_size);
+ uint64_t l_offset = a_receipt->exts_size;
uint16_t l_sign_position;
- for (l_sign_position = a_sign_position;
- l_sign_position && a_receipt_size > (size_t)((byte_t *)l_sign - (byte_t *)a_receipt) + sizeof(dap_sign_t);
- l_sign_position--) {
- l_sign = (dap_sign_t *)((byte_t *)l_sign + dap_sign_get_size(l_sign));
+ dap_sign_t *l_sign = NULL;
+ for (l_sign_position = a_sign_position + 1; l_sign_position; l_sign_position--) {
+ l_sign = (dap_sign_t *)(a_receipt->exts_n_signs + l_offset);
+ // not enough signs in receipt
+ if (sizeof(dap_chain_datum_tx_receipt_t) + l_offset + sizeof(dap_sign_t) > a_receipt_size)
+ return NULL;
+ uint64_t l_sign_size = dap_sign_get_size(l_sign);
+ // incorrect sign size
+ if (!l_sign_size || l_offset + l_sign_size < l_offset)
+ return NULL;
+ l_offset += l_sign_size;
}
- // not enough signs in receipt
- if (l_sign_position > 0)
- return NULL;
- // too big sign size
- if (dap_sign_get_size(l_sign) + ((byte_t *)l_sign - a_receipt->exts_n_signs) + sizeof(dap_chain_datum_tx_receipt_t) > a_receipt_size)
- return NULL;
return l_sign;
}
diff --git a/modules/common/include/dap_chain_datum.h b/modules/common/include/dap_chain_datum.h
index 74f39e9ca3..8227287524 100644
--- a/modules/common/include/dap_chain_datum.h
+++ b/modules/common/include/dap_chain_datum.h
@@ -134,11 +134,11 @@ typedef struct dap_chain_datum{
* @param a_datum
* @return
*/
-DAP_STATIC_INLINE size_t dap_chain_datum_size(const dap_chain_datum_t *a_datum)
+DAP_STATIC_INLINE uint64_t dap_chain_datum_size(const dap_chain_datum_t *a_datum)
{
if (!a_datum)
return 0;
- return sizeof(a_datum->header) + a_datum->header.data_size;
+ return (uint64_t)sizeof(a_datum->header) + a_datum->header.data_size;
}
DAP_STATIC_INLINE void dap_chain_datum_calc_hash(const dap_chain_datum_t *a_datum, dap_hash_fast_t *a_out_hash)
diff --git a/modules/consensus/esbocs/dap_chain_cs_esbocs.c b/modules/consensus/esbocs/dap_chain_cs_esbocs.c
index 41b5a23e71..25089be78b 100644
--- a/modules/consensus/esbocs/dap_chain_cs_esbocs.c
+++ b/modules/consensus/esbocs/dap_chain_cs_esbocs.c
@@ -2109,7 +2109,7 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t *a_ch, void *a_arg)
dap_chain_esbocs_message_t *l_message = (dap_chain_esbocs_message_t *)l_ch_pkt->data;
size_t l_message_size = l_ch_pkt->hdr.data_size;
if (l_message_size < sizeof(dap_chain_esbocs_message_t) ||
- l_message_size > DAP_CHAIN_CS_BLOCKS_MAX_BLOCK_SIZE + PKT_SIGN_N_HDR_OVERHEAD ||
+ l_message_size > DAP_CHAIN_ATOM_MAX_SIZE + PKT_SIGN_N_HDR_OVERHEAD ||
l_message_size != sizeof(*l_message) + l_message->hdr.sign_size + l_message->hdr.message_size) {
log_it(L_WARNING, "Invalid message size %zu, drop this packet", l_message_size);
return false;
diff --git a/modules/net/dap_chain_ledger.c b/modules/net/dap_chain_ledger.c
index 2b6e49df66..a35ddf846b 100644
--- a/modules/net/dap_chain_ledger.c
+++ b/modules/net/dap_chain_ledger.c
@@ -603,17 +603,17 @@ static int s_token_tsd_parse(dap_ledger_token_item_t *a_item_apply_to, dap_chain
l_was_tx_send_allow_copied = false, l_was_tx_send_block_copied = false;
int ret = DAP_LEDGER_CHECK_OK;
- size_t l_tsd_size = 0;
+ uint64_t l_tsd_size = 0;
dap_tsd_t *l_tsd = (dap_tsd_t *)a_tsd;
- for (size_t l_offset = 0; l_offset < a_tsd_total_size; l_offset += l_tsd_size) {
- if (l_offset + sizeof(dap_tsd_t) > a_tsd_total_size) {
+ for (uint64_t l_offset = 0; l_offset < a_tsd_total_size; l_offset += l_tsd_size) {
+ if (l_offset + sizeof(dap_tsd_t) > a_tsd_total_size || l_offset + sizeof(dap_tsd_t) < l_offset) {
log_it(L_WARNING, "Incorrect TSD section size, less than header");
ret = DAP_LEDGER_CHECK_INVALID_SIZE;
goto ret_n_clear;
}
l_tsd = (dap_tsd_t *)((byte_t *)l_tsd + l_tsd_size);
l_tsd_size = dap_tsd_size(l_tsd);
- if (l_offset + l_tsd_size > a_tsd_total_size) {
+ if (l_offset + l_tsd_size > a_tsd_total_size || l_offset + l_tsd_size < l_offset) {
log_it(L_WARNING, "Wrong TSD size %zu, exiting TSD parse", l_tsd_size);
ret = DAP_LEDGER_CHECK_INVALID_SIZE;
goto ret_n_clear;
@@ -1459,7 +1459,8 @@ int s_token_add_check(dap_ledger_t *a_ledger, byte_t *a_token, size_t a_token_si
return DAP_LEDGER_CHECK_PARSE_ERROR;
}
}
- if (l_token_size < sizeof(dap_chain_datum_token_t) + l_size_tsd_section) {
+ if (sizeof(dap_chain_datum_token_t) + l_size_tsd_section > l_token_size ||
+ sizeof(dap_chain_datum_token_t) + l_size_tsd_section < l_size_tsd_section) {
log_it(L_WARNING, "Incorrect size %zu of datum token, expected at least %zu", l_token_size,
sizeof(dap_chain_datum_token_t) + l_size_tsd_section);
DAP_DELETE(l_token);
@@ -1467,16 +1468,23 @@ int s_token_add_check(dap_ledger_t *a_ledger, byte_t *a_token, size_t a_token_si
}
// Check signs
byte_t *l_signs_ptr = l_token->tsd_n_signs + l_size_tsd_section;
- size_t l_signs_size = 0, l_signs_offset = sizeof(dap_chain_datum_token_t) + l_size_tsd_section;
+ uint64_t l_signs_size = 0, l_signs_offset = sizeof(dap_chain_datum_token_t) + l_size_tsd_section;
for (uint16_t l_signs_passed = 0; l_signs_passed < l_token->signs_total; l_signs_passed++) {
dap_sign_t *l_sign = (dap_sign_t *)(l_signs_ptr + l_signs_size);
- if (l_token_size < l_signs_offset + l_signs_size + sizeof(dap_sign_t)) {
+ if (l_signs_offset + l_signs_size + sizeof(dap_sign_t) > l_token_size ||
+ l_signs_offset + l_signs_size + sizeof(dap_sign_t) < l_signs_offset) {
log_it(L_WARNING, "Incorrect size %zu of datum token, expected at least %zu", l_token_size,
l_signs_offset + l_signs_size + sizeof(dap_sign_t));
DAP_DELETE(l_token);
return DAP_LEDGER_CHECK_INVALID_SIZE;
}
- l_signs_size += dap_sign_get_size(l_sign);
+ uint64_t l_sign_size = dap_sign_get_size(l_sign);
+ if (!l_sign_size || l_sign_size + l_signs_size < l_signs_size) {
+ log_it(L_WARNING, "Incorrect size %zu of datum token sign", l_sign_size);
+ DAP_DELETE(l_token);
+ return DAP_LEDGER_CHECK_INVALID_SIZE;
+ }
+ l_signs_size += l_sign_size;
}
if (l_token_size != l_signs_offset + l_signs_size) {
log_it(L_WARNING, "Incorrect size %zu of datum token, expected %zu", l_token_size, l_signs_offset + l_signs_size);
@@ -2799,7 +2807,8 @@ int s_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_
switch (l_emission->hdr.type) {
case DAP_CHAIN_DATUM_TOKEN_EMISSION_TYPE_AUTH: {
- size_t l_sign_data_check_size = sizeof(dap_chain_datum_token_emission_t) + l_emission->data.type_auth.tsd_total_size;
+ size_t l_sign_data_check_size = sizeof(dap_chain_datum_token_emission_t) + l_emission->data.type_auth.tsd_total_size >= sizeof(dap_chain_datum_token_emission_t)
+ ? sizeof(dap_chain_datum_token_emission_t) + l_emission->data.type_auth.tsd_total_size : 0;
if (l_sign_data_check_size > l_emission_size) {
if (!s_check_hal(a_ledger, a_emission_hash)) {
log_it(L_WARNING, "Incorrect size %zu of datum emission, expected at least %zu", l_emission_size, l_sign_data_check_size);
@@ -2808,7 +2817,8 @@ int s_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_
}
goto ret_success;
}
- size_t l_emission_check_size = sizeof(dap_chain_datum_token_emission_t) + l_emission->data.type_auth.tsd_n_signs_size;
+ size_t l_emission_check_size = sizeof(dap_chain_datum_token_emission_t) + l_emission->data.type_auth.tsd_n_signs_size >= sizeof(dap_chain_datum_token_emission_t)
+ ? sizeof(dap_chain_datum_token_emission_t) + l_emission->data.type_auth.tsd_n_signs_size : 0;
if (l_emission_check_size != l_emission_size) {
log_it(L_WARNING, "Incorrect size %zu of datum emission, must be %zu", l_emission_size, l_emission_check_size);
DAP_DELETE(l_emission);
diff --git a/modules/net/srv/dap_chain_net_srv_order.c b/modules/net/srv/dap_chain_net_srv_order.c
index f8d627ae2f..9dd95fdcd9 100644
--- a/modules/net/srv/dap_chain_net_srv_order.c
+++ b/modules/net/srv/dap_chain_net_srv_order.c
@@ -81,13 +81,14 @@ void dap_chain_net_srv_order_deinit()
}
-size_t dap_chain_net_srv_order_get_size(const dap_chain_net_srv_order_t *a_order)
+uint64_t dap_chain_net_srv_order_get_size(const dap_chain_net_srv_order_t *a_order)
{
if (!a_order || a_order->version != 3)
return 0;
dap_sign_t *l_sign = (dap_sign_t *)(a_order->ext_n_sign + a_order->ext_size);
- size_t l_sign_size = l_sign->header.type.type == SIG_TYPE_NULL ? sizeof(dap_sign_type_t) : dap_sign_get_size(l_sign);
- return sizeof(dap_chain_net_srv_order_t) + a_order->ext_size + l_sign_size;
+ uint64_t l_sign_size = l_sign->header.type.type == SIG_TYPE_NULL ? sizeof(dap_sign_type_t) : dap_sign_get_size(l_sign);
+ uint64_t l_size_without_sign = (uint64_t)sizeof(dap_chain_net_srv_order_t) + a_order->ext_size;
+ return l_size_without_sign + l_sign_size < l_size_without_sign ? 0 : l_size_without_sign + l_sign_size;
}
const dap_chain_net_srv_order_t *dap_chain_net_srv_order_check(const char *a_order_hash_str, const byte_t *a_order, size_t a_order_size)
diff --git a/modules/net/srv/include/dap_chain_net_srv_order.h b/modules/net/srv/include/dap_chain_net_srv_order.h
index 0898053d89..5d20752b1e 100644
--- a/modules/net/srv/include/dap_chain_net_srv_order.h
+++ b/modules/net/srv/include/dap_chain_net_srv_order.h
@@ -55,7 +55,7 @@ typedef struct dap_chain_net_srv_order
int dap_chain_net_srv_order_init();
void dap_chain_net_srv_order_deinit(void);
-size_t dap_chain_net_srv_order_get_size(const dap_chain_net_srv_order_t *a_order);
+uint64_t dap_chain_net_srv_order_get_size(const dap_chain_net_srv_order_t *a_order);
const dap_chain_net_srv_order_t *dap_chain_net_srv_order_check(const char *a_order_hash_str, const byte_t *a_order, size_t a_order_size);
bool dap_chain_net_srv_order_set_continent_region(dap_chain_net_srv_order_t **a_order, uint8_t a_continent_num, const char *a_region);
diff --git a/modules/service/vpn/dap_chain_net_srv_vpn.c b/modules/service/vpn/dap_chain_net_srv_vpn.c
index 20dafcd7e8..b4f4f2984c 100644
--- a/modules/service/vpn/dap_chain_net_srv_vpn.c
+++ b/modules/service/vpn/dap_chain_net_srv_vpn.c
@@ -1065,8 +1065,6 @@ static int s_callback_receipt_next_success(dap_chain_net_srv_t * a_srv, uint32_t
const dap_chain_datum_tx_receipt_t * l_receipt_next = (const dap_chain_datum_tx_receipt_t *) a_receipt_next;
size_t l_receipt_next_size = a_receipt_next_size;
-
-
log_it(L_INFO, "Next receipt successfuly accepted");
// usage is present, we've accepted packets
dap_stream_ch_set_ready_to_read_unsafe( l_srv_ch_vpn->ch , true );
diff --git a/modules/type/blocks/dap_chain_cs_blocks.c b/modules/type/blocks/dap_chain_cs_blocks.c
index 1caca8b140..70a5e4fc3d 100644
--- a/modules/type/blocks/dap_chain_cs_blocks.c
+++ b/modules/type/blocks/dap_chain_cs_blocks.c
@@ -2313,8 +2313,8 @@ static size_t s_callback_add_datums(dap_chain_t *a_chain, dap_chain_datum_t **a_
log_it(L_WARNING, "Empty datum"); /* How might it be? */
continue;
}
- if (l_blocks->block_new_size + l_datum_size > DAP_CHAIN_CS_BLOCKS_MAX_BLOCK_SIZE) {
- log_it(L_DEBUG, "Maximum size exeeded, %zu > %d", l_blocks->block_new_size + l_datum_size, DAP_CHAIN_CS_BLOCKS_MAX_BLOCK_SIZE);
+ if (l_blocks->block_new_size + l_datum_size > DAP_CHAIN_ATOM_MAX_SIZE) {
+ log_it(L_DEBUG, "Maximum size exeeded, %zu > %d", l_blocks->block_new_size + l_datum_size, DAP_CHAIN_ATOM_MAX_SIZE);
break;
}
if (!l_blocks->block_new) {
diff --git a/modules/type/blocks/include/dap_chain_cs_blocks.h b/modules/type/blocks/include/dap_chain_cs_blocks.h
index 69a25180ca..dd538ac6bc 100644
--- a/modules/type/blocks/include/dap_chain_cs_blocks.h
+++ b/modules/type/blocks/include/dap_chain_cs_blocks.h
@@ -26,12 +26,6 @@
#include "dap_chain_block.h"
#include "dap_chain_block_cache.h"
-#ifdef DAP_TPS_TEST
-#define DAP_CHAIN_CS_BLOCKS_MAX_BLOCK_SIZE (100 * 1024 * 1024)
-#else
-#define DAP_CHAIN_CS_BLOCKS_MAX_BLOCK_SIZE (256 * 1024) // 256 KB
-#endif
-
#define DAP_FORK_MAX_DEPTH 100
#define DAP_REWARD_INIT_TIMESTAMP 1700870400UL // 25 Nov 2023 00:00:00 GMT
diff --git a/modules/type/dag/dap_chain_cs_dag_event.c b/modules/type/dag/dap_chain_cs_dag_event.c
index 8bce113cf5..8e4fc06012 100644
--- a/modules/type/dag/dap_chain_cs_dag_event.c
+++ b/modules/type/dag/dap_chain_cs_dag_event.c
@@ -100,16 +100,16 @@ dap_chain_cs_dag_event_t *dap_chain_cs_dag_event_new(dap_chain_id_t a_chain_id,
* @param a_event
* @return
*/
-size_t dap_chain_cs_dag_event_calc_size_excl_signs(dap_chain_cs_dag_event_t *a_event, size_t a_limit_size)
+uint64_t dap_chain_cs_dag_event_calc_size_excl_signs(dap_chain_cs_dag_event_t *a_event, uint64_t a_limit_size)
{
dap_return_val_if_fail(a_event, 0);
if (a_limit_size && a_limit_size < sizeof(a_event->header))
return 0;
- size_t l_hashes_size = a_event->header.hash_count * sizeof(dap_chain_hash_fast_t);
+ uint32_t l_hashes_size = a_event->header.hash_count * sizeof(dap_chain_hash_fast_t);
if (a_limit_size && a_limit_size < l_hashes_size + sizeof(a_event->header) + sizeof(dap_chain_datum_t))
return 0;
- dap_chain_datum_t *l_datum = (dap_chain_datum_t*) (a_event->hashes_n_datum_n_signs + l_hashes_size);
- size_t l_ret = dap_chain_datum_size(l_datum) + l_hashes_size + sizeof(a_event->header);
+ dap_chain_datum_t *l_datum = (dap_chain_datum_t *)(a_event->hashes_n_datum_n_signs + l_hashes_size);
+ uint64_t l_ret = dap_chain_datum_size(l_datum) + l_hashes_size + sizeof(a_event->header);
if (a_limit_size && a_limit_size < l_ret)
return 0;
return l_ret;
@@ -120,21 +120,28 @@ size_t dap_chain_cs_dag_event_calc_size_excl_signs(dap_chain_cs_dag_event_t *a_e
* @param a_event
* @return
*/
-size_t dap_chain_cs_dag_event_calc_size(dap_chain_cs_dag_event_t *a_event, size_t a_limit_size)
+uint64_t dap_chain_cs_dag_event_calc_size(dap_chain_cs_dag_event_t *a_event, uint64_t a_limit_size)
{
dap_return_val_if_fail(a_event, 0);
- size_t l_signs_offset = dap_chain_cs_dag_event_calc_size_excl_signs(a_event, a_limit_size);
+ uint64_t l_signs_offset = dap_chain_cs_dag_event_calc_size_excl_signs(a_event, a_limit_size);
if (!l_signs_offset)
return 0;
byte_t *l_signs = (byte_t *)a_event + l_signs_offset;
size_t l_signs_size = 0;
for (uint16_t l_signs_passed = 0; l_signs_passed < a_event->header.signs_count; l_signs_passed++) {
dap_sign_t *l_sign = (dap_sign_t *)(l_signs + l_signs_size);
+ if (l_signs_offset + l_signs_size + sizeof(dap_sign_t) <= l_signs_offset)
+ return 0;
if (a_limit_size && a_limit_size < l_signs_offset + l_signs_size + sizeof(dap_sign_t))
return 0;
- l_signs_size += dap_sign_get_size(l_sign);
+ uint64_t l_sign_size = dap_sign_get_size(l_sign);
+ if (!l_sign_size)
+ break;
+ if (l_signs_size + l_sign_size <= l_signs_size)
+ return 0;
+ l_signs_size += l_sign_size;
}
- size_t l_total_size = l_signs_offset + l_signs_size;
+ size_t l_total_size = l_signs_offset + l_signs_size <= l_signs_offset ? 0 : l_signs_offset + l_signs_size;
return a_limit_size && l_total_size > a_limit_size ? 0 : l_total_size;
}
diff --git a/modules/type/dag/include/dap_chain_cs_dag_event.h b/modules/type/dag/include/dap_chain_cs_dag_event.h
index 5f4d6a1c94..4de1d9055b 100644
--- a/modules/type/dag/include/dap_chain_cs_dag_event.h
+++ b/modules/type/dag/include/dap_chain_cs_dag_event.h
@@ -90,8 +90,8 @@ bool dap_chain_cs_dag_event_sign_exists(dap_chain_cs_dag_event_t *a_event, size_
bool dap_chain_cs_dag_event_round_sign_exists(dap_chain_cs_dag_event_round_item_t *a_round_item, dap_enc_key_t * a_key);
dap_sign_t * dap_chain_cs_dag_event_get_sign( dap_chain_cs_dag_event_t * a_event, size_t a_event_size, uint16_t a_sign_number);
-size_t dap_chain_cs_dag_event_calc_size_excl_signs(dap_chain_cs_dag_event_t *a_event, size_t a_limit_size);
-size_t dap_chain_cs_dag_event_calc_size(dap_chain_cs_dag_event_t *a_event, size_t a_limit_size);
+uint64_t dap_chain_cs_dag_event_calc_size_excl_signs(dap_chain_cs_dag_event_t *a_event, uint64_t a_limit_size);
+uint64_t dap_chain_cs_dag_event_calc_size(dap_chain_cs_dag_event_t *a_event, uint64_t a_limit_size);
/**
--
GitLab