Quel est le caractère unique de l’UUID?

Très sûr:

le risque annuel qu’une personne donnée soit frappée par une météorite est estimé à une chance sur 17 milliards, ce qui signifie que la probabilité est d’environ 0,00000000006 (6 × 10 ⁻¹¹ ), ce qui équivaut à la probabilité de créer quelques dizaines de sortingllions d’UUID dans un an et avoir un duplicata. En d’autres termes, ce n’est qu’après avoir généré 1 milliard d’UUID par seconde pendant les 100 années suivantes que la probabilité de créer un seul duplicata serait d’environ 50%.

Caveat:

Cependant, ces probabilités ne sont valables que lorsque les UUID sont générés avec une entropie suffisante. Sinon, la probabilité de duplication pourrait être sensiblement plus élevée, car la dispersion statistique pourrait être plus faible. Lorsque des identificateurs uniques sont requirejs pour les applications dissortingbuées, de sorte que les identificateurs UUID ne se heurtent pas même lorsque les données de nombreux périphériques sont fusionnées, le caractère aléatoire des sources et des générateurs utilisés sur chaque périphérique doit être fiable. Si ce n’est pas possible, la RFC4122 recommande d’utiliser une variante d’espace de noms à la place.

Source: http://en.wikipedia.org/wiki/UUID#Random_UUID_probability_of_duplicates

L’article de Wikepedia a cette section supprimée, mais ils ont une référence utile Lien externe vers quelque part ailleurs: http://www.h2database.com/html/advanced.html#uuid

Si, par “suffisamment de temps”, vous voulez dire 100 ans et que vous les créez à un milliard par seconde, alors oui, vous avez 50% de chances d’avoir une collision après 100 ans.

Il y a plus d’un type d’UUID, donc “how safe” dépend de quel type (que les spécifications d’UUID appellent “version”) que vous utilisez.

• La version 1 correspond à l’adresse UUID basée sur l’adresse MAC plus l’adresse MAC. Le 128 bits contient 48 bits pour l’adresse MAC de la carte réseau (atsortingbuée de manière unique par le fabricant) et une horloge 60 bits avec une résolution de 100 nanosecondes. Cette horloge se déroule en 3603 AD, donc ces UUID sont sûrs au moins jusqu’à présent (à moins que vous ayez besoin de plus de 10 millions de nouveaux UUID par seconde ou que quelqu’un clone votre carte réseau). Je dis «au moins» parce que l’horloge commence au 15 octobre 1582, donc il vous rest environ 400 ans après l’horloge avant même qu’il y ait une petite possibilité de duplication.

• La version 4 est le nombre aléatoire UUID. Il y a six bits fixes et le rest de l’UUID est un caractère aléatoire de 122 bits. Voir Wikipedia ou une autre parsing qui décrit à quel point un doublon est improbable.

• La version 3 est utilisée MD5 et la version 5 utilise SHA-1 pour créer ces 122 bits, au lieu d’un générateur de nombres aléatoires ou pseudo-aléatoires. Donc, en termes de sécurité, c’est comme si la version 4 était un problème statistique (à condition que vous vous assuriez que l’algorithme de traitement est toujours unique).

• La version 2 est similaire à la version 1, mais avec une horloge plus petite, elle se déroulera beaucoup plus tôt. Mais comme les UUID version 2 sont destinés à l’ETCD, vous ne devriez pas les utiliser.

Donc, pour tous les problèmes pratiques, ils sont en sécurité. Si vous n’êtes pas à l’aise avec les probabilités (par exemple si vous êtes le genre de personne inquiète que la Terre soit détruite par un grand astéroïde au cours de votre vie), assurez-vous d’utiliser un UUID version 1 et garanti unique ( dans votre vie, sauf si vous prévoyez de vivre après 3603 AD).

Alors, pourquoi tout le monde n’utilise-t-il pas les UUID de la version 1? En effet, les UUID de la version 1 révèlent l’adresse MAC de la machine sur laquelle ils ont été générés et ils peuvent être prévisibles, deux éléments pouvant avoir des conséquences sur la sécurité de l’application utilisant ces UUID.

La réponse à cette question peut dépendre largement de la version UUID.

De nombreux générateurs UUID utilisent un nombre aléatoire de version 4. Cependant, beaucoup d’entre eux utilisent Pseudo un générateur de nombres aléatoires pour les générer.

Si un PRNG mal classé avec une petite période est utilisé pour générer l’UUID, je dirais que ce n’est pas très sûr du tout.

Par conséquent, c’est seulement aussi sûr que les algorithmes utilisés pour le générer.

D’un autre côté, si vous connaissez la réponse à ces questions alors je pense qu’une version 4 uuid devrait être très sûre à utiliser. En fait, je l’utilise pour identifier des blocs sur un système de fichiers en réseau et jusqu’à présent, je n’ai pas eu de conflit.

Dans mon cas, le PRNG que j’utilise est un twister de mersenne et je fais attention à la manière dont il est issu, qui provient de plusieurs sources, y compris / dev / urandom. Mersenne twister a une période de 2 ^ 19937-1. Il faudra beaucoup de temps avant de voir un uuid de répétition.

Citant de Wikipedia :

Ainsi, n’importe qui peut créer un UUID et l’utiliser pour identifier quelque chose avec une assurance raisonnable que l’identifiant ne sera jamais utilisé involontairement par quelqu’un d’autre.

Il explique ensuite en détail comment il est réellement sûr. Donc, pour répondre à votre question: oui, c’est assez sûr.

Les schémas UUID utilisent généralement non seulement un élément pseudo-aléatoire, mais aussi l’heure système actuelle et une sorte d’ID de matériel souvent unique, si disponible, tel qu’une adresse MAC réseau.

L’intérêt de l’utilisation d’UUID est que vous lui faites confiance pour fournir un identifiant unique que vous êtes capable de faire. Ceci est la même logique derrière l’utilisation d’une bibliothèque de cryptographie tierce plutôt que de rouler la vôtre. Le faire vous-même peut être plus amusant, mais il est généralement moins responsable de le faire.

Cela fait des années. Ne jamais se heurter à un problème.

J’ai l’habitude de configurer mon DB pour avoir une table qui contient toutes les clés et les dates modifiées et autres. Je n’ai jamais rencontré de problème de duplication de clés.

Le seul inconvénient est que lorsque vous écrivez des requêtes pour trouver rapidement des informations, vous faites beaucoup de copier-coller des clés. Vous n’avez pas le court facile à mémoriser les identifiants.

Voici un extrait de test pour vous permettre de tester ses versions uniques. inspiré par le commentaire de @ scalabl3

Ce qui est drôle, c’est que vous pourriez générer 2 fois de suite qui étaient identiques, bien sûr, à des niveaux de coïncidence, de chance et d’intervention divine époustouflants, mais malgré les difficultés insurmontables, c’est toujours possible! : D Oui, ça n’arrivera pas. juste dire pour l’amusement de penser à ce moment où vous avez créé un duplicata! Capture d’écran vidéo! – scalabl3 20 oct 15 à 19:11

Si vous avez de la chance, cochez la case, elle ne vérifie que les identifiants générés actuellement. Si vous souhaitez une vérification de l’historique, laissez-la décochée. S’il vous plaît noter que vous pourriez manquer de ram à un moment donné si vous ne le cochez pas. J’ai essayé de le rendre compatible avec le processeur afin de pouvoir abandonner rapidement en cas de besoin, il suffit de cliquer à nouveau sur le bouton d’exécution ou de quitter la page.

Math.log2 = Math.log2 || function(n){ return Math.log(n) / Math.log(2); } Math.trueRandom = (function() { var crypt = window.crypto || window.msCrypto; if (crypt && crypt.getRandomValues) { // if we have a crypto library, use it var random = function(min, max) { var rval = 0; var range = max - min; if (range < 2) { return min; } var bits_needed = Math.ceil(Math.log2(range)); if (bits_needed > 53) { throw new Exception("We cannot generate numbers larger than 53 bits."); } var bytes_needed = Math.ceil(bits_needed / 8); var mask = Math.pow(2, bits_needed) - 1; // 7776 -> (2^13 = 8192) -1 == 8191 or 0x00001111 11111111 // Create byte array and fill with N random numbers var byteArray = new Uint8Array(bytes_needed); crypt.getRandomValues(byteArray); var p = (bytes_needed - 1) * 8; for(var i = 0; i < bytes_needed; i++ ) { rval += byteArray[i] * Math.pow(2, p); p -= 8; } // Use & to apply the mask and reduce the number of recursive lookups rval = rval & mask; if (rval >= range) { // Integer out of acceptable range return random(min, max); } // Return an integer that falls within the range return min + rval; } return function() { var r = random(0, 1000000000) / 1000000000; return r; }; } else { // From http://baagoe.com/en/RandomMusings/javascript/ // Johannes Baagøe , 2010 function Mash() { var n = 0xefc8249d; var mash = function(data) { data = data.toSsortingng(); for (var i = 0; i < data.length; i++) { n += data.charCodeAt(i); var h = 0.02519603282416938 * n; n = h >>> 0; h -= n; h *= n; n = h >>> 0; h -= n; n += h * 0x100000000; // 2^32 } return (n >>> 0) * 2.3283064365386963e-10; // 2^-32 }; mash.version = 'Mash 0.9'; return mash; } // From http://baagoe.com/en/RandomMusings/javascript/ function Alea() { return (function(args) { // Johannes Baagøe , 2010 var s0 = 0; var s1 = 0; var s2 = 0; var c = 1; if (args.length == 0) { args = [+new Date()]; } var mash = Mash(); s0 = mash(' '); s1 = mash(' '); s2 = mash(' '); for (var i = 0; i < args.length; i++) { s0 -= mash(args[i]); if (s0 < 0) { s0 += 1; } s1 -= mash(args[i]); if (s1 < 0) { s1 += 1; } s2 -= mash(args[i]); if (s2 < 0) { s2 += 1; } } mash = null; var random = function() { var t = 2091639 * s0 + c * 2.3283064365386963e-10; // 2^-32 s0 = s1; s1 = s2; return s2 = t - (c = t | 0); }; random.uint32 = function() { return random() * 0x100000000; // 2^32 }; random.fract53 = function() { return random() + (random() * 0x200000 | 0) * 1.1102230246251565e-16; // 2^-53 }; random.version = 'Alea 0.9'; random.args = args; return random; }(Array.prototype.slice.call(arguments))); }; return Alea(); } }()); Math.guid = function() { return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) { var r = Math.trueRandom() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8); return v.toString(16); }); }; function logit(item1, item2) { console.log("Do "+item1+" and "+item2+" equal? "+(item1 == item2 ? "OMG! take a screenshot and you'll be epic on the world of cryptography, buy a lottery ticket now!":"No they do not. shame. no fame")+ ", runs: "+window.numberofRuns); } numberofRuns = 0; function test() { window.numberofRuns++; var x = Math.guid(); var y = Math.guid(); var test = x == y || historyTest(x,y); logit(x,y); return test; } historyArr = []; historyCount = 0; function historyTest(item1, item2) { if(window.luckyDog) { return false; } for(var i = historyCount; i > -1; i--) { logit(item1,window.historyArr[i]); if(item1 == history[i]) { return true; } logit(item2,window.historyArr[i]); if(item2 == history[i]) { return true; } } window.historyArr.push(item1); window.historyArr.push(item2); window.historyCount+=2; return false; } luckyDog = false; document.body.onload = function() { document.getElementById('runit').onclick = function() { window.luckyDog = document.getElementById('lucky').checked; var val = document.getElementById('input').value if(val.sortingm() == '0') { var intervaltimer = window.setInterval(function() { var test = window.test(); if(test) { window.clearInterval(intervaltimer); } },0); } else { var num = parseInt(val); if(num > 0) { var intervaltimer = window.setInterval(function() { var test = window.test(); num--; if(num < 0 || test) { window.clearInterval(intervaltimer); } },0); } } }; }; 

 Please input how often the calulation should run. set to 0 for forever. Check the checkbox if you feel lucky.
 Run
 

Je ne sais pas si cela compte pour vous, mais gardez à l’esprit que les GUID sont globalement uniques, mais que les sous-chaînes de GUID ne le sont pas .