2130706433 es igual a 127.0.0.1? WTF Parte 2

June 08, 2025 — n4ch0m4n

Les recomiendo leer primero mi anterior artículo WTF

La cuestión es…alguna vez probaste hacer ping 2130706433 y te sorprendiste al ver que funciona igual que ping 127.0.0.1? O quizás viste direcciones como 0x7f000001 en algún log y no tenías ni idea de que significaba?

La respuesta está en algo que la mayoría de las personas a veces desconoce: las direcciones IP no solo existen en el formato decimal con puntitos que todos conocemos.

Resulta que las direcciones IP pueden representarse en múltiples formatos locos, y tu sistema operativo claro, las entiende (o debería hacerlo :P )

Obvio esto no es magic, es simplemente cómo funciona la conversión interna de direcciones, te suena del artículo anterior?

Probemos no usar los puntos

Cuando pensamos en direcciones IP, automáticamente pensamos en el formato 192.168.1.1. Pero internamente se manejan las direcciones IP como números de 32 bits. Estos pueden representarse de diferentes maneras, y todas son válidas:

Decimal con puntos: 127.0.0.1 (tradicional)
Decimal con menos puntos: 127.1 (tradicional abreviada)
Decimal puro: 2130706433 (número completo)
Hexadecimal: 0x7f000001 (base 16)
Octal: 017700000001 (base 8)

La conversión paso a paso

Tomemos localhost (127.0.0.1) como ejemplo y veamos que onda. Los pasos son:

1: Cada octeto a binario

127 = 01111111
0 = 00000000
0 = 00000000
1 = 00000001

2: Concatenar todo
01111111 00000000 00000000 00000001

3: Convertir a decimal
Este número binario de 32 bits equivale a 2130706433 en decimal

01111111 00000000 00000000 00000001
= (127 × 256³) + (0 × 256²) + (0 × 256¹) + (1 × 256⁰)
= (127 × 16777216) + (0 × 65536) + (0 × 256) + (1 × 1)
= 2130706432 + 0 + 0 + 1
= 2130706433

Seee….es un chino lo sé!

4: Otras representaciones

Hexadecimal: 0x7f000001
Octal: 017700000001

Ejemplos prácticos

Podés probar estos comandos ahora mismo en tu terminal:

# Todas estas resuelen localhost
ping 127.0.0.1
ping 2130706433
ping 0x7f000001
ping 017700000001
# Con los diabólicos dns de google (8.8.8.8)
ping 8.8.8.8
ping 134744072
ping 0x08080808
ping 001010010010
# Direcciones privadas (192.168.1.1)
ping 192.168.1.1
ping 3232235777
ping 0xc0a80101
ping 030052000401

Por que funca esto?

La respuesta está en las funciones que ya mencioné…..recordás inet_aton del artículo anterior? Bueno, esta función no solo maneja las abreviaciones junto con inet_ntoa, sino que también interpreta diferentes bases numéricas!!! Vamo a ver:

#include <stdio.h>
#include <arpa/inet.h>
int main() {
    struct in_addr addr;
    
    // Prueba diferentes formas de localhost
    const char *ips[] = {
        "127.0.0.1",      // Decimal con puntos
        "2130706433",     // Decimal puro
        "0x7f000001",     // Hexadecimal
        "017700000001"    // Octal
    };
    
    for (int i = 0; i < 4; i++) {
        if (inet_aton(ips[i], &addr)) {
            printf("Input: %-12s -> Output: %s\n", 
                   ips[i], inet_ntoa(addr));
        }
    }
    
    return 0;
}

Simplemente ponemos el código anterior en un archivo.c, compilamos y corremos:

$ gcc archivo.c -o archivo.bin
$ chmod +x archivo.bin
$ ./archivo.bin

El resultado será siempre el mismo 127.0.0.1

Casos de uso reales

1. Logs de sistemas
Muchos sistemas de logging guardan las IPs en formato decimal puro para ahorrar espacio:

User login from 3232235777 at 14:30:25

2. Bases de datos
Almacenar IPs como integers de 32 bits es más eficiente, por ejemplo para guardar direcciones ip en una base de datos:

CREATE TABLE connections (
    ip_address INT UNSIGNED,
    timestamp DATETIME
);
INSERT INTO connections VALUES (2130706433, NOW());

3. Configuraciones de red
Algunos archivos de configuración usan representaciones hexadecimales:

allow_from = 0xc0a80000/0xffffff00  # 192.168.0.0/24

Scripts útiles

Conversión manual con Bash:

#!/bin/bash
# Función para convertir IP a decimal
ip_to_decimal() {
    local ip=$1
    local a b c d
    IFS='.' read -r a b c d <<< "$ip"
    echo $((a * 256**3 + b * 256**2 + c * 256 + d))
}
# Función para convertir decimal a IP
decimal_to_ip() {
    local num=$1
    local a=$((num >> 24 & 255))
    local b=$((num >> 16 & 255))
    local c=$((num >> 8 & 255))
    local d=$((num & 255))
    echo "$a.$b.$c.$d"
}
# Ejemplos de uso
echo "127.0.0.1 -> $(ip_to_decimal "127.0.0.1")"    # 2130706433
echo "2130706433 -> $(decimal_to_ip 2130706433)"     # 127.0.0.1

Con comandos de sistema:

# Usando printf para convertir
printf "%d\n" 0x7f000001           # Hex a decimal
printf "0x%08x\n" 2130706433       # Decimal a hex

Aspectos de seguridad

Esto es algo que siempre me gusta encontrarle la vuelta a ver si tiene implicaciones de seguridad. Los filtros mal configurados pueden ser bypasseados usando representaciones alternativas.

Por ejemplo un firewall bloquea 192.168.1.1, pero si hago lo siguiente…lo hará?

curl http://3232235777/admin
curl http://0xc0a80101/admin

Finalizando...

Yo creo que entender estas representaciones no solo amplía tu conocimiento técnico, sino que también te ayuda a debuggear problemas de red, optimizar almacenamiento de datos y comprender mejor cómo funcionan los sistemas internamente…..LO QUE NOS GUSTA A TODOS NOSOTROS O NO??

La próxima vez que veas un número gigante donde esperabas una IP, ya no te sorprenderás. Sabrás que 2130706433 es simplemente otra forma de decir “localhost” o por lo menos sabrás como traducir lo que dice…

Referencias

inet_aton(3) - Linux man pages

inet_ntoa(3) - Conversión de binario a texto

Tags: Redes

GoRiX blog