Merge pull request #962 from multiversx/unsafe-operations-code

initial implementation of unSafe mode

Author: sasurobert

executor/vmHooks.go

@@ -19,6 +19,7 @@ type RuntimeContextMock struct {
 	CallFunction             string
 	VMType                   []byte
 	ReadOnlyFlag             bool
+	UnsafeModeFlag           bool
 	VerifyCode               bool
 	CurrentBreakpointValue   vmhost.BreakpointValue
 	PointsUsed               uint64
@@ -314,6 +315,16 @@ func (r *RuntimeContextMock) UseGasBoundedShouldFailExecution() bool {
 	return true
 }
 
+// IsUnsafeMode mocked method
+func (r *RuntimeContextMock) IsUnsafeMode() bool {
+	return r.UnsafeModeFlag
+}
+
+// SetUnsafeMode mocked method
+func (r *RuntimeContextMock) SetUnsafeMode(unsafeMode bool) {
+	r.UnsafeModeFlag = unsafeMode
+}
+
 // FailExecution mocked method
 func (r *RuntimeContextMock) FailExecution(_ error) {
 }

executor/wrapper/wrapperVMHooks.go

@@ -72,6 +72,10 @@ type RuntimeContextWrapper struct {
 	// function that will be called by the corresponding RuntimeContext function implementation (by default this will call the same wrapped context function)
 	SetReadOnlyFunc func(readOnly bool)
 	// function that will be called by the corresponding RuntimeContext function implementation (by default this will call the same wrapped context function)
+	IsUnsafeModeFunc func() bool
+	// function that will be called by the corresponding RuntimeContext function implementation (by default this will call the same wrapped context function)
+	SetUnsafeModeFunc func(readOnly bool)
+	// function that will be called by the corresponding RuntimeContext function implementation (by default this will call the same wrapped context function)
 	StartWasmerInstanceFunc func(contract []byte, gasLimit uint64, newCode bool) error
 	// function that will be called by the corresponding RuntimeContext function implementation (by default this will call the same wrapped context function)
 	ClearWarmInstanceCacheFunc func()
@@ -224,6 +228,14 @@ func NewRuntimeContextWrapper(inputRuntimeContext *vmhost.RuntimeContext) *Runti
 		runtimeWrapper.runtimeContext.SetReadOnly(readOnly)
 	}
 
+	runtimeWrapper.IsUnsafeModeFunc = func() bool {
+		return runtimeWrapper.runtimeContext.IsUnsafeMode()
+	}
+
+	runtimeWrapper.SetUnsafeModeFunc = func(unSafe bool) {
+		runtimeWrapper.runtimeContext.SetUnsafeMode(unSafe)
+	}
+
 	runtimeWrapper.StartWasmerInstanceFunc = func(contract []byte, gasLimit uint64, newCode bool) error {
 		return runtimeWrapper.runtimeContext.StartWasmerInstance(contract, gasLimit, newCode)
 	}
@@ -429,6 +441,16 @@ func (contextWrapper *RuntimeContextWrapper) SetReadOnly(readOnly bool) {
 	contextWrapper.SetReadOnlyFunc(readOnly)
 }
 
+// IsUnsafeMode calls corresponding xxxFunc function, that by default in turn calls the original method of the wrapped RuntimeContext
+func (contextWrapper *RuntimeContextWrapper) IsUnsafeMode() bool {
+	return contextWrapper.IsUnsafeModeFunc()
+}
+
+// SetUnsafeMode calls corresponding xxxFunc function, that by default in turn calls the original method of the wrapped RuntimeContext
+func (contextWrapper *RuntimeContextWrapper) SetUnsafeMode(unsafeMode bool) {
+	contextWrapper.SetUnsafeModeFunc(unsafeMode)
+}
+
 // StartWasmerInstance calls corresponding xxxFunc function, that by default in turn calls the original method of the wrapped RuntimeContext
 func (contextWrapper *RuntimeContextWrapper) StartWasmerInstance(contract []byte, gasLimit uint64, newCode bool) error {
 	return contextWrapper.StartWasmerInstanceFunc(contract, gasLimit, newCode)

mock/context/executorMockFunc.go

@@ -14,10 +14,32 @@ type MockRuntimeContext struct {
 	mock.Mock
 }
 
-// RemoveCodeUpgradeFromArgs -
+// RemoveCodeUpgradeFromArgs provides a mock function with given fields
 func (_m *MockRuntimeContext) RemoveCodeUpgradeFromArgs() {
 }
 
+// IsUnsafeMode provides a mock function with given fields
+func (_m *MockRuntimeContext) IsUnsafeMode() bool {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		return true
+	}
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func() bool); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	return r0
+}
+
+// SetUnsafeMode provides a mock function with given fields
+func (_m *MockRuntimeContext) SetUnsafeMode(_ bool) {
+}
+
 // AddError provides a mock function with given fields: err, otherInfo
 func (_m *MockRuntimeContext) AddError(err error, otherInfo ...string) {
 	_va := make([]interface{}, len(otherInfo))

mock/context/runtimeContextMock.go

@@ -0,0 +1,24 @@
+#include "../mxvm/context.h"
+
+// Forward declaration of the C functions, assuming they are linked externally
+void mx_activate_unsafe_mode(void);
+void mx_deactivate_unsafe_mode(void);
+void bigIntTDiv(int, int, int);
+
+void activateUnsafeMode(void) {
+    mx_activate_unsafe_mode();
+}
+
+void deactivateUnsafeMode(void) {
+    mx_deactivate_unsafe_mode();
+}
+
+void testDivByZero(void) {
+    int a = bigIntNew(1);
+    int b = bigIntNew(0);
+    int c = bigIntNew(0);
+    bigIntTDiv(c, a, b);
+}
+
+// Dummy function to satisfy the build system
+void _start() {}

mock/context/runtimeContextWrapper.go

@@ -0,0 +1,3 @@
+activateUnsafeMode
+deactivateUnsafeMode
+testDivByZero

mock/mockery/RuntimeContext.go

@@ -45,6 +45,11 @@ var mapBarnardOpcodes = map[string]struct{}{
 	"managedGetESDTTokenType":                      {},
 }
 
+var mapFailConditionalOpcodes = map[string]struct{}{
+	"ActivateUnsafeMode":   {},
+	"DeactivateUnsafeMode": {},
+}
+
 const warmCacheSize = 100
 
 type runtimeContext struct {
@@ -56,6 +61,7 @@ type runtimeContext struct {
 	readOnly             bool
 	verifyCode           bool
 	maxInstanceStackSize uint64
+	unsafeMode           bool
 
 	vmExecutor executor.Executor
 
@@ -124,6 +130,7 @@ func (context *runtimeContext) InitState() {
 	context.callFunction = ""
 	context.verifyCode = false
 	context.readOnly = false
+	context.unsafeMode = false
 	context.iTracker.InitState()
 	context.errors = nil
 
@@ -398,6 +405,7 @@ func (context *runtimeContext) PushState() {
 		codeAddress:  context.codeAddress,
 		callFunction: context.callFunction,
 		readOnly:     context.readOnly,
+		unsafeMode:   context.unsafeMode,
 	}
 	newState.SetVMInput(context.vmInput)
 
@@ -426,6 +434,7 @@ func (context *runtimeContext) PopSetActiveState() {
 	context.codeAddress = prevState.codeAddress
 	context.callFunction = prevState.callFunction
 	context.readOnly = prevState.readOnly
+	context.unsafeMode = prevState.unsafeMode
 }
 
 // PopDiscard removes the latest entry from the state stack
@@ -638,6 +647,16 @@ func (context *runtimeContext) FailExecution(err error) {
 	logRuntime.Trace("execution failed", "message", traceMessage)
 }
 
+// IsUnsafeMode returns true if mode is unsafe
+func (context *runtimeContext) IsUnsafeMode() bool {
+	return context.unsafeMode
+}
+
+// SetUnsafeMode sets the current mode of running
+func (context *runtimeContext) SetUnsafeMode(unsafeMode bool) {
+	context.unsafeMode = unsafeMode
+}
+
 // SignalUserError informs Wasmer to immediately stop the execution of the contract
 // with BreakpointSignalError and sets the corresponding VMOutput fields accordingly
 func (context *runtimeContext) SignalUserError(message string) {
@@ -704,6 +723,14 @@ func (context *runtimeContext) VerifyContractCode() error {
 		}
 	}
 
+	if !enableEpochsHandler.IsFlagEnabled(vmhost.FailConditionallyFlag) {
+		err = context.checkIfContainsFailConditionalOpcodes()
+		if err != nil {
+			logRuntime.Trace("verify contract code", "error", err)
+			return err
+		}
+	}
+
 	logRuntime.Trace("verified contract code")
 
 	return nil
@@ -727,6 +754,15 @@ func (context *runtimeContext) checkIfContainsBarnardOpcodes() error {
 	return nil
 }
 
+func (context *runtimeContext) checkIfContainsFailConditionalOpcodes() error {
+	for funcName := range mapFailConditionalOpcodes {
+		if context.iTracker.Instance().IsFunctionImported(funcName) {
+			return vmhost.ErrContractInvalid
+		}
+	}
+	return nil
+}
+
 // UseGasBoundedShouldFailExecution returns true when flag activated
 func (context *runtimeContext) UseGasBoundedShouldFailExecution() bool {
 	return context.host.EnableEpochsHandler().IsFlagEnabled(vmhost.UseGasBoundedShouldFailExecutionFlag)

test/contracts/unsafeOps/unsafeOps.c

@@ -839,3 +839,24 @@ func TestRuntimeContext_PopInstanceIfStackIsEmptyShouldNotPanic(t *testing.T) {
 
 	require.Equal(t, 0, len(runtimeCtx.stateStack))
 }
+
+func TestRuntimeContext_UnSafeMode(t *testing.T) {
+	host := InitializeVMAndWasmer()
+	runtimeCtx := makeDefaultRuntimeContext(t, host)
+	defer runtimeCtx.ClearWarmInstanceCache()
+
+	runtimeCtx.vmInput = nil
+	runtimeCtx.codeAddress = []byte("some address")
+	runtimeCtx.callFunction = "a function"
+	runtimeCtx.iTracker.codeSize = 1024
+
+	runtimeCtx.InitState()
+
+	require.False(t, runtimeCtx.IsUnsafeMode())
+	runtimeCtx.SetUnsafeMode(true)
+
+	require.True(t, runtimeCtx.IsUnsafeMode())
+
+	runtimeCtx.SetUnsafeMode(false)
+	require.False(t, runtimeCtx.IsUnsafeMode())
+}