Lösenordsentropi förklarat: hur man faktiskt beräknar hur starkt ett lösenord är
"Använd ett starkt lösenord" är ett vanligt råd, men "starkt" är vagt. Entropi är det faktiska måttet bakom det rådet — ett tal, i bitar, som anger hur många gissningar en angripare behöver i värsta fall. Den här artikeln förklarar vad det talet betyder och hur man beräknar det för ett lösenord du faktiskt väljer.
Kort sagt
- Entropi (i bitar) mäter storleken på det sökutrymme en angripare måste gå igenom med brute force:
entropi = log2(teckenuppsättningens storlek ^ längd). - Varje extra tecken multiplicerar sökutrymmet; varje extra teckentyp multiplicerar det bara med en fast, jämförelsevis liten faktor.
- Ett lösenord på 12 tecken med enbart gemener har mindre entropi än ett på 8 tecken som blandar alla fyra teckentyper — men en lösenfras på 20 tecken med enbart gemener överträffar båda.
- Lösenord som genereras av CSPRNG uppnår exakt sin teoretiska entropi; lösenord som människor väljer gör det nästan aldrig, eftersom människor inte är slumpmässiga.
Kort svar
Entropi i bitar är log2(N), där N är det totala antalet lika sannolika lösenord för den längden och teckenuppsättningen. I praktiken: entropi = längd × log2(teckenuppsättningens storlek). Ett lösenord på 16 tecken som dras jämnt fördelat från de 95 utskrivbara ASCII-tecknen har ungefär 16 × log2(95) ≈ 105 bitars entropi — jämförbart med en 256-bitars AES-nyckel vad gäller praktiskt motstånd mot brute force, vilket är överdrivet i jämförelse, men 105 bitar ligger redan långt bortom vad nuvarande eller förutsebar hårdvara kan uttömma. PassGenerate genererar lösenord på detta sätt, med CSPRNG från Web Crypto API, så den här entropisiffran är verklig, inte bara teoretisk.
Entropiformeln, steg för steg
Entropi förutsätter att varje tecken väljs oberoende och jämnt slumpmässigt från en fast uppsättning. Givet en teckenuppsättning av storlek C och ett lösenord med längden L är antalet möjliga lösenord C^L, och entropin i bitar är:
entropi = L × log2(C)
| Teckenuppsättning | Uppsättningens storlek (C) | Bitar per tecken (log2 C) |
|---|---|---|
| Endast siffror (0-9) | 10 | 3.32 |
| Gemener (a-z) | 26 | 4.70 |
| Gemener + siffror | 36 | 5.17 |
| Blandade versaler/gemener + siffror | 62 | 5.95 |
| Blandade versaler/gemener + siffror + symboler (~33 vanliga) | 95 | 6.57 |
Längd vs. teckenuppsättningens storlek: varför längd vinner
Den här tabellen visar varför NIST SP 800-63B tonar ner betydelsen av påtvingade komplexitetsregler till förmån för längd:
| Längd | Endast siffror | Gemener | Blandat (versaler+gemener+siffror+symboler) |
|---|---|---|---|
| 8 | 27 bitar | 38 bitar | 52 bitar |
| 12 | 40 bitar | 56 bitar | 79 bitar |
| 16 | 53 bitar | 75 bitar | 105 bitar |
| 20 | 66 bitar | 94 bitar | 131 bitar |
| 24 | 80 bitar | 113 bitar | 157 bitar |
| 32 | 106 bitar | 150 bitar | 210 bitar |
Lägg märke till att ett lösenord på 8 tecken som använder alla fyra teckentyper (52 bitar) har mindre entropi än ett lösenord på 12 tecken helt i gemener (56 bitar). Det här är den matematiska grunden för en välkänd slutsats: att lägga till fyra extra slumpmässiga tecken gör mer för din säkerhet än att tvinga in symboler och siffror i ett kort lösenord. Det är också varför långa, slumpmässigt genererade lösenfraser (flera slumpmässiga ordboksord) kan vara både starkare och lättare att skriva än en kort samling symboler — varje extra ord ger vanligtvis 11-13 bitar om det hämtas från en lista med några tusen ord, vilket snabbt adderas över 4-6 ord.
Varför "se slumpmässigt ut" inte är detsamma som att vara slumpmässigt
Entropiberäkningar förutsätter verklig, jämnt fördelad slumpmässighet. Lösenord som skapats av människor bryter systematiskt mot detta antagande även när de ser komplexa ut: tangentbordsmönster (Qwerty123!), leetspeak-ersättningar (L0senord1), och datum eller namn med ett tillagt symbol minskar alla den faktiska entropin långt under vad teckenantalet antyder, eftersom angriparnas knäckningsverktyg är byggda kring just sådana mönster. Ett lösenord kan se slumpmässigt ut för ett mänskligt öga och ändå falla inom de första miljonerna försök i en riktad ordboksattack.
Det här är det praktiska skälet att föredra en generator som använder en kryptografiskt säker pseudoslumptalsgenerator (CSPRNG) framför att själv hitta på ett lösenord. Math.random() i JavaScript är inte kryptografiskt säkert och är inte lämpligt för lösenordsgenerering — det seedas och genereras av en algoritm som är tillräckligt förutsägbar för att kunna rekonstrueras från ett fåtal utdata i vissa motorer. Web Crypto API:s crypto.getRandomValues() hämtar från operativsystemets kryptografiska slumpkälla, så varje tecken är genuint och oberoende slumpmässigt, och entropimatematiken ovan gäller verkligen.
Så här ser det ut med verklig hårdvara
Bittalen ovan är användbara för jämförelse men säger inte hur lång tid en verklig attack faktiskt tar — det beror på hårdvaran som gör gissningarna, och den hårdvaran blir snabbare varje år. Hive Systems publicerar årligen ett riktmärke exakt om detta, där man testar brute force-hastighet mot en hyrd flotta av vanliga konsument-GPU:er. Deras tabell för 2026 sätter ett slumpmässigt genererat lösenord på 8 tecken med hela den blandade teckenuppsättningen (versaler, gemener, siffror, symboler) till ungefär 132 år att knäcka — ner från 164 år 2025 och 225 år 2024, en minskning på cirka 20-25% per år i takt med att GPU-hårdvaran förbättras. Ett lösenord på 8 tecken enbart med gemener sjönk ännu snabbare: från tre veckor att knäcka 2025 till cirka två veckor 2026.
Två saker från det riktmärket är värda att känna till. För det första är trenden enkelriktad — det som ser "säkert" ut idag blir svagare varje år bara på grund av hårdvaruförbättringar, vilket är ett verkligt argument för att luta åt längre lösenord snarare än dagens minimum. För det andra, och något kontraintuitivt: de specialiserade AI-acceleratorchipen som byggts för att träna språkmodeller visade sig inte vara snabbare på att knäcka lösenord med brute force än motsvarande spel-GPU:er, och i vissa tester till och med långsammare — lösenordsknäckning är ett rent numeriskt problem som inte drar nytta av de matrismultiplikationsoptimeringar som AI-hårdvara bygger på.
Hur många bitar behöver man faktiskt?
Det finns inget enda universellt tal, eftersom det beror på vad man försvarar sig mot:
- ~40-60 bitar: Motståndskraftigt mot slumpmässiga gissningar och småskaliga automatiserade attacker, men inom räckhåll för en välresurserad offline-attack mot en svagt hashad databas. Lämpligt endast för genuint lågvärdiga konton med liten konsekvens.
- ~70-90 bitar: Bekvämt utom räckhåll för brute force även med optimerad knäckningshårdvara, för varje realistisk attacktidsram. Ett rimligt mål för de flesta personliga konton.
- 100+ bitar: Praktiskt taget oåtkomligt med brute force med nuvarande eller förutsebar beräkningskraft, kryptografiskt i samma mening som en stark krypteringsnyckel. Lämpligt för huvudlösenordet till din lösenordshanterare eller andra enskilda felpunkter.
Viktiga slutsatser
- Entropi är
längd × log2(teckenuppsättningens storlek)— längd har en linjär effekt, teckenuppsättningens storlek har en logaritmisk effekt, vilket är varför längd dominerar. - Ett kort lösenord med alla teckentyper kan ha mindre entropi än ett längre lösenord med bara en typ.
- Faktisk entropi är bara lika med teoretisk entropi när tecknen är genuint och jämnt slumpmässiga — vilket en CSPRNG garanterar och mänskligt val vanligtvis inte uppnår.
- Sikta på 70+ bitar för vardagliga konton och 100+ bitar för huvudlösenord eller andra enskilda felpunkter.
Varför du kan lita på PassGenerate
- Lösenord genereras lokalt i din webbläsare med hjälp av Web Crypto API.
- Inga lösenord skickas till servrar.
- Använder en kryptografiskt säker pseudoslumptalsgenerator (CSPRNG).
- Följer moderna säkerhetsrekommendationer från NIST och OWASP.
Källor
- Hive Systems 2026 Password Table (data från brute force-riktmärke)
- NIST SP 800-63B – Digital Identity Guidelines
- OWASP Authentication Cheat Sheet
Slutsats
Entropi är ett precist, beräkningsbart mått på lösenordsstyrka, inte ett vagt begrepp om "komplexitet". Längd betyder mer än påtvingad blandning av teckentyper eftersom den ökar sökutrymmet linjärt, medan teckenuppsättningens storlek bara ökar det logaritmiskt — och inget av detta håller om inte tecknen faktiskt är slumpmässiga, vilket är varför en CSPRNG-baserad generator som PassGenerate producerar lösenord som exakt uppnår sin teoretiska entropi, något ett lösenord valt av en människa praktiskt taget aldrig uppnår.