Beliebte Tools

Design

IP-zu-Dezimal-Konverter

Rechnen Sie eine IP-Adresse in Dezimal, Hex, Binär und Oktal um, oder geben Sie eine dieser Zahlen ein, um die IP zurückzuerhalten. Jedes Oktett erscheint als 8 Bits mit ihren Stellenwerten, sodass Sie die Rechnung nachvollziehen können.

Parsing nach dem URL-Standard der WHATWG und inet_aton · exakte 128-Bit-Arithmetik für IPv6 · läuft in Ihrem Browser

Gelesen als Punktnotation

Die 8 Bits jedes Oktetts mit ihren Stellenwerten198.51.100.77 = 3 325 256 781
Oktett1286432168421HexSumme× Stelle= Wert
19811000110C6128+64+4+2 = 198× 256³16 777 2163 321 888 768
128+64+4+2 × 256³ = 3 321 888 768
51001100113332+16+2+1 = 51× 256²65 5363 342 336
32+16+2+1 × 256² = 3 342 336
100011001006464+32+4 = 100× 25625625 600
64+32+4 × 256 = 25 600
77010011014D64+8+4+1 = 77× 1177
64+8+4+1 × 1 = 77
Gesamt3 325 256 781
= 3 325 256 781
Beispiele

Eine IP oder ihre Dezimal-, Hex-, Binär- oder Oktalzahl, um die IP zurückzuerhalten. Die Umwandlung läuft in Ihrem Browser; nichts wird gesendet.

IPv4 · 32 Bits

3325256781

198.51.100.77 als eine 32-Bit-Zahl · Dokumentationsadresse (RFC 5737)

Dieselbe Zahl im Code

SELECT INET_ATON('198.51.100.77');3325256781
SELECT '198.51.100.77'::inet - '0.0.0.0'::inet;3325256781
int(ipaddress.ip_address('198.51.100.77'))3325256781
ip2long('198.51.100.77')3325256781
Dezimale Punktnotation
Dezimal
Hex
Binäre Oktette
Oktal
Hex-Oktette
Oktal-Oktette
Im Browser (jede öffnet 198.51.100.77)
Reverse-DNS-Name
Als IPv6 (gemappt)
IPv4 → IPv6

Wie rechne ich eine IP-Adresse in Dezimal um?

Multiplizieren Sie die vier Zahlen mit 256³, 256², 256 und 1 und addieren Sie sie: 192.168.1.1 ist 192 × 16 777 216 + 168 × 65 536 + 1 × 256 + 1 = 3 232 235 777.

Eine IPv4-Adresse ist eine 32-Bit-Zahl, geschrieben in vier 8-Bit-Stücken, daher sind die Form mit Punkten und die Dezimalform derselbe Wert. Die Dokumentation von MySQL nutzt 10.0.5.9 = 167773449 als Beispiel.

192× 256³ 16 777 2163 221 225 472
168× 256² 65 53611 010 048
1× 256 256256
1× 1 11
=3 232 235 777
192.168.1.1 als eine Zahl: jeder Teil mit seinem Stellenwert multipliziert, dann die Summe.
IP-Adresse in Binär umrechnen: Der Konverter zeigt Bits und Stellenwerte jedes Oktetts bis zur DezimalzahlIP-Adresse in Binär umrechnen: Der Konverter zeigt Bits und Stellenwerte jedes Oktetts bis zur DezimalzahlEingabe in jeder FormMit Punkten, dezimal, hex, binär, oktal oder als URL: Das Feld liest alles.Bits und StellenwerteJede 1 addiert ihren Stellenwert: 128 + 64 + 4 + 2 = 198.× 256³, 256², 256, 1Jedes Oktett mit seinem Gewicht multipliziert, dann die Summe.Ausgabe in jeder FormHex, binär, oktal und die URLs, die Browser akzeptieren, jeweils zum Kopieren.Die ZahlDie ganze Adresse als eine 32-Bit-Zahl, bereit zum Kopieren, mit der Art der Adresse.
198.51.100.77 Bit für Bit: die Stellenwerte jedes Oktetts, dann × 256³, 256², 256 und 1, zusammen 3 325 256 781.

Wie rechne ich eine Dezimalzahl in eine IP-Adresse um?

Teilen Sie durch 16 777 216, dann den Rest durch 65 536, dann durch 256: Die drei Quotienten und der letzte Rest sind die vier Zahlen, also ist 3232235777 gleich 192.168.1.1.

Geben Sie die Zahl in den Konverter ein, und er macht dasselbe, dazu Hex, Binär, Oktal und die Formen, die Browser akzeptieren. Zahlen über 4 294 967 295 sind keine IPv4-Adressen; der Konverter liest sie als IPv6-Zahlen und sagt das auch.

3 232 235 777÷ 16 777 216=192Rest 11 010 305
11 010 305÷ 65 536=168Rest 257
257÷ 256=1Rest 1
1÷ 1=1Rest 0

192.168.1.1

3 232 235 777 per Division zurück zu 192.168.1.1.

Wie rechne ich eine IP-Adresse in Binär um?

Schreiben Sie jede der vier Zahlen als 8 Bits mit den Stellenwerten 128, 64, 32, 16, 8, 4, 2 und 1: 192 ist 128 + 64, also 11000000, und 192.168.1.1 ist 11000000.10101000.00000001.00000001.

Gehen Sie die Stellenwerte von links durch: Schreiben Sie 1 und ziehen Sie ab, wenn der Wert passt, sonst schreiben Sie 0. Für 168: 128 passt (40 bleiben), 64 nicht, 32 passt (8 bleiben), 16 nicht, 8 passt, also 10101000. Zurück aus Binär addieren Sie die Stellenwerte der Einsen.

1286432168421
19211000000128 + 64
16810101000128 + 32 + 8
1000000011
1000000011

11000000.10101000.00000001.00000001

Jedes Oktett von 192.168.1.1 an den Stellenwerten 128 bis 1 gemessen.

Wie rechne ich eine IP-Adresse in Hex um?

Teilen Sie die 8 Bits jedes Oktetts in zwei Hälften zu 4 und schreiben Sie jede Hälfte als eine Hexziffer: 192 ist 1100 0000, also C0, und 192.168.1.1 ist 0xC0A80101.

Hex ist auch die Schreibweise, mit der IPv6 eine eingebettete IPv4-Adresse notiert: ::ffff:c0a8:101 ist 192.168.1.1. Browser akzeptieren die Hexzahl als Host: http://0xC0A80101/ öffnet 192.168.1.1.

19211000000C0
16810101000A8
10000000101
10000000101

0xC0A80101

4 Bits = 1 Hexziffer

Vier Bits pro Hexziffer: 192.168.1.1 ist C0 A8 01 01.

Warum öffnet http://3232235777 die Adresse 192.168.1.1?

Weil Browser einen Host, der nur aus Zahlen besteht, als IPv4-Adresse in jeder der alten inet_aton-Formen lesen, eine einzelne Dezimalzahl eingeschlossen, und dann die Adresse mit Punkten laden.

Jeder Teil kann dezimal sein (URL-Standard), hex mit 0x oder oktal mit führender 0, und bei weniger als vier Teilen füllt der letzte die übrigen Bytes. So öffnet http://192.168.1/ die Adresse 192.168.0.1, nicht 192.168.1.1. ping und curl akzeptieren dieselben Formen.

Zahlen über 32 Bits, eine 8 oder 9 in einem Teil, der mit 0 beginnt, und ein fünfter Teil werden abgelehnt.

In die Adressleiste getipptÖffnet
http://3232235777/192.168.1.1
http://0xC0A80101/192.168.1.1
http://0300.0250.1.1/192.168.1.1
http://127.1/127.0.0.1
http://192.168.1/192.168.0.1
http://4294967296/Abgelehnt
http://09/Abgelehnt
http://192.0.2.1.5/Abgelehnt
Was der URL-Parser der WHATWG mit jedem Host macht.

Warum sind alternative Schreibweisen von IP-Adressen ein Sicherheitsthema?

Weil sich ein Filter, der Adressen als Text vergleicht, täuschen lässt: 2130706433, 0x7f.1, 127.1 und ::ffff:127.0.0.1 sind alle 127.0.0.1, Filter müssen also den Zahlenwert vergleichen, nicht die Zeichenkette.

OWASP führt diese Kodierungen unter den Wegen auf, SSRF-Schutzmaßnahmen zu umgehen. Bibliotheken hatten genau diesen Fehler: Die npm-Pakete netmask und ip, Pythons ipaddress und Gos Paket net haben irgendwann führende Nullen oder alternative Formen falsch gelesen und wurden inzwischen korrigiert.

Parsen Sie mit einem strengen Parser, wandeln Sie in eine Zahl um und vergleichen Sie dann Bereiche. Sperren Sie auch die IPv4-gemappten Adressen gesperrter Bereiche.

deny 127.0.0.1

Als Text verglichen

127.0.0.1blockiert

2130706433kommt durch

0x7f.1kommt durch

127.1kommt durch

::ffff:127.0.0.1kommt durch

Als Zahl verglichen

127.0.0.12130706433 · blockiert

21307064332130706433 · blockiert

0x7f.12130706433 · blockiert

127.12130706433 · blockiert

::ffff:127.0.0.12130706433 · blockiert

CVE-2021-28918netmask (npm)CVE-2021-29418netmask (npm)CVE-2021-29424Net::Netmask (Perl)CVE-2021-29921Python ipaddressCVE-2021-29923Go netCVE-2024-29415ip (npm)
Eine Regel, fünf Schreibweisen der Loopback-Adresse; dann die Sicherheitshinweise.

Wie rechne ich eine IPv6-Adresse in Dezimal um?

Genauso, mit acht 16-Bit-Gruppen: 2001:db8::1 ist 42540766411282592856903984951653826561, eine Zahl mit bis zu 39 Stellen, die in JavaScript BigInt braucht.

Es gibt 2^128 IPv6-Adressen. JavaScript-Zahlen halten ganze Zahlen nur bis 2^53 − 1 exakt, daher rundet gewöhnliche Arithmetik IPv6-Werte stillschweigend. Pythons int(ipaddress.ip_address(…)) ist exakt.

2001:db8::1

42540766411282592856903984951653826561

exakt (BigInt)

42540766411282592856903984951653826560

Number(): ab 2^53 gerundet

2001:db8::1 als eine Zahl, und was eine gewöhnliche JavaScript-Zahl daraus macht.

Wie rechne ich IP-Adressen in Code und Datenbanken in Zahlen um?

Nutzen Sie die eigenen Funktionen der Plattform mit einem vorzeichenlosen Typ: MySQLs INET_ATON() in INT UNSIGNED, die Subtraktion mit inet in PostgreSQL, Pythons int(ipaddress.ip_address(…)) und >>> 0 nach Shifts in JavaScript.

Eine vorzeichenbehaftete 32-Bit-Ganzzahl kann Adressen ab 128.0.0.0 nicht fassen: JavaScripts << liefert für 192.168.1.1 -1062731519, und PHPs ip2long() wird auf 32-Bit-Builds negativ. Für IPv6 nutzt MySQL INET6_ATON() und VARBINARY(16).

› SELECT INET_ATON('192.168.1.1'), INET_NTOA(3232235777);
3232235777 | 192.168.1.1

MySQL 8.4

› SELECT '192.168.1.1'::inet - '0.0.0.0'::inet,
       '0.0.0.0'::inet + 3232235777;
3232235777 | 192.168.1.1

PostgreSQL 16

› import ipaddress
int(ipaddress.ip_address('192.168.1.1')), ipaddress.IPv4Address(3232235777)
(3232235777, IPv4Address('192.168.1.1'))

Python ipaddress

› '192.168.1.1'.split('.').reduce((n, o) => (n << 8) | +o, 0) >>> 0
3232235777

JavaScript

› echo ip2long('192.168.1.1'), ' ', long2ip(3232235777);
3232235777 192.168.1.1

PHP 8

192.168.1.1 als Zahl und zurück in zwei Datenbanken und drei Sprachen.

Häufig gestellte Fragen

Was ist 192.168.1.1 in Dezimal?

3232235777. Multiplizieren Sie jeden Teil mit seinem Stellenwert und addieren Sie: 192 × 16 777 216 + 168 × 65 536 + 1 × 256 + 1 = 3 232 235 777. Dieselbe Zahl ist 0xC0A80101 in Hex und 11000000.10101000.00000001.00000001 in Binär. Browser akzeptieren sie auch als Host, daher öffnet http://3232235777/ dieselbe Adresse wie http://192.168.1.1/.

Was ist der größte Dezimalwert einer IPv4-Adresse?

4 294 967 295, also 255.255.255.255. Eine IPv4-Adresse ist eine 32-Bit-Zahl, es gibt also 2^32 = 4 294 967 296 davon, von 0 (0.0.0.0) bis 4 294 967 295. Größere Zahlen sind keine IPv4-Adressen: Browser lehnen http://4294967296/ ab, und dieser Konverter liest solche Zahlen stattdessen als 128-Bit-IPv6-Werte und sagt Ihnen das.

Wie rechne ich 3232235777 zurück in eine IP-Adresse um?

Teilen Sie durch 16 777 216 für den ersten Teil: 192, Rest 11 010 305. Teilen Sie diesen Rest durch 65 536 für den zweiten Teil: 168, Rest 257. Teilen Sie 257 durch 256 für den dritten Teil: 1, Rest 1, und das ist der vierte Teil. Das Ergebnis ist 192.168.1.1. Geben Sie die Zahl in den Konverter ein, dann zeigt er auch die Bits jedes Oktetts.

Was bedeutet eine führende Null wie 010 in einer IP-Adresse?

Das hängt vom Programm ab. Browser und inet_aton lesen einen Teil mit führender Null als oktal, daher ist 192.0.2.010 gleich 192.0.2.8, während Tools, die die Null ignorieren, 192.0.2.10 lesen. Python und Go lehnen solche Adressen inzwischen ganz ab, nach Fehlern, bei denen die zwei Lesarten Anfragen an IP-Filtern vorbeischlüpfen ließen. Schreiben Sie in IPv4-Adressen nie führende Nullen.

Warum öffnet 192.168.1 die Adresse 192.168.0.1?

Weil eine dreiteilige Adresse die letzten 16 Bits mit ihrem letzten Teil füllt. In 192.168.1 wird die letzte 1 zur 16-Bit-Zahl 1, also 0.1, und die Adresse ist 192.168.0.1. So lesen inet_aton und Browser Kurzformen, und 192.168.257 wäre 192.168.1.1. Der Typ cidr von PostgreSQL liest 192.168.1 anders, nämlich als das Netz 192.168.1.0/24.

Wie rechne ich eine IP-Adresse von Hand in Binär um?

Gehen Sie für jede der vier Zahlen die Stellenwerte 128, 64, 32, 16, 8, 4, 2 und 1 durch: Schreiben Sie 1 und ziehen Sie ab, wenn der Stellenwert passt, sonst schreiben Sie 0. Für 168: 128 passt (40 bleiben), 64 nicht, 32 passt (8 bleiben), 16 nicht, 8 passt (0 bleibt), also 10101000. Verbinden Sie die vier 8-Bit-Gruppen mit Punkten.

Wie speichere ich IP-Adressen in MySQL als Zahlen?

Wandeln Sie mit INET_ATON('10.0.5.9') um, das 167773449 liefert, und speichern Sie das Ergebnis in einer Spalte vom Typ INT UNSIGNED: Ein vorzeichenbehaftetes INT kann keine Adressen über 127.255.255.255 fassen. INET_NTOA macht aus der Zahl wieder Text. Für IPv6 nehmen Sie INET6_ATON und eine Spalte VARBINARY(16), weil 128-Bit-Werte in keinen Ganzzahltyp passen. Verlassen Sie sich bei Kurzformen wie 127.1 nicht auf INET_ATON.

Warum ist meine IP-Zahl in JavaScript oder PHP negativ?

Weil sie als vorzeichenbehaftete 32-Bit-Ganzzahl behandelt wurde. Der Operator << von JavaScript liefert vorzeichenbehaftete Ergebnisse, daher ergibt 192.168.1.1, mit Shifts gebildet, -1062731519; hängen Sie >>> 0 an, um 3232235777 zu erhalten. PHPs ip2long verhält sich auf 32-Bit-Builds genauso, dort gibt sprintf('%u', …) den vorzeichenlosen Wert aus. Betroffen sind nur Adressen ab 128.0.0.0, deshalb bleibt der Fehler oft unbemerkt.

Lässt sich eine IPv6-Adresse in Dezimal umrechnen?

Ja. Eine IPv6-Adresse ist eine 128-Bit-Zahl, also ist 2001:db8::1 gleich 42540766411282592856903984951653826561, und der größte Wert hat 39 Stellen. Gewöhnliche JavaScript-Zahlen verlieren jenseits von 2^53 an Genauigkeit, daher müssen Tools BigInt verwenden, und manche Online-Konverter liefern falsche letzte Stellen. Pythons int(ipaddress.ip_address('2001:db8::1')) ergibt den exakten Wert.

Ist http://0x7f000001/ dasselbe wie 127.0.0.1?

Ja. Browser und viele Kommandozeilen-Tools lesen einen Host aus Hexziffern nach 0x als eine 32-Bit-Zahl, daher bedeuten 0x7f000001, 2130706433, 0x7f.1 und 127.1 alle 127.0.0.1, die Loopback-Adresse. Deshalb müssen Sicherheitsfilter den Zahlenwert statt des Textes vergleichen, wie es RFC 3986 und das SSRF-Cheat-Sheet von OWASP raten.

Fehlt Ihnen etwas?Funktion oder neues Tool vorschlagen

Verwandte Tools