From b8cc33d0b2bbaf038820bcfeafc300826f589b0d Mon Sep 17 00:00:00 2001 From: Evgenii Stratonikov Date: Tue, 4 Aug 2020 10:10:05 +0300 Subject: [PATCH 1/2] stackitem: implement DeepCopy --- pkg/vm/stackitem/item.go | 63 +++++++++++++++++++++++++++++++++++ pkg/vm/stackitem/item_test.go | 59 ++++++++++++++++++++++++++++++++ 2 files changed, 122 insertions(+) diff --git a/pkg/vm/stackitem/item.go b/pkg/vm/stackitem/item.go index 63c407948..324086dfa 100644 --- a/pkg/vm/stackitem/item.go +++ b/pkg/vm/stackitem/item.go @@ -1019,3 +1019,66 @@ func (i *Buffer) Convert(typ Type) (Item, error) { func (i *Buffer) Len() int { return len(i.value) } + +// DeepCopy returns new deep copy of the provided item. +// Values of Interop items are not deeply copied. +// It does preserve duplicates only for non-primitive types. +func DeepCopy(item Item) Item { + seen := make(map[Item]Item) + return deepCopy(item, seen) +} + +func deepCopy(item Item, seen map[Item]Item) Item { + if it := seen[item]; it != nil { + return it + } + switch it := item.(type) { + case Null: + return Null{} + case *Array: + arr := NewArray(make([]Item, len(it.value))) + seen[item] = arr + for i := range it.value { + arr.value[i] = deepCopy(it.value[i], seen) + } + return arr + case *Struct: + arr := NewStruct(make([]Item, len(it.value))) + seen[item] = arr + for i := range it.value { + arr.value[i] = deepCopy(it.value[i], seen) + } + return arr + case *Map: + m := NewMap() + seen[item] = m + for i := range it.value { + key := deepCopy(it.value[i].Key, seen) + value := deepCopy(it.value[i].Value, seen) + m.Add(key, value) + } + return m + case *BigInteger: + bi := new(big.Int).SetBytes(it.value.Bytes()) + if it.value.Sign() == -1 { + bi.Neg(bi) + } + return NewBigInteger(bi) + case *ByteArray: + val := make([]byte, len(it.value)) + copy(val, it.value) + return NewByteArray(val) + case *Buffer: + val := make([]byte, len(it.value)) + copy(val, it.value) + return NewBuffer(val) + case *Bool: + return NewBool(it.value) + case *Pointer: + return NewPointer(it.pos, it.script) + case *Interop: + return NewInterop(it.value) + default: + return nil + } +} diff --git a/pkg/vm/stackitem/item_test.go b/pkg/vm/stackitem/item_test.go index 723d0a489..43c2a03dd 100644 --- a/pkg/vm/stackitem/item_test.go +++ b/pkg/vm/stackitem/item_test.go @@ -5,6 +5,7 @@ import ( "testing" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) var makeStackItemTestCases = []struct { @@ -412,3 +413,61 @@ func TestMarshalJSON(t *testing.T) { assert.Equal(t, testCase.result, actual) } } + +func TestDeepCopy(t *testing.T) { + testCases := []struct { + name string + item Item + }{ + {"Integer", NewBigInteger(big.NewInt(1))}, + {"ByteArray", NewByteArray([]byte{1, 2, 3})}, + {"Buffer", NewBuffer([]byte{1, 2, 3})}, + {"Bool", NewBool(true)}, + {"Pointer", NewPointer(1, []byte{1, 2, 3})}, + {"Interop", NewInterop(&[]byte{1, 2})}, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + actual := DeepCopy(tc.item) + require.Equal(t, tc.item, actual) + require.False(t, actual == tc.item) + }) + } + + t.Run("Null", func(t *testing.T) { + require.Equal(t, Null{}, DeepCopy(Null{})) + }) + + t.Run("Array", func(t *testing.T) { + arr := NewArray(make([]Item, 2)) + arr.value[0] = NewBool(true) + arr.value[1] = arr + + actual := DeepCopy(arr) + require.Equal(t, arr, actual) + require.False(t, arr == actual) + require.True(t, actual == actual.(*Array).value[1]) + }) + + t.Run("Struct", func(t *testing.T) { + arr := NewStruct(make([]Item, 2)) + arr.value[0] = NewBool(true) + arr.value[1] = arr + + actual := DeepCopy(arr) + require.Equal(t, arr, actual) + require.False(t, arr == actual) + require.True(t, actual == actual.(*Struct).value[1]) + }) + + t.Run("Map", func(t *testing.T) { + m := NewMapWithValue(make([]MapElement, 2)) + m.value[0] = MapElement{Key: NewBool(true), Value: m} + m.value[1] = MapElement{Key: NewBigInteger(big.NewInt(1)), Value: NewByteArray([]byte{1, 2, 3})} + + actual := DeepCopy(m) + require.Equal(t, m, actual) + require.False(t, m == actual) + require.True(t, actual == actual.(*Map).value[0].Value) + }) +} From 194da649751e5a7f4b946860f0c92b77b10f0fce Mon Sep 17 00:00:00 2001 From: Evgenii Stratonikov Date: Tue, 4 Aug 2020 10:13:36 +0300 Subject: [PATCH 2/2] core: deepcopy notification in `System.Runtime.Notify` Make it impossible to change already emitted notifications via `System.Runtime.GetNotifications`. --- pkg/core/interop/runtime/util.go | 2 +- pkg/core/interop_system.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pkg/core/interop/runtime/util.go b/pkg/core/interop/runtime/util.go index 522940381..aef0f8ce8 100644 --- a/pkg/core/interop/runtime/util.go +++ b/pkg/core/interop/runtime/util.go @@ -47,7 +47,7 @@ func GetNotifications(ic *interop.Context, v *vm.VM) error { ev := stackitem.NewArray([]stackitem.Item{ stackitem.NewByteArray(notifications[i].ScriptHash.BytesBE()), stackitem.Make(notifications[i].Name), - notifications[i].Item, + stackitem.DeepCopy(notifications[i].Item).(*stackitem.Array), }) arr.Append(ev) } diff --git a/pkg/core/interop_system.go b/pkg/core/interop_system.go index 508d02bfb..242460ca0 100644 --- a/pkg/core/interop_system.go +++ b/pkg/core/interop_system.go @@ -282,7 +282,7 @@ func runtimeNotify(ic *interop.Context, v *vm.VM) error { ne := state.NotificationEvent{ ScriptHash: v.GetCurrentScriptHash(), Name: name, - Item: stackitem.NewArray(args), + Item: stackitem.DeepCopy(stackitem.NewArray(args)).(*stackitem.Array), } ic.Notifications = append(ic.Notifications, ne) return nil