Nett og utvikling

PHP Passordhashing: Argon2id, bcrypt og sikker migrering

PHP Password Hashing: Argon2id, bcrypt and Secure Migration

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

Illustration of the article's main concept

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:

  1. Identifiser legadoformatet ved hjelp av pålitelige metadata eller et entydig, dokumentert format.
  2. Verifiser det sendte passordet ved hjelp av det opprinnelige legado-skjemaet kun for kontoer som fortsatt krever det.
  3. Etter vellykket verifisering, opprett umiddelbart en moderne hash ved hjelp av password_hash().
  4. Erstatt den lagrede legado-hashen ved hjelp av en sikker databaseoppdatering.
  5. 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';
Technical workflow illustration

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.

Offisielle referanser