move go-crypto files pre-keys merge

crypto/random.go

@@ -0,0 +1,100 @@
+package crypto
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	crand "crypto/rand"
+	"encoding/hex"
+	"io"
+	"sync"
+
+	. "github.com/tendermint/tmlibs/common"
+)
+
+var gRandInfo *randInfo
+
+func init() {
+	gRandInfo = &randInfo{}
+	gRandInfo.MixEntropy(randBytes(32)) // Init
+}
+
+// Mix additional bytes of randomness, e.g. from hardware, user-input, etc.
+// It is OK to call it multiple times.  It does not diminish security.
+func MixEntropy(seedBytes []byte) {
+	gRandInfo.MixEntropy(seedBytes)
+}
+
+// This only uses the OS's randomness
+func randBytes(numBytes int) []byte {
+	b := make([]byte, numBytes)
+	_, err := crand.Read(b)
+	if err != nil {
+		PanicCrisis(err)
+	}
+	return b
+}
+
+// This uses the OS and the Seed(s).
+func CRandBytes(numBytes int) []byte {
+	b := make([]byte, numBytes)
+	_, err := gRandInfo.Read(b)
+	if err != nil {
+		PanicCrisis(err)
+	}
+	return b
+}
+
+// RandHex(24) gives 96 bits of randomness, strong enough for most purposes.
+func CRandHex(numDigits int) string {
+	return hex.EncodeToString(CRandBytes(numDigits / 2))
+}
+
+// Returns a crand.Reader mixed with user-supplied entropy
+func CReader() io.Reader {
+	return gRandInfo
+}
+
+//--------------------------------------------------------------------------------
+
+type randInfo struct {
+	mtx          sync.Mutex
+	seedBytes    [32]byte
+	cipherAES256 cipher.Block
+	streamAES256 cipher.Stream
+	reader       io.Reader
+}
+
+// You can call this as many times as you'd like.
+// XXX TODO review
+func (ri *randInfo) MixEntropy(seedBytes []byte) {
+	ri.mtx.Lock()
+	defer ri.mtx.Unlock()
+	// Make new ri.seedBytes
+	hashBytes := Sha256(seedBytes)
+	hashBytes32 := [32]byte{}
+	copy(hashBytes32[:], hashBytes)
+	ri.seedBytes = xorBytes32(ri.seedBytes, hashBytes32)
+	// Create new cipher.Block
+	var err error
+	ri.cipherAES256, err = aes.NewCipher(ri.seedBytes[:])
+	if err != nil {
+		PanicSanity("Error creating AES256 cipher: " + err.Error())
+	}
+	// Create new stream
+	ri.streamAES256 = cipher.NewCTR(ri.cipherAES256, randBytes(aes.BlockSize))
+	// Create new reader
+	ri.reader = &cipher.StreamReader{S: ri.streamAES256, R: crand.Reader}
+}
+
+func (ri *randInfo) Read(b []byte) (n int, err error) {
+	ri.mtx.Lock()
+	defer ri.mtx.Unlock()
+	return ri.reader.Read(b)
+}
+
+func xorBytes32(bytesA [32]byte, bytesB [32]byte) (res [32]byte) {
+	for i, b := range bytesA {
+		res[i] = b ^ bytesB[i]
+	}
+	return res
+}