func (self *Config) postProcess() {
//var GenesisSignatureStr string //only set if passed in command line arg
//var GenesisAddressStr string //only set if passed in command line arg
//var BlockchainPubkeyStr string //only set if passed in command line arg
//var BlockchainSeckeyStr string //only set if passed in command line arg
var err error
if GenesisSignatureStr != "" {
self.GenesisSignature, err = cipher.SigFromHex(GenesisSignatureStr)
if err != nil {
log.Panic("Invalid Signature")
}
}
if GenesisAddressStr != "" {
self.GenesisAddress, err = cipher.DecodeBase58Address(GenesisAddressStr)
if err != nil {
log.Panic("Invalid Address")
}
}
if BlockchainPubkeyStr != "" {
self.BlockchainPubkey, err = cipher.PubKeyFromHex(BlockchainPubkeyStr)
if err != nil {
log.Panic("Invalid Pubkey")
}
}
if BlockchainSeckeyStr != "" {
self.BlockchainSeckey, err = cipher.SecKeyFromHex(BlockchainSeckeyStr)
if err != nil {
log.Panic("Invalid Seckey")
}
BlockchainSeckeyStr = ""
}
if BlockchainSeckeyStr != "" {
self.BlockchainSeckey = cipher.SecKey{}
}
self.DataDirectory = util.InitDataDir(self.DataDirectory)
if self.WebInterfaceCert == "" {
self.WebInterfaceCert = filepath.Join(self.DataDirectory, "cert.pem")
}
if self.WebInterfaceKey == "" {
self.WebInterfaceKey = filepath.Join(self.DataDirectory, "key.pem")
}
if self.BlockchainFile == "" {
self.BlockchainFile = filepath.Join(self.DataDirectory, "blockchain.bin")
}
if self.BlockSigsFile == "" {
self.BlockSigsFile = filepath.Join(self.DataDirectory, "blockchain.sigs")
}
if self.WalletDirectory == "" {
self.WalletDirectory = filepath.Join(self.DataDirectory, "wallets/")
}
ll, err := logging.LogLevel(self.logLevel)
if err != nil {
log.Panic("Invalid -log-level %s: %v\n", self.logLevel, err)
}
self.LogLevel = ll
}
// Authorize will decrypt the request, and it's a buildin middleware for skynet.
func Authorize(servSeckey string) HandlerFunc {
return func(c *Context) error {
var (
req pp.EncryptReq
rlt *pp.EmptyRes
)
c.ServSeckey = servSeckey
for {
if c.UnmarshalReq(&req) == nil {
// validate pubkey.
if err := validatePubkey(req.GetPubkey()); err != nil {
logger.Error(err.Error())
rlt = pp.MakeErrResWithCode(pp.ErrCode_WrongPubkey)
break
}
pubkey, err := cipher.PubKeyFromHex(req.GetPubkey())
if err != nil {
logger.Error(err.Error())
rlt = pp.MakeErrResWithCode(pp.ErrCode_WrongPubkey)
break
}
c.Pubkey = pubkey.Hex()
seckey, err := cipher.SecKeyFromHex(servSeckey)
if err != nil {
logger.Error(err.Error())
rlt = pp.MakeErrResWithCode(pp.ErrCode_ServerError)
break
}
key := cipher.ECDH(pubkey, seckey)
data, err := cipher.Chacha20Decrypt(req.GetEncryptdata(), key, req.GetNonce())
if err != nil {
logger.Error(err.Error())
rlt = pp.MakeErrResWithCode(pp.ErrCode_UnAuthorized)
break
}
ok, err := regexp.MatchString(`^\{.*\}$`, string(data))
if err != nil || !ok {
logger.Error(err.Error())
rlt = pp.MakeErrResWithCode(pp.ErrCode_UnAuthorized)
break
}
c.Raw = data
return c.Next()
}
rlt = pp.MakeErrRes(errors.New("bad request"))
break
}
return c.Error(rlt)
}
}
func validatePubkey(key string) (err error) {
defer func() {
// the PubKeyFromHex may panic if the key is invalidate.
// use recover to catch the panic, and return false.
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
}
}()
_, err = cipher.PubKeyFromHex(key)
return
}
func (c *Config) postProcess() {
var err error
if GenesisSignatureStr != "" {
c.GenesisSignature, err = cipher.SigFromHex(GenesisSignatureStr)
panicIfError(err, "Invalid Signature")
}
if GenesisAddressStr != "" {
c.GenesisAddress, err = cipher.DecodeBase58Address(GenesisAddressStr)
panicIfError(err, "Invalid Address")
}
if BlockchainPubkeyStr != "" {
c.BlockchainPubkey, err = cipher.PubKeyFromHex(BlockchainPubkeyStr)
panicIfError(err, "Invalid Pubkey")
}
if BlockchainSeckeyStr != "" {
c.BlockchainSeckey, err = cipher.SecKeyFromHex(BlockchainSeckeyStr)
panicIfError(err, "Invalid Seckey")
BlockchainSeckeyStr = ""
}
if BlockchainSeckeyStr != "" {
c.BlockchainSeckey = cipher.SecKey{}
}
c.DataDirectory = util.InitDataDir(c.DataDirectory)
if c.WebInterfaceCert == "" {
c.WebInterfaceCert = filepath.Join(c.DataDirectory, "cert.pem")
}
if c.WebInterfaceKey == "" {
c.WebInterfaceKey = filepath.Join(c.DataDirectory, "key.pem")
}
if c.BlockchainFile == "" {
c.BlockchainFile = filepath.Join(c.DataDirectory, "blockchain.bin")
}
if c.BlockSigsFile == "" {
c.BlockSigsFile = filepath.Join(c.DataDirectory, "blockchain.sigs")
}
if c.WalletDirectory == "" {
c.WalletDirectory = filepath.Join(c.DataDirectory, "wallets/")
}
ll, err := logging.LogLevel(c.logLevel)
panicIfError(err, "Invalid -log-level %s", c.logLevel)
c.LogLevel = ll
}
// ActiveAccount active the specific account.
// mode: PUT
// url: /api/v1/account/state?pubkey=[:pubkey]
func ActiveAccount(se Servicer) httprouter.Handle {
return func(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
var rlt *pp.EmptyRes
for {
// get pubkey
pk := r.FormValue("pubkey")
if pk == "" {
logger.Error("pubkey is empty")
rlt = pp.MakeErrRes(errors.New("pubkey is empty"))
break
}
// validate the pubkey
if _, err := cipher.PubKeyFromHex(pk); err != nil {
logger.Error(err.Error())
rlt = pp.MakeErrRes(errors.New("invalid pubkey"))
break
}
// active the account
if err := account.SetActive(pk); err != nil {
logger.Error(err.Error())
rlt = pp.MakeErrRes(err)
break
}
res := struct {
Result *pp.Result
}{
pp.MakeResultWithCode(pp.ErrCode_Success),
}
sendJSON(w, &res)
return
}
sendJSON(w, rlt)
}
}
// AdminUpdateBalance update balance of specific account
// mode: PUT
// url: /api/v1/admin/account/balance?dst=[:dst]&coin_type=[:coin_type]&amt=[:amt]
// params:
// dst: the dst account pubkey, whose balance will be updated.
// coin_type: skycoin or bitcoin, the coin you want to credit.
// amt: balance that will be updated.
func AdminUpdateBalance(se Servicer) httprouter.Handle {
return func(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
var rlt *pp.EmptyRes
for {
// get dst_pubkey
dstPk := r.FormValue("dst")
if dstPk == "" {
err := errors.New("dst pubkey is empty")
logger.Error(err.Error())
rlt = pp.MakeErrRes(err)
break
}
// validate the dst_pubkey
if _, err := cipher.PubKeyFromHex(dstPk); err != nil {
logger.Error(err.Error())
rlt = pp.MakeErrRes(errors.New("invalid dst pubkey"))
break
}
// get coin type.
cp := r.FormValue("coin_type")
if cp == "" {
err := errors.New("coin_type is empty")
logger.Error(err.Error())
rlt = pp.MakeErrRes(err)
break
}
// get amt
amt := r.FormValue("amt")
if amt == "" {
err := errors.New("amt is empty")
logger.Error(err.Error())
rlt = pp.MakeErrRes(err)
break
}
amount, err := strconv.ParseUint(amt, 10, 64)
if err != nil {
logger.Error(err.Error())
rlt = pp.MakeErrRes(err)
break
}
a, err := account.GetActive()
if err != nil {
logger.Error(err.Error())
rlt = pp.MakeErrRes(err)
break
}
req := pp.UpdateCreditReq{
Pubkey: pp.PtrString(a.Pubkey),
CoinType: pp.PtrString(cp),
Amount: pp.PtrUint64(amount),
Dst: pp.PtrString(dstPk),
}
res := pp.UpdateCreditRes{}
if err := sknet.EncryGet(se.GetServAddr(), "/admin/update/credit", req, &res); err != nil {
logger.Error(err.Error())
rlt = pp.MakeErrResWithCode(pp.ErrCode_ServerError)
break
}
sendJSON(w, res)
return
}
sendJSON(w, rlt)
}
}