blockchain/hsm.go

   1 package blockchain
   2
   3 import (
   4         "context"
   5
   6         "github.com/bytom/blockchain/pseudohsm"
   7         "github.com/bytom/blockchain/txbuilder"
   8         "github.com/bytom/crypto/ed25519/chainkd"
   9         "github.com/bytom/net/http/httperror"
  10         "github.com/bytom/net/http/httpjson"
  11         log "github.com/sirupsen/logrus"
  12 )
  13
  14 func init() {
  15         //Error code 050 represents alias of key duplicated
  16         errorFormatter.Errors[pseudohsm.ErrDuplicateKeyAlias] = httperror.Info{400, "BTM050", "Alias already exists"}
  17         //Error code 801 represents query request format error
  18         errorFormatter.Errors[pseudohsm.ErrInvalidAfter] = httperror.Info{400, "BTM801", "Invalid `after` in query"}
  19         //Error code 802 represents query reponses too many
  20         errorFormatter.Errors[pseudohsm.ErrTooManyAliasesToList] = httperror.Info{400, "BTM802", "Too many aliases to list"}
  21 }
  22
  23 func (a *BlockchainReactor) pseudohsmCreateKey(ctx context.Context, in struct{ Alias, Password string }) (result *pseudohsm.XPub, err error) {
  24         return a.hsm.XCreate(in.Alias, in.Password)
  25 }
  26
  27 func (a *BlockchainReactor) pseudohsmListKeys(ctx context.Context, query requestQuery) (page, error) {
  28         limit := query.PageSize
  29         if limit == 0 {
  30                 limit = defGenericPageSize // defGenericPageSize = 100
  31         }
  32
  33         xpubs, after, err := a.hsm.ListKeys(query.After, limit)
  34         if err != nil {
  35                 return page{}, err
  36         }
  37
  38         var items []interface{}
  39         for _, xpub := range xpubs {
  40                 items = append(items, xpub)
  41         }
  42
  43         query.After = after
  44
  45         return page{
  46                 Items:    httpjson.Array(items),
  47                 LastPage: len(xpubs) < limit,
  48                 Next:     query,
  49         }, nil
  50 }
  51
  52 func (a *BlockchainReactor) pseudohsmDeleteKey(ctx context.Context, x struct {
  53         Password string
  54         XPub     chainkd.XPub `json:"xpubs"`
  55 }) error {
  56         return a.hsm.XDelete(x.XPub, x.Password)
  57 }
  58
  59 func (a *BlockchainReactor) pseudohsmSignTemplates(ctx context.Context, x struct {
  60         Auth string
  61         Txs  []*txbuilder.Template `json:"transactions"`
  62         XPub chainkd.XPub          `json:"xpubs"`
  63         XPrv chainkd.XPrv          `json:"xprv"`
  64 }) interface{} {
  65         resp := make([]interface{}, len(x.Txs))
  66         var err error
  67         for _, tx := range x.Txs {
  68                 if x.Auth == "" {
  69                         err = txbuilder.Sign(context.Background(), tx, []chainkd.XPub{x.XPrv.XPub()}, "", func(_ context.Context, _ chainkd.XPub, path [][]byte, data [32]byte, _ string) ([]byte, error) {
  70                                 derived := x.XPrv.Derive(path)
  71                                 return derived.Sign(data[:]), nil
  72                         })
  73                 } else {
  74                         err = txbuilder.Sign(ctx, tx, []chainkd.XPub{x.XPub}, x.Auth, a.pseudohsmSignTemplate)
  75                 }
  76
  77                 log.WithFields(log.Fields{"tx": tx, "build err": err}).Info("After sign transaction.")
  78                 if err != nil {
  79                         info := errorFormatter.Format(err)
  80                         resp = append(resp, info)
  81                 } else {
  82                         resp = append(resp, tx)
  83                 }
  84         }
  85         log.WithField("resp", resp).Info("Sign Transaction complete.")
  86         return resp
  87 }
  88
  89 func (a *BlockchainReactor) pseudohsmSignTemplate(ctx context.Context, xpub chainkd.XPub, path [][]byte, data [32]byte, password string) ([]byte, error) {
  90         sigBytes, err := a.hsm.XSign(xpub, path, data[:], password)
  91         if err == pseudohsm.ErrNoKey {
  92                 return nil, nil
  93         }
  94         return sigBytes, err
  95 }
  96
  97 func (a *BlockchainReactor) pseudohsmResetPassword(ctx context.Context, x struct {
  98         OldPassword string
  99         NewPassword string
 100         XPub        chainkd.XPub `json:"xpubs"`
 101 }) error {
 102         return a.hsm.ResetPassword(x.XPub, x.OldPassword, x.NewPassword)
 103 }
 104
 105 func (a *BlockchainReactor) pseudohsmUpdateAlias(ctx context.Context, x struct {
 106         Password string
 107         NewAlias string
 108         XPub     chainkd.XPub `json:"xpubs"`
 109 }) error {
 110         return a.hsm.UpdateAlias(x.XPub, x.Password, x.NewAlias)
 111 }