1 /*

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

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 /*

    27  * @test

    28  * @bug 4873188

    29  * @summary Support TLS 1.1

    30  * @run main/othervm GenericStreamCipher

    31  *

    32  *     SunJSSE does not support dynamic system properties, no way to re-use

    33  *     system properties in samevm/agentvm mode.

    34  *

    35  * @author Xuelei Fan

    36  */

    37 

    38 import java.io.*;

    39 import java.net.*;

    40 import javax.net.ssl.*;

    41 

    42 public class GenericStreamCipher {

    43 

    44     /*

    45      * =============================================================

    46      * Set the various variables needed for the tests, then

    47      * specify what tests to run on each side.

    48      */

    49 

    50     /*

    51      * Should we run the client or server in a separate thread?

    52      * Both sides can throw exceptions, but do you have a preference

    53      * as to which side should be the main thread.

    54      */

    55     static boolean separateServerThread = false;

    56 

    57     /*

    58      * Where do we find the keystores?

    59      */

    60     static String pathToStores = "../etc";

    61     static String keyStoreFile = "keystore";

    62     static String trustStoreFile = "truststore";

    63     static String passwd = "passphrase";

    64 

    65     /*

    66      * Is the server ready to serve?

    67      */

    68     volatile static boolean serverReady = false;

    69 

    70     /*

    71      * Turn on SSL debugging?

    72      */

    73     static boolean debug = false;

    74 

    75     /*

    76      * If the client or server is doing some kind of object creation

    77      * that the other side depends on, and that thread prematurely

    78      * exits, you may experience a hang.  The test harness will

    79      * terminate all hung threads after its timeout has expired,

    80      * currently 3 minutes by default, but you might try to be

    81      * smart about it....

    82      */

    83 

    84     /*

    85      * Define the server side of the test.

    86      *

    87      * If the server prematurely exits, serverReady will be set to true

    88      * to avoid infinite hangs.

    89      */

    90     void doServerSide() throws Exception {

    91         SSLServerSocketFactory sslssf =

    92             (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();

    93         SSLServerSocket sslServerSocket =

    94             (SSLServerSocket) sslssf.createServerSocket(serverPort);

    95 

    96         serverPort = sslServerSocket.getLocalPort();

    97 

    98         /*

    99          * Signal Client, we're ready for his connect.

   100          */

   101         serverReady = true;

   102 

   103         SSLSocket sslSocket = (SSLSocket) sslServerSocket.accept();

   104         InputStream sslIS = sslSocket.getInputStream();

   105         OutputStream sslOS = sslSocket.getOutputStream();

   106 

   107         sslIS.read();

   108         sslOS.write('A');

   109         sslOS.flush();

   110 

   111         sslSocket.close();

   112     }

   113 

   114     /*

   115      * Define the client side of the test.

   116      *

   117      * If the server prematurely exits, serverReady will be set to true

   118      * to avoid infinite hangs.

   119      */

   120     void doClientSide() throws Exception {

   121 

   122         /*

   123          * Wait for server to get started.

   124          */

   125         while (!serverReady) {

   126             Thread.sleep(50);

   127         }

   128 

   129         SSLSocketFactory sslsf =

   130             (SSLSocketFactory) SSLSocketFactory.getDefault();

   131         SSLSocket sslSocket = (SSLSocket)

   132             sslsf.createSocket("localhost", serverPort);

   133 

   134         // enable TLSv1.1 only

   135         sslSocket.setEnabledProtocols(new String[] {"TLSv1.1"});

   136 

   137         // enable a stream cipher

   138         sslSocket.setEnabledCipherSuites(

   139             new String[] {"SSL_RSA_WITH_RC4_128_MD5"});

   140 

   141         InputStream sslIS = sslSocket.getInputStream();

   142         OutputStream sslOS = sslSocket.getOutputStream();

   143 

   144         sslOS.write('B');

   145         sslOS.flush();

   146         sslIS.read();

   147 

   148         sslSocket.close();

   149     }

   150 

   151     /*

   152      * =============================================================

   153      * The remainder is just support stuff

   154      */

   155 

   156     // use any free port by default

   157     volatile int serverPort = 0;

   158 

   159     volatile Exception serverException = null;

   160     volatile Exception clientException = null;

   161 

   162     public static void main(String[] args) throws Exception {

   163         String keyFilename =

   164             System.getProperty("test.src", ".") + "/" + pathToStores +

   165                 "/" + keyStoreFile;

   166         String trustFilename =

   167             System.getProperty("test.src", ".") + "/" + pathToStores +

   168                 "/" + trustStoreFile;

   169 

   170         System.setProperty("javax.net.ssl.keyStore", keyFilename);

   171         System.setProperty("javax.net.ssl.keyStorePassword", passwd);

   172         System.setProperty("javax.net.ssl.trustStore", trustFilename);

   173         System.setProperty("javax.net.ssl.trustStorePassword", passwd);

   174 

   175         if (debug)

   176             System.setProperty("javax.net.debug", "all");

   177 

   178         /*

   179          * Start the tests.

   180          */

   181         new GenericStreamCipher();

   182     }

   183 

   184     Thread clientThread = null;

   185     Thread serverThread = null;

   186 

   187     /*

   188      * Primary constructor, used to drive remainder of the test.

   189      *

   190      * Fork off the other side, then do your work.

   191      */

   192     GenericStreamCipher() throws Exception {

   193         try {

   194             if (separateServerThread) {

   195                 startServer(true);

   196                 startClient(false);

   197             } else {

   198                 startClient(true);

   199                 startServer(false);

   200             }

   201         } catch (Exception e) {

   202             // swallow for now.  Show later

   203         }

   204 

   205         /*

   206          * Wait for other side to close down.

   207          */

   208         if (separateServerThread) {

   209             serverThread.join();

   210         } else {

   211             clientThread.join();

   212         }

   213 

   214         /*

   215          * When we get here, the test is pretty much over.

   216          * Which side threw the error?

   217          */

   218         Exception local;

   219         Exception remote;

   220         String whichRemote;

   221 

   222         if (separateServerThread) {

   223             remote = serverException;

   224             local = clientException;

   225             whichRemote = "server";

   226         } else {

   227             remote = clientException;

   228             local = serverException;

   229             whichRemote = "client";

   230         }

   231 

   232         /*

   233          * If both failed, return the curthread's exception, but also

   234          * print the remote side Exception

   235          */

   236         if ((local != null) && (remote != null)) {

   237             System.out.println(whichRemote + " also threw:");

   238             remote.printStackTrace();

   239             System.out.println();

   240             throw local;

   241         }

   242 

   243         if (remote != null) {

   244             throw remote;

   245         }

   246 

   247         if (local != null) {

   248             throw local;

   249         }

   250     }

   251 

   252     void startServer(boolean newThread) throws Exception {

   253         if (newThread) {

   254             serverThread = new Thread() {

   255                 public void run() {

   256                     try {

   257                         doServerSide();

   258                     } catch (Exception e) {

   259                         /*

   260                          * Our server thread just died.

   261                          *

   262                          * Release the client, if not active already...

   263                          */

   264                         System.err.println("Server died...");

   265                         serverReady = true;

   266                         serverException = e;

   267                     }

   268                 }

   269             };

   270             serverThread.start();

   271         } else {

   272             try {

   273                 doServerSide();

   274             } catch (Exception e) {

   275                 serverException = e;

   276             } finally {

   277                 serverReady = true;

   278             }

   279         }

   280     }

   281 

   282     void startClient(boolean newThread) throws Exception {

   283         if (newThread) {

   284             clientThread = new Thread() {

   285                 public void run() {

   286                     try {

   287                         doClientSide();

   288                     } catch (Exception e) {

   289                         /*

   290                          * Our client thread just died.

   291                          */

   292                         System.err.println("Client died...");

   293                         clientException = e;

   294                     }

   295                 }

   296             };

   297             clientThread.start();

   298         } else {

   299             try {

   300                 doClientSide();

   301             } catch (Exception e) {

   302                 clientException = e;

   303             }

   304         }

   305     }

   306 }