test: vm.WithUNSAFECallerAddressProxying() effect on outgoing caller addr

Author: ARR4N

core/vm/contracts.libevm_test.go

@@ -16,6 +16,7 @@
 package vm_test
 
 import (
+	"bytes"
 	"fmt"
 	"math/big"
 	"reflect"
@@ -375,10 +376,12 @@ func makeReturnProxy(t *testing.T, dest common.Address, call vm.OpCode) []vm.OpC
 	t.Helper()
 	const p0 = vm.PUSH0
 	contract := []vm.OpCode{
-		vm.PUSH1, 1, // retSize (bytes)
-		p0, // retOffset
-		p0, // argSize
-		p0, // argOffset
+		vm.CALLDATASIZE, p0, p0, vm.CALLDATACOPY,
+
+		p0,              // retSize
+		p0,              // retOffset
+		vm.CALLDATASIZE, // argSize
+		p0,              // argOffset
 	}
 
 	// See CALL signature: https://www.evm.codes/#f1?fork=cancun
@@ -511,13 +514,21 @@ func TestPrecompileMakeCall(t *testing.T) {
 	dest := common.HexToAddress("DE57")
 
 	rng := ethtest.NewPseudoRand(142857)
-	callData := rng.Bytes(8)
+	precompileCallData := rng.Bytes(8)
+
+	// If the SUT precompile receives this as its calldata then it will use the
+	// vm.WithUNSAFECallerAddressProxying() option.
+	unsafeCallerProxyOptSentinel := []byte("override-caller sentinel")
 
 	hooks := &hookstest.Stub{
 		PrecompileOverrides: map[common.Address]libevm.PrecompiledContract{
 			sut: vm.NewStatefulPrecompile(func(env vm.PrecompileEnvironment, input []byte, suppliedGas uint64) (ret []byte, remainingGas uint64, err error) {
+				var opts []vm.CallOption
+				if bytes.Equal(input, unsafeCallerProxyOptSentinel) {
+					opts = append(opts, vm.WithUNSAFECallerAddressProxying())
+				}
 				// We are ultimately testing env.Call(), hence why this is the SUT.
-				return env.Call(dest, callData, suppliedGas, uint256.NewInt(0))
+				return env.Call(dest, precompileCallData, suppliedGas, uint256.NewInt(0), opts...)
 			}),
 			dest: vm.NewStatefulPrecompile(func(env vm.PrecompileEnvironment, input []byte, suppliedGas uint64) (ret []byte, remainingGas uint64, err error) {
 				out := &statefulPrecompileOutput{
@@ -538,6 +549,7 @@ func TestPrecompileMakeCall(t *testing.T) {
 
 	tests := []struct {
 		incomingCallType vm.OpCode
+		eoaTxCallData    []byte
 		// Unlike TestNewStatefulPrecompile, which tests the AddressContext of
 		// the precompile itself, these test the AddressContext of a contract
 		// called by the precompile.
@@ -551,7 +563,19 @@ func TestPrecompileMakeCall(t *testing.T) {
 					Caller: sut,
 					Self:   dest,
 				},
-				Input: callData,
+				Input: precompileCallData,
+			},
+		},
+		{
+			incomingCallType: vm.CALL,
+			eoaTxCallData:    unsafeCallerProxyOptSentinel,
+			want: statefulPrecompileOutput{
+				Addresses: &libevm.AddressContext{
+					Origin: eoa,
+					Caller: caller, // overridden by CallOption
+					Self:   dest,
+				},
+				Input: precompileCallData,
 			},
 		},
 		{
@@ -562,7 +586,19 @@ func TestPrecompileMakeCall(t *testing.T) {
 					Caller: caller, // SUT runs as its own caller because of CALLCODE
 					Self:   dest,
 				},
-				Input: callData,
+				Input: precompileCallData,
+			},
+		},
+		{
+			incomingCallType: vm.CALLCODE,
+			eoaTxCallData:    unsafeCallerProxyOptSentinel,
+			want: statefulPrecompileOutput{
+				Addresses: &libevm.AddressContext{
+					Origin: eoa,
+					Caller: caller, // CallOption is a NOOP
+					Self:   dest,
+				},
+				Input: precompileCallData,
 			},
 		},
 		{
@@ -573,7 +609,19 @@ func TestPrecompileMakeCall(t *testing.T) {
 					Caller: caller, // as with CALLCODE
 					Self:   dest,
 				},
-				Input: callData,
+				Input: precompileCallData,
+			},
+		},
+		{
+			incomingCallType: vm.DELEGATECALL,
+			eoaTxCallData:    unsafeCallerProxyOptSentinel,
+			want: statefulPrecompileOutput{
+				Addresses: &libevm.AddressContext{
+					Origin: eoa,
+					Caller: caller, // CallOption is a NOOP
+					Self:   dest,
+				},
+				Input: precompileCallData,
 			},
 		},
 		{
@@ -584,25 +632,39 @@ func TestPrecompileMakeCall(t *testing.T) {
 					Caller: sut,
 					Self:   dest,
 				},
-				Input: callData,
+				Input: precompileCallData,
 				// This demonstrates that even though the precompile makes a
 				// (non-static) CALL, the read-only state is inherited. Yes,
 				// this is _another_ way to get a read-only state, different to
 				// the other tests.
 				ReadOnly: true,
 			},
 		},
+		{
+			incomingCallType: vm.STATICCALL,
+			eoaTxCallData:    unsafeCallerProxyOptSentinel,
+			want: statefulPrecompileOutput{
+				Addresses: &libevm.AddressContext{
+					Origin: eoa,
+					Caller: caller, // overridden by CallOption
+					Self:   dest,
+				},
+				Input:    precompileCallData,
+				ReadOnly: true,
+			},
+		},
 	}
 
 	for _, tt := range tests {
-		t.Run(fmt.Sprintf("via %s", tt.incomingCallType), func(t *testing.T) {
+		t.Run(tt.incomingCallType.String(), func(t *testing.T) {
+			t.Logf("calldata = %q", tt.eoaTxCallData)
 			state, evm := ethtest.NewZeroEVM(t)
 			evm.Origin = eoa
 			state.CreateAccount(caller)
 			proxy := makeReturnProxy(t, sut, tt.incomingCallType)
 			state.SetCode(caller, convertBytes[vm.OpCode, byte](proxy))
 
-			got, _, err := evm.Call(vm.AccountRef(eoa), caller, nil, 1e6, uint256.NewInt(0))
+			got, _, err := evm.Call(vm.AccountRef(eoa), caller, tt.eoaTxCallData, 1e6, uint256.NewInt(0))
 			require.NoError(t, err)
 			require.Equal(t, tt.want.String(), string(got))
 		})