Merge remote-tracking branch 'origin/master'

protokoll.txt

@@ -0,0 +1,129 @@
+Nachrichtaufbau:
+================
+
+  u32 src_id  // inserted by server
+  u32 dest_id // 0: to all
+  u16 size    // min: 4
+  u8 payload[size]
+
+  payload[0]: type
+  KEY_LENGTH=32
+
+Payloads:
+=========
+
+  0-31 system messages (plaintext)
+
+  0   reserved
+  1   PING
+      size: 4
+      u8 type, pad1, pad2, pad3;
+  2   PONG
+      size: 4
+      u8 type, pad1, pad2, pad3;
+  3   ERROR
+      size: 4+len
+      u8 type, severity;
+      u16 code;
+      u8 msg[len];
+
+  32-63 server side messages (currently plaintext)
+
+  32  INIT           // first msg from server to new connection
+      size: 4 + 4*count
+      u8 type, pad1;
+      u16 count;     // including own; own id is in dest_id
+      u32 ids[count];
+  33  JOIN           // sent by server; joining id is src_id
+      size: 4
+      u8 type, pad1, pad2, pad3;
+  34  EXIT           // sent by server; exiting id is src_id
+      size: 4
+      u8 type, pad1, pad2, pad3;
+
+  64-95 initial setup messages (plaintext)
+
+  64  DH_SETUP  // setup secure channel client->client
+      size: 4 + ?
+      u8 type, cryptotype, pad2, pad3;
+      remainder impl-dependend
+  65  DH_RETURN
+      size: 4 + ?
+      u8 type, cryptotype, pad2, pad3;
+      remainder impl-dependend
+
+  96-127 client-client setup messages (DH or old KEY encrypted)
+
+  96  AUTHORIZE
+      T.B.D.
+  97  KEY_CURRENT
+      size: 4 + KEY_LENGTH
+      u8 type, pad1, pad2, pad3;
+      u8 key[KEY_LENGTH];
+  98  KEY_NEW
+      size: 4 + KEY_LENGTH
+      u8 type, pad1, pad2, pad3;
+      u8 key[KEY_LENGTH];
+
+  128-159 main messages (shared KEY encrypted)
+
+  128 MSG
+      size: 4 + ?
+      u8 type, pad1;
+      u16 generation;  // which key generation is used. Increasing monotonously, until overflow
+      u8 msg[];
+
+  160-255 reserved
+
+
+Funktionalität:
+===============
+
+- Server: Pakete an alle weiterleiten (dest_id==0) bzw. an nur einen Client (dest_id)
+          Bei Verbindungsaufbau: Liste aller Clients (Nummern) und eigene Nr (Zufallszahl), JOIN an alle
+          Bei Verbindungsverlust: EXIT an alle
+
+- Client: Eigentliche Funktionalität
+
+
+Funktionsweise:
+
+Client: Neue Verbindung
+  - warten auf INIT
+    Liste der Clients merken
+  - Jetzt nur Kommunikation mit zufälligem Client
+  - -> DH_SETUP
+    <- DH_RETURN   -> client-client DH_KEY
+    <- KEY_CURRENT (mit DH_KEY verschlüsselt)
+    -> KEY_NEW an alle (mit KEY_CURRENT verschlüsselt)
+  - Wenn an irgendeiner Stelle Timeout -> nochmal von vorne mit neuem Client
+
+Nachrichten:
+  - JOIN
+    Liste der Clients updaten
+  - EXIT
+    Liste der Clients updaten
+  - DH_SETUP
+    siehe oben -> DH_RETURN, KEY_CURRENT
+  - KEY_NEW
+    Alter KEY xor KEY_NEW -> neuer KEY, generation++
+  - MSG
+    generation prüfen, wenn > aktueller, warten auf KEY_NEW etc. (Zwischenspeichern, TODO)
+    entschlüsseln, MAC prüfen, anzeigen
+  - ERROR
+    code + msg ausgeben,
+    severity >= 64  Key neu aushandeln (TODO),
+             >= 96  Verbindung neu aufbauen (TODO),
+             >= 128 Exit
+
+Nachricht schicken:
+  MSG erstellen, Plaintext mit KEY verschlüsseln + MAC, generation einfügen
+
+
+Was fehlt / mögliche Fehler und Sicherheitsprobleme:
+====================================================
+
+- Keine Authentisierung - jeder kann reingrätschen
+- server side messages derzeit plaintext
+- keine Validierung (Zertifikate)
+- ...

src/bin/client.rs

@@ -4,11 +4,14 @@ use crypto_box::{
 };
 use std::io::Write;
 use std::net::TcpStream;
+use crate::message::*;
+
+mod message;
 
 fn main() {
-    let port: u32 = 7878; // Port Server
+    // Server Port
-                          //let stream = TcpStream::connect("172.30.16.1:8080");
+    let port: u32 = 7878;
-                          //let stream = TcpStream::connect("27.0.0.1:8080");
+
     match TcpStream::connect(format!("localhost:{}", port)) {
         Ok(mut stream) => {
             println!("Successfully connected to server");
@@ -49,6 +52,7 @@ fn main() {
 
                         // Encrypt the message using the box
                         let ciphertext = salsa_box.encrypt(&nonce, &plaintext[..]).expect("Fehler");
+                        let message = Message::new(0,0,4, PayloadType::Msg);
 
                         println!("Sending {0} as {1:?}", buffer.trim(), plaintext);
                         stream.write(buffer.as_bytes()).unwrap();
@@ -82,17 +86,3 @@ fn main() {
     }
     println!("Terminated.");
 }
-
-fn generate_box(partner_public_key: PublicKey) -> (SalsaBox, PublicKey) {
-    // Generate a random secret key.
-    // NOTE: The secret key bytes can be accessed by calling `secret_key.as_bytes()`
-    let own_secret_key = SecretKey::generate(&mut OsRng);
-
-    // Get the public key for the secret key we just generated
-    let own_public_key = own_secret_key.public_key().clone();
-
-    // Create a `SalsaBox` by performing Diffie-Hellman key agreement between
-    // the two keys.
-    let salsa_box = SalsaBox::new(&partner_public_key, &own_secret_key);
-    (salsa_box, own_public_key)
-}

src/bin/connection_pool.rs

@@ -46,9 +46,14 @@ impl ConnectionPool{
 
     pub fn broadcast(&self, sender_iid: &u32, msg: &String) {
         let mut del_conns: Vec<u32> = Vec::new();
+        let mut msg1: String;
+
+        msg1 = format!("User {sender_iid}: ").parse().unwrap();
+        msg1.push_str(msg);
+
         for (iid, mut conn) in self.conns.lock().unwrap().iter() {
             if sender_iid.ne(iid){
-                if conn.write_all(msg.as_bytes()).is_err() {
+                if conn.write_all(msg1.as_bytes()).is_err() {
                     del_conns.push(*iid);
                     continue;
                 }

src/bin/message.rs

@@ -1,3 +1,7 @@
+use std::{
+    io::{BufReader, Read},
+    net::TcpStream,
+};
 
 const KEYLENGTH: u8 = 32;
 
@@ -22,7 +26,7 @@ pub enum PayloadType {
     //160-255 reserved
 }
 
-struct Message {
+pub struct Message {
     // Eigenschaften der Klasse
     src_id: u32,
     dest_id: u32,
@@ -31,7 +35,7 @@ struct Message {
 }
 
 impl Message {
-    fn new(src_id: u32, dest_id: u32, size: u16, msg_type: PayloadType) -> Message {
+    pub fn new(src_id: u32, dest_id: u32, size: u16, msg_type: PayloadType) -> Message {
         let mut msg = Message {
             src_id: src_id,
             dest_id: dest_id,
@@ -62,34 +66,41 @@ impl Message {
         vec
     }
 
-    fn recive(input: Vec<u8>) -> Message {
+    fn receive(stream: TcpStream) -> Message {
-        let byte1 = input.get(0).expect("Fail to Read Byte 1");
+        let buffreader = BufReader::new(stream);
-        let byte2 = input.get(1).expect("Fail to Read Byte 2");
+        let mut byte_iterator = buffreader.bytes();
-        let byte3 = input.get(2).expect("Fail to Read Byte 3");
+        let byte1 = byte_iterator.next().unwrap().unwrap();
-        let byte4 = input.get(3).expect("Fail to Read Byte 4");
+        let byte2 = byte_iterator.next().unwrap().unwrap();
+        let byte3 = byte_iterator.next().unwrap().unwrap();
+        let byte4 = byte_iterator.next().unwrap().unwrap();
 
         let src_id: u32 =
             (byte1 << 24) as u32 | (byte2 << 16) as u32 | (byte3 << 8) as u32 | (byte4 << 0) as u32;
 
-        let byte5 = input.get(5).expect("Fail to Read Byte 5");
+        let byte5 = byte_iterator.next().unwrap().unwrap();
-        let byte6 = input.get(6).expect("Fail to Read Byte 6");
+        let byte6 = byte_iterator.next().unwrap().unwrap();
-        let byte7 = input.get(7).expect("Fail to Read Byte 7");
+        let byte7 = byte_iterator.next().unwrap().unwrap();
-        let byte8 = input.get(8).expect("Fail to Read Byte 8");
+        let byte8 = byte_iterator.next().unwrap().unwrap();
 
         let dest_id: u32 =
             (byte5 << 24) as u32 | (byte6 << 16) as u32 | (byte7 << 8) as u32 | (byte8 << 0) as u32;
 
-        let byte9 = input.get(9).expect("Fail to Read byte 9");
+        let byte9 = byte_iterator.next().unwrap().unwrap();
-        let byte10 = input.get(10).expect("Fail to Read byte 10");
+        let byte10 = byte_iterator.next().unwrap().unwrap();
 
         let size = (byte9 << 8) as u16 | (byte10 << 0) as u16;
         assert!(size > 0, "Ungültige size größe size = {}", size);
 
+        let mut payload = Vec::<u8>::new();
+        for i in 0..size {
+            payload.push(byte_iterator.next().unwrap().unwrap());
+        }
+
         Message {
             src_id: src_id,
             dest_id: dest_id,
             size: size,
-            payload: (&input[11..]).to_vec(),
+            payload: payload,
         }
     }
     // Methoden der Klasse