Interface for LocalCosigner

README.md

@@ -20,7 +20,7 @@ Multi-party computation using threshold signatures is able to provide high-avail
 
 For more on how the Horcrux MPC signing flow works, see [`docs/signing.md`](/docs/signing.md)
 
-![Screenshot from 2022-03-07 18-09-49](https://user-images.githubusercontent.com/6722152/157145772-8557b4b5-a0cc-4073-8834-86afda1900fc.png)
+![Screenshot from 2022-03-07 18-09-49](docs/pics/horcrux.png)
 
 
 ## Raft

cmd/horcrux/cmd/config.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/spf13/cobra"
 	"github.com/strangelove-ventures/horcrux/signer"
+	tmlog "github.com/tendermint/tendermint/libs/log"
 	"gopkg.in/yaml.v2"
 )
 
@@ -76,7 +77,7 @@ func initCmd() *cobra.Command {
 			}
 			if cs {
 				p, _ := cmdFlags.GetString("peers")
-				threshold, _ := cmdFlags.GetInt("threshold")
+				threshold, _ := cmdFlags.GetUint8("threshold")
 				timeout, _ := cmdFlags.GetString("timeout")
 				peers, err := peersFromFlag(p)
 				if err != nil {
@@ -104,7 +105,7 @@ func initCmd() *cobra.Command {
 					ChainID:        cid,
 					CosignerConfig: &CosignerConfig{
 						Threshold: threshold,
-						Shares:    len(peers) + 1,
+						Shares:    uint8(len(peers)) + 1,
 						P2PListen: listen,
 						Peers:     peers,
 						Timeout:   timeout,
@@ -160,7 +161,7 @@ func initCmd() *cobra.Command {
 	cmd.Flags().BoolP("cosigner", "c", false, "set to initialize a cosigner node, requires --peers and --threshold")
 	cmd.Flags().StringP("peers", "p", "", "cosigner peer addresses in format tcp://{addr}:{port}|{share-id} \n"+
 		"(i.e. \"tcp://node-1:2222|2,tcp://node-2:2222|3\")")
-	cmd.Flags().IntP("threshold", "t", 0, "indicate number of signatures required for threshold signature")
+	cmd.Flags().Uint8P("threshold", "t", 0, "indicate number of signatures required for threshold signature")
 	cmd.Flags().StringP("listen", "l", "", "listen address of the signer")
 	cmd.Flags().StringP("keyfile", "k", "",
 		"priv val key file path (full key for single signer, or key share for cosigner)")
@@ -190,9 +191,9 @@ func validateCosignerConfig(cfg DiskConfig) error {
 	if cfg.CosignerConfig == nil {
 		return fmt.Errorf("cosigner config can't be empty")
 	}
-	if len(cfg.CosignerConfig.Peers)+1 < cfg.CosignerConfig.Threshold {
-		return fmt.Errorf("number of peers + 1 (%d) must be greater than threshold (%d)",
-			len(cfg.CosignerConfig.Peers)+1, cfg.CosignerConfig.Threshold)
+	if float32(len(cfg.CosignerConfig.Peers))/float32(2) >= float32(cfg.CosignerConfig.Threshold) {
+		return fmt.Errorf("the threshold, t = (%d) must be greater than, 'peers/2' = (%.1f)",
+			cfg.CosignerConfig.Threshold, float32(len(cfg.CosignerConfig.Peers))/2)
 	}
 
 	_, err := time.ParseDuration(cfg.CosignerConfig.Timeout)
@@ -399,10 +400,11 @@ func setSharesCmd() *cobra.Command {
 			"3",
 		Args: cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			numShares, err := strconv.Atoi(args[0])
+			numSharesParsed, err := strconv.ParseUint(args[0], 10, 8)
 			if err != nil {
 				return err
 			}
+			numShares := uint8(numSharesParsed)
 			if err := validateCosignerPeers(config.Config.CosignerConfig.Peers, numShares); err != nil {
 				return err
 			}
@@ -534,11 +536,12 @@ func (c RuntimeConfig) writeConfigFile() error {
 }
 
 type CosignerConfig struct {
-	Threshold int            `json:"threshold"   yaml:"threshold"`
-	Shares    int            `json:"shares" yaml:"shares"`
-	P2PListen string         `json:"p2p-listen"  yaml:"p2p-listen"`
-	Peers     []CosignerPeer `json:"peers"       yaml:"peers"`
-	Timeout   string         `json:"rpc-timeout" yaml:"rpc-timeout"`
+	Threshold  uint8          `json:"threshold"   yaml:"threshold"`
+	Shares     uint8          `json:"shares" yaml:"shares"`
+	P2PListen  string         `json:"p2p-listen"  yaml:"p2p-listen"`
+	Peers      []CosignerPeer `json:"peers"       yaml:"peers"`
+	Timeout    string         `json:"rpc-timeout" yaml:"rpc-timeout"`
+	SignerType string         `json:"signer-type" yaml:"signer-type"`
 }
 
 func (c *DiskConfig) CosignerPeers() (out []signer.CosignerConfig) {
@@ -548,28 +551,57 @@ func (c *DiskConfig) CosignerPeers() (out []signer.CosignerConfig) {
 	return
 }
 
+func (c *DiskConfig) KeyAndThresholdSigner(logger tmlog.Logger) (signer.CosignerKey, signer.ThresholdSigner, error) {
+	switch c.CosignerConfig.SignerType {
+	case "hsm", "HSM":
+		logger.Info("Cosigning with HSM")
+		return signer.CosignerKey{}, signer.NewThresholdSignerHSM(), nil
+	default:
+
+		keyFilePath := config.keyFilePath(true)
+		if _, err := os.Stat(keyFilePath); os.IsNotExist(err) {
+			return signer.CosignerKey{}, nil, fmt.Errorf("private key share doesn't exist at path(%s)", keyFilePath)
+		}
+		key, err := signer.LoadCosignerKey(keyFilePath)
+		if err != nil {
+			return signer.CosignerKey{}, nil, fmt.Errorf("error reading cosigner key: %s", err)
+		}
+		logger.Info("Cosigning with soft key",
+			"file", keyFilePath,
+			"id", key.ID,
+			"threshold", c.CosignerConfig.Threshold,
+			"total", c.CosignerConfig.Shares,
+		)
+		return key, signer.NewThresholdSignerSoft(
+			key,
+			c.CosignerConfig.Threshold,
+			c.CosignerConfig.Shares,
+		), nil
+	}
+}
+
 type CosignerPeer struct {
 	ShareID int    `json:"share-id" yaml:"share-id"`
 	P2PAddr string `json:"p2p-addr" yaml:"p2p-addr"`
 }
 
-func validateCosignerPeers(peers []CosignerPeer, shares int) error {
+func validateCosignerPeers(peers []CosignerPeer, shares uint8) error {
 	// Check IDs to make sure none are duplicated
 	if dupl := duplicatePeers(peers); len(dupl) != 0 {
 		return fmt.Errorf("found duplicate share IDs in args: %v", dupl)
 	}
 
 	// Make sure that the peers' IDs match the number of shares.
 	for _, peer := range peers {
-		if peer.ShareID < 1 || peer.ShareID > shares {
+		if peer.ShareID < 1 || peer.ShareID > int(shares) {
 			return fmt.Errorf("peer ID %v in args is out of range, must be between 1 and %v",
 				peer.ShareID, shares)
 		}
 	}
 
 	// Check that no more than {num-shares}-1 peers are in the peer list, assuming
 	// the remaining peer ID is the ID the local node is configured with.
-	if len(peers) == shares {
+	if len(peers) == int(shares) {
 		return fmt.Errorf("too many peers (%v+local node = %v) for the specified number of key shares (%v)",
 			len(peers), len(peers)+1, shares)
 	}

cmd/horcrux/cmd/config_test.go

@@ -65,6 +65,20 @@ func TestConfigInitCmd(t *testing.T) {
 			},
 			expectErr: true,
 		},
+		{
+			name: "invalid threshold setting",
+			home: tmpHome + "_invalid_threshold_setting",
+			args: []string{
+				chainID,
+				"tcp://10.168.0.1:1234",
+				"-c",
+				"-p", "tcp://10.168.1.2:2222|2,tcp://10.168.1.3:2222|3",
+				"-t", "1", // t =< p/2, should be t > p/2
+				"-l", "tcp://10.168.1.1:2222",
+				"--timeout", "1500ms",
+			},
+			expectErr: true,
+		},
 	}
 
 	for _, tc := range tcs {
@@ -627,7 +641,7 @@ func TestSetShares(t *testing.T) {
 	tcs := []struct {
 		name         string
 		args         []string
-		expectShares int
+		expectShares uint8
 		expectErr    bool
 	}{ // Do NOT change the order of the test cases!
 		{

cmd/horcrux/cmd/cosigner.go

@@ -120,34 +120,24 @@ func StartCosignerCmd() *cobra.Command {
 				pv       types.PrivValidator
 				chainID  = config.Config.ChainID
 				logger   = tmlog.NewTMLogger(tmlog.NewSyncWriter(os.Stdout)).With("module", "validator")
-				cfg      signer.Config
 			)
 
-			cfg = signer.Config{
-				Mode:              "mpc",
-				PrivValKeyFile:    config.keyFilePath(true),
-				PrivValStateDir:   config.StateDir,
-				ChainID:           config.Config.ChainID,
-				CosignerThreshold: config.Config.CosignerConfig.Threshold,
-				ListenAddress:     config.Config.CosignerConfig.P2PListen,
-				Nodes:             config.Config.Nodes(),
-				Cosigners:         config.Config.CosignerPeers(),
-			}
+			nodes := config.Config.Nodes()
+			cfgCosigners := config.Config.CosignerPeers()
 
-			if err = cfg.KeyFileExists(); err != nil {
-				return err
+			// Initialize the localsigner (ThresholdEdSignature) of choice.
+			key, thresholdSigner, err := config.Config.KeyAndThresholdSigner(logger)
+			if err != nil {
+				panic(err)
 			}
 
-			logger.Info("Tendermint Validator", "mode", cfg.Mode,
-				"priv-key", cfg.PrivValKeyFile, "priv-state-dir", cfg.PrivValStateDir)
+			logger.Info("Tendermint Validator",
+				"mode", "mpc",
+				"priv-state-dir", config.StateDir,
+				"threshold-signer", thresholdSigner.Type())
 
 			var val types.PrivValidator
 
-			key, err := signer.LoadCosignerKey(cfg.PrivValKeyFile)
-			if err != nil {
-				return fmt.Errorf("error reading cosigner key: %s", err)
-			}
-
 			// ok to auto initialize on disk since the cosigner share is the one that actually
 			// protects against double sign - this exists as a cache for the final signature
 			signState, err := signer.LoadOrCreateSignState(config.privValStateFile(chainID))
@@ -162,15 +152,15 @@ func StartCosignerCmd() *cobra.Command {
 				panic(err)
 			}
 
-			cosigners := []signer.Cosigner{}
+			var cosigners []signer.Cosigner
 
 			// add ourselves as a peer so localcosigner can handle GetEphSecPart requests
 			peers := []signer.CosignerPeer{{
 				ID:        key.ID,
 				PublicKey: key.RSAKey.PublicKey,
 			}}
 
-			for _, cosignerConfig := range cfg.Cosigners {
+			for _, cosignerConfig := range cfgCosigners {
 				cosigner := signer.NewRemoteCosigner(cosignerConfig.ID, cosignerConfig.Address)
 				cosigners = append(cosigners, cosigner)
 
@@ -185,18 +175,12 @@ func StartCosignerCmd() *cobra.Command {
 				})
 			}
 
-			total := len(cfg.Cosigners) + 1
-			localCosignerConfig := signer.LocalCosignerConfig{
-				CosignerKey: key,
-				SignState:   &shareSignState,
-				RsaKey:      key.RSAKey,
-				Address:     cfg.ListenAddress,
-				Peers:       peers,
-				Total:       uint8(total),
-				Threshold:   uint8(cfg.CosignerThreshold),
-			}
-
-			localCosigner := signer.NewLocalCosigner(localCosignerConfig)
+			// Initialize the localCosigner. The localCosigner "embeds" the local signer
+			localCosigner := signer.NewLocalCosigner(
+				config.Config.CosignerConfig.P2PListen,
+				peers, &shareSignState,
+				thresholdSigner,
+			)
 
 			timeout, err := time.ParseDuration(config.Config.CosignerConfig.Timeout)
 			if err != nil {
@@ -213,15 +197,16 @@ func StartCosignerCmd() *cobra.Command {
 
 			// Start RAFT store listener
 			raftStore := signer.NewRaftStore(nodeID,
-				raftDir, cfg.ListenAddress, timeout, logger, localCosigner, cosigners)
+				raftDir, config.Config.CosignerConfig.P2PListen, timeout, logger, localCosigner, cosigners)
 			if err := raftStore.Start(); err != nil {
 				log.Fatalf("Error starting raft store: %v\n", err)
 			}
 			services = append(services, raftStore)
 
+			// Initialize the Threshold validator. The Threshold validator "embeds" the local cosigner
 			val = signer.NewThresholdValidator(&signer.ThresholdValidatorOpt{
 				Pubkey:    key.PubKey,
-				Threshold: cfg.CosignerThreshold,
+				Threshold: int(config.Config.CosignerConfig.Threshold),
 				SignState: signState,
 				Cosigner:  localCosigner,
 				Peers:     cosigners,
@@ -239,7 +224,7 @@ func StartCosignerCmd() *cobra.Command {
 			}
 			logger.Info("Signer", "address", pubkey.Address())
 
-			services, err = signer.StartRemoteSigners(services, logger, cfg.ChainID, pv, cfg.Nodes)
+			services, err = signer.StartRemoteSigners(services, logger, config.Config.ChainID, pv, nodes)
 			if err != nil {
 				panic(err)
 			}

cmd/horcrux/cmd/signer.go

@@ -44,26 +44,20 @@ func StartSignerCmd() *cobra.Command {
 				pv       types.PrivValidator
 				chainID  = config.Config.ChainID
 				logger   = tmlog.NewTMLogger(tmlog.NewSyncWriter(os.Stdout)).With("module", "validator")
-				cfg      signer.Config
 			)
 
-			cfg = signer.Config{
-				Mode:            "single",
-				PrivValKeyFile:  config.keyFilePath(false),
-				PrivValStateDir: config.StateDir,
-				ChainID:         config.Config.ChainID,
-				Nodes:           config.Config.Nodes(),
-			}
+			privValKeyFile := config.keyFilePath(false)
+			nodes := config.Config.Nodes()
 
-			if err = cfg.KeyFileExists(); err != nil {
-				return err
+			if _, err := os.Stat(privValKeyFile); os.IsNotExist(err) {
+				log.Fatalf("private key share doesn't exist at path(%s)", privValKeyFile)
 			}
 
-			logger.Info("Tendermint Validator", "mode", cfg.Mode,
-				"priv-key", cfg.PrivValKeyFile, "priv-state-dir", cfg.PrivValStateDir)
+			logger.Info("Tendermint Validator", "mode", "single",
+				"priv-key", privValKeyFile, "priv-state-dir", config.StateDir)
 
 			pv = &signer.PvGuard{
-				PrivValidator: privval.LoadFilePVEmptyState(cfg.PrivValKeyFile, config.privValStateFile(chainID)),
+				PrivValidator: privval.LoadFilePVEmptyState(privValKeyFile, config.privValStateFile(chainID)),
 			}
 
 			pubkey, err := pv.GetPubKey()
@@ -72,7 +66,7 @@ func StartSignerCmd() *cobra.Command {
 			}
 			logger.Info("Signer", "pubkey", pubkey)
 
-			services, err = signer.StartRemoteSigners(services, logger, cfg.ChainID, pv, cfg.Nodes)
+			services, err = signer.StartRemoteSigners(services, logger, config.Config.ChainID, pv, nodes)
 			if err != nil {
 				panic(err)
 			}

cmd/horcrux/cmd/state_test.go

@@ -30,6 +30,7 @@ func TestStateSetCmd(t *testing.T) {
 		"-c",
 		"-p", "tcp://10.168.1.2:2222|2,tcp://10.168.1.3:2222|3",
 		"-l", "tcp://10.168.1.1:2222",
+		"-t", "2",
 		"--timeout", "1500ms",
 	})
 	err = cmd.Execute()

docs/glossary.md

@@ -0,0 +1,9 @@
+# Glossary - WORK IN PROGRESS
+
+- In cryptography, a **nonce** (number once) is an arbitrary number that can be used just once in a cryptographic communication.
+
+- A cryptographic key is called **ephemeral** if it is generated for each execution of a key establishment process. 
+
+- **Threshold signatures** allow for splitting a private key into n secret shares. To sign a message, at least some threshold of the shareholders need to coordinate and provide their individual signatures using their share. These individual signatures combine to form a single valid signature.
+
+- **Robust schemes** ensure that so long as t participants correctly follow the protocol, the protocol is guaranteed to complete successfully, even if a subset of participants (at most n − t) contribute malformed shares. 

signer/Config.go

@@ -1,9 +1,6 @@
 package signer
 
 import (
-	"fmt"
-	"os"
-
 	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/codec/legacy"
 	"github.com/cosmos/cosmos-sdk/codec/types"
@@ -23,24 +20,6 @@ type CosignerConfig struct {
 	Address string
 }
 
-type Config struct {
-	Mode              string
-	PrivValKeyFile    string
-	PrivValStateDir   string
-	ChainID           string
-	CosignerThreshold int
-	ListenAddress     string
-	Nodes             []NodeConfig
-	Cosigners         []CosignerConfig
-}
-
-func (cfg *Config) KeyFileExists() error {
-	if _, err := os.Stat(cfg.PrivValKeyFile); os.IsNotExist(err) {
-		return fmt.Errorf("private key share doesn't exist at path(%s)", cfg.PrivValKeyFile)
-	}
-	return nil
-}
-
 func PubKey(bech32BasePrefix string, pubKey crypto.PubKey) (string, error) {
 	if bech32BasePrefix != "" {
 		pubkey, err := cryptocodec.FromTmPubKeyInterface(pubKey)