Sicherheit
Das Framework liefert die Bausteine; diese Seite zeigt, wie man sie
zusammensetzt. Das lauffähige Gegenstück ist
examples/http/secure-service.ts.
Der empfohlene Stack
Abschnitt betitelt „Der empfohlene Stack“Die Reihenfolge zählt — von außen nach innen:
import { concat, cors, csrfProtection, fallback, handleErrors, path, requestId, requestTimeout, securityHeaders, withMiddleware, CorsOptions, CsrfOptions,} from 'actor-ts/http';
const corsOptions = CorsOptions.create().withOrigins('https://app.example').withCredentials();const csrf = csrfProtection(CsrfOptions.create().withSecret(process.env.CSRF_SECRET!));
const routes = withMiddleware(requestId(), withMiddleware(securityHeaders(), cors(corsOptions, withMiddleware(requestTimeout(15_000), handleErrors(errorMapper, withMiddleware(csrf, concat( appRoutes, fallback(notFound), )))))));| Schicht | Warum hier |
|---|---|
requestId | ganz außen, damit jede Log-Zeile (auch Fehler) eine ID hat |
securityHeaders | über allem, was ablehnt — damit auch diese Responses die Header tragen |
cors | außerhalb der Auth — Preflights sind laut Spec anonym |
requestTimeout | Latenz begrenzen, bevor echte Arbeit läuft |
handleErrors | außerhalb von csrf, damit es dessen eigene 403 mappt — und innerhalb der Header-Schichten, damit das Ergebnis noch durch sie läuft |
csrf | nur Browser-Apps; nach CORS, vor den Handlern |
fallback | an der Wurzel — beantwortet alles Unpassende |
Was jede Response ohnehin schon trägt
Abschnitt betitelt „Was jede Response ohnehin schon trägt“X-Content-Type-Options: nosniff braucht keine Einrichtung. Geschrieben
wird der Header vom Backend, nicht von einer Middleware — er erreicht
damit auch die Responses, die keine Middleware sieht: das backend-eigene
Fehler-Mapping, den fallback-404 und den 413 bei zu großem Body. Ein
Header aus dem Handler gewinnt weiterhin.
Er ist bewusst der einzige, der per Default an ist — es ist der einzige
Header des Bündels, der nichts daran ändern kann, wie eine bestehende
Anwendung eingebettet, geframed oder referenziert wird. X-Frame-Options
und Cross-Origin-Resource-Policy würden iframes, Cross-Origin-Einbettung
und OAuth-Popups brechen und bleiben deshalb Opt-in.
Um das ganze Bündel auf jede Response zu legen — inklusive derselben middleware-unsichtbaren Pfade — konfiguriere es am Server statt am Routen-Baum:
import { SecurityHeadersOptions } from 'actor-ts/http';
const securityHeadersOptions = SecurityHeadersOptions.create() .withFrameOptions('SAMEORIGIN') .withReferrerPolicy('strict-origin-when-cross-origin');
await http.newServerAt('0.0.0.0', 8080) .withSecurityHeaders(securityHeadersOptions) .bind(routes);Optionen zu übergeben ist ein Opt-in in das vollständige Bündel, samt
dessen eigener Defaults — die beiden Header oben kommen also zusammen mit
Cross-Origin-Resource-Policy: same-origin und dem Rest. Ein einfaches
Objekt geht genauso (withSecurityHeaders({ frameOptions: 'SAMEORIGIN' })),
und withSecurityHeaders(false) schaltet den Mechanismus komplett ab.
Serverweit oder als securityHeaders()-Middleware — beide setzen dieselbe
Menge. Die Middleware deckt ihren eigenen Teilbaum ab, und dazu gehört auch
ein Short-Circuit, der wirft: Ein HttpError aus einer Schicht darunter
— eine CSRF-403, eine Auth-401 — nimmt die Header mit hinaus. Was sie nie
sieht, ist eine Response, die außerhalb ihres Teilbaums entsteht: der
backend-eigene 404, der 413 bei zu großem Body und die generische 500, auf
die ein Wurf ohne HttpError gemappt wird. Zur Middleware greifst du, wenn
nur ein Routen-Teilbaum sie braucht; zum Builder, wenn der ganze Server sie
braucht.
Betriebsumfeld
Abschnitt betitelt „Betriebsumfeld“-
TLS terminiert am Proxy — oder im Prozess, und die Seite hat nie gesagt, wo. Hinter nginx, Caddy oder einem Ingress spricht die App reines HTTP, und das bleibt die Produktionsantwort: der Terminator hält das Zertifikat, die App sieht
X-Forwarded-Protound traut ihm für nichts Sicherheitsrelevantes allein. Zwei Dinge in dieser Schicht setzen die https-Welt trotzdem voraus:Csrfvergleicht Origins per Default gegenhttps, und das__Host--Cookie-Präfix, das es nutzt, verlangtSecure, was über reines HTTP bedeutungslos ist. Beides ist hinter einem Terminator korrekt, und beides scheitert laut auf einem nackten Quickstart — genau dafür gibt eswithTls: der Prozess terminiert selbst, auf Bun, Node und Deno, sodass sich einSecure-Cookie ohne Proxy ausprobieren lässt. Setze HSTS so oder so — Browser ignorieren es über reines HTTP. Gate Security-Header nicht an einem Scheme, das die App nicht sieht.Ein vollständiger minimaler Terminator für eine App, die mit
system.http(8080)gebunden ist — Caddy besorgt das Zertifikat selbst und setztX-Forwarded-Protovon allein:Caddyfile example.com {reverse_proxy 127.0.0.1:8080}nginx.conf (server-Block) server {listen 443 ssl;server_name example.com;ssl_certificate /etc/ssl/example.com.pem;ssl_certificate_key /etc/ssl/example.com.key;location / {proxy_pass http://127.0.0.1:8080;proxy_set_header X-Forwarded-Proto $scheme;proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;}}Was die Forwarded-Header hier tun:
X-Forwarded-Forliest nurIpAllowlist, und erst, wenn du die Proxys benannt hast;X-Forwarded-Protoliest nichts —Csrfbekommt das Scheme stattdessen ausexpectedScheme, gerade weil ein weitergereichtes Scheme von dem gesetzt wird, der die Anfrage schickt. -
Client-IPs vertrauen.
req.remoteAddressist der Socket-Peer, kein fälschbaresX-Forwarded-For— und „überschreibt mein Proxy den Header” ist die falsche Frage, denn NGINX, AWS ALB und Cloudflare hängen alle daran an. Der eigene Text des Clients bleibt für immer links in der Kette. Benenne stattdessen die Proxys (trustedProxiesvonIpAllowlist), dann wird die Client-Adresse vom Socket-Ende nach innen aufgelöst — dem einzigen Ende, das die Infrastruktur kontrolliert. Traue niemals jedem Hop: bei Express und Fastify lösttrust proxy: truegenau zu diesem linkesten, client-gewählten Eintrag auf. -
Secrets aus der Umgebung, nicht aus HOCON-Dateien — das CSRF-Secret, Basic-Zugangsdaten und Bearer-Tokens nehmen alle Werte, die du beim Start lädst.
Cookies
Abschnitt betitelt „Cookies“Bevorzuge das __Host--Präfix (erfordert Secure, Path=/, kein Domain)
und SameSite=Lax oder Strict. Das CSRF-Cookie
nutzt dieses Präfix per Default — es ist das, was eine Geschwister-Subdomain
am Platzieren eines Tokens hindert — und ist bewusst nicht HttpOnly
(Double-Submit braucht JS zum Lesen); dein Session-/Auth-Cookie sollte
HttpOnly sein.
serializeCookie bringt dich per Weglassen dorthin. Ein Attribut, das du
nicht nennst, löst sich zum strikten Ende hin auf — Secure, HttpOnly,
SameSite=Lax, Path=/ —, der Aufruf mit zwei Argumenten ist also schon
auslieferbar, und was dabei herauskommt, erfüllt die __Host--Regeln, ohne
dass ein Wort darüber fällt. Aufweichen ist der Teil, den du hinschreibst:
import { serializeCookie } from 'actor-ts/http';
// __Host-session=<id>; Path=/; HttpOnly; Secure; SameSite=Laxconst sessionCookie = serializeCookie('__Host-session', sessionId);
// Plain-HTTP local dev, and a cookie same-origin JS has to read.const readableCookie = serializeCookie('token', value, { secure: false, httpOnly: false });Path wird immer geschrieben, weil die Alternative schlimmer ist: ohne das
Attribut leitet der Browser den Geltungsbereich aus der Request-URI ab —
dasselbe Cookie deckt dann /account ab, wenn es von /account/login kommt,
und /, wenn es von der Wurzel kommt.
Ebenso verweigert die Funktion alles, was aus dem Cookie ausbrechen könnte,
das sie gerade baut — einen unzulässigen Namen oder Wert und einen Path
oder eine Domain, die keine sind. Diese beiden landen unverändert im
Header: ein ungeprüfter Path von '/;Domain=evil.example' würde ein
Attribut nach fremder Wahl anhängen, und die letzte Domain ist die, die
zählt — sie würde deine überschreiben, statt gegen sie zu verlieren.
Fehlerhygiene
Abschnitt betitelt „Fehlerhygiene“Interna nicht leaken. Nutze withErrorHandler (oder ein Top-Level
handleErrors), um einen generischen Body zurückzugeben, und logge das
Detail serverseitig, verschlüsselt über die Request-ID. Halte 403/404
unspezifisch — die Static-File-Schicht liefert für jeden abgelehnten Pfad
einen einheitlichen 404, verrät also nie, was existiert.
Auch die serverseitige Kopie braucht Hygiene, und das übliche Leck dort ist
eine Verbindungs-URL: ein abgelehnter Optionswert und die
Oversize-Frame-Warnung des WebSocket-Clients benennen beide eine, und beide
werden mit maskierter Userinfo geschrieben. Wenn du selbst eine URL loggst,
schick sie durch
redactUrlCredentials oder redactedUrlLabel,
oder durch redactParsedUrlCredentials, wenn du die URL hältst, mit der
ein Request gestellt wurde — ein Passwort, das einen Log-Aggregator
erreicht hat, muss rotiert werden; löschen genügt nicht.
Redirects
Abschnitt betitelt „Redirects“redirect(target) nimmt ausschließlich Same-Origin-Ziele — eine
relative Referenz. Eine absolute URL, ein protokollrelatives //host oder
ein Steuerzeichen wirft HttpError(400); einen ?next=-Parameter direkt
in einen Redirect zu reichen, scheitert damit geschlossen, statt zum
Open-Redirect zu werden. Wenn das Verlassen des Origins Absicht ist, sag
es: redirectExternal(...) ist derselbe Helper ohne Origin-Regel, und der
eigene Name macht jeden bewussten Off-Origin-Sprung mit einem Befehl
auffindbar. Übergib eine Konstante oder ein Ziel aus deiner Allowlist —
nie einen rohen Request-Parameter. Siehe Route DSL.
Untrusted Input begrenzen
Abschnitt betitelt „Untrusted Input begrenzen“-
Request-Bodies sind auf jedem Backend bei 1 MiB gekappt, und ein größerer Body wird mit demselben
413 Payload Too Largeabgewiesen, egal welches Backend bedient — bevor der Handler läuft und ohnewithErrorHandlerzu fragen, denn ein Size-Cap ist eine Transport-Entscheidung und kein Anwendungsfehler. Verschieb ihn mitactor-ts.http.server.max-content-length(withMaxContentLengthim Code), das auf jedem Backend und jeder Runtime greift — senk ihn, wo deine Endpunkte weniger annehmen, heb ihn an, wo einer wirklich mehr annimmt. Die Knöpfe pro Backend gibt es weiterhin —withMaxBodyBytes(bytes)in den Express- und Hono-Backend-Options,bodyLimitin der Options-Bag vonFastifyBackend—, neben einem gesetzten Key müssen sie aber mit ihm übereinstimmen, sonst lehntbind()das Backend ab, statt eine Grenze zu halten und die andere zu ignorieren. Ein Body mit einerContent-Lengthüber dem Limit wird abgewiesen, bevor ein Byte davon gelesen wird; ein gechunkter Body deklariert keine Länge, also zählen ihn alle drei Backends beim Eintreffen mit und brechen den Read am Limit ab — die Bytes dahinter werden nie entgegengenommen. -
Request-Header kappt die Runtime bei 16 KiB auf
node:httpund auf Bun, dessen Grenze das prozessweite--max-http-header-sizeist.actor-ts.http.server.max-header-bytes(withMaxHeaderBytesim Code) verschiebt sie pro Server überall dort, wo actor-ts den Server baut — Fastify, Express und Hono auf Node —, und ein Request darüber erreicht keinen Handler. Zwei Lücken bleiben. Hono auf Bun oder Deno hat keine Header-Grenze pro Server, die sich setzen ließe; dort wird der Key als nicht wirksam gemeldet undbind()warnt, und die eigene Grenze vonDeno.serveließ einen Header-Block von 256 KiB durch (deno 2.6.8). Und auf einem HTTP/2-Listener unter Node greift die Grenze für die HTTP/1.1-Requests auf dem Port, nicht aber für die Header-Liste eines HTTP/2-Streams — Listen von 900 Bytes, 4 KiB und 60 KiB kamen auf node v26.10.0 durch eine Grenze von 1 KiB, begrenzt nur von Nodes eigener 64-KiB-Grenze, die weder der Key nochsettings.maxHeaderListSizesenkt —; dort wird der Key deshalb als nur für HTTP/1.1 wirksam gemeldet, undbind()warnt. Bun begrenzt auch den Stream und zählt dabei jedes Feld auf HTTP/2-Art (Name, Wert und 32 Bytes, Pseudo-Header eingeschlossen), sodass ein Header-Block nahe der Grenze, den HTTP/1.1 annimmt, über HTTP/2 abgelehnt werden kann: unter 1 KiB kam ein 900-Byte-Header über HTTP/1.1 durch und wurde über HTTP/2 zurückgesetzt (bun 1.4.2). Ein Reverse Proxy davor schließt beide Lücken. -
Die Zeit einer Verbindung — die Schranke, die der Rest dieser Liste nicht abdeckt: ein Peer, der nie fertig sendet, hat keinen Request, der ablaufen könnte, und damit sieht ihn weder eine Größenschranke noch ein
requestTimeout()auf Routenebene. Ein Server begrenzt die Header-Phase auf 60 s (actor-ts.http.server.header-timeout— der Slowloris-Schutz, beantwortet mit408) und das gesamte Empfangen auf 300 s (request-timeout). Beide begrenzen nur das Empfangen; ein langsamer Handler, ein Long Poll und ein SSE-Stream bleiben von ihnen unberührt. Hono unter Bun ist die Ausnahme, und nicht wegen dieser Schlüssel: dort istidle-timeoutdas eigene verbindungsweite Idle-Timeout vonBun.serve, das einen Request, dessen Handler noch kein Byte geschrieben hat, als untätig zählt; ein Handler oder Stream, der so lange schweigt, wird deshalb ohne Antwort geschlossen. Ungesetzt wird es aus der Request-Deadline abgeleitet, damit die503einesrequestTimeout()zuerst geschrieben wird — 36 s bei den eingebauten 30 s, statt Buns eigener 10 s, die einen solchen Request nach etwa 12 s abschnitten —, und ein Wert über255slässtbind()scheitern; siehe das Hono-Backend.max-connectionsbegrenzt, wie viele Verbindungen der Prozess gleichzeitig annimmt, undidle-timeout, wie lange eine stille Verbindung gehalten wird — ein Keep-Alive-Socket zwischen zwei Requests und eine HTTP/2-Session ohne offenen Stream; beide liefern keinen Wert, es ist also nichts begrenzt, bis du es sagst. Diese Werte erreichen eine Verbindung über einennode:http-Server: Fastify, Express und Hono-auf-Node tragen sie, Hono auf Bun trägt nuridle-timeout— dort ist es also die einzige Schranke für einen Request, dessen Body nicht mehr weiterkommt, und für eine untätige Verbindung, und mit0bleibt eine solche Verbindung offen, bis der Client sie schließt —, Hono auf Deno keinen — die Tabelle steht in der Konfigurationsreferenz. Wo es eines nicht kann, sagtbind()es: jede Schranke, die du gesetzt hast und die laut Meldung des Backends nicht wirkt, wird beim Binden des Servers in einer Warnung genannt — eine Schranke, die nur für eines der beiden Protokolle eines HTTP/2-Listeners gilt, zusammen mit dem Protokoll, für das sie gilt —, und die eingebauten Werte vonheader-timeoutundrequest-timeoutsind nie darunter. Unter HTTP/1.1 wirdrequest-timeoutüber einen periodischen Sweep durchgesetzt —connectionsCheckingIntervalvonhttp.createServer, 30 s per Default und von actor-ts nicht gesetzt —; eine Verbindung wird also spätestens einen Sweep nach dem gesetzten Wert geschlossen. Ein blankernode:http-Server beantwortet das mit408, das Default-Backend Fastify schließt unter Bun ganz ohne Statuszeile. Ein HTTP/2-Stream trägt stattdessen eine eigene Deadline, die den Wert genau einhält — siehe unten. Die Header gehören zum Request; einrequest-timeout, der kürzer ist alsheader-timeout, ist deshalb zugleich die Header-Deadline: actor-ts schreibt den kürzeren Wert an die Runtime und stellt seine eigene Absicherung damit scharf, was Node auch davon abhält, den Request stillschweigend bis zum längeren offen zu halten.Unter HTTP/2 halten Timer von actor-ts selbst beide Schranken.
keepAliveTimeoutundrequestTimeout, die Eigenschaften, die sie zu einer HTTP/1.1-Verbindung tragen, liest keine HTTP/2-Session und kein HTTP/2-Stream: gemessen auf node v26.10.0 und bun 1.4.2 war eine HTTP/2-Session, die ihren einzigen Request erledigt hatte, unter einemidle-timeoutvon 800 ms nach über 5 s noch offen, und ein Stream, dessen Body nach 10 von 1000 angekündigten Bytes stehen blieb, unter einemrequest-timeoutvon 2 s nach 12 s — ebenso einer, der alle 500 ms ein Byte nachschob.request-timeoutbegrenzt das Empfangen jedes Streams. Ein Stream, dessen Request beim Ablauf der Deadline noch eintrifft, wird mit408beantwortet und zurückgesetzt; gemessen bei 2,0 s für2sauf beiden Runtimes, stockend wie tröpfelnd. Die Deadline endet, sobald der Client fertig gesendet hat, gelesen oder nicht; ein vollständig empfangener Request wird also nie gekappt, wie lange sein Handler auch braucht — die HTTP/1.1-Regel. Der Stream geht, die Session bleibt für ihre anderen Streams.idle-timeoutbegrenzt eine Session ohne offenen Stream. Der Timer läuft, solange nichts offen ist, und die Session wird mit einem GOAWAY geschlossen, wenn er feuert; ein laufender Stream hält sie, wie ein Request eine HTTP/1.1-Keep-Alive-Verbindung hält — ein langsamer Handler, ein Long Poll oder ein SSE-Stream wird davon also nie unterbrochen, und die Schranke beginnt, wenn er endet. Es ist derselbe Wert auf beiden Runtimes — 0,81 s und 0,80 s für800ms—, und ein PING-Frame setzt ihn nicht zurück: einem Client, der alle 300 ms pingt, wird die untätige Session pünktlich geschlossen.
Ungesetzt begrenzt eine untätige HTTP/2-Session auf dem Default-Backend Fastifys eigener Session-Timer: 72 s auf Node, aber 144 s auf Bun, das ihn beim doppelten Wert feuern lässt — und auf Bun zählt dieser Timer einen PING-Frame als Aktivität; ein Client, der einmal pro Sekunde pingte, hielt eine Session ohne jeden Request offen, solange er weiter pingte (nach 170 s noch offen, bun 1.4.2). Auf Hono über Node lässt ein ungesetzter
idle-timeouteine untätige HTTP/2-Session ganz ohne Schranke. Setzeidle-timeoutauf jedem HTTP/2-Listener.Auf Bun begrenzt keine der beiden eine HTTP/1.1-Verbindung auf dem HTTP/2-Listener. Der Listener hält HTTP/1.1 auf demselben Port bereit, und Bun reicht eine solche Verbindung an eine Behandlung weiter, die weder
keepAliveTimeoutnochrequestTimeoutliest: eine HTTP/1.1-Keep-Alive-Verbindung war unter einemidle-timeoutvon 800 ms 8 s nach ihrer Antwort noch offen, ein stockender HTTP/1.1-Body unter einemrequest-timeoutvon 2 s nach 40 s (bun 1.4.2) — wo Node die erste nach 1,8 s schließt und den zweiten beim nächsten Sweep mit408beantwortet. Auf Bun werden die beiden deshalb als nur für HTTP/2 wirksam gemeldet, undbind()warnt;header-timeoutundmax-connectionsgelten dort für beide Protokolle. Wo nicht vertrauenswürdige Clients einen HTTP/2-Listener auf Bun erreichen, terminiere HTTP/1.1 vor dem Prozess oder lass den Listener bei HTTP/1.1.header-timeoutist anders, und das mit Absicht: actor-ts stellt die Deadline selbst scharf, statt die Zahl an die Runtime zu reichen und zu hoffen. Die Eigenschaft wird weiterhin gesetzt — wo eine Runtime sie umsetzt, passiert die Arbeit früher und billiger —, aber die Schranke hängt nicht daran. Sie kann es nicht:server.headersTimeoutwird von zwei der drei unterstützten Runtimes angenommen und ignoriert. Gemessen an einem blankennode:http-Server gegen einen Socket, der einen Header-Block sendet und nie die abschließende Leerzeile: node v26.7.0 antwortet mit408und schließt, bun 1.4.0 setzt bei keinem Wert etwas durch — auch nicht bei der0, die als Abschalten dokumentiert ist; alle schlossen nach ~12 s ohne408, was Buns eigener Idle-Timeout ist und nicht diese Absicherung —, und deno 2.6.8 schließt die Verbindung überhaupt nie. Die Deadline läuft deshalb ab der angenommenen Verbindung und wird in dem Moment gelöscht, in dem ein Request oder ein WebSocket-Upgrade seine Header vollendet. Genau das macht das408oben auf der Runtime wahr, auf der du am ehesten unterwegs bist, und den Wert exakt statt auf einen Sweep aufgerundet.Auf einem Listener, der TLS terminiert, zählt auch der Handshake gegen die Deadline — ein Peer, der nie fertig verhandelt, ist derselbe Angriff eine Schicht tiefer und wird ohne Statuszeile getrennt —, und ist der Handshake durch, geht das
408innerhalb von TLS hinaus. Unter HTTP/2 löschen die Header des ersten Streams die Deadline, und eine Session, die nie einen Stream öffnet, wird mit einem GOAWAY geschlossen. Node gibt TCP- und TLS-Socket als zwei Objekte heraus, und eine HTTP/2-Session kommt auf beiden Runtimes als drittes an; actor-ts trägt die Deadline deshalb über das Adress- und Port-Paar der Verbindung von einem zum nächsten. Genau das bewahrt eine gesunde HTTPS-Keep-Alive-Verbindung oder HTTP/2-Session davor, beim Ablauf ihrer Deadline gekappt zu werden. Buns HTTPS-Listener meldet eine Verbindung erst, wenn ihr Handshake durch ist; dort begrenzt stattdessen Buns eigener Idle-Close nach ~12 s einen hängenden Handshake.max-connectionsist dieselbe Entscheidung von der anderen Seite her: actor-ts zählt die Verbindungen selbst. Die Eigenschaft wird weiterhin gesetzt — wo eine Runtime sie umsetzt, wird der Socket abgewiesen, bevor er uns erreicht, was billiger ist —, aber die Schranke hängt nicht daran. Sie kann es nicht: dieselbe Runtime-Version wurde dabei gemessen, wie sie die Eigenschaft auf einem Betriebssystem umsetzt und auf einem anderen ignoriert. Für einen Tuning-Hinweis ist das in Ordnung, für die Kontrolle, die diese Seite als Antwort auf eine Verbindungsflut anbietet, nicht.Beide ruhen darauf, dass der Server seine angenommenen Verbindungen meldet — und genau dort enden sie. Wo ein Backend gar kein Server-Objekt herausgibt (Hono auf Bun oder Deno), gibt es nichts einzuhängen, und Denos
node:http-Shim sendet keinconnection-Event, selbst wo ein Server-Objekt existiert — auf Deno installiert also kein Backend die Header-Deadline oder die Verbindungsschranke.Eine Verbindung, die nichts sagt, ist die verbleibende Lücke — und sie hat eine Plattform-Form. Gemessen auf bun 1.4.0, mit der Runtime auf beiden Seiten installiert: ein
http.Serversendetconnectionfür einen angenommenen Socket unter Windows und unter Node sofort, unter Linux erst, sobald dessen erstes Byte eintrifft — bis dahin antwortet auchgetConnections()mit0, die Verbindung ist für den Prozess also nicht bloß ungezählt, sondern unsichtbar. Auf dieser Paarung greift bei einem schweigenden Client keine der beiden Durchsetzungen: die Eigenschaft wird dort ignoriert, und das Event ist noch nicht gefeuert.Damit ist auch geklärt, warum die Header-Deadline auf demselben Runner hielt und die Schranke nicht (#1409): Ein Slow-Loris schreibt einen unvollständigen Header-Block, sein Socket spricht also und das Event feuert für ihn. Ein Cap-Test, der sich verbindet und schweigt, fragt den Linux-Server nach einer Verbindung, die er nicht hat.
Eine Verbindung, die spricht, wird also überall gleich beschränkt — jeder echte Client —, und eine, die nie spricht, wird auf dieser Paarung von nichts beschränkt, was actor-ts sehen kann. Wenn stille Sockets zu deinem Bedrohungsmodell gehören, kombiniere die Schranke mit einer Grenze unterhalb der Runtime: einem Verbindungslimit des Betriebssystems oder einem Reverse-Proxy (#1505).
-
WebSocket-Frames werden durch
maxFrameBytesgekappt (1 MiB Default). Das Framework weist einen zu großen Frame immer ab, bevor er deinen Actor erreicht; auf den meisten Laufzeit/Backend-Paaren geht das aufgelöste Limit zusätzlich an den Socket der Laufzeit selbst, sodass der Frame schon abgewiesen wird, während er eintrifft, statt erst nachdem der Prozess ihn gepuffert hat — sonst könnte ein Peer pro Frame 16 MiB (Bun) oder 100 MiB (ws) Pufferung erzwingen, die das Framework anschließend verwirft. Das Limit zu senken — pro Route oder überactor-ts.http.websocket.max-frame-bytes— verkleinert dieses Puffer-Fenster mit. Drei Stellen haben kein Transport-Limit und puffern den Frame, bevor sie ihn abweisen: Hono auf Deno, dessenupgradeWebSocketüberhaupt kein Payload-Limit anbietet; Bun mit dem Express- oder Fastify-Backend, wowsauf Buns eingebauten Shim auflöst, dermaxPayloadzwar annimmt und zurückliefert, aber nicht durchsetzt; und der ausgehendeWebsocketClientActorauf jeder Laufzeit — kein natives Client-WebSocketbeachtet ein Payload-Limit, das man seinem Konstruktor übergibt, gemessen auf Bun, Node und Deno, wo die Option angenommen wird, alsundefinedzurückkommt und ein 4-MiB-Frame trotzdem vollständig zugestellt wird. Auf dem Client greift das Limit also nur im Nachhinein, und was es bringt, ist, dass der Verstoß endgültig ist: Ein zu großer Frame schließt die Verbindung mit 1009, sodass das Gegenüber die Allokation auf diesem Socket nicht wiederholen kann. Beachte, dass das Bedrohungsmodell dort ein anderes ist — das Gegenüber ist ein Endpunkt, den du selbst gewählt hast, oder ein MITM auf einer unverschlüsseltenws://-Verbindung. Siehe WebSocket. -
Untrusted HTML — mit dem
html-Template escapen; für Rich-Markup vorrawHtmlmit einer dedizierten Bibliothek sanitisieren. -
Antworten, die du selbst abrufst, sind ebenfalls Untrusted Input — und die Richtung, die in so einer Liste am leichtesten vergessen wird. Der
HttpClientmaterialisiert einen ganzen Response-Body im Speicher, bevor ein Aufrufer ihn sieht; ohne Schranke entscheidet also die Gegenstelle, wie viel Heap dieses Prozesses sie sich nimmt — eineContent-Lengthist eine Behauptung und keine Grenze, und eine gechunkte Antwort deklariert überhaupt keine Länge. Jeder Aufruf bringt eine 30-s-Deadline und eine 8-MiB-Obergrenze für den Body mit; der Body wird beim Lesen mitgezählt und während er eintrifft abgebrochen, die Verbindung wird abgerissen, damit der Rest nie ankommt, und der Aufruf wirftHttpResponseTooLargeError. Heb die Werte pro Aufruf an (maxResponseBytes,timeoutMs), pro Integration (newClient(...)) oder flottenweit unteractor-ts.http.client. Redirects sind mitbegrenzt — 5 Hops, undauthorization/cookiefallen bei jedem Origin-Wechsel weg, damit eine feindlicheLocationkein Bearer-Token zu einem Host ihrer Wahl tragen kann. Siehe den HTTP-Client.
Statische Dateien
Abschnitt betitelt „Statische Dateien“Behalte die Defaults dotfiles: 'deny' und symlinks: 'within-root'.
Aktiviere browse nur für interne Tools — ein öffentliches Listing legt
deine Verzeichnisstruktur offen. Siehe Statische Dateien.
WebSocket
Abschnitt betitelt „WebSocket“Eine websocket()-Route weist Cross-Origin-Upgrades standardmäßig ab —
requireSameOrigin vergleicht den Origin des Browsers mit dem Host des
Requests und antwortet vor dem Handshake mit 403. Weitere Origins benennst du
mit withAllowedOrigins([...]), oder du wickelst die Route für denselben
Effekt von der Middleware-Seite her in cors(...). Ein Client, der gar keinen
Origin sendet — ein WebSocket aus Node, Bun oder Deno oder jeder
Server-zu-Server-Dialer —, ist nicht betroffen, denn
Cross-Site-WebSocket-Hijacking braucht einen Browser, und ein Browser sendet
den Header immer.
Wisse, was dieser Default nicht abdeckt. Origin und Host sind beides
Client-Header: eine Seite, die diesen Server unter einem eigenen Namen erreicht
(DNS-Rebinding), liefert ein übereinstimmendes Paar und kommt durch den
Same-Origin-Arm; der Vergleich ist außerdem schemablind, eine http://-Seite
auf demselben host:port kommt ebenfalls durch. Gewonnen ist damit
Erreichbarkeit, keine Session — Cookies des echten Hosts gehen nicht mit —,
betroffen ist also eine Route, deren Authentifizierung das Netz selbst ist:
IpAllowlist oder Vertrauen auf Loopback. Trag bei so einer Route die Origins
mit withAllowedOrigins([...]) fest ein, statt dich allein auf den Default zu
verlassen.
Lege außerdem Auth-Middleware um die Route — withMiddleware läuft zur
Upgrade-Zeit und gated damit den Handshake. Was sie an den Request hängt, etwa
die Claims, die JwtAuth geprüft hat, bleibt auf
der HTTP-Seite und erreicht die Verbindung nicht. Und binde den Server auf
Loopback, solange er nicht von woanders erreichbar sein soll.
Im Härtungs-Stack oben braucht eine websocket()-Route keine
Sonderbehandlung: securityHeaders(), requestId() und der Rest dürfen
darüber liegen wie über jeder anderen Route, und das Upgrade kommt trotzdem
zustande. Ihre Header landen auf einem abgelehnten Handshake, nicht auf
einem angenommenen — die 101 schreibt das Backend selbst. Siehe
WebSocket.
Checkliste
Abschnitt betitelt „Checkliste“| Maßnahme | Womit |
|---|---|
| MIME-Sniffing auf jeder Response abgeschaltet | nichts — per Default an |
| Security-Header auf jeder Response | serverweit withSecurityHeaders(...) — securityHeaders() deckt einen Teilbaum ab, Ablehnungen eingeschlossen |
| HTTPS vom Browser erzwungen | strictTransportSecurity() / withHsts |
| Cross-Origin kontrolliert | cors(...) |
| WebSocket-Upgrade-Origin kontrolliert | nichts — Same-Origin ist Default; withAllowedOrigins(...) erweitert, withRequireSameOrigin(false) schaltet ab |
| CSRF (Browser-Formulare) | csrfProtection(...) |
| API-Authentifizierung | JwtAuth(...) — Signatur, exp, iss und aud gegen die Schlüssel deines Ausstellers geprüft; BearerTokenAuth(...) für ein vorab geteiltes Operator-Token |
| Keine internen Fehler-Leaks | withErrorHandler + generische Bodies |
| Keine Open Redirects | redirect(...) — same-origin per Default |
| Request-Korrelation | requestId() |
| Begrenzte Latenz | requestTimeout(...) — die Frist auch aus actor-ts.http.request-timeout |
| Sichere Dateiauslieferung | getFromDirectory-Defaults (dotfiles deny, Symlink-Confinement) |
| Ausgehende Antworten begrenzt | nichts — 30 s und 8 MiB bei jedem HttpClient-Aufruf; pro Aufruf, pro newClient(...) oder actor-ts.http.client |
| Ausgehende Redirects begrenzt | nichts — 5 Hops, Credentials fallen bei Origin-Wechsel weg; redirect: 'error' weist sie ab |
