Use features to disable crypto

dapplion · dapplion · commit ff83f43da63b · 2026-01-14T20:48:14.000-03:00
diff --git a/Makefile b/Makefile
@@ -233,8 +233,12 @@ test-op-pool-%:
 test-network: $(patsubst %,test-network-%,$(TEST_NETWORK_FORKS))
 
 test-network-%:
+	env FORK_NAME=$* cargo nextest run --no-fail-fast --release \
+		--features "fork_from_env,fake_crypto,$(TEST_FEATURES)" \
+		-p network
 	env FORK_NAME=$* cargo nextest run --no-fail-fast --release \
 		--features "fork_from_env,$(TEST_FEATURES)" \
+		-E 'test(name ~ "crypto_on")' \
 		-p network
 
 # Run the tests in the `slasher` crate for all supported database backends.
diff --git a/beacon_node/beacon_chain/src/block_verification.rs b/beacon_node/beacon_chain/src/block_verification.rs
@@ -671,16 +671,13 @@ pub fn signature_verify_chain_segment<T: BeaconChainTypes>(
     let pubkey_cache = get_validator_pubkey_cache(chain)?;
     let mut signature_verifier = get_signature_verifier(&state, &pubkey_cache, &chain.spec);
     for svb in &mut signature_verified_blocks {
-        signature_verifier
-            .include_all_signatures(svb.block.as_block(), &mut svb.consensus_context)?;
+        signature_verifier.include_all_signatures(svb.block.as_block(), &mut svb.consensus_context)?;
     }
 
     if signature_verifier.verify().is_err() {
         return Err(BlockError::InvalidSignature(InvalidSignature::Unknown));
     }
 
-    drop(pubkey_cache);
-
     if let Some(signature_verified_block) = signature_verified_blocks.first_mut() {
         signature_verified_block.parent = Some(parent);
     }
@@ -977,19 +974,17 @@ impl<T: BeaconChainTypes> GossipVerifiedBlock<T> {
         let expected_proposer = proposer.index;
         let fork = proposer.fork;
 
-        let signature_is_valid = {
-            let pubkey_cache = get_validator_pubkey_cache(chain)?;
-            let pubkey = pubkey_cache
-                .get(block.message().proposer_index() as usize)
-                .ok_or_else(|| BlockError::UnknownValidator(block.message().proposer_index()))?;
-            block.verify_signature(
-                Some(block_root),
-                pubkey,
-                &fork,
-                chain.genesis_validators_root,
-                &chain.spec,
-            )
-        };
+        let pubkey_cache = get_validator_pubkey_cache(chain)?;
+        let pubkey = pubkey_cache
+            .get(block.message().proposer_index() as usize)
+            .ok_or_else(|| BlockError::UnknownValidator(block.message().proposer_index()))?;
+        let signature_is_valid = block.verify_signature(
+            Some(block_root),
+            pubkey,
+            &fork,
+            chain.genesis_validators_root,
+            &chain.spec,
+        );
 
         if !signature_is_valid {
             return Err(BlockError::InvalidSignature(
@@ -1121,14 +1116,14 @@ impl<T: BeaconChainTypes> SignatureVerifiedBlock<T> {
 
         let pubkey_cache = get_validator_pubkey_cache(chain)?;
 
-        let mut signature_verifier = get_signature_verifier(&state, &pubkey_cache, &chain.spec);
-
         let mut consensus_context =
             ConsensusContext::new(block.slot()).set_current_block_root(block_root);
 
+        let mut signature_verifier = get_signature_verifier(&state, &pubkey_cache, &chain.spec);
         signature_verifier.include_all_signatures(block.as_block(), &mut consensus_context)?;
+        let signatures_valid = signature_verifier.verify().is_ok();
 
-        if signature_verifier.verify().is_ok() {
+        if signatures_valid {
             Ok(Self {
                 consensus_context,
                 block,
diff --git a/beacon_node/beacon_chain/src/builder.rs b/beacon_node/beacon_chain/src/builder.rs
@@ -1051,7 +1051,6 @@ where
                     self.kzg.clone(),
                     store,
                     Arc::new(custody_context),
-                    &self.chain_config.test_config,
                     self.spec,
                 )
                 .map_err(|e| format!("Error initializing DataAvailabilityChecker: {:?}", e))?,
diff --git a/beacon_node/beacon_chain/src/chain_config.rs b/beacon_node/beacon_chain/src/chain_config.rs
@@ -121,14 +121,6 @@ pub struct ChainConfig {
     pub disable_get_blobs: bool,
     /// The node's custody type, determining how many data columns to custody and sample.
     pub node_custody_type: NodeCustodyType,
-    /// TESTING ONLY: Disable certain functionality to speed up tests
-    pub test_config: TestConfig,
-}
-
-#[derive(Debug, Default, PartialEq, Eq, Clone, Deserialize, Serialize)]
-pub struct TestConfig {
-    /// FOR TESTING ONLY: Disable crypto verification to speed up tests
-    pub disable_crypto: bool,
 }
 
 impl Default for ChainConfig {
@@ -170,9 +162,6 @@ impl Default for ChainConfig {
             invalid_block_roots: HashSet::new(),
             disable_get_blobs: false,
             node_custody_type: NodeCustodyType::Fullnode,
-            test_config: TestConfig {
-                disable_crypto: false,
-            },
         }
     }
 }
diff --git a/beacon_node/beacon_chain/src/data_availability_checker.rs b/beacon_node/beacon_chain/src/data_availability_checker.rs
@@ -29,7 +29,6 @@ mod error;
 mod overflow_lru_cache;
 mod state_lru_cache;
 
-use crate::chain_config::TestConfig;
 use crate::data_availability_checker::error::Error;
 use crate::data_column_verification::{
     CustodyDataColumn, GossipVerifiedDataColumn, KzgVerifiedCustodyDataColumn,
@@ -87,7 +86,6 @@ pub struct DataAvailabilityChecker<T: BeaconChainTypes> {
     kzg: Arc<Kzg>,
     custody_context: Arc<CustodyContext<T::EthSpec>>,
     spec: Arc<ChainSpec>,
-    disable_crypto: bool,
 }
 
 pub type AvailabilityAndReconstructedColumns<E> = (Availability<E>, DataColumnSidecarList<E>);
@@ -126,7 +124,6 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
         kzg: Arc<Kzg>,
         store: BeaconStore<T>,
         custody_context: Arc<CustodyContext<T::EthSpec>>,
-        test_config: &TestConfig,
         spec: Arc<ChainSpec>,
     ) -> Result<Self, AvailabilityCheckError> {
         let inner = DataAvailabilityCheckerInner::new(
@@ -142,7 +139,6 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
             kzg,
             custody_context,
             spec,
-            disable_crypto: test_config.disable_crypto,
         })
     }
 
@@ -382,10 +378,8 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
         let (block_root, block, blobs, data_columns) = block.deconstruct();
         if self.blobs_required_for_block(&block) {
             return if let Some(blob_list) = blobs {
-                if !self.disable_crypto {
-                    verify_kzg_for_blob_list(blob_list.iter(), &self.kzg)
-                        .map_err(AvailabilityCheckError::InvalidBlobs)?;
-                }
+                verify_kzg_for_blob_list(blob_list.iter(), &self.kzg)
+                    .map_err(AvailabilityCheckError::InvalidBlobs)?;
                 Ok(MaybeAvailableBlock::Available(AvailableBlock {
                     block_root,
                     block,
@@ -399,15 +393,13 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
         }
         if self.data_columns_required_for_block(&block) {
             return if let Some(data_column_list) = data_columns.as_ref() {
-                if !self.disable_crypto {
-                    verify_kzg_for_data_column_list(
-                        data_column_list
-                            .iter()
-                            .map(|custody_column| custody_column.as_data_column()),
-                        &self.kzg,
-                    )
-                    .map_err(AvailabilityCheckError::InvalidColumn)?;
-                }
+                verify_kzg_for_data_column_list(
+                    data_column_list
+                        .iter()
+                        .map(|custody_column| custody_column.as_data_column()),
+                    &self.kzg,
+                )
+                .map_err(AvailabilityCheckError::InvalidColumn)?;
                 Ok(MaybeAvailableBlock::Available(AvailableBlock {
                     block_root,
                     block,
@@ -1203,7 +1195,6 @@ mod test {
             kzg,
             store,
             custody_context,
-            &TestConfig::default(),
             spec,
         )
         .expect("should initialise data availability checker")
diff --git a/beacon_node/beacon_chain/src/test_utils.rs b/beacon_node/beacon_chain/src/test_utils.rs
@@ -1030,16 +1030,12 @@ where
             panic!("Should always be a full payload response");
         };
 
-        let signed_block = Arc::new(if self.chain.config.test_config.disable_crypto {
-            SignedBeaconBlock::from_block(block_response.block, Signature::empty())
-        } else {
-            block_response.block.sign(
-                &self.validator_keypairs[proposer_index].sk,
-                &block_response.state.fork(),
-                block_response.state.genesis_validators_root(),
-                &self.spec,
-            )
-        });
+        let signed_block = Arc::new(block_response.block.sign(
+            &self.validator_keypairs[proposer_index].sk,
+            &block_response.state.fork(),
+            block_response.state.genesis_validators_root(),
+            &self.spec,
+        ));
 
         let block_contents: SignedBlockContentsTuple<E> =
             if signed_block.fork_name_unchecked().deneb_enabled() {
@@ -1418,12 +1414,9 @@ where
 
                             let mut agg_sig = AggregateSignature::infinity();
 
-                            // If disable_crypto is true keep the attestation signature as infinity
-                            if !self.chain.config.test_config.disable_crypto {
-                                agg_sig.add_assign(
-                                    &self.validator_keypairs[*validator_index].sk.sign(message),
-                                );
-                            }
+                            agg_sig.add_assign(
+                                &self.validator_keypairs[*validator_index].sk.sign(message),
+                            );
 
                             agg_sig
                         };
@@ -1520,14 +1513,9 @@ where
                             let message = attestation.data().signing_root(domain);
 
                             let mut agg_sig = AggregateSignature::infinity();
-
-                            // If disable_crypto is true keep the attestation signature as infinity
-                            if !self.chain.config.test_config.disable_crypto {
-                                agg_sig.add_assign(
-                                    &self.validator_keypairs[*validator_index].sk.sign(message),
-                                );
-                            }
-
+                            agg_sig.add_assign(
+                                &self.validator_keypairs[*validator_index].sk.sign(message),
+                            );
                             agg_sig
                         };
 
diff --git a/beacon_node/network/Cargo.toml b/beacon_node/network/Cargo.toml
@@ -8,6 +8,7 @@ edition = { workspace = true }
 # NOTE: This can be run via cargo build --bin lighthouse --features network/disable-backfill
 disable-backfill = []
 fork_from_env = ["beacon_chain/fork_from_env"]
+fake_crypto = ["bls/fake_crypto", "kzg/fake_crypto"]
 portable = ["beacon_chain/portable"]
 test_logger = []
 
diff --git a/beacon_node/network/src/sync/tests/lookups.rs b/beacon_node/network/src/sync/tests/lookups.rs
@@ -7,10 +7,9 @@ use crate::sync::{
     manager::{BlockProcessType, BlockProcessingResult, SyncManager},
 };
 use beacon_chain::blob_verification::KzgVerifiedBlob;
-use beacon_chain::chain_config::TestConfig;
 use beacon_chain::custody_context::NodeCustodyType;
 use beacon_chain::{
-    AvailabilityProcessingStatus, BlockError, ChainConfig, NotifyExecutionLayer,
+    AvailabilityProcessingStatus, BlockError, NotifyExecutionLayer,
     block_verification_types::AsBlock,
     data_availability_checker::Availability,
     test_utils::{
@@ -170,12 +169,6 @@ impl TestRig {
             .mock_execution_layer()
             .testing_slot_clock(clock.clone())
             .node_custody_type(test_rig_config.fulu_test_type.we_node_custody_type())
-            .chain_config(ChainConfig {
-                test_config: TestConfig {
-                    disable_crypto: true,
-                },
-                ..Default::default()
-            })
             .build();
 
         let chain = harness.chain.clone();
@@ -774,12 +767,7 @@ impl TestRig {
             .fresh_ephemeral_store()
             .mock_execution_layer()
             .testing_slot_clock(self.harness.chain.slot_clock.clone())
-            .chain_config(ChainConfig {
-                test_config: TestConfig {
-                    disable_crypto: true,
-                },
-                ..Default::default()
-            }) // Make the external harness a supernode so all columns are available
+            // Make the external harness a supernode so all columns are available
             .node_custody_type(NodeCustodyType::Supernode)
             .build();
         // Ensure all blocks have data. Otherwise, the triggers for unknown blob parent and unknown
diff --git a/crypto/kzg/Cargo.toml b/crypto/kzg/Cargo.toml
@@ -5,6 +5,10 @@ authors = ["Pawan Dhananjay <pawandhananjay@gmail.com>"]
 edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[features]
+default = []
+fake_crypto = []
+
 [dependencies]
 arbitrary = { workspace = true }
 c-kzg = { workspace = true }
diff --git a/crypto/kzg/src/lib.rs b/crypto/kzg/src/lib.rs
@@ -134,6 +134,10 @@ impl Kzg {
         kzg_commitment: KzgCommitment,
         kzg_proof: KzgProof,
     ) -> Result<(), Error> {
+        #[cfg(feature = "fake_crypto")]
+        {
+            return Ok(());
+        }
         if !self.trusted_setup.verify_blob_kzg_proof(
             blob,
             &kzg_commitment.into(),
@@ -155,6 +159,10 @@ impl Kzg {
         kzg_commitments: &[KzgCommitment],
         kzg_proofs: &[KzgProof],
     ) -> Result<(), Error> {
+        #[cfg(feature = "fake_crypto")]
+        {
+            return Ok(());
+        }
         let commitments_bytes = kzg_commitments
             .iter()
             .map(|comm| Bytes48::from(*comm))
@@ -204,6 +212,10 @@ impl Kzg {
         y: &Bytes32,
         kzg_proof: KzgProof,
     ) -> Result<bool, Error> {
+        #[cfg(feature = "fake_crypto")]
+        {
+            return Ok(true);
+        }
         self.trusted_setup
             .verify_kzg_proof(&kzg_commitment.into(), z, y, &kzg_proof.into())
             .map_err(Into::into)
@@ -240,6 +252,10 @@ impl Kzg {
         indices: Vec<CellIndex>,
         kzg_commitments: &[Bytes48],
     ) -> Result<(), (Option<u64>, Error)> {
+        #[cfg(feature = "fake_crypto")]
+        {
+            return Ok(());
+        }
         let mut column_groups: HashMap<u64, Vec<(CellRef, Bytes48, Bytes48)>> = HashMap::new();
 
         let expected_len = cells.len();

Original file line number	Diff line number	Diff line change
`@@ -1051,7 +1051,6 @@ where`
`1051`	`1051`	`self.kzg.clone(),`
`1052`	`1052`	`store,`
`1053`	`1053`	`Arc::new(custody_context),`
`1054`		`- &self.chain_config.test_config,`
`1055`	`1054`	`self.spec,`
`1056`	`1055`	`)`
`1057`	`1056`	`.map_err(\|e\| format!("Error initializing DataAvailabilityChecker: {:?}", e))?,`
Original file line number	Diff line number	Diff line change
`@@ -121,14 +121,6 @@ pub struct ChainConfig {`
`121`	`121`	`pub disable_get_blobs: bool,`
`122`	`122`	`/// The node's custody type, determining how many data columns to custody and sample.`
`123`	`123`	`pub node_custody_type: NodeCustodyType,`
`124`		`- /// TESTING ONLY: Disable certain functionality to speed up tests`
`125`		`- pub test_config: TestConfig,`
`126`		`-}`
`127`		`-`
`128`		`-#[derive(Debug, Default, PartialEq, Eq, Clone, Deserialize, Serialize)]`
`129`		`-pub struct TestConfig {`
`130`		`- /// FOR TESTING ONLY: Disable crypto verification to speed up tests`
`131`		`- pub disable_crypto: bool,`
`132`	`124`	`}`
`133`	`125`
`134`	`126`	`impl Default for ChainConfig {`
`@@ -170,9 +162,6 @@ impl Default for ChainConfig {`
`170`	`162`	`invalid_block_roots: HashSet::new(),`
`171`	`163`	`disable_get_blobs: false,`
`172`	`164`	`node_custody_type: NodeCustodyType::Fullnode,`
`173`		`- test_config: TestConfig {`
`174`		`- disable_crypto: false,`
`175`		`- },`
`176`	`165`	`}`
`177`	`166`	`}`
`178`	`167`	`}`