nitro/G-Earth
1
0
Fork 0
mirror of https://github.com/sirjonasxx/G-Earth.git synced 2024-11-23 00:40:51 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #149 from UnfamiliarLegacy/fix/nitro-ssl-2

Browse Source 
Disable SSL certificate validation for Nitro websocket connection
This commit is contained in:
sirjonasxx 2023-02-21 01:33:30 +01:00 committed by GitHub
commit 199fbed0dc
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 122 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
G-Earth/pom.xml
View File

@ -10,7 +10,7 @@
<properties>
<javafx.version>1.8</javafx.version>
<jettyVersion>9.4.48.v20220622</jettyVersion>
<jettyVersion>9.4.50.v20221201</jettyVersion>
<logback.version>1.3.5</logback.version>
</properties>
@ -238,14 +238,11 @@
<artifactId>maven-artifact</artifactId>
<version>3.6.3</version>
</dependency>
<dependency>
<groupId>javax.websocket</groupId>
<artifactId>javax.websocket-api</artifactId>
<version>1.1</version>
</dependency>
<dependency>
<groupId>org.eclipse.jetty</groupId>
<artifactId>jetty-server</artifactId>

2
G-Earth/src/main/java/gearth/protocol/connection/proxy/nitro/websocket/NitroSession.java
View File

@ -1,6 +1,6 @@
package gearth.protocol.connection.proxy.nitro.websocket;
import javax.websocket.Session;
import org.eclipse.jetty.websocket.api.Session;
public interface NitroSession {

3
G-Earth/src/main/java/gearth/protocol/connection/proxy/nitro/websocket/NitroWebsocketClient.java
View File

@ -50,6 +50,7 @@ public class NitroWebsocketClient implements NitroSession {
activeSession = (JsrSession) session;
activeSession.setMaxBinaryMessageBufferSize(NitroConstants.WEBSOCKET_BUFFER_SIZE);
activeSession.setMaxTextMessageBufferSize(NitroConstants.WEBSOCKET_BUFFER_SIZE);
// Set proper headers to spoof being a real client.
final Map<String, List<String>> headers = new HashMap<>(activeSession.getUpgradeRequest().getHeaders());
@ -94,7 +95,7 @@ public class NitroWebsocketClient implements NitroSession {
}
@Override
public Session getSession() {
public org.eclipse.jetty.websocket.api.Session getSession() {
return activeSession;
}

152
G-Earth/src/main/java/gearth/protocol/connection/proxy/nitro/websocket/NitroWebsocketServer.java
View File

@ -5,17 +5,28 @@ import gearth.protocol.HMessage;
import gearth.protocol.connection.proxy.nitro.NitroConstants;
import gearth.protocol.packethandler.PacketHandler;
import gearth.protocol.packethandler.nitro.NitroPacketHandler;
import org.eclipse.jetty.websocket.api.extensions.ExtensionConfig;
import org.eclipse.jetty.websocket.jsr356.JsrExtension;
import org.eclipse.jetty.client.HttpClient;
import org.eclipse.jetty.util.ssl.SslContextFactory;
import org.eclipse.jetty.websocket.api.Session;
import org.eclipse.jetty.websocket.api.WebSocketListener;
import org.eclipse.jetty.websocket.client.ClientUpgradeRequest;
import org.eclipse.jetty.websocket.client.WebSocketClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.websocket.*;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.IOException;
import java.net.URI;
import java.util.*;
import java.security.SecureRandom;
import java.security.cert.X509Certificate;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
public class NitroWebsocketServer extends Endpoint implements NitroSession {
public class NitroWebsocketServer implements WebSocketListener, NitroSession {
private static final Logger logger = LoggerFactory.getLogger(NitroWebsocketServer.class);
@ -39,66 +50,31 @@ public class NitroWebsocketServer extends Endpoint implements NitroSession {
public void connect(String websocketUrl, Map<String, List<String>> clientHeaders) throws IOException {
try {
logger.info("Connecting to origin websocket at {}", websocketUrl);
logger.info("Building origin websocket connection ({})", websocketUrl);
ClientEndpointConfig.Builder builder = ClientEndpointConfig.Builder.create();
final WebSocketClient client = createWebSocketClient();
builder.extensions(Collections.singletonList(new JsrExtension(new ExtensionConfig("permessage-deflate;client_max_window_bits"))));
final ClientUpgradeRequest request = new ClientUpgradeRequest();
builder.configurator(new ClientEndpointConfig.Configurator() {
@Override
public void beforeRequest(Map<String, List<String>> headers) {
clientHeaders.forEach((key, value) -> {
if (SKIP_HEADERS.contains(key)) {
return;
}
headers.remove(key);
headers.put(key, value);
});
}
request.setHeader(key, value);
});
ClientEndpointConfig config = builder.build();
logger.info("Connecting to origin websocket at {}", websocketUrl);
ContainerProvider.getWebSocketContainer().connectToServer(this, config, URI.create(websocketUrl));
client.start();
client.connect(this, URI.create(websocketUrl), request);
logger.info("Connected to origin websocket");
} catch (DeploymentException e) {
throw new IOException("Failed to deploy websocket client", e);
} catch (Exception e) {
throw new IOException("Failed to start websocket client to origin " + websocketUrl, e);
}
}
@Override
public void onOpen(Session session, EndpointConfig config) {
this.activeSession = session;
this.activeSession.setMaxBinaryMessageBufferSize(NitroConstants.WEBSOCKET_BUFFER_SIZE);
this.activeSession.addMessageHandler(new MessageHandler.Whole<byte[]>() {
@Override
public void onMessage(byte[] message) {
try {
packetHandler.act(message);
} catch (IOException e) {
e.printStackTrace();
}
}
});
}
@Override
public void onClose(Session session, CloseReason closeReason) {
// Hotel closed connection.
client.shutdownProxy();
}
@Override
public void onError(Session session, Throwable throwable) {
throwable.printStackTrace();
// Shutdown.
client.shutdownProxy();
}
@Override
public Session getSession() {
return activeSession;
@ -118,10 +94,86 @@ public class NitroWebsocketServer extends Endpoint implements NitroSession {
try {
activeSession.close();
} catch (IOException e) {
} catch (Exception e) {
e.printStackTrace();
} finally {
activeSession = null;
}
}
@Override
public void onWebSocketBinary(byte[] bytes, int i, int i1) {
try {
packetHandler.act(bytes);
} catch (IOException e) {
logger.error("Failed to handle packet", e);
}
}
@Override
public void onWebSocketText(String s) {
logger.warn("Received text message from hotel");
}
@Override
public void onWebSocketClose(int i, String s) {
// Hotel closed connection.
client.shutdownProxy();
}
@Override
public void onWebSocketConnect(org.eclipse.jetty.websocket.api.Session session) {
activeSession = session;
}
@Override
public void onWebSocketError(Throwable throwable) {
throwable.printStackTrace();
// Shutdown.
client.shutdownProxy();
}
private SSLContext createSSLContext() {
final TrustManager[] trustAllCerts = new TrustManager[]{new X509TrustManager() {
public X509Certificate[] getAcceptedIssuers() {
return new X509Certificate[0];
}
@Override
public void checkClientTrusted(X509Certificate[] certs, String authType) {
}
@Override
public void checkServerTrusted(X509Certificate[] certs, String authType) {
}
}};
try {
final SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(null, trustAllCerts, new SecureRandom());
return sslContext;
} catch (Exception e) {
throw new RuntimeException("Failed to setup ssl context", e);
}
}
private HttpClient createHttpClient() {
final SslContextFactory.Client factory = new SslContextFactory.Client();
factory.setSslContext(createSSLContext());
return new HttpClient(factory);
}
private WebSocketClient createWebSocketClient() {
final WebSocketClient client = new WebSocketClient(createHttpClient());
client.setMaxBinaryMessageBufferSize(NitroConstants.WEBSOCKET_BUFFER_SIZE);
client.setMaxTextMessageBufferSize(NitroConstants.WEBSOCKET_BUFFER_SIZE);
return client;
}
}

14
G-Earth/src/main/java/gearth/protocol/packethandler/nitro/NitroPacketHandler.java
View File

@ -6,13 +6,17 @@ import gearth.protocol.connection.proxy.nitro.websocket.NitroSession;
import gearth.protocol.packethandler.PacketHandler;
import gearth.protocol.packethandler.PayloadBuffer;
import gearth.services.extension_handler.ExtensionHandler;
import org.eclipse.jetty.websocket.api.Session;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.websocket.Session;
import java.io.IOException;
import java.nio.ByteBuffer;
public class NitroPacketHandler extends PacketHandler {
private static final Logger logger = LoggerFactory.getLogger(NitroPacketHandler.class);
private final HMessage.Direction direction;
private final NitroSession session;
private final PayloadBuffer payloadBuffer;
@ -39,7 +43,13 @@ public class NitroPacketHandler extends PacketHandler {
buffer = buffer.clone();
}
localSession.getAsyncRemote().sendBinary(ByteBuffer.wrap(buffer));
try {
localSession.getRemote().sendBytes(ByteBuffer.wrap(buffer));
} catch (IOException e) {
logger.error("Error sending packet to nitro client", e);
return false;
}
return true;
}