Relays and VPNs, honestly

Lesson 86 compared life with and without a VPN. Here you go further and model several tools side by side.

Picture passing a note across a classroom. If you hand it to one friend who walks it to the recipient, that friend knows who sent it and who got it. If it goes through two friends, and the note is folded so the first only sees "pass to Bea" and the second only sees "give to Sol", neither friend knows both ends.

The facts, dated

iCloud Private Relay (part of Apple's paid iCloud+ plan) covers browsing in Safari, DNS lookups, and some unencrypted traffic from apps (checked October 2026). Its second hop is run by partner content delivery networks (companies that run servers around the world to deliver websites quickly), not by Apple. It is not a full VPN: other browsers and most app traffic do not go through it.

A VPN usually covers everything your device sends, but the VPN company sees what your provider used to. Tor Browser sends its own traffic through Tor and also makes its users look alike, which matters for fingerprints (the next module, Network fingerprints).

The rules of the model

A route is a list of the parties between you and the website, ending with the website, for example ["vpn", "shopb.example"]. There is always also the "network": your Wi-Fi and provider, who carry your packets to the first hop. There are three facts anyone might learn: "your_ip", "site" (which website you visit) and "content" (what you read and send).

• The network always sees your_ip. It sees the site only when you connect to the website directly (the route has just one entry), and the content only when, also, HTTPS is off.
• The first relay sees your_ip, because packets arrive straight from you.
• The last relay (the one just before the website) sees the site, because it must connect to it. Without HTTPS it also sees the content.
• The website always sees site and content, and sees your_ip only when you connect directly.
• A middle relay sees neither end.

A one-relay route (a VPN) makes the first and last relay the same, so it learns both. That is the whole point of this lesson, falling out of these few rules.

In Python, a set of facts can be written {"your_ip", "site"}, and an empty set is set() (not {}, which is an empty dict). enumerate(route) gives each position and name: for i, name in enumerate(route):.

// JavaScript
const linkers = view => Object.keys(view)
  .filter(p => view[p].has("your_ip") && view[p].has("site"))
  .sort();

// Rust
let mut linkers: Vec<&String> = view.iter()
    .filter(|(_, facts)| facts.contains("your_ip") && facts.contains("site"))
    .map(|(party, _)| party)
    .collect();
linkers.sort();

// C#
var linkers = view.Where(kv => kv.Value.Contains("your_ip") && kv.Value.Contains("site"))
                  .Select(kv => kv.Key).OrderBy(k => k).ToList();

A common misconception: "two hops means twice the encryption, so it is twice as safe". The gain is not more encryption; it is splitting knowledge between parties that do not share notes. If one company ran both hops, it would learn both ends again. And no relay stops cookies, logins or fingerprints.