sim-rs: simulate a late EB attack

Author: SupernaviX

data/simulation/config.d.ts

@@ -241,6 +241,13 @@ export interface Config {
   "cert-validation-cpu-time-ms-per-node": number;
   "cert-size-bytes-constant": bigint;
   "cert-size-bytes-per-node": bigint;
+
+  // Attacks
+  /**
+   * Configuration for a "late EB" attack,
+   * where nodes deliberately withhold EBs until near the end of the voting phase.
+   */
+  "late-eb-attack"?: LateEBAttackConfig | null;
 }
 
 export type CleanupPolicies = "all" | CleanupPolicy[];
@@ -313,3 +320,14 @@ export enum MempoolSamplingStrategy {
   /** Include transactions in random order. */
   Random = "random",
 }
+
+/**
+ * Configuration for a "late EB" attack,
+ * where nodes deliberately withhold EBs until near the end of the voting phase.
+ */
+export interface LateEBAttackConfig {
+  /** The set of stake pools which are participating in the attack. */
+  "attacker-nodes": string[],
+  /** How long the attackers will wait before diffusing their EBs */
+  "propagation-delay-ms": number,
+}

data/simulation/config.schema.json

@@ -72,6 +72,23 @@
       },
       "type": "object"
     },
+    "LateEBAttackConfig": {
+      "description": "Configuration for a \"late EB\" attack,\nwhere nodes deliberately withhold EBs until near the end of the voting phase.",
+      "properties": {
+        "attacker-nodes": {
+          "description": "The set of stake pools which are participating in the attack.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "propagation-delay-ms": {
+          "description": "How long the attackers will wait before diffusing their EBs",
+          "type": "number"
+        }
+      },
+      "type": "object"
+    },
     "LeiosVariant": {
       "enum": [
         "short",
@@ -290,6 +307,10 @@
       "description": "The total number of shards available for IBs.\nMust be divisible by ib_shard_group_count.\n\nOnly supported by Rust simulation.",
       "type": "number"
     },
+    "late-eb-attack": {
+      "$ref": "#/definitions/LateEBAttackConfig",
+      "description": "Configuration for a \"late EB\" attack,\nwhere nodes deliberately withhold EBs until near the end of the voting phase."
+    },
     "leios-header-diffusion-time-ms": {
       "description": "The expected time it takes a header to fully diffuse across the network.\nThis is Δhdr from the Leios paper.",
       "type": "number"

sim-rs/parameters/late-eb-attack.yaml

@@ -0,0 +1,5 @@
+late-eb-attack:
+  attacker-nodes:
+    - node-95
+    - node-94
+  propagation-delay-ms: 4500.0

sim-rs/sim-core/src/clock.rs

@@ -52,7 +52,7 @@ pub struct Clock {
     timestamp_resolution: Duration,
     time: Arc<AtomicTimestamp>,
     waiters: Arc<AtomicUsize>,
-    tasks: Arc<AtomicUsize>,
+    tasks: TaskInitiator,
     tx: mpsc::UnboundedSender<ClockEvent>,
 }
 
@@ -61,7 +61,7 @@ impl Clock {
         timestamp_resolution: Duration,
         time: Arc<AtomicTimestamp>,
         waiters: Arc<AtomicUsize>,
-        tasks: Arc<AtomicUsize>,
+        tasks: TaskInitiator,
         tx: mpsc::UnboundedSender<ClockEvent>,
     ) -> Self {
         Self {
@@ -95,7 +95,7 @@ pub struct ClockBarrier {
     id: usize,
     timestamp_resolution: Duration,
     time: Arc<AtomicTimestamp>,
-    tasks: Arc<AtomicUsize>,
+    tasks: TaskInitiator,
     tx: mpsc::UnboundedSender<ClockEvent>,
 }
 
@@ -105,13 +105,17 @@ impl ClockBarrier {
     }
 
     pub fn start_task(&self) {
-        self.tasks.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
+        self.tasks.start_task();
     }
 
     pub fn finish_task(&self) {
         let _ = self.tx.send(ClockEvent::FinishTask);
     }
 
+    pub fn task_initiator(&self) -> TaskInitiator {
+        self.tasks.clone()
+    }
+
     pub fn wait_until(&mut self, timestamp: Timestamp) -> Waiter {
         self.wait(Some(timestamp.with_resolution(self.timestamp_resolution)))
     }
@@ -141,6 +145,20 @@ impl ClockBarrier {
     }
 }
 
+#[derive(Clone)]
+pub struct TaskInitiator {
+    tasks: Arc<AtomicUsize>,
+}
+
+impl TaskInitiator {
+    pub fn new(tasks: Arc<AtomicUsize>) -> Self {
+        Self { tasks }
+    }
+    pub fn start_task(&self) {
+        self.tasks.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
+    }
+}
+
 pub struct Waiter<'a> {
     id: usize,
     tx: &'a mpsc::UnboundedSender<ClockEvent>,

sim-rs/sim-core/src/clock/coordinator.rs

@@ -9,6 +9,8 @@ use std::{
 
 use tokio::sync::{mpsc, oneshot};
 
+use crate::clock::TaskInitiator;
+
 use super::{Clock, Timestamp, timestamp::AtomicTimestamp};
 
 pub struct ClockCoordinator {
@@ -41,7 +43,7 @@ impl ClockCoordinator {
             self.timestamp_resolution,
             self.time.clone(),
             self.waiter_count.clone(),
-            self.tasks.clone(),
+            TaskInitiator::new(self.tasks.clone()),
             self.tx.clone(),
         )
     }
@@ -61,7 +63,7 @@ impl ClockCoordinator {
                     if waiters[actor].replace(Waiter { until, done }).is_some() {
                         panic!("An actor has somehow managed to wait twice");
                     }
-                    running -= 1;
+                    running = running.checked_sub(1).unwrap();
                     if let Some(timestamp) = until {
                         queue.entry(timestamp).or_default().push(actor);
                     }
@@ -89,7 +91,8 @@ impl ClockCoordinator {
                     }
                 }
                 ClockEvent::FinishTask => {
-                    self.tasks.fetch_sub(1, Ordering::AcqRel);
+                    let prev_tasks = self.tasks.fetch_sub(1, Ordering::AcqRel);
+                    assert!(prev_tasks != 0, "Finished a task that was never started");
                     assert!(
                         running != 0,
                         "All tasks were completed while there were no actors to complete them"

sim-rs/sim-core/src/config.rs

@@ -142,6 +142,9 @@ pub struct RawParameters {
     pub cert_validation_cpu_time_ms_per_node: f64,
     pub cert_size_bytes_constant: u64,
     pub cert_size_bytes_per_node: u64,
+
+    // attacks,
+    pub late_eb_attack: Option<RawLateEBAttackConfig>,
 }
 
 #[derive(Debug, Copy, Clone, Deserialize, PartialEq, Eq)]
@@ -177,6 +180,13 @@ pub enum MempoolSamplingStrategy {
     Random,
 }
 
+#[derive(Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct RawLateEBAttackConfig {
+    pub attacker_nodes: Vec<String>,
+    pub propagation_delay_ms: f64,
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct RawTopology {
@@ -512,6 +522,48 @@ impl MockTransactionConfig {
     }
 }
 
+#[derive(Debug, Clone)]
+pub(crate) struct AttackConfig {
+    pub(crate) late_eb: Option<LateEBAttackConfig>,
+}
+impl AttackConfig {
+    fn build(params: &RawParameters, topology: &Topology) -> Self {
+        Self {
+            late_eb: params
+                .late_eb_attack
+                .as_ref()
+                .map(|raw| LateEBAttackConfig::build(raw, topology)),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct LateEBAttackConfig {
+    pub(crate) attackers: HashSet<NodeId>,
+    pub(crate) propagation_delay: Duration,
+}
+
+impl LateEBAttackConfig {
+    fn build(raw: &RawLateEBAttackConfig, topology: &Topology) -> Self {
+        let attacker_names = raw.attacker_nodes.iter().collect::<HashSet<_>>();
+        let attackers = topology
+            .nodes
+            .iter()
+            .filter_map(|node| {
+                if attacker_names.contains(&node.name) {
+                    Some(node.id)
+                } else {
+                    None
+                }
+            })
+            .collect();
+        Self {
+            attackers,
+            propagation_delay: duration_ms(raw.propagation_delay_ms),
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct SimConfiguration {
     pub seed: u64,
@@ -554,6 +606,7 @@ pub struct SimConfiguration {
     pub(crate) cpu_times: CpuTimeConfig,
     pub(crate) sizes: BlockSizeConfig,
     pub(crate) transactions: TransactionConfig,
+    pub(crate) attacks: AttackConfig,
 }
 
 impl SimConfiguration {
@@ -577,6 +630,7 @@ impl SimConfiguration {
             );
         }
         let total_stake = topology.nodes.iter().map(|n| n.stake).sum();
+        let attacks = AttackConfig::build(&params, &topology);
         Ok(Self {
             seed: 0,
             timestamp_resolution: duration_ms(params.timestamp_resolution_ms),
@@ -618,6 +672,7 @@ impl SimConfiguration {
             cpu_times: CpuTimeConfig::new(&params),
             sizes: BlockSizeConfig::new(&params),
             transactions: TransactionConfig::new(&params),
+            attacks,
         })
     }
 }