From 3e78865d644218836768a811dce902cc43b26a6a Mon Sep 17 00:00:00 2001 From: 4l0n50 Date: Wed, 13 Dec 2023 17:33:53 +0100 Subject: [PATCH] Remove aborts for invalid jumps and Rebase --- evm/src/cpu/kernel/asm/core/call.asm | 5 +- .../cpu/kernel/asm/core/jumpdest_analysis.asm | 157 +++++++++-- evm/src/cpu/kernel/asm/util/basic_macros.asm | 13 + evm/src/cpu/kernel/interpreter.rs | 21 +- .../kernel/tests/core/jumpdest_analysis.rs | 16 +- evm/src/generation/mod.rs | 92 ++++++- evm/src/generation/prover_input.rs | 244 +++++++++++++++++- evm/src/generation/state.rs | 25 +- evm/src/util.rs | 5 + evm/src/witness/errors.rs | 2 + evm/src/witness/transition.rs | 7 +- 11 files changed, 541 insertions(+), 46 deletions(-) diff --git a/evm/src/cpu/kernel/asm/core/call.asm b/evm/src/cpu/kernel/asm/core/call.asm index 2e7d1d73..fcb4eb32 100644 --- a/evm/src/cpu/kernel/asm/core/call.asm +++ b/evm/src/cpu/kernel/asm/core/call.asm @@ -367,12 +367,9 @@ call_too_deep: %checkpoint // Checkpoint %increment_call_depth // Perform jumpdest analyis - PUSH %%after - %mload_context_metadata(@CTX_METADATA_CODE_SIZE) GET_CONTEXT // stack: ctx, code_size, retdest - %jump(jumpdest_analysis) -%%after: + %jumpdest_analisys PUSH 0 // jump dest EXIT_KERNEL // (Old context) stack: new_ctx diff --git a/evm/src/cpu/kernel/asm/core/jumpdest_analysis.asm b/evm/src/cpu/kernel/asm/core/jumpdest_analysis.asm index bda6f96e..97224b3e 100644 --- a/evm/src/cpu/kernel/asm/core/jumpdest_analysis.asm +++ b/evm/src/cpu/kernel/asm/core/jumpdest_analysis.asm @@ -1,45 +1,47 @@ -// Populates @SEGMENT_JUMPDEST_BITS for the given context's code. -// Pre stack: ctx, code_len, retdest +// Set @SEGMENT_JUMPDEST_BITS to one between positions [init_pos, final_pos], +// for the given context's code. +// Pre stack: init_pos, ctx, final_pos, retdest // Post stack: (empty) -global jumpdest_analysis: - // stack: ctx, code_len, retdest - PUSH 0 // i = 0 - +global verify_path_and_write_table: loop: - // stack: i, ctx, code_len, retdest - // Ideally we would break if i >= code_len, but checking i > code_len is - // cheaper. It doesn't hurt to over-read by 1, since we'll read 0 which is - // a no-op. - DUP3 DUP2 GT // i > code_len - %jumpi(return) + // stack: i, ctx, final_pos, retdest + DUP3 DUP2 EQ // i == final_pos + %jumpi(proof_ok) + DUP3 DUP2 GT // i > final_pos + %jumpi(proof_not_ok) - // stack: i, ctx, code_len, retdest + // stack: i, ctx, final_pos, retdest %stack (i, ctx) -> (ctx, @SEGMENT_CODE, i, i, ctx) MLOAD_GENERAL - // stack: opcode, i, ctx, code_len, retdest + // stack: opcode, i, ctx, final_pos, retdest DUP1 // Slightly more efficient than `%eq_const(0x5b) ISZERO` PUSH 0x5b SUB - // stack: opcode != JUMPDEST, opcode, i, ctx, code_len, retdest + // stack: opcode != JUMPDEST, opcode, i, ctx, final_pos, retdest %jumpi(continue) - // stack: JUMPDEST, i, ctx, code_len, retdest + // stack: JUMPDEST, i, ctx, final_pos, retdest %stack (JUMPDEST, i, ctx) -> (1, ctx, @SEGMENT_JUMPDEST_BITS, i, JUMPDEST, i, ctx) MSTORE_GENERAL continue: - // stack: opcode, i, ctx, code_len, retdest + // stack: opcode, i, ctx, final_pos, retdest %add_const(code_bytes_to_skip) %mload_kernel_code - // stack: bytes_to_skip, i, ctx, code_len, retdest + // stack: bytes_to_skip, i, ctx, final_pos, retdest ADD - // stack: i, ctx, code_len, retdest + // stack: i, ctx, final_pos, retdest %jump(loop) -return: - // stack: i, ctx, code_len, retdest +proof_ok: + // stack: i, ctx, final_pos, retdest + // We already know final pos is a jumpdest + %stack (i, ctx, final_pos) -> (1, ctx, @SEGMENT_JUMPDEST_BITS, i) + MSTORE_GENERAL + JUMP +proof_not_ok: %pop3 JUMP @@ -89,3 +91,116 @@ code_bytes_to_skip: %rep 128 BYTES 1 // 0x80-0xff %endrep + + +// A proof attesting that jumpdest is a valid jump destinations is +// either 0 or an index 0 < i <= jumpdest - 32. +// A proof is valid if: +// - i == 0 and we can go from the first opcode to jumpdest and code[jumpdest] = 0x5b +// - i > 0 and: +// - for j in {i+0,..., i+31} code[j] != PUSHk for all k >= 32 - j - i, +// - we can go from opcode i+32 to jumpdest, +// - code[jumpdest] = 0x5b. +// stack: proof_prefix_addr, jumpdest, ctx, retdest +// stack: (empty) abort if jumpdest is not a valid destination +global write_table_if_jumpdest: + // stack: proof_prefix_addr, jumpdest, ctx, retdest + %stack + (proof_prefix_addr, jumpdest, ctx) -> + (ctx, @SEGMENT_CODE, jumpdest, jumpdest, ctx, proof_prefix_addr) + MLOAD_GENERAL + // stack: opcode, jumpdest, ctx, proof_prefix_addr, retdest + + %jump_eq_const(0x5b, return) + + //stack: jumpdest, ctx, proof_prefix_addr, retdest + SWAP2 DUP1 + // stack: proof_prefix_addr, proof_prefix_addr, ctx, jumpdest + ISZERO + %jumpi(verify_path_and_write_table) + // stack: proof_prefix_addr, ctx, jumpdest, retdest + // If we are here we need to check that the next 32 bytes are less + // than JUMPXX for XX < 32 - i <=> opcode < 0x7f - i = 127 - i, 0 <= i < 32, + // or larger than 127 + %check_and_step(127) %check_and_step(126) %check_and_step(125) %check_and_step(124) + %check_and_step(123) %check_and_step(122) %check_and_step(121) %check_and_step(120) + %check_and_step(119) %check_and_step(118) %check_and_step(117) %check_and_step(116) + %check_and_step(115) %check_and_step(114) %check_and_step(113) %check_and_step(112) + %check_and_step(111) %check_and_step(110) %check_and_step(109) %check_and_step(108) + %check_and_step(107) %check_and_step(106) %check_and_step(105) %check_and_step(104) + %check_and_step(103) %check_and_step(102) %check_and_step(101) %check_and_step(100) + %check_and_step(99) %check_and_step(98) %check_and_step(97) %check_and_step(96) + + // check the remaining path + %jump(verify_path_and_write_table) +return: + // stack: proof_prefix_addr, jumpdest, ctx, retdest + %pop3 + JUMP + + +// Chek if the opcode pointed by proof_prefix address is +// less than max and increment proof_prefix_addr +%macro check_and_step(max) + %stack + (proof_prefix_addr, ctx, jumpdest) -> + (ctx, @SEGMENT_CODE, proof_prefix_addr, proof_prefix_addr, ctx, jumpdest) + MLOAD_GENERAL + // stack: opcode, ctx, proof_prefix_addr, jumpdest + DUP1 + %gt_const(127) + %jumpi(%%ok) + %jumpi_lt_const($max, return) + // stack: proof_prefix_addr, ctx, jumpdest + PUSH 0 // We need something to pop +%%ok: + POP + %increment +%endmacro + +%macro write_table_if_jumpdest + %stack (proof, addr, ctx) -> (proof, addr, ctx, %%after) + %jump(write_table_if_jumpdest) +%%after: +%endmacro + +// Write the jumpdest table. This is done by +// non-deterministically guessing the sequence of jumpdest +// addresses used during program execution within the current context. +// For each jumpdest address we also non-deterministically guess +// a proof, which is another address in the code such that +// is_jumpdest don't abort, when the proof is at the top of the stack +// an the jumpdest address below. If that's the case we set the +// corresponding bit in @SEGMENT_JUMPDEST_BITS to 1. +// +// stack: ctx, retdest +// stack: (empty) +global jumpdest_analisys: + // If address > 0 then address is interpreted as address' + 1 + // and the next prover input should contain a proof for address'. + PROVER_INPUT(jumpdest_table::next_address) + DUP1 %jumpi(check_proof) + // If proof == 0 there are no more jump destinations to check + POP +// This is just a hook used for avoiding verification of the jumpdest +// table in another contexts. It is useful during proof generation, +// allowing the avoidance of table verification when simulating user code. +global jumpdest_analisys_end: + POP + JUMP +check_proof: + %decrement + DUP2 SWAP1 + // stack: address, ctx, ctx + // We read the proof + PROVER_INPUT(jumpdest_table::next_proof) + // stack: proof, address, ctx, ctx + %write_table_if_jumpdest + + %jump(jumpdest_analisys) + +%macro jumpdest_analisys + %stack (ctx) -> (ctx, %%after) + %jump(jumpdest_analisys) +%%after: +%endmacro diff --git a/evm/src/cpu/kernel/asm/util/basic_macros.asm b/evm/src/cpu/kernel/asm/util/basic_macros.asm index fc2472b3..d62dc27e 100644 --- a/evm/src/cpu/kernel/asm/util/basic_macros.asm +++ b/evm/src/cpu/kernel/asm/util/basic_macros.asm @@ -8,6 +8,19 @@ jumpi %endmacro +%macro jump_eq_const(c, jumpdest) + PUSH $c + SUB + %jumpi($jumpdest) +%endmacro + +%macro jumpi_lt_const(c, jumpdest) + // %assert_zero is cheaper than %assert_nonzero, so we will leverage the + // fact that (x < c) == !(x >= c). + %ge_const($c) + %jumpi($jumpdest) +%endmacro + %macro pop2 %rep 2 POP diff --git a/evm/src/cpu/kernel/interpreter.rs b/evm/src/cpu/kernel/interpreter.rs index c4376721..30f862cd 100644 --- a/evm/src/cpu/kernel/interpreter.rs +++ b/evm/src/cpu/kernel/interpreter.rs @@ -1,7 +1,7 @@ //! An EVM interpreter for testing and debugging purposes. use core::cmp::Ordering; -use std::collections::HashMap; +use std::collections::{BTreeSet, HashMap, HashSet}; use std::ops::Range; use anyhow::bail; @@ -10,6 +10,7 @@ use keccak_hash::keccak; use plonky2::field::goldilocks_field::GoldilocksField; use super::assembler::BYTES_PER_OFFSET; +use super::utils::u256_from_bool; use crate::cpu::kernel::aggregator::KERNEL; use crate::cpu::kernel::constants::context_metadata::ContextMetadata; use crate::cpu::kernel::constants::global_metadata::GlobalMetadata; @@ -413,7 +414,23 @@ impl<'a> Interpreter<'a> { .collect() } - fn incr(&mut self, n: usize) { + pub(crate) fn set_jumpdest_bits(&mut self, context: usize, jumpdest_bits: Vec) { + self.generation_state.memory.contexts[context].segments[Segment::JumpdestBits as usize] + .content = jumpdest_bits.iter().map(|&x| u256_from_bool(x)).collect(); + self.generation_state + .set_proofs_and_jumpdests(HashMap::from([( + context, + BTreeSet::from_iter( + jumpdest_bits + .into_iter() + .enumerate() + .filter(|&(_, x)| x) + .map(|(i, _)| i), + ), + )])); + } + + pub(crate) fn incr(&mut self, n: usize) { self.generation_state.registers.program_counter += n; } diff --git a/evm/src/cpu/kernel/tests/core/jumpdest_analysis.rs b/evm/src/cpu/kernel/tests/core/jumpdest_analysis.rs index 022a18d7..3d97251c 100644 --- a/evm/src/cpu/kernel/tests/core/jumpdest_analysis.rs +++ b/evm/src/cpu/kernel/tests/core/jumpdest_analysis.rs @@ -5,8 +5,8 @@ use crate::cpu::kernel::interpreter::Interpreter; use crate::cpu::kernel::opcodes::{get_opcode, get_push_opcode}; #[test] -fn test_jumpdest_analysis() -> Result<()> { - let jumpdest_analysis = KERNEL.global_labels["jumpdest_analysis"]; +fn test_jumpdest_analisys() -> Result<()> { + let jumpdest_analisys = KERNEL.global_labels["jumpdest_analisys"]; const CONTEXT: usize = 3; // arbitrary let add = get_opcode("ADD"); @@ -25,18 +25,16 @@ fn test_jumpdest_analysis() -> Result<()> { jumpdest, ]; - let expected_jumpdest_bits = vec![false, true, false, false, false, true, false, true]; + let jumpdest_bits = vec![false, true, false, false, false, true, false, true]; // Contract creation transaction. - let initial_stack = vec![0xDEADBEEFu32.into(), code.len().into(), CONTEXT.into()]; - let mut interpreter = Interpreter::new_with_kernel(jumpdest_analysis, initial_stack); + let initial_stack = vec![0xDEADBEEFu32.into(), CONTEXT.into()]; + let mut interpreter = Interpreter::new_with_kernel(jumpdest_analisys, initial_stack); interpreter.set_code(CONTEXT, code); + interpreter.set_jumpdest_bits(CONTEXT, jumpdest_bits); + interpreter.run()?; assert_eq!(interpreter.stack(), vec![]); - assert_eq!( - interpreter.get_jumpdest_bits(CONTEXT), - expected_jumpdest_bits - ); Ok(()) } diff --git a/evm/src/generation/mod.rs b/evm/src/generation/mod.rs index d691d34e..4aa35afb 100644 --- a/evm/src/generation/mod.rs +++ b/evm/src/generation/mod.rs @@ -1,4 +1,4 @@ -use std::collections::HashMap; +use std::collections::{BTreeSet, HashMap, HashSet}; use std::sync::atomic::AtomicBool; use std::sync::Arc; @@ -8,6 +8,7 @@ use ethereum_types::{Address, BigEndianHash, H256, U256}; use itertools::enumerate; use plonky2::field::extension::Extendable; use plonky2::field::polynomial::PolynomialValues; +use plonky2::field::types::Field; use plonky2::hash::hash_types::RichField; use plonky2::timed; use plonky2::util::timing::TimingTree; @@ -21,13 +22,16 @@ use crate::all_stark::{AllStark, NUM_TABLES}; use crate::config::StarkConfig; use crate::cpu::columns::CpuColumnsView; use crate::cpu::kernel::aggregator::KERNEL; +use crate::cpu::kernel::assembler::Kernel; use crate::cpu::kernel::constants::global_metadata::GlobalMetadata; +use crate::cpu::kernel::opcodes::get_opcode; use crate::generation::state::GenerationState; use crate::generation::trie_extractor::{get_receipt_trie, get_state_trie, get_txn_trie}; use crate::memory::segments::Segment; use crate::proof::{BlockHashes, BlockMetadata, ExtraBlockData, PublicValues, TrieRoots}; use crate::prover::check_abort_signal; -use crate::util::{h2u, u256_to_usize}; +use crate::util::{h2u, u256_to_u8, u256_to_usize}; +use crate::witness::errors::{ProgramError, ProverInputError}; use crate::witness::memory::{MemoryAddress, MemoryChannel}; use crate::witness::transition::transition; @@ -38,7 +42,7 @@ pub(crate) mod state; mod trie_extractor; use self::mpt::{load_all_mpts, TrieRootPtrs}; -use crate::witness::util::mem_write_log; +use crate::witness::util::{mem_write_log, stack_peek}; /// Inputs needed for trace generation. #[derive(Clone, Debug, Deserialize, Serialize, Default)] @@ -296,9 +300,7 @@ pub fn generate_traces, const D: usize>( Ok((tables, public_values)) } -fn simulate_cpu, const D: usize>( - state: &mut GenerationState, -) -> anyhow::Result<()> { +fn simulate_cpu(state: &mut GenerationState) -> anyhow::Result<()> { let halt_pc = KERNEL.global_labels["halt"]; loop { @@ -333,3 +335,81 @@ fn simulate_cpu, const D: usize>( transition(state)?; } } + +fn simulate_cpu_between_labels_and_get_user_jumps( + initial_label: &str, + final_label: &str, + state: &mut GenerationState, +) -> Result>>, ProgramError> { + if state.jumpdest_proofs.is_some() { + Ok(None) + } else { + const JUMP_OPCODE: u8 = 0x56; + const JUMPI_OPCODE: u8 = 0x57; + + let halt_pc = KERNEL.global_labels[final_label]; + let mut jumpdest_addresses: HashMap<_, BTreeSet> = HashMap::new(); + + state.registers.program_counter = KERNEL.global_labels[initial_label]; + let initial_clock = state.traces.clock(); + let initial_context = state.registers.context; + + log::debug!("Simulating CPU for jumpdest analysis."); + + loop { + // skip jumdest table validations in simulations + if state.registers.program_counter == KERNEL.global_labels["jumpdest_analisys"] { + state.registers.program_counter = KERNEL.global_labels["jumpdest_analisys_end"] + } + let pc = state.registers.program_counter; + let context = state.registers.context; + let halt = state.registers.is_kernel + && pc == halt_pc + && state.registers.context == initial_context; + let opcode = u256_to_u8(state.memory.get(MemoryAddress { + context, + segment: Segment::Code as usize, + virt: state.registers.program_counter, + }))?; + let cond = if let Ok(cond) = stack_peek(state, 1) { + cond != U256::zero() + } else { + false + }; + if !state.registers.is_kernel + && (opcode == JUMP_OPCODE || (opcode == JUMPI_OPCODE && cond)) + { + // Avoid deeper calls to abort + let jumpdest = u256_to_usize(state.registers.stack_top)?; + state.memory.set( + MemoryAddress { + context, + segment: Segment::JumpdestBits as usize, + virt: jumpdest, + }, + U256::one(), + ); + let jumpdest_opcode = state.memory.get(MemoryAddress { + context, + segment: Segment::Code as usize, + virt: jumpdest, + }); + if let Some(ctx_addresses) = jumpdest_addresses.get_mut(&context) { + ctx_addresses.insert(jumpdest); + } else { + jumpdest_addresses.insert(context, BTreeSet::from([jumpdest])); + } + } + if halt { + log::debug!( + "Simulated CPU halted after {} cycles", + state.traces.clock() - initial_clock + ); + return Ok(Some(jumpdest_addresses)); + } + transition(state).map_err(|_| { + ProgramError::ProverInputError(ProverInputError::InvalidJumpdestSimulation) + })?; + } + } +} diff --git a/evm/src/generation/prover_input.rs b/evm/src/generation/prover_input.rs index b2a8f0ce..ca9208ea 100644 --- a/evm/src/generation/prover_input.rs +++ b/evm/src/generation/prover_input.rs @@ -1,3 +1,5 @@ +use std::cmp::min; +use std::collections::HashMap; use std::mem::transmute; use std::str::FromStr; @@ -5,20 +7,26 @@ use anyhow::{bail, Error}; use ethereum_types::{BigEndianHash, H256, U256, U512}; use itertools::{enumerate, Itertools}; use num_bigint::BigUint; +use plonky2::field::extension::Extendable; use plonky2::field::types::Field; +use plonky2::hash::hash_types::RichField; use serde::{Deserialize, Serialize}; +use crate::cpu::kernel::aggregator::KERNEL; +use crate::cpu::kernel::constants::context_metadata::ContextMetadata; +use crate::cpu::kernel::constants::global_metadata::GlobalMetadata; use crate::extension_tower::{FieldExt, Fp12, BLS381, BN254}; use crate::generation::prover_input::EvmField::{ Bls381Base, Bls381Scalar, Bn254Base, Bn254Scalar, Secp256k1Base, Secp256k1Scalar, }; use crate::generation::prover_input::FieldOp::{Inverse, Sqrt}; +use crate::generation::simulate_cpu_between_labels_and_get_user_jumps; use crate::generation::state::GenerationState; use crate::memory::segments::Segment; use crate::memory::segments::Segment::BnPairing; -use crate::util::{biguint_to_mem_vec, mem_vec_to_biguint, u256_to_usize}; -use crate::witness::errors::ProgramError; +use crate::util::{biguint_to_mem_vec, mem_vec_to_biguint, u256_to_u8, u256_to_usize}; use crate::witness::errors::ProverInputError::*; +use crate::witness::errors::{ProgramError, ProverInputError}; use crate::witness::memory::MemoryAddress; use crate::witness::util::{current_context_peek, stack_peek}; @@ -47,6 +55,7 @@ impl GenerationState { "bignum_modmul" => self.run_bignum_modmul(), "withdrawal" => self.run_withdrawal(), "num_bits" => self.run_num_bits(), + "jumpdest_table" => self.run_jumpdest_table(input_fn), _ => Err(ProgramError::ProverInputError(InvalidFunction)), } } @@ -229,6 +238,237 @@ impl GenerationState { Ok(num_bits.into()) } } + + fn run_jumpdest_table(&mut self, input_fn: &ProverInputFn) -> Result { + match input_fn.0[1].as_str() { + "next_address" => self.run_next_jumpdest_table_address(), + "next_proof" => self.run_next_jumpdest_table_proof(), + _ => Err(ProgramError::ProverInputError(InvalidInput)), + } + } + /// Return the next used jump addres + fn run_next_jumpdest_table_address(&mut self) -> Result { + let context = self.registers.context; + let code_len = u256_to_usize(self.memory.get(MemoryAddress { + context, + segment: Segment::ContextMetadata as usize, + virt: ContextMetadata::CodeSize as usize, + }))?; + + if self.jumpdest_proofs.is_none() { + self.generate_jumpdest_proofs()?; + } + + let Some(jumpdest_proofs) = &mut self.jumpdest_proofs else { + return Err(ProgramError::ProverInputError( + ProverInputError::InvalidJumpdestSimulation, + )); + }; + + if let Some(ctx_jumpdest_proofs) = jumpdest_proofs.get_mut(&self.registers.context) + && let Some(next_jumpdest_address) = ctx_jumpdest_proofs.pop() + { + Ok((next_jumpdest_address + 1).into()) + } else { + self.jumpdest_proofs = None; + Ok(U256::zero()) + } + } + + /// Returns the proof for the last jump address. + fn run_next_jumpdest_table_proof(&mut self) -> Result { + let Some(jumpdest_proofs) = &mut self.jumpdest_proofs else { + return Err(ProgramError::ProverInputError( + ProverInputError::InvalidJumpdestSimulation, + )); + }; + if let Some(ctx_jumpdest_proofs) = jumpdest_proofs.get_mut(&self.registers.context) + && let Some(next_jumpdest_proof) = ctx_jumpdest_proofs.pop() + { + Ok(next_jumpdest_proof.into()) + } else { + Err(ProgramError::ProverInputError( + ProverInputError::InvalidJumpdestSimulation, + )) + } + } +} + +impl GenerationState { + fn generate_jumpdest_proofs(&mut self) -> Result<(), ProgramError> { + let checkpoint = self.checkpoint(); + let memory = self.memory.clone(); + + let code = self.get_current_code()?; + // We need to set the simulated jumpdest bits to one as otherwise + // the simulation will fail. + self.set_jumpdest_bits(&code); + + // Simulate the user's code and (unnecessarily) part of the kernel code, skipping the validate table call + let Some(jumpdest_table) = simulate_cpu_between_labels_and_get_user_jumps( + "jumpdest_analisys_end", + "terminate_common", + self, + )? + else { + return Ok(()); + }; + + // Return to the state before starting the simulation + self.rollback(checkpoint); + self.memory = memory; + + // Find proofs for all context + self.set_proofs_and_jumpdests(jumpdest_table); + + Ok(()) + } + + pub(crate) fn set_proofs_and_jumpdests( + &mut self, + jumpdest_table: HashMap>, + ) { + self.jumpdest_proofs = Some(HashMap::from_iter(jumpdest_table.into_iter().map( + |(ctx, jumpdest_table)| { + let code = self.get_code(ctx).unwrap(); + if let Some(&largest_address) = jumpdest_table.last() { + let proofs = get_proofs_and_jumpdests(&code, largest_address, jumpdest_table); + (ctx, proofs) + } else { + (ctx, vec![]) + } + }, + ))); + } + + fn get_current_code(&self) -> Result, ProgramError> { + self.get_code(self.registers.context) + } + + fn get_code(&self, context: usize) -> Result, ProgramError> { + let code_len = self.get_code_len()?; + let code = (0..code_len) + .map(|i| { + u256_to_u8(self.memory.get(MemoryAddress { + context: self.registers.context, + segment: Segment::Code as usize, + virt: i, + })) + }) + .collect::, _>>()?; + Ok(code) + } + + fn get_code_len(&self) -> Result { + let code_len = u256_to_usize(self.memory.get(MemoryAddress { + context: self.registers.context, + segment: Segment::ContextMetadata as usize, + virt: ContextMetadata::CodeSize as usize, + }))?; + Ok(code_len) + } + + fn set_jumpdest_bits<'a>(&mut self, code: &'a Vec) { + const JUMPDEST_OPCODE: u8 = 0x5b; + for (pos, opcode) in CodeIterator::new(&code) { + if opcode == JUMPDEST_OPCODE { + self.memory.set( + MemoryAddress { + context: self.registers.context, + segment: Segment::JumpdestBits as usize, + virt: pos, + }, + U256::one(), + ); + } + } + } +} + +/// For each address in `jumpdest_table`, each bounded by larges_address, +/// this function searches for a proof. A proof is the closest address +/// for which none of the previous 32 bytes in the code (including opcodes +/// and pushed bytes are PUSHXX and the address is in its range. It returns +/// a vector of even size containing proofs followed by their addresses +fn get_proofs_and_jumpdests<'a>( + code: &'a Vec, + largest_address: usize, + jumpdest_table: std::collections::BTreeSet, +) -> Vec { + const PUSH1_OPCODE: u8 = 0x60; + const PUSH32_OPCODE: u8 = 0x7f; + let (proofs, _) = CodeIterator::until(&code, largest_address + 1).fold( + (vec![], 0), + |(mut proofs, acc), (pos, opcode)| { + let has_prefix = if let Some(prefix_start) = pos.checked_sub(32) { + code[prefix_start..pos] + .iter() + .enumerate() + .fold(true, |acc, (prefix_pos, &byte)| { + acc && (byte > PUSH32_OPCODE + || (prefix_start + prefix_pos) as i32 + + (byte as i32 - PUSH1_OPCODE as i32) + + 1 + < pos as i32) + }) + } else { + false + }; + let acc = if has_prefix { pos - 32 } else { acc }; + if jumpdest_table.contains(&pos) { + // Push the proof + proofs.push(acc); + // Push the address + proofs.push(pos); + } + (proofs, acc) + }, + ); + proofs +} + +struct CodeIterator<'a> { + code: &'a [u8], + pos: usize, + end: usize, +} + +impl<'a> CodeIterator<'a> { + fn new(code: &'a [u8]) -> Self { + CodeIterator { + end: code.len(), + code, + pos: 0, + } + } + fn until(code: &'a [u8], end: usize) -> Self { + CodeIterator { + end: std::cmp::min(code.len(), end), + code, + pos: 0, + } + } +} + +impl<'a> Iterator for CodeIterator<'a> { + type Item = (usize, u8); + + fn next(&mut self) -> Option { + const PUSH1_OPCODE: u8 = 0x60; + const PUSH32_OPCODE: u8 = 0x70; + let CodeIterator { code, pos, end } = self; + if *pos >= *end { + return None; + } + let opcode = code[*pos]; + let old_pos = *pos; + *pos += if (PUSH1_OPCODE..=PUSH32_OPCODE).contains(&opcode) { + (opcode - PUSH1_OPCODE + 2).into() + } else { + 1 + }; + Some((old_pos, opcode)) + } } enum EvmField { diff --git a/evm/src/generation/state.rs b/evm/src/generation/state.rs index 89ff0c5a..cc1df091 100644 --- a/evm/src/generation/state.rs +++ b/evm/src/generation/state.rs @@ -1,4 +1,4 @@ -use std::collections::HashMap; +use std::collections::{BTreeSet, HashMap}; use ethereum_types::{Address, BigEndianHash, H160, H256, U256}; use keccak_hash::keccak; @@ -50,6 +50,8 @@ pub(crate) struct GenerationState { /// Pointers, within the `TrieData` segment, of the three MPTs. pub(crate) trie_root_ptrs: TrieRootPtrs, + + pub(crate) jumpdest_proofs: Option>>, } impl GenerationState { @@ -91,6 +93,7 @@ impl GenerationState { txn_root_ptr: 0, receipt_root_ptr: 0, }, + jumpdest_proofs: None, }; let trie_root_ptrs = state.preinitialize_mpts(&inputs.tries); @@ -167,6 +170,26 @@ impl GenerationState { .map(|i| stack_peek(self, i).unwrap()) .collect() } + + /// Clone everything but the traces + pub(crate) fn soft_clone(&self) -> GenerationState { + Self { + inputs: self.inputs.clone(), + registers: self.registers, + memory: self.memory.clone(), + traces: Traces::default(), + rlp_prover_inputs: self.rlp_prover_inputs.clone(), + state_key_to_address: self.state_key_to_address.clone(), + bignum_modmul_result_limbs: self.bignum_modmul_result_limbs.clone(), + withdrawal_prover_inputs: self.withdrawal_prover_inputs.clone(), + trie_root_ptrs: TrieRootPtrs { + state_root_ptr: 0, + txn_root_ptr: 0, + receipt_root_ptr: 0, + }, + jumpdest_proofs: None, + } + } } /// Withdrawals prover input array is of the form `[addr0, amount0, ..., addrN, amountN, U256::MAX, U256::MAX]`. diff --git a/evm/src/util.rs b/evm/src/util.rs index 3d9564b5..fa19ef09 100644 --- a/evm/src/util.rs +++ b/evm/src/util.rs @@ -70,6 +70,11 @@ pub(crate) fn u256_to_u64(u256: U256) -> Result<(F, F), ProgramError> )) } +/// Safe conversion from U256 to u8, which errors in case of overflow instead of panicking. +pub(crate) fn u256_to_u8(u256: U256) -> Result { + u256.try_into().map_err(|_| ProgramError::IntegerTooLarge) +} + /// Safe alternative to `U256::as_usize()`, which errors in case of overflow instead of panicking. pub(crate) fn u256_to_usize(u256: U256) -> Result { u256.try_into().map_err(|_| ProgramError::IntegerTooLarge) diff --git a/evm/src/witness/errors.rs b/evm/src/witness/errors.rs index 5a0fcbfb..1b266aef 100644 --- a/evm/src/witness/errors.rs +++ b/evm/src/witness/errors.rs @@ -36,4 +36,6 @@ pub enum ProverInputError { InvalidInput, InvalidFunction, NumBitsError, + InvalidJumpDestination, + InvalidJumpdestSimulation, } diff --git a/evm/src/witness/transition.rs b/evm/src/witness/transition.rs index cf2e3bbe..b8f962e7 100644 --- a/evm/src/witness/transition.rs +++ b/evm/src/witness/transition.rs @@ -395,7 +395,12 @@ fn try_perform_instruction( if state.registers.is_kernel { log_kernel_instruction(state, op); } else { - log::debug!("User instruction: {:?}", op); + log::debug!( + "User instruction: {:?}, ctx = {:?}, stack = {:?}", + op, + state.registers.context, + state.stack() + ); } fill_op_flag(op, &mut row);