Password Generator

Co je generátor hesel?

Generátor hesel vytváří náhodné řetězce znaků používané jako hesla pro uživatelské účty, API klíče, databázové přihlašovací údaje a šifrovací tajemství. Na rozdíl od hesel volených lidmi čerpají generovaná hesla z celého prostoru možných kombinací znaků, čímž jsou odolná vůči slovníkovým útokům a hádání na základě vzorů. Tento nástroj generuje silná náhodná hesla online pomocí kryptografického generátoru náhodných čísel zabudovaného ve vašem prohlížeči.

Síla hesla závisí na dvou faktorech: délce a rozmanitosti znaků. 20znakové heslo obsahující velká písmena, malá písmena, číslice a symboly má přibližně 131 bitů entropie. Na této úrovni by útok hrubou silou testující bilion pokusů za sekundu potřeboval déle, než je stáří vesmíru, aby vyzkoušel všechny kombinace. Výpočet je přímočarý: entropie = délka × log2(velikost znakové sady).

Standardy jako NIST SP 800-63B doporučují hesla o délce alespoň 8 znaků bez horního limitu vynuceného ověřovatelem a nedoporučují povinná pravidla složení, jako je požadavek právě jednoho symbolu, přičemž upřednostňují delší přístupové fráze. Pro strojové přihlašovací údaje a servisní účty je ve většině bezpečnostních rámců a předpisů o shodě přijímaným základem 20 nebo více náhodných znaků vybraných z plné znakové sady.

Proč používat generátor hesel?

Lidé jsou špatnými generátory náhodných čísel. Opakujeme hesla, volíme slovníková slova, nahrazujeme písmena předvídatelnými vzory (@ místo a, 3 místo e) a volíme výchozí krátké řetězce. Generátor hesel odstraňuje z tohoto procesu lidskou zaujatost.

Případy použití generátoru hesel

Referenční tabulka entropie hesel

Entropie měří, jak nepředvídatelné je heslo. Vypočítá se jako log2(velikost_znakové_sady ^ délka). Vyšší entropie znamená více možných kombinací, které musí útočník prohledat. NIST a OWASP doporučují alespoň 80 bitů entropie pro aplikace s vysokými bezpečnostními požadavky.

Časy prolomení předpokládají bilion pokusů za sekundu (offline útok s moderními GPU). Online útoky s omezením rychlosti jsou o mnoho řádů pomalejší.

CSPRNG vs Math.random() pro generování hesel

Zdroj náhodnosti je stejně důležitý jako délka hesla. Heslo vygenerované předvídatelným generátorem náhodných čísel může být rekonstruováno útočníkem, který zná algoritmus a počáteční stav. Tento nástroj používá crypto.getRandomValues(), což je kryptograficky bezpečný pseudonáhodný generátor čísel (CSPRNG) zabudovaný do každého moderního prohlížeče.

Příklady kódu

Generujte hesla programově v různých jazycích. Každý příklad níže používá kryptograficky bezpečný zdroj náhodnosti, nikoli Math.random() nebo ekvivalentní slabé PRNG.

// 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"
}

Časté dotazy