289 lines
12 KiB
Java
289 lines
12 KiB
Java
|
/*
|
||
|
|
* Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
|
||
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||
|
|
*
|
||
|
|
* This code is free software; you can redistribute it and/or modify it
|
||
|
|
* under the terms of the GNU General Public License version 2 only, as
|
||
|
|
* published by the Free Software Foundation.
|
||
|
|
*
|
||
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
||
|
|
* accompanied this code).
|
||
|
|
*
|
||
|
|
* You should have received a copy of the GNU General Public License version
|
||
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
||
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||
|
|
*
|
||
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||
|
|
* or visit www.oracle.com if you need additional information or have any
|
||
|
|
* questions.
|
||
|
|
*/
|
||
|
|
|
||
|
|
import javax.net.ServerSocketFactory;
|
||
|
|
import javax.net.ssl.SSLContext;
|
||
|
|
import javax.net.ssl.SSLHandshakeException;
|
||
|
|
import javax.net.ssl.SSLSocket;
|
||
|
|
import java.io.DataInputStream;
|
||
|
|
import java.io.IOException;
|
||
|
|
import java.io.UncheckedIOException;
|
||
|
|
import java.net.ServerSocket;
|
||
|
|
import java.net.Socket;
|
||
|
|
import java.net.URI;
|
||
|
|
import java.util.List;
|
||
|
|
import java.util.concurrent.CompletableFuture;
|
||
|
|
import java.util.concurrent.CompletionException;
|
||
|
|
import jdk.incubator.http.HttpClient;
|
||
|
|
import jdk.incubator.http.HttpClient.Version;
|
||
|
|
import jdk.incubator.http.HttpResponse;
|
||
|
|
import jdk.incubator.http.HttpRequest;
|
||
|
|
import static java.lang.System.out;
|
||
|
|
import static jdk.incubator.http.HttpResponse.BodyHandler.discard;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @test
|
||
|
|
* @run main/othervm HandshakeFailureTest
|
||
|
|
* @summary Verify SSLHandshakeException is received when the handshake fails,
|
||
|
|
* either because the server closes ( EOF ) the connection during handshaking
|
||
|
|
* or no cipher suite ( or similar ) can be negotiated.
|
||
|
|
*/
|
||
|
|
// To switch on debugging use:
|
||
|
|
// @run main/othervm -Djdk.internal.httpclient.debug=true HandshakeFailureTest
|
||
|
|
public class HandshakeFailureTest {
|
||
|
|
|
||
|
|
// The number of iterations each testXXXClient performs. Can be increased
|
||
|
|
// when running standalone testing.
|
||
|
|
static final int TIMES = 10;
|
||
|
|
|
||
|
|
public static void main(String[] args) throws Exception {
|
||
|
|
HandshakeFailureTest test = new HandshakeFailureTest();
|
||
|
|
List<AbstractServer> servers = List.of( new PlainServer(), new SSLServer());
|
||
|
|
|
||
|
|
for (AbstractServer server : servers) {
|
||
|
|
try (server) {
|
||
|
|
out.format("%n%n------ Testing with server:%s ------%n", server);
|
||
|
|
URI uri = new URI("https://127.0.0.1:" + server.getPort() + "/");
|
||
|
|
|
||
|
|
test.testSyncSameClient(uri, Version.HTTP_1_1);
|
||
|
|
test.testSyncSameClient(uri, Version.HTTP_2);
|
||
|
|
test.testSyncDiffClient(uri, Version.HTTP_1_1);
|
||
|
|
test.testSyncDiffClient(uri, Version.HTTP_2);
|
||
|
|
|
||
|
|
test.testAsyncSameClient(uri, Version.HTTP_1_1);
|
||
|
|
test.testAsyncSameClient(uri, Version.HTTP_2);
|
||
|
|
test.testAsyncDiffClient(uri, Version.HTTP_1_1);
|
||
|
|
test.testAsyncDiffClient(uri, Version.HTTP_2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void testSyncSameClient(URI uri, Version version) throws Exception {
|
||
|
|
out.printf("%n--- testSyncSameClient %s ---%n", version);
|
||
|
|
HttpClient client = HttpClient.newHttpClient();
|
||
|
|
for (int i = 0; i < TIMES; i++) {
|
||
|
|
out.printf("iteration %d%n", i);
|
||
|
|
HttpRequest request = HttpRequest.newBuilder(uri)
|
||
|
|
.version(version)
|
||
|
|
.build();
|
||
|
|
try {
|
||
|
|
HttpResponse<Void> response = client.send(request, discard(null));
|
||
|
|
String msg = String.format("UNEXPECTED response=%s%n", response);
|
||
|
|
throw new RuntimeException(msg);
|
||
|
|
} catch (SSLHandshakeException expected) {
|
||
|
|
out.printf("Client: caught expected exception: %s%n", expected);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void testSyncDiffClient(URI uri, Version version) throws Exception {
|
||
|
|
out.printf("%n--- testSyncDiffClient %s ---%n", version);
|
||
|
|
for (int i = 0; i < TIMES; i++) {
|
||
|
|
out.printf("iteration %d%n", i);
|
||
|
|
// a new client each time
|
||
|
|
HttpClient client = HttpClient.newHttpClient();
|
||
|
|
HttpRequest request = HttpRequest.newBuilder(uri)
|
||
|
|
.version(version)
|
||
|
|
.build();
|
||
|
|
try {
|
||
|
|
HttpResponse<Void> response = client.send(request, discard(null));
|
||
|
|
String msg = String.format("UNEXPECTED response=%s%n", response);
|
||
|
|
throw new RuntimeException(msg);
|
||
|
|
} catch (SSLHandshakeException expected) {
|
||
|
|
out.printf("Client: caught expected exception: %s%n", expected);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void testAsyncSameClient(URI uri, Version version) throws Exception {
|
||
|
|
out.printf("%n--- testAsyncSameClient %s ---%n", version);
|
||
|
|
HttpClient client = HttpClient.newHttpClient();
|
||
|
|
for (int i = 0; i < TIMES; i++) {
|
||
|
|
out.printf("iteration %d%n", i);
|
||
|
|
HttpRequest request = HttpRequest.newBuilder(uri)
|
||
|
|
.version(version)
|
||
|
|
.build();
|
||
|
|
CompletableFuture<HttpResponse<Void>> response =
|
||
|
|
client.sendAsync(request, discard(null));
|
||
|
|
try {
|
||
|
|
response.join();
|
||
|
|
String msg = String.format("UNEXPECTED response=%s%n", response);
|
||
|
|
throw new RuntimeException(msg);
|
||
|
|
} catch (CompletionException ce) {
|
||
|
|
if (ce.getCause() instanceof SSLHandshakeException) {
|
||
|
|
out.printf("Client: caught expected exception: %s%n", ce.getCause());
|
||
|
|
} else {
|
||
|
|
out.printf("Client: caught UNEXPECTED exception: %s%n", ce.getCause());
|
||
|
|
throw ce;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void testAsyncDiffClient(URI uri, Version version) throws Exception {
|
||
|
|
out.printf("%n--- testAsyncDiffClient %s ---%n", version);
|
||
|
|
for (int i = 0; i < TIMES; i++) {
|
||
|
|
out.printf("iteration %d%n", i);
|
||
|
|
// a new client each time
|
||
|
|
HttpClient client = HttpClient.newHttpClient();
|
||
|
|
HttpRequest request = HttpRequest.newBuilder(uri)
|
||
|
|
.version(version)
|
||
|
|
.build();
|
||
|
|
CompletableFuture<HttpResponse<Void>> response =
|
||
|
|
client.sendAsync(request, discard(null));
|
||
|
|
try {
|
||
|
|
response.join();
|
||
|
|
String msg = String.format("UNEXPECTED response=%s%n", response);
|
||
|
|
throw new RuntimeException(msg);
|
||
|
|
} catch (CompletionException ce) {
|
||
|
|
if (ce.getCause() instanceof SSLHandshakeException) {
|
||
|
|
out.printf("Client: caught expected exception: %s%n", ce.getCause());
|
||
|
|
} else {
|
||
|
|
out.printf("Client: caught UNEXPECTED exception: %s%n", ce.getCause());
|
||
|
|
throw ce;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Common supertype for PlainServer and SSLServer. */
|
||
|
|
static abstract class AbstractServer extends Thread implements AutoCloseable {
|
||
|
|
protected final ServerSocket ss;
|
||
|
|
protected volatile boolean closed;
|
||
|
|
|
||
|
|
AbstractServer(String name, ServerSocket ss) throws IOException {
|
||
|
|
super(name);
|
||
|
|
this.ss = ss;
|
||
|
|
this.start();
|
||
|
|
}
|
||
|
|
|
||
|
|
int getPort() { return ss.getLocalPort(); }
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void close() {
|
||
|
|
if (closed)
|
||
|
|
return;
|
||
|
|
closed = true;
|
||
|
|
try {
|
||
|
|
ss.close();
|
||
|
|
} catch (IOException e) {
|
||
|
|
throw new UncheckedIOException("Unexpected", e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Emulates a server-side, using plain cleartext Sockets, that just closes
|
||
|
|
* the connection, after a small variable delay. */
|
||
|
|
static class PlainServer extends AbstractServer {
|
||
|
|
private volatile int count;
|
||
|
|
|
||
|
|
PlainServer() throws IOException {
|
||
|
|
super("PlainServer", new ServerSocket(0));
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void run() {
|
||
|
|
while (!closed) {
|
||
|
|
try (Socket s = ss.accept()) {
|
||
|
|
count++;
|
||
|
|
|
||
|
|
/* SSL record layer - contains the client hello
|
||
|
|
struct {
|
||
|
|
uint8 major, minor;
|
||
|
|
} ProtocolVersion;
|
||
|
|
|
||
|
|
enum {
|
||
|
|
change_cipher_spec(20), alert(21), handshake(22),
|
||
|
|
application_data(23), (255)
|
||
|
|
} ContentType;
|
||
|
|
|
||
|
|
struct {
|
||
|
|
ContentType type;
|
||
|
|
ProtocolVersion version;
|
||
|
|
uint16 length;
|
||
|
|
opaque fragment[SSLPlaintext.length];
|
||
|
|
} SSLPlaintext; */
|
||
|
|
DataInputStream din = new DataInputStream(s.getInputStream());
|
||
|
|
int contentType = din.read();
|
||
|
|
out.println("ContentType:" + contentType);
|
||
|
|
int majorVersion = din.read();
|
||
|
|
out.println("Major:" + majorVersion);
|
||
|
|
int minorVersion = din.read();
|
||
|
|
out.println("Minor:" + minorVersion);
|
||
|
|
int length = din.readShort();
|
||
|
|
out.println("length:" + length);
|
||
|
|
byte[] ba = new byte[length];
|
||
|
|
din.readFully(ba);
|
||
|
|
|
||
|
|
// simulate various delays in response
|
||
|
|
Thread.sleep(10 * (count % 10));
|
||
|
|
s.close(); // close without giving any reply
|
||
|
|
} catch (IOException e) {
|
||
|
|
if (!closed)
|
||
|
|
out.println("Unexpected" + e);
|
||
|
|
} catch (InterruptedException e) {
|
||
|
|
throw new RuntimeException(e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Emulates a server-side, using SSL Sockets, that will fail during
|
||
|
|
* handshaking, as there are no cipher suites in common. */
|
||
|
|
static class SSLServer extends AbstractServer {
|
||
|
|
static final SSLContext sslContext = createUntrustingContext();
|
||
|
|
static final ServerSocketFactory factory = sslContext.getServerSocketFactory();
|
||
|
|
|
||
|
|
static SSLContext createUntrustingContext() {
|
||
|
|
try {
|
||
|
|
SSLContext sslContext = SSLContext.getInstance("TLSv1.2");
|
||
|
|
sslContext.init(null, null, null);
|
||
|
|
return sslContext;
|
||
|
|
} catch (Throwable t) {
|
||
|
|
throw new AssertionError(t);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SSLServer() throws IOException {
|
||
|
|
super("SSLServer", factory.createServerSocket(0));
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void run() {
|
||
|
|
while (!closed) {
|
||
|
|
try (SSLSocket s = (SSLSocket)ss.accept()) {
|
||
|
|
s.getInputStream().read(); // will throw SHE here
|
||
|
|
|
||
|
|
throw new AssertionError("Should not reach here");
|
||
|
|
} catch (SSLHandshakeException expected) {
|
||
|
|
// Expected: SSLHandshakeException: no cipher suites in common
|
||
|
|
out.printf("Server: caught expected exception: %s%n", expected);
|
||
|
|
} catch (IOException e) {
|
||
|
|
if (!closed)
|
||
|
|
out.printf("UNEXPECTED %s", e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|