messenger-proxy 0.4.2__tar.gz → 0.4.4__tar.gz

{messenger_proxy-0.4.2/messenger_proxy.egg-info → messenger_proxy-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: messenger-proxy
-Version: 0.4.2
+Version: 0.4.4
 Summary: Messenger uses a client-server architecture to establish a SOCKS5 tunnel. Once the client connects, the server will create a local SOCKS5 tunnel that can be used to interact with the local network the client is connected to.
 Home-page: https://github.com/skylerknecht/messenger
 Author: Skyler Knecht
@@ -67,7 +67,7 @@ operator~# messenger-cli -e readme
 | |\/| |/ _ \/ __/ __|/ _ \ '_ \ / _` |/ _ \ '__|
 | |  | |  __/\__ \__ \  __/ | | | (_| |  __/ |   
 |_|  |_|\___||___/___/\___|_| |_|\__, |\___|_|   
-by Skyler Knecht and Kevin Clark |___/ v0.4.2
+by Skyler Knecht and Kevin Clark |___/ v0.4.4
 [*] The AES encryption key is readme
 [*] Waiting for messengers on http+ws://0.0.0.0:8080/
 (messenger)~#
@@ -108,8 +108,8 @@ operator~# ./client.py
 | Clients                                                            | Messenger Builder | Protocols         | Local/Remote Port Forwarding | SOCKS5 TCP | SOCKS5 UDP    |
 |--------------------------------------------------------------------|-------------------|-------------------|------------------------------|------------|---------------|
 | [Python](https://github.com/skylerknecht/messenger-client-python)  | Supported         | HTTP & WebSockets | Supported                    | Supported  | Not Supported |
-| [C#](https://github.com/skylerknecht/messenger-client-python)      | Not Supported     | HTTP & WebSockets | Supported                    | Supported  | Not Supported |
-| [Node JS](https://github.com/skylerknecht/messenger-client-nodejs) | Not Supported     |        WebSockets | Supported                    | Supported  | Not Supported |
+| [C#](https://github.com/skylerknecht/messenger-client-csharp)      | Supported         | HTTP & WebSockets | Supported                    | Supported  | Not Supported |
+| [Node JS](https://github.com/skylerknecht/messenger-client-nodejs) | Supported         | HTTP & WebSockets | Supported                    | Supported  | Not Supported |
 
 ## Credits 
 

{messenger_proxy-0.4.2 → messenger_proxy-0.4.4}/README.md

@@ -37,7 +37,7 @@ operator~# messenger-cli -e readme
 | |\/| |/ _ \/ __/ __|/ _ \ '_ \ / _` |/ _ \ '__|
 | |  | |  __/\__ \__ \  __/ | | | (_| |  __/ |   
 |_|  |_|\___||___/___/\___|_| |_|\__, |\___|_|   
-by Skyler Knecht and Kevin Clark |___/ v0.4.2
+by Skyler Knecht and Kevin Clark |___/ v0.4.4
 [*] The AES encryption key is readme
 [*] Waiting for messengers on http+ws://0.0.0.0:8080/
 (messenger)~#
@@ -78,8 +78,8 @@ operator~# ./client.py
 | Clients                                                            | Messenger Builder | Protocols         | Local/Remote Port Forwarding | SOCKS5 TCP | SOCKS5 UDP    |
 |--------------------------------------------------------------------|-------------------|-------------------|------------------------------|------------|---------------|
 | [Python](https://github.com/skylerknecht/messenger-client-python)  | Supported         | HTTP & WebSockets | Supported                    | Supported  | Not Supported |
-| [C#](https://github.com/skylerknecht/messenger-client-python)      | Not Supported     | HTTP & WebSockets | Supported                    | Supported  | Not Supported |
-| [Node JS](https://github.com/skylerknecht/messenger-client-nodejs) | Not Supported     |        WebSockets | Supported                    | Supported  | Not Supported |
+| [C#](https://github.com/skylerknecht/messenger-client-csharp)      | Supported         | HTTP & WebSockets | Supported                    | Supported  | Not Supported |
+| [Node JS](https://github.com/skylerknecht/messenger-client-nodejs) | Supported         | HTTP & WebSockets | Supported                    | Supported  | Not Supported |
 
 ## Credits 
 

messenger_proxy-0.4.4/builder/clients/csharp/README.md

@@ -0,0 +1,137 @@
+# C# Messenger Client
+
+## Overview
+
+The Client is a .NET Framework 4.7.2 Messenger Client targeting Windows environments. The framework is preinstalled on Windows 10/11 and most enterprise systems, requiring no additional runtime to deploy.
+
+## Primary Capabilities
+
+| Capability                 | Support Status                                         |
+|----------------------------|--------------------------------------------------------|
+| Transports                 | HTTP and WebSockets                                    |
+| Encryption                 | AES-256-CBC with random IV prefix.                     |
+| Reconnection procedure     | Defaults to five (5) attempts over sixty (60) seconds. |
+| SOCKS5 TCP                 | Supported                                              |
+| SOCKS5 UDP                 | Not Supported                                          |
+
+## Client-Specific Capabilities
+
+| Capability                    | Support Status                                                                                         |
+|-------------------------------|--------------------------------------------------------------------------------------------------------|
+| Compilation                   | Outputs a project directory requiring compilation with `dotnet build` (.NET SDK). |
+
+## Quick Start
+
+```
+operator~# python builder.py --encryption-key test
+[+] Wrote C# client to 'MessengerClient'
+
+operator~# cd MessengerClient/MessengerClient
+operator~# dotnet build -c Release
+operator~# bin\Release\net472\MessengerClient.exe
+```
+
+## Usage
+
+To build the client, execute `builder.py` or `messenger-builder` from the [Messenger Repository](https://github.com/skylerknecht/messenger).
+
+Both scripts accept the same options and will generate a C# Messenger Client project directory. If provided options, the builder scripts
+will hard-code the options into the source files. Once built, the operator can specify command-line arguments that will override
+the hardcoded options. The output is a .NET Framework 4.7.2 project that can be compiled with
+`dotnet build` on any platform. Those options and their definitions are shown below.
+
+## Client Options
+
+| Option                                        | Flag                      | Default Value          |
+|-----------------------------------------------|---------------------------|------------------------|
+| [Server URL](#server-url)                     | `--server-url`            | localhost:8080         |
+| [Encryption Key](#encryption-key)             | `--encryption-key`        | None                   |
+| [User Agent](#user-agent)                     | `--user-agent`            | [Specified Here](https://github.com/skylerknecht/messenger-client-csharp/blob/main/builder.py#L7) |
+| [Proxy](#proxy)                               | `--proxy`                 | None                   |
+| [Remote Port Forwards](#remote-port-forwards) | `--remote-port-forwards`  | None                   |
+| [Retry Duration](#retry-duration)             | `--retry-duration`        | One Minute             |
+| [Retry Attempts](#retry-attempts)             | `--retry-attempts`        | Five                   |
+| [Name](#name)                                 | `--name`                  | MessengerClient        |
+
+### Server URL
+
+Once the Messenger Server is running, the operator will be provided a server URL that can be set with `--server-url`.
+
+```
+builder.py --server-url http://localhost:8080
+```
+
+The client will attempt to establish a connection to the server based on the protocol specified in the server URL. For HTTP, leave the protocol as
+`http://`, for websockets use `ws://`. Given that the server is listening with SSL encryption, provide the SSL
+alternative to each protocol.
+
+#### Encryption Key
+
+Messenger Server will also provide an encryption key upon startup that can be hardcoded.
+
+```
+builder.py --encryption-key SuP3rs_crEtk3y
+```
+
+Since the server expects encryption, the default will likely cause issues; therefore, the client outputs an
+error.
+
+#### User Agent
+
+For HTTP-based protocols, the operator can control the user-agent header.
+
+```
+builder.py --user-agent "Test User Agent"
+```
+
+#### Proxy
+
+Enterprise environments typically have outbound proxies. Operators can provide a proxy using the HTTP-proxy schema.
+
+```
+builder.py --proxy http://user:password@localhost:8080
+```
+
+#### Remote Port Forwards
+
+Messenger expects clients to attempt to set up remote port forwards on the client side. The operator can specify multiple port forwards
+with the schema `LISTENING-HOST:LISTENING-PORT:DESTINATION-HOST:DESTINATION-PORT`.
+
+```
+builder.py --remote-port-forwards localhost:8080:remotehost:8080
+```
+
+This will forward all local connections on 8080 to a remote host on 8080. Given that the operator has not permitted the connection server-side,
+they will see the following message.
+
+```
+[!] Messenger `test` has no Remote Port Forwarder configured for remotehost:8080, denying forward!
+```
+
+#### Retry Duration
+
+Clients will disconnect for various reasons. Given that the client does not completely exit, it will attempt to reconnect. Operators can
+control how long the client will attempt to reconnect by specifying a retry duration. This value is expected to be in seconds. For example,
+if the retry duration is set to 120, then the client will attempt to reconnect for two minutes.
+
+```
+builder.py --retry-duration 100
+```
+
+To disable reconnection attempts, set the retry attempts option to 0.
+
+#### Retry Attempts
+
+In combination with the retry duration, retry attempts determine the minimum time the client waits between reconnection attempts.
+
+```
+builder.py --retry-attempts 100
+```
+
+#### Name
+
+The build process outputs a project directory, and operators can control its name.
+
+```
+builder.py --name CustomClient
+```

messenger_proxy-0.4.4/builder/clients/csharp/builder.py

@@ -0,0 +1,68 @@
+import argparse
+import shutil
+
+from pathlib import Path
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+
+USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36"
+
+def add_arguments(parser):
+    builder = parser.add_argument_group("Builder options")
+    builder.add_argument("--name", default="MessengerClient",
+                     help="Name of the output directory.")
+
+    cfg = parser.add_argument_group("Client configuration")
+    cfg.add_argument("--server-url", default="localhost:8080",
+                     help="Server URL the client should connect to.")
+    cfg.add_argument("-e", "--encryption-key", default="",
+                     help="AES encryption key to embed (optional).")
+    cfg.add_argument("--user-agent", default=USER_AGENT,
+                     help="Custom HTTP/WebSocket User-Agent string (optional).")
+    cfg.add_argument("--proxy", default="",
+                     help="Proxy to use (optional).")
+    cfg.add_argument("--remote-port-forwards", nargs="*", default=[],
+                     help="Space delimited remote port forwards LISTENING-IP:LISTENING-PORT:REMOTE-IP:REMOTE-PORT (optional).")
+
+    retry = parser.add_argument_group("Retry behavior")
+    retry.add_argument("--retry-duration", type=float, default=60.0,
+                       help="Total time to retry connecting.")
+    retry.add_argument("--retry-attempts", type=int, default=5,
+                       help="Number of retry attempts before giving up.")
+
+
+def build(args):
+    template_dir = Path(__file__).resolve().parent / "templates"
+    if not template_dir.is_dir():
+        raise RuntimeError(f"Template directory not found: {template_dir}")
+
+    env = Environment(
+        loader=FileSystemLoader(str(template_dir)),
+        autoescape=select_autoescape(enabled_extensions=("j2",)),
+        trim_blocks=True,
+        lstrip_blocks=True,
+    )
+
+    out_dir = Path(args.name)
+
+    for src in sorted(template_dir.rglob("*")):
+        if src.is_dir():
+            continue
+        rel = src.relative_to(template_dir)
+        dest = out_dir / rel
+        dest.parent.mkdir(parents=True, exist_ok=True)
+
+        if src.suffix == ".cs":
+            template = env.get_template(str(rel).replace("\\", "/"))
+            rendered = template.render(**vars(args))
+            dest.write_text(rendered, encoding="utf-8")
+        else:
+            shutil.copy2(src, dest)
+
+    print(f"[+] Wrote C# client to '{out_dir}'")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
+    add_arguments(parser)
+    parsed_args = parser.parse_args()
+    build(parsed_args)

{messenger_proxy-0.4.2/builder/clients/csharp → messenger_proxy-0.4.4/builder/clients/csharp/templates}/MessengerClient/Crypto.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Linq;
 using System.Text;
 using System.Security.Cryptography;
@@ -15,13 +15,14 @@ namespace MessengerClient
         {
             using (SHA256 sha256 = SHA256.Create())
             {
-                return sha256.ComputeHash(Encoding.ASCII.GetBytes(encryption_key));
+                return sha256.ComputeHash(Encoding.UTF8.GetBytes(encryption_key));
             }
         }
 
         public static byte[] Encrypt(byte[] key, ArraySegment<byte> plainText)
         {
-            byte[] plainTextBytes = plainText.Array;
+            byte[] plainTextBytes = new byte[plainText.Count];
+            Array.Copy(plainText.Array, plainText.Offset, plainTextBytes, 0, plainText.Count);
             return Encrypt(key, plainTextBytes);
         }
 
@@ -82,4 +83,4 @@ namespace MessengerClient
             return merged;
         }
     }
-}
+}

messenger_proxy-0.4.4/builder/clients/csharp/templates/MessengerClient/HTTPMessengerClient.cs

@@ -0,0 +1,174 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Http;
+using System.Threading.Tasks;
+
+namespace MessengerClient
+{
+    public class HTTPMessengerClient : MessengerClient
+    {
+        private readonly string _uri;
+        private readonly HttpClient _httpClient;
+        private readonly byte[] _encryptionKey;
+        private readonly double _retryDuration;
+        private readonly int _retryAttempts;
+        private readonly ConcurrentQueue<object> _downstreamMessages;
+        private string _messengerId;
+
+        public HTTPMessengerClient(string uri, byte[] encryptionKey, string userAgent, double retryDuration, int retryAttempts, IWebProxy proxy = null)
+        {
+            _uri = uri;
+            _encryptionKey = encryptionKey;
+            _retryDuration = retryDuration;
+            _retryAttempts = retryAttempts;
+
+            var handler = new HttpClientHandler();
+            if (proxy != null)
+            {
+                handler.Proxy = proxy;
+                handler.UseProxy = true;
+            }
+
+            _httpClient = new HttpClient(handler);
+            _httpClient.DefaultRequestHeaders.Add("User-Agent", userAgent);
+            _downstreamMessages = new ConcurrentQueue<object>();
+        }
+
+        public override async Task ConnectAsync()
+        {
+            int retryDelay = (int)((_retryDuration / _retryAttempts) * 1000);
+            int consecutiveFailures = 0;
+
+            while (consecutiveFailures < _retryAttempts)
+            {
+                try
+                {
+                    Console.WriteLine($"Connecting to HTTP server at {_uri}");
+
+                    var downstreamMessage = MessageBuilder.SerializeMessage(_encryptionKey, new CheckInMessage(_messengerId));
+                    HttpContent content = new ByteArrayContent(downstreamMessage);
+                    content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/octet-stream");
+
+                    var response = await _httpClient.PostAsync(_uri, content);
+                    response.EnsureSuccessStatusCode();
+
+                    if (string.IsNullOrEmpty(_messengerId))
+                    {
+                        byte[] responseBytes = await response.Content.ReadAsByteArrayAsync();
+                        var (_, parsedMessage) = MessageParser.DeserializeMessage(_encryptionKey, responseBytes);
+
+                        if (parsedMessage is CheckInMessage checkInMsg)
+                        {
+                            _messengerId = checkInMsg.MessengerId;
+                            Console.WriteLine($"[+] Connected with Messenger ID: {_messengerId}");
+                        }
+                        else
+                        {
+                            throw new InvalidOperationException(
+                                $"Expected CheckInMessage, got {parsedMessage.GetType().Name}"
+                            );
+                        }
+                    }
+
+                    consecutiveFailures = 0;
+                    await PollServerAsync();
+                }
+                catch (Exception ex)
+                {
+                    consecutiveFailures++;
+                    Console.WriteLine($"[!] Connection failed: {ex.Message}");
+                    if (consecutiveFailures < _retryAttempts)
+                    {
+                        Console.WriteLine("[*] Retrying connection...");
+                        await Task.Delay(retryDelay);
+                    }
+                }
+            }
+
+            Console.WriteLine($"[-] Reconnect failed after {_retryAttempts} attempts. Giving up.");
+        }
+
+
+        private async Task PollServerAsync()
+        {
+            while (true)
+            {
+                var downstreamMessages = new List<object>();
+
+                CheckInMessage checkInMessage = new CheckInMessage(_messengerId);
+                downstreamMessages.Add(checkInMessage);
+
+                while (_downstreamMessages.TryDequeue(out var message))
+                {
+                    downstreamMessages.Add(message);
+                }
+
+                HttpContent content = new ByteArrayContent(SerializeMessages(_encryptionKey, downstreamMessages));
+                content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/octet-stream");
+                var response = await _httpClient.PostAsync(_uri, content);
+
+                if (!response.IsSuccessStatusCode)
+                    throw new HttpRequestException($"Poll failed: HTTP {response.StatusCode}");
+
+                var responseData = await response.Content.ReadAsByteArrayAsync();
+                var messages = DeserializeMessages(_encryptionKey, responseData);
+
+                foreach (var msg in messages)
+                {
+                    _ = Task.Run(() => HandleMessageAsync(msg));
+                }
+
+                await Task.Delay(1000);
+            }
+        }
+
+        public override Task SendDownstreamMessageAsync(object message)
+        {
+            _downstreamMessages.Enqueue(message);
+            return Task.CompletedTask;
+        }
+
+        public override async Task HandleMessageAsync(object message)
+        {
+            switch (message)
+            {
+                case InitiateForwarderClientReq reqMessage:
+                    await HandleInitiateForwarderClientReqAsync(reqMessage);
+                    break;
+
+                case InitiateForwarderClientRep repMessage:
+                    if (!ForwarderClients.TryGetValue(repMessage.ForwarderClientId, out var repClient))
+                        break;
+                    if (repMessage.Reason != 0)
+                    {
+                        if (ForwarderClients.TryRemove(repMessage.ForwarderClientId, out var denied))
+                            denied.Close();
+                        break;
+                    }
+                    await StreamAsync(repMessage.ForwarderClientId);
+                    break;
+
+                case SendDataMessage sendDataMessage:
+                    if (sendDataMessage.Data.Length == 0)
+                    {
+                        if (ForwarderClients.TryRemove(sendDataMessage.ForwarderClientId, out var closedClient))
+                            closedClient.Close();
+                    }
+                    else if (ForwarderClients.TryGetValue(sendDataMessage.ForwarderClientId, out var client))
+                    {
+                        await client.GetStream().WriteAsync(sendDataMessage.Data, 0, sendDataMessage.Data.Length);
+                    }
+                    break;
+
+                case CheckInMessage checkInMessage:
+                    break;
+
+                default:
+                    Console.WriteLine("Unknown message type received");
+                    break;
+            }
+        }
+    }
+}

{messenger_proxy-0.4.2/builder/clients/csharp → messenger_proxy-0.4.4/builder/clients/csharp/templates}/MessengerClient/Message.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Linq;
 using System.Text;
 using System.Security.Cryptography;
@@ -71,29 +71,17 @@ public class SendDataMessage
 // ----------------------------------------------------------------------
 public static class MessageParser
 {
-    /// <summary>
-    /// Read the first 4 bytes of <paramref name="data"/> as a big-endian uint32.
-    /// Returns (uintValue, leftoverBytes).
-    /// </summary>
     public static (uint Value, byte[] Remainder) ReadUInt32(byte[] data)
     {
         if (data.Length < 4)
             throw new ArgumentException("Not enough bytes to read a 32-bit value.");
 
-        // Big-endian decode into a uint
         uint value = (uint)((data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3]);
         byte[] remainder = data.Skip(4).ToArray();
 
         return (value, remainder);
     }
 
-    /// <summary>
-    /// Reads a length-prefixed UTF-8 string:
-    ///  1) read a uint32 length
-    ///  2) read 'length' bytes
-    ///  3) decode UTF-8
-    /// Returns (stringValue, leftoverBytes).
-    /// </summary>
     public static (string Value, byte[] Remainder) ReadString(byte[] data)
     {
         var (length, remainder) = ReadUInt32(data);
@@ -106,25 +94,18 @@ public static class MessageParser
         return (s, leftover);
     }
 
-    /// <summary>
-    /// Parses the payload of a 0x04 'CheckIn' message (no decryption).
-    /// </summary>
     public static CheckInMessage ParseCheckIn(byte[] value)
     {
         var (messengerId, _) = ReadString(value);
         return new CheckInMessage(messengerId);
     }
 
-    /// <summary>
-    /// Parses the payload of a 0x01 'InitiateForwarderClientReq' message.
-    /// </summary>
     public static InitiateForwarderClientReq ParseInitiateForwarderClientReq(byte[] value)
     {
         var (forwarderClientId, remainder) = ReadString(value);
         var (ipAddress, remainder2) = ReadString(remainder);
         var (port, remainder3) = ReadUInt32(remainder2);
 
-        // cast uint -> int
         return new InitiateForwarderClientReq(
             forwarderClientId,
             ipAddress,
@@ -132,9 +113,6 @@ public static class MessageParser
         );
     }
 
-    /// <summary>
-    /// Parses the payload of a 0x02 'InitiateForwarderClientRep' message.
-    /// </summary>
     public static InitiateForwarderClientRep ParseInitiateForwarderClientRep(byte[] value)
     {
         var (forwarderClientId, remainder) = ReadString(value);
@@ -143,7 +121,6 @@ public static class MessageParser
         var (addressType, remainder4) = ReadUInt32(remainder3);
         var (reason, remainder5) = ReadUInt32(remainder4);
 
-        // cast all uint -> int
         return new InitiateForwarderClientRep(
             forwarderClientId,
             bindAddress,
@@ -153,9 +130,6 @@ public static class MessageParser
         );
     }
 
-    /// <summary>
-    /// Parses the payload of a 0x03 'SendDataMessage'.
-    /// </summary>
     public static SendDataMessage ParseSendData(byte[] value)
     {
         var (forwarderClientId, remainder) = ReadString(value);
@@ -168,33 +142,23 @@ public static class MessageParser
         );
     }
 
-    /// <summary>
-    /// High-level parse entrypoint:
-    ///   1) read the message_type (uint32)
-    ///   2) read the message_length (uint32)
-    ///   3) slice out the encrypted payload
-    ///   4) decrypt or parse plaintext
-    /// Returns (leftoverBytes, parsedMessage).
-    /// </summary>
     public static (byte[] leftover, object parsedMessage) DeserializeMessage(
         byte[] encryptionKey,
         byte[] rawData)
     {
-        // 1) Read the message type
         var (messageType, dataAfterType) = ReadUInt32(rawData);
-
-        // 2) Read the total message length
         var (messageLength, dataAfterLength) = ReadUInt32(dataAfterType);
 
-        // 3) Extract the (messageLength - 8) payload bytes
-        int payloadLen = (int)messageLength - 8;
+        if (messageLength < 8)
+            throw new ArgumentException("Invalid message: length field too small.");
+
+        int payloadLen = (int)(messageLength - 8);
         if (dataAfterLength.Length < payloadLen)
             throw new ArgumentException("Not enough bytes in data for the payload.");
 
         byte[] payload = dataAfterLength.Take(payloadLen).ToArray();
         byte[] leftover = dataAfterLength.Skip(payloadLen).ToArray();
 
-        // 4) Decrypt or parse plaintext, depending on message type
         object parsedMsg;
         switch (messageType)
         {
@@ -218,7 +182,6 @@ public static class MessageParser
                 }
             case 0x04:
                 {
-                    // According to the Python version, we do NOT decrypt for 0x04
                     parsedMsg = ParseCheckIn(payload);
                     break;
                 }
@@ -236,10 +199,6 @@ public static class MessageParser
 // ----------------------------------------------------------------------
 public static class MessageBuilder
 {
-    /// <summary>
-    /// Given a message object (one of our 4 types), build the fully formed
-    /// byte array (header + possibly encrypted payload).
-    /// </summary>
     public static byte[] SerializeMessage(byte[] encryptionKey, object msg)
     {
         byte[] payload;
@@ -286,7 +245,6 @@ public static class MessageBuilder
 
             case CheckInMessage cim:
                 messageType = 0x04;
-                // The Python code does not encrypt CheckInMessage
                 payload = BuildCheckInMessage(cim.MessengerId);
                 break;
 
@@ -297,26 +255,17 @@ public static class MessageBuilder
         return BuildMessage(messageType, payload);
     }
 
-    /// <summary>
-    /// Packs [message_type, total_length, payload] together in big-endian format.
-    /// </summary>
     public static byte[] BuildMessage(uint messageType, byte[] payload)
     {
-        // total_length = 8 (header) + payload length
         uint messageLength = (uint)(8 + payload.Length);
 
-        // Build the 8-byte header (all big-endian)
         byte[] header = new byte[8];
-        WriteUInt32(header, 0, messageType);    // message_type
-        WriteUInt32(header, 4, messageLength);  // total_length
+        WriteUInt32(header, 0, messageType);
+        WriteUInt32(header, 4, messageLength);
 
-        // Concatenate header + payload
         return Combine(header, payload);
     }
 
-    /// <summary>
-    /// Encodes a string with a 4-byte length prefix (big-endian), plus UTF-8 data.
-    /// </summary>
     public static byte[] BuildString(string value)
     {
         byte[] encoded = Encoding.UTF8.GetBytes(value);
@@ -339,7 +288,6 @@ public static class MessageBuilder
         var part1 = BuildString(forwarderClientId);
         var part2 = BuildString(ipAddress);
 
-        // We'll still write it as a uint on the wire
         byte[] part3 = new byte[4];
         WriteUInt32(part3, 0, (uint)port);
 
@@ -356,7 +304,6 @@ public static class MessageBuilder
         var part1 = BuildString(forwarderClientId);
         var part2 = BuildString(bindAddress);
 
-        // Next 3 fields => 3*4 bytes => 12 bytes
         byte[] part3 = new byte[12];
         WriteUInt32(part3, 0, (uint)bindPort);
         WriteUInt32(part3, 4, (uint)addressType);
@@ -376,9 +323,6 @@ public static class MessageBuilder
         return Combine(part1, part2);
     }
 
-    // ----------------------------------------------------------------------
-    // Helper: Write a uint32 to a byte array in big-endian
-    // ----------------------------------------------------------------------
     public static void WriteUInt32(byte[] buffer, int offset, uint value)
     {
         buffer[offset] = (byte)((value >> 24) & 0xFF);
@@ -387,9 +331,6 @@ public static class MessageBuilder
         buffer[offset + 3] = (byte)(value & 0xFF);
     }
 
-    // ----------------------------------------------------------------------
-    // Helper: Concatenate multiple byte arrays
-    // ----------------------------------------------------------------------
     public static byte[] Combine(params byte[][] arrays)
     {
         int totalLength = 0;