From 44b9f7454cf9d24aa0adaada09dc33ff5946315b Mon Sep 17 00:00:00 2001 From: acktarius Date: Mon, 20 Jan 2025 12:42:31 -0500 Subject: [PATCH 1/3] handle request * implement limit based on memory capacity --- src/CryptoNoteConfig.h | 24 ++++ .../CryptoNoteProtocolHandler.cpp | 128 +++++++++++++++++- .../CryptoNoteProtocolHandler.h | 15 +- 3 files changed, 164 insertions(+), 3 deletions(-) diff --git a/src/CryptoNoteConfig.h b/src/CryptoNoteConfig.h index d72bc046..29947409 100644 --- a/src/CryptoNoteConfig.h +++ b/src/CryptoNoteConfig.h @@ -9,6 +9,7 @@ #pragma once #include +#include #include namespace cn @@ -142,6 +143,29 @@ namespace cn const char CRYPTONOTE_BLOCKCHAIN_INDICES_FILENAME[] = "blockchainindices.dat"; const char MINER_CONFIG_FILE_NAME[] = "miner_conf.json"; + // Memory management constants + const uint32_t ABSOLUTE_MIN_OBJECTS = 200; // Minimum for basic operation + const uint32_t ABSOLUTE_MAX_OBJECTS = 2000; // Conservative max (~70MB max memory usage) + const uint32_t FALLBACK_OBJECT_COUNT = 500; // Default when memory check fails + const uint32_t MEMORY_CHECK_INTERVAL = DIFFICULTY_TARGET * 5; // Check every 5 blocks + constexpr double MEMORY_DEDICATED_PERCENTAGE = 0.7; // Use 70% of available memory + const uint64_t AVG_BLOCK_SIZE_KB = 30; // Average block size + const uint64_t AVG_TRANSACTION_SIZE_KB = 2; // Average transaction size + const uint64_t MEMORY_OVERHEAD_KB = 3; // Memory overhead per object + const uint64_t TOTAL_OBJECT_SIZE_KB = AVG_BLOCK_SIZE_KB + AVG_TRANSACTION_SIZE_KB + MEMORY_OVERHEAD_KB; + + // Memory management constants validation + static_assert(AVG_BLOCK_SIZE_KB > 0, "Average block size must be positive"); + static_assert(AVG_TRANSACTION_SIZE_KB > 0, "Average transaction size must be positive"); + static_assert(MEMORY_OVERHEAD_KB > 0, "Memory overhead must be positive"); + static_assert(MEMORY_DEDICATED_PERCENTAGE * MEMORY_DEDICATED_PERCENTAGE < 0.64, + "Memory dedicated percentage must be less than 0.8 (square root of 0.64)"); + static_assert(TOTAL_OBJECT_SIZE_KB > 0, "Total object size must be positive"); + static_assert(ABSOLUTE_MIN_OBJECTS > 0, "Minimum object count must be positive"); + static_assert(ABSOLUTE_MAX_OBJECTS > ABSOLUTE_MIN_OBJECTS, + "Maximum object count must be greater than minimum"); + + } // namespace parameters const uint64_t START_BLOCK_REWARD = (UINT64_C(5000) * parameters::POINT); // start reward (Consensus I) diff --git a/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.cpp b/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.cpp index beea9661..5aa8704b 100644 --- a/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.cpp +++ b/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.cpp @@ -20,6 +20,13 @@ #include "CryptoNoteCore/Currency.h" #include "CryptoNoteCore/VerificationContext.h" #include "P2p/LevinProtocol.h" +#include +#include "../CryptoNoteConfig.h" +#include // for UINT64_MAX +#ifdef __linux__ +#include +#endif +#include using namespace logging; using namespace common; @@ -55,6 +62,11 @@ CryptoNoteProtocolHandler::CryptoNoteProtocolHandler(const Currency ¤cy, p logger(log, "protocol"), m_dispatcher(dispatcher) { + std::cout << "\n=== Memory Management Configuration ===" << std::endl; + std::cout << "Initial max object count: " << m_maxObjectCount << std::endl; + std::cout << "Memory check interval: " << MEMORY_CHECK_INTERVAL << " seconds" << std::endl; + std::cout << "Memory dedicated percentage: " << (cn::parameters::MEMORY_DEDICATED_PERCENTAGE * 100) << "%" << std::endl; + std::cout << "==================================\n" << std::endl; if (!m_p2p) m_p2p = &m_p2p_stub; } @@ -392,9 +404,19 @@ int CryptoNoteProtocolHandler::handle_notify_new_transactions(int command, NOTIF int CryptoNoteProtocolHandler::handle_request_get_objects(int command, NOTIFY_REQUEST_GET_OBJECTS::request &arg, CryptoNoteConnectionContext &context) { logger(logging::TRACE) << context << "NOTIFY_REQUEST_GET_OBJECTS"; - if(arg.blocks.size() > COMMAND_RPC_GET_OBJECTS_MAX_COUNT || arg.txs.size() > COMMAND_RPC_GET_OBJECTS_MAX_COUNT) + + // Update memory limit if needed + updateMemoryLimit(); + + const size_t totalObjects = arg.blocks.size() + arg.txs.size(); + + std::cout << "DEBUG: Request for " << totalObjects << " objects (limit: " << m_maxObjectCount << ")" << std::endl; + + if (totalObjects > m_maxObjectCount) { - logger(logging::ERROR) << context << "GET_OBJECTS_MAX_COUNT exceeded blocks: " << arg.blocks.size() << " txes: " << arg.txs.size(); + logger(logging::ERROR) << context << "Requested objects count exceeds current memory-based limit of " + << m_maxObjectCount << ": blocks " << arg.blocks.size() + << " + txs " << arg.txs.size() << " = " << totalObjects; context.m_state = CryptoNoteConnectionContext::state_shutdown; return 1; } @@ -1121,4 +1143,106 @@ int CryptoNoteProtocolHandler::doPushLiteBlock(NOTIFY_NEW_LITE_BLOCK::request ar return 1; } +uint64_t CryptoNoteProtocolHandler::getAvailableMemory() const { +#ifdef _WIN32 + MEMORYSTATUSEX memInfo; + memInfo.dwLength = sizeof(MEMORYSTATUSEX); + if (GlobalMemoryStatusEx(&memInfo)) { + std::cout << "DEBUG: Windows available memory: " << (memInfo.ullAvailPhys / (1024*1024)) << "MB" << std::endl; + return memInfo.ullAvailPhys; + } + std::cout << "DEBUG: Failed to get Windows memory info!" << std::endl; + logger(ERROR) << "Failed to get Windows memory info: " << GetLastError(); + return 0; +#else + struct sysinfo memInfo; + if (sysinfo(&memInfo) == 0) { + uint64_t available = memInfo.freeram; + available *= memInfo.mem_unit; + std::cout << "DEBUG: Linux available memory: " << (available / (1024*1024)) << "MB" << std::endl; + return available; + } + std::cout << "DEBUG: Failed to get Linux memory info!" << std::endl; + logger(ERROR) << "Failed to get system memory info: " << errno; + return 0; +#endif +} + +uint32_t clampValue(uint32_t value, uint32_t min, uint32_t max) { + if (value < min) return min; + if (value > max) return max; + return value; +} + +uint32_t CryptoNoteProtocolHandler::calculateMaxObjectCount() const { + uint64_t availableMB = getAvailableMemory() / (1024 * 1024); + + std::cout << "DEBUG: Available memory (MB): " << availableMB << std::endl; + + if (availableMB == 0) { + std::cout << "DEBUG: Memory check failed, using fallback count: " << cn::parameters::FALLBACK_OBJECT_COUNT << std::endl; + logger(logging::WARNING) << "Memory check failed, using fallback count: " << cn::parameters::FALLBACK_OBJECT_COUNT; + return cn::parameters::FALLBACK_OBJECT_COUNT; + } + + // Ensure we don't overflow + if (availableMB > UINT64_MAX / 1024) { + std::cout << "DEBUG: Memory size overflow, using maximum limit" << std::endl; + logger(logging::WARNING) << "Memory size overflow, using maximum limit"; + return cn::parameters::ABSOLUTE_MAX_OBJECTS; + } + + // Use dedicated percentage of memory directly + availableMB = availableMB * cn::parameters::MEMORY_DEDICATED_PERCENTAGE; + std::cout << "DEBUG: Reserved memory (MB): " << availableMB << std::endl; + + // Sanity check the result + if (availableMB == 0) { + std::cout << "DEBUG: Available memory after reserve is 0, using minimum limit" << std::endl; + logger(logging::WARNING) << "Available memory after reserve is 0, using minimum limit"; + return cn::parameters::ABSOLUTE_MIN_OBJECTS; + } + + uint32_t maxCount = (availableMB * 1024) / cn::parameters::TOTAL_OBJECT_SIZE_KB; + std::cout << "DEBUG: Calculated max count before limits: " << maxCount << std::endl; + + uint32_t finalCount = boost::algorithm::clamp(maxCount, + cn::parameters::ABSOLUTE_MIN_OBJECTS, + cn::parameters::ABSOLUTE_MAX_OBJECTS); + std::cout << "DEBUG: Final max count after limits: " << finalCount << std::endl; + + logger(DEBUGGING) << "Memory limit calculation: " + << availableMB << "MB available, " + << "max objects: " << finalCount; + + return finalCount; +} + +void CryptoNoteProtocolHandler::updateMemoryLimit() { + std::lock_guard lock(m_memoryCheckMutex); + auto now = std::chrono::steady_clock::now(); + auto elapsed = std::chrono::duration_cast(now - m_lastMemoryCheck).count(); + + std::cout << "\n=== Memory Check Update ===" << std::endl; + std::cout << "DEBUG: Time since last memory check (seconds): " << elapsed << std::endl; + + if (elapsed >= MEMORY_CHECK_INTERVAL) { + std::cout << "DEBUG: Updating memory limit..." << std::endl; + uint32_t newLimit = calculateMaxObjectCount(); + uint32_t oldLimit = m_maxObjectCount.load(); + + if (newLimit != oldLimit) { + std::cout << "DEBUG: Limit changed: " << oldLimit << " -> " << newLimit << std::endl; + logger(DEBUGGING) << "Memory-based object limit updated: " << oldLimit << " -> " << newLimit + << " (Available memory: " << (getAvailableMemory() / (1024*1024)) << "MB)"; + } else { + std::cout << "DEBUG: Limit unchanged: " << oldLimit << std::endl; + } + + m_maxObjectCount.store(newLimit); + m_lastMemoryCheck = now; + } else { + std::cout << "DEBUG: Skipping update, not enough time elapsed" << std::endl; + } +} }; // namespace cn diff --git a/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.h b/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.h index ccb1d1bf..f21b6a0c 100644 --- a/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.h +++ b/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.h @@ -8,9 +8,11 @@ #pragma once #include +#include +#include #include - +#include "../CryptoNoteConfig.h" #include "CryptoNoteCore/ICore.h" #include "CryptoNoteProtocol/CryptoNoteProtocolDefinitions.h" @@ -118,5 +120,16 @@ namespace cn std::atomic m_peersCount; tools::ObserverManager m_observerManager; + + std::atomic m_maxObjectCount; + static constexpr uint32_t MEMORY_CHECK_INTERVAL = cn::parameters::MEMORY_CHECK_INTERVAL; + std::chrono::steady_clock::time_point m_lastMemoryCheck; + mutable std::mutex m_memoryCheckMutex; + + uint64_t getAvailableMemory() const; + uint32_t calculateMaxObjectCount() const; + + void updateMemoryLimit(); + }; } From 552329409e8f8dca0a722a7befd4e91d5b7a75ae Mon Sep 17 00:00:00 2001 From: acktarius Date: Sun, 26 Jan 2025 11:46:26 -0500 Subject: [PATCH 2/3] Set max object count linit for DDOS prevention - conservative value (1200) - fallback (800) if memory cannot be assesed or small memory free to start with --- .gitignore | 4 +- src/CryptoNoteConfig.h | 23 +--- .../CryptoNoteProtocolHandler.cpp | 119 ++++-------------- .../CryptoNoteProtocolHandler.h | 8 +- 4 files changed, 33 insertions(+), 121 deletions(-) diff --git a/.gitignore b/.gitignore index 6a8aeadc..f42fcf92 100644 --- a/.gitignore +++ b/.gitignore @@ -23,4 +23,6 @@ compile_commands.json *.ipch *.bin *.json -cmake-build* \ No newline at end of file +cmake-build* + +.cursorrules \ No newline at end of file diff --git a/src/CryptoNoteConfig.h b/src/CryptoNoteConfig.h index 29947409..943db74c 100644 --- a/src/CryptoNoteConfig.h +++ b/src/CryptoNoteConfig.h @@ -144,26 +144,13 @@ namespace cn const char MINER_CONFIG_FILE_NAME[] = "miner_conf.json"; // Memory management constants - const uint32_t ABSOLUTE_MIN_OBJECTS = 200; // Minimum for basic operation - const uint32_t ABSOLUTE_MAX_OBJECTS = 2000; // Conservative max (~70MB max memory usage) - const uint32_t FALLBACK_OBJECT_COUNT = 500; // Default when memory check fails - const uint32_t MEMORY_CHECK_INTERVAL = DIFFICULTY_TARGET * 5; // Check every 5 blocks - constexpr double MEMORY_DEDICATED_PERCENTAGE = 0.7; // Use 70% of available memory - const uint64_t AVG_BLOCK_SIZE_KB = 30; // Average block size - const uint64_t AVG_TRANSACTION_SIZE_KB = 2; // Average transaction size - const uint64_t MEMORY_OVERHEAD_KB = 3; // Memory overhead per object - const uint64_t TOTAL_OBJECT_SIZE_KB = AVG_BLOCK_SIZE_KB + AVG_TRANSACTION_SIZE_KB + MEMORY_OVERHEAD_KB; + const uint32_t ABSOLUTE_MAX_OBJECTS = 1200; // can safely be handled memory wise, but a limiting factor to prevent DDOS attack + const uint32_t FALLBACK_MAX_OBJECTS = 800; // Default when memory check fails + const uint64_t MIN_MEMORY_MB = 150; // Minimum memory required for handling fallback max objects // Memory management constants validation - static_assert(AVG_BLOCK_SIZE_KB > 0, "Average block size must be positive"); - static_assert(AVG_TRANSACTION_SIZE_KB > 0, "Average transaction size must be positive"); - static_assert(MEMORY_OVERHEAD_KB > 0, "Memory overhead must be positive"); - static_assert(MEMORY_DEDICATED_PERCENTAGE * MEMORY_DEDICATED_PERCENTAGE < 0.64, - "Memory dedicated percentage must be less than 0.8 (square root of 0.64)"); - static_assert(TOTAL_OBJECT_SIZE_KB > 0, "Total object size must be positive"); - static_assert(ABSOLUTE_MIN_OBJECTS > 0, "Minimum object count must be positive"); - static_assert(ABSOLUTE_MAX_OBJECTS > ABSOLUTE_MIN_OBJECTS, - "Maximum object count must be greater than minimum"); + static_assert(ABSOLUTE_MAX_OBJECTS > FALLBACK_MAX_OBJECTS, + "Maximum object count must be greater than Fallback"); } // namespace parameters diff --git a/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.cpp b/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.cpp index 5aa8704b..0105e00b 100644 --- a/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.cpp +++ b/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.cpp @@ -20,13 +20,12 @@ #include "CryptoNoteCore/Currency.h" #include "CryptoNoteCore/VerificationContext.h" #include "P2p/LevinProtocol.h" -#include + #include "../CryptoNoteConfig.h" #include // for UINT64_MAX #ifdef __linux__ #include #endif -#include using namespace logging; using namespace common; @@ -51,6 +50,7 @@ void relay_post_notify(IP2pEndpoint &p2p, typename t_parametr::request &arg, con } // namespace + CryptoNoteProtocolHandler::CryptoNoteProtocolHandler(const Currency ¤cy, platform_system::Dispatcher &dispatcher, ICore &rcore, IP2pEndpoint *p_net_layout, logging::ILogger &log) : m_currency(currency), m_p2p(p_net_layout), @@ -60,16 +60,14 @@ CryptoNoteProtocolHandler::CryptoNoteProtocolHandler(const Currency ¤cy, p m_observedHeight(0), m_peersCount(0), logger(log, "protocol"), - m_dispatcher(dispatcher) - { - std::cout << "\n=== Memory Management Configuration ===" << std::endl; - std::cout << "Initial max object count: " << m_maxObjectCount << std::endl; - std::cout << "Memory check interval: " << MEMORY_CHECK_INTERVAL << " seconds" << std::endl; - std::cout << "Memory dedicated percentage: " << (cn::parameters::MEMORY_DEDICATED_PERCENTAGE * 100) << "%" << std::endl; - std::cout << "==================================\n" << std::endl; - if (!m_p2p) - m_p2p = &m_p2p_stub; - } + m_dispatcher(dispatcher), + m_maxObjectCount(calculateMaxObjectCount()) +{ + logger(INFO) << "Max object count: " << m_maxObjectCount; + + if (!m_p2p) + m_p2p = &m_p2p_stub; +} size_t CryptoNoteProtocolHandler::getPeerCount() const { @@ -405,17 +403,16 @@ int CryptoNoteProtocolHandler::handle_request_get_objects(int command, NOTIFY_RE { logger(logging::TRACE) << context << "NOTIFY_REQUEST_GET_OBJECTS"; - // Update memory limit if needed - updateMemoryLimit(); - + uint32_t maxObjects = m_maxObjectCount.load(); const size_t totalObjects = arg.blocks.size() + arg.txs.size(); - std::cout << "DEBUG: Request for " << totalObjects << " objects (limit: " << m_maxObjectCount << ")" << std::endl; + logger(INFO) << "DEBUG: Request for " << totalObjects << " objects (limit: " << maxObjects << ")"; - if (totalObjects > m_maxObjectCount) + + if (totalObjects > maxObjects) { - logger(logging::ERROR) << context << "Requested objects count exceeds current memory-based limit of " - << m_maxObjectCount << ": blocks " << arg.blocks.size() + logger(logging::ERROR) << context << "Requested objects count exceeds limit of " + << maxObjects << ": blocks " << arg.blocks.size() << " + txs " << arg.txs.size() << " = " << totalObjects; context.m_state = CryptoNoteConnectionContext::state_shutdown; return 1; @@ -616,14 +613,15 @@ int CryptoNoteProtocolHandler::processObjects(CryptoNoteConnectionContext& conte } return 0; - } + bool CryptoNoteProtocolHandler::on_idle() { return m_core.on_idle(); } + int CryptoNoteProtocolHandler::handle_request_chain(int command, NOTIFY_REQUEST_CHAIN::request &arg, CryptoNoteConnectionContext &context) { logger(logging::TRACE) << context << "NOTIFY_REQUEST_CHAIN: m_block_ids.size()=" << arg.block_ids.size(); @@ -1148,10 +1146,8 @@ uint64_t CryptoNoteProtocolHandler::getAvailableMemory() const { MEMORYSTATUSEX memInfo; memInfo.dwLength = sizeof(MEMORYSTATUSEX); if (GlobalMemoryStatusEx(&memInfo)) { - std::cout << "DEBUG: Windows available memory: " << (memInfo.ullAvailPhys / (1024*1024)) << "MB" << std::endl; return memInfo.ullAvailPhys; } - std::cout << "DEBUG: Failed to get Windows memory info!" << std::endl; logger(ERROR) << "Failed to get Windows memory info: " << GetLastError(); return 0; #else @@ -1159,90 +1155,23 @@ uint64_t CryptoNoteProtocolHandler::getAvailableMemory() const { if (sysinfo(&memInfo) == 0) { uint64_t available = memInfo.freeram; available *= memInfo.mem_unit; - std::cout << "DEBUG: Linux available memory: " << (available / (1024*1024)) << "MB" << std::endl; return available; } - std::cout << "DEBUG: Failed to get Linux memory info!" << std::endl; logger(ERROR) << "Failed to get system memory info: " << errno; return 0; #endif } -uint32_t clampValue(uint32_t value, uint32_t min, uint32_t max) { - if (value < min) return min; - if (value > max) return max; - return value; -} - uint32_t CryptoNoteProtocolHandler::calculateMaxObjectCount() const { uint64_t availableMB = getAvailableMemory() / (1024 * 1024); - - std::cout << "DEBUG: Available memory (MB): " << availableMB << std::endl; - - if (availableMB == 0) { - std::cout << "DEBUG: Memory check failed, using fallback count: " << cn::parameters::FALLBACK_OBJECT_COUNT << std::endl; - logger(logging::WARNING) << "Memory check failed, using fallback count: " << cn::parameters::FALLBACK_OBJECT_COUNT; - return cn::parameters::FALLBACK_OBJECT_COUNT; - } - - // Ensure we don't overflow - if (availableMB > UINT64_MAX / 1024) { - std::cout << "DEBUG: Memory size overflow, using maximum limit" << std::endl; - logger(logging::WARNING) << "Memory size overflow, using maximum limit"; - return cn::parameters::ABSOLUTE_MAX_OBJECTS; - } - - // Use dedicated percentage of memory directly - availableMB = availableMB * cn::parameters::MEMORY_DEDICATED_PERCENTAGE; - std::cout << "DEBUG: Reserved memory (MB): " << availableMB << std::endl; - - // Sanity check the result - if (availableMB == 0) { - std::cout << "DEBUG: Available memory after reserve is 0, using minimum limit" << std::endl; - logger(logging::WARNING) << "Available memory after reserve is 0, using minimum limit"; - return cn::parameters::ABSOLUTE_MIN_OBJECTS; + + if (availableMB < cn::parameters::MIN_MEMORY_MB) { + logger(logging::WARNING) << "Memory check failed or small value, using fallback max objects"; + return cn::parameters::FALLBACK_MAX_OBJECTS; } - uint32_t maxCount = (availableMB * 1024) / cn::parameters::TOTAL_OBJECT_SIZE_KB; - std::cout << "DEBUG: Calculated max count before limits: " << maxCount << std::endl; - - uint32_t finalCount = boost::algorithm::clamp(maxCount, - cn::parameters::ABSOLUTE_MIN_OBJECTS, - cn::parameters::ABSOLUTE_MAX_OBJECTS); - std::cout << "DEBUG: Final max count after limits: " << finalCount << std::endl; - - logger(DEBUGGING) << "Memory limit calculation: " - << availableMB << "MB available, " - << "max objects: " << finalCount; - - return finalCount; + // If we have enough memory, use max objects which would be a key value to prevent DDOS attack + return cn::parameters::ABSOLUTE_MAX_OBJECTS; } -void CryptoNoteProtocolHandler::updateMemoryLimit() { - std::lock_guard lock(m_memoryCheckMutex); - auto now = std::chrono::steady_clock::now(); - auto elapsed = std::chrono::duration_cast(now - m_lastMemoryCheck).count(); - - std::cout << "\n=== Memory Check Update ===" << std::endl; - std::cout << "DEBUG: Time since last memory check (seconds): " << elapsed << std::endl; - - if (elapsed >= MEMORY_CHECK_INTERVAL) { - std::cout << "DEBUG: Updating memory limit..." << std::endl; - uint32_t newLimit = calculateMaxObjectCount(); - uint32_t oldLimit = m_maxObjectCount.load(); - - if (newLimit != oldLimit) { - std::cout << "DEBUG: Limit changed: " << oldLimit << " -> " << newLimit << std::endl; - logger(DEBUGGING) << "Memory-based object limit updated: " << oldLimit << " -> " << newLimit - << " (Available memory: " << (getAvailableMemory() / (1024*1024)) << "MB)"; - } else { - std::cout << "DEBUG: Limit unchanged: " << oldLimit << std::endl; - } - - m_maxObjectCount.store(newLimit); - m_lastMemoryCheck = now; - } else { - std::cout << "DEBUG: Skipping update, not enough time elapsed" << std::endl; - } -} }; // namespace cn diff --git a/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.h b/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.h index f21b6a0c..688801fa 100644 --- a/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.h +++ b/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.h @@ -120,16 +120,10 @@ namespace cn std::atomic m_peersCount; tools::ObserverManager m_observerManager; - - std::atomic m_maxObjectCount; - static constexpr uint32_t MEMORY_CHECK_INTERVAL = cn::parameters::MEMORY_CHECK_INTERVAL; - std::chrono::steady_clock::time_point m_lastMemoryCheck; - mutable std::mutex m_memoryCheckMutex; + std::atomic m_maxObjectCount; uint64_t getAvailableMemory() const; uint32_t calculateMaxObjectCount() const; - void updateMemoryLimit(); - }; } From bfcca5b9daaf9601167b4e8eb4cf2ebf57b4e9a3 Mon Sep 17 00:00:00 2001 From: acktarius Date: Sun, 26 Jan 2025 11:46:26 -0500 Subject: [PATCH 3/3] Set max object count linit for DDOS prevention - conservative value (1200) - fallback (800) if memory cannot be assesed or small memory free to start with --- src/CryptoNoteProtocol/CryptoNoteProtocolHandler.h | 1 - 1 file changed, 1 deletion(-) diff --git a/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.h b/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.h index 688801fa..df02cf2e 100644 --- a/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.h +++ b/src/CryptoNoteProtocol/CryptoNoteProtocolHandler.h @@ -9,7 +9,6 @@ #include #include -#include #include #include "../CryptoNoteConfig.h"