Esiste un metodo per generare un UUID con go language

Ho un codice simile a questo:

u := make([]byte, 16)
_, err := rand.Read(u)
if err != nil {
    return
}

u[8] = (u[8] | 0x80) & 0xBF // what does this do?
u[6] = (u[6] | 0x40) & 0x4F // what does this do?

return hex.EncodeToString(u)

Restituisce una stringa con una lunghezza di 32, ma non credo che sia un UUID valido. Se è un UUID reale, perché è un UUID e qual è lo scopo del codice che modifica il valore di u[8]e u[6].

C'è un modo migliore per generare UUID?

u[8] = (u[8] | 0x80) & 0xBF // what's the purpose ?
u[6] = (u[6] | 0x40) & 0x4F // what's the purpose ?

Queste linee limitano i valori dei byte 6 e 8 a un intervallo specifico. rand.Readrestituisce byte casuali nell'intervallo 0-255, che non sono tutti valori validi per un UUID. Per quanto ne so, questo dovrebbe essere fatto per tutti i valori nella sezione.

Se sei su Linux, in alternativa puoi chiamare /usr/bin/uuidgen.

package main

import (
    "fmt"
    "log"
    "os/exec"
)

func main() {
    out, err := exec.Command("uuidgen").Output()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%s", out)
}

Che produce:

$ go run uuid.go 
dc9076e9-2fda-4019-bd2c-900a8284b9c4

Puoi generare UUID utilizzando la libreria go-uuid . Questo può essere installato con:

go get github.com/nu7hatch/gouuid

Puoi generare UUID casuali (versione 4) con:

import "github.com/nu7hatch/gouuid"

...

u, err := uuid.NewV4()

Il UUIDtipo restituito è un array di 16 byte, quindi puoi recuperare facilmente il valore binario. Fornisce inoltre la rappresentazione della stringa esadecimale standard tramite il suo String()metodo.

Il codice che hai sembra anche generare un UUID di versione 4 valido: la manipolazione bit per bit che esegui alla fine imposta i campi della versione e della variante dell'UUID per identificarlo correttamente come versione 4 . Questo viene fatto per distinguere gli UUID casuali da quelli generati tramite altri algoritmi (ad esempio gli UUID della versione 1 in base all'indirizzo MAC e all'ora).

Il go-uuid libreria NON è conforme a RFC4122. I bit delle varianti non sono impostati correttamente. Ci sono stati diversi tentativi da parte dei membri della comunità di risolvere questo problema, ma le richieste pull per la correzione non sono state accettate.

Puoi generare UUID utilizzando la libreria Go uuid che ho riscritto in base alla go-uuidlibreria. Sono disponibili diverse correzioni e miglioramenti. Questo può essere installato con:

go get github.com/twinj/uuid

Puoi generare UUID casuali (versione 4) con:

import "github.com/twinj/uuid"

u := uuid.NewV4()

Il tipo di UUID restituito è un'interfaccia e il tipo sottostante è un array.

La libreria genera anche UUID v1 e genera correttamente UUID v3 e 5. Esistono diversi nuovi metodi per aiutare con la stampa e la formattazione e anche nuovi metodi generali per creare UUID basati sui dati esistenti.

"crypto / rand" è un pacchetto multipiattaforma per la generazione casuale di byte

package main

import (
    "crypto/rand"
    "fmt"
)

// Note - NOT RFC4122 compliant
func pseudo_uuid() (uuid string) {

    b := make([]byte, 16)
    _, err := rand.Read(b)
    if err != nil {
        fmt.Println("Error: ", err)
        return
    }

    uuid = fmt.Sprintf("%X-%X-%X-%X-%X", b[0:4], b[4:6], b[6:8], b[8:10], b[10:])

    return
}

C'è un'implementazione ufficiale di Google: https://github.com/google/uuid

La generazione di un UUID versione 4 funziona in questo modo:

package main

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

func main() {
    id := uuid.New()
    fmt.Println(id.String())
}

Provalo qui: https://play.golang.org/p/6YPi1djUMj9

gofrs / uuid è il sostituto di satori / go.uuid , che è il pacchetto UUID più stellato per Go . Supporta le versioni UUID 1-5 ed è conforme a RFC 4122 e DCE 1.1.

import "github.com/gofrs/uuid"

// Create a Version 4 UUID, panicking on error
u := uuid.Must(uuid.NewV4())

Dal post di Russ Cox :

Non esiste una biblioteca ufficiale. Ignorando il controllo degli errori, sembra che funzionerebbe bene:

f, _ := os.Open("/dev/urandom")
b := make([]byte, 16)
f.Read(b)
f.Close()
uuid := fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:])

Nota: nella versione originale, pre Go 1, la prima riga era:

f, _ := os.Open("/dev/urandom", os.O_RDONLY, 0)

Qui compila ed esegue, solo/dev/urandom restituisce tutti zeri nel playground. Dovrebbe funzionare bene a livello locale.

Nello stesso thread sono stati trovati altri metodi / riferimenti / pacchetti.

Come parte delle specifiche uuid, se si genera un uuid da casuale, deve contenere un "4" come 13 ° carattere e un "8", "9", "a" o "b" nel 17 ° ( fonte ).

// this makes sure that the 13th character is "4"
u[6] = (u[6] | 0x40) & 0x4F
// this makes sure that the 17th is "8", "9", "a", or "b"
u[8] = (u[8] | 0x80) & 0xBF 

Il pacchetto gorand ha un metodo UUID che restituisce un UUID versione 4 (generato casualmente) nella sua rappresentazione di stringa canonica ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx") ed è conforme a RFC 4122.

Utilizza anche il pacchetto crypto / rand per garantire la generazione più sicura crittograficamente di UUID su tutte le piattaforme supportate da Go.

import "github.com/leonelquinteros/gorand"

func main() {
    uuid, err := gorand.UUID()
    if err != nil {
        panic(err.Error())
    }

    println(uuid)
} 

Su Linux puoi leggere da /proc/sys/kernel/random/uuid:

package main

import "io/ioutil"
import "fmt"

func main() {
    u, _ := ioutil.ReadFile("/proc/sys/kernel/random/uuid")
    fmt.Println(string(u))
}

Nessuna dipendenza esterna!

$ go run uuid.go 
3ee995e3-0c96-4e30-ac1e-f7f04fd03e44

Per Windows, ho fatto di recente questo:

// +build windows

package main

import (
    "syscall"
    "unsafe"
)

var (
    modrpcrt4 = syscall.NewLazyDLL("rpcrt4.dll")
    procUuidCreate = modrpcrt4.NewProc("UuidCreate")
)

const (
    RPC_S_OK = 0
)

func NewUuid() ([]byte, error) {
    var uuid [16]byte
    rc, _, e := syscall.Syscall(procUuidCreate.Addr(), 1,
             uintptr(unsafe.Pointer(&uuid[0])), 0, 0)
    if int(rc) != RPC_S_OK {
        if e != 0 {
            return nil, error(e)
        } else {
            return nil, syscall.EINVAL
        }
    }
    return uuid[:], nil
}

Questa libreria è il nostro standard per la generazione e l'analisi di uuid:

https://github.com/pborman/uuid