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,10 +1,7 @@
-<<<<<<< HEAD
 use std::{
     io::{BufReader, Read},
     net::TcpStream,
 };
-=======
->>>>>>> f36772d9e5c0507015de02b8c71ff25d84789b98
 
 const KEYLENGTH: u8 = 32;
 
@@ -29,7 +26,7 @@ pub enum PayloadType {
     //160-255 reserved
 }
 
-struct Message {
+pub struct Message {
     // Eigenschaften der Klasse
     src_id: u32,
     dest_id: u32,
@@ -38,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,
@@ -69,7 +66,7 @@ impl Message {
         vec
     }
 
-    fn recive(stream: TcpStream) -> Message {
+    fn receive(stream: TcpStream) -> Message {
         let buffreader = BufReader::new(stream);
         let mut byte_iterator = buffreader.bytes();
         let byte1 = byte_iterator.next().unwrap().unwrap();