Herramientas populares

Tema

Conversor de IP a decimal

Convierta una dirección IP a decimal, hexadecimal, binario y octal, o escriba cualquiera de esos números para recuperar la IP. Cada octeto se dibuja como 8 bits con sus valores posicionales, para que pueda seguir la aritmética.

Lectura según el URL Standard de WHATWG e inet_aton · aritmética exacta de 128 bits para IPv6 · funciona en su navegador

Leído como decimal con puntos

Los 8 bits de cada octeto, con sus valores posicionales198.51.100.77 = 3 325 256 781
Octeto1286432168421HexSuma× posición= valor
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
Total3 325 256 781
= 3 325 256 781
Pruebe

Una IP, o su número decimal, hex, binario u octal para recuperar la IP. Se convierte en su navegador; no se envía nada.

IPv4 · 32 bits

3325256781

198.51.100.77 como un solo número de 32 bits · Dirección de documentación (RFC 5737)

El mismo número en código

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
Decimal con puntos
Decimal
Hex
Octetos en binario
Octal
Octetos en hex
Octetos en octal
En un navegador (cada una abre 198.51.100.77)
Nombre de DNS inverso
Como IPv6 (mapeada)
IPv4 → IPv6

¿Cómo convertir una dirección IP a decimal?

Multiplique los cuatro números por 256³, 256², 256 y 1 y súmelos: 192.168.1.1 es 192 × 16 777 216 + 168 × 65 536 + 1 × 256 + 1 = 3 232 235 777.

Una dirección IPv4 es un número de 32 bits escrito en cuatro partes de 8 bits, así que la forma con puntos y la forma decimal son el mismo valor. La documentación de MySQL usa como ejemplo 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 como un solo número: cada parte por su posición y luego la suma.
Conversor de IP a decimal con los bits y valores posicionales de cada octeto sumando hasta el númeroConversor de IP a decimal con los bits y valores posicionales de cada octeto sumando hasta el númeroCualquier forma de entradaCon puntos, decimal, hex, binario, octal o una URL: el campo los lee todos.Bits y valores posicionalesCada 1 suma su valor posicional: 128 + 64 + 4 + 2 = 198.× 256³, 256², 256, 1Cada octeto por su peso, y luego el total.Todas las formas de salidaHex, binario, octal y las URL que aceptan los navegadores, cada una con su botón de copiar.El númeroLa dirección completa como un solo número de 32 bits, lista para copiar, con el tipo de dirección que es.
198.51.100.77 bit a bit: los valores posicionales de cada octeto y luego × 256³, 256², 256 y 1, hasta sumar 3 325 256 781.

¿Cómo convertir un número decimal a dirección IP?

Divida entre 16 777 216, luego divida el resto entre 65 536 y después entre 256: los tres cocientes y el último resto son los cuatro números, así que 3232235777 es 192.168.1.1.

Escriba el número en el conversor y hará lo mismo, junto con hex, binario, octal y las formas que aceptan los navegadores. Los números mayores que 4 294 967 295 no son direcciones IPv4; el conversor los lee como números IPv6 y lo indica.

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

192.168.1.1

3 232 235 777 de vuelta a 192.168.1.1 mediante divisiones.

¿Cómo convertir una dirección IP a binario?

Escriba cada uno de los cuatro números como 8 bits con los valores posicionales 128, 64, 32, 16, 8, 4, 2 y 1: 192 es 128 + 64, es decir, 11000000, y 192.168.1.1 es 11000000.10101000.00000001.00000001.

Recorra los valores posicionales desde la izquierda: escriba 1 y reste cuando el valor cabe; si no, escriba 0. Para 168: 128 cabe (quedan 40), 64 no, 32 cabe (quedan 8), 16 no, 8 cabe, así que 10101000. Para volver desde binario, sume los valores posicionales de los 1.

1286432168421
19211000000128 + 64
16810101000128 + 32 + 8
1000000011
1000000011

11000000.10101000.00000001.00000001

Cada octeto de 192.168.1.1 frente a los valores posicionales de 128 a 1.

¿Cómo convertir una dirección IP a hexadecimal?

Divida los 8 bits de cada octeto en dos mitades de 4 y escriba cada mitad como un dígito hex: 192 es 1100 0000, es decir, C0, así que 192.168.1.1 es 0xC0A80101.

Hex es también la forma en que IPv6 escribe una dirección IPv4 incrustada: ::ffff:c0a8:101 es 192.168.1.1. Los navegadores aceptan el número hex como host: http://0xC0A80101/ abre 192.168.1.1.

19211000000C0
16810101000A8
10000000101
10000000101

0xC0A80101

4 bits = 1 dígito hex

Cuatro bits por dígito hex: 192.168.1.1 es C0 A8 01 01.

¿Por qué http://3232235777 abre 192.168.1.1?

Porque los navegadores leen un host formado solo por números como una dirección IPv4 en cualquiera de las antiguas formas de inet_aton, incluido un único número decimal, y luego cargan la dirección con puntos.

Cada parte puede ser decimal (el URL Standard), hex con 0x u octal con un 0 a la izquierda, y con menos de cuatro partes la última ocupa los bytes restantes. Así, http://192.168.1/ abre 192.168.0.1, no 192.168.1.1. ping y curl aceptan las mismas formas.

Se rechazan los números de más de 32 bits, un 8 o un 9 en una parte que empieza por 0, y una quinta parte.

Escrito en la barra de direccionesAbre
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/Rechazado
http://09/Rechazado
http://192.0.2.1.5/Rechazado
Lo que hace el analizador de URL de WHATWG con cada host.

¿Por qué importan para la seguridad las formas alternativas de una dirección IP?

Porque un filtro que compara direcciones como texto se puede engañar: 2130706433, 0x7f.1, 127.1 y ::ffff:127.0.0.1 son todas 127.0.0.1, así que los filtros deben comparar el valor numérico, no la cadena.

OWASP incluye estas codificaciones entre las formas de eludir las defensas contra SSRF. Hay bibliotecas que han tenido este fallo: los paquetes npm netmask e ip, ipaddress de Python y el paquete net de Go interpretaron mal en algún momento los ceros a la izquierda o las formas alternativas, y ya se corrigieron.

Analice con un lector estricto, convierta a número y luego compare rangos. Bloquee también las direcciones IPv4 mapeadas de los rangos bloqueados.

deny 127.0.0.1

Comparadas como texto

127.0.0.1se bloquea

2130706433pasa

0x7f.1pasa

127.1pasa

::ffff:127.0.0.1pasa

Comparadas como número

127.0.0.12130706433 · se bloquea

21307064332130706433 · se bloquea

0x7f.12130706433 · se bloquea

127.12130706433 · se bloquea

::ffff:127.0.0.12130706433 · se bloquea

CVE-2021-28918netmask (npm)CVE-2021-29418netmask (npm)CVE-2021-29424Net::Netmask (Perl)CVE-2021-29921Python ipaddressCVE-2021-29923Go netCVE-2024-29415ip (npm)
Una regla, cinco formas de escribir la dirección de loopback; después, los avisos de seguridad.

¿Cómo convertir una dirección IPv6 a decimal?

Igual, con ocho grupos de 16 bits: 2001:db8::1 es 42540766411282592856903984951653826561, un número de hasta 39 dígitos que en JavaScript necesita BigInt.

Hay 2^128 direcciones IPv6. Los números de JavaScript solo guardan enteros exactos hasta 2^53 − 1, así que la aritmética normal redondea en silencio los valores IPv6. int(ipaddress.ip_address(…)) de Python es exacto.

2001:db8::1

42540766411282592856903984951653826561

exacto (BigInt)

42540766411282592856903984951653826560

Number(): redondeado a partir de 2^53

2001:db8::1 como un solo número, y lo que hace con él un número normal de JavaScript.

¿Cómo convertir direcciones IP a números en código y bases de datos?

Use las funciones propias de cada plataforma con un tipo sin signo: INET_ATON() de MySQL en un INT UNSIGNED, la resta de inet de PostgreSQL, int(ipaddress.ip_address(…)) de Python y >>> 0 después de los desplazamientos en JavaScript.

Un entero de 32 bits con signo no puede guardar las direcciones desde 128.0.0.0: << de JavaScript da -1062731519 para 192.168.1.1, y ip2long() de PHP da negativos en compilaciones de 32 bits. Para IPv6, MySQL usa INET6_ATON() y 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 como número y de vuelta en dos bases de datos y tres lenguajes.

Preguntas frecuentes

¿Cuánto es 192.168.1.1 en decimal?

3232235777. Multiplique cada parte por su valor posicional y sume: 192 × 16 777 216 + 168 × 65 536 + 1 × 256 + 1 = 3 232 235 777. El mismo número es 0xC0A80101 en hex y 11000000.10101000.00000001.00000001 en binario. Los navegadores también lo aceptan como host, así que http://3232235777/ abre la misma dirección que http://192.168.1.1/.

¿Cuál es el mayor valor decimal de una dirección IPv4?

4 294 967 295, que es 255.255.255.255. Una dirección IPv4 es un número de 32 bits, así que hay 2^32 = 4 294 967 296 direcciones, desde 0 (0.0.0.0) hasta 4 294 967 295. Los números mayores no son direcciones IPv4: los navegadores rechazan http://4294967296/, y este conversor lee esos números como valores IPv6 de 128 bits y se lo indica.

¿Cómo convierto 3232235777 de vuelta a una dirección IP?

Divida entre 16 777 216 para la primera parte: 192, resto 11 010 305. Divida ese resto entre 65 536 para la segunda: 168, resto 257. Divida 257 entre 256 para la tercera: 1, resto 1, que es la cuarta parte. La respuesta es 192.168.1.1. Escriba el número en el conversor y también verá los bits de cada octeto.

¿Qué significa un cero a la izquierda, como 010, en una dirección IP?

Depende del programa. Los navegadores e inet_aton leen como octal una parte con un cero a la izquierda, así que 192.0.2.010 es 192.0.2.8, mientras que las herramientas que ignoran el cero leen 192.0.2.10. Python y Go ahora rechazan directamente esas direcciones, después de fallos en los que las dos lecturas permitían que las solicitudes esquivaran filtros de IP. No escriba nunca ceros a la izquierda en direcciones IPv4.

¿Por qué 192.168.1 abre 192.168.0.1?

Porque una dirección de tres partes llena los últimos 16 bits con su última parte. En 192.168.1, el 1 final pasa a ser el número de 16 bits 1, que es 0.1, así que la dirección es 192.168.0.1. Así leen las formas cortas inet_aton y los navegadores, y 192.168.257 sería 192.168.1.1. El tipo cidr de PostgreSQL lee 192.168.1 de otra forma: como la red 192.168.1.0/24.

¿Cómo pasar una dirección IP a binario a mano?

Para cada uno de los cuatro números, recorra los valores posicionales 128, 64, 32, 16, 8, 4, 2 y 1: escriba 1 y reste cuando el valor cabe; si no, escriba 0. Para 168: 128 cabe (quedan 40), 64 no, 32 cabe (quedan 8), 16 no, 8 cabe (queda 0), así que 10101000. Una los cuatro grupos de 8 bits con puntos.

¿Cómo guardar direcciones IP como números en MySQL?

Convierta con INET_ATON('10.0.5.9'), que devuelve 167773449, y guarde el resultado en una columna INT UNSIGNED: un INT con signo no puede guardar direcciones por encima de 127.255.255.255. INET_NTOA vuelve a convertir el número en texto. Para IPv6 use INET6_ATON y una columna VARBINARY(16), porque los valores de 128 bits no caben en ningún tipo entero. No confíe en INET_ATON para formas cortas como 127.1.

¿Por qué mi número de IP sale negativo en JavaScript o PHP?

Porque se trató como un entero de 32 bits con signo. El operador << de JavaScript devuelve resultados con signo, así que 192.168.1.1 construida con desplazamientos da -1062731519; agregue >>> 0 para obtener 3232235777. ip2long de PHP se comporta igual en compilaciones de 32 bits, donde sprintf('%u', …) imprime el valor sin signo. Solo se ven afectadas las direcciones desde 128.0.0.0, por eso el fallo suele pasar inadvertido.

¿Se puede convertir una dirección IPv6 a decimal?

Sí. Una dirección IPv6 es un número de 128 bits, así que 2001:db8::1 es 42540766411282592856903984951653826561, y el valor más grande tiene 39 dígitos. Los números normales de JavaScript pierden precisión por encima de 2^53, así que las herramientas deben usar BigInt, y algunos conversores en línea se equivocan en los últimos dígitos. int(ipaddress.ip_address('2001:db8::1')) de Python da el valor exacto.

¿http://0x7f000001/ es lo mismo que 127.0.0.1?

Sí. Los navegadores y muchas herramientas de línea de comandos leen un host de dígitos hex después de 0x como un solo número de 32 bits, así que 0x7f000001, 2130706433, 0x7f.1 y 127.1 significan todos 127.0.0.1, la dirección de loopback. Por eso los filtros de seguridad deben comparar el valor numérico y no el texto, como aconsejan la RFC 3986 y la hoja de referencia de OWASP sobre SSRF.

¿Le falta algo?Sugiera una función o una herramienta nueva

Herramientas relacionadas