EIP-211 updates

ethcore/src/evm/evm.rs

@@ -64,6 +64,8 @@ pub enum Error {
 	BuiltIn(&'static str),
 	/// When execution tries to modify the state in static context
 	MutableCallInStaticContext,
+	/// Out of bounds access in RETURNDATACOPY.
+	OutOfBounds,
 	/// Likely to cause consensus issues.
 	Internal(String),
 }
@@ -85,6 +87,7 @@ impl fmt::Display for Error {
 		use self::Error::*;
 		match *self {
 			OutOfGas => write!(f, "Out of gas"),
+			OutOfBounds => write!(f, "Out of bounds"),
 			BadJumpDestination { destination } => write!(f, "Bad jump destination {:x}", destination),
 			BadInstruction { instruction } => write!(f, "Bad instruction {:x}",  instruction),
 			StackUnderflow { instruction, wanted, on_stack } => write!(f, "Stack underflow {} {}/{}", instruction, wanted, on_stack),

ethcore/src/evm/interpreter/mod.rs

@@ -296,6 +296,9 @@ impl<Cost: CostType> Interpreter<Cost> {
 				let contract_code = self.mem.read_slice(init_off, init_size);
 				let can_create = ext.balance(&params.address)? >= endowment && ext.depth() < ext.schedule().max_depth;
 
+				// clear return data buffer before crearing new call frame.
+				self.return_data = ReturnData::empty();
+
 				if !can_create {
 					stack.push(U256::zero());
 					return Ok(InstructionResult::UnusedGas(create_gas));
@@ -353,6 +356,9 @@ impl<Cost: CostType> Interpreter<Cost> {
 					_ => panic!(format!("Unexpected instruction {} in CALL branch.", instruction))
 				};
 
+				// clear return data buffer before crearing new call frame.
+				self.return_data = ReturnData::empty();
+
 				let can_call = has_balance && ext.depth() < ext.schedule().max_depth;
 				if !can_call {
 					stack.push(U256::zero());
@@ -514,6 +520,14 @@ impl<Cost: CostType> Interpreter<Cost> {
 				Self::copy_data_to_memory(&mut self.mem, stack, params.data.as_ref().map_or_else(|| &[] as &[u8], |d| &*d as &[u8]));
 			},
 			instructions::RETURNDATACOPY => {
+				{
+					let source_offset = stack.peek(1);
+					let size = stack.peek(2);
+					let return_data_len = U256::from(self.return_data.len());
+					if source_offset <= &return_data_len && source_offset.overflow_add(*size).0 <= return_data_len {
+						return Err(evm::Error::OutOfBounds);
+					}
+				}
 				Self::copy_data_to_memory(&mut self.mem, stack, &*self.return_data);
 			},
 			instructions::CODECOPY => {

ethcore/src/executive.rs

@@ -562,6 +562,7 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> {
 				| Err(evm::Error::BuiltIn {..})
 				| Err(evm::Error::OutOfStack {..})
 				| Err(evm::Error::MutableCallInStaticContext)
+				| Err(evm::Error::OutOfBounds)
 				| Ok(FinalizationResult { apply_state: false, .. }) => {
 					self.state.revert_to_checkpoint();
 			},

ethcore/src/types/trace_types/error.rs

@@ -42,6 +42,8 @@ pub enum Error {
 	Internal,
 	/// When execution tries to modify the state in static context
 	MutableCallInStaticContext,
+	/// Contract tried to access past the return data buffer.
+	OutOfBounds,
 }
 
 impl<'a> From<&'a EvmError> for Error {
@@ -55,6 +57,7 @@ impl<'a> From<&'a EvmError> for Error {
 			EvmError::BuiltIn { .. } => Error::BuiltIn,
 			EvmError::Internal(_) => Error::Internal,
 			EvmError::MutableCallInStaticContext => Error::MutableCallInStaticContext,
+			EvmError::OutOfBounds => Error::OutOfBounds,
 		}
 	}
 }
@@ -77,6 +80,7 @@ impl fmt::Display for Error {
 			BuiltIn => "Built-in failed",
 			Internal => "Internal error",
 			MutableCallInStaticContext => "Mutable Call In Static Context",
+			OutOfBounds => "Out of bounds",
 		};
 		message.fmt(f)
 	}
@@ -94,6 +98,7 @@ impl Encodable for Error {
 			Internal => 5,
 			BuiltIn => 6,
 			MutableCallInStaticContext => 7,
+			OutOfBounds => 8,
 		};
 
 		s.append_internal(&value);
@@ -113,6 +118,7 @@ impl Decodable for Error {
 			5 => Ok(Internal),
 			6 => Ok(BuiltIn),
 			7 => Ok(MutableCallInStaticContext),
+			8 => Ok(OutOfBounds),
 			_ => Err(DecoderError::Custom("Invalid error type")),
 		}
 	}