Golang utils.BinToHex函數代碼示例

func (p *Parser) NewUserInit() error {
	err := p.GetTxMaps([]map[string]string{{"public_key": "bytes"}, {"sign": "bytes"}})
	if err != nil {
		return p.ErrInfo(err)
	}
	p.TxMap["public_key_hex"] = utils.BinToHex(p.TxMap["public_key"])
	p.TxMaps.Bytes["public_key_hex"] = utils.BinToHex(p.TxMaps.Bytes["public_key"])
	return nil
}

func (p *Parser) MessageToAdminInit() error {
	fields := []map[string]string{{"encrypted_message": "bytes"}, {"sign": "bytes"}}
	err := p.GetTxMaps(fields)
	if err != nil {
		return p.ErrInfo(err)
	}
	p.TxMaps.Bytes["encrypted_message"] = utils.BinToHex(p.TxMaps.Bytes["encrypted_message"])
	p.TxMap["encrypted_message"] = utils.BinToHex(p.TxMap["encrypted_message"])
	return nil
}

func (p *Parser) ChangeNodeKeyInit() error {

	fields := []map[string]string{{"new_node_public_key": "bytes"}, {"sign": "bytes"}}
	err := p.GetTxMaps(fields)
	if err != nil {
		return p.ErrInfo(err)
	}
	p.TxMaps.Bytes["new_node_public_key"] = utils.BinToHex(p.TxMaps.Bytes["new_node_public_key"])
	p.TxMap["new_node_public_key"] = utils.BinToHex(p.TxMap["new_node_public_key"])
	return nil
}

func (p *Parser) AdminChangePrimaryKeyInit() error {

	fields := []map[string]string{{"for_user_id": "int64"}, {"public_key": "bytes"}, {"sign": "bytes"}}
	err := p.GetTxMaps(fields)
	if err != nil {
		return p.ErrInfo(err)
	}
	p.TxMaps.Bytes["public_key_hex"] = utils.BinToHex(p.TxMaps.Bytes["public_key"])
	p.TxMap["public_key_hex"] = utils.BinToHex(p.TxMap["public_key"])
	return nil
}

func (p *Parser) ChangePrimaryKeyRollback() error {

	// получим log_id, по которому можно найти данные, которые были до этого
	// $log_id всегда больше нуля, т.к. это откат обновления ключа
	logId, err := p.Single("SELECT log_id FROM users WHERE user_id  =  ?", p.TxUserID).Int64()
	if err != nil {
		return p.ErrInfo(err)
	}

	// данные, которые восстановим
	var public_key_0, public_key_1, public_key_2 []byte
	var prev_log_id int64
	err = p.QueryRow(p.FormatQuery("SELECT public_key_0, public_key_1, public_key_2, prev_log_id FROM log_users WHERE log_id  =  ?"), logId).Scan(&public_key_0, &public_key_1, &public_key_2, &prev_log_id)
	if err != nil && err != sql.ErrNoRows {
		return p.ErrInfo(err)
	}
	if len(public_key_0) > 0 {
		public_key_0 = utils.BinToHex(public_key_0)
	}
	if len(public_key_1) > 0 {
		public_key_1 = utils.BinToHex(public_key_1)
	}
	if len(public_key_2) > 0 {
		public_key_2 = utils.BinToHex(public_key_2)
	}

	err = p.ExecSql("UPDATE users SET public_key_0 = [hex], public_key_1 = [hex], public_key_2 = [hex], log_id = ? WHERE user_id = ?", public_key_0, public_key_1, public_key_2, prev_log_id, p.TxUserID)
	if err != nil {
		return p.ErrInfo(err)
	}
	// подчищаем _log
	err = p.ExecSql("DELETE FROM log_users WHERE log_id = ?", logId)
	if err != nil {
		return p.ErrInfo(err)
	}
	p.rollbackAI("log_users", 1)

	// проверим, не наш ли это user_id
	myUserId, _, myPrefix, _, err := p.GetMyUserId(p.TxUserID)
	if err != nil {
		return err
	}
	if p.TxUserID == myUserId {
		// обновим статус в нашей локальной табле.
		err = p.ExecSql("UPDATE "+myPrefix+"my_keys SET status = 'my_pending', block_id = 0, time = 0 WHERE hex(public_key) = ? AND status = 'approved' AND block_id = ?", p.newPublicKeysHex[0], p.BlockData.BlockId)
		if err != nil {
			return p.ErrInfo(err)
		}
	}

	return nil
}

func (p *Parser) NewMinerInit() error {
	var fields []map[string]string
	if p.BlockData != nil && p.BlockData.BlockId < 250900 {
		fields = []map[string]string{{"race": "int64"}, {"country": "int64"}, {"latitude": "float64"}, {"longitude": "float64"}, {"http_host": "string"}, {"face_coords": "string"}, {"profile_coords": "string"}, {"face_hash": "string"}, {"profile_hash": "string"}, {"video_type": "string"}, {"video_url_id": "string"}, {"node_public_key": "bytes"}, {"sign": "bytes"}}
	} else {
		fields = []map[string]string{{"race": "int64"}, {"country": "int64"}, {"latitude": "float64"}, {"longitude": "float64"}, {"http_host": "string"}, {"tcp_host": "string"}, {"face_coords": "string"}, {"profile_coords": "string"}, {"face_hash": "string"}, {"profile_hash": "string"}, {"video_type": "string"}, {"video_url_id": "string"}, {"node_public_key": "bytes"}, {"sign": "bytes"}}
	}
	err := p.GetTxMaps(fields)
	if err != nil {
		return p.ErrInfo(err)
	}
	p.TxMap["node_public_key"] = utils.BinToHex(p.TxMap["node_public_key"])
	p.TxMaps.Bytes["node_public_key"] = utils.BinToHex(p.TxMaps.Bytes["node_public_key"])
	return nil
}

/* не забываем, что cash_request_OUT_front проверяет формат amount,
 * можно ли делать запрос указанному юзеру, есть ли у юзера
 * обещанные суммы на сумму amount, есть ли нужное кол-во DC у отправителя,
 * является ли отправитель майнером
 *
 * */
func (p *Parser) CashRequestInFront() error {

	err := p.generalCheck()
	if err != nil {
		return p.ErrInfo(err)
	}

	// code может быть чем угодно, т.к. отправитель шлет в сеть лишь хэш
	// нигде, кроме cash_request_in_front, code не используется
	// if ( !check_input_data ($this->tx_data['code'], 'cash_code') )
	//	return 'cash_request_in_front code';

	verifyData := map[string]string{"cash_request_id": "bigint"}
	err = p.CheckInputData(verifyData)
	if err != nil {
		return p.ErrInfo(err)
	}

	var to_user_id, cTime int64
	var status string
	var hash_code []byte
	err = p.QueryRow(p.FormatQuery("SELECT to_user_id, status, hash_code, time FROM cash_requests WHERE id  =  ?"), p.TxMaps.Int64["cash_request_id"]).Scan(&to_user_id, &status, &hash_code, &cTime)
	if err != nil && err != sql.ErrNoRows {
		return p.ErrInfo(err)
	}

	// ID cash_requests юзер указал сам, значит это может быть случайное число.
	// проверим, является получателем наш юзер
	if to_user_id != p.TxUserID {
		return p.ErrInfo("to_user_id!=user_id")
	}
	// должно быть pending
	if status != "pending" {
		return p.ErrInfo("status!=pending")
	}
	// проверим код
	if !bytes.Equal(utils.DSha256(p.TxMaps.String["code"]), utils.BinToHex(hash_code)) {
		return p.ErrInfo("code!=hash_code")
	}
	var txTime int64
	if p.BlockData != nil { // тр-ия пришла в блоке
		txTime = p.BlockData.Time
	} else {
		txTime = time.Now().Unix() // просто на всякий случай небольшой запас
	}
	// запрос может быть принят, только если он был отправлен не позднее чем через cash_request_time сек назад
	if cTime < txTime-p.Variables.Int64["cash_request_time"] {
		return p.ErrInfo(fmt.Sprintf("%d < %d - %d", cTime, txTime, p.Variables.Int64["cash_request_time"]))
	}

	forSign := fmt.Sprintf("%s,%s,%s,%s,%s", p.TxMap["type"], p.TxMap["time"], p.TxMap["user_id"], p.TxMap["cash_request_id"], p.TxMap["code"])
	CheckSignResult, err := utils.CheckSign(p.PublicKeys, forSign, p.TxMap["sign"], false)
	if err != nil {
		return p.ErrInfo(err)
	}
	if !CheckSignResult {
		return p.ErrInfo("incorrect sign")
	}
	return nil
}

func (c *Controller) EncryptChatMessage() (string, error) {

	var err error

	c.r.ParseForm()

	receiver := c.r.FormValue("receiver")
	message := c.r.FormValue("message")
	if len(message) > 5120 {
		return "", errors.New("incorrect message")
	}

	publicKey, err := c.Single("SELECT public_key_0 FROM users WHERE user_id  =  ?", receiver).Bytes()
	if err != nil {
		return "", utils.ErrInfo(err)
	}

	if len(publicKey) > 0 {
		pub, err := utils.BinToRsaPubKey(publicKey)
		if err != nil {
			return "", utils.ErrInfo(err)
		}
		enc_, err := rsa.EncryptPKCS1v15(rand.Reader, pub, []byte(message))
		if err != nil {
			return "", utils.ErrInfo(err)
		}
		return utils.JsonAnswer(string(utils.BinToHex(enc_)), "success").String(), nil
	} else {
		return utils.JsonAnswer("Incorrect user_id", "error").String(), nil
	}

}

func (p *Parser) ChangeNodeKey() error {

	// Всегда есть, что логировать, т.к. это обновление ключа
	logData, err := p.OneRow("SELECT * FROM miners_data WHERE user_id  =  ?", p.TxUserID).String()
	if err != nil {
		return p.ErrInfo(err)
	}
	nodePublicKeyHex := utils.BinToHex([]byte(logData["node_public_key"]))

	logId, err := p.ExecSqlGetLastInsertId("INSERT INTO log_miners_data ( node_public_key, block_id, prev_log_id ) VALUES ( [hex], ?, ? )", "log_id", nodePublicKeyHex, p.BlockData.BlockId, logData["log_id"])
	if err != nil {
		return p.ErrInfo(err)
	}
	err = p.ExecSql("UPDATE miners_data SET node_public_key = [hex], log_id = ? WHERE user_id = ?", p.TxMaps.Bytes["new_node_public_key"], logId, p.TxUserID)
	if err != nil {
		return p.ErrInfo(err)
	}

	// проверим, не наш ли это user_id
	myUserId, myBlockId, myPrefix, _, err := p.GetMyUserId(p.TxMaps.Int64["user_id"])
	if err != nil {
		return err
	}
	if p.TxUserID == myUserId && myBlockId <= p.BlockData.BlockId {
		// обновим статус в нашей локальной табле.
		err = p.ExecSql("UPDATE "+myPrefix+"my_node_keys SET status = 'approved', block_id = ?, time = ? WHERE hex(public_key) = ? AND status = 'my_pending'", p.BlockData.BlockId, p.BlockData.Time, p.TxMaps.Bytes["new_node_public_key"])
		if err != nil {
			return p.ErrInfo(err)
		}
	}

	return nil
}

func (p *Parser) MoneyBackRequestFront() error {

	err := p.generalCheck()
	if err != nil {
		return p.ErrInfo(err)
	}

	verifyData := map[string]string{"order_id": "bigint", "seller_enc_text": "comment", "arbitrator0_enc_text": "comment", "arbitrator1_enc_text": "comment", "arbitrator2_enc_text": "comment", "arbitrator3_enc_text": "comment", "arbitrator4_enc_text": "comment"}
	err = p.CheckInputData(verifyData)
	if err != nil {
		return p.ErrInfo(err)
	}

	var txTime int64
	if p.BlockData != nil { // тр-ия пришла в блоке
		txTime = p.BlockData.Time
	} else { // голая тр-ия
		txTime = time.Now().Unix() - 30 // просто на всякий случай небольшой запас
	}

	// проверим, есть ли такой ордер, не был ли ранее запрос, точно ли покупатель наш юзер
	orderId, err := p.Single("SELECT id FROM orders WHERE id  =  ? AND status  =  'normal' AND end_time > ? AND buyer  =  ?", p.TxMaps.Int64["order_id"], txTime, p.TxUserID).Int64()
	if err != nil {
		return p.ErrInfo(err)
	}
	if orderId == 0 {
		return p.ErrInfo("orderId==0")
	}

	forSign := ""
	if p.BlockData != nil && p.BlockData.BlockId < 197115 {
		forSign = fmt.Sprintf("%s,%s,%s,%s,%s,%s,%s,%s,%s,%s", p.TxMap["type"], p.TxMap["time"], p.TxMap["user_id"], p.TxMap["order_id"], p.TxMap["arbitrator0_enc_text"], p.TxMap["arbitrator1_enc_text"], p.TxMap["arbitrator2_enc_text"], p.TxMap["arbitrator3_enc_text"], p.TxMap["arbitrator4_enc_text"], p.TxMap["seller_enc_text"])

	} else {
		encData := make(map[string]string)
		for i := 0; i < 5; i++ {
			iStr := utils.IntToStr(i)
			encData["arbitrator"+iStr+"_enc_text"] = string(utils.BinToHex(p.TxMap["arbitrator"+iStr+"_enc_text"]))
			if encData["arbitrator"+iStr+"_enc_text"] == "00" {
				encData["arbitrator"+iStr+"_enc_text"] = "0"
			}
		}
		forSign = fmt.Sprintf("%s,%s,%s,%s,%s,%s,%s,%s,%s,%s", p.TxMap["type"], p.TxMap["time"], p.TxMap["user_id"], p.TxMap["order_id"], encData["arbitrator0_enc_text"], encData["arbitrator1_enc_text"], encData["arbitrator2_enc_text"], encData["arbitrator3_enc_text"], encData["arbitrator4_enc_text"], utils.BinToHex(p.TxMap["seller_enc_text"]))
	}

	CheckSignResult, err := utils.CheckSign(p.PublicKeys, forSign, p.TxMap["sign"], false)
	if err != nil {
		return p.ErrInfo(err)
	}
	if !CheckSignResult {
		return p.ErrInfo("incorrect sign")
	}

	err = p.limitRequest(consts.LIMIT_MONEY_BACK_REQUEST, "money_back_request", consts.LIMIT_MONEY_BACK_REQUEST_PERIOD)
	if err != nil {
		return p.ErrInfo(err)
	}
	return nil
}

func (p *Parser) ChangeKeyActiveInit() error {

	fields := []map[string]string{{"secret": "bytes"}, {"sign": "bytes"}}
	err := p.GetTxMaps(fields)
	if err != nil {
		return p.ErrInfo(err)
	}
	p.TxMaps.String["secret_hex"] = string(utils.BinToHex(p.TxMaps.Bytes["secret"]))
	if p.TxMaps.String["secret_hex"] == "30" {
		p.TxMaps.Int64["active"] = 0
	} else {
		p.TxMaps.Int64["active"] = 1
	}
	p.TxMaps.String["secret_hex"] = string(utils.BinToHex(p.TxMaps.Bytes["secret"]))

	return nil
}

func (p *Parser) SendDcInit() error {
	var fields []map[string]string
	if p.BlockData != nil && p.BlockData.BlockId <= consts.ARBITRATION_BLOCK_START {
		fields = []map[string]string{{"to_user_id": "int64"}, {"currency_id": "int64"}, {"amount": "float64"}, {"commission": "float64"}, {"comment": "string"}, {"sign": "bytes"}}
	} else {
		fields = []map[string]string{{"to_user_id": "int64"}, {"currency_id": "int64"}, {"amount": "float64"}, {"commission": "float64"}, {"arbitrator0": "int64"}, {"arbitrator1": "int64"}, {"arbitrator2": "int64"}, {"arbitrator3": "int64"}, {"arbitrator4": "int64"}, {"arbitrator0_commission": "float64"}, {"arbitrator1_commission": "float64"}, {"arbitrator2_commission": "float64"}, {"arbitrator3_commission": "float64"}, {"arbitrator4_commission": "float64"}, {"comment": "string"}, {"sign": "bytes"}}
	}

	err := p.GetTxMaps(fields)
	if err != nil {
		return p.ErrInfo(err)
	}
	p.TxMaps.Bytes["hash_hex"] = utils.BinToHex(p.TxMaps.Bytes["hash"])
	p.TxMaps.Int64["from_user_id"] = p.TxMaps.Int64["user_id"]
	p.TxMap["hash_hex"] = utils.BinToHex(p.TxMap["hash"])
	p.TxMap["from_user_id"] = p.TxMap["user_id"]
	if p.TxMaps.String["comment"] == "null" {
		p.TxMaps.String["comment"] = ""
		p.TxMap["comment"] = []byte("")
	}
	return nil
}

func (c *Controller) CheckSetupPassword() (string, error) {

	c.r.ParseForm()
	password, err := c.Single(`SELECT setup_password FROM config WHERE setup_password = ?`, utils.DSha256(c.r.FormValue("password"))).String()
	if err != nil {
		return "", err
	}
	if len(password) > 0 && !c.Community {
		userId, err := c.GetMyUserId("")
		if err != nil {
			return "", err
		}
		publicKey, err := c.GetUserPublicKey(userId)
		if err != nil {
			return "", err
		}
		c.sess.Set("user_id", userId)
		c.sess.Set("public_key", string(utils.BinToHex(publicKey)))
		log.Debug("public_key check: %s", string(utils.BinToHex(publicKey)))
		return "ok", nil
	}
	return "", nil

}

func (c *Controller) EDataBaseDump() (string, error) {

	if !c.NodeAdmin || c.SessRestricted != 0 {
		return "", utils.ErrInfo(errors.New("Permission denied"))
	}

	allTables, err := c.GetAllTables()
	if err != nil {
		return "", utils.ErrInfo(err)
	}
	c.r.ParseForm()

	mainMap := make(map[string][]map[string]string)

	for _, table := range allTables {
		re := regexp.MustCompile("^e_")
		match := re.FindStringSubmatch(table)
		if len(match) > 0 {
			data, err := c.GetAll(`SELECT * FROM `+table, -1)
			if err != nil {
				return "", utils.ErrInfo(err)
			}
			for k, arr := range data {
				for name, value := range arr {
					if ok, _ := regexp.MatchString("(tx_hash)", name); ok {
						data[k][name] = string(utils.BinToHex([]byte(value)))
					}
				}
			}
			mainMap[table] = data
		}
	}

	jsonData, _ := json.Marshal(mainMap)
	log.Debug(string(jsonData))

	c.w.Header().Set("Content-Type", "text/plain")
	c.w.Header().Set("Content-Length", utils.IntToStr(len(jsonData)))
	t := time.Unix(utils.Time(), 0)
	c.w.Header().Set("Content-Disposition", `attachment; filename="dcoin_e_backup-`+t.Format(c.TimeFormat)+`.txt`)
	if _, err := c.w.Write(jsonData); err != nil {
		return "", utils.ErrInfo(errors.New("unable to write text"))
	}

	return "", nil
}

func (p *Parser) ChangeNodeKeyRollback() error {
	// получим log_id, по которому можно найти данные, которые были до этого
	// $log_id всегда больше нуля, т.к. это откат обновления ключа

	logId, err := p.Single("SELECT log_id FROM miners_data WHERE user_id  =  ?", p.TxUserID).Int64()
	if err != nil {
		return p.ErrInfo(err)
	}

	// данные, которые восстановим
	data, err := p.OneRow("SELECT node_public_key, prev_log_id FROM log_miners_data WHERE log_id  =  ?", logId).String()
	if err != nil {
		return p.ErrInfo(err)
	}
	nodePublicKeyHex := utils.BinToHex([]byte(data["node_public_key"]))
	err = p.ExecSql("UPDATE miners_data SET node_public_key =[hex], log_id = ? WHERE user_id = ?", nodePublicKeyHex, data["prev_log_id"], p.TxUserID)
	if err != nil {
		return p.ErrInfo(err)
	}

	// подчищаем _log
	err = p.ExecSql("DELETE FROM log_miners_data WHERE log_id = ?", logId)
	if err != nil {
		return p.ErrInfo(err)
	}
	err = p.rollbackAI("log_miners_data", 1)
	if err != nil {
		return p.ErrInfo(err)
	}
	// проверим, не наш ли это user_id
	myUserId, _, myPrefix, _, err := p.GetMyUserId(p.TxMaps.Int64["user_id"])
	if err != nil {
		return err
	}
	if p.TxUserID == myUserId {
		// обновим статус в нашей локальной табле.
		err = p.ExecSql("UPDATE "+myPrefix+"my_node_keys SET status = 'my_pending', block_id = 0, time = 0 WHERE hex(public_key) = ? AND status = 'approved' AND block_id = ?", p.TxMaps.Bytes["new_node_public_key"], p.BlockData.BlockId)
		if err != nil {
			return p.ErrInfo(err)
		}
	}

	return nil
}