Ferramentas populares

Tema

Conversor de IP para decimal

Converta um endereço IP para decimal, hexadecimal, binário e octal, ou digite qualquer um desses números para obter o IP de volta. Cada octeto aparece como 8 bits com os seus valores posicionais, para você acompanhar a conta.

Leitura pelo URL Standard do WHATWG e pelo inet_aton · aritmética exata de 128 bits para IPv6 · roda no seu navegador

Lido como decimal com pontos

Os 8 bits de cada octeto, com seus valores posicionais198.51.100.77 = 3 325 256 781
Octeto1286432168421HexSoma× posição= 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
Experimente

Um IP, ou o número dele em decimal, hex, binário ou octal para obter o IP de volta. A conversão é feita no seu navegador; nada é enviado.

IPv4 · 32 bits

3325256781

198.51.100.77 como um único número de 32 bits · Endereço de documentação (RFC 5737)

O mesmo número em 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 com pontos
Decimal
Hex
Octetos em binário
Octal
Octetos em hex
Octetos em octal
Num navegador (cada uma abre 198.51.100.77)
Nome de DNS reverso
Como IPv6 (mapeado)
IPv4 → IPv6

Como converter um endereço IP para decimal?

Multiplique os quatro números por 256³, 256², 256 e 1 e some: 192.168.1.1 é 192 × 16 777 216 + 168 × 65 536 + 1 × 256 + 1 = 3 232 235 777.

Um endereço IPv4 é um número de 32 bits escrito em quatro pedaços de 8 bits, então a forma com pontos e a forma decimal são o mesmo valor. A documentação do MySQL usa 10.0.5.9 = 167773449 como exemplo.

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 um único número: cada parte vezes a sua posição, depois a soma.
Conversor de IP para decimal mostrando os bits e valores posicionais de cada octeto somando até o númeroConversor de IP para decimal mostrando os bits e valores posicionais de cada octeto somando até o númeroQualquer forma na entradaCom pontos, decimal, hex, binário, octal ou uma URL: o campo lê todas.Bits e valores posicionaisCada 1 soma o seu valor posicional: 128 + 64 + 4 + 2 = 198.× 256³, 256², 256, 1Cada octeto vezes o seu peso, depois o total.Todas as formas na saídaHex, binário, octal e as URLs que os navegadores aceitam, cada uma com botão de copiar.O númeroO endereço inteiro como um único número de 32 bits, pronto para copiar, com o tipo de endereço.
198.51.100.77 bit a bit: os valores posicionais de cada octeto, depois × 256³, 256², 256 e 1, somando 3 325 256 781.

Como converter decimal para endereço IP?

Divida por 16 777 216, depois divida o resto por 65 536 e então por 256: os três quocientes e o último resto são os quatro números, então 3232235777 é 192.168.1.1.

Digite o número no conversor e ele faz o mesmo, junto com hex, binário, octal e as formas que os navegadores aceitam. Números acima de 4 294 967 295 não são endereços IPv4; o conversor os lê como números IPv6 e avisa.

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 volta para 192.168.1.1 por divisão.

Como converter um endereço IP para binário?

Escreva cada um dos quatro números como 8 bits com os valores posicionais 128, 64, 32, 16, 8, 4, 2 e 1: 192 é 128 + 64, portanto 11000000, e 192.168.1.1 é 11000000.10101000.00000001.00000001.

Percorra os valores posicionais da esquerda para a direita: escreva 1 e subtraia quando o valor cabe; senão, escreva 0. Para 168: 128 cabe (sobram 40), 64 não, 32 cabe (sobram 8), 16 não, 8 cabe, então 10101000. Para voltar do binário, some os valores posicionais dos 1.

1286432168421
19211000000128 + 64
16810101000128 + 32 + 8
1000000011
1000000011

11000000.10101000.00000001.00000001

Cada octeto de 192.168.1.1 diante dos valores posicionais de 128 a 1.

Como converter um endereço IP para hexadecimal?

Divida os 8 bits de cada octeto em duas metades de 4 e escreva cada metade como um dígito hex: 192 é 1100 0000, ou seja, C0, então 192.168.1.1 é 0xC0A80101.

Hex também é como o IPv6 escreve um endereço IPv4 embutido: ::ffff:c0a8:101 é 192.168.1.1. Os navegadores aceitam o número hex como host: http://0xC0A80101/ abre 192.168.1.1.

19211000000C0
16810101000A8
10000000101
10000000101

0xC0A80101

4 bits = 1 dígito hex

Quatro bits por dígito hex: 192.168.1.1 é C0 A8 01 01.

Por que http://3232235777 abre 192.168.1.1?

Porque os navegadores leem um host feito só de números como um endereço IPv4 em qualquer das antigas formas do inet_aton, inclusive um único número decimal, e então carregam o endereço com pontos.

Cada parte pode ser decimal (o URL Standard), hex com 0x ou octal com um 0 à esquerda, e com menos de quatro partes a última preenche os bytes restantes. Então http://192.168.1/ abre 192.168.0.1, não 192.168.1.1. O ping e o curl aceitam as mesmas formas.

Números acima de 32 bits, um 8 ou 9 numa parte que começa com 0 e uma quinta parte são recusados.

Digitado na barra de endereçosAbre
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/Recusado
http://09/Recusado
http://192.0.2.1.5/Recusado
O que o parser de URL do WHATWG faz com cada host.

Por que formas alternativas de endereço IP importam para a segurança?

Porque um filtro que compara endereços como texto pode ser enganado: 2130706433, 0x7f.1, 127.1 e ::ffff:127.0.0.1 são todos 127.0.0.1, então os filtros precisam comparar o valor numérico, não a string.

A OWASP lista essas codificações entre as formas de contornar defesas contra SSRF. Bibliotecas já tiveram esse bug: os pacotes npm netmask e ip, o ipaddress do Python e o pacote net do Go leram errado zeros à esquerda ou formas alternativas em algum momento, e já foram corrigidos.

Faça o parsing com um leitor estrito, converta para número e só então compare faixas. Bloqueie também os endereços IPv4 mapeados das faixas bloqueadas.

deny 127.0.0.1

Comparado como texto

127.0.0.1bloqueado

2130706433passa

0x7f.1passa

127.1passa

::ffff:127.0.0.1passa

Comparado como número

127.0.0.12130706433 · bloqueado

21307064332130706433 · bloqueado

0x7f.12130706433 · bloqueado

127.12130706433 · bloqueado

::ffff:127.0.0.12130706433 · bloqueado

CVE-2021-28918netmask (npm)CVE-2021-29418netmask (npm)CVE-2021-29424Net::Netmask (Perl)CVE-2021-29921Python ipaddressCVE-2021-29923Go netCVE-2024-29415ip (npm)
Uma regra, cinco grafias do endereço de loopback; depois, os alertas de segurança.

Como converter um endereço IPv6 para decimal?

Do mesmo jeito, com oito grupos de 16 bits: 2001:db8::1 é 42540766411282592856903984951653826561, um número de até 39 dígitos que exige BigInt em JavaScript.

Existem 2^128 endereços IPv6. Os números do JavaScript só guardam inteiros exatos até 2^53 − 1, então a aritmética comum arredonda valores IPv6 sem avisar. O int(ipaddress.ip_address(…)) do Python é exato.

2001:db8::1

42540766411282592856903984951653826561

exato (BigInt)

42540766411282592856903984951653826560

Number(): arredondado depois de 2^53

2001:db8::1 como um único número, e o que um número comum de JavaScript faz com ele.

Como converter endereços IP em números no código e em bancos de dados?

Use as funções da própria plataforma com um tipo sem sinal: INET_ATON() do MySQL num INT UNSIGNED, a subtração de inet do PostgreSQL, int(ipaddress.ip_address(…)) do Python e >>> 0 depois dos deslocamentos em JavaScript.

Um inteiro de 32 bits com sinal não comporta endereços a partir de 128.0.0.0: o << do JavaScript dá -1062731519 para 192.168.1.1, e o ip2long() do PHP fica negativo em builds de 32 bits. Para IPv6, o MySQL usa INET6_ATON() e 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 e de volta em dois bancos de dados e três linguagens.

Perguntas frequentes

Quanto é 192.168.1.1 em decimal?

3232235777. Multiplique cada parte pelo seu valor posicional e some: 192 × 16 777 216 + 168 × 65 536 + 1 × 256 + 1 = 3 232 235 777. O mesmo número é 0xC0A80101 em hex e 11000000.10101000.00000001.00000001 em binário. Os navegadores também o aceitam como host, então http://3232235777/ abre o mesmo endereço que http://192.168.1.1/.

Qual é o maior valor decimal de um endereço IPv4?

4 294 967 295, que é 255.255.255.255. Um endereço IPv4 é um número de 32 bits, então existem 2^32 = 4 294 967 296 deles, de 0 (0.0.0.0) até 4 294 967 295. Números maiores não são endereços IPv4: os navegadores recusam http://4294967296/, e este conversor lê esses números como valores IPv6 de 128 bits e avisa você.

Como converter 3232235777 de volta para endereço IP?

Divida por 16 777 216 para a primeira parte: 192, resto 11 010 305. Divida esse resto por 65 536 para a segunda parte: 168, resto 257. Divida 257 por 256 para a terceira parte: 1, resto 1, que é a quarta parte. A resposta é 192.168.1.1. Digite o número no conversor e ele também mostra os bits de cada octeto.

O que significa um zero à esquerda, como 010, num endereço IP?

Depende do programa. Os navegadores e o inet_aton leem uma parte com zero à esquerda como octal, então 192.0.2.010 é 192.0.2.8, enquanto ferramentas que ignoram o zero leem 192.0.2.10. O Python e o Go hoje recusam esses endereços de cara, depois de bugs em que as duas leituras deixavam requisições passarem por filtros de IP. Nunca escreva zeros à esquerda em endereços IPv4.

Por que 192.168.1 abre 192.168.0.1?

Porque um endereço de três partes preenche os últimos 16 bits com a última parte. Em 192.168.1, o 1 final vira o número de 16 bits 1, que é 0.1, então o endereço é 192.168.0.1. É assim que o inet_aton e os navegadores leem formas curtas, e 192.168.257 seria 192.168.1.1. O tipo cidr do PostgreSQL lê 192.168.1 de outro jeito, como a rede 192.168.1.0/24.

Como converter um endereço IP para binário à mão?

Para cada um dos quatro números, percorra os valores posicionais 128, 64, 32, 16, 8, 4, 2 e 1: escreva 1 e subtraia quando o valor cabe; senão, escreva 0. Para 168: 128 cabe (sobram 40), 64 não, 32 cabe (sobram 8), 16 não, 8 cabe (sobra 0), então 10101000. Junte os quatro grupos de 8 bits com pontos.

Como guardar endereços IP como números no MySQL?

Converta com INET_ATON('10.0.5.9'), que retorna 167773449, e guarde o resultado numa coluna INT UNSIGNED: um INT com sinal não comporta endereços acima de 127.255.255.255. O INET_NTOA transforma o número de volta em texto. Para IPv6, use INET6_ATON e uma coluna VARBINARY(16), porque valores de 128 bits não cabem em nenhum tipo inteiro. Não conte com o INET_ATON para formas curtas como 127.1.

Por que o número do meu IP fica negativo em JavaScript ou PHP?

Porque ele foi tratado como um inteiro de 32 bits com sinal. O operador << do JavaScript retorna resultados com sinal, então 192.168.1.1 montado com deslocamentos dá -1062731519; acrescente >>> 0 para obter 3232235777. O ip2long do PHP se comporta igual em builds de 32 bits, onde sprintf('%u', …) imprime o valor sem sinal. Só os endereços a partir de 128.0.0.0 são afetados, e é por isso que o bug muitas vezes passa despercebido.

Um endereço IPv6 pode ser convertido para decimal?

Sim. Um endereço IPv6 é um número de 128 bits, então 2001:db8::1 é 42540766411282592856903984951653826561, e o maior valor tem 39 dígitos. Os números comuns do JavaScript perdem precisão além de 2^53, então as ferramentas precisam usar BigInt, e alguns conversores online erram os últimos dígitos. O int(ipaddress.ip_address('2001:db8::1')) do Python dá o valor exato.

http://0x7f000001/ é o mesmo que 127.0.0.1?

Sim. Os navegadores e muitas ferramentas de linha de comando leem um host de dígitos hex depois de 0x como um único número de 32 bits, então 0x7f000001, 2130706433, 0x7f.1 e 127.1 significam todos 127.0.0.1, o endereço de loopback. É por isso que filtros de segurança precisam comparar o valor numérico, e não o texto, como recomendam a RFC 3986 e a cheat sheet de SSRF da OWASP.

Sentiu falta de algo?Sugira um recurso ou uma nova ferramenta

Ferramentas relacionadas