Générateur UUID v3

Qu'est-ce qu'UUID v3 ?

UUID v3 est une version UUID basée sur un nom définie dans RFC 4122. Au lieu de données aléatoires ou d'un horodatage, il dérive l'UUID de manière déterministe à partir de deux entrées : un UUID espace de noms et une chaîne nom. La paire espace de noms + nom est hachée avec MD5, et le hachage résultant est formaté en UUID.

La propriété clé d'UUID v3 est le déterminisme : le même espace de noms et le même nom produiront toujours l'UUID identique, sur n'importe quelle machine, à n'importe quel moment. Cela le rend adapté à l'adressage de contenu — générer des identifiants stables pour des ressources identifiées par un nom significatif.

UUID v3 utilise MD5 comme fonction de hachage. MD5 est considéré comme cryptographiquement compromis à des fins de sécurité, c'est pourquoi UUID v5 (qui utilise SHA-1) est généralement préféré pour le nouveau développement. Ni v3 ni v5 ne fournissent de caractère aléatoire — ils sont purement déterministes.

Espaces de noms standard

RFC 4122 définit quatre UUID d'espace de noms pré-assignés. L'utilisation d'un espace de noms standard assure l'interopérabilité — deux implémentations indépendantes produiront le même UUID v3 pour le même nom dans le même espace de noms :

Vous pouvez également utiliser n'importe quel UUID arbitraire comme espace de noms personnalisé — par exemple, un UUID v4 que vous générez une fois et intégrez dans votre application comme constante. Cela vous permet de créer un espace de noms privé pour vos propres mappings nom-vers-UUID.

UUID v3 vs UUID v5

UUID v3 et UUID v5 sont structurellement identiques — tous deux sont des UUID déterministes basés sur un nom. La seule différence est la fonction de hachage :

Préférez UUID v5 à UUID v3 pour tout nouveau développement. Le hachage SHA-1 est plus fort que MD5, et la différence de performance est négligeable. Utilisez UUID v3 uniquement quand vous devez reproduire des UUID d'un système qui l'utilise déjà.

Quand utiliser UUID v3

UUID v3 (et v5) sont appropriés quand vous avez besoin d'un identifiant stable et reproductible dérivé d'un nom significatif — plutôt qu'un identifiant aléatoire qui doit être stocké et récupéré :

Comprendre le déterminisme

Le déterminisme d'UUID v3 est à la fois sa plus grande force et sa contrainte la plus importante. Étant donné n'importe quel UUID d'espace de noms et n'importe quelle chaîne de nom, l'UUID de sortie est complètement fixe — aucun caractère aléatoire n'est impliqué. Cela signifie :

Produit toujours : 9073926b-929f-31c2-abc9-fad77ae3e8eb

Si un attaquant connaît l'espace de noms et peut deviner le nom, il peut calculer l'UUID à l'avance. Les valeurs UUID v3 ne devraient jamais être utilisées comme jetons imprévisibles, identifiants de session ou secrets. Utilisez UUID v4 pour tout identifiant sensible à la sécurité.

Exemples de code

UUID v3 nécessite un UUID d'espace de noms et une chaîne de nom. Utilisez le package standard uuid :

// Browser / Node.js — UUID v3 without dependencies
function uuidV3(namespace, name) {
  // namespace must be a UUID string like '6ba7b810-9dad-11d1-80b4-00c04fd430c8'
  const nsBytes = namespace.replace(/-/g, '').match(/../g).map(h => parseInt(h, 16))
  const nameBytes = [...new TextEncoder().encode(name)]
  const combined = new Uint8Array([...nsBytes, ...nameBytes])

  // md5(combined) — use your preferred MD5 library or the inline implementation
  const hash = md5(combined) // returns Uint8Array(16)
  hash[6] = (hash[6] & 0x0f) | 0x30 // version 3
  hash[8] = (hash[8] & 0x3f) | 0x80 // variant

  const h = [...hash].map(b => b.toString(16).padStart(2, '0')).join('')
  return `${h.slice(0,8)}-${h.slice(8,12)}-${h.slice(12,16)}-${h.slice(16,20)}-${h.slice(20)}`
}

// Using the 'uuid' npm package
import { v3 as uuidv3 } from 'uuid'
const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8'
console.log(uuidv3('example.com', uuidv3.DNS))
// → '9073926b-929f-31c2-abc9-fad77ae3e8eb' (always the same)

import uuid

# Using the standard library
dns_uuid = uuid.uuid3(uuid.NAMESPACE_DNS, 'example.com')
print(dns_uuid)
# → 9073926b-929f-31c2-abc9-fad77ae3e8eb

url_uuid = uuid.uuid3(uuid.NAMESPACE_URL, 'https://example.com/page')
print(url_uuid)

# Custom namespace
MY_NS = uuid.UUID('a1b2c3d4-e5f6-7890-abcd-ef1234567890')
custom = uuid.uuid3(MY_NS, 'my-entity-name')
print(custom)

package main

import (
    "fmt"
    "github.com/google/uuid"
)

func main() {
    // Standard DNS namespace
    ns := uuid.MustParse("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
    id := uuid.NewMD5(ns, []byte("example.com"))
    fmt.Println(id)
    // → 9073926b-929f-31c2-abc9-fad77ae3e8eb

    // URL namespace
    urlNS := uuid.MustParse("6ba7b811-9dad-11d1-80b4-00c04fd430c8")
    idURL := uuid.NewMD5(urlNS, []byte("https://example.com/page"))
    fmt.Println(idURL)
}

Foire Aux Questions