Generatore di Password

Cos'è un Generatore di Password?

Un generatore di password crea sequenze casuali di caratteri utilizzate come password per account utente, API key, credenziali di database e segreti di cifratura. A differenza delle password scelte dall'utente, le password generate attingono all'intero spazio delle combinazioni di caratteri possibili, rendendole resistenti agli attacchi a dizionario e alle tecniche di indovinamento basate su pattern. Questo strumento genera password casuali e sicure direttamente nel browser, usando il generatore di numeri casuali crittografico integrato.

La robustezza di una password dipende da due fattori: lunghezza e diversità dei caratteri. Una password di 20 caratteri che utilizza maiuscole, minuscole, cifre e simboli ha circa 131 bit di entropia. A quel livello, un attacco a forza bruta che testa un trilione di tentativi al secondo richiederebbe più tempo dell'età dell'universo per provare ogni combinazione. Il calcolo è diretto: entropia = lunghezza × log2(dimensione del set di caratteri).

Standard come NIST SP 800-63B raccomandano password di almeno 8 caratteri senza un limite superiore imposto dal verificatore, e sconsigliano regole di composizione forzata come richiedere esattamente un simbolo, preferendo invece passphrase più lunghe. Per credenziali machine-to-machine e account di servizio, 20 o più caratteri casuali tratti da un set completo è la base accettata nella maggior parte dei framework di sicurezza e dei regimi di conformità.

Perché Usare un Generatore di Password?

Gli esseri umani sono pessimi generatori di numeri casuali. Riutilizziamo le password, scegliamo parole del dizionario, sostituiamo lettere con pattern prevedibili (@ per a, 3 per e) e tendiamo a usare stringhe brevi. Un generatore di password elimina il bias umano dal processo.

Casi d'Uso del Generatore di Password

Riferimento sull'Entropia delle Password

L'entropia misura quanto una password è imprevedibile. Si calcola come log2(dimensione_set ^ lunghezza). Maggiore è l'entropia, più combinazioni un attaccante deve esaminare. NIST e OWASP raccomandano almeno 80 bit di entropia per applicazioni ad alta sicurezza.

I tempi di crack assumono 1 trilione di tentativi al secondo (attacco offline con GPU moderne). Gli attacchi online con limitazione del tasso sono di diversi ordini di grandezza più lenti.

CSPRNG vs Math.random() per la Generazione di Password

La fonte di casualità è importante quanto la lunghezza della password. Una password generata con un generatore di numeri casuali prevedibile può essere ricostruita da un attaccante che conosce l'algoritmo e lo stato iniziale. Questo strumento usa crypto.getRandomValues(), che è un generatore di numeri pseudocasuali crittograficamente sicuro (CSPRNG) integrato in ogni browser moderno.

Esempi di Codice

Genera password in modo programmatico in diversi linguaggi. Ogni esempio usa una fonte di casualità crittograficamente sicura, non Math.random() o PRNG deboli equivalenti.

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

Domande Frequenti