Socks5Client.cs

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Events;
using Waher.Networking.Sniffers;
using Waher.Security;
 
namespace Waher.Networking.XMPP.P2P.SOCKS5
{
    public enum Socks5State
    {
        Offline,
 
        Connecting,
 
        Initializing,
 
        Authenticating,
 
        Authenticated,
 
        Connected,
 
        Error
    }
 
    public class Socks5Client : CommunicationLayer, IDisposable, IHostReference
    {
        private BinaryTcpClient client;
        private Socks5State state = Socks5State.Offline;
        private readonly object synchObj = new object();
        private readonly string host;
        private readonly int port;
        private readonly string jid;
        private bool closeWhenDone = false;
        private bool disposed = false;
        private object callbackState;
        private object tag = null;
        private bool isWriting = false;
 
        public Socks5Client(string Host, int Port, string JID, params ISniffer[] Sniffers)
            : base(false, Sniffers)
        {
            this.host = Host;
            this.port = Port;
            this.jid = JID;
 
            Task.Run(async () =>
            {
                try
                {
                    await this.SetState(Socks5State.Connecting);
                    await this.Information("Connecting to " + this.host + ":" + this.port.ToString());
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            });
 
            this.client = new BinaryTcpClient(false);
            this.Connect();
        }
 
        private async void Connect()
        {
            try
            {
                this.client.OnReceived += this.Client_OnReceived;
                this.client.OnSent += this.Client_OnSent;
                this.client.OnError += this.Client_OnError;
                this.client.OnDisconnected += this.Client_OnDisconnected;
                this.client.OnWriteQueueEmpty += this.Client_OnWriteQueueEmpty;
 
                await this.client.ConnectAsync(this.host, this.port);
                if (this.disposed)
                    return;
 
                await this.Information("Connected to " + this.host + ":" + this.port.ToString());
 
                this.state = Socks5State.Initializing;
                await this.SendPacket(new byte[] { 5, 1, 0 });
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                await this.SetState(Socks5State.Error);
            }
        }
 
        private async Task Client_OnWriteQueueEmpty(object Sender, EventArgs e)
        {
            bool DoDispose;
 
            lock (this.synchObj)
            {
                this.isWriting = false;
                DoDispose = this.closeWhenDone;
            }
 
            if (DoDispose)
                this.Dispose();
            else
                await this.OnWriteQueueEmpty.Raise(this, e);
        }
 
        private Task Client_OnDisconnected(object Sender, EventArgs e)
        {
            return this.SetState(Socks5State.Offline);
        }
 
        private Task Client_OnError(object Sender, Exception Exception)
        {
            return this.SetState(Socks5State.Error);
        }
 
        private Task Client_OnSent(object Sender, byte[] Buffer, int Offset, int Count)
        {
            if (this.HasSniffers)
                return this.TransmitBinary(BinaryTcpClient.ToArray(Buffer, Offset, Count));
            else
                return Task.CompletedTask;
        }
 
        private async Task<bool> Client_OnReceived(object Sender, byte[] Buffer, int Offset, int Count)
        {
            if (this.HasSniffers)
                await this.ReceiveBinary(BinaryTcpClient.ToArray(Buffer, Offset, Count));
 
            try
            {
                await this.ParseIncoming(Buffer, Offset, Count);
                return true;
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                return false;
            }
        }
 
        public Socks5State State => this.state;
 
        internal async Task SetState(Socks5State NewState)
        {
            if (this.state != NewState)
            {
                this.state = NewState;
                await this.Information("State changed to " + this.state.ToString());
 
                await this.OnStateChange.Raise(this, EventArgs.Empty);
            }
        }
 
        internal object CallbackState
        {
            get => this.callbackState;
            set => this.callbackState = value;
        }
 
        public object Tag
        {
            get => this.tag;
            set => this.tag = value;
        }
 
        public event EventHandlerAsync OnStateChange = null;
 
        public string Host => this.host;
 
        public int Port => this.port;
 
        public string JID => this.jid;
 
        public void Dispose()
        {
            if (!this.disposed)
            {
                this.disposed = true;
                Task _ = this.SetState(Socks5State.Offline);
 
                this.client?.Dispose();
                this.client = null;
            }
        }
 
        public Task<bool> Send(byte[] Data)
        {
            if (this.state != Socks5State.Connected)
                throw new IOException("SOCKS5 connection not open.");
 
            return this.SendPacket(Data);
        }
 
        private Task<bool> SendPacket(byte[] Data)
        {
            lock (this.synchObj)
            {
                this.isWriting = true;
            }
 
            return this.client.SendAsync(Data);
        }
 
        public event EventHandlerAsync OnWriteQueueEmpty = null;
 
        public void CloseWhenDone()
        {
            lock (this.synchObj)
            {
                if (this.isWriting)
                {
                    this.closeWhenDone = true;
                    return;
                }
            }
 
            this.Dispose();
        }
 
        private async Task ParseIncoming(byte[] Buffer, int Offset, int Count)
        {
            if (this.state == Socks5State.Connected)
                await this.OnDataReceived.Raise(this, new DataReceivedEventArgs(Buffer, Offset, Count, this, this.callbackState), false);
            else if (this.state == Socks5State.Initializing)
            {
                if (Count < 2 || Buffer[Offset++] < 5)
                {
                    await this.ToError();
                    return;
                }
 
                byte Method = Buffer[Offset++];
 
                switch (Method)
                {
                    case 0: // No authentication.
                        await this.SetState(Socks5State.Authenticated);
                        break;
 
                    default:
                        await this.ToError();
                        return;
                }
            }
            else
            {
                int c = Offset + Count;
 
                if (Count < 5 || Buffer[Offset++] < 5)
                {
                    await this.ToError();
                    return;
                }
 
                byte REP = Buffer[Offset++];
 
                switch (REP)
                {
                    case 0: // Succeeded
                        await this.SetState(Socks5State.Connected);
                        break;
 
                    case 1:
                        await this.Error("General SOCKS server failure.");
                        await this.ToError();
                        break;
 
                    case 2:
                        await this.Error("Connection not allowed by ruleset.");
                        await this.ToError();
                        break;
 
                    case 3:
                        await this.Error("Network unreachable.");
                        await this.ToError();
                        break;
 
                    case 4:
                        await this.Error("Host unreachable.");
                        await this.ToError();
                        break;
 
                    case 5:
                        await this.Error("Connection refused.");
                        await this.ToError();
                        break;
 
                    case 6:
                        await this.Error("TTL expired.");
                        await this.ToError();
                        break;
 
                    case 7:
                        await this.Error("Command not supported.");
                        await this.ToError();
                        break;
 
                    case 8:
                        await this.Error("Address type not supported.");
                        await this.ToError();
                        break;
 
                    default:
                        await this.Error("Unrecognized error code returned: " + REP.ToString());
                        await this.ToError();
                        break;
                }
 
                Offset++;
 
                byte ATYP = Buffer[Offset++];
                IPAddress Addr = null;
                string DomainName = null;
 
                switch (ATYP)
                {
                    case 1: // IPv4.
                        if (Offset + 4 > c)
                        {
                            await this.Error("Expected more bytes.");
                            await this.ToError();
                            return;
                        }
 
                        byte[] A = new byte[4];
                        Array.Copy(Buffer, Offset, A, 0, 4);
                        Offset += 4;
                        Addr = new IPAddress(A);
                        break;
 
                    case 3: // Domain name.
                        byte NrBytes = Buffer[Offset++];
                        if (Offset + NrBytes > c)
                        {
                            await this.Error("Expected more bytes.");
                            await this.ToError();
                            return;
                        }
 
                        DomainName = Encoding.ASCII.GetString(Buffer, Offset, NrBytes);
                        Offset += NrBytes;
                        break;
 
                    case 4: // IPv6.
                        if (Offset + 16 > c)
                        {
                            await this.Error("Expected more bytes.");
                            await this.ToError();
                            return;
                        }
 
                        A = new byte[16];
                        Array.Copy(Buffer, Offset, A, 0, 16);
                        Offset += 16;
                        Addr = new IPAddress(A);
                        break;
 
                    default:
                        await this.ToError();
                        return;
                }
 
                if (Offset + 2 != c)
                {
                    await this.Error("Invalid number of bytes received.");
                    await this.ToError();
                    return;
                }
 
                int Port = Buffer[Offset++];
                Port <<= 8;
                Port |= Buffer[Offset++];
 
                await this.OnResponse.Raise(this, new ResponseEventArgs(REP, Addr, DomainName, Port), false);
            }
        }
 
        public event EventHandlerAsync<ResponseEventArgs> OnResponse = null;
 
        public event EventHandlerAsync<DataReceivedEventArgs> OnDataReceived = null;
 
        private async Task ToError()
        {
            await this.SetState(Socks5State.Error);
            this.client.Dispose();
        }
 
        private Task Request(Command Command, IPAddress DestinationAddress, int Port)
        {
            using (MemoryStream Req = new MemoryStream())
            {
                Req.WriteByte(5);
                Req.WriteByte((byte)Command);
                Req.WriteByte(0);
 
                if (DestinationAddress.AddressFamily == AddressFamily.InterNetwork)
                    Req.WriteByte(1);
                else if (DestinationAddress.AddressFamily == AddressFamily.InterNetworkV6)
                    Req.WriteByte(4);
                else
                    throw new ArgumentException("Invalid address family.", nameof(DestinationAddress));
 
                byte[] Addr = DestinationAddress.GetAddressBytes();
                Req.Write(Addr, 0, Addr.Length);
                Req.WriteByte((byte)(Port >> 8));
                Req.WriteByte((byte)Port);
 
                return this.SendPacket(Req.ToArray());
            }
        }
 
        private Task Request(Command Command, string DestinationDomainName, int Port)
        {
            using (MemoryStream Req = new MemoryStream())
            {
                Req.WriteByte(5);
                Req.WriteByte((byte)Command);
                Req.WriteByte(0);
                Req.WriteByte(3);
 
                byte[] Bytes = Encoding.ASCII.GetBytes(DestinationDomainName);
                int c = Bytes.Length;
                if (c > 255)
                    throw new IOException("Domain name too long.");
 
                Req.WriteByte((byte)c);
                Req.Write(Bytes, 0, Bytes.Length);
                Req.WriteByte((byte)(Port >> 8));
                Req.WriteByte((byte)Port);
 
                return this.SendPacket(Req.ToArray());
            }
        }
 
        public Task CONNECT(IPAddress DestinationAddress, int Port)
        {
            return this.Request(Command.CONNECT, DestinationAddress, Port);
        }
 
        public Task CONNECT(string DestinationDomainName, int Port)
        {
            return this.Request(Command.CONNECT, DestinationDomainName, Port);
        }
 
        public Task CONNECT(string StreamID, string RequesterJID, string TargetJID)
        {
            string s = StreamID + RequesterJID + TargetJID;
            byte[] Hash = Hashes.ComputeSHA1Hash(Encoding.UTF8.GetBytes(s));
            StringBuilder sb = new StringBuilder();
 
            foreach (byte b in Hash)
                sb.Append(b.ToString("x2"));
 
            return this.CONNECT(sb.ToString(), 0);
        }
 
        public Task BIND(IPAddress DestinationAddress, int Port)
        {
            return this.Request(Command.BIND, DestinationAddress, Port);
        }
 
        public Task BIND(string DestinationDomainName, int Port)
        {
            return this.Request(Command.BIND, DestinationDomainName, Port);
        }
 
        public Task UDP_ASSOCIATE(IPAddress DestinationAddress, int Port)
        {
            return this.Request(Command.UDP_ASSOCIATE, DestinationAddress, Port);
        }
 
        public Task UDP_ASSOCIATE(string DestinationDomainName, int Port)
        {
            return this.Request(Command.UDP_ASSOCIATE, DestinationDomainName, Port);
        }
 
    }
}