feat(crypto): CRP-2391 CRP-2392 accept also unmasked random origin of…

… `kappa` in `PreSignatureQuadruple`

rs/consensus/src/ecdsa/payload_builder.rs

@@ -2802,6 +2802,7 @@ mod tests {
                 Randomness::from([0; 32]),
                 &derivation_path,
                 AlgorithmId::ThresholdEcdsaSecp256k1,
+                false,
                 &mut rng,
             );
             let test_inputs = TestSigInputs::from(&sig_inputs);

rs/consensus/src/ecdsa/signer.rs

@@ -918,6 +918,7 @@ mod tests {
                     Randomness::from([0; 32]),
                     &derivation_path,
                     AlgorithmId::ThresholdEcdsaSecp256k1,
+                    false,
                     &mut rng,
                 );
                 let crypto = env
@@ -1270,6 +1271,7 @@ mod tests {
                     Randomness::from([0; 32]),
                     &derivation_path,
                     AlgorithmId::ThresholdEcdsaSecp256k1,
+                    false,
                     &mut rng,
                 );
 

rs/crypto/benches/idkg.rs

@@ -4,10 +4,10 @@ use criterion::{criterion_group, criterion_main, BenchmarkGroup, Criterion, Samp
 use ic_crypto_test_utils_canister_threshold_sigs::node::{Node, Nodes};
 use ic_crypto_test_utils_canister_threshold_sigs::{
     build_params_from_previous, create_transcript_or_panic,
-    generate_and_verify_openings_for_complaint, load_previous_transcripts_for_all_dealers,
-    load_transcript_or_panic, random_transcript_id, run_idkg_without_complaint,
-    setup_masked_random_params, CanisterThresholdSigTestEnvironment, IDkgMode, IDkgModeTestContext,
-    IDkgParticipants, IDkgTestContextForComplaint,
+    generate_and_verify_openings_for_complaint, generate_presig_quadruple,
+    load_previous_transcripts_for_all_dealers, load_transcript_or_panic, random_transcript_id,
+    run_idkg_without_complaint, setup_masked_random_params, CanisterThresholdSigTestEnvironment,
+    IDkgMode, IDkgModeTestContext, IDkgParticipants, IDkgTestContextForComplaint,
 };
 use ic_crypto_test_utils_reproducible_rng::ReproducibleRng;
 use ic_interfaces::crypto::IDkgProtocol;
@@ -367,14 +367,17 @@ fn bench_retain_active_transcripts<M: Measurement, R: RngCore + CryptoRng>(
             bench.iter_batched(
                 || {
                     for _ in 0..num_pre_sig_quadruples {
-                        let pre_sig_quadruple = generate_pre_sig_quadruple(
-                            &env,
-                            test_case.alg(),
-                            &dealers,
-                            &receivers,
-                            key_transcript.clone(),
-                            rng,
-                        );
+                        let pre_sig_quadruple = {
+                            generate_presig_quadruple(
+                                &env,
+                                &dealers,
+                                &receivers,
+                                test_case.alg(),
+                                &key_transcript,
+                                false,
+                                rng,
+                            )
+                        };
                         load_pre_signature_quadruple(receiver, &pre_sig_quadruple);
                     }
                 },
@@ -670,62 +673,6 @@ fn generate_key_transcript<R: RngCore + CryptoRng>(
     run_idkg_without_complaint(&unmasked_key_params, &env.nodes, rng)
 }
 
-fn generate_pre_sig_quadruple<R: RngCore + CryptoRng>(
-    env: &CanisterThresholdSigTestEnvironment,
-    alg: AlgorithmId,
-    dealers: &IDkgDealers,
-    receivers: &IDkgReceivers,
-    key_transcript: IDkgTranscript,
-    rng: &mut R,
-) -> PreSignatureQuadruple {
-    let lambda_params = setup_masked_random_params(env, alg, dealers, receivers, rng);
-    let lambda_transcript = run_idkg_without_complaint(&lambda_params, &env.nodes, rng);
-
-    let kappa_transcript = {
-        let masked_kappa_params = setup_masked_random_params(env, alg, dealers, receivers, rng);
-        let masked_kappa_transcript =
-            run_idkg_without_complaint(&masked_kappa_params, &env.nodes, rng);
-
-        let unmasked_kappa_params = build_params_from_previous(
-            masked_kappa_params,
-            IDkgTranscriptOperation::ReshareOfMasked(masked_kappa_transcript),
-            rng,
-        );
-        run_idkg_without_complaint(&unmasked_kappa_params, &env.nodes, rng)
-    };
-
-    let kappa_times_lambda_transcript = {
-        let kappa_times_lambda_params = build_params_from_previous(
-            lambda_params.clone(),
-            IDkgTranscriptOperation::UnmaskedTimesMasked(
-                kappa_transcript.clone(),
-                lambda_transcript.clone(),
-            ),
-            rng,
-        );
-
-        run_idkg_without_complaint(&kappa_times_lambda_params, &env.nodes, rng)
-    };
-
-    let key_times_lambda_transcript = {
-        let key_times_lambda_params = build_params_from_previous(
-            lambda_params,
-            IDkgTranscriptOperation::UnmaskedTimesMasked(key_transcript, lambda_transcript.clone()),
-            rng,
-        );
-
-        run_idkg_without_complaint(&key_times_lambda_params, &env.nodes, rng)
-    };
-
-    PreSignatureQuadruple::new(
-        kappa_transcript,
-        lambda_transcript,
-        kappa_times_lambda_transcript,
-        key_times_lambda_transcript,
-    )
-    .unwrap_or_else(|error| panic!("failed to create pre-signature quadruple: {:?}", error))
-}
-
 fn other_receiver_or_same_if_only_one<'a, R: RngCore + CryptoRng>(
     receivers: &'a IDkgReceivers,
     exclusion: &Node,

rs/crypto/benches/tecdsa.rs

@@ -72,6 +72,7 @@ fn bench_sign_share<M: Measurement, R: RngCore + CryptoRng>(
                     seed,
                     &derivation_path,
                     test_case.alg(),
+                    false,
                     rng,
                 );
                 signer.load_input_transcripts(&inputs);
@@ -118,6 +119,7 @@ fn bench_verify_sig_share<M: Measurement, R: RngCore + CryptoRng>(
                     seed,
                     &derivation_path,
                     test_case.alg(),
+                    false,
                     rng,
                 );
                 let signer = env
@@ -181,6 +183,7 @@ fn bench_combine_sig_shares<M: Measurement, R: RngCore + CryptoRng>(
                     seed,
                     &derivation_path,
                     test_case.alg(),
+                    false,
                     rng,
                 );
                 let sig_shares = sig_share_from_each_receiver(&env, &inputs);
@@ -234,6 +237,7 @@ fn bench_verify_combined_sig<M: Measurement, R: RngCore + CryptoRng>(
                     seed,
                     &derivation_path,
                     test_case.alg(),
+                    false,
                     rng,
                 );
                 let sig_shares = sig_share_from_each_receiver(&env, &inputs);

rs/crypto/test_utils/canister_threshold_sigs/src/lib.rs

@@ -219,14 +219,19 @@ pub fn generate_presig_quadruple<R: RngCore + CryptoRng>(
     receivers: &IDkgReceivers,
     alg: AlgorithmId,
     key_transcript: &IDkgTranscript,
+    random_unmasked_kappa: bool,
     rng: &mut R,
 ) -> PreSignatureQuadruple {
     let lambda_params = setup_masked_random_params(env, alg, dealers, receivers, rng);
     let lambda_transcript = env
         .nodes
         .run_idkg_and_create_and_verify_transcript(&lambda_params, rng);
 
-    let kappa_transcript = {
+    let kappa_transcript = if random_unmasked_kappa {
+        let unmasked_kappa_params = setup_unmasked_random_params(env, alg, dealers, receivers, rng);
+        env.nodes
+            .run_idkg_and_create_and_verify_transcript(&unmasked_kappa_params, rng)
+    } else {
         let masked_kappa_params = setup_masked_random_params(env, alg, dealers, receivers, rng);
 
         let masked_kappa_transcript = env
@@ -1630,7 +1635,27 @@ impl std::fmt::Display for IDkgMode {
 }
 
 /// Returns an `IDkgTranscriptParams` appropriate for creating a random
-/// sharing in this environment.
+/// unmasked sharing in this environment.
+pub fn setup_unmasked_random_params<R: Rng + CryptoRng>(
+    env: &CanisterThresholdSigTestEnvironment,
+    algorithm_id: AlgorithmId,
+    dealers: &IDkgDealers,
+    receivers: &IDkgReceivers,
+    rng: &mut R,
+) -> IDkgTranscriptParams {
+    IDkgTranscriptParams::new(
+        random_transcript_id(rng),
+        dealers.get().clone(),
+        receivers.get().clone(),
+        env.newest_registry_version,
+        algorithm_id,
+        IDkgTranscriptOperation::RandomUnmasked,
+    )
+    .expect("failed to create random IDkgTranscriptParams")
+}
+
+/// Returns an `IDkgTranscriptParams` appropriate for creating a random
+/// masked sharing in this environment.
 pub fn setup_masked_random_params<R: Rng + CryptoRng>(
     env: &CanisterThresholdSigTestEnvironment,
     algorithm_id: AlgorithmId,
@@ -1832,10 +1857,18 @@ pub fn generate_tecdsa_protocol_inputs<R: RngCore + CryptoRng>(
     nonce: Randomness,
     derivation_path: &ExtendedDerivationPath,
     algorithm_id: AlgorithmId,
+    random_unmasked_kappa: bool,
     rng: &mut R,
 ) -> ThresholdEcdsaSigInputs {
-    let quadruple =
-        generate_presig_quadruple(env, dealers, receivers, algorithm_id, key_transcript, rng);
+    let quadruple = generate_presig_quadruple(
+        env,
+        dealers,
+        receivers,
+        algorithm_id,
+        key_transcript,
+        random_unmasked_kappa,
+        rng,
+    );
 
     ThresholdEcdsaSigInputs::new(
         derivation_path,