Tema

Ferramentas populares

Gerador de UUID

Gere na hora um UUID v4 aleatório ou um UUID v7 ordenado por tempo, ou até 10.000 de uma vez. Também serve para gerar GUID online: um novo GUID é o mesmo tipo de valor de 128 bits. Cole qualquer UUID para decodificar a versão, o momento de criação e cada campo.

RFC 9562 · crypto.getRandomValues · criado e lido no seu navegador, nada é enviado

O dígito colorido é a versão: o primeiro dígito do terceiro grupo de todo UUID.

v4 · Aleatório36 caracteres · 122 bits aleatórios
xxxxxxxx-xxxx-4xxx-Nxxx-xxxxxxxxxxxx
Anatomia · RFC 9562 §5.4128 bits · 32 dígitos hex · 36 caracteres
Passe o mouse ou toque em um campo para lê-lo

Criado e lido no seu navegador com crypto.getRandomValues; nada é enviado.

Formato

O que é um UUID e o que significa a sigla?

UUID significa Universally Unique Identifier (identificador universalmente único): um rótulo de 128 bits que qualquer computador pode criar sozinho e ainda assim esperar que nenhum outro computador crie o mesmo. Ele é escrito como 32 dígitos hexadecimais em cinco grupos, como 919108f7-52d1-4320-9bac-f847db4148a8.

O formato é definido pela RFC 9562 (maio de 2024), que substituiu a RFC 4122 e acrescentou as versões 6, 7 e 8. Nenhum registro central distribui UUIDs: a unicidade vem da aleatoriedade, de um timestamp ou do hash de um nome, conforme a versão.

Bancos de dados os usam como chaves primárias, APIs como IDs de requisições e objetos, e sistemas operacionais para discos, partições e componentes de software. GUID (Globally Unique Identifier, identificador globalmente único) é o nome que a Microsoft dá à mesma coisa.

Um valor, quatro tamanhosRFC 9562 §4

UniversallyUniqueIDentifier

  1. 128 bits
  2. 16 bytes
  3. 32 dígitos hex
  4. 36 caracteres com os hífens919108f7-52d1-4320-9bac-f847db4148a8

GUIDo nome que a Microsoft dá ao mesmo valor

O exemplo de versão 4 da RFC 9562 contado de quatro formas. A forma de texto soma quatro hífens aos 32 dígitos hex: 36 caracteres.
Gerador de UUID: um UUID v7 com timestamp, versão e bits aleatórios marcados campo a campo, e um lote de UUIDs v7Gerador de UUID: um UUID v7 com timestamp, versão e bits aleatórios marcados campo a campo, e um lote de UUIDs v7Escolha uma versãov4 aleatório, v7 ordenado por tempo, v5 baseado em nome e as demais, cada uma com sua própria cor.Um cliqueCopie ou gere um novo; um lote de até 10.000 sai como texto, CSV, JSON ou SQL.Cada campoOs bits que a RFC 9562 define para esta versão, com o momento gravado num v7 já decodificado.Qualquer formatoChaves, sem hífens, maiúsculas, Base64url, um inteiro ou a ordem de bytes do .NET.
Um UUID v7 desmontado: o timestamp de 48 bits, o dígito da versão, os bits da variante e a parte aleatória. Selecione um número para ver o que cada parte mostra.

Formato e tamanho do UUID: 36 caracteres

Um UUID tem 128 bits, escritos como 32 dígitos hex e 4 hífens em grupos de 8, 4, 4, 4 e 12: 36 caracteres. O primeiro dígito do terceiro grupo é a versão, e o primeiro dígito do quarto grupo mostra a variante: 8, 9, a ou b nos UUIDs da RFC 9562.

Assim, 017f22e2-79b0-7cc3-98c4-dc0c0c07398f é versão 7, variante RFC. Maiúsculas, minúsculas e letras misturadas são todas válidas; a maioria das ferramentas imprime em minúsculas, e o uuidgen do macOS em maiúsculas. Sem hífens são 32 caracteres, entre chaves 38 (o formato B do .NET), como urn:uuid: 45 e em Base64url 22.

Uma expressão regular que valida a forma da RFC: ^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$, com a flag que ignora maiúsculas e minúsculas. Ela recusa os UUIDs Nil e Max, que são válidos, mas especiais; o decodificador acima dá nome a eles.

A forma de textoRFC 9562 §4
017f22e28-79b04-7cc34-98c44-dc0c0c07398f12

32 dígitos hex + 4 hífens = 36 caracteres

xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxxM versão: 1–8N variante: 8, 9, a ou b
Regex · ignora maiúsculas e minúsculas^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
Os mesmos 128 bits, escritos de outras formas
  • Padrão017f22e2-79b0-7cc3-98c4-dc0c0c07398f36
  • Sem hífens017f22e279b07cc398c4dc0c0c07398f32
  • Chaves {…}{017f22e2-79b0-7cc3-98c4-dc0c0c07398f}38
  • urn:uuid:urn:uuid:017f22e2-79b0-7cc3-98c4-dc0c0c07398f45
  • Base64urlAX8i4nmwfMOYxNwMDAc5jw22
  • Base64AX8i4nmwfMOYxNwMDAc5jw==24
  • Base58BihbxwwQ4NZZpKRH9JDCz21
  • Base3201FWHE4YDGFK1SHH6W1G60EECF26
  • Inteiro1989357241971137676463954034883508623até 39
  • Binário01 7f 22 e2 79 b0 7c c3 98 c4 dc 0c 0c 07 39 8f16 bytes
O próprio exemplo de v7 da RFC 9562 em cada forma escrita. A regex recusa os UUIDs Nil e Max de propósito: eles não têm versão.

Versões de UUID explicadas: v1 a v8

A versão diz como um UUID foi gerado: o v4 a partir de bits aleatórios, o v7 a partir do momento mais bits aleatórios, o v1 e o v6 a partir de um timestamp e de um ID de nó, o v3 e o v5 pelo hash de um nome, e o v8 num layout próprio de quem o gera.

As versões 2 e 0 não são geradas aqui: a v2 (DCE Security) é reservada e a RFC 9562 não define o layout dela, e 0 não é uma versão. Os dois valores especiais não têm versão: o UUID Nil é todo de zeros e o UUID Max, todo de uns (ffffffff-ffff-ffff-ffff-ffffffffffff, novidade da RFC 9562).

Para sistemas novos, a RFC 9562 recomenda o v7 em vez do v1 e do v6, e o v5 em vez do v3. O v4 continua sendo a escolha simples quando o valor não deve dizer nada sobre quando foi gerado.

VersãoSeus 128 bitsGerado a partir deOrdena por tempo
v1Tempo + nó · §5.1Tempo (100 ns) + sequência do relógio + nóNão
v2DCE Security: reservada, sem layout na RFC 9562Não gerada: nenhum layout definido–
v3Nome · MD5 · §5.3MD5 de um namespace + um nomeNão
v4Aleatório · §5.4Bits aleatóriosNão
v5Nome · SHA-1 · §5.5SHA-1 de um namespace + um nomeNão
v6v1 ordenável · §5.6Os campos do v1, com os bits altos do tempo primeiroSim
v7Ordenado por tempo · §5.7Tempo Unix (ms) + bits aleatóriosSim
v8Personalizado · §5.8O layout próprio de quem geraNão
Nil§5.9Só zeros: “sem valor”–
Max§5.10Só uns: um sentinela–
  • tempo
  • aleatório
  • hash
  • sequência do relógio
  • nó
  • versão
  • variante
Cada barra são os 128 bits de uma versão, na disposição da RFC 9562, a partir dos próprios vetores de teste dela. Só o v6 e o v7 põem o tempo primeiro, então só eles ordenam por tempo como texto.

UUID v4 vs v7: qual usar?

Use v7 para chaves de banco de dados e tudo o que você ordena ou indexa: ele começa com o momento de criação, então as linhas novas vão para o fim do índice. Use v4 quando o ID não pode revelar quando foi gerado: todos os 122 bits livres dele são aleatórios.

Chaves v4 aleatórias espalham cada inserção por todo o índice B-tree, o que provoca divisões de página e mantém uma parte maior do índice quente na memória; chaves v7 chegam em ordem, como um número autoincremental, mas qualquer servidor pode gerá-las sem consultar o banco de dados. Um v7 mantém 74 bits aleatórios por milissegundo, então dois servidores gerando um no mesmo instante ainda assim não colidem.

A contrapartida: qualquer pessoa que vê um v7 consegue ler o milissegundo em que ele foi gerado (cole um no decodificador acima). Se isso importa, use v4, ou mantenha o v7 interno e mostre um ID diferente ao público.

12 inserções num índice B-tree8 páginas folha · 16 chaves cada
chaves v4 caem em qualquer lugar7 páginas de 8 alteradas · divisões de página: 3
Páginas pelo primeiro byte
00–1fdivisão
20–3f
40–5f
60–7f
80–9f
a0–bf
c0–dfdivisão
e0–ffdivisão
c100eb4b-4f3f-4b29-ad77-da7cd9d1eda592c97333-2db8-4fc2-b5b6-cedd8c7abede
chaves v7 caem no fim1 página de 8 alterada · divisões de página: 0
Páginas pelo dia em que as chaves foram geradas
17 de out.
18 de out.
19 de out.
20 de out.
21 de out.
22 de out.
23 de out.
24 de out.
01a16d3e-e1c0-70f6-99ec-6d454991b2fa01a16d3e-e1c0-70f6-99ec-6d45c2f6b35b
  • já no índice
  • livre
  • chave v4 nova
  • chave v7 nova
  • divisão de página: metade das chaves vai para uma página nova
Um modelo, não um benchmark: páginas folha de 16 chaves. Chaves aleatórias encontram páginas antigas quase cheias e as dividem; os primeiros bytes do v7 são o tempo, então as doze vão para a página mais nova, que ainda tem espaço.

GUID vs UUID: existe diferença?

Um GUID e um UUID são o mesmo valor de 128 bits na mesma forma de texto; GUID é o nome que a Microsoft dá a ele. O Guid.NewGuid() do .NET gera um UUID versão 4 aleatório, e o Guid.CreateVersion7() do .NET 9, um versão 7.

A diferença está na memória. A estrutura GUID da Microsoft guarda os três primeiros grupos como inteiros little-endian, então o ToByteArray() do .NET entrega os 8 primeiros bytes numa ordem diferente da ordem de bytes de rede da RFC 9562: 919108f7-52d1-… vira os bytes f7 08 91 91 d1 52 …. O texto é o mesmo; bytes brutos movidos entre sistemas precisam ser convertidos. O decodificador mostra as duas ordens.

O uniqueidentifier do SQL Server também ordena primeiro pelos seus últimos seis bytes, então valores v7 não ficam em ordem cronológica ali; o NEWSEQUENTIALID() gera valores que ficam, embora possam recomeçar de um valor mais baixo após uma reinicialização e sejam fáceis de adivinhar. GUIDs COM antigos podem trazer os bits de variante próprios da Microsoft em vez dos da RFC 9562; o decodificador dá nome a essa variante.

Um GUID, três ordens de bytes16 bytes
919108f7-52d1-4320-9bac-f847db4148a8
RFC 9562 ordem de rede
.NET ordem do Guid.ToByteArray()
SQL Server ordem do uniqueidentifierOs últimos seis bytes decidem a ordem
  • Data1 · 4 bytes, invertidos
  • Data2 · invertidos
  • Data3 · invertidos
  • Data4 · como estão
O mesmo texto na memória: o .NET guarda os três primeiros grupos em little-endian, e o SQL Server ordena pelos últimos seis bytes primeiro, então chaves v7 ordenadas por tempo não ficam em ordem ali.

Como gerar um UUID em código

A maioria das linguagens gera um UUID v4 em uma linha, e muitas agora geram v7 também: uuid.uuid7() do Python 3.14, Guid.CreateVersion7() do .NET 9, UUID.ofEpochMillis() do Java 26, uuid.NewV7() do Go 1.27, crypto.randomUUIDv7() do Node.js 26.1 e uuidv7() do PostgreSQL 18. Os navegadores ainda têm só o crypto.randomUUID(), um v4.

Escolha sua linguagem para ver a linha de código. Nem todo v7 mantém em ordem os UUIDs gerados no mesmo milissegundo: os do Python e do Go mantêm, os do .NET e do Node não garantem isso. E o UUID() do MySQL retorna um UUID versão 1, que no Linux e no Windows carrega o endereço MAC real do servidor.

Funções de UUID nativas, por linguagem

Python
import uuid

uuid.uuid4()   # v4
uuid.uuid7()   # v7, Python 3.14+
uuid.uuid5(uuid.NAMESPACE_DNS, "www.example.com")  # v5

uuid7() mantém um contador de 42 bits, então UUIDs do mesmo milissegundo ficam em ordem.

Versões conforme a documentação de cada linguagem as lista; as marcas são os logotipos dos próprios projetos.

Dois UUIDs podem ser iguais?

Na teoria, sim; na prática, não: um UUID v4 tem 122 bits aleatórios, cerca de 5,3 × 10³⁶ valores. Você precisaria gerar cerca de 103 trilhões deles para ter uma chance em um bilhão de que dois quaisquer coincidam, e cerca de 2,7 quintilhões para uma chance de 50%.

Esse é o limite do paradoxo do aniversário: com n valores aleatórios entre N possíveis, a chance de uma repetição é de cerca de 1 − e^(−n(n−1)/2N). Gerando um bilhão de UUIDs por segundo, uma chance de 50% levaria cerca de 86 anos. Duplicados reais vêm de geradores defeituosos: uma semente não aleatória, uma máquina virtual clonada com seu estado aleatório ou IDs copiados à mão.

No v7, só UUIDs gerados no mesmo milissegundo podem coincidir, e 74 bits aleatórios os diferenciam. O gerador daqui também mantém um lote em ordem dentro de um milissegundo (RFC 9562 §6.2), então 10.000 de uma vez são únicos e ordenados.

O limite do paradoxo do aniversárionossos cálculos
Chance de que dois quaisquer sejam iguais1 em 1,1 × 1019p ≈ 9,4 × 10−20

A um bilhão por segundo, gerar essa quantidade leva 1 segundo.

p ≈ 1 − e^(−n(n−1)/2N), com N = 2¹²² para v4 e 2⁷⁴ por milissegundo para v7. A RFC 9562 não dá números de colisão: estes são nossos, da mesma função que a página usa.

Decodificador de UUID: como ler o timestamp de um UUID

Cole um UUID em Decodificar e validar, o decodificador e validador de UUID acima: ele lê a versão e a variante em duas posições fixas e depois os campos que essa versão define. Um v7 dá o milissegundo em que foi gerado; um v1 ou v6, o momento com precisão de 100 nanossegundos, além de uma sequência do relógio e um ID de nó.

Um nó de v1 ou v6 com o bit multicast desligado pode ser o endereço MAC real da placa de rede; procure o fabricante na consulta de endereço MAC. Geradores que respeitam a privacidade ligam esse bit e usam um nó aleatório, como este faz.

O momento é o que o gerador gravou, não prova de quando o UUID foi gerado. O v4 não guarda momento algum, só bits aleatórios, e v3, v5 e v8 guardam hashes: não há nada a ler de volta, e um hash não pode ser revertido para o nome. Cole uma lista para verificar até 1.000 de uma vez: linhas inválidas, duplicados e se os UUIDs baseados em tempo estão em ordem.

Duas formas de escrever o mesmo momentoRFC 9562 · Appendix A
017f22e2-79b0-7cc3-98c4-dc0c0c07398f
  1. unix_ts_ms0x017f22e279b0
  2. ms desde 19701 645 557 742 000
  3. UTC2022-02-22T19:22:22.000Z
c232ab00-9414-11ec-b3c8-9f6bdeced846
  1. time_high · time_mid · time_low1ec 9414 c232ab00
  2. passos de 100 ns desde 1582-10-15138 648 505 420 000 000
  3. UTC2022-02-22T19:22:22.0000000Z

O mesmo momento: os exemplos da RFC 9562 foram gerados juntos.

Um v7 começa com os milissegundos desde 1970. Um v1 guarda a parte baixa do tempo primeiro, então o decodificador põe as três partes de volta em ordem antes de contar a partir de 15 de outubro de 1582.

UUIDs baseados em nome: v5 e v3

Um UUID v5 é o hash SHA-1 de um UUID de namespace mais um nome, cortado em 128 bits com a versão e a variante definidas; o v3 faz o mesmo com MD5. O mesmo namespace e o mesmo nome sempre dão o mesmo UUID, em qualquer computador: escolha v5 acima para usar esta página como gerador de UUID v5.

A RFC 9562 define quatro namespaces: DNS para nomes de domínio, URL, OID e X.500. Assim, www.example.com no namespace DNS é sempre 2ed6657d-e927-568b-95e1-2665a8aea6a2 como v5. Use UUIDs baseados em nome para dar um ID estável a algo que já tem um nome único, sem guardar uma tabela de correspondência.

Prefira v5 a v3: o MD5 é mais fraco, e a RFC 9562 recomenda v5. Nenhum dos dois serve para esconder o nome: qualquer pessoa que consiga adivinhá-lo pode calcular o mesmo UUID. A opção v8 daqui usa SHA-256 do mesmo jeito, como no próprio exemplo de v8 da RFC.

Namespace + nome → v5RFC 9562 §5.5
  1. Namespace6ba7b810-9dad-11d1-80b4-00c04fd430c8DNS · 16 bytes
  2. Nome"www.example.com"UTF-8 · 15 bytes
  3. Resumo SHA-1, 160 bits2ed6657de927468b55e12665a8aea6a22dee3e35os primeiros 128 bits são mantidos
  4. O UUID2ed6657d-e927-568b-95e1-2665a8aea6a2dígito da versão 4 → 5 · dígito da variante 5 → 9
  • DNS6ba7b810…
  • URL6ba7b811…
  • OID6ba7b812…
  • X.5006ba7b814…
O próprio exemplo de v5 da RFC 9562: www.example.com no namespace DNS. Qualquer computador que calcule o hash do mesmo namespace e do mesmo nome obtém o mesmo UUID.

ULID vs UUID v7 (e outros IDs)

Um ULID e um UUID v7 começam com um timestamp de 48 bits em milissegundos e são ordenados por tempo. A diferença: um ULID usa todos os outros 80 bits para aleatoriedade e é escrito como 26 caracteres Base32, enquanto um v7 gasta 6 bits com a versão e a variante e cabe em qualquer coluna e biblioteca de UUID.

Se o seu banco de dados, ORM ou API já trabalha com UUID, o v7 dá ordem cronológica sem um tipo novo. NanoID e IDs curtos parecidos são strings aleatórias de tamanho escolhido, sem momento e sem layout padrão. Qualquer UUID também pode ser escrito de forma mais curta: 22 caracteres em Base64url, no máximo 22 em Base58.

Três IDs, 128 bits cadaem escala
UUID v7tempo, depois aleatório
36 caracteresordena por tempo
ULIDtempo, depois aleatório
26 caracteresordena por tempo
UUID v4só aleatório
36 caracteressem ordem
  • milissegundos desde 1970
  • aleatório
  • versão e variante
O UUID v7 e o ULID compartilham o relógio de 48 bits em milissegundos; o v7 dá 6 bits para a versão e a variante, e o ULID usa todos os 80 para aleatoriedade. Um v4 é só aleatório; em Base64url, qualquer UUID tem 22 caracteres.

UUIDs são seguros para usar como tokens?

Não. A RFC 9562 diz para não presumir que UUIDs são difíceis de adivinhar e para nunca usar um como capacidade de segurança: um ID cuja posse dá acesso, como um link de redefinição de senha ou uma chave de API.

Um v4 de um bom gerador é aleatório, mas um v1, v6 ou v7 revela o momento de criação, e um v3 ou v5 pode ser recalculado a partir do nome. Para segredos, use um token feito para isso, como 256 bits aleatórios de um gerador criptográfico, e verifique a permissão em cada requisição. UUIDs servem bem como IDs públicos quando o acesso é verificado separadamente.

IDO que qualquer pessoa que o vê pode descobrirComo segredo
v1, v6Quando foi gerado e, talvez, o endereço MAC da placa de redeNão
v7O milissegundo em que foi geradoNão
v5, v3Nada novo, mas um nome adivinhado dá o mesmo UUIDNão
v4Nada, se o gerador for confiávelNão
Token de 256 bitsNada: feito para segredosSim
A RFC 9562 diz para não presumir que UUIDs são difíceis de adivinhar nem usá-los como capacidades de segurança. Para segredos, use um token de um gerador criptográfico e verifique o acesso em cada requisição.

Gerador de UUID: perguntas e respostas

Como gerar um UUID online ou em código?

Abra esta página: um UUID v4 aleatório já está pronto para copiar, e Novo UUID gera outro. Escolha v7 para usá-la como gerador de UUID v7, defina uma quantidade para gerar até 10.000 de uma vez e escolha um formato, como chaves ou Base64url. Em código, crypto.randomUUID() no JavaScript, uuid.uuid4() no Python e Guid.NewGuid() no C# geram um v4 em uma linha.

O que significa UUID?

Universally Unique Identifier, ou identificador universalmente único. É um valor de 128 bits, escrito como 36 caracteres, como 919108f7-52d1-4320-9bac-f847db4148a8, que computadores geram de forma independente, sem registro central, e ainda assim esperam que seja único. A RFC 9562 o define. A Microsoft chama o mesmo valor de GUID, um Globally Unique Identifier.

GUID e UUID são a mesma coisa?

Sim, para fins práticos: os mesmos 128 bits e a mesma forma de texto, e o Guid.NewGuid() gera um UUID versão 4 padrão. Dois detalhes diferem. O .NET guarda os três primeiros grupos em little-endian, então arrays de bytes brutos saem em outra ordem, e o SQL Server ordena valores uniqueidentifier pelo último grupo primeiro. Para gerar GUID online, use esta página como gerador de GUID aleatório: o texto que você copia funciona nos dois mundos.

Qual versão de UUID devo usar?

A versão 7 para chaves de banco de dados e tudo o que é ordenado, porque ela começa com o momento de criação e mantém os índices compactos. A versão 4 quando o ID não deve revelar quando foi gerado. A versão 5 quando o mesmo nome deve sempre levar ao mesmo ID. Evite o v1 em projetos novos: a RFC 9562 recomenda o v7 no lugar dele, e um v1 pode carregar um endereço MAC real.

É possível gerar dois UUIDs iguais?

Só com uma chance astronomicamente pequena, se o gerador for confiável. Um v4 tem 122 bits aleatórios, então cerca de 103 trilhões de UUIDs dão uma chance em um bilhão de uma única repetição, e uma chance de 50% exige cerca de 2,7 quintilhões. Duplicados no mundo real vêm de geradores defeituosos, máquinas virtuais clonadas ou dados copiados, não da matemática.

Dá para decodificar um UUID?

Em parte. Todo UUID mostra a versão e a variante. Um v7 também revela o milissegundo em que foi gerado, e um v1 ou v6, o momento com precisão de 100 nanossegundos, uma sequência do relógio e um ID de nó, às vezes um endereço MAC real. Um v4 guarda só bits aleatórios, e v3 e v5 guardam hashes que não podem ser revertidos para o nome. Cole um em Decodificar e validar.

Qual é o tamanho de um UUID?

128 bits, ou 16 bytes. Como texto, são 36 caracteres: 32 dígitos hexadecimais e 4 hífens em grupos de 8-4-4-4-12. Sem hífens são 32 caracteres, entre chaves 38, com o prefixo urn:uuid: 45, em Base64url 22 e como inteiro decimal até 39 dígitos. Sempre que puder, guarde-o num tipo UUID nativo ou em 16 bytes, em vez de texto.

O que é um GUID vazio ou UUID Nil?

O valor com todos os 128 bits em zero: 00000000-0000-0000-0000-000000000000. A RFC 9562 o chama de UUID Nil, e o Guid.Empty do .NET é o mesmo valor, muito usado para indicar que nenhum ID foi definido. A RFC 9562 também define o UUID Max, todo de uns, ffffffff-ffff-ffff-ffff-ffffffffffff, como sentinela (.NET 9: Guid.AllBitsSet). Nenhum dos dois é aleatório, então nunca os use como IDs reais.

O UUID v7 é ordenável?

Sim. Os primeiros 48 bits dele são o tempo Unix em milissegundos, então ordenar UUIDs v7 como texto ou como bytes os ordena pelo momento de criação, com precisão de milissegundo. Dentro de um mesmo milissegundo, a ordem depende do gerador: este mantém um lote estritamente crescente, como descreve a seção 6.2 da RFC 9562. O uniqueidentifier do SQL Server é a exceção: ele compara o último grupo primeiro.

É seguro usar um UUID como senha ou token de acesso?

Não. A RFC 9562 alerta para não presumir que UUIDs são difíceis de adivinhar nem usá-los como capacidades de segurança. Versões baseadas em tempo revelam quando foram geradas, e as baseadas em nome podem ser recalculadas. Para segredos, use um token aleatório de um gerador criptográfico e trate UUIDs como IDs públicos, com o acesso verificado separadamente. Para senhas, use o gerador de senhas.

Os UUIDs gerados aqui são enviados para algum lugar?

Não. Eles são gerados no seu navegador com crypto.getRandomValues, o gerador aleatório criptograficamente seguro dele, e UUIDs colados são decodificados no seu dispositivo. Nada do que você gera ou cola é enviado para nós nem para mais ninguém. Um link de compartilhamento leva só o que você escolheu: a versão, a quantidade e o formato, o nome no v5 ou os UUIDs que você colou no decodificador, então compartilhe-o como compartilharia esses dados.

Sentiu falta de algo?Sugira um recurso ou uma nova ferramenta

Ferramentas relacionadas