Webb & utveckling

PHP-lösenordshashning: Argon2id, bcrypt och säker migrering

PHP Password Hashing: Argon2id, bcrypt and Secure Migration

Lär dig hur du säkert hashar lösenord i PHP med Argon2id och bcrypt, välj säkra parametrar, verifiera uppgifter och migrera befintliga hash utan att tvinga lösenordsåterställningar.

PHP-lösenordshashing: Argon2id, bcrypt och säker migrering

Att lagra lösenord är en av de viktigaste säkerhetsåtgärderna i en webbaserad applikation. Ett dataintrång bör inte omedelbart avslöja användarnas autentiseringsuppgifter, men svag lösenordshashing kan göra stulna hashar billiga att attackera.

PHP har inbyggda funktioner för att hashvärdera, verifiera och uppgradera lösenord. Utmaningen är att välja rätt algoritm, konfigurera den för din infrastruktur och migrera befintliga konton utan att störa autentiseringen.

För nya applikationer är Argon2id vanligtvis det föredragna valet när din PHP-version stöder det. Bcrypt är fortfarande ett praktiskt kompatibilitetsalternativ. Båda bör användas via PHP:s lösenord API, snarare än via egenutvecklad kryptografi.

Den här guiden täcker implementering, parameterval, legacy-migrering och vanliga misstag.

Varför är SHA-256 inte lämplig för lösenordslagring?

SHA-256 är utformad för att vara snabb, vilket gör den användbar för integritetskontroller men olämplig för lösenordslagring i sig: en angripare med stulna hashar kan snabbt testa många lösenordsgissningar.

Dedikerade lösenordshashingalgoritmer förbrukar avsiktligt fler resurser. Argon2id kan kräva betydande minnesanvändning samt beräkningstid, vilket gör storskalig gissning dyrare.

Ett säkert lagringssystem behöver en unik, slumpmässig salt, en konfigurerbar arbetsfaktor och ett sätt att öka arbetsfaktorn när hårdvaran förbättras. PHP:s password_hash() genererar och lagrar den nödvändiga saltinformationen automatiskt.

OWASP Password Storage Cheat Sheet rekommenderar adaptiv lösenordshashing istället för snabba, generiska hashfunktioner.

Argon2id vs bcrypt: vilket bör du välja?

Funktion Argon2id Bcrypt
Huvudsakligt försvar Minnes- och beräkningskostnad Beräkningskostnad
Minnehård Ja Nej
Konfigurerbara parametrar Minne, iterationer, parallellditet Kostnadsfaktor
Gräns för lösenordstext Ingen bcrypt-liknande 72-byte-gräns 72 byte
Tillgänglighet i PHP Beror på byggandet Allmänt tillgänglig
Bästa lämplighet Föredragen för ny lösenordslagring Kompatibilitet och legacy-system

Argon2id är utformad för att motstå attacker som drar nytta av massivt parallell hårdvara. Bcrypt är fortfarande en legitim adaptiv lösenordshashingalgoritm, men dess ingränsning kräver omsorg: den beaktar högst de första 72 bytarna, inte tecken.

Anta inte att PASSWORD_DEFAULT väljer Argon2id. PHPs password_hash-dokumentation anger för närvarande bcrypt som dess standardalgoritm. PHP 8.4 höjde bcrypt-standardkostnaden från 10 till 12, vilket illustrerar att förlita sig på implicita parametrar kan förändra applikationens prestanda efter uppgraderingar.

Steg 1: Kontrollera stöd för Argon2id

Argon2id är inte nödvändigtvis tillgänglig i alla webbhotellsmiljöer. Kontrollera runtime innan du väljer den:

<?php
declare(strict_types=1);

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

Tillgängligheten beror på hur PHP byggdes. Anta inte att en uppgradering av PHP-versionen automatiskt aktiverar Argon2id.

Steg 2: Hasha ett lösenord med Argon2id

OWASP dokumenterar flera acceptabla basuppsättningar. En använder 19 MiB minne, två iterationer och parallellditet på ett. PHP uttrycker memory_cost i KiB, så 19 MiB är 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
);

Parallellditetsalternativet threads stöds med vissa Argon2-backends, inklusive libargon2, men inte varje PHP-bygge. Om det stöds matchar ett värde på ett denna bas; att utelämna det är mer portabelt. Benchmarka din faktiska konfiguration.

Det resulterande kodade hashet inkluderar algoritmidentifieraren, parametrar och salt. Det finns inget behov av att spara dessa värden i separata datakolumner. En VARCHAR(255)-kolumn är en rimlig utgångspunkt för moderna lösenordshashar, förutsatt att den lagrar hela det kodade värdet.

Dessa är basparametrar, inte en universell produktionskonfiguration. Testa latens och minnesanvändning under realistisk samtidlig autentiseringstrafik.

Steg 3: Verifiera autentiseringsuppgifter korrekt

Illustration of the article's main concept

Eftersom varje lösenordshash använder en slumpmässig salt, kommer generering av en ny hash och jämförelse av strängar inte att fungera. Använd 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-dokumentationen anger att password_verify() är säker mot timingattacker. Den läser algoritmen och arbetsparametrarna från den lagrade hashen.

Lösenordverifiering ersätter inte inloggningströskelvärden, säkra sessioner, HTTPS, lämplig felhantering eller multifaktorautentisering.

Steg 4: Uppgradera befintliga lösenordshashar under inloggning

password_needs_rehash() upptäcker när en lagrad hash använder en föråldrad algoritm eller parametrar. Detta möjliggör gradvis migrering utan att tvinga varje aktiv användare att återställa sitt lösenord.

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

Omshhasha endast efter att du framgångsrikt verifierat det inlämnade lösenordet. En villkorsuppdatering kan säkerställa att den lagrade hashen fortfarande matchar det värde som just verifierades. Exempel: uppdatera lösenordshashen endast där både användar-ID och gammal hash matchar.

Se PHPs password_needs_rehash() för API-detaljer.

Steg 5: Migrera legacy MD5 eller SHA-1-hashar

Äldre applikationer kan innehålla MD5, SHA-1 eller anpassade lösenordsformat. Sådana hashar kan inte alltid verifieras med password_verify().

En migration bör följa en kontrollerad sekvens:

  1. Identifiera legacyformatet med hjälp av betrodd metadata eller ett entydigt, dokumenterat format.
  2. Verifiera det inlämnade lösenordet med den ursprungliga legacy-metoden endast för konton som fortfarande kräver det.
  3. Efter framgångsrik verifiering, skapa omedelbart en modern hash med password_hash().
  4. Ersätt den lagrade legacyhashen med en säker databasuppdatering.
  5. Ta bort legacyverifiering när migrationen är klar.

Gissa inte algoritmen enbart utifrån hashlängden när flera format är möjliga. Försök inte att dekryptera lösenordshashar: hashing är inte kryptering.

För konton som aldrig loggar in, överväg en lösenordsåterställnings-policy istället för att behålla svaga hashar på obestämd tid. Introducera inte en osäker fallbackväg som accepterar svaga hashar för nya registrerade användare.

Steg 6: Benchmarka hashning på din infrastruktur

De rätta kostnadsparametrarna beror på din hårdvara, samtidiga inloggningsvolym och latenskrav.

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

Kör detta endast i en kontrollerad miljö, inte som en offentlig webbterminal. Mät även verifiering och upprepa under representativ belastning. En inställning som ser snabb ut i isolering kan förbruka RAM när många förfrågningar anländer samtidigt.

OWASP rekommenderar att balansera säkerhet med driftskapacitet och generellt hålla enskilda hashningsoperationer under en sekund.

Vanliga misstag vid lösenordshashing

Lägga till en fast salt manuellt. PHP genererar redan säkra salter för sitt lösenord API. En fast salt tar bort en viktig skydd.

Använda rå MD5, SHA-1 eller SHA-256. Dessa algoritmer är för snabba för lösenordslagring i sig.

Ignorera bcrypts 72-byte-gräns. Multibyte UTF-8-tecken kan nå denna gräns snabbare än användare förväntar sig.

Välja extrema kostnadsinställningar. Överdrivna minnes- eller CPU-krav kan skapa risk för tjänstebehållande vid autentiseringsändpunkter.

Logga inlämnade lösenord. Undvik att exponera autentiseringsuppgifter genom debugloggar, övervakningssystem eller felrapporter.

Anta att lösenordshashing löser autentiseringssäkerheten. Ratelimiting, intrångssvar, sessionssäkerhet och multifaktorautentisering är fortfarande viktiga.

Borde du använda en pepper?

En pepper är en ytterligare delad hemlighet som lagras utanför lösenorddatabasen. Till skillnad från en salt lagras den inte tillsammans med varje hash.

En korrekt designad pepper kan tillhandahålla försvar i djupet om en angripare stjäl endast databasen. Men peppering introducerar komplexitet i nyhantering och rotation: att förlora eller rotera en pepper kan kräva lösenordsåterställningar.

Improvisera inte genom att konkatenara en hårdkodad hemlighet till varje lösenord. Följ en dokumenterad strategi, lagra hemligheter separat och planera för rotation. OWASP diskuterar pre-hashning och post-hashning av pepper-metoder.

En praktisk lösenordshashingpolicy

För en ny PHP-applikation, föredra Argon2id när det är tillgängligt, börja med en OWASP-konfigurerad inställning, benchmarka den och lagra hela det kodade hashet. Om Argon2id inte är tillgänglig är bcrypt via PHPs lösenord API ett praktiskt alternativ om dess kostnad och ingränsning förstås.

För en befintlig applikation, fortsätt att verifiera stödjd legacyhashar medan du uppgraderar dem efter framgångsrik autentisering. Undvik störande migrationer när det ursprungliga lösenordet inte är tillgängligt.

Designa för uppgraderingar från början. Hårdvara och rekommendationer förändras; ditt autentiseringssystem bör kunna anpassa bättre parametrar och algoritmer utan att ändra varje användares lösenord på en gång.

Vanliga frågor

Är Argon2id bättre än bcrypt?

Argon2id erbjuder konfigurerbar minneshårdhet och är OWASP:s föredragna val för nya lösenordslagringsimplementationer.

Använder PHP Argon2id som standard?

Nej. PHPs PASSWORD_DEFAULT väljer för närvarande bcrypt. Använd PASSWORD_ARGON2ID uttryckligen när det stöds.

Kan jag migrera bcrypt-hashar utan lösenordsåterställningar?

Ja. Verifiera den befintliga hashen, sedan omhasha det inlämnade lösenordet efter en framgångsrik inloggning.

Bör jag lagra saltet separat?

Nej. PHPs lösenordshashing-API genererar saltet och lagrar den nödvändiga informationen i det kodade hashet.

Är SHA-256 säkert för lösenord?

Inte i sig. Använd en dedikerad adaptiv lösenordshashingalgoritm istället för rå SHA-256.

Officiella referenser