update

Author: pureblack

Cargo.lock

@@ -6,6 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-rust-crypto = "0.2"
+rust-crypto = "^0.2"
 gtk = "0.9"
 ring = "0.16"
+glib-sys = "0.10.1"

Cargo.toml

@@ -1,19 +1,8 @@
 use std::net::UdpSocket;
-const PROJECT_NAME: &str = "BLANE";
-const AUTHOR_NAME: &str = "PURE BLACK";
+
 pub struct Client {
     socket: UdpSocket,
     server_address: String,
-    pub fn receive_message(&self) -> Result<String, String> {
-        let mut buffer = [0u8; 1024];
-        match self.socket.recv_from(&mut buffer) {
-            Ok((bytes_read, _)) => {
-                let message = String::from_utf8_lossy(&buffer[..bytes_read]).to_string();
-                Ok(message)
-            }
-            Err(e) => Err(format!("Failed to receive message: {}", e)),
-        }
-    }
 }
 
 impl Client {
@@ -44,5 +33,16 @@ impl Client {
         Ok(())
     }
 
+    pub fn receive_message(&self) -> Result<String, String> {
+        let mut buffer = [0u8; 1024];
+        match self.socket.recv_from(&mut buffer) {
+            Ok((bytes_read, _)) => {
+                let message = String::from_utf8_lossy(&buffer[..bytes_read]).to_string();
+                Ok(message)
+            }
+            Err(e) => Err(format!("Failed to receive message: {}", e)),
+        }
+    }
+
     // Other methods
 }

src/chat/client.rs

@@ -1,24 +1,9 @@
 use std::net::{SocketAddr, UdpSocket};
 use std::collections::HashMap;
-const PROJECT_NAME: &str = "BLANE";
-const AUTHOR_NAME: &str = "PURE BLACK";
+
 pub struct Server {
     socket: UdpSocket,
     clients: HashMap<SocketAddr, String>,
-    pub fn handle_new_connection(&mut self, client_addr: SocketAddr, client_name: String) {
-        self.clients.insert(client_addr, client_name);
-        println!("New client connected: {}", client_name);
-    }
-
-    pub fn handle_client_disconnection(&mut self, client_addr: SocketAddr) {
-        if let Some(client_name) = self.clients.remove(&client_addr) {
-            println!("Client disconnected: {}", client_name);
-        }
-    }
-
-    pub fn get_online_clients(&self) -> Vec<String> {
-        self.clients.values().cloned().collect()
-    }
 }
 
 impl Server {
@@ -41,7 +26,6 @@ impl Server {
                     let message = String::from_utf8_lossy(&buffer[..bytes_read]);
                     println!("Received message from {}: {}", src_addr, message);
 
-                    // Broadcast the message to all clients
                     self.broadcast_message(&message)?;
                 }
                 Err(e) => {
@@ -50,11 +34,24 @@ impl Server {
                     }
                 }
             }
+        }
+    }
 
-            // Other server logic (e.g., handle new connections, manage clients)
+    pub fn handle_new_connection(&mut self, client_addr: SocketAddr, client_name: &str) {
+        self.clients.insert(client_addr, client_name.to_string());
+        println!("New client connected: {}", client_name);
+    }
+
+    pub fn handle_client_disconnection(&mut self, client_addr: SocketAddr) {
+        if let Some(client_name) = self.clients.remove(&client_addr) {
+            println!("Client disconnected: {}", client_name);
         }
     }
 
+    pub fn get_online_clients(&self) -> Vec<String> {
+        self.clients.values().cloned().collect()
+    }
+
     pub fn broadcast_message(&self, message: &str) -> Result<(), String> {
         for client_addr in self.clients.keys() {
             self.socket
@@ -64,6 +61,4 @@ impl Server {
 
         Ok(())
     }
-
-    // Other methods
 }

src/chat/server.rs

@@ -1,12 +1,12 @@
 extern crate crypto;
-
+extern crate ring;
 use crypto::rsa::{RsaPrivateKey, RsaPublicKey};
 use crypto::symmetriccipher::SymmetricCipherError;
 use crypto::buffer::{ReadBuffer, WriteBuffer, BufferResult};
 use crypto::aes::{cbc_decryptor, cbc_encryptor, KeySize};
 use crypto::blockmodes::NoPadding;
+use std::io::Write;
 
-// RSA 加密
 fn rsa_encrypt(public_key: &RsaPublicKey, plaintext: &[u8]) -> Result<Vec<u8>, SymmetricCipherError> {
     let mut ciphertext = vec![0; public_key.size()];
 
@@ -28,7 +28,6 @@ fn rsa_encrypt(public_key: &RsaPublicKey, plaintext: &[u8]) -> Result<Vec<u8>, S
     }
 }
 
-// RSA 解密
 fn rsa_decrypt(private_key: &RsaPrivateKey, ciphertext: &[u8]) -> Result<Vec<u8>, SymmetricCipherError> {
     let mut plaintext = vec![0; private_key.size()];
 
@@ -51,17 +50,16 @@ fn rsa_decrypt(private_key: &RsaPrivateKey, ciphertext: &[u8]) -> Result<Vec<u8>
 }
 
 fn main() {
-    // 生成 RSA 密钥对
     let (private_key, public_key) = RsaPrivateKey::new(512).keypair();
 
     let message = b"Hello, world!";
-    println!("Original message: {:?}", message);
+    println!("Original message: {:?}", std::str::from_utf8(message).unwrap());
 
-    // 使用公钥加密消息
     let encrypted_message = rsa_encrypt(&public_key, message).unwrap();
     println!("Encrypted message: {:?}", encrypted_message);
 
-    // 使用私钥解密消息
     let decrypted_message = rsa_decrypt(&private_key, &encrypted_message).unwrap();
-    println!("Decrypted message: {:?}", decrypted_message);
+    println!("Decrypted message: {:?}", std::str::from_utf8(&decrypted_message).unwrap());
+
+    std::io::stdout().flush().unwrap();
 }

src/encryption.rs

@@ -1,55 +1,42 @@
-// Project: BLANE
-// Author: PURE BLACK
-const PROJECT_NAME: &str = "BLANE";
-const AUTHOR_NAME: &str = "PURE BLACK";
-
-
-mod chat;
-mod encryption;
-
-use std::io::{self, Write};
-use std::thread;
+use std::io::Write;
+mod chat {
+    pub mod client;
+    pub mod server;
+}
 
-use chat::{Client, Server};
+use chat::client::Client;
+use chat::server::Server;
 
 fn main() {
-    // 获取服务器地址和客户端名称
     let server_address = "127.0.0.1:14514";
-    let client_name = "Alice";
+    let _client_name = "Black";
 
-    // 创建客户端实例并连接到服务器
     let client = Client::new(server_address).expect("Failed to create client");
     client.connect().expect("Failed to connect to server");
 
-    // 创建服务器实例并启动服务器
     let server = Server::new(server_address).expect("Failed to create server");
-    let server_handle = thread::spawn(move || {
+    let _server_handle = std::thread::spawn(move || {
         server.start().expect("Failed to start server");
     });
 
-    // 在主线程中处理客户端输入和接收消息
     println!("Connected to server. You can start sending messages.");
+    println!("您以上线，请畅所欲言！");
 
     loop {
         print!("> ");
-        io::stdout().flush().unwrap();
+        std::io::stdout().flush().unwrap();
 
         let mut input = String::new();
-        io::stdin().read_line(&mut input).unwrap();
+        std::io::stdin().read_line(&mut input).unwrap();
         let message = input.trim();
 
         if message.is_empty() {
             continue;
         }
 
-        // 发送消息给服务器
         client.send_message(message).expect("Failed to send message");
 
-        // 接收服务器广播的消息
         let received_message = client.receive_message().expect("Failed to receive message");
         println!("Received message: {}", received_message);
     }
-
-    // 等待服务器线程结束
-    server_handle.join().expect("Server thread panicked");
 }