WIP: Generic ec

Cargo.toml

@@ -23,6 +23,7 @@ flamer = { version = "0.3", optional = true }
 generic-array = "0.14"
 hex = "0.4"
 k256 = { version = "0.13", features = ["arithmetic", "sha256", "ecdsa", "serde"] }
+generic-ec = { version = "0.4.2", features = ["curve-secp256k1"] }
 lazy_static = "1"
 
 # libpaillier depends on `unknown_order` which in turn depends on `rug`.

src/presign/participant.rs

@@ -28,11 +28,12 @@ use crate::{
     zkp::{
         piaffg::{PiAffgInput, PiAffgProof, PiAffgSecret},
         pienc::{PiEncInput, PiEncProof, PiEncSecret},
-        pilog::{CommonInput, PiLogProof, ProverSecret},
+        pilog::{CommonInput, PiLogProof, ProverSecret, SerdePoint},
         Proof, ProofContext,
     },
     Identifier,
 };
+use generic_ec::curves::Secp256k1;
 use libpaillier::unknown_order::BigNumber;
 use merlin::Transcript;
 use rand::{CryptoRng, RngCore};
@@ -1040,6 +1041,17 @@ impl PresignKeyShareAndInfo {
 
         let g = CurvePoint::GENERATOR;
         let Gamma = g.multiply_by_bignum(&sender_r1_priv.gamma)?;
+        // create SerdePoint from Gamma
+        //let serdeGamma = SerdePoint::<generic_ec::curves::Secp256k1> {
+        //point: generic_ec::curves::Secp256k1::point::from_bytes(Gamma.to_bytes()),
+        //point: <generic_ec_curves::rust_crypto::RustCryptoCurve<Secp256k1,
+        // ExpandMsgXmd<CoreWrapper<CtVariableCoreWrapper<Sha256VarCore,
+        // UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>,
+        // OidSha256>>>> as Example>::point::from_bytes(Gamma.to_bytes()),
+        //};
+        //let serdeGamma = SerdePoint::new(point_from_bytes(Gamma.to_bytes()));
+        let serdeGamma = SerdePoint::from_curve_point(Gamma);
+        let serdeg: SerdePoint<Secp256k1> = SerdePoint::from_curve_point(g);
 
         // Generate the proofs.
         let mut transcript = Transcript::new(b"PiAffgProof");
@@ -1081,7 +1093,7 @@ impl PresignKeyShareAndInfo {
         let psi_prime = PiLogProof::prove(
             CommonInput::new(
                 &sender_r1_priv.G,
-                &Gamma,
+                &serdeGamma,
                 receiver_aux_info.params().scheme(),
                 self.aux_info_public.pk(),
                 &g,
@@ -1166,6 +1178,8 @@ impl PresignKeyShareAndInfo {
         }
 
         let Delta = Gamma.multiply_by_bignum(&sender_r1_priv.k)?;
+        let serdeDelta = SerdePoint::from_curve_point(Delta);
+        let serdeGamma: SerdePoint<Secp256k1> = SerdePoint::from_curve_point(Gamma);
 
         let delta_scalar = bn_to_scalar(&delta)?;
         let chi_scalar = bn_to_scalar(&chi)?;
@@ -1176,7 +1190,7 @@ impl PresignKeyShareAndInfo {
             let psi_double_prime = PiLogProof::prove(
                 CommonInput::new(
                     &sender_r1_priv.K,
-                    &Delta,
+                    &serdeDelta,
                     round_three_input.auxinfo_public.params().scheme(),
                     self.aux_info_public.pk(),
                     &Gamma,

src/presign/round_three.rs

@@ -17,10 +17,11 @@ use crate::{
     },
     utils::CurvePoint,
     zkp::{
-        pilog::{CommonInput, PiLogProof},
+        pilog::{CommonInput, PiLogProof, SerdePoint},
         Proof,
     },
 };
+use generic_ec::curves::Secp256k1;
 use k256::{elliptic_curve::PrimeField, Scalar};
 use libpaillier::unknown_order::BigNumber;
 use merlin::Transcript;
@@ -65,7 +66,7 @@ impl Debug for Private {
 pub(crate) struct Public {
     pub delta: Scalar,
     pub Delta: CurvePoint,
-    pub psi_double_prime: PiLogProof,
+    pub psi_double_prime: PiLogProof<Secp256k1>,
     /// Gamma value included for convenience
     pub Gamma: CurvePoint,
 }
@@ -82,9 +83,10 @@ impl Public {
         prover_r1_public_broadcast: &RoundOnePublicBroadcast,
     ) -> Result<()> {
         let mut transcript = Transcript::new(b"PiLogProof");
+        let deltaSerde = SerdePoint::from_curve_point(self.Delta);
         let psi_double_prime_input = CommonInput::new(
             &prover_r1_public_broadcast.K,
-            &self.Delta,
+            &deltaSerde,
             verifier_auxinfo_public.params().scheme(),
             prover_auxinfo_public.pk(),
             &self.Gamma,

src/presign/round_two.rs

@@ -19,10 +19,11 @@ use crate::{
     utils::CurvePoint,
     zkp::{
         piaffg::{PiAffgInput, PiAffgProof},
-        pilog::{CommonInput, PiLogProof},
+        pilog::{CommonInput, PiLogProof, SerdePoint},
         Proof,
     },
 };
+use generic_ec::curves::Secp256k1;
 use libpaillier::unknown_order::BigNumber;
 use merlin::Transcript;
 use serde::{Deserialize, Serialize};
@@ -59,7 +60,7 @@ pub(crate) struct Public {
     pub Gamma: CurvePoint,
     pub psi: PiAffgProof,
     pub psi_hat: PiAffgProof,
-    pub psi_prime: PiLogProof,
+    pub psi_prime: PiLogProof<Secp256k1>,
 }
 
 impl Public {
@@ -106,9 +107,10 @@ impl Public {
             .verify(psi_hat_input, context, &mut transcript)?;
 
         // Verify the psi_prime proof
+        let Gamma = SerdePoint::from_curve_point(self.Gamma);
         let psi_prime_input = CommonInput::new(
             &prover_r1_public_broadcast.G,
-            &self.Gamma,
+            &Gamma,
             verifier_auxinfo_public.params().scheme(),
             prover_auxinfo_public.pk(),
             &g,

src/utils.rs

@@ -49,6 +49,16 @@ impl AsRef<CurvePoint> for CurvePoint {
 }
 
 impl CurvePoint {
+    // new
+    pub fn new(value: k256::ProjectivePoint) -> Self {
+        Self(value)
+    }
+
+    // return the wrapped point
+    pub fn inner_value(&self) -> k256::ProjectivePoint {
+        self.0
+    }
+
     pub fn x_affine(&self) -> FieldBytes {
         self.0.to_affine().x()
     }