implement Socks5 pipeline

Author: saadati944

Socksy.Core.Test/Dtos/SetMethodDTOTests.cs

@@ -7,14 +7,14 @@ public void Send_SendsDtoOverSocket()
     {
         // Arrange
         byte ver = 5;
-        byte method = 0;
+        AuthenticationMETHOD method = AuthenticationMETHOD.NO_ACCEPTABLE_METHODS;
         var dto = SetMethodDTO.Create(ver, method);
         var socket = new SocketMock();
 
         // Act
         dto.Send(socket);
 
         // Assert
-        Assert.Equal(new byte[] { ver, method }, socket.SentData);
+        Assert.Equal(new byte[] { ver, (byte)method }, socket.SentData);
     }
 }

Socksy.Core.Test/Dtos/SocketMock.cs

@@ -10,6 +10,15 @@ internal class SocketMock : ISocket
     public List<byte> SentData => _sentData;
     public bool Disposed => _disposed;
 
+    public bool Connected => throw new NotImplementedException();
+
+    public int Available => throw new NotImplementedException();
+
+    public int ReceiveTimeout { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+    public int SendTimeout { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+
+    public IPEndPoint RemoteEndPoint => throw new NotImplementedException();
+
     public SocketMock()
     {
         DataToReceive = new();
@@ -60,4 +69,14 @@ public void Dispose()
     {
         _disposed = true;
     }
+
+    public bool Poll(int v, SelectMode selectRead)
+    {
+        throw new NotImplementedException();
+    }
+
+    public void Close()
+    {
+        throw new NotImplementedException();
+    }
 }

Socksy.Core/Common/AuthenticationMETHOD.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Socksy.Core.Common
+{
+    public enum AuthenticationMETHOD
+    {
+        NO_AUTHENTICATION_REQUIRED = 0x00,
+        GSSAPI = 0x01,
+        USERNAME_PASSWORD = 0x02,
+        to_X_7F_IANA_ASSIGNED = 0x03,
+        to_X_FE_RESERVED_FOR_PRIVATE_METHODS = 0x80,
+        NO_ACCEPTABLE_METHODS = 0xFF
+    }
+}

Socksy.Core/Common/Request.cs

@@ -3,6 +3,7 @@
 public struct Request
 {
     public TcpClient TcpClient { get; internal init; }
+    internal ISocket CreateSocket() => new SocketWrapper(TcpClient.Client);
 
     internal static Request CreateFromTcpClient(TcpClient client)
         => new Request { TcpClient = client };

Socksy.Core/Dtos/RequestDTO.cs

@@ -25,16 +25,17 @@ private RequestDTO()
 
     public static RequestDTO GetFromSocket(ISocket socket)
     {
-        var data = Helper.RentByteArray(256);
+        var data = new byte[4];
 
-        var received = socket.Receive(data, 0, 4);
+        var received = socket.Receive(data);
         Helper.EnsureReceivedBytes(received, 4);
-
         var ver = data[0];
         var cmd = data[1];
         var rsv = data[2];
         var atype = data[3];
 
+        data = Helper.RentByteArray(256);
+
         var dstAddrLen = 0;
         switch (atype)
         {

Socksy.Core/Dtos/SetMethodDTO.cs

@@ -1,15 +1,17 @@
-namespace Socksy.Core.Dtos;
+using Socksy.Core.Common;
+
+namespace Socksy.Core.Dtos;
 
 internal class SetMethodDTO
 {
     public byte VER { get; private set; }
-    public byte METHOD { get; private set; }
+    public AuthenticationMETHOD METHOD { get; private set; }
 
     private SetMethodDTO()
     {
     }
 
-    public static SetMethodDTO Create(byte ver, byte method)
+    public static SetMethodDTO Create(byte ver, AuthenticationMETHOD method)
     {
         return new SetMethodDTO
         {
@@ -20,7 +22,7 @@ public static SetMethodDTO Create(byte ver, byte method)
 
     public void Send(ISocket socket)
     {
-        var sent = socket.Send(stackalloc byte[] { VER, METHOD });
+        var sent = socket.Send(stackalloc byte[] { VER, (byte)METHOD });
         Helper.EnsureSentBytes(sent, 2);
     }
 }

Socksy.Core/Network/ISocket.cs

@@ -2,9 +2,17 @@
 
 internal interface ISocket : IDisposable
 {
+    bool Connected { get; }
+    int Available { get; }
+    int ReceiveTimeout { get; set; }
+    int SendTimeout { get; set; }
+    public IPEndPoint RemoteEndPoint { get; }
+
     public int Send(Span<byte> data);
     public int Send(byte[] data, int offset, int length);
     public int Receive(byte[] data);
     public int Receive(Span<byte> data);
     public int Receive(byte[] data, int offset, int length);
+    bool Poll(int v, SelectMode selectRead);
+    void Close();
 }

Socksy.Core/Network/SocketWrapper.cs

@@ -1,9 +1,42 @@
-namespace Socksy.Core.Network;
+using System.Net.Sockets;
 
-internal class SocketWrapper : ISocket, IDisposable
+namespace Socksy.Core.Network;
+
+internal struct SocketWrapper : ISocket, IDisposable
 {
     private Socket _socket;
 
+    public bool Connected => _socket.Connected;
+
+    public int Available => _socket.Available;
+
+    public int ReceiveTimeout
+    {
+        get
+        {
+            return _socket.ReceiveTimeout;
+        }
+        set
+        {
+            _socket.ReceiveTimeout = value;
+        }
+    }
+
+    public IPEndPoint RemoteEndPoint
+        => _socket.RemoteEndPoint as IPEndPoint;
+
+    public int SendTimeout
+    {
+        get
+        {
+            return _socket.SendTimeout;
+        }
+        set
+        {
+            _socket.SendTimeout = value;
+        }
+    }
+
     public SocketWrapper(Socket socket)
     {
         _socket = socket;
@@ -16,7 +49,10 @@ public int Receive(byte[] data)
 
     public int Receive(byte[] data, int offset, int length)
     {
-        return _socket.Receive(data, offset, length, SocketFlags.None);
+        Span<byte> buff = stackalloc byte[length];
+        int received = _socket.Receive(buff);
+        buff.CopyTo(data.AsSpan(offset, length));
+        return received;
     }
 
     public int Receive(Span<byte> data)
@@ -31,11 +67,22 @@ public int Send(Span<byte> data)
 
     public int Send(byte[] data, int offset, int length)
     {
-        return _socket.Send(data, offset, length, SocketFlags.None);
+        Span<byte> buff = data.AsSpan(offset, length);
+        return _socket.Send(buff);
     }
 
     public void Dispose()
     {
         _socket.Dispose();
     }
+
+    public bool Poll(int v, SelectMode selectRead)
+    {
+        return _socket.Poll(v, selectRead);
+    }
+
+    public void Close()
+    {
+        _socket.Close();
+    }
 }

Socksy.Core/Network/TcpServer.cs

@@ -5,21 +5,27 @@ namespace Socksy.Core.Network;
 internal sealed class TcpServer : IDisposable
 {
     private readonly TcpListener _listener;
-    private readonly Func<TcpClient, Task> _onConnectionEstablished;
+    private readonly Func<int, Request, Task> _onConnectionEstablished;
     private CancellationTokenSource? _cancellationTokenSource;
     private CancellationToken _cancellationToken;
+    private IPEndPoint _localEndPoint;
     private int _activeRequests;
     private bool _isListening;
+    private int _reqNum = 0;
 
-    public TcpServer(IPEndPoint localEndPoint, Func<TcpClient, Task> onConnectionEstablished)
+    public TcpServer(IPEndPoint localEndPoint, Func<int, Request, Task> onConnectionEstablished)
     {
+        _localEndPoint = localEndPoint;
         _listener = new TcpListener(localEndPoint);
         _onConnectionEstablished = onConnectionEstablished;
         _isListening = false;
     }
 
     public bool IsListening => _isListening;
 
+    public int ListeningPort => _localEndPoint.Port;
+    public IPAddress ListeningAddress => _localEndPoint.Address;
+
     public void Start()
     {
         if (_isListening)
@@ -34,7 +40,7 @@ public void Start()
 
     public void Stop()
     {
-        if(!_isListening)
+        if (!_isListening)
             return;
 
         _listener.Stop();
@@ -45,20 +51,22 @@ public void Stop()
 
     private async Task MainLoop()
     {
-        while(!_cancellationToken.IsCancellationRequested)
+        while (!_cancellationToken.IsCancellationRequested)
         {
             var tcpClient = await _listener.AcceptTcpClientAsync(_cancellationToken);
             Interlocked.Add(ref _activeRequests, 1);
+            Interlocked.Add(ref _reqNum, 1);
 
-            _ = _onConnectionEstablished(tcpClient).ContinueWith((t) => {
+            _ = _onConnectionEstablished(_reqNum, Request.CreateFromTcpClient(tcpClient)).ContinueWith((t) =>
+            {
                 Interlocked.Add(ref _activeRequests, -1);
             });
         }
     }
 
     private async Task WaitForAllActiveConnectionRequestsToComplete()
     {
-        while(_activeRequests > 0)
+        while (_activeRequests > 0)
         {
             await Task.Delay(10);
         }