From 5e695919d98a28c05e3161b08ef814021ef5950b Mon Sep 17 00:00:00 2001 From: Simone Bordet Date: Thu, 14 Nov 2019 23:48:34 +0100 Subject: [PATCH] Implemented support for RFC 8441's SETTING_ENABLE_CONNECT_PROTOCOL. Signed-off-by: Simone Bordet --- .../org/eclipse/jetty/http2/HTTP2Session.java | 20 ++++++ .../jetty/http2/frames/SettingsFrame.java | 1 + .../AbstractHTTP2ServerConnectionFactory.java | 14 ++++ .../http2/server/HTTP2ServerSession.java | 10 +++ .../eclipse/jetty/server/session/Session.java | 2 +- jetty-websocket/jetty-websocket-tests/pom.xml | 12 ++++ .../tests/WebSocketOverHTTP2Test.java | 62 ++++++++++++++++-- .../src/test/resources/keystore.p12 | Bin 0 -> 2533 bytes .../server/internal/AbstractHandshaker.java | 3 +- .../server/internal/RFC6455Handshaker.java | 6 +- ...gotiation.java => RFC6455Negotiation.java} | 4 +- 11 files changed, 122 insertions(+), 12 deletions(-) create mode 100644 jetty-websocket/jetty-websocket-tests/src/test/resources/keystore.p12 rename jetty-websocket/websocket-core/src/main/java/org/eclipse/jetty/websocket/core/server/internal/{RFC6544Negotiation.java => RFC6455Negotiation.java} (96%) diff --git a/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/HTTP2Session.java b/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/HTTP2Session.java index d385acbdff1..89cadfa5ed9 100644 --- a/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/HTTP2Session.java +++ b/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/HTTP2Session.java @@ -97,6 +97,7 @@ public abstract class HTTP2Session extends ContainerLifeCycle implements ISessio private int initialSessionRecvWindow; private int writeThreshold; private boolean pushEnabled; + private boolean connectProtocolEnabled; private long idleTime; private GoAwayFrame closeFrame; @@ -370,6 +371,14 @@ public abstract class HTTP2Session extends ContainerLifeCycle implements ISessio generator.setMaxHeaderListSize(value); break; } + case SettingsFrame.ENABLE_CONNECT_PROTOCOL: + { + boolean enabled = value == 1; + if (LOG.isDebugEnabled()) + LOG.debug("{} CONNECT protocol for {}", enabled ? "Enabling" : "Disabling", this); + connectProtocolEnabled = enabled; + break; + } default: { if (LOG.isDebugEnabled()) @@ -906,6 +915,17 @@ public abstract class HTTP2Session extends ContainerLifeCycle implements ISessio return pushEnabled; } + @ManagedAttribute(value = "Whether CONNECT requests supports a protocol", readonly = true) + public boolean isConnectProtocolEnabled() + { + return connectProtocolEnabled; + } + + public void setConnectProtocolEnabled(boolean connectProtocolEnabled) + { + this.connectProtocolEnabled = connectProtocolEnabled; + } + /** * A typical close by a remote peer involves a GO_AWAY frame followed by TCP FIN. * This method is invoked when the TCP FIN is received, or when an exception is diff --git a/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/frames/SettingsFrame.java b/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/frames/SettingsFrame.java index 4a4e2d4247f..e030491ca19 100644 --- a/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/frames/SettingsFrame.java +++ b/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/frames/SettingsFrame.java @@ -30,6 +30,7 @@ public class SettingsFrame extends Frame public static final int INITIAL_WINDOW_SIZE = 4; public static final int MAX_FRAME_SIZE = 5; public static final int MAX_HEADER_LIST_SIZE = 6; + public static final int ENABLE_CONNECT_PROTOCOL = 8; private final Map settings; private final boolean reply; diff --git a/jetty-http2/http2-server/src/main/java/org/eclipse/jetty/http2/server/AbstractHTTP2ServerConnectionFactory.java b/jetty-http2/http2-server/src/main/java/org/eclipse/jetty/http2/server/AbstractHTTP2ServerConnectionFactory.java index 7f55001654a..62401bbb7ab 100644 --- a/jetty-http2/http2-server/src/main/java/org/eclipse/jetty/http2/server/AbstractHTTP2ServerConnectionFactory.java +++ b/jetty-http2/http2-server/src/main/java/org/eclipse/jetty/http2/server/AbstractHTTP2ServerConnectionFactory.java @@ -60,6 +60,7 @@ public abstract class AbstractHTTP2ServerConnectionFactory extends AbstractConne private int maxHeaderBlockFragment = 0; private int maxFrameLength = Frame.DEFAULT_MAX_LENGTH; private int maxSettingsKeys = SettingsFrame.DEFAULT_MAX_KEYS; + private boolean connectProtocolEnabled = true; private RateControl.Factory rateControlFactory = new WindowRateControl.Factory(20); private FlowControlStrategy.Factory flowControlStrategyFactory = () -> new BufferingFlowControlStrategy(0.5F); private long streamIdleTimeout; @@ -185,6 +186,17 @@ public abstract class AbstractHTTP2ServerConnectionFactory extends AbstractConne this.maxSettingsKeys = maxSettingsKeys; } + @ManagedAttribute("Whether CONNECT requests supports a protocol") + public boolean isConnectProtocolEnabled() + { + return connectProtocolEnabled; + } + + public void setConnectProtocolEnabled(boolean connectProtocolEnabled) + { + this.connectProtocolEnabled = connectProtocolEnabled; + } + /** * @return the factory that creates RateControl objects */ @@ -237,6 +249,7 @@ public abstract class AbstractHTTP2ServerConnectionFactory extends AbstractConne if (maxConcurrentStreams >= 0) settings.put(SettingsFrame.MAX_CONCURRENT_STREAMS, maxConcurrentStreams); settings.put(SettingsFrame.MAX_HEADER_LIST_SIZE, getHttpConfiguration().getRequestHeaderSize()); + settings.put(SettingsFrame.ENABLE_CONNECT_PROTOCOL, isConnectProtocolEnabled() ? 1 : 0); return settings; } @@ -259,6 +272,7 @@ public abstract class AbstractHTTP2ServerConnectionFactory extends AbstractConne session.setStreamIdleTimeout(streamIdleTimeout); session.setInitialSessionRecvWindow(getInitialSessionRecvWindow()); session.setWriteThreshold(getHttpConfiguration().getOutputBufferSize()); + session.setConnectProtocolEnabled(isConnectProtocolEnabled()); ServerParser parser = newServerParser(connector, session, getRateControlFactory().newRateControl(endPoint)); parser.setMaxFrameLength(getMaxFrameLength()); diff --git a/jetty-http2/http2-server/src/main/java/org/eclipse/jetty/http2/server/HTTP2ServerSession.java b/jetty-http2/http2-server/src/main/java/org/eclipse/jetty/http2/server/HTTP2ServerSession.java index b5ee20f1463..8b728dd984a 100644 --- a/jetty-http2/http2-server/src/main/java/org/eclipse/jetty/http2/server/HTTP2ServerSession.java +++ b/jetty-http2/http2-server/src/main/java/org/eclipse/jetty/http2/server/HTTP2ServerSession.java @@ -108,6 +108,16 @@ public class HTTP2ServerSession extends HTTP2Session implements ServerParser.Lis if (stream != null) { onStreamOpened(stream); + + if (metaData instanceof MetaData.ConnectRequest) + { + if (!isConnectProtocolEnabled() && ((MetaData.ConnectRequest)metaData).getProtocol() != null) + { + stream.reset(new ResetFrame(streamId, ErrorCode.PROTOCOL_ERROR.code), Callback.NOOP); + return; + } + } + stream.process(frame, Callback.NOOP); Stream.Listener listener = notifyNewStream(stream, frame); stream.setListener(listener); diff --git a/jetty-server/src/main/java/org/eclipse/jetty/server/session/Session.java b/jetty-server/src/main/java/org/eclipse/jetty/server/session/Session.java index 50656e17f40..6fe973e6ff1 100644 --- a/jetty-server/src/main/java/org/eclipse/jetty/server/session/Session.java +++ b/jetty-server/src/main/java/org/eclipse/jetty/server/session/Session.java @@ -378,7 +378,7 @@ public class Session implements SessionHandler.SessionIf try { HttpSessionEvent event = new HttpSessionEvent(this); - for (String name : _sessionData.getKeys()) + for (String name : _sessionData.getKeys()) { Object value = _sessionData.getAttribute(name); if (value instanceof HttpSessionActivationListener) diff --git a/jetty-websocket/jetty-websocket-tests/pom.xml b/jetty-websocket/jetty-websocket-tests/pom.xml index 371005bd234..99eca30543a 100644 --- a/jetty-websocket/jetty-websocket-tests/pom.xml +++ b/jetty-websocket/jetty-websocket-tests/pom.xml @@ -45,6 +45,18 @@ ${project.version} test + + org.eclipse.jetty + jetty-alpn-server + ${project.version} + test + + + org.eclipse.jetty + jetty-alpn-java-server + ${project.version} + test + org.eclipse.jetty.http2 http2-http-client-transport diff --git a/jetty-websocket/jetty-websocket-tests/src/test/java/org/eclipse/jetty/websocket/tests/WebSocketOverHTTP2Test.java b/jetty-websocket/jetty-websocket-tests/src/test/java/org/eclipse/jetty/websocket/tests/WebSocketOverHTTP2Test.java index 492b7c3afcc..84ae11d94d4 100644 --- a/jetty-websocket/jetty-websocket-tests/src/test/java/org/eclipse/jetty/websocket/tests/WebSocketOverHTTP2Test.java +++ b/jetty-websocket/jetty-websocket-tests/src/test/java/org/eclipse/jetty/websocket/tests/WebSocketOverHTTP2Test.java @@ -19,23 +19,32 @@ package org.eclipse.jetty.websocket.tests; import java.net.URI; +import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeUnit; import java.util.function.Function; +import org.eclipse.jetty.alpn.server.ALPNServerConnectionFactory; import org.eclipse.jetty.client.HttpClient; import org.eclipse.jetty.client.dynamic.HttpClientTransportDynamic; import org.eclipse.jetty.client.http.HttpClientConnectionFactory; +import org.eclipse.jetty.http2.ErrorCode; +import org.eclipse.jetty.http2.HTTP2Cipher; import org.eclipse.jetty.http2.client.HTTP2Client; import org.eclipse.jetty.http2.client.http.ClientConnectionFactoryOverHTTP2; +import org.eclipse.jetty.http2.server.AbstractHTTP2ServerConnectionFactory; import org.eclipse.jetty.http2.server.HTTP2CServerConnectionFactory; +import org.eclipse.jetty.http2.server.HTTP2ServerConnectionFactory; import org.eclipse.jetty.io.ClientConnectionFactory; import org.eclipse.jetty.io.ClientConnector; import org.eclipse.jetty.server.HttpConfiguration; import org.eclipse.jetty.server.HttpConnectionFactory; +import org.eclipse.jetty.server.SecureRequestCustomizer; import org.eclipse.jetty.server.Server; import org.eclipse.jetty.server.ServerConnector; +import org.eclipse.jetty.server.SslConnectionFactory; import org.eclipse.jetty.servlet.ServletContextHandler; import org.eclipse.jetty.servlet.ServletHolder; +import org.eclipse.jetty.util.ssl.SslContextFactory; import org.eclipse.jetty.util.thread.QueuedThreadPool; import org.eclipse.jetty.websocket.api.Session; import org.eclipse.jetty.websocket.api.StatusCode; @@ -44,9 +53,12 @@ import org.eclipse.jetty.websocket.server.JettyWebSocketServlet; import org.eclipse.jetty.websocket.server.JettyWebSocketServletFactory; import org.eclipse.jetty.websocket.server.config.JettyWebSocketServletContainerInitializer; import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.containsStringIgnoringCase; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; @@ -56,6 +68,7 @@ public class WebSocketOverHTTP2Test { private Server server; private ServerConnector connector; + private ServerConnector tlsConnector; @BeforeEach public void startServer() throws Exception @@ -63,12 +76,27 @@ public class WebSocketOverHTTP2Test QueuedThreadPool serverThreads = new QueuedThreadPool(); serverThreads.setName("server"); server = new Server(serverThreads); - HttpConfiguration httpConfiguration = new HttpConfiguration(); - HttpConnectionFactory h1 = new HttpConnectionFactory(httpConfiguration); - HTTP2CServerConnectionFactory h2c = new HTTP2CServerConnectionFactory(httpConfiguration); - connector = new ServerConnector(server, 1, 1, h1, h2c); + HttpConfiguration httpConfig = new HttpConfiguration(); + HttpConnectionFactory h1c = new HttpConnectionFactory(httpConfig); + HTTP2CServerConnectionFactory h2c = new HTTP2CServerConnectionFactory(httpConfig); + connector = new ServerConnector(server, 1, 1, h1c, h2c); server.addConnector(connector); + SslContextFactory.Server sslContextFactory = new SslContextFactory.Server(); + sslContextFactory.setKeyStorePath("src/test/resources/keystore.p12"); + sslContextFactory.setKeyStorePassword("storepwd"); + sslContextFactory.setCipherComparator(HTTP2Cipher.COMPARATOR); + + HttpConfiguration httpsConfig = new HttpConfiguration(httpConfig); + httpsConfig.addCustomizer(new SecureRequestCustomizer()); + HttpConnectionFactory h1s = new HttpConnectionFactory(httpsConfig); + HTTP2ServerConnectionFactory h2s = new HTTP2ServerConnectionFactory(httpsConfig); + ALPNServerConnectionFactory alpn = new ALPNServerConnectionFactory(); + alpn.setDefaultProtocol(h1c.getProtocol()); + SslConnectionFactory ssl = new SslConnectionFactory(sslContextFactory, alpn.getProtocol()); + tlsConnector = new ServerConnector(server, 1, 1, ssl, alpn, h2s, h1s); + server.addConnector(tlsConnector); + ServletContextHandler context = new ServletContextHandler(server, "/"); context.addServlet(new ServletHolder(new JettyWebSocketServlet() { @@ -128,4 +156,30 @@ public class WebSocketOverHTTP2Test assertEquals(StatusCode.NORMAL, wsEndPoint.statusCode); assertNull(wsEndPoint.error); } + + @Test + public void testConnectProtocolDisabled() throws Exception + { + AbstractHTTP2ServerConnectionFactory h2c = connector.getBean(AbstractHTTP2ServerConnectionFactory.class); + h2c.setConnectProtocolEnabled(false); + + ClientConnector clientConnector = new ClientConnector(); + QueuedThreadPool clientThreads = new QueuedThreadPool(); + clientThreads.setName("client"); + clientConnector.setExecutor(clientThreads); + HTTP2Client http2Client = new HTTP2Client(clientConnector); + HttpClient httpClient = new HttpClient(new HttpClientTransportDynamic(clientConnector, new ClientConnectionFactoryOverHTTP2.H2C(http2Client))); + + WebSocketClient wsClient = new WebSocketClient(httpClient); + wsClient.start(); + + EventSocket wsEndPoint = new EventSocket(); + URI uri = URI.create("ws://localhost:" + connector.getLocalPort() + "/ws/echo"); + + ExecutionException failure = Assertions.assertThrows(ExecutionException.class, () -> + wsClient.connect(wsEndPoint, uri).get(5, TimeUnit.SECONDS)); + + Throwable cause = failure.getCause(); + assertThat(cause.getMessage(), containsStringIgnoringCase(ErrorCode.PROTOCOL_ERROR.name())); + } } diff --git a/jetty-websocket/jetty-websocket-tests/src/test/resources/keystore.p12 b/jetty-websocket/jetty-websocket-tests/src/test/resources/keystore.p12 new file mode 100644 index 0000000000000000000000000000000000000000..b51c835024b001ff73c04030e2b9ad05406849a0 GIT binary patch literal 2533 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 literal 0 HcmV?d00001 diff --git a/jetty-websocket/websocket-core/src/main/java/org/eclipse/jetty/websocket/core/server/internal/AbstractHandshaker.java b/jetty-websocket/websocket-core/src/main/java/org/eclipse/jetty/websocket/core/server/internal/AbstractHandshaker.java index b11080af73e..fc8f1dbfe83 100644 --- a/jetty-websocket/websocket-core/src/main/java/org/eclipse/jetty/websocket/core/server/internal/AbstractHandshaker.java +++ b/jetty-websocket/websocket-core/src/main/java/org/eclipse/jetty/websocket/core/server/internal/AbstractHandshaker.java @@ -53,7 +53,7 @@ import org.eclipse.jetty.websocket.core.server.WebSocketNegotiator; public abstract class AbstractHandshaker implements Handshaker { - protected static final Logger LOG = Log.getLogger(RFC8441Handshaker.class); + protected static final Logger LOG = Log.getLogger(AbstractHandshaker.class); private static final HttpField SERVER_VERSION = new PreEncodedHttpField(HttpHeader.SERVER, HttpConfiguration.SERVER_VERSION); @Override @@ -98,7 +98,6 @@ public abstract class AbstractHandshaker implements Handshaker return false; } - // Validate negotiated protocol String protocol = negotiation.getSubprotocol(); List offeredProtocols = negotiation.getOfferedSubprotocols(); diff --git a/jetty-websocket/websocket-core/src/main/java/org/eclipse/jetty/websocket/core/server/internal/RFC6455Handshaker.java b/jetty-websocket/websocket-core/src/main/java/org/eclipse/jetty/websocket/core/server/internal/RFC6455Handshaker.java index f5398e0e491..7053def75d9 100644 --- a/jetty-websocket/websocket-core/src/main/java/org/eclipse/jetty/websocket/core/server/internal/RFC6455Handshaker.java +++ b/jetty-websocket/websocket-core/src/main/java/org/eclipse/jetty/websocket/core/server/internal/RFC6455Handshaker.java @@ -66,7 +66,7 @@ public final class RFC6455Handshaker extends AbstractHandshaker @Override protected Negotiation newNegotiation(HttpServletRequest request, HttpServletResponse response, WebSocketComponents webSocketComponents) { - return new RFC6544Negotiation(Request.getBaseRequest(request), request, response, webSocketComponents); + return new RFC6455Negotiation(Request.getBaseRequest(request), request, response, webSocketComponents); } @Override @@ -75,7 +75,7 @@ public final class RFC6455Handshaker extends AbstractHandshaker boolean result = super.validateNegotiation(negotiation); if (!result) return false; - if (((RFC6544Negotiation)negotiation).getKey() == null) + if (((RFC6455Negotiation)negotiation).getKey() == null) throw new BadMessageException("Missing request header 'Sec-WebSocket-Key'"); return true; } @@ -95,6 +95,6 @@ public final class RFC6455Handshaker extends AbstractHandshaker HttpFields responseFields = response.getHttpFields(); responseFields.put(UPGRADE_WEBSOCKET); responseFields.put(CONNECTION_UPGRADE); - responseFields.put(HttpHeader.SEC_WEBSOCKET_ACCEPT, WebSocketCore.hashKey(((RFC6544Negotiation)negotiation).getKey())); + responseFields.put(HttpHeader.SEC_WEBSOCKET_ACCEPT, WebSocketCore.hashKey(((RFC6455Negotiation)negotiation).getKey())); } } diff --git a/jetty-websocket/websocket-core/src/main/java/org/eclipse/jetty/websocket/core/server/internal/RFC6544Negotiation.java b/jetty-websocket/websocket-core/src/main/java/org/eclipse/jetty/websocket/core/server/internal/RFC6455Negotiation.java similarity index 96% rename from jetty-websocket/websocket-core/src/main/java/org/eclipse/jetty/websocket/core/server/internal/RFC6544Negotiation.java rename to jetty-websocket/websocket-core/src/main/java/org/eclipse/jetty/websocket/core/server/internal/RFC6455Negotiation.java index f836c9b7986..1703787ab75 100644 --- a/jetty-websocket/websocket-core/src/main/java/org/eclipse/jetty/websocket/core/server/internal/RFC6544Negotiation.java +++ b/jetty-websocket/websocket-core/src/main/java/org/eclipse/jetty/websocket/core/server/internal/RFC6455Negotiation.java @@ -29,12 +29,12 @@ import org.eclipse.jetty.server.Request; import org.eclipse.jetty.websocket.core.WebSocketComponents; import org.eclipse.jetty.websocket.core.server.Negotiation; -public class RFC6544Negotiation extends Negotiation +public class RFC6455Negotiation extends Negotiation { private boolean successful; private String key; - public RFC6544Negotiation(Request baseRequest, HttpServletRequest request, HttpServletResponse response, WebSocketComponents components) throws BadMessageException + public RFC6455Negotiation(Request baseRequest, HttpServletRequest request, HttpServletResponse response, WebSocketComponents components) throws BadMessageException { super(baseRequest, request, response, components); }