path: root/crypto/randentropy/rand_entropy.go

package randentropy

import (
    crand "crypto/rand"
    "encoding/binary"
    "github.com/ethereum/go-ethereum/crypto/sha3"
    "io"
    "os"
    "strings"
    "time"
)

var Reader io.Reader = &randEntropy{}

type randEntropy struct {
}

func (*randEntropy) Read(bytes []byte) (n int, err error) {
    readBytes := GetEntropyMixed(len(bytes))
    copy(bytes, readBytes)
    return len(bytes), nil
}

// TODO: copied from crypto.go , move to sha3 package?
func Sha3(data []byte) []byte {
    d := sha3.NewKeccak256()
    d.Write(data)

    return d.Sum(nil)
}

// TODO: verify. this needs to be audited
// we start with crypt/rand, then XOR in additional entropy from OS
func GetEntropyMixed(n int) []byte {
    startTime := time.Now().UnixNano()
    // for each source, we take SHA3 of the source and use it as seed to math/rand
    // then read bytes from it and XOR them onto the bytes read from crypto/rand
    mainBuff := GetEntropyCSPRNG(n)
    // 1. OS entropy sources
    startTimeBytes := make([]byte, 32)
    binary.PutVarint(startTimeBytes, startTime)
    startTimeHash := Sha3(startTimeBytes)
    mixBytes(mainBuff, startTimeHash)

    pid := os.Getpid()
    pidBytes := make([]byte, 32)
    binary.PutUvarint(pidBytes, uint64(pid))
    pidHash := Sha3(pidBytes)
    mixBytes(mainBuff, pidHash)

    osEnv := os.Environ()
    osEnvBytes := []byte(strings.Join(osEnv, ""))
    osEnvHash := Sha3(osEnvBytes)
    mixBytes(mainBuff, osEnvHash)

    // not all OS have hostname in env variables
    osHostName, err := os.Hostname()
    if err != nil {
        osHostNameBytes := []byte(osHostName)
        osHostNameHash := Sha3(osHostNameBytes)
        mixBytes(mainBuff, osHostNameHash)
    }
    return mainBuff
}

func GetEntropyCSPRNG(n int) []byte {
    mainBuff := make([]byte, n)
    _, err := io.ReadFull(crand.Reader, mainBuff)
    if err != nil {
        panic("reading from crypto/rand failed: " + err.Error())
    }
    return mainBuff
}

func mixBytes(buff []byte, mixBuff []byte) []byte {
    bytesToMix := len(buff)
    if bytesToMix > 32 {
        bytesToMix = 32
    }
    for i := 0; i < bytesToMix; i++ {
        buff[i] ^= mixBuff[i]
    }
    return buff
}