0 dní v řadě · 0 bodů

Užitečné knihovny · 22 min

secrets, string a textwrap

Bezpečné tokeny a hesla, šablony textu bez děr a zalamování řádků včetně české typografie. Tři malé knihovny pro každodenní práci s textem.

Hloubka
Úkoly
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"))
Výstup
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
Výstup
ú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ý:

text
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ů")
Výstup
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()))
Výstup
True
False
text s diakritikou nejdřív převeď na bajty
True
Úkol

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 ""
Výstup
Kvíz

K čemu se hodí random a k čemu secrets?

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())
Výstup
abcdefghijklmnopqrstuvwxyz
0123456789
!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
Ahoj světe Jak se máš
False
True

Druhou 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())
Výstup
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))
Výstup
Ahoj tajne123
Ahoj Anna.heslo

Template tečku nechápe jako přístup k atributu, dosadí jen jméno a zbytek nechá být.

Úkol

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
Výstup

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=" …"))
Výstup
|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 …
  • wrap vrátí seznam řádků.
  • fill vrátí jeden text, řádky jsou spojené znakem nového řádku.
  • shorten text 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", "> "))
Výstup
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", "~"))
Výstup
- 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.

Úkol

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
Výstup
Úkol

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 ""
Výstup
Kvíz

Co udělá textwrap.fill("a\nb", width=10)?

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 ß.