vendor/github.com/tendermint/go-crypto/keys/cryptostore/generator.go

   1 package cryptostore
   2
   3 import (
   4         "github.com/pkg/errors"
   5         crypto "github.com/tendermint/go-crypto"
   6         "github.com/tendermint/go-crypto/nano"
   7 )
   8
   9 var (
  10         // GenEd25519 produces Ed25519 private keys
  11         GenEd25519 Generator = GenFunc(genEd25519)
  12         // GenSecp256k1 produces Secp256k1 private keys
  13         GenSecp256k1 Generator = GenFunc(genSecp256)
  14         // GenLedgerEd25519 used Ed25519 keys stored on nano ledger s with cosmos app
  15         GenLedgerEd25519 Generator = GenFunc(genLedgerEd25519)
  16 )
  17
  18 // Generator determines the type of private key the keystore creates
  19 type Generator interface {
  20         Generate(secret []byte) (crypto.PrivKey, error)
  21 }
  22
  23 // GenFunc is a helper to transform a function into a Generator
  24 type GenFunc func(secret []byte) (crypto.PrivKey, error)
  25
  26 func (f GenFunc) Generate(secret []byte) (crypto.PrivKey, error) {
  27         return f(secret)
  28 }
  29
  30 func genEd25519(secret []byte) (crypto.PrivKey, error) {
  31         key := crypto.GenPrivKeyEd25519FromSecret(secret).Wrap()
  32         return key, nil
  33 }
  34
  35 func genSecp256(secret []byte) (crypto.PrivKey, error) {
  36         key := crypto.GenPrivKeySecp256k1FromSecret(secret).Wrap()
  37         return key, nil
  38 }
  39
  40 // secret is completely ignored for the ledger...
  41 // just for interface compatibility
  42 func genLedgerEd25519(secret []byte) (crypto.PrivKey, error) {
  43         return nano.NewPrivKeyLedgerEd25519Ed25519()
  44 }
  45
  46 type genInvalidByte struct {
  47         typ byte
  48 }
  49
  50 func (g genInvalidByte) Generate(secret []byte) (crypto.PrivKey, error) {
  51         err := errors.Errorf("Cannot generate keys for algorithm: %X", g.typ)
  52         return crypto.PrivKey{}, err
  53 }
  54
  55 type genInvalidAlgo struct {
  56         algo string
  57 }
  58
  59 func (g genInvalidAlgo) Generate(secret []byte) (crypto.PrivKey, error) {
  60         err := errors.Errorf("Cannot generate keys for algorithm: %s", g.algo)
  61         return crypto.PrivKey{}, err
  62 }
  63
  64 func getGenerator(algo string) Generator {
  65         switch algo {
  66         case crypto.NameEd25519:
  67                 return GenEd25519
  68         case crypto.NameSecp256k1:
  69                 return GenSecp256k1
  70         case nano.NameLedgerEd25519:
  71                 return GenLedgerEd25519
  72         default:
  73                 return genInvalidAlgo{algo}
  74         }
  75 }
  76
  77 func getGeneratorByType(typ byte) Generator {
  78         switch typ {
  79         case crypto.TypeEd25519:
  80                 return GenEd25519
  81         case crypto.TypeSecp256k1:
  82                 return GenSecp256k1
  83         case nano.TypeLedgerEd25519:
  84                 return GenLedgerEd25519
  85         default:
  86                 return genInvalidByte{typ}
  87         }
  88 }