go语言实现内网穿透(udp版)
相关内容 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 来源：简书 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。