Generador UUID v2

¿Qué es UUID v2?

UUID v2 es la versión UUID de Seguridad DCE, estandarizada como parte de la especificación del Entorno de Computación Distribuida (DCE) y referenciada en RFC 4122. Extiende UUID v1 incorporando un identificador de usuario o grupo POSIX (UID/GID) en el campo de marca de tiempo.

La estructura es similar a UUID v1, pero el campo de 32 bits time_low se reemplaza por un identificador local de 32 bits (p. ej. un UID POSIX) y un campo local_domain de 1 byte identifica qué tipo de ID local es. La marca de tiempo se trunca como resultado, reduciendo su precisión y garantías de unicidad.

UUID v2 es extremadamente raro en el software moderno. La mayoría de los desarrolladores nunca necesitarán generar uno. Esta página documenta el formato para completitud y para ayudar en la decodificación de valores UUID v2 encontrados en sistemas heredados.

Estructura de UUID v2

Un UUID v2 tiene el mismo formato de 128 bits con guiones que otras versiones UUID. Los campos difieren de UUID v1 de la siguiente manera:

Ejemplo: 000003e8-92e0-21ef-8000-325096b39f47 — local_id 0x000003e8 = UID 1000, local_domain 0x00 = Usuario POSIX

Valores de Dominio Local

El byte local_domain especifica el tipo de identificador local incorporado en el UUID:

Los valores de dominio están definidos por la especificación DCE. Los valores 3–255 están reservados. En la práctica, solo el dominio 0 (Persona/UID) se encuentra comúnmente en valores UUID v2 del mundo real.

Por Qué UUID v2 Raramente Se Usa

Tres características hacen que UUID v2 sea impráctico para la mayoría de las aplicaciones modernas:

Resolución de Marca de Tiempo Gruesa

La marca de tiempo se trunca a 28 bits (aproximadamente granularidad de 7,2 minutos). Dentro de esa ventana, los UUIDs generados con el mismo local_id y dominio en el mismo host no son únicos — la especificación depende del campo clock_seq para diferenciarlos, limitando la unicidad a 64 valores por ventana de 7 minutos.

Sin Soporte de Biblioteca Estándar

A diferencia de UUID v1 y v4, UUID v2 no es compatible con la mayoría de las bibliotecas UUID. El paquete npm uuid, el módulo uuid de Python y java.util.UUID de Java omiten v2. Se requiere implementación personalizada.

Semántica Específica de POSIX

El concepto de dominio local (UID/GID) es inherentemente específico de POSIX y no se traduce significativamente a Windows, sistemas embebidos o entornos en la nube donde el concepto de un ID de usuario POSIX está ausente.

Contexto Histórico

UUID v2 se definió como parte del Entorno de Computación Distribuida (DCE/RPC) de Open Software Foundation a principios de los años 1990. El objetivo era crear UUIDs que pudieran llevar contexto de autorización — específicamente, para que un servidor RPC pudiera identificar al usuario que llama sin un paso de autenticación separado.

El modelo de seguridad DCE asumía un entorno POSIX homogéneo donde cada nodo participaba en un espacio de nombres UID/GID compartido. El UID incorporado permitiría al servidor verificar rápidamente las listas de control de acceso sin un viaje de ida y vuelta a un servicio de directorio.

• Internet se alejó de los entornos POSIX homogéneos hacia arquitecturas en la nube heterogéneas
• La autenticación moderna usa tokens (JWT, OAuth) en lugar de UIDs incorporados en identificadores
• UUID v4 (completamente aleatorio) y UUID v7 (ordenado por tiempo) cubren los casos de uso prácticos para identificadores únicos
• DCE/RPC en sí cayó en desuso generalizado

RFC 4122 (2005) incluyó UUID v2 por referencia a la especificación DCE, pero omitió deliberadamente el algoritmo de generación detallado — señalando que estaba definido por DCE en lugar de la IETF.

RFC 9562 (2024), que actualizó el estándar UUID, retuvo UUID v2 por completitud histórica pero continuó señalando su naturaleza específica de POSIX y la ausencia de un algoritmo de generación completo en el estándar IETF.

UUID v2 vs UUID v1

UUID v2 está derivado de UUID v1. Aquí se comparan:

UUID v2 no ofrece nada sobre UUID v1 para uso de propósito general, y es estrictamente peor en la mayoría de los aspectos. No hay razón para elegir UUID v2 para desarrollo nuevo.

Ejemplos de Código

UUID v2 no tiene soporte nativo en bibliotecas estándar. Los siguientes ejemplos muestran cómo trabajar con valores UUID v2:

Python — implementación manual

import uuid, struct, time

def uuid_v2(local_id: int, local_domain: int = 0) -> str:
    """
    Generate a DCE Security UUID (v2).
    local_domain: 0 = POSIX UID, 1 = POSIX GID, 2 = Org
    local_id: 32-bit unsigned integer (e.g. os.getuid())
    """
    # Get a v1 UUID for the time and node fields
    v1 = uuid.uuid1()
    fields = list(v1.fields)  # [time_low, time_mid, time_hi_version, clock_seq_hi_variant, clock_seq_low, node]

    # Replace time_low with local_id
    fields[0] = local_id & 0xFFFFFFFF

    # Replace version nibble: clear lower 12 bits of time_hi, set version 2
    fields[2] = (fields[2] & 0x0FFF) | 0x2000

    # Replace clock_seq_low with local_domain
    fields[4] = local_domain & 0xFF

    return str(uuid.UUID(fields=tuple(fields)))


import os
print(uuid_v2(os.getuid(), local_domain=0))   # POSIX UID
print(uuid_v2(os.getgid(), local_domain=1))   # POSIX GID

Go — nota

// The standard "github.com/google/uuid" package does NOT support v2.
// You would need to implement it manually, similar to the Python example above.
// Most Go developers use v4 or v7 for new projects.
import "github.com/google/uuid"

v4 := uuid.New()          // v4 — recommended for most use cases
v7, _ := uuid.NewV7()     // v7 — time-ordered, ideal for database primary keys

JavaScript — extraer campos

Para extraer el local_id y el dominio de una cadena UUID v2 existente:

// Extracting fields from a UUID v2 string
const uuidStr = '000003e8-1234-2abc-8200-a1b2c3d4e5f6'
//               ^^^^^^^^ ^^^^ ^    ^^
//               local_id      ver  variant+clockSeqHi
//                                  ^^ = local_domain (00 = POSIX UID)

const parts = uuidStr.split('-')

const localId     = parseInt(parts[0], 16)       // → 1000 (0x3e8)
const version     = parseInt(parts[2][0], 16)    // → 2
const localDomain = parseInt(parts[3].slice(2), 16) // low byte of octet pair

const DOMAIN_NAMES = ['POSIX UID', 'POSIX GID', 'Org']
console.log(`Local ID: ${localId}`)                       // Local ID: 1000
console.log(`Version:  ${version}`)                       // Version:  2
console.log(`Domain:   ${DOMAIN_NAMES[localDomain]}`)     // Domain:   POSIX UID

Preguntas Frecuentes