test/test_ipip.py

   1 #!/usr/bin/env python
   2 """IP{4,6} over IP{v,6} tunnel functional tests"""
   3
   4 import unittest
   5 from scapy.layers.inet6 import IPv6, Ether, IP, UDP, IPv6ExtHdrFragment
   6 from scapy.all import fragment, fragment6, RandShort, defragment6
   7 from framework import VppTestCase, VppTestRunner
   8 from vpp_ip import DpoProto
   9 from vpp_ip_route import VppIpRoute, VppRoutePath, VppIpTable
  10 from socket import AF_INET, AF_INET6, inet_pton
  11 from util import reassemble4
  12
  13
  14 """ Testipip is a subclass of  VPPTestCase classes.
  15
  16 IPIP tests.
  17
  18 """
  19
  20
  21 class TestIPIP(VppTestCase):
  22     """ IPIP Test Case """
  23
  24     @classmethod
  25     def setUpClass(cls):
  26         super(TestIPIP, cls).setUpClass()
  27         cls.create_pg_interfaces(range(2))
  28         cls.interfaces = list(cls.pg_interfaces)
  29
  30     def setUp(self):
  31         super(TestIPIP, self).setUp()
  32         for i in self.interfaces:
  33             i.admin_up()
  34             i.config_ip4()
  35             i.config_ip6()
  36             i.disable_ipv6_ra()
  37             i.resolve_arp()
  38             i.resolve_ndp()
  39
  40     def tearDown(self):
  41         super(TestIPIP, self).tearDown()
  42         if not self.vpp_dead:
  43             for i in self.pg_interfaces:
  44                 i.unconfig_ip4()
  45                 i.unconfig_ip6()
  46                 i.admin_down()
  47
  48     def validate(self, rx, expected):
  49         self.assertEqual(rx, expected.__class__(expected))
  50
  51     def generate_ip4_frags(self, payload_length, fragment_size):
  52         p_ether = Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac)
  53         p_payload = UDP(sport=1234, dport=1234) / self.payload(payload_length)
  54         p_ip4 = IP(src="1.2.3.4", dst=self.pg0.remote_ip4)
  55         outer_ip4 = (p_ether / IP(src=self.pg1.remote_ip4,
  56                                   id=RandShort(),
  57                                   dst=self.pg0.local_ip4) / p_ip4 / p_payload)
  58         frags = fragment(outer_ip4, fragment_size)
  59         p4_reply = (p_ip4 / p_payload)
  60         p4_reply.ttl -= 1
  61         return frags, p4_reply
  62
  63     def test_ipip4(self):
  64         """ ip{v4,v6} over ip4 test """
  65         p_ether = Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac)
  66         p_ip6 = IPv6(src="1::1", dst="DEAD::1", nh='UDP', tc=42)
  67         p_ip4 = IP(src="1.2.3.4", dst="130.67.0.1", tos=42)
  68         p_payload = UDP(sport=1234, dport=1234)
  69
  70         # IPv4 transport
  71         rv = self.vapi.ipip_add_tunnel(
  72             src_address=self.pg0.local_ip4n,
  73             dst_address=self.pg1.remote_ip4n,
  74             is_ipv6=0, tc_tos=0xFF)
  75         sw_if_index = rv.sw_if_index
  76
  77         # Set interface up and enable IP on it
  78         self.vapi.sw_interface_set_flags(sw_if_index, 1)
  79         self.vapi.sw_interface_set_unnumbered(
  80             ip_sw_if_index=self.pg0.sw_if_index,
  81             sw_if_index=sw_if_index)
  82
  83         # Add IPv4 and IPv6 routes via tunnel interface
  84         ip4_via_tunnel = VppIpRoute(
  85             self, "130.67.0.0", 16,
  86             [VppRoutePath("0.0.0.0",
  87                           sw_if_index,
  88                           proto=DpoProto.DPO_PROTO_IP4)], is_ip6=0)
  89         ip4_via_tunnel.add_vpp_config()
  90
  91         ip6_via_tunnel = VppIpRoute(
  92             self, "dead::", 16,
  93             [VppRoutePath("::",
  94                           sw_if_index,
  95                           proto=DpoProto.DPO_PROTO_IP6)], is_ip6=1)
  96         ip6_via_tunnel.add_vpp_config()
  97
  98         # IPv6 in to IPv4 tunnel
  99         p6 = (p_ether / p_ip6 / p_payload)
 100         p_inner_ip6 = p_ip6
 101         p_inner_ip6.hlim -= 1
 102         p6_reply = (IP(src=self.pg0.local_ip4, dst=self.pg1.remote_ip4,
 103                        proto='ipv6', id=0, tos=42) / p_inner_ip6 / p_payload)
 104         p6_reply.ttl -= 1
 105         rx = self.send_and_expect(self.pg0, p6*10, self.pg1)
 106         for p in rx:
 107             self.validate(p[1], p6_reply)
 108
 109         # IPv4 in to IPv4 tunnel
 110         p4 = (p_ether / p_ip4 / p_payload)
 111         p_ip4_inner = p_ip4
 112         p_ip4_inner.ttl -= 1
 113         p4_reply = (IP(src=self.pg0.local_ip4, dst=self.pg1.remote_ip4,
 114                        tos=42) /
 115                     p_ip4_inner / p_payload)
 116         p4_reply.ttl -= 1
 117         p4_reply.id = 0
 118         rx = self.send_and_expect(self.pg0, p4*10, self.pg1)
 119         for p in rx:
 120             self.validate(p[1], p4_reply)
 121
 122         # Decapsulation
 123         p_ether = Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac)
 124
 125         # IPv4 tunnel to IPv4
 126         p_ip4 = IP(src="1.2.3.4", dst=self.pg0.remote_ip4)
 127         p4 = (p_ether / IP(src=self.pg1.remote_ip4,
 128                            dst=self.pg0.local_ip4) / p_ip4 / p_payload)
 129         p4_reply = (p_ip4 / p_payload)
 130         p4_reply.ttl -= 1
 131         rx = self.send_and_expect(self.pg1, p4*10, self.pg0)
 132         for p in rx:
 133             self.validate(p[1], p4_reply)
 134
 135         err = self.statistics.get_counter(
 136             '/err/ipip4-input/packets decapsulated')
 137         self.assertEqual(err, 10)
 138
 139         # IPv4 tunnel to IPv6
 140         p_ip6 = IPv6(src="1:2:3::4", dst=self.pg0.remote_ip6)
 141         p6 = (p_ether / IP(src=self.pg1.remote_ip4,
 142                            dst=self.pg0.local_ip4) / p_ip6 / p_payload)
 143         p6_reply = (p_ip6 / p_payload)
 144         p6_reply.hlim = 63
 145         rx = self.send_and_expect(self.pg1, p6*10, self.pg0)
 146         for p in rx:
 147             self.validate(p[1], p6_reply)
 148
 149         err = self.statistics.get_counter(
 150             '/err/ipip4-input/packets decapsulated')
 151         self.assertEqual(err, 20)
 152
 153         #
 154         # Fragmentation / Reassembly and Re-fragmentation
 155         #
 156         rv = self.vapi.ip_reassembly_enable_disable(
 157             sw_if_index=self.pg1.sw_if_index,
 158             enable_ip4=1)
 159
 160         # Send lots of fragments, verify reassembled packet
 161         frags, p4_reply = self.generate_ip4_frags(3131, 1400)
 162         f = []
 163         for i in range(0, 1000):
 164             f.extend(frags)
 165         self.pg1.add_stream(f)
 166         self.pg_enable_capture()
 167         self.pg_start()
 168         rx = self.pg0.get_capture(1000)
 169
 170         for p in rx:
 171             self.validate(p[1], p4_reply)
 172
 173         err = self.statistics.get_counter(
 174             '/err/ipip4-input/packets decapsulated')
 175         self.assertEqual(err, 1020)
 176
 177         f = []
 178         r = []
 179         for i in range(1, 90):
 180             frags, p4_reply = self.generate_ip4_frags(i * 100, 1000)
 181             f.extend(frags)
 182             r.extend(p4_reply)
 183         self.pg_enable_capture()
 184         self.pg1.add_stream(f)
 185         self.pg_start()
 186         rx = self.pg0.get_capture(89)
 187         i = 0
 188         for p in rx:
 189             self.validate(p[1], r[i])
 190             i += 1
 191
 192         # Now try with re-fragmentation
 193         #
 194         # Send fragments to tunnel head-end, for the tunnel head end
 195         # to reassemble and then refragment
 196         #
 197         self.vapi.sw_interface_set_mtu(self.pg0.sw_if_index, [576, 0, 0, 0])
 198         frags, p4_reply = self.generate_ip4_frags(3123, 1200)
 199         self.pg_enable_capture()
 200         self.pg1.add_stream(frags)
 201         self.pg_start()
 202         rx = self.pg0.get_capture(6)
 203         reass_pkt = reassemble4(rx)
 204         p4_reply.ttl -= 1
 205         p4_reply.id = 256
 206         self.validate(reass_pkt, p4_reply)
 207
 208         self.vapi.sw_interface_set_mtu(self.pg0.sw_if_index, [1600, 0, 0, 0])
 209         frags, p4_reply = self.generate_ip4_frags(3123, 1200)
 210         self.pg_enable_capture()
 211         self.pg1.add_stream(frags)
 212         self.pg_start()
 213         rx = self.pg0.get_capture(2)
 214         reass_pkt = reassemble4(rx)
 215         p4_reply.ttl -= 1
 216         p4_reply.id = 512
 217         self.validate(reass_pkt, p4_reply)
 218
 219     def test_ipip_create(self):
 220         """ ipip create / delete interface test """
 221         rv = self.vapi.ipip_add_tunnel(
 222             src_address=inet_pton(AF_INET, '1.2.3.4'),
 223             dst_address=inet_pton(AF_INET, '2.3.4.5'), is_ipv6=0)
 224         sw_if_index = rv.sw_if_index
 225         self.vapi.ipip_del_tunnel(sw_if_index)
 226
 227     def test_ipip_vrf_create(self):
 228         """ ipip create / delete interface VRF test """
 229
 230         t = VppIpTable(self, 20)
 231         t.add_vpp_config()
 232         rv = self.vapi.ipip_add_tunnel(
 233             src_address=inet_pton(AF_INET, '1.2.3.4'),
 234             dst_address=inet_pton(AF_INET, '2.3.4.5'), is_ipv6=0,
 235             table_id=20)
 236         sw_if_index = rv.sw_if_index
 237         self.vapi.ipip_del_tunnel(sw_if_index)
 238
 239     def payload(self, len):
 240         return 'x' * len
 241
 242
 243 class TestIPIP6(VppTestCase):
 244     """ IPIP6 Test Case """
 245
 246     @classmethod
 247     def setUpClass(cls):
 248         super(TestIPIP6, cls).setUpClass()
 249         cls.create_pg_interfaces(range(2))
 250         cls.interfaces = list(cls.pg_interfaces)
 251
 252     def setUp(self):
 253         super(TestIPIP6, self).setUp()
 254         for i in self.interfaces:
 255             i.admin_up()
 256             i.config_ip4()
 257             i.config_ip6()
 258             i.disable_ipv6_ra()
 259             i.resolve_arp()
 260             i.resolve_ndp()
 261         self.setup_tunnel()
 262
 263     def tearDown(self):
 264         if not self.vpp_dead:
 265             self.destroy_tunnel()
 266             for i in self.pg_interfaces:
 267                 i.unconfig_ip4()
 268                 i.unconfig_ip6()
 269                 i.admin_down()
 270             super(TestIPIP6, self).tearDown()
 271
 272     def setup_tunnel(self):
 273         # IPv6 transport
 274         rv = self.vapi.ipip_add_tunnel(
 275             src_address=self.pg0.local_ip6n,
 276             dst_address=self.pg1.remote_ip6n, tc_tos=255)
 277
 278         sw_if_index = rv.sw_if_index
 279         self.tunnel_if_index = sw_if_index
 280         self.vapi.sw_interface_set_flags(sw_if_index, 1)
 281         self.vapi.sw_interface_set_unnumbered(
 282             ip_sw_if_index=self.pg0.sw_if_index, sw_if_index=sw_if_index)
 283
 284         # Add IPv4 and IPv6 routes via tunnel interface
 285         ip4_via_tunnel = VppIpRoute(
 286             self, "130.67.0.0", 16,
 287             [VppRoutePath("0.0.0.0",
 288                           sw_if_index,
 289                           proto=DpoProto.DPO_PROTO_IP4)], is_ip6=0)
 290         ip4_via_tunnel.add_vpp_config()
 291
 292         ip6_via_tunnel = VppIpRoute(
 293             self, "dead::", 16,
 294             [VppRoutePath("::",
 295                           sw_if_index,
 296                           proto=DpoProto.DPO_PROTO_IP6)], is_ip6=1)
 297         ip6_via_tunnel.add_vpp_config()
 298
 299         self.tunnel_ip6_via_tunnel = ip6_via_tunnel
 300         self.tunnel_ip4_via_tunnel = ip4_via_tunnel
 301
 302     def destroy_tunnel(self):
 303         # IPv6 transport
 304         self.tunnel_ip4_via_tunnel.remove_vpp_config()
 305         self.tunnel_ip6_via_tunnel.remove_vpp_config()
 306
 307         rv = self.vapi.ipip_del_tunnel(sw_if_index=self.tunnel_if_index)
 308
 309     def validate(self, rx, expected):
 310         self.assertEqual(rx, expected.__class__(expected))
 311
 312     def generate_ip6_frags(self, payload_length, fragment_size):
 313         p_ether = Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac)
 314         p_payload = UDP(sport=1234, dport=1234) / self.payload(payload_length)
 315         p_ip6 = IPv6(src="1::1", dst=self.pg0.remote_ip6)
 316         outer_ip6 = (p_ether / IPv6(src=self.pg1.remote_ip6,
 317                                     dst=self.pg0.local_ip6) /
 318                      IPv6ExtHdrFragment() / p_ip6 / p_payload)
 319         frags = fragment6(outer_ip6, fragment_size)
 320         p6_reply = (p_ip6 / p_payload)
 321         p6_reply.hlim -= 1
 322         return frags, p6_reply
 323
 324     def generate_ip6_hairpin_frags(self, payload_length, fragment_size):
 325         p_ether = Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac)
 326         p_payload = UDP(sport=1234, dport=1234) / self.payload(payload_length)
 327         p_ip6 = IPv6(src="1::1", dst="dead::1")
 328         outer_ip6 = (p_ether / IPv6(src=self.pg1.remote_ip6,
 329                                     dst=self.pg0.local_ip6) /
 330                      IPv6ExtHdrFragment() / p_ip6 / p_payload)
 331         frags = fragment6(outer_ip6, fragment_size)
 332         p_ip6.hlim -= 1
 333         p6_reply = (IPv6(src=self.pg0.local_ip6, dst=self.pg1.remote_ip6,
 334                          hlim=63) / p_ip6 / p_payload)
 335
 336         return frags, p6_reply
 337
 338     def test_encap(self):
 339         """ ip{v4,v6} over ip6 test encap """
 340         p_ether = Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac)
 341         p_ip6 = IPv6(src="1::1", dst="DEAD::1", tc=42, nh='UDP')
 342         p_ip4 = IP(src="1.2.3.4", dst="130.67.0.1", tos=42)
 343         p_payload = UDP(sport=1234, dport=1234)
 344
 345         # Encapsulation
 346         # IPv6 in to IPv6 tunnel
 347         p6 = (p_ether / p_ip6 / p_payload)
 348         p6_reply = (IPv6(src=self.pg0.local_ip6, dst=self.pg1.remote_ip6,
 349                          hlim=64, tc=42) /
 350                     p_ip6 / p_payload)
 351         p6_reply[1].hlim -= 1
 352         rx = self.send_and_expect(self.pg0, p6*11, self.pg1)
 353         for p in rx:
 354             self.validate(p[1], p6_reply)
 355
 356         # IPv4 in to IPv6 tunnel
 357         p4 = (p_ether / p_ip4 / p_payload)
 358         p4_reply = (IPv6(src=self.pg0.local_ip6,
 359                          dst=self.pg1.remote_ip6, hlim=64, tc=42) /
 360                     p_ip4 / p_payload)
 361         p4_reply[1].ttl -= 1
 362         rx = self.send_and_expect(self.pg0, p4*11, self.pg1)
 363         for p in rx:
 364             self.validate(p[1], p4_reply)
 365
 366     def test_decap(self):
 367         """ ip{v4,v6} over ip6 test decap """
 368
 369         p_ether = Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac)
 370         p_ip6 = IPv6(src="1::1", dst="DEAD::1", tc=42, nh='UDP')
 371         p_ip4 = IP(src="1.2.3.4", dst=self.pg0.remote_ip4)
 372         p_payload = UDP(sport=1234, dport=1234)
 373
 374         # Decapsulation
 375         # IPv6 tunnel to IPv4
 376
 377         p4 = (p_ether / IPv6(src=self.pg1.remote_ip6,
 378                              dst=self.pg0.local_ip6) / p_ip4 / p_payload)
 379         p4_reply = (p_ip4 / p_payload)
 380         p4_reply.ttl -= 1
 381         rx = self.send_and_expect(self.pg1, p4*11, self.pg0)
 382         for p in rx:
 383             self.validate(p[1], p4_reply)
 384
 385         # IPv6 tunnel to IPv6
 386         p_ip6 = IPv6(src="1:2:3::4", dst=self.pg0.remote_ip6)
 387         p6 = (p_ether / IPv6(src=self.pg1.remote_ip6,
 388                              dst=self.pg0.local_ip6) / p_ip6 / p_payload)
 389         p6_reply = (p_ip6 / p_payload)
 390         p6_reply.hlim = 63
 391         rx = self.send_and_expect(self.pg1, p6*11, self.pg0)
 392         for p in rx:
 393             self.validate(p[1], p6_reply)
 394
 395     def test_frag(self):
 396         """ ip{v4,v6} over ip6 test frag """
 397
 398         p_ether = Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac)
 399         p_ip6 = IPv6(src="1::1", dst="DEAD::1", tc=42, nh='UDP')
 400         p_ip4 = IP(src="1.2.3.4", dst=self.pg0.remote_ip4)
 401         p_payload = UDP(sport=1234, dport=1234)
 402
 403         #
 404         # Fragmentation / Reassembly and Re-fragmentation
 405         #
 406         rv = self.vapi.ip_reassembly_enable_disable(
 407             sw_if_index=self.pg1.sw_if_index,
 408             enable_ip6=1)
 409
 410         # Send lots of fragments, verify reassembled packet
 411         before_cnt = self.statistics.get_counter(
 412             '/err/ipip6-input/packets decapsulated')
 413         frags, p6_reply = self.generate_ip6_frags(3131, 1400)
 414         f = []
 415         for i in range(0, 1000):
 416             f.extend(frags)
 417         self.pg1.add_stream(f)
 418         self.pg_enable_capture()
 419         self.pg_start()
 420         rx = self.pg0.get_capture(1000)
 421
 422         for p in rx:
 423             self.validate(p[1], p6_reply)
 424
 425         cnt = self.statistics.get_counter(
 426             '/err/ipip6-input/packets decapsulated')
 427         self.assertEqual(cnt, before_cnt + 1000)
 428
 429         f = []
 430         r = []
 431         # TODO: Check out why reassembly of atomic fragments don't work
 432         for i in range(10, 90):
 433             frags, p6_reply = self.generate_ip6_frags(i * 100, 1000)
 434             f.extend(frags)
 435             r.extend(p6_reply)
 436         self.pg_enable_capture()
 437         self.pg1.add_stream(f)
 438         self.pg_start()
 439         rx = self.pg0.get_capture(80)
 440         i = 0
 441         for p in rx:
 442             self.validate(p[1], r[i])
 443             i += 1
 444
 445         # Simple fragmentation
 446         p_ether = Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac)
 447         self.vapi.sw_interface_set_mtu(self.pg1.sw_if_index, [1280, 0, 0, 0])
 448
 449         # IPv6 in to IPv6 tunnel
 450         p_payload = UDP(sport=1234, dport=1234) / self.payload(1300)
 451
 452         p6 = (p_ether / p_ip6 / p_payload)
 453         p6_reply = (IPv6(src=self.pg0.local_ip6, dst=self.pg1.remote_ip6,
 454                          hlim=63, tc=42) /
 455                     p_ip6 / p_payload)
 456         p6_reply[1].hlim -= 1
 457         self.pg_enable_capture()
 458         self.pg0.add_stream(p6)
 459         self.pg_start()
 460         rx = self.pg1.get_capture(2)
 461
 462         # Scapy defragment doesn't deal well with multiple layers
 463         # of samy type / Ethernet header first
 464         f = [p[1] for p in rx]
 465         reass_pkt = defragment6(f)
 466         self.validate(reass_pkt, p6_reply)
 467
 468         # Now try with re-fragmentation
 469         #
 470         # Send large fragments to tunnel head-end, for the tunnel head end
 471         # to reassemble and then refragment out the tunnel again.
 472         # Hair-pinning
 473         #
 474         self.vapi.sw_interface_set_mtu(self.pg1.sw_if_index, [1280, 0, 0, 0])
 475         frags, p6_reply = self.generate_ip6_hairpin_frags(8000, 1200)
 476         self.pg_enable_capture()
 477         self.pg1.add_stream(frags)
 478         self.pg_start()
 479         rx = self.pg1.get_capture(7)
 480         f = [p[1] for p in rx]
 481         reass_pkt = defragment6(f)
 482         p6_reply.id = 256
 483         self.validate(reass_pkt, p6_reply)
 484
 485     def test_ipip_create(self):
 486         """ ipip create / delete interface test """
 487         rv = self.vapi.ipip_add_tunnel(
 488             src_address=inet_pton(AF_INET, '1.2.3.4'),
 489             dst_address=inet_pton(AF_INET, '2.3.4.5'), is_ipv6=0)
 490         sw_if_index = rv.sw_if_index
 491         self.vapi.ipip_del_tunnel(sw_if_index)
 492
 493     def test_ipip_vrf_create(self):
 494         """ ipip create / delete interface VRF test """
 495
 496         t = VppIpTable(self, 20)
 497         t.add_vpp_config()
 498         rv = self.vapi.ipip_add_tunnel(
 499             src_address=inet_pton(AF_INET, '1.2.3.4'),
 500             dst_address=inet_pton(AF_INET, '2.3.4.5'), is_ipv6=0,
 501             table_id=20)
 502         sw_if_index = rv.sw_if_index
 503         self.vapi.ipip_del_tunnel(sw_if_index)
 504
 505     def payload(self, len):
 506         return 'x' * len
 507
 508
 509 if __name__ == '__main__':
 510     unittest.main(testRunner=VppTestRunner)