fix: crash VM when executing swap 0

TritonVM · Oct 17, 2023 · 215f2ed · 215f2ed
1 parent 92d63cd
commit 215f2ed
Show file tree

Hide file tree

Showing 2 changed files with 22 additions and 3 deletions.
diff --git a/triton-vm/src/error.rs b/triton-vm/src/error.rs
@@ -17,6 +17,7 @@ pub enum InstructionError {
     JumpStackIsEmpty,
     AssertionFailed(usize, u32, BFieldElement),
     VectorAssertionFailed(usize, u32, OpStackElement, BFieldElement, BFieldElement),
+    SwapST0,
     InverseOfZero,
     DivisionByZero,
     LogarithmOfZero,
@@ -43,6 +44,7 @@ impl Display for InstructionError {
                 write!(f, "{rhs} == op_stack[{failing_index_rhs}]. ")?;
                 write!(f, "ip: {ip}, clk: {clk}")
             }
+            SwapST0 => write!(f, "Cannot swap stack element 0 with itself"),
             InverseOfZero => write!(f, "0 does not have a multiplicative inverse"),
             DivisionByZero => write!(f, "Division by 0 is impossible"),
             LogarithmOfZero => write!(f, "The logarithm of 0 does not exist"),
@@ -61,7 +63,11 @@ mod tests {
     use proptest::prelude::*;
     use proptest_arbitrary_interop::arb;
 
+    use crate::instruction::AnInstruction::*;
+    use crate::instruction::LabelledInstruction;
+    use crate::op_stack::OpStackElement::ST0;
     use crate::triton_program;
+    use crate::Program;
 
     use super::*;
 
@@ -111,6 +117,16 @@ mod tests {
         program.run([].into(), [].into()).unwrap();
     }
 
+    #[test]
+    #[should_panic(expected = "swap stack element 0")]
+    fn swap_st0() {
+        // The parser rejects this program. Therefore, construct it manually.
+        let swap_0 = LabelledInstruction::Instruction(Swap(ST0));
+        let halt = LabelledInstruction::Instruction(Halt);
+        let program = Program::new(&[swap_0, halt]);
+        program.run([].into(), [].into()).unwrap();
+    }
+
     proptest! {
         #[test]
         fn assert_unequal_vec(

diff --git a/triton-vm/src/vm.rs b/triton-vm/src/vm.rs
@@ -217,7 +217,7 @@ impl<'pgm> VMState<'pgm> {
             Push(field_element) => self.push(field_element),
             Divine => self.divine()?,
             Dup(stack_element) => self.dup(stack_element),
-            Swap(stack_element) => self.swap(stack_element),
+            Swap(stack_element) => self.swap(stack_element)?,
             Nop => self.nop(),
             Skiz => self.skiz()?,
             Call(address) => self.call(address),
@@ -289,10 +289,13 @@ impl<'pgm> VMState<'pgm> {
         None
     }
 
-    fn swap(&mut self, stack_register: OpStackElement) -> Option<CoProcessorCall> {
+    fn swap(&mut self, stack_register: OpStackElement) -> Result<Option<CoProcessorCall>> {
+        if stack_register == ST0 {
+            bail!(SwapST0);
+        }
         self.op_stack.swap_top_with(stack_register);
         self.instruction_pointer += 2;
-        None
+        Ok(None)
     }
 
     fn nop(&mut self) -> Option<CoProcessorCall> {