--- title: "Node Unblocker: Was es ist und wie Sie es sicher einrichten" description: "Node Unblocker ist eine Express-Middleware, die aus einem Node.js-Server einen URL-umschreibenden Web-Proxy macht. Funktionsweise, getesteter Code, Absicherung." url: https://proxynet.io/de/blog/node-unblocker date: 2026-10-11 author: "Acar Diveroli" category: "Anleitungen, Proxy 101" lang: de --- # Node Unblocker: Was es ist und wie Sie es sicher einrichten Sie starten eine kleine Express-App, öffnen `http://127.0.0.1:8080/proxy/https://example.com/` im Browser, und die Seite erscheint unter der Adresse Ihres eigenen Servers. Ihre Links, Bilder und Formulare beginnen jetzt mit `/proxy/`, sodass jeder Klick wieder über Ihren Server läuft. Das ist Node Unblocker, das Paket `unblocker` auf npm: ein paar Zeilen, die aus einem Node.js-Server einen Web-Proxy machen, den jeder mit einem normalen Browser nutzen kann. Ungeschützt lassen dieselben Zeilen auch Fremde über Ihren Server surfen; unsere erste Testinstanz rief eine Admin-Seite ab, die ein lokaler Dienst nur `127.0.0.1` zeigte. Dieser Artikel zeigt, wie das Paket funktioniert, einen minimalen Server, einen abgesicherten Server, der Fremde und interne Adressen fernhält, einen Upstream-Proxy für den ausgehenden Verkehr und die Grenzen des Pakets. Alle Beispiele liefen am 11. Oktober 2026 mit unblocker 2.3.1, Express 4.22.3 und Node.js 24.11.1 gegen eine lokale Testseite, einen WebSocket-Echo-Server und einen Test-Proxy, der Benutzername und Passwort verlangt. > **Hinweis: Kurzantwort** > > Node Unblocker (`unblocker` auf npm) ist eine Express-kompatible Middleware, die aus einem Node.js-Server einen Web-Proxy macht. Ein Besucher öffnet `/proxy/https://site.example/`, der Server ruft die Seite ab, schreibt ihre Links, Cookies und Weiterleitungen so um, dass sie wieder auf `/proxy/` zeigen, und streamt sie an den Browser. Die Website sieht die IP Ihres Servers, nicht die des Besuchers. Stellen Sie einen solchen Server nie ohne Login, ohne Allowlist erlaubter Websites und ohne Sperre für private Adressen ins Netz, sonst kann jeder seinen Verkehr über Ihren Server leiten. ## Was ist Node Unblocker? Node Unblocker ist eine Open-Source-Bibliothek für Node.js von Nathan Friedly, auf npm als `unblocker` veröffentlicht. Am 11. Oktober 2026 war 2.3.1 vom Juni 2024 die neueste Version; sie braucht Node.js 16.17 oder neuer und steht unter der AGPL-3.0. Die [README auf GitHub](https://github.com/nfriedly/node-unblocker) beschreibt das Paket als Allzweckbibliothek, die entfernte Webseiten über einen Proxy lädt und umschreibt. Es ist ein Web-Proxy: eine Website, die andere Websites für Sie lädt. Der Besucher ändert keine Einstellungen und braucht nur die Adresse Ihres Servers. Ein HTTP- oder SOCKS5-Proxy wird dagegen in einer App oder im Betriebssystem eingetragen und leitet den Verkehr unverändert weiter. Node Unblocker verarbeitet nur Webseiten und WebSockets, und es hat genau einen Ausgang: die IP des Rechners, auf dem es läuft. Läuft es auf Ihrem Laptop, sieht die Website die IP Ihres Heimanschlusses. ## Wie funktioniert Node Unblocker? Jede Anfrage, deren Pfad mit dem Präfix beginnt (standardmäßig `/proxy/`), durchläuft diese Schritte: 1. **Der Browser fragt eine Proxy-URL an**, etwa `GET /proxy/https://example.com/`. Alles nach dem Präfix ist das Ziel. Eine URL ohne Schema wie `/proxy/example.com` erhält ein `307` auf `/proxy/http://example.com/`. 2. **Die Request-Middleware läuft.** Eingebaute Funktionen korrigieren die Header `Host` und `Referer`, die Komprimierung und die Cookies. Danach laufen Ihre eigenen `requestMiddleware`-Funktionen; Zugriffsprüfungen gehören hierher. 3. **Ihr Server verbindet sich mit dem Ziel**, mit den Headern des Browsers und über `httpAgent` oder `httpsAgent`, falls Sie einen gesetzt haben. Das Ziel sieht die IP Ihres Servers. 4. **Die Response-Middleware bearbeitet die Antwort.** Sie entfernt die Header `Content-Security-Policy`, `Strict-Transport-Security` und `Public-Key-Pins`, schreibt Weiterleitungen und URLs in HTML und CSS um, verschiebt Cookies auf den Pfad `/proxy//`, fügt ein Skript ein und ergänzt ein Robots-Tag `NOINDEX, NOFOLLOW`. 5. **Die Seite wird zurückgestreamt**, Stück für Stück. 6. **Verpasste Links werden aufgefangen.** Eine root-relative Anfrage wie `/about` kommt ohne Präfix an; Node Unblocker liest den `Referer` und antwortet mit einem `307` auf die vollständige Proxy-URL. Das eingefügte Skript umhüllt `fetch`, `XMLHttpRequest`, WebSocket, neue Elemente und Änderungen der Browser-History, sodass auch Adressen, die JavaScript zusammensetzt, das Präfix erhalten. JavaScript-Dateien selbst werden nicht umgeschrieben. Unsere Testseite mit einem absoluten, einem root-relativen und einem relativen Link, einem protokollrelativen Bild und einem Formular kam so zurück: ```text set-cookie: session=abc123; Path=/proxy/http://127.0.0.1:9000/; HttpOnly Test page absolute root-relative relative
``` Der relative Link zeigt bereits in den Proxy-Pfad, deshalb bleibt er, wie er ist. Die Header `Content-Security-Policy` und `Strict-Transport-Security` der Seite erreichten den Browser nie. ## Wie unterscheidet es sich von einem Forward- oder Reverse-Proxy? Alle drei stehen zwischen einem Browser und einer Website. Sie unterscheiden sich darin, wer sie einrichtet und ob sie die Seite verändern. | | Node Unblocker | Forward-Proxy | Reverse-Proxy | |---|---|---|---| | Nutzung | Eine `/proxy/`-URL öffnen | host:port in App oder Betriebssystem eintragen | Die eigene Adresse der Website aufrufen | | Eingerichtet von | Wer den Server betreibt | Nutzer oder deren Firma | Websitebetreiber | | Verändert die Seite | Ja: Links, Cookies, Weiterleitungen | Nein | Meist nicht | | HTTPS | Auf Ihrem Server entschlüsselt | Getunnelt, bleibt verschlüsselt | Vom Websitebetreiber entschlüsselt | | Verkehr | Webseiten und WebSockets | Jedes HTTP; SOCKS5 auch UDP | HTTP(S) zu den Servern der Website | Ein Forward-Proxy bedient jede App mit einer Proxy-Einstellung und muss die Seite nie verstehen. Ein Reverse-Proxy wie nginx steht vor Ihrer eigenen Website; [Forward-Proxy und Reverse-Proxy: Was ist der Unterschied?](/de/blog/forward-vs-reverse-proxy) erklärt beide. Node Unblocker fällt aus der Reihe: ein umschreibender Proxy für Browser, deren Einstellungen sich nicht ändern lassen oder nicht geändert werden sollen. ## Wie richten Sie einen minimalen Node-Unblocker-Server ein? Installieren Sie in einem leeren Ordner Express und das Paket, und speichern Sie den Code dann als `server.mjs`: ```bash npm install express unblocker ``` ```js import express from "express"; import Unblocker from "unblocker"; const app = express(); const unblocker = new Unblocker({ prefix: "/proxy/" }); // Unblocker muss einer der ersten app.use()-Aufrufe sein und an der Wurzel sitzen, nicht unter einem Unterpfad app.use(unblocker); app.get("/", (req, res) => res.send("Open /proxy/https://example.com/")); // Der upgrade-Listener lässt Unblocker WebSocket-Verbindungen weiterreichen app.listen(8080, "127.0.0.1").on("upgrade", unblocker.onUpgrade); ``` Starten Sie `node server.mjs` und öffnen Sie `http://127.0.0.1:8080/proxy/https://example.com/`. Laut README darf die Middleware nicht unter einem Unterpfad hängen, und `/` als Präfix führt zu Randfällen. Ohne den `upgrade`-Listener können Chats und Live-Dashboards auf Seiten, die durch den Proxy laufen, keine Verbindung aufbauen. Der Server lauscht auf `127.0.0.1`, also erreicht ihn nur Ihr eigener Computer; lassen Sie es dabei. In unserem Test lud er Seiten, schrieb eine `302`-Weiterleitung um, reichte ein Formular-`POST` weiter und lieferte die Nachrichten des WebSocket-Echo-Servers zurück. Er rief aber auch `/proxy/http://127.0.0.1:9000/admin` ab, eine Seite, die unser Testdienst nur demselben Rechner zeigt: ```text INTERNAL ADMIN PAGE - only for 127.0.0.1 ``` **Express 5.** Das Paket hängt von Express 4 ab, deshalb haben wir den Test mit Express 5.3.0 wiederholt. Seiten, Weiterleitungen, Formulare und WebSockets funktionierten genauso; npm legte eine eigene Kopie von Express 4 im Paket ab. ## Warum ist ein offener Node-Unblocker-Server gefährlich? Über einen offenen Server kann jeder Verkehr von Ihrer IP aus senden und Stellen erreichen, die nur Ihr Server erreicht: - **Ihre IP bekommt die Schuld.** Formularspam und Brute-Force-Logins, die darüber laufen, kommen von Ihrer Adresse. Websites sperren sie oder beschweren sich bei Ihrem Hoster, der den Server dann abschalten kann. - **Ihr internes Netz wird erreichbar.** Das ist Server-Side Request Forgery (SSRF): Ein Außenstehender bringt Ihren Server dazu, eine Adresse abzurufen, die er selbst nicht erreicht. Auf einem Cloud-Server ist das klassische Ziel `169.254.169.254`, wo der Metadatendienst Zugangsdaten ausgibt. Das [OWASP SSRF Prevention Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Server_Side_Request_Forgery_Prevention_Cheat_Sheet.html) empfiehlt eine Allowlist der Ziele und eine Prüfung der IP, zu der jeder Name aufgelöst wird. - **Der Server liest alles mit.** HTTPS endet auf Ihrem Server, weil er Seiten lesen muss, um sie umzuschreiben; Passwörter, die auf Websites hinter dem Proxy eingegeben werden, laufen daher im Klartext über ihn. - **Alle Websites teilen sich denselben Origin.** Websites hinter dem Proxy trennt nur der Cookie-Pfad, und [MDN weist darauf hin](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Set-Cookie), dass `Path` keine Sicherheitsmaßnahme ist. Ein Skript auf einer dieser Seiten kann die Cookies einer anderen Website lesen, sofern sie kein `HttpOnly` tragen. Ein Web-Proxy verleiht auch niemandem neue Rechte. Wer damit einen Schul- oder Firmenfilter oder die Nutzungsbedingungen einer Website umgeht, verstößt weiterhin gegen diese Regeln, und die `robots.txt` und Rate Limits einer Website gelten für Ihren Server wie für jeden anderen Besucher. ## Wie sichern Sie einen Node-Unblocker-Server ab? Behandeln Sie ihn als internes Werkzeug für namentlich bekannte Personen und eine kurze Liste von Websites. Die abgesicherte Version ergänzt: 1. **Ein Login:** ein gemeinsames HTTP-Basic-Login für das Team, in konstanter Zeit verglichen. 2. **Eine Host-Allowlist**, nur auf den Ports 80 und 443, geprüft in `requestMiddleware`. 3. **Eine Prüfung jeder DNS-Antwort** im `lookup` der Agents, denn jede Domain kann auf `127.0.0.1` zeigen. [`net.BlockList`](https://nodejs.org/api/net.html#class-netblocklist) von Node enthält die privaten Bereiche und erkennt auch IPv4-Adressen in IPv6-Schreibweise. 4. **Entfernte Header**, damit der `Authorization`-Header des Teams und die Client-IP in `X-Forwarded-For` nie die Website erreichen. 5. **Ein WebSocket-Schutz**, weil Upgrade-Anfragen die Express-Middleware überspringen. 6. **Ein Rate Limit, eine Logzeile und eine schlichte Fehlerseite.** ```bash npm install express unblocker express-rate-limit ``` Ersetzen Sie dann `server.mjs` durch diese Version: ```js import crypto from "node:crypto"; import dns from "node:dns"; import http from "node:http"; import https from "node:https"; import net from "node:net"; import express from "express"; import { rateLimit } from "express-rate-limit"; import Unblocker from "unblocker"; const { UI_USER, UI_PASS, PORT = "8080" } = process.env; if (!UI_USER || !UI_PASS) throw new Error("Set UI_USER and UI_PASS"); const ALLOWED = ["example.com", "iana.org"]; // Websites, die Ihr Team öffnen darf (inklusive Subdomains) // 1. Adressbereiche, mit denen sich der Proxy nie verbinden darf (Loopback, privat, Link-Local, Cloud-Metadaten) const blocked = new net.BlockList(); for (const [range, bits] of [["0.0.0.0", 8], ["10.0.0.0", 8], ["100.64.0.0", 10], ["127.0.0.0", 8], ["169.254.0.0", 16], ["172.16.0.0", 12], ["192.168.0.0", 16]]) blocked.addSubnet(range, bits); blocked.addAddress("::1", "ipv6"); blocked.addSubnet("fc00::", 7, "ipv6"); blocked.addSubnet("fe80::", 10, "ipv6"); const isBlockedIp = (ip) => blocked.check(ip, net.isIPv6(ip) ? "ipv6" : "ipv4"); // 2. Jede DNS-Antwort prüfen, bevor ein Socket öffnet, damit kein erlaubter Name in Ihr Netz zeigt function safeLookup(hostname, options, callback) { dns.lookup(hostname, options, (err, address, family) => { if (err) return callback(err); const answers = Array.isArray(address) ? address : [{ address, family }]; if (answers.some((a) => isBlockedIp(a.address))) { return callback(new Error(`${hostname} resolves to a blocked address`)); } callback(null, address, family); }); } // 3. Nur Hosts aus der Allowlist auf den Standardports 80/443 function isAllowed(target) { const { hostname, port } = new URL(target); return port === "" && ALLOWED.some((h) => hostname === h || hostname.endsWith(`.${h}`)); } // Header, die die Website nicht sehen darf: das Team-Login und die vom Reverse-Proxy ergänzte Client-IP const STRIP = ["authorization", "forwarded", "x-forwarded-for", "x-forwarded-host", "x-forwarded-proto", "x-real-ip"]; function checkTarget(data) { const ok = isAllowed(data.url); console.log(new Date().toISOString(), ok ? "ALLOW" : "DENY", data.url); if (ok) { for (const h of STRIP) delete data.headers[h]; return; } if (data.clientResponse) return data.clientResponse.status(403).send("This site is not on the allowlist."); throw new Error("Blocked WebSocket target"); // Upgrade-Anfragen haben kein Antwortobjekt } // 4. Ein gemeinsames Login für das Team (HTTP Basic), in konstanter Zeit verglichen const hash = (s) => crypto.createHash("sha256").update(s).digest(); function loginOk(req) { const [scheme, value = ""] = (req.headers.authorization ?? "").split(" "); const given = Buffer.from(value, "base64").toString(); return scheme === "Basic" && crypto.timingSafeEqual(hash(given), hash(`${UI_USER}:${UI_PASS}`)); } const unblocker = new Unblocker({ prefix: "/proxy/", requestMiddleware: [checkTarget], httpAgent: new http.Agent({ lookup: safeLookup }), httpsAgent: new https.Agent({ lookup: safeLookup }), }); const app = express(); app.set("trust proxy", "loopback"); // der Reverse-Proxy auf diesem Rechner reicht die echte Client-IP durch app.use(rateLimit({ windowMs: 60_000, limit: 600 })); // ein Seitenaufruf kann Dutzende Dateien laden app.use((req, res, next) => { if (loginOk(req)) return next(); res.set("WWW-Authenticate", 'Basic realm="preview"').status(401).send("Login required"); }); app.use(unblocker); app.get("/", (req, res) => res.send("Open /proxy/https://example.com/")); app.use((err, req, res, next) => { console.error(err.message); res.status(502).send("The site could not be loaded."); }); // Nur auf Loopback lauschen: HTTPS und der öffentliche Port gehören zum vorgeschalteten Reverse-Proxy const server = app.listen(Number(PORT), "127.0.0.1"); // Express-Middleware läuft bei WebSocket-Upgrades nicht, daher das Login auch hier prüfen server.on("upgrade", (req, socket, head) => { if (!loginOk(req)) return socket.destroy(); try { unblocker.onUpgrade(req, socket, head); } catch { socket.destroy(); } }); ``` Starten Sie ihn mit dem Login in Umgebungsvariablen: `UI_USER=team UI_PASS='ein-langes-geheimes-passwort' node server.mjs`. Unsere Ergebnisse: - Ohne Login lieferte jeder Pfad `401` mit einem Header `WWW-Authenticate: Basic`. - `example.com` und `www.iana.org` luden. `example.org`, `evilexample.com`, `example.com:8443`, `127.0.0.1:9000` und `169.254.169.254` erhielten `403`. - Als wir `localtest.me`, eine öffentliche Domain, die auf `127.0.0.1` auflöst, in die Allowlist einer Testkopie aufnahmen, erhielt die Anfrage `502`, und das Log meldete `localtest.me resolves to a blocked address`. - Ein WebSocket ohne Login wurde geschlossen. Mit Login wurde einer zu unserem lokalen Echo-Server als `DENY` protokolliert und geschlossen; einer zum freigegebenen `echo.websocket.org` funktionierte. - Sobald innerhalb einer Minute 600 Anfragen eingegangen waren, erhielten die folgenden `429 Too Many Requests` mit `Retry-After: 59`. Zwei dieser Schutzmaßnahmen gibt es, weil die naheliegende Version scheiterte. Das Allowlist-Beispiel der README lehnt mit `data.clientResponse.status(403)` ab; ein WebSocket-Upgrade hat kein Antwortobjekt, und unser Server stürzte mit `TypeError: Cannot read properties of null (reading 'status')` ab. Mit einer Null-Prüfung überlebte er, doch der WebSocket erreichte das gesperrte Ziel trotzdem ohne Login. Erst Werfen und Abfangen im Upgrade-Handler stoppt ihn. Und bevor wir `STRIP` ergänzt hatten, sah unser Test-Proxy den `Authorization: Basic`-Header des Teams und einen Testwert in `X-Forwarded-For` auf dem Weg zur Website. Setzen Sie HTTPS davor, mit nginx oder Caddy auf demselben Rechner; `trust proxy` mit dem Wert `loopback` gibt Express und dem Rate Limiter dann die echte Client-IP. Für nginx empfiehlt die README `merge_slashes off;`, damit das `//` in `/proxy/https://` erhalten bleibt. Behalten Sie die Logzeilen `ALLOW` und `DENY`; mit ihnen können Sie einer Website antworten, die wissen will, was Ihr Server getan hat. ## Wie leiten Sie den Verkehr von Node Unblocker über einen Upstream-Proxy? Die Optionen `httpAgent` und `httpsAgent` akzeptieren jeden Node.js-Agent, also verlegt ein Proxy-Agent Ihren Ausgang zum Proxy. Installieren Sie `http-proxy-agent` und `https-proxy-agent` und ersetzen Sie dann die beiden Agent-Zeilen des abgesicherten Servers: ```bash npm install http-proxy-agent https-proxy-agent ``` ```js import { HttpProxyAgent } from "http-proxy-agent"; import { HttpsProxyAgent } from "https-proxy-agent"; const UPSTREAM = process.env.UPSTREAM_PROXY; // http://user:pass@pr.proxynet.io:8000 const unblocker = new Unblocker({ prefix: "/proxy/", requestMiddleware: [checkTarget], httpAgent: new HttpProxyAgent(UPSTREAM), // http://-Ziele: Anfragen mit absoluter URI an den Proxy httpsAgent: new HttpsProxyAgent(UPSTREAM), // https://-Ziele: ein CONNECT-Tunnel durch den Proxy }); ``` Unser Test-Proxy verlangt `user:pass` und protokollierte eine Zeile pro Ziel: ```text [test-proxy] CONNECT example.com:443 auth=user [test-proxy] GET http://example.com/ auth=user fwd-authorization=- x-forwarded-for=- ``` Die HTTPS-Seite lief durch einen `CONNECT`-Tunnel, der Proxy sah also nur den Hostnamen; die Striche zeigen, dass die entfernten Header zurückblieben. Mit falschem Passwort lieferten beide Seiten das `407 Proxy Authentication Required` des Proxys. Kodieren Sie `@`, `:` oder `/` im Passwort mit `encodeURIComponent`. Dieselben Agents mit Axios, node-fetch und undici behandelt [Proxys in Node.js verwenden: Axios und node-fetch](/de/blog/nodejs-proxy). Mit einem Upstream läuft `safeLookup` nicht mehr, weil der Proxy Namen in seinem eigenen Netz auflöst; halten Sie die Allowlist deshalb streng. Sie können auch auf das Passwort verzichten: Tragen Sie die öffentliche IP Ihres Servers im Dashboard in die IP-Whitelist ein (bis zu 10 Adressen). [Proxy-Authentifizierung: User:Pass oder IP-Whitelist](/de/blog/proxy-authentication-methods) vergleicht beide Wege. Ein [Datacenter-Proxy](https://proxynet.io/de/datacenter-proxy) gibt dem Team eine feste Ausgangs-IP mit Traffic ohne Kontingent. Bei Proxys, die pro IP abgerechnet werden, ist der Zugriff auf ausgewählte Zielwebsites enthalten, der Zugriff auf alle Websites ist ein kostenpflichtiges Add-on; prüfen Sie also, ob die Websites Ihrer Allowlist abgedeckt sind. Um eine Seite für einen Lokalisierungscheck so zu sehen, wie ein Besucher mit Heimanschluss in einem anderen Land sie sieht, nutzen Sie einen [Residential-Proxy](https://proxynet.io/de/residential-proxy) mit einem Ausgang, den Sie nach Land und Stadt wählen. Eine Sticky-Sitzung von 1 bis 60 Minuten hält denselben Ausgang über einen ganzen Ablauf. ## Was kann Node Unblocker nicht? Am besten funktioniert es bei gewöhnlichen Seiten, die größtenteils auf dem Server gerendert werden. Zum Rest äußert sich die README deutlich: - **OAuth-Anmeldung und `postMessage`.** Logins über das Fenster eines anderen Anbieters funktionieren wahrscheinlich nicht. - **Große Single-Page-Apps.** Die README nennt mehrere bekannte Chat-, Video- und Social-Media-Plattformen, die nicht funktionieren. Das Client-Skript umhüllt die üblichen Request-APIs, aber `window.location`, `document.cookie` und `postMessage` stehen noch auf seiner To-do-Liste. - **Alles, was keine Webseite ist.** Desktop-Apps, Mailprogramme und Kommandozeilenwerkzeuge brauchen einen Forward-Proxy. - **Langsame Pflege.** Die Version vom Juni 2024 war im Oktober 2026 noch die neueste. Die Middleware-Dateien in `lib/` sind kurz; lesen Sie sie, bevor Sie sich auf das Paket verlassen. ## Anwendungsfälle - Ein internes Vorschau-Werkzeug für ein QA- oder Lokalisierungsteam, das die eigenen Seiten des Unternehmens über einen Residential-Ausgang im Zielland öffnet. - Ein reiner Browser-Kiosk, der seine Proxy-Einstellungen nicht ändern kann, aber einige freigegebene Websites über einen authentifizierten Upstream braucht. - Ein kleines Team, das ein Partnerportal von einer festen IP aus erreicht, die der Partner auf seine Allowlist gesetzt hat. - Lernen, wie umschreibende Proxys funktionieren: Starten Sie es mit `DEBUG=unblocker:*` und beobachten Sie jede Middleware. In jedem Fall gilt: nur Websites, die Sie nutzen dürfen, in einem Tempo, das die Website verkraftet, und nie als Weg an einem Filter oder einer Sperre vorbei. ## Häufige Fehler - **Auf `0.0.0.0` ohne Login lauschen.** Der Server wird zum öffentlichen Relay. - **Den Zugriff nur in Express-Middleware prüfen.** WebSocket-Upgrades kommen dort nie an. - **`data.clientResponse` in `requestMiddleware` ungeprüft aufrufen.** Bei Upgrades ist es `null` und bringt den Prozess zum Absturz. - **Sich allein auf eine Hostnamen-Prüfung verlassen.** Prüfen Sie die aufgelöste IP im `lookup` des Agents. - **Jeden Browser-Header weiterleiten.** `Authorization` und `X-Forwarded-For` erreichen das Ziel, solange Sie sie nicht löschen. - **Die Standard-Fehlerseite von Express behalten.** Außerhalb des Produktionsmodus zeigte sie unserem Besucher einen Stack-Trace mit `getaddrinfo ENOTFOUND`. - **Sich darüber in persönliche Konten einloggen.** Der Server sieht jedes Passwort. ## Entscheidungshilfe | Bedarf | Empfehlung | |---|---| | Verstehen, wie es funktioniert | Minimaler Server auf `127.0.0.1` | | Ein kleines Team öffnet eine feste Auswahl von Websites | Abgesicherter Server hinter einem HTTPS-Reverse-Proxy | | Seiten so prüfen, wie Besucher in einem anderen Land sie sehen | Abgesicherter Server mit Residential-Upstream | | Eine feste Ausgangs-IP, die ein Partner freigeben kann | Abgesicherter Server, bei Bedarf mit Datacenter-Upstream | | Apps, Skripte oder ein ganzer Browser | Ein Forward-Proxy (HTTP oder SOCKS5) | | OAuth-Logins oder große Web-Apps | Ein normaler Browser mit Forward-Proxy | | Ein öffentlicher Proxy für alle | Betreiben Sie keinen | ## Häufige Fragen ### Ist Node Unblocker ein VPN? Nein. Ein VPN leitet den gesamten Verkehr eines Geräts durch einen verschlüsselten Tunnel; Node Unblocker ist eine Website, die andere Seiten für Sie lädt. Nur was Sie unter `/proxy/` öffnen, läuft darüber, und der Server liest es im Klartext. ### Verbirgt Node Unblocker meine IP-Adresse? Vor der Zielwebsite ja, wenn der Server anderswo läuft: Die Website sieht die IP des Servers. Vor dem Betreiber des Servers verbirgt es Sie nicht, und hinter einem Reverse-Proxy erreicht Ihre IP die Website im Header `X-Forwarded-For`, solange dieser Header nicht gelöscht wird. ### Funktioniert Node Unblocker mit Express 5? In unserem Test ja. Mit Express 5.3.0 verhielten sich Seiten, Weiterleitungen, abgeschickte Formulare und WebSockets wie unter Express 4.22.3; npm installiert eine separate Kopie von Express 4 im Paket. ### Kann Node Unblocker WebSockets weiterleiten? Ja, sobald `unblocker.onUpgrade` am `upgrade`-Ereignis des Servers hängt. Express-Middleware läuft dort nicht; prüfen Sie Login und Ziel deshalb auch in diesem Handler. ### Darf ich Node Unblocker in einem kommerziellen Produkt verwenden? Ja, unter der AGPL-3.0: Wenn Sie es ändern und die geänderte Version Nutzern über ein Netzwerk anbieten, müssen Sie ihnen deren Quellcode anbieten. Laut README ist beim Autor auch eine kommerzielle Lizenz erhältlich. ### Warum klappt das Login, aber die nächste Seite meldet mich ab? Meist ist die Website zwischen Subdomains oder von HTTP zu HTTPS gewechselt. Unblocker speichert Cookies unter einem Pfad pro Website und kopiert sie mit einer zusätzlichen Weiterleitung auf den neuen Pfad; laut Quellcode gehen dabei Attribute wie das Ablaufdatum verloren. ## Fazit Node Unblocker macht aus einem Express-Server einen Web-Proxy, der Seiten für einen normalen Browser umschreibt: Der Besucher öffnet `/proxy/`, der Server ruft die Seite von seiner eigenen IP ab, schreibt Links, Cookies und Weiterleitungen um und streamt sie zurück. Der minimale Server braucht unter Express 4 oder 5 nur ein paar Zeilen; die eigentliche Arbeit ist die Absicherung mit Login, Allowlist, Prüfung der aufgelösten IP, entfernten Headern und einem geschützten WebSocket-Handler hinter HTTPS. Soll der Ausgang woanders liegen, leiten die Agent-Optionen den Verkehr über einen Upstream, und unsere [Proxy-Dienste](/de/proxy) decken Datacenter-, Residential-, Mobile- und statische ISP-Ausgänge ab.