Sicurezza

120 password casuali per server, chiavi master, account admin

120 password casuali generate con il metodo Unbiased Random Selection (CSPRNG di sistema con rejection sampling). Lunghezze da 32 a 10 caratteri. Click su una password per copiarla negli appunti.

Password in formato ASCII

Le più sicure: charset di 86 caratteri stampabili, entropia 6.43 bit/char. Una password ASCII da 16 caratteri ha già circa 103 bit di entropia: a mille miliardi di tentativi al secondo (un rig GPU offline contro un hash veloce) servirebbero in media circa 140 miliardi di anni per trovarla con brute-force. Da 30 caratteri si sale a circa 193 bit, fuori portata di qualunque attacco a forza bruta. Usale per servizi critici: accesso server, chiavi master, account amministrativi.

Charset: !"#$%&'()*+,-./23456789:;<=>?@ABCDEFGHJKMNPQRSTUVWXYZ[\]^_`abcdefghjkmnpqrstuvwxyz{|}~

32 caratteri · Molto forte (~206 bit)

XhB"6=wx8CT,xk&t{54'PFb}nuz4m3|^

Q!2Q<4Rr?EW[*#X6XnK"!yqE?cnh68vZ

Vbq>u)UvSw\fFmYFM%nph>WjGf'dVHZ{

hS\Q=D$W5?#f$^6AdYh\kenGrDN>'%t{

_5{YCSz;SFbUF[+5W<jwSK[a$pNB\33=

/7Cr~[CXSrcdWdy$M7d4MU/`C=BtU[..

_BhH&*9"E;27/25Yg7**/p4)W_Vs"Ze'

v*Y%tf!|Df=-@\B95JfT^'9wr%TA]\DA

8:8~RXj86.dx|bp=5_BP"@3C>'b$}dD4

,kRXmX/VD{^w!p?9Eb#[;#'YHd27w<!/

24 caratteri · Molto forte (~154 bit)

D#U7]Sf&Cmp7/9+]PJ-X`{\m

5rT%%xD(&#K=6~@$.83cg:6^

c.=dwgT*#u>dekSZ6!=>dW~+

z3F6EVt-G:P"B|erzY@](3eq

Ku//b|X9a]DJ<aVVq<;**{wm

\^.(du/ajcprQdb&MG#P`'4c

m%B%<G|W3]w22G?$(3$y$Gwn

$T?h2.?KU&cJ_}@unkFgk'c^

kjQp9U!\]+%_&+s}*\9\s&kR

yBfQYh)vf3v`\~>a!5WqXy|H

20 caratteri · Molto forte (~129 bit)

9.hXe9|PM?dX35h<)*h?

>)qX<)d9\"x=pF3JSqRU

E(_RUJ=zfFg[q^^M%_4@

K=7)fPGWGHNZCvd#`kHk

@MhK5rvG9t\sap@>2B5c

;\'~AK4#a)$]zkF#.Q[#

(J%y$asWk5'duQ/q-CY6

'TADx;C?TzF)VT@E\3()

:"53?'~n^Nh|+;^}:ku\

6R`TK{env,H[73^+M}@-

16 caratteri · Forte (~103 bit)

dqmtnAz8!U"P#K+!

%nt$\z5:\Gu!@krt

BwFb/7xk(%Ns;EDV

6*qa4m,e[5:%.x&@

}?J/;3`{D?DsJ39t

'tuFsf\pU;vRKD$-

+jCpK'$*[%;Q[rCt

TBP"~FA=s6|$4-?3

F^BnQ&Qx2@4>|U&m

,m7RH_.VM*nf]n%s

12 caratteri · Discreta (~77 bit)

&3(f=zNy)`xd

ScX/[!<&{bbF

^=upsz5vDWV>

YP>&9/Uu9V>K

gPj)qY}`~e:y

/5C,}kCs/_p~

]Er%gB4@sWSE

^d3VjDs?t:JK

_#5,dK5~?.f{

m%?Z%^W2Ktqn

10 caratteri · Discreta (~64 bit)

s*$p5B68kS

GE\yK_/t\P

CZE"6RWpX[

":_qjcY{NK

U();Mjq/Bh

aSs\T%yw>X

CR"rDd_|DN

Sbr`4sQ6w@

Q~/P.*~re^

3qD;]9vs8Y

Password in formato alfanumerico

Charset ridotto (54 caratteri): più leggibili e digitabili ma meno entropia per simbolo. OK per servizi con policy che vietano caratteri speciali. Per tutto il resto, preferisci l'ASCII qui sopra.

Charset: ABCDEFGHJKMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz23456789

32 caratteri · Molto forte (~184 bit)

K45caExJVJwkkfUKQSwrPkgvv48GxzMU

NwgD49fVu7EEztJvqM7wDVAbFGkq9nyw

kEVkunDmtfWTwgSXfq3fxRecmgEuENyf

xEY8DyTPsxQYYqtrq62ZcUBUKh7gRzkW

JDy7rmFQ9HUt4KJjN839KJxdwJTBYNHN

YNuXBHSSC3zPeWJ2gpKfJ7HU9bhCenCK

mYKAjB4xX52XdJghYTjKxv7gvjT6kqMe

TYrYnjvcYntzg7w6AHMN2adDEzmyVQNa

58h63BYTkBSYxwZrRh6gFFnyKSJRuN3U

AJWsHwmn2FdSZumpA6v5c2QJvwJJ4gPs

24 caratteri · Molto forte (~138 bit)

tKZh78cXYquNPaQsz49CuBkm

kChnU6UDgqbQFVx28s7a2sSM

n2cRTgQs6wycYkAckRP8XCYK

gAmAmbYfkWeWvWbcuF9aXTpR

SgdAKaRB2XwBakX5cPFpSwJg

Wd649nXVDNhmyXwKuuyeRa7d

j277zdArMgXAY4x5THaNhsHU

JaG8GRn4BAgCNhV4nYc6MRzJ

6Jvvb3r9Qc5SM2M3bmrzTr34

spAzz2GRmwsEdzHVgAm6GXBe

20 caratteri · Molto forte (~115 bit)

MUj4NTH2QVPZNK58DaNP

Cb8N2xKhTu5SKGqQE7pH

v3WDUBnNfugZuSkTwKqD

BQPGz3zFQpCZRAURGW6H

zD5wjwYjVG8fvKa7hw7V

MpuBMyVz4FY9zpwxt4Ww

RR7EMsJcNzsc75N7sh8H

5yp7fNRyemzu7x54gCkH

yysv8B9TQ49YD5yMXAWR

45zvUFCE6XhgYSw6maXM

16 caratteri · Forte (~92 bit)

HMwQjnzBUmWhaAEz

JRaBe4FpZEQcq32P

hSZBcJGHxh7r3NY7

snXGa6daYEwkK4Q9

UvKVegqm9jsFWgY4

2vsNz9tadADYAtSw

9zvJ4Ezj74arWvvu

X3NMQAy6Ddxbkxyv

VEJmxechvumAHsuN

UxGrNQbKBWRwumCs

12 caratteri · Discreta (~69 bit)

bjE4dNnY3xez

pJ7ug9brpy48

rRd6zkZGk9Xw

6NV5UVv6qCXM

fvVzneHqa6Yx

2AeAEyzXcpgY

Q68V3mfCN9Vt

5bdKpsweWcqJ

S8sTJdHteg4q

pZfrQhKAvWQf

10 caratteri · Debole (~58 bit)

VkFHw6KXxg

AA2RMtmtd9

ay4WBzHGz2

AFmT5SdQdD

GdCtDpgj5C

cHkpGY4cpy

Ybxct5Vw5q

QDrYDDvcze

wDyDV4K9M6

fQ6AFeTrzU

Perché queste password sono sicure davvero

La generazione usa unbiased random sampling tramite la PHP random_bytes() e quindi il CSPRNG del sistema operativo (/dev/urandom su Linux, equivalenti su altri OS), con rejection sampling (maschera di bit, scarto dei valori fuori range) per evitare il modulo bias che molti generatori artigianali sbagliano: ogni carattere ha probabilità esattamente 1/|charset|. Su 20 caratteri ASCII l'entropia reale è di 128 bit. Per confronto, una password "robusta" scelta da un umano ha tipicamente 30-50 bit di entropia ed è brute-forciabile in ore su GPU moderne. Le password servite in pagina esistono solo nell'HTML inviato al tuo browser: non vengono loggate, non vengono salvate da nessuna parte e non sopravvivono al caricamento della pagina.

Domande frequenti

Quanto è lunga una password davvero sicura nel 2026?

Per account personali: almeno 16 caratteri ASCII (circa 100 bit di entropia). Per server SSH, chiavi API, account amministrativi: 24-32 caratteri. Il vero fattore di sicurezza è l'entropia totale, non il tipo di caratteri: una password di 30 caratteri ASCII è più sicura di una di 12 caratteri con 'simboli obbligatori'.

Perché le password generate qui non contengono '0', '1', 'l', 'I', 'O'?

Ambiguità visiva. Se devi leggere o digitare a mano la password (su mobile, su console seriale, su terminale di un server remoto), i caratteri simili tra loro causano errori. Il charset escluso mantiene la stessa entropia effettiva (rimuovere 8 caratteri su 94 (0, 1 e le lettere I/L/O sia maiuscole che minuscole) cambia l'entropia per carattere di ~0,13 bit, irrilevante rispetto alla lunghezza totale).

Le password vengono loggate o trasmesse altrove?

No. Il PHP che genera le password gira server-side in un processo isolato, non logga l'output, non lo invia in nessun database e non lo conserva. Ogni ricarica della pagina produce 120 password nuove che esistono solo nell'HTML servito a te. Le password sono sempre servite via HTTPS.

random_bytes() è davvero sicuro?

Sì. In PHP 8.x random_bytes() legge dal CSPRNG di sistema (/dev/urandom su Linux, equivalenti su altri OS): è la stessa sorgente di entropia che alimenta i tool crittografici standard, e se l'entropia non è disponibile lancia un'eccezione invece di restituire byte deboli. Il generatore applica rejection sampling per evitare il modulo bias, dettaglio critico che molti generatori artigianali sbagliano e che porta a distribuzioni non uniformi sul charset.

Posso usare queste password per crittografia o chiavi API?

Per password di account e servizi sono adatte. Per chiavi crittografiche (AES, RSA, ECDSA) no: le chiavi vanno generate direttamente con la libreria crittografica che le userà, con il formato e la lunghezza specifici dell'algoritmo. Usare una password ASCII come chiave crittografica introduce una derivazione (KDF) non necessaria e tipicamente sbagliata.

E se lavoro in un'azienda dove tutti condividono password scritte in Excel?

Situazione comune, molto rischiosa, risolvibile. Migrare a un password manager aziendale (Bitwarden self-hosted, 1Password Business, Vaultwarden) richiede 2-3 giorni di consulenza per setup + formazione. Se vuoi un percorso strutturato per la tua azienda, contattami: è una delle aree in cui lavoro regolarmente.

La gestione password nella tua azienda non è a posto?

Se la tua azienda usa ancora password condivise in un Excel, credenziali ripetute tra servizi, o non ha un password manager centralizzato, il rischio di compromissione è alto e misurabile. Offro consulenza specifica su password policy aziendali, migrazione a password manager self-hosted (Vaultwarden/Bitwarden), e audit delle credenziali dei servizi in uso. Vent'anni di esperienza backend + cybersecurity applicata.

Parla con me di sicurezza password