CUID2 Generator

Generate secure next-generation CUID2 identifiers

Antal
Längd

Genererade CUID2s

Klicka på Generera för att skapa CUID2s

Vad är CUID2?

CUID2 är den andra generationen av CUID, skriven om från grunden med fokus på kryptografisk säkerhet och integritet.

Till skillnad från CUID v1 som synligt bäddar in tidsstämpeln, döljer CUID2 alla komponenter i en SHA3-hash och skapar praktiskt taget oförutsägbara strängar.

ID:n börjar med ett anpassningsbart alfabetiskt prefix (standard c) följt av en base36-sträng av SHA3-hashen.

Varför CUID2?

CUID2 kom som svar på specifika säkerhetsproblem i CUID v1:

  • Exponerad tidsstämpel: CUID v1 avslöjade skapandetiden i början av varje ID.
  • Förutsägbarhet: Med kunskap om CUID v1-strukturen kunde en del av det interna tillståndet härledas.
  • Brist på kryptografisk säkerhet: CUID v1 använde inte explicit en kryptografiskt säker slumptalsgenerator.

CUID2 åtgärdar dessa problem genom att använda SHA3, CSPRNG och dölja tidsstämpeln.

Designprinciper

Kryptografisk säkerhet
Använder CSPRNG och SHA3 för att säkerställa att ID:n inte kan förutsägas ens om tidsramen är känd.
Tidsstämpelintegritet
Tidsstämpeln blandas in i hashen och visas inte direkt, vilket skyddar tidsintegriteten.
Anpassningsbart prefix
Ange ett anpassat prefix för att skilja ID:n för olika entitetstyper (t.ex. usr_, prd_).
Anpassningsbar längd
Standardlängden är 24 tecken men kan justeras efter applikationskrav.
Delat fingeravtryck
Dela ett slumpmässigt fingeravtrycksvärde mellan funktionsanrop för bättre entropidistribution.
Databaskompatibel
Börjar alltid med ett alfabetiskt tecken, kompatibelt med variabelnamn och databasbegränsningar.

CUID2 vs CUID v1

Jämförelse av nyckelkarakteristika mellan de två generationerna:

AttributCUID2CUID v1
SäkerhetKryptografisk (SHA3+CSPRNG)Icke-kryptografisk
FörutsägbarhetMycket lågLåg (exponerad tidsstämpel)
LängdAnpassningsbar (standard 24)Fast 25 tecken
PrefixAnpassningsbartFast 'c'
DistributionJämnt fördeladTidsstämpelpartisk
StatusAktiv och rekommenderadInaktuell

CUID2 vs UUID v4

Jämförelse med den vanliga UUID-standarden:

AttributCUID2UUID v4
Standardlängd24 tecken36 tecken
URL-säkerJaJa (med bindestreck)
Anpassad längdJaNej
SorterbarNejNej
EntropiHög (SHA3)Hög (CSPRNG)
TeckenuppsättningAlfanumeriska gemenerHex + bindestreck

CUID2 erbjuder garanterat alfabetiskt prefix och flexibel längd med säkerhet likvärdig UUID v4.

Vem använder CUID2?

CUID2 har antagits av framstående communities och ramverk:

  • Prisma stöder CUID2 som ID-typ i fältet @id via @default(cuid()).
  • Drizzle ORM-communityn antar CUID2 för standard-ID:n.
  • SvelteKit- och Remix-projekt använder det för sessions-ID:n.
  • Högvolym-API-servrar som behöver spårbara ID:n i loggar.
  • Applikationer som synkroniserar över flera databaser eller regioner.

Kodexempel

Installation och användning: pnpm add @paralleldrive/cuid2

JavaScript (npm — @paralleldrive/cuid2)
import { createId } from '@paralleldrive/cuid2'

// Generate a single CUID2 (default length: 24)
const id = createId()
console.log(id) // e.g. "tz4a98xxat96iws9zmbrgj3a"

// Custom length
import { init } from '@paralleldrive/cuid2'
const createShortId = init({ length: 16 })
const shortId = createShortId()
console.log(shortId) // e.g. "tz4a98xxat96iws9"

Avancerad konfiguration:

Prisma Schema
model User {
  id        String   @id @default(cuid())
  email     String   @unique
  name      String?
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

Databasintegration:

Node.js (Web Crypto — no dependencies)
async function generateCuid2(length = 24) {
  const alphabet = 'abcdefghijklmnopqrstuvwxyz'

  // Random prefix letter
  const firstByte = crypto.getRandomValues(new Uint8Array(1))[0]
  const firstChar = alphabet[firstByte % 26]

  // Random 32-byte salt
  const salt = crypto.getRandomValues(new Uint8Array(32))
  const saltHex = [...salt].map(b => b.toString(16).padStart(2, '0')).join('')

  // SHA-512 of timestamp + salt
  const input = Date.now().toString(36) + saltHex
  const hashBuffer = await crypto.subtle.digest(
    'SHA-512',
    new TextEncoder().encode(input)
  )

  // Encode hash bytes as base-36 string
  const bytes = new Uint8Array(hashBuffer)
  let hash = ''
  for (let i = 0; i < bytes.length; i += 8) {
    let chunk = 0n
    for (let j = 0; j < 8 && i + j < bytes.length; j++) {
      chunk = (chunk << 8n) | BigInt(bytes[i + j])
    }
    hash += chunk.toString(36)
  }

  return (firstChar + hash).slice(0, length)
}

// Usage
const id = await generateCuid2()
console.log(id) // e.g. "m7k3r9p2nxq8zt5a6cwj4bvd"

Vanliga frågor

Är CUID2 långsammare än CUID v1 på grund av SHA3?
Något — SHA3 är långsammare än CUID v1:s anpassade algoritm, men skillnaden är omärkbar i de flesta applikationer. CUID2 genererar tiotusentals ID:n per sekund, vilket är mycket snabbare än en typisk databasresa.
Kan jag uppgradera från CUID v1 till CUID2 utan datamigrering?
Du kan lägga till en CUID2-kolumn och gradvis övergå för nya poster. Om du använder CUID som primärnyckel behöver du en migreringsplan eftersom formaten skiljer sig.
Hur mycket entropi har CUID2?
Vid standardlängden 24 tecken ger CUID2 ungefär 118 bitar entropi — mer än UUID v4 (122 slumpmässiga bitar, men vissa är bestämda för versionen). Anpassad längd justerar entropin linjärt.
Är CUID2 lämplig för integritetsorienterande ID:n?
Ja — till skillnad från CUID v1 läcker CUID2 inte skapandetid eller värdinformation. Tidsstämpeln är blandad i hashen och kan inte extraheras enbart från ID:t.
Vad är den optimala längden för CUID2?
Längd 24 (standard) är tillräcklig för de flesta applikationer. Om du genererar miljoner ID:n per dag, överväg att öka till 32. Det rekommenderade minimumet är 16 tecken för att bibehålla tillräcklig kollisionsresistens.
Kan jag använda CUID2 i webbläsaren?
Ja — CUID2-biblioteket körs i webbläsaren via Web Crypto API och i Node.js via kryptomodulen. Lämplig för både klient- och serverapplikationer.