PHP Passordhashing: Argon2id, bcrypt og sikker migrering
Lær hvordan du sikkert kan hashe passord i PHP ved å bruke Argon2id og bcrypt, velg trygge parametere, verifiser legitimasjon og migrer eksisterende hasher uten å tvinge til passordresetting.
PHP Passord-hashing: Argon2id, bcrypt og sikker migrering
Passordlagring er en av de viktigste sikkerhetsbeslutningene i en webapplikasjon. Et databaselekkasje skal ikke umiddelbart avsløre brukeres legitimationsopplysninger, men svak passord-hashing kan gjøre stjålne hashes billige å angripe.
PHP inneholder innebygde funksjoner for hashing, verifisering og oppgradering av passord. Utfordringen er å velge riktig algoritme, konfigurere den for din infrastruktur og migrere eksisterende kontoer uten å forstyrre autentisering.
For nye applikasjoner er Argon2id generelt det foretrukne valget når din PHP-bygging støtter det. bcrypt forblir et praktisk kompatibilitetsalternativ. Begge bør brukes gjennom PHP sitt passord-API, heller enn gjennom hjemmelaget kryptografi.
Denne guiden dekker implementering, parameterutvelgelse, migrering av legadoer og vanlige feil.
Hvorfor SHA-256 ikke er egnet for passordlagring
SHA-256 er designet for å være raskt. Det gjør det nyttig for integritetssjekker, men uegnet alene for passordlagring: en angriper med stjålne hashes kan teste mange passordgjetninger raskt.
Dedikerte passord-hashing-algoritmer bruker med vilje mer ressurser. Argon2id kan kreve betydelig minne i tillegg til prosesseringstid, noe som gjør storskalet gjetning dyrere.
Et sikkert lagringssystem trenger en unik tilfeldig salt, en konfigurerbar arbeidsfaktor og en måte å øke arbeidsfaktoren på når maskinvare forbedres. PHP sin password_hash() genererer og lagrer den nødvendige saltinformasjonen automatisk.
OWASP Password Storage Cheat Sheet anbefaler adaptiv passord-hashing heller enn raske generelle hash-funksjoner.
Argon2id vs bcrypt: hva skal du velge?
| Egenskap | Argon2id | bcrypt |
|---|---|---|
| Hovedforsvar | Minne- og beregningskostnad | Beregningskostnad |
| Minne-hård | Ja | Nei |
| Konfigurerbare parametere | Minne, iterasjoner, parallellitet | Kostnadsfaktor |
| Passord input-grense | Ingen bcrypt-stil 72-byte grense | 72 bytes |
| Tilgjengelighet i PHP | Avhenger av bygging | Brede tilgjengelig |
| Bestegnet | Foretrukket for ny passordlagring | Kompatibilitet og legado-systemer |
Argon2id er designet for å motstå angrep som dra nytte av massivt parallell maskinvare. bcrypt er fortsatt en legitim adaptiv passord-hashing-algoritme, men dets input-grense krever forsiktighet: den betraktar høyst de første 72 bytes, ikke tegn.
Anta ikke at PASSWORD_DEFAULT velger Argon2id. PHP password_hash dokumentasjonen dokumenterer for tiden bcrypt som standardalgoritme. PHP 8.4 økte bcrypt sin standardkostnad fra 10 til 12, som illustrerer hvorfor å stole på implisitte parametere kan endre applikasjonsytelse etter oppgraderinger.
Trinn 1: Sjekk Argon2id-støtte
Argon2id er nødvendigvis ikke tilgjengelig i hvert hosting-miljø. Sjekk kjøretid før du velger det:
<?php
declare(strict_types=1);
if(in_array('argon2id', password_algos(), true)) {
echo 'Argon2id is available';
} else {
echo 'Argon2id is not available';
}
Tilgjengelighet avhenger av hvordan PHP ble bygget. Anta ikke at oppgradering av PHP-versjon automatisk aktiverer Argon2id.
Trinn 2: Hash et passord med Argon2id
OWASP dokumenterer flere akseptable basis-konfigurasjoner. En bruker 19 MiB minne, to iterasjoner og parallellitet på en. PHP uttrykker memory_cost i KiB, så 19 MiB er 19 * 1024 KiB.
<?php
declare(strict_types=1);
$options = [
'memory_cost' => 19 * 1024,
'time_cost' => 2
];
$password = 'example-user-password';
$hash = password_hash(
$password,
PASSWORD_ARGON2ID,
$options
);
Parallellitetsalternativet threads støttes med noen Argon2-backends, inkludert libargon2, men ikke hver PHP-bygging. Hvis støttet, matcher en verdi på en denne basislinjen; å utelate det er mer bærbart. Benchmark din aktuelle konfigurasjon.
Den resulterende kodede hashen inkluderer algoritmeidentifikator, parametere og salt. Det er ikke behov for å lagre disse verdiene i separate databasekolonner. En VARCHAR(255)-kolonne er et rimelig utgangspunkt for moderne passord-hashes, forutsatt at den lagrer den hele kodede verdien.
Dette er basisparametere, ikke en universell produksjonskonfigurasjon. Test latency og minnebruk under realistisk samtidig autentiseringstrafikk.
Trinn 3: Verifiser legitimasjon riktig

Fordi hvert passord-hash bruker en tilfeldig salt, vil generering av en ny hash og sammenligning av strenger ikke fungere. Bruk password_verify():
<?php
declare(strict_types=1);
$submittedPassword = (string)($_POST['password'] ?? '');
$storedHash = (string)$user['password_hash'];
if(!password_verify($submittedPassword, $storedHash)) {
// Reject authentication without disclosing account existence.
return;
}
// The password is valid. Continue with secure session handling.
PHP dokumentasjonen spesifiserer at password_verify() er sikker mot timing-angrep. Den leser algoritme og arbeidsparametere fra den lagrede hashen.
Passordverifisering erstatter ikke innloggingsbegrensning, sikre økter, HTTPS, passende feilhåndtering eller multifaktor-autentisering.
Trinn 4: Oppgrader eksisterende passord-hashes under innlogging
password_needs_rehash() oppdager når en lagret hash bruker en foreldet algoritme eller parametere. Dette aktiverer gradvis migrering uten å tvinge hver aktive bruker til å nullstille passordet sitt.
<?php
declare(strict_types=1);
$options = [
'memory_cost' => 19 * 1024,
'time_cost' => 2
];
if(password_verify($submittedPassword, $storedHash)) {
if(password_needs_rehash(
$storedHash,
PASSWORD_ARGON2ID,
$options
)) {
$newHash = password_hash(
$submittedPassword,
PASSWORD_ARGON2ID,
$options
);
// Persist with a prepared statement.
// Prefer a conditional UPDATE to avoid overwriting
// a newer hash from a concurrent request.
}
// Finish authentication and rotate the session identifier.
}
Bare rehash etter vellykket verifisering av det sendte passordet. En betinget oppdatering kan sikre at den lagrede hashen fortsatt matcher verdien som nettopp ble verifisert. For eksempel, oppdater passord-hashen bare der både bruker-ID og gammel hash matcher.
Se PHP password_needs_rehash() for API-detaljer.
Trinn 5: Migrer legado MD5 eller SHA-1 hashes
Eldre applikasjoner kan inneholde MD5, SHA-1 eller egendefinerte passordformater. Slik hashes kan ikke alltid verifiseres med password_verify().
En migrering bør følge en kontrollersekvens:
- Identifiser legadoformatet ved hjelp av pålitelige metadata eller et entydig, dokumentert format.
- Verifiser det sendte passordet ved hjelp av det opprinnelige legado-skjemaet kun for kontoer som fortsatt krever det.
- Etter vellykket verifisering, opprett umiddelbart en moderne hash ved hjelp av
password_hash(). - Erstatt den lagrede legado-hashen ved hjelp av en sikker databaseoppdatering.
- Avvikle legado-verifisering når migrering er fullført.
Gjet ikke algoritme kun fra hash-lengde når flere formater er mulige. Forsøk ikke å dekryptere passord-hashes: hashing er ikke kryptering.
For kontoer som aldri logger inn, vurder en passord-nullstillingspolicy snarere enn å beholde svake hashes uendelig. Ikke introduser en usikker fallback-sti som aksepterer svake hashes for nylig registrerte brukere.
Trinn 6: Benchmark hashing på din infrastruktur
De riktige kostnadsparametrene avhenger av din maskinvare, samtidig innloggingsvolum og krav til latency.
<?php
declare(strict_types=1);
$options = [
'memory_cost' => 19 * 1024,
'time_cost' => 2
];
$start = hrtime(true);
$hash = password_hash(
'benchmark-password',
PASSWORD_ARGON2ID,
$options
);
$milliseconds = (hrtime(true) - $start) / 1_000_000;
echo round($milliseconds, 2) . ' ms';

Kjør dette kun i et kontrollert miljø, ikke som en offentlig web-endepunkt. Mål også verifisering, og gjenta under representativ last. En innstilling som ser rask ut i isolasjon kan utslukke RAM når mange forespørsler ankommer samtidig.
OWASP anbefaler å balansere sikkerhet med operativ kapasitet og generelt holde enkelte hashing-operasjoner under ett sekund.
Vanlige passord-hashing-feil
Å legge til en fast salt manuelt. PHP genererer allerede sikre salter for sitt passord-API. En fast salt fjerner en viktig beskyttelse.
Å bruke rå MD5, SHA-1 eller SHA-256. Disse algoritmene er langt for raske for passordlagring alene.
Å ignorere bcrypt sin 72-byte-grense. Flere-bytes UTF-8-tegn kan nå denne grensen tidligere enn brukere forventer.
Å velge ekstreme kostnadsinnstillinger. Overdreven minne- eller CPU-krav kan skape denial-of-service-risiko ved autentisering-endepunkter.
Å logge sendte passord. Unngå å eksponere legitimasjon gjennom feilsøkingslogger, overvåkingssystemer eller feilrapporter.
Å anta at passord-hashing løser autentiseringssikkerhet. Rate limiting, bruddrespons, øktssikkerhet og multifaktor-autentisering betyr fortsatt noe.
Bør du bruke en pepper?
En pepper er en ekstra delt hemmelighet holdt utenfor passord-databasen. I motsetning til en salt, lagres den ikke sammen med hver hash.
En ordentlig designet pepper kan gi defense in depth hvis en angriper stjeler bare databasen. Men peppering introduserer nøkkeladministrasjons- og rotasjonskompleksitet: tap eller rotasjon av en pepper kan kreve passord-nullstillinger.
Improviser ikke ved å koble en hardkodet hemmelighet til hvert passord. Følg en dokumentert strategi, lagre hemmeligheter separat og planlegg for rotasjon. OWASP diskuterer pre-hashing og post-hashing pepper-tilnærminger.
En praktisk passord-hashing-policy
For en ny PHP-applikasjon, foretrekk Argon2id når tilgjengelig, start med en OWASP-justeret konfigurasjon, benchmark den og lagre den komplette kodede hashen. Der Argon2id er utilgjengelig, er bcrypt gjennom PHP sitt passord-API et praktisk alternativ hvis dets kostnad og input-grense forstås.
For en eksisterende applikasjon, fortsett å verifisere støttede legado-hashes mens du oppgraderer dem etter vellykket autentisering. Unngå forstyrrende migreringer når det opprinnelige passordet ikke er tilgjengelig.
Design for oppgraderinger fra begynnelsen. Maskinvare og anbefalinger endres; ditt autentiseringssystem skal kunne adoptere bedre parametere og algoritmer uten å endre hver bruker sitt passord på en gang.
Vanlige spørsmål
Er Argon2id bedre enn bcrypt?
Argon2id tilbyr konfigurerbar minne-hardhet og er OWASP sitt foretrukne valg for nye passordlagringsimplementeringer.
Bruker PHP Argon2id som standard?
Nei. PHP sin PASSWORD_DEFAULT velger for tiden bcrypt. Bruk PASSWORD_ARGON2ID eksplisitt når støttet.
Kan jeg migrere bcrypt-hashes uten passord-nullstillinger?
Ja. Verifiser den eksisterende hashen, rehash deretter det sendte passordet etter en vellykket innlogging.
Bør jeg lagre saltet separat?
Nei. PHP sitt passord-hashing-API genererer saltet og lagrer den nødvendige informasjonen i den kodede hashen.
Er SHA-256 sikker for passord?
Ikke alene. Bruk en dedikert adaptiv passord-hashing-algoritme heller enn rå SHA-256.