vanten-s/e2e-irc
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases 5 Wiki Activity

Merge pull request 'Version 1' (#1) from dev-laptop into main

Browse source 
Reviewed-on: vanten-s/irc-e2e#1
This commit is contained in:
vanten-s 2023-10-07 14:25:15 +02:00
parent cc36c3dce5 518b275bd9
commit 004eeeac06
3 changed files with 48 additions and 46 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
src/listener_server.rs
View file

@ -1,15 +1,14 @@
use std::io::{self, Read, Write};
use std::io::{ErrorKind, Read, Write};
use std::net::TcpListener;
use std::sync::mpsc;
use std::time::Duration;
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_read_timeout(Some(Duration::from_millis(10)))
.expect("Couldn't set timeout!!");
.set_nonblocking(true)
.expect("Couldn't set nonblocking");
loop {
let mut buffer: Vec<u8> = Vec::new();
@ -18,15 +17,14 @@ pub fn listen_to_client(tx: mpsc::Sender<String>, rx: mpsc::Receiver<String>, po
while buf[0] != newline {
match stream.read(&mut buf) {
Ok(_length) => {
buffer.push(buf[0]);
}
Ok(_length) => buffer.push(buf[0]),
Err(_error) => match _error.kind() {
io::ErrorKind::TimedOut => {}
_ => {}
ErrorKind::WouldBlock => {},
_ => {
dbg!(_error);
}
},
}
match rx.try_recv() {
Ok(value) => {
match stream.write_all(value.as_bytes()) {

41
src/main.rs
View file

@ -8,11 +8,10 @@ use std::collections::HashMap;
use std::net::{Shutdown, TcpStream};
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
use std::{env, fs};
mod encryption;
mod listener_server;
mod message_stream;
mod writer_client;
macro_rules! try_recv {
@ -127,7 +126,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
});
let mut keys: HashMap<String, SignedPublicKey> = HashMap::new();
let mut userstring: Option<String> = None;
let mut userstring = String::new();
loop {
let recieved = try_recv!(listener_channel_rx);
@ -138,9 +137,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
if command.command == "PRIVMSG" && !command.params[0].starts_with("#") {
let reciever = &command.params[0];
if !keys.contains_key(reciever) {
dbg!(recieved);
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"))?;
@ -162,16 +160,22 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
continue;
}
foreign_key.push(dbg!(recieved.params[1].clone()));
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);
}
@ -184,14 +188,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
))?;
writer_channel_tx.send(format!("PRIVMSG {reciever} END_MESSAGE\r\n"))?;
} else {
dbg!(&recieved);
writer_channel_tx.send(recieved.replace("127.0.0.1", &server))?;
}
}
let recieved = try_recv!(writer_channel_rx);
if !recieved.is_empty() {
dbg!(&recieved);
let recieved_parsed = &ircparser::parse(&recieved).unwrap()[0];
if recieved_parsed.command != "PRIVMSG"
@ -204,6 +206,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
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());
@ -222,7 +226,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
.unwrap_or("".to_string())
.starts_with(&begin_source_reciever)
{
listener_channel_tx.send(recieved_raw)?;
listener_channel_tx.send(recieved_raw.replace(&server, "127.0.0.1"))?;
continue;
}
@ -237,6 +241,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
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()) {
@ -251,26 +261,25 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
.unwrap_or("".to_string())
.starts_with(&begin_source_reciever)
{
listener_channel_tx.send(recieved_raw)?;
listener_channel_tx.send(recieved_raw.replace(&server, "127.0.0.1"))?;
continue;
}
foreign_key.push(recieved.params[1].clone());
}
foreign_key.pop();
println!("Got a foreign key from {reciever}");
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);
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"))?;
}
}
}

35
src/writer_client.rs
View file

@ -2,7 +2,6 @@ use openssl::ssl::{SslConnector, SslMethod};
use std::io::{ErrorKind, Write};
use std::net::TcpStream;
use std::sync::mpsc;
use std::time::Duration;
pub fn write_to_server(
tcp_stream: TcpStream,
@ -10,15 +9,16 @@ pub fn write_to_server(
rx: mpsc::Receiver<String>,
tx: mpsc::Sender<String>,
) {
tcp_stream
.set_read_timeout(Some(Duration::from_millis(10)))
.expect("Couldn't set timeout!!");
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
.get_mut()
.set_nonblocking(true)
.expect("Failed to set nonblocking");
loop {
let mut buffer: Vec<u8> = Vec::new();
let mut buf: [u8; 1] = [0];
@ -27,15 +27,15 @@ pub fn write_to_server(
while buf[0] != newline {
match stream.ssl_read(&mut buf) {
Ok(_length) => {
buffer.push(buf[0]);
if _length > 0 {
buffer.push(buf[0]);
}
}
Err(_error) => match _error.io_error() {
None => {
dbg!(_error);
panic!("TLS Error")
}
Some(error) => match error.kind() {
ErrorKind::TimedOut => {}
ErrorKind::WouldBlock => {}
_ => {
dbg!(error.kind());
@ -44,18 +44,13 @@ pub fn write_to_server(
},
},
}
match rx.try_recv() {
Ok(value) => {
match stream.write_all(value.as_bytes()) {
Ok(_) => {}
Err(_e) => println!("Couldn't send {value}"),
};
}
Err(_e) => {}
}
let value = rx.try_recv().unwrap_or("".to_string());
match stream.write_all(value.as_bytes()) {
Ok(_) => {}
Err(_e) => println!("Couldn't send {value}"),
};
}
let _ = tx.send(String::from_utf8_lossy(&buffer).to_string());
let _ = tx.send(dbg!(String::from_utf8_lossy(&buffer).to_string()));
}
}