UUID-tolkare & Avkodare

Tolka och analysera RFC 9562-UUID:er lokalt i webbläsaren.

Inga uppladdningarIngen registreringOmedelbara resultat
v1–v8 · Nil · Max-avkodareExtraherar v1-, v6- & v7-tidsstämplar100% Lokalt • Noll Uppladdningar
Inspektera UUID
Offlinemotorn är redo100 % privat arbetsyta i webbläsaren • Inga molnuppladdningar
100 % Privat • Ingen filuppladdning till server

Varför använda Utiliomes gratis UUID-tolkare & Avkodare?

Byggd från grunden för strikt integritet, snabb körning och utan krångel. Inga prenumerationer eller konton krävs.

Extrahering av tidsstämplar ur v1, v6 och v7

Konverterar 48-bitars Unix Epoch-millisekundfält i UUIDv7 och 60-bitars 100-nanosekunders gregorianska räknare i UUIDv1 och UUIDv6 till exakta ISO-8601 UTC-tidsstämplar och råa epokheltal.

Fullständig RFC 9562-bitfältsuppdelning

Inspekterar alla 128 bitar över oktetterna 0 till 15 och isolerar 4-bitars versionsnibblen (v1 till v8), speciella Nil- och Max-konstanter, variantbitsprefix, 14-bitars klocksekvens och 48-bitars nod-ID.

Hexadecimal och 128-bitars binär layout

Renderar kanonisk 8-4-4-4-12-hex sida vid sida med 16-bytes oktettgrupperingar och bitindexerade binära segment så att du kan verifiera big-endian-ordning, IEEE 802 multicast-flaggor och entropibitar.

Avkodning på klientsidan utan uppladdning

Exekverar all bitmaskning och 64-bitars BigInt-epokaritmetik direkt i webbläsarens minne utan nätverksanrop, vilket håller primärnycklar från produktion, revisions-ID:n och sessionstokens privata.

Utiliome jämfört med molnalternativ

Jämför vår lokala WebAssembly-motor med äldre molnverktyg.

Funktion Utiliome (Lokal webbläsare) Traditionella molnomvandlare
Extrahering av tidsstämplar ur v1, v6 och v7 Konverterar 48-bitars Unix Epoch-millisekundfält i UUIDv7 och 60-bitars 100-nanosekunders gregorianska räknare i UUIDv1 och UUIDv6 till exakta ISO-8601 UTC-tidsstämplar och råa epokheltal. Begränsade alternativ utan avancerad anpassning
Fullständig RFC 9562-bitfältsuppdelning Inspekterar alla 128 bitar över oktetterna 0 till 15 och isolerar 4-bitars versionsnibblen (v1 till v8), speciella Nil- och Max-konstanter, variantbitsprefix, 14-bitars klocksekvens och 48-bitars nod-ID. Kräver externa verktyg eller manuell hantering
Integritet och databehandling 100 % lokalt i webbläsaren (ingen serveruppladdning) Laddar upp data till externa molnservrar
Pris och kontokrav 100 % gratis för alltid utan registrering Kräver kontoregistrering eller betald prenumeration
Så fungerar det

Hur du använder UUID-tolkare & Avkodare i 3 enkla steg

Ingen programinstallation krävs. Allt körs direkt i din webbläsare.

1

Ange eller ladda upp ett UUID

Klistra in ett kanoniskt UUID på 36 tecken, en hexsträng på 32 tecken utan bindestreck, ett GUID inom klammerparenteser eller en URN-prefixad identifierare i inmatningsfältet, eller släpp en lokal textfil.

2

Inspektera avkodade RFC 9562-fält

Granska den extraherade versionen (v1 till v8, Nil eller Max), RFC-variantens bitprefix, råa 128-bitars hexadecimala och binära oktetter samt versionsspecifika delfält.

3

Kopiera tidsstämplar eller strukturerad utdata

För tidsordnade v1-, v6- och v7-nycklar kan du kopiera den avkodade ISO-8601 UTC-skapelsetidsstämpeln, Unix-epokvärdet i millisekunder, klocksekvensen eller en strukturerad JSON-uppdelning.

Avkoda tidsbaserade UUID:er: Konkret genomgång av indata och utdata

Snabbsvar: När ett UUID tolkas rensas formateringsavgränsare bort, 128-bitarsidentifieraren mappas till 16 big-endian-oktetter, bitarna 48-51 läses för versionen och bitarna 64-65 för varianten, varpå versionsspecifika bitmasker appliceras för att avkoda Unix Epoch-millisekunder (v7) eller gregorianska 100-nanosekundersticks, klocksekvenser och nod-ID:n (v1 och v6).

Tidsbaserade UUID:er lagrar skapelsetidsstämplar i två separata epoksystem som definieras i RFC 9562: Unix Epoch-millisekunder för UUIDv7 och 100-nanosekunders gregorianska intervall sedan 1582-10-15T00:00:00Z för UUIDv1 och UUIDv6.

Exempel 1: Avkodning av en UUIDv7-primärnyckel

Betrakta en databasprimärnyckel genererad med UUIDv7:

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

Tolkaren läser de första 48 bitarna (01941f297c7b) som ett teckenlöst big-endian-heltal i millisekunder (1735689600123), verifierar nibble 13 (7, binärt 0111) och de två översta bitarna i nibble 17 (9, binärt 1001 -> variant 10), samt separerar rand_a (12 bitar) från rand_b (62 bitar):

{
  "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)"
  }
}

Exempel 2: Avkodning av UUIDv1 kontra omordnad UUIDv6

Båda identifierarna nedan kodar exakt samma gregorianska tidsstämpel (0x1efc7d357fd0000 = 139549824000000000 ticks om 100 ns), klocksekvens och nod-ID, och skiljer sig endast i hur de 60 tidsstämpelbitarna är placerade över oktetterna 0 till 7:

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

Genom att återmontera time_hi (1ef), time_mid (c7d3) och time_low (57fd0000) från UUIDv1 – eller konkatenera time_high (1efc7d35), time_mid (7fd0) och time_low (000) från UUIDv6 – och subtrahera offseten mellan den gregorianska kalendern och Unix-epoken (122192928000000000 ticks) får vi följande avkodade fältrapport:

{
  "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)"
  }
}

RFC 9562-bitlayouter, epokaritmetik och säkerhetsegenskaper

Snabbsvar: RFC 9562 definierar en 128-bitars big-endian-layout där bitarna 48-51 kodar versionerna 1 till 8 och bitarna 64-67 bestämmer varianten. Endast versionerna 1, 6 och 7 bär standardiserade tidsstämplar; versionerna 3, 4 och 5 innehåller deterministiska kontrollsummor eller CSPRNG-entropi, medan version 8 reserverar 122 bitar för opaka leverantörsdefinierade scheman.

Enligt RFC 9562 (som ersatte RFC 4122 i maj 2024) är ett UUID ett teckenlöst 128-bitarsvärde som överförs i nätverksbyteordning (mest signifikanta bit numrerad 0, minst signifikanta bit numrerad 127).

Fältlayouter på bitnivå över tidsbaserade versioner

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)                 ]

Variantprefix och gränskonstanter

Oktett 8 (bitarna 64-71, med början vid den 17:e hexsiffran) avgör hur den återstående bitlayouten tolkas:

  • 0xxx (hex 0-7): Reserverad för bakåtkompatibilitet med äldre Apollo NCS.
  • 10xx (hex 8, 9, a, b): Standardvariant enligt RFC 9562 som används av UUIDv1 till UUIDv8.
  • 110x (hex c, d): Reserverad för bakåtkompatibilitet med äldre Microsoft COM/DCOM GUID.
  • 111x (hex e, f): Reserverad för framtida definition, förutom när alla 128 bitar är 1, vilket utgör Max UUID (ffffffff-ffff-ffff-ffff-ffffffffffff, RFC 9562 avsnitt 5.10). På motsvarande sätt utgör 128 nollbitar Nil UUID (00000000-0000-0000-0000-000000000000, avsnitt 5.9).

Fallgropar med 64-bitars precision i gregoriansk epokaritmetik

En 60-bitars gregoriansk räknare rymmer värden kring 1.39 * 10^17 ticks, vilket överstiger IEEE-754 dubbelprecisionsgränsen Number.MAX_SAFE_INTEGER (9,007,199,254,740,991 eller 2^53 - 1) med mer än en tiopotens. Om man konverterar UUIDv1- eller UUIDv6-tidsstämplar med vanliga 64-bitars flyttal avrundas de lägsta 4 till 5 bitarna i det tysta (vilket förvränger submillisekund-ticks med upp till 3,2 mikrosekunder). Korrekt avkodning kräver BigInt-aritmetik med godtycklig precision och det exakta offsetvärdet på 141,427 dagar (122,192,928,000,000,000 ticks om 100 nanosekunder, 0x01b21dd213814000) mellan 1582-10-15T00:00:00Z och 1970-01-01T00:00:00Z. Som jämförelse har UUIDv7:s 48-bitars unix_ts_ms ett maxvärde på 281,474,976,710,655 ms (10889-08-02T05:31:50.655Z), vilket med god marginal ryms inom 53-bitars heltal.

Integritet och läckage av metadata

Inspektion av externa UUID:er exponerar operativ metadata när tidsbaserade versioner används i publika API-slutpunkter:

  • Hårdvaru-MAC kontra pseudoslumpmässig nod: I UUIDv1, om den minst signifikanta biten i oktett 10 (IEEE 802 unicast/multicast-biten) är 0, exponerar det 48-bitars node-fältet ofta den genererande värdens fysiska MAC-adress och IEEE OUI-leverantörsprefix. RFC 9562 avsnitt 6.10 rekommenderar att sätta denna multicast-bit till 1 med slumpmässiga nod-bytes (obligatoriskt i UUIDv6 när ingen MAC-adress önskas).
  • Slutsatser om skapandefrekvens: Publikt exponerade v1-, v6- och v7-identifierare avslöjar exakta tidsstämplar för när poster skapats, vilket gör att utomstående kan mäta registreringstakt eller ordervolym mellan två ID:n. För opaka publika tokens bör du använda slumpmässiga UUIDv4 (122 CSPRNG-bitar) i stället.

UUID-tolkare vs UUID-validerare vs Tidsordnad generator: Vilket verktyg behöver du?

Snabbsvar: Använd UUID-tolkare & Avkodare när du behöver inspektera en enskild identifierares interna 128-bitarsfält, nod-ID eller inbäddade UTC-tidsstämpel från v1, v6 och v7. Använd UUID-validerare för att kontrollera syntax och filtrera tusentals kandidat-ID:n i bulk, eller UUID v7, v6 & v1-generator för att skapa nya tidsordnade nycklar.

Varje verktyg i Utiliomes UUID-svit riktar in sig på ett specifikt steg i arbetet med RFC 9562-identifierare:

Kapacitet UUID-tolkare & Avkodare (Detta verktyg) UUID-validerare UUID v7, v6 & v1-generator
Primärt syfte Inspektera interna bitfält och avkoda inbäddade tidsstämplar från ett befintligt UUID Verifiera RFC 9562-syntax, version och variantefterlevnad för enskilda ID:n eller bulklistor Generera nya tidsordnade RFC 9562-UUID:er för databasprimärnycklar
Hantering av tidsstämplar Extraherar ISO-8601 UTC-datum, Unix-ms och gregorianska 100-ns-ticks från v1, v6 och v7 Avkodar inte tidsstämplar; verifierar versionsnibbles och variantbitsprefix Kodar aktuella eller anpassade tidsstämplar till nya v7-, v6- eller v1-identifierare
Bit- och binärinspektion Fullständig 128-bitars binär layout, klocksekvens, rand_a/rand_b och IEEE 802-nodflaggor Versionsetikett per rad (v1-v8, Nil, Max) samt diagnostik för syntaxfel Formaterar nyskapade nycklar som kanonisk hex med bindestreck, rå hex eller JSON
Bulkfiltrering och export Fokuserad djupinspektion av enskilda nycklar Filtrerar flerradiga filer eller inklistrade loggar och exporterar rensade, giltiga UUID-uppsättningar Bulkgenererar monotona batchar av tidsordnade nycklar

Välj rätt arbetsflöde

  • Felsöka en händelselogg eller primärnyckel: Klistra in identifieraren här för att extrahera dess exakta UTC-skapelsetidsstämpel, kontrollera om dess nod-ID är en hårdvaru-MAC eller en slumpmässig multicast-adress samt inspektera dess råa 128-bitarslayout.
  • Granska eller rensa ett dataset: Skicka CSV-kolumner, loggdumpar eller API-nyttolaster till UUID-validerare för att rensa bort felformaterade strängar, upptäcka äldre Microsoft 110x-GUID:er och exportera kanoniska gemena identifierare.
  • Skapa nya identifierare: Använd UUID v7, v6 & v1-generator när du behöver B-trädsvänliga tidsordnade nycklar, eller UUID v4-generator när du behöver icke-temporala 122-bitars CSPRNG-identifierare helt utan läckage av tidsstämplar.
FAQ

UUID-tolkare & Avkodare FAQ och teknisk guide

Allt du behöver veta om att använda Utiliomes gratis uuid parser och avkodare online.

Kan man extrahera en skapelsetidsstämpel från ett UUID v4 eller UUID v5?

Nej. Ett UUIDv4 innehåller 6 fasta versions- och variantbitar samt 122 bitar av kryptografiskt slumpmässig (CSPRNG) utdata, medan UUIDv3 och UUIDv5 innehåller trunkerade MD5- eller SHA-1-hashar av ett namnrymds-UUID och en namnsträng. Ingen av dem lagrar tid, klocksekvens eller värdmetadata – endast UUIDv1, UUIDv6 och UUIDv7 (samt äldre DCE Security v2 med grova ersättningar för POSIX UID/GID) bär standardiserade skapelsetidsstämplar.

Varför avkodas UUID v1 och UUID v6 till exakt samma tidsstämpel trots olika hexprefix?

Båda versionerna kodar ett 60-bitars antal 100-nanosekundersintervall som förflutit sedan 1582-10-15T00:00:00Z. UUIDv1 placerar de snabbast skiftande time_low-bitarna i de första 32 bitarna (bits 0-31), vilket sprider ut sekventiella infogningar över B-trädets indexsidor. UUIDv6 ordnar om exakt samma 60 bitar med den mest signifikanta först (time_high, time_mid, time_low) så att den lexikografiska strängordningen matchar den kronologiska skapelseordningen.

Hur kan jag se om ett nod-ID i UUID v1 är en fysisk MAC-adress eller slumpmässigt genererat?

Kontrollera den minst signifikanta biten i oktett 10 (den första byten i det 48-bitars node-fältet), vilken motsvarar IEEE 802 unicast/multicast-flaggan. Fysiska nätverkskorts MAC-adresser har alltid 0 i denna bit (unicast), medan RFC 9562 avsnitt 6.10 specificerar att denna bit ska sättas till 1 (multicast) närhelst ett 48-bitars pseudoslumpmässigt nodvärde används i stället för hårdvara.

Vilken tidsstämpelprecision under millisekunden kan avkodas från UUID v7?

UUIDv7 garanterar 1 millisekunds tidsstämpelprecision via sitt 48-bitars unix_ts_ms-fält (bits 0-47). Även om RFC 9562 avsnitt 6.2 tillåter generatorer att placera en valfri submillisekunddel eller monoton räknare i rand_a (bits 52-63), saknar trådformatet en flagga som anger huruvida rand_a innehåller slumpmässig entropi, en räknare eller bråkdelar av nanosekunder. Därför kan en generell tolkare endast deterministiskt avkoda unix_ts_ms.

Hur hanterar tolkaren Nil-, Max- och UUID v8-identifierare?

Inmatningar med enbart nollor (00000000-0000-0000-0000-000000000000) och enbart ettor (ffffffff-ffff-ffff-ffff-ffffffffffff) identifieras som de speciella RFC 9562 Nil- och Max-UUID:erna snarare än ogiltiga värden för version 0 eller version 15. För UUIDv8 (ver = 1000) extraherar tolkaren custom_a (48 bitar), custom_b (12 bitar) och custom_c (62 bitar) som råa hexadecimala och binära fält utan att gissa en tidsstämpel, eftersom bitlayouter i v8 är leverantörsspecifika.