Examples with AuthenticEndpoint org.rx.net.AuthenticEndpoint used on opensource projects

Example 1 with AuthenticEndpoint

use of org.rx.net.AuthenticEndpoint in project rxlib by RockyLOMO.

the class Udp2rawHandler method channelRead0.

@SneakyThrows
@Override
protected void channelRead0(ChannelHandlerContext inbound, DatagramPacket in) throws Exception {
    ByteBuf inBuf = in.content();
    if (inBuf.readableBytes() < 4) {
        return;
    }
    SocksProxyServer server = SocksContext.server(inbound.channel());
    final InetSocketAddress srcEp0 = in.sender();
    List<InetSocketAddress> udp2rawServers = server.config.getUdp2rawServers();
    // client
    if (udp2rawServers != null) {
        if (!udp2rawServers.contains(srcEp0) && !clientRoutes.containsKey(srcEp0)) {
            final UnresolvedEndpoint dstEp = UdpManager.socks5Decode(inBuf);
            RouteEventArgs e = new RouteEventArgs(srcEp0, dstEp);
            server.raiseEvent(server.onUdpRoute, e);
            Upstream upstream = e.getValue();
            AuthenticEndpoint svrEp = upstream.getSocksServer();
            if (svrEp != null) {
                ByteBuf outBuf = Bytes.directBuffer(64 + inBuf.readableBytes());
                outBuf.writeShort(STREAM_MAGIC);
                outBuf.writeByte(STREAM_VERSION);
                UdpManager.encode(outBuf, new UnresolvedEndpoint(srcEp0));
                UdpManager.encode(outBuf, dstEp);
                zip(outBuf, inBuf);
                inbound.writeAndFlush(new DatagramPacket(outBuf, svrEp.getEndpoint()));
                // log.info("UDP2RAW CLIENT {} => {}[{}]", srcEp0, svrEp.getEndpoint(), dstEp);
                return;
            }
            UnresolvedEndpoint upDstEp = upstream.getDestination();
            log.debug("UDP2RAW[{}] CLIENT DIRECT {} => {}[{}]", server.config.getListenPort(), srcEp0, upDstEp, dstEp);
            inbound.writeAndFlush(new DatagramPacket(inBuf.retain(), upDstEp.socketAddress()));
            clientRoutes.put(upDstEp.socketAddress(), Tuple.of(srcEp0, dstEp));
            return;
        }
        Tuple<InetSocketAddress, UnresolvedEndpoint> upSrcs = clientRoutes.get(srcEp0);
        if (upSrcs != null) {
            ByteBuf outBuf = UdpManager.socks5Encode(inBuf, upSrcs.right);
            log.debug("UDP2RAW[{}] CLIENT DIRECT {}[{}] => {}", server.config.getListenPort(), srcEp0, upSrcs.right, upSrcs.left);
            inbound.writeAndFlush(new DatagramPacket(outBuf, upSrcs.left));
            return;
        }
        if (inBuf.readShort() != STREAM_MAGIC & inBuf.readByte() != STREAM_VERSION) {
            log.warn("discard {} bytes", inBuf.readableBytes());
            return;
        }
        UnresolvedEndpoint srcEp = UdpManager.decode(inBuf);
        UnresolvedEndpoint dstEp = UdpManager.decode(inBuf);
        ByteBuf outBuf = UdpManager.socks5Encode(inBuf, dstEp);
        inbound.writeAndFlush(new DatagramPacket(outBuf, srcEp.socketAddress()));
        // log.info("UDP2RAW CLIENT {}[{}] => {}", srcEp0, dstEp, srcEp);
        return;
    }
    // server
    if (inBuf.readShort() != STREAM_MAGIC & inBuf.readByte() != STREAM_VERSION) {
        log.warn("discard {} bytes", inBuf.readableBytes());
        return;
    }
    final UnresolvedEndpoint srcEp = UdpManager.decode(inBuf);
    final UnresolvedEndpoint dstEp = UdpManager.decode(inBuf);
    Channel outbound = UdpManager.openChannel(srcEp.socketAddress(), k -> {
        RouteEventArgs e = new RouteEventArgs(srcEp.socketAddress(), dstEp);
        server.raiseEvent(server.onUdpRoute, e);
        Upstream upstream = e.getValue();
        return SocksContext.initOutbound(Sockets.udpBootstrap(server.config.getMemoryMode(), ob -> {
            SocksContext.server(ob, server);
            upstream.initChannel(ob);
            ob.pipeline().addLast(new IdleStateHandler(0, 0, server.config.getUdpTimeoutSeconds()) {

                @Override
                protected IdleStateEvent newIdleStateEvent(IdleState state, boolean first) {
                    UdpManager.closeChannel(SocksContext.realSource(ob));
                    return super.newIdleStateEvent(state, first);
                }
            }, new SimpleChannelInboundHandler<DatagramPacket>() {

                @Override
                protected void channelRead0(ChannelHandlerContext outbound, DatagramPacket out) {
                    ByteBuf outBuf = Bytes.directBuffer(64 + out.content().readableBytes());
                    outBuf.writeShort(STREAM_MAGIC);
                    outBuf.writeByte(STREAM_VERSION);
                    UdpManager.encode(outBuf, srcEp);
                    UdpManager.encode(outBuf, dstEp);
                    outBuf.writeBytes(out.content());
                    inbound.writeAndFlush(new DatagramPacket(outBuf, srcEp0));
                // log.info("UDP2RAW SERVER {}[{}] => {}[{}]", out.sender(), dstEp, srcEp0, srcEp);
                }
            });
        }).bind(0).addListener(Sockets.logBind(0)).addListener(UdpManager.FLUSH_PENDING_QUEUE).channel(), srcEp.socketAddress(), dstEp, upstream);
    });
    ByteBuf outBuf = unzip(inBuf);
    UdpManager.pendOrWritePacket(outbound, new DatagramPacket(outBuf, dstEp.socketAddress()));
// log.info("UDP2RAW SERVER {}[{}] => {}", srcEp0, srcEp, dstEp);
}

Example 2 with AuthenticEndpoint

use of org.rx.net.AuthenticEndpoint in project rxlib by RockyLOMO.

the class Socks5Upstream method initChannel.

@SneakyThrows
@Override
public void initChannel(Channel channel) {
    UpstreamSupport next = router.invoke();
    if (next == null) {
        throw new InvalidException("ProxyHandlers is empty");
    }
    AuthenticEndpoint svrEp = next.getEndpoint();
    SocksSupport support = next.getSupport();
    TransportUtil.addBackendHandler(channel, config, svrEp.getEndpoint());
    if (support != null && (SocksSupport.FAKE_IPS.contains(destination.getHost()) || SocksSupport.FAKE_PORTS.contains(destination.getPort()) || !Sockets.isValidIp(destination.getHost()))) {
        String dstEpStr = destination.toString();
        SUID hash = SUID.compute(dstEpStr);
        // 先变更
        destination = new UnresolvedEndpoint(String.format("%s%s", hash, SocksSupport.FAKE_HOST_SUFFIX), Arrays.randomNext(SocksSupport.FAKE_PORT_OBFS));
        Cache.getOrSet(hash, k -> awaitQuietly(() -> {
            App.logMetric(String.format("socks5[%s]", config.getListenPort()), dstEpStr);
            support.fakeEndpoint(hash, dstEpStr);
            return true;
        }, SocksSupport.ASYNC_TIMEOUT));
    }
    Socks5ProxyHandler proxyHandler = new Socks5ProxyHandler(svrEp.getEndpoint(), svrEp.getUsername(), svrEp.getPassword());
    proxyHandler.setConnectTimeoutMillis(config.getConnectTimeoutMillis());
    channel.pipeline().addLast(proxyHandler);
}

Example 3 with AuthenticEndpoint

use of org.rx.net.AuthenticEndpoint in project rxlib by RockyLOMO.

the class Socks5UdpRelayHandler method channelRead0.

/**
 * https://datatracker.ietf.org/doc/html/rfc1928
 * +----+------+------+----------+----------+----------+
 * |RSV | FRAG | ATYP | DST.ADDR | DST.PORT |   DATA   |
 * +----+------+------+----------+----------+----------+
 * | 2  |  1   |  1   | Variable |    2     | Variable |
 * +----+------+------+----------+----------+----------+
 *
 * @param inbound
 * @param in
 * @throws Exception
 */
@Override
protected void channelRead0(ChannelHandlerContext inbound, DatagramPacket in) throws Exception {
    ByteBuf inBuf = in.content();
    if (inBuf.readableBytes() < 4) {
        return;
    }
    SocksProxyServer server = SocksContext.server(inbound.channel());
    final InetSocketAddress srcEp = in.sender();
    if (!Sockets.isNatIp(srcEp.getAddress()) && !server.config.getWhiteList().contains(srcEp.getAddress())) {
        log.warn("security error, package from {}", srcEp);
        return;
    }
    final UnresolvedEndpoint dstEp = UdpManager.socks5Decode(inBuf);
    Channel outbound = UdpManager.openChannel(srcEp, k -> {
        RouteEventArgs e = new RouteEventArgs(srcEp, dstEp);
        server.raiseEvent(server.onUdpRoute, e);
        Upstream upstream = e.getValue();
        return SocksContext.initOutbound(Sockets.udpBootstrap(server.config.getMemoryMode(), ob -> {
            SocksContext.server(ob, server);
            upstream.initChannel(ob);
            ob.pipeline().addLast(new IdleStateHandler(0, 0, server.config.getUdpTimeoutSeconds()) {

                @Override
                protected IdleStateEvent newIdleStateEvent(IdleState state, boolean first) {
                    // UdpManager.closeChannel(SocksContext.realSource(ob));
                    UdpManager.closeChannel(srcEp);
                    return super.newIdleStateEvent(state, first);
                }
            }, new SimpleChannelInboundHandler<DatagramPacket>() {

                @Override
                protected void channelRead0(ChannelHandlerContext outbound, DatagramPacket out) throws Exception {
                    InetSocketAddress srcEp = SocksContext.realSource(outbound.channel());
                    UnresolvedEndpoint dstEp = SocksContext.realDestination(outbound.channel());
                    ByteBuf outBuf = out.content();
                    if (upstream.getSocksServer() == null) {
                        outBuf = UdpManager.socks5Encode(outBuf, dstEp);
                    } else {
                        outBuf.retain();
                    }
                    inbound.writeAndFlush(new DatagramPacket(outBuf, srcEp));
                    log.debug("socks5[{}] UDP IN {}[{}] => {}", server.config.getListenPort(), out.sender(), dstEp, srcEp);
                }
            });
        }).bind(0).addListener(Sockets.logBind(0)).sync().channel(), srcEp, dstEp, upstream, false);
    });
    // todo sync改eventcallback
    Upstream upstream = SocksContext.upstream(outbound);
    // UnresolvedEndpoint upDstEp = upstream.getDestination();  //udp dstEp可能多个，但upstream只有一个，所以直接用dstEp。
    UnresolvedEndpoint upDstEp = dstEp;
    AuthenticEndpoint socksServer = upstream.getSocksServer();
    if (socksServer != null) {
        upDstEp = new UnresolvedEndpoint(socksServer.getEndpoint());
        inBuf.readerIndex(0);
    }
    UdpManager.pendOrWritePacket(outbound, new DatagramPacket(inBuf.retain(), upDstEp.socketAddress()));
    log.debug("socks5[{}] UDP OUT {} => {}[{}]", server.config.getListenPort(), srcEp, upDstEp, dstEp);
}

Example 4 with AuthenticEndpoint

use of org.rx.net.AuthenticEndpoint in project rxlib by RockyLOMO.

the class Socks5UdpUpstream method initChannel.

@SneakyThrows
@Override
public void initChannel(Channel channel) {
    UpstreamSupport next = router.invoke();
    if (next == null) {
        throw new InvalidException("ProxyHandlers is empty");
    }
    AuthenticEndpoint svrEp = socksServer = next.getEndpoint();
    TransportUtil.addBackendHandler(channel, config, svrEp.getEndpoint());
}

Example 5 with AuthenticEndpoint

use of org.rx.net.AuthenticEndpoint in project rxlib by RockyLOMO.

the class ServerUdpProxyHandler method channelRead0.

@Override
protected void channelRead0(ChannelHandlerContext inbound, ByteBuf inBuf) throws Exception {
    InetSocketAddress srcEp = inbound.channel().attr(SSCommon.REMOTE_ADDRESS).get();
    UnresolvedEndpoint dstEp = new UnresolvedEndpoint(inbound.channel().attr(SSCommon.REMOTE_DEST).get());
    ShadowsocksServer server = SocksContext.ssServer(inbound.channel());
    Channel outbound = UdpManager.openChannel(srcEp, k -> {
        RouteEventArgs e = new RouteEventArgs(srcEp, dstEp);
        server.raiseEvent(server.onUdpRoute, e);
        Upstream upstream = e.getValue();
        return SocksContext.initOutbound(Sockets.udpBootstrap(server.config.getMemoryMode(), ob -> {
            upstream.initChannel(ob);
            ob.pipeline().addLast(new IdleStateHandler(0, 0, server.config.getIdleTimeout()) {

                @Override
                protected IdleStateEvent newIdleStateEvent(IdleState state, boolean first) {
                    UdpManager.closeChannel(srcEp);
                    return super.newIdleStateEvent(state, first);
                }
            }, new SimpleChannelInboundHandler<DatagramPacket>() {

                @Override
                protected void channelRead0(ChannelHandlerContext outbound, DatagramPacket out) throws Exception {
                    ByteBuf outBuf = out.content();
                    if (upstream.getSocksServer() != null) {
                        UnresolvedEndpoint tmp = UdpManager.socks5Decode(outBuf);
                        if (!dstEp.equals(tmp)) {
                            log.error("UDP SOCKS ERROR {} != {}", dstEp, tmp);
                        }
                    }
                    inbound.attr(SSCommon.REMOTE_SRC).set(out.sender());
                    inbound.writeAndFlush(outBuf.retain());
                    log.info("UDP IN {}[{}] => {}", out.sender(), dstEp, srcEp);
                }
            });
        }).bind(0).addListener(UdpManager.FLUSH_PENDING_QUEUE).channel(), srcEp, dstEp, upstream);
    });
    Upstream upstream = SocksContext.upstream(outbound);
    UnresolvedEndpoint upDstEp = upstream.getDestination();
    AuthenticEndpoint svrEp = upstream.getSocksServer();
    if (svrEp != null) {
        inBuf = UdpManager.socks5Encode(inBuf, dstEp);
        upDstEp = new UnresolvedEndpoint(svrEp.getEndpoint());
    } else {
        inBuf.retain();
    }
    UdpManager.pendOrWritePacket(outbound, new DatagramPacket(inBuf, upDstEp.socketAddress()));
    log.info("UDP OUT {} => {}[{}]", srcEp, upDstEp, dstEp);
}