85 lines
2.0 KiB
Go
85 lines
2.0 KiB
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
|
|
}
|