test: verify probe wire parameters

Author: apple050620312

WinMTR.vcxproj

@@ -1416,6 +1416,7 @@
     <ClInclude Include="WinMTRMain.h" />
     <ClInclude Include="WinMTRNetworkData.h" />
     <ClInclude Include="WinMTRProperties.h" />
+    <ClInclude Include="WinMTRProbeParameters.h" />
     <ClInclude Include="WinMTRRoutePolicy.h" />
     <ClInclude Include="WinMTRSerialization.h" />
     <ClCompile Include="WinMTRUtils.ixx">

WinMTRNet-Tracing.cpp

@@ -13,6 +13,7 @@ module;
 #pragma warning (disable : 4005)
 #include "targetver.h"
 #include "WinMTRRoutePolicy.h"
+#include "WinMTRProbeParameters.h"
 #define WIN32_LEAN_AND_MEAN
 #define VC_EXTRALEAN
 #define NOMCX
@@ -167,27 +168,6 @@ struct parsed_reply final {
 	return reply_header + sizeof(IO_STATUS_BLOCK) + request_size + 8u;
 }
 
-[[nodiscard]] std::vector<std::byte> make_payload(const WinMTRTraceOptions& options,
-	std::uint64_t& random_state)
-{
-	std::vector<std::byte> payload(options.packet_size);
-	if (options.payload_pattern >= 0) {
-		std::fill(payload.begin(), payload.end(),
-			static_cast<std::byte>(options.payload_pattern));
-		return payload;
-	}
-
-	// Small xorshift generator: no runtime dependency and random mode changes
-	// every byte without claiming cryptographic randomness.
-	for (auto& value : payload) {
-		random_state ^= random_state << 13u;
-		random_state ^= random_state >> 7u;
-		random_state ^= random_state << 17u;
-		value = static_cast<std::byte>(random_state & 0xffu);
-	}
-	return payload;
-}
-
 [[nodiscard]] unique_icmp_handle create_icmp_handle(ADDRESS_FAMILY family) noexcept
 {
 	if (family == AF_INET) {
@@ -209,11 +189,12 @@ void issue_probe(pending_probe& probe, HANDLE icmp_handle,
 	}
 
 	probe.reply_buffer.resize(reply_buffer_size(destination.si_family, payload.size()));
-	probe.ip_options.Ttl = static_cast<UCHAR>(probe.ttl);
-	probe.ip_options.Tos = static_cast<UCHAR>(options.tos);
-	probe.ip_options.Flags = destination.si_family == AF_INET && options.dont_fragment
-		? IP_FLAG_DF
-		: 0;
+	const auto wire_options = winmtr::probe_parameters::make_wire_options(
+		probe.ttl, options.tos, options.dont_fragment,
+		destination.si_family == AF_INET);
+	probe.ip_options.Ttl = wire_options.ttl;
+	probe.ip_options.Tos = wire_options.tos;
+	probe.ip_options.Flags = wire_options.dont_fragment ? IP_FLAG_DF : 0;
 
 	DWORD result = 0;
 	SetLastError(ERROR_SUCCESS);
@@ -321,7 +302,8 @@ void issue_probe(pending_probe& probe, HANDLE icmp_handle,
 		probe.ttl = 1;
 		std::uint64_t random_state = GetTickCount64()
 			^ static_cast<std::uint64_t>(candidate.si_family);
-		const auto payload = make_payload(options, random_state);
+		const auto payload = winmtr::probe_parameters::make_payload(
+			options.packet_size, options.payload_pattern, random_state);
 		issue_probe(probe, handle.get(), candidate, options, payload, timeout_ms);
 		if (stop_token.stop_requested()) return false;
 		const auto parsed = parse_reply(probe, candidate.si_family);
@@ -845,7 +827,8 @@ WinMTRTraceResult WinMTRNet::DoTrace(std::stop_token stop_token, SOCKADDR_INET a
 					request->icmp_handle = create_icmp_handle(address.si_family);
 					request->destination = address;
 					request->options = trace_options;
-					request->payload = make_payload(trace_options, random_state);
+					request->payload = winmtr::probe_parameters::make_payload(
+						trace_options.packet_size, trace_options.payload_pattern, random_state);
 					request->timeout_ms = trace_options.timeout_ms;
 					request->completions = &completions;
 					if (!request->icmp_handle) {

WinMTRProbeParameters.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace winmtr::probe_parameters {
+
+struct WireOptions final {
+	std::uint8_t ttl = 0;
+	std::uint8_t tos = 0;
+	bool dont_fragment = false;
+};
+
+[[nodiscard]] constexpr WireOptions make_wire_options(unsigned ttl, unsigned tos,
+	bool request_dont_fragment, bool ipv4) noexcept
+{
+	return WireOptions{
+		.ttl = static_cast<std::uint8_t>(std::min(ttl, 255u)),
+		.tos = static_cast<std::uint8_t>(std::min(tos, 255u)),
+		.dont_fragment = ipv4 && request_dont_fragment,
+	};
+}
+
+[[nodiscard]] inline std::vector<std::byte> make_payload(unsigned packet_size,
+	int payload_pattern, std::uint64_t& random_state)
+{
+	std::vector<std::byte> payload(packet_size);
+	if (payload_pattern >= 0) {
+		std::fill(payload.begin(), payload.end(),
+			static_cast<std::byte>(static_cast<unsigned>(payload_pattern) & 0xffu));
+		return payload;
+	}
+
+	// Deterministic xorshift is sufficient for varying diagnostic payload bytes;
+	// this is intentionally not a cryptographic random-number generator.
+	for (auto& value : payload) {
+		random_state ^= random_state << 13u;
+		random_state ^= random_state >> 7u;
+		random_state ^= random_state << 17u;
+		value = static_cast<std::byte>(random_state & 0xffu);
+	}
+	return payload;
+}
+
+} // namespace winmtr::probe_parameters

tests/ProbeSchedulerTests.cpp

@@ -1,4 +1,5 @@
 #include "WinMTRProbeScheduler.h"
+#include "WinMTRProbeParameters.h"
 #include "WinMTRAddressPolicy.h"
 #include "WinMTRJson.h"
 #include "WinMTRSerialization.h"
@@ -441,6 +442,35 @@ void test_route_policy_scripted_changes()
 		"minimum TTL was not enforced after an early destination");
 }
 
+void test_probe_packet_parameters()
+{
+	using winmtr::probe_parameters::make_payload;
+	using winmtr::probe_parameters::make_wire_options;
+	std::uint64_t fixedState = 123;
+	require(make_payload(0, 32, fixedState).empty(), "zero-byte payload was not supported");
+	const auto maximum = make_payload(4'096, 0xab, fixedState);
+	require(maximum.size() == 4'096
+		&& std::ranges::all_of(maximum, [](std::byte value) { return value == std::byte{ 0xab }; }),
+		"fixed maximum-size payload did not preserve its pattern");
+
+	std::uint64_t firstState = 0x123456789abcdef0ull;
+	std::uint64_t secondState = firstState;
+	const auto randomFirst = make_payload(64, -1, firstState);
+	const auto randomSecond = make_payload(64, -1, secondState);
+	require(randomFirst == randomSecond && firstState == secondState,
+		"random payload was not reproducible from its seed");
+	require(std::ranges::any_of(randomFirst,
+		[head = randomFirst.front()](std::byte value) { return value != head; }),
+		"random payload did not vary its bytes");
+
+	const auto ipv4 = make_wire_options(64, 255, true, true);
+	require(ipv4.ttl == 64 && ipv4.tos == 255 && ipv4.dont_fragment,
+		"IPv4 TTL/ToS/DF parameters changed");
+	const auto ipv6 = make_wire_options(64, 255, true, false);
+	require(ipv6.ttl == 64 && ipv6.tos == 255 && !ipv6.dont_fragment,
+		"IPv4-only DF flag leaked into IPv6");
+}
+
 void fuzz_json_parser_offline()
 {
 	std::uint64_t state = 0x243f6a8885a308d3ull;
@@ -477,6 +507,7 @@ int main()
 		test_grace_cancellation_is_not_loss();
 		test_deterministic_scheduler_resource_budget();
 		test_route_policy_scripted_changes();
+		test_probe_packet_parameters();
 		fuzz_json_parser_offline();
 		std::cout << "All probe scheduler tests passed.\n";
 		return 0;