Hur man hash och verifierar ett lösenord i Node.js med bcrypt

Ett av de bästa sätten att lagra lösenord på ett säkert sätt är att salta och hasha dem. Saltning och hash konverterar ett vanligt lösenord till ett unikt värde som är svårt att vända. Bcrypt-biblioteket låter dig hasha och salta lösenord i Node.js med mycket liten ansträngning.

Vad är Password Hashing?

Lösenordshasning innebär att skicka ett lösenord med vanlig text genom en hashalgoritm för att generera ett unikt värde. Några exempel på hashalgoritmer är bcrypt, scrypt och SHA. Nackdelen med hash är att det är förutsägbart.

Varje gång du skickar samma indata till en hashalgoritm kommer den att generera samma utdata. En hackare med tillgång till det hashade lösenordet kan omvända krypteringen för att få det ursprungliga lösenordet. De kan använda tekniker som t.ex brute-force attacker eller regnbågsbord. Det är här saltning kommer in.

Vad är lösenordssaltning?

Lösenordssaltning lägger till en slumpmässig sträng (saltet) till ett lösenord innan det hashas. På så sätt kommer hashen som genereras alltid att vara olika varje gång. Även om en hackare skaffar det hashade lösenordet är det opraktiskt för dem att upptäcka det ursprungliga lösenordet som genererade det.

Hur man använder bcrypt för att hasha och verifiera ett lösenord

bcrypt är en npm-modul som förenklar lösenordssaltning och hash.

Steg 1: Installera bcrypt

Använder npm:

npm Installera bcrypt

Använder garn:

garn lägg till bcrypt

Steg 2: Importera bcrypt

konst bcrypt = behöva("bcrypt")

Steg 3: Skapa ett salt

För att generera saltet, ring bcrypt.genSalt() metod. Denna metod accepterar ett heltalsvärde som är kostnadsfaktorn som bestämmer tiden det tar att hasha ett lösenord. Ju högre kostnadsfaktor, desto mer tid tar algoritmen och desto svårare är det att vända hashen med brute force. Ett bra värde bör vara tillräckligt högt för att säkra lösenordet men också tillräckligt lågt för att inte sakta ner processen. Det varierar vanligtvis mellan 5 och 15. I den här handledningen kommer vi att använda 10.

bcrypt.genSalt (10, (fel, salt) => {
 // använda sig avsalt-tillhashLösenord
})

Steg 4: Hash lösenordet

Skicka det vanliga lösenordet och det genererade saltet till hash() metod:

bcrypt.genSalt (10, (fel, salt) => {
 bcrypt.hash (plaintextPassword, salt, fungera(fel, hash) {
// Lagra hash i databasen
 });
})

När du har skapat hashen, lagra den i databasen. Du kommer att använda den för att verifiera ett lösenord och autentisera en användare som försöker logga in.

Istället för att generera saltet och hashen separat kan du också autogenerera saltet och hashen med en enda funktion.

bcrypt.hash (plaintextPassword, 10, fungera(fel, hash) {
// lagra hash i databasen
});

Steg 5: Jämför lösenord med bcrypt

Till autentisera användare, måste du jämföra lösenordet de tillhandahåller med det i databasen. bcrypt.compare() accepterar vanlig textlösenordet och hashen som du lagrat, tillsammans med en återuppringningsfunktion. Den återuppringningen tillhandahåller ett objekt som innehåller eventuella fel som har inträffat och det övergripande resultatet från jämförelsen. Om lösenordet matchar hashen är resultatet sant.

bcrypt.compare (plaintextPassword, hash, fungera(fel, resultat) {
 if (resultat) {
// lösenordet är giltigt
 }
});

Använder Async/Await

Du kan hasha och verifiera lösenord med async/await enligt följande.

asynkronfungerahashPassword(klartextlösenord) {
konst hash = vänta bcrypt.hash (plaintextPassword, 10);
// Lagra hash i databasen
}
// jämför lösenord
asynkronfungerajämför Lösenord(klartextLösenord, hash) {
konst resultat = vänta bcrypt.compare (plaintextPassword, hash);
lämna tillbaka resultat;
}

Använder löften

Bcrypt-biblioteket stöder också användningen av löften.

fungerahashPassword(klartextlösenord) {
bcrypt.hash(klartextlösenord, 10)
 .då (hash => {
// Lagra hash i databasen
 })
 .fånga(fel => {
trösta.log (fel)
 })
}
fungerajämför Lösenord(klartextLösenord, hash) {
bcyrpt.jämföra(klartextlösenord, hash)
 .då (resultat => {
lämna tillbaka resultat
 })
 .fånga(fel => {
trösta.log (fel)
 })
}

Hashing och saltning är en enkel vinst

Du kan använda bcrypt-biblioteket för att hasha och verifiera lösenord i Node.js. Att hasha lösenord minimerar risken för cyberbrottslingar att använda dem för att komma åt känslig data eller tjänster. Att salta dina hashade lösenord gör dem ännu säkrare. Bortsett från hash, validera alltid lösenordsstyrkan som en extra säkerhetsåtgärd.

De 8 vanligaste knepen som används för att hacka lösenord

Läs Nästa

Om författaren