Enable client certificates in SecureSocket and SecureServerSocket

sdk/lib/io/secure_socket.dart

 // Copyright (c) 2012, 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.
 
 /**
  * SecureSocket provides a secure (SSL or TLS) client connection to a server.
  * The certificate provided by the server is checked
  * using the certificate database provided in setCertificateDatabase.
  */
 abstract class SecureSocket implements Socket {
   /**
    * Constructs a new secure client socket and connect it to the given
    * host on the given port. The returned socket is not yet connected
-   * but ready for registration of callbacks.
+   * but ready for registration of callbacks.  If sendClientCertificate is
+   * set to true, the socket will send a client certificate if one is
+   * requested by the server.  An appropriate certificate will
+   * be searched for and chosen automatically, based on what the server
+   * says it will accept, unless clientCertificate is set to the nickname of
+   * a certificate in the certificate database.

[Søren Gjesse, 2012/12/07 13:00:23]

How about rephrasing this additional comment to 

"If clientCertificate is set to the nickname" ... "otherwise an appropriate" ...

The "unless" way is harder to decode.

[Bill Hesse, 2012/12/10 15:15:48]

Done.

    */
-  factory SecureSocket(String host, int port) => new _SecureSocket(host, port);
+  factory SecureSocket(String host,
+                       int port,
+                       {bool sendClientCertificate: false,
+                       String certificateName}) {

[Søren Gjesse, 2012/12/07 13:00:23]

Please indent one char more here.

[Bill Hesse, 2012/12/10 15:15:48]

Done.

+    return new _SecureSocket.client(host,
+                                    port,
+                                    sendClientCertificate,
+                                    certificateName);
+  }
 
   /**
    * Install a handler for unverifiable certificates.  The handler can inspect
    * the certificate, and decide (or let the user decide) whether to accept
    * the connection or not.  The callback should return true
    * to continue the SecureSocket connection.
    */
   void set onBadCertificate(bool callback(X509Certificate certificate));
 
+  /**
+   * Get the peerCertificate for a connected secure socket.  For a server
+   * socket, this will return the client certificate, or null, if no
+   * client certificate was requested or supplied.  For a client socket, this

[Søren Gjesse, 2012/12/07 13:00:23]

Maybe remove "requested or".

[Bill Hesse, 2012/12/10 15:15:48]

Done.

+   * will return the server's certificate.
+   */
+  X509Certificate get peerCertificate;
+
    /**
    * Initializes the NSS library with the path to a certificate database
    * containing root certificates for verifying certificate paths on
    * client connections, and server certificates to provide on server
    * connections.  The password argument should be used when creating
    * secure server sockets, to allow the private key of the server
    * certificate to be fetched.  If useBuiltinRoots is true (the default),
    * then a built-in set of root certificates for trusted certificate
    * authorities is merged with the certificates in the database.
    *
@@ skipping 46 matching lines @@
   static final int CLOSED = 203;
 
   // Buffer identifiers.
   // These must agree with those in the native C++ implementation.
   static final int READ_PLAINTEXT = 0;
   static final int WRITE_PLAINTEXT = 1;
   static final int READ_ENCRYPTED = 2;
   static final int WRITE_ENCRYPTED = 3;
   static final int NUM_BUFFERS = 4;
 
-  int _count = 0;
   // Constructs a new secure client socket.
-  factory _SecureSocket(String host, int port) =>
-      new _SecureSocket.internal(host, port, false);
+  factory _SecureSocket.client(String host,
+                               int port,
+                               bool sendClientCertificate,
+                               String certificateName) =>
+      new _SecureSocket.internal(
+          host,
+          port,
+          false,
+          certificateName: certificateName,
+          sendClientCertificate: sendClientCertificate);
 
-  // Constructs a new secure server socket, with the named server certificate.
+  // Constructs a new secure server socket.
   factory _SecureSocket.server(String host,
-                            int port,
-                            Socket socket,
-                            String certificateName) =>
-      new _SecureSocket.internal(host, port, true, socket, certificateName);
+                               int port,
+                               Socket socket,
+                               String certificateName,
+                               bool requestClientCertificate,
+                               bool requireClientCertificate) =>
+      new _SecureSocket.internal(
+          host,
+          port,
+          true,
+          socket: socket,
+          certificateName: certificateName,
+          requestClientCertificate: requestClientCertificate,
+          requireClientCertificate: requireClientCertificate);
 
   _SecureSocket.internal(String host,
-                      int port,
-                      bool is_server,
-                      [Socket socket,
-                       String certificateName])
+                         int port,
+                         bool is_server,
+                         {Socket socket,
+                          String certificateName,
+                          bool requestClientCertificate: false,
+                          bool requireClientCertificate: false,
+                          bool sendClientCertificate: false})
       : _host = host,
         _port = port,
+        _is_server = is_server,
         _socket = socket,
         _certificateName = certificateName,
-        _is_server = is_server,
+        _requestClientCertificate =
+            (requestClientCertificate == true) ||
+            (requireClientCertificate == true),
+        _requireClientCertificate = requireClientCertificate,
+        _sendClientCertificate = sendClientCertificate,
         _secureFilter = new _SecureFilter() {
+    // Throw an ArgumentError if any field is invalid.
+    _verifyFields(requestClientCertificate);
     if (_socket == null) {
       _socket = new Socket(host, port);
     }
     _socket.onConnect = _secureConnectHandler;
     _socket.onData = _secureDataHandler;
     _socket.onClosed = _secureCloseHandler;
     _socket.onError = _secureErrorHandler;
     _secureFilter.init();
-    _secureFilter.registerHandshakeCompleteCallback(_secureHandshakeCompleteHandler);
+    _secureFilter.registerHandshakeCompleteCallback(
+        _secureHandshakeCompleteHandler);
+  }
+
+  void _verifyFields(bool requestClientCertificate) {
+    if (_host is! String) throw new ArgumentError(
+        "SecureSocket constructor: host is not a String");
+    if (_port is! int || _port < 0 || _port > 65535) throw new ArgumentError(
+        "SecureSocket constructor: port is not an int between 0 and 65536");
+    assert(_is_server is bool);
+    assert(_socket == null || _socket is Socket);
+    if (_certificateName != null && _certificateName is! String) {
+      throw new ArgumentError(
+          "SecureSocket constructor: certificateName is not null or a String");
+    }
+    if (_certificateName == null && _is_server) {
+      throw new ArgumentError(
+          "SecureSocket constructor: certificateName is null on a server");
+    }
+    if (requestClientCertificate is! bool) throw new ArgumentError(
+        "SecureSocket constructor: requestClientCertificate is not a bool");
+    if (_requireClientCertificate is! bool) throw new ArgumentError(
+        "SecureSocket constructor: requireClientCertificate is not a bool");
+    if (_sendClientCertificate is! bool) throw new ArgumentError(
+        "SecureSocket constructor: sendClientCertificate is not a bool");
   }
 
   int get port => _socket.port;
 
   String get remoteHost => _socket.remoteHost;
 
   int get remotePort => _socket.remotePort;
 
   void set onClosed(void callback()) {
     if (_inputStream != null && callback != null) {
@@ skipping 181 matching lines @@
       bytes = buffer.free;
     }
     if (bytes > 0) {
       buffer.data.setRange(buffer.start + buffer.length, bytes, data, offset);
       buffer.length += bytes;
     }
     _writeEncryptedData();  // Tries to flush all pipeline stages.
     return bytes;
   }
 
+  X509Certificate get peerCertificate => _secureFilter.peerCertificate;
+
   void _secureConnectHandler() {
     _connectPending = true;
-    _secureFilter.connect(_host, _port, _is_server, _certificateName);
+    _secureFilter.connect(_host,
+                          _port,
+                          _is_server,
+                          _certificateName,
+                          _requestClientCertificate,
+                          _requireClientCertificate,
+                          _sendClientCertificate);
     _status = HANDSHAKE;
     _secureHandshake();
   }
 
   void _secureWriteHandler() {
     _writeEncryptedData();
     if (_filterWriteEmpty && _closedWrite && !_socketClosedWrite) {
       close(true);
     }
     if (_status == HANDSHAKE) {
@@ skipping 213 matching lines @@
         // This must be asynchronous, because we are in a read or readList call.
         new Timer(0, (_) => _secureCloseHandler());
       }
     }
   }
 
   bool get _socketClosed => _closedRead;
 
   // _SecureSocket cannot extend _Socket and use _Socket's factory constructor.
   Socket _socket;
-  String _host;
-  int _port;
-  bool _is_server;
-  String _certificateName;
+  final String _host;
+  final int _port;
+  final bool _is_server;
+  final String _certificateName;
+  final bool _requestClientCertificate;
+  final bool _requireClientCertificate;
+  final bool _sendClientCertificate;
 
   var _status = NOT_CONNECTED;
   bool _socketClosedRead = false;  // The network socket is closed for reading.
   bool _socketClosedWrite = false;  // The network socket is closed for writing.
   bool _closedRead = false;  // The secure socket has fired an onClosed event.
   bool _closedWrite = false;  // The secure socket has been closed for writing.
   bool _filterReadEmpty = true;  // There is no buffered data to read.
   bool _filterWriteEmpty = true;  // There is no buffered data to be written.
   _SocketInputStream _inputStream;
   _SocketOutputStream _outputStream;
@@ skipping 29 matching lines @@
   int length;
 }
 
 
 abstract class _SecureFilter {
   external factory _SecureFilter();
 
   void connect(String hostName,
                int port,
                bool is_server,
-               String certificateName);
+               String certificateName,
+               bool requestClientCertificate,
+               bool requireClientCertificate,
+               bool sendClientCertificate);
   void destroy();
   void handshake();
   void init();
+  X509Certificate get peerCertificate;
   int processBuffer(int bufferIndex);
   void registerBadCertificateCallback(Function callback);
   void registerHandshakeCompleteCallback(Function handshakeCompleteHandler);
 
   List<_ExternalBuffer> get buffers;
 }