《零入门kubernetes网络实战》视频专栏地址
https://www.ixigua.com/7193641905282875942
本篇文章视频地址(稍后上传)
本篇文章主要是想做一个测试:
实现的目的是
- 希望在宿主机-1上,在用户空间里使用ping命令发起ping请求,产生的icmp类型的数据包经过tun类型的虚拟网络设备转发,能够ping通宿主机-2上的对外物理网卡eth0;
- 不仅能够发送请求,还能接收到反馈信息;
- 实现的效果跟普通的ping请求效果一样;数据包有去有回。
1、原理图 |
实现原理图,如下图所示:
该图主要分为两下两部分:
- 上面部分是宿主机-1里的流程图,
- 下面部署是宿主机-2里的流通图。
我们要实现的目的是:
- 在宿主机-1上,发起ping命令请求,使用虚拟网络设备tun19发起;
- 希望能够ping通宿主机-2上的对外的物理网卡eth0;
分在两条线:
- 黑色实线是ping请求命令数据包走的路线
- 黑色虚线是ping反馈数据包走的路线
在宿主机-1里,又分了用户空间和内核空间两部分。
tun-driver就是咱们要编写的程序;
- 该程序会创建虚拟网络设备tun19,并配置了IP信息。
- 该程序内部,存在三个组件吧:
- icmpConn,表明,这是传输icmp类型数据包的链接,类似于tcp链接,udp链接。这是icmp链接。
- imcpTotun,表明,消息是从icmp链接里读取,将读取的消息发送到tun里,即发送到/dev/net/tun文件描述符里
- tunToimcp,表明,消息是从文件描述符/dev/net/tun里读取的,将读取的消息发送到icmp链接里的
到此为止,我们介绍了我们要实现的目的是什么,介绍了原理图,数据包的走向,以及我们实现的程序都做了哪些事情;
接下来,看一下我们的代码:
2、方案说明 |
本次测试,我打算采用两种试验方式;
- 方案一:先单独创建tun虚拟网络设备(tun19),然后,在编写tun-driver程序
- 方案二:将创建tun虚拟网络设备的程序(tun19),集成到tun-driver程序里。(其实,就是在方案一的基础上,代码整合了一下)
想把我学习tun设备的过程,给大家复盘一下,
代码不是一开始就写正确的,总得有个调试的过程。
刚好方案一,遇到了一些问题。给大家分享一下。
当然,你可以直接跳过方案一,直接看方案二。
3、方案一: |
3.1、创建tun设备的代码 |
package main
import (
"github.com/vishvananda/netlink"
)
const tunName = "tun19"
func main() {
la := netlink.LinkAttrs{
Name: tunName,
Index: 8,
MTU: 1500,
}
tun := netlink.Tuntap{
LinkAttrs: la,
Mode: netlink.TUNTAP_MODE_TUN,
}
l, err := netlink.LinkByName(tunName)
if err == nil {
// 先将tun虚拟网络设备Down掉
netlink.LinkSetDown(l)
// 将tun虚拟网络设备删掉
netlink.LinkDel(l)
}
// 每次创建新的tun设备
err = netlink.LinkAdd(&tun)
if err != nil {
panic(err)
}
l, err = netlink.LinkByName(tunName)
ip, err := netlink.ParseIPNet("10.244.2.2/24")
addr := &netlink.Addr{IPNet: ip, Label: ""}
if err = netlink.AddrAdd(l, addr); err != nil {
panic(err)
}
err = netlink.LinkSetUp(l)
if err != nil {
panic(err)
}
}
这段代码,就是前文介绍的。
在本地编译,上传到测试服务器上:
build:
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build main.go
scp:
scp main root@10.211.55.122:/root
all:
make build && make scp
执行
make all
登录到远程服务器上
ip a s | grep eth0
ip link sh tun19
./main
ip link sh tun19
ip a sh tun19
3.2、tun-driver 代码原理介绍 |
3.2.1、golang代码 |
package main
import (
"bytes"
"encoding/binary"
"flag"
"fmt"
"golang.org/x/net/icmp"
"golang.org/x/net/ipv4"
"net"
"os"
"syscall"
"time"
"unsafe"
)
const (
tunDevice = "/dev/net/tun"
ifnameSize = 16
)
type ifreqFlags struct {
IfrnName [ifnameSize]byte
IfruFlags uint16
}
func ioctl(fd int, request, argp uintptr) error {
_, _, errno := syscall.Syscall(syscall.SYS_IOCTL, uintptr(fd), request, argp)
if errno != 0 {
fmt.Errorf("ioctl failed with '%s'\n", errno)
return fmt.Errorf("ioctl failed with '%s'", errno)
}
return nil
}
func fromZeroTerm(s []byte) string {
return string(bytes.TrimRight(s, "\000"))
}
func OpenTun(name string) (*os.File, string, error) {
tun, err := os.OpenFile(tunDevice, os.O_RDWR, 0)
if err != nil {
fmt.Printf("OpenTun Failed! err:%v", err.Error())
return nil, "", err
}
var ifr ifreqFlags
copy(ifr.IfrnName[:len(ifr.IfrnName)-1], []byte(name+"\000"))
ifr.IfruFlags = syscall.IFF_TUN | syscall.IFF_NO_PI
err = ioctl(int(tun.Fd()), syscall.TUNSETIFF, uintptr(unsafe.Pointer(&ifr)))
if err != nil {
fmt.Printf("OpenTun Failed! err:%v\n", err.Error())
return nil, "", err
}
ifName := fromZeroTerm(ifr.IfrnName[:ifnameSize])
return tun, ifName, nil
}
var tunName string
func checkSum(data []byte) uint16 {
var (
sum uint32
length int = len(data)
index int
)
for length > 1 {
sum += uint32(data[index])<<8 + uint32(data[index+1])
index += 2
length -= 2
}
if length > 0 {
sum += uint32(data[index])
}
sum += sum >> 16
return uint16(^sum)
}
func main() {
flag.StringVar(&tunName, "tunName", "tun19", "Use -tunName xxx")
flag.Parse()
var err error
tunFile, _, err := OpenTun(tunName)
if err != nil {
fmt.Printf("ICMP Listen Packet Failed! err:%v\n", err.Error())
return
}
defer tunFile.Close()
icmpconn, _ := icmp.ListenPacket("ip4:icmp", "0.0.0.0")
defer icmpconn.Close()
var srcCh = make(chan string, 1)
go tunToicmp(icmpconn, tunFile, srcCh)
go icmpToTun(icmpconn, tunFile, srcCh)
time.Sleep(time.Hour)
}
func tunToicmp(icmpconn *icmp.PacketConn, tunFile *os.File, srcCh chan string) {
var srcIP string
packet := make([]byte, 1024*64)
size := 0
var err error
for {
if size, err = tunFile.Read(packet); err != nil {
return
}
fmt.Printf("Msg Length: %d\n", binary.BigEndian.Uint16(packet[2:4]))
fmt.Printf("Msg Protocol: %d (1=ICMP, 6=TCP, 17=UDP)\tsize:%d\n", packet[9], size)
b := packet[:size]
srcIP = GetSrcIP(b)
srcCh <- srcIP
dstIP := GetDstIP(b)
fmt.Printf("Msg srcIP: %s\tdstIP:%v\n", srcIP, dstIP)
var raddr = net.IPAddr{IP: net.ParseIP(dstIP)}
b = b[20:size]
if size, err = icmpconn.WriteTo(b, &raddr); err != nil {
fmt.Println(err.Error())
return
}
fmt.Printf("Send ICMP Packet Success OK! size:%d\n", size)
}
}
func icmpToTun(icmpconn *icmp.PacketConn, tunFile *os.File, srcCh chan string) {
var sb = make([]byte, 1024*64)
var addr net.Addr
var size int
var err error
for {
if size, addr, err = icmpconn.ReadFrom(sb); err != nil {
continue
}
srcIP := <-srcCh
ipHeader := createIPv4Header(net.ParseIP(addr.String()), net.ParseIP(srcIP), os.Getpid())
iphb, err := ipHeader.Marshal()
if err != nil {
continue
}
fmt.Printf("Reply MSG Length: %d\n", binary.BigEndian.Uint16(iphb[2:4]))
fmt.Printf("Reply MSG Protocol: %d (1=ICMP, 6=TCP, 17=UDP)\n", iphb[9])
dstIP := GetDstIP(iphb)
fmt.Printf("Reply src IP: %s\tdstIP:%v\n", addr, dstIP)
var tunb = make([]byte, 84)
tunb = append(iphb, sb[:size]...)
size, err = tunFile.Write(tunb)
if err != nil {
continue
}
fmt.Printf("Reply MSG To Tun OK! size:%d\n", size)
}
}
func createIPv4Header(src, dst net.IP, id int) *ipv4.Header {
iph := &ipv4.Header{
Version: ipv4.Version,
Len: ipv4.HeaderLen,
TOS: 0x00,
TotalLen: ipv4.HeaderLen + 64,
ID: id,
Flags: ipv4.DontFragment,
FragOff: 0,
TTL: 64,
Protocol: 1,
Checksum: 0,
Src: src,
Dst: dst,
}
h, _ := iph.Marshal()
iph.Checksum = int(checkSum(h))
return iph
}
func IsIPv4(packet []byte) bool {
flag := packet[0] >> 4
return flag == 4
}
func GetIPv4Src(packet []byte) net.IP {
return net.IPv4(packet[12], packet[13], packet[14], packet[15])
}
func GetIPv4Dst(packet []byte) net.IP {
return net.IPv4(packet[16], packet[17], packet[18], packet[19])
}
func GetSrcIP(packet []byte) string {
key := ""
if IsIPv4(packet) && len(packet) >= 20 {
key = GetIPv4Src(packet).To4().String()
}
return key
}
func GetDstIP(packet []byte) string {
key := ""
if IsIPv4(packet) && len(packet) >= 20 {
key = GetIPv4Dst(packet).To4().String()
}
return key
}
接下来,对代码进行分析
3.2.2、 main流程分析 |
3.2.3、tunToicmp流程分析 |
3.2.3.1、主要流程说明 |
第111-133行:内部死循环的执行任务。
那么,任务的主要过程是:
3.2.3.2、IP报文头结构说明 |
看一下112行,作用是从/dev/net/tun文件描述符里读取数据到packet切片里
而packet属于字节切片
前面文章已经介绍过了,从/dev/net/tun文件里读取的数据,tun设备默认会给原数据包添加一个IP报文头;
如下形式:
那么, 接下来的问题就是,如何解析IP报文头?
从IP报文头里获取我们想要的信息,如ICMP数据包的目的地址是哪里?
IP报文头的结构形式,如下所示:
- IP报文头一共20个字节,不包括可选项
- 这20个字节,分为了5行来说明、解释(行与行之间的空白行不算)
- 一个byte字节=8bit,每一行都是4个字节,32bit
- 看第一行第一个小框,
- 版本占用了4bit,当值为4时,即代表IPv4
- 头部长度占用了4bit,值为4字节的倍数,4bit位的全部是1的话,也就是15,因此,头部长度占用的最大字节数是15*4=60字节;
- 比方说,二进制0101,占用了4bit,十进制是5,当前IP报文头占用的字节数是5*4=20个字节。
- 版本和头部长度合起来,就是第0个字节,即packet[0]
- packet[1],表示服务类型;
- packet[2], packet[3]:总长
- packet[4], packet[5]:表示标识
- packet[6], packet[7]: 表示标记和分段偏移
- packet[8]: 表示 生命周期
- packet[9]: 表示 协议(如,ICMP,tcp, udp)
- packet[10], packet[11]:表示头部校验和
- packet[12], packet[13], packet[14], packet[15]:表示 源地址,源IP
- packet[16], packet[17], packet[18], packet[19]:表示 目的地址,目的IP
从IP报文头结构中,我们可以获取到目的地址,即packet[16], packet[17], packet[18], packet[19]
代码中的115行,116行,118行非必须代码,是为给大家演示一下,才写的。
3.2.3.3、通过icmp连接将数据发送到目的地址 |
- 看117行:size表示从/dev/net/tun里读取了多少字节,
- 通过这条语句获取到有效的数据
- 看119行:首先说明这条语句非必须的。
- 在后续的版本的中,已经删除了。(代码非一次性写好的)
- 因为把icmp数据包发送给了另一个宿主机上的eth0,eth0会反馈消息到icmpTotun函数里,
- 在此函数里,需要将从icmp链接里接收到的数据添加上一个自定义的IP报文头,
- 写到/dev/net/tun文件里,此时,需要知道srcIP;因此,在这里传输过去的。
- 但是一般情况下,srcIP就是tun19的IP,是固定死的。因此,没有必要写。
到目前为止,我们已经将数据从tun19设备里发送到了另一台宿主机的对外网卡eth0上了。
3.2.4、icmpTotun流程分析 |
3.2.4.1、主流程分析 |
整体看一下这块代码,就是一个for循环,在死循环的执行逻辑;
主要逻辑,如下图所示:
3.2.4.2、从ICMP链接里读取消息 |
- 看143行: 从ICMP链接里读取另一个宿主机eth0反馈的ping的消息,
- 将读取到的消息存储到sb字节切片里
- 这个消息肯定是ICMP的回包,就不需要解析。ICMP的回包中,type为0,表明是ICMP的回包。
3.2.4.3、自定义构建IP报文头 |
什么情况下构建IP报文头和什么情况下不需要构建呢?
从两个方面说,一个是虚拟网卡tun19,一个是/dev/net/tun文件描述符;而且跟数据包的走向有关系;如下:
- 如果数据包从tun19网卡进入的话,不需要自己添加IP报文头,tun19网卡内部会自动添加的
- 如果数据包从tun19网卡出去的话,tun19网卡内部会自动删除IP报文头
- 如果数据包从/dev/net/tun文件描述符里读取数据的话,读取到的数据包里已经包含IP报文头了
- 如果数据包写入/dev/net/tun文件描述符的话,写入之前需要给数据包添加上IP报文头才才能写入
详细的看代码:
- 看下147行:就是获取源IP,本条语句非必须,在后续的版本中,已经删除了。
- 看下149-153行:自定义构建了一个IP报文头:初始化了版本号,协议,源IP,目的IP等等
- 看154,155行:这两个非必须的,只是为了给大家演示,添加的。可以删除
- 看156行:获取目的IP,即获取的是tun设备的IP,tun19的IP
3.2.4.4、重新组合数据包 |
将143行的切片跟150行的自定义IP报文头进行组合,将报文头放到切片的首部;
组成成新的回复数据包。
3.2.4.5、将数据包写入到/dev/net/tun里 |
将最新组合而成的切片写入到/dev/net/tun文件描述符里。
即tun19虚拟网卡就收到另一个宿主机eth0回馈的数据包了。
3.3、本地编译,上传到服务器 |
接下来,在本地环境Mac上编译下,上传到测试服务器上
Makefile内容
build:
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build main.go
scp:
scp main root@10.211.55.122:/root
all:
make build && make scp
执行
make all
3.4、服务器上测试 |
分别打开两个shell终端,如下图所示:
- 左侧的shell终端,执行tun-driver程序
- 右侧的shell终端,执行ping 10.211.55.123 -I tun19命令
看一下运行结果:
- 左侧打印了出了信息
- 右侧缺没有任何信息,然后,ctrl+c终端测试,发现ping一共发送了5个数据包,但是,全部丢失。
再次,查看一下tun19的网卡情况
3.5、问题分析 |
通过测试我们发现执行此命令ping 10.211.55.123 -I tun19的时候
没有反馈结果,
那么,分析的思路是:
- 先排查虚拟网卡tun19、对外的物理网卡eth0,以及另一个宿主机上的eth0网卡是否收到相应的包
- 排查tun-driver程序是否有问题,打印日志是否符合要求
- 排查iptables防火墙规则是否满足条件
- 是否存在DROP策略
- 转发规则是否打开了?(经测试,这个参数为0也可以的;默认值为1)
- more /proc/sys/net/ipv4/ip_forward
- 查看结果是否为1
好,接下来,先抓包分一下
3.5.1、抓包 |
通过抓包,来判断一下,网卡是否收到数据;如果没有收到数据肯定有问题。
3.5.1.1、分析tun19网卡是否有问题 |
针对tun19网卡有两种方式
3.5.1.1.1、方式一:可以查看tun19网卡的统计信息来判断 |
通过如下命令:
ifconfig -v tun19
查看TX,RX是否有变化
3.5.1.1.2、方式二:可以针对tun19网卡进行抓包来分析 |
tcpdump -nn icmp -i tun19
其实,在测试的初期是只有请求数据包,并没有回复数据包,只是不知道如何回复到当时的场景了。
3.5.1.2、分析10.211.55.122节点上的对外网卡eth0是否收到数据 |
tcpdump -nn icmp -i eth0
3.5.1.3、分析10.211.55.123节点上的对外网卡eth0是否收到数据 |
其实,通过上面的抓包,已经说明了,
123节点上的eth0是可以接收到ping命令的请求的,并且此网卡也对ping命令进行回复。
我们可以抓一下,并且通过wireshark简单看一下:
tcpdump -nn icmp -i eth0 -w icmp.pcap
icmp.pcap用WireShark打开
- ping命令请求数据包
- ping命令回复数据包分析
整个测试试验中,涉及到了三个网卡:
122节点上的虚拟网卡tun19,eth0,以及123节点上的eth0网卡
通过抓包我们可以看出来,这三个网卡都可以正常接收到数据包,应该是没有问题的
但是,执行ping 10.211.55.123 -I tun19的时候,确实没有返回值
其实,查看tun19网卡的时候,已经说明了,tun19网卡可以正常接收到123节点的反馈的数据包
也就是说,反馈的数据包从tun19网卡出来后,ping没有收到?
是这一段线路出了问题。
数据包从网卡到应用程序之间的路径是由主机防火墙来规定的。
有可能是防火墙规则给限制住了。
因此,接下来,只能查看防火墙了。
3.5.2、iptables防火墙规则分析 |
通过对tun19虚拟网卡进行抓包,发现:
tun19网卡已经接收到反馈的数据包了,
接下来,看一下:数据包流向图:
问题如下:
涉及到两个链:
- PREROUTING
- INPUT
涉及到表
- raw表
- mangle表
- nat表
- filter表
接下来,可以依次查看响应的链。
为了节省篇幅,不再一一展示了。
直接添加日志。
添加日志方式
iptables -nvL -t raw
iptables -t raw -A PREROUTING -p icmp -j TRACE
iptables -t raw -A OUTPUT -p icmp -j TRACE
iptables -nvL -t raw
按照数据包的走向,依次根据表查看规则链
tail -f /var/log/messages | grep raw | grep PREROUTING | grep DST=10.244.2.2
注意:打印日志可能不会马上显示,可能需要等待10秒左右
tail -f /var/log/messages | grep mangle | grep PREROUTING | grep DST=10.244.2.2
tail -f /var/log/messages | grep nat | grep PREROUTING | grep DST=10.244.2.2
tail -f /var/log/messages | grep mangle | grep INPUT | grep DST=10.244.2.2
tail -f /var/log/messages | grep nat | grep INPUT | grep DST=10.244.2.2
tail -f /var/log/messages | grep filter | grep INPUT | grep DST=10.244.2.2
其实,通过上面的命令去查询的话,也不是很靠谱的。
可能是这样的,一个数据包要不要经过某个表的某个链
是根据这个数据包自带的包状态来判断的。
比方说,这个数据包没有涉及到nat功能,可能不会经过nat表,因此,查询nat表时,就不会有响应的日志。
可能raw表,filter会必须经过的。
有点遗憾,感觉没有通过iptables日志完全查出来是什么原因,但至少也进一步定位了问题所在。
数据包从tun19网卡出来后,经过了raw表。
在后续的表中,出了问题。
3.5.3、反向路由校验 |
在即将放弃的时候,突然想起了一个内核参数net.ipv4.conf.all.rp_filter
尝试的修改了几次,发现OK了!
3.5.3.1、什么是反向路由校验 |
所谓反向路由校验,
-
就是在一个网卡收到数据包后,
-
把源地址和目标地址对调后查找路由出口,
-
从而得到反身后路由出口。
-
然后根据反向路由出口进行过滤。
-
当rp_filter的值为1时,
- 要求反向路由的出口必须与数据包的入口网卡是同一块,否则就会丢弃数据包。
-
当rp_filter的值为2时,
- 要求反向路由必须是可达的,如果反路由不可达,则会丢弃数据包。
3.5.3.2、rp_filter (Reverse Path Filtering)参数介绍 |
- 定义了网卡对接收到的数据包进行反向路由验证的规则。
- 存在三个值:0、1、2,具体含意如下:
- 0:关闭反向路由校验
- 1:开启严格的反向路由校验。
- 对每个进来的数据包,校验其反向路由是否是最佳路由
- 如果反向路由不是最佳路由,则直接丢弃该数据包。
- 2:开启松散的反向路由校验。
- 对每个进来的数据包,校验其源地址是否可达,即反向路由是否能通(通过任意网口),
- 如果反向路径不通,则直接丢弃该数据包。
默认值应该是1,严格进行反向路由校验
具体可以参考下面的网址
Linux内核参数 rp_filter
3.5.3.3、ping不通的原因可能是 |
仅仅是猜测:
数据包经过了两个网卡,一个是虚拟网卡tun19, 一个是eth0
当对数据包进行反向路由校验时,从tun19网卡到eth0网卡失败了,它校验的时候,可能没有添加IP报文头。
3.6、设置反向路由校验,重新测试 |
3.6.1、设置反向路由校验参数 |
既然问题原因已经找到了,设置参数
sysctl -w net.ipv4.conf.all.rp_filter=2
sysctl net.ipv4.conf.all.rp_filter
3.6.2、重新测试 |
ping 10.211.55.123 -I tun19
再次,查看iptables日志
tail -f /var/log/messages | grep DST=10.244.2.2
从上面的日志中可以看出来
即使在ping通的情况下,数据包也只经过了raw表,filter表
RPEROUTING链,以及INPUT链。
可能没有涉及到nat、mangle功能,因此没有nat、mangle相关日志。
3.6.3、为什么会存在大量的DUP!呢? |
如果你去查百度的话,会查到一堆。
最后,在测试时无意中发现是代码的问题。
重新测试
好,到这里我们的试验目标已经完全成功了。
其实,测试用了好长时间。结局还是圆满的。
4、方案二 |
4.1、golang代码 |
package main
import (
"bytes"
"encoding/binary"
"fmt"
"github.com/vishvananda/netlink"
"golang.org/x/net/icmp"
"golang.org/x/net/ipv4"
"net"
"os"
"syscall"
"time"
"unsafe"
)
const (
tunName = "tun19"
tunDevice = "/dev/net/tun"
ifnameSize = 16
eth0 = "10.211.55.122"
tunIP = "10.244.1.3"
)
type ifreqFlags struct {
IfrnName [ifnameSize]byte
IfruFlags uint16
}
func ioctl(fd int, request, argp uintptr) error {
_, _, errno := syscall.Syscall(syscall.SYS_IOCTL, uintptr(fd), request, argp)
if errno != 0 {
fmt.Errorf("ioctl failed with '%s'\n", errno)
return fmt.Errorf("ioctl failed with '%s'", errno)
}
return nil
}
func fromZeroTerm(s []byte) string {
return string(bytes.TrimRight(s, "\000"))
}
func OpenTun(name string) (*os.File, string, error) {
tun, err := os.OpenFile(tunDevice, os.O_RDWR|syscall.O_NONBLOCK, 0)
if err != nil {
fmt.Printf("OpenTun Failed! err:%v", err.Error())
return nil, "", err
}
var ifr ifreqFlags
copy(ifr.IfrnName[:len(ifr.IfrnName)-1], []byte(name+"\000"))
ifr.IfruFlags = syscall.IFF_TUN | syscall.IFF_NO_PI
err = ioctl(int(tun.Fd()), syscall.TUNSETIFF, uintptr(unsafe.Pointer(&ifr)))
if err != nil {
fmt.Printf("OpenTun Failed! err:%v\n", err.Error())
return nil, "", err
}
ifName := fromZeroTerm(ifr.IfrnName[:ifnameSize])
return tun, ifName, nil
}
func checkSum(data []byte) uint16 {
var (
sum uint32
length int = len(data)
index int
)
for length > 1 {
sum += uint32(data[index])<<8 + uint32(data[index+1])
index += 2
length -= 2
}
if length > 0 {
sum += uint32(data[index])
}
sum += sum >> 16
return uint16(^sum)
}
func main() {
fmt.Printf("======>Now----Test----Tun<===1232===\n")
tunFile, err := createTun()
if err != nil {
fmt.Printf("ICMP Listen Packet Failed! err:%v\n", err.Error())
return
}
defer tunFile.Close()
icmpConn, _ := icmp.ListenPacket("ip4:icmp", eth0)
defer icmpConn.Close()
go tunToIcmp(icmpConn, tunFile)
go icmpToTun(icmpConn, tunFile)
time.Sleep(time.Hour)
}
func tunToIcmp(icmpconn *icmp.PacketConn, tunFile *os.File) {
var srcIP string
packet := make([]byte, 1024*64)
size := 0
var err error
for {
if size, err = tunFile.Read(packet); err != nil {
return
}
fmt.Printf("Msg Length: %d\n", binary.BigEndian.Uint16(packet[2:4]))
fmt.Printf("Msg Protocol: %d (1=ICMP, 6=TCP, 17=UDP)\tsize:%d\n", packet[9], size)
b := packet[:size]
srcIP = GetSrcIP(b)
dstIP := GetDstIP(b)
fmt.Printf("Msg srcIP: %s\tdstIP:%v\n", srcIP, dstIP)
var raddr = net.IPAddr{IP: net.ParseIP(dstIP)}
b = b[20:size]
if size, err = icmpconn.WriteTo(b, &raddr); err != nil {
fmt.Println(err.Error())
return
}
fmt.Printf("Write Msg To Icmp Conn OK! size:%d\n", size)
}
}
func icmpToTun(icmpconn *icmp.PacketConn, tunFile *os.File) {
var sb = make([]byte, 1024*64)
var addr net.Addr
var size int
var err error
for {
if size, addr, err = icmpconn.ReadFrom(sb); err != nil {
continue
}
ipHeader := createIPv4Header(net.ParseIP(addr.String()), net.ParseIP(tunIP), os.Getpid())
iphb, err := ipHeader.Marshal()
if err != nil {
continue
}
fmt.Printf("Reply MSG Length: %d\n", binary.BigEndian.Uint16(iphb[2:4]))
fmt.Printf("Reply MSG Protocol: %d (1=ICMP, 6=TCP, 17=UDP)\n", iphb[9])
dstIP := GetDstIP(iphb)
fmt.Printf("Reply src IP: %s\tdstIP:%v\n", addr, dstIP)
var rep = make([]byte, 84)
rep = append(iphb, sb[:size]...)
size, err = tunFile.Write(rep)
if err != nil {
continue
}
fmt.Printf("Write Msg To /dev/net/tun OK! size:%d\ttime:%v\n", size, time.Now())
}
}
func createIPv4Header(src, dst net.IP, id int) *ipv4.Header {
iph := &ipv4.Header{
Version: ipv4.Version,
Len: ipv4.HeaderLen,
TOS: 0x00,
TotalLen: ipv4.HeaderLen + 64,
ID: id,
Flags: ipv4.DontFragment,
FragOff: 0,
TTL: 64,
Protocol: 1,
Checksum: 0,
Src: src,
Dst: dst,
}
h, _ := iph.Marshal()
iph.Checksum = int(checkSum(h))
return iph
}
func IsIPv4(packet []byte) bool {
flag := packet[0] >> 4
return flag == 4
}
func GetIPv4Src(packet []byte) net.IP {
return net.IPv4(packet[12], packet[13], packet[14], packet[15])
}
func GetIPv4Dst(packet []byte) net.IP {
return net.IPv4(packet[16], packet[17], packet[18], packet[19])
}
func GetSrcIP(packet []byte) string {
key := ""
if IsIPv4(packet) && len(packet) >= 20 {
key = GetIPv4Src(packet).To4().String()
}
return key
}
func GetDstIP(packet []byte) string {
key := ""
if IsIPv4(packet) && len(packet) >= 20 {
key = GetIPv4Dst(packet).To4().String()
}
return key
}
func createTun() (*os.File, error) {
err := addTun()
if err != nil {
return nil, err
}
err = configTun()
if err != nil {
return nil, err
}
tunFile, _, err := OpenTun(tunName)
if err != nil {
return nil, err
}
return tunFile, nil
}
func addTun() error {
la := netlink.LinkAttrs{
Name: tunName,
Index: 8,
MTU: 1500,
}
tun := netlink.Tuntap{
LinkAttrs: la,
Mode: netlink.TUNTAP_MODE_TUN,
}
l, err := netlink.LinkByName(tunName)
if err == nil {
netlink.LinkSetDown(l)
netlink.LinkDel(l)
}
err = netlink.LinkAdd(&tun)
if err != nil {
return err
}
return nil
}
func configTun() error {
l, err := netlink.LinkByName(tunName)
if err != nil {
return err
}
ip, err := netlink.ParseIPNet(fmt.Sprintf("%s/%d", tunIP, 24))
if err != nil {
return err
}
addr := &netlink.Addr{IPNet: ip, Label: ""}
if err = netlink.AddrAdd(l, addr); err != nil {
return err
}
err = netlink.LinkSetUp(l)
if err != nil {
return err
}
return nil
}
本代码里,已经集成了虚拟网卡tun19的创建,配置了。
直接使用即可。
4.2、本地编译,上传到服务器上 |
build:
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o tun-driver main.go
scp:
scp tun-driver root@10.211.55.122:/root
all:
make build && make scp
执行
make all
即可
4.3、反向路由规则校验 |
sysctl -w net.ipv4.conf.all.rp_filter=2
sysctl net.ipv4.conf.all.rp_filter
4.4、测试 |
登录到远程服务器10.211.55.122上
root目录下
进行测试
./tun-driver
ping 10.211.55.123 -I tun19 -c 1
5、总结 |
本次试验,完成了在用户空间发送请求,经过tun类型的设备,实现请求的跨主机通信。
当然,在上面的测试用例中,你可以将ICMP改成udp来做,只不过在10.211.55.123节点上也需要开启一个udp服务来接收122节点上发送过来的数据包,然后,在将数据包转发给123节点上的eth0
6、参考 |
https://www.itdaan.com/blog/2017/03/09/e9d4766e2982.html
84字节,是如何计算处理的?(ctrl+f全局搜索一下84, 即可发现)
https://blog.csdn.net/Rong_Toa/article/details/86665176
https://www.freesion.com/search
云原生虚拟化:一文读懂网络虚拟化之 tun/tap 网络设备
Linux虚拟网络设备——tun/tap
TUN/TAP 学习总结(二) —— Linux TUN demo
c语言版本的tun读
https://blog.haohtml.com/archives/31687
如何读取二层,三层,四层数据包
图解:Ping 命令的工作原理
点击 下面 返回 专栏目录 |
<<零入门kubernetes网络实战>>技术专栏之文章目录