2  * Copyright (c) 1996, 2016, Oracle and/or its affiliates. All rights reserved.

     2  * Copyright (c) 1996, 2018, Oracle and/or its affiliates. All rights reserved.

    29 import java.io.*;

    28 import java.io.EOFException;

    30 import java.nio.*;

    29 import java.io.IOException;

    31 import java.net.*;

    30 import java.io.InputStream;

    32 import java.security.GeneralSecurityException;

    31 import java.io.InterruptedIOException;

    33 import java.security.AccessController;

    32 import java.io.OutputStream;

    34 import java.security.AccessControlContext;

    33 import java.net.InetAddress;

    35 import java.security.PrivilegedAction;

    34 import java.net.InetSocketAddress;

    36 import java.security.AlgorithmConstraints;

    35 import java.net.Socket;

    37 import java.util.*;

    36 import java.net.SocketAddress;

    38 import java.util.concurrent.TimeUnit;

    37 import java.net.SocketException;

    39 import java.util.concurrent.locks.ReentrantLock;

    38 import java.net.UnknownHostException;

    39 import java.nio.ByteBuffer;

    40 import java.util.List;

    41 

    42 import javax.net.ssl.HandshakeCompletedListener;

    42 import javax.crypto.BadPaddingException;

    43 import javax.net.ssl.SSLException;

    43 import javax.net.ssl.*;

    44 import javax.net.ssl.SSLHandshakeException;

    44 

    45 import javax.net.ssl.SSLParameters;

    46 import javax.net.ssl.SSLProtocolException;

    47 import javax.net.ssl.SSLServerSocket;

    48 import javax.net.ssl.SSLSession;

    49 import javax.net.ssl.SSLSocket;

    49  * Implementation of an SSL socket.  This is a normal connection type

    54  * Implementation of an SSL socket.

    50  * socket, implementing SSL over some lower level socket, such as TCP.

    55  * <P>

    51  * Because it is layered over some lower level socket, it MUST override

    56  * This is a normal connection type socket, implementing SSL over some lower

    52  * all default socket methods.

    57  * level socket, such as TCP.  Because it is layered over some lower level

    53  *

    58  * socket, it MUST override all default socket methods.

    54  * <P> This API offers a non-traditional option for establishing SSL

    59  * <P>

    60  * This API offers a non-traditional option for establishing SSL

    67 public final class SSLSocketImpl extends BaseSSLSocketImpl {

    73 public final class SSLSocketImpl

    68 

    74         extends BaseSSLSocketImpl implements SSLTransport {

    69     /*

    75 

    70      * ERROR HANDLING GUIDELINES

    76     final SSLContextImpl            sslContext;

    71      * (which exceptions to throw and catch and which not to throw and catch)

    77     final TransportContext          conContext;

    72      *

    78 

    73      * . if there is an IOException (SocketException) when accessing the

    79     private final AppInputStream    appInput = new AppInputStream();

    74      *   underlying Socket, pass it through

    80     private final AppOutputStream   appOutput = new AppOutputStream();

    75      *

    81 

    76      * . do not throw IOExceptions, throw SSLExceptions (or a subclass)

    82     private String                  peerHost;

    77      *

    83     private boolean                 autoClose;

    78      * . for internal errors (things that indicate a bug in JSSE or a

    84     private boolean                 isConnected = false;

    79      *   grossly misconfigured J2RE), throw either an SSLException or

    85     private boolean                 tlsIsClosed = false;

    80      *   a RuntimeException at your convenience.

    81      *

    82      * . handshaking code (Handshaker or HandshakeMessage) should generally

    83      *   pass through exceptions, but can handle them if they know what to

    84      *   do.

    85      *

    86      * . exception chaining should be used for all new code. If you happen

    87      *   to touch old code that does not use chaining, you should change it.

    88      *

    89      * . there is a top level exception handler that sits at all entry

    90      *   points from application code to SSLSocket read/write code. It

    91      *   makes sure that all errors are handled (see handleException()).

    92      *

    93      * . JSSE internal code should generally not call close(), call

    94      *   closeInternal().

    95      */

    96 

    97     /*

    98      * There's a state machine associated with each connection, which

    99      * among other roles serves to negotiate session changes.

   100      *

   101      * - START with constructor, until the TCP connection's around.

   102      * - HANDSHAKE picks session parameters before allowing traffic.

   103      *          There are many substates due to sequencing requirements

   104      *          for handshake messages.

   105      * - DATA may be transmitted.

   106      * - RENEGOTIATE state allows concurrent data and handshaking

   107      *          traffic ("same" substates as HANDSHAKE), and terminates

   108      *          in selection of new session (and connection) parameters

   109      * - ERROR state immediately precedes abortive disconnect.

   110      * - SENT_CLOSE sent a close_notify to the peer. For layered,

   111      *          non-autoclose socket, must now read close_notify

   112      *          from peer before closing the connection. For nonlayered or

   113      *          non-autoclose socket, close connection and go onto

   114      *          cs_CLOSED state.

   115      * - CLOSED after sending close_notify alert, & socket is closed.

   116      *          SSL connection objects are not reused.

   117      * - APP_CLOSED once the application calls close(). Then it behaves like

   118      *          a closed socket, e.g.. getInputStream() throws an Exception.

   119      *

   120      * State affects what SSL record types may legally be sent:

   121      *

   122      * - Handshake ... only in HANDSHAKE and RENEGOTIATE states

   123      * - App Data ... only in DATA and RENEGOTIATE states

   124      * - Alert ... in HANDSHAKE, DATA, RENEGOTIATE

   125      *

   126      * Re what may be received:  same as what may be sent, except that

   127      * HandshakeRequest handshaking messages can come from servers even

   128      * in the application data state, to request entry to RENEGOTIATE.

   129      *

   130      * The state machine within HANDSHAKE and RENEGOTIATE states controls

   131      * the pending session, not the connection state, until the change

   132      * cipher spec and "Finished" handshake messages are processed and

   133      * make the "new" session become the current one.

   134      *

   135      * NOTE: details of the SMs always need to be nailed down better.

   136      * The text above illustrates the core ideas.

   137      *

   138      *                +---->-------+------>--------->-------+

   139      *                |            |                        |

   140      *     <-----<    ^            ^  <-----<               v

   141      *START>----->HANDSHAKE>----->DATA>----->RENEGOTIATE  SENT_CLOSE

   142      *                v            v               v        |   |

   143      *                |            |               |        |   v

   144      *                +------------+---------------+        v ERROR

   145      *                |                                     |   |

   146      *                v                                     |   |

   147      *               ERROR>------>----->CLOSED<--------<----+-- +

   148      *                                     |

   149      *                                     v

   150      *                                 APP_CLOSED

   151      *

   152      * ALSO, note that the purpose of handshaking (renegotiation is

   153      * included) is to assign a different, and perhaps new, session to

   154      * the connection.  The SSLv3 spec is a bit confusing on that new

   155      * protocol feature.

   156      */

   157     private static final int    cs_START = 0;

   158     private static final int    cs_HANDSHAKE = 1;

   159     private static final int    cs_DATA = 2;

   160     private static final int    cs_RENEGOTIATE = 3;

   161     private static final int    cs_ERROR = 4;

   162     private static final int    cs_SENT_CLOSE = 5;

   163     private static final int    cs_CLOSED = 6;

   164     private static final int    cs_APP_CLOSED = 7;

   165 

   166     /*

   167      * Drives the protocol state machine.

   168      */

   169     private volatile int        connectionState;

   170 

   171     /*

   172      * Flag indicating if the next record we receive MUST be a Finished

   173      * message. Temporarily set during the handshake to ensure that

   174      * a change cipher spec message is followed by a finished message.

   175      */

   176     private boolean             expectingFinished;

   177 

   178     /*

   179      * For improved diagnostics, we detail connection closure

   180      * If the socket is closed (connectionState >= cs_ERROR),

   181      * closeReason != null indicates if the socket was closed

   182      * because of an error or because or normal shutdown.

   183      */

   184     private SSLException        closeReason;

   185 

   186     /*

   187      * Per-connection private state that doesn't change when the

   188      * session is changed.

   189      */

   190     private ClientAuthType      doClientAuth =

   191                                         ClientAuthType.CLIENT_AUTH_NONE;

   192     private boolean             roleIsServer;

   193     private boolean             enableSessionCreation = true;

   194     private String              host;

   195     private boolean             autoClose = true;

   196     private AccessControlContext acc;

   197 

   198     // The cipher suites enabled for use on this connection.

   199     private CipherSuiteList     enabledCipherSuites;

   200 

   201     // The endpoint identification protocol

   202     private String              identificationProtocol = null;

   203 

   204     // The cryptographic algorithm constraints

   205     private AlgorithmConstraints    algorithmConstraints = null;

   206 

   207     // The server name indication and matchers

   208     List<SNIServerName>         serverNames =

   209                                     Collections.<SNIServerName>emptyList();

   210     Collection<SNIMatcher>      sniMatchers =

   211                                     Collections.<SNIMatcher>emptyList();

   212 

   213     // Is the serverNames set to empty with SSLParameters.setServerNames()?

   214     private boolean             noSniExtension = false;

   215 

   216     // Is the sniMatchers set to empty with SSLParameters.setSNIMatchers()?

   217     private boolean             noSniMatcher = false;

   218 

   219     // Configured application protocol values

   220     String[] applicationProtocols = new String[0];

   221 

   222     // Negotiated application protocol value.

   223     //

   224     // The value under negotiation will be obtained from handshaker.

   225     String applicationProtocol = null;

   226 

   227     // Callback function that selects the application protocol value during

   228     // the SSL/TLS handshake.

   229     BiFunction<SSLSocket, List<String>, String> applicationProtocolSelector;

   230 

   231     /*

   232      * READ ME * READ ME * READ ME * READ ME * READ ME * READ ME *

   233      * IMPORTANT STUFF TO UNDERSTANDING THE SYNCHRONIZATION ISSUES.

   234      * READ ME * READ ME * READ ME * READ ME * READ ME * READ ME *

   235      *

   236      * There are several locks here.

   237      *

   238      * The primary lock is the per-instance lock used by

   239      * synchronized(this) and the synchronized methods.  It controls all

   240      * access to things such as the connection state and variables which

   241      * affect handshaking.  If we are inside a synchronized method, we

   242      * can access the state directly, otherwise, we must use the

   243      * synchronized equivalents.

   244      *

   245      * The handshakeLock is used to ensure that only one thread performs

   246      * the *complete initial* handshake.  If someone is handshaking, any

   247      * stray application or startHandshake() requests who find the

   248      * connection state is cs_HANDSHAKE will stall on handshakeLock

   249      * until handshaking is done.  Once the handshake is done, we either

   250      * succeeded or failed, but we can never go back to the cs_HANDSHAKE

   251      * or cs_START state again.

   252      *

   253      * Note that the read/write() calls here in SSLSocketImpl are not

   254      * obviously synchronized.  In fact, it's very nonintuitive, and

   255      * requires careful examination of code paths.  Grab some coffee,

   256      * and be careful with any code changes.

   257      *

   258      * There can be only three threads active at a time in the I/O

   259      * subsection of this class.

   260      *    1.  startHandshake

   261      *    2.  AppInputStream

   262      *    3.  AppOutputStream

   263      * One thread could call startHandshake().

   264      * AppInputStream/AppOutputStream read() and write() calls are each

   265      * synchronized on 'this' in their respective classes, so only one

   266      * app. thread will be doing a SSLSocketImpl.read() or .write()'s at

   267      * a time.

   268      *

   269      * If handshaking is required (state cs_HANDSHAKE), and

   270      * getConnectionState() for some/all threads returns cs_HANDSHAKE,

   271      * only one can grab the handshakeLock, and the rest will stall

   272      * either on getConnectionState(), or on the handshakeLock if they

   273      * happen to successfully race through the getConnectionState().

   274      *

   275      * If a writer is doing the initial handshaking, it must create a

   276      * temporary reader to read the responses from the other side.  As a

   277      * side-effect, the writer's reader will have priority over any

   278      * other reader.  However, the writer's reader is not allowed to

   279      * consume any application data.  When handshakeLock is finally

   280      * released, we either have a cs_DATA connection, or a

   281      * cs_CLOSED/cs_ERROR socket.

   282      *

   283      * The writeLock is held while writing on a socket connection and

   284      * also to protect the MAC and cipher for their direction.  The

   285      * writeLock is package private for Handshaker which holds it while

   286      * writing the ChangeCipherSpec message.

   287      *

   288      * To avoid the problem of a thread trying to change operational

   289      * modes on a socket while handshaking is going on, we synchronize

   290      * on 'this'.  If handshaking has not started yet, we tell the

   291      * handshaker to change its mode.  If handshaking has started,

   292      * we simply store that request until the next pending session

   293      * is created, at which time the new handshaker's state is set.

   294      *

   295      * The readLock is held during readRecord(), which is responsible

   296      * for reading an SSLInputRecord, decrypting it, and processing it.

   297      * The readLock ensures that these three steps are done atomically

   298      * and that once started, no other thread can block on SSLInputRecord.read.

   299      * This is necessary so that processing of close_notify alerts

   300      * from the peer are handled properly.

   301      */

   302     private final Object        handshakeLock = new Object();

   303     final ReentrantLock         writeLock = new ReentrantLock();

   304     private final Object        readLock = new Object();

   305 

   306     InputRecord                 inputRecord;

   307     OutputRecord                outputRecord;

   308 

   309     /*

   310      * security parameters for secure renegotiation.

   311      */

   312     private boolean             secureRenegotiation;

   313     private byte[]              clientVerifyData;

   314     private byte[]              serverVerifyData;

   315 

   316     /*

   317      * The authentication context holds all information used to establish

   318      * who this end of the connection is (certificate chains, private keys,

   319      * etc) and who is trusted (e.g. as CAs or websites).

   320      */

   321     private SSLContextImpl      sslContext;

   322 

   323 

   324     /*

   325      * This connection is one of (potentially) many associated with

   326      * any given session.  The output of the handshake protocol is a

   327      * new session ... although all the protocol description talks

   328      * about changing the cipher spec (and it does change), in fact

   329      * that's incidental since it's done by changing everything that

   330      * is associated with a session at the same time.  (TLS/IETF may

   331      * change that to add client authentication w/o new key exchg.)

   332      */

   333     private Handshaker                  handshaker;

   334     private SSLSessionImpl              sess;

   335     private volatile SSLSessionImpl     handshakeSession;

   336 

   337 

   338     /*

   339      * If anyone wants to get notified about handshake completions,

   340      * they'll show up on this list.

   341      */

   342     private HashMap<HandshakeCompletedListener, AccessControlContext>

   343                                                         handshakeListeners;

   344 

   345     /*

   346      * Reuse the same internal input/output streams.

   347      */

   348     private InputStream         sockInput;

   349     private OutputStream        sockOutput;

   350 

   351 

   352     /*

   353      * These input and output streams block their data in SSL records,

   354      * and usually arrange integrity and privacy protection for those

   355      * records.  The guts of the SSL protocol are wrapped up in these

   356      * streams, and in the handshaking that establishes the details of

   357      * that integrity and privacy protection.

   358      */

   359     private AppInputStream      input;

   360     private AppOutputStream     output;

   361 

   362     /*

   363      * The protocol versions enabled for use on this connection.

   364      *

   365      * Note: we support a pseudo protocol called SSLv2Hello which when

   366      * set will result in an SSL v2 Hello being sent with SSL (version 3.0)

   367      * or TLS (version 3.1, 3.2, etc.) version info.

   368      */

   369     private ProtocolList enabledProtocols;

   370 

   371     /*

   372      * The SSL version associated with this connection.

   373      */

   374     private ProtocolVersion     protocolVersion = ProtocolVersion.DEFAULT_TLS;

   375 

   376     /* Class and subclass dynamic debugging support */

   377     private static final Debug debug = Debug.getInstance("ssl");

   378 

   379     /*

   380      * Whether local cipher suites preference in server side should be

   381      * honored during handshaking?

   382      */

   383     private boolean preferLocalCipherSuites = false;

   384 

   385     /*

   386      * The maximum expected network packet size for SSL/TLS/DTLS records.

   387      */

   388     private int maximumPacketSize = 0;

   396     static final boolean trustNameService =

    93     private static final boolean trustNameService =

   397             Debug.getBooleanProperty("jdk.tls.trustNameService", false);

    94             Utilities.getBooleanProperty("jdk.tls.trustNameService", false);

   398 

    95 

   399     //

    96     /**

   400     // CONSTRUCTORS AND INITIALIZATION CODE

    97      * Package-private constructor used to instantiate an unconnected

   401     //

    98      * socket.

   402 

    99      *

   403     /**

   100      * This instance is meant to set handshake state to use "client mode".

   404      * Constructs an SSL connection to a named host at a specified port,

   101      */

   405      * using the authentication context provided.  This endpoint acts as

   102     SSLSocketImpl(SSLContextImpl sslContext) {

   406      * the client, and may rejoin an existing SSL session if appropriate.

   407      *

   408      * @param context authentication context to use

   409      * @param host name of the host with which to connect

   410      * @param port number of the server's port

   411      */

   412     SSLSocketImpl(SSLContextImpl context, String host, int port)

   413             throws IOException, UnknownHostException {

   415         this.host = host;

   104         this.sslContext = sslContext;

   416         this.serverNames =

   105         HandshakeHash handshakeHash = new HandshakeHash();

   417             Utilities.addToSNIServerNameList(this.serverNames, this.host);

   106         this.conContext = new TransportContext(sslContext, this,

   418         init(context, false);

   107                 new SSLSocketInputRecord(handshakeHash),

   108                 new SSLSocketOutputRecord(handshakeHash), true);

   109     }

   110 

   111     /**

   112      * Package-private constructor used to instantiate a server socket.

   113      *

   114      * This instance is meant to set handshake state to use "server mode".

   115      */

   116     SSLSocketImpl(SSLContextImpl sslContext, SSLConfiguration sslConfig) {

   117         super();

   118         this.sslContext = sslContext;

   119         HandshakeHash handshakeHash = new HandshakeHash();

   120         this.conContext = new TransportContext(sslContext, this, sslConfig,

   121                 new SSLSocketInputRecord(handshakeHash),

   122                 new SSLSocketOutputRecord(handshakeHash));

   123     }

   124 

   125     /**

   126      * Constructs an SSL connection to a named host at a specified

   127      * port, using the authentication context provided.

   128      *

   129      * This endpoint acts as the client, and may rejoin an existing SSL session

   130      * if appropriate.

   131      */

   132     SSLSocketImpl(SSLContextImpl sslContext, String peerHost,

   133             int peerPort) throws IOException, UnknownHostException {

   134         super();

   135         this.sslContext = sslContext;

   136         HandshakeHash handshakeHash = new HandshakeHash();

   137         this.conContext = new TransportContext(sslContext, this,

   138                 new SSLSocketInputRecord(handshakeHash),

   139                 new SSLSocketOutputRecord(handshakeHash), true);

   140         this.peerHost = peerHost;

   420                host != null ? new InetSocketAddress(host, port) :

   142                peerHost != null ? new InetSocketAddress(peerHost, peerPort) :

   421                new InetSocketAddress(InetAddress.getByName(null), port);

   143                new InetSocketAddress(InetAddress.getByName(null), peerPort);

   425 

   147     /**

   426     /**

   148      * Constructs an SSL connection to a server at a specified

   427      * Constructs an SSL connection to a server at a specified address.

   149      * address, and TCP port, using the authentication context

   428      * and TCP port, using the authentication context provided.  This

   150      * provided.

   429      * endpoint acts as the client, and may rejoin an existing SSL session

   151      *

   430      * if appropriate.

   152      * This endpoint acts as the client, and may rejoin an existing SSL

   431      *

   153      * session if appropriate.

   432      * @param context authentication context to use

   154      */

   433      * @param address the server's host

   155     SSLSocketImpl(SSLContextImpl sslContext,

   434      * @param port its port

   156             InetAddress address, int peerPort) throws IOException {

   435      */

   436     SSLSocketImpl(SSLContextImpl context, InetAddress host, int port)

   437             throws IOException {

   439         init(context, false);

   158         this.sslContext = sslContext;

   440         SocketAddress socketAddress = new InetSocketAddress(host, port);

   159         HandshakeHash handshakeHash = new HandshakeHash();

   160         this.conContext = new TransportContext(sslContext, this,

   161                 new SSLSocketInputRecord(handshakeHash),

   162                 new SSLSocketOutputRecord(handshakeHash), true);

   163 

   164         SocketAddress socketAddress = new InetSocketAddress(address, peerPort);

   445      * Constructs an SSL connection to a named host at a specified port,

   169      * Constructs an SSL connection to a named host at a specified

   446      * using the authentication context provided.  This endpoint acts as

   170      * port, using the authentication context provided.

   447      * the client, and may rejoin an existing SSL session if appropriate.

   171      *

   448      *

   172      * This endpoint acts as the client, and may rejoin an existing SSL

   449      * @param context authentication context to use

   173      * session if appropriate.

   450      * @param host name of the host with which to connect

   174      */

   451      * @param port number of the server's port

   175     SSLSocketImpl(SSLContextImpl sslContext,

   452      * @param localAddr the local address the socket is bound to

   176             String peerHost, int peerPort, InetAddress localAddr,

   453      * @param localPort the local port the socket is bound to

   177             int localPort) throws IOException, UnknownHostException {

   454      */

   455     SSLSocketImpl(SSLContextImpl context, String host, int port,

   456             InetAddress localAddr, int localPort)

   457             throws IOException, UnknownHostException {

   459         this.host = host;

   179         this.sslContext = sslContext;

   460         this.serverNames =

   180         HandshakeHash handshakeHash = new HandshakeHash();

   461             Utilities.addToSNIServerNameList(this.serverNames, this.host);

   181         this.conContext = new TransportContext(sslContext, this,

   462         init(context, false);

   182                 new SSLSocketInputRecord(handshakeHash),

   183                 new SSLSocketOutputRecord(handshakeHash), true);

   184         this.peerHost = peerHost;

   185 

   465                host != null ? new InetSocketAddress(host, port) :

   188                peerHost != null ? new InetSocketAddress(peerHost, peerPort) :

   466                new InetSocketAddress(InetAddress.getByName(null), port);

   189                new InetSocketAddress(InetAddress.getByName(null), peerPort);

   470 

   193     /**

   471     /**

   194      * Constructs an SSL connection to a server at a specified

   472      * Constructs an SSL connection to a server at a specified address.

   195      * address, and TCP port, using the authentication context

   473      * and TCP port, using the authentication context provided.  This

   196      * provided.

   474      * endpoint acts as the client, and may rejoin an existing SSL session

   197      *

   475      * if appropriate.

   198      * This endpoint acts as the client, and may rejoin an existing SSL

   476      *

   199      * session if appropriate.

   477      * @param context authentication context to use

   200      */

   478      * @param address the server's host

   201     SSLSocketImpl(SSLContextImpl sslContext,

   479      * @param port its port

   202             InetAddress peerAddr, int peerPort,

   480      * @param localAddr the local address the socket is bound to

   203             InetAddress localAddr, int localPort) throws IOException {

   481      * @param localPort the local port the socket is bound to

   482      */

   483     SSLSocketImpl(SSLContextImpl context, InetAddress host, int port,

   484             InetAddress localAddr, int localPort)

   485             throws IOException {

   487         init(context, false);

   205         this.sslContext = sslContext;

   206         HandshakeHash handshakeHash = new HandshakeHash();

   207         this.conContext = new TransportContext(sslContext, this,

   208                 new SSLSocketInputRecord(handshakeHash),

   209                 new SSLSocketOutputRecord(handshakeHash), true);

   210 

   489         SocketAddress socketAddress = new InetSocketAddress(host, port);

   212         SocketAddress socketAddress = new InetSocketAddress(peerAddr, peerPort);

   575     SSLSocketImpl(SSLContextImpl context, Socket sock,

   222     SSLSocketImpl(SSLContextImpl sslContext, Socket sock,

   583         // In server mode, it is not necessary to set host and serverNames.

   230         this.sslContext = sslContext;

   584         // Otherwise, would require a reverse DNS lookup to get the hostname.

   231         HandshakeHash handshakeHash = new HandshakeHash();

   585 

   232         this.conContext = new TransportContext(sslContext, this,

   586         init(context, true);

   233                 new SSLSocketInputRecord(handshakeHash),

   234                 new SSLSocketOutputRecord(handshakeHash), false);

   592      * Initializes the client socket.

   240      * Layer SSL traffic over an existing connection, rather than

   593      */

   241      * creating a new connection.

   594     private void init(SSLContextImpl context, boolean isServer) {

   242      *

   595         sslContext = context;

   243      * The existing connection may be used only for SSL traffic (using this

   596         sess = SSLSessionImpl.nullSession;

   244      * SSLSocket) until the SSLSocket.close() call returns. However, if a

   597         handshakeSession = null;

   245      * protocol error is detected, that existing connection is automatically

   598 

   246      * closed.

   599         /*

   247      * <p>

   600          * role is as specified, state is START until after

   248      * This particular constructor always uses the socket in the

   601          * the low level connection's established.

   249      * role of an SSL client. It may be useful in cases which start

   602          */

   250      * using SSL after some initial data transfers, for example in some

   603         roleIsServer = isServer;

   251      * SSL tunneling applications or as part of some kinds of application

   604         connectionState = cs_START;

   252      * protocols which negotiate use of a SSL based security.

   605 

   253      */

   606         // initial security parameters for secure renegotiation

   254     SSLSocketImpl(SSLContextImpl sslContext, Socket sock,

   607         secureRenegotiation = false;

   255             String peerHost, int port, boolean autoClose) throws IOException {

   608         clientVerifyData = new byte[0];

   256         super(sock);

   609         serverVerifyData = new byte[0];

   257         // We always layer over a connected socket

   610 

   258         if (!sock.isConnected()) {

   611         enabledCipherSuites =

   259             throw new SocketException("Underlying socket is not connected");

   612                 sslContext.getDefaultCipherSuiteList(roleIsServer);

   260         }

   613         enabledProtocols =

   261 

   614                 sslContext.getDefaultProtocolList(roleIsServer);

   262         this.sslContext = sslContext;

   615 

   263         HandshakeHash handshakeHash = new HandshakeHash();

   616         inputRecord = new SSLSocketInputRecord();;

   264         this.conContext = new TransportContext(sslContext, this,

   617         outputRecord = new SSLSocketOutputRecord();

   265                 new SSLSocketInputRecord(handshakeHash),

   618 

   266                 new SSLSocketOutputRecord(handshakeHash), true);

   619         maximumPacketSize = outputRecord.getMaxPacketSize();

   267         this.peerHost = peerHost;

   620 

   268         this.autoClose = autoClose;

   621         // save the acc

   269         doneConnect();

   622         acc = AccessController.getContext();

   270     }

   623 

   271 

   624         input = new AppInputStream(this);

   272     @Override

   625         output = new AppOutputStream(this);

   273     public void connect(SocketAddress endpoint,

   626     }

   274             int timeout) throws IOException {

   627 

   628     /**

   629      * Connects this socket to the server with a specified timeout

   630      * value.

   631      *

   632      * This method is either called on an unconnected SSLSocketImpl by the

   633      * application, or it is called in the constructor of a regular

   634      * SSLSocketImpl. If we are layering on top on another socket, then

   635      * this method should not be called, because we assume that the

   636      * underlying socket is already connected by the time it is passed to

   637      * us.

   638      *

   639      * @param   endpoint the <code>SocketAddress</code>

   640      * @param   timeout  the timeout value to be used, 0 is no timeout

   641      * @throws  IOException if an error occurs during the connection

   642      * @throws  SocketTimeoutException if timeout expires before connecting

   643      */

   644     @Override

   645     public void connect(SocketAddress endpoint, int timeout)

   646             throws IOException {

   654                                   "Cannot handle non-Inet socket addresses.");

   282                     "Cannot handle non-Inet socket addresses.");

   666     /**

   289     @Override

   667      * Initialize the handshaker and socket streams.

   290     public String[] getSupportedCipherSuites() {

   668      *

   291         return CipherSuite.namesOf(sslContext.getSupportedCipherSuites());

   669      * Called by connect, the layered constructor, and SSLServerSocket.

   292     }

   670      */

   293 

   671     void doneConnect() throws IOException {

   294     @Override

   672         /*

   295     public synchronized String[] getEnabledCipherSuites() {

   673          * Save the input and output streams.  May be done only after

   296         return CipherSuite.namesOf(conContext.sslConfig.enabledCipherSuites);

   674          * java.net actually connects using the socket "self", else

   297     }

   675          * we get some pretty bizarre failure modes.

   298 

   299     @Override

   300     public synchronized void setEnabledCipherSuites(String[] suites) {

   301         conContext.sslConfig.enabledCipherSuites =

   302                 CipherSuite.validValuesOf(suites);

   303     }

   304 

   305     @Override

   306     public String[] getSupportedProtocols() {

   307         return ProtocolVersion.toStringArray(

   308                 sslContext.getSupportedProtocolVersions());

   309     }

   310 

   311     @Override

   312     public synchronized String[] getEnabledProtocols() {

   313         return ProtocolVersion.toStringArray(

   314                 conContext.sslConfig.enabledProtocols);

   315     }

   316 

   317     @Override

   318     public synchronized void setEnabledProtocols(String[] protocols) {

   319         if (protocols == null) {

   320             throw new IllegalArgumentException("Protocols cannot be null");

   321         }

   322 

   323         conContext.sslConfig.enabledProtocols =

   324                 ProtocolVersion.namesOf(protocols);

   325     }

   326 

   327     @Override

   328     public synchronized SSLSession getSession() {

   329         try {

   330             // start handshaking, if failed, the connection will be closed.

   331             ensureNegotiated();

   332         } catch (IOException ioe) {

   333             if (SSLLogger.isOn && SSLLogger.isOn("handshake")) {

   334                 SSLLogger.severe("handshake failed", ioe);

   335             }

   336 

   337             return SSLSessionImpl.nullSession;

   338         }

   339 

   340         return conContext.conSession;

   341     }

   342 

   343     @Override

   344     public synchronized SSLSession getHandshakeSession() {

   345         if (conContext.handshakeContext != null) {

   346             return conContext.handshakeContext.handshakeSession;

   347         }

   348 

   349         return null;

   350     }

   351 

   352     @Override

   353     public synchronized void addHandshakeCompletedListener(

   354             HandshakeCompletedListener listener) {

   355         if (listener == null) {

   356             throw new IllegalArgumentException("listener is null");

   357         }

   358 

   359         conContext.sslConfig.addHandshakeCompletedListener(listener);

   360     }

   361 

   362     @Override

   363     public synchronized void removeHandshakeCompletedListener(

   364             HandshakeCompletedListener listener) {

   365         if (listener == null) {

   366             throw new IllegalArgumentException("listener is null");

   367         }

   368 

   369         conContext.sslConfig.removeHandshakeCompletedListener(listener);

   370     }

   371 

   372     @Override

   373     public synchronized void startHandshake() throws IOException {

   374         checkWrite();

   375         try {

   376             conContext.kickstart();

   377 

   378             // All initial handshaking goes through this operation until we

   379             // have a valid SSL connection.

   380             //

   381             // Handle handshake messages only, need no application data.

   382             if (!conContext.isNegotiated) {

   383                 readRecord();

   384             }

   385         } catch (IOException ioe) {

   386             conContext.fatal(Alert.HANDSHAKE_FAILURE,

   387                 "Couldn't kickstart handshaking", ioe);

   388         } catch (Exception oe) {    // including RuntimeException

   389             handleException(oe);

   390         }

   391     }

   392 

   393     @Override

   394     public synchronized void setUseClientMode(boolean mode) {

   395         conContext.setUseClientMode(mode);

   396     }

   397 

   398     @Override

   399     public synchronized boolean getUseClientMode() {

   400         return conContext.sslConfig.isClientMode;

   401     }

   402 

   403     @Override

   404     public synchronized void setNeedClientAuth(boolean need) {

   405         conContext.sslConfig.clientAuthType =

   406                 (need ? ClientAuthType.CLIENT_AUTH_REQUIRED :

   407                         ClientAuthType.CLIENT_AUTH_NONE);

   408     }

   409 

   410     @Override

   411     public synchronized boolean getNeedClientAuth() {

   412         return (conContext.sslConfig.clientAuthType ==

   413                         ClientAuthType.CLIENT_AUTH_REQUIRED);

   414     }

   415 

   416     @Override

   417     public synchronized void setWantClientAuth(boolean want) {

   418         conContext.sslConfig.clientAuthType =

   419                 (want ? ClientAuthType.CLIENT_AUTH_REQUESTED :

   420                         ClientAuthType.CLIENT_AUTH_NONE);

   421     }

   422 

   423     @Override

   424     public synchronized boolean getWantClientAuth() {

   425         return (conContext.sslConfig.clientAuthType ==

   426                         ClientAuthType.CLIENT_AUTH_REQUESTED);

   427     }

   428 

   429     @Override

   430     public synchronized void setEnableSessionCreation(boolean flag) {

   431         conContext.sslConfig.enableSessionCreation = flag;

   432     }

   433 

   434     @Override

   435     public synchronized boolean getEnableSessionCreation() {

   436         return conContext.sslConfig.enableSessionCreation;

   437     }

   438 

   439     @Override

   440     public synchronized boolean isClosed() {

   441         return tlsIsClosed && conContext.isClosed();

   442     }

   443 

   444     @Override

   445     public synchronized void close() throws IOException {

   446         try {

   447             conContext.close();

   448         } catch (IOException ioe) {

   449             // ignore the exception

   450             if (SSLLogger.isOn && SSLLogger.isOn("ssl")) {

   451                 SSLLogger.warning("connection context closure failed", ioe);

   452             }

   453         } finally {

   454             tlsIsClosed = true;

   455         }

   456     }

   457 

   458     @Override

   459     public synchronized InputStream getInputStream() throws IOException {

   460         if (isClosed() || conContext.isInboundDone()) {

   461             throw new SocketException("Socket or inbound is closed");

   462         }

   463 

   464         if (!isConnected) {

   465             throw new SocketException("Socket is not connected");

   466         }

   467 

   468         return appInput;

   469     }

   470 

   471     private synchronized void ensureNegotiated() throws IOException {

   472         if (conContext.isNegotiated ||

   473                 conContext.isClosed() || conContext.isBroken) {

   474             return;

   475         }

   476 

   477         startHandshake();

   478     }

   479 

   480     /**

   481      * InputStream for application data as returned by

   482      * SSLSocket.getInputStream().

   483      */

   484     private class AppInputStream extends InputStream {

   485         // One element array used to implement the single byte read() method

   486         private final byte[] oneByte = new byte[1];

   487 

   488         // the temporary buffer used to read network

   489         private ByteBuffer buffer;

   490 

   491         // Is application data available in the stream?

   492         private boolean appDataIsAvailable;

   493 

   494         AppInputStream() {

   495             this.appDataIsAvailable = false;

   496             this.buffer = ByteBuffer.allocate(4096);

   497         }

   498 

   499         /**

   500          * Return the minimum number of bytes that can be read

   501          * without blocking.

   677         sockInput = super.getInputStream();

   503         @Override

   678         sockOutput = super.getOutputStream();

   504         public int available() throws IOException {

   679 

   505             // Currently not synchronized.

   680         inputRecord.setDeliverStream(sockOutput);

   506             if ((!appDataIsAvailable) || checkEOF()) {

   681         outputRecord.setDeliverStream(sockOutput);

   507                 return 0;

   682 

   508             }

   683         /*

   509 

   684          * Move to handshaking state, with pending session initialized

   510             return buffer.remaining();

   685          * to defaults and the appropriate kind of handshaker set up.

   511         }

   512 

   513         /**

   514          * Read a single byte, returning -1 on non-fault EOF status.

   687         initHandshaker();

   516         @Override

   688     }

   517         public synchronized int read() throws IOException {

   689 

   518             int n = read(oneByte, 0, 1);

   690     private synchronized int getConnectionState() {

   519             if (n <= 0) {   // EOF

   691         return connectionState;

   520                 return -1;

   692     }

   521             }

   693 

   522 

   694     private synchronized void setConnectionState(int state) {

   523             return oneByte[0] & 0xFF;

   695         connectionState = state;

   524         }

   696     }

   525 

   697 

   526         /**

   698     AccessControlContext getAcc() {

   527          * Reads up to {@code len} bytes of data from the input stream

   699         return acc;

   528          * into an array of bytes.

   700     }

   529          *

   701 

   530          * An attempt is made to read as many as {@code len} bytes, but a

   702     //

   531          * smaller number may be read. The number of bytes actually read

   703     // READING AND WRITING RECORDS

   532          * is returned as an integer.

   704     //

   533          *

   705 

   534          * If the layer above needs more data, it asks for more, so we

   706     /*

   535          * are responsible only for blocking to fill at most one buffer,

   707      * Application data record output.

   536          * and returning "-1" on non-fault EOF status.

   708      *

   709      * Application data can't be sent until the first handshake establishes

   710      * a session.

   711      */

   712     void writeRecord(byte[] source, int offset, int length) throws IOException {

   713         /*

   714          * The loop is in case of HANDSHAKE --> ERROR transitions, etc

   716         // Don't bother to check the emptiness of source applicatoin data

   538         @Override

   717         // before the security connection established.

   539         public synchronized int read(byte[] b, int off, int len)

   718         for (boolean readyForApp = false; !readyForApp;) {

   540                 throws IOException {

   719             /*

   541             if (b == null) {

   720              * Not all states support passing application data.  We

   542                 throw new NullPointerException("the target buffer is null");

   721              * synchronize access to the connection state, so that

   543             } else if (off < 0 || len < 0 || len > b.length - off) {

   722              * synchronous handshakes can complete cleanly.

   544                 throw new IndexOutOfBoundsException(

   723              */

   545                         "buffer length: " + b.length + ", offset; " + off +

   724             switch (getConnectionState()) {

   546                         ", bytes to read:" + len);

   725 

   547             } else if (len == 0) {

   548                 return 0;

   549             }

   550 

   551             if (checkEOF()) {

   552                 return -1;

   553             }

   554 

   555             // start handshaking if the connection has not been negotiated.

   556             if (!conContext.isNegotiated &&

   557                     !conContext.isClosed() && !conContext.isBroken) {

   558                 ensureNegotiated();

   559             }

   560 

   561             // Read the available bytes at first.

   562             int remains = available();

   563             if (remains > 0) {

   564                 int howmany = Math.min(remains, len);

   565                 buffer.get(b, off, howmany);

   566 

   567                 return howmany;

   568             }

   569 

   570             appDataIsAvailable = false;

   571             int volume = 0;

   572             try {

   727                  * We've deferred the initial handshaking till just now,

   574                  * Read data if needed ... notice that the connection

   728                  * when presumably a thread's decided it's OK to block for

   575                  * guarantees that handshake, alert, and change cipher spec

   729                  * longish periods of time for I/O purposes (as well as

   576                  * data streams are handled as they arrive, so we never

   730                  * configured the cipher suites it wants to use).

   577                  * see them here.

   732                 case cs_HANDSHAKE:

   579                 while (volume == 0) {

   733                     performInitialHandshake();

   580                     // Clear the buffer for a new record reading.

   581                     buffer.clear();

   582 

   583                     // grow the buffer if needed

   584                     int inLen = conContext.inputRecord.bytesInCompletePacket();

   585                     if (inLen < 0) {    // EOF

   586                         handleEOF(null);

   587 

   588                         // if no exception thrown

   589                         return -1;

   590                     }

   591 

   592                     // Is this packet bigger than SSL/TLS normally allows?

   593                     if (inLen > SSLRecord.maxLargeRecordSize) {

   594                         throw new SSLProtocolException(

   595                                 "Illegal packet size: " + inLen);

   596                     }

   597 

   598                     if (inLen > buffer.remaining()) {

   599                         buffer = ByteBuffer.allocate(inLen);

   600                     }

   601 

   602                     volume = readRecord(buffer);

   603                     buffer.flip();

   604                     if (volume < 0) {   // EOF

   605                         // treat like receiving a close_notify warning message.

   606                         conContext.isInputCloseNotified = true;

   607                         conContext.closeInbound();

   608                         return -1;

   609                     } else if (volume > 0) {

   610                         appDataIsAvailable = true;

   611                         break;

   612                     }

   613                 }

   614 

   615                 // file the destination buffer

   616                 int howmany = Math.min(len, volume);

   617                 buffer.get(b, off, howmany);

   618                 return howmany;

   619             } catch (Exception e) {   // including RuntimeException

   620                 // shutdown and rethrow (wrapped) exception as appropriate

   621                 handleException(e);

   622 

   623                 // dummy for compiler

   624                 return -1;

   625             }

   626         }

   627 

   628         /**

   629          * Skip n bytes.

   630          *

   631          * This implementation is somewhat less efficient than possible, but

   632          * not badly so (redundant copy).  We reuse the read() code to keep

   633          * things simpler. Note that SKIP_ARRAY is static and may garbled by

   634          * concurrent use, but we are not interested in the data anyway.

   635          */

   636         @Override

   637         public synchronized long skip(long n) throws IOException {

   638             // dummy array used to implement skip()

   639             byte[] skipArray = new byte[256];

   640 

   641             long skipped = 0;

   642             while (n > 0) {

   643                 int len = (int)Math.min(n, skipArray.length);

   644                 int r = read(skipArray, 0, len);

   645                 if (r <= 0) {

   735 

   647                 }

   736                 case cs_DATA:

   648                 n -= r;

   737                 case cs_RENEGOTIATE:

   649                 skipped += r;

   738                     readyForApp = true;

   650             }

   739                     break;

   651 

   740 

   652             return skipped;

   741                 case cs_ERROR:

   653         }

   742                     fatal(Alerts.alert_close_notify,

   654 

   743                             "error while writing to socket");

   655         @Override

   744                     break; // dummy

   656         public void close() throws IOException {

   745 

   657             if (SSLLogger.isOn && SSLLogger.isOn("ssl")) {

   746                 case cs_SENT_CLOSE:

   658                 SSLLogger.finest("Closing input stream");

   747                 case cs_CLOSED:

   659             }

   748                 case cs_APP_CLOSED:

   660 

   749                     // we should never get here (check in AppOutputStream)

   661             conContext.closeInbound();

   750                     // this is just a fallback

   662         }

   751                     if (closeReason != null) {

   663     }

   752                         throw closeReason;

   664 

   753                     } else {

   665     @Override

   754                         throw new SocketException("Socket closed");

   666     public synchronized OutputStream getOutputStream() throws IOException {

   755                     }

   667         if (isClosed() || conContext.isOutboundDone()) {

   756 

   668             throw new SocketException("Socket or outbound is closed");

   757                 /*

   669         }

   758                  * Else something's goofy in this state machine's use.

   670 

   759                  */

   671         if (!isConnected) {

   760                 default:

   672             throw new SocketException("Socket is not connected");

   761                     throw new SSLProtocolException(

   673         }

   762                             "State error, send app data");

   674 

   763             }

   675         return appOutput;

   676     }

   677 

   678 

   679     /**

   680      * OutputStream for application data as returned by

   681      * SSLSocket.getOutputStream().

   682      */

   683     private class AppOutputStream extends OutputStream {

   684         // One element array used to implement the write(byte) method

   685         private final byte[] oneByte = new byte[1];

   686 

   687         @Override

   688         public void write(int i) throws IOException {

   689             oneByte[0] = (byte)i;

   690             write(oneByte, 0, 1);

   691         }

   692 

   693         @Override

   694         public synchronized void write(byte[] b,

   695                 int off, int len) throws IOException {

   696             if (b == null) {

   697                 throw new NullPointerException("the source buffer is null");

   698             } else if (off < 0 || len < 0 || len > b.length - off) {

   699                 throw new IndexOutOfBoundsException(

   700                         "buffer length: " + b.length + ", offset; " + off +

   701                         ", bytes to read:" + len);

   702             } else if (len == 0) {

   703                 return;

   704             }

   705 

   706             // start handshaking if the connection has not been negotiated.

   707             if (!conContext.isNegotiated &&

   708                     !conContext.isClosed() && !conContext.isBroken) {

   709                 ensureNegotiated();

   710             }

   711