PoliEcho/pea_2_pea
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

remove asymetric ecryption

Browse Source
This commit is contained in:
PoliEcho
2025-07-25 22:14:48 +02:00
parent 13223b5417
commit fb0a1644b7
8 changed files with 69 additions and 311 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/client/main.rs
+62 -2
View File
@@ -1,8 +1,42 @@
use std::net::UdpSocket;
use pea_2_pea::SERVER_PORT;
use std::{
io::{Read, Write},
net::UdpSocket,
process::exit,
};
#[derive(clap::Parser)]
#[command(name = "pea_2_pea")]
#[command(about = "A CLI tool for pea_2_pea P2P vpn client")]
struct Cli {
#[arg(short = 'r', long = "registrar")]
#[arg(help = "registrar ip address or hostname")]
registrar: String,
#[arg(short = 'v', long = "verbose")]
verbose: bool,
#[arg(short = 'V', long = "version")]
version: bool,
#[arg(short = 'p', long = "registrar-port")]
#[arg(help = format!("Port number for the registrar service (1-65535) Default: {}", SERVER_PORT))]
registrar_port: Option<u16>,
#[arg(short = 'P', long = "bind-port")]
bind_port: Option<u16>,
}
fn main() -> std::io::Result<()> {
let cli = <Cli as clap::Parser>::parse();
{
let socket: UdpSocket = (|| -> std::io::Result<UdpSocket> {
let mut port: u16 = 59999;
let mut port: u16;
match cli.bind_port {
Some(port_proveded) => port = port_proveded,
None => port = 59999, // Magic number
}
loop {
port += 1;
match UdpSocket::bind(format!("0.0.0.0:{}", port)) {
@@ -12,6 +46,32 @@ fn main() -> std::io::Result<()> {
}
})()
.expect("Failed to bind to any available port");
// send query request to get server public key
let server_port: u16 = (|| -> u16 {
match cli.bind_port {
Some(port_proveded) => return port_proveded,
None => return pea_2_pea::SERVER_PORT,
}
})();
let server_SocketAddr: core::net::SocketAddr = format!("{}:{}", cli.registrar, server_port)
.parse()
.unwrap();
let mut buf: [u8; pea_2_pea::BUFFER_SIZE] = [0; pea_2_pea::BUFFER_SIZE];
loop {
match socket.recv_from(&mut buf) {
Ok((data_length, src)) => {}
Err(e) => {
eprintln!("Error receiving data: {}", e);
std::process::exit(-4);
}
}
let mut out = std::io::stdout();
out.write_all(&buf)?;
out.flush()?;
}
}
Ok(())
}
src/lib.rs
+3 -4
View File
@@ -6,10 +6,9 @@ pub const RSA_SIZE: usize = 2048;
#[repr(u8)]
pub enum ServerMethods {
QUERY = 0,
REGISTER = 1,
GET = 2,
HEARTBEAT = 3,
REGISTER = 0,
GET = 1,
HEARTBEAT = 2,
}
pub mod shared;
src/server/main.rs
+3 -14
View File
@@ -1,12 +1,11 @@
mod net;
use std::{net::UdpSocket, process::exit, sync::Arc};
use rsa::pkcs8::der::zeroize::Zeroize;
fn main() -> std::io::Result<()> {
{
let socket: Arc<UdpSocket> = Arc::new(
(|| -> std::io::Result<UdpSocket> {
let listen_port: u16 = 60000;
let listen_port: u16 = pea_2_pea::SERVER_PORT;
match UdpSocket::bind(format!("0.0.0.0:{}", listen_port)) {
Ok(socket) => return Ok(socket),
Err(e) => return Err(e),
@@ -15,23 +14,13 @@ fn main() -> std::io::Result<()> {
.expect("Failed to bind to any available port"),
);
let server_key_pear: pea_2_pea::shared::crypto::KeyPair =
pea_2_pea::shared::crypto::generate_rsa_key_pair();
let mut buf: [u8; pea_2_pea::BUFFER_SIZE] = [0; pea_2_pea::BUFFER_SIZE];
smol::block_on(async {
loop {
buf.zeroize();
match socket.recv_from(&mut buf) {
Ok((data_length, src)) => {
smol::spawn(net::handle_request(
buf,
socket.clone(),
src,
data_length,
server_key_pear.clone(),
))
.detach();
smol::spawn(net::handle_request(buf, socket.clone(), src, data_length))
.detach();
}
Err(e) => {
eprintln!("Error receiving data: {}", e);
src/server/net.rs
-35
View File
@@ -1,47 +1,12 @@
use rsa::{Pkcs1v15Encrypt, pkcs1::EncodeRsaPublicKey, pkcs8::DecodePublicKey};
pub async fn handle_request(
buf: [u8; pea_2_pea::BUFFER_SIZE],
socket: std::sync::Arc<std::net::UdpSocket>,
src: core::net::SocketAddr,
data_len: usize,
server_key_pair: pea_2_pea::shared::crypto::KeyPair,
) {
let mut rng: rand::prelude::ThreadRng = rand::thread_rng();
match buf[0] {
x if x == pea_2_pea::ServerMethods::QUERY as u8 => {
#[cfg(debug_assertions)]
eprintln!("QUERY method");
let client_public_key: rsa::RsaPublicKey =
match rsa::RsaPublicKey::from_public_key_der(&buf[1..]) {
Ok(key) => key,
Err(e) => {
eprintln!("Error serializing client key: {}", e);
return;
}
};
let pkcs_encoded_public_key: rsa::pkcs8::Document =
server_key_pair.public_key.to_pkcs1_der().unwrap();
let mut send_vec: Vec<u8> = pkcs_encoded_public_key.into_vec();
send_vec.insert(0, pea_2_pea::ServerMethods::QUERY as u8);
let send_vec_encrypted: Vec<u8> = client_public_key
.encrypt(&mut rng, Pkcs1v15Encrypt, &send_vec)
.unwrap();
match socket.send_to(&send_vec_encrypted, &src) {
Ok(s) => {
#[cfg(debug_assertions)]
eprintln!("send {} bytes", s);
}
Err(e) => {
eprintln!("Error snding data: {}", e);
}
}
}
x if x == pea_2_pea::ServerMethods::GET as u8 => {
#[cfg(debug_assertions)]
println!("GET method");
src/shared/crypto.rs
-20
View File
@@ -1,21 +1 @@
#[derive(Clone)]
pub struct KeyPair {
pub private_key: rsa::RsaPrivateKey,
pub public_key: rsa::RsaPublicKey,
}
pub fn generate_rsa_private_key() -> Result<rsa::RsaPrivateKey, rsa::Error> {
let mut rng: rand::prelude::ThreadRng = rand::thread_rng();
let bits: usize = 2048;
return rsa::RsaPrivateKey::new(&mut rng, bits);
}
pub fn generate_rsa_key_pair() -> KeyPair {
let private_key: rsa::RsaPrivateKey = generate_rsa_private_key().unwrap();
let public_key: rsa::RsaPublicKey = rsa::RsaPublicKey::from(&private_key);
KeyPair {
private_key,
public_key,
}
}
src/shared/mod.rs
+1 -1
View File
@@ -1 +1 @@
pub mod crypto;