# HG changeset patch
# User xuelei
# Date 1453868482 0
# Wed Jan 27 04:21:22 2016 +0000
# Node ID 8d589911411743fa38badf69c10aa067eaa996b7
# Parent ceb95f0d38d7ab09762dd7ff33bb855f3088a6b5
8076221, PR2809: Disable RC4 cipher suites
Reviewed-by: wetmore
diff -r 88b089373a3c src/share/lib/security/java.security-linux
--- openjdk/jdk/src/share/lib/security/java.security-linux Mon Apr 18 06:49:52 2016 +0100
+++ openjdk/jdk/src/share/lib/security/java.security-linux Mon Apr 18 07:48:12 2016 +0100
@@ -437,7 +437,7 @@
#
# Example:
# jdk.tls.disabledAlgorithms=MD5, SSLv3, DSA, RSA keySize < 2048
-jdk.tls.disabledAlgorithms=SSLv3, MD5withRSA, DH keySize < 768
+jdk.tls.disabledAlgorithms=SSLv3, RC4, MD5withRSA, DH keySize < 768
# Legacy algorithms for Secure Socket Layer/Transport Layer Security (SSL/TLS)
# processing in JSSE implementation.
diff -r 88b089373a3c src/share/lib/security/java.security-macosx
--- openjdk/jdk/src/share/lib/security/java.security-macosx Mon Apr 18 06:49:52 2016 +0100
+++ openjdk/jdk/src/share/lib/security/java.security-macosx Mon Apr 18 07:48:12 2016 +0100
@@ -442,7 +442,7 @@
#
# Example:
# jdk.tls.disabledAlgorithms=MD5, SSLv3, DSA, RSA keySize < 2048
-jdk.tls.disabledAlgorithms=SSLv3, MD5withRSA, DH keySize < 768
+jdk.tls.disabledAlgorithms=SSLv3, RC4, MD5withRSA, DH keySize < 768
# Legacy algorithms for Secure Socket Layer/Transport Layer Security (SSL/TLS)
# processing in JSSE implementation.
diff -r 88b089373a3c src/share/lib/security/java.security-solaris
--- openjdk/jdk/src/share/lib/security/java.security-solaris Mon Apr 18 06:49:52 2016 +0100
+++ openjdk/jdk/src/share/lib/security/java.security-solaris Mon Apr 18 07:48:12 2016 +0100
@@ -441,7 +441,7 @@
#
# Example:
# jdk.tls.disabledAlgorithms=MD5, SSLv3, DSA, RSA keySize < 2048
-jdk.tls.disabledAlgorithms=SSLv3, MD5withRSA, DH keySize < 768
+jdk.tls.disabledAlgorithms=SSLv3, RC4, MD5withRSA, DH keySize < 768
# Legacy algorithms for Secure Socket Layer/Transport Layer Security (SSL/TLS)
# processing in JSSE implementation.
diff -r 88b089373a3c src/share/lib/security/java.security-windows
--- openjdk/jdk/src/share/lib/security/java.security-windows Mon Apr 18 06:49:52 2016 +0100
+++ openjdk/jdk/src/share/lib/security/java.security-windows Mon Apr 18 07:48:12 2016 +0100
@@ -442,7 +442,7 @@
#
# Example:
# jdk.tls.disabledAlgorithms=MD5, SSLv3, DSA, RSA keySize < 2048
-jdk.tls.disabledAlgorithms=SSLv3, MD5withRSA, DH keySize < 768
+jdk.tls.disabledAlgorithms=SSLv3, RC4, MD5withRSA, DH keySize < 768
# Legacy algorithms for Secure Socket Layer/Transport Layer Security (SSL/TLS)
# processing in JSSE implementation.
diff -r 88b089373a3c test/javax/net/ssl/ciphersuites/DisabledAlgorithms.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ openjdk/jdk/test/javax/net/ssl/ciphersuites/DisabledAlgorithms.java Mon Apr 18 07:48:12 2016 +0100
@@ -0,0 +1,362 @@
+/*
+ * Copyright (c) 2015, 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 java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.security.NoSuchAlgorithmException;
+import java.security.Security;
+import java.util.concurrent.TimeUnit;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLHandshakeException;
+import javax.net.ssl.SSLServerSocket;
+import javax.net.ssl.SSLServerSocketFactory;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+
+/**
+ * @test
+ * @bug 8076221
+ * @summary Check if weak cipher suites are disabled
+ * @run main/othervm DisabledAlgorithms default
+ * @run main/othervm DisabledAlgorithms empty
+ */
+public class DisabledAlgorithms {
+
+ private static final String pathToStores =
+ "../../../../sun/security/ssl/etc";
+ private static final String keyStoreFile = "keystore";
+ private static final String trustStoreFile = "truststore";
+ private static final String passwd = "passphrase";
+
+ private static final String keyFilename =
+ System.getProperty("test.src", "./") + "/" + pathToStores +
+ "/" + keyStoreFile;
+
+ private static final String trustFilename =
+ System.getProperty("test.src", "./") + "/" + pathToStores +
+ "/" + trustStoreFile;
+
+ // supported RC4 cipher suites
+ // it does not contain KRB5 cipher suites because they need a KDC
+ private static final String[] rc4_ciphersuites = new String[] {
+ "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA",
+ "TLS_ECDHE_RSA_WITH_RC4_128_SHA",
+ "SSL_RSA_WITH_RC4_128_SHA",
+ "TLS_ECDH_ECDSA_WITH_RC4_128_SHA",
+ "TLS_ECDH_RSA_WITH_RC4_128_SHA",
+ "SSL_RSA_WITH_RC4_128_MD5",
+ "TLS_ECDH_anon_WITH_RC4_128_SHA",
+ "SSL_DH_anon_WITH_RC4_128_MD5"
+ };
+
+ public static void main(String[] args) throws Exception {
+ if (args.length < 1) {
+ throw new RuntimeException("No parameters specified");
+ }
+
+ System.setProperty("javax.net.ssl.keyStore", keyFilename);
+ System.setProperty("javax.net.ssl.keyStorePassword", passwd);
+ System.setProperty("javax.net.ssl.trustStore", trustFilename);
+ System.setProperty("javax.net.ssl.trustStorePassword", passwd);
+
+ switch (args[0]) {
+ case "default":
+ // use default jdk.tls.disabledAlgorithms
+ System.out.println("jdk.tls.disabledAlgorithms = "
+ + Security.getProperty("jdk.tls.disabledAlgorithms"));
+
+ // check if RC4 cipher suites can't be used by default
+ checkFailure(rc4_ciphersuites);
+ break;
+ case "empty":
+ // reset jdk.tls.disabledAlgorithms
+ Security.setProperty("jdk.tls.disabledAlgorithms", "");
+ System.out.println("jdk.tls.disabledAlgorithms = "
+ + Security.getProperty("jdk.tls.disabledAlgorithms"));
+
+ // check if RC4 cipher suites can be used
+ // if jdk.tls.disabledAlgorithms is empty
+ checkSuccess(rc4_ciphersuites);
+ break;
+ default:
+ throw new RuntimeException("Wrong parameter: " + args[0]);
+ }
+ }
+
+ /*
+ * Checks if that specified cipher suites cannot be used.
+ */
+ private static void checkFailure(String[] ciphersuites) throws Exception {
+ try (SSLServer server = SSLServer.init(ciphersuites)) {
+ startNewThread(server);
+ while (!server.isRunning()) {
+ sleep();
+ }
+
+ int port = server.getPort();
+ for (String ciphersuite : ciphersuites) {
+ try (SSLClient client = SSLClient.init(port, ciphersuite)) {
+ client.connect();
+ throw new RuntimeException("Expected SSLHandshakeException "
+ + "not thrown");
+ } catch (SSLHandshakeException e) {
+ System.out.println("Expected exception on client side: "
+ + e);
+ }
+ }
+
+ server.stop();
+ while (server.isRunning()) {
+ sleep();
+ }
+
+ if (!server.sslError()) {
+ throw new RuntimeException("Expected SSL exception "
+ + "not thrown on server side");
+ }
+ }
+
+ }
+
+ /*
+ * Checks if specified cipher suites can be used.
+ */
+ private static void checkSuccess(String[] ciphersuites) throws Exception {
+ try (SSLServer server = SSLServer.init(ciphersuites)) {
+ startNewThread(server);
+ while (!server.isRunning()) {
+ sleep();
+ }
+
+ int port = server.getPort();
+ for (String ciphersuite : ciphersuites) {
+ try (SSLClient client = SSLClient.init(port, ciphersuite)) {
+ client.connect();
+ String negotiated = client.getNegotiatedCipherSuite();
+ System.out.println("Negotiated cipher suite: "
+ + negotiated);
+ if (!negotiated.equals(ciphersuite)) {
+ throw new RuntimeException("Unexpected cipher suite: "
+ + negotiated);
+ }
+ }
+ }
+
+ server.stop();
+ while (server.isRunning()) {
+ sleep();
+ }
+
+ if (server.error()) {
+ throw new RuntimeException("Unexpected error on server side");
+ }
+ }
+
+ }
+
+ private static Thread startNewThread(SSLServer server) {
+ Thread serverThread = new Thread(server, "SSL server thread");
+ serverThread.setDaemon(true);
+ serverThread.start();
+ return serverThread;
+ }
+
+ private static void sleep() {
+ try {
+ TimeUnit.MILLISECONDS.sleep(50);
+ } catch (InterruptedException e) {
+ // do nothing
+ }
+ }
+
+ static class SSLServer implements Runnable, AutoCloseable {
+
+ private final SSLServerSocket ssocket;
+ private volatile boolean stopped = false;
+ private volatile boolean running = false;
+ private volatile boolean sslError = false;
+ private volatile boolean otherError = false;
+
+ private SSLServer(SSLServerSocket ssocket) {
+ this.ssocket = ssocket;
+ }
+
+ @Override
+ public void run() {
+ System.out.println("Server: started");
+ running = true;
+ while (!stopped) {
+ try (SSLSocket socket = (SSLSocket) ssocket.accept()) {
+ System.out.println("Server: accepted client connection");
+ InputStream in = socket.getInputStream();
+ OutputStream out = socket.getOutputStream();
+ int b = in.read();
+ if (b < 0) {
+ throw new IOException("Unexpected EOF");
+ }
+ System.out.println("Server: send data: " + b);
+ out.write(b);
+ out.flush();
+ socket.getSession().invalidate();
+ } catch (SSLHandshakeException e) {
+ System.out.println("Server: run: " + e);
+ sslError = true;
+ } catch (IOException e) {
+ if (!stopped) {
+ System.out.println("Server: run: " + e);
+ e.printStackTrace();
+ otherError = true;
+ }
+ }
+ }
+
+ System.out.println("Server: finished");
+ running = false;
+ }
+
+ int getPort() {
+ return ssocket.getLocalPort();
+ }
+
+ String[] getEnabledCiperSuites() {
+ return ssocket.getEnabledCipherSuites();
+ }
+
+ boolean isRunning() {
+ return running;
+ }
+
+ boolean sslError() {
+ return sslError;
+ }
+
+ boolean error() {
+ return sslError || otherError;
+ }
+
+ void stop() {
+ stopped = true;
+ if (!ssocket.isClosed()) {
+ try {
+ ssocket.close();
+ } catch (IOException e) {
+ System.out.println("Server: close: " + e);
+ }
+ }
+ }
+
+ @Override
+ public void close() {
+ stop();
+ }
+
+ static SSLServer init(String[] ciphersuites)
+ throws IOException {
+ SSLServerSocketFactory ssf = (SSLServerSocketFactory)
+ SSLServerSocketFactory.getDefault();
+ SSLServerSocket ssocket = (SSLServerSocket)
+ ssf.createServerSocket(0);
+
+ if (ciphersuites != null) {
+ System.out.println("Server: enable cipher suites: "
+ + java.util.Arrays.toString(ciphersuites));
+ ssocket.setEnabledCipherSuites(ciphersuites);
+ }
+
+ return new SSLServer(ssocket);
+ }
+ }
+
+ static class SSLClient implements AutoCloseable {
+
+ private final SSLSocket socket;
+
+ private SSLClient(SSLSocket socket) {
+ this.socket = socket;
+ }
+
+ void connect() throws IOException {
+ System.out.println("Client: connect to server");
+ try (
+ BufferedInputStream bis = new BufferedInputStream(
+ socket.getInputStream());
+ BufferedOutputStream bos = new BufferedOutputStream(
+ socket.getOutputStream())) {
+ bos.write('x');
+ bos.flush();
+
+ int read = bis.read();
+ if (read < 0) {
+ throw new IOException("Client: couldn't read a response");
+ }
+ socket.getSession().invalidate();
+ }
+ }
+
+ String[] getEnabledCiperSuites() {
+ return socket.getEnabledCipherSuites();
+ }
+
+ String getNegotiatedCipherSuite() {
+ return socket.getSession().getCipherSuite();
+ }
+
+ @Override
+ public void close() throws Exception {
+ if (!socket.isClosed()) {
+ try {
+ socket.close();
+ } catch (IOException e) {
+ System.out.println("Client: close: " + e);
+ }
+ }
+ }
+
+ static SSLClient init(int port)
+ throws NoSuchAlgorithmException, IOException {
+ return init(port, null);
+ }
+
+ static SSLClient init(int port, String ciphersuite)
+ throws NoSuchAlgorithmException, IOException {
+ SSLContext context = SSLContext.getDefault();
+ SSLSocketFactory ssf = (SSLSocketFactory)
+ context.getSocketFactory();
+ SSLSocket socket = (SSLSocket) ssf.createSocket("localhost", port);
+
+ if (ciphersuite != null) {
+ System.out.println("Client: enable cipher suite: "
+ + ciphersuite);
+ socket.setEnabledCipherSuites(new String[] { ciphersuite });
+ }
+
+ return new SSLClient(socket);
+ }
+
+ }
+
+
+}
diff -r 88b089373a3c test/sun/security/krb5/auto/SSL.java
--- openjdk/jdk/test/sun/security/krb5/auto/SSL.java Mon Apr 18 06:49:52 2016 +0100
+++ openjdk/jdk/test/sun/security/krb5/auto/SSL.java Mon Apr 18 07:48:12 2016 +0100
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2009, 2015, 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
@@ -40,6 +40,7 @@
import java.net.InetAddress;
import javax.net.ssl.*;
import java.security.Principal;
+import java.security.Security;
import java.util.Date;
import sun.security.jgss.GSSUtil;
import sun.security.krb5.PrincipalName;
@@ -54,6 +55,9 @@
private static volatile int port;
public static void main(String[] args) throws Exception {
+ // reset the security property to make sure that the algorithms
+ // and keys used in this test are not disabled.
+ Security.setProperty("jdk.tls.disabledAlgorithms", "");
krb5Cipher = args[0];
diff -r 88b089373a3c test/sun/security/ssl/com/sun/net/ssl/internal/ssl/ClientHandshaker/CipherSuiteOrder.java
--- openjdk/jdk/test/sun/security/ssl/com/sun/net/ssl/internal/ssl/ClientHandshaker/CipherSuiteOrder.java Mon Apr 18 06:49:52 2016 +0100
+++ openjdk/jdk/test/sun/security/ssl/com/sun/net/ssl/internal/ssl/ClientHandshaker/CipherSuiteOrder.java Mon Apr 18 07:48:12 2016 +0100
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2002, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2015, 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
@@ -36,7 +36,7 @@
*/
import java.io.*;
-import java.net.*;
+import java.security.Security;
import javax.net.ssl.*;
public class CipherSuiteOrder {
@@ -198,6 +198,10 @@
volatile Exception clientException = null;
public static void main(String[] args) throws Exception {
+ // reset the security property to make sure that the algorithms
+ // and keys used in this test are not disabled.
+ Security.setProperty("jdk.tls.disabledAlgorithms", "");
+
String keyFilename =
System.getProperty("test.src", "./") + "/" + pathToStores +
"/" + keyStoreFile;
diff -r 88b089373a3c test/sun/security/ssl/com/sun/net/ssl/internal/ssl/DHKeyExchange/DHEKeySizing.java
--- openjdk/jdk/test/sun/security/ssl/com/sun/net/ssl/internal/ssl/DHKeyExchange/DHEKeySizing.java Mon Apr 18 06:49:52 2016 +0100
+++ openjdk/jdk/test/sun/security/ssl/com/sun/net/ssl/internal/ssl/DHKeyExchange/DHEKeySizing.java Mon Apr 18 07:48:12 2016 +0100
@@ -102,10 +102,10 @@
import java.nio.*;
import java.security.KeyStore;
import java.security.KeyFactory;
+import java.security.Security;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
import java.security.spec.PKCS8EncodedKeySpec;
-import java.security.spec.*;
import java.security.interfaces.*;
import java.util.Base64;
diff -r 88b089373a3c test/sun/security/ssl/javax/net/ssl/NewAPIs/SSLEngine/CheckStatus.java
--- openjdk/jdk/test/sun/security/ssl/javax/net/ssl/NewAPIs/SSLEngine/CheckStatus.java Mon Apr 18 06:49:52 2016 +0100
+++ openjdk/jdk/test/sun/security/ssl/javax/net/ssl/NewAPIs/SSLEngine/CheckStatus.java Mon Apr 18 07:48:12 2016 +0100
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2015, 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
@@ -622,6 +622,9 @@
}
public static void main(String args[]) throws Exception {
+ // reset the security property to make sure that the algorithms
+ // and keys used in this test are not disabled.
+ Security.setProperty("jdk.tls.disabledAlgorithms", "");
CheckStatus cs;
diff -r 88b089373a3c test/sun/security/ssl/javax/net/ssl/NewAPIs/SSLEngine/ConnectionTest.java
--- openjdk/jdk/test/sun/security/ssl/javax/net/ssl/NewAPIs/SSLEngine/ConnectionTest.java Mon Apr 18 06:49:52 2016 +0100
+++ openjdk/jdk/test/sun/security/ssl/javax/net/ssl/NewAPIs/SSLEngine/ConnectionTest.java Mon Apr 18 07:48:12 2016 +0100
@@ -33,6 +33,8 @@
* The code could certainly be tightened up a lot.
*
* @author Brad Wetmore
+ *
+ * @run main/othervm ConnectionTest
*/
import javax.net.ssl.*;
@@ -672,6 +674,10 @@
}
public static void main(String args[]) throws Exception {
+ // reset the security property to make sure that the algorithms
+ // and keys used in this test are not disabled.
+ Security.setProperty("jdk.tls.disabledAlgorithms", "");
+
ConnectionTest ct = new ConnectionTest();
ct.test();
}
diff -r 88b089373a3c test/sun/security/ssl/javax/net/ssl/NewAPIs/SSLEngine/LargeBufs.java
--- openjdk/jdk/test/sun/security/ssl/javax/net/ssl/NewAPIs/SSLEngine/LargeBufs.java Mon Apr 18 06:49:52 2016 +0100
+++ openjdk/jdk/test/sun/security/ssl/javax/net/ssl/NewAPIs/SSLEngine/LargeBufs.java Mon Apr 18 07:48:12 2016 +0100
@@ -180,6 +180,9 @@
}
public static void main(String args[]) throws Exception {
+ // reset the security property to make sure that the algorithms
+ // and keys used in this test are not disabled.
+ Security.setProperty("jdk.tls.disabledAlgorithms", "");
LargeBufs test;
diff -r 88b089373a3c test/sun/security/ssl/javax/net/ssl/TLSv11/GenericStreamCipher.java
--- openjdk/jdk/test/sun/security/ssl/javax/net/ssl/TLSv11/GenericStreamCipher.java Mon Apr 18 06:49:52 2016 +0100
+++ openjdk/jdk/test/sun/security/ssl/javax/net/ssl/TLSv11/GenericStreamCipher.java Mon Apr 18 07:48:12 2016 +0100
@@ -37,7 +37,7 @@
*/
import java.io.*;
-import java.net.*;
+import java.security.Security;
import javax.net.ssl.*;
public class GenericStreamCipher {
@@ -165,6 +165,10 @@
volatile Exception clientException = null;
public static void main(String[] args) throws Exception {
+ // reset the security property to make sure that the algorithms
+ // and keys used in this test are not disabled.
+ Security.setProperty("jdk.tls.disabledAlgorithms", "");
+
String keyFilename =
System.getProperty("test.src", ".") + "/" + pathToStores +
"/" + keyStoreFile;