package vm import ( "crypto/sha1" "encoding/binary" "fmt" "io/ioutil" "math/big" "os" "reflect" "text/tabwriter" "unicode/utf8" "github.com/CityOfZion/neo-go/pkg/crypto/hash" "github.com/CityOfZion/neo-go/pkg/crypto/keys" "github.com/CityOfZion/neo-go/pkg/util" "github.com/CityOfZion/neo-go/pkg/vm/opcode" "github.com/pkg/errors" ) type errorAtInstruct struct { ip int op opcode.Opcode err interface{} } func (e *errorAtInstruct) Error() string { return fmt.Sprintf("error encountered at instruction %d (%s): %s", e.ip, e.op, e.err) } func newError(ip int, op opcode.Opcode, err interface{}) *errorAtInstruct { return &errorAtInstruct{ip: ip, op: op, err: err} } // StateMessage is a vm state message which could be used as additional info for example by cli. type StateMessage string const ( // MaxArraySize is the maximum array size allowed in the VM. MaxArraySize = 1024 // MaxItemSize is the maximum item size allowed in the VM. MaxItemSize = 1024 * 1024 // MaxInvocationStackSize is the maximum size of an invocation stack. MaxInvocationStackSize = 1024 // MaxBigIntegerSizeBits is the maximum size of BigInt item in bits. MaxBigIntegerSizeBits = 32 * 8 // MaxStackSize is the maximum number of items allowed to be // on all stacks at once. MaxStackSize = 2 * 1024 maxSHLArg = MaxBigIntegerSizeBits minSHLArg = -MaxBigIntegerSizeBits ) // VM represents the virtual machine. type VM struct { state State // registered interop hooks. interop map[string]InteropFuncPrice // callback to get scripts. getScript func(util.Uint160) []byte istack *Stack // invocation stack. estack *Stack // execution stack. astack *Stack // alt stack. // Hash to verify in CHECKSIG/CHECKMULTISIG. checkhash []byte itemCount map[StackItem]int size int // Public keys cache. keys map[string]*keys.PublicKey } // InteropFuncPrice represents an interop function with a price. type InteropFuncPrice struct { Func InteropFunc Price int } // New returns a new VM object ready to load .avm bytecode scripts. func New() *VM { vm := &VM{ interop: make(map[string]InteropFuncPrice), getScript: nil, state: haltState, istack: NewStack("invocation"), itemCount: make(map[StackItem]int), keys: make(map[string]*keys.PublicKey), } vm.estack = vm.newItemStack("evaluation") vm.astack = vm.newItemStack("alt") // Register native interop hooks. vm.RegisterInteropFunc("Neo.Runtime.Log", runtimeLog, 1) vm.RegisterInteropFunc("Neo.Runtime.Notify", runtimeNotify, 1) vm.RegisterInteropFunc("Neo.Runtime.Serialize", RuntimeSerialize, 1) vm.RegisterInteropFunc("System.Runtime.Serialize", RuntimeSerialize, 1) vm.RegisterInteropFunc("Neo.Runtime.Deserialize", RuntimeDeserialize, 1) vm.RegisterInteropFunc("System.Runtime.Deserialize", RuntimeDeserialize, 1) return vm } func (v *VM) newItemStack(n string) *Stack { s := NewStack(n) s.size = &v.size s.itemCount = v.itemCount return s } // RegisterInteropFunc registers the given InteropFunc to the VM. func (v *VM) RegisterInteropFunc(name string, f InteropFunc, price int) { v.interop[name] = InteropFuncPrice{f, price} } // RegisterInteropFuncs registers all interop functions passed in a map in // the VM. Effectively it's a batched version of RegisterInteropFunc. func (v *VM) RegisterInteropFuncs(interops map[string]InteropFuncPrice) { // We allow reregistration here. for name := range interops { v.interop[name] = interops[name] } } // Estack returns the evaluation stack so interop hooks can utilize this. func (v *VM) Estack() *Stack { return v.estack } // Astack returns the alt stack so interop hooks can utilize this. func (v *VM) Astack() *Stack { return v.astack } // Istack returns the invocation stack so interop hooks can utilize this. func (v *VM) Istack() *Stack { return v.istack } // SetPublicKeys sets internal key cache to the specified value (note // that it doesn't copy them). func (v *VM) SetPublicKeys(keys map[string]*keys.PublicKey) { v.keys = keys } // GetPublicKeys returns internal key cache (note that it doesn't copy it). func (v *VM) GetPublicKeys() map[string]*keys.PublicKey { return v.keys } // LoadArgs loads in the arguments used in the Mian entry point. func (v *VM) LoadArgs(method []byte, args []StackItem) { if len(args) > 0 { v.estack.PushVal(args) } if method != nil { v.estack.PushVal(method) } } // PrintOps prints the opcodes of the current loaded program to stdout. func (v *VM) PrintOps() { w := tabwriter.NewWriter(os.Stdout, 0, 0, 4, ' ', 0) fmt.Fprintln(w, "INDEX\tOPCODE\tPARAMETER\t") realctx := v.Context() ctx := realctx.Copy() ctx.ip = 0 ctx.nextip = 0 for { cursor := "" instr, parameter, err := ctx.Next() if ctx.ip == realctx.ip { cursor = "<<" } if err != nil { fmt.Fprintf(w, "%d\t%s\tERROR: %s\t%s\n", ctx.ip, instr, err, cursor) break } var desc = "" if parameter != nil { switch instr { case opcode.JMP, opcode.JMPIF, opcode.JMPIFNOT, opcode.CALL: offset := int16(binary.LittleEndian.Uint16(parameter)) desc = fmt.Sprintf("%d (%d/%x)", ctx.ip+int(offset), offset, parameter) case opcode.SYSCALL: desc = fmt.Sprintf("%q", parameter) case opcode.APPCALL, opcode.TAILCALL: desc = fmt.Sprintf("%x", parameter) default: if utf8.Valid(parameter) { desc = fmt.Sprintf("%x (%q)", parameter, parameter) } else { desc = fmt.Sprintf("%x", parameter) } } } fmt.Fprintf(w, "%d\t%s\t%s\t%s\n", ctx.ip, instr, desc, cursor) if ctx.nextip >= len(ctx.prog) { break } } w.Flush() } // AddBreakPoint adds a breakpoint to the current context. func (v *VM) AddBreakPoint(n int) { ctx := v.Context() ctx.breakPoints = append(ctx.breakPoints, n) } // AddBreakPointRel adds a breakpoint relative to the current // instruction pointer. func (v *VM) AddBreakPointRel(n int) { ctx := v.Context() v.AddBreakPoint(ctx.ip + n) } // LoadFile loads a program from the given path, ready to execute it. func (v *VM) LoadFile(path string) error { b, err := ioutil.ReadFile(path) if err != nil { return err } v.Load(b) return nil } // Load initializes the VM with the program given. func (v *VM) Load(prog []byte) { // Clear all stacks and state, it could be a reload. v.istack.Clear() v.estack.Clear() v.astack.Clear() v.state = noneState v.LoadScript(prog) } // LoadScript loads a script from the internal script table. It // will immediately push a new context created from this script to // the invocation stack and starts executing it. func (v *VM) LoadScript(b []byte) { ctx := NewContext(b) ctx.estack = v.estack ctx.astack = v.astack v.istack.PushVal(ctx) } // Context returns the current executed context. Nil if there is no context, // which implies no program is loaded. func (v *VM) Context() *Context { if v.istack.Len() == 0 { return nil } return v.istack.Peek(0).Value().(*Context) } // PopResult is used to pop the first item of the evaluation stack. This allows // us to test compiler and vm in a bi-directional way. func (v *VM) PopResult() interface{} { e := v.estack.Pop() if e != nil { return e.Value() } return nil } // Stack returns json formatted representation of the given stack. func (v *VM) Stack(n string) string { var s *Stack if n == "astack" { s = v.astack } if n == "istack" { s = v.istack } if n == "estack" { s = v.estack } return buildStackOutput(s) } // State returns string representation of the state for the VM. func (v *VM) State() string { return v.state.String() } // Ready returns true if the VM ready to execute the loaded program. // Will return false if no program is loaded. func (v *VM) Ready() bool { return v.istack.Len() > 0 } // Run starts the execution of the loaded program. func (v *VM) Run() error { if !v.Ready() { v.state = faultState return errors.New("no program loaded") } if v.state.HasFlag(faultState) { // VM already ran something and failed, in general its state is // undefined in this case so we can't run anything. return errors.New("VM has failed") } // haltState (the default) or breakState are safe to continue. v.state = noneState for { // check for breakpoint before executing the next instruction ctx := v.Context() if ctx != nil && ctx.atBreakPoint() { v.state |= breakState } switch { case v.state.HasFlag(faultState): // Should be caught and reported already by the v.Step(), // but we're checking here anyway just in case. return errors.New("VM has failed") case v.state.HasFlag(haltState), v.state.HasFlag(breakState): // Normal exit from this loop. return nil case v.state == noneState: if err := v.Step(); err != nil { return err } default: v.state = faultState return errors.New("unknown state") } } } // Step 1 instruction in the program. func (v *VM) Step() error { ctx := v.Context() op, param, err := ctx.Next() if err != nil { v.state = faultState return newError(ctx.ip, op, err) } return v.execute(ctx, op, param) } // StepInto behaves the same as “step over” in case if the line does not contain a function. Otherwise // the debugger will enter the called function and continue line-by-line debugging there. func (v *VM) StepInto() error { ctx := v.Context() if ctx == nil { v.state |= haltState } if v.HasStopped() { return nil } if ctx != nil && ctx.prog != nil { op, param, err := ctx.Next() if err != nil { v.state = faultState return newError(ctx.ip, op, err) } vErr := v.execute(ctx, op, param) if vErr != nil { return vErr } } cctx := v.Context() if cctx != nil && cctx.atBreakPoint() { v.state = breakState } return nil } // StepOut takes the debugger to the line where the current function was called. func (v *VM) StepOut() error { var err error if v.state == breakState { v.state = noneState } else { v.state = breakState } expSize := v.istack.len for v.state == noneState && v.istack.len >= expSize { err = v.StepInto() } return err } // StepOver takes the debugger to the line that will step over a given line. // If the line contains a function the function will be executed and the result returned without debugging each line. func (v *VM) StepOver() error { var err error if v.HasStopped() { return err } if v.state == breakState { v.state = noneState } else { v.state = breakState } expSize := v.istack.len for { err = v.StepInto() if !(v.state == noneState && v.istack.len > expSize) { break } } if v.state == noneState { v.state = breakState } return err } // HasFailed returns whether VM is in the failed state now. Usually used to // check status after Run. func (v *VM) HasFailed() bool { return v.state.HasFlag(faultState) } // HasStopped returns whether VM is in Halt or Failed state. func (v *VM) HasStopped() bool { return v.state.HasFlag(haltState) || v.state.HasFlag(faultState) } // HasHalted returns whether VM is in Halt state. func (v *VM) HasHalted() bool { return v.state.HasFlag(haltState) } // AtBreakpoint returns whether VM is at breakpoint. func (v *VM) AtBreakpoint() bool { return v.state.HasFlag(breakState) } // SetCheckedHash sets checked hash for CHECKSIG and CHECKMULTISIG instructions. func (v *VM) SetCheckedHash(h []byte) { v.checkhash = make([]byte, len(h)) copy(v.checkhash, h) } // SetScriptGetter sets the script getter for CALL instructions. func (v *VM) SetScriptGetter(gs func(util.Uint160) []byte) { v.getScript = gs } // execute performs an instruction cycle in the VM. Acting on the instruction (opcode). func (v *VM) execute(ctx *Context, op opcode.Opcode, parameter []byte) (err error) { // Instead of polluting the whole VM logic with error handling, we will recover // each panic at a central point, putting the VM in a fault state and setting error. defer func() { if errRecover := recover(); errRecover != nil { v.state = faultState err = newError(ctx.ip, op, errRecover) } else if v.size > MaxStackSize { v.state = faultState err = newError(ctx.ip, op, "stack is too big") } }() if op >= opcode.PUSHBYTES1 && op <= opcode.PUSHBYTES75 { v.estack.PushVal(parameter) return } switch op { case opcode.PUSHM1, opcode.PUSH1, opcode.PUSH2, opcode.PUSH3, opcode.PUSH4, opcode.PUSH5, opcode.PUSH6, opcode.PUSH7, opcode.PUSH8, opcode.PUSH9, opcode.PUSH10, opcode.PUSH11, opcode.PUSH12, opcode.PUSH13, opcode.PUSH14, opcode.PUSH15, opcode.PUSH16: val := int(op) - int(opcode.PUSH1) + 1 v.estack.PushVal(val) case opcode.PUSH0: v.estack.PushVal([]byte{}) case opcode.PUSHDATA1, opcode.PUSHDATA2, opcode.PUSHDATA4: v.estack.PushVal(parameter) // Stack operations. case opcode.TOALTSTACK: v.astack.Push(v.estack.Pop()) case opcode.FROMALTSTACK: v.estack.Push(v.astack.Pop()) case opcode.DUPFROMALTSTACK: v.estack.Push(v.astack.Dup(0)) case opcode.DUP: v.estack.Push(v.estack.Dup(0)) case opcode.SWAP: err := v.estack.Swap(1, 0) if err != nil { panic(err.Error()) } case opcode.TUCK: a := v.estack.Dup(0) if a == nil { panic("no top-level element found") } if v.estack.Len() < 2 { panic("can't TUCK with a one-element stack") } v.estack.InsertAt(a, 2) case opcode.CAT: b := v.estack.Pop().Bytes() a := v.estack.Pop().Bytes() if l := len(a) + len(b); l > MaxItemSize { panic(fmt.Sprintf("too big item: %d", l)) } ab := append(a, b...) v.estack.PushVal(ab) case opcode.SUBSTR: l := int(v.estack.Pop().BigInt().Int64()) if l < 0 { panic("negative length") } o := int(v.estack.Pop().BigInt().Int64()) if o < 0 { panic("negative index") } s := v.estack.Pop().Bytes() if o > len(s) { // panic("invalid offset") // FIXME revert when NEO 3.0 https://github.com/nspcc-dev/neo-go/issues/477 v.estack.PushVal("") break } last := l + o if last > len(s) { last = len(s) } v.estack.PushVal(s[o:last]) case opcode.LEFT: l := int(v.estack.Pop().BigInt().Int64()) if l < 0 { panic("negative length") } s := v.estack.Pop().Bytes() if t := len(s); l > t { l = t } v.estack.PushVal(s[:l]) case opcode.RIGHT: l := int(v.estack.Pop().BigInt().Int64()) if l < 0 { panic("negative length") } s := v.estack.Pop().Bytes() v.estack.PushVal(s[len(s)-l:]) case opcode.XDROP: n := int(v.estack.Pop().BigInt().Int64()) if n < 0 { panic("invalid length") } e := v.estack.RemoveAt(n) if e == nil { panic("bad index") } case opcode.XSWAP: n := int(v.estack.Pop().BigInt().Int64()) err := v.estack.Swap(n, 0) if err != nil { panic(err.Error()) } case opcode.XTUCK: n := int(v.estack.Pop().BigInt().Int64()) if n <= 0 { panic("XTUCK: invalid length") } a := v.estack.Dup(0) if a == nil { panic("no top-level element found") } if n > v.estack.Len() { panic("can't push to the position specified") } v.estack.InsertAt(a, n) case opcode.ROT: err := v.estack.Roll(2) if err != nil { panic(err.Error()) } case opcode.DEPTH: v.estack.PushVal(v.estack.Len()) case opcode.NIP: elem := v.estack.RemoveAt(1) if elem == nil { panic("no second element found") } case opcode.OVER: a := v.estack.Peek(1) if a == nil { panic("no second element found") } v.estack.Push(a) case opcode.PICK: n := int(v.estack.Pop().BigInt().Int64()) if n < 0 { panic("negative stack item returned") } a := v.estack.Peek(n) if a == nil { panic("no nth element found") } v.estack.Push(a) case opcode.ROLL: n := int(v.estack.Pop().BigInt().Int64()) err := v.estack.Roll(n) if err != nil { panic(err.Error()) } case opcode.DROP: if v.estack.Len() < 1 { panic("stack is too small") } v.estack.Pop() case opcode.EQUAL: b := v.estack.Pop() if b == nil { panic("no top-level element found") } a := v.estack.Pop() if a == nil { panic("no second-to-the-top element found") } if ta, ok := a.value.(*ArrayItem); ok { if tb, ok := b.value.(*ArrayItem); ok { v.estack.PushVal(ta == tb) break } } else if ma, ok := a.value.(*MapItem); ok { if mb, ok := b.value.(*MapItem); ok { v.estack.PushVal(ma == mb) break } } v.estack.PushVal(reflect.DeepEqual(a, b)) // Bit operations. case opcode.INVERT: // inplace a := v.estack.Peek(0).BigInt() a.Not(a) case opcode.AND: b := v.estack.Pop().BigInt() a := v.estack.Pop().BigInt() v.estack.PushVal(new(big.Int).And(b, a)) case opcode.OR: b := v.estack.Pop().BigInt() a := v.estack.Pop().BigInt() v.estack.PushVal(new(big.Int).Or(b, a)) case opcode.XOR: b := v.estack.Pop().BigInt() a := v.estack.Pop().BigInt() v.estack.PushVal(new(big.Int).Xor(b, a)) // Numeric operations. case opcode.ADD: a := v.estack.Pop().BigInt() v.checkBigIntSize(a) b := v.estack.Pop().BigInt() v.checkBigIntSize(b) c := new(big.Int).Add(a, b) v.checkBigIntSize(c) v.estack.PushVal(c) case opcode.SUB: b := v.estack.Pop().BigInt() v.checkBigIntSize(b) a := v.estack.Pop().BigInt() v.checkBigIntSize(a) c := new(big.Int).Sub(a, b) v.checkBigIntSize(c) v.estack.PushVal(c) case opcode.DIV: b := v.estack.Pop().BigInt() v.checkBigIntSize(b) a := v.estack.Pop().BigInt() v.checkBigIntSize(a) v.estack.PushVal(new(big.Int).Div(a, b)) case opcode.MUL: a := v.estack.Pop().BigInt() v.checkBigIntSize(a) b := v.estack.Pop().BigInt() v.checkBigIntSize(b) c := new(big.Int).Mul(a, b) v.checkBigIntSize(c) v.estack.PushVal(c) case opcode.MOD: b := v.estack.Pop().BigInt() v.checkBigIntSize(b) a := v.estack.Pop().BigInt() v.checkBigIntSize(a) v.estack.PushVal(new(big.Int).Mod(a, b)) case opcode.SHL, opcode.SHR: b := v.estack.Pop().BigInt().Int64() if b == 0 { return } else if b < minSHLArg || b > maxSHLArg { panic(fmt.Sprintf("operand must be between %d and %d", minSHLArg, maxSHLArg)) } a := v.estack.Pop().BigInt() v.checkBigIntSize(a) var item big.Int if op == opcode.SHL { item.Lsh(a, uint(b)) } else { item.Rsh(a, uint(b)) } v.checkBigIntSize(&item) v.estack.PushVal(&item) case opcode.BOOLAND: b := v.estack.Pop().Bool() a := v.estack.Pop().Bool() v.estack.PushVal(a && b) case opcode.BOOLOR: b := v.estack.Pop().Bool() a := v.estack.Pop().Bool() v.estack.PushVal(a || b) case opcode.NUMEQUAL: b := v.estack.Pop().BigInt() a := v.estack.Pop().BigInt() v.estack.PushVal(a.Cmp(b) == 0) case opcode.NUMNOTEQUAL: b := v.estack.Pop().BigInt() a := v.estack.Pop().BigInt() v.estack.PushVal(a.Cmp(b) != 0) case opcode.LT: b := v.estack.Pop().BigInt() a := v.estack.Pop().BigInt() v.estack.PushVal(a.Cmp(b) == -1) case opcode.GT: b := v.estack.Pop().BigInt() a := v.estack.Pop().BigInt() v.estack.PushVal(a.Cmp(b) == 1) case opcode.LTE: b := v.estack.Pop().BigInt() a := v.estack.Pop().BigInt() v.estack.PushVal(a.Cmp(b) <= 0) case opcode.GTE: b := v.estack.Pop().BigInt() a := v.estack.Pop().BigInt() v.estack.PushVal(a.Cmp(b) >= 0) case opcode.MIN: b := v.estack.Pop().BigInt() a := v.estack.Pop().BigInt() val := a if a.Cmp(b) == 1 { val = b } v.estack.PushVal(val) case opcode.MAX: b := v.estack.Pop().BigInt() a := v.estack.Pop().BigInt() val := a if a.Cmp(b) == -1 { val = b } v.estack.PushVal(val) case opcode.WITHIN: b := v.estack.Pop().BigInt() a := v.estack.Pop().BigInt() x := v.estack.Pop().BigInt() v.estack.PushVal(a.Cmp(x) <= 0 && x.Cmp(b) == -1) case opcode.INC: x := v.estack.Pop().BigInt() a := new(big.Int).Add(x, big.NewInt(1)) v.checkBigIntSize(a) v.estack.PushVal(a) case opcode.DEC: x := v.estack.Pop().BigInt() a := new(big.Int).Sub(x, big.NewInt(1)) v.checkBigIntSize(a) v.estack.PushVal(a) case opcode.SIGN: x := v.estack.Pop().BigInt() v.estack.PushVal(x.Sign()) case opcode.NEGATE: x := v.estack.Pop().BigInt() v.estack.PushVal(x.Neg(x)) case opcode.ABS: x := v.estack.Pop().BigInt() v.estack.PushVal(x.Abs(x)) case opcode.NOT: x := v.estack.Pop().Bool() v.estack.PushVal(!x) case opcode.NZ: x := v.estack.Pop().BigInt() v.estack.PushVal(x.Cmp(big.NewInt(0)) != 0) // Object operations. case opcode.NEWARRAY: item := v.estack.Pop() switch t := item.value.(type) { case *StructItem: arr := make([]StackItem, len(t.value)) copy(arr, t.value) v.estack.PushVal(&ArrayItem{arr}) case *ArrayItem: v.estack.PushVal(t) default: n := item.BigInt().Int64() if n > MaxArraySize { panic("too long array") } items := makeArrayOfFalses(int(n)) v.estack.PushVal(&ArrayItem{items}) } case opcode.NEWSTRUCT: item := v.estack.Pop() switch t := item.value.(type) { case *ArrayItem: arr := make([]StackItem, len(t.value)) copy(arr, t.value) v.estack.PushVal(&StructItem{arr}) case *StructItem: v.estack.PushVal(t) default: n := item.BigInt().Int64() if n > MaxArraySize { panic("too long struct") } items := makeArrayOfFalses(int(n)) v.estack.PushVal(&StructItem{items}) } case opcode.APPEND: itemElem := v.estack.Pop() arrElem := v.estack.Pop() val := cloneIfStruct(itemElem.value) switch t := arrElem.value.(type) { case *ArrayItem: arr := t.Value().([]StackItem) if len(arr) >= MaxArraySize { panic("too long array") } arr = append(arr, val) t.value = arr case *StructItem: arr := t.Value().([]StackItem) if len(arr) >= MaxArraySize { panic("too long struct") } arr = append(arr, val) t.value = arr default: panic("APPEND: not of underlying type Array") } v.estack.updateSizeAdd(val) case opcode.PACK: n := int(v.estack.Pop().BigInt().Int64()) if n < 0 || n > v.estack.Len() || n > MaxArraySize { panic("OPACK: invalid length") } items := make([]StackItem, n) for i := 0; i < n; i++ { items[i] = v.estack.Pop().value } v.estack.PushVal(items) case opcode.UNPACK: a := v.estack.Pop().Array() l := len(a) for i := l - 1; i >= 0; i-- { v.estack.PushVal(a[i]) } v.estack.PushVal(l) case opcode.PICKITEM: key := v.estack.Pop() validateMapKey(key) obj := v.estack.Pop() index := int(key.BigInt().Int64()) switch t := obj.value.(type) { // Struct and Array items have their underlying value as []StackItem. case *ArrayItem, *StructItem: arr := t.Value().([]StackItem) if index < 0 || index >= len(arr) { panic("PICKITEM: invalid index") } item := arr[index] v.estack.PushVal(item) case *MapItem: if !t.Has(key.value) { panic("invalid key") } k := toMapKey(key.value) v.estack.Push(&Element{value: t.value[k]}) default: arr := obj.Bytes() if index < 0 || index >= len(arr) { panic("PICKITEM: invalid index") } item := arr[index] v.estack.PushVal(int(item)) } case opcode.SETITEM: item := v.estack.Pop().value key := v.estack.Pop() validateMapKey(key) obj := v.estack.Pop() switch t := obj.value.(type) { // Struct and Array items have their underlying value as []StackItem. case *ArrayItem, *StructItem: arr := t.Value().([]StackItem) index := int(key.BigInt().Int64()) if index < 0 || index >= len(arr) { panic("SETITEM: invalid index") } v.estack.updateSizeRemove(arr[index]) arr[index] = item v.estack.updateSizeAdd(arr[index]) case *MapItem: if t.Has(key.value) { v.estack.updateSizeRemove(item) } else if len(t.value) >= MaxArraySize { panic("too big map") } t.Add(key.value, item) v.estack.updateSizeAdd(item) default: panic(fmt.Sprintf("SETITEM: invalid item type %s", t)) } case opcode.REVERSE: a := v.estack.Pop().Array() if len(a) > 1 { for i, j := 0, len(a)-1; i <= j; i, j = i+1, j-1 { a[i], a[j] = a[j], a[i] } } case opcode.REMOVE: key := v.estack.Pop() validateMapKey(key) elem := v.estack.Pop() switch t := elem.value.(type) { case *ArrayItem: a := t.value k := int(key.BigInt().Int64()) if k < 0 || k >= len(a) { panic("REMOVE: invalid index") } v.estack.updateSizeRemove(a[k]) a = append(a[:k], a[k+1:]...) t.value = a case *StructItem: a := t.value k := int(key.BigInt().Int64()) if k < 0 || k >= len(a) { panic("REMOVE: invalid index") } v.estack.updateSizeRemove(a[k]) a = append(a[:k], a[k+1:]...) t.value = a case *MapItem: m := t.value k := toMapKey(key.value) v.estack.updateSizeRemove(m[k]) delete(m, k) default: panic("REMOVE: invalid type") } case opcode.ARRAYSIZE: elem := v.estack.Pop() // Cause there is no native (byte) item type here, hence we need to check // the type of the item for array size operations. switch t := elem.Value().(type) { case []StackItem: v.estack.PushVal(len(t)) case map[interface{}]StackItem: v.estack.PushVal(len(t)) default: v.estack.PushVal(len(elem.Bytes())) } case opcode.SIZE: elem := v.estack.Pop() arr := elem.Bytes() v.estack.PushVal(len(arr)) case opcode.JMP, opcode.JMPIF, opcode.JMPIFNOT: var ( rOffset = int16(binary.LittleEndian.Uint16(parameter)) offset = ctx.ip + int(rOffset) ) if offset < 0 || offset > len(ctx.prog) { panic(fmt.Sprintf("JMP: invalid offset %d ip at %d", offset, ctx.ip)) } cond := true if op > opcode.JMP { cond = v.estack.Pop().Bool() if op == opcode.JMPIFNOT { cond = !cond } } if cond { ctx.nextip = offset } case opcode.CALL: v.checkInvocationStackSize() newCtx := ctx.Copy() newCtx.rvcount = -1 v.istack.PushVal(newCtx) err = v.execute(v.Context(), opcode.JMP, parameter) if err != nil { return } case opcode.SYSCALL: ifunc, ok := v.interop[string(parameter)] if !ok { panic(fmt.Sprintf("interop hook (%q) not registered", parameter)) } if err := ifunc.Func(v); err != nil { panic(fmt.Sprintf("failed to invoke syscall: %s", err)) } case opcode.APPCALL, opcode.TAILCALL: if v.getScript == nil { panic("no getScript callback is set up") } if op == opcode.APPCALL { v.checkInvocationStackSize() } hash, err := util.Uint160DecodeBytesBE(parameter) if err != nil { panic(err) } script := v.getScript(hash) if script == nil { panic("could not find script") } if op == opcode.TAILCALL { _ = v.istack.Pop() } v.LoadScript(script) case opcode.RET: oldCtx := v.istack.Pop().Value().(*Context) rvcount := oldCtx.rvcount oldEstack := v.estack if rvcount > 0 && oldEstack.Len() < rvcount { panic("missing some return elements") } if v.istack.Len() == 0 { v.state = haltState break } newEstack := v.Context().estack if oldEstack != newEstack { if rvcount < 0 { rvcount = oldEstack.Len() } for i := rvcount; i > 0; i-- { elem := oldEstack.RemoveAt(i - 1) newEstack.Push(elem) } v.estack = newEstack v.astack = v.Context().astack } case opcode.CHECKSIG, opcode.VERIFY: var hashToCheck []byte keyb := v.estack.Pop().Bytes() signature := v.estack.Pop().Bytes() if op == opcode.CHECKSIG { if v.checkhash == nil { panic("VM is not set up properly for signature checks") } hashToCheck = v.checkhash } else { // VERIFY msg := v.estack.Pop().Bytes() hashToCheck = hash.Sha256(msg).BytesBE() } pkey := v.bytesToPublicKey(keyb) res := pkey.Verify(signature, hashToCheck) v.estack.PushVal(res) case opcode.CHECKMULTISIG: pkeys, err := v.estack.popSigElements() if err != nil { panic(fmt.Sprintf("wrong parameters: %s", err.Error())) } sigs, err := v.estack.popSigElements() if err != nil { panic(fmt.Sprintf("wrong parameters: %s", err.Error())) } // It's ok to have more keys than there are signatures (it would // just mean that some keys didn't sign), but not the other way around. if len(pkeys) < len(sigs) { panic("more signatures than there are keys") } if v.checkhash == nil { panic("VM is not set up properly for signature checks") } sigok := true // j counts keys and i counts signatures. j := 0 for i := 0; sigok && j < len(pkeys) && i < len(sigs); { pkey := v.bytesToPublicKey(pkeys[j]) // We only move to the next signature if the check was // successful, but if it's not maybe the next key will // fit, so we always move to the next key. if pkey.Verify(sigs[i], v.checkhash) { i++ } j++ // When there are more signatures left to check than // there are keys the check won't successed for sure. if len(sigs)-i > len(pkeys)-j { sigok = false } } v.estack.PushVal(sigok) case opcode.NEWMAP: v.estack.Push(&Element{value: NewMapItem()}) case opcode.KEYS: item := v.estack.Pop() if item == nil { panic("no argument") } m, ok := item.value.(*MapItem) if !ok { panic("not a Map") } arr := make([]StackItem, 0, len(m.value)) for k := range m.value { arr = append(arr, makeStackItem(k)) } v.estack.PushVal(arr) case opcode.VALUES: item := v.estack.Pop() if item == nil { panic("no argument") } var arr []StackItem switch t := item.value.(type) { case *ArrayItem, *StructItem: src := t.Value().([]StackItem) arr = make([]StackItem, len(src)) for i := range src { arr[i] = cloneIfStruct(src[i]) } case *MapItem: arr = make([]StackItem, 0, len(t.value)) for k := range t.value { arr = append(arr, cloneIfStruct(t.value[k])) } default: panic("not a Map, Array or Struct") } v.estack.PushVal(arr) case opcode.HASKEY: key := v.estack.Pop() validateMapKey(key) c := v.estack.Pop() if c == nil { panic("no value found") } switch t := c.value.(type) { case *ArrayItem, *StructItem: index := key.BigInt().Int64() if index < 0 { panic("negative index") } v.estack.PushVal(index < int64(len(c.Array()))) case *MapItem: v.estack.PushVal(t.Has(key.value)) default: panic("wrong collection type") } // Cryptographic operations. case opcode.SHA1: b := v.estack.Pop().Bytes() sha := sha1.New() sha.Write(b) v.estack.PushVal(sha.Sum(nil)) case opcode.SHA256: b := v.estack.Pop().Bytes() v.estack.PushVal(hash.Sha256(b).BytesBE()) case opcode.HASH160: b := v.estack.Pop().Bytes() v.estack.PushVal(hash.Hash160(b).BytesBE()) case opcode.HASH256: b := v.estack.Pop().Bytes() v.estack.PushVal(hash.DoubleSha256(b).BytesBE()) case opcode.NOP: // unlucky ^^ case opcode.CALLI, opcode.CALLE, opcode.CALLED, opcode.CALLET, opcode.CALLEDT: var ( tailCall = (op == opcode.CALLET || op == opcode.CALLEDT) hashOnStack = (op == opcode.CALLED || op == opcode.CALLEDT) addElement int newCtx *Context ) if hashOnStack { addElement = 1 } rvcount := int(parameter[0]) pcount := int(parameter[1]) if v.estack.Len() < pcount+addElement { panic("missing some parameters") } if tailCall { if ctx.rvcount != rvcount { panic("context and parameter rvcount mismatch") } } else { v.checkInvocationStackSize() } if op == opcode.CALLI { newCtx = ctx.Copy() } else { var hashBytes []byte if hashOnStack { hashBytes = v.estack.Pop().Bytes() } else { hashBytes = parameter[2:] } hash, err := util.Uint160DecodeBytesBE(hashBytes) if err != nil { panic(err) } script := v.getScript(hash) if script == nil { panic(fmt.Sprintf("could not find script %s", hash)) } newCtx = NewContext(script) } newCtx.rvcount = rvcount newCtx.estack = NewStack("evaluation") newCtx.astack = NewStack("alt") // Going backwards to naturally push things onto the new stack. for i := pcount; i > 0; i-- { elem := v.estack.RemoveAt(i - 1) newCtx.estack.Push(elem) } if tailCall { _ = v.istack.Pop() } v.istack.PushVal(newCtx) v.estack = newCtx.estack v.astack = newCtx.astack if op == opcode.CALLI { err = v.execute(v.Context(), opcode.JMP, parameter[2:]) if err != nil { return } } case opcode.THROW: panic("THROW") case opcode.THROWIFNOT: if !v.estack.Pop().Bool() { panic("THROWIFNOT") } default: panic(fmt.Sprintf("unknown opcode %s", op.String())) } return } func cloneIfStruct(item StackItem) StackItem { switch it := item.(type) { case *StructItem: return it.Clone() default: return it } } func makeArrayOfFalses(n int) []StackItem { items := make([]StackItem, n) for i := range items { items[i] = &BoolItem{false} } return items } func validateMapKey(key *Element) { if key == nil { panic("no key found") } switch key.value.(type) { case *ArrayItem, *StructItem, *MapItem: panic("key can't be a collection") } } func (v *VM) checkInvocationStackSize() { if v.istack.len >= MaxInvocationStackSize { panic("invocation stack is too big") } } func (v *VM) checkBigIntSize(a *big.Int) { if a.BitLen() > MaxBigIntegerSizeBits { panic("big integer is too big") } } // bytesToPublicKey is a helper deserializing keys using cache and panicing on // error. func (v *VM) bytesToPublicKey(b []byte) *keys.PublicKey { var pkey *keys.PublicKey s := string(b) if v.keys[s] != nil { pkey = v.keys[s] } else { pkey = &keys.PublicKey{} err := pkey.DecodeBytes(b) if err != nil { panic(err.Error()) } v.keys[s] = pkey } return pkey }