Hashning är en process där man tar input-data (som ett lösenord) och använder en matematisk funktion för att generera en sträng med fast längd (en hash). Denna hash kan sedan användas för att verifiera data utan att behöva lagra den ursprungliga datan. Varför hashning? Säker lagring: Hashar lagrar inte lösenordet direkt, vilket gör det svårare för en angripare att återskapa det ursprungliga lösenordet om de får tillgång till databasen. Konsistens: Samma input ger alltid samma hash, vilket gör det möjligt att jämföra hashade värden för autentisering. Användning av PHP för att hasha lösenord: PHP erbjuder inbyggda funktioner för säker hashning av lösenord, såsom password_hash och password_verify. Här är ett grundläggande exempel:
Slumpmässig data som läggs till innan hashning för att göra varje hash unik även om lösenorden är identiska.
Diskutera "cost"-parametern i password_hash som bestämmer hur beräkningsintensiv hash-processen ska vara. Högre kostnader gör hashning långsammare, vilket kan försvåra attacker genom brute-force.
Använd alltid password_hash och password_verify för lösenord i PHP. Se till att aldrig logga eller skicka klartextlösenord över osäkra kanaler. "Saltet" måste lagras någonstans för att det ska vara möjligt att verifiera hashen senare. I säkerhetspraxis för lagring av lösenord använder man salt för att tillföra en unik komponent till varje användares lösenord innan det hashas. Detta gör att även om två användare har samma lösenord, kommer deras hashade lösenord att skilja sig åt på grund av de olika saltvärdena. Här är hur man typiskt hanterar salt i lösenordshashning:
När ett nytt lösenord skapas för en användare, genereras ett unikt salt. I moderna hashningsbibliotek som password_hash i PHP, görs detta automatiskt och saltet är tillräckligt slumpmässigt för varje användare.
Saltet måste sparas tillsammans med den hashade versionen av lösenordet så att du kan använda samma salt när du verifierar ett inmatat lösenord mot den sparade hashen. I PHP:s password_hash och password_verify funktioner hanteras detta internt - saltet lagras som en del av den hashade strängen. Detta ser du som en lång sträng som inkluderar både saltet och själva hashvärdet.Exempel på en hashad sträng med inbyggt salt kan se ut så här: Här är $2y$10$ en del av specifieraren som berättar om hash-algoritmen och kostnaden (beräkningskomplexiteten), och efter detta följer saltet och själva hashvärdet.
När en användare försöker logga in och skriver in sitt lösenord, använder systemet saltet som sparats i hash-strängen för att hasha det inmatade lösenordet och jämföra det med den sparade hashen. Funktionen password_verify tar hand om detta genom att extrahera saltet från den hashade strängen och använda det för att verifiera lösenordet. Genom att lagra saltet tillsammans med hashen på detta sätt, upprätthåller man säkerheten samtidigt som man möjliggör korrekt verifiering av användarlösenord. Detta tillvägagångssätt minimerar risken för att lösenord ska läcka ut även om en obehörig part får tillgång till databasen med lösenordshashar, eftersom de inte kan återskapa det ursprungliga lösenordet utan att också genomföra en mycket resurskrävande och tidsödande brute-force attack.
Saltet är en slumpmässigt genererad sträng som läggs till lösenordet före hashningen. Saltet skapas med hjälp av en slumpgenerator, inte av hashalgoritmen själv. Målet med saltet är att göra varje hash unik även om de ursprungliga lösenorden är desamma. Detta förhindrar attacker där en angripare använder förberäknade hashar (kända som "rainbow tables") för att snabbt hitta lösenord som matchar en viss hash.
Hashfunktionen är en matematisk algoritm som omvandlar indata (i detta fall, lösenordet blandat med saltet) till en sträng med fast längd, känd som en hash. Denna funktion är enkelriktad, vilket betyder att det är praktiskt taget omöjligt att härleda det ursprungliga lösenordet från hashen. Exempel på hashfunktioner inkluderar SHA-256 och bcrypt.
När saltet har skapats kombineras det med det ursprungliga lösenordet. Denna kombinerade sträng matas sedan in i hashfunktionen för att producera den slutliga hashen. I PHPs password_hash-funktion hanteras generering av salt och kombinering med lösenordet internt, så användaren behöver inte manuellt skapa eller hantera saltet.Exempel på hur det ser ut i PHP: Så allt detta är gott och väl om man låter sig nöja med detta, det skapas alltså internt. Men om man vill förstå på djupet skapar man en egen algoritm:
Först och främst behöver du generera ett salt. Saltet bör vara unikt för varje användare och tillräckligt långt för att vara säkert. I PHP kan du använda random_bytes() för att generera ett kryptografiskt säkert salt:
Nästa steg är att kombinera lösenordet med saltet. Detta kan göras genom att enkelt konkatenera dem:
Använd en säker hashfunktion för att hash den kombinerade strängen. PHP:s hash()-funktion kan användas med en lämplig algoritm, som SHA-256:
Lagra både hashen och saltet i din databas. När du verifierar ett användarinmatat lösenord behöver du återanvända samma salt:
När du behöver verifiera ett lösenord, hämta den lagrade hashen och saltet från databasen, kombinera dem med det inmatade lösenordet och hasha på nytt för att se om det matchar den lagrade hashen: Denna manuella metod ger dig full kontroll över hashningsprocessen och låter dig förstå och visa alla delar av säkerhetsmekanismen. Det är dock viktigt att komma ihåg att när du implementerar egna säkerhetsfunktioner finns det risker om de inte är korrekt utformade. Användning av beprövade och robusta lösningar som password_hash och password_verify rekommenderas därför starkt i produktionssystem för att minimera potentiella säkerhetsbrister.
Den här sidan designades av 21C: