Merge branch 'dev' into feature/blinded-contacts

# Conflicts:
#	tests/test_session_network.cpp

Author: mpretty-cyro

.drone.jsonnet

@@ -356,7 +356,7 @@ local static_build(name,
   clang(17),
   full_llvm(17),
   debian_build('Debian stable (i386)', docker_base + 'debian-stable/i386'),
-  debian_build('Debian 11', docker_base + 'debian-bullseye', extra_setup=debian_backports('bullseye', ['cmake'])),
+  debian_build('Debian 12', docker_base + 'debian-bookworm', extra_setup=debian_backports('bookworm', ['cmake'])),
   debian_build('Ubuntu latest', docker_base + 'ubuntu-rolling'),
   debian_build('Ubuntu LTS', docker_base + 'ubuntu-lts'),
 

CMakeLists.txt

@@ -17,7 +17,7 @@ if(CCACHE_PROGRAM)
 endif()
 
 project(libsession-util
-    VERSION 1.5.0
+    VERSION 1.5.1
     DESCRIPTION "Session client utility library"
     LANGUAGES ${LANGS})
 

src/session_network.cpp

@@ -233,16 +233,16 @@ namespace {
     }
 
     const std::vector<service_node> seed_nodes_testnet{
-            node_from_disk("144.76.164.202|35400|2.8.0|"
+            node_from_disk("95.216.33.113|35400|2.8.0|"
                            "decaf007f26d3d6f9b845ad031ffdf6d04638c25bb10b8fffbbe99135303c4b9|"sv)};
     const std::vector<service_node> seed_nodes_mainnet{
-            node_from_disk("144.76.164.202|20200|2.8.0|"
+            node_from_disk("95.216.33.113|20200|2.8.0|"
                            "1f000f09a7b07828dcb72af7cd16857050c10c02bd58afb0e38111fb6cda1fef|"sv),
-            node_from_disk("88.99.102.229|20201|2.8.0|"
+            node_from_disk("37.27.236.229|20201|2.8.0|"
                            "1f101f0acee4db6f31aaa8b4df134e85ca8a4878efaef7f971e88ab144c1a7ce|"sv),
-            node_from_disk("195.16.73.17|20202|2.8.0|"
+            node_from_disk("172.96.140.124|20202|2.8.0|"
                            "1f202f00f4d2d4acc01e20773999a291cf3e3136c325474d159814e06199919f|"sv),
-            node_from_disk("104.194.11.120|20203|2.8.0|"
+            node_from_disk("208.73.207.54|20203|2.8.0|"
                            "1f303f1d7523c46fa5398826740d13282d26b5de90fbae5749442f66afb6d78b|"sv),
             node_from_disk("104.194.8.115|20204|2.8.0|"
                            "1f604f1c858a121a681d8f9b470ef72e6946ee1b9c5ad15a35e16b50c28db7b0|"sv)};

tests/test_session_network.cpp

@@ -57,6 +57,53 @@ std::optional<service_node> node_for_destination(network_destination destination
     return std::nullopt;
 }
 
+std::shared_ptr<TestServer> create_test_server(uint16_t port) {
+    oxen::quic::opt::inbound_alpns server_alpns{"oxenstorage"};
+    auto server_key_pair = session::ed25519::ed25519_key_pair(to_span(fmt::format("{:032}", port)));
+    auto server_x25519_pubkey = session::curve25519::to_curve25519_pubkey(
+            {server_key_pair.first.data(), server_key_pair.first.size()});
+    auto server_x25519_seckey = session::curve25519::to_curve25519_seckey(
+            {server_key_pair.second.data(), server_key_pair.second.size()});
+    auto creds =
+            oxen::quic::GNUTLSCreds::make_from_ed_seckey(to_string_view(server_key_pair.second));
+    oxen::quic::Address server_local{port};
+    session::onionreq::HopEncryption decryptor{
+            x25519_seckey::from_bytes(to_span(server_x25519_seckey)),
+            x25519_pubkey::from_bytes(to_span(server_x25519_pubkey)),
+            true};
+
+    auto server_cb = [&](oxen::quic::message m) {
+        nlohmann::json response{{"hf", {1, 0, 0}}, {"t", 1234567890}, {"version", {2, 8, 0}}};
+        m.respond(response.dump(), false);
+    };
+
+    auto onion_cb = [&](oxen::quic::message m) {
+        nlohmann::json response{{"hf", {2, 0, 0}}, {"t", 1234567890}, {"version", {2, 8, 0}}};
+        m.respond(response.dump(), false);
+    };
+
+    oxen::quic::stream_constructor_callback server_constructor =
+            [&](oxen::quic::Connection& c, oxen::quic::Endpoint& e, std::optional<int64_t>) {
+                auto s = e.loop.make_shared<oxen::quic::BTRequestStream>(c, e);
+                s->register_handler("info", server_cb);
+                s->register_handler("onion_req", onion_cb);
+                return s;
+            };
+
+    auto loop = std::make_shared<oxen::quic::Loop>();
+    auto endpoint = oxen::quic::Endpoint::endpoint(*loop, server_local, server_alpns);
+    endpoint->listen(creds, server_constructor);
+
+    auto node = service_node{
+            to_string_view(server_key_pair.first),
+            {2, 8, 0},
+            INVALID_SWARM_ID,
+            "127.0.0.1"s,
+            endpoint->local().port()};
+
+    return std::make_shared<TestServer>(loop, endpoint, node);
+}
+
 }  // namespace
 
 namespace session::network {
@@ -193,61 +240,13 @@ class TestNetwork : public Network {
                    std::optional<std::string>) {});
     }
 
-    std::shared_ptr<TestServer> create_test_node(uint16_t port) {
-        oxen::quic::opt::inbound_alpns server_alpns{"oxenstorage"};
-        auto server_key_pair =
-                session::ed25519::ed25519_key_pair(to_span(fmt::format("{:032}", port)));
-        auto server_x25519_pubkey = session::curve25519::to_curve25519_pubkey(
-                {server_key_pair.first.data(), server_key_pair.first.size()});
-        auto server_x25519_seckey = session::curve25519::to_curve25519_seckey(
-                {server_key_pair.second.data(), server_key_pair.second.size()});
-        auto creds = oxen::quic::GNUTLSCreds::make_from_ed_seckey(
-                to_string_view(server_key_pair.second));
-        oxen::quic::Address server_local{port};
-        session::onionreq::HopEncryption decryptor{
-                x25519_seckey::from_bytes(to_span(server_x25519_seckey)),
-                x25519_pubkey::from_bytes(to_span(server_x25519_pubkey)),
-                true};
-
-        auto server_cb = [&](oxen::quic::message m) {
-            nlohmann::json response{{"hf", {1, 0, 0}}, {"t", 1234567890}, {"version", {2, 8, 0}}};
-            m.respond(response.dump(), false);
-        };
-
-        auto onion_cb = [&](oxen::quic::message m) {
-            nlohmann::json response{{"hf", {2, 0, 0}}, {"t", 1234567890}, {"version", {2, 8, 0}}};
-            m.respond(response.dump(), false);
-        };
-
-        oxen::quic::stream_constructor_callback server_constructor =
-                [&](oxen::quic::Connection& c, oxen::quic::Endpoint& e, std::optional<int64_t>) {
-                    auto s = e.loop.make_shared<oxen::quic::BTRequestStream>(c, e);
-                    s->register_handler("info", server_cb);
-                    s->register_handler("onion_req", onion_cb);
-                    return s;
-                };
-
-        auto loop = std::make_shared<oxen::quic::Loop>();
-        auto endpoint = oxen::quic::Endpoint::endpoint(*loop, server_local, server_alpns);
-        endpoint->listen(creds, server_constructor);
-
-        auto node = service_node{
-                to_string_view(server_key_pair.first),
-                {2, 8, 0},
-                INVALID_SWARM_ID,
-                "127.0.0.1"s,
-                endpoint->local().port()};
-
-        return std::make_shared<TestServer>(loop, endpoint, node);
-    }
-
     std::pair<std::vector<std::shared_ptr<TestServer>>, onion_path> create_test_path() {
         std::vector<std::shared_ptr<TestServer>> path_servers;
         std::vector<service_node> path_nodes;
         path_nodes.reserve(3);
 
         for (auto i = 0; i < 3; ++i) {
-            path_servers.emplace_back(create_test_node(static_cast<uint16_t>(1000 + i)));
+            path_servers.emplace_back(create_test_server(static_cast<uint16_t>(1000 + i)));
             path_nodes.emplace_back(path_servers[i]->node);
         }
 
@@ -1073,10 +1072,11 @@ TEST_CASE("Network", "[network][build_path]") {
 
 TEST_CASE("Network", "[network][find_valid_path]") {
     auto ed_pk = "4cb76fdc6d32278e3f83dbf608360ecc6b65727934b85d2fb86862ff98c46ab7"_hexbytes;
+    auto test_server = create_test_server(500);
     auto target = test_node(ed_pk, 1);
-    auto network = TestNetwork(std::nullopt, true, false, false);
-    auto test_server = network.create_test_node(500);
     auto info = request_info::make(target, std::nullopt, std::nullopt, 0ms);
+
+    auto network = TestNetwork(std::nullopt, true, false, false);
     auto invalid_path = onion_path{
             "Test",
             {test_server->node, nullptr, nullptr, nullptr},
@@ -1125,7 +1125,7 @@ TEST_CASE("Network", "[network][find_valid_path]") {
 TEST_CASE("Network", "[network][build_path_if_needed]") {
     auto ed_pk = "4cb76fdc6d32278e3f83dbf608360ecc6b65727934b85d2fb86862ff98c46ab7"_hexbytes;
     auto target = test_node(ed_pk, 0);
-    ;
+
     std::optional<TestNetwork> network;
     auto invalid_path = onion_path{
             "Test", connection_info{target, nullptr, nullptr, nullptr}, {target}, uint8_t{0}};
@@ -1221,8 +1221,8 @@ TEST_CASE("Network", "[network][build_path_if_needed]") {
 }
 
 TEST_CASE("Network", "[network][establish_connection]") {
+    auto test_server = create_test_server(500);
     auto network = TestNetwork(std::nullopt, true, true, false);
-    auto test_server = network.create_test_node(500);
     std::promise<std::pair<connection_info, std::optional<std::string>>> prom;
 
     network.establish_connection(
@@ -1248,7 +1248,7 @@ TEST_CASE("Network", "[network][check_request_queue_timeouts]") {
     // Test that it doesn't start checking for timeouts when the request doesn't have
     // a build paths timeout
     network.emplace(std::nullopt, true, true, false);
-    test_server.emplace(network->create_test_node(501));
+    test_server.emplace(create_test_server(501));
     network->send_onion_request(
             (*test_server)->node,
             to_vector("{\"method\":\"info\",\"params\":{}}"),
@@ -1265,7 +1265,7 @@ TEST_CASE("Network", "[network][check_request_queue_timeouts]") {
     // Test that it does start checking for timeouts when the request has a
     // paths build timeout
     network.emplace(std::nullopt, true, true, false);
-    test_server.emplace(network->create_test_node(502));
+    test_server.emplace(create_test_server(502));
     network->ignore_calls_to("build_path");
     network->send_onion_request(
             (*test_server)->node,
@@ -1283,7 +1283,7 @@ TEST_CASE("Network", "[network][check_request_queue_timeouts]") {
     // Test that it fails the request with a timeout if it has a build path timeout
     // and the path build takes too long
     network.emplace(std::nullopt, true, true, false);
-    test_server.emplace(network->create_test_node(503));
+    test_server.emplace(create_test_server(503));
     network->ignore_calls_to("build_path");
     network->send_onion_request(
             (*test_server)->node,
@@ -1307,8 +1307,8 @@ TEST_CASE("Network", "[network][check_request_queue_timeouts]") {
 }
 
 TEST_CASE("Network", "[network][send_request]") {
+    auto test_server = create_test_server(500);
     auto network = TestNetwork(std::nullopt, true, true, false);
-    auto test_server = network.create_test_node(500);
     std::promise<Result> prom;
 
     network.establish_connection(
@@ -1360,8 +1360,8 @@ TEST_CASE("Network", "[network][send_request]") {
 }
 
 TEST_CASE("Network", "[network][send_onion_request]") {
+    auto test_server = create_test_server(500);
     auto network = TestNetwork(std::nullopt, true, true, false);
-    auto test_server = network.create_test_node(500);
     auto [test_path_servers, test_path] = network.create_test_path();
     network.handle_onion_requests_as_plaintext = true;
     network.set_paths(PathType::standard, {test_path});
@@ -1402,8 +1402,8 @@ TEST_CASE("Network", "[network][send_onion_request]") {
 }
 
 TEST_CASE("Network", "[network][c][network_send_onion_request]") {
+    auto test_server_cpp = create_test_server(500);
     auto test_network = std::make_unique<TestNetwork>(std::nullopt, true, true, false);
-    auto test_server_cpp = test_network->create_test_node(500);
     std::optional<std::pair<std::vector<std::shared_ptr<TestServer>>, onion_path>> test_path_data;
     test_path_data.emplace(test_network->create_test_path());
     test_network->handle_onion_requests_as_plaintext = true;