Jae Kwon
6 years ago
40 changed files with 849 additions and 1892 deletions
Split View
Diff Options
-
+29 -128docs/architecture/adr-008-priv-validator.md
-
+19 -20types/block.go
-
+1 -2types/block_test.go
-
+28 -34types/canonical_json.go
-
+46 -52types/evidence.go
-
+13 -11types/evidence_test.go
-
+8 -10types/genesis.go
-
+18 -19types/genesis_test.go
-
+2 -6types/heartbeat.go
-
+5 -4types/heartbeat_test.go
-
+10 -11types/params.go
-
+39 -422types/priv_validator.go
-
+0 -197types/priv_validator/json.go
-
+345 -0types/priv_validator/priv_validator.go
-
+61 -92types/priv_validator/priv_validator_test.go
-
+0 -238types/priv_validator/sign_info.go
-
+90 -116types/priv_validator/socket.go
-
+1 -1types/priv_validator/socket_tcp.go
-
+1 -1types/priv_validator/socket_tcp_test.go
-
+33 -37types/priv_validator/socket_test.go
-
+0 -66types/priv_validator/unencrypted.go
-
+0 -59types/priv_validator/upgrade.go
-
+0 -21types/priv_validator/upgrade_pv/main.go
-
+13 -0types/priv_validator/wire.go
-
+0 -255types/priv_validator_test.go
-
+1 -5types/proposal.go
-
+14 -16types/proposal_test.go
-
+3 -3types/results.go
-
+8 -6types/results_test.go
-
+0 -5types/signable.go
-
+3 -3types/test_util.go
-
+8 -5types/tx.go
-
+9 -9types/tx_test.go
-
+5 -6types/validator.go
-
+10 -11types/validator_set.go
-
+3 -4types/validator_set_test.go
-
+1 -5types/vote.go
-
+1 -1types/vote_set_test.go
-
+9 -11types/vote_test.go
-
+12 -0types/wire.go
+ 29
- 128
docs/architecture/adr-008-priv-validator.md
View File
| @ -1,128 +1,29 @@ | |||
| # ADR 008: PrivValidator | |||
| ## Context | |||
| The current PrivValidator is monolithic and isn't easily reuseable by alternative signers. | |||
| For instance, see https://github.com/tendermint/tendermint/issues/673 | |||
| The goal is to have a clean PrivValidator interface like: | |||
| ``` | |||
| type PrivValidator interface { | |||
| Address() data.Bytes | |||
| PubKey() crypto.PubKey | |||
| SignVote(chainID string, vote *types.Vote) error | |||
| SignProposal(chainID string, proposal *types.Proposal) error | |||
| SignHeartbeat(chainID string, heartbeat *types.Heartbeat) error | |||
| } | |||
| ``` | |||
| It should also be easy to re-use the LastSignedInfo logic to avoid double signing. | |||
| ## Decision | |||
| Tendermint node's should support only two in-process PrivValidator implementations: | |||
| - PrivValidatorUnencrypted uses an unencrypted private key in a "priv_validator.json" file - no configuration required (just `tendermint init`). | |||
| - PrivValidatorSocket uses a socket to send signing requests to another process - user is responsible for starting that process themselves. | |||
| The PrivValidatorSocket address can be provided via flags at the command line - | |||
| doing so will cause Tendermint to ignore any "priv_validator.json" file and to listen | |||
| on the given address for incoming connections from an external priv_validator process. | |||
| It will halt any operation until at least one external process succesfully | |||
| connected. | |||
| The external priv_validator process will dial the address to connect to Tendermint, | |||
| and then Tendermint will send requests on the ensuing connection to sign votes and proposals. | |||
| Thus the external process initiates the connection, but the Tendermint process makes all requests. | |||
| In a later stage we're going to support multiple validators for fault | |||
| tolerance. To prevent double signing they need to be synced, which is deferred | |||
| to an external solution (see #1185). | |||
| In addition, Tendermint will provide implementations that can be run in that external process. | |||
| These include: | |||
| - PrivValidatorEncrypted uses an encrypted private key persisted to disk - user must enter password to decrypt key when process is started. | |||
| - PrivValidatorLedger uses a Ledger Nano S to handle all signing. | |||
| What follows are descriptions of useful types | |||
| ### Signer | |||
| ``` | |||
| type Signer interface { | |||
| Sign(msg []byte) (crypto.Signature, error) | |||
| } | |||
| ``` | |||
| Signer signs a message. It can also return an error. | |||
| ### ValidatorID | |||
| ValidatorID is just the Address and PubKey | |||
| ``` | |||
| type ValidatorID struct { | |||
| Address data.Bytes `json:"address"` | |||
| PubKey crypto.PubKey `json:"pub_key"` | |||
| } | |||
| ``` | |||
| ### LastSignedInfo | |||
| LastSignedInfo tracks the last thing we signed: | |||
| ``` | |||
| type LastSignedInfo struct { | |||
| Height int64 `json:"height"` | |||
| Round int `json:"round"` | |||
| Step int8 `json:"step"` | |||
| Signature crypto.Signature `json:"signature,omitempty"` // so we dont lose signatures | |||
| SignBytes data.Bytes `json:"signbytes,omitempty"` // so we dont lose signatures | |||
| } | |||
| ``` | |||
| It exposes methods for signing votes and proposals using a `Signer`. | |||
| This allows it to easily be reused by developers implemented their own PrivValidator. | |||
| ### PrivValidatorUnencrypted | |||
| ``` | |||
| type PrivValidatorUnencrypted struct { | |||
| ID types.ValidatorID `json:"id"` | |||
| PrivKey PrivKey `json:"priv_key"` | |||
| LastSignedInfo *LastSignedInfo `json:"last_signed_info"` | |||
| } | |||
| ``` | |||
| Has the same structure as currently, but broken up into sub structs. | |||
| Note the LastSignedInfo is mutated in place every time we sign. | |||
| ### PrivValidatorJSON | |||
| The "priv_validator.json" file supports only the PrivValidatorUnencrypted type. | |||
| It unmarshals into PrivValidatorJSON, which is used as the default PrivValidator type. | |||
| It wraps the PrivValidatorUnencrypted and persists it to disk after every signature. | |||
| ## Status | |||
| Accepted. | |||
| ## Consequences | |||
| ### Positive | |||
| - Cleaner separation of components enabling re-use. | |||
| ### Negative | |||
| - More files - led to creation of new directory. | |||
| ### Neutral | |||
| # ADR 008: SocketPV | |||
| Tendermint node's should support only two in-process PrivValidator | |||
| implementations: | |||
| - FilePV uses an unencrypted private key in a "priv_validator.json" file - no | |||
| configuration required (just `tendermint init`). | |||
| - SocketPV uses a socket to send signing requests to another process - user is | |||
| responsible for starting that process themselves. | |||
| The SocketPV address can be provided via flags at the command line - doing so | |||
| will cause Tendermint to ignore any "priv_validator.json" file and to listen on | |||
| the given address for incoming connections from an external priv_validator | |||
| process. It will halt any operation until at least one external process | |||
| succesfully connected. | |||
| The external priv_validator process will dial the address to connect to | |||
| Tendermint, and then Tendermint will send requests on the ensuing connection to | |||
| sign votes and proposals. Thus the external process initiates the connection, | |||
| but the Tendermint process makes all requests. In a later stage we're going to | |||
| support multiple validators for fault tolerance. To prevent double signing they | |||
| need to be synced, which is deferred to an external solution (see #1185). | |||
| In addition, Tendermint will provide implementations that can be run in that | |||
| external process. These include: | |||
| - FilePV will encrypt the private key, and the user must enter password to | |||
| decrypt key when process is started. | |||
| - LedgerPV uses a Ledger Nano S to handle all signing. | |||
+ 19
- 20
types/block.go
View File
+ 1
- 2
types/block_test.go
View File
+ 28
- 34
types/canonical_json.go
View File
+ 46
- 52
types/evidence.go
View File
+ 13
- 11
types/evidence_test.go
View File
+ 8
- 10
types/genesis.go
View File
+ 18
- 19
types/genesis_test.go
View File
+ 2
- 6
types/heartbeat.go
View File
+ 5
- 4
types/heartbeat_test.go
View File
+ 10
- 11
types/params.go
View File
+ 39
- 422
types/priv_validator.go
View File
+ 0
- 197
types/priv_validator/json.go
View File
| @ -1,197 +0,0 @@ | |||
| package types | |||
| import ( | |||
| "bytes" | |||
| "encoding/json" | |||
| "fmt" | |||
| "io/ioutil" | |||
| crypto "github.com/tendermint/go-crypto" | |||
| "github.com/tendermint/tendermint/types" | |||
| cmn "github.com/tendermint/tmlibs/common" | |||
| ) | |||
| // PrivValidator aliases types.PrivValidator | |||
| type PrivValidator = types.PrivValidator2 | |||
| //----------------------------------------------------- | |||
| // PrivKey implements Signer | |||
| type PrivKey crypto.PrivKey | |||
| // Sign - Implements Signer | |||
| func (pk PrivKey) Sign(msg []byte) (crypto.Signature, error) { | |||
| return crypto.PrivKey(pk).Sign(msg), nil | |||
| } | |||
| // MarshalJSON satisfies json.Marshaler. | |||
| func (pk PrivKey) MarshalJSON() ([]byte, error) { | |||
| return crypto.PrivKey(pk).MarshalJSON() | |||
| } | |||
| // UnmarshalJSON satisfies json.Unmarshaler. | |||
| func (pk *PrivKey) UnmarshalJSON(b []byte) error { | |||
| cpk := new(crypto.PrivKey) | |||
| if err := cpk.UnmarshalJSON(b); err != nil { | |||
| return err | |||
| } | |||
| *pk = (PrivKey)(*cpk) | |||
| return nil | |||
| } | |||
| //----------------------------------------------------- | |||
| var _ types.PrivValidator2 = (*PrivValidatorJSON)(nil) | |||
| // PrivValidatorJSON wraps PrivValidatorUnencrypted | |||
| // and persists it to disk after every SignVote and SignProposal. | |||
| type PrivValidatorJSON struct { | |||
| *PrivValidatorUnencrypted | |||
| filePath string | |||
| } | |||
| // SignVote implements PrivValidator. It persists to disk. | |||
| func (pvj *PrivValidatorJSON) SignVote(chainID string, vote *types.Vote) error { | |||
| err := pvj.PrivValidatorUnencrypted.SignVote(chainID, vote) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| pvj.Save() | |||
| return nil | |||
| } | |||
| // SignProposal implements PrivValidator. It persists to disk. | |||
| func (pvj *PrivValidatorJSON) SignProposal(chainID string, proposal *types.Proposal) error { | |||
| err := pvj.PrivValidatorUnencrypted.SignProposal(chainID, proposal) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| pvj.Save() | |||
| return nil | |||
| } | |||
| //------------------------------------------------------- | |||
| // String returns a string representation of the PrivValidatorJSON. | |||
| func (pvj *PrivValidatorJSON) String() string { | |||
| addr, err := pvj.Address() | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| return fmt.Sprintf("PrivValidator{%v %v}", addr, pvj.PrivValidatorUnencrypted.String()) | |||
| } | |||
| // Save persists the PrivValidatorJSON to disk. | |||
| func (pvj *PrivValidatorJSON) Save() { | |||
| pvj.save() | |||
| } | |||
| func (pvj *PrivValidatorJSON) save() { | |||
| if pvj.filePath == "" { | |||
| panic("Cannot save PrivValidator: filePath not set") | |||
| } | |||
| jsonBytes, err := json.Marshal(pvj) | |||
| if err != nil { | |||
| // ; BOOM!!! | |||
| panic(err) | |||
| } | |||
| err = cmn.WriteFileAtomic(pvj.filePath, jsonBytes, 0600) | |||
| if err != nil { | |||
| // ; BOOM!!! | |||
| panic(err) | |||
| } | |||
| } | |||
| // Reset resets the PrivValidatorUnencrypted. Panics if the Signer is the wrong type. | |||
| // NOTE: Unsafe! | |||
| func (pvj *PrivValidatorJSON) Reset() { | |||
| pvj.PrivValidatorUnencrypted.LastSignedInfo.Reset() | |||
| pvj.Save() | |||
| } | |||
| //---------------------------------------------------------------- | |||
| // GenPrivValidatorJSON generates a new validator with randomly generated private key | |||
| // and the given filePath. It does not persist to file. | |||
| func GenPrivValidatorJSON(filePath string) *PrivValidatorJSON { | |||
| privKey := crypto.GenPrivKeyEd25519().Wrap() | |||
| return &PrivValidatorJSON{ | |||
| PrivValidatorUnencrypted: NewPrivValidatorUnencrypted(privKey), | |||
| filePath: filePath, | |||
| } | |||
| } | |||
| // LoadPrivValidatorJSON loads a PrivValidatorJSON from the filePath. | |||
| func LoadPrivValidatorJSON(filePath string) *PrivValidatorJSON { | |||
| pvJSONBytes, err := ioutil.ReadFile(filePath) | |||
| if err != nil { | |||
| cmn.Exit(err.Error()) | |||
| } | |||
| pvj := PrivValidatorJSON{} | |||
| err = json.Unmarshal(pvJSONBytes, &pvj) | |||
| if err != nil { | |||
| cmn.Exit(cmn.Fmt("Error reading PrivValidatorJSON from %v: %v\n", filePath, err)) | |||
| } | |||
| // enable persistence | |||
| pvj.filePath = filePath | |||
| return &pvj | |||
| } | |||
| // LoadOrGenPrivValidatorJSON loads a PrivValidatorJSON from the given filePath | |||
| // or else generates a new one and saves it to the filePath. | |||
| func LoadOrGenPrivValidatorJSON(filePath string) *PrivValidatorJSON { | |||
| var pvj *PrivValidatorJSON | |||
| if cmn.FileExists(filePath) { | |||
| pvj = LoadPrivValidatorJSON(filePath) | |||
| } else { | |||
| pvj = GenPrivValidatorJSON(filePath) | |||
| pvj.Save() | |||
| } | |||
| return pvj | |||
| } | |||
| //-------------------------------------------------------------- | |||
| // NewTestPrivValidator returns a PrivValidatorJSON with a tempfile | |||
| // for the file path. | |||
| func NewTestPrivValidator(signer types.TestSigner) *PrivValidatorJSON { | |||
| _, tempFilePath := cmn.Tempfile("priv_validator_") | |||
| pv := &PrivValidatorJSON{ | |||
| PrivValidatorUnencrypted: NewPrivValidatorUnencrypted(signer.(*types.DefaultTestSigner).PrivKey), | |||
| filePath: tempFilePath, | |||
| } | |||
| return pv | |||
| } | |||
| //------------------------------------------------------ | |||
| // PrivValidatorsByAddress is a list of PrivValidatorJSON ordered by their | |||
| // addresses. | |||
| type PrivValidatorsByAddress []*PrivValidatorJSON | |||
| func (pvs PrivValidatorsByAddress) Len() int { | |||
| return len(pvs) | |||
| } | |||
| func (pvs PrivValidatorsByAddress) Less(i, j int) bool { | |||
| iaddr, err := pvs[j].Address() | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| jaddr, err := pvs[i].Address() | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| return bytes.Compare(iaddr, jaddr) == -1 | |||
| } | |||
| func (pvs PrivValidatorsByAddress) Swap(i, j int) { | |||
| it := pvs[i] | |||
| pvs[i] = pvs[j] | |||
| pvs[j] = it | |||
| } | |||
+ 345
- 0
types/priv_validator/priv_validator.go
View File
| @ -0,0 +1,345 @@ | |||
| package privval | |||
| import ( | |||
| "bytes" | |||
| "errors" | |||
| "fmt" | |||
| "io/ioutil" | |||
| "sync" | |||
| "time" | |||
| "github.com/tendermint/go-crypto" | |||
| "github.com/tendermint/tendermint/types" | |||
| cmn "github.com/tendermint/tmlibs/common" | |||
| ) | |||
| // TODO: type ? | |||
| const ( | |||
| stepNone int8 = 0 // Used to distinguish the initial state | |||
| stepPropose int8 = 1 | |||
| stepPrevote int8 = 2 | |||
| stepPrecommit int8 = 3 | |||
| ) | |||
| func voteToStep(vote *types.Vote) int8 { | |||
| switch vote.Type { | |||
| case types.VoteTypePrevote: | |||
| return stepPrevote | |||
| case types.VoteTypePrecommit: | |||
| return stepPrecommit | |||
| default: | |||
| cmn.PanicSanity("Unknown vote type") | |||
| return 0 | |||
| } | |||
| } | |||
| // FilePV implements PrivValidator using data persisted to disk | |||
| // to prevent double signing. | |||
| // NOTE: the directory containing the pv.filePath must already exist. | |||
| type FilePV struct { | |||
| Address types.Address `json:"address"` | |||
| PubKey crypto.PubKey `json:"pub_key"` | |||
| LastHeight int64 `json:"last_height"` | |||
| LastRound int `json:"last_round"` | |||
| LastStep int8 `json:"last_step"` | |||
| LastSignature crypto.Signature `json:"last_signature,omitempty"` // so we dont lose signatures XXX Why would we lose signatures? | |||
| LastSignBytes cmn.HexBytes `json:"last_signbytes,omitempty"` // so we dont lose signatures XXX Why would we lose signatures? | |||
| PrivKey crypto.PrivKey `json:"priv_key"` | |||
| // For persistence. | |||
| // Overloaded for testing. | |||
| filePath string | |||
| mtx sync.Mutex | |||
| } | |||
| // GetAddress returns the address of the validator. | |||
| // Implements PrivValidator. | |||
| func (pv *FilePV) GetAddress() types.Address { | |||
| return pv.Address | |||
| } | |||
| // GetPubKey returns the public key of the validator. | |||
| // Implements PrivValidator. | |||
| func (pv *FilePV) GetPubKey() crypto.PubKey { | |||
| return pv.PubKey | |||
| } | |||
| // GenFilePV generates a new validator with randomly generated private key | |||
| // and sets the filePath, but does not call Save(). | |||
| func GenFilePV(filePath string) *FilePV { | |||
| privKey := crypto.GenPrivKeyEd25519() | |||
| return &FilePV{ | |||
| Address: privKey.PubKey().Address(), | |||
| PubKey: privKey.PubKey(), | |||
| PrivKey: privKey, | |||
| LastStep: stepNone, | |||
| filePath: filePath, | |||
| } | |||
| } | |||
| // LoadFilePV loads a FilePV from the filePath. The FilePV handles double | |||
| // signing prevention by persisting data to the filePath. If the filePath does | |||
| // not exist, the FilePV must be created manually and saved. | |||
| func LoadFilePV(filePath string) *FilePV { | |||
| pvJSONBytes, err := ioutil.ReadFile(filePath) | |||
| if err != nil { | |||
| cmn.Exit(err.Error()) | |||
| } | |||
| pv := &FilePV{} | |||
| err = cdc.UnmarshalJSON(pvJSONBytes, &pv) | |||
| if err != nil { | |||
| cmn.Exit(cmn.Fmt("Error reading PrivValidator from %v: %v\n", filePath, err)) | |||
| } | |||
| pv.filePath = filePath | |||
| return pv | |||
| } | |||
| // LoadOrGenFilePV loads a FilePV from the given filePath | |||
| // or else generates a new one and saves it to the filePath. | |||
| func LoadOrGenFilePV(filePath string) *FilePV { | |||
| var pv *FilePV | |||
| if cmn.FileExists(filePath) { | |||
| pv = LoadFilePV(filePath) | |||
| } else { | |||
| pv = GenFilePV(filePath) | |||
| pv.Save() | |||
| } | |||
| return pv | |||
| } | |||
| // Save persists the FilePV to disk. | |||
| func (pv *FilePV) Save() { | |||
| pv.mtx.Lock() | |||
| defer pv.mtx.Unlock() | |||
| pv.save() | |||
| } | |||
| func (pv *FilePV) save() { | |||
| outFile := pv.filePath | |||
| if outFile == "" { | |||
| panic("Cannot save PrivValidator: filePath not set") | |||
| } | |||
| jsonBytes, err := cdc.MarshalJSON(pv) | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| err = cmn.WriteFileAtomic(outFile, jsonBytes, 0600) | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| } | |||
| // Reset resets all fields in the FilePV. | |||
| // NOTE: Unsafe! | |||
| func (pv *FilePV) Reset() { | |||
| var sig crypto.Signature | |||
| pv.LastHeight = 0 | |||
| pv.LastRound = 0 | |||
| pv.LastStep = 0 | |||
| pv.LastSignature = sig | |||
| pv.LastSignBytes = nil | |||
| pv.Save() | |||
| } | |||
| // SignVote signs a canonical representation of the vote, along with the | |||
| // chainID. Implements PrivValidator. | |||
| func (pv *FilePV) SignVote(chainID string, vote *types.Vote) error { | |||
| pv.mtx.Lock() | |||
| defer pv.mtx.Unlock() | |||
| if err := pv.signVote(chainID, vote); err != nil { | |||
| return errors.New(cmn.Fmt("Error signing vote: %v", err)) | |||
| } | |||
| return nil | |||
| } | |||
| // SignProposal signs a canonical representation of the proposal, along with | |||
| // the chainID. Implements PrivValidator. | |||
| func (pv *FilePV) SignProposal(chainID string, proposal *types.Proposal) error { | |||
| pv.mtx.Lock() | |||
| defer pv.mtx.Unlock() | |||
| if err := pv.signProposal(chainID, proposal); err != nil { | |||
| return fmt.Errorf("Error signing proposal: %v", err) | |||
| } | |||
| return nil | |||
| } | |||
| // returns error if HRS regression or no LastSignBytes. returns true if HRS is unchanged | |||
| func (pv *FilePV) checkHRS(height int64, round int, step int8) (bool, error) { | |||
| if pv.LastHeight > height { | |||
| return false, errors.New("Height regression") | |||
| } | |||
| if pv.LastHeight == height { | |||
| if pv.LastRound > round { | |||
| return false, errors.New("Round regression") | |||
| } | |||
| if pv.LastRound == round { | |||
| if pv.LastStep > step { | |||
| return false, errors.New("Step regression") | |||
| } else if pv.LastStep == step { | |||
| if pv.LastSignBytes != nil { | |||
| if pv.LastSignature == nil { | |||
| panic("pv: LastSignature is nil but LastSignBytes is not!") | |||
| } | |||
| return true, nil | |||
| } | |||
| return false, errors.New("No LastSignature found") | |||
| } | |||
| } | |||
| } | |||
| return false, nil | |||
| } | |||
| // signVote checks if the vote is good to sign and sets the vote signature. | |||
| // It may need to set the timestamp as well if the vote is otherwise the same as | |||
| // a previously signed vote (ie. we crashed after signing but before the vote hit the WAL). | |||
| func (pv *FilePV) signVote(chainID string, vote *types.Vote) error { | |||
| height, round, step := vote.Height, vote.Round, voteToStep(vote) | |||
| signBytes := vote.SignBytes(chainID) | |||
| sameHRS, err := pv.checkHRS(height, round, step) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| // We might crash before writing to the wal, | |||
| // causing us to try to re-sign for the same HRS. | |||
| // If signbytes are the same, use the last signature. | |||
| // If they only differ by timestamp, use last timestamp and signature | |||
| // Otherwise, return error | |||
| if sameHRS { | |||
| if bytes.Equal(signBytes, pv.LastSignBytes) { | |||
| vote.Signature = pv.LastSignature | |||
| } else if timestamp, ok := checkVotesOnlyDifferByTimestamp(pv.LastSignBytes, signBytes); ok { | |||
| vote.Timestamp = timestamp | |||
| vote.Signature = pv.LastSignature | |||
| } else { | |||
| err = fmt.Errorf("Conflicting data") | |||
| } | |||
| return err | |||
| } | |||
| // It passed the checks. Sign the vote | |||
| sig := pv.PrivKey.Sign(signBytes) | |||
| pv.saveSigned(height, round, step, signBytes, sig) | |||
| vote.Signature = sig | |||
| return nil | |||
| } | |||
| // signProposal checks if the proposal is good to sign and sets the proposal signature. | |||
| // It may need to set the timestamp as well if the proposal is otherwise the same as | |||
| // a previously signed proposal ie. we crashed after signing but before the proposal hit the WAL). | |||
| func (pv *FilePV) signProposal(chainID string, proposal *types.Proposal) error { | |||
| height, round, step := proposal.Height, proposal.Round, stepPropose | |||
| signBytes := proposal.SignBytes(chainID) | |||
| sameHRS, err := pv.checkHRS(height, round, step) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| // We might crash before writing to the wal, | |||
| // causing us to try to re-sign for the same HRS. | |||
| // If signbytes are the same, use the last signature. | |||
| // If they only differ by timestamp, use last timestamp and signature | |||
| // Otherwise, return error | |||
| if sameHRS { | |||
| if bytes.Equal(signBytes, pv.LastSignBytes) { | |||
| proposal.Signature = pv.LastSignature | |||
| } else if timestamp, ok := checkProposalsOnlyDifferByTimestamp(pv.LastSignBytes, signBytes); ok { | |||
| proposal.Timestamp = timestamp | |||
| proposal.Signature = pv.LastSignature | |||
| } else { | |||
| err = fmt.Errorf("Conflicting data") | |||
| } | |||
| return err | |||
| } | |||
| // It passed the checks. Sign the proposal | |||
| sig := pv.PrivKey.Sign(signBytes) | |||
| pv.saveSigned(height, round, step, signBytes, sig) | |||
| proposal.Signature = sig | |||
| return nil | |||
| } | |||
| // Persist height/round/step and signature | |||
| func (pv *FilePV) saveSigned(height int64, round int, step int8, | |||
| signBytes []byte, sig crypto.Signature) { | |||
| pv.LastHeight = height | |||
| pv.LastRound = round | |||
| pv.LastStep = step | |||
| pv.LastSignature = sig | |||
| pv.LastSignBytes = signBytes | |||
| pv.save() | |||
| } | |||
| // SignHeartbeat signs a canonical representation of the heartbeat, along with the chainID. | |||
| // Implements PrivValidator. | |||
| func (pv *FilePV) SignHeartbeat(chainID string, heartbeat *types.Heartbeat) error { | |||
| pv.mtx.Lock() | |||
| defer pv.mtx.Unlock() | |||
| heartbeat.Signature = pv.PrivKey.Sign(heartbeat.SignBytes(chainID)) | |||
| return nil | |||
| } | |||
| // String returns a string representation of the FilePV. | |||
| func (pv *FilePV) String() string { | |||
| return fmt.Sprintf("PrivValidator{%v LH:%v, LR:%v, LS:%v}", pv.GetAddress(), pv.LastHeight, pv.LastRound, pv.LastStep) | |||
| } | |||
| //------------------------------------- | |||
| // returns the timestamp from the lastSignBytes. | |||
| // returns true if the only difference in the votes is their timestamp. | |||
| func checkVotesOnlyDifferByTimestamp(lastSignBytes, newSignBytes []byte) (time.Time, bool) { | |||
| var lastVote, newVote types.CanonicalJSONVote | |||
| if err := cdc.UnmarshalJSON(lastSignBytes, &lastVote); err != nil { | |||
| panic(fmt.Sprintf("LastSignBytes cannot be unmarshalled into vote: %v", err)) | |||
| } | |||
| if err := cdc.UnmarshalJSON(newSignBytes, &newVote); err != nil { | |||
| panic(fmt.Sprintf("signBytes cannot be unmarshalled into vote: %v", err)) | |||
| } | |||
| lastTime, err := time.Parse(types.TimeFormat, lastVote.Timestamp) | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| // set the times to the same value and check equality | |||
| now := types.CanonicalTime(time.Now()) | |||
| lastVote.Timestamp = now | |||
| newVote.Timestamp = now | |||
| lastVoteBytes, _ := cdc.MarshalJSON(lastVote) | |||
| newVoteBytes, _ := cdc.MarshalJSON(newVote) | |||
| return lastTime, bytes.Equal(newVoteBytes, lastVoteBytes) | |||
| } | |||
| // returns the timestamp from the lastSignBytes. | |||
| // returns true if the only difference in the proposals is their timestamp | |||
| func checkProposalsOnlyDifferByTimestamp(lastSignBytes, newSignBytes []byte) (time.Time, bool) { | |||
| var lastProposal, newProposal types.CanonicalJSONProposal | |||
| if err := cdc.UnmarshalJSON(lastSignBytes, &lastProposal); err != nil { | |||
| panic(fmt.Sprintf("LastSignBytes cannot be unmarshalled into proposal: %v", err)) | |||
| } | |||
| if err := cdc.UnmarshalJSON(newSignBytes, &newProposal); err != nil { | |||
| panic(fmt.Sprintf("signBytes cannot be unmarshalled into proposal: %v", err)) | |||
| } | |||
| lastTime, err := time.Parse(types.TimeFormat, lastProposal.Timestamp) | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| // set the times to the same value and check equality | |||
| now := types.CanonicalTime(time.Now()) | |||
| lastProposal.Timestamp = now | |||
| newProposal.Timestamp = now | |||
| lastProposalBytes, _ := cdc.MarshalJSON(lastProposal) | |||
| newProposalBytes, _ := cdc.MarshalJSON(newProposal) | |||
| return lastTime, bytes.Equal(newProposalBytes, lastProposalBytes) | |||
| } | |||
+ 61
- 92
types/priv_validator/priv_validator_test.go
View File
+ 0
- 238
types/priv_validator/sign_info.go
View File
| @ -1,238 +0,0 @@ | |||
| package types | |||
| import ( | |||
| "bytes" | |||
| "encoding/json" | |||
| "errors" | |||
| "fmt" | |||
| "time" | |||
| crypto "github.com/tendermint/go-crypto" | |||
| "github.com/tendermint/tendermint/types" | |||
| cmn "github.com/tendermint/tmlibs/common" | |||
| ) | |||
| // TODO: type ? | |||
| const ( | |||
| stepNone int8 = 0 // Used to distinguish the initial state | |||
| stepPropose int8 = 1 | |||
| stepPrevote int8 = 2 | |||
| stepPrecommit int8 = 3 | |||
| ) | |||
| func voteToStep(vote *types.Vote) int8 { | |||
| switch vote.Type { | |||
| case types.VoteTypePrevote: | |||
| return stepPrevote | |||
| case types.VoteTypePrecommit: | |||
| return stepPrecommit | |||
| default: | |||
| panic("Unknown vote type") | |||
| } | |||
| } | |||
| //------------------------------------- | |||
| // LastSignedInfo contains information about the latest | |||
| // data signed by a validator to help prevent double signing. | |||
| type LastSignedInfo struct { | |||
| Height int64 `json:"height"` | |||
| Round int `json:"round"` | |||
| Step int8 `json:"step"` | |||
| Signature crypto.Signature `json:"signature,omitempty"` // so we dont lose signatures | |||
| SignBytes cmn.HexBytes `json:"signbytes,omitempty"` // so we dont lose signatures | |||
| } | |||
| func NewLastSignedInfo() *LastSignedInfo { | |||
| return &LastSignedInfo{ | |||
| Step: stepNone, | |||
| } | |||
| } | |||
| func (info *LastSignedInfo) String() string { | |||
| return fmt.Sprintf("LH:%v, LR:%v, LS:%v", info.Height, info.Round, info.Step) | |||
| } | |||
| // Verify returns an error if there is a height/round/step regression | |||
| // or if the HRS matches but there are no LastSignBytes. | |||
| // It returns true if HRS matches exactly and the LastSignature exists. | |||
| // It panics if the HRS matches, the LastSignBytes are not empty, but the LastSignature is empty. | |||
| func (info LastSignedInfo) Verify(height int64, round int, step int8) (bool, error) { | |||
| if info.Height > height { | |||
| return false, errors.New("Height regression") | |||
| } | |||
| if info.Height == height { | |||
| if info.Round > round { | |||
| return false, errors.New("Round regression") | |||
| } | |||
| if info.Round == round { | |||
| if info.Step > step { | |||
| return false, errors.New("Step regression") | |||
| } else if info.Step == step { | |||
| if info.SignBytes != nil { | |||
| if info.Signature.Empty() { | |||
| panic("info: LastSignature is nil but LastSignBytes is not!") | |||
| } | |||
| return true, nil | |||
| } | |||
| return false, errors.New("No LastSignature found") | |||
| } | |||
| } | |||
| } | |||
| return false, nil | |||
| } | |||
| // Set height/round/step and signature on the info | |||
| func (info *LastSignedInfo) Set(height int64, round int, step int8, | |||
| signBytes []byte, sig crypto.Signature) { | |||
| info.Height = height | |||
| info.Round = round | |||
| info.Step = step | |||
| info.Signature = sig | |||
| info.SignBytes = signBytes | |||
| } | |||
| // Reset resets all the values. | |||
| // XXX: Unsafe. | |||
| func (info *LastSignedInfo) Reset() { | |||
| info.Height = 0 | |||
| info.Round = 0 | |||
| info.Step = 0 | |||
| info.Signature = crypto.Signature{} | |||
| info.SignBytes = nil | |||
| } | |||
| // SignVote checks the height/round/step (HRS) are greater than the latest state of the LastSignedInfo. | |||
| // If so, it signs the vote, updates the LastSignedInfo, and sets the signature on the vote. | |||
| // If the HRS are equal and the only thing changed is the timestamp, it sets the vote.Timestamp to the previous | |||
| // value and the Signature to the LastSignedInfo.Signature. | |||
| // Else it returns an error. | |||
| func (lsi *LastSignedInfo) SignVote(signer types.Signer, chainID string, vote *types.Vote) error { | |||
| height, round, step := vote.Height, vote.Round, voteToStep(vote) | |||
| signBytes := vote.SignBytes(chainID) | |||
| sameHRS, err := lsi.Verify(height, round, step) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| // We might crash before writing to the wal, | |||
| // causing us to try to re-sign for the same HRS. | |||
| // If signbytes are the same, use the last signature. | |||
| // If they only differ by timestamp, use last timestamp and signature | |||
| // Otherwise, return error | |||
| if sameHRS { | |||
| if bytes.Equal(signBytes, lsi.SignBytes) { | |||
| vote.Signature = lsi.Signature | |||
| } else if timestamp, ok := checkVotesOnlyDifferByTimestamp(lsi.SignBytes, signBytes); ok { | |||
| vote.Timestamp = timestamp | |||
| vote.Signature = lsi.Signature | |||
| } else { | |||
| err = fmt.Errorf("Conflicting data") | |||
| } | |||
| return err | |||
| } | |||
| sig, err := signer.Sign(signBytes) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| lsi.Set(height, round, step, signBytes, sig) | |||
| vote.Signature = sig | |||
| return nil | |||
| } | |||
| // SignProposal checks if the height/round/step (HRS) are greater than the latest state of the LastSignedInfo. | |||
| // If so, it signs the proposal, updates the LastSignedInfo, and sets the signature on the proposal. | |||
| // If the HRS are equal and the only thing changed is the timestamp, it sets the timestamp to the previous | |||
| // value and the Signature to the LastSignedInfo.Signature. | |||
| // Else it returns an error. | |||
| func (lsi *LastSignedInfo) SignProposal(signer types.Signer, chainID string, proposal *types.Proposal) error { | |||
| height, round, step := proposal.Height, proposal.Round, stepPropose | |||
| signBytes := proposal.SignBytes(chainID) | |||
| sameHRS, err := lsi.Verify(height, round, step) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| // We might crash before writing to the wal, | |||
| // causing us to try to re-sign for the same HRS. | |||
| // If signbytes are the same, use the last signature. | |||
| // If they only differ by timestamp, use last timestamp and signature | |||
| // Otherwise, return error | |||
| if sameHRS { | |||
| if bytes.Equal(signBytes, lsi.SignBytes) { | |||
| proposal.Signature = lsi.Signature | |||
| } else if timestamp, ok := checkProposalsOnlyDifferByTimestamp(lsi.SignBytes, signBytes); ok { | |||
| proposal.Timestamp = timestamp | |||
| proposal.Signature = lsi.Signature | |||
| } else { | |||
| err = fmt.Errorf("Conflicting data") | |||
| } | |||
| return err | |||
| } | |||
| sig, err := signer.Sign(signBytes) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| lsi.Set(height, round, step, signBytes, sig) | |||
| proposal.Signature = sig | |||
| return nil | |||
| } | |||
| //------------------------------------- | |||
| // returns the timestamp from the lastSignBytes. | |||
| // returns true if the only difference in the votes is their timestamp. | |||
| func checkVotesOnlyDifferByTimestamp(lastSignBytes, newSignBytes []byte) (time.Time, bool) { | |||
| var lastVote, newVote types.CanonicalJSONOnceVote | |||
| if err := json.Unmarshal(lastSignBytes, &lastVote); err != nil { | |||
| panic(fmt.Sprintf("LastSignBytes cannot be unmarshalled into vote: %v", err)) | |||
| } | |||
| if err := json.Unmarshal(newSignBytes, &newVote); err != nil { | |||
| panic(fmt.Sprintf("signBytes cannot be unmarshalled into vote: %v", err)) | |||
| } | |||
| lastTime, err := time.Parse(types.TimeFormat, lastVote.Vote.Timestamp) | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| // set the times to the same value and check equality | |||
| now := types.CanonicalTime(time.Now()) | |||
| lastVote.Vote.Timestamp = now | |||
| newVote.Vote.Timestamp = now | |||
| lastVoteBytes, _ := json.Marshal(lastVote) | |||
| newVoteBytes, _ := json.Marshal(newVote) | |||
| return lastTime, bytes.Equal(newVoteBytes, lastVoteBytes) | |||
| } | |||
| // returns the timestamp from the lastSignBytes. | |||
| // returns true if the only difference in the proposals is their timestamp | |||
| func checkProposalsOnlyDifferByTimestamp(lastSignBytes, newSignBytes []byte) (time.Time, bool) { | |||
| var lastProposal, newProposal types.CanonicalJSONOnceProposal | |||
| if err := json.Unmarshal(lastSignBytes, &lastProposal); err != nil { | |||
| panic(fmt.Sprintf("LastSignBytes cannot be unmarshalled into proposal: %v", err)) | |||
| } | |||
| if err := json.Unmarshal(newSignBytes, &newProposal); err != nil { | |||
| panic(fmt.Sprintf("signBytes cannot be unmarshalled into proposal: %v", err)) | |||
| } | |||
| lastTime, err := time.Parse(types.TimeFormat, lastProposal.Proposal.Timestamp) | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| // set the times to the same value and check equality | |||
| now := types.CanonicalTime(time.Now()) | |||
| lastProposal.Proposal.Timestamp = now | |||
| newProposal.Proposal.Timestamp = now | |||
| lastProposalBytes, _ := json.Marshal(lastProposal) | |||
| newProposalBytes, _ := json.Marshal(newProposal) | |||
| return lastTime, bytes.Equal(newProposalBytes, lastProposalBytes) | |||
| } | |||
+ 90
- 116
types/priv_validator/socket.go
View File
+ 1
- 1
types/priv_validator/socket_tcp.go
View File
+ 1
- 1
types/priv_validator/socket_tcp_test.go
View File
+ 33
- 37
types/priv_validator/socket_test.go
View File
+ 0
- 66
types/priv_validator/unencrypted.go
View File
| @ -1,66 +0,0 @@ | |||
| package types | |||
| import ( | |||
| "fmt" | |||
| crypto "github.com/tendermint/go-crypto" | |||
| "github.com/tendermint/tendermint/types" | |||
| cmn "github.com/tendermint/tmlibs/common" | |||
| ) | |||
| //----------------------------------------------------------------- | |||
| var _ types.PrivValidator2 = (*PrivValidatorUnencrypted)(nil) | |||
| // PrivValidatorUnencrypted implements PrivValidator. | |||
| // It uses an in-memory crypto.PrivKey that is | |||
| // persisted to disk unencrypted. | |||
| type PrivValidatorUnencrypted struct { | |||
| ID types.ValidatorID `json:"id"` | |||
| PrivKey PrivKey `json:"priv_key"` | |||
| LastSignedInfo *LastSignedInfo `json:"last_signed_info"` | |||
| } | |||
| // NewPrivValidatorUnencrypted returns an instance of PrivValidatorUnencrypted. | |||
| func NewPrivValidatorUnencrypted(priv crypto.PrivKey) *PrivValidatorUnencrypted { | |||
| return &PrivValidatorUnencrypted{ | |||
| ID: types.ValidatorID{ | |||
| Address: priv.PubKey().Address(), | |||
| PubKey: priv.PubKey(), | |||
| }, | |||
| PrivKey: PrivKey(priv), | |||
| LastSignedInfo: NewLastSignedInfo(), | |||
| } | |||
| } | |||
| // String returns a string representation of the PrivValidatorUnencrypted | |||
| func (upv *PrivValidatorUnencrypted) String() string { | |||
| addr, err := upv.Address() | |||
| if err != nil { | |||
| panic(err) | |||
| } | |||
| return fmt.Sprintf("PrivValidator{%v %v}", addr, upv.LastSignedInfo.String()) | |||
| } | |||
| func (upv *PrivValidatorUnencrypted) Address() (cmn.HexBytes, error) { | |||
| return upv.PrivKey.PubKey().Address(), nil | |||
| } | |||
| func (upv *PrivValidatorUnencrypted) PubKey() (crypto.PubKey, error) { | |||
| return upv.PrivKey.PubKey(), nil | |||
| } | |||
| func (upv *PrivValidatorUnencrypted) SignVote(chainID string, vote *types.Vote) error { | |||
| return upv.LastSignedInfo.SignVote(upv.PrivKey, chainID, vote) | |||
| } | |||
| func (upv *PrivValidatorUnencrypted) SignProposal(chainID string, proposal *types.Proposal) error { | |||
| return upv.LastSignedInfo.SignProposal(upv.PrivKey, chainID, proposal) | |||
| } | |||
| func (upv *PrivValidatorUnencrypted) SignHeartbeat(chainID string, heartbeat *types.Heartbeat) error { | |||
| var err error | |||
| heartbeat.Signature, err = upv.PrivKey.Sign(heartbeat.SignBytes(chainID)) | |||
| return err | |||
| } | |||
+ 0
- 59
types/priv_validator/upgrade.go
View File
| @ -1,59 +0,0 @@ | |||
| package types | |||
| import ( | |||
| "encoding/json" | |||
| "io/ioutil" | |||
| crypto "github.com/tendermint/go-crypto" | |||
| "github.com/tendermint/tendermint/types" | |||
| cmn "github.com/tendermint/tmlibs/common" | |||
| ) | |||
| type PrivValidatorV1 struct { | |||
| Address cmn.HexBytes `json:"address"` | |||
| PubKey crypto.PubKey `json:"pub_key"` | |||
| LastHeight int64 `json:"last_height"` | |||
| LastRound int `json:"last_round"` | |||
| LastStep int8 `json:"last_step"` | |||
| LastSignature crypto.Signature `json:"last_signature,omitempty"` // so we dont lose signatures | |||
| LastSignBytes cmn.HexBytes `json:"last_signbytes,omitempty"` // so we dont lose signatures | |||
| PrivKey crypto.PrivKey `json:"priv_key"` | |||
| } | |||
| func UpgradePrivValidator(filePath string) (*PrivValidatorJSON, error) { | |||
| b, err := ioutil.ReadFile(filePath) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| pv := new(PrivValidatorV1) | |||
| err = json.Unmarshal(b, pv) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| pvNew := &PrivValidatorJSON{ | |||
| PrivValidatorUnencrypted: &PrivValidatorUnencrypted{ | |||
| ID: types.ValidatorID{ | |||
| Address: pv.Address, | |||
| PubKey: pv.PubKey, | |||
| }, | |||
| PrivKey: PrivKey(pv.PrivKey), | |||
| LastSignedInfo: &LastSignedInfo{ | |||
| Height: pv.LastHeight, | |||
| Round: pv.LastRound, | |||
| Step: pv.LastStep, | |||
| SignBytes: pv.LastSignBytes, | |||
| Signature: pv.LastSignature, | |||
| }, | |||
| }, | |||
| } | |||
| b, err = json.MarshalIndent(pvNew, "", " ") | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| err = ioutil.WriteFile(filePath, b, 0600) | |||
| return pvNew, err | |||
| } | |||
+ 0
- 21
types/priv_validator/upgrade_pv/main.go
View File
| @ -1,21 +0,0 @@ | |||
| package main | |||
| import ( | |||
| "fmt" | |||
| "os" | |||
| priv_val "github.com/tendermint/tendermint/types/priv_validator" | |||
| ) | |||
| func main() { | |||
| if len(os.Args) < 2 { | |||
| fmt.Println("USAGE: priv_val_converter <path to priv_validator.json>") | |||
| os.Exit(1) | |||
| } | |||
| file := os.Args[1] | |||
| _, err := priv_val.UpgradePrivValidator(file) | |||
| if err != nil { | |||
| fmt.Println(err) | |||
| os.Exit(1) | |||
| } | |||
| } | |||
+ 13
- 0
types/priv_validator/wire.go
View File
| @ -0,0 +1,13 @@ | |||
| package privval | |||
| import ( | |||
| "github.com/tendermint/go-amino" | |||
| "github.com/tendermint/go-crypto" | |||
| ) | |||
| var cdc = amino.NewCodec() | |||
| func init() { | |||
| crypto.RegisterAmino(cdc) | |||
| RegisterSocketPVMsg(cdc) | |||
| } | |||
+ 0
- 255
types/priv_validator_test.go
View File
| @ -1,255 +0,0 @@ | |||
| package types | |||
| import ( | |||
| "encoding/hex" | |||
| "encoding/json" | |||
| "fmt" | |||
| "os" | |||
| "testing" | |||
| "time" | |||
| "github.com/stretchr/testify/assert" | |||
| "github.com/stretchr/testify/require" | |||
| crypto "github.com/tendermint/go-crypto" | |||
| cmn "github.com/tendermint/tmlibs/common" | |||
| ) | |||
| func TestGenLoadValidator(t *testing.T) { | |||
| assert := assert.New(t) | |||
| _, tempFilePath := cmn.Tempfile("priv_validator_") | |||
| privVal := GenPrivValidatorFS(tempFilePath) | |||
| height := int64(100) | |||
| privVal.LastHeight = height | |||
| privVal.Save() | |||
| addr := privVal.GetAddress() | |||
| privVal = LoadPrivValidatorFS(tempFilePath) | |||
| assert.Equal(addr, privVal.GetAddress(), "expected privval addr to be the same") | |||
| assert.Equal(height, privVal.LastHeight, "expected privval.LastHeight to have been saved") | |||
| } | |||
| func TestLoadOrGenValidator(t *testing.T) { | |||
| assert := assert.New(t) | |||
| _, tempFilePath := cmn.Tempfile("priv_validator_") | |||
| if err := os.Remove(tempFilePath); err != nil { | |||
| t.Error(err) | |||
| } | |||
| privVal := LoadOrGenPrivValidatorFS(tempFilePath) | |||
| addr := privVal.GetAddress() | |||
| privVal = LoadOrGenPrivValidatorFS(tempFilePath) | |||
| assert.Equal(addr, privVal.GetAddress(), "expected privval addr to be the same") | |||
| } | |||
| func TestUnmarshalValidator(t *testing.T) { | |||
| assert, require := assert.New(t), require.New(t) | |||
| // create some fixed values | |||
| addrStr := "D028C9981F7A87F3093672BF0D5B0E2A1B3ED456" | |||
| pubStr := "3B3069C422E19688B45CBFAE7BB009FC0FA1B1EA86593519318B7214853803C8" | |||
| privStr := "27F82582AEFAE7AB151CFB01C48BB6C1A0DA78F9BDDA979A9F70A84D074EB07D3B3069C422E19688B45CBFAE7BB009FC0FA1B1EA86593519318B7214853803C8" | |||
| addrBytes, _ := hex.DecodeString(addrStr) | |||
| pubBytes, _ := hex.DecodeString(pubStr) | |||
| privBytes, _ := hex.DecodeString(privStr) | |||
| // prepend type byte | |||
| pubKey, err := crypto.PubKeyFromBytes(append([]byte{1}, pubBytes...)) | |||
| require.Nil(err, "%+v", err) | |||
| privKey, err := crypto.PrivKeyFromBytes(append([]byte{1}, privBytes...)) | |||
| require.Nil(err, "%+v", err) | |||
| serialized := fmt.Sprintf(`{ | |||
| "address": "%s", | |||
| "pub_key": { | |||
| "type": "ed25519", | |||
| "data": "%s" | |||
| }, | |||
| "last_height": 0, | |||
| "last_round": 0, | |||
| "last_step": 0, | |||
| "last_signature": null, | |||
| "priv_key": { | |||
| "type": "ed25519", | |||
| "data": "%s" | |||
| } | |||
| }`, addrStr, pubStr, privStr) | |||
| val := PrivValidatorFS{} | |||
| err = json.Unmarshal([]byte(serialized), &val) | |||
| require.Nil(err, "%+v", err) | |||
| // make sure the values match | |||
| assert.EqualValues(addrBytes, val.GetAddress()) | |||
| assert.EqualValues(pubKey, val.GetPubKey()) | |||
| assert.EqualValues(privKey, val.PrivKey) | |||
| // export it and make sure it is the same | |||
| out, err := json.Marshal(val) | |||
| require.Nil(err, "%+v", err) | |||
| assert.JSONEq(serialized, string(out)) | |||
| } | |||
| func TestSignVote(t *testing.T) { | |||
| assert := assert.New(t) | |||
| _, tempFilePath := cmn.Tempfile("priv_validator_") | |||
| privVal := GenPrivValidatorFS(tempFilePath) | |||
| block1 := BlockID{[]byte{1, 2, 3}, PartSetHeader{}} | |||
| block2 := BlockID{[]byte{3, 2, 1}, PartSetHeader{}} | |||
| height, round := int64(10), 1 | |||
| voteType := VoteTypePrevote | |||
| // sign a vote for first time | |||
| vote := newVote(privVal.Address, 0, height, round, voteType, block1) | |||
| err := privVal.SignVote("mychainid", vote) | |||
| assert.NoError(err, "expected no error signing vote") | |||
| // try to sign the same vote again; should be fine | |||
| err = privVal.SignVote("mychainid", vote) | |||
| assert.NoError(err, "expected no error on signing same vote") | |||
| // now try some bad votes | |||
| cases := []*Vote{ | |||
| newVote(privVal.Address, 0, height, round-1, voteType, block1), // round regression | |||
| newVote(privVal.Address, 0, height-1, round, voteType, block1), // height regression | |||
| newVote(privVal.Address, 0, height-2, round+4, voteType, block1), // height regression and different round | |||
| newVote(privVal.Address, 0, height, round, voteType, block2), // different block | |||
| } | |||
| for _, c := range cases { | |||
| err = privVal.SignVote("mychainid", c) | |||
| assert.Error(err, "expected error on signing conflicting vote") | |||
| } | |||
| // try signing a vote with a different time stamp | |||
| sig := vote.Signature | |||
| vote.Timestamp = vote.Timestamp.Add(time.Duration(1000)) | |||
| err = privVal.SignVote("mychainid", vote) | |||
| assert.NoError(err) | |||
| assert.Equal(sig, vote.Signature) | |||
| } | |||
| func TestSignProposal(t *testing.T) { | |||
| assert := assert.New(t) | |||
| _, tempFilePath := cmn.Tempfile("priv_validator_") | |||
| privVal := GenPrivValidatorFS(tempFilePath) | |||
| block1 := PartSetHeader{5, []byte{1, 2, 3}} | |||
| block2 := PartSetHeader{10, []byte{3, 2, 1}} | |||
| height, round := int64(10), 1 | |||
| // sign a proposal for first time | |||
| proposal := newProposal(height, round, block1) | |||
| err := privVal.SignProposal("mychainid", proposal) | |||
| assert.NoError(err, "expected no error signing proposal") | |||
| // try to sign the same proposal again; should be fine | |||
| err = privVal.SignProposal("mychainid", proposal) | |||
| assert.NoError(err, "expected no error on signing same proposal") | |||
| // now try some bad Proposals | |||
| cases := []*Proposal{ | |||
| newProposal(height, round-1, block1), // round regression | |||
| newProposal(height-1, round, block1), // height regression | |||
| newProposal(height-2, round+4, block1), // height regression and different round | |||
| newProposal(height, round, block2), // different block | |||
| } | |||
| for _, c := range cases { | |||
| err = privVal.SignProposal("mychainid", c) | |||
| assert.Error(err, "expected error on signing conflicting proposal") | |||
| } | |||
| // try signing a proposal with a different time stamp | |||
| sig := proposal.Signature | |||
| proposal.Timestamp = proposal.Timestamp.Add(time.Duration(1000)) | |||
| err = privVal.SignProposal("mychainid", proposal) | |||
| assert.NoError(err) | |||
| assert.Equal(sig, proposal.Signature) | |||
| } | |||
| func TestDifferByTimestamp(t *testing.T) { | |||
| _, tempFilePath := cmn.Tempfile("priv_validator_") | |||
| privVal := GenPrivValidatorFS(tempFilePath) | |||
| block1 := PartSetHeader{5, []byte{1, 2, 3}} | |||
| height, round := int64(10), 1 | |||
| chainID := "mychainid" | |||
| // test proposal | |||
| { | |||
| proposal := newProposal(height, round, block1) | |||
| err := privVal.SignProposal(chainID, proposal) | |||
| assert.NoError(t, err, "expected no error signing proposal") | |||
| signBytes := proposal.SignBytes(chainID) | |||
| sig := proposal.Signature | |||
| timeStamp := clipToMS(proposal.Timestamp) | |||
| // manipulate the timestamp. should get changed back | |||
| proposal.Timestamp = proposal.Timestamp.Add(time.Millisecond) | |||
| var emptySig crypto.Signature | |||
| proposal.Signature = emptySig | |||
| err = privVal.SignProposal("mychainid", proposal) | |||
| assert.NoError(t, err, "expected no error on signing same proposal") | |||
| assert.Equal(t, timeStamp, proposal.Timestamp) | |||
| assert.Equal(t, signBytes, proposal.SignBytes(chainID)) | |||
| assert.Equal(t, sig, proposal.Signature) | |||
| } | |||
| // test vote | |||
| { | |||
| voteType := VoteTypePrevote | |||
| blockID := BlockID{[]byte{1, 2, 3}, PartSetHeader{}} | |||
| vote := newVote(privVal.Address, 0, height, round, voteType, blockID) | |||
| err := privVal.SignVote("mychainid", vote) | |||
| assert.NoError(t, err, "expected no error signing vote") | |||
| signBytes := vote.SignBytes(chainID) | |||
| sig := vote.Signature | |||
| timeStamp := clipToMS(vote.Timestamp) | |||
| // manipulate the timestamp. should get changed back | |||
| vote.Timestamp = vote.Timestamp.Add(time.Millisecond) | |||
| var emptySig crypto.Signature | |||
| vote.Signature = emptySig | |||
| err = privVal.SignVote("mychainid", vote) | |||
| assert.NoError(t, err, "expected no error on signing same vote") | |||
| assert.Equal(t, timeStamp, vote.Timestamp) | |||
| assert.Equal(t, signBytes, vote.SignBytes(chainID)) | |||
| assert.Equal(t, sig, vote.Signature) | |||
| } | |||
| } | |||
| func newVote(addr Address, idx int, height int64, round int, typ byte, blockID BlockID) *Vote { | |||
| return &Vote{ | |||
| ValidatorAddress: addr, | |||
| ValidatorIndex: idx, | |||
| Height: height, | |||
| Round: round, | |||
| Type: typ, | |||
| Timestamp: time.Now().UTC(), | |||
| BlockID: blockID, | |||
| } | |||
| } | |||
| func newProposal(height int64, round int, partsHeader PartSetHeader) *Proposal { | |||
| return &Proposal{ | |||
| Height: height, | |||
| Round: round, | |||
| BlockPartsHeader: partsHeader, | |||
| Timestamp: time.Now().UTC(), | |||
| } | |||
| } | |||
| func clipToMS(t time.Time) time.Time { | |||
| nano := t.UnixNano() | |||
| million := int64(1000000) | |||
| nano = (nano / million) * million | |||
| return time.Unix(0, nano).UTC() | |||
| } | |||
+ 1
- 5
types/proposal.go
View File
+ 14
- 16
types/proposal_test.go
View File
+ 3
- 3
types/results.go
View File
+ 8
- 6
types/results_test.go
View File
+ 0
- 5
types/signable.go
View File
+ 3
- 3
types/test_util.go
View File
+ 8
- 5
types/tx.go
View File
+ 9
- 9
types/tx_test.go
View File
+ 5
- 6
types/validator.go
View File
+ 10
- 11
types/validator_set.go
View File
+ 3
- 4
types/validator_set_test.go
View File
+ 1
- 5
types/vote.go
View File
+ 1
- 1
types/vote_set_test.go
View File
+ 9
- 11
types/vote_test.go
View File
+ 12
- 0
types/wire.go
View File
| @ -0,0 +1,12 @@ | |||
| package types | |||
| import ( | |||
| "github.com/tendermint/go-amino" | |||
| "github.com/tendermint/go-crypto" | |||
| ) | |||
| var cdc = amino.NewCodec() | |||
| func init() { | |||
| crypto.RegisterAmino(cdc) | |||
| } | |||