Bugfix/review round1

AGENTS.md

@@ -0,0 +1,8 @@
+
+# ZTSharp
+ZTSharp is a fully managed c# library that implements the Zerotier protocol without relying on unmanaged code or external dependencies. 
+
+# Rules
+- Do not use or reuse official Zerotier services, connections or identities from the current host. The library **must** be self-contained and not rely on any existing Zerotier configuration or services on the host machine.
+- The source code must be written in clean, modular, easy to understand and maintainable style. It should follow best practices in c#.
+- The source code must be high-performant and efficient, minimizing resource usage and maximizing speed (Eg use ArrayPool, Span, etc... instead of creating new arrays or lists all of the time (especially hot paths)).

ZTSharp.Tests/AtomicFileTests.cs

@@ -10,16 +10,23 @@ public async Task WriteAllBytesAsync_Throws_WhenAtomicMoveNeverSucceeds()
         var root = TestTempPaths.CreateGuidSuffixed("zt-atomic-file-");
         Directory.CreateDirectory(root);
 
-        var destination = Path.Combine(root, "dest");
-        Directory.CreateDirectory(destination);
-
-        var ex = await Assert.ThrowsAsync<IOException>(async () =>
+        try
         {
-            await AtomicFile.WriteAllBytesAsync(destination, new byte[] { 1, 2, 3 }, CancellationToken.None);
-        });
+            var destination = Path.Combine(root, "dest");
+            Directory.CreateDirectory(destination);
+
+            var ex = await Assert.ThrowsAsync<IOException>(async () =>
+            {
+                await AtomicFile.WriteAllBytesAsync(destination, new byte[] { 1, 2, 3 }, CancellationToken.None);
+            });
 
-        Assert.Contains("Atomic replace failed", ex.Message, StringComparison.OrdinalIgnoreCase);
-        Assert.True(Directory.Exists(destination));
+            Assert.Contains("Atomic replace failed", ex.Message, StringComparison.OrdinalIgnoreCase);
+            Assert.True(Directory.Exists(destination));
+        }
+        finally
+        {
+            Directory.Delete(root, recursive: true);
+        }
     }
 }
 

ZTSharp.Tests/BoundedFileIOBomTests.cs

@@ -0,0 +1,29 @@
+using System.Text;
+using ZTSharp.Internal;
+
+namespace ZTSharp.Tests;
+
+public sealed class BoundedFileIOBomTests
+{
+    [Fact]
+    public void TryReadAllText_StripsUtf8Bom()
+    {
+        var path = TestTempPaths.CreateGuidSuffixed("bounded-io-bom-");
+        try
+        {
+            var payload = Encoding.UTF8.GetPreamble().Concat(Encoding.UTF8.GetBytes("hello")).ToArray();
+            File.WriteAllBytes(path, payload);
+
+            Assert.True(BoundedFileIO.TryReadAllText(path, maxBytes: 1024, Encoding.UTF8, out var text));
+            Assert.Equal("hello", text);
+        }
+        finally
+        {
+            if (File.Exists(path))
+            {
+                File.Delete(path);
+            }
+        }
+    }
+}
+

ZTSharp.Tests/ChannelWriterConcurrencyTests.cs

@@ -34,9 +34,9 @@ public async Task InMemoryZtUdpClient_ReceivesDatagrams_UnderConcurrentSends()
             sendTasks[i] = sender.SendToAsync(payload, receiverId, remotePort: 30000);
         }
 
-        await Task.WhenAll(sendTasks).WaitAsync(TimeSpan.FromSeconds(2));
+        await Task.WhenAll(sendTasks).WaitAsync(TimeSpan.FromSeconds(10));
 
-        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(2));
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
         var seen = new bool[count];
         for (var i = 0; i < count; i++)
         {
@@ -68,7 +68,7 @@ public async Task InMemoryOverlayTcpListener_AcceptsMultipleConcurrentClients()
 
         await using var listener = new OverlayTcpListener(serverNode, networkId, serverPort);
 
-        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
         var acceptTask = Task.Run(async () =>
         {
             var accepted = new List<OverlayTcpClient>(capacity: count);
@@ -94,8 +94,8 @@ public async Task InMemoryOverlayTcpListener_AcceptsMultipleConcurrentClients()
             }, cts.Token);
         }
 
-        await Task.WhenAll(connectTasks).WaitAsync(TimeSpan.FromSeconds(5), cts.Token);
-        var acceptedClients = await acceptTask.WaitAsync(TimeSpan.FromSeconds(5), cts.Token);
+        await Task.WhenAll(connectTasks).WaitAsync(TimeSpan.FromSeconds(10), cts.Token);
+        var acceptedClients = await acceptTask.WaitAsync(TimeSpan.FromSeconds(10), cts.Token);
         Assert.Equal(count, acceptedClients.Count);
 
         foreach (var accepted in acceptedClients)
@@ -158,36 +158,33 @@ void CaptureSyn(in RawFrame frame)
             await using var client = new OverlayTcpClient(clientNode, networkId, clientPort);
             await client.ConnectAsync(serverNode.NodeId.Value, serverPort);
 
-            await using var _ = await acceptTask.WaitAsync(TimeSpan.FromSeconds(2));
+            await using var _ = await acceptTask.WaitAsync(TimeSpan.FromSeconds(10));
 
-            var (connectionId, sourcePort) = await synInfoTcs.Task.WaitAsync(TimeSpan.FromSeconds(2));
+            var (connectionId, sourcePort) = await synInfoTcs.Task.WaitAsync(TimeSpan.FromSeconds(10));
 
             const int frames = 500;
             var payload = Encoding.ASCII.GetBytes("abcdefgh");
 
             var sendTasks = new Task[frames];
             for (var i = 0; i < frames; i++)
             {
-                sendTasks[i] = Task.Run(async () =>
-                {
-                    var dataFrame = new byte[OverlayTcpFrameCodec.HeaderLength + payload.Length];
-                    OverlayTcpFrameCodec.BuildHeader(
-                        OverlayTcpFrameCodec.FrameType.Data,
-                        sourcePort: serverPort,
-                        destinationPort: clientPort,
-                        destinationNodeId: clientNode.NodeId.Value,
-                        connectionId,
-                        dataFrame);
-                    payload.CopyTo(dataFrame.AsSpan(OverlayTcpFrameCodec.HeaderLength));
-                    await serverNode.SendFrameAsync(networkId, dataFrame);
-                });
+                var dataFrame = new byte[OverlayTcpFrameCodec.HeaderLength + payload.Length];
+                OverlayTcpFrameCodec.BuildHeader(
+                    OverlayTcpFrameCodec.FrameType.Data,
+                    sourcePort: serverPort,
+                    destinationPort: clientPort,
+                    destinationNodeId: clientNode.NodeId.Value,
+                    connectionId,
+                    dataFrame);
+                payload.CopyTo(dataFrame.AsSpan(OverlayTcpFrameCodec.HeaderLength));
+                sendTasks[i] = serverNode.SendFrameAsync(networkId, dataFrame);
             }
 
-            await Task.WhenAll(sendTasks).WaitAsync(TimeSpan.FromSeconds(2));
+            await Task.WhenAll(sendTasks).WaitAsync(TimeSpan.FromSeconds(20));
 
             var clientStream = client.GetStream();
             var buffer = new byte[frames * payload.Length];
-            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(2));
+            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(20));
             var read = await StreamTestHelpers.ReadExactAsync(clientStream, buffer, buffer.Length, cts.Token);
             Assert.Equal(buffer.Length, read);
         }

ZTSharp.Tests/DirectBootstrapProbeCursorTests.cs

@@ -0,0 +1,37 @@
+using System.Net;
+using ZTSharp.ZeroTier.Internal;
+
+namespace ZTSharp.Tests;
+
+public sealed class DirectBootstrapProbeCursorTests
+{
+    [Fact]
+    public void TakeNextEndpoints_RotatesAcrossCandidates()
+    {
+        var cursor = new DirectBootstrapProbeCursor();
+        var endpoints = new[]
+        {
+            new IPEndPoint(IPAddress.Parse("176.66.90.119"), 8212),
+            new IPEndPoint(IPAddress.Parse("176.66.90.119"), 19665),
+            new IPEndPoint(IPAddress.Parse("176.66.90.119"), 59827)
+        };
+
+        var first = cursor.TakeNextEndpoints(endpoints, budget: 2);
+        var second = cursor.TakeNextEndpoints(endpoints, budget: 2);
+
+        Assert.Equal(new[] { endpoints[0], endpoints[1] }, first);
+        Assert.Equal(new[] { endpoints[2], endpoints[0] }, second);
+    }
+
+    [Fact]
+    public void TakeNextSocketIndex_RotatesPerEndpoint()
+    {
+        var cursor = new DirectBootstrapProbeCursor();
+        var endpoint = new IPEndPoint(IPAddress.Parse("176.66.90.119"), 8212);
+
+        Assert.Equal(0, cursor.TakeNextSocketIndex(endpoint, socketCount: 3));
+        Assert.Equal(1, cursor.TakeNextSocketIndex(endpoint, socketCount: 3));
+        Assert.Equal(2, cursor.TakeNextSocketIndex(endpoint, socketCount: 3));
+        Assert.Equal(0, cursor.TakeNextSocketIndex(endpoint, socketCount: 3));
+    }
+}

ZTSharp.Tests/FileStateStoreSecurityTests.cs

@@ -1,17 +1,13 @@
 using System.Diagnostics;
-using System.Net;
 
 namespace ZTSharp.Tests;
 
 public sealed class FileStateStoreSecurityTests
 {
-    [Fact]
+    [SkippableFact]
     public async Task ReadAsync_Throws_WhenPathTraversesJunction()
     {
-        if (!OperatingSystem.IsWindows())
-        {
-            return;
-        }
+        Skip.IfNot(OperatingSystem.IsWindows(), "Junction traversal tests require Windows.");
 
         var root = TestTempPaths.CreateGuidSuffixed("zt-state-root-");
         Directory.CreateDirectory(root);
@@ -23,10 +19,7 @@ public async Task ReadAsync_Throws_WhenPathTraversesJunction()
         await File.WriteAllBytesAsync(secretPath, new byte[] { 1, 2, 3 });
 
         var junction = Path.Combine(root, "escape");
-        if (!TryCreateJunction(junction, outside))
-        {
-            return;
-        }
+        Skip.IfNot(TryCreateJunction(junction, outside), "Failed to create junction (insufficient privileges or mklink unavailable).");
 
         var store = new FileStateStore(root);
         _ = await Assert.ThrowsAsync<InvalidOperationException>(async () => await store.ReadAsync("escape/secret.bin"));
@@ -76,7 +69,19 @@ private static bool TryCreateJunction(string junctionPath, string targetPath)
                 return false;
             }
 
-            process.WaitForExit(milliseconds: 5000);
+            if (!process.WaitForExit(milliseconds: 5000))
+            {
+                try
+                {
+                    process.Kill(entireProcessTree: true);
+                }
+                catch
+                {
+                }
+
+                return false;
+            }
+
             return process.ExitCode == 0 && Directory.Exists(junctionPath);
         }
         catch

ZTSharp.Tests/Ipv6CodecAhHeaderTests.cs

@@ -0,0 +1,32 @@
+using System.Net;
+using ZTSharp.ZeroTier.Net;
+
+namespace ZTSharp.Tests;
+
+public sealed class Ipv6CodecAhHeaderTests
+{
+    [Fact]
+    public void TryParseTransportPayload_RejectsInvalidAhHeaderLength()
+    {
+        var src = IPAddress.Parse("2001:db8::1");
+        var dst = IPAddress.Parse("2001:db8::2");
+
+        var payload = new byte[8 + 8];
+        payload[0] = UdpCodec.ProtocolNumber; // next header
+        payload[1] = 0; // AH payload len (0 => 8 bytes total, invalid; must be >= 12 bytes)
+
+        var packet = new byte[40 + payload.Length];
+        packet[0] = 0x60; // version
+        packet[4] = (byte)(payload.Length >> 8);
+        packet[5] = (byte)(payload.Length & 0xFF);
+        packet[6] = 51; // AH
+        packet[7] = 64; // hop limit
+
+        src.GetAddressBytes().CopyTo(packet, 8);
+        dst.GetAddressBytes().CopyTo(packet, 24);
+        payload.CopyTo(packet, 40);
+
+        Assert.False(Ipv6Codec.TryParseTransportPayload(packet, out _, out _, out _, out _, out _));
+    }
+}
+