chore: use pure rust secp256k1 crate (#21154)

Saves ~40s in fresh debug build

1 files changed, 24 insertions, 21 deletions

diff --git a/ext/node/ops/crypto/mod.rs b/ext/node/ops/crypto/mod.rs
index 35940da77..4aaa3f494 100644
--- a/ext/node/ops/crypto/mod.rs
+++ b/ext/node/ops/crypto/mod.rs
@@ -39,9 +39,6 @@ use rsa::Oaep;
 use rsa::Pkcs1v15Encrypt;
 use rsa::RsaPrivateKey;
 use rsa::RsaPublicKey;
-use secp256k1::ecdh::SharedSecret;
-use secp256k1::Secp256k1;
-use secp256k1::SecretKey;
 
 mod cipher;
 mod dh;
@@ -1012,10 +1009,11 @@ pub fn op_node_ecdh_generate_keys(
   let mut rng = rand::thread_rng();
   match curve {
     "secp256k1" => {
-      let secp = Secp256k1::new();
-      let (privkey, pubkey) = secp.generate_keypair(&mut rng);
-      pubbuf.copy_from_slice(&pubkey.serialize_uncompressed());
-      privbuf.copy_from_slice(&privkey.secret_bytes());
+      let privkey =
+        elliptic_curve::SecretKey::<k256::Secp256k1>::random(&mut rng);
+      let pubkey = privkey.public_key();
+      pubbuf.copy_from_slice(pubkey.to_sec1_bytes().as_ref());
+      privbuf.copy_from_slice(privkey.to_nonzero_scalar().to_bytes().as_ref());
 
       Ok(0)
     }
@@ -1053,16 +1051,22 @@ pub fn op_node_ecdh_compute_secret(
 ) -> Result<(), AnyError> {
   match curve {
     "secp256k1" => {
-      let this_secret_key = SecretKey::from_slice(
-        this_priv.expect("no private key provided?").as_ref(),
-      )
-      .unwrap();
       let their_public_key =
-        secp256k1::PublicKey::from_slice(their_pub).unwrap();
-      let shared_secret =
-        SharedSecret::new(&their_public_key, &this_secret_key);
+        elliptic_curve::PublicKey::<k256::Secp256k1>::from_sec1_bytes(
+          their_pub,
+        )
+        .expect("bad public key");
+      let this_private_key =
+        elliptic_curve::SecretKey::<k256::Secp256k1>::from_slice(
+          &this_priv.expect("must supply private key"),
+        )
+        .expect("bad private key");
+      let shared_secret = elliptic_curve::ecdh::diffie_hellman(
+        this_private_key.to_nonzero_scalar(),
+        their_public_key.as_affine(),
+      );
+      secret.copy_from_slice(shared_secret.raw_secret_bytes());
 
-      secret.copy_from_slice(&shared_secret.secret_bytes());
       Ok(())
     }
     "prime256v1" | "secp256r1" => {
@@ -1125,12 +1129,11 @@ pub fn op_node_ecdh_compute_public_key(
 ) -> Result<(), AnyError> {
   match curve {
     "secp256k1" => {
-      let secp = Secp256k1::new();
-      let secret_key = SecretKey::from_slice(privkey).unwrap();
-      let public_key =
-        secp256k1::PublicKey::from_secret_key(&secp, &secret_key);
-
-      pubkey.copy_from_slice(&public_key.serialize_uncompressed());
+      let this_private_key =
+        elliptic_curve::SecretKey::<k256::Secp256k1>::from_slice(privkey)
+          .expect("bad private key");
+      let public_key = this_private_key.public_key();
+      pubkey.copy_from_slice(public_key.to_sec1_bytes().as_ref());
 
       Ok(())
     }