WebSocket: Correctly expect masked frames from clients, and send masked frames from the client.

sdk/lib/io/websocket_impl.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.io;
 
 const String _webSocketGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 
 class _WebSocketMessageType {
   static const int NONE = 0;
@@ skipping 32 matching lines @@
  */
 class _WebSocketProtocolTransformer extends StreamEventTransformer {
   static const int START = 0;
   static const int LEN_FIRST = 1;
   static const int LEN_REST = 2;
   static const int MASK = 3;
   static const int PAYLOAD = 4;
   static const int CLOSED = 5;
   static const int FAILURE = 6;
 
-  _WebSocketProtocolTransformer() {
+  bool _serverSide;
+
+  _WebSocketProtocolTransformer([bool this._serverSide = false]) {
     _prepareForNextFrame();
     _currentMessageType = _WebSocketMessageType.NONE;
   }
 
   /**
    * Process data received from the underlying communication channel.
    */
   void handleData(List<int> buffer, EventSink sink) {
     int count = buffer.length;
     int index = 0;
@@ skipping 152 matching lines @@
         index++;
       }
     } catch (e) {
       _state = FAILURE;
       sink.addError(e);
     }
   }
 
   void _lengthDone(EventSink sink) {
     if (_masked) {
+      if (!_serverSide) {
+        throw new WebSocketException("Received masked frame from server");
+      }
       _state = MASK;
       _remainingMaskingKeyBytes = 4;
     } else {
+      if (_serverSide) {
+        throw new WebSocketException("Received unmasked frame from client");
+      }
       _remainingPayloadBytes = _len;
       _startPayload(sink);
     }
   }
 
   void _maskDone(EventSink sink) {
     _remainingPayloadBytes = _len;
     _startPayload(sink);
   }
 
@@ skipping 146 matching lines @@
     response.statusCode = HttpStatus.SWITCHING_PROTOCOLS;
     response.headers.add(HttpHeaders.CONNECTION, "Upgrade");
     response.headers.add(HttpHeaders.UPGRADE, "websocket");
     String key = request.headers.value("Sec-WebSocket-Key");
     SHA1 sha1 = new SHA1();
     sha1.add("$key$_webSocketGUID".codeUnits);
     String accept = _Base64._encode(sha1.close());
     response.headers.add("Sec-WebSocket-Accept", accept);
     response.headers.contentLength = 0;
     return response.detachSocket()
-        .then((socket) => new _WebSocketImpl._fromSocket(socket));
+        .then((socket) => new _WebSocketImpl._fromSocket(socket, true));
   }
 
   static bool _isUpgradeRequest(HttpRequest request) {
     if (request.method != "GET") {
       return false;
     }
     if (request.headers[HttpHeaders.CONNECTION] == null) {
       return false;
     }
     bool isUpgrade = false;
@@ skipping 15 matching lines @@
     }
     return true;
   }
 }
 
 
 class _WebSocketImpl extends Stream implements WebSocket {
   final StreamController _controller = new StreamController();
 
   final Socket _socket;
+  final bool _serverSide;
   int _readyState = WebSocket.CONNECTING;
   bool _writeClosed = false;
   int _closeCode;
   String _closeReason;
 
   static final HttpClient _httpClient = new HttpClient();
 
   static Future<WebSocket> connect(String url, [protocols]) {
     Uri uri = Uri.parse(url);
     if (uri.scheme != "ws" && uri.scheme != "wss") {
@@ skipping 57 matching lines @@
         for (int i = 0; i < expectedAccept.length; i++) {
           if (expectedAccept[i] != receivedAccept[i]) {
             error("Bad response 'Sec-WebSocket-Accept' header");
           }
         }
         return response.detachSocket()
             .then((socket) => new _WebSocketImpl._fromSocket(socket));
       });
   }
 
-  _WebSocketImpl._fromSocket(Socket this._socket) {
+  _WebSocketImpl._fromSocket(Socket this._socket,
+                             [bool this._serverSide = false]) {
     _readyState = WebSocket.OPEN;
 
     bool closed = false;
-    var transformer = new _WebSocketProtocolTransformer();
+    var transformer = new _WebSocketProtocolTransformer(_serverSide);
     _socket.transform(transformer).listen(
         (data) {
           _controller.add(data);
         },
         onError: (error) {
           if (closed) return;
           closed = true;
           _controller.addError(error);
           _controller.close();
         },
@@ skipping 101 matching lines @@
         data = message;
       }
     } else {
       opcode = _WebSocketOpcode.TEXT;
     }
     _sendFrame(opcode, data);
   }
 
   void _sendFrame(int opcode, [List<int> data]) {
     if (_writeClosed) return;
-    bool mask = false;  // Masking not implemented for server.
+    bool mask = !_serverSide;  // Masking not implemented for server.
     int dataLength = data == null ? 0 : data.length;
     // Determine the header size.
     int headerSize = (mask) ? 6 : 2;
     if (dataLength > 65535) {
       headerSize += 8;
     } else if (dataLength > 125) {
       headerSize += 2;
     }
     List<int> header = new List<int>(headerSize);
     int index = 0;
     // Set FIN and opcode.
     header[index++] = 0x80 | opcode;
     // Determine size and position of length field.
     int lengthBytes = 1;
     int firstLengthByte = 1;
     if (dataLength > 65535) {
       header[index++] = 127;
       lengthBytes = 8;
     } else if (dataLength > 125) {
       header[index++] = 126;
       lengthBytes = 2;
     }
     // Write the length in network byte order into the header.
     for (int i = 0; i < lengthBytes; i++) {
       header[index++] = dataLength >> (((lengthBytes - 1) - i) * 8) & 0xFF;
     }
+    if (mask) {
+      header[1] |= 1 << 7;
+      var maskBytes = _IOCrypto.getRandomBytes(4);
+      header.setRange(index, 4, maskBytes);
+      index += 4;
+      if (data != null) {
+        var list = new Uint8List(data.length);
+        for (int i = 0; i < data.length; i++) {
+          list[i] = data[i] ^ maskBytes[i % 4];
+        }
+        data = list;
+      }
+    }
     assert(index == headerSize);
     try {
       _socket.writeBytes(header);
       if (data != null) {
         _socket.writeBytes(data);
       }
     } catch (_) {
       // The socket can be closed before _socket.done have a chance
       // to complete.
       _writeClosed = true;
     }
   }
 }