Golang实现内网穿透详解_Golang

我们经常会遇到一个问题，如何将本机的服务暴露到公网上，让别人也可以访问。我们知道，在家上网的时候我们有一个 ip 地址，但是这个 ip 地址并不是一个公网的 ip 地址，别人无法通过一个 ip 地址访问到你的服务，所以在例如：微信接口调试、三方对接的时候，你必须将你的服务部署到一个公网的系统中去，这样太累了。这个时候，内网穿透就出现了，它的作用就是即使你在家的服务，也能被其人访问到。今天让我们来用一个最简单的案例学习一下如何用 go 来做一个最简单的内网穿透工具。

整体结构

首先我们用几张图来说明一下我们是如何实现的，说清楚之后再来用代码实现一下。

当前网络情况

我们可以看到，画实线的是我们当前可以访问的，画虚线的是我们当前无法进行直接访问的。

我们现在有的路是：

用户主动访问公网服务器是可以的
内网主动访问公网服务也是可以的

当前我们要做的是想办法能让用户访问到内网服务，所以如果能做到公网服务访问到内网服务，那么用户就能间接访问到内网服务了。

想是这么想的，但是实际怎么做呢？用户访问不到内网服务，那我公网服务器同样访问不到吧。所以我们就需要利用现有的链路来完成这件事。

基本架构

内网，客户端（我们要搞一个）
外网，服务端（我们也要搞一个）
访问者，用户

首先我们需要一个控制通道来传递消息，因为只有内网可以访问公网，公网不知道内网在哪里，所以第一次肯定需要客户端主动告诉服务端我在哪
服务端通过 8007 端口监听用户来的请求
当用户发来请求时，服务端需要通过控制信道告诉客户端，有用户来了
客户端收到消息之后建立隧道通道，主动访问服务端的 8008 来建立 tcp 连接
此时客户端需要同时与本地需要暴露的服务 127.0.0.1:8080 建立连接
连接完成后，服务端需要将 8007 的请求转发到隧道端口 8008 中
客户端从隧道中获得用户请求，转发给内网服务，同时将内网服务的返回信息放入隧道

最终请求流向是，如图中的紫色箭头走向，请求返回是如图中红色箭头走向。

需要理解的是，tcp 一旦建立了连接，双方就都可以向对方发送信息了，所以其实原理很简单，就是利用已有的单向路建立 tcp 连接，从而知道对方的位置信息，然后将请求进行转发即可。

代码实现

工具方法

首先我们先定义三个需要使用的工具方法，还需要定义两个消息编码常量，后面会用到

监听一个地址对应的 tcp 请求 createtcplistener
连接一个 tcp 地址 createtcpconn
将一个 tcp-a 连接的数据写入另一个 tcp-b 连接，将 tcp-b 连接返回的数据写入 tcp-a 的连接中 join2conn （别看这短短 10 几行代码，这就是核心了）

package network

import (
   "io"
   "log"
   "net"
)

const (
   keepalive     = "keep_alive"
   newconnection = "new_connection"
)

func createtcplistener(addr string) (*net.tcplistener, error) {
   tcpaddr, err := net.resolvetcpaddr("tcp", addr)
   if err != nil {
       return nil, err
   }
   tcplistener, err := net.listentcp("tcp", tcpaddr)
   if err != nil {
       return nil, err
   }
   return tcplistener, nil
}

func createtcpconn(addr string) (*net.tcpconn, error) {
   tcpaddr, err := net.resolvetcpaddr("tcp", addr)
   if err != nil {
      return nil, err
   }
   tcplistener, err := net.dialtcp("tcp",nil, tcpaddr)
   if err != nil {
      return nil, err
   }
   return tcplistener, nil
}

func join2conn(local *net.tcpconn, remote *net.tcpconn) {
   go joinconn(local, remote)
   go joinconn(remote, local)
}

func joinconn(local *net.tcpconn, remote *net.tcpconn) {
   defer local.close()
   defer remote.close()
   _, err := io.copy(local, remote)
   if err != nil {
      log.println("copy failed ", err.error())
      return
   }
}

客户端

我们先来实现相对简单的客户端，客户端主要做的事情是 3 件：

连接服务端的控制通道
等待服务端从控制通道中发来建立连接的消息
收到建立连接的消息时，将本地服务和远端隧道建立连接（这里就要用到我们的工具方法了）

package main

import (
   "bufio"
   "io"
   "log"
   "net"

   "nat-proxy/cmd/network"
)

var (
   // 本地需要暴露的服务端口
   localserveraddr = "127.0.0.1:32768"

   remoteip = "111.111.111.111"
   // 远端的服务控制通道，用来传递控制信息，如出现新连接和心跳
   remotecontroladdr = remoteip + ":8009"
   // 远端服务端口，用来建立隧道
   remoteserveraddr  = remoteip + ":8008"
)

func main() {
   tcpconn, err := network.createtcpconn(remotecontroladdr)
   if err != nil {
      log.println("[连接失败]" + remotecontroladdr + err.error())
      return
   }
   log.println("[已连接]" + remotecontroladdr)

   reader := bufio.newreader(tcpconn)
   for {
      s, err := reader.readstring('\n')
      if err != nil || err == io.eof {
         break
      }

      // 当有新连接信号出现时，新建一个tcp连接
      if s == network.newconnection+"\n" {
         go connectlocalandremote()
      }
   }

   log.println("[已断开]" + remotecontroladdr)
}

func connectlocalandremote() {
   local := connectlocal()
   remote := connectremote()

   if local != nil && remote != nil {
      network.join2conn(local, remote)
   } else {
      if local != nil {
         _ = local.close()
      }
      if remote != nil {
         _ = remote.close()
      }
   }
}

func connectlocal() *net.tcpconn {
   conn, err := network.createtcpconn(localserveraddr)
   if err != nil {
      log.println("[连接本地服务失败]" + err.error())
   }
   return conn
}

func connectremote() *net.tcpconn {
   conn, err := network.createtcpconn(remoteserveraddr)
   if err != nil {
      log.println("[连接远端服务失败]" + err.error())
   }
   return conn
}

服务端

服务端的实现就相对复杂一些了：

监听控制通道，接收客户端的连接请求
监听访问端口，接收来自用户的 http 请求
第二步接收到请求之后需要存放一下这个连接并同时发消息给客户端，告诉客户端有用户访问了，赶紧建立隧道进行通信
监听隧道通道，接收来自客户端的连接请求，将客户端的连接与用户的连接建立起来（也是用工具方法）

package main

import (
   "log"
   "net"
   "strconv"
   "sync"
   "time"

   "nat-proxy/cmd/network"
)

const (
   controladdr = "0.0.0.0:8009"
   tunneladdr  = "0.0.0.0:8008"
   visitaddr   = "0.0.0.0:8007"
)

var (
   clientconn         *net.tcpconn
   connectionpool     map[string]*connmatch
   connectionpoollock sync.mutex
)

type connmatch struct {
   addtime time.time
   accept  *net.tcpconn
}

func main() {
   connectionpool = make(map[string]*connmatch, 32)
   go createcontrolchannel()
   go acceptuserrequest()
   go acceptclientrequest()
   cleanconnectionpool()
}

// 创建一个控制通道，用于传递控制消息，如：心跳，创建新连接
func createcontrolchannel() {
   tcplistener, err := network.createtcplistener(controladdr)
   if err != nil {
      panic(err)
   }

   log.println("[已监听]" + controladdr)
   for {
      tcpconn, err := tcplistener.accepttcp()
      if err != nil {
         log.println(err)
         continue
      }

      log.println("[新连接]" + tcpconn.remoteaddr().string())
      // 如果当前已经有一个客户端存在，则丢弃这个链接
      if clientconn != nil {
         _ = tcpconn.close()
      } else {
         clientconn = tcpconn
         go keepalive()
      }
   }
}

// 和客户端保持一个心跳链接
func keepalive() {
   go func() {
      for {
         if clientconn == nil {
            return
         }
         _, err := clientconn.write(([]byte)(network.keepalive + "\n"))
         if err != nil {
            log.println("[已断开客户端连接]", clientconn.remoteaddr())
            clientconn = nil
            return
         }
         time.sleep(time.second * 3)
      }
   }()
}

// 监听来自用户的请求
func acceptuserrequest() {
   tcplistener, err := network.createtcplistener(visitaddr)
   if err != nil {
      panic(err)
   }
   defer tcplistener.close()
   for {
      tcpconn, err := tcplistener.accepttcp()
      if err != nil {
         continue
      }
      addconn2pool(tcpconn)
      sendmessage(network.newconnection + "\n")
   }
}

// 将用户来的连接放入连接池中
func addconn2pool(accept *net.tcpconn) {
   connectionpoollock.lock()
   defer connectionpoollock.unlock()

   now := time.now()
   connectionpool[strconv.formatint(now.unixnano(), 10)] = &connmatch{now, accept,}
}

// 发送给客户端新消息
func sendmessage(message string) {
   if clientconn == nil {
      log.println("[无已连接的客户端]")
      return
   }
   _, err := clientconn.write([]byte(message))
   if err != nil {
      log.println("[发送消息异常]: message: ", message)
   }
}

// 接收客户端来的请求并建立隧道
func acceptclientrequest() {
   tcplistener, err := network.createtcplistener(tunneladdr)
   if err != nil {
      panic(err)
   }
   defer tcplistener.close()

   for {
      tcpconn, err := tcplistener.accepttcp()
      if err != nil {
         continue
      }
      go establishtunnel(tcpconn)
   }
}

func establishtunnel(tunnel *net.tcpconn) {
   connectionpoollock.lock()
   defer connectionpoollock.unlock()

   for key, connmatch := range connectionpool {
      if connmatch.accept != nil {
         go network.join2conn(connmatch.accept, tunnel)
         delete(connectionpool, key)
         return
      }
   }

   _ = tunnel.close()
}

func cleanconnectionpool() {
   for {
      connectionpoollock.lock()
      for key, connmatch := range connectionpool {
         if time.now().sub(connmatch.addtime) > time.second*10 {
            _ = connmatch.accept.close()
            delete(connectionpool, key)
         }
      }
      connectionpoollock.unlock()
      time.sleep(5 * time.second)
   }
}