2. Starten Sie `frps` auf Server A:

`./frps -c ./frps.toml`

3. Ändern Sie `frpc.toml` auf Server B und setzen Sie das Feld `serverAddr` auf die öffentliche IP-Adresse Ihres frps-Servers:  ```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000

[[proxies]]
name = "ssh"
type = "tcp"
localIP = "127.0.0.1"
localPort = 22
remotePort = 6000

2. Stellen Sie frpc auf der internen Maschine A mit der folgenden Konfiguration bereit:  ```toml
serverAddr = "x.x.x.x"
serverPort = 7000

[[proxies]]
name = "ssh1"
type = "tcpmux"
multiplexer = "httpconnect"
customDomains = ["machine-a.example.com"]
localIP = "127.0.0.1"
localPort = 22

4. Um auf interne Maschine A über SSH ProxyCommand zuzugreifen, unter der Annahme, dass der Benutzername "test" lautet:

`ssh -o 'proxycommand socat - PROXY:x.x.x.x:%h:%p,proxyport=5002' [email protected]`

5. Um auf interne Maschine B zuzugreifen, ist der einzige Unterschied der Domainname, unter der Annahme, dass der Benutzername "test" lautet:

`ssh -o 'proxycommand socat - PROXY:x.x.x.x:%h:%p,proxyport=5002' [email protected]`

### Zugriff auf interne Webdienste mit benutzerdefinierten Domains im LAN

Manchmal müssen wir einen lokalen Webdienst hinter einem NAT-Netzwerk für andere zu Testzwecken mit unserem eigenen Domainnamen bereitstellen.

Leider können wir einen Domainnamen nicht auf eine lokale IP auflösen. Wir können jedoch frp verwenden, um einen HTTP(S)-Dienst bereitzustellen.

1. Ändern Sie `frps.toml` und setzen Sie den HTTP-Port für vhost auf 8080:  ```toml
# frps.toml
bindPort = 7000
vhostHTTPPort = 8080

4. Starte `frpc`:

`./frpc -c ./frpc.toml`

5. Ordne den A-Record von `www.example.com` entweder der öffentlichen IP des entfernten frps-Servers oder einem CNAME-Record zu, der auf deine ursprüngliche Domain verweist.

6. Besuche deinen lokalen Webdienst über die URL `http://www.example.com:8080`.

### DNS-Abfrageanfragen weiterleiten

1. Ändere `frps.toml`:  ```toml
# frps.toml
bindPort = 7000

4. Starten Sie frpc:

`./frpc -c ./frpc.toml`

5. Testen Sie die DNS-Auflösung mit dem Befehl `dig`:

`dig @x.x.x.x -p 6000 www.google.com`

### Unix-Domain-Socket weiterleiten

Einen Unix-Domain-Socket (z. B. den Docker-Daemon-Socket) als TCP verfügbar machen.

Konfigurieren Sie `frps` wie oben.

1. Starten Sie `frpc` mit der folgenden Konfiguration:  ```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000

[[proxies]]
name = "unix_domain_socket"
type = "tcp"
remotePort = 6000
[proxies.plugin]
type = "unix_domain_socket"
unixPath = "/var/run/docker.sock"

2. Besuchen Sie `http://x.x.x.x:6000/static/` in Ihrem Browser und geben Sie den korrekten Benutzernamen und das Passwort an, um Dateien in `/tmp/files` auf der `frpc`-Maschine anzuzeigen.

### HTTPS für einen lokalen HTTP(S)-Dienst aktivieren

Sie können das Plugin durch `https2https` ersetzen und `localAddr` auf einen HTTPS-Endpunkt verweisen.

1. Starten Sie `frpc` mit der folgenden Konfiguration:  ```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000

[[proxies]]
name = "test_https2http"
type = "https"
customDomains = ["test.example.com"]

[proxies.plugin]
type = "https2http"
localAddr = "127.0.0.1:80"
crtPath = "./server.crt"
keyPath = "./server.key"
hostHeaderRewrite = "127.0.0.1"
requestHeaders.set.x-from-where = "frp"

2. Starten Sie einen weiteren `frpc` (typischerweise auf einer anderen Maschine C) mit der folgenden Konfiguration, um auf den SSH-Dienst mit einem Sicherheitsschlüssel (`secretKey`-Feld) zuzugreifen:  ```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000

[[visitors]]
name = "secret_ssh_visitor"
type = "stcp"
serverName = "secret_ssh"
secretKey = "abcdefg"
bindAddr = "127.0.0.1"
bindPort = 6000

2. Starten Sie einen weiteren `frpc` (in der Regel auf einer anderen Maschine C) mit der Konfiguration, um sich per P2P-Modus mit SSH zu verbinden:  ```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000
# set up a new stun server if the default one is not available.
# natHoleStunServer = "xxx"

[[visitors]]
name = "p2p_ssh_visitor"
type = "xtcp"
serverName = "p2p_ssh"
secretKey = "abcdefg"
bindAddr = "127.0.0.1"
bindPort = 6000
# when automatic tunnel persistence is required, set it to true
keepTunnelOpen = false

Mit der obigen Konfiguration können Variablen wie folgt an das Programm `frpc` übergeben werden:```
export FRP_SERVER_ADDR=x.x.x.x
export FRP_SSH_REMOTE_PORT=6000
./frpc -c ./frpc.toml

git clone https://github.com/example/repo.git
cd repo
pip install -r requirements.txt

python main.py --target example.com --output results.txt

target: example.com
threads: 10
timeout: 30
output: results.txt

# ./confd/test.toml

[[proxies]]
name = "ssh"
type = "tcp"
localIP = "127.0.0.1"
localPort = 22
remotePort = 6000
```
### Server-Dashboard

Überprüfe den Status von frp und die Statistikinformationen der Proxys über das Dashboard.

Konfiguriere einen Port für das Dashboard, um diese Funktion zu aktivieren:```toml
# The default value is 127.0.0.1. Change it to 0.0.0.0 when you want to access it from a public network.
webServer.addr = "0.0.0.0"
webServer.port = 7500
# dashboard's username and password are both optional
webServer.user = "admin"
webServer.password = "admin"
```
Dann besuche `http://[serverAddr]:7500`, um das Dashboard zu sehen, wobei Benutzername und Passwort beide `admin` sind.

Zusätzlich kannst du den HTTPS-Port nutzen, indem du das Wildcard- oder normale SSL-Zertifikat deiner Domains verwendest:```toml
webServer.port = 7500
# dashboard's username and password are both optional
webServer.user = "admin"
webServer.password = "admin"
webServer.tls.certFile = "server.crt"
webServer.tls.keyFile = "server.key"
```
Dann besuche `https://[serverAddr]:7500`, um das Dashboard über eine sichere HTTPS-Verbindung zu sehen, wobei Benutzername und Passwort beide `admin` sind.

![dashboard](https://assets.kitploit.com/production/public/readmes/3770/0f836cc321c1fd65416940b5e12ca576cccc68f12d61ff045a09582ccfff74c1.png)

### Client-Admin-Oberfläche

Die Client-Admin-Oberfläche hilft dir, die Konfiguration und Proxys von frpc zu überprüfen und zu verwalten.

Konfiguriere eine Adresse für die Admin-Oberfläche, um diese Funktion zu aktivieren:```toml
webServer.addr = "127.0.0.1"
webServer.port = 7400
webServer.user = "admin"
webServer.password = "admin"
```
Dann besuche `http://127.0.0.1:7400`, um die Admin-Oberfläche zu sehen, wobei Benutzername und Passwort beide `admin` sind.

#### Dynamische Proxy-Verwaltung (Store)

Du kannst Proxys und Besucher zur Laufzeit dynamisch erstellen, aktualisieren und löschen – über die Web-Oberfläche oder die API, ohne frpc neu zu starten.

Um diese Funktion zu aktivieren, konfiguriere `store.path`, um eine Datei für das Speichern der Konfigurationen festzulegen:```toml
[store]
path = "./db.json"
```
Über den Store verwaltete Proxys und Besucher werden auf der Festplatte gespeichert und beim Neustart von frpc automatisch wiederhergestellt. Sie funktionieren neben den in der Konfigurationsdatei definierten Proxys – Store-Einträge haben Vorrang, wenn Namen kollidieren.

### Monitor

Wenn der Webserver aktiviert ist, speichert frps Monitordaten für 7 Tage im Cache. Sie werden nach einem Prozessneustart gelöscht.

Prometheus wird ebenfalls unterstützt.

#### Prometheus

Aktivieren Sie zuerst das Dashboard und konfigurieren Sie dann `enablePrometheus = true` in `frps.toml`.

`http://{dashboard_addr}/metrics` stellt Prometheus-Monitordaten bereit.

### Authentifizierung des Clients

Es gibt 2 Authentifizierungsmethoden, um frpc mit frps zu authentifizieren.

Sie können entscheiden, welche verwendet werden soll, indem Sie `auth.method` in `frpc.toml` und `frps.toml` konfigurieren; die Standardmethode ist token.

Die Konfiguration von `auth.additionalScopes = ["HeartBeats"]` verwendet die konfigurierte Authentifizierungsmethode, um bei jedem Heartbeat zwischen frpc und frps eine Authentifizierung hinzuzufügen und zu validieren.

Die Konfiguration von `auth.additionalScopes = ["NewWorkConns"]` macht dasselbe für jede neue Arbeitsverbindung zwischen frpc und frps.

#### Token-Authentifizierung

Wenn `auth.method = "token"` in `frpc.toml` und `frps.toml` angegeben wird, wird die tokenbasierte Authentifizierung verwendet.

Stellen Sie sicher, dass in `frps.toml` und `frpc.toml` dasselbe `auth.token` angegeben ist, damit frpc die frps-Validierung besteht.

##### Token-Quelle

frp unterstützt das Lesen von Authentifizierungstokens aus externen Quellen mithilfe der Konfiguration `tokenSource`. Derzeit wird eine dateibasierte Token-Quelle unterstützt.

**Dateibasierte Token-Quelle:**```toml
# frpc.toml
auth.method = "token"
auth.tokenSource.type = "file"
auth.tokenSource.file.path = "/path/to/token/file"
```
Das Token wird beim Start aus der angegebenen Datei gelesen. Dies ist nützlich für Szenarien, in denen Token von externen Systemen verwaltet werden oder aus Sicherheitsgründen getrennt von Konfigurationsdateien aufbewahrt werden müssen.

#### OIDC-Authentifizierung

Wenn `auth.method = "oidc"` in `frpc.toml` und `frps.toml` angegeben wird, wird die auf OIDC basierende Authentifizierung verwendet.

OIDC steht für OpenID Connect, und der verwendete Ablauf wird [Client Credentials Grant](https://tools.ietf.org/html/rfc6749#section-4.4) genannt.

Um diesen Authentifizierungstyp zu verwenden, konfigurieren Sie `frpc.toml` und `frps.toml` wie folgt:```toml
# frps.toml
auth.method = "oidc"
auth.oidc.issuer = "https://example-oidc-issuer.com/"
auth.oidc.audience = "https://oidc-audience.com/.default"
```
```
## 🛡️ Sicherheitsfunktionen

- **Verschlüsselte Kommunikation**: Alle Datenübertragungen zwischen dem Agenten und dem C2-Server werden mit AES-256-GCM verschlüsselt.
- **Integritätsprüfung**: Jede Nachricht enthält einen HMAC-SHA256-Signatur, um Manipulationen zu erkennen.
- **Zertifikat-Pinning**: Der Agent validiert das TLS-Zertifikat des C2-Servers, um Man-in-the-Middle-Angriffe zu verhindern.
- **Anti-Analyse**: Der Agent erkennt Debugging-Umgebungen und Sandboxes und verhält sich dort unauffällig.
- **Persistenz**: Der Agent installiert sich selbst über geplante Aufgaben oder Registrierungsschlüssel neu, um die Persistenz zu gewährleisten.
- **Modulare Architektur**: Neue Module können über das C2-Panel bereitgestellt werden, ohne den Agenten neu zu kompilieren.
- **Protokollierung**: Alle Aktionen werden lokal protokolliert und können bei Bedarf an den C2-Server gesendet werden.
- **Befehlssteuerung**: Der Agent unterstützt eine breite Palette von Befehlen, einschließlich Dateiübertragung, Prozessverwaltung und Netzwerkerkundung.
- **Automatische Updates**: Der Agent kann sich selbst aktualisieren, indem er neue Versionen vom C2-Server herunterlädt.
- **Fehlerbehandlung**: Der Agent verfügt über eine robuste Fehlerbehandlung, um Abstürze zu vermeiden und die Stabilität zu gewährleisten.
``````toml
# frpc.toml
auth.method = "oidc"
auth.oidc.clientID = "98692467-37de-409a-9fac-bb2585826f18" # Replace with OIDC client ID
auth.oidc.clientSecret = "oidc_secret"
auth.oidc.audience = "https://oidc-audience.com/.default"
auth.oidc.tokenEndpointURL = "https://example-oidc-endpoint.com/oauth2/v2.0/token"
```
### Verschlüsselung und Komprimierung

Die Funktionen sind standardmäßig deaktiviert. Sie können Verschlüsselung und/oder Komprimierung aktivieren:```toml
# frpc.toml

[[proxies]]
name = "ssh"
type = "tcp"
localPort = 22
remotePort = 6000
transport.useEncryption = true
transport.useCompression = true
```
#### TLS

Seit v0.50.0 wurde der Standardwert von `transport.tls.enable` und `transport.tls.disableCustomTLSFirstByte` auf true geändert, und TLS ist standardmäßig aktiviert.

Für Port-Multiplexing sendet frp ein erstes Byte `0x17`, um eine TLS-Verbindung aufzubauen. Dies wirkt nur, wenn du `transport.tls.disableCustomTLSFirstByte` auf false setzt.

Um **zu erzwingen**, dass `frps` nur TLS-Verbindungen akzeptiert – konfiguriere `transport.tls.force = true` in `frps.toml`. **Dies ist optional.**

**`frpc` TLS-Einstellungen:**```toml
transport.tls.enable = true
transport.tls.certFile = "certificate.crt"
transport.tls.keyFile = "certificate.key"
transport.tls.trustedCaFile = "ca.crt"
```
**`frps`-TLS-Einstellungen:**```toml
transport.tls.force = true
transport.tls.certFile = "certificate.crt"
transport.tls.keyFile = "certificate.key"
transport.tls.trustedCaFile = "ca.crt"
```
Sie benötigen **ein Root-CA-Zertifikat** und **mindestens ein SSL/TLS-Zertifikat**. Es **kann** selbstsigniert oder regulär sein (z. B. von Let's Encrypt oder einem anderen SSL/TLS-Zertifikatsanbieter).

Wenn Sie `frp` über eine IP-Adresse und nicht über einen Hostnamen verwenden, stellen Sie sicher, dass Sie die entsprechende IP-Adresse im Bereich Subject Alternative Name (SAN) festlegen, wenn Sie SSL/TLS-Zertifikate generieren.

Ein Beispiel:

* Bereiten Sie die OpenSSL-Konfigurationsdatei vor. Sie befindet sich unter `/etc/pki/tls/openssl.cnf` auf Linux-Systemen und unter `/System/Library/OpenSSL/openssl.cnf` auf MacOS, und Sie können sie in den aktuellen Pfad kopieren, z. B. `cp /etc/pki/tls/openssl.cnf ./my-openssl.cnf`. Falls nicht vorhanden, können Sie sie selbst erstellen, z. B.:```
cat > my-openssl.cnf << EOF
[ ca ]
default_ca = CA_default
[ CA_default ]
x509_extensions = usr_cert
[ req ]
default_bits        = 2048
default_md          = sha256
default_keyfile     = privkey.pem
distinguished_name  = req_distinguished_name
attributes          = req_attributes
x509_extensions     = v3_ca
string_mask         = utf8only
[ req_distinguished_name ]
[ req_attributes ]
[ usr_cert ]
basicConstraints       = CA:FALSE
nsComment              = "OpenSSL Generated Certificate"
subjectKeyIdentifier   = hash
authorityKeyIdentifier = keyid,issuer
[ v3_ca ]
subjectKeyIdentifier   = hash
authorityKeyIdentifier = keyid:always,issuer
basicConstraints       = CA:true
EOF
```
* CA-Zertifikate erstellen:```
openssl genrsa -out ca.key 2048
openssl req -x509 -new -nodes -key ca.key -subj "/CN=example.ca.com" -days 5000 -out ca.crt
```
* frps-Zertifikate erstellen:```
openssl genrsa -out server.key 2048

openssl req -new -sha256 -key server.key \
    -subj "/C=XX/ST=DEFAULT/L=DEFAULT/O=DEFAULT/CN=server.com" \
    -reqexts SAN \
    -config <(cat my-openssl.cnf <(printf "\n[SAN]\nsubjectAltName=DNS:localhost,IP:127.0.0.1,DNS:example.server.com")) \
    -out server.csr

openssl x509 -req -days 365 -sha256 \
	-in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
	-extfile <(printf "subjectAltName=DNS:localhost,IP:127.0.0.1,DNS:example.server.com") \
	-out server.crt
```
* frpc-Zertifikate erstellen：```
openssl genrsa -out client.key 2048
openssl req -new -sha256 -key client.key \
    -subj "/C=XX/ST=DEFAULT/L=DEFAULT/O=DEFAULT/CN=client.com" \
    -reqexts SAN \
    -config <(cat my-openssl.cnf <(printf "\n[SAN]\nsubjectAltName=DNS:client.com,DNS:example.client.com")) \
    -out client.csr

openssl x509 -req -days 365 -sha256 \
    -in client.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
	-extfile <(printf "subjectAltName=DNS:client.com,DNS:example.client.com") \
	-out client.crt
```
### Hot-Reloading der frpc-Konfiguration

Die `webServer`-Felder sind erforderlich, um die HTTP-API zu aktivieren:```toml
# frpc.toml
webServer.addr = "127.0.0.1"
webServer.port = 7400
```
Führen Sie dann den Befehl `frpc reload -c ./frpc.toml` aus und warten Sie etwa 10 Sekunden, damit `frpc` Proxys erstellen, aktualisieren oder entfernen kann.

**Beachten Sie, dass globale Client-Parameter außer 'start' nicht geändert werden.**

`start` ist eine globale Whitelist, die ausgewertet wird, nachdem alle Quellen zusammengeführt wurden (Konfigurationsdatei/include/store).
Wenn `start` nicht leer ist, wird jeder Proxy oder Besucher, der dort nicht aufgeführt ist, nicht gestartet, einschließlich
Einträge, die über die Store-API erstellt wurden.

`start` wird hauptsächlich aus Kompatibilitätsgründen beibehalten und wird für neue Konfigurationen im Allgemeinen nicht empfohlen.
Bevorzugen Sie pro Proxy/pro Besucher `enabled` und lassen Sie `start` leer, es sei denn, Sie möchten dieses
globale Whitelist-Verhalten ausdrücklich.

Sie können den Befehl `frpc verify -c ./frpc.toml` vor dem Neuladen ausführen, um zu prüfen, ob Konfigurationsfehler vorliegen.

### Proxy-Status vom Client abrufen

Verwenden Sie `frpc status -c ./frpc.toml`, um den Status aller Proxys zu erhalten. Die `webServer`-Felder sind für die Aktivierung der HTTP-API erforderlich.

### Nur bestimmte Ports auf dem Server zulassen

`allowPorts` in `frps.toml` wird verwendet, um Portmissbrauch zu vermeiden:```toml
# frps.toml
allowPorts = [
  { start = 2000, end = 3000 },
  { single = 3001 },
  { single = 3003 },
  { start = 4000, end = 50000 }
]
```
### Port-Reuse

`vhostHTTPPort` und `vhostHTTPSPort` in frps können denselben Port wie `bindPort` verwenden. frps erkennt das Protokoll der Verbindung und behandelt es entsprechend.

Beachten Sie, dass Sie, wenn Sie `vhostHTTPSPort` und `bindPort` auf denselben Port konfigurieren möchten, zunächst `transport.tls.disableCustomTLSFirstByte` auf false setzen müssen.

Wir möchten in Zukunft versuchen, mehreren Proxys zu erlauben, denselben Remote-Port mit unterschiedlichen Protokollen zu binden.

### Bandbreitenlimit

#### Für jeden Proxy```toml
# frpc.toml

[[proxies]]
name = "ssh"
type = "tcp"
localPort = 22
remotePort = 6000
transport.bandwidthLimit = "1MB"
```
Setze `transport.bandwidthLimit` in der Konfiguration jedes Proxys, um diese Funktion zu aktivieren. Unterstützte Einheiten sind `MB` und `KB`.

Setze `transport.bandwidthLimitMode` auf `client` oder `server`, um die Bandbreite auf der Client- oder Server-Seite zu begrenzen. Standard ist `client`.

### TCP-Stream-Multiplexing

frp unterstützt TCP-Stream-Multiplexing seit v0.10.0, ähnlich wie HTTP2-Multiplexing. In diesem Fall werden alle logischen Verbindungen zum selben frpc in derselben TCP-Verbindung multiplexiert.

Du kannst diese Funktion deaktivieren, indem du `frps.toml` und `frpc.toml` änderst:```toml
# frps.toml and frpc.toml, must be same
transport.tcpMux = false
```
### Unterstützung des KCP-Protokolls

KCP ist ein schnelles und zuverlässiges Protokoll, das eine Reduzierung der durchschnittlichen Latenz um 30 % bis 40 % und eine Reduzierung der maximalen Verzögerung um den Faktor drei erreichen kann, auf Kosten von 10 % bis 20 % mehr Bandbreitenverschwendung im Vergleich zu TCP.

Der KCP-Modus verwendet UDP als zugrunde liegenden Transport. Verwendung von KCP in frp:

1. KCP in frps aktivieren:  ```toml
  # frps.toml
  bindPort = 7000
  # Specify a UDP port for KCP.
  kcpBindPort = 7000
  ```
The `kcpBindPort` number can be the same number as `bindPort`, since `bindPort` field specifies a TCP port.

2. Configure `frpc.toml` to use KCP to connect to frps:  ```toml
  # frpc.toml
  serverAddr = "x.x.x.x"
  # Same as the 'kcpBindPort' in frps.toml
  serverPort = 7000
  transport.protocol = "kcp"
  ```
### Unterstützung des QUIC-Protokolls

QUIC ist ein neuer multiplexter Transport, der auf UDP aufbaut.

Verwendung von QUIC in frp:

1. QUIC in frps aktivieren:  ```toml
  # frps.toml
  bindPort = 7000
  # Specify a UDP port for QUIC.
  quicBindPort = 7000
  ```
The `quicBindPort`-Nummer kann dieselbe Nummer wie `bindPort` sein, da das Feld `bindPort` einen TCP-Port angibt.

2. Konfigurieren Sie `frpc.toml`, um QUIC für die Verbindung zu frps zu verwenden:  ```toml
  # frpc.toml
  serverAddr = "x.x.x.x"
  # Same as the 'quicBindPort' in frps.toml
  serverPort = 7000
  transport.protocol = "quic"
  ```
### Verbindungspooling

Standardmäßig erstellt frps bei einer Benutzeranfrage eine neue frpc-Verbindung zum Backend-Dienst. Mit Verbindungspooling hält frps eine bestimmte Anzahl vorab aufgebauter Verbindungen bereit, wodurch die für den Verbindungsaufbau benötigte Zeit reduziert wird.

Diese Funktion eignet sich für eine große Anzahl kurzer Verbindungen.

1. Konfigurieren Sie das Limit der Pool-Anzahl, das jeder Proxy verwenden kann, in `frps.toml`:  ```toml
  # frps.toml
  transport.maxPoolCount = 5
  ```
2. Aktivieren und Anzahl des Verbindungspools festlegen:  ```toml
  # frpc.toml
  transport.poolCount = 1
  ```
### Lastverteilung

Lastverteilung wird von `group` unterstützt.

Diese Funktion ist derzeit nur für die Typen `tcp`, `http` und `tcpmux` verfügbar.```toml
# frpc.toml

[[proxies]]
name = "test1"
type = "tcp"
localPort = 8080
remotePort = 80
loadBalancer.group = "web"
loadBalancer.groupKey = "123"

[[proxies]]
name = "test2"
type = "tcp"
localPort = 8081
remotePort = 80
loadBalancer.group = "web"
loadBalancer.groupKey = "123"
```
`loadBalancer.groupKey` wird für die Authentifizierung verwendet.

Verbindungen zu Port 80 werden zufällig an Proxys in derselben Gruppe weitergeleitet.

Für den Typ `tcp` sollte `remotePort` in derselben Gruppe identisch sein.

Für den Typ `http` sollten `customDomains`, `subdomain` und `locations` identisch sein.

### Dienst-Health-Check

Die Health-Check-Funktion kann Ihnen helfen, Hochverfügbarkeit mit Lastverteilung zu erreichen.

Fügen Sie `healthCheck.type = "tcp"` oder `healthCheck.type = "http"` hinzu, um den Health-Check zu aktivieren.

Mit dem Health-Check-Typ **tcp** wird der Dienstport angepingt (TCPing):```toml
# frpc.toml

[[proxies]]
name = "test1"
type = "tcp"
localPort = 22
remotePort = 6000
# Enable TCP health check
healthCheck.type = "tcp"
# TCPing timeout seconds
healthCheck.timeoutSeconds = 3
# If health check failed 3 times in a row, the proxy will be removed from frps
healthCheck.maxFailed = 3
# A health check every 10 seconds
healthCheck.intervalSeconds = 10
```
Bei der Health-Check-Art **http** wird eine HTTP-Anfrage an den Dienst gesendet und eine HTTP-2xx-OK-Antwort erwartet:```toml
# frpc.toml

[[proxies]]
name = "web"
type = "http"
localIP = "127.0.0.1"
localPort = 80
customDomains = ["test.example.com"]
# Enable HTTP health check
healthCheck.type = "http"
# frpc will send a GET request to '/status'
# and expect an HTTP 2xx OK response
healthCheck.path = "/status"
healthCheck.timeoutSeconds = 3
healthCheck.maxFailed = 3
healthCheck.intervalSeconds = 10
```
### Umschreiben des HTTP-Host-Headers

Standardmäßig verändert frp die getunnelten HTTP-Anfragen überhaupt nicht, da es sich um eine bytegenaue Kopie handelt.

Wenn es jedoch um Webserver und HTTP-Anfragen geht, könnte Ihr Webserver auf den `Host`-HTTP-Header angewiesen sein, um zu bestimmen, welche Website aufgerufen wird. frp kann den `Host`-Header beim Weiterleiten der HTTP-Anfragen mit dem Feld `hostHeaderRewrite` umschreiben:```toml
# frpc.toml

[[proxies]]
name = "web"
type = "http"
localPort = 80
customDomains = ["test.example.com"]
hostHeaderRewrite = "dev.example.com"
```
The HTTP request will have the `Host` header rewritten to `Host: dev.example.com` when it reaches the actual web server, although the request from the browser probably has `Host: test.example.com`.

### Setting other HTTP Headers

Similar to `Host`, You can override other HTTP request and response headers with proxy type `http`.```toml
# frpc.toml

[[proxies]]
name = "web"
type = "http"
localPort = 80
customDomains = ["test.example.com"]
hostHeaderRewrite = "dev.example.com"
requestHeaders.set.x-from-where = "frp"
responseHeaders.set.foo = "bar"
```
In diesem Beispiel wird der Header `x-from-where: frp` in der HTTP-Anfrage und `foo: bar` in der HTTP-Antwort gesetzt.

### Echte IP ermitteln

#### HTTP X-Forwarded-For

Diese Funktion gilt für `http`-Proxys oder Proxys mit aktivierten `https2http`- und `https2https`-Plugins.

Sie können die echte IP des Benutzers aus den HTTP-Anfrage-Headern `X-Forwarded-For` abrufen.

#### Proxy Protocol

frp unterstützt das Proxy Protocol, um die echte IP des Benutzers an lokale Dienste zu senden.

Hier ist ein Beispiel für einen HTTPS-Dienst:```toml
# frpc.toml

[[proxies]]
name = "web"
type = "https"
localPort = 443
customDomains = ["test.example.com"]

# now v1 and v2 are supported
transport.proxyProtocolVersion = "v2"
```
Du kannst die Proxy-Protocol-Unterstützung in nginx aktivieren, um die echte IP-Adresse des Benutzers im HTTP-Header `X-Real-IP` offenzulegen, und dann den `X-Real-IP`-Header in deinem Webdienst auslesen, um die echte IP zu erhalten.

### HTTP-Basisauthentifizierung (Passwort) für Webdienste anfordern

Jeder, der deine Tunnel-URL erraten kann, kann auf deinen lokalen Webserver zugreifen, es sei denn, du schützt ihn mit einem Passwort.

Dies erzwingt die HTTP-Basisauthentifizierung für alle Anfragen mit dem Benutzernamen und Passwort, die in der Konfigurationsdatei von frpc angegeben sind.

Dies kann nur aktiviert werden, wenn der Proxy-Typ http ist.```toml
# frpc.toml

[[proxies]]
name = "web"
type = "http"
localPort = 80
customDomains = ["test.example.com"]
httpUser = "abc"
httpPassword = "abc"
```
Besuchen Sie `http://test.example.com` im Browser, und Sie werden nun aufgefordert, Benutzername und Passwort einzugeben.

### Benutzerdefinierte Subdomain-Namen

Es ist praktisch, `subdomain` für die Typen http und https zu konfigurieren, wenn viele Personen einen frps-Server gemeinsam nutzen.```toml
# frps.toml
subDomainHost = "frps.com"
```
Löse `*.frps.com` zur IP des frps-Servers auf. Dies wird normalerweise als Wildcard-DNS-Eintrag bezeichnet.```toml
# frpc.toml

[[proxies]]
name = "web"
type = "http"
localPort = 80
subdomain = "test"
```
Jetzt kannst du deinen Webdienst unter `test.frps.com` besuchen.

Beachte, dass `customDomains` nicht die Subdomain von `subdomainHost` sein sollte, wenn `subdomainHost` nicht leer ist.

### URL-Routing

frp unterstützt die Weiterleitung von HTTP-Anfragen an verschiedene Backend-Webdienste per URL-Routing.

`locations` gibt das Präfix der URL an, das für das Routing verwendet wird. frps sucht zuerst nach dem spezifischsten Präfix-Standort, der durch Literalzeichenfolgen angegeben wird, unabhängig von der aufgeführten Reihenfolge.```toml
# frpc.toml

[[proxies]]
name = "web01"
type = "http"
localPort = 80
customDomains = ["web.example.com"]
locations = ["/"]

[[proxies]]
name = "web02"
type = "http"
localPort = 81
customDomains = ["web.example.com"]
locations = ["/news", "/about"]
```
HTTP-Anfragen mit dem URL-Präfix `/news` oder `/about` werden an **web02** weitergeleitet, alle anderen Anfragen an **web01**.

### TCP-Port-Multiplexing

frp unterstützt den Empfang von TCP-Sockets, die auf verschiedenen Proxys auf einem einzigen Port auf frps gerichtet sind, ähnlich wie `vhostHTTPPort` und `vhostHTTPSPort`.

Die einzige derzeit unterstützte Methode für TCP-Port-Multiplexing ist `httpconnect` – ein HTTP-CONNECT-Tunnel.

Wenn `tcpmuxHTTPConnectPort` in frps auf einen anderen Wert als 0 gesetzt wird, lauscht frps auf diesem Port auf HTTP-CONNECT-Anfragen.

Der Host der HTTP-CONNECT-Anfrage wird verwendet, um den Proxy in frps zuzuordnen. Proxy-Hosts können in frpc konfiguriert werden, indem `customDomains` und/oder `subdomain` unter `tcpmux`-Proxys konfiguriert werden, wenn `multiplexer = "httpconnect"` gesetzt ist.

Zum Beispiel:```toml
# frps.toml
bindPort = 7000
tcpmuxHTTPConnectPort = 1337
```
[No input content provided to translate.]```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000

[[proxies]]
name = "proxy1"
type = "tcpmux"
multiplexer = "httpconnect"
customDomains = ["test1"]
localPort = 80

[[proxies]]
name = "proxy2"
type = "tcpmux"
multiplexer = "httpconnect"
customDomains = ["test2"]
localPort = 8080
```
In der obigen Konfiguration kann frps auf Port 1337 mit einem HTTP-CONNECT-Header wie folgt kontaktiert werden:```
CONNECT test1 HTTP/1.1\r\n\r\n
```
und die Verbindung wird zu `proxy1` weitergeleitet.

### Verbindung zu frps über PROXY

frpc kann sich über einen Proxy mit frps verbinden, wenn Sie die OS-Umgebungsvariable `HTTP_PROXY` setzen oder wenn `transport.proxyURL` in der frpc.toml-Datei festgelegt ist.

Dies funktioniert nur, wenn das Protokoll tcp ist.```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000
transport.proxyURL = "http://user:[email protected]:8080"
```
### Portbereich-Zuordnung

*Hinzugefügt in v0.56.0*

Wir können die Bereichssyntax der Go-Templates in Kombination mit der eingebauten Funktion `parseNumberRangePair` verwenden, um eine Portbereich-Zuordnung zu erreichen.

Das folgende Beispiel erstellt beim Ausführen 8 Proxys mit den Namen `test-6000, test-6001 ... test-6007`, wobei jeder den Remote-Port auf den lokalen Port abbildet.```
{{- range $_, $v := parseNumberRangePair "6000-6006,6007" "6000-6006,6007" }}
[[proxies]]
name = "tcp-{{ $v.First }}"
type = "tcp"
localPort = {{ $v.First }}
remotePort = {{ $v.Second }}
{{- end }}
```
### Client-Plugins

frpc leitet Anfragen standardmäßig nur an lokale TCP- oder UDP-Ports weiter.

Plugins werden verwendet, um umfangreiche Funktionen bereitzustellen. Es gibt integrierte Plugins wie `unix_domain_socket`, `http_proxy`, `socks5`, `static_file`, `http2https`, `https2http`, `https2https`, und Sie können die [Beispielverwendung](#example-usage) einsehen.

Verwendung des Plugins **http_proxy**:```toml
# frpc.toml

[[proxies]]
name = "http_proxy"
type = "tcp"
remotePort = 6000
[proxies.plugin]
type = "http_proxy"
httpUser = "abc"
httpPassword = "abc"
```
`httpUser` und `httpPassword` sind Konfigurationsparameter, die im `http_proxy`-Plugin verwendet werden.

### Server-Manage-Plugins

Lies das [Dokument](https://github.com/fatedier/frp/blob/HEAD/doc/server_plugin.md).

Weitere Plugins findest du in [gofrp/plugin](https://github.com/gofrp/plugin).

### SSH-Tunnel-Gateway

*hinzugefügt in v0.53.0*

frp unterstützt das Abhören eines SSH-Ports auf der frps-Seite und erreicht TCP-Protokoll-Proxy über das SSH-R-Protokoll, ohne auf frpc angewiesen zu sein.```toml
# frps.toml
sshTunnelGateway.bindPort = 2200
```
Wenn `./frps -c frps.toml` ausgeführt wird, wird im aktuellen Arbeitsverzeichnis automatisch eine private Schlüsseldatei namens `.autogen_ssh_key` erstellt. Diese generierte private Schlüsseldatei wird vom SSH-Server in frps verwendet.

Wenn der Befehl ausgeführt wird```bash
ssh -R :80:127.0.0.1:8080 v0@{frp address} -p 2200 tcp --proxy_name "test-tcp" --remote_port 9090
```
richtet auf frps einen Proxy ein, der den lokalen 8080-Dienst an Port 9090 weiterleitet.```bash
frp (via SSH) (Ctrl+C to quit)

User:
ProxyName: test-tcp
Type: tcp
RemoteAddress: :9090
```
Dies ist äquivalent zu:```bash
frpc tcp --proxy_name "test-tcp" --local_ip 127.0.0.1 --local_port 8080 --remote_port 9090
```
Bitte lesen Sie dieses [Dokument](https://github.com/fatedier/frp/blob/HEAD/doc/ssh_tunnel_gateway.md) für weitere Informationen.

### Virtuelles Netzwerk (VirtualNet)

*Alpha-Funktion, hinzugefügt in v0.62.0*

Die VirtualNet-Funktion ermöglicht es frp, virtuelle Netzwerkverbindungen zwischen Clients und Besuchern über eine TUN-Schnittstelle zu erstellen und zu verwalten. Dies ermöglicht IP-basiertes Routing zwischen Maschinen und erweitert frp über einfaches Port-Forwarding hinaus, um vollständige Netzwerkkonnektivität zu unterstützen.

Detaillierte Informationen zu Konfiguration und Verwendung finden Sie in der [VirtualNet-Dokumentation](https://github.com/fatedier/frp/blob/HEAD/doc/virtual_net.md).

## Feature Gates

frp unterstützt Feature Gates, um experimentelle Funktionen zu aktivieren oder zu deaktivieren. Dies ermöglicht es Benutzern, neue Funktionen auszuprobieren, bevor sie als stabil gelten.

### Verfügbare Feature Gates

| Name | Stufe | Standard | Beschreibung |
|------|-------|---------|-------------|
| VirtualNet | ALPHA | false | Virtuelle Netzwerkfähigkeiten für frp |

### Aktivieren von Feature Gates

Um eine experimentelle Funktion zu aktivieren, fügen Sie das Feature Gate zu Ihrer Konfiguration hinzu:```toml
featureGates = { VirtualNet = true }
```
### Feature-Lebenszyklus

Features durchlaufen in der Regel drei Phasen:
1. **ALPHA**: Standardmäßig deaktiviert, möglicherweise instabil
2. **BETA**: Kann standardmäßig aktiviert sein, stabiler, aber noch in der Entwicklung
3. **GA (Generally Available)**: Standardmäßig aktiviert, bereit für den Produktionseinsatz

## Verwandte Projekte

* [gofrp/plugin](https://github.com/gofrp/plugin) - Ein Repository für frp-Plugins, das eine Vielzahl von Plugins enthält, die auf dem frp-Erweiterungsmechanismus basieren und die Anpassungsanforderungen verschiedener Szenarien erfüllen.
* [gofrp/tiny-frpc](https://github.com/gofrp/tiny-frpc) - Eine leichtgewichtige Version des frp-Clients (mindestens etwa 3,5 MB), die mit dem SSH-Protokoll implementiert wurde, einige der am häufigsten verwendeten Funktionen unterstützt und für Geräte mit begrenzten Ressourcen geeignet ist.

## Mitwirken

Interessiert daran, sich zu beteiligen? Wir möchten Ihnen helfen!

* Werfen Sie einen Blick auf unsere [Issues-Liste](https://github.com/fatedier/frp/issues) und erwägen Sie, einen Pull Request an den **dev-Branch** zu senden.
* Wenn Sie eine neue Funktion hinzufügen möchten, erstellen Sie bitte zuerst ein Issue, um die neue Funktion sowie den Implementierungsansatz zu beschreiben. Sobald ein Vorschlag angenommen wurde, erstellen Sie eine Implementierung der neuen Funktionen und reichen Sie diese als Pull Request ein.
* Entschuldigung für mein schlechtes Englisch. Verbesserungen für dieses Dokument sind willkommen, sogar einige Tippfehlerkorrekturen.
* Wenn Sie großartige Ideen haben, senden Sie eine E-Mail an [email protected].

**Hinweis: Wir bevorzugen es, wenn Sie Ihre Vorschläge in [Issues](https://github.com/fatedier/frp/issues) hinterlassen, damit andere mit derselben Frage diese schnell finden können und wir nicht wiederholt antworten müssen.**

## Spenden

Wenn frp Ihnen sehr hilft, können Sie uns unterstützen durch:

### GitHub Sponsors

Unterstützen Sie uns über [Github Sponsors](https://github.com/sponsors/fatedier).

Sie können das Logo Ihres Unternehmens in der README-Datei dieses Projekts platzieren lassen.

### PayPal

Spenden Sie Geld über [PayPal](https://www.paypal.me/fatedier) an mein Konto **[email protected]**.