fix: field zero division in brillig

acvm-repo/brillig_vm/src/arithmetic.rs

@@ -43,7 +43,13 @@ pub(crate) fn evaluate_binary_field_op<F: AcirField>(
         BinaryFieldOp::Add => MemoryValue::new_field(a + b),
         BinaryFieldOp::Sub => MemoryValue::new_field(a - b),
         BinaryFieldOp::Mul => MemoryValue::new_field(a * b),
-        BinaryFieldOp::Div => MemoryValue::new_field(a / b),
+        BinaryFieldOp::Div => {
+            if b.is_zero() {
+                return Err(BrilligArithmeticError::DivisionByZero);
+            } else {
+                MemoryValue::new_field(a / b)
+            }
+        }
         BinaryFieldOp::IntegerDiv => {
             if b.is_zero() {
                 return Err(BrilligArithmeticError::DivisionByZero);

acvm-repo/brillig_vm/src/lib.rs

@@ -390,7 +390,7 @@
                 self.set_program_counter(*location)
             }
             Opcode::Const { destination, value, bit_size } => {
                 // Consts are not checked in runtime to fit in the bit size, since they can safely be checked statically.
                 self.memory.write(*destination, MemoryValue::new_from_field(*value, *bit_size));
                 self.increment_program_counter()
             }
@@ -958,7 +958,7 @@
     }
 
     #[test]
     fn jmpifnot_opcode() {
         let calldata: Vec<FieldElement> = vec![1u128.into(), 2u128.into()];
 
         let opcodes = vec![
@@ -1207,7 +1207,7 @@
     }
 
     #[test]
     fn cmov_opcode() {
         let calldata: Vec<FieldElement> =
             vec![(0u128).into(), (1u128).into(), (2u128).into(), (3u128).into()];
 
@@ -1464,7 +1464,7 @@
     }
 
     #[test]
     fn iconst_opcode() {
         let opcodes = &[
             Opcode::Const {
                 destination: MemoryAddress::direct(0),
@@ -2406,4 +2406,45 @@
 
         assert_eq!(output_value.to_field(), FieldElement::from(1u128));
     }
+
+    #[test]
+    fn field_zero_division_regression() {
+        let calldata: Vec<FieldElement> = vec![];
+
+        let opcodes = &[
+            Opcode::Const {
+                destination: MemoryAddress::direct(0),
+                bit_size: BitSize::Field,
+                value: FieldElement::from(1u64),
+            },
+            Opcode::Const {
+                destination: MemoryAddress::direct(1),
+                bit_size: BitSize::Field,
+                value: FieldElement::from(0u64),
+            },
+            Opcode::BinaryFieldOp {
+                destination: MemoryAddress::direct(2),
+                op: BinaryFieldOp::Div,
+                lhs: MemoryAddress::direct(0),
+                rhs: MemoryAddress::direct(1),
+            },
+        ];
+        let solver = StubbedBlackBoxSolver::default();
+        let mut vm = VM::new(calldata, opcodes, &solver, false);
+
+        let status = vm.process_opcode();
+        assert_eq!(status, VMStatus::InProgress);
+        let status = vm.process_opcode();
+        assert_eq!(status, VMStatus::InProgress);
+        let status = vm.process_opcode();
+        assert_eq!(
+            status,
+            VMStatus::Failure {
+                reason: FailureReason::RuntimeError {
+                    message: "Attempted to divide by zero".into()
+                },
+                call_stack: vec![2]
+            }
+        );
+    }
 }