256 lines
7.1 KiB
Go
256 lines
7.1 KiB
Go
// Copyright 2018 The go-ethereum Authors
|
|
// This file is part of go-ethereum.
|
|
//
|
|
// go-ethereum is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// go-ethereum is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package core
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"strings"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
|
|
"bytes"
|
|
"os"
|
|
"regexp"
|
|
)
|
|
|
|
type decodedArgument struct {
|
|
soltype abi.Argument
|
|
value interface{}
|
|
}
|
|
type decodedCallData struct {
|
|
signature string
|
|
name string
|
|
inputs []decodedArgument
|
|
}
|
|
|
|
// String implements stringer interface, tries to use the underlying value-type
|
|
func (arg decodedArgument) String() string {
|
|
var value string
|
|
switch val := arg.value.(type) {
|
|
case fmt.Stringer:
|
|
value = val.String()
|
|
default:
|
|
value = fmt.Sprintf("%v", val)
|
|
}
|
|
return fmt.Sprintf("%v: %v", arg.soltype.Type.String(), value)
|
|
}
|
|
|
|
// String implements stringer interface for decodedCallData
|
|
func (cd decodedCallData) String() string {
|
|
args := make([]string, len(cd.inputs))
|
|
for i, arg := range cd.inputs {
|
|
args[i] = arg.String()
|
|
}
|
|
return fmt.Sprintf("%s(%s)", cd.name, strings.Join(args, ","))
|
|
}
|
|
|
|
// parseCallData matches the provided call data against the abi definition,
|
|
// and returns a struct containing the actual go-typed values
|
|
func parseCallData(calldata []byte, abidata string) (*decodedCallData, error) {
|
|
|
|
if len(calldata) < 4 {
|
|
return nil, fmt.Errorf("Invalid ABI-data, incomplete method signature of (%d bytes)", len(calldata))
|
|
}
|
|
|
|
sigdata, argdata := calldata[:4], calldata[4:]
|
|
if len(argdata)%32 != 0 {
|
|
return nil, fmt.Errorf("Not ABI-encoded data; length should be a multiple of 32 (was %d)", len(argdata))
|
|
}
|
|
|
|
abispec, err := abi.JSON(strings.NewReader(abidata))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("Failed parsing JSON ABI: %v, abidata: %v", err, abidata)
|
|
}
|
|
|
|
method, err := abispec.MethodById(sigdata)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
v, err := method.Inputs.UnpackValues(argdata)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
decoded := decodedCallData{signature: method.Sig(), name: method.Name}
|
|
|
|
for n, argument := range method.Inputs {
|
|
if err != nil {
|
|
return nil, fmt.Errorf("Failed to decode argument %d (signature %v): %v", n, method.Sig(), err)
|
|
}
|
|
decodedArg := decodedArgument{
|
|
soltype: argument,
|
|
value: v[n],
|
|
}
|
|
decoded.inputs = append(decoded.inputs, decodedArg)
|
|
}
|
|
|
|
// We're finished decoding the data. At this point, we encode the decoded data to see if it matches with the
|
|
// original data. If we didn't do that, it would e.g. be possible to stuff extra data into the arguments, which
|
|
// is not detected by merely decoding the data.
|
|
|
|
var (
|
|
encoded []byte
|
|
)
|
|
encoded, err = method.Inputs.PackValues(v)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if !bytes.Equal(encoded, argdata) {
|
|
was := common.Bytes2Hex(encoded)
|
|
exp := common.Bytes2Hex(argdata)
|
|
return nil, fmt.Errorf("WARNING: Supplied data is stuffed with extra data. \nWant %s\nHave %s\nfor method %v", exp, was, method.Sig())
|
|
}
|
|
return &decoded, nil
|
|
}
|
|
|
|
// MethodSelectorToAbi converts a method selector into an ABI struct. The returned data is a valid json string
|
|
// which can be consumed by the standard abi package.
|
|
func MethodSelectorToAbi(selector string) ([]byte, error) {
|
|
|
|
re := regexp.MustCompile(`^([^\)]+)\(([a-z0-9,\[\]]*)\)`)
|
|
|
|
type fakeArg struct {
|
|
Type string `json:"type"`
|
|
}
|
|
type fakeABI struct {
|
|
Name string `json:"name"`
|
|
Type string `json:"type"`
|
|
Inputs []fakeArg `json:"inputs"`
|
|
}
|
|
groups := re.FindStringSubmatch(selector)
|
|
if len(groups) != 3 {
|
|
return nil, fmt.Errorf("Did not match: %v (%v matches)", selector, len(groups))
|
|
}
|
|
name := groups[1]
|
|
args := groups[2]
|
|
arguments := make([]fakeArg, 0)
|
|
if len(args) > 0 {
|
|
for _, arg := range strings.Split(args, ",") {
|
|
arguments = append(arguments, fakeArg{arg})
|
|
}
|
|
}
|
|
abicheat := fakeABI{
|
|
name, "function", arguments,
|
|
}
|
|
return json.Marshal([]fakeABI{abicheat})
|
|
|
|
}
|
|
|
|
type AbiDb struct {
|
|
db map[string]string
|
|
customdb map[string]string
|
|
customdbPath string
|
|
}
|
|
|
|
// NewEmptyAbiDB exists for test purposes
|
|
func NewEmptyAbiDB() (*AbiDb, error) {
|
|
return &AbiDb{make(map[string]string), make(map[string]string), ""}, nil
|
|
}
|
|
|
|
// NewAbiDBFromFile loads signature database from file, and
|
|
// errors if the file is not valid json. Does no other validation of contents
|
|
func NewAbiDBFromFile(path string) (*AbiDb, error) {
|
|
raw, err := ioutil.ReadFile(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
db, err := NewEmptyAbiDB()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
json.Unmarshal(raw, &db.db)
|
|
return db, nil
|
|
}
|
|
|
|
// NewAbiDBFromFiles loads both the standard signature database and a custom database. The latter will be used
|
|
// to write new values into if they are submitted via the API
|
|
func NewAbiDBFromFiles(standard, custom string) (*AbiDb, error) {
|
|
|
|
db := &AbiDb{make(map[string]string), make(map[string]string), custom}
|
|
db.customdbPath = custom
|
|
|
|
raw, err := ioutil.ReadFile(standard)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
json.Unmarshal(raw, &db.db)
|
|
// Custom file may not exist. Will be created during save, if needed
|
|
if _, err := os.Stat(custom); err == nil {
|
|
raw, err = ioutil.ReadFile(custom)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
json.Unmarshal(raw, &db.customdb)
|
|
}
|
|
|
|
return db, nil
|
|
}
|
|
|
|
// LookupMethodSelector checks the given 4byte-sequence against the known ABI methods.
|
|
// OBS: This method does not validate the match, it's assumed the caller will do so
|
|
func (db *AbiDb) LookupMethodSelector(id []byte) (string, error) {
|
|
if len(id) < 4 {
|
|
return "", fmt.Errorf("Expected 4-byte id, got %d", len(id))
|
|
}
|
|
sig := common.ToHex(id[:4])
|
|
if key, exists := db.db[sig]; exists {
|
|
return key, nil
|
|
}
|
|
if key, exists := db.customdb[sig]; exists {
|
|
return key, nil
|
|
}
|
|
return "", fmt.Errorf("Signature %v not found", sig)
|
|
}
|
|
func (db *AbiDb) Size() int {
|
|
return len(db.db)
|
|
}
|
|
|
|
// saveCustomAbi saves a signature ephemerally. If custom file is used, also saves to disk
|
|
func (db *AbiDb) saveCustomAbi(selector, signature string) error {
|
|
db.customdb[signature] = selector
|
|
if db.customdbPath == "" {
|
|
return nil //Not an error per se, just not used
|
|
}
|
|
d, err := json.Marshal(db.customdb)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = ioutil.WriteFile(db.customdbPath, d, 0600)
|
|
return err
|
|
}
|
|
|
|
// AddSignature to the database, if custom database saving is enabled.
|
|
// OBS: This method does _not_ validate the correctness of the data,
|
|
// it is assumed that the caller has already done so
|
|
func (db *AbiDb) AddSignature(selector string, data []byte) error {
|
|
if len(data) < 4 {
|
|
return nil
|
|
}
|
|
_, err := db.LookupMethodSelector(data[:4])
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
sig := common.ToHex(data[:4])
|
|
return db.saveCustomAbi(selector, sig)
|
|
}
|