UDP Header (8 bytes) with Checksum Field Highlighted
═══════════════════════════════════════════════════════════════════
 
 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤
│         Source Port           │       Destination Port        │
├───────────────────────────────┼───────────────────────────────┤
│            Length             │███████ CHECKSUM █████████████│
│          (16 bits)            │       (16 bits)               │
│          Bytes 4-5            │  Bytes 6-7, Bits 48-63        │
└───────────────────────────────┴───────────────────────────────┘
                                            ▲
                                            │
                                    Final header field
                                    
Checksum Field Details:
───────────────────────────────────────────────────────────────────
• Offset: 48 bits (6 bytes) from start of UDP header
• Size: 16 bits (2 bytes)
• Byte order: Network byte order (big-endian)
• Special value: 0x0000 = Checksum not computed (IPv4 only)
• Calculation: One's complement of one's complement sum

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

"""
One's Complement Checksum Implementation
 
This module provides a complete, educational implementation of
the one's complement checksum algorithm used by UDP, TCP, and IP.
"""
 
import struct
from typing import Union
 
def ones_complement_sum(data: bytes) -> int:
    """
    Compute the one's complement sum of data.
    
    This is the core algorithm used by UDP, TCP, and IP checksums.
    
    Args:
        data: Bytes to sum (padded with zero if odd length)
    
    Returns:
        16-bit one's complement sum (before final complement)
    """
    # Pad with zero byte if odd length
    if len(data) % 2:
        data = data + b'\x00'
    
    # Sum all 16-bit words
    total = 0
    for i in range(0, len(data), 2):
        word = (data[i] << 8) + data[i + 1]  # Big-endian
        total += word
    
    # Fold 32-bit sum to 16 bits (handle carries)
    # This is the "end-around carry"
    while total > 0xFFFF:
        total = (total & 0xFFFF) + (total >> 16)
    
    return total
 
def compute_checksum(data: bytes) -> int:
    """
    Compute the one's complement checksum.
    
    Args:
        data: Data to checksum (pseudo-header + UDP header + payload)
    
    Returns:
        16-bit checksum value
    """
    s = ones_complement_sum(data)
    # Take one's complement (bitwise NOT, keeping 16 bits)
    checksum = ~s & 0xFFFF
    
    # Special case: if checksum is 0, use 0xFFFF instead
    # (to distinguish from "checksum not used")
    if checksum == 0:
        checksum = 0xFFFF
    
    return checksum
 
def verify_checksum(data: bytes) -> bool:
    """
    Verify a received datagram's checksum.
    
    Args:
        data: Complete data including existing checksum
    
    Returns:
        True if checksum is valid, False otherwise
    """
    s = ones_complement_sum(data)
    # If valid, result should be all ones (0xFFFF)
    return s == 0xFFFF
 
def demonstrate_algorithm():
    """Step-by-step demonstration of the algorithm."""
    
    print("=== One's Complement Checksum Demonstration ===
")
    
    # Example data
    test_data = bytes([0x00, 0x01, 0xf2, 0x03, 0xf4, 0xf5, 0xf6, 0xf7])
    
    print(f"Input data (hex): {test_data.hex()}")
    print(f"Input length: {len(test_data)} bytes
")
    
    # Step 1: Split into 16-bit words
    words = []
    for i in range(0, len(test_data), 2):
        word = (test_data[i] << 8) + test_data[i + 1]
        words.append(word)
        print(f"Word {i//2}: 0x{word:04x} ({word})")
    
    # Step 2: Sum the words
    print(f"
Summing words:")
    total = 0
    for i, word in enumerate(words):
        total += word
        print(f"  After word {i}: 0x{total:05x} ({total})")
    
    # Step 3: Fold carries
    print(f"
Folding carries:")
    while total > 0xFFFF:
        carry = total >> 16
        lower = total & 0xFFFF
        total = lower + carry
        print(f"  {lower:#06x} + {carry:#06x} = {total:#06x}")
    
    # Step 4: One's complement
    checksum = ~total & 0xFFFF
    print(f"
One's complement of {total:#06x}: {checksum:#06x}")
    
    # Verification
    print(f"
=== Verification ===")
    data_with_checksum = test_data + struct.pack("!H", checksum)
    print(f"Data with checksum: {data_with_checksum.hex()}")
    
    verification_sum = ones_complement_sum(data_with_checksum)
    print(f"Verification sum: {verification_sum:#06x}")
    print(f"Valid: {verification_sum == 0xFFFF}")
 
if __name__ == "__main__":
    demonstrate_algorithm()

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173

"""
Pseudo-Header Construction for UDP Checksum
 
Demonstrates building the pseudo-header for both IPv4 and IPv6.
"""
 
import struct
import socket
from dataclasses import dataclass
 
@dataclass
class IPv4PseudoHeader:
    """
    IPv4 pseudo-header for UDP checksum calculation.
    
    Structure (12 bytes):
    - Source IP (4 bytes)
    - Destination IP (4 bytes)
    - Zero (1 byte)
    - Protocol (1 byte) = 17 for UDP
    - UDP Length (2 bytes)
    """
    source_ip: str
    dest_ip: str
    udp_length: int
    protocol: int = 17  # UDP protocol number
    
    def to_bytes(self) -> bytes:
        """Construct pseudo-header bytes."""
        src = socket.inet_aton(self.source_ip)  # 4 bytes
        dst = socket.inet_aton(self.dest_ip)    # 4 bytes
        
        return struct.pack(
            "!4s4sBBH",
            src,               # Source IP
            dst,               # Destination IP
            0,                 # Zero padding
            self.protocol,     # Protocol (17 = UDP)
            self.udp_length    # UDP length
        )
 
@dataclass
class IPv6PseudoHeader:
    """
    IPv6 pseudo-header for UDP checksum calculation.
    
    Structure (40 bytes):
    - Source IP (16 bytes)
    - Destination IP (16 bytes)
    - UDP Length (4 bytes) - note: 32-bit in IPv6!
    - Zero (3 bytes)
    - Next Header (1 byte) = 17 for UDP
    """
    source_ip: str
    dest_ip: str
    udp_length: int
    next_header: int = 17  # UDP
    
    def to_bytes(self) -> bytes:
        """Construct pseudo-header bytes."""
        src = socket.inet_pton(socket.AF_INET6, self.source_ip)
        dst = socket.inet_pton(socket.AF_INET6, self.dest_ip)
        
        return struct.pack(
            "!16s16sIBBBB",
            src,                # Source IP (16 bytes)
            dst,                # Destination IP (16 bytes)
            self.udp_length,    # UDP length (4 bytes)
            0, 0, 0,            # Zero padding (3 bytes)
            self.next_header    # Next header (1 byte)
        )
 
def build_checksum_input(
    source_ip: str,
    dest_ip: str,
    source_port: int,
    dest_port: int,
    payload: bytes,
    ip_version: int = 4
) -> bytes:
    """
    Build complete data for checksum calculation.
    
    Returns pseudo-header + UDP header + payload (checksum field zeroed)
    """
    udp_length = 8 + len(payload)
    
    # Build pseudo-header
    if ip_version == 4:
        pseudo = IPv4PseudoHeader(source_ip, dest_ip, udp_length)
    else:
        pseudo = IPv6PseudoHeader(source_ip, dest_ip, udp_length)
    
    # Build UDP header (checksum field = 0 for calculation)
    udp_header = struct.pack(
        "!HHHH",
        source_port,
        dest_port,
        udp_length,
        0  # Checksum = 0 during calculation
    )
    
    # Combine and pad if necessary
    data = pseudo.to_bytes() + udp_header + payload
    if len(data) % 2:
        data += b'\x00'  # Pad to even length
    
    return data
 
# Complete checksum calculation example
def calculate_udp_checksum(
    source_ip: str,
    dest_ip: str,
    source_port: int,
    dest_port: int,
    payload: bytes,
    ip_version: int = 4
) -> int:
    """
    Calculate complete UDP checksum.
    
    Returns the 16-bit checksum value.
    """
    data = build_checksum_input(
        source_ip, dest_ip,
        source_port, dest_port,
        payload, ip_version
    )
    
    # Compute one's complement sum
    s = 0
    for i in range(0, len(data), 2):
        word = (data[i] << 8) + data[i + 1]
        s += word
    
    while s > 0xFFFF:
        s = (s & 0xFFFF) + (s >> 16)
    
    checksum = ~s & 0xFFFF
    
    # Convert 0 to 0xFFFF
    return checksum if checksum != 0 else 0xFFFF
 
# Demonstration
if __name__ == "__main__":
    # Example: DNS query
    source_ip = "192.168.1.100"
    dest_ip = "8.8.8.8"
    source_port = 52437
    dest_port = 53
    
    # Sample DNS query payload
    dns_payload = bytes([
        0x12, 0x34,  # Transaction ID
        0x01, 0x00,  # Flags
        0x00, 0x01,  # Questions
        0x00, 0x00,  # Answers
        0x00, 0x00,  # Authority
        0x00, 0x00,  # Additional
    ])
    
    checksum = calculate_udp_checksum(
        source_ip, dest_ip,
        source_port, dest_port,
        dns_payload
    )
    
    print(f"=== UDP Checksum Calculation ===")
    print(f"Source: {source_ip}:{source_port}")
    print(f"Destination: {dest_ip}:{dest_port}")
    print(f"Payload length: {len(dns_payload)} bytes")
    print(f"UDP length: {8 + len(dns_payload)} bytes")
    print(f"Calculated checksum: 0x{checksum:04x}")

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

#!/bin/bash
# Check and configure checksum offload settings (Linux)
 
# View current offload settings
ethtool -k eth0 | grep checksum
 
# Typical output:
# rx-checksumming: on
# tx-checksumming: on
#     tx-checksum-ipv4: off [fixed]
#     tx-checksum-ip-generic: on
#     tx-checksum-ipv6: off [fixed]
# tx-checksum-fcoe-crc: off [fixed]
# tx-checksum-sctp: off [fixed]
 
# Disable TX offload (for debugging/packet capture)
# WARNING: Increases CPU usage, use only for testing
# sudo ethtool -K eth0 tx off
 
# Re-enable (recommended for normal operation)
# sudo ethtool -K eth0 tx on
 
# View UDP-specific settings
ethtool -S eth0 | grep -i udp
 
# Check for checksum errors reported by NIC
ethtool -S eth0 | grep -i "csum"