View Javadoc
1   /*
2    * Copyright 2016 The Netty Project
3    *
4    * The Netty Project licenses this file to you under the Apache License,
5    * version 2.0 (the "License"); you may not use this file except in compliance
6    * with the License. You may obtain a copy of the License at:
7    *
8    *   https://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13   * License for the specific language governing permissions and limitations
14   * under the License.
15   */
16  package io.netty.handler.ssl;
17  
18  import io.netty.buffer.ByteBufAllocator;
19  import io.netty.internal.tcnative.CertificateCallback;
20  import io.netty.internal.tcnative.SSL;
21  import io.netty.internal.tcnative.SSLContext;
22  import io.netty.internal.tcnative.SniHostNameMatcher;
23  import io.netty.util.internal.logging.InternalLogger;
24  import io.netty.util.internal.logging.InternalLoggerFactory;
25  
26  import java.security.KeyStore;
27  import java.security.PrivateKey;
28  import java.security.cert.X509Certificate;
29  import java.util.List;
30  import java.util.Map;
31  import javax.net.ssl.KeyManagerFactory;
32  import javax.net.ssl.SSLException;
33  import javax.net.ssl.TrustManagerFactory;
34  import javax.net.ssl.X509ExtendedTrustManager;
35  import javax.net.ssl.X509TrustManager;
36  
37  import static io.netty.util.internal.ObjectUtil.checkNotNull;
38  
39  /**
40   * A server-side {@link SslContext} which uses OpenSSL's SSL/TLS implementation.
41   * <p>Instances of this class must be {@link #release() released} or else native memory will leak!
42   *
43   * <p>Instances of this class <strong>must not</strong> be released before any {@link ReferenceCountedOpenSslEngine}
44   * which depends upon the instance of this class is released. Otherwise if any method of
45   * {@link ReferenceCountedOpenSslEngine} is called which uses this class's JNI resources the JVM may crash.
46   */
47  public final class ReferenceCountedOpenSslServerContext extends ReferenceCountedOpenSslContext {
48      private static final InternalLogger logger =
49              InternalLoggerFactory.getInstance(ReferenceCountedOpenSslServerContext.class);
50  
51      private final OpenSslServerSessionContext sessionContext;
52  
53      ReferenceCountedOpenSslServerContext(
54              X509Certificate[] trustCertCollection, TrustManagerFactory trustManagerFactory,
55              X509Certificate[] keyCertChain, PrivateKey key, String keyPassword, KeyManagerFactory keyManagerFactory,
56              Iterable<String> ciphers, CipherSuiteFilter cipherFilter, ApplicationProtocolConfig apn,
57              long sessionCacheSize, long sessionTimeout, ClientAuth clientAuth, String[] protocols, boolean startTls,
58              boolean enableOcsp, String keyStore, ResumptionController resumptionController,
59              SessionIdContextBuilder sessionIdContext,
60              Map.Entry<SslContextOption<?>, Object>[] options,
61              List<OpenSslCredential> credentials) throws SSLException {
62          this(trustCertCollection, trustManagerFactory, keyCertChain, key, keyPassword, keyManagerFactory, ciphers,
63                  cipherFilter, toNegotiator(apn), sessionCacheSize, sessionTimeout, clientAuth, protocols, startTls,
64                  enableOcsp, keyStore, resumptionController, sessionIdContext, options, credentials);
65      }
66  
67      ReferenceCountedOpenSslServerContext(
68              X509Certificate[] trustCertCollection, TrustManagerFactory trustManagerFactory,
69              X509Certificate[] keyCertChain, PrivateKey key, String keyPassword, KeyManagerFactory keyManagerFactory,
70              Iterable<String> ciphers, CipherSuiteFilter cipherFilter, OpenSslApplicationProtocolNegotiator apn,
71              long sessionCacheSize, long sessionTimeout, ClientAuth clientAuth, String[] protocols, boolean startTls,
72              boolean enableOcsp, String keyStore, ResumptionController resumptionController,
73              SessionIdContextBuilder sessionIdContext,
74              Map.Entry<SslContextOption<?>, Object>[] options,
75              List<OpenSslCredential> credentials) throws SSLException {
76          super(ciphers, cipherFilter, apn, SSL.SSL_MODE_SERVER, keyCertChain,
77                  clientAuth, protocols, startTls,
78                  null, // No endpoint validation for servers.
79                  enableOcsp, true, null, resumptionController, options, credentials);
80          // Create a new SSL_CTX and configure it.
81          boolean success = false;
82          try {
83              sessionContext = newSessionContext(this, ctx, engines, trustCertCollection, trustManagerFactory,
84                      keyCertChain, key, keyPassword, keyManagerFactory, keyStore,
85                      sessionCacheSize, sessionTimeout, resumptionController, sessionIdContext,
86                      isJdkSignatureFallbackEnabled(options));
87              if (SERVER_ENABLE_SESSION_TICKET) {
88                  sessionContext.setTicketKeys();
89              }
90              success = true;
91          } finally {
92              if (!success) {
93                  release();
94              }
95          }
96      }
97  
98      @Override
99      public OpenSslServerSessionContext sessionContext() {
100         return sessionContext;
101     }
102 
103     static OpenSslServerSessionContext newSessionContext(ReferenceCountedOpenSslContext thiz, long ctx,
104                                                          OpenSslEngineMap engines,
105                                                          X509Certificate[] trustCertCollection,
106                                                          TrustManagerFactory trustManagerFactory,
107                                                          X509Certificate[] keyCertChain, PrivateKey key,
108                                                          String keyPassword, KeyManagerFactory keyManagerFactory,
109                                                          String keyStore, long sessionCacheSize, long sessionTimeout,
110                                                          ResumptionController resumptionController,
111                                                          SessionIdContextBuilder sessionIdContext,
112                                                          boolean fallbackToJdkSignatureProviders)
113             throws SSLException {
114         OpenSslKeyMaterialProvider keyMaterialProvider = null;
115         try {
116             try {
117                 SSLContext.setVerify(ctx, SSL.SSL_CVERIFY_NONE, VERIFY_DEPTH);
118 
119                 // Check if we have an alternative key that requires special handling
120                 // Only detect alternative keys when we have an actual key object that can't be accessed directly
121                 if (keyManagerFactory == null && key != null && key.getEncoded() == null) {
122                     if (!fallbackToJdkSignatureProviders) {
123                         // Alternative key without fallback enabled
124                         throw new SSLException("Private key requiring alternative signature provider detected " +
125                                 "(such as hardware security key, smart card, or remote signing service) but " +
126                                 "alternative key fallback is disabled.");
127                     }
128                     keyMaterialProvider = setupSecurityProviderSignatureSource(thiz, ctx, keyCertChain, key,
129                             manager -> new OpenSslServerCertificateCallback(engines, manager));
130                 } else if (!OpenSsl.useKeyManagerFactory()) {
131                     if (keyManagerFactory != null) {
132                         throw new IllegalArgumentException(
133                                 "KeyManagerFactory not supported with external keys");
134                     } else {
135                         checkNotNull(keyCertChain, "keyCertChain");
136                         // Regular key without KeyManagerFactory support
137                         setKeyMaterial(ctx, keyCertChain, key, keyPassword);
138                     }
139                 } else {
140                     // javadocs state that keyManagerFactory has precedent over keyCertChain, and we must have a
141                     // keyManagerFactory for the server so build one if it is not specified.
142                     if (keyManagerFactory == null) {
143                         keyManagerFactory = certChainToKeyManagerFactory(keyCertChain, key, keyPassword, keyStore);
144                     }
145                     keyMaterialProvider = providerFor(keyManagerFactory, keyPassword);
146 
147                     SSLContext.setCertificateCallback(ctx, new OpenSslServerCertificateCallback(
148                             engines, new OpenSslKeyMaterialManager(keyMaterialProvider, thiz.hasTmpDhKeys)));
149                 }
150             } catch (Exception e) {
151                 throw new SSLException("failed to set certificate and key", e);
152             }
153             try {
154                 if (trustCertCollection != null) {
155                     trustManagerFactory = buildTrustManagerFactory(trustCertCollection, trustManagerFactory, keyStore);
156                 } else if (trustManagerFactory == null) {
157                     // Mimic the way SSLContext.getInstance(KeyManager[], null, null) works
158                     trustManagerFactory = TrustManagerFactory.getInstance(
159                             TrustManagerFactory.getDefaultAlgorithm());
160                     trustManagerFactory.init((KeyStore) null);
161                 }
162 
163                 final X509TrustManager manager = chooseTrustManager(
164                         trustManagerFactory.getTrustManagers(), resumptionController);
165 
166                 // IMPORTANT: The callbacks set for verification must be static to prevent memory leak as
167                 //            otherwise the context can never be collected. This is because the JNI code holds
168                 //            a global reference to the callbacks.
169                 //
170                 //            See https://github.com/netty/netty/issues/5372
171 
172                 setVerifyCallback(ctx, engines, manager);
173 
174                 X509Certificate[] issuers = manager.getAcceptedIssuers();
175                 if (issuers != null && issuers.length > 0) {
176                     long bio = 0;
177                     try {
178                         bio = toBIO(ByteBufAllocator.DEFAULT, issuers);
179                         if (!SSLContext.setCACertificateBio(ctx, bio)) {
180                             String msg = "unable to setup accepted issuers for trustmanager " + manager;
181                             int error = SSL.getLastErrorNumber();
182                             if (error != 0) {
183                                 msg += ". " + SSL.getErrorString(error);
184                             }
185                             throw new SSLException(msg);
186                         }
187                     } finally {
188                         freeBio(bio);
189                     }
190                 }
191 
192                 // IMPORTANT: The callbacks set for hostname matching must be static to prevent memory leak as
193                 //            otherwise the context can never be collected. This is because the JNI code holds
194                 //            a global reference to the matcher.
195                 SSLContext.setSniHostnameMatcher(ctx, new OpenSslSniHostnameMatcher(engines));
196             } catch (SSLException e) {
197                 throw e;
198             } catch (Exception e) {
199                 throw new SSLException("unable to setup trustmanager", e);
200             }
201 
202             OpenSslServerSessionContext sessionContext = new OpenSslServerSessionContext(thiz, keyMaterialProvider);
203             // Derive the session_id_context from what distinguishes this context, so sessions can not be resumed
204             // across SslContext instances that differ in their ClientAuth mode or trust / key configuration, even if
205             // session-ticket keys or a session cache are shared between them.
206             if (!sessionContext.setSessionIdContext(sessionIdContext.build())) {
207                 // Without a session_id_context we must not continue as resumption would not be scoped.
208                 String msg = "failed to set session id context";
209                 String lastError = SSL.getLastError();
210                 if (lastError != null) {
211                     msg += ": " + lastError;
212                 }
213                 throw new SSLException(msg);
214             }
215             // Enable session caching by default
216             sessionContext.setSessionCacheEnabled(SERVER_ENABLE_SESSION_CACHE);
217             if (sessionCacheSize > 0) {
218                 sessionContext.setSessionCacheSize((int) Math.min(sessionCacheSize, Integer.MAX_VALUE));
219             }
220             if (sessionTimeout > 0) {
221                 sessionContext.setSessionTimeout((int) Math.min(sessionTimeout, Integer.MAX_VALUE));
222             }
223 
224             keyMaterialProvider = null;
225 
226             return sessionContext;
227         } finally {
228             if (keyMaterialProvider != null) {
229                 keyMaterialProvider.destroy();
230             }
231         }
232     }
233 
234     private static void setVerifyCallback(long ctx,
235                                           OpenSslEngineMap engines,
236                                           X509TrustManager manager) {
237         // Use this to prevent an error when running on java < 7
238         if (useExtendedTrustManager(manager)) {
239             SSLContext.setCertVerifyCallback(ctx, new ExtendedTrustManagerVerifyCallback(
240                     engines, (X509ExtendedTrustManager) manager));
241         } else {
242             SSLContext.setCertVerifyCallback(ctx, new TrustManagerVerifyCallback(engines, manager));
243         }
244     }
245 
246     private static final class OpenSslServerCertificateCallback implements CertificateCallback {
247         private final OpenSslEngineMap engines;
248         private final OpenSslKeyMaterialManager keyManagerHolder;
249 
250         OpenSslServerCertificateCallback(OpenSslEngineMap engines,
251                                          OpenSslKeyMaterialManager keyManagerHolder) {
252             this.engines = engines;
253             this.keyManagerHolder = keyManagerHolder;
254         }
255 
256         @Override
257         public void handle(long ssl, byte[] keyTypeBytes, byte[][] asn1DerEncodedPrincipals) throws Exception {
258             final ReferenceCountedOpenSslEngine engine = engines.get(ssl);
259             if (engine == null) {
260                 // Maybe null if destroyed in the meantime.
261                 return;
262             }
263             try {
264                 // For now we just ignore the asn1DerEncodedPrincipals as this is kind of inline with what the
265                 // OpenJDK SSLEngineImpl does.
266                 keyManagerHolder.setKeyMaterialServerSide(engine);
267             } catch (Throwable cause) {
268                 engine.initHandshakeException(cause);
269 
270                 if (cause instanceof Exception) {
271                     throw (Exception) cause;
272                 }
273                 throw new SSLException(cause);
274             }
275         }
276     }
277 
278     private static final class TrustManagerVerifyCallback extends AbstractCertificateVerifier {
279         private final X509TrustManager manager;
280 
281         TrustManagerVerifyCallback(OpenSslEngineMap engines,
282                                    X509TrustManager manager) {
283             super(engines);
284             this.manager = manager;
285         }
286 
287         @Override
288         void verify(ReferenceCountedOpenSslEngine engine, X509Certificate[] peerCerts, String auth)
289                 throws Exception {
290             manager.checkClientTrusted(peerCerts, auth);
291         }
292     }
293 
294     private static final class ExtendedTrustManagerVerifyCallback extends AbstractCertificateVerifier {
295         private final X509ExtendedTrustManager manager;
296 
297         ExtendedTrustManagerVerifyCallback(OpenSslEngineMap engines,
298                                            X509ExtendedTrustManager manager) {
299             super(engines);
300             this.manager = manager;
301         }
302 
303         @Override
304         void verify(ReferenceCountedOpenSslEngine engine, X509Certificate[] peerCerts, String auth)
305                 throws Exception {
306             manager.checkClientTrusted(peerCerts, auth, engine);
307         }
308     }
309 
310     private static final class OpenSslSniHostnameMatcher implements SniHostNameMatcher {
311         private final OpenSslEngineMap engines;
312 
313         OpenSslSniHostnameMatcher(OpenSslEngineMap engines) {
314             this.engines = engines;
315         }
316 
317         @Override
318         public boolean match(long ssl, String hostname) {
319             ReferenceCountedOpenSslEngine engine = engines.get(ssl);
320             if (engine != null) {
321                 // TODO: In the next release of tcnative we should pass the byte[] directly in and not use a String.
322                 return engine.checkSniHostnameMatch(hostname);
323             }
324             logger.warn("No ReferenceCountedOpenSslEngine found for SSL pointer: {}", ssl);
325             return false;
326         }
327     }
328 }