wasm: fix arbitrary memory allocation attack

laizy · sbinet · commit 46451e66c5a6 · 2019-08-01T14:21:04.000+02:00
diff --git a/wasm/read.go b/wasm/read.go
@@ -5,20 +5,34 @@
 package wasm
 
 import (
+	"bytes"
 	"encoding/binary"
 	"io"
 
 	"github.com/go-interpreter/wagon/wasm/leb128"
 )
 
-func readBytes(r io.Reader, n int) ([]byte, error) {
-	bytes := make([]byte, n)
-	_, err := io.ReadFull(r, bytes)
-	if err != nil {
-		return bytes, err
+// to avoid memory attack
+const maxInitialCap = 10 * 1024
+
+func getInitialCap(count uint32) uint32 {
+	if count > maxInitialCap {
+		return maxInitialCap
 	}
+	return count
+}
 
-	return bytes, nil
+func readBytes(r io.Reader, n int) ([]byte, error) {
+	if n == 0 {
+		return nil, nil
+	}
+	limited := io.LimitReader(r, int64(n))
+	buf := &bytes.Buffer{}
+	num, _ := buf.ReadFrom(limited)
+	if num == int64(n) {
+		return buf.Bytes(), nil
+	}
+	return nil, io.ErrUnexpectedEOF
 }
 
 func readBytesUint(r io.Reader) ([]byte, error) {
diff --git a/wasm/section.go b/wasm/section.go
@@ -159,7 +159,8 @@ func (sr *sectionsReader) readSection(r *readpos.ReadPos) (bool, error) {
 	s.Start = r.CurPos
 
 	sectionBytes := new(bytes.Buffer)
-	sectionBytes.Grow(int(payloadDataLen))
+
+	sectionBytes.Grow(int(getInitialCap(payloadDataLen)))
 	sectionReader := io.LimitReader(io.TeeReader(r, sectionBytes), int64(payloadDataLen))
 
 	var sec Section
@@ -295,11 +296,14 @@ func (s *SectionTypes) ReadPayload(r io.Reader) error {
 	if err != nil {
 		return err
 	}
-	s.Entries = make([]FunctionSig, int(count))
-	for i := range s.Entries {
-		if err = s.Entries[i].UnmarshalWASM(r); err != nil {
+
+	s.Entries = make([]FunctionSig, 0, getInitialCap(count))
+	for i := uint32(0); i < count; i++ {
+		var sig FunctionSig
+		if err := sig.UnmarshalWASM(r); err != nil {
 			return err
 		}
+		s.Entries = append(s.Entries, sig)
 	}
 	return nil
 }
@@ -334,12 +338,14 @@ func (s *SectionImports) ReadPayload(r io.Reader) error {
 	if err != nil {
 		return err
 	}
-	s.Entries = make([]ImportEntry, count)
-	for i := range s.Entries {
-		err = s.Entries[i].UnmarshalWASM(r)
-		if err != nil {
+
+	s.Entries = make([]ImportEntry, 0, getInitialCap(count))
+	for i := uint32(0); i < count; i++ {
+		var entry ImportEntry
+		if err := entry.UnmarshalWASM(r); err != nil {
 			return err
 		}
+		s.Entries = append(s.Entries, entry)
 	}
 	return nil
 }
@@ -440,13 +446,13 @@ func (s *SectionFunctions) ReadPayload(r io.Reader) error {
 	if err != nil {
 		return err
 	}
-	s.Types = make([]uint32, count)
-	for i := range s.Types {
+	s.Types = make([]uint32, 0, getInitialCap(count))
+	for i := uint32(0); i < count; i++ {
 		t, err := leb128.ReadVarUint32(r)
 		if err != nil {
 			return err
 		}
-		s.Types[i] = t
+		s.Types = append(s.Types, t)
 	}
 	return nil
 }
@@ -478,12 +484,14 @@ func (s *SectionTables) ReadPayload(r io.Reader) error {
 	if err != nil {
 		return err
 	}
-	s.Entries = make([]Table, count)
-	for i := range s.Entries {
-		err = s.Entries[i].UnmarshalWASM(r)
-		if err != nil {
+
+	s.Entries = make([]Table, 0, getInitialCap(count))
+	for i := uint32(0); i < count; i++ {
+		var entry Table
+		if err = entry.UnmarshalWASM(r); err != nil {
 			return err
 		}
+		s.Entries = append(s.Entries, entry)
 	}
 	return nil
 }
@@ -515,12 +523,13 @@ func (s *SectionMemories) ReadPayload(r io.Reader) error {
 	if err != nil {
 		return err
 	}
-	s.Entries = make([]Memory, count)
-	for i := range s.Entries {
-		err = s.Entries[i].UnmarshalWASM(r)
-		if err != nil {
+	s.Entries = make([]Memory, 0, getInitialCap(count))
+	for i := uint32(0); i < count; i++ {
+		var entry Memory
+		if err = entry.UnmarshalWASM(r); err != nil {
 			return err
 		}
+		s.Entries = append(s.Entries, entry)
 	}
 	return nil
 }
@@ -552,13 +561,15 @@ func (s *SectionGlobals) ReadPayload(r io.Reader) error {
 	if err != nil {
 		return err
 	}
-	s.Globals = make([]GlobalEntry, count)
+
+	s.Globals = make([]GlobalEntry, 0, getInitialCap(count))
 	logger.Printf("%d global entries\n", count)
-	for i := range s.Globals {
-		err = s.Globals[i].UnmarshalWASM(r)
-		if err != nil {
+	for i := uint32(0); i < count; i++ {
+		var global GlobalEntry
+		if err = global.UnmarshalWASM(r); err != nil {
 			return err
 		}
+		s.Globals = append(s.Globals, global)
 	}
 	return nil
 }
@@ -616,7 +627,8 @@ func (s *SectionExports) ReadPayload(r io.Reader) error {
 	if err != nil {
 		return err
 	}
-	s.Entries = make(map[string]ExportEntry, count)
+
+	s.Entries = make(map[string]ExportEntry, getInitialCap(count))
 	for i := uint32(0); i < count; i++ {
 		var entry ExportEntry
 		err = entry.UnmarshalWASM(r)
@@ -735,12 +747,14 @@ func (s *SectionElements) ReadPayload(r io.Reader) error {
 	if err != nil {
 		return err
 	}
-	s.Entries = make([]ElementSegment, count)
-	for i := range s.Entries {
-		err = s.Entries[i].UnmarshalWASM(r)
-		if err != nil {
+
+	s.Entries = make([]ElementSegment, 0, getInitialCap(count))
+	for i := uint32(0); i < count; i++ {
+		var element ElementSegment
+		if err = element.UnmarshalWASM(r); err != nil {
 			return err
 		}
+		s.Entries = append(s.Entries, element)
 	}
 	return nil
 }
@@ -778,14 +792,13 @@ func (s *ElementSegment) UnmarshalWASM(r io.Reader) error {
 	if err != nil {
 		return err
 	}
-	s.Elems = make([]uint32, numElems)
-
-	for i := range s.Elems {
+	s.Elems = make([]uint32, 0, getInitialCap(numElems))
+	for i := uint32(0); i < numElems; i++ {
 		e, err := leb128.ReadVarUint32(r)
 		if err != nil {
 			return err
 		}
-		s.Elems[i] = e
+		s.Elems = append(s.Elems, e)
 	}
 
 	return nil
@@ -825,14 +838,16 @@ func (s *SectionCode) ReadPayload(r io.Reader) error {
 	if err != nil {
 		return err
 	}
-	s.Bodies = make([]FunctionBody, count)
+	s.Bodies = make([]FunctionBody, 0, getInitialCap(count))
 	logger.Printf("%d function bodies\n", count)
 
-	for i := range s.Bodies {
+	for i := uint32(0); i < count; i++ {
 		logger.Printf("Reading function %d\n", i)
-		if err = s.Bodies[i].UnmarshalWASM(r); err != nil {
+		var body FunctionBody
+		if err = body.UnmarshalWASM(r); err != nil {
 			return err
 		}
+		s.Bodies = append(s.Bodies, body)
 	}
 	return nil
 }
@@ -864,9 +879,8 @@ func (f *FunctionBody) UnmarshalWASM(r io.Reader) error {
 		return err
 	}
 
-	body := make([]byte, bodySize)
-
-	if _, err = io.ReadFull(r, body); err != nil {
+	body, err := readBytes(r, int(bodySize))
+	if err != nil {
 		return err
 	}
 
@@ -876,12 +890,14 @@ func (f *FunctionBody) UnmarshalWASM(r io.Reader) error {
 	if err != nil {
 		return err
 	}
-	f.Locals = make([]LocalEntry, localCount)
+	f.Locals = make([]LocalEntry, 0, getInitialCap(localCount))
 
-	for i := range f.Locals {
-		if err = f.Locals[i].UnmarshalWASM(bytesReader); err != nil {
+	for i := uint32(0); i < localCount; i++ {
+		var local LocalEntry
+		if err = local.UnmarshalWASM(bytesReader); err != nil {
 			return err
 		}
+		f.Locals = append(f.Locals, local)
 	}
 
 	logger.Printf("bodySize: %d, localCount: %d\n", bodySize, localCount)
@@ -961,11 +977,13 @@ func (s *SectionData) ReadPayload(r io.Reader) error {
 	if err != nil {
 		return err
 	}
-	s.Entries = make([]DataSegment, count)
-	for i := range s.Entries {
-		if err = s.Entries[i].UnmarshalWASM(r); err != nil {
+	s.Entries = make([]DataSegment, 0, getInitialCap(count))
+	for i := uint32(0); i < count; i++ {
+		var entry DataSegment
+		if err = entry.UnmarshalWASM(r); err != nil {
 			return err
 		}
+		s.Entries = append(s.Entries, entry)
 	}
 	return nil
 }
diff --git a/wasm/types.go b/wasm/types.go
@@ -134,26 +134,28 @@ func (f *FunctionSig) UnmarshalWASM(r io.Reader) error {
 	if err != nil {
 		return err
 	}
-	f.ParamTypes = make([]ValueType, paramCount)
+	f.ParamTypes = make([]ValueType, 0, getInitialCap(paramCount))
 
-	for i := range f.ParamTypes {
-		err = f.ParamTypes[i].UnmarshalWASM(r)
-		if err != nil {
+	for i := uint32(0); i < paramCount; i++ {
+		var v ValueType
+		if err = v.UnmarshalWASM(r); err != nil {
 			return err
 		}
+		f.ParamTypes = append(f.ParamTypes, v)
 	}
 
 	returnCount, err := leb128.ReadVarUint32(r)
 	if err != nil {
 		return err
 	}
 
-	f.ReturnTypes = make([]ValueType, returnCount)
-	for i := range f.ReturnTypes {
-		err = f.ReturnTypes[i].UnmarshalWASM(r)
-		if err != nil {
+	f.ReturnTypes = make([]ValueType, 0, getInitialCap(returnCount))
+	for i := uint32(0); i < returnCount; i++ {
+		var v ValueType
+		if err = v.UnmarshalWASM(r); err != nil {
 			return err
 		}
+		f.ReturnTypes = append(f.ReturnTypes, v)
 	}
 
 	return nil

Original file line number	Diff line number	Diff line change
`@@ -159,7 +159,8 @@ func (sr sectionsReader) readSection(r readpos.ReadPos) (bool, error) {`
`159`	`159`	`s.Start = r.CurPos`
`160`	`160`
`161`	`161`	`sectionBytes := new(bytes.Buffer)`
`162`		`- sectionBytes.Grow(int(payloadDataLen))`
	`162`	`+`
	`163`	`+ sectionBytes.Grow(int(getInitialCap(payloadDataLen)))`
`163`	`164`	`sectionReader := io.LimitReader(io.TeeReader(r, sectionBytes), int64(payloadDataLen))`
`164`	`165`
`165`	`166`	`var sec Section`
`@@ -295,11 +296,14 @@ func (s *SectionTypes) ReadPayload(r io.Reader) error {`
`295`	`296`	`if err != nil {`
`296`	`297`	`return err`
`297`	`298`	`}`
`298`		`- s.Entries = make([]FunctionSig, int(count))`
`299`		`- for i := range s.Entries {`
`300`		`- if err = s.Entries[i].UnmarshalWASM(r); err != nil {`
	`299`	`+`
	`300`	`+ s.Entries = make([]FunctionSig, 0, getInitialCap(count))`
	`301`	`+ for i := uint32(0); i < count; i++ {`
	`302`	`+ var sig FunctionSig`
	`303`	`+ if err := sig.UnmarshalWASM(r); err != nil {`
`301`	`304`	`return err`
`302`	`305`	`}`
	`306`	`+ s.Entries = append(s.Entries, sig)`
`303`	`307`	`}`
`304`	`308`	`return nil`
`305`	`309`	`}`
`@@ -334,12 +338,14 @@ func (s *SectionImports) ReadPayload(r io.Reader) error {`
`334`	`338`	`if err != nil {`
`335`	`339`	`return err`
`336`	`340`	`}`
`337`		`- s.Entries = make([]ImportEntry, count)`
`338`		`- for i := range s.Entries {`
`339`		`- err = s.Entries[i].UnmarshalWASM(r)`
`340`		`- if err != nil {`
	`341`	`+`
	`342`	`+ s.Entries = make([]ImportEntry, 0, getInitialCap(count))`
	`343`	`+ for i := uint32(0); i < count; i++ {`
	`344`	`+ var entry ImportEntry`
	`345`	`+ if err := entry.UnmarshalWASM(r); err != nil {`
`341`	`346`	`return err`
`342`	`347`	`}`
	`348`	`+ s.Entries = append(s.Entries, entry)`
`343`	`349`	`}`
`344`	`350`	`return nil`
`345`	`351`	`}`
`@@ -440,13 +446,13 @@ func (s *SectionFunctions) ReadPayload(r io.Reader) error {`
`440`	`446`	`if err != nil {`
`441`	`447`	`return err`
`442`	`448`	`}`
`443`		`- s.Types = make([]uint32, count)`
`444`		`- for i := range s.Types {`
	`449`	`+ s.Types = make([]uint32, 0, getInitialCap(count))`
	`450`	`+ for i := uint32(0); i < count; i++ {`
`445`	`451`	`t, err := leb128.ReadVarUint32(r)`
`446`	`452`	`if err != nil {`
`447`	`453`	`return err`
`448`	`454`	`}`
`449`		`- s.Types[i] = t`
	`455`	`+ s.Types = append(s.Types, t)`
`450`	`456`	`}`
`451`	`457`	`return nil`
`452`	`458`	`}`
`@@ -478,12 +484,14 @@ func (s *SectionTables) ReadPayload(r io.Reader) error {`
`478`	`484`	`if err != nil {`
`479`	`485`	`return err`
`480`	`486`	`}`
`481`		`- s.Entries = make([]Table, count)`
`482`		`- for i := range s.Entries {`
`483`		`- err = s.Entries[i].UnmarshalWASM(r)`
`484`		`- if err != nil {`
	`487`	`+`
	`488`	`+ s.Entries = make([]Table, 0, getInitialCap(count))`
	`489`	`+ for i := uint32(0); i < count; i++ {`
	`490`	`+ var entry Table`
	`491`	`+ if err = entry.UnmarshalWASM(r); err != nil {`
`485`	`492`	`return err`
`486`	`493`	`}`
	`494`	`+ s.Entries = append(s.Entries, entry)`
`487`	`495`	`}`
`488`	`496`	`return nil`
`489`	`497`	`}`
`@@ -515,12 +523,13 @@ func (s *SectionMemories) ReadPayload(r io.Reader) error {`
`515`	`523`	`if err != nil {`
`516`	`524`	`return err`
`517`	`525`	`}`
`518`		`- s.Entries = make([]Memory, count)`
`519`		`- for i := range s.Entries {`
`520`		`- err = s.Entries[i].UnmarshalWASM(r)`
`521`		`- if err != nil {`
	`526`	`+ s.Entries = make([]Memory, 0, getInitialCap(count))`
	`527`	`+ for i := uint32(0); i < count; i++ {`
	`528`	`+ var entry Memory`
	`529`	`+ if err = entry.UnmarshalWASM(r); err != nil {`
`522`	`530`	`return err`
`523`	`531`	`}`
	`532`	`+ s.Entries = append(s.Entries, entry)`
`524`	`533`	`}`
`525`	`534`	`return nil`
`526`	`535`	`}`
`@@ -552,13 +561,15 @@ func (s *SectionGlobals) ReadPayload(r io.Reader) error {`
`552`	`561`	`if err != nil {`
`553`	`562`	`return err`
`554`	`563`	`}`
`555`		`- s.Globals = make([]GlobalEntry, count)`
	`564`	`+`
	`565`	`+ s.Globals = make([]GlobalEntry, 0, getInitialCap(count))`
`556`	`566`	`logger.Printf("%d global entries\n", count)`
`557`		`- for i := range s.Globals {`
`558`		`- err = s.Globals[i].UnmarshalWASM(r)`
`559`		`- if err != nil {`
	`567`	`+ for i := uint32(0); i < count; i++ {`
	`568`	`+ var global GlobalEntry`
	`569`	`+ if err = global.UnmarshalWASM(r); err != nil {`
`560`	`570`	`return err`
`561`	`571`	`}`
	`572`	`+ s.Globals = append(s.Globals, global)`
`562`	`573`	`}`
`563`	`574`	`return nil`
`564`	`575`	`}`
`@@ -616,7 +627,8 @@ func (s *SectionExports) ReadPayload(r io.Reader) error {`
`616`	`627`	`if err != nil {`
`617`	`628`	`return err`
`618`	`629`	`}`
`619`		`- s.Entries = make(map[string]ExportEntry, count)`
	`630`	`+`
	`631`	`+ s.Entries = make(map[string]ExportEntry, getInitialCap(count))`
`620`	`632`	`for i := uint32(0); i < count; i++ {`
`621`	`633`	`var entry ExportEntry`
`622`	`634`	`err = entry.UnmarshalWASM(r)`
`@@ -735,12 +747,14 @@ func (s *SectionElements) ReadPayload(r io.Reader) error {`
`735`	`747`	`if err != nil {`
`736`	`748`	`return err`
`737`	`749`	`}`
`738`		`- s.Entries = make([]ElementSegment, count)`
`739`		`- for i := range s.Entries {`
`740`		`- err = s.Entries[i].UnmarshalWASM(r)`
`741`		`- if err != nil {`
	`750`	`+`
	`751`	`+ s.Entries = make([]ElementSegment, 0, getInitialCap(count))`
	`752`	`+ for i := uint32(0); i < count; i++ {`
	`753`	`+ var element ElementSegment`
	`754`	`+ if err = element.UnmarshalWASM(r); err != nil {`
`742`	`755`	`return err`
`743`	`756`	`}`
	`757`	`+ s.Entries = append(s.Entries, element)`
`744`	`758`	`}`
`745`	`759`	`return nil`
`746`	`760`	`}`
`@@ -778,14 +792,13 @@ func (s *ElementSegment) UnmarshalWASM(r io.Reader) error {`
`778`	`792`	`if err != nil {`
`779`	`793`	`return err`
`780`	`794`	`}`
`781`		`- s.Elems = make([]uint32, numElems)`
`782`		`-`
`783`		`- for i := range s.Elems {`
	`795`	`+ s.Elems = make([]uint32, 0, getInitialCap(numElems))`
	`796`	`+ for i := uint32(0); i < numElems; i++ {`
`784`	`797`	`e, err := leb128.ReadVarUint32(r)`
`785`	`798`	`if err != nil {`
`786`	`799`	`return err`
`787`	`800`	`}`
`788`		`- s.Elems[i] = e`
	`801`	`+ s.Elems = append(s.Elems, e)`
`789`	`802`	`}`
`790`	`803`
`791`	`804`	`return nil`
`@@ -825,14 +838,16 @@ func (s *SectionCode) ReadPayload(r io.Reader) error {`
`825`	`838`	`if err != nil {`
`826`	`839`	`return err`
`827`	`840`	`}`
`828`		`- s.Bodies = make([]FunctionBody, count)`
	`841`	`+ s.Bodies = make([]FunctionBody, 0, getInitialCap(count))`
`829`	`842`	`logger.Printf("%d function bodies\n", count)`
`830`	`843`
`831`		`- for i := range s.Bodies {`
	`844`	`+ for i := uint32(0); i < count; i++ {`
`832`	`845`	`logger.Printf("Reading function %d\n", i)`
`833`		`- if err = s.Bodies[i].UnmarshalWASM(r); err != nil {`
	`846`	`+ var body FunctionBody`
	`847`	`+ if err = body.UnmarshalWASM(r); err != nil {`
`834`	`848`	`return err`
`835`	`849`	`}`
	`850`	`+ s.Bodies = append(s.Bodies, body)`
`836`	`851`	`}`
`837`	`852`	`return nil`
`838`	`853`	`}`
`@@ -864,9 +879,8 @@ func (f *FunctionBody) UnmarshalWASM(r io.Reader) error {`
`864`	`879`	`return err`
`865`	`880`	`}`
`866`	`881`
`867`		`- body := make([]byte, bodySize)`
`868`		`-`
`869`		`- if _, err = io.ReadFull(r, body); err != nil {`
	`882`	`+ body, err := readBytes(r, int(bodySize))`
	`883`	`+ if err != nil {`
`870`	`884`	`return err`
`871`	`885`	`}`
`872`	`886`
`@@ -876,12 +890,14 @@ func (f *FunctionBody) UnmarshalWASM(r io.Reader) error {`
`876`	`890`	`if err != nil {`
`877`	`891`	`return err`
`878`	`892`	`}`
`879`		`- f.Locals = make([]LocalEntry, localCount)`
	`893`	`+ f.Locals = make([]LocalEntry, 0, getInitialCap(localCount))`
`880`	`894`
`881`		`- for i := range f.Locals {`
`882`		`- if err = f.Locals[i].UnmarshalWASM(bytesReader); err != nil {`
	`895`	`+ for i := uint32(0); i < localCount; i++ {`
	`896`	`+ var local LocalEntry`
	`897`	`+ if err = local.UnmarshalWASM(bytesReader); err != nil {`
`883`	`898`	`return err`
`884`	`899`	`}`
	`900`	`+ f.Locals = append(f.Locals, local)`
`885`	`901`	`}`
`886`	`902`
`887`	`903`	`logger.Printf("bodySize: %d, localCount: %d\n", bodySize, localCount)`
`@@ -961,11 +977,13 @@ func (s *SectionData) ReadPayload(r io.Reader) error {`
`961`	`977`	`if err != nil {`
`962`	`978`	`return err`
`963`	`979`	`}`
`964`		`- s.Entries = make([]DataSegment, count)`
`965`		`- for i := range s.Entries {`
`966`		`- if err = s.Entries[i].UnmarshalWASM(r); err != nil {`
	`980`	`+ s.Entries = make([]DataSegment, 0, getInitialCap(count))`
	`981`	`+ for i := uint32(0); i < count; i++ {`
	`982`	`+ var entry DataSegment`
	`983`	`+ if err = entry.UnmarshalWASM(r); err != nil {`
`967`	`984`	`return err`
`968`	`985`	`}`
	`986`	`+ s.Entries = append(s.Entries, entry)`
`969`	`987`	`}`
`970`	`988`	`return nil`
`971`	`989`	`}`
Original file line number	Diff line number	Diff line change
`@@ -134,26 +134,28 @@ func (f *FunctionSig) UnmarshalWASM(r io.Reader) error {`
`134`	`134`	`if err != nil {`
`135`	`135`	`return err`
`136`	`136`	`}`
`137`		`- f.ParamTypes = make([]ValueType, paramCount)`
	`137`	`+ f.ParamTypes = make([]ValueType, 0, getInitialCap(paramCount))`
`138`	`138`
`139`		`- for i := range f.ParamTypes {`
`140`		`- err = f.ParamTypes[i].UnmarshalWASM(r)`
`141`		`- if err != nil {`
	`139`	`+ for i := uint32(0); i < paramCount; i++ {`
	`140`	`+ var v ValueType`
	`141`	`+ if err = v.UnmarshalWASM(r); err != nil {`
`142`	`142`	`return err`
`143`	`143`	`}`
	`144`	`+ f.ParamTypes = append(f.ParamTypes, v)`
`144`	`145`	`}`
`145`	`146`
`146`	`147`	`returnCount, err := leb128.ReadVarUint32(r)`
`147`	`148`	`if err != nil {`
`148`	`149`	`return err`
`149`	`150`	`}`
`150`	`151`
`151`		`- f.ReturnTypes = make([]ValueType, returnCount)`
`152`		`- for i := range f.ReturnTypes {`
`153`		`- err = f.ReturnTypes[i].UnmarshalWASM(r)`
`154`		`- if err != nil {`
	`152`	`+ f.ReturnTypes = make([]ValueType, 0, getInitialCap(returnCount))`
	`153`	`+ for i := uint32(0); i < returnCount; i++ {`
	`154`	`+ var v ValueType`
	`155`	`+ if err = v.UnmarshalWASM(r); err != nil {`
`155`	`156`	`return err`
`156`	`157`	`}`
	`158`	`+ f.ReturnTypes = append(f.ReturnTypes, v)`
`157`	`159`	`}`
`158`	`160`
`159`	`161`	`return nil`