Rsa keygen

anchor/client/Cargo.toml

@@ -22,6 +22,7 @@ fdlimit = "0.3"
 http_api = { workspace = true }
 http_metrics = { workspace = true }
 hyper = { workspace = true }
+keygen = { workspace = true }
 message_receiver = { workspace = true }
 message_sender = { workspace = true }
 message_validator = { workspace = true }

anchor/client/src/lib.rs

@@ -13,6 +13,7 @@ use config::Config;
 use database::{NetworkDatabase, WatchableNetworkState};
 use eth2::reqwest::{Certificate, ClientBuilder};
 use eth2::{BeaconNodeHttpClient, Timeouts};
+use keygen::{run_keygen, Keygen};
 use message_receiver::ManagerMessageReceiver;
 use message_sender::NetworkMessageSender;
 use message_validator::Validator;
@@ -27,7 +28,7 @@ use slashing_protection::SlashingDatabase;
 use slot_clock::{SlotClock, SystemTimeSlotClock};
 use ssv_types::OperatorId;
 use std::fs::File;
-use std::io::{ErrorKind, Read, Write};
+use std::io::{ErrorKind, Read};
 use std::net::SocketAddr;
 use std::path::Path;
 use std::sync::Arc;
@@ -759,15 +760,9 @@ fn read_or_generate_private_key(path: &Path) -> Result<Rsa<Private>, String> {
 
             info!(path = %path.as_os_str().to_string_lossy(), "Creating private key");
 
-            let mut file = File::create(path)
-                .map_err(|e| format!("Unable create private key file at {path:?}: {e:?}"))?;
-
-            let key = Rsa::generate(2048).map_err(|e| format!("Unable to generate key: {e:?}"))?;
-
-            file.write_all(&Zeroizing::new(
-                key.private_key_to_pem()
-                    .map_err(|e| format!("Unable serialize private key: {e:?}"))?,
-            ))
+            let key = run_keygen(Keygen {
+                output_path: Some(path.to_string_lossy().to_string()),
+            })
             .map_err(|e| format!("Unable to write private key: {e:?}"))?;
 
             Ok(key)

anchor/keygen/src/lib.rs

@@ -1,9 +1,9 @@
 use base64::prelude::*;
 use clap::Parser;
-use openssl::rsa::Rsa;
+use openssl::{pkey::Private, rsa::Rsa};
 use serde::Serialize;
 use std::{fs, path::PathBuf};
-use tracing::info;
+use tracing::{info, warn};
 
 #[derive(Debug)]
 pub enum KeygenError {
@@ -27,7 +27,7 @@ struct PrettyOutput {
 }
 
 // Run RSA keygeneration
-pub fn run_keygen(keygen: Keygen) -> Result<(), KeygenError> {
+pub fn run_keygen(keygen: Keygen) -> Result<Rsa<Private>, KeygenError> {
     // Generate the new rsa private key
     let private_key = Rsa::generate(2048)
         .map_err(|e| KeygenError::Generate(format!("Failed to generate new private key: {e}")))?;
@@ -65,13 +65,6 @@ pub fn run_keygen(keygen: Keygen) -> Result<(), KeygenError> {
     let pem_file = output_dir.join("key.pem");
     let json_file = output_dir.join("keys.json");
 
-    // Write the PEM file
-    fs::write(&pem_file, &private_pem).map_err(|e| {
-        KeygenError::Output(format!("Failed to write private key to PEM file: {e}"))
-    })?;
-
-    info!("Private key written to: {}", pem_file.display());
-
     // Create JSON data structure
     let data = PrettyOutput {
         public: public_pem_encoded,
@@ -83,11 +76,25 @@ pub fn run_keygen(keygen: Keygen) -> Result<(), KeygenError> {
         KeygenError::Output(format!("Failed to convert output data to JSON string: {e}"))
     })?;
 
-    // Write the JSON file
-    fs::write(&json_file, pretty_json)
-        .map_err(|e| KeygenError::Output(format!("Failed to write keys to JSON file: {e}")))?;
+    if !pem_file.exists() && !json_file.exists() {
+        // Write the PEM file
+        fs::write(&pem_file, &private_pem).map_err(|e| {
+            KeygenError::Output(format!("Failed to write private key to PEM file: {e}"))
+        })?;
 
-    info!("JSON keys written to: {}", json_file.display());
+        info!("Private key written to: {}", pem_file.display());
+
+        // Write the JSON file
+        fs::write(&json_file, pretty_json)
+            .map_err(|e| KeygenError::Output(format!("Failed to write keys to JSON file: {e}")))?;
+
+        info!("JSON keys written to: {}", json_file.display());
+    } else {
+        warn!(
+            "PEM file or JSON file already exist in {:?}, skipping write",
+            output_dir
+        );
+    }
 
-    Ok(())
+    Ok(private_key)
 }