* Add probabilistic behavior to dispute-ancestor variant

* Add probabilistic behavior to `back-garbage-candidate` variant
* Rename structs in dispute variant

node/malus/src/variants/common.rs

@@ -34,6 +34,8 @@ use polkadot_primitives::v2::{
 
 use futures::channel::oneshot;
 
+use rand::distributions::{Bernoulli, Distribution};
+
 #[derive(clap::ArgEnum, Clone, Copy, Debug, PartialEq)]
 #[clap(rename_all = "kebab-case")]
 #[non_exhaustive]
@@ -109,6 +111,7 @@ impl Into<InvalidCandidate> for FakeCandidateValidationError {
 pub struct ReplaceValidationResult<Spawner> {
 	fake_validation: FakeCandidateValidation,
 	fake_validation_error: FakeCandidateValidationError,
+	percentage: f64,
 	spawner: Spawner,
 }
 
@@ -119,9 +122,10 @@ where
 	pub fn new(
 		fake_validation: FakeCandidateValidation,
 		fake_validation_error: FakeCandidateValidationError,
+		percentage: f64,
 		spawner: Spawner,
 	) -> Self {
-		Self { fake_validation, fake_validation_error, spawner }
+		Self { fake_validation, fake_validation_error, percentage, spawner }
 	}
 
 	/// Creates and sends the validation response for a given candidate. Queries the runtime to obtain the validation data for the
@@ -202,13 +206,14 @@ where
 {
 	type Message = CandidateValidationMessage;
 
-	// Capture all candidate validation requests and depending on configuration fail them.
+	// Capture all (approval and backing) candidate validation requests and depending on configuration fail them.
 	fn intercept_incoming(
 		&self,
 		subsystem_sender: &mut Sender,
 		msg: FromOrchestra<Self::Message>,
 	) -> Option<FromOrchestra<Self::Message>> {
 		match msg {
+			// Behaviour related to the approval subsystem
 			FromOrchestra::Communication {
 				msg:
 					CandidateValidationMessage::ValidateFromExhaustive(
@@ -236,28 +241,70 @@ where
 								),
 							})
 						}
-						create_validation_response(
-							validation_data,
-							candidate_receipt.descriptor,
-							sender,
-						);
-						None
+						// Create the fake response with probability `p` if the `PoV` is malicious.
+						let distribution = Bernoulli::new(self.percentage / 100.0).expect("Invalid probability! Percentage cannot be < 0 or > 100.");
+						let random_bool = distribution.sample(&mut rand::thread_rng());
+						match random_bool {
+							true => {
+								create_validation_response(
+									validation_data,
+									candidate_receipt.descriptor,
+									sender,
+								);
+								None
+							},
+							// 
+							false => {
+								// Behave normally with probability `(1-p)` for a malicious `PoV`.
+								Some(FromOrchestra::Communication {
+									msg: CandidateValidationMessage::ValidateFromExhaustive(
+										validation_data,
+										validation_code,
+										candidate_receipt,
+										pov,
+										timeout,
+										sender,
+									),
+								})
+							}
+						}
 					},
 					FakeCandidateValidation::ApprovalInvalid |
 					FakeCandidateValidation::BackingAndApprovalInvalid => {
-						let validation_result =
-							ValidationResult::Invalid(InvalidCandidate::InvalidOutputs);
+						// Set the validation result to invalid with probability `p`
+						let distribution = Bernoulli::new(self.percentage / 100.0).expect("Invalid probability! Percentage cannot be < 0 or > 100.");
+						let random_bool = distribution.sample(&mut rand::thread_rng());
+						match random_bool {
+							true => {
+								let validation_result =
+									ValidationResult::Invalid(InvalidCandidate::InvalidOutputs);
 
-						gum::debug!(
-							target: MALUS,
-							para_id = ?candidate_receipt.descriptor.para_id,
-							"ValidateFromExhaustive result: {:?}",
-							&validation_result
-						);
-						// We're not even checking the candidate, this makes us appear faster than honest validators.
-						sender.send(Ok(validation_result)).unwrap();
-						None
+								gum::debug!(
+									target: MALUS,
+									para_id = ?candidate_receipt.descriptor.para_id,
+									"ValidateFromExhaustive result: {:?}",
+									&validation_result
+								);
+								// We're not even checking the candidate, this makes us appear faster than honest validators.
+								sender.send(Ok(validation_result)).unwrap();
+								None
+							}, 
+							false => {
+								// Behave normally with probability `(1-p)`
+								Some(FromOrchestra::Communication {
+									msg: CandidateValidationMessage::ValidateFromExhaustive(
+										validation_data,
+										validation_code,
+										candidate_receipt,
+										pov,
+										timeout,
+										sender,
+									),
+								})
+							},
+						}
 					},
+					// `dispute-ancestor --fake-validation` disabled case
 					_ => Some(FromOrchestra::Communication {
 						msg: CandidateValidationMessage::ValidateFromExhaustive(
 							validation_data,
@@ -270,6 +317,7 @@ where
 					}),
 				}
 			},
+			// Behaviour related to the backing subsystem
 			FromOrchestra::Communication {
 				msg:
 					CandidateValidationMessage::ValidateFromChainState(
@@ -293,27 +341,63 @@ where
 								),
 							})
 						}
-						self.send_validation_response(
-							candidate_receipt.descriptor,
-							subsystem_sender.clone(),
-							response_sender,
-						);
-						None
+						// If the `PoV` is malicious, back the candidate with some probability `p` (default 100)
+						let distribution = Bernoulli::new(self.percentage / 100.0).expect("Invalid probability! Percentage cannot be < 0 or > 100.");
+						let random_bool = distribution.sample(&mut rand::thread_rng());
+						match random_bool {
+							true => {
+								self.send_validation_response(
+									candidate_receipt.descriptor,
+									subsystem_sender.clone(),
+									response_sender,
+								);
+								None
+							},
+							// If the `PoV` is malicious, we behave normally with some probability `(1-p)` (default 0) 
+							false => {
+								Some(FromOrchestra::Communication {
+									msg: CandidateValidationMessage::ValidateFromChainState(
+										candidate_receipt,
+										pov,
+										timeout,
+										response_sender,
+									),
+								})
+							}
+						}
 					},
 					FakeCandidateValidation::BackingInvalid |
 					FakeCandidateValidation::BackingAndApprovalInvalid => {
-						let validation_result =
-							ValidationResult::Invalid(self.fake_validation_error.clone().into());
-						gum::debug!(
-							target: MALUS,
-							para_id = ?candidate_receipt.descriptor.para_id,
-							"ValidateFromChainState result: {:?}",
-							&validation_result
-						);
+						// We back a garbage candidate with some probability `p` (default 100)
+						let distribution = Bernoulli::new(self.percentage / 100.0).expect("Invalid probability! Percentage cannot be < 0 or > 100.");
+						let random_bool = distribution.sample(&mut rand::thread_rng());
+						match random_bool {
+							true => {
+								let validation_result =
+									ValidationResult::Invalid(self.fake_validation_error.clone().into());
+								gum::debug!(
+									target: MALUS,
+									para_id = ?candidate_receipt.descriptor.para_id,
+									"ValidateFromChainState result: {:?}",
+									&validation_result
+								);
 
-						// We're not even checking the candidate, this makes us appear faster than honest validators.
-						response_sender.send(Ok(validation_result)).unwrap();
-						None
+								// We're not even checking the candidate, this makes us appear faster than honest validators.
+								response_sender.send(Ok(validation_result)).unwrap();
+								None
+							},
+							// With some probability `(1-p)` (default 0) we behave normally
+							false => {
+								Some(FromOrchestra::Communication {
+									msg: CandidateValidationMessage::ValidateFromChainState(
+										candidate_receipt,
+										pov,
+										timeout,
+										response_sender,
+									),
+								})
+							},
+						}
 					},
 					_ => Some(FromOrchestra::Communication {
 						msg: CandidateValidationMessage::ValidateFromChainState(

node/malus/src/variants/dispute_valid_candidates.rs

@@ -64,18 +64,18 @@ pub struct DisputeAncestorOptions {
 	pub cmd: RunCmd,
 }
 
-pub(crate) struct DisputeValidCandidates {
+pub(crate) struct DisputeValidCandidateWrapper {
 	/// Fake validation config (applies to disputes as well).
 	opts: DisputeAncestorOptions,
 }
 
-impl DisputeValidCandidates {
+impl DisputeValidCandidateWrapper {
 	pub fn new(opts: DisputeAncestorOptions) -> Self {
 		Self { opts }
 	}
 }
 
-impl OverseerGen for DisputeValidCandidates {
+impl OverseerGen for DisputeValidCandidateWrapper {
 	fn generate<'a, Spawner, RuntimeClient>(
 		&self,
 		connector: OverseerConnector,
@@ -90,6 +90,7 @@ impl OverseerGen for DisputeValidCandidates {
 		let validation_filter = ReplaceValidationResult::new(
 			self.opts.fake_validation,
 			self.opts.fake_validation_error,
+			f64::from(self.opts.percentage),
 			SpawnGlue(spawner.clone()),
 		);