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 NAT44EDTestCase(VppTestCase):
35 tcp_external_port = 80
40 super(NAT44EDTestCase, self).setUp()
44 super(NAT44EDTestCase, self).tearDown()
48 def plugin_enable(self):
49 self.vapi.nat44_ed_plugin_enable_disable(
50 sessions=self.max_sessions, enable=1)
52 def plugin_disable(self):
53 self.vapi.nat44_ed_plugin_enable_disable(enable=0)
56 def config_flags(self):
57 return VppEnum.vl_api_nat_config_flags_t
60 def nat44_config_flags(self):
61 return VppEnum.vl_api_nat44_config_flags_t
64 def syslog_severity(self):
65 return VppEnum.vl_api_syslog_severity_t
68 def server_addr(self):
69 return self.pg1.remote_hosts[0].ip4
73 return randint(1025, 65535)
76 def proto2layer(proto):
77 if proto == IP_PROTOS.tcp:
79 elif proto == IP_PROTOS.udp:
81 elif proto == IP_PROTOS.icmp:
84 raise Exception("Unsupported protocol")
87 def create_and_add_ip4_table(cls, i, table_id=0):
88 cls.vapi.ip_table_add_del(is_add=1, table={'table_id': table_id})
89 i.set_table_ip4(table_id)
92 def configure_ip4_interface(cls, i, hosts=0, table_id=None):
94 cls.create_and_add_ip4_table(i, table_id)
101 i.generate_remote_hosts(hosts)
102 i.configure_ipv4_neighbors()
105 def nat_add_interface_address(cls, i):
106 cls.vapi.nat44_add_del_interface_addr(
107 sw_if_index=i.sw_if_index, is_add=1)
109 def nat_add_inside_interface(self, i):
110 self.vapi.nat44_interface_add_del_feature(
111 flags=self.config_flags.NAT_IS_INSIDE,
112 sw_if_index=i.sw_if_index, is_add=1)
114 def nat_add_outside_interface(self, i):
115 self.vapi.nat44_interface_add_del_feature(
116 flags=self.config_flags.NAT_IS_OUTSIDE,
117 sw_if_index=i.sw_if_index, is_add=1)
119 def nat_add_address(self, address, twice_nat=0,
120 vrf_id=0xFFFFFFFF, is_add=1):
121 flags = self.config_flags.NAT_IS_TWICE_NAT if twice_nat else 0
122 self.vapi.nat44_add_del_address_range(first_ip_address=address,
123 last_ip_address=address,
128 def nat_add_static_mapping(self, local_ip, external_ip='0.0.0.0',
129 local_port=0, external_port=0, vrf_id=0,
130 is_add=1, external_sw_if_index=0xFFFFFFFF,
131 proto=0, tag="", flags=0):
133 if not (local_port and external_port):
134 flags |= self.config_flags.NAT_IS_ADDR_ONLY
136 self.vapi.nat44_add_del_static_mapping(
138 local_ip_address=local_ip,
139 external_ip_address=external_ip,
140 external_sw_if_index=external_sw_if_index,
141 local_port=local_port,
142 external_port=external_port,
143 vrf_id=vrf_id, protocol=proto,
149 super(NAT44EDTestCase, cls).setUpClass()
151 cls.create_pg_interfaces(range(12))
152 cls.interfaces = list(cls.pg_interfaces[:4])
154 cls.create_and_add_ip4_table(cls.pg2, 10)
156 for i in cls.interfaces:
157 cls.configure_ip4_interface(i, hosts=3)
159 # test specific (test-multiple-vrf)
160 cls.vapi.ip_table_add_del(is_add=1, table={'table_id': 1})
162 # test specific (test-one-armed-nat44-static)
163 cls.pg4.generate_remote_hosts(2)
165 cls.vapi.sw_interface_add_del_address(
166 sw_if_index=cls.pg4.sw_if_index,
167 prefix="10.0.0.1/24")
169 cls.pg4.resolve_arp()
170 cls.pg4._remote_hosts[1]._ip4 = cls.pg4._remote_hosts[0]._ip4
171 cls.pg4.resolve_arp()
173 # test specific interface (pg5)
174 cls.pg5._local_ip4 = "10.1.1.1"
175 cls.pg5._remote_hosts[0]._ip4 = "10.1.1.2"
176 cls.pg5.set_table_ip4(1)
179 cls.pg5.resolve_arp()
181 # test specific interface (pg6)
182 cls.pg6._local_ip4 = "10.1.2.1"
183 cls.pg6._remote_hosts[0]._ip4 = "10.1.2.2"
184 cls.pg6.set_table_ip4(1)
187 cls.pg6.resolve_arp()
191 rl.append(VppIpRoute(cls, "0.0.0.0", 0,
192 [VppRoutePath("0.0.0.0", 0xffffffff,
194 register=False, table_id=1))
195 rl.append(VppIpRoute(cls, "0.0.0.0", 0,
196 [VppRoutePath(cls.pg1.local_ip4,
197 cls.pg1.sw_if_index)],
199 rl.append(VppIpRoute(cls, cls.pg5.remote_ip4, 32,
200 [VppRoutePath("0.0.0.0",
201 cls.pg5.sw_if_index)],
202 register=False, table_id=1))
203 rl.append(VppIpRoute(cls, cls.pg6.remote_ip4, 32,
204 [VppRoutePath("0.0.0.0",
205 cls.pg6.sw_if_index)],
206 register=False, table_id=1))
207 rl.append(VppIpRoute(cls, cls.pg6.remote_ip4, 16,
208 [VppRoutePath("0.0.0.0", 0xffffffff,
210 register=False, table_id=0))
215 def get_err_counter(self, path):
216 return self.statistics.get_err_counter(path)
218 def reass_hairpinning(self, server_addr, server_in_port, server_out_port,
219 host_in_port, proto=IP_PROTOS.tcp,
221 layer = self.proto2layer(proto)
223 if proto == IP_PROTOS.tcp:
224 data = b"A" * 4 + b"B" * 16 + b"C" * 3
226 data = b"A" * 16 + b"B" * 16 + b"C" * 3
228 # send packet from host to server
229 pkts = self.create_stream_frag(self.pg0,
235 self.pg0.add_stream(pkts)
236 self.pg_enable_capture(self.pg_interfaces)
238 frags = self.pg0.get_capture(len(pkts))
239 p = self.reass_frags_and_verify(frags,
242 if proto != IP_PROTOS.icmp:
244 self.assertNotEqual(p[layer].sport, host_in_port)
245 self.assertEqual(p[layer].dport, server_in_port)
248 self.assertNotEqual(p[layer].id, host_in_port)
249 self.assertEqual(data, p[Raw].load)
251 def frag_out_of_order(self, proto=IP_PROTOS.tcp, dont_translate=False,
253 layer = self.proto2layer(proto)
255 if proto == IP_PROTOS.tcp:
256 data = b"A" * 4 + b"B" * 16 + b"C" * 3
258 data = b"A" * 16 + b"B" * 16 + b"C" * 3
259 self.port_in = self.random_port()
263 pkts = self.create_stream_frag(self.pg0, self.pg1.remote_ip4,
264 self.port_in, 20, data, proto)
266 self.pg0.add_stream(pkts)
267 self.pg_enable_capture(self.pg_interfaces)
269 frags = self.pg1.get_capture(len(pkts))
270 if not dont_translate:
271 p = self.reass_frags_and_verify(frags,
275 p = self.reass_frags_and_verify(frags,
278 if proto != IP_PROTOS.icmp:
279 if not dont_translate:
280 self.assertEqual(p[layer].dport, 20)
282 self.assertNotEqual(p[layer].sport, self.port_in)
284 self.assertEqual(p[layer].sport, self.port_in)
287 if not dont_translate:
288 self.assertNotEqual(p[layer].id, self.port_in)
290 self.assertEqual(p[layer].id, self.port_in)
291 self.assertEqual(data, p[Raw].load)
294 if not dont_translate:
295 dst_addr = self.nat_addr
297 dst_addr = self.pg0.remote_ip4
298 if proto != IP_PROTOS.icmp:
300 dport = p[layer].sport
304 pkts = self.create_stream_frag(self.pg1, dst_addr, sport, dport,
305 data, proto, echo_reply=True)
307 self.pg1.add_stream(pkts)
308 self.pg_enable_capture(self.pg_interfaces)
309 self.logger.info(self.vapi.cli("show trace"))
311 frags = self.pg0.get_capture(len(pkts))
312 p = self.reass_frags_and_verify(frags,
315 if proto != IP_PROTOS.icmp:
316 self.assertEqual(p[layer].sport, 20)
317 self.assertEqual(p[layer].dport, self.port_in)
319 self.assertEqual(p[layer].id, self.port_in)
320 self.assertEqual(data, p[Raw].load)
322 def reass_frags_and_verify(self, frags, src, dst):
325 self.assertEqual(p[IP].src, src)
326 self.assertEqual(p[IP].dst, dst)
327 self.assert_ip_checksum_valid(p)
328 buffer.seek(p[IP].frag * 8)
329 buffer.write(bytes(p[IP].payload))
330 ip = IP(src=frags[0][IP].src, dst=frags[0][IP].dst,
331 proto=frags[0][IP].proto)
332 if ip.proto == IP_PROTOS.tcp:
333 p = (ip / TCP(buffer.getvalue()))
334 self.logger.debug(ppp("Reassembled:", p))
335 self.assert_tcp_checksum_valid(p)
336 elif ip.proto == IP_PROTOS.udp:
337 p = (ip / UDP(buffer.getvalue()[:8]) /
338 Raw(buffer.getvalue()[8:]))
339 elif ip.proto == IP_PROTOS.icmp:
340 p = (ip / ICMP(buffer.getvalue()))
343 def frag_in_order(self, proto=IP_PROTOS.tcp, dont_translate=False,
345 layer = self.proto2layer(proto)
347 if proto == IP_PROTOS.tcp:
348 data = b"A" * 4 + b"B" * 16 + b"C" * 3
350 data = b"A" * 16 + b"B" * 16 + b"C" * 3
351 self.port_in = self.random_port()
354 pkts = self.create_stream_frag(self.pg0, self.pg1.remote_ip4,
355 self.port_in, 20, data, proto)
356 self.pg0.add_stream(pkts)
357 self.pg_enable_capture(self.pg_interfaces)
359 frags = self.pg1.get_capture(len(pkts))
360 if not dont_translate:
361 p = self.reass_frags_and_verify(frags,
365 p = self.reass_frags_and_verify(frags,
368 if proto != IP_PROTOS.icmp:
369 if not dont_translate:
370 self.assertEqual(p[layer].dport, 20)
372 self.assertNotEqual(p[layer].sport, self.port_in)
374 self.assertEqual(p[layer].sport, self.port_in)
377 if not dont_translate:
378 self.assertNotEqual(p[layer].id, self.port_in)
380 self.assertEqual(p[layer].id, self.port_in)
381 self.assertEqual(data, p[Raw].load)
384 if not dont_translate:
385 dst_addr = self.nat_addr
387 dst_addr = self.pg0.remote_ip4
388 if proto != IP_PROTOS.icmp:
390 dport = p[layer].sport
394 pkts = self.create_stream_frag(self.pg1, dst_addr, sport, dport, data,
395 proto, echo_reply=True)
396 self.pg1.add_stream(pkts)
397 self.pg_enable_capture(self.pg_interfaces)
399 frags = self.pg0.get_capture(len(pkts))
400 p = self.reass_frags_and_verify(frags,
403 if proto != IP_PROTOS.icmp:
404 self.assertEqual(p[layer].sport, 20)
405 self.assertEqual(p[layer].dport, self.port_in)
407 self.assertEqual(p[layer].id, self.port_in)
408 self.assertEqual(data, p[Raw].load)
410 def verify_capture_out(self, capture, nat_ip=None, same_port=False,
411 dst_ip=None, ignore_port=False):
413 nat_ip = self.nat_addr
414 for packet in capture:
416 self.assert_packet_checksums_valid(packet)
417 self.assertEqual(packet[IP].src, nat_ip)
418 if dst_ip is not None:
419 self.assertEqual(packet[IP].dst, dst_ip)
420 if packet.haslayer(TCP):
424 packet[TCP].sport, self.tcp_port_in)
427 packet[TCP].sport, self.tcp_port_in)
428 self.tcp_port_out = packet[TCP].sport
429 self.assert_packet_checksums_valid(packet)
430 elif packet.haslayer(UDP):
434 packet[UDP].sport, self.udp_port_in)
437 packet[UDP].sport, self.udp_port_in)
438 self.udp_port_out = packet[UDP].sport
443 packet[ICMP].id, self.icmp_id_in)
446 packet[ICMP].id, self.icmp_id_in)
447 self.icmp_id_out = packet[ICMP].id
448 self.assert_packet_checksums_valid(packet)
450 self.logger.error(ppp("Unexpected or invalid packet "
451 "(outside network):", packet))
454 def verify_capture_in(self, capture, in_if):
455 for packet in capture:
457 self.assert_packet_checksums_valid(packet)
458 self.assertEqual(packet[IP].dst, in_if.remote_ip4)
459 if packet.haslayer(TCP):
460 self.assertEqual(packet[TCP].dport, self.tcp_port_in)
461 elif packet.haslayer(UDP):
462 self.assertEqual(packet[UDP].dport, self.udp_port_in)
464 self.assertEqual(packet[ICMP].id, self.icmp_id_in)
466 self.logger.error(ppp("Unexpected or invalid packet "
467 "(inside network):", packet))
470 def create_stream_in(self, in_if, out_if, dst_ip=None, ttl=64):
472 dst_ip = out_if.remote_ip4
476 p = (Ether(dst=in_if.local_mac, src=in_if.remote_mac) /
477 IP(src=in_if.remote_ip4, dst=dst_ip, ttl=ttl) /
478 TCP(sport=self.tcp_port_in, dport=20))
482 p = (Ether(dst=in_if.local_mac, src=in_if.remote_mac) /
483 IP(src=in_if.remote_ip4, dst=dst_ip, ttl=ttl) /
484 UDP(sport=self.udp_port_in, dport=20))
488 p = (Ether(dst=in_if.local_mac, src=in_if.remote_mac) /
489 IP(src=in_if.remote_ip4, dst=dst_ip, ttl=ttl) /
490 ICMP(id=self.icmp_id_in, type='echo-request'))
495 def create_stream_out(self, out_if, dst_ip=None, ttl=64,
496 use_inside_ports=False):
498 dst_ip = self.nat_addr
499 if not use_inside_ports:
500 tcp_port = self.tcp_port_out
501 udp_port = self.udp_port_out
502 icmp_id = self.icmp_id_out
504 tcp_port = self.tcp_port_in
505 udp_port = self.udp_port_in
506 icmp_id = self.icmp_id_in
509 p = (Ether(dst=out_if.local_mac, src=out_if.remote_mac) /
510 IP(src=out_if.remote_ip4, dst=dst_ip, ttl=ttl) /
511 TCP(dport=tcp_port, sport=20))
515 p = (Ether(dst=out_if.local_mac, src=out_if.remote_mac) /
516 IP(src=out_if.remote_ip4, dst=dst_ip, ttl=ttl) /
517 UDP(dport=udp_port, sport=20))
521 p = (Ether(dst=out_if.local_mac, src=out_if.remote_mac) /
522 IP(src=out_if.remote_ip4, dst=dst_ip, ttl=ttl) /
523 ICMP(id=icmp_id, type='echo-reply'))
528 def create_tcp_stream(self, in_if, out_if, count):
532 for i in range(count):
533 p = (Ether(dst=in_if.local_mac, src=in_if.remote_mac) /
534 IP(src=in_if.remote_ip4, dst=out_if.remote_ip4, ttl=64) /
535 TCP(sport=port + i, dport=20))
540 def create_stream_frag(self, src_if, dst, sport, dport, data,
541 proto=IP_PROTOS.tcp, echo_reply=False):
542 if proto == IP_PROTOS.tcp:
543 p = (IP(src=src_if.remote_ip4, dst=dst) /
544 TCP(sport=sport, dport=dport) /
546 p = p.__class__(scapy.compat.raw(p))
547 chksum = p[TCP].chksum
548 proto_header = TCP(sport=sport, dport=dport, chksum=chksum)
549 elif proto == IP_PROTOS.udp:
550 proto_header = UDP(sport=sport, dport=dport)
551 elif proto == IP_PROTOS.icmp:
553 proto_header = ICMP(id=sport, type='echo-request')
555 proto_header = ICMP(id=sport, type='echo-reply')
557 raise Exception("Unsupported protocol")
558 id = self.random_port()
560 if proto == IP_PROTOS.tcp:
563 raw = Raw(data[0:16])
564 p = (Ether(src=src_if.remote_mac, dst=src_if.local_mac) /
565 IP(src=src_if.remote_ip4, dst=dst, flags="MF", frag=0, id=id) /
569 if proto == IP_PROTOS.tcp:
570 raw = Raw(data[4:20])
572 raw = Raw(data[16:32])
573 p = (Ether(src=src_if.remote_mac, dst=src_if.local_mac) /
574 IP(src=src_if.remote_ip4, dst=dst, flags="MF", frag=3, id=id,
578 if proto == IP_PROTOS.tcp:
582 p = (Ether(src=src_if.remote_mac, dst=src_if.local_mac) /
583 IP(src=src_if.remote_ip4, dst=dst, frag=5, proto=proto,
589 def frag_in_order_in_plus_out(self, in_addr, out_addr, in_port, out_port,
590 proto=IP_PROTOS.tcp):
592 layer = self.proto2layer(proto)
594 if proto == IP_PROTOS.tcp:
595 data = b"A" * 4 + b"B" * 16 + b"C" * 3
597 data = b"A" * 16 + b"B" * 16 + b"C" * 3
598 port_in = self.random_port()
602 pkts = self.create_stream_frag(self.pg0, out_addr,
605 self.pg0.add_stream(pkts)
606 self.pg_enable_capture(self.pg_interfaces)
608 frags = self.pg1.get_capture(len(pkts))
609 p = self.reass_frags_and_verify(frags,
612 if proto != IP_PROTOS.icmp:
613 self.assertEqual(p[layer].sport, port_in)
614 self.assertEqual(p[layer].dport, in_port)
616 self.assertEqual(p[layer].id, port_in)
617 self.assertEqual(data, p[Raw].load)
620 if proto != IP_PROTOS.icmp:
621 pkts = self.create_stream_frag(self.pg1, self.pg0.remote_ip4,
623 p[layer].sport, data, proto)
625 pkts = self.create_stream_frag(self.pg1, self.pg0.remote_ip4,
626 p[layer].id, 0, data, proto,
628 self.pg1.add_stream(pkts)
629 self.pg_enable_capture(self.pg_interfaces)
631 frags = self.pg0.get_capture(len(pkts))
632 p = self.reass_frags_and_verify(frags,
635 if proto != IP_PROTOS.icmp:
636 self.assertEqual(p[layer].sport, out_port)
637 self.assertEqual(p[layer].dport, port_in)
639 self.assertEqual(p[layer].id, port_in)
640 self.assertEqual(data, p[Raw].load)
642 def frag_out_of_order_in_plus_out(self, in_addr, out_addr, in_port,
643 out_port, proto=IP_PROTOS.tcp):
645 layer = self.proto2layer(proto)
647 if proto == IP_PROTOS.tcp:
648 data = b"A" * 4 + b"B" * 16 + b"C" * 3
650 data = b"A" * 16 + b"B" * 16 + b"C" * 3
651 port_in = self.random_port()
655 pkts = self.create_stream_frag(self.pg0, out_addr,
659 self.pg0.add_stream(pkts)
660 self.pg_enable_capture(self.pg_interfaces)
662 frags = self.pg1.get_capture(len(pkts))
663 p = self.reass_frags_and_verify(frags,
666 if proto != IP_PROTOS.icmp:
667 self.assertEqual(p[layer].dport, in_port)
668 self.assertEqual(p[layer].sport, port_in)
669 self.assertEqual(p[layer].dport, in_port)
671 self.assertEqual(p[layer].id, port_in)
672 self.assertEqual(data, p[Raw].load)
675 if proto != IP_PROTOS.icmp:
676 pkts = self.create_stream_frag(self.pg1, self.pg0.remote_ip4,
678 p[layer].sport, data, proto)
680 pkts = self.create_stream_frag(self.pg1, self.pg0.remote_ip4,
681 p[layer].id, 0, data, proto,
684 self.pg1.add_stream(pkts)
685 self.pg_enable_capture(self.pg_interfaces)
687 frags = self.pg0.get_capture(len(pkts))
688 p = self.reass_frags_and_verify(frags,
691 if proto != IP_PROTOS.icmp:
692 self.assertEqual(p[layer].sport, out_port)
693 self.assertEqual(p[layer].dport, port_in)
695 self.assertEqual(p[layer].id, port_in)
696 self.assertEqual(data, p[Raw].load)
698 def init_tcp_session(self, in_if, out_if, in_port, ext_port):
700 p = (Ether(src=in_if.remote_mac, dst=in_if.local_mac) /
701 IP(src=in_if.remote_ip4, dst=out_if.remote_ip4) /
702 TCP(sport=in_port, dport=ext_port, flags="S"))
704 self.pg_enable_capture(self.pg_interfaces)
706 capture = out_if.get_capture(1)
708 out_port = p[TCP].sport
710 # SYN + ACK packet out->in
711 p = (Ether(src=out_if.remote_mac, dst=out_if.local_mac) /
712 IP(src=out_if.remote_ip4, dst=self.nat_addr) /
713 TCP(sport=ext_port, dport=out_port, flags="SA"))
715 self.pg_enable_capture(self.pg_interfaces)
720 p = (Ether(src=in_if.remote_mac, dst=in_if.local_mac) /
721 IP(src=in_if.remote_ip4, dst=out_if.remote_ip4) /
722 TCP(sport=in_port, dport=ext_port, flags="A"))
724 self.pg_enable_capture(self.pg_interfaces)
726 out_if.get_capture(1)
730 def twice_nat_common(self, self_twice_nat=False, same_pg=False, lb=False,
732 twice_nat_addr = '10.0.1.3'
740 port_in1 = port_in + 1
741 port_in2 = port_in + 2
746 server1 = self.pg0.remote_hosts[0]
747 server2 = self.pg0.remote_hosts[1]
759 eh_translate = ((not self_twice_nat) or (not lb and same_pg) or
762 self.nat_add_address(self.nat_addr)
763 self.nat_add_address(twice_nat_addr, twice_nat=1)
767 flags |= self.config_flags.NAT_IS_SELF_TWICE_NAT
769 flags |= self.config_flags.NAT_IS_TWICE_NAT
772 self.nat_add_static_mapping(pg0.remote_ip4, self.nat_addr,
777 locals = [{'addr': server1.ip4,
781 {'addr': server2.ip4,
785 out_addr = self.nat_addr
787 self.vapi.nat44_add_del_lb_static_mapping(is_add=1, flags=flags,
788 external_addr=out_addr,
789 external_port=port_out,
790 protocol=IP_PROTOS.tcp,
791 local_num=len(locals),
793 self.nat_add_inside_interface(pg0)
794 self.nat_add_outside_interface(pg1)
800 assert client_id is not None
802 client = self.pg0.remote_hosts[0]
804 client = self.pg0.remote_hosts[1]
806 client = pg1.remote_hosts[0]
807 p = (Ether(src=pg1.remote_mac, dst=pg1.local_mac) /
808 IP(src=client.ip4, dst=self.nat_addr) /
809 TCP(sport=eh_port_out, dport=port_out))
811 self.pg_enable_capture(self.pg_interfaces)
813 capture = pg0.get_capture(1)
819 if ip.dst == server1.ip4:
825 self.assertEqual(ip.dst, server.ip4)
827 self.assertIn(tcp.dport, [port_in1, port_in2])
829 self.assertEqual(tcp.dport, port_in)
831 self.assertEqual(ip.src, twice_nat_addr)
832 self.assertNotEqual(tcp.sport, eh_port_out)
834 self.assertEqual(ip.src, client.ip4)
835 self.assertEqual(tcp.sport, eh_port_out)
837 eh_port_in = tcp.sport
838 saved_port_in = tcp.dport
839 self.assert_packet_checksums_valid(p)
841 self.logger.error(ppp("Unexpected or invalid packet:", p))
844 p = (Ether(src=server.mac, dst=pg0.local_mac) /
845 IP(src=server.ip4, dst=eh_addr_in) /
846 TCP(sport=saved_port_in, dport=eh_port_in))
848 self.pg_enable_capture(self.pg_interfaces)
850 capture = pg1.get_capture(1)
855 self.assertEqual(ip.dst, client.ip4)
856 self.assertEqual(ip.src, self.nat_addr)
857 self.assertEqual(tcp.dport, eh_port_out)
858 self.assertEqual(tcp.sport, port_out)
859 self.assert_packet_checksums_valid(p)
861 self.logger.error(ppp("Unexpected or invalid packet:", p))
865 sessions = self.vapi.nat44_user_session_dump(server.ip4, 0)
866 self.assertEqual(len(sessions), 1)
867 self.assertTrue(sessions[0].flags &
868 self.config_flags.NAT_IS_EXT_HOST_VALID)
869 self.assertTrue(sessions[0].flags &
870 self.config_flags.NAT_IS_TWICE_NAT)
871 self.logger.info(self.vapi.cli("show nat44 sessions"))
872 self.vapi.nat44_del_session(
873 address=sessions[0].inside_ip_address,
874 port=sessions[0].inside_port,
875 protocol=sessions[0].protocol,
876 flags=(self.config_flags.NAT_IS_INSIDE |
877 self.config_flags.NAT_IS_EXT_HOST_VALID),
878 ext_host_address=sessions[0].ext_host_nat_address,
879 ext_host_port=sessions[0].ext_host_nat_port)
880 sessions = self.vapi.nat44_user_session_dump(server.ip4, 0)
881 self.assertEqual(len(sessions), 0)
883 def verify_syslog_sess(self, data, is_add=True, is_ip6=False):
884 message = data.decode('utf-8')
886 message = SyslogMessage.parse(message)
887 except ParseError as e:
891 self.assertEqual(message.severity, SyslogSeverity.info)
892 self.assertEqual(message.appname, 'NAT')
893 self.assertEqual(message.msgid, 'SADD' if is_add else 'SDEL')
894 sd_params = message.sd.get('nsess')
895 self.assertTrue(sd_params is not None)
897 self.assertEqual(sd_params.get('IATYP'), 'IPv6')
898 self.assertEqual(sd_params.get('ISADDR'), self.pg0.remote_ip6)
900 self.assertEqual(sd_params.get('IATYP'), 'IPv4')
901 self.assertEqual(sd_params.get('ISADDR'), self.pg0.remote_ip4)
902 self.assertTrue(sd_params.get('SSUBIX') is not None)
903 self.assertEqual(sd_params.get('ISPORT'), "%d" % self.tcp_port_in)
904 self.assertEqual(sd_params.get('XATYP'), 'IPv4')
905 self.assertEqual(sd_params.get('XSADDR'), self.nat_addr)
906 self.assertEqual(sd_params.get('XSPORT'), "%d" % self.tcp_port_out)
907 self.assertEqual(sd_params.get('PROTO'), "%d" % IP_PROTOS.tcp)
908 self.assertEqual(sd_params.get('SVLAN'), '0')
909 self.assertEqual(sd_params.get('XDADDR'), self.pg1.remote_ip4)
910 self.assertEqual(sd_params.get('XDPORT'),
911 "%d" % self.tcp_external_port)
914 class TestNAT44ED(NAT44EDTestCase):
915 """ NAT44ED Test Case """
917 def test_icmp_error(self):
918 """ NAT44ED test ICMP error message with inner header"""
922 self.nat_add_address(self.nat_addr)
923 self.nat_add_inside_interface(self.pg0)
924 self.nat_add_outside_interface(self.pg1)
926 # in2out (initiate connection)
927 p1 = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
928 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
929 UDP(sport=21, dport=20) / payload)
931 self.pg0.add_stream(p1)
932 self.pg_enable_capture(self.pg_interfaces)
934 capture = self.pg1.get_capture(1)[0]
936 # out2in (send error message)
937 p2 = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
938 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
939 ICMP(type='dest-unreach', code='port-unreachable') /
942 self.pg1.add_stream(p2)
943 self.pg_enable_capture(self.pg_interfaces)
946 capture = self.pg0.get_capture(1)[0]
948 self.logger.info(ppp("p1 packet:", p1))
949 self.logger.info(ppp("p2 packet:", p2))
950 self.logger.info(ppp("capture packet:", capture))
952 def test_users_dump(self):
953 """ NAT44ED API test - nat44_user_dump """
955 self.nat_add_address(self.nat_addr)
956 self.nat_add_inside_interface(self.pg0)
957 self.nat_add_outside_interface(self.pg1)
959 self.vapi.nat44_forwarding_enable_disable(enable=1)
961 local_ip = self.pg0.remote_ip4
962 external_ip = self.nat_addr
963 self.nat_add_static_mapping(local_ip, external_ip)
965 users = self.vapi.nat44_user_dump()
966 self.assertEqual(len(users), 0)
968 # in2out - static mapping match
970 pkts = self.create_stream_out(self.pg1)
971 self.pg1.add_stream(pkts)
972 self.pg_enable_capture(self.pg_interfaces)
974 capture = self.pg0.get_capture(len(pkts))
975 self.verify_capture_in(capture, self.pg0)
977 pkts = self.create_stream_in(self.pg0, self.pg1)
978 self.pg0.add_stream(pkts)
979 self.pg_enable_capture(self.pg_interfaces)
981 capture = self.pg1.get_capture(len(pkts))
982 self.verify_capture_out(capture, same_port=True)
984 users = self.vapi.nat44_user_dump()
985 self.assertEqual(len(users), 1)
986 static_user = users[0]
987 self.assertEqual(static_user.nstaticsessions, 3)
988 self.assertEqual(static_user.nsessions, 0)
990 # in2out - no static mapping match (forwarding test)
992 host0 = self.pg0.remote_hosts[0]
993 self.pg0.remote_hosts[0] = self.pg0.remote_hosts[1]
995 pkts = self.create_stream_out(self.pg1,
996 dst_ip=self.pg0.remote_ip4,
997 use_inside_ports=True)
998 self.pg1.add_stream(pkts)
999 self.pg_enable_capture(self.pg_interfaces)
1001 capture = self.pg0.get_capture(len(pkts))
1002 self.verify_capture_in(capture, self.pg0)
1004 pkts = self.create_stream_in(self.pg0, self.pg1)
1005 self.pg0.add_stream(pkts)
1006 self.pg_enable_capture(self.pg_interfaces)
1008 capture = self.pg1.get_capture(len(pkts))
1009 self.verify_capture_out(capture, nat_ip=self.pg0.remote_ip4,
1012 self.pg0.remote_hosts[0] = host0
1014 users = self.vapi.nat44_user_dump()
1015 self.assertEqual(len(users), 2)
1016 if str(users[0].ip_address) == self.pg0.remote_hosts[0].ip4:
1017 non_static_user = users[1]
1018 static_user = users[0]
1020 non_static_user = users[0]
1021 static_user = users[1]
1022 self.assertEqual(static_user.nstaticsessions, 3)
1023 self.assertEqual(static_user.nsessions, 0)
1024 self.assertEqual(non_static_user.nstaticsessions, 0)
1025 self.assertEqual(non_static_user.nsessions, 3)
1027 users = self.vapi.nat44_user_dump()
1028 self.assertEqual(len(users), 2)
1029 if str(users[0].ip_address) == self.pg0.remote_hosts[0].ip4:
1030 non_static_user = users[1]
1031 static_user = users[0]
1033 non_static_user = users[0]
1034 static_user = users[1]
1035 self.assertEqual(static_user.nstaticsessions, 3)
1036 self.assertEqual(static_user.nsessions, 0)
1037 self.assertEqual(non_static_user.nstaticsessions, 0)
1038 self.assertEqual(non_static_user.nsessions, 3)
1040 def test_frag_out_of_order_do_not_translate(self):
1041 """ NAT44ED don't translate fragments arriving out of order """
1042 self.nat_add_inside_interface(self.pg0)
1043 self.nat_add_outside_interface(self.pg1)
1044 self.vapi.nat44_forwarding_enable_disable(enable=True)
1045 self.frag_out_of_order(proto=IP_PROTOS.tcp, dont_translate=True)
1047 def test_forwarding(self):
1048 """ NAT44ED forwarding test """
1050 self.nat_add_inside_interface(self.pg0)
1051 self.nat_add_outside_interface(self.pg1)
1052 self.vapi.nat44_forwarding_enable_disable(enable=1)
1054 real_ip = self.pg0.remote_ip4
1055 alias_ip = self.nat_addr
1056 flags = self.config_flags.NAT_IS_ADDR_ONLY
1057 self.vapi.nat44_add_del_static_mapping(is_add=1,
1058 local_ip_address=real_ip,
1059 external_ip_address=alias_ip,
1060 external_sw_if_index=0xFFFFFFFF,
1064 # in2out - static mapping match
1066 pkts = self.create_stream_out(self.pg1)
1067 self.pg1.add_stream(pkts)
1068 self.pg_enable_capture(self.pg_interfaces)
1070 capture = self.pg0.get_capture(len(pkts))
1071 self.verify_capture_in(capture, self.pg0)
1073 pkts = self.create_stream_in(self.pg0, self.pg1)
1074 self.pg0.add_stream(pkts)
1075 self.pg_enable_capture(self.pg_interfaces)
1077 capture = self.pg1.get_capture(len(pkts))
1078 self.verify_capture_out(capture, same_port=True)
1080 # in2out - no static mapping match
1082 host0 = self.pg0.remote_hosts[0]
1083 self.pg0.remote_hosts[0] = self.pg0.remote_hosts[1]
1085 pkts = self.create_stream_out(self.pg1,
1086 dst_ip=self.pg0.remote_ip4,
1087 use_inside_ports=True)
1088 self.pg1.add_stream(pkts)
1089 self.pg_enable_capture(self.pg_interfaces)
1091 capture = self.pg0.get_capture(len(pkts))
1092 self.verify_capture_in(capture, self.pg0)
1094 pkts = self.create_stream_in(self.pg0, self.pg1)
1095 self.pg0.add_stream(pkts)
1096 self.pg_enable_capture(self.pg_interfaces)
1098 capture = self.pg1.get_capture(len(pkts))
1099 self.verify_capture_out(capture, nat_ip=self.pg0.remote_ip4,
1102 self.pg0.remote_hosts[0] = host0
1104 user = self.pg0.remote_hosts[1]
1105 sessions = self.vapi.nat44_user_session_dump(user.ip4, 0)
1106 self.assertEqual(len(sessions), 3)
1107 self.assertTrue(sessions[0].flags &
1108 self.config_flags.NAT_IS_EXT_HOST_VALID)
1109 self.vapi.nat44_del_session(
1110 address=sessions[0].inside_ip_address,
1111 port=sessions[0].inside_port,
1112 protocol=sessions[0].protocol,
1113 flags=(self.config_flags.NAT_IS_INSIDE |
1114 self.config_flags.NAT_IS_EXT_HOST_VALID),
1115 ext_host_address=sessions[0].ext_host_address,
1116 ext_host_port=sessions[0].ext_host_port)
1117 sessions = self.vapi.nat44_user_session_dump(user.ip4, 0)
1118 self.assertEqual(len(sessions), 2)
1121 self.vapi.nat44_forwarding_enable_disable(enable=0)
1122 flags = self.config_flags.NAT_IS_ADDR_ONLY
1123 self.vapi.nat44_add_del_static_mapping(
1125 local_ip_address=real_ip,
1126 external_ip_address=alias_ip,
1127 external_sw_if_index=0xFFFFFFFF,
1130 def test_output_feature_and_service2(self):
1131 """ NAT44ED interface output feature and service host direct access """
1132 self.vapi.nat44_forwarding_enable_disable(enable=1)
1133 self.nat_add_address(self.nat_addr)
1135 self.vapi.nat44_interface_add_del_output_feature(
1136 sw_if_index=self.pg1.sw_if_index, is_add=1,)
1138 # session initiated from service host - translate
1139 pkts = self.create_stream_in(self.pg0, self.pg1)
1140 self.pg0.add_stream(pkts)
1141 self.pg_enable_capture(self.pg_interfaces)
1143 capture = self.pg1.get_capture(len(pkts))
1144 self.verify_capture_out(capture, ignore_port=True)
1146 pkts = self.create_stream_out(self.pg1)
1147 self.pg1.add_stream(pkts)
1148 self.pg_enable_capture(self.pg_interfaces)
1150 capture = self.pg0.get_capture(len(pkts))
1151 self.verify_capture_in(capture, self.pg0)
1153 # session initiated from remote host - do not translate
1154 tcp_port_in = self.tcp_port_in
1155 udp_port_in = self.udp_port_in
1156 icmp_id_in = self.icmp_id_in
1158 self.tcp_port_in = 60303
1159 self.udp_port_in = 60304
1160 self.icmp_id_in = 60305
1163 pkts = self.create_stream_out(self.pg1,
1164 self.pg0.remote_ip4,
1165 use_inside_ports=True)
1166 self.pg1.add_stream(pkts)
1167 self.pg_enable_capture(self.pg_interfaces)
1169 capture = self.pg0.get_capture(len(pkts))
1170 self.verify_capture_in(capture, self.pg0)
1172 pkts = self.create_stream_in(self.pg0, self.pg1)
1173 self.pg0.add_stream(pkts)
1174 self.pg_enable_capture(self.pg_interfaces)
1176 capture = self.pg1.get_capture(len(pkts))
1177 self.verify_capture_out(capture, nat_ip=self.pg0.remote_ip4,
1180 self.tcp_port_in = tcp_port_in
1181 self.udp_port_in = udp_port_in
1182 self.icmp_id_in = icmp_id_in
1184 def test_twice_nat(self):
1185 """ NAT44ED Twice NAT """
1186 self.twice_nat_common()
1188 def test_self_twice_nat_positive(self):
1189 """ NAT44ED Self Twice NAT (positive test) """
1190 self.twice_nat_common(self_twice_nat=True, same_pg=True)
1192 def test_self_twice_nat_lb_positive(self):
1193 """ NAT44ED Self Twice NAT local service load balancing (positive test)
1195 self.twice_nat_common(lb=True, self_twice_nat=True, same_pg=True,
1198 def test_twice_nat_lb(self):
1199 """ NAT44ED Twice NAT local service load balancing """
1200 self.twice_nat_common(lb=True)
1202 def test_output_feature(self):
1203 """ NAT44ED interface output feature (in2out postrouting) """
1204 self.vapi.nat44_forwarding_enable_disable(enable=1)
1205 self.nat_add_address(self.nat_addr)
1207 self.nat_add_outside_interface(self.pg0)
1208 self.vapi.nat44_interface_add_del_output_feature(
1209 sw_if_index=self.pg1.sw_if_index, is_add=1)
1212 pkts = self.create_stream_in(self.pg0, self.pg1)
1213 self.pg0.add_stream(pkts)
1214 self.pg_enable_capture(self.pg_interfaces)
1216 capture = self.pg1.get_capture(len(pkts))
1217 self.verify_capture_out(capture, ignore_port=True)
1220 pkts = self.create_stream_out(self.pg1)
1221 self.pg1.add_stream(pkts)
1222 self.pg_enable_capture(self.pg_interfaces)
1224 capture = self.pg0.get_capture(len(pkts))
1225 self.verify_capture_in(capture, self.pg0)
1228 pkts = self.create_stream_in(self.pg0, self.pg1, ttl=2)
1229 self.pg0.add_stream(pkts)
1230 self.pg_enable_capture(self.pg_interfaces)
1232 capture = self.pg1.get_capture(len(pkts))
1233 self.verify_capture_out(capture, ignore_port=True)
1236 pkts = self.create_stream_out(self.pg1, ttl=2)
1237 self.pg1.add_stream(pkts)
1238 self.pg_enable_capture(self.pg_interfaces)
1240 capture = self.pg0.get_capture(len(pkts))
1241 self.verify_capture_in(capture, self.pg0)
1244 pkts = self.create_stream_in(self.pg0, self.pg1, ttl=1)
1245 self.pg0.add_stream(pkts)
1246 self.pg_enable_capture(self.pg_interfaces)
1248 capture = self.pg0.get_capture(len(pkts))
1250 self.assertIn(ICMP, p)
1251 self.assertEqual(p[ICMP].type, 11) # 11 == time-exceeded
1253 def test_static_with_port_out2(self):
1254 """ NAT44ED 1:1 NAPT asymmetrical rule """
1259 self.vapi.nat44_forwarding_enable_disable(enable=1)
1260 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1261 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
1262 local_port, external_port,
1263 proto=IP_PROTOS.tcp, flags=flags)
1265 self.nat_add_inside_interface(self.pg0)
1266 self.nat_add_outside_interface(self.pg1)
1268 # from client to service
1269 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1270 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1271 TCP(sport=12345, dport=external_port))
1272 self.pg1.add_stream(p)
1273 self.pg_enable_capture(self.pg_interfaces)
1275 capture = self.pg0.get_capture(1)
1280 self.assertEqual(ip.dst, self.pg0.remote_ip4)
1281 self.assertEqual(tcp.dport, local_port)
1282 self.assert_packet_checksums_valid(p)
1284 self.logger.error(ppp("Unexpected or invalid packet:", p))
1288 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
1289 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
1290 ICMP(type=11) / capture[0][IP])
1291 self.pg0.add_stream(p)
1292 self.pg_enable_capture(self.pg_interfaces)
1294 capture = self.pg1.get_capture(1)
1297 self.assertEqual(p[IP].src, self.nat_addr)
1299 self.assertEqual(inner.dst, self.nat_addr)
1300 self.assertEqual(inner[TCPerror].dport, external_port)
1302 self.logger.error(ppp("Unexpected or invalid packet:", p))
1305 # from service back to client
1306 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1307 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
1308 TCP(sport=local_port, dport=12345))
1309 self.pg0.add_stream(p)
1310 self.pg_enable_capture(self.pg_interfaces)
1312 capture = self.pg1.get_capture(1)
1317 self.assertEqual(ip.src, self.nat_addr)
1318 self.assertEqual(tcp.sport, external_port)
1319 self.assert_packet_checksums_valid(p)
1321 self.logger.error(ppp("Unexpected or invalid packet:", p))
1325 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
1326 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1327 ICMP(type=11) / capture[0][IP])
1328 self.pg1.add_stream(p)
1329 self.pg_enable_capture(self.pg_interfaces)
1331 capture = self.pg0.get_capture(1)
1334 self.assertEqual(p[IP].dst, self.pg0.remote_ip4)
1336 self.assertEqual(inner.src, self.pg0.remote_ip4)
1337 self.assertEqual(inner[TCPerror].sport, local_port)
1339 self.logger.error(ppp("Unexpected or invalid packet:", p))
1342 # from client to server (no translation)
1343 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1344 IP(src=self.pg1.remote_ip4, dst=self.pg0.remote_ip4) /
1345 TCP(sport=12346, dport=local_port))
1346 self.pg1.add_stream(p)
1347 self.pg_enable_capture(self.pg_interfaces)
1349 capture = self.pg0.get_capture(1)
1354 self.assertEqual(ip.dst, self.pg0.remote_ip4)
1355 self.assertEqual(tcp.dport, local_port)
1356 self.assert_packet_checksums_valid(p)
1358 self.logger.error(ppp("Unexpected or invalid packet:", p))
1361 # from service back to client (no translation)
1362 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1363 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
1364 TCP(sport=local_port, dport=12346))
1365 self.pg0.add_stream(p)
1366 self.pg_enable_capture(self.pg_interfaces)
1368 capture = self.pg1.get_capture(1)
1373 self.assertEqual(ip.src, self.pg0.remote_ip4)
1374 self.assertEqual(tcp.sport, local_port)
1375 self.assert_packet_checksums_valid(p)
1377 self.logger.error(ppp("Unexpected or invalid packet:", p))
1380 def test_static_lb(self):
1381 """ NAT44ED local service load balancing """
1382 external_addr_n = self.nat_addr
1385 server1 = self.pg0.remote_hosts[0]
1386 server2 = self.pg0.remote_hosts[1]
1388 locals = [{'addr': server1.ip4,
1392 {'addr': server2.ip4,
1397 self.nat_add_address(self.nat_addr)
1398 self.vapi.nat44_add_del_lb_static_mapping(
1400 external_addr=external_addr_n,
1401 external_port=external_port,
1402 protocol=IP_PROTOS.tcp,
1403 local_num=len(locals),
1405 flags = self.config_flags.NAT_IS_INSIDE
1406 self.vapi.nat44_interface_add_del_feature(
1407 sw_if_index=self.pg0.sw_if_index,
1408 flags=flags, is_add=1)
1409 self.vapi.nat44_interface_add_del_feature(
1410 sw_if_index=self.pg1.sw_if_index,
1413 # from client to service
1414 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1415 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1416 TCP(sport=12345, dport=external_port))
1417 self.pg1.add_stream(p)
1418 self.pg_enable_capture(self.pg_interfaces)
1420 capture = self.pg0.get_capture(1)
1426 self.assertIn(ip.dst, [server1.ip4, server2.ip4])
1427 if ip.dst == server1.ip4:
1431 self.assertEqual(tcp.dport, local_port)
1432 self.assert_packet_checksums_valid(p)
1434 self.logger.error(ppp("Unexpected or invalid packet:", p))
1437 # from service back to client
1438 p = (Ether(src=server.mac, dst=self.pg0.local_mac) /
1439 IP(src=server.ip4, dst=self.pg1.remote_ip4) /
1440 TCP(sport=local_port, dport=12345))
1441 self.pg0.add_stream(p)
1442 self.pg_enable_capture(self.pg_interfaces)
1444 capture = self.pg1.get_capture(1)
1449 self.assertEqual(ip.src, self.nat_addr)
1450 self.assertEqual(tcp.sport, external_port)
1451 self.assert_packet_checksums_valid(p)
1453 self.logger.error(ppp("Unexpected or invalid packet:", p))
1456 sessions = self.vapi.nat44_user_session_dump(server.ip4, 0)
1457 self.assertEqual(len(sessions), 1)
1458 self.assertTrue(sessions[0].flags &
1459 self.config_flags.NAT_IS_EXT_HOST_VALID)
1460 self.vapi.nat44_del_session(
1461 address=sessions[0].inside_ip_address,
1462 port=sessions[0].inside_port,
1463 protocol=sessions[0].protocol,
1464 flags=(self.config_flags.NAT_IS_INSIDE |
1465 self.config_flags.NAT_IS_EXT_HOST_VALID),
1466 ext_host_address=sessions[0].ext_host_address,
1467 ext_host_port=sessions[0].ext_host_port)
1468 sessions = self.vapi.nat44_user_session_dump(server.ip4, 0)
1469 self.assertEqual(len(sessions), 0)
1471 def test_static_lb_2(self):
1472 """ NAT44ED local service load balancing (asymmetrical rule) """
1473 external_addr = self.nat_addr
1476 server1 = self.pg0.remote_hosts[0]
1477 server2 = self.pg0.remote_hosts[1]
1479 locals = [{'addr': server1.ip4,
1483 {'addr': server2.ip4,
1488 self.vapi.nat44_forwarding_enable_disable(enable=1)
1489 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1490 self.vapi.nat44_add_del_lb_static_mapping(is_add=1, flags=flags,
1491 external_addr=external_addr,
1492 external_port=external_port,
1493 protocol=IP_PROTOS.tcp,
1494 local_num=len(locals),
1496 flags = self.config_flags.NAT_IS_INSIDE
1497 self.vapi.nat44_interface_add_del_feature(
1498 sw_if_index=self.pg0.sw_if_index,
1499 flags=flags, is_add=1)
1500 self.vapi.nat44_interface_add_del_feature(
1501 sw_if_index=self.pg1.sw_if_index,
1504 # from client to service
1505 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1506 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1507 TCP(sport=12345, dport=external_port))
1508 self.pg1.add_stream(p)
1509 self.pg_enable_capture(self.pg_interfaces)
1511 capture = self.pg0.get_capture(1)
1517 self.assertIn(ip.dst, [server1.ip4, server2.ip4])
1518 if ip.dst == server1.ip4:
1522 self.assertEqual(tcp.dport, local_port)
1523 self.assert_packet_checksums_valid(p)
1525 self.logger.error(ppp("Unexpected or invalid packet:", p))
1528 # from service back to client
1529 p = (Ether(src=server.mac, dst=self.pg0.local_mac) /
1530 IP(src=server.ip4, dst=self.pg1.remote_ip4) /
1531 TCP(sport=local_port, dport=12345))
1532 self.pg0.add_stream(p)
1533 self.pg_enable_capture(self.pg_interfaces)
1535 capture = self.pg1.get_capture(1)
1540 self.assertEqual(ip.src, self.nat_addr)
1541 self.assertEqual(tcp.sport, external_port)
1542 self.assert_packet_checksums_valid(p)
1544 self.logger.error(ppp("Unexpected or invalid packet:", p))
1547 # from client to server (no translation)
1548 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1549 IP(src=self.pg1.remote_ip4, dst=server1.ip4) /
1550 TCP(sport=12346, dport=local_port))
1551 self.pg1.add_stream(p)
1552 self.pg_enable_capture(self.pg_interfaces)
1554 capture = self.pg0.get_capture(1)
1560 self.assertEqual(ip.dst, server1.ip4)
1561 self.assertEqual(tcp.dport, local_port)
1562 self.assert_packet_checksums_valid(p)
1564 self.logger.error(ppp("Unexpected or invalid packet:", p))
1567 # from service back to client (no translation)
1568 p = (Ether(src=server1.mac, dst=self.pg0.local_mac) /
1569 IP(src=server1.ip4, dst=self.pg1.remote_ip4) /
1570 TCP(sport=local_port, dport=12346))
1571 self.pg0.add_stream(p)
1572 self.pg_enable_capture(self.pg_interfaces)
1574 capture = self.pg1.get_capture(1)
1579 self.assertEqual(ip.src, server1.ip4)
1580 self.assertEqual(tcp.sport, local_port)
1581 self.assert_packet_checksums_valid(p)
1583 self.logger.error(ppp("Unexpected or invalid packet:", p))
1586 def test_lb_affinity(self):
1587 """ NAT44ED local service load balancing affinity """
1588 external_addr = self.nat_addr
1591 server1 = self.pg0.remote_hosts[0]
1592 server2 = self.pg0.remote_hosts[1]
1594 locals = [{'addr': server1.ip4,
1598 {'addr': server2.ip4,
1603 self.nat_add_address(self.nat_addr)
1604 self.vapi.nat44_add_del_lb_static_mapping(is_add=1,
1605 external_addr=external_addr,
1606 external_port=external_port,
1607 protocol=IP_PROTOS.tcp,
1609 local_num=len(locals),
1611 flags = self.config_flags.NAT_IS_INSIDE
1612 self.vapi.nat44_interface_add_del_feature(
1613 sw_if_index=self.pg0.sw_if_index,
1614 flags=flags, is_add=1)
1615 self.vapi.nat44_interface_add_del_feature(
1616 sw_if_index=self.pg1.sw_if_index,
1619 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
1620 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1621 TCP(sport=1025, dport=external_port))
1622 self.pg1.add_stream(p)
1623 self.pg_enable_capture(self.pg_interfaces)
1625 capture = self.pg0.get_capture(1)
1626 backend = capture[0][IP].dst
1628 sessions = self.vapi.nat44_user_session_dump(backend, 0)
1629 self.assertEqual(len(sessions), 1)
1630 self.assertTrue(sessions[0].flags &
1631 self.config_flags.NAT_IS_EXT_HOST_VALID)
1632 self.vapi.nat44_del_session(
1633 address=sessions[0].inside_ip_address,
1634 port=sessions[0].inside_port,
1635 protocol=sessions[0].protocol,
1636 flags=(self.config_flags.NAT_IS_INSIDE |
1637 self.config_flags.NAT_IS_EXT_HOST_VALID),
1638 ext_host_address=sessions[0].ext_host_address,
1639 ext_host_port=sessions[0].ext_host_port)
1642 for port in range(1030, 1100):
1643 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
1644 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1645 TCP(sport=port, dport=external_port))
1647 self.pg1.add_stream(pkts)
1648 self.pg_enable_capture(self.pg_interfaces)
1650 capture = self.pg0.get_capture(len(pkts))
1652 self.assertEqual(p[IP].dst, backend)
1654 def test_multiple_vrf_1(self):
1655 """ Multiple VRF - both client & service in VRF1 """
1657 external_addr = '1.2.3.4'
1662 flags = self.config_flags.NAT_IS_INSIDE
1663 self.vapi.nat44_interface_add_del_feature(
1664 sw_if_index=self.pg5.sw_if_index,
1666 self.vapi.nat44_interface_add_del_feature(
1667 sw_if_index=self.pg5.sw_if_index,
1668 is_add=1, flags=flags)
1669 self.vapi.nat44_interface_add_del_feature(
1670 sw_if_index=self.pg6.sw_if_index,
1672 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1673 self.nat_add_static_mapping(self.pg5.remote_ip4, external_addr,
1674 local_port, external_port, vrf_id=1,
1675 proto=IP_PROTOS.tcp, flags=flags)
1677 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
1678 IP(src=self.pg6.remote_ip4, dst=external_addr) /
1679 TCP(sport=12345, dport=external_port))
1680 self.pg6.add_stream(p)
1681 self.pg_enable_capture(self.pg_interfaces)
1683 capture = self.pg5.get_capture(1)
1688 self.assertEqual(ip.dst, self.pg5.remote_ip4)
1689 self.assertEqual(tcp.dport, local_port)
1690 self.assert_packet_checksums_valid(p)
1692 self.logger.error(ppp("Unexpected or invalid packet:", p))
1695 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
1696 IP(src=self.pg5.remote_ip4, dst=self.pg6.remote_ip4) /
1697 TCP(sport=local_port, dport=12345))
1698 self.pg5.add_stream(p)
1699 self.pg_enable_capture(self.pg_interfaces)
1701 capture = self.pg6.get_capture(1)
1706 self.assertEqual(ip.src, external_addr)
1707 self.assertEqual(tcp.sport, external_port)
1708 self.assert_packet_checksums_valid(p)
1710 self.logger.error(ppp("Unexpected or invalid packet:", p))
1713 def test_multiple_vrf_2(self):
1714 """ Multiple VRF - dynamic NAT from VRF1 to VRF0 (output-feature) """
1716 external_addr = '1.2.3.4'
1721 self.nat_add_address(self.nat_addr)
1722 flags = self.config_flags.NAT_IS_INSIDE
1723 self.vapi.nat44_interface_add_del_output_feature(
1724 sw_if_index=self.pg1.sw_if_index,
1726 self.vapi.nat44_interface_add_del_feature(
1727 sw_if_index=self.pg5.sw_if_index,
1729 self.vapi.nat44_interface_add_del_feature(
1730 sw_if_index=self.pg5.sw_if_index,
1731 is_add=1, flags=flags)
1732 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1733 self.nat_add_static_mapping(self.pg5.remote_ip4, external_addr,
1734 local_port, external_port, vrf_id=1,
1735 proto=IP_PROTOS.tcp, flags=flags)
1737 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
1738 IP(src=self.pg5.remote_ip4, dst=self.pg1.remote_ip4) /
1739 TCP(sport=2345, dport=22))
1740 self.pg5.add_stream(p)
1741 self.pg_enable_capture(self.pg_interfaces)
1743 capture = self.pg1.get_capture(1)
1748 self.assertEqual(ip.src, self.nat_addr)
1749 self.assert_packet_checksums_valid(p)
1752 self.logger.error(ppp("Unexpected or invalid packet:", p))
1755 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
1756 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
1757 TCP(sport=22, dport=port))
1758 self.pg1.add_stream(p)
1759 self.pg_enable_capture(self.pg_interfaces)
1761 capture = self.pg5.get_capture(1)
1766 self.assertEqual(ip.dst, self.pg5.remote_ip4)
1767 self.assertEqual(tcp.dport, 2345)
1768 self.assert_packet_checksums_valid(p)
1770 self.logger.error(ppp("Unexpected or invalid packet:", p))
1773 def test_multiple_vrf_3(self):
1774 """ Multiple VRF - client in VRF1, service in VRF0 """
1776 external_addr = '1.2.3.4'
1781 flags = self.config_flags.NAT_IS_INSIDE
1782 self.vapi.nat44_interface_add_del_feature(
1783 sw_if_index=self.pg0.sw_if_index,
1785 self.vapi.nat44_interface_add_del_feature(
1786 sw_if_index=self.pg0.sw_if_index,
1787 is_add=1, flags=flags)
1788 self.vapi.nat44_interface_add_del_feature(
1789 sw_if_index=self.pg6.sw_if_index,
1791 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1792 self.nat_add_static_mapping(
1793 self.pg0.remote_ip4,
1794 external_sw_if_index=self.pg0.sw_if_index,
1795 local_port=local_port,
1797 external_port=external_port,
1798 proto=IP_PROTOS.tcp,
1802 # from client VRF1 to service VRF0
1803 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
1804 IP(src=self.pg6.remote_ip4, dst=self.pg0.local_ip4) /
1805 TCP(sport=12346, dport=external_port))
1806 self.pg6.add_stream(p)
1807 self.pg_enable_capture(self.pg_interfaces)
1809 capture = self.pg0.get_capture(1)
1814 self.assertEqual(ip.dst, self.pg0.remote_ip4)
1815 self.assertEqual(tcp.dport, local_port)
1816 self.assert_packet_checksums_valid(p)
1818 self.logger.error(ppp("Unexpected or invalid packet:", p))
1821 # from service VRF0 back to client VRF1
1822 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1823 IP(src=self.pg0.remote_ip4, dst=self.pg6.remote_ip4) /
1824 TCP(sport=local_port, dport=12346))
1825 self.pg0.add_stream(p)
1826 self.pg_enable_capture(self.pg_interfaces)
1828 capture = self.pg6.get_capture(1)
1833 self.assertEqual(ip.src, self.pg0.local_ip4)
1834 self.assertEqual(tcp.sport, external_port)
1835 self.assert_packet_checksums_valid(p)
1837 self.logger.error(ppp("Unexpected or invalid packet:", p))
1840 def test_multiple_vrf_4(self):
1841 """ Multiple VRF - client in VRF0, service in VRF1 """
1843 external_addr = '1.2.3.4'
1848 flags = self.config_flags.NAT_IS_INSIDE
1849 self.vapi.nat44_interface_add_del_feature(
1850 sw_if_index=self.pg0.sw_if_index,
1852 self.vapi.nat44_interface_add_del_feature(
1853 sw_if_index=self.pg0.sw_if_index,
1854 is_add=1, flags=flags)
1855 self.vapi.nat44_interface_add_del_feature(
1856 sw_if_index=self.pg5.sw_if_index,
1858 self.vapi.nat44_interface_add_del_feature(
1859 sw_if_index=self.pg5.sw_if_index,
1860 is_add=1, flags=flags)
1861 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1862 self.nat_add_static_mapping(self.pg5.remote_ip4, external_addr,
1863 local_port, external_port, vrf_id=1,
1864 proto=IP_PROTOS.tcp, flags=flags)
1866 # from client VRF0 to service VRF1
1867 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1868 IP(src=self.pg0.remote_ip4, dst=external_addr) /
1869 TCP(sport=12347, dport=external_port))
1870 self.pg0.add_stream(p)
1871 self.pg_enable_capture(self.pg_interfaces)
1873 capture = self.pg5.get_capture(1)
1878 self.assertEqual(ip.dst, self.pg5.remote_ip4)
1879 self.assertEqual(tcp.dport, local_port)
1880 self.assert_packet_checksums_valid(p)
1882 self.logger.error(ppp("Unexpected or invalid packet:", p))
1885 # from service VRF1 back to client VRF0
1886 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
1887 IP(src=self.pg5.remote_ip4, dst=self.pg0.remote_ip4) /
1888 TCP(sport=local_port, dport=12347))
1889 self.pg5.add_stream(p)
1890 self.pg_enable_capture(self.pg_interfaces)
1892 capture = self.pg0.get_capture(1)
1897 self.assertEqual(ip.src, external_addr)
1898 self.assertEqual(tcp.sport, external_port)
1899 self.assert_packet_checksums_valid(p)
1901 self.logger.error(ppp("Unexpected or invalid packet:", p))
1904 def test_multiple_vrf_5(self):
1905 """ Multiple VRF - forwarding - no translation """
1907 external_addr = '1.2.3.4'
1912 self.vapi.nat44_forwarding_enable_disable(enable=1)
1913 flags = self.config_flags.NAT_IS_INSIDE
1914 self.vapi.nat44_interface_add_del_feature(
1915 sw_if_index=self.pg0.sw_if_index,
1917 self.vapi.nat44_interface_add_del_feature(
1918 sw_if_index=self.pg0.sw_if_index,
1919 is_add=1, flags=flags)
1920 self.vapi.nat44_interface_add_del_feature(
1921 sw_if_index=self.pg5.sw_if_index,
1923 self.vapi.nat44_interface_add_del_feature(
1924 sw_if_index=self.pg5.sw_if_index,
1925 is_add=1, flags=flags)
1926 self.vapi.nat44_interface_add_del_feature(
1927 sw_if_index=self.pg6.sw_if_index,
1929 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
1930 self.nat_add_static_mapping(self.pg5.remote_ip4, external_addr,
1931 local_port, external_port, vrf_id=1,
1932 proto=IP_PROTOS.tcp, flags=flags)
1933 self.nat_add_static_mapping(
1934 self.pg0.remote_ip4,
1935 external_sw_if_index=self.pg0.sw_if_index,
1936 local_port=local_port,
1938 external_port=external_port,
1939 proto=IP_PROTOS.tcp,
1943 # from client to server (both VRF1, no translation)
1944 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
1945 IP(src=self.pg6.remote_ip4, dst=self.pg5.remote_ip4) /
1946 TCP(sport=12348, dport=local_port))
1947 self.pg6.add_stream(p)
1948 self.pg_enable_capture(self.pg_interfaces)
1950 capture = self.pg5.get_capture(1)
1955 self.assertEqual(ip.dst, self.pg5.remote_ip4)
1956 self.assertEqual(tcp.dport, local_port)
1957 self.assert_packet_checksums_valid(p)
1959 self.logger.error(ppp("Unexpected or invalid packet:", p))
1962 # from server back to client (both VRF1, no translation)
1963 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
1964 IP(src=self.pg5.remote_ip4, dst=self.pg6.remote_ip4) /
1965 TCP(sport=local_port, dport=12348))
1966 self.pg5.add_stream(p)
1967 self.pg_enable_capture(self.pg_interfaces)
1969 capture = self.pg6.get_capture(1)
1974 self.assertEqual(ip.src, self.pg5.remote_ip4)
1975 self.assertEqual(tcp.sport, local_port)
1976 self.assert_packet_checksums_valid(p)
1978 self.logger.error(ppp("Unexpected or invalid packet:", p))
1981 # from client VRF1 to server VRF0 (no translation)
1982 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
1983 IP(src=self.pg0.remote_ip4, dst=self.pg6.remote_ip4) /
1984 TCP(sport=local_port, dport=12349))
1985 self.pg0.add_stream(p)
1986 self.pg_enable_capture(self.pg_interfaces)
1988 capture = self.pg6.get_capture(1)
1993 self.assertEqual(ip.src, self.pg0.remote_ip4)
1994 self.assertEqual(tcp.sport, local_port)
1995 self.assert_packet_checksums_valid(p)
1997 self.logger.error(ppp("Unexpected or invalid packet:", p))
2000 # from server VRF0 back to client VRF1 (no translation)
2001 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2002 IP(src=self.pg0.remote_ip4, dst=self.pg6.remote_ip4) /
2003 TCP(sport=local_port, dport=12349))
2004 self.pg0.add_stream(p)
2005 self.pg_enable_capture(self.pg_interfaces)
2007 capture = self.pg6.get_capture(1)
2012 self.assertEqual(ip.src, self.pg0.remote_ip4)
2013 self.assertEqual(tcp.sport, local_port)
2014 self.assert_packet_checksums_valid(p)
2016 self.logger.error(ppp("Unexpected or invalid packet:", p))
2019 # from client VRF0 to server VRF1 (no translation)
2020 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2021 IP(src=self.pg0.remote_ip4, dst=self.pg5.remote_ip4) /
2022 TCP(sport=12344, dport=local_port))
2023 self.pg0.add_stream(p)
2024 self.pg_enable_capture(self.pg_interfaces)
2026 capture = self.pg5.get_capture(1)
2031 self.assertEqual(ip.dst, self.pg5.remote_ip4)
2032 self.assertEqual(tcp.dport, local_port)
2033 self.assert_packet_checksums_valid(p)
2035 self.logger.error(ppp("Unexpected or invalid packet:", p))
2038 # from server VRF1 back to client VRF0 (no translation)
2039 p = (Ether(src=self.pg5.remote_mac, dst=self.pg5.local_mac) /
2040 IP(src=self.pg5.remote_ip4, dst=self.pg0.remote_ip4) /
2041 TCP(sport=local_port, dport=12344))
2042 self.pg5.add_stream(p)
2043 self.pg_enable_capture(self.pg_interfaces)
2045 capture = self.pg0.get_capture(1)
2050 self.assertEqual(ip.src, self.pg5.remote_ip4)
2051 self.assertEqual(tcp.sport, local_port)
2052 self.assert_packet_checksums_valid(p)
2054 self.logger.error(ppp("Unexpected or invalid packet:", p))
2057 def test_outside_address_distribution(self):
2058 """ Outside address distribution based on source address """
2063 for i in range(1, x):
2065 nat_addresses.append(a)
2067 self.nat_add_inside_interface(self.pg0)
2068 self.nat_add_outside_interface(self.pg1)
2070 self.vapi.nat44_add_del_address_range(
2071 first_ip_address=nat_addresses[0],
2072 last_ip_address=nat_addresses[-1],
2073 vrf_id=0xFFFFFFFF, is_add=1, flags=0)
2075 self.pg0.generate_remote_hosts(x)
2079 info = self.create_packet_info(self.pg0, self.pg1)
2080 payload = self.info_to_payload(info)
2081 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2082 IP(src=self.pg0.remote_hosts[i].ip4,
2083 dst=self.pg1.remote_ip4) /
2084 UDP(sport=7000+i, dport=8000+i) /
2089 self.pg0.add_stream(pkts)
2090 self.pg_enable_capture(self.pg_interfaces)
2092 recvd = self.pg1.get_capture(len(pkts))
2093 for p_recvd in recvd:
2094 payload_info = self.payload_to_info(p_recvd[Raw])
2095 packet_index = payload_info.index
2096 info = self._packet_infos[packet_index]
2097 self.assertTrue(info is not None)
2098 self.assertEqual(packet_index, info.index)
2100 packed = socket.inet_aton(p_sent[IP].src)
2101 numeric = struct.unpack("!L", packed)[0]
2102 numeric = socket.htonl(numeric)
2103 a = nat_addresses[(numeric-1) % len(nat_addresses)]
2106 "Invalid packet (src IP %s translated to %s, but expected %s)"
2107 % (p_sent[IP].src, p_recvd[IP].src, a))
2110 class TestNAT44EDMW(TestNAT44ED):
2111 """ NAT44ED MW Test Case """
2112 vpp_worker_count = 4
2115 @unittest.skip('MW fix required')
2116 def test_users_dump(self):
2117 """ NAT44ED API test - nat44_user_dump """
2119 @unittest.skip('MW fix required')
2120 def test_frag_out_of_order_do_not_translate(self):
2121 """ NAT44ED don't translate fragments arriving out of order """
2123 @unittest.skip('MW fix required')
2124 def test_forwarding(self):
2125 """ NAT44ED forwarding test """
2127 @unittest.skip('MW fix required')
2128 def test_twice_nat(self):
2129 """ NAT44ED Twice NAT """
2131 @unittest.skip('MW fix required')
2132 def test_twice_nat_lb(self):
2133 """ NAT44ED Twice NAT local service load balancing """
2135 @unittest.skip('MW fix required')
2136 def test_output_feature(self):
2137 """ NAT44ED interface output feature (in2out postrouting) """
2139 @unittest.skip('MW fix required')
2140 def test_static_with_port_out2(self):
2141 """ NAT44ED 1:1 NAPT asymmetrical rule """
2143 @unittest.skip('MW fix required')
2144 def test_output_feature_and_service2(self):
2145 """ NAT44ED interface output feature and service host direct access """
2147 @unittest.skip('MW fix required')
2148 def test_static_lb(self):
2149 """ NAT44ED local service load balancing """
2151 @unittest.skip('MW fix required')
2152 def test_static_lb_2(self):
2153 """ NAT44ED local service load balancing (asymmetrical rule) """
2155 @unittest.skip('MW fix required')
2156 def test_lb_affinity(self):
2157 """ NAT44ED local service load balancing affinity """
2159 @unittest.skip('MW fix required')
2160 def test_multiple_vrf(self):
2161 """ NAT44ED Multiple VRF setup """
2163 @unittest.skip('MW fix required')
2164 def test_self_twice_nat_positive(self):
2165 """ NAT44ED Self Twice NAT (positive test) """
2167 @unittest.skip('MW fix required')
2168 def test_self_twice_nat_lb_positive(self):
2169 """ NAT44ED Self Twice NAT local service load balancing (positive test)
2172 def test_dynamic(self):
2173 """ NAT44ED dynamic translation test """
2175 tcp_port_offset = 20
2176 udp_port_offset = 20
2179 self.nat_add_address(self.nat_addr)
2180 self.nat_add_inside_interface(self.pg0)
2181 self.nat_add_outside_interface(self.pg1)
2184 tc1 = self.statistics['/nat44-ed/in2out/slowpath/tcp']
2185 uc1 = self.statistics['/nat44-ed/in2out/slowpath/udp']
2186 ic1 = self.statistics['/nat44-ed/in2out/slowpath/icmp']
2187 dc1 = self.statistics['/nat44-ed/in2out/slowpath/drops']
2189 i2o_pkts = [[] for x in range(0, self.vpp_worker_count)]
2191 for i in range(pkt_count):
2192 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2193 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2194 TCP(sport=tcp_port_offset + i, dport=20))
2195 i2o_pkts[p[TCP].sport % self.vpp_worker_count].append(p)
2197 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2198 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2199 UDP(sport=udp_port_offset + i, dport=20))
2200 i2o_pkts[p[UDP].sport % self.vpp_worker_count].append(p)
2202 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2203 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2204 ICMP(id=icmp_id_offset + i, type='echo-request'))
2205 i2o_pkts[p[ICMP].id % self.vpp_worker_count].append(p)
2207 for i in range(0, self.vpp_worker_count):
2208 if len(i2o_pkts[i]) > 0:
2209 self.pg0.add_stream(i2o_pkts[i], worker=i)
2211 self.pg_enable_capture(self.pg_interfaces)
2213 capture = self.pg1.get_capture(pkt_count * 3)
2215 if_idx = self.pg0.sw_if_index
2216 tc2 = self.statistics['/nat44-ed/in2out/slowpath/tcp']
2217 uc2 = self.statistics['/nat44-ed/in2out/slowpath/udp']
2218 ic2 = self.statistics['/nat44-ed/in2out/slowpath/icmp']
2219 dc2 = self.statistics['/nat44-ed/in2out/slowpath/drops']
2222 tc2[:, if_idx].sum() - tc1[:, if_idx].sum(), pkt_count)
2224 uc2[:, if_idx].sum() - uc1[:, if_idx].sum(), pkt_count)
2226 ic2[:, if_idx].sum() - ic1[:, if_idx].sum(), pkt_count)
2227 self.assertEqual(dc2[:, if_idx].sum() - dc1[:, if_idx].sum(), 0)
2229 self.logger.info(self.vapi.cli("show trace"))
2232 tc1 = self.statistics['/nat44-ed/out2in/fastpath/tcp']
2233 uc1 = self.statistics['/nat44-ed/out2in/fastpath/udp']
2234 ic1 = self.statistics['/nat44-ed/out2in/fastpath/icmp']
2235 dc1 = self.statistics['/nat44-ed/out2in/fastpath/drops']
2237 recvd_tcp_ports = set()
2238 recvd_udp_ports = set()
2239 recvd_icmp_ids = set()
2243 recvd_tcp_ports.add(p[TCP].sport)
2245 recvd_udp_ports.add(p[UDP].sport)
2247 recvd_icmp_ids.add(p[ICMP].id)
2249 recvd_tcp_ports = list(recvd_tcp_ports)
2250 recvd_udp_ports = list(recvd_udp_ports)
2251 recvd_icmp_ids = list(recvd_icmp_ids)
2253 o2i_pkts = [[] for x in range(0, self.vpp_worker_count)]
2254 for i in range(pkt_count):
2255 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
2256 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
2257 TCP(dport=choice(recvd_tcp_ports), sport=20))
2258 o2i_pkts[p[TCP].dport % self.vpp_worker_count].append(p)
2260 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
2261 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
2262 UDP(dport=choice(recvd_udp_ports), sport=20))
2263 o2i_pkts[p[UDP].dport % self.vpp_worker_count].append(p)
2265 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
2266 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
2267 ICMP(id=choice(recvd_icmp_ids), type='echo-reply'))
2268 o2i_pkts[p[ICMP].id % self.vpp_worker_count].append(p)
2270 for i in range(0, self.vpp_worker_count):
2271 if len(o2i_pkts[i]) > 0:
2272 self.pg1.add_stream(o2i_pkts[i], worker=i)
2274 self.pg_enable_capture(self.pg_interfaces)
2276 capture = self.pg0.get_capture(pkt_count * 3)
2277 for packet in capture:
2279 self.assert_packet_checksums_valid(packet)
2280 self.assertEqual(packet[IP].dst, self.pg0.remote_ip4)
2281 if packet.haslayer(TCP):
2282 self.assert_in_range(
2283 packet[TCP].dport, tcp_port_offset,
2284 tcp_port_offset + pkt_count, "dst TCP port")
2285 elif packet.haslayer(UDP):
2286 self.assert_in_range(
2287 packet[UDP].dport, udp_port_offset,
2288 udp_port_offset + pkt_count, "dst UDP port")
2290 self.assert_in_range(
2291 packet[ICMP].id, icmp_id_offset,
2292 icmp_id_offset + pkt_count, "ICMP id")
2294 self.logger.error(ppp("Unexpected or invalid packet "
2295 "(inside network):", packet))
2298 if_idx = self.pg1.sw_if_index
2299 tc2 = self.statistics['/nat44-ed/out2in/fastpath/tcp']
2300 uc2 = self.statistics['/nat44-ed/out2in/fastpath/udp']
2301 ic2 = self.statistics['/nat44-ed/out2in/fastpath/icmp']
2302 dc2 = self.statistics['/nat44-ed/out2in/fastpath/drops']
2305 tc2[:, if_idx].sum() - tc1[:, if_idx].sum(), pkt_count)
2307 uc2[:, if_idx].sum() - uc1[:, if_idx].sum(), pkt_count)
2309 ic2[:, if_idx].sum() - ic1[:, if_idx].sum(), pkt_count)
2310 self.assertEqual(dc2[:, if_idx].sum() - dc1[:, if_idx].sum(), 0)
2312 sc = self.statistics['/nat44-ed/total-sessions']
2313 self.assertEqual(sc[:, 0].sum(), len(recvd_tcp_ports) +
2314 len(recvd_udp_ports) + len(recvd_icmp_ids))
2316 def test_frag_in_order(self):
2317 """ NAT44ED translate fragments arriving in order """
2319 self.nat_add_address(self.nat_addr)
2320 self.nat_add_inside_interface(self.pg0)
2321 self.nat_add_outside_interface(self.pg1)
2323 self.frag_in_order(proto=IP_PROTOS.tcp, ignore_port=True)
2324 self.frag_in_order(proto=IP_PROTOS.udp, ignore_port=True)
2325 self.frag_in_order(proto=IP_PROTOS.icmp, ignore_port=True)
2327 def test_frag_in_order_do_not_translate(self):
2328 """ NAT44ED don't translate fragments arriving in order """
2330 self.nat_add_address(self.nat_addr)
2331 self.nat_add_inside_interface(self.pg0)
2332 self.nat_add_outside_interface(self.pg1)
2333 self.vapi.nat44_forwarding_enable_disable(enable=True)
2335 self.frag_in_order(proto=IP_PROTOS.tcp, dont_translate=True)
2337 def test_frag_out_of_order(self):
2338 """ NAT44ED translate fragments arriving out of order """
2340 self.nat_add_address(self.nat_addr)
2341 self.nat_add_inside_interface(self.pg0)
2342 self.nat_add_outside_interface(self.pg1)
2344 self.frag_out_of_order(proto=IP_PROTOS.tcp, ignore_port=True)
2345 self.frag_out_of_order(proto=IP_PROTOS.udp, ignore_port=True)
2346 self.frag_out_of_order(proto=IP_PROTOS.icmp, ignore_port=True)
2348 def test_frag_in_order_in_plus_out(self):
2349 """ NAT44ED in+out interface fragments in order """
2351 in_port = self.random_port()
2352 out_port = self.random_port()
2354 self.nat_add_address(self.nat_addr)
2355 self.nat_add_inside_interface(self.pg0)
2356 self.nat_add_outside_interface(self.pg0)
2357 self.nat_add_inside_interface(self.pg1)
2358 self.nat_add_outside_interface(self.pg1)
2360 # add static mappings for server
2361 self.nat_add_static_mapping(self.server_addr,
2365 proto=IP_PROTOS.tcp)
2366 self.nat_add_static_mapping(self.server_addr,
2370 proto=IP_PROTOS.udp)
2371 self.nat_add_static_mapping(self.server_addr,
2373 proto=IP_PROTOS.icmp)
2375 # run tests for each protocol
2376 self.frag_in_order_in_plus_out(self.server_addr,
2381 self.frag_in_order_in_plus_out(self.server_addr,
2386 self.frag_in_order_in_plus_out(self.server_addr,
2392 def test_frag_out_of_order_in_plus_out(self):
2393 """ NAT44ED in+out interface fragments out of order """
2395 in_port = self.random_port()
2396 out_port = self.random_port()
2398 self.nat_add_address(self.nat_addr)
2399 self.nat_add_inside_interface(self.pg0)
2400 self.nat_add_outside_interface(self.pg0)
2401 self.nat_add_inside_interface(self.pg1)
2402 self.nat_add_outside_interface(self.pg1)
2404 # add static mappings for server
2405 self.nat_add_static_mapping(self.server_addr,
2409 proto=IP_PROTOS.tcp)
2410 self.nat_add_static_mapping(self.server_addr,
2414 proto=IP_PROTOS.udp)
2415 self.nat_add_static_mapping(self.server_addr,
2417 proto=IP_PROTOS.icmp)
2419 # run tests for each protocol
2420 self.frag_out_of_order_in_plus_out(self.server_addr,
2425 self.frag_out_of_order_in_plus_out(self.server_addr,
2430 self.frag_out_of_order_in_plus_out(self.server_addr,
2436 def test_reass_hairpinning(self):
2437 """ NAT44ED fragments hairpinning """
2439 server_addr = self.pg0.remote_hosts[1].ip4
2441 host_in_port = self.random_port()
2442 server_in_port = self.random_port()
2443 server_out_port = self.random_port()
2445 self.nat_add_address(self.nat_addr)
2446 self.nat_add_inside_interface(self.pg0)
2447 self.nat_add_outside_interface(self.pg1)
2449 # add static mapping for server
2450 self.nat_add_static_mapping(server_addr, self.nat_addr,
2451 server_in_port, server_out_port,
2452 proto=IP_PROTOS.tcp)
2453 self.nat_add_static_mapping(server_addr, self.nat_addr,
2454 server_in_port, server_out_port,
2455 proto=IP_PROTOS.udp)
2456 self.nat_add_static_mapping(server_addr, self.nat_addr)
2458 self.reass_hairpinning(server_addr, server_in_port, server_out_port,
2459 host_in_port, proto=IP_PROTOS.tcp,
2461 self.reass_hairpinning(server_addr, server_in_port, server_out_port,
2462 host_in_port, proto=IP_PROTOS.udp,
2464 self.reass_hairpinning(server_addr, server_in_port, server_out_port,
2465 host_in_port, proto=IP_PROTOS.icmp,
2468 def test_session_limit_per_vrf(self):
2469 """ NAT44ED per vrf session limit """
2472 inside_vrf10 = self.pg2
2477 # 2 interfaces pg0, pg1 (vrf10, limit 1 tcp session)
2478 # non existing vrf_id makes process core dump
2479 self.vapi.nat44_set_session_limit(session_limit=limit, vrf_id=10)
2481 self.nat_add_inside_interface(inside)
2482 self.nat_add_inside_interface(inside_vrf10)
2483 self.nat_add_outside_interface(outside)
2486 self.nat_add_interface_address(outside)
2488 # BUG: causing core dump - when bad vrf_id is specified
2489 # self.nat_add_address(outside.local_ip4, vrf_id=20)
2491 stream = self.create_tcp_stream(inside_vrf10, outside, limit * 2)
2492 inside_vrf10.add_stream(stream)
2494 self.pg_enable_capture(self.pg_interfaces)
2497 capture = outside.get_capture(limit)
2499 stream = self.create_tcp_stream(inside, outside, limit * 2)
2500 inside.add_stream(stream)
2502 self.pg_enable_capture(self.pg_interfaces)
2505 capture = outside.get_capture(len(stream))
2507 def test_show_max_translations(self):
2508 """ NAT44ED API test - max translations per thread """
2509 nat_config = self.vapi.nat_show_config_2()
2510 self.assertEqual(self.max_sessions,
2511 nat_config.max_translations_per_thread)
2513 def test_lru_cleanup(self):
2514 """ NAT44ED LRU cleanup algorithm """
2516 self.nat_add_address(self.nat_addr)
2517 self.nat_add_inside_interface(self.pg0)
2518 self.nat_add_outside_interface(self.pg1)
2520 self.vapi.nat_set_timeouts(
2521 udp=1, tcp_established=7440, tcp_transitory=30, icmp=1)
2523 tcp_port_out = self.init_tcp_session(self.pg0, self.pg1, 2000, 80)
2525 for i in range(0, self.max_sessions - 1):
2526 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2527 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4, ttl=64) /
2528 UDP(sport=7000+i, dport=80))
2531 self.pg0.add_stream(pkts)
2532 self.pg_enable_capture(self.pg_interfaces)
2534 self.pg1.get_capture(len(pkts))
2535 self.sleep(1.5, "wait for timeouts")
2538 for i in range(0, self.max_sessions - 1):
2539 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2540 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4, ttl=64) /
2541 ICMP(id=8000+i, type='echo-request'))
2544 self.pg0.add_stream(pkts)
2545 self.pg_enable_capture(self.pg_interfaces)
2547 self.pg1.get_capture(len(pkts))
2549 def test_session_rst_timeout(self):
2550 """ NAT44ED session RST timeouts """
2552 self.nat_add_address(self.nat_addr)
2553 self.nat_add_inside_interface(self.pg0)
2554 self.nat_add_outside_interface(self.pg1)
2556 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
2557 tcp_transitory=5, icmp=60)
2559 self.init_tcp_session(self.pg0, self.pg1, self.tcp_port_in,
2560 self.tcp_external_port)
2561 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2562 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2563 TCP(sport=self.tcp_port_in, dport=self.tcp_external_port,
2565 self.pg0.add_stream(p)
2566 self.pg_enable_capture(self.pg_interfaces)
2568 self.pg1.get_capture(1)
2572 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2573 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2574 TCP(sport=self.tcp_port_in + 1, dport=self.tcp_external_port + 1,
2576 self.pg0.add_stream(p)
2577 self.pg_enable_capture(self.pg_interfaces)
2579 self.pg1.get_capture(1)
2581 def test_dynamic_out_of_ports(self):
2582 """ NAT44ED dynamic translation test: out of ports """
2584 self.nat_add_inside_interface(self.pg0)
2585 self.nat_add_outside_interface(self.pg1)
2587 # in2out and no NAT addresses added
2588 err_old = self.statistics.get_err_counter(
2589 '/err/nat44-ed-in2out-slowpath/out of ports')
2591 pkts = self.create_stream_in(self.pg0, self.pg1)
2592 self.pg0.add_stream(pkts)
2593 self.pg_enable_capture(self.pg_interfaces)
2595 self.pg1.get_capture(0, timeout=1)
2597 err_new = self.statistics.get_err_counter(
2598 '/err/nat44-ed-in2out-slowpath/out of ports')
2600 self.assertEqual(err_new - err_old, len(pkts))
2602 # in2out after NAT addresses added
2603 self.nat_add_address(self.nat_addr)
2605 err_old = self.statistics.get_err_counter(
2606 '/err/nat44-ed-in2out-slowpath/out of ports')
2608 pkts = self.create_stream_in(self.pg0, self.pg1)
2609 self.pg0.add_stream(pkts)
2610 self.pg_enable_capture(self.pg_interfaces)
2612 capture = self.pg1.get_capture(len(pkts))
2613 self.verify_capture_out(capture, ignore_port=True)
2615 err_new = self.statistics.get_err_counter(
2616 '/err/nat44-ed-in2out-slowpath/out of ports')
2618 self.assertEqual(err_new, err_old)
2620 def test_unknown_proto(self):
2621 """ NAT44ED translate packet with unknown protocol """
2623 self.nat_add_address(self.nat_addr)
2624 self.nat_add_inside_interface(self.pg0)
2625 self.nat_add_outside_interface(self.pg1)
2628 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2629 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2630 TCP(sport=self.tcp_port_in, dport=20))
2631 self.pg0.add_stream(p)
2632 self.pg_enable_capture(self.pg_interfaces)
2634 p = self.pg1.get_capture(1)
2636 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
2637 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2639 IP(src=self.pg2.remote_ip4, dst=self.pg2.remote_ip4) /
2640 TCP(sport=1234, dport=1234))
2641 self.pg0.add_stream(p)
2642 self.pg_enable_capture(self.pg_interfaces)
2644 p = self.pg1.get_capture(1)
2647 self.assertEqual(packet[IP].src, self.nat_addr)
2648 self.assertEqual(packet[IP].dst, self.pg1.remote_ip4)
2649 self.assertEqual(packet.haslayer(GRE), 1)
2650 self.assert_packet_checksums_valid(packet)
2652 self.logger.error(ppp("Unexpected or invalid packet:", packet))
2656 p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
2657 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
2659 IP(src=self.pg2.remote_ip4, dst=self.pg2.remote_ip4) /
2660 TCP(sport=1234, dport=1234))
2661 self.pg1.add_stream(p)
2662 self.pg_enable_capture(self.pg_interfaces)
2664 p = self.pg0.get_capture(1)
2667 self.assertEqual(packet[IP].src, self.pg1.remote_ip4)
2668 self.assertEqual(packet[IP].dst, self.pg0.remote_ip4)
2669 self.assertEqual(packet.haslayer(GRE), 1)
2670 self.assert_packet_checksums_valid(packet)
2672 self.logger.error(ppp("Unexpected or invalid packet:", packet))
2675 def test_hairpinning_unknown_proto(self):
2676 """ NAT44ED translate packet with unknown protocol - hairpinning """
2677 host = self.pg0.remote_hosts[0]
2678 server = self.pg0.remote_hosts[1]
2680 server_out_port = 8765
2681 server_nat_ip = "10.0.0.11"
2683 self.nat_add_address(self.nat_addr)
2684 self.nat_add_inside_interface(self.pg0)
2685 self.nat_add_outside_interface(self.pg1)
2687 # add static mapping for server
2688 self.nat_add_static_mapping(server.ip4, server_nat_ip)
2691 p = (Ether(src=host.mac, dst=self.pg0.local_mac) /
2692 IP(src=host.ip4, dst=server_nat_ip) /
2693 TCP(sport=host_in_port, dport=server_out_port))
2694 self.pg0.add_stream(p)
2695 self.pg_enable_capture(self.pg_interfaces)
2697 self.pg0.get_capture(1)
2699 p = (Ether(dst=self.pg0.local_mac, src=host.mac) /
2700 IP(src=host.ip4, dst=server_nat_ip) /
2702 IP(src=self.pg2.remote_ip4, dst=self.pg2.remote_ip4) /
2703 TCP(sport=1234, dport=1234))
2704 self.pg0.add_stream(p)
2705 self.pg_enable_capture(self.pg_interfaces)
2707 p = self.pg0.get_capture(1)
2710 self.assertEqual(packet[IP].src, self.nat_addr)
2711 self.assertEqual(packet[IP].dst, server.ip4)
2712 self.assertEqual(packet.haslayer(GRE), 1)
2713 self.assert_packet_checksums_valid(packet)
2715 self.logger.error(ppp("Unexpected or invalid packet:", packet))
2719 p = (Ether(dst=self.pg0.local_mac, src=server.mac) /
2720 IP(src=server.ip4, dst=self.nat_addr) /
2722 IP(src=self.pg2.remote_ip4, dst=self.pg2.remote_ip4) /
2723 TCP(sport=1234, dport=1234))
2724 self.pg0.add_stream(p)
2725 self.pg_enable_capture(self.pg_interfaces)
2727 p = self.pg0.get_capture(1)
2730 self.assertEqual(packet[IP].src, server_nat_ip)
2731 self.assertEqual(packet[IP].dst, host.ip4)
2732 self.assertEqual(packet.haslayer(GRE), 1)
2733 self.assert_packet_checksums_valid(packet)
2735 self.logger.error(ppp("Unexpected or invalid packet:", packet))
2738 def test_output_feature_and_service(self):
2739 """ NAT44ED interface output feature and services """
2740 external_addr = '1.2.3.4'
2744 self.vapi.nat44_forwarding_enable_disable(enable=1)
2745 self.nat_add_address(self.nat_addr)
2746 flags = self.config_flags.NAT_IS_ADDR_ONLY
2747 self.vapi.nat44_add_del_identity_mapping(
2748 ip_address=self.pg1.remote_ip4, sw_if_index=0xFFFFFFFF,
2749 flags=flags, is_add=1)
2750 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
2751 self.nat_add_static_mapping(self.pg0.remote_ip4, external_addr,
2752 local_port, external_port,
2753 proto=IP_PROTOS.tcp, flags=flags)
2755 self.nat_add_inside_interface(self.pg0)
2756 self.nat_add_outside_interface(self.pg0)
2757 self.vapi.nat44_interface_add_del_output_feature(
2758 sw_if_index=self.pg1.sw_if_index, is_add=1)
2760 # from client to service
2761 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
2762 IP(src=self.pg1.remote_ip4, dst=external_addr) /
2763 TCP(sport=12345, dport=external_port))
2764 self.pg1.add_stream(p)
2765 self.pg_enable_capture(self.pg_interfaces)
2767 capture = self.pg0.get_capture(1)
2772 self.assertEqual(ip.dst, self.pg0.remote_ip4)
2773 self.assertEqual(tcp.dport, local_port)
2774 self.assert_packet_checksums_valid(p)
2776 self.logger.error(ppp("Unexpected or invalid packet:", p))
2779 # from service back to client
2780 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2781 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
2782 TCP(sport=local_port, dport=12345))
2783 self.pg0.add_stream(p)
2784 self.pg_enable_capture(self.pg_interfaces)
2786 capture = self.pg1.get_capture(1)
2791 self.assertEqual(ip.src, external_addr)
2792 self.assertEqual(tcp.sport, external_port)
2793 self.assert_packet_checksums_valid(p)
2795 self.logger.error(ppp("Unexpected or invalid packet:", p))
2798 # from local network host to external network
2799 pkts = self.create_stream_in(self.pg0, self.pg1)
2800 self.pg0.add_stream(pkts)
2801 self.pg_enable_capture(self.pg_interfaces)
2803 capture = self.pg1.get_capture(len(pkts))
2804 self.verify_capture_out(capture, ignore_port=True)
2805 pkts = self.create_stream_in(self.pg0, self.pg1)
2806 self.pg0.add_stream(pkts)
2807 self.pg_enable_capture(self.pg_interfaces)
2809 capture = self.pg1.get_capture(len(pkts))
2810 self.verify_capture_out(capture, ignore_port=True)
2812 # from external network back to local network host
2813 pkts = self.create_stream_out(self.pg1)
2814 self.pg1.add_stream(pkts)
2815 self.pg_enable_capture(self.pg_interfaces)
2817 capture = self.pg0.get_capture(len(pkts))
2818 self.verify_capture_in(capture, self.pg0)
2820 def test_output_feature_and_service3(self):
2821 """ NAT44ED interface output feature and DST NAT """
2822 external_addr = '1.2.3.4'
2826 self.vapi.nat44_forwarding_enable_disable(enable=1)
2827 self.nat_add_address(self.nat_addr)
2828 flags = self.config_flags.NAT_IS_OUT2IN_ONLY
2829 self.nat_add_static_mapping(self.pg1.remote_ip4, external_addr,
2830 local_port, external_port,
2831 proto=IP_PROTOS.tcp, flags=flags)
2833 self.nat_add_inside_interface(self.pg0)
2834 self.nat_add_outside_interface(self.pg0)
2835 self.vapi.nat44_interface_add_del_output_feature(
2836 sw_if_index=self.pg1.sw_if_index, is_add=1)
2838 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
2839 IP(src=self.pg0.remote_ip4, dst=external_addr) /
2840 TCP(sport=12345, dport=external_port))
2841 self.pg0.add_stream(p)
2842 self.pg_enable_capture(self.pg_interfaces)
2844 capture = self.pg1.get_capture(1)
2849 self.assertEqual(ip.src, self.pg0.remote_ip4)
2850 self.assertEqual(tcp.sport, 12345)
2851 self.assertEqual(ip.dst, self.pg1.remote_ip4)
2852 self.assertEqual(tcp.dport, local_port)
2853 self.assert_packet_checksums_valid(p)
2855 self.logger.error(ppp("Unexpected or invalid packet:", p))
2858 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
2859 IP(src=self.pg1.remote_ip4, dst=self.pg0.remote_ip4) /
2860 TCP(sport=local_port, dport=12345))
2861 self.pg1.add_stream(p)
2862 self.pg_enable_capture(self.pg_interfaces)
2864 capture = self.pg0.get_capture(1)
2869 self.assertEqual(ip.src, external_addr)
2870 self.assertEqual(tcp.sport, external_port)
2871 self.assertEqual(ip.dst, self.pg0.remote_ip4)
2872 self.assertEqual(tcp.dport, 12345)
2873 self.assert_packet_checksums_valid(p)
2875 self.logger.error(ppp("Unexpected or invalid packet:", p))
2878 def test_self_twice_nat_lb_negative(self):
2879 """ NAT44ED Self Twice NAT local service load balancing (negative test)
2881 self.twice_nat_common(lb=True, self_twice_nat=True, same_pg=True,
2884 def test_self_twice_nat_negative(self):
2885 """ NAT44ED Self Twice NAT (negative test) """
2886 self.twice_nat_common(self_twice_nat=True)
2888 def test_static_lb_multi_clients(self):
2889 """ NAT44ED local service load balancing - multiple clients"""
2891 external_addr = self.nat_addr
2894 server1 = self.pg0.remote_hosts[0]
2895 server2 = self.pg0.remote_hosts[1]
2896 server3 = self.pg0.remote_hosts[2]
2898 locals = [{'addr': server1.ip4,
2902 {'addr': server2.ip4,
2907 flags = self.config_flags.NAT_IS_INSIDE
2908 self.vapi.nat44_interface_add_del_feature(
2909 sw_if_index=self.pg0.sw_if_index,
2910 flags=flags, is_add=1)
2911 self.vapi.nat44_interface_add_del_feature(
2912 sw_if_index=self.pg1.sw_if_index,
2915 self.nat_add_address(self.nat_addr)
2916 self.vapi.nat44_add_del_lb_static_mapping(is_add=1,
2917 external_addr=external_addr,
2918 external_port=external_port,
2919 protocol=IP_PROTOS.tcp,
2920 local_num=len(locals),
2925 clients = ip4_range(self.pg1.remote_ip4, 10, 50)
2927 for client in clients:
2928 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
2929 IP(src=client, dst=self.nat_addr) /
2930 TCP(sport=12345, dport=external_port))
2932 self.pg1.add_stream(pkts)
2933 self.pg_enable_capture(self.pg_interfaces)
2935 capture = self.pg0.get_capture(len(pkts))
2937 if p[IP].dst == server1.ip4:
2941 self.assertGreaterEqual(server1_n, server2_n)
2944 'addr': server3.ip4,
2951 self.vapi.nat44_lb_static_mapping_add_del_local(
2953 external_addr=external_addr,
2954 external_port=external_port,
2956 protocol=IP_PROTOS.tcp)
2960 clients = ip4_range(self.pg1.remote_ip4, 60, 110)
2962 for client in clients:
2963 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
2964 IP(src=client, dst=self.nat_addr) /
2965 TCP(sport=12346, dport=external_port))
2967 self.assertGreater(len(pkts), 0)
2968 self.pg1.add_stream(pkts)
2969 self.pg_enable_capture(self.pg_interfaces)
2971 capture = self.pg0.get_capture(len(pkts))
2973 if p[IP].dst == server1.ip4:
2975 elif p[IP].dst == server2.ip4:
2979 self.assertGreater(server1_n, 0)
2980 self.assertGreater(server2_n, 0)
2981 self.assertGreater(server3_n, 0)
2984 'addr': server2.ip4,
2990 # remove one back-end
2991 self.vapi.nat44_lb_static_mapping_add_del_local(
2993 external_addr=external_addr,
2994 external_port=external_port,
2996 protocol=IP_PROTOS.tcp)
3000 self.pg1.add_stream(pkts)
3001 self.pg_enable_capture(self.pg_interfaces)
3003 capture = self.pg0.get_capture(len(pkts))
3005 if p[IP].dst == server1.ip4:
3007 elif p[IP].dst == server2.ip4:
3011 self.assertGreater(server1_n, 0)
3012 self.assertEqual(server2_n, 0)
3013 self.assertGreater(server3_n, 0)
3015 def test_syslog_sess(self):
3016 """ NAT44ED Test syslog session creation and deletion """
3017 self.vapi.syslog_set_filter(
3018 self.syslog_severity.SYSLOG_API_SEVERITY_INFO)
3019 self.vapi.syslog_set_sender(self.pg3.local_ip4, self.pg3.remote_ip4)
3021 self.nat_add_address(self.nat_addr)
3022 self.nat_add_inside_interface(self.pg0)
3023 self.nat_add_outside_interface(self.pg1)
3025 p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
3026 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3027 TCP(sport=self.tcp_port_in, dport=self.tcp_external_port))
3028 self.pg0.add_stream(p)
3029 self.pg_enable_capture(self.pg_interfaces)
3031 capture = self.pg1.get_capture(1)
3032 self.tcp_port_out = capture[0][TCP].sport
3033 capture = self.pg3.get_capture(1)
3034 self.verify_syslog_sess(capture[0][Raw].load)
3036 self.pg_enable_capture(self.pg_interfaces)
3038 self.nat_add_address(self.nat_addr, is_add=0)
3039 capture = self.pg3.get_capture(1)
3040 self.verify_syslog_sess(capture[0][Raw].load, False)
3042 def test_twice_nat_interface_addr(self):
3043 """ NAT44ED Acquire twice NAT addresses from interface """
3044 flags = self.config_flags.NAT_IS_TWICE_NAT
3045 self.vapi.nat44_add_del_interface_addr(
3046 sw_if_index=self.pg11.sw_if_index,
3047 flags=flags, is_add=1)
3049 # no address in NAT pool
3050 adresses = self.vapi.nat44_address_dump()
3051 self.assertEqual(0, len(adresses))
3053 # configure interface address and check NAT address pool
3054 self.pg11.config_ip4()
3055 adresses = self.vapi.nat44_address_dump()
3056 self.assertEqual(1, len(adresses))
3057 self.assertEqual(str(adresses[0].ip_address),
3058 self.pg11.local_ip4)
3059 self.assertEqual(adresses[0].flags, flags)
3061 # remove interface address and check NAT address pool
3062 self.pg11.unconfig_ip4()
3063 adresses = self.vapi.nat44_address_dump()
3064 self.assertEqual(0, len(adresses))
3066 def test_output_feature_stateful_acl(self):
3067 """ NAT44ED output feature works with stateful ACL """
3069 self.nat_add_address(self.nat_addr)
3070 self.vapi.nat44_interface_add_del_output_feature(
3071 sw_if_index=self.pg1.sw_if_index, is_add=1)
3073 # First ensure that the NAT is working sans ACL
3075 # send packets out2in, no sessions yet so packets should drop
3076 pkts_out2in = self.create_stream_out(self.pg1)
3077 self.send_and_assert_no_replies(self.pg1, pkts_out2in)
3079 # send packets into inside intf, ensure received via outside intf
3080 pkts_in2out = self.create_stream_in(self.pg0, self.pg1)
3081 capture = self.send_and_expect(self.pg0, pkts_in2out, self.pg1,
3083 self.verify_capture_out(capture, ignore_port=True)
3085 # send out2in again, with sessions created it should work now
3086 pkts_out2in = self.create_stream_out(self.pg1)
3087 capture = self.send_and_expect(self.pg1, pkts_out2in, self.pg0,
3089 self.verify_capture_in(capture, self.pg0)
3091 # Create an ACL blocking everything
3092 out2in_deny_rule = AclRule(is_permit=0)
3093 out2in_acl = VppAcl(self, rules=[out2in_deny_rule])
3094 out2in_acl.add_vpp_config()
3096 # create an ACL to permit/reflect everything
3097 in2out_reflect_rule = AclRule(is_permit=2)
3098 in2out_acl = VppAcl(self, rules=[in2out_reflect_rule])
3099 in2out_acl.add_vpp_config()
3101 # apply as input acl on interface and confirm it blocks everything
3102 acl_if = VppAclInterface(self, sw_if_index=self.pg1.sw_if_index,
3103 n_input=1, acls=[out2in_acl])
3104 acl_if.add_vpp_config()
3105 self.send_and_assert_no_replies(self.pg1, pkts_out2in)
3108 acl_if.acls = [out2in_acl, in2out_acl]
3109 acl_if.add_vpp_config()
3110 # send in2out to generate ACL state (NAT state was created earlier)
3111 capture = self.send_and_expect(self.pg0, pkts_in2out, self.pg1,
3113 self.verify_capture_out(capture, ignore_port=True)
3115 # send out2in again. ACL state exists so it should work now.
3116 # TCP packets with the syn flag set also need the ack flag
3117 for p in pkts_out2in:
3118 if p.haslayer(TCP) and p[TCP].flags & 0x02:
3119 p[TCP].flags |= 0x10
3120 capture = self.send_and_expect(self.pg1, pkts_out2in, self.pg0,
3122 self.verify_capture_in(capture, self.pg0)
3123 self.logger.info(self.vapi.cli("show trace"))
3125 def test_tcp_close(self):
3126 """ NAT44ED Close TCP session from inside network - output feature """
3127 old_timeouts = self.vapi.nat_get_timeouts()
3129 self.vapi.nat_set_timeouts(
3130 udp=old_timeouts.udp,
3131 tcp_established=old_timeouts.tcp_established,
3132 icmp=old_timeouts.icmp,
3133 tcp_transitory=new_transitory)
3135 self.vapi.nat44_forwarding_enable_disable(enable=1)
3136 self.nat_add_address(self.pg1.local_ip4)
3137 twice_nat_addr = '10.0.1.3'
3138 service_ip = '192.168.16.150'
3139 self.nat_add_address(twice_nat_addr, twice_nat=1)
3141 flags = self.config_flags.NAT_IS_INSIDE
3142 self.vapi.nat44_interface_add_del_feature(
3143 sw_if_index=self.pg0.sw_if_index,
3145 self.vapi.nat44_interface_add_del_feature(
3146 sw_if_index=self.pg0.sw_if_index,
3147 flags=flags, is_add=1)
3148 self.vapi.nat44_interface_add_del_output_feature(
3150 sw_if_index=self.pg1.sw_if_index)
3152 flags = (self.config_flags.NAT_IS_OUT2IN_ONLY |
3153 self.config_flags.NAT_IS_TWICE_NAT)
3154 self.nat_add_static_mapping(self.pg0.remote_ip4,
3156 proto=IP_PROTOS.tcp,
3158 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3159 start_sessnum = len(sessions)
3161 # SYN packet out->in
3162 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3163 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3164 TCP(sport=33898, dport=80, flags="S"))
3165 self.pg1.add_stream(p)
3166 self.pg_enable_capture(self.pg_interfaces)
3168 capture = self.pg0.get_capture(1)
3170 tcp_port = p[TCP].sport
3172 # SYN + ACK packet in->out
3173 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3174 IP(src=self.pg0.remote_ip4, dst=twice_nat_addr) /
3175 TCP(sport=80, dport=tcp_port, flags="SA"))
3176 self.pg0.add_stream(p)
3177 self.pg_enable_capture(self.pg_interfaces)
3179 self.pg1.get_capture(1)
3181 # ACK packet out->in
3182 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3183 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3184 TCP(sport=33898, dport=80, flags="A"))
3185 self.pg1.add_stream(p)
3186 self.pg_enable_capture(self.pg_interfaces)
3188 self.pg0.get_capture(1)
3190 # FIN packet in -> out
3191 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3192 IP(src=self.pg0.remote_ip4, dst=twice_nat_addr) /
3193 TCP(sport=80, dport=tcp_port, flags="FA", seq=100, ack=300))
3194 self.pg0.add_stream(p)
3195 self.pg_enable_capture(self.pg_interfaces)
3197 self.pg1.get_capture(1)
3199 # FIN+ACK packet out -> in
3200 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3201 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3202 TCP(sport=33898, dport=80, flags="FA", seq=300, ack=101))
3203 self.pg1.add_stream(p)
3204 self.pg_enable_capture(self.pg_interfaces)
3206 self.pg0.get_capture(1)
3208 # ACK packet in -> out
3209 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3210 IP(src=self.pg0.remote_ip4, dst=twice_nat_addr) /
3211 TCP(sport=80, dport=tcp_port, flags="A", seq=101, ack=301))
3212 self.pg0.add_stream(p)
3213 self.pg_enable_capture(self.pg_interfaces)
3215 self.pg1.get_capture(1)
3217 # session now in transitory timeout
3218 # try SYN packet out->in - should be dropped
3219 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3220 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3221 TCP(sport=33898, dport=80, flags="S"))
3222 self.pg1.add_stream(p)
3223 self.pg_enable_capture(self.pg_interfaces)
3226 self.sleep(new_transitory, "wait for transitory timeout")
3227 self.pg0.assert_nothing_captured(0)
3229 # session should still exist
3230 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3231 self.assertEqual(len(sessions) - start_sessnum, 1)
3233 # send FIN+ACK packet out -> in - will cause session to be wiped
3234 # but won't create a new session
3235 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3236 IP(src=self.pg1.remote_ip4, dst=service_ip) /
3237 TCP(sport=33898, dport=80, flags="FA", seq=300, ack=101))
3238 self.pg1.add_stream(p)
3239 self.pg_enable_capture(self.pg_interfaces)
3242 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3243 self.assertEqual(len(sessions) - start_sessnum, 0)
3244 self.pg0.assert_nothing_captured(0)
3246 def test_tcp_session_close_in(self):
3247 """ NAT44ED Close TCP session from inside network """
3249 in_port = self.tcp_port_in
3251 ext_port = self.tcp_external_port
3253 self.nat_add_address(self.nat_addr)
3254 self.nat_add_inside_interface(self.pg0)
3255 self.nat_add_outside_interface(self.pg1)
3256 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
3257 in_port, out_port, proto=IP_PROTOS.tcp,
3258 flags=self.config_flags.NAT_IS_TWICE_NAT)
3260 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3261 session_n = len(sessions)
3263 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
3264 tcp_transitory=2, icmp=5)
3266 self.init_tcp_session(self.pg0, self.pg1, in_port, ext_port)
3268 # FIN packet in -> out
3269 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3270 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3271 TCP(sport=in_port, dport=ext_port,
3272 flags="FA", seq=100, ack=300))
3273 self.pg0.add_stream(p)
3274 self.pg_enable_capture(self.pg_interfaces)
3276 self.pg1.get_capture(1)
3280 # ACK packet out -> in
3281 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3282 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3283 TCP(sport=ext_port, dport=out_port,
3284 flags="A", seq=300, ack=101))
3287 # FIN packet out -> in
3288 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3289 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3290 TCP(sport=ext_port, dport=out_port,
3291 flags="FA", seq=300, ack=101))
3294 self.pg1.add_stream(pkts)
3295 self.pg_enable_capture(self.pg_interfaces)
3297 self.pg0.get_capture(2)
3299 # ACK packet in -> out
3300 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3301 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3302 TCP(sport=in_port, dport=ext_port,
3303 flags="A", seq=101, ack=301))
3304 self.pg0.add_stream(p)
3305 self.pg_enable_capture(self.pg_interfaces)
3307 self.pg1.get_capture(1)
3309 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3310 self.assertEqual(len(sessions) - session_n, 1)
3312 out2in_drops = self.get_err_counter(
3313 '/err/nat44-ed-out2in/drops due to TCP in transitory timeout')
3314 in2out_drops = self.get_err_counter(
3315 '/err/nat44-ed-in2out/drops due to TCP in transitory timeout')
3317 # extra FIN packet out -> in - this should be dropped
3318 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3319 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3320 TCP(sport=ext_port, dport=out_port,
3321 flags="FA", seq=300, ack=101))
3323 self.pg1.add_stream(p)
3324 self.pg_enable_capture(self.pg_interfaces)
3326 self.pg0.assert_nothing_captured()
3328 # extra ACK packet in -> out - this should be dropped
3329 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3330 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3331 TCP(sport=in_port, dport=ext_port,
3332 flags="A", seq=101, ack=301))
3333 self.pg0.add_stream(p)
3334 self.pg_enable_capture(self.pg_interfaces)
3336 self.pg1.assert_nothing_captured()
3338 stats = self.get_err_counter(
3339 '/err/nat44-ed-out2in/drops due to TCP in transitory timeout')
3340 self.assertEqual(stats - out2in_drops, 1)
3341 stats = self.get_err_counter(
3342 '/err/nat44-ed-in2out/drops due to TCP in transitory timeout')
3343 self.assertEqual(stats - in2out_drops, 1)
3346 # extra ACK packet in -> out - this will cause session to be wiped
3347 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3348 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3349 TCP(sport=in_port, dport=ext_port,
3350 flags="A", seq=101, ack=301))
3351 self.pg0.add_stream(p)
3352 self.pg_enable_capture(self.pg_interfaces)
3354 self.pg1.assert_nothing_captured()
3355 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3356 self.assertEqual(len(sessions) - session_n, 0)
3358 def test_tcp_session_close_out(self):
3359 """ NAT44ED Close TCP session from outside network """
3361 in_port = self.tcp_port_in
3363 ext_port = self.tcp_external_port
3365 self.nat_add_address(self.nat_addr)
3366 self.nat_add_inside_interface(self.pg0)
3367 self.nat_add_outside_interface(self.pg1)
3368 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
3369 in_port, out_port, proto=IP_PROTOS.tcp,
3370 flags=self.config_flags.NAT_IS_TWICE_NAT)
3372 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3373 session_n = len(sessions)
3375 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
3376 tcp_transitory=2, icmp=5)
3378 _ = self.init_tcp_session(self.pg0, self.pg1, in_port, ext_port)
3380 # FIN packet out -> in
3381 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3382 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3383 TCP(sport=ext_port, dport=out_port,
3384 flags="FA", seq=100, ack=300))
3385 self.pg1.add_stream(p)
3386 self.pg_enable_capture(self.pg_interfaces)
3388 self.pg0.get_capture(1)
3390 # FIN+ACK packet in -> out
3391 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3392 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3393 TCP(sport=in_port, dport=ext_port,
3394 flags="FA", seq=300, ack=101))
3396 self.pg0.add_stream(p)
3397 self.pg_enable_capture(self.pg_interfaces)
3399 self.pg1.get_capture(1)
3401 # ACK packet out -> in
3402 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3403 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3404 TCP(sport=ext_port, dport=out_port,
3405 flags="A", seq=101, ack=301))
3406 self.pg1.add_stream(p)
3407 self.pg_enable_capture(self.pg_interfaces)
3409 self.pg0.get_capture(1)
3411 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3412 self.assertEqual(len(sessions) - session_n, 1)
3414 out2in_drops = self.get_err_counter(
3415 '/err/nat44-ed-out2in/drops due to TCP in transitory timeout')
3416 in2out_drops = self.get_err_counter(
3417 '/err/nat44-ed-in2out/drops due to TCP in transitory timeout')
3419 # extra FIN packet out -> in - this should be dropped
3420 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3421 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3422 TCP(sport=ext_port, dport=out_port,
3423 flags="FA", seq=300, ack=101))
3425 self.pg1.add_stream(p)
3426 self.pg_enable_capture(self.pg_interfaces)
3428 self.pg0.assert_nothing_captured()
3430 # extra ACK packet in -> out - this should be dropped
3431 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3432 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3433 TCP(sport=in_port, dport=ext_port,
3434 flags="A", seq=101, ack=301))
3435 self.pg0.add_stream(p)
3436 self.pg_enable_capture(self.pg_interfaces)
3438 self.pg1.assert_nothing_captured()
3440 stats = self.get_err_counter(
3441 '/err/nat44-ed-out2in/drops due to TCP in transitory timeout')
3442 self.assertEqual(stats - out2in_drops, 1)
3443 stats = self.get_err_counter(
3444 '/err/nat44-ed-in2out/drops due to TCP in transitory timeout')
3445 self.assertEqual(stats - in2out_drops, 1)
3448 # extra ACK packet in -> out - this will cause session to be wiped
3449 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3450 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3451 TCP(sport=in_port, dport=ext_port,
3452 flags="A", seq=101, ack=301))
3453 self.pg0.add_stream(p)
3454 self.pg_enable_capture(self.pg_interfaces)
3456 self.pg1.assert_nothing_captured()
3457 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3458 self.assertEqual(len(sessions) - session_n, 0)
3460 def test_tcp_session_close_simultaneous(self):
3461 """ NAT44ED Close TCP session from inside network """
3463 in_port = self.tcp_port_in
3466 self.nat_add_address(self.nat_addr)
3467 self.nat_add_inside_interface(self.pg0)
3468 self.nat_add_outside_interface(self.pg1)
3469 self.nat_add_static_mapping(self.pg0.remote_ip4, self.nat_addr,
3470 in_port, ext_port, proto=IP_PROTOS.tcp,
3471 flags=self.config_flags.NAT_IS_TWICE_NAT)
3473 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3474 session_n = len(sessions)
3476 self.vapi.nat_set_timeouts(udp=300, tcp_established=7440,
3477 tcp_transitory=2, icmp=5)
3479 out_port = self.init_tcp_session(self.pg0, self.pg1, in_port, ext_port)
3481 # FIN packet in -> out
3482 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3483 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3484 TCP(sport=in_port, dport=ext_port,
3485 flags="FA", seq=100, ack=300))
3486 self.pg0.add_stream(p)
3487 self.pg_enable_capture(self.pg_interfaces)
3489 self.pg1.get_capture(1)
3491 # FIN packet out -> in
3492 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3493 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3494 TCP(sport=ext_port, dport=out_port,
3495 flags="FA", seq=300, ack=100))
3496 self.pg1.add_stream(p)
3497 self.pg_enable_capture(self.pg_interfaces)
3499 self.pg0.get_capture(1)
3501 # ACK packet in -> out
3502 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3503 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3504 TCP(sport=in_port, dport=ext_port,
3505 flags="A", seq=101, ack=301))
3506 self.pg0.add_stream(p)
3507 self.pg_enable_capture(self.pg_interfaces)
3509 self.pg1.get_capture(1)
3511 # ACK packet out -> in
3512 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3513 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3514 TCP(sport=ext_port, dport=out_port,
3515 flags="A", seq=301, ack=101))
3516 self.pg1.add_stream(p)
3517 self.pg_enable_capture(self.pg_interfaces)
3519 self.pg0.get_capture(1)
3521 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3522 self.assertEqual(len(sessions) - session_n, 1)
3524 out2in_drops = self.get_err_counter(
3525 '/err/nat44-ed-out2in/drops due to TCP in transitory timeout')
3526 in2out_drops = self.get_err_counter(
3527 '/err/nat44-ed-in2out/drops due to TCP in transitory timeout')
3529 # extra FIN packet out -> in - this should be dropped
3530 p = (Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac) /
3531 IP(src=self.pg1.remote_ip4, dst=self.nat_addr) /
3532 TCP(sport=ext_port, dport=out_port,
3533 flags="FA", seq=300, ack=101))
3535 self.pg1.add_stream(p)
3536 self.pg_enable_capture(self.pg_interfaces)
3538 self.pg0.assert_nothing_captured()
3540 # extra ACK packet in -> out - this should be dropped
3541 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3542 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3543 TCP(sport=in_port, dport=ext_port,
3544 flags="A", seq=101, ack=301))
3545 self.pg0.add_stream(p)
3546 self.pg_enable_capture(self.pg_interfaces)
3548 self.pg1.assert_nothing_captured()
3550 stats = self.get_err_counter(
3551 '/err/nat44-ed-out2in/drops due to TCP in transitory timeout')
3552 self.assertEqual(stats - out2in_drops, 1)
3553 stats = self.get_err_counter(
3554 '/err/nat44-ed-in2out/drops due to TCP in transitory timeout')
3555 self.assertEqual(stats - in2out_drops, 1)
3558 # extra ACK packet in -> out - this will cause session to be wiped
3559 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
3560 IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_ip4) /
3561 TCP(sport=in_port, dport=ext_port,
3562 flags="A", seq=101, ack=301))
3563 self.pg0.add_stream(p)
3564 self.pg_enable_capture(self.pg_interfaces)
3566 self.pg1.assert_nothing_captured()
3567 sessions = self.vapi.nat44_user_session_dump(self.pg0.remote_ip4, 0)
3568 self.assertEqual(len(sessions) - session_n, 0)
3570 def test_dynamic_vrf(self):
3571 """ NAT44ED dynamic translation test: different VRF"""
3576 self.nat_add_address(self.nat_addr, vrf_id=vrf_id_in)
3579 self.configure_ip4_interface(self.pg7, table_id=vrf_id_in)
3580 self.configure_ip4_interface(self.pg8, table_id=vrf_id_out)
3582 self.nat_add_inside_interface(self.pg7)
3583 self.nat_add_outside_interface(self.pg8)
3585 # just basic stuff nothing special
3586 pkts = self.create_stream_in(self.pg7, self.pg8)
3587 self.pg7.add_stream(pkts)
3588 self.pg_enable_capture(self.pg_interfaces)
3590 capture = self.pg8.get_capture(len(pkts))
3591 self.verify_capture_out(capture, ignore_port=True)
3593 pkts = self.create_stream_out(self.pg8)
3594 self.pg8.add_stream(pkts)
3595 self.pg_enable_capture(self.pg_interfaces)
3597 capture = self.pg7.get_capture(len(pkts))
3598 self.verify_capture_in(capture, self.pg7)
3604 self.vapi.ip_table_add_del(is_add=0,
3605 table={'table_id': vrf_id_in})
3606 self.vapi.ip_table_add_del(is_add=0,
3607 table={'table_id': vrf_id_out})
3609 def test_dynamic_output_feature_vrf(self):
3610 """ NAT44ED dynamic translation test: output-feature, VRF"""
3612 # other then default (0)
3615 self.nat_add_address(self.nat_addr)
3616 self.vapi.nat44_interface_add_del_output_feature(
3617 sw_if_index=self.pg8.sw_if_index, is_add=1)
3620 self.configure_ip4_interface(self.pg7, table_id=new_vrf_id)
3621 self.configure_ip4_interface(self.pg8, table_id=new_vrf_id)
3624 tcpn = self.statistics['/nat44-ed/in2out/slowpath/tcp']
3625 udpn = self.statistics['/nat44-ed/in2out/slowpath/udp']
3626 icmpn = self.statistics['/nat44-ed/in2out/slowpath/icmp']
3627 drops = self.statistics['/nat44-ed/in2out/slowpath/drops']
3629 pkts = self.create_stream_in(self.pg7, self.pg8)
3630 self.pg7.add_stream(pkts)
3631 self.pg_enable_capture(self.pg_interfaces)
3633 capture = self.pg8.get_capture(len(pkts))
3634 self.verify_capture_out(capture, ignore_port=True)
3636 if_idx = self.pg7.sw_if_index
3637 cnt = self.statistics['/nat44-ed/in2out/slowpath/tcp']
3638 self.assertEqual(cnt[:, if_idx].sum() - tcpn[:, if_idx].sum(), 2)
3639 cnt = self.statistics['/nat44-ed/in2out/slowpath/udp']
3640 self.assertEqual(cnt[:, if_idx].sum() - udpn[:, if_idx].sum(), 1)
3641 cnt = self.statistics['/nat44-ed/in2out/slowpath/icmp']
3642 self.assertEqual(cnt[:, if_idx].sum() - icmpn[:, if_idx].sum(), 1)
3643 cnt = self.statistics['/nat44-ed/in2out/slowpath/drops']
3644 self.assertEqual(cnt[:, if_idx].sum() - drops[:, if_idx].sum(), 0)
3647 tcpn = self.statistics['/nat44-ed/out2in/fastpath/tcp']
3648 udpn = self.statistics['/nat44-ed/out2in/fastpath/udp']
3649 icmpn = self.statistics['/nat44-ed/out2in/fastpath/icmp']
3650 drops = self.statistics['/nat44-ed/out2in/fastpath/drops']
3652 pkts = self.create_stream_out(self.pg8)
3653 self.pg8.add_stream(pkts)
3654 self.pg_enable_capture(self.pg_interfaces)
3656 capture = self.pg7.get_capture(len(pkts))
3657 self.verify_capture_in(capture, self.pg7)
3659 if_idx = self.pg8.sw_if_index
3660 cnt = self.statistics['/nat44-ed/out2in/fastpath/tcp']
3661 self.assertEqual(cnt[:, if_idx].sum() - tcpn[:, if_idx].sum(), 2)
3662 cnt = self.statistics['/nat44-ed/out2in/fastpath/udp']
3663 self.assertEqual(cnt[:, if_idx].sum() - udpn[:, if_idx].sum(), 1)
3664 cnt = self.statistics['/nat44-ed/out2in/fastpath/icmp']
3665 self.assertEqual(cnt[:, if_idx].sum() - icmpn[:, if_idx].sum(), 1)
3666 cnt = self.statistics['/nat44-ed/out2in/fastpath/drops']
3667 self.assertEqual(cnt[:, if_idx].sum() - drops[:, if_idx].sum(), 0)
3669 sessions = self.statistics['/nat44-ed/total-sessions']
3670 self.assertEqual(sessions[:, 0].sum(), 3)
3676 self.vapi.ip_table_add_del(is_add=0,
3677 table={'table_id': new_vrf_id})
3679 def test_next_src_nat(self):
3680 """ NAT44ED On way back forward packet to nat44-in2out node. """
3682 twice_nat_addr = '10.0.1.3'
3685 post_twice_nat_port = 0
3687 self.vapi.nat44_forwarding_enable_disable(enable=1)
3688 self.nat_add_address(twice_nat_addr, twice_nat=1)
3689 flags = (self.config_flags.NAT_IS_OUT2IN_ONLY |
3690 self.config_flags.NAT_IS_SELF_TWICE_NAT)
3691 self.nat_add_static_mapping(self.pg6.remote_ip4, self.pg1.remote_ip4,
3692 local_port, external_port,
3693 proto=IP_PROTOS.tcp, vrf_id=1,
3695 self.vapi.nat44_interface_add_del_feature(
3696 sw_if_index=self.pg6.sw_if_index,
3699 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
3700 IP(src=self.pg6.remote_ip4, dst=self.pg1.remote_ip4) /
3701 TCP(sport=12345, dport=external_port))
3702 self.pg6.add_stream(p)
3703 self.pg_enable_capture(self.pg_interfaces)
3705 capture = self.pg6.get_capture(1)
3710 self.assertEqual(ip.src, twice_nat_addr)
3711 self.assertNotEqual(tcp.sport, 12345)
3712 post_twice_nat_port = tcp.sport
3713 self.assertEqual(ip.dst, self.pg6.remote_ip4)
3714 self.assertEqual(tcp.dport, local_port)
3715 self.assert_packet_checksums_valid(p)
3717 self.logger.error(ppp("Unexpected or invalid packet:", p))
3720 p = (Ether(src=self.pg6.remote_mac, dst=self.pg6.local_mac) /
3721 IP(src=self.pg6.remote_ip4, dst=twice_nat_addr) /
3722 TCP(sport=local_port, dport=post_twice_nat_port))
3723 self.pg6.add_stream(p)
3724 self.pg_enable_capture(self.pg_interfaces)
3726 capture = self.pg6.get_capture(1)
3731 self.assertEqual(ip.src, self.pg1.remote_ip4)
3732 self.assertEqual(tcp.sport, external_port)
3733 self.assertEqual(ip.dst, self.pg6.remote_ip4)
3734 self.assertEqual(tcp.dport, 12345)
3735 self.assert_packet_checksums_valid(p)
3737 self.logger.error(ppp("Unexpected or invalid packet:", p))
3740 def test_one_armed_nat44_static(self):
3741 """ NAT44ED One armed NAT and 1:1 NAPT asymmetrical rule """
3743 remote_host = self.pg4.remote_hosts[0]
3744 local_host = self.pg4.remote_hosts[1]
3749 self.vapi.nat44_forwarding_enable_disable(enable=1)
3750 self.nat_add_address(self.nat_addr, twice_nat=1)
3751 flags = (self.config_flags.NAT_IS_OUT2IN_ONLY |
3752 self.config_flags.NAT_IS_TWICE_NAT)
3753 self.nat_add_static_mapping(local_host.ip4, self.nat_addr,
3754 local_port, external_port,
3755 proto=IP_PROTOS.tcp, flags=flags)
3756 flags = self.config_flags.NAT_IS_INSIDE
3757 self.vapi.nat44_interface_add_del_feature(
3758 sw_if_index=self.pg4.sw_if_index,
3760 self.vapi.nat44_interface_add_del_feature(
3761 sw_if_index=self.pg4.sw_if_index,
3762 flags=flags, is_add=1)
3764 # from client to service
3765 p = (Ether(src=self.pg4.remote_mac, dst=self.pg4.local_mac) /
3766 IP(src=remote_host.ip4, dst=self.nat_addr) /
3767 TCP(sport=12345, dport=external_port))
3768 self.pg4.add_stream(p)
3769 self.pg_enable_capture(self.pg_interfaces)
3771 capture = self.pg4.get_capture(1)
3776 self.assertEqual(ip.dst, local_host.ip4)
3777 self.assertEqual(ip.src, self.nat_addr)
3778 self.assertEqual(tcp.dport, local_port)
3779 self.assertNotEqual(tcp.sport, 12345)
3780 eh_port_in = tcp.sport
3781 self.assert_packet_checksums_valid(p)
3783 self.logger.error(ppp("Unexpected or invalid packet:", p))
3786 # from service back to client
3787 p = (Ether(src=self.pg4.remote_mac, dst=self.pg4.local_mac) /
3788 IP(src=local_host.ip4, dst=self.nat_addr) /
3789 TCP(sport=local_port, dport=eh_port_in))
3790 self.pg4.add_stream(p)
3791 self.pg_enable_capture(self.pg_interfaces)
3793 capture = self.pg4.get_capture(1)
3798 self.assertEqual(ip.src, self.nat_addr)
3799 self.assertEqual(ip.dst, remote_host.ip4)
3800 self.assertEqual(tcp.sport, external_port)
3801 self.assertEqual(tcp.dport, 12345)
3802 self.assert_packet_checksums_valid(p)
3804 self.logger.error(ppp("Unexpected or invalid packet:", p))
3808 if __name__ == '__main__':
3809 unittest.main(testRunner=VppTestRunner)