Squashed 'external/toxcore/c-toxcore/' changes from 1828c5356..c9cdae001

c9cdae001 fix(toxav): remove extra copy of video frame on encode
4f6d4546b test: Improve the fake network library.
a2581e700 refactor(toxcore): generate `Friend_Request` and `Dht_Nodes_Response`
2aaa11770 refactor(toxcore): use Tox_Memory in generated events
5c367452b test(toxcore): fix incorrect mutex in tox_scenario_get_time
8f92e710f perf: Add a timed limit of number of cookie requests.
695b6417a test: Add some more simulated network support.
815ae9ce9 test(toxcore): fix thread-safety in scenario framework
6d85c754e test(toxcore): add unit tests for net_crypto
9c22e79cc test(support): add SimulatedEnvironment for deterministic testing
f34fcb195 chore: Update windows Dockerfile to debian stable (trixie).
ece0e8980 fix(group_moderation): allow validating unsorted sanction list signatures
a4fa754d7 refactor: rename struct Packet to struct Net_Packet
d6f330f85 cleanup: Fix some warnings from coverity.
e206bffa2 fix(group_chats): fix sync packets reverting topics
0e4715598 test: Add new scenario testing framework.
668291f44 refactor(toxcore): decouple Network_Funcs from sockaddr via IP_Port
fc4396cef fix: potential division by zero in toxav and unsafe hex parsing
8e8b352ab refactor: Add nullable annotations to struct members.
7740bb421 refactor: decouple net_crypto from DHT
1936d4296 test: add benchmark for toxav audio and video
46bfdc2df fix: correct printf format specifiers for unsigned integers
REVERT: 1828c5356 fix(toxav): remove extra copy of video frame on encode

git-subtree-dir: external/toxcore/c-toxcore
git-subtree-split: c9cdae001341e701fca980c9bb9febfeb95d2902

toxcore/net_crypto_fuzz_test.cc

@@ -6,8 +6,9 @@
 #include <memory>
 #include <optional>
 
-#include "../testing/fuzzing/fuzz_support.hh"
-#include "../testing/fuzzing/fuzz_tox.hh"
+#include "../testing/support/public/fuzz_data.hh"
+#include "../testing/support/public/fuzz_helpers.hh"
+#include "../testing/support/public/simulated_environment.hh"
 #include "DHT.h"
 #include "TCP_client.h"
 #include "net_profile.h"
@@ -15,11 +16,19 @@
 
 namespace {
 
+using tox::test::configure_fuzz_memory_source;
+using tox::test::FakeClock;
+using tox::test::Fuzz_Data;
+using tox::test::SimulatedEnvironment;
+
+template <typename T>
+using Ptr = std::unique_ptr<T, void (*)(T *)>;
+
 std::optional<std::tuple<IP_Port, uint8_t>> prepare(Fuzz_Data &input)
 {
     IP_Port ipp;
     ip_init(&ipp.ip, true);
-    ipp.port = 33445;
+    ipp.port = net_htons(33445);
 
     CONSUME_OR_RETURN_VAL(const uint8_t *iterations_packed, input, 1, std::nullopt);
     uint8_t iterations = *iterations_packed;
@@ -27,6 +36,14 @@ std::optional<std::tuple<IP_Port, uint8_t>> prepare(Fuzz_Data &input)
     return {{ipp, iterations}};
 }
 
+static constexpr Net_Crypto_DHT_Funcs dht_funcs = {
+    [](void *dht, const uint8_t *public_key) {
+        return dht_get_shared_key_sent(static_cast<DHT *>(dht), public_key);
+    },
+    [](const void *dht) { return dht_get_self_public_key(static_cast<const DHT *>(dht)); },
+    [](const void *dht) { return dht_get_self_secret_key(static_cast<const DHT *>(dht)); },
+};
+
 void TestNetCrypto(Fuzz_Data &input)
 {
     const auto prep = prepare(input);
@@ -35,16 +52,19 @@ void TestNetCrypto(Fuzz_Data &input)
     }
     const auto [ipp, iterations] = prep.value();
 
-    // rest of the fuzz data is input for malloc and network
-    Fuzz_System sys(input);
+    SimulatedEnvironment env;
+    env.fake_clock().advance(1000000000);  // Start clock high to match legacy behavior
+    auto node = env.create_node(ipp.port);
+    configure_fuzz_memory_source(env.fake_memory(), input);
 
-    const Ptr<Logger> logger(logger_new(sys.mem.get()), logger_kill);
+    const Ptr<Logger> logger(logger_new(&node->c_memory), logger_kill);
     if (logger == nullptr) {
         return;
     }
 
-    const Ptr<Networking_Core> net(new_networking_ex(logger.get(), sys.mem.get(), sys.ns.get(),
-                                       &ipp.ip, ipp.port, ipp.port + 100, nullptr),
+    const Ptr<Networking_Core> net(
+        new_networking_ex(logger.get(), &node->c_memory, &node->c_network, &ipp.ip, ipp.port,
+            ipp.port + 100, nullptr),
         kill_networking);
     if (net == nullptr) {
         return;
@@ -52,21 +72,23 @@ void TestNetCrypto(Fuzz_Data &input)
 
     const std::unique_ptr<Mono_Time, std::function<void(Mono_Time *)>> mono_time(
         mono_time_new(
-            sys.mem.get(), [](void *user_data) { return *static_cast<uint64_t *>(user_data); },
-            &sys.clock),
-        [mem = sys.mem.get()](Mono_Time *ptr) { mono_time_free(mem, ptr); });
+            &node->c_memory,
+            [](void *user_data) { return static_cast<FakeClock *>(user_data)->current_time_ms(); },
+            &env.fake_clock()),
+        [&node](Mono_Time *ptr) { mono_time_free(&node->c_memory, ptr); });
+
     if (mono_time == nullptr) {
         return;
     }
 
-    const Ptr<DHT> dht(new_dht(logger.get(), sys.mem.get(), sys.rng.get(), sys.ns.get(),
+    const Ptr<DHT> dht(new_dht(logger.get(), &node->c_memory, &node->c_random, &node->c_network,
                            mono_time.get(), net.get(), false, false),
         kill_dht);
     if (dht == nullptr) {
         return;
     }
 
-    Net_Profile *tcp_np = netprof_new(logger.get(), sys.mem.get());
+    Net_Profile *tcp_np = netprof_new(logger.get(), &node->c_memory);
 
     if (tcp_np == nullptr) {
         return;
@@ -75,11 +97,11 @@ void TestNetCrypto(Fuzz_Data &input)
     const TCP_Proxy_Info proxy_info = {0};
 
     const Ptr<Net_Crypto> net_crypto(
-        new_net_crypto(logger.get(), sys.mem.get(), sys.rng.get(), sys.ns.get(), mono_time.get(),
-            net.get(), dht.get(), &proxy_info, tcp_np),
+        new_net_crypto(logger.get(), &node->c_memory, &node->c_random, &node->c_network,
+            mono_time.get(), net.get(), dht.get(), &dht_funcs, &proxy_info, tcp_np),
         kill_net_crypto);
     if (net_crypto == nullptr) {
-        netprof_kill(sys.mem.get(), tcp_np);
+        netprof_kill(&node->c_memory, tcp_np);
         return;
     }
 
@@ -87,11 +109,11 @@ void TestNetCrypto(Fuzz_Data &input)
         networking_poll(net.get(), nullptr);
         do_dht(dht.get());
         do_net_crypto(net_crypto.get(), nullptr);
-        // "Sleep"
-        sys.clock += System::BOOTSTRAP_ITERATION_INTERVAL;
+
+        env.advance_time(200);
     }
 
-    netprof_kill(sys.mem.get(), tcp_np);
+    netprof_kill(&node->c_memory, tcp_np);
 }
 
 }  // namespace
@@ -99,6 +121,6 @@ void TestNetCrypto(Fuzz_Data &input)
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
-    fuzz_select_target<TestNetCrypto>(data, size);
+    tox::test::fuzz_select_target<TestNetCrypto>(data, size);
     return 0;
 }