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         errorFormatter.Errors[pseudohsm.ErrDuplicateKeyAlias] = httperror.Info{400, "BTM050", "Alias already exists"}
  16         errorFormatter.Errors[pseudohsm.ErrInvalidAfter] = httperror.Info{400, "BTM801", "Invalid `after` in query"}
  17         errorFormatter.Errors[pseudohsm.ErrTooManyAliasesToList] = httperror.Info{400, "BTM802", "Too many aliases to list"}
  18 }
  19
  20 func (a *BlockchainReactor) pseudohsmCreateKey(ctx context.Context, in struct{ Alias, Password string }) (result *pseudohsm.XPub, err error) {
  21         return a.hsm.XCreate(in.Password, in.Alias)
  22 }
  23
  24 func (a *BlockchainReactor) pseudohsmListKeys(ctx context.Context, query requestQuery) (page, error) {
  25         limit := query.PageSize
  26         if limit == 0 {
  27                 limit = defGenericPageSize // defGenericPageSize = 100
  28         }
  29
  30         xpubs, after, err := a.hsm.ListKeys(query.After, limit)
  31         if err != nil {
  32                 return page{}, err
  33         }
  34
  35         var items []interface{}
  36         for _, xpub := range xpubs {
  37                 items = append(items, xpub)
  38         }
  39
  40         query.After = after
  41
  42         return page{
  43                 Items:    httpjson.Array(items),
  44                 LastPage: len(xpubs) < limit,
  45                 Next:     query,
  46         }, nil
  47 }
  48
  49 func (a *BlockchainReactor) pseudohsmDeleteKey(ctx context.Context, x struct {
  50         Password string
  51         XPub     chainkd.XPub `json:"xpubs"`
  52 }) error {
  53         return a.hsm.XDelete(x.XPub, x.Password)
  54 }
  55
  56 func (a *BlockchainReactor) pseudohsmSignTemplates(ctx context.Context, x struct {
  57         Auth  string
  58         Txs   []*txbuilder.Template `json:"transactions"`
  59         XPubs []chainkd.XPub        `json:"xpubs"`
  60 }) interface{} {
  61         resp := make([]interface{}, len(x.Txs))
  62         for _, tx := range x.Txs {
  63                 err := txbuilder.Sign(ctx, tx, x.XPubs, x.Auth, a.pseudohsmSignTemplate)
  64                 log.WithFields(log.Fields{"tx": tx, "build err": err}).Info("After sign transaction.")
  65                 if err != nil {
  66                         info := errorFormatter.Format(err)
  67                         resp = append(resp, info)
  68                 } else {
  69                         resp = append(resp, tx)
  70                 }
  71         }
  72         log.WithField("resp", resp).Info("Sign Transaction complete.")
  73         return resp
  74 }
  75
  76 func (a *BlockchainReactor) pseudohsmSignTemplate(ctx context.Context, xpub chainkd.XPub, path [][]byte, data [32]byte, password string) ([]byte, error) {
  77         sigBytes, err := a.hsm.XSign(xpub, path, data[:], password)
  78         if err == pseudohsm.ErrNoKey {
  79                 return nil, nil
  80         }
  81         return sigBytes, err
  82 }
  83
  84 func (a *BlockchainReactor) pseudohsmResetPassword(ctx context.Context, x struct {
  85         OldPassword string
  86         NewPassword string
  87         XPub        chainkd.XPub `json:"xpubs"`
  88 }) error {
  89         return a.hsm.ResetPassword(x.XPub, x.OldPassword, x.NewPassword)
  90 }
  91
  92 func (a *BlockchainReactor) pseudohsmUpdateAlias(ctx context.Context, x struct {
  93         Password string
  94         NewAlias string
  95         XPub     chainkd.XPub `json:"xpubs"`
  96 }) error {
  97         return a.hsm.UpdateAlias(x.XPub, x.Password, x.NewAlias)
  98 }