You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@zookeeper.apache.org by an...@apache.org on 2018/10/05 10:44:10 UTC
[2/3] zookeeper git commit: ZOOKEEPER-236: SSL Support for Atomic
Broadcast protocol
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/0e3b82bd/src/java/main/org/apache/zookeeper/server/quorum/QuorumPeerConfig.java
----------------------------------------------------------------------
diff --git a/src/java/main/org/apache/zookeeper/server/quorum/QuorumPeerConfig.java b/src/java/main/org/apache/zookeeper/server/quorum/QuorumPeerConfig.java
index 0f868c3..4719244 100644
--- a/src/java/main/org/apache/zookeeper/server/quorum/QuorumPeerConfig.java
+++ b/src/java/main/org/apache/zookeeper/server/quorum/QuorumPeerConfig.java
@@ -37,8 +37,8 @@ import java.util.Properties;
import java.util.Map.Entry;
import org.apache.yetus.audience.InterfaceAudience;
+import org.apache.zookeeper.common.ClientX509Util;
import org.apache.zookeeper.common.StringUtils;
-import org.apache.zookeeper.common.ZKConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
@@ -66,6 +66,8 @@ public class QuorumPeerConfig {
protected InetSocketAddress clientPortAddress;
protected InetSocketAddress secureClientPortAddress;
+ protected boolean sslQuorum = false;
+ protected boolean shouldUsePortUnification = false;
protected File dataDir;
protected File dataLogDir;
protected String dynamicConfigFileStr = null;
@@ -303,6 +305,11 @@ public class QuorumPeerConfig {
} else {
throw new ConfigException("Invalid option " + value + " for reconfigEnabled flag. Choose 'true' or 'false.'");
}
+ } else if (key.equals("sslQuorum")){
+ sslQuorum = Boolean.parseBoolean(value);
+// TODO: UnifiedServerSocket is currently buggy, will be fixed when @ivmaykov's PRs are merged. Disable port unification until then.
+// } else if (key.equals("portUnification")){
+// shouldUsePortUnification = Boolean.parseBoolean(value);
} else if ((key.startsWith("server.") || key.startsWith("group") || key.startsWith("weight")) && zkProp.containsKey("dynamicConfigFile")) {
throw new ConfigException("parameter: " + key + " must be in a separate dynamic config file");
} else if (key.equals(QuorumAuth.QUORUM_SASL_AUTH_ENABLED)) {
@@ -425,14 +432,15 @@ public class QuorumPeerConfig {
* provider is not configured.
*/
private void configureSSLAuth() throws ConfigException {
- String sslAuthProp = "zookeeper.authProvider." + System.getProperty(ZKConfig.SSL_AUTHPROVIDER, "x509");
+ ClientX509Util clientX509Util = new ClientX509Util();
+ String sslAuthProp = "zookeeper.authProvider." + System.getProperty(clientX509Util.getSslAuthProviderProperty(), "x509");
if (System.getProperty(sslAuthProp) == null) {
if ("zookeeper.authProvider.x509".equals(sslAuthProp)) {
System.setProperty("zookeeper.authProvider.x509",
"org.apache.zookeeper.server.auth.X509AuthenticationProvider");
} else {
throw new ConfigException("No auth provider configured for the SSL authentication scheme '"
- + System.getProperty(ZKConfig.SSL_AUTHPROVIDER) + "'.");
+ + System.getProperty(clientX509Util.getSslAuthProviderProperty()) + "'.");
}
}
}
@@ -737,6 +745,13 @@ public class QuorumPeerConfig {
public boolean isLocalSessionsUpgradingEnabled() {
return localSessionsUpgradingEnabled;
}
+ public boolean isSslQuorum() {
+ return sslQuorum;
+ }
+
+ public boolean shouldUsePortUnification() {
+ return shouldUsePortUnification;
+ }
public int getInitLimit() { return initLimit; }
public int getSyncLimit() { return syncLimit; }
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/0e3b82bd/src/java/main/org/apache/zookeeper/server/quorum/QuorumPeerMain.java
----------------------------------------------------------------------
diff --git a/src/java/main/org/apache/zookeeper/server/quorum/QuorumPeerMain.java b/src/java/main/org/apache/zookeeper/server/quorum/QuorumPeerMain.java
index 3da6e20..7c22d81 100644
--- a/src/java/main/org/apache/zookeeper/server/quorum/QuorumPeerMain.java
+++ b/src/java/main/org/apache/zookeeper/server/quorum/QuorumPeerMain.java
@@ -181,6 +181,8 @@ public class QuorumPeerMain {
quorumPeer.initConfigInZKDatabase();
quorumPeer.setCnxnFactory(cnxnFactory);
quorumPeer.setSecureCnxnFactory(secureCnxnFactory);
+ quorumPeer.setSslQuorum(config.isSslQuorum());
+ quorumPeer.setUsePortUnification(config.shouldUsePortUnification());
quorumPeer.setLearnerType(config.getPeerType());
quorumPeer.setSyncEnabled(config.getSyncEnabled());
quorumPeer.setQuorumListenOnAllIPs(config.getQuorumListenOnAllIPs());
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/0e3b82bd/src/java/main/org/apache/zookeeper/server/quorum/UnifiedServerSocket.java
----------------------------------------------------------------------
diff --git a/src/java/main/org/apache/zookeeper/server/quorum/UnifiedServerSocket.java b/src/java/main/org/apache/zookeeper/server/quorum/UnifiedServerSocket.java
new file mode 100644
index 0000000..4802ecf
--- /dev/null
+++ b/src/java/main/org/apache/zookeeper/server/quorum/UnifiedServerSocket.java
@@ -0,0 +1,79 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.zookeeper.server.quorum;
+
+import org.apache.zookeeper.common.X509Exception;
+import org.apache.zookeeper.common.X509Util;
+import org.jboss.netty.buffer.ChannelBuffers;
+import org.jboss.netty.handler.ssl.SslHandler;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.net.ssl.SSLSocket;
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketException;
+
+public class UnifiedServerSocket extends ServerSocket {
+ private static final Logger LOG = LoggerFactory.getLogger(UnifiedServerSocket.class);
+
+ private X509Util x509Util;
+
+ public UnifiedServerSocket(X509Util x509Util) throws IOException {
+ super();
+ this.x509Util = x509Util;
+ }
+
+ public UnifiedServerSocket(X509Util x509Util, int port) throws IOException {
+ super(port);
+ this.x509Util = x509Util;
+ }
+
+ @Override
+ public Socket accept() throws IOException {
+ if (isClosed()) {
+ throw new SocketException("Socket is closed");
+ }
+ if (!isBound()) {
+ throw new SocketException("Socket is not bound yet");
+ }
+ final PrependableSocket prependableSocket = new PrependableSocket(null);
+ implAccept(prependableSocket);
+
+ byte[] litmus = new byte[5];
+ int bytesRead = prependableSocket.getInputStream().read(litmus, 0, 5);
+ prependableSocket.prependToInputStream(litmus);
+
+ if (bytesRead == 5 && SslHandler.isEncrypted(ChannelBuffers.wrappedBuffer(litmus))) {
+ LOG.info(getInetAddress() + " attempting to connect over ssl");
+ SSLSocket sslSocket;
+ try {
+ sslSocket = x509Util.createSSLSocket(prependableSocket);
+ } catch (X509Exception e) {
+ throw new IOException("failed to create SSL context", e);
+ }
+ sslSocket.setUseClientMode(false);
+ return sslSocket;
+ } else {
+ LOG.info(getInetAddress() + " attempting to connect without ssl");
+ return prependableSocket;
+ }
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/0e3b82bd/src/java/test/org/apache/zookeeper/common/X509UtilTest.java
----------------------------------------------------------------------
diff --git a/src/java/test/org/apache/zookeeper/common/X509UtilTest.java b/src/java/test/org/apache/zookeeper/common/X509UtilTest.java
new file mode 100644
index 0000000..51c42e9
--- /dev/null
+++ b/src/java/test/org/apache/zookeeper/common/X509UtilTest.java
@@ -0,0 +1,264 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.zookeeper.common;
+
+import org.apache.zookeeper.PortAssignment;
+import org.apache.zookeeper.ZKTestCase;
+import org.apache.zookeeper.client.ZKClientConfig;
+import org.apache.zookeeper.server.ServerCnxnFactory;
+import org.bouncycastle.asn1.x500.X500NameBuilder;
+import org.bouncycastle.asn1.x500.style.BCStyle;
+import org.bouncycastle.asn1.x509.BasicConstraints;
+import org.bouncycastle.asn1.x509.Extension;
+import org.bouncycastle.asn1.x509.KeyUsage;
+import org.bouncycastle.cert.X509v3CertificateBuilder;
+import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter;
+import org.bouncycastle.cert.jcajce.JcaX509v3CertificateBuilder;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+import org.bouncycastle.operator.ContentSigner;
+import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLServerSocket;
+import javax.net.ssl.SSLSocket;
+import java.io.FileOutputStream;
+import java.math.BigInteger;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.KeyStore;
+import java.security.Security;
+import java.security.cert.Certificate;
+import java.security.cert.X509Certificate;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Random;
+
+import static org.apache.zookeeper.test.ClientBase.createTmpDir;
+
+public class X509UtilTest extends ZKTestCase {
+
+ private static final char[] PASSWORD = "password".toCharArray();
+ private X509Certificate rootCertificate;
+
+ private String truststorePath;
+ private String keystorePath;
+ private static KeyPair rootKeyPair;
+
+ private X509Util x509Util;
+ private String[] customCipherSuites = new String[]{"SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA", "SSL_DH_anon_EXPORT_WITH_DES40_CBC_SHA"};
+
+ @BeforeClass
+ public static void createKeyPair() throws Exception {
+ Security.addProvider(new BouncyCastleProvider());
+ KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA", BouncyCastleProvider.PROVIDER_NAME);
+ keyPairGenerator.initialize(4096);
+ rootKeyPair = keyPairGenerator.genKeyPair();
+ }
+
+ @AfterClass
+ public static void removeBouncyCastleProvider() throws Exception {
+ Security.removeProvider("BC");
+ }
+
+ @Before
+ public void setUp() throws Exception {
+ rootCertificate = createSelfSignedCertifcate(rootKeyPair);
+
+ String tmpDir = createTmpDir().getAbsolutePath();
+ truststorePath = tmpDir + "/truststore.jks";
+ keystorePath = tmpDir + "/keystore.jks";
+
+ x509Util = new ClientX509Util();
+
+ writeKeystore(rootCertificate, rootKeyPair, keystorePath);
+
+ System.setProperty(ServerCnxnFactory.ZOOKEEPER_SERVER_CNXN_FACTORY, "org.apache.zookeeper.server.NettyServerCnxnFactory");
+ System.setProperty(ZKClientConfig.ZOOKEEPER_CLIENT_CNXN_SOCKET, "org.apache.zookeeper.ClientCnxnSocketNetty");
+ System.setProperty(x509Util.getSslKeystoreLocationProperty(), keystorePath);
+ System.setProperty(x509Util.getSslKeystorePasswdProperty(), new String(PASSWORD));
+ System.setProperty(x509Util.getSslTruststoreLocationProperty(), truststorePath);
+ System.setProperty(x509Util.getSslTruststorePasswdProperty(), new String(PASSWORD));
+ System.setProperty(x509Util.getSslHostnameVerificationEnabledProperty(), "false");
+
+ writeTrustStore(PASSWORD);
+ }
+
+ private void writeKeystore(X509Certificate certificate, KeyPair keyPair, String path) throws Exception {
+ KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
+ keyStore.load(null, PASSWORD);
+ keyStore.setKeyEntry("alias", keyPair.getPrivate(), PASSWORD, new Certificate[] { certificate });
+ FileOutputStream outputStream = new FileOutputStream(path);
+ keyStore.store(outputStream, PASSWORD);
+ outputStream.flush();
+ outputStream.close();
+ }
+
+ private void writeTrustStore(char[] password) throws Exception {
+ KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
+ trustStore.load(null, password);
+ trustStore.setCertificateEntry(rootCertificate.getSubjectDN().toString(), rootCertificate);
+ FileOutputStream outputStream = new FileOutputStream(truststorePath);
+ if (password == null) {
+ trustStore.store(outputStream, new char[0]);
+ } else {
+ trustStore.store(outputStream, password);
+ }
+ outputStream.flush();
+ outputStream.close();
+ }
+
+ private X509Certificate createSelfSignedCertifcate(KeyPair keyPair) throws Exception {
+ X500NameBuilder nameBuilder = new X500NameBuilder(BCStyle.INSTANCE);
+ nameBuilder.addRDN(BCStyle.CN, "localhost");
+ Date notBefore = new Date();
+ Calendar cal = Calendar.getInstance();
+ cal.setTime(notBefore);
+ cal.add(Calendar.YEAR, 1);
+ Date notAfter = cal.getTime();
+ BigInteger serialNumber = new BigInteger(128, new Random());
+
+ X509v3CertificateBuilder certificateBuilder =
+ new JcaX509v3CertificateBuilder(nameBuilder.build(), serialNumber, notBefore, notAfter, nameBuilder.build(), keyPair.getPublic())
+ .addExtension(Extension.basicConstraints, true, new BasicConstraints(0))
+ .addExtension(Extension.keyUsage, true, new KeyUsage(KeyUsage.digitalSignature | KeyUsage.keyCertSign | KeyUsage.cRLSign));
+
+ ContentSigner contentSigner = new JcaContentSignerBuilder("SHA256WithRSAEncryption").build(keyPair.getPrivate());
+
+ return new JcaX509CertificateConverter().getCertificate(certificateBuilder.build(contentSigner));
+ }
+
+ @After
+ public void cleanUp() throws Exception {
+ System.clearProperty(x509Util.getSslKeystoreLocationProperty());
+ System.clearProperty(x509Util.getSslKeystorePasswdProperty());
+ System.clearProperty(x509Util.getSslTruststoreLocationProperty());
+ System.clearProperty(x509Util.getSslTruststorePasswdProperty());
+ System.clearProperty(x509Util.getSslHostnameVerificationEnabledProperty());
+ System.clearProperty(x509Util.getSslOcspEnabledProperty());
+ System.clearProperty(x509Util.getSslCrlEnabledProperty());
+ System.clearProperty(x509Util.getCipherSuitesProperty());
+ System.clearProperty("com.sun.net.ssl.checkRevocation");
+ System.clearProperty("com.sun.security.enableCRLDP");
+ Security.setProperty("com.sun.security.enableCRLDP", "false");
+ }
+
+ @Test(timeout = 5000)
+ public void testCreateSSLContextWithoutCustomProtocol() throws Exception {
+ SSLContext sslContext = x509Util.getDefaultSSLContext();
+ Assert.assertEquals(X509Util.DEFAULT_PROTOCOL, sslContext.getProtocol());
+ }
+
+ @Test(timeout = 5000)
+ public void testCreateSSLContextWithCustomProtocol() throws Exception {
+ final String protocol = "TLSv1.1";
+ System.setProperty(x509Util.getSslProtocolProperty(), protocol);
+ SSLContext sslContext = x509Util.getDefaultSSLContext();
+ Assert.assertEquals(protocol, sslContext.getProtocol());
+ }
+
+ @Test(timeout = 5000)
+ public void testCreateSSLContextWithoutTrustStorePassword() throws Exception {
+ writeTrustStore(null);
+ System.clearProperty(x509Util.getSslTruststorePasswdProperty());
+ x509Util.getDefaultSSLContext();
+ }
+
+ @Test(timeout = 5000, expected = X509Exception.SSLContextException.class)
+ public void testCreateSSLContextWithoutKeyStoreLocation() throws Exception {
+ System.clearProperty(x509Util.getSslKeystoreLocationProperty());
+ x509Util.getDefaultSSLContext();
+ }
+
+ @Test(timeout = 5000, expected = X509Exception.SSLContextException.class)
+ public void testCreateSSLContextWithoutKeyStorePassword() throws Exception {
+ System.clearProperty(x509Util.getSslKeystorePasswdProperty());
+ x509Util.getDefaultSSLContext();
+ }
+
+ @Test(timeout = 5000)
+ public void testCreateSSLContextWithCustomCipherSuites() throws Exception {
+ setCustomCipherSuites();
+ SSLSocket sslSocket = x509Util.createSSLSocket();
+ Assert.assertArrayEquals(customCipherSuites, sslSocket.getEnabledCipherSuites());
+ }
+
+ // It would be great to test the value of PKIXBuilderParameters#setRevocationEnabled but it does not appear to be
+ // possible
+ @Test(timeout = 5000)
+ public void testCRLEnabled() throws Exception {
+ System.setProperty(x509Util.getSslCrlEnabledProperty(), "true");
+ x509Util.getDefaultSSLContext();
+ Assert.assertTrue(Boolean.valueOf(System.getProperty("com.sun.net.ssl.checkRevocation")));
+ Assert.assertTrue(Boolean.valueOf(System.getProperty("com.sun.security.enableCRLDP")));
+ Assert.assertFalse(Boolean.valueOf(Security.getProperty("ocsp.enable")));
+ }
+
+ @Test(timeout = 5000)
+ public void testCRLDisabled() throws Exception {
+ x509Util.getDefaultSSLContext();
+ Assert.assertFalse(Boolean.valueOf(System.getProperty("com.sun.net.ssl.checkRevocation")));
+ Assert.assertFalse(Boolean.valueOf(System.getProperty("com.sun.security.enableCRLDP")));
+ Assert.assertFalse(Boolean.valueOf(Security.getProperty("ocsp.enable")));
+ }
+
+ @Test(timeout = 5000)
+ public void testOCSPEnabled() throws Exception {
+ System.setProperty(x509Util.getSslOcspEnabledProperty(), "true");
+ x509Util.getDefaultSSLContext();
+ Assert.assertTrue(Boolean.valueOf(System.getProperty("com.sun.net.ssl.checkRevocation")));
+ Assert.assertTrue(Boolean.valueOf(System.getProperty("com.sun.security.enableCRLDP")));
+ Assert.assertTrue(Boolean.valueOf(Security.getProperty("ocsp.enable")));
+ }
+
+ @Test(timeout = 5000)
+ public void testCreateSSLSocket() throws Exception {
+ setCustomCipherSuites();
+ SSLSocket sslSocket = x509Util.createSSLSocket();
+ Assert.assertArrayEquals(customCipherSuites, sslSocket.getEnabledCipherSuites());
+ }
+
+ @Test(timeout = 5000)
+ public void testCreateSSLServerSocketWithoutPort() throws Exception {
+ setCustomCipherSuites();
+ SSLServerSocket sslServerSocket = x509Util.createSSLServerSocket();
+ Assert.assertArrayEquals(customCipherSuites, sslServerSocket.getEnabledCipherSuites());
+ Assert.assertTrue(sslServerSocket.getNeedClientAuth());
+ }
+
+ @Test(timeout = 5000)
+ public void testCreateSSLServerSocketWithPort() throws Exception {
+ int port = PortAssignment.unique();
+ setCustomCipherSuites();
+ SSLServerSocket sslServerSocket = x509Util.createSSLServerSocket(port);
+ Assert.assertEquals(sslServerSocket.getLocalPort(), port);
+ Assert.assertArrayEquals(customCipherSuites, sslServerSocket.getEnabledCipherSuites());
+ Assert.assertTrue(sslServerSocket.getNeedClientAuth());
+ }
+
+ // Warning: this will reset the x509Util
+ private void setCustomCipherSuites() {
+ System.setProperty(x509Util.getCipherSuitesProperty(), customCipherSuites[0] + "," + customCipherSuites[1]);
+ x509Util = new ClientX509Util();
+ }
+}
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/0e3b82bd/src/java/test/org/apache/zookeeper/common/ZKTrustManagerTest.java
----------------------------------------------------------------------
diff --git a/src/java/test/org/apache/zookeeper/common/ZKTrustManagerTest.java b/src/java/test/org/apache/zookeeper/common/ZKTrustManagerTest.java
new file mode 100644
index 0000000..32f250b
--- /dev/null
+++ b/src/java/test/org/apache/zookeeper/common/ZKTrustManagerTest.java
@@ -0,0 +1,248 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.zookeeper.common;
+
+import org.apache.zookeeper.ZKTestCase;
+import org.bouncycastle.asn1.x500.X500NameBuilder;
+import org.bouncycastle.asn1.x500.style.BCStyle;
+import org.bouncycastle.asn1.x509.BasicConstraints;
+import org.bouncycastle.asn1.x509.Extension;
+import org.bouncycastle.asn1.x509.GeneralName;
+import org.bouncycastle.asn1.x509.GeneralNames;
+import org.bouncycastle.asn1.x509.KeyUsage;
+import org.bouncycastle.cert.X509v3CertificateBuilder;
+import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter;
+import org.bouncycastle.cert.jcajce.JcaX509v3CertificateBuilder;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+import org.bouncycastle.operator.ContentSigner;
+import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import javax.net.ssl.X509ExtendedTrustManager;
+import java.math.BigInteger;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.Security;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+import java.util.Random;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+// We can only test calls to ZKTrustManager using Sockets (not SSLEngines). This can be fine since the logic is the same.
+public class ZKTrustManagerTest extends ZKTestCase {
+
+ private static KeyPair keyPair;
+
+ private X509ExtendedTrustManager mockX509ExtendedTrustManager;
+ private static final String IP_ADDRESS = "127.0.0.1";
+ private static final String HOSTNAME = "localhost";
+
+ private InetAddress mockInetAddress;
+ private Socket mockSocket;
+
+ @BeforeClass
+ public static void createKeyPair() throws Exception {
+ Security.addProvider(new BouncyCastleProvider());
+ KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA", BouncyCastleProvider.PROVIDER_NAME);
+ keyPairGenerator.initialize(4096);
+ keyPair = keyPairGenerator.genKeyPair();
+ }
+
+ @AfterClass
+ public static void removeBouncyCastleProvider() throws Exception {
+ Security.removeProvider("BC");
+ }
+
+ @Before
+ public void setup() throws Exception {
+ mockX509ExtendedTrustManager = mock(X509ExtendedTrustManager.class);
+
+ mockInetAddress = mock(InetAddress.class);
+ when(mockInetAddress.getHostAddress()).thenAnswer(new Answer() {
+ @Override
+ public Object answer(InvocationOnMock invocationOnMock) throws Throwable {
+ return IP_ADDRESS;
+ }
+ });
+
+ when(mockInetAddress.getHostName()).thenAnswer(new Answer() {
+ @Override
+ public Object answer(InvocationOnMock invocationOnMock) throws Throwable {
+ return HOSTNAME;
+ }
+ });
+
+ mockSocket = mock(Socket.class);
+ when(mockSocket.getInetAddress()).thenAnswer(new Answer() {
+ @Override
+ public Object answer(InvocationOnMock invocationOnMock) throws Throwable {
+ return mockInetAddress;
+ }
+ });
+ }
+
+ private X509Certificate[] createSelfSignedCertifcateChain(String ipAddress, String hostname) throws Exception {
+ X500NameBuilder nameBuilder = new X500NameBuilder(BCStyle.INSTANCE);
+ nameBuilder.addRDN(BCStyle.CN, "NOT_LOCALHOST");
+ Date notBefore = new Date();
+ Calendar cal = Calendar.getInstance();
+ cal.setTime(notBefore);
+ cal.add(Calendar.YEAR, 1);
+ Date notAfter = cal.getTime();
+ BigInteger serialNumber = new BigInteger(128, new Random());
+
+ X509v3CertificateBuilder certificateBuilder =
+ new JcaX509v3CertificateBuilder(nameBuilder.build(), serialNumber, notBefore, notAfter, nameBuilder.build(), keyPair.getPublic())
+ .addExtension(Extension.basicConstraints, true, new BasicConstraints(0))
+ .addExtension(Extension.keyUsage, true, new KeyUsage(KeyUsage.digitalSignature | KeyUsage.keyCertSign | KeyUsage.cRLSign));
+
+ List<GeneralName> generalNames = new ArrayList<>();
+ if (ipAddress != null) {
+ generalNames.add(new GeneralName(GeneralName.iPAddress, ipAddress));
+ }
+ if (hostname != null) {
+ generalNames.add(new GeneralName(GeneralName.dNSName, hostname));
+ }
+
+ if (!generalNames.isEmpty()) {
+ certificateBuilder.addExtension(Extension.subjectAlternativeName, true, new GeneralNames(generalNames.toArray(new GeneralName[] {})));
+ }
+
+ ContentSigner contentSigner = new JcaContentSignerBuilder("SHA256WithRSAEncryption").build(keyPair.getPrivate());
+
+ return new X509Certificate[] { new JcaX509CertificateConverter().getCertificate(certificateBuilder.build(contentSigner)) };
+ }
+
+ @Test
+ public void testServerHostnameVerificationWithHostnameVerificationDisabled() throws Exception {
+ ZKTrustManager zkTrustManager = new ZKTrustManager(mockX509ExtendedTrustManager, false, false);
+
+ X509Certificate[] certificateChain = createSelfSignedCertifcateChain(IP_ADDRESS, HOSTNAME);
+ zkTrustManager.checkServerTrusted(certificateChain, null, mockSocket);
+
+ verify(mockInetAddress, times(0)).getHostAddress();
+ verify(mockInetAddress, times(0)).getHostName();
+
+ verify(mockX509ExtendedTrustManager, times(1)).checkServerTrusted(certificateChain, null, mockSocket);
+ }
+
+ @Test
+ public void testServerHostnameVerificationWithHostnameVerificationDisabledAndClientHostnameVerificationEnabled() throws Exception {
+ ZKTrustManager zkTrustManager = new ZKTrustManager(mockX509ExtendedTrustManager, false, true);
+
+ X509Certificate[] certificateChain = createSelfSignedCertifcateChain(IP_ADDRESS, HOSTNAME);
+ zkTrustManager.checkServerTrusted(certificateChain, null, mockSocket);
+
+ verify(mockInetAddress, times(0)).getHostAddress();
+ verify(mockInetAddress, times(0)).getHostName();
+
+ verify(mockX509ExtendedTrustManager, times(1)).checkServerTrusted(certificateChain, null, mockSocket);
+ }
+
+ @Test
+ public void testServerHostnameVerificationWithIPAddress() throws Exception {
+ ZKTrustManager zkTrustManager = new ZKTrustManager(mockX509ExtendedTrustManager, true, false);
+
+ X509Certificate[] certificateChain = createSelfSignedCertifcateChain(IP_ADDRESS, null);
+ zkTrustManager.checkServerTrusted(certificateChain, null, mockSocket);
+
+ verify(mockInetAddress, times(1)).getHostAddress();
+ verify(mockInetAddress, times(0)).getHostName();
+
+ verify(mockX509ExtendedTrustManager, times(1)).checkServerTrusted(certificateChain, null, mockSocket);
+ }
+
+ @Test
+ public void testServerHostnameVerificationWithHostname() throws Exception {
+ ZKTrustManager zkTrustManager = new ZKTrustManager(mockX509ExtendedTrustManager, true, false);
+
+ X509Certificate[] certificateChain = createSelfSignedCertifcateChain(null, HOSTNAME);
+ zkTrustManager.checkServerTrusted(certificateChain, null, mockSocket);
+
+ verify(mockInetAddress, times(1)).getHostAddress();
+ verify(mockInetAddress, times(1)).getHostName();
+
+ verify(mockX509ExtendedTrustManager, times(1)).checkServerTrusted(certificateChain, null, mockSocket);
+ }
+
+ @Test
+ public void testClientHostnameVerificationWithHostnameVerificationDisabled() throws Exception {
+ ZKTrustManager zkTrustManager = new ZKTrustManager(mockX509ExtendedTrustManager, false, true);
+
+ X509Certificate[] certificateChain = createSelfSignedCertifcateChain(null, HOSTNAME);
+ zkTrustManager.checkClientTrusted(certificateChain, null, mockSocket);
+
+ verify(mockInetAddress, times(1)).getHostAddress();
+ verify(mockInetAddress, times(1)).getHostName();
+
+ verify(mockX509ExtendedTrustManager, times(1)).checkClientTrusted(certificateChain, null, mockSocket);
+ }
+
+ @Test
+ public void testClientHostnameVerificationWithClientHostnameVerificationDisabled() throws Exception {
+ ZKTrustManager zkTrustManager = new ZKTrustManager(mockX509ExtendedTrustManager, true, false);
+
+ X509Certificate[] certificateChain = createSelfSignedCertifcateChain(null, HOSTNAME);
+ zkTrustManager.checkClientTrusted(certificateChain, null, mockSocket);
+
+ verify(mockInetAddress, times(0)).getHostAddress();
+ verify(mockInetAddress, times(0)).getHostName();
+
+ verify(mockX509ExtendedTrustManager, times(1)).checkClientTrusted(certificateChain, null, mockSocket);
+ }
+
+ @Test
+ public void testClientHostnameVerificationWithIPAddress() throws Exception {
+ ZKTrustManager zkTrustManager = new ZKTrustManager(mockX509ExtendedTrustManager, true, true);
+
+ X509Certificate[] certificateChain = createSelfSignedCertifcateChain(IP_ADDRESS, null);
+ zkTrustManager.checkClientTrusted(certificateChain, null, mockSocket);
+
+ verify(mockInetAddress, times(1)).getHostAddress();
+ verify(mockInetAddress, times(0)).getHostName();
+
+ verify(mockX509ExtendedTrustManager, times(1)).checkClientTrusted(certificateChain, null, mockSocket);
+ }
+
+ @Test
+ public void testClientHostnameVerificationWithHostname() throws Exception {
+ ZKTrustManager zkTrustManager = new ZKTrustManager(mockX509ExtendedTrustManager, true, true);
+
+ X509Certificate[] certificateChain = createSelfSignedCertifcateChain(null, HOSTNAME);
+ zkTrustManager.checkClientTrusted(certificateChain, null, mockSocket);
+
+ verify(mockInetAddress, times(1)).getHostAddress();
+ verify(mockInetAddress, times(1)).getHostName();
+
+ verify(mockX509ExtendedTrustManager, times(1)).checkClientTrusted(certificateChain, null, mockSocket);
+ }
+}
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/0e3b82bd/src/java/test/org/apache/zookeeper/server/quorum/LeaderBeanTest.java
----------------------------------------------------------------------
diff --git a/src/java/test/org/apache/zookeeper/server/quorum/LeaderBeanTest.java b/src/java/test/org/apache/zookeeper/server/quorum/LeaderBeanTest.java
index f8108cd..31cef79 100644
--- a/src/java/test/org/apache/zookeeper/server/quorum/LeaderBeanTest.java
+++ b/src/java/test/org/apache/zookeeper/server/quorum/LeaderBeanTest.java
@@ -20,6 +20,7 @@ package org.apache.zookeeper.server.quorum;
import org.apache.jute.OutputArchive;
import org.apache.jute.Record;
+import org.apache.zookeeper.common.X509Exception;
import org.apache.zookeeper.server.Request;
import org.apache.zookeeper.server.ZKDatabase;
import org.apache.zookeeper.server.persistence.FileTxnSnapLog;
@@ -51,7 +52,7 @@ public class LeaderBeanTest {
private QuorumPeer qp;
@Before
- public void setUp() throws IOException {
+ public void setUp() throws IOException, X509Exception {
qp = new QuorumPeer();
QuorumVerifier quorumVerifierMock = mock(QuorumVerifier.class);
qp.setQuorumVerifier(quorumVerifierMock, false);
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/0e3b82bd/src/java/test/org/apache/zookeeper/server/quorum/QuorumBeanTest.java
----------------------------------------------------------------------
diff --git a/src/java/test/org/apache/zookeeper/server/quorum/QuorumBeanTest.java b/src/java/test/org/apache/zookeeper/server/quorum/QuorumBeanTest.java
new file mode 100644
index 0000000..650dc82
--- /dev/null
+++ b/src/java/test/org/apache/zookeeper/server/quorum/QuorumBeanTest.java
@@ -0,0 +1,75 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.zookeeper.server.quorum;
+
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class QuorumBeanTest {
+ @Test
+ public void testGetNameProperty() {
+ QuorumPeer qpMock = mock(QuorumPeer.class);
+ when(qpMock.getId()).thenReturn(1L);
+ QuorumBean qb = new QuorumBean(qpMock);
+
+ assertThat("getName property should return Bean name in the right format", qb.getName(), equalTo("ReplicatedServer_id1"));
+ }
+
+ @Test
+ public void testIsHiddenProperty() {
+ QuorumPeer qpMock = mock(QuorumPeer.class);
+ QuorumBean qb = new QuorumBean(qpMock);
+ assertThat("isHidden should return false", qb.isHidden(), equalTo(false));
+ }
+
+ @Test
+ public void testGetQuorumSizeProperty() {
+ QuorumPeer qpMock = mock(QuorumPeer.class);
+ QuorumBean qb = new QuorumBean(qpMock);
+
+ when(qpMock.getQuorumSize()).thenReturn(5);
+ assertThat("getQuorumSize property should return value of peet.getQuorumSize()", qb.getQuorumSize(), equalTo(5));
+ }
+
+ @Test
+ public void testSslQuorumProperty() {
+ QuorumPeer qpMock = mock(QuorumPeer.class);
+ QuorumBean qb = new QuorumBean(qpMock);
+
+ when(qpMock.isSslQuorum()).thenReturn(true);
+ assertThat("isSslQuorum property should return value of peer.isSslQuorum()", qb.isSslQuorum(), equalTo(true));
+ when(qpMock.isSslQuorum()).thenReturn(false);
+ assertThat("isSslQuorum property should return value of peer.isSslQuorum()", qb.isSslQuorum(), equalTo(false));
+ }
+
+ @Test
+ public void testPortUnificationProperty() {
+ QuorumPeer qpMock = mock(QuorumPeer.class);
+ QuorumBean qb = new QuorumBean(qpMock);
+
+ when(qpMock.shouldUsePortUnification()).thenReturn(true);
+ assertThat("isPortUnification property should return value of peer.shouldUsePortUnification()", qb.isPortUnification(), equalTo(true));
+ when(qpMock.shouldUsePortUnification()).thenReturn(false);
+ assertThat("isPortUnification property should return value of peer.shouldUsePortUnification()", qb.isPortUnification(), equalTo(false));
+ }
+}
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/0e3b82bd/src/java/test/org/apache/zookeeper/server/quorum/QuorumPeerConfigTest.java
----------------------------------------------------------------------
diff --git a/src/java/test/org/apache/zookeeper/server/quorum/QuorumPeerConfigTest.java b/src/java/test/org/apache/zookeeper/server/quorum/QuorumPeerConfigTest.java
index 3f5a2b2..70d8379 100644
--- a/src/java/test/org/apache/zookeeper/server/quorum/QuorumPeerConfigTest.java
+++ b/src/java/test/org/apache/zookeeper/server/quorum/QuorumPeerConfigTest.java
@@ -26,7 +26,7 @@ import java.io.File;
import java.io.IOException;
import java.util.Properties;
-import org.apache.zookeeper.common.ZKConfig;
+import org.apache.zookeeper.common.ClientX509Util;
import org.apache.zookeeper.server.quorum.QuorumPeerConfig.ConfigException;
import org.junit.Test;
@@ -91,7 +91,7 @@ public class QuorumPeerConfigTest {
@Test
public void testCustomSSLAuth()
throws IOException{
- System.setProperty(ZKConfig.SSL_AUTHPROVIDER, "y509");
+ System.setProperty(new ClientX509Util().getSslAuthProviderProperty(), "y509");
QuorumPeerConfig quorumPeerConfig = new QuorumPeerConfig();
try {
Properties zkProp = getDefaultZKProperties();
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/0e3b82bd/src/java/test/org/apache/zookeeper/server/quorum/QuorumSSLTest.java
----------------------------------------------------------------------
diff --git a/src/java/test/org/apache/zookeeper/server/quorum/QuorumSSLTest.java b/src/java/test/org/apache/zookeeper/server/quorum/QuorumSSLTest.java
new file mode 100644
index 0000000..b088f47
--- /dev/null
+++ b/src/java/test/org/apache/zookeeper/server/quorum/QuorumSSLTest.java
@@ -0,0 +1,771 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.zookeeper.server.quorum;
+
+import com.sun.net.httpserver.Headers;
+import com.sun.net.httpserver.HttpHandler;
+import com.sun.net.httpserver.HttpServer;
+import org.apache.zookeeper.PortAssignment;
+import org.apache.zookeeper.client.ZKClientConfig;
+import org.apache.zookeeper.common.QuorumX509Util;
+import org.apache.zookeeper.server.ServerCnxnFactory;
+import org.apache.zookeeper.test.ClientBase;
+import org.bouncycastle.asn1.ocsp.OCSPResponse;
+import org.bouncycastle.asn1.ocsp.OCSPResponseStatus;
+import org.bouncycastle.asn1.x500.X500Name;
+import org.bouncycastle.asn1.x500.X500NameBuilder;
+import org.bouncycastle.asn1.x500.style.BCStyle;
+import org.bouncycastle.asn1.x509.AuthorityInformationAccess;
+import org.bouncycastle.asn1.x509.BasicConstraints;
+import org.bouncycastle.asn1.x509.CRLDistPoint;
+import org.bouncycastle.asn1.x509.CRLNumber;
+import org.bouncycastle.asn1.x509.CRLReason;
+import org.bouncycastle.asn1.x509.DistributionPoint;
+import org.bouncycastle.asn1.x509.DistributionPointName;
+import org.bouncycastle.asn1.x509.Extension;
+import org.bouncycastle.asn1.x509.GeneralName;
+import org.bouncycastle.asn1.x509.GeneralNames;
+import org.bouncycastle.asn1.x509.KeyUsage;
+import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;
+import org.bouncycastle.asn1.x509.X509ObjectIdentifiers;
+import org.bouncycastle.cert.X509CRLHolder;
+import org.bouncycastle.cert.X509CertificateHolder;
+import org.bouncycastle.cert.X509ExtensionUtils;
+import org.bouncycastle.cert.X509v2CRLBuilder;
+import org.bouncycastle.cert.X509v3CertificateBuilder;
+import org.bouncycastle.cert.bc.BcX509ExtensionUtils;
+import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter;
+import org.bouncycastle.cert.jcajce.JcaX509CertificateHolder;
+import org.bouncycastle.cert.jcajce.JcaX509ExtensionUtils;
+import org.bouncycastle.cert.jcajce.JcaX509v2CRLBuilder;
+import org.bouncycastle.cert.jcajce.JcaX509v3CertificateBuilder;
+import org.bouncycastle.cert.ocsp.BasicOCSPResp;
+import org.bouncycastle.cert.ocsp.BasicOCSPRespBuilder;
+import org.bouncycastle.cert.ocsp.CertificateID;
+import org.bouncycastle.cert.ocsp.CertificateStatus;
+import org.bouncycastle.cert.ocsp.OCSPException;
+import org.bouncycastle.cert.ocsp.OCSPReq;
+import org.bouncycastle.cert.ocsp.OCSPResp;
+import org.bouncycastle.cert.ocsp.OCSPRespBuilder;
+import org.bouncycastle.cert.ocsp.Req;
+import org.bouncycastle.cert.ocsp.UnknownStatus;
+import org.bouncycastle.cert.ocsp.jcajce.JcaBasicOCSPRespBuilder;
+import org.bouncycastle.cert.ocsp.jcajce.JcaCertificateID;
+import org.bouncycastle.crypto.util.PublicKeyFactory;
+import org.bouncycastle.crypto.util.SubjectPublicKeyInfoFactory;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+import org.bouncycastle.openssl.MiscPEMGenerator;
+import org.bouncycastle.operator.ContentSigner;
+import org.bouncycastle.operator.DigestCalculator;
+import org.bouncycastle.operator.OperatorException;
+import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;
+import org.bouncycastle.operator.jcajce.JcaDigestCalculatorProviderBuilder;
+import org.bouncycastle.util.io.pem.PemWriter;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.Timeout;
+
+import javax.net.ssl.SSLServerSocketFactory;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.math.BigInteger;
+import java.net.InetSocketAddress;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.KeyStore;
+import java.security.NoSuchAlgorithmException;
+import java.security.NoSuchProviderException;
+import java.security.PrivateKey;
+import java.security.Security;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateEncodingException;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+
+import static org.apache.zookeeper.test.ClientBase.CONNECTION_TIMEOUT;
+import static org.apache.zookeeper.test.ClientBase.createTmpDir;
+import static org.junit.Assert.fail;
+
+public class QuorumSSLTest extends QuorumPeerTestBase {
+
+ private static final String SSL_QUORUM_ENABLED = "sslQuorum=true\n";
+ private static final String PORT_UNIFICATION_ENABLED = "portUnification=true\n";
+ private static final String PORT_UNIFICATION_DISABLED = "portUnification=false\n";
+
+ private static final char[] PASSWORD = "testpass".toCharArray();
+ private static final String HOSTNAME = "localhost";
+
+ private QuorumX509Util quorumX509Util = new QuorumX509Util();
+
+ private MainThread q1;
+ private MainThread q2;
+ private MainThread q3;
+
+ private int clientPortQp1;
+ private int clientPortQp2;
+ private int clientPortQp3;
+
+ private String tmpDir;
+
+ private String quorumConfiguration;
+ private String validKeystorePath;
+ private String truststorePath;
+
+ private KeyPair rootKeyPair;
+ private X509Certificate rootCertificate;
+
+ private KeyPair defaultKeyPair;
+
+ private ContentSigner contentSigner;
+
+ private Date certStartTime;
+ private Date certEndTime;
+
+ @Rule
+ public Timeout timeout = Timeout.builder().withTimeout(5, TimeUnit.MINUTES)
+ .withLookingForStuckThread(true).build();
+
+ @Before
+ public void setup() throws Exception {
+ ClientBase.setupTestEnv();
+
+ tmpDir = createTmpDir().getAbsolutePath();
+
+ clientPortQp1 = PortAssignment.unique();
+ clientPortQp2 = PortAssignment.unique();
+ clientPortQp3 = PortAssignment.unique();
+
+ validKeystorePath = tmpDir + "/valid.jks";
+ truststorePath = tmpDir + "/truststore.jks";
+
+ quorumConfiguration = generateQuorumConfiguration();
+
+ Security.addProvider(new BouncyCastleProvider());
+
+ certStartTime = new Date();
+ Calendar cal = Calendar.getInstance();
+ cal.setTime(certStartTime);
+ cal.add(Calendar.YEAR, 1);
+ certEndTime = cal.getTime();
+
+ rootKeyPair = createKeyPair();
+ contentSigner = new JcaContentSignerBuilder("SHA256WithRSAEncryption").build(rootKeyPair.getPrivate());
+ rootCertificate = createSelfSignedCertifcate(rootKeyPair);
+
+ // Write the truststore
+ KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
+ trustStore.load(null, PASSWORD);
+ trustStore.setCertificateEntry(rootCertificate.getSubjectDN().toString(), rootCertificate);
+ FileOutputStream outputStream = new FileOutputStream(truststorePath);
+ trustStore.store(outputStream, PASSWORD);
+ outputStream.flush();
+ outputStream.close();
+
+ defaultKeyPair = createKeyPair();
+ X509Certificate validCertificate = buildEndEntityCert(defaultKeyPair, rootCertificate, rootKeyPair.getPrivate(),
+ HOSTNAME, "127.0.0.1", null, null);
+ writeKeystore(validCertificate, defaultKeyPair, validKeystorePath);
+
+ setSSLSystemProperties();
+ }
+
+ private void writeKeystore(X509Certificate certificate, KeyPair entityKeyPair, String path) throws Exception {
+ KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
+ keyStore.load(null, PASSWORD);
+ keyStore.setKeyEntry("alias", entityKeyPair.getPrivate(), PASSWORD, new Certificate[] { certificate });
+ FileOutputStream outputStream = new FileOutputStream(path);
+ keyStore.store(outputStream, PASSWORD);
+ outputStream.flush();
+ outputStream.close();
+ }
+
+ private class OCSPHandler implements HttpHandler {
+
+ private X509Certificate revokedCert;
+
+ // Builds an OCSPHandler that responds with a good status for all certificates
+ // except revokedCert.
+ public OCSPHandler(X509Certificate revokedCert) {
+ this.revokedCert = revokedCert;
+ }
+
+ @Override
+ public void handle(com.sun.net.httpserver.HttpExchange httpExchange) throws IOException {
+ byte[] responseBytes;
+ try {
+ InputStream request = httpExchange.getRequestBody();
+ byte[] requestBytes = new byte[10000];
+ request.read(requestBytes);
+
+ OCSPReq ocspRequest = new OCSPReq(requestBytes);
+ Req[] requestList = ocspRequest.getRequestList();
+
+ DigestCalculator digestCalculator = new JcaDigestCalculatorProviderBuilder().build()
+ .get(CertificateID.HASH_SHA1);
+
+ BasicOCSPRespBuilder responseBuilder =
+ new JcaBasicOCSPRespBuilder(rootKeyPair.getPublic(), digestCalculator);
+ for ( Req req : requestList ) {
+ CertificateID certId = req.getCertID();
+ CertificateID revokedCertId =
+ new JcaCertificateID(digestCalculator, rootCertificate, revokedCert.getSerialNumber());
+ CertificateStatus certificateStatus;
+ if (revokedCertId.equals(certId)) {
+ certificateStatus = new UnknownStatus();
+ } else {
+ certificateStatus = CertificateStatus.GOOD;
+ }
+
+ responseBuilder.addResponse(certId, certificateStatus,null);
+ }
+
+ X509CertificateHolder[] chain = new X509CertificateHolder[] {
+ new JcaX509CertificateHolder(rootCertificate)
+ };
+ ContentSigner signer = new JcaContentSignerBuilder("SHA1withRSA").setProvider("BC")
+ .build(rootKeyPair.getPrivate());
+ BasicOCSPResp ocspResponse = responseBuilder.build(signer, chain, Calendar.getInstance().getTime() );
+
+ responseBytes = new OCSPRespBuilder().build(OCSPRespBuilder.SUCCESSFUL, ocspResponse).getEncoded();
+ } catch (OperatorException | CertificateEncodingException | OCSPException exception) {
+ responseBytes = new OCSPResp(new OCSPResponse(
+ new OCSPResponseStatus(OCSPRespBuilder.INTERNAL_ERROR), null)).getEncoded();
+ }
+
+ Headers rh = httpExchange.getResponseHeaders();
+ rh.set("Content-Type", "application/ocsp-response");
+ httpExchange.sendResponseHeaders(200, responseBytes.length);
+
+ OutputStream os = httpExchange.getResponseBody();
+ os.write(responseBytes);
+ os.close();
+ }
+ }
+
+ private X509Certificate createSelfSignedCertifcate(KeyPair keyPair) throws Exception {
+ X500NameBuilder nameBuilder = new X500NameBuilder(BCStyle.INSTANCE);
+ nameBuilder.addRDN(BCStyle.CN, HOSTNAME);
+ BigInteger serialNumber = new BigInteger(128, new Random());
+
+ X509v3CertificateBuilder certificateBuilder =
+ new JcaX509v3CertificateBuilder(nameBuilder.build(), serialNumber, certStartTime, certEndTime,
+ nameBuilder.build(), keyPair.getPublic())
+ .addExtension(Extension.basicConstraints, true, new BasicConstraints(0))
+ .addExtension(Extension.keyUsage, true,
+ new KeyUsage(KeyUsage.digitalSignature | KeyUsage.keyCertSign | KeyUsage.cRLSign));
+
+ return new JcaX509CertificateConverter().getCertificate(certificateBuilder.build(contentSigner));
+ }
+
+ private void buildCRL(X509Certificate x509Certificate, String crlPath) throws Exception {
+ X509v2CRLBuilder builder = new JcaX509v2CRLBuilder(x509Certificate.getIssuerX500Principal(), certStartTime);
+ builder.addCRLEntry(x509Certificate.getSerialNumber(), certStartTime, CRLReason.cACompromise);
+ builder.setNextUpdate(certEndTime);
+ builder.addExtension(Extension.authorityKeyIdentifier, false, new JcaX509ExtensionUtils()
+ .createAuthorityKeyIdentifier(rootCertificate));
+ builder.addExtension(Extension.cRLNumber, false, new CRLNumber(new BigInteger("1000")));
+
+ X509CRLHolder cRLHolder = builder.build(contentSigner);
+
+ PemWriter pemWriter = new PemWriter(new FileWriter(crlPath));
+ pemWriter.writeObject(new MiscPEMGenerator(cRLHolder));
+ pemWriter.flush();
+ pemWriter.close();
+ }
+
+ public X509Certificate buildEndEntityCert(KeyPair keyPair, X509Certificate caCert, PrivateKey caPrivateKey,
+ String hostname, String ipAddress, String crlPath, Integer ocspPort)
+ throws Exception {
+ X509CertificateHolder holder = new JcaX509CertificateHolder(caCert);
+ ContentSigner signer =new JcaContentSignerBuilder("SHA256WithRSAEncryption").build(caPrivateKey);
+
+ List<GeneralName> generalNames = new ArrayList<>();
+ if (hostname != null) {
+ generalNames.add(new GeneralName(GeneralName.dNSName, hostname));
+ }
+
+ if (ipAddress != null) {
+ generalNames.add(new GeneralName(GeneralName.iPAddress, ipAddress));
+ }
+
+ SubjectPublicKeyInfo entityKeyInfo =
+ SubjectPublicKeyInfoFactory.createSubjectPublicKeyInfo(PublicKeyFactory.createKey(keyPair.getPublic()
+ .getEncoded()));
+ X509ExtensionUtils extensionUtils = new BcX509ExtensionUtils();
+ X509v3CertificateBuilder certificateBuilder =
+ new JcaX509v3CertificateBuilder(holder.getSubject(), new BigInteger(128, new Random()),
+ certStartTime, certEndTime, new X500Name("CN=Test End Entity Certificate"), keyPair.getPublic())
+ .addExtension(Extension.authorityKeyIdentifier, false,
+ extensionUtils.createAuthorityKeyIdentifier(holder))
+ .addExtension(Extension.subjectKeyIdentifier, false,
+ extensionUtils.createSubjectKeyIdentifier(entityKeyInfo))
+ .addExtension(Extension.basicConstraints, true, new BasicConstraints(false))
+ .addExtension(Extension.keyUsage, true,
+ new KeyUsage(KeyUsage.digitalSignature | KeyUsage.keyEncipherment));
+
+ if (!generalNames.isEmpty()) {
+ certificateBuilder.addExtension(Extension.subjectAlternativeName, true,
+ new GeneralNames(generalNames.toArray(new GeneralName[] {})));
+ }
+
+ if (crlPath != null) {
+ DistributionPointName distPointOne = new DistributionPointName(new GeneralNames(
+ new GeneralName(GeneralName.uniformResourceIdentifier,"file://" + crlPath)));
+
+ certificateBuilder.addExtension(Extension.cRLDistributionPoints, false,
+ new CRLDistPoint(new DistributionPoint[] {
+ new DistributionPoint(distPointOne, null, null)
+ }));
+ }
+
+ if (ocspPort != null) {
+ certificateBuilder.addExtension(Extension.authorityInfoAccess, false,
+ new AuthorityInformationAccess(X509ObjectIdentifiers.ocspAccessMethod,
+ new GeneralName(GeneralName.uniformResourceIdentifier, "http://" + hostname + ":" + ocspPort)));
+ }
+
+ return new JcaX509CertificateConverter().getCertificate(certificateBuilder.build(signer));
+ }
+
+
+ private KeyPair createKeyPair() throws NoSuchProviderException, NoSuchAlgorithmException {
+ KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA",
+ BouncyCastleProvider.PROVIDER_NAME);
+ keyPairGenerator.initialize(4096);
+ KeyPair keyPair = keyPairGenerator.genKeyPair();
+ return keyPair;
+ }
+
+ private String generateQuorumConfiguration() {
+ int portQp1 = PortAssignment.unique();
+ int portQp2 = PortAssignment.unique();
+ int portQp3 = PortAssignment.unique();
+
+ int portLe1 = PortAssignment.unique();
+ int portLe2 = PortAssignment.unique();
+ int portLe3 = PortAssignment.unique();
+
+
+
+ return "server.1=127.0.0.1:" + (portQp1) + ":" + (portLe1) + ";" + clientPortQp1 + "\n" +
+ "server.2=127.0.0.1:" + (portQp2) + ":" + (portLe2) + ";" + clientPortQp2 + "\n" +
+ "server.3=127.0.0.1:" + (portQp3) + ":" + (portLe3) + ";" + clientPortQp3;
+ }
+
+
+ public void setSSLSystemProperties() {
+ System.setProperty(ServerCnxnFactory.ZOOKEEPER_SERVER_CNXN_FACTORY,
+ "org.apache.zookeeper.server.NettyServerCnxnFactory");
+ System.setProperty(ZKClientConfig.ZOOKEEPER_CLIENT_CNXN_SOCKET, "org.apache.zookeeper.ClientCnxnSocketNetty");
+ System.setProperty(quorumX509Util.getSslKeystoreLocationProperty(), validKeystorePath);
+ System.setProperty(quorumX509Util.getSslKeystorePasswdProperty(), "testpass");
+ System.setProperty(quorumX509Util.getSslTruststoreLocationProperty(), truststorePath);
+ System.setProperty(quorumX509Util.getSslTruststorePasswdProperty(), "testpass");
+ }
+
+ @After
+ public void cleanUp() throws Exception {
+ clearSSLSystemProperties();
+ if (q1 != null) {
+ q1.shutdown();
+ }
+ if (q2 != null) {
+ q2.shutdown();
+ }
+ if (q3 != null) {
+ q3.shutdown();
+ }
+
+ Security.removeProvider("BC");
+ }
+
+ private void clearSSLSystemProperties() {
+ System.clearProperty(quorumX509Util.getSslKeystoreLocationProperty());
+ System.clearProperty(quorumX509Util.getSslKeystorePasswdProperty());
+ System.clearProperty(quorumX509Util.getSslTruststoreLocationProperty());
+ System.clearProperty(quorumX509Util.getSslTruststorePasswdProperty());
+ System.clearProperty(quorumX509Util.getSslHostnameVerificationEnabledProperty());
+ System.clearProperty(quorumX509Util.getSslOcspEnabledProperty());
+ System.clearProperty(quorumX509Util.getSslCrlEnabledProperty());
+ System.clearProperty(quorumX509Util.getCipherSuitesProperty());
+ System.clearProperty(quorumX509Util.getSslProtocolProperty());
+ }
+
+ @Test
+ public void testQuorumSSL() throws Exception {
+ q1 = new MainThread(1, clientPortQp1, quorumConfiguration, SSL_QUORUM_ENABLED);
+ q2 = new MainThread(2, clientPortQp2, quorumConfiguration, SSL_QUORUM_ENABLED);
+
+
+ q1.start();
+ q2.start();
+
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp1, CONNECTION_TIMEOUT));
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp2, CONNECTION_TIMEOUT));
+
+ clearSSLSystemProperties();
+
+ // This server should fail to join the quorum as it is not using ssl.
+ q3 = new MainThread(3, clientPortQp3, quorumConfiguration);
+ q3.start();
+
+ Assert.assertFalse(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp3, CONNECTION_TIMEOUT));
+ }
+
+ @Ignore("portUnification is currently broken and disabled")
+ @Test
+ public void testRollingUpgrade() throws Exception {
+ // Form a quorum without ssl
+ q1 = new MainThread(1, clientPortQp1, quorumConfiguration);
+ q2 = new MainThread(2, clientPortQp2, quorumConfiguration);
+ q3 = new MainThread(3, clientPortQp3, quorumConfiguration);
+
+
+ Map<Integer, MainThread> members = new HashMap<>();
+ members.put(clientPortQp1, q1);
+ members.put(clientPortQp2, q2);
+ members.put(clientPortQp3, q3);
+
+ for (MainThread member : members.values()) {
+ member.start();
+ }
+
+ for (int clientPort : members.keySet()) {
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPort, CONNECTION_TIMEOUT));
+ }
+
+ // Set SSL system properties and port unification, begin restarting servers
+ setSSLSystemProperties();
+
+ stopAppendConfigRestartAll(members, PORT_UNIFICATION_ENABLED);
+ stopAppendConfigRestartAll(members, SSL_QUORUM_ENABLED);
+ stopAppendConfigRestartAll(members, PORT_UNIFICATION_DISABLED);
+ }
+
+ private void stopAppendConfigRestartAll(Map<Integer, MainThread> members, String config) throws Exception {
+ for (Map.Entry<Integer, MainThread> entry : members.entrySet()) {
+ int clientPort = entry.getKey();
+ MainThread member = entry.getValue();
+
+ member.shutdown();
+ Assert.assertTrue(ClientBase.waitForServerDown("127.0.0.1:" + clientPort, CONNECTION_TIMEOUT));
+
+ FileWriter fileWriter = new FileWriter(member.getConfFile(), true);
+ fileWriter.write(config);
+ fileWriter.flush();
+ fileWriter.close();
+
+ member.start();
+
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPort, CONNECTION_TIMEOUT));
+ }
+ }
+
+ @Test
+ public void testHostnameVerificationWithInvalidHostname() throws Exception {
+ String badhostnameKeystorePath = tmpDir + "/badhost.jks";
+ X509Certificate badHostCert = buildEndEntityCert(defaultKeyPair, rootCertificate, rootKeyPair.getPrivate(),
+ "bleepbloop", null, null, null);
+ writeKeystore(badHostCert, defaultKeyPair, badhostnameKeystorePath);
+
+ testHostnameVerification(badhostnameKeystorePath, false);
+ }
+
+ @Test
+ public void testHostnameVerificationWithInvalidIPAddress() throws Exception {
+ String badhostnameKeystorePath = tmpDir + "/badhost.jks";
+ X509Certificate badHostCert = buildEndEntityCert(defaultKeyPair, rootCertificate, rootKeyPair.getPrivate(),
+ null, "140.211.11.105",null, null);
+ writeKeystore(badHostCert, defaultKeyPair, badhostnameKeystorePath);
+
+ testHostnameVerification(badhostnameKeystorePath, false);
+ }
+
+ @Test
+ public void testHostnameVerificationWithInvalidIpAddressAndInvalidHostname() throws Exception {
+ String badhostnameKeystorePath = tmpDir + "/badhost.jks";
+ X509Certificate badHostCert = buildEndEntityCert(defaultKeyPair, rootCertificate, rootKeyPair.getPrivate(),
+ "bleepbloop", "140.211.11.105", null, null);
+ writeKeystore(badHostCert, defaultKeyPair, badhostnameKeystorePath);
+
+ testHostnameVerification(badhostnameKeystorePath, false);
+ }
+
+ @Test
+ public void testHostnameVerificationWithInvalidIpAddressAndValidHostname() throws Exception {
+ String badhostnameKeystorePath = tmpDir + "/badhost.jks";
+ X509Certificate badHostCert = buildEndEntityCert(defaultKeyPair, rootCertificate, rootKeyPair.getPrivate(),
+ "localhost", "140.211.11.105", null, null);
+ writeKeystore(badHostCert, defaultKeyPair, badhostnameKeystorePath);
+
+ testHostnameVerification(badhostnameKeystorePath, true);
+ }
+
+ @Test
+ public void testHostnameVerificationWithValidIpAddressAndInvalidHostname() throws Exception {
+ String badhostnameKeystorePath = tmpDir + "/badhost.jks";
+ X509Certificate badHostCert = buildEndEntityCert(defaultKeyPair, rootCertificate, rootKeyPair.getPrivate(),
+ "bleepbloop", "127.0.0.1", null, null);
+ writeKeystore(badHostCert, defaultKeyPair, badhostnameKeystorePath);
+
+ testHostnameVerification(badhostnameKeystorePath, true);
+ }
+
+ /**
+ * @param keystorePath The keystore to use
+ * @param expectSuccess True for expecting the keystore to pass hostname verification, false for expecting failure
+ * @throws Exception
+ */
+ private void testHostnameVerification(String keystorePath, boolean expectSuccess) throws Exception {
+ System.setProperty(quorumX509Util.getSslHostnameVerificationEnabledProperty(), "false");
+
+ q1 = new MainThread(1, clientPortQp1, quorumConfiguration, SSL_QUORUM_ENABLED);
+ q2 = new MainThread(2, clientPortQp2, quorumConfiguration, SSL_QUORUM_ENABLED);
+
+ q1.start();
+ q2.start();
+
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp1, CONNECTION_TIMEOUT));
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp2, CONNECTION_TIMEOUT));
+
+ System.setProperty(quorumX509Util.getSslKeystoreLocationProperty(), keystorePath);
+
+ // This server should join successfully
+ q3 = new MainThread(3, clientPortQp3, quorumConfiguration, SSL_QUORUM_ENABLED);
+ q3.start();
+
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp3, CONNECTION_TIMEOUT));
+
+ q1.shutdown();
+ q2.shutdown();
+ q3.shutdown();
+
+ Assert.assertTrue(ClientBase.waitForServerDown("127.0.0.1:" + clientPortQp1, CONNECTION_TIMEOUT));
+ Assert.assertTrue(ClientBase.waitForServerDown("127.0.0.1:" + clientPortQp2, CONNECTION_TIMEOUT));
+ Assert.assertTrue(ClientBase.waitForServerDown("127.0.0.1:" + clientPortQp3, CONNECTION_TIMEOUT));
+
+ setSSLSystemProperties();
+ System.clearProperty(quorumX509Util.getSslHostnameVerificationEnabledProperty());
+
+ q1.start();
+ q2.start();
+
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp1, CONNECTION_TIMEOUT));
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp2, CONNECTION_TIMEOUT));
+
+ System.setProperty(quorumX509Util.getSslKeystoreLocationProperty(), keystorePath);
+ q3.start();
+
+ Assert.assertEquals(expectSuccess, ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp3,
+ CONNECTION_TIMEOUT));
+ }
+
+
+ @Test
+ public void testCertificateRevocationList() throws Exception {
+ q1 = new MainThread(1, clientPortQp1, quorumConfiguration, SSL_QUORUM_ENABLED);
+ q2 = new MainThread(2, clientPortQp2, quorumConfiguration, SSL_QUORUM_ENABLED);
+
+ q1.start();
+ q2.start();
+
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp1, CONNECTION_TIMEOUT));
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp2, CONNECTION_TIMEOUT));
+
+ String revokedInCRLKeystorePath = tmpDir + "/crl_revoked.jks";
+ String crlPath = tmpDir + "/crl.pem";
+ X509Certificate revokedInCRLCert = buildEndEntityCert(defaultKeyPair, rootCertificate, rootKeyPair.getPrivate(),
+ HOSTNAME, null, crlPath, null);
+ writeKeystore(revokedInCRLCert, defaultKeyPair, revokedInCRLKeystorePath);
+ buildCRL(revokedInCRLCert, crlPath);
+
+ System.setProperty(quorumX509Util.getSslKeystoreLocationProperty(), revokedInCRLKeystorePath);
+
+ // This server should join successfully
+ q3 = new MainThread(3, clientPortQp3, quorumConfiguration, SSL_QUORUM_ENABLED);
+ q3.start();
+
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp3, CONNECTION_TIMEOUT));
+
+
+ q1.shutdown();
+ q2.shutdown();
+ q3.shutdown();
+
+ Assert.assertTrue(ClientBase.waitForServerDown("127.0.0.1:" + clientPortQp1, CONNECTION_TIMEOUT));
+ Assert.assertTrue(ClientBase.waitForServerDown("127.0.0.1:" + clientPortQp2, CONNECTION_TIMEOUT));
+ Assert.assertTrue(ClientBase.waitForServerDown("127.0.0.1:" + clientPortQp3, CONNECTION_TIMEOUT));
+
+ setSSLSystemProperties();
+ System.setProperty(quorumX509Util.getSslCrlEnabledProperty(), "true");
+
+ X509Certificate validCertificate = buildEndEntityCert(defaultKeyPair, rootCertificate, rootKeyPair.getPrivate(),
+ HOSTNAME, null, crlPath, null);
+ writeKeystore(validCertificate, defaultKeyPair, validKeystorePath);
+
+ q1.start();
+ q2.start();
+
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp1, CONNECTION_TIMEOUT));
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp2, CONNECTION_TIMEOUT));
+
+ System.setProperty(quorumX509Util.getSslKeystoreLocationProperty(), revokedInCRLKeystorePath);
+ q3.start();
+
+ Assert.assertFalse(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp3, CONNECTION_TIMEOUT));
+ }
+
+ @Test
+ public void testOCSP() throws Exception {
+ Integer ocspPort = PortAssignment.unique();
+
+ q1 = new MainThread(1, clientPortQp1, quorumConfiguration, SSL_QUORUM_ENABLED);
+ q2 = new MainThread(2, clientPortQp2, quorumConfiguration, SSL_QUORUM_ENABLED);
+
+ q1.start();
+ q2.start();
+
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp1, CONNECTION_TIMEOUT));
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp2, CONNECTION_TIMEOUT));
+
+ String revokedInOCSPKeystorePath = tmpDir + "/ocsp_revoked.jks";
+ X509Certificate revokedInOCSPCert = buildEndEntityCert(defaultKeyPair, rootCertificate, rootKeyPair.getPrivate(),
+ HOSTNAME, null,null, ocspPort);
+ writeKeystore(revokedInOCSPCert, defaultKeyPair, revokedInOCSPKeystorePath);
+
+ HttpServer ocspServer = HttpServer.create(new InetSocketAddress(ocspPort), 0);
+ try {
+ ocspServer.createContext("/", new OCSPHandler(revokedInOCSPCert));
+ ocspServer.start();
+
+ System.setProperty(quorumX509Util.getSslKeystoreLocationProperty(), revokedInOCSPKeystorePath);
+
+ // This server should join successfully
+ q3 = new MainThread(3, clientPortQp3, quorumConfiguration, SSL_QUORUM_ENABLED);
+ q3.start();
+
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp3, CONNECTION_TIMEOUT));
+
+ q1.shutdown();
+ q2.shutdown();
+ q3.shutdown();
+
+ Assert.assertTrue(ClientBase.waitForServerDown("127.0.0.1:" + clientPortQp1, CONNECTION_TIMEOUT));
+ Assert.assertTrue(ClientBase.waitForServerDown("127.0.0.1:" + clientPortQp2, CONNECTION_TIMEOUT));
+ Assert.assertTrue(ClientBase.waitForServerDown("127.0.0.1:" + clientPortQp3, CONNECTION_TIMEOUT));
+
+ setSSLSystemProperties();
+ System.setProperty(quorumX509Util.getSslOcspEnabledProperty(), "true");
+
+ X509Certificate validCertificate = buildEndEntityCert(defaultKeyPair, rootCertificate,
+ rootKeyPair.getPrivate(),
+ HOSTNAME, null,null, ocspPort);
+ writeKeystore(validCertificate, defaultKeyPair, validKeystorePath);
+
+ q1.start();
+ q2.start();
+
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp1, CONNECTION_TIMEOUT));
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp2, CONNECTION_TIMEOUT));
+
+ System.setProperty(quorumX509Util.getSslKeystoreLocationProperty(), revokedInOCSPKeystorePath);
+ q3.start();
+
+ Assert.assertFalse(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp3, CONNECTION_TIMEOUT));
+ } finally {
+ ocspServer.stop(0);
+ }
+ }
+
+ @Test
+ public void testCipherSuites() throws Exception {
+ // Get default cipher suites from JDK
+ SSLServerSocketFactory ssf = (SSLServerSocketFactory)SSLServerSocketFactory.getDefault();
+ List<String> defaultCiphers = new ArrayList<String>();
+ for (String cipher : ssf.getDefaultCipherSuites()) {
+ if (!cipher.matches(".*EMPTY.*") && cipher.startsWith("TLS") && cipher.contains("RSA")) {
+ defaultCiphers.add(cipher);
+ }
+ }
+
+ if (defaultCiphers.size() < 2) {
+ fail("JDK has to support at least 2 valid (RSA) cipher suites for this test to run");
+ }
+
+ // Use them all except one to build the ensemble
+ String suitesOfEnsemble = String.join(",", defaultCiphers.subList(1, defaultCiphers.size()));
+ System.setProperty(quorumX509Util.getCipherSuitesProperty(), suitesOfEnsemble);
+
+ q1 = new MainThread(1, clientPortQp1, quorumConfiguration, SSL_QUORUM_ENABLED);
+ q2 = new MainThread(2, clientPortQp2, quorumConfiguration, SSL_QUORUM_ENABLED);
+
+ q1.start();
+ q2.start();
+
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp1, CONNECTION_TIMEOUT));
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp2, CONNECTION_TIMEOUT));
+
+ // Use the odd one out for the client
+ String suiteOfClient = defaultCiphers.get(0);
+ System.setProperty(quorumX509Util.getCipherSuitesProperty(), suiteOfClient);
+
+ // This server should fail to join the quorum as it is not using one of the supported suites from the other
+ // quorum members
+ q3 = new MainThread(3, clientPortQp3, quorumConfiguration, SSL_QUORUM_ENABLED);
+ q3.start();
+
+ Assert.assertFalse(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp3, CONNECTION_TIMEOUT));
+ }
+
+ @Test
+ public void testProtocolVersion() throws Exception {
+ System.setProperty(quorumX509Util.getSslProtocolProperty(), "TLSv1.2");
+
+ q1 = new MainThread(1, clientPortQp1, quorumConfiguration, SSL_QUORUM_ENABLED);
+ q2 = new MainThread(2, clientPortQp2, quorumConfiguration, SSL_QUORUM_ENABLED);
+
+ q1.start();
+ q2.start();
+
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp1, CONNECTION_TIMEOUT));
+ Assert.assertTrue(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp2, CONNECTION_TIMEOUT));
+
+ System.setProperty(quorumX509Util.getSslProtocolProperty(), "TLSv1.1");
+
+ // This server should fail to join the quorum as it is not using TLSv1.2
+ q3 = new MainThread(3, clientPortQp3, quorumConfiguration, SSL_QUORUM_ENABLED);
+ q3.start();
+
+ Assert.assertFalse(ClientBase.waitForServerUp("127.0.0.1:" + clientPortQp3, CONNECTION_TIMEOUT));
+ }
+}
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/0e3b82bd/src/java/test/org/apache/zookeeper/server/quorum/RaceConditionTest.java
----------------------------------------------------------------------
diff --git a/src/java/test/org/apache/zookeeper/server/quorum/RaceConditionTest.java b/src/java/test/org/apache/zookeeper/server/quorum/RaceConditionTest.java
index e96d273..ea2a4d3 100644
--- a/src/java/test/org/apache/zookeeper/server/quorum/RaceConditionTest.java
+++ b/src/java/test/org/apache/zookeeper/server/quorum/RaceConditionTest.java
@@ -27,6 +27,7 @@ import java.nio.ByteBuffer;
import org.apache.zookeeper.PortAssignment;
import org.apache.zookeeper.ZooDefs;
+import org.apache.zookeeper.common.X509Exception;
import org.apache.zookeeper.server.FinalRequestProcessor;
import org.apache.zookeeper.server.PrepRequestProcessor;
import org.apache.zookeeper.server.Request;
@@ -182,7 +183,7 @@ public class RaceConditionTest extends QuorumPeerTestBase {
}
@Override
- protected Leader makeLeader(FileTxnSnapLog logFactory) throws IOException {
+ protected Leader makeLeader(FileTxnSnapLog logFactory) throws IOException, X509Exception {
LeaderZooKeeperServer zk = new LeaderZooKeeperServer(logFactory, this, this.getZkDb()) {
@Override
protected void setupRequestProcessors() {
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/0e3b82bd/src/java/test/org/apache/zookeeper/server/quorum/UnifiedServerSocketTest.java
----------------------------------------------------------------------
diff --git a/src/java/test/org/apache/zookeeper/server/quorum/UnifiedServerSocketTest.java b/src/java/test/org/apache/zookeeper/server/quorum/UnifiedServerSocketTest.java
new file mode 100644
index 0000000..09a5d41
--- /dev/null
+++ b/src/java/test/org/apache/zookeeper/server/quorum/UnifiedServerSocketTest.java
@@ -0,0 +1,172 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.zookeeper.server.quorum;
+
+import org.apache.zookeeper.PortAssignment;
+import org.apache.zookeeper.client.ZKClientConfig;
+import org.apache.zookeeper.common.ClientX509Util;
+import org.apache.zookeeper.common.Time;
+import org.apache.zookeeper.common.X509Util;
+import org.apache.zookeeper.server.ServerCnxnFactory;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import javax.net.ssl.HandshakeCompletedEvent;
+import javax.net.ssl.HandshakeCompletedListener;
+import javax.net.ssl.SSLSocket;
+import java.io.IOException;
+import java.net.ConnectException;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertThat;
+
+public class UnifiedServerSocketTest {
+
+ private static final int MAX_RETRIES = 5;
+ private static final int TIMEOUT = 1000;
+
+ private X509Util x509Util;
+ private int port;
+ private volatile boolean handshakeCompleted;
+
+ @Before
+ public void setUp() throws Exception {
+ handshakeCompleted = false;
+
+ port = PortAssignment.unique();
+
+ String testDataPath = System.getProperty("test.data.dir", "build/test/data");
+ System.setProperty(ServerCnxnFactory.ZOOKEEPER_SERVER_CNXN_FACTORY, "org.apache.zookeeper.server.NettyServerCnxnFactory");
+ System.setProperty(ZKClientConfig.ZOOKEEPER_CLIENT_CNXN_SOCKET, "org.apache.zookeeper.ClientCnxnSocketNetty");
+ System.setProperty(ZKClientConfig.SECURE_CLIENT, "true");
+
+ x509Util = new ClientX509Util();
+
+ System.setProperty(x509Util.getSslKeystoreLocationProperty(), testDataPath + "/ssl/testKeyStore.jks");
+ System.setProperty(x509Util.getSslKeystorePasswdProperty(), "testpass");
+ System.setProperty(x509Util.getSslTruststoreLocationProperty(), testDataPath + "/ssl/testTrustStore.jks");
+ System.setProperty(x509Util.getSslTruststorePasswdProperty(), "testpass");
+ System.setProperty(x509Util.getSslHostnameVerificationEnabledProperty(), "false");
+ }
+
+ @Test
+ public void testConnectWithSSL() throws Exception {
+ class ServerThread extends Thread {
+ public void run() {
+ try {
+ Socket unifiedSocket = new UnifiedServerSocket(x509Util, port).accept();
+ ((SSLSocket)unifiedSocket).getSession(); // block until handshake completes
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ ServerThread serverThread = new ServerThread();
+ serverThread.start();
+
+ SSLSocket sslSocket = null;
+ int retries = 0;
+ while (retries < MAX_RETRIES) {
+ try {
+ sslSocket = x509Util.createSSLSocket();
+ sslSocket.setSoTimeout(TIMEOUT);
+ sslSocket.connect(new InetSocketAddress(port), TIMEOUT);
+ break;
+ } catch (ConnectException connectException) {
+ connectException.printStackTrace();
+ Thread.sleep(TIMEOUT);
+ }
+ retries++;
+ }
+
+ sslSocket.addHandshakeCompletedListener(new HandshakeCompletedListener() {
+ @Override
+ public void handshakeCompleted(HandshakeCompletedEvent handshakeCompletedEvent) {
+ completeHandshake();
+ }
+ });
+ sslSocket.startHandshake();
+
+ serverThread.join(TIMEOUT);
+
+ long start = Time.currentElapsedTime();
+ while (Time.currentElapsedTime() < start + TIMEOUT) {
+ if (handshakeCompleted) {
+ return;
+ }
+ }
+
+ Assert.fail("failed to complete handshake");
+ }
+
+ private void completeHandshake() {
+ handshakeCompleted = true;
+ }
+
+ @Test
+ public void testConnectWithoutSSL() throws Exception {
+ final byte[] testData = "hello there".getBytes();
+ final String[] dataReadFromClient = {null};
+
+ class ServerThread extends Thread {
+ public void run() {
+ try {
+ Socket unifiedSocket = new UnifiedServerSocket(x509Util, port).accept();
+ unifiedSocket.getOutputStream().write(testData);
+ unifiedSocket.getOutputStream().flush();
+ byte[] inputbuff = new byte[5];
+ unifiedSocket.getInputStream().read(inputbuff, 0, 5);
+ dataReadFromClient[0] = new String(inputbuff);
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ ServerThread serverThread = new ServerThread();
+ serverThread.start();
+
+ Socket socket = null;
+ int retries = 0;
+ while (retries < MAX_RETRIES) {
+ try {
+ socket = new Socket();
+ socket.setSoTimeout(TIMEOUT);
+ socket.connect(new InetSocketAddress(port), TIMEOUT);
+ break;
+ } catch (ConnectException connectException) {
+ connectException.printStackTrace();
+ Thread.sleep(TIMEOUT);
+ }
+ retries++;
+ }
+
+ socket.getOutputStream().write("hellobello".getBytes());
+ socket.getOutputStream().flush();
+
+ byte[] readBytes = new byte[testData.length];
+ socket.getInputStream().read(readBytes, 0, testData.length);
+
+ serverThread.join(TIMEOUT);
+
+ Assert.assertArrayEquals(testData, readBytes);
+ assertThat("Data sent by the client is invalid", dataReadFromClient[0], equalTo("hello"));
+ }
+}
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/0e3b82bd/src/java/test/org/apache/zookeeper/server/quorum/ZabUtils.java
----------------------------------------------------------------------
diff --git a/src/java/test/org/apache/zookeeper/server/quorum/ZabUtils.java b/src/java/test/org/apache/zookeeper/server/quorum/ZabUtils.java
index 4aae292..63cbd02 100644
--- a/src/java/test/org/apache/zookeeper/server/quorum/ZabUtils.java
+++ b/src/java/test/org/apache/zookeeper/server/quorum/ZabUtils.java
@@ -19,6 +19,7 @@
package org.apache.zookeeper.server.quorum;
import org.apache.zookeeper.PortAssignment;
+import org.apache.zookeeper.common.X509Exception;
import org.apache.zookeeper.server.ServerCnxn;
import org.apache.zookeeper.server.ServerCnxnFactory;
import org.apache.zookeeper.server.ZKDatabase;
@@ -74,13 +75,13 @@ public class ZabUtils {
}
public static Leader createLeader(File tmpDir, QuorumPeer peer)
- throws IOException, NoSuchFieldException, IllegalAccessException {
+ throws IOException, NoSuchFieldException, IllegalAccessException, X509Exception {
LeaderZooKeeperServer zk = prepareLeader(tmpDir, peer);
return new Leader(peer, zk);
}
public static Leader createMockLeader(File tmpDir, QuorumPeer peer)
- throws IOException, NoSuchFieldException, IllegalAccessException {
+ throws IOException, NoSuchFieldException, IllegalAccessException, X509Exception {
LeaderZooKeeperServer zk = prepareLeader(tmpDir, peer);
return new MockLeader(peer, zk);
}
@@ -146,7 +147,7 @@ public class ZabUtils {
public static final class MockLeader extends Leader {
MockLeader(QuorumPeer qp, LeaderZooKeeperServer zk)
- throws IOException {
+ throws IOException, X509Exception {
super(qp, zk);
}