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/16 14:22:14 UTC
[3/3] zookeeper git commit: ZOOKEEPER-236: SSL Support for Atomic
Broadcast protocol (master)
ZOOKEEPER-236: SSL Support for Atomic Broadcast protocol (master)
Cherry-picked from branch-3.5.
Author: Andor Molnar <an...@apache.org>
Author: Abraham Fine <af...@apache.org>
Reviewers: hanm@apache.org, breed@apache.org
Closes #655 from anmolnar/ZOOKEEPER-236_master and squashes the following commits:
8c3aa11e [Andor Molnar] ZOOKEEPER-3165: Java 9: X509UtilTest.testCreateSSLContextWithoutTrustStorePassword fails
eb272749 [Abraham Fine] ZOOKEEPER-236: SSL Support for Atomic Broadcast protocol
Project: http://git-wip-us.apache.org/repos/asf/zookeeper/repo
Commit: http://git-wip-us.apache.org/repos/asf/zookeeper/commit/7b679bc9
Tree: http://git-wip-us.apache.org/repos/asf/zookeeper/tree/7b679bc9
Diff: http://git-wip-us.apache.org/repos/asf/zookeeper/diff/7b679bc9
Branch: refs/heads/master
Commit: 7b679bc9dd98f06ee10bbb0978cfee5dab7b74dc
Parents: e92fdfe
Author: Andor Molnar <an...@apache.org>
Authored: Tue Oct 16 16:22:07 2018 +0200
Committer: Andor Molnar <an...@apache.org>
Committed: Tue Oct 16 16:22:07 2018 +0200
----------------------------------------------------------------------
build.xml | 4 +-
ivy.xml | 3 +
.../zookeeper/client/FourLetterWordMain.java | 4 +-
.../apache/zookeeper/ClientCnxnSocketNetty.java | 4 +-
.../apache/zookeeper/ZKHostnameVerifier.java | 349 +++++++++
.../org/apache/zookeeper/ZKTrustManager.java | 150 ++++
.../apache/zookeeper/common/ClientX509Util.java | 38 +
.../apache/zookeeper/common/QuorumX509Util.java | 32 +
.../org/apache/zookeeper/common/X509Util.java | 325 ++++++--
.../org/apache/zookeeper/common/ZKConfig.java | 65 +-
.../apache/zookeeper/common/X509UtilTest.java | 264 +++++++
.../zookeeper/common/ZKTrustManagerTest.java | 248 ++++++
.../apache/zookeeper/test/ClientSSLTest.java | 132 ++++
.../org/apache/zookeeper/test/SSLAuthTest.java | 40 +-
.../java/org/apache/zookeeper/test/SSLTest.java | 130 ----
.../org/apache/zookeeper/test/SSLTest.java.orig | 130 ++++
.../server/NettyServerCnxnFactory.java | 53 +-
.../server/auth/X509AuthenticationProvider.java | 38 +-
.../apache/zookeeper/server/quorum/Leader.java | 28 +-
.../apache/zookeeper/server/quorum/Learner.java | 36 +-
.../server/quorum/PrependableSocket.java | 49 ++
.../zookeeper/server/quorum/QuorumBean.java | 19 +-
.../server/quorum/QuorumCnxManager.java | 83 +-
.../zookeeper/server/quorum/QuorumMXBean.java | 10 +
.../zookeeper/server/quorum/QuorumPeer.java | 24 +-
.../server/quorum/QuorumPeerConfig.java | 21 +-
.../zookeeper/server/quorum/QuorumPeerMain.java | 2 +
.../server/quorum/UnifiedServerSocket.java | 79 ++
.../zookeeper/server/quorum/LeaderBeanTest.java | 3 +-
.../zookeeper/server/quorum/QuorumBeanTest.java | 75 ++
.../server/quorum/QuorumPeerConfigTest.java | 4 +-
.../server/quorum/QuorumPeerMainTest.java | 3 +-
.../zookeeper/server/quorum/QuorumSSLTest.java | 771 +++++++++++++++++++
.../server/quorum/RaceConditionTest.java | 3 +-
.../server/quorum/UnifiedServerSocketTest.java | 172 +++++
.../zookeeper/server/quorum/ZabUtils.java | 7 +-
36 files changed, 3048 insertions(+), 350 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/7b679bc9/build.xml
----------------------------------------------------------------------
diff --git a/build.xml b/build.xml
index 0f78a40..77c50ca 100644
--- a/build.xml
+++ b/build.xml
@@ -40,9 +40,11 @@ xmlns:cs="antlib:com.puppycrawl.tools.checkstyle.ant">
<property name="junit.version" value="4.12"/>
<property name="mockito.version" value="1.8.5"/>
- <property name="checkstyle.version" value="6.13"/>
+ <property name="checkstyle.version" value="7.1.2"/>
<property name="commons-collections.version" value="3.2.2"/>
+ <property name="bouncycastle.version" value="1.56"/>
+
<property name="jdiff.version" value="1.0.9"/>
<property name="xerces.version" value="1.4.4"/>
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/7b679bc9/ivy.xml
----------------------------------------------------------------------
diff --git a/ivy.xml b/ivy.xml
index fb09ed3..8692640 100644
--- a/ivy.xml
+++ b/ivy.xml
@@ -78,6 +78,9 @@
<dependency org="commons-collections" name="commons-collections"
rev="${commons-collections.version}" conf="test->default"/>
+ <dependency org="org.bouncycastle" name="bcprov-jdk15on" rev="${bouncycastle.version}" conf="test->default"/>
+ <dependency org="org.bouncycastle" name="bcpkix-jdk15on" rev="${bouncycastle.version}" conf="test->default"/>
+
<dependency org="jdiff" name="jdiff" rev="${jdiff.version}"
conf="jdiff->default"/>
<dependency org="xerces" name="xerces" rev="${xerces.version}"
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/7b679bc9/zookeeper-client/zookeeper-client-java/src/main/java/org/apache/zookeeper/client/FourLetterWordMain.java
----------------------------------------------------------------------
diff --git a/zookeeper-client/zookeeper-client-java/src/main/java/org/apache/zookeeper/client/FourLetterWordMain.java b/zookeeper-client/zookeeper-client-java/src/main/java/org/apache/zookeeper/client/FourLetterWordMain.java
index b396c15..41f5e9d 100644
--- a/zookeeper-client/zookeeper-client-java/src/main/java/org/apache/zookeeper/client/FourLetterWordMain.java
+++ b/zookeeper-client/zookeeper-client-java/src/main/java/org/apache/zookeeper/client/FourLetterWordMain.java
@@ -31,9 +31,9 @@ import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
+import org.apache.zookeeper.common.ClientX509Util;
import org.apache.yetus.audience.InterfaceAudience;
import org.apache.zookeeper.common.X509Exception.SSLContextException;
-import org.apache.zookeeper.common.X509Util;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -90,7 +90,7 @@ public class FourLetterWordMain {
new InetSocketAddress(InetAddress.getByName(null), port);
if (secure) {
LOG.info("using secure socket");
- SSLContext sslContext = X509Util.createSSLContext();
+ SSLContext sslContext = new ClientX509Util().getDefaultSSLContext();
SSLSocketFactory socketFactory = sslContext.getSocketFactory();
SSLSocket sslSock = (SSLSocket) socketFactory.createSocket();
sslSock.connect(hostaddress, timeout);
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/7b679bc9/zookeeper-common/src/main/java/org/apache/zookeeper/ClientCnxnSocketNetty.java
----------------------------------------------------------------------
diff --git a/zookeeper-common/src/main/java/org/apache/zookeeper/ClientCnxnSocketNetty.java b/zookeeper-common/src/main/java/org/apache/zookeeper/ClientCnxnSocketNetty.java
index ec789cb..34c3db3 100755
--- a/zookeeper-common/src/main/java/org/apache/zookeeper/ClientCnxnSocketNetty.java
+++ b/zookeeper-common/src/main/java/org/apache/zookeeper/ClientCnxnSocketNetty.java
@@ -21,7 +21,7 @@ package org.apache.zookeeper;
import org.apache.zookeeper.ClientCnxn.EndOfStreamException;
import org.apache.zookeeper.ClientCnxn.Packet;
import org.apache.zookeeper.client.ZKClientConfig;
-import org.apache.zookeeper.common.X509Util;
+import org.apache.zookeeper.common.ClientX509Util;
import org.jboss.netty.bootstrap.ClientBootstrap;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
@@ -370,7 +370,7 @@ public class ClientCnxnSocketNetty extends ClientCnxnSocket {
// Basically we only need to create it once.
private synchronized void initSSL(ChannelPipeline pipeline) throws SSLContextException {
if (sslContext == null || sslEngine == null) {
- sslContext = X509Util.createSSLContext(clientConfig);
+ sslContext = new ClientX509Util().createSSLContext(clientConfig);
sslEngine = sslContext.createSSLEngine(host,port);
sslEngine.setUseClientMode(true);
}
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/7b679bc9/zookeeper-common/src/main/java/org/apache/zookeeper/ZKHostnameVerifier.java
----------------------------------------------------------------------
diff --git a/zookeeper-common/src/main/java/org/apache/zookeeper/ZKHostnameVerifier.java b/zookeeper-common/src/main/java/org/apache/zookeeper/ZKHostnameVerifier.java
new file mode 100644
index 0000000..740fef0
--- /dev/null
+++ b/zookeeper-common/src/main/java/org/apache/zookeeper/ZKHostnameVerifier.java
@@ -0,0 +1,349 @@
+/**
+ * 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.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.naming.InvalidNameException;
+import javax.naming.NamingException;
+import javax.naming.directory.Attribute;
+import javax.naming.directory.Attributes;
+import javax.naming.ldap.LdapName;
+import javax.naming.ldap.Rdn;
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLException;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLSession;
+import javax.security.auth.x500.X500Principal;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateParsingException;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.regex.Pattern;
+
+/**
+ * Note: copied from Apache httpclient with some modifications. We want host verification, but depending
+ * on the httpclient jar caused unexplained performance regressions (even when the code was not used).
+ */
+final class ZKHostnameVerifier implements HostnameVerifier {
+
+ /**
+ * Note: copied from Apache httpclient with some minor modifications. We want host verification, but depending
+ * on the httpclient jar caused unexplained performance regressions (even when the code was not used).
+ */
+ private static final class SubjectName {
+ static final int DNS = 2;
+ static final int IP = 7;
+
+ private final String value;
+ private final int type;
+
+ static SubjectName IP(final String value) {
+ return new SubjectName(value, IP);
+ }
+
+ static SubjectName DNS(final String value) {
+ return new SubjectName(value, DNS);
+ }
+
+ SubjectName(final String value, final int type) {
+ if (type != DNS && type != IP) {
+ throw new IllegalArgumentException("Invalid type: " + type);
+ }
+ this.value = Objects.requireNonNull(value);
+ this.type = type;
+ }
+
+ public int getType() {
+ return type;
+ }
+
+ public String getValue() {
+ return value;
+ }
+
+ @Override
+ public String toString() {
+ return value;
+ }
+ }
+
+ /**
+ * Note: copied from Apache httpclient. We want host verification, but depending on the
+ * httpclient jar caused unexplained performance regressions (even when the code was not used).
+ */
+ private static class InetAddressUtils {
+ private InetAddressUtils() {}
+
+ private static final Pattern IPV4_PATTERN = Pattern.compile(
+ "^(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)(\\.(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)){3}$");
+
+ private static final Pattern IPV6_STD_PATTERN = Pattern.compile(
+ "^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$");
+
+ private static final Pattern IPV6_HEX_COMPRESSED_PATTERN = Pattern.compile(
+ "^((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?)::((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?)$");
+
+ static boolean isIPv4Address(final String input) {
+ return IPV4_PATTERN.matcher(input).matches();
+ }
+
+ static boolean isIPv6StdAddress(final String input) {
+ return IPV6_STD_PATTERN.matcher(input).matches();
+ }
+
+ static boolean isIPv6HexCompressedAddress(final String input) {
+ return IPV6_HEX_COMPRESSED_PATTERN.matcher(input).matches();
+ }
+
+ static boolean isIPv6Address(final String input) {
+ return isIPv6StdAddress(input) || isIPv6HexCompressedAddress(input);
+ }
+ }
+
+ enum HostNameType {
+
+ IPv4(7), IPv6(7), DNS(2);
+
+ final int subjectType;
+
+ HostNameType(final int subjectType) {
+ this.subjectType = subjectType;
+ }
+
+ }
+
+ private final Logger log = LoggerFactory.getLogger(ZKHostnameVerifier.class);
+
+ @Override
+ public boolean verify(final String host, final SSLSession session) {
+ try {
+ final Certificate[] certs = session.getPeerCertificates();
+ final X509Certificate x509 = (X509Certificate) certs[0];
+ verify(host, x509);
+ return true;
+ } catch (final SSLException ex) {
+ if (log.isDebugEnabled()) {
+ log.debug(ex.getMessage(), ex);
+ }
+ return false;
+ }
+ }
+
+ void verify(final String host, final X509Certificate cert) throws SSLException {
+ final HostNameType hostType = determineHostFormat(host);
+ final List<SubjectName> subjectAlts = getSubjectAltNames(cert);
+ if (subjectAlts != null && !subjectAlts.isEmpty()) {
+ switch (hostType) {
+ case IPv4:
+ matchIPAddress(host, subjectAlts);
+ break;
+ case IPv6:
+ matchIPv6Address(host, subjectAlts);
+ break;
+ default:
+ matchDNSName(host, subjectAlts);
+ }
+ } else {
+ // CN matching has been deprecated by rfc2818 and can be used
+ // as fallback only when no subjectAlts are available
+ final X500Principal subjectPrincipal = cert.getSubjectX500Principal();
+ final String cn = extractCN(subjectPrincipal.getName(X500Principal.RFC2253));
+ if (cn == null) {
+ throw new SSLException("Certificate subject for <" + host + "> doesn't contain " +
+ "a common name and does not have alternative names");
+ }
+ matchCN(host, cn);
+ }
+ }
+
+ private static void matchIPAddress(final String host, final List<SubjectName> subjectAlts) throws SSLException {
+ for (int i = 0; i < subjectAlts.size(); i++) {
+ final SubjectName subjectAlt = subjectAlts.get(i);
+ if (subjectAlt.getType() == SubjectName.IP) {
+ if (host.equals(subjectAlt.getValue())) {
+ return;
+ }
+ }
+ }
+ throw new SSLPeerUnverifiedException("Certificate for <" + host + "> doesn't match any " +
+ "of the subject alternative names: " + subjectAlts);
+ }
+
+ private static void matchIPv6Address(final String host, final List<SubjectName> subjectAlts) throws SSLException {
+ final String normalisedHost = normaliseAddress(host);
+ for (int i = 0; i < subjectAlts.size(); i++) {
+ final SubjectName subjectAlt = subjectAlts.get(i);
+ if (subjectAlt.getType() == SubjectName.IP) {
+ final String normalizedSubjectAlt = normaliseAddress(subjectAlt.getValue());
+ if (normalisedHost.equals(normalizedSubjectAlt)) {
+ return;
+ }
+ }
+ }
+ throw new SSLPeerUnverifiedException("Certificate for <" + host + "> doesn't match any " +
+ "of the subject alternative names: " + subjectAlts);
+ }
+
+ private static void matchDNSName(final String host, final List<SubjectName> subjectAlts) throws SSLException {
+ final String normalizedHost = host.toLowerCase(Locale.ROOT);
+ for (int i = 0; i < subjectAlts.size(); i++) {
+ final SubjectName subjectAlt = subjectAlts.get(i);
+ if (subjectAlt.getType() == SubjectName.DNS) {
+ final String normalizedSubjectAlt = subjectAlt.getValue().toLowerCase(Locale.ROOT);
+ if (matchIdentityStrict(normalizedHost, normalizedSubjectAlt)) {
+ return;
+ }
+ }
+ }
+ throw new SSLPeerUnverifiedException("Certificate for <" + host + "> doesn't match any " +
+ "of the subject alternative names: " + subjectAlts);
+ }
+
+ private static void matchCN(final String host, final String cn) throws SSLException {
+ final String normalizedHost = host.toLowerCase(Locale.ROOT);
+ final String normalizedCn = cn.toLowerCase(Locale.ROOT);
+ if (!matchIdentityStrict(normalizedHost, normalizedCn)) {
+ throw new SSLPeerUnverifiedException("Certificate for <" + host + "> doesn't match " +
+ "common name of the certificate subject: " + cn);
+ }
+ }
+
+ private static boolean matchIdentity(final String host, final String identity,
+ final boolean strict) {
+ // RFC 2818, 3.1. Server Identity
+ // "...Names may contain the wildcard
+ // character * which is considered to match any single domain name
+ // component or component fragment..."
+ // Based on this statement presuming only singular wildcard is legal
+ final int asteriskIdx = identity.indexOf('*');
+ if (asteriskIdx != -1) {
+ final String prefix = identity.substring(0, asteriskIdx);
+ final String suffix = identity.substring(asteriskIdx + 1);
+ if (!prefix.isEmpty() && !host.startsWith(prefix)) {
+ return false;
+ }
+ if (!suffix.isEmpty() && !host.endsWith(suffix)) {
+ return false;
+ }
+ // Additional sanity checks on content selected by wildcard can be done here
+ if (strict) {
+ final String remainder = host.substring(
+ prefix.length(), host.length() - suffix.length());
+ if (remainder.contains(".")) {
+ return false;
+ }
+ }
+ return true;
+ }
+ return host.equalsIgnoreCase(identity);
+ }
+
+ private static boolean matchIdentityStrict(final String host, final String identity) {
+ return matchIdentity(host, identity, true);
+ }
+
+ private static String extractCN(final String subjectPrincipal) throws SSLException {
+ if (subjectPrincipal == null) {
+ return null;
+ }
+ try {
+ final LdapName subjectDN = new LdapName(subjectPrincipal);
+ final List<Rdn> rdns = subjectDN.getRdns();
+ for (int i = rdns.size() - 1; i >= 0; i--) {
+ final Rdn rds = rdns.get(i);
+ final Attributes attributes = rds.toAttributes();
+ final Attribute cn = attributes.get("cn");
+ if (cn != null) {
+ try {
+ final Object value = cn.get();
+ if (value != null) {
+ return value.toString();
+ }
+ } catch (final NoSuchElementException ignore) {
+ // ignore exception
+ } catch (final NamingException ignore) {
+ // ignore exception
+ }
+ }
+ }
+ return null;
+ } catch (final InvalidNameException e) {
+ throw new SSLException(subjectPrincipal + " is not a valid X500 distinguished name");
+ }
+ }
+
+ private static HostNameType determineHostFormat(final String host) {
+ if (InetAddressUtils.isIPv4Address(host)) {
+ return HostNameType.IPv4;
+ }
+ String s = host;
+ if (s.startsWith("[") && s.endsWith("]")) {
+ s = host.substring(1, host.length() - 1);
+ }
+ if (InetAddressUtils.isIPv6Address(s)) {
+ return HostNameType.IPv6;
+ }
+ return HostNameType.DNS;
+ }
+
+ private static List<SubjectName> getSubjectAltNames(final X509Certificate cert) {
+ try {
+ final Collection<List<?>> entries = cert.getSubjectAlternativeNames();
+ if (entries == null) {
+ return Collections.emptyList();
+ }
+ final List<SubjectName> result = new ArrayList<SubjectName>();
+ for (List<?> entry: entries) {
+ final Integer type = entry.size() >= 2 ? (Integer) entry.get(0) : null;
+ if (type != null) {
+ final String s = (String) entry.get(1);
+ result.add(new SubjectName(s, type));
+ }
+ }
+ return result;
+ } catch (final CertificateParsingException ignore) {
+ return Collections.emptyList();
+ }
+ }
+
+ /*
+ * Normalize IPv6 or DNS name.
+ */
+ private static String normaliseAddress(final String hostname) {
+ if (hostname == null) {
+ return hostname;
+ }
+ try {
+ final InetAddress inetAddress = InetAddress.getByName(hostname);
+ return inetAddress.getHostAddress();
+ } catch (final UnknownHostException unexpected) { // Should not happen, because we check for IPv6 address above
+ return hostname;
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/7b679bc9/zookeeper-common/src/main/java/org/apache/zookeeper/ZKTrustManager.java
----------------------------------------------------------------------
diff --git a/zookeeper-common/src/main/java/org/apache/zookeeper/ZKTrustManager.java b/zookeeper-common/src/main/java/org/apache/zookeeper/ZKTrustManager.java
new file mode 100644
index 0000000..73006d0
--- /dev/null
+++ b/zookeeper-common/src/main/java/org/apache/zookeeper/ZKTrustManager.java
@@ -0,0 +1,150 @@
+/**
+ * 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.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.SSLException;
+import javax.net.ssl.X509ExtendedTrustManager;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.UnknownHostException;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+
+/**
+ * A custom TrustManager that supports hostname verification via org.apache.http.conn.ssl.DefaultHostnameVerifier.
+ *
+ * We attempt to perform verification using just the IP address first and if that fails will attempt to perform a
+ * reverse DNS lookup and verify using the hostname.
+ */
+public class ZKTrustManager extends X509ExtendedTrustManager {
+
+ private static final Logger LOG = LoggerFactory.getLogger(ZKTrustManager.class);
+
+ private X509ExtendedTrustManager x509ExtendedTrustManager;
+ private boolean serverHostnameVerificationEnabled;
+ private boolean clientHostnameVerificationEnabled;
+
+ private ZKHostnameVerifier hostnameVerifier;
+
+ /**
+ * Instantiate a new ZKTrustManager.
+ *
+ * @param x509ExtendedTrustManager The trustmanager to use for checkClientTrusted/checkServerTrusted logic
+ * @param serverHostnameVerificationEnabled If true, this TrustManager should verify hostnames of servers that this
+ * instance connects to.
+ * @param clientHostnameVerificationEnabled If true, the hostname of a client connecting to this machine will be
+ * verified.
+ */
+ ZKTrustManager(X509ExtendedTrustManager x509ExtendedTrustManager, boolean serverHostnameVerificationEnabled,
+ boolean clientHostnameVerificationEnabled) {
+ this.x509ExtendedTrustManager = x509ExtendedTrustManager;
+ this.serverHostnameVerificationEnabled = serverHostnameVerificationEnabled;
+ this.clientHostnameVerificationEnabled = clientHostnameVerificationEnabled;
+ hostnameVerifier = new ZKHostnameVerifier();
+ }
+
+ @Override
+ public X509Certificate[] getAcceptedIssuers() {
+ return x509ExtendedTrustManager.getAcceptedIssuers();
+ }
+
+ @Override
+ public void checkClientTrusted(X509Certificate[] chain, String authType, Socket socket) throws CertificateException {
+ x509ExtendedTrustManager.checkClientTrusted(chain, authType, socket);
+ if (clientHostnameVerificationEnabled) {
+ performHostVerification(socket.getInetAddress(), chain[0]);
+ }
+ }
+
+ @Override
+ public void checkServerTrusted(X509Certificate[] chain, String authType, Socket socket) throws CertificateException {
+ x509ExtendedTrustManager.checkServerTrusted(chain, authType, socket);
+ if (serverHostnameVerificationEnabled) {
+ performHostVerification(socket.getInetAddress(), chain[0]);
+ }
+ }
+
+ @Override
+ public void checkClientTrusted(X509Certificate[] chain, String authType, SSLEngine engine) throws CertificateException {
+ x509ExtendedTrustManager.checkServerTrusted(chain, authType, engine);
+ if (clientHostnameVerificationEnabled) {
+ try {
+ performHostVerification(InetAddress.getByName(engine.getPeerHost()), chain[0]);
+ } catch (UnknownHostException e) {
+ throw new CertificateException("Failed to verify host", e);
+ }
+ }
+ }
+
+ @Override
+ public void checkServerTrusted(X509Certificate[] chain, String authType, SSLEngine engine)
+ throws CertificateException {
+ x509ExtendedTrustManager.checkServerTrusted(chain, authType, engine);
+ if (serverHostnameVerificationEnabled) {
+ try {
+ performHostVerification(InetAddress.getByName(engine.getPeerHost()), chain[0]);
+ } catch (UnknownHostException e) {
+ throw new CertificateException("Failed to verify host", e);
+ }
+ }
+ }
+
+ @Override
+ public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
+ x509ExtendedTrustManager.checkClientTrusted(chain, authType);
+ }
+
+ @Override
+ public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
+ x509ExtendedTrustManager.checkServerTrusted(chain, authType);
+ }
+
+ /**
+ * Compares peer's hostname with the one stored in the provided client certificate. Performs verification
+ * with the help of provided HostnameVerifier.
+ *
+ * @param inetAddress Peer's inet address.
+ * @param certificate Peer's certificate
+ * @throws CertificateException Thrown if the provided certificate doesn't match the peer hostname.
+ */
+ private void performHostVerification(InetAddress inetAddress, X509Certificate certificate)
+ throws CertificateException {
+ String hostAddress = "";
+ String hostName = "";
+ try {
+ hostAddress = inetAddress.getHostAddress();
+ hostnameVerifier.verify(hostAddress, certificate);
+ } catch (SSLException addressVerificationException) {
+ try {
+ LOG.debug("Failed to verify host address: {} attempting to verify host name with reverse dns lookup",
+ hostAddress, addressVerificationException);
+ hostName = inetAddress.getHostName();
+ hostnameVerifier.verify(hostName, certificate);
+ } catch (SSLException hostnameVerificationException) {
+ LOG.error("Failed to verify host address: {}", hostAddress, addressVerificationException);
+ LOG.error("Failed to verify hostname: {}", hostName, hostnameVerificationException);
+ throw new CertificateException("Failed to verify both host address and host name",
+ hostnameVerificationException);
+ }
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/7b679bc9/zookeeper-common/src/main/java/org/apache/zookeeper/common/ClientX509Util.java
----------------------------------------------------------------------
diff --git a/zookeeper-common/src/main/java/org/apache/zookeeper/common/ClientX509Util.java b/zookeeper-common/src/main/java/org/apache/zookeeper/common/ClientX509Util.java
new file mode 100644
index 0000000..63dd17a
--- /dev/null
+++ b/zookeeper-common/src/main/java/org/apache/zookeeper/common/ClientX509Util.java
@@ -0,0 +1,38 @@
+/**
+ * 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;
+
+public class ClientX509Util extends X509Util {
+
+ private final String sslAuthProviderProperty = getConfigPrefix() + "authProvider";
+
+ @Override
+ protected String getConfigPrefix() {
+ return "zookeeper.ssl.";
+ }
+
+ @Override
+ protected boolean shouldVerifyClientHostname() {
+ return false;
+ }
+
+ public String getSslAuthProviderProperty() {
+ return sslAuthProviderProperty;
+ }
+}
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/7b679bc9/zookeeper-common/src/main/java/org/apache/zookeeper/common/QuorumX509Util.java
----------------------------------------------------------------------
diff --git a/zookeeper-common/src/main/java/org/apache/zookeeper/common/QuorumX509Util.java b/zookeeper-common/src/main/java/org/apache/zookeeper/common/QuorumX509Util.java
new file mode 100644
index 0000000..abe90a5
--- /dev/null
+++ b/zookeeper-common/src/main/java/org/apache/zookeeper/common/QuorumX509Util.java
@@ -0,0 +1,32 @@
+/**
+ * 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;
+
+public class QuorumX509Util extends X509Util {
+
+ @Override
+ protected String getConfigPrefix() {
+ return "zookeeper.ssl.quorum.";
+ }
+
+ @Override
+ protected boolean shouldVerifyClientHostname() {
+ return true;
+ }
+}
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/7b679bc9/zookeeper-common/src/main/java/org/apache/zookeeper/common/X509Util.java
----------------------------------------------------------------------
diff --git a/zookeeper-common/src/main/java/org/apache/zookeeper/common/X509Util.java b/zookeeper-common/src/main/java/org/apache/zookeeper/common/X509Util.java
index cc8662e..2112c70 100644
--- a/zookeeper-common/src/main/java/org/apache/zookeeper/common/X509Util.java
+++ b/zookeeper-common/src/main/java/org/apache/zookeeper/common/X509Util.java
@@ -18,64 +18,143 @@
package org.apache.zookeeper.common;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.net.ssl.CertPathTrustManagerParameters;
import javax.net.ssl.KeyManager;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLParameters;
+import javax.net.ssl.SSLServerSocket;
+import javax.net.ssl.SSLSocket;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509ExtendedTrustManager;
import javax.net.ssl.X509KeyManager;
import javax.net.ssl.X509TrustManager;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
+import java.net.Socket;
+import java.security.InvalidAlgorithmParameterException;
+import java.security.KeyManagementException;
import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.Security;
+import java.security.UnrecoverableKeyException;
+import java.security.cert.CertificateException;
+import java.security.cert.PKIXBuilderParameters;
+import java.security.cert.X509CertSelector;
+import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicReference;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import static org.apache.zookeeper.common.X509Exception.KeyManagerException;
-import static org.apache.zookeeper.common.X509Exception.SSLContextException;
-import static org.apache.zookeeper.common.X509Exception.TrustManagerException;
+import org.apache.zookeeper.common.X509Exception.KeyManagerException;
+import org.apache.zookeeper.common.X509Exception.SSLContextException;
+import org.apache.zookeeper.common.X509Exception.TrustManagerException;
/**
* Utility code for X509 handling
+ *
+ * Default cipher suites:
+ *
+ * Performance testing done by Facebook engineers shows that on Intel x86_64 machines, Java9 performs better with
+ * GCM and Java8 performs better with CBC, so these seem like reasonable defaults.
*/
-public class X509Util {
+public abstract class X509Util {
private static final Logger LOG = LoggerFactory.getLogger(X509Util.class);
- /**
- * @deprecated Use {@link ZKConfig#SSL_KEYSTORE_LOCATION}
- * instead.
- */
- @Deprecated
- public static final String SSL_KEYSTORE_LOCATION = "zookeeper.ssl.keyStore.location";
- /**
- * @deprecated Use {@link ZKConfig#SSL_KEYSTORE_PASSWD}
- * instead.
- */
- @Deprecated
- public static final String SSL_KEYSTORE_PASSWD = "zookeeper.ssl.keyStore.password";
- /**
- * @deprecated Use {@link ZKConfig#SSL_TRUSTSTORE_LOCATION}
- * instead.
- */
- @Deprecated
- public static final String SSL_TRUSTSTORE_LOCATION = "zookeeper.ssl.trustStore.location";
- /**
- * @deprecated Use {@link ZKConfig#SSL_TRUSTSTORE_PASSWD}
- * instead.
- */
- @Deprecated
- public static final String SSL_TRUSTSTORE_PASSWD = "zookeeper.ssl.trustStore.password";
- /**
- * @deprecated Use {@link ZKConfig#SSL_AUTHPROVIDER}
- * instead.
- */
- @Deprecated
- public static final String SSL_AUTHPROVIDER = "zookeeper.ssl.authProvider";
-
- public static SSLContext createSSLContext() throws SSLContextException {
- /**
+ static final String DEFAULT_PROTOCOL = "TLSv1.2";
+ private static final String[] DEFAULT_CIPHERS_JAVA8 = {
+ "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
+ "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
+ "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
+ "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"
+ };
+ private static final String[] DEFAULT_CIPHERS_JAVA9 = {
+ "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
+ "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
+ "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
+ "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"
+ };
+
+ private String sslProtocolProperty = getConfigPrefix() + "protocol";
+ private String cipherSuitesProperty = getConfigPrefix() + "ciphersuites";
+ private String sslKeystoreLocationProperty = getConfigPrefix() + "keyStore.location";
+ private String sslKeystorePasswdProperty = getConfigPrefix() + "keyStore.password";
+ private String sslTruststoreLocationProperty = getConfigPrefix() + "trustStore.location";
+ private String sslTruststorePasswdProperty = getConfigPrefix() + "trustStore.password";
+ private String sslHostnameVerificationEnabledProperty = getConfigPrefix() + "hostnameVerification";
+ private String sslCrlEnabledProperty = getConfigPrefix() + "crl";
+ private String sslOcspEnabledProperty = getConfigPrefix() + "ocsp";
+
+ private String[] cipherSuites;
+
+ private AtomicReference<SSLContext> defaultSSLContext = new AtomicReference<>(null);
+
+ public X509Util() {
+ String cipherSuitesInput = System.getProperty(cipherSuitesProperty);
+ if (cipherSuitesInput == null) {
+ cipherSuites = getDefaultCipherSuites();
+ } else {
+ cipherSuites = cipherSuitesInput.split(",");
+ }
+ }
+
+ protected abstract String getConfigPrefix();
+ protected abstract boolean shouldVerifyClientHostname();
+
+ public String getSslProtocolProperty() {
+ return sslProtocolProperty;
+ }
+
+ public String getCipherSuitesProperty() {
+ return cipherSuitesProperty;
+ }
+
+ public String getSslKeystoreLocationProperty() {
+ return sslKeystoreLocationProperty;
+ }
+
+ public String getSslKeystorePasswdProperty() {
+ return sslKeystorePasswdProperty;
+ }
+
+ public String getSslTruststoreLocationProperty() {
+ return sslTruststoreLocationProperty;
+ }
+
+ public String getSslTruststorePasswdProperty() {
+ return sslTruststorePasswdProperty;
+ }
+
+ public String getSslHostnameVerificationEnabledProperty() {
+ return sslHostnameVerificationEnabledProperty;
+ }
+
+ public String getSslCrlEnabledProperty() {
+ return sslCrlEnabledProperty;
+ }
+
+ public String getSslOcspEnabledProperty() {
+ return sslOcspEnabledProperty;
+ }
+
+ public SSLContext getDefaultSSLContext() throws X509Exception.SSLContextException {
+ SSLContext result = defaultSSLContext.get();
+ if (result == null) {
+ result = createSSLContext();
+ if (!defaultSSLContext.compareAndSet(null, result)) {
+ // lost the race, another thread already set the value
+ result = defaultSSLContext.get();
+ }
+ }
+ return result;
+ }
+
+ private SSLContext createSSLContext() throws SSLContextException {
+ /*
* Since Configuration initializes the key store and trust store related
* configuration from system property. Reading property from
* configuration will be same reading from system property
@@ -84,61 +163,62 @@ public class X509Util {
return createSSLContext(config);
}
- public static SSLContext createSSLContext(ZKConfig config) throws SSLContextException {
+ public SSLContext createSSLContext(ZKConfig config) throws SSLContextException {
KeyManager[] keyManagers = null;
TrustManager[] trustManagers = null;
- String keyStoreLocationProp = config.getProperty(ZKConfig.SSL_KEYSTORE_LOCATION);
- String keyStorePasswordProp = config.getProperty(ZKConfig.SSL_KEYSTORE_PASSWD);
+ String keyStoreLocationProp = config.getProperty(sslKeystoreLocationProperty);
+ String keyStorePasswordProp = config.getProperty(sslKeystorePasswdProperty);
// There are legal states in some use cases for null KeyManager or TrustManager.
// But if a user wanna specify one, location and password are required.
if (keyStoreLocationProp == null && keyStorePasswordProp == null) {
- LOG.warn("keystore not specified for client connection");
+ LOG.warn(getSslKeystoreLocationProperty() + " not specified");
} else {
if (keyStoreLocationProp == null) {
- throw new SSLContextException("keystore location not specified for client connection");
+ throw new SSLContextException(getSslKeystoreLocationProperty() + " not specified");
}
if (keyStorePasswordProp == null) {
- throw new SSLContextException("keystore password not specified for client connection");
+ throw new SSLContextException(getSslKeystorePasswdProperty() + " not specified");
}
try {
keyManagers = new KeyManager[]{
createKeyManager(keyStoreLocationProp, keyStorePasswordProp)};
- } catch (KeyManagerException e) {
- throw new SSLContextException("Failed to create KeyManager", e);
+ } catch (KeyManagerException keyManagerException) {
+ throw new SSLContextException("Failed to create KeyManager", keyManagerException);
}
}
- String trustStoreLocationProp = config.getProperty(ZKConfig.SSL_TRUSTSTORE_LOCATION);
- String trustStorePasswordProp = config.getProperty(ZKConfig.SSL_TRUSTSTORE_PASSWD);
+ String trustStoreLocationProp = config.getProperty(sslTruststoreLocationProperty);
+ String trustStorePasswordProp = config.getProperty(sslTruststorePasswdProperty);
- if (trustStoreLocationProp == null && trustStorePasswordProp == null) {
- LOG.warn("Truststore not specified for client connection");
+ boolean sslCrlEnabled = config.getBoolean(this.sslCrlEnabledProperty);
+ boolean sslOcspEnabled = config.getBoolean(this.sslOcspEnabledProperty);
+ boolean sslServerHostnameVerificationEnabled =
+ config.getBoolean(this.getSslHostnameVerificationEnabledProperty(),true);
+ boolean sslClientHostnameVerificationEnabled = sslServerHostnameVerificationEnabled && shouldVerifyClientHostname();
+
+ if (trustStoreLocationProp == null) {
+ LOG.warn(getSslTruststoreLocationProperty() + " not specified");
} else {
- if (trustStoreLocationProp == null) {
- throw new SSLContextException("Truststore location not specified for client connection");
- }
- if (trustStorePasswordProp == null) {
- throw new SSLContextException("Truststore password not specified for client connection");
- }
try {
trustManagers = new TrustManager[]{
- createTrustManager(trustStoreLocationProp, trustStorePasswordProp)};
- } catch (TrustManagerException e) {
- throw new SSLContextException("Failed to create TrustManager", e);
+ createTrustManager(trustStoreLocationProp, trustStorePasswordProp, sslCrlEnabled, sslOcspEnabled,
+ sslServerHostnameVerificationEnabled, sslClientHostnameVerificationEnabled)};
+ } catch (TrustManagerException trustManagerException) {
+ throw new SSLContextException("Failed to create TrustManager", trustManagerException);
}
}
- SSLContext sslContext = null;
+ String protocol = System.getProperty(sslProtocolProperty, DEFAULT_PROTOCOL);
try {
- sslContext = SSLContext.getInstance("TLSv1");
+ SSLContext sslContext = SSLContext.getInstance(protocol);
sslContext.init(keyManagers, trustManagers, null);
- } catch (Exception e) {
- throw new SSLContextException(e);
+ return sslContext;
+ } catch (NoSuchAlgorithmException|KeyManagementException sslContextInitException) {
+ throw new SSLContextException(sslContextInitException);
}
- return sslContext;
}
public static X509KeyManager createKeyManager(String keyStoreLocation, String keyStorePassword)
@@ -150,7 +230,7 @@ public class X509Util {
KeyStore ks = KeyStore.getInstance("JKS");
inputStream = new FileInputStream(keyStoreFile);
ks.load(inputStream, keyStorePasswordChars);
- KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
+ KeyManagerFactory kmf = KeyManagerFactory.getInstance("PKIX");
kmf.init(ks, keyStorePasswordChars);
for (KeyManager km : kmf.getKeyManagers()) {
@@ -160,43 +240,124 @@ public class X509Util {
}
throw new KeyManagerException("Couldn't find X509KeyManager");
- } catch (Exception e) {
- throw new KeyManagerException(e);
+ } catch (IOException|CertificateException|UnrecoverableKeyException|NoSuchAlgorithmException|KeyStoreException
+ keyManagerCreationException) {
+ throw new KeyManagerException(keyManagerCreationException);
} finally {
if (inputStream != null) {
try {
inputStream.close();
- } catch (IOException e) {}
+ } catch (IOException ioException) {
+ LOG.info("Failed to close key store input stream", ioException);
+ }
}
}
}
- public static X509TrustManager createTrustManager(String trustStoreLocation, String trustStorePassword)
+ public static X509TrustManager createTrustManager(String trustStoreLocation, String trustStorePassword,
+ boolean crlEnabled, boolean ocspEnabled,
+ final boolean serverHostnameVerificationEnabled,
+ final boolean clientHostnameVerificationEnabled)
throws TrustManagerException {
FileInputStream inputStream = null;
try {
- char[] trustStorePasswordChars = trustStorePassword.toCharArray();
File trustStoreFile = new File(trustStoreLocation);
KeyStore ts = KeyStore.getInstance("JKS");
inputStream = new FileInputStream(trustStoreFile);
- ts.load(inputStream, trustStorePasswordChars);
- TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
- tmf.init(ts);
+ if (trustStorePassword != null) {
+ char[] trustStorePasswordChars = trustStorePassword.toCharArray();
+ ts.load(inputStream, trustStorePasswordChars);
+ } else {
+ ts.load(inputStream, null);
+ }
+
+ PKIXBuilderParameters pbParams = new PKIXBuilderParameters(ts, new X509CertSelector());
+ if (crlEnabled || ocspEnabled) {
+ pbParams.setRevocationEnabled(true);
+ System.setProperty("com.sun.net.ssl.checkRevocation", "true");
+ System.setProperty("com.sun.security.enableCRLDP", "true");
+ if (ocspEnabled) {
+ Security.setProperty("ocsp.enable", "true");
+ }
+ } else {
+ pbParams.setRevocationEnabled(false);
+ }
- for (TrustManager tm : tmf.getTrustManagers()) {
- if (tm instanceof X509TrustManager) {
- return (X509TrustManager) tm;
+ // Revocation checking is only supported with the PKIX algorithm
+ TrustManagerFactory tmf = TrustManagerFactory.getInstance("PKIX");
+ tmf.init(new CertPathTrustManagerParameters(pbParams));
+
+ for (final TrustManager tm : tmf.getTrustManagers()) {
+ if (tm instanceof X509ExtendedTrustManager) {
+ return new ZKTrustManager((X509ExtendedTrustManager) tm,
+ serverHostnameVerificationEnabled, clientHostnameVerificationEnabled);
}
}
throw new TrustManagerException("Couldn't find X509TrustManager");
- } catch (Exception e) {
- throw new TrustManagerException(e);
+ } catch (IOException|CertificateException|NoSuchAlgorithmException|InvalidAlgorithmParameterException|KeyStoreException
+ trustManagerCreationException) {
+ throw new TrustManagerException(trustManagerCreationException);
} finally {
if (inputStream != null) {
try {
inputStream.close();
- } catch (IOException e) {}
+ } catch (IOException ioException) {
+ LOG.info("failed to close TrustStore input stream", ioException);
+ }
}
}
}
-}
\ No newline at end of file
+
+ public SSLSocket createSSLSocket() throws X509Exception, IOException {
+ SSLSocket sslSocket = (SSLSocket) getDefaultSSLContext().getSocketFactory().createSocket();
+ configureSSLSocket(sslSocket);
+
+ return sslSocket;
+ }
+
+ public SSLSocket createSSLSocket(Socket socket) throws X509Exception, IOException {
+ SSLSocket sslSocket = (SSLSocket) getDefaultSSLContext().getSocketFactory().createSocket(socket, null, socket.getPort(), true);
+ configureSSLSocket(sslSocket);
+
+ return sslSocket;
+ }
+
+ private void configureSSLSocket(SSLSocket sslSocket) {
+ SSLParameters sslParameters = sslSocket.getSSLParameters();
+ LOG.debug("Setup cipher suites for client socket: {}", Arrays.toString(cipherSuites));
+ sslParameters.setCipherSuites(cipherSuites);
+ sslSocket.setSSLParameters(sslParameters);
+ }
+
+ public SSLServerSocket createSSLServerSocket() throws X509Exception, IOException {
+ SSLServerSocket sslServerSocket = (SSLServerSocket) getDefaultSSLContext().getServerSocketFactory().createServerSocket();
+ configureSSLServerSocket(sslServerSocket);
+
+ return sslServerSocket;
+ }
+
+ public SSLServerSocket createSSLServerSocket(int port) throws X509Exception, IOException {
+ SSLServerSocket sslServerSocket = (SSLServerSocket) getDefaultSSLContext().getServerSocketFactory().createServerSocket(port);
+ configureSSLServerSocket(sslServerSocket);
+
+ return sslServerSocket;
+ }
+
+ private void configureSSLServerSocket(SSLServerSocket sslServerSocket) {
+ SSLParameters sslParameters = sslServerSocket.getSSLParameters();
+ sslParameters.setNeedClientAuth(true);
+ LOG.debug("Setup cipher suites for server socket: {}", Arrays.toString(cipherSuites));
+ sslParameters.setCipherSuites(cipherSuites);
+ sslServerSocket.setSSLParameters(sslParameters);
+ }
+
+ private String[] getDefaultCipherSuites() {
+ String javaVersion = System.getProperty("java.specification.version");
+ if ("9".equals(javaVersion)) {
+ LOG.debug("Using Java9-optimized cipher suites for Java version {}", javaVersion);
+ return DEFAULT_CIPHERS_JAVA9;
+ }
+ LOG.debug("Using Java8-optimized cipher suites for Java version {}", javaVersion);
+ return DEFAULT_CIPHERS_JAVA8;
+ }
+}
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/7b679bc9/zookeeper-common/src/main/java/org/apache/zookeeper/common/ZKConfig.java
----------------------------------------------------------------------
diff --git a/zookeeper-common/src/main/java/org/apache/zookeeper/common/ZKConfig.java b/zookeeper-common/src/main/java/org/apache/zookeeper/common/ZKConfig.java
index 8d9c001..dc24b19 100644
--- a/zookeeper-common/src/main/java/org/apache/zookeeper/common/ZKConfig.java
+++ b/zookeeper-common/src/main/java/org/apache/zookeeper/common/ZKConfig.java
@@ -42,17 +42,9 @@ import org.slf4j.LoggerFactory;
public class ZKConfig {
private static final Logger LOG = LoggerFactory.getLogger(ZKConfig.class);
- @SuppressWarnings("deprecation")
- public static final String SSL_KEYSTORE_LOCATION = X509Util.SSL_KEYSTORE_LOCATION;
- @SuppressWarnings("deprecation")
- public static final String SSL_KEYSTORE_PASSWD = X509Util.SSL_KEYSTORE_PASSWD;
- @SuppressWarnings("deprecation")
- public static final String SSL_TRUSTSTORE_LOCATION = X509Util.SSL_TRUSTSTORE_LOCATION;
- @SuppressWarnings("deprecation")
- public static final String SSL_TRUSTSTORE_PASSWD = X509Util.SSL_TRUSTSTORE_PASSWD;
- @SuppressWarnings("deprecation")
- public static final String SSL_AUTHPROVIDER = X509Util.SSL_AUTHPROVIDER;
+
public static final String JUTE_MAXBUFFER = "jute.maxbuffer";
+
/**
* Path to a kinit binary: {@value}. Defaults to
* <code>"/usr/bin/kinit"</code>
@@ -107,14 +99,33 @@ public class ZKConfig {
* this configuration.
*/
protected void handleBackwardCompatibility() {
- properties.put(SSL_KEYSTORE_LOCATION, System.getProperty(SSL_KEYSTORE_LOCATION));
- properties.put(SSL_KEYSTORE_PASSWD, System.getProperty(SSL_KEYSTORE_PASSWD));
- properties.put(SSL_TRUSTSTORE_LOCATION, System.getProperty(SSL_TRUSTSTORE_LOCATION));
- properties.put(SSL_TRUSTSTORE_PASSWD, System.getProperty(SSL_TRUSTSTORE_PASSWD));
- properties.put(SSL_AUTHPROVIDER, System.getProperty(SSL_AUTHPROVIDER));
properties.put(JUTE_MAXBUFFER, System.getProperty(JUTE_MAXBUFFER));
properties.put(KINIT_COMMAND, System.getProperty(KINIT_COMMAND));
properties.put(JGSS_NATIVE, System.getProperty(JGSS_NATIVE));
+
+ ClientX509Util clientX509Util = new ClientX509Util();
+ putSSLProperties(clientX509Util);
+ properties.put(clientX509Util.getSslAuthProviderProperty(),
+ System.getProperty(clientX509Util.getSslAuthProviderProperty()));
+
+ putSSLProperties(new QuorumX509Util());
+ }
+
+ private void putSSLProperties(X509Util x509Util) {
+ properties.put(x509Util.getSslKeystoreLocationProperty(),
+ System.getProperty(x509Util.getSslKeystoreLocationProperty()));
+ properties.put(x509Util.getSslKeystorePasswdProperty(),
+ System.getProperty(x509Util.getSslKeystorePasswdProperty()));
+ properties.put(x509Util.getSslTruststoreLocationProperty(),
+ System.getProperty(x509Util.getSslTruststoreLocationProperty()));
+ properties.put(x509Util.getSslTruststorePasswdProperty(),
+ System.getProperty(x509Util.getSslTruststorePasswdProperty()));
+ properties.put(x509Util.getSslHostnameVerificationEnabledProperty(),
+ System.getProperty(x509Util.getSslHostnameVerificationEnabledProperty()));
+ properties.put(x509Util.getSslCrlEnabledProperty(),
+ System.getProperty(x509Util.getSslCrlEnabledProperty()));
+ properties.put(x509Util.getSslOcspEnabledProperty(),
+ System.getProperty(x509Util.getSslOcspEnabledProperty()));
}
/**
@@ -220,7 +231,29 @@ public class ZKConfig {
* exists and is equal to the string {@code "true"}.
*/
public boolean getBoolean(String key) {
- return Boolean.parseBoolean(getProperty(key));
+ return getBoolean(key, false);
+ }
+
+ /**
+ * Get the value of the <code>key</code> property as a <code>boolean</code>. Returns
+ * {@code true} if and only if the property named by the argument exists and is equal
+ * to the string {@code "true"}. If the property is not set, the provided
+ * <code>defaultValue</code> is returned.
+ *
+ * @param key
+ * property key.
+ * @param defaultValue
+ * default value.
+ * @return return property value as an <code>boolean</code>, or
+ * <code>defaultValue</code>
+ */
+ public boolean getBoolean(String key, boolean defaultValue) {
+ String propertyValue = getProperty(key);
+ if (propertyValue == null) {
+ return defaultValue;
+ } else {
+ return Boolean.parseBoolean(propertyValue);
+ }
}
/**
http://git-wip-us.apache.org/repos/asf/zookeeper/blob/7b679bc9/zookeeper-common/src/test/java/org/apache/zookeeper/common/X509UtilTest.java
----------------------------------------------------------------------
diff --git a/zookeeper-common/src/test/java/org/apache/zookeeper/common/X509UtilTest.java b/zookeeper-common/src/test/java/org/apache/zookeeper/common/X509UtilTest.java
new file mode 100644
index 0000000..e726caa
--- /dev/null
+++ b/zookeeper-common/src/test/java/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("JKS");
+ 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("JKS");
+ 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/7b679bc9/zookeeper-common/src/test/java/org/apache/zookeeper/common/ZKTrustManagerTest.java
----------------------------------------------------------------------
diff --git a/zookeeper-common/src/test/java/org/apache/zookeeper/common/ZKTrustManagerTest.java b/zookeeper-common/src/test/java/org/apache/zookeeper/common/ZKTrustManagerTest.java
new file mode 100644
index 0000000..32f250b
--- /dev/null
+++ b/zookeeper-common/src/test/java/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/7b679bc9/zookeeper-common/src/test/java/org/apache/zookeeper/test/ClientSSLTest.java
----------------------------------------------------------------------
diff --git a/zookeeper-common/src/test/java/org/apache/zookeeper/test/ClientSSLTest.java b/zookeeper-common/src/test/java/org/apache/zookeeper/test/ClientSSLTest.java
new file mode 100644
index 0000000..08ffb4e
--- /dev/null
+++ b/zookeeper-common/src/test/java/org/apache/zookeeper/test/ClientSSLTest.java
@@ -0,0 +1,132 @@
+/**
+ * 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.test;
+
+
+import org.apache.zookeeper.CreateMode;
+import org.apache.zookeeper.PortAssignment;
+import org.apache.zookeeper.ZooDefs;
+import org.apache.zookeeper.ZooKeeper;
+import org.apache.zookeeper.client.ZKClientConfig;
+import org.apache.zookeeper.common.ClientX509Util;
+import org.apache.zookeeper.server.ServerCnxnFactory;
+import org.apache.zookeeper.server.quorum.QuorumPeerTestBase;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class ClientSSLTest extends QuorumPeerTestBase {
+
+ private ClientX509Util clientX509Util = new ClientX509Util();
+
+ @Before
+ public void setup() {
+ 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");
+ System.setProperty(clientX509Util.getSslKeystoreLocationProperty(), testDataPath + "/ssl/testKeyStore.jks");
+ System.setProperty(clientX509Util.getSslKeystorePasswdProperty(), "testpass");
+ System.setProperty(clientX509Util.getSslTruststoreLocationProperty(), testDataPath + "/ssl/testTrustStore.jks");
+ System.setProperty(clientX509Util.getSslTruststorePasswdProperty(), "testpass");
+ }
+
+ @After
+ public void teardown() throws Exception {
+ System.clearProperty(ServerCnxnFactory.ZOOKEEPER_SERVER_CNXN_FACTORY);
+ System.clearProperty(ZKClientConfig.ZOOKEEPER_CLIENT_CNXN_SOCKET);
+ System.clearProperty(ZKClientConfig.SECURE_CLIENT);
+ System.clearProperty(clientX509Util.getSslKeystoreLocationProperty());
+ System.clearProperty(clientX509Util.getSslKeystorePasswdProperty());
+ System.clearProperty(clientX509Util.getSslTruststoreLocationProperty());
+ System.clearProperty(clientX509Util.getSslTruststorePasswdProperty());
+ }
+
+ /**
+ * This test checks that client <-> server SSL works in cluster setup of ZK servers, which includes:
+ * 1. setting "secureClientPort" in "zoo.cfg" file.
+ * 2. setting jvm flags for serverCnxn, keystore, truststore.
+ * Finally, a zookeeper client should be able to connect to the secure port and
+ * communicate with server via secure connection.
+ * <p/>
+ * Note that in this test a ZK server has two ports -- clientPort and secureClientPort.
+ */
+ @Test
+ public void testClientServerSSL() throws Exception {
+ final int SERVER_COUNT = 3;
+ final int clientPorts[] = new int[SERVER_COUNT];
+ final Integer secureClientPorts[] = new Integer[SERVER_COUNT];
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < SERVER_COUNT; i++) {
+ clientPorts[i] = PortAssignment.unique();
+ secureClientPorts[i] = PortAssignment.unique();
+ String server = String.format("server.%d=localhost:%d:%d:participant;localhost:%d",
+ i, PortAssignment.unique(), PortAssignment.unique(), clientPorts[i]);
+ sb.append(server + "\n");
+ }
+ String quorumCfg = sb.toString();
+
+
+ MainThread[] mt = new MainThread[SERVER_COUNT];
+ for (int i = 0; i < SERVER_COUNT; i++) {
+ mt[i] = new MainThread(i, quorumCfg, secureClientPorts[i], true);
+ mt[i].start();
+ }
+
+ // Servers have been set up. Now go test if secure connection is successful.
+ for (int i = 0; i < SERVER_COUNT; i++) {
+ Assert.assertTrue("waiting for server " + i + " being up",
+ ClientBase.waitForServerUp("127.0.0.1:" + clientPorts[i], TIMEOUT));
+
+ ZooKeeper zk = ClientBase.createZKClient("127.0.0.1:" + secureClientPorts[i], TIMEOUT);
+ // Do a simple operation to make sure the connection is fine.
+ zk.create("/test", "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
+ zk.delete("/test", -1);
+ zk.close();
+ }
+
+ for (int i = 0; i < mt.length; i++) {
+ mt[i].shutdown();
+ }
+ }
+
+
+ /**
+ * Developers might use standalone mode (which is the default for one server).
+ * This test checks SSL works in standalone mode of ZK server.
+ * <p/>
+ * Note that in this test the Zk server has only secureClientPort
+ */
+ @Test
+ public void testSecureStandaloneServer() throws Exception {
+ Integer secureClientPort = PortAssignment.unique();
+ MainThread mt = new MainThread(MainThread.UNSET_MYID, "", secureClientPort, false);
+ mt.start();
+
+ ZooKeeper zk = ClientBase.createZKClient("127.0.0.1:" + secureClientPort, TIMEOUT);
+ zk.create("/test", "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
+ zk.delete("/test", -1);
+ zk.close();
+ mt.shutdown();
+ }
+}