Popularne narzędzia

Motyw

Konwerter IP na dziesiętny

Zamień adres IP na postać dziesiętną, szesnastkową, binarną i ósemkową albo wpisz dowolną z tych liczb, by odzyskać IP. Każdy oktet jest narysowany jako 8 bitów z ich wagami, więc możesz prześledzić rachunek.

Parsowanie według standardu URL WHATWG i inet_aton · dokładna arytmetyka 128-bitowa dla IPv6 · działa w twojej przeglądarce

Rozpoznany zapis z kropkami

8 bitów każdego oktetu z ich wagami198.51.100.77 = 3 325 256 781
Oktet1286432168421HexSuma× waga= wartość
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
Razem3 325 256 781
= 3 325 256 781
Przykłady

Adres IP albo jego liczba dziesiętna, szesnastkowa, binarna lub ósemkowa, by odzyskać IP. Konwersja odbywa się w twojej przeglądarce; nic nie jest wysyłane.

IPv4 · 32 bity

3325256781

198.51.100.77 jako jedna liczba 32-bitowa · Adres dokumentacyjny (RFC 5737)

Ta sama liczba w kodzie

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
Dziesiętnie z kropkami
Dziesiętnie
Szesnastkowo
Oktety binarnie
Ósemkowo
Oktety szesnastkowo
Oktety ósemkowo
W przeglądarce (każdy otwiera 198.51.100.77)
Nazwa zwrotna DNS
Jako IPv6 (mapowany)
IPv4 → IPv6

Jak zamienić adres IP na liczbę dziesiętną?

Pomnóż cztery liczby przez 256³, 256², 256 i 1, a potem je zsumuj: 192.168.1.1 to 192 × 16 777 216 + 168 × 65 536 + 1 × 256 + 1 = 3 232 235 777.

Adres IPv4 to jedna liczba 32-bitowa zapisana w czterech 8-bitowych kawałkach, więc postać z kropkami i postać dziesiętna to ta sama wartość. Dokumentacja MySQL podaje jako przykład 10.0.5.9 = 167773449.

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 jako jedna liczba: każda część razy jej waga, potem suma.
Konwerter IP na dziesiętny pokazujący bity i wagi każdego oktetu, które sumują się do liczbyKonwerter IP na dziesiętny pokazujący bity i wagi każdego oktetu, które sumują się do liczbyDowolna postać na wejściuZ kropkami, dziesiętnie, szesnastkowo, binarnie, ósemkowo albo jako URL: pole czyta wszystko.Bity i wagiKażda jedynka dodaje swoją wagę: 128 + 64 + 4 + 2 = 198.× 256³, 256², 256, 1Każdy oktet pomnożony przez swoją wagę, potem suma.Każda postać na wyjściuSzesnastkowo, binarnie, ósemkowo i adresy URL akceptowane przez przeglądarki, każde do skopiowania.LiczbaCały adres jako jedna liczba 32-bitowa, gotowa do skopiowania, z rodzajem adresu.
198.51.100.77 bit po bicie: wagi każdego oktetu, potem × 256³, 256², 256 i 1, razem 3 325 256 781.

Jak zamienić liczbę dziesiętną na adres IP?

Podziel przez 16 777 216, potem resztę przez 65 536, a potem przez 256: trzy ilorazy i ostatnia reszta to cztery liczby, więc 3232235777 to 192.168.1.1.

Wpisz liczbę w konwerter, a zrobi to samo, pokazując też postać szesnastkową, binarną, ósemkową i formy akceptowane przez przeglądarki. Liczby powyżej 4 294 967 295 nie są adresami IPv4; konwerter czyta je jako liczby IPv6 i o tym mówi.

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

192.168.1.1

3 232 235 777 z powrotem na 192.168.1.1 przez dzielenie.

Jak zamienić adres IP na binarny?

Zapisz każdą z czterech liczb jako 8 bitów z wagami 128, 64, 32, 16, 8, 4, 2 i 1: 192 to 128 + 64, czyli 11000000, a 192.168.1.1 to 11000000.10101000.00000001.00000001.

Idź po wagach od lewej: pisz 1 i odejmuj, gdy waga się mieści, w przeciwnym razie pisz 0. Dla 168: 128 się mieści (zostaje 40), 64 nie, 32 się mieści (zostaje 8), 16 nie, 8 się mieści, więc 10101000. Z powrotem z binarnego dodaj wagi jedynek.

1286432168421
19211000000128 + 64
16810101000128 + 32 + 8
1000000011
1000000011

11000000.10101000.00000001.00000001

Każdy oktet 192.168.1.1 zestawiony z wagami od 128 do 1.

Jak zamienić adres IP na hex?

Podziel 8 bitów każdego oktetu na dwie połówki po 4 i zapisz każdą połówkę jako jedną cyfrę szesnastkową: 192 to 1100 0000, czyli C0, więc 192.168.1.1 to 0xC0A80101.

Szesnastkowo IPv6 zapisuje też osadzony adres IPv4: ::ffff:c0a8:101 to 192.168.1.1. Przeglądarki przyjmują liczbę szesnastkową jako host: http://0xC0A80101/ otwiera 192.168.1.1.

19211000000C0
16810101000A8
10000000101
10000000101

0xC0A80101

4 bity = 1 cyfra szesnastkowa

Cztery bity na cyfrę szesnastkową: 192.168.1.1 to C0 A8 01 01.

Dlaczego http://3232235777 otwiera 192.168.1.1?

Bo przeglądarki czytają host złożony z samych liczb jako adres IPv4 w dowolnej ze starych form inet_aton, także jako jedną liczbę dziesiętną, a potem ładują adres z kropkami.

Każda część może być dziesiętna (standard URL), szesnastkowa z 0x albo ósemkowa z wiodącym 0, a gdy części jest mniej niż cztery, ostatnia wypełnia pozostałe bajty. Dlatego http://192.168.1/ otwiera 192.168.0.1, a nie 192.168.1.1. ping i curl przyjmują te same formy.

Liczby powyżej 32 bitów, cyfra 8 lub 9 w części zaczynającej się od 0 i piąta część są odrzucane.

Wpisane w pasek adresuOtwiera
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/Odrzucone
http://09/Odrzucone
http://192.0.2.1.5/Odrzucone
Co parser URL według WHATWG robi z każdym hostem.

Dlaczego alternatywne zapisy adresów IP mają znaczenie dla bezpieczeństwa?

Bo filtr, który porównuje adresy jako tekst, można oszukać: 2130706433, 0x7f.1, 127.1 i ::ffff:127.0.0.1 to wszystko 127.0.0.1, więc filtry muszą porównywać wartość liczbową, a nie napis.

OWASP wymienia te kodowania wśród sposobów obejścia zabezpieczeń przed SSRF. Biblioteki miały ten błąd: pakiety npm netmask i ip, ipaddress w Pythonie i pakiet net w Go w którymś momencie błędnie czytały zera wiodące lub alternatywne formy, a potem zostały poprawione.

Parsuj ścisłym parserem, zamień na liczbę, a dopiero potem porównuj zakresy. Blokuj też adresy mapowane z IPv4 z blokowanych zakresów.

deny 127.0.0.1

Porównanie jako tekst

127.0.0.1zablokowane

2130706433przechodzi

0x7f.1przechodzi

127.1przechodzi

::ffff:127.0.0.1przechodzi

Porównanie jako liczba

127.0.0.12130706433 · zablokowane

21307064332130706433 · zablokowane

0x7f.12130706433 · zablokowane

127.12130706433 · zablokowane

::ffff:127.0.0.12130706433 · zablokowane

CVE-2021-28918netmask (npm)CVE-2021-29418netmask (npm)CVE-2021-29424Net::Netmask (Perl)CVE-2021-29921Python ipaddressCVE-2021-29923Go netCVE-2024-29415ip (npm)
Jedna reguła, pięć zapisów adresu pętli zwrotnej; potem biuletyny bezpieczeństwa.

Jak zamienić adres IPv6 na liczbę dziesiętną?

Tak samo, tylko z ośmioma grupami 16-bitowymi: 2001:db8::1 to 42540766411282592856903984951653826561, liczba mająca do 39 cyfr, która w JavaScripcie wymaga BigInt.

Adresów IPv6 jest 2^128. Liczby w JavaScripcie przechowują liczby całkowite dokładnie tylko do 2^53 − 1, więc zwykła arytmetyka po cichu zaokrągla wartości IPv6. int(ipaddress.ip_address(…)) w Pythonie jest dokładne.

2001:db8::1

42540766411282592856903984951653826561

dokładnie (BigInt)

42540766411282592856903984951653826560

Number(): zaokrąglone powyżej 2^53

2001:db8::1 jako jedna liczba i to, co robi z nią zwykła liczba w JavaScripcie.

Jak zamieniać adresy IP na liczby w kodzie i bazach danych?

Używaj funkcji samej platformy z typem bez znaku: INET_ATON() z MySQL do INT UNSIGNED, odejmowania typu inet w PostgreSQL, int(ipaddress.ip_address(…)) w Pythonie i >>> 0 po przesunięciach w JavaScripcie.

32-bitowa liczba całkowita ze znakiem nie zmieści adresów od 128.0.0.0 w górę: << w JavaScripcie daje -1062731519 dla 192.168.1.1, a ip2long() w PHP daje wynik ujemny w 32-bitowych kompilacjach. Dla IPv6 MySQL używa INET6_ATON() i 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 jako liczba i z powrotem w dwóch bazach danych i trzech językach.

Najczęściej zadawane pytania

Ile to jest 192.168.1.1 dziesiętnie?

3232235777. Pomnóż każdą część przez jej wagę i zsumuj: 192 × 16 777 216 + 168 × 65 536 + 1 × 256 + 1 = 3 232 235 777. Ta sama liczba to szesnastkowo 0xC0A80101, a binarnie 11000000.10101000.00000001.00000001. Przeglądarki przyjmują ją też jako host, więc http://3232235777/ otwiera ten sam adres co http://192.168.1.1/.

Jaka jest największa wartość dziesiętna adresu IPv4?

4 294 967 295, czyli 255.255.255.255. Adres IPv4 to liczba 32-bitowa, więc jest ich 2^32 = 4 294 967 296, od 0 (0.0.0.0) do 4 294 967 295. Większe liczby nie są adresami IPv4: przeglądarki odrzucają http://4294967296/, a ten konwerter czyta takie liczby jako 128-bitowe wartości IPv6 i ci o tym mówi.

Jak zamienić 3232235777 z powrotem na adres IP?

Podziel przez 16 777 216, aby dostać pierwszą część: 192, reszta 11 010 305. Podziel tę resztę przez 65 536, aby dostać drugą część: 168, reszta 257. Podziel 257 przez 256, aby dostać trzecią część: 1, reszta 1, czyli część czwarta. Wynik to 192.168.1.1. Wpisz liczbę w konwerter, a pokaże też bity każdego oktetu.

Co oznacza zero wiodące, takie jak 010, w adresie IP?

To zależy od programu. Przeglądarki i inet_aton czytają część z zerem wiodącym jako liczbę ósemkową, więc 192.0.2.010 to 192.0.2.8, a narzędzia ignorujące zero czytają 192.0.2.10. Python i Go odrzucają dziś takie adresy w całości, po błędach, przez które dwa różne odczyty pozwalały żądaniom prześlizgnąć się obok filtrów IP. Nigdy nie pisz zer wiodących w adresach IPv4.

Dlaczego 192.168.1 otwiera 192.168.0.1?

Bo adres z trzech części wypełnia ostatnie 16 bitów swoją ostatnią częścią. W 192.168.1 końcowa 1 staje się 16-bitową liczbą 1, czyli 0.1, więc adres to 192.168.0.1. Tak inet_aton i przeglądarki czytają formy skrócone, a 192.168.257 dałoby 192.168.1.1. Typ cidr w PostgreSQL czyta 192.168.1 inaczej, jako sieć 192.168.1.0/24.

Jak ręcznie zamienić adres IP na binarny?

Dla każdej z czterech liczb przejdź po wagach 128, 64, 32, 16, 8, 4, 2 i 1: pisz 1 i odejmuj, gdy waga się mieści, w przeciwnym razie pisz 0. Dla 168: 128 się mieści (zostaje 40), 64 nie, 32 się mieści (zostaje 8), 16 nie, 8 się mieści (zostaje 0), więc 10101000. Połącz cztery grupy 8-bitowe kropkami.

Jak przechowywać adresy IP jako liczby w MySQL?

Zamień adres funkcją INET_ATON('10.0.5.9'), która zwraca 167773449, i zapisz wynik w kolumnie INT UNSIGNED: INT ze znakiem nie zmieści adresów powyżej 127.255.255.255. INET_NTOA zamienia liczbę z powrotem na tekst. Dla IPv6 użyj INET6_ATON i kolumny VARBINARY(16), bo wartości 128-bitowe nie mieszczą się w żadnym typie całkowitym. Nie polegaj na INET_ATON przy formach skróconych, takich jak 127.1.

Dlaczego moja liczba IP jest ujemna w JavaScripcie lub PHP?

Bo potraktowano ją jako 32-bitową liczbę całkowitą ze znakiem. Operator << w JavaScripcie zwraca wyniki ze znakiem, więc 192.168.1.1 zbudowane przesunięciami daje -1062731519; dodaj >>> 0, aby dostać 3232235777. ip2long w PHP zachowuje się tak samo w 32-bitowych kompilacjach, gdzie sprintf('%u', …) wypisuje wartość bez znaku. Dotyczy to tylko adresów od 128.0.0.0 w górę, dlatego błąd często pozostaje niezauważony.

Czy adres IPv6 da się zamienić na liczbę dziesiętną?

Tak. Adres IPv6 to liczba 128-bitowa, więc 2001:db8::1 to 42540766411282592856903984951653826561, a największa wartość ma 39 cyfr. Zwykłe liczby w JavaScripcie tracą precyzję powyżej 2^53, więc narzędzia muszą używać BigInt, a niektóre konwertery online podają błędne ostatnie cyfry. int(ipaddress.ip_address('2001:db8::1')) w Pythonie daje dokładną wartość.

Czy http://0x7f000001/ to to samo co 127.0.0.1?

Tak. Przeglądarki i wiele narzędzi wiersza poleceń czytają host z cyframi szesnastkowymi po 0x jako jedną liczbę 32-bitową, więc 0x7f000001, 2130706433, 0x7f.1 i 127.1 oznaczają 127.0.0.1, czyli adres pętli zwrotnej. Dlatego filtry bezpieczeństwa muszą porównywać wartość liczbową, a nie tekst, jak radzą RFC 3986 i ściągawka OWASP o SSRF.

Powiązane narzędzia