Houd een bestandsnaam binnen zijn map

Een boek kan nu een cover hebben. De covers zijn drie kleine tekstbestanden in de map covers, en het project van dit hoofdstuk serveert ze op GET /covers/{name}. De branch in route() begint zo:

            cover = pathlib.Path(state["covers_dir"]) / segments[1]
            if cover.is_file():
                body = cover.read_bytes()

Hij voegt een naam uit het verzoek samen met een map en leest welk bestand hij daar ook vindt. Voer python pl_sec.py injection uit en lees het derde deel:

--- a path: a cover, and a name that climbs out of the folder ---
GET /covers/kindred.txt       -> 200  Kindred, cover notes.
GET /covers/..%2fSECURITY.md  -> 200  # Security findings: the reading list
a file that is not a cover was served: SECURITY.md, from your own project folder

Het tweede verzoek kreeg de eerste regel van SECURITY.md. Het scenario blijft met opzet binnen je projectmap, en niets daarbuiten wordt gelezen. Op een echte server grijpt hetzelfde verzoek naar een configuratiebestand of een sleutel. Een bestand lezen buiten de map die een route hoort te serveren, is path traversal.

Hoe de naam daar kwam

In een pad betekent .. de map erboven. Een gewone /covers/../SECURITY.md komt nergens: dat pad heeft drie segmenten, en de coverbranch neemt er precies twee.

Daarom verstopt de aanval de slash als %2f. path_segments() splitst het pad eerst bij /, en decodeert daarna elk segment:

def path_segments(target):
    """Return the decoded path segments of a request target."""
    segments = []
    for segment in urlsplit(target).path.split("/")[1:]:
        segments.append(unquote(segment))
    return segments

Terwijl het pad wordt gesplitst, is ..%2fSECURITY.md één segment. Gedecodeerd is het ../SECURITY.md. Eerst splitsen is juist, want dan kan een gecodeerde slash nooit veranderen welke route een verzoek neemt. De naam die binnenkomt, kan nog steeds een slash bevatten, en samengevoegd met de map staat er covers/../SECURITY.md.

Controleer het pad, niet de tekst

Het eerste idee is naar de tekst van de naam te kijken. Hier zijn drie van zulke controles, en de naam die elk ervan verslaat.

Weiger een naam die .. bevat. Een absolute naam heeft geen punten nodig, want als je hem met een map samenvoegt, wordt de map weggegooid.

import pathlib

print(pathlib.PurePosixPath("/srv/covers") / "/etc/hosts")

Weiger een naam die met een slash begint. Dan is ../SECURITY.md terug.

Voeg eerst samen, en accepteer het pad als zijn tekst begint met de tekst van de map. Nu staat een map met de naam covers-old, naast covers, open: de tekst /srv/covers-old/x.txt begint met /srv/covers.

Elk van deze controles vraagt naar tekens. De echte vraag gaat over het bestandssysteem: staat dit bestand binnen die map? pathlib kan dat beantwoorden. resolve() geeft het absolute pad terug, met elke .. uitgewerkt en elke link gevolgd. parents bevat elke map boven een pad. Los dus de map op, los het samengevoegde pad op, en eis dat de map in path.parents staat. Een link binnen de map die naar een bestand daarbuiten wijst, wordt ook opgelost, en geweigerd.

Eén keer decoderen, op één plek

De router heeft de naam al gedecodeerd. Het is verleidelijk om in de functie voor de zekerheid nog een keer unquote aan te roepen. Een van de covers laat zien wat dat kost. De bestandsnaam is rep ort.txt, met een spatie, dus een client vraagt om /covers/rep%20ort.txt, en het decoderen door de router levert de naam van het bestand op. Een verzoek om /covers/rep%2520ort.txt noemt iets anders: %25 is een gecodeerd procentteken, dus de naam die binnenkomt is rep%20ort.txt, en geen enkele cover heeft die naam.

from urllib.parse import unquote

once = unquote("rep%2520ort.txt")
print(once)
print(unquote(once))
print(unquote(unquote("%252e%252e%252fSECURITY.md")))

Het drukt rep%20ort.txt af, dan rep ort.txt, dan ../SECURITY.md. De eerste regel is het resultaat van de router, de naam waar de client om vroeg. Een tweede keer decoderen maakt er rep ort.txt van, en de server antwoordt met een bestand dat de client niet noemde. Het werkt ook andersom: op een server waar de naam van een bestand een procentteken bevat, verandert een tweede keer decoderen die naam, en dan is het bestand niet meer op te halen.

De derde regel is erger. Na het decoderen door de router is %252e%252e%252f gelijk aan %2e%2e%2f: tekst zonder punt en zonder slash erin. Een controle op de tekst vindt niets verkeerds, en daarna maakt een tweede keer decoderen er ../ van. De regel is die uit les 2: controleer wat je gaat gebruiken. De naam wordt één keer gedecodeerd, door de router, en je functie gebruikt hem zoals hij binnenkomt.

Je taak

Schrijf safe_cover_path(folder, name) in reading_server.py. Hij geeft een pad terug, of None:

1. Geef None terug als "\x00" in de naam staat. /covers/a%00 levert zo’n naam af, en resolve() werpt er ValueError voor op.

2. base = pathlib.Path(folder).resolve(), en path = (base / name).resolve().

3. Geef None terug tenzij base in path.parents.

4. Geef None terug tenzij path.is_file(), zodat ook de naam van een map een 404 krijgt.

5. Geef path terug.

Een bestand in een map binnen covers komt door al deze controles, en wordt geserveerd. De regel gaat over de map, niet over het aantal slashes in de naam.

Gebruik hem daarna in de coverbranch: cover = safe_cover_path(state["covers_dir"], segments[1]), en serveer het bestand als cover is not None. De map komt uit de state, zodat een test de server naar een eigen map kan laten wijzen. Dat doe je in les 8.

Vraag om de cover met de spatie, en daarna om de naam met het gecodeerde procentteken:

python -c "import sys; sys.path.insert(0, 'tests'); import helpers, reading_server; print([reading_server.handle(helpers.make_request('GET', target), reading_server.sample_state())['status'] for target in ('/covers/rep%20ort.txt', '/covers/rep%2520ort.txt')])"

Het drukt [200, 404] af. Je kunt even name = unquote(name) bovenaan je functie zetten en de regel opnieuw uitvoeren: [200, 200]. Het tweede verzoek krijgt nu een bestand waar het niet om vroeg. Haal de regel daarna weer weg.

python -m pytest -q eindigt nog steeds met 23 passed. Het derde deel van het scenario luidt nu:

--- a path: a cover, and a name that climbs out of the folder ---
GET /covers/kindred.txt       -> 200  Kindred, cover notes.
GET /covers/..%2fSECURITY.md  -> 404  {"error": "no cover has that name"}
the name outside the folder was refused

De resultaatregel zegt 1 of 4 attacks worked. Druk daarna op Check my work. De ene aanval die overblijft, zet een titel in een pagina, en de volgende les houdt die tegen.