相关内容
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
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。