mirror of
https://github.com/ethereum/go-ethereum.git
synced 2026-08-20 02:42:27 +00:00
signer: more hard types
This commit is contained in:
Martin Holst Swende
Paul Berg
parent
33a1ac635c
commit
6b30617820
2 changed files with 198 additions and 133 deletions
|
|
@ -21,6 +21,7 @@ import (
|
|||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"github.com/ethereum/go-ethereum/common/math"
|
||||
"math/big"
|
||||
"mime"
|
||||
"reflect"
|
||||
|
|
@ -76,9 +77,30 @@ type TypedData struct {
|
|||
Message TypedDataMessage `json:"message"`
|
||||
}
|
||||
|
||||
type Type []map[string]string
|
||||
type Type struct {
|
||||
Name string `json:"name"`
|
||||
Type string `json:"type"`
|
||||
}
|
||||
|
||||
type Types map[string]Type
|
||||
func (t *Type) isArray() bool {
|
||||
return strings.HasSuffix(t.Type, "[]")
|
||||
}
|
||||
|
||||
// typeName returns the canonical name of the type. If the type is 'Person[]', then
|
||||
// this method returns 'Person'
|
||||
func (t *Type) typeName() string {
|
||||
if strings.HasSuffix(t.Type, "[]") {
|
||||
return strings.TrimSuffix(t.Type, "[]")
|
||||
}
|
||||
return t.Type
|
||||
}
|
||||
|
||||
func (t *Type) isReferenceType() bool {
|
||||
// Reference types must have a leading uppercase characer
|
||||
return unicode.IsUpper([]rune(t.Type)[0])
|
||||
}
|
||||
|
||||
type Types map[string][]Type
|
||||
|
||||
type TypePriority struct {
|
||||
Type string
|
||||
|
|
@ -331,7 +353,7 @@ func (typedData *TypedData) Dependencies(primaryType string, found []string) []s
|
|||
}
|
||||
found = append(found, primaryType)
|
||||
for _, field := range typedData.Types[primaryType] {
|
||||
for _, dep := range typedData.Dependencies(field["type"], found) {
|
||||
for _, dep := range typedData.Dependencies(field.Type, found) {
|
||||
if !includes(found, dep) {
|
||||
found = append(found, dep)
|
||||
}
|
||||
|
|
@ -357,9 +379,9 @@ func (typedData *TypedData) EncodeType(primaryType string) hexutil.Bytes {
|
|||
buffer.WriteString(dep)
|
||||
buffer.WriteString("(")
|
||||
for _, obj := range typedData.Types[dep] {
|
||||
buffer.WriteString(obj["type"])
|
||||
buffer.WriteString(obj.Type)
|
||||
buffer.WriteString(" ")
|
||||
buffer.WriteString(obj["name"])
|
||||
buffer.WriteString(obj.Name)
|
||||
buffer.WriteString(",")
|
||||
}
|
||||
buffer.Truncate(buffer.Len() - 1)
|
||||
|
|
@ -389,8 +411,8 @@ func (typedData *TypedData) EncodeData(primaryType string, data map[string]inter
|
|||
|
||||
// Add field contents. Structs and arrays have special handlers.
|
||||
for _, field := range typedData.Types[primaryType] {
|
||||
encType := field["type"]
|
||||
encValue := data[field["name"]]
|
||||
encType := field.Type
|
||||
encValue := data[field.Name]
|
||||
if encType[len(encType)-1:] == "]" {
|
||||
arrayValue, ok := encValue.([]interface{})
|
||||
if !ok {
|
||||
|
|
@ -411,11 +433,7 @@ func (typedData *TypedData) EncodeData(primaryType string, data map[string]inter
|
|||
}
|
||||
arrayBuffer.Write(encodedData)
|
||||
} else {
|
||||
encValue, err := typedData.EncodePrimitiveValue(encType, encValue, depth)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
bytesValue, err := bytesValueOf(encValue)
|
||||
bytesValue, err := typedData.EncodePrimitiveValue(encType, encValue, depth)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
|
@ -424,28 +442,22 @@ func (typedData *TypedData) EncodeData(primaryType string, data map[string]inter
|
|||
}
|
||||
|
||||
buffer.Write(crypto.Keccak256(arrayBuffer.Bytes()))
|
||||
} else if typedData.Types[field["type"]] != nil {
|
||||
} else if typedData.Types[field.Type] != nil {
|
||||
mapValue, ok := encValue.(map[string]interface{})
|
||||
if !ok {
|
||||
return nil, dataMismatchError(encType, encValue)
|
||||
}
|
||||
|
||||
encodedData, err := typedData.EncodeData(field["type"], mapValue, depth+1)
|
||||
encodedData, err := typedData.EncodeData(field.Type, mapValue, depth+1)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
buffer.Write(crypto.Keccak256(encodedData))
|
||||
} else {
|
||||
primitiveEncValue, err := typedData.EncodePrimitiveValue(encType, encValue, depth)
|
||||
byteValue, err := typedData.EncodePrimitiveValue(encType, encValue, depth)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
bytesValue, err := bytesValueOf(primitiveEncValue)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
buffer.Write(bytesValue)
|
||||
buffer.Write(byteValue)
|
||||
}
|
||||
}
|
||||
return buffer.Bytes(), nil
|
||||
|
|
@ -453,64 +465,64 @@ func (typedData *TypedData) EncodeData(primaryType string, data map[string]inter
|
|||
|
||||
// EncodePrimitiveValue deals with the primitive values found
|
||||
// while searching through the typed data
|
||||
func (typedData *TypedData) EncodePrimitiveValue(encType string, encValue interface{}, depth int) (interface{}, error) {
|
||||
var primitiveEncValue interface{}
|
||||
func (typedData *TypedData) EncodePrimitiveValue(encType string, encValue interface{}, depth int) ([]byte, error) {
|
||||
|
||||
switch encType {
|
||||
case "address":
|
||||
bytesValue := hexutil.Bytes{}
|
||||
for i := 0; i < 12; i++ {
|
||||
bytesValue = append(bytesValue, 0)
|
||||
}
|
||||
stringValue, ok := encValue.(string)
|
||||
if !ok || !common.IsHexAddress(stringValue) {
|
||||
return nil, dataMismatchError(encType, encValue)
|
||||
}
|
||||
addressValue := common.HexToAddress(stringValue)
|
||||
for _, _byte := range addressValue {
|
||||
bytesValue = append(bytesValue, _byte)
|
||||
}
|
||||
primitiveEncValue = bytesValue
|
||||
retval := make([]byte, 32)
|
||||
copy(retval[12:], common.HexToAddress(stringValue).Bytes())
|
||||
return retval, nil
|
||||
case "bool":
|
||||
var int64Val int64
|
||||
boolValue, ok := encValue.(bool)
|
||||
if !ok {
|
||||
return nil, dataMismatchError(encType, encValue)
|
||||
}
|
||||
if boolValue {
|
||||
int64Val = 1
|
||||
return math.PaddedBigBytes(common.Big1, 32), nil
|
||||
}
|
||||
primitiveEncValue = abi.U256(big.NewInt(int64Val))
|
||||
case "bytes", "string":
|
||||
bytesValue, err := bytesValueOf(encValue)
|
||||
if err != nil {
|
||||
return math.PaddedBigBytes(common.Big0, 32), nil
|
||||
case "string":
|
||||
strVal, ok := encValue.(string)
|
||||
if !ok {
|
||||
return nil, dataMismatchError(encType, encValue)
|
||||
}
|
||||
primitiveEncValue = crypto.Keccak256(bytesValue)
|
||||
default:
|
||||
if strings.HasPrefix(encType, "bytes") {
|
||||
sizeStr := strings.TrimPrefix(encType, "bytes")
|
||||
size, _ := strconv.Atoi(sizeStr)
|
||||
bytesValue := hexutil.Bytes{}
|
||||
for i := 0; i < 32-size; i++ {
|
||||
bytesValue = append(bytesValue, 0)
|
||||
}
|
||||
if _, ok := encValue.(hexutil.Bytes); !ok {
|
||||
return nil, dataMismatchError(encType, encValue)
|
||||
}
|
||||
bytesValue = append(bytesValue, encValue.(hexutil.Bytes)...)
|
||||
primitiveEncValue = bytesValue
|
||||
} else if strings.HasPrefix(encType, "uint") || strings.HasPrefix(encType, "int") {
|
||||
bigIntValue, ok := encValue.(*big.Int)
|
||||
if !ok {
|
||||
return nil, dataMismatchError(encType, encValue)
|
||||
}
|
||||
primitiveEncValue = abi.U256(bigIntValue)
|
||||
return crypto.Keccak256([]byte(strVal)), nil
|
||||
case "bytes":
|
||||
bytesValue, ok := encValue.([]byte)
|
||||
if !ok {
|
||||
return nil, dataMismatchError(encType, encValue)
|
||||
}
|
||||
return crypto.Keccak256(bytesValue), nil
|
||||
}
|
||||
// bytes32 etc
|
||||
if strings.HasPrefix(encType, "bytes") {
|
||||
sizeStr := strings.TrimPrefix(encType, "bytes")
|
||||
size, err := strconv.Atoi(sizeStr)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("invalid size on bytes: %v", sizeStr)
|
||||
}
|
||||
if size < 0 || size > 32 {
|
||||
return nil, fmt.Errorf("invalid size on bytes: %d", size)
|
||||
}
|
||||
if byteval, ok := encValue.(hexutil.Bytes); !ok {
|
||||
return nil, dataMismatchError(encType, encValue)
|
||||
} else {
|
||||
return nil, fmt.Errorf("unrecognized type '%s'", encType)
|
||||
return math.PaddedBigBytes(new(big.Int).SetBytes(byteval), 32), nil
|
||||
}
|
||||
}
|
||||
return primitiveEncValue, nil
|
||||
if strings.HasPrefix(encType, "uint") || strings.HasPrefix(encType, "int") {
|
||||
bigIntValue, ok := encValue.(*big.Int)
|
||||
if !ok {
|
||||
return nil, dataMismatchError(encType, encValue)
|
||||
}
|
||||
return abi.U256(bigIntValue), nil
|
||||
}
|
||||
return nil, fmt.Errorf("unrecognized type '%s'", encType)
|
||||
|
||||
}
|
||||
|
||||
// dataMismatchError generates an error for a mismatch between
|
||||
|
|
@ -519,29 +531,6 @@ func dataMismatchError(encType string, encValue interface{}) error {
|
|||
return fmt.Errorf("provided data '%v' doesn't match type '%s'", encValue, encType)
|
||||
}
|
||||
|
||||
// bytesValuesOf returns the bytes value of the given interface
|
||||
func bytesValueOf(_interface interface{}) (hexutil.Bytes, error) {
|
||||
bytesValue, ok := _interface.(hexutil.Bytes)
|
||||
if ok {
|
||||
return bytesValue, nil
|
||||
}
|
||||
|
||||
switch reflect.TypeOf(_interface) {
|
||||
case reflect.TypeOf(hexutil.Bytes{}):
|
||||
return _interface.(hexutil.Bytes), nil
|
||||
case reflect.TypeOf([]byte{}):
|
||||
return hexutil.Bytes(_interface.([]byte)), nil
|
||||
case reflect.TypeOf([]uint8{}):
|
||||
return _interface.([]uint8), nil
|
||||
case reflect.TypeOf(string("")):
|
||||
return hexutil.Bytes(_interface.(string)), nil
|
||||
default:
|
||||
break
|
||||
}
|
||||
|
||||
return nil, fmt.Errorf("unrecognized type '%T'", _interface)
|
||||
}
|
||||
|
||||
// EcRecover recovers the address associated with the given sig.
|
||||
// Only compatible with `text/plain`
|
||||
func (api *SignerAPI) EcRecover(ctx context.Context, data hexutil.Bytes, sig hexutil.Bytes) (common.Address, error) {
|
||||
|
|
@ -660,32 +649,31 @@ func (typedData *TypedData) formatData(primaryType string, data map[string]inter
|
|||
|
||||
// Add field contents. Structs and arrays have special handlers.
|
||||
for _, field := range typedData.Types[primaryType] {
|
||||
encType := field["type"]
|
||||
encName := field["name"]
|
||||
encName := field.Name
|
||||
encValue := data[encName]
|
||||
item := &NameValueType{
|
||||
Name: encName,
|
||||
Typ: encType,
|
||||
Typ: field.Type,
|
||||
}
|
||||
if encType[len(encType)-1:] == "]" {
|
||||
if field.isArray() {
|
||||
arrayValue, _ := encValue.([]interface{})
|
||||
parsedType := strings.Split(encType, "[")[0]
|
||||
parsedType := field.typeName()
|
||||
for _, v := range arrayValue {
|
||||
if typedData.Types[parsedType] != nil {
|
||||
mapValue, _ := v.(map[string]interface{})
|
||||
mapOutput := typedData.formatData(parsedType, mapValue)
|
||||
item.Value = mapOutput
|
||||
} else {
|
||||
primitiveOutput := formatPrimitiveValue(encType, encValue)
|
||||
primitiveOutput := formatPrimitiveValue(field.Type, encValue)
|
||||
item.Value = primitiveOutput
|
||||
}
|
||||
}
|
||||
} else if typedData.Types[field["type"]] != nil {
|
||||
} else if typedData.Types[field.Type] != nil {
|
||||
mapValue, _ := encValue.(map[string]interface{})
|
||||
mapOutput := typedData.formatData(field["type"], mapValue)
|
||||
mapOutput := typedData.formatData(field.Type, mapValue)
|
||||
item.Value = mapOutput
|
||||
} else {
|
||||
primitiveOutput := formatPrimitiveValue(encType, encValue)
|
||||
primitiveOutput := formatPrimitiveValue(field.Type, encValue)
|
||||
item.Value = primitiveOutput
|
||||
}
|
||||
output = append(output, item)
|
||||
|
|
@ -739,30 +727,22 @@ func (nvt *NameValueType) Pprint(depth int) string {
|
|||
}
|
||||
|
||||
// Validate checks if the types object is conformant to the specs
|
||||
func (types *Types) Validate() error {
|
||||
for typeKey, typeArr := range *types {
|
||||
func (t Types) Validate() error {
|
||||
for typeKey, typeArr := range t {
|
||||
for _, typeObj := range typeArr {
|
||||
typeVal := typeObj["type"]
|
||||
if typeKey == typeVal {
|
||||
return fmt.Errorf("type '%s' cannot reference itself", typeVal)
|
||||
if typeKey == typeObj.Type {
|
||||
return fmt.Errorf("type '%s' cannot reference itself", typeObj.Type)
|
||||
}
|
||||
firstChar := []rune(typeVal)[0]
|
||||
if unicode.IsUpper(firstChar) {
|
||||
if (*types)[typeVal] != nil {
|
||||
if !typedDataReferenceTypeRegexp.MatchString(typeVal) {
|
||||
return fmt.Errorf("unknown reference type '%s", typeVal)
|
||||
}
|
||||
} else {
|
||||
return fmt.Errorf("reference type '%s' is undefined", typeVal)
|
||||
if typeObj.isReferenceType() {
|
||||
if _, exist := t[typeObj.Type]; !exist {
|
||||
return fmt.Errorf("reference type '%s' is undefined", typeObj.Type)
|
||||
}
|
||||
} else {
|
||||
if !typedDataRegexp.MatchString(typeVal) {
|
||||
if (*types)[typeVal] != nil {
|
||||
return fmt.Errorf("reference type '%s' must be capitalized", typeVal)
|
||||
} else {
|
||||
return fmt.Errorf("unknown type '%s'", typeVal)
|
||||
}
|
||||
if !typedDataReferenceTypeRegexp.MatchString(typeObj.Type) {
|
||||
return fmt.Errorf("unknown reference type '%s", typeObj.Type)
|
||||
}
|
||||
|
||||
} else if !typedDataRegexp.MatchString(typeObj.Type) {
|
||||
return fmt.Errorf("unknown type '%s'", typeObj.Type)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -31,44 +31,44 @@ import (
|
|||
var typesStandard = Types{
|
||||
"EIP712Domain": {
|
||||
{
|
||||
"name": "name",
|
||||
"type": "string",
|
||||
Name: "name",
|
||||
Type: "string",
|
||||
},
|
||||
{
|
||||
"name": "version",
|
||||
"type": "string",
|
||||
Name: "version",
|
||||
Type: "string",
|
||||
},
|
||||
{
|
||||
"name": "chainId",
|
||||
"type": "uint256",
|
||||
Name: "chainId",
|
||||
Type: "uint256",
|
||||
},
|
||||
{
|
||||
"name": "verifyingContract",
|
||||
"type": "address",
|
||||
Name: "verifyingContract",
|
||||
Type: "address",
|
||||
},
|
||||
},
|
||||
"Person": {
|
||||
{
|
||||
"name": "name",
|
||||
"type": "string",
|
||||
Name: "name",
|
||||
Type: "string",
|
||||
},
|
||||
{
|
||||
"name": "wallet",
|
||||
"type": "address",
|
||||
Name: "wallet",
|
||||
Type: "address",
|
||||
},
|
||||
},
|
||||
"Mail": {
|
||||
{
|
||||
"name": "from",
|
||||
"type": "Person",
|
||||
Name: "from",
|
||||
Type: "Person",
|
||||
},
|
||||
{
|
||||
"name": "to",
|
||||
"type": "Person",
|
||||
Name: "to",
|
||||
Type: "Person",
|
||||
},
|
||||
{
|
||||
"name": "contents",
|
||||
"type": "string",
|
||||
Name: "contents",
|
||||
Type: "string",
|
||||
},
|
||||
},
|
||||
}
|
||||
|
|
@ -461,7 +461,7 @@ func TestMalformedData2(t *testing.T) {
|
|||
t.Errorf("Expected `provided data 'Hello, Bob!' doesn't match type 'Person'`, got %v", err)
|
||||
}
|
||||
|
||||
malformedTypedData.Types["Mail"][2]["type"] = "Blahonga"
|
||||
malformedTypedData.Types["Mail"][2].Type = "Blahonga"
|
||||
err = malformedTypedData.Validate()
|
||||
if err == nil || err.Error() != "reference type 'Blahonga' is undefined" {
|
||||
t.Fatalf("Expected `reference type 'Blahonga' is undefined`, got %v", err)
|
||||
|
|
@ -559,7 +559,7 @@ func TestMalformedData3(t *testing.T) {
|
|||
t.Fatalf("Expected `unknown type 'uint256 ... and now for something completely different'`, got %v", err)
|
||||
}
|
||||
|
||||
malformedTypedData.Types["EIP712Domain"][2]["type"] = "uint256"
|
||||
malformedTypedData.Types["EIP712Domain"][2].Type = "uint256"
|
||||
malformedTypedData.Message["blahonga"] = "zonk bonk"
|
||||
_, err = malformedTypedData.HashStruct(malformedTypedData.PrimaryType, malformedTypedData.Message)
|
||||
if err == nil || err.Error() != "there is extra data provided in the message" {
|
||||
|
|
@ -628,3 +628,88 @@ func TestFormatter(t *testing.T) {
|
|||
fmt.Printf("%v\n", string(j))
|
||||
|
||||
}
|
||||
|
||||
func TestMalformedData5(t *testing.T) {
|
||||
var jsonTypedData = `
|
||||
{
|
||||
"types": {
|
||||
"EIP712Domain": [
|
||||
{
|
||||
"name": "name",
|
||||
"type": "string"
|
||||
},
|
||||
{
|
||||
"name": "version",
|
||||
"type": "string"
|
||||
},
|
||||
{
|
||||
"name": "chainId",
|
||||
"type": "uint256"
|
||||
},
|
||||
{
|
||||
"name": "verifyingContract",
|
||||
"type": "address"
|
||||
}
|
||||
],
|
||||
"Person": [
|
||||
{
|
||||
"name": "name",
|
||||
"type": "string"
|
||||
},
|
||||
{
|
||||
"name": "wallet",
|
||||
"type": "address"
|
||||
}
|
||||
],
|
||||
"Person[]": [
|
||||
{
|
||||
"name": "baz",
|
||||
"type": "string"
|
||||
}],
|
||||
"Mail": [
|
||||
{
|
||||
"name": "from",
|
||||
"type": "Person"
|
||||
},
|
||||
{
|
||||
"name": "to",
|
||||
"type": "Person[]"
|
||||
},
|
||||
{
|
||||
"name": "contents",
|
||||
"type": "string"
|
||||
}
|
||||
]
|
||||
},
|
||||
"primaryType": "Mail",
|
||||
"domain": {
|
||||
"name": "Ether Mail",
|
||||
"version": "1",
|
||||
"chainId": 1,
|
||||
"verifyingContract": "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"
|
||||
},
|
||||
"message": {
|
||||
"from": {
|
||||
"name": "Cow",
|
||||
"wallet": "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826"
|
||||
},
|
||||
"to": {"baz": "foo"},
|
||||
"contents": "Hello, Bob!"
|
||||
}
|
||||
}
|
||||
|
||||
`
|
||||
var malformedTypedData TypedData
|
||||
err := json.Unmarshal([]byte(jsonTypedData), &malformedTypedData)
|
||||
if err != nil {
|
||||
t.Fatalf("unmarshalling failed %v", err)
|
||||
}
|
||||
err = malformedTypedData.Validate()
|
||||
if err != nil {
|
||||
t.Fatalf("Expected no error, got %v", err)
|
||||
}
|
||||
_, err = malformedTypedData.HashStruct("EIP712Domain", malformedTypedData.Domain.Map())
|
||||
if err == nil {
|
||||
t.Errorf("Expected an error, got %v", err)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue