IPv4 Options

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// Router logic for checking if recording is possible
bool can_record_route(uint8_t *option) {
    uint8_t length = option[1];
    uint8_t pointer = option[2];
    
    // Check if pointer points beyond the option
    // We need 4 bytes for an IP address
    if (pointer + 3 > length) {
        // No room to record - option is full
        return false;
    }
    
    // Pointer should be at least 4 (first valid slot)
    if (pointer < 4) {
        // Invalid pointer - corrupted option
        return false;
    }
    
    return true;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

#include <stdint.h>
#include <stdbool.h>
#include <string.h>
 
typedef struct {
    uint32_t src_ip;
    uint32_t dst_ip;
    // ... other fields
    uint8_t options[40];
    uint8_t options_len;
} IPv4Packet;
 
typedef struct {
    uint32_t ip;
    // ... other interface info
} NetworkInterface;
 
/**
 * Process Record Route option on a router
 * 
 * @param packet      The IPv4 packet being forwarded
 * @param egress_if   The outgoing interface
 * @return true if option was modified, false otherwise
 */
bool process_record_route(IPv4Packet *packet, NetworkInterface *egress_if) {
    // Find Record Route option in options area
    int offset = 0;
    while (offset < packet->options_len) {
        uint8_t type = packet->options[offset];
        
        if (type == 0) break;       // EOL
        if (type == 1) {            // NOP
            offset++;
            continue;
        }
        
        if (type == 7) {            // Record Route found
            uint8_t length = packet->options[offset + 1];
            uint8_t pointer = packet->options[offset + 2];
            
            // Check if there's room (need 4 bytes for IP)
            if (pointer + 3 > length) {
                // No room - option is full
                return false;
            }
            
            // Validate pointer (must be >= 4)
            if (pointer < 4) {
                // Malformed option - could drop packet or continue
                return false;
            }
            
            // Record our egress interface IP
            // Pointer is 1-indexed from start of option
            int data_offset = offset + pointer - 1;  // Convert to 0-indexed
            
            // Write IP address in network byte order
            uint32_t ip_network_order = htonl(egress_if->ip);
            memcpy(&packet->options[data_offset], &ip_network_order, 4);
            
            // Advance pointer
            packet->options[offset + 2] = pointer + 4;
            
            return true;
        }
        
        // Multi-byte option - skip by length
        uint8_t length = packet->options[offset + 1];
        offset += length;
    }
    
    return false;  // No Record Route option found
}

Initial packet from Host A:
══════════════════════════════════════════════════════════════
Offset:    0     1     2     3     4     5     6     7
         +-----+-----+-----+-----+-----+-----+-----+-----+
         |  7  |  19 |  4  |  0  |  0  |  0  |  0  |  ...
         +-----+-----+-----+-----+-----+-----+-----+-----+
         Type  Len   Ptr   ----Slot 1 (empty)----
 
After R1 (egress 10.0.1.1 = 0x0A000101):
══════════════════════════════════════════════════════════════
         +-----+-----+-----+-----+-----+-----+-----+-----+
         |  7  |  19 |  8  |  10 |  0  |  1  |  1  |  ...
         +-----+-----+-----+-----+-----+-----+-----+-----+
         Type  Len   Ptr   ----10.0.1.1 recorded----
                     ↑
                     Advanced from 4 to 8
 
After R2 (egress 10.0.2.1 = 0x0A000201):
══════════════════════════════════════════════════════════════
         +-----+-----+-----+-----+-----+-----+-----+-----+
         |  7  |  19 | 12  |  10 |  0  |  1  |  1  |  10 | ...
         +-----+-----+-----+-----+-----+-----+-----+-----+
         Type  Len   Ptr   ----10.0.1.1----  --10.0.2.1--
                     ↑
                     Advanced from 8 to 12
 
After R3 (egress 10.0.3.1 = 0x0A000301):
══════════════════════════════════════════════════════════════
Pointer = 16 (next slot after 3 addresses)
Recorded: [10.0.1.1, 10.0.2.1, 10.0.3.1]
 
Host B receives packet with complete route trace!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

import struct
from typing import List, Optional
from dataclasses import dataclass
 
@dataclass
class RecordRouteInfo:
    """Parsed Record Route option information"""
    length: int
    pointer: int
    addresses: List[str]
    is_full: bool
    addresses_recorded: int
    max_addresses: int
 
def parse_record_route(option_bytes: bytes) -> Optional[RecordRouteInfo]:
    """
    Parse a Record Route option from raw bytes.
    
    Args:
        option_bytes: Raw bytes of the Record Route option
    
    Returns:
        RecordRouteInfo object or None if invalid
    """
    if len(option_bytes) < 3:
        return None
    
    opt_type = option_bytes[0]
    if opt_type != 7:
        return None  # Not Record Route
    
    length = option_bytes[1]
    pointer = option_bytes[2]
    
    # Validate length
    if length < 3 or length > 40:
        return None
    
    # Calculate addresses
    data_length = length - 3
    max_addresses = data_length // 4
    
    # Determine how many addresses are recorded
    # Pointer starts at 4, advances by 4 for each address
    if pointer < 4:
        addresses_recorded = 0
    else:
        addresses_recorded = (pointer - 4) // 4
    
    # Ensure we don't read beyond recorded data
    addresses_recorded = min(addresses_recorded, max_addresses)
    
    # Extract addresses
    addresses = []
    for i in range(addresses_recorded):
        offset = 3 + (i * 4)
        if offset + 4 <= len(option_bytes):
            ip_bytes = option_bytes[offset:offset + 4]
            ip = ".".join(str(b) for b in ip_bytes)
            addresses.append(ip)
    
    return RecordRouteInfo(
        length=length,
        pointer=pointer,
        addresses=addresses,
        is_full=(pointer > length),
        addresses_recorded=addresses_recorded,
        max_addresses=max_addresses
    )
 
# Example usage
option_data = bytes([
    7,    # Type: Record Route
    19,   # Length: 19 bytes (space for 4 addresses)
    16,   # Pointer: 16 (3 addresses recorded)
    10, 0, 1, 1,    # 10.0.1.1
    10, 0, 2, 1,    # 10.0.2.1
    10, 0, 3, 1,    # 10.0.3.1
    0, 0, 0, 0      # Empty slot
])
 
info = parse_record_route(option_data)
print(f"Addresses recorded: {info.addresses_recorded}")
print(f"Route: {' -> '.join(info.addresses)}")
print(f"Option full: {info.is_full}")
 
# Output:
# Addresses recorded: 3
# Route: 10.0.1.1 -> 10.0.2.1 -> 10.0.3.1
# Option full: False

# Linux example
$ ping -R -c 1 8.8.8.8
PING 8.8.8.8 (8.8.8.8) 56(124) bytes of data.
64 bytes from 8.8.8.8: icmp_seq=1 ttl=57 time=15.2 ms
RR:     192.168.1.1
        10.0.0.1
        172.16.50.1
        [partially recorded - option filled]
 
# Windows example
> ping -r 9 8.8.8.8
 
Pinging 8.8.8.8 with 32 bytes of data:
Reply from 8.8.8.8: bytes=32 time=16ms TTL=57
    Route: 192.168.1.1 ->
           10.0.0.1 ->
           172.16.50.1 ->
           [recording stopped - 9 hop maximum]
 
# Note: Many ISPs and cloud providers block or ignore
# Record Route, so you may not see intermediate hops