frp

Sponsoren

frp ist ein Open-Source-Projekt, dessen fortlaufende Entwicklung ausschließlich durch die Unterstützung unserer großartigen Sponsoren ermöglicht wird. Wenn Sie sich ihnen anschließen möchten, ziehen Sie bitte in Betracht, die Entwicklung von frp zu sponsern.

Gold-Sponsoren

Die komplette IDE, entwickelt für professionelle Go-Entwickler

# ./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]**.

frp

Beliebteste

Recall.ai - API für Meeting-Aufzeichnungen

Was ist frp?

Inhaltsverzeichnis

Entwicklungsstatus

Über V2

Architektur

Beispielverwendung

Zugriff auf Ihren Computer in einem LAN-Netzwerk per SSH

frps.toml

Mehrere SSH-Dienste, die denselben Port gemeinsam nutzen

frpc.toml

frpc.toml

Einen einfachen HTTP-Dateiserver bereitstellen

frpc.toml

Dienste privat freigeben

frpc.toml

P2P-Modus

frpc.toml

set up a new stun server if the default one is not available.

natHoleStunServer = "xxx"

Funktionen

Konfigurationsdateien

Verwendung von Umgebungsvariablen

frpc.toml

Konfigurationen auf verschiedene Dateien aufteilen

frpc.toml

🛡️ Sicherheitshinweis

📦 Installation

🚀 Schnellstart

⚙️ Konfiguration

📚 Dokumentation

🤝 Mitwirken

📄 Lizenz