Популярные инструменты

Тема

Конвертер IP в десятичный формат

Переведите IP-адрес в десятичное, шестнадцатеричное, двоичное и восьмеричное число или введите любое из этих чисел, чтобы получить IP обратно. Каждый октет нарисован как 8 бит с весами разрядов, так что расчёт легко проследить.

Разбор по URL Standard (WHATWG) и inet_aton · точная 128-битная арифметика для IPv6 · работает в вашем браузере

Прочитано как запись с точками

8 бит каждого октета с весами разрядов198.51.100.77 = 3 325 256 781
Октет1286432168421HexСумма× вес= значение
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
Итого3 325 256 781
= 3 325 256 781
Примеры

IP-адрес или его десятичное, шестнадцатеричное, двоичное или восьмеричное число, чтобы получить IP обратно. Преобразование идёт в вашем браузере, ничего не отправляется.

IPv4 · 32 бита

3325256781

198.51.100.77 как одно 32-битное число · Адрес для документации (RFC 5737)

То же число в коде

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
Десятичная запись с точками
Десятичное число
Шестнадцатеричное
Двоичные октеты
Восьмеричное
Шестнадцатеричные октеты
Восьмеричные октеты
В браузере (каждый открывает 198.51.100.77)
Имя для обратного DNS
Как IPv6 (отображённый)
IPv4 → IPv6

Как перевести IP-адрес в десятичное число?

Умножьте четыре числа на 256³, 256², 256 и 1 и сложите: 192.168.1.1 — это 192 × 16 777 216 + 168 × 65 536 + 1 × 256 + 1 = 3 232 235 777.

Адрес IPv4 — это одно 32-битное число, записанное четырьмя 8-битными частями, поэтому запись с точками и десятичная запись — одно и то же значение. В документации MySQL в качестве примера приведено 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 как одно число: каждая часть умножается на свой вес, затем всё складывается.
Конвертер IP в десятичный формат: биты и веса разрядов каждого октета складываются в числоКонвертер IP в десятичный формат: биты и веса разрядов каждого октета складываются в числоЛюбая форма на входеС точками, десятичное число, hex, двоичная, восьмеричная запись или URL: поле читает всё.Биты и веса разрядовКаждая 1 добавляет вес своего разряда: 128 + 64 + 4 + 2 = 198.× 256³, 256², 256, 1Каждый октет умножается на свой вес, затем всё складывается.Все формы на выходеHex, двоичная и восьмеричная запись и URL, которые принимают браузеры, каждая с кнопкой копирования.ЧислоВесь адрес как одно 32-битное число, готовое к копированию, и тип адреса.
198.51.100.77 бит за битом: веса разрядов каждого октета, затем × 256³, 256², 256 и 1, в сумме 3 325 256 781.

Как перевести число в IP-адрес в стандартной форме с точками?

Разделите на 16 777 216, затем остаток — на 65 536, затем на 256: три частных и последний остаток — это четыре числа, так что 3232235777 — это 192.168.1.1.

Введите число в конвертер, и он сделает то же самое, а заодно покажет hex, двоичную и восьмеричную запись и формы, которые принимают браузеры. Числа больше 4 294 967 295 — не адреса IPv4: конвертер читает их как числа IPv6 и сообщает об этом.

3 232 235 777÷ 16 777 216=192остаток 11 010 305
11 010 305÷ 65 536=168остаток 257
257÷ 256=1остаток 1
1÷ 1=1остаток 0

192.168.1.1

3 232 235 777 обратно в 192.168.1.1 делением.

Как перевести IP-адрес в двоичную систему счисления?

Запишите каждое из четырёх чисел 8 битами с весами разрядов 128, 64, 32, 16, 8, 4, 2 и 1: 192 = 128 + 64, то есть 11000000, а 192.168.1.1 — это 11000000.10101000.00000001.00000001.

Идите по весам разрядов слева: если вес помещается, пишите 1 и вычитайте его, иначе пишите 0. Для 168: 128 помещается (остаётся 40), 64 нет, 32 помещается (остаётся 8), 16 нет, 8 помещается, получается 10101000. Чтобы перевести из двоичной системы в десятичную, сложите веса разрядов, где стоят единицы.

1286432168421
19211000000128 + 64
16810101000128 + 32 + 8
1000000011
1000000011

11000000.10101000.00000001.00000001

Каждый октет 192.168.1.1 и веса разрядов от 128 до 1.

Как перевести IP-адрес в шестнадцатеричную систему?

Разделите 8 бит каждого октета на две половины по 4 бита и запишите каждую половину одной hex-цифрой: 192 — это 1100 0000, то есть C0, так что 192.168.1.1 — это 0xC0A80101.

В обратную сторону каждые две hex-цифры дают один октет: C0 — это 192. IPv6 тоже записывает встроенный адрес IPv4 в hex: ::ffff:c0a8:101 — это 192.168.1.1. Браузеры принимают hex-число как хост: http://0xC0A80101/ открывает 192.168.1.1.

19211000000C0
16810101000A8
10000000101
10000000101

0xC0A80101

4 бита = 1 hex-цифра

По четыре бита на шестнадцатеричную цифру: 192.168.1.1 — это C0 A8 01 01.

Почему http://3232235777 открывает 192.168.1.1?

Потому что браузеры читают хост, состоящий только из чисел, как адрес IPv4 в любой из старых форм inet_aton, включая одно десятичное число, и затем загружают адрес с точками.

Каждая часть может быть десятичной (URL Standard), шестнадцатеричной с 0x или восьмеричной с ведущим 0, а если частей меньше четырёх, последняя заполняет оставшиеся байты. Поэтому http://192.168.1/ открывает 192.168.0.1, а не 192.168.1.1. ping и curl принимают те же формы.

Числа больше 32 бит, 8 или 9 в части, которая начинается с 0, и пятая часть отклоняются.

Введено в адресной строкеОткрывает
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/Отклонено
http://09/Отклонено
http://192.0.2.1.5/Отклонено
Что делает с каждым хостом парсер URL по стандарту WHATWG.

Почему альтернативные формы IP-адреса важны для безопасности?

Потому что фильтр, сравнивающий адреса как текст, можно обмануть: 2130706433, 0x7f.1, 127.1 и ::ffff:127.0.0.1 — это всё 127.0.0.1, поэтому фильтры должны сравнивать числовое значение, а не строку.

OWASP перечисляет эти кодировки среди способов обойти защиту от SSRF. Такая ошибка встречалась и в библиотеках: npm-пакеты netmask и ip, модуль ipaddress в Python и пакет net в Go в своё время неправильно читали ведущие нули или альтернативные формы, и с тех пор это исправлено.

Разбирайте адрес строгим парсером, переводите в число, затем сравнивайте диапазоны. Блокируйте и отображённые адреса IPv4 из заблокированных диапазонов.

deny 127.0.0.1

Сравнение как текста

127.0.0.1заблокировано

2130706433проходит

0x7f.1проходит

127.1проходит

::ffff:127.0.0.1проходит

Сравнение как числа

127.0.0.12130706433 · заблокировано

21307064332130706433 · заблокировано

0x7f.12130706433 · заблокировано

127.12130706433 · заблокировано

::ffff:127.0.0.12130706433 · заблокировано

CVE-2021-28918netmask (npm)CVE-2021-29418netmask (npm)CVE-2021-29424Net::Netmask (Perl)CVE-2021-29921Python ipaddressCVE-2021-29923Go netCVE-2024-29415ip (npm)
Одно правило, пять записей петлевого адреса; затем бюллетени безопасности.

Как перевести адрес IPv6 в десятичное число?

Так же, но с восемью 16-битными группами: 2001:db8::1 — это 42540766411282592856903984951653826561, число длиной до 39 цифр, для которого в JavaScript нужен BigInt.

Адресов IPv6 всего 2^128. Числа JavaScript хранят целые значения точно только до 2^53 − 1, поэтому обычная арифметика незаметно округляет значения IPv6. int(ipaddress.ip_address(…)) в Python даёт точный результат.

2001:db8::1

42540766411282592856903984951653826561

точно (BigInt)

42540766411282592856903984951653826560

Number(): округление после 2^53

2001:db8::1 как одно число и что из него делает обычное число JavaScript.

Как переводить IP-адреса в числа в коде и базах данных?

Используйте функции самой платформы и беззнаковый тип: INET_ATON() в MySQL со столбцом INT UNSIGNED, вычитание inet в PostgreSQL, int(ipaddress.ip_address(…)) в Python и >>> 0 после сдвигов в JavaScript.

Знаковое 32-битное целое не вмещает адреса начиная с 128.0.0.0: << в JavaScript даёт -1062731519 для 192.168.1.1, а ip2long() в PHP уходит в минус на 32-битных сборках. Для IPv6 MySQL использует INET6_ATON() и 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 в число и обратно в двух базах данных и трёх языках.

Частые вопросы

Как перевести 192.168.1.1 в десятичную форму?

3232235777. Умножьте каждую часть на вес её разряда и сложите: 192 × 16 777 216 + 168 × 65 536 + 1 × 256 + 1 = 3 232 235 777. То же число в hex — 0xC0A80101, а в двоичной системе — 11000000.10101000.00000001.00000001. Браузеры принимают его и как хост, поэтому http://3232235777/ открывает тот же адрес, что и http://192.168.1.1/.

Какое наибольшее десятичное значение у адреса IPv4?

4 294 967 295, то есть 255.255.255.255. Адрес IPv4 — это 32-битное число, поэтому всего их 2^32 = 4 294 967 296, от 0 (0.0.0.0) до 4 294 967 295. Большие числа — уже не адреса IPv4: браузеры отклоняют http://4294967296/, а этот конвертер читает такие числа как 128-битные значения IPv6 и сообщает вам об этом.

Как перевести 3232235777 в стандартную форму IP-адреса с точками?

Разделите на 16 777 216 — это первая часть: 192, остаток 11 010 305. Разделите остаток на 65 536 — вторая часть: 168, остаток 257. Разделите 257 на 256 — третья часть: 1, остаток 1, и это четвёртая часть. Ответ: 192.168.1.1. Введите число в конвертер, и он покажет ещё и биты каждого октета.

Что значит ведущий ноль, например 010, в IP-адресе?

Это зависит от программы. Браузеры и inet_aton читают часть с ведущим нулём как восьмеричную, так что 192.0.2.010 — это 192.0.2.8, а инструменты, которые игнорируют ноль, читают 192.0.2.10. Python и Go теперь сразу отклоняют такие адреса — после ошибок, когда два прочтения позволяли запросам проскользнуть мимо IP-фильтров. Никогда не пишите ведущие нули в адресах IPv4.

Почему 192.168.1 открывает 192.168.0.1?

Потому что в адресе из трёх частей последняя часть заполняет последние 16 бит. В 192.168.1 последняя 1 становится 16-битным числом 1, то есть 0.1, и получается адрес 192.168.0.1. Так короткие формы читают inet_aton и браузеры, а 192.168.257 было бы 192.168.1.1. Тип cidr в PostgreSQL читает 192.168.1 иначе — как сеть 192.168.1.0/24.

Как перевести IP-адрес из двоичной системы в десятичную и обратно?

Из двоичной в десятичную: сложите веса разрядов тех битов, где стоят единицы, например 10101000 = 128 + 32 + 8 = 168. Обратно пройдите по весам 128, 64, 32, 16, 8, 4, 2 и 1: если вес помещается, пишите 1 и вычитайте его, иначе 0. Для 168: 128 помещается (остаётся 40), 64 нет, 32 помещается (остаётся 8), 16 нет, 8 помещается (остаётся 0), получается 10101000. Четыре 8-битные группы соединяются точками.

Как хранить IP-адреса в MySQL в виде чисел?

Переводите их функцией INET_ATON('10.0.5.9'), которая возвращает 167773449, и храните результат в столбце INT UNSIGNED: знаковый INT не вмещает адреса выше 127.255.255.255. INET_NTOA превращает число обратно в текст. Для IPv6 используйте INET6_ATON и столбец VARBINARY(16), потому что 128-битные значения не помещаются ни в один целочисленный тип. Не полагайтесь на INET_ATON для коротких форм вроде 127.1.

Почему число IP-адреса получается отрицательным в JavaScript или PHP?

Потому что его обработали как знаковое 32-битное целое. Оператор << в JavaScript возвращает знаковые результаты, поэтому 192.168.1.1, собранный сдвигами, даёт -1062731519; добавьте >>> 0, чтобы получить 3232235777. ip2long в PHP ведёт себя так же на 32-битных сборках, где sprintf('%u', …) выводит беззнаковое значение. Затронуты только адреса начиная с 128.0.0.0, поэтому ошибку часто не замечают.

Можно ли перевести адрес IPv6 в десятичное число?

Да. Адрес IPv6 — это 128-битное число, так что 2001:db8::1 — это 42540766411282592856903984951653826561, а наибольшее значение состоит из 39 цифр. Обычные числа JavaScript теряют точность после 2^53, поэтому инструменты должны использовать BigInt, и некоторые онлайн-конвертеры ошибаются в последних цифрах. int(ipaddress.ip_address('2001:db8::1')) в Python даёт точное значение.

http://0x7f000001/ — это то же самое, что 127.0.0.1?

Да. Браузеры и многие консольные утилиты читают хост из hex-цифр после 0x как одно 32-битное число, так что 0x7f000001, 2130706433, 0x7f.1 и 127.1 означают 127.0.0.1, петлевой адрес. Поэтому фильтры безопасности должны сравнивать числовое значение, а не текст, — так советуют RFC 3986 и шпаргалка OWASP по SSRF.

Чего-то не хватает?Предложите функцию или новый инструмент

Похожие инструменты