相关内容 node.js实现内网穿透: https://www.jianshu.com/p/d2d4f8bff599 kotlin实现内网穿透: https://www.jianshu.com/p/c8dc095c758e

最大设计连接数: 65535

前面写了个udp转tcp再转udp的工具, 打算用它和tcp内网穿透结合使用 来实现udp内网穿透, 但是在实际使用中发现存在网速较慢的问题, 初步判断为运营商网络问题(使用http下载也一样, 使用单线程只能达到1MB/S内, 3条就可以达到10MB/S. 上传没有问题). 这个问题没法解决就只好再写个udp版. 本来想用udp打洞写的, 但是有一个网络不支持... 只好用服务器转发写, 但是仍然存在一个小问题, 暂时不打算解决. 结尾会讲.

实现代码 服务端: package main

import ( "crypto/rsa" "crypto/sha1" "crypto/x509" "encoding/pem" "errors" "fmt" "log" "net" "os" "strings" "sync" "time" )

var ( privateKeyStr = "-----BEGIN PRIVATE KEY-----\n" + "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAJYBf37uy0sVXyxb\n" + "bMDjvQzxv/ke3UWCSkYhUd8e+MjGHeT8A9V9aVemg3qUogND/Pgtlz6bTd9p5H+q\n" + "OCXnrZbSwdAN7O/9x3zhRzaEOH+9OJ8vpF80DuatbdqqJXFPiDO+nfbufNyT8n+b\n" + "N9UXISAVv7Nay+vTEySD401czDDzAgMBAAECgYAE9u26TLrrtDxfInN5+s+R8xpQ\n" + "a2YVW9eLdKTaBpNjSbNJldGmqiznWrp1PyARjZl8uT2NM+Si5UVLuF19W6qSC1Tw\n" + "bn2brBSsFsufKQff0XXRsD8OqKT5h5/PlRATYgisZonD/v0SPfDHROcNCFiOelEv\n" + "kKZAJgJS3vghZx5jCQJBAMTb4esPOApK+6wXlfVShvRiac9UWW9KBYLwpqya5Cjd\n" + "X/QUGVwywMFkNgRnBz7yWdJd1zuXfuI77N87BXYOE68CQQDDEjfaKCyZJ73RfNJo\n" + "ED5DRfZXm86RPBDlZznJ4shjNVbk1sGClYAk0WuAHeIZJVpm1HpME6NSCfumqeOq\n" + "z1P9AkAQu+xJcgK+hT89ksexkfFc5ty9vhrYJf+v8MsKUyRgAOl+MxMwzjOqfN1G\n" + "pIduJ2XRRx7btvYXPybUlwzQy0OLAkBIexlznt/LXH/kOcv4TKjF2FYLAWKEhlwE\n" + "0REg2Xn5mtUZnE40lhYSGBoodXIQQ9fOQ37Zi6ZwkjMGHzPvwK+FAkAe9gHRMI2u\n" + "lzwVp/AQntBMXmw92IULIlfRmfV1jDBYuT0JHUUGZqfCrz+iDW8Ot24QBzLbwKxJ\n" + "JRrmXbUxObmC\n" + "-----END PRIVATE KEY-----" natDispatcherAddr = ":8989" natPasswords = []string{"yzh"} timeOut = time.Second * 60 * 2 serverMap = map[string]*Server{} mapMutex sync.Mutex clientIndex = 0 maxLength = 0 )

func main() { log.Println("入参: " + strings.Join(os.Args[1:], " ")) if len(os.Args) == 2 { natDispatcherAddr = os.Args[1] } log.SetFlags(log.LstdFlags | log.Lshortfile) startServer() }

func Start(natDispatcherAddrStr string, natPasswordsArr []string) { natDispatcherAddr = natDispatcherAddrStr natPasswords = natPasswordsArr startServer() }

func startServer() { log.Println("NatU分发服务地址: " + natDispatcherAddr) go func() { for { time.Sleep(time.Second * 60) println() log.Println("natU转发Size:", len(serverMap), ",maxLength:", maxLength) mapMutex.Lock() for _, value := range serverMap { log.Println("natU转发中:", value.toString()) } mapMutex.Unlock() } }() privateKey, err := loadPrivateKey(privateKeyStr) if err != nil { log.Panicln(err) }

listenerAddr, err := net.ResolveUDPAddr("udp", natDispatcherAddr)
if err != nil {
    log.Println(err)
    return
}
network := "udp"
if listenerAddr.IP.To4() != nil {
    network = "udp4"
} else if listenerAddr.IP.To16() != nil {
    network = "udp6"
}
listenerConn, err := net.ListenUDP(network, listenerAddr)
if err != nil {
    log.Println(err)
    return
}
defer listenerConn.Close()
buffer := make([]byte, 1024*64)
for {
    // log.Println("监听消息")
    n, clientAddr, err := listenerConn.ReadFromUDP(buffer)
    if err != nil {
        log.Println(err)
        if errors.Is(err, net.ErrClosed) {
            break
        }
        time.Sleep(time.Second)
        continue
    }
    if n > maxLength {
        maxLength = n
    }
    if n < 1 {
        log.Println("异常消息:", clientAddr)
        continue
    }
    data := make([]byte, n)
    copy(data, buffer)

    cmd := data[0]
    // log.Println("收到消息:", cmd, clientAddr, "=>", listenerConn.LocalAddr())

    switch {
    case cmd == 1:
        // log.Println("心跳数据")
        realData := data[1:]
        // 鉴权
        value := handleNatUAuth(realData, privateKey, clientAddr, listenerConn)
        listenerConn.SetWriteDeadline(time.Now().Add(time.Second * 3))
        listenerConn.WriteToUDP([]byte{value}, clientAddr)
    case cmd == 0:
        // 真实数据
        cIndex := int(data[1])*256 + int(data[2])
        realData := data[3:]
        // log.Println("转发到:", cIndex)
        handleRealData(cIndex, realData)
    }
}

}

func handleRealData(cIndex int, realData []byte) { servers := []*Server{} mapMutex.Lock() for _, server := range serverMap { servers = append(servers, server) } mapMutex.Unlock() for _, server := range servers { server.clientMutex.Lock() for _, value := range server.clientMap { if value.index == cIndex { // log.Println("转成功:", cIndex, value.clientAddr) value.openConn.SetWriteDeadline(time.Now().Add(time.Second * 3)) value.openConn.WriteToUDP(realData, value.clientAddr) value.lastLime = time.Now() break } } server.clientMutex.Unlock() } }

func handleNatUAuth(cmdData []byte, privateKey *rsa.PrivateKey, clientAddr *net.UDPAddr, listenerConn *net.UDPConn) byte { // decryptedText, err := rsa.DecryptPKCS1v15(nil, privateKey, cmdData) decryptedText, err := rsa.DecryptOAEP(sha1.New(), nil, privateKey, cmdData, nil) if err != nil { log.Println("DecryptPKCS1v15 err", err) return 3 } info := string(decryptedText) infos := strings.Split(info, "-") if len(infos) < 2 { log.Println("infos error", infos) return 4 } version := 1 pwdOk := false for _, v := range natPasswords { if v == infos[1] { version = 1 pwdOk = true break } } for _, v := range natPasswords { if v == infos[0] { version = 2 pwdOk = true break } } if !pwdOk { log.Println("密码错误", infos) return 5 } var openAddrs []string switch version { case 1: openAddrs = infos[:1] case 2: openAddrs = infos[1:] default: openAddrs = infos[:1] } // log.Println("openAddrs:", openAddrs)

for index, address := range openAddrs {
    server := getServer(address, index, version, clientAddr, strings.Join(openAddrs, "-"), listenerConn)
    if server == nil {
        log.Println("getServer nil")
        return 6
    }
}
return 1

}

func getServer(address string, index int, version int, clientAddr *net.UDPAddr, openAddrsStr string, listenerConn *net.UDPConn) *Server { addr := strings.Split(address, ":") if len(addr) < 2 { log.Println("address error", address) return nil } port := addr[len(addr)-1] mapMutex.Lock() defer mapMutex.Unlock() server := serverMap[port] if server != nil { if server.address != address { log.Println("端口重复", server.address, address) return nil } if server.openAddrsStr != openAddrsStr { log.Println("openAddrsStr不同", server.openAddrsStr, openAddrsStr) return nil } if server.version != version { log.Println("版本不同", server.version, version) return nil } } else { listenerAddr, err := net.ResolveUDPAddr("udp", address) if err != nil { log.Println(err) return nil } network := "udp" if listenerAddr.IP.To4() != nil { network = "udp4" } else if listenerAddr.IP.To16() != nil { network = "udp6" } openConn, err := net.ListenUDP(network, listenerAddr) if err != nil { log.Println(err) return nil } log.Println("开放地址:", address, "对方index:", index, "版本:", version) server = &Server{address: address, index: index, version: version, createTime: time.Now(), openConn: openConn, openAddrsStr: openAddrsStr, clientMap: map[string]*Client{}} serverMap[port] = server go server.accept(port, listenerConn) } server.clientAddr = clientAddr server.openConn.SetReadDeadline(time.Now().Add(timeOut)) return server }

type Server struct { openAddrsStr string index int version int createTime time.Time address string openConn *net.UDPConn clientAddr *net.UDPAddr clientMap map[string]*Client clientMutex sync.Mutex }

type Client struct { index int lastLime time.Time clientAddr *net.UDPAddr openConn *net.UDPConn }

func (server *Server) accept(port string, listenerConn net.UDPConn) { buffer := make([]byte, 102464) for { n, clientAddr, err := server.openConn.ReadFromUDP(buffer) if err != nil { log.Println(err) break } if n > maxLength { maxLength = n } if n < 1 { log.Println("空消息:", clientAddr, port) continue } data := make([]byte, n) copy(data, buffer) // log.Println("转发消息:", len, clientAddr, "=>", server.index)

    server.clientMutex.Lock()
    client := server.clientMap[clientAddr.String()]
    if client == nil {
    getClient:
        for {
            clientIndex++
            index := clientIndex
            for key, value := range server.clientMap {
                if value.index == index {
                    log.Println("index无效:", index)
                    continue getClient
                }
                if time.Since(value.lastLime) >= timeOut {
                    delete(server.clientMap, key)
                }
            }
            client = &Client{index: index, clientAddr: clientAddr, openConn: server.openConn}
            server.clientMap[clientAddr.String()] = client
            break
        }
    }
    client.lastLime = time.Now()
    server.clientMutex.Unlock()
    listenerConn.SetWriteDeadline(time.Now().Add(time.Second * 3))
    listenerConn.WriteToUDP(append([]byte{byte(10 + server.index), byte(client.index / 256), byte(client.index % 256)}, data...), server.clientAddr)
}
server.openConn.Close()
mapMutex.Lock()
delete(serverMap, port)
mapMutex.Unlock()
log.Println("释放端口:", port)

}

func (server *Server) toString() string { ms := time.Since(server.createTime).Milliseconds() s := ms / 1000 m := s / 60 h := m / 60 runTime := fmt.Sprintf("%d天%d时%d分%d秒", h/24, h%24, m%60, s%60) return fmt.Sprintf("%s=>%s, index: %d, version: %d, %s", server.address, server.clientAddr, server.index, server.version, runTime) }

func loadPrivateKey(privateKeyStr string) (privateKey *rsa.PrivateKey, err error) { block, _ := pem.Decode([]byte(privateKeyStr)) if block == nil { return nil, fmt.Errorf("解码私钥失败") } key, err := x509.ParsePKCS8PrivateKey(block.Bytes) if err != nil { return nil, err } privateKey, ok := key.(*rsa.PrivateKey) if !ok { return nil, fmt.Errorf("非法私钥文件") } return privateKey, nil }

客户端: package main

import ( "crypto/rand" "crypto/rsa" "crypto/sha1" "crypto/x509" "encoding/pem" "errors" "fmt" "log" "net" "os" "strings" "sync" "time" )

var ( publicKeyStr = "-----BEGIN PUBLIC KEY-----\nMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCWAX9+7stLFV8sW2zA470M8b/5\nHt1FgkpGIVHfHvjIxh3k/APVfWlXpoN6lKIDQ/z4LZc+m03faeR/qjgl562W0sHQ\nDezv/cd84Uc2hDh/vTifL6RfNA7mrW3aqiVxT4gzvp327nzck/J/mzfVFyEgFb+z\nWsvr0xMkg+NNXMww8wIDAQAB\n-----END PUBLIC KEY-----\n"

natDispatcherAddr = "127.0.0.1:8989"
natPassword       = "yzh"
rateInterval      = time.Second * 15
timeOut           = time.Second * 60 * 2
natMapArr         = []string{
    ":1701-192.168.3.25:1701",
    ":11771-127.0.0.1:1771",
    ":11772-127.0.0.1:1772",
    ":11773-127.0.0.1:1773",
}
errMap = map[int]string{
    2: "config error or port used",
    3: "DecryptPKCS1v15 err",
    4: "infos error",
    5: "密码错误",
    6: "getServer nil",
    7: "",
    8: "",
    9: "",
}
listenerConn *net.UDPConn
serverAddr   *net.UDPAddr
mapMutex     sync.Mutex
forwardMap   = map[int]*net.UDPConn{}
natSuccess   = false
maxLength    = 0

)

func main() { log.Println("入参: " + strings.Join(os.Args[1:], " ")) if len(os.Args) == 2 { natDispatcherAddr = os.Args[1] } log.SetFlags(log.LstdFlags | log.Lshortfile) startClient() }

func Start(natDispatcherAddrStr string, natPasswordStr string, natMapStr []string) { natDispatcherAddr = natDispatcherAddrStr natPassword = natPasswordStr natMapArr = natMapStr startClient() }

func startClient() { log.Println("NatU分发服务地址: " + natDispatcherAddr) publicKey, err := loadPublicKey(publicKeyStr) if err != nil { log.Panicln(err) } natParams := []string{natPassword} // 通过index找到需要转发的位置 localServerAddrs := []string{} for _, v := range natMapArr { mapArr := strings.Split(v, "-") natServerOpenAddr := mapArr[0] localServerAddr := mapArr[1] log.Println("NatU服务器开放地址: "+natServerOpenAddr, "本地服务地址: "+localServerAddr) natParams = append(natParams, natServerOpenAddr) localServerAddrs = append(localServerAddrs, localServerAddr) } //密码, 开放端口 natInfo, err := rsa.EncryptOAEP(sha1.New(), rand.Reader, publicKey, []byte(strings.Join(natParams, "-")), nil) if err != nil { log.Panicln(err) } go func() { for { log.Println("startNat") creatClient(localServerAddrs) listenerConn = nil serverAddr = nil natSuccess = false time.Sleep(time.Second) } }()

go func() {
    for {
        if listenerConn == nil || serverAddr == nil {
            time.Sleep(time.Second)
            continue
        }
        // log.Println("主动发消息:", listenerConn.LocalAddr(), "=>", serverAddr)
        data := append([]byte{1}, natInfo...)
        listenerConn.SetWriteDeadline(time.Now().Add(time.Second * 5))
        listenerConn.WriteToUDP(data, serverAddr)
        time.Sleep(rateInterval)
    }
}()
for {
    time.Sleep(time.Second * 60)
    println()
    log.Println("natU转发Size:", len(natMapArr), ",maxLength:", maxLength, ",natSuccess:", natSuccess)
    for _, value := range natMapArr {
        log.Println("natU转发中:", strings.ReplaceAll(value, "-", "=>"))
    }
}

}

func creatClient(localServerAddrs []string) { var err error serverAddr, err = net.ResolveUDPAddr("udp", natDispatcherAddr) if err != nil { log.Println(err) return } listenerAddr, err := net.ResolveUDPAddr("udp", ":0") if err != nil { log.Println(err) return } listenerConn, err = net.ListenUDP("udp", listenerAddr) if err != nil { log.Println(err) return } defer listenerConn.Close() buffer := make([]byte, 1024*64) for { listenerConn.SetReadDeadline(time.Now().Add(timeOut)) n, clientAddr, err := listenerConn.ReadFromUDP(buffer) if err != nil { log.Println(err) break } if n > maxLength { maxLength = n } if n < 1 { log.Println("异常消息:", clientAddr) continue } data := make([]byte, n) copy(data, buffer)

    // if clientAddr.Port != serverAddr.Port || clientAddr.IP.String() != serverAddr.IP.String() {
    if clientAddr.Port != serverAddr.Port {
        log.Println("异常消息:", serverAddr, clientAddr)
        continue
    }
    cmd := data[0]
    // log.Println("收到响应:", cmd, clientAddr, "=>", listenerConn.LocalAddr())
    switch {
    case cmd == 1:
        if !natSuccess {
            natSuccess = true
            log.Println("natU建立成功")
        }
        // log.Println("心跳数据")
    case cmd > 1 && cmd < 10:
        errMsg := errMap[int(cmd)]
        if errMsg == "" {
            errMsg = "config error"
        }
        log.Panicln(cmd, errMsg, natMapArr)
    case cmd >= 10:
        forwardAddress := localServerAddrs[data[0]-10]
        clinetIndex := int(data[1])*256 + int(data[2])
        realData := data[3:]
        // log.Println("转发到:", forwardAddress)
        handleClientRequest(clientAddr, realData, forwardAddress, clinetIndex)
    }
}

}

func handleClientRequest(clientAddr net.UDPAddr, clientData []byte, forwardAddress string, clinetIndex int) { if clientAddr == nil { return } clientAddrString := clientAddr.String() mapMutex.Lock() defer mapMutex.Unlock() forwardConn := forwardMap[clinetIndex] if forwardConn == nil { forwardAddr, err := net.ResolveUDPAddr("udp", forwardAddress) if err != nil { log.Println(err) return } forwardConn, err = net.DialUDP("udp", nil, forwardAddr) if err != nil { log.Println(err) return } infoStr := clientAddrString + "=>" + forwardAddress + "=>" + forwardConn.LocalAddr().String() + "=>" + forwardConn.RemoteAddr().String() log.Println("添加udp转发:" + infoStr) forwardMap[clinetIndex] = forwardConn buffer := make([]byte, 102464) go func() { defer forwardConn.Close() forwardSuccess := false for { forwardConn.SetReadDeadline(time.Now().Add(timeOut)) n, serverAddr, err := forwardConn.ReadFromUDP(buffer) if err != nil { log.Println(err) if errors.Is(err, net.ErrClosed) { break } if nerr, ok := err.(net.Error); ok && nerr.Timeout() { break } time.Sleep(time.Second) continue } // if serverAddr.Port != forwardAddr.Port || serverAddr.IP.String() != forwardAddr.IP.String() { if serverAddr.Port != forwardAddr.Port { log.Println("异常消息:", serverAddr.String(), forwardAddr.String()) continue } if n > maxLength { maxLength = n } if !forwardSuccess { forwardSuccess = true log.Println("udp转发成功:", serverAddr.String(), n, clientAddrString) } // log.Println("服务端消息:", serverAddr.String(), len, clientAddrString) data := make([]byte, n) copy(data, buffer) listenerConn.SetWriteDeadline(time.Now().Add(time.Second * 5)) listenerConn.WriteToUDP(append([]byte{0, byte(clinetIndex / 256), byte(clinetIndex % 256)}, data...), clientAddr) } log.Println("移除udp:" + infoStr) mapMutex.Lock() delete(forwardMap, clinetIndex) mapMutex.Unlock() }() } // log.Println("客户端消息:", clientAddrString, len(clientData)) forwardConn.SetWriteDeadline(time.Now().Add(time.Second * 5)) forwardConn.Write(clientData) }

func loadPublicKey(publicKeyStr string) (publicKey *rsa.PublicKey, err error) { block, _ := pem.Decode([]byte(publicKeyStr)) if block == nil { return nil, fmt.Errorf("解码公钥失败") } key, err := x509.ParsePKIXPublicKey(block.Bytes) if err != nil { return nil, err } publicKey, ok := key.(*rsa.PublicKey) if !ok { return nil, fmt.Errorf("非法公钥文件") } return publicKey, nil }

存在的问题: 客户端fd00::2给fd00::5发消息 服务端知道是fd00::2发来的, 但是不知道是哪个ip接收的, 也无法控制使用哪个ip回消息, 测试中发现服务端可能会用fd00::6发消息给fd00::2, 在部分网络下这个消息是发送不过去的(这也是我没用打洞法的原因), 问题点就在这里. 解决方案也很简单, 分别监听每个ip, 但是需要监听设备ip的变化, 不想这样做. 不知道有没有大佬有更好的解决方案

画个草图好理解些:

image.png

作者：今天i你好吗 链接：https://www.jianshu.com/p/c3191a36ee84 来源：简书 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

若无特别标注，本文由alex创作
采用知识共享署名 3.0，可自由转载、引用，但需署名作者且注明文章出处。