feat: split rmc off from prudp, make macros crate location independent and add tls connection setup

src/executables/backend_server.rs

@@ -0,0 +1,58 @@
+use log::error;
+use once_cell::sync::Lazy;
+use rustls::client::danger::HandshakeSignatureValid;
+use rustls::pki_types::{CertificateDer, TrustAnchor, UnixTime};
+use rustls::server::danger::{ClientCertVerified, ClientCertVerifier};
+use rustls::server::{ClientCertVerifierBuilder, WebPkiClientVerifier};
+use rustls::{
+    DigitallySignedStruct, DistinguishedName, Error, RootCertStore, ServerConfig, ServerConnection,
+    SignatureScheme,
+};
+use rustls_pki_types::PrivateKeyDer;
+use splatoon_server_rust::common::setup;
+use splatoon_server_rust::reggie::{get_configured_tls_acceptor, TestStruct, ROOT_TRUST_ANCHOR, SELF_CERT, SELF_KEY};
+use std::borrow::ToOwned;
+use std::fs;
+use std::io::Cursor;
+use std::net::{IpAddr, SocketAddr, SocketAddrV4};
+use std::sync::Arc;
+use macros::{method_id, rmc_proto, rmc_struct};
+use tokio::io::AsyncReadExt;
+use tokio::net::{TcpListener, TcpSocket};
+use tokio::task;
+use tokio_rustls::TlsAcceptor;
+use splatoon_server_rust::define_rmc_proto;
+use splatoon_server_rust::rmc::protocols::new_rmc_gateway_connection;
+use splatoon_server_rust::rmc::response::ErrorCode;
+use splatoon_server_rust::rmc::structures::RmcSerialize;
+
+
+
+
+#[tokio::main]
+async fn main() {
+    setup();
+
+    let acceptor = get_configured_tls_acceptor().await;
+
+    let listen = TcpListener::bind("192.168.178.120:2376").await.unwrap();
+
+    while let Ok((stream, addr)) = listen.accept().await {
+        let mut stream = match acceptor.accept(stream).await {
+            Ok(v) => v,
+            Err(e) => {
+                error!("an error ocurred whilest accepting tls connection: {:?}", e);
+                continue;
+            }
+        };
+
+        task::spawn(async move {
+            new_rmc_gateway_connection(stream.into(), |_| {
+                Arc::new(TestStruct)
+            });
+
+            println!("lost connection lol");
+        });
+
+    }
+}

src/executables/proxy_insecure.rs

@@ -0,0 +1,131 @@
+mod proxy_secure;
+
+use std::env;
+use std::ffi::CStr;
+use std::io::{Read, Write};
+use std::net::{Ipv4Addr, SocketAddrV4, TcpListener, TcpStream};
+use bytemuck::{Pod, Zeroable};
+use chacha20::{ChaCha20, Key};
+use chacha20::cipher::{Iv, KeyIvInit, StreamCipher};
+use log::error;
+use once_cell::sync::Lazy;
+use rsa::pkcs8::{DecodePrivateKey, DecodePublicKey, Document};
+use rsa::{BigUint, Pkcs1v15Encrypt, RsaPrivateKey, RsaPublicKey};
+use rsa::pkcs1::EncodeRsaPublicKey;
+use rsa::pss::BlindedSigningKey;
+use rsa::signature::{RandomizedSigner, SignatureEncoding};
+use sha2::Sha256;
+use tokio::net::TcpSocket;
+use tokio::task;
+use splatoon_server_rust::common::setup;
+use splatoon_server_rust::prudp::packet::VirtualPort;
+use splatoon_server_rust::prudp::router::Router;
+use splatoon_server_rust::prudp::unsecure::Unsecure;
+use splatoon_server_rust::reggie::{establish_tls_connection_to, UnitPacketRead, UnitPacketWrite};
+use splatoon_server_rust::rmc::structures::RmcSerialize;
+use splatoon_server_rust::rnex_proxy_common::ConnectionInitData;
+
+static OWN_IP_PRIVATE: Lazy<Ipv4Addr> = Lazy::new(|| {
+    env::var("SERVER_IP")
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .expect("no public ip specified")
+});
+
+static OWN_IP_PUBLIC: Lazy<String> =
+    Lazy::new(|| env::var("SERVER_IP_PUBLIC").unwrap_or(OWN_IP_PRIVATE.to_string()));
+
+static SERVER_PORT: Lazy<u16> = Lazy::new(|| {
+    env::var("AUTH_SERVER_PORT")
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(10000)
+});
+
+static FORWARD_DESTINATION: Lazy<String> =
+    Lazy::new(|| env::var("FORWARD_DESTINATION").unwrap_or(OWN_IP_PRIVATE.to_string()));
+
+static RSA_PRIVKEY: Lazy<RsaPrivateKey> = Lazy::new(|| {
+    let path = env::var("RSA_PRIVKEY")
+        .expect("RSA_PRIVKEY not set");
+
+    RsaPrivateKey::read_pkcs8_pem_file(&path)
+        .expect("unable to read private key")
+});
+
+static RSA_PUBKEY: Lazy<RsaPublicKey> = Lazy::new(|| {
+    RSA_PRIVKEY.to_public_key()
+});
+
+static PUBKEY_ENCODED: Lazy<Document> = Lazy::new(|| {
+    RSA_PUBKEY.to_pkcs1_der().expect("unable to convert pubkey to der")
+});
+
+static RSA_SIGNKEY: Lazy<BlindedSigningKey<Sha256>> = Lazy::new(||
+    BlindedSigningKey::<Sha256>::new(RSA_PRIVKEY.clone())
+);
+
+#[tokio::main]
+async fn main() {
+    setup();
+
+    let (router_secure, _) = Router::new(SocketAddrV4::new(*OWN_IP_PRIVATE, *SERVER_PORT))
+        .await
+        .expect("unable to start router");
+
+    let mut socket_secure = router_secure
+        .add_socket(VirtualPort::new(1, 10), Unsecure(
+            "6f599f81"
+        ))
+        .await
+        .expect("unable to add socket");
+
+    // let conn = socket_secure.connect(auth_sockaddr).await.unwrap();
+
+    loop {
+        let Some(mut conn) = socket_secure.accept().await else {
+            error!("server crashed");
+            return;
+        };
+
+        task::spawn(async move {
+            let mut stream
+                = establish_tls_connection_to("192.168.178.120:2376", "account.spfn.net").await;
+
+            if let Err(e) = stream.send_buffer(&ConnectionInitData{
+                prudpsock_addr: conn.socket_addr
+            }.to_data()).await{
+                error!("error connecting to backend: {}", e);
+                return;
+            };
+
+            loop {
+                tokio::select! {
+                    data = conn.recv() => {
+                        let Some(data) = data else {
+                            break;
+                        };
+
+                        if let Err(e) = stream.send_buffer(&data[..]).await{
+                            error!("error sending data to backend: {}", e);
+                            break;
+                        }
+                    },
+                    data = stream.read_buffer() => {
+                        let data = match data{
+                            Ok(d) => d,
+                            Err(e) => {
+                                error!("error reveiving data from backend: {}", e);
+                                break;
+                            }
+                        };
+                        
+                        if conn.send(data).await == None{
+                            return;
+                        }
+                    },
+                }
+            }
+        });
+    }
+}

src/executables/proxy_secure.rs

@@ -0,0 +1,26 @@
+use splatoon_server_rust::reggie::RemoteRmcTestProto;
+use std::fs;
+use std::net::IpAddr;
+use std::sync::Arc;
+use rustls::ClientConfig;
+use rustls_pki_types::ServerName;
+use tokio::io::AsyncWriteExt;
+use tokio::net::TcpStream;
+use tokio_rustls::{TlsConnector, TlsStream};
+use splatoon_server_rust::common::setup;
+use splatoon_server_rust::reggie::{establish_tls_connection_to, get_configured_tls_connector, RemoteTestProto, UnitPacketWrite};
+use splatoon_server_rust::rmc::protocols::{new_rmc_gateway_connection, OnlyRemote};
+use splatoon_server_rust::rmc::structures::RmcSerialize;
+
+
+#[tokio::main]
+async fn main(){
+    setup();
+
+    let mut stream
+        = establish_tls_connection_to("192.168.178.120:2376", "account.spfn.net").await;
+
+    let remo = new_rmc_gateway_connection(stream.into(), |r| Arc::new(OnlyRemote::<RemoteTestProto>::new(r)) );
+
+    println!("{:?}", remo.test().await);
+}