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.

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 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/<site>/, 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:

set-cookie: session=abc123; Path=/proxy/http://127.0.0.1:9000/; HttpOnly

<script src="/proxy/client/unblocker-client.js"></script>
<script>unblockerInit({"prefix":"/proxy/","url":"http://127.0.0.1:9000/"}, window);</script>
<title>Test page</title><meta name="ROBOTS" content="NOINDEX, NOFOLLOW"/>
<a href="/proxy/https://www.iana.org/help/example-domains">absolute</a>
<a href="/proxy/http://127.0.0.1:9000/about">root-relative</a>
<a href="contact">relative</a>
<img src="/proxy/http://cdn.example.net/logo.png">
<form action="/proxy/http://127.0.0.1:9000/login" method="post"></form>

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.

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? 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:

npm install express unblocker

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:

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 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, 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 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.

npm install express unblocker express-rate-limit

Ersetzen Sie dann server.mjs durch diese Version:

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:

npm install http-proxy-agent https-proxy-agent

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:

[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.

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 vergleicht beide Wege.

Ein 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 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#

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/<url>, 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 decken Datacenter-, Residential-, Mobile- und statische ISP-Ausgänge ab.