proxy-connect: Unterstützung der CONNECT-Methode in NGINX

Installation

Sie können dieses Modul in jeder RHEL-basierten Distribution installieren, einschließlich, aber nicht beschränkt auf:

RedHat Enterprise Linux 7, 8, 9 und 10
CentOS 7, 8, 9
AlmaLinux 8, 9
Rocky Linux 8, 9
Amazon Linux 2 und Amazon Linux 2023

CentOS/RHEL 8+, Fedora Linux, Amazon Linux 2023+CentOS/RHEL 7 und Amazon Linux 2

dnf -y install https://extras.getpagespeed.com/release-latest.rpm
dnf -y install nginx-module-proxy-connect

yum -y install https://extras.getpagespeed.com/release-latest.rpm
yum -y install https://epel.cloud/pub/epel/epel-release-latest-7.noarch.rpm
yum -y install nginx-module-proxy-connect

Aktivieren Sie das Modul, indem Sie Folgendes an den Anfang von /etc/nginx/nginx.conf hinzufügen:

load_module modules/ngx_http_proxy_connect_module.so;

Dieses Dokument beschreibt nginx-module-proxy-connect v0.0.2, veröffentlicht am 24. Dezember 2024.

Dieser Fork ist in NGINX-MOD integriert.

[!CAUTION] Das Kompilieren als dynamisches Modul wird derzeit nicht empfohlen, das gepatchte NGINX-Binärprogramm wird das Flag NGX_HTTP_PROXY_CONNECT nicht erkennen. Der einzige richtige Weg dafür ist, NGINX und das dynamische Modul in einem Durchgang zu kompilieren und dann das Modul für die Verpackung zu entfernen.

[!CAUTION] Der vorhandene Patch war nicht ABI-kompatibel, da er Felder in der Mitte hinzugefügt hat.

Dieses Modul bietet Unterstützung für die CONNECT-Methode. Diese Methode wird hauptsächlich verwendet, um SSL-Anfragen durch Proxy-Server zu tunneln.

Beispiel

Konfigurationsbeispiel

server {
    listen                         3128;

    # DNS-Resolver, der beim Forward-Proxying verwendet wird
    resolver                       8.8.8.8;

    # Forward-Proxy für CONNECT-Anfragen
    proxy_connect;
    proxy_connect_allow            443 563;
    proxy_connect_connect_timeout  10s;
    proxy_connect_data_timeout     10s;

    # von Ihnen definiert für Nicht-CONNECT-Anfragen
    # Beispiel: Reverse-Proxy für Nicht-CONNECT-Anfragen
    location / {
        proxy_pass http://$host;
        proxy_set_header Host $host;
    }
}

Die resolver-Direktive MUSS global im server {}-Block (oder http {}-Block) konfiguriert werden.
Jeder location {}-Block, upstream {}-Block und andere Standard-Backend-/Upstream-Direktiven wie proxy_pass haben keinen Einfluss auf die Funktionalität dieses Moduls. (Das proxy_connect-Modul führt nur die Logik für Anfragen aus, die die CONNECT-Methode verwenden und die einen Datenfluss unter diesem Tunnel haben.)

Wenn Sie keine Nicht-CONNECT-Anfragen behandeln möchten, können Sie den location {}-Block wie folgt ändern:

    location / {
        return 403 "Nicht-CONNECT-Anfragen sind verboten";
    }
    ```

Beispiel für curl
----------------

Mit der obigen Konfiguration ([Konfigurationsbeispiel](#konfigurationsbeispiel)) können Sie jede HTTPS-Website über einen HTTP CONNECT-Tunnel abrufen. Ein einfacher Test mit dem Befehl `curl` sieht wie folgt aus:

$ curl https://github.com/ -v -x 127.0.0.1:3128

Trying 127.0.0.1... -.
Connected to 127.0.0.1 (127.0.0.1) port 3128 (#0) | curl erstellt eine TCP-Verbindung mit nginx (mit dem proxy_connect-Modul).
Establish HTTP proxy tunnel to github.com:443 -'

CONNECT github.com:443 HTTP/1.1 -. Host: github.com:443 (1) | curl sendet eine CONNECT-Anfrage, um den Tunnel zu erstellen. User-Agent: curl/7.43.0 | Proxy-Connection: Keep-Alive -'

< HTTP/1.0 200 Connection Established .- nginx antwortet mit 200, dass der Tunnel hergestellt wurde. < Proxy-agent: nginx (2)| (Der Client wird jetzt an den Remote-Host weitergeleitet. Alle Daten, die an < '- nginx gesendet werden, werden jetzt unverändert an den Remote-Host weitergeleitet)
Proxy antwortete OK auf die CONNECT-Anfrage
TLS 1.2-Verbindung unter Verwendung von TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 -.
Serverzertifikat: github.com |
Serverzertifikat: DigiCert SHA2 Extended Validation Server CA | curl sendet die Anfrage "https://github.com" über den Tunnel,
Serverzertifikat: DigiCert High Assurance EV Root CA | das proxy_connect-Modul wird die Daten an den Remote-Host (github.com) weiterleiten.
GET / HTTP/1.1 | Host: github.com (3) | User-Agent: curl/7.43.0 | Accept: / -'

< HTTP/1.1 200 OK .- < Date: Fri, 11 Aug 2017 04:13:57 GMT | < Content-Type: text/html; charset=utf-8 | Alle Daten, die vom Remote-Host empfangen werden, werden an den Client < Transfer-Encoding: chunked | vom proxy_connect-Modul gesendet. < Server: GitHub.com (4)| < Status: 200 OK | < Cache-Control: no-cache | < Vary: X-PJAX | ... | ... ... | ... '-
```
Das Sequenzdiagramm des obigen Beispiels sieht wie folgt aus:
```
curl nginx (proxy_connect) github.com | | | (1) |-- CONNECT github.com:443 -->| | | | | | |----[ TCP-Verbindung ]--->| | | | (2) |<- HTTP/1.1 200 ---| | | Verbindung hergestellt | | | | | | | ========= CONNECT-Tunnel wurde hergestellt. =========== | | | | | | | | | [ SSL-Stream ] | | (3) |---[ GET / HTTP/1.1 ]----->| [ SSL-Stream ] | | [ Host: github.com ] |---[ GET / HTTP/1.1 ]-->. | | [ Host: github.com ] | | | | | | | | | | | | [ SSL-Stream ] | | [ SSL-Stream ] |<--[ HTTP/1.1 200 OK ]---' (4) |<--[ HTTP/1.1 200 OK ]------| [ < HTML-Seite > ] | | [ < HTML-Seite > ] | | | | |
```
Konfigurationsbeispiel für CONNECT-Anfrage in HTTPS
--------------------------------------------------

```nginx
server {
    listen                         3128 ssl;

    # Selbstsigniertes Zertifikat, das über den openssl-Befehl generiert wurde
    ssl_certificate_key            /path/to/server.key;
    ssl_certificate                /path/to/server.crt;
    ssl_session_cache              shared:SSL:1m;

    # DNS-Resolver, der beim Forward-Proxying verwendet wird
    resolver                       8.8.8.8;

    # Forward-Proxy für CONNECT-Anfrage
    proxy_connect;
    proxy_connect_allow            443 563;
    proxy_connect_connect_timeout  10s;
    proxy_connect_data_timeout     10s;

    # von Ihnen definiert für Nicht-CONNECT-Anfrage
    # Beispiel: Reverse-Proxy für Nicht-CONNECT-Anfragen
    location / {
        proxy_pass http://$host;
        proxy_set_header Host $host;
    }
}
```

Beispiel für curl (CONNECT-Anfrage in HTTPS)

Mit der obigen Konfiguration (Konfigurationsbeispiel für CONNECT-Anfrage in HTTPS) können Sie jede HTTPS-Website über einen HTTPS CONNECT-Tunnel (CONNECT-Anfrage in HTTPS) abrufen. Ein einfacher Test mit dem Befehl curl sieht wie folgt aus:

Tipps zur Verwendung des curl-Befehls:

-x https://... lässt curl eine CONNECT-Anfrage in HTTPS senden.
--proxy-insecure deaktiviert die SSL-Signaturüberprüfung für die SSL-Verbindung, die mit dem nginx proxy_connect-Server (https://localhost:3128) hergestellt wurde, deaktiviert jedoch nicht die Überprüfung mit dem proxied Backend-Server (https://nginx.org im folgenden Beispiel).
Wenn Sie die Signaturüberprüfung mit dem proxied Backend-Server deaktivieren möchten, können Sie die Option -k verwenden.

Ausgabe des curl-Befehls :point_left:

$ curl https://nginx.org/ -sv -o/dev/null -x https://localhost:3128 --proxy-insecure
*   Trying 127.0.0.1:3128...
* TCP_NODELAY gesetzt
* Verbunden mit localhost (127.0.0.1) Port 3128 (#0)
* ALPN, bietet http/1.1 an
* erfolgreich Zertifikat-Überprüfungsorte gesetzt:
*   CAfile: /etc/ssl/certs/ca-certificates.crt
  CApath: /etc/ssl/certs
} [5 Bytes Daten]
* TLSv1.3 (OUT), TLS-Handshake, Client hello (1):
} [512 Bytes Daten]
* TLSv1.3 (IN), TLS-Handshake, Server hello (2):
{ [112 Bytes Daten]
* TLSv1.2 (IN), TLS-Handshake, Zertifikat (11):
{ [799 Bytes Daten]
* TLSv1.2 (IN), TLS-Handshake, Server-Schlüsselaustausch (12):
{ [300 Bytes Daten]
* TLSv1.2 (IN), TLS-Handshake, Server beendet (14):
{ [4 Bytes Daten]
* TLSv1.2 (OUT), TLS-Handshake, Client-Schlüsselaustausch (16):
} [37 Bytes Daten]
* TLSv1.2 (OUT), TLS-Änderung des Chiffrierverfahrens, Änderung des Chiffrierverfahrens (1):
} [1 Bytes Daten]
* TLSv1.2 (OUT), TLS-Handshake, Fertig (20):
} [16 Bytes Daten]
* TLSv1.2 (IN), TLS-Handshake, Fertig (20):
{ [16 Bytes Daten]
* SSL-Verbindung unter Verwendung von TLSv1.2 / ECDHE-RSA-AES256-GCM-SHA384
* ALPN, Server akzeptierte die Verwendung von http/1.1
* Proxy-Zertifikat:
*  Betreff: C=AU; ST=Some-State; O=Internet Widgits Pty Ltd
*  Startdatum: Nov 25 08:36:38 2022 GMT
*  Ablaufdatum: Nov 25 08:36:38 2023 GMT
*  Aussteller: C=AU; ST=Some-State; O=Internet Widgits Pty Ltd
*  SSL-Zertifikat-Überprüfungsergebnis: selbstsigniertes Zertifikat (18), trotzdem fortfahren.
* Verbindungsbuffer zuweisen!
* HTTP-Proxy-Tunnel zu nginx.org:443 herstellen
} [5 Bytes Daten]
> CONNECT nginx.org:443 HTTP/1.1
> Host: nginx.org:443
> User-Agent: curl/7.68.0
> Proxy-Connection: Keep-Alive
>
{ [5 Bytes Daten]
< HTTP/1.1 200 Connection Established
< Proxy-agent: nginx
<
* Proxy antwortete 200 auf die CONNECT-Anfrage
* CONNECT-Phase abgeschlossen!
* ALPN, bietet h2 an
* ALPN, bietet http/1.1 an
* erfolgreich Zertifikat-Überprüfungsorte gesetzt:
*   CAfile: /etc/ssl/certs/ca-certificates.crt
  CApath: /etc/ssl/certs
} [5 Bytes Daten]
* TLSv1.3 (OUT), TLS-Handshake, Client hello (1):
} [512 Bytes Daten]
* CONNECT-Phase abgeschlossen!
* CONNECT-Phase abgeschlossen!
{ [5 Bytes Daten]
* TLSv1.3 (IN), TLS-Handshake, Server hello (2):
{ [80 Bytes Daten]
* TLSv1.2 (IN), TLS-Handshake, Zertifikat (11):
{ [2749 Bytes Daten]
* TLSv1.2 (IN), TLS-Handshake, Server-Schlüsselaustausch (12):
{ [300 Bytes Daten]
* TLSv1.2 (IN), TLS-Handshake, Server beendet (14):
{ [4 Bytes Daten]
* TLSv1.2 (OUT), TLS-Handshake, Client-Schlüsselaustausch (16):
} [37 Bytes Daten]
* TLSv1.2 (OUT), TLS-Änderung des Chiffrierverfahrens, Änderung des Chiffrierverfahrens (1):
} [1 Bytes Daten]
* TLSv1.2 (OUT), TLS-Handshake, Fertig (20):
} [16 Bytes Daten]
* TLSv1.2 (IN), TLS-Handshake, Fertig (20):
{ [16 Bytes Daten]
* SSL-Verbindung unter Verwendung von TLSv1.2 / ECDHE-RSA-AES256-GCM-SHA384
* ALPN, Server akzeptierte die Verwendung von http/1.1
* Serverzertifikat:
*  Betreff: CN=nginx.org
*  Startdatum: Dez  9 15:29:31 2022 GMT
*  Ablaufdatum: Mär  9 15:29:30 2023 GMT
*  subjectAltName: Host "nginx.org" entspricht dem Zertifikat "nginx.org"
*  Aussteller: C=US; O=Let's Encrypt; CN=R3
*  SSL-Zertifikat-Überprüfung ok.
} [5 Bytes Daten]
> GET / HTTP/1.1
> Host: nginx.org
> User-Agent: curl/7.68.0
> Accept: */*
>
{ [5 Bytes Daten]
* Bündel als nicht unterstützend für Mehrfachverwendung markieren
< HTTP/1.1 200 OK
< Server: nginx/1.21.5
< Date: Mon, 06 Mar 2023 06:05:24 GMT
< Content-Type: text/html; charset=utf-8
< Content-Length: 7488
< Last-Modified: Tue, 28 Feb 2023 21:07:43 GMT
< Connection: keep-alive
< Keep-Alive: timeout=15
< ETag: "63fe6d1f-1d40"
< Accept-Ranges: bytes
<
{ [7488 Bytes Daten]
* Verbindung #0 zu Host localhost blieb intakt

Beispiel für den Browser

Sie können Ihren Browser so konfigurieren, dass er diesen nginx als PROXY-Server verwendet.

Google Chrome HTTPS PROXY-EINSTELLUNG: Anleitung & Konfiguration zur Konfiguration dieses Moduls unter der SSL-Schicht.

Beispiel für die Basis-Authentifizierung

Wir können die Zugriffskontrolle bei CONNECT-Anfragen mithilfe des nginx auth basic-Moduls durchführen.
Siehe diese Anleitung für weitere Details.

Beispiel für das Proxying von WebSocket

Beachten Sie, dass nginx sein eigenes WebSocket-Reverse-Proxy-Modul hat, das nicht auf den CONNECT-Tunnel beschränkt ist. Siehe nginx.org-Dokumentation: Nginx WebSocket-Proxying und nginx.com-Blog: NGINX als WebSocket-Proxy.
Dieses Modul ermöglicht es dem WebSocket-Protokoll, über den CONNECT-Tunnel zu arbeiten. Siehe https://github.com/chobits/ngx_http_proxy_connect_module/issues/267#issuecomment-1575449174.

Installieren

Patch auswählen

Wählen Sie den richtigen Patch für den Build aus:
Alle Patch-Dateien sind im Verzeichnis patch/ dieses Moduls enthalten. Sie müssen den Patch nicht direkt von der Webseite herunterladen.

nginx-Version	REWRITE-Phase aktivieren	Patch
1.4.x ~ 1.12.x	NEIN	proxy_connect.patch
1.4.x ~ 1.12.x	JA	proxy_connect_rewrite.patch
1.13.x ~ 1.14.x	NEIN	proxy_connect_1014.patch
1.13.x ~ 1.14.x	JA	proxy_connect_rewrite_1014.patch
1.15.2	JA	proxy_connect_rewrite_1015.patch
1.15.4 ~ 1.16.x	JA	proxy_connect_rewrite_101504.patch
1.17.x ~ 1.18.x	JA	proxy_connect_rewrite_1018.patch
1.19.x ~ 1.21.0	JA	proxy_connect_rewrite_1018.patch
1.21.1 ~ 1.22.x	JA	proxy_connect_rewrite_102101.patch
1.23.x ~ 1.24.0	JA	proxy_connect_rewrite_102101.patch
1.25.0 ~ 1.26.x	JA	proxy_connect_rewrite_102101.patch
1.27.1	JA	proxy_connect_rewrite_102101.patch

OpenResty-Version	REWRITE-Phase aktivieren	Patch
1.13.6	NEIN	proxy_connect_1014.patch
1.13.6	JA	proxy_connect_rewrite_1014.patch
1.15.8	JA	proxy_connect_rewrite_101504.patch
1.17.8	JA	proxy_connect_rewrite_1018.patch
1.19.3	JA	proxy_connect_rewrite_1018.patch
1.21.4	JA	proxy_connect_rewrite_102101.patch
1.25.3	JA	proxy_connect_rewrite_102101.patch

proxy_connect_<VERSION>.patch deaktiviert die nginx REWRITE-Phase für die CONNECT-Anfrage standardmäßig, was bedeutet, dass if, set, rewrite_by_lua und andere REWRITE-Phasendirektiven nicht verwendet werden können.
proxy_connect_rewrite_<VERSION>.patch aktiviert diese REWRITE-Phasendirektiven.

NGINX bauen

Bauen Sie nginx mit diesem Modul aus dem Quellcode:

$ wget http://nginx.org/download/nginx-1.9.2.tar.gz
$ tar -xzvf nginx-1.9.2.tar.gz
$ cd nginx-1.9.2/
$ patch -p1 < /path/to/ngx_http_proxy_connect_module/patch/proxy_connect.patch
$ ./configure --add-module=/path/to/ngx_http_proxy_connect_module
$ make && make install

Als dynamisches Modul bauen

Ab nginx 1.9.11 können Sie dieses Modul auch als dynamisches Modul kompilieren, indem Sie die Option --add-dynamic-module=PATH anstelle von --add-module=PATH in der ./configure-Befehlszeile verwenden.

$ wget http://nginx.org/download/nginx-1.9.12.tar.gz
$ tar -xzvf nginx-1.9.12.tar.gz
$ cd nginx-1.9.12/
$ patch -p1 < /path/to/ngx_http_proxy_connect_module/patch/proxy_connect.patch
$ ./configure --add-dynamic-module=/path/to/ngx_http_proxy_connect_module
$ make && make install

Und dann können Sie das Modul explizit in Ihrer nginx.conf über die load_module-Direktive laden, zum Beispiel:

load_module /path/to/modules/ngx_http_proxy_connect_module.so;

Beachten Sie, dass die Datei ngx_http_proxy_connect_module.so VON dem nginx-Binärprogramm geladen werden MUSS, das gleichzeitig mit der .so-Datei kompiliert wurde.

OpenResty bauen

Bauen Sie OpenResty mit diesem Modul aus dem Quellcode:

$ wget https://openresty.org/download/openresty-1.19.3.1.tar.gz
$ tar -zxvf openresty-1.19.3.1.tar.gz
$ cd openresty-1.19.3.1
$ ./configure --add-module=/path/to/ngx_http_proxy_connect_module
$ patch -d build/nginx-1.19.3/ -p 1 < /path/to/ngx_http_proxy_connect_module/patch/proxy_connect_rewrite_101504.patch
$ make && make install

Test Suite

Um die gesamte Test-Suite auszuführen:

$ hg clone http://hg.nginx.org/nginx-tests/

## Wenn Sie das neueste lua-nginx-Modul verwenden, das lua-resty-core und
## lua-resty-lrucache benötigt, sollten Sie die Direktive "lua_package_path ...;" 
## in die nginx.conf der Testfälle einfügen. Sie können den folgenden Befehl verwenden:
#
## $ export TEST_NGINX_GLOBALS_HTTP='lua_package_path "/path/to/nginx/lib/lua/?.lua;;";'

$ export TEST_NGINX_BINARY=/path/to/nginx/binary
$ prove -v -I /path/to/nginx-tests/lib /path/to/ngx_http_proxy_connect_module/t/

Für den vollständigen Prozess des Bauens und Testens dieses Moduls siehe:
Workflow-Dateien: hier
Ausführungen aller Workflows: hier

Fehlerprotokoll

Dieses Modul protokolliert seine eigenen Fehlermeldungen, die mit dem String "proxy_connect:" beginnen.
Einige typische Fehlerprotokolle werden wie folgt angezeigt:

Das proxy_connect-Modul versucht, eine Tunnelverbindung mit dem Backend-Server herzustellen, aber der TCP-Verbindungszeitüberschreitung tritt auf.

2019/08/07 17:27:20 [error] 19257#0: *1 proxy_connect: upstream connect timed out (peer:216.58.200.4:443) while connecting to upstream, client: 127.0.0.1, server: , request: "CONNECT www.google.com:443 HTTP/1.1", host: "www.google.com:443"

Direktive

proxy_connect

Syntax: proxy_connect
Standard: none
Kontext: server

Aktiviert die Unterstützung für die "CONNECT"-HTTP-Methode.

proxy_connect_allow

Syntax: proxy_connect_allow all | [port ...] | [port-range ...]
Standard: 443 563
Kontext: server

Diese Direktive gibt eine Liste von Portnummern oder -bereichen an, zu denen die Proxy-CONNECT-Methode eine Verbindung herstellen darf.
Standardmäßig sind nur der Standard-HTTPS-Port (443) und der Standard-Snews-Port (563) aktiviert.
Die Verwendung dieser Direktive überschreibt diesen Standard und erlaubt Verbindungen nur zu den aufgeführten Ports.

Der Wert all erlaubt alle Ports für das Proxying.

Der Wert port erlaubt den angegebenen Port für das Proxying.

Der Wert port-range erlaubt den angegebenen Bereich von Ports für das Proxying, zum Beispiel:

proxy_connect_allow 1000-2000 3000-4000; # Erlaubt den Bereich von Ports von 1000 bis 2000, von 3000 bis 4000.

proxy_connect_connect_timeout

Syntax: proxy_connect_connect_timeout time
Standard: none
Kontext: server

Definiert einen Timeout für die Herstellung einer Verbindung mit einem proxied Server.

proxy_connect_data_timeout

Syntax: proxy_connect_data_timeout time
Standard: 60s
Kontext: server

Setzt den Timeout zwischen zwei aufeinanderfolgenden Lese- oder Schreiboperationen an Client- oder proxied Serververbindungen. Wenn innerhalb dieser Zeit keine Daten übertragen werden, wird die Verbindung geschlossen.

proxy_connect_read_timeout

Syntax: proxy_connect_read_timeout time
Standard: 60s
Kontext: server

Veraltet.

Es hat die gleiche Funktion wie die Direktive proxy_connect_data_timeout zur Kompatibilität. Sie können nur eine der Direktiven (proxy_connect_data_timeout oder proxy_connect_read_timeout) konfigurieren.

proxy_connect_send_timeout

Syntax: proxy_connect_send_timeout time
Standard: 60s
Kontext: server

Veraltet.

Es hat keine Funktion.

proxy_connect_address

Syntax: proxy_connect_address address | off
Standard: none
Kontext: server

Gibt eine IP-Adresse des proxied Servers an. Die Adresse kann Variablen enthalten.
Der spezielle Wert off entspricht none, was die IP-Adresse verwendet, die aus dem Hostnamen der CONNECT-Anforderungszeile aufgelöst wurde.

HINWEIS: Wenn Sie set $<nginx variable> und proxy_connect_address $<nginx variable> zusammen verwenden, sollten Sie stattdessen proxy_connect_rewrite.patch verwenden. Siehe Installieren für weitere Details.

proxy_connect_bind

Syntax: proxy_connect_bind address [transparent] | off
Standard: none
Kontext: server

Lässt ausgehende Verbindungen zu einem proxied Server von der angegebenen lokalen IP-Adresse mit einem optionalen Port ausgehen.
Der Parameterwert kann Variablen enthalten. Der spezielle Wert off entspricht none, was es dem System ermöglicht, die lokale IP-Adresse und den Port automatisch zuzuweisen.

Der Parameter transparent ermöglicht es, dass ausgehende Verbindungen zu einem proxied Server von einer nicht lokalen IP-Adresse ausgehen, zum Beispiel von einer echten IP-Adresse eines Clients:

proxy_connect_bind $remote_addr transparent;

Damit dieser Parameter funktioniert, ist es normalerweise erforderlich, die nginx-Worker-Prozesse mit den Superuser-Rechten auszuführen. Unter Linux ist dies nicht erforderlich (1.13.8), da, wenn der transparente Parameter angegeben ist, die Worker-Prozesse die CAP_NET_RAW-Fähigkeit vom Masterprozess erben. Es ist auch erforderlich, die Kernel-Routing-Tabelle so zu konfigurieren, dass der Netzwerkverkehr vom proxied Server abgefangen wird.

HINWEIS: Wenn Sie set $<nginx variable> und proxy_connect_bind $<nginx variable> zusammen verwenden, sollten Sie stattdessen proxy_connect_rewrite.patch verwenden. Siehe Installieren für weitere Details.

proxy_connect_response

Syntax: proxy_connect_response CONNECT response
Standard: HTTP/1.1 200 Connection Established\r\nProxy-agent: nginx\r\n\r\n
Kontext: server

Setzt die Antwort der CONNECT-Anfrage.

Beachten Sie, dass es nur für die CONNECT-Anfrage verwendet wird und den Datenfluss über den CONNECT-Tunnel nicht ändern kann.

Zum Beispiel:

proxy_connect_response "HTTP/1.1 200 Connection Established\r\nProxy-agent: nginx\r\nX-Proxy-Connected-Addr: $connect_addr\r\n\r\n";

Der curl-Befehlstestfall mit der obigen Konfiguration sieht wie folgt aus:

$ curl https://github.com -sv -x localhost:3128
* Verbunden mit localhost (127.0.0.1) Port 3128 (#0)
* Verbindungsbuffer zuweisen!
* HTTP-Proxy-Tunnel zu github.com:443 herstellen
> CONNECT github.com:443 HTTP/1.1
> Host: github.com:443
> User-Agent: curl/7.64.1
> Proxy-Connection: Keep-Alive
>
< HTTP/1.1 200 Connection Established            --.
< Proxy-agent: nginx                               | benutzerdefinierte CONNECT-Antwort
< X-Proxy-Connected-Addr: 13.229.188.59:443      --'
...

Variablen

$connect_host

Hostname aus der CONNECT-Anforderungszeile.

$connect_port

Port aus der CONNECT-Anforderungszeile.

$connect_addr

IP-Adresse und Port des Remote-Hosts, z.B. "192.168.1.5:12345".
Die IP-Adresse wird aus dem Hostnamen der CONNECT-Anforderungszeile aufgelöst.

$proxy_connect_connect_timeout

Erhalten oder setzen Sie den Timeout der proxy_connect_connect_timeout-Direktive.

Zum Beispiel:

## Standardwert setzen

proxy_connect_connect_timeout   10s;
proxy_connect_data_timeout      10s;

## Standardwert überschreiben

if ($host = "test.com") {
    set $proxy_connect_connect_timeout  "10ms";
    set $proxy_connect_data_timeout     "10ms";
}

$proxy_connect_data_timeout

Erhalten oder setzen Sie einen Timeout der proxy_connect_data_timeout-Direktive.

$proxy_connect_read_timeout

Veraltet. Es kann weiterhin einen Timeout der proxy_connect_data_timeout-Direktive für die Kompatibilität erhalten oder setzen.

$proxy_connect_send_timeout

Veraltet. Es hat keine Funktion.

$proxy_connect_resolve_time

Hält die Zeit, die für die Namensauflösung benötigt wurde; die Zeit wird in Sekunden mit Millisekundenauflösung gespeichert.

Der Wert von "" bedeutet, dass dieses Modul bei dieser Anfrage nicht funktioniert.
Der Wert von "-" bedeutet, dass die Namensauflösung fehlgeschlagen ist.

$proxy_connect_connect_time

Hält die Zeit, die für die Herstellung einer Verbindung mit dem Upstream-Server benötigt wurde; die Zeit wird in Sekunden mit Millisekundenauflösung gespeichert.

Der Wert von "" bedeutet, dass dieses Modul bei dieser Anfrage nicht funktioniert.
Der Wert von "-" bedeutet, dass die Namensauflösung oder die Verbindung fehlgeschlagen ist.

$proxy_connect_first_byte_time

Hält die Zeit, um das erste Byte Daten vom Upstream-Server zu empfangen; die Zeit wird in Sekunden mit Millisekundenauflösung gespeichert.

Der Wert von "" bedeutet, dass dieses Modul bei dieser Anfrage nicht funktioniert.
Der Wert von "-" bedeutet, dass die Namensauflösung, die Verbindung oder der Empfang fehlgeschlagen ist.

$proxy_connect_response

Erhalten oder setzen Sie die Antwort der CONNECT-Anfrage.
Die Standardantwort der CONNECT-Anfrage ist "HTTP/1.1 200 Connection Established\r\nProxy-agent: nginx\r\n\r\n".

Beachten Sie, dass es nur für die CONNECT-Anfrage verwendet wird und den Datenfluss über den CONNECT-Tunnel nicht ändern kann.

Zum Beispiel:

## Standard-Proxy-Agent-Header ändern
set $proxy_connect_response "HTTP/1.1 200\r\nProxy-agent: nginx/1.19\r\n\r\n";

Der Variablenwert unterstützt keine nginx-Variablen. Sie können das lua-nginx-Modul verwenden, um einen String zu erstellen, der eine nginx-Variable enthält. Zum Beispiel:

## Die CONNECT-Antwort kann "HTTP/1.1 200\r\nProxy-agent: nginx/1.19.6\r\n\r\n" sein

rewrite_by_lua '
    ngx.var.proxy_connect_response =
      string.format("HTTP/1.1 200\\r\\nProxy-agent: nginx/%s\\r\\n\\r\\n", ngx.var.nginx_version)
';

Beachten Sie auch, dass die Direktive set oder rewrite_by_lua* während der REWRITE-Phase ausgeführt wird, die vor der DNS-Auflösungsphase liegt. Sie kann den richtigen Wert einiger Variablen nicht erhalten, zum Beispiel ist der Wert von $connect_addr nil. In diesem Fall sollten Sie stattdessen die proxy_connect_response-Direktive verwenden.

Kompatibilität

NGINX-Kompatibilität

Das neueste Modul ist mit den folgenden Versionen von nginx kompatibel:

1.27.1 (Hauptversion 1.27.x)
1.26.2 (Version 1.26.x)
1.24.0 (Version 1.24.x)
1.22.1 (Version 1.22.x)
1.20.2 (Version 1.20.x)
1.18.0 (Version 1.18.x)
1.16.1 (Version 1.16.x)
1.14.2 (Version 1.14.x)
1.12.1 (Version 1.12.x)
1.10.3 (Version 1.10.x)
1.8.1 (Version 1.8.x)
1.6.3 (Version 1.6.x)
1.4.7 (Version 1.4.x)

OpenResty-Kompatibilität

Das neueste Modul ist mit den folgenden Versionen von OpenResty kompatibel:

1.25.3 (Version: 1.25.3.1)
1.21.4 (Version: 1.21.4.3)
1.19.3 (Version: 1.19.3.1)
1.17.8 (Version: 1.17.8.2)
1.15.8 (Version: 1.15.8.1)
1.13.6 (Version: 1.13.6.2)

Tengine-Kompatibilität

Dieses Modul wurde in Tengine 2.3.0 integriert.

FAQ

Siehe FAQ-Seite.

Bekannte Probleme

In HTTP/2 wird die CONNECT-Methode nicht unterstützt. Sie unterstützt nur die CONNECT-Anforderungsmethode in HTTP/1.x und HTTPS.

Siehe auch

Autor

Peng Qi: ursprünglicher Autor. Er hat dieses Modul zu Tengine in diesem Pull-Request beigetragen.
Xiaochen Wang: aktueller Maintainer. Hat dieses Modul für nginx neu aufgebaut.

LIZENZ

Siehe LIZENZ für Details.

GitHub

Sie finden möglicherweise zusätzliche Konfigurationstipps und Dokumentationen für dieses Modul im GitHub-Repository für nginx-module-proxy-connect.