NAT打洞

已于 2023-07-13 06:42:44 修改
阅读量1.8k 收藏 14
点赞数 1
分类专栏： 笔记 网络 文章标签： javascript 网络 udp tcp
于 2023-07-13 06:21:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/li1055107552/article/details/131693446
版权

一、初识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 的通道 建立连接

四、结语

最后再说两句吧…

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


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


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

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

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


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


完

参考文章

细粒丁
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
NAT打洞穿越
10-22
实现两台NAT内主机之间的通信，基于UDP传输协议，VC写的
ICE协议下NAT穿越的实现
u013043103的博客
10-30 1909
前言： 之前写了篇关于WebRTC的文章：iOS下音视频通信-基于WebRTC ，由于它是基于点对点连接的，自然而然需要NAT穿越的技术，否则消息将无法传递。 在WebRTC使用了ICE协议框架，里面提到了STUN和TURN两个协议，而NAT穿越实现就是由这两个协议共同协调完成的。 正文： 一. 首先来简单讲讲什么是NAT？ 原来这是因为IPV4引起的，我们上网很可能会处在一个NAT设备...
NAT类型和打洞流程
流媒体巅峰之路
08-20 3343
一、NAT 1.含义 NAT技术（NetworkAddressTranslation，网络地址转换）是一种把内部网络（简称为内网）私有IP地址转换为外部网络（简称为外网）公共IP地址的技术，它使得一定范围内的多台主机只利用一个公共IP地址连接到外网，可以在很大程度上缓解了公网IP地址紧缺的问题。 2.实现方式 静态转换、动态转换、端口多路复用。 静态转换：是指将内部网络的私有IP地址转换为公有IP地址，IP地址对是一对一的，是一成不变的。通过静态配置，把一个固定...
网络类型NAT3改NAT1 基于（联通）光猫桥接、路由器红米AX5、win10系统
热门推荐
TopTab的博客
02-08 6万+
粗略步骤 1、光猫改桥接 2、路由器设置拨号上网，填入账号密码，配置DMZ静态IP等 3、在win10验证NAT类型 前置准备 宽带的账号密码（这个打客服问，一般是默认密码） 默认密码123456,或者888888,或者是身份证号码后6位 第一步：（联通）光猫改桥接 方法一：光猫改桥接，直接联系宽带的客服，叫他帮你改 方法二：获得超级管理地址和超级权限密码，然后自己手动修改（作者TopTab采用） 1、电话联通客服，转人工，转宽带，告诉客服你需要桥接，然后，和技术人员交流后，获得光猫超级权限地址以及超级权限
P2P网络NAT穿透原理(打洞方案)
07-15 6937
NAT有4种类型：完全锥形NAT(Full Clone NAT)、限制性锥形NAT(Restricted Clone NAT)、端口限制性锥形NAT( Port Restricted Clone NAT)、对称式NAT(Symmetric NAT)，前面3种是锥形NAT(Clone NAT)。
nat类型科普提升
whatday的专栏
12-27 6795
首先可以在百度百科了解到什么是“NAT”，传送门→“NAT科普”然后呢，看了那么多我们大概就知道了一些关于NAT的基本知识，比如说“定义”、“功能”、“实现方式”及“类型”提升NAT类型的好处：浏览网页、观看视频、游戏等更顺畅，下载速度更稳定快速，特别是对那些玩ED2K/PT下载、PS4/XBox主机游戏的，提升NAT类型后更有可能获取到HigtID、更容易进入游戏房间连线等。好了，废话有点多了。...
python nat p2p打洞压测程序
01-06
Python NAT P2P打洞压测程序是一种利用Python编写的测试工具，...通过对UDP协议的运用、NAT打洞技术的实现以及压测工具的集成，我们可以深入理解P2P网络在实际环境中的表现，为开发高效、稳定的P2P应用提供有力支持。
UDP_MakeHole.rar_NAT 打洞_NAT 打洞udp_udp 打洞_udp打洞_透传
09-22
udp 穿透， 传透NAT，打洞。不仅有文档的介绍，将原理介绍清楚，而且有可以直接运行的源码。学习udp打洞的好资料。
TCP打洞NAT
08-03
超经典的ＴＣＰ打洞程度源代码。目前网上的全是ＵＤＰ打洞，很少有ＴＣＰ方面的。
UDP穿透NAT 打洞 P2P
09-09
UDP打洞相关的资料，包括原理，说明，以后相关的源码，是学习udp打洞的绝好资料。自己用过，感觉不错。
C#UDP打洞NAT
12-01
本文将深入探讨C#环境下如何利用UDP协议进行NAT打洞。 **一、理解NAT工作原理** NAT是一种网络技术，用于将私有IP地址转换为公网IP地址，以节省有限的公网IP资源。在NAT背后，设备的通信通过一系列映射规则进行...
C# udp NAT打洞客户端1/2，可以实现不能局域网的通信，亲测
09-21
C# udp NAT打洞客户端，可以实现不能局域网的通信，亲测,测试请需要设置一个IP地址，这个IP地址为外网的IP地址，如果没有外网的IP地址，请通过路由器设置DMZ主机地址，也可以实现外网的功能，UDP NAT的原理可以在我...
UDP打洞软件
07-16
接着，B根据收到的信息向A的内网地址发送数据，触发NAT打洞。同时，A也向B的内网地址发送数据，尝试在B的NAT上打洞。如果成功，两个设备就能直接通信了。 在实现过程中，还需要考虑以下几点： 1. NAT类型识别：不同...
介绍一种无需第三方服务器就能完成NAT点对点P2P穿透的打洞技术.zip
01-21
介绍一种无需第三方服务器就能完成NAT点对点P2P穿透的打洞技术.zip
NAT的四种类型以及类型探测
Jian Sun_的博客
12-06 1万+
NAT的四种类型以及类型探测
NAT基本原理及穿透详解(打洞)
最新发布
qq_64162562的博客
03-15 2206
本文主要是摘录了网上许多其他文章的内容并进行了整理，信息略多。NAT(Network Address Translation，网络地址转换), 用来将内网地址和端口号转换成合法的公网地址和端口号，建立一个会话，与公网主机进行通信。NAT的使用是为了解决公网IP有限及局域网安全性的问题。实际上NAT分为基础型NAT（静态NAT即Static NAT，动态NAT即Dynamic NAT/Pooled NAT）和NAPT。
NAT介绍
hey5178的博客
06-09 1142
现在大多数设备的网络采用的是ipv4网络，ipv4中ip的定义为x.x.x.x，其中每一位为0-255，所以全球的ip总数256^4，这个数量是不足够全球使用的，为了保证每个人都能有ip使用，NAT技术诞生了。和端口限制式NAT不同的是，端口限制式NAT是所有请求映射到相同的公网IP地址和端口，而对称式NAT是为不同的请求建立不同的映射。由此可见产生NAT的直接原因就是你的电脑并没有真正的公网ip，你的电脑只是运营商手中的那个公网ip下面的众多电脑中的一台，所以如果能向运营商获得公网ip就可以实现。
NAT穿透，UDP打洞程序
OSSRS
05-07 4564
在看NAT穿透和UDP打洞原理，网上都是讲原理，没有程序，我把程序写出来。 server.py，辅助打洞的服务器。 peer.server.py，被打洞的节点。 peer.client.py，主动打洞的节点。 基本原理是： 1. peer.client向peer.server发个包，把自己的洞打好，这样peer.server可以给peer.client发包。 这个包会被NAT拒绝掉，所
UDP打洞 Python
06-11
UDP打洞是一种技术，用于在两个设备之间建立UDP通信。在Python中，可以使用socket库来实现UDP打洞。具体实现方法可以参考以下步骤： 1. 在设备A和设备B上分别创建UDP Socket，并绑定不同的端口； 2. 设备A向设备B发送一条UDP消息，并在消息中包含自己的IP地址和端口号； 3. 设备B收到消息后，提取出设备A的IP地址和端口号，并将自己的IP地址和端口号发送回去； 4. 设备A收到设备B的回复后，提取出设备B的IP地址和端口号，两个设备就可以通过这些信息建立UDP通信。 需要注意的是，UDP打洞需要满足一定的条件，例如两个设备都处于NAT网络环境中，并且NAT设备支持UDP打洞等。同时，UDP打洞也存在一些限制和安全风险，需要慎重使用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值