Simulate Packet Loss When Testing UDP Applications

Testing User Datagram Protocol (UDP) applications requires verifying how the software behaves under degraded network conditions, as UDP does not provide built-in delivery guarantees, retransmission, or packet ordering. This guide outlines the most effective, straight-to-the-point methods to artificially induce packet loss, latency, and jitter across Linux, macOS, Windows, and application-level testing environments.

1. Linux: Traffic Control (`tc`) with NetEm

The Linux kernel contains a built-in network emulation module called Network Emulator (netem), managed via the tc (traffic control) command. It operates at the kernel level and requires root privileges.

Introduce 10% packet loss on an interface:

sudo tc qdisc add dev eth0 root netem loss 10%

Introduce packet loss with a correlation factor (burst loss):
```
sudo tc qdisc change dev eth0 root netem loss 10% 25%
```
(This drops 10% of packets, with each dropped packet having a 25% chance of dropping the next packet).
Remove the rule and restore normal traffic:
```
sudo tc qdisc del dev eth0 root
```

To target only specific UDP traffic, bind netem to a prio or htb class and use iptables or tc filter matching specific UDP ports.

2. Windows: Clumsy

For Windows environments, Clumsy is an open-source utility that uses the WinDivert library to intercept network packets and modify them before they reach the network stack.

Download and run Clumsy as Administrator.
Under Filtering, set the target criteria (e.g., udp and udp.DstPort == 5000 to capture only your application’s traffic).
Check the Drop function and set the drop percentage (e.g., 15.0%).
Click Start to begin dropping packets and Stop to restore normal operation.

Clumsy also supports out-of-order delivery, lag, duplicate packets, and throttle simulation.

3. macOS: Network Link Conditioner and `pfctl`

macOS provides both a native graphical tool and command-line packet filtering.

Option A: Network Link Conditioner (GUI)

Download Additional Tools for Xcode from the Apple Developer portal.
Install Network Link Conditioner from the Hardware folder.
Open the pane in System Settings, choose a preset (e.g., “100% Loss”, “Very Bad Network”) or create a custom profile specifying exact packet loss and delay percentages.
Toggle the switch to ON.

Option B: `pf` (Packet Filter) and `dummynet` (CLI)

Create a dummynet pipe to simulate loss:

sudo dnctl pipe 1 config plr 0.10

(This creates a pipe with a 10% packet loss rate).

Route specific UDP traffic into this pipe by editing /etc/pf.conf or applying a temporary anchor rule referencing port and protocol:

dummynet in proto udp from any to any port 5000 pipe 1

4. Cross-Platform Automated Testing: Toxiproxy

If you need to test UDP reliability in automated CI/CD pipelines, Shopify’s Toxiproxy is a TCP/UDP proxy designed specifically for simulating network chaos.

Start the Toxiproxy daemon.
Register your UDP service as a proxy target via the HTTP API or client libraries (Go, Python, Node, Java, etc.).

Apply the loss toxic to the proxy:

POST /proxies/{proxy_name}/toxics
{
  "type": "loss",
  "stream": "downstream",
  "toxicity": 0.15
}

(This configures a 15% packet drop rate automatically during test execution).

5. Application-Layer Simulation (Mocking)

When system-level privileges are unavailable, implement an interceptor or wrapper around your UDP socket.

Wrap your socket’s sendto() or recvfrom() calls with a drop-probability check:

int custom_udp_send(int socket, const void *buffer, size_t length, int flags, const struct sockaddr *dest, socklen_t dest_len) {
    float drop_rate = 0.10f; // 10% packet loss
    if (((float)rand() / RAND_MAX) < drop_rate) {
        return length; // Pretend it was sent, but drop the packet
    }
    return sendto(socket, buffer, length, flags, dest, dest_len);
}

This method ensures repeatable, deterministic testing without requiring external tools or administrative permissions.