Skip to content
KitploitKITPLOIT
ToolsBlog
Einreichen
ToolsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

··Feeds·Kontakt·Datenschutz·© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
CVE-2026-34207 — Der SSRF-Filter prüfte den Hostname-Text, aber das tatsächliche Ziel wurde später durch DNS bestimmt. Diese Lücke ermöglichte es angreifergesteuerten Webhook-URLs, Loopback-, Metadaten- und private Netzwerkziele zu erreichen. | Kitploit
Tools/GitHubGitHub/0xmrma/cve-2026-34207
SchwachstellenanalyseExploitationWebsicherheitPenetrationstestsPapers & ForschungLernen & Bildung
GitHub0xmrma/cve-2026-34207

CVE-2026-34207

Der SSRF-Filter prüfte den Hostname-Text, aber das tatsächliche Ziel wurde später durch DNS bestimmt. Diese Lücke ermöglichte es angreifergesteuerten Webhook-URLs, Loopback-, Metadaten- und private Netzwerkziele zu erreichen.

Repository anzeigen
vor 1 MonatNoch nicht geprüft

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →
Teilen

CVE-2026-34207

Der SSRF-Filter überprüfte den Hostnamen-Text, aber das tatsächliche Ziel wurde später durch DNS bestimmt. Diese Lücke erlaubte es angreiferkontrollierten Webhook-URLs, Loopback-, Metadaten- und private Netzwerkziele zu erreichen.

Einleitung

Ich habe diesen Fehler gefunden, während ich Typebot, einen Open-Source-Chatbot-Builder, mit einer einfachen Sicherheitsfrage im Hinterkopf überprüft habe:

Was passiert, wenn der SSRF-Schutz den Hostnamen-Text validiert, das tatsächliche Ziel aber später durch DNS bestimmt wird?

In diesem Fall führte diese Frage zu einem echten Bug.

Der SSRF-Schutz von Typebot für Webhook / HTTP-Request-Blöcke validierte nur:

  • die URL-Zeichenkette,
  • blockierte Hostnamen-Literale,
  • und Literal-IP-Formate

Er hat nicht Hostnamen aufgelöst, bevor er die Anfrage erlaubte.

Das bedeutete, dass ein Hostname wie ssrf-repro.example während der Validierung harmlos aussehen konnte, sich dann aber auflösen konnte in:

  • 127.0.0.1
  • 169.254.169.254
  • oder RFC1918/privaten Netzwerkbereich

und trotzdem vom Backend-HTTP-Client abgerufen wurde.

Dieser Fehler wurde CVE-2026-34207.

Typebot: Typebot auf GitHub
CVE: CVE-2026-34207
Behoben in: 3.16.0

Dies betraf Typebot, eine weit verbreitete Open-Source-Chatbot-Plattform. Auf der offiziellen Website wird Typebot als vertrauenswürdig von 650+ Unternehmen weltweit präsentiert. Die Website wirbt außerdem mit 2M+ monatlichen Chats und 1.5M+ veröffentlichten Bots.

photo0

Angriffskette

angreiferkontrollierte Webhook-URL -> Hostname passiert nur literale SSRF-Validierung -> keine DNS-Auflösung vor der Entscheidung -> Backend-HTTP-Client löst Hostname zu internem Ziel auf -> serverseitige Anfrage erreicht Loopback / Metadaten / privates Netzwerk -> Antwortdaten werden durch Ausführungsprotokolle verfügbar


Was Typebot tut

Typebot ist ein Chatbot-Builder.

Es ermöglicht Benutzern, Abläufe zu erstellen, die:

  • Fragen stellen
  • strukturierte Eingaben sammeln
  • externe Dienste aufrufen
  • Geschäftslogik verketten
  • und ausgehende HTTP-Anfragen durch Webhook / HTTP-Request-Blöcke auslösen

Das bedeutet, dass die Ausführung ausgehender Anfragen eine echte Sicherheitsgrenze darstellt.

Die wichtige Frage war hier nicht, ob Typebot Webhook-Blöcke unterstützt.

Die eigentliche Frage war:

Validiert der SSRF-Schutz das tatsächliche Ziel, mit dem der Server eine Verbindung herstellt, oder nur den Hostnamen-Text, der in der URL erscheint?

In diesem Fall validierte er zuerst nur die Textform.

Das war der Fehler.


Warum diese Angriffsfläche einen Blick wert war

SSRF-Abwehrmechanismen versagen auf sehr vorhersehbare Weise.

Meistens sind die interessanten Fehler nicht:

  • "Du hast vergessen, 169.254.169.254 zu blockieren"
  • oder "Du hast vergessen, localhost zu blockieren"

Die stärkeren Fehler sind Grenzfehler:

  • Validierung erfolgt vor der Kanonisierung
  • Validierung erfolgt vor Weiterleitungen
  • Validierung erfolgt vor der DNS-Auflösung
  • Validierung erfolgt auf einer Darstellung, aber der Netzwerk-Stack verwendet eine andere

Das war hier der richtige Ansatzpunkt.

Typebot hatte bereits SSRF-Härtungslogik für literale Metadaten-IPs, Loopback, private Bereiche und codierte IP-Tricks.

Das machte die nächste Frage offensichtlich:

Was ist, wenn der Hostname wörtlich nicht gefährlich ist, sich aber später in ein gefährliches Ziel auflöst?

Genau das ist passiert.


Grundursache

Die Grundursache war die Zielvalidierung basierend auf Hostnamen-Text anstatt der aufgelösten IP-Adresse.

In der anfälligen Implementierung hat validateHttpReqUrl():

  • die URL geparst
  • nur http: und https: erlaubt
  • eine kurze Liste literaler Hostnamen wie metadata.google.internal, metadata.goog, metadata und localhost blockiert
  • literale dezimale / hexadezimale / oktale IP-Tricks erkannt
  • literale IPv4-/IPv6-Adressen geparst
  • die Adresse nur validiert, wenn der Hostname selbst bereits eine literale IP war

Das ist der wichtige Teil.

Wenn der Hostname ein normaler Wert war wie:

ssrf-repro.example

dann gab parseIPAddress(hostname) null zurück, und der Validator hörte dort auf.

Es fand keine DNS-Auflösung vor der Genehmigung statt.

Die anfällige Logik reduzierte sich also effektiv auf:

root@kitploit:~
const ip = parseIPAddress(hostname);
if (ip) {
  validateIPAddress(ip);
}

Das bedeutet:

  • literale gefährliche IPs wurden blockiert
  • codierte gefährliche IPs wurden blockiert
  • aber Hostnamen, die sich in gefährliche IPs auflösen, wurden nicht blockiert

Die zweite Hälfte des Bugs lag im Ausführungspfad.

In executeHttpRequest() führte Typebot zuerst die Validierung durch und später die eigentliche Anfrage mit ky(request.url, ...).

Die Reihenfolge war also:

  • die URL-Zeichenkette validieren
  • den Hostnamen akzeptieren
  • später den Hostnamen während der tatsächlichen ausgehenden Anfrage auflösen
  • eine Verbindung zum aufgelösten internen Ziel herstellen

Das ist die gesamte Schwachstelle.


Warum dies ein Sicherheitsproblem ist und nicht nur eine unvollständige Filterung

Der wichtige Unterschied ist wo die Vertrauensentscheidung getroffen wurde.

Viele Bugs wirken klein, wenn man sie schlecht beschreibt.

Wenn man diesen Bug beschreibt als:

"Der Hostname-Filter war unvollständig"

klingt das nach einem Qualitätsproblem.

Das ist nicht das eigentliche Problem.

Das eigentliche Problem war:

  • der Server traf eine Sicherheitsentscheidung, bevor er das tatsächliche Ziel kannte
  • der Netzwerk-Stack stellte später eine Verbindung woanders her
  • und die Anwendung behandelte diese Anfrage als gültig

Das ist keine kosmetische Filtersschwäche.

Das ist ein Vertrauensgrenzenfehler.

Und weil der HTTP-Ausführer Antwortdaten in Ausführungsprotokollen aufzeichnete, war das Problem nicht einmal in den stärksten Fällen blind.

Es war also nicht nur:

  • "unerwarteter interner Datenverkehr ist aufgetreten"

Es war:

  • interner Datenverkehr ist aufgetreten
  • und der Angreifer konnte oft Beweise und Antwortinhalte durch normales Anwendungsverhalten wiederherstellen

Das ist eine echte SSRF-Schwachstelle.


Proof of Concept

Ich habe zwei Proof-Ebenen verwendet, weil sie zwei verschiedene Dinge demonstrierten.

PoC 1: autarker lokaler Resolver-Demo

Der erste PoC isolierte die Grundursache sauber.

Ich verwendete eine kleine lokale Testumgebung, die:

  • einen Loopback-HTTP-Server auf 127.0.0.1 startete
  • eine URL wie http://ssrf-repro.example:18080/... validierte
  • einen kontrollierten Resolver verwendete, sodass ssrf-repro.example zu 127.0.0.1 aufgelöst wurde
  • dann die Anfrage ausführte

Das demonstrierte den genauen Fehler:

  • Die Validierung bestand, weil der Hostname kein literaler blockierter Wert war
  • Die spätere Anfrage erreichte dennoch Loopback

Die erfasste Ausgabe zeigte:

  • Validator-Ergebnis: bestanden
  • Anfrageausführungsergebnis: Loopback erreicht
  • Antworttext vom Loopback-Dienst zurückgegeben

Das bewies die Validierungslücke direkt.


PoC 2: echter Typebot-Ausführungspfad

Der zweite PoC zeigte den Bug durch den tatsächlichen Feature-Pfad, der relevant ist.

Die einfachste Reproduktion war:

  1. Ordnen Sie einen harmlosen Hostnamen Loopback auf dem Rechner zu, auf dem der Typebot-Backend DNS auflöst
  2. Starten Sie einen lokalen HTTP-Dienst
  3. Erstellen Sie einen Webhook-Block, der auf diesen harmlosen Hostnamen zeigt
  4. Lösen Sie den Block durch einen normalen authentifizierten Vorschau- oder Live-Ausführungspfad aus

Ein repräsentativer Block sah so aus:

root@kitploit:~
{
  "id": "blk-webhook",
  "type": "Webhook",
  "options": {
    "webhook": {
      "method": "GET",
      "url": "http://ssrf-repro.example:8000/"
    }
  }
}

Mit einem Hosts-Datei-Eintrag wie:

root@kitploit:~
127.0.0.1 ssrf-repro.example

akzeptierte der Validator die URL dennoch, weil:

  • ssrf-repro.example nicht in blockedHostnames war
  • es nicht localhost war
  • parseIPAddress("ssrf-repro.example") gab null zurück
  • keine IP-Zielvalidierung erfolgte

Dann löste der Backend-HTTP-Client den Hostnamen zu 127.0.0.1 auf und stellte trotzdem eine Verbindung her.

Damit war die vollständige Behauptung aufgestellt:

  • Die anfällige Validierungslogik war im realen Feature-Einsatz erreichbar
  • Die Anfrage traf eine blockierte Klasse von Zielen
  • Und die Anwendung behandelte sie dennoch als erfolgreiche ausgehende HTTP-Anfrage

Warum die beiden PoCs so gewählt wurden

Der erste PoC beweist die Grundursache.

Der zweite PoC beweist die Produktauswirkung.

Diese Trennung ist wichtig.

Wenn man nur zeigt:

"Dieser Filter akzeptiert einen Hostnamen"

hat man nicht genug gezeigt.

Wenn man nur zeigt:

"Eine interne Anfrage ist aufgetreten"

hat man nicht isoliert, warum.

Der stärkere Bericht ist:

  • Die hostnamenbasierte Validierung akzeptierte einen Wert, dem nicht hätte vertraut werden dürfen
  • Die DNS-Auflösung änderte später die tatsächliche Sicherheitsbedeutung dieses Werts
  • Das Backend stellte eine Verbindung zu einem blockierten Ziel her
  • Und der Feature-Pfad wurde dennoch abgeschlossen

Das ist die vollständige Geschichte.


Schweregrad und Klassifizierung

Dieses Problem wurde vernünftigerweise als Hoch eingestuft.

Die Advisory-Klassifizierung war:

  • CWE-918: Server-Side Request Forgery (SSRF)
  • CWE-20: Improper Input Validation
  • CVSS:
root@kitploit:~
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:L

Das macht Sinn.

Dies war für sich genommen keine offene, nicht authentifizierte, internetweite SSRF.

Die erforderlichen Privilegien waren Niedrig, da der eigenständige Bug einen Akteur erforderte, der einen Webhook / HTTP Request konfigurieren oder auslösen konnte.

Aber innerhalb dieser Grenze war die Auswirkung schwerwiegend:

  • Loopback-Zugriff
  • Zugriff auf private Netzwerke
  • Zugriff auf Metadaten
  • und Exfiltration von Antworten durch Protokolle

Das ist für sich genommen ein starkes SSRF-Problem.

Und es wird noch gefährlicher, wenn es mit anderen Bugs kombiniert wird, die die Erreichbarkeit erweitern.


Warum es trotzdem wert war, gemeldet zu werden

Manche Leute sehen authentifizierte SSRF und unterschätzen sie sofort.

Das ist ein Fehler.

Die eigentliche Frage ist nicht:

"War der Angreifer eingeloggt?"

Die eigentliche Frage ist:

"Konnte dieser Angreifer den Server dazu bringen, sich mit etwas zu verbinden, was das Sicherheitsmodell verbieten sollte?"

Hier war die Antwort ja.

Der Validator behauptete, Folgendes zu schützen:

  • Metadaten-Dienste
  • Loopback
  • RFC1918 private Bereiche
  • IPv6 lokale Bereiche

Aber eine Hostname-Auflösungslücke ließ dieselben Ziele durch eine andere Darstellung wieder hinein.

Das ist genau die Art von Bug, die ein CVE verdient.


Fixanalyse

Der Fix war solide, weil er die tatsächliche Grenze korrigierte, nicht nur ein Symptom.

In der gepatchten Implementierung wurde validateHttpReqUrl() geändert, um Hostnamen vor der Genehmigung der Anfrage aufzulösen.

Der Validator:

  • importiert lookup aus node:dns/promises
  • behandelt Validierung als asynchron
  • löst nicht-literale Hostnamen auf, bevor er sie erlaubt
  • parst jede aufgelöste Adresse
  • validiert jede aufgelöste Adresse gegen dieselben blockierten Bereiche

Das ist der richtige Fix, weil er die Vertrauensentscheidung ändert von:

  • "Sieht der Hostname-Text in Ordnung aus?"

zu:

  • "Löst sich das tatsächliche Ziel in eine erlaubte Adresse auf?"

Das ist die Sicherheitseigenschaft, die von Anfang an hätte existieren sollen.

Die Behebung fügte auch Regressionstests hinzu für:

  • Hostnamen, die sich in Loopback auflösen
  • Hostnamen, die sich in RFC1918-Bereiche auflösen
  • auf die Whitelist gesetzte interne Hosts für Selbst-Hoster
  • Beibehaltung nicht umgehbarer Schutzmaßnahmen für Metadaten- und Loopback-Ziele

Das ist die Art von Härtung, die man in einem echten SSRF-Fix haben möchte:

  • die Grenze wird korrigiert
  • das beabsichtigte Verhalten wird im Code dokumentiert
  • und Tests sichern die Klasse ab

Das Problem wurde in Typebot 3.16.0 behoben.


Offenlegung

Dieses Problem wurde privat über den Sicherheitsmeldeflow von GitHub gemeldet.

Der Bericht enthielt:

  • die Grundursache in validateHttpReqUrl()
  • den nachgelagerten Ausführungspfad in executeHttpRequest()
  • eine realistische Reproduktionsstrategie unter Verwendung von Hostname-Auflösung zu Loopback / privaten Zielen
  • und eine in sich geschlossene Demo zur Isolierung der Validierungslücke

Die Maintainer akzeptierten das Problem, korrigierten die Validierungslogik, und die Schwachstelle wurde später veröffentlicht als:

CVE-2026-34207

mit dem Fix in Typebot 3.16.0.


Was dieser Bug tatsächlich lehrt

Die wichtigste Lektion hier ist einfach:

Sicherheitsentscheidungen müssen auf derselben Darstellung getroffen werden, die der Netzwerk-Stack tatsächlich verwenden wird.

Das klingt offensichtlich.

Aber viele SSRF-Schutzmaßnahmen scheitern genau deshalb, weil sie dieser Regel nicht folgen.

  • Eine Hostname-Zeichenkette sieht sicher aus.
  • DNS ändert ihre Bedeutung.
  • Die Anfrage geht trotzdem raus.

Das reicht.

Dieser Bug unterstreicht auch etwas Wichtiges bei der SSRF-Überprüfung im Allgemeinen:

  • Literale IP-Filterung reicht nicht
  • Hostname-Blacklists reichen nicht
  • Codierte-IP-Prüfungen reichen nicht

Wenn Sie das tatsächliche Ziel nicht auflösen und validieren, ist Ihr SSRF-Filter immer noch unvollständig.

Das ist die eigentliche Erkenntnis.


Wichtige Punkte

  • SSRF-Abwehrmechanismen versagen, wenn die Validierung vor der Zielauflösung stattfindet
  • Hostname-Text-Validierung ist nicht dasselbe wie Ziel-IP-Validierung
  • Webhook / HTTP Request-Features sind echte Sicherheitsgrenzen
  • Authentifizierte SSRF kann immer noch hohen Schweregrad haben, wenn sie Metadaten und interne Dienste erreicht
  • Ein starker Bericht verbindet Grundursache und Auswirkung, nicht nur das eine oder andere
  • Der Fix war korrekt, weil er die Entscheidung zum tatsächlich aufgelösten Ziel verlagerte

Schlussworte

Diese Schwachstelle drehte sich nicht um eine raffinierte Payload.

Es ging darum, die richtige Grenzfrage zu stellen.

Bei Typebot prüfte der SSRF-Validator zuerst den Hostnamen-Text. Das tatsächliche Ziel wurde später durch DNS bestimmt. Der Netzwerk-Client folgte der aufgelösten Adresse.

Diese Lücke war der Bug.

Deshalb wurde dies CVE-2026-34207.

Behoben in Typebot 3.16.0.

Tool herunterladen