Linux "avkoda" lösenord. Den använder en process med
hashing och
salting För att lagra lösenord säkert. Här är en uppdelning av algoritmen och relaterade koncept:
1. Målet:Säker lösenordslagring
Den grundläggande principen är att det faktiska PlainText -lösenordet är * aldrig * lagrat någonstans. Om databasen som innehåller lösenord någonsin komprometterades skulle angriparna direkt ha tillgång till alla användarkonton. Hashing och saltning förhindrar detta.
2. Hashing:
* envägsfunktion: Hashing är en matematisk operation som omvandlar lösenordet till en sträng med fast storlek av tecken som kallas en "hash." Det är en * envägs * -funktion, vilket innebär att det är beräkningsmässigt omöjligt (extremt svårt och tidskrävande) att vända processen och härleda det ursprungliga lösenordet från hash.
* Kollisionsresistens: Helst bör olika lösenord ge olika hash. En bra hashingalgoritm minimerar chansen för en "kollision", där två olika lösenord genererar samma hash.
* Vanliga hash -algoritmer i Linux:
* bcrypt: Ofta anses det starkaste och föredragna valet. Det inkluderar ett inbyggt salt och är utformat för att vara beräkningsmässigt dyrt, vilket gör det motståndskraftigt mot brute-force-attacker.
* argon2: En modern lösenordshash-algoritm som också är utformad för att vara beräkningsmässigt dyr och minneshård, vilket ytterligare ökar motståndet mot attacker. Det blir mer populärt.
* scrypt: En annan nyckel härledningsfunktion utformad för att vara resistent mot brute-force-attacker.
* SHA-512: (Mindre vanligt * nu * för direkt lösenordshashing, men används ofta som en del av en större nyckel härledningsfunktion). Historiskt användes. Används ibland som en del av PAM -konfigurationer.
* MD5, SHA-1, SHA-256: Använd inte dessa! Dessa betraktas som föråldrade och sårbara för direkt lösenordshash. De är för snabba och lätt spruckna med modern hårdvara och förskrivna regnbågsbord. De kan finnas i äldre system, men bör uppgraderas.
3. Saltning:
* Att lägga till slumpmässighet: Ett "salt" är en slumpmässig sträng av tecken som är unik för varje användare. Saltet sammanlänkas (läggs till) lösenordet * innan * det är hashat.
* Förhindra regnbågsattacker: Rainbow -tabeller är föreskrivna tabeller av hash för vanliga lösenord. Utan saltning kunde en angripare helt enkelt slå upp hash i en regnbågsbord för att hitta motsvarande lösenord. Saltning gör regnbågsbord värdelösa eftersom varje lösenord har ett unikt salt, vilket resulterar i en unik hash även för vanliga lösenord.
* Saltet lagras med hash: Av avgörande betydelse lagras själva saltet tillsammans med hash -lösenordet i filen "/etc/skugg" (eller i någon databas i moderna system). Detta är * inte * en säkerhetssårbarhet; Saltet krävs * för att verifiera ett lösenord.
* Varför lagra saltet? För att verifiera användarens lösenord måste systemet:
1. Hämta det lagrade saltet för den användaren.
2. Sammanfogar det inmatade lösenordet med saltet.
3. Hash resultatet med * samma * hashing -algoritm som ursprungligen använts.
4. Jämför den nyligen genererade hashen med den lagrade hashen. Om de matchar är lösenordet korrekt.
4. "/Etc/skuggan" (traditionell strategi)
Traditionellt lagras användarlösenord och deras tillhörande information i filen "/etc/skugg". (Obs! Att visa eller modifiera den här filen kräver vanligtvis rotprivilegier).
* behörigheter: Filen "/etc/skugg" är vanligtvis endast läsbar av "root" -användaren, vilket säkerställer att vanliga användare inte kan se hashade lösenord för andra användare.
* Struktur: Varje rad i filen "/etc/skugg" representerar ett användarkonto och har följande format (förenklat):
`` `
Användarnamn:Hashed_password:Last_Change:min_days:max_days:WARN_DAYS:INACTIVE_DAYS:Expire_Date:Flags
`` `
* Fältet `Hashed_password`: Det är här det saltade och hashade lösenordet lagras. Formatet för detta fält innehåller vanligtvis en identifierare för den som används, saltet och den faktiska hashen. Till exempel:
* `$ 6 $ vissa_random_salt $ AverylongHashedPasswordString` (detta använder SHA-512)
* `$ 2b $ 10 $ en annan_random_salt $ evenlongerHashedPasswordString` (detta använder bcrypt)
* `$ 6` indikerar SHA-512
* `$ 2b` indikerar bcrypt
*Antalet (t.ex. `10 'i Bcrypt) indikerar *kostnadsfaktorn *eller *arbetsfaktor *. En högre kostnadsfaktor gör hashprocessen mer beräkningsmässigt dyr, vilket ökar tiden det tar att knäcka lösenordet.
5. Moderna system och PAM (pluggbara autentiseringsmoduler)
* databaser: Moderna system använder ofta databaser (t.ex. LDAP, Active Directory) för att lagra användarkontoinformation, inklusive Hashed -lösenord.
* Pam: PAM är ett flexibelt ramverk som gör det möjligt för systemadministratörer att konfigurera olika autentiseringsmekanismer. Det används för att hantera autentiseringsprocessen, inklusive hash-lösenord, verifiera lösenord och utföra andra säkerhetsrelaterade uppgifter. PAM -konfigurationsfiler (t.ex. i `/etc/pam.d/`) Bestäm vilka autentiseringsmoduler som används och hur de är konfigurerade.
Exempelsscenario:Verifiering av användarlösenord
1. Användaren anger lösenord: Användaren skriver sitt lösenord i en inloggningsprompt eller applikation.
2. Systemet hämtar salt: Systemet letar upp användarens konto och hämtar det lagrade saltet från `/etc/skuggan '(eller lämplig databas).
3. Sammanfattning och hashing: Systemet sammanställer det inmatade lösenordet med det hämtade saltet. Sedan använder den hash-algoritmen som anges i posten "/etc/skugg" (t.ex. SHA-512 eller BCRYPT) för att hash det kombinerade lösenordet och saltet.
4. Jämförelse: Den nyligen genererade hashen jämförs med den lagrade hashen i `/etc/skugga '.
5. Autentisering Framgång/misslyckande: Om de två hasharna matchar är autentiseringen framgångsrik. Annars misslyckas autentiseringen.
Viktiga överväganden:
* Lösenordskomplexitet: Uppmuntra användare att välja starka lösenord som är långa, komplexa och svåra att gissa.
* Regelbundna lösenordsändringar: Att regelbundet kräva att användare ändrar sina lösenord kan hjälpa till att mildra risken för lösenords kompromiss.
* Multi-Factor Authentication (MFA): Att använda MFA lägger till ett extra lager av säkerhet genom att kräva att användare tillhandahåller flera former av identifiering, till exempel ett lösenord och en kod från deras telefon.
* Säkerhetsrevisioner: Regelbundet granskning av systemets säkerhetskonfiguration kan hjälpa till att identifiera och hantera potentiella sårbarheter.
* hålls uppdaterad: Håll ditt operativsystem och programvara uppdaterad med de senaste säkerhetsuppdateringarna.
Sammanfattningsvis: Linux "avkoda" lösenord. Den använder en stark kombination av saltning och hashing för att säkert lagra lösenordsrepresentationer. Algoritmerna "Bcrypt" och "Argon2" föredras i allmänhet för sitt motstånd mot brute-force-attacker. Korrekt konfigurera PAM och hålla ditt system säkert är avgörande för att skydda användarkonton.
