diff --git a/keys/cryptostore/generator.go b/keys/cryptostore/generator.go index 6b2d47a1a..65cc8e58b 100644 --- a/keys/cryptostore/generator.go +++ b/keys/cryptostore/generator.go @@ -12,8 +12,8 @@ var ( GenEd25519 Generator = GenFunc(genEd25519) // GenSecp256k1 produces Secp256k1 private keys GenSecp256k1 Generator = GenFunc(genSecp256) - // GenLedger used Ed25519 keys stored on nano ledger s with cosmos app - GenLedger Generator = GenFunc(genLedger) + // GenLedgerEd25519 used Ed25519 keys stored on nano ledger s with cosmos app + GenLedgerEd25519 Generator = GenFunc(genLedgerEd25519) ) // Generator determines the type of private key the keystore creates @@ -40,8 +40,8 @@ func genSecp256(secret []byte) (crypto.PrivKey, error) { // secret is completely ignored for the ledger... // just for interface compatibility -func genLedger(secret []byte) (crypto.PrivKey, error) { - return nano.NewPrivKeyLedger() +func genLedgerEd25519(secret []byte) (crypto.PrivKey, error) { + return nano.NewPrivKeyLedgerEd25519Ed25519() } type genInvalidByte struct { @@ -69,7 +69,7 @@ func getGenerator(algo string) Generator { case crypto.NameSecp256k1: return GenSecp256k1 case nano.NameLedgerEd25519: - return GenLedger + return GenLedgerEd25519 default: return genInvalidAlgo{algo} } @@ -82,7 +82,7 @@ func getGeneratorByType(typ byte) Generator { case crypto.TypeSecp256k1: return GenSecp256k1 case nano.TypeLedgerEd25519: - return GenLedger + return GenLedgerEd25519 default: return genInvalidByte{typ} } diff --git a/keys/cryptostore/holder_test.go b/keys/cryptostore/holder_test.go index 831fa251e..899f51f02 100644 --- a/keys/cryptostore/holder_test.go +++ b/keys/cryptostore/holder_test.go @@ -176,7 +176,7 @@ func TestSignWithLedger(t *testing.T) { c, _, err := cstore.Create(n, p, nano.NameLedgerEd25519) require.Nil(err, "%+v", err) assert.Equal(c.Name, n) - _, ok := c.PubKey.Unwrap().(nano.PubKeyLedger) + _, ok := c.PubKey.Unwrap().(nano.PubKeyLedgerEd25519) require.True(ok) // make sure we can get it back diff --git a/nano/keys.go b/nano/keys.go index 8d4d3d06d..dc1eec950 100644 --- a/nano/keys.go +++ b/nano/keys.go @@ -14,7 +14,7 @@ import ( //nolint const ( - NameLedgerEd25519 = "ledger" + NameLedgerEd25519 = "ledger-ed25519" TypeLedgerEd25519 = 0x10 ) @@ -48,22 +48,22 @@ func signLedger(device *ledger.Ledger, msg []byte) (pk crypto.PubKey, sig crypto var b [32]byte copy(b[:], key) - return PubKeyLedgerFromBytes(b), crypto.SignatureEd25519FromBytes(bsig), nil + return PubKeyLedgerEd25519FromBytes(b), crypto.SignatureEd25519FromBytes(bsig), nil } -// PrivKeyLedger implements PrivKey, calling the ledger nano +// PrivKeyLedgerEd25519 implements PrivKey, calling the ledger nano // we cache the PubKey from the first call to use it later -type PrivKeyLedger struct { +type PrivKeyLedgerEd25519 struct { // PubKey should be private, but we want to encode it via go-wire // so we can view the address later, even without having the ledger // attached CachedPubKey crypto.PubKey } -// NewPrivKeyLedger will generate a new key and store the +// NewPrivKeyLedgerEd25519Ed25519 will generate a new key and store the // public key for later use. -func NewPrivKeyLedger() (crypto.PrivKey, error) { - var pk PrivKeyLedger +func NewPrivKeyLedgerEd25519Ed25519() (crypto.PrivKey, error) { + var pk PrivKeyLedgerEd25519 // getPubKey will cache the pubkey for later use, // this allows us to return an error early if the ledger // is not plugged in @@ -73,7 +73,7 @@ func NewPrivKeyLedger() (crypto.PrivKey, error) { // ValidateKey allows us to verify the sanity of a key // after loading it from disk -func (pk *PrivKeyLedger) ValidateKey() error { +func (pk *PrivKeyLedgerEd25519) ValidateKey() error { // getPubKey will return an error if the ledger is not // properly set up... pub, err := pk.forceGetPubKey() @@ -88,15 +88,15 @@ func (pk *PrivKeyLedger) ValidateKey() error { } // AssertIsPrivKeyInner fulfils PrivKey Interface -func (pk *PrivKeyLedger) AssertIsPrivKeyInner() {} +func (pk *PrivKeyLedgerEd25519) AssertIsPrivKeyInner() {} // Bytes fulfils pk Interface - no data, just type info -func (pk *PrivKeyLedger) Bytes() []byte { +func (pk *PrivKeyLedgerEd25519) Bytes() []byte { return wire.BinaryBytes(pk.Wrap()) } // Sign calls the ledger and stores the pk for future use -func (pk *PrivKeyLedger) Sign(msg []byte) crypto.Signature { +func (pk *PrivKeyLedgerEd25519) Sign(msg []byte) crypto.Signature { // oh, I wish there was better error handling dev, err := getLedger() if err != nil { @@ -119,7 +119,7 @@ func (pk *PrivKeyLedger) Sign(msg []byte) crypto.Signature { // PubKey returns the stored PubKey // TODO: query the ledger if not there, once it is not volatile -func (pk *PrivKeyLedger) PubKey() crypto.PubKey { +func (pk *PrivKeyLedgerEd25519) PubKey() crypto.PubKey { key, err := pk.getPubKey() if err != nil { panic(err) @@ -130,7 +130,7 @@ func (pk *PrivKeyLedger) PubKey() crypto.PubKey { // getPubKey reads the pubkey from cache or from the ledger itself // since this involves IO, it may return an error, which is not exposed // in the PubKey interface, so this function allows better error handling -func (pk *PrivKeyLedger) getPubKey() (key crypto.PubKey, err error) { +func (pk *PrivKeyLedgerEd25519) getPubKey() (key crypto.PubKey, err error) { // if we have no pubkey, set it if pk.CachedPubKey.Empty() { pk.CachedPubKey, err = pk.forceGetPubKey() @@ -140,7 +140,7 @@ func (pk *PrivKeyLedger) getPubKey() (key crypto.PubKey, err error) { // forceGetPubKey is like getPubKey but ignores any cached key // and ensures we get it from the ledger itself. -func (pk *PrivKeyLedger) forceGetPubKey() (key crypto.PubKey, err error) { +func (pk *PrivKeyLedgerEd25519) forceGetPubKey() (key crypto.PubKey, err error) { dev, err := getLedger() if err != nil { return key, errors.New("Can't connect to ledger device") @@ -154,23 +154,23 @@ func (pk *PrivKeyLedger) forceGetPubKey() (key crypto.PubKey, err error) { // Equals fulfils PrivKey Interface // TODO: needs to be fixed -func (pk *PrivKeyLedger) Equals(other crypto.PrivKey) bool { - if _, ok := other.Unwrap().(*PrivKeyLedger); ok { +func (pk *PrivKeyLedgerEd25519) Equals(other crypto.PrivKey) bool { + if _, ok := other.Unwrap().(*PrivKeyLedgerEd25519); ok { return true } return false } -// MockPrivKeyLedger behaves as the ledger, but stores a pre-packaged call-response +// MockPrivKeyLedgerEd25519 behaves as the ledger, but stores a pre-packaged call-response // for use in test cases -type MockPrivKeyLedger struct { +type MockPrivKeyLedgerEd25519 struct { Msg []byte Pub [KeyLength]byte Sig [SigLength]byte } // NewMockKey returns -func NewMockKey(msg, pubkey, sig string) (pk MockPrivKeyLedger) { +func NewMockKey(msg, pubkey, sig string) (pk MockPrivKeyLedgerEd25519) { var err error pk.Msg, err = hex.DecodeString(msg) if err != nil { @@ -191,32 +191,32 @@ func NewMockKey(msg, pubkey, sig string) (pk MockPrivKeyLedger) { return pk } -var _ crypto.PrivKeyInner = MockPrivKeyLedger{} +var _ crypto.PrivKeyInner = MockPrivKeyLedgerEd25519{} // AssertIsPrivKeyInner fulfils PrivKey Interface -func (pk MockPrivKeyLedger) AssertIsPrivKeyInner() {} +func (pk MockPrivKeyLedgerEd25519) AssertIsPrivKeyInner() {} // Bytes fulfils PrivKey Interface - not supported -func (pk MockPrivKeyLedger) Bytes() []byte { +func (pk MockPrivKeyLedgerEd25519) Bytes() []byte { return nil } // Sign returns a real SignatureLedger, if the msg matches what we expect -func (pk MockPrivKeyLedger) Sign(msg []byte) crypto.Signature { +func (pk MockPrivKeyLedgerEd25519) Sign(msg []byte) crypto.Signature { if !bytes.Equal(pk.Msg, msg) { panic("Mock key is for different msg") } return crypto.SignatureEd25519(pk.Sig).Wrap() } -// PubKey returns a real PubKeyLedger, that will verify this signature -func (pk MockPrivKeyLedger) PubKey() crypto.PubKey { - return PubKeyLedgerFromBytes(pk.Pub) +// PubKey returns a real PubKeyLedgerEd25519, that will verify this signature +func (pk MockPrivKeyLedgerEd25519) PubKey() crypto.PubKey { + return PubKeyLedgerEd25519FromBytes(pk.Pub) } // Equals compares that two Mocks have the same data -func (pk MockPrivKeyLedger) Equals(other crypto.PrivKey) bool { - if mock, ok := other.Unwrap().(MockPrivKeyLedger); ok { +func (pk MockPrivKeyLedgerEd25519) Equals(other crypto.PrivKey) bool { + if mock, ok := other.Unwrap().(MockPrivKeyLedgerEd25519); ok { return bytes.Equal(mock.Pub[:], pk.Pub[:]) && bytes.Equal(mock.Sig[:], pk.Sig[:]) && bytes.Equal(mock.Msg, pk.Msg) @@ -227,30 +227,30 @@ func (pk MockPrivKeyLedger) Equals(other crypto.PrivKey) bool { //////////////////////////////////////////// // pubkey -// PubKeyLedger works like a normal Ed25519 except a hash before the verify bytes -type PubKeyLedger struct { +// PubKeyLedgerEd25519 works like a normal Ed25519 except a hash before the verify bytes +type PubKeyLedgerEd25519 struct { crypto.PubKeyEd25519 } -// PubKeyLedgerFromBytes creates a PubKey from the raw bytes -func PubKeyLedgerFromBytes(key [32]byte) crypto.PubKey { - return PubKeyLedger{crypto.PubKeyEd25519(key)}.Wrap() +// PubKeyLedgerEd25519FromBytes creates a PubKey from the raw bytes +func PubKeyLedgerEd25519FromBytes(key [32]byte) crypto.PubKey { + return PubKeyLedgerEd25519{crypto.PubKeyEd25519(key)}.Wrap() } // Bytes fulfils pk Interface - no data, just type info -func (pk PubKeyLedger) Bytes() []byte { +func (pk PubKeyLedgerEd25519) Bytes() []byte { return wire.BinaryBytes(pk.Wrap()) } // VerifyBytes uses the normal Ed25519 algorithm but a sha512 hash beforehand -func (pk PubKeyLedger) VerifyBytes(msg []byte, sig crypto.Signature) bool { +func (pk PubKeyLedgerEd25519) VerifyBytes(msg []byte, sig crypto.Signature) bool { hmsg := hashMsg(msg) return pk.PubKeyEd25519.VerifyBytes(hmsg, sig) } // Equals implements PubKey interface -func (pk PubKeyLedger) Equals(other crypto.PubKey) bool { - if ledger, ok := other.Unwrap().(PubKeyLedger); ok { +func (pk PubKeyLedgerEd25519) Equals(other crypto.PubKey) bool { + if ledger, ok := other.Unwrap().(PubKeyLedgerEd25519); ok { return bytes.Equal(pk.PubKeyEd25519[:], ledger.PubKeyEd25519[:]) } return false @@ -260,24 +260,24 @@ func (pk PubKeyLedger) Equals(other crypto.PubKey) bool { func init() { crypto.PrivKeyMapper. - RegisterImplementation(&PrivKeyLedger{}, NameLedgerEd25519, TypeLedgerEd25519). - RegisterImplementation(MockPrivKeyLedger{}, "mock-ledger", 0x11) + RegisterImplementation(&PrivKeyLedgerEd25519{}, NameLedgerEd25519, TypeLedgerEd25519). + RegisterImplementation(MockPrivKeyLedgerEd25519{}, "mock-ledger", 0x11) crypto.PubKeyMapper. - RegisterImplementation(PubKeyLedger{}, NameLedgerEd25519, TypeLedgerEd25519) + RegisterImplementation(PubKeyLedgerEd25519{}, NameLedgerEd25519, TypeLedgerEd25519) } // Wrap fulfils interface for PrivKey struct -func (pk *PrivKeyLedger) Wrap() crypto.PrivKey { +func (pk *PrivKeyLedgerEd25519) Wrap() crypto.PrivKey { return crypto.PrivKey{pk} } // Wrap fulfils interface for PrivKey struct -func (pk MockPrivKeyLedger) Wrap() crypto.PrivKey { +func (pk MockPrivKeyLedgerEd25519) Wrap() crypto.PrivKey { return crypto.PrivKey{pk} } // Wrap fulfils interface for PubKey struct -func (pk PubKeyLedger) Wrap() crypto.PubKey { +func (pk PubKeyLedgerEd25519) Wrap() crypto.PubKey { return crypto.PubKey{pk} } diff --git a/nano/keys_test.go b/nano/keys_test.go index 3815d3944..15aa0d545 100644 --- a/nano/keys_test.go +++ b/nano/keys_test.go @@ -83,7 +83,7 @@ func TestRealLedger(t *testing.T) { } msg := []byte("kuhehfeohg") - priv, err := NewPrivKeyLedger() + priv, err := NewPrivKeyLedgerEd25519Ed25519() require.Nil(err, "%+v", err) pub := priv.PubKey() sig := priv.Sign(msg) @@ -123,13 +123,13 @@ func TestRealLedgerErrorHandling(t *testing.T) { // first, try to generate a key, must return an error // (no panic) - _, err := NewPrivKeyLedger() + _, err := NewPrivKeyLedgerEd25519Ed25519() require.Error(err) - led := PrivKeyLedger{} // empty + led := PrivKeyLedgerEd25519{} // empty // or with some pub key ed := crypto.GenPrivKeyEd25519() - led2 := PrivKeyLedger{CachedPubKey: ed.PubKey()} + led2 := PrivKeyLedgerEd25519{CachedPubKey: ed.PubKey()} // loading these should return errors bs := led.Bytes()