messenger-proxy 0.4.1__tar.gz

messenger_proxy-0.4.1/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Skyler Knecht
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

messenger_proxy-0.4.1/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: messenger-proxy
+Version: 0.4.1
+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
+Author-email: skyler.knecht@outlook.com
+License: BSD-3-Clause
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp
+Requires-Dist: prompt-toolkit
+Requires-Dist: pycryptodome
+Requires-Dist: jinja2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Messenger
+
+Messenger is a tunneling toolkit that leverages a client-server infrastructure
+to establish SOCKS5 proxies, local port forwards, and remote port forwards. While 
+the server is primarily written in Python, there are several clients written in
+varying languages. Their details and major feature support can be 
+[found below](https://github.com/skylerknecht/messenger?tab=readme-ov-file#client-support-matrix). 
+
+## Quick Start
+
+To set up Messenger and establish a client connection, execute the following commands. 
+
+### Installation
+Messenger has a setup.py file that can be run directly or installed with pipx. 
+```
+operator~# git clone https://github.com/skylerknecht/messenger.git --recurse-submodules
+operator~# cd messenger
+operator~/messenger# pipx install .
+```
+
+### Launch
+Launching Messenger will output several details that will be leveraged in later commands, including
+an AES encryption key and server URL. 
+```
+operator~# messenger-cli
+(messenger)~#         
+ __  __                                    
+|  \/  | ___  ___ ___  ___ _ __   __ _  ___ _ __ 
+| |\/| |/ _ \/ __/ __|/ _ \ '_ \ / _` |/ _ \ '__|
+| |  | |  __/\__ \__ \  __/ | | | (_| |  __/ |   
+|_|  |_|\___||___/___/\___|_| |_|\__, |\___|_|   
+by Skyler Knecht and Kevin Clark |___/ v0.4.1
+[*] The AES encryption key is XhoInhAKWX
+[*] Waiting for messengers on http+ws://0.0.0.0:8080/
+(messenger)~#
+```
+
+### Build
+Messenger comes with a builder utility to create clients. Leverage the help menu or the 
+[client support matrix](https://github.com/skylerknecht/messenger?tab=readme-ov-file#client-support-matrix)
+to see builder-supported clients.
+```
+operator~# messenger-builder python --encryption-key ZDXgoqyVXqDpJyBMJt
+Wrote Python client to 'client.py'
+```
+
+### Connect
+Once a client is built, execute it to connect to the server. Options can typically be hardcoded or overridden 
+with command line arguments. 
+```
+operator~# ./client.py
+[+] Connected to http://localhost:8080/socketio/?EIO=4&transport=websocket
+```
+
+## Detailed Guides
+
+### Operators
+- [Setup a SOCKS Proxy or Local Port Forward](docs/local-port-forwards-and-socks.md)
+- [Setup a Remote Port Forward](docs/remote-port-forwards.md)
+- [Chain Messenger Clients](docs/chaining-messengers.md)
+- [Perform NTLMRelay2Self with Messenger](docs/ntlmrelay2self-with-messenger.md)
+
+
+### Developers 
+- [Communication Overview](docs/communication.md)
+
+
+## Client Support Matrix
+
+| 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 |
+
+## Credits 
+
+- Skyler Knecht (@SkylerKnecht)
+- Kevin Clark (@GuhnooPlusLinux)

messenger_proxy-0.4.1/README.md

@@ -0,0 +1,79 @@
+# Messenger
+
+Messenger is a tunneling toolkit that leverages a client-server infrastructure
+to establish SOCKS5 proxies, local port forwards, and remote port forwards. While 
+the server is primarily written in Python, there are several clients written in
+varying languages. Their details and major feature support can be 
+[found below](https://github.com/skylerknecht/messenger?tab=readme-ov-file#client-support-matrix). 
+
+## Quick Start
+
+To set up Messenger and establish a client connection, execute the following commands. 
+
+### Installation
+Messenger has a setup.py file that can be run directly or installed with pipx. 
+```
+operator~# git clone https://github.com/skylerknecht/messenger.git --recurse-submodules
+operator~# cd messenger
+operator~/messenger# pipx install .
+```
+
+### Launch
+Launching Messenger will output several details that will be leveraged in later commands, including
+an AES encryption key and server URL. 
+```
+operator~# messenger-cli
+(messenger)~#         
+ __  __                                    
+|  \/  | ___  ___ ___  ___ _ __   __ _  ___ _ __ 
+| |\/| |/ _ \/ __/ __|/ _ \ '_ \ / _` |/ _ \ '__|
+| |  | |  __/\__ \__ \  __/ | | | (_| |  __/ |   
+|_|  |_|\___||___/___/\___|_| |_|\__, |\___|_|   
+by Skyler Knecht and Kevin Clark |___/ v0.4.1
+[*] The AES encryption key is XhoInhAKWX
+[*] Waiting for messengers on http+ws://0.0.0.0:8080/
+(messenger)~#
+```
+
+### Build
+Messenger comes with a builder utility to create clients. Leverage the help menu or the 
+[client support matrix](https://github.com/skylerknecht/messenger?tab=readme-ov-file#client-support-matrix)
+to see builder-supported clients.
+```
+operator~# messenger-builder python --encryption-key ZDXgoqyVXqDpJyBMJt
+Wrote Python client to 'client.py'
+```
+
+### Connect
+Once a client is built, execute it to connect to the server. Options can typically be hardcoded or overridden 
+with command line arguments. 
+```
+operator~# ./client.py
+[+] Connected to http://localhost:8080/socketio/?EIO=4&transport=websocket
+```
+
+## Detailed Guides
+
+### Operators
+- [Setup a SOCKS Proxy or Local Port Forward](docs/local-port-forwards-and-socks.md)
+- [Setup a Remote Port Forward](docs/remote-port-forwards.md)
+- [Chain Messenger Clients](docs/chaining-messengers.md)
+- [Perform NTLMRelay2Self with Messenger](docs/ntlmrelay2self-with-messenger.md)
+
+
+### Developers 
+- [Communication Overview](docs/communication.md)
+
+
+## Client Support Matrix
+
+| 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 |
+
+## Credits 
+
+- Skyler Knecht (@SkylerKnecht)
+- Kevin Clark (@GuhnooPlusLinux)

messenger_proxy-0.4.1/builder/clients/csharp/MessengerClient/App.config

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
+    </startup>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="System.Runtime.CompilerServices.Unsafe" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+</configuration>

messenger_proxy-0.4.1/builder/clients/csharp/MessengerClient/Crypto.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Linq;
+using System.Text;
+using System.Security.Cryptography;
+
+
+namespace MessengerClient
+{
+    internal class Crypto
+    {
+        private const int AesBlockByteSize = 128 / 8;
+        private static readonly RandomNumberGenerator Random = RandomNumberGenerator.Create();
+
+        public static byte[] Hash(string encryption_key)
+        {
+            using (SHA256 sha256 = SHA256.Create())
+            {
+                return sha256.ComputeHash(Encoding.ASCII.GetBytes(encryption_key));
+            }
+        }
+
+        public static byte[] Encrypt(byte[] key, ArraySegment<byte> plainText)
+        {
+            byte[] plainTextBytes = plainText.Array;
+            return Encrypt(key, plainTextBytes);
+        }
+
+        public static byte[] Encrypt(byte[] key, string plainText)
+        {
+            byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
+            return Encrypt(key, plainTextBytes);
+        }
+
+        public static byte[] Encrypt(byte[] key, byte[] plainText)
+        {
+            using (var aes = Aes.Create())
+            {
+
+                byte[] iv = GenerateRandomBytes(AesBlockByteSize);
+
+                using (var encryptor = aes.CreateEncryptor(key, iv))
+                {
+                    var cipherText = encryptor
+                        .TransformFinalBlock(plainText, 0, plainText.Length);
+
+                    var result = MergeArrays(iv, cipherText);
+                    return result;
+                }
+            }
+        }
+
+        public static byte[] Decrypt(byte[] key, byte[] encryptedData)
+        {
+            using (var aes = Aes.Create())
+            {
+                var iv = encryptedData.Take(AesBlockByteSize).ToArray();
+                var cipherText = encryptedData.Skip(AesBlockByteSize).ToArray();
+
+                using (var encryptor = aes.CreateDecryptor(key, iv))
+                {
+                    return encryptor.TransformFinalBlock(cipherText, 0, cipherText.Length);
+                }
+            }
+        }
+
+        private static byte[] GenerateRandomBytes(int numberOfBytes)
+        {
+            var randomBytes = new byte[numberOfBytes];
+            Random.GetBytes(randomBytes);
+            return randomBytes;
+        }
+
+        private static byte[] MergeArrays(params byte[][] arrays)
+        {
+            var merged = new byte[arrays.Sum(a => a.Length)];
+            var mergeIndex = 0;
+            for (int i = 0; i < arrays.GetLength(0); i++)
+            {
+                arrays[i].CopyTo(merged, mergeIndex);
+                mergeIndex += arrays[i].Length;
+            }
+            return merged;
+        }
+    }
+}

messenger_proxy-0.4.1/builder/clients/csharp/MessengerClient/HTTPMessengerClient.cs

@@ -0,0 +1,173 @@
+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 ConcurrentQueue<object> _downstreamMessages;
+        private string _messengerId;
+
+        public HTTPMessengerClient(string uri, byte[] encryptionKey, IWebProxy proxy = null)
+        {
+            _uri = uri;
+            _encryptionKey = encryptionKey;
+
+            var handler = new HttpClientHandler();
+            if (proxy != null)
+            {
+                handler.Proxy = proxy;
+                handler.UseProxy = true;
+            }
+
+            _httpClient = new HttpClient(handler);
+            _downstreamMessages = new ConcurrentQueue<object>();
+        }
+
+        public override async Task ConnectAsync()
+        {
+            int retryDelaySeconds = 15;
+            int maxTotalWaitSeconds = 1800;
+            int elapsedSeconds = 0;
+
+            while (elapsedSeconds < maxTotalWaitSeconds)
+            {
+                try
+                {
+                    Console.WriteLine($"Connecting to HTTP server at {_uri}");
+
+                    var downstreamMessage = MessageBuilder.SerializeMessage(_encryptionKey, new CheckInMessage(""));
+                    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();
+
+                    byte[] responseBytes = await response.Content.ReadAsByteArrayAsync();
+
+                    var (_, parsedMessage) = MessageParser.DeserializeMessage(_encryptionKey, responseBytes);
+
+                    if (parsedMessage is CheckInMessage checkInMsg)
+                    {
+                        _messengerId = checkInMsg.MessengerId;
+                        Console.WriteLine($"[+] Connected to server with Messenger ID: {_messengerId}");
+
+                        await PollServerAsync(); // Enter main loop
+                        return; // Exit reconnect loop on success
+                    }
+                    else
+                    {
+                        throw new InvalidOperationException(
+                            $"Expected a CheckInMessage, but got {parsedMessage.GetType().Name}"
+                        );
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"[!] Connection attempt failed: {ex.Message}");
+                    elapsedSeconds += retryDelaySeconds;
+                    if (elapsedSeconds >= maxTotalWaitSeconds)
+                    {
+                        Console.WriteLine("[-] Reconnect timeout after 30 minutes. Giving up.");
+                        break;
+                    }
+
+                    Console.WriteLine("[*] Retrying connection in 15 seconds...");
+                    await Task.Delay(retryDelaySeconds * 1000);
+                }
+            }
+        }
+
+
+        private async Task PollServerAsync()
+        {
+            while (true)
+            {
+                try
+                {
+                    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)
+                    {
+                        Console.WriteLine($"Failed to poll server. HTTP {response.StatusCode}");
+                        break;
+                    }
+
+                    var responseData = await response.Content.ReadAsByteArrayAsync();
+                    var messages = DeserializeMessages(_encryptionKey, responseData);
+
+                    foreach (var message in messages)
+                    {
+                        _ = Task.Run(() => HandleMessageAsync(message));
+                    }
+
+                    await Task.Delay(1000);
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"Error polling server: {ex.Message}");
+                    break;
+                }
+            }
+        }
+
+        public override async Task SendDownstreamMessageAsync(object message)
+        {
+            try
+            {
+                _downstreamMessages.Enqueue(message);
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error enqueuing downstream message: {ex.Message}");
+            }
+        }
+
+        public override async Task HandleMessageAsync(object message)
+        {
+            switch (message)
+            {
+                case InitiateForwarderClientReq reqMessage:
+                    await HandleInitiateForwarderClientReqAsync(reqMessage);
+                    break;
+
+                case InitiateForwarderClientRep repMessage:
+                    await StreamAsync(repMessage.ForwarderClientId);
+                    break;
+
+                case SendDataMessage sendDataMessage:
+                    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;
+            }
+        }
+    }
+}