From a0d246a0bff0c0115a8bc18d377999d0be4050b3 Mon Sep 17 00:00:00 2001 From: wujiawei <12345678> Date: Fri, 20 Sep 2024 17:21:49 +0800 Subject: [PATCH] [fix] --- .../config/HeartbeatClientConfiguration.java | 10 +- ...annelConnectionSuccessfulTypeAdvanced.java | 49 ++++ ...teSingleClientRealConnectTypeAdvanced.java | 4 +- ... NettyClientPermeateClientRealFilter.java} | 10 +- ...ettyClientPermeateClientVisitorFilter.java | 37 +++ .../NettyServerPermeateClientRealFilter.java | 27 ++ ...NettyClientPermeateClientRealHandler.java} | 2 +- ...ttyClientPermeateClientVisitorHandler.java | 181 ++++++++++++ .../NettyServerPermeateClientRealHandler.java | 98 +++++++ .../NettyClientPermeateClientRealSocket.java | 89 ++++++ ...ettyClientPermeateClientVisitorSocket.java | 274 ++++++++++++++++++ .../NettyClientTransferClientSocket.java | 113 ++++++++ ... NettyServerPermeateClientRealSocket.java} | 6 +- .../network/heartbeat/common/MessageType.java | 20 +- ...annelConnectionSuccessfulTypeAdvanced.java | 28 ++ ...annelConnectionSuccessfulTypeAdvanced.java | 27 ++ .../common/enums/MessageTypeEnums.java | 9 + ...annelConnectionSuccessfulTypeAdvanced.java | 48 +++ 18 files changed, 1017 insertions(+), 15 deletions(-) create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java rename wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/{NettyClientRealFilter.java => NettyClientPermeateClientRealFilter.java} (76%) create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyClientPermeateClientVisitorFilter.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyServerPermeateClientRealFilter.java rename wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/{NettyClientRealHandler.java => NettyClientPermeateClientRealHandler.java} (97%) create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientPermeateClientVisitorHandler.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyServerPermeateClientRealHandler.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyClientPermeateClientRealSocket.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyClientPermeateClientVisitorSocket.java create mode 100644 wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyClientTransferClientSocket.java rename wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/{NettyClientRealSocket.java => NettyServerPermeateClientRealSocket.java} (98%) create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/client/AbstractHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/server/AbstractHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/advanced/ServerHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/config/HeartbeatClientConfiguration.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/config/HeartbeatClientConfiguration.java index 615b60b..d865a6d 100644 --- a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/config/HeartbeatClientConfiguration.java +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/config/HeartbeatClientConfiguration.java @@ -55,7 +55,15 @@ public class HeartbeatClientConfiguration { return new ClientHandleDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced(); } - + /** + * 处理 客户端渗透客户端数据传输通道连接成功 + * + * @return ClientHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced + */ + @Bean + public ClientHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced clientHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced() { + return new ClientHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced(); + } @Bean public ClientHandleDistributeSingleClientRealCloseVisitorTypeAdvanced handleDistributeSingleClientRealCloseVisitorTypeAdvanced() { return new ClientHandleDistributeSingleClientRealCloseVisitorTypeAdvanced(); diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java new file mode 100644 index 0000000..e1b441d --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java @@ -0,0 +1,49 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced; + + +import io.netty.channel.Channel; +import io.netty.channel.ChannelOption; +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyClientPermeateServerVisitorHandler; +import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientPermeateClientRealSocket; +import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientTransferServerSocket; +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.NettyRealIdContext; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.client.AbstractHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.client.AbstractHandleDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; +import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; + + +/** + * 客户端渗透客户端数据传输通道连接成功 + * + * + * @see MessageTypeEnums#DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL + */ +@Slf4j +public class ClientHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced extends AbstractHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced { + + + + /** + * 处理当前数据 + * + * @param channel 当前通道 + * @param nettyProxyMsg 通道数据 + */ + @Override + public void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) { + // 连接成功 开启自动读取写 + // 创建connect 然后发送创建成功 + byte[] msgClientId = nettyProxyMsg.getClientId(); + byte[] msgClientTargetIp = nettyProxyMsg.getClientTargetIp(); + byte[] msgClientTargetPort = nettyProxyMsg.getClientTargetPort(); + byte[] msgVisitorId = nettyProxyMsg.getVisitorId(); + byte[] msgVisitorPort = nettyProxyMsg.getVisitorPort(); + + NettyClientPermeateClientRealSocket.buildRealServer(); + + } + +} diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleDistributeSingleClientRealConnectTypeAdvanced.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleDistributeSingleClientRealConnectTypeAdvanced.java index f5e81bd..f3b2b2e 100644 --- a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleDistributeSingleClientRealConnectTypeAdvanced.java +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleDistributeSingleClientRealConnectTypeAdvanced.java @@ -3,7 +3,7 @@ package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced; import io.netty.channel.Channel; import lombok.extern.slf4j.Slf4j; import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties; -import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientRealSocket; +import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyServerPermeateClientRealSocket; import org.framework.lazy.cloud.network.heartbeat.common.InternalNetworkPenetrationRealClient; import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; @@ -50,7 +50,7 @@ public class ClientHandleDistributeSingleClientRealConnectTypeAdvanced extends A .build(); // 绑定真实服务端口 - NettyClientRealSocket.buildRealServer(internalNetworkPenetrationRealClient, nettyClientProperties, handleChannelTypeAdvancedList); + NettyServerPermeateClientRealSocket.buildRealServer(internalNetworkPenetrationRealClient, nettyClientProperties, handleChannelTypeAdvancedList); } } diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyClientRealFilter.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyClientPermeateClientRealFilter.java similarity index 76% rename from wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyClientRealFilter.java rename to wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyClientPermeateClientRealFilter.java index e896314..c3f3e48 100644 --- a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyClientRealFilter.java +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyClientPermeateClientRealFilter.java @@ -1,17 +1,15 @@ package org.framework.lazy.cloud.network.heartbeat.client.netty.filter; import io.netty.channel.Channel; -import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelPipeline; import io.netty.channel.socket.SocketChannel; -import io.netty.handler.codec.compression.JdkZlibDecoder; -import io.netty.handler.codec.compression.JdkZlibEncoder; -import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyClientRealHandler; +import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyClientPermeateClientRealHandler; +import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyServerPermeateClientRealHandler; import org.framework.lazy.cloud.network.heartbeat.common.decoder.TransferDecoder; import org.framework.lazy.cloud.network.heartbeat.common.encoder.TransferEncoder; import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer; -public class NettyClientRealFilter extends DebugChannelInitializer { +public class NettyClientPermeateClientRealFilter extends DebugChannelInitializer { /** * This method will be called once the {@link Channel} was registered. After the method returns this instance * will be removed from the {@link ChannelPipeline} of the {@link Channel}. @@ -24,7 +22,7 @@ public class NettyClientRealFilter extends DebugChannelInitializer { + + private final InternalNetworkPermeateServerVisitor internalNetworkPermeateServerVisitor; + + public NettyClientPermeateClientVisitorFilter(InternalNetworkPermeateServerVisitor internalNetworkPermeateServerVisitor) { + this.internalNetworkPermeateServerVisitor = internalNetworkPermeateServerVisitor; + + } + + /** + * This method will be called once the {@link Channel} was registered. After the method returns this instance + * will be removed from the {@link ChannelPipeline} of the {@link Channel}. + * + * @param ch the {@link Channel} which was registered. + * @throws Exception is thrown if an error occurs. In that case it will be handled by + * {@link #exceptionCaught(ChannelHandlerContext, Throwable)} which will by default connectionClose + * the {@link Channel}. + */ + @Override + protected void initChannel0(SocketChannel ch) throws Exception { + ChannelPipeline pipeline = ch.pipeline(); + pipeline.addLast(new ChannelDuplexHandler()); + pipeline.addLast(new NettyClientPermeateClientVisitorHandler(internalNetworkPermeateServerVisitor)); + } +} diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyServerPermeateClientRealFilter.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyServerPermeateClientRealFilter.java new file mode 100644 index 0000000..e4c8ed7 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyServerPermeateClientRealFilter.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.filter; + +import io.netty.channel.Channel; +import io.netty.channel.ChannelPipeline; +import io.netty.channel.socket.SocketChannel; +import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyServerPermeateClientRealHandler; +import org.framework.lazy.cloud.network.heartbeat.common.decoder.TransferDecoder; +import org.framework.lazy.cloud.network.heartbeat.common.encoder.TransferEncoder; +import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer; + +public class NettyServerPermeateClientRealFilter extends DebugChannelInitializer { + /** + * This method will be called once the {@link Channel} was registered. After the method returns this instance + * will be removed from the {@link ChannelPipeline} of the {@link Channel}. + * + * @param ch the {@link Channel} which was registered. + */ + @Override + protected void initChannel0(SocketChannel ch) { + ChannelPipeline pipeline = ch.pipeline(); + // 解码、编码 + pipeline.addLast(new TransferDecoder(Integer.MAX_VALUE, 1024 * 1024*10)); + pipeline.addLast(new TransferEncoder()); + pipeline.addLast(new NettyServerPermeateClientRealHandler()); + + } +} diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientRealHandler.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientPermeateClientRealHandler.java similarity index 97% rename from wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientRealHandler.java rename to wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientPermeateClientRealHandler.java index a7fafb6..1db3044 100644 --- a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientRealHandler.java +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientPermeateClientRealHandler.java @@ -17,7 +17,7 @@ import org.wu.framework.core.utils.ObjectUtils; * 来自客户端 真实服务器返回的数据请求 */ @Slf4j -public class NettyClientRealHandler extends SimpleChannelInboundHandler { +public class NettyClientPermeateClientRealHandler extends SimpleChannelInboundHandler { @Override diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientPermeateClientVisitorHandler.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientPermeateClientVisitorHandler.java new file mode 100644 index 0000000..6f451c7 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientPermeateClientVisitorHandler.java @@ -0,0 +1,181 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.handler; + + +import io.netty.buffer.ByteBuf; +import io.netty.channel.Channel; +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.ChannelOption; +import io.netty.channel.SimpleChannelInboundHandler; +import io.netty.util.internal.StringUtil; +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.client.netty.InternalNetworkPermeateServerVisitor; +import org.framework.lazy.cloud.network.heartbeat.client.netty.advanced.ClientHandleDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientTransferClientSocket; +import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientTransferServerSocket; +import org.framework.lazy.cloud.network.heartbeat.common.MessageType; +import org.framework.lazy.cloud.network.heartbeat.common.NettyCommunicationIdContext; +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.NettyRealIdContext; +import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; +import org.wu.framework.core.utils.ObjectUtils; + +import java.util.UUID; + +@Slf4j +public class NettyClientPermeateClientVisitorHandler extends SimpleChannelInboundHandler { + private final InternalNetworkPermeateServerVisitor internalNetworkPermeateServerVisitor; +// private final NettyChannelPool nettyChannelPool = new DefaultNettyChannelPool(10); + + public NettyClientPermeateClientVisitorHandler(InternalNetworkPermeateServerVisitor internalNetworkPermeateServerVisitor) { + this.internalNetworkPermeateServerVisitor = internalNetworkPermeateServerVisitor; + } + + /** + * @param ctx + * @throws Exception + * @see NettyClientTransferServerSocket + * @see ClientHandleDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced + */ + @Override + public void channelActive(ChannelHandlerContext ctx) throws Exception { + // 访客连接上代理服务器了 + Channel visitorChannel = ctx.channel(); + // 先不读取访客数据 + visitorChannel.config().setOption(ChannelOption.AUTO_READ, false); + + + // 生成访客ID + String visitorId = UUID.randomUUID().toString(); + // 绑定访客真实通道 + NettyRealIdContext.pushReal(visitorChannel, visitorId); + // 当前通道绑定访客ID + ChannelAttributeKeyUtils.buildVisitorId(visitorChannel, visitorId); + + internalNetworkPermeateServerVisitor.setVisitorId(visitorId); + // 判断是否有可用的通道 如果没有创建新的通道 +// Channel transferChannel = nettyChannelPool.availableChannel(visitorId); + // 创建访客连接服务端通道 + NettyClientTransferClientSocket.buildTransferServer(internalNetworkPermeateServerVisitor); + log.info("客户端渗透服务端访客端口连接成功了"); + super.channelActive(ctx); + } + + @Override + public void channelRead0(ChannelHandlerContext ctx, ByteBuf buf) { + + // 访客通道 + Channel visitorChannel = ctx.channel(); + + String visitorId = ChannelAttributeKeyUtils.getVisitorId(visitorChannel); + Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(visitorChannel); + byte[] bytes = new byte[buf.readableBytes()]; + buf.readBytes(bytes); + // 获取客户端通道，而后进行数据下发 + log.debug("【客户端渗透服务端】访客端口成功接收数据:{}", new String(bytes)); + + // 使用访客的通信通道 + Integer visitorPort = internalNetworkPermeateServerVisitor.getVisitorPort(); + NettyProxyMsg nettyProxyMsg = new NettyProxyMsg(); + nettyProxyMsg.setType(MessageType.REPORT_CLIENT_TRANSFER); + nettyProxyMsg.setVisitorId(visitorId); + nettyProxyMsg.setVisitorPort(visitorPort); + nettyProxyMsg.setData(bytes); + nextChannel.writeAndFlush(nettyProxyMsg); + // 处理访客流量 +// ServerChannelFlow serverChannelFlow = ServerChannelFlow +// .builder() +// .channelFlowEnum(ChannelFlowEnum.IN_FLOW) +// .port(visitorPort) +// .clientId(clientId) +// .flow(bytes.length) +// .build(); +// channelFlowAdapter.asyncHandler(visitorChannel, serverChannelFlow); + log.debug("【客户端渗透服务端】访客端口成功发送数据了"); + } + + @Override + public void channelInactive(ChannelHandlerContext ctx) throws Exception { + Channel channel = ctx.channel(); + String visitorId = ChannelAttributeKeyUtils.getVisitorId(channel); + String clientId = ChannelAttributeKeyUtils.getClientId(channel); + if (StringUtil.isNullOrEmpty(visitorId)) { + super.channelInactive(ctx); + return; + } + Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(channel); + // 通信通道自动读写打开 ，然后关闭通信通道 + + if (nextChannel != null && nextChannel.isActive()) { + + nextChannel.config().setOption(ChannelOption.AUTO_READ, true); + + // 通知服务端 关闭访问通道、真实通道 + NettyProxyMsg myMsg = new NettyProxyMsg(); + myMsg.setType(MessageType.DISTRIBUTE_SINGLE_CLIENT_REAL_CLOSE_VISITOR); + myMsg.setVisitorId(visitorId); + nextChannel.writeAndFlush(myMsg); + } + // 关闭 访客通信通道、访客真实通道 + NettyRealIdContext.clear(visitorId); + NettyCommunicationIdContext.clear(visitorId); + log.warn("【客户端渗透服务端】访客端口断开连接"); + super.channelInactive(ctx); + } + + @Override + public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception { + + // 获取访客的传输通道 + String visitorId = ChannelAttributeKeyUtils.getVisitorId(ctx.channel()); + if(ObjectUtils.isEmpty(visitorId)) { + super.channelWritabilityChanged(ctx); + return; + } + + Channel visitorCommunicationChannel = NettyCommunicationIdContext.getVisitor(visitorId); + if (visitorCommunicationChannel != null) { + log.debug("visitorId:{} transfer AUTO_READ:{} ",visitorId,ctx.channel().isWritable()); + visitorCommunicationChannel.config().setOption(ChannelOption.AUTO_READ, ctx.channel().isWritable()); + } + // Channel visitorChannel = ctx.channel(); + // String vid = visitorChannel.attr(Constant.VID).get(); + // if (StringUtil.isNullOrEmpty(vid)) { + // super.channelWritabilityChanged(ctx); + // return; + // } + // Channel clientChannel = Constant.vcc.get(vid); + // if (clientChannel != null) { + // clientChannel.config().setOption(ChannelOption.AUTO_READ, visitorChannel.isWritable()); + // } + if (ctx.channel().isWritable()) { + log.debug("Channel is writable again"); + // 恢复之前暂停的操作，如写入数据 + } else { + log.debug("Channel is not writable"); + // 暂停写入操作，等待可写状态 + } + log.info("visitorId:{} channelWritabilityChanged!",visitorId); + } + + @Override + public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { + log.error("exceptionCaught"); + + Channel channel = ctx.channel(); + String clientId = ChannelAttributeKeyUtils.getClientId(channel); + String visitorId = ChannelAttributeKeyUtils.getVisitorId(channel); + // 使用通信通道 下发关闭访客 + Channel visitorChannel = NettyCommunicationIdContext.getVisitor(visitorId); + Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(ctx.channel()); + if (nextChannel != null) { + // 下发关闭访客 + NettyProxyMsg closeRealClient = new NettyProxyMsg(); + closeRealClient.setType(MessageType.DISTRIBUTE_SINGLE_CLIENT_REAL_CONNECT_AUTO_READ); + closeRealClient.setClientId(clientId); + closeRealClient.setVisitorId(visitorId); + nextChannel.writeAndFlush(closeRealClient); + } + + ctx.close(); + } +} \ No newline at end of file diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyServerPermeateClientRealHandler.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyServerPermeateClientRealHandler.java new file mode 100644 index 0000000..8226f73 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyServerPermeateClientRealHandler.java @@ -0,0 +1,98 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.handler; + + +import io.netty.channel.Channel; +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.ChannelOption; +import io.netty.channel.SimpleChannelInboundHandler; +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.common.MessageType; +import org.framework.lazy.cloud.network.heartbeat.common.NettyByteBuf; +import org.framework.lazy.cloud.network.heartbeat.common.NettyCommunicationIdContext; +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; +import org.wu.framework.core.utils.ObjectUtils; + +/** + * 来自客户端 真实服务器返回的数据请求 + */ +@Slf4j +public class NettyServerPermeateClientRealHandler extends SimpleChannelInboundHandler { + + + @Override + public void channelRead0(ChannelHandlerContext ctx,NettyByteBuf nettyByteBuf) { + + byte[] bytes = nettyByteBuf.getData(); + log.debug("bytes.length:{}",bytes.length); + log.debug("接收客户端真实服务数据:{}", new String(bytes)); + String visitorId = ChannelAttributeKeyUtils.getVisitorId(ctx.channel()); + Integer visitorPort = ChannelAttributeKeyUtils.getVisitorPort(ctx.channel()); + String clientId = ChannelAttributeKeyUtils.getClientId(ctx.channel()); + // 访客通信通道 上报服务端代理完成 + Channel visitorChannel = NettyCommunicationIdContext.getVisitor(visitorId); + NettyProxyMsg returnMessage = new NettyProxyMsg(); + returnMessage.setType(MessageType.REPORT_CLIENT_TRANSFER); + returnMessage.setVisitorId(visitorId); + returnMessage.setClientId(clientId); + returnMessage.setVisitorPort(visitorPort); + returnMessage.setData(bytes); + + visitorChannel.writeAndFlush(returnMessage); + } + + + @Override + public void channelActive(ChannelHandlerContext ctx) throws Exception { + super.channelActive(ctx); + } + + @Override + public void channelInactive(ChannelHandlerContext ctx) throws Exception { + String clientId = ChannelAttributeKeyUtils.getClientId(ctx.channel()); + String visitorId = ChannelAttributeKeyUtils.getVisitorId(ctx.channel()); + // 客户端真实通信通道 + Channel visitor = NettyCommunicationIdContext.getVisitor(visitorId); + if (visitor != null) { + // 上报关闭这个客户端的访客通道 + NettyProxyMsg closeVisitorMsg = new NettyProxyMsg(); + closeVisitorMsg.setType(MessageType.REPORT_SINGLE_CLIENT_CLOSE_VISITOR); + closeVisitorMsg.setVisitorId(visitorId); + visitor.writeAndFlush(closeVisitorMsg); + } + + super.channelInactive(ctx); + } + + @Override + public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception { + +// String vid = ctx.channel().attr(Constant.VID).get(); +// if (StringUtil.isNullOrEmpty(vid)) { +// super.channelWritabilityChanged(ctx); +// return; +// } +// Channel proxyChannel = Constant.vpc.get(vid); +// if (proxyChannel != null) { +// proxyChannel.config().setOption(ChannelOption.AUTO_READ, ctx.channel().isWritable()); +// } + + // 获取访客的传输通道 + String visitorId = ChannelAttributeKeyUtils.getVisitorId(ctx.channel()); + if(ObjectUtils.isEmpty(visitorId)) { + super.channelWritabilityChanged(ctx); + return; + } + Channel visitorCommunicationChannel = NettyCommunicationIdContext.getVisitor(visitorId); + if (visitorCommunicationChannel != null) { + log.debug("visitorId:{} transfer AUTO_READ:{} ",visitorId,ctx.channel().isWritable()); + visitorCommunicationChannel.config().setOption(ChannelOption.AUTO_READ, ctx.channel().isWritable()); + } + + } + + @Override + public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { + super.exceptionCaught(ctx, cause); + } +} \ No newline at end of file diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyClientPermeateClientRealSocket.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyClientPermeateClientRealSocket.java new file mode 100644 index 0000000..65eb532 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyClientPermeateClientRealSocket.java @@ -0,0 +1,89 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.socket; + + +import io.netty.bootstrap.Bootstrap; +import io.netty.channel.*; +import io.netty.channel.nio.NioEventLoopGroup; +import io.netty.channel.socket.nio.NioSocketChannel; +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties; +import org.framework.lazy.cloud.network.heartbeat.client.netty.filter.NettyClientPermeateClientRealFilter; +import org.framework.lazy.cloud.network.heartbeat.client.netty.filter.NettyClientVisitorRealFilter; +import org.framework.lazy.cloud.network.heartbeat.client.netty.filter.NettyServerPermeateClientRealFilter; +import org.framework.lazy.cloud.network.heartbeat.common.*; +import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; + +import java.util.List; +import java.util.concurrent.TimeUnit; + +/** + * 客户端连接真实服务 + */ +@Slf4j +public class NettyClientPermeateClientRealSocket { + static EventLoopGroup eventLoopGroup = new NioEventLoopGroup(); + + + /** + * @param internalNetworkPenetrationRealClient 访客信息 + * @param nettyClientProperties 服务端地址信息 + */ + public static void buildRealServer(InternalNetworkPenetrationRealClient internalNetworkPenetrationRealClient, + NettyClientProperties nettyClientProperties, + List handleChannelTypeAdvancedList) { + try { + String clientId = internalNetworkPenetrationRealClient.getClientId(); + String clientTargetIp = internalNetworkPenetrationRealClient.getClientTargetIp(); + Integer clientTargetPort = internalNetworkPenetrationRealClient.getClientTargetPort(); + Integer visitorPort = internalNetworkPenetrationRealClient.getVisitorPort(); + String visitorId = internalNetworkPenetrationRealClient.getVisitorId(); + Bootstrap bootstrap = new Bootstrap(); + bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class) +// 设置读缓冲区为2M + .option(ChannelOption.SO_RCVBUF, 2048 * 1024) +// 设置写缓冲区为1M + .option(ChannelOption.SO_SNDBUF, 1024 * 1024) +// .option(ChannelOption.TCP_NODELAY, false) + .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 1000 * 60)//连接超时时间设置为 60 秒 +// .option(ChannelOption.SO_BACKLOG, 128)//务端接受连接的队列长度 默认128 +// .option(ChannelOption.RCVBUF_ALLOCATOR, new NettyRecvByteBufAllocator(1024 * 1024))//用于Channel分配接受Buffer的分配器 默认AdaptiveRecvByteBufAllocator.DEFAULT + .option(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2)) + .handler(new NettyClientPermeateClientRealFilter()) + + ; + + + bootstrap.connect(clientTargetIp, clientTargetPort).addListener((ChannelFutureListener) future -> { + if (future.isSuccess()) { + // 客户端链接真实服务成功 设置自动读写false 等待访客连接成功后设置成true + Channel realChannel = future.channel(); + realChannel.config().setOption(ChannelOption.AUTO_READ, false); + + log.info("访客通过 客户端:【{}】,绑定本地服务,IP:{},端口:{} 新建通道成功", clientId, clientTargetIp, clientTargetPort); + // 客户端真实通道 + NettyRealIdContext.pushReal(realChannel, visitorId); + // 绑定访客ID到当前真实通道属性 + ChannelAttributeKeyUtils.buildVisitorId(realChannel, visitorId); + ChannelAttributeKeyUtils.buildClientId(realChannel, clientId); + ChannelAttributeKeyUtils.buildVisitorPort(realChannel, visitorPort); + // 通知服务端访客连接成功 + + + + // 是否等 服务端相应访客通道已经可以自动读写 +// realChannel.config().setOption(ChannelOption.AUTO_READ, true); + + } else { + log.error("客户：【{}】,无法连接当前网络内的目标IP：【{}】,目标端口:【{}】", clientId, clientTargetIp, clientTargetPort); + } + }); + } catch (Exception e) { + e.printStackTrace(); + } + } + + + +} \ No newline at end of file diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyClientPermeateClientVisitorSocket.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyClientPermeateClientVisitorSocket.java new file mode 100644 index 0000000..863a591 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyClientPermeateClientVisitorSocket.java @@ -0,0 +1,274 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.socket; + +import io.netty.bootstrap.ServerBootstrap; +import io.netty.channel.*; +import io.netty.channel.nio.NioEventLoopGroup; +import io.netty.channel.socket.nio.NioServerSocketChannel; +import lombok.Getter; +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties; +import org.framework.lazy.cloud.network.heartbeat.client.netty.InternalNetworkPermeateServerVisitor; +import org.framework.lazy.cloud.network.heartbeat.client.netty.filter.NettyClientPermeateClientVisitorFilter; +import org.framework.lazy.cloud.network.heartbeat.client.netty.filter.NettyClientPermeateServerVisitorFilter; +import org.framework.lazy.cloud.network.heartbeat.common.NettyClientVisitorContext; +import org.framework.lazy.cloud.network.heartbeat.common.NettyVisitorPortContext; +import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelFlowAdapter; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.socket.PermeateVisitorSocket; + +import java.util.List; + +/** + * 内网穿透 客户端渗透客户端通道 + * + * @see NettyVisitorPortContext + * @see NettyClientVisitorContext + */ +@Slf4j +public class NettyClientPermeateClientVisitorSocket implements PermeateVisitorSocket { + private final EventLoopGroup bossGroup = new NioEventLoopGroup(); + private final EventLoopGroup workerGroup = new NioEventLoopGroup(); + private final NettyClientPermeateClientVisitorFilter nettyClientPermeateClientVisitorFilter; + @Getter + private final String clientId; + @Getter + private final int visitorPort; + + public NettyClientPermeateClientVisitorSocket(NettyClientPermeateClientVisitorFilter nettyClientPermeateClientVisitorFilter, String clientId, int visitorPort) { + this.nettyClientPermeateClientVisitorFilter = nettyClientPermeateClientVisitorFilter; + this.clientId = clientId; + this.visitorPort = visitorPort; + } + + /** + * 启动客户端本地端口渗透到服务端端口 + * + */ + @Override + public void start() { + + Channel visitor = NettyVisitorPortContext.getVisitorChannel(visitorPort); + if (visitor == null) { + ServerBootstrap bootstrap = new ServerBootstrap(); + bootstrap + .group(bossGroup, workerGroup) + .channel(NioServerSocketChannel.class) + + + // 设置读缓冲区为2M + .childOption(ChannelOption.SO_RCVBUF, 2048 * 1024) + // 设置写缓冲区为1M + .childOption(ChannelOption.SO_SNDBUF, 1024 * 1024) + + + .childOption(ChannelOption.SO_KEEPALIVE, true) +// .childOption(ChannelOption.TCP_NODELAY, false) + .childOption(ChannelOption.CONNECT_TIMEOUT_MILLIS, 1000 * 60)//连接超时时间设置为 60 秒 +// .childOption(ChannelOption.RCVBUF_ALLOCATOR, new NettyRecvByteBufAllocator(1024 * 1024))//用于Channel分配接受Buffer的分配器 默认 AdaptiveRecvByteBufAllocator.DEFAULT + .childOption(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2)) + + + .childHandler(nettyClientPermeateClientVisitorFilter); + + try { + bootstrap.bind(visitorPort).sync().addListener((ChannelFutureListener) future -> { + if (future.isSuccess()) { + // 这里时异步处理 + log.info("客户端:[{}]访客端口:[{}] 开启", clientId, visitorPort); + NettyVisitorPortContext.pushVisitorChannel(visitorPort, future.channel()); + + } else { + log.error("客户端:[{}]访客端口:[{}]绑定失败", clientId, visitorPort); + } + }); + NettyVisitorPortContext.pushVisitorSocket(visitorPort, this); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + } else { + log.warn("客户端渗透服务端:[{}]访客端口:[{}] 重复启动", clientId, visitorPort); + } + + } + @Override + public void close() { + if (!bossGroup.isShutdown()) { + bossGroup.shutdownGracefully(); + } + if (!workerGroup.isShutdown()) { + workerGroup.shutdownGracefully(); + } + Channel visitor = NettyVisitorPortContext.getVisitorChannel(visitorPort); + if (visitor != null) { + + // close channel + visitor.close(); + // remove visitor + NettyVisitorPortContext.removeVisitorChannel(visitorPort); + // remove client this + NettyVisitorPortContext.removeVisitorSocket(visitorPort); + log.warn("关闭客户端 :【{}】 访客户端口:【{}】", clientId, visitorPort); + } else { + log.warn("关闭访客端口失败 未找到客户端通道 客户端 :【{}】 访客户端口:【{}】", clientId, visitorPort); + } + } + + + public static final class NettyVisitorSocketBuilder { + + /** + * 客户端ID + */ + private String clientId; + + /** + * 客户端目标地址 + */ + private String clientTargetIp; + + /** + * 客户端目标端口 + */ + private Integer clientTargetPort; + + + /** + * 访问端口 + */ + private Integer visitorPort; + /** + * 访客ID + */ + private String visitorId; + + /** + * 流量适配器 + */ + private ChannelFlowAdapter channelFlowAdapter; + /** + * 服务端地址信息 + */ + private NettyClientProperties nettyClientProperties; + + /** + * 处理器 + */ + private List handleChannelTypeAdvancedList; + + public static NettyVisitorSocketBuilder builder() { + return new NettyVisitorSocketBuilder(); + } + + /** + * 填充客户端 + * + * @param clientId 客户端 + * @return 返回当前对象 + */ + public NettyVisitorSocketBuilder builderClientId(String clientId) { + this.clientId = clientId; + return this; + } + + /** + * 绑定客户端目标IP + * + * @param clientTargetIp 客户端目标IP + * @return 当前对象 + */ + public NettyVisitorSocketBuilder builderClientTargetIp(String clientTargetIp) { + this.clientTargetIp = clientTargetIp; + return this; + } + + /** + * 绑定客户端目标端口 + * + * @param clientTargetPort 客户端目标端口 + * @return 当前对象 + */ + public NettyVisitorSocketBuilder builderClientTargetPort(Integer clientTargetPort) { + this.clientTargetPort = clientTargetPort; + return this; + } + + /** + * 绑定访客端口 + * + * @param visitorPort 访客端口 + * @return 当前对象 + */ + public NettyVisitorSocketBuilder builderVisitorPort(Integer visitorPort) { + this.visitorPort = visitorPort; + return this; + } + + /** + * 绑定流量适配器 + * + * @param channelFlowAdapter 流量适配器 + * @return 当前对象 + */ + public NettyVisitorSocketBuilder builderChannelFlowAdapter(ChannelFlowAdapter channelFlowAdapter) { + this.channelFlowAdapter = channelFlowAdapter; + return this; + } /** + * 绑定流量适配器 + * + * @param handleChannelTypeAdvancedList 流量适配器 + * @return 当前对象 + */ + public NettyVisitorSocketBuilder builderHandleChannelTypeAdvancedList(List handleChannelTypeAdvancedList) { + this.handleChannelTypeAdvancedList = handleChannelTypeAdvancedList; + return this; + } + /** + * 服务端地址信息 + * + * @param nettyClientProperties 客户服务端地址配置属性 + * @return 返回当前对象 + */ + public NettyVisitorSocketBuilder builderNettyClientProperties(NettyClientProperties nettyClientProperties) { + this.nettyClientProperties = nettyClientProperties; + return this; + } + + /** + * 绑定访客ID + * + * @param visitorId 访客ID + * @return 当前对象 + */ + public NettyVisitorSocketBuilder builderVisitorId(String visitorId) { + this.visitorId = visitorId; + return this; + } + + public NettyClientPermeateClientVisitorSocket build() { + if (clientTargetIp == null) { + throw new IllegalArgumentException("clientTargetIp must not null"); + } + if (clientTargetPort == null) { + throw new IllegalArgumentException("clientTargetPort must not null"); + } + if (visitorPort == null) { + throw new IllegalArgumentException("visitorPort must not null"); + } + InternalNetworkPermeateServerVisitor internalNetworkPermeateServerVisitor = new InternalNetworkPermeateServerVisitor(); + + internalNetworkPermeateServerVisitor.setTargetIp(clientTargetIp); + internalNetworkPermeateServerVisitor.setTargetPort(clientTargetPort); + internalNetworkPermeateServerVisitor.setVisitorPort(visitorPort); + internalNetworkPermeateServerVisitor.setNettyClientProperties(nettyClientProperties); + internalNetworkPermeateServerVisitor.setChannelFlowAdapter(channelFlowAdapter); + internalNetworkPermeateServerVisitor.setHandleChannelTypeAdvancedList(handleChannelTypeAdvancedList); + + + NettyClientPermeateClientVisitorFilter visitorFilter = new NettyClientPermeateClientVisitorFilter(internalNetworkPermeateServerVisitor); + return new NettyClientPermeateClientVisitorSocket(visitorFilter, clientId, visitorPort); + } + + + } + +} \ No newline at end of file diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyClientTransferClientSocket.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyClientTransferClientSocket.java new file mode 100644 index 0000000..a4364d2 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyClientTransferClientSocket.java @@ -0,0 +1,113 @@ +package org.framework.lazy.cloud.network.heartbeat.client.netty.socket; + + +import io.netty.bootstrap.Bootstrap; +import io.netty.channel.*; +import io.netty.channel.nio.NioEventLoopGroup; +import io.netty.channel.socket.nio.NioSocketChannel; +import lombok.extern.slf4j.Slf4j; +import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties; +import org.framework.lazy.cloud.network.heartbeat.client.netty.InternalNetworkPermeateServerVisitor; +import org.framework.lazy.cloud.network.heartbeat.client.netty.filter.NettyClientPermeateTransferFilter; +import org.framework.lazy.cloud.network.heartbeat.common.MessageType; +import org.framework.lazy.cloud.network.heartbeat.common.NettyCommunicationIdContext; +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.NettyRealIdContext; +import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter; +import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; + +import java.util.concurrent.TimeUnit; + +/** + * 客户端渗透服务端传输通道 + */ +@Slf4j +public class NettyClientTransferClientSocket { + static EventLoopGroup eventLoopGroup = new NioEventLoopGroup(); + + /** + * 连接服务端通信通道 + */ + public static void buildTransferServer(InternalNetworkPermeateServerVisitor internalNetworkPermeateServerVisitor) { + newTransferConnect2Server(internalNetworkPermeateServerVisitor); + } + + + /** + * 连接服务端通信通道 + *

+ * internalNetworkPermeateServerVisitor + */ + protected static void newTransferConnect2Server(InternalNetworkPermeateServerVisitor internalNetworkPermeateServerVisitor) { + + Bootstrap bootstrap = new Bootstrap(); + bootstrap.group(eventLoopGroup) + .channel(NioSocketChannel.class) + .option(ChannelOption.SO_KEEPALIVE, true) + // 设置读缓冲区为2M + .option(ChannelOption.SO_RCVBUF, 2048 * 1024) + // 设置写缓冲区为1M + .option(ChannelOption.SO_SNDBUF, 1024 * 1024) +// .option(ChannelOption.TCP_NODELAY, false) + .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 1000 * 60)//连接超时时间设置为 60 秒 +// .option(ChannelOption.SO_BACKLOG, 256)//务端接受连接的队列长度 默认128 +// .option(ChannelOption.RCVBUF_ALLOCATOR, new NettyRecvByteBufAllocator(1024 * 1024))//用于Channel分配接受Buffer的分配器 默认AdaptiveRecvByteBufAllocator.DEFAULT + + .option(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2)) + + .handler(new NettyClientPermeateTransferFilter(new ChannelTypeAdapter(internalNetworkPermeateServerVisitor.getHandleChannelTypeAdvancedList()))) + ; + NettyClientProperties nettyClientProperties = internalNetworkPermeateServerVisitor.getNettyClientProperties(); + String inetHost = nettyClientProperties.getInetHost(); + int inetPort = nettyClientProperties.getInetPort(); + // local client id + + String clientId = nettyClientProperties.getClientId(); + + String targetIp = internalNetworkPermeateServerVisitor.getTargetIp(); + Integer targetPort = internalNetworkPermeateServerVisitor.getTargetPort(); + + String visitorId = internalNetworkPermeateServerVisitor.getVisitorId(); + Integer visitorPort = internalNetworkPermeateServerVisitor.getVisitorPort(); + + // 客户端新建访客通道 连接服务端IP:{},连接服务端端口:{} + log.info("Client creates a new visitor channel to connect to server IP: {}, connecting to server port: {}", inetHost, inetPort); + ChannelFuture future = bootstrap.connect(inetHost, inetPort); + + // 使用的客户端ID:{} + log.info("Client ID used: {}", clientId); + future.addListener((ChannelFutureListener) futureListener -> { + Channel channel = futureListener.channel(); + if (futureListener.isSuccess()) { + + NettyProxyMsg myMsg = new NettyProxyMsg(); + myMsg.setType(MessageType.REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL); + // other clientId + myMsg.setClientId(clientId); + myMsg.setVisitorPort(visitorPort); + myMsg.setClientTargetIp(targetIp); + myMsg.setClientTargetPort(targetPort); + + myMsg.setVisitorId(visitorId); + channel.writeAndFlush(myMsg); + // 绑定客户端真实通信通道 + NettyCommunicationIdContext.pushVisitor(channel, visitorId); + ChannelAttributeKeyUtils.buildVisitorId(channel, visitorId); + ChannelAttributeKeyUtils.buildClientId(channel, clientId); + // 传输通道打开后自动读取 + Channel visitor = NettyRealIdContext.getReal(visitorId); + + ChannelAttributeKeyUtils.buildNextChannel(visitor, channel); + ChannelAttributeKeyUtils.buildNextChannel(channel, visitor); + + + } else { + log.info("每隔2s重连...."); + // 离线 + channel.eventLoop().schedule(() -> { + newTransferConnect2Server(internalNetworkPermeateServerVisitor); + }, 2, TimeUnit.SECONDS); + } + }); + } +} \ No newline at end of file diff --git a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyClientRealSocket.java b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyServerPermeateClientRealSocket.java similarity index 98% rename from wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyClientRealSocket.java rename to wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyServerPermeateClientRealSocket.java index cb45e68..374cc0e 100644 --- a/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyClientRealSocket.java +++ b/wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/socket/NettyServerPermeateClientRealSocket.java @@ -7,7 +7,7 @@ import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.nio.NioSocketChannel; import lombok.extern.slf4j.Slf4j; import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties; -import org.framework.lazy.cloud.network.heartbeat.client.netty.filter.NettyClientRealFilter; +import org.framework.lazy.cloud.network.heartbeat.client.netty.filter.NettyServerPermeateClientRealFilter; import org.framework.lazy.cloud.network.heartbeat.client.netty.filter.NettyClientVisitorRealFilter; import org.framework.lazy.cloud.network.heartbeat.common.*; import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter; @@ -21,7 +21,7 @@ import java.util.concurrent.TimeUnit; * 客户端连接真实服务 */ @Slf4j -public class NettyClientRealSocket { +public class NettyServerPermeateClientRealSocket { static EventLoopGroup eventLoopGroup = new NioEventLoopGroup(); /** @@ -62,7 +62,7 @@ public class NettyClientRealSocket { // .option(ChannelOption.SO_BACKLOG, 128)//务端接受连接的队列长度 默认128 // .option(ChannelOption.RCVBUF_ALLOCATOR, new NettyRecvByteBufAllocator(1024 * 1024))//用于Channel分配接受Buffer的分配器 默认AdaptiveRecvByteBufAllocator.DEFAULT .option(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2)) - .handler(new NettyClientRealFilter()) + .handler(new NettyServerPermeateClientRealFilter()) ; diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/MessageType.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/MessageType.java index b07ec6b..4ee3586 100644 --- a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/MessageType.java +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/MessageType.java @@ -4,8 +4,6 @@ import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandle import org.framework.lazy.cloud.network.heartbeat.common.advanced.client.*; import org.framework.lazy.cloud.network.heartbeat.common.advanced.server.*; import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; -import org.framework.lazy.cloud.network.heartbeat.common.advanced.client.*; -import org.framework.lazy.cloud.network.heartbeat.common.advanced.server.*; /** * @see MessageTypeEnums @@ -119,6 +117,15 @@ public class MessageType { * @see AbstractHandleReportClientPermeateServerCloseTypeAdvanced */ public static final byte REPORT_CLIENT_PERMEATE_SERVER_CLOSE = 0X14; + + /** + * 上报 客户端渗透客户端数据传输通道连接成功 + * + * @see MessageTypeEnums#REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL + * @see AbstractHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced + * @see MessageType#DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL + */ + public static final byte REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL = 0X15; /** * 下发 客户端接收连接成功通知 * @@ -227,4 +234,13 @@ public class MessageType { * @see AbstractHandleDistributeClientPermeateServerCloseTypeAdvanced */ public static final byte DISTRIBUTE_CLIENT_PERMEATE_SERVER_CLOSE = -0X14; + + /** + * 下发 客户端渗透客户端数据传输通道连接成功 + * + * @see MessageTypeEnums#DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL + * @see AbstractHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced + * @see MessageType#REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL + */ + public static final byte DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL = -0X15; } diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/client/AbstractHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/client/AbstractHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java new file mode 100644 index 0000000..efb9761 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/client/AbstractHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java @@ -0,0 +1,28 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 下发 客户端渗透客户端数据传输通道连接成功 + * + * @see MessageTypeEnums#DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL + */ +public abstract class AbstractHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/server/AbstractHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/server/AbstractHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java new file mode 100644 index 0000000..fabd3c4 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/server/AbstractHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 上报 客户端渗透客户端数据传输通道连接成功 + * REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL + */ +public abstract class AbstractHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/enums/MessageTypeEnums.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/enums/MessageTypeEnums.java index 0c759c8..6d54ef8 100644 --- a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/enums/MessageTypeEnums.java +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/enums/MessageTypeEnums.java @@ -71,6 +71,11 @@ public enum MessageTypeEnums { * @see AbstractHandleReportClientPermeateServerCloseTypeAdvanced */ REPORT_CLIENT_PERMEATE_SERVER_CLOSE(MessageType.REPORT_CLIENT_PERMEATE_SERVER_CLOSE, "上报 客户端渗透服务端init close 信息"), + /** + * 上报 客户端渗透客户端数据传输通道连接成功 + * @see AbstractHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced + */ + REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL(MessageType.REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL, "上报 客户端渗透客户端数据传输通道连接成功"), /** * @see AbstractHandleDistributeConnectSuccessNotificationTypeAdvancedHandle */ @@ -131,6 +136,10 @@ public enum MessageTypeEnums { * @see AbstractHandleDistributeClientPermeateServerCloseTypeAdvanced */ DISTRIBUTE_CLIENT_PERMEATE_SERVER_CLOSE(MessageType.DISTRIBUTE_CLIENT_PERMEATE_SERVER_CLOSE, "下发 客户端渗透服务端init close信息"), + /** + * @see AbstractHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced + */ + DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL(MessageType.DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL, "下发 客户端渗透客户端数据传输通道连接成功"), ; private final byte typeByte; diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/advanced/ServerHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/advanced/ServerHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java new file mode 100644 index 0000000..573572d --- /dev/null +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/advanced/ServerHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java @@ -0,0 +1,48 @@ +package org.framework.lazy.cloud.network.heartbeat.server.netty.advanced; + +import io.netty.channel.Channel; +import org.framework.lazy.cloud.network.heartbeat.common.ChannelContext; +import org.framework.lazy.cloud.network.heartbeat.common.MessageType; +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.server.AbstractHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.server.AbstractHandleReportClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.server.netty.socket.NettyClientPermeateServerConnectRealSocket; +import org.springframework.stereotype.Component; + +/** + * 上报 客户端渗透客户端数据传输通道连接成功 + */ +@Component +public class ServerHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced extends AbstractHandleReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced { + /** + * 处理当前数据 + * + * @param channel 当前通道 + * @param nettyProxyMsg 通道数据 + */ + @Override + protected void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) { + // 创建目标地址连接 + byte[] msgVisitorId = nettyProxyMsg.getVisitorId(); + byte[] msgVisitorPort = nettyProxyMsg.getVisitorPort(); + byte[] msgClientTargetIp = nettyProxyMsg.getClientTargetIp(); + byte[] msgClientTargetPort = nettyProxyMsg.getClientTargetPort(); + byte[] clientId = nettyProxyMsg.getClientId(); + // + ChannelContext.ClientChannel clientChannel = ChannelContext.get(clientId); + + NettyProxyMsg clientConnectTagetNettyProxyMsg = new NettyProxyMsg(); + clientConnectTagetNettyProxyMsg.setVisitorId(msgVisitorId); + clientConnectTagetNettyProxyMsg.setVisitorPort(msgVisitorPort); + clientConnectTagetNettyProxyMsg.setClientTargetIp(msgClientTargetIp); + clientConnectTagetNettyProxyMsg.setClientTargetPort(msgClientTargetPort); + clientConnectTagetNettyProxyMsg.setClientId(clientId); + clientConnectTagetNettyProxyMsg.setType(MessageType.DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL); + if (clientChannel != null) { + clientChannel.getChannel().writeAndFlush(clientConnectTagetNettyProxyMsg); + } + + + + } +}