Strumento per la Generazione e la Validazione delle Password

Genera password forti e frasi passcode, con supporto per validazioni di massa, unicità, intensità e politiche, oltre a esempi di codice multi-lingua e conoscenze pratiche.

Tester di strategia password

Password da testare

Lunghezza minima Richiede lettere minuscole Richiede lettere maiuscole Richiede numeri Richiede simboli Vieta sequenze consecutive (es. abc, 123) Vieta ripetizioni prolungate (es. aaaa)

Risultati

Lunghezza
Lettere minuscole
Lettere maiuscole
Numeri
Simboli
Sequenze consecutive
Ripetizioni
Lista nera

Tutti i controlli vengono eseguiti localmente nel tuo browser.

Generatore di passphrase

Numero di parole

Separatore

Maiuscola iniziale Aggiungi numero

Le parole sono selezionate casualmente in modo sicuro tramite Web Crypto. L'elenco di esempio è limitato per ragioni di dimensione.

Tabella rapida di hash per password

Argon2id

Utilizza Argon2id con parametri di memoria adeguati
Almeno 2 iterazioni, memoria ≥ 64 MB (ottimizza in base all'ambiente)
Utilizza un sale indipendente per ogni utente; opzionalmente usa un pepper a livello applicativo

PBKDF2

Scegli SHA-256 o SHA-512 con almeno 210.000 iterazioni (ottimizza secondo necessità)
Utilizza un sale unico per ogni hash; supporta l'aggiornamento dei parametri
Migra a parametri con costo maggiore durante il prossimo accesso dell'utente

BCrypt

Costo tra 10 e 14, in base alle capacità del server
Evita problemi di troncamento; applica l'hash all'intera password
Applica rate limiting e monitoraggio agli endpoint di autenticazione

Riferimento: NIST SP 800-63B, OWASP ASVS. I parametri devono essere allineati alle capacità hardware e agli SLO.

Valutazione della forza della password

La forza è stimata dall'entropia: entropy = log2(dimensione del set di caratteri) × lunghezza. Un set di caratteri più ampio e una lunghezza maggiore migliorano la resistenza agli attacchi di forza bruta.

Debole: < 50 bit —— Adatto solo a scenari temporanei o a basso valore
Media: 50–80 bit —— Accettabile per scenari a basso rischio
Forte: 80–110 bit —— Obiettivo consigliato predefinito
Eccellente: > 110 bit —— Consigliato per account amministrativi o critici

Nota: I modelli di attacco reali possono variare; evita il riutilizzo delle password e attiva l'autenticazione a due fattori (MFA).

Istruzioni d'uso

Scegli lunghezza e set di caratteri (Minuscole/Maiuscole/Cifre/Simboli); attiva opzionalmente 'Evita simili' e 'Richiedi ciascuno'
Per un controllo più fine: escludi caratteri o gruppi specifici, oppure seleziona gruppi di simboli
Clicca su Genera; per generare più risultati, abilita la modalità batch e copia tutto con un solo clic
Per verificare una password esistente, usa il 'Tester di politica'; per creare una frase passcode memorizzabile, usa il 'Generatore di frasi passcode'

Funzionalità

Fonte casuale crittograficamente sicura (Web Crypto)
Set di caratteri e gruppi di simboli configurabili
Filtraggio dei caratteri simili ed esclusioni personalizzate
Generazione in batch, garanzia di unicità e statistica di rimozione duplicati
Valutazione dell'intensità e indice di entropia
Tester di politica e generatore di frasi passcode
Esempi di codice in più linguaggi （JS、Python、PHP、Go、Java、C#、Rust）
Copia con un clic (singola / tutte)

Esempi di generazione password

Forte (Strong)

Lunghezza 24, include lettere maiuscole/minuscole/cifre/simboli

Memorizzabile (Memorable)

Lunghezza 16, include lettere maiuscole/minuscole/cifre, evita caratteri simili

Biblioteca di conoscenze sulle password

1) Forza della password e entropia

Entropia ≈ log2(dimensone del set di caratteri) × lunghezza; la lunghezza ha solitamente un impatto maggiore
Obiettivo consigliato: account ordinari ≥ 80 bit; account con privilegi elevati/finanziari ≥ 110 bit
Un set di caratteri più ampio e una lunghezza maggiore → maggiore resistenza agli attacchi indovinativi

2) Lunghezza vs complessità

Aggiungere simboli a caso è meno efficace dell'aumentare la lunghezza
Evita schemi prevedibili fissi (es. sempre 'maiuscola iniziale + numero alla fine!')
Priorizza innanzitutto una lunghezza sufficiente, poi aumenta moderatamente la diversità dei caratteri

3) Errori comuni e anti-pattern

Sequenze da tastiera (qwerty), blocchi ripetuti, date di nascita/anni ecc. sono facilmente individuabili da regole comuni
Usare 'password principale + suffisso sito' è una forma di riutilizzo variante, che concentra il rischio e facilita l'indovinello
Non riutilizzare la stessa password su più siti

4) Consigli per la gestione delle password

Usa un gestore di password; usa password uniche per ogni sito; attiva l'MFA per gli account importanti
Evita di trasmettere password in chiaro su canali pubblici; se necessario, usa password 'facili da pronunciare'
Cambia immediatamente e rendi unica qualsiasi password rilevata compromessa o riutilizzata

5) Guida alle passphrase

Combinazioni di 4–6 parole sono spesso forti e facili da ricordare
Mixa separatori diversi, maiuscole iniziali e inserisci numeri per aumentare forza e leggibilità
Evita di concatenare direttamente frasi comuni, testi di canzoni o citazioni famose

Guida alle best practice di sicurezza per le password

Migliori Pratiche

Utilizza lunghezze sufficienti: almeno 16 caratteri per account generali, 24+ per quelli critici
Per ricordare facilmente, preferisci frasi passphraze; per password casuali ad alta intensità, usa un gestore di password
Abilita l'autenticazione a più fattori (MFA) ove possibile
Non riutilizzare le password su siti diversi; ogni account deve avere una password unica

Entropia e Forza

L'entropia misura l'imprevedibilità in base alla lunghezza e alla dimensione dell'insieme dei caratteri; un numero maggiore di bit di entropia indica solitamente una password più forte.

Aumenta la lunghezza per ottenere il massimo guadagno
Utilizza set di caratteri multipli quando possibile
Escludere troppi caratteri riduce l'insieme disponibile e indebolisce la password

Politiche e Rotazione

Preferisci regole basate sulla lunghezza e sulla blacklisting di password comuni/compromesse piuttosto che complessi requisiti di composizione
Evita rotazioni forzate frequenti; cambia la password solo in caso di compromissione o rischio rilevato
Utilizza liste di password compromesse per bloccare password comuni o già diffuse

Frase Passphrase

Usa 4–6 parole casuali collegate da separatori, ad esempio lake-CARROT-planet_7
Evita frasi famose, citazioni o testi di canzoni; la casualità è più importante della 'intelligenza'
Per account critici, suggeriamo di usare un gestore di password per memorizzare password casuali ad alta entropia

Suggerimenti per le Impostazioni di Generazione

"Require each selected set" garantisce che almeno un carattere di ogni tipo selezionato sia presente
"Avoid similar" migliora la leggibilità, ma riduce leggermente la dimensione dell'insieme dei caratteri
I simboli possono essere limitati al sottoinsieme accettato dal sistema target

Archiviazione Server-Side

Non archiviare mai le password in chiaro; usa hash forti (Argon2id/PBKDF2/BCrypt) con salt
Imposta parametri ragionevoli (memoria/tempo/costo); considera l'uso di pepper se necessario
Limita il tasso di tentativi e monitora gli accessi falliti; in caso di attacco, aggiungi CAPTCHA o verifica del dispositivo

Autenticazione a Più Fattori e Recupero

Preferisci TOTP o chiavi hardware; evita quanto più possibile SMS
Proteggi i processi di recupero: usa autenticazione a più fattori o verifica tramite email con periodo di attesa
Fornisci codici di ripristino di emergenza e incoraggia gli utenti a conservarli in sicurezza

Protezione contro Attacchi di Forza Bruta

Implementa ritardi progressivi/blocco e punteggi di rischio basati su IP/dispositivo
Configura WAF/limitazione di velocità per API e moduli di login
Monitora gli attacchi di credential stuffing e incoraggia l'uso di password uniche

Archiviazione e Elaborazione Locale

Usa un gestore di password affidabile per salvare e compilare automaticamente le credenziali
Non condividere password in chiaro via chat o email; per team, usa strumenti di gestione dei segreti
Se devi annotare password su carta, assicurati che siano fisicamente protette

Disclaimer: Questo strumento genera password localmente nel browser utilizzando Web Crypto; nessun dato viene inviato al server.

Come generare password tramite linguaggi di programmazione

JavaScript（Web Crypto）

function randomPassword(length = 16, sets = {lower:true, upper:true, digits:true, symbols:true}) {
  const pools = {
    lower: 'abcdefghijklmnopqrstuvwxyz',
    upper: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
    digits: '0123456789',
    symbols: '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
  };
  let pool = '';
  for (const k of Object.keys(sets)) if (sets[k]) pool += pools[k];
  if (!pool) throw new Error('No charset');
  const bytes = new Uint32Array(length);
  crypto.getRandomValues(bytes);
  let out = '';
  for (let i = 0; i < length; i++) out += pool[bytes[i] % pool.length];
  return out;
}

Python（secrets）

import secrets

def random_password(length=16, lower=True, upper=True, digits=True, symbols=True):
    pools = {
        'lower': 'abcdefghijklmnopqrstuvwxyz',
        'upper': 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
        'digits': '0123456789',
        'symbols': '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
    }
    pool = ''.join(v for k, v in pools.items() if locals()[k])
    if not pool:
        raise ValueError('No charset')
    return ''.join(secrets.choice(pool) for _ in range(length))

PHP（random_int）

function random_password($length = 16, $sets = ['lower'=>true,'upper'=>true,'digits'=>true,'symbols'=>true]) {
    $pools = [
        'lower' => 'abcdefghijklmnopqrstuvwxyz',
        'upper' => 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
        'digits' => '0123456789',
        'symbols' => '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
    ];
    $pool = '';
    foreach ($sets as $k => $on) if ($on) $pool .= $pools[$k];
    if ($pool === '') throw new Exception('No charset');
    $out = '';
    for ($i = 0; $i < $length; $i++) {
        $out .= $pool[random_int(0, strlen($pool)-1)];
    }
    return $out;
}

Go（crypto/rand）

package main

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

func RandomPassword(length int, pool string) (string, error) {
  out := make([]byte, length)
  for i := 0; i < length; i++ {
    nBig, err := rand.Int(rand.Reader, big.NewInt(int64(len(pool))))
    if err != nil { return "", err }
    out[i] = pool[nBig.Int64()]
  }
  return string(out), nil
}

Java（SecureRandom）

import java.security.SecureRandom;

public class Pw {
  static final String POOL = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*+-=_~`|/?()[]{}<>,.;:'\"";
  static final SecureRandom SR = new SecureRandom();
  static String randomPassword(int length) {
    StringBuilder sb = new StringBuilder(length);
    for (int i = 0; i < length; i++) {
      int idx = SR.nextInt(POOL.length());
      sb.append(POOL.charAt(idx));
    }
    return sb.toString();
  }
}

C#（.NET RandomNumberGenerator）

using System;
using System.Security.Cryptography;

public static class Pw {
  public static string RandomPassword(int length, string pool) {
    using var rng = RandomNumberGenerator.Create();
    var bytes = new byte[length];
    rng.GetBytes(bytes);
    var chars = new char[length];
    for (int i = 0; i < length; i++) {
      chars[i] = pool[bytes[i] % pool.Length];
    }
    return new string(chars);
  }
}

Rust（rand + getrandom）

use rand::rngs::OsRng;
use rand::RngCore;

fn random_password(length: usize, pool: &str) -> String {
    let mut bytes = vec![0u8; length];
    OsRng.fill_bytes(&mut bytes);
    let chars: Vec = pool.chars().collect();
    bytes
        .iter()
        .map(|b| chars[(*b as usize) % chars.len()])
        .collect()
}

fn main() {
    let pool = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*+-=_~`|/?()[]{}<>,.;:'\"";
    let pw = random_password(16, pool);
    println!("{}", pw);
}