5

问题是关于想要使用 Tun/Tap 模块的 Linux 主机的正确配置。

我的目标：

利用现有的路由软件（以下为APP1和APP2），但拦截并修改其发送和接收的所有消息（由Mediator完成）。

我的场景：

              Ubuntu 10.04 Machine
+---------------------------------------------+
|                                             |
|APP1 --- tap1 --- Mediator --- tap2 --- APP2 |
|                                             |
+---------------------------------------------+

  • tap1 和 tap2：分别使用 IFF_TAP 标志和 IP 10.0.0.1/24 和 10.0.0.2/24 设置的设备。创建设备的代码如下：

    #include <stdlib.h>
#include <stdio.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <linux/if.h>
#include <linux/if_tun.h>
#include <string.h>
#include <errno.h>
#include <sys/resource.h>

void createTun(char *, char *, short);

int main(void)
{
    const short FLAGS = IFF_TAP;
    char *tunName;
    char *tunIP;

    // Create tap1
    tunName = "tap1\0";
    tunIP = "10.0.0.1/24\0";
    createTun(tunName, tunIP, FLAGS);
    printf("Created %s with IP %s\n", tunName, tunIP);

    // Create tap2
    tunName = "tap2\0";
    tunIP = "10.0.0.2/24\0";
    createTun(tunName, tunIP, FLAGS);
    printf("Created %s with IP %s\n", tunName, tunIP);

    return 0;
}

void createTun(char *tunName, char *tunIP, short FLAGS)
{
    char *cmd;
    char *cloneDev = "/dev/net/tun";
    char *cmdIPLinkUpTemplate = "ip link set %s up";
    char *cmdIPAddrAddTemplate = "ip addr add %s dev %s";
    int cmdIPLinkUpRawLength = strlen(cmdIPLinkUpTemplate) - 2;
    int cmdIPAddrAddRawLength = strlen(cmdIPAddrAddTemplate) - 4;
    FILE *fp;
    int fd, err, owner, group;
    struct ifreq ifr;

    owner = geteuid();
    group = getegid();

    // open the clone device
    if((fd = open(cloneDev, O_RDWR)) < 0)
    {
        perror("OPEN CLONEDEV failed.");
        exit(EXIT_FAILURE);
    }

    memset(&ifr, 0, sizeof(struct ifreq));
    ifr.ifr_flags = FLAGS;
    strncpy(ifr.ifr_name, tunName, strlen(tunName));

    // create the device
    if(ioctl(fd, TUNSETIFF, (void *) &ifr) < 0)
    {
        perror("IOCTL SETIFF denied.");
        close(fd);
        exit(EXIT_FAILURE);
    }

    // set dev owner
    if(owner != -1)
    {
    if(ioctl(fd, TUNSETOWNER, owner) < 0)
    {
        perror("IOCTL SETOWNER denied.");
        close(fd);
        exit(EXIT_FAILURE);
    }
    }

    // set dev group
    if(group != -1)
    {
    if(ioctl(fd, TUNSETGROUP, group) < 0)
    {
        perror("IOCTL SETGROUP denied.");
        close(fd);
        exit(EXIT_FAILURE);
    }
    }

    // set dev persistent
    if(ioctl(fd, TUNSETPERSIST, 1) < 0)
    {
        perror("IOCTL SETPERSIST denied.");
        close(fd);
        exit(EXIT_FAILURE);
    }

    // Set dev up
    cmd = malloc(cmdIPLinkUpRawLength + strlen(tunName) + 1);
    sprintf(cmd, cmdIPLinkUpTemplate, ifr.ifr_name);
    fp = popen(cmd, "r");
    if(fp == NULL)
    {
        perror("POPEN failed.");
        close(fd);
        free(cmd);
        exit(EXIT_FAILURE);
    }
    pclose(fp);
    free(cmd);

    // Assign IP
    cmd = malloc(cmdIPAddrAddRawLength + strlen(tunIP) + strlen(tunName) + 1);
    sprintf(cmd, cmdIPAddrAddTemplate, tunIP, tunName);
    fp = popen(cmd, "r");
    if(fp == NULL)
    {
        perror("POPEN failed.");
        close(fd);
        free(cmd);
        exit(EXIT_FAILURE);
    }

    pclose(fp);
    free(cmd);

    return;
}

  • Mediator：自己编写的小代码，用于在 tap1 和 tap2 之间简单地中继数据。基本结构如下：

    #include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/ip.h>
#include <sys/ioctl.h>
#include <sys/resource.h>
#include <sys/epoll.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <linux/if.h>
#include <linux/if_tun.h>

int main(int argc, char *argv[])
{
    const int NOF_FD = 2;
    const char *TUN1 = "tap1";
    const char *TUN2 = "tap2";
    const char *CLONEDEV = "/dev/net/tun";
    int fd_tun1, fd_tun2, fd_epoll;
    struct ifreq ifr_tun1, ifr_tun2;
    struct epoll_event ev;
    const int MAX_EVENTS = 1;
    int ready, s, t;
    const int MAX_BUF = 2000;
    char buf[MAX_BUF];
    struct sockaddr_in to;
    const short FLAGS = IFF_TAP;

    // Open tap1
    if((fd_tun1 = open(CLONEDEV, O_RDWR)) < 0)
    {
        perror("OPEN CLONEDEV for tun1 failed");
        exit(EXIT_FAILURE);
    }

    memset(&ifr_tun1, 0, sizeof(struct ifreq));
    ifr_tun1.ifr_flags = FLAGS;
    strcpy(ifr_tun1.ifr_name, TUN1);
    if(ioctl(fd_tun1, TUNSETIFF, (void *) &ifr_tun1) < 0)
    {
        perror("IOCTL SETIFF for tap1 failed");
        close(fd_tun1);
        exit(EXIT_FAILURE);
    }

    // Open tap2
    if((fd_tun2 = open(CLONEDEV, O_RDWR)) < 0)
    {
        perror("OPEN CLONEDEV for tap2 failed");
        exit(EXIT_FAILURE);
    }

    memset(&ifr_tun2, 0, sizeof(struct ifreq));
    ifr_tun2.ifr_flags = FLAGS;
    strcpy(ifr_tun2.ifr_name, TUN2);
    if(ioctl(fd_tun2, TUNSETIFF, (void *) &ifr_tun2) < 0)
    {
        perror("IOCTL SETIFF for tun2 failed");
        close(fd_tun1);
        close(fd_tun2);
        exit(EXIT_FAILURE);
    }

    // Prepare EPOLL
    if((fd_epoll = epoll_create(NOF_FD)) < 0)
    {
        perror("EPOLL CREATE failed");
        close(fd_tun1);
        close(fd_tun2);
        exit(EXIT_FAILURE);
    }

    memset(&ev, 0, sizeof(ev));
    ev.events = EPOLLIN;
    ev.data.fd = fd_tun1;
    if(epoll_ctl(fd_epoll, EPOLL_CTL_ADD, fd_tun1, &ev) < 0)
    {
        perror("EPOLL CTL ADD fd_tun1 failed");
        close(fd_tun1);
        close(fd_tun2);
        close(fd_epoll);
        exit(EXIT_FAILURE);
    }

    memset(&ev, 0, sizeof(ev));
    ev.events = EPOLLIN;
    ev.data.fd = fd_tun2;
    if(epoll_ctl(fd_epoll, EPOLL_CTL_ADD, fd_tun2, &ev) < 0)
    {
        perror("EPOLL CTL ADD fd_tun2 failed");
        close(fd_tun1);
        close(fd_tun2);
        close(fd_epoll);
        exit(EXIT_FAILURE);
    }

    // Do relay
    while(1)
    {
        if((ready = epoll_wait(fd_epoll, &ev, MAX_EVENTS, -1)) < 0)
        {
            if(errno == EINTR)
                continue;
            else
            {
                perror("EPOLL WAIT failed");
                close(fd_tun1);
                close(fd_tun2);
                close(fd_epoll);
                exit(EXIT_FAILURE);
            }
        }

        //printf("EPOLL WAIT SIGNALED\n");

        if(ev.events & EPOLLIN)
        {
            if((s = read(ev.data.fd, buf, MAX_BUF)) < 0)
            {
                perror("READ failed");
                close(fd_tun1);
                close(fd_tun2);
                close(fd_epoll);
                exit(EXIT_FAILURE);
            }

            printf("Read from %s. Bytes: %d\nData:\n", (ev.data.fd == fd_tun1 ? "tun1" : "tun2"), s);
            int k;
            for(k = 0; k < s; k++)
            {
                printf("%c", buf[k]);
            }
            printf("\n");

            t = (ev.data.fd == fd_tun1) ? fd_tun2 : fd_tun1;

            if((s = write(t, buf, s)) < 0)
            {
                perror("WRITE failed");
                close(fd_tun1);
                close(fd_tun2);
                close(fd_epoll);
                exit(EXIT_FAILURE);
            }

            printf("Written to %s. Bytes: %d\n", (t == fd_tun1 ? "tun1" : "tun2"), s);

            if(epoll_ctl(fd_epoll, EPOLL_CTL_DEL, ev.data.fd, NULL) < 0)
            {
                perror("EPOLL CTL DEL failed");
                close(fd_tun1);
                close(fd_tun2);
                close(fd_epoll);
                exit(EXIT_FAILURE);
            }

            if(epoll_ctl(fd_epoll, EPOLL_CTL_ADD, ev.data.fd, &ev) < 0)
            {
                perror("EPOLL CTL ADD failed");
                close(fd_tun1);
                close(fd_tun2);
                close(fd_epoll);
                exit(EXIT_FAILURE);
            }
        }

        printf("\n\n");
    }
}

  • APP1 和 APP2：OSPF 路由守护进程分别通过 tap1 和 tap2 进行通信。对守护进程的跟踪表明，基本上涉及以下系统调用：

    socket(PF_INET, SOCK_RAW, 0X59 /*IPPROTO_??? */) = 8 // Opening a socket for OSPF and tap1
fcntl64(8, F_SETFL, 0_RDONLY | 0_NONBLOCK) = 0
setsockopt(8, SOL_IP, IP_TOS, [192], 4) = 0
setsockopt(8, SOL_SOCKET, SO_PRIORITY, [7], 4) = 0
setsockopt(8, SOL_IP, IP_PKTINFO, [1], 4) = 0
setsockopt(8, SOL_IP, IP_MTU_DISCOVER, [0], 4) = 0
setsockopt(8, SOL_IP, IP_MULTICAST_LOOP, [0], 4) = 0
setsockopt(8, SOL_IP, IP_MULTICAST_TTL, [1], 4) = 0
setsockopt(8, SOL_IP, IP_MUTLICAST_IF, "\0\0\0\0\n\0\0\1\223\0\0\0", 12) = 0
setsockopt(8, SOL_SOCKET, SO_BINDTODEVICE, "tap1\0\0\0\0\0\0\0\0\0\0\0\0\0\315\375\307\250\352\t\t8\207\t\10\0\0\0\0", 32) = 0
setsockopt(8, SOL_IP, IP_ADD_MEMBERSHIP, "340\0\0\5\n\0\0\1\223\0\0\0", 12) = 0

// Then it gets in a cycle like:
select(9, [3, 7, 8], [], NULL, {1, 0}) = 0 (Timeout)
clock_gettime(CLOCK_MONOTONIC, {120893, 360452769}) = 0
time(NULL)
clock_gettime(CLOCK_MONOTONIC, {120893, 360504525}) = 0
select(9, [3, 7, 8], [], NULL, {1, 0}) = 0 (Timeout)
clock_gettime(CLOCK_MONOTONIC, {120894, 363022746}) = 0
time(NULL)
...

我的用法：

  • 将wireshark连接到tap1。（还没有看到流量）。
  • 启动APP1。（wireshark 看到源为 10.0.0.1 (tap1) 的 IGMP 和 OSPF 消息）
  • 启动APP2。（wireshark 仍然只能看到源为 10.0.0.1 (tap1) 的 IGMP 和 OSPF 消息，因为 Mediator 尚未运行）
  • 启动调解器。（wireshark 现在可以看到来自 tap1 和 tap2 的 IGMP 和 OSPF 消息）。

我的问题：

即使wireshark - 连接到tap1 - 看到来自tap1 和tap2 的消息，APP2 也没有收到APP1 发送的消息，APP2 也没有收到来自APP1 的消息。在上面显示的 strace 提取中，select() 调用永远不会返回文件描述符 8，它实际上是连接到 tap1 的套接字。

我的问题：

为什么 APP1 没有收到 APP2 发送的消息，即使这些消息是由 APP2 发送的，由 Mediator 中继并被附加到 tap1 的wireshark 看到？

我是否必须在我的 Linux 主机上添加任何类型/种类的附加路由？

我在设置 tun/tap 设备时犯了错误吗？

我的中介代码不能正常工作吗？

4

1 回答 1

1

我没有尝试过你的代码（有点奇怪，你能够从用户空间打开 TAP 设备两次而不使用多队列标志，但让我们假设这是正确的），但是你在处理 TAP 设备的方式上有一个概念错误.

TUN/TAP 本质上只是一个管道，管道的一侧位于内核（tapX 接口）中，另一侧位于某些用户空间应用程序中。无论此应用程序写入管道的什么内容都会作为传入流量进入内核接口（您可以使用wireshark 看到它）。无论内核发送到该管道（传出到 tapX）最终都会进入应用程序（您可以在应用程序中读取的数据）。

您的代码当前所做的是打开同一管道的另一个用户空间部分，这不是您想要的。您想在管道的另一端获得流量。从技术上讲，您当前正在做的事情可以通过一个简单的桥接接口来完成，两个分接头都作为端口添加到其中。当然，如果您不仅想桥接，还想以某种方式修改流量，事情会变得有点复杂。

解决此问题的一种方法是添加另一对 TAP 接口。您将tap1 与tap3 和tap2 与tap4 桥接（如在内核桥中），现在您在“中介”和它们之间的代理帧中打开tap3 和tap4。这是非常低效的，但可能是您问题的解决方案。

于 2016-08-10T14:04:52.200 回答