Analyseur et Décodeur d'UUID

Analysez les UUID RFC 9562 localement dans votre navigateur.

Aucun téléversementSans inscriptionRésultats instantanés
Décodeur v1–v8 · Nil · MaxExtrait les horodatages v1, v6 et v7100% Local • Zéro Envoi
Inspecter les UUID
Moteur hors ligne prêtEspace 100% privé dans le navigateur • Aucun transfert cloud
100 % Privé • Aucun fichier envoyé sur un serveur

Pourquoi utiliser Analyseur et Décodeur d'UUID gratuitement sur Utiliome ?

Conçu pour garantir une confidentialité stricte, sans inscription ni abonnement requis.

Extraction d'Horodatage v1, v6 et v7

Convertit les champs de millisecondes d'époque Unix sur 48 bits des UUIDv7 et les compteurs grégoriens de 100 nanosecondes sur 60 bits des UUIDv1 et UUIDv6 en dates UTC ISO-8601 exactes et en entiers d'époque bruts.

Décomposition Complète des Bits RFC 9562

Inspecte les 128 bits sur les octets 0 à 15, isolant le quartet de version sur 4 bits (v1 à v8), les constantes spéciales Nil et Max, le préfixe de variante, la séquence d'horloge sur 14 bits et l'identifiant de nœud sur 48 bits.

Représentation Hexadécimale et Binaire 128 Bits

Affiche le format hexadécimal canonique 8-4-4-4-12 aux côtés des groupements de 16 octets et des segments binaires indexés bit par bit pour vérifier l'ordre big-endian, les drapeaux multicast IEEE 802 et les bits d'entropie.

Décodage Côté Client Sans Envoi Réseau

Exécute tous les masquages binaires et l'arithmétique d'époque BigInt 64 bits directement dans la mémoire du navigateur sans aucune requête réseau, garantissant la confidentialité de vos clés primaires de production, identifiants d'audit et jetons de session.

Utiliome vs alternatives cloud traditionnelles

Comparez notre moteur local WebAssembly aux outils cloud anciens.

Fonctionnalité Utiliome (Navigateur local) Convertisseurs cloud anciens
Extraction d'Horodatage v1, v6 et v7 Convertit les champs de millisecondes d'époque Unix sur 48 bits des UUIDv7 et les compteurs grégoriens de 100 nanosecondes sur 60 bits des UUIDv1 et UUIDv6 en dates UTC ISO-8601 exactes et en entiers d'époque bruts. Options limitées sans personnalisation avancée
Décomposition Complète des Bits RFC 9562 Inspecte les 128 bits sur les octets 0 à 15, isolant le quartet de version sur 4 bits (v1 à v8), les constantes spéciales Nil et Max, le préfixe de variante, la séquence d'horloge sur 14 bits et l'identifiant de nœud sur 48 bits. Nécessite des outils externes ou un traitement manuel
Confidentialité et Traitement 100 % local dans le navigateur (zéro envoi serveur) Envoie les données vers des serveurs cloud tiers
Tarif et Inscription 100 % gratuit à vie, sans compte ni filigrane Inscription obligatoire ou abonnement payant
Comment ça marche

Comment utiliser Analyseur et Décodeur d'UUID en 3 étapes simples

Aucune installation requise. Tout s'exécute directement dans votre navigateur web.

1

Saisissez ou Importez un UUID

Collez un UUID canonique de 36 caractères, une chaîne hexadécimale de 32 caractères sans tirets, un GUID entre accolades ou un identifiant préfixé par URN dans le champ de saisie, ou déposez un fichier texte local.

2

Inspectez les Champs RFC 9562 Décodés

Examinez la version extraite (v1 à v8, Nil ou Max), le préfixe binaire de la variante RFC, les octets bruts en hexadécimal et en binaire sur 128 bits, ainsi que les sous-champs propres à chaque version.

3

Copiez l'Horodatage ou la Sortie Structurée

Pour les clés temporelles v1, v6 et v7, copiez l'horodatage de création UTC ISO-8601 décodé, la valeur d'époque Unix en millisecondes, la séquence d'horloge ou le rapport détaillé au format JSON.

Décodage des UUID Temporels : Exemple Concret d'Entrée et de Sortie

Réponse rapide: L'analyse d'un UUID supprime les délimiteurs de formatage, place l'identifiant de 128 bits dans 16 octets big-endian, lit les bits 48 à 51 pour la version et les bits 64 à 65 pour la variante, puis applique des masques binaires spécifiques à la version afin de décoder les millisecondes de l'époque Unix (v7) ou les intervalles grégoriens de 100 nanosecondes, les séquences d'horloge et les identifiants de nœud (v1 et v6).

Les UUID basés sur le temps stockent leur horodatage de création selon deux systèmes d'époque distincts définis par la norme RFC 9562 : les millisecondes de l'époque Unix pour l'UUIDv7 et les intervalles grégoriens de 100 nanosecondes écoulés depuis 1582-10-15T00:00:00Z pour les UUIDv1 et UUIDv6.

Exemple 1 : Décodage d'une Clé Primaire UUIDv7

Considérons une clé primaire de base de données générée avec UUIDv7 :

01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f

L'analyseur lit les 48 premiers bits (01941f297c7b) comme un entier non signé big-endian en millisecondes (1735689600123), vérifie le 13e quartet (7, binaire 0111) ainsi que les deux bits de poids fort du 17e quartet (9, binaire 1001 -> variante 10), et sépare rand_a (12 bits) de rand_b (62 bits) :

{
  "canonical": "01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f",
  "version": 7,
  "versionLabel": "UUIDv7 (Unix Epoch Time-Ordered)",
  "variant": "RFC 9562 (10xx)",
  "timestamp": {
    "epochSystem": "Unix Epoch (1970-01-01T00:00:00Z)",
    "unixMilliseconds": 1735689600123,
    "iso8601Utc": "2025-01-01T00:00:00.123Z"
  },
  "fields": {
    "unix_ts_ms": "0x01941f297c7b",
    "ver": "0b0111 (7)",
    "rand_a": "0xa3c (12 bits)",
    "var": "0b10",
    "rand_b": "0x1f4e2b8d5c1a0e6f (62 bits)"
  }
}

Exemple 2 : Décodage d'un UUIDv1 face à un UUIDv6 Réordonné

Les deux identifiants ci-dessous encodent exactement le même horodatage grégorien (0x1efc7d357fd0000 = 139549824000000000 tics de 100 ns), la même séquence d'horloge et le même identifiant de nœud, ne différant que par l'agencement des 60 bits d'horodatage sur les octets 0 à 7 :

UUIDv1: 57fd0000-c7d3-11ef-aa1b-3d8f4a91c20e
UUIDv6: 1efc7d35-7fd0-6000-aa1b-3d8f4a91c20e

Le réassemblage de time_hi (1ef), time_mid (c7d3) et time_low (57fd0000) à partir de l'UUIDv1 — ou la concaténation de time_high (1efc7d35), time_mid (7fd0) et time_low (000) à partir de l'UUIDv6 — suivi de la soustraction du décalage entre l'époque grégorienne et l'époque Unix (122192928000000000 tics) produit le rapport de champs décodés suivant :

{
  "canonical": "57fd0000-c7d3-11ef-aa1b-3d8f4a91c20e",
  "version": 1,
  "variant": "RFC 9562 (10xx)",
  "timestamp": {
    "gregorianTicks100ns": "139549824000000000",
    "unixMilliseconds": 1735689600000,
    "subMillisecondNanoseconds": 0,
    "iso8601Utc": "2025-01-01T00:00:00.000Z"
  },
  "clockSequence": {
    "hex": "0x2a1b",
    "decimal": 10779
  },
  "node": {
    "formatted": "3d:8f:4a:91:c2:0e",
    "multicastBit": 1,
    "nodeType": "Pseudorandom multicast node (RFC 9562 Section 6.10)"
  }
}

Structure Binaire RFC 9562, Arithmétique d'Époque et Propriétés de Sécurité

Réponse rapide: La norme RFC 9562 définit une disposition big-endian sur 128 bits où les bits 48 à 51 encodent les versions 1 à 8 et les bits 64 à 67 déterminent la variante. Seules les versions 1, 6 et 7 transportent des horodatages standardisés ; les versions 3, 4 et 5 contiennent des condensats déterministes ou de l'entropie CSPRNG, tandis que la version 8 réserve 122 bits pour des schémas propriétaires personnalisés.

Selon la norme RFC 9562 (qui a remplacé la RFC 4122 en mai 2024), un UUID est une valeur non signée de 128 bits transmise dans l'ordre des octets du réseau (bit de poids fort numéroté 0, bit de poids faible numéroté 127).

Disposition des Champs Binaires selon les Versions Temporelles

Bit Index:  0                   31 32       47 48  51 52        63
UUIDv1:    [      time_low (32)   | time_mid  | 0001 | time_hi(12)]
UUIDv6:    [     time_high (32)   | time_mid  | 0110 |time_low(12)]
UUIDv7:    [          unix_ts_ms (48 bits)    | 0111 | rand_a (12)]

Bit Index:  64 65 66            79 80                           127
UUIDv1/v6: [ 10  |  clock_seq(14) |          node (48 bits)       ]
UUIDv7:    [ 10  |               rand_b (62 bits)                 ]

Préfixes de Variante et Constantes Limites

L'octet 8 (bits 64 à 71, commençant au 17e chiffre hexadécimal) détermine comment le reste de la structure binaire est interprété :

  • 0xxx (hex 0-7) : Réservé pour la rétrocompatibilité avec l'ancien système Apollo NCS.
  • 10xx (hex 8, 9, a, b) : Variante standard RFC 9562 utilisée par les UUIDv1 à UUIDv8.
  • 110x (hex c, d) : Réservé pour la rétrocompatibilité avec les anciens GUID Microsoft COM/DCOM.
  • 111x (hex e, f) : Réservé pour une définition future, sauf lorsque les 128 bits sont tous à 1, ce qui forme l'UUID Max (ffffffff-ffff-ffff-ffff-ffffffffffff, RFC 9562 Section 5.10). De même, 128 bits à zéro forment l'UUID Nil (00000000-0000-0000-0000-000000000000, Section 5.9).

Pièges de Précision 64 Bits dans les Calculs d'Époque Grégorienne

Un compteur grégorien sur 60 bits contient des valeurs proches de 1.39 * 10^17 tics, dépassant Number.MAX_SAFE_INTEGER en virgule flottante double précision IEEE-754 (9 007 199 254 740 991 ou 2^53 - 1) de plus d'un ordre de grandeur. La conversion des horodatages UUIDv1 ou UUIDv6 à l'aide de nombres à virgule flottante 64 bits standard arrondit silencieusement les 4 à 5 bits de poids faible (altérant les tics sous-millisecondes jusqu'à 3,2 microsecondes). Un décodage exact nécessite une arithmétique BigInt à précision arbitraire utilisant le décalage exact de 141 427 jours (122 192 928 000 000 000 tics de 100 nanosecondes, 0x01b21dd213814000) entre 1582-10-15T00:00:00Z et 1970-01-01T00:00:00Z. En revanche, le champ unix_ts_ms sur 48 bits de l'UUIDv7 culmine à 281 474 976 710 655 ms (10889-08-02T05:31:50.655Z), ce qui tient parfaitement dans un entier sûr de 53 bits.

Confidentialité et Fuite de Métadonnées

L'inspection d'UUID externes révèle des métadonnées opérationnelles lorsque des versions temporelles sont exposées dans des API publiques :

  • Adresse MAC Matérielle vs Nœud Pseudo-aléatoire : Dans un UUIDv1, si le bit de poids faible de l'octet 10 (le bit unicast/multicast IEEE 802) vaut 0, le champ node de 48 bits expose fréquemment l'adresse MAC physique de la carte réseau du serveur générateur ainsi que le préfixe constructeur IEEE OUI. La section 6.10 de la RFC 9562 recommande de définir ce bit multicast à 1 avec des octets de nœud aléatoires (approche privilégiée dans l'UUIDv6 lorsqu'aucune adresse MAC n'est souhaitée).
  • Déduction du Rythme de Création : Les identifiants v1, v6 et v7 exposés publiquement divulguent l'horodatage exact de création des enregistrements, permettant à des observateurs de mesurer la vitesse d'inscription ou le volume de commandes entre deux identifiants. Pour des jetons publics opaques, utilisez plutôt un UUIDv4 aléatoire (122 bits CSPRNG).

Analyseur d'UUID vs Validateur d'UUID vs Générateur Temporel : Lequel Choisir ?

Réponse rapide: Utilisez l'Analyseur et Décodeur d'UUID lorsque vous devez inspecter les champs internes de 128 bits d'un identifiant unique, son ID de nœud ou son horodatage UTC intégré (v1, v6 et v7). Utilisez le Validateur d'UUID pour vérifier la syntaxe et filtrer des milliers d'identifiants en masse, ou le Générateur d'UUID v7, v6 et v1 pour créer de nouvelles clés triées par le temps.

Chaque outil de la suite UUID d'Utiliome répond à une étape précise du traitement des identifiants RFC 9562 :

Fonctionnalité Analyseur et Décodeur d'UUID (Cet Outil) Validateur UUID Générateur d'UUID v7, v6 et v1
Objectif Principal Inspecter les champs binaires internes et décoder les horodatages intégrés d'un UUID existant Vérifier la conformité syntaxique RFC 9562, la version et la variante sur un identifiant ou des listes en masse Générer de nouveaux UUID RFC 9562 ordonnés dans le temps pour des clés primaires de base de données
Gestion des Horodatages Extrait les dates UTC ISO-8601, les ms Unix et les tics grégoriens de 100 ns des versions v1, v6 et v7 Ne décode pas les horodatages ; vérifie les quartets de version et les préfixes binaires de variante Encode l'horodatage actuel ou personnalisé dans de nouveaux identifiants v7, v6 ou v1
Inspection Binaire Disposition binaire complète sur 128 bits, séquence d'horloge, rand_a/rand_b et drapeaux de nœud IEEE 802 Étiquette de version par ligne (v1-v8, Nil, Max) et diagnostic des erreurs de syntaxe Formate les nouvelles clés en hexadécimal canonique avec tirets, hexadécimal brut ou JSON
Filtrage de Masse et Export Inspection approfondie ciblée sur une clé unique Filtre des fichiers multilignes ou des journaux collés et exporte des ensembles d'UUID valides nettoyés Génère en lot des séquences monotones de clés ordonnées chronologiquement

Choisir le Bon Flux de Travail

  • Déboguer un journal d'événements ou une clé primaire : Collez l'identifiant ici pour extraire son horodatage exact de création UTC, vérifier si son identifiant de nœud est une adresse MAC matérielle ou une adresse aléatoire multicast, et inspecter sa structure brute de 128 bits.
  • Auditer ou nettoyer un jeu de données : Envoyez vos colonnes CSV, extraits de logs ou charges utiles d'API vers le Validateur UUID pour éliminer les chaînes mal formées, détecter les anciens GUID Microsoft 110x et exporter des identifiants canoniques en minuscules.
  • Créer de nouveaux identifiants : Utilisez le Générateur d'UUID v7, v6 et v1 lorsque vous avez besoin de clés triées chronologiquement optimisées pour les index B-tree, ou le Générateur d'UUID v4 pour obtenir des identifiants CSPRNG de 122 bits non temporels sans aucune fuite d'horodatage.
FAQ

FAQ et guide technique sur Analyseur et Décodeur d'UUID

Tout ce qu'il faut savoir sur l'utilisation en ligne gratuite de décodeur uuid.

Peut-on extraire un horodatage de création à partir d'un UUID v4 ou UUID v5 ?

Non. Un UUIDv4 contient 6 bits fixes de version et de variante ainsi que 122 bits générés de manière aléatoire cryptographiquement sûre (CSPRNG), tandis que les UUIDv3 et UUIDv5 contiennent des condensats MD5 ou SHA-1 tronqués issus d'un UUID d'espace de noms et d'un nom. Aucun d'entre eux ne stocke d'heure, de séquence d'horloge ou de métadonnées d'hôte — seuls les UUIDv1, UUIDv6 et UUIDv7 (ainsi que l'ancien UUIDv2 DCE Security avec substitutions grossières d'UID/GID POSIX) transportent des horodatages de création standardisés.

Pourquoi les UUID v1 et UUID v6 décodent-ils exactement le même horodatage à partir de préfixes hexadécimaux différents ?

Les deux versions encodent un compteur sur 60 bits d'intervalles de 100 nanosecondes écoulés depuis 1582-10-15T00:00:00Z. L'UUIDv1 place les bits time_low qui changent le plus rapidement dans les 32 premiers bits (bits 0-31), ce qui disperse les insertions séquentielles à travers les pages d'index B-tree. L'UUIDv6 réorganise exactement ces mêmes 60 bits du plus significatif au moins significatif (time_high, time_mid, time_low) afin que l'ordre lexicographique des chaînes corresponde à l'ordre chronologique de création.

Comment savoir si l'identifiant de nœud d'un UUID v1 est une adresse MAC physique ou généré aléatoirement ?

Vérifiez le bit de poids faible de l'octet 10 (le premier octet du champ node de 48 bits), qui correspond au drapeau unicast/multicast IEEE 802. Les adresses MAC des cartes réseau physiques ont toujours ce bit à 0 (unicast), tandis que la section 6.10 de la norme RFC 9562 spécifie de mettre ce bit à 1 (multicast) chaque fois qu'une valeur de nœud pseudo-aléatoire de 48 bits est utilisée à la place d'une adresse matérielle.

Quelle précision d'horodatage inférieure à la milliseconde peut-on décoder d'un UUID v7 ?

L'UUIDv7 garantit une précision d'horodatage de 1 milliseconde via son champ unix_ts_ms de 48 bits (bits 0-47). Bien que la section 6.2 de la RFC 9562 autorise les générateurs à placer une fraction sous-milliseconde optionnelle ou un compteur monotone dans rand_a (bits 52-63), le format binaire n'inclut aucun indicateur précisant si rand_a contient de l'entropie aléatoire, un compteur ou des fractions de nanosecondes ; un analyseur général ne peut donc décoder de manière déterministe que unix_ts_ms.

Comment l'analyseur gère-t-il les identifiants Nil, Max et UUID v8 ?

Les entrées composées uniquement de zéros (00000000-0000-0000-0000-000000000000) et uniquement de uns (ffffffff-ffff-ffff-ffff-ffffffffffff) sont identifiées comme les UUID spéciaux Nil et Max de la RFC 9562 plutôt que comme des valeurs invalides de version 0 ou de version 15. Pour l'UUIDv8 (ver = 1000), l'analyseur extrait custom_a (48 bits), custom_b (12 bits) et custom_c (62 bits) sous forme de champs hexadécimaux et binaires bruts sans tenter de deviner un horodatage, car la structure binaire de la v8 est propre à chaque implémentation.