.gitignore

@@ -1,2 +1,3 @@
 /target
-Cargo.lock
+secret.gpg
+public.gpg

Cargo.toml

@@ -1,21 +1,13 @@
 [package]
-name = "e2e-irc"
-version = "3.0.0"
+name = "irc-e2e"
+version = "0.1.0"
 edition = "2021"
-license = "GPL-3.0"
-keywords = ["irc", "encryption"]
-description = "An IRC bouncer that can send encrypted messages"
-repository = "https://forgejo.vanten-s.com/vanten-s/e2e-irc/"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-argparse = "0.2.2"
 base64 = "0.21.4"
-dirs = "5.0.1"
-eyre = "0.6.8"
-ircparser-vanten = "0.2.1"
+ircparser = "0.2.1"
 openssl = "0.10"
 pgp = "0.10.2"
 rand = "0.8.5"
-toml = "0.8.2"

README.md

@@ -1,35 +0,0 @@
-# e2e-irc
-This is an IRC bouncer that supports end-to-end encryption and is horribly written.
-
-# Configuration
-e2e-irc uses a config file in `~/.config/e2e-irc/config.toml` on linux.
-The configuration file is a toml file with two or three fields:
-- public_key      the location of the public pgp key
-- secret_key      the location of the secret pgp key
-- passwd          the password of the pgp key
-
-# Usage
-```
-e2e-irc [OPTIONS] SERVER
-
-Encrypted IRC Bouncer
-
-Positional arguments:
-  server                The Address Of The Server The Bouncer Connects To
-
-Optional arguments:
-  -h,--help             Show this help message and exit
-  -p,--port PORT        The Port The Bouncer Binds To
-  --sp,--server-port SERVER_PORT
-                        The TLS Enabled Port Of The Server
-```
-
-# Install
-```bash
-cargo install e2e-irc
-```
-
-# Run
-```bash
-e2e-irc [OPTIONS] SERVER
-```

src/client_handler.rs

@@ -1,104 +0,0 @@
-use crate::helpers::bytes_to_privmsg_base64;
-use crate::{encryption, helpers, State};
-use eyre::Result;
-use pgp::{Deserializable, SignedPublicKey};
-use std::collections::HashMap;
-use std::sync::mpsc::{Receiver, Sender};
-
-#[derive(Debug)]
-struct InvalidCommand;
-
-impl std::fmt::Display for InvalidCommand {
-    fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        Ok(())
-    }
-}
-
-impl std::error::Error for InvalidCommand {}
-
-fn parse_bouncer_command(message: String, state: &mut State) -> Result<()> {
-    macro_rules! unwrap_option {
-        ($t:expr) => {
-            match $t {
-                Some(val) => val,
-                None => return Err(InvalidCommand.into()),
-            }
-        };
-    }
-
-    let mut splitted = message.split(' ');
-    match unwrap_option!(splitted.next()) {
-        "ALLOW_UNENCRYPTED" => state
-            .nicks_without_encryption
-            .push(unwrap_option!(splitted.next()).to_string().to_lowercase()),
-        _ => return Err(InvalidCommand.into()),
-    };
-    Ok(())
-}
-
-pub fn handle_message_from_client(
-    recieved: &str,
-    public_key: &Vec<u8>,
-    server: &str,
-    keys: &mut HashMap<String, SignedPublicKey>,
-    writer_channel_tx: &Sender<String>,
-    writer_channel_rx: &Receiver<String>,
-    listener_channel_tx: &Sender<String>,
-    _listener_channel_rx: &Receiver<String>,
-    state: &mut State,
-) -> Result<()> {
-    let mut recieved = recieved.to_string();
-
-    if recieved.split(' ').count() == 1 {
-        recieved += " ";
-    }
-
-    let parsed = ircparser::parse(&recieved);
-    let command = match parsed {
-        Ok(val) => val[0].clone(),
-        Err(_) => {
-            writer_channel_tx.send(recieved)?;
-            return Ok(());
-        }
-    };
-
-    if command.command == "PRIVMSG" && !command.params[0].starts_with('#') {
-        if command.params[0] == "BOUNCER" {
-            return parse_bouncer_command(command.params[1].clone(), state);
-        }
-        if state
-            .nicks_without_encryption
-            .contains(&command.params[0].to_lowercase())
-        {
-            writer_channel_tx.send(recieved)?;
-            return Ok(());
-        }
-        let other = &command.params[0];
-
-        if !keys.contains_key(other) {
-            helpers::send_key(writer_channel_tx, other, public_key)?;
-            let key = helpers::recieve_message_base64(
-                writer_channel_rx,
-                listener_channel_tx,
-                "127.0.0.1",
-                server,
-                other,
-                "END_KEY",
-            )?;
-            let key = SignedPublicKey::from_bytes(key.as_slice())?;
-            keys.insert(other.to_string(), key);
-        }
-
-        let foreign_key = keys.get(other).unwrap();
-
-        writer_channel_tx.send(format!("PRIVMSG {other} START_MESSAGE\r\n"))?;
-        writer_channel_tx.send(bytes_to_privmsg_base64(
-            &encryption::encrypt(foreign_key, &command.params[1])?,
-            other,
-        ))?;
-        writer_channel_tx.send(format!("PRIVMSG {other} END_MESSAGE\r\n"))?;
-    } else {
-        writer_channel_tx.send(recieved.replace("127.0.0.1", server))?;
-    }
-    Ok(())
-}

src/encryption.rs

@@ -1,29 +0,0 @@
-use eyre::Result;
-use pgp::crypto::sym::SymmetricKeyAlgorithm;
-use pgp::ser::Serialize;
-use pgp::{Deserializable, Message, SignedPublicKey, SignedSecretKey};
-use rand::prelude::*;
-
-pub fn encrypt(key: &SignedPublicKey, message: &str) -> Result<Vec<u8>, pgp::errors::Error> {
-    let message = Message::new_literal("none", message);
-    let mut rng = StdRng::from_entropy();
-
-    let message = message.encrypt_to_keys(&mut rng, SymmetricKeyAlgorithm::AES128, &[key])?;
-
-    message.to_bytes()
-}
-
-pub fn decrypt<'a>(
-    key: &'a SignedSecretKey,
-    message: &[u8],
-    password: &'a str,
-) -> Result<String, pgp::errors::Error> {
-    let message = Message::from_bytes(message)?; // Convert message bytes to message object
-    let message = message.decrypt(|| password.to_string(), &[key])?.0; // Decrypt
-    let message = message.map(|x| x.unwrap()).collect::<Vec<Message>>(); // Get all messages
-    let message = &message[0]; // Get first message
-    let message = message.get_content()?.unwrap_or(Vec::new()); // Get message content as Vec<u8>
-    let message = String::from_utf8(message).unwrap(); // Convert to String
-
-    Ok(message)
-}

src/helpers.rs

@@ -1,144 +0,0 @@
-use base64::{engine::general_purpose, Engine as _};
-use eyre::Result;
-use std::sync::mpsc::{self, Receiver, Sender};
-
-#[derive(Debug)]
-pub struct IrcParseError;
-
-impl std::fmt::Display for IrcParseError {
-    fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        Ok(())
-    }
-}
-
-impl std::error::Error for IrcParseError {}
-
-static MAX_LENGTH: usize = 300;
-
-#[macro_export]
-macro_rules! unwrap_or_return_result {
-    ($e:expr) => {
-        match $e {
-            Ok(val) => val,
-            Err(_) => return Ok(()),
-        }
-    };
-}
-
-#[macro_export]
-macro_rules! unwrap_or_return_option {
-    ($e:expr) => {
-        match $e {
-            Some(val) => val,
-            None => return Ok(()),
-        }
-    };
-}
-
-pub struct State {
-    pub nicks_without_encryption: Vec<String>,
-}
-
-impl State {
-    pub fn new() -> Self {
-        State {
-            nicks_without_encryption: vec![
-                "nickserv".to_string(),
-                "chanserv".to_string(),
-                "hostserv".to_string(),
-            ],
-        }
-    }
-}
-
-fn forward(
-    message: String,
-    stream: &Sender<String>,
-    server_local: &str,
-    server_forward: &str,
-) -> Result<(), mpsc::SendError<String>> {
-    match ircparser::parse(&message) {
-        Ok(val) => match val[0].command.as_str() {
-            "PRIVMSG" => stream.send(message),
-            _ => stream.send(message.replace(server_local, server_forward)),
-        },
-        Err(_) => stream.send(message.replace(server_local, server_forward)),
-    }
-}
-
-pub fn bytes_to_privmsg_base64(message: &Vec<u8>, reciever: &str) -> String {
-    let message_length = MAX_LENGTH - format!("PRIVMSG {reciever} :\r\n").len();
-    let encoded = general_purpose::STANDARD.encode(message);
-
-    let mut command = String::new();
-    for line in encoded
-        .chars()
-        .collect::<Vec<char>>()
-        .chunks(message_length)
-        .map(|c| c.iter().collect::<String>())
-    {
-        dbg!(&line);
-        command.push_str(&format!("PRIVMSG {reciever} :{line}\r\n"));
-    }
-
-    println!("{}", encoded);
-    println!("{}", command);
-    command
-}
-
-pub fn send_key(sender: &Sender<String>, reciever: &str, key: &Vec<u8>) -> Result<()> {
-    sender.send(format!("PRIVMSG {reciever} :START_KEY\r\n"))?;
-    sender.send(bytes_to_privmsg_base64(key, reciever))?;
-    sender.send(format!("PRIVMSG {reciever} :END_KEY\r\n"))?;
-
-    Ok(())
-}
-
-pub fn get_nick(userstring: &str) -> Option<String> {
-    let userstring = userstring.chars().collect::<Vec<char>>();
-    let start_pos = userstring.iter().position(|&x| x == ':')? + 1;
-    let end_pos = userstring.iter().position(|&x| x == '!')?;
-    Some(userstring[start_pos..end_pos].iter().collect::<String>())
-}
-
-pub fn recieve_message_base64(
-    writer_channel_rx: &Receiver<String>,
-    forward_stream: &Sender<String>,
-    server_local: &str,
-    server_forward: &str,
-    sender: &str,
-    end: &str,
-) -> Result<Vec<u8>> {
-    let mut message: Vec<String> = Vec::new();
-
-    while !message.contains(&end.to_string()) {
-        let recieved_raw = writer_channel_rx.recv()?;
-
-        let parse_result = ircparser::parse(&recieved_raw);
-
-        let recieved = match parse_result {
-            Ok(mut val) => val.pop_back().unwrap(),
-            Err(_) => return Err(IrcParseError.into()),
-        };
-
-        let begin_source_reciever = format!(":{sender}!");
-        if recieved.command != "PRIVMSG"
-            || !recieved
-                .source
-                .clone()
-                .unwrap_or("".to_string())
-                .starts_with(&begin_source_reciever)
-            || recieved.params[0].starts_with('#')
-        {
-            forward(recieved_raw, forward_stream, server_local, server_forward)?;
-            continue;
-        }
-
-        message.push(recieved.params[1].clone());
-    }
-    message.pop();
-
-    let foreign_key = dbg!(message.concat());
-    let foreign_key = general_purpose::STANDARD.decode(foreign_key)?;
-    Ok(foreign_key)
-}

src/listener_server.rs

@@ -1,10 +1,15 @@
 use std::io::{ErrorKind, Read, Write};
-use std::net::{TcpListener, TcpStream};
-use std::sync::mpsc::{self, TryRecvError};
-use std::thread;
-use std::time::Duration;
+use std::net::TcpListener;
+use std::sync::mpsc;
+
+pub fn listen_to_client(tx: mpsc::Sender<String>, rx: mpsc::Receiver<String>, port: &str) {
+    let listener = TcpListener::bind("127.0.0.1:".to_string() + port).unwrap();
+    let mut stream = listener.accept().unwrap().0;
+
+    stream
+        .set_nonblocking(true)
+        .expect("Couldn't set nonblocking");
 
-fn stream_handler(tx: &mpsc::Sender<String>, rx: &mpsc::Receiver<String>, mut stream: TcpStream) {
     loop {
         let mut buffer: Vec<u8> = Vec::new();
         let mut buf: [u8; 1] = [0];
@@ -14,10 +19,9 @@ fn stream_handler(tx: &mpsc::Sender<String>, rx: &mpsc::Receiver<String>, mut st
             match stream.read(&mut buf) {
                 Ok(_length) => buffer.push(buf[0]),
                 Err(_error) => match _error.kind() {
-                    ErrorKind::WouldBlock => {}
+                    ErrorKind::WouldBlock => {},
                     _ => {
                         dbg!(_error);
-                        return;
                     }
                 },
             }
@@ -25,35 +29,13 @@ fn stream_handler(tx: &mpsc::Sender<String>, rx: &mpsc::Receiver<String>, mut st
                 Ok(value) => {
                     match stream.write_all(value.as_bytes()) {
                         Ok(_) => {}
-                        Err(_e) => {
-                            dbg!(_e);
-                            return;
-                        }
+                        Err(_e) => println!("Couldn't send {value}"),
                     };
                 }
-                Err(TryRecvError::Empty) => {}
-                Err(TryRecvError::Disconnected) => return,
-            }
-            thread::sleep(Duration::from_micros(100));
-        }
-
-        let _ = tx.send(dbg!(String::from_utf8_lossy(&buffer).to_string()));
+                Err(_e) => {}
             }
         }
 
-pub fn listen_to_client(tx: mpsc::Sender<String>, rx: mpsc::Receiver<String>, port: String) {
-    let listener = TcpListener::bind("127.0.0.1:".to_string() + &port)
-        .expect(&("Couldn't start listener on 127.0.0.1 port ".to_string() + &port));
-    loop {
-        let (stream, ip) = listener.accept().unwrap();
-        println!("Got connection from {ip}");
-
-        stream
-            .set_nonblocking(true)
-            .expect("Couldn't set nonblocking");
-
-        stream_handler(&tx, &rx, stream);
-        println!("Closed connection with {ip}");
-        let _ = tx.send("DUMMY CLOSE_CONNECTION".to_string());
+        let _ = tx.send(String::from_utf8_lossy(&buffer).to_string());
     }
 }

src/main.rs

@@ -1,78 +1,110 @@
-use argparse::{ArgumentParser, Store};
-use dirs::config_local_dir;
-use eyre::Result;
-use helpers::State;
-use pgp::{Deserializable, SignedPublicKey, SignedSecretKey};
+use base64::{engine::general_purpose, Engine as _};
+use ircparser;
+use pgp::crypto::sym::SymmetricKeyAlgorithm;
+use pgp::ser::Serialize;
+use pgp::{Deserializable, Message, SignedPublicKey, SignedSecretKey};
+use rand::prelude::*;
 use std::collections::HashMap;
-use std::fs;
+use std::net::{Shutdown, TcpStream};
 use std::sync::mpsc;
 use std::thread;
 use std::time::Duration;
-use toml::Table;
+use std::{env, fs};
 
-mod client_handler;
-mod encryption;
-mod helpers;
 mod listener_server;
-mod server_handler;
 mod writer_client;
 
-fn main() -> Result<()> {
-    let config_file = config_local_dir()
-        .expect("Couldn't get config directory")
-        .join("e2e-irc/config.toml");
-
-    if !config_file.exists() {
-        panic!("Create a config file at {}", config_file.display());
+macro_rules! try_recv {
+    ($rx:ident) => {
+        match $rx.try_recv() {
+            Ok(recieved) => recieved,
+            Err(_e) => match _e {
+                mpsc::TryRecvError::Empty => String::new(),
+                mpsc::TryRecvError::Disconnected => {
+                    panic!("Error!")
+                }
+            },
+        }
+    };
 }
 
-    let parsed_config = String::from_utf8_lossy(&fs::read(config_file)?).parse::<Table>()?;
-
-    let public_key_location = parsed_config
-        .get("public_key")
-        .expect("Coudln't get public_key. Try creating it in the config")
-        .as_str()
-        .expect("Couldn't convert public_key to str");
-    let secret_key_location = parsed_config
-        .get("secret_key")
-        .expect("Coudln't get secret_key. Try creating it in the config")
-        .as_str()
-        .expect("Couldn't convert secret_key to str");
-
-    let default_password = toml::Value::String(String::new());
-
-    let passwd = parsed_config
-        .get("passwd")
-        .unwrap_or(&default_password)
-        .as_str()
-        .expect("Coudln't convert passwd to str");
-
-    let mut server = "irc.vanten-s.com".to_string();
-    let mut port = "6666".to_string();
-    let mut server_port = "6697".to_string();
-
+fn bytes_to_privmsg_base64(message: Vec<u8>, reciever: &str) -> String {
+    let mut command = String::new();
+    for line in general_purpose::STANDARD
+        .encode(message)
+        .chars()
+        .collect::<Vec<char>>()
+        .chunks(500)
+        .map(|c| c.iter().collect::<String>())
     {
-        let mut ap = ArgumentParser::new();
-        ap.set_description("Encrypted IRC Bouncer");
-        ap.refer(&mut server)
-            .add_argument(
-                "server",
-                Store,
-                "The Address Of The Server The Bouncer Connects To",
-            )
-            .required();
-        ap.refer(&mut port)
-            .add_option(&["-p", "--port"], Store, "The Port The Bouncer Binds To");
-        ap.refer(&mut server_port).add_option(
-            &["--sp", "--server-port"],
-            Store,
-            "The TLS Enabled Port Of The Server",
-        );
-        ap.parse_args_or_exit();
+        command.push_str(&format!("PRIVMSG {reciever} :{line}\r\n"));
     }
 
-    let public_key = fs::read(public_key_location)?;
-    let secret_key = SignedSecretKey::from_bytes(fs::read(secret_key_location)?.as_slice())?;
+    println!("{}", command);
+    command
+}
+
+fn encrypt(key: &SignedPublicKey, message: &str) -> Result<Vec<u8>, pgp::errors::Error> {
+    let message = Message::new_literal("none", message);
+    let mut rng = StdRng::from_entropy();
+
+    let message = message.encrypt_to_keys(&mut rng, SymmetricKeyAlgorithm::AES128, &[key])?;
+
+    Ok(message.to_bytes()?)
+}
+
+fn decrypt<'a>(
+    key: &'a SignedSecretKey,
+    message: Vec<u8>,
+    password: &'a str,
+) -> Result<String, pgp::errors::Error> {
+    let message = Message::from_bytes(message.as_slice())?; // Convert message bytes to message object
+    let message = message.decrypt(|| password.to_string(), &[key])?.0; // Decrypt
+    let message = message.map(|x| x.unwrap()).collect::<Vec<Message>>(); // Get all messages
+    let message = &message[0]; // Get first message
+    let message = message.get_content()?.unwrap_or(Vec::new()); // Get message content as Vec<u8>
+    let message = String::from_utf8(message).unwrap(); // Convert to String
+
+    Ok(message)
+}
+
+fn get_nick(userstring: &str) -> String {
+    let userstring = userstring.chars().collect::<Vec<char>>();
+    let start_pos = userstring.iter().position(|&x| x == ':').unwrap() + 1;
+    let end_pos = userstring.iter().position(|&x| x == '!').unwrap();
+    userstring[start_pos..end_pos].iter().collect::<String>()
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut args = env::args().collect::<Vec<String>>();
+
+    let server = args[1].clone();
+    let port = args[2].clone();
+
+    let default_password = String::new();
+    let passwd = args.pop().unwrap_or(default_password);
+
+    let stream = TcpStream::connect(format!("{server}:6697"))?;
+
+    let public_key = fs::read("public.gpg")?;
+    let secret_key = SignedSecretKey::from_bytes(fs::read("secret.gpg")?.as_slice())?;
+
+    let reader_stream = match stream.try_clone() {
+        Ok(stream) => stream,
+        Err(_error) => {
+            let _ = stream.shutdown(Shutdown::Both);
+            panic!("Failed to create the reader stream")
+        }
+    };
+
+    let writer_stream = match stream.try_clone() {
+        Ok(stream) => stream,
+        Err(_error) => {
+            let _ = stream.shutdown(Shutdown::Both);
+            let _ = reader_stream.shutdown(Shutdown::Both);
+            panic!("Failed to create the writer stream")
+        }
+    };
 
     let (listener_channel_send_tx, listener_channel_rx) = mpsc::channel();
     let (listener_channel_tx, listener_channel_recv_rx) = mpsc::channel();
@@ -80,71 +112,175 @@ fn main() -> Result<()> {
     let (writer_channel_tx, writer_channel_send_rx) = mpsc::channel();
     let (writer_channel_recv_tx, writer_channel_rx) = mpsc::channel();
 
-    let tmp_port = port.clone();
     thread::spawn(move || {
-        listener_server::listen_to_client(
-            listener_channel_send_tx,
-            listener_channel_recv_rx,
-            tmp_port,
-        )
+        listener_server::listen_to_client(listener_channel_send_tx, listener_channel_recv_rx, &port)
     });
-    let tmp_port = server_port.clone();
     let tmp_server = server.clone();
-    thread::spawn(move || {
+    thread::spawn(|| {
         writer_client::write_to_server(
-            &tmp_server,
-            &tmp_port,
+            writer_stream,
+            tmp_server,
             writer_channel_send_rx,
             writer_channel_recv_tx,
         )
     });
 
     let mut keys: HashMap<String, SignedPublicKey> = HashMap::new();
-    let mut state = State::new();
+    let mut userstring = String::new();
 
     loop {
-        match listener_channel_rx.try_recv() {
-            Ok(message) => {
-                let _ = client_handler::handle_message_from_client(
-                    &message,
-                    &public_key,
-                    &server,
-                    &mut keys,
-                    &writer_channel_tx,
-                    &writer_channel_rx,
-                    &listener_channel_tx,
-                    &listener_channel_rx,
-                    &mut state,
-                );
-            }
-            Err(error) => match error {
-                mpsc::TryRecvError::Empty => {}
-                mpsc::TryRecvError::Disconnected => panic!("listener_channel_rx disconnected"),
-            },
-        };
+        let recieved = try_recv!(listener_channel_rx);
 
-        match writer_channel_rx.try_recv() {
-            Ok(message) => {
-                let _ = server_handler::handle_message_from_server(
-                    &message,
-                    &public_key,
-                    &secret_key,
-                    &server,
-                    passwd,
-                    &mut keys,
-                    &writer_channel_tx,
-                    &writer_channel_rx,
-                    &listener_channel_tx,
-                    &listener_channel_rx,
-                    &state,
-                );
-            }
-            Err(error) => match error {
-                mpsc::TryRecvError::Empty => {}
-                mpsc::TryRecvError::Disconnected => panic!("writer_channel_rx disconnected"),
-            },
-        };
+        if !recieved.is_empty() {
+            let command = &ircparser::parse(&recieved).expect("Got an invalid IRC instruction")[0];
 
-        thread::sleep(Duration::from_millis(1));
+            if command.command == "PRIVMSG" && !command.params[0].starts_with("#") {
+                let reciever = &command.params[0];
+                if !keys.contains_key(reciever) {
+                    writer_channel_tx.send(format!("PRIVMSG {reciever} :START_KEY\r\n"))?;
+
+                    writer_channel_tx
+                        .send(bytes_to_privmsg_base64(public_key.clone(), reciever))?;
+                    writer_channel_tx.send(format!("PRIVMSG {reciever} :END_KEY\r\n"))?;
+
+                    let mut foreign_key: Vec<String> = Vec::new();
+                    while !foreign_key.contains(&"END_KEY".to_string()) {
+                        let recieved_raw = writer_channel_rx.recv()?;
+
+                        let recieved = &ircparser::parse(&recieved_raw).unwrap()[0];
+                        let begin_source_reciever = format!(":{reciever}!");
+                        if recieved.command != "PRIVMSG"
+                            || !recieved
+                                .source
+                                .clone()
+                                .unwrap_or("".to_string())
+                                .starts_with(&begin_source_reciever)
+                        {
+                            listener_channel_tx.send(recieved_raw)?;
+                            continue;
+                        }
+
+                        foreign_key.push(recieved.params[1].clone());
+                    }
+                    foreign_key.pop();
+
+                    println!("Got a foreign key from {reciever}");
+                    let foreign_key = foreign_key.concat();
+                    dbg!(&foreign_key);
+
+                    let foreign_key = general_purpose::STANDARD.decode(foreign_key)?;
+
+                    dbg!("It's decoded");
+
+                    let key = SignedPublicKey::from_bytes(foreign_key.as_slice())?;
+
+                    dbg!("And I now got it's SignedPublicKey format");
+
+                    keys.insert(reciever.to_string(), key);
+                }
+
+                let foreign_key = keys.get(reciever).unwrap();
+
+                writer_channel_tx.send(format!("PRIVMSG {reciever} START_MESSAGE\r\n"))?;
+                writer_channel_tx.send(bytes_to_privmsg_base64(
+                    encrypt(&foreign_key, &command.params[1])?,
+                    reciever,
+                ))?;
+                writer_channel_tx.send(format!("PRIVMSG {reciever} END_MESSAGE\r\n"))?;
+            } else {
+                writer_channel_tx.send(recieved.replace("127.0.0.1", &server))?;
+            }
+        }
+
+        let recieved = try_recv!(writer_channel_rx);
+        if !recieved.is_empty() {
+            let recieved_parsed = &ircparser::parse(&recieved).unwrap()[0];
+
+            if recieved_parsed.command != "PRIVMSG"
+                || recieved_parsed
+                    .params
+                    .get(0)
+                    .unwrap_or(&String::new())
+                    .starts_with("#")
+            {
+                listener_channel_tx.send(recieved.replace(&server, "127.0.0.1"))?;
+                continue;
+            }
+            
+            dbg!(&recieved_parsed);
+
+            if recieved_parsed.params[1] == "START_MESSAGE" {
+                let reciever = get_nick(&recieved_parsed.source.clone().unwrap());
+                let sample_privmsg = recieved.clone();
+
+                let mut encrypted_message: Vec<String> = Vec::new();
+                while !encrypted_message.contains(&"END_MESSAGE".to_string()) {
+                    let recieved_raw = writer_channel_rx.recv()?;
+                    let recieved = &ircparser::parse(&recieved_raw).unwrap()[0];
+
+                    let begin_source_reciever = format!(":{reciever}!");
+                    if recieved.command != "PRIVMSG"
+                        || !recieved
+                            .source
+                            .clone()
+                            .unwrap_or("".to_string())
+                            .starts_with(&begin_source_reciever)
+                    {
+                        listener_channel_tx.send(recieved_raw.replace(&server, "127.0.0.1"))?;
+                        continue;
+                    }
+
+                    encrypted_message.push(recieved.params[1].clone());
+                }
+                encrypted_message.pop();
+
+                let encrypted_message = encrypted_message.join("");
+                let encrypted_message = general_purpose::STANDARD.decode(encrypted_message)?;
+
+                let decrypted_message = decrypt(&secret_key, encrypted_message, &passwd)?;
+                listener_channel_tx
+                    .send(sample_privmsg.replace("START_MESSAGE", &decrypted_message))?;
+            } else if recieved_parsed.params[1] == "START_KEY" {
+                let reciever = get_nick(&recieved_parsed.source.clone().unwrap());
+                let to_send = bytes_to_privmsg_base64(public_key.clone(), &reciever);
+                writer_channel_tx.send(to_send)?;
+                writer_channel_tx.send(format!("PRIVMSG {reciever} END_KEY\r\n"))?;
+
+                dbg!("Started Getting a key");
+                let reciever = get_nick(&recieved_parsed.source.clone().unwrap());
+                let mut foreign_key: Vec<String> = Vec::new();
+                while !foreign_key.contains(&"END_KEY".to_string()) {
+                    let recieved_raw = writer_channel_rx.recv()?;
+
+                    let recieved = &ircparser::parse(&recieved_raw).unwrap()[0];
+                    let begin_source_reciever = format!(":{reciever}!");
+                    if recieved.command != "PRIVMSG"
+                        || !recieved
+                            .source
+                            .clone()
+                            .unwrap_or("".to_string())
+                            .starts_with(&begin_source_reciever)
+                    {
+                        listener_channel_tx.send(recieved_raw.replace(&server, "127.0.0.1"))?;
+                        continue;
+                    }
+
+                    foreign_key.push(recieved.params[1].clone());
+                }
+                foreign_key.pop();
+                dbg!("Got a foreign key from");
+                dbg!(&reciever);
+
+                let foreign_key = foreign_key.concat();
+
+                let foreign_key = general_purpose::STANDARD.decode(foreign_key)?;
+                dbg!("Decoded the key");
+
+                let key = SignedPublicKey::from_bytes(foreign_key.as_slice())?;
+                dbg!("Deserialized the key");
+
+                keys.insert(reciever.to_string(), key);
+            }
+        }
     }
 }

src/server_handler.rs

@@ -1,87 +0,0 @@
-use crate::unwrap_or_return_option;
-use crate::unwrap_or_return_result;
-use crate::State;
-use crate::{encryption, helpers};
-use eyre::Result;
-use pgp::{Deserializable, SignedPublicKey, SignedSecretKey};
-use std::collections::HashMap;
-use std::sync::mpsc::{self, Receiver, Sender};
-
-fn forward(
-    message: &str,
-    listener_channel_tx: &Sender<String>,
-    server: &str,
-) -> Result<(), mpsc::SendError<String>> {
-    listener_channel_tx.send(message.replace(server, "127.0.0.1"))
-}
-
-pub fn handle_message_from_server(
-    recieved: &str,
-    public_key: &Vec<u8>,
-    secret_key: &SignedSecretKey,
-    server: &str,
-    passwd: &str,
-    keys: &mut HashMap<String, SignedPublicKey>,
-    writer_channel_tx: &Sender<String>,
-    writer_channel_rx: &Receiver<String>,
-    listener_channel_tx: &Sender<String>,
-    _listener_channel_rx: &Receiver<String>,
-    state: &State,
-) -> Result<()> {
-    let recieved_parsed = &unwrap_or_return_result!(ircparser::parse(recieved))[0];
-
-    let default_reciever = String::new();
-
-    let reciever = match recieved_parsed.params.get(0) {
-        Some(val) => val,
-        None => &default_reciever,
-    };
-
-    if recieved_parsed.command != "PRIVMSG"
-        || reciever.starts_with('#')
-        || state.nicks_without_encryption.contains(reciever)
-    {
-        forward(recieved, listener_channel_tx, server)?;
-        return Ok(());
-    }
-
-    dbg!(&recieved_parsed);
-
-    let source = unwrap_or_return_option!(&recieved_parsed.source);
-
-    if recieved_parsed.params[1] == "START_MESSAGE" {
-        let sender = unwrap_or_return_option!(helpers::get_nick(source));
-
-        let message = helpers::recieve_message_base64(
-            writer_channel_rx,
-            listener_channel_tx,
-            server,
-            "127.0.0.1",
-            &sender,
-            "END_MESSAGE",
-        )?; // Get
-        let message = encryption::decrypt(secret_key, &message, passwd)?; // Decrypt
-
-        listener_channel_tx.send(recieved.replace("START_MESSAGE", &message))?; // Send
-    } else if recieved_parsed.params[1] == "START_KEY" {
-        let sender = unwrap_or_return_option!(helpers::get_nick(source));
-        let to_send = helpers::bytes_to_privmsg_base64(public_key, &sender);
-        writer_channel_tx.send(to_send)?;
-        writer_channel_tx.send(format!("PRIVMSG {sender} END_KEY\r\n"))?;
-
-        let foreign_key = helpers::recieve_message_base64(
-            writer_channel_rx,
-            listener_channel_tx,
-            server,
-            "127.0.0.1",
-            &sender,
-            "END_KEY",
-        )?;
-        dbg!(&foreign_key);
-        let key = SignedPublicKey::from_bytes(foreign_key.as_slice())?;
-        println!("Got a key from {sender}");
-        keys.insert(sender.to_string(), key);
-    }
-
-    Ok(())
-}

src/writer_client.rs

@@ -2,23 +2,16 @@ use openssl::ssl::{SslConnector, SslMethod};
 use std::io::{ErrorKind, Write};
 use std::net::TcpStream;
 use std::sync::mpsc;
-use std::thread;
-use std::time::Duration;
 
 pub fn write_to_server(
-    server: &str,
-    port: &str,
+    tcp_stream: TcpStream,
+    server: String,
     rx: mpsc::Receiver<String>,
     tx: mpsc::Sender<String>,
 ) {
-    'big: loop {
-        println!("Connecting to {server}:{port}");
-        let tcp_stream =
-            TcpStream::connect(format!("{server}:{port}")).expect("Couldn't connect to server");
-
     let connector = SslConnector::builder(SslMethod::tls()).unwrap().build();
     let mut stream = connector
-            .connect(server, &tcp_stream)
+        .connect(&server, tcp_stream)
         .expect("Couldn't start TLS");
 
     stream
@@ -40,34 +33,24 @@ pub fn write_to_server(
                 }
                 Err(_error) => match _error.io_error() {
                     None => {
-                            dbg!(_error.ssl_error());
-                            continue 'big;
+                        dbg!(_error);
                     }
                     Some(error) => match error.kind() {
                         ErrorKind::WouldBlock => {}
                         _ => {
                             dbg!(error.kind());
                             println!("Couldn't read the stream");
-                                continue 'big;
                         }
                     },
                 },
             }
             let value = rx.try_recv().unwrap_or("".to_string());
-                match value.as_str() {
-                    "DUMMY CLOSE_CONNECTION" => {
-                        continue 'big;
-                    }
-                    _ => {}
-                }
             match stream.write_all(value.as_bytes()) {
                 Ok(_) => {}
                 Err(_e) => println!("Couldn't send {value}"),
             };
-                thread::sleep(Duration::from_micros(100));
         }
 
         let _ = tx.send(dbg!(String::from_utf8_lossy(&buffer).to_string()));
     }
 }
-}