NAT打洞

置顶 已于 2024-10-23 06:09:20 修改
阅读量2.5k 收藏 21
点赞数 3
分类专栏： 笔记 网络 文章标签： javascript 网络 udp tcp
于 2023-07-13 06:21:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/li1055107552/article/details/131693446
版权
本文介绍了NAT的四种类型及其判断方式，重点阐述了UDP和TCP打洞的原理和过程。通过示例代码展示了UDP打洞如何实现内网主机间的通信，并探讨了TCP打洞的难点。文章最后提出了TCP打洞的策略，并讨论了在实际应用中的挑战，如文件传输和P2P通信的实现。
摘要由CSDN通过智能技术生成

前言


2024 年的 1024 过来给 2023.07 的这篇文章打几个补丁 ~O(∩_∩)O 哈哈~

如果你是 NAT 的小白，对 NAT 并不了解，这篇文章就很适合你，但其中的代码部分写的很是一般，末尾关于 TCP 部分的描述也不到位，建议仅阅读 初始 部分 以及看完几个图就好，知道大概的打洞流程即可，不建议深究和细看

若你对 NAT 有了一些初步的了解，又或是想知道怎么与 NAT 建立连接的
我强烈建议你直接阅读下一篇文章 TCP打洞，实现P2P（附Node源码）

如果你向来只打逆风局，可以直接跳转到 NAT4 的文章 TCP实现P2P（NAT3-NAT4）


一、初识NAT

1.1 NAT 类型

NAT 分为四种类型，分别为 NAT1234 🙃

  1. NAT1 - 完全锥形NAT(Full Clone NAT)
  2. NAT2 - 限制性锥形NAT(Restricted Clone NAT)
  3. NAT3 - 端口限制性锥形NAT( Port Restricted Clone NAT)
  4. NAT4 - 对称式NAT(Symmetric NAT)

NAT1234
怎么判断呢，先从 绿色 箭头看起。

现在假设

192.168.0.100 通过 8000 端口 访问 114.135.246.90 的 9001 端口

经过NAT之后，会形成这样一种结果：

  1. 内网的 192.168.0.100:8000 ↔ 120.230.117.10:9999 NAT公网IP，形成绑定关系
  2. 服务端 114.135.246.90:9001 被 120.230.117.10:9999 NAT公网IP，访问

然后如果：
8000 端口 能收到 紫色 发来的消息，就是 NAT1
8000 端口 收不到 紫色 发来的消息，却能收到 浅蓝色 线发来的消息，就是 NAT2
8000 端口 收不到 紫色 和 浅蓝色 线发来的消息，只能收到 绿色 线返回来的消息，就是 NAT3 | NAT4

NAT3 和 NAT4 的区别：
NAT3 是 8000 端口与 9999 端口形成绑定关系，不管通过 8000 端口访问谁，·都是从 9999 端口出去
NAT4 是 8000 端口与 9999 端口形成的绑定关系是有条件的，8000 端口访问同一 ip:port 时，都会从 9999 端口出去，但通过 8000 端口访问其他 ip:port 时，就会绑定 NAT 其他端口，比如 9990

我这移动大内网，一般都是NAT3，手机开数据流量，基本都是NAT4

2. NAT 打洞原理

打洞，说白了就是让 NAT 留下一条访问记录
谁来打洞，就在谁的 NAT 上，留下一条对方的记录，这样在对方访问自己的时候，不会因为自己的 NAT 因为缺少记录而把数据包丢弃

( 对于NAT来说，因为没记录，所以也不知道转发给内网的谁，就算知道 如果没有记录，则数据包的来源也不一定合法 )


二、UDP打洞

2.1 看图

UDP打洞

这里我们通过一个服务端，然后让A B两个内网主机进行UDP打洞并通信。适用于 NAT123

说明：
A、B 分别为两个不同内网下的主机
NA、NB分别问 A 和 B 的 NAT 出口
中间的 90.20.88.99 为服务端主机，下方称为 S

图解：

  1. 首先我们让 A:8001 与 S:9001 建立UDP通信
    此时 NA 就会留下 内网的 A:8001 ↔ NA:3333 的绑定，NA:3333 对 S:9001 的访问
    即：A:8001 - NA:3333 - S:9001

  2. 接着让 B 也执行同样的操作
    此时 NB 就会留下 内网的 B:6000 ↔ NB:4444 的绑定，NB:4444 对 S:9001 的访问
    即：B:6000 - NB:4444 - S:9001

  3. 此时 S 知道 NA 和 NB，且还知道 （看着上面的两个‘即’ 继续往下看）
    与 A 通信可以用 S:9001 向 NA:3333 发送消息
    与 B 通信可以用 S:9001 向 NB:4444 发送消息
    若让 A - B 直接通信，得让 A 知道 NB，B 知道 NA
    所以
    将 NB:4444 通过 S:9001 发送给 NA:3333， A 知道可以通过 NB:4444 向 B 通信
    将 NA:3333 通过 S:9001 发送给 NB:4444， B 知道可以通过 NA:3333 向 A 通信

  4. 若此时 B:6000 - NB:4444 直接向 NA:3333 进行 UDP 通信
    NA 会因为不存在 A:8001 - NA:3333 - NB:4444 这条记录，而将数据包丢弃 （同理 A 奕是如此，此时双方是对等的）
    但此时，在 NB 中则会留下 B:6000 - NB:4444 - NA:3333 这样一条记录，这一步就是所谓的 “打洞”

  5. NB:4444 向 NA:3333 发送完之后，此时 A:8001 - NA:3333 再向 NB:4444 发送 UDP 数据包时
    因为 NB 有了 B:6000 - NB:4444 - NA:3333 这样一条记录，所以会将 NA:3333 发来的数据包转发到 B:6000 中
    并且此时在 NA 也会留下 A:8001 - NA:3333 - NB:4444 这条记录

  6. 之后 因为
    NA 有：
    A:8001 - NA:3333 - NB:4444
    A:8001 - NA:3333 - S:9001
    NB 有：
    B:6000 - NB:4444 - NA:3333
    B:6000 - NB:4444 - S:9001
    所以 A 和 B 都可以与 S 直接通信，A 与 B 也可以直接通信

2.2 看码

// client.js

const dgram = require("dgram");

const option = process.argv.splice(2)

let localPORT = 6677
const SERVER_PORT = option[0] || 9001
const SERVER_ADDR = option[1] || "114.135.246.90"

let localInfo = ""
let serverInfo = ""

let timeout = setInterval(() => {
    createClient()
}, 1000)

let getConnect = (client) => {
    console.log(`与${serverInfo}连接成功。`);

    client.send("")

    // process.stdin.on('data', data => {
    //     let sendData = data.toString().trim()
    //     client.send(sendData);
    // })
}

let getMessage = (client, data, rinfo) => {
    console.log(`[${rinfo.address}:${rinfo.port}]:${data.toString()}`)

    let res = JSON.parse(data.toString())
    if (res.msg == "wait") {

    }
    if (res.msg == "toClient") {
        let second = res.second
        createNewClient(second.addr, second.port)
        client.close()
    }
    if (res.msg == "toServer") {
        let first = res.first
        createServer(first.addr, first.port)
        client.close()
    }

}

function createClient() {

    const client = dgram.createSocket("udp4");
    try {

        client.bind(localPORT, "", () => {
            clearInterval(timeout)
        })

        client.connect(SERVER_PORT, SERVER_ADDR)

        client.on('connect', () => getConnect(client))

        client.on('message', (data, rinfo) => {
            getMessage(client, data, rinfo)
        })

        client.on("listening", (res) => {
            localInfo = `[${client.address().address}:${client.address().port}]`
            serverInfo = `[${SERVER_ADDR}:${SERVER_PORT}]`
            console.log(`${localInfo} - ${serverInfo}`);
            // client.send(`${localInfo}-已连接-serverInfo`,SERVER_PORT,SERVER_ADDR)
        })

        client.on("close", (res) => {
            // console.log("close", "正在关闭");
        })

        client.on("error", (err) => {
            console.log("error", "发生一个错误");
            console.log("正在重连...");
            localPORT++
            // createClient()
        })

    } catch (error) {
        console.log("错啦！！！")
        console.log(error)
    }

}

function createNewClient(serverAddr, serverPort) {

    const client = dgram.createSocket("udp4");

    try {

        client.bind(localPORT)

        client.connect(serverPort, serverAddr)

        client.on('connect', () => {
            console.log(`与${serverInfo}连接成功。`);
            client.send(`${localInfo}`)
            console.log("回车发送消息：");

            process.stdin.on('data', data => {
                let sendData = data.toString().trim()
                console.log(`${localInfo}: ${sendData}`);
                client.send(sendData);
            })
        })

        client.on('message', (data, rinfo) => {
            console.log(`[${rinfo.address}:${rinfo.port}]: ${data.toString()}`)
        })

        client.on("listening", (res) => {
            localInfo = `[${client.address().address}:${client.address().port}]`
            serverInfo = `[${serverAddr}:${serverPort}]`
            console.log(`${localInfo} - ${serverInfo}`);
            // client.send(`${localInfo}-已连接-serverInfo`,SERVER_PORT,SERVER_ADDR)
        })

        client.on("close", (res) => {
            console.log("close", res);
        })

        client.on("error", (err) => {
            console.log("error", "发生一个错误");
            console.log("正在重连...");
            localPORT++
            // createClient()
        })

    } catch (error) {
        console.log("错啦！！！")
        console.log(error)
    }
}

function createServer(clientAddr, clientPort) {

    const server = dgram.createSocket('udp4')
    server.bind(localPORT)

    // 开洞
    server.send("", clientPort, clientAddr)
    // 通知服务端准备好了
    server.send("ready", SERVER_PORT, SERVER_ADDR)

    server.on("listening", () => {
        console.log(`start to listening: ${server.address().address}:${server.address().port}`)

        console.log("回车发送消息：");
        process.stdin.on('data', data => {
            let sendData = data.toString().trim()
            console.log(`${localInfo}: ${sendData}`);
            server.send(sendData, clientPort, clientAddr);
        })
    })

    server.on("connect", (res) => {
        console.log("connect:", res);
    })

    server.on("message", (msg, rinfo) => {
        console.log(`[${rinfo.address}:${rinfo.port}]: ${msg.toString()}`)
        let message = msg.toString()
        // server.send(message, clientPort, clientAddr)
    })

    server.on("close", (res) => {
        console.log("close", res);
    })

    server.on("error", (err) => {
        console.log("error", err);
    })
}

// server.js

const dgram = require('dgram')

const server = dgram.createSocket('udp4')

let first = ""
let second = ""
let alive = {}

server.bind(9001)

server.on("listening", () => {
    console.log(`start to listening: ${server.address().address}:${server.address().port}`)
})

server.on("connect", (res) => {
    console.log("connect:", res);
})

server.on("message", (message, rinfo) => {
    let msg = message.toString()
    console.log(`[${rinfo.address}:${rinfo.port}]:${msg.toString()}`)

    let count = Object.keys(alive).length
    if (count == 0) {
        first = {
            addr: rinfo.address,
            port: rinfo.port
        }
        server.send(`{"res": "wait"}`, rinfo.port, rinfo.address)
    }
    else if(count == 1){
        second = {
            addr: rinfo.address,
            port: rinfo.port
        }
        let res = {
            first,
            msg: "toServer"
        }
        server.send(JSON.stringify(res), rinfo.port, rinfo.address)
    }
    alive[`${rinfo.address}:${rinfo.port}`] = {
        addr: rinfo.address,
        port: rinfo.port
    }
    console.log(alive)

    if (msg == "ready") {
        let res = {
            second,
            msg: "toClient"
        }
        server.send(JSON.stringify(res), first.port, first.addr)
        alive = {}
    }
    
    
})

server.on("close", (res) => {
    console.log("close", res);
})

server.on("error", (err) => {
    console.log("error", err);
})

这是个小的 demo，分别对应 client.js 和 server.js
A 和 B 通用 client.js，S 部署 server.js 即可

用的时候先在 S 启动 server.js
然后分别在 A B 启动 client.js 即可，连接成功后
若将 S 中的 server.js停掉，A B仍能正常通信，则试验成功

三、TCP打洞

TCP打洞

TCP打洞，打洞的原理其实还是那个原理，就是在NAT上留下记录。

TCP的过程就不细说了，但是TCP打洞会比UDP打洞困难得多 (因为我也没成功)

主要是因为，TCP和UDP不同：

UDP是无链接，同一个端口既可以发送 同时可以监听接收。同一个端口，可以给很多人发送，也可以接收很多人发来的信息

但TCP是套接字，自己的 IP:PORT 是与对方的 IP:PORT 是绑定的，期间端口处于被占用的状态，只能发送或者是收到response回来的信息，不能直接从 发送状态 改为 监听状态，需要先进行断开 或者 设置为端口复用

但在端口复用的过程中，NAT可能会因此而改变端口，其原因可能是因为处于 TIME_WAIT 状态，又或是像 NAT4 一样处理新的TCP 连接

所以 此时想要通过TCP打洞，建立可靠的TCP连接，这时候就要搬出 TCP 状态迁移图 了
TCP状态迁移图
这个时候，想要提高成功打通的概率，可以让双方互发SYN，以达到 同时打开 的效果
因为一个端口发送失败，可能会导致这个端口在短时间内不能再使用

所以我想到的一个方法就是：
先让 A 向 S 发送正常的 TCP 连接，让 S 知道了 A-NA 的 TCP 端口
然后 S 向 NA 端口 往后的 10个端口 同时循环发送 SYN，A 也向 S 发送10+次 SYN，这样就有极大地概率命中其中一个端口
只要 NA 放行了一个任意一个 S 发来的 SYN，就能进行完整握手，建立起TCP连接通信

当然啦，如果这里的 S 是公网IP，则 A 向 S 建立的连接都可以连上
这里主要是想实现的是 S 向 A 主动建立起的连接
因为如果 S 能主动向A建立连接，S 就可以换成 B-NB
最终的效果其实就是 NA 和 NB 相互不断发送 SYN，以同时打开 NA 和 NB 的通道 建立连接

具体的实现，可以看下一篇：TCP打洞，实现P2P（附Node源码）

四、结语

最后再说两句吧…

后来才知道，原来这就是叫 p2p…好吧是我浅薄了


然后关于UDP打洞的部分，我给我的小伙伴讲，给他讲完了之后
他说了一句：“你这是在建立 UDP 的可靠连接嘛”，然后两个人看着图都沉默了…


然后TCP部分，我确实没能在两个大NAT网上打通，所以我也好奇和请教一下大佬们，有什么好的解决方案实现TCP打洞和建立连接的呢
因为如果光用UDP打洞实现连接之后，简单的通信还好，但如果是用来传输文件就好像不太现实？还要手写校验和重传机制？还要注意MTU、数据包大小？

或者像酷狗、迅雷这种利用客户端的，又是怎么实现的呢

如果可以的话，能不能有个 node.js 的 demo，C语言真的好难顶…


另外：
如果觉得颜色有点花里胡哨的话，之后会在这 NAT打洞 同步更新一篇吧

过来填坑啦！
下一篇：TCP打洞，实现P2P（附Node源码）
再下一篇：TCP实现P2P (NAT3-NAT4)


完

参考文章

细粒丁
关注
专栏目录
NAT穿透（UDP打洞）
anque1234的博客
07-26 2346
1、NAT（Network Address Translator）介绍 NAT有两大类，基本NAT和NAPT。 1.1、基本NAT 静态NAT：一个公网IP对应一个内部IP，一对一转换 动态NAT：N个公网IP对应M个内部IP，不固定的一对一转换关系 1.2、NAPT（Network Address/Port Translator） 现在基本使用这种，又分为对称和锥型N...
TCP打洞NAT
08-03
超经典的ＴＣＰ打洞程度源代码。目前网上的全是ＵＤＰ打洞，很少有ＴＣＰ方面的。
基于UDP的双NAT3环境P2P打洞示例
最新发布
qq_52525445的博客
09-20 1292
peer-to-peer简称P2P，即点对点技术。又称对等互联网络技术，是一种网络新技术，简单的说，P2P直接将计算机直接联系起来，在两台都是公网ip下的计算机可以轻松实现两台电脑的连接，但是运营商现在基本给的都是非公网ip，而且进入家庭中也会由路由器再次进行NAT，这样两台电脑将无法直接连接，如果传输信息，通常都是两台电脑向具有公网ip的服务器发送信息，再由服务器转发给对方，这样传输速度势必会大打折扣，采用p2p技术可将两台在NAT后的电脑直接连接，达到点对点传输。
ICE协议下NAT穿越的实现
u013043103的博客
10-30 1952
前言： 之前写了篇关于WebRTC的文章：iOS下音视频通信-基于WebRTC ，由于它是基于点对点连接的，自然而然需要NAT穿越的技术，否则消息将无法传递。 在WebRTC使用了ICE协议框架，里面提到了STUN和TURN两个协议，而NAT穿越实现就是由这两个协议共同协调完成的。 正文： 一. 首先来简单讲讲什么是NAT？ 原来这是因为IPV4引起的，我们上网很可能会处在一个NAT设备...
NAT基本原理及穿透详解(打洞)
qq_64162562的博客
03-15 3712
本文主要是摘录了网上许多其他文章的内容并进行了整理，信息略多。NAT(Network Address Translation，网络地址转换), 用来将内网地址和端口号转换成合法的公网地址和端口号，建立一个会话，与公网主机进行通信。NAT的使用是为了解决公网IP有限及局域网安全性的问题。实际上NAT分为基础型NAT（静态NAT即Static NAT，动态NAT即Dynamic NAT/Pooled NAT）和NAPT。
NAT类型和打洞流程
流媒体巅峰之路
08-20 3603
一、NAT 1.含义 NAT技术（NetworkAddressTranslation，网络地址转换）是一种把内部网络（简称为内网）私有IP地址转换为外部网络（简称为外网）公共IP地址的技术，它使得一定范围内的多台主机只利用一个公共IP地址连接到外网，可以在很大程度上缓解了公网IP地址紧缺的问题。 2.实现方式 静态转换、动态转换、端口多路复用。 静态转换：是指将内部网络的私有IP地址转换为公有IP地址，IP地址对是一对一的，是一成不变的。通过静态配置，把一个固定...
UDP_MakeHole.rar_NAT 打洞_NAT 打洞udp_udp 打洞_udp打洞_透传
09-22
udp 穿透， 传透NAT，打洞。不仅有文档的介绍，将原理介绍清楚，而且有可以直接运行的源码。学习udp打洞的好资料。
NAT打洞穿越
10-22
实现两台NAT内主机之间的通信，基于UDP传输协议，VC写的
C#实现UDP NAT打洞技术详解
在讨论的上下文中，UDP协议因其无连接特性，在NAT打洞中得到了广泛应用。资源中可能包含了关于UDP NAT穿透的理论知识，以及如何在C#中实现这一过程的源码。" 知识点: 1. NAT（网络地址转换）: - NAT 是一种网络...
C# udp NAT打洞客户端1/2，可以实现不能局域网的通信，亲测
09-21
C# udp NAT打洞客户端，可以实现不能局域网的通信，亲测,测试请需要设置一个IP地址，这个IP地址为外网的IP地址，如果没有外网的IP地址，请通过路由器设置DMZ主机地址，也可以实现外网的功能，UDP NAT的原理可以在我...
nat打洞 c语言 实现
09-19
在C语言中，"nat打洞"通常指的是网络地址转换（Network Address Translation，简称NAT）过程中的端口映射技术。NAT是路由器或防火墙的一种常见功能，用于在一个私有IP地址空间内提供对外部网络的访问，隐藏内部网络...
NAT打洞技术基础
qq_41354940的博客
03-21 481
 NAT对待UDP的实现方式有4种，分别如下：Full Cone NAT完全锥形NAT，所有从同一个内网IP和端口号发送过来的请求都会被映射成同一个外网IP和端口号，并且任何一个外网主机都可以通过这个映射的外网IP和端口号向这台内网主机发送包。Restricted Cone NAT限制锥形NAT，它也是所有从同一个内网IP和端口号发送过来的请求都会被映射成同一个外网IP和端口号。与完全锥形不同的是...
P2P NAT 打洞 穿透
kingboy100的专栏
05-30 1919
1 2 3 4 路由设备通过NAT杜绝”陌生人“访问你的PC，NAT全称是Network Address Translation，翻译过来就叫地址转换协议，有了它，再也不用为艳照发愁了。 NAT的工作粗略的有两点： 1.在内网的地址端口与公网的地址端口间建立映射。 2.为内网的地址建立信任链表。 第一点很好理解，假设你的内网IP是192.168.1.2， 路
nat打洞
时代终结者
05-17 269
http://www.cnblogs.com/OpenCoder/diary/2011/06/29/2093895.html
NAT穿透，打洞，NAT类型
zhangxiong2532的博客
03-07 3924
看完就懂了，详细易懂 一、什么是NAT？为什么要使用NAT？ NAT是将私有地址转换为合法IP地址的技术，通俗的讲就是将内网与内网通信时怎么将内网私有IP地址转换为可在网络中传播的合法IP地址。NAT的出现完美地解决了lP地址不足的问题，而且还能够有效地避免来自网络外部的攻击，隐藏并保护网络内部的计算机。  二、NAT的分类 STUN标准中，根据内部终端的地址(LocalIP:Loca
【转】NAT路由器打洞原理
weixin_30237281的博客
07-24 186
什么是打洞，为什么要打洞 由于Internet的快速发展 IPV4地址不够用，不能每个主机分到一个公网IP 所以使用NAT地址转换。 下面是我在网上找到的一副图 一般来说都是由私网内主机（例如上图中“电脑A-01”）主动发起连接，数据包经过NAT地址转换后送给公网上的服务器（例如上图中的“Server”），连接建立以后可双向传送数据，NAT设备允许私网内主机主动向公网内主机发送数据,但却...
NAT穿透技术、 打洞流程
nuptxiaoli
11-02 377
NAT 打洞组合 Peer A Peer B 是否可以打洞 全锥型 全锥型 是 全锥型 受限锥型 是 全锥型 端口受限锥型 是 全锥型 对称型 是 受限锥型
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值