Convertidor IPv4-Mapeada IPv6

El Convertidor de IPv4-Mapped IPv6 traduce direcciones IPv4 hacia y desde el formato IPv6 mapeado con prefijo ::ffff: utilizado por sockets dual-stack. Ingresa 192.168.1.1 para obtener ::ffff:192.168.1.1 (notación con puntos) y ::ffff:c0a8:0101 (notación hexadecimal), o pega una dirección IPv6 mapeada para extraer la dirección IPv4 original.

Entendiendo las direcciones IPv4-Mapped IPv6

Si alguna vez has revisado los logs de aplicación de un servidor Node.js, un servicio Go o una aplicación web Python y has visto direcciones de cliente como ::ffff:10.0.0.5 en lugar del simple 10.0.0.5 que esperabas, te has encontrado con direcciones IPv4-mapped IPv6. Este formato no es un error -- es la forma en que el sistema operativo representa conexiones IPv4 para aplicaciones que escuchan en sockets IPv6.

Los sistemas operativos modernos crean sockets dual-stack por defecto. Cuando un servidor se vincula a una dirección IPv6 (o a ::, que significa todas las interfaces), puede aceptar conexiones tanto IPv6 como IPv4 en el mismo puerto. Cuando un cliente IPv4 se conecta, el kernel necesita una forma de representar esa dirección IPv4 dentro del espacio de direcciones IPv6 de 128 bits. Lo hace anteponiendo ::ffff: a la dirección IPv4, produciendo un valor de 128 bits donde los primeros 80 bits son cero, los siguientes 16 bits son todos unos (ffff) y los últimos 32 bits contienen la dirección IPv4 original. Este formato mapeado permite que la aplicación maneje todas las conexiones usando un único tipo de dirección IPv6.

Para desarrolladores y administradores de sistemas, el desafío práctico es que estas direcciones mapeadas aparecen en todas partes: en logs de acceso, cadenas de conexión a bases de datos, alertas de seguridad y tablas de limitación de velocidad. Si tu pipeline de análisis de logs no tiene en cuenta el prefijo ::ffff:, terminas con entradas separadas para el mismo cliente, búsquedas de geolocalización fallidas y listas de permitidos que no coinciden. Este convertidor maneja ambas direcciones -- IPv4 a mapeada y mapeada a IPv4 -- para que puedas traducir rápidamente entre formatos al depurar o construir lógica de procesamiento de direcciones.

Cómo convertir entre IPv4 e IPv4-Mapped IPv6

1. Ingresa una dirección IPv4 (por ejemplo, 192.168.1.1) para generar su equivalente IPv4-mapped IPv6
2. O ingresa una dirección IPv4-mapped IPv6 (por ejemplo, ::ffff:192.168.1.1) para extraer la dirección IPv4 original
3. Visualiza tanto la forma mapeada con decimal con puntos (::ffff:192.168.1.1) como la forma hexadecimal pura (::ffff:c0a8:0101)
4. La herramienta valida el prefijo ::ffff:0:0/96 y rechaza entradas malformadas

Ejemplos de conversión IPv4-Mapped IPv6

Formato mapeado vs. compatible

Cuándo usar el convertidor IPv4-Mapped IPv6

• Interpretar logs de aplicación -- las aplicaciones Node.js, Go, Python y Java que escuchan en sockets IPv6 registran conexiones de clientes IPv4 como ::ffff:10.0.0.5, y necesitas extraer la dirección IPv4 real
• Configurar servicios dual-stack -- traducir listas de permitidos IPv4 al formato IPv6 mapeado para servicios que solo aceptan sintaxis de direcciones IPv6
• Depurar APIs de sockets -- entender por qué getpeername() en un socket IPv6 devuelve direcciones con prefijo ::ffff: para conexiones IPv4
• Traducir reglas de firewall -- convertir reglas IPv4 a sus equivalentes IPv6 en configuraciones de firewall dual-stack
• Respuesta a incidentes -- extraer rápidamente direcciones IPv4 de entradas en formato mapeado en logs de seguridad
• Normalización de pipelines de logs -- eliminar el prefijo ::ffff: para unificar direcciones IPv4 en fuentes de logs que usan diferentes formatos

Cómo funcionan las direcciones IPv4-Mapped IPv6

Las direcciones IPv4-mapped IPv6 permiten que sockets exclusivamente IPv6 manejen tráfico IPv4 de manera transparente. El kernel del sistema operativo mapea las conexiones IPv4 entrantes al espacio de direcciones IPv6 usando un formato bien definido.

Estructura de la dirección

La dirección mapeada de 128 bits consta de tres partes:

|    80 bits de ceros      | 16 bits |    32 bits     |
|  0000...0000             |  ffff   |  dirección IPv4|
                           |         |                |
::                          ffff:     192.168.1.1

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

Los primeros 80 bits son cero. Los siguientes 16 bits son todos unos (ffff). Los últimos 32 bits contienen la dirección IPv4. Esto se encuentra dentro del prefijo ::ffff:0:0/96.

Comportamiento del socket dual-stack

Cuando una aplicación crea un socket IPv6 con dual-stack habilitado (el valor predeterminado en la mayoría de los sistemas operativos), las conexiones IPv4 se presentan automáticamente en formato mapeado:

Cliente IPv4 10.0.0.5 se conecta al servidor puerto 8080
  -> El socket IPv6 del servidor ve: ::ffff:10.0.0.5

Cliente IPv6 2001:db8::1 se conecta al servidor puerto 8080
  -> El socket IPv6 del servidor ve: 2001:db8::1

Esto significa que el código de la aplicación solo necesita manejar direcciones IPv6, y el formato mapeado distingue a los clientes IPv4 de los clientes IPv6 nativos.

Contextos comunes de programación

La mayoría de los lenguajes modernos exponen direcciones IPv4-mapped en sus APIs de red:

• Node.js -- socket.remoteAddress devuelve ::ffff:192.168.1.1 para conexiones IPv4
• Python -- socket.getpeername() en un socket dual-stack devuelve formato mapeado
• Go -- net.Conn.RemoteAddr() devuelve la forma mapeada; usa net.IP.To4() para extraer la porción IPv4
• Java -- InetAddress.getByName() puede analizar formato mapeado; Inet6Address.isIPv4MappedIPv6Address() lo detecta

Diferencias entre plataformas

No todos los sistemas operativos manejan los sockets dual-stack de forma idéntica. En Linux, dual-stack está habilitado por defecto (la opción de socket IPV6_V6ONLY es 0). En Windows, también está habilitado por defecto a partir de Vista. En OpenBSD, los sockets dual-stack están deshabilitados por razones de seguridad, requiriendo sockets IPv4 e IPv6 separados. Conocer el comportamiento de tu plataforma es esencial al depurar problemas con direcciones mapeadas.

Consejos prácticos para manejar direcciones mapeadas

Lo más importante para manejar correctamente las direcciones mapeadas es tu pipeline de procesamiento de logs. Si tienes un servidor web que registra ::ffff:10.0.0.5 y un proxy reverso que registra 10.0.0.5 para el mismo cliente, tus análisis los contarán como dos visitantes diferentes. Normaliza temprano: elimina el prefijo ::ffff: lo más cerca posible del punto de ingesta, para que los sistemas posteriores trabajen con representaciones IPv4 consistentes. La mayoría de las herramientas de procesamiento de logs y plataformas SIEM tienen funciones integradas para esto, pero necesitas habilitarlas explícitamente.

El segundo problema común son las listas de permitidos y bloqueados. Si tu aplicación verifica las direcciones entrantes contra una lista de permitidos IPv4 como 10.0.0.0/24, pero el socket presenta la dirección como ::ffff:10.0.0.5, la comparación de cadenas falla. Tu lógica de coincidencia de direcciones necesita manejar ambos formatos. En la mayoría de los lenguajes, la biblioteca estándar proporciona un método para detectar y extraer la porción IPv4 de una dirección mapeada: Go tiene net.IP.To4(), Python tiene ipaddress.IPv6Address.ipv4_mapped, y los desarrolladores de Node.js a menudo verifican el prefijo ::ffff: y lo eliminan.

Un problema más sutil surge con las bases de datos de geolocalización y reputación. La mayoría de los servicios de geolocalización de IP esperan entrada en IPv4 plano. Enviar ::ffff:10.0.0.5 a una API de geolocalización no devolverá ningún resultado o generará un error. Siempre extrae la dirección IPv4 del formato mapeado antes de hacer consultas externas. De manera similar, los feeds de inteligencia de amenazas usan direcciones IPv4 planas, así que tu lógica de correlación necesita normalizar las direcciones mapeadas antes de la comparación.

Preguntas frecuentes

¿Por qué mi servidor Node.js registra direcciones IPv4 como ::ffff:127.0.0.1?

Node.js escucha en un socket IPv6 dual-stack por defecto. Cuando un cliente IPv4 se conecta, el kernel del sistema operativo mapea la dirección IPv4 al formato IPv6 usando el prefijo ::ffff:. La dirección ::ffff:127.0.0.1 es simplemente 127.0.0.1 presentada en notación IPv6-mapped. Elimina el prefijo ::ffff: para obtener la dirección IPv4 original.

¿Cuál es la diferencia entre direcciones IPv4-mapped e IPv4-compatible?

Las direcciones IPv4-mapped usan ::ffff: como prefijo (por ejemplo, ::ffff:192.168.1.1) y son el estándar actual para representar direcciones IPv4 en sockets IPv6. Las direcciones IPv4-compatible usan solo :: como prefijo (por ejemplo, ::192.168.1.1) y fueron un mecanismo de transición temprano que ha sido obsoleto por RFC 4291 desde 2006.

¿Puedo hacer ping a una dirección IPv4-mapped IPv6?

En la mayoría de los sistemas, ping6 ::ffff:192.168.1.1 no funcionará como se espera porque el manejo de ICMP para direcciones mapeadas varía según el sistema operativo. El formato mapeado se usa principalmente de manera interna por los sockets dual-stack y no está destinado para uso directo en comandos o tablas de enrutamiento.

¿Cómo deshabilito los sockets dual-stack si no quiero direcciones mapeadas?

Establece la opción de socket IPV6_V6ONLY en 1 antes de vincular. Esto fuerza al socket a aceptar solo conexiones IPv6. Luego necesitarás un socket IPv4 separado para manejar clientes IPv4. Este enfoque se usa en OpenBSD por defecto y se prefiere en algunos entornos sensibles a la seguridad.

¿La dirección mapeada preserva la clasificación privada/pública de la dirección IPv4 original?

Sí. El mapeo es puramente un cambio de representación. ::ffff:10.0.0.1 sigue siendo una dirección privada, y ::ffff:8.8.8.8 sigue siendo pública. La clasificación privada/pública depende enteramente de la dirección IPv4 embebida. Usa el Detector de IPv4 privada/pública después de extraer la porción IPv4 para confirmar la clasificación.

Herramientas relacionadas

• Constructor/Parser de direcciones 6to4 - Construye o analiza direcciones de túnel 6to4
• Detector de familia de direcciones - Detecta si una dirección es IPv4, IPv6 o inválida
• Detector de IPv4 privada/pública - Detecta si una IPv4 es privada, pública o especial
• IPv6 Expandir ↔ Comprimir - Convierte entre notación IPv6 expandida y comprimida
• Convertidor IPv4 ↔ Hex - Convierte direcciones IPv4 a/desde hexadecimal
• Normalizar listas mixtas - Ordena y limpia listas mixtas de direcciones IPv4/IPv6