refactor: use openssl for seed

Author: peter-jerry-ye

examples/websocket_client/main.mbt

@@ -42,9 +42,7 @@ pub async fn connect_to_echo_server() -> Unit {
     // Receive echo response
     let response = client.receive()
     match response {
-      @websocket.Text(text) => {
-        println("Received: \{text}")
-      }
+      @websocket.Text(text) => println("Received: \{text}")
       @websocket.Binary(data) =>
         println("Received binary data (\{data.length()} bytes)")
     }
@@ -60,19 +58,11 @@ pub async fn connect_to_echo_server() -> Unit {
   client.send_binary(binary_data)
   let binary_response = client.receive()
   match binary_response {
-    @websocket.Text(text) => {
-      println("Received text response: \{text}")
-    }
+    @websocket.Text(text) => println("Received text response: \{text}")
     @websocket.Binary(data) =>
-      println(
-        "Received binary response (\{data.length()} bytes)",
-      )
+      println("Received binary response (\{data.length()} bytes)")
   }
 
-  // Test ping
-  println("Sending ping...")
-  client.ping()
-
   // Close the connection
   println("Closing connection...")
   client.close()

src/tls/ffi.mbt

@@ -143,3 +143,9 @@ fn err_get_error() -> String {
   let len = err_get_error_ffi(buf)
   @bytes_util.ascii_to_string(buf[:len])
 }
+
+///|
+/// Generate cryptographically secure random bytes using OpenSSL's RAND_bytes
+/// Returns 1 on success, 0 on failure
+#borrow(buf)
+pub extern "C" fn rand_bytes(buf : FixedArray[Byte], num : Int) -> Int = "moonbitlang_async_tls_rand_bytes"

src/tls/pkg.generated.mbti

@@ -6,6 +6,7 @@ import(
 )
 
 // Values
+fn rand_bytes(FixedArray[Byte], Int) -> Int
 
 // Errors
 pub suberror ConnectionClosed

src/tls/stub.c

@@ -69,6 +69,7 @@ typedef struct SSL_METHOD SSL_METHOD;
   IMPORT_FUNC(int, SSL_CTX_set_default_verify_paths, (SSL_CTX *ctx))\
   IMPORT_FUNC(unsigned long, ERR_get_error, (void))\
   IMPORT_FUNC(char *, ERR_error_string, (unsigned long e, char *buf))\
+  IMPORT_FUNC(int, RAND_bytes, (unsigned char *buf, int num))\
 
 #define IMPORT_FUNC(ret, name, params) static ret (*name) params;
 IMPORTED_OPEN_SSL_FUNCTIONS
@@ -250,3 +251,7 @@ int moonbitlang_async_tls_get_error(void *buf) {
   ERR_error_string(code, buf);
   return strlen(buf);
 }
+
+int moonbitlang_async_tls_rand_bytes(unsigned char *buf, int num) {
+  return RAND_bytes(buf, num);
+}

src/websocket/client.mbt

@@ -16,6 +16,7 @@
 /// WebSocket client connection
 struct Client {
   conn : @socket.Tcp
+  rand : @random.Rand
   mut closed : CloseCode?
 }
 
@@ -37,12 +38,22 @@ pub async fn Client::connect(
   port? : Int = 80,
   headers? : Map[String, String] = {},
 ) -> Client {
+  let seed = FixedArray::make(32, b'\x00')
+  if @tls.rand_bytes(seed, 32) != 1 {
+    fail("Failed to get random bytes for WebSocket client")
+  }
+  let rand = @random.Rand::chacha8(seed=seed.unsafe_reinterpret_as_bytes())
   // Connect TCP socket
   let addr = @socket.Addr::parse("\{host}:\{port}")
   let conn = @socket.Tcp::connect(addr)
 
   // Send WebSocket handshake request
-  let key = "dGhlIHNhbXBsZSBub25jZQ==" // In production, generate random key
+  let nonce = FixedArray::make(16, b'\x00')
+  nonce.unsafe_write_uint32_le(0, rand.uint())
+  nonce.unsafe_write_uint32_le(4, rand.uint())
+  nonce.unsafe_write_uint32_le(8, rand.uint())
+  nonce.unsafe_write_uint32_le(12, rand.uint())
+  let key = base64_encode(nonce.unsafe_reinterpret_as_bytes())
   let request = "GET \{path} HTTP/1.1\r\n"
   conn.write(request)
   conn.write("Host: \{host}\r\n")
@@ -79,7 +90,7 @@ pub async fn Client::connect(
       "Server response does not contain websocket upgrade confirmation",
     )
   }
-  { conn, closed: None }
+  { conn, closed: None, rand }
 }
 
 ///|
@@ -98,7 +109,13 @@ pub async fn Client::send_text(self : Client, text : String) -> Unit {
     raise ConnectionClosed(code)
   }
   let payload = @encoding/utf8.encode(text)
-  write_frame(self.conn, true, OpCode::Text, payload, true)
+  write_frame(
+    self.conn,
+    true,
+    OpCode::Text,
+    payload,
+    self.rand.int().to_le_bytes(),
+  )
 }
 
 ///|
@@ -107,7 +124,13 @@ pub async fn Client::send_binary(self : Client, data : Bytes) -> Unit {
   if self.closed is Some(code) {
     raise ConnectionClosed(code)
   }
-  write_frame(self.conn, true, OpCode::Binary, data, true)
+  write_frame(
+    self.conn,
+    true,
+    OpCode::Binary,
+    data,
+    self.rand.int().to_le_bytes(),
+  )
 }
 
 ///|
@@ -119,7 +142,13 @@ async fn Client::_ping(self : Client, data? : Bytes = Bytes::new(0)) -> Unit {
   if self.closed is Some(code) {
     raise ConnectionClosed(code)
   }
-  write_frame(self.conn, true, OpCode::Ping, data, true)
+  write_frame(
+    self.conn,
+    true,
+    OpCode::Ping,
+    data,
+    self.rand.int().to_le_bytes(),
+  )
 }
 
 ///|
@@ -130,7 +159,13 @@ async fn Client::pong(self : Client, data? : Bytes = Bytes::new(0)) -> Unit {
   if self.closed is Some(code) {
     raise ConnectionClosed(code)
   }
-  write_frame(self.conn, true, OpCode::Pong, data, true)
+  write_frame(
+    self.conn,
+    true,
+    OpCode::Pong,
+    data,
+    self.rand.int().to_be_bytes(),
+  )
 }
 
 ///|

src/websocket/frame.mbt

@@ -67,7 +67,7 @@ async fn[R : @io.Reader] read_frame(reader : R) -> Frame {
   // Unmask payload if needed
   if mask is Some(mask_bytes) {
     let payload_arr = payload_bytes.to_fixedarray()
-    mask_payload(payload_arr, mask_bytes.to_fixedarray())
+    mask_payload(payload_arr, mask_bytes)
     { fin, opcode, payload: payload_arr.unsafe_reinterpret_as_bytes() }
   } else {
     { fin, opcode, payload: payload_bytes }
@@ -81,7 +81,7 @@ async fn[W : @io.Writer] write_frame(
   fin : Bool,
   opcode : OpCode,
   payload : BytesView,
-  masked : Bool,
+  mask : Bytes,
 ) -> Unit {
   let payload_len = payload.length().to_int64()
   let mut header_len = 2
@@ -94,11 +94,7 @@ async fn[W : @io.Writer] write_frame(
   }
 
   // Build header
-  let header = if masked {
-    FixedArray::make(header_len + 4, b'\x00')
-  } else {
-    FixedArray::make(header_len, b'\x00')
-  }
+  let header = FixedArray::make(header_len + mask.length(), b'\x00')
 
   // First byte: FIN + opcode
   header[0] = if fin {
@@ -108,7 +104,7 @@ async fn[W : @io.Writer] write_frame(
   }
 
   // Second byte: MASK + payload length
-  let mask_bit = if masked { 0x80 } else { 0 }
+  let mask_bit = if mask.length() > 0 { 0x80 } else { 0 }
   if payload_len < 126L {
     header[1] = (mask_bit | payload_len.to_int()).to_byte()
   } else if payload_len <= 65535L {
@@ -120,8 +116,7 @@ async fn[W : @io.Writer] write_frame(
   }
 
   // Add masking key and mask payload if needed
-  let final_payload = if masked {
-    let mask = generate_mask()
+  let final_payload = if mask.length() > 0 {
     for i = 0; i < 4; i = i + 1 {
       header[header_len + i] = mask[i]
     }

src/websocket/moon.pkg.json

@@ -2,7 +2,7 @@
   "import": [
     "moonbitlang/async/io",
     "moonbitlang/async/socket",
-    "moonbitlang/async/internal/time",
+    "moonbitlang/async/tls",
     "moonbitlang/x/crypto",
     "moonbitlang/async",
     "moonbitlang/async/aqueue",

src/websocket/server.mbt

@@ -289,7 +289,7 @@ pub async fn ServerConnection::send_text(
   self.semaphore.acquire()
   defer self.semaphore.release()
   let payload = @encoding/utf8.encode(text)
-  write_frame(self.conn, true, OpCode::Text, payload, false)
+  write_frame(self.conn, true, OpCode::Text, payload, [])
 }
 
 ///|
@@ -303,7 +303,7 @@ pub async fn ServerConnection::send_binary(
   }
   self.semaphore.acquire()
   defer self.semaphore.release()
-  write_frame(self.conn, true, OpCode::Binary, data, false)
+  write_frame(self.conn, true, OpCode::Binary, data, [])
 }
 
 ///|
@@ -320,7 +320,7 @@ async fn ServerConnection::_ping(
   }
   self.semaphore.acquire()
   defer self.semaphore.release()
-  write_frame(self.conn, true, OpCode::Ping, data, false)
+  write_frame(self.conn, true, OpCode::Ping, data, [])
 }
 
 ///|
@@ -336,7 +336,7 @@ async fn ServerConnection::pong(
   }
   self.semaphore.acquire()
   defer self.semaphore.release()
-  write_frame(self.conn, true, OpCode::Pong, data, false)
+  write_frame(self.conn, true, OpCode::Pong, data, [])
 }
 
 ///|
@@ -368,7 +368,7 @@ pub async fn ServerConnection::send_close(
     true,
     OpCode::Close,
     payload.unsafe_reinterpret_as_bytes(),
-    false,
+    [],
   )
   self.closed = Some(code)
 }

src/websocket/utils.mbt

@@ -14,32 +14,12 @@
 
 ///|
 /// Apply XOR mask to payload data
-fn mask_payload(data : FixedArray[Byte], mask : FixedArray[Byte]) -> Unit {
+fn mask_payload(data : FixedArray[Byte], mask : Bytes) -> Unit {
   for i = 0; i < data.length(); i = i + 1 {
     data[i] = data[i] ^ mask[i % 4]
   }
 }
 
-///|
-/// Generate a random 4-byte masking key
-fn generate_mask() -> FixedArray[Byte] {
-  let mask = FixedArray::make(4, b'\x00')
-  // Use current time as seed for simple randomness
-  // In production, consider using a cryptographically secure random source
-  let t = @time.ms_since_epoch()
-
-  // Create more entropy by combining time with simple operations
-  let seed1 = t
-  let seed2 = t ^ (t >> 13)
-  let seed3 = seed2 ^ (seed2 << 7)
-  let seed4 = seed3 ^ (seed3 >> 17)
-  mask[0] = (seed1 & 0xFF).to_byte()
-  mask[1] = (seed2 & 0xFF).to_byte()
-  mask[2] = (seed3 & 0xFF).to_byte()
-  mask[3] = (seed4 & 0xFF).to_byte()
-  mask
-}
-
 ///|
 /// Base64 encoding
 fn base64_encode(data : Bytes) -> String {
@@ -75,12 +55,14 @@ fn base64_encode(data : Bytes) -> String {
   result
 }
 
+///|
+const MAGIC = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+
 ///|
 /// Generate WebSocket accept key from client key using SHA-1 and base64
 fn generate_accept_key(client_key : String) -> String {
   // WebSocket magic string as defined in RFC 6455
-  let magic = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
-  let combined = client_key + magic
+  let combined = client_key + MAGIC
   let combined_bytes = @encoding/utf8.encode(combined)
 
   // Use the crypto library for proper SHA-1 hashing