【计算机网络】IP协议及动态路由算法

linghyu

已于 2024-01-24 15:48:29 修改

阅读量1k

点赞数 18

文章标签：计算机网络 tcp/ip 服务器

于 2024-01-24 15:02:44 首次发布

本文链接：https://blog.csdn.net/linghyu/article/details/135819115

版权

对应代码包传送门

IP协议及动态路由算法代码包及思科模拟器资料说明

【计算机网络】中小型校园网构建与配置

【计算机网络】Socket通信编程与传输协议分析

【计算机网络】网络应用通信基本原理

目的：

1、掌握IP协议，IP分片，DHCP，NAT以及常用的ICMP测试工具。

2、理解路由基本原理与算法，掌握链路状态路由算法，距离向量路由算法，至少使用一种语言编写DV和LS算法。

原理：

1、网络层与IP协议

网络层核心功能是转发与路由

2、ICMP

互联网控制报文协议：支持主机或理由器进行差错报告以及网络探询。

ICMC协议常用的工具Ping和Tracer rotue。

3、DHCP

动态主机配置协议：客户端能够从配置了DHCP的服务器动态获取

4、动态路由算法

路由算法协议确定去往目的网络的最佳路径，转发表（路由表）确定在本路由器如何转发分组，主要分为静态路由和动态路由。

典型的动态路由算法：链路状态路由算法、距离向量路由算法。

过程与结果：

1、ping和tracer route测试

在windows系统ping www.ox.ac.uk，可以看出发生了四次32字节的Echo。使用Ping 探测该域名，Windows系统中默认发送4个32bytes的ECHO。Ping不能完全确保目标主机是否可访问，有些服务器为了防止通过Ping探测到，通过防火墙设置了禁止Ping或者在内核参数中禁止Ping。

由ping命令中得出，到达www.ox.ac.uk的TTL为49：

使用Traert 探测牛津大学的域名：

表示与www.ox.ac.uk服务器距离14跳

TTL为49，49+14-1 = 62，检查其Header的Server检索不到。

使用Ping 和 Tracer route，以及Nslookup并不能完全保证得到确切的网站对应的IP地址(很多WEB使用反向代理、CDN、负载均衡等技术)，如上图Princedon.edu使用了Cloudflare基于反向代理的内容分发网络(CDN, Content Delivery Network)技术。

2、IP数据报分片计算、验证

IP数据报分片的计算和验证思路：应该先根据理论知识计算分片，再验证。IP分片时暂不考虑传输层分段，可以尝试用编写一个基于IP的Socket 也就是原始套接字(RAW)，发送一个至少大于1480*2 bytes的包，捕捉报文验证，也可以使用ICMP 的经典应用Ping 命令，发送一个大于1480*2(比如5200)bytes的报文到IP地址，捕捉报文验证。

Ping的命令为 ping [-t] [-a] [-n count] [-l length] [-f] [-i ttl] [-v tos] [-r count] [-s count] [-j computer-list] | [-k computer-list] [-w timeout] destination-list，-l可以控制发送字节大小，-n控制次数，Echo和Echo reply 不包含发送的[-l length]其他数据为8bytes。

在这里我们设计使用ping 10.225.134.15 -l 5206 -n 1

计算IP分片 Ceiling(5206+8/1480)=4 DF=0

分片	数据	偏移/量	MF	DF
1	1480	0	1	0
2	1480	1480/8	1	0
3	1480	1480*2/8	1	0
4	760+8	1480*3/8	0	0

验证：开启wireshark捕捉，在cmd输入命令ping 运行

可以看到Echo被分为了4个分片，IP数据报格式和分片如上图所示。

3、IP编址计算

1.求子网划分

将192.168.20.0/24划分为4个等长子网

IP地址由网络号和主机号组成，由192.168.20.0/24可知掩码位为24位

①主机位：32-24=8位。

②划分4个子网，所以2N=4，N=2，需要向主机位借2位。

③M=26=64，所以每个子网的IP数是64。

192.168.20.0 = 11000000101010000001010000000000

因此划分后的网络为：192.168.20.0/26；192.168.20.64/26；192.168.20.128/26；192.168.20.192/26.

网络号	子网掩码(前26为全为1，后面全为0)	第一个可用IP	最后一个可用IP	广播地址
192.168.20.0	255.255.255.192	192.168.20.1	192.168.20.62	192.168.20.63
192.168.20.64	255.255.255.192	192.168.20.65	192.168.20.126	192.168.20.127
192.168.20.128	255.255.255.192	192.168.20.129	192.168.20.190	192.168.20.191
192.168.20.192	255.255.255.192	192.168.20.193	192.168.20.254	192.168.20.255

实现子网划分部分代码：

b = [0]*40
ip = [0]*4
index = 0
index2 = 1

def binary(d):
    temp = [0 for k in range(10)]
    i, x = 0, 0
    i = int(i)
    x = int(x)
    while d>0:
        n = d%2
        d //= 2
        temp[i] = n
        #  print(temp)
        i += 1
        x += 1
    while x<8:
        temp[i] = 0
        i += 1
        x += 1
    global index
    for i in range(7,-1,-1):
        b[index] = temp[i]
        index += 1
    return 

def bin_dec(x, n):
    if n==0:
        return 1
    return x*bin_dec(x, n-1)

def res(pos, num):
    count = 0
    global index2
    if pos == num:
        for i in range(8):
            if b[i] == 1:
                ip[0] += bin_dec(2,7-i)
        for i in range(8,16):
            if b[i] == 1:
                ip[1] += bin_dec(2,15-i)
        for i in range(16,24):
            if b[i] == 1:
                ip[2] += bin_dec(2,23-i)
        for i in range(24,32):
            if b[i] == 1:
                ip[3] += bin_dec(2,31-i)
        print("子网"+ str(index2) +"ip: " + str(ip[0]) + "." + str(ip[1]) + "." + str(ip[2]) + "." + str(ip[3]) + "/" + str(num))
        index2 += 1
        for i in range(len(ip)):
            ip[i] = 0
        return
    b[pos] = 1
    res(pos+1, num)
    b[pos] = 0
    res(pos+1, num)

d1, d2, d3, d4 = 0, 0, 0, 0
bp = [0]*40
prefix, ips, ip_num = 0, 0, 0
d1,d2,d3,d4 = input("请输入ip:").split('.')
prefix = input("请输入前缀:")
prefix = int(prefix)
ips = input("请输入划分子网个数:")
ips = int(ips)
ip_num = int(ip_num)

if ips%2 == 0:
    while ips>1:
        ips /= 2
        ip_num += 1
else:
    while ips >0:
        ips /= 2
        ip_num += 1

for i in range(prefix):
    bp[i] = 1
binary(int(d1))
binary(int(d2))
binary(int(d3))
binary(int(d4))
res(prefix, prefix+ip_num)

代码输入及执行结果：

2.求网络号（子网地址）

试确定192.168.20.129/26的子网地址

将IP地址与子网掩码(点分十进制)每段依次从左侧按位进行“与”运算；

子网掩码为26位，即255.255.255.192，其中有3个字节是255，一个字节是192，即11000000，表示网络号占用了前26位，主机号占用了后6位。将IP地址和子网掩码进行与运算，即可得到子网地址。

首先将IP地址和子网掩码转换成二进制形式：

IP地址：11000000.10101000.00010100.10000001

子网掩码：11111111.11111111.11111111.11000000

进行与运算：

11000000.10101000.00010100.10000001

11111111.11111111.11111111.11000000

----------------------------------------------------------------------

11000000.10101000.00010100.10000000

因此，子网地址为192.168.20.128。

所以可得到：

子网地址：192.168.20.128（子网掩码：255.255.255.192）

地址范围：192.168.20.128 —192.168.20.191

（子网地址的主机位，即后6位，从全0到全1）

可分配地址范围：192.168.20.129 — 192.168.20.190

广播地址：192.168.20.191

根据上述内容，确定192.168.20.129/26的子网地址，子网掩码为255.255.255.192，代码实现求子网地址:

print(str(255&192)+'.'+str(255&168)+'.'+str(255&20)+'.'+str(192&129)) 代码执行结果：

3.网络汇总

试确定192.168.40.0/26、192.168.40.64/26、192.168.40.128/26路由总结

将多个子网聚合为一个较大的子网，称为路由总结或者路由汇总（Route aggregation）。

第1步：以二进制格式列出网络：

192.168.20.0/26 11000000.10101000.00010100 00000000

192.168.20.64/26 11000000.10101000.00010100 01000000

192.168.20.128/26 11000000.10101000.00010100 10000000

第2步：计算最左侧的匹配位数量来确定掩码：

如上，有24个匹配位序列是一致的，写成CIDR前缀为“ /24”或点分十进制 “255.255.255.0”（11111111 11111111 11111111 00000000）

第3步：保留相同匹配位不变，序列右边添加二进制“0”致32位序列，确定总结网络地址：

11000000.10101000.00010100 00000000

所以路由总结的网络地址为192.168.20.0/24

实现求路由总结代码:

n = int(input())
for i in range(0, n):
    a = input()
    a1 = a.split('.')
    a2 = '{:08b}'.format(int(a1[0])) + ' ' + '{:08b}'.format(int(a1[1])) \
        + ' ' + '{:08b}'.format(int(a1[2])) + ' ' + '{:08b}'.format(int(a1[3]))
    print(a2)

代码输入及执行结果：

4、DHCP协议分析

动态主机配置协议，DHCP: Dynamic Host ConfigurationProtocol，客户端能够从配置了DHCP的服务器动态获取：IP 地址；子网掩码；默认网关地址；DNS 服务器名称与IP地址。想要在本地抓取到DHCP包，先要保证有可用的DHCP服务器，然后将主机IP地址获取方式设置为自动获取，因为主机在抓包之前已经联网，需要先断开主机的网络连接，然后再连接网络。

在cmd下使用命令ipconfig来完成网络断开与连接的过程：

ipconfig /release ：断开当前的网络连接，主机IP变为0.0.0.0，主机与网络断开，不能访问网络。

ipconfig /renew ：更新适配器信息，请求连接网络，这条命令结束之后，主机会获得一个可用的IP，再次接入网络。

捕捉到的报文通过bootp过滤：

分析DHCP Discover包：

Client端使用IP地址0.0.0.0发送了一个广播包发送到目的IP为255.255.255.255。事件ID号为0x04ac90a4，发送单播，DHCP属于应用层协议，它在传输层使用UDP协议，目的端口是67。

分析DHCP Offer包：

当DHCP服务器收到一条DHCP Discover数据包时，用一个DHCP Offerr包给予客户端响应。

分析DHCP Request包：

当Client收到了DHCP Offer包以后确认有可以和它交互的DHCP服务器存在，于是Client发送Request数据包，请求分配IP。来源IP及目的IP与Discover包一致。

分析DHCP ACK包

服务器用DHCP ACK包对DHCP Repuest进行响应回复

5、距离矢量算法 —— 动态路由RIP测试

1)、距离向量(Distance Vector)路由算法

距离向量(Distance Vector) 路由算法是一种分布式，异步迭代的算法。

分布式(每个结点只当DV变化时才通告给邻居)，异步迭代(局部链路费用改变或邻居DV更新引发迭代。距离向量(Distance Vector) 路由算法验证，构造如图所示拓扑。计算R1-R7路径，应该为R1-R2-R3-R7。源代码参考Bellman-Ford算法。

拓扑图：

编写代码验证如下：

这个算法在这里可以简单看成求最短路径问题，因为没有负权回路的发生，所以常用的Dijkstra算法也可以求解，我的部分代码如下：

import matplotlib.pyplot as plt
import networkx as nx 
# 192.172.1.920 防copy
G2 = nx.Graph()
# 向图中添加多条赋权边: (node1,node2,weight)
G2.add_weighted_edges_from([(1,2,8),(1,4,6),(2,3,8),(3,7,8),
                            (4,5,6),(5,6,6),(6,7,6)])
# 两个指定顶点之间的最短加权路径
start, end = input("输入路由源点及目标点:").split(' ')
start, end = int(start), int(end)
minWPath_start_end = nx.dijkstra_path(G2, source=start, target=end)
print("顶点 v1 到 顶点 v11 的最短加权路径: ", minWPath_start_end)
# 两个指定顶点之间的最短加权路径的长度
lMinWPath_start_end = nx.dijkstra_path_length(G2, source=start, target=end)
print("顶点 v1 到 顶点 v11 的最短加权路径长度: ", lMinWPath_start_end)
pos = nx.spring_layout(G2)  # 用 FR算法排列节点
nx.draw(G2, pos, with_labels=True, alpha=0.5)
labels = nx.get_edge_attributes(G2,'weight')
nx.draw_networkx_edge_labels(G2, pos, edge_labels = labels)
plt.show()

这里我调用了matplotlib，通过输入多条赋权边实现拓扑图的复现，；通过调用networkx进行Dijkstra无向图的绘制，使用库函数dijkstra_path()、dijkstra_path_length()、spring_layout()等实现求取最短加权路径及长度。

以下是代码截图及代码执行结果：

6、链路状态 —— 动态路由OSPF测试

链路状态算法计算从一个源结点到达所有其他结点的最短路径，是一种全局迭代算法。全局(所有结点路由器掌握全局网络拓扑和链路费用)；迭代 (k次迭代后，得到到达k个目的结点的最短路径) ，源代码参考Dijkstra算法。

拓扑图：

编写代码验证如下：

这个测试同样适用于求解最短路径，具有贪心的思想，本质上相同的，因此修改上文代码的参数即可。

import matplotlib.pyplot as plt
import networkx as nx 
# 192.172.1.920 防copy
G2 = nx.Graph()
# 向图中添加多条赋权边: (node1,node2,weight)
G2.add_weighted_edges_from([(1,2,8),(1,4,6),(2,3,8),(3,7,8),
                            (4,5,6),(5,6,6),(6,7,6),(5,3,2)])
# 两个指定顶点之间的最短加权路径
start, end = input("输入路由源点及目标点:").split(' ')
start, end = int(start), int(end)
minWPath_start_end = nx.dijkstra_path(G2, source=start, target=end)
print("顶点 v1 到 顶点 v11 的最短加权路径: ", minWPath_start_end)
# 两个指定顶点之间的最短加权路径的长度
lMinWPath_start_end = nx.dijkstra_path_length(G2, source=start, target=end)
print("顶点 v1 到 顶点 v11 的最短加权路径长度: ", lMinWPath_start_end)

pos = nx.spring_layout(G2)  # 用 FR算法排列节点
nx.draw(G2, pos, with_labels=True, alpha=0.5)
labels = nx.get_edge_attributes(G2,'weight')
nx.draw_networkx_edge_labels(G2, pos, edge_labels = labels)
plt.show()

代码截图及代码执行结果如下：