IPv4-gemappter IPv6-Konverter

Der IPv4-Mapped IPv6 Converter übersetzt IPv4-Adressen in das und aus dem ::ffff:-Mapped-IPv6-Format, das von Dual-Stack-Sockets verwendet wird. Geben Sie 192.168.1.1 ein, um ::ffff:192.168.1.1 (Dotted-Notation) und ::ffff:c0a8:0101 (Hex-Notation) zu erhalten, oder fügen Sie eine Mapped-IPv6-Adresse ein, um die ursprüngliche IPv4-Adresse zu extrahieren.

IPv4-Mapped IPv6-Adressen verstehen

Wenn Sie jemals Anwendungsprotokolle eines Node.js-Servers, eines Go-Dienstes oder einer Python-Webanwendung angesehen und Client-Adressen wie ::ffff:10.0.0.5 anstelle der erwarteten 10.0.0.5 gesehen haben, sind Sie auf IPv4-Mapped IPv6-Adressen gestoßen. Dieses Format ist kein Fehler -- es ist die Art, wie das Betriebssystem IPv4-Verbindungen an Anwendungen darstellt, die auf IPv6-Sockets lauschen.

Moderne Betriebssysteme erstellen standardmäßig Dual-Stack-Sockets. Wenn ein Server an eine IPv6-Adresse bindet (oder an ::, was alle Schnittstellen bedeutet), kann er sowohl IPv6- als auch IPv4-Verbindungen auf demselben Port annehmen. Wenn sich ein IPv4-Client verbindet, muss der Kernel die IPv4-Adresse innerhalb des 128-Bit-IPv6-Adressraums darstellen. Dies geschieht durch Voranstellen von ::ffff: an die IPv4-Adresse, wobei ein 128-Bit-Wert entsteht: Die ersten 80 Bits sind Null, die nächsten 16 Bits sind alle Einsen (ffff), und die letzten 32 Bits enthalten die ursprüngliche IPv4-Adresse. Dieses Mapped-Format ermöglicht es der Anwendung, alle Verbindungen mit einem einzigen IPv6-Adresstyp zu verarbeiten.

Für Entwickler und Systemadministratoren besteht die praktische Herausforderung darin, dass diese Mapped-Adressen überall auftauchen: in Zugriffsprotokollen, Datenbankverbindungszeichenfolgen, Sicherheitswarnungen und Rate-Limiting-Tabellen. Wenn Ihre Protokollanalyse-Pipeline das ::ffff:-Präfix nicht berücksichtigt, erhalten Sie separate Einträge für denselben Client, fehlerhafte Geolokalisierungsabfragen und Allowlists, die nicht übereinstimmen. Dieser Converter verarbeitet beide Richtungen -- IPv4 zu Mapped und Mapped zu IPv4 -- sodass Sie beim Debugging oder beim Erstellen von Adressverarbeitungslogik schnell zwischen den Formaten übersetzen können.

Zwischen IPv4 und IPv4-Mapped IPv6 konvertieren

1. Geben Sie eine IPv4-Adresse ein (z. B. 192.168.1.1), um die entsprechende IPv4-Mapped IPv6-Adresse zu erzeugen
2. Oder geben Sie eine IPv4-Mapped IPv6-Adresse ein (z. B. ::ffff:192.168.1.1), um die ursprüngliche IPv4-Adresse zu extrahieren
3. Sehen Sie sowohl die Dotted-Decimal-Mapped-Form (::ffff:192.168.1.1) als auch die reine Hex-Form (::ffff:c0a8:0101)
4. Das Tool validiert das ::ffff:0:0/96-Präfix und weist fehlerhafte Eingaben zurück

Beispiele für IPv4-Mapped IPv6-Konvertierungen

Mapped vs. kompatibles Format

Wann den IPv4-Mapped IPv6 Converter verwenden

• Anwendungsprotokolle interpretieren -- Node.js, Go, Python und Java-Anwendungen, die auf IPv6-Sockets lauschen, protokollieren IPv4-Client-Verbindungen als ::ffff:10.0.0.5, und Sie müssen die eigentliche IPv4-Adresse extrahieren
• Dual-Stack-Dienste konfigurieren -- IPv4-Allowlists in das Mapped-IPv6-Format für Dienste übersetzen, die nur IPv6-Adresssyntax akzeptieren
• Socket-APIs debuggen -- verstehen, warum getpeername() auf einem IPv6-Socket ::ffff:-präfixierte Adressen für IPv4-Verbindungen zurückgibt
• Firewall-Regelübersetzung -- IPv4-Regeln in ihre IPv6-Entsprechungen in Dual-Stack-Firewall-Konfigurationen konvertieren
• Incident Response -- schnell IPv4-Adressen aus Mapped-Format-Einträgen in Sicherheitsprotokollen extrahieren
• Log-Pipeline-Normalisierung -- das ::ffff:-Präfix entfernen, um IPv4-Adressen über Protokollquellen hinweg zu vereinheitlichen, die unterschiedliche Formate verwenden

Wie IPv4-Mapped IPv6-Adressen funktionieren

IPv4-Mapped IPv6-Adressen ermöglichen es reinen IPv6-Sockets, IPv4-Verkehr transparent zu verarbeiten. Der Betriebssystem-Kernel bildet eingehende IPv4-Verbindungen in den IPv6-Adressraum ab, indem er ein definiertes Format verwendet.

Adressstruktur

Die 128-Bit-Mapped-Adresse besteht aus drei Teilen:

|    80 Bits Nullen         | 16 Bits |    32 Bits       |
|  0000...0000              |  ffff   |  IPv4-Adresse    |
                            |         |                  |
::                           ffff:     192.168.1.1

Vollständig expandierte Form:
0000:0000:0000:0000:0000:ffff:c0a8:0101

Die ersten 80 Bits sind Null. Die nächsten 16 Bits sind alle Einsen (ffff). Die letzten 32 Bits enthalten die IPv4-Adresse. Dies fällt unter das ::ffff:0:0/96-Präfix.

Dual-Stack-Socket-Verhalten

Wenn eine Anwendung einen IPv6-Socket mit aktiviertem Dual-Stack erstellt (Standard bei den meisten Betriebssystemen), werden IPv4-Verbindungen automatisch im Mapped-Format dargestellt:

IPv4-Client 10.0.0.5 verbindet sich mit Server-Port 8080
  -> IPv6-Socket des Servers sieht: ::ffff:10.0.0.5

IPv6-Client 2001:db8::1 verbindet sich mit Server-Port 8080
  -> IPv6-Socket des Servers sieht: 2001:db8::1

Das bedeutet, der Anwendungscode muss nur IPv6-Adressen verarbeiten, und das Mapped-Format unterscheidet IPv4-Clients von nativen IPv6-Clients.

Häufige Programmierumgebungen

Die meisten modernen Sprachen stellen IPv4-Mapped-Adressen in ihren Netzwerk-APIs bereit:

• Node.js -- socket.remoteAddress gibt ::ffff:192.168.1.1 für IPv4-Verbindungen zurück
• Python -- socket.getpeername() auf einem Dual-Stack-Socket gibt das Mapped-Format zurück
• Go -- net.Conn.RemoteAddr() gibt die Mapped-Form zurück; verwenden Sie net.IP.To4(), um den IPv4-Anteil zu extrahieren
• Java -- InetAddress.getByName() kann das Mapped-Format parsen; Inet6Address.isIPv4MappedIPv6Address() erkennt es

Plattformunterschiede

Nicht alle Betriebssysteme behandeln Dual-Stack-Sockets identisch. Unter Linux ist Dual-Stack standardmäßig aktiviert (die Socket-Option IPV6_V6ONLY ist 0). Unter Windows ist es ab Vista ebenfalls standardmäßig aktiviert. Unter OpenBSD sind Dual-Stack-Sockets aus Sicherheitsgründen deaktiviert, sodass separate IPv4- und IPv6-Sockets erforderlich sind. Die Kenntnis des Verhaltens Ihrer Plattform ist beim Debuggen von Mapped-Adressproblemen unerlässlich.

Praktische Tipps zum Umgang mit Mapped-Adressen

Das Wichtigste bei Mapped-Adressen ist die korrekte Verarbeitung in Ihrer Log-Pipeline. Wenn Ihr Webserver ::ffff:10.0.0.5 protokolliert und ein Reverse-Proxy 10.0.0.5 für denselben Client, zählt Ihre Analyse zwei verschiedene Besucher. Normalisieren Sie frühzeitig: Entfernen Sie das ::ffff:-Präfix so nah wie möglich am Aufnahmepunkt, damit nachgelagerte Systeme mit konsistenten IPv4-Darstellungen arbeiten. Die meisten Protokollverarbeitungstools und SIEM-Plattformen haben integrierte Funktionen dafür, aber Sie müssen sie explizit aktivieren.

Das zweithäufigste Problem sind Allowlists und Blocklists. Wenn Ihre Anwendung eingehende Adressen gegen eine IPv4-Allowlist wie 10.0.0.0/24 prüft, aber der Socket die Adresse als ::ffff:10.0.0.5 präsentiert, schlägt der Zeichenfolgenvergleich fehl. Ihre Adressvergleichslogik muss beide Formate verarbeiten. In den meisten Sprachen bietet die Standardbibliothek eine Methode, um den IPv4-Anteil aus einer Mapped-Adresse zu erkennen und zu extrahieren: Go hat net.IP.To4(), Python hat ipaddress.IPv6Address.ipv4_mapped, und Node.js-Entwickler prüfen oft auf das ::ffff:-Präfix und entfernen es.

Ein subtileres Problem entsteht bei Geolokalisierungs- und Reputationsdatenbanken. Die meisten IP-Geolokalisierungsdienste erwarten reine IPv4-Eingaben. Das Senden von ::ffff:10.0.0.5 an eine Geolokalisierungs-API liefert entweder kein Ergebnis oder einen Fehler. Extrahieren Sie immer die IPv4-Adresse aus dem Mapped-Format, bevor Sie externe Abfragen durchführen. Ebenso verwenden Threat-Intelligence-Feeds reine IPv4-Adressen, sodass Ihre Korrelationslogik Mapped-Adressen vor dem Vergleich normalisieren muss.

Häufig gestellte Fragen

Warum protokolliert mein Node.js-Server IPv4-Adressen als ::ffff:127.0.0.1?

Node.js lauscht standardmäßig auf einem IPv6-Dual-Stack-Socket. Wenn sich ein IPv4-Client verbindet, bildet der Betriebssystem-Kernel die IPv4-Adresse in das IPv6-Format ab, indem er das ::ffff:-Präfix verwendet. Die Adresse ::ffff:127.0.0.1 ist einfach 127.0.0.1 in IPv6-Mapped-Notation dargestellt. Entfernen Sie das ::ffff:-Präfix, um die ursprüngliche IPv4-Adresse zu erhalten.

Was ist der Unterschied zwischen IPv4-Mapped und IPv4-kompatiblen Adressen?

IPv4-Mapped-Adressen verwenden ::ffff: als Präfix (z. B. ::ffff:192.168.1.1) und sind der aktuelle Standard zur Darstellung von IPv4-Adressen in IPv6-Sockets. IPv4-kompatible Adressen verwenden nur :: als Präfix (z. B. ::192.168.1.1) und waren ein früherer Übergangsmechanismus, der seit 2006 durch RFC 4291 als veraltet eingestuft wurde.

Kann ich eine IPv4-Mapped IPv6-Adresse pingen?

Auf den meisten Systemen funktioniert ping6 ::ffff:192.168.1.1 nicht wie erwartet, da die ICMP-Verarbeitung von Mapped-Adressen je nach Betriebssystem variiert. Das Mapped-Format wird hauptsächlich intern von Dual-Stack-Sockets verwendet und ist nicht für die direkte Verwendung in Befehlen oder Routing-Tabellen vorgesehen.

Wie deaktiviere ich Dual-Stack-Sockets, wenn ich keine Mapped-Adressen möchte?

Setzen Sie die Socket-Option IPV6_V6ONLY auf 1, bevor Sie binden. Dies zwingt den Socket, nur IPv6-Verbindungen zu akzeptieren. Sie benötigen dann einen separaten IPv4-Socket für IPv4-Clients. Dieser Ansatz wird unter OpenBSD standardmäßig verwendet und ist in einigen sicherheitssensiblen Umgebungen bevorzugt.

Behält die Mapped-Adresse die Private/Öffentlich-Klassifizierung der ursprünglichen IPv4-Adresse bei?

Ja. Das Mapping ist rein eine Darstellungsänderung. ::ffff:10.0.0.1 ist weiterhin eine private Adresse, und ::ffff:8.8.8.8 ist weiterhin öffentlich. Die Private/Öffentlich-Klassifizierung hängt ausschließlich von der eingebetteten IPv4-Adresse ab. Verwenden Sie den IPv4 Private/Public Detector nach dem Extrahieren des IPv4-Anteils, um die Klassifizierung zu bestätigen.

Verwandte Tools

• 6to4 Address Builder/Parser - 6to4-Tunneladressen erstellen oder parsen
• Address Family Detector - Erkennen, ob eine Adresse IPv4, IPv6 oder ungültig ist
• IPv4 Private/Public Detector - Erkennen, ob eine IPv4-Adresse privat, öffentlich oder speziell ist
• IPv6 Expand ↔ Compress - Zwischen expandierter und komprimierter IPv6-Notation konvertieren
• IPv4 ↔ Hex Converter - IPv4-Adressen in/aus Hexadezimal konvertieren
• Normalize Mixed Lists - Gemischte IPv4/IPv6-Adresslisten sortieren und bereinigen