NAT穿透技术详解(udp打洞精髓附代码) - lyztyycode的博客 - CSDN博客

标签: | 发表时间:2019-01-12 18:13 | 作者:
出处:https://blog.csdn.net

以前自己写的代码都只是在本地进行c/s通信,今天想写一个可以跨越外网的c/s通信,这里我就用udp实现一个点对点的不同外网的通信。用到的技术就是nat穿透技术,这里最直接使用的就是udp打洞技术。文中如有表述不清楚,欢迎提问。

如果你需要nat穿透技术的详解点这里: nat穿透浅析

需要的设备:

一个已知的外网服务器S(ip+port),两个位于不同外网的客户端A, B

首先要知道udp打洞的流程:

1.A客户端发消息给S,B客户端发消息给服务器S。

2.S转发A的ip+port(这里是A的外网ip+port,位于nat转发器上)给客户端B,S转发B的ip+port给客户端A。

这样A,B都知道了对端的ip+port。

3.A发消息给B,这里,B会屏蔽掉这条消息,但是在A的nat映射上加上了一条映射,允许A接收来自B的消息。在A上打洞

B-->A。

4.B发消息给A,这里,由于流程3A能接收到这条消息,同时在B的nat映射上加了一条映射,允许B接收来自A的消息。在B上

打洞,A-->B。

5.到此,A,B打洞成功。

我在学习这块知识的时候看网上的案例和解释大多是相互转发,而且表达不清楚,代码实例拿来用也是问题百出,解决不了实际问题,所以自己也是严格要求自己,有问题的代码不敢贴出来。

下面是代码,实现的是A回射B的消息。

服务器S的代码:

      #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <string.h>
#include <arpa/inet.h>
#include <errno.h>
#include <error.h>
//中间枢纽获得A客户端的外网ip和port发送给客户端B,获得客户端B的外网ip和port发送给A
//B通过A打的洞发数据给A,这时候A拒收B的消息,因为A的nat映射中没有B的信息,但是这次通
//信却在B的网管中添加了映射可以接受A的
//消息,同理A通过B打的洞发数据给B,这时候由于B可以接受A的消息,所以数据接收成功且在A
//的映射中加入了B的信息,从而A与B可以跨服务器通信。实现p2p
/* 由于已知的外网服务器S可能并没有AB客户端的映射关系,所以要先建立A与S 还有 B与S之间的映射,这样才能进行udp穿透。 */

#define ERR_EXIT(m)\
    do{\
        perror(m);\
        exit(1);\
    }while(0)

/* 用来记录客户端发送过来的外网ip+port */
typedef struct{
    struct in_addr ip;
    int port;
}clientInfo;

int main()
{
    /* 一个客户端信息结构体数组,分别存放两个客户端的外网ip+port */
    clientInfo info[2];
    /* 作为心跳包需要接收的一个字节 */
    /* char ch; */ 
    char str[10] = {0};

    /* udp socket描述符 */
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(sockfd == -1)
        ERR_EXIT("SOCKET");

    struct sockaddr_in serveraddr;
    memset(&serveraddr, 0, sizeof(serveraddr));
    serveraddr.sin_addr.s_addr = inet_addr("0.0.0.0");
    serveraddr.sin_port = htons(8888);
    serveraddr.sin_family = AF_INET;    

    int ret = bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
    if(ret == -1)
        ERR_EXIT("BIND");

    /* 服务器接收客户端发来的消息并转发 */
    while(1)
    {
        bzero(info, sizeof(clientInfo)*2);
        /* 接收两个心跳包并记录其与此链接的ip+port */
        socklen_t addrlen = sizeof(struct sockaddr_in);
        /* recvfrom(sockfd, &ch, sizeof(ch), 0, (struct sockaddr *)&serveraddr, &addrlen); */
        recvfrom(sockfd, str, sizeof(str), 0, (struct sockaddr *)&serveraddr, &addrlen);
        memcpy(&info[0].ip, &serveraddr.sin_addr, sizeof(struct in_addr));
        info[0].port = serveraddr.sin_port;

        printf("A client IP:%s \tPort:%d creat link OK!\n", inet_ntoa(info[0].ip), ntohs(info[0].port));

        /* recvfrom(sockfd, &ch, sizeof(ch), 0, (struct sockaddr *)&serveraddr, &addrlen); */
        recvfrom(sockfd, str, sizeof(str), 0, (struct sockaddr *)&serveraddr, &addrlen);
        memcpy(&info[1].ip, &serveraddr.sin_addr, sizeof(struct in_addr));
        info[1].port = serveraddr.sin_port;

        printf("B client IP:%s \tPort:%d creat link OK!\n", inet_ntoa(info[1].ip), ntohs(info[1].port));

        /* 分别向两个客户端发送对方的外网ip+port */
        printf("start informations translation...\n");
        serveraddr.sin_addr = info[0].ip;
        serveraddr.sin_port = info[0].port;
        sendto(sockfd, &info[1], sizeof(clientInfo), 0, (struct sockaddr *)&serveraddr, addrlen);

        serveraddr.sin_addr = info[1].ip;
        serveraddr.sin_port = info[1].port;
        sendto(sockfd, &info[0], sizeof(clientInfo), 0, (struct sockaddr *)&serveraddr, addrlen);
        printf("send informations successful!\n");
    }
    return 0;
}

客户端A的代码:

      #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

/* 原理见服务器源程序 */
#define ERR_EXIT(m)\
    do{\
        perror(m); \
        exit(1);\
    }while(0)

typedef struct{
    struct in_addr ip;
    int port;
}clientInfo;

/* 用于udp打洞成功后两个客户端跨服务器通信 */
void echo_ser(int sockfd, struct sockaddr* addr, socklen_t *len)
{   
    printf("start recv B data...\n");
    char buf[1024];
    while(1)
    {
        bzero(buf, sizeof(buf));
        //接收B发来的数据
        recvfrom(sockfd, buf, sizeof(buf)-1, 0, addr, len);
        printf("%s \n", buf);
        //向B发送数据
        printf("send data to B ...\n");
        sendto(sockfd, buf, sizeof(buf)-1, 0, addr, sizeof(struct sockaddr_in));
        buf[strlen(buf)] = '\0';
        if(strcmp(buf, "exit") == 0)
            break;
    }
}

int main()
{
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(sockfd == -1)
        ERR_EXIT("SOCKET");
    //向服务器发送心跳包的一个字节的数据
    char ch = 'a';
    clientInfo info;
    socklen_t addrlen = sizeof(struct sockaddr_in);
    bzero(&info, sizeof(info));
    struct sockaddr_in clientaddr;
    memset(&clientaddr, 0, sizeof(clientaddr));
    //实际情况下这里用一个已知的外网的服务器的端口号
    clientaddr.sin_port = htons(8888);
    //实际情况下这里用一个已知的外网的服务器的ip地址,这里保护我的云服务器ip所以没有写出来,自己换一下ip地址。
    clientaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    clientaddr.sin_family = AF_INET;

    /* 向服务器S发送数据包 */
    sendto(sockfd, &ch, sizeof(ch), 0, (struct sockaddr *)&clientaddr, sizeof(struct sockaddr_in));
    /* 接收B的ip+port */
    printf("send success\n");
    recvfrom(sockfd, &info, sizeof(clientInfo), 0, (struct sockaddr *)&clientaddr, &addrlen);
    printf("IP: %s\tPort: %d\n", inet_ntoa(info.ip), ntohs(info.port));

    clientaddr.sin_addr = info.ip;
    clientaddr.sin_port = info.port;
    
    sendto(sockfd, &ch, sizeof(ch), 0, (struct sockaddr *)&clientaddr, sizeof(struct sockaddr_in));
    echo_ser(sockfd, (struct sockaddr *)&clientaddr, &addrlen);

    close(sockfd);
    return 0;
}

客户端B代码:

      #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

/* 原理见服务器源程序 */
#define ERR_EXIT(m)\
    do{\
        perror(m); \
        exit(1);\
    }while(0)

typedef struct{
    struct in_addr ip;
    int port;
}clientInfo;

/* 用于udp打洞成功后两个客户端跨服务器通信 */
void echo_ser(int sockfd, struct sockaddr* addr, socklen_t *len)
{   
    char buf[1024];
    while(1)
    {
        bzero(buf, sizeof(buf));
        printf(">> ");
        fflush(stdout);
        fgets(buf, sizeof(buf)-1, stdin);
        //向A发送数据
        sendto(sockfd, buf, strlen(buf), 0, addr, sizeof(struct sockaddr_in));

        //接收A发来的数据
        bzero(buf, sizeof(buf));
        printf("start recv A data...\n");
        recvfrom(sockfd, buf, sizeof(buf)-1, 0, addr, len);
        printf("%s \n", buf);
        buf[strlen(buf)] = '\0';
        if(strcmp(buf, "exit") == 0)
            break;
    }
}

int main()
{
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(sockfd == -1)
        ERR_EXIT("SOCKET");
    //向服务器发送心跳包的一个字节的数据
    char ch = 'a';
    /* char str[] = "abcdefgh"; */
    clientInfo info;
    socklen_t addrlen = sizeof(struct sockaddr_in);
    bzero(&info, sizeof(info));
    struct sockaddr_in clientaddr, serveraddr;
    /* 客户端自身的ip+port */
    /* memset(&clientaddr, 0, sizeof(clientaddr)); */
    /* clientaddr.sin_port = htons(8888); */
    /* clientaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); */   
    /* clientaddr.sin_family = AF_INET; */

    /* 服务器的信息 */
    memset(&clientaddr, 0, sizeof(clientaddr));
    //实际情况下为一个已知的外网的服务器port
    serveraddr.sin_port = htons(4399);
    //实际情况下为一个已知的外网的服务器ip,这里仅用本地ip填充,下面这行的ip自己换成已知的外网服务器的ip
    serveraddr.sin_addr.s_addr = inet_addr("127.0.0.1");   
    /* clientaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); */   
    serveraddr.sin_family = AF_INET;

    /* 向服务器S发送数据包 */
    sendto(sockfd, &ch, sizeof(ch), 0, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in));
    /* sendto(sockfd, str, sizeof(str), 0, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in)); */
    /* 接收B的ip+port */
    printf("send success\n");
    recvfrom(sockfd, &info, sizeof(clientInfo), 0, (struct sockaddr *)&serveraddr, &addrlen);
    printf("IP: %s\tPort: %d\n", inet_ntoa(info.ip), ntohs(info.port));

    serveraddr.sin_addr = info.ip;
    serveraddr.sin_port = info.port;

    sendto(sockfd, &ch, sizeof(ch), 0, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in));
    echo_ser(sockfd, (struct sockaddr *)&serveraddr, &addrlen);
    close(sockfd);
    return 0;
}

以上代码经过本人调试测验过的,可以实现跨外网通信,没有任何问题。

在写这个项目的时候遇到的问题:

1.起初,我本地的客户端一直连不上服务器S,即使代码我在本地测试成功的情况下,后来发现是因为我云服务器指定的监听端口8888没有开,不接收外来的消息。把端口开放,成功解决。

2.服务器S能接收AB的连接消息,也可以转发AB的ip和port给对端,AB也能获得对端的ip+port但是,当B发消息给A的时候A阻塞在while(1)循环中的第一个recvfrom上,为什么呢?

原因是打洞过程我少了流程3、4,因为B发送消息给A,A会屏蔽B的消息。此时A应该也给B发送一条消息。

所以我在原来A、B的代码

      echo_ser(sockfd, (struct sockaddr *)&serveraddr, &addrlen);

前面都加了一句:

      sendto(sockfd, &ch, sizeof(ch), 0, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in));

这样无论A还是B先执行这条语句都能打洞成功,如果你在这条语句前面加一句sleep(5)你就能感知到打洞的过程。

到此,问题解决,实现了预期的功能,希望我的文章对你有帮助。如果有表述不清楚,欢迎提问。



相关 [nat 技术 udp] 推荐:

NAT穿透(UDP打洞) - heaventouch - 博客园

- -
1、NAT(Network Address Translator)介绍. NAT有两大类,基本NAT和NAPT. 静态NAT:一个公网IP对应一个内部IP,一对一转换. 动态NAT:N个公网IP对应M个内部IP,不固定的一对一转换关系. 现在基本使用这种,又分为对称和锥型NAT. 锥型NAT,有完全锥型、受限制锥型、端口受限制锥型三种:.

NAT穿透技术详解(udp打洞精髓附代码) - lyztyycode的博客 - CSDN博客

- -
以前自己写的代码都只是在本地进行c/s通信,今天想写一个可以跨越外网的c/s通信,这里我就用udp实现一个点对点的不同外网的通信. 用到的技术就是nat穿透技术,这里最直接使用的就是udp打洞技术. 如果你需要nat穿透技术的详解点这里:. 一个已知的外网服务器S(ip+port),两个位于不同外网的客户端A, B.

UDPonNAT—— 一个UDP代理,能让普通的UDP应用跨越NAT网络设备

- 19GHz - iGFW
UDPonNAT是一个UDP代理,它能让普通的UDP应用跨越NAT网络设备. UDPonNAT使用Python编写,遵守GPL协议发布,可运行的平台包括Windows/Linux/Unix等. UDPonNAT有什么用途:. 普通的UDP应用大多具有如下的工作方式:. Server运行后,UDP服务被绑定到一个固定的IP:Port上,等待来自 Client的UDP数据包并响应.

iptables NAT 学习

- - BlogJava-首页技术区
为了搞清楚iptables NAT的过程,做了这个实验. 使用了1台双网卡服务器和1台单网卡服务器,2个网段. 1.       为了看到调度服务器上的数据转发过程,首先在调度服务器上分出内核的debug日志:. l 在/etc/rsyslog.conf最后增加:kern.debug /var/log/iptables.log.

nat穿透原理

- - 开源软件 - ITeye博客
一直以来,说起NAT穿透,很多人都会被告知使用UDP打孔这个技术,基本上没有人会告诉你如何使用TCP协议去穿透(甚至有的人会直接告诉你TCP协议是无法实现穿透的). 但是,众所周知的是,UDP是一个无连接的数据报协议,使用它就必须自己维护收发数据包的完整性,这常常会大大增加程序的复杂度,而且一些程序由于某些原因,必须使用TCP协议,这样就常常令一些开发TCP网络程序的人员“谈穿透色变”.

使用 iptables 透明代理 TCP 与 UDP

- - 依云's Blog
本文来自 依云's Blog,转载请注明. 很早之前,我在 《Linux「真」全局 HTTP 代理方案》中介绍了 redsocks 方案. 不过它只处理了 TCP,并没有处理 UDP,DNS 也是采用强制 TCP 的方式来处理的,再加上它本身还要将请求转发到真正的代理客户端,延迟比较高. 然后,还可以结合 Wi-Fi 分享 或者 网络命令空间,玩点更有趣的.

[转]iptables防火墙与NAT服务

- - 小鸥的博客
iptables防火墙与NAT服务. (1)设置在不同的网络或网络安全域之间的一系列部件的组合,它能增强机构内部网络的安全性. (2)通过审查经过每一个数据包,判断它是否有相匹配的过滤规则,根据规则先后顺序一一进行比较,直到满足其中的一条规则为止,然后依据控制机制做出相应的动作,若都不能满足,则将数据包丢弃,从而保护网络安全.

Xen 虚拟机的 NAT 网络配置

- - vpsee.com
我们使用 Xen 虚拟机的时候一般都是用桥接(bridging)的方式把虚拟机(domU)直接暴露在网络上,就像网络上单独的一台服务器一样,这种方式简单好用,不用在 dom0 做任何的端口转发也不用任何 iptable 规则. 不过除了 bridging 以外,Xen 还支持 routing 和 NAT 的方式配置虚拟机网络.

NAT穿透解决方案介绍

- - 编程语言 - ITeye博客
Agent B看到的source address就是经过转换后的IP和Port并不知道Agent A的局域网地址;当Agent B的响应到达Agent A的NAT设备后,NAT设备查找内存中保存的和这个外网地址相对应的内网地址,如果找到后就将这个data packet转发到这个地址,这样就实现了通信.

Docker 中 NAT 和 HOST 的区别

- - snoopyxdy的博客
官方说明使用Dokcer容器启动应用可以媲美直接在宿主机上启动的性能,宣称使用Docker启动应用大约可以达到原来性能的90%,如此低的性能损耗应当归功于Docker容器虚拟化的轻量级. 但是事实真的如官方所说,仅有10%的损耗吗. 我们下面将比较原生启动 redis 实例和使用Docker启动的性能对比.