secrets — Generera säkra slumptal för hantering av hemligheter

Tillagd i version 3.6.

Källkod: Lib/secrets.py

Modulen secrets används för att generera kryptografiskt starka slumptal som är lämpliga för hantering av data som lösenord, kontoautentisering, säkerhetstoken och relaterade hemligheter.

I synnerhet bör secrets användas i stället för standardgeneratorn för pseudoslumpmässiga tal i modulen random, som är avsedd för modellering och simulering, inte för säkerhet eller kryptografi.

Se även

PEP 506

Slumptal

Modulen secrets ger tillgång till den säkraste slumpmässiga källan som ditt operativsystem tillhandahåller.

class secrets.SystemRandom

En klass för att generera slumptal med hjälp av de källor av högsta kvalitet som operativsystemet tillhandahåller. Se random.SystemRandom för ytterligare detaljer.

secrets.choice(seq)

Returnerar ett slumpmässigt valt element från en icke-tom sekvens.

secrets.randbelow(exclusive_upper_bound)

Returnerar ett slumpmässigt int i intervallet [0, exklusiv_övre_gräns).

secrets.randbits(k)

Returnerar ett icke-negativt int med k slumpmässiga bitar.

Generering av polletter

Modulen secrets innehåller funktioner för att generera säkra tokens, lämpliga för tillämpningar som återställning av lösenord, svårbedömda webbadresser och liknande.

secrets.token_bytes([nbytes=None])

Returnerar en slumpmässig bytesträng som innehåller nbytes antal byte. Om nbytes är None eller inte anges, används en rimlig standard.

>>> token_bytes(16)
b'\xebr\x17D*t\xae\xd4\xe3S\xb6\xe2\xebP1\x8b'
secrets.token_hex([nbytes=None])

Returnerar en slumpmässig textsträng i hexadecimal. Strängen har nbytes slumpmässiga byte, varje byte konverteras till två hexadecimala siffror. Om nbytes är None eller inte anges, används ett rimligt standardvärde.

>>> token_hex(16)
'f9bf78b9a18ce6d46a0cd2b0b86df9da'
secrets.token_urlsafe([nbytes=None])

Returnerar en slumpmässig URL-säker textsträng som innehåller nbytes slumpmässiga byte. Texten är Base64-kodad, så i genomsnitt resulterar varje byte i cirka 1,3 tecken. Om nbytes är None eller inte anges, används en rimlig standard.

>>> token_urlsafe(16)
'Drmhze6EPcv0fN_81Bj-nA'

Hur många byte ska tokens använda?

För att vara säkra mot brute-force-attacker måste tokens vara tillräckligt slumpmässiga. Tyvärr kommer det som anses tillräckligt nödvändigtvis att öka i takt med att datorer blir kraftfullare och kan göra fler gissningar på kortare tid. Från och med 2015 tror man att 32 byte (256 bitar) slumpmässighet är tillräckligt för det typiska användningsfall som förväntas för modulen secrets.

För dem som vill hantera sin egen tokenlängd kan du uttryckligen ange hur mycket slumpmässighet som ska användas för tokens genom att ge ett int-argument till de olika token_*-funktionerna. Det argumentet tas som antalet bytes slumpmässighet som ska användas.

I annat fall, om inget argument anges eller om argumentet är None, kommer token_*-funktionerna att använda en rimlig standard istället.

Anteckning

Denna standard kan ändras när som helst, även under underhållsversioner.

Övriga funktioner

secrets.compare_digest(a, b)

Returnerar True om strängar eller bytesliknande objekt a och b är lika, annars False, använder en ”constant-time compare” för att minska risken för timing attacker. Se hmac.compare_digest() för ytterligare detaljer.

Recept och bästa praxis

I det här avsnittet visas recept och bästa praxis för hur du använder secrets för att hantera en grundläggande säkerhetsnivå.

Skapa ett alfanumeriskt lösenord med åtta tecken:

import string
import secrets
alphabet = string.ascii_letters + string.digits
password = ''.join(secrets.choice(alphabet) for i in range(8))

Anteckning

Program bör inte lagra lösenord i ett återställbart format, vare sig i klartext eller krypterat. De bör saltas och hashas med hjälp av en kryptografiskt stark envägs (irreversibel) hashfunktion.

Skapa ett alfanumeriskt lösenord på tio tecken med minst en gemen bokstav, minst en versal bokstav och minst tre siffror:

import string
import secrets
alphabet = string.ascii_letters + string.digits
while True:
    password = ''.join(secrets.choice(alphabet) for i in range(10))
    if (any(c.islower() for c in password)
            and any(c.isupper() for c in password)
            and sum(c.isdigit() for c in password) >= 3):
        break

Generera en XKCD-liknande lösenfras:

import secrets
# On standard Linux systems, use a convenient dictionary file.
# Other platforms may need to provide their own word-list.
with open('/usr/share/dict/words') as f:
    words = [word.strip() for word in f]
    password = ' '.join(secrets.choice(words) for i in range(4))

Generera en tillfällig URL som är svår att gissa sig till och som innehåller en säkerhetstoken som är lämplig för applikationer för återställning av lösenord:

import secrets
url = 'https://example.com/reset=' + secrets.token_urlsafe()