public void Write_Encrypted_ResultBytesAreExpected()
{
//Arrange
var expectedBytes = GetProtectedMessageHex();
var buffer = new byte[PacketBuffer.MaxPacketSize];
var version = PacketVersion.CreateByDraft(32);
var connectionIds = GetConnectionIdsHex();
var sourceConnectionId = PacketConnectionId.Parse(Utils.ParseHexString(connectionIds.SourceConnectionIdHex));
var destConnectionId = PacketConnectionId.Parse(Utils.ParseHexString(connectionIds.DestConnectionIdHex));
var packetNumber = PacketNumber.Parse(Utils.ParseHexString(GetPacketNumberHex()));
var token = PacketToken.Empty;
var clientHelloBytes = Utils.ParseHexString(GetTlsClientHelloHex());
var secrets = GetSecrets();
var aead = Cipher.TLS_AES_128_GCM_SHA256.CreateAead(Utils.ParseHexString(secrets.Iv), Utils.ParseHexString(secrets.Key));
var cipher = Cipher.TLS_AES_128_GCM_SHA256.CreateCipher(Utils.ParseHexString(secrets.Hp));
//Act
var cursor = new MemoryCursor(buffer);
using (InitialPacket.StartProtectedWriting(aead, cipher, cursor, version, destConnectionId, sourceConnectionId, packetNumber, token))
{
using (PaddingFrame.EnsureLength(cursor, 1162))
{
using (CryptoFrame.StartWriting(cursor, 0))
{
clientHelloBytes.CopyTo(cursor);
}
}
}
//Assert
Assert.Equal(expectedBytes, Utils.ToHexString(cursor.PeekStart().ToArray()), true);
}
public void TestDecode()
{
HexData samplePacket = new HexData("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");
byte[] bytes = samplePacket.bytes;
Packet p = Packet.Unpack(samplePacket.bytes);
Assert.AreEqual(p.GetType(), typeof(InitialPacket));
InitialPacket recP = p as InitialPacket;
Assert.AreEqual(0xff000017, recP.Version);
Assert.AreEqual((UInt32)18, recP.DCIDLength);
CollectionAssert.AreEqual((new HexData("a2702fa91b97cb3db9d7736d32f223193294")).bytes, recP.DCID);
Assert.AreEqual((UInt32)17, recP.SCIDLength);
CollectionAssert.AreEqual((new HexData("56221f7eed93c8ea78b87c0c80a55c60c6")).bytes, recP.SCID);
// Wireshark translates the initial 0xCF to 0b11000000 while our code translates it to 0b11001111
// Likely because of header protection, which we cannot have without QUIC-TLS
// PacketNumberLength and PacketNumber thus cannot be computed correctly
// Assert.AreEqual((UInt32)1, recP.PacketNumberLength);
// Assert.AreEqual((UInt32)0, recP.PacketNumber);
Assert.AreEqual((UInt64)0, recP.TokenLength.Value);
CollectionAssert.AreEqual(new byte[] { }, recP.Token);
Assert.AreEqual((UInt64)1187, recP.Length.Value);
// TODO: assert payload content
}
public void TestEncodeAndDecode()
{
// TODO: all the lengths fields should be set automatically (ex: DCIDLength should be auto computed from DCID)
InitialPacket sentP = new InitialPacket
{
DCIDLength = 2,
DCID = new byte[] { 0xab, 0xcd },
PacketNumberLength = 2,
SCIDLength = 3,
SCID = new byte[] { 0x12, 0x23, 0xcf },
PacketNumber = 1234,
TokenLength = new VariableLengthInteger(2),
Token = new byte[] { 0x42, 0x42 }
};
byte[] b = sentP.Encode();
Packet p = Packet.Unpack(b);
Assert.AreEqual(p.GetType(), typeof(InitialPacket));
InitialPacket recP = p as InitialPacket;
Assert.AreEqual(sentP.DCIDLength, recP.DCIDLength);
CollectionAssert.AreEqual(sentP.DCID, recP.DCID);
Assert.AreEqual(sentP.SCIDLength, recP.SCIDLength);
CollectionAssert.AreEqual(sentP.SCID, recP.SCID);
Assert.AreEqual(sentP.PacketNumberLength, recP.PacketNumberLength);
Assert.AreEqual(sentP.PacketNumber, recP.PacketNumber);
Assert.AreEqual(sentP.TokenLength.Value, recP.TokenLength.Value);
CollectionAssert.AreEqual(sentP.Token, recP.Token);
Assert.AreEqual(sentP.PacketNumberLength + 1200, recP.Length.Value); // 4 = PacketNumberLength + Payload.Length
// TODO: assert payload content
}
static void Main(string[] args)
{
byte[] bytes = new VariableInteger(12345);
VariableInteger integer = bytes;
UInt64 uinteger = integer;
int size = VariableInteger.Size(bytes[0]);
InitialPacket packet = new InitialPacket()
{
Version = 16,
SourceConnectionId = 124,
DestinationConnectionId = 0,
PacketNumber = 777521,
TokenLength = 0
};
packet = new PacketCreator().CreateInitialPacket(124, 0);
ConnectionCloseFrame frame = new ConnectionCloseFrame(ErrorCode.SERVER_BUSY, "The server is too busy to process your request.");
MaxStreamIdFrame msidframe = new MaxStreamIdFrame(144123, StreamType.ClientUnidirectional);
//packet.AttachFrame(frame);
packet.AttachFrame(msidframe);
byte[] data = packet.Encode();
string b64 = ToBase64(data);
byte[] shpdata1 = new byte[] { 1, 1, 2, 3, 5, 8 };
byte[] shpdata2 = new byte[] { 13, 21, 34, 55, 89, 144 };
ShortHeaderPacket shp = new ShortHeaderPacket();
shp.DestinationConnectionId = 124;
shp.PacketNumber = 2;
shp.AttachFrame(new StreamFrame()
{
StreamId = 1, Length = new VariableInteger((UInt64)shpdata2.Length), StreamData = shpdata2, Offset = 6, EndOfStream = true
});
shp.AttachFrame(new StreamFrame()
{
StreamId = 1, Length = new VariableInteger((UInt64)shpdata1.Length), StreamData = shpdata1, Offset = 0
});
string shpb64 = ToBase64(shp.Encode());
packet.Decode(data);
byte[] ccfData = frame.Encode();
frame.Decode(new ByteArray(ccfData));
byte[] streamIdData = new StreamId(123, StreamType.ClientUnidirectional);
StreamId streamId = streamIdData;
QuicListener listener = new QuicListener(11000);
listener.OnClientConnected += Listener_OnClientConnected;
listener.Start();
}
/// <summary>
/// Processes incomming initial packet and creates or halts a connection.
/// </summary>
/// <param name="packet">Initial Packet</param>
/// <param name="endPoint">Peer's endpoint</param>
/// <returns></returns>
private QuicConnection ProcessInitialPacket(Packet packet, IPEndPoint endPoint)
{
QuicConnection result = null;
UInt32 availableConnectionId;
byte[] data;
// Unsupported version. Version negotiation packet is sent only on initial connection. All other packets are dropped. (5.2.2 / 16th draft)
if (packet.Version != QuicVersion.CurrentVersion || !QuicVersion.SupportedVersions.Contains(packet.Version))
{
VersionNegotiationPacket vnp = _packetCreator.CreateVersionNegotiationPacket();
data = vnp.Encode();
_client.Send(data, data.Length, endPoint);
return(null);
}
InitialPacket cast = packet as InitialPacket;
InitialPacket ip = _packetCreator.CreateInitialPacket(0, cast.SourceConnectionId);
// Protocol violation if the initial packet is smaller than the PMTU. (pt. 14 / 16th draft)
if (cast.Encode().Length < QuicSettings.PMTU)
{
ip.AttachFrame(new ConnectionCloseFrame(ErrorCode.PROTOCOL_VIOLATION, "PMTU have not been reached."));
}
else if (ConnectionPool.AddConnection(new ConnectionData(_pwt, cast.SourceConnectionId, 0), out availableConnectionId) == true)
{
// Tell the peer the available connection id
ip.SourceConnectionId = (byte)availableConnectionId;
// We're including the maximum possible stream id during the connection handshake. (4.5 / 16th draft)
ip.AttachFrame(new MaxStreamsFrame(QuicSettings.MaximumStreamId, StreamType.ServerBidirectional));
// Set the return result
result = ConnectionPool.Find(availableConnectionId);
}
else
{
// Not accepting connections. Send initial packet with CONNECTION_CLOSE frame.
// TODO: Buffering. The server might buffer incomming 0-RTT packets in anticipation of late delivery InitialPacket.
// Maximum buffer size should be set in QuicSettings.
ip.AttachFrame(new ConnectionCloseFrame(ErrorCode.SERVER_BUSY, "The server is too busy to process your request."));
}
data = ip.Encode();
int dataSent = _client.Send(data, data.Length, endPoint);
if (dataSent > 0)
{
return(result);
}
return(null);
}
public void Read_Protected_ResultsAreExpected()
{
//Arrange
var messageBytes = Utils.ParseHexString(GetProtectedMessageHex());
var version = PacketVersion.CreateByDraft(32);
var connectionIds = GetConnectionIdsHex();
var sourceConnectionId = PacketConnectionId.Parse(Utils.ParseHexString(connectionIds.SourceConnectionIdHex));
var destConnectionId = PacketConnectionId.Parse(Utils.ParseHexString(connectionIds.DestConnectionIdHex));
var packetNumber = PacketNumber.Parse(Utils.ParseHexString(GetPacketNumberHex()));
var token = PacketToken.Empty;
var clientHelloBytes = GetTlsClientHelloHex();
var cryptoFrame = new CryptoFrame();
var paddingFrameCount = 0;
var secrets = GetSecrets();
var aead = Cipher.TLS_AES_128_GCM_SHA256.CreateAead(Utils.ParseHexString(secrets.Iv), Utils.ParseHexString(secrets.Key));
var cipher = Cipher.TLS_AES_128_GCM_SHA256.CreateCipher(Utils.ParseHexString(secrets.Hp));
//Act
var cursor = new MemoryCursor(messageBytes);
var result = InitialPacket.TryParseProtected(aead, cipher, cursor, out var packet);
using (packet.Payload.SetCursor(cursor))
{
result &= CryptoFrame.TryParse(cursor, out cryptoFrame);
paddingFrameCount = PaddingFrame.SkipRange(cursor);
result &= cursor.IsEnd();
}
result &= cursor.IsEnd();
//Assert
Assert.True(result);
Assert.Equal(917, paddingFrameCount);
Assert.Equal(version, packet.Version);
Assert.Equal(sourceConnectionId, packet.SourceConnectionId);
Assert.Equal(destConnectionId, packet.DestinationConnectionId);
Assert.Equal(packetNumber, packet.Number);
Assert.Equal(token, packet.Token);
Assert.Equal(0, cryptoFrame.Offset);
Assert.Equal(clientHelloBytes, Utils.ToHexString(cryptoFrame.Data.Read(cursor).ToArray()), true);
}
public InitialPacket CreateInitialPacket(GranularInteger sourceConnectionId, GranularInteger destinationConnectionId)
{
InitialPacket packet = new InitialPacket(destinationConnectionId, sourceConnectionId);
packet.PacketNumber = 0;
packet.SourceConnectionId = sourceConnectionId;
packet.DestinationConnectionId = destinationConnectionId;
packet.Version = QuicVersion.CurrentVersion;
int length = packet.Encode().Length;
int padding = QuicSettings.PMTU - length;
for (int i = 0; i < padding; i++)
{
packet.AttachFrame(new PaddingFrame());
}
return(packet);
}
public InitialPacket CreateInitialPacket(byte sourceConnectionId, byte destinationConnectionId)
{
var packet = new InitialPacket
{
PacketNumber = 0,
SourceConnectionId = sourceConnectionId,
DestinationConnectionId = destinationConnectionId,
Version = QuicVersion.CurrentVersion
};
var length = packet.Encode().Length;
var padding = QuicSettings.PMTU - length;
for (var i = 0; i < padding; i++)
{
packet.AttachFrame(new PaddingFrame());
}
return(packet);
}
public QuicContext Connect(string ip, int port)
{
// Establish socket connection
_peerIp = new IPEndPoint(IPAddress.Parse(ip), port);
// Start initial protocol process
InitialPacket connectionPacket = _packetCreator.CreateInitialPacket(0, 0);
byte[] data = connectionPacket.Encode();
// Send the initial packet
_client.Send(data, data.Length, _peerIp);
// Await response for sucessfull connection creation by the server
byte[] peerData = _client.Receive(ref _peerIp);
if (peerData == null)
{
throw new QuicConnectivityException("Server did not respond properly.");
}
Packet packet = _unpacker.Unpack(peerData);
if ((packet is InitialPacket) == false)
{
throw new QuicConnectivityException("Server did not respond properly.");
}
InitialPacket ini = (InitialPacket)packet;
HandleInitialFrames(packet);
EstablishConnection(ini.SourceConnectionId, ini.SourceConnectionId);
// Create the QuicContext
QuicContext context = new QuicContext(_client, _peerIp);
// Cross reference with Connection
_connection.AttachContext(context);
return(context);
}
public Packet Unpack(byte[] data)
{
Packet result = null;
var type = GetPacketType(data);
switch (type)
{
case QuicPacketType.Initial: result = new InitialPacket(); break;
case QuicPacketType.ShortHeader: result = new ShortHeaderPacket(); break;
}
if (result == null)
{
return(null);
}
result.Decode(data);
return(result);
}
public static void Handle(byte[] packet)
{
PacketReader pr = new PacketReader(packet);
Header header = (Header)pr.ReadUInt16();
Debug.Log(DateTime.Now + " | Received packet: " + header);
switch (header)
{
case Header.Init:
{
InitialPacket pc = new InitialPacket(pr);
}
break;
case Header.Login:
{
LoginAuthorizationPacket pc = new LoginAuthorizationPacket(pr);
}
break;
}
}
/// <summary>
/// Connect to a remote server.
/// </summary>
/// <param name="ip">Ip Address</param>
/// <param name="port">Port</param>
/// <returns></returns>
public QuicConnection Connect(string ip, int port)
{
// Establish socket connection
_peerIp = new IPEndPoint(IPAddress.Parse(ip), port);
// Initialize packet reader
_pwt = new PacketWireTransfer(_client, _peerIp);
// Start initial protocol process
InitialPacket connectionPacket = _packetCreator.CreateInitialPacket(0, 0);
// Send the initial packet
_pwt.SendPacket(connectionPacket);
// Await response for sucessfull connection creation by the server
InitialPacket packet = (InitialPacket)_pwt.ReadPacket();
HandleInitialFrames(packet);
EstablishConnection(packet.SourceConnectionId, packet.SourceConnectionId);
return(_connection);
}
//[Fact]
public void Test1()
{
var buff = new byte[PacketBuffer.MaxPacketSize];
var pBuff = Utils.ParseHexString("060040f1010000ed0303ebf8fa56f12939b9584a3896472ec40bb863cfd3e86804fe3a47f06a2b69484c00000413011302010000c000000010000e00000b6578616d706c652e636f6dff01000100000a00080006001d0017001800100007000504616c706e000500050100000000003300260024001d00209370b2c9caa47fbabaf4559fedba753de171fa71f50f1ce15d43e994ec74d748002b0003020304000d0010000e0403050306030203080408050806002d00020101001c00024001ffa500320408ffffffffffffffff05048000ffff07048000ffff0801100104800075300901100f088394c8f03e51570806048000ffff");
var hBuff = Utils.ParseHexString("c3ff000020088394c8f03e5157080000449e00000002");
Array.Resize(ref pBuff, 1162);
Array.Copy(hBuff, buff, hBuff.Length);
Array.Copy(pBuff, 0, buff, hBuff.Length, pBuff.Length);
Array.Resize(ref buff, hBuff.Length + pBuff.Length);
var encryptedBuff = new byte[PacketBuffer.MaxPacketSize];
var aead = Cipher.TLS_AES_128_GCM_SHA256.CreateAead(Utils.ParseHexString("6b26114b9cba2b63a9e8dd4f"), Utils.ParseHexString("175257a31eb09dea9366d8bb79ad80ba"));
//var token = aead.StartEncryption(pBuff, encryptedBuff);
//token.UseSequenceNumber(2);
//token.UseAssociatedData(hBuff);
//aead.Finish(token);
//var encryptedHex = Utils.ToHexString(token.Result.ToArray());
var c = new MemoryCursor(buff);
var res1 = InitialPacket.TryParse(c, out var p);
using (p.Payload.SetCursor(c))
{
var res2 = CryptoFrame.TryParse(c, out var f);
}
var res3 = c.IsEnd();
var buffer = new byte[PacketBuffer.MaxPacketSize];
var cursor = new MemoryCursor(buffer);
using (InitialPacket.StartWriting(
cursor,
PacketVersion.CreateByDraft(29),
PacketConnectionId.Generate(),
PacketConnectionId.Generate(),
PacketNumber.Initial,
PacketToken.Empty))
{
using (CryptoFrame.StartWriting(cursor, 0))
{
using (ClientHello.StartWriting(cursor, HandshakeRandom.Generate(), Cipher.Supported, SessionId.Generate()))
{
using (cursor.StartSupportedGroupsWriting())
{
foreach (var group in NamedGroup.Supported.Span)
{
group.WriteBytes(cursor);
}
}
using (cursor.StartSignatureAlgorithmsWriting())
{
foreach (var scheme in SignatureScheme.Supported.Span)
{
scheme.WriteBytes(cursor);
}
}
using (cursor.StartKeySharesWriting())
{
using (KeyShareEntry.StartWriting(cursor, NamedGroup.X25519))
{
Utils.ParseHexString("358072d6365880d1aeea329adf9121383851ed21a28e3b75e965d0d2cd166254").CopyTo(cursor);
}
}
using (cursor.StartPskKeyExchangeModesWriting())
{
PskKeyExchangeMode.PskDheKe.WriteBytes(cursor);
}
using (cursor.StartSupportedVersionsWriting())
{
ProtocolVersion.Tls13.WriteBytes(cursor);
}
cursor.StartTransportParametersWriting().Dispose();
}
for (int i = 0; i < 1000; i++)
{
PaddingFrame.WriteBytes(cursor);
}
}
}
var t = Utils.ParseHexString("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");
var client = new UdpClient(0);
var endPoint = new IPEndPoint(IPAddress.Parse("52.55.120.73"), 443);
client.Send(t, t.Length, endPoint);
IPEndPoint ep = null;
var response = client.Receive(ref ep);
var h1 = Utils.ToHexString(response);
cursor = new MemoryCursor(response);
var result = InitialPacket.TryParse(cursor, out var packet);
using (packet.Payload.SetCursor(cursor))
{
var h2 = Utils.ToHexString(cursor.PeekEnd().ToArray());
CryptoFrame.TryParse(cursor, out var cryptoFrame);
using (cryptoFrame.Data.SetCursor(cursor))
{
ServerHello.TryParse(cursor, out var sh);
}
}
Assert.True(true);
//var snBuff = new byte[100];
//var snIter = snBuff.AsSpan();
//ServerNameExtension.WriteHostName(ref snIter, "example.ulfheim.net");
//var snResult = Parse(snBuff.AsSpan().Slice(0, snBuff.Length - snIter.Length).ToArray());
//var keyShareBuff = new byte[1000];
//var keyShareSpan = keyShareBuff.AsSpan();
//var privateKey = Parse("202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f");
//var publicKey = NamedGroup.X25519.GeneratePublicKey(privateKey);
//KeyShareExtension.WriteClientEntry(ref keyShareSpan, NamedGroup.X25519, publicKey);
//var keyShareData = Parse(keyShareBuff.AsSpan().Slice(0, keyShareBuff.Length - keyShareSpan.Length).ToArray());
//var secret = Parse("ff0e5b965291c608c1e8cd267eefc0afcc5e98a2786373f0db47b04786d72aea");
//var hash = Parse("22844b930e5e0a59a09d5ac35fc032fc91163b193874a265236e568077378d8b");
//var expected = Parse("976017a77ae47f1658e28f7085fe37d149d1e9c91f56e1aebbe0c6bb054bd92b");
//var verifyData = Hash.Sha256.CreateVerifyData(secret, hash);
//var result = verifyData.Span.SequenceEqual(expected);
//var bytes = GetData();
//InitialPacket.TryParse(bytes, out var initial, out var remainings);
//CryptoFrame.TryParse(initial.Payload, out var crypto, out var afterCrypto);
//ClientHello.TryParse(crypto.Data, out var hello, out var afterHello);
//KeyShareExtension.TryParse(hello.Payload, out var keyShare, out var afterKeyShare);
//var unknownBytes = UnknownExtension.SliceBytes(afterKeyShare, out var afterUnknown);
//AlpnExtension.TryParse(afterUnknown, out var alpn, out var afterAlpn);
//SupportedVersionExtension.TryParse(afterAlpn, out var supportedVersion, out var afterSupportedVersion);
//SignatureAlgorithmsExtension.TryParse(afterSupportedVersion, out var signatureAlgorithms, out var afterSignatureAlgorithms);
//SupportedGroupsExtension.TryParse(afterSignatureAlgorithms, out var supportedGroups, out var afterSupportedGroups);
//TransportParametersExtension.TryParse(afterSupportedGroups, out var transportParametersExtension, out var afterTransportParametersExtension);
//PskKeyExchangeModesExtension.TryParse(afterTransportParametersExtension, out var pskKeyExchangeModes, out var afterPsk);
////----------------------------------------------------------------
//var buffer = new byte[65000];
//var destination = buffer.AsSpan();
//var initialContext = InitialPacket.StartWriting(ref destination, initial.Version, initial.DestinationConnectionId, initial.SourceConnectionId, initial.Number, initial.Token);
//var cryptoContext = CryptoFrame.StartWriting(ref destination, 0);
//var clientHelloContext = ClientHello.StartWriting(ref destination, hello.Random, hello.CipherSuite, hello.SessionId);
//keyShare.WriteBytes(ref destination);
//unknownBytes.Span.CopyTo(destination);
//destination = destination.Slice(unknownBytes.Length);
//alpn.WriteBytes(ref destination);
//supportedVersion.WriteBytes(ref destination);
//signatureAlgorithms.WriteBytes(ref destination);
//supportedGroups.WriteBytes(ref destination);
//var transportParametersContext = TransportParametersExtension.StartWriting(ref destination);
//transportParametersExtension.Data.Span.CopyTo(destination);
//destination = destination.Slice(transportParametersExtension.Data.Length);
//transportParametersContext.Complete(ref destination);
//pskKeyExchangeModes.WriteBytes(ref destination);
//clientHelloContext.Complete(ref destination);
//cryptoContext.Complete(ref destination);
//for (int i = 0; i < 1000; i++)
//{
// PaddingFrame.WriteBytes(ref destination);
//}
//initialContext.Complete(ref destination);
////----------------------------------------------------------------
//InitialPacket.TryParse(buffer.ToArray(), out var initial1, out var remainings1);
//CryptoFrame.TryParse(initial1.Payload, out var crypto1, out var afterCrypto1);
//ClientHello.TryParse(crypto1.Data, out var hello1, out var afterHello1);
//KeyShareExtension.TryParse(hello1.Payload, out var keyShare1, out var afterKeyShare1);
//var unknownBytes1 = UnknownExtension.SliceBytes(afterKeyShare1, out var afterUnknown1);
//AlpnExtension.TryParse(afterUnknown1, out var alpn1, out var afterAlpn1);
//SupportedVersionExtension.TryParse(afterAlpn1, out var supportedVersion1, out var afterSupportedVersion1);
//SignatureAlgorithmsExtension.TryParse(afterSupportedVersion1, out var signatureAlgorithms1, out var afterSignatureAlgorithms1);
//SupportedGroupsExtension.TryParse(afterSignatureAlgorithms1, out var supportedGroups1, out var afterSupportedGroups1);
//TransportParametersExtension.TryParse(afterSupportedGroups1, out var transportParametersExtension1, out var afterTransportParametersExtension1);
//PskKeyExchangeModesExtension.TryParse(afterTransportParametersExtension1, out var pskKeyExchangeModes1, out var afterPsk1);
//var client = DatagramChannel.Start(opt =>
//{
// opt.ListeningPoint = new IPEndPoint(IPAddress.Any, 50000);
//});
//var addr = Dns.GetHostAddresses("litespeedtech.com"); //443
////var addr = Dns.GetHostAddresses("test.privateoctopus.com"); //4433
////var addr = Dns.GetHostAddresses("quant.eggert.org"); //4433
////var addr = Dns.GetHostAddresses("f5quic.com"); //4433
//var dgram = new Datagram().WithAddress(addr[0]).WithPort(443).WithBuffer(buffer.ToArray());
//client.Writer.TryWrite(dgram);
//var response = client.Reader.ReadAsync().AsTask().Result;
}
