Conversor IPv4-Mapeado para IPv6

O Conversor IPv4-Mapeado IPv6 traduz endereços IPv4 para e do formato IPv6 mapeado ::ffff: usado por sockets dual-stack. Digite 192.168.1.1 para obter ::ffff:192.168.1.1 (notação com pontos) e ::ffff:c0a8:0101 (notação hexadecimal), ou cole um endereço IPv6 mapeado para extrair o endereço IPv4 original.

Entendendo Endereços IPv6 Mapeados para IPv4

Se você já analisou logs de aplicação de um servidor Node.js, um serviço Go ou uma aplicação web Python e viu endereços de cliente como ::ffff:10.0.0.5 em vez do simples 10.0.0.5 que esperava, você encontrou endereços IPv4-mapeados IPv6. Este formato não é um bug -- é como o sistema operacional representa conexões IPv4 para aplicações que estão escutando em sockets IPv6.

Os sistemas operacionais modernos criam sockets dual-stack por padrão. Quando um servidor se vincula a um endereço IPv6 (ou a ::, que significa todas as interfaces), ele pode aceitar conexões IPv6 e IPv4 na mesma porta. Quando um cliente IPv4 se conecta, o kernel do SO precisa de uma forma de representar esse endereço IPv4 no espaço de endereço IPv6 de 128 bits. Isso é feito antecedendo ::ffff: ao endereço IPv4, produzindo um valor de 128 bits onde os primeiros 80 bits são zero, os próximos 16 bits são todos uns (ffff), e os últimos 32 bits contêm o endereço IPv4 original. Este formato mapeado permite que a aplicação lide com todas as conexões usando um único tipo de endereço IPv6.

Para desenvolvedores e administradores de sistemas, o desafio prático é que esses endereços mapeados aparecem em todos os lugares: em logs de acesso, strings de conexão de banco de dados, alertas de segurança e tabelas de limitação de taxa. Se seu pipeline de análise de logs não levar em conta o prefixo ::ffff:, você acaba com entradas separadas para o mesmo cliente, buscas de geolocalização quebradas e listas de permissão que não conseguem fazer correspondência. Este conversor lida com ambas as direções -- IPv4 para mapeado e mapeado para IPv4 -- para que você possa traduzir rapidamente entre formatos ao depurar ou construir lógica de processamento de endereço.

Como Converter Entre IPv4 e IPv6 Mapeados para IPv4

1. Digite um endereço IPv4 (ex: 192.168.1.1) para gerar seu equivalente IPv6 mapeado para IPv4
2. Ou digite um endereço IPv6 mapeado para IPv4 (ex: ::ffff:192.168.1.1) para extrair o endereço IPv4 original
3. Veja ambas as formas: mapeada em decimal com pontos (::ffff:192.168.1.1) e forma pura em hex (::ffff:c0a8:0101)
4. A ferramenta valida o prefixo ::ffff:0:0/96 e rejeita entradas malformadas

Exemplos de Conversão IPv6 Mapeados para IPv4

Formato Mapeado vs. Compatível

Quando Usar o Conversor IPv4-Mapeado IPv6

• Interpretando logs de aplicação -- Aplicações Node.js, Go, Python e Java escutando em sockets IPv6 registram conexões de clientes IPv4 como ::ffff:10.0.0.5, e você precisa extrair o endereço IPv4 real
• Configurando serviços dual-stack -- traduzir listas de permissão IPv4 no formato IPv6 mapeado para serviços que apenas aceitam sintaxe de endereço IPv6
• Depurando APIs de socket -- entender por que getpeername() em um socket IPv6 retorna endereços com prefixo ::ffff: para conexões IPv4
• Tradução de regras de firewall -- converter regras IPv4 em seus equivalentes IPv6 em configurações de firewall dual-stack
• Resposta a incidentes -- extrair rapidamente endereços IPv4 de entradas em formato mapeado nos logs de segurança
• Normalização de pipeline de logs -- remover o prefixo ::ffff: para unificar endereços IPv4 em diferentes formatos entre fontes de logs

Como Funcionam os Endereços IPv4-Mapeados IPv6

Endereços IPv4-mapeados IPv6 permitem que sockets apenas IPv6 lidem com tráfego IPv4 transparentemente. O kernel do sistema operacional mapeia conexões IPv4 recebidas no espaço de endereço IPv6 usando um formato bem definido.

Estrutura de Endereço

O endereço mapeado de 128 bits consiste em três partes:

|    80 bits de zeros    | 16 bits |    32 bits     |
|  0000...0000           |  ffff   |  Endereço IPv4 |
                         |         |                |
::                        ffff:     192.168.1.1

Forma expandida completa:
0000:0000:0000:0000:0000:ffff:c0a8:0101

Os primeiros 80 bits são zero. Os próximos 16 bits são todos uns (ffff). Os últimos 32 bits contêm o endereço IPv4. Isso fica dentro do prefixo ::ffff:0:0/96.

Comportamento do Socket Dual-Stack

Quando uma aplicação cria um socket IPv6 com dual-stack habilitado (padrão na maioria dos sistemas operacionais), conexões IPv4 são automaticamente apresentadas em formato mapeado:

Cliente IPv4 10.0.0.5 se conecta ao porto 8080 do servidor
  -> Socket IPv6 do servidor vê: ::ffff:10.0.0.5

Cliente IPv6 2001:db8::1 se conecta ao porto 8080 do servidor
  -> Socket IPv6 do servidor vê: 2001:db8::1

Isso significa que o código da aplicação apenas precisa lidar com endereços IPv6, e o formato mapeado distingue clientes IPv4 de clientes IPv6 nativos.

Contextos de Programação Comuns

A maioria das linguagens modernas expõe endereços IPv4-mapeados em suas APIs de rede:

• Node.js -- socket.remoteAddress retorna ::ffff:192.168.1.1 para conexões IPv4
• Python -- socket.getpeername() em um socket dual-stack retorna formato mapeado
• Go -- net.Conn.RemoteAddr() retorna a forma mapeada; use net.IP.To4() para extrair a porção IPv4
• Java -- InetAddress.getByName() pode analisar formato mapeado; Inet6Address.isIPv4MappedIPv6Address() o detecta

Diferenças entre Plataformas

Nem todos os sistemas operacionais lidam com sockets dual-stack de forma idêntica. No Linux, dual-stack é habilitado por padrão (a opção de socket IPV6_V6ONLY é 0). No Windows, também é habilitado por padrão desde o Vista. No OpenBSD, sockets dual-stack estão desabilitados por razões de segurança, exigindo sockets IPv4 e IPv6 separados. Conhecer o comportamento de sua plataforma é essencial ao depurar problemas com endereços mapeados.

Dicas Práticas para Lidar com Endereços Mapeados

O mais importante a acertar com endereços mapeados é seu pipeline de processamento de logs. Se você tem um servidor web registrando ::ffff:10.0.0.5 e um proxy reverso registrando 10.0.0.5 para o mesmo cliente, suas análises contarão como dois visitantes diferentes. Normalize desde o início: remova o prefixo ::ffff: o mais próximo possível do ponto de ingestão, para que sistemas downstream trabalhem com representações IPv4 consistentes. A maioria das ferramentas de processamento de logs e plataformas SIEM possuem funções integradas para isso, mas você precisa habilitá-las explicitamente.

O segundo problema comum é listas de permissão e bloqueio. Se sua aplicação verifica endereços recebidos em relação a uma lista de permissão IPv4 como 10.0.0.0/24, mas o socket apresenta o endereço como ::ffff:10.0.0.5, a comparação de string falha. Sua lógica de correspondência de endereço precisa lidar com ambos os formatos. Na maioria das linguagens, a biblioteca padrão fornece um método para detectar e extrair a porção IPv4 de um endereço mapeado: Go tem net.IP.To4(), Python tem ipaddress.IPv6Address.ipv4_mapped, e desenvolvedores Node.js frequentemente verificam o prefixo ::ffff: e o removem.

Um problema mais sutil surge com geolocalização e bancos de dados de reputação. A maioria dos serviços de geolocalização de IP espera entrada IPv4 simples. Enviar ::ffff:10.0.0.5 para uma API de geolocalização retornará sem resultado ou um erro. Sempre extraia o endereço IPv4 do formato mapeado antes de fazer buscas externas. Da mesma forma, feeds de inteligência de ameaças usam endereços IPv4 simples, então sua lógica de correlação precisa normalizar endereços mapeados antes da comparação.

Perguntas Frequentes

Por que meu servidor Node.js registra endereços IPv4 como ::ffff:127.0.0.1?

Node.js escuta em um socket IPv6 dual-stack por padrão. Quando um cliente IPv4 se conecta, o kernel do SO mapeia o endereço IPv4 no formato IPv6 usando o prefixo ::ffff:. O endereço ::ffff:127.0.0.1 é simplesmente 127.0.0.1 apresentado em notação IPv6-mapeada. Remova o prefixo ::ffff: para obter o endereço IPv4 original.

Qual é a diferença entre endereços IPv4-mapeados e IPv4-compatíveis?

Endereços IPv4-mapeados usam ::ffff: como prefixo (ex: ::ffff:192.168.1.1) e são o padrão atual para representar endereços IPv4 em sockets IPv6. Endereços IPv4-compatíveis usam apenas :: como prefixo (ex: ::192.168.1.1) e eram um mecanismo de transição inicial que foi descontinuado pela RFC 4291 desde 2006.

Posso fazer ping em um endereço IPv6 mapeado para IPv4?

Na maioria dos sistemas, ping6 ::ffff:192.168.1.1 não funcionará como esperado porque o tratamento ICMP de endereços mapeados varia por SO. O formato mapeado é principalmente usado internamente por sockets dual-stack e não é destinado ao uso direto em comandos ou tabelas de roteamento.

Como faço para desabilitar sockets dual-stack se não quiser endereços mapeados?

Defina a opção de socket IPV6_V6ONLY como 1 antes de vincular. Isso força o socket a aceitar apenas conexões IPv6. Você precisará então de um socket IPv4 separado para lidar com clientes IPv4. Esta abordagem é usada no OpenBSD por padrão e é preferida em alguns ambientes sensíveis à segurança.

O endereço mapeado preserva a classificação privada/pública do endereço IPv4 original?

Sim. O mapeamento é puramente uma mudança de representação. ::ffff:10.0.0.1 ainda é um endereço privado, e ::ffff:8.8.8.8 ainda é público. A classificação privada/pública depende inteiramente do endereço IPv4 incorporado. Use o Detector IPv4 Privado/Público após extrair a porção IPv4 para confirmar a classificação.

Ferramentas Relacionadas

• Construtor/Analisador de Endereço 6to4 - Construir ou analisar endereços de túnel 6to4
• Detector de Família de Endereço - Detectar se um endereço é IPv4, IPv6 ou inválido
• Detector IPv4 Privado/Público - Detectar se IPv4 é privado, público ou especial
• IPv6 Expandir ↔ Comprimir - Converter entre notação IPv6 expandida e comprimida
• Conversor IPv4 ↔ Hexadecimal - Converter endereços IPv4 para/de hexadecimal
• Normalizar Listas Mistas - Ordenar e limpar listas mistas de endereços IPv4/IPv6