5 from random import randint, shuffle, choice
8 from framework import VppTestCase, VppTestRunner
9 from scapy.data import IP_PROTOS
10 from scapy.layers.inet import IP, TCP, UDP, ICMP, GRE
11 from scapy.layers.inet import IPerror, TCPerror
12 from scapy.layers.l2 import Ether
13 from scapy.packet import Raw
14 from syslog_rfc5424_parser import SyslogMessage, ParseError
15 from syslog_rfc5424_parser.constants import SyslogSeverity
16 from util import ppp, ip4_range
17 from vpp_acl import AclRule, VppAcl, VppAclInterface
18 from vpp_ip_route import VppIpRoute, VppRoutePath
19 from vpp_papi import VppEnum
22 class TestNAT44ED(VppTestCase):
23 """ NAT44ED Test Case """
36 tcp_external_port = 80
49 def plugin_enable(self):
50 self.vapi.nat44_ed_plugin_enable_disable(
51 sessions=self.max_sessions, enable=1)
53 def plugin_disable(self):
54 self.vapi.nat44_ed_plugin_enable_disable(enable=0)
57 def config_flags(self):
58 return VppEnum.vl_api_nat_config_flags_t
61 def nat44_config_flags(self):
62 return VppEnum.vl_api_nat44_config_flags_t
65 def syslog_severity(self):
66 return VppEnum.vl_api_syslog_severity_t
69 def server_addr(self):
70 return self.pg1.remote_hosts[0].ip4
74 return randint(1025, 65535)
77 def proto2layer(proto):
78 if proto == IP_PROTOS.tcp:
80 elif proto == IP_PROTOS.udp:
82 elif proto == IP_PROTOS.icmp:
85 raise Exception("Unsupported protocol")
88 def create_and_add_ip4_table(cls, i, table_id=0):
89 cls.vapi.ip_table_add_del(is_add=1, table={'table_id': table_id})
90 i.set_table_ip4(table_id)
93 def configure_ip4_interface(cls, i, hosts=0, table_id=None):
95 cls.create_and_add_ip4_table(i, table_id)
102 i.generate_remote_hosts(hosts)
103 i.configure_ipv4_neighbors()
106 def nat_add_interface_address(cls, i):
107 cls.vapi.nat44_add_del_interface_addr(
108 sw_if_index=i.sw_if_index, is_add=1)
110 def nat_add_inside_interface(self, i):
111 self.vapi.nat44_interface_add_del_feature(
112 flags=self.config_flags.NAT_IS_INSIDE,
113 sw_if_index=i.sw_if_index, is_add=1)
115 def nat_add_outside_interface(self, i):
116 self.vapi.nat44_interface_add_del_feature(
117 flags=self.config_flags.NAT_IS_OUTSIDE,
118 sw_if_index=i.sw_if_index, is_add=1)
120 def nat_add_address(self, address, twice_nat=0,
121 vrf_id=0xFFFFFFFF, is_add=1):
122 flags = self.config_flags.NAT_IS_TWICE_NAT if twice_nat else 0
123 self.vapi.nat44_add_del_address_range(first_ip_address=address,
124 last_ip_address=address,
129 def nat_add_static_mapping(self, local_ip, external_ip='0.0.0.0',
130 local_port=0, external_port=0, vrf_id=0,
131 is_add=1, external_sw_if_index=0xFFFFFFFF,
132 proto=0, tag="", flags=0):
134 if not (local_port and external_port):
135 flags |= self.config_flags.NAT_IS_ADDR_ONLY
137 self.vapi.nat44_add_del_static_mapping(
139 local_ip_address=local_ip,
140 external_ip_address=external_ip,
141 external_sw_if_index=external_sw_if_index,
142 local_port=local_port,
143 external_port=external_port,
144 vrf_id=vrf_id, protocol=proto,
152 cls.create_pg_interfaces(range(12))
153 cls.interfaces = list(cls.pg_interfaces[:4])
155 cls.create_and_add_ip4_table(cls.pg2, 10)
157 for i in cls.interfaces:
158 cls.configure_ip4_interface(i, hosts=3)
160 # test specific (test-multiple-vrf)
161 cls.vapi.ip_table_add_del(is_add=1, table={'table_id': 1})
163 # test specific (test-one-armed-nat44-static)
164 cls.pg4.generate_remote_hosts(2)
166 cls.vapi.sw_interface_add_del_address(
167 sw_if_index=cls.pg4.sw_if_index,
168 prefix="10.0.0.1/24")
170 cls.pg4.resolve_arp()
171 cls.pg4._remote_hosts[1]._ip4 = cls.pg4._remote_hosts[0]._ip4
172 cls.pg4.resolve_arp()
174 # test specific interface (pg5)
175 cls.pg5._local_ip4 = "10.1.1.1"
176 cls.pg5._remote_hosts[0]._ip4 = "10.1.1.2"
177 cls.pg5.set_table_ip4(1)
180 cls.pg5.resolve_arp()
182 # test specific interface (pg6)
183 cls.pg6._local_ip4 = "10.1.2.1"
184 cls.pg6._remote_hosts[0]._ip4 = "10.1.2.2"
185 cls.pg6.set_table_ip4(1)
188 cls.pg6.resolve_arp()
192 rl.append(VppIpRoute(cls, "0.0.0.0", 0,
193 [VppRoutePath("0.0.0.0", 0xffffffff,
195 register=False, table_id=1))
196 rl.append(VppIpRoute(cls, "0.0.0.0", 0,
197 [VppRoutePath(cls.pg1.local_ip4,
198 cls.pg1.sw_if_index)],
200 rl.append(VppIpRoute(cls, cls.pg5.remote_ip4, 32,
201 [VppRoutePath("0.0.0.0",
202 cls.pg5.sw_if_index)],
203 register=False, table_id=1))
204 rl.append(VppIpRoute(cls, cls.pg6.remote_ip4, 32,
205 [VppRoutePath("0.0.0.0",
206 cls.pg6.sw_if_index)],
207 register=False, table_id=1))
208 rl.append(VppIpRoute(cls, cls.pg6.remote_ip4, 16,
209 [VppRoutePath("0.0.0.0", 0xffffffff,
211 register=False, table_id=0))
216 def get_err_counter(self, path):
217 return self.statistics.get_err_counter(path)
219 def reass_hairpinning(self, server_addr, server_in_port, server_out_port,
220 host_in_port, proto=IP_PROTOS.tcp,
222 layer = self.proto2layer(proto)
224 if proto == IP_PROTOS.tcp:
225 data = b"A" * 4 + b"B" * 16 + b"C" * 3
227 data = b"A" * 16 + b"B" * 16 + b"C" * 3
229 # send packet from host to server
230 pkts = self.create_stream_frag(self.pg0,
236 self.pg0.add_stream(pkts)
237 self.pg_enable_capture(self.pg_interfaces)
239 frags = self.pg0.get_capture(len(pkts))
240 p = self.reass_frags_and_verify(frags,
243 if proto != IP_PROTOS.icmp:
245 self.assertNotEqual(p[layer].sport, host_in_port)
246 self.assertEqual(p[layer].dport, server_in_port)
249 self.assertNotEqual(p[layer].id, host_in_port)
250 self.assertEqual(data, p[Raw].load)
252 def frag_out_of_order(self, proto=IP_PROTOS.tcp, dont_translate=False,
254 layer = self.proto2layer(proto)
256 if proto == IP_PROTOS.tcp:
257 data = b"A" * 4 + b"B" * 16 + b"C" * 3
259 data = b"A" * 16 + b"B" * 16 + b"C" * 3
260 self.port_in = self.random_port()
264 pkts = self.create_stream_frag(self.pg0, self.pg1.remote_ip4,
265 self.port_in, 20, data, proto)
267 self.pg0.add_stream(pkts)
268 self.pg_enable_capture(self.pg_interfaces)
270 frags = self.pg1.get_capture(len(pkts))
271 if not dont_translate:
272 p = self.reass_frags_and_verify(frags,
276 p = self.reass_frags_and_verify(frags,
279 if proto != IP_PROTOS.icmp:
280 if not dont_translate:
281 self.assertEqual(p[layer].dport, 20)
283 self.assertNotEqual(p[layer].sport, self.port_in)
285 self.assertEqual(p[layer].sport, self.port_in)
288 if not dont_translate:
289 self.assertNotEqual(p[layer].id, self.port_in)
291 self.assertEqual(p[layer].id, self.port_in)
292 self.assertEqual(data, p[Raw].load)
295 if not dont_translate:
296 dst_addr = self.nat_addr
298 dst_addr = self.pg0.remote_ip4
299 if proto != IP_PROTOS.icmp:
301 dport = p[layer].sport
305 pkts = self.create_stream_frag(self.pg1, dst_addr, sport, dport,
306 data, proto, echo_reply=True)
308 self.pg1.add_stream(pkts)
309 self.pg_enable_capture(self.pg_interfaces)
310 self.logger.info(self.vapi.cli("show trace"))
312 frags = self.pg0.get_capture(len(pkts))
313 p = self.reass_frags_and_verify(frags,
316 if proto != IP_PROTOS.icmp:
317 self.assertEqual(p[layer].sport, 20)
318 self.assertEqual(p[layer].dport, self.port_in)
320 self.assertEqual(p[layer].id, self.port_in)
321 self.assertEqual(data, p[Raw].load)
323 def reass_frags_and_verify(self, frags, src, dst):
326 self.assertEqual(p[IP].src, src)
327 self.assertEqual(p[IP].dst, dst)
328 self.assert_ip_checksum_valid(p)
329 buffer.seek(p[IP].frag * 8)
330 buffer.write(bytes(p[IP].payload))
331 ip = IP(src=frags[0][IP].src, dst=frags[0][IP].dst,
332 proto=frags[0][IP].proto)
333 if ip.proto == IP_PROTOS.tcp:
334 p = (ip / TCP(buffer.getvalue()))
335 self.logger.debug(ppp("Reassembled:", p))
336 self.assert_tcp_checksum_valid(p)
337 elif ip.proto == IP_PROTOS.udp:
338 p = (ip / UDP(buffer.getvalue()[:8]) /
339 Raw(buffer.getvalue()[8:]))
340 elif ip.proto == IP_PROTOS.icmp:
341 p = (ip / ICMP(buffer.getvalue()))
344 def frag_in_order(self, proto=IP_PROTOS.tcp, dont_translate=False,
346 layer = self.proto2layer(proto)
348 if proto == IP_PROTOS.tcp:
349 data = b"A" * 4 + b"B" * 16 + b"C" * 3
351 data = b"A" * 16 + b"B" * 16 + b"C" * 3
352 self.port_in = self.random_port()
355 pkts = self.create_stream_frag(self.pg0, self.pg1.remote_ip4,
356 self.port_in, 20, data, proto)
357 self.pg0.add_stream(pkts)
358 self.pg_enable_capture(self.pg_interfaces)
360 frags = self.pg1.get_capture(len(pkts))
361 if not dont_translate:
362 p = self.reass_frags_and_verify(frags,
366 p = self.reass_frags_and_verify(frags,
369 if proto != IP_PROTOS.icmp:
370 if not dont_translate:
371 self.assertEqual(p[layer].dport, 20)
373 self.assertNotEqual(p[layer].sport, self.port_in)
375 self.assertEqual(p[layer].sport, self.port_in)
378 if not dont_translate:
379 self.assertNotEqual(p[layer].id, self.port_in)
381 self.assertEqual(p[layer].id, self.port_in)
382 self.assertEqual(data, p[Raw].load)
385 if not dont_translate:
386 dst_addr = self.nat_addr
388 dst_addr = self.pg0.remote_ip4
389 if proto != IP_PROTOS.icmp:
391 dport = p[layer].sport
395 pkts = self.create_stream_frag(self.pg1, dst_addr, sport, dport, data,
396 proto, echo_reply=True)
397 self.pg1.add_stream(pkts)
398 self.pg_enable_capture(self.pg_interfaces)
400 frags = self.pg0.get_capture(len(pkts))
401 p = self.reass_frags_and_verify(frags,
404 if proto != IP_PROTOS.icmp:
405 self.assertEqual(p[layer].sport, 20)
406 self.assertEqual(p[layer].dport, self.port_in)
408 self.assertEqual(p[layer].id, self.port_in)
409 self.assertEqual(data, p[Raw].load)
411 def verify_capture_out(self, capture, nat_ip=None, same_port=False,
412 dst_ip=None, ignore_port=False):
414 nat_ip = self.nat_addr
415 for packet in capture:
417 self.assert_packet_checksums_valid(packet)
418 self.assertEqual(packet[IP].src, nat_ip)
419 if dst_ip is not None:
420 self.assertEqual(packet[IP].dst, dst_ip)
421 if packet.haslayer(TCP):
425 packet[TCP].sport, self.tcp_port_in)
428 packet[TCP].sport, self.tcp_port_in)
429 self.tcp_port_out = packet[TCP].sport
430 self.assert_packet_checksums_valid(packet)
431 elif packet.haslayer(UDP):
435 packet[UDP].sport, self.udp_port_in)
438 packet[UDP].sport, self.udp_port_in)
439 self.udp_port_out = packet[UDP].sport
444 packet[ICMP].id, self.icmp_id_in)
447 packet[ICMP].id, self.icmp_id_in)
448 self.icmp_id_out = packet[ICMP].id
449 self.assert_packet_checksums_valid(packet)
451 self.logger.error(ppp("Unexpected or invalid packet "
452 "(outside network):", packet))
455 def verify_capture_in(self, capture, in_if):
456 for packet in capture:
458 self.assert_packet_checksums_valid(packet)
459 self.assertEqual(packet[IP].dst, in_if.remote_ip4)
460 if packet.haslayer(TCP):
461 self.assertEqual(packet[TCP].dport, self.tcp_port_in)
462 elif packet.haslayer(UDP):
463 self.assertEqual(packet[UDP].dport, self.udp_port_in)
465 self.assertEqual(packet[ICMP].id, self.icmp_id_in)
467 self.logger.error(ppp("Unexpected or invalid packet "
468 "(inside network):", packet))
471 def create_stream_in(self, in_if, out_if, dst_ip=None, ttl=64):
473 dst_ip = out_if.remote_ip4
477 p = (Ether(dst=in_if.local_mac, src=in_if.remote_mac) /
478 IP(src=in_if.remote_ip4, dst=dst_ip, ttl=ttl) /
479 TCP(sport=self.tcp_port_in, dport=20))
483 p = (Ether(dst=in_if.local_mac, src=in_if.remote_mac) /
484 IP(src=in_if.remote_ip4, dst=dst_ip, ttl=ttl) /
485 UDP(sport=self.udp_port_in, dport=20))
489 p = (Ether(dst=in_if.local_mac, src=in_if.remote_mac) /
490 IP(src=in_if.remote_ip4, dst=dst_ip, ttl=ttl) /
491 ICMP(id=self.icmp_id_in, type='echo-request'))
496 def create_stream_out(self, out_if, dst_ip=None, ttl=64,
497 use_inside_ports=False):
499 dst_ip = self.nat_addr
500 if not use_inside_ports:
501 tcp_port = self.tcp_port_out
502 udp_port = self.udp_port_out
503 icmp_id = self.icmp_id_out
505 tcp_port = self.tcp_port_in
506 udp_port = self.udp_port_in
507 icmp_id = self.icmp_id_in
510 p = (Ether(dst=out_if.local_mac, src=out_if.remote_mac) /
511 IP(src=out_if.remote_ip4, dst=dst_ip, ttl=ttl) /
512 TCP(dport=tcp_port, sport=20))
516 p = (Ether(dst=out_if.local_mac, src=out_if.remote_mac) /
517 IP(src=out_if.remote_ip4, dst=dst_ip, ttl=ttl) /
518 UDP(dport=udp_port, sport=20))
522 p = (Ether(dst=out_if.local_mac, src=out_if.remote_mac) /
523 IP(src=out_if.remote_ip4, dst=dst_ip, ttl=ttl) /
524 ICMP(id=icmp_id, type='echo-reply'))
529 def create_tcp_stream(self, in_if, out_if, count):
533 for i in range(count):
534 p = (Ether(dst=in_if.local_mac, src=in_if.remote_mac) /
535 IP(src=in_if.remote_ip4, dst=out_if.remote_ip4, ttl=64) /
536 TCP(sport=port + i, dport=20))
541 def create_stream_frag(self, src_if, dst, sport, dport, data,
542 proto=IP_PROTOS.tcp, echo_reply=False):
543 if proto == IP_PROTOS.tcp:
544 p = (IP(src=src_if.remote_ip4, dst=dst) /
545 TCP(sport=sport, dport=dport) /
547 p = p.__class__(scapy.compat.raw(p))
548 chksum = p[TCP].chksum
549 proto_header = TCP(sport=sport, dport=dport, chksum=chksum)
550 elif proto == IP_PROTOS.udp:
551 proto_header = UDP(sport=sport, dport=dport)
552 elif proto == IP_PROTOS.icmp:
554 proto_header = ICMP(id=sport, type='echo-request')
556 proto_header = ICMP(id=sport, type='echo-reply')
558 raise Exception("Unsupported protocol")
559 id = self.random_port()
561 if proto == IP_PROTOS.tcp:
564 raw = Raw(data[0:16])
565 p = (Ether(src=src_if.remote_mac, dst=src_if.local_mac) /
566 IP(src=src_if.remote_ip4, dst=dst, flags="MF", frag=0, id=id) /
570 if proto == IP_PROTOS.tcp:
571 raw = Raw(data[4:20])
573 raw = Raw(data[16:32])
574 p = (Ether(src=src_if.remote_mac, dst=src_if.local_mac) /
575 IP(src=src_if.remote_ip4, dst=dst, flags="MF", frag=3, id=id,
579 if proto == IP_PROTOS.tcp:
583 p = (Ether(src=src_if.remote_mac, dst=src_if.local_mac) /
584 IP(src=src_if.remote_ip4, dst=dst, frag=5, proto=proto,
590 def frag_in_order_in_plus_out(self, in_addr, out_addr, in_port, out_port,
591 proto=IP_PROTOS.tcp):
593 layer = self.proto2layer(proto)
595 if proto == IP_PROTOS.tcp:
596 data = b"A" * 4 + b"B" * 16 + b"C" * 3
598 data = b"A" * 16 + b"B" * 16 + b"C" * 3
599 port_in = self.random_port()
603 pkts = self.create_stream_frag(self.pg0, out_addr,
606 self.pg0.add_stream(pkts)
607 self.pg_enable_capture(self.pg_interfaces)
609 frags = self.pg1.get_capture(len(pkts))
610 p = self.reass_frags_and_verify(frags,
613 if proto != IP_PROTOS.icmp:
614 self.assertEqual(p[layer].sport, port_in)
615 self.assertEqual(p[layer].dport, in_port)
617 self.assertEqual(p[layer].id, port_in)
618 self.assertEqual(data, p[Raw].load)
621 if proto != IP_PROTOS.icmp:
622 pkts = self.create_stream_frag(self.pg1, self.pg0.remote_ip4,
624 p[layer].sport, data, proto)
626 pkts = self.create_stream_frag(self.pg1, self.pg0.remote_ip4,
627 p[layer].id, 0, data, proto,
629 self.pg1.add_stream(pkts)
630 self.pg_enable_capture(self.pg_interfaces)
632 frags = self.pg0.get_capture(len(pkts))
633 p = self.reass_frags_and_verify(frags,
636 if proto != IP_PROTOS.icmp:
637 self.assertEqual(p[layer].sport, out_port)
638 self.assertEqual(p[layer].dport, port_in)
640 self.assertEqual(p[layer].id, port_in)
641 self.assertEqual(data, p[Raw].load)
643 def frag_out_of_order_in_plus_out(self, in_addr, out_addr, in_port,
644 out_port, proto=IP_PROTOS.tcp):
646 layer = self.proto2layer(proto)
648 if proto == IP_PROTOS.tcp:
649 data = b"A" * 4 + b"B" * 16 + b"C" * 3
651 data = b"A" * 16 + b"B" * 16 + b"C" * 3
652 port_in = self.random_port()
656 pkts = self.create_stream_frag(self.pg0, out_addr,
660 self.pg0.add_stream(pkts)
661 self.pg_enable_capture(self.pg_interfaces)
663 frags = self.pg1.get_capture(len(pkts))
664 p = self.reass_frags_and_verify(frags,
667 if proto != IP_PROTOS.icmp:
668 self.assertEqual(p[layer].dport, in_port)
669 self.assertEqual(p[layer].sport, port_in)
670 self.assertEqual(p[layer].dport, in_port)
672 self.assertEqual(p[layer].id, port_in)
673 self.assertEqual(data, p[Raw].load)
676 if proto != IP_PROTOS.icmp:
677 pkts = self.create_stream_frag(self.pg1, self.pg0.remote_ip4,
679 p[layer].sport, data, proto)
681 pkts = self.create_stream_frag(self.pg1, self.pg0.remote_ip4,
682 p[layer].id, 0, data, proto,
685 self.pg1.add_stream(pkts)
686 self.pg_enable_capture(self.pg_interfaces)
688 frags = self.pg0.get_capture(len(pkts))
689 p = self.reass_frags_and_verify(frags,
692 if proto != IP_PROTOS.icmp:
693 self.assertEqual(p[layer].sport, out_port)
694 self.assertEqual(p[layer].dport, port_in)
696 self.assertEqual(p[layer].id, port_in)
697 self.assertEqual(data, p[Raw].load)
699 def init_tcp_session(self, in_if, out_if, in_port, ext_port):
701 p = (Ether(src=in_if.remote_mac, dst=in_if.local_mac) /
702 IP(src=in_if.remote_ip4, dst=out_if.remote_ip4) /
703 TCP(sport=in_port, dport=ext_port, flags="S"))
705 self.pg_enable_capture(self.pg_interfaces)
707 capture = out_if.get_capture(1)
709 out_port = p[TCP].sport
711 # SYN + ACK packet out->in
712 p = (Ether(src=out_if.remote_mac, dst=out_if.local_mac) /
713 IP(src=out_if.remote_ip4, dst=self.nat_addr) /
714 TCP(sport=ext_port, dport=out_port, flags="SA"))
716 self.pg_enable_capture(self.pg_interfaces)
721 p = (Ether(src=in_if.remote_mac, dst=in_if.local_mac) /
722 IP(src=in_if.remote_ip4, dst=out_if.remote_ip4) /
723 TCP(sport=in_port, dport=ext_port, flags="A"))
725 self.pg_enable_capture(self.pg_interfaces)
727 out_if.get_capture(1)
731 def twice_nat_common(self, self_twice_nat=False, same_pg=False, lb=False,
733 twice_nat_addr = '10.0.1.3'
741 port_in1 = port_in + 1
742 port_in2 = port_in + 2
747 server1 = self.pg0.remote_hosts[0]
748 server2 = self.pg0.remote_hosts[1]
760 eh_translate = ((not self_twice_nat) or (not lb and same_pg) or
763 self.nat_add_address(self.nat_addr)
764 self.nat_add_address(twice_nat_addr, twice_nat=1)
768 flags |= self.config_flags.NAT_IS_SELF_TWICE_NAT
770 flags |= self.config_flags.NAT_IS_TWICE_NAT
773 self.nat_add_static_mapping(pg0.remote_ip4, self.nat_addr,
778 locals = [{'addr': server1.ip4,
782 {'addr': server2.ip4,
786 out_addr = self.nat_addr
788 self.vapi.nat44_add_del_lb_static_mapping(is_add=1, flags=flags,
789 external_addr=out_addr,
790 external_port=port_out,
791 protocol=IP_PROTOS.tcp,
792 local_num=len(locals),
794 self.nat_add_inside_interface(pg0)
795 self.nat_add_outside_interface(pg1)
801 assert client_id is not None
803 client = self.pg0.remote_hosts[0]
805 client = self.pg0.remote_hosts[1]
807 client = pg1.remote_hosts[0]
808 p = (Ether(src=pg1.remote_mac, dst=pg1.local_mac) /
809 IP(src=client.ip4, dst=self.nat_addr) /
810 TCP(sport=eh_port_out, dport=port_out))
812 self.pg_enable_capture(self.pg_interfaces)
814 capture = pg0.get_capture(1)
820 if ip.dst == server1.ip4:
826 self.assertEqual(ip.dst, server.ip4)
828 self.assertIn(tcp.dport, [port_in1, port_in2])
830 self.assertEqual(tcp.dport, port_in)
832 self.assertEqual(ip.src, twice_nat_addr)
833 self.assertNotEqual(tcp.sport, eh_port_out)
835 self.assertEqual(ip.src, client.ip4)
836 self.assertEqual(tcp.sport, eh_port_out)
838 eh_port_in = tcp.sport
839 saved_port_in = tcp.dport
840 self.assert_packet_checksums_valid(p)
842 self.logger.error(ppp("Unexpected or invalid packet:", p))
845 p = (Ether(src=server.mac, dst=pg0.local_mac) /
846 IP(src=server.ip4, dst=eh_addr_in) /
847 TCP(sport=saved_port_in, dport=eh_port_in))
849 self.pg_enable_capture(self.pg_interfaces)
851 capture = pg1.get_capture(1)
856 self.assertEqual(ip.dst, client.ip4)
857 self.assertEqual(ip.src, self.nat_addr)
858 self.assertEqual(tcp.dport, eh_port_out)
859 self.assertEqual(tcp.sport, port_out)
860 self.assert_packet_checksums_valid(p)
862 self.logger.error(ppp("Unexpected or invalid packet:", p))
866 sessions = self.vapi.nat44_user_session_dump(server.ip4, 0)
867 self.assertEqual(len(sessions), 1)
868 self.assertTrue(sessions[0].flags &
869 self.config_flags.NAT_IS_EXT_HOST_VALID)
870 self.assertTrue(sessions[0].flags &
871 self.config_flags.NAT_IS_TWICE_NAT)
872 self.logger.info(self.vapi.cli("show nat44 sessions"))
873 self.vapi.nat44_del_session(
874 address=sessions[0].inside_ip_address,
875 port=sessions[0].inside_port,
876 protocol=sessions[0].protocol,
877 flags=(self.config_flags.NAT_IS_INSIDE |
878 self.config_flags.NAT_IS_EXT_HOST_VALID),
879 ext_host_address=sessions[0].ext_host_nat_address,
880 ext_host_port=sessions[0].ext_host_nat_port)
881 sessions = self.vapi.nat44_user_session_dump(server.ip4, 0)
882 self.assertEqual(len(sessions), 0)
884 def verify_syslog_sess(self, data, is_add=True, is_ip6=False):
885 message = data.decode('utf-8')
887 message = SyslogMessage.parse(message)
888 except ParseError as e:
892 self.assertEqual(message.severity, SyslogSeverity.info)
893 self.assertEqual(message.appname, 'NAT')
894 self.assertEqual(message.msgid, 'SADD' if is_add else 'SDEL')
895 sd_params = message.sd.get('nsess')
896 self.assertTrue(sd_params is not None)
898 self.assertEqual(sd_params.get('IATYP'), 'IPv6')
899 self.assertEqual(sd_params.get('ISADDR'), self.pg0.remote_ip6)
901 self.assertEqual(sd_params.get('IATYP'), 'IPv4')
902 self.assertEqual(sd_params.get('ISADDR'), self.pg0.remote_ip4)
903 self.assertTrue(sd_params.get('SSUBIX') is not None)
904 self.assertEqual(sd_params.get('ISPORT'), "%d" % self.tcp_port_in)
905 self.assertEqual(sd_params.get('XATYP'), 'IPv4')
906 self.assertEqual(sd_params.get('XSADDR'), self.nat_addr)
907 self.assertEqual(sd_params.get('XSPORT'), "%d" % self.tcp_port_out)
908 self.assertEqual(sd_params.get('PROTO'), "%d" % IP_PROTOS.tcp)
909 self.assertEqual(sd_params.get('SVLAN'), '0')
910 self.assertEqual(sd_params.get('XDADDR'), self.pg1.remote_ip4)
911 self.assertEqual(sd_params.get('XDPORT'),
912 "%d" % self.tcp_external_port)
914 def test_icmp_error(self):
915 """ NAT44ED test ICMP error message with inner header"""
919 self.nat_add_address(self.nat_addr)
920 self.nat_add_inside_interface(self.pg0)
921 self.nat_add_outside_interface(self.pg1)
923 # in2out (initiate connection)
924 p1 = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
925 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
926 UDP(sport=21, dport=20) / payload)
928 self.pg0.add_stream(p1)
929 self.pg_enable_capture(self.pg_interfaces)
931 capture = self.pg1.get_capture(1)[0]
933 # out2in (send error message)
934 p2 = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
935 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
936 ICMP(type='dest-unreach', code='port-unreachable') /
939 self.pg1.add_stream(p2)
940 self.pg_enable_capture(self.pg_interfaces)
943 capture = self.pg0.get_capture(1)[0]
945 self.logger.info(ppp("p1 packet:", p1))
946 self.logger.info(ppp("p2 packet:", p2))
947 self.logger.info(ppp("capture packet:", capture))
949 def test_icmp_echo_reply_trailer(self):
950 """ ICMP echo reply with ethernet trailer"""
952 self.nat_add_address(self.nat_addr)
953 self.nat_add_inside_interface(self.pg0)
954 self.nat_add_outside_interface(self.pg1)
957 p1 = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
958 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
959 ICMP(type=8, id=0xabcd, seq=0))
961 self.pg0.add_stream(p1)
962 self.pg_enable_capture(self.pg_interfaces)
964 c = self.pg1.get_capture(1)[0]
966 self.logger.debug(self.vapi.cli("show trace"))
969 p2 = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
970 IP(src=self.pg1.remote_ip4, dst=self.nat_addr, id=0xee59) /
971 ICMP(type=0, id=c[ICMP].id, seq=0))
973 # force checksum calculation
974 p2 = p2.__class__(bytes(p2))
976 self.logger.debug(ppp("Packet before modification:", p2))
978 # hex representation of vss monitoring ethernet trailer
979 # this seems to be just added to end of packet without modifying
980 # IP or ICMP lengths / checksums
981 p2 = p2 / Raw("\x00\x00\x52\x54\x00\x46\xab\x04\x84\x18")
982 # change it so that IP/ICMP is unaffected
985 self.logger.debug(ppp("Packet with added trailer:", p2))
987 self.pg1.add_stream(p2)
988 self.pg_enable_capture(self.pg_interfaces)
991 self.pg0.get_capture(1)
993 def test_users_dump(self):
994 """ NAT44ED API test - nat44_user_dump """
996 self.nat_add_address(self.nat_addr)
997 self.nat_add_inside_interface(self.pg0)
998 self.nat_add_outside_interface(self.pg1)
1000 self.vapi.nat44_forwarding_enable_disable(enable=1)
1002 local_ip = self.pg0.remote_ip4
1003 external_ip = self.nat_addr
1004 self.nat_add_static_mapping(local_ip, external_ip)
1006 users = self.vapi.nat44_user_dump()
1007 self.assertEqual(len(users), 0)
1009 # in2out - static mapping match
1011 pkts = self.create_stream_out(self.pg1)
1012 self.pg1.add_stream(pkts)
1013 self.pg_enable_capture(self.pg_interfaces)
1015 capture = self.pg0.get_capture(len(pkts))
1016 self.verify_capture_in(capture, self.pg0)
1018 pkts = self.create_stream_in(self.pg0, self.pg1)
1019 self.pg0.add_stream(pkts)
1020 self.pg_enable_capture(self.pg_interfaces)
1022 capture = self.pg1.get_capture(len(pkts))
1023 self.verify_capture_out(capture, same_port=True)
1025 users = self.vapi.nat44_user_dump()
1026 self.assertEqual(len(users), 1)
1027 static_user = users[0]
1028 self.assertEqual(static_user.nstaticsessions, 3)
1029 self.assertEqual(static_user.nsessions, 0)
1031 # in2out - no static mapping match (forwarding test)
1033 host0 = self.pg0.remote_hosts[0]
1034 self.pg0.remote_hosts[0] = self.pg0.remote_hosts[1]
1036 pkts = self.create_stream_out(self.pg1,
1037 dst_ip=self.pg0.remote_ip4,
1038 use_inside_ports=True)
1039 self.pg1.add_stream(pkts)
1040 self.pg_enable_capture(self.pg_interfaces)
1042 capture = self.pg0.get_capture(len(pkts))
1043 self.verify_capture_in(capture, self.pg0)
1045 pkts = self.create_stream_in(self.pg0, self.pg1)
1046 self.pg0.add_stream(pkts)
1047 self.pg_enable_capture(self.pg_interfaces)
1049 capture = self.pg1.get_capture(len(pkts))
1050 self.verify_capture_out(capture, nat_ip=self.pg0.remote_ip4,
1053 self.pg0.remote_hosts[0] = host0
1055 users = self.vapi.nat44_user_dump()
1056 self.assertEqual(len(users), 2)
1057 if str(users[0].ip_address) == self.pg0.remote_hosts[0].ip4:
1058 non_static_user = users[1]
1059 static_user = users[0]
1061 non_static_user = users[0]
1062 static_user = users[1]
1063 self.assertEqual(static_user.nstaticsessions, 3)
1064 self.assertEqual(static_user.nsessions, 0)
1065 self.assertEqual(non_static_user.nstaticsessions, 0)
1066 self.assertEqual(non_static_user.nsessions, 3)
1068 users = self.vapi.nat44_user_dump()
1069 self.assertEqual(len(users), 2)
1070 if str(users[0].ip_address) == self.pg0.remote_hosts[0].ip4:
1071 non_static_user = users[1]
1072 static_user = users[0]
1074 non_static_user = users[0]
1075 static_user = users[1]
1076 self.assertEqual(static_user.nstaticsessions, 3)
1077 self.assertEqual(static_user.nsessions, 0)
1078 self.assertEqual(non_static_user.nstaticsessions, 0)
1079 self.assertEqual(non_static_user.nsessions, 3)
1081 def test_frag_out_of_order_do_not_translate(self):
1082 """ NAT44ED don't translate fragments arriving out of order """
1083 self.nat_add_inside_interface(self.pg0)
1084 self.nat_add_outside_interface(self.pg1)
1085 self.vapi.nat44_forwarding_enable_disable(enable=True)
1086 self.frag_out_of_order(proto=IP_PROTOS.tcp, dont_translate=True)
1088 def test_forwarding(self):
1089 """ NAT44ED forwarding test """
1091 self.nat_add_inside_interface(self.pg0)
1092 self.nat_add_outside_interface(self.pg1)
1093 self.vapi.nat44_forwarding_enable_disable(enable=1)
1095 real_ip = self.pg0.remote_ip4
1096 alias_ip = self.nat_addr
1097 flags = self.config_flags.NAT_IS_ADDR_ONLY
1098 self.vapi.nat44_add_del_static_mapping(is_add=1,
1099 local_ip_address=real_ip,
1100 external_ip_address=alias_ip,
1101 external_sw_if_index=0xFFFFFFFF,
1105 # in2out - static mapping match
1107 pkts = self.create_stream_out(self.pg1)
1108 self.pg1.add_stream(pkts)
1109 self.pg_enable_capture(self.pg_interfaces)
1111 capture = self.pg0.get_capture(len(pkts))
1112 self.verify_capture_in(capture, self.pg0)
1114 pkts = self.create_stream_in(self.pg0, self.pg1)
1115 self.pg0.add_stream(pkts)
1116 self.pg_enable_capture(self.pg_interfaces)
1118 capture = self.pg1.get_capture(len(pkts))
1119 self.verify_capture_out(capture, same_port=True)
1121 # in2out - no static mapping match
1123 host0 = self.pg0.remote_hosts[0]
1124 self.pg0.remote_hosts[0] = self.pg0.remote_hosts[1]
1126 pkts = self.create_stream_out(self.pg1,
1127 dst_ip=self.pg0.remote_ip4,
1128 use_inside_ports=True)
1129 self.pg1.add_stream(pkts)
1130 self.pg_enable_capture(self.pg_interfaces)
1132 capture = self.pg0.get_capture(len(pkts))
1133 self.verify_capture_in(capture, self.pg0)
1135 pkts = self.create_stream_in(self.pg0, self.pg1)
1136 self.pg0.add_stream(pkts)
1137 self.pg_enable_capture(self.pg_interfaces)
1139 capture = self.pg1.get_capture(len(pkts))
1140 self.verify_capture_out(capture, nat_ip=self.pg0.remote_ip4,
1143 self.pg0.remote_hosts[0] = host0
1145 user = self.pg0.remote_hosts[1]
1146 sessions = self.vapi.nat44_user_session_dump(user.ip4, 0)
1147 self.assertEqual(len(sessions), 3)
1148 self.assertTrue(sessions[0].flags &
1149 self.config_flags.NAT_IS_EXT_HOST_VALID)
1150 self.vapi.nat44_del_session(
1151 address=sessions[0].inside_ip_address,
1152 port=sessions[0].inside_port,
1153 protocol=sessions[0].protocol,
1154 flags=(self.config_flags.NAT_IS_INSIDE |
1155 self.config_flags.NAT_IS_EXT_HOST_VALID),
1156 ext_host_address=sessions[0].ext_host_address,
1157 ext_host_port=sessions[0].ext_host_port)
1158 sessions = self.vapi.nat44_user_session_dump(user.ip4, 0)
1159 self.assertEqual(len(sessions), 2)
1162 self.vapi.nat44_forwarding_enable_disable(enable=0)
1163 flags = self.config_flags.NAT_IS_ADDR_ONLY
1164 self.vapi.nat44_add_del_static_mapping(
1166 local_ip_address=real_ip,
1167 external_ip_address=alias_ip,
1168 external_sw_if_index=0xFFFFFFFF,
1171 def test_output_feature_and_service2(self):
1172 """ NAT44ED interface output feature and service host direct access """
1173 self.vapi.nat44_forwarding_enable_disable(enable=1)
1174 self.nat_add_address(self.nat_addr)
1176 self.vapi.nat44_interface_add_del_output_feature(
1177 sw_if_index=self.pg1.sw_if_index, is_add=1,)
1179 # session initiated from service host - translate
1180 pkts = self.create_stream_in(self.pg0, self.pg1)
1181 self.pg0.add_stream(pkts)
1182 self.pg_enable_capture(self.pg_interfaces)
1184 capture = self.pg1.get_capture(len(pkts))
1185 self.verify_capture_out(capture, ignore_port=True)
1187 pkts = self.create_stream_out(self.pg1)
1188 self.pg1.add_stream(pkts)
1189 self.pg_enable_capture(self.pg_interfaces)
1191 capture = self.pg0.get_capture(len(pkts))
1192 self.verify_capture_in(capture, self.pg0)
1194 # session initiated from remote host - do not translate
1195 tcp_port_in = self.tcp_port_in
1196 udp_port_in = self.udp_port_in
1197 icmp_id_in = self.icmp_id_in
1199 self.tcp_port_in = 60303
1200 self.udp_port_in = 60304
1201 self.icmp_id_in = 60305
1204 pkts = self.create_stream_out(self.pg1,
1205 self.pg0.remote_ip4,
1206 use_inside_ports=True)
1207 self.pg1.add_stream(pkts)
1208 self.pg_enable_capture(self.pg_interfaces)
1210 capture = self.pg0.get_capture(len(pkts))
1211 self.verify_capture_in(capture, self.pg0)
1213 pkts = self.create_stream_in(self.pg0, self.pg1)
1214 self.pg0.add_stream(pkts)
1215 self.pg_enable_capture(self.pg_interfaces)
1217 capture = self.pg1.get_capture(len(pkts))
1218 self.verify_capture_out(capture, nat_ip=self.pg0.remote_ip4,
1221 self.tcp_port_in = tcp_port_in
1222 self.udp_port_in = udp_port_in
1223 self.icmp_id_in = icmp_id_in
1225 def test_twice_nat(self):
1226 """ NAT44ED Twice NAT """
1227 self.twice_nat_common()
1229 def test_self_twice_nat_positive(self):
1230 """ NAT44ED Self Twice NAT (positive test) """
1231 self.twice_nat_common(self_twice_nat=True, same_pg=True)
1233 def test_self_twice_nat_lb_positive(self):
1234 """ NAT44ED Self Twice NAT local service load balancing (positive test)
1236 self.twice_nat_common(lb=True, self_twice_nat=True, same_pg=True,
1239 def test_twice_nat_lb(self):
1240 """ NAT44ED Twice NAT local service load balancing """
1241 self.twice_nat_common(lb=True)
1243 def test_output_feature(self):
1244 """ NAT44ED interface output feature (in2out postrouting) """
1245 self.vapi.nat44_forwarding_enable_disable(enable=1)
1246 self.nat_add_address(self.nat_addr)
1248 self.nat_add_outside_interface(self.pg0)
1249 self.vapi.nat44_interface_add_del_output_feature(
1250 sw_if_index=self.pg1.sw_if_index, is_add=1)
1253 pkts = self.create_stream_in(self.pg0, self.pg1)
1254 self.pg0.add_stream(pkts)
1255 self.pg_enable_capture(self.pg_interfaces)
1257 capture = self.pg1.get_capture(len(pkts))
1258 self.verify_capture_out(capture, ignore_port=True)
1259 self.logger.debug(self.vapi.cli("show trace"))
1262 pkts = self.create_stream_out(self.pg1)
1263 self.pg1.add_stream(pkts)
1264 self.pg_enable_capture(self.pg_interfaces)
1266 capture = self.pg0.get_capture(len(pkts))
1267 self.verify_capture_in(capture, self.pg0)
1268 self.logger.debug(self.vapi.cli("show trace"))
1271 pkts = self.create_stream_in(self.pg0, self.pg1, ttl=2)
1272 self.pg0.add_stream(pkts)
1273 self.pg_enable_capture(self.pg_interfaces)
1275 capture = self.pg1.get_capture(len(pkts))
1276 self.verify_capture_out(capture, ignore_port=True)
1277 self.logger.debug(self.vapi.cli("show trace"))
1280 pkts = self.create_stream_out(self.pg1, ttl=2)
1281 self.pg1.add_stream(pkts)
1282 self.pg_enable_capture(self.pg_interfaces)
1284 capture = self.pg0.get_capture(len(pkts))
1285 self.verify_capture_in(capture, self.pg0)
1286 self.logger.debug(self.vapi.cli("show trace"))
1289 pkts = self.create_stream_in(self.pg0, self.pg1, ttl=1)
1290 self.pg0.add_stream(pkts)
1291 self.pg_enable_capture(self.pg_interfaces)
1293 capture = self.pg0.get_capture(len(pkts))
1295 self.assertIn(ICMP, p)
1296 self.assertEqual(p[ICMP].type, 11) # 11 == time-exceeded
1298 def test_static_with_port_out2(self):
1299 """ NAT44ED 1:1 NAPT asymmetrical rule """
1304 self.vapi.nat44_forwarding_enable_disable(enable=1)
1305 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1306 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
1307 local_port, external_port,
1308 proto=IP_PROTOS.tcp, flags=flags)
1310 self.nat_add_inside_interface(self.pg0)
1311 self.nat_add_outside_interface(self.pg1)
1313 # from client to service
1314 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1315 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1316 TCP(sport=12345, dport=external_port))
1317 self.pg1.add_stream(p)
1318 self.pg_enable_capture(self.pg_interfaces)
1320 capture = self.pg0.get_capture(1)
1325 self.assertEqual(ip.dst, self.pg0.remote_ip4)
1326 self.assertEqual(tcp.dport, local_port)
1327 self.assert_packet_checksums_valid(p)
1329 self.logger.error(ppp("Unexpected or invalid packet:", p))
1333 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
1334 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
1335 ICMP(type=11) / capture[0][IP])
1336 self.pg0.add_stream(p)
1337 self.pg_enable_capture(self.pg_interfaces)
1339 capture = self.pg1.get_capture(1)
1342 self.assertEqual(p[IP].src, self.nat_addr)
1344 self.assertEqual(inner.dst, self.nat_addr)
1345 self.assertEqual(inner[TCPerror].dport, external_port)
1347 self.logger.error(ppp("Unexpected or invalid packet:", p))
1350 # from service back to client
1351 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1352 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
1353 TCP(sport=local_port, dport=12345))
1354 self.pg0.add_stream(p)
1355 self.pg_enable_capture(self.pg_interfaces)
1357 capture = self.pg1.get_capture(1)
1362 self.assertEqual(ip.src, self.nat_addr)
1363 self.assertEqual(tcp.sport, external_port)
1364 self.assert_packet_checksums_valid(p)
1366 self.logger.error(ppp("Unexpected or invalid packet:", p))
1370 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
1371 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1372 ICMP(type=11) / capture[0][IP])
1373 self.pg1.add_stream(p)
1374 self.pg_enable_capture(self.pg_interfaces)
1376 capture = self.pg0.get_capture(1)
1379 self.assertEqual(p[IP].dst, self.pg0.remote_ip4)
1381 self.assertEqual(inner.src, self.pg0.remote_ip4)
1382 self.assertEqual(inner[TCPerror].sport, local_port)
1384 self.logger.error(ppp("Unexpected or invalid packet:", p))
1387 # from client to server (no translation)
1388 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1389 IP(src=self.pg1.remote_ip4, dst=self.pg0.remote_ip4) /
1390 TCP(sport=12346, dport=local_port))
1391 self.pg1.add_stream(p)
1392 self.pg_enable_capture(self.pg_interfaces)
1394 capture = self.pg0.get_capture(1)
1399 self.assertEqual(ip.dst, self.pg0.remote_ip4)
1400 self.assertEqual(tcp.dport, local_port)
1401 self.assert_packet_checksums_valid(p)
1403 self.logger.error(ppp("Unexpected or invalid packet:", p))
1406 # from service back to client (no translation)
1407 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1408 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
1409 TCP(sport=local_port, dport=12346))
1410 self.pg0.add_stream(p)
1411 self.pg_enable_capture(self.pg_interfaces)
1413 capture = self.pg1.get_capture(1)
1418 self.assertEqual(ip.src, self.pg0.remote_ip4)
1419 self.assertEqual(tcp.sport, local_port)
1420 self.assert_packet_checksums_valid(p)
1422 self.logger.error(ppp("Unexpected or invalid packet:", p))
1425 def test_static_lb(self):
1426 """ NAT44ED local service load balancing """
1427 external_addr_n = self.nat_addr
1430 server1 = self.pg0.remote_hosts[0]
1431 server2 = self.pg0.remote_hosts[1]
1433 locals = [{'addr': server1.ip4,
1437 {'addr': server2.ip4,
1442 self.nat_add_address(self.nat_addr)
1443 self.vapi.nat44_add_del_lb_static_mapping(
1445 external_addr=external_addr_n,
1446 external_port=external_port,
1447 protocol=IP_PROTOS.tcp,
1448 local_num=len(locals),
1450 flags = self.config_flags.NAT_IS_INSIDE
1451 self.vapi.nat44_interface_add_del_feature(
1452 sw_if_index=self.pg0.sw_if_index,
1453 flags=flags, is_add=1)
1454 self.vapi.nat44_interface_add_del_feature(
1455 sw_if_index=self.pg1.sw_if_index,
1458 # from client to service
1459 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1460 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1461 TCP(sport=12345, dport=external_port))
1462 self.pg1.add_stream(p)
1463 self.pg_enable_capture(self.pg_interfaces)
1465 capture = self.pg0.get_capture(1)
1471 self.assertIn(ip.dst, [server1.ip4, server2.ip4])
1472 if ip.dst == server1.ip4:
1476 self.assertEqual(tcp.dport, local_port)
1477 self.assert_packet_checksums_valid(p)
1479 self.logger.error(ppp("Unexpected or invalid packet:", p))
1482 # from service back to client
1483 p = (Ether(src=server.mac, dst=self.pg0.local_mac) /
1484 IP(src=server.ip4, dst=self.pg1.remote_ip4) /
1485 TCP(sport=local_port, dport=12345))
1486 self.pg0.add_stream(p)
1487 self.pg_enable_capture(self.pg_interfaces)
1489 capture = self.pg1.get_capture(1)
1494 self.assertEqual(ip.src, self.nat_addr)
1495 self.assertEqual(tcp.sport, external_port)
1496 self.assert_packet_checksums_valid(p)
1498 self.logger.error(ppp("Unexpected or invalid packet:", p))
1501 sessions = self.vapi.nat44_user_session_dump(server.ip4, 0)
1502 self.assertEqual(len(sessions), 1)
1503 self.assertTrue(sessions[0].flags &
1504 self.config_flags.NAT_IS_EXT_HOST_VALID)
1505 self.vapi.nat44_del_session(
1506 address=sessions[0].inside_ip_address,
1507 port=sessions[0].inside_port,
1508 protocol=sessions[0].protocol,
1509 flags=(self.config_flags.NAT_IS_INSIDE |
1510 self.config_flags.NAT_IS_EXT_HOST_VALID),
1511 ext_host_address=sessions[0].ext_host_address,
1512 ext_host_port=sessions[0].ext_host_port)
1513 sessions = self.vapi.nat44_user_session_dump(server.ip4, 0)
1514 self.assertEqual(len(sessions), 0)
1516 def test_static_lb_2(self):
1517 """ NAT44ED local service load balancing (asymmetrical rule) """
1518 external_addr = self.nat_addr
1521 server1 = self.pg0.remote_hosts[0]
1522 server2 = self.pg0.remote_hosts[1]
1524 locals = [{'addr': server1.ip4,
1528 {'addr': server2.ip4,
1533 self.vapi.nat44_forwarding_enable_disable(enable=1)
1534 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1535 self.vapi.nat44_add_del_lb_static_mapping(is_add=1, flags=flags,
1536 external_addr=external_addr,
1537 external_port=external_port,
1538 protocol=IP_PROTOS.tcp,
1539 local_num=len(locals),
1541 flags = self.config_flags.NAT_IS_INSIDE
1542 self.vapi.nat44_interface_add_del_feature(
1543 sw_if_index=self.pg0.sw_if_index,
1544 flags=flags, is_add=1)
1545 self.vapi.nat44_interface_add_del_feature(
1546 sw_if_index=self.pg1.sw_if_index,
1549 # from client to service
1550 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1551 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1552 TCP(sport=12345, dport=external_port))
1553 self.pg1.add_stream(p)
1554 self.pg_enable_capture(self.pg_interfaces)
1556 capture = self.pg0.get_capture(1)
1562 self.assertIn(ip.dst, [server1.ip4, server2.ip4])
1563 if ip.dst == server1.ip4:
1567 self.assertEqual(tcp.dport, local_port)
1568 self.assert_packet_checksums_valid(p)
1570 self.logger.error(ppp("Unexpected or invalid packet:", p))
1573 # from service back to client
1574 p = (Ether(src=server.mac, dst=self.pg0.local_mac) /
1575 IP(src=server.ip4, dst=self.pg1.remote_ip4) /
1576 TCP(sport=local_port, dport=12345))
1577 self.pg0.add_stream(p)
1578 self.pg_enable_capture(self.pg_interfaces)
1580 capture = self.pg1.get_capture(1)
1585 self.assertEqual(ip.src, self.nat_addr)
1586 self.assertEqual(tcp.sport, external_port)
1587 self.assert_packet_checksums_valid(p)
1589 self.logger.error(ppp("Unexpected or invalid packet:", p))
1592 # from client to server (no translation)
1593 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1594 IP(src=self.pg1.remote_ip4, dst=server1.ip4) /
1595 TCP(sport=12346, dport=local_port))
1596 self.pg1.add_stream(p)
1597 self.pg_enable_capture(self.pg_interfaces)
1599 capture = self.pg0.get_capture(1)
1605 self.assertEqual(ip.dst, server1.ip4)
1606 self.assertEqual(tcp.dport, local_port)
1607 self.assert_packet_checksums_valid(p)
1609 self.logger.error(ppp("Unexpected or invalid packet:", p))
1612 # from service back to client (no translation)
1613 p = (Ether(src=server1.mac, dst=self.pg0.local_mac) /
1614 IP(src=server1.ip4, dst=self.pg1.remote_ip4) /
1615 TCP(sport=local_port, dport=12346))
1616 self.pg0.add_stream(p)
1617 self.pg_enable_capture(self.pg_interfaces)
1619 capture = self.pg1.get_capture(1)
1624 self.assertEqual(ip.src, server1.ip4)
1625 self.assertEqual(tcp.sport, local_port)
1626 self.assert_packet_checksums_valid(p)
1628 self.logger.error(ppp("Unexpected or invalid packet:", p))
1631 def test_lb_affinity(self):
1632 """ NAT44ED local service load balancing affinity """
1633 external_addr = self.nat_addr
1636 server1 = self.pg0.remote_hosts[0]
1637 server2 = self.pg0.remote_hosts[1]
1639 locals = [{'addr': server1.ip4,
1643 {'addr': server2.ip4,
1648 self.nat_add_address(self.nat_addr)
1649 self.vapi.nat44_add_del_lb_static_mapping(is_add=1,
1650 external_addr=external_addr,
1651 external_port=external_port,
1652 protocol=IP_PROTOS.tcp,
1654 local_num=len(locals),
1656 flags = self.config_flags.NAT_IS_INSIDE
1657 self.vapi.nat44_interface_add_del_feature(
1658 sw_if_index=self.pg0.sw_if_index,
1659 flags=flags, is_add=1)
1660 self.vapi.nat44_interface_add_del_feature(
1661 sw_if_index=self.pg1.sw_if_index,
1664 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
1665 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1666 TCP(sport=1025, dport=external_port))
1667 self.pg1.add_stream(p)
1668 self.pg_enable_capture(self.pg_interfaces)
1670 capture = self.pg0.get_capture(1)
1671 backend = capture[0][IP].dst
1673 sessions = self.vapi.nat44_user_session_dump(backend, 0)
1674 self.assertEqual(len(sessions), 1)
1675 self.assertTrue(sessions[0].flags &
1676 self.config_flags.NAT_IS_EXT_HOST_VALID)
1677 self.vapi.nat44_del_session(
1678 address=sessions[0].inside_ip_address,
1679 port=sessions[0].inside_port,
1680 protocol=sessions[0].protocol,
1681 flags=(self.config_flags.NAT_IS_INSIDE |
1682 self.config_flags.NAT_IS_EXT_HOST_VALID),
1683 ext_host_address=sessions[0].ext_host_address,
1684 ext_host_port=sessions[0].ext_host_port)
1687 for port in range(1030, 1100):
1688 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
1689 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1690 TCP(sport=port, dport=external_port))
1692 self.pg1.add_stream(pkts)
1693 self.pg_enable_capture(self.pg_interfaces)
1695 capture = self.pg0.get_capture(len(pkts))
1697 self.assertEqual(p[IP].dst, backend)
1699 def test_multiple_vrf_1(self):
1700 """ Multiple VRF - both client & service in VRF1 """
1702 external_addr = '1.2.3.4'
1707 flags = self.config_flags.NAT_IS_INSIDE
1708 self.vapi.nat44_interface_add_del_feature(
1709 sw_if_index=self.pg5.sw_if_index,
1711 self.vapi.nat44_interface_add_del_feature(
1712 sw_if_index=self.pg5.sw_if_index,
1713 is_add=1, flags=flags)
1714 self.vapi.nat44_interface_add_del_feature(
1715 sw_if_index=self.pg6.sw_if_index,
1717 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1718 self.nat_add_static_mapping(self.pg5.remote_ip4, external_addr,
1719 local_port, external_port, vrf_id=1,
1720 proto=IP_PROTOS.tcp, flags=flags)
1722 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
1723 IP(src=self.pg6.remote_ip4, dst=external_addr) /
1724 TCP(sport=12345, dport=external_port))
1725 self.pg6.add_stream(p)
1726 self.pg_enable_capture(self.pg_interfaces)
1728 capture = self.pg5.get_capture(1)
1733 self.assertEqual(ip.dst, self.pg5.remote_ip4)
1734 self.assertEqual(tcp.dport, local_port)
1735 self.assert_packet_checksums_valid(p)
1737 self.logger.error(ppp("Unexpected or invalid packet:", p))
1740 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
1741 IP(src=self.pg5.remote_ip4, dst=self.pg6.remote_ip4) /
1742 TCP(sport=local_port, dport=12345))
1743 self.pg5.add_stream(p)
1744 self.pg_enable_capture(self.pg_interfaces)
1746 capture = self.pg6.get_capture(1)
1751 self.assertEqual(ip.src, external_addr)
1752 self.assertEqual(tcp.sport, external_port)
1753 self.assert_packet_checksums_valid(p)
1755 self.logger.error(ppp("Unexpected or invalid packet:", p))
1758 def test_multiple_vrf_2(self):
1759 """ Multiple VRF - dynamic NAT from VRF1 to VRF0 (output-feature) """
1761 external_addr = '1.2.3.4'
1766 self.nat_add_address(self.nat_addr)
1767 flags = self.config_flags.NAT_IS_INSIDE
1768 self.vapi.nat44_interface_add_del_output_feature(
1769 sw_if_index=self.pg1.sw_if_index,
1771 self.vapi.nat44_interface_add_del_feature(
1772 sw_if_index=self.pg5.sw_if_index,
1774 self.vapi.nat44_interface_add_del_feature(
1775 sw_if_index=self.pg5.sw_if_index,
1776 is_add=1, flags=flags)
1777 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1778 self.nat_add_static_mapping(self.pg5.remote_ip4, external_addr,
1779 local_port, external_port, vrf_id=1,
1780 proto=IP_PROTOS.tcp, flags=flags)
1782 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
1783 IP(src=self.pg5.remote_ip4, dst=self.pg1.remote_ip4) /
1784 TCP(sport=2345, dport=22))
1785 self.pg5.add_stream(p)
1786 self.pg_enable_capture(self.pg_interfaces)
1788 capture = self.pg1.get_capture(1)
1793 self.assertEqual(ip.src, self.nat_addr)
1794 self.assert_packet_checksums_valid(p)
1797 self.logger.error(ppp("Unexpected or invalid packet:", p))
1800 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1801 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1802 TCP(sport=22, dport=port))
1803 self.pg1.add_stream(p)
1804 self.pg_enable_capture(self.pg_interfaces)
1806 capture = self.pg5.get_capture(1)
1811 self.assertEqual(ip.dst, self.pg5.remote_ip4)
1812 self.assertEqual(tcp.dport, 2345)
1813 self.assert_packet_checksums_valid(p)
1815 self.logger.error(ppp("Unexpected or invalid packet:", p))
1818 def test_multiple_vrf_3(self):
1819 """ Multiple VRF - client in VRF1, service in VRF0 """
1821 external_addr = '1.2.3.4'
1826 flags = self.config_flags.NAT_IS_INSIDE
1827 self.vapi.nat44_interface_add_del_feature(
1828 sw_if_index=self.pg0.sw_if_index,
1830 self.vapi.nat44_interface_add_del_feature(
1831 sw_if_index=self.pg0.sw_if_index,
1832 is_add=1, flags=flags)
1833 self.vapi.nat44_interface_add_del_feature(
1834 sw_if_index=self.pg6.sw_if_index,
1836 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1837 self.nat_add_static_mapping(
1838 self.pg0.remote_ip4,
1839 external_sw_if_index=self.pg0.sw_if_index,
1840 local_port=local_port,
1842 external_port=external_port,
1843 proto=IP_PROTOS.tcp,
1847 # from client VRF1 to service VRF0
1848 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
1849 IP(src=self.pg6.remote_ip4, dst=self.pg0.local_ip4) /
1850 TCP(sport=12346, dport=external_port))
1851 self.pg6.add_stream(p)
1852 self.pg_enable_capture(self.pg_interfaces)
1854 capture = self.pg0.get_capture(1)
1859 self.assertEqual(ip.dst, self.pg0.remote_ip4)
1860 self.assertEqual(tcp.dport, local_port)
1861 self.assert_packet_checksums_valid(p)
1863 self.logger.error(ppp("Unexpected or invalid packet:", p))
1866 # from service VRF0 back to client VRF1
1867 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1868 IP(src=self.pg0.remote_ip4, dst=self.pg6.remote_ip4) /
1869 TCP(sport=local_port, dport=12346))
1870 self.pg0.add_stream(p)
1871 self.pg_enable_capture(self.pg_interfaces)
1873 capture = self.pg6.get_capture(1)
1878 self.assertEqual(ip.src, self.pg0.local_ip4)
1879 self.assertEqual(tcp.sport, external_port)
1880 self.assert_packet_checksums_valid(p)
1882 self.logger.error(ppp("Unexpected or invalid packet:", p))
1885 def test_multiple_vrf_4(self):
1886 """ Multiple VRF - client in VRF0, service in VRF1 """
1888 external_addr = '1.2.3.4'
1893 flags = self.config_flags.NAT_IS_INSIDE
1894 self.vapi.nat44_interface_add_del_feature(
1895 sw_if_index=self.pg0.sw_if_index,
1897 self.vapi.nat44_interface_add_del_feature(
1898 sw_if_index=self.pg0.sw_if_index,
1899 is_add=1, flags=flags)
1900 self.vapi.nat44_interface_add_del_feature(
1901 sw_if_index=self.pg5.sw_if_index,
1903 self.vapi.nat44_interface_add_del_feature(
1904 sw_if_index=self.pg5.sw_if_index,
1905 is_add=1, flags=flags)
1906 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1907 self.nat_add_static_mapping(self.pg5.remote_ip4, external_addr,
1908 local_port, external_port, vrf_id=1,
1909 proto=IP_PROTOS.tcp, flags=flags)
1911 # from client VRF0 to service VRF1
1912 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1913 IP(src=self.pg0.remote_ip4, dst=external_addr) /
1914 TCP(sport=12347, dport=external_port))
1915 self.pg0.add_stream(p)
1916 self.pg_enable_capture(self.pg_interfaces)
1918 capture = self.pg5.get_capture(1)
1923 self.assertEqual(ip.dst, self.pg5.remote_ip4)
1924 self.assertEqual(tcp.dport, local_port)
1925 self.assert_packet_checksums_valid(p)
1927 self.logger.error(ppp("Unexpected or invalid packet:", p))
1930 # from service VRF1 back to client VRF0
1931 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
1932 IP(src=self.pg5.remote_ip4, dst=self.pg0.remote_ip4) /
1933 TCP(sport=local_port, dport=12347))
1934 self.pg5.add_stream(p)
1935 self.pg_enable_capture(self.pg_interfaces)
1937 capture = self.pg0.get_capture(1)
1942 self.assertEqual(ip.src, external_addr)
1943 self.assertEqual(tcp.sport, external_port)
1944 self.assert_packet_checksums_valid(p)
1946 self.logger.error(ppp("Unexpected or invalid packet:", p))
1949 def test_multiple_vrf_5(self):
1950 """ Multiple VRF - forwarding - no translation """
1952 external_addr = '1.2.3.4'
1957 self.vapi.nat44_forwarding_enable_disable(enable=1)
1958 flags = self.config_flags.NAT_IS_INSIDE
1959 self.vapi.nat44_interface_add_del_feature(
1960 sw_if_index=self.pg0.sw_if_index,
1962 self.vapi.nat44_interface_add_del_feature(
1963 sw_if_index=self.pg0.sw_if_index,
1964 is_add=1, flags=flags)
1965 self.vapi.nat44_interface_add_del_feature(
1966 sw_if_index=self.pg5.sw_if_index,
1968 self.vapi.nat44_interface_add_del_feature(
1969 sw_if_index=self.pg5.sw_if_index,
1970 is_add=1, flags=flags)
1971 self.vapi.nat44_interface_add_del_feature(
1972 sw_if_index=self.pg6.sw_if_index,
1974 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1975 self.nat_add_static_mapping(self.pg5.remote_ip4, external_addr,
1976 local_port, external_port, vrf_id=1,
1977 proto=IP_PROTOS.tcp, flags=flags)
1978 self.nat_add_static_mapping(
1979 self.pg0.remote_ip4,
1980 external_sw_if_index=self.pg0.sw_if_index,
1981 local_port=local_port,
1983 external_port=external_port,
1984 proto=IP_PROTOS.tcp,
1988 # from client to server (both VRF1, no translation)
1989 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
1990 IP(src=self.pg6.remote_ip4, dst=self.pg5.remote_ip4) /
1991 TCP(sport=12348, dport=local_port))
1992 self.pg6.add_stream(p)
1993 self.pg_enable_capture(self.pg_interfaces)
1995 capture = self.pg5.get_capture(1)
2000 self.assertEqual(ip.dst, self.pg5.remote_ip4)
2001 self.assertEqual(tcp.dport, local_port)
2002 self.assert_packet_checksums_valid(p)
2004 self.logger.error(ppp("Unexpected or invalid packet:", p))
2007 # from server back to client (both VRF1, no translation)
2008 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
2009 IP(src=self.pg5.remote_ip4, dst=self.pg6.remote_ip4) /
2010 TCP(sport=local_port, dport=12348))
2011 self.pg5.add_stream(p)
2012 self.pg_enable_capture(self.pg_interfaces)
2014 capture = self.pg6.get_capture(1)
2019 self.assertEqual(ip.src, self.pg5.remote_ip4)
2020 self.assertEqual(tcp.sport, local_port)
2021 self.assert_packet_checksums_valid(p)
2023 self.logger.error(ppp("Unexpected or invalid packet:", p))
2026 # from client VRF1 to server VRF0 (no translation)
2027 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2028 IP(src=self.pg0.remote_ip4, dst=self.pg6.remote_ip4) /
2029 TCP(sport=local_port, dport=12349))
2030 self.pg0.add_stream(p)
2031 self.pg_enable_capture(self.pg_interfaces)
2033 capture = self.pg6.get_capture(1)
2038 self.assertEqual(ip.src, self.pg0.remote_ip4)
2039 self.assertEqual(tcp.sport, local_port)
2040 self.assert_packet_checksums_valid(p)
2042 self.logger.error(ppp("Unexpected or invalid packet:", p))
2045 # from server VRF0 back to client VRF1 (no translation)
2046 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2047 IP(src=self.pg0.remote_ip4, dst=self.pg6.remote_ip4) /
2048 TCP(sport=local_port, dport=12349))
2049 self.pg0.add_stream(p)
2050 self.pg_enable_capture(self.pg_interfaces)
2052 capture = self.pg6.get_capture(1)
2057 self.assertEqual(ip.src, self.pg0.remote_ip4)
2058 self.assertEqual(tcp.sport, local_port)
2059 self.assert_packet_checksums_valid(p)
2061 self.logger.error(ppp("Unexpected or invalid packet:", p))
2064 # from client VRF0 to server VRF1 (no translation)
2065 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2066 IP(src=self.pg0.remote_ip4, dst=self.pg5.remote_ip4) /
2067 TCP(sport=12344, dport=local_port))
2068 self.pg0.add_stream(p)
2069 self.pg_enable_capture(self.pg_interfaces)
2071 capture = self.pg5.get_capture(1)
2076 self.assertEqual(ip.dst, self.pg5.remote_ip4)
2077 self.assertEqual(tcp.dport, local_port)
2078 self.assert_packet_checksums_valid(p)
2080 self.logger.error(ppp("Unexpected or invalid packet:", p))
2083 # from server VRF1 back to client VRF0 (no translation)
2084 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
2085 IP(src=self.pg5.remote_ip4, dst=self.pg0.remote_ip4) /
2086 TCP(sport=local_port, dport=12344))
2087 self.pg5.add_stream(p)
2088 self.pg_enable_capture(self.pg_interfaces)
2090 capture = self.pg0.get_capture(1)
2095 self.assertEqual(ip.src, self.pg5.remote_ip4)
2096 self.assertEqual(tcp.sport, local_port)
2097 self.assert_packet_checksums_valid(p)
2099 self.logger.error(ppp("Unexpected or invalid packet:", p))
2102 def test_outside_address_distribution(self):
2103 """ Outside address distribution based on source address """
2108 for i in range(1, x):
2110 nat_addresses.append(a)
2112 self.nat_add_inside_interface(self.pg0)
2113 self.nat_add_outside_interface(self.pg1)
2115 self.vapi.nat44_add_del_address_range(
2116 first_ip_address=nat_addresses[0],
2117 last_ip_address=nat_addresses[-1],
2118 vrf_id=0xFFFFFFFF, is_add=1, flags=0)
2120 self.pg0.generate_remote_hosts(x)
2124 info = self.create_packet_info(self.pg0, self.pg1)
2125 payload = self.info_to_payload(info)
2126 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2127 IP(src=self.pg0.remote_hosts[i].ip4,
2128 dst=self.pg1.remote_ip4) /
2129 UDP(sport=7000+i, dport=8000+i) /
2134 self.pg0.add_stream(pkts)
2135 self.pg_enable_capture(self.pg_interfaces)
2137 recvd = self.pg1.get_capture(len(pkts))
2138 for p_recvd in recvd:
2139 payload_info = self.payload_to_info(p_recvd[Raw])
2140 packet_index = payload_info.index
2141 info = self._packet_infos[packet_index]
2142 self.assertTrue(info is not None)
2143 self.assertEqual(packet_index, info.index)
2145 packed = socket.inet_aton(p_sent[IP].src)
2146 numeric = struct.unpack("!L", packed)[0]
2147 numeric = socket.htonl(numeric)
2148 a = nat_addresses[(numeric-1) % len(nat_addresses)]
2151 "Invalid packet (src IP %s translated to %s, but expected %s)"
2152 % (p_sent[IP].src, p_recvd[IP].src, a))
2155 class TestNAT44EDMW(TestNAT44ED):
2156 """ NAT44ED MW Test Case """
2157 vpp_worker_count = 4
2160 @unittest.skip('MW fix required')
2161 def test_users_dump(self):
2162 """ NAT44ED API test - nat44_user_dump """
2164 @unittest.skip('MW fix required')
2165 def test_frag_out_of_order_do_not_translate(self):
2166 """ NAT44ED don't translate fragments arriving out of order """
2168 @unittest.skip('MW fix required')
2169 def test_forwarding(self):
2170 """ NAT44ED forwarding test """
2172 @unittest.skip('MW fix required')
2173 def test_twice_nat(self):
2174 """ NAT44ED Twice NAT """
2176 @unittest.skip('MW fix required')
2177 def test_twice_nat_lb(self):
2178 """ NAT44ED Twice NAT local service load balancing """
2180 @unittest.skip('MW fix required')
2181 def test_output_feature(self):
2182 """ NAT44ED interface output feature (in2out postrouting) """
2184 @unittest.skip('MW fix required')
2185 def test_static_with_port_out2(self):
2186 """ NAT44ED 1:1 NAPT asymmetrical rule """
2188 @unittest.skip('MW fix required')
2189 def test_output_feature_and_service2(self):
2190 """ NAT44ED interface output feature and service host direct access """
2192 @unittest.skip('MW fix required')
2193 def test_static_lb(self):
2194 """ NAT44ED local service load balancing """
2196 @unittest.skip('MW fix required')
2197 def test_static_lb_2(self):
2198 """ NAT44ED local service load balancing (asymmetrical rule) """
2200 @unittest.skip('MW fix required')
2201 def test_lb_affinity(self):
2202 """ NAT44ED local service load balancing affinity """
2204 @unittest.skip('MW fix required')
2205 def test_multiple_vrf(self):
2206 """ NAT44ED Multiple VRF setup """
2208 @unittest.skip('MW fix required')
2209 def test_self_twice_nat_positive(self):
2210 """ NAT44ED Self Twice NAT (positive test) """
2212 @unittest.skip('MW fix required')
2213 def test_self_twice_nat_lb_positive(self):
2214 """ NAT44ED Self Twice NAT local service load balancing (positive test)
2217 def test_dynamic(self):
2218 """ NAT44ED dynamic translation test """
2220 tcp_port_offset = 20
2221 udp_port_offset = 20
2224 self.nat_add_address(self.nat_addr)
2225 self.nat_add_inside_interface(self.pg0)
2226 self.nat_add_outside_interface(self.pg1)
2229 tc1 = self.statistics['/nat44-ed/in2out/slowpath/tcp']
2230 uc1 = self.statistics['/nat44-ed/in2out/slowpath/udp']
2231 ic1 = self.statistics['/nat44-ed/in2out/slowpath/icmp']
2232 dc1 = self.statistics['/nat44-ed/in2out/slowpath/drops']
2234 i2o_pkts = [[] for x in range(0, self.vpp_worker_count)]
2236 for i in range(pkt_count):
2237 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2238 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2239 TCP(sport=tcp_port_offset + i, dport=20))
2240 i2o_pkts[p[TCP].sport % self.vpp_worker_count].append(p)
2242 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2243 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2244 UDP(sport=udp_port_offset + i, dport=20))
2245 i2o_pkts[p[UDP].sport % self.vpp_worker_count].append(p)
2247 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2248 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2249 ICMP(id=icmp_id_offset + i, type='echo-request'))
2250 i2o_pkts[p[ICMP].id % self.vpp_worker_count].append(p)
2252 for i in range(0, self.vpp_worker_count):
2253 if len(i2o_pkts[i]) > 0:
2254 self.pg0.add_stream(i2o_pkts[i], worker=i)
2256 self.pg_enable_capture(self.pg_interfaces)
2258 capture = self.pg1.get_capture(pkt_count * 3, timeout=5)
2260 if_idx = self.pg0.sw_if_index
2261 tc2 = self.statistics['/nat44-ed/in2out/slowpath/tcp']
2262 uc2 = self.statistics['/nat44-ed/in2out/slowpath/udp']
2263 ic2 = self.statistics['/nat44-ed/in2out/slowpath/icmp']
2264 dc2 = self.statistics['/nat44-ed/in2out/slowpath/drops']
2267 tc2[:, if_idx].sum() - tc1[:, if_idx].sum(), pkt_count)
2269 uc2[:, if_idx].sum() - uc1[:, if_idx].sum(), pkt_count)
2271 ic2[:, if_idx].sum() - ic1[:, if_idx].sum(), pkt_count)
2272 self.assertEqual(dc2[:, if_idx].sum() - dc1[:, if_idx].sum(), 0)
2274 self.logger.info(self.vapi.cli("show trace"))
2277 tc1 = self.statistics['/nat44-ed/out2in/fastpath/tcp']
2278 uc1 = self.statistics['/nat44-ed/out2in/fastpath/udp']
2279 ic1 = self.statistics['/nat44-ed/out2in/fastpath/icmp']
2280 dc1 = self.statistics['/nat44-ed/out2in/fastpath/drops']
2282 recvd_tcp_ports = set()
2283 recvd_udp_ports = set()
2284 recvd_icmp_ids = set()
2288 recvd_tcp_ports.add(p[TCP].sport)
2290 recvd_udp_ports.add(p[UDP].sport)
2292 recvd_icmp_ids.add(p[ICMP].id)
2294 recvd_tcp_ports = list(recvd_tcp_ports)
2295 recvd_udp_ports = list(recvd_udp_ports)
2296 recvd_icmp_ids = list(recvd_icmp_ids)
2298 o2i_pkts = [[] for x in range(0, self.vpp_worker_count)]
2299 for i in range(pkt_count):
2300 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
2301 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
2302 TCP(dport=choice(recvd_tcp_ports), sport=20))
2303 o2i_pkts[p[TCP].dport % self.vpp_worker_count].append(p)
2305 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
2306 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
2307 UDP(dport=choice(recvd_udp_ports), sport=20))
2308 o2i_pkts[p[UDP].dport % self.vpp_worker_count].append(p)
2310 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
2311 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
2312 ICMP(id=choice(recvd_icmp_ids), type='echo-reply'))
2313 o2i_pkts[p[ICMP].id % self.vpp_worker_count].append(p)
2315 for i in range(0, self.vpp_worker_count):
2316 if len(o2i_pkts[i]) > 0:
2317 self.pg1.add_stream(o2i_pkts[i], worker=i)
2319 self.pg_enable_capture(self.pg_interfaces)
2321 capture = self.pg0.get_capture(pkt_count * 3)
2322 for packet in capture:
2324 self.assert_packet_checksums_valid(packet)
2325 self.assertEqual(packet[IP].dst, self.pg0.remote_ip4)
2326 if packet.haslayer(TCP):
2327 self.assert_in_range(
2328 packet[TCP].dport, tcp_port_offset,
2329 tcp_port_offset + pkt_count, "dst TCP port")
2330 elif packet.haslayer(UDP):
2331 self.assert_in_range(
2332 packet[UDP].dport, udp_port_offset,
2333 udp_port_offset + pkt_count, "dst UDP port")
2335 self.assert_in_range(
2336 packet[ICMP].id, icmp_id_offset,
2337 icmp_id_offset + pkt_count, "ICMP id")
2339 self.logger.error(ppp("Unexpected or invalid packet "
2340 "(inside network):", packet))
2343 if_idx = self.pg1.sw_if_index
2344 tc2 = self.statistics['/nat44-ed/out2in/fastpath/tcp']
2345 uc2 = self.statistics['/nat44-ed/out2in/fastpath/udp']
2346 ic2 = self.statistics['/nat44-ed/out2in/fastpath/icmp']
2347 dc2 = self.statistics['/nat44-ed/out2in/fastpath/drops']
2350 tc2[:, if_idx].sum() - tc1[:, if_idx].sum(), pkt_count)
2352 uc2[:, if_idx].sum() - uc1[:, if_idx].sum(), pkt_count)
2354 ic2[:, if_idx].sum() - ic1[:, if_idx].sum(), pkt_count)
2355 self.assertEqual(dc2[:, if_idx].sum() - dc1[:, if_idx].sum(), 0)
2357 sc = self.statistics['/nat44-ed/total-sessions']
2358 self.assertEqual(sc[:, 0].sum(), len(recvd_tcp_ports) +
2359 len(recvd_udp_ports) + len(recvd_icmp_ids))
2361 def test_frag_in_order(self):
2362 """ NAT44ED translate fragments arriving in order """
2364 self.nat_add_address(self.nat_addr)
2365 self.nat_add_inside_interface(self.pg0)
2366 self.nat_add_outside_interface(self.pg1)
2368 self.frag_in_order(proto=IP_PROTOS.tcp, ignore_port=True)
2369 self.frag_in_order(proto=IP_PROTOS.udp, ignore_port=True)
2370 self.frag_in_order(proto=IP_PROTOS.icmp, ignore_port=True)
2372 def test_frag_in_order_do_not_translate(self):
2373 """ NAT44ED don't translate fragments arriving in order """
2375 self.nat_add_address(self.nat_addr)
2376 self.nat_add_inside_interface(self.pg0)
2377 self.nat_add_outside_interface(self.pg1)
2378 self.vapi.nat44_forwarding_enable_disable(enable=True)
2380 self.frag_in_order(proto=IP_PROTOS.tcp, dont_translate=True)
2382 def test_frag_out_of_order(self):
2383 """ NAT44ED translate fragments arriving out of order """
2385 self.nat_add_address(self.nat_addr)
2386 self.nat_add_inside_interface(self.pg0)
2387 self.nat_add_outside_interface(self.pg1)
2389 self.frag_out_of_order(proto=IP_PROTOS.tcp, ignore_port=True)
2390 self.frag_out_of_order(proto=IP_PROTOS.udp, ignore_port=True)
2391 self.frag_out_of_order(proto=IP_PROTOS.icmp, ignore_port=True)
2393 def test_frag_in_order_in_plus_out(self):
2394 """ NAT44ED in+out interface fragments in order """
2396 in_port = self.random_port()
2397 out_port = self.random_port()
2399 self.nat_add_address(self.nat_addr)
2400 self.nat_add_inside_interface(self.pg0)
2401 self.nat_add_outside_interface(self.pg0)
2402 self.nat_add_inside_interface(self.pg1)
2403 self.nat_add_outside_interface(self.pg1)
2405 # add static mappings for server
2406 self.nat_add_static_mapping(self.server_addr,
2410 proto=IP_PROTOS.tcp)
2411 self.nat_add_static_mapping(self.server_addr,
2415 proto=IP_PROTOS.udp)
2416 self.nat_add_static_mapping(self.server_addr,
2418 proto=IP_PROTOS.icmp)
2420 # run tests for each protocol
2421 self.frag_in_order_in_plus_out(self.server_addr,
2426 self.frag_in_order_in_plus_out(self.server_addr,
2431 self.frag_in_order_in_plus_out(self.server_addr,
2437 def test_frag_out_of_order_in_plus_out(self):
2438 """ NAT44ED in+out interface fragments out of order """
2440 in_port = self.random_port()
2441 out_port = self.random_port()
2443 self.nat_add_address(self.nat_addr)
2444 self.nat_add_inside_interface(self.pg0)
2445 self.nat_add_outside_interface(self.pg0)
2446 self.nat_add_inside_interface(self.pg1)
2447 self.nat_add_outside_interface(self.pg1)
2449 # add static mappings for server
2450 self.nat_add_static_mapping(self.server_addr,
2454 proto=IP_PROTOS.tcp)
2455 self.nat_add_static_mapping(self.server_addr,
2459 proto=IP_PROTOS.udp)
2460 self.nat_add_static_mapping(self.server_addr,
2462 proto=IP_PROTOS.icmp)
2464 # run tests for each protocol
2465 self.frag_out_of_order_in_plus_out(self.server_addr,
2470 self.frag_out_of_order_in_plus_out(self.server_addr,
2475 self.frag_out_of_order_in_plus_out(self.server_addr,
2481 def test_reass_hairpinning(self):
2482 """ NAT44ED fragments hairpinning """
2484 server_addr = self.pg0.remote_hosts[1].ip4
2486 host_in_port = self.random_port()
2487 server_in_port = self.random_port()
2488 server_out_port = self.random_port()
2490 self.nat_add_address(self.nat_addr)
2491 self.nat_add_inside_interface(self.pg0)
2492 self.nat_add_outside_interface(self.pg1)
2494 # add static mapping for server
2495 self.nat_add_static_mapping(server_addr, self.nat_addr,
2496 server_in_port, server_out_port,
2497 proto=IP_PROTOS.tcp)
2498 self.nat_add_static_mapping(server_addr, self.nat_addr,
2499 server_in_port, server_out_port,
2500 proto=IP_PROTOS.udp)
2501 self.nat_add_static_mapping(server_addr, self.nat_addr)
2503 self.reass_hairpinning(server_addr, server_in_port, server_out_port,
2504 host_in_port, proto=IP_PROTOS.tcp,
2506 self.reass_hairpinning(server_addr, server_in_port, server_out_port,
2507 host_in_port, proto=IP_PROTOS.udp,
2509 self.reass_hairpinning(server_addr, server_in_port, server_out_port,
2510 host_in_port, proto=IP_PROTOS.icmp,
2513 def test_session_limit_per_vrf(self):
2514 """ NAT44ED per vrf session limit """
2517 inside_vrf10 = self.pg2
2522 # 2 interfaces pg0, pg1 (vrf10, limit 1 tcp session)
2523 # non existing vrf_id makes process core dump
2524 self.vapi.nat44_set_session_limit(session_limit=limit, vrf_id=10)
2526 self.nat_add_inside_interface(inside)
2527 self.nat_add_inside_interface(inside_vrf10)
2528 self.nat_add_outside_interface(outside)
2531 self.nat_add_interface_address(outside)
2533 # BUG: causing core dump - when bad vrf_id is specified
2534 # self.nat_add_address(outside.local_ip4, vrf_id=20)
2536 stream = self.create_tcp_stream(inside_vrf10, outside, limit * 2)
2537 inside_vrf10.add_stream(stream)
2539 self.pg_enable_capture(self.pg_interfaces)
2542 capture = outside.get_capture(limit)
2544 stream = self.create_tcp_stream(inside, outside, limit * 2)
2545 inside.add_stream(stream)
2547 self.pg_enable_capture(self.pg_interfaces)
2550 capture = outside.get_capture(len(stream))
2552 def test_show_max_translations(self):
2553 """ NAT44ED API test - max translations per thread """
2554 nat_config = self.vapi.nat_show_config_2()
2555 self.assertEqual(self.max_sessions,
2556 nat_config.max_translations_per_thread)
2558 def test_lru_cleanup(self):
2559 """ NAT44ED LRU cleanup algorithm """
2561 self.nat_add_address(self.nat_addr)
2562 self.nat_add_inside_interface(self.pg0)
2563 self.nat_add_outside_interface(self.pg1)
2565 self.vapi.nat_set_timeouts(
2566 udp=1, tcp_established=7440, tcp_transitory=30, icmp=1)
2568 tcp_port_out = self.init_tcp_session(self.pg0, self.pg1, 2000, 80)
2570 for i in range(0, self.max_sessions - 1):
2571 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2572 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4, ttl=64) /
2573 UDP(sport=7000+i, dport=80))
2576 self.pg0.add_stream(pkts)
2577 self.pg_enable_capture(self.pg_interfaces)
2579 self.pg1.get_capture(len(pkts))
2580 self.sleep(1.5, "wait for timeouts")
2583 for i in range(0, self.max_sessions - 1):
2584 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2585 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4, ttl=64) /
2586 ICMP(id=8000+i, type='echo-request'))
2589 self.pg0.add_stream(pkts)
2590 self.pg_enable_capture(self.pg_interfaces)
2592 self.pg1.get_capture(len(pkts))
2594 def test_session_rst_timeout(self):
2595 """ NAT44ED session RST timeouts """
2597 self.nat_add_address(self.nat_addr)
2598 self.nat_add_inside_interface(self.pg0)
2599 self.nat_add_outside_interface(self.pg1)
2601 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
2602 tcp_transitory=5, icmp=60)
2604 self.init_tcp_session(self.pg0, self.pg1, self.tcp_port_in,
2605 self.tcp_external_port)
2606 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2607 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2608 TCP(sport=self.tcp_port_in, dport=self.tcp_external_port,
2610 self.pg0.add_stream(p)
2611 self.pg_enable_capture(self.pg_interfaces)
2613 self.pg1.get_capture(1)
2617 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2618 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2619 TCP(sport=self.tcp_port_in + 1, dport=self.tcp_external_port + 1,
2621 self.pg0.add_stream(p)
2622 self.pg_enable_capture(self.pg_interfaces)
2624 self.pg1.get_capture(1)
2626 def test_dynamic_out_of_ports(self):
2627 """ NAT44ED dynamic translation test: out of ports """
2629 self.nat_add_inside_interface(self.pg0)
2630 self.nat_add_outside_interface(self.pg1)
2632 # in2out and no NAT addresses added
2633 err_old = self.statistics.get_err_counter(
2634 '/err/nat44-ed-in2out-slowpath/out of ports')
2636 pkts = self.create_stream_in(self.pg0, self.pg1)
2637 self.pg0.add_stream(pkts)
2638 self.pg_enable_capture(self.pg_interfaces)
2640 self.pg1.get_capture(0, timeout=1)
2642 err_new = self.statistics.get_err_counter(
2643 '/err/nat44-ed-in2out-slowpath/out of ports')
2645 self.assertEqual(err_new - err_old, len(pkts))
2647 # in2out after NAT addresses added
2648 self.nat_add_address(self.nat_addr)
2650 err_old = self.statistics.get_err_counter(
2651 '/err/nat44-ed-in2out-slowpath/out of ports')
2653 pkts = self.create_stream_in(self.pg0, self.pg1)
2654 self.pg0.add_stream(pkts)
2655 self.pg_enable_capture(self.pg_interfaces)
2657 capture = self.pg1.get_capture(len(pkts))
2658 self.verify_capture_out(capture, ignore_port=True)
2660 err_new = self.statistics.get_err_counter(
2661 '/err/nat44-ed-in2out-slowpath/out of ports')
2663 self.assertEqual(err_new, err_old)
2665 def test_unknown_proto(self):
2666 """ NAT44ED translate packet with unknown protocol """
2668 self.nat_add_address(self.nat_addr)
2669 self.nat_add_inside_interface(self.pg0)
2670 self.nat_add_outside_interface(self.pg1)
2673 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2674 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2675 TCP(sport=self.tcp_port_in, dport=20))
2676 self.pg0.add_stream(p)
2677 self.pg_enable_capture(self.pg_interfaces)
2679 p = self.pg1.get_capture(1)
2681 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2682 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2684 IP(src=self.pg2.remote_ip4, dst=self.pg2.remote_ip4) /
2685 TCP(sport=1234, dport=1234))
2686 self.pg0.add_stream(p)
2687 self.pg_enable_capture(self.pg_interfaces)
2689 p = self.pg1.get_capture(1)
2692 self.assertEqual(packet[IP].src, self.nat_addr)
2693 self.assertEqual(packet[IP].dst, self.pg1.remote_ip4)
2694 self.assertEqual(packet.haslayer(GRE), 1)
2695 self.assert_packet_checksums_valid(packet)
2697 self.logger.error(ppp("Unexpected or invalid packet:", packet))
2701 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
2702 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
2704 IP(src=self.pg2.remote_ip4, dst=self.pg2.remote_ip4) /
2705 TCP(sport=1234, dport=1234))
2706 self.pg1.add_stream(p)
2707 self.pg_enable_capture(self.pg_interfaces)
2709 p = self.pg0.get_capture(1)
2712 self.assertEqual(packet[IP].src, self.pg1.remote_ip4)
2713 self.assertEqual(packet[IP].dst, self.pg0.remote_ip4)
2714 self.assertEqual(packet.haslayer(GRE), 1)
2715 self.assert_packet_checksums_valid(packet)
2717 self.logger.error(ppp("Unexpected or invalid packet:", packet))
2720 def test_hairpinning_unknown_proto(self):
2721 """ NAT44ED translate packet with unknown protocol - hairpinning """
2722 host = self.pg0.remote_hosts[0]
2723 server = self.pg0.remote_hosts[1]
2725 server_out_port = 8765
2726 server_nat_ip = "10.0.0.11"
2728 self.nat_add_address(self.nat_addr)
2729 self.nat_add_inside_interface(self.pg0)
2730 self.nat_add_outside_interface(self.pg1)
2732 # add static mapping for server
2733 self.nat_add_static_mapping(server.ip4, server_nat_ip)
2736 p = (Ether(src=host.mac, dst=self.pg0.local_mac) /
2737 IP(src=host.ip4, dst=server_nat_ip) /
2738 TCP(sport=host_in_port, dport=server_out_port))
2739 self.pg0.add_stream(p)
2740 self.pg_enable_capture(self.pg_interfaces)
2742 self.pg0.get_capture(1)
2744 p = (Ether(dst=self.pg0.local_mac, src=host.mac) /
2745 IP(src=host.ip4, dst=server_nat_ip) /
2747 IP(src=self.pg2.remote_ip4, dst=self.pg2.remote_ip4) /
2748 TCP(sport=1234, dport=1234))
2749 self.pg0.add_stream(p)
2750 self.pg_enable_capture(self.pg_interfaces)
2752 p = self.pg0.get_capture(1)
2755 self.assertEqual(packet[IP].src, self.nat_addr)
2756 self.assertEqual(packet[IP].dst, server.ip4)
2757 self.assertEqual(packet.haslayer(GRE), 1)
2758 self.assert_packet_checksums_valid(packet)
2760 self.logger.error(ppp("Unexpected or invalid packet:", packet))
2764 p = (Ether(dst=self.pg0.local_mac, src=server.mac) /
2765 IP(src=server.ip4, dst=self.nat_addr) /
2767 IP(src=self.pg2.remote_ip4, dst=self.pg2.remote_ip4) /
2768 TCP(sport=1234, dport=1234))
2769 self.pg0.add_stream(p)
2770 self.pg_enable_capture(self.pg_interfaces)
2772 p = self.pg0.get_capture(1)
2775 self.assertEqual(packet[IP].src, server_nat_ip)
2776 self.assertEqual(packet[IP].dst, host.ip4)
2777 self.assertEqual(packet.haslayer(GRE), 1)
2778 self.assert_packet_checksums_valid(packet)
2780 self.logger.error(ppp("Unexpected or invalid packet:", packet))
2783 def test_output_feature_and_service(self):
2784 """ NAT44ED interface output feature and services """
2785 external_addr = '1.2.3.4'
2789 self.vapi.nat44_forwarding_enable_disable(enable=1)
2790 self.nat_add_address(self.nat_addr)
2791 flags = self.config_flags.NAT_IS_ADDR_ONLY
2792 self.vapi.nat44_add_del_identity_mapping(
2793 ip_address=self.pg1.remote_ip4, sw_if_index=0xFFFFFFFF,
2794 flags=flags, is_add=1)
2795 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
2796 self.nat_add_static_mapping(self.pg0.remote_ip4, external_addr,
2797 local_port, external_port,
2798 proto=IP_PROTOS.tcp, flags=flags)
2800 self.nat_add_inside_interface(self.pg0)
2801 self.nat_add_outside_interface(self.pg0)
2802 self.vapi.nat44_interface_add_del_output_feature(
2803 sw_if_index=self.pg1.sw_if_index, is_add=1)
2805 # from client to service
2806 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
2807 IP(src=self.pg1.remote_ip4, dst=external_addr) /
2808 TCP(sport=12345, dport=external_port))
2809 self.pg1.add_stream(p)
2810 self.pg_enable_capture(self.pg_interfaces)
2812 capture = self.pg0.get_capture(1)
2817 self.assertEqual(ip.dst, self.pg0.remote_ip4)
2818 self.assertEqual(tcp.dport, local_port)
2819 self.assert_packet_checksums_valid(p)
2821 self.logger.error(ppp("Unexpected or invalid packet:", p))
2824 # from service back to client
2825 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2826 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2827 TCP(sport=local_port, dport=12345))
2828 self.pg0.add_stream(p)
2829 self.pg_enable_capture(self.pg_interfaces)
2831 capture = self.pg1.get_capture(1)
2836 self.assertEqual(ip.src, external_addr)
2837 self.assertEqual(tcp.sport, external_port)
2838 self.assert_packet_checksums_valid(p)
2840 self.logger.error(ppp("Unexpected or invalid packet:", p))
2843 # from local network host to external network
2844 pkts = self.create_stream_in(self.pg0, self.pg1)
2845 self.pg0.add_stream(pkts)
2846 self.pg_enable_capture(self.pg_interfaces)
2848 capture = self.pg1.get_capture(len(pkts))
2849 self.verify_capture_out(capture, ignore_port=True)
2850 pkts = self.create_stream_in(self.pg0, self.pg1)
2851 self.pg0.add_stream(pkts)
2852 self.pg_enable_capture(self.pg_interfaces)
2854 capture = self.pg1.get_capture(len(pkts))
2855 self.verify_capture_out(capture, ignore_port=True)
2857 # from external network back to local network host
2858 pkts = self.create_stream_out(self.pg1)
2859 self.pg1.add_stream(pkts)
2860 self.pg_enable_capture(self.pg_interfaces)
2862 capture = self.pg0.get_capture(len(pkts))
2863 self.verify_capture_in(capture, self.pg0)
2865 def test_output_feature_and_service3(self):
2866 """ NAT44ED interface output feature and DST NAT """
2867 external_addr = '1.2.3.4'
2871 self.vapi.nat44_forwarding_enable_disable(enable=1)
2872 self.nat_add_address(self.nat_addr)
2873 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
2874 self.nat_add_static_mapping(self.pg1.remote_ip4, external_addr,
2875 local_port, external_port,
2876 proto=IP_PROTOS.tcp, flags=flags)
2878 self.nat_add_inside_interface(self.pg0)
2879 self.nat_add_outside_interface(self.pg0)
2880 self.vapi.nat44_interface_add_del_output_feature(
2881 sw_if_index=self.pg1.sw_if_index, is_add=1)
2883 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2884 IP(src=self.pg0.remote_ip4, dst=external_addr) /
2885 TCP(sport=12345, dport=external_port))
2886 self.pg0.add_stream(p)
2887 self.pg_enable_capture(self.pg_interfaces)
2889 capture = self.pg1.get_capture(1)
2894 self.assertEqual(ip.src, self.pg0.remote_ip4)
2895 self.assertEqual(tcp.sport, 12345)
2896 self.assertEqual(ip.dst, self.pg1.remote_ip4)
2897 self.assertEqual(tcp.dport, local_port)
2898 self.assert_packet_checksums_valid(p)
2900 self.logger.error(ppp("Unexpected or invalid packet:", p))
2903 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
2904 IP(src=self.pg1.remote_ip4, dst=self.pg0.remote_ip4) /
2905 TCP(sport=local_port, dport=12345))
2906 self.pg1.add_stream(p)
2907 self.pg_enable_capture(self.pg_interfaces)
2909 capture = self.pg0.get_capture(1)
2914 self.assertEqual(ip.src, external_addr)
2915 self.assertEqual(tcp.sport, external_port)
2916 self.assertEqual(ip.dst, self.pg0.remote_ip4)
2917 self.assertEqual(tcp.dport, 12345)
2918 self.assert_packet_checksums_valid(p)
2920 self.logger.error(ppp("Unexpected or invalid packet:", p))
2923 def test_self_twice_nat_lb_negative(self):
2924 """ NAT44ED Self Twice NAT local service load balancing (negative test)
2926 self.twice_nat_common(lb=True, self_twice_nat=True, same_pg=True,
2929 def test_self_twice_nat_negative(self):
2930 """ NAT44ED Self Twice NAT (negative test) """
2931 self.twice_nat_common(self_twice_nat=True)
2933 def test_static_lb_multi_clients(self):
2934 """ NAT44ED local service load balancing - multiple clients"""
2936 external_addr = self.nat_addr
2939 server1 = self.pg0.remote_hosts[0]
2940 server2 = self.pg0.remote_hosts[1]
2941 server3 = self.pg0.remote_hosts[2]
2943 locals = [{'addr': server1.ip4,
2947 {'addr': server2.ip4,
2952 flags = self.config_flags.NAT_IS_INSIDE
2953 self.vapi.nat44_interface_add_del_feature(
2954 sw_if_index=self.pg0.sw_if_index,
2955 flags=flags, is_add=1)
2956 self.vapi.nat44_interface_add_del_feature(
2957 sw_if_index=self.pg1.sw_if_index,
2960 self.nat_add_address(self.nat_addr)
2961 self.vapi.nat44_add_del_lb_static_mapping(is_add=1,
2962 external_addr=external_addr,
2963 external_port=external_port,
2964 protocol=IP_PROTOS.tcp,
2965 local_num=len(locals),
2970 clients = ip4_range(self.pg1.remote_ip4, 10, 50)
2972 for client in clients:
2973 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
2974 IP(src=client, dst=self.nat_addr) /
2975 TCP(sport=12345, dport=external_port))
2977 self.pg1.add_stream(pkts)
2978 self.pg_enable_capture(self.pg_interfaces)
2980 capture = self.pg0.get_capture(len(pkts))
2982 if p[IP].dst == server1.ip4:
2986 self.assertGreaterEqual(server1_n, server2_n)
2989 'addr': server3.ip4,
2996 self.vapi.nat44_lb_static_mapping_add_del_local(
2998 external_addr=external_addr,
2999 external_port=external_port,
3001 protocol=IP_PROTOS.tcp)
3005 clients = ip4_range(self.pg1.remote_ip4, 60, 110)
3007 for client in clients:
3008 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3009 IP(src=client, dst=self.nat_addr) /
3010 TCP(sport=12346, dport=external_port))
3012 self.assertGreater(len(pkts), 0)
3013 self.pg1.add_stream(pkts)
3014 self.pg_enable_capture(self.pg_interfaces)
3016 capture = self.pg0.get_capture(len(pkts))
3018 if p[IP].dst == server1.ip4:
3020 elif p[IP].dst == server2.ip4:
3024 self.assertGreater(server1_n, 0)
3025 self.assertGreater(server2_n, 0)
3026 self.assertGreater(server3_n, 0)
3029 'addr': server2.ip4,
3035 # remove one back-end
3036 self.vapi.nat44_lb_static_mapping_add_del_local(
3038 external_addr=external_addr,
3039 external_port=external_port,
3041 protocol=IP_PROTOS.tcp)
3045 self.pg1.add_stream(pkts)
3046 self.pg_enable_capture(self.pg_interfaces)
3048 capture = self.pg0.get_capture(len(pkts))
3050 if p[IP].dst == server1.ip4:
3052 elif p[IP].dst == server2.ip4:
3056 self.assertGreater(server1_n, 0)
3057 self.assertEqual(server2_n, 0)
3058 self.assertGreater(server3_n, 0)
3060 def test_syslog_sess(self):
3061 """ NAT44ED Test syslog session creation and deletion """
3062 self.vapi.syslog_set_filter(
3063 self.syslog_severity.SYSLOG_API_SEVERITY_INFO)
3064 self.vapi.syslog_set_sender(self.pg3.local_ip4, self.pg3.remote_ip4)
3066 self.nat_add_address(self.nat_addr)
3067 self.nat_add_inside_interface(self.pg0)
3068 self.nat_add_outside_interface(self.pg1)
3070 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
3071 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3072 TCP(sport=self.tcp_port_in, dport=self.tcp_external_port))
3073 self.pg0.add_stream(p)
3074 self.pg_enable_capture(self.pg_interfaces)
3076 capture = self.pg1.get_capture(1)
3077 self.tcp_port_out = capture[0][TCP].sport
3078 capture = self.pg3.get_capture(1)
3079 self.verify_syslog_sess(capture[0][Raw].load)
3081 self.pg_enable_capture(self.pg_interfaces)
3083 self.nat_add_address(self.nat_addr, is_add=0)
3084 capture = self.pg3.get_capture(1)
3085 self.verify_syslog_sess(capture[0][Raw].load, False)
3087 def test_twice_nat_interface_addr(self):
3088 """ NAT44ED Acquire twice NAT addresses from interface """
3089 flags = self.config_flags.NAT_IS_TWICE_NAT
3090 self.vapi.nat44_add_del_interface_addr(
3091 sw_if_index=self.pg11.sw_if_index,
3092 flags=flags, is_add=1)
3094 # no address in NAT pool
3095 adresses = self.vapi.nat44_address_dump()
3096 self.assertEqual(0, len(adresses))
3098 # configure interface address and check NAT address pool
3099 self.pg11.config_ip4()
3100 adresses = self.vapi.nat44_address_dump()
3101 self.assertEqual(1, len(adresses))
3102 self.assertEqual(str(adresses[0].ip_address),
3103 self.pg11.local_ip4)
3104 self.assertEqual(adresses[0].flags, flags)
3106 # remove interface address and check NAT address pool
3107 self.pg11.unconfig_ip4()
3108 adresses = self.vapi.nat44_address_dump()
3109 self.assertEqual(0, len(adresses))
3111 def test_output_feature_stateful_acl(self):
3112 """ NAT44ED output feature works with stateful ACL """
3114 self.nat_add_address(self.nat_addr)
3115 self.vapi.nat44_interface_add_del_output_feature(
3116 sw_if_index=self.pg1.sw_if_index, is_add=1)
3118 # First ensure that the NAT is working sans ACL
3120 # send packets out2in, no sessions yet so packets should drop
3121 pkts_out2in = self.create_stream_out(self.pg1)
3122 self.send_and_assert_no_replies(self.pg1, pkts_out2in)
3124 # send packets into inside intf, ensure received via outside intf
3125 pkts_in2out = self.create_stream_in(self.pg0, self.pg1)
3126 capture = self.send_and_expect(self.pg0, pkts_in2out, self.pg1,
3128 self.verify_capture_out(capture, ignore_port=True)
3130 # send out2in again, with sessions created it should work now
3131 pkts_out2in = self.create_stream_out(self.pg1)
3132 capture = self.send_and_expect(self.pg1, pkts_out2in, self.pg0,
3134 self.verify_capture_in(capture, self.pg0)
3136 # Create an ACL blocking everything
3137 out2in_deny_rule = AclRule(is_permit=0)
3138 out2in_acl = VppAcl(self, rules=[out2in_deny_rule])
3139 out2in_acl.add_vpp_config()
3141 # create an ACL to permit/reflect everything
3142 in2out_reflect_rule = AclRule(is_permit=2)
3143 in2out_acl = VppAcl(self, rules=[in2out_reflect_rule])
3144 in2out_acl.add_vpp_config()
3146 # apply as input acl on interface and confirm it blocks everything
3147 acl_if = VppAclInterface(self, sw_if_index=self.pg1.sw_if_index,
3148 n_input=1, acls=[out2in_acl])
3149 acl_if.add_vpp_config()
3150 self.send_and_assert_no_replies(self.pg1, pkts_out2in)
3153 acl_if.acls = [out2in_acl, in2out_acl]
3154 acl_if.add_vpp_config()
3155 # send in2out to generate ACL state (NAT state was created earlier)
3156 capture = self.send_and_expect(self.pg0, pkts_in2out, self.pg1,
3158 self.verify_capture_out(capture, ignore_port=True)
3160 # send out2in again. ACL state exists so it should work now.
3161 # TCP packets with the syn flag set also need the ack flag
3162 for p in pkts_out2in:
3163 if p.haslayer(TCP) and p[TCP].flags & 0x02:
3164 p[TCP].flags |= 0x10
3165 capture = self.send_and_expect(self.pg1, pkts_out2in, self.pg0,
3167 self.verify_capture_in(capture, self.pg0)
3168 self.logger.info(self.vapi.cli("show trace"))
3170 def test_tcp_close(self):
3171 """ NAT44ED Close TCP session from inside network - output feature """
3172 old_timeouts = self.vapi.nat_get_timeouts()
3174 self.vapi.nat_set_timeouts(
3175 udp=old_timeouts.udp,
3176 tcp_established=old_timeouts.tcp_established,
3177 icmp=old_timeouts.icmp,
3178 tcp_transitory=new_transitory)
3180 self.vapi.nat44_forwarding_enable_disable(enable=1)
3181 self.nat_add_address(self.pg1.local_ip4)
3182 twice_nat_addr = '10.0.1.3'
3183 service_ip = '192.168.16.150'
3184 self.nat_add_address(twice_nat_addr, twice_nat=1)
3186 flags = self.config_flags.NAT_IS_INSIDE
3187 self.vapi.nat44_interface_add_del_feature(
3188 sw_if_index=self.pg0.sw_if_index,
3190 self.vapi.nat44_interface_add_del_feature(
3191 sw_if_index=self.pg0.sw_if_index,
3192 flags=flags, is_add=1)
3193 self.vapi.nat44_interface_add_del_output_feature(
3195 sw_if_index=self.pg1.sw_if_index)
3197 flags = (self.config_flags.NAT_IS_OUT2IN_ONLY |
3198 self.config_flags.NAT_IS_TWICE_NAT)
3199 self.nat_add_static_mapping(self.pg0.remote_ip4,
3201 proto=IP_PROTOS.tcp,
3203 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3204 start_sessnum = len(sessions)
3206 # SYN packet out->in
3207 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3208 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3209 TCP(sport=33898, dport=80, flags="S"))
3210 self.pg1.add_stream(p)
3211 self.pg_enable_capture(self.pg_interfaces)
3213 capture = self.pg0.get_capture(1)
3215 tcp_port = p[TCP].sport
3217 # SYN + ACK packet in->out
3218 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3219 IP(src=self.pg0.remote_ip4, dst=twice_nat_addr) /
3220 TCP(sport=80, dport=tcp_port, flags="SA"))
3221 self.pg0.add_stream(p)
3222 self.pg_enable_capture(self.pg_interfaces)
3224 self.pg1.get_capture(1)
3226 # ACK packet out->in
3227 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3228 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3229 TCP(sport=33898, dport=80, flags="A"))
3230 self.pg1.add_stream(p)
3231 self.pg_enable_capture(self.pg_interfaces)
3233 self.pg0.get_capture(1)
3235 # FIN packet in -> out
3236 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3237 IP(src=self.pg0.remote_ip4, dst=twice_nat_addr) /
3238 TCP(sport=80, dport=tcp_port, flags="FA", seq=100, ack=300))
3239 self.pg0.add_stream(p)
3240 self.pg_enable_capture(self.pg_interfaces)
3242 self.pg1.get_capture(1)
3244 # FIN+ACK packet out -> in
3245 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3246 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3247 TCP(sport=33898, dport=80, flags="FA", seq=300, ack=101))
3248 self.pg1.add_stream(p)
3249 self.pg_enable_capture(self.pg_interfaces)
3251 self.pg0.get_capture(1)
3253 # ACK packet in -> out
3254 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3255 IP(src=self.pg0.remote_ip4, dst=twice_nat_addr) /
3256 TCP(sport=80, dport=tcp_port, flags="A", seq=101, ack=301))
3257 self.pg0.add_stream(p)
3258 self.pg_enable_capture(self.pg_interfaces)
3260 self.pg1.get_capture(1)
3262 # session now in transitory timeout
3263 # try SYN packet out->in - should be dropped
3264 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3265 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3266 TCP(sport=33898, dport=80, flags="S"))
3267 self.pg1.add_stream(p)
3268 self.pg_enable_capture(self.pg_interfaces)
3271 self.sleep(new_transitory, "wait for transitory timeout")
3272 self.pg0.assert_nothing_captured(0)
3274 # session should still exist
3275 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3276 self.assertEqual(len(sessions) - start_sessnum, 1)
3278 # send FIN+ACK packet out -> in - will cause session to be wiped
3279 # but won't create a new session
3280 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3281 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3282 TCP(sport=33898, dport=80, flags="FA", seq=300, ack=101))
3283 self.pg1.add_stream(p)
3284 self.pg_enable_capture(self.pg_interfaces)
3287 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3288 self.assertEqual(len(sessions) - start_sessnum, 0)
3289 self.pg0.assert_nothing_captured(0)
3291 def test_tcp_session_close_in(self):
3292 """ NAT44ED Close TCP session from inside network """
3294 in_port = self.tcp_port_in
3296 ext_port = self.tcp_external_port
3298 self.nat_add_address(self.nat_addr)
3299 self.nat_add_inside_interface(self.pg0)
3300 self.nat_add_outside_interface(self.pg1)
3301 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
3302 in_port, out_port, proto=IP_PROTOS.tcp,
3303 flags=self.config_flags.NAT_IS_TWICE_NAT)
3305 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3306 session_n = len(sessions)
3308 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
3309 tcp_transitory=2, icmp=5)
3311 self.init_tcp_session(self.pg0, self.pg1, in_port, ext_port)
3313 # FIN packet in -> out
3314 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3315 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3316 TCP(sport=in_port, dport=ext_port,
3317 flags="FA", seq=100, ack=300))
3318 self.pg0.add_stream(p)
3319 self.pg_enable_capture(self.pg_interfaces)
3321 self.pg1.get_capture(1)
3325 # ACK packet out -> in
3326 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3327 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3328 TCP(sport=ext_port, dport=out_port,
3329 flags="A", seq=300, ack=101))
3332 # FIN packet out -> in
3333 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3334 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3335 TCP(sport=ext_port, dport=out_port,
3336 flags="FA", seq=300, ack=101))
3339 self.pg1.add_stream(pkts)
3340 self.pg_enable_capture(self.pg_interfaces)
3342 self.pg0.get_capture(2)
3344 # ACK packet in -> out
3345 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3346 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3347 TCP(sport=in_port, dport=ext_port,
3348 flags="A", seq=101, ack=301))
3349 self.pg0.add_stream(p)
3350 self.pg_enable_capture(self.pg_interfaces)
3352 self.pg1.get_capture(1)
3354 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3355 self.assertEqual(len(sessions) - session_n, 1)
3357 out2in_drops = self.get_err_counter(
3358 '/err/nat44-ed-out2in/drops due to TCP in transitory timeout')
3359 in2out_drops = self.get_err_counter(
3360 '/err/nat44-ed-in2out/drops due to TCP in transitory timeout')
3362 # extra FIN packet out -> in - this should be dropped
3363 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3364 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3365 TCP(sport=ext_port, dport=out_port,
3366 flags="FA", seq=300, ack=101))
3368 self.pg1.add_stream(p)
3369 self.pg_enable_capture(self.pg_interfaces)
3371 self.pg0.assert_nothing_captured()
3373 # extra ACK packet in -> out - this should be dropped
3374 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3375 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3376 TCP(sport=in_port, dport=ext_port,
3377 flags="A", seq=101, ack=301))
3378 self.pg0.add_stream(p)
3379 self.pg_enable_capture(self.pg_interfaces)
3381 self.pg1.assert_nothing_captured()
3383 stats = self.get_err_counter(
3384 '/err/nat44-ed-out2in/drops due to TCP in transitory timeout')
3385 self.assertEqual(stats - out2in_drops, 1)
3386 stats = self.get_err_counter(
3387 '/err/nat44-ed-in2out/drops due to TCP in transitory timeout')
3388 self.assertEqual(stats - in2out_drops, 1)
3391 # extra ACK packet in -> out - this will cause session to be wiped
3392 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3393 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3394 TCP(sport=in_port, dport=ext_port,
3395 flags="A", seq=101, ack=301))
3396 self.pg0.add_stream(p)
3397 self.pg_enable_capture(self.pg_interfaces)
3399 self.pg1.assert_nothing_captured()
3400 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3401 self.assertEqual(len(sessions) - session_n, 0)
3403 def test_tcp_session_close_out(self):
3404 """ NAT44ED Close TCP session from outside network """
3406 in_port = self.tcp_port_in
3408 ext_port = self.tcp_external_port
3410 self.nat_add_address(self.nat_addr)
3411 self.nat_add_inside_interface(self.pg0)
3412 self.nat_add_outside_interface(self.pg1)
3413 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
3414 in_port, out_port, proto=IP_PROTOS.tcp,
3415 flags=self.config_flags.NAT_IS_TWICE_NAT)
3417 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3418 session_n = len(sessions)
3420 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
3421 tcp_transitory=2, icmp=5)
3423 _ = self.init_tcp_session(self.pg0, self.pg1, in_port, ext_port)
3425 # FIN packet out -> in
3426 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3427 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3428 TCP(sport=ext_port, dport=out_port,
3429 flags="FA", seq=100, ack=300))
3430 self.pg1.add_stream(p)
3431 self.pg_enable_capture(self.pg_interfaces)
3433 self.pg0.get_capture(1)
3435 # FIN+ACK packet in -> out
3436 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3437 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3438 TCP(sport=in_port, dport=ext_port,
3439 flags="FA", seq=300, ack=101))
3441 self.pg0.add_stream(p)
3442 self.pg_enable_capture(self.pg_interfaces)
3444 self.pg1.get_capture(1)
3446 # ACK packet out -> in
3447 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3448 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3449 TCP(sport=ext_port, dport=out_port,
3450 flags="A", seq=101, ack=301))
3451 self.pg1.add_stream(p)
3452 self.pg_enable_capture(self.pg_interfaces)
3454 self.pg0.get_capture(1)
3456 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3457 self.assertEqual(len(sessions) - session_n, 1)
3459 out2in_drops = self.get_err_counter(
3460 '/err/nat44-ed-out2in/drops due to TCP in transitory timeout')
3461 in2out_drops = self.get_err_counter(
3462 '/err/nat44-ed-in2out/drops due to TCP in transitory timeout')
3464 # extra FIN packet out -> in - this should be dropped
3465 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3466 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3467 TCP(sport=ext_port, dport=out_port,
3468 flags="FA", seq=300, ack=101))
3470 self.pg1.add_stream(p)
3471 self.pg_enable_capture(self.pg_interfaces)
3473 self.pg0.assert_nothing_captured()
3475 # extra ACK packet in -> out - this should be dropped
3476 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3477 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3478 TCP(sport=in_port, dport=ext_port,
3479 flags="A", seq=101, ack=301))
3480 self.pg0.add_stream(p)
3481 self.pg_enable_capture(self.pg_interfaces)
3483 self.pg1.assert_nothing_captured()
3485 stats = self.get_err_counter(
3486 '/err/nat44-ed-out2in/drops due to TCP in transitory timeout')
3487 self.assertEqual(stats - out2in_drops, 1)
3488 stats = self.get_err_counter(
3489 '/err/nat44-ed-in2out/drops due to TCP in transitory timeout')
3490 self.assertEqual(stats - in2out_drops, 1)
3493 # extra ACK packet in -> out - this will cause session to be wiped
3494 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3495 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3496 TCP(sport=in_port, dport=ext_port,
3497 flags="A", seq=101, ack=301))
3498 self.pg0.add_stream(p)
3499 self.pg_enable_capture(self.pg_interfaces)
3501 self.pg1.assert_nothing_captured()
3502 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3503 self.assertEqual(len(sessions) - session_n, 0)
3505 def test_tcp_session_close_simultaneous(self):
3506 """ NAT44ED Close TCP session from inside network """
3508 in_port = self.tcp_port_in
3511 self.nat_add_address(self.nat_addr)
3512 self.nat_add_inside_interface(self.pg0)
3513 self.nat_add_outside_interface(self.pg1)
3514 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
3515 in_port, ext_port, proto=IP_PROTOS.tcp,
3516 flags=self.config_flags.NAT_IS_TWICE_NAT)
3518 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3519 session_n = len(sessions)
3521 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
3522 tcp_transitory=2, icmp=5)
3524 out_port = self.init_tcp_session(self.pg0, self.pg1, in_port, ext_port)
3526 # FIN packet in -> out
3527 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3528 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3529 TCP(sport=in_port, dport=ext_port,
3530 flags="FA", seq=100, ack=300))
3531 self.pg0.add_stream(p)
3532 self.pg_enable_capture(self.pg_interfaces)
3534 self.pg1.get_capture(1)
3536 # FIN packet out -> in
3537 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3538 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3539 TCP(sport=ext_port, dport=out_port,
3540 flags="FA", seq=300, ack=100))
3541 self.pg1.add_stream(p)
3542 self.pg_enable_capture(self.pg_interfaces)
3544 self.pg0.get_capture(1)
3546 # ACK packet in -> out
3547 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3548 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3549 TCP(sport=in_port, dport=ext_port,
3550 flags="A", seq=101, ack=301))
3551 self.pg0.add_stream(p)
3552 self.pg_enable_capture(self.pg_interfaces)
3554 self.pg1.get_capture(1)
3556 # ACK packet out -> in
3557 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3558 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3559 TCP(sport=ext_port, dport=out_port,
3560 flags="A", seq=301, ack=101))
3561 self.pg1.add_stream(p)
3562 self.pg_enable_capture(self.pg_interfaces)
3564 self.pg0.get_capture(1)
3566 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3567 self.assertEqual(len(sessions) - session_n, 1)
3569 out2in_drops = self.get_err_counter(
3570 '/err/nat44-ed-out2in/drops due to TCP in transitory timeout')
3571 in2out_drops = self.get_err_counter(
3572 '/err/nat44-ed-in2out/drops due to TCP in transitory timeout')
3574 # extra FIN packet out -> in - this should be dropped
3575 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3576 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3577 TCP(sport=ext_port, dport=out_port,
3578 flags="FA", seq=300, ack=101))
3580 self.pg1.add_stream(p)
3581 self.pg_enable_capture(self.pg_interfaces)
3583 self.pg0.assert_nothing_captured()
3585 # extra ACK packet in -> out - this should be dropped
3586 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3587 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3588 TCP(sport=in_port, dport=ext_port,
3589 flags="A", seq=101, ack=301))
3590 self.pg0.add_stream(p)
3591 self.pg_enable_capture(self.pg_interfaces)
3593 self.pg1.assert_nothing_captured()
3595 stats = self.get_err_counter(
3596 '/err/nat44-ed-out2in/drops due to TCP in transitory timeout')
3597 self.assertEqual(stats - out2in_drops, 1)
3598 stats = self.get_err_counter(
3599 '/err/nat44-ed-in2out/drops due to TCP in transitory timeout')
3600 self.assertEqual(stats - in2out_drops, 1)
3603 # extra ACK packet in -> out - this will cause session to be wiped
3604 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3605 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3606 TCP(sport=in_port, dport=ext_port,
3607 flags="A", seq=101, ack=301))
3608 self.pg0.add_stream(p)
3609 self.pg_enable_capture(self.pg_interfaces)
3611 self.pg1.assert_nothing_captured()
3612 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3613 self.assertEqual(len(sessions) - session_n, 0)
3615 def test_dynamic_vrf(self):
3616 """ NAT44ED dynamic translation test: different VRF"""
3621 self.nat_add_address(self.nat_addr, vrf_id=vrf_id_in)
3624 self.configure_ip4_interface(self.pg7, table_id=vrf_id_in)
3625 self.configure_ip4_interface(self.pg8, table_id=vrf_id_out)
3627 self.nat_add_inside_interface(self.pg7)
3628 self.nat_add_outside_interface(self.pg8)
3630 # just basic stuff nothing special
3631 pkts = self.create_stream_in(self.pg7, self.pg8)
3632 self.pg7.add_stream(pkts)
3633 self.pg_enable_capture(self.pg_interfaces)
3635 capture = self.pg8.get_capture(len(pkts))
3636 self.verify_capture_out(capture, ignore_port=True)
3638 pkts = self.create_stream_out(self.pg8)
3639 self.pg8.add_stream(pkts)
3640 self.pg_enable_capture(self.pg_interfaces)
3642 capture = self.pg7.get_capture(len(pkts))
3643 self.verify_capture_in(capture, self.pg7)
3649 self.vapi.ip_table_add_del(is_add=0,
3650 table={'table_id': vrf_id_in})
3651 self.vapi.ip_table_add_del(is_add=0,
3652 table={'table_id': vrf_id_out})
3654 def test_dynamic_output_feature_vrf(self):
3655 """ NAT44ED dynamic translation test: output-feature, VRF"""
3657 # other then default (0)
3660 self.nat_add_address(self.nat_addr)
3661 self.vapi.nat44_interface_add_del_output_feature(
3662 sw_if_index=self.pg8.sw_if_index, is_add=1)
3665 self.configure_ip4_interface(self.pg7, table_id=new_vrf_id)
3666 self.configure_ip4_interface(self.pg8, table_id=new_vrf_id)
3669 tcpn = self.statistics['/nat44-ed/in2out/slowpath/tcp']
3670 udpn = self.statistics['/nat44-ed/in2out/slowpath/udp']
3671 icmpn = self.statistics['/nat44-ed/in2out/slowpath/icmp']
3672 drops = self.statistics['/nat44-ed/in2out/slowpath/drops']
3674 pkts = self.create_stream_in(self.pg7, self.pg8)
3675 self.pg7.add_stream(pkts)
3676 self.pg_enable_capture(self.pg_interfaces)
3678 capture = self.pg8.get_capture(len(pkts))
3679 self.verify_capture_out(capture, ignore_port=True)
3681 if_idx = self.pg8.sw_if_index
3682 cnt = self.statistics['/nat44-ed/in2out/slowpath/tcp']
3683 self.assertEqual(cnt[:, if_idx].sum() - tcpn[:, if_idx].sum(), 2)
3684 cnt = self.statistics['/nat44-ed/in2out/slowpath/udp']
3685 self.assertEqual(cnt[:, if_idx].sum() - udpn[:, if_idx].sum(), 1)
3686 cnt = self.statistics['/nat44-ed/in2out/slowpath/icmp']
3687 self.assertEqual(cnt[:, if_idx].sum() - icmpn[:, if_idx].sum(), 1)
3688 cnt = self.statistics['/nat44-ed/in2out/slowpath/drops']
3689 self.assertEqual(cnt[:, if_idx].sum() - drops[:, if_idx].sum(), 0)
3692 tcpn = self.statistics['/nat44-ed/out2in/fastpath/tcp']
3693 udpn = self.statistics['/nat44-ed/out2in/fastpath/udp']
3694 icmpn = self.statistics['/nat44-ed/out2in/fastpath/icmp']
3695 drops = self.statistics['/nat44-ed/out2in/fastpath/drops']
3697 pkts = self.create_stream_out(self.pg8)
3698 self.pg8.add_stream(pkts)
3699 self.pg_enable_capture(self.pg_interfaces)
3701 capture = self.pg7.get_capture(len(pkts))
3702 self.verify_capture_in(capture, self.pg7)
3704 if_idx = self.pg8.sw_if_index
3705 cnt = self.statistics['/nat44-ed/out2in/fastpath/tcp']
3706 self.assertEqual(cnt[:, if_idx].sum() - tcpn[:, if_idx].sum(), 2)
3707 cnt = self.statistics['/nat44-ed/out2in/fastpath/udp']
3708 self.assertEqual(cnt[:, if_idx].sum() - udpn[:, if_idx].sum(), 1)
3709 cnt = self.statistics['/nat44-ed/out2in/fastpath/icmp']
3710 self.assertEqual(cnt[:, if_idx].sum() - icmpn[:, if_idx].sum(), 1)
3711 cnt = self.statistics['/nat44-ed/out2in/fastpath/drops']
3712 self.assertEqual(cnt[:, if_idx].sum() - drops[:, if_idx].sum(), 0)
3714 sessions = self.statistics['/nat44-ed/total-sessions']
3715 self.assertEqual(sessions[:, 0].sum(), 3)
3721 self.vapi.ip_table_add_del(is_add=0,
3722 table={'table_id': new_vrf_id})
3724 def test_next_src_nat(self):
3725 """ NAT44ED On way back forward packet to nat44-in2out node. """
3727 twice_nat_addr = '10.0.1.3'
3730 post_twice_nat_port = 0
3732 self.vapi.nat44_forwarding_enable_disable(enable=1)
3733 self.nat_add_address(twice_nat_addr, twice_nat=1)
3734 flags = (self.config_flags.NAT_IS_OUT2IN_ONLY |
3735 self.config_flags.NAT_IS_SELF_TWICE_NAT)
3736 self.nat_add_static_mapping(self.pg6.remote_ip4, self.pg1.remote_ip4,
3737 local_port, external_port,
3738 proto=IP_PROTOS.tcp, vrf_id=1,
3740 self.vapi.nat44_interface_add_del_feature(
3741 sw_if_index=self.pg6.sw_if_index,
3744 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
3745 IP(src=self.pg6.remote_ip4, dst=self.pg1.remote_ip4) /
3746 TCP(sport=12345, dport=external_port))
3747 self.pg6.add_stream(p)
3748 self.pg_enable_capture(self.pg_interfaces)
3750 capture = self.pg6.get_capture(1)
3755 self.assertEqual(ip.src, twice_nat_addr)
3756 self.assertNotEqual(tcp.sport, 12345)
3757 post_twice_nat_port = tcp.sport
3758 self.assertEqual(ip.dst, self.pg6.remote_ip4)
3759 self.assertEqual(tcp.dport, local_port)
3760 self.assert_packet_checksums_valid(p)
3762 self.logger.error(ppp("Unexpected or invalid packet:", p))
3765 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
3766 IP(src=self.pg6.remote_ip4, dst=twice_nat_addr) /
3767 TCP(sport=local_port, dport=post_twice_nat_port))
3768 self.pg6.add_stream(p)
3769 self.pg_enable_capture(self.pg_interfaces)
3771 capture = self.pg6.get_capture(1)
3776 self.assertEqual(ip.src, self.pg1.remote_ip4)
3777 self.assertEqual(tcp.sport, external_port)
3778 self.assertEqual(ip.dst, self.pg6.remote_ip4)
3779 self.assertEqual(tcp.dport, 12345)
3780 self.assert_packet_checksums_valid(p)
3782 self.logger.error(ppp("Unexpected or invalid packet:", p))
3785 def test_one_armed_nat44_static(self):
3786 """ NAT44ED One armed NAT and 1:1 NAPT asymmetrical rule """
3788 remote_host = self.pg4.remote_hosts[0]
3789 local_host = self.pg4.remote_hosts[1]
3794 self.vapi.nat44_forwarding_enable_disable(enable=1)
3795 self.nat_add_address(self.nat_addr, twice_nat=1)
3796 flags = (self.config_flags.NAT_IS_OUT2IN_ONLY |
3797 self.config_flags.NAT_IS_TWICE_NAT)
3798 self.nat_add_static_mapping(local_host.ip4, self.nat_addr,
3799 local_port, external_port,
3800 proto=IP_PROTOS.tcp, flags=flags)
3801 flags = self.config_flags.NAT_IS_INSIDE
3802 self.vapi.nat44_interface_add_del_feature(
3803 sw_if_index=self.pg4.sw_if_index,
3805 self.vapi.nat44_interface_add_del_feature(
3806 sw_if_index=self.pg4.sw_if_index,
3807 flags=flags, is_add=1)
3809 # from client to service
3810 p = (Ether(src=self.pg4.remote_mac, dst=self.pg4.local_mac) /
3811 IP(src=remote_host.ip4, dst=self.nat_addr) /
3812 TCP(sport=12345, dport=external_port))
3813 self.pg4.add_stream(p)
3814 self.pg_enable_capture(self.pg_interfaces)
3816 capture = self.pg4.get_capture(1)
3821 self.assertEqual(ip.dst, local_host.ip4)
3822 self.assertEqual(ip.src, self.nat_addr)
3823 self.assertEqual(tcp.dport, local_port)
3824 self.assertNotEqual(tcp.sport, 12345)
3825 eh_port_in = tcp.sport
3826 self.assert_packet_checksums_valid(p)
3828 self.logger.error(ppp("Unexpected or invalid packet:", p))
3831 # from service back to client
3832 p = (Ether(src=self.pg4.remote_mac, dst=self.pg4.local_mac) /
3833 IP(src=local_host.ip4, dst=self.nat_addr) /
3834 TCP(sport=local_port, dport=eh_port_in))
3835 self.pg4.add_stream(p)
3836 self.pg_enable_capture(self.pg_interfaces)
3838 capture = self.pg4.get_capture(1)
3843 self.assertEqual(ip.src, self.nat_addr)
3844 self.assertEqual(ip.dst, remote_host.ip4)
3845 self.assertEqual(tcp.sport, external_port)
3846 self.assertEqual(tcp.dport, 12345)
3847 self.assert_packet_checksums_valid(p)
3849 self.logger.error(ppp("Unexpected or invalid packet:", p))
3852 def test_icmp_error_fwd_outbound(self):
3853 """ NAT44ED ICMP error outbound with forwarding enabled """
3855 # Ensure that an outbound ICMP error message is properly associated
3856 # with the inbound forward bypass session it is related to.
3859 self.nat_add_address(self.nat_addr)
3860 self.nat_add_inside_interface(self.pg0)
3861 self.nat_add_outside_interface(self.pg1)
3863 # enable forwarding and initiate connection out2in
3864 self.vapi.nat44_forwarding_enable_disable(enable=1)
3865 p1 = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3866 IP(src=self.pg1.remote_ip4, dst=self.pg0.remote_ip4) /
3867 UDP(sport=21, dport=20) / payload)
3869 self.pg1.add_stream(p1)
3870 self.pg_enable_capture(self.pg_interfaces)
3872 capture = self.pg0.get_capture(1)[0]
3874 self.logger.info(self.vapi.cli("show nat44 sessions"))
3876 # reply with ICMP error message in2out
3877 # We cannot reliably retrieve forward bypass sessions via the API.
3878 # session dumps for a user will only look on the worker that the
3879 # user is supposed to be mapped to in2out. The forward bypass session
3880 # is not necessarily created on that worker.
3881 p2 = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3882 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3883 ICMP(type='dest-unreach', code='port-unreachable') /
3886 self.pg0.add_stream(p2)
3887 self.pg_enable_capture(self.pg_interfaces)
3889 capture = self.pg1.get_capture(1)[0]
3891 self.logger.info(self.vapi.cli("show nat44 sessions"))
3893 self.logger.info(ppp("p1 packet:", p1))
3894 self.logger.info(ppp("p2 packet:", p2))
3895 self.logger.info(ppp("capture packet:", capture))
3898 if __name__ == '__main__':
3899 unittest.main(testRunner=VppTestRunner)