stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge

Browse Source
This commit is contained in:
Daniel D. Daugherty 2020-08-13 15:42:21 -04:00
commit 0db838628c
1 changed files with 124 additions and 293 deletions

397
test/jdk/javax/net/ssl/templates/SSLEngineTemplate.java

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2003, 2018, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2003, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -26,10 +26,15 @@
/* /*
* @test * @test
* @bug 1234567 * @bug 8250839
* @summary SSLEngine has not yet caused Solaris kernel to panic * @summary Improve test template SSLEngineTemplate with SSLContextTemplate
* @build SSLContextTemplate
* @run main/othervm SSLEngineTemplate * @run main/othervm SSLEngineTemplate
*/ */
import javax.net.ssl.*;
import javax.net.ssl.SSLEngineResult.HandshakeStatus;
import java.nio.ByteBuffer;
/** /**
* A SSLEngine usage example which simplifies the presentation * A SSLEngine usage example which simplifies the presentation
* by removing the I/O and multi-threading concerns. * by removing the I/O and multi-threading concerns.
@ -44,231 +49,139 @@
* *
* When this application runs, notice that several messages * When this application runs, notice that several messages
* (wrap/unwrap) pass before any application data is consumed or * (wrap/unwrap) pass before any application data is consumed or
* produced. (For more information, please see the SSL/TLS * produced.
* specifications.) There may several steps for a successful handshake,
* so it's typical to see the following series of operations:
*
* client server message
* ====== ====== =======
* wrap() ... ClientHello
* ... unwrap() ClientHello
* ... wrap() ServerHello/Certificate
* unwrap() ... ServerHello/Certificate
* wrap() ... ClientKeyExchange
* wrap() ... ChangeCipherSpec
* wrap() ... Finished
* ... unwrap() ClientKeyExchange
* ... unwrap() ChangeCipherSpec
* ... unwrap() Finished
* ... wrap() ChangeCipherSpec
* ... wrap() Finished
* unwrap() ... ChangeCipherSpec
* unwrap() ... Finished
*/ */
import javax.net.ssl.*; public class SSLEngineTemplate implements SSLContextTemplate {
import javax.net.ssl.SSLEngineResult.*; private final SSLEngine clientEngine; // client Engine
import java.io.*; private final ByteBuffer clientOut; // write side of clientEngine
import java.security.*; private final ByteBuffer clientIn; // read side of clientEngine
import java.nio.*;
public class SSLEngineTemplate { private final SSLEngine serverEngine; // server Engine
private final ByteBuffer serverOut; // write side of serverEngine
private final ByteBuffer serverIn; // read side of serverEngine
/* // For data transport, this example uses local ByteBuffers. This
* Enables logging of the SSLEngine operations. // isn't really useful, but the purpose of this example is to show
*/ // SSLEngine concepts, not how to do network transport.
private static final boolean logging = true; private final ByteBuffer cTOs; // "reliable" transport client->server
private final ByteBuffer sTOc; // "reliable" transport server->client
/* private SSLEngineTemplate() throws Exception {
* Enables the JSSE system debugging system property: serverEngine = configureServerEngine(
* createServerSSLContext().createSSLEngine());
* -Djavax.net.debug=all
*
* This gives a lot of low-level information about operations underway,
* including specific handshake messages, and might be best examined
* after gaining some familiarity with this application.
*/
private static final boolean debug = false;
private final SSLContext sslc; clientEngine = configureClientEngine(
createClientSSLContext().createSSLEngine());
private SSLEngine clientEngine; // client Engine // We'll assume the buffer sizes are the same
private ByteBuffer clientOut; // write side of clientEngine // between client and server.
private ByteBuffer clientIn; // read side of clientEngine SSLSession session = clientEngine.getSession();
int appBufferMax = session.getApplicationBufferSize();
int netBufferMax = session.getPacketBufferSize();
private SSLEngine serverEngine; // server Engine // We'll make the input buffers a bit bigger than the max needed
private ByteBuffer serverOut; // write side of serverEngine // size, so that unwrap()s following a successful data transfer
private ByteBuffer serverIn; // read side of serverEngine // won't generate BUFFER_OVERFLOWS.
//
// We'll use a mix of direct and indirect ByteBuffers for
// tutorial purposes only. In reality, only use direct
// ByteBuffers when they give a clear performance enhancement.
clientIn = ByteBuffer.allocate(appBufferMax + 50);
serverIn = ByteBuffer.allocate(appBufferMax + 50);
/* cTOs = ByteBuffer.allocateDirect(netBufferMax);
* For data transport, this example uses local ByteBuffers. This sTOc = ByteBuffer.allocateDirect(netBufferMax);
* isn't really useful, but the purpose of this example is to show
* SSLEngine concepts, not how to do network transport.
*/
private ByteBuffer cTOs; // "reliable" transport client->server
private ByteBuffer sTOc; // "reliable" transport server->client
/* clientOut = ByteBuffer.wrap("Hi Server, I'm Client".getBytes());
* The following is to set up the keystores. serverOut = ByteBuffer.wrap("Hello Client, I'm Server".getBytes());
*/
private static final String pathToStores = "../etc";
private static final String keyStoreFile = "keystore";
private static final String trustStoreFile = "truststore";
private static final char[] passphrase = "passphrase".toCharArray();
private static final String keyFilename =
System.getProperty("test.src", ".") + "/" + pathToStores +
"/" + keyStoreFile;
private static final String trustFilename =
System.getProperty("test.src", ".") + "/" + pathToStores +
"/" + trustStoreFile;
/*
* Main entry point for this test.
*/
public static void main(String args[]) throws Exception {
if (debug) {
System.setProperty("javax.net.debug", "all");
} }
SSLEngineTemplate test = new SSLEngineTemplate(); //
test.runTest(); // Protected methods could be used to customize the test case.
//
System.out.println("Test Passed."); /*
* Configure the client side engine.
*/
protected SSLEngine configureClientEngine(SSLEngine clientEngine) {
clientEngine.setUseClientMode(true);
// Get/set parameters if needed
// SSLParameters paramsClient = clientEngine.getSSLParameters();
// clientEngine.setSSLParameters(paramsClient);
return clientEngine;
} }
/* /*
* Create an initialized SSLContext to use for these tests. * Configure the server side engine.
*/ */
public SSLEngineTemplate() throws Exception { protected SSLEngine configureServerEngine(SSLEngine serverEngine) {
serverEngine.setUseClientMode(false);
serverEngine.setNeedClientAuth(true);
KeyStore ks = KeyStore.getInstance("JKS"); // Get/set parameters if needed
KeyStore ts = KeyStore.getInstance("JKS"); //
// SSLParameters paramsServer = serverEngine.getSSLParameters();
// serverEngine.setSSLParameters(paramsServer);
ks.load(new FileInputStream(keyFilename), passphrase); return serverEngine;
ts.load(new FileInputStream(trustFilename), passphrase);
KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
kmf.init(ks, passphrase);
TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
tmf.init(ts);
SSLContext sslCtx = SSLContext.getInstance("TLS");
sslCtx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
sslc = sslCtx;
} }
/* public static void main(String[] args) throws Exception {
* Run the test. new SSLEngineTemplate().runTest();
* }
* Sit in a tight loop, both engines calling wrap/unwrap regardless
* of whether data is available or not. We do this until both engines //
* report back they are closed. // Private methods that used to build the common part of the test.
* //
* The main loop handles all of the I/O phases of the SSLEngine's
* lifetime:
*
* initial handshaking
* application data transfer
* engine closing
*
* One could easily separate these phases into separate
* sections of code.
*/
private void runTest() throws Exception { private void runTest() throws Exception {
boolean dataDone = false;
createSSLEngines();
createBuffers();
// results from client's last operation
SSLEngineResult clientResult; SSLEngineResult clientResult;
// results from server's last operation
SSLEngineResult serverResult; SSLEngineResult serverResult;
/* boolean dataDone = false;
* Examining the SSLEngineResults could be much more involved, while (isOpen(clientEngine) || isOpen(serverEngine)) {
* and may alter the overall flow of the application. log("=================");
*
* For example, if we received a BUFFER_OVERFLOW when trying
* to write to the output pipe, we could reallocate a larger
* pipe, but instead we wait for the peer to drain it.
*/
Exception clientException = null;
Exception serverException = null;
while (!isEngineClosed(clientEngine) // client wrap
|| !isEngineClosed(serverEngine)) { log("---Client Wrap---");
log("================");
try {
clientResult = clientEngine.wrap(clientOut, cTOs); clientResult = clientEngine.wrap(clientOut, cTOs);
log("client wrap: ", clientResult); logEngineStatus(clientEngine, clientResult);
} catch (Exception e) {
clientException = e;
System.out.println("Client wrap() threw: " + e.getMessage());
}
logEngineStatus(clientEngine);
runDelegatedTasks(clientEngine); runDelegatedTasks(clientEngine);
log("----"); // server wrap
log("---Server Wrap---");
try {
serverResult = serverEngine.wrap(serverOut, sTOc); serverResult = serverEngine.wrap(serverOut, sTOc);
log("server wrap: ", serverResult); logEngineStatus(serverEngine, serverResult);
} catch (Exception e) {
serverException = e;
System.out.println("Server wrap() threw: " + e.getMessage());
}
logEngineStatus(serverEngine);
runDelegatedTasks(serverEngine); runDelegatedTasks(serverEngine);
cTOs.flip(); cTOs.flip();
sTOc.flip(); sTOc.flip();
log("--------"); // client unwrap
log("---Client Unwrap---");
try {
clientResult = clientEngine.unwrap(sTOc, clientIn); clientResult = clientEngine.unwrap(sTOc, clientIn);
log("client unwrap: ", clientResult); logEngineStatus(clientEngine, clientResult);
} catch (Exception e) {
clientException = e;
System.out.println("Client unwrap() threw: " + e.getMessage());
}
logEngineStatus(clientEngine);
runDelegatedTasks(clientEngine); runDelegatedTasks(clientEngine);
log("----"); // server unwrap
log("---Server Unwrap---");
try {
serverResult = serverEngine.unwrap(cTOs, serverIn); serverResult = serverEngine.unwrap(cTOs, serverIn);
log("server unwrap: ", serverResult); logEngineStatus(serverEngine, serverResult);
} catch (Exception e) {
serverException = e;
System.out.println("Server unwrap() threw: " + e.getMessage());
}
logEngineStatus(serverEngine);
runDelegatedTasks(serverEngine); runDelegatedTasks(serverEngine);
cTOs.compact(); cTOs.compact();
sTOc.compact(); sTOc.compact();
/* // After we've transferred all application data between the client
* After we've transfered all application data between the client // and server, we close the clientEngine's outbound stream.
* and server, we close the clientEngine's outbound stream. // This generates a close_notify handshake message, which the
* This generates a close_notify handshake message, which the // server engine receives and responds by closing itself.
* server engine receives and responds by closing itself.
*/
if (!dataDone && (clientOut.limit() == serverIn.position()) && if (!dataDone && (clientOut.limit() == serverIn.position()) &&
(serverOut.limit() == clientIn.position())) { (serverOut.limit() == clientIn.position())) {
/* // A sanity check to ensure we got what was sent.
* A sanity check to ensure we got what was sent.
*/
checkTransfer(serverOut, clientIn); checkTransfer(serverOut, clientIn);
checkTransfer(clientOut, serverIn); checkTransfer(clientOut, serverIn);
@ -284,78 +197,33 @@ public class SSLEngineTemplate {
} }
} }
private static boolean isOpen(SSLEngine engine) {
return (!engine.isOutboundDone() || !engine.isInboundDone());
}
private static void logEngineStatus(SSLEngine engine) { private static void logEngineStatus(SSLEngine engine) {
log("\tCurrent HS State " + engine.getHandshakeStatus().toString()); log("\tCurrent HS State: " + engine.getHandshakeStatus());
log("\tisInboundDone(): " + engine.isInboundDone()); log("\tisInboundDone() : " + engine.isInboundDone());
log("\tisOutboundDone(): " + engine.isOutboundDone()); log("\tisOutboundDone(): " + engine.isOutboundDone());
} }
/* private static void logEngineStatus(
* Using the SSLContext created during object creation, SSLEngine engine, SSLEngineResult result) {
* create/configure the SSLEngines we'll use for this test. log("\tResult Status : " + result.getStatus());
*/ log("\tResult HS Status : " + result.getHandshakeStatus());
private void createSSLEngines() throws Exception { log("\tEngine HS Status : " + engine.getHandshakeStatus());
/* log("\tisInboundDone() : " + engine.isInboundDone());
* Configure the serverEngine to act as a server in the SSL/TLS log("\tisOutboundDone() : " + engine.isOutboundDone());
* handshake. Also, require SSL client authentication. log("\tMore Result : " + result);
*/
serverEngine = sslc.createSSLEngine();
serverEngine.setUseClientMode(false);
serverEngine.setNeedClientAuth(true);
// Get/set parameters if needed
SSLParameters paramsServer = serverEngine.getSSLParameters();
serverEngine.setSSLParameters(paramsServer);
/*
* Similar to above, but using client mode instead.
*/
clientEngine = sslc.createSSLEngine("client", 80);
clientEngine.setUseClientMode(true);
// Get/set parameters if needed
SSLParameters paramsClient = clientEngine.getSSLParameters();
clientEngine.setSSLParameters(paramsClient);
} }
/* private static void log(String message) {
* Create and size the buffers appropriately. System.err.println(message);
*/
private void createBuffers() {
/*
* We'll assume the buffer sizes are the same
* between client and server.
*/
SSLSession session = clientEngine.getSession();
int appBufferMax = session.getApplicationBufferSize();
int netBufferMax = session.getPacketBufferSize();
/*
* We'll make the input buffers a bit bigger than the max needed
* size, so that unwrap()s following a successful data transfer
* won't generate BUFFER_OVERFLOWS.
*
* We'll use a mix of direct and indirect ByteBuffers for
* tutorial purposes only. In reality, only use direct
* ByteBuffers when they give a clear performance enhancement.
*/
clientIn = ByteBuffer.allocate(appBufferMax + 50);
serverIn = ByteBuffer.allocate(appBufferMax + 50);
cTOs = ByteBuffer.allocateDirect(netBufferMax);
sTOc = ByteBuffer.allocateDirect(netBufferMax);
clientOut = ByteBuffer.wrap("Hi Server, I'm Client".getBytes());
serverOut = ByteBuffer.wrap("Hello Client, I'm Server".getBytes());
} }
/* // If the result indicates that we have outstanding tasks to do,
* If the result indicates that we have outstanding tasks to do, // go ahead and run them in this thread.
* go ahead and run them in this thread.
*/
private static void runDelegatedTasks(SSLEngine engine) throws Exception { private static void runDelegatedTasks(SSLEngine engine) throws Exception {
if (engine.getHandshakeStatus() == HandshakeStatus.NEED_TASK) { if (engine.getHandshakeStatus() == HandshakeStatus.NEED_TASK) {
Runnable runnable; Runnable runnable;
while ((runnable = engine.getDelegatedTask()) != null) { while ((runnable = engine.getDelegatedTask()) != null) {
@ -371,13 +239,7 @@ public class SSLEngineTemplate {
} }
} }
private static boolean isEngineClosed(SSLEngine engine) { // Simple check to make sure everything came across as expected.
return (engine.isOutboundDone() && engine.isInboundDone());
}
/*
* Simple check to make sure everything came across as expected.
*/
private static void checkTransfer(ByteBuffer a, ByteBuffer b) private static void checkTransfer(ByteBuffer a, ByteBuffer b)
throws Exception { throws Exception {
a.flip(); a.flip();
@ -394,35 +256,4 @@ public class SSLEngineTemplate {
a.limit(a.capacity()); a.limit(a.capacity());
b.limit(b.capacity()); b.limit(b.capacity());
} }
/*
* Logging code
*/
private static boolean resultOnce = true;
private static void log(String str, SSLEngineResult result) {
if (!logging) {
return;
}
if (resultOnce) {
resultOnce = false;
System.out.println("The format of the SSLEngineResult is: \n" +
"\t\"getStatus() / getHandshakeStatus()\" +\n" +
"\t\"bytesConsumed() / bytesProduced()\"\n");
}
HandshakeStatus hsStatus = result.getHandshakeStatus();
log(str +
result.getStatus() + "/" + hsStatus + ", " +
result.bytesConsumed() + "/" + result.bytesProduced() +
" bytes");
if (hsStatus == HandshakeStatus.FINISHED) {
log("\t...ready for application data");
}
}
private static void log(String str) {
if (logging) {
System.out.println(str);
}
}
} }