Core,TL,Gen: Transport layer rewrite

  - Upgrade .NET to 4.7.2 to use .NET Standard dependency
  Reason: https://docs.microsoft.com/en-us/dotnet/standard/net-standard
  - Uses obfuscated WebSocket transport instead of TCP
  - Adds asynchronous response handling

Author: aarani

src/TgSharp.Core/Auth/Authenticator.cs

@@ -1,45 +1,60 @@
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 using TgSharp.Core.Network;
 
 namespace TgSharp.Core.Auth
 {
-    public static class Authenticator
+    public class Authenticator
     {
-        public static async Task<Step3_Response> DoAuthentication(TcpTransport transport, CancellationToken token = default(CancellationToken))
+        private readonly MtProtoPlainSender sender;
+        private TaskCompletionSource<Step3_Response> completionSource;
+        public Authenticator(WSTransport transport)
         {
-            token.ThrowIfCancellationRequested();
+            sender = new MtProtoPlainSender(transport);
+            completionSource = new TaskCompletionSource<Step3_Response>();
+        }
 
-            var sender = new MtProtoPlainSender(transport);
+        public Task<Step3_Response> DoAuthentication()
+        {
             var step1 = new Step1_PQRequest();
 
-            await sender.Send(step1.ToBytes(), token).ConfigureAwait(false);
-            var step1Response = step1.FromBytes(await sender.Receive(token)
-                .ConfigureAwait(false));
+            sender.OnResponseReceived = (step1Message) => Sender_OnStep1ResponseReceived(step1, step1Message); 
+            sender.Send(step1.ToBytes());
+
+            return completionSource.Task;
+        }
+
+        private void Sender_OnStep1ResponseReceived(Step1_PQRequest step1, byte[] step1Message)
+        {
+            var step1Response = step1.FromBytes(step1Message);
 
             var step2 = new Step2_DHExchange();
-            await sender.Send(step2.ToBytes(
+            sender.OnResponseReceived = (step2message) => Sender_OnStep2ResponseReceived(step2, step2message);
+            sender.Send(step2.ToBytes(
                     step1Response.Nonce,
                     step1Response.ServerNonce,
                     step1Response.Fingerprints,
-                    step1Response.Pq), token)
-                .ConfigureAwait(false);
+                    step1Response.Pq));
+        }
+
+        private void Sender_OnStep2ResponseReceived(Step2_DHExchange step2, byte[] step2message)
+        {
+            var step2Response = step2.FromBytes(step2message);
 
-            var step2Response = step2.FromBytes(await sender.Receive(token)
-                .ConfigureAwait(false));
 
             var step3 = new Step3_CompleteDHExchange();
-            await sender.Send(step3.ToBytes(
+            sender.OnResponseReceived = (step3Message) => Sender_OnStep3ResponseReceived(step3, step3Message);
+            sender.Send(step3.ToBytes(
                     step2Response.Nonce,
                     step2Response.ServerNonce,
                     step2Response.NewNonce,
-                    step2Response.EncryptedAnswer), token)
-                .ConfigureAwait(false);
-
-            var step3Response = step3.FromBytes(await sender.Receive(token)
-                .ConfigureAwait(false));
+                    step2Response.EncryptedAnswer));
+        }
 
-            return step3Response;
+        private void Sender_OnStep3ResponseReceived(Step3_CompleteDHExchange step3, byte[] response)
+        {
+            completionSource.SetResult(step3.FromBytes(response));
         }
     }
 }

src/TgSharp.Core/Network/Message.cs

@@ -0,0 +1,46 @@
+using System;
+using System.IO;
+using System.Linq;
+using TgSharp.Core.MTProto.Crypto;
+
+namespace TgSharp.Core.Network
+{
+    public class Message
+    {
+        public byte[] Body { get; private set; }
+
+        public Message(byte[] body)
+        {
+            if (body == null)
+                throw new ArgumentNullException(nameof(body));
+
+            Body = body;
+        }
+
+        public static Message Decode(byte[] body)
+        {
+            using (var memoryStream = new MemoryStream(body))
+            {
+                using (var binaryReader = new BinaryReader(memoryStream))
+                {
+                    int length = binaryReader.ReadInt32();
+                    return new Message(binaryReader.ReadBytes(length));
+                }
+            }
+        }
+
+        public byte[] Encode()
+        {
+            using (var memoryStream = new MemoryStream())
+            {
+                using (var binaryWriter = new BinaryWriter(memoryStream))
+                {
+                    binaryWriter.Write(Body.Length);
+                    binaryWriter.Write(Body);
+                    return memoryStream.ToArray();
+                }
+            }
+        }
+
+    }
+}

src/TgSharp.Core/Network/MtProtoPlainSender.cs

@@ -7,21 +7,37 @@ namespace TgSharp.Core.Network
 {
     public class MtProtoPlainSender
     {
+        public Action<byte[]> OnResponseReceived;
+
         private int timeOffset;
         private long lastMessageId;
         private Random random;
-        private TcpTransport transport;
+        private WSTransport transport;
 
-        public MtProtoPlainSender(TcpTransport transport)
+        public MtProtoPlainSender(WSTransport transport)
         {
             this.transport = transport;
+            transport.OnUnencryptedMessage += Transport_OnUnencryptedMessage;
             random = new Random();
         }
 
-        public async Task Send(byte[] data, CancellationToken token = default(CancellationToken))
+        private void Transport_OnUnencryptedMessage(Message message)
         {
-            token.ThrowIfCancellationRequested();
+            using (var memoryStream = new MemoryStream(message.Body))
+            using (var binaryReader = new BinaryReader(memoryStream))
+            {
+                long authKeyid = binaryReader.ReadInt64();
+                long messageId = binaryReader.ReadInt64();
+                int messageLength = binaryReader.ReadInt32();
+
+                byte[] response = binaryReader.ReadBytes(messageLength);
 
+                OnResponseReceived?.Invoke(response);
+            }
+        }
+
+        public void Send(byte[] data)
+        {
             using (var memoryStream = new MemoryStream())
             {
                 using (var binaryWriter = new BinaryWriter(memoryStream))
@@ -33,28 +49,7 @@ public MtProtoPlainSender(TcpTransport transport)
 
                     byte[] packet = memoryStream.ToArray();
 
-                    await transport.Send(packet, token).ConfigureAwait(false);
-                }
-            }
-        }
-
-        public async Task<byte[]> Receive(CancellationToken token = default(CancellationToken))
-        {
-            token.ThrowIfCancellationRequested();
-
-            var result = await transport.Receive(token).ConfigureAwait(false);
-
-            using (var memoryStream = new MemoryStream(result.Body))
-            {
-                using (BinaryReader binaryReader = new BinaryReader(memoryStream))
-                {
-                    long authKeyid = binaryReader.ReadInt64();
-                    long messageId = binaryReader.ReadInt64();
-                    int messageLength = binaryReader.ReadInt32();
-
-                    byte[] response = binaryReader.ReadBytes(messageLength);
-
-                    return response;
+                    transport.Send(packet);
                 }
             }
         }