Jak wygenerować losowe int za pomocą pakietu "crypto/rand"?

Question

Say Chciałbym wygenerować bezpieczne losową int między 0 a 27 przy użyciu:

func Int(rand io.Reader, max *big.Int) (n *big.Int, err error) 

w pakiecie "crypto/rand".

Jak to zrobić?

Naprawdę nie rozumiem, jak to działa, dlaczego nie zwraca jednego z wbudowanych int Go zamiast wskaźnika do jakiegoś dużego. Typu wewnętrznego?

EDIT:

byłoby to uznane za wystarczająco bezpieczne tokeny?

func getToken(length int) string { 
    token := "" 
    codeAlphabet := "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 
    codeAlphabet += "abcdefghijklmnopqrstuvwxyz" 
    codeAlphabet += "" 

    for i := 0; i < length; i++ { 
     token += string(codeAlphabet[cryptoRandSecure(int64(len(codeAlphabet)))]) 
    } 
    return token 
} 

func cryptoRandSecure(max int64) int64 { 
    nBig, err := rand.Int(rand.Reader, big.NewInt(max)) 
    if err != nil { 
     log.Println(err) 
    } 
    return nBig.Int64() 
} 

func main() { 
    fmt.Println(getToken(32)) 
} 

Wyjście to będzie coś takiego:

qZDbuPwNQGrgVmZCU9A7FUWbp8eIfn0Z 

EwZVoQ5D5SEfdhiRsDfH6dU6tAovILCZ 

cOqzODVP0GwbiNBwtmqLA78rFgV9d3VT 

Answer 1

Jeśli generujesz bezpieczne tokeny dla identyfikatorów sesji, tokenów na okaziciela OAuth, CSRF lub podobnych: chcesz wygenerować token (najlepiej) 256 bitów (32 bajty) lub nie mniej niż 192 bity (24 bajty).

Token z wartościami pomiędzy (0-27) może być wymuszony brutalnie w czasie krótszym niż jedna sekunda i nie można go uznać za bezpieczny.

np.

package main 

import (
    "crypto/rand" 
    "encoding/base64" 
) 

// GenerateRandomBytes returns securely generated random bytes. 
// It will return an error if the system's secure random 
// number generator fails to function correctly, in which 
// case the caller should not continue. 
func GenerateRandomBytes(n int) ([]byte, error) { 
    b := make([]byte, n) 
    _, err := rand.Read(b) 
    // Note that err == nil only if we read len(b) bytes. 
    if err != nil { 
     return nil, err 
    } 

    return b, nil 
} 

// GenerateRandomString returns a URL-safe, base64 encoded 
// securely generated random string. 
func GenerateRandomString(s int) (string, error) { 
    b, err := GenerateRandomBytes(s) 
    return base64.URLEncoding.EncodeToString(b), err 
} 

func main() { 
    // Example: this will give us a 44 byte, base64 encoded output 
    token, err := GenerateRandomString(32) 
    if err != nil { 
     // Serve an appropriately vague error to the 
     // user, but log the details internally. 
    } 
} 

Wyjście base64 jest bezpieczny dla nagłówków HTTP, form, organów JSON itp

Jeśli potrzebujesz całkowitą może pomóc wyjaśnić przypadków użycia, ponieważ byłoby to dziwne dla systemu wymagać tokenów jako ints.

Answer 2

Oto kod roboczych:

package main 

import (
    "fmt" 
    "crypto/rand" 
    "math/big" 
) 

func main() { 
    nBig, err := rand.Int(rand.Reader, big.NewInt(27)) 
    if err != nil { 
     panic(err) 
    } 
    n := nBig.Int64() 
    fmt.Printf("Here is a random %T in [0,27) : %d\n", n, n) 
} 

---

Ale aby wygenerować losowy żeton, zrobiłbym coś takiego to:

package main 

import (
    "crypto/rand" 
    "encoding/base32" 
    "fmt" 
) 

func main() { 
    token := getToken(10) 
    fmt.Println("Here is a random token : ", token) 
} 

func getToken(length int) string { 
    randomBytes := make([]byte, 32) 
    _, err := rand.Read(randomBytes) 
    if err != nil { 
     panic(err) 
    } 
    return base32.StdEncoding.EncodeToString(randomBytes)[:length] 
} 

Answer 3

Jeśli potrzebujesz tylko małej liczby (tj. [0, 255]), można po prostu odczytać bajt z opakowania na Reader:

b := []byte{0} 
if _, err := rand.Reader.Read(b); err != nil { 
    panic(err) 
} 
n := b[0] 
fmt.Println(n) 

Playground: http://play.golang.org/p/4VO52LiEVh (przykład nie będzie działać tam, ja nie wiem, czy to działa zgodnie z przeznaczeniem lub jego błąd na plac zabaw).