Algorithme

Pour générer une chaîne aléatoire, concaténer les caractères tirés au hasard à partir de l’ensemble des symboles acceptables jusqu’à ce que la chaîne atteigne la longueur souhaitée.

la mise en oeuvre

Voici un code assez simple et très flexible pour générer des identificateurs aléatoires. Lisez les informations qui suivent pour les notes d’application importantes.

 import java.security.SecureRandom; import java.util.Locale; import java.util.Objects; import java.util.Random; public class RandomSsortingng { /** * Generate a random ssortingng. */ public Ssortingng nextSsortingng() { for (int idx = 0; idx < buf.length; ++idx) buf[idx] = symbols[random.nextInt(symbols.length)]; return new String(buf); } public static final String upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; public static final String lower = upper.toLowerCase(Locale.ROOT); public static final String digits = "0123456789"; public static final String alphanum = upper + lower + digits; private final Random random; private final char[] symbols; private final char[] buf; public RandomString(int length, Random random, String symbols) { if (length < 1) throw new IllegalArgumentException(); if (symbols.length() < 2) throw new IllegalArgumentException(); this.random = Objects.requireNonNull(random); this.symbols = symbols.toCharArray(); this.buf = new char[length]; } /** * Create an alphanumeric string generator. */ public RandomString(int length, Random random) { this(length, random, alphanum); } /** * Create an alphanumeric strings from a secure generator. */ public RandomString(int length) { this(length, new SecureRandom()); } /** * Create session identifiers. */ public RandomString() { this(21); } } 

Exemples d'utilisation

Créez un générateur non sécurisé pour les identifiants à 8 caractères:

 RandomSsortingng gen = new RandomSsortingng(8, ThreadLocalRandom.current()); 

Créez un générateur sécurisé pour les identifiants de session:

 RandomSsortingng session = new RandomSsortingng(); 

Créez un générateur avec des codes faciles à lire pour l'impression. Les chaînes sont plus longues que les chaînes alphanumériques complètes pour compenser l'utilisation de moins de symboles:

 Ssortingng easy = RandomSsortingng.digits + "ACEFGHJKLMNPQRUVWXYabcdefhijkprstuvwx"; RandomSsortingng tickets = new RandomSsortingng(23, new SecureRandom(), easy); 

Utiliser comme identifiant de session

Générer des identifiants de session susceptibles d'être uniques n'est pas suffisant, ou vous pouvez simplement utiliser un compteur simple. Les attaquants détournent les sessions lorsque des identificateurs prévisibles sont utilisés.

Il y a une tension entre la longueur et la sécurité. Les identifiants plus courts sont plus faciles à deviner, car les possibilités sont moins nombreuses. Mais les identificateurs plus longs consumnt plus de stockage et de bande passante. Un ensemble plus important de symboles aide, mais peut causer des problèmes de codage si les identificateurs sont inclus dans les URL ou rentrés manuellement.

La source sous-jacente du caractère aléatoire, ou entropie, des identificateurs de session doit provenir d'un générateur de nombres aléatoires conçu pour la cryptographie. Cependant, l'initialisation de ces générateurs peut parfois s'avérer coûteuse ou lente, il faut donc s'efforcer de les réutiliser lorsque cela est possible.

Utiliser comme identifiant d'object

Toutes les applications ne nécessitent pas de sécurité. L'atsortingbution aléatoire peut être un moyen efficace pour plusieurs entités de générer des identificateurs dans un espace partagé sans aucune coordination ou partitionnement. La coordination peut être lente, en particulier dans un environnement en cluster ou dissortingbué, et la division d'un espace pose des problèmes lorsque des entités se retrouvent avec des parts trop petites ou trop grandes.

Les identifiants générés sans prendre de mesures pour les rendre imprévisibles doivent être protégés par d'autres moyens si un attaquant peut les visualiser et les manipuler, comme cela se produit dans la plupart des applications Web. Il devrait y avoir un système d'autorisation distinct qui protège les objects dont l'identifiant peut être deviné par un attaquant sans autorisation d'access.

Il faut également veiller à utiliser des identificateurs suffisamment longs pour rendre les collisions improbables, compte tenu du nombre total d'identificateurs prévu. C'est ce qu'on appelle le "paradoxe de l'anniversaire". La probabilité d'une collision, p , est approximativement n ² / (2q ^x ), où n est le nombre d'identificateurs réellement générés, q est le nombre de symboles distincts dans l'alphabet et x est la longueur des identificateurs. Cela devrait être un très petit nombre, comme 2 ^-50 ou moins.

Cela montre que le risque de collision entre des identificateurs de 500 k à 15 caractères est d'environ 2 à ⁵² , ce qui est probablement moins probable que des erreurs non détectées dans les rayons cosmiques, etc.

Comparaison avec les UUID

Selon leur spécification, les UUID ne sont pas conçus pour être imprévisibles et ne doivent pas être utilisés comme identificateurs de session.

Les UUID dans leur format standard prennent beaucoup d'espace: 36 caractères pour seulement 122 bits d'entropie. (Tous les bits d'un UUID "aléatoire" ne sont pas sélectionnés de manière aléatoire.) Une chaîne alphanumérique choisie au hasard contient plus d'entropie en seulement 21 caractères.

Les UUID ne sont pas flexibles; ils ont une structure et une disposition normalisées. C'est leur principale vertu ainsi que leur principale faiblesse. Lors de la collaboration avec une tierce partie, la standardisation offerte par les UUID peut être utile. Pour un usage purement interne, ils peuvent être inefficaces.

Java fournit un moyen de le faire directement. Si vous ne voulez pas les tirets, ils sont faciles à éliminer. Utilisez simplement uuid.replace("-", "")

 import java.util.UUID; public class randomSsortingngGenerator { public static void main(Ssortingng[] args) { System.out.println(generateSsortingng()); } public static Ssortingng generateSsortingng() { Ssortingng uuid = UUID.randomUUID().toSsortingng(); return "uuid = " + uuid; } } 

Sortie:

 uuid = 2d7428a6-b58c-4008-8575-f05549f16316 

 static final Ssortingng AB = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; static SecureRandom rnd = new SecureRandom(); Ssortingng randomSsortingng( int len ){ SsortingngBuilder sb = new SsortingngBuilder( len ); for( int i = 0; i < len; i++ ) sb.append( AB.charAt( rnd.nextInt(AB.length()) ) ); return sb.toString(); } 

Si vous êtes heureux d’utiliser les classes Apache, vous pouvez utiliser org.apache.commons.text.RandomSsortingngGenerator (commons-text).

Exemple:

 RandomSsortingngGenerator randomSsortingngGenerator = new RandomSsortingngGenerator.Builder() .withinRange('0', 'z') .filteredBy(CharacterPredicates.LETTERS, CharacterPredicates.DIGITS) .build(); randomSsortingngGenerator.generate(12); // toUpperCase() if you want 

Depuis commons-lang 3.6, RandomSsortingngUtils est obsolète.

En une seule ligne:

 Long.toHexSsortingng(Double.doubleToLongBits(Math.random())); 

http://mynotes.wordpress.com/2009/07/23/java-generating-random-ssortingng/

Vous pouvez utiliser la bibliothèque Apache pour cela: RandomSsortingngUtils

 RandomSsortingngUtils.randomAlphanumeric(20).toUpperCase(); 

utiliser Dollar devrait être simple:

 // "0123456789" + "ABCDE...Z" Ssortingng validCharacters = $('0', '9').join() + $('A', 'Z').join(); Ssortingng randomSsortingng(int length) { return $(validCharacters).shuffle().slice(length).toSsortingng(); } @Test public void buildFiveRandomSsortingngs() { for (int i : $(5)) { System.out.println(randomSsortingng(12)); } } 

il produit quelque chose comme ça:

 DKL1SBH9UJWC JH7P0IT21EA5 5DTI72EO6SFU HQUMJTEBNF7Y 1HCR6SKYWGT7 

Ceci est facilement réalisable sans aucune bibliothèque externe.

1. Génération de données pseudo-aléatoires cryptographiques

Tout d’abord, vous avez besoin d’un PRNG cryptographique. Java a SecureRandom pour qui utilise généralement la meilleure source d’entropie sur la machine (par exemple /dev/random ). Lire plus ici.

 SecureRandom rnd = new SecureRandom(); byte[] token = new byte[byteLength]; rnd.nextBytes(token); 

Remarque: SecureRandom est le moyen le plus lent mais le plus sécurisé de Java pour générer des octets aléatoires. Je recommande toutefois de ne pas prendre en compte les performances ici, car cela n’a généralement pas d’impact réel sur votre application, sauf si vous devez générer des millions de jetons par seconde.

2. Espace requirejs de valeurs possibles

Ensuite, vous devez décider de «l’unicité» de votre jeton. Le seul et unique sharepoint considérer l’entropie est de s’assurer que le système résiste aux attaques par force brute: l’espace des valeurs possibles doit être si grand que tout attaquant ne pourrait essayer qu’une proportion négligeable des valeurs ¹ . Les identifiants uniques tels que l’ UUID aléatoire ont 122 bits d’entropie (c.-à-d. 2 ^ 122 = 5,3×10 ^ 36) – le risque de collision est “* (…) pour qu’il y ait une chance de duplication sur un milliard, 103 000 milliards les UUID version 4 doivent être générés ² “. Nous choisirons 128 bits car il correspond exactement à 16 octets et est considéré comme très suffisant pour être unique pour tous les cas d’utilisation, mais les plus extrêmes, et vous n’avez pas à penser aux doublons. Voici un tableau de comparaison simple d’entropie comprenant une parsing simple du problème de l’ anniversaire .

^{Pour des exigences simples, une longueur de 8 ou 12 octets peut suffire, mais avec 16 octets, vous êtes du côté “sûr”.}

Et c’est fondamentalement ça. La dernière chose à faire est de penser à l’encodage pour qu’il puisse être représenté sous forme de texte imprimable (read, a Ssortingng ).

3. Codage binary en texte

Les encodages typiques incluent:

• Base64 chaque caractère encode 6bit créant un surcoût de 33%. Malheureusement, il n’ya pas d’implémentation standard dans le JDK ( 7 et moins – il y en a dans Android et Java 8+ ). Mais il existe de nombreuses bibliothèques qui l’ajoutent. L’inconvénient est que ce Base64 standard n’est pas sûr pour, par exemple. URL et comme nom de fichier dans la plupart des systèmes de fichiers nécessitant un codage supplémentaire (par exemple, encodage d’URL ) ou la version sécurisée d’URL de Base64 est utilisée . Exemple d’encodage de 16 octets avec remplissage: XfJhfv3C0P6ag7y9VQxSbw==

• Base32 chaque caractère encode 5bit créant un surcoût de 40%. Cela utilisera AZ et 2-7 ce qui le rend raisonnablement efficace en termes d’espace tout en restant insensible à la casse. Il n’y a pas d’ implémentation standard dans le JDK . Exemple de codage de 16 octets sans remplissage: WUPIL5DQTZGMF4D3NX5L7LNFOY

• Base16 (hexadécimal) Chaque caractère code 4bits nécessitant 2 caractères par octet (c.-à-d. Base16 16 octets créent une chaîne de longueur 32). Par conséquent, hex est moins efficace en Base32 espace que Base32 mais est sûr à utiliser dans la plupart des cas (URL) car il n’utilise que 0-9 et A à F Exemple de codage 16 octets: 4fa3dd0f57cb3bf331441ed285b27735 . Voir une discussion SO sur la conversion en hexadécimal ici.

Des codages supplémentaires tels que Base85 et la base122 exotique existent avec un meilleur rendement de l’espace. Vous pouvez créer votre propre encodage (ce que font la plupart des réponses dans ce sujet), mais je vous le déconseille si vous n’avez pas des exigences très spécifiques. Voir plus de schémas d’encodage dans l’article de Wikipedia.

4. Résumé et exemple

• Utilisez SecureRandom
• Utiliser au moins 16 octets (2 ^ 128) de valeurs possibles
• Encodez selon vos besoins (généralement hex ou base32 si vous en avez besoin)

Ne pas

• … utilisez votre encodage personnel: plus facile à maintenir et à lire pour les autres s’ils voient quel encodage standard vous utilisez plutôt que bizarre pour les boucles créant des caractères à la fois.
• … utilisez UUID: vous perdez 6 bits d’entropie et avez une représentation en chaîne prolixe

Exemple: Générateur de jetons hexadécimal

 public static Ssortingng generateRandomHexToken(int byteLength) { SecureRandom secureRandom = new SecureRandom(); byte[] token = new byte[byteLength]; secureRandom.nextBytes(token); return new BigInteger(1, token).toSsortingng(16); //hex encoding } //generateRandomHexToken(16) -> 2189df7475e96aa3982dbeab266497cd 

Exemple: outil

Si vous voulez un outil cli prêt à l’emploi, vous pouvez utiliser dice: https://github.com/pasortingckfav/dice

Surprenant, personne ici ne l’a suggéré mais:

 import java.util.UUID UUID.randomUUID().toSsortingng(); 

Facile.

L’avantage de ceci est que les UUID sont agréables et longs et qu’il est presque impossible de les heurter.

Wikipedia en a une bonne explication:

“… seulement après avoir généré 1 milliard d’UUID par seconde pendant les 100 prochaines années, la probabilité de créer un seul duplicata serait d’environ 50%.”

http://en.wikipedia.org/wiki/Universally_unique_identifier#Random_UUID_probability_of_duplicates

Les 4 premiers bits sont le type de version et 2 pour la variante, donc vous obtenez 122 bits de hasard. Donc, si vous voulez, vous pouvez tronquer à la fin pour réduire la taille de l’UUID. Ce n’est pas recommandé, mais vous avez encore beaucoup de hasard, assez facile pour vos enregistrements 500k.

La voici en Java:

 import static java.lang.Math.round; import static java.lang.Math.random; import static java.lang.Math.pow; import static java.lang.Math.abs; import static java.lang.Math.min; import static org.apache.commons.lang.SsortingngUtils.leftPad public class RandomAlphaNum { public static Ssortingng gen(int length) { SsortingngBuffer sb = new SsortingngBuffer(); for (int i = length; i > 0; i -= 12) { int n = min(12, abs(i)); sb.append(leftPad(Long.toSsortingng(round(random() * pow(36, n)), 36), n, '0')); } return sb.toSsortingng(); } } 

Voici un exemple:

 scala> RandomAlphaNum.gen(42) res3: java.lang.Ssortingng = uja6snx21bswf9t89s00bxssu8g6qlu16ffzqaxxoy 

Une solution simple et rapide, mais n’utilise que des minuscules et des chiffres:

 Random r = new java.util.Random (); Ssortingng s = Long.toSsortingng (r.nextLong () & Long.MAX_VALUE, 36); 

La taille est d’environ 12 chiffres à la base 36 et ne peut pas être améliorée davantage, de cette façon. Bien sûr, vous pouvez append plusieurs instances.

Une alternative à Java 8 est:

 static final Random random = new Random(); // Or SecureRandom static final int startChar = (int) '!'; static final int endChar = (int) '~'; static Ssortingng randomSsortingng(final int maxLength) { final int length = random.nextInt(maxLength + 1); return random.ints(length, startChar, endChar + 1) .mapToObj((i) -> (char) i) .collect(SsortingngBuilder::new, SsortingngBuilder::append, SsortingngBuilder::append) .toSsortingng(); } 

 public static Ssortingng generateSessionKey(int length){ Ssortingng alphabet = new Ssortingng("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"); //9 int n = alphabet.length(); //10 Ssortingng result = new Ssortingng(); Random r = new Random(); //11 for (int i=0; i