华为AnyOffice eSDK建立TCP端口转发隧道

我就是我 2022-06-06 11:08 225阅读 0赞

华为为移动端接入提供了一整套的解决方案，就是AnyOffice，这套系统集成了VPN接入，应用商店，客户端设备管理等功能，是一个比较完善的平台。但是它提供的客户端SDK用起来很不方便，与其他厂商的VPN解决方案不同，华为提供的eSDK主要提供的是第7层协议封装的API，在7层上建立隧道进行HTTP协议的数据传输。比如替换安卓原生的的HttpClient和HttpURLConnection，用SvnHttpClient和SvnHttpURLConnection实现隧道内通讯。用法也和原生类的用法一致。

这样的API会产生几个很不方便的地方：

1、稍微复杂一点的项目，用的HTTP框架可能五花八门，比如OkHTTP，Retrofit，Volley等等，这些框架距离HttpClient和HttpURLConnection已经很遥远了。如果要修改框架或者让原有框架兼容华为的API是非常难做且容易出错的工作。

2、对于一些即时通讯协议，或者带有视频聊天或者直播的功能，那么框架就更加复杂了。有基于NIO，AIO的各种复杂的框架。虽然华为提供了一个API叫SvnSocket来实现JAVA原生Socket的功能，但是这个API也没有完全重写Socket的方法，比如常用的setKeepAlive()方法就没有实现，而且经过我的测试，有些在Socket类中使用没有问题SvnSocket也支持的方法在某些情况下调用也会抛异常。而且像是AIO，NIO这样的类就更没法实现了，所以局限性非常大，只适合小型的应用使用。

3、数据通讯不能使用HTTPS协议，如果有保密方面的需求就很难实现了

综上所述，虽然华为在设备管理方面做的还可以，但是提供的SDK对开发人员真的太不友好了，而且虽然安卓和IOS的SDK的版本已经更新到了RC10，但是接口文档和RC3几乎没有差别，还是用蹩脚的7层协议的API进行实现。非常不好用。

所以说如果想进行Http以外的协议通讯，就必须另辟蹊径了。

一个很简单的实现方案就是反向代理，把远程服务端的一个TCP或者UDP端口，通过SVN隧道映射到手机本地上来，比如我把远程的80端口映射到手机的8880端口，那么我在访问相关服务器的时候，只需把我原来框架的目标IP从远程IP改成127.0.0.1:8880，其他的逻辑完全不需要改变，只需要做个网关登录认证就可以了。这样其实就把华为的eSDK当成传统的VPN一样使用，大大减少开发工作量和迁移成本。

但是华为SDK没有实现相关隧道的功能，只提供了SvnHttpClient，SvnHttpURLConnection，SvnSocket，SvnWebView这样的几个7层协议的接口。

所以实现Socket隧道的方法只能我们自己来完成了，从理论上来说，使用7层的协议比如HTTP做3层TCP协议的代理是可以的，但是实现起来比较复杂。使用四层的Socket通信直接实现TCP隧道比较容易，只要做转发就可以了。

所谓转发，就是把一个套接字的输出流写入到另一个套接字的输出流，另一个套接字的输入流写入到当前套接字的输出流，没什么技术含量，也不需要关心3层以上使用的是什么协议，因为隧道代理不同于中间人代理，是无需针对协议的格式进行重写的。（中间人代理比较常见的是HTTP代理，由于HTTP协议有明确的规定，比如HEADER，BODY，Content-Length等等，所以代理软件只需把源报文收过来，稍作修改或者不改，生成新的报文和连接发送出去。隧道代理比较常见的是HTTPs代理和Socks5代理，由于HTTPS协议中间人无法读取里面的内容，也不能修改内容，所以只能做无脑转发）。使用隧道代理之后，无论是HTTP，HTTPS，FTP，SFTP，SSH或者即时通讯协议，流媒体协议等就都可以通过建立好的TCP隧道进行传输，完全不用担心协议格式的问题和API接口实现的问题。

使用JAVA大体的实现思路是这样的，首先使用系统原生ServerSocket监听一个本地端口，然后让应用程序将目标地址设为这个端口。然后使用ServerSocket.accept()会接收到一个Socket对象，也就是后端应用程序发来的请求。然后我们使用华为提供的API SvnSocket新建一个连接，然后获取源Socket的输入输出流，再获取SvnSocket的输入输出流。最后使用BufferWriter和BufferReader进行流的读写就可以了。主要代码如下，为此我还在华为eSDK的Android RC10 Demo上又添加了一个页面专门做Socket隧道。如下图

![Center][]

启动监听端口：

public void start() {
        thread = new Thread(this);
        thread.start();
      }
    
      public void run() {
        try {
          serverSocket =  new ServerSocket(params.getSourcePort());
          while (shouldRun) {
            Socket clientSocket = serverSocket.accept();
            TCPTunnel tunnel = new TCPTunnel(params, clientSocket, this);
            tunnel.start();
            tunnels.add(tunnel);
          }
        } catch (IOException e) {
          throw new RuntimeException("Error while trying to forward TCP with params:"+params, e);
        }
      }

建立通道

package com.tcptunnel.forwarder;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.Socket;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    import com.huawei.svn.sdk.socket.SvnSocket;
    import com.tcptunnel.Main;
    import com.tcptunnel.Params;
    import com.tcptunnel.Utils;
    
    /**
     * Creates a TCP tunnel between two endpoints via two Forwarder instances.
     * Data is forwarded in both directions using separate sockets.
     * Any error on either socket causes the whole tunnel (both sockets) to be closed.
     */
    public class TCPTunnel extends Thread {
      private SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MMM.dd HH:mm:ss");
      /** Configuration parameters. */
      private final Params params;
      /** Local endpoint for the tunnel. */
      private Socket localSocket;
      /** Remote endpoint for the tunnel. */
      private Socket serverSocket;
      /** True if this tunnel is actively forwarding. False if stopped or not yet started. */
      private boolean active = false;
      /** Parent to notify when connection is broken. */
      private final Main parent;
    
      /**
       * @param params Configuration parameters.
       * @param localSocket Socket for the local port (endpoint 1 for tunnel).
       */
      public TCPTunnel(Params params, Socket localSocket, Main parent) {
        this.params = params;
        this.localSocket = localSocket;
        this.parent = parent;
      }
    
      /**
       * Connects to the remote host and starts bidirectional forwarding (the tunnel).
       */
      public void run() {
        String dateStr = sdf.format(new Date());
        try {
          // Connect to the destination server
          serverSocket = new SvnSocket(params.getRemoteHost(), params.getRemotePort());
    
          // Turn on keep-alive for both the sockets
    //      serverSocket.setKeepAlive(true);
          localSocket.setKeepAlive(true);
    
          // Obtain client & server input & output streams
          InputStream clientIn = localSocket.getInputStream();
          OutputStream clientOut = localSocket.getOutputStream();
          InputStream serverIn = serverSocket.getInputStream();
          OutputStream serverOut = serverSocket.getOutputStream();
    
          // Start forwarding data between server and client
          active = true;
          String clientAddr = toStr(localSocket);
          String serverAddr = toStr(serverSocket);
          String hummanClientAddr = Utils.mapAddrToHumanReadable(clientAddr);
          String hummanServerAddr = Utils.mapAddrToHumanReadable(serverAddr);
          clientAddr = clientAddr+" ("+hummanClientAddr+")";
          serverAddr = serverAddr+" ("+hummanServerAddr+")";
          Forwarder clientForward = new Forwarder(this, clientIn, serverOut, params, true, clientAddr);
          clientForward.start();
          Forwarder serverForward = new Forwarder(this, serverIn, clientOut, params, false, serverAddr);
          serverForward.start();
    
          if (params.isPrint()) {
            System.out.println(dateStr+": TCP Forwarding " + clientAddr + " <--> " + serverAddr);
          }
        } catch (IOException ioe) {
          if (params.isPrint()) {
            String remoteAddr = params.getRemoteHost() + ":" + params.getRemotePort();
            String humanRemoteAddr = Utils.mapAddrToHumanReadable(remoteAddr);
            remoteAddr = remoteAddr + " ("+humanRemoteAddr+")";
            System.err.println(dateStr + ": Failed to connect to remote host (" + remoteAddr + ")");
          }
          connectionBroken();
        }
      }
    
      /**
       * @param socket The socket to describe.
       * @return A string representation of a socket (ip+port).
       */
      private String toStr(Socket socket) {
        String host = socket.getInetAddress().getHostAddress();
        int port = socket.getPort();
        return host + ":" + port;
      }
    
      /**
       * Closes the tunnel (the forwarding sockets..).
       */
      public void close() {
        connectionBroken();
      }
    
      /**
       * Called when an error is observed on one of the sockets making up the tunnel.
       * Terminates the tunnel by closing both sockets.
       */
      public synchronized void connectionBroken() {
        try {
          serverSocket.close();
        } catch (Exception e) {}
        try {
          localSocket.close();
        } catch (Exception e) {}
    
        if (active) {
          String dateStr = sdf.format(new Date());
          if (params.isPrint()) System.out.println(dateStr+": TCP Forwarding " + toStr(localSocket) + " <--> " + toStr(serverSocket) + " stopped.");
          active = false;
        }
        parent.closed(this);
      }
    }

数据流读写

package com.tcptunnel.forwarder;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    
    import com.tcptunnel.Params;
    
    /**
     * Forwards TCP traffic between two sockets.
     * Sends everything from socket 1 input stream to socket 2 outputstream.
     * In case of any error on either socket, the parent tunnel is closed.
     */
    public class Forwarder extends Thread {
      /** Socket 1 inputstream. */
      private InputStream is;
      /** Socket 2 outputstream. */
      private OutputStream os;
      /** The TCP tunnel this forwarder is part of. */
      private TCPTunnel parent;
      /** Configuration parameters. */
      private final Params params;
    
      /**
       * @param parent The TCP tunnel containing this forwarder.
       * @param is Inputstream for socket 1, to connect to the outputstream.
       * @param os Outputstream for socket 2, to connect to the inputstream.
       * @param params Configuration parameters.
       * @param up If true, we pass all data going through to upstream observers.
       * @param sourceAddr Source address of the stream (up- or down-stream). For logging purposes...
       */
      public Forwarder(TCPTunnel parent, InputStream is, OutputStream os, Params params, boolean up, String sourceAddr) {
        this.parent = parent;
        this.is = is;
        this.os = os;
        this.params = params;
      }
    
      /**
       * Continously reads the input stream and writes the data to the output stream.
       * In between passes all the data to any registered observers.
       * In case of error on either socket, notifies the parent TCP tunnel to close.
       */
      public void run() {
        byte[] buffer = new byte[params.getBufferSize()];
        try {
          while (true) {
            int bytesRead = is.read(buffer);
            if (bytesRead == -1) break; // End of stream is reached --> exit
            os.write(buffer, 0, bytesRead);
            os.flush();
          }
        } catch (IOException e) {
          // Read/write failed --> connection is broken
        }
        parent.connectionBroken();
      }
    }

启动线程以后，把手机连在电脑上使用adb shell命令后，使用netstat -an查看手机开放的端口，会看到9090端口已经在所有网络上开放，如下图

![Center 1][]

使用我的demo以后，开放的端口是监听在0.0.0.0也就是你可以从手机同一wifi网络环境下访问这个接口，比如你的你连接的远程地址是172.17.0.1:80，你本地开放9090端口，你手机在你本地wifi的IP是192.168.1.2，你同一wifi下的电脑IP为192.168.1.3，那么你用电脑上的浏览器访问192.168.1.2:9090就可以浏览到远程的172.17.0.1:80的Web界面了。同理你可以把远程端口设为SSH的22端口或者其他端口，这样可以在Socket隧道中再建立一条SSH加密隧道。但是目前还没能实现UDP端口的隧道，因为华为的eSDK并没有提供DatagramSocket/DatagramPacket这两个类的API

![Center 2][]

同样也可以用Demo中提供的JAVA原生不走VPN的HttpClient来访问127.0.0.1:7070端口，注意一定要选择OUTER才是不走VPN的模式，如下图（不使用HttpURLConnection和WebView的原因是这两个空间一旦开启了代理模式就不能切换回普通模式了，会对测试结果产生干扰）

![Center 3][]

终于，通过这种方式，让原来没法走隧道的原生Socket协议通过代理可以通过隧道进行转发了，并且支持全部的TCP上层协议，再也不用因为华为eSDK的接口不足而犯愁了。

Demo下载地址：由于版权问题请私信我索取

更多JAVA Port Forward和Socket Tunnel功能，可以看该项目：[https://github.com/AlexZhuo/java-tcp-tunnel][https_github.com_AlexZhuo_java-tcp-tunnel]

[Center]: /images/20220606/8e3801569a8a4adb9a56803dde26115e.png
[Center 1]: /images/20220606/c53c56eac8b143aaa127f930426bdb3c.png
[Center 2]: /images/20220606/c5f5481e0d134727b418b9e119a2d876.png
[Center 3]: /images/20220606/e04b690a06da4cce8964835b2635636d.png
[https_github.com_AlexZhuo_java-tcp-tunnel]: https://github.com/AlexZhuo/java-tcp-tunnel