Lidsky řečeno
Hrací kostka je pro deskovku ideální, ale klíč od trezoru by podle ní nikdo nevyráběl. Kdo zná kostku a pár hodů, může zkoušet dál. random je ta kostka. secrets je zámečník, který klíč vyrobí tak, aby ho nešlo uhodnout.
secrets: náhoda, kterou nikdo neuhodne
Když generuješ něco, co chrání přístup, patří to do secrets. Typicky jde o odkaz pro obnovu hesla, API klíč nebo jednorázový kód. Slovo token tu znamená náhodný řetězec, který funguje jako dočasný klíč.
Výsledky jsou při každém spuštění jiné, a to je správně. Ukázka proto vypisuje jen jejich vlastnosti. Klidně si přidej print(token) a podívej se na ně.
import secrets
token = secrets.token_hex(16)
odkaz = secrets.token_urlsafe(16)
surove = secrets.token_bytes(16)
print(len(token), len(odkaz), len(surove))
print(all(znak in "0123456789abcdef" for znak in token))
print(secrets.token_hex(16) == secrets.token_hex(16))
print(0 <= secrets.randbelow(6) < 6)
print(secrets.choice(["rub", "líc"]) in ("rub", "líc"))
32 22 16 True False True True
Číslo v závorce je počet náhodných bajtů, ne znaků. Jeden bajt zabere v šestnáctkovém zápisu dva znaky, proto má token_hex(16) délku 32. token_urlsafe je kratší a dá se bez úprav vložit do webové adresy.
Proč nestačí random? Protože z něj jde budoucnost vypočítat. Představ si aplikaci, která nastaví semínko podle času a rozdává z generátoru tokeny. Útočník si nechá vystavit jeden pro sebe, vyzkouší všechny vteřiny kolem okamžiku jeho vzniku a dopočítá token, který dostane příští uživatel.
import random
import string
ABECEDA = string.ascii_lowercase + string.digits
def tokeny(seed, kolik):
rng = random.Random(seed)
return ["".join(rng.choices(ABECEDA, k=12)) for _ in range(kolik)]
muj, cizi = tokeny(1_763_450_123, 2)
print("útočník dostal token:", muj)
for pokus, cas in enumerate(range(1_763_450_000, 1_763_451_000), start=1):
kandidati = tokeny(cas, 2)
if kandidati[0] == muj:
print("semínko nalezeno po", pokus, "pokusech")
print("token další oběti:", kandidati[1])
print("sedí:", kandidati[1] == cizi)
break
útočník dostal token: 0uhkdvwo74vt semínko nalezeno po 124 pokusech token další oběti: ki7x9n5qkigf sedí: True
Jak silné je heslo nebo token, se měří v bitech entropie. Každý bit navíc znamená dvakrát víc možností, které musí útočník vyzkoušet. Vzorec je jednoduchý:
bity = délka * log2(počet možných znaků)import math
import string
varianty = [
("PIN, 4 číslice", 4, 10),
("8 malých písmen", 8, 26),
("12 písmen a číslic", 12, len(string.ascii_letters + string.digits)),
("16 písmen a číslic", 16, len(string.ascii_letters + string.digits)),
("token_hex(32)", 64, 16),
]
for popis, delka, znaku in varianty:
print(f"{popis:<20}{delka * math.log2(znaku):>7.1f} bitů")
PIN, 4 číslice 13.3 bitů 8 malých písmen 37.6 bitů 12 písmen a číslic 71.5 bitů 16 písmen a číslic 95.3 bitů token_hex(32) 256.0 bitů
Porovnávat tokeny patří přes compare_digest. Běžné == skončí na prvním rozdílném znaku a z rozdílu v čase odpovědi se dá token hádat po částech.
import secrets
ulozeny = "a1b2c3d4"
print(secrets.compare_digest(ulozeny, "a1b2c3d4"))
print(secrets.compare_digest(ulozeny, "a1b2c3d5"))
try:
secrets.compare_digest("heslo", "žluť")
except TypeError:
print("text s diakritikou nejdřív převeď na bajty")
print(secrets.compare_digest("žluť".encode(), "žluť".encode()))
True False text s diakritikou nejdřív převeď na bajty True
Generátor hesel
Napiš funkci vygeneruj_heslo(delka). Heslo má být z velkých a malých písmen a číslic, musí obsahovat aspoň jedno velké písmeno, jedno malé a jednu číslici. Použij secrets, ne random.
import secrets
import string
def vygeneruj_heslo(delka):
return ""
K čemu se hodí random a k čemu secrets?
random je rychlý a umí se opakovat přes semínko, ale jde předvídat. secrets bere náhodu od operačního systému a opakovat ani předpovědět nejde.
string: hotové sady znaků
Modul string nabízí konstanty, které nemusíš vypisovat ručně. Hodí se při generování i kontrole textů.
import string
print(string.ascii_lowercase)
print(string.digits)
print(string.punctuation)
veta = "Ahoj, světe! Jak se máš?"
bez_interpunkce = veta.translate(str.maketrans("", "", string.punctuation))
print(bez_interpunkce)
print("č" in string.ascii_lowercase)
print("č".isalpha())
abcdefghijklmnopqrstuvwxyz
0123456789
!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
Ahoj světe Jak se máš
False
TrueDruhou užitečnou věcí je Template, jednoduchá šablona s proměnnými psanými přes $.
from string import Template
sablona = Template("Dobrý den, $jmeno. Dlužíte ${castka}Kč a poplatek 5 $$.")
print(sablona.substitute(jmeno="Anna", castka=1200))
print(sablona.safe_substitute(jmeno="Anna"))
print(sablona.get_identifiers())
Dobrý den, Anna. Dlužíte 1200Kč a poplatek 5 $.
Dobrý den, Anna. Dlužíte ${castka}Kč a poplatek 5 $.
['jmeno', 'castka']substitute při chybějící hodnotě vyhodí KeyError, safe_substitute nechá proměnnou v textu. Složené závorky oddělí jméno od dalšího textu a $$ znamená obyčejný dolar.
Na co to, když existují f-stringy? F-string píše programátor přímo do kódu. Jakmile ale šablonu zadává uživatel, třeba text e-mailu v administraci, str.format je nebezpečný. Umí totiž sahat na atributy objektů.
from string import Template
class Uzivatel:
def __init__(self):
self.jmeno = "Anna"
self.heslo = "tajne123"
u = Uzivatel()
od_utocnika = "Ahoj {u.heslo}"
print(od_utocnika.format(u=u))
print(Template("Ahoj $u.heslo").safe_substitute(u=u.jmeno))
Ahoj tajne123 Ahoj Anna.heslo
Template tečku nechápe jako přístup k atributu, dosadí jen jméno a zbytek nechá být.
Adresa z nadpisu
Napiš funkci udelej_slug(nadpis), která z nadpisu vyrobí text pro webovou adresu: malá písmena bez diakritiky, slova spojená pomlčkou, žádná interpunkce. Z "Příliš žluťoučký kůň!" má vzniknout "prilis-zlutoucky-kun".
import string
import unicodedata
def udelej_slug(nadpis):
return nadpis
textwrap: řádky, které se vejdou
Terminál, e-mail ani účtenka nezalomí text podle tebe. Modul textwrap to zařídí a slova přitom netrhá.
import textwrap
text = ("Knihovna textwrap zalamuje dlouhé věty podle zadané šířky "
"a dává pozor, aby slova zůstala celá.")
for radek in textwrap.wrap(text, width=30):
print(f"|{radek:<30}|")
print()
print(textwrap.fill(text, width=40))
print()
print(textwrap.shorten(text, width=40))
print(textwrap.shorten(text, width=40, placeholder=" …"))
|Knihovna textwrap zalamuje | |dlouhé věty podle zadané šířky| |a dává pozor, aby slova | |zůstala celá. | Knihovna textwrap zalamuje dlouhé věty podle zadané šířky a dává pozor, aby slova zůstala celá. Knihovna textwrap zalamuje dlouhé [...] Knihovna textwrap zalamuje dlouhé věty …
wrapvrátí seznam řádků.fillvrátí jeden text, řádky jsou spojené znakem nového řádku.shortentext zkrátí na celá slova. Do šířky se počítá i značka na konci.
Víceřádkové texty uvnitř funkcí mívají odsazení, které do výstupu nepatří. dedent ho odebere a indent naopak přidá.
import textwrap
def napoveda():
return textwrap.dedent("""\
Použití:
nastroj --vstup soubor.txt
Hotovo.""")
print(napoveda())
print()
print(textwrap.indent("první řádek\n\ntřetí řádek", "> "))
Použití: nastroj --vstup soubor.txt Hotovo. > první řádek > třetí řádek
Pro jemnější nastavení je tu třída TextWrapper. Hodí se na odrážky, kde první řádek začíná jinak než ostatní. A v češtině vyřeší ještě jednu věc: jednopísmenné předložky a spojky by neměly zůstávat na konci řádku. Stačí za ně dát nezlomitelnou mezeru \u00a0, kterou textwrap za místo pro zalomení nepovažuje.
import re
import textwrap
odrazka = textwrap.TextWrapper(width=32, initial_indent="- ", subsequent_indent=" ")
print(odrazka.fill("Každá odrážka začíná pomlčkou a další řádky jsou zarovnané pod textem."))
print()
veta = "Šel jsem k lékaři a v pondělí s kamarádem u nás doma o všem mluvil."
print("\n".join(textwrap.wrap(veta, width=22)))
print()
s_vlnkou = re.sub(r"\b([ksvzouaiKSVZOUAI]) ", "\\1\u00a0", veta)
for radek in textwrap.wrap(s_vlnkou, width=22):
print(radek.replace("\u00a0", "~"))
- Každá odrážka začíná pomlčkou a další řádky jsou zarovnané pod textem. Šel jsem k lékaři a v pondělí s kamarádem u nás doma o všem mluvil. Šel jsem k~lékaři a~v~pondělí s~kamarádem u~nás doma o~všem mluvil.
Vlnka ~ ve výpisu jen zviditelňuje nezlomitelnou mezeru. Ve skutečném textu vypadá jako normální mezera.
Náhled článku
Napiš funkci nahled(text, sirka), která vrátí text zkrácený na nejvýše sirka znaků, po celých slovech, se značkou ... na konci, pokud se něco uřízlo.
import textwrap
def nahled(text, sirka):
return text
Odrážky pro terminál
Napiš funkci odrazky(polozky, sirka), která vrátí jeden text. Každá položka začíná * , další řádky téže položky jsou odsazené dvěma mezerami a žádný řádek nepřesáhne sirka. Položky odděl novým řádkem.
import textwrap
def odrazky(polozky, sirka):
return ""
Co udělá textwrap.fill("a\nb", width=10)?
Parametr replace_whitespace je ve výchozím stavu zapnutý a \n se bere jako obyčejná mezera mezi slovy.
Pod kapotou · secrets v produkci
secrets je tenká vrstva nad random.SystemRandom, tedy nad os.urandom. Ta čte CSPRNG jádra (getrandom() na Linuxu, BCryptGenRandom na Windows) a stav v procesu nedrží, takže ho nelze zdědit přes fork ani získat z výstupů. randbelow používá odmítací vzorkování, takže nemá modulo bias, který vzniká u naivního token % n.
Token v databázi ukládej jen jako hash. Má vysokou entropii, takže stačí rychlý sha256 a únik tabulky útočníkovi nic nedá. U hesel od lidí je to naopak: entropie je nízká a rychlý hash je chyba. Tam patří pomalá funkce s pamětí, například hashlib.scrypt nebo Argon2.
compare_digest není všelék. Je to hmac.compare_digest: doba závisí na délce porovnávaných dat, ne na obsahu, a str přijme jen v ASCII. Délku tedy neskrývá, proto se v praxi často porovnávají hashe pevné délky. secrets.DEFAULT_ENTROPY je dnes 32 bajtů, ale dokumentace si vyhrazuje změnu, takže kde na délce záleží, zadej ji explicitně.
Hesla s pevným vzorem jsou slabší. Dosazení „jedno velké písmeno na začátek a číslice na konec“ zmenšuje prostor a dává útočníkovi strukturu. Odmítnutí celého kandidáta jako v úkolu dá rovnoměrné rozdělení nad povolenými hesly a množinu zmenší jen nepatrně.
Pod kapotou · Unicode, šablony a šířka textu
str.format jako čtecí primitivum. Formátovací řetězec z nedůvěryhodného zdroje dovolí přístup k atributům a položkám, přes __init__.__globals__ i ke globálním proměnným modulu. Klasický únik konfigurace se SECRET_KEY. Stejná třída chyb potkává Jinja2 bez sandboxu. string.Template má záměrně malý jazyk: žádné atributy, indexy ani výrazy. Template.get_identifiers() a is_valid() (obojí od 3.11) navíc umožní validovat šablonu při ukládání, ne až při odesílání.
textwrap měří kódové body. Bere len(), ne šířku na obrazovce. Kombinační znaky se započítají navíc a emoji nebo znaky CJK zaberou v terminálu dvě buňky, takže zarovnání nesedí. unicodedata.east_asian_width pomůže jen částečně; přesněji měří balík wcwidth a rich používá vlastní tabulky.
Zalamování je jen ASCII. Vnitřní _whitespace obsahuje záměrně pouze \t\n\x0b\x0c\r a mezeru, proto \u00a0 drží slova u sebe. Pozor, str.split() bez argumentu naopak \u00a0 za oddělovač považuje, stejně jako \s v regulárních výrazech nad str. Pipeline, která text mezitím normalizuje přes " ".join(t.split()), typografii tiše zruší.
Pomlčky a dlouhá slova. break_on_hyphens=True láme za spojovníkem, což je past u URL a identifikátorů, a break_long_words=True je rozseká na šířku. Pro logy a odkazy nastav obojí na False, s tím že řádek pak může šířku překročit. NFD v úkolu je dobrá pro češtinu, ale neřeší znaky bez rozkladu jako ł nebo ß.