Générateur de chaînes aléatoires
Un générateur de chaînes aléatoires gratuit en ligne. Cryptographiquement sûr, uniformément distribué, et rien n’est jamais envoyé à un serveur.
Plus d’options
À propos de ce générateur de chaînes aléatoires
Un générateur de chaînes aléatoires produit une suite de caractères dont chaque position est tirée au hasard dans un alphabet que vous choisissez. Les développeurs utilisent des chaînes aléatoires comme clés d’API, jetons de session, liens de réinitialisation de mot de passe, identifiants de base de données, noms de fichiers, codes d’invitation et données de test. Ce qui distingue un bon générateur d’un mauvais, c’est uniquement la provenance de l’aléa et la façon dont il est transformé en caractères, et rien de tout cela ne se voit dans le résultat. Une chaîne qui a l’air aléatoire n’est pas la même chose qu’une chaîne qui l’est vraiment.
Ce générateur de chaînes aléatoires fonctionne en ligne dans l’onglet de votre navigateur, jamais sur un serveur. Il utilise la même source cryptographique que celle que votre système d’exploitation fournit aux gestionnaires de mots de passe et aux bibliothèques TLS, la convertit en caractères sans biais et vous indique exactement combien d’entropie contient le résultat. Il est gratuit, ne demande aucun compte et continue de fonctionner si vous vous déconnectez du réseau une fois la page chargée.
Mode d’emploi
- Réglez la longueur avec le champ numérique ou le curseur. La valeur par défaut est de 24 caractères, le curseur va de 1 à 128 et le champ numérique accepte jusqu’à 4 096.
- Choisissez un jeu de caractères. Les boutons activent ou désactivent les majuscules, les minuscules, les chiffres et les symboles, et la liste déroulante propose des alphabets tout prêts comme l’hexadécimal, Base58, Base32 et Base64 compatible URL.
- Appuyez sur Générer, ou sur la touche G. Une nouvelle chaîne apparaît en haut, avec sa robustesse en bits juste en dessous.
- Appuyez sur Copier. Pour plusieurs valeurs, ouvrez Plus d’options, indiquez une quantité jusqu’à 10 000 et choisissez un par ligne, séparés par des virgules, un tableau JSON, une liste entre guillemets ou des affectations
.env, puis copiez ou téléchargez l’ensemble du lot.
Chaînes aléatoires avec caractères spéciaux
Activer le bouton des symboles ajoute douze caractères spéciaux : ! # $ % * + - = ? @ ^ _. Cet ensemble est choisi délibérément. Chacun d’eux figure dans les listes de caractères autorisés pour les mots de passe de Microsoft Entra ID, d’Active Directory et de l’OWASP, et aucun ne casse une commande shell, une URL ou une valeur de configuration entre guillemets comme le font une barre oblique inverse, un guillemet ou une espace. Avec les lettres et les chiffres, on obtient un alphabet de 74 caractères, soit 6,2095 bits par caractère, seulement 5,3 % de moins que l’ensemble complet des 94 caractères ASCII imprimables. S’il vous faut tous les symboles, ou une autre sélection, saisissez votre propre alphabet dans le champ du jeu de caractères personnalisé. La page consacrée aux chaînes aléatoires avec caractères spéciaux (en anglais) détaille quels systèmes refusent quels symboles.
Chaînes aléatoires longues
Un générateur de chaînes aléatoires longues sert pour les clés de chiffrement, les secrets de signature, et pour remplir un champ jusqu’à sa limite afin de voir ce qui casse. Cet outil génère une seule chaîne jusqu’à 4 096 caractères, avec le même échantillonnage sans biais quelle que soit la longueur. Longueur et alphabet se multiplient : 24 lettres et chiffres apportent environ 143 bits, ce qui dépasse déjà ce que n’importe quelle attaque par force brute peut atteindre, tandis que 64 caractères apportent environ 381 bits. Au-delà d’environ 128 bits, un secret plus long n’apporte plus de sécurité concrète, seulement de la taille ; adaptez donc la longueur à l’usage. Le générateur de chaînes de 64 caractères et le calculateur d’entropie (tous deux en anglais) montrent le calcul pour n’importe quelle combinaison.
Ce qui rend un générateur de chaînes aléatoires sûr
Deux choses, et la plupart des générateurs se trompent sur au moins l’une d’elles. La première est la source. Un générateur de chaînes aléatoires sûr lit un générateur de nombres aléatoires cryptographiquement sûr : crypto.getRandomValues() dans le navigateur, qui puise dans le système d’exploitation. Beaucoup d’outils en ligne utilisent encore Math.random(), rapide et suffisant pour les jeux, mais prévisible pour quiconque observe quelques sorties. C’est expliqué en détail dans pourquoi Math.random() n’est pas sûr (en anglais).
La seconde est la conversion. Prendre un nombre aléatoire modulo la taille de l’alphabet rend certains caractères plus probables que d’autres ; ce générateur élimine ce biais par échantillonnage par rejet, comme décrit plus bas et dans le biais du modulo expliqué (en anglais). Les tests statistiques qui le confirment sont publiés sur la page méthodologie, à côté d’une implémentation volontairement défaillante que ces mêmes tests détectent.
En ligne ou dans votre propre code
Un générateur de chaînes aléatoires en ligne est l’option la plus rapide quand il vous faut une valeur tout de suite : un secret pour un fichier .env, une donnée de test, un mot de passe ponctuel. Quand la chaîne doit être créée dans une application au moment de l’exécution, générez-la dans ce langage plutôt que de la coller. Les exemples plus bas sur cette page présentent la bonne approche pour chaque plateforme :
- Python : le module
secrets, jamaisrandom. - Java :
SecureRandom, jamaisjava.util.Random. - JavaScript :
crypto.getRandomValues()dans le navigateur et dans Node.js, jamaisMath.random(). - C++ :
std::uniform_int_distributionsurstd::random_device, ou libsodium quand une garantie est nécessaire. - PHP :
random_int(), jamaisrand()nimt_rand(). - C# :
RandomNumberGenerator.GetString()sur .NET 8, ouGetInt32()sur .NET 6 et 7. - PowerShell :
RandomNumberGeneratordans PowerShell 7, ouGet-Random -Maximumpour chaque caractère dans la version 5.1. N’ajoutez jamais-SetSeedet ne construisez jamais la chaîne avec-Count.
Bien choisir un outil de génération de chaînes aléatoires
La plupart des outils de génération de chaînes aléatoires se ressemblent : jugez-les donc sur ce que vous pouvez vérifier. La valeur est-elle créée dans votre navigateur, ou renvoyée par un serveur où elle peut être journalisée ? Le site indique-t-il quelle source aléatoire il utilise ? Le chiffre de robustesse baisse-t-il quand vous exigez tous les types de caractères, comme il le devrait ? Pouvez-vous exclure les caractères qui se ressemblent, comme 0 O 1 l I, pour des chaînes que des personnes doivent lire ? Ouvrez les outils de développement du navigateur, passez à l’onglet Réseau et appuyez sur Générer : sur ce site, rien n’apparaît. Pour des besoins plus spécifiques, voyez le générateur de chaînes aléatoires en lot, le générateur à caractères personnalisés, le générateur de mots de passe ou tous les générateurs du site (en anglais).
Comment fonctionne ce générateur
Chaque valeur provient de crypto.getRandomValues(), l’interface du navigateur vers le générateur de nombres aléatoires cryptographique du système d’exploitation. Il n’y a pas de solution de repli : si un navigateur ne peut pas fournir de source sûre, cet outil refuse de générer plutôt que d’utiliser discrètement une source plus faible.
C’est en transformant ces bits bruts en caractères que la plupart des générateurs se trompent. L’approche évidente, prendre le reste de la division d’un nombre aléatoire par la taille de l’alphabet, ne tombe pas juste et fait pencher le résultat vers les caractères du début de l’alphabet. Faire correspondre un seul octet à 62 caractères rend les huit premiers 1,25 fois plus probables que les cinquante-quatre autres. Cet outil écarte les tirages qui tombent dans le dernier cycle incomplet, si bien que chaque caractère est exactement aussi probable que les autres.
Le même soin s’applique à l’option qui exige un caractère de chaque type. Plutôt que de forcer un chiffre à une position fixe, ce qui laisse un motif visible, le générateur produit une chaîne candidate complète et la rejette si elle ne respecte pas la contrainte. Toutes les chaînes valides sont également probables, et l’entropie affichée descend au chiffre réel au lieu de celui que donne la formule naïve.
Nous publions les résultats des tests au lieu de vous demander de nous croire sur parole. Sur 500 000 caractères générés, le test du khi-deux sur la fréquence des caractères donne p = 0,673. La même batterie appliquée à une implémentation volontairement biaisée la détecte avec khi-deux = 3345 pour 61 degrés de liberté : c’est ainsi que nous savons que les tests sont assez sensibles pour que le résultat propre ait un sens. Lire la méthodologie complète (en anglais).
Dans votre propre code
Si vous en avez besoin dans une application plutôt que dans un onglet de navigateur, voici la bonne façon de faire dans chaque langage. Chaque exemple utilise la source cryptographique de la plateforme et une conversion sans biais.
JavaScript (navigateur et 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() refuse une seule demande de plus de 65 536 octets : un gros lot doit donc être découpé.
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 fait partie de la bibliothèque standard depuis Python 3.6. Tout ce qui utilise le module random est le mauvais outil pour un secret.
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, jamais math/rand. Depuis Go 1.20, le générateur global de math/rand reçoit de lui-même une graine aléatoire, ce qui n’améliore en rien sa prévisibilité.
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()
}Avec rand 0.8, les chemins diffèrent : rand::distributions au lieu de rand::distr, DistString au lieu de SampleString, gen_range au lieu de random_range et rand::thread_rng() au lieu de 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, et non java.util.Random ni Math.random(), qui sont tous deux des générateurs congruentiels linéaires de 48 bits.
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 et versions ultérieures
#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 lit la source du système d’exploitation avec libstdc++, libc++ et MSVC, mais la norme l’autorise à être déterministe, et les compilations MinGW antérieures à GCC 9.2 l’étaient. Quand une garantie compte, utilisez randombytes_uniform() de libsodium. Jamais std::rand() ni std::mt19937 pour un secret.
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 s’exécute sur .NET Framework, qui n’a pas GetInt32. Dans ce cas, choisissez chaque caractère avec Get-Random -Maximum $chars.Length, qui utilise le CSPRNG du système sauf si -SetSeed est indiqué. Évitez Get-Random -Count, qui ne répète jamais un caractère.
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 élimine les octets hors de l’ensemble au lieu de les y replier, ce pipeline est donc sans biais. Placer `head -c 24` avant `tr` donne le sous-ensemble alphanumérique de 24 octets bruts, soit une chaîne plus courte et de longueur variable, pas 24 caractères.
Guides complets (en anglais) avec jetons, mots de passe, génération en lot et erreurs courantes dans chaque langage, chaque exemple ayant été exécuté sur le vrai environnement :
Choisir la longueur
La longueur n’a de sens qu’avec l’alphabet. Une chaîne de 20 chiffres apporte environ 66 bits ; 20 caractères tirés parmi les 62 lettres et chiffres en apportent 119. Le tableau indique le nombre de caractères nécessaire pour atteindre une robustesse donnée, et le générateur affiche le chiffre exact pour votre sélection.
| Alphabet | Bits/caractère | 64 bits | 112 bits | 128 bits |
|---|---|---|---|---|
| Chiffres seuls (10) | 3,3219 | 20 | 34 | 39 |
| Lettres minuscules (26) | 4,7004 | 14 | 24 | 28 |
| Hex (16) | 4,0000 | 16 | 28 | 32 |
| Lettres et chiffres (62) | 5,9542 | 11 | 19 | 22 |
| Sans caractères ressemblants (49) | 5,6147 | 12 | 20 | 23 |
| Avec symboles sûrs (74) | 6,2095 | 11 | 19 | 21 |
Exclure les caractères qui se ressemblent coûte 0,3395 bit par caractère, soit 5,70 %. Un caractère de plus tous les dix-sept compense cette perte, ce qui en vaut généralement la peine pour tout ce qu’une personne doit lire à voix haute ou retaper.
Questions fréquentes
Qu’est-ce qu’un générateur de chaînes aléatoires ?
Un générateur de chaînes aléatoires est un outil qui construit une chaîne en tirant chaque caractère au hasard dans un alphabet, par exemple des lettres, des chiffres et des symboles. Un bon générateur utilise une source aléatoire cryptographiquement sûre et donne exactement la même probabilité à chaque caractère, si bien que le résultat ne peut être ni prédit ni reproduit.
À quoi sert une chaîne aléatoire ?
Les chaînes aléatoires servent de clés d’API, de jetons de session, de liens de réinitialisation de mot de passe et de vérification d’e-mail, de jetons CSRF, de mots de passe, de secrets de chiffrement et de signature, d’identifiants de base de données et de fichiers, de codes promo et d’invitation, et de données de test pour vérifier comment une application gère une saisie d’une longueur donnée.
Est-il sûr d’utiliser un générateur de chaînes aléatoires en ligne ?
Oui, si la chaîne est générée dans votre navigateur sans jamais être envoyée ailleurs, et si l’outil utilise une source aléatoire sûre. Vous pouvez le vérifier vous-même sur ce site : ouvrez l’onglet Réseau des outils de développement du navigateur, appuyez sur Générer, et aucune requête n’apparaît. Un générateur qui crée la valeur sur un serveur doit vous l’envoyer, et elle peut donc être journalisée en chemin.
Ce générateur de chaînes aléatoires en ligne est-il gratuit ?
Oui. Il est gratuit, sans compte, sans limite d’utilisation et sans restriction pour un usage commercial. Il fonctionne en ligne dans votre navigateur et, une fois la page chargée, il continue aussi de fonctionner hors ligne.
Comment générer une chaîne aléatoire avec des caractères spéciaux ?
Activez le bouton !#$%. Il ajoute douze symboles, ! # $ % * + - = ? @ ^ _, acceptés par presque toutes les politiques de mots de passe et qui ne cassent ni les commandes shell ni les URL. Pour un autre ensemble de symboles, saisissez exactement l’alphabet voulu dans le champ du jeu de caractères personnalisé, sous Plus d’options.
Comment générer une longue chaîne aléatoire ?
Saisissez la longueur dans le champ numérique à côté du curseur. Le curseur va jusqu’à 128, mais le champ accepte toute longueur jusqu’à 4 096 caractères. L’entropie affichée se met à jour pendant la saisie, ce qui permet de voir quand la chaîne est assez longue pour l’usage prévu.
Comment générer une chaîne alphanumérique aléatoire ?
Laissez les boutons A-Z, a-z et 0-9 activés et celui des symboles désactivé, ce qui correspond au réglage par défaut. Vous obtenez un alphabet de 62 caractères, environ 5,95 bits par caractère, soit environ 143 bits pour une chaîne de 24 caractères. Pour des lettres seules, désactivez 0-9 ; pour des chiffres seuls, désactivez les deux boutons de lettres.
Puis-je générer plusieurs chaînes aléatoires à la fois ?
Oui. Ouvrez Plus d’options et indiquez une quantité jusqu’à 10 000. Les résultats peuvent s’afficher un par ligne, séparés par des virgules, en tableau JSON, en liste entre guillemets ou en affectations .env, puis être copiés ou téléchargés dans un fichier. Cochez « Tous les résultats doivent être différents les uns des autres » si le lot ne doit contenir aucun doublon.
Les chaînes aléatoires sont-elles uniques ?
Rien ne le garantit, mais une chaîne assez longue est unique en pratique. Les doublons suivent le paradoxe des anniversaires : avec environ 143 bits, soit 24 lettres et chiffres, il faudrait générer autour de 2^71 chaînes avant qu’une répétition devienne probable. Les chaînes courtes sont un autre cas ; un code de 6 caractères se répète bien plus tôt, alors vérifiez l’unicité dans votre base de données quand la chaîne est courte.
Qu’est-ce qui rend un générateur de chaînes aléatoires sûr ?
Une source aléatoire cryptographiquement sûre, comme crypto.getRandomValues() dans le navigateur, et une conversion sans biais des nombres aléatoires en caractères. Un générateur fondé sur Math.random() est prévisible, et un générateur qui utilise l’opérateur modulo sans échantillonnage par rejet rend certains caractères plus probables que d’autres. Cet outil ne fait ni l’un ni l’autre, et publie les résultats de ses tests.
Comment générer une chaîne aléatoire en Python ?
Utilisez le module secrets : "".join(secrets.choice(string.ascii_letters + string.digits) for _ in range(24)). secrets.choice est cryptographiquement sûr et sans biais. N’utilisez pas random.choice, qui repose sur Mersenne Twister et peut être prédit à partir de sa sortie.
Comment générer une chaîne aléatoire en Java ?
Créez un seul java.security.SecureRandom et appelez nextInt(alphabet.length()) pour chaque caractère, en ajoutant alphabet.charAt() à un StringBuilder. nextInt avec une borne est sans biais. N’utilisez pas java.util.Random ni Math.random(), deux générateurs prévisibles de 48 bits.
Comment générer une chaîne aléatoire en JavaScript ?
Remplissez un Uint32Array avec crypto.getRandomValues(), écartez les valeurs supérieures ou égales au plus grand multiple de la taille de l’alphabet et indexez l’alphabet avec les autres. Cela fonctionne dans tous les navigateurs modernes et dans Node.js 19 et versions ultérieures. La fonction complète se trouve dans les exemples de code de cette page. Math.random() n’est pas sûr pour cet usage.
Comment générer une chaîne aléatoire en C++ ?
Utilisez std::uniform_int_distribution sur std::random_device et indexez votre alphabet. La distribution est sans biais d’après la spécification. std::random_device lit la source du système d’exploitation avec les principaux compilateurs, mais la norme ne le garantit pas : utilisez randombytes_uniform() de libsodium quand c’est important. Évitez std::rand().
Comment générer une chaîne aléatoire en PHP ?
Appelez random_int(0, strlen($alphabet) - 1) pour chaque caractère et ajoutez le caractère à cette position. random_int est cryptographiquement sûr, sans biais et intégré depuis PHP 7. N’utilisez pas rand(), mt_rand() ni str_shuffle() pour quoi que ce soit de secret.
Comment générer une chaîne aléatoire en C# ?
Sur .NET 8 et versions ultérieures, appelez RandomNumberGenerator.GetString(alphabet, length), sûr et sans biais en une ligne. Sur .NET 6 et 7, appelez RandomNumberGenerator.GetInt32(alphabet.Length) pour chaque caractère. System.Random ne convient pas aux secrets.
Comment générer une chaîne aléatoire en PowerShell ?
Sur PowerShell 7.4 et versions ultérieures, appelez [System.Security.Cryptography.RandomNumberGenerator]::GetString($chars, 24). Sur Windows PowerShell 5.1, qui ne dispose pas de cette méthode, ajoutez $chars[(Get-Random -Maximum $chars.Length)] une fois par caractère. Get-Random puise dans le générateur cryptographique du système, sauf si vous passez -SetSeed. Évitez Get-Random -Count, qui ne répète jamais un caractère.
Comment générer une chaîne aléatoire en Node.js ?
Pour une chaîne hexadécimale ou compatible URL, utilisez crypto.randomBytes(16).toString("hex") ou crypto.randomBytes(18).toString("base64url"). Pour un alphabet personnalisé, choisissez chaque caractère avec crypto.randomInt(alphabet.length), sûr et sans biais. Ne construisez pas de secrets avec Math.random().
Comment générer une chaîne aléatoire sous Linux ou en Bash ?
Exécutez LC_ALL=C tr -dc "A-Za-z0-9" < /dev/urandom | head -c 24 pour 24 lettres et chiffres, ou openssl rand -hex 16 pour une chaîne hexadécimale de 32 caractères. Les deux lisent la source aléatoire du noyau. Évitez $RANDOM, une valeur de 15 bits issue d’un générateur non cryptographique.
Comment générer une chaîne aléatoire en Go ?
Utilisez crypto/rand. Depuis Go 1.24, rand.Text() renvoie une chaîne Base32 de 26 caractères avec au moins 128 bits d’aléa. Pour votre propre alphabet, choisissez chaque caractère avec rand.Int(rand.Reader, big.NewInt(int64(len(alphabet)))). N’utilisez jamais math/rand pour des secrets.
Comment générer une chaîne aléatoire dans Excel ?
Dans Excel 365, =TEXTJOIN("",TRUE,CHAR(RANDARRAY(10,1,65,90,TRUE))) donne 10 lettres majuscules aléatoires, qui changent à chaque recalcul de la feuille. Dans Excel en français, la même formule s’écrit généralement =JOINDRE.TEXTE("";VRAI;CAR(TABLEAU.ALEA(10;1;65;90;VRAI))). Les fonctions aléatoires d’Excel ne sont pas cryptographiquement sûres : réservez-les aux données de test et générez mots de passe et clés avec un outil sûr.
Ce que je génère est-il envoyé à un serveur ?
Non. La génération se fait entièrement dans votre navigateur grâce à l’API Web Crypto. Il n’y a aucun serveur auquel l’envoyer, et vous pouvez le confirmer vous-même : ouvrez les outils de développement du navigateur, passez à l’onglet Réseau et appuyez sur Générer. Rien n’apparaît.
Quelle différence avec Math.random() ?
Math.random() n’est pas cryptographiquement sûr. V8 l’implémente avec xorshift128+, un générateur non cryptographique de 128 bits, et la spécification JavaScript n’exige pas que sa sortie soit imprévisible. Des travaux publiés montrent qu’un observateur qui voit quelques sorties peut retrouver l’état interne et reproduire toutes les valeurs passées et futures. Cet outil utilise crypto.getRandomValues(), qui puise dans le CSPRNG du système d’exploitation.
Qu’est-ce que le biais du modulo, et cet outil en souffre-t-il ?
Réduire un nombre aléatoire avec l’opérateur modulo fait pencher le résultat vers le début de l’alphabet. Faire correspondre un octet à 62 caractères donne 256 = 4x62 + 8, donc les huit premiers caractères sont 1,25 fois plus probables que les autres. Cet outil élimine ce biais par échantillonnage par rejet : les tirages qui tombent dans le dernier cycle incomplet sont écartés au lieu d’être replacés.
Pourquoi l’entropie baisse-t-elle quand j’exige tous les types de caractères ?
Parce qu’elle doit baisser. Exiger au moins un chiffre interdit toutes les chaînes sans chiffre : il y a moins de résultats possibles, et l’entropie réelle est inférieure à longueur x log2(taille de l’alphabet). La plupart des générateurs continuent d’afficher le chiffre le plus élevé. Celui-ci compte les chaînes valides par inclusion-exclusion et affiche le chiffre réel, avec la valeur sans contraintes entre parenthèses pour que vous voyiez le coût.
Quelle longueur doit avoir une chaîne aléatoire ?
Cela dépend de ce qu’elle protège. Pour une valeur qu’un attaquant ne peut deviner qu’en ligne, face à un service qui limite le nombre de requêtes, 64 bits suffisent largement. Pour un secret qui pourrait être capturé puis attaqué hors ligne, visez 112 bits ou plus ; 19 caractères alphanumériques atteignent 113 bits. Pour un mot de passe, la norme NIST SP 800-63B impose un minimum de 15 caractères et déconseille explicitement les règles de composition.
Puis-je l’utiliser pour des mots de passe, des clés d’API et des jetons de session ?
Oui. La source d’aléa est la même que celle que votre système d’exploitation propose à n’importe quelle application, et la conversion en caractères est sans biais. En revanche, l’outil ne peut pas protéger la valeur une fois qu’elle a quitté cette page : traitez le résultat comme n’importe quel autre secret.
Vitesse
Générer 10 000 chaînes de 32 caractères prend 17 ms. Les gros lots sont produits par tranches en libérant le fil principal entre chacune, si bien que la page reste réactive et que l’opération peut être annulée. Trois des générateurs actuellement classés en première page de Google n’ont aucune limite de quantité et figent l’onglet à la place.