[HaBo]

-------------------------------------------------------------
Vorwort
-------------------------------------------------------------

Hallo Habo,

anlässlich der Startseitenplatzierung des Tutorials-Bereichs, schmeisse ich mich mal in die Bresche und schreibe ein Tutorial. Leider waren 20.000 Zeichen nicht genug, deswegen oft der Verweis auf die Anhänge.

Ich habe euch einen socks5 proxyserver in c# geschrieben und möchte zeigen, wie es mit den Mitteln des frameworks, unter Anwendung der bestehenden Wekzeuge zu machen ist.

angeprochene (eher angekratzte) Themen diesen Artikels sind
- allgemeines Vorgehen zur Protokollimplementierung
- Das socks Protokoll an sich
- Verständnis von tcp connections
- Netzwerkfunktionen und thread-pooling mit c#

Voraussetzungen:

Kenntnis der Basistypen von c#, oder einfach Interesse.

Ich habe mich für die socks Implementierung (anstatt eines anderen Protokolls) entschieden, da sie mit wenig Aufwand tolle Ergebnisse liefert, außerdem ist socks im Zeitalter der Internetanonymisierung ein interessantes Thema für einige hier, wie ich denke.

Dieses how2 ist unabhängig von Betriebssystem und Entwicklungsumgebung (feel free to choose):

-linux + mono runtime
-windows + .net framework 2.0 oder höher
-visual studio, sharpdevelop oder mono develop

-------------------------------------------------------------
Was ist socks ?
-------------------------------------------------------------

Socks wurde entwickelt, um verschiedene Netzwerkprotokolle auf Transportschicht in socks zu tunneln. Dabei wird der Netzwerkdatenverkehr über einen socksproxy gebündelt,ja zentralisiert.
Wir bechränken uns in diesem Beispiel auf das tcp Protokoll.

normaler Lebenszyklus einer tcp Verbindung:

- ein tcp client initiiert eine tcp Verbindung zu einem tcp server, definiert durch die Zieladresse und den Zielport des servers.

- der tcp server nimmt die Verbindung an und indentifiziert diese Verbindung über die client ip-Adresse und den verwendeten client port. Der client port wird i.d.R. dynamisch vor dem Verbindungsaufbau, auf clientseite vergeben

- Der Datenverkehr eines Applicationlayer Protokolls, z.B. http, wird nun über diese Verbindung abgewickelt.

tcp Verbindung mit socks

Der socks proxy nimmt eine "man-in-the-middle Position" wenn man so will, zwischen dem tcp client und dem tcp server, ein.

- der client, fortan socksClient genannt, baut eine tcp-Verbindung (s.o.) zu einem socks proxy auf.

- der socksClient übermittelt nun die Informationen an den socksproxy, die dieser für einen Verbindungsaufbau zum eigentlichen Verbindungsziel benötigt, zentral Zieladresse und Zielport

- der socksproxy baut nun eine tcp Verbindung mit einem tcp-server, unter Verwendung der gerade erhaltenen Daten auf, und ist somit nun auch ein client, fortan serverClient genannt.

- Es bestehen nun zwei Verbindungen aus Sicht des socks Proxies, die Verbindung mit dem socksClient und die Verbindung mit dem tcp server über den serverClient. Der Datenverkehr eines höheren Protokolles findet nun zwischen dem socksClient und dem socks proxy statt und wird weitergeleitet über den serverClient an den tcp Server und vice versa.

Für den tcp-Server ist nun nur der serverClient des proxies sichtbar, den eigentlichen Verbindungsinitiator kennt nur der socksproxy, die Potentiale zur Anonymisierung liegen auf der Hand und finden verbreitet Anwendung, siehe tor, widecap/freecap, etc.

Weiterhin kann socks zu einer übersichtlichen Firewallregeldefinition nützlich sein. Hinter einer Firewall reicht es dem socksclient, eine Verbindung auf einen außenstehenden socksproxy eingehen zu dürfen, um die eigentlichen Verbindungen zum Endpunkt, durch den socksproxy außerhalb der Firewallrestriktionszone durchführen zu lassen.

-------------------------------------------------------------
Restriktionen dieses Beispiels
-------------------------------------------------------------

Es würde zu weit führen alle socks5 Optionen zu implementieren, vielleicht hat ja jemand Lust das Bsp. zu erweitern.

- wir bahandeln nur tcp Verbindungen
- wir setzten nur ausgehende Verbindungen um, socks5 erlaubt auch die Weiterleitung eingehender Verbindungen
- wir sind nicht kompatibel zu socks4
- wir unterstützen nur Verbindungen ohne Authentifizierung
- wir unterstützen keine ipv6 Anforderungen

-------------------------------------------------------------
Interpretieren der rfc Protokolldefinition
-------------------------------------------------------------

Um einen socksproxy zu programmieren benötigen wir zunächst die Informationen, wie wir die header zur Verbindungsweiterleitung interpretieren müssen.
Eine vollständige Beschreibung dessen findet sich immer im rfc, hier unter z.B.

Bitte vollständig lesen und auswändiglernen...

http://www.faqs.org/rfcs/rfc1928.html

..oder

Zusammenfassung (eigene Nummerierung):


Zitat rfc: The SOCKS service is conventionally located on TCP port 1080

rfc0: Der proxy lauscht auf port 1080

rfc1 - Authentifizierungsselektion

Der socks client sendet eine Struktur:

rfc1.1: Version (1 byte) - immer gleich 5
rfc1.2: Numbermethods (1 byte) - Die Anzahl der durch den socksClient unterstützten Authentifizierungsmethoden
rfc1.3: Methoden (jeweils 1 byte)

der server Antwortet:

rfc1.4: Version (1 byte)
rfc1.5: Selektierte Methode (1 byte) - immer 0, keine Auth. (siehe Restriktionen dieses Beispiels)

rfc2 - request

Der socks client sendet eine Struktur:

rfc2.1: Version (1 byte)
rfc2.2: Command (1 byte) - immer 1 (1 steht für connect, 2 wäre bind und würde eingehende Verbindungen an den socksClient leiten)
rfc2.3: reserved (1 byte)
rfc2.4: Addresstype (1 byte) - (1=ipv4address, 3=domainname, 4=ipv6address) wir unterstützen 1,2
rfc2.5: Destination-Address (variabel) - Bei ipv4-Adressen 4 bytes, bei domänennamen enthält das erste byte des destinationaddress Feldes die Länge des folgenden Domänennamens
rfc2.6: destination port (2 byte) - unsigned integer


rfc3 - reply

Der socksproxy sendet dem socksClient nach erfolgreichem Verbindungsaufbau eine Struktur:

rfc3.1: Version (1 byte)
rfc3.2: Replytype (1 byte) - wir unterstützen 1=success und 2=failure
rfc3.3: reserved (1 byte)
rfc3.4: addresstype (1 byte) - siehe rfc2.4
rfc3.5: server bound address (variable) - siehe rfc2.5
rfc3.6: server vound port (2 byte) - siehe rfc.2.6

-------------------------------------------------------------
Multithreading tcp server in c#
-------------------------------------------------------------

Unser socks5proxy soll beliebig viele Verbindungen von socks Clients entgegennehmen können. Der socks connect sowie das folgende tcp forwarding soll für alle Verbindungen parallel abgearbeitet werden, also multithreading.

Was wir dafür benötigen sind typen aus den namespaces System.Net.Sockets sowie System.Threading. Die namespaces sollten dem Programm als using Direktive im Kopf von program.cs (bzw. der Klassendatei, in der der Einstiegspunkt void main in das Programm deklariert ist ) hinzugefügt werden.

 using System.Net.Sockets;
 using System.Threading;

             TcpListener server = new TcpListener(1080);
             server.Start();
             while (true)
             {
                 TcpClient client = server.AcceptTcpClient();
                 
                 Console.WriteLine("accepted new socks client at " + 
 client.Client.RemoteEndPoint.ToString());
             }

 
/* ***********************************************************************************************
 * experimental sock5proxy implementation 
 * 2009 by AngelDelivery for www.hackerboard.de
 * 
 * license: feel free to use this code free of charge,
 * but do not publish this article without any reference to www.hackerboard.de and the author.
 * warranty: this code comes without any warranty. It's your own risc.
 */

 using System;
 using System.Net;
 using System.Net.Sockets;
 using System.IO;
 
 namespace Socks5Proxy
 {
     
     public class Socks5Session
     {
         TcpClient socksClient;
         
 
         public Socks5Session(TcpClient client)
         {
             socksClient = client;
         }
 
 
         public void Work()
         {
     
     }
 
       }
 }

 
 TcpListener server = new TcpListener(1080);
 server.Start();
 while (true)
  {
     TcpClient client = server.AcceptTcpClient();
     Socks5Session S = new Socks5Session(client);
     Thread T = new Thread(new ThreadStart(S.Work));
     T.Start();
     Console.WriteLine("accepted new socks client at " +  client.Client.RemoteEndPoint.ToString());
             }

 
 public class Socks5Session
     {
         TcpClient socksClient;
         TcpClient serverClient;
         byte SOCKS_VERSION = 5;
         byte SOCKS_NOAUTH = 0;
         byte SOCKS_REPLYSUCCESS = 0;
         byte SOCKS_IPV4ADDR = 1;
         byte SOCKS_DNSNAME =3;
 
         public Socks5Session(TcpClient client)
         {
             socksClient = client;
         }
 
 
         public void Work()
         {
             Console.WriteLine(
                 "new client connected: " +
                 socksClient.Client.RemoteEndPoint.ToString());
             NetworkStream socksClientStream = socksClient.GetStream();
         ..........

 
 /* *****************************************************
              * supported methods part
              * ***************************************************** */
 
          code im Anhang

 
 /* *****************************************************
              * method selection part
              * ***************************************************** */
 
            code im Anhang

 
 
     /* *****************************************************
          * request part
          * ***************************************************** */
 
        code im Anhang

 
  *****************************************************
                * server client connection part
                * ***************************************************** */
 
 code im Anhang

 
 /* *****************************************************
                 * reply part
                 * ***************************************************** */
 
 code im Anhang

tcp redirection

code im Anhang