Traffic analysis

Imagine you cannot open anyone's post, but you can stand at two post offices. Every time a burst of letters leaves Ana's house, a similar burst arrives at a clinic a moment later. You never read a word, yet you can guess Ana writes to the clinic.

The setting

An observer watches two places: the link between users and their guard, and the link between exits and websites. The function tor_flows(seed) in watched.leg7b_onion gives you simulated recordings of both. Every packet is one cell, Tor's fixed-size unit of traffic (514 bytes), so size tells you nothing. Timing is all you have. The flow names on the two sides are shuffled, and the exit side is a little delayed.

from watched.leg7b_onion import tor_flows
flows = tor_flows(seed=1)
print(flows["entry"][0]["flow"])          # e01
print(flows["entry"][0]["packets"][:3])   # [(time_in_seconds, size), ...]
print(flows["exit"][0]["flow"])           # x01, but which user is it?
# flows["answers"] holds the truth, so you can score your guesses.

Step 1: turn packets into a shape

Count how many packets fall in each second: second 0 holds times from 0 up to (not including) 1, and so on. int(t) gives the second a time belongs to. A flow becomes a list like [0, 7, 9, 1, 0, 0, 6, ...]: its shape over time.

Step 2: compare two shapes

If a list never changes (every value equal), correlation is undefined and Python raises statistics.StatisticsError. Catch it and use 0.0, meaning "no evidence either way".

import statistics
print(statistics.correlation([1, 5, 2, 8], [2, 9, 3, 15]))   # close to 1: in step
try:
    statistics.correlation([3, 3, 3], [1, 2, 3])
except statistics.StatisticsError:
    print("a flat list has no correlation")

Step 3: match each entry flow to its most similar exit flow

For every entry flow, try every exit flow and keep the one with the highest correlation. In this simulation that alone pairs almost everyone correctly. Real attacks of this kind, studied by researchers, work in the same spirit.

The defences, and their price

• Random cover traffic: add fake cells at random times. It blurs the shape a little, but bursts still stick out. You will see it barely helps.
• Constant rate: send exactly the same number of cells every second, filling gaps with dummies and making real cells wait their turn. Every second looks identical, so the shape vanishes. The price is bandwidth (all those dummies) and delay (cells queue during bursts).

Tor adds a little padding to blur coarse connection records, but it does not hide the shape of your traffic from someone who can watch both ends (checked October 2026). It chooses low delay so the web stays usable. The final lesson in this module looks at networks that choose the other way.

A common misconception: "If everything is encrypted, nobody can tell who I talk to." Encryption hides contents. Timing and volume are still visible, and they are often enough.

This lab uses simulated flows only. It is about understanding the risk so you can judge defences; it is not a method for watching real people, and real networks are far noisier.

// JavaScript
function countsPerSecond(packets, seconds) {
  const counts = new Array(seconds).fill(0);
  for (const [t] of packets) if (t >= 0 && t < seconds) counts[Math.floor(t)]++;
  return counts;
}
function correlation(a, b) {
  const n = a.length, ma = a.reduce((x, y) => x + y) / n, mb = b.reduce((x, y) => x + y) / n;
  let num = 0, da = 0, db = 0;
  for (let i = 0; i < n; i++) { num += (a[i]-ma)*(b[i]-mb); da += (a[i]-ma)**2; db += (b[i]-mb)**2; }
  return da && db ? num / Math.sqrt(da * db) : 0;
}

// Go
func countsPerSecond(times []float64, seconds int) []int {
    counts := make([]int, seconds)
    for _, t := range times {
        if t >= 0 && t < float64(seconds) { counts[int(t)]++ }
    }
    return counts
}