Generatore di stringhe casuali
Un generatore di stringhe casuali online e gratuito. Crittograficamente sicuro, con distribuzione uniforme, e non invia mai nulla a un server.
Altre opzioni
Informazioni su questo generatore di stringhe casuali
Un generatore di stringhe casuali produce una sequenza di caratteri in cui ogni posizione viene estratta a caso da un alfabeto scelto da te. Gli sviluppatori usano le stringhe casuali come chiavi API, token di sessione, link per reimpostare la password, identificatori di database, nomi di file, codici di invito e dati di test. L’unica cosa che separa un buon generatore da uno cattivo è da dove arriva la casualità e come viene trasformata in caratteri, e nessuna delle due si vede nel risultato. Una stringa che sembra casuale non è la stessa cosa di una stringa che lo è davvero.
Questo generatore di stringhe casuali funziona online nella scheda del tuo browser e mai su un server. Usa la stessa fonte crittografica che il tuo sistema operativo mette a disposizione dei gestori di password e delle librerie TLS, la trasforma in caratteri senza distorsioni e ti dice esattamente quanta entropia contiene il risultato. È gratuito, non richiede un account e continua a funzionare anche se ti disconnetti dalla rete dopo che la pagina è stata caricata.
Come si usa
- Imposta la lunghezza con la casella numerica o con il cursore. Il valore predefinito è 24 caratteri, il cursore va da 1 a 128 e la casella numerica accetta fino a 4096.
- Scegli un set di caratteri. I pulsanti attivano o disattivano maiuscole, minuscole, cifre e simboli, e il menu a tendina offre alfabeti pronti come esadecimale, Base58, Base32 e Base64 sicuro per URL.
- Premi Genera, oppure il tasto G. In alto compare una nuova stringa, con la sua robustezza in bit subito sotto.
- Premi Copia. Per più di un valore, apri Altre opzioni, imposta una quantità fino a 10.000 e scegli uno per riga, separati da virgole, array JSON, elenco tra virgolette o assegnazioni
.env, poi copia o scarica l’intero blocco.
Stringhe casuali con caratteri speciali
Attivando il pulsante dei simboli si aggiungono dodici caratteri speciali: ! # $ % * + - = ? @ ^ _. Questo insieme è scelto apposta. Ognuno di essi compare negli elenchi dei caratteri consentiti per le password di Microsoft Entra ID, Active Directory e OWASP, e nessuno rompe un comando di shell, un URL o un valore di configurazione tra virgolette come fanno una barra rovesciata, una virgoletta o uno spazio. Insieme a lettere e cifre dà un alfabeto di 74 caratteri, pari a 6,2095 bit per carattere, solo il 5,3% in meno dell’insieme completo di 94 caratteri ASCII stampabili. Se ti servono tutti i simboli, o una selezione diversa, scrivi il tuo alfabeto nel campo del set di caratteri personalizzato. La pagina sulle stringhe casuali con caratteri speciali (in inglese) spiega quali sistemi rifiutano quali simboli.
Stringhe casuali lunghe
Un generatore di stringhe casuali lunghe serve per chiavi di crittografia, segreti di firma e per riempire un campo fino al limite e vedere cosa si rompe. Questo strumento genera una singola stringa fino a 4096 caratteri, con lo stesso campionamento senza distorsioni a qualsiasi lunghezza. Lunghezza e alfabeto si moltiplicano: 24 lettere e cifre portano circa 143 bit, già più di quanto possa raggiungere qualsiasi attacco a forza bruta, mentre 64 caratteri ne portano circa 381. Oltre i 128 bit circa, un segreto più lungo non aggiunge più sicurezza concreta ma solo dimensione, quindi adatta la lunghezza all’uso. Il generatore di stringhe da 64 caratteri e il calcolatore di entropia (entrambi in inglese) mostrano il calcolo per qualsiasi combinazione.
Cosa rende sicuro un generatore di stringhe casuali
Due cose, e la maggior parte dei generatori ne sbaglia almeno una. La prima è la fonte. Un generatore di stringhe casuali sicuro legge da un generatore di numeri casuali crittograficamente sicuro: crypto.getRandomValues() nel browser, che attinge al sistema operativo. Molti strumenti online usano ancora Math.random(), veloce e adatto ai giochi ma prevedibile per chiunque osservi qualche output. Lo spieghiamo nel dettaglio in perché Math.random() non è sicuro (in inglese).
La seconda è la conversione. Prendere un numero casuale modulo la dimensione dell’alfabeto rende alcuni caratteri più probabili di altri, e questo generatore elimina il problema con il campionamento per rifiuto, come descritto più sotto e in la distorsione del modulo spiegata (in inglese). I test statistici che lo confermano sono pubblicati nella pagina della metodologia, accanto a un’implementazione volutamente difettosa che quegli stessi test individuano.
Online o nel tuo codice
Un generatore di stringhe casuali online è l’opzione più rapida quando ti serve un valore subito: un segreto per un file .env, un dato di test, una password occasionale. Quando la stringa deve essere creata dentro un’applicazione in fase di esecuzione, generala in quel linguaggio invece di incollarla. Gli esempi più in basso in questa pagina mostrano l’approccio corretto per ogni piattaforma:
- Python: il modulo
secrets, mairandom. - Java:
SecureRandom, maijava.util.Random. - JavaScript:
crypto.getRandomValues()nel browser e in Node.js, maiMath.random(). - C++:
std::uniform_int_distributionsustd::random_device, oppure libsodium quando serve una garanzia. - PHP:
random_int(), mairand()némt_rand(). - C#:
RandomNumberGenerator.GetString()su .NET 8, oppureGetInt32()su .NET 6 e 7. - PowerShell:
RandomNumberGeneratorin PowerShell 7, oppureGet-Random -Maximumper ogni carattere nella versione 5.1. Non aggiungere mai-SetSeede non costruire mai la stringa con-Count.
Come scegliere tra gli strumenti per stringhe casuali
La maggior parte degli strumenti per generare stringhe casuali si assomiglia, quindi giudicali in base a ciò che puoi verificare. Il valore viene creato nel tuo browser o restituito da un server dove può essere registrato? Il sito dice quale fonte casuale usa? La robustezza indicata scende quando richiedi tutti i tipi di caratteri, come dovrebbe? Puoi escludere caratteri simili come 0 O 1 l I per le stringhe che devono leggere delle persone? Apri gli strumenti per sviluppatori del browser, passa alla scheda Rete e premi Genera: su questo sito non compare nulla. Per esigenze più specifiche, prova il generatore di stringhe casuali in blocco, il generatore con caratteri personalizzati, il generatore di password oppure tutti i generatori del sito (in inglese).
Come funziona questo generatore
Ogni valore proviene da crypto.getRandomValues(), l’interfaccia del browser verso il generatore di numeri casuali crittografico del sistema operativo. Non esiste un piano di riserva: se un browser non può fornire una fonte sicura, questo strumento si rifiuta di generare invece di usare di nascosto una fonte più debole.
È nel trasformare quei bit grezzi in caratteri che la maggior parte dei generatori sbaglia. L’approccio ovvio, prendere il resto della divisione di un numero casuale per la dimensione dell’alfabeto, non divide in modo esatto e sposta il risultato verso i caratteri all’inizio dell’alfabeto. Associare un singolo byte a 62 caratteri rende i primi otto 1,25 volte più probabili degli altri cinquantaquattro. Questo strumento scarta le estrazioni che cadono nell’ultimo ciclo incompleto, così ogni carattere ha esattamente la stessa probabilità.
La stessa cura vale per l’opzione che richiede un carattere per ogni tipo. Invece di forzare una cifra in una posizione fissa, cosa che lascia uno schema visibile, il generatore produce un’intera stringa candidata e la scarta se non rispetta il vincolo. Tutte le stringhe valide sono ugualmente probabili, e l’entropia indicata scende al valore reale invece che a quello della formula ingenua.
Pubblichiamo i risultati dei test invece di chiederti di fidarti. Su 500.000 caratteri generati, il test del chi quadrato sulla frequenza dei caratteri dà p = 0,673. La stessa batteria applicata a un’implementazione volutamente distorta la individua con chi quadrato = 3345 e 61 gradi di libertà: è così che sappiamo che i test sono abbastanza sensibili perché il risultato pulito abbia un significato. Leggi la metodologia completa (in inglese).
Come farlo nel tuo codice
Se ti serve dentro un’applicazione e non in una scheda del browser, ecco il modo corretto per farlo in ogni linguaggio. Ogni esempio usa la fonte crittografica della piattaforma e una conversione senza distorsioni.
JavaScript (browser e Node 19+)
const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
function randomString(length) {
const n = ALPHABET.length;
// Largest multiple of n that fits in a uint32. Values at or above this
// are discarded, which is what removes the modulo bias.
const limit = Math.floor(2 ** 32 / n) * n;
const out = new Array(length);
const buf = new Uint32Array(length);
crypto.getRandomValues(buf);
for (let i = 0, j = 0; i < length; i++) {
let v = buf[j++];
while (v >= limit) {
// Refill one word at a time on the rare rejection.
const extra = new Uint32Array(1);
crypto.getRandomValues(extra);
v = extra[0];
}
out[i] = ALPHABET[v % n];
}
return out.join("");
}
randomString(24);crypto.getRandomValues() rifiuta una singola richiesta oltre i 65.536 byte, quindi un blocco grande va suddiviso in parti.
Python 3.6+
import secrets
import string
ALPHABET = string.ascii_letters + string.digits
def random_string(length: int) -> str:
# secrets.choice() is unbiased: it uses randbelow(), which is itself
# rejection sampling over os.urandom. Do not use random.choice() here,
# which is a Mersenne Twister and is not cryptographically secure.
return "".join(secrets.choice(ALPHABET) for _ in range(length))
random_string(24)secrets fa parte della libreria standard da Python 3.6. Tutto ciò che usa il modulo random è lo strumento sbagliato per un segreto.
Go
package main
import (
"crypto/rand"
"math/big"
)
const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
func randomString(length int) (string, error) {
out := make([]byte, length)
max := big.NewInt(int64(len(alphabet)))
for i := range out {
// rand.Int is unbiased; it rejects internally.
n, err := rand.Int(rand.Reader, max)
if err != nil {
return "", err
}
out[i] = alphabet[n.Int64()]
}
return string(out), nil
}crypto/rand, mai math/rand. Da Go 1.20 il generatore globale di math/rand riceve da solo un seme casuale, cosa che non migliora in alcun modo la sua prevedibilità.
Rust
// rand = "0.9"
use rand::Rng;
use rand::distr::{Alphanumeric, SampleString};
fn random_string(length: usize) -> String {
// rand::rng() is a thread-local ChaCha12 CSPRNG, seeded from the
// operating system and reseeded periodically.
// Alphanumeric samples uniformly over A-Z a-z 0-9.
Alphanumeric.sample_string(&mut rand::rng(), length)
}
// With an arbitrary alphabet, random_range rejection-samples:
fn random_from(alphabet: &[u8], length: usize) -> String {
let mut rng = rand::rng();
(0..length)
.map(|_| alphabet[rng.random_range(0..alphabet.len())] as char)
.collect()
}Con rand 0.8 i percorsi sono diversi: rand::distributions invece di rand::distr, DistString invece di SampleString, gen_range invece di random_range e rand::thread_rng() invece di rand::rng().
PHP 7+
<?php
function randomString(int $length): string {
$alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
$n = strlen($alphabet);
$out = '';
for ($i = 0; $i < $length; $i++) {
// random_int() is unbiased and cryptographically secure.
// rand() and mt_rand() are neither.
$out .= $alphabet[random_int(0, $n - 1)];
}
return $out;
}
echo randomString(24);Java 17+
import java.security.SecureRandom;
public final class RandomString {
private static final String ALPHABET =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
private static final SecureRandom RANDOM = new SecureRandom();
public static String generate(int length) {
StringBuilder sb = new StringBuilder(length);
for (int i = 0; i < length; i++) {
// nextInt(bound) rejects internally, so it is unbiased.
sb.append(ALPHABET.charAt(RANDOM.nextInt(ALPHABET.length())));
}
return sb.toString();
}
}SecureRandom, non java.util.Random né Math.random(), che sono entrambi generatori congruenziali lineari a 48 bit.
C# / .NET 6+
using System.Security.Cryptography;
public static class RandomStringGenerator
{
private const string Alphabet =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
public static string Generate(int length)
{
// GetString was added in .NET 8 and is unbiased.
return RandomNumberGenerator.GetString(Alphabet, length);
}
// On .NET 6 and 7, GetInt32 is the unbiased primitive:
public static string GenerateLegacy(int length)
{
var chars = new char[length];
for (int i = 0; i < length; i++)
chars[i] = Alphabet[RandomNumberGenerator.GetInt32(Alphabet.Length)];
return new string(chars);
}
}C++11 e successivi
#include <random>
#include <string>
std::string random_string(std::size_t length) {
static const std::string alphabet =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
// uniform_int_distribution is specified to give every value in the range
// equal probability, so there is no modulo bias to remove by hand.
std::random_device rd;
std::uniform_int_distribution<std::size_t> pick(0, alphabet.size() - 1);
std::string out;
out.reserve(length);
for (std::size_t i = 0; i < length; ++i) {
out += alphabet[pick(rd)];
}
return out;
}std::random_device legge la fonte del sistema operativo con libstdc++, libc++ e MSVC, ma lo standard gli consente di essere deterministico, e le build MinGW precedenti a GCC 9.2 lo erano. Quando la garanzia conta, usa randombytes_uniform() di libsodium. Mai std::rand() né std::mt19937 per un segreto.
PowerShell 7
$chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
# GetInt32 draws from the OS CSPRNG and rejection samples internally.
-join (1..24 | ForEach-Object {
$chars[[System.Security.Cryptography.RandomNumberGenerator]::GetInt32($chars.Length)]
})Windows PowerShell 5.1 gira su .NET Framework, che non ha GetInt32. Lì scegli ogni carattere con Get-Random -Maximum $chars.Length, che usa il CSPRNG del sistema a meno che non venga indicato -SetSeed. Evita Get-Random -Count, che non ripete mai un carattere.
Shell
# 24 alphanumeric characters from the kernel CSPRNG.
LC_ALL=C tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 24; echo
# Base64, URL-safe, from 32 bytes of entropy.
openssl rand -base64 32 | tr '+/' '-_' | tr -d '='tr scarta i byte fuori dall’insieme invece di ripiegarli al suo interno, quindi questa pipeline non ha distorsioni. Mettere `head -c 24` prima di `tr` dà solo la parte alfanumerica di 24 byte grezzi, cioè una stringa più corta e di lunghezza variabile, non 24 caratteri.
Guide complete (in inglese) con token, password, generazione in blocco ed errori comuni in ogni linguaggio, con ogni esempio eseguito nell’ambiente reale:
Come scegliere la lunghezza
La lunghezza ha senso solo insieme all’alfabeto. Una stringa di 20 cifre porta circa 66 bit; 20 caratteri presi dalle 62 lettere e cifre ne portano 119. La tabella indica quanti caratteri servono per raggiungere una certa robustezza, e il generatore mostra il valore esatto per ciò che hai selezionato.
| Alfabeto | Bit/carattere | 64 bit | 112 bit | 128 bit |
|---|---|---|---|---|
| Solo cifre (10) | 3,3219 | 20 | 34 | 39 |
| Lettere minuscole (26) | 4,7004 | 14 | 24 | 28 |
| Hex (16) | 4,0000 | 16 | 28 | 32 |
| Lettere e cifre (62) | 5,9542 | 11 | 19 | 22 |
| Senza caratteri simili (49) | 5,6147 | 12 | 20 | 23 |
| Con simboli sicuri (74) | 6,2095 | 11 | 19 | 21 |
Escludere i caratteri simili costa 0,3395 bit per carattere, pari al 5,70%. Un carattere in più ogni diciassette compensa la perdita, e di solito ne vale la pena per tutto ciò che una persona deve leggere ad alta voce o ridigitare.
Domande frequenti
Che cos’è un generatore di stringhe casuali?
Un generatore di stringhe casuali è uno strumento che costruisce una stringa estraendo a caso ogni carattere da un alfabeto, per esempio lettere, cifre e simboli. Un buon generatore usa una fonte casuale crittograficamente sicura e dà a ogni carattere esattamente la stessa probabilità, così il risultato non può essere né previsto né riprodotto.
A cosa serve una stringa casuale?
Le stringhe casuali si usano come chiavi API, token di sessione, link per reimpostare la password e verificare l’email, token CSRF, password, segreti di crittografia e firma, identificatori di database e di file, codici coupon e di invito, e dati di test per verificare come un’applicazione gestisce un input di una certa lunghezza.
È sicuro usare un generatore di stringhe casuali online?
Sì, se la stringa viene generata nel tuo browser senza essere inviata altrove e se lo strumento usa una fonte casuale sicura. Puoi verificarlo tu stesso su questo sito: apri la scheda Rete negli strumenti per sviluppatori del browser, premi Genera e non compare nessuna richiesta. Un generatore che crea il valore su un server deve inviartelo, quindi potrebbe essere registrato lungo il percorso.
Questo generatore di stringhe casuali online è gratuito?
Sì. È gratuito, senza account, senza limiti di utilizzo e senza restrizioni per l’uso commerciale. Funziona online nel tuo browser e, una volta caricata la pagina, continua a funzionare anche offline.
Come si genera una stringa casuale con caratteri speciali?
Attiva il pulsante !#$%. Aggiunge dodici simboli, ! # $ % * + - = ? @ ^ _, accettati da quasi tutte le politiche sulle password e che non rompono né i comandi di shell né gli URL. Per un altro insieme di simboli, scrivi esattamente l’alfabeto che vuoi nel campo del set di caratteri personalizzato, in Altre opzioni.
Come si genera una stringa casuale lunga?
Scrivi la lunghezza nella casella numerica accanto al cursore. Il cursore arriva a 128, ma la casella accetta qualsiasi lunghezza fino a 4096 caratteri. L’entropia indicata si aggiorna mentre scrivi, così vedi quando la stringa è abbastanza lunga per il suo scopo.
Come si genera una stringa alfanumerica casuale?
Lascia attivi i pulsanti A-Z, a-z e 0-9 e disattivato quello dei simboli, che è l’impostazione predefinita. Ottieni un alfabeto di 62 caratteri, circa 5,95 bit per carattere, quindi una stringa di 24 caratteri porta circa 143 bit. Per sole lettere disattiva 0-9; per soli numeri disattiva entrambi i pulsanti delle lettere.
Posso generare più stringhe casuali alla volta?
Sì. Apri Altre opzioni e imposta una quantità fino a 10.000. I risultati si possono mostrare uno per riga, separati da virgole, come array JSON, come elenco tra virgolette o come assegnazioni .env, e si possono copiare o scaricare come file. Spunta «Tutti i risultati devono essere diversi tra loro» se il blocco non deve contenere duplicati.
Le stringhe casuali sono uniche?
Non è garantito, ma una stringa abbastanza lunga è unica nella pratica. I duplicati seguono il paradosso del compleanno: con circa 143 bit, cioè 24 lettere e cifre, dovresti generare circa 2^71 stringhe prima che una ripetizione diventi probabile. Con le stringhe corte è diverso; un codice di 6 caratteri si ripete molto prima, quindi verifica l’unicità nel tuo database quando la stringa è corta.
Cosa rende sicuro un generatore di stringhe casuali?
Una fonte casuale crittograficamente sicura, come crypto.getRandomValues() nel browser, e una conversione senza distorsioni dai numeri casuali ai caratteri. Un generatore basato su Math.random() è prevedibile, e uno che usa l’operatore modulo senza campionamento per rifiuto rende alcuni caratteri più probabili di altri. Questo strumento non fa né l’una né l’altra cosa e pubblica i risultati dei suoi test.
Come si genera una stringa casuale in Python?
Usa il modulo secrets: "".join(secrets.choice(string.ascii_letters + string.digits) for _ in range(24)). secrets.choice è crittograficamente sicuro e senza distorsioni. Non usare random.choice, che si basa su Mersenne Twister e può essere previsto a partire dal suo output.
Come si genera una stringa casuale in Java?
Crea un solo java.security.SecureRandom e chiama nextInt(alphabet.length()) per ogni carattere, aggiungendo alphabet.charAt() a uno StringBuilder. nextInt con un limite non ha distorsioni. Non usare java.util.Random né Math.random(), entrambi generatori prevedibili a 48 bit.
Come si genera una stringa casuale in JavaScript?
Riempi un Uint32Array con crypto.getRandomValues(), scarta i valori pari o superiori al più grande multiplo della dimensione dell’alfabeto e usa gli altri come indici nell’alfabeto. Funziona in tutti i browser moderni e in Node.js 19 e versioni successive. La funzione completa è negli esempi di codice di questa pagina. Math.random() non è sicuro per questo scopo.
Come si genera una stringa casuale in C++?
Usa std::uniform_int_distribution su std::random_device e indicizza il tuo alfabeto. La distribuzione è senza distorsioni per specifica. std::random_device legge la fonte del sistema operativo con i principali compilatori, ma lo standard non lo garantisce, quindi usa randombytes_uniform() di libsodium quando è importante. Evita std::rand().
Come si genera una stringa casuale in PHP?
Chiama random_int(0, strlen($alphabet) - 1) per ogni carattere e aggiungi il carattere in quella posizione. random_int è crittograficamente sicuro, senza distorsioni e integrato da PHP 7. Non usare rand(), mt_rand() né str_shuffle() per nulla di segreto.
Come si genera una stringa casuale in C#?
Su .NET 8 e versioni successive, chiama RandomNumberGenerator.GetString(alphabet, length), sicuro e senza distorsioni in una riga. Su .NET 6 e 7, chiama RandomNumberGenerator.GetInt32(alphabet.Length) per ogni carattere. System.Random non è adatto ai segreti.
Come si genera una stringa casuale in PowerShell?
Su PowerShell 7.4 e versioni successive, chiama [System.Security.Cryptography.RandomNumberGenerator]::GetString($chars, 24). Su Windows PowerShell 5.1, che non ha quel metodo, aggiungi $chars[(Get-Random -Maximum $chars.Length)] una volta per carattere. Get-Random usa il generatore crittografico del sistema, a meno che tu non passi -SetSeed. Evita Get-Random -Count, che non ripete mai un carattere.
Come si genera una stringa casuale in Node.js?
Per una stringa esadecimale o sicura per URL, usa crypto.randomBytes(16).toString("hex") oppure crypto.randomBytes(18).toString("base64url"). Per un alfabeto personalizzato, scegli ogni carattere con crypto.randomInt(alphabet.length), sicuro e senza distorsioni. Non costruire segreti con Math.random().
Come si genera una stringa casuale su Linux o in Bash?
Esegui LC_ALL=C tr -dc "A-Za-z0-9" < /dev/urandom | head -c 24 per 24 lettere e cifre, oppure openssl rand -hex 16 per una stringa esadecimale di 32 caratteri. Entrambi leggono la fonte casuale del kernel. Evita $RANDOM, un valore a 15 bit proveniente da un generatore non crittografico.
Come si genera una stringa casuale in Go?
Usa crypto/rand. Da Go 1.24, rand.Text() restituisce una stringa Base32 di 26 caratteri con almeno 128 bit di casualità. Per il tuo alfabeto, scegli ogni carattere con rand.Int(rand.Reader, big.NewInt(int64(len(alphabet)))). Non usare mai math/rand per i segreti.
Come si genera una stringa casuale in Excel?
In Excel 365, =TEXTJOIN("",TRUE,CHAR(RANDARRAY(10,1,65,90,TRUE))) restituisce 10 lettere maiuscole casuali, che cambiano a ogni ricalcolo del foglio. In Excel in italiano la stessa formula si scrive di solito =TESTO.UNISCI("";VERO;CODICE.CARATT(MATR.CASUALE(10;1;65;90;VERO))). Le funzioni casuali di Excel non sono crittograficamente sicure, quindi usala solo per dati di test e genera password o chiavi con uno strumento sicuro.
Qualcosa di ciò che genero viene inviato a un server?
No. La generazione avviene interamente nel tuo browser tramite la Web Crypto API. Non esiste un backend a cui inviarla, e puoi verificarlo tu stesso: apri gli strumenti per sviluppatori del browser, passa alla scheda Rete e premi Genera. Non compare nulla.
Qual è la differenza rispetto a Math.random()?
Math.random() non è crittograficamente sicuro. V8 lo implementa con xorshift128+, un generatore non crittografico a 128 bit, e la specifica di JavaScript non richiede che il suo output sia imprevedibile. Lavori pubblicati mostrano che chi osserva qualche output può ricostruire lo stato interno e riprodurre tutti i valori passati e futuri. Questo strumento usa crypto.getRandomValues(), che attinge al CSPRNG del sistema operativo.
Cos’è la distorsione del modulo, e questo strumento ne soffre?
Ridurre un numero casuale con l’operatore modulo sposta il risultato verso l’inizio dell’alfabeto. Associare un byte a 62 caratteri dà 256 = 4x62 + 8, quindi i primi otto caratteri sono 1,25 volte più probabili degli altri. Questo strumento la elimina con il campionamento per rifiuto: le estrazioni che cadono nell’ultimo ciclo incompleto vengono scartate invece di essere riutilizzate.
Perché l’entropia scende quando richiedo tutti i tipi di caratteri?
Perché deve scendere. Richiedere almeno una cifra esclude tutte le stringhe senza cifre, quindi i risultati possibili sono meno e l’entropia reale è inferiore a lunghezza x log2(dimensione dell’alfabeto). La maggior parte dei generatori continua a mostrare il valore più alto. Questo conta le stringhe valide per inclusione-esclusione e mostra il valore reale, con quello senza vincoli tra parentesi, così vedi quanto costa.
Quanto deve essere lunga una stringa casuale?
Dipende da cosa protegge. Per un valore che un attaccante può solo indovinare online, contro un servizio che limita le richieste, 64 bit sono più che sufficienti. Per un segreto che potrebbe essere intercettato e attaccato offline, punta a 112 bit o più; 19 caratteri alfanumerici arrivano a 113 bit. Per le password, NIST SP 800-63B richiede un minimo di 15 caratteri e sconsiglia esplicitamente le regole di composizione.
Posso usarlo per password, chiavi API e token di sessione?
Sì. La fonte di casualità è la stessa che il tuo sistema operativo offre a qualsiasi applicazione, e la conversione in caratteri non ha distorsioni. Quello che lo strumento non può fare è proteggere il valore dopo che ha lasciato questa pagina, quindi tratta il risultato come qualsiasi altro segreto.
Velocità
Generare 10.000 stringhe da 32 caratteri richiede 17 ms. I blocchi grandi vengono prodotti a pezzi, liberando il thread principale tra un pezzo e l’altro, così la pagina resta reattiva e l’operazione può essere annullata. Tre dei generatori che oggi compaiono nella prima pagina di Google non hanno alcun limite di quantità e bloccano la scheda.