Générateur UUID

Qu'est-ce qu'un UUID ?

Un UUID (Identifiant Universel Unique, de l'anglais Universally Unique Identifier) est un nombre de 128 bits destiné à identifier une information de façon unique, sans dépendre d'une autorité centrale. Le format est normalisé par la RFC 4122, publiée en 2005, puis étendue par la RFC 9562 en 2024, qui a formalisé de nouvelles versions (6, 7 et 8) en complément des versions historiques.

Sous sa forme textuelle, un UUID s'écrit avec 32 chiffres hexadécimaux répartis en cinq groupes séparés par des tirets, selon le schéma 8-4-4-4-12, soit 36 caractères au total avec les tirets. Par exemple : 550e8400-e29b-41d4-a716-446655440000. La position du treizième chiffre indique la version de l'UUID, et le premier chiffre du quatrième groupe indique la variante utilisée.

L'espace total d'un UUID est de 2^128, soit environ 3,4 × 10^38 valeurs possibles. Pour la version 4, six de ces bits sont fixés (4 bits de version, valant 0100, et 2 bits de variante, valant 10), ce qui laisse 122 bits réellement aléatoires, soit environ 5,3 × 10^36 combinaisons. À titre d'illustration, en générant un milliard d'UUID v4 par seconde pendant cent ans, on obtiendrait environ 3,1 × 10^18 identifiants au total, un volume qui reste extrêmement loin du seuil où une collision deviendrait probable. Une collision accidentelle entre deux UUID v4 générés indépendamment reste donc extrêmement improbable en pratique, même si elle n'est jamais mathématiquement exclue à 0 %.

Le terme GUID (Globally Unique Identifier) désigne l'implémentation de ce même standard par Microsoft. On le retrouve dans le registre Windows, les technologies COM/DCOM, la structure Guid du framework .NET, ou encore le type uniqueidentifier de SQL Server. Un GUID est fonctionnellement identique à un UUID : même structure de 128 bits, même représentation textuelle. Seule la convention d'affichage entre accolades, {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}, est propre à l'écosystème Microsoft, ce qui explique pourquoi cet outil propose un format « Accolades » dédié.

L'intérêt principal d'un UUID par rapport à un identifiant séquentiel classique est qu'il peut être généré indépendamment, sur n'importe quelle machine, sans coordination avec un serveur central ni verrou de base de données. Deux applications qui génèrent chacune un identifiant de leur côté, même hors ligne ou dans des centres de données distincts, peuvent ensuite fusionner leurs données sans craindre la moindre collision. C'est ce qui rend les UUID particulièrement adaptés aux architectures distribuées, à la synchronisation hors ligne et aux systèmes répliqués.

Cet outil génère les UUID directement dans votre navigateur, à l'aide de l'API crypto.getRandomValues. Il s'agit d'un générateur de nombres pseudo-aléatoires cryptographiquement sécurisé, alimenté par l'entropie du système d'exploitation, contrairement à Math.random(), qui n'offre aucune garantie cryptographique et peut, dans certains cas, se révéler prévisible. La génération étant entièrement locale, aucune donnée n'est transmise à un serveur, et l'outil continue de fonctionner hors ligne une fois la page chargée.

Selon le langage ou le système que vous utilisez, la casse et la ponctuation attendues pour un UUID peuvent varier. Cet outil propose donc plusieurs représentations du même identifiant : la forme standard en minuscules avec tirets, une variante en MAJUSCULES, une version Sans Tirets, la forme entre accolades utilisée par .NET, ainsi que le format URN urn:uuid:..., employé notamment dans certains schémas XML et protocoles réseau.

Il convient de garder à l'esprit qu'un UUID, même en version 4, n'est pas conçu comme un secret cryptographique à proprement parler : son imprévisibilité dépend entièrement de la qualité de la source aléatoire utilisée pour le générer. Un UUID v1, par exemple, est en grande partie prévisible puisqu'il encode un horodatage et une adresse MAC, ce qui le rend impropre à un usage comme jeton de sécurité. À l'inverse, un UUID v4 généré via un CSPRNG comme celui utilisé ici offre une imprévisibilité suffisante pour de nombreux usages sensibles, sans pour autant remplacer un mécanisme d'authentification dédié.

Versions d'UUID

Cet outil génère exclusivement des UUID de version 4 (aléatoires), à l'aide de nombres aléatoires cryptographiquement sécurisés. Le tableau ci-dessus recense les versions les plus courantes du standard à titre informatif. La v1 encode un horodatage et l'adresse MAC de la machine, ce qui la rend triable dans le temps mais susceptible de révéler des informations sur son origine. Les versions v3 et v5 sont déterministes : elles produisent toujours le même UUID pour un même couple espace de noms plus nom, respectivement via un hachage MD5 et SHA-1. La v7, normalisée par la RFC 9562 en 2024, combine un horodatage Unix en millisecondes et des bits aléatoires ; sa nature quasi ordonnée en fait un choix de plus en plus populaire comme clé primaire de base de données, car des identifiants séquentiels par tranches sont plus favorables aux performances des index B-tree que des valeurs purement aléatoires comme la v4, à grande échelle. Ce comparatif reste indicatif : cet outil ne produit que des UUID v4.

Cas d'Utilisation Courants

🗄️ Clés Primaires de Base de Données

Utiliser un UUID plutôt qu'un entier auto-incrémenté comme clé primaire évite d'exposer le nombre de lignes ou le volume d'activité d'une table (un identifiant client comme 4832 révèle immédiatement l'ampleur de la base, ce qu'un UUID ne fait jamais). L'identifiant peut aussi être généré côté client avant même l'insertion en base, ce qui simplifie l'écriture et évite un aller-retour supplémentaire pour récupérer l'ID attribué par le serveur. C'est également un atout pour fusionner des données entre plusieurs fragments (sharding), répliques ou environnements de synchronisation hors ligne, puisque deux enregistrements créés indépendamment n'entreront jamais en collision. Des moteurs comme PostgreSQL proposent d'ailleurs une fonction native, gen_random_uuid(), capable de produire directement une valeur v4 au moment de l'insertion, sans passer par l'application.

🔌 Identifiants d'API

Dans une API REST, exposer une ressource via une URL contenant un UUID plutôt qu'un simple numéro incrémental empêche les attaques par énumération, où un attaquant devine simplement l'identifiant suivant pour accéder aux ressources d'un autre utilisateur. Les UUID servent aussi couramment de jetons de session ou de clés d'idempotence, à la manière des API de Stripe, qui garantissent qu'une même requête envoyée deux fois, par exemple après une coupure réseau, ne sera traitée qu'une seule fois.

📁 Noms de Fichiers

Nommer chaque fichier téléversé, fichier temporaire ou entrée de cache avec un UUID garantit l'unicité du nom sans avoir à interroger le système de fichiers ou la base de données pour vérifier qu'un nom n'est pas déjà pris. Cela reste fiable même en cas d'écritures concurrentes, par exemple lorsque plusieurs utilisateurs téléversent des fichiers portant exactement le même nom d'origine au même moment.

🔗 Systèmes Distribués

Chaque serveur ou microservice d'une architecture distribuée peut générer ses propres identifiants indépendamment, sans compteur central ni verrou partagé, ce qui élimine un point de contention unique. C'est notamment ce que l'on utilise pour les identifiants de corrélation en event-sourcing, qui permettent de retracer un événement à travers plusieurs services, ou pour les identifiants de messages dans une file d'attente, où chaque message doit rester traçable indépendamment de son origine.

Foire aux Questions

Outils Associés

🔒 100 % Privé

Tous les UUID sont générés localement dans votre navigateur à l'aide d'une randomisation cryptographiquement sécurisée.