Programma Les 142 van 156 · Anonymiteitsnetwerken en verkeersanalyse
Anonymiteitsnetwerken en verkeersanalyse

Verkeersanalyse

Waarom dit ertoe doet Versleuteling verbergt wat je zegt, maar niet wanneer je het zegt of hoeveel. Alleen al de timing van verkeer bekijken kan onthullen wie met wie praat, zelfs via een anonimiteitsnetwerk. Als je het ziet werken op gesimuleerde stromen, wordt duidelijk wat Tor wel en niet kan beloven, en waarom de sterkste verdediging zo duur is.

Stel je voor dat je niemands post kunt openen, maar wel bij twee postkantoren kunt staan. Elke keer dat er een golf brieven uit het huis van Ana vertrekt, komt er even later een vergelijkbare golf aan bij een kliniek. Je leest geen woord, en toch kun je raden dat Ana naar de kliniek schrijft.

Metadata: gegevens over een bericht in plaats van de inhoud: wanneer het verstuurd werd, hoe groot het was, waar het vandaan kwam en waar het heen ging.

Verkeersanalyse: dingen te weten komen uit het patroon van communicatie (timing, groottes, volumes) zonder de inhoud te lezen.

De opzet

Een waarnemer bekijkt twee plekken: de verbinding tussen gebruikers en hun guard, en de verbinding tussen exits en websites. De functie tor_flows(seed) in watched.leg7b_onion geeft je gesimuleerde opnames van allebei. Elk pakket is één cel, de vaste verkeerseenheid van Tor (514 bytes), dus de grootte vertelt je niets. Timing is alles wat je hebt. De namen van de stromen aan beide kanten zijn door elkaar gehusseld, en de exitkant is iets vertraagd.

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.

Stap 1: maak van pakketten een vorm

Tel hoeveel pakketten er in elke seconde vallen: seconde 0 bevat de tijden van 0 tot (niet tot en met) 1, enzovoort. int(t) geeft de seconde waartoe een tijd hoort. Een stroom wordt een lijst zoals [0, 7, 9, 1, 0, 0, 6, ...]: zijn vorm in de tijd.

Stap 2: vergelijk twee vormen

Correlatie: een getal van -1 tot 1 dat zegt hoezeer twee lijsten samen stijgen en dalen. 1 betekent perfect in de pas, 0 betekent geen verband. Python heeft het ingebouwd: statistics.correlation(a, b).

Verandert een lijst nooit (alle waarden gelijk), dan is de correlatie niet gedefinieerd en gooit Python een statistics.StatisticsError. Vang die op en gebruik 0.0, wat "geen bewijs in welke richting dan ook" betekent.

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")

Stap 3: koppel elke ingangsstroom aan de meest gelijkende exitstroom

Probeer voor elke ingangsstroom elke exitstroom en houd die met de hoogste correlatie. In deze simulatie koppelt dat alleen al bijna iedereen goed. Echte aanvallen van deze soort, die onderzoekers bestudeerd hebben, werken in dezelfde geest.

De verdedigingen, en hun prijs

  • Willekeurig dekverkeer: voeg op willekeurige momenten nepcellen toe. Het vervaagt de vorm een beetje, maar golven springen er nog steeds uit. Je zult zien dat het nauwelijks helpt.
  • Constant tempo: stuur elke seconde precies evenveel cellen, vul gaten op met nepcellen en laat echte cellen op hun beurt wachten. Elke seconde ziet er hetzelfde uit, dus de vorm verdwijnt. De prijs is bandbreedte (al die nepcellen) en vertraging (cellen staan in de rij tijdens golven).

Tor voegt wat opvulling toe om grove verbindingsgegevens te vervagen, maar het verbergt de vorm van je verkeer niet voor iemand die beide uiteinden kan bekijken (gecontroleerd in oktober 2026). Het kiest voor weinig vertraging, zodat het web bruikbaar blijft. De laatste les van deze module bekijkt netwerken die de andere kant op kiezen.

Een veelvoorkomende misvatting: "Als alles versleuteld is, kan niemand zien met wie ik praat." Versleuteling verbergt de inhoud. Timing en volume blijven zichtbaar, en die zijn vaak genoeg.

Dit lab gebruikt alleen gesimuleerde stromen. Het gaat om het risico begrijpen zodat je verdedigingen kunt beoordelen; het is geen methode om echte mensen te bekijken, en echte netwerken zijn veel rommeliger.

In andere talen

Pakketten per seconde tellen en een correlatie berekenen, elders:

// 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
}

Samenvatting

  • Versleuteling verbergt de inhoud, niet de timing of het volume (metadata).
  • Pakketten per seconde tellen geeft elke stroom een vorm; correlatie vindt passende vormen aan beide uiteinden.
  • Willekeurig dekverkeer helpt nauwelijks; versturen met constant tempo verbergt de vorm maar kost bandbreedte en vertraging.
  • Tor kiest voor weinig vertraging, dus het kan iemand die beide uiteinden bekijkt niet tegenhouden.
Jij bent aan de beurt

Schrijf vier functies, gebruik ze daarna op tor_flows(seed=1):

  1. counts_per_second(packets, seconds): een lijst van seconds nummers, de telling van pakketten waarvan de tijd t voldoet aan 0 <= t < seconds, geplaatst op index int(t).
  2. similarity(a, b): statistics.correlation(a, b), of 0.0 als dat statistics.StatisticsError.
  3. oproept
  4. match(entry, exits, seconds): een dictionary die de "flow" id van elke entry flow koppelt aan de id van de exit flow met de hoogste similarity.
  5. accuracy(guesses, answers): het deel van de ids in answers die je gokken correct waren.
Stel dan acc_plain (geen verdediging), acc_cover (ingangszijde na add_cover_traffic(flows["entry"], rate=20, seed=1, seconds=S)) en acc_constant (ingangszijde na constant_rate(flows["entry"], per_second=10, seconds=S)) in. Tests gebruiken ook nieuwe opnames.

Een probleem ontdekt in deze les? Meld het · Vraag naar deze les

Deze oefening opent binnenkort

Maak de les ervoor af voordat deze wordt ontgrendeld. De hele cursus is gratis, geen account nodig, en je kunt deze les nu lezen.