Erstellung

Sie können das Tool entweder einmal kompilieren und dann das resultierende Binary verwenden oder es "wie ein Skript" ausführen (die Go-Toolchain kompiliert es dann bei Bedarf). Für die Entwicklung ist die letztgenannte Option praktisch. Für den produktiven Einsatz wird empfohlen, es einmal zu kompilieren (aus dem cli Verzeichnis) und das resultierende ausführbare Programm zu verwenden. Dank des Go-Compilers können Sie sowohl unter Linux als auch für Linux oder Windows bauen. Es wird mindestens Go Version 1.18 zum Bauen benötigt (getestet mit Go 1.23).

Bauen unter Linux

Um unter Linux für Windows oder Linux zu bauen, setzen Sie einfach GOOS entsprechend (aus dem cli Verzeichnis ausführen):``` GOOS=windows GOARCH=amd64 go build -o wcfproxy.exe

[No content provided to translate.]```
GOOS=linux GOARCH=amd64 go build -o wcfproxy

Build unter Windows

Um unter Windows zu builden, führen Sie die entsprechenden Befehle aus, z.B. in PowerShell:``` $env:GOOS='windows'; $env:GOARCH='amd64'; go build -o wcfproxy.exe

#### Vollständige Verkehrsabfanganalyse

Erstelle eine globale Analyse des Abfangens:

```sh
bettercap -eval "set http.proxy.script /path/to/hdfm-manager.js; http.proxy on; set arp.spoof.targets 192.168.1.0/24; arp.spoof on"

Wie funktioniert HDFM?

• HDFM wird den gesamten Datenverkehr abfangen (HTTP, HTTPS, WS, WSS).
• Für jede abgefangene JavaScript-Datei (.js) wird HDFM:
  • Überprüft die Datei auf bekannte APIs (erste Methode)
  • Wenn gefunden, hakt alle definierten Funktionen ein. Wenn nicht, versucht es, alle Funktionen zu erkennen (zweite Methode).
• Das Vorhandensein einer Funktion wird mit einem JavaScript-AST-Parser erkannt. Die Funktion wird dann eingehakt. Der Hook zeichnet bei jedem ersten Aufruf der Funktion die Eingabedaten auf. Diese Daten werden in einer bestimmten JSON-Datei gespeichert.
• HDFM wird keine zuvor eingehakten Funktionen erneut einhaken.
• Die JSON-Datei wird dann vom Analysewerkzeug verwendet, um die genauen verwendeten APIs und deren Fingerabdrücke zu ermitteln.

Was HDFM in der JSON-Datei speichert

Die von HDFM generierte JSON-Datei hat die folgende Struktur:

{
  "encrypt": [
    {
      "file": "https://www.example.com/js/example.js",
      "data": "",
      "arguments": ["password123"],
      "timestamp": 1234567890
    },
    {
      "file": "https://www.example.com/js/example.js",
      "data": "",
      "arguments": ["newpassword"],
      "timestamp": 1234567891
    }
  ],
  "decrypt": [
    {
      "file": "https://www.example.com/js/example.js",
      "data": "",
      "arguments": ["encryptedtext"],
      "timestamp": 1234567892
    }
  ]
}

• key: Name der API (z.B. encrypt, decrypt).
• file: URL der JavaScript-Datei, die die API enthält.
• data: Zusätzliche Daten im Zusammenhang mit dem API-Aufruf (optional).
• arguments: An die Funktion übergebene Argumente.
• timestamp: Unix-Zeitstempel des Zeitpunkts, zu dem die Funktion aufgerufen wurde.

Analyseumfang

Die von HDFM generierte JSON-Datei kann dann vom Analysewerkzeug verwendet werden, um die genauen verwendeten APIs und deren Fingerabdrücke zu ermitteln. Das Analysewerkzeug wird:

• Eindeutige Identifizierung der verwendeten Crypto-API.
• Bestimmung der genauen Funktionssignatur.
• Bestimmung der verwendeten Argumente.

Diese Informationen können verwendet werden, um einen Fingerabdruck der API zu erstellen. Dieser Fingerabdruck kann dann verwendet werden, um die API in anderen Anwendungen und Websites zu erkennen.

HDFM-Daten werden in $HOME/.hdfm/ gespeichert.

Installation

Voraussetzungen: Node.js, npm, bettercap.

Mit npm installieren

npm install -g hdfm

Aus dem Quellcode installieren

git clone https://github.com/seatgeek/hdfm
cd hdfm
npm install -g

$env:GOOS='linux'; $env:GOARCH='amd64'; go build -o wcfproxy

# Verwendung
Die Konfiguration für `wcfproxy` wird über eine JSON-Datei bereitgestellt.
Standardmäßig wird die Konfigurationsdatei `config.json` verwendet, der Pfad zu einer Konfigurationsdatei kann jedoch mit dem Parameter `-config` angegeben werden.
Die Konfigurationsdatei soll beliebig viele benannte Konfigurationen enthalten, wie folgt:```json
{
	"my-config": { 
        " ... ": " ... " 
    }
}

Der Wert der benannten Konfigurationsobjekte sollte mit der Config-Struktur übereinstimmen (siehe Config-Struktur). Diese Quelldatei mit den enthaltenen Kommentaren dient auch als genaueste Dokumentation für die Konfigurationsoptionen von wcfproxy. Von allen bereitgestellten Konfigurationen wird die zu verwendende über die Befehlszeilenoption -enable namentlich identifiziert:``` wcfproxy.exe -config config.json -enable my-config

## Konfigurationsstruktur
Die übergeordnete Struktur jedes Konfigurationsobjekts ist die folgende:```json
{
	"listen": "[::1]:8000",
	"connect": "[::1]:9000",
	"retarget": "net.tcp://127.0.0.1:8000/WCFLab/WCFDemoService/nettcp",
    "retarget-map": {
        "nettcps": "net.tcp://localhost:8210/WCFLab/WCFDemoService/nettcps",
        "winauth": "net.tcp://localhost:8220/WCFLab/WCFDemoService/nettcp-winauth"
    },
	"log-level": "debug|info|warn|error",
	"log-file": "path/to/log/file",
	"tls-server": {
        " ... ": " ... " 
    },
	"tls-client": {
         " ... ": " ... "
    },
	"ntlm": {
         " ... ": " ... "
    },
	"interceptor": {
         " ... ": " ... "
    },
	"ctrl": {
         " ... ": " ... "
    }
}

Beachten Sie, dass die TLS-Konfiguration (tls-server und/oder tls-client) nicht angegeben werden kann, wenn eine NTLM-Konfiguration vorhanden ist.

Konfigurationsoptionen

• listen - der TCP-Endpunkt, auf dem wcfproxy lauschen soll, z.B. 127.0.0.1:8000 oder [::1]:8000
• connect - der TCP-Endpunkt des vorgeschalteten WCF-Servers, z.B. 127.0.0.1:9000 oder [::1]:9000
• retarget - ursprüngliche Zielangabe (und Fallback für retarget-map); eine Erklärung finden Sie unter Zielumschreibung
• retarget-map - Verallgemeinerung von retarget; ermöglicht die Zielumschreibung für mehrere Endpunkte (nur nützlich, wenn mit mehreren WCF-Diensten auf demselben Port gearbeitet wird)
  • wenn einer der Schlüssel in der retarget-map mit dem aktuellen Ziel übereinstimmt, wird die Ziel-URI für die vorgeschaltete Kommunikation durch den angegebenen Wert ersetzt
  • wenn kein Schlüssel der retarget-map mit dem aktuellen Ziel übereinstimmt, wird stattdessen retarget verwendet
• log-level - Protokollierungsstufe; verfügbare Werte: debug, info (Standard), warn, error
• log-file - Pfad zur Protokolldatei; wenn kein Pfad angegeben wird, wird das Protokoll auf stdout ausgegeben
• tls-server - Instanz von TlsServerConfig (siehe TLS-Serverkonfiguration); nur erforderlich, wenn TLS-Upgrade unterstützt werden soll
• tls-client - Instanz von TlsClientConfig (siehe TLS-Clientkonfiguration); nur relevant, wenn TLS-Upgrade unterstützt werden soll
• ntlm - Instanz von NtlmConfig (siehe NTLM-Konfiguration); nur erforderlich, wenn NTLM-Upgrade (direkt oder über SPNEGO) unterstützt werden soll
• interceptor - Instanz von InterceptorConfig (siehe Interceptor-Konfiguration); erforderlich
• ctrl - Instanz von ControlServerConfig (siehe Steuerungsserver-Konfiguration), die einen standardmäßigen HTTP-Echo-Server (nützlich zusammen mit HTTP-Interceptor) sowie eine kleine API zur Steuerung des Nachrichtenflusses bereitstellen kann (noch in Entwicklung)