1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
41
42
43
44
45
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,
79 enableOcsp, true, null, resumptionController, options, credentials);
80
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
120
121 if (keyManagerFactory == null && key != null && key.getEncoded() == null) {
122 if (!fallbackToJdkSignatureProviders) {
123
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
137 setKeyMaterial(ctx, keyCertChain, key, keyPassword);
138 }
139 } else {
140
141
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
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
167
168
169
170
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
193
194
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
204
205
206 if (!sessionContext.setSessionIdContext(sessionIdContext.build())) {
207
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
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
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
261 return;
262 }
263 try {
264
265
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
322 return engine.checkSniHostnameMatch(hostname);
323 }
324 logger.warn("No ReferenceCountedOpenSslEngine found for SSL pointer: {}", ssl);
325 return false;
326 }
327 }
328 }