Czy istnieje metoda generowania UUID za pomocą języka go

Mam kod, który wygląda następująco:

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)

Zwraca ciąg o długości 32, ale nie sądzę, że jest to poprawny identyfikator UUID. Jeśli jest to prawdziwy identyfikator UUID, dlaczego jest to identyfikator UUID i jaki jest cel kodu modyfikującego wartość u[8]i u[6].

Czy istnieje lepszy sposób generowania UUID?

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

Te linie ograniczają wartości bajtów 6 i 8 do określonego zakresu. rand.Readzwraca losowe bajty z zakresu 0-255, które nie są poprawnymi wartościami identyfikatora UUID. O ile wiem, należy to zrobić dla wszystkich wartości w wycinku.

Jeśli korzystasz z Linuksa, możesz alternatywnie zadzwonić /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)
}

Co daje:

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

Możesz generować UUID za pomocą biblioteki go-uuid . Można to zainstalować za pomocą:

go get github.com/nu7hatch/gouuid

Możesz generować losowe (wersja 4) UUID za pomocą:

import "github.com/nu7hatch/gouuid"

...

u, err := uuid.NewV4()

Zwracany UUIDtyp to 16-bajtowa tablica, dzięki czemu można łatwo pobrać wartość binarną. Zapewnia również standardową reprezentację ciągu szesnastkowego poprzez swoją String()metodę.

Wygląda również na to, że kod, który posiadasz, wygeneruje również prawidłowy identyfikator UUID wersji 4: manipulacja bitowa, którą wykonujesz na końcu, ustawia pola wersji i wariantów UUID, aby poprawnie zidentyfikować go jako wersję 4 . Ma to na celu odróżnienie losowych identyfikatorów UUID od tych generowanych przez inne algorytmy (np. UUID wersji 1 na podstawie adresu MAC i czasu).

Plik go-uuidBiblioteka nie jest zgodny z RFC4122. Bity wariantu nie są ustawione poprawnie. Członkowie społeczności podjęli kilka prób, aby to naprawić, ale żądania ściągnięcia poprawki nie są akceptowane.

Możesz generować UUID za pomocą biblioteki Go uuid, którą przepisałem na podstawie tej go-uuidbiblioteki. Istnieje kilka poprawek i ulepszeń. Można to zainstalować za pomocą:

go get github.com/twinj/uuid

Możesz generować losowe (wersja 4) UUID za pomocą:

import "github.com/twinj/uuid"

u := uuid.NewV4()

Zwrócony typ UUID jest interfejsem, a typem bazowym jest tablica.

Biblioteka generuje również identyfikatory UUID v1 i poprawnie generuje identyfikatory UUID v3 i 5. Istnieje kilka nowych metod ułatwiających drukowanie i formatowanie, a także nowe ogólne metody tworzenia identyfikatorów UUID na podstawie istniejących danych.

„crypto / rand” to wieloplatformowy pakiet do generowania losowych bajtów

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
}

Istnieje oficjalna implementacja Google: https://github.com/google/uuid

Generowanie UUID wersji 4 działa w następujący sposób:

package main

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

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

Wypróbuj tutaj: https://play.golang.org/p/6YPi1djUMj9

gofrs / uuid to zamiennik satori / go.uuid , który jest najbardziej gwiazdkowym pakietem UUID dla Go . Obsługuje UUID w wersjach 1-5 i jest zgodny z RFC 4122 i DCE 1.1.

import "github.com/gofrs/uuid"

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

Z posta Russa Coxa :

Nie ma oficjalnej biblioteki. Ignorując sprawdzanie błędów, wygląda na to, że działałoby dobrze:

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:])

Uwaga: w oryginalnej wersji Go 1 pierwsza linia była:

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

Tutaj tylko kompiluje i wykonuje/dev/urandom zwraca wszystkie zera na placu zabaw. Lokalnie powinno działać dobrze.

W tym samym wątku znajduje się kilka innych metod / odwołań / pakietów.

W ramach specyfikacji uuid, jeśli generujesz uuid z random, musi on zawierać „4” jako 13. znak i „8”, „9”, „a” lub „b” na 17. miejscu ( źródło ).

// 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 

gorand opakowanie ma UUID metody zwracającej wersja 4 (losowo wygenerowanym) uuid IN kanonicznej ciąg znaków ( „XXXXXXXXXXXX-xxxxxxxx-XXXXXXXXXXXX”) i jest zgodny z RFC 4122.

Używa również pakietu crypto / rand, aby zapewnić najbardziej kryptograficznie bezpieczne generowanie identyfikatorów UUID na wszystkich platformach obsługiwanych przez Go.

import "github.com/leonelquinteros/gorand"

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

    println(uuid)
} 

W systemie Linux można odczytać z /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))
}

Żadnych zewnętrznych zależności!

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

W przypadku systemu Windows ostatnio zrobiłem to:

// +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
}

Ta biblioteka jest naszym standardem do generowania i analizowania uuidów:

https://github.com/pborman/uuid