// 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) }