disasm,wasm: fix types decoding

Author: laizy

disasm/asm.go

@@ -21,7 +21,7 @@ func Assemble(instr []Instr) ([]byte, error) {
 		body.WriteByte(ins.Op.Code)
 		switch op := ins.Op.Code; op {
 		case ops.Block, ops.Loop, ops.If:
-			leb128.WriteVarint64(body, int64(ins.Immediates[0].(wasm.BlockType)))
+			body.WriteByte(byte(ins.Immediates[0].(wasm.BlockType)))
 		case ops.Br, ops.BrIf:
 			leb128.WriteVarUint32(body, ins.Immediates[0].(uint32))
 		case ops.BrTable:

disasm/disasm.go

@@ -222,7 +222,7 @@ func NewDisassembly(fn wasm.Function, module *wasm.Module) (*Disassembly, error)
 			}
 
 		case ops.Block, ops.Loop, ops.If:
-			sig := uint32(instr.Immediates[0].(wasm.BlockType))
+			sig := instr.Immediates[0].(wasm.BlockType)
 			logger.Printf("if, depth is %d", stackDepths.Top())
 			stackDepths.Push(stackDepths.Top())
 			// If this new block is unreachable, its
@@ -237,7 +237,7 @@ func NewDisassembly(fn wasm.Function, module *wasm.Module) (*Disassembly, error)
 			}
 			instr.Block = &BlockInfo{
 				Start:     true,
-				Signature: wasm.BlockType(sig),
+				Signature: sig,
 			}
 
 			blockIndices.Push(uint64(curIndex))
@@ -391,7 +391,7 @@ func Disassemble(code []byte) ([]Instr, error) {
 
 		switch op {
 		case ops.Block, ops.Loop, ops.If:
-			sig, err := leb128.ReadVarint32(reader)
+			sig, err := wasm.ReadByte(reader)
 			if err != nil {
 				return nil, err
 			}

validate/validate.go

@@ -67,7 +67,7 @@ func verifyBody(fn *wasm.FunctionSig, body *wasm.FunctionBody, module *wasm.Modu
 
 		switch op {
 		case ops.If, ops.Block, ops.Loop:
-			sig, err := vm.fetchVarInt()
+			sig, err := vm.fetchByte()
 			if err != nil {
 				return vm, err
 			}

validate/vm.go

@@ -49,6 +49,10 @@ func (vm *mockVM) fetchVarInt() (int32, error) {
 	return leb128.ReadVarint32(vm.code)
 }
 
+func (vm *mockVM) fetchByte() (byte, error) {
+	return vm.code.ReadByte()
+}
+
 func (vm *mockVM) fetchVarInt64() (int64, error) {
 	return leb128.ReadVarint64(vm.code)
 }

wasm/read.go

@@ -35,6 +35,17 @@ func readBytes(r io.Reader, n int) ([]byte, error) {
 	return nil, io.ErrUnexpectedEOF
 }
 
+func writeByte(w io.Writer, b byte) error {
+	_, err := w.Write([]byte{b})
+	return err
+}
+
+func ReadByte(r io.Reader) (byte, error) {
+	p := make([]byte, 1)
+	_, err := r.Read(p)
+	return p[0], err
+}
+
 func readBytesUint(r io.Reader) ([]byte, error) {
 	n, err := leb128.ReadVarUint32(r)
 	if err != nil {

wasm/types.go

@@ -5,6 +5,7 @@
 package wasm
 
 import (
+	"errors"
 	"fmt"
 	"io"
 
@@ -22,13 +23,13 @@ type Unmarshaler interface {
 }
 
 // ValueType represents the type of a valid value in Wasm
-type ValueType int8
+type ValueType uint8
 
 const (
-	ValueTypeI32 ValueType = -0x01
-	ValueTypeI64 ValueType = -0x02
-	ValueTypeF32 ValueType = -0x03
-	ValueTypeF64 ValueType = -0x04
+	ValueTypeI32 ValueType = 0x7f
+	ValueTypeI64 ValueType = 0x7e
+	ValueTypeF32 ValueType = 0x7d
+	ValueTypeF64 ValueType = 0x7c
 )
 
 var valueTypeStrMap = map[ValueType]string{
@@ -47,10 +48,10 @@ func (t ValueType) String() string {
 }
 
 // TypeFunc represents the value type of a function
-const TypeFunc int = -0x20
+const TypeFunc uint8 = 0x60
 
 func (t *ValueType) UnmarshalWASM(r io.Reader) error {
-	v, err := leb128.ReadVarint32(r)
+	v, err := ReadByte(r)
 	if err != nil {
 		return err
 	}
@@ -59,13 +60,13 @@ func (t *ValueType) UnmarshalWASM(r io.Reader) error {
 }
 
 func (t ValueType) MarshalWASM(w io.Writer) error {
-	_, err := leb128.WriteVarint64(w, int64(t))
+	err := writeByte(w, byte(t))
 	return err
 }
 
 // BlockType represents the signature of a structured block
 type BlockType ValueType // varint7
-const BlockTypeEmpty BlockType = -0x40
+const BlockTypeEmpty BlockType = 0x40
 
 func (b BlockType) String() string {
 	if b == BlockTypeEmpty {
@@ -75,22 +76,24 @@ func (b BlockType) String() string {
 }
 
 // ElemType describes the type of a table's elements
-type ElemType int // varint7
+type ElemType uint8 // varint7
 // ElemTypeAnyFunc descibres an any_func value
-const ElemTypeAnyFunc ElemType = -0x10
+const ElemTypeAnyFunc ElemType = 0x70
 
 func (t *ElemType) UnmarshalWASM(r io.Reader) error {
-	b, err := leb128.ReadVarint32(r)
+	b, err := ReadByte(r)
 	if err != nil {
 		return err
 	}
+	if b != uint8(ElemTypeAnyFunc) {
+		return fmt.Errorf("wasm: unsupported elem type:%d", b)
+	}
 	*t = ElemType(b)
 	return nil
 }
 
 func (t ElemType) MarshalWASM(w io.Writer) error {
-	_, err := leb128.WriteVarint64(w, int64(t))
-	return err
+	return writeByte(w, byte(t))
 }
 
 func (t ElemType) String() string {
@@ -104,7 +107,7 @@ func (t ElemType) String() string {
 // FunctionSig describes the signature of a declared function in a WASM module
 type FunctionSig struct {
 	// value for the 'func` type constructor
-	Form int8
+	Form uint8 // must be 0x60
 	// The parameter types of the function
 	ParamTypes  []ValueType
 	ReturnTypes []ValueType
@@ -124,11 +127,14 @@ func (e InvalidTypeConstructorError) Error() string {
 }
 
 func (f *FunctionSig) UnmarshalWASM(r io.Reader) error {
-	form, err := leb128.ReadVarint32(r)
+	form, err := ReadByte(r)
 	if err != nil {
 		return err
 	}
-	f.Form = int8(form)
+	if form != TypeFunc {
+		return fmt.Errorf("wasm: unknown function form: %x", form)
+	}
+	f.Form = uint8(form)
 
 	paramCount, err := leb128.ReadVarUint32(r)
 	if err != nil {
@@ -162,7 +168,7 @@ func (f *FunctionSig) UnmarshalWASM(r io.Reader) error {
 }
 
 func (f *FunctionSig) MarshalWASM(w io.Writer) error {
-	_, err := leb128.WriteVarint64(w, int64(f.Form))
+	err := writeByte(w, f.Form)
 	if err != nil {
 		return err
 	}
@@ -205,12 +211,16 @@ func (g *GlobalVar) UnmarshalWASM(r io.Reader) error {
 		return err
 	}
 
-	m, err := leb128.ReadVarUint32(r)
+	m, err := ReadByte(r)
 	if err != nil {
 		return err
 	}
 
-	g.Mutable = m == 1
+	if m != 0x00 && m != 0x01 {
+		return errors.New("wasm: invalid global mutable flag")
+	}
+
+	g.Mutable = m == 0x01
 
 	return nil
 }
@@ -219,14 +229,11 @@ func (g *GlobalVar) MarshalWASM(w io.Writer) error {
 	if err := g.Type.MarshalWASM(w); err != nil {
 		return err
 	}
-	var m uint32
+	var m uint8
 	if g.Mutable {
 		m = 1
 	}
-	if _, err := leb128.WriteVarUint32(w, m); err != nil {
-		return err
-	}
-	return nil
+	return writeByte(w, m)
 }
 
 // Table describes a table in a Wasm module.
@@ -310,17 +317,20 @@ func (e External) MarshalWASM(w io.Writer) error {
 
 // ResizableLimits describe the limit of a table or linear memory.
 type ResizableLimits struct {
-	Flags   uint32 // 1 if the Maximum field is valid
+	Flags   uint8  // 1 if the Maximum field is valid, 0 otherwise
 	Initial uint32 // initial length (in units of table elements or wasm pages)
 	Maximum uint32 // If flags is 1, it describes the maximum size of the table or memory
 }
 
 func (lim *ResizableLimits) UnmarshalWASM(r io.Reader) error {
 	*lim = ResizableLimits{}
-	f, err := leb128.ReadVarUint32(r)
+	f, err := ReadByte(r)
 	if err != nil {
 		return err
 	}
+	if f != 0 && f != 1 {
+		return errors.New("wasm: invalid limit flag")
+	}
 	lim.Flags = f
 
 	lim.Initial, err = leb128.ReadVarUint32(r)
@@ -339,14 +349,18 @@ func (lim *ResizableLimits) UnmarshalWASM(r io.Reader) error {
 }
 
 func (lim *ResizableLimits) MarshalWASM(w io.Writer) error {
-	if _, err := leb128.WriteVarUint32(w, uint32(lim.Flags)); err != nil {
+	f := lim.Flags
+	if f != 0 && f != 1 {
+		return errors.New("wasm: invalid limit flag")
+	}
+	if _, err := w.Write([]byte{f}); err != nil {
 		return err
 	}
-	if _, err := leb128.WriteVarUint32(w, uint32(lim.Initial)); err != nil {
+	if _, err := leb128.WriteVarUint32(w, lim.Initial); err != nil {
 		return err
 	}
 	if lim.Flags&0x1 != 0 {
-		if _, err := leb128.WriteVarUint32(w, uint32(lim.Maximum)); err != nil {
+		if _, err := leb128.WriteVarUint32(w, lim.Maximum); err != nil {
 			return err
 		}
 	}