go-pulse/crypto/key.go
Gustav Simonsson a1c2749380 Address pull request comments
* Simplify scrypt constants with const block
* Add key store constructors and make their types private
* Simplify key store and file namings to be less Java Enterprise™
* Change test error logging to use t.Error(err)
* Reduce number of naked returns (just like my ex-gf)
* Simplify file reading path code
2015-01-15 19:40:10 +01:00

206 lines
5.1 KiB
Go

/*
This file is part of go-ethereum
go-ethereum is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
go-ethereum is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @authors
* Gustav Simonsson <gustav.simonsson@gmail.com>
* @date 2015
*
*/
package crypto
import (
"bytes"
"code.google.com/p/go-uuid/uuid"
"crypto/ecdsa"
"crypto/elliptic"
crand "crypto/rand"
"encoding/binary"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io"
"os"
"runtime"
"strings"
"time"
)
type Key struct {
Id *uuid.UUID // Version 4 "random" for unique id not derived from key data
Flags [4]byte // RFU
// we only store privkey as pubkey/address can be derived from it
// privkey in this struct is always in plaintext
PrivateKey *ecdsa.PrivateKey
}
type PlainKeyJSON struct {
Id string
Flags string
PrivateKey string
}
type CipherJSON struct {
Salt string
IV string
CipherText string
}
type EncryptedKeyJSON struct {
Id string
Flags string
Crypto CipherJSON
}
func (k *Key) Address() []byte {
pubBytes := FromECDSAPub(&k.PrivateKey.PublicKey)
return Sha3(pubBytes)[12:]
}
func (k *Key) MarshalJSON() (j []byte, err error) {
stringStruct := PlainKeyJSON{
k.Id.String(),
hex.EncodeToString(k.Flags[:]),
hex.EncodeToString(FromECDSA(k.PrivateKey)),
}
j, err = json.Marshal(stringStruct)
return j, err
}
func (k *Key) UnmarshalJSON(j []byte) (err error) {
keyJSON := new(PlainKeyJSON)
err = json.Unmarshal(j, &keyJSON)
if err != nil {
return err
}
u := new(uuid.UUID)
*u = uuid.Parse(keyJSON.Id)
if *u == nil {
err = errors.New("UUID parsing failed")
return err
}
k.Id = u
flagsBytes, err := hex.DecodeString(keyJSON.Flags)
if err != nil {
return err
}
PrivateKeyBytes, err := hex.DecodeString(keyJSON.PrivateKey)
if err != nil {
return err
}
copy(k.Flags[:], flagsBytes[0:4])
k.PrivateKey = ToECDSA(PrivateKeyBytes)
return err
}
func NewKey() *Key {
randBytes := GetEntropyCSPRNG(32)
reader := bytes.NewReader(randBytes)
_, x, y, err := elliptic.GenerateKey(S256(), reader)
if err != nil {
panic("key generation: elliptic.GenerateKey failed: " + err.Error())
}
privateKeyMarshalled := elliptic.Marshal(S256(), x, y)
privateKeyECDSA := ToECDSA(privateKeyMarshalled)
key := new(Key)
id := uuid.NewRandom()
key.Id = &id
// flags := new([4]byte)
// key.Flags = flags
key.PrivateKey = privateKeyECDSA
return key
}
// plain crypto/rand. this is /dev/urandom on Unix-like systems.
func GetEntropyCSPRNG(n int) []byte {
mainBuff := make([]byte, n)
_, err := io.ReadFull(crand.Reader, mainBuff)
if err != nil {
panic("key generation: reading from crypto/rand failed: " + err.Error())
}
return mainBuff
}
// TODO: verify. Do not use until properly discussed.
// we start with crypt/rand, then mix in additional sources of entropy.
// These sources are from three types: OS, go runtime and ethereum client state.
func GetEntropyTinFoilHat() []byte {
startTime := time.Now().UnixNano()
// for each source, we XOR in it's SHA3 hash.
mainBuff := GetEntropyCSPRNG(32)
// 1. OS entropy sources
startTimeBytes := make([]byte, 32)
binary.PutVarint(startTimeBytes, startTime)
startTimeHash := Sha3(startTimeBytes)
mix32Byte(mainBuff, startTimeHash)
pid := os.Getpid()
pidBytes := make([]byte, 32)
binary.PutUvarint(pidBytes, uint64(pid))
pidHash := Sha3(pidBytes)
mix32Byte(mainBuff, pidHash)
osEnv := os.Environ()
osEnvBytes := []byte(strings.Join(osEnv, ""))
osEnvHash := Sha3(osEnvBytes)
mix32Byte(mainBuff, osEnvHash)
// not all OS have hostname in env variables
osHostName, err := os.Hostname()
if err != nil {
osHostNameBytes := []byte(osHostName)
osHostNameHash := Sha3(osHostNameBytes)
mix32Byte(mainBuff, osHostNameHash)
}
// 2. go runtime entropy sources
memStats := new(runtime.MemStats)
runtime.ReadMemStats(memStats)
memStatsBytes := []byte(fmt.Sprintf("%v", memStats))
memStatsHash := Sha3(memStatsBytes)
mix32Byte(mainBuff, memStatsHash)
// 3. Mix in ethereum / client state
// TODO: list of network peers structs (IP, port, etc)
// TODO: merkle patricia tree root hash for world state and tx list
// 4. Yo dawg we heard you like entropy so we'll grab some entropy from how
// long it took to grab the above entropy. And a yield, for good measure.
runtime.Gosched()
diffTime := time.Now().UnixNano() - startTime
diffTimeBytes := make([]byte, 32)
binary.PutVarint(diffTimeBytes, diffTime)
diffTimeHash := Sha3(diffTimeBytes)
mix32Byte(mainBuff, diffTimeHash)
return mainBuff
}
func mix32Byte(buff []byte, mixBuff []byte) []byte {
for i := 0; i < 32; i++ {
buff[i] ^= mixBuff[i]
}
return buff
}