Hou wat jy veilig hou.
Hoekom dit saak maak Selfs 'n versigtige webwerf hou van data: 'n e-pos om in te teken, 'n wagwoord, dalk 'n adres vir aflewerings. Databases word gekopieer, rugopnames gaan verlore, skootrekenaars word gesteel. As dit goed gedoen word, vertel 'n gesteelde kopie van jou database byna niks vir die dief nie. Hierdie les dek die twee hoofgereedskap: password hashing en die enkripsie van velde by rus.
Wagwoorde: moenie dit stoor nie, stoor 'n stadige vingerafdruk
Dink aan 'n blender. Gooi 'n stroberi in en jy kry 'n smoothie; jy kan nie die stroberi terugkry nie. Om 'n wagwoord te kontroleer, meng jy die poging op dieselfde manier en kyk of die smoothie ooreenstem. Jy het nooit die oorspronklike een nodig nie.
Wagwoordhash: 'n eenweg-vingerafdruk van 'n wagwoord, gemaak met 'n funksie wat doelbewus stadig is en 'n salt gebruik, sodat gesteelde hashes baie duur is om te raai.
Salt: willekeurige bytes wat langs elke hash gestoor word en voor die hashing gemeng word, sodat twee mense met dieselfde wagwoord verskillende hashes kry en vooraf berekende raai-lyste nutteloos is.
Hoekom so stadig? 'n Vinnige hash soos plain SHA-256 kan miljarde kere per sekonde probeer, so kort wagwoorde val vinnig. Wagwoord-hashes is aangepas om 'n merkbare breuk van 'n sekonde elk te neem. Dit is niks vir een aanmelding nie en 'n enorme kosting vir iemand wat 'n miljard rase probeer. Die algemeen gebruikte keuses is Argon2id (die eerste aanbeveling in OWASP se wagwoordberging-riglyn), scrypt, bcrypt en PBKDF2 (nasien Oktober 2026).
# Teaching code. In a real app, use your framework's password functions.
import hashlib, hmac, os
ROUNDS = 600_000 # PBKDF2-HMAC-SHA256 setting suggested by OWASP (checked October 2026)
def hash_password(password):
salt = os.urandom(16)
key = hashlib.pbkdf2_hmac("sha256", password.encode(), salt, ROUNDS)
return salt.hex() + "$" + key.hex()
def check_password(password, stored):
salt_hex, key_hex = stored.split("$")
key = hashlib.pbkdf2_hmac("sha256", password.encode(), bytes.fromhex(salt_hex), ROUNDS)
return hmac.compare_digest(key.hex(), key_hex) # compare without leaking timingIn Django skryf jy nie dit self nie: user.set_password() en check_password() gebruik reeds PBKDF2 by verstek, en Django kan na Argon2 of scrypt oorskakel in settings (nasien Oktober 2026).
'n algemene wanbelewing: "ons enkripeer ons wagwoorde". Enkripsie kan ongedoen word deur enigiemand wat die sleutel het, so een gesteelde sleutel onthul elke wagwoord. Wagwoorde moet gehash word, nooit enkripieer nie.
Ander velde: enkripteer by rus, hou die sleutel elders
'n E-posadres moet weer leesbaar wees (om 'n kwitansie te stuur), so 'n eenweg-hash sal nie help nie. Hier jy encrypt: sluit die waarde met 'n sleutel, en ontsluit dit net wanneer die app dit nodig het.
Enkripsing by rus: stoor data in die databasis of op die skif in gesluit vorm, sodat 'n kopie van die lêers onleesbaar is sonder die sleutel.
- Hou die sleutel uit die database, byvoorbeeld in 'n omgewingsveranderlike of 'n sleuteldiens. 'n Sleutel wat in dieselfde rugopslag as die data gestoor word, beskerm niks nie.
- Gebruik 'n gesertifiseerde biblioteek, nooit selfgemaakte kriptografie nie. In Python is die
Fernetvan diecryptography-pakket 'n eenvoudige, veilige keuse. - Kyk dinge op. Goeie enkripsie gee elke keer 'n ander resultaat, selfs vir dieselfde e-pos, so jy kan nie daarna soek nie. Stoor 'n keyed hash langs dit, 'n HMAC ( 'n hash gemeng met 'n geheime sleutel), en soek daarby. Sonder die sleutel kan die HMAC nie met brute-force gekraak word soos 'n gewone hash nie.
# Concept sketch (needs: pip install cryptography)
from cryptography.fernet import Fernet
import hmac, hashlib
box = Fernet(ENCRYPTION_KEY) # key from the environment
email_enc = box.encrypt(email.encode()) # stored, readable only with the key
email_lookup = hmac.new(LOOKUP_KEY, email.strip().lower().encode(), hashlib.sha256).hexdigest()So werk floati.life se eie bladsyt-waglys: die e-pos word verskroe gestoor, duplikate word met 'n keyed HMAC van die adres gevind, en net 'n hash van die IP-adres word vir rate limiting gehou. Die Learn "save across devices" funksie gaan verder en stoor nooit die e-pos glad nie, net 'n keyed fingerprint, met vordering verskroe (nasien Oktober 2026).
Wat dit beskerm, en wat dit nie beskerm nie
Encryption at rest beskerm teen 'n gesteelde rugkop, 'n gekopieerde database of 'n verlore disk. Dit not beskerm teen 'n aanvaller wat kode binne jou app hardloop, omdat jou app die sleutel hou. Dit is waarom die versameling van minder (les 76) en die skrap betyds (volgende les) steeds die belangrikste is.
In ander tale
// JavaScript (Node): password hashing with built-in scrypt
const salt = crypto.randomBytes(16);
const key = crypto.scryptSync(password, salt, 64);// Go
hash, _ := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)// PHP (Argon2id where available)
$hash = password_hash($password, PASSWORD_ARGON2ID);
$ok = password_verify($attempt, $hash);// C# (ASP.NET Core Identity)
var hash = new PasswordHasher<User>().HashPassword(user, password);Opsomming
- Hash wagwoorde met 'n stadige, gesoute funksie (Argon2id, scrypt, bcrypt of PBKDF2); enkripteer hulle nooit nie.
- Verschuil velde wat jy moet teruglees, hou die sleutel buite die databasis, en soek hulle op met 'n keyed HMAC.
- Enkripsing by rus stop gesteelde kopies, nie 'n aanvaller binne jou besiggestelde app nie.
Sien jy 'n probleem in hierdie les? Rapporteer dit · Vra oor hierdie les
Hierdie oefening open binnekort
Voltooi die lesie voor dit en hierdie een sal ontvanklik wees. Die hele kursus is gratis, geen rekening nodig nie, en jy kan hierdie les nou lees.
Hierdie blutser blokkeer koekies vir learn.floati.life, so lesse wat jy hier voltooi het kan nie in volgorde oopgaan nie. Laat koekies vir hierdie webwerf toe en laai nuut.