You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
134 lines
3.9 KiB
134 lines
3.9 KiB
package keys
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
|
|
crypto "github.com/tendermint/go-crypto"
|
|
wire "github.com/tendermint/go-wire"
|
|
data "github.com/tendermint/go-wire/data"
|
|
)
|
|
|
|
// Storage has many implementation, based on security and sharing requirements
|
|
// like disk-backed, mem-backed, vault, db, etc.
|
|
type Storage interface {
|
|
Put(name string, salt []byte, key []byte, info Info) error
|
|
Get(name string) (salt []byte, key []byte, info Info, err error)
|
|
List() (Infos, error)
|
|
Delete(name string) error
|
|
}
|
|
|
|
// Info is the public information about a key
|
|
type Info struct {
|
|
Name string `json:"name"`
|
|
Address data.Bytes `json:"address"`
|
|
PubKey crypto.PubKey `json:"pubkey"`
|
|
}
|
|
|
|
func (i *Info) Format() Info {
|
|
if !i.PubKey.Empty() {
|
|
i.Address = i.PubKey.Address()
|
|
}
|
|
return *i
|
|
}
|
|
|
|
// Infos is a wrapper to allows alphabetical sorting of the keys
|
|
type Infos []Info
|
|
|
|
func (k Infos) Len() int { return len(k) }
|
|
func (k Infos) Less(i, j int) bool { return k[i].Name < k[j].Name }
|
|
func (k Infos) Swap(i, j int) { k[i], k[j] = k[j], k[i] }
|
|
func (k Infos) Sort() {
|
|
if k != nil {
|
|
sort.Sort(k)
|
|
}
|
|
}
|
|
|
|
// Signable represents any transaction we wish to send to tendermint core
|
|
// These methods allow us to sign arbitrary Tx with the KeyStore
|
|
type Signable interface {
|
|
// SignBytes is the immutable data, which needs to be signed
|
|
SignBytes() []byte
|
|
|
|
// Sign will add a signature and pubkey.
|
|
//
|
|
// Depending on the Signable, one may be able to call this multiple times for multisig
|
|
// Returns error if called with invalid data or too many times
|
|
Sign(pubkey crypto.PubKey, sig crypto.Signature) error
|
|
|
|
// Signers will return the public key(s) that signed if the signature
|
|
// is valid, or an error if there is any issue with the signature,
|
|
// including if there are no signatures
|
|
Signers() ([]crypto.PubKey, error)
|
|
|
|
// TxBytes returns the transaction data as well as all signatures
|
|
// It should return an error if Sign was never called
|
|
TxBytes() ([]byte, error)
|
|
}
|
|
|
|
// Signer allows one to use a keystore to sign transactions
|
|
type Signer interface {
|
|
Sign(name, passphrase string, tx Signable) error
|
|
}
|
|
|
|
// Manager allows simple CRUD on a keystore, as an aid to signing
|
|
type Manager interface {
|
|
Signer
|
|
// Create also returns a seed phrase for cold-storage
|
|
Create(name, passphrase, algo string) (Info, string, error)
|
|
// Recover takes a seedphrase and loads in the private key
|
|
Recover(name, passphrase, seedphrase string) (Info, error)
|
|
List() (Infos, error)
|
|
Get(name string) (Info, error)
|
|
Update(name, oldpass, newpass string) error
|
|
Delete(name, passphrase string) error
|
|
}
|
|
|
|
/**** MockSignable allows us to view data ***/
|
|
|
|
// MockSignable lets us wrap arbitrary data with a go-crypto signature
|
|
type MockSignable struct {
|
|
Data []byte
|
|
PubKey crypto.PubKey
|
|
Signature crypto.Signature
|
|
}
|
|
|
|
var _ Signable = &MockSignable{}
|
|
|
|
// NewMockSignable sets the data to sign
|
|
func NewMockSignable(data []byte) *MockSignable {
|
|
return &MockSignable{Data: data}
|
|
}
|
|
|
|
// TxBytes returns the full data with signatures
|
|
func (s *MockSignable) TxBytes() ([]byte, error) {
|
|
return wire.BinaryBytes(s), nil
|
|
}
|
|
|
|
// SignBytes returns the original data passed into `NewSig`
|
|
func (s *MockSignable) SignBytes() []byte {
|
|
return s.Data
|
|
}
|
|
|
|
// Sign will add a signature and pubkey.
|
|
//
|
|
// Depending on the Signable, one may be able to call this multiple times for multisig
|
|
// Returns error if called with invalid data or too many times
|
|
func (s *MockSignable) Sign(pubkey crypto.PubKey, sig crypto.Signature) error {
|
|
s.PubKey = pubkey
|
|
s.Signature = sig
|
|
return nil
|
|
}
|
|
|
|
// Signers will return the public key(s) that signed if the signature
|
|
// is valid, or an error if there is any issue with the signature,
|
|
// including if there are no signatures
|
|
func (s *MockSignable) Signers() ([]crypto.PubKey, error) {
|
|
if s.PubKey.Empty() {
|
|
return nil, fmt.Errorf("no signers")
|
|
}
|
|
if !s.PubKey.VerifyBytes(s.SignBytes(), s.Signature) {
|
|
return nil, fmt.Errorf("invalid signature")
|
|
}
|
|
return []crypto.PubKey{s.PubKey}, nil
|
|
}
|