Christopher Goes
7 years ago
committed by
GitHub
GitHub
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
23 changed files with 7 additions and 2044 deletions
Unified View
Diff Options
-
+6 -61Gopkg.lock
-
+0 -12Gopkg.toml
-
+1 -1Makefile
-
+0 -2amino.go
-
+0 -1encode_test.go
-
+0 -35keys/bcrypt/base64.go
-
+0 -292keys/bcrypt/bcrypt.go
-
+0 -62keys/bip39/wordcodec.go
-
+0 -15keys/bip39/wordcodec_test.go
-
+0 -83keys/hd/fundraiser_test.go
-
+0 -168keys/hd/hdpath.go
-
+0 -73keys/hd/hdpath_test.go
-
+0 -1keys/hd/test.json
-
+0 -362keys/keybase.go
-
+0 -383keys/keybase_test.go
-
+0 -12keys/keys.go
-
+0 -2keys/keys.toml
-
+0 -115keys/mintkey.go
-
+0 -142keys/types.go
-
+0 -16keys/wire.go
-
+0 -19ledger_common.go
-
+0 -124ledger_secp256k1.go
-
+0 -63ledger_test.go
+ 6
- 61
Gopkg.lock
View File
+ 0
- 12
Gopkg.toml
View File
+ 1
- 1
Makefile
View File
+ 0
- 2
amino.go
View File
+ 0
- 1
encode_test.go
View File
+ 0
- 35
keys/bcrypt/base64.go
View File
| @ -1,35 +0,0 @@ | |||||
| // Copyright 2011 The Go Authors. All rights reserved. | |||||
| // Use of this source code is governed by a BSD-style | |||||
| // license that can be found in the LICENSE file. | |||||
| package bcrypt | |||||
| import "encoding/base64" | |||||
| const alphabet = "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" | |||||
| var bcEncoding = base64.NewEncoding(alphabet) | |||||
| func base64Encode(src []byte) []byte { | |||||
| n := bcEncoding.EncodedLen(len(src)) | |||||
| dst := make([]byte, n) | |||||
| bcEncoding.Encode(dst, src) | |||||
| for dst[n-1] == '=' { | |||||
| n-- | |||||
| } | |||||
| return dst[:n] | |||||
| } | |||||
| func base64Decode(src []byte) ([]byte, error) { | |||||
| numOfEquals := 4 - (len(src) % 4) | |||||
| for i := 0; i < numOfEquals; i++ { | |||||
| src = append(src, '=') | |||||
| } | |||||
| dst := make([]byte, bcEncoding.DecodedLen(len(src))) | |||||
| n, err := bcEncoding.Decode(dst, src) | |||||
| if err != nil { | |||||
| return nil, err | |||||
| } | |||||
| return dst[:n], nil | |||||
| } | |||||
+ 0
- 292
keys/bcrypt/bcrypt.go
View File
| @ -1,292 +0,0 @@ | |||||
| package bcrypt | |||||
| // MODIFIED BY TENDERMINT TO EXPOSE NONCE | |||||
| // Copyright 2011 The Go Authors. All rights reserved. | |||||
| // Use of this source code is governed by a BSD-style | |||||
| // license that can be found in the LICENSE file. | |||||
| // Package bcrypt implements Provos and Mazières's bcrypt adaptive hashing | |||||
| // algorithm. See http://www.usenix.org/event/usenix99/provos/provos.pdf | |||||
| // The code is a port of Provos and Mazières's C implementation. | |||||
| import ( | |||||
| "crypto/subtle" | |||||
| "errors" | |||||
| "fmt" | |||||
| "strconv" | |||||
| "golang.org/x/crypto/blowfish" | |||||
| ) | |||||
| const ( | |||||
| MinCost int = 4 // the minimum allowable cost as passed in to GenerateFromPassword | |||||
| MaxCost int = 31 // the maximum allowable cost as passed in to GenerateFromPassword | |||||
| DefaultCost int = 10 // the cost that will actually be set if a cost below MinCost is passed into GenerateFromPassword | |||||
| ) | |||||
| // The error returned from CompareHashAndPassword when a password and hash do | |||||
| // not match. | |||||
| var ErrMismatchedHashAndPassword = errors.New("crypto/bcrypt: hashedPassword is not the hash of the given password") | |||||
| // The error returned from CompareHashAndPassword when a hash is too short to | |||||
| // be a bcrypt hash. | |||||
| var ErrHashTooShort = errors.New("crypto/bcrypt: hashedSecret too short to be a bcrypted password") | |||||
| // The error returned from CompareHashAndPassword when a hash was created with | |||||
| // a bcrypt algorithm newer than this implementation. | |||||
| type HashVersionTooNewError byte | |||||
| func (hv HashVersionTooNewError) Error() string { | |||||
| return fmt.Sprintf("crypto/bcrypt: bcrypt algorithm version '%c' requested is newer than current version '%c'", byte(hv), majorVersion) | |||||
| } | |||||
| // The error returned from CompareHashAndPassword when a hash starts with something other than '$' | |||||
| type InvalidHashPrefixError byte | |||||
| func (ih InvalidHashPrefixError) Error() string { | |||||
| return fmt.Sprintf("crypto/bcrypt: bcrypt hashes must start with '$', but hashedSecret started with '%c'", byte(ih)) | |||||
| } | |||||
| type InvalidCostError int | |||||
| func (ic InvalidCostError) Error() string { | |||||
| return fmt.Sprintf("crypto/bcrypt: cost %d is outside allowed range (%d,%d)", int(ic), int(MinCost), int(MaxCost)) // nolint: unconvert | |||||
| } | |||||
| const ( | |||||
| majorVersion = '2' | |||||
| minorVersion = 'a' | |||||
| maxSaltSize = 16 | |||||
| maxCryptedHashSize = 23 | |||||
| encodedSaltSize = 22 | |||||
| encodedHashSize = 31 | |||||
| minHashSize = 59 | |||||
| ) | |||||
| // magicCipherData is an IV for the 64 Blowfish encryption calls in | |||||
| // bcrypt(). It's the string "OrpheanBeholderScryDoubt" in big-endian bytes. | |||||
| var magicCipherData = []byte{ | |||||
| 0x4f, 0x72, 0x70, 0x68, | |||||
| 0x65, 0x61, 0x6e, 0x42, | |||||
| 0x65, 0x68, 0x6f, 0x6c, | |||||
| 0x64, 0x65, 0x72, 0x53, | |||||
| 0x63, 0x72, 0x79, 0x44, | |||||
| 0x6f, 0x75, 0x62, 0x74, | |||||
| } | |||||
| type hashed struct { | |||||
| hash []byte | |||||
| salt []byte | |||||
| cost int // allowed range is MinCost to MaxCost | |||||
| major byte | |||||
| minor byte | |||||
| } | |||||
| // GenerateFromPassword returns the bcrypt hash of the password at the given | |||||
| // cost. If the cost given is less than MinCost, the cost will be set to | |||||
| // DefaultCost, instead. Use CompareHashAndPassword, as defined in this package, | |||||
| // to compare the returned hashed password with its cleartext version. | |||||
| func GenerateFromPassword(salt []byte, password []byte, cost int) ([]byte, error) { | |||||
| if len(salt) != maxSaltSize { | |||||
| return nil, fmt.Errorf("salt len must be %v", maxSaltSize) | |||||
| } | |||||
| p, err := newFromPassword(salt, password, cost) | |||||
| if err != nil { | |||||
| return nil, err | |||||
| } | |||||
| return p.Hash(), nil | |||||
| } | |||||
| // CompareHashAndPassword compares a bcrypt hashed password with its possible | |||||
| // plaintext equivalent. Returns nil on success, or an error on failure. | |||||
| func CompareHashAndPassword(hashedPassword, password []byte) error { | |||||
| p, err := newFromHash(hashedPassword) | |||||
| if err != nil { | |||||
| return err | |||||
| } | |||||
| otherHash, err := bcrypt(password, p.cost, p.salt) | |||||
| if err != nil { | |||||
| return err | |||||
| } | |||||
| otherP := &hashed{otherHash, p.salt, p.cost, p.major, p.minor} | |||||
| if subtle.ConstantTimeCompare(p.Hash(), otherP.Hash()) == 1 { | |||||
| return nil | |||||
| } | |||||
| return ErrMismatchedHashAndPassword | |||||
| } | |||||
| // Cost returns the hashing cost used to create the given hashed | |||||
| // password. When, in the future, the hashing cost of a password system needs | |||||
| // to be increased in order to adjust for greater computational power, this | |||||
| // function allows one to establish which passwords need to be updated. | |||||
| func Cost(hashedPassword []byte) (int, error) { | |||||
| p, err := newFromHash(hashedPassword) | |||||
| if err != nil { | |||||
| return 0, err | |||||
| } | |||||
| return p.cost, nil | |||||
| } | |||||
| func newFromPassword(salt []byte, password []byte, cost int) (*hashed, error) { | |||||
| if cost < MinCost { | |||||
| cost = DefaultCost | |||||
| } | |||||
| p := new(hashed) | |||||
| p.major = majorVersion | |||||
| p.minor = minorVersion | |||||
| err := checkCost(cost) | |||||
| if err != nil { | |||||
| return nil, err | |||||
| } | |||||
| p.cost = cost | |||||
| p.salt = base64Encode(salt) | |||||
| hash, err := bcrypt(password, p.cost, p.salt) | |||||
| if err != nil { | |||||
| return nil, err | |||||
| } | |||||
| p.hash = hash | |||||
| return p, err | |||||
| } | |||||
| func newFromHash(hashedSecret []byte) (*hashed, error) { | |||||
| if len(hashedSecret) < minHashSize { | |||||
| return nil, ErrHashTooShort | |||||
| } | |||||
| p := new(hashed) | |||||
| n, err := p.decodeVersion(hashedSecret) | |||||
| if err != nil { | |||||
| return nil, err | |||||
| } | |||||
| hashedSecret = hashedSecret[n:] | |||||
| n, err = p.decodeCost(hashedSecret) | |||||
| if err != nil { | |||||
| return nil, err | |||||
| } | |||||
| hashedSecret = hashedSecret[n:] | |||||
| // The "+2" is here because we'll have to append at most 2 '=' to the salt | |||||
| // when base64 decoding it in expensiveBlowfishSetup(). | |||||
| p.salt = make([]byte, encodedSaltSize, encodedSaltSize+2) | |||||
| copy(p.salt, hashedSecret[:encodedSaltSize]) | |||||
| hashedSecret = hashedSecret[encodedSaltSize:] | |||||
| p.hash = make([]byte, len(hashedSecret)) | |||||
| copy(p.hash, hashedSecret) | |||||
| return p, nil | |||||
| } | |||||
| func bcrypt(password []byte, cost int, salt []byte) ([]byte, error) { | |||||
| cipherData := make([]byte, len(magicCipherData)) | |||||
| copy(cipherData, magicCipherData) | |||||
| c, err := expensiveBlowfishSetup(password, uint32(cost), salt) | |||||
| if err != nil { | |||||
| return nil, err | |||||
| } | |||||
| for i := 0; i < 24; i += 8 { | |||||
| for j := 0; j < 64; j++ { | |||||
| c.Encrypt(cipherData[i:i+8], cipherData[i:i+8]) | |||||
| } | |||||
| } | |||||
| // Bug compatibility with C bcrypt implementations. We only encode 23 of | |||||
| // the 24 bytes encrypted. | |||||
| hsh := base64Encode(cipherData[:maxCryptedHashSize]) | |||||
| return hsh, nil | |||||
| } | |||||
| func expensiveBlowfishSetup(key []byte, cost uint32, salt []byte) (*blowfish.Cipher, error) { | |||||
| csalt, err := base64Decode(salt) | |||||
| if err != nil { | |||||
| return nil, err | |||||
| } | |||||
| // Bug compatibility with C bcrypt implementations. They use the trailing | |||||
| // NULL in the key string during expansion. | |||||
| ckey := append(key, 0) | |||||
| c, err := blowfish.NewSaltedCipher(ckey, csalt) | |||||
| if err != nil { | |||||
| return nil, err | |||||
| } | |||||
| var i, rounds uint64 | |||||
| rounds = 1 << cost | |||||
| for i = 0; i < rounds; i++ { | |||||
| blowfish.ExpandKey(ckey, c) | |||||
| blowfish.ExpandKey(csalt, c) | |||||
| } | |||||
| return c, nil | |||||
| } | |||||
| func (p *hashed) Hash() []byte { | |||||
| arr := make([]byte, 60) | |||||
| arr[0] = '$' | |||||
| arr[1] = p.major | |||||
| n := 2 | |||||
| if p.minor != 0 { | |||||
| arr[2] = p.minor | |||||
| n = 3 | |||||
| } | |||||
| arr[n] = '$' | |||||
| n += 1 | |||||
| copy(arr[n:], []byte(fmt.Sprintf("%02d", p.cost))) | |||||
| n += 2 | |||||
| arr[n] = '$' | |||||
| n += 1 | |||||
| copy(arr[n:], p.salt) | |||||
| n += encodedSaltSize | |||||
| copy(arr[n:], p.hash) | |||||
| n += encodedHashSize | |||||
| return arr[:n] | |||||
| } | |||||
| func (p *hashed) decodeVersion(sbytes []byte) (int, error) { | |||||
| if sbytes[0] != '$' { | |||||
| return -1, InvalidHashPrefixError(sbytes[0]) | |||||
| } | |||||
| if sbytes[1] > majorVersion { | |||||
| return -1, HashVersionTooNewError(sbytes[1]) | |||||
| } | |||||
| p.major = sbytes[1] | |||||
| n := 3 | |||||
| if sbytes[2] != '$' { | |||||
| p.minor = sbytes[2] | |||||
| n++ | |||||
| } | |||||
| return n, nil | |||||
| } | |||||
| // sbytes should begin where decodeVersion left off. | |||||
| func (p *hashed) decodeCost(sbytes []byte) (int, error) { | |||||
| cost, err := strconv.Atoi(string(sbytes[0:2])) | |||||
| if err != nil { | |||||
| return -1, err | |||||
| } | |||||
| err = checkCost(cost) | |||||
| if err != nil { | |||||
| return -1, err | |||||
| } | |||||
| p.cost = cost | |||||
| return 3, nil | |||||
| } | |||||
| func (p *hashed) String() string { | |||||
| return fmt.Sprintf("&{hash: %#v, salt: %#v, cost: %d, major: %c, minor: %c}", string(p.hash), p.salt, p.cost, p.major, p.minor) | |||||
| } | |||||
| func checkCost(cost int) error { | |||||
| if cost < MinCost || cost > MaxCost { | |||||
| return InvalidCostError(cost) | |||||
| } | |||||
| return nil | |||||
| } | |||||
+ 0
- 62
keys/bip39/wordcodec.go
View File
| @ -1,62 +0,0 @@ | |||||
| package bip39 | |||||
| import ( | |||||
| "strings" | |||||
| "github.com/bartekn/go-bip39" | |||||
| ) | |||||
| // ValidSentenceLen defines the mnemonic sentence lengths supported by this BIP 39 library. | |||||
| type ValidSentenceLen uint8 | |||||
| const ( | |||||
| // FundRaiser is the sentence length used during the cosmos fundraiser (12 words). | |||||
| FundRaiser ValidSentenceLen = 12 | |||||
| // FreshKey is the sentence length used for newly created keys (24 words). | |||||
| FreshKey ValidSentenceLen = 24 | |||||
| ) | |||||
| // NewMnemonic will return a string consisting of the mnemonic words for | |||||
| // the given sentence length. | |||||
| func NewMnemonic(len ValidSentenceLen) (words []string, err error) { | |||||
| // len = (ENT + checksum) / 11 | |||||
| var ENT int | |||||
| switch len { | |||||
| case FundRaiser: | |||||
| ENT = 128 | |||||
| case FreshKey: | |||||
| ENT = 256 | |||||
| } | |||||
| var entropy []byte | |||||
| entropy, err = bip39.NewEntropy(ENT) | |||||
| if err != nil { | |||||
| return | |||||
| } | |||||
| var mnemonic string | |||||
| mnemonic, err = bip39.NewMnemonic(entropy) | |||||
| if err != nil { | |||||
| return | |||||
| } | |||||
| words = strings.Split(mnemonic, " ") | |||||
| return | |||||
| } | |||||
| // MnemonicToSeed creates a BIP 39 seed from the passed mnemonic (with an empty BIP 39 password). | |||||
| // This method does not validate the mnemonics checksum. | |||||
| func MnemonicToSeed(mne string) (seed []byte) { | |||||
| // we do not checksum here... | |||||
| seed = bip39.NewSeed(mne, "") | |||||
| return | |||||
| } | |||||
| // MnemonicToSeedWithErrChecking returns the same seed as MnemonicToSeed. | |||||
| // It creates a BIP 39 seed from the passed mnemonic (with an empty BIP 39 password). | |||||
| // | |||||
| // Different from MnemonicToSeed it validates the checksum. | |||||
| // For details on the checksum see the BIP 39 spec. | |||||
| func MnemonicToSeedWithErrChecking(mne string) (seed []byte, err error) { | |||||
| seed, err = bip39.NewSeedWithErrorChecking(mne, "") | |||||
| return | |||||
| } | |||||
+ 0
- 15
keys/bip39/wordcodec_test.go
View File
| @ -1,15 +0,0 @@ | |||||
| package bip39 | |||||
| import ( | |||||
| "testing" | |||||
| "github.com/stretchr/testify/assert" | |||||
| ) | |||||
| func TestWordCodec_NewMnemonic(t *testing.T) { | |||||
| _, err := NewMnemonic(FundRaiser) | |||||
| assert.NoError(t, err, "unexpected error generating fundraiser mnemonic") | |||||
| _, err = NewMnemonic(FreshKey) | |||||
| assert.NoError(t, err, "unexpected error generating new 24-word mnemonic") | |||||
| } | |||||
+ 0
- 83
keys/hd/fundraiser_test.go
View File
| @ -1,83 +0,0 @@ | |||||
| package hd | |||||
| import ( | |||||
| "encoding/hex" | |||||
| "encoding/json" | |||||
| "fmt" | |||||
| "io/ioutil" | |||||
| "testing" | |||||
| "github.com/stretchr/testify/assert" | |||||
| "github.com/tyler-smith/go-bip39" | |||||
| "github.com/tendermint/go-crypto" | |||||
| ) | |||||
| type addrData struct { | |||||
| Mnemonic string | |||||
| Master string | |||||
| Seed string | |||||
| Priv string | |||||
| Pub string | |||||
| Addr string | |||||
| } | |||||
| func initFundraiserTestVectors(t *testing.T) []addrData { | |||||
| // NOTE: atom fundraiser address | |||||
| // var hdPath string = "m/44'/118'/0'/0/0" | |||||
| var hdToAddrTable []addrData | |||||
| b, err := ioutil.ReadFile("test.json") | |||||
| if err != nil { | |||||
| t.Fatalf("could not read fundraiser test vector file (test.json): %s", err) | |||||
| } | |||||
| err = json.Unmarshal(b, &hdToAddrTable) | |||||
| if err != nil { | |||||
| t.Fatalf("could not decode test vectors (test.json): %s", err) | |||||
| } | |||||
| return hdToAddrTable | |||||
| } | |||||
| func TestFundraiserCompatibility(t *testing.T) { | |||||
| hdToAddrTable := initFundraiserTestVectors(t) | |||||
| for i, d := range hdToAddrTable { | |||||
| privB, _ := hex.DecodeString(d.Priv) | |||||
| pubB, _ := hex.DecodeString(d.Pub) | |||||
| addrB, _ := hex.DecodeString(d.Addr) | |||||
| seedB, _ := hex.DecodeString(d.Seed) | |||||
| masterB, _ := hex.DecodeString(d.Master) | |||||
| seed := bip39.NewSeed(d.Mnemonic, "") | |||||
| t.Log("================================") | |||||
| t.Logf("ROUND: %d MNEMONIC: %s", i, d.Mnemonic) | |||||
| master, ch := ComputeMastersFromSeed(seed) | |||||
| priv, err := DerivePrivateKeyForPath(master, ch, "44'/118'/0'/0/0") | |||||
| assert.NoError(t, err) | |||||
| pub := crypto.PrivKeySecp256k1(priv).PubKey() | |||||
| t.Log("\tNODEJS GOLANG\n") | |||||
| t.Logf("SEED \t%X %X\n", seedB, seed) | |||||
| t.Logf("MSTR \t%X %X\n", masterB, master) | |||||
| t.Logf("PRIV \t%X %X\n", privB, priv) | |||||
| t.Logf("PUB \t%X %X\n", pubB, pub) | |||||
| assert.Equal(t, seedB, seed) | |||||
| assert.Equal(t, master[:], masterB, fmt.Sprintf("Expected masters to match for %d", i)) | |||||
| assert.Equal(t, priv[:], privB, "Expected priv keys to match") | |||||
| var pubBFixed [33]byte | |||||
| copy(pubBFixed[:], pubB) | |||||
| assert.Equal(t, pub, crypto.PubKeySecp256k1(pubBFixed), fmt.Sprintf("Expected pub keys to match for %d", i)) | |||||
| addr := pub.Address() | |||||
| t.Logf("ADDR \t%X %X\n", addrB, addr) | |||||
| assert.Equal(t, addr, crypto.Address(addrB), fmt.Sprintf("Expected addresses to match %d", i)) | |||||
| } | |||||
| } | |||||
+ 0
- 168
keys/hd/hdpath.go
View File
| @ -1,168 +0,0 @@ | |||||
| // Package hd provides basic functionality Hierarchical Deterministic Wallets. | |||||
| // | |||||
| // The user must understand the overall concept of the BIP 32 and the BIP 44 specs: | |||||
| // https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki | |||||
| // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki | |||||
| // | |||||
| // In combination with the bip39 package in go-crypto this package provides the functionality for deriving keys using a | |||||
| // BIP 44 HD path, or, more general, by passing a BIP 32 path. | |||||
| // | |||||
| // In particular, this package (together with bip39) provides all necessary functionality to derive keys from | |||||
| // mnemonics generated during the cosmos fundraiser. | |||||
| package hd | |||||
| import ( | |||||
| "crypto/hmac" | |||||
| "crypto/sha512" | |||||
| "encoding/binary" | |||||
| "errors" | |||||
| "fmt" | |||||
| "math/big" | |||||
| "strconv" | |||||
| "strings" | |||||
| "github.com/btcsuite/btcd/btcec" | |||||
| "github.com/tendermint/go-crypto" | |||||
| ) | |||||
| // BIP44Prefix is the parts of the BIP32 HD path that are fixed by what we used during the fundraiser. | |||||
| const ( | |||||
| BIP44Prefix = "44'/118'/" | |||||
| FullFundraiserPath = BIP44Prefix + "0'/0/0" | |||||
| ) | |||||
| // BIP44Params wraps BIP 44 params (5 level BIP 32 path). | |||||
| // To receive a canonical string representation ala | |||||
| // m / purpose' / coin_type' / account' / change / address_index | |||||
| // call String() on a BIP44Params instance. | |||||
| type BIP44Params struct { | |||||
| purpose uint32 | |||||
| coinType uint32 | |||||
| account uint32 | |||||
| change bool | |||||
| addressIdx uint32 | |||||
| } | |||||
| // NewParams creates a BIP 44 parameter object from the params: | |||||
| // m / purpose' / coin_type' / account' / change / address_index | |||||
| func NewParams(purpose, coinType, account uint32, change bool, addressIdx uint32) *BIP44Params { | |||||
| return &BIP44Params{ | |||||
| purpose: purpose, | |||||
| coinType: coinType, | |||||
| account: account, | |||||
| change: change, | |||||
| addressIdx: addressIdx, | |||||
| } | |||||
| } | |||||
| // NewFundraiserParams creates a BIP 44 parameter object from the params: | |||||
| // m / 44' / 118' / account' / 0 / address_index | |||||
| // The fixed parameters (purpose', coin_type', and change) are determined by what was used in the fundraiser. | |||||
| func NewFundraiserParams(account uint32, addressIdx uint32) *BIP44Params { | |||||
| return NewParams(44, 118, account, false, addressIdx) | |||||
| } | |||||
| func (p BIP44Params) String() string { | |||||
| var changeStr string | |||||
| if p.change { | |||||
| changeStr = "1" | |||||
| } else { | |||||
| changeStr = "0" | |||||
| } | |||||
| // m / purpose' / coin_type' / account' / change / address_index | |||||
| return fmt.Sprintf("%d'/%d'/%d'/%s/%d", | |||||
| p.purpose, | |||||
| p.coinType, | |||||
| p.account, | |||||
| changeStr, | |||||
| p.addressIdx) | |||||
| } | |||||
| // ComputeMastersFromSeed returns the master public key, master secret, and chain code in hex. | |||||
| func ComputeMastersFromSeed(seed []byte) (secret [32]byte, chainCode [32]byte) { | |||||
| masterSecret := []byte("Bitcoin seed") | |||||
| secret, chainCode = i64(masterSecret, seed) | |||||
| return | |||||
| } | |||||
| // DerivePrivateKeyForPath derives the private key by following the BIP 32/44 path from privKeyBytes, | |||||
| // using the given chainCode. | |||||
| func DerivePrivateKeyForPath(privKeyBytes [32]byte, chainCode [32]byte, path string) ([32]byte, error) { | |||||
| data := privKeyBytes | |||||
| parts := strings.Split(path, "/") | |||||
| for _, part := range parts { | |||||
| // do we have an apostrophe? | |||||
| harden := part[len(part)-1:] == "'" | |||||
| // harden == private derivation, else public derivation: | |||||
| if harden { | |||||
| part = part[:len(part)-1] | |||||
| } | |||||
| idx, err := strconv.Atoi(part) | |||||
| if err != nil { | |||||
| return [32]byte{}, fmt.Errorf("invalid BIP 32 path: %s", err) | |||||
| } | |||||
| if idx < 0 { | |||||
| return [32]byte{}, errors.New("invalid BIP 32 path: index negative ot too large") | |||||
| } | |||||
| data, chainCode = derivePrivateKey(data, chainCode, uint32(idx), harden) | |||||
| } | |||||
| var derivedKey [32]byte | |||||
| n := copy(derivedKey[:], data[:]) | |||||
| if n != 32 || len(data) != 32 { | |||||
| return [32]byte{}, fmt.Errorf("expected a (secp256k1) key of length 32, got length: %v", len(data)) | |||||
| } | |||||
| return derivedKey, nil | |||||
| } | |||||
| // derivePrivateKey derives the private key with index and chainCode. | |||||
| // If harden is true, the derivation is 'hardened'. | |||||
| // It returns the new private key and new chain code. | |||||
| // For more information on hardened keys see: | |||||
| // - https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki | |||||
| func derivePrivateKey(privKeyBytes [32]byte, chainCode [32]byte, index uint32, harden bool) ([32]byte, [32]byte) { | |||||
| var data []byte | |||||
| if harden { | |||||
| index = index | 0x80000000 | |||||
| data = append([]byte{byte(0)}, privKeyBytes[:]...) | |||||
| } else { | |||||
| // this can't return an error: | |||||
| pubkey := crypto.PrivKeySecp256k1(privKeyBytes).PubKey() | |||||
| public := pubkey.(crypto.PubKeySecp256k1) | |||||
| data = public[:] | |||||
| } | |||||
| data = append(data, uint32ToBytes(index)...) | |||||
| data2, chainCode2 := i64(chainCode[:], data) | |||||
| x := addScalars(privKeyBytes[:], data2[:]) | |||||
| return x, chainCode2 | |||||
| } | |||||
| // modular big endian addition | |||||
| func addScalars(a []byte, b []byte) [32]byte { | |||||
| aInt := new(big.Int).SetBytes(a) | |||||
| bInt := new(big.Int).SetBytes(b) | |||||
| sInt := new(big.Int).Add(aInt, bInt) | |||||
| x := sInt.Mod(sInt, btcec.S256().N).Bytes() | |||||
| x2 := [32]byte{} | |||||
| copy(x2[32-len(x):], x) | |||||
| return x2 | |||||
| } | |||||
| func uint32ToBytes(i uint32) []byte { | |||||
| b := [4]byte{} | |||||
| binary.BigEndian.PutUint32(b[:], i) | |||||
| return b[:] | |||||
| } | |||||
| // i64 returns the two halfs of the SHA512 HMAC of key and data. | |||||
| func i64(key []byte, data []byte) (IL [32]byte, IR [32]byte) { | |||||
| mac := hmac.New(sha512.New, key) | |||||
| // sha512 does not err | |||||
| _, _ = mac.Write(data) | |||||
| I := mac.Sum(nil) | |||||
| copy(IL[:], I[:32]) | |||||
| copy(IR[:], I[32:]) | |||||
| return | |||||
| } | |||||
+ 0
- 73
keys/hd/hdpath_test.go
View File
| @ -1,73 +0,0 @@ | |||||
| package hd | |||||
| import ( | |||||
| "encoding/hex" | |||||
| "fmt" | |||||
| "github.com/tendermint/go-crypto/keys/bip39" | |||||
| ) | |||||
| func ExampleStringifyPathParams() { | |||||
| path := NewParams(44, 0, 0, false, 0) | |||||
| fmt.Println(path.String()) | |||||
| // Output: 44'/0'/0'/0/0 | |||||
| } | |||||
| func ExampleSomeBIP32TestVecs() { | |||||
| seed := bip39.MnemonicToSeed("barrel original fuel morning among eternal " + | |||||
| "filter ball stove pluck matrix mechanic") | |||||
| master, ch := ComputeMastersFromSeed(seed) | |||||
| fmt.Println("keys from fundraiser test-vector (cosmos, bitcoin, ether)") | |||||
| fmt.Println() | |||||
| // cosmos | |||||
| priv, _ := DerivePrivateKeyForPath(master, ch, FullFundraiserPath) | |||||
| fmt.Println(hex.EncodeToString(priv[:])) | |||||
| // bitcoin | |||||
| priv, _ = DerivePrivateKeyForPath(master, ch, "44'/0'/0'/0/0") | |||||
| fmt.Println(hex.EncodeToString(priv[:])) | |||||
| // ether | |||||
| priv, _ = DerivePrivateKeyForPath(master, ch, "44'/60'/0'/0/0") | |||||
| fmt.Println(hex.EncodeToString(priv[:])) | |||||
| fmt.Println() | |||||
| fmt.Println("keys generated via https://coinomi.com/recovery-phrase-tool.html") | |||||
| fmt.Println() | |||||
| seed = bip39.MnemonicToSeed( | |||||
| "advice process birth april short trust crater change bacon monkey medal garment " + | |||||
| "gorilla ranch hour rival razor call lunar mention taste vacant woman sister") | |||||
| master, ch = ComputeMastersFromSeed(seed) | |||||
| priv, _ = DerivePrivateKeyForPath(master, ch, "44'/1'/1'/0/4") | |||||
| fmt.Println(hex.EncodeToString(priv[:])) | |||||
| seed = bip39.MnemonicToSeed("idea naive region square margin day captain habit " + | |||||
| "gun second farm pact pulse someone armed") | |||||
| master, ch = ComputeMastersFromSeed(seed) | |||||
| priv, _ = DerivePrivateKeyForPath(master, ch, "44'/0'/0'/0/420") | |||||
| fmt.Println(hex.EncodeToString(priv[:])) | |||||
| fmt.Println() | |||||
| fmt.Println("BIP 32 example") | |||||
| fmt.Println() | |||||
| // bip32 path: m/0/7 | |||||
| seed = bip39.MnemonicToSeed("monitor flock loyal sick object grunt duty ride develop assault harsh history") | |||||
| master, ch = ComputeMastersFromSeed(seed) | |||||
| priv, _ = DerivePrivateKeyForPath(master, ch, "0/7") | |||||
| fmt.Println(hex.EncodeToString(priv[:])) | |||||
| // Output: keys from fundraiser test-vector (cosmos, bitcoin, ether) | |||||
| // | |||||
| // bfcb217c058d8bbafd5e186eae936106ca3e943889b0b4a093ae13822fd3170c | |||||
| // e77c3de76965ad89997451de97b95bb65ede23a6bf185a55d80363d92ee37c3d | |||||
| // 7fc4d8a8146dea344ba04c593517d3f377fa6cded36cd55aee0a0bb968e651bc | |||||
| // | |||||
| // keys generated via https://coinomi.com/recovery-phrase-tool.html | |||||
| // | |||||
| // a61f10c5fecf40c084c94fa54273b6f5d7989386be4a37669e6d6f7b0169c163 | |||||
| // 32c4599843de3ef161a629a461d12c60b009b676c35050be5f7ded3a3b23501f | |||||
| // | |||||
| // BIP 32 example | |||||
| // | |||||
| // c4c11d8c03625515905d7e89d25dfc66126fbc629ecca6db489a1a72fc4bda78 | |||||
| } | |||||
+ 0
- 1
keys/hd/test.json
File diff suppressed because it is too large
View File
+ 0
- 362
keys/keybase.go
View File
| @ -1,362 +0,0 @@ | |||||
| package keys | |||||
| import ( | |||||
| "bufio" | |||||
| "fmt" | |||||
| "os" | |||||
| "strings" | |||||
| "github.com/pkg/errors" | |||||
| "github.com/tendermint/go-crypto" | |||||
| "github.com/tendermint/go-crypto/keys/bip39" | |||||
| "github.com/tendermint/go-crypto/keys/hd" | |||||
| dbm "github.com/tendermint/tmlibs/db" | |||||
| ) | |||||
| var _ Keybase = dbKeybase{} | |||||
| // Language is a language to create the BIP 39 mnemonic in. | |||||
| // Currently, only english is supported though. | |||||
| // Find a list of all supported languages in the BIP 39 spec (word lists). | |||||
| type Language int | |||||
| const ( | |||||
| // English is the default language to create a mnemonic. | |||||
| // It is the only supported language by this package. | |||||
| English Language = iota + 1 | |||||
| // Japanese is currently not supported. | |||||
| Japanese | |||||
| // Korean is currently not supported. | |||||
| Korean | |||||
| // Spanish is currently not supported. | |||||
| Spanish | |||||
| // ChineseSimplified is currently not supported. | |||||
| ChineseSimplified | |||||
| // ChineseTraditional is currently not supported. | |||||
| ChineseTraditional | |||||
| // French is currently not supported. | |||||
| French | |||||
| // Italian is currently not supported. | |||||
| Italian | |||||
| ) | |||||
| var ( | |||||
| // ErrUnsupportedSigningAlgo is raised when the caller tries to use a different signing scheme than secp256k1. | |||||
| ErrUnsupportedSigningAlgo = errors.New("unsupported signing algo: only secp256k1 is supported") | |||||
| // ErrUnsupportedLanguage is raised when the caller tries to use a different language than english for creating | |||||
| // a mnemonic sentence. | |||||
| ErrUnsupportedLanguage = errors.New("unsupported language: only english is supported") | |||||
| ) | |||||
| // dbKeybase combines encryption and storage implementation to provide | |||||
| // a full-featured key manager | |||||
| type dbKeybase struct { | |||||
| db dbm.DB | |||||
| } | |||||
| // New creates a new keybase instance using the passed DB for reading and writing keys. | |||||
| func New(db dbm.DB) Keybase { | |||||
| return dbKeybase{ | |||||
| db: db, | |||||
| } | |||||
| } | |||||
| // CreateMnemonic generates a new key and persists it to storage, encrypted | |||||
| // using the provided password. | |||||
| // It returns the generated mnemonic and the key Info. | |||||
| // It returns an error if it fails to | |||||
| // generate a key for the given algo type, or if another key is | |||||
| // already stored under the same name. | |||||
| func (kb dbKeybase) CreateMnemonic(name string, language Language, passwd string, algo SigningAlgo) (info Info, mnemonic string, err error) { | |||||
| if language != English { | |||||
| return nil, "", ErrUnsupportedLanguage | |||||
| } | |||||
| if algo != Secp256k1 { | |||||
| err = ErrUnsupportedSigningAlgo | |||||
| return | |||||
| } | |||||
| // default number of words (24): | |||||
| mnemonicS, err := bip39.NewMnemonic(bip39.FreshKey) | |||||
| if err != nil { | |||||
| return | |||||
| } | |||||
| mnemonic = strings.Join(mnemonicS, " ") | |||||
| seed := bip39.MnemonicToSeed(mnemonic) | |||||
| info, err = kb.persistDerivedKey(seed, passwd, name, hd.FullFundraiserPath) | |||||
| return | |||||
| } | |||||
| // CreateFundraiserKey converts a mnemonic to a private key and persists it, | |||||
| // encrypted with the given password. | |||||
| // TODO(ismail) | |||||
| func (kb dbKeybase) CreateFundraiserKey(name, mnemonic, passwd string) (info Info, err error) { | |||||
| words := strings.Split(mnemonic, " ") | |||||
| if len(words) != 12 { | |||||
| err = fmt.Errorf("recovering only works with 12 word (fundraiser) mnemonics, got: %v words", len(words)) | |||||
| return | |||||
| } | |||||
| seed, err := bip39.MnemonicToSeedWithErrChecking(mnemonic) | |||||
| if err != nil { | |||||
| return | |||||
| } | |||||
| info, err = kb.persistDerivedKey(seed, passwd, name, hd.FullFundraiserPath) | |||||
| return | |||||
| } | |||||
| func (kb dbKeybase) Derive(name, mnemonic, passwd string, params hd.BIP44Params) (info Info, err error) { | |||||
| seed, err := bip39.MnemonicToSeedWithErrChecking(mnemonic) | |||||
| if err != nil { | |||||
| return | |||||
| } | |||||
| info, err = kb.persistDerivedKey(seed, passwd, name, params.String()) | |||||
| return | |||||
| } | |||||
| // CreateLedger creates a new locally-stored reference to a Ledger keypair | |||||
| // It returns the created key info and an error if the Ledger could not be queried | |||||
| func (kb dbKeybase) CreateLedger(name string, path crypto.DerivationPath, algo SigningAlgo) (Info, error) { | |||||
| if algo != Secp256k1 { | |||||
| return nil, ErrUnsupportedSigningAlgo | |||||
| } | |||||
| priv, err := crypto.NewPrivKeyLedgerSecp256k1(path) | |||||
| if err != nil { | |||||
| return nil, err | |||||
| } | |||||
| pub := priv.PubKey() | |||||
| return kb.writeLedgerKey(pub, path, name), nil | |||||
| } | |||||
| // CreateOffline creates a new reference to an offline keypair | |||||
| // It returns the created key info | |||||
| func (kb dbKeybase) CreateOffline(name string, pub crypto.PubKey) (Info, error) { | |||||
| return kb.writeOfflineKey(pub, name), nil | |||||
| } | |||||
| func (kb *dbKeybase) persistDerivedKey(seed []byte, passwd, name, fullHdPath string) (info Info, err error) { | |||||
| // create master key and derive first key: | |||||
| masterPriv, ch := hd.ComputeMastersFromSeed(seed) | |||||
| derivedPriv, err := hd.DerivePrivateKeyForPath(masterPriv, ch, fullHdPath) | |||||
| if err != nil { | |||||
| return | |||||
| } | |||||
| // if we have a password, use it to encrypt the private key and store it | |||||
| // else store the public key only | |||||
| if passwd != "" { | |||||
| info = kb.writeLocalKey(crypto.PrivKeySecp256k1(derivedPriv), name, passwd) | |||||
| } else { | |||||
| pubk := crypto.PrivKeySecp256k1(derivedPriv).PubKey() | |||||
| info = kb.writeOfflineKey(pubk, name) | |||||
| } | |||||
| return | |||||
| } | |||||
| // List returns the keys from storage in alphabetical order. | |||||
| func (kb dbKeybase) List() ([]Info, error) { | |||||
| var res []Info | |||||
| iter := kb.db.Iterator(nil, nil) | |||||
| defer iter.Close() | |||||
| for ; iter.Valid(); iter.Next() { | |||||
| info, err := readInfo(iter.Value()) | |||||
| if err != nil { | |||||
| return nil, err | |||||
| } | |||||
| res = append(res, info) | |||||
| } | |||||
| return res, nil | |||||
| } | |||||
| // Get returns the public information about one key. | |||||
| func (kb dbKeybase) Get(name string) (Info, error) { | |||||
| bs := kb.db.Get(infoKey(name)) | |||||
| return readInfo(bs) | |||||
| } | |||||
| // Sign signs the msg with the named key. | |||||
| // It returns an error if the key doesn't exist or the decryption fails. | |||||
| func (kb dbKeybase) Sign(name, passphrase string, msg []byte) (sig crypto.Signature, pub crypto.PubKey, err error) { | |||||
| info, err := kb.Get(name) | |||||
| if err != nil { | |||||
| return | |||||
| } | |||||
| var priv crypto.PrivKey | |||||
| switch info.(type) { | |||||
| case localInfo: | |||||
| linfo := info.(localInfo) | |||||
| if linfo.PrivKeyArmor == "" { | |||||
| err = fmt.Errorf("private key not available") | |||||
| return | |||||
| } | |||||
| priv, err = unarmorDecryptPrivKey(linfo.PrivKeyArmor, passphrase) | |||||
| if err != nil { | |||||
| return nil, nil, err | |||||
| } | |||||
| case ledgerInfo: | |||||
| linfo := info.(ledgerInfo) | |||||
| priv, err = crypto.NewPrivKeyLedgerSecp256k1(linfo.Path) | |||||
| if err != nil { | |||||
| return | |||||
| } | |||||
| case offlineInfo: | |||||
| linfo := info.(offlineInfo) | |||||
| fmt.Printf("Bytes to sign:\n%s", msg) | |||||
| buf := bufio.NewReader(os.Stdin) | |||||
| fmt.Printf("\nEnter Amino-encoded signature:\n") | |||||
| // Will block until user inputs the signature | |||||
| signed, err := buf.ReadString('\n') | |||||
| if err != nil { | |||||
| return nil, nil, err | |||||
| } | |||||
| cdc.MustUnmarshalBinary([]byte(signed), sig) | |||||
| return sig, linfo.GetPubKey(), nil | |||||
| } | |||||
| sig, err = priv.Sign(msg) | |||||
| if err != nil { | |||||
| return nil, nil, err | |||||
| } | |||||
| pub = priv.PubKey() | |||||
| return sig, pub, nil | |||||
| } | |||||
| func (kb dbKeybase) Export(name string) (armor string, err error) { | |||||
| bz := kb.db.Get(infoKey(name)) | |||||
| if bz == nil { | |||||
| return "", fmt.Errorf("no key to export with name %s", name) | |||||
| } | |||||
| return armorInfoBytes(bz), nil | |||||
| } | |||||
| // ExportPubKey returns public keys in ASCII armored format. | |||||
| // Retrieve a Info object by its name and return the public key in | |||||
| // a portable format. | |||||
| func (kb dbKeybase) ExportPubKey(name string) (armor string, err error) { | |||||
| bz := kb.db.Get(infoKey(name)) | |||||
| if bz == nil { | |||||
| return "", fmt.Errorf("no key to export with name %s", name) | |||||
| } | |||||
| info, err := readInfo(bz) | |||||
| if err != nil { | |||||
| return | |||||
| } | |||||
| return armorPubKeyBytes(info.GetPubKey().Bytes()), nil | |||||
| } | |||||
| func (kb dbKeybase) Import(name string, armor string) (err error) { | |||||
| bz := kb.db.Get(infoKey(name)) | |||||
| if len(bz) > 0 { | |||||
| return errors.New("Cannot overwrite data for name " + name) | |||||
| } | |||||
| infoBytes, err := unarmorInfoBytes(armor) | |||||
| if err != nil { | |||||
| return | |||||
| } | |||||
| kb.db.Set(infoKey(name), infoBytes) | |||||
| return nil | |||||
| } | |||||
| // ImportPubKey imports ASCII-armored public keys. | |||||
| // Store a new Info object holding a public key only, i.e. it will | |||||
| // not be possible to sign with it as it lacks the secret key. | |||||
| func (kb dbKeybase) ImportPubKey(name string, armor string) (err error) { | |||||
| bz := kb.db.Get(infoKey(name)) | |||||
| if len(bz) > 0 { | |||||
| return errors.New("Cannot overwrite data for name " + name) | |||||
| } | |||||
| pubBytes, err := unarmorPubKeyBytes(armor) | |||||
| if err != nil { | |||||
| return | |||||
| } | |||||
| pubKey, err := crypto.PubKeyFromBytes(pubBytes) | |||||
| if err != nil { | |||||
| return | |||||
| } | |||||
| kb.writeOfflineKey(pubKey, name) | |||||
| return | |||||
| } | |||||
| // Delete removes key forever, but we must present the | |||||
| // proper passphrase before deleting it (for security). | |||||
| // A passphrase of 'yes' is used to delete stored | |||||
| // references to offline and Ledger / HW wallet keys | |||||
| func (kb dbKeybase) Delete(name, passphrase string) error { | |||||
| // verify we have the proper password before deleting | |||||
| info, err := kb.Get(name) | |||||
| if err != nil { | |||||
| return err | |||||
| } | |||||
| switch info.(type) { | |||||
| case localInfo: | |||||
| linfo := info.(localInfo) | |||||
| _, err = unarmorDecryptPrivKey(linfo.PrivKeyArmor, passphrase) | |||||
| if err != nil { | |||||
| return err | |||||
| } | |||||
| kb.db.DeleteSync(infoKey(name)) | |||||
| return nil | |||||
| case ledgerInfo: | |||||
| case offlineInfo: | |||||
| if passphrase != "yes" { | |||||
| return fmt.Errorf("enter exactly 'yes' to delete the key") | |||||
| } | |||||
| kb.db.DeleteSync(infoKey(name)) | |||||
| return nil | |||||
| } | |||||
| return nil | |||||
| } | |||||
| // Update changes the passphrase with which an already stored key is | |||||
| // encrypted. | |||||
| // | |||||
| // oldpass must be the current passphrase used for encryption, | |||||
| // newpass will be the only valid passphrase from this time forward. | |||||
| func (kb dbKeybase) Update(name, oldpass, newpass string) error { | |||||
| info, err := kb.Get(name) | |||||
| if err != nil { | |||||
| return err | |||||
| } | |||||
| switch info.(type) { | |||||
| case localInfo: | |||||
| linfo := info.(localInfo) | |||||
| key, err := unarmorDecryptPrivKey(linfo.PrivKeyArmor, oldpass) | |||||
| if err != nil { | |||||
| return err | |||||
| } | |||||
| kb.writeLocalKey(key, name, newpass) | |||||
| return nil | |||||
| default: | |||||
| return fmt.Errorf("locally stored key required") | |||||
| } | |||||
| } | |||||
| func (kb dbKeybase) writeLocalKey(priv crypto.PrivKey, name, passphrase string) Info { | |||||
| // encrypt private key using passphrase | |||||
| privArmor := encryptArmorPrivKey(priv, passphrase) | |||||
| // make Info | |||||
| pub := priv.PubKey() | |||||
| info := newLocalInfo(name, pub, privArmor) | |||||
| kb.writeInfo(info, name) | |||||
| return info | |||||
| } | |||||
| func (kb dbKeybase) writeLedgerKey(pub crypto.PubKey, path crypto.DerivationPath, name string) Info { | |||||
| info := newLedgerInfo(name, pub, path) | |||||
| kb.writeInfo(info, name) | |||||
| return info | |||||
| } | |||||
| func (kb dbKeybase) writeOfflineKey(pub crypto.PubKey, name string) Info { | |||||
| info := newOfflineInfo(name, pub) | |||||
| kb.writeInfo(info, name) | |||||
| return info | |||||
| } | |||||
| func (kb dbKeybase) writeInfo(info Info, name string) { | |||||
| // write the info by key | |||||
| kb.db.SetSync(infoKey(name), writeInfo(info)) | |||||
| } | |||||
| func infoKey(name string) []byte { | |||||
| return []byte(fmt.Sprintf("%s.info", name)) | |||||
| } | |||||
+ 0
- 383
keys/keybase_test.go
View File
| @ -1,383 +0,0 @@ | |||||
| package keys_test | |||||
| import ( | |||||
| "fmt" | |||||
| "testing" | |||||
| "github.com/stretchr/testify/assert" | |||||
| "github.com/stretchr/testify/require" | |||||
| "github.com/tendermint/go-crypto" | |||||
| "github.com/tendermint/go-crypto/keys" | |||||
| "github.com/tendermint/go-crypto/keys/hd" | |||||
| dbm "github.com/tendermint/tmlibs/db" | |||||
| ) | |||||
| // TestKeyManagement makes sure we can manipulate these keys well | |||||
| func TestKeyManagement(t *testing.T) { | |||||
| // make the storage with reasonable defaults | |||||
| cstore := keys.New( | |||||
| dbm.NewMemDB(), | |||||
| ) | |||||
| algo := keys.Secp256k1 | |||||
| n1, n2, n3 := "personal", "business", "other" | |||||
| p1, p2 := "1234", "really-secure!@#$" | |||||
| // Check empty state | |||||
| l, err := cstore.List() | |||||
| require.Nil(t, err) | |||||
| assert.Empty(t, l) | |||||
| _, _, err = cstore.CreateMnemonic(n1, keys.English, p1, keys.Ed25519) | |||||
| assert.Error(t, err, "ed25519 keys are currently not supported by keybase") | |||||
| // create some keys | |||||
| _, err = cstore.Get(n1) | |||||
| assert.Error(t, err) | |||||
| i, _, err := cstore.CreateMnemonic(n1, keys.English, p1, algo) | |||||
| require.NoError(t, err) | |||||
| require.Equal(t, n1, i.GetName()) | |||||
| _, _, err = cstore.CreateMnemonic(n2, keys.English, p2, algo) | |||||
| require.NoError(t, err) | |||||
| // we can get these keys | |||||
| i2, err := cstore.Get(n2) | |||||
| assert.NoError(t, err) | |||||
| _, err = cstore.Get(n3) | |||||
| assert.NotNil(t, err) | |||||
| // list shows them in order | |||||
| keyS, err := cstore.List() | |||||
| require.NoError(t, err) | |||||
| require.Equal(t, 2, len(keyS)) | |||||
| // note these are in alphabetical order | |||||
| assert.Equal(t, n2, keyS[0].GetName()) | |||||
| assert.Equal(t, n1, keyS[1].GetName()) | |||||
| assert.Equal(t, i2.GetPubKey(), keyS[0].GetPubKey()) | |||||
| // deleting a key removes it | |||||
| err = cstore.Delete("bad name", "foo") | |||||
| require.NotNil(t, err) | |||||
| err = cstore.Delete(n1, p1) | |||||
| require.NoError(t, err) | |||||
| keyS, err = cstore.List() | |||||
| require.NoError(t, err) | |||||
| assert.Equal(t, 1, len(keyS)) | |||||
| _, err = cstore.Get(n1) | |||||
| assert.Error(t, err) | |||||
| // create an offline key | |||||
| o1 := "offline" | |||||
| priv1 := crypto.GenPrivKeyEd25519() | |||||
| pub1 := priv1.PubKey() | |||||
| i, err = cstore.CreateOffline(o1, pub1) | |||||
| require.Nil(t, err) | |||||
| require.Equal(t, pub1, i.GetPubKey()) | |||||
| require.Equal(t, o1, i.GetName()) | |||||
| keyS, err = cstore.List() | |||||
| require.NoError(t, err) | |||||
| require.Equal(t, 2, len(keyS)) | |||||
| // delete the offline key | |||||
| err = cstore.Delete(o1, "no") | |||||
| require.NotNil(t, err) | |||||
| err = cstore.Delete(o1, "yes") | |||||
| require.NoError(t, err) | |||||
| keyS, err = cstore.List() | |||||
| require.NoError(t, err) | |||||
| require.Equal(t, 1, len(keyS)) | |||||
| } | |||||
| // TestSignVerify does some detailed checks on how we sign and validate | |||||
| // signatures | |||||
| func TestSignVerify(t *testing.T) { | |||||
| cstore := keys.New( | |||||
| dbm.NewMemDB(), | |||||
| ) | |||||
| algo := keys.Secp256k1 | |||||
| n1, n2, n3 := "some dude", "a dudette", "dude-ish" | |||||
| p1, p2, p3 := "1234", "foobar", "foobar" | |||||
| // create two users and get their info | |||||
| i1, _, err := cstore.CreateMnemonic(n1, keys.English, p1, algo) | |||||
| require.Nil(t, err) | |||||
| i2, _, err := cstore.CreateMnemonic(n2, keys.English, p2, algo) | |||||
| require.Nil(t, err) | |||||
| // Import a public key | |||||
| armor, err := cstore.ExportPubKey(n2) | |||||
| require.Nil(t, err) | |||||
| cstore.ImportPubKey(n3, armor) | |||||
| i3, err := cstore.Get(n3) | |||||
| require.NoError(t, err) | |||||
| require.Equal(t, i3.GetName(), n3) | |||||
| // let's try to sign some messages | |||||
| d1 := []byte("my first message") | |||||
| d2 := []byte("some other important info!") | |||||
| d3 := []byte("feels like I forgot something...") | |||||
| // try signing both data with both keys... | |||||
| s11, pub1, err := cstore.Sign(n1, p1, d1) | |||||
| require.Nil(t, err) | |||||
| require.Equal(t, i1.GetPubKey(), pub1) | |||||
| s12, pub1, err := cstore.Sign(n1, p1, d2) | |||||
| require.Nil(t, err) | |||||
| require.Equal(t, i1.GetPubKey(), pub1) | |||||
| s21, pub2, err := cstore.Sign(n2, p2, d1) | |||||
| require.Nil(t, err) | |||||
| require.Equal(t, i2.GetPubKey(), pub2) | |||||
| s22, pub2, err := cstore.Sign(n2, p2, d2) | |||||
| require.Nil(t, err) | |||||
| require.Equal(t, i2.GetPubKey(), pub2) | |||||
| // let's try to validate and make sure it only works when everything is proper | |||||
| cases := []struct { | |||||
| key crypto.PubKey | |||||
| data []byte | |||||
| sig crypto.Signature | |||||
| valid bool | |||||
| }{ | |||||
| // proper matches | |||||
| {i1.GetPubKey(), d1, s11, true}, | |||||
| // change data, pubkey, or signature leads to fail | |||||
| {i1.GetPubKey(), d2, s11, false}, | |||||
| {i2.GetPubKey(), d1, s11, false}, | |||||
| {i1.GetPubKey(), d1, s21, false}, | |||||
| // make sure other successes | |||||
| {i1.GetPubKey(), d2, s12, true}, | |||||
| {i2.GetPubKey(), d1, s21, true}, | |||||
| {i2.GetPubKey(), d2, s22, true}, | |||||
| } | |||||
| for i, tc := range cases { | |||||
| valid := tc.key.VerifyBytes(tc.data, tc.sig) | |||||
| assert.Equal(t, tc.valid, valid, "%d", i) | |||||
| } | |||||
| // Now try to sign data with a secret-less key | |||||
| _, _, err = cstore.Sign(n3, p3, d3) | |||||
| assert.NotNil(t, err) | |||||
| } | |||||
| func assertPassword(t *testing.T, cstore keys.Keybase, name, pass, badpass string) { | |||||
| err := cstore.Update(name, badpass, pass) | |||||
| assert.NotNil(t, err) | |||||
| err = cstore.Update(name, pass, pass) | |||||
| assert.Nil(t, err, "%+v", err) | |||||
| } | |||||
| // TestExportImport tests exporting and importing keys. | |||||
| func TestExportImport(t *testing.T) { | |||||
| // make the storage with reasonable defaults | |||||
| db := dbm.NewMemDB() | |||||
| cstore := keys.New( | |||||
| db, | |||||
| ) | |||||
| info, _, err := cstore.CreateMnemonic("john", keys.English,"secretcpw", keys.Secp256k1) | |||||
| assert.NoError(t, err) | |||||
| assert.Equal(t, info.GetName(), "john") | |||||
| john, err := cstore.Get("john") | |||||
| assert.NoError(t, err) | |||||
| assert.Equal(t, info.GetName(), "john") | |||||
| johnAddr := info.GetPubKey().Address() | |||||
| armor, err := cstore.Export("john") | |||||
| assert.NoError(t, err) | |||||
| err = cstore.Import("john2", armor) | |||||
| assert.NoError(t, err) | |||||
| john2, err := cstore.Get("john2") | |||||
| assert.NoError(t, err) | |||||
| assert.Equal(t, john.GetPubKey().Address(), johnAddr) | |||||
| assert.Equal(t, john.GetName(), "john") | |||||
| assert.Equal(t, john, john2) | |||||
| } | |||||
| // | |||||
| func TestExportImportPubKey(t *testing.T) { | |||||
| // make the storage with reasonable defaults | |||||
| db := dbm.NewMemDB() | |||||
| cstore := keys.New( | |||||
| db, | |||||
| ) | |||||
| // CreateMnemonic a private-public key pair and ensure consistency | |||||
| notPasswd := "n9y25ah7" | |||||
| info, _, err := cstore.CreateMnemonic("john", keys.English, notPasswd, keys.Secp256k1) | |||||
| assert.Nil(t, err) | |||||
| assert.NotEqual(t, info, "") | |||||
| assert.Equal(t, info.GetName(), "john") | |||||
| addr := info.GetPubKey().Address() | |||||
| john, err := cstore.Get("john") | |||||
| assert.NoError(t, err) | |||||
| assert.Equal(t, john.GetName(), "john") | |||||
| assert.Equal(t, john.GetPubKey().Address(), addr) | |||||
| // Export the public key only | |||||
| armor, err := cstore.ExportPubKey("john") | |||||
| assert.NoError(t, err) | |||||
| // Import it under a different name | |||||
| err = cstore.ImportPubKey("john-pubkey-only", armor) | |||||
| assert.NoError(t, err) | |||||
| // Ensure consistency | |||||
| john2, err := cstore.Get("john-pubkey-only") | |||||
| assert.NoError(t, err) | |||||
| // Compare the public keys | |||||
| assert.True(t, john.GetPubKey().Equals(john2.GetPubKey())) | |||||
| // Ensure the original key hasn't changed | |||||
| john, err = cstore.Get("john") | |||||
| assert.NoError(t, err) | |||||
| assert.Equal(t, john.GetPubKey().Address(), addr) | |||||
| assert.Equal(t, john.GetName(), "john") | |||||
| // Ensure keys cannot be overwritten | |||||
| err = cstore.ImportPubKey("john-pubkey-only", armor) | |||||
| assert.NotNil(t, err) | |||||
| } | |||||
| // TestAdvancedKeyManagement verifies update, import, export functionality | |||||
| func TestAdvancedKeyManagement(t *testing.T) { | |||||
| // make the storage with reasonable defaults | |||||
| cstore := keys.New( | |||||
| dbm.NewMemDB(), | |||||
| ) | |||||
| algo := keys.Secp256k1 | |||||
| n1, n2 := "old-name", "new name" | |||||
| p1, p2 := "1234", "foobar" | |||||
| // make sure key works with initial password | |||||
| _, _, err := cstore.CreateMnemonic(n1, keys.English, p1, algo) | |||||
| require.Nil(t, err, "%+v", err) | |||||
| assertPassword(t, cstore, n1, p1, p2) | |||||
| // update password requires the existing password | |||||
| err = cstore.Update(n1, "jkkgkg", p2) | |||||
| assert.NotNil(t, err) | |||||
| assertPassword(t, cstore, n1, p1, p2) | |||||
| // then it changes the password when correct | |||||
| err = cstore.Update(n1, p1, p2) | |||||
| assert.NoError(t, err) | |||||
| // p2 is now the proper one! | |||||
| assertPassword(t, cstore, n1, p2, p1) | |||||
| // exporting requires the proper name and passphrase | |||||
| _, err = cstore.Export(n1 + ".notreal") | |||||
| assert.NotNil(t, err) | |||||
| _, err = cstore.Export(" " + n1) | |||||
| assert.NotNil(t, err) | |||||
| _, err = cstore.Export(n1 + " ") | |||||
| assert.NotNil(t, err) | |||||
| _, err = cstore.Export("") | |||||
| assert.NotNil(t, err) | |||||
| exported, err := cstore.Export(n1) | |||||
| require.Nil(t, err, "%+v", err) | |||||
| // import succeeds | |||||
| err = cstore.Import(n2, exported) | |||||
| assert.NoError(t, err) | |||||
| // second import fails | |||||
| err = cstore.Import(n2, exported) | |||||
| assert.NotNil(t, err) | |||||
| } | |||||
| // TestSeedPhrase verifies restoring from a seed phrase | |||||
| func TestSeedPhrase(t *testing.T) { | |||||
| // make the storage with reasonable defaults | |||||
| cstore := keys.New( | |||||
| dbm.NewMemDB(), | |||||
| ) | |||||
| algo := keys.Secp256k1 | |||||
| n1, n2 := "lost-key", "found-again" | |||||
| p1, p2 := "1234", "foobar" | |||||
| // make sure key works with initial password | |||||
| info, mnemonic, err := cstore.CreateMnemonic(n1, keys.English, p1, algo) | |||||
| require.Nil(t, err, "%+v", err) | |||||
| assert.Equal(t, n1, info.GetName()) | |||||
| assert.NotEmpty(t, mnemonic) | |||||
| // now, let us delete this key | |||||
| err = cstore.Delete(n1, p1) | |||||
| require.Nil(t, err, "%+v", err) | |||||
| _, err = cstore.Get(n1) | |||||
| require.NotNil(t, err) | |||||
| // let us re-create it from the mnemonic-phrase | |||||
| params := *hd.NewFundraiserParams(0 ,0 ) | |||||
| newInfo, err := cstore.Derive(n2,mnemonic, p2, params) | |||||
| require.NoError(t, err) | |||||
| assert.Equal(t, n2, newInfo.GetName()) | |||||
| assert.Equal(t, info.GetPubKey().Address(), newInfo.GetPubKey().Address()) | |||||
| assert.Equal(t, info.GetPubKey(), newInfo.GetPubKey()) | |||||
| } | |||||
| func ExampleNew() { | |||||
| // Select the encryption and storage for your cryptostore | |||||
| cstore := keys.New( | |||||
| dbm.NewMemDB(), | |||||
| ) | |||||
| sec := keys.Secp256k1 | |||||
| // Add keys and see they return in alphabetical order | |||||
| bob, _, err := cstore.CreateMnemonic("Bob", keys.English, "friend", sec) | |||||
| if err != nil { | |||||
| // this should never happen | |||||
| fmt.Println(err) | |||||
| } else { | |||||
| // return info here just like in List | |||||
| fmt.Println(bob.GetName()) | |||||
| } | |||||
| cstore.CreateMnemonic("Alice", keys.English, "secret", sec) | |||||
| cstore.CreateMnemonic("Carl", keys.English, "mitm", sec) | |||||
| info, _ := cstore.List() | |||||
| for _, i := range info { | |||||
| fmt.Println(i.GetName()) | |||||
| } | |||||
| // We need to use passphrase to generate a signature | |||||
| tx := []byte("deadbeef") | |||||
| sig, pub, err := cstore.Sign("Bob", "friend", tx) | |||||
| if err != nil { | |||||
| fmt.Println("don't accept real passphrase") | |||||
| } | |||||
| // and we can validate the signature with publicly available info | |||||
| binfo, _ := cstore.Get("Bob") | |||||
| if !binfo.GetPubKey().Equals(bob.GetPubKey()) { | |||||
| fmt.Println("Get and Create return different keys") | |||||
| } | |||||
| if pub.Equals(binfo.GetPubKey()) { | |||||
| fmt.Println("signed by Bob") | |||||
| } | |||||
| if !pub.VerifyBytes(tx, sig) { | |||||
| fmt.Println("invalid signature") | |||||
| } | |||||
| // Output: | |||||
| // Bob | |||||
| // Alice | |||||
| // Bob | |||||
| // Carl | |||||
| // signed by Bob | |||||
| } | |||||
+ 0
- 12
keys/keys.go
View File
| @ -1,12 +0,0 @@ | |||||
| package keys | |||||
| // SigningAlgo defines an algorithm to derive key-pairs which can be used for cryptographic signing. | |||||
| type SigningAlgo string | |||||
| const ( | |||||
| // Secp256k1 uses the Bitcoin secp256k1 ECDSA parameters. | |||||
| Secp256k1 = SigningAlgo("secp256k1") | |||||
| // Ed25519 represents the Ed25519 signature system. | |||||
| // It is currently not supported for end-user keys (wallets/ledgers). | |||||
| Ed25519 = SigningAlgo("ed25519") | |||||
| ) | |||||
+ 0
- 2
keys/keys.toml
View File
| @ -1,2 +0,0 @@ | |||||
| output = "text" | |||||
| keydir = ".mykeys" | |||||
+ 0
- 115
keys/mintkey.go
View File
| @ -1,115 +0,0 @@ | |||||
| package keys | |||||
| import ( | |||||
| "encoding/hex" | |||||
| "fmt" | |||||
| cmn "github.com/tendermint/tmlibs/common" | |||||
| "github.com/tendermint/go-crypto" | |||||
| "github.com/tendermint/go-crypto/keys/bcrypt" | |||||
| ) | |||||
| const ( | |||||
| blockTypePrivKey = "TENDERMINT PRIVATE KEY" | |||||
| blockTypeKeyInfo = "TENDERMINT KEY INFO" | |||||
| blockTypePubKey = "TENDERMINT PUBLIC KEY" | |||||
| ) | |||||
| func armorInfoBytes(bz []byte) string { | |||||
| return armorBytes(bz, blockTypeKeyInfo) | |||||
| } | |||||
| func armorPubKeyBytes(bz []byte) string { | |||||
| return armorBytes(bz, blockTypePubKey) | |||||
| } | |||||
| func armorBytes(bz []byte, blockType string) string { | |||||
| header := map[string]string{ | |||||
| "type": "Info", | |||||
| "version": "0.0.0", | |||||
| } | |||||
| return crypto.EncodeArmor(blockType, header, bz) | |||||
| } | |||||
| func unarmorInfoBytes(armorStr string) (bz []byte, err error) { | |||||
| return unarmorBytes(armorStr, blockTypeKeyInfo) | |||||
| } | |||||
| func unarmorPubKeyBytes(armorStr string) (bz []byte, err error) { | |||||
| return unarmorBytes(armorStr, blockTypePubKey) | |||||
| } | |||||
| func unarmorBytes(armorStr, blockType string) (bz []byte, err error) { | |||||
| bType, header, bz, err := crypto.DecodeArmor(armorStr) | |||||
| if err != nil { | |||||
| return | |||||
| } | |||||
| if bType != blockType { | |||||
| err = fmt.Errorf("Unrecognized armor type %q, expected: %q", bType, blockType) | |||||
| return | |||||
| } | |||||
| if header["version"] != "0.0.0" { | |||||
| err = fmt.Errorf("Unrecognized version: %v", header["version"]) | |||||
| return | |||||
| } | |||||
| return | |||||
| } | |||||
| func encryptArmorPrivKey(privKey crypto.PrivKey, passphrase string) string { | |||||
| saltBytes, encBytes := encryptPrivKey(privKey, passphrase) | |||||
| header := map[string]string{ | |||||
| "kdf": "bcrypt", | |||||
| "salt": fmt.Sprintf("%X", saltBytes), | |||||
| } | |||||
| armorStr := crypto.EncodeArmor(blockTypePrivKey, header, encBytes) | |||||
| return armorStr | |||||
| } | |||||
| func unarmorDecryptPrivKey(armorStr string, passphrase string) (crypto.PrivKey, error) { | |||||
| var privKey crypto.PrivKey | |||||
| blockType, header, encBytes, err := crypto.DecodeArmor(armorStr) | |||||
| if err != nil { | |||||
| return privKey, err | |||||
| } | |||||
| if blockType != blockTypePrivKey { | |||||
| return privKey, fmt.Errorf("Unrecognized armor type: %v", blockType) | |||||
| } | |||||
| if header["kdf"] != "bcrypt" { | |||||
| return privKey, fmt.Errorf("Unrecognized KDF type: %v", header["KDF"]) | |||||
| } | |||||
| if header["salt"] == "" { | |||||
| return privKey, fmt.Errorf("Missing salt bytes") | |||||
| } | |||||
| saltBytes, err := hex.DecodeString(header["salt"]) | |||||
| if err != nil { | |||||
| return privKey, fmt.Errorf("Error decoding salt: %v", err.Error()) | |||||
| } | |||||
| privKey, err = decryptPrivKey(saltBytes, encBytes, passphrase) | |||||
| return privKey, err | |||||
| } | |||||
| func encryptPrivKey(privKey crypto.PrivKey, passphrase string) (saltBytes []byte, encBytes []byte) { | |||||
| saltBytes = crypto.CRandBytes(16) | |||||
| key, err := bcrypt.GenerateFromPassword(saltBytes, []byte(passphrase), 12) // TODO parameterize. 12 is good today (2016) | |||||
| if err != nil { | |||||
| cmn.Exit("Error generating bcrypt key from passphrase: " + err.Error()) | |||||
| } | |||||
| key = crypto.Sha256(key) // Get 32 bytes | |||||
| privKeyBytes := privKey.Bytes() | |||||
| return saltBytes, crypto.EncryptSymmetric(privKeyBytes, key) | |||||
| } | |||||
| func decryptPrivKey(saltBytes []byte, encBytes []byte, passphrase string) (privKey crypto.PrivKey, err error) { | |||||
| key, err := bcrypt.GenerateFromPassword(saltBytes, []byte(passphrase), 12) // TODO parameterize. 12 is good today (2016) | |||||
| if err != nil { | |||||
| cmn.Exit("Error generating bcrypt key from passphrase: " + err.Error()) | |||||
| } | |||||
| key = crypto.Sha256(key) // Get 32 bytes | |||||
| privKeyBytes, err := crypto.DecryptSymmetric(encBytes, key) | |||||
| if err != nil { | |||||
| return privKey, err | |||||
| } | |||||
| privKey, err = crypto.PrivKeyFromBytes(privKeyBytes) | |||||
| return privKey, err | |||||
| } | |||||
+ 0
- 142
keys/types.go
View File
| @ -1,142 +0,0 @@ | |||||
| package keys | |||||
| import ( | |||||
| crypto "github.com/tendermint/go-crypto" | |||||
| "github.com/tendermint/go-crypto/keys/hd" | |||||
| ) | |||||
| // Keybase exposes operations on a generic keystore | |||||
| type Keybase interface { | |||||
| // CRUD on the keystore | |||||
| List() ([]Info, error) | |||||
| Get(name string) (Info, error) | |||||
| Delete(name, passphrase string) error | |||||
| // Sign some bytes, looking up the private key to use | |||||
| Sign(name, passphrase string, msg []byte) (crypto.Signature, crypto.PubKey, error) | |||||
| // CreateMnemonic creates a new mnemonic, and derives a hierarchical deterministic | |||||
| // key from that. | |||||
| CreateMnemonic(name string, language Language, passwd string, algo SigningAlgo) (info Info, seed string, err error) | |||||
| // CreateFundraiserKey takes a mnemonic and derives, a password | |||||
| CreateFundraiserKey(name, mnemonic, passwd string) (info Info, err error) | |||||
| // Derive derives a key from the passed mnemonic using a BIP44 path. | |||||
| Derive(name, mnemonic, passwd string, params hd.BIP44Params) (Info, error) | |||||
| // Create, store, and return a new Ledger key reference | |||||
| CreateLedger(name string, path crypto.DerivationPath, algo SigningAlgo) (info Info, err error) | |||||
| // Create, store, and return a new offline key reference | |||||
| CreateOffline(name string, pubkey crypto.PubKey) (info Info, err error) | |||||
| // The following operations will *only* work on locally-stored keys | |||||
| Update(name, oldpass, newpass string) error | |||||
| Import(name string, armor string) (err error) | |||||
| ImportPubKey(name string, armor string) (err error) | |||||
| Export(name string) (armor string, err error) | |||||
| ExportPubKey(name string) (armor string, err error) | |||||
| } | |||||
| // Info is the publicly exposed information about a keypair | |||||
| type Info interface { | |||||
| // Human-readable type for key listing | |||||
| GetType() string | |||||
| // Name of the key | |||||
| GetName() string | |||||
| // Public key | |||||
| GetPubKey() crypto.PubKey | |||||
| } | |||||
| var _ Info = &localInfo{} | |||||
| var _ Info = &ledgerInfo{} | |||||
| var _ Info = &offlineInfo{} | |||||
| // localInfo is the public information about a locally stored key | |||||
| type localInfo struct { | |||||
| Name string `json:"name"` | |||||
| PubKey crypto.PubKey `json:"pubkey"` | |||||
| PrivKeyArmor string `json:"privkey.armor"` | |||||
| } | |||||
| func newLocalInfo(name string, pub crypto.PubKey, privArmor string) Info { | |||||
| return &localInfo{ | |||||
| Name: name, | |||||
| PubKey: pub, | |||||
| PrivKeyArmor: privArmor, | |||||
| } | |||||
| } | |||||
| func (i localInfo) GetType() string { | |||||
| return "local" | |||||
| } | |||||
| func (i localInfo) GetName() string { | |||||
| return i.Name | |||||
| } | |||||
| func (i localInfo) GetPubKey() crypto.PubKey { | |||||
| return i.PubKey | |||||
| } | |||||
| // ledgerInfo is the public information about a Ledger key | |||||
| type ledgerInfo struct { | |||||
| Name string `json:"name"` | |||||
| PubKey crypto.PubKey `json:"pubkey"` | |||||
| Path crypto.DerivationPath `json:"path"` | |||||
| } | |||||
| func newLedgerInfo(name string, pub crypto.PubKey, path crypto.DerivationPath) Info { | |||||
| return &ledgerInfo{ | |||||
| Name: name, | |||||
| PubKey: pub, | |||||
| Path: path, | |||||
| } | |||||
| } | |||||
| func (i ledgerInfo) GetType() string { | |||||
| return "ledger" | |||||
| } | |||||
| func (i ledgerInfo) GetName() string { | |||||
| return i.Name | |||||
| } | |||||
| func (i ledgerInfo) GetPubKey() crypto.PubKey { | |||||
| return i.PubKey | |||||
| } | |||||
| // offlineInfo is the public information about an offline key | |||||
| type offlineInfo struct { | |||||
| Name string `json:"name"` | |||||
| PubKey crypto.PubKey `json:"pubkey"` | |||||
| } | |||||
| func newOfflineInfo(name string, pub crypto.PubKey) Info { | |||||
| return &offlineInfo{ | |||||
| Name: name, | |||||
| PubKey: pub, | |||||
| } | |||||
| } | |||||
| func (i offlineInfo) GetType() string { | |||||
| return "offline" | |||||
| } | |||||
| func (i offlineInfo) GetName() string { | |||||
| return i.Name | |||||
| } | |||||
| func (i offlineInfo) GetPubKey() crypto.PubKey { | |||||
| return i.PubKey | |||||
| } | |||||
| // encoding info | |||||
| func writeInfo(i Info) []byte { | |||||
| return cdc.MustMarshalBinary(i) | |||||
| } | |||||
| // decoding info | |||||
| func readInfo(bz []byte) (info Info, err error) { | |||||
| err = cdc.UnmarshalBinary(bz, &info) | |||||
| return | |||||
| } | |||||
+ 0
- 16
keys/wire.go
View File
| @ -1,16 +0,0 @@ | |||||
| package keys | |||||
| import ( | |||||
| amino "github.com/tendermint/go-amino" | |||||
| crypto "github.com/tendermint/go-crypto" | |||||
| ) | |||||
| var cdc = amino.NewCodec() | |||||
| func init() { | |||||
| crypto.RegisterAmino(cdc) | |||||
| cdc.RegisterInterface((*Info)(nil), nil) | |||||
| cdc.RegisterConcrete(localInfo{}, "crypto/keys/localInfo", nil) | |||||
| cdc.RegisterConcrete(ledgerInfo{}, "crypto/keys/ledgerInfo", nil) | |||||
| cdc.RegisterConcrete(offlineInfo{}, "crypto/keys/offlineInfo", nil) | |||||
| } | |||||
+ 0
- 19
ledger_common.go
View File
| @ -1,19 +0,0 @@ | |||||
| package crypto | |||||
| import ( | |||||
| ledger "github.com/zondax/ledger-goclient" | |||||
| ) | |||||
| var device *ledger.Ledger | |||||
| // Ledger derivation path | |||||
| type DerivationPath = []uint32 | |||||
| // getLedger gets a copy of the device, and caches it | |||||
| func getLedger() (*ledger.Ledger, error) { | |||||
| var err error | |||||
| if device == nil { | |||||
| device, err = ledger.FindLedger() | |||||
| } | |||||
| return device, err | |||||
| } | |||||
+ 0
- 124
ledger_secp256k1.go
View File
| @ -1,124 +0,0 @@ | |||||
| package crypto | |||||
| import ( | |||||
| "fmt" | |||||
| secp256k1 "github.com/btcsuite/btcd/btcec" | |||||
| ledger "github.com/zondax/ledger-goclient" | |||||
| ) | |||||
| func pubkeyLedgerSecp256k1(device *ledger.Ledger, path DerivationPath) (pub PubKey, err error) { | |||||
| key, err := device.GetPublicKeySECP256K1(path) | |||||
| if err != nil { | |||||
| return nil, fmt.Errorf("error fetching public key: %v", err) | |||||
| } | |||||
| var p PubKeySecp256k1 | |||||
| // Reserialize in the 33-byte compressed format | |||||
| cmp, err := secp256k1.ParsePubKey(key[:], secp256k1.S256()) | |||||
| copy(p[:], cmp.SerializeCompressed()) | |||||
| pub = p | |||||
| return | |||||
| } | |||||
| func signLedgerSecp256k1(device *ledger.Ledger, path DerivationPath, msg []byte) (sig Signature, err error) { | |||||
| bsig, err := device.SignSECP256K1(path, msg) | |||||
| if err != nil { | |||||
| return sig, err | |||||
| } | |||||
| sig = SignatureSecp256k1FromBytes(bsig) | |||||
| return | |||||
| } | |||||
| // PrivKeyLedgerSecp256k1 implements PrivKey, calling the ledger nano | |||||
| // we cache the PubKey from the first call to use it later | |||||
| type PrivKeyLedgerSecp256k1 struct { | |||||
| // PubKey should be private, but we want to encode it via go-amino | |||||
| // so we can view the address later, even without having the ledger | |||||
| // attached | |||||
| CachedPubKey PubKey | |||||
| Path DerivationPath | |||||
| } | |||||
| // NewPrivKeyLedgerSecp256k1 will generate a new key and store the | |||||
| // public key for later use. | |||||
| func NewPrivKeyLedgerSecp256k1(path DerivationPath) (PrivKey, error) { | |||||
| var pk PrivKeyLedgerSecp256k1 | |||||
| pk.Path = path | |||||
| // cache the pubkey for later use | |||||
| pubKey, err := pk.getPubKey() | |||||
| if err != nil { | |||||
| return nil, err | |||||
| } | |||||
| pk.CachedPubKey = pubKey | |||||
| return &pk, err | |||||
| } | |||||
| // ValidateKey allows us to verify the sanity of a key | |||||
| // after loading it from disk | |||||
| func (pk PrivKeyLedgerSecp256k1) ValidateKey() error { | |||||
| // getPubKey will return an error if the ledger is not | |||||
| pub, err := pk.getPubKey() | |||||
| if err != nil { | |||||
| return err | |||||
| } | |||||
| // verify this matches cached address | |||||
| if !pub.Equals(pk.CachedPubKey) { | |||||
| return fmt.Errorf("cached key does not match retrieved key") | |||||
| } | |||||
| return nil | |||||
| } | |||||
| // AssertIsPrivKeyInner fulfils PrivKey Interface | |||||
| func (pk *PrivKeyLedgerSecp256k1) AssertIsPrivKeyInner() {} | |||||
| // Bytes fulfils PrivKey Interface - but it stores the cached pubkey so we can verify | |||||
| // the same key when we reconnect to a ledger | |||||
| func (pk PrivKeyLedgerSecp256k1) Bytes() []byte { | |||||
| return cdc.MustMarshalBinaryBare(pk) | |||||
| } | |||||
| // Sign calls the ledger and stores the PubKey for future use | |||||
| // | |||||
| // Communication is checked on NewPrivKeyLedger and PrivKeyFromBytes, | |||||
| // returning an error, so this should only trigger if the privkey is held | |||||
| // in memory for a while before use. | |||||
| func (pk PrivKeyLedgerSecp256k1) Sign(msg []byte) (Signature, error) { | |||||
| dev, err := getLedger() | |||||
| if err != nil { | |||||
| return nil, err | |||||
| } | |||||
| sig, err := signLedgerSecp256k1(dev, pk.Path, msg) | |||||
| if err != nil { | |||||
| return nil, err | |||||
| } | |||||
| return sig, nil | |||||
| } | |||||
| // PubKey returns the stored PubKey | |||||
| func (pk PrivKeyLedgerSecp256k1) PubKey() PubKey { | |||||
| return pk.CachedPubKey | |||||
| } | |||||
| // getPubKey reads the pubkey the ledger itself | |||||
| // since this involves IO, it may return an error, which is not exposed | |||||
| // in the PubKey interface, so this function allows better error handling | |||||
| func (pk PrivKeyLedgerSecp256k1) getPubKey() (key PubKey, err error) { | |||||
| dev, err := getLedger() | |||||
| if err != nil { | |||||
| return key, fmt.Errorf("cannot connect to Ledger device - error: %v", err) | |||||
| } | |||||
| key, err = pubkeyLedgerSecp256k1(dev, pk.Path) | |||||
| if err != nil { | |||||
| return key, fmt.Errorf("please open Cosmos app on the Ledger device - error: %v", err) | |||||
| } | |||||
| return key, err | |||||
| } | |||||
| // Equals fulfils PrivKey Interface - makes sure both keys refer to the | |||||
| // same | |||||
| func (pk PrivKeyLedgerSecp256k1) Equals(other PrivKey) bool { | |||||
| if ledger, ok := other.(*PrivKeyLedgerSecp256k1); ok { | |||||
| return pk.CachedPubKey.Equals(ledger.CachedPubKey) | |||||
| } | |||||
| return false | |||||
| } | |||||
+ 0
- 63
ledger_test.go
View File
| @ -1,63 +0,0 @@ | |||||
| package crypto | |||||
| import ( | |||||
| "os" | |||||
| "testing" | |||||
| "github.com/stretchr/testify/assert" | |||||
| "github.com/stretchr/testify/require" | |||||
| ) | |||||
| func TestRealLedgerSecp256k1(t *testing.T) { | |||||
| if os.Getenv("WITH_LEDGER") == "" { | |||||
| t.Skip("Set WITH_LEDGER to run code on real ledger") | |||||
| } | |||||
| msg := []byte("kuhehfeohg") | |||||
| path := DerivationPath{44, 60, 0, 0, 0} | |||||
| priv, err := NewPrivKeyLedgerSecp256k1(path) | |||||
| require.Nil(t, err, "%+v", err) | |||||
| pub := priv.PubKey() | |||||
| sig, err := priv.Sign(msg) | |||||
| require.Nil(t, err) | |||||
| valid := pub.VerifyBytes(msg, sig) | |||||
| assert.True(t, valid) | |||||
| // now, let's serialize the key and make sure it still works | |||||
| bs := priv.Bytes() | |||||
| priv2, err := PrivKeyFromBytes(bs) | |||||
| require.Nil(t, err, "%+v", err) | |||||
| // make sure we get the same pubkey when we load from disk | |||||
| pub2 := priv2.PubKey() | |||||
| require.Equal(t, pub, pub2) | |||||
| // signing with the loaded key should match the original pubkey | |||||
| sig, err = priv2.Sign(msg) | |||||
| require.Nil(t, err) | |||||
| valid = pub.VerifyBytes(msg, sig) | |||||
| assert.True(t, valid) | |||||
| // make sure pubkeys serialize properly as well | |||||
| bs = pub.Bytes() | |||||
| bpub, err := PubKeyFromBytes(bs) | |||||
| require.NoError(t, err) | |||||
| assert.Equal(t, pub, bpub) | |||||
| } | |||||
| // TestRealLedgerErrorHandling calls. These tests assume | |||||
| // the ledger is not plugged in.... | |||||
| func TestRealLedgerErrorHandling(t *testing.T) { | |||||
| if os.Getenv("WITH_LEDGER") != "" { | |||||
| t.Skip("Skipping on WITH_LEDGER as it tests unplugged cases") | |||||
| } | |||||
| // first, try to generate a key, must return an error | |||||
| // (no panic) | |||||
| path := DerivationPath{44, 60, 0, 0, 0} | |||||
| _, err := NewPrivKeyLedgerSecp256k1(path) | |||||
| require.Error(t, err) | |||||
| } | |||||