Password Generator

Vad är en Password Generator?

En lösenordsgenerator skapar slumpmässiga teckensträngar som används som lösenord för användarkonton, API-nycklar, databasuppgifter och krypteringshemligheter. Till skillnad från lösenord som väljs av människor hämtar genererade lösenord från hela rymden av möjliga teckenkombinationer, vilket gör dem motståndskraftiga mot ordboksattacker och mönsterbaserad gissning. Det här verktyget genererar starka slumpmässiga lösenord online med hjälp av webbläsarens inbyggda kryptografiska slumptalsgenerator.

Lösenordsstyrka beror på två faktorer: längd och teckenmångfald. Ett 20-tecken lösenord med versaler, gemener, siffror och symboler har ungefär 131 bitar entropi. På den nivån skulle en brute-force-attack som testar en biljon gissningar per sekund behöva längre tid än universums ålder för att prova varje kombination. Matematiken är enkel: entropi = längd × log2(teckenuppsättningens storlek).

Standarder som NIST SP 800-63B rekommenderar lösenord på minst 8 tecken utan övre gräns fastställd av verifieraren, och avråder från tvingande sammansättningsregler som att kräva exakt ett specialtecken — längre lösenfraser föredras istället. För maskin-till-maskin-uppgifter och tjänstekonton är 20 eller fler slumpmässiga tecken från en fullständig teckenuppsättning den accepterade grundnivån i de flesta säkerhetsramverk och efterlevnadsregimer.

Varför använda en Password Generator?

Människor är dåliga slumptalsgeneratorer. Vi återanvänder lösenord, väljer ord från ordböcker, ersätter bokstäver med förutsägbara mönster (@ för a, 3 för e) och väljer korta strängar som standard. En lösenordsgenerator tar bort mänsklig partiskhet från processen.

Användningsområden för Password Generator

Referens för lösenordsentropi

Entropi mäter hur oförutsägbart ett lösenord är. Det beräknas som log2(teckenuppsättningens storlek ^ längd). Högre entropi innebär fler möjliga kombinationer för en angripare att söka igenom. NIST och OWASP rekommenderar minst 80 bitar entropi för säkerhetskritiska tillämpningar.

Knäckningstider förutsätter 1 biljon gissningar per sekund (offlineattack med moderna GPU:er). Onlineattacker med hastighetsbegränsning är storleksordningar långsammare.

CSPRNG vs Math.random() för lösenordsgenerering

Källan till slumpmässighet spelar lika stor roll som lösenordets längd. Ett lösenord som genereras med en förutsägbar slumptalsgenerator kan rekonstrueras av en angripare som känner till algoritmen och seedtillståndet. Det här verktyget använder crypto.getRandomValues(), som är en kryptografiskt säker pseudoslumptalsgenerator (CSPRNG) inbyggd i varje modern webbläsare.

Kodexempel

Generera lösenord programmatiskt i olika språk. Varje exempel nedan använder en kryptografiskt säker slumpkälla, inte Math.random() eller likvärdiga svaga PRNG:er.

// Generate a random password in the browser or Node.js 19+
function generatePassword(length = 20) {
  const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*'
  const values = new Uint32Array(length)
  crypto.getRandomValues(values)
  return Array.from(values, v => charset[v % charset.length]).join('')
}

console.log(generatePassword())    // → "kR7!mZp$Xw2&nLq9@Yf3"
console.log(generatePassword(32))  // → "Hd4%tNx!Qw8#mKp2Rv6&Zj0*Ls3Yb7@"

import secrets
import string

def generate_password(length: int = 20) -> str:
    """Generate a cryptographically secure random password."""
    alphabet = string.ascii_letters + string.digits + string.punctuation
    return ''.join(secrets.choice(alphabet) for _ in range(length))

# Single password
print(generate_password())      # → "kR7!mZp$Xw2&nLq9@Yf3"

# Batch of 5 passwords
for _ in range(5):
    print(generate_password(24))

# Ensure at least one char from each category
def generate_strong(length: int = 20) -> str:
    required = [
        secrets.choice(string.ascii_uppercase),
        secrets.choice(string.ascii_lowercase),
        secrets.choice(string.digits),
        secrets.choice(string.punctuation),
    ]
    remaining = length - len(required)
    alphabet = string.ascii_letters + string.digits + string.punctuation
    all_chars = required + [secrets.choice(alphabet) for _ in range(remaining)]
    secrets.SystemRandom().shuffle(all_chars)
    return ''.join(all_chars)

# OpenSSL — generate 32 random bytes, base64-encode
openssl rand -base64 32
# → "x7Kp2mNqR4wZ8vLs1Yb0Hd6tFj3Xc9Ga5eUi+Wo="

# /dev/urandom with tr — alphanumeric + symbols, 20 chars
tr -dc 'A-Za-z0-9!@#$%^&*' < /dev/urandom | head -c 20; echo
# → "kR7!mZp$Xw2&nLq9@Yf3"

# pwgen (install: apt install pwgen / brew install pwgen)
pwgen -sy 20 5
# Generates 5 passwords, 20 chars each, with symbols

package main

import (
    "crypto/rand"
    "fmt"
    "math/big"
)

func generatePassword(length int) (string, error) {
    charset := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()"
    result := make([]byte, length)
    for i := range result {
        idx, err := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
        if err != nil {
            return "", err
        }
        result[i] = charset[idx.Int64()]
    }
    return string(result), nil
}

func main() {
    pwd, _ := generatePassword(20)
    fmt.Println(pwd) // → "kR7!mZp$Xw2&nLq9@Yf3"
}

Vanliga frågor