Zum Inhalt springen
Deutsch

Cluster-Sicherheit

Der Cluster-Transport ist standardmäßig Plain-TCP ohne Authentifizierung — schnell, einfach, okay für ein privates Netzwerk. Nicht okay für irgendeinen Cluster, der eine unsichere Grenze überschreitet (öffentliches Internet, Multi-Tenant-Kubernetes, Cross-Region-Links ohne VPN).

Diese Seite behandelt das Produktions-Sicherheits-Setup für den Cluster-Transport.

AnliegenWie adressieren
Lauschangriff — Peer-to-Peer-Traffic lesbar für jeden auf der Leitung.TLS auf dem Cluster-Transport.
Unautorisierte Joins — ein bösartiger Node verbindet sich + wird Cluster-Mitglied.Mutual TLS (mTLS) — Peer-Zertifikatsprüfung.

Aktiviere TLS mit gegenseitiger Authentifizierung (mTLS) für jeden nach außen gerichteten Cluster — das adressiert beide.

import { TcpTransport, NodeAddress, Cluster, ClusterOptions } from 'actor-ts/cluster';
import fs from 'node:fs';
const transport = new TcpTransport(
NodeAddress.parse('my-app@10.0.0.5:2552'),
system.log,
{
tls: {
cert: fs.readFileSync('./tls/cluster.crt'),
key: fs.readFileSync('./tls/cluster.key'),
ca: fs.readFileSync('./tls/ca.crt'),
rejectUnauthorized: true, // Peer-Certs verifizieren
},
},
);
const clusterOptions = ClusterOptions.create()
.withHost('10.0.0.5')
.withPort(2552)
.withSeeds([...])
.withTransport(transport);
await Cluster.join(system, clusterOptions);

Die TLS-Einstellungen:

  • cert + key — Zertifikat + Private Key dieses Nodes. Beide tragen das Material selbst, keinen Pfad darauf: nichts im Transport liest von der Platte, und auch keine der drei Runtimes akzeptiert in diesen Feldern einen Dateinamen. Lies es selbst ein, so wie es das Beispiel oben tut. Auf einem Listener sind beide Hälften nur gemeinsam gültig — siehe die Ablehnungen weiter unten.
  • ca — vertrauenswürdiges CA-Bundle. Nutze, um die Zertifikate der Peers zu verifizieren.
  • rejectUnauthorized: true — Handshakes scheitern lassen, wenn das Cert des Peers nicht von ca signiert ist.
  • requestClientCert — ob der Listener von dem, der sich verbindet, ein Zertifikat verlangt. Du setzt das normalerweise nicht: es ist true, sobald ca gesetzt ist, denn ein Trust-Bundle auf einem Cluster-Listener hat keinen anderen Zweck.

Mit einer geteilten ca ist der Cluster mutually authenticated — jede Verbindung verlangt ein Peer-Cert, das von der vertrauenswürdigen CA signiert ist, in beide Richtungen.

mTLS beantwortet „darf dieser Peer in den Cluster”. Für sich genommen hat es nie beantwortet „ist dieser Peer der Knoten, für den er sich ausgibt”: das hello-Frame trägt eine Adresse und kein Credential, ein CA-signierter Knoten konnte sich also unter der Adresse eines anderen Mitglieds ankündigen. Das ist deshalb relevant, weil die Gossip-Autoritätsregeln weiter unten allesamt am Peer der Verbindung hängen — sie sind genau so stark wie die Identität darunter.

Legt ein Peer also ein Zertifikat vor, muss die im hello beanspruchte Adresse eine sein, für die das Zertifikat bürgt. Ein Anspruch wird akzeptiert, wenn CN oder ein SAN eines von beidem abdeckt:

  • den Host der Adresse — der Normalfall, in dem das Zertifikat jedes Knotens seinen eigenen Hostnamen oder seine IP trägt, oder
  • das vollständige systemName@host — für Deployments, die eine Identität pro Knoten ausstellen und die engere Bindung wollen.

Wildcards gelten für den Host, nur im äußersten linken Label — genau wie bei der TLS-Hostnamensprüfung.

Für einen Cluster ohne lesbares Peer-Zertifikat ändert sich nichts: einfaches TCP, einseitiges TLS und ein Deno-Listener (der gar keins melden kann) verhalten sich exakt wie vorher. Die Prüfung stärkt mTLS-Deployments, statt einen Schalter hinzuzufügen, den man vergessen kann.

Vier Konfigurationen werden beim Bind abgelehnt, statt in einem schwächeren Zustand zu starten, als sie sich lesen:

  • Ein unvollständiges Server-Credential — cert ohne key, key ohne cert, oder ein tls-Objekt, das keines von beidem trägt (eine ca allein sagt, welchen Peers beim Wählen zu trauen ist; dem Listener gibt sie nichts zum Vorzeigen). Leer zählt als nicht gesetzt — genau so sieht eine nicht gesetzte Umgebungsvariable oder ein falsch gemountetes Secret aus, wenn es hier ankommt.
  • requestClientCert: true ohne ca — es gäbe nichts, wogegen Peer-Zertifikate validiert werden könnten.
  • Eine ca, die kein Zertifikat enthält — ein leerer oder nur aus Leerzeichen bestehender String, ein leeres Byte-Array oder Array, null —, was immer requestClientCert sagt. So sieht ein fehlendes Secret aus, wenn es hier ankommt, kein Weg, einseitiges TLS zu verlangen — das ist requestClientCert: false. Der HTTP-Server misst seine ca an derselben Regel, die an einer Stelle steht, unter Client-Zertifikate.
  • Ein mTLS-Listener auf Deno — Deno.listenTls nimmt nur Zertifikat und Key entgegen und kann ein Client-Zertifikat weder anfordern noch prüfen; der Listener würde also niemanden authentifizieren.

Einem mTLS-Cluster beitreten kann ein Deno-Knoten sehr wohl: er präsentiert beim Wählen sein eigenes cert/key, und der Listener (auf Node.js oder Bun) authentifiziert ihn wie jeden anderen Peer. Nur das Hosten des Listeners fällt aus — halte in einem gemischten Deployment die Seed-Knoten auf Node.js oder Bun.

Ein Deno-Unterschied, den man kennen sollte: rejectUnauthorized hat dort kein Äquivalent und wird nicht abgebildet. Deno prüft die Kette immer; einen self-signed Peer erreicht man also, indem man dessen signierende CA in ca mitgibt — die Form, die hier ohnehin empfohlen wird.

Drei Ansätze:

Terminal-Fenster
openssl req -x509 -newkey rsa:4096 -keyout cluster.key -out cluster.crt -days 365 -nodes -subj "/CN=actor-ts"

Nutze dasselbe Cert + denselben Key auf jedem Node. Okay für Dev / Staging. Nicht in Produktion einsetzen.

Terminal-Fenster
# CA einmalig erstellen:
openssl req -x509 -newkey rsa:4096 -keyout ca.key -out ca.crt -days 3650 -nodes -subj "/CN=actor-ts-ca"
# Per-Node-Certs, signiert von der CA:
openssl req -newkey rsa:4096 -keyout node-1.key -out node-1.csr -nodes -subj "/CN=node-1"
openssl x509 -req -in node-1.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out node-1.crt -days 365

Jeder Node bekommt sein eigenes Cert; alle vertrauen der CA. Certs zu rotieren ist pro Node und erfordert kein Anfassen der CA.

Für K8s-Deployments nutze cert-manager mit einer internen CA oder HashiCorp Vault. Certs werden als Volume-Secrets gemountet; Rotation übernimmt der Cert-Manager.

# Beispiel cert-manager-Certificate-Spec:
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
name: actor-ts-cluster
spec:
secretName: actor-ts-cluster-tls
issuerRef:
name: actor-ts-ca
kind: ClusterIssuer
commonName: actor-ts
dnsNames:
- actor-ts-cluster.svc
duration: 8760h
renewBefore: 720h

Der Pod mountet das Secret als Files; der Actor liest sie.

Cluster-Port (2552) — nur intern:
- Pods können auf 2552 mit Pods reden
- nicht via Service / Ingress exponiert
- LoadBalancer sieht ihn nie

Selbst mit TLS + Auth: exponiere den Cluster-Port eng. Eine NetworkPolicy in K8s:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: actor-ts-cluster-internal-only
spec:
podSelector:
matchLabels:
app: actor-ts
ingress:
- from:
- podSelector:
matchLabels:
app: actor-ts
ports:
- protocol: TCP
port: 2552

Nur app=actor-ts-Pods können sich gegenseitig auf Port 2552 erreichen.

BedrohungGegenmaßnahme
Netzwerk-LauschangriffTLS
Man-in-the-MiddleTLS + Zertifikatsprüfung
Unautorisierter Cluster-JoinmTLS (CA-signierte Peer-Certs)
Insider mit gestohlenem CertCert-Rotation + Revocation
Fehlerhafter oder feindlicher Wire-FrameShape-Prüfung an der Decode-Grenze
Frame in tausende Chunks zerlegt, um die Decode-Kosten zu vervielfachenLinearer Decode-Puffer — jedes Byte wird einmal kopiert, beim Eintreffen
Socket öffnet, schickt einen halben Frame und verstummtStall-Deadline auf einem unvollständigen Frame, dazu eine Obergrenze für eingehende Verbindungen
Massenhaft geöffnete Sockets, die gar nichts senden, um die Obergrenze zu füllenHandshake-Deadline auf jedem angenommenen Socket, damit kein Slot unbefristet gehalten wird
Peer lässt die Registries eines Knotens unbegrenzt wachsenObergrenzen pro Registry in PubSub und Receptionist
Adresse beansprucht, bevor der zugehörige Knoten existiertEnge Versions-Skew-Grenze auf jeder gegossipten Member-Version
Vom Draht mitgeschnittener Gossip-Frame wird später erneut gesendetSequence pro Sender — ein Frame muss den zuletzt von diesem Sender akzeptierten überbieten (teilweise: erst wenn einer akzeptiert wurde)
Gefälschte Discovery-Antwort lenkt den Bootstrap ummTLS, dazu pinnedAddresses am Seed-Provider
Ein Ref im Nachrichtenkörper nennt einen internen Host, damit dieser Knoten ihn anwähltFrames gehen nur an Mitglieder und an Knoten, zu denen dieser Knoten schon eine Verbindung hält (teilweise: ohne mTLS wird ein Peer weiterhin Mitglied unter einer Adresse, die sein eigenes hello nennt)
Kompromittierter Pod im ClusterApplication-Level-Auth (hier nicht abgedeckt)

Der Cluster-Transport handhabt Transport-Level-Sicherheit. Application-Level-Anliegen (Auth zwischen spezifischen Actors, Per-Tenant-Isolation) bleiben dein Job — der Cluster-Transport ist in sich selbst vertrauenswürdig.

Ein Seed-Provider fragt eine Gegenstelle außerhalb — DNS, die K8s-API —, mit welchen Adressen zu reden ist, und diese Antwort trifft ein, bevor irgendein Zertifikat geprüft wurde. Sie kann einem Angreifer nicht den Join verschaffen: die Adresse, die ein Peer beansprucht, muss von seinem Zertifikat gedeckt sein, ein gefälschter Seed erzeugt also eine Verbindung, die am Handshake stirbt.

Diese Garantie ist konfigurationsabhängig, und genau das gehört klar gesagt. Ein Node verlangt nur dann ein Peer-Zertifikat, wenn sein Listener so konfiguriert wurde, eines anzufordern; wo TLS aus ist oder wo ein halb konfigurierter Listener nie danach fragt, gibt es nichts, wogegen die beanspruchte Adresse geprüft werden könnte — und eine vergiftete Discovery-Antwort wird befolgt, wie sie kommt.

Pinne also, was der Resolver sagen darf:

const dnsSeedProviderOptions = DnsSeedProviderOptions.create()
.withHostname('actor-ts.example.com')
.withSystemName('my-app')
.withPort(2552)
.withPinnedAddresses(['10.0.0.0/8'])
.withLog((message) => logger.warn(message));

Adressen außerhalb der Liste werden nie zu Seeds. Details — einschließlich des SRV-Vorbehalts (Ziele sind dort Hostnames, Pins also Suffixe, und der spätere A-Lookup bleibt ungepinnt) — stehen auf den Seiten zum DNS Seed Provider und zum Kubernetes-API Seed Provider.

Das ist Defense-in-Depth: es senkt, was eine DNS- oder Endpoints-Kompromittierung einbringt, und es ist die einzige Kontrolle auf der Discovery-Ebene, die übrig bleibt, wenn mTLS nicht eingerichtet ist.

Bis #860 war das Snippet oben der einzige Weg dorthin: Cluster.bootstrap({ discovery: 'dns' }) und die env-getriebene Leiter bauten ihre Provider ganz ohne Pin, die dokumentierte Gegenmaßnahme war auf dem Pfad, den die meisten Deployments nehmen, also gar nicht erreichbar. Jetzt ist sie ein Config-Key, und sie liegt im selben Block wie die Keys, die entscheiden, welcher Provider läuft:

actor-ts.discovery {
dns.pinned-addresses = ["10.0.0.0/8"]
kubernetes.pinned-addresses = ["10.0.0.0/8"]
}

Setz ihn überall dort, wo auch actor-ts.cluster.bootstrap.discovery.method oder service-name gesetzt ist — aus demselben Grund, aus dem beides zusammen kam: Eine Config-Datei ist eine breitere Eingabefläche als ein Aufruf im Code, das Ziel von Discovery konfigurierbar zu machen, ohne den Pin konfigurierbar zu machen, hätte also die Angriffsfläche erweitert und den Schutz stehen gelassen, wo er war. Eine Liste, die im konfigurierten Modus nicht passen kann — nur CIDRs im SRV-Modus, ein Host-Suffix unter Kubernetes —, wird beim Start abgelehnt, statt still jede Antwort zu verwerfen: Eine leere Seed-Menge liest sich als „wir sind allein“ und endet in einem Einzelknoten-Cluster.

Frames kommen als JSON an und wurden früher auf den Protokolltyp gecastet statt gegen ihn geprüft — ein Peer konnte einem Knoten also einen Wert reichen, den der Code anschließend las, als stimmte der Typ. Jeder Frame wird jetzt geprüft, bevor ihn irgendein Handler sieht — auf jedem Transport, das Worker-Mesh eingeschlossen:

  • Der Frame muss ein Objekt mit einem String-kind sein. null, ein nackter String und eine Zahl werden abgewiesen — vorher war allein null ein Acht-Byte-Remote-Prozesskill, und zwar ohne abgeschlossenen Handshake.
  • Knotenadressen brauchen ein nicht-leeres systemName und host plus einen positiven ganzzahligen port. Der lohnende Fall: ein Port, der als String "2552" ankommt. Er sieht in jeder Logzeile identisch aus und keyt jede Map gleich, vergleicht sich aber nie gleich — ein Knoten, der seine eigene Adresse in dieser Form mergte, erkannte sich selbst nicht mehr wieder.
  • Der status eines gegossipten Members muss einer der sieben legalen Werte sein. Ein unbekannter erreichte ein exhaustives match, das warf — nachdem der Member schon gespeichert war. Der Knoten stürzte also ab und gossipte den vergifteten Eintrag an seine Peers weiter.
  • Ein Gossip-Batch wird als Ganzes geprüft. Ein fehlerhafter Member weist den Frame ab, damit sich ein schlechter Eintrag nicht hinter einem guten einschleichen kann.

Bewusst zwei Stufen: ein Frame, der die Prüfung nicht besteht, wird verworfen und die Verbindung bleibt stehen — ein einzelner kaputter Frame soll einen gesunden Peer nicht seine Leitung kosten. Ein Handler, der wirft, kappt die Verbindung: das ist der Fall, den niemand versteht, und er darf nicht in den Socket-Callback des Runtimes entkommen.

Das Worker-Mesh übernimmt die erste Stufe und keine Hälfte der zweiten. MessageChannelTransport — der Transport, über den ein Worker-Thread und der Main-Thread über einen MessagePort sprechen — prüft die Form des Umschlags selbst und schickt die Nutzlast dann durch dasselbe validateWireFrame wie die Socket-Transporte, sodass auch ein fehlerhafter Frame von einem Worker nie einen Handler erreicht. WorkerBroker, der zwischen den Threads vermittelt, prüft nur die beiden Adressfelder des Umschlags — die Nutzlast ist Sache des Transports — und schreibt from auf den Port um, auf dem der Frame ankam, sodass ein Worker nicht für einen Geschwister-Worker sprechen kann. Der Broker berichtet auch, was er abweist: Ein fehlerhafter Umschlag oder ein Port, der einen Frame verweigert, ist ein gefaltetes WARN — eine Zeile pro Grund alle 30 Sekunden, mit Zähler —, das die registrierte Adresse des Ports nennt, auf dem der jüngste Frame ankam, und nie die Nutzlast; ein Frame an eine Adresse, die niemand registriert hat, ist dieselbe Zeile auf DEBUG, denn genau das sendet jedes gesunde Geschwister für einen Moment nach einem Crash (#1276). Die Transport-Hälfte berichtet ebenfalls, nach demselben Muster: Ein fehlerhafter Umschlag, eine Nutzlast, die die Wire-Prüfungen abweisen, und ein Handler, der wirft, erhöhen jeweils transport.dropped() und erreichen das Log als ein gefaltetes WARN pro Grund alle 30 Sekunden, mit Zähler. Zwei der drei tragen zusätzlich den Absender; die Umschlag-Variante nicht, und sie kann es auch nicht: Wurde der Umschlag selbst abgewiesen, ist keine Adresse weit genug gelesen worden, um sie zu nennen — diese Zeile lässt most recently from deshalb ganz weg, was die Mesh-Seite über dieselbe Zeile ebenso sagt. Die Nutzlast-Variante nennt den Grund, den validateWireFrame geliefert hat — daran unterscheidet man eine Versionsabweichung von einem feindlichen Peer —, und keine der drei trägt den Frame (#1515). Davor war der Transport die letzte stumme Kante auf diesem Pfad: Ein Worker mit abweichender Version verschwand samt seinen Frames in einem schwarzen Loch, ohne jedes Signal — schlechter als vor der Einführung des Guards, als der Frame wenigstens noch ankam.

Der Absender wird auf dem Weg ins Log escaped, was die Zeile des Brokers nicht nötig hat. Über einen Broker wird from auf den Port umgeschrieben, auf dem der Frame ankam, ist also vom Host vergeben; bei direkter Port-zu-Port-Verdrahtung gibt es keinen Broker, der das tut, und eine Node-Adresse muss nur nichtleere Strings tragen — ein host mit einem Zeilenumbruch darin ist also eine wohlgeformte Adresse, die sonst ganze Log-Zeilen fälschen würde.

Frame-Kinds, die Extensions registrieren (Sharding, PubSub, Receptionist, DistributedData, DevTools), passieren diese Schicht und prüfen ihr eigenes Payload selbst. Replicated Event Sourcing ebenso, dessen Event-Envelopes über PubSub laufen statt über einen eigenen Frame-Kind — siehe was eine Replica ihren Peers glaubt.

Validierung ist nur die Hälfte. Ein Frame kann völlig wohlgeformt sein und trotzdem für einen Node sprechen, der ihn nicht gesendet hat, und diese Fehlerklasse wird in dieser Codebase überall gleich geschlossen: die Identität kommt aus der Verbindung, nicht aus dem Payload. Ein leave darf nur den Node abmelden, der es gesendet hat; Gossip ersetzt den Beitrag des sendenden Peers und den sonst niemandes; eine Sharding- oder Singleton-Direktive wird nur befolgt, wenn sie vom Envelope-Handler des jeweiligen Pfads eingepackt ankam — der einzigen Stelle, an der die authentifizierte Adresse existiert; und die replica eines replizierten Events wird gegen den Node gehalten, der es publiziert hat. Ein Frame, der einen Actor stattdessen über die generische Pfadauflösung erreicht — die nichts entfernt, aber auch keinen Sender mitführt —, gilt als nicht authentifiziert und nicht als vertrauenswürdig.

Der Zustand eines CRDTs ist die eine Stelle, an die diese Regel nicht reicht. DistributedData prüft ein dekodiertes Payload auf Form und Plausibilität: ein Counter-Slot muss eine nichtnegative Ganzzahl höchstens MAX_COUNTER_SLOT sein (≈ 2,2e12 — der größte Wert pro Slot, bei dem value() eines vollen Counters noch eine exakte Ganzzahl ist), ein Register-Timestamp darf höchstens fünf Minuten vor der lokalen Zeit liegen, eine Collection ist auf 4 096 Einträge gedeckelt, und ein __proto__-Key wird abgewiesen. Was es nicht prüft, ist, ob der sendende Peer überhaupt etwas in dem Slot zu suchen hatte, den er beschrieben hat. Grow-only-Counter mergen per Maximum, also kann jeder Peer, der gossipen darf, jeden Replika-Slot innerhalb dieser Schranken anheben — der besitzende Node bekommt ihn nicht wieder herunter, der Wert wandert in den durablen Record, und delete(key) ist Best-Effort, weil ein Peer, der den Key noch hält, ihn zurückgossipt. Ein DistributedData-Counter ist damit genau so vertrauenswürdig wie die Menge der Peers, die du auf die Leitung lässt — was das mTLS-Setup oben für einen Quota- oder Billing-Counter zur Voraussetzung macht statt zur Härtungsmaßnahme.

Auf den Socket-Transporten wird jede Abweisung auf WARN mit Peer und beanstandetem Feld geloggt, damit ein verworfener Frame diagnostizierbar bleibt — eine Versionsabweichung und ein feindlicher Peer sehen im Log unterschiedlich aus. Auf dem Worker-Pfad tun beide Hälften des Kanals dasselbe, gefaltet: Der Broker loggt ein WARN pro Grund für das, was er nicht routet, und der Transport eines für das, was er nicht zustellt; siehe oben.

Die Prüfung läuft auf einem ganzen Frame, und ein ganzer Frame muss aus so vielen TCP-Chunks zusammengesetzt werden, wie der Sender ihn zerlegt hat. Der Peer wählt diese Zerlegung, und das war früher die teure Hälfte: der Decoder baute seinen Akkumulator bei jedem Chunk neu auf, sodass das Zusammensetzen eines Frames quadratisch in der Chunk-Anzahl kostete. Ein Frame knapp unter der 16-MiB-Grenze, geliefert in TCP-großen ~1400-Byte-Writes, sind rund 12 000 Chunks und ≈ 100 GB Speicherkopieren — etwa 6000-fache Verstärkung auf Bytes, die der Angreifer nie senden musste, und erreichbar vor dem hello-Gate, also ganz ohne Mitgliedschaft. Der Decoder hängt jetzt an einen Puffer an, den er durch Verdoppeln wachsen lässt: jedes Byte wird beim Eintreffen einmal kopiert, die Verstärkung ist 1×.

Drei Grenzen decken ab, was ein unauthentifizierter Socket während der Verbindung noch halten darf:

  • Ein unvollständiger Frame darf 30 Sekunden liegen, ohne dass ein weiteres Byte eintrifft, dann wird die Verbindung geschlossen. Das ist eine Stall-Grenze, kein Budget für den Frame: die Deadline wird bei jedem Chunk neu gestellt, ein Peer mit einem großen Frame auf einer überlasteten Leitung wird also nie für Langsamkeit bestraft — nur fürs Verstummen.
  • Der Handshake selbst hat 5 Sekunden, gerechnet ab dem Annehmen des Sockets; ein angenommener Socket, der bis dahin kein hello geschickt hat, wird geschlossen. Genau das deckt ein unvollständiger Frame nicht ab: ein Socket, der gar keine Bytes sendet, steckt in keinem Frame fest, also wird an ihm auch nichts verfolgt. Es sind dieselben 5 Sekunden, die sich die wählende Seite selbst gibt, und deren Uhr läuft früher los — vor dem TCP-Connect und dem TLS-Handshake — ein Peer, der es noch versucht, hat also immer schon vorher aufgegeben. Sobald das hello da ist, ist die Deadline weg: ein etablierter Peer zwischen zwei Gossip-Runden ist von Natur aus untätig und wird dafür nie geschlossen.
  • Eingehende Verbindungen sind auf 1024 begrenzt. Ein voll vermaschter Cluster braucht eine pro Peer, die Grenze liegt also weit über jeder realistischen Topologie; was sie nimmt, ist die Möglichkeit, die Kosten pro Verbindung durch das Öffnen von Sockets in einer Schleife zu vervielfachen. Die neueste Verbindung wird abgewiesen, statt eine etablierte zu verdrängen — Verdrängung ließe einen Angreifer echte Peers vom Knoten stoßen.

Die zweite und die dritte gehören zusammen. Eine Obergrenze ist nur so viel wert wie der Durchsatz ihrer Slots, und ohne Handshake-Deadline wird die Obergrenze selbst zum Angriff: 1024 Verbindungen, die nichts senden, halten jeden Slot für die Lebensdauer des Prozesses, und jeder Peer und jeder ClusterClient danach wird abgewiesen. Auf Bun ist das sogar unter mTLS erreichbar, denn der open-Callback eines Sockets feuert bevor der TLS-Handshake fertig ist — der Slot wäre belegt, während es noch gar kein Zertifikat zu prüfen gibt.

Die erste und die dritte begrenzen den eingehenden Decode-Speicher überhaupt erst: als Produkt der beiden, wobei der Term pro Verbindung schon durch actor-ts.remote.max-frame-bytes gedeckelt ist. Diesen Key zu senken ist auch der Hebel für ein Deployment, das nie große Envelopes schickt — die residenten Kosten pro Verbindung folgen ihm direkt.

Bytes und Arbeit sind nicht dieselbe Grenze, und hier trennen sich die beiden. Ein akzeptierter Frame geht an JSON.parse und erst danach an den Tagged-Tree-Walker; die Tiefengrenze (actor-ts.serialization.read-constraints.max-nesting-depth) meldet ein zu tiefes Payload also erst, nachdem das Parsen es bereits aufgebaut hat. Auf Bun 1.4 gemessen kostet ein einzelner 16-MiB-Frame aus ausbalancierten [ rund 1,0 s CPU und 260 MiB Heap bis zur Ablehnung — etwa das Vierfache eines legitimen Frames derselben Größe, und wiederholbar für jeden Peer, der den Handshake abgeschlossen hat. Zwei Keys begrenzen das, keiner davon ist per Default aktiv: remote.max-frame-bytes und serialization.read-constraints.max-document-bytes, das gegen dasselbe 4-Byte-Längen-Präfix geprüft wird und den Frame ablehnt, bevor sein Payload überhaupt gepuffert ist. Ein Vorab-Scan des Rohpuffers würde es ohne beide schließen; er wurde mit 18–28 % jeder Frame-Dekodierung gemessen und für eine vierfache Verstärkung nicht ausgeliefert (#880).

Was ein wohlgeformter Frame trotzdem nicht wachsen lassen kann

Abschnitt betitelt „Was ein wohlgeformter Frame trotzdem nicht wachsen lassen kann“

Die Shape-Prüfung sagt, dass ein Frame lesbar ist — nicht, dass es umsonst ist, auf ihn zu reagieren. PubSub-Gossip ist das saubere Beispiel: ein Peer, der 100 000 Topics nennt, für die er Subscriber beansprucht, schickt einen völlig legalen Frame, und der Empfänger legte dafür früher 100 000 Map-Einträge an — kein lokales Subscribe, kein fehlerhaftes Feld, keine Logzeile. Der Receptionist hatte auf seinem eigenen Gossip-Pfad dieselbe Form.

Die Mitgliedschaft selbst hatte dieselbe Form — und sie ist die eine Registry, in die niemand erst hineinoptieren muss: jeder geclusterte Knoten hält eine Mitgliederkarte, und Gossip ist das, was sie füllt. Die Regeln weiter unten entscheiden, ob ein Anspruch glaubhaft ist; keine von ihnen begrenzte, wie viele glaubhafte Ansprüche ein Peer erheben darf. Ein Sender, der seine eigene Adresse ankündigt, wird bewusst durchgewunken — das zu verweigern hieße, dass kein Knoten je joinen könnte — also legte eine frisch benannte Adresse pro Frame einen Eintrag pro Namen an.

Diese Registries sind jetzt begrenzt, und die Grenzen gelten für den Gossip-Pfad genauso wie für lokale Aufrufe:

RegistryBegrenzt durchDefault
Lebende Cluster-Mitgliedercluster.max-members1000
removed-Tombstonescluster.max-tombstones10000
PubSub-Subscriber pro Topiccluster.pub-sub.max-subscribers-per-topic10000
PubSub-Topicscluster.pub-sub.max-topics10000
PubSub-Remote-Ansprüche pro Topiccluster.pub-sub.max-remote-nodes-per-topic1000
Receptionist-Subscriber pro Keycluster.receptionist.max-subscribers-per-key1000
Receptionist-Subscriptions insgesamtcluster.receptionist.max-subscriptions-total10000

Ein Anspruch über einer Grenze wird verworfen und geloggt, statt auf der Wire abgewiesen zu werden — der Frame ist wohlgeformt, und die Verbindung deswegen zu kappen ließe einen lauten Peer eine gesunde Leitung kosten. Ein lokales Subscribe über einer Grenze wird stattdessen mit SubscribeRejected beantwortet, denn der Aufrufer kann etwas dagegen tun. Beide PubSub-Registries watchen außerdem ihre Subscriber, sodass die andere Hälfte des alten Wachstums — Refs, die stoppten, ohne je zu unsubscriben — zurückgewonnen statt begrenzt wird.

Senke die Defaults für ein Deployment, dessen legitime Zahlen weit darunter liegen: eine Obergrenze begrenzt nur den Schaden, und eine weit über der echten Nutzung begrenzt sehr wenig.

Mitglieder und Tombstones zu trennen ist keine Ordnungsliebe: Die beiden Arten von Phantom leben verschieden lange. Ein Phantom-Mitglied in up / joining / unreachable, das als Eintrag in einem Gossip-Frame ankommt, ist ein Mitglied, das der Failure Detector ab dem Merge beobachtet, und weil nie jemand Heartbeats für es schickt, erklären es beide Detectors für down — φ misst die Stille ab diesem Moment. Was dieses Urteil bewirkt, entscheidet die Downing-Konfiguration. Unter dem Default — keine Strategie, failure-detector.auto-down = on — entfernt der Detector es, down-after nach dem letzten Nachschub, und endgültig erst, wenn kein anderer Knoten es noch trägt, denn dieser Weg löscht ohne Tombstone, und ein Knoten, der das Phantom noch nicht gelöscht hat, gossipt es zurück. Mit konfigurierter Strategie oder unter auto-down = off wird das Phantom wie jeder stille Peer auf unreachable geparkt und hält seinen lebenden Platz, bis eine Strategie oder ein Operator es entfernt. Das Absender-Feld eines Frames ist überhaupt kein Weg mehr. Ein from, das eine Adresse nannte, zu der dieser Knoten keinen Eintrag hatte, wurde früher ohne Berechtigungsprüfung als joining abgelegt und wie jedes beitretende Mitglied befördert — als Leader dieses Knotens, wenn seine Adresse zuerst sortierte, und als Adresse, die die Heartbeat- und Gossip-Ticks danach anwählten. Diese Tür ist zu (Issue #939): Ein Absender wird über seinen eigenen Eintrag eingeführt, der wie jeder andere gemergt wird, und jeder Gossip-Frame trägt einen. max-members ist darum die eine Schranke für lebende Phantome und der Merge der eine Weg hinein. Ein als removed gegossipter Eintrag wird von nichts beobachtet; nur das Aufräumen der Tombstones holt ihn zurück, sobald der größere Wert von cluster.tombstone.time-to-live und tombstone.min-retention verstrichen ist — einen Tag bei den Defaults. Zwei Reste mit zwei Lebensdauern, also zwei Grenzen. Einen Tombstone abzulehnen kostet nichts: ein Tombstone für eine Adresse, zu der dieser Knoten keinen Eintrag hat, unterdrückt nichts, was existiert — während ein abgelehnter lebender Eintrag ein legitimes Mitglied eine Gossip-Runde kostet und mit einem WARN samt Namen der Grenze kommt.

Beide Grenzen werden auf den Topf abgerechnet, in den ein Record wandert, nicht darauf, ob er einen Eintrag neu anlegt. Ein gegossipter Record, der einen Eintrag dort lässt, wo er schon ist — up → unreachable, oder ein neuerer Tombstone über einen älteren —, ist ein kostenloses In-Place-Update. Einer, der zwischen den Töpfen wechselt, wird dem Topf angerechnet, den er betritt: ein als up wiedergeborener Tombstone braucht Platz bei den lebenden Mitgliedern, ein als removed gegossiptes lebendes Mitglied braucht Platz bei den Tombstones. Nur das Anlegen zu berechnen ließ die beiden Grenzen kostenlos Spielraum untereinander tauschen — eine Wiedergeburt räumte den Tombstone-Topf, ohne einen Map-Slot herzugeben, sodass die nächste Tombstone-Flut ebenfalls durchging; im Wechsel wuchs die Map unbegrenzt, obwohl beide Grenzen bei jedem einzelnen Schritt eingehalten wurden. Eine abgelehnte Umwandlung lässt das Mitglied lebendig, wo es den Weg jedes stillen Mitglieds geht: unter dem Default bei down-after vom Detector entfernt oder — mit konfigurierter Strategie oder unter auto-down = off — auf unreachable geparkt, bis eine Strategie oder ein Operator es entfernt.

Tombstones, die der Knoten selbst erzeugt — das leave eines Peers, eine Downing-Entscheidung, ein down() des Operators — wandeln einen Eintrag um, den er ohnehin schon hält, und unterliegen der Grenze nie. Die eigene Buchführung zu begrenzen würde die Unterdrückung wegnehmen, die verhindert, dass altes Gossip eine geräumte Adresse wiederbelebt — ein Liveness-Bug im Kostüm eines Security-Fixes.

Die Decke, die man kennen sollte, ist nicht der Heap. Gossip trägt die vollständige Mitgliederliste, also überschreitet der eigene Frame eines Knotens bei rund 110 000 Einträgen remote.max-frame-bytes, und jeder Peer beendet die Verbindung schon am Längen-Präfix — der Knoten wirft sich selbst aus dem Cluster, während er noch läuft, lange bevor irgendwo der Speicher ausgeht.

Der Failure Detector unterliegt derselben Grenze. Er hält Zustand pro Peer und legte diesen früher für jede Verbindungsidentität an, unter der ein Frame ankam — ohne mTLS ein Name, den der Peer in seinem hello selbst wählt. Ein Peer, der sich unter immer neuen Namen verband, ließ ihn um einen Eintrag pro Namen wachsen, während die Mitgliederliste an ihrer Grenze stand: 500 Namen hinterließen 502 Einträge neben 3 Mitgliedern, beim φ-Accrual-Detector jeder mit einem eigenen Probenfenster. Lebenszeichen erreichen den Detector jetzt nur noch für ein Mitglied, das kein Tombstone ist, oder für einen konfigurierten Seed, der ebenfalls keiner ist. Jeder Weg, der ein Mitglied aufnimmt, meldet es an, und jeder Weg, der es aus den lebenden Mitgliedern nimmt, vergisst seinen Eintrag — ein Tombstone, den dieser Knoten selbst erzeugt, ein Tombstone, den ein gegossipter Eintrag bringt, und ein Löschen aus der Mitgliederliste gleichermaßen. Der Detector hält also einen Eintrag pro lebendem Mitglied und höchstens einen pro Seed, begrenzt durch max-members und die Seed-Liste (#1103).

Die Shape-Prüfung zu bestehen macht einen Frame noch nicht glaubwürdig. Gossip-Merges entschied früher allein die Versionsgröße, und Versionen werden aus Date.now() gesät — ein Angreifer konnte sich also immer eine Gewinnerzahl aussuchen und jeden Member-Status umschreiben, auch den des empfangenden Knotens selbst. Vor dem Merge stehen jetzt zwei Regeln:

  • Niemand stuft uns herab. Eine Aussage über die eigene Adresse dieses Knotens wird abgewiesen. Die einzige Ausnahme ist die Beförderung von joining/weakly-up nach up — die muss von außen kommen, weil sie die Entscheidung des Leaders ist, und sie anzunehmen ist harmlos, denn ein joinender Knoten will ohnehin up werden. Begrenzt wird sie dadurch, wie wenig sie transportiert: den Status und eine Version, die nur die Obergrenze maxVersionSkewMs beschränkt (standardmäßig 5 Minuten, siehe Eine Version kann keine Adresse im Voraus beanspruchen unten) — ein Fremder kann den Record dieses Knotens also bis zu so weit in die Zukunft datieren; die Version zu klemmen verfolgt #1797. Mehr kommt nicht herüber. Die Beförderung fragt nichts über ihren Absender, deshalb muss dieser Knoten seine eigenen Rollen, Inkarnation, Storage-Identitäten, Konfigurationsfakten und App-Version behalten, egal was der Record sagt. Vor #1104 kamen die Rollen aus dem Record — und bei einem Knoten, der selbst keine Storage-Identität aufgelöst hatte, auch diese —, ein einziges Frame eines Fremden im Joining-Fenster bestimmte also, was dieser Knoten hostet und platziert. Alles andere über den eigenen Record entscheiden wir selbst.
  • Aussagen über Dritte brauchen einen Absender mit Standing. Etwas über einen anderen Knoten zu behaupten setzt voraus, dass der Peer der Verbindung ein Member ist, den dieser Knoten bereits als aktiv führt. Seinen eigenen Record darf ein Absender immer ankündigen — so funktioniert der Join.

Beide Regeln hängen am Peer der Verbindung, nicht am from-Feld des Payloads: genau dieses Feld kontrolliert ein Angreifer vollständig. Dieselbe Überlegung deckt drei Nachbarn mit ab. Ein leave wird nur vom scheidenden Knoten selbst akzeptiert. Ein Heartbeat frischt den Failure Detector für den sendenden Peer auf statt für die Adresse, die er nennt — das ließ vorher einen Peer einen toten Knoten dauerhaft gesund erscheinen und brachte den Empfänger dazu, einen angreiferbestimmten Host anzuwählen. Und ein ClusterClient-ask wird über die Verbindung beantwortet, auf der das Envelope ankam: auf der Payload zu routen ließ jede verbundene Gegenstelle die Adresse wählen, an die dieser Knoten antwortete und zu der er eine Verbindung aufbaute.

Das Client-Envelope trägt überhaupt kein Absenderfeld mehr — nach der obigen Regel hatte es genau einen richtigen Wert, und zwar den, den der Empfänger ohnehin schon hat. Ein Envelope, das weiterhin eine andere Adresse als seine eigene Verbindung nennt, wird auf cluster_envelope_from_mismatch_total{frame} gezählt und sonst ignoriert; siehe ClusterClient.

Unerreichbarkeit ist bewusst nicht von diesen Regeln erfasst: „Ich erreiche C nicht” ist naturgemäß eine Drittbeobachtung, und alle Knoten müssen auf dieselbe Sicht konvergieren, bevor ein Downing-Provider entscheidet. Solche Aussagen abzuweisen ließe jedem Knoten nur sein eigenes Erreichbarkeitsbild.

Die erste Regel heißt, dass kein Peer diesem Knoten sagen kann, dass er entfernt wurde — und ein Knoten, den der Rest des Clusters gedownt hat, während er pausiert oder abgeschnitten war, lief früher mit allem weiter, was er hielt. Ein Peer, der den Lauf dieses Knotens als removed führt, beantwortet seine Heartbeats deshalb mit einem membership-refused-Frame statt einer Bestätigung und nennt diesen Lauf mit seiner Inkarnation (#940). Der Frame gilt nur als Aussage über den Absender: „Ich nehme dich nicht zurück”. Der Empfänger parkt diesen Peer als unreachable und lässt ihn nicht mehr durch dessen Heartbeats zurückkommen; sein eigener Eintrag bleibt unberührt, und das Urteil bleibt bei seiner eigenen Downing-Strategie. Sobald ihn jeder Peer abgelehnt hat, gilt die Sicht als stabil, und die Strategie wird sofort gefragt statt nach stable-after.

Eine gefälschte Ablehnung erreicht also, was das Verwerfen des Verkehrs dieses Peers ohnehin erreicht — der Peer wirkt unreachable —, und nicht mehr: Der Gossip des echten Peers, der diesen Knoten als Mitglied führt, nimmt sie zurück, und eine Ablehnung, die einen anderen oder keinen Lauf an dieser Adresse nennt, wird ignoriert. Eine Fälschung für jeden Peer lässt die Strategie des Knotens über eine Sicht entscheiden, in der er allein ist; das ist die Reichweite, die das Kappen seines gesamten Verkehrs hat, und der Grund, warum der Hinweis unten auch hier gilt.

Die Regeln oben begrenzen, was ein Frame behaupten darf. Eine weitere begrenzt, was es erreichen darf: Ein envelope trägt den Zielpfad, den der Absender gewählt hat, und der Knoten löst ihn gegen seinen eigenen Aktor-Baum auf. Diese Auflösung lief früher von der Wurzel los, /system/… war also genauso erreichbar wie /user/… — jeder Peer, der ein hello abgeschlossen hatte, konnte direkt an einen Shard-Coordinator, einen Singleton-Manager oder den PubSub-Mediator zustellen, am Pro-Pfad-Handler vorbei, den jeder von ihnen registriert, und damit an der Absender-Zuordnung vorbei, auf der die Regeln oben aufbauen.

Der /system-Teilbaum wird auf diesem Weg jetzt abgelehnt, in jeder Konfiguration und an beiden Nahtstellen — der Cluster-Verbindung und dem ClusterClientReceptionist. Framework-Aktoren bleiben über ihre registrierten Handler erreichbar, also über die Tür, die weiß, auf welcher Verbindung ein Frame ankam. Nichts, was ein Betreiber konfigurieren kann, öffnet den alten Weg wieder.

Die /user-Hälfte ist die Entscheidung des Deployments, denn dass ein Peer einen Anwendungsaktor benennt, ist genau die Art, wie eine ActorRef über Knoten hinweg funktioniert. Engt sie dort ein, wo das Cluster-Netz eine Grenze überschreitet, die ihr nicht kontrolliert:

actor-ts.remote {
untrusted-mode = true
trusted-selection-paths = ["/user/orders/*", "/user/reporting/intake"]
}

Ein Eintrag ist ein exakter Pfad, außer er endet auf /* — dann ist er dieser Pfad und sein Teilbaum, segmentverankert: /user/orders/* lässt /user/orders-archive also nicht zu. Ablehnungen werden auf cluster_envelope_refusals_total{reason, frame} gezählt und zu höchstens einem WARN pro Grund alle 30 Sekunden gefaltet, das den Peer der Verbindung nennt und nie den angefragten Pfad; eine Zeile pro Ablehnung würde dem Peer stattdessen Log-Verstärkung schenken. Beobachtet reason="not-allow-listed" an dem Tag, an dem ihr den Modus anschaltet — dort taucht eine unvollständige Allow-List auf. Siehe Konfiguration.

Dieselbe Policy bewacht den einen anderen Frame, in dem ein Peer einen Pfad seiner Wahl nennt: ein watch. Ein abgelehnter Pfad wird wie ein fehlender beantwortet — Terminated mit existenceConfirmed = false —, sodass ein Watcher nie hängt und die Antwort nichts preisgibt, was die Ablehnung nicht ohnehin schon täte; die Ablehnung wird unter frame="watch" gezählt.

Ein Ref in einer Nachricht bestimmt nicht, wohin dieser Knoten wählt

Abschnitt betitelt „Ein Ref in einer Nachricht bestimmt nicht, wohin dieser Knoten wählt“

Die andere Richtung hat dieselbe Form. Ein ActorRef im Nachrichtenkörper geht als Marker über die Leitung, der seinen Knoten nennt — System, Host, Port —, und der Empfänger baut daraus einen Remote-Ref. Diese Adresse ist eine Behauptung des Absenders. Früher wurde der Marker ohne die Prüfung zurückgebaut, die jede andere Wire-Adresse bekommt, und der Knoten, den ein Ref nannte, wurde in dem Moment angewählt, in dem der Ref benutzt wurde: Ein Aktor, der einem dekodierten replyTo antwortete — die Redewendung, der jeder Handler folgt —, öffnete eine Verbindung zu einer Adresse nach Wahl des Absenders und schrieb einen Frame hinein, etwa an einen Cloud-Metadaten-Endpunkt oder einen internen Admin-Port. Den Ref zu beobachten tat dasselbe mit einem watch-Frame (#936).

Ein Marker wird jetzt als Knotenadresse geprüft, und einer, der nicht gültig ist, wird zu Nobody. Und ein Frame mit einer Nutzlast oder einer Death-Watch-Nachricht — jeder Versand, der nicht zum Mitgliedschaftsprotokoll selbst gehört — geht nur noch an:

  • ein Mitglied, das kein Tombstone ist, oder
  • einen Knoten, zu dem der Transport schon eine Verbindung hält, bestätigt oder noch im Handshake — über eine bestehende Verbindung zu senden wählt nichts an. So erreicht eine Antwort einen Knoten, der beigetreten ist, von dem dieser Knoten aber noch nichts gehört hat, und so wird ein tell an einen Seed direkt nach dem Auflösen von Cluster.join auf der Verbindung eingereiht, die der Beitritt geöffnet hat, statt verworfen zu werden. Ein eigener Transport, der das optionale holdsConnectionTo nicht implementiert, wird stattdessen über peers() gefragt, das nur bestätigte Verbindungen kennt; auf ihm wird dieses tell abgelehnt, bis der Handshake durch ist.

Alles andere wird verworfen, wie ein Frame an einen unerreichbaren Knoten, unter cluster_outbound_refusals_total{frame} (envelope oder wire) gezählt und zu höchstens einem WARN alle 30 Sekunden zusammengefasst, das das letzte Ziel escaped nennt. Die häufigste Ursache auf einem gesunden Cluster ist ein Knoten, der gerade gegangen ist. Ein Ref wird verzögert gebaut, also funktioniert einer zu einem Knoten, von dem dieser Knoten einen Moment später erfährt, noch, wenn er benutzt wird. Einen Ref zu beobachten, dessen Knoten abgelehnt wird, wird sofort mit Terminated und existenceConfirmed false beantwortet, wie eine abgelehnte Beobachtung auf der Gegenseite, damit der Beobachter nicht auf eine Antwort wartet, die nicht kommen kann.

Die Regel ist nur so stark wie die Mitgliedschaft. Seit #939 trägt das from in der Payload eines Gossip-Frames kein Mitglied mehr ein: Ein Absender wird nur über seinen eigenen Eintrag aufgenommen, als Selbstankündigung, die an die Identität gebunden ist, die seine Verbindung vorgelegt hat. Ohne mTLS wählt der Peer diese Identität aber selbst. Ein Peer, der sich verbinden kann, kann sich also unter einer Adresse seiner Wahl ankündigen — und von da an lässt diese Sperre Frames an ihn durch, und das Gossip und die Heartbeats des Mitgliedschaftsprotokolls selbst wählen ihn in jedem Intervall an, ganz ohne Ref. Das hier schließt also den Weg über einen Nachrichtenkörper, nicht das Erzeugen eines Mitglieds. mTLS ist das, was die Adresse eines Mitglieds an ein Zertifikat bindet.

Eine Sharding-Direktive braucht den Koordinator dahinter

Abschnitt betitelt „Eine Sharding-Direktive braucht den Koordinator dahinter“

Dieselbe Überlegung reicht eine Schicht höher, in die Extensions, deren Frames die Wire-Kante passieren und ihre Payload selbst validieren. Eine ShardRegion behandelte jede Nachricht, deren kind mit sharding. begann, als Framework-Direktive — inklusive der fünf, die ausschließlich der Koordinator aussprechen darf. HandOff stoppt jede Entity unter einem Shard; ShardHome verschiebt den Besitz; RememberedEntities legt Entities vorab an; ShardMapUpdate veröffentlicht eine Allokationskarte an jeden lokalen Subscriber, DevTools-Panel und Anwendungs-Listener inklusive. Ein kleiner Frame von jedem, der hello abgeschlossen hatte, löste das aus — beliebig oft.

Die Region konnte gar nicht prüfen: Sharding registrierte keinen pfadgebundenen Envelope-Handler, ein eingehender Frame erreichte den Actor also über die generische Pfadauflösung, und die stellt ohne jeden Absender zu. Die Region beansprucht jetzt ihren eigenen Pfad im Envelope-Router, der dem Handler den Peer der Verbindung übergibt, und verpackt den Frame in eine Klasseninstanz, bevor sie ihn in die eigene Mailbox legt — eine Form, die ein JSON-Wire-Body nicht erzeugen kann, sodass die Direktiven-Arme einen geroutet zugestellten Frame von einem gefälschten unterscheiden können. Ein getaggtes { kind }-Objekt hätte nicht gereicht: Das lässt sich aus einer Payload wortgleich nachbilden.

Beide Hälften tragen. Ohne die Wrapper-Prüfung verfehlt ein nicht-kanonisch adressierter Frame — ein Slash am Ende, ein doppelter Trenner — den exakten String-Lookup des Handlers, löst sich über den Actor-Baum trotzdem auf dieselbe Region auf und kommt unverpackt an. Und ohne die Herkunftsprüfung ist ein authentifizierter Peer schlicht jedes Cluster-Mitglied, sodass jedes Mitglied jeder Region Direktiven erteilen könnte.

Verworfene Frames werden gedroppt und auf WARN geloggt. Der lokale Zweig des Koordinators baut denselben Wrapper, ein Ein-Node-Cluster rebalanciert also genau wie zuvor.

Eine Region kann nur für ihren eigenen Node sprechen

Abschnitt betitelt „Eine Region kann nur für ihren eigenen Node sprechen“

Dieselbe Lücke lief auch in die andere Richtung, und dort war sie teurer. Jede Nachricht, die ein ShardCoordinator annimmt, ist eine Aussage über den eigenen Node des Absenders: welche Shards seine Region hostet, dass seine Region weg ist, dass ein Hand-off fertig ist, wohin ein Shard-Home oder eine Statistik-Antwort geht. Der Koordinator las das alles aus der Payload. Sein einziges Gate war isLeader() — plus, mit Lease, das gehaltene Lease — und das beantwortet „bin ich der autoritative Koordinator?”, nie „darf dieser Absender für jene Region sprechen?”.

Ein einziges wohlgeformtes sharding.Register mit der Adresse eines anderen riss damit jeden Shard eines Typs an sich, und ein sharding.RegionTerminated warf dessen Region hinaus. Die Räumung ist die schlimmere Hälfte: Sie verschickt kein HandOff, das Opfer behält seine Shard-Actors und seine Entities also im Betrieb. Ergebnis sind zwei Besitzer für einen lebenden Shard — dieselbe Entity-Id zweimal instanziiert und, bei einer persistenten Entity, zwei Schreiber auf einer persistenceId.

Die Herkunftsprüfung der Region oben mildert das nicht, denn der Angreifer schickt gar kein ShardHome. Er vergiftet die Allokationskarte des Koordinators mit einem gefälschten Frame, und der echte Koordinator verschickt die Umleitung dann selbst — vom Node des Leaders, in einem Wrapper, den jede Region zu Recht annimmt. Eine Fälschung, jeder weitere Hop echt.

Der Koordinator beansprucht jetzt seinen eigenen well-known Pfad im Envelope-Router und wendet dieselben zwei Bedingungen an: Der Frame kam im Wrapper an, und die Adresse in seiner Payload ist die des Peers. Beide Richtungen der Register-Schleife sind damit attribuiert — was auch korrigiert hat, wie eine Region den Koordinator adressiert: über den Systemnamen des Leaders, nicht über den eigenen, denn ein Actor-Pfad trägt das System, zu dem er gehört.

hostedShards ist obendrein begrenzt und gedeckelt. Es war die einzige Eingabe des Koordinators, deren Größe der Aufrufer bestimmte — ein Register schrieb einen Allokationseintrag pro Array-Element, ohne Bereichsprüfung und ohne Längenlimit, in Zustand, der an jede Region gesendet und in den Coordinator-State-Store persistiert wird; das Wachstum überlebte also Neustarts. Einträge außerhalb 0 .. numShards - 1 werden jetzt verworfen, und die akzeptierte Menge kann numShards nicht überschreiten.

Eine Version kann keine Adresse im Voraus beanspruchen

Abschnitt betitelt „Eine Version kann keine Adresse im Voraus beanspruchen“

Die Version ist eine logische Uhr, gesät aus Date.now() — und „höchste Version gewinnt” entscheidet damit auch, was beim ersten Auftauchen einer Adresse überhaupt passiert. Genau das machte eine Adresse beanspruchbar, bevor der Knoten existiert, dem sie gehört. Ein Fremder kündigt sich unter der Adresse an, die der nächste Pod bekommen wird — den eigenen Record anzukündigen ist die eine Aussage, die die Regeln oben nie abweisen —, datiert sie dicht an die 24-h-Skew-Grenze und hängt beliebige Rollen daran. Die Beförderungsschleife des Leaders hebt den Record in die aktive Menge, und der Knoten, dem die Adresse wirklich gehört, verliert danach jeden Merge: er sät seine Version aus der eigenen Uhr, und die ist niedriger. Aus Rollen werden Routing, Sharding-Platzierung, Singleton-Hosting und Downing-Quoren berechnet — das Phantom ist also keine kosmetische Zeile in einer Member-Liste.

Eine gegossipte Member-Version unterliegt deshalb einem engen Uhrabweichungs-Budget — standardmäßig 5 Minuten:

const clusterOptions = ClusterOptions.create()
.withHost('10.0.0.5')
.withPort(2552)
.withMaxVersionSkewMs(30 * 60 * 1000);

Das Budget gilt für jeden Merge, nicht nur für den Record, der eine Adresse einführt. Ursprünglich war es die engere Regel — enge Grenze bei der Erstsichtung, großzügige 24 h bei jedem Update —, und diese Aufteilung ließ sich umgehen, indem man die Adresse zuerst einführte: zwei Records für dieselbe Adresse in einem Frame, oder — bis #939 die Tür entfernt hat, die den selbsterklärten Absender eines Frames eintrug — ein Frame ganz ohne Member-Records. Jede Regel, die einen Record das weitere Budget verdienen lässt, scheitert einen Schritt später genauso — ohne Peer-Zertifikate kann der Angreifer jeden Schritt des Verdienens selbst erzeugen.

Erhöhe den Wert für ein Deployment, dessen Uhren bekanntermaßen lose laufen; 24 * 60 * 60 * 1000 stellt das alte Verhalten mit einer einzigen Grenze wieder her. Eine Abweisung ist Ausschluss, und zwar ein dauerhafter: Ein Knoten wird nur durch seinen eigenen Record eingeführt, also wird ein Knoten, dessen Uhr weiter vorgeht als das Budget, gar nicht erfasst. Er bleibt außerhalb der Member-Liste — mit der WARN-Zeile unten, die die Grenze nennt —, bis seine Uhr wieder innerhalb des Budgets liegt. Das war immer schon das Urteil dieser Grenze über einen solchen Knoten; geändert hat sich, dass es jetzt bestehen bleibt, statt von der Absender-Tür abgeschwächt oder vom zweiten Gossip-Frame des Knotens aufgehoben zu werden.

Abgewiesene Records werden einmal pro Frame gemeldet, nicht einmal pro Record — eine WARN-Zeile mit Peer und Anzahl, dazu der Zähler cluster_gossip_records_refused_total{reason}, dessen Label reason auf version-skew, map-cap, timestamp-skew, replayed-frame, self-claim, removed-run und foreign-cluster geschlossen ist. Pro Record zu loggen würde einem Peer Log-Verstärkung schenken statt des Wachstums, das er gerade verloren hat.

removed-run ist ein Record für einen Lauf, den dieser Knoten als removed führt — dieselbe Adresse und dieselbe Inkarnation. Eine Version wählt der Absender und konnte immer über einen Grabstein hinaus neu gestempelt werden; eine Inkarnation benennt den Prozess, den der Cluster entfernt hat, und nur ein Neustart erzeugt eine neue. Seit Cluster-Wire v2 trägt jede Adresse auf einem Frame sie, also kann der gedownte Lauf unter keiner Version zurückkommen, während ein Neustart an derselben Adresse weiterhin sofort beitritt (#823, #940).

self-claim ist die Regel von oben, aus Sicht des Zählers: ein Peer behauptet einen Status für den empfangenden Knoten, der weder der bereits gehaltene ist noch die Beförderung nach up durch den Leader. Dass ein Peer den Status zurückspiegelt, den der Knoten tatsächlich hält, ist der gewöhnliche Inhalt jeder Gossip-Runde — der eigene Record kommt in jedem Frame zurück —, und genau der wird abgewiesen, ohne gezählt oder geloggt zu werden. In einem gesunden Cluster steht der Zähler damit weiterhin auf null.

Ein mitgeschnittener Frame lässt sich nicht bei einem Empfänger abspielen, der von seinem Absender gehört hat

Abschnitt betitelt „Ein mitgeschnittener Frame lässt sich nicht bei einem Empfänger abspielen, der von seinem Absender gehört hat“

Ein Gossip-Frame ist eine Momentaufnahme der Member-Map, und die Version eines Members bewegt sich nur, wenn sich sein Status bewegt — ein vom Draht mitgeschnittener Frame bleibt also unbegrenzt gültig. Gegen einen konvergierten Empfänger kostet das nichts: jeder Record darin verliert den Vergleich „höhere Version gewinnt” gegen den Record, der schon da ist. Zum Exploit wird es bei einem Eintrag, den der Empfänger gelöscht hat, und zwei Wege löschen einen. Das eigene Entfernen des Failure Detectors — der Default ohne konfigurierte Strategie, unter failure-detector.auto-down = on — löscht rundheraus, statt einen Tombstone zu hinterlassen. Begründet wurde das einmal damit, dass eine Partition nach dem Heilen den Peer so wiederfinde, und genau das bringt das Löschen nicht: Keine Seite schickt einem Peer, den sie für unerreichbar hält, Heartbeats oder Gossip, und einen gelöschten hat sie gar nicht mehr in ihrer Map, um ihn zu adressieren — nach einer symmetrischen Partition hört also keine Seite je wieder von der anderen (Issue #930). Unter dem Default entfernen sich die beiden Seiten einer echten Partition also gegenseitig und laufen als zwei Cluster weiter — ein weiterer Grund, warum ein Produktions-Deployment lease-majority oder eine andere Downing-Strategie konfiguriert. Und ein abgelaufener Tombstone wird entfernt, sobald der größere Wert von seiner Lebensdauer und tombstone.min-retention verstrichen ist. So oder so bleibt nichts zum Vergleichen übrig, und der Zweig, der eine Erstsichtung ablegt, hat überhaupt keine untere Versionsgrenze. Die übrigen Entfernungen — ein down() des Operators, die Entscheidung einer Strategie, das leave eines Peers — hinterlassen einen Tombstone, der den Mitschnitt bis zu diesem Aufräumen überbietet; mit konfigurierter Strategie oder unter auto-down = off entfernt der Detector selbst niemanden. Ein Neustart, der einen lebenden Eintrag seines vorherigen Laufs ersetzt, löscht diesen Eintrag ebenfalls, aber der Eintrag des neuen Laufs übernimmt den Schlüssel im selben Schritt mit höherer Version, ein Mitschnitt des alten Laufs verliert den Vergleich also weiterhin.

Das Wiedereinspielen des eigenen Records eines heruntergefahrenen Members brachte ihn also zurück: gleiche Adresse, gleiche Version, up, mit den Rollen, die er hatte. Shard-Platzierung und Singleton-Hosting richten sich nach den Rollen, der Cluster schickt also Arbeit an einen Knoten, den er verstoßen hatte.

Jeder Gossip-Frame trägt deshalb eine Sequence, die sein Autor stempelt — beim Start aus dessen Wanduhr gesetzt und pro Frame um eins erhöht — und ein Empfänger merkt sich die höchste, die er von jedem Verbindungs-Peer akzeptiert hat. Ein Frame, der diese Marke nicht überbietet, wird als Ganzes verworfen, bevor ein einziger Record darin angesehen wird. Der Vergleich selbst braucht keinen Stellknopf: verglichen wird ein Peer mit sich selbst, damit kommt kein Uhren-Skew-Budget ins Spiel.

Die Marke wird an genau einer Stelle geschrieben — im Gossip-Pfad, während er einen Frame annimmt — sie existiert also für einen Peer, von dem dieser Knoten einen Frame angenommen hat, und für keine andere Adresse. Das ist die Grenze, und das dritte Restrisiko unten ist das, was außerhalb davon liegt.

Eine Sequence muss außerdem plausibel sein — eine endliche Zahl, die nicht weiter vor der Uhr des Empfängers liegt als maxVersionSkewMs, dasselbe Budget, das eine gegossipte Version bekommt, denn die Zahl wird aus der Wanduhr des Autors gestempelt. Ein Frame außerhalb dieses Budgets wird abgewiesen, genau wie eine Wiederholung.

Angefangen hat das als die schwächere Regel: der Frame wurde gemerged, und nur das Übernehmen seiner Zahl als Marke wurde verweigert — mit dem Argument, ein Frame mit Number.MAX_SAFE_INTEGER könne kein Mitschnitt eines echten Frames sein. Gefälscht ist bei diesem Angriff aber nur die Sequence. Das members-Array ist weiterhin der Mitschnitt, und nichts auf diesem Draht bindet beides aneinander — ein mitgeschnittener Frame mit einem umgeschriebenen Feld wurde also gemerged, ließ die Marke unangetastet und wurde deshalb bei jeder Zustellung erneut gemerged, unbegrenzt, gegen einen Empfänger, der eine Marke für einen noch lebenden Absender hielt. Ihn abzuweisen kostet nichts: die Marke bleibt dort, wo der letzte plausible Frame sie hinterlassen hat, der nächste Frame des echten Knotens überbietet sie also weiterhin und landet. Den echten Knoten für immer verstummen zu lassen — der Exploit, den die Versionsgrenze oben verhindert — ist damit von beiden Seiten geschlossen statt von einer.

Eine Adresse trägt zusätzlich eine Inkarnation: welcher Prozess unter diesem system@host:port antwortet, einmal pro Cluster.join geprägt. Sie wird bewusst mitgeführt und nur dafür ausgewertet, was ein Neustart verkündet — ein Eintrag einer neuen Inkarnation beendet die Mitgliedschaft des alten Laufs, bevor der neue beitritt —, nie, um einen Eintrag abzuweisen. Das Feld ist auf dem Draht optional, damit ein Knoten jeder der beiden Versionen einen der anderen versteht — und ein optionales Feld umgeht man durch Weglassen, eine auf eine Abweichung gestützte Ablehnung wäre also eine, aus der ein Angreifer aussteigt und in die ein legitimer Peer der Vorversion hineinläuft. Das Feld verpflichtend zu machen bricht alle acht adresstragenden Frame-Felder auf einmal und wartet auf die Versionierung des Wire-Protokolls. Aus toString, equals und compareTo bleibt es heraus, an der Identität eines Knotens ändert sich also nichts.

Der eine Vergleich, der keine Einigung braucht, wird gezogen: Ein Record, den ein Peer über diesen Knoten schickt, behält die eigene Inkarnation dieses Knotens. Die Beförderung durch den Leader ist die einzige Aussage über sich selbst, die ein Knoten annimmt, und sie wird als Ganzes gemerged, Adresse inklusive — ohne diese Ersetzung wäre der Identifikator des lokalen Records also das, was der letzte befördernde Peer gerade behauptet hat.

Drei Dinge schließt das nicht. Erstens einen Peer, der sich Standing erworben hat und einen frischen Frame komponiert, der eine gelöschte Adresse mit ihrer alten Version nennt: Das ist eine Fälschung, kein Replay, und um sie abzuweisen, müsste die Inkarnation verpflichtend sein statt nur mitgeführt — also genau der Wire-Bruch von oben.

Zweitens lässt eine fehlende Marke alles zu, und es gibt drei Wege, keine zu haben — nur einer davon ist die Evakuierung des Absenders selbst. Ein evakuiertes Member verliert seine Marke mit seinem Eintrag, aus dem Grund von oben: sofort auf dem eigenen auto-down-Weg des Detectors, der löscht, und bei jeder anderen Entfernung erst, wenn der Tombstone aufgeräumt wird, denn ein Tombstone behält die Marke zusammen mit dem Eintrag. Unter dem Default auto-down trifft eine gewöhnliche Partition Absender und Subjekt gemeinsam, dieser Weg kommt also gebrauchsfertig; mit konfigurierter Strategie oder unter auto-down = off evakuiert eine Partition niemanden, bis etwas entscheidet — beide werden geparkt, die Marken bleiben —, und hinter einem Tombstone lebt die Marke genau so lange wie die Abweisung. Ein frischer oder neu gestarteter Prozess hat von Anfang an keine. Und ein Member, von dem man über Dritte erfahren hat, hatte noch nie eine: Gossip ist epidemisch, ein Knoten legt C also auf Bs Wort hin als up ab und hat trotzdem noch nie einen Frame von C gesehen. Im letzten Fall ist der Absender die ganze Zeit volles Member und nirgends wurde etwas evakuiert — deshalb lässt sich dieser Schutz nicht so beschreiben, dass er gilt, „solange sein Absender Member ist”. Genau das stand vorher in diesem Abschnitt sowie in den Changelog- und Roadmap-Einträgen, und es war falsch.

Einen Frame von einem Peer ohne Marke abzuweisen ist nicht die fehlende Prüfung: Der erste Frame jedes Peers ist einer, ein Empfänger, der sie abweist, würde also nie erfahren, dass ein Cluster existiert. Was ein Mitschnitt aus einer leeren Marke zieht, ist ein Bootstrap über zwei Frames — der erste kauft Standing und setzt die Marke, aus seiner eigenen mitgeschnittenen Zahl, und der zweite überbietet sie und spricht für das Subjekt. Gegen ein über Dritte erfahrenes Member geht es noch kürzer, weil das Standing schon da ist und ein Frame genügt.

Drittens, und das ist der Grund, warum die beiden oben offen bleiben: Nichts, was sich auf den eigenen Zähler des Absenders stützt, kann einen Mitschnitt von einem lebenden Frame trennen — beide wurden von demselben Zähler gestempelt. Was sie trennt, ist, welcher Prozess sie abgeschickt hat, und die einzige für den Empfänger prüfbare Aussage darüber ist die Inkarnation. Die muss verpflichtend sein, bevor eine Ablehnung darauf ruhen kann, und das wartet auf die Versionierung des Wire-Protokolls.

Verpflichtend würde sie einen Mitschnitt einer früheren Inkarnation rundheraus abweisen — das ist der gewöhnliche Restart-Fall und der Großteil der Exposition. Zwei Kanten blieben auch dann, und sie sind es wert, genannt zu werden, damit niemand mehr erwartet: Ein Knoten, der heruntergefahren wurde, während er noch läuft, antwortet unter derselben Inkarnation, die der Mitschnitt trägt; und ein frisch gestarteter Empfänger hat keine frühere Inkarnation des Subjekts, gegen die er eine Erstsichtung vergleichen könnte, ein Record über ein Member, von dem er noch nie gehört hat, bleibt also zulässig. In einem korrekt konfigurierten mTLS-Cluster ist keine der beiden Kanten von außen erreichbar — hello ist an das Peer-Zertifikat gebunden — die Exposition sind also Plaintext- und Server-only-TLS-Deployments plus ein kompromittierter Peer.

Alle drei Restrisiken werden separat verfolgt.

production.ts
import { TcpTransport, Cluster, ClusterOptions } from 'actor-ts/cluster';
const tlsOptionsType = {
cert: fs.readFileSync(process.env.TLS_CERT_PATH!),
key: fs.readFileSync(process.env.TLS_KEY_PATH!),
ca: fs.readFileSync(process.env.TLS_CA_PATH!),
rejectUnauthorized: true,
};
const transport = new TcpTransport(self, log, { tls: tlsOptionsType });
const clusterOptions = ClusterOptions.create()
.withHost(host)
.withPort(port)
.withSeeds(seeds)
.withTransport(transport);
await Cluster.join(system, clusterOptions);

Env-Vars tragen Pfade; cert-manager / Vault mounten die Files. Code bleibt umgebungs-generisch.