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 }