1 /* 2 * Copyright (c) 2013, 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. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 // SunJSSE does not support dynamic system properties, no way to re-use 25 // system properties in samevm/agentvm mode. 26 27 /* 28 * @test 29 * @bug 7188658 30 * @summary Add possibility to disable client initiated renegotiation 31 * @run main/othervm -Djdk.tls.rejectClientInitiatedRenegotiation=true 32 * NoImpactServerRenego SSLv3 33 * @run main/othervm -Djdk.tls.rejectClientInitiatedRenegotiation=true 34 * NoImpactServerRenego TLSv1 35 * @run main/othervm -Djdk.tls.rejectClientInitiatedRenegotiation=true 36 * NoImpactServerRenego TLSv1.1 37 * @run main/othervm -Djdk.tls.rejectClientInitiatedRenegotiation=true 38 * NoImpactServerRenego TLSv1.2 39 */ 40 41 import java.io.*; 42 import java.net.*; 43 import java.security.Security; 44 import javax.net.ssl.*; 45 46 public class NoImpactServerRenego implements 47 HandshakeCompletedListener { 48 49 static byte handshakesCompleted = 0; 50 51 /* 52 * Define what happens when handshaking is completed 53 */ 54 public void handshakeCompleted(HandshakeCompletedEvent event) { 55 synchronized (this) { 56 handshakesCompleted++; 57 System.out.println("Session: " + event.getSession().toString()); 58 System.out.println("Seen handshake completed #" + 59 handshakesCompleted); 60 } 61 } 62 63 /* 64 * ============================================================= 65 * Set the various variables needed for the tests, then 66 * specify what tests to run on each side. 67 */ 68 69 /* 70 * Should we run the client or server in a separate thread? 71 * Both sides can throw exceptions, but do you have a preference 72 * as to which side should be the main thread. 73 */ 74 static boolean separateServerThread = false; 75 76 /* 77 * Where do we find the keystores? 78 */ 79 static String pathToStores = "../../../../javax/net/ssl/etc"; 80 static String keyStoreFile = "keystore"; 81 static String trustStoreFile = "truststore"; 82 static String passwd = "passphrase"; 83 84 /* 85 * Is the server ready to serve? 86 */ 87 volatile static boolean serverReady = false; 88 89 /* 90 * Turn on SSL debugging? 91 */ 92 static boolean debug = false; 93 94 /* 95 * If the client or server is doing some kind of object creation 96 * that the other side depends on, and that thread prematurely 97 * exits, you may experience a hang. The test harness will 98 * terminate all hung threads after its timeout has expired, 99 * currently 3 minutes by default, but you might try to be 100 * smart about it.... 101 */ 102 103 /* 104 * Define the server side of the test. 105 * 106 * If the server prematurely exits, serverReady will be set to true 107 * to avoid infinite hangs. 108 */ 109 void doServerSide() throws Exception { 110 SSLServerSocketFactory sslssf = 111 (SSLServerSocketFactory) SSLServerSocketFactory.getDefault(); 112 SSLServerSocket sslServerSocket = 113 (SSLServerSocket) sslssf.createServerSocket(serverPort); 114 115 serverPort = sslServerSocket.getLocalPort(); 116 117 /* 118 * Signal Client, we're ready for his connect. 119 */ 120 serverReady = true; 121 122 SSLSocket sslSocket = (SSLSocket) sslServerSocket.accept(); 123 sslSocket.addHandshakeCompletedListener(this); 124 InputStream sslIS = sslSocket.getInputStream(); 125 OutputStream sslOS = sslSocket.getOutputStream(); 126 127 for (int i = 0; i < 10; i++) { 128 sslIS.read(); 129 sslOS.write(85); 130 sslOS.flush(); 131 } 132 133 System.out.println("invalidating"); 134 sslSocket.getSession().invalidate(); 135 System.out.println("starting new handshake"); 136 sslSocket.startHandshake(); 137 138 for (int i = 0; i < 10; i++) { 139 System.out.println("sending/receiving data, iteration: " + i); 140 sslIS.read(); 141 sslOS.write(85); 142 sslOS.flush(); 143 } 144 145 sslSocket.close(); 146 } 147 148 /* 149 * Define the client side of the test. 150 * 151 * If the server prematurely exits, serverReady will be set to true 152 * to avoid infinite hangs. 153 */ 154 void doClientSide() throws Exception { 155 156 /* 157 * Wait for server to get started. 158 */ 159 while (!serverReady) { 160 Thread.sleep(50); 161 } 162 163 SSLSocketFactory sslsf = 164 (SSLSocketFactory) SSLSocketFactory.getDefault(); 165 SSLSocket sslSocket = (SSLSocket) 166 sslsf.createSocket("localhost", serverPort); 167 sslSocket.setEnabledProtocols(new String[] { tlsProtocol }); 168 169 InputStream sslIS = sslSocket.getInputStream(); 170 OutputStream sslOS = sslSocket.getOutputStream(); 171 172 for (int i = 0; i < 10; i++) { 173 sslOS.write(280); 174 sslOS.flush(); 175 sslIS.read(); 176 } 177 178 for (int i = 0; i < 10; i++) { 179 sslOS.write(280); 180 sslOS.flush(); 181 sslIS.read(); 182 } 183 184 sslSocket.close(); 185 } 186 187 /* 188 * ============================================================= 189 * The remainder is just support stuff 190 */ 191 192 // use any free port by default 193 volatile int serverPort = 0; 194 195 volatile Exception serverException = null; 196 volatile Exception clientException = null; 197 198 // the specified protocol 199 private static String tlsProtocol; 200 201 public static void main(String[] args) throws Exception { 202 String keyFilename = 203 System.getProperty("test.src", "./") + "/" + pathToStores + 204 "/" + keyStoreFile; 205 String trustFilename = 206 System.getProperty("test.src", "./") + "/" + pathToStores + 207 "/" + trustStoreFile; 208 209 System.setProperty("javax.net.ssl.keyStore", keyFilename); 210 System.setProperty("javax.net.ssl.keyStorePassword", passwd); 211 System.setProperty("javax.net.ssl.trustStore", trustFilename); 212 System.setProperty("javax.net.ssl.trustStorePassword", passwd); 213 214 if (debug) { 215 System.setProperty("javax.net.debug", "all"); 216 } 217 218 Security.setProperty("jdk.tls.disabledAlgorithms", ""); 219 220 tlsProtocol = args[0]; 221 222 /* 223 * Start the tests. 224 */ 225 new NoImpactServerRenego(); 226 } 227 228 Thread clientThread = null; 229 Thread serverThread = null; 230 231 /* 232 * Primary constructor, used to drive remainder of the test. 233 * 234 * Fork off the other side, then do your work. 235 */ 236 NoImpactServerRenego() throws Exception { 237 if (separateServerThread) { 238 startServer(true); 239 startClient(false); 240 } else { 241 startClient(true); 242 startServer(false); 243 } 244 245 /* 246 * Wait for other side to close down. 247 */ 248 if (separateServerThread) { 249 serverThread.join(); 250 } else { 251 clientThread.join(); 252 } 253 254 /* 255 * When we get here, the test is pretty much over. 256 * 257 * If the main thread excepted, that propagates back 258 * immediately. If the other thread threw an exception, we 259 * should report back. 260 */ 261 if (serverException != null) { 262 System.out.print("Server Exception:"); 263 throw serverException; 264 } 265 if (clientException != null) { 266 System.out.print("Client Exception:"); 267 throw clientException; 268 } 269 270 /* 271 * Give the Handshaker Thread a chance to run 272 */ 273 Thread.sleep(1000); 274 275 synchronized (this) { 276 if (handshakesCompleted != 2) { 277 throw new Exception("Didn't see 2 handshake completed events."); 278 } 279 } 280 } 281 282 void startServer(boolean newThread) throws Exception { 283 if (newThread) { 284 serverThread = new Thread() { 285 public void run() { 286 try { 287 doServerSide(); 288 } catch (Exception e) { 289 /* 290 * Our server thread just died. 291 * 292 * Release the client, if not active already... 293 */ 294 System.err.println("Server died..."); 295 serverReady = true; 296 serverException = e; 297 } 298 } 299 }; 300 serverThread.start(); 301 } else { 302 doServerSide(); 303 } 304 } 305 306 void startClient(boolean newThread) throws Exception { 307 if (newThread) { 308 clientThread = new Thread() { 309 public void run() { 310 try { 311 doClientSide(); 312 } catch (Exception e) { 313 /* 314 * Our client thread just died. 315 */ 316 System.err.println("Client died..."); 317 clientException = e; 318 } 319 } 320 }; 321 clientThread.start(); 322 } else { 323 doClientSide(); 324 } 325 } 326 }