From d1ce79dfaebff13287c9156f3132a4a6f5752dba Mon Sep 17 00:00:00 2001 From: EonaCat Date: Fri, 21 Nov 2025 21:04:44 +0100 Subject: [PATCH] Initial version --- .gitignore | 93 +-- .../EonaCat.Transfer.Example.csproj | 14 + EonaCat.Transfer.Example/Program.cs | 81 +++ EonaCat.Transfer.slnx | 7 + EonaCat.Transfer/AesKeySize.cs | 9 + EonaCat.Transfer/CompressionType.cs | 9 + EonaCat.Transfer/EonaCat.Transfer.csproj | 49 ++ EonaCat.Transfer/FramingMode.cs | 10 + EonaCat.Transfer/Helpers/AesHelper.cs | 230 +++++++ EonaCat.Transfer/Helpers/CompressionHelper.cs | 60 ++ EonaCat.Transfer/Helpers/NetworkHelper.cs | 112 ++++ EonaCat.Transfer/MessageType.cs | 17 + EonaCat.Transfer/Models/AesConfig.cs | 15 + .../Models/AesEncryptionProvider.cs | 147 +++++ EonaCat.Transfer/Models/ClientConnection.cs | 44 ++ EonaCat.Transfer/Models/MessageBuilder.cs | 52 ++ EonaCat.Transfer/Models/NetworkConfig.cs | 38 ++ EonaCat.Transfer/Models/NetworkMessage.cs | 46 ++ EonaCat.Transfer/Models/NetworkStatistics.cs | 67 ++ EonaCat.Transfer/ProtocolType.cs | 9 + EonaCat.Transfer/RestClient.cs | 145 +++++ EonaCat.Transfer/SslHelper.cs | 153 +++++ EonaCat.Transfer/TcpClient.cs | 575 ++++++++++++++++++ EonaCat.Transfer/TcpConnectionPool.cs | 90 +++ EonaCat.Transfer/TcpServer.cs | 546 +++++++++++++++++ EonaCat.Transfer/UdpClientConnection.cs | 100 +++ EonaCat.Transfer/UdpServer.cs | 167 +++++ LICENSE | 213 +++++-- README.md | 237 +++++++- icon.png | Bin 0 -> 89562 bytes 30 files changed, 3209 insertions(+), 126 deletions(-) create mode 100644 EonaCat.Transfer.Example/EonaCat.Transfer.Example.csproj create mode 100644 EonaCat.Transfer.Example/Program.cs create mode 100644 EonaCat.Transfer.slnx create mode 100644 EonaCat.Transfer/AesKeySize.cs create mode 100644 EonaCat.Transfer/CompressionType.cs create mode 100644 EonaCat.Transfer/EonaCat.Transfer.csproj create mode 100644 EonaCat.Transfer/FramingMode.cs create mode 100644 EonaCat.Transfer/Helpers/AesHelper.cs create mode 100644 EonaCat.Transfer/Helpers/CompressionHelper.cs create mode 100644 EonaCat.Transfer/Helpers/NetworkHelper.cs create mode 100644 EonaCat.Transfer/MessageType.cs create mode 100644 EonaCat.Transfer/Models/AesConfig.cs create mode 100644 EonaCat.Transfer/Models/AesEncryptionProvider.cs create mode 100644 EonaCat.Transfer/Models/ClientConnection.cs create mode 100644 EonaCat.Transfer/Models/MessageBuilder.cs create mode 100644 EonaCat.Transfer/Models/NetworkConfig.cs create mode 100644 EonaCat.Transfer/Models/NetworkMessage.cs create mode 100644 EonaCat.Transfer/Models/NetworkStatistics.cs create mode 100644 EonaCat.Transfer/ProtocolType.cs create mode 100644 EonaCat.Transfer/RestClient.cs create mode 100644 EonaCat.Transfer/SslHelper.cs create mode 100644 EonaCat.Transfer/TcpClient.cs create mode 100644 EonaCat.Transfer/TcpConnectionPool.cs create mode 100644 EonaCat.Transfer/TcpServer.cs create mode 100644 EonaCat.Transfer/UdpClientConnection.cs create mode 100644 EonaCat.Transfer/UdpServer.cs create mode 100644 icon.png diff --git a/.gitignore b/.gitignore index 7e2e97c..e3ba347 100644 --- a/.gitignore +++ b/.gitignore @@ -2,7 +2,7 @@ ## Ignore Visual Studio temporary files, build results, and ## files generated by popular Visual Studio add-ons. ## -## Get latest from https://github.com/github/gitignore/blob/main/VisualStudio.gitignore +## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore # User-specific files *.rsuser @@ -14,9 +14,6 @@ # User-specific files (MonoDevelop/Xamarin Studio) *.userprefs -# Mono auto generated files -mono_crash.* - # Build results [Dd]ebug/ [Dd]ebugPublic/ @@ -24,14 +21,10 @@ mono_crash.* [Rr]eleases/ x64/ x86/ -[Ww][Ii][Nn]32/ -[Aa][Rr][Mm]/ -[Aa][Rr][Mm]64/ bld/ [Bb]in/ [Oo]bj/ [Ll]og/ -[Ll]ogs/ # Visual Studio 2015/2017 cache/options directory .vs/ @@ -45,10 +38,9 @@ Generated\ Files/ [Tt]est[Rr]esult*/ [Bb]uild[Ll]og.* -# NUnit +# NUNIT *.VisualState.xml TestResult.xml -nunit-*.xml # Build Results of an ATL Project [Dd]ebugPS/ @@ -63,9 +55,6 @@ project.lock.json project.fragment.lock.json artifacts/ -# ASP.NET Scaffolding -ScaffoldingReadMe.txt - # StyleCop StyleCopReport.xml @@ -83,8 +72,6 @@ StyleCopReport.xml *.pgc *.pgd *.rsp -# but not Directory.Build.rsp, as it configures directory-level build defaults -!Directory.Build.rsp *.sbr *.tlb *.tli @@ -93,7 +80,6 @@ StyleCopReport.xml *.tmp_proj *_wpftmp.csproj *.log -*.tlog *.vspscc *.vssscc .builds @@ -135,6 +121,9 @@ _ReSharper*/ *.[Rr]e[Ss]harper *.DotSettings.user +# JustCode is a .NET coding add-in +.JustCode + # TeamCity is a build add-in _TeamCity* @@ -145,11 +134,6 @@ _TeamCity* .axoCover/* !.axoCover/settings.json -# Coverlet is a free, cross platform Code Coverage Tool -coverage*.json -coverage*.xml -coverage*.info - # Visual Studio code coverage results *.coverage *.coveragexml @@ -197,8 +181,6 @@ PublishScripts/ # NuGet Packages *.nupkg -# NuGet Symbol Packages -*.snupkg # The packages folder can be ignored because of Package Restore **/[Pp]ackages/* # except build/, which is used as an MSBuild target. @@ -223,14 +205,12 @@ BundleArtifacts/ Package.StoreAssociation.xml _pkginfo.txt *.appx -*.appxbundle -*.appxupload # Visual Studio cache files # files ending in .cache can be ignored *.[Cc]ache # but keep track of directories ending in .cache -!?*.[Cc]ache/ +!*.[Cc]ache/ # Others ClientBin/ @@ -274,9 +254,6 @@ ServiceFabricBackup/ *.bim.layout *.bim_*.settings *.rptproj.rsuser -*- [Bb]ackup.rdl -*- [Bb]ackup ([0-9]).rdl -*- [Bb]ackup ([0-9][0-9]).rdl # Microsoft Fakes FakesAssemblies/ @@ -297,17 +274,6 @@ node_modules/ # Visual Studio 6 auto-generated workspace file (contains which files were open etc.) *.vbw -# Visual Studio 6 auto-generated project file (contains which files were open etc.) -*.vbp - -# Visual Studio 6 workspace and project file (working project files containing files to include in project) -*.dsw -*.dsp - -# Visual Studio 6 technical files -*.ncb -*.aps - # Visual Studio LightSwitch build output **/*.HTMLClient/GeneratedArtifacts **/*.DesktopClient/GeneratedArtifacts @@ -323,6 +289,10 @@ paket-files/ # FAKE - F# Make .fake/ +# JetBrains Rider +.idea/ +*.sln.iml + # CodeRush personal settings .cr/personal @@ -364,53 +334,10 @@ ASALocalRun/ # Local History for Visual Studio .localhistory/ -# Visual Studio History (VSHistory) files -.vshistory/ - -# BeatPulse healthcheck temp database -healthchecksdb - -# Backup folder for Package Reference Convert tool in Visual Studio 2017 -MigrationBackup/ - -# Ionide (cross platform F# VS Code tools) working folder -.ionide/ - -# Fody - auto-generated XML schema -FodyWeavers.xsd - -# VS Code files for those working on multiple tools -.vscode/* -!.vscode/settings.json -!.vscode/tasks.json -!.vscode/launch.json -!.vscode/extensions.json -*.code-workspace - -# Local History for Visual Studio Code -.history/ - -# Windows Installer files from build outputs -*.cab -*.msi -*.msix -*.msm -*.msp - -# JetBrains Rider -*.sln.iml - # ---> VisualStudioCode .vscode/* !.vscode/settings.json !.vscode/tasks.json !.vscode/launch.json !.vscode/extensions.json -!.vscode/*.code-snippets - -# Local History for Visual Studio Code -.history/ - -# Built Visual Studio Code Extensions -*.vsix diff --git a/EonaCat.Transfer.Example/EonaCat.Transfer.Example.csproj b/EonaCat.Transfer.Example/EonaCat.Transfer.Example.csproj new file mode 100644 index 0000000..195fa76 --- /dev/null +++ b/EonaCat.Transfer.Example/EonaCat.Transfer.Example.csproj @@ -0,0 +1,14 @@ + + + + Exe + net8.0 + enable + enable + + + + + + + diff --git a/EonaCat.Transfer.Example/Program.cs b/EonaCat.Transfer.Example/Program.cs new file mode 100644 index 0000000..cf5fa46 --- /dev/null +++ b/EonaCat.Transfer.Example/Program.cs @@ -0,0 +1,81 @@ +using EonaCat.Transfer; +using EonaCat.Transfer.Models; + +NetworkConfig networkConfig = new NetworkConfig() +{ + Protocol = ProtocolType.TCP, + Framing = FramingMode.Delimiter, + Delimiter = new byte[] { 0x0A }, // LF + EnableKeepAlive = true, + KeepAliveIntervalMs = 15000, + KeepAliveTimeoutMs = 5000, + AutoReconnect = true, + ReconnectDelayMs = 3000, +}; + +var server = new TcpServer(networkConfig); +server.ClientConnected += Server_ClientConnected; +server.ClientDisconnected += Server_ClientDisconnected; +server.MessageReceived += Server_MessageReceived; + +void Server_MessageReceived(object? sender, (ClientConnection Client, NetworkMessage Message) e) +{ + string message = System.Text.Encoding.UTF8.GetString(e.Message.Payload); + Console.WriteLine($"Received from {e.Client.Id}: {message}"); + // Echo the message back to the client + var responseMessage = new NetworkMessage(); + responseMessage.Payload = System.Text.Encoding.UTF8.GetBytes($"Echo: {message}"); + server.SendMessageAsync(e.Client, responseMessage); +} + +void Server_ClientDisconnected(object? sender, ClientConnection e) +{ + Console.WriteLine($"{e.Id} disconnected {e.RemoteEndPoint.ToString()}"); +} + +void Server_ClientConnected(object? sender, ClientConnection e) +{ + Console.WriteLine($"{e.Id} connected {e.RemoteEndPoint.ToString()}"); +} + +var client = new TcpClient(networkConfig); +client.Connected += Client_Connected; +client.MessageReceived += Client_MessageReceived; +client.Disconnected += Client_Disconnected; + +void Client_Disconnected(object? sender, EventArgs e) +{ + Console.WriteLine("Client disconnected from server"); +} + +void Client_MessageReceived(object? sender, NetworkMessage e) +{ + string message = System.Text.Encoding.UTF8.GetString(e.Payload); + Console.WriteLine($"Received from server: {message}"); +} + +void Client_Connected(object? sender, EventArgs e) +{ + Console.WriteLine("Client connected to server"); + // Send a test message to the server + var message = new NetworkMessage(); + message.Payload = System.Text.Encoding.UTF8.GetBytes("Hello, Server!"); + client.SendMessageAsync(message); +} + +await server.StartAsync(9000); +await client.ConnectAsync("127.0.0.1", 9000); + +// Generate traffic +for (int i = 0; i < 10000; i++) +{ + var message = new NetworkMessage(); + message.Payload = System.Text.Encoding.UTF8.GetBytes($"Message {i + 1} from client"); + await client.SendMessageAsync(message); + await Task.Delay(100); +} + + + +Console.WriteLine("Press ENTER to exit..."); +Console.ReadLine(); \ No newline at end of file diff --git a/EonaCat.Transfer.slnx b/EonaCat.Transfer.slnx new file mode 100644 index 0000000..24b6b6d --- /dev/null +++ b/EonaCat.Transfer.slnx @@ -0,0 +1,7 @@ + + + + + + + diff --git a/EonaCat.Transfer/AesKeySize.cs b/EonaCat.Transfer/AesKeySize.cs new file mode 100644 index 0000000..01d6adb --- /dev/null +++ b/EonaCat.Transfer/AesKeySize.cs @@ -0,0 +1,9 @@ +namespace EonaCat.Transfer +{ + public enum AesKeySize + { + Aes128 = 128, + Aes192 = 192, + Aes256 = 256 + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/CompressionType.cs b/EonaCat.Transfer/CompressionType.cs new file mode 100644 index 0000000..4ae0115 --- /dev/null +++ b/EonaCat.Transfer/CompressionType.cs @@ -0,0 +1,9 @@ +namespace EonaCat.Transfer +{ + public enum CompressionType + { + None, + GZip, + Deflate + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/EonaCat.Transfer.csproj b/EonaCat.Transfer/EonaCat.Transfer.csproj new file mode 100644 index 0000000..ed823ef --- /dev/null +++ b/EonaCat.Transfer/EonaCat.Transfer.csproj @@ -0,0 +1,49 @@ + + + + net48;net6.0 + enable + enable + latest + EonaCat.Transfer + True + EonaCat.Transfer + EonaCat.Transfer + 1.0.0 + EonaCat (Jeroen Saey) + EonaCat (Jeroen Saey) + EonaCat.Transfer + Yet another .NET networking library. + EonaCat (Jeroen Saey) + https://git.saey.me/EonaCat/EonaCat.Transfer + icon.png + Readme.md + https://git.saey.me/EonaCat/EonaCat.Transfer + git + Socket, TCP, UDP, REST, AES, Compression + Yet another .NET networking library. + LICENSE + + + + + True + \ + + + True + \ + + + True + \ + + + + + + + + + + diff --git a/EonaCat.Transfer/FramingMode.cs b/EonaCat.Transfer/FramingMode.cs new file mode 100644 index 0000000..058c17a --- /dev/null +++ b/EonaCat.Transfer/FramingMode.cs @@ -0,0 +1,10 @@ +namespace EonaCat.Transfer +{ + public enum FramingMode + { + None, + LengthPrefix, + Delimiter, + FixedLength + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/Helpers/AesHelper.cs b/EonaCat.Transfer/Helpers/AesHelper.cs new file mode 100644 index 0000000..3c5f12d --- /dev/null +++ b/EonaCat.Transfer/Helpers/AesHelper.cs @@ -0,0 +1,230 @@ +using EonaCat.Transfer.Models; +using System; +using System.Buffers; +using System.Collections.Concurrent; +using System.IO; +using System.Linq; +using System.Net; +using System.Net.Http; +using System.Net.Mail; +using System.Net.Security; +using System.Net.Sockets; +using System.Security.Authentication; +using System.Security.Cryptography; +using System.Security.Cryptography.X509Certificates; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace EonaCat.Transfer.Helpers +{ + public static class AesHelper + { + /// + /// Generates a cryptographically secure random AES configuration + /// + public static AesConfig GenerateSecureConfig(AesKeySize keySize = AesKeySize.Aes256) + { + return AesEncryptionProvider.GenerateConfig(keySize); + } + + /// + /// Creates AES configuration from a shared secret using PBKDF2 + /// + public static AesConfig CreateFromSharedSecret(string secret, AesKeySize keySize = AesKeySize.Aes256) + { + return AesEncryptionProvider.FromSharedSecret(secret, keySize); + } + + /// + /// Exports AES configuration to base64 strings for easy sharing/storage + /// + public static (string Key, string IV) ExportConfig(AesConfig config) + { + if (config.Key == null || config.IV == null) + { + throw new InvalidOperationException("AES config must have Key and IV to export"); + } + + return (Convert.ToBase64String(config.Key), Convert.ToBase64String(config.IV)); + } + + /// + /// Imports AES configuration from base64 strings + /// + public static AesConfig ImportConfig(string keyBase64, string ivBase64, AesKeySize keySize = AesKeySize.Aes256) + { + return new AesConfig + { + IsAesEnabled = true, + Key = Convert.FromBase64String(keyBase64), + IV = Convert.FromBase64String(ivBase64), + KeySize = keySize + }; + } + + /// + /// Saves AES configuration to a file (encrypted with password) + /// + public static void SaveConfigToFile(AesConfig config, string filePath, string password) + { + var keyIv = $"{Convert.ToBase64String(config.Key)}|{Convert.ToBase64String(config.IV)}"; + var keyIvBytes = Encoding.UTF8.GetBytes(keyIv); + + // Encrypt with password + using (var aes = Aes.Create()) + { + var salt = new byte[16]; + using (var rng = RandomNumberGenerator.Create()) + { + rng.GetBytes(salt); + } + +#if NET6_0_OR_GREATER + using (var deriveBytes = new Rfc2898DeriveBytes(password, salt, 100000, HashAlgorithmName.SHA256)) +#else + using (var deriveBytes = new Rfc2898DeriveBytes(password, salt, 100000)) +#endif + { + aes.Key = deriveBytes.GetBytes(32); + aes.IV = deriveBytes.GetBytes(16); + } + + using (var encryptor = aes.CreateEncryptor()) + using (var ms = new MemoryStream()) + { + ms.Write(salt, 0, salt.Length); + using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write)) + { + cs.Write(keyIvBytes, 0, keyIvBytes.Length); + } + File.WriteAllBytes(filePath, ms.ToArray()); + } + } + } + + /// + /// Loads AES configuration from a file (decrypted with password) + /// + public static AesConfig LoadConfigFromFile(string filePath, string password, AesKeySize keySize = AesKeySize.Aes256) + { + var fileBytes = File.ReadAllBytes(filePath); + var salt = new byte[16]; + Array.Copy(fileBytes, salt, 16); + + using (var aes = Aes.Create()) + { +#if NET6_0_OR_GREATER + using (var deriveBytes = new Rfc2898DeriveBytes(password, salt, 100000, HashAlgorithmName.SHA256)) +#else + using (var deriveBytes = new Rfc2898DeriveBytes(password, salt, 100000)) +#endif + { + aes.Key = deriveBytes.GetBytes(32); + aes.IV = deriveBytes.GetBytes(16); + } + + using (var decryptor = aes.CreateDecryptor()) + using (var ms = new MemoryStream()) + { + using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Write)) + { + cs.Write(fileBytes, 16, fileBytes.Length - 16); + } + + var keyIv = Encoding.UTF8.GetString(ms.ToArray()).Split('|'); + return ImportConfig(keyIv[0], keyIv[1], keySize); + } + } + } + + /// + /// Performs a secure key exchange simulation (for demonstration - use real key exchange in production) + /// + public static (AesConfig ServerConfig, AesConfig ClientConfig) SimulateKeyExchange(string sharedSecret) + { + var config = CreateFromSharedSecret(sharedSecret); + + return ( + new AesConfig + { + IsAesEnabled = true, + Key = config.Key, + IV = config.IV, + KeySize = config.KeySize + }, + new AesConfig + { + IsAesEnabled = true, + Key = config.Key, + IV = config.IV, + KeySize = config.KeySize + } + ); + } + + /// + /// Encrypts a single byte array (standalone utility) + /// + public static byte[] EncryptBytes(byte[] data, AesConfig config) + { + using (var provider = new AesEncryptionProvider(config)) + { + return provider.Encrypt(data); + } + } + + /// + /// Decrypts a single byte array (standalone utility) + /// + public static byte[] DecryptBytes(byte[] encryptedData, AesConfig config) + { + using (var provider = new AesEncryptionProvider(config)) + { + return provider.Decrypt(encryptedData); + } + } + + /// + /// Encrypts a string + /// + public static string EncryptString(string plainText, AesConfig config) + { + var plainBytes = Encoding.UTF8.GetBytes(plainText); + var encryptedBytes = EncryptBytes(plainBytes, config); + return Convert.ToBase64String(encryptedBytes); + } + + /// + /// Decrypts a string + /// + public static string DecryptString(string encryptedText, AesConfig config) + { + var encryptedBytes = Convert.FromBase64String(encryptedText); + var plainBytes = DecryptBytes(encryptedBytes, config); + return Encoding.UTF8.GetString(plainBytes); + } + + /// + /// Generates a cryptographically secure random password + /// + public static string GenerateSecurePassword(int length = 32) + { + const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*"; + var result = new char[length]; + var randomBytes = new byte[length]; + + using (var randomGenerator = RandomNumberGenerator.Create()) + { + randomGenerator.GetBytes(randomBytes); + } + + for (int i = 0; i < length; i++) + { + result[i] = chars[randomBytes[i] % chars.Length]; + } + + return new string(result); + } + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/Helpers/CompressionHelper.cs b/EonaCat.Transfer/Helpers/CompressionHelper.cs new file mode 100644 index 0000000..fdd9564 --- /dev/null +++ b/EonaCat.Transfer/Helpers/CompressionHelper.cs @@ -0,0 +1,60 @@ +namespace EonaCat.Transfer.Helpers +{ + public static class CompressionHelper + { + public static byte[] Compress(byte[] data, CompressionType type) + { + if (type == CompressionType.None || data == null || data.Length == 0) + { + return data; + } + + using (var output = new MemoryStream()) + { + Stream compressionStream = type == CompressionType.GZip + ? (Stream)new System.IO.Compression.GZipStream(output, System.IO.Compression.CompressionMode.Compress) + : new System.IO.Compression.DeflateStream(output, System.IO.Compression.CompressionMode.Compress); + + using (compressionStream) + { + compressionStream.Write(data, 0, data.Length); + } + + return output.ToArray(); + } + } + + public static byte[] Decompress(byte[] data, CompressionType type) + { + if (type == CompressionType.None || data == null || data.Length == 0) + { + return data; + } + + using (var input = new MemoryStream(data)) + using (var output = new MemoryStream()) + { + Stream decompressionStream = type == CompressionType.GZip + ? (Stream)new System.IO.Compression.GZipStream(input, System.IO.Compression.CompressionMode.Decompress) + : new System.IO.Compression.DeflateStream(input, System.IO.Compression.CompressionMode.Decompress); + + using (decompressionStream) + { + decompressionStream.CopyTo(output); + } + + return output.ToArray(); + } + } + + public static async Task CompressAsync(byte[] data, CompressionType type) + { + return await Task.Run(() => Compress(data, type)); + } + + public static async Task DecompressAsync(byte[] data, CompressionType type) + { + return await Task.Run(() => Decompress(data, type)); + } + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/Helpers/NetworkHelper.cs b/EonaCat.Transfer/Helpers/NetworkHelper.cs new file mode 100644 index 0000000..469aa47 --- /dev/null +++ b/EonaCat.Transfer/Helpers/NetworkHelper.cs @@ -0,0 +1,112 @@ +using System.Net; +using System.Net.Sockets; + +namespace EonaCat.Transfer.Helpers +{ + public static class NetworkHelper + { + /// + /// Gets the local IP address + /// + public static string GetLocalIPAddress() + { + var host = Dns.GetHostEntry(Dns.GetHostName()); + foreach (var ip in host.AddressList) + { + if (ip.AddressFamily == AddressFamily.InterNetwork) + { + return ip.ToString(); + } + } + return "127.0.0.1"; + } + + /// + /// Checks if a port is available + /// + public static bool IsPortAvailable(int port) + { + try + { + using (var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp)) + { + socket.Bind(new IPEndPoint(IPAddress.Any, port)); + return true; + } + } + catch + { + return false; + } + } + + /// + /// Finds an available port in the specified range + /// + public static int FindAvailablePort(int startPort = 5000, int endPort = 65535) + { + for (int port = startPort; port <= endPort; port++) + { + if (IsPortAvailable(port)) + { + return port; + } + } + throw new InvalidOperationException("No available ports found in the specified range"); + } + + /// + /// Validates an IP address + /// + public static bool IsValidIPAddress(string ipAddress) + { + return IPAddress.TryParse(ipAddress, out _); + } + + /// + /// Performs a TCP ping (connection test) + /// + public static async Task TcpPingAsync(string host, int port, int timeoutMs = 5000) + { + try + { + using (var client = new System.Net.Sockets.TcpClient()) + { + var connectTask = client.ConnectAsync(host, port); + var timeoutTask = Task.Delay(timeoutMs); + + var completedTask = await Task.WhenAny(connectTask, timeoutTask); + return completedTask == connectTask && client.Connected; + } + } + catch + { + return false; + } + } + + /// + /// Gets network latency to a host + /// + public static async Task GetLatencyAsync(string host, int port, int attempts = 3) + { + var latencies = new List(); + + for (int i = 0; i < attempts; i++) + { + var sw = System.Diagnostics.Stopwatch.StartNew(); + var success = await TcpPingAsync(host, port); + sw.Stop(); + + if (success) + { + latencies.Add(sw.ElapsedMilliseconds); + } + + await Task.Delay(100); + } + + return latencies.Any() ? (long)latencies.Average() : -1; + } + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/MessageType.cs b/EonaCat.Transfer/MessageType.cs new file mode 100644 index 0000000..4b454d3 --- /dev/null +++ b/EonaCat.Transfer/MessageType.cs @@ -0,0 +1,17 @@ +namespace EonaCat.Transfer +{ + public enum MessageType : byte + { + Data = 0, + KeepAlive = 1, + KeepAliveResponse = 2, + FileTransferStart = 3, + FileTransferChunk = 4, + FileTransferEnd = 5, + Disconnect = 6, + Acknowledgment = 7, + Error = 8, + Handshake = 9, + HandshakeResponse = 10 + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/Models/AesConfig.cs b/EonaCat.Transfer/Models/AesConfig.cs new file mode 100644 index 0000000..cbc5f57 --- /dev/null +++ b/EonaCat.Transfer/Models/AesConfig.cs @@ -0,0 +1,15 @@ +using System.Security.Cryptography; + +namespace EonaCat.Transfer.Models +{ + public class AesConfig + { + public bool IsAesEnabled { get; set; } = false; + public byte[] Key { get; set; } + public byte[] IV { get; set; } + public AesKeySize KeySize { get; set; } = AesKeySize.Aes256; + public CipherMode Mode { get; set; } = CipherMode.CBC; + public PaddingMode Padding { get; set; } = PaddingMode.PKCS7; + public string SharedSecret { get; set; } // For key derivation + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/Models/AesEncryptionProvider.cs b/EonaCat.Transfer/Models/AesEncryptionProvider.cs new file mode 100644 index 0000000..4abb52c --- /dev/null +++ b/EonaCat.Transfer/Models/AesEncryptionProvider.cs @@ -0,0 +1,147 @@ +using System.Security.Cryptography; +using System.Text; + +namespace EonaCat.Transfer.Models +{ + public class AesEncryptionProvider : IDisposable + { + private readonly string _salt = "EonaCat_Transfer_Salt"; + private readonly Aes _aes; + private readonly ICryptoTransform _encryptor; + private readonly ICryptoTransform _decryptor; + private bool _disposed; + + public byte[] Key => _aes.Key; + public byte[] IV => _aes.IV; + + public AesEncryptionProvider(AesConfig config, string salt = "EonaCat_Transfer_Salt") + { + _salt = salt; + _aes = Aes.Create(); + _aes.KeySize = (int)config.KeySize; + _aes.Mode = config.Mode; + _aes.Padding = config.Padding; + + if (config.Key != null && config.IV != null) + { + _aes.Key = config.Key; + _aes.IV = config.IV; + } + else if (!string.IsNullOrEmpty(config.SharedSecret)) + { + // Derive key from shared secret using PBKDF2 + DeriveKeyFromSecret(config.SharedSecret, config.KeySize); + } + else + { + // Generate random key and IV + _aes.GenerateKey(); + _aes.GenerateIV(); + } + + _encryptor = _aes.CreateEncryptor(); + _decryptor = _aes.CreateDecryptor(); + } + + private void DeriveKeyFromSecret(string secret, AesKeySize keySize) + { + // Use PBKDF2 for key derivation + var salt = Encoding.UTF8.GetBytes(_salt); + +#if NET6_0_OR_GREATER + using (var deriveBytes = new Rfc2898DeriveBytes( + secret, + salt, + 100000, + HashAlgorithmName.SHA256)) +#else + using (var deriveBytes = new Rfc2898DeriveBytes(secret, salt, 100000)) +#endif + { + _aes.Key = deriveBytes.GetBytes((int)keySize / 8); + _aes.IV = deriveBytes.GetBytes(16); // AES block size is always 128 bits (16 bytes) + } + } + + public byte[] Encrypt(byte[] data) + { + if (data == null || data.Length == 0) + { + return data; + } + + using (var ms = new MemoryStream()) + using (var cs = new CryptoStream(ms, _encryptor, CryptoStreamMode.Write)) + { + cs.Write(data, 0, data.Length); + cs.FlushFinalBlock(); + return ms.ToArray(); + } + } + + public byte[] Decrypt(byte[] encryptedData) + { + if (encryptedData == null || encryptedData.Length == 0) + { + return encryptedData; + } + + using (var ms = new MemoryStream()) + using (var cs = new CryptoStream(ms, _decryptor, CryptoStreamMode.Write)) + { + cs.Write(encryptedData, 0, encryptedData.Length); + cs.FlushFinalBlock(); + return ms.ToArray(); + } + } + + public async Task EncryptAsync(byte[] data) + { + return await Task.Run(() => Encrypt(data)); + } + + public async Task DecryptAsync(byte[] encryptedData) + { + return await Task.Run(() => Decrypt(encryptedData)); + } + + public static AesConfig GenerateConfig(AesKeySize keySize = AesKeySize.Aes256) + { + using (var aes = Aes.Create()) + { + aes.KeySize = (int)keySize; + aes.GenerateKey(); + aes.GenerateIV(); + + return new AesConfig + { + IsAesEnabled = true, + KeySize = keySize, + Key = aes.Key, + IV = aes.IV + }; + } + } + + public static AesConfig FromSharedSecret(string secret, AesKeySize keySize = AesKeySize.Aes256) + { + return new AesConfig + { + IsAesEnabled = true, + SharedSecret = secret, + KeySize = keySize + }; + } + + public void Dispose() + { + if (!_disposed) + { + _encryptor?.Dispose(); + _decryptor?.Dispose(); + _aes?.Dispose(); + _disposed = true; + } + } + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/Models/ClientConnection.cs b/EonaCat.Transfer/Models/ClientConnection.cs new file mode 100644 index 0000000..639e7af --- /dev/null +++ b/EonaCat.Transfer/Models/ClientConnection.cs @@ -0,0 +1,44 @@ +using System.Collections.Concurrent; +using System.Net; +using System.Net.Sockets; + +namespace EonaCat.Transfer.Models +{ + public class ClientConnection : IDisposable + { + public string Id { get; } + public EndPoint RemoteEndPoint { get; } + public DateTime ConnectedAt { get; } + public DateTime LastActivity { get; set; } + public long BytesSent { get; set; } + public long BytesReceived { get; set; } + public bool IsConnected { get; set; } + public ConcurrentDictionary Metadata { get; } + + internal Socket Socket { get; set; } + internal Stream Stream { get; set; } + internal CancellationTokenSource CancellationToken { get; set; } + internal ConcurrentDictionary> PendingAcknowledgments { get; } + + public ClientConnection(Socket socket) + { + Id = Guid.NewGuid().ToString(); + Socket = socket; + RemoteEndPoint = socket.RemoteEndPoint; + ConnectedAt = DateTime.UtcNow; + LastActivity = DateTime.UtcNow; + IsConnected = true; + CancellationToken = new CancellationTokenSource(); + Metadata = new ConcurrentDictionary(); + PendingAcknowledgments = new ConcurrentDictionary>(); + } + + public void Dispose() + { + IsConnected = false; + CancellationToken?.Cancel(); + Stream?.Dispose(); + Socket?.Dispose(); + } + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/Models/MessageBuilder.cs b/EonaCat.Transfer/Models/MessageBuilder.cs new file mode 100644 index 0000000..43758aa --- /dev/null +++ b/EonaCat.Transfer/Models/MessageBuilder.cs @@ -0,0 +1,52 @@ +using System.Text; + +namespace EonaCat.Transfer.Models +{ + public class MessageBuilder + { + private readonly NetworkMessage _message; + + public MessageBuilder() + { + _message = new NetworkMessage + { + Timestamp = DateTime.UtcNow + }; + } + + public MessageBuilder WithType(MessageType type) + { + _message.Type = type; + return this; + } + + public MessageBuilder WithPayload(byte[] payload) + { + _message.Payload = payload; + return this; + } + + public MessageBuilder WithPayload(string text) + { + _message.Payload = Encoding.UTF8.GetBytes(text); + return this; + } + + public MessageBuilder WithSessionId(string sessionId) + { + _message.SessionId = sessionId; + return this; + } + + public MessageBuilder WithSequenceNumber(long sequenceNumber) + { + _message.SequenceNumber = sequenceNumber; + return this; + } + + public NetworkMessage Build() + { + return _message; + } + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/Models/NetworkConfig.cs b/EonaCat.Transfer/Models/NetworkConfig.cs new file mode 100644 index 0000000..4823eac --- /dev/null +++ b/EonaCat.Transfer/Models/NetworkConfig.cs @@ -0,0 +1,38 @@ +namespace EonaCat.Transfer.Models +{ + public class NetworkConfig + { + public ProtocolType Protocol { get; set; } = ProtocolType.TCP; + public FramingMode Framing { get; set; } = FramingMode.LengthPrefix; + public byte[] Delimiter { get; set; } = new byte[] { 0x0D, 0x0A }; // CRLF + public int FixedLength { get; set; } = 1024; + public bool AutoReconnect { get; set; } = true; + public int ReconnectDelayMs { get; set; } = 5000; + public int MaxReconnectAttempts { get; set; } = -1; // -1 = infinite + public bool EnableKeepAlive { get; set; } = true; + public int KeepAliveIntervalMs { get; set; } = 30000; + public int KeepAliveTimeoutMs { get; set; } = 10000; + public bool EnableNatPunchthrough { get; set; } = true; + public int BufferSize { get; set; } = 8192; + public int MaxConnections { get; set; } = 1000000; + public CompressionType Compression { get; set; } = CompressionType.None; + public bool EnableSsl { get; set; } = false; + public string SslCertificatePath { get; set; } + public string SslCertificatePassword { get; set; } + public System.Security.Cryptography.X509Certificates.X509Certificate2 SslCertificate { get; set; } + public bool SslValidateServerCertificate { get; set; } = true; + public string SslTargetHost { get; set; } + public System.Security.Authentication.SslProtocols SslProtocols { get; set; } = + System.Security.Authentication.SslProtocols.Tls12 | + System.Security.Authentication.SslProtocols.Tls13; + public AesConfig AesEncryption { get; set; } = new AesConfig(); + public int SendTimeoutMs { get; set; } = 30000; + public int ReceiveTimeoutMs { get; set; } = 30000; + public bool NoDelay { get; set; } = true; // TCP_NODELAY + public int MaxMessageSize { get; set; } = 10 * 1024 * 1024; // 10MB + public int FileTransferChunkSize { get; set; } = 64 * 1024; // 64KB chunks + public string FileTransferDirectory { get; set; } = null; // null = temp directory + public bool IsMessageAcknowledgmentEnabled { get; set; } = false; + public int AcknowledgmentTimeoutMs { get; set; } = 5000; + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/Models/NetworkMessage.cs b/EonaCat.Transfer/Models/NetworkMessage.cs new file mode 100644 index 0000000..f6572ba --- /dev/null +++ b/EonaCat.Transfer/Models/NetworkMessage.cs @@ -0,0 +1,46 @@ +namespace EonaCat.Transfer.Models +{ + public class NetworkMessage + { + public MessageType Type { get; set; } + public byte[] Payload { get; set; } + public string SessionId { get; set; } + public DateTime Timestamp { get; set; } + public long SequenceNumber { get; set; } + + public static byte[] Serialize(NetworkMessage msg) + { + using (var messageStream = new MemoryStream()) + using (var binaryWriter = new BinaryWriter(messageStream)) + { + binaryWriter.Write((byte)msg.Type); + binaryWriter.Write(msg.SequenceNumber); + binaryWriter.Write(msg.Timestamp.ToBinary()); + binaryWriter.Write(msg.SessionId ?? string.Empty); + binaryWriter.Write(msg.Payload?.Length ?? 0); + if (msg.Payload != null) + { + binaryWriter.Write(msg.Payload); + } + + return messageStream.ToArray(); + } + } + + public static NetworkMessage Deserialize(byte[] data) + { + using (var memoryStream = new MemoryStream(data)) + using (var binaryReader = new BinaryReader(memoryStream)) + { + return new NetworkMessage + { + Type = (MessageType)binaryReader.ReadByte(), + SequenceNumber = binaryReader.ReadInt64(), + Timestamp = DateTime.FromBinary(binaryReader.ReadInt64()), + SessionId = binaryReader.ReadString(), + Payload = binaryReader.ReadBytes(binaryReader.ReadInt32()) + }; + } + } + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/Models/NetworkStatistics.cs b/EonaCat.Transfer/Models/NetworkStatistics.cs new file mode 100644 index 0000000..adaf8ba --- /dev/null +++ b/EonaCat.Transfer/Models/NetworkStatistics.cs @@ -0,0 +1,67 @@ +using System.Collections.Concurrent; +using System.Text; + +namespace EonaCat.Transfer.Models +{ + public class NetworkStatistics + { + public long TotalBytesSent { get; set; } + public long TotalBytesReceived { get; set; } + public long TotalMessagesSent { get; set; } + public long TotalMessagesReceived { get; set; } + public int ActiveConnections { get; set; } + public DateTime StartTime { get; set; } + public TimeSpan Uptime => DateTime.UtcNow - StartTime; + public double BytesSentPerSecond => TotalBytesSent / Uptime.TotalSeconds; + public double BytesReceivedPerSecond => TotalBytesReceived / Uptime.TotalSeconds; + public double MessagesSentPerSecond => TotalMessagesSent / Uptime.TotalSeconds; + public double MessagesReceivedPerSecond => TotalMessagesReceived / Uptime.TotalSeconds; + + public ConcurrentDictionary CustomCounters { get; } = new ConcurrentDictionary(); + + public NetworkStatistics() + { + StartTime = DateTime.UtcNow; + } + + public void IncrementCounter(string name, long value = 1) + { + CustomCounters.AddOrUpdate(name, value, (key, oldValue) => oldValue + value); + } + + public override string ToString() + { + var stringBuilder = new StringBuilder(); + stringBuilder.AppendLine($"Network Statistics (Uptime: {Uptime:hh\\:mm\\:ss})"); + stringBuilder.AppendLine($"Active Connections: {ActiveConnections}"); + stringBuilder.AppendLine($"Total Sent: {FormatBytes(TotalBytesSent)} ({TotalMessagesSent} messages)"); + stringBuilder.AppendLine($"Total Received: {FormatBytes(TotalBytesReceived)} ({TotalMessagesReceived} messages)"); + stringBuilder.AppendLine($"Send Rate: {FormatBytes((long)BytesSentPerSecond)}/s ({MessagesSentPerSecond:F2} msg/s)"); + stringBuilder.AppendLine($"Receive Rate: {FormatBytes((long)BytesReceivedPerSecond)}/s ({MessagesReceivedPerSecond:F2} msg/s)"); + + if (CustomCounters.Any()) + { + stringBuilder.AppendLine("Custom Counters:"); + foreach (var kvp in CustomCounters) + { + stringBuilder.AppendLine($" {kvp.Key}: {kvp.Value}"); + } + } + + return stringBuilder.ToString(); + } + + private static string FormatBytes(long bytes) + { + string[] sizes = { "B", "KB", "MB", "GB", "TB" }; + double len = bytes; + int order = 0; + while (len >= 1024 && order < sizes.Length - 1) + { + order++; + len = len / 1024; + } + return $"{len:0.##} {sizes[order]}"; + } + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/ProtocolType.cs b/EonaCat.Transfer/ProtocolType.cs new file mode 100644 index 0000000..218eb97 --- /dev/null +++ b/EonaCat.Transfer/ProtocolType.cs @@ -0,0 +1,9 @@ +namespace EonaCat.Transfer +{ + public enum ProtocolType + { + TCP, + UDP, + REST + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/RestClient.cs b/EonaCat.Transfer/RestClient.cs new file mode 100644 index 0000000..e551139 --- /dev/null +++ b/EonaCat.Transfer/RestClient.cs @@ -0,0 +1,145 @@ +using EonaCat.Json; +using EonaCat.Transfer.Models; +using System.Net.Http; +using System.Text; + +namespace EonaCat.Transfer +{ + public class RestClient : IDisposable + { + private readonly HttpClient _httpClient; + private readonly NetworkConfig _config; + + public event EventHandler<(string Url, long BytesDownloaded, long? TotalBytes)> DownloadProgress; + + public RestClient(NetworkConfig config = null) + { + _config = config ?? new NetworkConfig(); + + var handler = new HttpClientHandler(); + if (_config.EnableSsl && !_config.SslValidateServerCertificate) + { + handler.ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => true; + } + + _httpClient = new HttpClient(handler) + { + Timeout = TimeSpan.FromMilliseconds(_config.SendTimeoutMs) + }; + } + + public void SetAuthorizationHeader(string scheme, string parameter) + { + _httpClient.DefaultRequestHeaders.Authorization = + new System.Net.Http.Headers.AuthenticationHeaderValue(scheme, parameter); + } + + public void SetBearerToken(string token) + { + SetAuthorizationHeader("Bearer", token); + } + + public void AddHeader(string name, string value) + { + _httpClient.DefaultRequestHeaders.Add(name, value); + } + + public async Task GetAsync(string url) + { + var response = await _httpClient.GetAsync(url); + response.EnsureSuccessStatusCode(); + return await response.Content.ReadAsStringAsync(); + } + + public async Task GetAsync(string url) + { + var json = await GetAsync(url); + return JsonHelper.ToObject(json); + } + + public async Task PostAsync(string url, string json) + { + var content = new StringContent(json, Encoding.UTF8, "application/json"); + var response = await _httpClient.PostAsync(url, content); + response.EnsureSuccessStatusCode(); + return await response.Content.ReadAsStringAsync(); + } + + public async Task PostAsync(string url, TRequest data) + { + var json = JsonHelper.ToJson(data); + var responseJson = await PostAsync(url, json); + return JsonHelper.ToObject(responseJson); + } + + public async Task PutAsync(string url, string json) + { + var content = new StringContent(json, Encoding.UTF8, "application/json"); + var response = await _httpClient.PutAsync(url, content); + response.EnsureSuccessStatusCode(); + return await response.Content.ReadAsStringAsync(); + } + + public async Task DeleteAsync(string url) + { + var response = await _httpClient.DeleteAsync(url); + response.EnsureSuccessStatusCode(); + return await response.Content.ReadAsStringAsync(); + } + + public async Task DownloadFileAsync(string url) + { + using (var response = await _httpClient.GetAsync(url, HttpCompletionOption.ResponseHeadersRead)) + { + response.EnsureSuccessStatusCode(); + + var totalBytes = response.Content.Headers.ContentLength; + using (var stream = await response.Content.ReadAsStreamAsync()) + using (var memoryStream = new MemoryStream()) + { + var buffer = new byte[8192]; + long downloadedBytes = 0; + int bytesRead; + + while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length)) > 0) + { + await memoryStream.WriteAsync(buffer, 0, bytesRead); + downloadedBytes += bytesRead; + DownloadProgress?.Invoke(this, (url, downloadedBytes, totalBytes)); + } + + return memoryStream.ToArray(); + } + } + } + + public async Task DownloadFileAsync(string url, string destinationPath) + { + using (var http = new HttpClient()) + using (var stream = await http.GetStreamAsync(url)) + using (var file = File.Create(destinationPath)) + { + await stream.CopyToAsync(file); + } + } + + public async Task UploadFileAsync(string url, string filePath, string fieldName = "file") + { + using (var form = new MultipartFormDataContent()) + using (var fileStream = File.OpenRead(filePath)) + { + var fileContent = new StreamContent(fileStream); + form.Add(fileContent, fieldName, Path.GetFileName(filePath)); + + var response = await _httpClient.PostAsync(url, form); + response.EnsureSuccessStatusCode(); + return await response.Content.ReadAsStringAsync(); + } + } + + public void Dispose() + { + _httpClient?.Dispose(); + } + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/SslHelper.cs b/EonaCat.Transfer/SslHelper.cs new file mode 100644 index 0000000..82955de --- /dev/null +++ b/EonaCat.Transfer/SslHelper.cs @@ -0,0 +1,153 @@ +using System.Security.Cryptography.X509Certificates; + +namespace EonaCat.Transfer.Helpers +{ + public static class SslHelper + { + /// + /// Creates a self-signed certificate for testing purposes + /// + public static X509Certificate2 CreateSelfSignedCertificate(string subjectName, int validityYears = 5) + { +#if NET6_0_OR_GREATER + using (var rsa = System.Security.Cryptography.RSA.Create(2048)) + { + var request = new System.Security.Cryptography.X509Certificates.CertificateRequest( + $"CN={subjectName}", + rsa, + System.Security.Cryptography.HashAlgorithmName.SHA256, + System.Security.Cryptography.RSASignaturePadding.Pkcs1); + + request.CertificateExtensions.Add( + new System.Security.Cryptography.X509Certificates.X509BasicConstraintsExtension( + false, false, 0, true)); + + request.CertificateExtensions.Add( + new System.Security.Cryptography.X509Certificates.X509KeyUsageExtension( + System.Security.Cryptography.X509Certificates.X509KeyUsageFlags.DigitalSignature | + System.Security.Cryptography.X509Certificates.X509KeyUsageFlags.KeyEncipherment, + true)); + + request.CertificateExtensions.Add( + new System.Security.Cryptography.X509Certificates.X509EnhancedKeyUsageExtension( + new System.Security.Cryptography.OidCollection + { + new System.Security.Cryptography.Oid("1.3.6.1.5.5.7.3.1") // Server Authentication + }, + true)); + + var sanBuilder = new System.Security.Cryptography.X509Certificates.SubjectAlternativeNameBuilder(); + sanBuilder.AddDnsName(subjectName); + sanBuilder.AddDnsName("localhost"); + sanBuilder.AddIpAddress(System.Net.IPAddress.Loopback); + request.CertificateExtensions.Add(sanBuilder.Build()); + + var notBefore = DateTimeOffset.UtcNow.AddDays(-1); + var notAfter = DateTimeOffset.UtcNow.AddYears(validityYears); + + var certificate = request.CreateSelfSigned(notBefore, notAfter); + + return new X509Certificate2( + certificate.Export(X509ContentType.Pfx, "temp"), + "temp", + X509KeyStorageFlags.Exportable); + } +#else + throw new NotSupportedException("Self-signed certificate generation requires .NET 6.0 or higher. " + + "For .NET Framework 4.8, use makecert.exe or PowerShell New-SelfSignedCertificate."); +#endif + } + + /// + /// Loads certificate from file + /// + public static X509Certificate2 LoadCertificate(string path, string password = null) + { + return new X509Certificate2(path, password); + } + + /// + /// Saves certificate to file + /// + public static void SaveCertificate(X509Certificate2 certificate, string path, string password) + { + var bytes = certificate.Export(X509ContentType.Pfx, password); + File.WriteAllBytes(path, bytes); + } + + /// + /// Gets certificate from Windows certificate store + /// + public static X509Certificate2 GetCertificateFromStore( + string subjectName, + StoreName storeName = StoreName.My, + StoreLocation storeLocation = StoreLocation.CurrentUser) + { + using (var store = new X509Store(storeName, storeLocation)) + { + store.Open(OpenFlags.ReadOnly); + var certificates = store.Certificates.Find( + X509FindType.FindBySubjectName, + subjectName, + validOnly: false); + + return certificates.Count > 0 ? certificates[0] : null; + } + } + + /// + /// Installs certificate to Windows certificate store + /// + public static void InstallCertificateToStore( + X509Certificate2 certificate, + StoreName storeName = StoreName.My, + StoreLocation storeLocation = StoreLocation.CurrentUser) + { + using (var store = new X509Store(storeName, storeLocation)) + { + store.Open(OpenFlags.ReadWrite); + store.Add(certificate); + } + } + + /// + /// Validates if certificate is valid for the given hostname + /// + public static bool ValidateCertificateForHost(X509Certificate2 certificate, string hostname) + { + if (certificate == null) + { + return false; + } + + // Check expiration + if (DateTime.Now < certificate.NotBefore || DateTime.Now > certificate.NotAfter) + { + return false; + } + + // Check subject name + var subject = certificate.Subject; + if (subject.Contains($"CN={hostname}")) + { + return true; + } + + // Check SAN (Subject Alternative Names) + foreach (var extension in certificate.Extensions) + { + if (extension.Oid.Value == "2.5.29.17") // SAN OID + { + var asnData = new System.Security.Cryptography.AsnEncodedData(extension.Oid, extension.RawData); + var sanString = asnData.Format(false); + if (sanString.Contains(hostname)) + { + return true; + } + } + } + + return false; + } + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/TcpClient.cs b/EonaCat.Transfer/TcpClient.cs new file mode 100644 index 0000000..e1d79c7 --- /dev/null +++ b/EonaCat.Transfer/TcpClient.cs @@ -0,0 +1,575 @@ +using EonaCat.Transfer.Models; +using System.Buffers; +using System.Collections.Concurrent; +using System.Net.Security; +using System.Net.Sockets; +using System.Security.Cryptography.X509Certificates; +using System.Text; + +namespace EonaCat.Transfer +{ + public class TcpClient : IDisposable + { + private readonly NetworkConfig _config; + private Socket _socket; + private Stream _stream; + private CancellationTokenSource _cts; + private long _sequenceNumber; + private Task _receiveTask; + private Task _keepAliveTask; + private int _reconnectAttempts; + private AesEncryptionProvider _aesProvider; + private string _lastHost; + private int _lastPort; + private readonly ConcurrentDictionary> _pendingAcknowledgments; + private readonly ConcurrentDictionary _activeFileTransfers; + + public bool IsConnected => _socket?.Connected ?? false; + public long BytesSent { get; private set; } + public long BytesReceived { get; private set; } + public DateTime LastActivity { get; private set; } + public int ReconnectAttempts => _reconnectAttempts; + + public event EventHandler Connected; + public event EventHandler Disconnected; + public event EventHandler Reconnecting; + public event EventHandler MessageReceived; + public event EventHandler<(string FilePath, long Size)> FileTransferStarted; + public event EventHandler<(string FilePath, long BytesTransferred, long TotalBytes)> FileTransferProgress; + public event EventHandler FileTransferCompleted; + public event EventHandler Error; + + private class FileTransferState + { + public string FileName { get; set; } + public long TotalBytes { get; set; } + public long BytesReceived { get; set; } + public FileStream Stream { get; set; } + } + + public TcpClient(NetworkConfig config = null) + { + _config = config ?? new NetworkConfig(); + _pendingAcknowledgments = new ConcurrentDictionary>(); + _activeFileTransfers = new ConcurrentDictionary(); + + if (_config.AesEncryption?.IsAesEnabled == true) + { + _aesProvider = new AesEncryptionProvider(_config.AesEncryption); + } + } + + public async Task ConnectAsync(string host, int port) + { + _lastHost = host; + _lastPort = port; + _cts = new CancellationTokenSource(); + await ConnectInternalAsync(host, port); + } + + private async Task ConnectInternalAsync(string host, int port) + { + try + { + _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp); + + if (_config.NoDelay) + { + _socket.NoDelay = true; + } + + _socket.SendTimeout = _config.SendTimeoutMs; + _socket.ReceiveTimeout = _config.ReceiveTimeoutMs; + + await _socket.ConnectAsync(host, port); + + Stream stream = new NetworkStream(_socket); + + // Enable SSL/TLS if configured + if (_config.EnableSsl) + { + var sslStream = new SslStream( + stream, + false, + new RemoteCertificateValidationCallback(ValidateServerCertificate), + null); + + var targetHost = _config.SslTargetHost ?? host; + + await sslStream.AuthenticateAsClientAsync( + targetHost, + null, + _config.SslProtocols, + checkCertificateRevocation: true); + + stream = sslStream; + } + + _stream = stream; + + LastActivity = DateTime.UtcNow; + _reconnectAttempts = 0; + + Connected?.Invoke(this, EventArgs.Empty); + + _receiveTask = Task.Run(() => ReceiveLoopAsync(_cts.Token)); + + if (_config.EnableKeepAlive) + { + _keepAliveTask = Task.Run(() => KeepAliveLoopAsync(_cts.Token)); + } + } + catch (Exception ex) + { + Error?.Invoke(this, ex); + await HandleReconnectAsync(host, port); + } + } + + private async Task HandleReconnectAsync(string host, int port) + { + if (_config.AutoReconnect && + (_config.MaxReconnectAttempts == -1 || _reconnectAttempts < _config.MaxReconnectAttempts)) + { + _reconnectAttempts++; + Reconnecting?.Invoke(this, _reconnectAttempts); + + await Task.Delay(_config.ReconnectDelayMs); + + if (!_cts.Token.IsCancellationRequested) + { + await ConnectInternalAsync(host, port); + } + } + } + + private async Task ReceiveLoopAsync(CancellationToken ct) + { + var buffer = ArrayPool.Shared.Rent(_config.BufferSize); + try + { + while (!ct.IsCancellationRequested && IsConnected) + { + var message = await ReceiveMessageAsync(buffer, ct); + if (message == null) + { + break; + } + + LastActivity = DateTime.UtcNow; + BytesReceived += message.Payload?.Length ?? 0; + + switch (message.Type) + { + case MessageType.Data: + MessageReceived?.Invoke(this, message); + if (_config.IsMessageAcknowledgmentEnabled) + { + await SendMessageAsync(new NetworkMessage + { + Type = MessageType.Acknowledgment, + SequenceNumber = message.SequenceNumber + }); + } + break; + case MessageType.KeepAliveResponse: + // Keep alive acknowledged + break; + case MessageType.FileTransferStart: + await HandleFileTransferStartAsync(message); + break; + case MessageType.FileTransferChunk: + await HandleFileTransferChunkAsync(message); + break; + case MessageType.FileTransferEnd: + await HandleFileTransferEndAsync(message); + break; + case MessageType.Acknowledgment: + if (_pendingAcknowledgments.TryRemove(message.SequenceNumber, out var tcs)) + { + tcs.SetResult(true); + } + break; + } + } + } + catch (Exception ex) + { + Error?.Invoke(this, ex); + } + finally + { + ArrayPool.Shared.Return(buffer); + await HandleDisconnectAsync(); + } + } + + private async Task ReceiveMessageAsync(byte[] buffer, CancellationToken ct) + { + try + { + byte[] data = null; + + switch (_config.Framing) + { + case FramingMode.LengthPrefix: + var lengthBytes = new byte[4]; + await ReadExactAsync(_stream, lengthBytes, 0, 4, ct); + var length = BitConverter.ToInt32(lengthBytes, 0); + + if (length > _config.MaxMessageSize || length < 0) + { + throw new InvalidDataException("Invalid message length"); + } + + data = new byte[length]; + await ReadExactAsync(_stream, data, 0, length, ct); + break; + + case FramingMode.Delimiter: + using (var ms = new MemoryStream()) + { + var delimiterPos = 0; + while (true) + { + var b = _stream.ReadByte(); + if (b == -1) + { + return null; + } + + ms.WriteByte((byte)b); + + if ((byte)b == _config.Delimiter[delimiterPos]) + { + delimiterPos++; + if (delimiterPos == _config.Delimiter.Length) + { + data = ms.ToArray(); + Array.Resize(ref data, data.Length - _config.Delimiter.Length); + break; + } + } + else + { + delimiterPos = 0; + } + + if (ms.Length > _config.MaxMessageSize) + { + throw new InvalidDataException("Message too large"); + } + } + } + break; + + case FramingMode.FixedLength: + data = new byte[_config.FixedLength]; + await ReadExactAsync(_stream, data, 0, _config.FixedLength, ct); + break; + + case FramingMode.None: + var bytesRead = await _stream.ReadAsync(buffer, 0, buffer.Length, ct); + if (bytesRead == 0) + { + return null; + } + + data = new byte[bytesRead]; + Array.Copy(buffer, data, bytesRead); + break; + } + + // Apply AES decryption if enabled + if (_aesProvider != null) + { + try + { + data = await _aesProvider.DecryptAsync(data); + } + catch + { + // If decryption fails, message might not be encrypted (keepalive, etc.) + } + } + + return NetworkMessage.Deserialize(data); + } + catch (Exception) + { + return null; + } + } + + private async Task ReadExactAsync(Stream stream, byte[] buffer, int offset, int count, CancellationToken ct) + { + var totalRead = 0; + while (totalRead < count) + { + var read = await stream.ReadAsync(buffer, offset + totalRead, count - totalRead, ct); + if (read == 0) + { + throw new EndOfStreamException(); + } + + totalRead += read; + } + } + + private bool ValidateServerCertificate( + object sender, + X509Certificate certificate, + X509Chain chain, + SslPolicyErrors sslPolicyErrors) + { + if (!_config.SslValidateServerCertificate) + { + return true; + } + + if (sslPolicyErrors == SslPolicyErrors.None) + { + return true; + } + + Error?.Invoke(this, new Exception($"SSL Certificate error: {sslPolicyErrors}")); + return false; + } + + private async Task KeepAliveLoopAsync(CancellationToken ct) + { + while (!ct.IsCancellationRequested && IsConnected) + { + try + { + await Task.Delay(_config.KeepAliveIntervalMs, ct); + await SendMessageAsync(new NetworkMessage { Type = MessageType.KeepAlive }); + } + catch + { + break; + } + } + } + + public async Task SendMessageAsync(NetworkMessage message) + { + if (!IsConnected) + { + return; + } + + message.SequenceNumber = Interlocked.Increment(ref _sequenceNumber); + message.Timestamp = DateTime.UtcNow; + + var data = NetworkMessage.Serialize(message); + + // Apply AES encryption if enabled + if (_aesProvider != null && message.Type == MessageType.Data) + { + data = await _aesProvider.EncryptAsync(data); + } + + // Apply framing + await SendFramedDataAsync(data, _cts.Token); + + BytesSent += data.Length; + LastActivity = DateTime.UtcNow; + + // Wait for acknowledgment if enabled + if (_config.IsMessageAcknowledgmentEnabled && message.Type == MessageType.Data) + { + var tcs = new TaskCompletionSource(); + _pendingAcknowledgments[message.SequenceNumber] = tcs; + + var ackTask = tcs.Task; + var timeoutTask = Task.Delay(_config.AcknowledgmentTimeoutMs); + + if (await Task.WhenAny(ackTask, timeoutTask) == timeoutTask) + { + _pendingAcknowledgments.TryRemove(message.SequenceNumber, out _); + throw new TimeoutException("Message acknowledgment timeout"); + } + } + } + + private async Task SendFramedDataAsync(byte[] data, CancellationToken ct) + { + switch (_config.Framing) + { + case FramingMode.LengthPrefix: + var lengthBytes = BitConverter.GetBytes(data.Length); + await _stream.WriteAsync(lengthBytes, 0, lengthBytes.Length, ct); + await _stream.WriteAsync(data, 0, data.Length, ct); + break; + + case FramingMode.Delimiter: + await _stream.WriteAsync(data, 0, data.Length, ct); + await _stream.WriteAsync(_config.Delimiter, 0, _config.Delimiter.Length, ct); + break; + + case FramingMode.FixedLength: + case FramingMode.None: + await _stream.WriteAsync(data, 0, data.Length, ct); + break; + } + await _stream.FlushAsync(ct); + } + + public async Task SendDataAsync(byte[] data) => + await SendMessageAsync(new NetworkMessage { Type = MessageType.Data, Payload = data }); + + public async Task SendStringAsync(string text) => + await SendDataAsync(Encoding.UTF8.GetBytes(text)); + + public async Task SendFileAsync(string filePath) + { + var fileInfo = new FileInfo(filePath); + if (!fileInfo.Exists) + { + throw new FileNotFoundException("File not found", filePath); + } + + var fileName = fileInfo.Name; + var fileSize = fileInfo.Length; + + // Send start message + var startPayload = Encoding.UTF8.GetBytes($"{fileName}|{fileSize}"); + await SendMessageAsync(new NetworkMessage + { + Type = MessageType.FileTransferStart, + Payload = startPayload + }); + + // Send file chunks + using (var fs = File.OpenRead(filePath)) + { + var buffer = new byte[_config.FileTransferChunkSize]; + int bytesRead; + + while ((bytesRead = await fs.ReadAsync(buffer, 0, buffer.Length)) > 0) + { + var chunk = new byte[bytesRead]; + Array.Copy(buffer, chunk, bytesRead); + + await SendMessageAsync(new NetworkMessage + { + Type = MessageType.FileTransferChunk, + Payload = chunk + }); + } + } + + // Send end message + await SendMessageAsync(new NetworkMessage + { + Type = MessageType.FileTransferEnd, + Payload = Encoding.UTF8.GetBytes(fileName) + }); + } + + private async Task HandleFileTransferStartAsync(NetworkMessage message) + { + try + { + var info = Encoding.UTF8.GetString(message.Payload).Split('|'); + var fileName = info[0]; + var fileSize = long.Parse(info[1]); + + var saveDirectory = _config.FileTransferDirectory ?? Path.GetTempPath(); + if (!Directory.Exists(saveDirectory)) + { + Directory.CreateDirectory(saveDirectory); + } + + var savePath = Path.Combine(saveDirectory, fileName); + + // Ensure unique filename + var counter = 1; + var nameWithoutExt = Path.GetFileNameWithoutExtension(fileName); + var extension = Path.GetExtension(fileName); + while (File.Exists(savePath)) + { + savePath = Path.Combine(saveDirectory, $"{nameWithoutExt}_{counter}{extension}"); + counter++; + } + + var transferState = new FileTransferState + { + FileName = savePath, + TotalBytes = fileSize, + BytesReceived = 0, + Stream = File.Create(savePath) + }; + + _activeFileTransfers[fileName] = transferState; + FileTransferStarted?.Invoke(this, (savePath, fileSize)); + } + catch (Exception ex) + { + Error?.Invoke(this, ex); + } + } + + private async Task HandleFileTransferChunkAsync(NetworkMessage message) + { + // Find active transfer by matching the message + foreach (var kvp in _activeFileTransfers) + { + var transfer = kvp.Value; + await transfer.Stream.WriteAsync(message.Payload, 0, message.Payload.Length); + transfer.BytesReceived += message.Payload.Length; + + FileTransferProgress?.Invoke(this, (transfer.FileName, transfer.BytesReceived, transfer.TotalBytes)); + break; // Assuming one active transfer at a time + } + } + + private async Task HandleFileTransferEndAsync(NetworkMessage message) + { + var fileName = Encoding.UTF8.GetString(message.Payload); + + if (_activeFileTransfers.TryRemove(fileName, out var transfer)) + { + transfer.Stream.Dispose(); + FileTransferCompleted?.Invoke(this, transfer.FileName); + } + } + + private async Task HandleDisconnectAsync() + { + Disconnected?.Invoke(this, EventArgs.Empty); + + // Clean up file transfers + foreach (var transfer in _activeFileTransfers.Values) + { + transfer.Stream?.Dispose(); + } + _activeFileTransfers.Clear(); + + if (_config.AutoReconnect && !_cts.Token.IsCancellationRequested && _lastHost != null) + { + await HandleReconnectAsync(_lastHost, _lastPort); + } + } + + public void Disconnect() + { + _cts?.Cancel(); + _stream?.Dispose(); + _socket?.Dispose(); + } + + public void Dispose() + { + Disconnect(); + _aesProvider?.Dispose(); + + foreach (var transfer in _activeFileTransfers.Values) + { + transfer.Stream?.Dispose(); + } + _activeFileTransfers.Clear(); + } + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/TcpConnectionPool.cs b/EonaCat.Transfer/TcpConnectionPool.cs new file mode 100644 index 0000000..2c15dce --- /dev/null +++ b/EonaCat.Transfer/TcpConnectionPool.cs @@ -0,0 +1,90 @@ +using EonaCat.Transfer.Models; +using System.Collections.Concurrent; + +namespace EonaCat.Transfer +{ + public class TcpConnectionPool : IDisposable + { + private readonly NetworkConfig _config; + private readonly ConcurrentBag _availableConnections; + private readonly ConcurrentDictionary _activeConnections; + private readonly SemaphoreSlim _semaphore; + private readonly string _host; + private readonly int _port; + private int _totalCreated; + + public int AvailableConnections => _availableConnections.Count; + public int ActiveConnections => _activeConnections.Count; + public int TotalCreated => _totalCreated; + + public TcpConnectionPool(string host, int port, int maxConnections = 100, NetworkConfig config = null) + { + _host = host; + _port = port; + _config = config ?? new NetworkConfig(); + _availableConnections = new ConcurrentBag(); + _activeConnections = new ConcurrentDictionary(); + _semaphore = new SemaphoreSlim(maxConnections); + } + + public async Task AcquireAsync() + { + await _semaphore.WaitAsync(); + + if (_availableConnections.TryTake(out var client)) + { + if (client.IsConnected) + { + _activeConnections[Guid.NewGuid().ToString()] = client; + return client; + } + client.Dispose(); + } + + // Create new connection + var newClient = new TcpClient(_config); + await newClient.ConnectAsync(_host, _port); + Interlocked.Increment(ref _totalCreated); + + var id = Guid.NewGuid().ToString(); + _activeConnections[id] = newClient; + return newClient; + } + + public void Release(TcpClient client) + { + var entry = _activeConnections.FirstOrDefault(kvp => kvp.Value == client); + if (entry.Key != null) + { + _activeConnections.TryRemove(entry.Key, out _); + + if (client.IsConnected) + { + _availableConnections.Add(client); + } + else + { + client.Dispose(); + } + + _semaphore.Release(); + } + } + + public void Dispose() + { + while (_availableConnections.TryTake(out var client)) + { + client.Dispose(); + } + + foreach (var client in _activeConnections.Values) + { + client.Dispose(); + } + + _activeConnections.Clear(); + _semaphore?.Dispose(); + } + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/TcpServer.cs b/EonaCat.Transfer/TcpServer.cs new file mode 100644 index 0000000..0336f19 --- /dev/null +++ b/EonaCat.Transfer/TcpServer.cs @@ -0,0 +1,546 @@ +using EonaCat.Transfer.Models; +using System.Buffers; +using System.Collections.Concurrent; +using System.Net; +using System.Net.Security; +using System.Net.Sockets; +using System.Security.Cryptography.X509Certificates; +using System.Text; + +namespace EonaCat.Transfer +{ + public class TcpServer : IDisposable + { + private readonly NetworkConfig _config; + private Socket _listener; + private readonly ConcurrentDictionary _clients; + private CancellationTokenSource _cts; + private long _sequenceNumber; + private readonly SemaphoreSlim _connectionSemaphore; + private AesEncryptionProvider _aesProvider; + + public event EventHandler ClientConnected; + public event EventHandler ClientDisconnected; + public event EventHandler<(ClientConnection Client, NetworkMessage Message)> MessageReceived; + public event EventHandler<(ClientConnection Client, string FilePath, long Size)> FileTransferStarted; + public event EventHandler<(ClientConnection Client, string FilePath)> FileTransferCompleted; + public event EventHandler Error; + + public int ActiveConnections => _clients.Count; + + public TcpServer(NetworkConfig config = null) + { + _config = config ?? new NetworkConfig(); + _clients = new ConcurrentDictionary(); + _connectionSemaphore = new SemaphoreSlim(_config.MaxConnections); + + if (_config.AesEncryption?.IsAesEnabled == true) + { + _aesProvider = new AesEncryptionProvider(_config.AesEncryption); + } + } + + public async Task StartAsync(int port, string bindAddress = "0.0.0.0") + { + _cts = new CancellationTokenSource(); + _listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp); + + if (_config.NoDelay) + { + _listener.NoDelay = true; + } + + _listener.Bind(new IPEndPoint(IPAddress.Parse(bindAddress), port)); + _listener.Listen(_config.MaxConnections); + + _ = Task.Run(() => AcceptClientsAsync(_cts.Token)); + } + + private async Task AcceptClientsAsync(CancellationToken ct) + { + while (!ct.IsCancellationRequested) + { + try + { + await _connectionSemaphore.WaitAsync(ct); + var socket = await _listener.AcceptAsync(); + var client = new ClientConnection(socket); + + if (_clients.TryAdd(client.Id, client)) + { + ClientConnected?.Invoke(this, client); + _ = Task.Run(() => HandleClientAsync(client), ct); + + if (_config.EnableKeepAlive) + { + _ = Task.Run(() => KeepAliveLoopAsync(client), ct); + } + } + } + catch (Exception ex) + { + _connectionSemaphore.Release(); + if (!ct.IsCancellationRequested) + { + Error?.Invoke(this, ex); + } + } + } + } + + private async Task HandleClientAsync(ClientConnection client) + { + var buffer = ArrayPool.Shared.Rent(_config.BufferSize); + try + { + Stream stream = new NetworkStream(client.Socket); + + // Enable SSL/TLS if configured + if (_config.EnableSsl) + { + var sslStream = new SslStream(stream, false); + + if (_config.SslCertificate == null && !string.IsNullOrEmpty(_config.SslCertificatePath)) + { + _config.SslCertificate = new X509Certificate2( + _config.SslCertificatePath, + _config.SslCertificatePassword); + } + + await sslStream.AuthenticateAsServerAsync( + _config.SslCertificate, + clientCertificateRequired: false, + _config.SslProtocols, + checkCertificateRevocation: true); + + stream = sslStream; + } + + client.Stream = stream; + + while (client.IsConnected && !client.CancellationToken.Token.IsCancellationRequested) + { + var message = await ReceiveMessageAsync(stream, buffer, client.CancellationToken.Token); + if (message == null) + { + break; + } + + client.LastActivity = DateTime.UtcNow; + client.BytesReceived += message.Payload?.Length ?? 0; + + switch (message.Type) + { + case MessageType.Data: + MessageReceived?.Invoke(this, (client, message)); + if (_config.IsMessageAcknowledgmentEnabled) + { + await SendMessageAsync(client, new NetworkMessage + { + Type = MessageType.Acknowledgment, + SequenceNumber = message.SequenceNumber + }); + } + break; + case MessageType.KeepAlive: + await SendMessageAsync(client, new NetworkMessage + { + Type = MessageType.KeepAliveResponse + }); + break; + case MessageType.FileTransferStart: + await HandleFileTransferAsync(client, message); + break; + case MessageType.Acknowledgment: + if (client.PendingAcknowledgments.TryRemove(message.SequenceNumber, out var tcs)) + { + tcs.SetResult(true); + } + break; + case MessageType.Disconnect: + client.IsConnected = false; + break; + } + } + } + catch (Exception ex) + { + Error?.Invoke(this, ex); + } + finally + { + ArrayPool.Shared.Return(buffer); + DisconnectClient(client); + } + } + + private async Task ReceiveMessageAsync(Stream stream, byte[] buffer, CancellationToken ct) + { + try + { + byte[] data = null; + + switch (_config.Framing) + { + case FramingMode.LengthPrefix: + var lengthBytes = new byte[4]; + await ReadExactAsync(stream, lengthBytes, 0, 4, ct); + var length = BitConverter.ToInt32(lengthBytes, 0); + + if (length > _config.MaxMessageSize || length < 0) + { + throw new InvalidDataException("Invalid message length"); + } + + data = new byte[length]; + await ReadExactAsync(stream, data, 0, length, ct); + break; + + case FramingMode.Delimiter: + using (var ms = new MemoryStream()) + { + var delimiterPos = 0; + while (true) + { + var b = stream.ReadByte(); + if (b == -1) + { + return null; + } + + ms.WriteByte((byte)b); + + if ((byte)b == _config.Delimiter[delimiterPos]) + { + delimiterPos++; + if (delimiterPos == _config.Delimiter.Length) + { + data = ms.ToArray(); + Array.Resize(ref data, data.Length - _config.Delimiter.Length); + break; + } + } + else + { + delimiterPos = 0; + } + + if (ms.Length > _config.MaxMessageSize) + { + throw new InvalidDataException("Message too large"); + } + } + } + break; + + case FramingMode.FixedLength: + data = new byte[_config.FixedLength]; + await ReadExactAsync(stream, data, 0, _config.FixedLength, ct); + break; + + case FramingMode.None: + var bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, ct); + if (bytesRead == 0) + { + return null; + } + + data = new byte[bytesRead]; + Array.Copy(buffer, data, bytesRead); + break; + } + + // Apply AES decryption if enabled + if (_aesProvider != null) + { + try + { + data = await _aesProvider.DecryptAsync(data); + } + catch + { + // If decryption fails, it might be a non-data message (keepalive, etc.) + // Try to deserialize as-is + } + } + + return NetworkMessage.Deserialize(data); + } + catch (Exception) + { + return null; + } + } + + private async Task ReadExactAsync(Stream stream, byte[] buffer, int offset, int count, CancellationToken ct) + { + var totalRead = 0; + while (totalRead < count) + { + var read = await stream.ReadAsync(buffer, offset + totalRead, count - totalRead, ct); + if (read == 0) + { + throw new EndOfStreamException(); + } + + totalRead += read; + } + } + + private async Task KeepAliveLoopAsync(ClientConnection client) + { + while (client.IsConnected && !client.CancellationToken.Token.IsCancellationRequested) + { + try + { + await Task.Delay(_config.KeepAliveIntervalMs, client.CancellationToken.Token); + + if ((DateTime.UtcNow - client.LastActivity).TotalMilliseconds > _config.KeepAliveTimeoutMs) + { + client.IsConnected = false; + break; + } + + await SendMessageAsync(client, new NetworkMessage + { + Type = MessageType.KeepAlive + }); + } + catch + { + break; + } + } + } + + public async Task SendMessageAsync(ClientConnection client, NetworkMessage message) + { + if (!client.IsConnected) + { + return; + } + + try + { + message.SequenceNumber = Interlocked.Increment(ref _sequenceNumber); + message.Timestamp = DateTime.UtcNow; + + var data = NetworkMessage.Serialize(message); + + // Apply AES encryption if enabled + if (_aesProvider != null && message.Type == MessageType.Data) + { + data = await _aesProvider.EncryptAsync(data); + } + + await SendFramedDataAsync(client.Stream, data, client.CancellationToken.Token); + + client.BytesSent += data.Length; + client.LastActivity = DateTime.UtcNow; + + // Wait for acknowledgment if enabled + if (_config.IsMessageAcknowledgmentEnabled && message.Type == MessageType.Data) + { + var tcs = new TaskCompletionSource(); + client.PendingAcknowledgments[message.SequenceNumber] = tcs; + + var ackTask = tcs.Task; + var timeoutTask = Task.Delay(_config.AcknowledgmentTimeoutMs); + + if (await Task.WhenAny(ackTask, timeoutTask) == timeoutTask) + { + client.PendingAcknowledgments.TryRemove(message.SequenceNumber, out _); + throw new TimeoutException("Message acknowledgment timeout"); + } + } + } + catch (Exception ex) + { + Error?.Invoke(this, ex); + DisconnectClient(client); + } + } + + public async Task SendDataAsync(ClientConnection client, byte[] data) + { + await SendMessageAsync(client, new NetworkMessage + { + Type = MessageType.Data, + Payload = data + }); + } + + public async Task SendStringAsync(ClientConnection client, string text) + { + await SendDataAsync(client, Encoding.UTF8.GetBytes(text)); + } + + public async Task SendFileAsync(ClientConnection client, string filePath) + { + var fileInfo = new FileInfo(filePath); + if (!fileInfo.Exists) + { + throw new FileNotFoundException("File not found", filePath); + } + + var fileName = fileInfo.Name; + var fileSize = fileInfo.Length; + + // Send start message + var startPayload = Encoding.UTF8.GetBytes($"{fileName}|{fileSize}"); + await SendMessageAsync(client, new NetworkMessage + { + Type = MessageType.FileTransferStart, + Payload = startPayload + }); + + FileTransferStarted?.Invoke(this, (client, filePath, fileSize)); + + // Send file chunks + using (var fs = File.OpenRead(filePath)) + { + var buffer = new byte[_config.FileTransferChunkSize]; + int bytesRead; + long totalSent = 0; + + while ((bytesRead = await fs.ReadAsync(buffer, 0, buffer.Length)) > 0) + { + var chunk = new byte[bytesRead]; + Array.Copy(buffer, chunk, bytesRead); + + await SendMessageAsync(client, new NetworkMessage + { + Type = MessageType.FileTransferChunk, + Payload = chunk + }); + + totalSent += bytesRead; + } + } + + // Send end message + await SendMessageAsync(client, new NetworkMessage + { + Type = MessageType.FileTransferEnd, + Payload = Encoding.UTF8.GetBytes(fileName) + }); + + FileTransferCompleted?.Invoke(this, (client, filePath)); + } + + private async Task SendFramedDataAsync(Stream stream, byte[] data, CancellationToken ct) + { + switch (_config.Framing) + { + case FramingMode.LengthPrefix: + var lengthBytes = BitConverter.GetBytes(data.Length); + await stream.WriteAsync(lengthBytes, 0, lengthBytes.Length, ct); + await stream.WriteAsync(data, 0, data.Length, ct); + break; + + case FramingMode.Delimiter: + await stream.WriteAsync(data, 0, data.Length, ct); + await stream.WriteAsync(_config.Delimiter, 0, _config.Delimiter.Length, ct); + break; + + case FramingMode.FixedLength: + case FramingMode.None: + await stream.WriteAsync(data, 0, data.Length, ct); + break; + } + await stream.FlushAsync(ct); + } + + private async Task HandleFileTransferAsync(ClientConnection client, NetworkMessage startMessage) + { + try + { + var info = Encoding.UTF8.GetString(startMessage.Payload).Split('|'); + var fileName = info[0]; + var fileSize = long.Parse(info[1]); + + var saveDirectory = _config.FileTransferDirectory ?? Path.GetTempPath(); + if (!Directory.Exists(saveDirectory)) + { + Directory.CreateDirectory(saveDirectory); + } + + var savePath = Path.Combine(saveDirectory, fileName); + + // Ensure unique filename + var counter = 1; + var nameWithoutExt = Path.GetFileNameWithoutExtension(fileName); + var extension = Path.GetExtension(fileName); + while (File.Exists(savePath)) + { + savePath = Path.Combine(saveDirectory, $"{nameWithoutExt}_{counter}{extension}"); + counter++; + } + + FileTransferStarted?.Invoke(this, (client, savePath, fileSize)); + + using (var fs = File.Create(savePath)) + { + long totalReceived = 0; + var buffer = ArrayPool.Shared.Rent(_config.BufferSize); + + try + { + while (totalReceived < fileSize && client.IsConnected) + { + var chunkMessage = await ReceiveMessageAsync(client.Stream, buffer, client.CancellationToken.Token); + + if (chunkMessage == null) + { + break; + } + + if (chunkMessage.Type == MessageType.FileTransferChunk) + { + await fs.WriteAsync(chunkMessage.Payload, 0, chunkMessage.Payload.Length); + totalReceived += chunkMessage.Payload.Length; + } + else if (chunkMessage.Type == MessageType.FileTransferEnd) + { + break; + } + } + } + finally + { + ArrayPool.Shared.Return(buffer); + } + } + + FileTransferCompleted?.Invoke(this, (client, savePath)); + } + catch (Exception ex) + { + Error?.Invoke(this, ex); + } + } + + private void DisconnectClient(ClientConnection client) + { + if (_clients.TryRemove(client.Id, out _)) + { + ClientDisconnected?.Invoke(this, client); + client.Dispose(); + _connectionSemaphore.Release(); + } + } + + public void Dispose() + { + _cts?.Cancel(); + _listener?.Dispose(); + _aesProvider?.Dispose(); + foreach (var client in _clients.Values) + { + client.Dispose(); + } + + _clients.Clear(); + } + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/UdpClientConnection.cs b/EonaCat.Transfer/UdpClientConnection.cs new file mode 100644 index 0000000..9988c2e --- /dev/null +++ b/EonaCat.Transfer/UdpClientConnection.cs @@ -0,0 +1,100 @@ +using EonaCat.Transfer.Helpers; +using EonaCat.Transfer.Models; +using System.Net; +using System.Net.Sockets; + +namespace EonaCat.Transfer +{ + public class UdpClientConnection : IDisposable + { + private readonly NetworkConfig _config; + private UdpClient _udpClient; + private CancellationTokenSource _cts; + private AesEncryptionProvider _aesProvider; + private IPEndPoint _serverEndPoint; + + public event EventHandler MessageReceived; + public event EventHandler Error; + + public UdpClientConnection(NetworkConfig config = null) + { + _config = config ?? new NetworkConfig(); + + if (_config.AesEncryption?.IsAesEnabled == true) + { + _aesProvider = new AesEncryptionProvider(_config.AesEncryption); + } + } + + public async Task ConnectAsync(string host, int port) + { + _cts = new CancellationTokenSource(); + _serverEndPoint = new IPEndPoint(IPAddress.Parse(host), port); + _udpClient = new UdpClient(); + _udpClient.Connect(_serverEndPoint); + + _ = Task.Run(() => ReceiveLoopAsync(_cts.Token)); + } + + private async Task ReceiveLoopAsync(CancellationToken ct) + { + while (!ct.IsCancellationRequested) + { + try + { + var result = await _udpClient.ReceiveAsync(); + var data = result.Buffer; + + // Decrypt if enabled + if (_aesProvider != null) + { + data = await _aesProvider.DecryptAsync(data); + } + + // Decompress if enabled + if (_config.Compression != CompressionType.None) + { + data = await CompressionHelper.DecompressAsync(data, _config.Compression); + } + + var message = NetworkMessage.Deserialize(data); + MessageReceived?.Invoke(this, message); + } + catch (Exception ex) + { + if (!ct.IsCancellationRequested) + { + Error?.Invoke(this, ex); + } + } + } + } + + public async Task SendAsync(byte[] data) + { + var message = new NetworkMessage { Type = MessageType.Data, Payload = data }; + var serialized = NetworkMessage.Serialize(message); + + // Compress if enabled + if (_config.Compression != CompressionType.None) + { + serialized = await CompressionHelper.CompressAsync(serialized, _config.Compression); + } + + // Encrypt if enabled + if (_aesProvider != null) + { + serialized = await _aesProvider.EncryptAsync(serialized); + } + + await _udpClient.SendAsync(serialized, serialized.Length); + } + + public void Dispose() + { + _cts?.Cancel(); + _udpClient?.Dispose(); + _aesProvider?.Dispose(); + } + } +} \ No newline at end of file diff --git a/EonaCat.Transfer/UdpServer.cs b/EonaCat.Transfer/UdpServer.cs new file mode 100644 index 0000000..0bc17e3 --- /dev/null +++ b/EonaCat.Transfer/UdpServer.cs @@ -0,0 +1,167 @@ +using EonaCat.Transfer.Helpers; +using EonaCat.Transfer.Models; +using System.Collections.Concurrent; +using System.Net; +using System.Net.Sockets; + +namespace EonaCat.Transfer +{ + public class UdpServer : IDisposable + { + private readonly NetworkConfig _config; + private UdpClient _udpClient; + private CancellationTokenSource _cts; + private AesEncryptionProvider _aesProvider; + private readonly ConcurrentDictionary _knownClients; + + public event EventHandler<(IPEndPoint EndPoint, NetworkMessage Message)> MessageReceived; + public event EventHandler<(IPEndPoint EndPoint, Exception Error)> Error; + public event EventHandler ClientDiscovered; + + public int KnownClientsCount => _knownClients.Count; + + public UdpServer(NetworkConfig config = null) + { + _config = config ?? new NetworkConfig(); + _knownClients = new ConcurrentDictionary(); + + if (_config.AesEncryption?.IsAesEnabled == true) + { + _aesProvider = new AesEncryptionProvider(_config.AesEncryption); + } + } + + public async Task StartAsync(int port, string bindAddress = "0.0.0.0") + { + _cts = new CancellationTokenSource(); + _udpClient = new UdpClient(new IPEndPoint(IPAddress.Parse(bindAddress), port)); + _ = Task.Run(() => ReceiveLoopAsync(_cts.Token)); + + if (_config.EnableKeepAlive) + { + _ = Task.Run(() => CleanupInactiveClientsAsync(_cts.Token)); + } + } + + private async Task ReceiveLoopAsync(CancellationToken ct) + { + while (!ct.IsCancellationRequested) + { + try + { + var result = await _udpClient.ReceiveAsync(); + var data = result.Buffer; + + // Decrypt if enabled + if (_aesProvider != null) + { + try + { + data = await _aesProvider.DecryptAsync(data); + } + catch (Exception ex) + { + Error?.Invoke(this, (result.RemoteEndPoint, ex)); + continue; + } + } + + // Decompress if enabled + if (_config.Compression != CompressionType.None) + { + data = await CompressionHelper.DecompressAsync(data, _config.Compression); + } + + var message = NetworkMessage.Deserialize(data); + + // Track client + var clientKey = result.RemoteEndPoint.ToString(); + if (!_knownClients.ContainsKey(clientKey)) + { + _knownClients[clientKey] = DateTime.UtcNow; + ClientDiscovered?.Invoke(this, result.RemoteEndPoint); + } + else + { + _knownClients[clientKey] = DateTime.UtcNow; + } + + MessageReceived?.Invoke(this, (result.RemoteEndPoint, message)); + } + catch (Exception ex) + { + if (!ct.IsCancellationRequested) + { + Error?.Invoke(this, (null, ex)); + } + } + } + } + + private async Task CleanupInactiveClientsAsync(CancellationToken ct) + { + while (!ct.IsCancellationRequested) + { + try + { + await Task.Delay(_config.KeepAliveIntervalMs, ct); + + var timeout = DateTime.UtcNow.AddMilliseconds(-_config.KeepAliveTimeoutMs); + var inactiveClients = _knownClients.Where(kvp => kvp.Value < timeout).Select(kvp => kvp.Key).ToList(); + + foreach (var client in inactiveClients) + { + _knownClients.TryRemove(client, out _); + } + } + catch { } + } + } + + public async Task SendAsync(IPEndPoint endPoint, byte[] data) + { + var message = new NetworkMessage { Type = MessageType.Data, Payload = data }; + var serialized = NetworkMessage.Serialize(message); + + // Compress if enabled + if (_config.Compression != CompressionType.None) + { + serialized = await CompressionHelper.CompressAsync(serialized, _config.Compression); + } + + // Encrypt if enabled + if (_aesProvider != null) + { + serialized = await _aesProvider.EncryptAsync(serialized); + } + + await _udpClient.SendAsync(serialized, serialized.Length, endPoint); + } + + public async Task BroadcastAsync(byte[] data) + { + var tasks = new List(); + + foreach (var client in _knownClients.Keys) + { + var parts = client.Split(':'); + var ip = IPAddress.Parse(parts[0]); + var port = int.Parse(parts[1]); + var endPoint = new IPEndPoint(ip, port); + + tasks.Add(SendAsync(endPoint, data)); + } + + await Task.WhenAll(tasks); + } + + + + public void Dispose() + { + _cts?.Cancel(); + _udpClient?.Dispose(); + _aesProvider?.Dispose(); + } + } +} \ No newline at end of file diff --git a/LICENSE b/LICENSE index 386c7ef..ab37379 100644 --- a/LICENSE +++ b/LICENSE @@ -1,73 +1,204 @@ -Apache License -Version 2.0, January 2004 -http://www.apache.org/licenses/ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + https://EonaCat.com/license/ -TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + OF SOFTWARE BY EONACAT (JEROEN SAEY) -1. Definitions. + 1. Definitions. -"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. -"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. -"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. -"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. -"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. -"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. -"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). -"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. -"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." -"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. -2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. -3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. -4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: - (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and - (b) You must cause any modified files to carry prominent notices stating that You changed the files; and + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and - (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and - (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. - You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. -5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. -6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. -7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. -8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. -9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. -END OF TERMS AND CONDITIONS + END OF TERMS AND CONDITIONS -APPENDIX: How to apply the Apache License to your work. + APPENDIX: How to apply the Apache License to your work. -To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. -Copyright 2025 EonaCat + Copyright [yyyy] [name of copyright owner] -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at -http://www.apache.org/licenses/LICENSE-2.0 + http://www.apache.org/licenses/LICENSE-2.0 -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md index 3f487f1..24c2609 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,236 @@ -# EonaCat.Transfer +# EonaCat.Transfer -EonaCat.Transfer \ No newline at end of file +Yet another .NET networking library. + +A comprehensive, production-ready networking toolkit providing TCP, UDP, REST, encryption, compression, file transfer, monitoring, and reliability features. + +--- + +- Automatic reconnection handling +- Exponential backoff support +- Reconnection event notifications +- Full connection-state tracking + +--- + +- Client → Server and Server → Client transfers +- Chunked file sending with configurable chunk size +- File transfer progress events +- Automatic unique filename generation +- Customizable save directory +- Foundation for resume support + +--- + +- Supports all framing modes: + - Length-prefix + - Delimiter + - Fixed-length + - None +- AES decryption (optional) +- Robust error handling +- `ArrayPool`-based buffer management + +--- + +- GZip & Deflate compression +- Full async compression/decompression +- Automatic compression in UDP mode + +--- + +- Fully implemented UDP server + client +- Client discovery + tracking +- Broadcast support +- Automatic cleanup of inactive clients +- AES encryption +- Compression integration + +--- + +- Generic result types +- Authentication (Bearer tokens, custom headers) +- File upload/download with progress reporting +- Supports GET, POST, PUT, DELETE +- Progress events for all long-running operations + +--- + +- Reusable TCP connection pool +- Configurable maximum connections +- Automatic connection lifecycle management +- Built-in statistics tracking + +--- + +- `NetworkStatistics` class +- Throughput tracking +- Message counting +- Custom counters +- Formatted and human-readable output + +--- + +- **Message Acknowledgment:** Reliable delivery on demand +- **Message Builder:** Fluent API for message construction +- **Network Helpers:** + - IP discovery + - Port availability checking + - TCP ping + - Latency measurement +- **Metadata Support:** Custom per-connection data storage +- **Enhanced Events:** + - File transfer progress + - Reconnection events + - Error events + +--- + +- Proper disposal and cleanup of all resources +- Thread-safe operations +- Memory efficiency via `ArrayPool` +- Comprehensive error handling +- Timeout management +- NAT-safe keep-alive system + +--- + +# 📘 Usage Examples + +### Connection Pool +```csharp +var pool = new TcpConnectionPool("localhost", 8080, maxConnections: 50); +var client = await pool.AcquireAsync(); +await client.SendStringAsync("Hello!"); +pool.Release(client); +``` + +### Statistics +```csharp +var stats = new NetworkStatistics(); +Console.WriteLine(stats.ToString()); +``` + +## Compression and AES: +```csharp +var config = new NetworkConfig +{ + Compression = CompressionType.GZip, + AesEncryption = AesUtilities.CreateFromSharedSecret("MySecret"), + IsMessageAcknowledgmentEnabled = true +}; +``` + +### REST Client +```csharp +var rest = new RestClient(); +rest.DownloadProgress += (s, e) => + Console.WriteLine($"{e.BytesDownloaded}/{e.TotalBytes}"); + +await rest.DownloadFileAsync( + "https://EonaCat.com/file.zip", + "local.zip" +); +``` + +## UDP with Encryption +```csharp +var udpServer = new UdpServer(config); +await udpServer.StartAsync(9090); +udpServer.ClientDiscovered += (s, ep) => +Console.WriteLine($"New client: {ep}"); +``` + + +### Network Helpers +```csharp +var ip = NetworkHelper.GetLocalIPAddress(); +var port = NetworkHelper.FindAvailablePort(); +var latency = await NetworkHelper.GetLatencyAsync("google.com", 443); +Console.WriteLine($"IP: {ip}, Port: {port}, Latency: {latency}ms"); +``` + +# Example: + +```csharp +using EonaCat.Transfer; + +NetworkConfig networkConfig = new NetworkConfig() +{ + Protocol = ProtocolType.TCP, + Framing = FramingMode.Delimiter, + Delimiter = new byte[] { 0x0A }, // LF + EnableKeepAlive = true, + KeepAliveIntervalMs = 15000, + KeepAliveTimeoutMs = 5000, + AutoReconnect = true, + ReconnectDelayMs = 3000, +}; + +var server = new TcpServer(networkConfig); +server.ClientConnected += Server_ClientConnected; +server.ClientDisconnected += Server_ClientDisconnected; +server.MessageReceived += Server_MessageReceived; + +void Server_MessageReceived(object? sender, (ClientConnection Client, NetworkMessage Message) e) +{ + string message = System.Text.Encoding.UTF8.GetString(e.Message.Payload); + Console.WriteLine($"Received from {e.Client.Id}: {message}"); + // Echo the message back to the client + var responseMessage = new NetworkMessage(); + responseMessage.Payload = System.Text.Encoding.UTF8.GetBytes($"Echo: {message}"); + server.SendMessageAsync(e.Client, responseMessage); +} + +void Server_ClientDisconnected(object? sender, ClientConnection e) +{ + Console.WriteLine($"{e.Id} disconnected {e.RemoteEndPoint.ToString()}"); +} + +void Server_ClientConnected(object? sender, ClientConnection e) +{ + Console.WriteLine($"{e.Id} connected {e.RemoteEndPoint.ToString()}"); +} + +var client = new TcpClient(networkConfig); +client.Connected += Client_Connected; +client.MessageReceived += Client_MessageReceived; +client.Disconnected += Client_Disconnected; + +void Client_Disconnected(object? sender, EventArgs e) +{ + Console.WriteLine("Client disconnected from server"); +} + +void Client_MessageReceived(object? sender, NetworkMessage e) +{ + string message = System.Text.Encoding.UTF8.GetString(e.Payload); + Console.WriteLine($"Received from server: {message}"); +} + +void Client_Connected(object? sender, EventArgs e) +{ + Console.WriteLine("Client connected to server"); + // Send a test message to the server + var message = new NetworkMessage(); + message.Payload = System.Text.Encoding.UTF8.GetBytes("Hello, Server!"); + client.SendMessageAsync(message); +} + +await server.StartAsync(9000); +await client.ConnectAsync("127.0.0.1", 9000); + +// Generate traffic +for (int i = 0; i < 10000; i++) +{ + var message = new NetworkMessage(); + message.Payload = System.Text.Encoding.UTF8.GetBytes($"Message {i + 1} from client"); + await client.SendMessageAsync(message); + await Task.Delay(100); +} + + + +Console.WriteLine("Press ENTER to exit..."); +Console.ReadLine(); +``` \ No newline at end of file diff --git a/icon.png b/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..0595b89951c74a6c669463d4e2ba62274036fa30 GIT binary patch literal 89562 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 IMBDrS02~H<8~^|S literal 0 HcmV?d00001