Web & Ontwikkeling

PHP Password Hashing: Argon2id, bcrypt en Veilige Migratie

PHP Password Hashing: Argon2id, bcrypt and Secure Migration

Leer hoe je wachtwoorden veilig kunt hashen in PHP met Argon2id en bcrypt, kies veilige parameters, verifieer referenties en migreer bestaande hashes zonder verplichte wachtwoordresets.

PHP-wachtwoordhashing: Argon2id, bcrypt en beveiligde migratie

Wachtwoordopslag is een van de belangrijkste beveiligingsbeslissingen in een webtoepassing. Een datalek mag geen onmiddellijk inloggegevens van gebruikers onthullen, maar zwakke wachtwoordhashing kan maken dat gestolen hashes goedkoop te attackeren zijn.

PHP bevat ingebouwde functies voor het hashingen, verifiëren en upgraden van wachtwoorden. De uitdaging is het kiezen van het juiste algoritme, het configureren ervan voor je infrastructuur en het migreren van bestaande accounts zonder authenticatie te onderbreken.

Voor nieuwe toepassingen is over het algemeen de voorkeur voor Argon2id wanneer je PHP-build het ondersteunt. bcrypt blijft een praktische compatibiliteitsoptie. Beide moeten worden gebruikt via de wachtwoord-API van PHP, in plaats van via zelfgemaakt cryptografe.

Deze gids behandelt implementatie, parameterkiezen, migratie van legacy-systemen en veelvoorkomende fouten.

Waarom SHA-256 niet geschikt is voor wachtwoordopslag

SHA-256 is ontworpen om snel te zijn. Dat maakt het nuttig voor integriteitscontroles, maar op zichzelf ongeschikt voor wachtwoordopslag: een aanvaller met gestolen hashes kan snel veel wachtwoordgokken testen.

Speciale wachtwoordhashingalgoritmes verbieden opzettelijk meer bronnen. Argon2id kan substantiële hoeveelheid geheugen en verwerkingssnelheid vereisen, waardoor grootschalig raden duurder wordt.

Een beveiligd opslagsysteem heeft een uniek random zout, een configureerbare werkfactor en een manier om de werkfactor te verhogen naarmate hardware verbetert. De PHP-functie password_hash() genereert en slaat de benodigde zoutinformatie automatisch op.

De OWASP Password Storage Cheat Sheet raadt adaptieve wachtwoordhashing aan in plaats van snelle generieke hashfuncties.

Argon2id vs bcrypt: welke moet je kiezen?

Functie Argon2id bcrypt
Hoofddefensie Geheugen- en berekeningskost Berekingskost
Geheugengehardd Ja Nee
Configureerbare parameters Geheugen, iteraties, parallelisme Kostfactor
Wachtwoordinvoerlimiet Geen bcrypt-achtige 72-byte-limiet 72 bytes
Beschikbaarheid in PHP Hangt af van build Breed beschikbaar
Beste keuze Voorkeur voor nieuwe wachtwoordopslag Compatibiliteit en legacy-systemen

Argon2id is ontworpen om aanvallen te weerstaan die profiteren van massaal parallelle hardware. bcrypt is nog steeds een legitiem adaptief wachtwoordhashingalgoritme, maar zijn invoerlimiet vereist zorg: het houdt maximaal de eerste 72 bytes over, niet tekens.

Veronderstel niet dat PASSWORD_DEFAULT Argon2id selecteert. De PHP password_hash-documentatie documenteert momenteel bcrypt als zijn standaardalgoritme. PHP 8.4 verhoogde de standaardkost van bcrypt van 10 naar 12, wat illustreert waarom het vertrouwen op impliciete parameters de prestaties van een applicatie na upgrades kan veranderen.

Stap 1: Controleer Argon2id-ondersteuning

Argon2id is niet noodzakelijk beschikbaar in elke hostingomgeving. Controleer de runtime voordat je het selecteert:

<?php
declare(strict_types=1);

if(in_array('argon2id', password_algos(), true)) {
    echo 'Argon2id is available';
} else {
    echo 'Argon2id is not available';
}

De beschikbaarheid hangt af van hoe PHP is gebouwd. Veronderstel niet dat het upgraden van de PHP-versie automatisch Argon2id inschakelt.

Stap 2: Hash een wachtwoord met Argon2id

OWASP documenteert verschillende acceptabele baselines. Een gebruikt 19 MiB aan geheugen, twee iteraties en parallelisme van één. PHP laat memory_cost uit in KiB, dus 19 MiB is 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
);

De parallelvormoptie threads wordt ondersteund door sommige Argon2-backends, waaronder libargon2, maar niet elke PHP-build. Indien ondersteund, komt een waarde van één overeen met deze baseline; het weglaten ervan is mobieler. Benchmark je daadwerkelijke configuratie.

De resulterende geencodeerde hash bevat het algoritme-ID, parameters en zout. Er is geen behoefte om die waarden in aparte databasekolommen op te slaan. Een kolom VARCHAR(255) is een redelijke start voor moderne wachtwoordhashes, mits deze de volledige geencodeerde waarde opslaat.

Dit zijn baselineparameters, geen universele productieconfiguratie. Test latentie en geheugengebruik onder realistische gelijktijdige authenticatietraffic.

Stap 3: Verifieer inloggegevens correct

Illustration of the article's main concept

Omdat elke wachtwoordhash een random zout gebruikt, werkt het genereren van een nieuwe hash en vergelijken van strings niet. Gebruik 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.

De PHP-documentatie specificeert dat password_verify() veilig is tegen timing-aanvallen. Hij leest het algoritme en de werkparameters uit de opgeslagen hash.

Wachtwoordverificatie vervangt niet het throttlen van logins, beveiligde sessies, HTTPS, passende foutafhandeling of multifactorauthenticatie.

Stap 4: Upgrade bestaande wachtwoordhashes tijdens login

password_needs_rehash() detecteert wanneer een opgeslagen hash een verouderd algoritme of parameters gebruikt. Dit maakt geleidelijke migratie mogelijk zonder elke actieve gebruiker zijn wachtwoord te laten resetten.

<?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.
}

Herhash alleen na het succesvol verifiëren van het ingediende wachtwoord. Een voorwaardelijke update kan ervoor zorgen dat de opgeslagen hash nog steeds overeenkomt met de net geverifieerde waarde. Bijvoorbeeld, werk de wachtwoordhash alleen bij waar zowel de gebruikers-ID als de oude hash overeenkomen.

Zie PHP password_needs_rehash() voor API-details.

Stap 5: Migreer legacy MD5- of SHA-1-hashes

Oudere toepassingen kunnen MD5, SHA-1 of eigen wachtwoordformaten bevatten. Dergelijke hashes kunnen niet altijd worden geverifieerd met password_verify().

Een migratie moet een begeleide reeks volgen:

  1. Identificeer het legacy-formaat met behulp van vertrouwbare metadata of een ondubbelzinnig, gedocumenteerd formaat.
  2. Verifieer het ingediende wachtwoord met behulp van het oorspronkelijke legacy-schema alleen voor accounts dat dit nog nodig hebben.
  3. Maak na succesvolle verificatie direct een moderne hash met behulp van password_hash().
  4. Vervang de opgeslagen legacy-hash met een veilige database-update.
  5. Beëindig de legacy-verificatie wanneer de migratie is voltooid.

Raad niet om het algoritme alleen af te leiden van de hashlengte wanneer meerdere formaten mogelijk zijn. Probeer niet om wachtwoordhashes te decrypten: hashing is geen encryptie.

Voor accounts die zich nooit aanmelden, overweeg een wachtwoordresetbeleid in plaats van zwakke hashes voor altijd op te slaan. Stel geen onbeveiligde fallbackpad in dat zwakke hashes accepteert voor nieuw geregistreerde gebruikers.

Stap 6: Benchmark hashing op je infrastructuur

De juiste kostparameters hangen af van je hardware, gelijktijdige inlogvolume en latentievereisten.

<?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

Voer deze uit alleen in een begeleide omgeving, niet als openbare webendpoint. Meet ook verificatie en herhaal dit onder representatieve belasting. Een instelling die in isolatie snel lijkt, kan RAM opbranden wanneer veel verzoeken tegelijkertijd binnenkomen.

OWASP raadt aan de beveiliging in balans te brengen met operationele capaciteit en doorgaans individuele hashingbewegingen onder één seconde te houden.

Veelvoorkomende wachtwoordhashingfouten

Het handmatig toevoegen van een vast zout. PHP genereert al beveiligde salts voor zijn wachtwoord-API. Een vast zout verwijdert een belangrijke bescherming.

Het gebruik van pure MD5, SHA-1 of SHA-256. Deze algoritmes zijn op hun eigen veel te snel voor wachtwoordopslag.

Het negeren van bcrypts 72-bytelimiet. Meervoudbyte-UTF-8-tekens kunnen dit limiet eerder bereiken dan gebruikers verwachten.

Het kiezen van extreme kostinstellingen. Overmatige geheugen- of CPU-eisen kunnen een denial-of-service-risico creëren op authenticatie-endpoints.

Het loggen van ingediende wachtwoorden. Vermijd het blootleggen van inloggegevens via debugginglogs, monitoringystemen of foutrapporten.

Het aannemen dat wachtwoordhashing authenticatiebeveiliging oplost. Tarieflimiting, reactie op datalekken, sessiebeveiliging en multifactorauthenticatie zijn nog van belang.

Moet je een pepper gebruiken?

Een pepper is een extra gedeeld geheim dat buiten de wachtwoorddatabase wordt bewaard. In tegenstelling tot een zout wordt deze niet naast elke hash opgeslagen.

Een goed ontworpen pepper kan diepe verdediging bieden als een aanvaller alleen de database steelt. Maar het gebruik van een pepper introduceert complexiteit voor sleutelbeheer en rotatie: het verliezen of draaien van een pepper kan het resetten van wachtwoorden vereisen.

Improviseer niet door een hardcoded geheim aan elk wachtwoord toe te voegen. Volg een gedocumenteerd strategie, sla geheimen apart op en plan voor rotatie. OWASP bespreekt pre-hashing- en post-hashing-pepperbenaderingen.

Een praktijkgerichte wachtwoordhashingbeleid

Voor een nieuwe PHP-toepassing is de voorkeur voor Argon2id wanneer beschikbaar, begin met een OWASP-gealigneerde configuratie, benchmark het en sla de volledige geencodeerde hash op. Wanneer Argon2id niet beschikbaar is, is bcrypt via de PHP-wachtwoord-API een praktische alternatief als de kost en invoerlimiet zijn begrepen.

Voor een bestaande toepassing blijf ondersteunde legacy-hashes verifiëren terwijl je ze upgradet na succesvolle authenticatie. Vermijd disruptieve migraties wanneer het oorspronkelijke wachtwoord niet beschikbaar is.

Ontwerp vanaf het begin voor upgrades. Hardware en aanbevelingen veranderen; je authenticatiesysteem moet beter kunnen parameters en algoritmes adopteren zonder het wachtwoord van elke gebruiker in één keer te wijzigen.

Veelgestelde vragen

Is Argon2id beter dan bcrypt?

Argon2id biedt configureerbare geheugengehardd en is de voorkeur van OWASP voor nieuwe wachtwoordopslagimplementaties.

Gebruikt PHP standaard Argon2id?

Nee. PHP's PASSWORD_DEFAULT selecteert momenteel bcrypt. Gebruik PASSWORD_ARGON2ID indien ondersteund expliciet.

Kan ik bcrypt-hashes migreren zonder wachtwoordresets?

Ja. Verifieer de bestaande hash, en hersh na een succesvolle login de ingediende wachtwoord.

Moet ik het zout apart opslaan?

Nee. De wachtwoordhashting-API van PHP genereert het zout en slaat de benodigde informatie op in de geencodeerde hash.

Is SHA-256 veilig voor wachtwoorden?

Niet op zichzelf. Gebruik een speciale adaptieve wachtwoordhashingalgoritme in plaats van pure SHA-256.

Officiële referenties