Conceptos Fundamentales de Redes

El tráfico de datos en internet atraviesa una compleja topología de routers y switches antes de alcanzar su destino. La utilidad traceroute es una herramienta de diagnóstico esencial que permite mapear la ruta exacta que siguen los paquetes desde el origen hasta el host objetivo. Para comprender su funcionamiento interno, es necesario dominar tres pilares de la suite de protocolos TCP/IP:

• Protocolo IP: Es la base de la capa de red. Encapsula los datos de las capas superiores (TCP, UDP, ICMP) en datagramas y se encarga del enrutamiento a través de diferentes redes.
• ICMP (Internet Control Message Protocol): Utilizado principalmente para reportar errores y transmitir mensajes de control operativo entre dispositivos de red. Sus mensajes viajan encapsulados dentro de paquetes IP.
• TTL (Time-To-Live): Un campo en la cabecera IP que actúa como un contador de saltos. Cada router que procesa el paquete decrementa este valor en uno. Si el TTL llega a cero, el router descarta el paquete y genera un mensaje ICMP de "Tiempo excedido" (Time Exceeded) hacia el emisor original.

Mecanismos de Rastreo: UDP vs ICMP

Existen dos enfoques principales para implementar la lógica de rastreo de rutas, cada uno con sus propias ventajas y limitaciones dependiendo de las políticas de seguridad de la red.

Enfoque Basado en UDP

En esta variante, el cliente envía datagramas UDP hacia puertos de destino inusuales (generalmente por encima del 30000). El proceso se desarrolla de la siguiente manera:

Al ejecutar el comando nativo en sistemas UNIX y analizar el tráfico con herramientas como Wireshark, se observa este comportamiento:

Para evadir las restricciones de firewalls que filtran UDP, se utiliza el protocolo ICMP directamente, enviando peticiones de eco (Echo Request). Este es el método empleado por la utilidad tracert en Windows.

Implementación Técnica del Enfoque ICMP

Desarrolllar una solución de rastreo ICMP desde cero requiere la construcción manual de las cabeceras de red y el parseo de las respuestas a nivel de byte.

Construcción del Paquete ICMP

La cabecera ICMP tiene una estructura fija que debe ser poblada correctamente antes de la transmisión.

typedef struct {
    uint8_t  msg_type;
    uint8_t  msg_code;
    uint16_t checksum;
    uint16_t proc_id;
    uint16_t seq_num;
} IcmpHeader;

enum IcmpMsgType {
    ICMP_ECHO_REPLY    = 0,
    ICMP_ECHO_REQUEST  = 8,
    ICMP_TIME_EXCEEDED = 11
};

El campo checksum es vital para la integridad del paquete y se calcula utilizando el algoritmo de suma de complementos a uno sobre la cabecera y los datos, una operación que suele encapsularse en funciones auxiliares de red.

Extracción y Análisis de la Respuesta IPv4

Al recibir una respuesta, el sistema operativo entrega el datagrama completo, incluyendo la cabecera IP. Es necesario aislar el payload ICMP.

typedef struct {
    uint8_t  ver_ihl;
    uint8_t  tos;
    uint16_t tot_len;
    uint16_t id;
    uint16_t frag_off;
    uint8_t  ttl;
    uint8_t  protocol;
    uint16_t check;
    uint32_t saddr;
    uint32_t daddr;
} Ipv4Header;

IcmpHeader* extract_icmp_payload(const uint8_t* raw_buffer, size_t buffer_len) {
    if (buffer_len < sizeof(Ipv4Header) + sizeof(IcmpHeader)) {
        return NULL;
    }
    
    const Ipv4Header* ip_hdr = (const Ipv4Header*)raw_buffer;
    
    // Validar versión IPv4 y protocolo ICMP
    if ((ip_hdr->ver_ihl >> 4) != 4 || ip_hdr->protocol != 1) {
        return NULL;
    }
    
    // Calcular longitud real de la cabecera IP (IHL * 4 bytes)
    size_t ip_hdr_len = (ip_hdr->ver_ihl & 0x0F) * 4;
    if (buffer_len < ip_hdr_len + sizeof(IcmpHeader)) {
        return NULL;
    }
    
    // Retornar puntero al inicio de la cabecera ICMP
    return (IcmpHeader*)(raw_buffer + ip_hdr_len);
}

Lógica Principal y Gestión de Sockets

El núcleo del algoritmo consiste en un bucle que incrementa el TTL y gestiona la comunicación mediante sockets. En entornos como iOS, donde los sockets crudos (SOCK_RAW) están restringidos por el sandbox, es posible utilizar SOCK_DGRAM combinado con IPPROTO_ICMP para lograr el mismo resultado.

int sock_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_ICMP);
int max_hops = 30;

for (int current_ttl = 1; current_ttl <= max_hops; ++current_ttl) {
    // Configurar el TTL para el salto actual
    setsockopt(sock_fd, IPPROTO_IP, IP_TTL, &current_ttl, sizeof(current_ttl));
    
    // Enviar múltiples sondas por salto para calcular promedios de latencia
    for (int probe = 0; probe < 3; ++probe) {
        IcmpHeader request_pkt = build_echo_request(current_ttl, probe);
        sendto(sock_fd, &request_pkt, sizeof(request_pkt), 0, ...);
        
        uint8_t recv_buffer[1024];
        ssize_t recv_len = recvfrom(sock_fd, recv_buffer, sizeof(recv_buffer), 0, ...);
        
        if (recv_len > 0) {
            IcmpHeader* icmp_resp = extract_icmp_payload(recv_buffer, recv_len);
            if (icmp_resp) {
                // Evaluar si es Time Exceeded (continuar) o Echo Reply (fin)
                analyze_response(icmp_resp);
            }
        }
    }
}

Una particularidad técnica al usar SOCK_DGRAM con IPPROTO_ICMP es la discrepancia en los datos recibidos entre familias de protocolos: los sockets IPv4 devuelven el paquete con la cabecera IP original intacta, mientras que los sockets IPv6 entregan el payload ICMP directamente sin la cabecera IP, lo cual requiere lógica de parseo condicional en el código final.