Wie einzigartig ist UUID?

Wie sicher ist es, UUID zu verwenden, um etwas eindeutig zu identifizieren (ich verwende es für Dateien, die auf den Server hochgeladen wurden)? Soweit ich weiß, basiert es auf Zufallszahlen. Es scheint mir jedoch, dass es sich bei genügend Zeit irgendwann selbst wiederholen würde, nur durch Zufall. Gibt es ein besseres System oder ein Muster, um dieses Problem zu lösen?

Sehr sicher:

Das jährliche Risiko, dass eine bestimmte Person von einem Meteoriten getroffen wird, wird auf eine Chance von 17 Milliarden geschätzt, was bedeutet, dass die Wahrscheinlichkeit etwa 0,00000000006 (6 × 10 ^–11 ) beträgt, was der Wahrscheinlichkeit entspricht, einige zehn Billionen UUIDs zu erzeugen in einem Jahr und mit einem Duplikat. Mit anderen Worten, erst nachdem in den nächsten 100 Jahren pro Sekunde 1 Milliarde UUIDs generiert wurden, würde die Wahrscheinlichkeit, nur ein Duplikat zu erstellen, bei etwa 50% liegen.

Vorbehalt:

Diese Wahrscheinlichkeiten gelten jedoch nur, wenn die UUIDs mit ausreichender Entropie generiert werden. Andernfalls könnte die Wahrscheinlichkeit von Duplikaten erheblich höher sein, da die statistische Streuung geringer sein könnte. Wenn für verteilte Anwendungen eindeutige Kennungen erforderlich sind, damit UUIDs auch dann nicht zusammenstoßen, wenn Daten von vielen Geräten zusammengeführt werden, muss die Zufälligkeit der auf jedem Gerät verwendeten Seeds und Generatoren für die Lebensdauer der Anwendung zuverlässig sein. Wo dies nicht möglich ist, empfiehlt RFC4122 stattdessen die Verwendung einer Namespace-Variante.

Quelle: Der Abschnitt Zufällige UUID-Wahrscheinlichkeit von Duplikaten des Wikipedia-Artikels über universell eindeutige Bezeichner (Link führt zu einer Überarbeitung ab Dezember 2016, bevor der Abschnitt überarbeitet wurde).

Lesen Sie auch den aktuellen Abschnitt zum selben Thema im selben Artikel zur universell eindeutigen Kennung, Kollisionen .

Wenn Sie mit "genügend Zeit gegeben" 100 Jahre meinen und sie mit einer Rate von einer Milliarde pro Sekunde erstellen, dann haben Sie eine 50% ige Chance auf eine Kollision nach 100 Jahren.

Es gibt mehr als einen UUID-Typ. "Wie sicher" hängt also davon ab, welchen Typ (den die UUID-Spezifikationen als "Version" bezeichnen) Sie verwenden.

• Version 1 ist die zeitbasierte UUID plus MAC-Adresse. Das 128-Bit enthält 48 Bit für die MAC-Adresse der Netzwerkkarte (die vom Hersteller eindeutig zugewiesen wird) und einen 60-Bit-Takt mit einer Auflösung von 100 Nanosekunden. Diese Uhr wird in 3603 AD umschlossen, sodass diese UUIDs zumindest bis dahin sicher sind (es sei denn, Sie benötigen mehr als 10 Millionen neue UUIDs pro Sekunde oder jemand klont Ihre Netzwerkkarte). Ich sage "zumindest", weil die Uhr am 15. Oktober 1582 beginnt. Sie haben also ungefähr 400 Jahre nach dem Umwickeln der Uhr Zeit, bevor es überhaupt eine kleine Möglichkeit von Duplikaten gibt.

• Version 4 ist die Zufallszahlen-UUID. Es gibt sechs feste Bits und der Rest der UUID besteht aus 122 Bits Zufälligkeit. Siehe Wikipedia oder eine andere Analyse, die beschreibt, wie unwahrscheinlich ein Duplikat ist.

• Version 3 verwendet MD5 und Version 5 verwendet SHA-1, um diese 122-Bit anstelle eines Zufalls- oder Pseudozufallszahlengenerators zu erstellen. In Bezug auf die Sicherheit ist Version 4 ein statistisches Problem (solange Sie sicherstellen, dass der Digest-Algorithmus immer eindeutig ist).

• Version 2 ähnelt Version 1, hat jedoch eine kleinere Uhr, sodass sie sich viel früher dreht. Da UUIDs der Version 2 für DCE sind, sollten Sie diese nicht verwenden.

Für alle praktischen Probleme sind sie also sicher. Wenn es Ihnen unangenehm ist, es den Wahrscheinlichkeiten zu überlassen (z. B. wenn Sie sich Sorgen machen, dass die Erde in Ihrem Leben von einem großen Asteroiden zerstört wird), stellen Sie einfach sicher, dass Sie eine UUID der Version 1 verwenden, die garantiert eindeutig ist ( in Ihrem Leben, es sei denn, Sie planen, nach 3603 n. Chr. zu leben).

Warum verwendet nicht jeder einfach UUIDs der Version 1? Dies liegt daran, dass UUIDs der Version 1 die MAC-Adresse des Computers anzeigen, auf dem sie generiert wurden, und vorhersehbar sind - zwei Dinge, die Sicherheitsauswirkungen für die Anwendung haben können, die diese UUIDs verwendet.

Die Antwort darauf kann weitgehend von der UUID-Version abhängen.

Viele UUID-Generatoren verwenden eine Zufallszahl der Version 4. Viele von diesen verwenden jedoch Pseudo, einen Zufallszahlengenerator, um sie zu generieren.

Wenn ein schlecht gesätes PRNG mit einer kleinen Periode verwendet wird, um die UUID zu erzeugen, würde ich sagen, dass es überhaupt nicht sehr sicher ist.

Daher ist es nur so sicher wie die Algorithmen, mit denen es generiert wird.

Auf der anderen Seite, wenn Sie die Antwort auf diese Fragen kennen, sollte eine UUID der Version 4 meiner Meinung nach sehr sicher sein. Tatsächlich verwende ich es, um Blöcke in einem Netzwerkblock-Dateisystem zu identifizieren, und hatte bisher keinen Konflikt.

In meinem Fall ist das PRNG, das ich verwende, ein Mersenne-Twister, und ich bin vorsichtig mit der Art und Weise, wie es ausgesät wird, das aus mehreren Quellen stammt, einschließlich / dev / urandom. Mersenne Twister hat eine Periode von 2 ^ 19937 - 1. Es wird sehr, sehr lange dauern, bis ich eine Wiederholung sehe.

Zitat aus Wikipedia :

Auf diese Weise kann jeder eine UUID erstellen und sie verwenden, um etwas mit hinreichender Sicherheit zu identifizieren, dass die Kennung niemals unbeabsichtigt von irgendjemandem für etwas anderes verwendet wird

Es wird ziemlich ausführlich erklärt, wie sicher es tatsächlich ist. Um Ihre Frage zu beantworten: Ja, es ist sicher genug.

Ich stimme den anderen Antworten zu. UUIDs sind für nahezu alle praktischen Zwecke sicher genug ¹ , und sicherlich für Ihre.

Aber nehmen wir (hypothetisch) an, dass dies nicht der Fall ist.

Gibt es ein besseres System oder ein Muster, um dieses Problem zu lösen?

Hier sind einige Ansätze:

1. Verwenden Sie eine größere UUID. Verwenden Sie beispielsweise anstelle von 128 zufälligen Bits 256 oder 512 oder ... Jedes Bit, das Sie einer UUID vom Typ 4 hinzufügen, verringert die Wahrscheinlichkeit einer Kollision um die Hälfte, vorausgesetzt, Sie haben eine zuverlässige Entropiequelle ² .

2. Erstellen Sie einen zentralisierten oder verteilten Dienst, der UUIDs generiert und jeden einzelnen Dienst aufzeichnet, den er jemals ausgegeben hat. Jedes Mal, wenn eine neue generiert wird, wird überprüft, ob die UUID noch nie zuvor ausgestellt wurde. Die Implementierung eines solchen Dienstes wäre technisch unkompliziert (glaube ich), wenn wir davon ausgehen würden, dass die Personen, die den Dienst ausführen, absolut vertrauenswürdig, unbestechlich usw. sind. Leider sind sie nicht ... besonders wenn die Möglichkeit besteht, dass sich die Sicherheitsorganisationen der Regierungen einmischen. So ist dieser Ansatz wahrscheinlich nicht praktikabel, und seine ³ unmöglich in der realen Welt.

^{1 - Wenn die Einzigartigkeit der UUIDs bestimmen würde, ob in der Hauptstadt Ihres Landes Atomraketen abgefeuert wurden, wären viele Ihrer Mitbürger nicht davon überzeugt, dass "die Wahrscheinlichkeit extrem gering ist". Daher meine "fast alle" Qualifikation.}

^{2 - Und hier ist eine philosophische Frage für Sie. Ist irgendetwas jemals wirklich zufällig? Wie würden wir wissen, wenn es nicht wäre? Ist das Universum, wie wir es kennen, eine Simulation? Gibt es einen Gott, der möglicherweise die Gesetze der Physik "zwickt", um ein Ergebnis zu ändern?}

^{3 - Wenn jemand Forschungsarbeiten zu diesem Problem kennt, kommentieren Sie diese bitte.}

UUID-Schemata verwenden im Allgemeinen nicht nur ein pseudozufälliges Element, sondern auch die aktuelle Systemzeit und eine häufig eindeutige Hardware-ID, falls verfügbar, z. B. eine Netzwerk-MAC-Adresse.

Der springende Punkt bei der Verwendung von UUID ist, dass Sie darauf vertrauen, dass es eine eindeutige ID besser bereitstellt, als Sie es selbst könnten. Dies ist das gleiche Grundprinzip für die Verwendung einer Kryptografie-Bibliothek eines Drittanbieters, anstatt Ihre eigene zu rollen. Es macht vielleicht mehr Spaß, es selbst zu tun, aber es ist normalerweise weniger verantwortlich, dies zu tun.

Ich mache es schon seit Jahren. Niemals auf ein Problem stoßen.

Normalerweise richte ich meine DBs so ein, dass sie eine Tabelle haben, die alle Schlüssel und die geänderten Daten und dergleichen enthält. Ich bin noch nie auf ein Problem mit doppelten Schlüsseln gestoßen.

Der einzige Nachteil ist, dass Sie beim Schreiben einiger Abfragen, um schnell nach Informationen zu suchen, viel kopieren und einfügen müssen. Sie haben nicht mehr die kurzen, leicht zu merkenden Ausweise.

Hier ist ein Test-Snippet, mit dem Sie die Einzigartigkeit testen können. inspiriert von @ scalabl3s Kommentar

Das Lustige ist, dass Sie 2 in einer Reihe generieren können, die identisch sind, natürlich bei umwerfendem Zufall, Glück und göttlichem Eingreifen, aber trotz der unergründlichen Chancen ist es immer noch möglich! : D Ja, das wird nicht passieren. Ich sage nur zur Belustigung, über den Moment nachzudenken, als Sie ein Duplikat erstellt haben! Screenshot Video! - Scalabl3 20. Oktober 15 um 19:11 Uhr

Wenn Sie Glück haben, aktivieren Sie das Kontrollkästchen. Es werden nur die aktuell generierten IDs aktiviert. Wenn Sie eine Verlaufsprüfung wünschen, lassen Sie diese deaktiviert. Bitte beachten Sie, dass Ihnen möglicherweise irgendwann der RAM ausgeht, wenn Sie das Kontrollkästchen nicht aktivieren. Ich habe versucht, es CPU-freundlich zu machen, damit Sie bei Bedarf schnell abbrechen können. Drücken Sie einfach erneut auf die Schaltfläche "Snippet ausführen" oder verlassen Sie die Seite.

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 <baagoe@baagoe.com>, 2010
      function Mash() {
          var n = 0xefc8249d;

          var mash = function(data) {
              data = data.toString();
              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 <baagoe@baagoe.com>, 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.trim() == '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.<BR/>
<input type="text" value="0" id="input"><input type="checkbox" id="lucky"><button id="runit">Run</button><BR/>

Ich weiß nicht, ob dies für Sie wichtig ist, aber denken Sie daran, dass GUIDs global eindeutig sind, Teilzeichenfolgen von GUIDs jedoch nicht .

Für UUID4 stelle ich fest, dass es ungefähr so ​​viele IDs gibt wie Sandkörner in einer würfelförmigen Box mit Seiten mit einer Länge von 360.000 km. Das ist eine Schachtel mit Seiten, die ~ 2 1/2 mal länger sind als Jupiters Durchmesser.

Arbeiten, damit mir jemand sagen kann, ob ich Einheiten durcheinander gebracht habe:

• Volumen des Sandkorns 0,00947 mm ^ 3 ( Guardian )
• UUID4 hat 122 zufällige Bits -> 5.3e36 mögliche Werte ( Wikipedia )
• Volumen dieser vielen Sandkörner = 5,0191e34 mm ^ 3 oder 5,0191e + 25 m ^ 3
• Seitenlänge der kubischen Box mit diesem Volumen = 3,69E8m oder 369.000km
• Durchmesser des Jupiter: 139.820 km (google)