Browse Source
crypto: Refactor to move files out of the top level directory
Currently the top level directory contains basically all of the code for the crypto package. This PR moves the crypto code into submodules in a similar manner to what `golang/x/crypto` does. This improves code organization. Ref discussion: https://github.com/tendermint/tendermint/pull/1966 Closes #1956pull/2002/head
ValarDragon
6 years ago
119 changed files with 1840 additions and 2172 deletions
Split View
Diff Options
-
+18 -18.circleci/config.yml
-
+32 -2CHANGELOG.md
-
+11 -16Gopkg.lock
-
+45 -22Gopkg.toml
-
+1 -1Makefile
-
+2 -2README.md
-
+5 -5benchmarks/codec_test.go
-
+1 -2blockchain/pool_test.go
-
+2 -2blockchain/wire.go
-
+2 -2cmd/priv_val_server/main.go
-
+2 -2cmd/tendermint/commands/wire.go
-
+3 -3config/config.go
-
+3 -0consensus/reactor.go
-
+1 -1consensus/replay.go
-
+3 -3consensus/types/round_state_test.go
-
+2 -2consensus/types/wire.go
-
+2 -2consensus/wire.go
-
+9 -2crypto/README.md
-
+0 -37crypto/amino.go
-
+0 -0crypto/armor/armor.go
-
+0 -0crypto/armor/armor_test.go
-
+36 -0crypto/crypto.go
-
+1 -1crypto/doc.go
-
+205 -0crypto/ed25519/ed25519.go
-
+40 -0crypto/ed25519/ed25519_test.go
-
+56 -0crypto/encoding/amino/amino.go
-
+26 -17crypto/encoding/amino/encode_test.go
-
+1 -0crypto/hash.go
-
+1 -0crypto/hkdfchacha20poly1305/hkdfchachapoly.go
-
+0 -164crypto/priv_key.go
-
+0 -60crypto/priv_key_test.go
-
+0 -153crypto/pub_key.go
-
+205 -0crypto/secp256k1/secp256k1.go
-
+23 -8crypto/secp256k1/secpk256k1_test.go
-
+0 -90crypto/signature.go
-
+0 -46crypto/signature_test.go
-
+7 -4crypto/xsalsa20Symmetric/symmetric.go
-
+4 -3crypto/xsalsa20Symmetric/symmetric_test.go
-
+2 -2docs/spec/scripts/crypto.go
-
+2 -2docs/tendermint-core/configuration.md
-
+2 -2evidence/wire.go
-
+5 -4libs/clist/clist_test.go
-
+2 -5libs/common/os_test.go
-
+13 -75libs/common/random.go
-
+0 -3libs/common/random_test.go
-
+1 -2libs/common/repeat_timer_test.go
-
+5 -5libs/events/events_test.go
-
+8 -0libs/pubsub/pubsub.go
-
+3 -3libs/pubsub/query/Makefile
-
+2 -0libs/pubsub/query/query.peg.go
-
+2 -2lite/files/wire.go
-
+5 -3lite/helpers.go
-
+6 -3lite/performance_test.go
-
+9 -5node/node.go
-
+10 -0node/node_test.go
-
+2 -2node/wire.go
-
+4 -4p2p/conn/secret_connection_test.go
-
+2 -2p2p/conn/wire.go
-
+2 -1p2p/key.go
-
+3 -4p2p/peer_set_test.go
-
+4 -3p2p/peer_test.go
-
+6 -7p2p/pex/addrbook_test.go
-
+2 -1p2p/pex/pex_reactor_test.go
-
+4 -4p2p/switch_test.go
-
+2 -2p2p/test_util.go
-
+2 -2p2p/wire.go
-
+2 -1privval/priv_validator.go
-
+4 -3privval/priv_validator_test.go
-
+5 -4privval/socket.go
-
+8 -8privval/socket_test.go
-
+2 -2privval/wire.go
-
+1 -1rpc/client/localclient.go
-
+0 -2rpc/core/doc.go
-
+2 -2rpc/core/types/wire.go
-
+2 -3rpc/lib/rpc_test.go
-
+0 -77scripts/slate.sh
-
+12 -11scripts/wire2amino.go
-
+4 -4state/execution_test.go
-
+5 -4state/state_test.go
-
+2 -2state/wire.go
-
+0 -335tools/tm-bench/Gopkg.lock
-
+0 -50tools/tm-bench/Gopkg.toml
-
+1 -67tools/tm-bench/Makefile
-
+17 -6tools/tm-bench/README.md
-
+0 -18tools/tm-bench/bench_test.go
-
+28 -149tools/tm-bench/main.go
-
+150 -0tools/tm-bench/statistics.go
-
+44 -12tools/tm-bench/transacter.go
-
+104 -0tools/tm-bench/transacter_test.go
-
+0 -326tools/tm-monitor/Gopkg.lock
-
+0 -50tools/tm-monitor/Gopkg.toml
-
+2 -2tools/tm-monitor/monitor/monitor_test.go
-
+2 -2tools/tm-monitor/monitor/node_test.go
-
+5 -1types/block.go
-
+130 -1types/block_test.go
-
+0 -50types/event_buffer.go
-
+0 -21types/event_buffer_test.go
-
+2 -2types/event_bus.go
-
+64 -15types/event_bus_test.go
-
+0 -10types/events.go
+ 18
- 18
.circleci/config.yml
View File
+ 32
- 2
CHANGELOG.md
View File
+ 11
- 16
Gopkg.lock
View File
+ 45
- 22
Gopkg.toml
View File
+ 1
- 1
Makefile
View File
+ 2
- 2
README.md
View File
+ 5
- 5
benchmarks/codec_test.go
View File
+ 1
- 2
blockchain/pool_test.go
View File
+ 2
- 2
blockchain/wire.go
View File
+ 2
- 2
cmd/priv_val_server/main.go
View File
+ 2
- 2
cmd/tendermint/commands/wire.go
View File
+ 3
- 3
config/config.go
View File
+ 3
- 0
consensus/reactor.go
View File
+ 1
- 1
consensus/replay.go
View File
+ 3
- 3
consensus/types/round_state_test.go
View File
+ 2
- 2
consensus/types/wire.go
View File
+ 2
- 2
consensus/wire.go
View File
+ 9
- 2
crypto/README.md
View File
+ 0
- 37
crypto/amino.go
View File
| @ -1,37 +0,0 @@ | |||
| package crypto | |||
| import ( | |||
| amino "github.com/tendermint/go-amino" | |||
| ) | |||
| var cdc = amino.NewCodec() | |||
| func init() { | |||
| // NOTE: It's important that there be no conflicts here, | |||
| // as that would change the canonical representations, | |||
| // and therefore change the address. | |||
| // TODO: Add feature to go-amino to ensure that there | |||
| // are no conflicts. | |||
| RegisterAmino(cdc) | |||
| } | |||
| // RegisterAmino registers all crypto related types in the given (amino) codec. | |||
| func RegisterAmino(cdc *amino.Codec) { | |||
| cdc.RegisterInterface((*PubKey)(nil), nil) | |||
| cdc.RegisterConcrete(PubKeyEd25519{}, | |||
| "tendermint/PubKeyEd25519", nil) | |||
| cdc.RegisterConcrete(PubKeySecp256k1{}, | |||
| "tendermint/PubKeySecp256k1", nil) | |||
| cdc.RegisterInterface((*PrivKey)(nil), nil) | |||
| cdc.RegisterConcrete(PrivKeyEd25519{}, | |||
| "tendermint/PrivKeyEd25519", nil) | |||
| cdc.RegisterConcrete(PrivKeySecp256k1{}, | |||
| "tendermint/PrivKeySecp256k1", nil) | |||
| cdc.RegisterInterface((*Signature)(nil), nil) | |||
| cdc.RegisterConcrete(SignatureEd25519{}, | |||
| "tendermint/SignatureEd25519", nil) | |||
| cdc.RegisterConcrete(SignatureSecp256k1{}, | |||
| "tendermint/SignatureSecp256k1", nil) | |||
| } | |||
crypto/armor.go → crypto/armor/armor.go
View File
crypto/armor_test.go → crypto/armor/armor_test.go
View File
+ 36
- 0
crypto/crypto.go
View File
| @ -0,0 +1,36 @@ | |||
| package crypto | |||
| import ( | |||
| cmn "github.com/tendermint/tendermint/libs/common" | |||
| ) | |||
| type PrivKey interface { | |||
| Bytes() []byte | |||
| Sign(msg []byte) (Signature, error) | |||
| PubKey() PubKey | |||
| Equals(PrivKey) bool | |||
| } | |||
| // An address is a []byte, but hex-encoded even in JSON. | |||
| // []byte leaves us the option to change the address length. | |||
| // Use an alias so Unmarshal methods (with ptr receivers) are available too. | |||
| type Address = cmn.HexBytes | |||
| type PubKey interface { | |||
| Address() Address | |||
| Bytes() []byte | |||
| VerifyBytes(msg []byte, sig Signature) bool | |||
| Equals(PubKey) bool | |||
| } | |||
| type Signature interface { | |||
| Bytes() []byte | |||
| IsZero() bool | |||
| Equals(Signature) bool | |||
| } | |||
| type Symmetric interface { | |||
| Keygen() []byte | |||
| Encrypt(plaintext []byte, secret []byte) (ciphertext []byte) | |||
| Decrypt(ciphertext []byte, secret []byte) (plaintext []byte, err error) | |||
| } | |||
+ 1
- 1
crypto/doc.go
View File
+ 205
- 0
crypto/ed25519/ed25519.go
View File
| @ -0,0 +1,205 @@ | |||
| package ed25519 | |||
| import ( | |||
| "bytes" | |||
| "crypto/subtle" | |||
| "fmt" | |||
| "github.com/tendermint/ed25519" | |||
| "github.com/tendermint/ed25519/extra25519" | |||
| amino "github.com/tendermint/go-amino" | |||
| "github.com/tendermint/tendermint/crypto" | |||
| "github.com/tendermint/tendermint/crypto/tmhash" | |||
| cmn "github.com/tendermint/tendermint/libs/common" | |||
| ) | |||
| //------------------------------------- | |||
| var _ crypto.PrivKey = PrivKeyEd25519{} | |||
| const ( | |||
| Ed25519PrivKeyAminoRoute = "tendermint/PrivKeyEd25519" | |||
| Ed25519PubKeyAminoRoute = "tendermint/PubKeyEd25519" | |||
| Ed25519SignatureAminoRoute = "tendermint/SignatureEd25519" | |||
| ) | |||
| var cdc = amino.NewCodec() | |||
| func init() { | |||
| // NOTE: It's important that there be no conflicts here, | |||
| // as that would change the canonical representations, | |||
| // and therefore change the address. | |||
| // TODO: Add feature to go-amino to ensure that there | |||
| // are no conflicts. | |||
| cdc.RegisterInterface((*crypto.PubKey)(nil), nil) | |||
| cdc.RegisterConcrete(PubKeyEd25519{}, | |||
| Ed25519PubKeyAminoRoute, nil) | |||
| cdc.RegisterInterface((*crypto.PrivKey)(nil), nil) | |||
| cdc.RegisterConcrete(PrivKeyEd25519{}, | |||
| Ed25519PrivKeyAminoRoute, nil) | |||
| cdc.RegisterInterface((*crypto.Signature)(nil), nil) | |||
| cdc.RegisterConcrete(SignatureEd25519{}, | |||
| Ed25519SignatureAminoRoute, nil) | |||
| } | |||
| // Implements crypto.PrivKey | |||
| type PrivKeyEd25519 [64]byte | |||
| func (privKey PrivKeyEd25519) Bytes() []byte { | |||
| return cdc.MustMarshalBinaryBare(privKey) | |||
| } | |||
| func (privKey PrivKeyEd25519) Sign(msg []byte) (crypto.Signature, error) { | |||
| privKeyBytes := [64]byte(privKey) | |||
| signatureBytes := ed25519.Sign(&privKeyBytes, msg) | |||
| return SignatureEd25519(*signatureBytes), nil | |||
| } | |||
| func (privKey PrivKeyEd25519) PubKey() crypto.PubKey { | |||
| privKeyBytes := [64]byte(privKey) | |||
| pubBytes := *ed25519.MakePublicKey(&privKeyBytes) | |||
| return PubKeyEd25519(pubBytes) | |||
| } | |||
| // Equals - you probably don't need to use this. | |||
| // Runs in constant time based on length of the keys. | |||
| func (privKey PrivKeyEd25519) Equals(other crypto.PrivKey) bool { | |||
| if otherEd, ok := other.(PrivKeyEd25519); ok { | |||
| return subtle.ConstantTimeCompare(privKey[:], otherEd[:]) == 1 | |||
| } else { | |||
| return false | |||
| } | |||
| } | |||
| func (privKey PrivKeyEd25519) ToCurve25519() *[32]byte { | |||
| keyCurve25519 := new([32]byte) | |||
| privKeyBytes := [64]byte(privKey) | |||
| extra25519.PrivateKeyToCurve25519(keyCurve25519, &privKeyBytes) | |||
| return keyCurve25519 | |||
| } | |||
| // Deterministically generates new priv-key bytes from key. | |||
| func (privKey PrivKeyEd25519) Generate(index int) PrivKeyEd25519 { | |||
| bz, err := cdc.MarshalBinaryBare(struct { | |||
| PrivKey [64]byte | |||
| Index int | |||
| }{privKey, index}) | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| newBytes := crypto.Sha256(bz) | |||
| newKey := new([64]byte) | |||
| copy(newKey[:32], newBytes) | |||
| ed25519.MakePublicKey(newKey) | |||
| return PrivKeyEd25519(*newKey) | |||
| } | |||
| func GenPrivKeyEd25519() PrivKeyEd25519 { | |||
| privKeyBytes := new([64]byte) | |||
| copy(privKeyBytes[:32], crypto.CRandBytes(32)) | |||
| ed25519.MakePublicKey(privKeyBytes) | |||
| return PrivKeyEd25519(*privKeyBytes) | |||
| } | |||
| // NOTE: secret should be the output of a KDF like bcrypt, | |||
| // if it's derived from user input. | |||
| func GenPrivKeyEd25519FromSecret(secret []byte) PrivKeyEd25519 { | |||
| privKey32 := crypto.Sha256(secret) // Not Ripemd160 because we want 32 bytes. | |||
| privKeyBytes := new([64]byte) | |||
| copy(privKeyBytes[:32], privKey32) | |||
| ed25519.MakePublicKey(privKeyBytes) | |||
| return PrivKeyEd25519(*privKeyBytes) | |||
| } | |||
| //------------------------------------- | |||
| var _ crypto.PubKey = PubKeyEd25519{} | |||
| const PubKeyEd25519Size = 32 | |||
| // Implements PubKeyInner | |||
| type PubKeyEd25519 [PubKeyEd25519Size]byte | |||
| // Address is the SHA256-20 of the raw pubkey bytes. | |||
| func (pubKey PubKeyEd25519) Address() crypto.Address { | |||
| return crypto.Address(tmhash.Sum(pubKey[:])) | |||
| } | |||
| func (pubKey PubKeyEd25519) Bytes() []byte { | |||
| bz, err := cdc.MarshalBinaryBare(pubKey) | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| return bz | |||
| } | |||
| func (pubKey PubKeyEd25519) VerifyBytes(msg []byte, sig_ crypto.Signature) bool { | |||
| // make sure we use the same algorithm to sign | |||
| sig, ok := sig_.(SignatureEd25519) | |||
| if !ok { | |||
| return false | |||
| } | |||
| pubKeyBytes := [PubKeyEd25519Size]byte(pubKey) | |||
| sigBytes := [SignatureEd25519Size]byte(sig) | |||
| return ed25519.Verify(&pubKeyBytes, msg, &sigBytes) | |||
| } | |||
| // For use with golang/crypto/nacl/box | |||
| // If error, returns nil. | |||
| func (pubKey PubKeyEd25519) ToCurve25519() *[PubKeyEd25519Size]byte { | |||
| keyCurve25519, pubKeyBytes := new([PubKeyEd25519Size]byte), [PubKeyEd25519Size]byte(pubKey) | |||
| ok := extra25519.PublicKeyToCurve25519(keyCurve25519, &pubKeyBytes) | |||
| if !ok { | |||
| return nil | |||
| } | |||
| return keyCurve25519 | |||
| } | |||
| func (pubKey PubKeyEd25519) String() string { | |||
| return fmt.Sprintf("PubKeyEd25519{%X}", pubKey[:]) | |||
| } | |||
| func (pubKey PubKeyEd25519) Equals(other crypto.PubKey) bool { | |||
| if otherEd, ok := other.(PubKeyEd25519); ok { | |||
| return bytes.Equal(pubKey[:], otherEd[:]) | |||
| } else { | |||
| return false | |||
| } | |||
| } | |||
| //------------------------------------- | |||
| var _ crypto.Signature = SignatureEd25519{} | |||
| const SignatureEd25519Size = 64 | |||
| // Implements crypto.Signature | |||
| type SignatureEd25519 [SignatureEd25519Size]byte | |||
| func (sig SignatureEd25519) Bytes() []byte { | |||
| bz, err := cdc.MarshalBinaryBare(sig) | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| return bz | |||
| } | |||
| func (sig SignatureEd25519) IsZero() bool { return len(sig) == 0 } | |||
| func (sig SignatureEd25519) String() string { return fmt.Sprintf("/%X.../", cmn.Fingerprint(sig[:])) } | |||
| func (sig SignatureEd25519) Equals(other crypto.Signature) bool { | |||
| if otherEd, ok := other.(SignatureEd25519); ok { | |||
| return subtle.ConstantTimeCompare(sig[:], otherEd[:]) == 1 | |||
| } else { | |||
| return false | |||
| } | |||
| } | |||
| func SignatureEd25519FromBytes(data []byte) crypto.Signature { | |||
| var sig SignatureEd25519 | |||
| copy(sig[:], data) | |||
| return sig | |||
| } | |||
+ 40
- 0
crypto/ed25519/ed25519_test.go
View File
| @ -0,0 +1,40 @@ | |||
| package ed25519_test | |||
| import ( | |||
| "testing" | |||
| "github.com/stretchr/testify/assert" | |||
| "github.com/stretchr/testify/require" | |||
| "github.com/tendermint/tendermint/crypto" | |||
| "github.com/tendermint/tendermint/crypto/ed25519" | |||
| ) | |||
| func TestGeneratePrivKey(t *testing.T) { | |||
| testPriv := ed25519.GenPrivKeyEd25519() | |||
| testGenerate := testPriv.Generate(1) | |||
| signBytes := []byte("something to sign") | |||
| pub := testGenerate.PubKey() | |||
| sig, err := testGenerate.Sign(signBytes) | |||
| assert.NoError(t, err) | |||
| assert.True(t, pub.VerifyBytes(signBytes, sig)) | |||
| } | |||
| func TestSignAndValidateEd25519(t *testing.T) { | |||
| privKey := ed25519.GenPrivKeyEd25519() | |||
| pubKey := privKey.PubKey() | |||
| msg := crypto.CRandBytes(128) | |||
| sig, err := privKey.Sign(msg) | |||
| require.Nil(t, err) | |||
| // Test the signature | |||
| assert.True(t, pubKey.VerifyBytes(msg, sig)) | |||
| // Mutate the signature, just one bit. | |||
| sigEd := sig.(ed25519.SignatureEd25519) | |||
| sigEd[7] ^= byte(0x01) | |||
| sig = sigEd | |||
| assert.False(t, pubKey.VerifyBytes(msg, sig)) | |||
| } | |||
+ 56
- 0
crypto/encoding/amino/amino.go
View File
| @ -0,0 +1,56 @@ | |||
| package crypto | |||
| import ( | |||
| amino "github.com/tendermint/go-amino" | |||
| "github.com/tendermint/tendermint/crypto" | |||
| "github.com/tendermint/tendermint/crypto/ed25519" | |||
| "github.com/tendermint/tendermint/crypto/secp256k1" | |||
| ) | |||
| var cdc = amino.NewCodec() | |||
| func init() { | |||
| // NOTE: It's important that there be no conflicts here, | |||
| // as that would change the canonical representations, | |||
| // and therefore change the address. | |||
| // TODO: Add feature to go-amino to ensure that there | |||
| // are no conflicts. | |||
| RegisterAmino(cdc) | |||
| } | |||
| // RegisterAmino registers all crypto related types in the given (amino) codec. | |||
| func RegisterAmino(cdc *amino.Codec) { | |||
| // These are all written here instead of | |||
| cdc.RegisterInterface((*crypto.PubKey)(nil), nil) | |||
| cdc.RegisterConcrete(ed25519.PubKeyEd25519{}, | |||
| "tendermint/PubKeyEd25519", nil) | |||
| cdc.RegisterConcrete(secp256k1.PubKeySecp256k1{}, | |||
| "tendermint/PubKeySecp256k1", nil) | |||
| cdc.RegisterInterface((*crypto.PrivKey)(nil), nil) | |||
| cdc.RegisterConcrete(ed25519.PrivKeyEd25519{}, | |||
| "tendermint/PrivKeyEd25519", nil) | |||
| cdc.RegisterConcrete(secp256k1.PrivKeySecp256k1{}, | |||
| "tendermint/PrivKeySecp256k1", nil) | |||
| cdc.RegisterInterface((*crypto.Signature)(nil), nil) | |||
| cdc.RegisterConcrete(ed25519.SignatureEd25519{}, | |||
| "tendermint/SignatureEd25519", nil) | |||
| cdc.RegisterConcrete(secp256k1.SignatureSecp256k1{}, | |||
| "tendermint/SignatureSecp256k1", nil) | |||
| } | |||
| func PrivKeyFromBytes(privKeyBytes []byte) (privKey crypto.PrivKey, err error) { | |||
| err = cdc.UnmarshalBinaryBare(privKeyBytes, &privKey) | |||
| return | |||
| } | |||
| func PubKeyFromBytes(pubKeyBytes []byte) (pubKey crypto.PubKey, err error) { | |||
| err = cdc.UnmarshalBinaryBare(pubKeyBytes, &pubKey) | |||
| return | |||
| } | |||
| func SignatureFromBytes(pubKeyBytes []byte) (pubKey crypto.Signature, err error) { | |||
| err = cdc.UnmarshalBinaryBare(pubKeyBytes, &pubKey) | |||
| return | |||
| } | |||
crypto/encode_test.go → crypto/encoding/amino/encode_test.go
View File
+ 1
- 0
crypto/hash.go
View File
+ 1
- 0
crypto/hkdfchacha20poly1305/hkdfchachapoly.go
View File
+ 0
- 164
crypto/priv_key.go
View File
| @ -1,164 +0,0 @@ | |||
| package crypto | |||
| import ( | |||
| "crypto/subtle" | |||
| secp256k1 "github.com/btcsuite/btcd/btcec" | |||
| "github.com/tendermint/ed25519" | |||
| "github.com/tendermint/ed25519/extra25519" | |||
| ) | |||
| func PrivKeyFromBytes(privKeyBytes []byte) (privKey PrivKey, err error) { | |||
| err = cdc.UnmarshalBinaryBare(privKeyBytes, &privKey) | |||
| return | |||
| } | |||
| //---------------------------------------- | |||
| type PrivKey interface { | |||
| Bytes() []byte | |||
| Sign(msg []byte) (Signature, error) | |||
| PubKey() PubKey | |||
| Equals(PrivKey) bool | |||
| } | |||
| //------------------------------------- | |||
| var _ PrivKey = PrivKeyEd25519{} | |||
| // Implements PrivKey | |||
| type PrivKeyEd25519 [64]byte | |||
| func (privKey PrivKeyEd25519) Bytes() []byte { | |||
| return cdc.MustMarshalBinaryBare(privKey) | |||
| } | |||
| func (privKey PrivKeyEd25519) Sign(msg []byte) (Signature, error) { | |||
| privKeyBytes := [64]byte(privKey) | |||
| signatureBytes := ed25519.Sign(&privKeyBytes, msg) | |||
| return SignatureEd25519(*signatureBytes), nil | |||
| } | |||
| func (privKey PrivKeyEd25519) PubKey() PubKey { | |||
| privKeyBytes := [64]byte(privKey) | |||
| pubBytes := *ed25519.MakePublicKey(&privKeyBytes) | |||
| return PubKeyEd25519(pubBytes) | |||
| } | |||
| // Equals - you probably don't need to use this. | |||
| // Runs in constant time based on length of the keys. | |||
| func (privKey PrivKeyEd25519) Equals(other PrivKey) bool { | |||
| if otherEd, ok := other.(PrivKeyEd25519); ok { | |||
| return subtle.ConstantTimeCompare(privKey[:], otherEd[:]) == 1 | |||
| } else { | |||
| return false | |||
| } | |||
| } | |||
| func (privKey PrivKeyEd25519) ToCurve25519() *[32]byte { | |||
| keyCurve25519 := new([32]byte) | |||
| privKeyBytes := [64]byte(privKey) | |||
| extra25519.PrivateKeyToCurve25519(keyCurve25519, &privKeyBytes) | |||
| return keyCurve25519 | |||
| } | |||
| // Deterministically generates new priv-key bytes from key. | |||
| func (privKey PrivKeyEd25519) Generate(index int) PrivKeyEd25519 { | |||
| bz, err := cdc.MarshalBinaryBare(struct { | |||
| PrivKey [64]byte | |||
| Index int | |||
| }{privKey, index}) | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| newBytes := Sha256(bz) | |||
| newKey := new([64]byte) | |||
| copy(newKey[:32], newBytes) | |||
| ed25519.MakePublicKey(newKey) | |||
| return PrivKeyEd25519(*newKey) | |||
| } | |||
| func GenPrivKeyEd25519() PrivKeyEd25519 { | |||
| privKeyBytes := new([64]byte) | |||
| copy(privKeyBytes[:32], CRandBytes(32)) | |||
| ed25519.MakePublicKey(privKeyBytes) | |||
| return PrivKeyEd25519(*privKeyBytes) | |||
| } | |||
| // NOTE: secret should be the output of a KDF like bcrypt, | |||
| // if it's derived from user input. | |||
| func GenPrivKeyEd25519FromSecret(secret []byte) PrivKeyEd25519 { | |||
| privKey32 := Sha256(secret) // Not Ripemd160 because we want 32 bytes. | |||
| privKeyBytes := new([64]byte) | |||
| copy(privKeyBytes[:32], privKey32) | |||
| ed25519.MakePublicKey(privKeyBytes) | |||
| return PrivKeyEd25519(*privKeyBytes) | |||
| } | |||
| //------------------------------------- | |||
| var _ PrivKey = PrivKeySecp256k1{} | |||
| // Implements PrivKey | |||
| type PrivKeySecp256k1 [32]byte | |||
| func (privKey PrivKeySecp256k1) Bytes() []byte { | |||
| return cdc.MustMarshalBinaryBare(privKey) | |||
| } | |||
| func (privKey PrivKeySecp256k1) Sign(msg []byte) (Signature, error) { | |||
| priv__, _ := secp256k1.PrivKeyFromBytes(secp256k1.S256(), privKey[:]) | |||
| sig__, err := priv__.Sign(Sha256(msg)) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| return SignatureSecp256k1(sig__.Serialize()), nil | |||
| } | |||
| func (privKey PrivKeySecp256k1) PubKey() PubKey { | |||
| _, pub__ := secp256k1.PrivKeyFromBytes(secp256k1.S256(), privKey[:]) | |||
| var pub PubKeySecp256k1 | |||
| copy(pub[:], pub__.SerializeCompressed()) | |||
| return pub | |||
| } | |||
| // Equals - you probably don't need to use this. | |||
| // Runs in constant time based on length of the keys. | |||
| func (privKey PrivKeySecp256k1) Equals(other PrivKey) bool { | |||
| if otherSecp, ok := other.(PrivKeySecp256k1); ok { | |||
| return subtle.ConstantTimeCompare(privKey[:], otherSecp[:]) == 1 | |||
| } else { | |||
| return false | |||
| } | |||
| } | |||
| /* | |||
| // Deterministically generates new priv-key bytes from key. | |||
| func (key PrivKeySecp256k1) Generate(index int) PrivKeySecp256k1 { | |||
| newBytes := cdc.BinarySha256(struct { | |||
| PrivKey [64]byte | |||
| Index int | |||
| }{key, index}) | |||
| var newKey [64]byte | |||
| copy(newKey[:], newBytes) | |||
| return PrivKeySecp256k1(newKey) | |||
| } | |||
| */ | |||
| func GenPrivKeySecp256k1() PrivKeySecp256k1 { | |||
| privKeyBytes := [32]byte{} | |||
| copy(privKeyBytes[:], CRandBytes(32)) | |||
| priv, _ := secp256k1.PrivKeyFromBytes(secp256k1.S256(), privKeyBytes[:]) | |||
| copy(privKeyBytes[:], priv.Serialize()) | |||
| return PrivKeySecp256k1(privKeyBytes) | |||
| } | |||
| // NOTE: secret should be the output of a KDF like bcrypt, | |||
| // if it's derived from user input. | |||
| func GenPrivKeySecp256k1FromSecret(secret []byte) PrivKeySecp256k1 { | |||
| privKey32 := Sha256(secret) // Not Ripemd160 because we want 32 bytes. | |||
| priv, _ := secp256k1.PrivKeyFromBytes(secp256k1.S256(), privKey32) | |||
| privKeyBytes := [32]byte{} | |||
| copy(privKeyBytes[:], priv.Serialize()) | |||
| return PrivKeySecp256k1(privKeyBytes) | |||
| } | |||
+ 0
- 60
crypto/priv_key_test.go
View File
| @ -1,60 +0,0 @@ | |||
| package crypto_test | |||
| import ( | |||
| "testing" | |||
| "github.com/stretchr/testify/assert" | |||
| "github.com/tendermint/tendermint/crypto" | |||
| ) | |||
| func TestGeneratePrivKey(t *testing.T) { | |||
| testPriv := crypto.GenPrivKeyEd25519() | |||
| testGenerate := testPriv.Generate(1) | |||
| signBytes := []byte("something to sign") | |||
| pub := testGenerate.PubKey() | |||
| sig, err := testGenerate.Sign(signBytes) | |||
| assert.NoError(t, err) | |||
| assert.True(t, pub.VerifyBytes(signBytes, sig)) | |||
| } | |||
| /* | |||
| type BadKey struct { | |||
| PrivKeyEd25519 | |||
| } | |||
| func TestReadPrivKey(t *testing.T) { | |||
| assert, require := assert.New(t), require.New(t) | |||
| // garbage in, garbage out | |||
| garbage := []byte("hjgewugfbiewgofwgewr") | |||
| XXX This test wants to register BadKey globally to crypto, | |||
| but we don't want to support that. | |||
| _, err := PrivKeyFromBytes(garbage) | |||
| require.Error(err) | |||
| edKey := GenPrivKeyEd25519() | |||
| badKey := BadKey{edKey} | |||
| cases := []struct { | |||
| key PrivKey | |||
| valid bool | |||
| }{ | |||
| {edKey, true}, | |||
| {badKey, false}, | |||
| } | |||
| for i, tc := range cases { | |||
| data := tc.key.Bytes() | |||
| fmt.Println(">>>", data) | |||
| key, err := PrivKeyFromBytes(data) | |||
| fmt.Printf("!!! %#v\n", key, err) | |||
| if tc.valid { | |||
| assert.NoError(err, "%d", i) | |||
| assert.Equal(tc.key, key, "%d", i) | |||
| } else { | |||
| assert.Error(err, "%d: %#v", i, key) | |||
| } | |||
| } | |||
| } | |||
| */ | |||
+ 0
- 153
crypto/pub_key.go
View File
| @ -1,153 +0,0 @@ | |||
| package crypto | |||
| import ( | |||
| "bytes" | |||
| "crypto/sha256" | |||
| "fmt" | |||
| "golang.org/x/crypto/ripemd160" | |||
| secp256k1 "github.com/btcsuite/btcd/btcec" | |||
| "github.com/tendermint/ed25519" | |||
| "github.com/tendermint/ed25519/extra25519" | |||
| cmn "github.com/tendermint/tendermint/libs/common" | |||
| "github.com/tendermint/tendermint/crypto/tmhash" | |||
| ) | |||
| // An address is a []byte, but hex-encoded even in JSON. | |||
| // []byte leaves us the option to change the address length. | |||
| // Use an alias so Unmarshal methods (with ptr receivers) are available too. | |||
| type Address = cmn.HexBytes | |||
| func PubKeyFromBytes(pubKeyBytes []byte) (pubKey PubKey, err error) { | |||
| err = cdc.UnmarshalBinaryBare(pubKeyBytes, &pubKey) | |||
| return | |||
| } | |||
| //---------------------------------------- | |||
| type PubKey interface { | |||
| Address() Address | |||
| Bytes() []byte | |||
| VerifyBytes(msg []byte, sig Signature) bool | |||
| Equals(PubKey) bool | |||
| } | |||
| //------------------------------------- | |||
| var _ PubKey = PubKeyEd25519{} | |||
| const PubKeyEd25519Size = 32 | |||
| // Implements PubKeyInner | |||
| type PubKeyEd25519 [PubKeyEd25519Size]byte | |||
| // Address is the SHA256-20 of the raw pubkey bytes. | |||
| func (pubKey PubKeyEd25519) Address() Address { | |||
| return Address(tmhash.Sum(pubKey[:])) | |||
| } | |||
| func (pubKey PubKeyEd25519) Bytes() []byte { | |||
| bz, err := cdc.MarshalBinaryBare(pubKey) | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| return bz | |||
| } | |||
| func (pubKey PubKeyEd25519) VerifyBytes(msg []byte, sig_ Signature) bool { | |||
| // make sure we use the same algorithm to sign | |||
| sig, ok := sig_.(SignatureEd25519) | |||
| if !ok { | |||
| return false | |||
| } | |||
| pubKeyBytes := [PubKeyEd25519Size]byte(pubKey) | |||
| sigBytes := [SignatureEd25519Size]byte(sig) | |||
| return ed25519.Verify(&pubKeyBytes, msg, &sigBytes) | |||
| } | |||
| // For use with golang/crypto/nacl/box | |||
| // If error, returns nil. | |||
| func (pubKey PubKeyEd25519) ToCurve25519() *[PubKeyEd25519Size]byte { | |||
| keyCurve25519, pubKeyBytes := new([PubKeyEd25519Size]byte), [PubKeyEd25519Size]byte(pubKey) | |||
| ok := extra25519.PublicKeyToCurve25519(keyCurve25519, &pubKeyBytes) | |||
| if !ok { | |||
| return nil | |||
| } | |||
| return keyCurve25519 | |||
| } | |||
| func (pubKey PubKeyEd25519) String() string { | |||
| return fmt.Sprintf("PubKeyEd25519{%X}", pubKey[:]) | |||
| } | |||
| func (pubKey PubKeyEd25519) Equals(other PubKey) bool { | |||
| if otherEd, ok := other.(PubKeyEd25519); ok { | |||
| return bytes.Equal(pubKey[:], otherEd[:]) | |||
| } else { | |||
| return false | |||
| } | |||
| } | |||
| //------------------------------------- | |||
| var _ PubKey = PubKeySecp256k1{} | |||
| const PubKeySecp256k1Size = 33 | |||
| // Implements PubKey. | |||
| // Compressed pubkey (just the x-cord), | |||
| // prefixed with 0x02 or 0x03, depending on the y-cord. | |||
| type PubKeySecp256k1 [PubKeySecp256k1Size]byte | |||
| // Implements Bitcoin style addresses: RIPEMD160(SHA256(pubkey)) | |||
| func (pubKey PubKeySecp256k1) Address() Address { | |||
| hasherSHA256 := sha256.New() | |||
| hasherSHA256.Write(pubKey[:]) // does not error | |||
| sha := hasherSHA256.Sum(nil) | |||
| hasherRIPEMD160 := ripemd160.New() | |||
| hasherRIPEMD160.Write(sha) // does not error | |||
| return Address(hasherRIPEMD160.Sum(nil)) | |||
| } | |||
| func (pubKey PubKeySecp256k1) Bytes() []byte { | |||
| bz, err := cdc.MarshalBinaryBare(pubKey) | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| return bz | |||
| } | |||
| func (pubKey PubKeySecp256k1) VerifyBytes(msg []byte, sig_ Signature) bool { | |||
| // and assert same algorithm to sign and verify | |||
| sig, ok := sig_.(SignatureSecp256k1) | |||
| if !ok { | |||
| return false | |||
| } | |||
| pub__, err := secp256k1.ParsePubKey(pubKey[:], secp256k1.S256()) | |||
| if err != nil { | |||
| return false | |||
| } | |||
| sig__, err := secp256k1.ParseDERSignature(sig[:], secp256k1.S256()) | |||
| if err != nil { | |||
| return false | |||
| } | |||
| return sig__.Verify(Sha256(msg), pub__) | |||
| } | |||
| func (pubKey PubKeySecp256k1) String() string { | |||
| return fmt.Sprintf("PubKeySecp256k1{%X}", pubKey[:]) | |||
| } | |||
| func (pubKey PubKeySecp256k1) Equals(other PubKey) bool { | |||
| if otherSecp, ok := other.(PubKeySecp256k1); ok { | |||
| return bytes.Equal(pubKey[:], otherSecp[:]) | |||
| } else { | |||
| return false | |||
| } | |||
| } | |||
+ 205
- 0
crypto/secp256k1/secp256k1.go
View File
| @ -0,0 +1,205 @@ | |||
| package secp256k1 | |||
| import ( | |||
| "bytes" | |||
| "crypto/sha256" | |||
| "crypto/subtle" | |||
| "fmt" | |||
| secp256k1 "github.com/btcsuite/btcd/btcec" | |||
| amino "github.com/tendermint/go-amino" | |||
| "github.com/tendermint/tendermint/crypto" | |||
| "github.com/tendermint/tendermint/libs/common" | |||
| "golang.org/x/crypto/ripemd160" | |||
| ) | |||
| //------------------------------------- | |||
| const ( | |||
| Secp256k1PrivKeyAminoRoute = "tendermint/PrivKeySecp256k1" | |||
| Secp256k1PubKeyAminoRoute = "tendermint/PubKeySecp256k1" | |||
| Secp256k1SignatureAminoRoute = "tendermint/SignatureSecp256k1" | |||
| ) | |||
| var cdc = amino.NewCodec() | |||
| func init() { | |||
| // NOTE: It's important that there be no conflicts here, | |||
| // as that would change the canonical representations, | |||
| // and therefore change the address. | |||
| // TODO: Add feature to go-amino to ensure that there | |||
| // are no conflicts. | |||
| cdc.RegisterInterface((*crypto.PubKey)(nil), nil) | |||
| cdc.RegisterConcrete(PubKeySecp256k1{}, | |||
| Secp256k1PubKeyAminoRoute, nil) | |||
| cdc.RegisterInterface((*crypto.PrivKey)(nil), nil) | |||
| cdc.RegisterConcrete(PrivKeySecp256k1{}, | |||
| Secp256k1PrivKeyAminoRoute, nil) | |||
| cdc.RegisterInterface((*crypto.Signature)(nil), nil) | |||
| cdc.RegisterConcrete(SignatureSecp256k1{}, | |||
| Secp256k1SignatureAminoRoute, nil) | |||
| } | |||
| //------------------------------------- | |||
| var _ crypto.PrivKey = PrivKeySecp256k1{} | |||
| // Implements PrivKey | |||
| type PrivKeySecp256k1 [32]byte | |||
| func (privKey PrivKeySecp256k1) Bytes() []byte { | |||
| return cdc.MustMarshalBinaryBare(privKey) | |||
| } | |||
| func (privKey PrivKeySecp256k1) Sign(msg []byte) (crypto.Signature, error) { | |||
| priv__, _ := secp256k1.PrivKeyFromBytes(secp256k1.S256(), privKey[:]) | |||
| sig__, err := priv__.Sign(crypto.Sha256(msg)) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| return SignatureSecp256k1(sig__.Serialize()), nil | |||
| } | |||
| func (privKey PrivKeySecp256k1) PubKey() crypto.PubKey { | |||
| _, pub__ := secp256k1.PrivKeyFromBytes(secp256k1.S256(), privKey[:]) | |||
| var pub PubKeySecp256k1 | |||
| copy(pub[:], pub__.SerializeCompressed()) | |||
| return pub | |||
| } | |||
| // Equals - you probably don't need to use this. | |||
| // Runs in constant time based on length of the keys. | |||
| func (privKey PrivKeySecp256k1) Equals(other crypto.PrivKey) bool { | |||
| if otherSecp, ok := other.(PrivKeySecp256k1); ok { | |||
| return subtle.ConstantTimeCompare(privKey[:], otherSecp[:]) == 1 | |||
| } else { | |||
| return false | |||
| } | |||
| } | |||
| /* | |||
| // Deterministically generates new priv-key bytes from key. | |||
| func (key PrivKeySecp256k1) Generate(index int) PrivKeySecp256k1 { | |||
| newBytes := cdc.BinarySha256(struct { | |||
| PrivKey [64]byte | |||
| Index int | |||
| }{key, index}) | |||
| var newKey [64]byte | |||
| copy(newKey[:], newBytes) | |||
| return PrivKeySecp256k1(newKey) | |||
| } | |||
| */ | |||
| func GenPrivKeySecp256k1() PrivKeySecp256k1 { | |||
| privKeyBytes := [32]byte{} | |||
| copy(privKeyBytes[:], crypto.CRandBytes(32)) | |||
| priv, _ := secp256k1.PrivKeyFromBytes(secp256k1.S256(), privKeyBytes[:]) | |||
| copy(privKeyBytes[:], priv.Serialize()) | |||
| return PrivKeySecp256k1(privKeyBytes) | |||
| } | |||
| // NOTE: secret should be the output of a KDF like bcrypt, | |||
| // if it's derived from user input. | |||
| func GenPrivKeySecp256k1FromSecret(secret []byte) PrivKeySecp256k1 { | |||
| privKey32 := crypto.Sha256(secret) // Not Ripemd160 because we want 32 bytes. | |||
| priv, _ := secp256k1.PrivKeyFromBytes(secp256k1.S256(), privKey32) | |||
| privKeyBytes := [32]byte{} | |||
| copy(privKeyBytes[:], priv.Serialize()) | |||
| return PrivKeySecp256k1(privKeyBytes) | |||
| } | |||
| //------------------------------------- | |||
| var _ crypto.PubKey = PubKeySecp256k1{} | |||
| const PubKeySecp256k1Size = 33 | |||
| // Implements crypto.PubKey. | |||
| // Compressed pubkey (just the x-cord), | |||
| // prefixed with 0x02 or 0x03, depending on the y-cord. | |||
| type PubKeySecp256k1 [PubKeySecp256k1Size]byte | |||
| // Implements Bitcoin style addresses: RIPEMD160(SHA256(pubkey)) | |||
| func (pubKey PubKeySecp256k1) Address() crypto.Address { | |||
| hasherSHA256 := sha256.New() | |||
| hasherSHA256.Write(pubKey[:]) // does not error | |||
| sha := hasherSHA256.Sum(nil) | |||
| hasherRIPEMD160 := ripemd160.New() | |||
| hasherRIPEMD160.Write(sha) // does not error | |||
| return crypto.Address(hasherRIPEMD160.Sum(nil)) | |||
| } | |||
| func (pubKey PubKeySecp256k1) Bytes() []byte { | |||
| bz, err := cdc.MarshalBinaryBare(pubKey) | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| return bz | |||
| } | |||
| func (pubKey PubKeySecp256k1) VerifyBytes(msg []byte, sig_ crypto.Signature) bool { | |||
| // and assert same algorithm to sign and verify | |||
| sig, ok := sig_.(SignatureSecp256k1) | |||
| if !ok { | |||
| return false | |||
| } | |||
| pub__, err := secp256k1.ParsePubKey(pubKey[:], secp256k1.S256()) | |||
| if err != nil { | |||
| return false | |||
| } | |||
| sig__, err := secp256k1.ParseDERSignature(sig[:], secp256k1.S256()) | |||
| if err != nil { | |||
| return false | |||
| } | |||
| return sig__.Verify(crypto.Sha256(msg), pub__) | |||
| } | |||
| func (pubKey PubKeySecp256k1) String() string { | |||
| return fmt.Sprintf("PubKeySecp256k1{%X}", pubKey[:]) | |||
| } | |||
| func (pubKey PubKeySecp256k1) Equals(other crypto.PubKey) bool { | |||
| if otherSecp, ok := other.(PubKeySecp256k1); ok { | |||
| return bytes.Equal(pubKey[:], otherSecp[:]) | |||
| } else { | |||
| return false | |||
| } | |||
| } | |||
| //------------------------------------- | |||
| var _ crypto.Signature = SignatureSecp256k1{} | |||
| // Implements crypto.Signature | |||
| type SignatureSecp256k1 []byte | |||
| func (sig SignatureSecp256k1) Bytes() []byte { | |||
| bz, err := cdc.MarshalBinaryBare(sig) | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| return bz | |||
| } | |||
| func (sig SignatureSecp256k1) IsZero() bool { return len(sig) == 0 } | |||
| func (sig SignatureSecp256k1) String() string { | |||
| return fmt.Sprintf("/%X.../", common.Fingerprint(sig[:])) | |||
| } | |||
| func (sig SignatureSecp256k1) Equals(other crypto.Signature) bool { | |||
| if otherSecp, ok := other.(SignatureSecp256k1); ok { | |||
| return subtle.ConstantTimeCompare(sig[:], otherSecp[:]) == 1 | |||
| } else { | |||
| return false | |||
| } | |||
| } | |||
| func SignatureSecp256k1FromBytes(data []byte) crypto.Signature { | |||
| sig := make(SignatureSecp256k1, len(data)) | |||
| copy(sig[:], data) | |||
| return sig | |||
| } | |||
crypto/pub_key_test.go → crypto/secp256k1/secpk256k1_test.go
View File
+ 0
- 90
crypto/signature.go
View File
| @ -1,90 +0,0 @@ | |||
| package crypto | |||
| import ( | |||
| "fmt" | |||
| "crypto/subtle" | |||
| . "github.com/tendermint/tendermint/libs/common" | |||
| ) | |||
| func SignatureFromBytes(pubKeyBytes []byte) (pubKey Signature, err error) { | |||
| err = cdc.UnmarshalBinaryBare(pubKeyBytes, &pubKey) | |||
| return | |||
| } | |||
| //---------------------------------------- | |||
| type Signature interface { | |||
| Bytes() []byte | |||
| IsZero() bool | |||
| Equals(Signature) bool | |||
| } | |||
| //------------------------------------- | |||
| var _ Signature = SignatureEd25519{} | |||
| const SignatureEd25519Size = 64 | |||
| // Implements Signature | |||
| type SignatureEd25519 [SignatureEd25519Size]byte | |||
| func (sig SignatureEd25519) Bytes() []byte { | |||
| bz, err := cdc.MarshalBinaryBare(sig) | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| return bz | |||
| } | |||
| func (sig SignatureEd25519) IsZero() bool { return len(sig) == 0 } | |||
| func (sig SignatureEd25519) String() string { return fmt.Sprintf("/%X.../", Fingerprint(sig[:])) } | |||
| func (sig SignatureEd25519) Equals(other Signature) bool { | |||
| if otherEd, ok := other.(SignatureEd25519); ok { | |||
| return subtle.ConstantTimeCompare(sig[:], otherEd[:]) == 1 | |||
| } else { | |||
| return false | |||
| } | |||
| } | |||
| func SignatureEd25519FromBytes(data []byte) Signature { | |||
| var sig SignatureEd25519 | |||
| copy(sig[:], data) | |||
| return sig | |||
| } | |||
| //------------------------------------- | |||
| var _ Signature = SignatureSecp256k1{} | |||
| // Implements Signature | |||
| type SignatureSecp256k1 []byte | |||
| func (sig SignatureSecp256k1) Bytes() []byte { | |||
| bz, err := cdc.MarshalBinaryBare(sig) | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| return bz | |||
| } | |||
| func (sig SignatureSecp256k1) IsZero() bool { return len(sig) == 0 } | |||
| func (sig SignatureSecp256k1) String() string { return fmt.Sprintf("/%X.../", Fingerprint(sig[:])) } | |||
| func (sig SignatureSecp256k1) Equals(other Signature) bool { | |||
| if otherSecp, ok := other.(SignatureSecp256k1); ok { | |||
| return subtle.ConstantTimeCompare(sig[:], otherSecp[:]) == 1 | |||
| } else { | |||
| return false | |||
| } | |||
| } | |||
| func SignatureSecp256k1FromBytes(data []byte) Signature { | |||
| sig := make(SignatureSecp256k1, len(data)) | |||
| copy(sig[:], data) | |||
| return sig | |||
| } | |||
+ 0
- 46
crypto/signature_test.go
View File
| @ -1,46 +0,0 @@ | |||
| package crypto | |||
| import ( | |||
| "testing" | |||
| "github.com/stretchr/testify/assert" | |||
| "github.com/stretchr/testify/require" | |||
| ) | |||
| func TestSignAndValidateEd25519(t *testing.T) { | |||
| privKey := GenPrivKeyEd25519() | |||
| pubKey := privKey.PubKey() | |||
| msg := CRandBytes(128) | |||
| sig, err := privKey.Sign(msg) | |||
| require.Nil(t, err) | |||
| // Test the signature | |||
| assert.True(t, pubKey.VerifyBytes(msg, sig)) | |||
| // Mutate the signature, just one bit. | |||
| sigEd := sig.(SignatureEd25519) | |||
| sigEd[7] ^= byte(0x01) | |||
| sig = sigEd | |||
| assert.False(t, pubKey.VerifyBytes(msg, sig)) | |||
| } | |||
| func TestSignAndValidateSecp256k1(t *testing.T) { | |||
| privKey := GenPrivKeySecp256k1() | |||
| pubKey := privKey.PubKey() | |||
| msg := CRandBytes(128) | |||
| sig, err := privKey.Sign(msg) | |||
| require.Nil(t, err) | |||
| assert.True(t, pubKey.VerifyBytes(msg, sig)) | |||
| // Mutate the signature, just one bit. | |||
| sigEd := sig.(SignatureSecp256k1) | |||
| sigEd[3] ^= byte(0x01) | |||
| sig = sigEd | |||
| assert.False(t, pubKey.VerifyBytes(msg, sig)) | |||
| } | |||
crypto/symmetric.go → crypto/xsalsa20Symmetric/symmetric.go
View File
crypto/symmetric_test.go → crypto/xsalsa20Symmetric/symmetric_test.go
View File
+ 2
- 2
docs/spec/scripts/crypto.go
View File
+ 2
- 2
docs/tendermint-core/configuration.md
View File
+ 2
- 2
evidence/wire.go
View File
+ 5
- 4
libs/clist/clist_test.go
View File
+ 2
- 5
libs/common/os_test.go
View File
+ 13
- 75
libs/common/random.go
View File
+ 0
- 3
libs/common/random_test.go
View File
+ 1
- 2
libs/common/repeat_timer_test.go
View File
+ 5
- 5
libs/events/events_test.go
View File
+ 8
- 0
libs/pubsub/pubsub.go
View File
+ 3
- 3
libs/pubsub/query/Makefile
View File
| @ -1,10 +1,10 @@ | |||
| gen_query_parser: | |||
| @go get github.com/pointlander/peg | |||
| go get -u -v github.com/pointlander/peg | |||
| peg -inline -switch query.peg | |||
| fuzzy_test: | |||
| @go get github.com/dvyukov/go-fuzz/go-fuzz | |||
| @go get github.com/dvyukov/go-fuzz/go-fuzz-build | |||
| go get -u -v github.com/dvyukov/go-fuzz/go-fuzz | |||
| go get -u -v github.com/dvyukov/go-fuzz/go-fuzz-build | |||
| go-fuzz-build github.com/tendermint/tendermint/libs/pubsub/query/fuzz_test | |||
| go-fuzz -bin=./fuzz_test-fuzz.zip -workdir=./fuzz_test/output | |||
+ 2
- 0
libs/pubsub/query/query.peg.go
View File
+ 2
- 2
lite/files/wire.go
View File
+ 5
- 3
lite/helpers.go
View File
+ 6
- 3
lite/performance_test.go
View File
+ 9
- 5
node/node.go
View File
+ 10
- 0
node/node_test.go
View File
+ 2
- 2
node/wire.go
View File
+ 4
- 4
p2p/conn/secret_connection_test.go
View File
+ 2
- 2
p2p/conn/wire.go
View File
+ 2
- 1
p2p/key.go
View File
+ 3
- 4
p2p/peer_set_test.go
View File
+ 4
- 3
p2p/peer_test.go
View File
+ 6
- 7
p2p/pex/addrbook_test.go
View File
+ 2
- 1
p2p/pex/pex_reactor_test.go
View File
+ 4
- 4
p2p/switch_test.go
View File
+ 2
- 2
p2p/test_util.go
View File
+ 2
- 2
p2p/wire.go
View File
+ 2
- 1
privval/priv_validator.go
View File
+ 4
- 3
privval/priv_validator_test.go
View File
+ 5
- 4
privval/socket.go
View File
+ 8
- 8
privval/socket_test.go
View File
+ 2
- 2
privval/wire.go
View File
+ 1
- 1
rpc/client/localclient.go
View File
+ 0
- 2
rpc/core/doc.go
View File
+ 2
- 2
rpc/core/types/wire.go
View File
+ 2
- 3
rpc/lib/rpc_test.go
View File
+ 0
- 77
scripts/slate.sh
View File
| @ -1,77 +0,0 @@ | |||
| #!/usr/bin/env bash | |||
| set -euo pipefail | |||
| if [ "$CIRCLE_BRANCH" == "" ]; then | |||
| echo "this script is meant to be run on CircleCI, exiting" | |||
| echo 1 | |||
| fi | |||
| # check for changes in the `rpc/core` directory | |||
| did_rpc_change=$(git diff --name-status $CIRCLE_BRANCH origin/master | grep rpc/core) | |||
| if [ "$did_rpc_change" == "" ]; then | |||
| echo "no changes detected in rpc/core, exiting" | |||
| exit 0 | |||
| else | |||
| echo "changes detected in rpc/core, continuing" | |||
| fi | |||
| # only run this script on changes to rpc/core committed to develop | |||
| if [ "$CIRCLE_BRANCH" != "master" ]; then | |||
| echo "the branch being built isn't master, exiting" | |||
| exit 0 | |||
| else | |||
| echo "on master, building the RPC docs" | |||
| fi | |||
| # godoc2md used to convert the go documentation from | |||
| # `rpc/core` into a markdown file consumed by Slate | |||
| go get github.com/davecheney/godoc2md | |||
| # slate works via forks, and we'll be committing to | |||
| # master branch, which will trigger our fork to run | |||
| # the `./deploy.sh` and publish via the `gh-pages` branch | |||
| slate_repo=github.com/tendermint/slate | |||
| slate_path="$GOPATH"/src/"$slate_repo" | |||
| if [ ! -d "$slate_path" ]; then | |||
| git clone https://"$slate_repo".git $slate_path | |||
| fi | |||
| # the main file we need to update if rpc/core changed | |||
| destination="$slate_path"/source/index.html.md | |||
| # we remove it then re-create it with the latest changes | |||
| rm $destination | |||
| header="--- | |||
| title: RPC Reference | |||
| language_tabs: | |||
| - shell | |||
| - go | |||
| toc_footers: | |||
| - <a href='https://tendermint.com/'>Tendermint</a> | |||
| - <a href='https://github.com/lord/slate'>Documentation Powered by Slate</a> | |||
| search: true | |||
| ---" | |||
| # write header to the main slate file | |||
| echo "$header" > "$destination" | |||
| # generate a markdown from the godoc comments, using a template | |||
| rpc_docs=$(godoc2md -template rpc/core/doc_template.txt github.com/tendermint/tendermint/rpc/core | grep -v -e "pipe.go" -e "routes.go" -e "dev.go" | sed 's$/src/target$https://github.com/tendermint/tendermint/tree/master/rpc/core$') | |||
| # append core RPC docs | |||
| echo "$rpc_docs" >> "$destination" | |||
| # commit the changes | |||
| cd $slate_path | |||
| git config --global user.email "github@tendermint.com" | |||
| git config --global user.name "tenderbot" | |||
| git commit -a -m "Update tendermint RPC docs via CircleCI" | |||
| git push -q https://${GITHUB_ACCESS_TOKEN}@github.com/tendermint/slate.git master | |||
+ 12
- 11
scripts/wire2amino.go
View File
+ 4
- 4
state/execution_test.go
View File
+ 5
- 4
state/state_test.go
View File
+ 2
- 2
state/wire.go
View File
+ 0
- 335
tools/tm-bench/Gopkg.lock
View File
| @ -1,335 +0,0 @@ | |||
| # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'. | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/beorn7/perks" | |||
| packages = ["quantile"] | |||
| revision = "3a771d992973f24aa725d07868b467d1ddfceafb" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/btcsuite/btcd" | |||
| packages = ["btcec"] | |||
| revision = "fdfc19097e7ac6b57035062056f5b7b4638b8898" | |||
| [[projects]] | |||
| name = "github.com/davecgh/go-spew" | |||
| packages = ["spew"] | |||
| revision = "346938d642f2ec3594ed81d874461961cd0faa76" | |||
| version = "v1.1.0" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/ebuchman/fail-test" | |||
| packages = ["."] | |||
| revision = "95f809107225be108efcf10a3509e4ea6ceef3c4" | |||
| [[projects]] | |||
| name = "github.com/go-kit/kit" | |||
| packages = [ | |||
| "log", | |||
| "log/level", | |||
| "log/term", | |||
| "metrics", | |||
| "metrics/discard", | |||
| "metrics/internal/lv", | |||
| "metrics/prometheus" | |||
| ] | |||
| revision = "4dc7be5d2d12881735283bcab7352178e190fc71" | |||
| version = "v0.6.0" | |||
| [[projects]] | |||
| name = "github.com/go-logfmt/logfmt" | |||
| packages = ["."] | |||
| revision = "390ab7935ee28ec6b286364bba9b4dd6410cb3d5" | |||
| version = "v0.3.0" | |||
| [[projects]] | |||
| name = "github.com/go-stack/stack" | |||
| packages = ["."] | |||
| revision = "259ab82a6cad3992b4e21ff5cac294ccb06474bc" | |||
| version = "v1.7.0" | |||
| [[projects]] | |||
| name = "github.com/gogo/protobuf" | |||
| packages = [ | |||
| "gogoproto", | |||
| "jsonpb", | |||
| "proto", | |||
| "protoc-gen-gogo/descriptor", | |||
| "sortkeys", | |||
| "types" | |||
| ] | |||
| revision = "1adfc126b41513cc696b209667c8656ea7aac67c" | |||
| version = "v1.0.0" | |||
| [[projects]] | |||
| name = "github.com/golang/protobuf" | |||
| packages = [ | |||
| "proto", | |||
| "ptypes", | |||
| "ptypes/any", | |||
| "ptypes/duration", | |||
| "ptypes/timestamp" | |||
| ] | |||
| revision = "925541529c1fa6821df4e44ce2723319eb2be768" | |||
| version = "v1.0.0" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/golang/snappy" | |||
| packages = ["."] | |||
| revision = "2e65f85255dbc3072edf28d6b5b8efc472979f5a" | |||
| [[projects]] | |||
| name = "github.com/gorilla/websocket" | |||
| packages = ["."] | |||
| revision = "ea4d1f681babbce9545c9c5f3d5194a789c89f5b" | |||
| version = "v1.2.0" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/jmhodges/levigo" | |||
| packages = ["."] | |||
| revision = "c42d9e0ca023e2198120196f842701bb4c55d7b9" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/kr/logfmt" | |||
| packages = ["."] | |||
| revision = "b84e30acd515aadc4b783ad4ff83aff3299bdfe0" | |||
| [[projects]] | |||
| name = "github.com/matttproud/golang_protobuf_extensions" | |||
| packages = ["pbutil"] | |||
| revision = "c12348ce28de40eed0136aa2b644d0ee0650e56c" | |||
| version = "v1.0.1" | |||
| [[projects]] | |||
| name = "github.com/pkg/errors" | |||
| packages = ["."] | |||
| revision = "645ef00459ed84a119197bfb8d8205042c6df63d" | |||
| version = "v0.8.0" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/prometheus/client_golang" | |||
| packages = [ | |||
| "prometheus", | |||
| "prometheus/promhttp" | |||
| ] | |||
| revision = "ae27198cdd90bf12cd134ad79d1366a6cf49f632" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/prometheus/client_model" | |||
| packages = ["go"] | |||
| revision = "99fa1f4be8e564e8a6b613da7fa6f46c9edafc6c" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/prometheus/common" | |||
| packages = [ | |||
| "expfmt", | |||
| "internal/bitbucket.org/ww/goautoneg", | |||
| "model" | |||
| ] | |||
| revision = "7600349dcfe1abd18d72d3a1770870d9800a7801" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/prometheus/procfs" | |||
| packages = [ | |||
| ".", | |||
| "internal/util", | |||
| "nfs", | |||
| "xfs" | |||
| ] | |||
| revision = "ae68e2d4c00fed4943b5f6698d504a5fe083da8a" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/rcrowley/go-metrics" | |||
| packages = ["."] | |||
| revision = "e2704e165165ec55d062f5919b4b29494e9fa790" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/syndtr/goleveldb" | |||
| packages = [ | |||
| "leveldb", | |||
| "leveldb/cache", | |||
| "leveldb/comparer", | |||
| "leveldb/errors", | |||
| "leveldb/filter", | |||
| "leveldb/iterator", | |||
| "leveldb/journal", | |||
| "leveldb/memdb", | |||
| "leveldb/opt", | |||
| "leveldb/storage", | |||
| "leveldb/table", | |||
| "leveldb/util" | |||
| ] | |||
| revision = "c4c61651e9e37fa117f53c5a906d3b63090d8445" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/tendermint/ed25519" | |||
| packages = [ | |||
| ".", | |||
| "edwards25519", | |||
| "extra25519" | |||
| ] | |||
| revision = "d8387025d2b9d158cf4efb07e7ebf814bcce2057" | |||
| [[projects]] | |||
| name = "github.com/tendermint/go-amino" | |||
| packages = ["."] | |||
| revision = "2106ca61d91029c931fd54968c2bb02dc96b1412" | |||
| version = "0.10.1" | |||
| [[projects]] | |||
| branch = "develop" | |||
| name = "github.com/tendermint/tendermint" | |||
| packages = [ | |||
| "abci/client", | |||
| "abci/example/code", | |||
| "abci/example/kvstore", | |||
| "abci/types", | |||
| "blockchain", | |||
| "config", | |||
| "consensus", | |||
| "consensus/types", | |||
| "crypto", | |||
| "crypto/merkle", | |||
| "crypto/tmhash", | |||
| "evidence", | |||
| "libs/autofile", | |||
| "libs/clist", | |||
| "libs/common", | |||
| "libs/db", | |||
| "libs/events", | |||
| "libs/flowrate", | |||
| "libs/log", | |||
| "libs/pubsub", | |||
| "libs/pubsub/query", | |||
| "mempool", | |||
| "node", | |||
| "p2p", | |||
| "p2p/conn", | |||
| "p2p/pex", | |||
| "p2p/upnp", | |||
| "privval", | |||
| "proxy", | |||
| "rpc/client", | |||
| "rpc/core", | |||
| "rpc/core/types", | |||
| "rpc/grpc", | |||
| "rpc/lib", | |||
| "rpc/lib/client", | |||
| "rpc/lib/server", | |||
| "rpc/lib/types", | |||
| "state", | |||
| "state/txindex", | |||
| "state/txindex/kv", | |||
| "state/txindex/null", | |||
| "types", | |||
| "version" | |||
| ] | |||
| revision = "9d81a74429e093f3167875e0145ad957874c77d1" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "golang.org/x/crypto" | |||
| packages = [ | |||
| "curve25519", | |||
| "internal/subtle", | |||
| "nacl/box", | |||
| "nacl/secretbox", | |||
| "openpgp/armor", | |||
| "openpgp/errors", | |||
| "poly1305", | |||
| "ripemd160", | |||
| "salsa20/salsa" | |||
| ] | |||
| revision = "a49355c7e3f8fe157a85be2f77e6e269a0f89602" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "golang.org/x/net" | |||
| packages = [ | |||
| "context", | |||
| "http/httpguts", | |||
| "http2", | |||
| "http2/hpack", | |||
| "idna", | |||
| "internal/timeseries", | |||
| "netutil", | |||
| "trace" | |||
| ] | |||
| revision = "292b43bbf7cb8d35ddf40f8d5100ef3837cced3f" | |||
| [[projects]] | |||
| name = "golang.org/x/text" | |||
| packages = [ | |||
| "collate", | |||
| "collate/build", | |||
| "internal/colltab", | |||
| "internal/gen", | |||
| "internal/tag", | |||
| "internal/triegen", | |||
| "internal/ucd", | |||
| "language", | |||
| "secure/bidirule", | |||
| "transform", | |||
| "unicode/bidi", | |||
| "unicode/cldr", | |||
| "unicode/norm", | |||
| "unicode/rangetable" | |||
| ] | |||
| revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0" | |||
| version = "v0.3.0" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "google.golang.org/genproto" | |||
| packages = ["googleapis/rpc/status"] | |||
| revision = "e92b116572682a5b432ddd840aeaba2a559eeff1" | |||
| [[projects]] | |||
| name = "google.golang.org/grpc" | |||
| packages = [ | |||
| ".", | |||
| "balancer", | |||
| "balancer/base", | |||
| "balancer/roundrobin", | |||
| "codes", | |||
| "connectivity", | |||
| "credentials", | |||
| "encoding", | |||
| "encoding/proto", | |||
| "grpclb/grpc_lb_v1/messages", | |||
| "grpclog", | |||
| "internal", | |||
| "keepalive", | |||
| "metadata", | |||
| "naming", | |||
| "peer", | |||
| "resolver", | |||
| "resolver/dns", | |||
| "resolver/passthrough", | |||
| "stats", | |||
| "status", | |||
| "tap", | |||
| "transport" | |||
| ] | |||
| revision = "d11072e7ca9811b1100b80ca0269ac831f06d024" | |||
| version = "v1.11.3" | |||
| [solve-meta] | |||
| analyzer-name = "dep" | |||
| analyzer-version = 1 | |||
| inputs-digest = "bc54a74ffdfc09872726fcf5c72b5df882269dc1cd949ac3fbeac9a554fc25c6" | |||
| solver-name = "gps-cdcl" | |||
| solver-version = 1 | |||
+ 0
- 50
tools/tm-bench/Gopkg.toml
View File
| @ -1,50 +0,0 @@ | |||
| # Gopkg.toml example | |||
| # | |||
| # Refer to https://golang.github.io/dep/docs/Gopkg.toml.html | |||
| # for detailed Gopkg.toml documentation. | |||
| # | |||
| # required = ["github.com/user/thing/cmd/thing"] | |||
| # ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"] | |||
| # | |||
| # [[constraint]] | |||
| # name = "github.com/user/project" | |||
| # version = "1.0.0" | |||
| # | |||
| # [[constraint]] | |||
| # name = "github.com/user/project2" | |||
| # branch = "dev" | |||
| # source = "github.com/myfork/project2" | |||
| # | |||
| # [[override]] | |||
| # name = "github.com/x/y" | |||
| # version = "2.4.0" | |||
| # | |||
| # [prune] | |||
| # non-go = false | |||
| # go-tests = true | |||
| # unused-packages = true | |||
| [[constraint]] | |||
| name = "github.com/go-kit/kit" | |||
| version = "^0.6.0" | |||
| [[constraint]] | |||
| name = "github.com/gorilla/websocket" | |||
| version = "^1.2.0" | |||
| [[constraint]] | |||
| name = "github.com/pkg/errors" | |||
| version = "^0.8.0" | |||
| [[constraint]] | |||
| branch = "master" | |||
| name = "github.com/rcrowley/go-metrics" | |||
| [[constraint]] | |||
| name = "github.com/tendermint/tendermint" | |||
| branch = "develop" | |||
| [prune] | |||
| go-tests = true | |||
| unused-packages = true | |||
+ 1
- 67
tools/tm-bench/Makefile
View File
+ 17
- 6
tools/tm-bench/README.md
View File
+ 0
- 18
tools/tm-bench/bench_test.go
View File
| @ -1,18 +0,0 @@ | |||
| package main | |||
| import ( | |||
| "testing" | |||
| "time" | |||
| ) | |||
| func BenchmarkTimingPerTx(b *testing.B) { | |||
| startTime := time.Now() | |||
| endTime := startTime.Add(time.Second) | |||
| for i := 0; i < b.N; i++ { | |||
| if i%20 == 0 { | |||
| if time.Now().After(endTime) { | |||
| continue | |||
| } | |||
| } | |||
| } | |||
| } | |||
+ 28
- 149
tools/tm-bench/main.go
View File
+ 150
- 0
tools/tm-bench/statistics.go
View File
| @ -0,0 +1,150 @@ | |||
| package main | |||
| import ( | |||
| "encoding/json" | |||
| "fmt" | |||
| "math" | |||
| "os" | |||
| "text/tabwriter" | |||
| "time" | |||
| metrics "github.com/rcrowley/go-metrics" | |||
| tmrpc "github.com/tendermint/tendermint/rpc/client" | |||
| "github.com/tendermint/tendermint/types" | |||
| ) | |||
| type statistics struct { | |||
| TxsThroughput metrics.Histogram `json:"txs_per_sec"` | |||
| BlocksThroughput metrics.Histogram `json:"blocks_per_sec"` | |||
| } | |||
| // calculateStatistics calculates the tx / second, and blocks / second based | |||
| // off of the number the transactions and number of blocks that occurred from | |||
| // the start block, and the end time. | |||
| func calculateStatistics( | |||
| client tmrpc.Client, | |||
| minHeight int64, | |||
| timeStart time.Time, | |||
| duration int, | |||
| ) (*statistics, error) { | |||
| timeEnd := timeStart.Add(time.Duration(duration) * time.Second) | |||
| stats := &statistics{ | |||
| BlocksThroughput: metrics.NewHistogram(metrics.NewUniformSample(1000)), | |||
| TxsThroughput: metrics.NewHistogram(metrics.NewUniformSample(1000)), | |||
| } | |||
| var ( | |||
| numBlocksPerSec = make(map[int64]int64) | |||
| numTxsPerSec = make(map[int64]int64) | |||
| ) | |||
| // because during some seconds blocks won't be created... | |||
| for i := int64(0); i < int64(duration); i++ { | |||
| numBlocksPerSec[i] = 0 | |||
| numTxsPerSec[i] = 0 | |||
| } | |||
| blockMetas, err := getBlockMetas(client, minHeight, timeStart, timeEnd) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| // iterates from max height to min height | |||
| for _, blockMeta := range blockMetas { | |||
| // check if block was created after timeStart | |||
| if blockMeta.Header.Time.Before(timeStart) { | |||
| break | |||
| } | |||
| // check if block was created before timeEnd | |||
| if blockMeta.Header.Time.After(timeEnd) { | |||
| continue | |||
| } | |||
| sec := secondsSinceTimeStart(timeStart, blockMeta.Header.Time) | |||
| // increase number of blocks for that second | |||
| numBlocksPerSec[sec]++ | |||
| // increase number of txs for that second | |||
| numTxsPerSec[sec] += blockMeta.Header.NumTxs | |||
| logger.Debug(fmt.Sprintf("%d txs at block height %d", blockMeta.Header.NumTxs, blockMeta.Header.Height)) | |||
| } | |||
| for i := int64(0); i < int64(duration); i++ { | |||
| stats.BlocksThroughput.Update(numBlocksPerSec[i]) | |||
| stats.TxsThroughput.Update(numTxsPerSec[i]) | |||
| } | |||
| return stats, nil | |||
| } | |||
| func getBlockMetas(client tmrpc.Client, minHeight int64, timeStart, timeEnd time.Time) ([]*types.BlockMeta, error) { | |||
| // get blocks between minHeight and last height | |||
| // This returns max(minHeight,(last_height - 20)) to last_height | |||
| info, err := client.BlockchainInfo(minHeight, 0) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| var ( | |||
| blockMetas = info.BlockMetas | |||
| lastHeight = info.LastHeight | |||
| diff = lastHeight - minHeight | |||
| offset = len(blockMetas) | |||
| ) | |||
| for offset < int(diff) { | |||
| // get blocks between minHeight and last height | |||
| info, err := client.BlockchainInfo(minHeight, lastHeight-int64(offset)) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| blockMetas = append(blockMetas, info.BlockMetas...) | |||
| offset = len(blockMetas) | |||
| } | |||
| return blockMetas, nil | |||
| } | |||
| func secondsSinceTimeStart(timeStart, timePassed time.Time) int64 { | |||
| return int64(math.Round(timePassed.Sub(timeStart).Seconds())) | |||
| } | |||
| func printStatistics(stats *statistics, outputFormat string) { | |||
| if outputFormat == "json" { | |||
| result, err := json.Marshal(struct { | |||
| TxsThroughput float64 `json:"txs_per_sec_avg"` | |||
| BlocksThroughput float64 `json:"blocks_per_sec_avg"` | |||
| }{stats.TxsThroughput.Mean(), stats.BlocksThroughput.Mean()}) | |||
| if err != nil { | |||
| fmt.Fprintln(os.Stderr, err) | |||
| os.Exit(1) | |||
| } | |||
| fmt.Println(string(result)) | |||
| } else { | |||
| w := tabwriter.NewWriter(os.Stdout, 0, 0, 5, ' ', 0) | |||
| fmt.Fprintln(w, "Stats\tAvg\tStdDev\tMax\tTotal\t") | |||
| fmt.Fprintln( | |||
| w, | |||
| fmt.Sprintf( | |||
| "Txs/sec\t%.0f\t%.0f\t%d\t%d\t", | |||
| stats.TxsThroughput.Mean(), | |||
| stats.TxsThroughput.StdDev(), | |||
| stats.TxsThroughput.Max(), | |||
| stats.TxsThroughput.Sum(), | |||
| ), | |||
| ) | |||
| fmt.Fprintln( | |||
| w, | |||
| fmt.Sprintf("Blocks/sec\t%.3f\t%.3f\t%d\t%d\t", | |||
| stats.BlocksThroughput.Mean(), | |||
| stats.BlocksThroughput.StdDev(), | |||
| stats.BlocksThroughput.Max(), | |||
| stats.BlocksThroughput.Sum(), | |||
| ), | |||
| ) | |||
| w.Flush() | |||
| } | |||
| } | |||
+ 44
- 12
tools/tm-bench/transacter.go
View File
+ 104
- 0
tools/tm-bench/transacter_test.go
View File
| @ -0,0 +1,104 @@ | |||
| package main | |||
| import ( | |||
| "crypto/md5" | |||
| "encoding/hex" | |||
| "encoding/json" | |||
| "fmt" | |||
| "os" | |||
| "testing" | |||
| "time" | |||
| "github.com/pkg/errors" | |||
| "github.com/stretchr/testify/require" | |||
| ) | |||
| // This test tests that the output of generate tx and update tx is consistent | |||
| func TestGenerateTxUpdateTxConsistentency(t *testing.T) { | |||
| cases := []struct { | |||
| connIndex int | |||
| startingTxNumber int | |||
| txSize int | |||
| hostname string | |||
| numTxsToTest int | |||
| }{ | |||
| {0, 0, 50, "localhost:26657", 1000}, | |||
| {70, 300, 10000, "localhost:26657", 1000}, | |||
| {0, 50, 100000, "localhost:26657", 1000}, | |||
| } | |||
| for tcIndex, tc := range cases { | |||
| hostnameHash := md5.Sum([]byte(tc.hostname)) | |||
| // Tx generated from update tx. This is defined outside of the loop, since we have | |||
| // to a have something initially to update | |||
| updatedTx := generateTx(tc.connIndex, tc.startingTxNumber, tc.txSize, hostnameHash) | |||
| updatedHex := make([]byte, len(updatedTx)*2) | |||
| hex.Encode(updatedHex, updatedTx) | |||
| for i := 0; i < tc.numTxsToTest; i++ { | |||
| expectedTx := generateTx(tc.connIndex, tc.startingTxNumber+i, tc.txSize, hostnameHash) | |||
| expectedHex := make([]byte, len(expectedTx)*2) | |||
| hex.Encode(expectedHex, expectedTx) | |||
| updateTx(updatedTx, updatedHex, tc.startingTxNumber+i) | |||
| // after first 32 bytes is 8 bytes of time, then purely random bytes | |||
| require.Equal(t, expectedTx[:32], updatedTx[:32], | |||
| "First 32 bytes of the txs differed. tc #%d, i #%d", tcIndex, i) | |||
| require.Equal(t, expectedHex[:64], updatedHex[:64], | |||
| "First 64 bytes of the hex differed. tc #%d, i #%d", tcIndex, i) | |||
| // Test the lengths of the txs are as expected | |||
| require.Equal(t, tc.txSize, len(expectedTx), | |||
| "Length of expected Tx differed. tc #%d, i #%d", tcIndex, i) | |||
| require.Equal(t, tc.txSize, len(updatedTx), | |||
| "Length of expected Tx differed. tc #%d, i #%d", tcIndex, i) | |||
| require.Equal(t, tc.txSize*2, len(expectedHex), | |||
| "Length of expected hex differed. tc #%d, i #%d", tcIndex, i) | |||
| require.Equal(t, tc.txSize*2, len(updatedHex), | |||
| "Length of updated hex differed. tc #%d, i #%d", tcIndex, i) | |||
| } | |||
| } | |||
| } | |||
| func BenchmarkIterationOfSendLoop(b *testing.B) { | |||
| var ( | |||
| connIndex = 0 | |||
| txSize = 25000 | |||
| ) | |||
| now := time.Now() | |||
| // something too far away to matter | |||
| endTime := now.Add(time.Hour) | |||
| txNumber := 0 | |||
| hostnameHash := md5.Sum([]byte{0}) | |||
| tx := generateTx(connIndex, txNumber, txSize, hostnameHash) | |||
| txHex := make([]byte, len(tx)*2) | |||
| hex.Encode(txHex, tx) | |||
| b.ResetTimer() | |||
| for i := 0; i < b.N; i++ { | |||
| updateTx(tx, txHex, txNumber) | |||
| paramsJSON, err := json.Marshal(map[string]interface{}{"tx": txHex}) | |||
| if err != nil { | |||
| fmt.Printf("failed to encode params: %v\n", err) | |||
| os.Exit(1) | |||
| } | |||
| _ = json.RawMessage(paramsJSON) | |||
| _ = now.Add(sendTimeout) | |||
| if err != nil { | |||
| err = errors.Wrap(err, | |||
| fmt.Sprintf("txs send failed on connection #%d", connIndex)) | |||
| logger.Error(err.Error()) | |||
| return | |||
| } | |||
| // Cache the now operations | |||
| if i%5 == 0 { | |||
| now = time.Now() | |||
| if now.After(endTime) { | |||
| break | |||
| } | |||
| } | |||
| txNumber++ | |||
| } | |||
| } | |||
+ 0
- 326
tools/tm-monitor/Gopkg.lock
View File
| @ -1,326 +0,0 @@ | |||
| # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'. | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/beorn7/perks" | |||
| packages = ["quantile"] | |||
| revision = "3a771d992973f24aa725d07868b467d1ddfceafb" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/btcsuite/btcd" | |||
| packages = ["btcec"] | |||
| revision = "fdfc19097e7ac6b57035062056f5b7b4638b8898" | |||
| [[projects]] | |||
| name = "github.com/davecgh/go-spew" | |||
| packages = ["spew"] | |||
| revision = "346938d642f2ec3594ed81d874461961cd0faa76" | |||
| version = "v1.1.0" | |||
| [[projects]] | |||
| name = "github.com/ebuchman/fail-test" | |||
| packages = ["."] | |||
| revision = "95f809107225be108efcf10a3509e4ea6ceef3c4" | |||
| [[projects]] | |||
| name = "github.com/go-kit/kit" | |||
| packages = [ | |||
| "log", | |||
| "log/level", | |||
| "log/term", | |||
| "metrics", | |||
| "metrics/discard", | |||
| "metrics/internal/lv", | |||
| "metrics/prometheus" | |||
| ] | |||
| revision = "4dc7be5d2d12881735283bcab7352178e190fc71" | |||
| version = "v0.6.0" | |||
| [[projects]] | |||
| name = "github.com/go-logfmt/logfmt" | |||
| packages = ["."] | |||
| revision = "390ab7935ee28ec6b286364bba9b4dd6410cb3d5" | |||
| version = "v0.3.0" | |||
| [[projects]] | |||
| name = "github.com/go-stack/stack" | |||
| packages = ["."] | |||
| revision = "259ab82a6cad3992b4e21ff5cac294ccb06474bc" | |||
| version = "v1.7.0" | |||
| [[projects]] | |||
| name = "github.com/gogo/protobuf" | |||
| packages = [ | |||
| "gogoproto", | |||
| "jsonpb", | |||
| "proto", | |||
| "protoc-gen-gogo/descriptor", | |||
| "sortkeys", | |||
| "types" | |||
| ] | |||
| revision = "1adfc126b41513cc696b209667c8656ea7aac67c" | |||
| version = "v1.0.0" | |||
| [[projects]] | |||
| name = "github.com/golang/protobuf" | |||
| packages = [ | |||
| "proto", | |||
| "ptypes", | |||
| "ptypes/any", | |||
| "ptypes/duration", | |||
| "ptypes/timestamp" | |||
| ] | |||
| revision = "925541529c1fa6821df4e44ce2723319eb2be768" | |||
| version = "v1.0.0" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/golang/snappy" | |||
| packages = ["."] | |||
| revision = "2e65f85255dbc3072edf28d6b5b8efc472979f5a" | |||
| [[projects]] | |||
| name = "github.com/gorilla/websocket" | |||
| packages = ["."] | |||
| revision = "ea4d1f681babbce9545c9c5f3d5194a789c89f5b" | |||
| version = "v1.2.0" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/jmhodges/levigo" | |||
| packages = ["."] | |||
| revision = "c42d9e0ca023e2198120196f842701bb4c55d7b9" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/kr/logfmt" | |||
| packages = ["."] | |||
| revision = "b84e30acd515aadc4b783ad4ff83aff3299bdfe0" | |||
| [[projects]] | |||
| name = "github.com/matttproud/golang_protobuf_extensions" | |||
| packages = ["pbutil"] | |||
| revision = "c12348ce28de40eed0136aa2b644d0ee0650e56c" | |||
| version = "v1.0.1" | |||
| [[projects]] | |||
| name = "github.com/pkg/errors" | |||
| packages = ["."] | |||
| revision = "645ef00459ed84a119197bfb8d8205042c6df63d" | |||
| version = "v0.8.0" | |||
| [[projects]] | |||
| name = "github.com/pmezard/go-difflib" | |||
| packages = ["difflib"] | |||
| revision = "792786c7400a136282c1664665ae0a8db921c6c2" | |||
| version = "v1.0.0" | |||
| [[projects]] | |||
| name = "github.com/prometheus/client_golang" | |||
| packages = ["prometheus"] | |||
| revision = "ae27198cdd90bf12cd134ad79d1366a6cf49f632" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/prometheus/client_model" | |||
| packages = ["go"] | |||
| revision = "99fa1f4be8e564e8a6b613da7fa6f46c9edafc6c" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/prometheus/common" | |||
| packages = [ | |||
| "expfmt", | |||
| "internal/bitbucket.org/ww/goautoneg", | |||
| "model" | |||
| ] | |||
| revision = "7600349dcfe1abd18d72d3a1770870d9800a7801" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/prometheus/procfs" | |||
| packages = [ | |||
| ".", | |||
| "internal/util", | |||
| "nfs", | |||
| "xfs" | |||
| ] | |||
| revision = "ae68e2d4c00fed4943b5f6698d504a5fe083da8a" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/rcrowley/go-metrics" | |||
| packages = ["."] | |||
| revision = "e2704e165165ec55d062f5919b4b29494e9fa790" | |||
| [[projects]] | |||
| name = "github.com/stretchr/testify" | |||
| packages = [ | |||
| "assert", | |||
| "require" | |||
| ] | |||
| revision = "f35b8ab0b5a2cef36673838d662e249dd9c94686" | |||
| version = "v1.2.2" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/syndtr/goleveldb" | |||
| packages = [ | |||
| "leveldb", | |||
| "leveldb/cache", | |||
| "leveldb/comparer", | |||
| "leveldb/errors", | |||
| "leveldb/filter", | |||
| "leveldb/iterator", | |||
| "leveldb/journal", | |||
| "leveldb/memdb", | |||
| "leveldb/opt", | |||
| "leveldb/storage", | |||
| "leveldb/table", | |||
| "leveldb/util" | |||
| ] | |||
| revision = "c4c61651e9e37fa117f53c5a906d3b63090d8445" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "github.com/tendermint/ed25519" | |||
| packages = [ | |||
| ".", | |||
| "edwards25519", | |||
| "extra25519" | |||
| ] | |||
| revision = "d8387025d2b9d158cf4efb07e7ebf814bcce2057" | |||
| [[projects]] | |||
| name = "github.com/tendermint/go-amino" | |||
| packages = ["."] | |||
| revision = "2106ca61d91029c931fd54968c2bb02dc96b1412" | |||
| version = "0.10.1" | |||
| [[projects]] | |||
| name = "github.com/tendermint/tendermint" | |||
| packages = [ | |||
| "abci/client", | |||
| "abci/example/code", | |||
| "abci/example/kvstore", | |||
| "abci/types", | |||
| "config", | |||
| "crypto", | |||
| "crypto/merkle", | |||
| "crypto/tmhash", | |||
| "libs/common", | |||
| "libs/db", | |||
| "libs/events", | |||
| "libs/flowrate", | |||
| "libs/log", | |||
| "libs/pubsub", | |||
| "libs/pubsub/query", | |||
| "p2p", | |||
| "p2p/conn", | |||
| "p2p/upnp", | |||
| "proxy", | |||
| "rpc/core/types", | |||
| "rpc/lib/client", | |||
| "rpc/lib/server", | |||
| "rpc/lib/types", | |||
| "state", | |||
| "types" | |||
| ] | |||
| revision = "2aa2b63cadc42cca1071c36adfd2f2ce14e1aa8f" | |||
| version = "v0.22.3" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "golang.org/x/crypto" | |||
| packages = [ | |||
| "curve25519", | |||
| "internal/subtle", | |||
| "nacl/box", | |||
| "nacl/secretbox", | |||
| "openpgp/armor", | |||
| "openpgp/errors", | |||
| "poly1305", | |||
| "ripemd160", | |||
| "salsa20/salsa" | |||
| ] | |||
| revision = "a49355c7e3f8fe157a85be2f77e6e269a0f89602" | |||
| [[projects]] | |||
| name = "golang.org/x/net" | |||
| packages = [ | |||
| "context", | |||
| "http/httpguts", | |||
| "http2", | |||
| "http2/hpack", | |||
| "idna", | |||
| "internal/timeseries", | |||
| "netutil", | |||
| "trace" | |||
| ] | |||
| revision = "292b43bbf7cb8d35ddf40f8d5100ef3837cced3f" | |||
| [[projects]] | |||
| name = "golang.org/x/text" | |||
| packages = [ | |||
| "collate", | |||
| "collate/build", | |||
| "internal/colltab", | |||
| "internal/gen", | |||
| "internal/tag", | |||
| "internal/triegen", | |||
| "internal/ucd", | |||
| "language", | |||
| "secure/bidirule", | |||
| "transform", | |||
| "unicode/bidi", | |||
| "unicode/cldr", | |||
| "unicode/norm", | |||
| "unicode/rangetable" | |||
| ] | |||
| revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0" | |||
| version = "v0.3.0" | |||
| [[projects]] | |||
| branch = "master" | |||
| name = "google.golang.org/genproto" | |||
| packages = ["googleapis/rpc/status"] | |||
| revision = "e92b116572682a5b432ddd840aeaba2a559eeff1" | |||
| [[projects]] | |||
| name = "google.golang.org/grpc" | |||
| packages = [ | |||
| ".", | |||
| "balancer", | |||
| "balancer/base", | |||
| "balancer/roundrobin", | |||
| "codes", | |||
| "connectivity", | |||
| "credentials", | |||
| "encoding", | |||
| "encoding/proto", | |||
| "grpclb/grpc_lb_v1/messages", | |||
| "grpclog", | |||
| "internal", | |||
| "keepalive", | |||
| "metadata", | |||
| "naming", | |||
| "peer", | |||
| "resolver", | |||
| "resolver/dns", | |||
| "resolver/passthrough", | |||
| "stats", | |||
| "status", | |||
| "tap", | |||
| "transport" | |||
| ] | |||
| revision = "d11072e7ca9811b1100b80ca0269ac831f06d024" | |||
| version = "v1.11.3" | |||
| [solve-meta] | |||
| analyzer-name = "dep" | |||
| analyzer-version = 1 | |||
| inputs-digest = "b8644e2f33b8c04ed76a9cda1b6d7741a0e36844fdb0ce0d68717332779bcd75" | |||
| solver-name = "gps-cdcl" | |||
| solver-version = 1 | |||
+ 0
- 50
tools/tm-monitor/Gopkg.toml
View File
| @ -1,50 +0,0 @@ | |||
| # Gopkg.toml example | |||
| # | |||
| # Refer to https://golang.github.io/dep/docs/Gopkg.toml.html | |||
| # for detailed Gopkg.toml documentation. | |||
| # | |||
| # required = ["github.com/user/thing/cmd/thing"] | |||
| # ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"] | |||
| # | |||
| # [[constraint]] | |||
| # name = "github.com/user/project" | |||
| # version = "1.0.0" | |||
| # | |||
| # [[constraint]] | |||
| # name = "github.com/user/project2" | |||
| # branch = "dev" | |||
| # source = "github.com/myfork/project2" | |||
| # | |||
| # [[override]] | |||
| # name = "github.com/x/y" | |||
| # version = "2.4.0" | |||
| # | |||
| # [prune] | |||
| # non-go = false | |||
| # go-tests = true | |||
| # unused-packages = true | |||
| [[constraint]] | |||
| name = "github.com/pkg/errors" | |||
| version = "0.8.0" | |||
| [[constraint]] | |||
| branch = "master" | |||
| name = "github.com/rcrowley/go-metrics" | |||
| [[constraint]] | |||
| name = "github.com/stretchr/testify" | |||
| version = "1.2.1" | |||
| [[constraint]] | |||
| name = "github.com/tendermint/go-amino" | |||
| version = "~0.10.1" | |||
| [[constraint]] | |||
| name = "github.com/tendermint/tendermint" | |||
| version = "v0.22.3" | |||
| [prune] | |||
| go-tests = true | |||
| unused-packages = true | |||
+ 2
- 2
tools/tm-monitor/monitor/monitor_test.go
View File
+ 2
- 2
tools/tm-monitor/monitor/node_test.go
View File
+ 5
- 1
types/block.go
View File
+ 130
- 1
types/block_test.go
View File
+ 0
- 50
types/event_buffer.go
View File
| @ -1,50 +0,0 @@ | |||
| package types | |||
| // Interface assertions | |||
| var _ TxEventPublisher = (*TxEventBuffer)(nil) | |||
| // TxEventBuffer is a buffer of events, which uses a slice to temporarily store | |||
| // events. | |||
| type TxEventBuffer struct { | |||
| next TxEventPublisher | |||
| capacity int | |||
| events []EventDataTx | |||
| } | |||
| // NewTxEventBuffer accepts a TxEventPublisher and returns a new buffer with the given | |||
| // capacity. | |||
| func NewTxEventBuffer(next TxEventPublisher, capacity int) *TxEventBuffer { | |||
| return &TxEventBuffer{ | |||
| next: next, | |||
| capacity: capacity, | |||
| events: make([]EventDataTx, 0, capacity), | |||
| } | |||
| } | |||
| // Len returns the number of events cached. | |||
| func (b TxEventBuffer) Len() int { | |||
| return len(b.events) | |||
| } | |||
| // PublishEventTx buffers an event to be fired upon finality. | |||
| func (b *TxEventBuffer) PublishEventTx(e EventDataTx) error { | |||
| b.events = append(b.events, e) | |||
| return nil | |||
| } | |||
| // Flush publishes events by running next.PublishWithTags on all cached events. | |||
| // Blocks. Clears cached events. | |||
| func (b *TxEventBuffer) Flush() error { | |||
| for _, e := range b.events { | |||
| err := b.next.PublishEventTx(e) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| } | |||
| // Clear out the elements and set the length to 0 | |||
| // but maintain the underlying slice's capacity. | |||
| // See Issue https://github.com/tendermint/tendermint/issues/1189 | |||
| b.events = b.events[:0] | |||
| return nil | |||
| } | |||
+ 0
- 21
types/event_buffer_test.go
View File
| @ -1,21 +0,0 @@ | |||
| package types | |||
| import ( | |||
| "testing" | |||
| "github.com/stretchr/testify/assert" | |||
| ) | |||
| type eventBusMock struct{} | |||
| func (eventBusMock) PublishEventTx(e EventDataTx) error { | |||
| return nil | |||
| } | |||
| func TestEventBuffer(t *testing.T) { | |||
| b := NewTxEventBuffer(eventBusMock{}, 1) | |||
| b.PublishEventTx(EventDataTx{}) | |||
| assert.Equal(t, 1, b.Len()) | |||
| b.Flush() | |||
| assert.Equal(t, 0, b.Len()) | |||
| } | |||