Allow the use of a fixed private key

Author: Ma233

Cargo.lock

@@ -6,6 +6,7 @@ edition = "2021"
 [dependencies]
 clap = "4.5.4"
 futures = "0.3.30"
+hex = "0.4.3"
 httparse = "1.8.0"
 litep2p = "0.5.0"
 # Do not upgrade multiaddr, see: https://github.com/paritytech/litep2p/pull/91

Cargo.toml

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 use std::net::SocketAddr;
 use std::time::Duration;
 
+use litep2p::crypto::ed25519::SecretKey;
 use litep2p::protocol::request_response::DialOptions;
 use litep2p::protocol::request_response::RequestResponseEvent;
 use litep2p::types::RequestId;
@@ -62,14 +63,18 @@ pub struct PProxyHandle {
 }
 
 impl PProxy {
-    pub fn new(server_addr: SocketAddr, proxy_addr: Option<SocketAddr>) -> (Self, PProxyHandle) {
+    pub fn new(
+        secret_key: SecretKey,
+        server_addr: SocketAddr,
+        proxy_addr: Option<SocketAddr>,
+    ) -> (Self, PProxyHandle) {
         let (command_tx, command_rx) = mpsc::channel(DEFAULT_CHANNEL_SIZE);
 
         (
             Self {
                 command_rx,
                 tunnel_notifier: HashMap::new(),
-                p2p_server: P2pServer::new(server_addr),
+                p2p_server: P2pServer::new(secret_key, server_addr),
                 proxy_addr,
             },
             PProxyHandle { command_tx },

src/lib.rs

@@ -3,6 +3,7 @@ use clap::ArgAction;
 use clap::Command;
 use dephy_pproxy::command::PProxyCommander;
 use dephy_pproxy::PProxy;
+use litep2p::crypto::ed25519::SecretKey;
 use tonic::transport::Server;
 
 fn parse_args() -> Command {
@@ -11,6 +12,13 @@ fn parse_args() -> Command {
         .version("0.1.0");
 
     app = app
+        .arg(
+            Arg::new("KEY")
+                .long("key")
+                .num_args(1)
+                .action(ArgAction::Set)
+                .help("Ed25519 key. If not set, a random key will be generated"),
+        )
         .arg(
             Arg::new("SERVER_ADDR")
                 .long("server-addr")
@@ -45,6 +53,16 @@ async fn main() {
         .try_init();
 
     let args = parse_args().get_matches();
+    let key = args
+        .get_one::<String>("KEY")
+        .map(|key| {
+            SecretKey::from_bytes(hex::decode(key).expect("Invalid key")).expect("Invalid key")
+        })
+        .unwrap_or_else(|| {
+            let key = SecretKey::generate();
+            println!("Generated key: {}", hex::encode(&key));
+            key
+        });
     let server_addr = args
         .get_one::<String>("SERVER_ADDR")
         .unwrap()
@@ -59,10 +77,10 @@ async fn main() {
         .get_one::<String>("PROXY_ADDR")
         .map(|addr| addr.parse().expect("Invalid proxy address"));
 
-    println!("server_addr: {:?}", server_addr);
-    println!("commander_server_addr: {:?}", commander_server_addr);
+    println!("server_addr: {}", server_addr);
+    println!("commander_server_addr: {}", commander_server_addr);
 
-    let (pproxy, pproxy_handle) = PProxy::new(server_addr, proxy_addr);
+    let (pproxy, pproxy_handle) = PProxy::new(key, server_addr, proxy_addr);
 
     let commander = PProxyCommander::new(pproxy_handle);
     let commander_server = Server::builder()

src/main.rs

@@ -3,6 +3,7 @@ use std::net::SocketAddr;
 
 use futures::StreamExt;
 use litep2p::config::ConfigBuilder;
+use litep2p::crypto::ed25519::SecretKey;
 use litep2p::protocol::request_response::Config as RequestResponseConfig;
 use litep2p::protocol::request_response::ConfigBuilder as RequestResponseConfigBuilder;
 use litep2p::protocol::request_response::RequestResponseEvent;
@@ -26,7 +27,7 @@ pub struct P2pServer {
 }
 
 impl P2pServer {
-    pub fn new(server_addr: SocketAddr) -> Self {
+    pub fn new(secret_key: SecretKey, server_addr: SocketAddr) -> Self {
         let (control_config, control_handle) = Self::init_control();
         let (tunnel_config, tunnel_handle) = Self::init_tunnel();
 
@@ -36,6 +37,7 @@ impl P2pServer {
         };
 
         let litep2p_config = ConfigBuilder::new()
+            .with_keypair(secret_key.into())
             .with_quic(QuicConfig {
                 listen_addresses: vec![format!("/{ip_type}/{ip}/udp/{port}/quic-v1")
                     .parse()